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