 @@ -1,14 +1,14 @@
-/*	$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.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe and Andrew Doran.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -30,27 +30,27 @@
  */
 /*
  * Kernel mutex implementation, modeled after those found in Solaris,
  * a description of which can be found in:
+ *
  *	Solaris Internals: Core Kernel Architecture, Jim Mauro and
  *	    Richard McDougall.
  */
 #define	__MUTEX_PRIVATE
 #include <sys/cdefs.h>
-__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 <sys/param.h>
 #include <sys/atomic.h>
 #include <sys/proc.h>
 #include <sys/mutex.h>
 #include <sys/sched.h>
 #include <sys/sleepq.h>
 #include <sys/systm.h>
 #include <sys/lockdebug.h>
 #include <sys/kernel.h>
 #include <sys/intr.h>
 #include <sys/lock.h>
 #include <sys/types.h>
 @@ -72,27 +72,27 @@ __KERNEL_RCSID(0, "$NetBSD: kern_mutex.c
  * Debugging support.
  */
 #define	MUTEX_WANTLOCK(mtx)					\
     LOCKDEBUG_WANTLOCK(MUTEX_DEBUG_P(mtx), (mtx),		\
         (uintptr_t)__builtin_return_address(0), 0)
 #define	MUTEX_LOCKED(mtx)					\
     LOCKDEBUG_LOCKED(MUTEX_DEBUG_P(mtx), (mtx), NULL,		\
         (uintptr_t)__builtin_return_address(0), 0)
 #define	MUTEX_UNLOCKED(mtx)					\
     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)
 #define	MUTEX_DASSERT(mtx, cond)				\
 do {								\
 	if (!(cond))						\
 		MUTEX_ABORT(mtx, "assertion failed: " #cond);	\
 } while (/* CONSTCOND */ 0);
 #else	/* LOCKDEBUG */
 #define	MUTEX_DASSERT(mtx, cond)	/* nothing */
 @@ -251,28 +251,28 @@ MUTEX_RELEASE(kmutex_t *mtx)
 #undef	__HAVE_SPIN_MUTEX_STUBS
 #endif
 #ifndef __HAVE_MUTEX_STUBS
 __strong_alias(mutex_enter,mutex_vector_enter);
 __strong_alias(mutex_exit,mutex_vector_exit);
 #endif
 #ifndef __HAVE_SPIN_MUTEX_STUBS
 __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_abort(const char *, size_t, kmutex_t *, const char *);
-static void		mutex_dump(volatile void *);
+static void	mutex_dump(volatile void *);
 lockops_t mutex_spin_lockops = {
 	"Mutex",
 	LOCKOPS_SPIN,
 	mutex_dump
 };
 lockops_t mutex_adaptive_lockops = {
 	"Mutex",
 	LOCKOPS_SLEEP,
 	mutex_dump
 };
 @@ -297,31 +297,31 @@ mutex_dump(volatile void *cookie)
 	printf_nolog("owner field  : %#018lx wait/spin: %16d/%d\n",
 	    (long)MUTEX_OWNER(mtx->mtx_owner), MUTEX_HAS_WAITERS(mtx),
 	    MUTEX_SPIN_P(mtx));
+}
 /*
  * mutex_abort:
+ *
  *	Dump information about an error and panic the system.  This
  *	generates a lot of machine code in the DIAGNOSTIC case, so
  *	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) ?
+	LOCKDEBUG_ABORT(func, line, mtx, (MUTEX_SPIN_P(mtx) ?
-	    &mutex_spin_lockops : &mutex_adaptive_lockops), func, msg);
+	    &mutex_spin_lockops : &mutex_adaptive_lockops), msg);
+}
 /*
  * mutex_init:
+ *
  *	Initialize a mutex for use.  Note that adaptive mutexes are in
  *	essence spin mutexes that can sleep to avoid deadlock and wasting
  *	CPU time.  We can't easily provide a type of mutex that always
  *	sleeps - see comments in mutex_vector_enter() about releasing
  *	mutexes unlocked.
  */
 void
 mutex_init(kmutex_t *mtx, kmutex_type_t type, int ipl)

 @@ -1,14 +1,14 @@
-/*	$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.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe and Andrew Doran.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -28,27 +28,27 @@
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * Kernel reader/writer lock implementation, modeled after those
  * found in Solaris, a description of which can be found in:
+ *
  *	Solaris Internals: Core Kernel Architecture, Jim Mauro and
  *	    Richard McDougall.
  */
 #include <sys/cdefs.h>
-__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
 #include <sys/param.h>
 #include <sys/proc.h>
 #include <sys/rwlock.h>
 #include <sys/sched.h>
 #include <sys/sleepq.h>
 #include <sys/systm.h>
 #include <sys/lockdebug.h>
 #include <sys/cpu.h>
 #include <sys/atomic.h>
 #include <sys/lock.h>
 @@ -63,65 +63,65 @@ __KERNEL_RCSID(0, "$NetBSD: kern_rwlock.
 #define	RW_WANTLOCK(rw, op)						\
 	LOCKDEBUG_WANTLOCK(RW_DEBUG_P(rw), (rw),			\
 	    (uintptr_t)__builtin_return_address(0), op == RW_READER);
 #define	RW_LOCKED(rw, op)						\
 	LOCKDEBUG_LOCKED(RW_DEBUG_P(rw), (rw), NULL,			\
 	    (uintptr_t)__builtin_return_address(0), op == RW_READER);
 #define	RW_UNLOCKED(rw, op)						\
 	LOCKDEBUG_UNLOCKED(RW_DEBUG_P(rw), (rw),			\
 	    (uintptr_t)__builtin_return_address(0), op == RW_READER);
 #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 */
 #define	RW_WANTLOCK(rw, op)	/* nothing */
 #define	RW_LOCKED(rw, op)	/* nothing */
 #define	RW_UNLOCKED(rw, op)	/* nothing */
 #define	RW_DASSERT(rw, cond)	/* nothing */
 #endif	/* LOCKDEBUG */
 /*
  * DIAGNOSTIC
  */
 #if defined(DIAGNOSTIC)
 #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
 #define	RW_ASSERT(rw, cond)	/* nothing */
 #endif	/* DIAGNOSTIC */
 #define	RW_SETDEBUG(rw, on)		((rw)->rw_owner |= (on) ? 0 : RW_NODEBUG)
 #define	RW_DEBUG_P(rw)			(((rw)->rw_owner & RW_NODEBUG) == 0)
 #if defined(LOCKDEBUG)
 #define	RW_INHERITDEBUG(n, o)		(n) |= (o) & RW_NODEBUG
 #else /* defined(LOCKDEBUG) */
 #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);
 static inline uintptr_t
 rw_cas(krwlock_t *rw, uintptr_t o, uintptr_t n)
+{
 	RW_INHERITDEBUG(n, o);
 	return (uintptr_t)atomic_cas_ptr((volatile void *)&rw->rw_owner,
 	    (void *)o, (void *)n);
+}
 static inline void
 @@ -173,33 +173,33 @@ rw_dump(volatile void *cookie)
 	printf_nolog("owner/count  : %#018lx flags    : %#018x\n",
 	    (long)RW_OWNER(rw), (int)RW_FLAGS(rw));
+}
 /*
  * rw_abort:
+ *
  *	Dump information about an error and panic the system.  This
  *	generates a lot of machine code in the DIAGNOSTIC case, so
  *	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);
+}
 /*
  * rw_init:
+ *
  *	Initialize a rwlock for use.
  */
 void
 rw_init(krwlock_t *rw)
+{
 	bool dodebug;
 	memset(rw, 0, sizeof(*rw));
 @@ -328,27 +328,28 @@ rw_vector_enter(krwlock_t *rw, const krw
 			/*
 			 * Didn't get it -- spin around again (we'll
 			 * probably sleep on the next iteration).
 			 */
 			owner = next;
 			continue;
+		}
 		if (__predict_false(panicstr != NULL)) {
 			KPREEMPT_ENABLE(curlwp);
 			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
 		 * there are no existing waiters, then spin.
 		 */
 		if (rw_oncpu(owner)) {
 			LOCKSTAT_START_TIMER(lsflag, spintime);
 			u_int count = SPINLOCK_BACKOFF_MIN;
 			do {
 				KPREEMPT_ENABLE(curlwp);
 				SPINLOCK_BACKOFF(count);
 				KPREEMPT_DISABLE(curlwp);
 				owner = rw->rw_owner;

 @@ -1,14 +1,14 @@
-/*	$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.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -24,27 +24,27 @@
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * Basic lock debugging code shared among lock primitives.
  */
 #include <sys/cdefs.h>
-__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"
 #endif
 #include <sys/param.h>
 #include <sys/proc.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/lockdebug.h>
 #include <sys/sleepq.h>
 #include <sys/cpu.h>
 @@ -89,28 +89,28 @@ typedef struct lockdebug {
 } volatile lockdebug_t;
 typedef _TAILQ_HEAD(lockdebuglist, struct lockdebug, volatile) lockdebuglist_t;
 __cpu_simple_lock_t	ld_mod_lk;
 lockdebuglist_t		ld_free = TAILQ_HEAD_INITIALIZER(ld_free);
 lockdebuglist_t		ld_all = TAILQ_HEAD_INITIALIZER(ld_all);
 int			ld_nfree;
 int			ld_freeptr;
 int			ld_recurse;
 bool			ld_nomore;
 lockdebug_t		ld_prime[LD_BATCH];
-static void	lockdebug_abort1(lockdebug_t *, int, const char *,
+static void	lockdebug_abort1(const char *, size_t, lockdebug_t *, int,
-				 const char *, bool);
+    const char *, bool);
 static int	lockdebug_more(int);
 static void	lockdebug_init(void);
 static void	lockdebug_dump(lockdebug_t *, void (*)(const char *, ...)
     __printflike(1, 2));
 static signed int
 ld_rbto_compare_nodes(void *ctx, const void *n1, const void *n2)
+{
 	const lockdebug_t *ld1 = n1;
 	const lockdebug_t *ld2 = n2;
 	const uintptr_t a = (uintptr_t)ld1->ld_lock;
 	const uintptr_t b = (uintptr_t)ld2->ld_lock;
 @@ -180,34 +180,35 @@ lockdebug_unlock_cpus(void)
 	struct cpu_info *ci;
 	for (CPU_INFO_FOREACH(cii, ci)) {
 		__cpu_simple_unlock(&ci->ci_data.cpu_ld_lock);
+	}
+}
 /*
  * lockdebug_lookup:
+ *
  *	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 "
+		panic("%s,%zu: uninitialized lock (lock=%p, from=%08"
-		    "(lock=%p, from=%08"PRIxPTR")", lock, where);
+		    PRIxPTR ")", func, line, lock, where);
+	}
 	return ld;
+}
 /*
  * lockdebug_init:
+ *
  *	Initialize the lockdebug system.  Allocate an initial pool of
  *	lockdebug structures before the VM system is up and running.
  */
 static void
 lockdebug_init(void)
+{
 @@ -228,42 +229,44 @@ lockdebug_init(void)
 		TAILQ_INSERT_TAIL(&ld_all, ld, ld_achain);
+	}
 	ld_freeptr = 1;
 	ld_nfree = LD_BATCH - 1;
+}
 /*
  * lockdebug_alloc:
+ *
  *	A lock is being initialized, so allocate an associated debug
  *	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;
 	int s;
 	if (lo == NULL || panicstr != NULL || ld_panic)
 		return false;
 	if (ld_freeptr == 0)
 		lockdebug_init();
 	s = splhigh();
 	__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;
+	}
 	/*
 	 * Pinch a new debug structure.  We may recurse because we call
 	 * kmem_alloc(), which may need to initialize new locks somewhere
 	 * down the path.  If not recursing, we try to maintain at least
 	 * LD_SLOP structures free, which should hopefully be enough to
 	 * satisfy kmem_alloc().  If we can't provide a structure, not to
 	 * worry: we'll just mark the lock as not having an ID.
 	 */
 	ci = curcpu();
 	ci->ci_lkdebug_recurse++;
 @@ -278,72 +281,74 @@ lockdebug_alloc(volatile void *lock, loc
 	} else if (ci->ci_lkdebug_recurse == 1 && ld_nfree < LD_SLOP) {
 		s = lockdebug_more(s);
+	}
 	if ((ld = TAILQ_FIRST(&ld_free)) == NULL) {
 		__cpu_simple_unlock(&ld_mod_lk);
 		splx(s);
 		return false;
+	}
 	TAILQ_REMOVE(&ld_free, ld, ld_chain);
 	ld_nfree--;
 	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. */
 	ld->ld_lock = lock;
 	ld->ld_lockops = lo;
 	ld->ld_locked = 0;
 	ld->ld_unlocked = 0;
 	ld->ld_lwp = NULL;
 	ld->ld_initaddr = initaddr;
 	ld->ld_flags = (lo->lo_type == LOCKOPS_SLEEP ? LD_SLEEPER : 0);
 	lockdebug_lock_cpus();
 	(void)rb_tree_insert_node(&ld_rb_tree, __UNVOLATILE(ld));
 	lockdebug_unlock_cpus();
 	__cpu_simple_unlock(&ld_mod_lk);
 	splx(s);
 	return true;
+}
 /*
  * lockdebug_free:
+ *
  *	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;
 	if (panicstr != NULL || ld_panic)
 		return;
 	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"
+		panic("%s,%zu: destroying uninitialized object %p"
-		    "(ld_lock=%p)", lock, ld->ld_lock);
+		    "(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();
 	rb_tree_remove_node(&ld_rb_tree, __UNVOLATILE(ld));
 	lockdebug_unlock_cpus();
 	ld->ld_lock = NULL;
 	TAILQ_INSERT_TAIL(&ld_free, ld, ld_chain);
 	ld_nfree++;
 	__cpu_simple_unlock(&ld->ld_spinlock);
 	__cpu_simple_unlock(&ld_mod_lk);
 	splx(s);
+}
 @@ -405,321 +410,327 @@ lockdebug_more(int s)
 		membar_producer();
+	}
 	return s;
+}
 /*
  * lockdebug_wantlock:
+ *
  *	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;
 	bool recurse;
 	int s;
 	(void)shared;
 	recurse = false;
 	if (panicstr != NULL || ld_panic)
 		return;
 	s = splhigh();
-	if ((ld = lockdebug_lookup(lock, where)) == NULL) {
+	if ((ld = lockdebug_lookup(func, line, lock, where)) == NULL) {
 		splx(s);
 		return;
+	}
 	if ((ld->ld_flags & LD_LOCKED) != 0 || ld->ld_shares != 0) {
 		if ((ld->ld_flags & LD_SLEEPER) != 0) {
 			if (ld->ld_lwp == l)
 				recurse = true;
 		} else if (ld->ld_cpu == (uint16_t)cpu_index(curcpu()))
 			recurse = true;
+	}
 	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;
+		}
+	}
 	if (shared)
 		ld->ld_shwant++;
 	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;
+	}
 	__cpu_simple_unlock(&ld->ld_spinlock);
 	splx(s);
+}
 /*
  * lockdebug_locked:
+ *
  *	Process a lock acquire operation.
  */
 void
-lockdebug_locked(volatile void *lock, void *cvlock, uintptr_t where,
+lockdebug_locked(const char *func, size_t line,
-		 int shared)
+    volatile void *lock, void *cvlock, uintptr_t where, int shared)
+{
 	struct lwp *l = curlwp;
 	lockdebug_t *ld;
 	int s;
 	if (panicstr != NULL || ld_panic)
 		return;
 	s = splhigh();
-	if ((ld = lockdebug_lookup(lock, where)) == NULL) {
+	if ((ld = lockdebug_lookup(func, line, lock, where)) == NULL) {
 		splx(s);
 		return;
+	}
 	if (cvlock) {
 		KASSERT(ld->ld_lockops->lo_type == LOCKOPS_CV);
 		if (lock == (void *)&lbolt) {
 			/* nothing */
 		} 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"
+			lockdebug_abort1(func, line, ld, s,
-			    " with condition variable", true);
+			    "multiple locks used with condition variable",
 			    true);
 			return;
+		}
 	} else if (shared) {
 		l->l_shlocks++;
 		ld->ld_locked = where;
 		ld->ld_shares++;
 		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;
+		}
 		ld->ld_flags |= LD_LOCKED;
 		ld->ld_locked = where;
 		ld->ld_exwant--;
 		if ((ld->ld_flags & LD_SLEEPER) != 0) {
 			TAILQ_INSERT_TAIL(&l->l_ld_locks, ld, ld_chain);
 		} else {
 			TAILQ_INSERT_TAIL(&curcpu()->ci_data.cpu_ld_locks,
 			    ld, ld_chain);
+		}
+	}
 	ld->ld_cpu = (uint16_t)cpu_index(curcpu());
 	ld->ld_lwp = l;
 	__cpu_simple_unlock(&ld->ld_spinlock);
 	splx(s);
+}
 /*
  * lockdebug_unlocked:
+ *
  *	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;
 	int s;
 	if (panicstr != NULL || ld_panic)
 		return;
 	s = splhigh();
-	if ((ld = lockdebug_lookup(lock, where)) == NULL) {
+	if ((ld = lockdebug_lookup(func, line, lock, where)) == NULL) {
 		splx(s);
 		return;
+	}
 	if (ld->ld_lockops->lo_type == LOCKOPS_CV) {
 		if (lock == (void *)&lbolt) {
 			/* nothing */
 		} else {
 			ld->ld_shares--;
+		}
 	} 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;
+		}
 		l->l_shlocks--;
 		ld->ld_shares--;
 		if (ld->ld_lwp == l) {
 			ld->ld_unlocked = where;
 			ld->ld_lwp = NULL;
+		}
 		if (ld->ld_cpu == (uint16_t)cpu_index(curcpu()))
 			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;
+			}
 			TAILQ_REMOVE(&curcpu()->ci_data.cpu_ld_locks, ld,
 			    ld_chain);
+		}
 		ld->ld_flags &= ~LD_LOCKED;
 		ld->ld_unlocked = where;
 		ld->ld_lwp = NULL;
+	}
 	__cpu_simple_unlock(&ld->ld_spinlock);
 	splx(s);
+}
 /*
  * lockdebug_wakeup:
+ *
  *	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;
 	if (panicstr != NULL || ld_panic || lock == (void *)&lbolt)
 		return;
 	s = splhigh();
 	/* Find the CV... */
-	if ((ld = lockdebug_lookup(lock, where)) == NULL) {
+	if ((ld = lockdebug_lookup(func, line, lock, where)) == NULL) {
 		splx(s);
 		return;
+	}
 	/*
 	 * If it has any waiters, ensure that they are using the
 	 * 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;
+	}
 	__cpu_simple_unlock(&ld->ld_spinlock);
 	splx(s);
+}
 /*
  * lockdebug_barrier:
+ *
  *	Panic if we hold more than one specified spin lock, and optionally,
  *	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;
 	int s;
 	if (panicstr != NULL || ld_panic)
 		return;
 	s = splhigh();
 	if ((l->l_pflag & LP_INTR) == 0) {
 		TAILQ_FOREACH(ld, &curcpu()->ci_data.cpu_ld_locks, ld_chain) {
 			if (ld->ld_lock == spinlock) {
 				continue;
+			}
 			__cpu_simple_lock(&ld->ld_spinlock);
-			lockdebug_abort1(ld, s, __func__,
+			lockdebug_abort1(func, line, ld, s,
 			    "spin lock held", true);
 			return;
+		}
+	}
 	if (slplocks) {
 		splx(s);
 		return;
+	}
 	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);
 	if (l->l_shlocks != 0) {
 		TAILQ_FOREACH(ld, &ld_all, ld_achain) {
 			if (ld->ld_lockops->lo_type == LOCKOPS_CV)
 				continue;
 			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);
+	}
+}
 /*
  * lockdebug_mem_check:
+ *
  *	Check for in-use locks within a memory region that is
  *	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;
 	int s;
 	if (panicstr != NULL || ld_panic)
 		return;
 	s = splhigh();
 	ci = curcpu();
 	__cpu_simple_lock(&ci->ci_data.cpu_ld_lock);
 	ld = (lockdebug_t *)rb_tree_find_node_geq(&ld_rb_tree, base);
 	if (ld != NULL) {
 		const uintptr_t lock = (uintptr_t)ld->ld_lock;
 		if ((uintptr_t)base > lock)
-			panic("%s: corrupt tree ld=%p, base=%p, sz=%zu",
+			panic("%s,%zu: corrupt tree ld=%p, base=%p, sz=%zu",
-			    __func__, ld, base, sz);
+			    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;
+	}
 	splx(s);
+}
 /*
  * lockdebug_dump:
+ *
  *	Dump information about a lock on panic, or for DDB.
  */
 static void
 lockdebug_dump(lockdebug_t *ld, void (*pr)(const char *, ...)
 @@ -757,50 +768,50 @@ lockdebug_dump(lockdebug_t *ld, void (*p
 	if (sleeper) {
 		(*pr)("\n");
 		turnstile_print(ld->ld_lock, pr);
+	}
+}
 /*
  * lockdebug_abort1:
+ *
  *	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)
+{
 	/*
 	 * Don't make the situation worse if the system is already going
 	 * down in flames.  Once a panic is triggered, lockdebug state
 	 * becomes stale and cannot be trusted.
 	 */
 	if (atomic_inc_uint_nv(&ld_panic) != 1) {
 		__cpu_simple_unlock(&ld->ld_spinlock);
 		splx(s);
 		return;
+	}
-	printf_nolog("%s error: %s: %s\n\n", ld->ld_lockops->lo_name,
+	printf_nolog("%s error: %s,%zu: %s\n\n", ld->ld_lockops->lo_name,
-	    func, msg);
+	    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,
+		panic("LOCKDEBUG: %s error: %s,%zu: %s",
-		    func, msg);
+		    ld->ld_lockops->lo_name, func, line, msg);
+}
 #endif	/* LOCKDEBUG */
 /*
  * lockdebug_lock_print:
+ *
  *	Handle the DDB 'show lock' command.
  */
 #ifdef DDB
 void
 lockdebug_lock_print(void *addr, void (*pr)(const char *, ...))
+{
 @@ -822,48 +833,48 @@ lockdebug_lock_print(void *addr, void (*
+	}
 #else
 	(*pr)("Sorry, kernel not built with the LOCKDEBUG option.\n");
 #endif	/* LOCKDEBUG */
+}
 #endif	/* DDB */
 /*
  * lockdebug_abort:
+ *
  *	An error has been trapped - dump lock info and call panic().
  */
 void
-lockdebug_abort(volatile void *lock, lockops_t *ops, const char *func,
+lockdebug_abort(const char *func, size_t line, volatile void *lock,
-		const char *msg)
+    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);
 #endif	/* LOCKDEBUG */
 	/*
 	 * Complain first on the occurrance only.  Otherwise proceeed to
 	 * panic where we will `rendezvous' with other CPUs if the machine
 	 * 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",
+	panic("lock error: %s: %s,%zu: %s: lock %p cpu %d lwp %p",
-	    ops->lo_name, func, msg, lock, cpu_index(curcpu()), curlwp);
+	    ops->lo_name, func, line, msg, lock, cpu_index(curcpu()), curlwp);
+}

 @@ -1,14 +1,14 @@
-/*	$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.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -40,59 +40,66 @@
 #error "Sorry, nothing of interest to user level programs here."
 #endif
 #define	LOCKOPS_SLEEP	0
 #define	LOCKOPS_SPIN	1
 #define	LOCKOPS_CV	2
 typedef	struct lockops {
 	const char	*lo_name;
 	int		lo_type;
 	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 *,
+void	lockdebug_abort(const char *, size_t, volatile void *, lockops_t *,
-			const char *, const char *);
+    const char *);
 void	lockdebug_lock_print(void *, void (*)(const char *, ...)
     __printflike(1, 2));
 #ifdef LOCKDEBUG
-bool	lockdebug_alloc(volatile void *, lockops_t *, uintptr_t);
+bool	lockdebug_alloc(const char *, size_t, volatile void *, lockops_t *,
-void	lockdebug_free(volatile void *);
+    uintptr_t);
-void	lockdebug_wantlock(volatile void *, uintptr_t, int);
+void	lockdebug_free(const char *, size_t, volatile void *);
-void	lockdebug_locked(volatile void *, void *, uintptr_t, int);
+void	lockdebug_wantlock(const char *, size_t, volatile void *, uintptr_t,
-void	lockdebug_unlocked(volatile void *, uintptr_t, int);
+    int);
-void	lockdebug_barrier(volatile void *, int);
+void	lockdebug_locked(const char *, size_t, volatile void *, void *,
-void	lockdebug_mem_check(const char *, void *, size_t);
+    uintptr_t, int);
-void	lockdebug_wakeup(volatile void *, uintptr_t);
+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)
+    if (dodebug) lockdebug_unlocked(__func__, __LINE__, lock, where, s)
-#define	LOCKDEBUG_BARRIER(lock, slp)		lockdebug_barrier(lock, slp)
+#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 */
 #define	LOCKDEBUG_ALLOC(lock, ops, addr)		false
 #define	LOCKDEBUG_FREE(dodebug, lock)			/* nothing */
 #define	LOCKDEBUG_WANTLOCK(dodebug, lock, where, s)	/* nothing */
 #define	LOCKDEBUG_LOCKED(dodebug, lock, al, where, s)	/* nothing */
 #define	LOCKDEBUG_UNLOCKED(dodebug, lock, where, s)	/* nothing */
 #define	LOCKDEBUG_BARRIER(lock, slp)			/* nothing */
 #define	LOCKDEBUG_MEM_CHECK(base, sz)			/* nothing */
 #define	LOCKDEBUG_WAKEUP(dodebug, lock, where)		/* nothing */
 #endif	/* LOCKDEBUG */