1 /*
2 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
3 * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without modification,
6 * are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice, this list of
9 * conditions and the following disclaimer.
10 *
11 * 2. Redistributions in binary form must reproduce the above copyright notice, this list
12 * of conditions and the following disclaimer in the documentation and/or other materials
13 * provided with the distribution.
14 *
15 * 3. Neither the name of the copyright holder nor the names of its contributors may be used
16 * to endorse or promote products derived from this software without specific prior written
17 * permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
21 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
26 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
27 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
28 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
29 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #include "los_trace_pri.h"
33 #include "trace_pipeline.h"
34
35 #define BITS_NUM_FOR_TASK_ID 16
36
37 LITE_OS_SEC_BSS STATIC TraceOfflineHeaderInfo g_traceRecoder;
38 LITE_OS_SEC_BSS STATIC UINT32 g_tidMask[LOSCFG_BASE_CORE_TSK_LIMIT] = {0};
39
OsTraceGetMaskTid(UINT32 tid)40 UINT32 OsTraceGetMaskTid(UINT32 tid)
41 {
42 return tid | ((tid < LOSCFG_BASE_CORE_TSK_LIMIT) ? g_tidMask[tid] << BITS_NUM_FOR_TASK_ID : 0); /* tid < 65535 */
43 }
44
OsTraceBufInit(UINT32 size)45 UINT32 OsTraceBufInit(UINT32 size)
46 {
47 UINT32 headSize;
48 VOID *buf = NULL;
49 headSize = sizeof(OfflineHead) + sizeof(ObjData) * LOSCFG_TRACE_OBJ_MAX_NUM;
50 if (size <= headSize) {
51 TRACE_ERROR("trace buf size not enough than 0x%x\n", headSize);
52 return LOS_ERRNO_TRACE_BUF_TOO_SMALL;
53 }
54
55
56 buf = LOS_MemAlloc(m_aucSysMem0, size);
57 if (buf == NULL) {
58 return LOS_ERRNO_TRACE_NO_MEMORY;
59 }
60
61 (VOID)memset_s(buf, size, 0, size);
62 g_traceRecoder.head = (OfflineHead *)buf;
63 g_traceRecoder.head->baseInfo.bigLittleEndian = TRACE_BIGLITTLE_WORD;
64 g_traceRecoder.head->baseInfo.version = TRACE_VERSION(TRACE_MODE_OFFLINE);
65 g_traceRecoder.head->baseInfo.clockFreq = OS_SYS_CLOCK;
66 g_traceRecoder.head->objSize = sizeof(ObjData);
67 g_traceRecoder.head->frameSize = sizeof(TraceEventFrame);
68 g_traceRecoder.head->objOffset = sizeof(OfflineHead);
69 g_traceRecoder.head->frameOffset = headSize;
70 g_traceRecoder.head->totalLen = size;
71
72 g_traceRecoder.ctrl.curIndex = 0;
73 g_traceRecoder.ctrl.curObjIndex = 0;
74 g_traceRecoder.ctrl.maxObjCount = LOSCFG_TRACE_OBJ_MAX_NUM;
75 g_traceRecoder.ctrl.maxRecordCount = (size - headSize) / sizeof(TraceEventFrame);
76 g_traceRecoder.ctrl.objBuf = (ObjData *)((UINTPTR)buf + g_traceRecoder.head->objOffset);
77 g_traceRecoder.ctrl.frameBuf = (TraceEventFrame *)((UINTPTR)buf + g_traceRecoder.head->frameOffset);
78
79 return LOS_OK;
80 }
81
OsTraceObjAdd(UINT32 eventType,UINT32 taskId)82 VOID OsTraceObjAdd(UINT32 eventType, UINT32 taskId)
83 {
84 UINT32 intSave;
85 UINT32 index;
86 ObjData *obj = NULL;
87
88 TRACE_LOCK(intSave);
89 /* add obj begin */
90 index = g_traceRecoder.ctrl.curObjIndex;
91 if (index >= LOSCFG_TRACE_OBJ_MAX_NUM) { /* do nothing when config LOSCFG_TRACE_OBJ_MAX_NUM = 0 */
92 TRACE_UNLOCK(intSave);
93 return;
94 }
95 obj = &g_traceRecoder.ctrl.objBuf[index];
96
97 if (taskId < LOSCFG_BASE_CORE_TSK_LIMIT) {
98 g_tidMask[taskId]++;
99 }
100
101 OsTraceSetObj(obj, OS_TCB_FROM_TID(taskId));
102
103 g_traceRecoder.ctrl.curObjIndex++;
104 if (g_traceRecoder.ctrl.curObjIndex >= g_traceRecoder.ctrl.maxObjCount) {
105 g_traceRecoder.ctrl.curObjIndex = 0; /* turn around */
106 }
107 /* add obj end */
108 TRACE_UNLOCK(intSave);
109 }
110
OsTraceWriteOrSendEvent(const TraceEventFrame * frame)111 VOID OsTraceWriteOrSendEvent(const TraceEventFrame *frame)
112 {
113 UINT16 index;
114 UINT32 intSave;
115
116 TRACE_LOCK(intSave);
117 index = g_traceRecoder.ctrl.curIndex;
118 (VOID)memcpy_s(&g_traceRecoder.ctrl.frameBuf[index], sizeof(TraceEventFrame), frame, sizeof(TraceEventFrame));
119
120 g_traceRecoder.ctrl.curIndex++;
121 if (g_traceRecoder.ctrl.curIndex >= g_traceRecoder.ctrl.maxRecordCount) {
122 g_traceRecoder.ctrl.curIndex = 0;
123 }
124 TRACE_UNLOCK(intSave);
125 }
126
OsTraceReset(VOID)127 VOID OsTraceReset(VOID)
128 {
129 UINT32 intSave;
130 UINT32 bufLen;
131
132 TRACE_LOCK(intSave);
133 bufLen = sizeof(TraceEventFrame) * g_traceRecoder.ctrl.maxRecordCount;
134 (VOID)memset_s(g_traceRecoder.ctrl.frameBuf, bufLen, 0, bufLen);
135 g_traceRecoder.ctrl.curIndex = 0;
136 TRACE_UNLOCK(intSave);
137 }
138
OsTraceInfoObj(VOID)139 STATIC VOID OsTraceInfoObj(VOID)
140 {
141 UINT32 i;
142 ObjData *obj = &g_traceRecoder.ctrl.objBuf[0];
143
144 if (g_traceRecoder.ctrl.maxObjCount > 0) {
145 PRINTK("CurObjIndex = %u\n", g_traceRecoder.ctrl.curObjIndex);
146 PRINTK("Index TaskID TaskPrio TaskName \n");
147 for (i = 0; i < g_traceRecoder.ctrl.maxObjCount; i++, obj++) {
148 PRINTK("%-7u 0x%-6x %-10u %s\n", i, obj->id, obj->prio, obj->name);
149 }
150 PRINTK("\n");
151 }
152 }
153
OsTraceInfoEventTitle(VOID)154 STATIC VOID OsTraceInfoEventTitle(VOID)
155 {
156 PRINTK("CurEvtIndex = %u\n", g_traceRecoder.ctrl.curIndex);
157
158 PRINTK("Index Time(cycles) EventType CurPid CurTask Identity ");
159 #ifdef LOSCFG_TRACE_FRAME_CORE_MSG
160 PRINTK("cpuid hwiActive taskLockCnt ");
161 #endif
162 #ifdef LOSCFG_TRACE_FRAME_EVENT_COUNT
163 PRINTK("eventCount ");
164 #endif
165 #ifdef LOS_TRACE_FRAME_LR
166 UINT32 i;
167 PRINTK("backtrace ");
168 for (i = 0; i < LOS_TRACE_LR_RECORD; i++) {
169 PRINTK(" ");
170 }
171 #endif
172 if (LOSCFG_TRACE_FRAME_MAX_PARAMS > 0) {
173 PRINTK("params ");
174 }
175 PRINTK("\n");
176 }
177
OsTraceInfoEventData(VOID)178 STATIC VOID OsTraceInfoEventData(VOID)
179 {
180 UINT32 i, j;
181 TraceEventFrame *frame = &g_traceRecoder.ctrl.frameBuf[0];
182
183 for (i = 0; i < g_traceRecoder.ctrl.maxRecordCount; i++, frame++) {
184 PRINTK("%-7u 0x%-15llx 0x%-12x 0x%-7x 0x%-7x 0x%-11x ", i, frame->curTime, frame->eventType,
185 frame->curPid, frame->curTask, frame->identity);
186 #ifdef LOSCFG_TRACE_FRAME_CORE_MSG
187 UINT32 taskLockCnt = frame->core.taskLockCnt;
188 #ifdef LOSCFG_KERNEL_SMP
189 /*
190 * For smp systems, TRACE_LOCK will request taskLock, and this counter
191 * will increase by 1 in that case.
192 */
193 taskLockCnt -= 1;
194 #endif
195 PRINTK("%-11u %-11u %-11u", frame->core.cpuid, frame->core.hwiActive, taskLockCnt);
196 #endif
197 #ifdef LOSCFG_TRACE_FRAME_EVENT_COUNT
198 PRINTK("%-11u", frame->eventCount);
199 #endif
200 #ifdef LOS_TRACE_FRAME_LR
201 for (j = 0; j < LOS_TRACE_LR_RECORD; j++) {
202 PRINTK("0x%-11x", frame->linkReg[j]);
203 }
204 #endif
205 for (j = 0; j < LOSCFG_TRACE_FRAME_MAX_PARAMS; j++) {
206 PRINTK("0x%-11x", frame->params[j]);
207 }
208 PRINTK("\n");
209 }
210 }
211
OsTraceInfoDisplay(VOID)212 STATIC VOID OsTraceInfoDisplay(VOID)
213 {
214 OfflineHead *head = g_traceRecoder.head;
215
216 PRINTK("*******TraceInfo begin*******\n");
217 PRINTK("clockFreq = %u\n", head->baseInfo.clockFreq);
218
219 OsTraceInfoObj();
220
221 OsTraceInfoEventTitle();
222 OsTraceInfoEventData();
223
224 PRINTK("*******TraceInfo end*******\n");
225 }
226
227 #ifdef LOSCFG_TRACE_CLIENT_INTERACT
OsTraceSendInfo(VOID)228 STATIC VOID OsTraceSendInfo(VOID)
229 {
230 UINT32 i;
231 ObjData *obj = NULL;
232 TraceEventFrame *frame = NULL;
233
234 OsTraceDataSend(HEAD, sizeof(OfflineHead), (UINT8 *)g_traceRecoder.head);
235
236 obj = &g_traceRecoder.ctrl.objBuf[0];
237 for (i = 0; i < g_traceRecoder.ctrl.maxObjCount; i++) {
238 OsTraceDataSend(OBJ, sizeof(ObjData), (UINT8 *)(obj + i));
239 }
240
241 frame = &g_traceRecoder.ctrl.frameBuf[0];
242 for (i = 0; i < g_traceRecoder.ctrl.maxRecordCount; i++) {
243 OsTraceDataSend(EVENT, sizeof(TraceEventFrame), (UINT8 *)(frame + i));
244 }
245 }
246 #endif
247
OsTraceRecordDump(BOOL toClient)248 VOID OsTraceRecordDump(BOOL toClient)
249 {
250 if (!toClient) {
251 OsTraceInfoDisplay();
252 return;
253 }
254
255 #ifdef LOSCFG_TRACE_CLIENT_INTERACT
256 OsTraceSendInfo();
257 #endif
258 }
259
OsTraceRecordGet(VOID)260 OfflineHead *OsTraceRecordGet(VOID)
261 {
262 return g_traceRecoder.head;
263 }
264