xref: /illumos-gate/usr/src/uts/common/os/condvar.c (revision 35a5a358)
17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
52db6c79fSstevel  * Common Development and Distribution License (the "License").
62db6c79fSstevel  * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate  *
87c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate  * and limitations under the License.
127c478bd9Sstevel@tonic-gate  *
137c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate  *
197c478bd9Sstevel@tonic-gate  * CDDL HEADER END
207c478bd9Sstevel@tonic-gate  */
21a574db85Sraf 
227c478bd9Sstevel@tonic-gate /*
23454ab202SMadhavan Venkataraman  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
247c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
257c478bd9Sstevel@tonic-gate  */
267c478bd9Sstevel@tonic-gate 
277c478bd9Sstevel@tonic-gate #include <sys/thread.h>
287c478bd9Sstevel@tonic-gate #include <sys/proc.h>
297c478bd9Sstevel@tonic-gate #include <sys/debug.h>
307c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h>
317c478bd9Sstevel@tonic-gate #include <sys/systm.h>
327c478bd9Sstevel@tonic-gate #include <sys/sobject.h>
337c478bd9Sstevel@tonic-gate #include <sys/sleepq.h>
347c478bd9Sstevel@tonic-gate #include <sys/cpuvar.h>
357c478bd9Sstevel@tonic-gate #include <sys/condvar.h>
367c478bd9Sstevel@tonic-gate #include <sys/condvar_impl.h>
377c478bd9Sstevel@tonic-gate #include <sys/schedctl.h>
387c478bd9Sstevel@tonic-gate #include <sys/procfs.h>
397c478bd9Sstevel@tonic-gate #include <sys/sdt.h>
4087a18d3fSMadhavan Venkataraman #include <sys/callo.h>
417c478bd9Sstevel@tonic-gate 
4251b32bddSMadhavan Venkataraman clock_t cv_timedwait_hires(kcondvar_t *, kmutex_t *, hrtime_t, hrtime_t, int);
4351b32bddSMadhavan Venkataraman 
447c478bd9Sstevel@tonic-gate /*
457c478bd9Sstevel@tonic-gate  * CV_MAX_WAITERS is the maximum number of waiters we track; once
467c478bd9Sstevel@tonic-gate  * the number becomes higher than that, we look at the sleepq to
477c478bd9Sstevel@tonic-gate  * see whether there are *really* any waiters.
487c478bd9Sstevel@tonic-gate  */
497c478bd9Sstevel@tonic-gate #define	CV_MAX_WAITERS		1024		/* must be power of 2 */
507c478bd9Sstevel@tonic-gate #define	CV_WAITERS_MASK		(CV_MAX_WAITERS - 1)
517c478bd9Sstevel@tonic-gate 
527c478bd9Sstevel@tonic-gate /*
537c478bd9Sstevel@tonic-gate  * Threads don't "own" condition variables.
547c478bd9Sstevel@tonic-gate  */
557c478bd9Sstevel@tonic-gate /* ARGSUSED */
567c478bd9Sstevel@tonic-gate static kthread_t *
577c478bd9Sstevel@tonic-gate cv_owner(void *cvp)
587c478bd9Sstevel@tonic-gate {
597c478bd9Sstevel@tonic-gate 	return (NULL);
607c478bd9Sstevel@tonic-gate }
617c478bd9Sstevel@tonic-gate 
627c478bd9Sstevel@tonic-gate /*
637c478bd9Sstevel@tonic-gate  * Unsleep a thread that's blocked on a condition variable.
647c478bd9Sstevel@tonic-gate  */
657c478bd9Sstevel@tonic-gate static void
667c478bd9Sstevel@tonic-gate cv_unsleep(kthread_t *t)
677c478bd9Sstevel@tonic-gate {
687c478bd9Sstevel@tonic-gate 	condvar_impl_t *cvp = (condvar_impl_t *)t->t_wchan;
697c478bd9Sstevel@tonic-gate 	sleepq_head_t *sqh = SQHASH(cvp);
707c478bd9Sstevel@tonic-gate 
717c478bd9Sstevel@tonic-gate 	ASSERT(THREAD_LOCK_HELD(t));
727c478bd9Sstevel@tonic-gate 
737c478bd9Sstevel@tonic-gate 	if (cvp == NULL)
74903a11ebSrh 		panic("cv_unsleep: thread %p not on sleepq %p",
75903a11ebSrh 		    (void *)t, (void *)sqh);
762db6c79fSstevel 	DTRACE_SCHED1(wakeup, kthread_t *, t);
777c478bd9Sstevel@tonic-gate 	sleepq_unsleep(t);
787c478bd9Sstevel@tonic-gate 	if (cvp->cv_waiters != CV_MAX_WAITERS)
797c478bd9Sstevel@tonic-gate 		cvp->cv_waiters--;
807c478bd9Sstevel@tonic-gate 	disp_lock_exit_high(&sqh->sq_lock);
817c478bd9Sstevel@tonic-gate 	CL_SETRUN(t);
827c478bd9Sstevel@tonic-gate }
837c478bd9Sstevel@tonic-gate 
847c478bd9Sstevel@tonic-gate /*
857c478bd9Sstevel@tonic-gate  * Change the priority of a thread that's blocked on a condition variable.
867c478bd9Sstevel@tonic-gate  */
877c478bd9Sstevel@tonic-gate static void
887c478bd9Sstevel@tonic-gate cv_change_pri(kthread_t *t, pri_t pri, pri_t *t_prip)
897c478bd9Sstevel@tonic-gate {
907c478bd9Sstevel@tonic-gate 	condvar_impl_t *cvp = (condvar_impl_t *)t->t_wchan;
917c478bd9Sstevel@tonic-gate 	sleepq_t *sqp = t->t_sleepq;
927c478bd9Sstevel@tonic-gate 
937c478bd9Sstevel@tonic-gate 	ASSERT(THREAD_LOCK_HELD(t));
947c478bd9Sstevel@tonic-gate 	ASSERT(&SQHASH(cvp)->sq_queue == sqp);
957c478bd9Sstevel@tonic-gate 
967c478bd9Sstevel@tonic-gate 	if (cvp == NULL)
97903a11ebSrh 		panic("cv_change_pri: %p not on sleep queue", (void *)t);
987c478bd9Sstevel@tonic-gate 	sleepq_dequeue(t);
997c478bd9Sstevel@tonic-gate 	*t_prip = pri;
1007c478bd9Sstevel@tonic-gate 	sleepq_insert(sqp, t);
1017c478bd9Sstevel@tonic-gate }
1027c478bd9Sstevel@tonic-gate 
1037c478bd9Sstevel@tonic-gate /*
1047c478bd9Sstevel@tonic-gate  * The sobj_ops vector exports a set of functions needed when a thread
1057c478bd9Sstevel@tonic-gate  * is asleep on a synchronization object of this type.
1067c478bd9Sstevel@tonic-gate  */
1077c478bd9Sstevel@tonic-gate static sobj_ops_t cv_sobj_ops = {
1087c478bd9Sstevel@tonic-gate 	SOBJ_CV, cv_owner, cv_unsleep, cv_change_pri
1097c478bd9Sstevel@tonic-gate };
1107c478bd9Sstevel@tonic-gate 
1117c478bd9Sstevel@tonic-gate /* ARGSUSED */
1127c478bd9Sstevel@tonic-gate void
1137c478bd9Sstevel@tonic-gate cv_init(kcondvar_t *cvp, char *name, kcv_type_t type, void *arg)
1147c478bd9Sstevel@tonic-gate {
1157c478bd9Sstevel@tonic-gate 	((condvar_impl_t *)cvp)->cv_waiters = 0;
1167c478bd9Sstevel@tonic-gate }
1177c478bd9Sstevel@tonic-gate 
1187c478bd9Sstevel@tonic-gate /*
1197c478bd9Sstevel@tonic-gate  * cv_destroy is not currently needed, but is part of the DDI.
1207c478bd9Sstevel@tonic-gate  * This is in case cv_init ever needs to allocate something for a cv.
1217c478bd9Sstevel@tonic-gate  */
1227c478bd9Sstevel@tonic-gate /* ARGSUSED */
1237c478bd9Sstevel@tonic-gate void
1247c478bd9Sstevel@tonic-gate cv_destroy(kcondvar_t *cvp)
1257c478bd9Sstevel@tonic-gate {
1267c478bd9Sstevel@tonic-gate 	ASSERT((((condvar_impl_t *)cvp)->cv_waiters & CV_WAITERS_MASK) == 0);
1277c478bd9Sstevel@tonic-gate }
1287c478bd9Sstevel@tonic-gate 
1297c478bd9Sstevel@tonic-gate /*
1307c478bd9Sstevel@tonic-gate  * The cv_block() function blocks a thread on a condition variable
1317c478bd9Sstevel@tonic-gate  * by putting it in a hashed sleep queue associated with the
1327c478bd9Sstevel@tonic-gate  * synchronization object.
1337c478bd9Sstevel@tonic-gate  *
1347c478bd9Sstevel@tonic-gate  * Threads are taken off the hashed sleep queues via calls to
1357c478bd9Sstevel@tonic-gate  * cv_signal(), cv_broadcast(), or cv_unsleep().
1367c478bd9Sstevel@tonic-gate  */
1377c478bd9Sstevel@tonic-gate static void
1387c478bd9Sstevel@tonic-gate cv_block(condvar_impl_t *cvp)
1397c478bd9Sstevel@tonic-gate {
1407c478bd9Sstevel@tonic-gate 	kthread_t *t = curthread;
1417c478bd9Sstevel@tonic-gate 	klwp_t *lwp = ttolwp(t);
1427c478bd9Sstevel@tonic-gate 	sleepq_head_t *sqh;
1437c478bd9Sstevel@tonic-gate 
1447c478bd9Sstevel@tonic-gate 	ASSERT(THREAD_LOCK_HELD(t));
1457c478bd9Sstevel@tonic-gate 	ASSERT(t != CPU->cpu_idle_thread);
1467c478bd9Sstevel@tonic-gate 	ASSERT(CPU_ON_INTR(CPU) == 0);
1477c478bd9Sstevel@tonic-gate 	ASSERT(t->t_wchan0 == NULL && t->t_wchan == NULL);
1487c478bd9Sstevel@tonic-gate 	ASSERT(t->t_state == TS_ONPROC);
1497c478bd9Sstevel@tonic-gate 
1507c478bd9Sstevel@tonic-gate 	t->t_schedflag &= ~TS_SIGNALLED;
1517c478bd9Sstevel@tonic-gate 	CL_SLEEP(t);			/* assign kernel priority */
1527c478bd9Sstevel@tonic-gate 	t->t_wchan = (caddr_t)cvp;
1537c478bd9Sstevel@tonic-gate 	t->t_sobj_ops = &cv_sobj_ops;
1547c478bd9Sstevel@tonic-gate 	DTRACE_SCHED(sleep);
1557c478bd9Sstevel@tonic-gate 
1567c478bd9Sstevel@tonic-gate 	/*
1577c478bd9Sstevel@tonic-gate 	 * The check for t_intr is to avoid doing the
1587c478bd9Sstevel@tonic-gate 	 * account for an interrupt thread on the still-pinned
1597c478bd9Sstevel@tonic-gate 	 * lwp's statistics.
1607c478bd9Sstevel@tonic-gate 	 */
1617c478bd9Sstevel@tonic-gate 	if (lwp != NULL && t->t_intr == NULL) {
1627c478bd9Sstevel@tonic-gate 		lwp->lwp_ru.nvcsw++;
1637c478bd9Sstevel@tonic-gate 		(void) new_mstate(t, LMS_SLEEP);
1647c478bd9Sstevel@tonic-gate 	}
1657c478bd9Sstevel@tonic-gate 
1667c478bd9Sstevel@tonic-gate 	sqh = SQHASH(cvp);
1677c478bd9Sstevel@tonic-gate 	disp_lock_enter_high(&sqh->sq_lock);
1687c478bd9Sstevel@tonic-gate 	if (cvp->cv_waiters < CV_MAX_WAITERS)
1697c478bd9Sstevel@tonic-gate 		cvp->cv_waiters++;
1707c478bd9Sstevel@tonic-gate 	ASSERT(cvp->cv_waiters <= CV_MAX_WAITERS);
1717c478bd9Sstevel@tonic-gate 	THREAD_SLEEP(t, &sqh->sq_lock);
1727c478bd9Sstevel@tonic-gate 	sleepq_insert(&sqh->sq_queue, t);
1737c478bd9Sstevel@tonic-gate 	/*
1747c478bd9Sstevel@tonic-gate 	 * THREAD_SLEEP() moves curthread->t_lockp to point to the
1757c478bd9Sstevel@tonic-gate 	 * lock sqh->sq_lock. This lock is later released by the caller
1767c478bd9Sstevel@tonic-gate 	 * when it calls thread_unlock() on curthread.
1777c478bd9Sstevel@tonic-gate 	 */
1787c478bd9Sstevel@tonic-gate }
1797c478bd9Sstevel@tonic-gate 
1807c478bd9Sstevel@tonic-gate #define	cv_block_sig(t, cvp)	\
1817c478bd9Sstevel@tonic-gate 	{ (t)->t_flag |= T_WAKEABLE; cv_block(cvp); }
1827c478bd9Sstevel@tonic-gate 
1837c478bd9Sstevel@tonic-gate /*
1847c478bd9Sstevel@tonic-gate  * Block on the indicated condition variable and release the
1857c478bd9Sstevel@tonic-gate  * associated kmutex while blocked.
1867c478bd9Sstevel@tonic-gate  */
1877c478bd9Sstevel@tonic-gate void
1887c478bd9Sstevel@tonic-gate cv_wait(kcondvar_t *cvp, kmutex_t *mp)
1897c478bd9Sstevel@tonic-gate {
1907c478bd9Sstevel@tonic-gate 	if (panicstr)
1917c478bd9Sstevel@tonic-gate 		return;
1928a3feaaaSJerry Gilliam 	ASSERT(!quiesce_active);
1937c478bd9Sstevel@tonic-gate 
1947c478bd9Sstevel@tonic-gate 	ASSERT(curthread->t_schedflag & TS_DONT_SWAP);
1957c478bd9Sstevel@tonic-gate 	thread_lock(curthread);			/* lock the thread */
1967c478bd9Sstevel@tonic-gate 	cv_block((condvar_impl_t *)cvp);
1977c478bd9Sstevel@tonic-gate 	thread_unlock_nopreempt(curthread);	/* unlock the waiters field */
1987c478bd9Sstevel@tonic-gate 	mutex_exit(mp);
1997c478bd9Sstevel@tonic-gate 	swtch();
2007c478bd9Sstevel@tonic-gate 	mutex_enter(mp);
2017c478bd9Sstevel@tonic-gate }
2027c478bd9Sstevel@tonic-gate 
20387a18d3fSMadhavan Venkataraman static void
20487a18d3fSMadhavan Venkataraman cv_wakeup(void *arg)
20587a18d3fSMadhavan Venkataraman {
20687a18d3fSMadhavan Venkataraman 	kthread_t *t = arg;
20787a18d3fSMadhavan Venkataraman 
20887a18d3fSMadhavan Venkataraman 	/*
20987a18d3fSMadhavan Venkataraman 	 * This mutex is acquired and released in order to make sure that
21087a18d3fSMadhavan Venkataraman 	 * the wakeup does not happen before the block itself happens.
21187a18d3fSMadhavan Venkataraman 	 */
212454ab202SMadhavan Venkataraman 	mutex_enter(&t->t_wait_mutex);
213454ab202SMadhavan Venkataraman 	mutex_exit(&t->t_wait_mutex);
21487a18d3fSMadhavan Venkataraman 	setrun(t);
21587a18d3fSMadhavan Venkataraman }
21687a18d3fSMadhavan Venkataraman 
2177c478bd9Sstevel@tonic-gate /*
2187c478bd9Sstevel@tonic-gate  * Same as cv_wait except the thread will unblock at 'tim'
2197c478bd9Sstevel@tonic-gate  * (an absolute time) if it hasn't already unblocked.
2207c478bd9Sstevel@tonic-gate  *
2217c478bd9Sstevel@tonic-gate  * Returns the amount of time left from the original 'tim' value
2227c478bd9Sstevel@tonic-gate  * when it was unblocked.
2237c478bd9Sstevel@tonic-gate  */
2247c478bd9Sstevel@tonic-gate clock_t
2257c478bd9Sstevel@tonic-gate cv_timedwait(kcondvar_t *cvp, kmutex_t *mp, clock_t tim)
22651b32bddSMadhavan Venkataraman {
22751b32bddSMadhavan Venkataraman 	hrtime_t hrtim;
228d3d50737SRafael Vanoni 	clock_t now = ddi_get_lbolt();
22951b32bddSMadhavan Venkataraman 
230d3d50737SRafael Vanoni 	if (tim <= now)
23151b32bddSMadhavan Venkataraman 		return (-1);
23251b32bddSMadhavan Venkataraman 
233d3d50737SRafael Vanoni 	hrtim = TICK_TO_NSEC(tim - now);
23451b32bddSMadhavan Venkataraman 	return (cv_timedwait_hires(cvp, mp, hrtim, nsec_per_tick, 0));
23551b32bddSMadhavan Venkataraman }
23651b32bddSMadhavan Venkataraman 
237d3d50737SRafael Vanoni /*
238d3d50737SRafael Vanoni  * Same as cv_timedwait() except that the third argument is a relative
239d3d50737SRafael Vanoni  * timeout value, as opposed to an absolute one. There is also a fourth
240d3d50737SRafael Vanoni  * argument that specifies how accurately the timeout must be implemented.
241d3d50737SRafael Vanoni  */
242d3d50737SRafael Vanoni clock_t
243d3d50737SRafael Vanoni cv_reltimedwait(kcondvar_t *cvp, kmutex_t *mp, clock_t delta, time_res_t res)
244d3d50737SRafael Vanoni {
245d3d50737SRafael Vanoni 	hrtime_t exp;
246d3d50737SRafael Vanoni 
247d3d50737SRafael Vanoni 	ASSERT(TIME_RES_VALID(res));
248d3d50737SRafael Vanoni 
249d3d50737SRafael Vanoni 	if (delta <= 0)
250d3d50737SRafael Vanoni 		return (-1);
251d3d50737SRafael Vanoni 
252d3d50737SRafael Vanoni 	if ((exp = TICK_TO_NSEC(delta)) < 0)
253d3d50737SRafael Vanoni 		exp = CY_INFINITY;
254d3d50737SRafael Vanoni 
255d3d50737SRafael Vanoni 	return (cv_timedwait_hires(cvp, mp, exp, time_res[res], 0));
256d3d50737SRafael Vanoni }
257d3d50737SRafael Vanoni 
25851b32bddSMadhavan Venkataraman clock_t
25951b32bddSMadhavan Venkataraman cv_timedwait_hires(kcondvar_t *cvp, kmutex_t *mp, hrtime_t tim,
26051b32bddSMadhavan Venkataraman     hrtime_t res, int flag)
2617c478bd9Sstevel@tonic-gate {
2627c478bd9Sstevel@tonic-gate 	kthread_t *t = curthread;
26387a18d3fSMadhavan Venkataraman 	callout_id_t id;
2647c478bd9Sstevel@tonic-gate 	clock_t timeleft;
26551b32bddSMadhavan Venkataraman 	hrtime_t limit;
2667c478bd9Sstevel@tonic-gate 	int signalled;
2677c478bd9Sstevel@tonic-gate 
2687c478bd9Sstevel@tonic-gate 	if (panicstr)
2697c478bd9Sstevel@tonic-gate 		return (-1);
2708a3feaaaSJerry Gilliam 	ASSERT(!quiesce_active);
2717c478bd9Sstevel@tonic-gate 
27251b32bddSMadhavan Venkataraman 	limit = (flag & CALLOUT_FLAG_ABSOLUTE) ? gethrtime() : 0;
27351b32bddSMadhavan Venkataraman 	if (tim <= limit)
2747c478bd9Sstevel@tonic-gate 		return (-1);
275454ab202SMadhavan Venkataraman 	mutex_enter(&t->t_wait_mutex);
27651b32bddSMadhavan Venkataraman 	id = timeout_generic(CALLOUT_REALTIME, (void (*)(void *))cv_wakeup, t,
27751b32bddSMadhavan Venkataraman 	    tim, res, flag);
2787c478bd9Sstevel@tonic-gate 	thread_lock(t);		/* lock the thread */
2797c478bd9Sstevel@tonic-gate 	cv_block((condvar_impl_t *)cvp);
2807c478bd9Sstevel@tonic-gate 	thread_unlock_nopreempt(t);
281454ab202SMadhavan Venkataraman 	mutex_exit(&t->t_wait_mutex);
2827c478bd9Sstevel@tonic-gate 	mutex_exit(mp);
2837c478bd9Sstevel@tonic-gate 	swtch();
2847c478bd9Sstevel@tonic-gate 	signalled = (t->t_schedflag & TS_SIGNALLED);
2857c478bd9Sstevel@tonic-gate 	/*
2867c478bd9Sstevel@tonic-gate 	 * Get the time left. untimeout() returns -1 if the timeout has
2877c478bd9Sstevel@tonic-gate 	 * occured or the time remaining.  If the time remaining is zero,
2887c478bd9Sstevel@tonic-gate 	 * the timeout has occured between when we were awoken and
2897c478bd9Sstevel@tonic-gate 	 * we called untimeout.  We will treat this as if the timeout
2907c478bd9Sstevel@tonic-gate 	 * has occured and set timeleft to -1.
2917c478bd9Sstevel@tonic-gate 	 */
292454ab202SMadhavan Venkataraman 	timeleft = untimeout_default(id, 0);
2937c478bd9Sstevel@tonic-gate 	mutex_enter(mp);
2947c478bd9Sstevel@tonic-gate 	if (timeleft <= 0) {
2957c478bd9Sstevel@tonic-gate 		timeleft = -1;
2967c478bd9Sstevel@tonic-gate 		if (signalled)	/* avoid consuming the cv_signal() */
2977c478bd9Sstevel@tonic-gate 			cv_signal(cvp);
2987c478bd9Sstevel@tonic-gate 	}
2997c478bd9Sstevel@tonic-gate 	return (timeleft);
3007c478bd9Sstevel@tonic-gate }
3017c478bd9Sstevel@tonic-gate 
3027c478bd9Sstevel@tonic-gate int
3037c478bd9Sstevel@tonic-gate cv_wait_sig(kcondvar_t *cvp, kmutex_t *mp)
3047c478bd9Sstevel@tonic-gate {
3057c478bd9Sstevel@tonic-gate 	kthread_t *t = curthread;
3067c478bd9Sstevel@tonic-gate 	proc_t *p = ttoproc(t);
3077c478bd9Sstevel@tonic-gate 	klwp_t *lwp = ttolwp(t);
308a574db85Sraf 	int cancel_pending;
3097c478bd9Sstevel@tonic-gate 	int rval = 1;
3107c478bd9Sstevel@tonic-gate 	int signalled = 0;
3117c478bd9Sstevel@tonic-gate 
3127c478bd9Sstevel@tonic-gate 	if (panicstr)
3137c478bd9Sstevel@tonic-gate 		return (rval);
3148a3feaaaSJerry Gilliam 	ASSERT(!quiesce_active);
3157c478bd9Sstevel@tonic-gate 
3167c478bd9Sstevel@tonic-gate 	/*
317*35a5a358SJonathan Adams 	 * Threads in system processes don't process signals.  This is
318*35a5a358SJonathan Adams 	 * true both for standard threads of system processes and for
319*35a5a358SJonathan Adams 	 * interrupt threads which have borrowed their pinned thread's LWP.
3207c478bd9Sstevel@tonic-gate 	 */
321*35a5a358SJonathan Adams 	if (lwp == NULL || (p->p_flag & SSYS)) {
3227c478bd9Sstevel@tonic-gate 		cv_wait(cvp, mp);
3237c478bd9Sstevel@tonic-gate 		return (rval);
3247c478bd9Sstevel@tonic-gate 	}
325*35a5a358SJonathan Adams 	ASSERT(t->t_intr == NULL);
3267c478bd9Sstevel@tonic-gate 
3277c478bd9Sstevel@tonic-gate 	ASSERT(curthread->t_schedflag & TS_DONT_SWAP);
328a574db85Sraf 	cancel_pending = schedctl_cancel_pending();
3297c478bd9Sstevel@tonic-gate 	lwp->lwp_asleep = 1;
3307c478bd9Sstevel@tonic-gate 	lwp->lwp_sysabort = 0;
3317c478bd9Sstevel@tonic-gate 	thread_lock(t);
3327c478bd9Sstevel@tonic-gate 	cv_block_sig(t, (condvar_impl_t *)cvp);
3337c478bd9Sstevel@tonic-gate 	thread_unlock_nopreempt(t);
3347c478bd9Sstevel@tonic-gate 	mutex_exit(mp);
335a574db85Sraf 	if (ISSIG(t, JUSTLOOKING) || MUSTRETURN(p, t) || cancel_pending)
3367c478bd9Sstevel@tonic-gate 		setrun(t);
3377c478bd9Sstevel@tonic-gate 	/* ASSERT(no locks are held) */
3387c478bd9Sstevel@tonic-gate 	swtch();
3397c478bd9Sstevel@tonic-gate 	signalled = (t->t_schedflag & TS_SIGNALLED);
3407c478bd9Sstevel@tonic-gate 	t->t_flag &= ~T_WAKEABLE;
3417c478bd9Sstevel@tonic-gate 	mutex_enter(mp);
3427c478bd9Sstevel@tonic-gate 	if (ISSIG_PENDING(t, lwp, p)) {
3437c478bd9Sstevel@tonic-gate 		mutex_exit(mp);
3447c478bd9Sstevel@tonic-gate 		if (issig(FORREAL))
3457c478bd9Sstevel@tonic-gate 			rval = 0;
3467c478bd9Sstevel@tonic-gate 		mutex_enter(mp);
3477c478bd9Sstevel@tonic-gate 	}
3487c478bd9Sstevel@tonic-gate 	if (lwp->lwp_sysabort || MUSTRETURN(p, t))
3497c478bd9Sstevel@tonic-gate 		rval = 0;
350a574db85Sraf 	if (rval != 0 && cancel_pending) {
351a574db85Sraf 		schedctl_cancel_eintr();
352a574db85Sraf 		rval = 0;
353a574db85Sraf 	}
3547c478bd9Sstevel@tonic-gate 	lwp->lwp_asleep = 0;
3557c478bd9Sstevel@tonic-gate 	lwp->lwp_sysabort = 0;
3567c478bd9Sstevel@tonic-gate 	if (rval == 0 && signalled)	/* avoid consuming the cv_signal() */
3577c478bd9Sstevel@tonic-gate 		cv_signal(cvp);
3587c478bd9Sstevel@tonic-gate 	return (rval);
3597c478bd9Sstevel@tonic-gate }
3607c478bd9Sstevel@tonic-gate 
36187a18d3fSMadhavan Venkataraman static clock_t
36251b32bddSMadhavan Venkataraman cv_timedwait_sig_hires(kcondvar_t *cvp, kmutex_t *mp, hrtime_t tim,
36351b32bddSMadhavan Venkataraman     hrtime_t res, int flag)
3647c478bd9Sstevel@tonic-gate {
3657c478bd9Sstevel@tonic-gate 	kthread_t *t = curthread;
3667c478bd9Sstevel@tonic-gate 	proc_t *p = ttoproc(t);
3677c478bd9Sstevel@tonic-gate 	klwp_t *lwp = ttolwp(t);
368a574db85Sraf 	int cancel_pending = 0;
36987a18d3fSMadhavan Venkataraman 	callout_id_t id;
3707c478bd9Sstevel@tonic-gate 	clock_t rval = 1;
37151b32bddSMadhavan Venkataraman 	hrtime_t limit;
3727c478bd9Sstevel@tonic-gate 	int signalled = 0;
3737c478bd9Sstevel@tonic-gate 
3747c478bd9Sstevel@tonic-gate 	if (panicstr)
3757c478bd9Sstevel@tonic-gate 		return (rval);
3768a3feaaaSJerry Gilliam 	ASSERT(!quiesce_active);
3777c478bd9Sstevel@tonic-gate 
3787c478bd9Sstevel@tonic-gate 	/*
379*35a5a358SJonathan Adams 	 * Threads in system processes don't process signals.  This is
380*35a5a358SJonathan Adams 	 * true both for standard threads of system processes and for
381*35a5a358SJonathan Adams 	 * interrupt threads which have borrowed their pinned thread's LWP.
3827c478bd9Sstevel@tonic-gate 	 */
383*35a5a358SJonathan Adams 	if (lwp == NULL || (p->p_flag & SSYS))
38451b32bddSMadhavan Venkataraman 		return (cv_timedwait_hires(cvp, mp, tim, res, flag));
385*35a5a358SJonathan Adams 	ASSERT(t->t_intr == NULL);
3867c478bd9Sstevel@tonic-gate 
3877c478bd9Sstevel@tonic-gate 	/*
38851b32bddSMadhavan Venkataraman 	 * If tim is less than or equal to current hrtime, then the timeout
3897c478bd9Sstevel@tonic-gate 	 * has already occured.  So just check to see if there is a signal
3907c478bd9Sstevel@tonic-gate 	 * pending.  If so return 0 indicating that there is a signal pending.
3917c478bd9Sstevel@tonic-gate 	 * Else return -1 indicating that the timeout occured. No need to
3927c478bd9Sstevel@tonic-gate 	 * wait on anything.
3937c478bd9Sstevel@tonic-gate 	 */
39451b32bddSMadhavan Venkataraman 	limit = (flag & CALLOUT_FLAG_ABSOLUTE) ? gethrtime() : 0;
39551b32bddSMadhavan Venkataraman 	if (tim <= limit) {
3967c478bd9Sstevel@tonic-gate 		lwp->lwp_asleep = 1;
3977c478bd9Sstevel@tonic-gate 		lwp->lwp_sysabort = 0;
3987c478bd9Sstevel@tonic-gate 		rval = -1;
3997c478bd9Sstevel@tonic-gate 		goto out;
4007c478bd9Sstevel@tonic-gate 	}
4017c478bd9Sstevel@tonic-gate 
4027c478bd9Sstevel@tonic-gate 	/*
4037c478bd9Sstevel@tonic-gate 	 * Set the timeout and wait.
4047c478bd9Sstevel@tonic-gate 	 */
405a574db85Sraf 	cancel_pending = schedctl_cancel_pending();
406454ab202SMadhavan Venkataraman 	mutex_enter(&t->t_wait_mutex);
40787a18d3fSMadhavan Venkataraman 	id = timeout_generic(CALLOUT_REALTIME, (void (*)(void *))cv_wakeup, t,
40851b32bddSMadhavan Venkataraman 	    tim, res, flag);
4097c478bd9Sstevel@tonic-gate 	lwp->lwp_asleep = 1;
4107c478bd9Sstevel@tonic-gate 	lwp->lwp_sysabort = 0;
4117c478bd9Sstevel@tonic-gate 	thread_lock(t);
4127c478bd9Sstevel@tonic-gate 	cv_block_sig(t, (condvar_impl_t *)cvp);
4137c478bd9Sstevel@tonic-gate 	thread_unlock_nopreempt(t);
414454ab202SMadhavan Venkataraman 	mutex_exit(&t->t_wait_mutex);
4157c478bd9Sstevel@tonic-gate 	mutex_exit(mp);
41687a18d3fSMadhavan Venkataraman 	if (ISSIG(t, JUSTLOOKING) || MUSTRETURN(p, t) || cancel_pending)
4177c478bd9Sstevel@tonic-gate 		setrun(t);
4187c478bd9Sstevel@tonic-gate 	/* ASSERT(no locks are held) */
4197c478bd9Sstevel@tonic-gate 	swtch();
4207c478bd9Sstevel@tonic-gate 	signalled = (t->t_schedflag & TS_SIGNALLED);
4217c478bd9Sstevel@tonic-gate 	t->t_flag &= ~T_WAKEABLE;
4227c478bd9Sstevel@tonic-gate 
4237c478bd9Sstevel@tonic-gate 	/*
4247c478bd9Sstevel@tonic-gate 	 * Untimeout the thread.  untimeout() returns -1 if the timeout has
4257c478bd9Sstevel@tonic-gate 	 * occured or the time remaining.  If the time remaining is zero,
4267c478bd9Sstevel@tonic-gate 	 * the timeout has occured between when we were awoken and
4277c478bd9Sstevel@tonic-gate 	 * we called untimeout.  We will treat this as if the timeout
4287c478bd9Sstevel@tonic-gate 	 * has occured and set rval to -1.
4297c478bd9Sstevel@tonic-gate 	 */
430454ab202SMadhavan Venkataraman 	rval = untimeout_default(id, 0);
43187a18d3fSMadhavan Venkataraman 	mutex_enter(mp);
4327c478bd9Sstevel@tonic-gate 	if (rval <= 0)
4337c478bd9Sstevel@tonic-gate 		rval = -1;
4347c478bd9Sstevel@tonic-gate 
4357c478bd9Sstevel@tonic-gate 	/*
4367c478bd9Sstevel@tonic-gate 	 * Check to see if a signal is pending.  If so, regardless of whether
4377c478bd9Sstevel@tonic-gate 	 * or not we were awoken due to the signal, the signal is now pending
4387c478bd9Sstevel@tonic-gate 	 * and a return of 0 has the highest priority.
4397c478bd9Sstevel@tonic-gate 	 */
4407c478bd9Sstevel@tonic-gate out:
4417c478bd9Sstevel@tonic-gate 	if (ISSIG_PENDING(t, lwp, p)) {
4427c478bd9Sstevel@tonic-gate 		mutex_exit(mp);
4437c478bd9Sstevel@tonic-gate 		if (issig(FORREAL))
4447c478bd9Sstevel@tonic-gate 			rval = 0;
4457c478bd9Sstevel@tonic-gate 		mutex_enter(mp);
4467c478bd9Sstevel@tonic-gate 	}
4477c478bd9Sstevel@tonic-gate 	if (lwp->lwp_sysabort || MUSTRETURN(p, t))
4487c478bd9Sstevel@tonic-gate 		rval = 0;
449a574db85Sraf 	if (rval != 0 && cancel_pending) {
450a574db85Sraf 		schedctl_cancel_eintr();
451a574db85Sraf 		rval = 0;
452a574db85Sraf 	}
4537c478bd9Sstevel@tonic-gate 	lwp->lwp_asleep = 0;
4547c478bd9Sstevel@tonic-gate 	lwp->lwp_sysabort = 0;
4557c478bd9Sstevel@tonic-gate 	if (rval <= 0 && signalled)	/* avoid consuming the cv_signal() */
4567c478bd9Sstevel@tonic-gate 		cv_signal(cvp);
4577c478bd9Sstevel@tonic-gate 	return (rval);
4587c478bd9Sstevel@tonic-gate }
4597c478bd9Sstevel@tonic-gate 
46087a18d3fSMadhavan Venkataraman /*
46187a18d3fSMadhavan Venkataraman  * Returns:
46287a18d3fSMadhavan Venkataraman  * 	Function result in order of precedence:
46387a18d3fSMadhavan Venkataraman  *		 0 if a signal was received
46487a18d3fSMadhavan Venkataraman  *		-1 if timeout occured
46587a18d3fSMadhavan Venkataraman  *		>0 if awakened via cv_signal() or cv_broadcast().
46687a18d3fSMadhavan Venkataraman  *		   (returns time remaining)
46787a18d3fSMadhavan Venkataraman  *
46887a18d3fSMadhavan Venkataraman  * cv_timedwait_sig() is now part of the DDI.
46987a18d3fSMadhavan Venkataraman  *
47051b32bddSMadhavan Venkataraman  * This function is now just a wrapper for cv_timedwait_sig_hires().
47187a18d3fSMadhavan Venkataraman  */
47287a18d3fSMadhavan Venkataraman clock_t
47387a18d3fSMadhavan Venkataraman cv_timedwait_sig(kcondvar_t *cvp, kmutex_t *mp, clock_t tim)
47487a18d3fSMadhavan Venkataraman {
47551b32bddSMadhavan Venkataraman 	hrtime_t hrtim;
47651b32bddSMadhavan Venkataraman 
477d3d50737SRafael Vanoni 	hrtim = TICK_TO_NSEC(tim - ddi_get_lbolt());
47851b32bddSMadhavan Venkataraman 	return (cv_timedwait_sig_hires(cvp, mp, hrtim, nsec_per_tick, 0));
47987a18d3fSMadhavan Venkataraman }
48087a18d3fSMadhavan Venkataraman 
481d3d50737SRafael Vanoni /*
482d3d50737SRafael Vanoni  * Same as cv_timedwait_sig() except that the third argument is a relative
483d3d50737SRafael Vanoni  * timeout value, as opposed to an absolute one. There is also a fourth
484d3d50737SRafael Vanoni  * argument that specifies how accurately the timeout must be implemented.
485d3d50737SRafael Vanoni  */
486d3d50737SRafael Vanoni clock_t
487d3d50737SRafael Vanoni cv_reltimedwait_sig(kcondvar_t *cvp, kmutex_t *mp, clock_t delta,
488d3d50737SRafael Vanoni     time_res_t res)
489d3d50737SRafael Vanoni {
490d3d50737SRafael Vanoni 	hrtime_t exp;
491d3d50737SRafael Vanoni 
492d3d50737SRafael Vanoni 	ASSERT(TIME_RES_VALID(res));
493d3d50737SRafael Vanoni 
494d3d50737SRafael Vanoni 	if ((exp = TICK_TO_NSEC(delta)) < 0)
495d3d50737SRafael Vanoni 		exp = CY_INFINITY;
496d3d50737SRafael Vanoni 
497d3d50737SRafael Vanoni 	return (cv_timedwait_sig_hires(cvp, mp, exp, time_res[res], 0));
498d3d50737SRafael Vanoni }
499d3d50737SRafael Vanoni 
5007c478bd9Sstevel@tonic-gate /*
5017c478bd9Sstevel@tonic-gate  * Like cv_wait_sig_swap but allows the caller to indicate (with a
5027c478bd9Sstevel@tonic-gate  * non-NULL sigret) that they will take care of signalling the cv
5037c478bd9Sstevel@tonic-gate  * after wakeup, if necessary.  This is a vile hack that should only
5047c478bd9Sstevel@tonic-gate  * be used when no other option is available; almost all callers
5057c478bd9Sstevel@tonic-gate  * should just use cv_wait_sig_swap (which takes care of the cv_signal
5067c478bd9Sstevel@tonic-gate  * stuff automatically) instead.
5077c478bd9Sstevel@tonic-gate  */
5087c478bd9Sstevel@tonic-gate int
5097c478bd9Sstevel@tonic-gate cv_wait_sig_swap_core(kcondvar_t *cvp, kmutex_t *mp, int *sigret)
5107c478bd9Sstevel@tonic-gate {
5117c478bd9Sstevel@tonic-gate 	kthread_t *t = curthread;
5127c478bd9Sstevel@tonic-gate 	proc_t *p = ttoproc(t);
5137c478bd9Sstevel@tonic-gate 	klwp_t *lwp = ttolwp(t);
514a574db85Sraf 	int cancel_pending;
5157c478bd9Sstevel@tonic-gate 	int rval = 1;
5167c478bd9Sstevel@tonic-gate 	int signalled = 0;
5177c478bd9Sstevel@tonic-gate 
5187c478bd9Sstevel@tonic-gate 	if (panicstr)
5197c478bd9Sstevel@tonic-gate 		return (rval);
5207c478bd9Sstevel@tonic-gate 
5217c478bd9Sstevel@tonic-gate 	/*
522*35a5a358SJonathan Adams 	 * Threads in system processes don't process signals.  This is
523*35a5a358SJonathan Adams 	 * true both for standard threads of system processes and for
524*35a5a358SJonathan Adams 	 * interrupt threads which have borrowed their pinned thread's LWP.
5257c478bd9Sstevel@tonic-gate 	 */
526*35a5a358SJonathan Adams 	if (lwp == NULL || (p->p_flag & SSYS)) {
5277c478bd9Sstevel@tonic-gate 		cv_wait(cvp, mp);
5287c478bd9Sstevel@tonic-gate 		return (rval);
5297c478bd9Sstevel@tonic-gate 	}
530*35a5a358SJonathan Adams 	ASSERT(t->t_intr == NULL);
5317c478bd9Sstevel@tonic-gate 
532a574db85Sraf 	cancel_pending = schedctl_cancel_pending();
5337c478bd9Sstevel@tonic-gate 	lwp->lwp_asleep = 1;
5347c478bd9Sstevel@tonic-gate 	lwp->lwp_sysabort = 0;
5357c478bd9Sstevel@tonic-gate 	thread_lock(t);
5367c478bd9Sstevel@tonic-gate 	t->t_kpri_req = 0;	/* don't need kernel priority */
5377c478bd9Sstevel@tonic-gate 	cv_block_sig(t, (condvar_impl_t *)cvp);
5387c478bd9Sstevel@tonic-gate 	/* I can be swapped now */
5397c478bd9Sstevel@tonic-gate 	curthread->t_schedflag &= ~TS_DONT_SWAP;
5407c478bd9Sstevel@tonic-gate 	thread_unlock_nopreempt(t);
5417c478bd9Sstevel@tonic-gate 	mutex_exit(mp);
542a574db85Sraf 	if (ISSIG(t, JUSTLOOKING) || MUSTRETURN(p, t) || cancel_pending)
5437c478bd9Sstevel@tonic-gate 		setrun(t);
5447c478bd9Sstevel@tonic-gate 	/* ASSERT(no locks are held) */
5457c478bd9Sstevel@tonic-gate 	swtch();
5467c478bd9Sstevel@tonic-gate 	signalled = (t->t_schedflag & TS_SIGNALLED);
5477c478bd9Sstevel@tonic-gate 	t->t_flag &= ~T_WAKEABLE;
5487c478bd9Sstevel@tonic-gate 	/* TS_DONT_SWAP set by disp() */
5497c478bd9Sstevel@tonic-gate 	ASSERT(curthread->t_schedflag & TS_DONT_SWAP);
5507c478bd9Sstevel@tonic-gate 	mutex_enter(mp);
5517c478bd9Sstevel@tonic-gate 	if (ISSIG_PENDING(t, lwp, p)) {
5527c478bd9Sstevel@tonic-gate 		mutex_exit(mp);
5537c478bd9Sstevel@tonic-gate 		if (issig(FORREAL))
5547c478bd9Sstevel@tonic-gate 			rval = 0;
5557c478bd9Sstevel@tonic-gate 		mutex_enter(mp);
5567c478bd9Sstevel@tonic-gate 	}
5577c478bd9Sstevel@tonic-gate 	if (lwp->lwp_sysabort || MUSTRETURN(p, t))
5587c478bd9Sstevel@tonic-gate 		rval = 0;
559a574db85Sraf 	if (rval != 0 && cancel_pending) {
560a574db85Sraf 		schedctl_cancel_eintr();
561a574db85Sraf 		rval = 0;
562a574db85Sraf 	}
5637c478bd9Sstevel@tonic-gate 	lwp->lwp_asleep = 0;
5647c478bd9Sstevel@tonic-gate 	lwp->lwp_sysabort = 0;
5657c478bd9Sstevel@tonic-gate 	if (rval == 0) {
5667c478bd9Sstevel@tonic-gate 		if (sigret != NULL)
5677c478bd9Sstevel@tonic-gate 			*sigret = signalled;	/* just tell the caller */
5687c478bd9Sstevel@tonic-gate 		else if (signalled)
5697c478bd9Sstevel@tonic-gate 			cv_signal(cvp);	/* avoid consuming the cv_signal() */
5707c478bd9Sstevel@tonic-gate 	}
5717c478bd9Sstevel@tonic-gate 	return (rval);
5727c478bd9Sstevel@tonic-gate }
5737c478bd9Sstevel@tonic-gate 
5747c478bd9Sstevel@tonic-gate /*
5757c478bd9Sstevel@tonic-gate  * Same as cv_wait_sig but the thread can be swapped out while waiting.
5767c478bd9Sstevel@tonic-gate  * This should only be used when we know we aren't holding any locks.
5777c478bd9Sstevel@tonic-gate  */
5787c478bd9Sstevel@tonic-gate int
5797c478bd9Sstevel@tonic-gate cv_wait_sig_swap(kcondvar_t *cvp, kmutex_t *mp)
5807c478bd9Sstevel@tonic-gate {
5817c478bd9Sstevel@tonic-gate 	return (cv_wait_sig_swap_core(cvp, mp, NULL));
5827c478bd9Sstevel@tonic-gate }
5837c478bd9Sstevel@tonic-gate 
5847c478bd9Sstevel@tonic-gate void
5857c478bd9Sstevel@tonic-gate cv_signal(kcondvar_t *cvp)
5867c478bd9Sstevel@tonic-gate {
5877c478bd9Sstevel@tonic-gate 	condvar_impl_t *cp = (condvar_impl_t *)cvp;
5887c478bd9Sstevel@tonic-gate 
5897c478bd9Sstevel@tonic-gate 	/* make sure the cv_waiters field looks sane */
5907c478bd9Sstevel@tonic-gate 	ASSERT(cp->cv_waiters <= CV_MAX_WAITERS);
5917c478bd9Sstevel@tonic-gate 	if (cp->cv_waiters > 0) {
5927c478bd9Sstevel@tonic-gate 		sleepq_head_t *sqh = SQHASH(cp);
5937c478bd9Sstevel@tonic-gate 		disp_lock_enter(&sqh->sq_lock);
5947c478bd9Sstevel@tonic-gate 		ASSERT(CPU_ON_INTR(CPU) == 0);
5957c478bd9Sstevel@tonic-gate 		if (cp->cv_waiters & CV_WAITERS_MASK) {
5967c478bd9Sstevel@tonic-gate 			kthread_t *t;
5977c478bd9Sstevel@tonic-gate 			cp->cv_waiters--;
5987c478bd9Sstevel@tonic-gate 			t = sleepq_wakeone_chan(&sqh->sq_queue, cp);
5997c478bd9Sstevel@tonic-gate 			/*
6007c478bd9Sstevel@tonic-gate 			 * If cv_waiters is non-zero (and less than
6017c478bd9Sstevel@tonic-gate 			 * CV_MAX_WAITERS) there should be a thread
6027c478bd9Sstevel@tonic-gate 			 * in the queue.
6037c478bd9Sstevel@tonic-gate 			 */
6047c478bd9Sstevel@tonic-gate 			ASSERT(t != NULL);
6057c478bd9Sstevel@tonic-gate 		} else if (sleepq_wakeone_chan(&sqh->sq_queue, cp) == NULL) {
6067c478bd9Sstevel@tonic-gate 			cp->cv_waiters = 0;
6077c478bd9Sstevel@tonic-gate 		}
6087c478bd9Sstevel@tonic-gate 		disp_lock_exit(&sqh->sq_lock);
6097c478bd9Sstevel@tonic-gate 	}
6107c478bd9Sstevel@tonic-gate }
6117c478bd9Sstevel@tonic-gate 
6127c478bd9Sstevel@tonic-gate void
6137c478bd9Sstevel@tonic-gate cv_broadcast(kcondvar_t *cvp)
6147c478bd9Sstevel@tonic-gate {
6157c478bd9Sstevel@tonic-gate 	condvar_impl_t *cp = (condvar_impl_t *)cvp;
6167c478bd9Sstevel@tonic-gate 
6177c478bd9Sstevel@tonic-gate 	/* make sure the cv_waiters field looks sane */
6187c478bd9Sstevel@tonic-gate 	ASSERT(cp->cv_waiters <= CV_MAX_WAITERS);
6197c478bd9Sstevel@tonic-gate 	if (cp->cv_waiters > 0) {
6207c478bd9Sstevel@tonic-gate 		sleepq_head_t *sqh = SQHASH(cp);
6217c478bd9Sstevel@tonic-gate 		disp_lock_enter(&sqh->sq_lock);
6227c478bd9Sstevel@tonic-gate 		ASSERT(CPU_ON_INTR(CPU) == 0);
6237c478bd9Sstevel@tonic-gate 		sleepq_wakeall_chan(&sqh->sq_queue, cp);
6247c478bd9Sstevel@tonic-gate 		cp->cv_waiters = 0;
6257c478bd9Sstevel@tonic-gate 		disp_lock_exit(&sqh->sq_lock);
6267c478bd9Sstevel@tonic-gate 	}
6277c478bd9Sstevel@tonic-gate }
6287c478bd9Sstevel@tonic-gate 
6297c478bd9Sstevel@tonic-gate /*
6307c478bd9Sstevel@tonic-gate  * Same as cv_wait(), but wakes up (after wakeup_time milliseconds) to check
6317c478bd9Sstevel@tonic-gate  * for requests to stop, like cv_wait_sig() but without dealing with signals.
6327c478bd9Sstevel@tonic-gate  * This is a horrible kludge.  It is evil.  It is vile.  It is swill.
6337c478bd9Sstevel@tonic-gate  * If your code has to call this function then your code is the same.
6347c478bd9Sstevel@tonic-gate  */
6357c478bd9Sstevel@tonic-gate void
6367c478bd9Sstevel@tonic-gate cv_wait_stop(kcondvar_t *cvp, kmutex_t *mp, int wakeup_time)
6377c478bd9Sstevel@tonic-gate {
6387c478bd9Sstevel@tonic-gate 	kthread_t *t = curthread;
6397c478bd9Sstevel@tonic-gate 	klwp_t *lwp = ttolwp(t);
6407c478bd9Sstevel@tonic-gate 	proc_t *p = ttoproc(t);
64187a18d3fSMadhavan Venkataraman 	callout_id_t id;
6427c478bd9Sstevel@tonic-gate 	clock_t tim;
6437c478bd9Sstevel@tonic-gate 
6447c478bd9Sstevel@tonic-gate 	if (panicstr)
6457c478bd9Sstevel@tonic-gate 		return;
6467c478bd9Sstevel@tonic-gate 
6477c478bd9Sstevel@tonic-gate 	/*
648*35a5a358SJonathan Adams 	 * Threads in system processes don't process signals.  This is
649*35a5a358SJonathan Adams 	 * true both for standard threads of system processes and for
650*35a5a358SJonathan Adams 	 * interrupt threads which have borrowed their pinned thread's LWP.
6517c478bd9Sstevel@tonic-gate 	 */
652*35a5a358SJonathan Adams 	if (lwp == NULL || (p->p_flag & SSYS)) {
6537c478bd9Sstevel@tonic-gate 		cv_wait(cvp, mp);
6547c478bd9Sstevel@tonic-gate 		return;
6557c478bd9Sstevel@tonic-gate 	}
656*35a5a358SJonathan Adams 	ASSERT(t->t_intr == NULL);
6577c478bd9Sstevel@tonic-gate 
6587c478bd9Sstevel@tonic-gate 	/*
6597c478bd9Sstevel@tonic-gate 	 * Wakeup in wakeup_time milliseconds, i.e., human time.
6607c478bd9Sstevel@tonic-gate 	 */
661d3d50737SRafael Vanoni 	tim = ddi_get_lbolt() + MSEC_TO_TICK(wakeup_time);
662454ab202SMadhavan Venkataraman 	mutex_enter(&t->t_wait_mutex);
66387a18d3fSMadhavan Venkataraman 	id = realtime_timeout_default((void (*)(void *))cv_wakeup, t,
664d3d50737SRafael Vanoni 	    tim - ddi_get_lbolt());
6657c478bd9Sstevel@tonic-gate 	thread_lock(t);			/* lock the thread */
6667c478bd9Sstevel@tonic-gate 	cv_block((condvar_impl_t *)cvp);
6677c478bd9Sstevel@tonic-gate 	thread_unlock_nopreempt(t);
668454ab202SMadhavan Venkataraman 	mutex_exit(&t->t_wait_mutex);
6697c478bd9Sstevel@tonic-gate 	mutex_exit(mp);
6707c478bd9Sstevel@tonic-gate 	/* ASSERT(no locks are held); */
6717c478bd9Sstevel@tonic-gate 	swtch();
672454ab202SMadhavan Venkataraman 	(void) untimeout_default(id, 0);
6737c478bd9Sstevel@tonic-gate 
6747c478bd9Sstevel@tonic-gate 	/*
6758548bf79Snr 	 * Check for reasons to stop, if lwp_nostop is not true.
6767c478bd9Sstevel@tonic-gate 	 * See issig_forreal() for explanations of the various stops.
6777c478bd9Sstevel@tonic-gate 	 */
6787c478bd9Sstevel@tonic-gate 	mutex_enter(&p->p_lock);
6798548bf79Snr 	while (lwp->lwp_nostop == 0 && !(p->p_flag & SEXITLWPS)) {
6807c478bd9Sstevel@tonic-gate 		/*
6817c478bd9Sstevel@tonic-gate 		 * Hold the lwp here for watchpoint manipulation.
6827c478bd9Sstevel@tonic-gate 		 */
6838548bf79Snr 		if (t->t_proc_flag & TP_PAUSE) {
6847c478bd9Sstevel@tonic-gate 			stop(PR_SUSPENDED, SUSPEND_PAUSE);
6857c478bd9Sstevel@tonic-gate 			continue;
6867c478bd9Sstevel@tonic-gate 		}
6877c478bd9Sstevel@tonic-gate 		/*
6887c478bd9Sstevel@tonic-gate 		 * System checkpoint.
6897c478bd9Sstevel@tonic-gate 		 */
6908548bf79Snr 		if (t->t_proc_flag & TP_CHKPT) {
6917c478bd9Sstevel@tonic-gate 			stop(PR_CHECKPOINT, 0);
6927c478bd9Sstevel@tonic-gate 			continue;
6937c478bd9Sstevel@tonic-gate 		}
6947c478bd9Sstevel@tonic-gate 		/*
6957c478bd9Sstevel@tonic-gate 		 * Honor fork1(), watchpoint activity (remapping a page),
6968548bf79Snr 		 * and lwp_suspend() requests.
6977c478bd9Sstevel@tonic-gate 		 */
6988548bf79Snr 		if ((p->p_flag & (SHOLDFORK1|SHOLDWATCH)) ||
6998548bf79Snr 		    (t->t_proc_flag & TP_HOLDLWP)) {
7007c478bd9Sstevel@tonic-gate 			stop(PR_SUSPENDED, SUSPEND_NORMAL);
7017c478bd9Sstevel@tonic-gate 			continue;
7027c478bd9Sstevel@tonic-gate 		}
7037c478bd9Sstevel@tonic-gate 		/*
7047c478bd9Sstevel@tonic-gate 		 * Honor /proc requested stop.
7057c478bd9Sstevel@tonic-gate 		 */
7068548bf79Snr 		if (t->t_proc_flag & TP_PRSTOP) {
7077c478bd9Sstevel@tonic-gate 			stop(PR_REQUESTED, 0);
7087c478bd9Sstevel@tonic-gate 		}
7097c478bd9Sstevel@tonic-gate 		/*
7107c478bd9Sstevel@tonic-gate 		 * If some lwp in the process has already stopped
7117c478bd9Sstevel@tonic-gate 		 * showing PR_JOBCONTROL, stop in sympathy with it.
7127c478bd9Sstevel@tonic-gate 		 */
7138548bf79Snr 		if (p->p_stopsig && t != p->p_agenttp) {
7147c478bd9Sstevel@tonic-gate 			stop(PR_JOBCONTROL, p->p_stopsig);
7157c478bd9Sstevel@tonic-gate 			continue;
7167c478bd9Sstevel@tonic-gate 		}
7177c478bd9Sstevel@tonic-gate 		break;
7187c478bd9Sstevel@tonic-gate 	}
7197c478bd9Sstevel@tonic-gate 	mutex_exit(&p->p_lock);
7207c478bd9Sstevel@tonic-gate 	mutex_enter(mp);
7217c478bd9Sstevel@tonic-gate }
7227c478bd9Sstevel@tonic-gate 
7237c478bd9Sstevel@tonic-gate /*
7247c478bd9Sstevel@tonic-gate  * Like cv_timedwait_sig(), but takes an absolute hires future time
7257c478bd9Sstevel@tonic-gate  * rather than a future time in clock ticks.  Will not return showing
7267c478bd9Sstevel@tonic-gate  * that a timeout occurred until the future time is passed.
7277c478bd9Sstevel@tonic-gate  * If 'when' is a NULL pointer, no timeout will occur.
7287c478bd9Sstevel@tonic-gate  * Returns:
72987a18d3fSMadhavan Venkataraman  * 	Function result in order of precedence:
7307c478bd9Sstevel@tonic-gate  *		 0 if a signal was received
7317c478bd9Sstevel@tonic-gate  *		-1 if timeout occured
7327c478bd9Sstevel@tonic-gate  *	        >0 if awakened via cv_signal() or cv_broadcast()
7337c478bd9Sstevel@tonic-gate  *		   or by a spurious wakeup.
7347c478bd9Sstevel@tonic-gate  *		   (might return time remaining)
7353348528fSdm  * As a special test, if someone abruptly resets the system time
7363348528fSdm  * (but not through adjtime(2); drifting of the clock is allowed and
7373348528fSdm  * expected [see timespectohz_adj()]), then we force a return of -1
7383348528fSdm  * so the caller can return a premature timeout to the calling process
7393348528fSdm  * so it can reevaluate the situation in light of the new system time.
7403348528fSdm  * (The system clock has been reset if timecheck != timechanged.)
7417c478bd9Sstevel@tonic-gate  */
7427c478bd9Sstevel@tonic-gate int
7433348528fSdm cv_waituntil_sig(kcondvar_t *cvp, kmutex_t *mp,
7443348528fSdm 	timestruc_t *when, int timecheck)
7457c478bd9Sstevel@tonic-gate {
7467c478bd9Sstevel@tonic-gate 	timestruc_t now;
747b2a1c443Svb 	timestruc_t delta;
74851b32bddSMadhavan Venkataraman 	hrtime_t interval;
7497c478bd9Sstevel@tonic-gate 	int rval;
7507c478bd9Sstevel@tonic-gate 
7517c478bd9Sstevel@tonic-gate 	if (when == NULL)
7527c478bd9Sstevel@tonic-gate 		return (cv_wait_sig_swap(cvp, mp));
7537c478bd9Sstevel@tonic-gate 
75444e59b5cSDonghai Qiao 	gethrestime(&now);
755b2a1c443Svb 	delta = *when;
756b2a1c443Svb 	timespecsub(&delta, &now);
757b2a1c443Svb 	if (delta.tv_sec < 0 || (delta.tv_sec == 0 && delta.tv_nsec == 0)) {
7587c478bd9Sstevel@tonic-gate 		/*
7597c478bd9Sstevel@tonic-gate 		 * We have already reached the absolute future time.
7607c478bd9Sstevel@tonic-gate 		 * Call cv_timedwait_sig() just to check for signals.
7617c478bd9Sstevel@tonic-gate 		 * We will return immediately with either 0 or -1.
7627c478bd9Sstevel@tonic-gate 		 */
76351b32bddSMadhavan Venkataraman 		rval = cv_timedwait_sig_hires(cvp, mp, 0, 1, 0);
7647c478bd9Sstevel@tonic-gate 	} else {
7653348528fSdm 		if (timecheck == timechanged) {
76651b32bddSMadhavan Venkataraman 			/*
76751b32bddSMadhavan Venkataraman 			 * Make sure that the interval is atleast one tick.
76851b32bddSMadhavan Venkataraman 			 * This is to prevent a user from flooding the system
76951b32bddSMadhavan Venkataraman 			 * with very small, high resolution timers.
77051b32bddSMadhavan Venkataraman 			 */
77151b32bddSMadhavan Venkataraman 			interval = ts2hrt(&delta);
77251b32bddSMadhavan Venkataraman 			if (interval < nsec_per_tick)
77351b32bddSMadhavan Venkataraman 				interval = nsec_per_tick;
77451b32bddSMadhavan Venkataraman 			rval = cv_timedwait_sig_hires(cvp, mp, interval, 1,
77587a18d3fSMadhavan Venkataraman 			    CALLOUT_FLAG_HRESTIME);
7763348528fSdm 		} else {
7773348528fSdm 			/*
7783348528fSdm 			 * Someone reset the system time;
7793348528fSdm 			 * just force an immediate timeout.
7803348528fSdm 			 */
7813348528fSdm 			rval = -1;
7823348528fSdm 		}
7833348528fSdm 		if (rval == -1 && timecheck == timechanged) {
7843348528fSdm 			/*
7853348528fSdm 			 * Even though cv_timedwait_sig() returned showing a
7863348528fSdm 			 * timeout, the future time may not have passed yet.
7873348528fSdm 			 * If not, change rval to indicate a normal wakeup.
7883348528fSdm 			 */
7893348528fSdm 			gethrestime(&now);
7903348528fSdm 			delta = *when;
7913348528fSdm 			timespecsub(&delta, &now);
7923348528fSdm 			if (delta.tv_sec > 0 || (delta.tv_sec == 0 &&
7933348528fSdm 			    delta.tv_nsec > 0))
7947c478bd9Sstevel@tonic-gate 				rval = 1;
7953348528fSdm 		}
7967c478bd9Sstevel@tonic-gate 	}
7977c478bd9Sstevel@tonic-gate 	return (rval);
7987c478bd9Sstevel@tonic-gate }
799