465  * Assumes SQLOCK held.
469 	ASSERT(MUTEX_HELD(SQLOCK(sq)));					\
527  * Assumes SQLOCK held.
531 		ASSERT(MUTEX_HELD(SQLOCK(sq)));				\
596 		ASSERT(MUTEX_HELD(SQLOCK(sq)));				\
611 		ASSERT(MUTEX_HELD(SQLOCK(sq)));				\
1690 	mutex_enter(SQLOCK(sq));
1697 		cv_wait(&sq->sq_wait, SQLOCK(sq));
1703 	mutex_exit(SQLOCK(sq));
1715 		mutex_enter(SQLOCK(sq));
1718 			cv_wait(&sq->sq_wait, SQLOCK(sq));
1720 		mutex_exit(SQLOCK(sq));
2103 		mutex_enter(SQLOCK(sq));
2106 			cv_wait(&sq->sq_wait, SQLOCK(sq));
2108 		mutex_exit(SQLOCK(sq));
2181 		mutex_enter(SQLOCK(sq));
2184 			cv_wait(&sq->sq_wait, SQLOCK(sq));
2186 		mutex_exit(SQLOCK(sq));
3466 	ASSERT(MUTEX_NOT_HELD(SQLOCK(sq)));
3800 	mutex_enter(SQLOCK(sq));
3820 		cv_wait(&sq->sq_wait, SQLOCK(sq));
3823 	mutex_exit(SQLOCK(sq));
3831  * This routine assumes that SQLOCK is held.
3832  * NOTE that the lock order is to have the SQLOCK first,
3834  * before acquiring the SQLOCK (mostly relevant for the background
3836  * Note that the sq_svcflags are protected by the SQLOCK.
3847 	ASSERT(MUTEX_HELD(SQLOCK(sq)));
4625 		mutex_enter(SQLOCK(sq));
4648 			mutex_exit(SQLOCK(sql2->sql_sq));
4663 			cv_wait(&sq->sq_wait, SQLOCK(sq));
4673 		mutex_exit(SQLOCK(sq));
4703 		mutex_exit(SQLOCK(sql->sql_sq));
4874 		mutex_enter(SQLOCK(sq));
4879 		mutex_exit(SQLOCK(sq));
4882 			mutex_enter(SQLOCK(wsq));
4887 			mutex_exit(SQLOCK(wsq));
4905 	mutex_enter(SQLOCK(sq));
4911 	mutex_exit(SQLOCK(sq));
4991 	mutex_enter(SQLOCK(sq));
4993 	mutex_exit(SQLOCK(sq));
5013 	mutex_enter(SQLOCK(sq));
5036 		cv_wait(&sq->sq_wait, SQLOCK(sq));
5055 	mutex_exit(SQLOCK(sq));
5075 	mutex_enter(SQLOCK(sq));
5088 				/* drain_syncq drops SQLOCK */
5094 	mutex_exit(SQLOCK(sq));
5110 	mutex_enter(SQLOCK(sq));
5118 	mutex_exit(SQLOCK(sq));
5135 	mutex_enter(SQLOCK(sq));
5143 			/* drain_syncq() drops SQLOCK */
5149 	mutex_exit(SQLOCK(sq));
5372  * sq_putlocks/sq_putcounts instead of SQLOCK/sq_count (e.g. to optimize
5394 	mutex_enter(SQLOCK(sq));
5418 		cv_wait(&sq->sq_wait, SQLOCK(sq));
5447 		mutex_exit(SQLOCK(sq));
5449 		mutex_enter(SQLOCK(sq));
5470 			cv_wait(&sq->sq_wait, SQLOCK(sq));
5486 	mutex_exit(SQLOCK(sq));
5514 	mutex_enter(SQLOCK(sq));
5538 			ASSERT(MUTEX_NOT_HELD(SQLOCK(sq)));
5550 	mutex_exit(SQLOCK(sq));
5568 	mutex_enter(SQLOCK(sq));
5571 	mutex_exit(SQLOCK(sq));
5586 	mutex_enter(SQLOCK(sq));
5610 	mutex_exit(SQLOCK(sq));
5736 	mutex_enter(SQLOCK(outer));
5739 		cv_wait(&outer->sq_wait, SQLOCK(outer));
5749 	 * the SQLOCK on the outer syncq. This ensures that the changing
5750 	 * of SQ_WRITER is atomic under the outer SQLOCK.
5753 		mutex_enter(SQLOCK(sq));
5761 		mutex_exit(SQLOCK(sq));
5763 	mutex_exit(SQLOCK(outer));
5778 			mutex_enter(SQLOCK(sq));
5785 				cv_wait(&sq->sq_wait, SQLOCK(sq));
5791 			mutex_exit(SQLOCK(sq));
5799 		mutex_enter(SQLOCK(outer));
5801 			mutex_exit(SQLOCK(outer));
5805 		mutex_exit(SQLOCK(outer));
5823 	ASSERT(MUTEX_NOT_HELD(SQLOCK(outer)));
5828 	 * SQLOCK(outer) across all the dropsq calls and the resetting of
5831 	 * SQLOCK and the inner perimeter SQLOCKs.
5833 	mutex_enter(SQLOCK(outer));
5854 		mutex_exit(SQLOCK(outer));
5857 		mutex_enter(SQLOCK(outer));
5867 	mutex_exit(SQLOCK(outer));
5891 	mutex_enter(SQLOCK(sq));
5897 	mutex_exit(SQLOCK(sq));
5921 	mutex_enter(SQLOCK(sq));
5926 	mutex_exit(SQLOCK(sq));
5943 	ASSERT(MUTEX_HELD(SQLOCK(outer)));
5954 		mutex_exit(SQLOCK(outer));
5962 		mutex_exit(SQLOCK(outer));
5990 	mutex_enter(SQLOCK(outer));
6004 		 * The queueing is atomic under SQLOCK(outer) in order
6006 		 * queue_writer will drop the outer SQLOCK
6010 			mutex_enter(SQLOCK(osq));
6012 			mutex_exit(SQLOCK(osq));
6019 				mutex_enter(SQLOCK(osq));
6021 				mutex_exit(SQLOCK(osq));
6042 	 * the SQLOCK on the outer syncq. This ensures that the changing
6043 	 * of SQ_WRITER is atomic under the outer SQLOCK.
6050 		mutex_enter(SQLOCK(sq));
6058 		mutex_exit(SQLOCK(sq));
6076 		mutex_enter(SQLOCK(outer));
6087 		mutex_exit(SQLOCK(outer));
6091 		mutex_exit(SQLOCK(outer));
6110 	ASSERT(MUTEX_HELD(SQLOCK(outer)));
6128 		mutex_exit(SQLOCK(outer));
6145 		mutex_enter(SQLOCK(outer));
6147 	ASSERT(MUTEX_HELD(SQLOCK(outer)));
6167  * already exclusive (SQ_EXCL set), and the SQLOCK held.
6179 	ASSERT(MUTEX_HELD(SQLOCK(sq)));
6223 		mutex_exit(SQLOCK(sq));
6227 		mutex_enter(SQLOCK(sq));
6252  * This procedure assumes SQLOCK is held.  To run the event list, it
6260 	ASSERT(MUTEX_HELD(SQLOCK(sq)));
6288 	 * NOTE: We hold the SQLOCK, so we can just grab the
6308 		mutex_exit(SQLOCK(sq));
6331 	 * SQ_EXCL, since we are exclusive, and hold the SQLOCK.
6350 		mutex_exit(SQLOCK(sq));
6380 	ASSERT(MUTEX_HELD(SQLOCK(sq)));
6401 		mutex_exit(SQLOCK(sq));
6408 	 * NOT messages queued, return (remember, we have the SQLOCK,
6425 		mutex_exit(SQLOCK(sq));
6443 			mutex_exit(SQLOCK(sq));
6452 	 * the sq_count.  But since we already have the SQLOCK
6525 		 * state to happen, a thread needs the SQLOCK which we hold, and
6540 		 * SQLOCK and one claim, call qdrain_syncq.
6541 		 * This means we need to release the SQLOCK and
6549 		mutex_exit(SQLOCK(sq));
6552 		mutex_enter(SQLOCK(sq));
6563 	ASSERT(MUTEX_HELD(SQLOCK(sq)));
6607 	mutex_exit(SQLOCK(sq));
6641  * 	SQLOCK not held
6656 	ASSERT(MUTEX_NOT_HELD(SQLOCK(sq)));
6795 			mutex_enter(SQLOCK(sq));
6797 			mutex_exit(SQLOCK(sq));
6810 	ASSERT(MUTEX_NOT_HELD(SQLOCK(sq)));
6815 		mutex_enter(SQLOCK(sq));
6818 		mutex_exit(SQLOCK(sq));
6855  * SQLOCK(sq) and QLOCK(q) are not held.
6860 	ASSERT(MUTEX_NOT_HELD(SQLOCK(sq)));
6889 	 * protect it.  So it's ok to acquire SQLOCK after SQPUT_MP().
6892 	mutex_enter(SQLOCK(sq));
6896 	 * Note that we need the SQLOCK for this, and for testing flags
6924 	 * SQLOCK is still held, so sq_count can be safely decremented.
6957 	mutex_enter(SQLOCK(sq));
7011 			 * need to release SQLOCK which may allow lots of things
7037 			 * going to drop SQLOCK(sq) and return. We wakeup syncq
7038 			 * waiters while we still have the SQLOCK.
7044 			/* Drop SQLOCK across clr_qfull */
7045 			mutex_exit(SQLOCK(sq));
7057 				mutex_enter(SQLOCK(sq));
7067 		ASSERT(MUTEX_HELD(SQLOCK(sq)));
7075 	mutex_exit(SQLOCK(sq));
7107 	ASSERT(MUTEX_HELD(SQLOCK(sq)));
7128 			ASSERT(MUTEX_HELD(SQLOCK(nsq)));
7257 	mutex_enter(SQLOCK(sq));
7272 		mutex_exit(SQLOCK(sq));
7295  * Acquires SQLOCK(sq) if non-NULL is returned.
7322 	mutex_enter(SQLOCK(sq));
7333 	ASSERT(MUTEX_HELD(SQLOCK(sq)));
7351 	ASSERT(MUTEX_HELD(SQLOCK(sq)));
7380 	mutex_enter(SQLOCK(sq));
7408 			mutex_exit(SQLOCK(sq));
7415 		cv_wait(&sq->sq_wait, SQLOCK(sq));
7436 	mutex_exit(SQLOCK(sq));
7444 	mutex_enter(SQLOCK(sq));
7446 	mutex_exit(SQLOCK(sq));
7462  * the SQLOCK).  Lastly, if there are other messages queued
7473 	ASSERT(MUTEX_HELD(SQLOCK(sq)));
7506 	/* Drop the SQLOCK on exit */
7507 	mutex_exit(SQLOCK(sq));
7542  * SQLOCK and sd_reflock, we need to drop respective locks first.
8284 	mutex_enter(SQLOCK(sq));

Indexes created Tue Jul 24 14:28:13 CEST 2018