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_base.h"
33 #include "los_spinlock.h"
34 #include "los_task_pri.h"
35 #include "los_printf_pri.h"
36 #include "los_atomic.h"
37 #include "los_exc.h"
38
39 #ifdef LOSCFG_KERNEL_SMP_LOCKDEP
40
41 #define PRINT_BUF_SIZE 256
42
43 #define LOCKDEP_GET_NAME(lockDep, index) (((SPIN_LOCK_S *)((lockDep)->heldLocks[(index)].lockPtr))->name)
44 #define LOCKDEP_GET_ADDR(lockDep, index) ((lockDep)->heldLocks[(index)].lockAddr)
45
46 STATIC Atomic g_lockdepAvailable = 1;
47
48 /* atomic insurance for lockdep check */
OsLockDepRequire(UINT32 * intSave)49 STATIC INLINE VOID OsLockDepRequire(UINT32 *intSave)
50 {
51 *intSave = LOS_IntLock();
52 while (LOS_AtomicCmpXchg32bits(&g_lockdepAvailable, 0, 1)) {
53 /* busy waiting */
54 }
55 }
56
OsLockDepRelease(UINT32 intSave)57 STATIC INLINE VOID OsLockDepRelease(UINT32 intSave)
58 {
59 LOS_AtomicSet(&g_lockdepAvailable, 1);
60 LOS_IntRestore(intSave);
61 }
62
OsLockDepGetCycles(VOID)63 STATIC INLINE UINT64 OsLockDepGetCycles(VOID)
64 {
65 UINT32 high, low;
66
67 LOS_GetCpuCycle(&high, &low);
68 /* combine cycleHi and cycleLo into 8 bytes cycles */
69 return (((UINT64)high << 32) + low); // 32 bits for lower half of UINT64
70 }
71
OsLockDepErrorStringGet(enum LockDepErrType type)72 STATIC INLINE CHAR *OsLockDepErrorStringGet(enum LockDepErrType type)
73 {
74 CHAR *errorString = NULL;
75
76 switch (type) {
77 case LOCKDEP_ERR_DOUBLE_LOCK:
78 errorString = "double lock";
79 break;
80 case LOCKDEP_ERR_DEAD_LOCK:
81 errorString = "dead lock";
82 break;
83 case LOCKDEP_ERR_UNLOCK_WITOUT_LOCK:
84 errorString = "unlock without lock";
85 break;
86 case LOCKDEP_ERR_OVERFLOW:
87 errorString = "lockdep overflow";
88 break;
89 default:
90 errorString = "unknown error code";
91 break;
92 }
93
94 return errorString;
95 }
96
OsLockDepPanic(enum LockDepErrType errType)97 WEAK VOID OsLockDepPanic(enum LockDepErrType errType)
98 {
99 /* halt here */
100 (VOID)errType;
101 (VOID)LOS_IntLock();
102 OsBackTrace();
103 while (1) {}
104 }
105
OsLockDepPrint(const CHAR * fmt,va_list ap)106 STATIC VOID OsLockDepPrint(const CHAR *fmt, va_list ap)
107 {
108 UINT32 len;
109 CHAR buf[PRINT_BUF_SIZE] = {0};
110
111 len = vsnprintf_s(buf, PRINT_BUF_SIZE, PRINT_BUF_SIZE - 1, fmt, ap);
112 if ((len == -1) && (*buf == '\0')) {
113 /* parameter is illegal or some features in fmt dont support */
114 UartPuts("OsLockDepPrint is error\n", strlen("OsLockDepPrint is error\n"), 0);
115 return;
116 }
117 *(buf + len) = '\0';
118
119 UartPuts(buf, len, 0);
120 }
121
OsPrintLockDepInfo(const CHAR * fmt,...)122 STATIC VOID OsPrintLockDepInfo(const CHAR *fmt, ...)
123 {
124 va_list ap;
125 va_start(ap, fmt);
126 OsLockDepPrint(fmt, ap);
127 va_end(ap);
128 }
129
OsLockDepDumpLock(const LosTaskCB * task,const SPIN_LOCK_S * lock,const VOID * requestAddr,enum LockDepErrType errType)130 STATIC VOID OsLockDepDumpLock(const LosTaskCB *task, const SPIN_LOCK_S *lock,
131 const VOID *requestAddr, enum LockDepErrType errType)
132 {
133 INT32 i;
134 const LockDep *lockDep = &task->lockDep;
135 const LosTaskCB *temp = task;
136
137 OsPrintLockDepInfo("lockdep check failed\n");
138 OsPrintLockDepInfo("error type : %s\n", OsLockDepErrorStringGet(errType));
139 OsPrintLockDepInfo("request addr : 0x%x\n", requestAddr);
140
141 while (1) {
142 OsPrintLockDepInfo("task name : %s\n", temp->taskName);
143 OsPrintLockDepInfo("task id : %u\n", temp->taskID);
144 OsPrintLockDepInfo("cpu num : %u\n", temp->currCpu);
145 OsPrintLockDepInfo("start dumping lockdep information\n");
146 for (i = 0; i < lockDep->lockDepth; i++) {
147 if (lockDep->heldLocks[i].lockPtr == lock) {
148 OsPrintLockDepInfo("[%d] %s <-- addr:0x%x\n", i, LOCKDEP_GET_NAME(lockDep, i),
149 LOCKDEP_GET_ADDR(lockDep, i));
150 } else {
151 OsPrintLockDepInfo("[%d] %s \n", i, LOCKDEP_GET_NAME(lockDep, i));
152 }
153 }
154 OsPrintLockDepInfo("[%d] %s <-- now\n", i, lock->name);
155
156 if (errType == LOCKDEP_ERR_DEAD_LOCK) {
157 temp = lock->owner;
158 lock = temp->lockDep.waitLock;
159 lockDep = &temp->lockDep;
160 }
161
162 if (temp == task) {
163 break;
164 }
165 }
166 }
167
OsLockDepCheckDependency(const LosTaskCB * current,LosTaskCB * lockOwner)168 STATIC BOOL OsLockDepCheckDependency(const LosTaskCB *current, LosTaskCB *lockOwner)
169 {
170 BOOL checkResult = TRUE;
171 SPIN_LOCK_S *lockTemp = NULL;
172
173 do {
174 if (current == lockOwner) {
175 checkResult = FALSE;
176 return checkResult;
177 }
178 if (lockOwner->lockDep.waitLock != NULL) {
179 lockTemp = lockOwner->lockDep.waitLock;
180 lockOwner = lockTemp->owner;
181 } else {
182 break;
183 }
184 } while (lockOwner != SPINLOCK_OWNER_INIT);
185
186 return checkResult;
187 }
188
OsLockDepCheckIn(SPIN_LOCK_S * lock)189 VOID OsLockDepCheckIn(SPIN_LOCK_S *lock)
190 {
191 UINT32 intSave;
192 enum LockDepErrType checkResult = LOCKDEP_SUCCESS;
193 VOID *requestAddr = (VOID *)__builtin_return_address(1);
194 LosTaskCB *current = OsCurrTaskGet();
195 LockDep *lockDep = ¤t->lockDep;
196 LosTaskCB *lockOwner = NULL;
197
198 OsLockDepRequire(&intSave);
199
200 if (lockDep->lockDepth >= (INT32)MAX_LOCK_DEPTH) {
201 checkResult = LOCKDEP_ERR_OVERFLOW;
202 goto OUT;
203 }
204
205 lockOwner = lock->owner;
206 /* not owned by any tasks yet, not doing following checks */
207 if (lockOwner == SPINLOCK_OWNER_INIT) {
208 goto OUT;
209 }
210
211 if (current == lockOwner) {
212 checkResult = LOCKDEP_ERR_DOUBLE_LOCK;
213 goto OUT;
214 }
215
216 if (OsLockDepCheckDependency(current, lockOwner) != TRUE) {
217 checkResult = LOCKDEP_ERR_DEAD_LOCK;
218 goto OUT;
219 }
220
221 OUT:
222 if (checkResult == LOCKDEP_SUCCESS) {
223 /*
224 * though the check may succeed, the waitLock still need to be set.
225 * because the OsLockDepCheckIn and OsLockDepRecord is not strictly multi-core
226 * sequential, there would be more than two tasks can pass the checking, but
227 * only one task can successfully obtain the lock.
228 */
229 lockDep->waitLock = lock;
230 lockDep->heldLocks[lockDep->lockDepth].lockAddr = requestAddr;
231 lockDep->heldLocks[lockDep->lockDepth].waitTime = OsLockDepGetCycles(); /* start time */
232 OsLockDepRelease(intSave);
233 return;
234 }
235 OsLockDepDumpLock(current, lock, requestAddr, checkResult);
236 OsLockDepRelease(intSave);
237 OsLockDepPanic(checkResult);
238 }
239
OsLockDepRecord(SPIN_LOCK_S * lock)240 VOID OsLockDepRecord(SPIN_LOCK_S *lock)
241 {
242 UINT32 intSave;
243 UINT64 cycles;
244 LosTaskCB *current = OsCurrTaskGet();
245 LockDep *lockDep = ¤t->lockDep;
246 HeldLocks *heldlock = &lockDep->heldLocks[lockDep->lockDepth];
247
248 OsLockDepRequire(&intSave);
249
250 /*
251 * OsLockDepCheckIn records start time t1, after the lock is obtained, we
252 * get the time t2, (t2 - t1) is the time of waiting for the lock
253 */
254 cycles = OsLockDepGetCycles();
255 heldlock->waitTime = cycles - heldlock->waitTime;
256 heldlock->holdTime = cycles;
257
258 /* record lock info */
259 lock->owner = current;
260 lock->cpuid = ArchCurrCpuid();
261
262 /* record lockdep info */
263 heldlock->lockPtr = lock;
264 lockDep->lockDepth++;
265 lockDep->waitLock = NULL;
266
267 OsLockDepRelease(intSave);
268 }
269
OsLockDepCheckOut(SPIN_LOCK_S * lock)270 VOID OsLockDepCheckOut(SPIN_LOCK_S *lock)
271 {
272 UINT32 intSave;
273 INT32 depth;
274 enum LockDepErrType checkResult;
275 VOID *requestAddr = (VOID *)__builtin_return_address(1);
276 LosTaskCB *current = OsCurrTaskGet();
277 LosTaskCB *owner = NULL;
278 LockDep *lockDep = NULL;
279 HeldLocks *heldlocks = NULL;
280
281 OsLockDepRequire(&intSave);
282
283 owner = lock->owner;
284 if (owner == SPINLOCK_OWNER_INIT) {
285 checkResult = LOCKDEP_ERR_UNLOCK_WITOUT_LOCK;
286 OsLockDepDumpLock(current, lock, requestAddr, checkResult);
287 OsLockDepRelease(intSave);
288 OsLockDepPanic(checkResult);
289 return;
290 }
291
292 lockDep = &owner->lockDep;
293 heldlocks = &lockDep->heldLocks[0];
294 depth = lockDep->lockDepth;
295
296 /* find the lock position */
297 while (--depth >= 0) {
298 if (heldlocks[depth].lockPtr == lock) {
299 break;
300 }
301 }
302
303 LOS_ASSERT(depth >= 0);
304
305 /* record lock holding time */
306 heldlocks[depth].holdTime = OsLockDepGetCycles() - heldlocks[depth].holdTime;
307
308 /* if unlock an older lock, needs move heldLock records */
309 while (depth < lockDep->lockDepth - 1) {
310 lockDep->heldLocks[depth] = lockDep->heldLocks[depth + 1];
311 depth++;
312 }
313
314 lockDep->lockDepth--;
315 lock->cpuid = (UINT32)(-1);
316 lock->owner = SPINLOCK_OWNER_INIT;
317
318 OsLockDepRelease(intSave);
319 }
320
OsLockdepClearSpinlocks(VOID)321 VOID OsLockdepClearSpinlocks(VOID)
322 {
323 LosTaskCB *task = OsCurrTaskGet();
324 LockDep *lockDep = &task->lockDep;
325 SPIN_LOCK_S *lock = NULL;
326
327 /*
328 * Unlock spinlocks that running task has held.
329 * lockDepth will decrease after each spinlock is unlockded.
330 */
331 while (lockDep->lockDepth) {
332 lock = lockDep->heldLocks[lockDep->lockDepth - 1].lockPtr;
333 LOS_SpinUnlock(lock);
334 }
335 }
336
337 #else /* LOSCFG_KERNEL_SMP_LOCKDEP */
338
OsLockDepCheckIn(SPIN_LOCK_S * lock)339 VOID OsLockDepCheckIn(SPIN_LOCK_S *lock)
340 {
341 (VOID)lock;
342
343 return;
344 }
345
OsLockDepRecord(SPIN_LOCK_S * lock)346 VOID OsLockDepRecord(SPIN_LOCK_S *lock)
347 {
348 (VOID)lock;
349
350 return;
351 }
352
OsLockDepCheckOut(SPIN_LOCK_S * lock)353 VOID OsLockDepCheckOut(SPIN_LOCK_S *lock)
354 {
355 (VOID)lock;
356
357 return;
358 }
359
OsLockdepClearSpinlocks(VOID)360 VOID OsLockdepClearSpinlocks(VOID)
361 {
362 return;
363 }
364
365 #endif
366
367