Home | History | Annotate | Line # | Download | only in kern
kern_lwp.c revision 1.40.2.16
      1  1.40.2.16        ad /*	$NetBSD: kern_lwp.c,v 1.40.2.16 2007/01/30 13:51:40 ad Exp $	*/
      2        1.2   thorpej 
      3        1.2   thorpej /*-
      4   1.40.2.9        ad  * Copyright (c) 2001, 2006, 2007 The NetBSD Foundation, Inc.
      5        1.2   thorpej  * All rights reserved.
      6        1.2   thorpej  *
      7        1.2   thorpej  * This code is derived from software contributed to The NetBSD Foundation
      8   1.40.2.2        ad  * by Nathan J. Williams, and Andrew Doran.
      9        1.2   thorpej  *
     10        1.2   thorpej  * Redistribution and use in source and binary forms, with or without
     11        1.2   thorpej  * modification, are permitted provided that the following conditions
     12        1.2   thorpej  * are met:
     13        1.2   thorpej  * 1. Redistributions of source code must retain the above copyright
     14        1.2   thorpej  *    notice, this list of conditions and the following disclaimer.
     15        1.2   thorpej  * 2. Redistributions in binary form must reproduce the above copyright
     16        1.2   thorpej  *    notice, this list of conditions and the following disclaimer in the
     17        1.2   thorpej  *    documentation and/or other materials provided with the distribution.
     18        1.2   thorpej  * 3. All advertising materials mentioning features or use of this software
     19        1.2   thorpej  *    must display the following acknowledgement:
     20        1.2   thorpej  *        This product includes software developed by the NetBSD
     21        1.2   thorpej  *        Foundation, Inc. and its contributors.
     22        1.2   thorpej  * 4. Neither the name of The NetBSD Foundation nor the names of its
     23        1.2   thorpej  *    contributors may be used to endorse or promote products derived
     24        1.2   thorpej  *    from this software without specific prior written permission.
     25        1.2   thorpej  *
     26        1.2   thorpej  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     27        1.2   thorpej  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     28        1.2   thorpej  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     29        1.2   thorpej  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     30        1.2   thorpej  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     31        1.2   thorpej  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     32        1.2   thorpej  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     33        1.2   thorpej  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     34        1.2   thorpej  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     35        1.2   thorpej  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     36        1.2   thorpej  * POSSIBILITY OF SUCH DAMAGE.
     37        1.2   thorpej  */
     38        1.9     lukem 
     39   1.40.2.4        ad /*
     40   1.40.2.4        ad  * Overview
     41   1.40.2.4        ad  *
     42   1.40.2.4        ad  *	Lightweight processes (LWPs) are the basic unit (or thread) of
     43   1.40.2.4        ad  *	execution within the kernel.  The core state of an LWP is described
     44   1.40.2.4        ad  *	by "struct lwp".
     45   1.40.2.4        ad  *
     46   1.40.2.4        ad  *	Each LWP is contained within a process (described by "struct proc"),
     47   1.40.2.4        ad  *	Every process contains at least one LWP, but may contain more.  The
     48   1.40.2.4        ad  *	process describes attributes shared among all of its LWPs such as a
     49   1.40.2.4        ad  *	private address space, global execution state (stopped, active,
     50   1.40.2.4        ad  *	zombie, ...), signal disposition and so on.  On a multiprocessor
     51   1.40.2.4        ad  *	machine, multiple LWPs be executing in kernel simultaneously.
     52   1.40.2.4        ad  *
     53   1.40.2.4        ad  *	Note that LWPs differ from kernel threads (kthreads) in that kernel
     54   1.40.2.4        ad  *	threads are distinct processes (system processes) with no user space
     55   1.40.2.4        ad  *	component, which themselves may contain one or more LWPs.
     56   1.40.2.4        ad  *
     57   1.40.2.4        ad  * Execution states
     58   1.40.2.4        ad  *
     59   1.40.2.4        ad  *	At any given time, an LWP has overall state that is described by
     60   1.40.2.4        ad  *	lwp::l_stat.  The states are broken into two sets below.  The first
     61   1.40.2.4        ad  *	set is guaranteed to represent the absolute, current state of the
     62   1.40.2.4        ad  *	LWP:
     63   1.40.2.4        ad  *
     64   1.40.2.4        ad  * 	LSONPROC
     65   1.40.2.4        ad  *
     66   1.40.2.4        ad  * 		On processor: the LWP is executing on a CPU, either in the
     67   1.40.2.4        ad  * 		kernel or in user space.
     68   1.40.2.4        ad  *
     69   1.40.2.4        ad  * 	LSRUN
     70   1.40.2.4        ad  *
     71   1.40.2.4        ad  * 		Runnable: the LWP is parked on a run queue, and may soon be
     72   1.40.2.4        ad  * 		chosen to run by a idle processor, or by a processor that
     73   1.40.2.4        ad  * 		has been asked to preempt a currently runnning but lower
     74   1.40.2.4        ad  * 		priority LWP.  If the LWP is not swapped in (L_INMEM == 0)
     75   1.40.2.4        ad  *		then the LWP is not on a run queue, but may be soon.
     76   1.40.2.4        ad  *
     77   1.40.2.4        ad  * 	LSIDL
     78   1.40.2.4        ad  *
     79   1.40.2.4        ad  * 		Idle: the LWP has been created but has not yet executed.
     80   1.40.2.4        ad  * 		Whoever created the new LWP can be expected to set it to
     81   1.40.2.4        ad  * 		another state shortly.
     82   1.40.2.4        ad  *
     83   1.40.2.4        ad  * 	LSSUSPENDED:
     84   1.40.2.4        ad  *
     85   1.40.2.4        ad  * 		Suspended: the LWP has had its execution suspended by
     86   1.40.2.4        ad  *		another LWP in the same process using the _lwp_suspend()
     87   1.40.2.4        ad  *		system call.  User-level LWPs also enter the suspended
     88   1.40.2.4        ad  *		state when the system is shutting down.
     89   1.40.2.4        ad  *
     90   1.40.2.4        ad  *	The second set represent a "statement of intent" on behalf of the
     91   1.40.2.4        ad  *	LWP.  The LWP may in fact be executing on a processor, may be
     92   1.40.2.4        ad  *	sleeping, idle, or on a run queue. It is expected to take the
     93   1.40.2.4        ad  *	necessary action to stop executing or become "running" again within
     94   1.40.2.4        ad  *	a short timeframe.
     95   1.40.2.4        ad  *
     96   1.40.2.6        ad  * 	LSZOMB:
     97   1.40.2.4        ad  *
     98   1.40.2.4        ad  * 		Dead: the LWP has released most of its resources and is
     99   1.40.2.4        ad  * 		about to switch away into oblivion.  When it switches away,
    100   1.40.2.6        ad  * 		its few remaining resources will be collected.
    101   1.40.2.4        ad  *
    102   1.40.2.4        ad  * 	LSSLEEP:
    103   1.40.2.4        ad  *
    104   1.40.2.4        ad  * 		Sleeping: the LWP has entered itself onto a sleep queue, and
    105   1.40.2.4        ad  * 		will switch away shortly to allow other LWPs to run on the
    106   1.40.2.4        ad  * 		CPU.
    107   1.40.2.4        ad  *
    108   1.40.2.4        ad  * 	LSSTOP:
    109   1.40.2.4        ad  *
    110   1.40.2.4        ad  * 		Stopped: the LWP has been stopped as a result of a job
    111   1.40.2.4        ad  * 		control signal, or as a result of the ptrace() interface.
    112   1.40.2.4        ad  * 		Stopped LWPs may run briefly within the kernel to handle
    113   1.40.2.4        ad  * 		signals that they receive, but will not return to user space
    114   1.40.2.4        ad  * 		until their process' state is changed away from stopped.
    115   1.40.2.4        ad  * 		Single LWPs within a process can not be set stopped
    116   1.40.2.4        ad  * 		selectively: all actions that can stop or continue LWPs
    117   1.40.2.4        ad  * 		occur at the process level.
    118   1.40.2.4        ad  *
    119   1.40.2.4        ad  * State transitions
    120   1.40.2.4        ad  *
    121   1.40.2.4        ad  *	Note that the LSSTOP and LSSUSPENDED states may only be set
    122   1.40.2.4        ad  *	when returning to user space in userret(), or when sleeping
    123   1.40.2.4        ad  *	interruptably.  Before setting those states, we try to ensure
    124   1.40.2.4        ad  *	that the LWPs will release all kernel locks that they hold,
    125   1.40.2.4        ad  *	and at a minimum try to ensure that the LWP can be set runnable
    126   1.40.2.4        ad  *	again by a signal.
    127   1.40.2.4        ad  *
    128   1.40.2.4        ad  *	LWPs may transition states in the following ways:
    129   1.40.2.4        ad  *
    130   1.40.2.4        ad  *	 RUN -------> ONPROC		ONPROC -----> RUN
    131   1.40.2.4        ad  *	            > STOPPED			    > SLEEP
    132   1.40.2.4        ad  *	            > SUSPENDED			    > STOPPED
    133   1.40.2.4        ad  *						    > SUSPENDED
    134   1.40.2.6        ad  *						    > ZOMB
    135   1.40.2.4        ad  *
    136   1.40.2.4        ad  *	 STOPPED ---> RUN		SUSPENDED --> RUN
    137   1.40.2.4        ad  *	            > SLEEP			    > SLEEP
    138   1.40.2.4        ad  *
    139   1.40.2.7        ad  *	 SLEEP -----> ONPROC		IDL --------> RUN
    140   1.40.2.7        ad  *		    > RUN		            > SUSPENDED
    141   1.40.2.7        ad  *		    > STOPPED                       > STOPPED
    142   1.40.2.4        ad  *		    > SUSPENDED
    143   1.40.2.4        ad  *
    144   1.40.2.4        ad  * Locking
    145   1.40.2.4        ad  *
    146   1.40.2.4        ad  *	The majority of fields in 'struct lwp' are covered by a single,
    147   1.40.2.4        ad  *	general spin mutex pointed to by lwp::l_mutex.  The locks covering
    148   1.40.2.4        ad  *	each field are documented in sys/lwp.h.
    149   1.40.2.4        ad  *
    150   1.40.2.4        ad  *	State transitions must be made with the LWP's general lock held.  In
    151   1.40.2.4        ad  *	a multiprocessor kernel, state transitions may cause the LWP's lock
    152   1.40.2.4        ad  *	pointer to change.  On uniprocessor kernels, most scheduler and
    153   1.40.2.4        ad  *	synchronisation objects such as sleep queues and LWPs are protected
    154   1.40.2.4        ad  *	by only one mutex (sched_mutex).  In this case, LWPs' lock pointers
    155   1.40.2.4        ad  *	will never change and will always reference sched_mutex.
    156   1.40.2.4        ad  *
    157   1.40.2.4        ad  *	Manipulation of the general lock is not performed directly, but
    158   1.40.2.4        ad  *	through calls to lwp_lock(), lwp_relock() and similar.
    159   1.40.2.4        ad  *
    160   1.40.2.4        ad  *	States and their associated locks:
    161   1.40.2.4        ad  *
    162   1.40.2.6        ad  *	LSIDL, LSZOMB
    163   1.40.2.4        ad  *
    164   1.40.2.6        ad  *		Always covered by sched_mutex.
    165   1.40.2.4        ad  *
    166   1.40.2.4        ad  *	LSONPROC, LSRUN:
    167   1.40.2.4        ad  *
    168   1.40.2.4        ad  *		Always covered by sched_mutex, which protects the run queues
    169   1.40.2.4        ad  *		and other miscellaneous items.  If the scheduler is changed
    170   1.40.2.4        ad  *		to use per-CPU run queues, this may become a per-CPU mutex.
    171   1.40.2.4        ad  *
    172   1.40.2.4        ad  *	LSSLEEP:
    173   1.40.2.4        ad  *
    174   1.40.2.4        ad  *		Covered by a mutex associated with the sleep queue that the
    175   1.40.2.4        ad  *		LWP resides on, indirectly referenced by l_sleepq->sq_mutex.
    176   1.40.2.4        ad  *
    177   1.40.2.4        ad  *	LSSTOP, LSSUSPENDED:
    178   1.40.2.4        ad  *
    179   1.40.2.4        ad  *		If the LWP was previously sleeping (l_wchan != NULL), then
    180   1.40.2.4        ad  *		l_mutex references the sleep queue mutex.  If the LWP was
    181   1.40.2.4        ad  *		runnable or on the CPU when halted, or has been removed from
    182   1.40.2.6        ad  *		the sleep queue since halted, then the mutex is sched_mutex.
    183   1.40.2.4        ad  *
    184   1.40.2.6        ad  *	The lock order is as follows:
    185   1.40.2.4        ad  *
    186   1.40.2.6        ad  *		sleepq_t::sq_mutex -> sched_mutex
    187   1.40.2.4        ad  *
    188   1.40.2.4        ad  *	Each process has an scheduler state mutex (proc::p_smutex), and a
    189   1.40.2.4        ad  *	number of counters on LWPs and their states: p_nzlwps, p_nrlwps, and
    190   1.40.2.4        ad  *	so on.  When an LWP is to be entered into or removed from one of the
    191   1.40.2.4        ad  *	following states, p_mutex must be held and the process wide counters
    192   1.40.2.4        ad  *	adjusted:
    193   1.40.2.4        ad  *
    194   1.40.2.6        ad  *		LSIDL, LSZOMB, LSSTOP, LSSUSPENDED
    195   1.40.2.4        ad  *
    196   1.40.2.4        ad  *	Note that an LWP is considered running or likely to run soon if in
    197   1.40.2.4        ad  *	one of the following states.  This affects the value of p_nrlwps:
    198   1.40.2.4        ad  *
    199   1.40.2.4        ad  *		LSRUN, LSONPROC, LSSLEEP
    200   1.40.2.4        ad  *
    201   1.40.2.4        ad  *	p_smutex does not need to be held when transitioning among these
    202   1.40.2.4        ad  *	three states.
    203   1.40.2.4        ad  */
    204   1.40.2.4        ad 
    205        1.9     lukem #include <sys/cdefs.h>
    206  1.40.2.16        ad __KERNEL_RCSID(0, "$NetBSD: kern_lwp.c,v 1.40.2.16 2007/01/30 13:51:40 ad Exp $");
    207        1.8    martin 
    208        1.8    martin #include "opt_multiprocessor.h"
    209   1.40.2.4        ad #include "opt_lockdebug.h"
    210        1.2   thorpej 
    211   1.40.2.5        ad #define _LWP_API_PRIVATE
    212   1.40.2.5        ad 
    213        1.2   thorpej #include <sys/param.h>
    214        1.2   thorpej #include <sys/systm.h>
    215        1.2   thorpej #include <sys/pool.h>
    216        1.2   thorpej #include <sys/proc.h>
    217        1.2   thorpej #include <sys/syscallargs.h>
    218       1.37        ad #include <sys/kauth.h>
    219   1.40.2.2        ad #include <sys/sleepq.h>
    220   1.40.2.2        ad #include <sys/lockdebug.h>
    221   1.40.2.6        ad #include <sys/kmem.h>
    222        1.2   thorpej 
    223        1.2   thorpej #include <uvm/uvm_extern.h>
    224        1.2   thorpej 
    225   1.40.2.1        ad struct lwplist	alllwp;
    226        1.2   thorpej 
    227  1.40.2.15        ad POOL_INIT(lwp_pool, sizeof(struct lwp), 32, 0, 0, "lwppl",
    228   1.40.2.5        ad     &pool_allocator_nointr);
    229   1.40.2.5        ad POOL_INIT(lwp_uc_pool, sizeof(ucontext_t), 0, 0, 0, "lwpucpl",
    230   1.40.2.5        ad     &pool_allocator_nointr);
    231   1.40.2.5        ad 
    232   1.40.2.5        ad static specificdata_domain_t lwp_specificdata_domain;
    233   1.40.2.5        ad 
    234        1.2   thorpej #define LWP_DEBUG
    235        1.2   thorpej 
    236        1.2   thorpej #ifdef LWP_DEBUG
    237        1.2   thorpej int lwp_debug = 0;
    238        1.2   thorpej #define DPRINTF(x) if (lwp_debug) printf x
    239        1.2   thorpej #else
    240        1.2   thorpej #define DPRINTF(x)
    241        1.2   thorpej #endif
    242        1.2   thorpej 
    243   1.40.2.5        ad void
    244   1.40.2.5        ad lwpinit(void)
    245   1.40.2.5        ad {
    246   1.40.2.5        ad 
    247   1.40.2.5        ad 	lwp_specificdata_domain = specificdata_domain_create();
    248   1.40.2.5        ad 	KASSERT(lwp_specificdata_domain != NULL);
    249   1.40.2.6        ad 	lwp_sys_init();
    250   1.40.2.5        ad }
    251   1.40.2.5        ad 
    252   1.40.2.2        ad /*
    253   1.40.2.6        ad  * Set an suspended.
    254   1.40.2.2        ad  *
    255   1.40.2.2        ad  * Must be called with p_smutex held, and the LWP locked.  Will unlock the
    256   1.40.2.2        ad  * LWP before return.
    257   1.40.2.2        ad  */
    258        1.2   thorpej int
    259   1.40.2.6        ad lwp_suspend(struct lwp *curl, struct lwp *t)
    260        1.2   thorpej {
    261   1.40.2.6        ad 	int error;
    262        1.2   thorpej 
    263   1.40.2.6        ad 	LOCK_ASSERT(mutex_owned(&t->l_proc->p_smutex));
    264   1.40.2.2        ad 	LOCK_ASSERT(lwp_locked(t, NULL));
    265        1.2   thorpej 
    266   1.40.2.2        ad 	KASSERT(curl != t || curl->l_stat == LSONPROC);
    267       1.17      manu 
    268   1.40.2.2        ad 	/*
    269   1.40.2.2        ad 	 * If the current LWP has been told to exit, we must not suspend anyone
    270   1.40.2.2        ad 	 * else or deadlock could occur.  We won't return to userspace.
    271   1.40.2.2        ad 	 */
    272   1.40.2.6        ad 	if ((curl->l_stat & (L_WEXIT | L_WCORE)) != 0) {
    273   1.40.2.6        ad 		lwp_unlock(t);
    274   1.40.2.2        ad 		return (EDEADLK);
    275   1.40.2.6        ad 	}
    276        1.2   thorpej 
    277   1.40.2.2        ad 	error = 0;
    278       1.17      manu 
    279   1.40.2.2        ad 	switch (t->l_stat) {
    280   1.40.2.2        ad 	case LSRUN:
    281   1.40.2.2        ad 	case LSONPROC:
    282   1.40.2.6        ad 		t->l_flag |= L_WSUSPEND;
    283   1.40.2.6        ad 		lwp_need_userret(t);
    284   1.40.2.6        ad 		lwp_unlock(t);
    285   1.40.2.2        ad 		break;
    286   1.40.2.4        ad 
    287   1.40.2.2        ad 	case LSSLEEP:
    288   1.40.2.6        ad 		t->l_flag |= L_WSUSPEND;
    289   1.40.2.4        ad 
    290   1.40.2.4        ad 		/*
    291   1.40.2.4        ad 		 * Kick the LWP and try to get it to the kernel boundary
    292   1.40.2.4        ad 		 * so that it will release any locks that it holds.
    293   1.40.2.4        ad 		 * setrunnable() will release the lock.
    294   1.40.2.4        ad 		 */
    295   1.40.2.6        ad 		if ((t->l_flag & L_SINTR) != 0)
    296   1.40.2.6        ad 			setrunnable(t);
    297   1.40.2.6        ad 		else
    298   1.40.2.6        ad 			lwp_unlock(t);
    299   1.40.2.6        ad 		break;
    300   1.40.2.4        ad 
    301   1.40.2.2        ad 	case LSSUSPENDED:
    302   1.40.2.6        ad 		lwp_unlock(t);
    303   1.40.2.6        ad 		break;
    304   1.40.2.6        ad 
    305   1.40.2.2        ad 	case LSSTOP:
    306   1.40.2.6        ad 		t->l_flag |= L_WSUSPEND;
    307   1.40.2.6        ad 		setrunnable(t);
    308   1.40.2.2        ad 		break;
    309   1.40.2.4        ad 
    310   1.40.2.2        ad 	case LSIDL:
    311   1.40.2.2        ad 	case LSZOMB:
    312   1.40.2.2        ad 		error = EINTR; /* It's what Solaris does..... */
    313   1.40.2.6        ad 		lwp_unlock(t);
    314   1.40.2.2        ad 		break;
    315        1.2   thorpej 	}
    316        1.2   thorpej 
    317   1.40.2.6        ad 	/*
    318   1.40.2.6        ad 	 * XXXLWP Wait for:
    319   1.40.2.6        ad 	 *
    320   1.40.2.6        ad 	 * o process exiting
    321   1.40.2.6        ad 	 * o target LWP suspended
    322   1.40.2.6        ad 	 * o target LWP not suspended and L_WSUSPEND clear
    323   1.40.2.6        ad 	 * o target LWP exited
    324   1.40.2.6        ad 	 */
    325        1.2   thorpej 
    326   1.40.2.6        ad 	 return (error);
    327        1.2   thorpej }
    328        1.2   thorpej 
    329   1.40.2.2        ad /*
    330   1.40.2.2        ad  * Restart a suspended LWP.
    331   1.40.2.2        ad  *
    332   1.40.2.2        ad  * Must be called with p_smutex held, and the LWP locked.  Will unlock the
    333   1.40.2.2        ad  * LWP before return.
    334   1.40.2.2        ad  */
    335        1.2   thorpej void
    336        1.2   thorpej lwp_continue(struct lwp *l)
    337        1.2   thorpej {
    338        1.2   thorpej 
    339   1.40.2.2        ad 	LOCK_ASSERT(mutex_owned(&l->l_proc->p_smutex));
    340   1.40.2.4        ad 	LOCK_ASSERT(lwp_locked(l, NULL));
    341   1.40.2.2        ad 
    342        1.2   thorpej 	DPRINTF(("lwp_continue of %d.%d (%s), state %d, wchan %p\n",
    343        1.2   thorpej 	    l->l_proc->p_pid, l->l_lid, l->l_proc->p_comm, l->l_stat,
    344        1.2   thorpej 	    l->l_wchan));
    345        1.2   thorpej 
    346   1.40.2.4        ad 	/* If rebooting or not suspended, then just bail out. */
    347   1.40.2.4        ad 	if ((l->l_flag & L_WREBOOT) != 0) {
    348   1.40.2.2        ad 		lwp_unlock(l);
    349        1.2   thorpej 		return;
    350   1.40.2.2        ad 	}
    351        1.2   thorpej 
    352   1.40.2.4        ad 	l->l_flag &= ~L_WSUSPEND;
    353   1.40.2.4        ad 
    354   1.40.2.4        ad 	if (l->l_stat != LSSUSPENDED) {
    355   1.40.2.2        ad 		lwp_unlock(l);
    356   1.40.2.4        ad 		return;
    357        1.2   thorpej 	}
    358   1.40.2.4        ad 
    359   1.40.2.4        ad 	/* setrunnable() will release the lock. */
    360   1.40.2.4        ad 	setrunnable(l);
    361        1.2   thorpej }
    362        1.2   thorpej 
    363   1.40.2.2        ad /*
    364   1.40.2.2        ad  * Wait for an LWP within the current process to exit.  If 'lid' is
    365   1.40.2.2        ad  * non-zero, we are waiting for a specific LWP.
    366   1.40.2.2        ad  *
    367   1.40.2.2        ad  * Must be called with p->p_smutex held.
    368   1.40.2.2        ad  */
    369        1.2   thorpej int
    370        1.2   thorpej lwp_wait1(struct lwp *l, lwpid_t lid, lwpid_t *departed, int flags)
    371        1.2   thorpej {
    372        1.2   thorpej 	struct proc *p = l->l_proc;
    373   1.40.2.2        ad 	struct lwp *l2;
    374   1.40.2.6        ad 	int nfound, error;
    375        1.2   thorpej 
    376        1.2   thorpej 	DPRINTF(("lwp_wait1: %d.%d waiting for %d.\n",
    377        1.2   thorpej 	    p->p_pid, l->l_lid, lid));
    378        1.2   thorpej 
    379   1.40.2.2        ad 	LOCK_ASSERT(mutex_owned(&p->p_smutex));
    380        1.2   thorpej 
    381   1.40.2.2        ad 	/*
    382   1.40.2.6        ad 	 * We try to check for deadlock:
    383   1.40.2.2        ad 	 *
    384   1.40.2.2        ad 	 * 1) If all other LWPs are waiting for exits or suspended.
    385   1.40.2.2        ad 	 * 2) If we are trying to wait on ourself.
    386   1.40.2.2        ad 	 *
    387   1.40.2.2        ad 	 * XXX we'd like to check for a cycle of waiting LWPs (specific LID
    388   1.40.2.2        ad 	 * waits, not any-LWP waits) and detect that sort of deadlock, but
    389   1.40.2.2        ad 	 * we don't have a good place to store the lwp that is being waited
    390   1.40.2.2        ad 	 * for. wchan is already filled with &p->p_nlwps, and putting the
    391   1.40.2.2        ad 	 * lwp address in there for deadlock tracing would require exiting
    392   1.40.2.2        ad 	 * LWPs to call wakeup on both their own address and &p->p_nlwps, to
    393   1.40.2.2        ad 	 * get threads sleeping on any LWP exiting.
    394   1.40.2.2        ad 	 */
    395   1.40.2.6        ad 	if (lid == l->l_lid)
    396   1.40.2.6        ad 		return EDEADLK;
    397   1.40.2.2        ad 
    398   1.40.2.2        ad 	p->p_nlwpwait++;
    399        1.2   thorpej 
    400   1.40.2.6        ad 	for (;;) {
    401   1.40.2.6        ad 		/*
    402   1.40.2.6        ad 		 * Avoid a race between exit1() and sigexit(): if the
    403   1.40.2.6        ad 		 * process is dumping core, then we need to bail out: call
    404   1.40.2.6        ad 		 * into lwp_userret() where we will be suspended until the
    405   1.40.2.6        ad 		 * deed is done.
    406   1.40.2.6        ad 		 */
    407   1.40.2.6        ad 		if ((p->p_sflag & PS_WCORE) != 0) {
    408   1.40.2.6        ad 			mutex_exit(&p->p_smutex);
    409   1.40.2.6        ad 			lwp_userret(l);
    410   1.40.2.6        ad #ifdef DIAGNOSTIC
    411   1.40.2.6        ad 			panic("lwp_wait1");
    412   1.40.2.6        ad #endif
    413   1.40.2.6        ad 			/* NOTREACHED */
    414   1.40.2.6        ad 		}
    415   1.40.2.2        ad 
    416   1.40.2.6        ad 		/*
    417   1.40.2.6        ad 		 * First off, drain any detached LWP that is waiting to be
    418   1.40.2.6        ad 		 * reaped.
    419   1.40.2.6        ad 		 */
    420   1.40.2.6        ad 		while ((l2 = p->p_zomblwp) != NULL) {
    421   1.40.2.6        ad 			p->p_zomblwp = NULL;
    422   1.40.2.6        ad 			lwp_free(l2, 0, 0);	/* releases proc mutex */
    423   1.40.2.6        ad 			mutex_enter(&p->p_smutex);
    424   1.40.2.6        ad 		}
    425        1.2   thorpej 
    426   1.40.2.6        ad 		/*
    427   1.40.2.6        ad 		 * Now look for an LWP to collect.  If the whole process is
    428   1.40.2.6        ad 		 * exiting, count detached LWPs as eligible to be collected,
    429   1.40.2.6        ad 		 * but don't drain them here.
    430   1.40.2.6        ad 		 */
    431   1.40.2.6        ad 		nfound = 0;
    432   1.40.2.6        ad 		LIST_FOREACH(l2, &p->p_lwps, l_sibling) {
    433   1.40.2.6        ad 			if (l2 == l || (lid != 0 && l2->l_lid != lid))
    434   1.40.2.6        ad 				continue;
    435   1.40.2.6        ad 			if ((l2->l_prflag & LPR_DETACHED) != 0) {
    436   1.40.2.6        ad 				nfound += ((flags & LWPWAIT_EXITCONTROL) != 0);
    437   1.40.2.6        ad 				continue;
    438   1.40.2.6        ad 			}
    439   1.40.2.6        ad 			nfound++;
    440        1.2   thorpej 
    441   1.40.2.6        ad 			/* No need to lock the LWP in order to see LSZOMB. */
    442   1.40.2.6        ad 			if (l2->l_stat != LSZOMB)
    443   1.40.2.6        ad 				continue;
    444   1.40.2.6        ad 
    445   1.40.2.6        ad 			if (departed)
    446   1.40.2.6        ad 				*departed = l2->l_lid;
    447   1.40.2.6        ad 			lwp_free(l2, 0, 0);
    448   1.40.2.6        ad 			mutex_enter(&p->p_smutex);
    449   1.40.2.6        ad 			p->p_nlwpwait--;
    450   1.40.2.6        ad 			return 0;
    451   1.40.2.6        ad 		}
    452   1.40.2.6        ad 
    453   1.40.2.6        ad 		if (nfound == 0) {
    454   1.40.2.6        ad 			error = ESRCH;
    455   1.40.2.6        ad 			break;
    456   1.40.2.6        ad 		}
    457   1.40.2.6        ad 		if ((flags & LWPWAIT_EXITCONTROL) != 0) {
    458   1.40.2.6        ad 			KASSERT(p->p_nlwps > 1);
    459   1.40.2.6        ad 			cv_wait(&p->p_lwpcv, &p->p_smutex);
    460   1.40.2.6        ad 			continue;
    461   1.40.2.6        ad 		}
    462   1.40.2.6        ad 		if ((p->p_sflag & PS_WEXIT) != 0 ||
    463   1.40.2.6        ad 		    p->p_nrlwps <= p->p_nlwpwait + p->p_ndlwps) {
    464   1.40.2.6        ad 			error = EDEADLK;
    465   1.40.2.6        ad 			break;
    466   1.40.2.6        ad 		}
    467   1.40.2.6        ad 		if ((error = cv_wait_sig(&p->p_lwpcv, &p->p_smutex)) != 0)
    468   1.40.2.6        ad 			break;
    469   1.40.2.6        ad 	}
    470        1.2   thorpej 
    471   1.40.2.6        ad 	p->p_nlwpwait--;
    472   1.40.2.6        ad 	return error;
    473        1.2   thorpej }
    474        1.2   thorpej 
    475   1.40.2.2        ad /*
    476   1.40.2.2        ad  * Create a new LWP within process 'p2', using LWP 'l1' as a template.
    477   1.40.2.2        ad  * The new LWP is created in state LSIDL and must be set running,
    478   1.40.2.2        ad  * suspended, or stopped by the caller.
    479   1.40.2.2        ad  */
    480        1.2   thorpej int
    481        1.2   thorpej newlwp(struct lwp *l1, struct proc *p2, vaddr_t uaddr, boolean_t inmem,
    482        1.2   thorpej     int flags, void *stack, size_t stacksize,
    483        1.2   thorpej     void (*func)(void *), void *arg, struct lwp **rnewlwpp)
    484        1.2   thorpej {
    485   1.40.2.6        ad 	struct lwp *l2, *isfree;
    486   1.40.2.6        ad 	turnstile_t *ts;
    487        1.2   thorpej 
    488   1.40.2.6        ad 	/*
    489   1.40.2.6        ad 	 * First off, reap any detached LWP waiting to be collected.
    490   1.40.2.6        ad 	 * We can re-use its LWP structure and turnstile.
    491   1.40.2.6        ad 	 */
    492   1.40.2.6        ad 	isfree = NULL;
    493   1.40.2.6        ad 	if (p2->p_zomblwp != NULL) {
    494   1.40.2.6        ad 		mutex_enter(&p2->p_smutex);
    495   1.40.2.6        ad 		if ((isfree = p2->p_zomblwp) != NULL) {
    496   1.40.2.6        ad 			p2->p_zomblwp = NULL;
    497   1.40.2.6        ad 			lwp_free(isfree, 1, 0);	/* releases proc mutex */
    498   1.40.2.6        ad 		} else
    499   1.40.2.6        ad 			mutex_exit(&p2->p_smutex);
    500   1.40.2.6        ad 	}
    501   1.40.2.6        ad 	if (isfree == NULL) {
    502   1.40.2.6        ad 		l2 = pool_get(&lwp_pool, PR_WAITOK);
    503   1.40.2.6        ad 		memset(l2, 0, sizeof(*l2));
    504   1.40.2.6        ad 		l2->l_ts = pool_cache_get(&turnstile_cache, PR_WAITOK);
    505   1.40.2.6        ad 	} else {
    506   1.40.2.6        ad 		l2 = isfree;
    507   1.40.2.6        ad 		ts = l2->l_ts;
    508   1.40.2.6        ad 		memset(l2, 0, sizeof(*l2));
    509   1.40.2.6        ad 		l2->l_ts = ts;
    510   1.40.2.6        ad 	}
    511        1.2   thorpej 
    512        1.2   thorpej 	l2->l_stat = LSIDL;
    513        1.2   thorpej 	l2->l_proc = p2;
    514   1.40.2.4        ad 	l2->l_refcnt = 1;
    515   1.40.2.6        ad 	l2->l_priority = l1->l_priority;
    516   1.40.2.6        ad 	l2->l_usrpri = l1->l_usrpri;
    517   1.40.2.4        ad 	l2->l_mutex = &sched_mutex;
    518   1.40.2.6        ad 	l2->l_cpu = l1->l_cpu;
    519        1.2   thorpej 	l2->l_flag = inmem ? L_INMEM : 0;
    520   1.40.2.6        ad 	lwp_initspecific(l2);
    521        1.2   thorpej 
    522   1.40.2.2        ad 	if (p2->p_flag & P_SYSTEM) {
    523   1.40.2.2        ad 		/*
    524   1.40.2.2        ad 		 * Mark it as a system process and not a candidate for
    525   1.40.2.2        ad 		 * swapping.
    526   1.40.2.2        ad 		 */
    527  1.40.2.11      yamt 		l2->l_flag |= L_SYSTEM;
    528   1.40.2.2        ad 	}
    529   1.40.2.2        ad 
    530       1.37        ad 	lwp_update_creds(l2);
    531        1.2   thorpej 	callout_init(&l2->l_tsleep_ch);
    532  1.40.2.12        ad 	cv_init(&l2->l_sigcv, "sigwait");
    533   1.40.2.4        ad 	l2->l_syncobj = &sched_syncobj;
    534        1.2   thorpej 
    535        1.2   thorpej 	if (rnewlwpp != NULL)
    536        1.2   thorpej 		*rnewlwpp = l2;
    537        1.2   thorpej 
    538       1.36      yamt 	l2->l_addr = UAREA_TO_USER(uaddr);
    539        1.2   thorpej 	uvm_lwp_fork(l1, l2, stack, stacksize, func,
    540        1.2   thorpej 	    (arg != NULL) ? arg : l2);
    541        1.2   thorpej 
    542   1.40.2.2        ad 	mutex_enter(&p2->p_smutex);
    543   1.40.2.3        ad 
    544   1.40.2.6        ad 	if ((flags & LWP_DETACHED) != 0) {
    545   1.40.2.6        ad 		l2->l_prflag = LPR_DETACHED;
    546   1.40.2.6        ad 		p2->p_ndlwps++;
    547   1.40.2.6        ad 	} else
    548   1.40.2.6        ad 		l2->l_prflag = 0;
    549   1.40.2.6        ad 
    550  1.40.2.16        ad 	l2->l_sigmask = l1->l_sigmask;
    551   1.40.2.6        ad 	CIRCLEQ_INIT(&l2->l_sigpend.sp_info);
    552   1.40.2.6        ad 	sigemptyset(&l2->l_sigpend.sp_set);
    553   1.40.2.6        ad 
    554        1.2   thorpej 	l2->l_lid = ++p2->p_nlwpid;
    555        1.2   thorpej 	LIST_INSERT_HEAD(&p2->p_lwps, l2, l_sibling);
    556        1.2   thorpej 	p2->p_nlwps++;
    557   1.40.2.3        ad 
    558   1.40.2.2        ad 	mutex_exit(&p2->p_smutex);
    559        1.2   thorpej 
    560   1.40.2.6        ad 	mutex_enter(&proclist_mutex);
    561        1.2   thorpej 	LIST_INSERT_HEAD(&alllwp, l2, l_list);
    562   1.40.2.6        ad 	mutex_exit(&proclist_mutex);
    563        1.2   thorpej 
    564       1.16      manu 	if (p2->p_emul->e_lwp_fork)
    565       1.16      manu 		(*p2->p_emul->e_lwp_fork)(l1, l2);
    566       1.16      manu 
    567        1.2   thorpej 	return (0);
    568        1.2   thorpej }
    569        1.2   thorpej 
    570        1.2   thorpej /*
    571   1.40.2.2        ad  * Quit the process.  This will call cpu_exit, which will call cpu_switch,
    572   1.40.2.2        ad  * so this can only be used meaningfully if you're willing to switch away.
    573        1.2   thorpej  * Calling with l!=curlwp would be weird.
    574        1.2   thorpej  */
    575   1.40.2.6        ad void
    576   1.40.2.6        ad lwp_exit(struct lwp *l)
    577        1.2   thorpej {
    578        1.2   thorpej 	struct proc *p = l->l_proc;
    579   1.40.2.6        ad 	struct lwp *l2;
    580        1.2   thorpej 
    581        1.2   thorpej 	DPRINTF(("lwp_exit: %d.%d exiting.\n", p->p_pid, l->l_lid));
    582   1.40.2.2        ad 	DPRINTF((" nlwps: %d nzlwps: %d\n", p->p_nlwps, p->p_nzlwps));
    583        1.2   thorpej 
    584   1.40.2.4        ad 	/*
    585   1.40.2.6        ad 	 * Verify that we hold no locks other than the kernel lock.
    586   1.40.2.4        ad 	 */
    587   1.40.2.6        ad #ifdef MULTIPROCESSOR
    588   1.40.2.6        ad 	LOCKDEBUG_BARRIER(&kernel_lock, 0);
    589   1.40.2.6        ad #else
    590   1.40.2.6        ad 	LOCKDEBUG_BARRIER(NULL, 0);
    591   1.40.2.6        ad #endif
    592       1.16      manu 
    593        1.2   thorpej 	/*
    594   1.40.2.2        ad 	 * If we are the last live LWP in a process, we need to exit the
    595   1.40.2.2        ad 	 * entire process.  We do so with an exit status of zero, because
    596   1.40.2.2        ad 	 * it's a "controlled" exit, and because that's what Solaris does.
    597   1.40.2.2        ad 	 *
    598   1.40.2.2        ad 	 * We are not quite a zombie yet, but for accounting purposes we
    599   1.40.2.2        ad 	 * must increment the count of zombies here.
    600   1.40.2.5        ad 	 *
    601   1.40.2.5        ad 	 * Note: the last LWP's specificdata will be deleted here.
    602        1.2   thorpej 	 */
    603   1.40.2.6        ad 	mutex_enter(&p->p_smutex);
    604   1.40.2.6        ad 	if (p->p_nlwps - p->p_nzlwps == 1) {
    605        1.2   thorpej 		DPRINTF(("lwp_exit: %d.%d calling exit1()\n",
    606        1.2   thorpej 		    p->p_pid, l->l_lid));
    607        1.2   thorpej 		exit1(l, 0);
    608       1.19  jdolecek 		/* NOTREACHED */
    609        1.2   thorpej 	}
    610   1.40.2.6        ad 	p->p_nzlwps++;
    611   1.40.2.6        ad 	mutex_exit(&p->p_smutex);
    612   1.40.2.6        ad 
    613   1.40.2.6        ad 	if (p->p_emul->e_lwp_exit)
    614   1.40.2.6        ad 		(*p->p_emul->e_lwp_exit)(l);
    615        1.2   thorpej 
    616   1.40.2.5        ad 	/* Delete the specificdata while it's still safe to sleep. */
    617   1.40.2.5        ad 	specificdata_fini(lwp_specificdata_domain, &l->l_specdataref);
    618   1.40.2.5        ad 
    619   1.40.2.5        ad 	/*
    620   1.40.2.6        ad 	 * Release our cached credentials.
    621   1.40.2.5        ad 	 */
    622   1.40.2.5        ad 	kauth_cred_free(l->l_cred);
    623   1.40.2.5        ad 
    624   1.40.2.6        ad 	/*
    625   1.40.2.6        ad 	 * Remove the LWP from the global list.
    626   1.40.2.6        ad 	 */
    627   1.40.2.6        ad 	mutex_enter(&proclist_mutex);
    628   1.40.2.6        ad 	LIST_REMOVE(l, l_list);
    629   1.40.2.6        ad 	mutex_exit(&proclist_mutex);
    630   1.40.2.6        ad 
    631   1.40.2.6        ad 	/*
    632   1.40.2.6        ad 	 * Get rid of all references to the LWP that others (e.g. procfs)
    633   1.40.2.6        ad 	 * may have, and mark the LWP as a zombie.  If the LWP is detached,
    634   1.40.2.6        ad 	 * mark it waiting for collection in the proc structure.  Note that
    635   1.40.2.6        ad 	 * before we can do that, we need to free any other dead, deatched
    636   1.40.2.6        ad 	 * LWP waiting to meet its maker.
    637   1.40.2.6        ad 	 *
    638   1.40.2.6        ad 	 * XXXSMP disable preemption.
    639   1.40.2.6        ad 	 */
    640   1.40.2.6        ad 	mutex_enter(&p->p_smutex);
    641   1.40.2.6        ad 	lwp_drainrefs(l);
    642   1.40.2.4        ad 
    643   1.40.2.6        ad 	if ((l->l_prflag & LPR_DETACHED) != 0) {
    644   1.40.2.6        ad 		while ((l2 = p->p_zomblwp) != NULL) {
    645   1.40.2.6        ad 			p->p_zomblwp = NULL;
    646   1.40.2.6        ad 			lwp_free(l2, 0, 0);	/* releases proc mutex */
    647   1.40.2.6        ad 			mutex_enter(&p->p_smutex);
    648   1.40.2.6        ad 		}
    649   1.40.2.6        ad 		p->p_zomblwp = l;
    650   1.40.2.6        ad 	}
    651   1.40.2.9        ad 
    652   1.40.2.9        ad 	/*
    653  1.40.2.10        ad 	 * Clear any private, pending signals.  If we find a pending signal
    654  1.40.2.10        ad 	 * for the process and we have been asked to check for signals, then
    655  1.40.2.10        ad 	 * we loose badly: arrange to have all other LWPs in the process check
    656  1.40.2.10        ad 	 * for signals.
    657   1.40.2.9        ad 	 */
    658   1.40.2.9        ad 	sigclear(&l->l_sigpend, NULL);
    659  1.40.2.10        ad 	if ((l->l_flag & L_PENDSIG) != 0 &&
    660  1.40.2.10        ad 	    firstsig(&p->p_sigpend.sp_set) != 0)
    661  1.40.2.10        ad 		LIST_FOREACH(l2, &p->p_lwps, l_sibling)
    662  1.40.2.10        ad 			l2->l_flag |= L_PENDSIG;
    663   1.40.2.9        ad 
    664   1.40.2.6        ad 	lwp_lock(l);
    665   1.40.2.6        ad 	l->l_stat = LSZOMB;
    666   1.40.2.6        ad 	lwp_unlock(l);
    667   1.40.2.6        ad 	p->p_nrlwps--;
    668   1.40.2.6        ad 	mutex_exit(&p->p_smutex);
    669       1.37        ad 
    670   1.40.2.2        ad 	/*
    671   1.40.2.6        ad 	 * We can no longer block.  At this point, lwp_free() may already
    672   1.40.2.6        ad 	 * be gunning for us.  On a multi-CPU system, we may be off p_lwps.
    673   1.40.2.6        ad 	 *
    674   1.40.2.6        ad 	 * Free MD LWP resources.
    675   1.40.2.2        ad 	 */
    676       1.19  jdolecek #ifndef __NO_CPU_LWP_FREE
    677       1.19  jdolecek 	cpu_lwp_free(l, 0);
    678       1.19  jdolecek #endif
    679       1.31      yamt 	pmap_deactivate(l);
    680       1.31      yamt 
    681   1.40.2.2        ad 	/*
    682   1.40.2.6        ad 	 * Release the kernel lock, signal another LWP to collect us,
    683   1.40.2.6        ad 	 * and switch away into oblivion.
    684   1.40.2.2        ad 	 */
    685   1.40.2.7        ad #ifdef notyet
    686   1.40.2.7        ad 	/* XXXSMP hold in lwp_userret() */
    687   1.40.2.7        ad 	KERNEL_UNLOCK_LAST(l);
    688   1.40.2.7        ad #else
    689   1.40.2.7        ad 	KERNEL_UNLOCK_ALL(l, NULL);
    690   1.40.2.7        ad #endif
    691   1.40.2.7        ad 
    692   1.40.2.6        ad 	cv_broadcast(&p->p_lwpcv);
    693       1.19  jdolecek 	cpu_exit(l);
    694        1.2   thorpej }
    695        1.2   thorpej 
    696       1.19  jdolecek /*
    697   1.40.2.4        ad  * We are called from cpu_exit() once it is safe to schedule the dead LWP's
    698   1.40.2.4        ad  * resources to be freed (i.e., once we've switched to the idle PCB for the
    699   1.40.2.4        ad  * current CPU).
    700       1.19  jdolecek  */
    701        1.2   thorpej void
    702        1.2   thorpej lwp_exit2(struct lwp *l)
    703        1.2   thorpej {
    704   1.40.2.6        ad 	/* XXXSMP re-enable preemption */
    705   1.40.2.6        ad }
    706   1.40.2.4        ad 
    707   1.40.2.6        ad /*
    708   1.40.2.6        ad  * Free a dead LWP's remaining resources.
    709   1.40.2.6        ad  *
    710   1.40.2.6        ad  * XXXLWP limits.
    711   1.40.2.6        ad  */
    712   1.40.2.6        ad void
    713   1.40.2.6        ad lwp_free(struct lwp *l, int recycle, int last)
    714   1.40.2.6        ad {
    715   1.40.2.6        ad 	struct proc *p = l->l_proc;
    716   1.40.2.2        ad 
    717       1.19  jdolecek 	/*
    718   1.40.2.6        ad 	 * If this was not the last LWP in the process, then adjust
    719   1.40.2.6        ad 	 * counters and unlock.
    720       1.19  jdolecek 	 */
    721   1.40.2.6        ad 	if (!last) {
    722   1.40.2.7        ad 		/*
    723   1.40.2.7        ad 		 * Add the LWP's run time to the process' base value.
    724   1.40.2.7        ad 		 * This needs to co-incide with coming off p_lwps.
    725   1.40.2.7        ad 		 */
    726   1.40.2.7        ad 		timeradd(&l->l_rtime, &p->p_rtime, &p->p_rtime);
    727   1.40.2.7        ad 
    728   1.40.2.6        ad 		LIST_REMOVE(l, l_sibling);
    729   1.40.2.6        ad 		p->p_nlwps--;
    730   1.40.2.6        ad 		p->p_nzlwps--;
    731   1.40.2.6        ad 		if ((l->l_prflag & LPR_DETACHED) != 0)
    732   1.40.2.6        ad 			p->p_ndlwps--;
    733   1.40.2.6        ad 		mutex_exit(&p->p_smutex);
    734   1.40.2.4        ad 
    735   1.40.2.6        ad #ifdef MULTIPROCESSOR
    736   1.40.2.4        ad 		/*
    737   1.40.2.6        ad 		 * In the unlikely event that the LWP is still on the CPU,
    738   1.40.2.6        ad 		 * then spin until it has switched away.  We need to release
    739   1.40.2.6        ad 		 * all locks to avoid deadlock against interrupt handlers on
    740   1.40.2.6        ad 		 * the target CPU.
    741   1.40.2.4        ad 		 */
    742   1.40.2.6        ad 		if (l->l_cpu->ci_curlwp == l) {
    743   1.40.2.6        ad 			int count;
    744   1.40.2.9        ad 			KERNEL_UNLOCK_ALL(curlwp, &count);
    745   1.40.2.6        ad 			while (l->l_cpu->ci_curlwp == l)
    746   1.40.2.6        ad 				SPINLOCK_BACKOFF_HOOK;
    747   1.40.2.9        ad 			KERNEL_LOCK(count, curlwp);
    748   1.40.2.4        ad 		}
    749   1.40.2.6        ad #endif
    750       1.19  jdolecek 	}
    751   1.40.2.6        ad 
    752   1.40.2.6        ad 	/*
    753   1.40.2.6        ad 	 * Free the LWP's turnstile and the LWP structure itself unless the
    754   1.40.2.6        ad 	 * caller wants to recycle them.
    755   1.40.2.6        ad 	 *
    756   1.40.2.6        ad 	 * We can't return turnstile0 to the pool (it didn't come from it),
    757   1.40.2.6        ad 	 * so if it comes up just drop it quietly and move on.
    758   1.40.2.6        ad 	 *
    759   1.40.2.6        ad 	 * We don't recycle the VM resources at this time.
    760   1.40.2.6        ad 	 */
    761   1.40.2.6        ad 	if (!recycle && l->l_ts != &turnstile0)
    762   1.40.2.6        ad 		pool_cache_put(&turnstile_cache, l->l_ts);
    763   1.40.2.6        ad #ifndef __NO_CPU_LWP_FREE
    764   1.40.2.6        ad 	cpu_lwp_free2(l);
    765   1.40.2.6        ad #endif
    766   1.40.2.6        ad 	uvm_lwp_exit(l);
    767  1.40.2.12        ad 	cv_destroy(&l->l_sigcv);
    768   1.40.2.6        ad 	if (!recycle)
    769   1.40.2.6        ad 		pool_put(&lwp_pool, l);
    770        1.2   thorpej }
    771        1.2   thorpej 
    772        1.2   thorpej /*
    773        1.2   thorpej  * Pick a LWP to represent the process for those operations which
    774        1.2   thorpej  * want information about a "process" that is actually associated
    775        1.2   thorpej  * with a LWP.
    776   1.40.2.2        ad  *
    777   1.40.2.6        ad  * If 'locking' is false, no locking or lock checks are performed.
    778   1.40.2.6        ad  * This is intended for use by DDB.
    779   1.40.2.6        ad  *
    780   1.40.2.6        ad  * We don't bother locking the LWP here, since code that uses this
    781   1.40.2.6        ad  * interface is broken by design and an exact match is not required.
    782        1.2   thorpej  */
    783        1.2   thorpej struct lwp *
    784   1.40.2.2        ad proc_representative_lwp(struct proc *p, int *nrlwps, int locking)
    785        1.2   thorpej {
    786        1.2   thorpej 	struct lwp *l, *onproc, *running, *sleeping, *stopped, *suspended;
    787       1.27      matt 	struct lwp *signalled;
    788   1.40.2.2        ad 	int cnt;
    789   1.40.2.2        ad 
    790   1.40.2.5        ad 	if (locking) {
    791   1.40.2.2        ad 		LOCK_ASSERT(mutex_owned(&p->p_smutex));
    792   1.40.2.5        ad 	}
    793        1.2   thorpej 
    794        1.2   thorpej 	/* Trivial case: only one LWP */
    795   1.40.2.2        ad 	if (p->p_nlwps == 1) {
    796   1.40.2.2        ad 		l = LIST_FIRST(&p->p_lwps);
    797   1.40.2.2        ad 		if (nrlwps)
    798   1.40.2.2        ad 			*nrlwps = (l->l_stat == LSONPROC || LSRUN);
    799   1.40.2.2        ad 		return l;
    800   1.40.2.2        ad 	}
    801        1.2   thorpej 
    802   1.40.2.2        ad 	cnt = 0;
    803        1.2   thorpej 	switch (p->p_stat) {
    804        1.2   thorpej 	case SSTOP:
    805        1.2   thorpej 	case SACTIVE:
    806        1.2   thorpej 		/* Pick the most live LWP */
    807        1.2   thorpej 		onproc = running = sleeping = stopped = suspended = NULL;
    808       1.27      matt 		signalled = NULL;
    809        1.2   thorpej 		LIST_FOREACH(l, &p->p_lwps, l_sibling) {
    810       1.27      matt 			if (l->l_lid == p->p_sigctx.ps_lwp)
    811       1.27      matt 				signalled = l;
    812        1.2   thorpej 			switch (l->l_stat) {
    813        1.2   thorpej 			case LSONPROC:
    814        1.2   thorpej 				onproc = l;
    815   1.40.2.2        ad 				cnt++;
    816        1.2   thorpej 				break;
    817        1.2   thorpej 			case LSRUN:
    818        1.2   thorpej 				running = l;
    819   1.40.2.2        ad 				cnt++;
    820        1.2   thorpej 				break;
    821        1.2   thorpej 			case LSSLEEP:
    822        1.2   thorpej 				sleeping = l;
    823        1.2   thorpej 				break;
    824        1.2   thorpej 			case LSSTOP:
    825        1.2   thorpej 				stopped = l;
    826        1.2   thorpej 				break;
    827        1.2   thorpej 			case LSSUSPENDED:
    828        1.2   thorpej 				suspended = l;
    829        1.2   thorpej 				break;
    830        1.2   thorpej 			}
    831        1.2   thorpej 		}
    832   1.40.2.2        ad 		if (nrlwps)
    833   1.40.2.2        ad 			*nrlwps = cnt;
    834       1.27      matt 		if (signalled)
    835   1.40.2.2        ad 			l = signalled;
    836   1.40.2.2        ad 		else if (onproc)
    837   1.40.2.2        ad 			l = onproc;
    838   1.40.2.2        ad 		else if (running)
    839   1.40.2.2        ad 			l = running;
    840   1.40.2.2        ad 		else if (sleeping)
    841   1.40.2.2        ad 			l = sleeping;
    842   1.40.2.2        ad 		else if (stopped)
    843   1.40.2.2        ad 			l = stopped;
    844   1.40.2.2        ad 		else if (suspended)
    845   1.40.2.2        ad 			l = suspended;
    846   1.40.2.2        ad 		else
    847   1.40.2.2        ad 			break;
    848   1.40.2.2        ad 		return l;
    849   1.40.2.2        ad 		if (nrlwps)
    850   1.40.2.2        ad 			*nrlwps = 0;
    851   1.40.2.2        ad 		l = LIST_FIRST(&p->p_lwps);
    852   1.40.2.2        ad 		return l;
    853        1.2   thorpej #ifdef DIAGNOSTIC
    854        1.2   thorpej 	case SIDL:
    855   1.40.2.6        ad 	case SZOMB:
    856   1.40.2.6        ad 	case SDYING:
    857   1.40.2.6        ad 	case SDEAD:
    858   1.40.2.2        ad 		if (locking)
    859   1.40.2.2        ad 			mutex_exit(&p->p_smutex);
    860        1.2   thorpej 		/* We have more than one LWP and we're in SIDL?
    861        1.2   thorpej 		 * How'd that happen?
    862        1.2   thorpej 		 */
    863   1.40.2.6        ad 		panic("Too many LWPs in idle/dying process %d (%s) stat = %d",
    864   1.40.2.6        ad 		    p->p_pid, p->p_comm, p->p_stat);
    865   1.40.2.6        ad 		break;
    866        1.2   thorpej 	default:
    867   1.40.2.2        ad 		if (locking)
    868   1.40.2.2        ad 			mutex_exit(&p->p_smutex);
    869        1.2   thorpej 		panic("Process %d (%s) in unknown state %d",
    870        1.2   thorpej 		    p->p_pid, p->p_comm, p->p_stat);
    871        1.2   thorpej #endif
    872        1.2   thorpej 	}
    873        1.2   thorpej 
    874   1.40.2.2        ad 	if (locking)
    875   1.40.2.2        ad 		mutex_exit(&p->p_smutex);
    876        1.2   thorpej 	panic("proc_representative_lwp: couldn't find a lwp for process"
    877        1.2   thorpej 		" %d (%s)", p->p_pid, p->p_comm);
    878        1.2   thorpej 	/* NOTREACHED */
    879        1.2   thorpej 	return NULL;
    880        1.2   thorpej }
    881       1.37        ad 
    882       1.37        ad /*
    883   1.40.2.2        ad  * Look up a live LWP within the speicifed process, and return it locked.
    884   1.40.2.2        ad  *
    885   1.40.2.2        ad  * Must be called with p->p_smutex held.
    886   1.40.2.2        ad  */
    887   1.40.2.2        ad struct lwp *
    888   1.40.2.6        ad lwp_find(struct proc *p, int id)
    889   1.40.2.2        ad {
    890   1.40.2.2        ad 	struct lwp *l;
    891   1.40.2.2        ad 
    892   1.40.2.2        ad 	LOCK_ASSERT(mutex_owned(&p->p_smutex));
    893   1.40.2.2        ad 
    894   1.40.2.2        ad 	LIST_FOREACH(l, &p->p_lwps, l_sibling) {
    895   1.40.2.2        ad 		if (l->l_lid == id)
    896   1.40.2.2        ad 			break;
    897   1.40.2.2        ad 	}
    898   1.40.2.2        ad 
    899   1.40.2.6        ad 	/*
    900   1.40.2.6        ad 	 * No need to lock - all of these conditions will
    901   1.40.2.6        ad 	 * be visible with the process level mutex held.
    902   1.40.2.6        ad 	 */
    903   1.40.2.6        ad 	if (l != NULL && (l->l_stat == LSIDL || l->l_stat == LSZOMB))
    904   1.40.2.6        ad 		l = NULL;
    905   1.40.2.2        ad 
    906   1.40.2.2        ad 	return l;
    907   1.40.2.2        ad }
    908   1.40.2.2        ad 
    909   1.40.2.2        ad /*
    910       1.37        ad  * Update an LWP's cached credentials to mirror the process' master copy.
    911       1.37        ad  *
    912       1.37        ad  * This happens early in the syscall path, on user trap, and on LWP
    913       1.37        ad  * creation.  A long-running LWP can also voluntarily choose to update
    914       1.37        ad  * it's credentials by calling this routine.  This may be called from
    915       1.37        ad  * LWP_CACHE_CREDS(), which checks l->l_cred != p->p_cred beforehand.
    916       1.37        ad  */
    917       1.37        ad void
    918       1.37        ad lwp_update_creds(struct lwp *l)
    919       1.37        ad {
    920       1.37        ad 	kauth_cred_t oc;
    921       1.37        ad 	struct proc *p;
    922       1.37        ad 
    923       1.37        ad 	p = l->l_proc;
    924       1.37        ad 	oc = l->l_cred;
    925       1.37        ad 
    926   1.40.2.4        ad 	mutex_enter(&p->p_mutex);
    927       1.37        ad 	kauth_cred_hold(p->p_cred);
    928       1.37        ad 	l->l_cred = p->p_cred;
    929   1.40.2.4        ad 	mutex_exit(&p->p_mutex);
    930   1.40.2.6        ad 	if (oc != NULL) {
    931   1.40.2.7        ad 		KERNEL_LOCK(1, l);	/* XXXSMP */
    932       1.37        ad 		kauth_cred_free(oc);
    933   1.40.2.7        ad 		KERNEL_UNLOCK_ONE(l);	/* XXXSMP */
    934   1.40.2.6        ad 	}
    935       1.37        ad }
    936   1.40.2.2        ad 
    937   1.40.2.2        ad /*
    938   1.40.2.2        ad  * Verify that an LWP is locked, and optionally verify that the lock matches
    939   1.40.2.2        ad  * one we specify.
    940   1.40.2.2        ad  */
    941   1.40.2.2        ad int
    942   1.40.2.2        ad lwp_locked(struct lwp *l, kmutex_t *mtx)
    943   1.40.2.2        ad {
    944   1.40.2.3        ad 	kmutex_t *cur = l->l_mutex;
    945   1.40.2.2        ad 
    946   1.40.2.4        ad #if defined(MULTIPROCESSOR) || defined(LOCKDEBUG)
    947   1.40.2.3        ad 	return mutex_owned(cur) && (mtx == cur || mtx == NULL);
    948   1.40.2.3        ad #else
    949   1.40.2.4        ad 	return mutex_owned(cur);
    950   1.40.2.3        ad #endif
    951   1.40.2.2        ad }
    952   1.40.2.2        ad 
    953   1.40.2.4        ad #if defined(MULTIPROCESSOR) || defined(LOCKDEBUG)
    954   1.40.2.2        ad /*
    955   1.40.2.3        ad  * Lock an LWP.
    956   1.40.2.2        ad  */
    957   1.40.2.2        ad void
    958   1.40.2.4        ad lwp_lock_retry(struct lwp *l, kmutex_t *old)
    959   1.40.2.2        ad {
    960   1.40.2.3        ad 
    961   1.40.2.6        ad 	/*
    962   1.40.2.6        ad 	 * XXXgcc ignoring kmutex_t * volatile on i386
    963   1.40.2.6        ad 	 *
    964   1.40.2.6        ad 	 * gcc version 4.1.2 20061021 prerelease (NetBSD nb1 20061021)
    965   1.40.2.6        ad 	 */
    966   1.40.2.6        ad #if 1
    967   1.40.2.6        ad 	while (l->l_mutex != old) {
    968   1.40.2.6        ad #else
    969   1.40.2.3        ad 	for (;;) {
    970   1.40.2.6        ad #endif
    971  1.40.2.14        ad 		mutex_spin_exit(old);
    972   1.40.2.4        ad 		old = l->l_mutex;
    973  1.40.2.14        ad 		mutex_spin_enter(old);
    974   1.40.2.3        ad 
    975   1.40.2.3        ad 		/*
    976   1.40.2.3        ad 		 * mutex_enter() will have posted a read barrier.  Re-test
    977   1.40.2.3        ad 		 * l->l_mutex.  If it has changed, we need to try again.
    978   1.40.2.3        ad 		 */
    979   1.40.2.6        ad #if 1
    980   1.40.2.6        ad 	}
    981   1.40.2.6        ad #else
    982   1.40.2.4        ad 	} while (__predict_false(l->l_mutex != old));
    983   1.40.2.6        ad #endif
    984   1.40.2.2        ad }
    985   1.40.2.3        ad #endif
    986   1.40.2.3        ad 
    987   1.40.2.3        ad /*
    988   1.40.2.4        ad  * Lend a new mutex to an LWP.  The old mutex must be held.
    989   1.40.2.3        ad  */
    990   1.40.2.3        ad void
    991   1.40.2.3        ad lwp_setlock(struct lwp *l, kmutex_t *new)
    992   1.40.2.3        ad {
    993   1.40.2.4        ad 
    994   1.40.2.2        ad 	LOCK_ASSERT(mutex_owned(l->l_mutex));
    995   1.40.2.2        ad 
    996   1.40.2.4        ad #if defined(MULTIPROCESSOR) || defined(LOCKDEBUG)
    997   1.40.2.3        ad 	mb_write();
    998   1.40.2.3        ad 	l->l_mutex = new;
    999   1.40.2.4        ad #else
   1000   1.40.2.4        ad 	(void)new;
   1001   1.40.2.3        ad #endif
   1002   1.40.2.2        ad }
   1003   1.40.2.2        ad 
   1004   1.40.2.2        ad /*
   1005   1.40.2.3        ad  * Lend a new mutex to an LWP, and release the old mutex.  The old mutex
   1006   1.40.2.3        ad  * must be held.
   1007   1.40.2.3        ad  */
   1008   1.40.2.3        ad void
   1009   1.40.2.4        ad lwp_unlock_to(struct lwp *l, kmutex_t *new)
   1010   1.40.2.3        ad {
   1011   1.40.2.3        ad 	kmutex_t *old;
   1012   1.40.2.3        ad 
   1013   1.40.2.3        ad 	LOCK_ASSERT(mutex_owned(l->l_mutex));
   1014   1.40.2.3        ad 
   1015   1.40.2.3        ad 	old = l->l_mutex;
   1016   1.40.2.4        ad #if defined(MULTIPROCESSOR) || defined(LOCKDEBUG)
   1017   1.40.2.3        ad 	mb_write();
   1018   1.40.2.3        ad 	l->l_mutex = new;
   1019   1.40.2.4        ad #else
   1020   1.40.2.4        ad 	(void)new;
   1021   1.40.2.3        ad #endif
   1022  1.40.2.14        ad 	mutex_spin_exit(old);
   1023   1.40.2.3        ad }
   1024   1.40.2.3        ad 
   1025   1.40.2.3        ad /*
   1026   1.40.2.6        ad  * Acquire a new mutex, and donate it to an LWP.  The LWP must already be
   1027   1.40.2.3        ad  * locked.
   1028   1.40.2.2        ad  */
   1029   1.40.2.2        ad void
   1030   1.40.2.3        ad lwp_relock(struct lwp *l, kmutex_t *new)
   1031   1.40.2.2        ad {
   1032   1.40.2.4        ad #if defined(MULTIPROCESSOR) || defined(LOCKDEBUG)
   1033   1.40.2.4        ad 	kmutex_t *old;
   1034   1.40.2.4        ad #endif
   1035   1.40.2.2        ad 
   1036   1.40.2.2        ad 	LOCK_ASSERT(mutex_owned(l->l_mutex));
   1037   1.40.2.2        ad 
   1038   1.40.2.4        ad #if defined(MULTIPROCESSOR) || defined(LOCKDEBUG)
   1039   1.40.2.4        ad 	old = l->l_mutex;
   1040   1.40.2.4        ad 	if (old != new) {
   1041  1.40.2.14        ad 		mutex_spin_enter(new);
   1042   1.40.2.4        ad 		l->l_mutex = new;
   1043  1.40.2.14        ad 		mutex_spin_exit(old);
   1044   1.40.2.4        ad 	}
   1045   1.40.2.4        ad #else
   1046   1.40.2.4        ad 	(void)new;
   1047   1.40.2.3        ad #endif
   1048   1.40.2.2        ad }
   1049   1.40.2.2        ad 
   1050   1.40.2.2        ad /*
   1051   1.40.2.6        ad  * Handle exceptions for mi_userret().  Called if a member of L_USERRET is
   1052   1.40.2.6        ad  * set.
   1053   1.40.2.2        ad  */
   1054   1.40.2.2        ad void
   1055   1.40.2.2        ad lwp_userret(struct lwp *l)
   1056   1.40.2.2        ad {
   1057   1.40.2.2        ad 	struct proc *p;
   1058   1.40.2.4        ad 	int sig;
   1059   1.40.2.2        ad 
   1060   1.40.2.2        ad 	p = l->l_proc;
   1061   1.40.2.2        ad 
   1062   1.40.2.6        ad 	/*
   1063   1.40.2.6        ad 	 * It should be safe to do this read unlocked on a multiprocessor
   1064   1.40.2.6        ad 	 * system..
   1065   1.40.2.6        ad 	 */
   1066   1.40.2.6        ad 	while ((l->l_flag & L_USERRET) != 0) {
   1067   1.40.2.6        ad 		/*
   1068   1.40.2.6        ad 		 * Process pending signals first, unless the process
   1069   1.40.2.6        ad 		 * is dumping core, where we will instead enter the
   1070   1.40.2.6        ad 		 * L_WSUSPEND case below.
   1071   1.40.2.6        ad 		 */
   1072   1.40.2.6        ad 		if ((l->l_flag & (L_PENDSIG | L_WCORE)) == L_PENDSIG) {
   1073   1.40.2.4        ad 			KERNEL_LOCK(1, l);	/* XXXSMP pool_put() below */
   1074   1.40.2.4        ad 			mutex_enter(&p->p_smutex);
   1075   1.40.2.4        ad 			while ((sig = issignal(l)) != 0)
   1076   1.40.2.4        ad 				postsig(sig);
   1077   1.40.2.4        ad 			mutex_exit(&p->p_smutex);
   1078   1.40.2.7        ad 			KERNEL_UNLOCK_LAST(l);	/* XXXSMP */
   1079   1.40.2.4        ad 		}
   1080   1.40.2.2        ad 
   1081   1.40.2.6        ad 		/*
   1082   1.40.2.6        ad 		 * Core-dump or suspend pending.
   1083   1.40.2.6        ad 		 *
   1084   1.40.2.6        ad 		 * In case of core dump, suspend ourselves, so that the
   1085   1.40.2.6        ad 		 * kernel stack and therefore the userland registers saved
   1086   1.40.2.6        ad 		 * in the trapframe are around for coredump() to write them
   1087   1.40.2.6        ad 		 * out.  We issue a wakeup on p->p_lwpcv so that sigexit()
   1088   1.40.2.6        ad 		 * will write the core file out once all other LWPs are
   1089   1.40.2.6        ad 		 * suspended.
   1090   1.40.2.6        ad 		 */
   1091   1.40.2.4        ad 		if ((l->l_flag & L_WSUSPEND) != 0) {
   1092   1.40.2.4        ad 			mutex_enter(&p->p_smutex);
   1093   1.40.2.4        ad 			p->p_nrlwps--;
   1094   1.40.2.6        ad 			cv_broadcast(&p->p_lwpcv);
   1095   1.40.2.6        ad 			lwp_lock(l);
   1096   1.40.2.4        ad 			l->l_stat = LSSUSPENDED;
   1097   1.40.2.4        ad 			mutex_exit(&p->p_smutex);
   1098   1.40.2.4        ad 			mi_switch(l, NULL);
   1099   1.40.2.4        ad 		}
   1100   1.40.2.2        ad 
   1101   1.40.2.4        ad 		/* Process is exiting. */
   1102   1.40.2.4        ad 		if ((l->l_flag & L_WEXIT) != 0) {
   1103   1.40.2.4        ad 			KERNEL_LOCK(1, l);
   1104   1.40.2.6        ad 			lwp_exit(l);
   1105   1.40.2.4        ad 			KASSERT(0);
   1106   1.40.2.4        ad 			/* NOTREACHED */
   1107   1.40.2.4        ad 		}
   1108   1.40.2.6        ad 	}
   1109   1.40.2.2        ad }
   1110   1.40.2.2        ad 
   1111   1.40.2.2        ad /*
   1112   1.40.2.6        ad  * Force an LWP to enter the kernel, to take a trip through lwp_userret().
   1113   1.40.2.2        ad  */
   1114   1.40.2.6        ad void
   1115   1.40.2.6        ad lwp_need_userret(struct lwp *l)
   1116   1.40.2.2        ad {
   1117   1.40.2.6        ad 	LOCK_ASSERT(lwp_locked(l, NULL));
   1118   1.40.2.2        ad 
   1119   1.40.2.6        ad 	/*
   1120   1.40.2.6        ad 	 * Since the tests in lwp_userret() are done unlocked, make sure
   1121   1.40.2.6        ad 	 * that the condition will be seen before forcing the LWP to enter
   1122   1.40.2.6        ad 	 * kernel mode.
   1123   1.40.2.6        ad 	 */
   1124   1.40.2.6        ad 	mb_write();
   1125   1.40.2.2        ad 
   1126  1.40.2.13        ad 	if (l->l_priority > PUSER)
   1127  1.40.2.13        ad 		lwp_changepri(l, PUSER);
   1128   1.40.2.6        ad 	cpu_signotify(l);
   1129   1.40.2.2        ad }
   1130   1.40.2.4        ad 
   1131   1.40.2.4        ad /*
   1132   1.40.2.4        ad  * Add one reference to an LWP.  This will prevent the LWP from
   1133   1.40.2.6        ad  * exiting, thus keep the lwp structure and PCB around to inspect.
   1134   1.40.2.4        ad  */
   1135   1.40.2.4        ad void
   1136   1.40.2.4        ad lwp_addref(struct lwp *l)
   1137   1.40.2.4        ad {
   1138   1.40.2.4        ad 
   1139   1.40.2.6        ad 	LOCK_ASSERT(mutex_owned(&l->l_proc->p_smutex));
   1140   1.40.2.4        ad 	KASSERT(l->l_stat != LSZOMB);
   1141   1.40.2.4        ad 	KASSERT(l->l_refcnt != 0);
   1142   1.40.2.4        ad 
   1143   1.40.2.4        ad 	l->l_refcnt++;
   1144   1.40.2.4        ad }
   1145   1.40.2.4        ad 
   1146   1.40.2.4        ad /*
   1147   1.40.2.4        ad  * Remove one reference to an LWP.  If this is the last reference,
   1148   1.40.2.4        ad  * then we must finalize the LWP's death.
   1149   1.40.2.4        ad  */
   1150   1.40.2.4        ad void
   1151   1.40.2.4        ad lwp_delref(struct lwp *l)
   1152   1.40.2.4        ad {
   1153   1.40.2.6        ad 	struct proc *p = l->l_proc;
   1154   1.40.2.6        ad 	u_int refcnt;
   1155   1.40.2.6        ad 
   1156   1.40.2.6        ad 	mutex_enter(&p->p_smutex);
   1157   1.40.2.6        ad 	refcnt = --l->l_refcnt;
   1158   1.40.2.6        ad 	mutex_exit(&p->p_smutex);
   1159   1.40.2.6        ad 
   1160   1.40.2.6        ad 	if (refcnt == 0)
   1161   1.40.2.6        ad 		cv_broadcast(&p->p_refcv);
   1162   1.40.2.6        ad }
   1163   1.40.2.6        ad 
   1164   1.40.2.6        ad /*
   1165   1.40.2.6        ad  * Drain all references to the current LWP.
   1166   1.40.2.6        ad  */
   1167   1.40.2.6        ad void
   1168   1.40.2.6        ad lwp_drainrefs(struct lwp *l)
   1169   1.40.2.6        ad {
   1170   1.40.2.6        ad 	struct proc *p = l->l_proc;
   1171   1.40.2.6        ad 
   1172   1.40.2.6        ad 	LOCK_ASSERT(mutex_owned(&p->p_smutex));
   1173   1.40.2.6        ad 	KASSERT(l->l_refcnt != 0);
   1174   1.40.2.4        ad 
   1175   1.40.2.6        ad 	l->l_refcnt--;
   1176   1.40.2.6        ad 	while (l->l_refcnt != 0)
   1177   1.40.2.6        ad 		cv_wait(&p->p_refcv, &p->p_smutex);
   1178   1.40.2.4        ad }
   1179   1.40.2.5        ad 
   1180   1.40.2.5        ad /*
   1181   1.40.2.5        ad  * lwp_specific_key_create --
   1182   1.40.2.5        ad  *	Create a key for subsystem lwp-specific data.
   1183   1.40.2.5        ad  */
   1184   1.40.2.5        ad int
   1185   1.40.2.5        ad lwp_specific_key_create(specificdata_key_t *keyp, specificdata_dtor_t dtor)
   1186   1.40.2.5        ad {
   1187   1.40.2.5        ad 
   1188   1.40.2.5        ad 	return (specificdata_key_create(lwp_specificdata_domain, keyp, dtor));
   1189   1.40.2.5        ad }
   1190   1.40.2.5        ad 
   1191   1.40.2.5        ad /*
   1192   1.40.2.5        ad  * lwp_specific_key_delete --
   1193   1.40.2.5        ad  *	Delete a key for subsystem lwp-specific data.
   1194   1.40.2.5        ad  */
   1195   1.40.2.5        ad void
   1196   1.40.2.5        ad lwp_specific_key_delete(specificdata_key_t key)
   1197   1.40.2.5        ad {
   1198   1.40.2.5        ad 
   1199   1.40.2.5        ad 	specificdata_key_delete(lwp_specificdata_domain, key);
   1200   1.40.2.5        ad }
   1201   1.40.2.5        ad 
   1202   1.40.2.5        ad /*
   1203   1.40.2.5        ad  * lwp_initspecific --
   1204   1.40.2.5        ad  *	Initialize an LWP's specificdata container.
   1205   1.40.2.5        ad  */
   1206   1.40.2.5        ad void
   1207   1.40.2.5        ad lwp_initspecific(struct lwp *l)
   1208   1.40.2.5        ad {
   1209   1.40.2.5        ad 	int error;
   1210   1.40.2.5        ad 
   1211   1.40.2.5        ad 	error = specificdata_init(lwp_specificdata_domain, &l->l_specdataref);
   1212   1.40.2.5        ad 	KASSERT(error == 0);
   1213   1.40.2.5        ad }
   1214   1.40.2.5        ad 
   1215   1.40.2.5        ad /*
   1216   1.40.2.5        ad  * lwp_finispecific --
   1217   1.40.2.5        ad  *	Finalize an LWP's specificdata container.
   1218   1.40.2.5        ad  */
   1219   1.40.2.5        ad void
   1220   1.40.2.5        ad lwp_finispecific(struct lwp *l)
   1221   1.40.2.5        ad {
   1222   1.40.2.5        ad 
   1223   1.40.2.5        ad 	specificdata_fini(lwp_specificdata_domain, &l->l_specdataref);
   1224   1.40.2.5        ad }
   1225   1.40.2.5        ad 
   1226   1.40.2.5        ad /*
   1227   1.40.2.5        ad  * lwp_getspecific --
   1228   1.40.2.5        ad  *	Return lwp-specific data corresponding to the specified key.
   1229   1.40.2.5        ad  *
   1230   1.40.2.5        ad  *	Note: LWP specific data is NOT INTERLOCKED.  An LWP should access
   1231   1.40.2.5        ad  *	only its OWN SPECIFIC DATA.  If it is necessary to access another
   1232   1.40.2.5        ad  *	LWP's specifc data, care must be taken to ensure that doing so
   1233   1.40.2.5        ad  *	would not cause internal data structure inconsistency (i.e. caller
   1234   1.40.2.5        ad  *	can guarantee that the target LWP is not inside an lwp_getspecific()
   1235   1.40.2.5        ad  *	or lwp_setspecific() call).
   1236   1.40.2.5        ad  */
   1237   1.40.2.5        ad void *
   1238   1.40.2.5        ad lwp_getspecific(specificdata_key_t key)
   1239   1.40.2.5        ad {
   1240   1.40.2.5        ad 
   1241   1.40.2.5        ad 	return (specificdata_getspecific_unlocked(lwp_specificdata_domain,
   1242   1.40.2.5        ad 						  &curlwp->l_specdataref, key));
   1243   1.40.2.5        ad }
   1244   1.40.2.5        ad 
   1245   1.40.2.5        ad void *
   1246   1.40.2.5        ad _lwp_getspecific_by_lwp(struct lwp *l, specificdata_key_t key)
   1247   1.40.2.5        ad {
   1248   1.40.2.5        ad 
   1249   1.40.2.5        ad 	return (specificdata_getspecific_unlocked(lwp_specificdata_domain,
   1250   1.40.2.5        ad 						  &l->l_specdataref, key));
   1251   1.40.2.5        ad }
   1252   1.40.2.5        ad 
   1253   1.40.2.5        ad /*
   1254   1.40.2.5        ad  * lwp_setspecific --
   1255   1.40.2.5        ad  *	Set lwp-specific data corresponding to the specified key.
   1256   1.40.2.5        ad  */
   1257   1.40.2.5        ad void
   1258   1.40.2.5        ad lwp_setspecific(specificdata_key_t key, void *data)
   1259   1.40.2.5        ad {
   1260   1.40.2.5        ad 
   1261   1.40.2.5        ad 	specificdata_setspecific(lwp_specificdata_domain,
   1262   1.40.2.5        ad 				 &curlwp->l_specdataref, key, data);
   1263   1.40.2.5        ad }
   1264