Rework the witness code to work with sx locks as well as mutexes.

- Introduce lock classes and lock objects.  Each lock class specifies a
  name and set of flags (or properties) shared by all locks of a given
  type.  Currently there are three lock classes: spin mutexes, sleep
  mutexes, and sx locks.  A lock object specifies properties of an
  additional lock along with a lock name and all of the extra stuff needed
  to make witness work with a given lock.  This abstract lock stuff is
  defined in sys/lock.h.  The lockmgr constants, types, and prototypes have
  been moved to sys/lockmgr.h.  For temporary backwards compatability,
  sys/lock.h includes sys/lockmgr.h.
- Replace proc->p_spinlocks with a per-CPU list, PCPU(spinlocks), of spin
  locks held.  By making this per-cpu, we do not have to jump through
  magic hoops to deal with sched_lock changing ownership during context
  switches.
- Replace proc->p_heldmtx, formerly a list of held sleep mutexes, with
  proc->p_sleeplocks, which is a list of held sleep locks including sleep
  mutexes and sx locks.
- Add helper macros for logging lock events via the KTR_LOCK KTR logging
  level so that the log messages are consistent.
- Add some new flags that can be passed to mtx_init():
  - MTX_NOWITNESS - specifies that this lock should be ignored by witness.
    This is used for the mutex that blocks a sx lock for example.
  - MTX_QUIET - this is not new, but you can pass this to mtx_init() now
    and no events will be logged for this lock, so that one doesn't have
    to change all the individual mtx_lock/unlock() operations.
- All lock objects maintain an initialized flag.  Use this flag to export
  a mtx_initialized() macro that can be safely called from drivers.  Also,
  we on longer walk the all_mtx list if MUTEX_DEBUG is defined as witness
  performs the corresponding checks using the initialized flag.
- The lock order reversal messages have been improved to output slightly
  more accurate file and line numbers.

1 files changed, 63 insertions, 10 deletions

diff --git a/sys/kern/kern_sx.c b/sys/kern/kern_sx.c
index a1c576f..0f39097 100644
--- a/sys/kern/kern_sx.c
+++ b/sys/kern/kern_sx.c
@@ -46,43 +46,68 @@
 #include <sys/systm.h>
 #include <sys/ktr.h>
 #include <sys/condvar.h>
+#include <sys/lock.h>
 #include <sys/mutex.h>
 #include <sys/sx.h>
 
+/*
+ * XXX: We don't implement the LO_RECURSED flag for this lock yet.
+ * We could do this by walking p_sleeplocks if we really wanted to.
+ */
+struct lock_class lock_class_sx = {
+	"sx",
+	LC_SLEEPLOCK | LC_SLEEPABLE | LC_RECURSABLE
+};
+
 void
 sx_init(struct sx *sx, const char *description)
 {
-
-	mtx_init(&sx->sx_lock, description, MTX_DEF);
+	struct lock_object *lock;
+
+	bzero(sx, sizeof(*sx));
+	lock = &sx->sx_object;
+	lock->lo_class = &lock_class_sx;
+	lock->lo_name = description;
+	lock->lo_flags = LO_WITNESS | LO_SLEEPABLE;
+	mtx_init(&sx->sx_lock, "sx backing lock",
+	    MTX_DEF | MTX_NOWITNESS | MTX_QUIET);
 	sx->sx_cnt = 0;
 	cv_init(&sx->sx_shrd_cv, description);
 	sx->sx_shrd_wcnt = 0;
 	cv_init(&sx->sx_excl_cv, description);
-	sx->sx_descr = description;
 	sx->sx_excl_wcnt = 0;
 	sx->sx_xholder = NULL;
+
+	LOCK_LOG_INIT(lock, 0);
+
+	WITNESS_INIT(lock);
 }
 
 void
 sx_destroy(struct sx *sx)
 {
 
+	LOCK_LOG_DESTROY(&sx->sx_object, 0);
+
 	KASSERT((sx->sx_cnt == 0 && sx->sx_shrd_wcnt == 0 && sx->sx_excl_wcnt ==
-	    0), ("%s (%s): holders or waiters\n", __FUNCTION__, sx->sx_descr));
+	    0), ("%s (%s): holders or waiters\n", __FUNCTION__,
+	    sx->sx_object.lo_name));
 
 	mtx_destroy(&sx->sx_lock);
 	cv_destroy(&sx->sx_shrd_cv);
 	cv_destroy(&sx->sx_excl_cv);
+
+	WITNESS_DESTROY(&sx->sx_object);
 }
 
 void
-sx_slock(struct sx *sx)
+_sx_slock(struct sx *sx, const char *file, int line)
 {
 
 	mtx_lock(&sx->sx_lock);
 	KASSERT(sx->sx_xholder != curproc,
 	    ("%s (%s): trying to get slock while xlock is held\n", __FUNCTION__,
-	    sx->sx_descr));
+	    sx->sx_object.lo_name));
 
 	/*
 	 * Loop in case we lose the race for lock acquisition.
@@ -96,11 +121,17 @@ sx_slock(struct sx *sx)
 	/* Acquire a shared lock. */
 	sx->sx_cnt++;
 
+#ifdef WITNESS
+	sx->sx_object.lo_flags |= LO_LOCKED;
+#endif
+	LOCK_LOG_LOCK("SLOCK", &sx->sx_object, 0, 0, file, line);
+	WITNESS_LOCK(&sx->sx_object, 0, file, line);
+
 	mtx_unlock(&sx->sx_lock);
 }
 
 void
-sx_xlock(struct sx *sx)
+_sx_xlock(struct sx *sx, const char *file, int line)
 {
 
 	mtx_lock(&sx->sx_lock);
@@ -113,7 +144,8 @@ sx_xlock(struct sx *sx)
 	 * INVARIANTS.
 	 */
 	KASSERT(sx->sx_xholder != curproc,
-	    ("%s (%s): xlock already held", __FUNCTION__, sx->sx_descr));
+	    ("%s (%s): xlock already held @ %s:%d", __FUNCTION__,
+	    sx->sx_object.lo_name, file, line));
 
 	/* Loop in case we lose the race for lock acquisition. */
 	while (sx->sx_cnt != 0) {
@@ -128,16 +160,28 @@ sx_xlock(struct sx *sx)
 	sx->sx_cnt--;
 	sx->sx_xholder = curproc;
 
+#ifdef WITNESS
+	sx->sx_object.lo_flags |= LO_LOCKED;
+#endif
+	LOCK_LOG_LOCK("XLOCK", &sx->sx_object, 0, 0, file, line);
+	WITNESS_LOCK(&sx->sx_object, 0, file, line);
+
 	mtx_unlock(&sx->sx_lock);
 }
 
 void
-sx_sunlock(struct sx *sx)
+_sx_sunlock(struct sx *sx, const char *file, int line)
 {
 
 	mtx_lock(&sx->sx_lock);
 	_SX_ASSERT_SLOCKED(sx);
 
+#ifdef WITNESS
+	if (sx->sx_cnt == 0)
+		sx->sx_object.lo_flags &= ~LO_LOCKED;
+#endif
+	WITNESS_UNLOCK(&sx->sx_object, 0, file, line);
+
 	/* Release. */
 	sx->sx_cnt--;
 
@@ -153,17 +197,24 @@ sx_sunlock(struct sx *sx)
 	} else if (sx->sx_shrd_wcnt > 0)
 		cv_broadcast(&sx->sx_shrd_cv);
 
+	LOCK_LOG_LOCK("SUNLOCK", &sx->sx_object, 0, 0, file, line);
+
 	mtx_unlock(&sx->sx_lock);
 }
 
 void
-sx_xunlock(struct sx *sx)
+_sx_xunlock(struct sx *sx, const char *file, int line)
 {
 
 	mtx_lock(&sx->sx_lock);
 	_SX_ASSERT_XLOCKED(sx);
 	MPASS(sx->sx_cnt == -1);
 
+#ifdef WITNESS
+	sx->sx_object.lo_flags &= ~LO_LOCKED;
+#endif
+	WITNESS_UNLOCK(&sx->sx_object, 0, file, line);
+
 	/* Release. */
 	sx->sx_cnt++;
 	sx->sx_xholder = NULL;
@@ -176,5 +227,7 @@ sx_xunlock(struct sx *sx)
 	else if (sx->sx_excl_wcnt > 0)
 		cv_signal(&sx->sx_excl_cv);
 
+	LOCK_LOG_LOCK("XUNLOCK", &sx->sx_object, 0, 0, file, line);
+
 	mtx_unlock(&sx->sx_lock);
 }