 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_turnstile.c,v 1.31 2011/12/02 12:31:53 yamt Exp $	*/
+/*	$NetBSD: kern_turnstile.c,v 1.32 2012/06/15 13:51:40 yamt Exp $	*/
 /*-
  * Copyright (c) 2002, 2006, 2007, 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.
 @@ -50,27 +50,27 @@
  * queue.  If a thread decides it doesn't need to block after all, then this
  * interlock must be released by explicitly aborting the turnstile
  * operation.
+ *
  * When a thread is awakened, it needs to get its turnstile back.  If there
  * are still other threads waiting in the active turnstile, the thread
  * grabs a free turnstile off the free list.  Otherwise, it can take back
  * the active turnstile from the lock (thus deactivating the turnstile).
+ *
  * Turnstiles are the place to do priority inheritence.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_turnstile.c,v 1.31 2011/12/02 12:31:53 yamt Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_turnstile.c,v 1.32 2012/06/15 13:51:40 yamt Exp $");
 #include <sys/param.h>
 #include <sys/lockdebug.h>
 #include <sys/pool.h>
 #include <sys/proc.h>
 #include <sys/sleepq.h>
 #include <sys/systm.h>
 #define	TS_HASH_SIZE	64
 #define	TS_HASH_MASK	(TS_HASH_SIZE - 1)
 #define	TS_HASH(obj)	(((uintptr_t)(obj) >> 3) & TS_HASH_MASK)
 static tschain_t	turnstile_tab[TS_HASH_SIZE]	__cacheline_aligned;
 @@ -189,100 +189,120 @@ void
 turnstile_exit(wchan_t obj)
+{
 	tschain_t *tc;
 	tc = &turnstile_tab[TS_HASH(obj)];
 	mutex_spin_exit(tc->tc_mutex);
+}
 /*
  * turnstile_lendpri:
+ *
  *	Lend our priority to lwps on the blocking chain.
+ *
  *	If the current owner of the lock (l->l_wchan, set by sleepq_enqueue)
  *	has a priority lower than ours (lwp_eprio(l)), lend our priority to
  *	him to avoid priority inversions.
  */
 static void
 turnstile_lendpri(lwp_t *cur)
+{
 	lwp_t * l = cur;
 	pri_t prio;
 	/*
 	 * NOTE: if you get a panic in this code block, it is likely that
 	 * a lock has been destroyed or corrupted while still in use.  Try
 	 * compiling a kernel with LOCKDEBUG to pinpoint the problem.
 	 */
 	LOCKDEBUG_BARRIER(l->l_mutex, 1);
 	KASSERT(l == curlwp);
 	prio = lwp_eprio(l);
 	for (;;) {
 		lwp_t *owner;
 		turnstile_t *ts;
 		bool dolock;
 		if (l->l_wchan == NULL)
 			break;
 		/*
 		 * Ask syncobj the owner of the lock.
 		 */
 		owner = (*l->l_syncobj->sobj_owner)(l->l_wchan);
 		if (owner == NULL)
 			break;
-		/* The owner may have changed as we have dropped the tc lock */
+		/*
 		 * The owner may have changed as we have dropped the tc lock.
 		 */
 		if (cur == owner) {
 			/*
-			 * we own the lock: stop here, sleepq_block()
+			 * We own the lock: stop here, sleepq_block()
-			 * should wake up immediatly
+			 * should wake up immediatly.
 			 */
 			break;
+		}
-		if (l->l_mutex != owner->l_mutex)
+		/*
-			dolock = true;
+		 * Acquire owner->l_mutex if we don't have it yet.
-		else
+		 * Because we already have another LWP lock (l->l_mutex) held,
-			dolock = false;
+		 * we need to play a try lock dance to avoid deadlock.
 		 */
 		dolock = l->l_mutex != owner->l_mutex;
 		if (l == owner || (dolock && !lwp_trylock(owner))) {
 			/*
-			 * restart from curlwp.
+			 * The owner was changed behind us or trylock failed.
 			 * Restart from curlwp.
+			 *
 			 * Note that there may be a livelock here:
-			 * the owner may try grabing cur's lock (which is
+			 * the owner may try grabing cur's lock (which is the
-			 * the tc lock) while we're trying to grab
+			 * tc lock) while we're trying to grab the owner's lock.
 			 * the owner's lock.
 			 */
 			lwp_unlock(l);
 			l = cur;
 			lwp_lock(l);
 			prio = lwp_eprio(l);
 			continue;
+		}
 		/*
 		 * If the owner's priority is already higher than ours,
 		 * there's nothing to do anymore.
 		 */
 		if (prio <= lwp_eprio(owner)) {
 			if (dolock)
 				lwp_unlock(owner);
 			break;
+		}
 		/*
 		 * Lend our priority to the 'owner' LWP.
+		 *
 		 * Update lenders info for turnstile_unlendpri.
 		 */
 		ts = l->l_ts;
 		KASSERT(ts->ts_inheritor == owner || ts->ts_inheritor == NULL);
 		if (ts->ts_inheritor == NULL) {
 			ts->ts_inheritor = owner;
 			ts->ts_eprio = prio;
 			SLIST_INSERT_HEAD(&owner->l_pi_lenders, ts, ts_pichain);
 			lwp_lendpri(owner, prio);
 		} else if (prio > ts->ts_eprio) {
 			ts->ts_eprio = prio;
 			lwp_lendpri(owner, prio);
+		}
 		if (dolock)
 			lwp_unlock(l);
 		LOCKDEBUG_BARRIER(owner->l_mutex, 1);
 		l = owner;
+	}
 	LOCKDEBUG_BARRIER(l->l_mutex, 1);
 	if (cur->l_mutex != l->l_mutex) {
 		lwp_unlock(l);
 		lwp_lock(cur);
+	}
 	LOCKDEBUG_BARRIER(cur->l_mutex, 1);
+}
 /*
  * turnstile_unlendpri: undo turnstile_lendpri
  */