Home | History | Annotate | Line # | Download | only in kern
kern_proc.c revision 1.82
      1 /*	$NetBSD: kern_proc.c,v 1.82 2005/08/05 11:05:44 junyoung Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 1999 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
      9  * NASA Ames Research Center.
     10  *
     11  * Redistribution and use in source and binary forms, with or without
     12  * modification, are permitted provided that the following conditions
     13  * are met:
     14  * 1. Redistributions of source code must retain the above copyright
     15  *    notice, this list of conditions and the following disclaimer.
     16  * 2. Redistributions in binary form must reproduce the above copyright
     17  *    notice, this list of conditions and the following disclaimer in the
     18  *    documentation and/or other materials provided with the distribution.
     19  * 3. All advertising materials mentioning features or use of this software
     20  *    must display the following acknowledgement:
     21  *	This product includes software developed by the NetBSD
     22  *	Foundation, Inc. and its contributors.
     23  * 4. Neither the name of The NetBSD Foundation nor the names of its
     24  *    contributors may be used to endorse or promote products derived
     25  *    from this software without specific prior written permission.
     26  *
     27  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     28  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     29  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     30  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     31  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     37  * POSSIBILITY OF SUCH DAMAGE.
     38  */
     39 
     40 /*
     41  * Copyright (c) 1982, 1986, 1989, 1991, 1993
     42  *	The Regents of the University of California.  All rights reserved.
     43  *
     44  * Redistribution and use in source and binary forms, with or without
     45  * modification, are permitted provided that the following conditions
     46  * are met:
     47  * 1. Redistributions of source code must retain the above copyright
     48  *    notice, this list of conditions and the following disclaimer.
     49  * 2. Redistributions in binary form must reproduce the above copyright
     50  *    notice, this list of conditions and the following disclaimer in the
     51  *    documentation and/or other materials provided with the distribution.
     52  * 3. Neither the name of the University nor the names of its contributors
     53  *    may be used to endorse or promote products derived from this software
     54  *    without specific prior written permission.
     55  *
     56  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     57  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     58  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     59  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     60  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     61  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     62  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     63  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     64  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     65  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     66  * SUCH DAMAGE.
     67  *
     68  *	@(#)kern_proc.c	8.7 (Berkeley) 2/14/95
     69  */
     70 
     71 #include <sys/cdefs.h>
     72 __KERNEL_RCSID(0, "$NetBSD: kern_proc.c,v 1.82 2005/08/05 11:05:44 junyoung Exp $");
     73 
     74 #include "opt_kstack.h"
     75 
     76 #include <sys/param.h>
     77 #include <sys/systm.h>
     78 #include <sys/kernel.h>
     79 #include <sys/proc.h>
     80 #include <sys/resourcevar.h>
     81 #include <sys/buf.h>
     82 #include <sys/acct.h>
     83 #include <sys/wait.h>
     84 #include <sys/file.h>
     85 #include <ufs/ufs/quota.h>
     86 #include <sys/uio.h>
     87 #include <sys/malloc.h>
     88 #include <sys/pool.h>
     89 #include <sys/mbuf.h>
     90 #include <sys/ioctl.h>
     91 #include <sys/tty.h>
     92 #include <sys/signalvar.h>
     93 #include <sys/ras.h>
     94 #include <sys/sa.h>
     95 #include <sys/savar.h>
     96 #include <sys/filedesc.h>
     97 
     98 #include <uvm/uvm.h>
     99 #include <uvm/uvm_extern.h>
    100 
    101 /*
    102  * Other process lists
    103  */
    104 
    105 struct proclist allproc;
    106 struct proclist zombproc;	/* resources have been freed */
    107 
    108 
    109 /*
    110  * Process list locking:
    111  *
    112  * We have two types of locks on the proclists: read locks and write
    113  * locks.  Read locks can be used in interrupt context, so while we
    114  * hold the write lock, we must also block clock interrupts to
    115  * lock out any scheduling changes that may happen in interrupt
    116  * context.
    117  *
    118  * The proclist lock locks the following structures:
    119  *
    120  *	allproc
    121  *	zombproc
    122  *	pid_table
    123  */
    124 struct lock proclist_lock;
    125 
    126 /*
    127  * pid to proc lookup is done by indexing the pid_table array.
    128  * Since pid numbers are only allocated when an empty slot
    129  * has been found, there is no need to search any lists ever.
    130  * (an orphaned pgrp will lock the slot, a session will lock
    131  * the pgrp with the same number.)
    132  * If the table is too small it is reallocated with twice the
    133  * previous size and the entries 'unzipped' into the two halves.
    134  * A linked list of free entries is passed through the pt_proc
    135  * field of 'free' items - set odd to be an invalid ptr.
    136  */
    137 
    138 struct pid_table {
    139 	struct proc	*pt_proc;
    140 	struct pgrp	*pt_pgrp;
    141 };
    142 #if 1	/* strongly typed cast - should be a noop */
    143 static __inline uint p2u(struct proc *p) { return (uint)(uintptr_t)p; }
    144 #else
    145 #define p2u(p) ((uint)p)
    146 #endif
    147 #define P_VALID(p) (!(p2u(p) & 1))
    148 #define P_NEXT(p) (p2u(p) >> 1)
    149 #define P_FREE(pid) ((struct proc *)(uintptr_t)((pid) << 1 | 1))
    150 
    151 #define INITIAL_PID_TABLE_SIZE	(1 << 5)
    152 static struct pid_table *pid_table;
    153 static uint pid_tbl_mask = INITIAL_PID_TABLE_SIZE - 1;
    154 static uint pid_alloc_lim;	/* max we allocate before growing table */
    155 static uint pid_alloc_cnt;	/* number of allocated pids */
    156 
    157 /* links through free slots - never empty! */
    158 static uint next_free_pt, last_free_pt;
    159 static pid_t pid_max = PID_MAX;		/* largest value we allocate */
    160 
    161 /* Components of the first process -- never freed. */
    162 struct session session0;
    163 struct pgrp pgrp0;
    164 struct proc proc0;
    165 struct lwp lwp0;
    166 struct pcred cred0;
    167 struct filedesc0 filedesc0;
    168 struct cwdinfo cwdi0;
    169 struct plimit limit0;
    170 struct pstats pstat0;
    171 struct vmspace vmspace0;
    172 struct sigacts sigacts0;
    173 
    174 extern struct user *proc0paddr;
    175 
    176 extern const struct emul emul_netbsd;	/* defined in kern_exec.c */
    177 
    178 int nofile = NOFILE;
    179 int maxuprc = MAXUPRC;
    180 int cmask = CMASK;
    181 
    182 POOL_INIT(proc_pool, sizeof(struct proc), 0, 0, 0, "procpl",
    183     &pool_allocator_nointr);
    184 POOL_INIT(lwp_pool, sizeof(struct lwp), 0, 0, 0, "lwppl",
    185     &pool_allocator_nointr);
    186 POOL_INIT(lwp_uc_pool, sizeof(ucontext_t), 0, 0, 0, "lwpucpl",
    187     &pool_allocator_nointr);
    188 POOL_INIT(pgrp_pool, sizeof(struct pgrp), 0, 0, 0, "pgrppl",
    189     &pool_allocator_nointr);
    190 POOL_INIT(pcred_pool, sizeof(struct pcred), 0, 0, 0, "pcredpl",
    191     &pool_allocator_nointr);
    192 POOL_INIT(plimit_pool, sizeof(struct plimit), 0, 0, 0, "plimitpl",
    193     &pool_allocator_nointr);
    194 POOL_INIT(pstats_pool, sizeof(struct pstats), 0, 0, 0, "pstatspl",
    195     &pool_allocator_nointr);
    196 POOL_INIT(rusage_pool, sizeof(struct rusage), 0, 0, 0, "rusgepl",
    197     &pool_allocator_nointr);
    198 POOL_INIT(ras_pool, sizeof(struct ras), 0, 0, 0, "raspl",
    199     &pool_allocator_nointr);
    200 POOL_INIT(sadata_pool, sizeof(struct sadata), 0, 0, 0, "sadatapl",
    201     &pool_allocator_nointr);
    202 POOL_INIT(saupcall_pool, sizeof(struct sadata_upcall), 0, 0, 0, "saupcpl",
    203     &pool_allocator_nointr);
    204 POOL_INIT(sastack_pool, sizeof(struct sastack), 0, 0, 0, "sastackpl",
    205     &pool_allocator_nointr);
    206 POOL_INIT(savp_pool, sizeof(struct sadata_vp), 0, 0, 0, "savppl",
    207     &pool_allocator_nointr);
    208 POOL_INIT(ptimer_pool, sizeof(struct ptimer), 0, 0, 0, "ptimerpl",
    209     &pool_allocator_nointr);
    210 POOL_INIT(session_pool, sizeof(struct session), 0, 0, 0, "sessionpl",
    211     &pool_allocator_nointr);
    212 
    213 MALLOC_DEFINE(M_EMULDATA, "emuldata", "Per-process emulation data");
    214 MALLOC_DEFINE(M_PROC, "proc", "Proc structures");
    215 MALLOC_DEFINE(M_SUBPROC, "subproc", "Proc sub-structures");
    216 
    217 /*
    218  * The process list descriptors, used during pid allocation and
    219  * by sysctl.  No locking on this data structure is needed since
    220  * it is completely static.
    221  */
    222 const struct proclist_desc proclists[] = {
    223 	{ &allproc	},
    224 	{ &zombproc	},
    225 	{ NULL		},
    226 };
    227 
    228 static void orphanpg(struct pgrp *);
    229 static void pg_delete(pid_t);
    230 
    231 /*
    232  * Initialize global process hashing structures.
    233  */
    234 void
    235 procinit(void)
    236 {
    237 	const struct proclist_desc *pd;
    238 	int i;
    239 #define	LINK_EMPTY ((PID_MAX + INITIAL_PID_TABLE_SIZE) & ~(INITIAL_PID_TABLE_SIZE - 1))
    240 
    241 	for (pd = proclists; pd->pd_list != NULL; pd++)
    242 		LIST_INIT(pd->pd_list);
    243 
    244 	spinlockinit(&proclist_lock, "proclk", 0);
    245 
    246 	pid_table = malloc(INITIAL_PID_TABLE_SIZE * sizeof *pid_table,
    247 			    M_PROC, M_WAITOK);
    248 	/* Set free list running through table...
    249 	   Preset 'use count' above PID_MAX so we allocate pid 1 next. */
    250 	for (i = 0; i <= pid_tbl_mask; i++) {
    251 		pid_table[i].pt_proc = P_FREE(LINK_EMPTY + i + 1);
    252 		pid_table[i].pt_pgrp = 0;
    253 	}
    254 	/* slot 0 is just grabbed */
    255 	next_free_pt = 1;
    256 	/* Need to fix last entry. */
    257 	last_free_pt = pid_tbl_mask;
    258 	pid_table[last_free_pt].pt_proc = P_FREE(LINK_EMPTY);
    259 	/* point at which we grow table - to avoid reusing pids too often */
    260 	pid_alloc_lim = pid_tbl_mask - 1;
    261 #undef LINK_EMPTY
    262 
    263 	LIST_INIT(&alllwp);
    264 
    265 	uihashtbl =
    266 	    hashinit(maxproc / 16, HASH_LIST, M_PROC, M_WAITOK, &uihash);
    267 }
    268 
    269 /*
    270  * Initialize process 0.
    271  */
    272 void
    273 proc0_init(void)
    274 {
    275 	struct proc *p;
    276 	struct pgrp *pg;
    277 	struct session *sess;
    278 	struct lwp *l;
    279 	int s;
    280 	u_int i;
    281 	rlim_t lim;
    282 
    283 	p = &proc0;
    284 	pg = &pgrp0;
    285 	sess = &session0;
    286 	l = &lwp0;
    287 
    288 	simple_lock_init(&p->p_lock);
    289 	LIST_INIT(&p->p_lwps);
    290 	LIST_INSERT_HEAD(&p->p_lwps, l, l_sibling);
    291 	p->p_nlwps = 1;
    292 	simple_lock_init(&p->p_sigctx.ps_silock);
    293 	CIRCLEQ_INIT(&p->p_sigctx.ps_siginfo);
    294 
    295 	s = proclist_lock_write();
    296 
    297 	pid_table[0].pt_proc = p;
    298 	LIST_INSERT_HEAD(&allproc, p, p_list);
    299 	LIST_INSERT_HEAD(&alllwp, l, l_list);
    300 
    301 	p->p_pgrp = pg;
    302 	pid_table[0].pt_pgrp = pg;
    303 	LIST_INIT(&pg->pg_members);
    304 	LIST_INSERT_HEAD(&pg->pg_members, p, p_pglist);
    305 
    306 	pg->pg_session = sess;
    307 	sess->s_count = 1;
    308 	sess->s_sid = 0;
    309 	sess->s_leader = p;
    310 
    311 	proclist_unlock_write(s);
    312 
    313 	/*
    314 	 * Set P_NOCLDWAIT so that kernel threads are reparented to
    315 	 * init(8) when they exit.  init(8) can easily wait them out
    316 	 * for us.
    317 	 */
    318 	p->p_flag = P_SYSTEM | P_NOCLDWAIT;
    319 	p->p_stat = SACTIVE;
    320 	p->p_nice = NZERO;
    321 	p->p_emul = &emul_netbsd;
    322 #ifdef __HAVE_SYSCALL_INTERN
    323 	(*p->p_emul->e_syscall_intern)(p);
    324 #endif
    325 	strncpy(p->p_comm, "swapper", MAXCOMLEN);
    326 
    327 	l->l_flag = L_INMEM;
    328 	l->l_stat = LSONPROC;
    329 	p->p_nrlwps = 1;
    330 
    331 	callout_init(&l->l_tsleep_ch);
    332 
    333 	/* Create credentials. */
    334 	cred0.p_refcnt = 1;
    335 	p->p_cred = &cred0;
    336 	p->p_ucred = crget();
    337 	p->p_ucred->cr_ngroups = 1;	/* group 0 */
    338 
    339 	/* Create the CWD info. */
    340 	p->p_cwdi = &cwdi0;
    341 	cwdi0.cwdi_cmask = cmask;
    342 	cwdi0.cwdi_refcnt = 1;
    343 	simple_lock_init(&cwdi0.cwdi_slock);
    344 
    345 	/* Create the limits structures. */
    346 	p->p_limit = &limit0;
    347 	simple_lock_init(&limit0.p_slock);
    348 	for (i = 0; i < sizeof(p->p_rlimit)/sizeof(p->p_rlimit[0]); i++)
    349 		limit0.pl_rlimit[i].rlim_cur =
    350 		    limit0.pl_rlimit[i].rlim_max = RLIM_INFINITY;
    351 
    352 	limit0.pl_rlimit[RLIMIT_NOFILE].rlim_max = maxfiles;
    353 	limit0.pl_rlimit[RLIMIT_NOFILE].rlim_cur =
    354 	    maxfiles < nofile ? maxfiles : nofile;
    355 
    356 	limit0.pl_rlimit[RLIMIT_NPROC].rlim_max = maxproc;
    357 	limit0.pl_rlimit[RLIMIT_NPROC].rlim_cur =
    358 	    maxproc < maxuprc ? maxproc : maxuprc;
    359 
    360 	lim = ptoa(uvmexp.free);
    361 	limit0.pl_rlimit[RLIMIT_RSS].rlim_max = lim;
    362 	limit0.pl_rlimit[RLIMIT_MEMLOCK].rlim_max = lim;
    363 	limit0.pl_rlimit[RLIMIT_MEMLOCK].rlim_cur = lim / 3;
    364 	limit0.pl_corename = defcorename;
    365 	limit0.p_refcnt = 1;
    366 
    367 	/* Configure virtual memory system, set vm rlimits. */
    368 	uvm_init_limits(p);
    369 
    370 	/* Initialize file descriptor table for proc0. */
    371 	p->p_fd = &filedesc0.fd_fd;
    372 	fdinit1(&filedesc0);
    373 
    374 	/*
    375 	 * Initialize proc0's vmspace, which uses the kernel pmap.
    376 	 * All kernel processes (which never have user space mappings)
    377 	 * share proc0's vmspace, and thus, the kernel pmap.
    378 	 */
    379 	uvmspace_init(&vmspace0, pmap_kernel(), round_page(VM_MIN_ADDRESS),
    380 	    trunc_page(VM_MAX_ADDRESS));
    381 	p->p_vmspace = &vmspace0;
    382 
    383 	l->l_addr = proc0paddr;				/* XXX */
    384 
    385 	p->p_stats = &pstat0;
    386 
    387 	/* Initialize signal state for proc0. */
    388 	p->p_sigacts = &sigacts0;
    389 	siginit(p);
    390 }
    391 
    392 /*
    393  * Acquire a read lock on the proclist.
    394  */
    395 void
    396 proclist_lock_read(void)
    397 {
    398 	int error;
    399 
    400 	error = spinlockmgr(&proclist_lock, LK_SHARED, NULL);
    401 #ifdef DIAGNOSTIC
    402 	if (__predict_false(error != 0))
    403 		panic("proclist_lock_read: failed to acquire lock");
    404 #endif
    405 }
    406 
    407 /*
    408  * Release a read lock on the proclist.
    409  */
    410 void
    411 proclist_unlock_read(void)
    412 {
    413 
    414 	(void) spinlockmgr(&proclist_lock, LK_RELEASE, NULL);
    415 }
    416 
    417 /*
    418  * Acquire a write lock on the proclist.
    419  */
    420 int
    421 proclist_lock_write(void)
    422 {
    423 	int s, error;
    424 
    425 	s = splclock();
    426 	error = spinlockmgr(&proclist_lock, LK_EXCLUSIVE, NULL);
    427 #ifdef DIAGNOSTIC
    428 	if (__predict_false(error != 0))
    429 		panic("proclist_lock: failed to acquire lock");
    430 #endif
    431 	return s;
    432 }
    433 
    434 /*
    435  * Release a write lock on the proclist.
    436  */
    437 void
    438 proclist_unlock_write(int s)
    439 {
    440 
    441 	(void) spinlockmgr(&proclist_lock, LK_RELEASE, NULL);
    442 	splx(s);
    443 }
    444 
    445 /*
    446  * Check that the specified process group is in the session of the
    447  * specified process.
    448  * Treats -ve ids as process ids.
    449  * Used to validate TIOCSPGRP requests.
    450  */
    451 int
    452 pgid_in_session(struct proc *p, pid_t pg_id)
    453 {
    454 	struct pgrp *pgrp;
    455 
    456 	if (pg_id < 0) {
    457 		struct proc *p1 = pfind(-pg_id);
    458 		if (p1 == NULL)
    459 			return EINVAL;
    460 		pgrp = p1->p_pgrp;
    461 	} else {
    462 		pgrp = pgfind(pg_id);
    463 		if (pgrp == NULL)
    464 			return EINVAL;
    465 	}
    466 	if (pgrp->pg_session != p->p_pgrp->pg_session)
    467 		return EPERM;
    468 	return 0;
    469 }
    470 
    471 /*
    472  * Is p an inferior of q?
    473  */
    474 int
    475 inferior(struct proc *p, struct proc *q)
    476 {
    477 
    478 	for (; p != q; p = p->p_pptr)
    479 		if (p->p_pid == 0)
    480 			return 0;
    481 	return 1;
    482 }
    483 
    484 /*
    485  * Locate a process by number
    486  */
    487 struct proc *
    488 p_find(pid_t pid, uint flags)
    489 {
    490 	struct proc *p;
    491 	char stat;
    492 
    493 	if (!(flags & PFIND_LOCKED))
    494 		proclist_lock_read();
    495 	p = pid_table[pid & pid_tbl_mask].pt_proc;
    496 	/* Only allow live processes to be found by pid. */
    497 	if (P_VALID(p) && p->p_pid == pid &&
    498 	    ((stat = p->p_stat) == SACTIVE || stat == SSTOP
    499 		    || (stat == SZOMB && (flags & PFIND_ZOMBIE)))) {
    500 		if (flags & PFIND_UNLOCK_OK)
    501 			 proclist_unlock_read();
    502 		return p;
    503 	}
    504 	if (flags & PFIND_UNLOCK_FAIL)
    505 		 proclist_unlock_read();
    506 	return NULL;
    507 }
    508 
    509 
    510 /*
    511  * Locate a process group by number
    512  */
    513 struct pgrp *
    514 pg_find(pid_t pgid, uint flags)
    515 {
    516 	struct pgrp *pg;
    517 
    518 	if (!(flags & PFIND_LOCKED))
    519 		proclist_lock_read();
    520 	pg = pid_table[pgid & pid_tbl_mask].pt_pgrp;
    521 	/*
    522 	 * Can't look up a pgrp that only exists because the session
    523 	 * hasn't died yet (traditional)
    524 	 */
    525 	if (pg == NULL || pg->pg_id != pgid || LIST_EMPTY(&pg->pg_members)) {
    526 		if (flags & PFIND_UNLOCK_FAIL)
    527 			 proclist_unlock_read();
    528 		return NULL;
    529 	}
    530 
    531 	if (flags & PFIND_UNLOCK_OK)
    532 		proclist_unlock_read();
    533 	return pg;
    534 }
    535 
    536 static void
    537 expand_pid_table(void)
    538 {
    539 	uint pt_size = pid_tbl_mask + 1;
    540 	struct pid_table *n_pt, *new_pt;
    541 	struct proc *proc;
    542 	struct pgrp *pgrp;
    543 	int i;
    544 	int s;
    545 	pid_t pid;
    546 
    547 	new_pt = malloc(pt_size * 2 * sizeof *new_pt, M_PROC, M_WAITOK);
    548 
    549 	s = proclist_lock_write();
    550 	if (pt_size != pid_tbl_mask + 1) {
    551 		/* Another process beat us to it... */
    552 		proclist_unlock_write(s);
    553 		FREE(new_pt, M_PROC);
    554 		return;
    555 	}
    556 
    557 	/*
    558 	 * Copy entries from old table into new one.
    559 	 * If 'pid' is 'odd' we need to place in the upper half,
    560 	 * even pid's to the lower half.
    561 	 * Free items stay in the low half so we don't have to
    562 	 * fixup the reference to them.
    563 	 * We stuff free items on the front of the freelist
    564 	 * because we can't write to unmodified entries.
    565 	 * Processing the table backwards maintains a semblance
    566 	 * of issueing pid numbers that increase with time.
    567 	 */
    568 	i = pt_size - 1;
    569 	n_pt = new_pt + i;
    570 	for (; ; i--, n_pt--) {
    571 		proc = pid_table[i].pt_proc;
    572 		pgrp = pid_table[i].pt_pgrp;
    573 		if (!P_VALID(proc)) {
    574 			/* Up 'use count' so that link is valid */
    575 			pid = (P_NEXT(proc) + pt_size) & ~pt_size;
    576 			proc = P_FREE(pid);
    577 			if (pgrp)
    578 				pid = pgrp->pg_id;
    579 		} else
    580 			pid = proc->p_pid;
    581 
    582 		/* Save entry in appropriate half of table */
    583 		n_pt[pid & pt_size].pt_proc = proc;
    584 		n_pt[pid & pt_size].pt_pgrp = pgrp;
    585 
    586 		/* Put other piece on start of free list */
    587 		pid = (pid ^ pt_size) & ~pid_tbl_mask;
    588 		n_pt[pid & pt_size].pt_proc =
    589 				    P_FREE((pid & ~pt_size) | next_free_pt);
    590 		n_pt[pid & pt_size].pt_pgrp = 0;
    591 		next_free_pt = i | (pid & pt_size);
    592 		if (i == 0)
    593 			break;
    594 	}
    595 
    596 	/* Switch tables */
    597 	n_pt = pid_table;
    598 	pid_table = new_pt;
    599 	pid_tbl_mask = pt_size * 2 - 1;
    600 
    601 	/*
    602 	 * pid_max starts as PID_MAX (= 30000), once we have 16384
    603 	 * allocated pids we need it to be larger!
    604 	 */
    605 	if (pid_tbl_mask > PID_MAX) {
    606 		pid_max = pid_tbl_mask * 2 + 1;
    607 		pid_alloc_lim |= pid_alloc_lim << 1;
    608 	} else
    609 		pid_alloc_lim <<= 1;	/* doubles number of free slots... */
    610 
    611 	proclist_unlock_write(s);
    612 	FREE(n_pt, M_PROC);
    613 }
    614 
    615 struct proc *
    616 proc_alloc(void)
    617 {
    618 	struct proc *p;
    619 	int s;
    620 	int nxt;
    621 	pid_t pid;
    622 	struct pid_table *pt;
    623 
    624 	p = pool_get(&proc_pool, PR_WAITOK);
    625 	p->p_stat = SIDL;			/* protect against others */
    626 
    627 	/* allocate next free pid */
    628 
    629 	for (;;expand_pid_table()) {
    630 		if (__predict_false(pid_alloc_cnt >= pid_alloc_lim))
    631 			/* ensure pids cycle through 2000+ values */
    632 			continue;
    633 		s = proclist_lock_write();
    634 		pt = &pid_table[next_free_pt];
    635 #ifdef DIAGNOSTIC
    636 		if (__predict_false(P_VALID(pt->pt_proc) || pt->pt_pgrp))
    637 			panic("proc_alloc: slot busy");
    638 #endif
    639 		nxt = P_NEXT(pt->pt_proc);
    640 		if (nxt & pid_tbl_mask)
    641 			break;
    642 		/* Table full - expand (NB last entry not used....) */
    643 		proclist_unlock_write(s);
    644 	}
    645 
    646 	/* pid is 'saved use count' + 'size' + entry */
    647 	pid = (nxt & ~pid_tbl_mask) + pid_tbl_mask + 1 + next_free_pt;
    648 	if ((uint)pid > (uint)pid_max)
    649 		pid &= pid_tbl_mask;
    650 	p->p_pid = pid;
    651 	next_free_pt = nxt & pid_tbl_mask;
    652 
    653 	/* Grab table slot */
    654 	pt->pt_proc = p;
    655 	pid_alloc_cnt++;
    656 
    657 	proclist_unlock_write(s);
    658 
    659 	return p;
    660 }
    661 
    662 /*
    663  * Free last resources of a process - called from proc_free (in kern_exit.c)
    664  */
    665 void
    666 proc_free_mem(struct proc *p)
    667 {
    668 	int s;
    669 	pid_t pid = p->p_pid;
    670 	struct pid_table *pt;
    671 
    672 	s = proclist_lock_write();
    673 
    674 	pt = &pid_table[pid & pid_tbl_mask];
    675 #ifdef DIAGNOSTIC
    676 	if (__predict_false(pt->pt_proc != p))
    677 		panic("proc_free: pid_table mismatch, pid %x, proc %p",
    678 			pid, p);
    679 #endif
    680 	/* save pid use count in slot */
    681 	pt->pt_proc = P_FREE(pid & ~pid_tbl_mask);
    682 
    683 	if (pt->pt_pgrp == NULL) {
    684 		/* link last freed entry onto ours */
    685 		pid &= pid_tbl_mask;
    686 		pt = &pid_table[last_free_pt];
    687 		pt->pt_proc = P_FREE(P_NEXT(pt->pt_proc) | pid);
    688 		last_free_pt = pid;
    689 		pid_alloc_cnt--;
    690 	}
    691 
    692 	nprocs--;
    693 	proclist_unlock_write(s);
    694 
    695 	pool_put(&proc_pool, p);
    696 }
    697 
    698 /*
    699  * Move p to a new or existing process group (and session)
    700  *
    701  * If we are creating a new pgrp, the pgid should equal
    702  * the calling process' pid.
    703  * If is only valid to enter a process group that is in the session
    704  * of the process.
    705  * Also mksess should only be set if we are creating a process group
    706  *
    707  * Only called from sys_setsid, sys_setpgid/sys_setpgrp and the
    708  * SYSV setpgrp support for hpux == enterpgrp(curproc, curproc->p_pid)
    709  */
    710 int
    711 enterpgrp(struct proc *p, pid_t pgid, int mksess)
    712 {
    713 	struct pgrp *new_pgrp, *pgrp;
    714 	struct session *sess;
    715 	struct proc *curp = curproc;
    716 	pid_t pid = p->p_pid;
    717 	int rval;
    718 	int s;
    719 	pid_t pg_id = NO_PGID;
    720 
    721 	/* Allocate data areas we might need before doing any validity checks */
    722 	proclist_lock_read();		/* Because pid_table might change */
    723 	if (pid_table[pgid & pid_tbl_mask].pt_pgrp == 0) {
    724 		proclist_unlock_read();
    725 		new_pgrp = pool_get(&pgrp_pool, PR_WAITOK);
    726 	} else {
    727 		proclist_unlock_read();
    728 		new_pgrp = NULL;
    729 	}
    730 	if (mksess)
    731 		sess = pool_get(&session_pool, M_WAITOK);
    732 	else
    733 		sess = NULL;
    734 
    735 	s = proclist_lock_write();
    736 	rval = EPERM;	/* most common error (to save typing) */
    737 
    738 	/* Check pgrp exists or can be created */
    739 	pgrp = pid_table[pgid & pid_tbl_mask].pt_pgrp;
    740 	if (pgrp != NULL && pgrp->pg_id != pgid)
    741 		goto done;
    742 
    743 	/* Can only set another process under restricted circumstances. */
    744 	if (p != curp) {
    745 		/* must exist and be one of our children... */
    746 		if (p != pid_table[pid & pid_tbl_mask].pt_proc
    747 		    || !inferior(p, curp)) {
    748 			rval = ESRCH;
    749 			goto done;
    750 		}
    751 		/* ... in the same session... */
    752 		if (sess != NULL || p->p_session != curp->p_session)
    753 			goto done;
    754 		/* ... existing pgid must be in same session ... */
    755 		if (pgrp != NULL && pgrp->pg_session != p->p_session)
    756 			goto done;
    757 		/* ... and not done an exec. */
    758 		if (p->p_flag & P_EXEC) {
    759 			rval = EACCES;
    760 			goto done;
    761 		}
    762 	}
    763 
    764 	/* Changing the process group/session of a session
    765 	   leader is definitely off limits. */
    766 	if (SESS_LEADER(p)) {
    767 		if (sess == NULL && p->p_pgrp == pgrp)
    768 			/* unless it's a definite noop */
    769 			rval = 0;
    770 		goto done;
    771 	}
    772 
    773 	/* Can only create a process group with id of process */
    774 	if (pgrp == NULL && pgid != pid)
    775 		goto done;
    776 
    777 	/* Can only create a session if creating pgrp */
    778 	if (sess != NULL && pgrp != NULL)
    779 		goto done;
    780 
    781 	/* Check we allocated memory for a pgrp... */
    782 	if (pgrp == NULL && new_pgrp == NULL)
    783 		goto done;
    784 
    785 	/* Don't attach to 'zombie' pgrp */
    786 	if (pgrp != NULL && LIST_EMPTY(&pgrp->pg_members))
    787 		goto done;
    788 
    789 	/* Expect to succeed now */
    790 	rval = 0;
    791 
    792 	if (pgrp == p->p_pgrp)
    793 		/* nothing to do */
    794 		goto done;
    795 
    796 	/* Ok all setup, link up required structures */
    797 	if (pgrp == NULL) {
    798 		pgrp = new_pgrp;
    799 		new_pgrp = 0;
    800 		if (sess != NULL) {
    801 			sess->s_sid = p->p_pid;
    802 			sess->s_leader = p;
    803 			sess->s_count = 1;
    804 			sess->s_ttyvp = NULL;
    805 			sess->s_ttyp = NULL;
    806 			sess->s_flags = p->p_session->s_flags & ~S_LOGIN_SET;
    807 			memcpy(sess->s_login, p->p_session->s_login,
    808 			    sizeof(sess->s_login));
    809 			p->p_flag &= ~P_CONTROLT;
    810 		} else {
    811 			sess = p->p_pgrp->pg_session;
    812 			SESSHOLD(sess);
    813 		}
    814 		pgrp->pg_session = sess;
    815 		sess = 0;
    816 
    817 		pgrp->pg_id = pgid;
    818 		LIST_INIT(&pgrp->pg_members);
    819 #ifdef DIAGNOSTIC
    820 		if (__predict_false(pid_table[pgid & pid_tbl_mask].pt_pgrp))
    821 			panic("enterpgrp: pgrp table slot in use");
    822 		if (__predict_false(mksess && p != curp))
    823 			panic("enterpgrp: mksession and p != curproc");
    824 #endif
    825 		pid_table[pgid & pid_tbl_mask].pt_pgrp = pgrp;
    826 		pgrp->pg_jobc = 0;
    827 	}
    828 
    829 	/*
    830 	 * Adjust eligibility of affected pgrps to participate in job control.
    831 	 * Increment eligibility counts before decrementing, otherwise we
    832 	 * could reach 0 spuriously during the first call.
    833 	 */
    834 	fixjobc(p, pgrp, 1);
    835 	fixjobc(p, p->p_pgrp, 0);
    836 
    837 	/* Move process to requested group */
    838 	LIST_REMOVE(p, p_pglist);
    839 	if (LIST_EMPTY(&p->p_pgrp->pg_members))
    840 		/* defer delete until we've dumped the lock */
    841 		pg_id = p->p_pgrp->pg_id;
    842 	p->p_pgrp = pgrp;
    843 	LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist);
    844 
    845     done:
    846 	proclist_unlock_write(s);
    847 	if (sess != NULL)
    848 		pool_put(&session_pool, sess);
    849 	if (new_pgrp != NULL)
    850 		pool_put(&pgrp_pool, new_pgrp);
    851 	if (pg_id != NO_PGID)
    852 		pg_delete(pg_id);
    853 #ifdef DEBUG_PGRP
    854 	if (__predict_false(rval))
    855 		printf("enterpgrp(%d,%d,%d), curproc %d, rval %d\n",
    856 			pid, pgid, mksess, curp->p_pid, rval);
    857 #endif
    858 	return rval;
    859 }
    860 
    861 /*
    862  * remove process from process group
    863  */
    864 int
    865 leavepgrp(struct proc *p)
    866 {
    867 	int s;
    868 	struct pgrp *pgrp;
    869 	pid_t pg_id;
    870 
    871 	s = proclist_lock_write();
    872 	pgrp = p->p_pgrp;
    873 	LIST_REMOVE(p, p_pglist);
    874 	p->p_pgrp = 0;
    875 	pg_id = LIST_EMPTY(&pgrp->pg_members) ? pgrp->pg_id : NO_PGID;
    876 	proclist_unlock_write(s);
    877 
    878 	if (pg_id != NO_PGID)
    879 		pg_delete(pg_id);
    880 	return 0;
    881 }
    882 
    883 static void
    884 pg_free(pid_t pg_id)
    885 {
    886 	struct pgrp *pgrp;
    887 	struct pid_table *pt;
    888 	int s;
    889 
    890 	s = proclist_lock_write();
    891 	pt = &pid_table[pg_id & pid_tbl_mask];
    892 	pgrp = pt->pt_pgrp;
    893 #ifdef DIAGNOSTIC
    894 	if (__predict_false(!pgrp || pgrp->pg_id != pg_id
    895 	    || !LIST_EMPTY(&pgrp->pg_members)))
    896 		panic("pg_free: process group absent or has members");
    897 #endif
    898 	pt->pt_pgrp = 0;
    899 
    900 	if (!P_VALID(pt->pt_proc)) {
    901 		/* orphaned pgrp, put slot onto free list */
    902 #ifdef DIAGNOSTIC
    903 		if (__predict_false(P_NEXT(pt->pt_proc) & pid_tbl_mask))
    904 			panic("pg_free: process slot on free list");
    905 #endif
    906 
    907 		pg_id &= pid_tbl_mask;
    908 		pt = &pid_table[last_free_pt];
    909 		pt->pt_proc = P_FREE(P_NEXT(pt->pt_proc) | pg_id);
    910 		last_free_pt = pg_id;
    911 		pid_alloc_cnt--;
    912 	}
    913 	proclist_unlock_write(s);
    914 
    915 	pool_put(&pgrp_pool, pgrp);
    916 }
    917 
    918 /*
    919  * delete a process group
    920  */
    921 static void
    922 pg_delete(pid_t pg_id)
    923 {
    924 	struct pgrp *pgrp;
    925 	struct tty *ttyp;
    926 	struct session *ss;
    927 	int s, is_pgrp_leader;
    928 
    929 	s = proclist_lock_write();
    930 	pgrp = pid_table[pg_id & pid_tbl_mask].pt_pgrp;
    931 	if (pgrp == NULL || pgrp->pg_id != pg_id ||
    932 	    !LIST_EMPTY(&pgrp->pg_members)) {
    933 		proclist_unlock_write(s);
    934 		return;
    935 	}
    936 
    937 	ss = pgrp->pg_session;
    938 
    939 	/* Remove reference (if any) from tty to this process group */
    940 	ttyp = ss->s_ttyp;
    941 	if (ttyp != NULL && ttyp->t_pgrp == pgrp) {
    942 		ttyp->t_pgrp = NULL;
    943 #ifdef DIAGNOSTIC
    944 		if (ttyp->t_session != ss)
    945 			panic("pg_delete: wrong session on terminal");
    946 #endif
    947 	}
    948 
    949 	/*
    950 	 * The leading process group in a session is freed
    951 	 * by sessdelete() if last reference.
    952 	 */
    953 	is_pgrp_leader = (ss->s_sid == pgrp->pg_id);
    954 	proclist_unlock_write(s);
    955 	SESSRELE(ss);
    956 
    957 	if (is_pgrp_leader)
    958 		return;
    959 
    960 	pg_free(pg_id);
    961 }
    962 
    963 /*
    964  * Delete session - called from SESSRELE when s_count becomes zero.
    965  */
    966 void
    967 sessdelete(struct session *ss)
    968 {
    969 	/*
    970 	 * We keep the pgrp with the same id as the session in
    971 	 * order to stop a process being given the same pid.
    972 	 * Since the pgrp holds a reference to the session, it
    973 	 * must be a 'zombie' pgrp by now.
    974 	 */
    975 
    976 	pg_free(ss->s_sid);
    977 
    978 	pool_put(&session_pool, ss);
    979 }
    980 
    981 /*
    982  * Adjust pgrp jobc counters when specified process changes process group.
    983  * We count the number of processes in each process group that "qualify"
    984  * the group for terminal job control (those with a parent in a different
    985  * process group of the same session).  If that count reaches zero, the
    986  * process group becomes orphaned.  Check both the specified process'
    987  * process group and that of its children.
    988  * entering == 0 => p is leaving specified group.
    989  * entering == 1 => p is entering specified group.
    990  *
    991  * Call with proclist_lock held.
    992  */
    993 void
    994 fixjobc(struct proc *p, struct pgrp *pgrp, int entering)
    995 {
    996 	struct pgrp *hispgrp;
    997 	struct session *mysession = pgrp->pg_session;
    998 	struct proc *child;
    999 
   1000 	/*
   1001 	 * Check p's parent to see whether p qualifies its own process
   1002 	 * group; if so, adjust count for p's process group.
   1003 	 */
   1004 	hispgrp = p->p_pptr->p_pgrp;
   1005 	if (hispgrp != pgrp && hispgrp->pg_session == mysession) {
   1006 		if (entering)
   1007 			pgrp->pg_jobc++;
   1008 		else if (--pgrp->pg_jobc == 0)
   1009 			orphanpg(pgrp);
   1010 	}
   1011 
   1012 	/*
   1013 	 * Check this process' children to see whether they qualify
   1014 	 * their process groups; if so, adjust counts for children's
   1015 	 * process groups.
   1016 	 */
   1017 	LIST_FOREACH(child, &p->p_children, p_sibling) {
   1018 		hispgrp = child->p_pgrp;
   1019 		if (hispgrp != pgrp && hispgrp->pg_session == mysession &&
   1020 		    !P_ZOMBIE(child)) {
   1021 			if (entering)
   1022 				hispgrp->pg_jobc++;
   1023 			else if (--hispgrp->pg_jobc == 0)
   1024 				orphanpg(hispgrp);
   1025 		}
   1026 	}
   1027 }
   1028 
   1029 /*
   1030  * A process group has become orphaned;
   1031  * if there are any stopped processes in the group,
   1032  * hang-up all process in that group.
   1033  *
   1034  * Call with proclist_lock held.
   1035  */
   1036 static void
   1037 orphanpg(struct pgrp *pg)
   1038 {
   1039 	struct proc *p;
   1040 
   1041 	LIST_FOREACH(p, &pg->pg_members, p_pglist) {
   1042 		if (p->p_stat == SSTOP) {
   1043 			LIST_FOREACH(p, &pg->pg_members, p_pglist) {
   1044 				psignal(p, SIGHUP);
   1045 				psignal(p, SIGCONT);
   1046 			}
   1047 			return;
   1048 		}
   1049 	}
   1050 }
   1051 
   1052 /* mark process as suid/sgid, reset some values to defaults */
   1053 void
   1054 p_sugid(struct proc *p)
   1055 {
   1056 	struct plimit *lim;
   1057 	char *cn;
   1058 
   1059 	p->p_flag |= P_SUGID;
   1060 	/* reset what needs to be reset in plimit */
   1061 	lim = p->p_limit;
   1062 	if (lim->pl_corename != defcorename) {
   1063 		if (lim->p_refcnt > 1 &&
   1064 		    (lim->p_lflags & PL_SHAREMOD) == 0) {
   1065 			p->p_limit = limcopy(lim);
   1066 			limfree(lim);
   1067 			lim = p->p_limit;
   1068 		}
   1069 		simple_lock(&lim->p_slock);
   1070 		cn = lim->pl_corename;
   1071 		lim->pl_corename = defcorename;
   1072 		simple_unlock(&lim->p_slock);
   1073 		if (cn != defcorename)
   1074 			free(cn, M_TEMP);
   1075 	}
   1076 }
   1077 
   1078 #ifdef DDB
   1079 #include <ddb/db_output.h>
   1080 void pidtbl_dump(void);
   1081 void
   1082 pidtbl_dump(void)
   1083 {
   1084 	struct pid_table *pt;
   1085 	struct proc *p;
   1086 	struct pgrp *pgrp;
   1087 	int id;
   1088 
   1089 	db_printf("pid table %p size %x, next %x, last %x\n",
   1090 		pid_table, pid_tbl_mask+1,
   1091 		next_free_pt, last_free_pt);
   1092 	for (pt = pid_table, id = 0; id <= pid_tbl_mask; id++, pt++) {
   1093 		p = pt->pt_proc;
   1094 		if (!P_VALID(p) && !pt->pt_pgrp)
   1095 			continue;
   1096 		db_printf("  id %x: ", id);
   1097 		if (P_VALID(p))
   1098 			db_printf("proc %p id %d (0x%x) %s\n",
   1099 				p, p->p_pid, p->p_pid, p->p_comm);
   1100 		else
   1101 			db_printf("next %x use %x\n",
   1102 				P_NEXT(p) & pid_tbl_mask,
   1103 				P_NEXT(p) & ~pid_tbl_mask);
   1104 		if ((pgrp = pt->pt_pgrp)) {
   1105 			db_printf("\tsession %p, sid %d, count %d, login %s\n",
   1106 			    pgrp->pg_session, pgrp->pg_session->s_sid,
   1107 			    pgrp->pg_session->s_count,
   1108 			    pgrp->pg_session->s_login);
   1109 			db_printf("\tpgrp %p, pg_id %d, pg_jobc %d, members %p\n",
   1110 			    pgrp, pgrp->pg_id, pgrp->pg_jobc,
   1111 			    pgrp->pg_members.lh_first);
   1112 			for (p = pgrp->pg_members.lh_first; p != 0;
   1113 			    p = p->p_pglist.le_next) {
   1114 				db_printf("\t\tpid %d addr %p pgrp %p %s\n",
   1115 				    p->p_pid, p, p->p_pgrp, p->p_comm);
   1116 			}
   1117 		}
   1118 	}
   1119 }
   1120 #endif /* DDB */
   1121 
   1122 #ifdef KSTACK_CHECK_MAGIC
   1123 #include <sys/user.h>
   1124 
   1125 #define	KSTACK_MAGIC	0xdeadbeaf
   1126 
   1127 /* XXX should be per process basis? */
   1128 int kstackleftmin = KSTACK_SIZE;
   1129 int kstackleftthres = KSTACK_SIZE / 8; /* warn if remaining stack is
   1130 					  less than this */
   1131 
   1132 void
   1133 kstack_setup_magic(const struct lwp *l)
   1134 {
   1135 	u_int32_t *ip;
   1136 	u_int32_t const *end;
   1137 
   1138 	KASSERT(l != NULL);
   1139 	KASSERT(l != &lwp0);
   1140 
   1141 	/*
   1142 	 * fill all the stack with magic number
   1143 	 * so that later modification on it can be detected.
   1144 	 */
   1145 	ip = (u_int32_t *)KSTACK_LOWEST_ADDR(l);
   1146 	end = (u_int32_t *)((caddr_t)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE);
   1147 	for (; ip < end; ip++) {
   1148 		*ip = KSTACK_MAGIC;
   1149 	}
   1150 }
   1151 
   1152 void
   1153 kstack_check_magic(const struct lwp *l)
   1154 {
   1155 	u_int32_t const *ip, *end;
   1156 	int stackleft;
   1157 
   1158 	KASSERT(l != NULL);
   1159 
   1160 	/* don't check proc0 */ /*XXX*/
   1161 	if (l == &lwp0)
   1162 		return;
   1163 
   1164 #ifdef __MACHINE_STACK_GROWS_UP
   1165 	/* stack grows upwards (eg. hppa) */
   1166 	ip = (u_int32_t *)((caddr_t)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE);
   1167 	end = (u_int32_t *)KSTACK_LOWEST_ADDR(l);
   1168 	for (ip--; ip >= end; ip--)
   1169 		if (*ip != KSTACK_MAGIC)
   1170 			break;
   1171 
   1172 	stackleft = (caddr_t)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE - (caddr_t)ip;
   1173 #else /* __MACHINE_STACK_GROWS_UP */
   1174 	/* stack grows downwards (eg. i386) */
   1175 	ip = (u_int32_t *)KSTACK_LOWEST_ADDR(l);
   1176 	end = (u_int32_t *)((caddr_t)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE);
   1177 	for (; ip < end; ip++)
   1178 		if (*ip != KSTACK_MAGIC)
   1179 			break;
   1180 
   1181 	stackleft = (caddr_t)ip - KSTACK_LOWEST_ADDR(l);
   1182 #endif /* __MACHINE_STACK_GROWS_UP */
   1183 
   1184 	if (kstackleftmin > stackleft) {
   1185 		kstackleftmin = stackleft;
   1186 		if (stackleft < kstackleftthres)
   1187 			printf("warning: kernel stack left %d bytes"
   1188 			    "(pid %u:lid %u)\n", stackleft,
   1189 			    (u_int)l->l_proc->p_pid, (u_int)l->l_lid);
   1190 	}
   1191 
   1192 	if (stackleft <= 0) {
   1193 		panic("magic on the top of kernel stack changed for "
   1194 		    "pid %u, lid %u: maybe kernel stack overflow",
   1195 		    (u_int)l->l_proc->p_pid, (u_int)l->l_lid);
   1196 	}
   1197 }
   1198 #endif /* KSTACK_CHECK_MAGIC */
   1199 
   1200 /* XXX shouldn't be here */
   1201 #if defined(MULTIPROCESSOR) || defined(LOCKDEBUG)
   1202 #define	PROCLIST_ASSERT_LOCKED_READ()	\
   1203 	KASSERT(lockstatus(&proclist_lock) == LK_SHARED)
   1204 #else
   1205 #define	PROCLIST_ASSERT_LOCKED_READ()	/* nothing */
   1206 #endif
   1207 
   1208 int
   1209 proclist_foreach_call(struct proclist *list,
   1210     int (*callback)(struct proc *, void *arg), void *arg)
   1211 {
   1212 	struct proc marker;
   1213 	struct proc *p;
   1214 	struct lwp * const l = curlwp;
   1215 	int ret = 0;
   1216 
   1217 	marker.p_flag = P_MARKER;
   1218 	PHOLD(l);
   1219 	proclist_lock_read();
   1220 	for (p = LIST_FIRST(list); ret == 0 && p != NULL;) {
   1221 		if (p->p_flag & P_MARKER) {
   1222 			p = LIST_NEXT(p, p_list);
   1223 			continue;
   1224 		}
   1225 		LIST_INSERT_AFTER(p, &marker, p_list);
   1226 		ret = (*callback)(p, arg);
   1227 		PROCLIST_ASSERT_LOCKED_READ();
   1228 		p = LIST_NEXT(&marker, p_list);
   1229 		LIST_REMOVE(&marker, p_list);
   1230 	}
   1231 	proclist_unlock_read();
   1232 	PRELE(l);
   1233 
   1234 	return ret;
   1235 }
   1236