xref: /illumos-gate/usr/src/uts/common/os/condvar.c (revision 51b32bdd)
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 
42*51b32bddSMadhavan Venkataraman clock_t cv_timedwait_hires(kcondvar_t *, kmutex_t *, hrtime_t, hrtime_t, int);
43*51b32bddSMadhavan 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;
1927c478bd9Sstevel@tonic-gate 
1937c478bd9Sstevel@tonic-gate 	ASSERT(curthread->t_schedflag & TS_DONT_SWAP);
1947c478bd9Sstevel@tonic-gate 	thread_lock(curthread);			/* lock the thread */
1957c478bd9Sstevel@tonic-gate 	cv_block((condvar_impl_t *)cvp);
1967c478bd9Sstevel@tonic-gate 	thread_unlock_nopreempt(curthread);	/* unlock the waiters field */
1977c478bd9Sstevel@tonic-gate 	mutex_exit(mp);
1987c478bd9Sstevel@tonic-gate 	swtch();
1997c478bd9Sstevel@tonic-gate 	mutex_enter(mp);
2007c478bd9Sstevel@tonic-gate }
2017c478bd9Sstevel@tonic-gate 
20287a18d3fSMadhavan Venkataraman static void
20387a18d3fSMadhavan Venkataraman cv_wakeup(void *arg)
20487a18d3fSMadhavan Venkataraman {
20587a18d3fSMadhavan Venkataraman 	kthread_t *t = arg;
20687a18d3fSMadhavan Venkataraman 
20787a18d3fSMadhavan Venkataraman 	/*
20887a18d3fSMadhavan Venkataraman 	 * This mutex is acquired and released in order to make sure that
20987a18d3fSMadhavan Venkataraman 	 * the wakeup does not happen before the block itself happens.
21087a18d3fSMadhavan Venkataraman 	 */
211454ab202SMadhavan Venkataraman 	mutex_enter(&t->t_wait_mutex);
212454ab202SMadhavan Venkataraman 	mutex_exit(&t->t_wait_mutex);
21387a18d3fSMadhavan Venkataraman 	setrun(t);
21487a18d3fSMadhavan Venkataraman }
21587a18d3fSMadhavan Venkataraman 
2167c478bd9Sstevel@tonic-gate /*
2177c478bd9Sstevel@tonic-gate  * Same as cv_wait except the thread will unblock at 'tim'
2187c478bd9Sstevel@tonic-gate  * (an absolute time) if it hasn't already unblocked.
2197c478bd9Sstevel@tonic-gate  *
2207c478bd9Sstevel@tonic-gate  * Returns the amount of time left from the original 'tim' value
2217c478bd9Sstevel@tonic-gate  * when it was unblocked.
2227c478bd9Sstevel@tonic-gate  */
2237c478bd9Sstevel@tonic-gate clock_t
2247c478bd9Sstevel@tonic-gate cv_timedwait(kcondvar_t *cvp, kmutex_t *mp, clock_t tim)
225*51b32bddSMadhavan Venkataraman {
226*51b32bddSMadhavan Venkataraman 	hrtime_t hrtim;
227*51b32bddSMadhavan Venkataraman 
228*51b32bddSMadhavan Venkataraman 	if (tim <= lbolt)
229*51b32bddSMadhavan Venkataraman 		return (-1);
230*51b32bddSMadhavan Venkataraman 
231*51b32bddSMadhavan Venkataraman 	hrtim = TICK_TO_NSEC(tim - lbolt);
232*51b32bddSMadhavan Venkataraman 	return (cv_timedwait_hires(cvp, mp, hrtim, nsec_per_tick, 0));
233*51b32bddSMadhavan Venkataraman }
234*51b32bddSMadhavan Venkataraman 
235*51b32bddSMadhavan Venkataraman clock_t
236*51b32bddSMadhavan Venkataraman cv_timedwait_hires(kcondvar_t *cvp, kmutex_t *mp, hrtime_t tim,
237*51b32bddSMadhavan Venkataraman     hrtime_t res, int flag)
2387c478bd9Sstevel@tonic-gate {
2397c478bd9Sstevel@tonic-gate 	kthread_t *t = curthread;
24087a18d3fSMadhavan Venkataraman 	callout_id_t id;
2417c478bd9Sstevel@tonic-gate 	clock_t timeleft;
242*51b32bddSMadhavan Venkataraman 	hrtime_t limit;
2437c478bd9Sstevel@tonic-gate 	int signalled;
2447c478bd9Sstevel@tonic-gate 
2457c478bd9Sstevel@tonic-gate 	if (panicstr)
2467c478bd9Sstevel@tonic-gate 		return (-1);
2477c478bd9Sstevel@tonic-gate 
248*51b32bddSMadhavan Venkataraman 	limit = (flag & CALLOUT_FLAG_ABSOLUTE) ? gethrtime() : 0;
249*51b32bddSMadhavan Venkataraman 	if (tim <= limit)
2507c478bd9Sstevel@tonic-gate 		return (-1);
251454ab202SMadhavan Venkataraman 	mutex_enter(&t->t_wait_mutex);
252*51b32bddSMadhavan Venkataraman 	id = timeout_generic(CALLOUT_REALTIME, (void (*)(void *))cv_wakeup, t,
253*51b32bddSMadhavan Venkataraman 	    tim, res, flag);
2547c478bd9Sstevel@tonic-gate 	thread_lock(t);		/* lock the thread */
2557c478bd9Sstevel@tonic-gate 	cv_block((condvar_impl_t *)cvp);
2567c478bd9Sstevel@tonic-gate 	thread_unlock_nopreempt(t);
257454ab202SMadhavan Venkataraman 	mutex_exit(&t->t_wait_mutex);
2587c478bd9Sstevel@tonic-gate 	mutex_exit(mp);
2597c478bd9Sstevel@tonic-gate 	swtch();
2607c478bd9Sstevel@tonic-gate 	signalled = (t->t_schedflag & TS_SIGNALLED);
2617c478bd9Sstevel@tonic-gate 	/*
2627c478bd9Sstevel@tonic-gate 	 * Get the time left. untimeout() returns -1 if the timeout has
2637c478bd9Sstevel@tonic-gate 	 * occured or the time remaining.  If the time remaining is zero,
2647c478bd9Sstevel@tonic-gate 	 * the timeout has occured between when we were awoken and
2657c478bd9Sstevel@tonic-gate 	 * we called untimeout.  We will treat this as if the timeout
2667c478bd9Sstevel@tonic-gate 	 * has occured and set timeleft to -1.
2677c478bd9Sstevel@tonic-gate 	 */
268454ab202SMadhavan Venkataraman 	timeleft = untimeout_default(id, 0);
2697c478bd9Sstevel@tonic-gate 	mutex_enter(mp);
2707c478bd9Sstevel@tonic-gate 	if (timeleft <= 0) {
2717c478bd9Sstevel@tonic-gate 		timeleft = -1;
2727c478bd9Sstevel@tonic-gate 		if (signalled)	/* avoid consuming the cv_signal() */
2737c478bd9Sstevel@tonic-gate 			cv_signal(cvp);
2747c478bd9Sstevel@tonic-gate 	}
2757c478bd9Sstevel@tonic-gate 	return (timeleft);
2767c478bd9Sstevel@tonic-gate }
2777c478bd9Sstevel@tonic-gate 
2787c478bd9Sstevel@tonic-gate int
2797c478bd9Sstevel@tonic-gate cv_wait_sig(kcondvar_t *cvp, kmutex_t *mp)
2807c478bd9Sstevel@tonic-gate {
2817c478bd9Sstevel@tonic-gate 	kthread_t *t = curthread;
2827c478bd9Sstevel@tonic-gate 	proc_t *p = ttoproc(t);
2837c478bd9Sstevel@tonic-gate 	klwp_t *lwp = ttolwp(t);
284a574db85Sraf 	int cancel_pending;
2857c478bd9Sstevel@tonic-gate 	int rval = 1;
2867c478bd9Sstevel@tonic-gate 	int signalled = 0;
2877c478bd9Sstevel@tonic-gate 
2887c478bd9Sstevel@tonic-gate 	if (panicstr)
2897c478bd9Sstevel@tonic-gate 		return (rval);
2907c478bd9Sstevel@tonic-gate 
2917c478bd9Sstevel@tonic-gate 	/*
2927c478bd9Sstevel@tonic-gate 	 * The check for t_intr is to catch an interrupt thread
2937c478bd9Sstevel@tonic-gate 	 * that has not yet unpinned the thread underneath.
2947c478bd9Sstevel@tonic-gate 	 */
2957c478bd9Sstevel@tonic-gate 	if (lwp == NULL || t->t_intr) {
2967c478bd9Sstevel@tonic-gate 		cv_wait(cvp, mp);
2977c478bd9Sstevel@tonic-gate 		return (rval);
2987c478bd9Sstevel@tonic-gate 	}
2997c478bd9Sstevel@tonic-gate 
3007c478bd9Sstevel@tonic-gate 	ASSERT(curthread->t_schedflag & TS_DONT_SWAP);
301a574db85Sraf 	cancel_pending = schedctl_cancel_pending();
3027c478bd9Sstevel@tonic-gate 	lwp->lwp_asleep = 1;
3037c478bd9Sstevel@tonic-gate 	lwp->lwp_sysabort = 0;
3047c478bd9Sstevel@tonic-gate 	thread_lock(t);
3057c478bd9Sstevel@tonic-gate 	cv_block_sig(t, (condvar_impl_t *)cvp);
3067c478bd9Sstevel@tonic-gate 	thread_unlock_nopreempt(t);
3077c478bd9Sstevel@tonic-gate 	mutex_exit(mp);
308a574db85Sraf 	if (ISSIG(t, JUSTLOOKING) || MUSTRETURN(p, t) || cancel_pending)
3097c478bd9Sstevel@tonic-gate 		setrun(t);
3107c478bd9Sstevel@tonic-gate 	/* ASSERT(no locks are held) */
3117c478bd9Sstevel@tonic-gate 	swtch();
3127c478bd9Sstevel@tonic-gate 	signalled = (t->t_schedflag & TS_SIGNALLED);
3137c478bd9Sstevel@tonic-gate 	t->t_flag &= ~T_WAKEABLE;
3147c478bd9Sstevel@tonic-gate 	mutex_enter(mp);
3157c478bd9Sstevel@tonic-gate 	if (ISSIG_PENDING(t, lwp, p)) {
3167c478bd9Sstevel@tonic-gate 		mutex_exit(mp);
3177c478bd9Sstevel@tonic-gate 		if (issig(FORREAL))
3187c478bd9Sstevel@tonic-gate 			rval = 0;
3197c478bd9Sstevel@tonic-gate 		mutex_enter(mp);
3207c478bd9Sstevel@tonic-gate 	}
3217c478bd9Sstevel@tonic-gate 	if (lwp->lwp_sysabort || MUSTRETURN(p, t))
3227c478bd9Sstevel@tonic-gate 		rval = 0;
323a574db85Sraf 	if (rval != 0 && cancel_pending) {
324a574db85Sraf 		schedctl_cancel_eintr();
325a574db85Sraf 		rval = 0;
326a574db85Sraf 	}
3277c478bd9Sstevel@tonic-gate 	lwp->lwp_asleep = 0;
3287c478bd9Sstevel@tonic-gate 	lwp->lwp_sysabort = 0;
3297c478bd9Sstevel@tonic-gate 	if (rval == 0 && signalled)	/* avoid consuming the cv_signal() */
3307c478bd9Sstevel@tonic-gate 		cv_signal(cvp);
3317c478bd9Sstevel@tonic-gate 	return (rval);
3327c478bd9Sstevel@tonic-gate }
3337c478bd9Sstevel@tonic-gate 
33487a18d3fSMadhavan Venkataraman static clock_t
335*51b32bddSMadhavan Venkataraman cv_timedwait_sig_hires(kcondvar_t *cvp, kmutex_t *mp, hrtime_t tim,
336*51b32bddSMadhavan Venkataraman     hrtime_t res, int flag)
3377c478bd9Sstevel@tonic-gate {
3387c478bd9Sstevel@tonic-gate 	kthread_t *t = curthread;
3397c478bd9Sstevel@tonic-gate 	proc_t *p = ttoproc(t);
3407c478bd9Sstevel@tonic-gate 	klwp_t *lwp = ttolwp(t);
341a574db85Sraf 	int cancel_pending = 0;
34287a18d3fSMadhavan Venkataraman 	callout_id_t id;
3437c478bd9Sstevel@tonic-gate 	clock_t rval = 1;
344*51b32bddSMadhavan Venkataraman 	hrtime_t limit;
3457c478bd9Sstevel@tonic-gate 	int signalled = 0;
3467c478bd9Sstevel@tonic-gate 
3477c478bd9Sstevel@tonic-gate 	if (panicstr)
3487c478bd9Sstevel@tonic-gate 		return (rval);
3497c478bd9Sstevel@tonic-gate 
3507c478bd9Sstevel@tonic-gate 	/*
3517c478bd9Sstevel@tonic-gate 	 * If there is no lwp, then we don't need to wait for a signal.
3527c478bd9Sstevel@tonic-gate 	 * The check for t_intr is to catch an interrupt thread
3537c478bd9Sstevel@tonic-gate 	 * that has not yet unpinned the thread underneath.
3547c478bd9Sstevel@tonic-gate 	 */
3557c478bd9Sstevel@tonic-gate 	if (lwp == NULL || t->t_intr)
356*51b32bddSMadhavan Venkataraman 		return (cv_timedwait_hires(cvp, mp, tim, res, flag));
3577c478bd9Sstevel@tonic-gate 
3587c478bd9Sstevel@tonic-gate 	/*
359*51b32bddSMadhavan Venkataraman 	 * If tim is less than or equal to current hrtime, then the timeout
3607c478bd9Sstevel@tonic-gate 	 * has already occured.  So just check to see if there is a signal
3617c478bd9Sstevel@tonic-gate 	 * pending.  If so return 0 indicating that there is a signal pending.
3627c478bd9Sstevel@tonic-gate 	 * Else return -1 indicating that the timeout occured. No need to
3637c478bd9Sstevel@tonic-gate 	 * wait on anything.
3647c478bd9Sstevel@tonic-gate 	 */
365*51b32bddSMadhavan Venkataraman 	limit = (flag & CALLOUT_FLAG_ABSOLUTE) ? gethrtime() : 0;
366*51b32bddSMadhavan Venkataraman 	if (tim <= limit) {
3677c478bd9Sstevel@tonic-gate 		lwp->lwp_asleep = 1;
3687c478bd9Sstevel@tonic-gate 		lwp->lwp_sysabort = 0;
3697c478bd9Sstevel@tonic-gate 		rval = -1;
3707c478bd9Sstevel@tonic-gate 		goto out;
3717c478bd9Sstevel@tonic-gate 	}
3727c478bd9Sstevel@tonic-gate 
3737c478bd9Sstevel@tonic-gate 	/*
3747c478bd9Sstevel@tonic-gate 	 * Set the timeout and wait.
3757c478bd9Sstevel@tonic-gate 	 */
376a574db85Sraf 	cancel_pending = schedctl_cancel_pending();
377454ab202SMadhavan Venkataraman 	mutex_enter(&t->t_wait_mutex);
37887a18d3fSMadhavan Venkataraman 	id = timeout_generic(CALLOUT_REALTIME, (void (*)(void *))cv_wakeup, t,
379*51b32bddSMadhavan Venkataraman 	    tim, res, flag);
3807c478bd9Sstevel@tonic-gate 	lwp->lwp_asleep = 1;
3817c478bd9Sstevel@tonic-gate 	lwp->lwp_sysabort = 0;
3827c478bd9Sstevel@tonic-gate 	thread_lock(t);
3837c478bd9Sstevel@tonic-gate 	cv_block_sig(t, (condvar_impl_t *)cvp);
3847c478bd9Sstevel@tonic-gate 	thread_unlock_nopreempt(t);
385454ab202SMadhavan Venkataraman 	mutex_exit(&t->t_wait_mutex);
3867c478bd9Sstevel@tonic-gate 	mutex_exit(mp);
38787a18d3fSMadhavan Venkataraman 	if (ISSIG(t, JUSTLOOKING) || MUSTRETURN(p, t) || cancel_pending)
3887c478bd9Sstevel@tonic-gate 		setrun(t);
3897c478bd9Sstevel@tonic-gate 	/* ASSERT(no locks are held) */
3907c478bd9Sstevel@tonic-gate 	swtch();
3917c478bd9Sstevel@tonic-gate 	signalled = (t->t_schedflag & TS_SIGNALLED);
3927c478bd9Sstevel@tonic-gate 	t->t_flag &= ~T_WAKEABLE;
3937c478bd9Sstevel@tonic-gate 
3947c478bd9Sstevel@tonic-gate 	/*
3957c478bd9Sstevel@tonic-gate 	 * Untimeout the thread.  untimeout() returns -1 if the timeout has
3967c478bd9Sstevel@tonic-gate 	 * occured or the time remaining.  If the time remaining is zero,
3977c478bd9Sstevel@tonic-gate 	 * the timeout has occured between when we were awoken and
3987c478bd9Sstevel@tonic-gate 	 * we called untimeout.  We will treat this as if the timeout
3997c478bd9Sstevel@tonic-gate 	 * has occured and set rval to -1.
4007c478bd9Sstevel@tonic-gate 	 */
401454ab202SMadhavan Venkataraman 	rval = untimeout_default(id, 0);
40287a18d3fSMadhavan Venkataraman 	mutex_enter(mp);
4037c478bd9Sstevel@tonic-gate 	if (rval <= 0)
4047c478bd9Sstevel@tonic-gate 		rval = -1;
4057c478bd9Sstevel@tonic-gate 
4067c478bd9Sstevel@tonic-gate 	/*
4077c478bd9Sstevel@tonic-gate 	 * Check to see if a signal is pending.  If so, regardless of whether
4087c478bd9Sstevel@tonic-gate 	 * or not we were awoken due to the signal, the signal is now pending
4097c478bd9Sstevel@tonic-gate 	 * and a return of 0 has the highest priority.
4107c478bd9Sstevel@tonic-gate 	 */
4117c478bd9Sstevel@tonic-gate out:
4127c478bd9Sstevel@tonic-gate 	if (ISSIG_PENDING(t, lwp, p)) {
4137c478bd9Sstevel@tonic-gate 		mutex_exit(mp);
4147c478bd9Sstevel@tonic-gate 		if (issig(FORREAL))
4157c478bd9Sstevel@tonic-gate 			rval = 0;
4167c478bd9Sstevel@tonic-gate 		mutex_enter(mp);
4177c478bd9Sstevel@tonic-gate 	}
4187c478bd9Sstevel@tonic-gate 	if (lwp->lwp_sysabort || MUSTRETURN(p, t))
4197c478bd9Sstevel@tonic-gate 		rval = 0;
420a574db85Sraf 	if (rval != 0 && cancel_pending) {
421a574db85Sraf 		schedctl_cancel_eintr();
422a574db85Sraf 		rval = 0;
423a574db85Sraf 	}
4247c478bd9Sstevel@tonic-gate 	lwp->lwp_asleep = 0;
4257c478bd9Sstevel@tonic-gate 	lwp->lwp_sysabort = 0;
4267c478bd9Sstevel@tonic-gate 	if (rval <= 0 && signalled)	/* avoid consuming the cv_signal() */
4277c478bd9Sstevel@tonic-gate 		cv_signal(cvp);
4287c478bd9Sstevel@tonic-gate 	return (rval);
4297c478bd9Sstevel@tonic-gate }
4307c478bd9Sstevel@tonic-gate 
43187a18d3fSMadhavan Venkataraman /*
43287a18d3fSMadhavan Venkataraman  * Returns:
43387a18d3fSMadhavan Venkataraman  * 	Function result in order of precedence:
43487a18d3fSMadhavan Venkataraman  *		 0 if a signal was received
43587a18d3fSMadhavan Venkataraman  *		-1 if timeout occured
43687a18d3fSMadhavan Venkataraman  *		>0 if awakened via cv_signal() or cv_broadcast().
43787a18d3fSMadhavan Venkataraman  *		   (returns time remaining)
43887a18d3fSMadhavan Venkataraman  *
43987a18d3fSMadhavan Venkataraman  * cv_timedwait_sig() is now part of the DDI.
44087a18d3fSMadhavan Venkataraman  *
441*51b32bddSMadhavan Venkataraman  * This function is now just a wrapper for cv_timedwait_sig_hires().
44287a18d3fSMadhavan Venkataraman  */
44387a18d3fSMadhavan Venkataraman clock_t
44487a18d3fSMadhavan Venkataraman cv_timedwait_sig(kcondvar_t *cvp, kmutex_t *mp, clock_t tim)
44587a18d3fSMadhavan Venkataraman {
446*51b32bddSMadhavan Venkataraman 	hrtime_t hrtim;
447*51b32bddSMadhavan Venkataraman 
448*51b32bddSMadhavan Venkataraman 	hrtim = TICK_TO_NSEC(tim - lbolt);
449*51b32bddSMadhavan Venkataraman 	return (cv_timedwait_sig_hires(cvp, mp, hrtim, nsec_per_tick, 0));
45087a18d3fSMadhavan Venkataraman }
45187a18d3fSMadhavan Venkataraman 
4527c478bd9Sstevel@tonic-gate /*
4537c478bd9Sstevel@tonic-gate  * Like cv_wait_sig_swap but allows the caller to indicate (with a
4547c478bd9Sstevel@tonic-gate  * non-NULL sigret) that they will take care of signalling the cv
4557c478bd9Sstevel@tonic-gate  * after wakeup, if necessary.  This is a vile hack that should only
4567c478bd9Sstevel@tonic-gate  * be used when no other option is available; almost all callers
4577c478bd9Sstevel@tonic-gate  * should just use cv_wait_sig_swap (which takes care of the cv_signal
4587c478bd9Sstevel@tonic-gate  * stuff automatically) instead.
4597c478bd9Sstevel@tonic-gate  */
4607c478bd9Sstevel@tonic-gate int
4617c478bd9Sstevel@tonic-gate cv_wait_sig_swap_core(kcondvar_t *cvp, kmutex_t *mp, int *sigret)
4627c478bd9Sstevel@tonic-gate {
4637c478bd9Sstevel@tonic-gate 	kthread_t *t = curthread;
4647c478bd9Sstevel@tonic-gate 	proc_t *p = ttoproc(t);
4657c478bd9Sstevel@tonic-gate 	klwp_t *lwp = ttolwp(t);
466a574db85Sraf 	int cancel_pending;
4677c478bd9Sstevel@tonic-gate 	int rval = 1;
4687c478bd9Sstevel@tonic-gate 	int signalled = 0;
4697c478bd9Sstevel@tonic-gate 
4707c478bd9Sstevel@tonic-gate 	if (panicstr)
4717c478bd9Sstevel@tonic-gate 		return (rval);
4727c478bd9Sstevel@tonic-gate 
4737c478bd9Sstevel@tonic-gate 	/*
4747c478bd9Sstevel@tonic-gate 	 * The check for t_intr is to catch an interrupt thread
4757c478bd9Sstevel@tonic-gate 	 * that has not yet unpinned the thread underneath.
4767c478bd9Sstevel@tonic-gate 	 */
4777c478bd9Sstevel@tonic-gate 	if (lwp == NULL || t->t_intr) {
4787c478bd9Sstevel@tonic-gate 		cv_wait(cvp, mp);
4797c478bd9Sstevel@tonic-gate 		return (rval);
4807c478bd9Sstevel@tonic-gate 	}
4817c478bd9Sstevel@tonic-gate 
482a574db85Sraf 	cancel_pending = schedctl_cancel_pending();
4837c478bd9Sstevel@tonic-gate 	lwp->lwp_asleep = 1;
4847c478bd9Sstevel@tonic-gate 	lwp->lwp_sysabort = 0;
4857c478bd9Sstevel@tonic-gate 	thread_lock(t);
4867c478bd9Sstevel@tonic-gate 	t->t_kpri_req = 0;	/* don't need kernel priority */
4877c478bd9Sstevel@tonic-gate 	cv_block_sig(t, (condvar_impl_t *)cvp);
4887c478bd9Sstevel@tonic-gate 	/* I can be swapped now */
4897c478bd9Sstevel@tonic-gate 	curthread->t_schedflag &= ~TS_DONT_SWAP;
4907c478bd9Sstevel@tonic-gate 	thread_unlock_nopreempt(t);
4917c478bd9Sstevel@tonic-gate 	mutex_exit(mp);
492a574db85Sraf 	if (ISSIG(t, JUSTLOOKING) || MUSTRETURN(p, t) || cancel_pending)
4937c478bd9Sstevel@tonic-gate 		setrun(t);
4947c478bd9Sstevel@tonic-gate 	/* ASSERT(no locks are held) */
4957c478bd9Sstevel@tonic-gate 	swtch();
4967c478bd9Sstevel@tonic-gate 	signalled = (t->t_schedflag & TS_SIGNALLED);
4977c478bd9Sstevel@tonic-gate 	t->t_flag &= ~T_WAKEABLE;
4987c478bd9Sstevel@tonic-gate 	/* TS_DONT_SWAP set by disp() */
4997c478bd9Sstevel@tonic-gate 	ASSERT(curthread->t_schedflag & TS_DONT_SWAP);
5007c478bd9Sstevel@tonic-gate 	mutex_enter(mp);
5017c478bd9Sstevel@tonic-gate 	if (ISSIG_PENDING(t, lwp, p)) {
5027c478bd9Sstevel@tonic-gate 		mutex_exit(mp);
5037c478bd9Sstevel@tonic-gate 		if (issig(FORREAL))
5047c478bd9Sstevel@tonic-gate 			rval = 0;
5057c478bd9Sstevel@tonic-gate 		mutex_enter(mp);
5067c478bd9Sstevel@tonic-gate 	}
5077c478bd9Sstevel@tonic-gate 	if (lwp->lwp_sysabort || MUSTRETURN(p, t))
5087c478bd9Sstevel@tonic-gate 		rval = 0;
509a574db85Sraf 	if (rval != 0 && cancel_pending) {
510a574db85Sraf 		schedctl_cancel_eintr();
511a574db85Sraf 		rval = 0;
512a574db85Sraf 	}
5137c478bd9Sstevel@tonic-gate 	lwp->lwp_asleep = 0;
5147c478bd9Sstevel@tonic-gate 	lwp->lwp_sysabort = 0;
5157c478bd9Sstevel@tonic-gate 	if (rval == 0) {
5167c478bd9Sstevel@tonic-gate 		if (sigret != NULL)
5177c478bd9Sstevel@tonic-gate 			*sigret = signalled;	/* just tell the caller */
5187c478bd9Sstevel@tonic-gate 		else if (signalled)
5197c478bd9Sstevel@tonic-gate 			cv_signal(cvp);	/* avoid consuming the cv_signal() */
5207c478bd9Sstevel@tonic-gate 	}
5217c478bd9Sstevel@tonic-gate 	return (rval);
5227c478bd9Sstevel@tonic-gate }
5237c478bd9Sstevel@tonic-gate 
5247c478bd9Sstevel@tonic-gate /*
5257c478bd9Sstevel@tonic-gate  * Same as cv_wait_sig but the thread can be swapped out while waiting.
5267c478bd9Sstevel@tonic-gate  * This should only be used when we know we aren't holding any locks.
5277c478bd9Sstevel@tonic-gate  */
5287c478bd9Sstevel@tonic-gate int
5297c478bd9Sstevel@tonic-gate cv_wait_sig_swap(kcondvar_t *cvp, kmutex_t *mp)
5307c478bd9Sstevel@tonic-gate {
5317c478bd9Sstevel@tonic-gate 	return (cv_wait_sig_swap_core(cvp, mp, NULL));
5327c478bd9Sstevel@tonic-gate }
5337c478bd9Sstevel@tonic-gate 
5347c478bd9Sstevel@tonic-gate void
5357c478bd9Sstevel@tonic-gate cv_signal(kcondvar_t *cvp)
5367c478bd9Sstevel@tonic-gate {
5377c478bd9Sstevel@tonic-gate 	condvar_impl_t *cp = (condvar_impl_t *)cvp;
5387c478bd9Sstevel@tonic-gate 
5397c478bd9Sstevel@tonic-gate 	/* make sure the cv_waiters field looks sane */
5407c478bd9Sstevel@tonic-gate 	ASSERT(cp->cv_waiters <= CV_MAX_WAITERS);
5417c478bd9Sstevel@tonic-gate 	if (cp->cv_waiters > 0) {
5427c478bd9Sstevel@tonic-gate 		sleepq_head_t *sqh = SQHASH(cp);
5437c478bd9Sstevel@tonic-gate 		disp_lock_enter(&sqh->sq_lock);
5447c478bd9Sstevel@tonic-gate 		ASSERT(CPU_ON_INTR(CPU) == 0);
5457c478bd9Sstevel@tonic-gate 		if (cp->cv_waiters & CV_WAITERS_MASK) {
5467c478bd9Sstevel@tonic-gate 			kthread_t *t;
5477c478bd9Sstevel@tonic-gate 			cp->cv_waiters--;
5487c478bd9Sstevel@tonic-gate 			t = sleepq_wakeone_chan(&sqh->sq_queue, cp);
5497c478bd9Sstevel@tonic-gate 			/*
5507c478bd9Sstevel@tonic-gate 			 * If cv_waiters is non-zero (and less than
5517c478bd9Sstevel@tonic-gate 			 * CV_MAX_WAITERS) there should be a thread
5527c478bd9Sstevel@tonic-gate 			 * in the queue.
5537c478bd9Sstevel@tonic-gate 			 */
5547c478bd9Sstevel@tonic-gate 			ASSERT(t != NULL);
5557c478bd9Sstevel@tonic-gate 		} else if (sleepq_wakeone_chan(&sqh->sq_queue, cp) == NULL) {
5567c478bd9Sstevel@tonic-gate 			cp->cv_waiters = 0;
5577c478bd9Sstevel@tonic-gate 		}
5587c478bd9Sstevel@tonic-gate 		disp_lock_exit(&sqh->sq_lock);
5597c478bd9Sstevel@tonic-gate 	}
5607c478bd9Sstevel@tonic-gate }
5617c478bd9Sstevel@tonic-gate 
5627c478bd9Sstevel@tonic-gate void
5637c478bd9Sstevel@tonic-gate cv_broadcast(kcondvar_t *cvp)
5647c478bd9Sstevel@tonic-gate {
5657c478bd9Sstevel@tonic-gate 	condvar_impl_t *cp = (condvar_impl_t *)cvp;
5667c478bd9Sstevel@tonic-gate 
5677c478bd9Sstevel@tonic-gate 	/* make sure the cv_waiters field looks sane */
5687c478bd9Sstevel@tonic-gate 	ASSERT(cp->cv_waiters <= CV_MAX_WAITERS);
5697c478bd9Sstevel@tonic-gate 	if (cp->cv_waiters > 0) {
5707c478bd9Sstevel@tonic-gate 		sleepq_head_t *sqh = SQHASH(cp);
5717c478bd9Sstevel@tonic-gate 		disp_lock_enter(&sqh->sq_lock);
5727c478bd9Sstevel@tonic-gate 		ASSERT(CPU_ON_INTR(CPU) == 0);
5737c478bd9Sstevel@tonic-gate 		sleepq_wakeall_chan(&sqh->sq_queue, cp);
5747c478bd9Sstevel@tonic-gate 		cp->cv_waiters = 0;
5757c478bd9Sstevel@tonic-gate 		disp_lock_exit(&sqh->sq_lock);
5767c478bd9Sstevel@tonic-gate 	}
5777c478bd9Sstevel@tonic-gate }
5787c478bd9Sstevel@tonic-gate 
5797c478bd9Sstevel@tonic-gate /*
5807c478bd9Sstevel@tonic-gate  * Same as cv_wait(), but wakes up (after wakeup_time milliseconds) to check
5817c478bd9Sstevel@tonic-gate  * for requests to stop, like cv_wait_sig() but without dealing with signals.
5827c478bd9Sstevel@tonic-gate  * This is a horrible kludge.  It is evil.  It is vile.  It is swill.
5837c478bd9Sstevel@tonic-gate  * If your code has to call this function then your code is the same.
5847c478bd9Sstevel@tonic-gate  */
5857c478bd9Sstevel@tonic-gate void
5867c478bd9Sstevel@tonic-gate cv_wait_stop(kcondvar_t *cvp, kmutex_t *mp, int wakeup_time)
5877c478bd9Sstevel@tonic-gate {
5887c478bd9Sstevel@tonic-gate 	kthread_t *t = curthread;
5897c478bd9Sstevel@tonic-gate 	klwp_t *lwp = ttolwp(t);
5907c478bd9Sstevel@tonic-gate 	proc_t *p = ttoproc(t);
59187a18d3fSMadhavan Venkataraman 	callout_id_t id;
5927c478bd9Sstevel@tonic-gate 	clock_t tim;
5937c478bd9Sstevel@tonic-gate 
5947c478bd9Sstevel@tonic-gate 	if (panicstr)
5957c478bd9Sstevel@tonic-gate 		return;
5967c478bd9Sstevel@tonic-gate 
5977c478bd9Sstevel@tonic-gate 	/*
5987c478bd9Sstevel@tonic-gate 	 * If there is no lwp, then we don't need to eventually stop it
5997c478bd9Sstevel@tonic-gate 	 * The check for t_intr is to catch an interrupt thread
6007c478bd9Sstevel@tonic-gate 	 * that has not yet unpinned the thread underneath.
6017c478bd9Sstevel@tonic-gate 	 */
6027c478bd9Sstevel@tonic-gate 	if (lwp == NULL || t->t_intr) {
6037c478bd9Sstevel@tonic-gate 		cv_wait(cvp, mp);
6047c478bd9Sstevel@tonic-gate 		return;
6057c478bd9Sstevel@tonic-gate 	}
6067c478bd9Sstevel@tonic-gate 
6077c478bd9Sstevel@tonic-gate 	/*
6087c478bd9Sstevel@tonic-gate 	 * Wakeup in wakeup_time milliseconds, i.e., human time.
6097c478bd9Sstevel@tonic-gate 	 */
6107c478bd9Sstevel@tonic-gate 	tim = lbolt + MSEC_TO_TICK(wakeup_time);
611454ab202SMadhavan Venkataraman 	mutex_enter(&t->t_wait_mutex);
61287a18d3fSMadhavan Venkataraman 	id = realtime_timeout_default((void (*)(void *))cv_wakeup, t,
61387a18d3fSMadhavan Venkataraman 	    tim - lbolt);
6147c478bd9Sstevel@tonic-gate 	thread_lock(t);			/* lock the thread */
6157c478bd9Sstevel@tonic-gate 	cv_block((condvar_impl_t *)cvp);
6167c478bd9Sstevel@tonic-gate 	thread_unlock_nopreempt(t);
617454ab202SMadhavan Venkataraman 	mutex_exit(&t->t_wait_mutex);
6187c478bd9Sstevel@tonic-gate 	mutex_exit(mp);
6197c478bd9Sstevel@tonic-gate 	/* ASSERT(no locks are held); */
6207c478bd9Sstevel@tonic-gate 	swtch();
621454ab202SMadhavan Venkataraman 	(void) untimeout_default(id, 0);
6227c478bd9Sstevel@tonic-gate 
6237c478bd9Sstevel@tonic-gate 	/*
6248548bf79Snr 	 * Check for reasons to stop, if lwp_nostop is not true.
6257c478bd9Sstevel@tonic-gate 	 * See issig_forreal() for explanations of the various stops.
6267c478bd9Sstevel@tonic-gate 	 */
6277c478bd9Sstevel@tonic-gate 	mutex_enter(&p->p_lock);
6288548bf79Snr 	while (lwp->lwp_nostop == 0 && !(p->p_flag & SEXITLWPS)) {
6297c478bd9Sstevel@tonic-gate 		/*
6307c478bd9Sstevel@tonic-gate 		 * Hold the lwp here for watchpoint manipulation.
6317c478bd9Sstevel@tonic-gate 		 */
6328548bf79Snr 		if (t->t_proc_flag & TP_PAUSE) {
6337c478bd9Sstevel@tonic-gate 			stop(PR_SUSPENDED, SUSPEND_PAUSE);
6347c478bd9Sstevel@tonic-gate 			continue;
6357c478bd9Sstevel@tonic-gate 		}
6367c478bd9Sstevel@tonic-gate 		/*
6377c478bd9Sstevel@tonic-gate 		 * System checkpoint.
6387c478bd9Sstevel@tonic-gate 		 */
6398548bf79Snr 		if (t->t_proc_flag & TP_CHKPT) {
6407c478bd9Sstevel@tonic-gate 			stop(PR_CHECKPOINT, 0);
6417c478bd9Sstevel@tonic-gate 			continue;
6427c478bd9Sstevel@tonic-gate 		}
6437c478bd9Sstevel@tonic-gate 		/*
6447c478bd9Sstevel@tonic-gate 		 * Honor fork1(), watchpoint activity (remapping a page),
6458548bf79Snr 		 * and lwp_suspend() requests.
6467c478bd9Sstevel@tonic-gate 		 */
6478548bf79Snr 		if ((p->p_flag & (SHOLDFORK1|SHOLDWATCH)) ||
6488548bf79Snr 		    (t->t_proc_flag & TP_HOLDLWP)) {
6497c478bd9Sstevel@tonic-gate 			stop(PR_SUSPENDED, SUSPEND_NORMAL);
6507c478bd9Sstevel@tonic-gate 			continue;
6517c478bd9Sstevel@tonic-gate 		}
6527c478bd9Sstevel@tonic-gate 		/*
6537c478bd9Sstevel@tonic-gate 		 * Honor /proc requested stop.
6547c478bd9Sstevel@tonic-gate 		 */
6558548bf79Snr 		if (t->t_proc_flag & TP_PRSTOP) {
6567c478bd9Sstevel@tonic-gate 			stop(PR_REQUESTED, 0);
6577c478bd9Sstevel@tonic-gate 		}
6587c478bd9Sstevel@tonic-gate 		/*
6597c478bd9Sstevel@tonic-gate 		 * If some lwp in the process has already stopped
6607c478bd9Sstevel@tonic-gate 		 * showing PR_JOBCONTROL, stop in sympathy with it.
6617c478bd9Sstevel@tonic-gate 		 */
6628548bf79Snr 		if (p->p_stopsig && t != p->p_agenttp) {
6637c478bd9Sstevel@tonic-gate 			stop(PR_JOBCONTROL, p->p_stopsig);
6647c478bd9Sstevel@tonic-gate 			continue;
6657c478bd9Sstevel@tonic-gate 		}
6667c478bd9Sstevel@tonic-gate 		break;
6677c478bd9Sstevel@tonic-gate 	}
6687c478bd9Sstevel@tonic-gate 	mutex_exit(&p->p_lock);
6697c478bd9Sstevel@tonic-gate 	mutex_enter(mp);
6707c478bd9Sstevel@tonic-gate }
6717c478bd9Sstevel@tonic-gate 
6727c478bd9Sstevel@tonic-gate /*
6737c478bd9Sstevel@tonic-gate  * Like cv_timedwait_sig(), but takes an absolute hires future time
6747c478bd9Sstevel@tonic-gate  * rather than a future time in clock ticks.  Will not return showing
6757c478bd9Sstevel@tonic-gate  * that a timeout occurred until the future time is passed.
6767c478bd9Sstevel@tonic-gate  * If 'when' is a NULL pointer, no timeout will occur.
6777c478bd9Sstevel@tonic-gate  * Returns:
67887a18d3fSMadhavan Venkataraman  * 	Function result in order of precedence:
6797c478bd9Sstevel@tonic-gate  *		 0 if a signal was received
6807c478bd9Sstevel@tonic-gate  *		-1 if timeout occured
6817c478bd9Sstevel@tonic-gate  *	        >0 if awakened via cv_signal() or cv_broadcast()
6827c478bd9Sstevel@tonic-gate  *		   or by a spurious wakeup.
6837c478bd9Sstevel@tonic-gate  *		   (might return time remaining)
6843348528fSdm  * As a special test, if someone abruptly resets the system time
6853348528fSdm  * (but not through adjtime(2); drifting of the clock is allowed and
6863348528fSdm  * expected [see timespectohz_adj()]), then we force a return of -1
6873348528fSdm  * so the caller can return a premature timeout to the calling process
6883348528fSdm  * so it can reevaluate the situation in light of the new system time.
6893348528fSdm  * (The system clock has been reset if timecheck != timechanged.)
6907c478bd9Sstevel@tonic-gate  */
6917c478bd9Sstevel@tonic-gate int
6923348528fSdm cv_waituntil_sig(kcondvar_t *cvp, kmutex_t *mp,
6933348528fSdm 	timestruc_t *when, int timecheck)
6947c478bd9Sstevel@tonic-gate {
6957c478bd9Sstevel@tonic-gate 	timestruc_t now;
696b2a1c443Svb 	timestruc_t delta;
697*51b32bddSMadhavan Venkataraman 	hrtime_t interval;
6987c478bd9Sstevel@tonic-gate 	int rval;
6997c478bd9Sstevel@tonic-gate 
7007c478bd9Sstevel@tonic-gate 	if (when == NULL)
7017c478bd9Sstevel@tonic-gate 		return (cv_wait_sig_swap(cvp, mp));
7027c478bd9Sstevel@tonic-gate 
70344e59b5cSDonghai Qiao 	gethrestime(&now);
704b2a1c443Svb 	delta = *when;
705b2a1c443Svb 	timespecsub(&delta, &now);
706b2a1c443Svb 	if (delta.tv_sec < 0 || (delta.tv_sec == 0 && delta.tv_nsec == 0)) {
7077c478bd9Sstevel@tonic-gate 		/*
7087c478bd9Sstevel@tonic-gate 		 * We have already reached the absolute future time.
7097c478bd9Sstevel@tonic-gate 		 * Call cv_timedwait_sig() just to check for signals.
7107c478bd9Sstevel@tonic-gate 		 * We will return immediately with either 0 or -1.
7117c478bd9Sstevel@tonic-gate 		 */
712*51b32bddSMadhavan Venkataraman 		rval = cv_timedwait_sig_hires(cvp, mp, 0, 1, 0);
7137c478bd9Sstevel@tonic-gate 	} else {
7143348528fSdm 		if (timecheck == timechanged) {
715*51b32bddSMadhavan Venkataraman 			/*
716*51b32bddSMadhavan Venkataraman 			 * Make sure that the interval is atleast one tick.
717*51b32bddSMadhavan Venkataraman 			 * This is to prevent a user from flooding the system
718*51b32bddSMadhavan Venkataraman 			 * with very small, high resolution timers.
719*51b32bddSMadhavan Venkataraman 			 */
720*51b32bddSMadhavan Venkataraman 			interval = ts2hrt(&delta);
721*51b32bddSMadhavan Venkataraman 			if (interval < nsec_per_tick)
722*51b32bddSMadhavan Venkataraman 				interval = nsec_per_tick;
723*51b32bddSMadhavan Venkataraman 			rval = cv_timedwait_sig_hires(cvp, mp, interval, 1,
72487a18d3fSMadhavan Venkataraman 			    CALLOUT_FLAG_HRESTIME);
7253348528fSdm 		} else {
7263348528fSdm 			/*
7273348528fSdm 			 * Someone reset the system time;
7283348528fSdm 			 * just force an immediate timeout.
7293348528fSdm 			 */
7303348528fSdm 			rval = -1;
7313348528fSdm 		}
7323348528fSdm 		if (rval == -1 && timecheck == timechanged) {
7333348528fSdm 			/*
7343348528fSdm 			 * Even though cv_timedwait_sig() returned showing a
7353348528fSdm 			 * timeout, the future time may not have passed yet.
7363348528fSdm 			 * If not, change rval to indicate a normal wakeup.
7373348528fSdm 			 */
7383348528fSdm 			gethrestime(&now);
7393348528fSdm 			delta = *when;
7403348528fSdm 			timespecsub(&delta, &now);
7413348528fSdm 			if (delta.tv_sec > 0 || (delta.tv_sec == 0 &&
7423348528fSdm 			    delta.tv_nsec > 0))
7437c478bd9Sstevel@tonic-gate 				rval = 1;
7443348528fSdm 		}
7457c478bd9Sstevel@tonic-gate 	}
7467c478bd9Sstevel@tonic-gate 	return (rval);
7477c478bd9Sstevel@tonic-gate }
748