Home | History | Annotate | Line # | Download | only in kern
kern_lwp.c revision 1.19 
      1 /*	$NetBSD: kern_lwp.c,v 1.19 2004/01/04 11:33:31 jdolecek Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 2001 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.
      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 #include <sys/cdefs.h>
     40 __KERNEL_RCSID(0, "$NetBSD: kern_lwp.c,v 1.19 2004/01/04 11:33:31 jdolecek Exp $");
     41 
     42 #include "opt_multiprocessor.h"
     43 
     44 #include <sys/param.h>
     45 #include <sys/systm.h>
     46 #include <sys/pool.h>
     47 #include <sys/lock.h>
     48 #include <sys/proc.h>
     49 #include <sys/sa.h>
     50 #include <sys/savar.h>
     51 #include <sys/types.h>
     52 #include <sys/ucontext.h>
     53 #include <sys/resourcevar.h>
     54 #include <sys/mount.h>
     55 #include <sys/syscallargs.h>
     56 
     57 #include <uvm/uvm_extern.h>
     58 
     59 struct lwplist alllwp;
     60 
     61 #define LWP_DEBUG
     62 
     63 #ifdef LWP_DEBUG
     64 int lwp_debug = 0;
     65 #define DPRINTF(x) if (lwp_debug) printf x
     66 #else
     67 #define DPRINTF(x)
     68 #endif
     69 /* ARGSUSED */
     70 int
     71 sys__lwp_create(struct lwp *l, void *v, register_t *retval)
     72 {
     73 	struct sys__lwp_create_args /* {
     74 		syscallarg(const ucontext_t *) ucp;
     75 		syscallarg(u_long) flags;
     76 		syscallarg(lwpid_t *) new_lwp;
     77 	} */ *uap = v;
     78 	struct proc *p = l->l_proc;
     79 	struct lwp *l2;
     80 	vaddr_t uaddr;
     81 	boolean_t inmem;
     82 	ucontext_t *newuc;
     83 	int s, error;
     84 
     85 	newuc = pool_get(&lwp_uc_pool, PR_WAITOK);
     86 
     87 	error = copyin(SCARG(uap, ucp), newuc, sizeof(*newuc));
     88 	if (error)
     89 		return (error);
     90 
     91 	/* XXX check against resource limits */
     92 
     93 	inmem = uvm_uarea_alloc(&uaddr);
     94 	if (__predict_false(uaddr == 0)) {
     95 		return (ENOMEM);
     96 	}
     97 
     98 	/* XXX flags:
     99 	 * __LWP_ASLWP is probably needed for Solaris compat.
    100 	 */
    101 
    102 	newlwp(l, p, uaddr, inmem,
    103 	    SCARG(uap, flags) & LWP_DETACHED,
    104 	    NULL, 0, startlwp, newuc, &l2);
    105 
    106 	if ((SCARG(uap, flags) & LWP_SUSPENDED) == 0) {
    107 		SCHED_LOCK(s);
    108 		l2->l_stat = LSRUN;
    109 		setrunqueue(l2);
    110 		SCHED_UNLOCK(s);
    111 		simple_lock(&p->p_lock);
    112 		p->p_nrlwps++;
    113 		simple_unlock(&p->p_lock);
    114 	} else {
    115 		l2->l_stat = LSSUSPENDED;
    116 	}
    117 
    118 	error = copyout(&l2->l_lid, SCARG(uap, new_lwp),
    119 	    sizeof(l2->l_lid));
    120 	if (error)
    121 		return (error);
    122 
    123 	return (0);
    124 }
    125 
    126 
    127 int
    128 sys__lwp_exit(struct lwp *l, void *v, register_t *retval)
    129 {
    130 
    131 	lwp_exit(l);
    132 	/* NOTREACHED */
    133 	return (0);
    134 }
    135 
    136 
    137 int
    138 sys__lwp_self(struct lwp *l, void *v, register_t *retval)
    139 {
    140 
    141 	*retval = l->l_lid;
    142 
    143 	return (0);
    144 }
    145 
    146 
    147 int
    148 sys__lwp_getprivate(struct lwp *l, void *v, register_t *retval)
    149 {
    150 
    151 	*retval = (uintptr_t) l->l_private;
    152 
    153 	return (0);
    154 }
    155 
    156 
    157 int
    158 sys__lwp_setprivate(struct lwp *l, void *v, register_t *retval)
    159 {
    160 	struct sys__lwp_setprivate_args /* {
    161 		syscallarg(void *) ptr;
    162 	} */ *uap = v;
    163 
    164 	l->l_private = SCARG(uap, ptr);
    165 
    166 	return (0);
    167 }
    168 
    169 
    170 int
    171 sys__lwp_suspend(struct lwp *l, void *v, register_t *retval)
    172 {
    173 	struct sys__lwp_suspend_args /* {
    174 		syscallarg(lwpid_t) target;
    175 	} */ *uap = v;
    176 	int target_lid;
    177 	struct proc *p = l->l_proc;
    178 	struct lwp *t;
    179 	struct lwp *t2;
    180 
    181 	target_lid = SCARG(uap, target);
    182 
    183 	LIST_FOREACH(t, &p->p_lwps, l_sibling)
    184 		if (t->l_lid == target_lid)
    185 			break;
    186 
    187 	if (t == NULL)
    188 		return (ESRCH);
    189 
    190 	if (t == l) {
    191 		/*
    192 		 * Check for deadlock, which is only possible
    193 		 * when we're suspending ourself.
    194 		 */
    195 		LIST_FOREACH(t2, &p->p_lwps, l_sibling) {
    196 			if ((t2 != l) && (t2->l_stat != LSSUSPENDED))
    197 				break;
    198 		}
    199 
    200 		if (t2 == NULL) /* All other LWPs are suspended */
    201 			return (EDEADLK);
    202 	}
    203 
    204 	return lwp_suspend(l, t);
    205 }
    206 
    207 inline int
    208 lwp_suspend(l, t)
    209 	struct lwp *l;
    210 	struct lwp *t;
    211 {
    212 	struct proc *p = t->l_proc;
    213 	int s;
    214 
    215 	if (t == l) {
    216 		SCHED_LOCK(s);
    217 		l->l_stat = LSSUSPENDED;
    218 		/* XXX NJWLWP check if this makes sense here: */
    219 		p->p_stats->p_ru.ru_nvcsw++;
    220 		mi_switch(l, NULL);
    221 		SCHED_ASSERT_UNLOCKED();
    222 		splx(s);
    223 	} else {
    224 		switch (t->l_stat) {
    225 		case LSSUSPENDED:
    226 			return (0); /* _lwp_suspend() is idempotent */
    227 		case LSRUN:
    228 			SCHED_LOCK(s);
    229 			remrunqueue(t);
    230 			t->l_stat = LSSUSPENDED;
    231 			SCHED_UNLOCK(s);
    232 			simple_lock(&p->p_lock);
    233 			p->p_nrlwps--;
    234 			simple_unlock(&p->p_lock);
    235 			break;
    236 		case LSSLEEP:
    237 			t->l_stat = LSSUSPENDED;
    238 			break;
    239 		case LSIDL:
    240 		case LSDEAD:
    241 		case LSZOMB:
    242 			return (EINTR); /* It's what Solaris does..... */
    243 		case LSSTOP:
    244 			panic("_lwp_suspend: Stopped LWP in running process!");
    245 			break;
    246 		case LSONPROC:
    247 			panic("XXX multiprocessor LWPs? Implement me!");
    248 			break;
    249 		}
    250 	}
    251 
    252 	return (0);
    253 }
    254 
    255 
    256 int
    257 sys__lwp_continue(struct lwp *l, void *v, register_t *retval)
    258 {
    259 	struct sys__lwp_continue_args /* {
    260 		syscallarg(lwpid_t) target;
    261 	} */ *uap = v;
    262 	int s, target_lid;
    263 	struct proc *p = l->l_proc;
    264 	struct lwp *t;
    265 
    266 	target_lid = SCARG(uap, target);
    267 
    268 	LIST_FOREACH(t, &p->p_lwps, l_sibling)
    269 		if (t->l_lid == target_lid)
    270 			break;
    271 
    272 	if (t == NULL)
    273 		return (ESRCH);
    274 
    275 	SCHED_LOCK(s);
    276 	lwp_continue(t);
    277 	SCHED_UNLOCK(s);
    278 
    279 	return (0);
    280 }
    281 
    282 void
    283 lwp_continue(struct lwp *l)
    284 {
    285 
    286 	DPRINTF(("lwp_continue of %d.%d (%s), state %d, wchan %p\n",
    287 	    l->l_proc->p_pid, l->l_lid, l->l_proc->p_comm, l->l_stat,
    288 	    l->l_wchan));
    289 
    290 	if (l->l_stat != LSSUSPENDED)
    291 		return;
    292 
    293 	if (l->l_wchan == 0) {
    294 		/* LWP was runnable before being suspended. */
    295 		setrunnable(l);
    296 	} else {
    297 		/* LWP was sleeping before being suspended. */
    298 		l->l_stat = LSSLEEP;
    299 	}
    300 }
    301 
    302 int
    303 sys__lwp_wakeup(struct lwp *l, void *v, register_t *retval)
    304 {
    305 	struct sys__lwp_wakeup_args /* {
    306 		syscallarg(lwpid_t) wakeup;
    307 	} */ *uap = v;
    308 	lwpid_t target_lid;
    309 	struct lwp *t;
    310 	struct proc *p;
    311 	int error;
    312 	int s;
    313 
    314 	p = l->l_proc;
    315 	target_lid = SCARG(uap, target);
    316 
    317 	SCHED_LOCK(s);
    318 
    319 
    320 	LIST_FOREACH(t, &p->p_lwps, l_sibling)
    321 		if (t->l_lid == target_lid)
    322 			break;
    323 
    324 	if (t == NULL) {
    325 		error = ESRCH;
    326 		goto exit;
    327 	}
    328 
    329 	if (t->l_stat != LSSLEEP) {
    330 		error = ENODEV;
    331 		goto exit;
    332 	}
    333 
    334 	if ((t->l_flag & L_SINTR) == 0) {
    335 		error = EBUSY;
    336 		goto exit;
    337 	}
    338 	/*
    339 	 * Tell ltsleep to wakeup.
    340 	 */
    341 	t->l_flag |= L_CANCELLED;
    342 
    343 	setrunnable(t);
    344 	error = 0;
    345 exit:
    346 	SCHED_UNLOCK(s);
    347 
    348 
    349 	return error;
    350 }
    351 
    352 int
    353 sys__lwp_wait(struct lwp *l, void *v, register_t *retval)
    354 {
    355 	struct sys__lwp_wait_args /* {
    356 		syscallarg(lwpid_t) wait_for;
    357 		syscallarg(lwpid_t *) departed;
    358 	} */ *uap = v;
    359 	int error;
    360 	lwpid_t dep;
    361 
    362 	error = lwp_wait1(l, SCARG(uap, wait_for), &dep, 0);
    363 	if (error)
    364 		return (error);
    365 
    366 	if (SCARG(uap, departed)) {
    367 		error = copyout(&dep, SCARG(uap, departed),
    368 		    sizeof(dep));
    369 		if (error)
    370 			return (error);
    371 	}
    372 
    373 	return (0);
    374 }
    375 
    376 
    377 int
    378 lwp_wait1(struct lwp *l, lwpid_t lid, lwpid_t *departed, int flags)
    379 {
    380 
    381 	struct proc *p = l->l_proc;
    382 	struct lwp *l2, *l3;
    383 	int nfound, error, wpri;
    384 	static const char waitstr1[] = "lwpwait";
    385 	static const char waitstr2[] = "lwpwait2";
    386 
    387 	DPRINTF(("lwp_wait1: %d.%d waiting for %d.\n",
    388 	    p->p_pid, l->l_lid, lid));
    389 
    390 	if (lid == l->l_lid)
    391 		return (EDEADLK); /* Waiting for ourselves makes no sense. */
    392 
    393 	wpri = PWAIT |
    394 	    ((flags & LWPWAIT_EXITCONTROL) ? PNOEXITERR : PCATCH);
    395  loop:
    396 	nfound = 0;
    397 	LIST_FOREACH(l2, &p->p_lwps, l_sibling) {
    398 		if ((l2 == l) || (l2->l_flag & L_DETACHED) ||
    399 		    ((lid != 0) && (lid != l2->l_lid)))
    400 			continue;
    401 
    402 		nfound++;
    403 		if (l2->l_stat == LSZOMB) {
    404 			if (departed)
    405 				*departed = l2->l_lid;
    406 
    407 			simple_lock(&p->p_lock);
    408 			LIST_REMOVE(l2, l_sibling);
    409 			p->p_nlwps--;
    410 			p->p_nzlwps--;
    411 			simple_unlock(&p->p_lock);
    412 			/* XXX decrement limits */
    413 
    414 			pool_put(&lwp_pool, l2);
    415 
    416 			return (0);
    417 		} else if (l2->l_stat == LSSLEEP ||
    418 		           l2->l_stat == LSSUSPENDED) {
    419 			/* Deadlock checks.
    420 			 * 1. If all other LWPs are waiting for exits
    421 			 *    or suspended, we would deadlock.
    422 			 */
    423 
    424 			LIST_FOREACH(l3, &p->p_lwps, l_sibling) {
    425 				if (l3 != l && (l3->l_stat != LSSUSPENDED) &&
    426 				    !(l3->l_stat == LSSLEEP &&
    427 					l3->l_wchan == (caddr_t) &p->p_nlwps))
    428 					break;
    429 			}
    430 			if (l3 == NULL) /* Everyone else is waiting. */
    431 				return (EDEADLK);
    432 
    433 			/* XXX we'd like to check for a cycle of waiting
    434 			 * LWPs (specific LID waits, not any-LWP waits)
    435 			 * and detect that sort of deadlock, but we don't
    436 			 * have a good place to store the lwp that is
    437 			 * being waited for. wchan is already filled with
    438 			 * &p->p_nlwps, and putting the lwp address in
    439 			 * there for deadlock tracing would require
    440 			 * exiting LWPs to call wakeup on both their
    441 			 * own address and &p->p_nlwps, to get threads
    442 			 * sleeping on any LWP exiting.
    443 			 *
    444 			 * Revisit later. Maybe another auxillary
    445 			 * storage location associated with sleeping
    446 			 * is in order.
    447 			 */
    448 		}
    449 	}
    450 
    451 	if (nfound == 0)
    452 		return (ESRCH);
    453 
    454 	if ((error = tsleep((caddr_t) &p->p_nlwps, wpri,
    455 	    (lid != 0) ? waitstr1 : waitstr2, 0)) != 0)
    456 		return (error);
    457 
    458 	goto loop;
    459 }
    460 
    461 
    462 int
    463 newlwp(struct lwp *l1, struct proc *p2, vaddr_t uaddr, boolean_t inmem,
    464     int flags, void *stack, size_t stacksize,
    465     void (*func)(void *), void *arg, struct lwp **rnewlwpp)
    466 {
    467 	struct lwp *l2;
    468 	int s;
    469 
    470 	l2 = pool_get(&lwp_pool, PR_WAITOK);
    471 
    472 	l2->l_stat = LSIDL;
    473 	l2->l_forw = l2->l_back = NULL;
    474 	l2->l_proc = p2;
    475 
    476 
    477 	memset(&l2->l_startzero, 0,
    478 	       (unsigned) ((caddr_t)&l2->l_endzero -
    479 			   (caddr_t)&l2->l_startzero));
    480 	memcpy(&l2->l_startcopy, &l1->l_startcopy,
    481 	       (unsigned) ((caddr_t)&l2->l_endcopy -
    482 			   (caddr_t)&l2->l_startcopy));
    483 
    484 #if !defined(MULTIPROCESSOR)
    485 	/*
    486 	 * In the single-processor case, all processes will always run
    487 	 * on the same CPU.  So, initialize the child's CPU to the parent's
    488 	 * now.  In the multiprocessor case, the child's CPU will be
    489 	 * initialized in the low-level context switch code when the
    490 	 * process runs.
    491 	 */
    492 	KASSERT(l1->l_cpu != NULL);
    493 	l2->l_cpu = l1->l_cpu;
    494 #else
    495 	/*
    496 	 * zero child's cpu pointer so we don't get trash.
    497 	 */
    498 	l2->l_cpu = NULL;
    499 #endif /* ! MULTIPROCESSOR */
    500 
    501 	l2->l_flag = inmem ? L_INMEM : 0;
    502 	l2->l_flag |= (flags & LWP_DETACHED) ? L_DETACHED : 0;
    503 
    504 	callout_init(&l2->l_tsleep_ch);
    505 
    506 	if (rnewlwpp != NULL)
    507 		*rnewlwpp = l2;
    508 
    509 	l2->l_addr = (struct user *)uaddr;
    510 	uvm_lwp_fork(l1, l2, stack, stacksize, func,
    511 	    (arg != NULL) ? arg : l2);
    512 
    513 
    514 	simple_lock(&p2->p_lock);
    515 	l2->l_lid = ++p2->p_nlwpid;
    516 	LIST_INSERT_HEAD(&p2->p_lwps, l2, l_sibling);
    517 	p2->p_nlwps++;
    518 	simple_unlock(&p2->p_lock);
    519 
    520 	/* XXX should be locked differently... */
    521 	s = proclist_lock_write();
    522 	LIST_INSERT_HEAD(&alllwp, l2, l_list);
    523 	proclist_unlock_write(s);
    524 
    525 	if (p2->p_emul->e_lwp_fork)
    526 		(*p2->p_emul->e_lwp_fork)(l1, l2);
    527 
    528 	return (0);
    529 }
    530 
    531 
    532 /*
    533  * Quit the process. This will call cpu_exit, which will call cpu_switch,
    534  * so this can only be used meaningfully if you're willing to switch away.
    535  * Calling with l!=curlwp would be weird.
    536  */
    537 void
    538 lwp_exit(struct lwp *l)
    539 {
    540 	struct proc *p = l->l_proc;
    541 	int s;
    542 
    543 	DPRINTF(("lwp_exit: %d.%d exiting.\n", p->p_pid, l->l_lid));
    544 	DPRINTF((" nlwps: %d nrlwps %d nzlwps: %d\n",
    545 	    p->p_nlwps, p->p_nrlwps, p->p_nzlwps));
    546 
    547 	if (p->p_emul->e_lwp_exit)
    548 		(*p->p_emul->e_lwp_exit)(l);
    549 
    550 	/*
    551 	 * If we are the last live LWP in a process, we need to exit
    552 	 * the entire process (if that's not already going on). We do
    553 	 * so with an exit status of zero, because it's a "controlled"
    554 	 * exit, and because that's what Solaris does.
    555 	 */
    556 	if (((p->p_nlwps - p->p_nzlwps) == 1) && ((p->p_flag & P_WEXIT) == 0)) {
    557 		DPRINTF(("lwp_exit: %d.%d calling exit1()\n",
    558 		    p->p_pid, l->l_lid));
    559 		exit1(l, 0);
    560 		/* NOTREACHED */
    561 	}
    562 
    563 	s = proclist_lock_write();
    564 	LIST_REMOVE(l, l_list);
    565 	proclist_unlock_write(s);
    566 
    567 	/* Free MD LWP resources */
    568 #ifndef __NO_CPU_LWP_FREE
    569 	cpu_lwp_free(l, 0);
    570 #endif
    571 
    572 	simple_lock(&p->p_lock);
    573 	p->p_nrlwps--;
    574 	simple_unlock(&p->p_lock);
    575 
    576 	l->l_stat = LSDEAD;
    577 
    578 	/* This LWP no longer needs to hold the kernel lock. */
    579 	KERNEL_PROC_UNLOCK(l);
    580 
    581 	/* cpu_exit() will not return */
    582 	cpu_exit(l);
    583 
    584 }
    585 
    586 /*
    587  * We are called from cpu_exit() once it is safe to schedule the
    588  * dead process's resources to be freed (i.e., once we've switched to
    589  * the idle PCB for the current CPU).
    590  *
    591  * NOTE: One must be careful with locking in this routine.  It's
    592  * called from a critical section in machine-dependent code, so
    593  * we should refrain from changing any interrupt state.
    594  */
    595 void
    596 lwp_exit2(struct lwp *l)
    597 {
    598 	struct proc *p;
    599 
    600 	/*
    601 	 * Free the VM resources we're still holding on to.
    602 	 */
    603 	uvm_lwp_exit(l);
    604 
    605 	l->l_stat = LSZOMB;
    606 	if (l->l_flag & L_DETACHED) {
    607 		/* Nobody waits for detached LWPs. */
    608 		LIST_REMOVE(l, l_sibling);
    609 
    610 		if ((l->l_flag & L_PROCEXIT) == 0) {
    611 			p = l->l_proc;
    612 			p->p_nlwps--;
    613 		}
    614 
    615 		pool_put(&lwp_pool, l);
    616 	} else {
    617 		p = l->l_proc;
    618 		p->p_nzlwps++;
    619 		wakeup(&p->p_nlwps);
    620 	}
    621 }
    622 
    623 /*
    624  * Pick a LWP to represent the process for those operations which
    625  * want information about a "process" that is actually associated
    626  * with a LWP.
    627  */
    628 struct lwp *
    629 proc_representative_lwp(p)
    630 	struct proc *p;
    631 {
    632 	struct lwp *l, *onproc, *running, *sleeping, *stopped, *suspended;
    633 
    634 	/* Trivial case: only one LWP */
    635 	if (p->p_nlwps == 1)
    636 		return (LIST_FIRST(&p->p_lwps));
    637 
    638 	switch (p->p_stat) {
    639 	case SSTOP:
    640 	case SACTIVE:
    641 		/* Pick the most live LWP */
    642 		onproc = running = sleeping = stopped = suspended = NULL;
    643 		LIST_FOREACH(l, &p->p_lwps, l_sibling) {
    644 			switch (l->l_stat) {
    645 			case LSONPROC:
    646 				onproc = l;
    647 				break;
    648 			case LSRUN:
    649 				running = l;
    650 				break;
    651 			case LSSLEEP:
    652 				sleeping = l;
    653 				break;
    654 			case LSSTOP:
    655 				stopped = l;
    656 				break;
    657 			case LSSUSPENDED:
    658 				suspended = l;
    659 				break;
    660 			}
    661 		}
    662 		if (onproc)
    663 			return onproc;
    664 		if (running)
    665 			return running;
    666 		if (sleeping)
    667 			return sleeping;
    668 		if (stopped)
    669 			return stopped;
    670 		if (suspended)
    671 			return suspended;
    672 		break;
    673 	case SDEAD:
    674 	case SZOMB:
    675 		/* Doesn't really matter... */
    676 		return (LIST_FIRST(&p->p_lwps));
    677 #ifdef DIAGNOSTIC
    678 	case SIDL:
    679 		/* We have more than one LWP and we're in SIDL?
    680 		 * How'd that happen?
    681 		 */
    682 		panic("Too many LWPs (%d) in SIDL process %d (%s)",
    683 		    p->p_nrlwps, p->p_pid, p->p_comm);
    684 	default:
    685 		panic("Process %d (%s) in unknown state %d",
    686 		    p->p_pid, p->p_comm, p->p_stat);
    687 #endif
    688 	}
    689 
    690 	panic("proc_representative_lwp: couldn't find a lwp for process"
    691 		" %d (%s)", p->p_pid, p->p_comm);
    692 	/* NOTREACHED */
    693 	return NULL;
    694 }
    695