Home | History | Annotate | Line # | Download | only in kern
kern_proc.c revision 1.52
      1 /*	$NetBSD: kern_proc.c,v 1.52 2002/09/04 01:32:33 matt 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. All advertising materials mentioning features or use of this software
     53  *    must display the following acknowledgement:
     54  *	This product includes software developed by the University of
     55  *	California, Berkeley and its contributors.
     56  * 4. Neither the name of the University nor the names of its contributors
     57  *    may be used to endorse or promote products derived from this software
     58  *    without specific prior written permission.
     59  *
     60  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     61  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     62  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     63  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     64  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     65  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     66  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     67  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     68  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     69  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     70  * SUCH DAMAGE.
     71  *
     72  *	@(#)kern_proc.c	8.7 (Berkeley) 2/14/95
     73  */
     74 
     75 #include <sys/cdefs.h>
     76 __KERNEL_RCSID(0, "$NetBSD: kern_proc.c,v 1.52 2002/09/04 01:32:33 matt Exp $");
     77 
     78 #include "opt_kstack.h"
     79 
     80 #include <sys/param.h>
     81 #include <sys/systm.h>
     82 #include <sys/map.h>
     83 #include <sys/kernel.h>
     84 #include <sys/proc.h>
     85 #include <sys/resourcevar.h>
     86 #include <sys/buf.h>
     87 #include <sys/acct.h>
     88 #include <sys/wait.h>
     89 #include <sys/file.h>
     90 #include <ufs/ufs/quota.h>
     91 #include <sys/uio.h>
     92 #include <sys/malloc.h>
     93 #include <sys/pool.h>
     94 #include <sys/mbuf.h>
     95 #include <sys/ioctl.h>
     96 #include <sys/tty.h>
     97 #include <sys/signalvar.h>
     98 #include <sys/ras.h>
     99 
    100 /*
    101  * Structure associated with user cacheing.
    102  */
    103 struct uidinfo {
    104 	LIST_ENTRY(uidinfo) ui_hash;
    105 	uid_t	ui_uid;
    106 	long	ui_proccnt;
    107 };
    108 #define	UIHASH(uid)	(&uihashtbl[(uid) & uihash])
    109 LIST_HEAD(uihashhead, uidinfo) *uihashtbl;
    110 u_long uihash;		/* size of hash table - 1 */
    111 
    112 /*
    113  * Other process lists
    114  */
    115 struct pidhashhead *pidhashtbl;
    116 u_long pidhash;
    117 struct pgrphashhead *pgrphashtbl;
    118 u_long pgrphash;
    119 
    120 struct proclist allproc;
    121 struct proclist zombproc;	/* resources have been freed */
    122 
    123 /*
    124  * Process list locking:
    125  *
    126  * We have two types of locks on the proclists: read locks and write
    127  * locks.  Read locks can be used in interrupt context, so while we
    128  * hold the write lock, we must also block clock interrupts to
    129  * lock out any scheduling changes that may happen in interrupt
    130  * context.
    131  *
    132  * The proclist lock locks the following structures:
    133  *
    134  *	allproc
    135  *	zombproc
    136  *	pidhashtbl
    137  */
    138 struct lock proclist_lock;
    139 
    140 /*
    141  * Locking of this proclist is special; it's accessed in a
    142  * critical section of process exit, and thus locking it can't
    143  * modify interrupt state.  We use a simple spin lock for this
    144  * proclist.  Processes on this proclist are also on zombproc;
    145  * we use the p_hash member to linkup to deadproc.
    146  */
    147 struct simplelock deadproc_slock;
    148 struct proclist deadproc;	/* dead, but not yet undead */
    149 
    150 struct pool proc_pool;
    151 struct pool pcred_pool;
    152 struct pool plimit_pool;
    153 struct pool pgrp_pool;
    154 struct pool rusage_pool;
    155 struct pool ras_pool;
    156 
    157 /*
    158  * The process list descriptors, used during pid allocation and
    159  * by sysctl.  No locking on this data structure is needed since
    160  * it is completely static.
    161  */
    162 const struct proclist_desc proclists[] = {
    163 	{ &allproc	},
    164 	{ &zombproc	},
    165 	{ NULL		},
    166 };
    167 
    168 static void orphanpg __P((struct pgrp *));
    169 #ifdef DEBUG
    170 void pgrpdump __P((void));
    171 #endif
    172 
    173 /*
    174  * Initialize global process hashing structures.
    175  */
    176 void
    177 procinit()
    178 {
    179 	const struct proclist_desc *pd;
    180 
    181 	for (pd = proclists; pd->pd_list != NULL; pd++)
    182 		LIST_INIT(pd->pd_list);
    183 
    184 	spinlockinit(&proclist_lock, "proclk", 0);
    185 
    186 	LIST_INIT(&deadproc);
    187 	simple_lock_init(&deadproc_slock);
    188 
    189 	pidhashtbl =
    190 	    hashinit(maxproc / 4, HASH_LIST, M_PROC, M_WAITOK, &pidhash);
    191 	pgrphashtbl =
    192 	    hashinit(maxproc / 4, HASH_LIST, M_PROC, M_WAITOK, &pgrphash);
    193 	uihashtbl =
    194 	    hashinit(maxproc / 16, HASH_LIST, M_PROC, M_WAITOK, &uihash);
    195 
    196 	pool_init(&proc_pool, sizeof(struct proc), 0, 0, 0, "procpl",
    197 	    &pool_allocator_nointr);
    198 	pool_init(&pgrp_pool, sizeof(struct pgrp), 0, 0, 0, "pgrppl",
    199 	    &pool_allocator_nointr);
    200 	pool_init(&pcred_pool, sizeof(struct pcred), 0, 0, 0, "pcredpl",
    201 	    &pool_allocator_nointr);
    202 	pool_init(&plimit_pool, sizeof(struct plimit), 0, 0, 0, "plimitpl",
    203 	    &pool_allocator_nointr);
    204 	pool_init(&rusage_pool, sizeof(struct rusage), 0, 0, 0, "rusgepl",
    205 	    &pool_allocator_nointr);
    206 	pool_init(&ras_pool, sizeof(struct ras), 0, 0, 0, "raspl",
    207 	    &pool_allocator_nointr);
    208 }
    209 
    210 /*
    211  * Acquire a read lock on the proclist.
    212  */
    213 void
    214 proclist_lock_read()
    215 {
    216 	int error;
    217 
    218 	error = spinlockmgr(&proclist_lock, LK_SHARED, NULL);
    219 #ifdef DIAGNOSTIC
    220 	if (__predict_false(error != 0))
    221 		panic("proclist_lock_read: failed to acquire lock");
    222 #endif
    223 }
    224 
    225 /*
    226  * Release a read lock on the proclist.
    227  */
    228 void
    229 proclist_unlock_read()
    230 {
    231 
    232 	(void) spinlockmgr(&proclist_lock, LK_RELEASE, NULL);
    233 }
    234 
    235 /*
    236  * Acquire a write lock on the proclist.
    237  */
    238 int
    239 proclist_lock_write()
    240 {
    241 	int s, error;
    242 
    243 	s = splclock();
    244 	error = spinlockmgr(&proclist_lock, LK_EXCLUSIVE, NULL);
    245 #ifdef DIAGNOSTIC
    246 	if (__predict_false(error != 0))
    247 		panic("proclist_lock: failed to acquire lock");
    248 #endif
    249 	return (s);
    250 }
    251 
    252 /*
    253  * Release a write lock on the proclist.
    254  */
    255 void
    256 proclist_unlock_write(s)
    257 	int s;
    258 {
    259 
    260 	(void) spinlockmgr(&proclist_lock, LK_RELEASE, NULL);
    261 	splx(s);
    262 }
    263 
    264 /*
    265  * Change the count associated with number of processes
    266  * a given user is using.
    267  */
    268 int
    269 chgproccnt(uid, diff)
    270 	uid_t	uid;
    271 	int	diff;
    272 {
    273 	struct uidinfo *uip;
    274 	struct uihashhead *uipp;
    275 
    276 	uipp = UIHASH(uid);
    277 
    278 	LIST_FOREACH(uip, uipp, ui_hash)
    279 		if (uip->ui_uid == uid)
    280 			break;
    281 
    282 	if (uip) {
    283 		uip->ui_proccnt += diff;
    284 		if (uip->ui_proccnt > 0)
    285 			return (uip->ui_proccnt);
    286 		if (uip->ui_proccnt < 0)
    287 			panic("chgproccnt: procs < 0");
    288 		LIST_REMOVE(uip, ui_hash);
    289 		FREE(uip, M_PROC);
    290 		return (0);
    291 	}
    292 	if (diff <= 0) {
    293 		if (diff == 0)
    294 			return(0);
    295 		panic("chgproccnt: lost user");
    296 	}
    297 	MALLOC(uip, struct uidinfo *, sizeof(*uip), M_PROC, M_WAITOK);
    298 	LIST_INSERT_HEAD(uipp, uip, ui_hash);
    299 	uip->ui_uid = uid;
    300 	uip->ui_proccnt = diff;
    301 	return (diff);
    302 }
    303 
    304 /*
    305  * Is p an inferior of q?
    306  */
    307 int
    308 inferior(p, q)
    309 	struct proc *p;
    310 	struct proc *q;
    311 {
    312 
    313 	for (; p != q; p = p->p_pptr)
    314 		if (p->p_pid == 0)
    315 			return (0);
    316 	return (1);
    317 }
    318 
    319 /*
    320  * Locate a process by number
    321  */
    322 struct proc *
    323 pfind(pid)
    324 	pid_t pid;
    325 {
    326 	struct proc *p;
    327 
    328 	proclist_lock_read();
    329 	LIST_FOREACH(p, PIDHASH(pid), p_hash)
    330 		if (p->p_pid == pid)
    331 			goto out;
    332  out:
    333 	proclist_unlock_read();
    334 	return (p);
    335 }
    336 
    337 /*
    338  * Locate a process group by number
    339  */
    340 struct pgrp *
    341 pgfind(pgid)
    342 	pid_t pgid;
    343 {
    344 	struct pgrp *pgrp;
    345 
    346 	LIST_FOREACH(pgrp, PGRPHASH(pgid), pg_hash)
    347 		if (pgrp->pg_id == pgid)
    348 			return (pgrp);
    349 	return (NULL);
    350 }
    351 
    352 /*
    353  * Move p to a new or existing process group (and session)
    354  */
    355 int
    356 enterpgrp(p, pgid, mksess)
    357 	struct proc *p;
    358 	pid_t pgid;
    359 	int mksess;
    360 {
    361 	struct pgrp *pgrp = pgfind(pgid);
    362 
    363 #ifdef DIAGNOSTIC
    364 	if (__predict_false(pgrp != NULL && mksess))	/* firewalls */
    365 		panic("enterpgrp: setsid into non-empty pgrp");
    366 	if (__predict_false(SESS_LEADER(p)))
    367 		panic("enterpgrp: session leader attempted setpgrp");
    368 #endif
    369 	if (pgrp == NULL) {
    370 		pid_t savepid = p->p_pid;
    371 		struct proc *np;
    372 		/*
    373 		 * new process group
    374 		 */
    375 #ifdef DIAGNOSTIC
    376 		if (__predict_false(p->p_pid != pgid))
    377 			panic("enterpgrp: new pgrp and pid != pgid");
    378 #endif
    379 		pgrp = pool_get(&pgrp_pool, PR_WAITOK);
    380 		if ((np = pfind(savepid)) == NULL || np != p) {
    381 			pool_put(&pgrp_pool, pgrp);
    382 			return (ESRCH);
    383 		}
    384 		if (mksess) {
    385 			struct session *sess;
    386 
    387 			/*
    388 			 * new session
    389 			 */
    390 			MALLOC(sess, struct session *, sizeof(struct session),
    391 			    M_SESSION, M_WAITOK);
    392 			if ((np = pfind(savepid)) == NULL || np != p) {
    393 				FREE(sess, M_SESSION);
    394 				pool_put(&pgrp_pool, pgrp);
    395 				return (ESRCH);
    396 			}
    397 			sess->s_sid = p->p_pid;
    398 			sess->s_leader = p;
    399 			sess->s_count = 1;
    400 			sess->s_ttyvp = NULL;
    401 			sess->s_ttyp = NULL;
    402 			memcpy(sess->s_login, p->p_session->s_login,
    403 			    sizeof(sess->s_login));
    404 			p->p_flag &= ~P_CONTROLT;
    405 			pgrp->pg_session = sess;
    406 #ifdef DIAGNOSTIC
    407 			if (__predict_false(p != curproc))
    408 				panic("enterpgrp: mksession and p != curproc");
    409 #endif
    410 		} else {
    411 			SESSHOLD(p->p_session);
    412 			pgrp->pg_session = p->p_session;
    413 		}
    414 		pgrp->pg_id = pgid;
    415 		LIST_INIT(&pgrp->pg_members);
    416 		LIST_INSERT_HEAD(PGRPHASH(pgid), pgrp, pg_hash);
    417 		pgrp->pg_jobc = 0;
    418 	} else if (pgrp == p->p_pgrp)
    419 		return (0);
    420 
    421 	/*
    422 	 * Adjust eligibility of affected pgrps to participate in job control.
    423 	 * Increment eligibility counts before decrementing, otherwise we
    424 	 * could reach 0 spuriously during the first call.
    425 	 */
    426 	fixjobc(p, pgrp, 1);
    427 	fixjobc(p, p->p_pgrp, 0);
    428 
    429 	LIST_REMOVE(p, p_pglist);
    430 	if (LIST_EMPTY(&p->p_pgrp->pg_members))
    431 		pgdelete(p->p_pgrp);
    432 	p->p_pgrp = pgrp;
    433 	LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist);
    434 	return (0);
    435 }
    436 
    437 /*
    438  * remove process from process group
    439  */
    440 int
    441 leavepgrp(p)
    442 	struct proc *p;
    443 {
    444 
    445 	LIST_REMOVE(p, p_pglist);
    446 	if (LIST_EMPTY(&p->p_pgrp->pg_members))
    447 		pgdelete(p->p_pgrp);
    448 	p->p_pgrp = 0;
    449 	return (0);
    450 }
    451 
    452 /*
    453  * delete a process group
    454  */
    455 void
    456 pgdelete(pgrp)
    457 	struct pgrp *pgrp;
    458 {
    459 
    460 	/* Remove reference (if any) from tty to this process group */
    461 	if (pgrp->pg_session->s_ttyp != NULL &&
    462 	    pgrp->pg_session->s_ttyp->t_pgrp == pgrp)
    463 		pgrp->pg_session->s_ttyp->t_pgrp = NULL;
    464 	LIST_REMOVE(pgrp, pg_hash);
    465 	SESSRELE(pgrp->pg_session);
    466 	pool_put(&pgrp_pool, pgrp);
    467 }
    468 
    469 /*
    470  * Adjust pgrp jobc counters when specified process changes process group.
    471  * We count the number of processes in each process group that "qualify"
    472  * the group for terminal job control (those with a parent in a different
    473  * process group of the same session).  If that count reaches zero, the
    474  * process group becomes orphaned.  Check both the specified process'
    475  * process group and that of its children.
    476  * entering == 0 => p is leaving specified group.
    477  * entering == 1 => p is entering specified group.
    478  */
    479 void
    480 fixjobc(p, pgrp, entering)
    481 	struct proc *p;
    482 	struct pgrp *pgrp;
    483 	int entering;
    484 {
    485 	struct pgrp *hispgrp;
    486 	struct session *mysession = pgrp->pg_session;
    487 
    488 	/*
    489 	 * Check p's parent to see whether p qualifies its own process
    490 	 * group; if so, adjust count for p's process group.
    491 	 */
    492 	if ((hispgrp = p->p_pptr->p_pgrp) != pgrp &&
    493 	    hispgrp->pg_session == mysession) {
    494 		if (entering)
    495 			pgrp->pg_jobc++;
    496 		else if (--pgrp->pg_jobc == 0)
    497 			orphanpg(pgrp);
    498 	}
    499 
    500 	/*
    501 	 * Check this process' children to see whether they qualify
    502 	 * their process groups; if so, adjust counts for children's
    503 	 * process groups.
    504 	 */
    505 	LIST_FOREACH(p, &p->p_children, p_sibling) {
    506 		if ((hispgrp = p->p_pgrp) != pgrp &&
    507 		    hispgrp->pg_session == mysession &&
    508 		    P_ZOMBIE(p) == 0) {
    509 			if (entering)
    510 				hispgrp->pg_jobc++;
    511 			else if (--hispgrp->pg_jobc == 0)
    512 				orphanpg(hispgrp);
    513 		}
    514 	}
    515 }
    516 
    517 /*
    518  * A process group has become orphaned;
    519  * if there are any stopped processes in the group,
    520  * hang-up all process in that group.
    521  */
    522 static void
    523 orphanpg(pg)
    524 	struct pgrp *pg;
    525 {
    526 	struct proc *p;
    527 
    528 	LIST_FOREACH(p, &pg->pg_members, p_pglist) {
    529 		if (p->p_stat == SSTOP) {
    530 			LIST_FOREACH(p, &pg->pg_members, p_pglist) {
    531 				psignal(p, SIGHUP);
    532 				psignal(p, SIGCONT);
    533 			}
    534 			return;
    535 		}
    536 	}
    537 }
    538 
    539 /* mark process as suid/sgid, reset some values do defaults */
    540 void
    541 p_sugid(p)
    542 	struct proc *p;
    543 {
    544 	struct plimit *newlim;
    545 
    546 	p->p_flag |= P_SUGID;
    547 	/* reset what needs to be reset in plimit */
    548 	if (p->p_limit->pl_corename != defcorename) {
    549 		if (p->p_limit->p_refcnt > 1 &&
    550 		    (p->p_limit->p_lflags & PL_SHAREMOD) == 0) {
    551 			newlim = limcopy(p->p_limit);
    552 			limfree(p->p_limit);
    553 			p->p_limit = newlim;
    554 		}
    555 		free(p->p_limit->pl_corename, M_TEMP);
    556 		p->p_limit->pl_corename = defcorename;
    557 	}
    558 }
    559 
    560 #ifdef DEBUG
    561 void
    562 pgrpdump()
    563 {
    564 	struct pgrp *pgrp;
    565 	struct proc *p;
    566 	int i;
    567 
    568 	for (i = 0; i <= pgrphash; i++) {
    569 		if ((pgrp = LIST_FIRST(&pgrphashtbl[i])) != NULL) {
    570 			printf("\tindx %d\n", i);
    571 			for (; pgrp != 0; pgrp = pgrp->pg_hash.le_next) {
    572 				printf("\tpgrp %p, pgid %d, sess %p, "
    573 				    "sesscnt %d, mem %p\n",
    574 				    pgrp, pgrp->pg_id, pgrp->pg_session,
    575 				    pgrp->pg_session->s_count,
    576 				    LIST_FIRST(&pgrp->pg_members));
    577 				LIST_FOREACH(p, &pgrp->pg_members, p_pglist) {
    578 					printf("\t\tpid %d addr %p pgrp %p\n",
    579 					    p->p_pid, p, p->p_pgrp);
    580 				}
    581 			}
    582 		}
    583 	}
    584 }
    585 #endif /* DEBUG */
    586 
    587 #ifdef KSTACK_CHECK_MAGIC
    588 #include <sys/user.h>
    589 
    590 #define	KSTACK_MAGIC	0xdeadbeaf
    591 
    592 /* XXX should be per process basis? */
    593 int kstackleftmin = KSTACK_SIZE;
    594 int kstackleftthres = KSTACK_SIZE / 8; /* warn if remaining stack is
    595 					  less than this */
    596 
    597 void
    598 kstack_setup_magic(const struct proc *p)
    599 {
    600 	u_int32_t *ip;
    601 	u_int32_t const *end;
    602 
    603 	KASSERT(p != 0);
    604 	KASSERT(p != &proc0);
    605 
    606 	/*
    607 	 * fill all the stack with magic number
    608 	 * so that later modification on it can be detected.
    609 	 */
    610 	ip = (u_int32_t *)KSTACK_LOWEST_ADDR(p);
    611 	end = (u_int32_t *)((caddr_t)KSTACK_LOWEST_ADDR(p) + KSTACK_SIZE);
    612 	for (; ip < end; ip++) {
    613 		*ip = KSTACK_MAGIC;
    614 	}
    615 }
    616 
    617 void
    618 kstack_check_magic(const struct proc *p)
    619 {
    620 	u_int32_t const *ip, *end;
    621 	int stackleft;
    622 
    623 	KASSERT(p != 0);
    624 
    625 	/* don't check proc0 */ /*XXX*/
    626 	if (p == &proc0)
    627 		return;
    628 
    629 #ifdef __MACHINE_STACK_GROWS_UP
    630 	/* stack grows upwards (eg. hppa) */
    631 	ip = (u_int32_t *)((caddr_t)KSTACK_LOWEST_ADDR(p) + KSTACK_SIZE);
    632 	end = (u_int32_t *)KSTACK_LOWEST_ADDR(p);
    633 	for (ip--; ip >= end; ip--)
    634 		if (*ip != KSTACK_MAGIC)
    635 			break;
    636 
    637 	stackleft = (caddr_t)KSTACK_LOWEST_ADDR(p) + KSTACK_SIZE - (caddr_t)ip;
    638 #else /* __MACHINE_STACK_GROWS_UP */
    639 	/* stack grows downwards (eg. i386) */
    640 	ip = (u_int32_t *)KSTACK_LOWEST_ADDR(p);
    641 	end = (u_int32_t *)((caddr_t)KSTACK_LOWEST_ADDR(p) + KSTACK_SIZE);
    642 	for (; ip < end; ip++)
    643 		if (*ip != KSTACK_MAGIC)
    644 			break;
    645 
    646 	stackleft = (caddr_t)ip - KSTACK_LOWEST_ADDR(p);
    647 #endif /* __MACHINE_STACK_GROWS_UP */
    648 
    649 	if (kstackleftmin > stackleft) {
    650 		kstackleftmin = stackleft;
    651 		if (stackleft < kstackleftthres)
    652 			printf("warning: kernel stack left %d bytes(pid %u)\n",
    653 			    stackleft, p->p_pid);
    654 	}
    655 
    656 	if (stackleft <= 0) {
    657 		panic("magic on the top of kernel stack changed for pid %u: "
    658 		    "maybe kernel stack overflow\n", p->p_pid);
    659 	}
    660 }
    661 #endif /* KSTACK_CHECK_MAGIC */
    662