From 9be065fb89c14b8aabab33907510ed33fe68b01e Mon Sep 17 00:00:00 2001 From: christos Date: Thu, 26 Jan 2017 04:11:56 +0000 Subject: [PATCH] For LOCKDEBUG: Always provide the location of the caller of the lock as __func__, __LINE__. --- sys/kern/kern_lock.c | 6 +- sys/kern/kern_mutex.c | 16 ++--- sys/kern/kern_rwlock.c | 17 +++--- sys/kern/subr_lockdebug.c | 123 +++++++++++++++++++++----------------- sys/sys/lockdebug.h | 47 ++++++++------- 5 files changed, 114 insertions(+), 95 deletions(-) diff --git a/sys/kern/kern_lock.c b/sys/kern/kern_lock.c index c7fbe80e8e4b..f22a4c7132a5 100644 --- a/sys/kern/kern_lock.c +++ b/sys/kern/kern_lock.c @@ -1,4 +1,4 @@ -/* $NetBSD: kern_lock.c,v 1.157 2015/04/11 15:24:25 skrll Exp $ */ +/* $NetBSD: kern_lock.c,v 1.158 2017/01/26 04:11:56 christos Exp $ */ /*- * Copyright (c) 2002, 2006, 2007, 2008, 2009 The NetBSD Foundation, Inc. @@ -31,7 +31,7 @@ */ #include -__KERNEL_RCSID(0, "$NetBSD: kern_lock.c,v 1.157 2015/04/11 15:24:25 skrll Exp $"); +__KERNEL_RCSID(0, "$NetBSD: kern_lock.c,v 1.158 2017/01/26 04:11:56 christos Exp $"); #include #include @@ -101,7 +101,7 @@ assert_sleepable(void) */ #define _KERNEL_LOCK_ABORT(msg) \ - LOCKDEBUG_ABORT(kernel_lock, &_kernel_lock_ops, __func__, msg) + LOCKDEBUG_ABORT(__func__, __LINE__, kernel_lock, &_kernel_lock_ops, msg) #ifdef LOCKDEBUG #define _KERNEL_LOCK_ASSERT(cond) \ diff --git a/sys/kern/kern_mutex.c b/sys/kern/kern_mutex.c index 1263ee8ca5b5..a3f048a661f5 100644 --- a/sys/kern/kern_mutex.c +++ b/sys/kern/kern_mutex.c @@ -1,4 +1,4 @@ -/* $NetBSD: kern_mutex.c,v 1.63 2016/07/07 06:55:43 msaitoh Exp $ */ +/* $NetBSD: kern_mutex.c,v 1.64 2017/01/26 04:11:56 christos Exp $ */ /*- * Copyright (c) 2002, 2006, 2007, 2008 The NetBSD Foundation, Inc. @@ -40,7 +40,7 @@ #define __MUTEX_PRIVATE #include -__KERNEL_RCSID(0, "$NetBSD: kern_mutex.c,v 1.63 2016/07/07 06:55:43 msaitoh Exp $"); +__KERNEL_RCSID(0, "$NetBSD: kern_mutex.c,v 1.64 2017/01/26 04:11:56 christos Exp $"); #include #include @@ -82,7 +82,7 @@ __KERNEL_RCSID(0, "$NetBSD: kern_mutex.c,v 1.63 2016/07/07 06:55:43 msaitoh Exp LOCKDEBUG_UNLOCKED(MUTEX_DEBUG_P(mtx), (mtx), \ (uintptr_t)__builtin_return_address(0), 0) #define MUTEX_ABORT(mtx, msg) \ - mutex_abort(mtx, __func__, msg) + mutex_abort(__func__, __LINE__, mtx, msg) #if defined(LOCKDEBUG) @@ -261,8 +261,8 @@ __strong_alias(mutex_spin_enter,mutex_vector_enter); __strong_alias(mutex_spin_exit,mutex_vector_exit); #endif -static void mutex_abort(kmutex_t *, const char *, const char *); -static void mutex_dump(volatile void *); +static void mutex_abort(const char *, size_t, kmutex_t *, const char *); +static void mutex_dump(volatile void *); lockops_t mutex_spin_lockops = { "Mutex", @@ -307,11 +307,11 @@ mutex_dump(volatile void *cookie) * we ask the compiler to not inline it. */ void __noinline -mutex_abort(kmutex_t *mtx, const char *func, const char *msg) +mutex_abort(const char *func, size_t line, kmutex_t *mtx, const char *msg) { - LOCKDEBUG_ABORT(mtx, (MUTEX_SPIN_P(mtx) ? - &mutex_spin_lockops : &mutex_adaptive_lockops), func, msg); + LOCKDEBUG_ABORT(func, line, mtx, (MUTEX_SPIN_P(mtx) ? + &mutex_spin_lockops : &mutex_adaptive_lockops), msg); } /* diff --git a/sys/kern/kern_rwlock.c b/sys/kern/kern_rwlock.c index ffafcda6009c..0a195aac9554 100644 --- a/sys/kern/kern_rwlock.c +++ b/sys/kern/kern_rwlock.c @@ -1,4 +1,4 @@ -/* $NetBSD: kern_rwlock.c,v 1.45 2014/11/28 08:28:17 uebayasi Exp $ */ +/* $NetBSD: kern_rwlock.c,v 1.46 2017/01/26 04:11:56 christos Exp $ */ /*- * Copyright (c) 2002, 2006, 2007, 2008, 2009 The NetBSD Foundation, Inc. @@ -38,7 +38,7 @@ */ #include -__KERNEL_RCSID(0, "$NetBSD: kern_rwlock.c,v 1.45 2014/11/28 08:28:17 uebayasi Exp $"); +__KERNEL_RCSID(0, "$NetBSD: kern_rwlock.c,v 1.46 2017/01/26 04:11:56 christos Exp $"); #define __RWLOCK_PRIVATE @@ -73,7 +73,7 @@ __KERNEL_RCSID(0, "$NetBSD: kern_rwlock.c,v 1.45 2014/11/28 08:28:17 uebayasi Ex #define RW_DASSERT(rw, cond) \ do { \ if (!(cond)) \ - rw_abort(rw, __func__, "assertion failed: " #cond); \ + rw_abort(__func__, __LINE__, rw, "assertion failed: " #cond);\ } while (/* CONSTCOND */ 0); #else /* LOCKDEBUG */ @@ -94,7 +94,7 @@ do { \ #define RW_ASSERT(rw, cond) \ do { \ if (!(cond)) \ - rw_abort(rw, __func__, "assertion failed: " #cond); \ + rw_abort(__func__, __LINE__, rw, "assertion failed: " #cond);\ } while (/* CONSTCOND */ 0) #else @@ -111,7 +111,7 @@ do { \ #define RW_INHERITDEBUG(n, o) /* nothing */ #endif /* defined(LOCKDEBUG) */ -static void rw_abort(krwlock_t *, const char *, const char *); +static void rw_abort(const char *, size_t, krwlock_t *, const char *); static void rw_dump(volatile void *); static lwp_t *rw_owner(wchan_t); @@ -183,13 +183,13 @@ rw_dump(volatile void *cookie) * we ask the compiler to not inline it. */ static void __noinline -rw_abort(krwlock_t *rw, const char *func, const char *msg) +rw_abort(const char *func, size_t line, krwlock_t *rw, const char *msg) { if (panicstr != NULL) return; - LOCKDEBUG_ABORT(rw, &rwlock_lockops, func, msg); + LOCKDEBUG_ABORT(func, line, rw, &rwlock_lockops, msg); } /* @@ -338,7 +338,8 @@ rw_vector_enter(krwlock_t *rw, const krw_t op) return; } if (__predict_false(RW_OWNER(rw) == curthread)) { - rw_abort(rw, __func__, "locking against myself"); + rw_abort(__func__, __LINE__, rw, + "locking against myself"); } /* * If the lock owner is running on another CPU, and diff --git a/sys/kern/subr_lockdebug.c b/sys/kern/subr_lockdebug.c index c82b8d2ac3ef..38f8ff35cabd 100644 --- a/sys/kern/subr_lockdebug.c +++ b/sys/kern/subr_lockdebug.c @@ -1,4 +1,4 @@ -/* $NetBSD: subr_lockdebug.c,v 1.54 2015/09/29 01:44:57 ozaki-r Exp $ */ +/* $NetBSD: subr_lockdebug.c,v 1.55 2017/01/26 04:11:56 christos Exp $ */ /*- * Copyright (c) 2006, 2007, 2008 The NetBSD Foundation, Inc. @@ -34,7 +34,7 @@ */ #include -__KERNEL_RCSID(0, "$NetBSD: subr_lockdebug.c,v 1.54 2015/09/29 01:44:57 ozaki-r Exp $"); +__KERNEL_RCSID(0, "$NetBSD: subr_lockdebug.c,v 1.55 2017/01/26 04:11:56 christos Exp $"); #ifdef _KERNEL_OPT #include "opt_ddb.h" @@ -99,8 +99,8 @@ int ld_recurse; bool ld_nomore; lockdebug_t ld_prime[LD_BATCH]; -static void lockdebug_abort1(lockdebug_t *, int, const char *, - const char *, bool); +static void lockdebug_abort1(const char *, size_t, lockdebug_t *, int, + const char *, bool); static int lockdebug_more(int); static void lockdebug_init(void); static void lockdebug_dump(lockdebug_t *, void (*)(const char *, ...) @@ -190,14 +190,15 @@ lockdebug_unlock_cpus(void) * Find a lockdebug structure by a pointer to a lock and return it locked. */ static inline lockdebug_t * -lockdebug_lookup(volatile void *lock, uintptr_t where) +lockdebug_lookup(const char *func, size_t line, volatile void *lock, + uintptr_t where) { lockdebug_t *ld; ld = lockdebug_lookup1(lock); if (ld == NULL) { - panic("lockdebug_lookup: uninitialized lock " - "(lock=%p, from=%08"PRIxPTR")", lock, where); + panic("%s,%zu: uninitialized lock (lock=%p, from=%08" + PRIxPTR ")", func, line, lock, where); } return ld; } @@ -238,7 +239,8 @@ lockdebug_init(void) * structure. */ bool -lockdebug_alloc(volatile void *lock, lockops_t *lo, uintptr_t initaddr) +lockdebug_alloc(const char *func, size_t line, volatile void *lock, + lockops_t *lo, uintptr_t initaddr) { struct cpu_info *ci; lockdebug_t *ld; @@ -253,7 +255,8 @@ lockdebug_alloc(volatile void *lock, lockops_t *lo, uintptr_t initaddr) __cpu_simple_lock(&ld_mod_lk); if ((ld = lockdebug_lookup1(lock)) != NULL) { __cpu_simple_unlock(&ld_mod_lk); - lockdebug_abort1(ld, s, __func__, "already initialized", true); + lockdebug_abort1(func, line, ld, s, "already initialized", + true); return false; } @@ -288,7 +291,7 @@ lockdebug_alloc(volatile void *lock, lockops_t *lo, uintptr_t initaddr) ci->ci_lkdebug_recurse--; if (ld->ld_lock != NULL) { - panic("lockdebug_alloc: corrupt table ld %p", ld); + panic("%s,%zu: corrupt table ld %p", func, line, ld); } /* Initialise the structure. */ @@ -314,7 +317,7 @@ lockdebug_alloc(volatile void *lock, lockops_t *lo, uintptr_t initaddr) * A lock is being destroyed, so release debugging resources. */ void -lockdebug_free(volatile void *lock) +lockdebug_free(const char *func, size_t line, volatile void *lock) { lockdebug_t *ld; int s; @@ -324,16 +327,18 @@ lockdebug_free(volatile void *lock) s = splhigh(); __cpu_simple_lock(&ld_mod_lk); - ld = lockdebug_lookup(lock, (uintptr_t) __builtin_return_address(0)); + ld = lockdebug_lookup(func, line, lock, + (uintptr_t) __builtin_return_address(0)); if (ld == NULL) { __cpu_simple_unlock(&ld_mod_lk); - panic("lockdebug_free: destroying uninitialized object %p" - "(ld_lock=%p)", lock, ld->ld_lock); + panic("%s,%zu: destroying uninitialized object %p" + "(ld_lock=%p)", func, line, lock, ld->ld_lock); return; } if ((ld->ld_flags & LD_LOCKED) != 0 || ld->ld_shares != 0) { __cpu_simple_unlock(&ld_mod_lk); - lockdebug_abort1(ld, s, __func__, "is locked or in use", true); + lockdebug_abort1(func, line, ld, s, "is locked or in use", + true); return; } lockdebug_lock_cpus(); @@ -415,7 +420,8 @@ lockdebug_more(int s) * Process the preamble to a lock acquire. */ void -lockdebug_wantlock(volatile void *lock, uintptr_t where, int shared) +lockdebug_wantlock(const char *func, size_t line, + volatile void *lock, uintptr_t where, int shared) { struct lwp *l = curlwp; lockdebug_t *ld; @@ -429,7 +435,7 @@ lockdebug_wantlock(volatile void *lock, uintptr_t where, int shared) return; s = splhigh(); - if ((ld = lockdebug_lookup(lock, where)) == NULL) { + if ((ld = lockdebug_lookup(func, line, lock, where)) == NULL) { splx(s); return; } @@ -442,7 +448,7 @@ lockdebug_wantlock(volatile void *lock, uintptr_t where, int shared) } if (cpu_intr_p()) { if ((ld->ld_flags & LD_SLEEPER) != 0) { - lockdebug_abort1(ld, s, __func__, + lockdebug_abort1(func, line, ld, s, "acquiring sleep lock from interrupt context", true); return; @@ -453,7 +459,7 @@ lockdebug_wantlock(volatile void *lock, uintptr_t where, int shared) else ld->ld_exwant++; if (recurse) { - lockdebug_abort1(ld, s, __func__, "locking against myself", + lockdebug_abort1(func, line, ld, s, "locking against myself", true); return; } @@ -467,8 +473,8 @@ lockdebug_wantlock(volatile void *lock, uintptr_t where, int shared) * Process a lock acquire operation. */ void -lockdebug_locked(volatile void *lock, void *cvlock, uintptr_t where, - int shared) +lockdebug_locked(const char *func, size_t line, + volatile void *lock, void *cvlock, uintptr_t where, int shared) { struct lwp *l = curlwp; lockdebug_t *ld; @@ -478,7 +484,7 @@ lockdebug_locked(volatile void *lock, void *cvlock, uintptr_t where, return; s = splhigh(); - if ((ld = lockdebug_lookup(lock, where)) == NULL) { + if ((ld = lockdebug_lookup(func, line, lock, where)) == NULL) { splx(s); return; } @@ -489,8 +495,9 @@ lockdebug_locked(volatile void *lock, void *cvlock, uintptr_t where, } else if (ld->ld_shares++ == 0) { ld->ld_locked = (uintptr_t)cvlock; } else if (cvlock != (void *)ld->ld_locked) { - lockdebug_abort1(ld, s, __func__, "multiple locks used" - " with condition variable", true); + lockdebug_abort1(func, line, ld, s, + "multiple locks used with condition variable", + true); return; } } else if (shared) { @@ -500,7 +507,7 @@ lockdebug_locked(volatile void *lock, void *cvlock, uintptr_t where, ld->ld_shwant--; } else { if ((ld->ld_flags & LD_LOCKED) != 0) { - lockdebug_abort1(ld, s, __func__, "already locked", + lockdebug_abort1(func, line, ld, s, "already locked", true); return; } @@ -526,7 +533,8 @@ lockdebug_locked(volatile void *lock, void *cvlock, uintptr_t where, * Process a lock release operation. */ void -lockdebug_unlocked(volatile void *lock, uintptr_t where, int shared) +lockdebug_unlocked(const char *func, size_t line, + volatile void *lock, uintptr_t where, int shared) { struct lwp *l = curlwp; lockdebug_t *ld; @@ -536,7 +544,7 @@ lockdebug_unlocked(volatile void *lock, uintptr_t where, int shared) return; s = splhigh(); - if ((ld = lockdebug_lookup(lock, where)) == NULL) { + if ((ld = lockdebug_lookup(func, line, lock, where)) == NULL) { splx(s); return; } @@ -548,12 +556,12 @@ lockdebug_unlocked(volatile void *lock, uintptr_t where, int shared) } } else if (shared) { if (l->l_shlocks == 0) { - lockdebug_abort1(ld, s, __func__, + lockdebug_abort1(func, line, ld, s, "no shared locks held by LWP", true); return; } if (ld->ld_shares == 0) { - lockdebug_abort1(ld, s, __func__, + lockdebug_abort1(func, line, ld, s, "no shared holds on this lock", true); return; } @@ -567,20 +575,20 @@ lockdebug_unlocked(volatile void *lock, uintptr_t where, int shared) ld->ld_cpu = (uint16_t)-1; } else { if ((ld->ld_flags & LD_LOCKED) == 0) { - lockdebug_abort1(ld, s, __func__, "not locked", true); + lockdebug_abort1(func, line, ld, s, "not locked", true); return; } if ((ld->ld_flags & LD_SLEEPER) != 0) { if (ld->ld_lwp != curlwp) { - lockdebug_abort1(ld, s, __func__, + lockdebug_abort1(func, line, ld, s, "not held by current LWP", true); return; } TAILQ_REMOVE(&l->l_ld_locks, ld, ld_chain); } else { if (ld->ld_cpu != (uint16_t)cpu_index(curcpu())) { - lockdebug_abort1(ld, s, __func__, + lockdebug_abort1(func, line, ld, s, "not held by current CPU", true); return; } @@ -601,7 +609,8 @@ lockdebug_unlocked(volatile void *lock, uintptr_t where, int shared) * Process a wakeup on a condition variable. */ void -lockdebug_wakeup(volatile void *lock, uintptr_t where) +lockdebug_wakeup(const char *func, size_t line, volatile void *lock, + uintptr_t where) { lockdebug_t *ld; int s; @@ -611,7 +620,7 @@ lockdebug_wakeup(volatile void *lock, uintptr_t where) s = splhigh(); /* Find the CV... */ - if ((ld = lockdebug_lookup(lock, where)) == NULL) { + if ((ld = lockdebug_lookup(func, line, lock, where)) == NULL) { splx(s); return; } @@ -620,7 +629,7 @@ lockdebug_wakeup(volatile void *lock, uintptr_t where) * same interlock. */ if (ld->ld_shares != 0 && !mutex_owned((kmutex_t *)ld->ld_locked)) { - lockdebug_abort1(ld, s, __func__, "interlocking mutex not " + lockdebug_abort1(func, line, ld, s, "interlocking mutex not " "held during wakeup", true); return; } @@ -635,7 +644,8 @@ lockdebug_wakeup(volatile void *lock, uintptr_t where) * if we hold sleep locks. */ void -lockdebug_barrier(volatile void *spinlock, int slplocks) +lockdebug_barrier(const char *func, size_t line, volatile void *spinlock, + int slplocks) { struct lwp *l = curlwp; lockdebug_t *ld; @@ -651,7 +661,7 @@ lockdebug_barrier(volatile void *spinlock, int slplocks) continue; } __cpu_simple_lock(&ld->ld_spinlock); - lockdebug_abort1(ld, s, __func__, + lockdebug_abort1(func, line, ld, s, "spin lock held", true); return; } @@ -662,7 +672,7 @@ lockdebug_barrier(volatile void *spinlock, int slplocks) } if ((ld = TAILQ_FIRST(&l->l_ld_locks)) != NULL) { __cpu_simple_lock(&ld->ld_spinlock); - lockdebug_abort1(ld, s, __func__, "sleep lock held", true); + lockdebug_abort1(func, line, ld, s, "sleep lock held", true); return; } splx(s); @@ -673,7 +683,8 @@ lockdebug_barrier(volatile void *spinlock, int slplocks) if (ld->ld_lwp == l) lockdebug_dump(ld, printf); } - panic("%s: holding %d shared locks", __func__, l->l_shlocks); + panic("%s,%zu: holding %d shared locks", func, line, + l->l_shlocks); } } @@ -684,7 +695,7 @@ lockdebug_barrier(volatile void *spinlock, int slplocks) * being freed. */ void -lockdebug_mem_check(const char *func, void *base, size_t sz) +lockdebug_mem_check(const char *func, size_t line, void *base, size_t sz) { lockdebug_t *ld; struct cpu_info *ci; @@ -701,15 +712,15 @@ lockdebug_mem_check(const char *func, void *base, size_t sz) const uintptr_t lock = (uintptr_t)ld->ld_lock; if ((uintptr_t)base > lock) - panic("%s: corrupt tree ld=%p, base=%p, sz=%zu", - __func__, ld, base, sz); + panic("%s,%zu: corrupt tree ld=%p, base=%p, sz=%zu", + func, line, ld, base, sz); if (lock >= (uintptr_t)base + sz) ld = NULL; } __cpu_simple_unlock(&ci->ci_data.cpu_ld_lock); if (ld != NULL) { __cpu_simple_lock(&ld->ld_spinlock); - lockdebug_abort1(ld, s, func, + lockdebug_abort1(func, line, ld, s, "allocation contains active lock", !cold); return; } @@ -767,7 +778,7 @@ lockdebug_dump(lockdebug_t *ld, void (*pr)(const char *, ...) * An error has been trapped - dump lock info and panic. */ static void -lockdebug_abort1(lockdebug_t *ld, int s, const char *func, +lockdebug_abort1(const char *func, size_t line, lockdebug_t *ld, int s, const char *msg, bool dopanic) { @@ -782,15 +793,15 @@ lockdebug_abort1(lockdebug_t *ld, int s, const char *func, return; } - printf_nolog("%s error: %s: %s\n\n", ld->ld_lockops->lo_name, - func, msg); + printf_nolog("%s error: %s,%zu: %s\n\n", ld->ld_lockops->lo_name, + func, line, msg); lockdebug_dump(ld, printf_nolog); __cpu_simple_unlock(&ld->ld_spinlock); splx(s); printf_nolog("\n"); if (dopanic) - panic("LOCKDEBUG: %s error: %s: %s", ld->ld_lockops->lo_name, - func, msg); + panic("LOCKDEBUG: %s error: %s,%zu: %s", + ld->ld_lockops->lo_name, func, line, msg); } #endif /* LOCKDEBUG */ @@ -832,17 +843,17 @@ lockdebug_lock_print(void *addr, void (*pr)(const char *, ...)) * An error has been trapped - dump lock info and call panic(). */ void -lockdebug_abort(volatile void *lock, lockops_t *ops, const char *func, - const char *msg) +lockdebug_abort(const char *func, size_t line, volatile void *lock, + lockops_t *ops, const char *msg) { #ifdef LOCKDEBUG lockdebug_t *ld; int s; s = splhigh(); - if ((ld = lockdebug_lookup(lock, + if ((ld = lockdebug_lookup(func, line, lock, (uintptr_t) __builtin_return_address(0))) != NULL) { - lockdebug_abort1(ld, s, func, msg, true); + lockdebug_abort1(func, line, ld, s, msg, true); return; } splx(s); @@ -854,16 +865,16 @@ lockdebug_abort(volatile void *lock, lockops_t *ops, const char *func, * is going down in flames. */ if (atomic_inc_uint_nv(&ld_panic) == 1) { - printf_nolog("%s error: %s: %s\n\n" + printf_nolog("%s error: %s,%zu: %s\n\n" "lock address : %#018lx\n" "current cpu : %18d\n" "current lwp : %#018lx\n", - ops->lo_name, func, msg, (long)lock, + ops->lo_name, func, line, msg, (long)lock, (int)cpu_index(curcpu()), (long)curlwp); (*ops->lo_dump)(lock); printf_nolog("\n"); } - panic("lock error: %s: %s: %s: lock %p cpu %d lwp %p", - ops->lo_name, func, msg, lock, cpu_index(curcpu()), curlwp); + panic("lock error: %s: %s,%zu: %s: lock %p cpu %d lwp %p", + ops->lo_name, func, line, msg, lock, cpu_index(curcpu()), curlwp); } diff --git a/sys/sys/lockdebug.h b/sys/sys/lockdebug.h index 3f88b6a5703e..39d351d2c1eb 100644 --- a/sys/sys/lockdebug.h +++ b/sys/sys/lockdebug.h @@ -1,4 +1,4 @@ -/* $NetBSD: lockdebug.h,v 1.14 2013/04/27 08:12:34 mlelstv Exp $ */ +/* $NetBSD: lockdebug.h,v 1.15 2017/01/26 04:11:56 christos Exp $ */ /*- * Copyright (c) 2006, 2007, 2008 The NetBSD Foundation, Inc. @@ -50,39 +50,46 @@ typedef struct lockops { void (*lo_dump)(volatile void *); } lockops_t; -#define LOCKDEBUG_ABORT(l, o, f, m) lockdebug_abort(l, o, f, m) +#define LOCKDEBUG_ABORT(f, ln, l, o, m) \ + lockdebug_abort(f, ln, l, o, m) -void lockdebug_abort(volatile void *, lockops_t *, - const char *, const char *); +void lockdebug_abort(const char *, size_t, volatile void *, lockops_t *, + const char *); void lockdebug_lock_print(void *, void (*)(const char *, ...) __printflike(1, 2)); #ifdef LOCKDEBUG -bool lockdebug_alloc(volatile void *, lockops_t *, uintptr_t); -void lockdebug_free(volatile void *); -void lockdebug_wantlock(volatile void *, uintptr_t, int); -void lockdebug_locked(volatile void *, void *, uintptr_t, int); -void lockdebug_unlocked(volatile void *, uintptr_t, int); -void lockdebug_barrier(volatile void *, int); -void lockdebug_mem_check(const char *, void *, size_t); -void lockdebug_wakeup(volatile void *, uintptr_t); +bool lockdebug_alloc(const char *, size_t, volatile void *, lockops_t *, + uintptr_t); +void lockdebug_free(const char *, size_t, volatile void *); +void lockdebug_wantlock(const char *, size_t, volatile void *, uintptr_t, + int); +void lockdebug_locked(const char *, size_t, volatile void *, void *, + uintptr_t, int); +void lockdebug_unlocked(const char *, size_t, volatile void *, + uintptr_t, int); +void lockdebug_barrier(const char *, size_t, volatile void *, int); +void lockdebug_mem_check(const char *, size_t, void *, size_t); +void lockdebug_wakeup(const char *, size_t, volatile void *, uintptr_t); -#define LOCKDEBUG_ALLOC(lock, ops, addr) lockdebug_alloc(lock, ops, addr) +#define LOCKDEBUG_ALLOC(lock, ops, addr) \ + lockdebug_alloc(__func__, __LINE__, lock, ops, addr) #define LOCKDEBUG_FREE(dodebug, lock) \ - if (dodebug) lockdebug_free(lock) + if (dodebug) lockdebug_free(__func__, __LINE__, lock) #define LOCKDEBUG_WANTLOCK(dodebug, lock, where, s) \ - if (dodebug) lockdebug_wantlock(lock, where, s) + if (dodebug) lockdebug_wantlock(__func__, __LINE__, lock, where, s) #define LOCKDEBUG_LOCKED(dodebug, lock, al, where, s) \ - if (dodebug) lockdebug_locked(lock, al, where, s) + if (dodebug) lockdebug_locked(__func__, __LINE__, lock, al, where, s) #define LOCKDEBUG_UNLOCKED(dodebug, lock, where, s) \ - if (dodebug) lockdebug_unlocked(lock, where, s) -#define LOCKDEBUG_BARRIER(lock, slp) lockdebug_barrier(lock, slp) + if (dodebug) lockdebug_unlocked(__func__, __LINE__, lock, where, s) +#define LOCKDEBUG_BARRIER(lock, slp) \ + lockdebug_barrier(__func__, __LINE__, lock, slp) #define LOCKDEBUG_MEM_CHECK(base, sz) \ - lockdebug_mem_check(__func__, base, sz) + lockdebug_mem_check(__func__, __LINE__, base, sz) #define LOCKDEBUG_WAKEUP(dodebug, lock, where) \ - if (dodebug) lockdebug_wakeup(lock, where) + if (dodebug) lockdebug_wakeup(__func__, __LINE__, lock, where) #else /* LOCKDEBUG */