Annotation of sys/kern/kern_proc.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: kern_proc.c,v 1.34 2007/08/04 02:43:54 ckuethe Exp $ */
! 2: /* $NetBSD: kern_proc.c,v 1.14 1996/02/09 18:59:41 christos Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1982, 1986, 1989, 1991, 1993
! 6: * The Regents of the University of California. All rights reserved.
! 7: *
! 8: * Redistribution and use in source and binary forms, with or without
! 9: * modification, are permitted provided that the following conditions
! 10: * are met:
! 11: * 1. Redistributions of source code must retain the above copyright
! 12: * notice, this list of conditions and the following disclaimer.
! 13: * 2. Redistributions in binary form must reproduce the above copyright
! 14: * notice, this list of conditions and the following disclaimer in the
! 15: * documentation and/or other materials provided with the distribution.
! 16: * 3. Neither the name of the University nor the names of its contributors
! 17: * may be used to endorse or promote products derived from this software
! 18: * without specific prior written permission.
! 19: *
! 20: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 21: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 22: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 23: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 24: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 25: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 26: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 27: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 28: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 29: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 30: * SUCH DAMAGE.
! 31: *
! 32: * @(#)kern_proc.c 8.4 (Berkeley) 1/4/94
! 33: */
! 34:
! 35: #include <sys/param.h>
! 36: #include <sys/systm.h>
! 37: #include <sys/kernel.h>
! 38: #include <sys/proc.h>
! 39: #include <sys/buf.h>
! 40: #include <sys/acct.h>
! 41: #include <sys/wait.h>
! 42: #include <sys/file.h>
! 43: #include <ufs/ufs/quota.h>
! 44: #include <sys/uio.h>
! 45: #include <sys/malloc.h>
! 46: #include <sys/mbuf.h>
! 47: #include <sys/ioctl.h>
! 48: #include <sys/tty.h>
! 49: #include <sys/signalvar.h>
! 50: #include <sys/pool.h>
! 51:
! 52: #define UIHASH(uid) (&uihashtbl[(uid) & uihash])
! 53: LIST_HEAD(uihashhead, uidinfo) *uihashtbl;
! 54: u_long uihash; /* size of hash table - 1 */
! 55:
! 56: /*
! 57: * Other process lists
! 58: */
! 59: struct pidhashhead *pidhashtbl;
! 60: u_long pidhash;
! 61: struct pgrphashhead *pgrphashtbl;
! 62: u_long pgrphash;
! 63: struct proclist allproc;
! 64: struct proclist zombproc;
! 65:
! 66: struct pool proc_pool;
! 67: struct pool process_pool;
! 68: struct pool rusage_pool;
! 69: struct pool ucred_pool;
! 70: struct pool pgrp_pool;
! 71: struct pool session_pool;
! 72: struct pool pcred_pool;
! 73:
! 74: static void orphanpg(struct pgrp *);
! 75: #ifdef DEBUG
! 76: void pgrpdump(void);
! 77: #endif
! 78:
! 79: /*
! 80: * Initialize global process hashing structures.
! 81: */
! 82: void
! 83: procinit(void)
! 84: {
! 85: LIST_INIT(&allproc);
! 86: LIST_INIT(&zombproc);
! 87:
! 88:
! 89: pidhashtbl = hashinit(maxproc / 4, M_PROC, M_NOWAIT, &pidhash);
! 90: pgrphashtbl = hashinit(maxproc / 4, M_PROC, M_NOWAIT, &pgrphash);
! 91: uihashtbl = hashinit(maxproc / 16, M_PROC, M_NOWAIT, &uihash);
! 92: if (!pidhashtbl || !pgrphashtbl || !uihashtbl)
! 93: panic("procinit: malloc");
! 94:
! 95: pool_init(&proc_pool, sizeof(struct proc), 0, 0, 0, "procpl",
! 96: &pool_allocator_nointr);
! 97: pool_init(&process_pool, sizeof(struct process), 0, 0, 0, "processpl",
! 98: &pool_allocator_nointr);
! 99: pool_init(&rusage_pool, sizeof(struct rusage), 0, 0, 0, "zombiepl",
! 100: &pool_allocator_nointr);
! 101: pool_init(&ucred_pool, sizeof(struct ucred), 0, 0, 0, "ucredpl",
! 102: &pool_allocator_nointr);
! 103: pool_init(&pgrp_pool, sizeof(struct pgrp), 0, 0, 0, "pgrppl",
! 104: &pool_allocator_nointr);
! 105: pool_init(&session_pool, sizeof(struct session), 0, 0, 0, "sessionpl",
! 106: &pool_allocator_nointr);
! 107: pool_init(&pcred_pool, sizeof(struct pcred), 0, 0, 0, "pcredpl",
! 108: &pool_allocator_nointr);
! 109: }
! 110:
! 111: /*
! 112: * Change the count associated with number of processes
! 113: * a given user is using.
! 114: */
! 115: struct uidinfo *
! 116: uid_find(uid_t uid)
! 117: {
! 118: struct uidinfo *uip, *nuip;
! 119: struct uihashhead *uipp;
! 120:
! 121: uipp = UIHASH(uid);
! 122: LIST_FOREACH(uip, uipp, ui_hash)
! 123: if (uip->ui_uid == uid)
! 124: break;
! 125: if (uip)
! 126: return (uip);
! 127: MALLOC(nuip, struct uidinfo *, sizeof(*nuip), M_PROC, M_WAITOK);
! 128: /* may have slept, have to check again */
! 129: LIST_FOREACH(uip, uipp, ui_hash)
! 130: if (uip->ui_uid == uid)
! 131: break;
! 132: if (uip) {
! 133: free(nuip, M_PROC);
! 134: return (uip);
! 135: }
! 136: bzero(nuip, sizeof(*nuip));
! 137: nuip->ui_uid = uid;
! 138: LIST_INSERT_HEAD(uipp, nuip, ui_hash);
! 139:
! 140: return (nuip);
! 141: }
! 142:
! 143: int
! 144: chgproccnt(uid_t uid, int diff)
! 145: {
! 146: struct uidinfo *uip;
! 147:
! 148: uip = uid_find(uid);
! 149: uip->ui_proccnt += diff;
! 150: if (uip->ui_proccnt < 0)
! 151: panic("chgproccnt: procs < 0");
! 152: return (uip->ui_proccnt);
! 153: }
! 154:
! 155: /*
! 156: * Is p an inferior of the current process?
! 157: */
! 158: int
! 159: inferior(struct proc *p)
! 160: {
! 161:
! 162: for (; p != curproc; p = p->p_pptr)
! 163: if (p->p_pid == 0)
! 164: return (0);
! 165: return (1);
! 166: }
! 167:
! 168: /*
! 169: * Locate a process by number
! 170: */
! 171: struct proc *
! 172: pfind(pid_t pid)
! 173: {
! 174: struct proc *p;
! 175:
! 176: LIST_FOREACH(p, PIDHASH(pid), p_hash)
! 177: if (p->p_pid == pid)
! 178: return (p);
! 179: return (NULL);
! 180: }
! 181:
! 182: /*
! 183: * Locate a process group by number
! 184: */
! 185: struct pgrp *
! 186: pgfind(pid_t pgid)
! 187: {
! 188: struct pgrp *pgrp;
! 189:
! 190: LIST_FOREACH(pgrp, PGRPHASH(pgid), pg_hash)
! 191: if (pgrp->pg_id == pgid)
! 192: return (pgrp);
! 193: return (NULL);
! 194: }
! 195:
! 196: /*
! 197: * Move p to a new or existing process group (and session)
! 198: */
! 199: int
! 200: enterpgrp(struct proc *p, pid_t pgid, int mksess)
! 201: {
! 202: struct pgrp *pgrp = pgfind(pgid);
! 203:
! 204: #ifdef DIAGNOSTIC
! 205: if (pgrp != NULL && mksess) /* firewalls */
! 206: panic("enterpgrp: setsid into non-empty pgrp");
! 207: if (SESS_LEADER(p))
! 208: panic("enterpgrp: session leader attempted setpgrp");
! 209: #endif
! 210: if (pgrp == NULL) {
! 211: pid_t savepid = p->p_pid;
! 212: struct proc *np;
! 213: /*
! 214: * new process group
! 215: */
! 216: #ifdef DIAGNOSTIC
! 217: if (p->p_pid != pgid)
! 218: panic("enterpgrp: new pgrp and pid != pgid");
! 219: #endif
! 220: if ((np = pfind(savepid)) == NULL || np != p)
! 221: return (ESRCH);
! 222: pgrp = pool_get(&pgrp_pool, PR_WAITOK);
! 223: if (mksess) {
! 224: struct session *sess;
! 225:
! 226: /*
! 227: * new session
! 228: */
! 229: sess = pool_get(&session_pool, PR_WAITOK);
! 230: sess->s_leader = p;
! 231: sess->s_count = 1;
! 232: sess->s_ttyvp = NULL;
! 233: sess->s_ttyp = NULL;
! 234: bcopy(p->p_session->s_login, sess->s_login,
! 235: sizeof(sess->s_login));
! 236: atomic_clearbits_int(&p->p_flag, P_CONTROLT);
! 237: pgrp->pg_session = sess;
! 238: #ifdef DIAGNOSTIC
! 239: if (p != curproc)
! 240: panic("enterpgrp: mksession and p != curproc");
! 241: #endif
! 242: } else {
! 243: pgrp->pg_session = p->p_session;
! 244: pgrp->pg_session->s_count++;
! 245: }
! 246: pgrp->pg_id = pgid;
! 247: LIST_INIT(&pgrp->pg_members);
! 248: LIST_INSERT_HEAD(PGRPHASH(pgid), pgrp, pg_hash);
! 249: pgrp->pg_jobc = 0;
! 250: } else if (pgrp == p->p_pgrp)
! 251: return (0);
! 252:
! 253: /*
! 254: * Adjust eligibility of affected pgrps to participate in job control.
! 255: * Increment eligibility counts before decrementing, otherwise we
! 256: * could reach 0 spuriously during the first call.
! 257: */
! 258: fixjobc(p, pgrp, 1);
! 259: fixjobc(p, p->p_pgrp, 0);
! 260:
! 261: LIST_REMOVE(p, p_pglist);
! 262: if (LIST_EMPTY(&p->p_pgrp->pg_members))
! 263: pgdelete(p->p_pgrp);
! 264: p->p_pgrp = pgrp;
! 265: LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist);
! 266: return (0);
! 267: }
! 268:
! 269: /*
! 270: * remove process from process group
! 271: */
! 272: int
! 273: leavepgrp(struct proc *p)
! 274: {
! 275:
! 276: LIST_REMOVE(p, p_pglist);
! 277: if (LIST_EMPTY(&p->p_pgrp->pg_members))
! 278: pgdelete(p->p_pgrp);
! 279: p->p_pgrp = 0;
! 280: return (0);
! 281: }
! 282:
! 283: /*
! 284: * delete a process group
! 285: */
! 286: void
! 287: pgdelete(struct pgrp *pgrp)
! 288: {
! 289:
! 290: if (pgrp->pg_session->s_ttyp != NULL &&
! 291: pgrp->pg_session->s_ttyp->t_pgrp == pgrp)
! 292: pgrp->pg_session->s_ttyp->t_pgrp = NULL;
! 293: LIST_REMOVE(pgrp, pg_hash);
! 294: SESSRELE(pgrp->pg_session);
! 295: pool_put(&pgrp_pool, pgrp);
! 296: }
! 297:
! 298: /*
! 299: * Adjust pgrp jobc counters when specified process changes process group.
! 300: * We count the number of processes in each process group that "qualify"
! 301: * the group for terminal job control (those with a parent in a different
! 302: * process group of the same session). If that count reaches zero, the
! 303: * process group becomes orphaned. Check both the specified process'
! 304: * process group and that of its children.
! 305: * entering == 0 => p is leaving specified group.
! 306: * entering == 1 => p is entering specified group.
! 307: */
! 308: void
! 309: fixjobc(struct proc *p, struct pgrp *pgrp, int entering)
! 310: {
! 311: struct pgrp *hispgrp;
! 312: struct session *mysession = pgrp->pg_session;
! 313:
! 314: /*
! 315: * Check p's parent to see whether p qualifies its own process
! 316: * group; if so, adjust count for p's process group.
! 317: */
! 318: if ((hispgrp = p->p_pptr->p_pgrp) != pgrp &&
! 319: hispgrp->pg_session == mysession) {
! 320: if (entering)
! 321: pgrp->pg_jobc++;
! 322: else if (--pgrp->pg_jobc == 0)
! 323: orphanpg(pgrp);
! 324: }
! 325:
! 326: /*
! 327: * Check this process' children to see whether they qualify
! 328: * their process groups; if so, adjust counts for children's
! 329: * process groups.
! 330: */
! 331: LIST_FOREACH(p, &p->p_children, p_sibling)
! 332: if ((hispgrp = p->p_pgrp) != pgrp &&
! 333: hispgrp->pg_session == mysession &&
! 334: P_ZOMBIE(p) == 0) {
! 335: if (entering)
! 336: hispgrp->pg_jobc++;
! 337: else if (--hispgrp->pg_jobc == 0)
! 338: orphanpg(hispgrp);
! 339: }
! 340: }
! 341:
! 342: /*
! 343: * A process group has become orphaned;
! 344: * if there are any stopped processes in the group,
! 345: * hang-up all process in that group.
! 346: */
! 347: static void
! 348: orphanpg(struct pgrp *pg)
! 349: {
! 350: struct proc *p;
! 351:
! 352: LIST_FOREACH(p, &pg->pg_members, p_pglist) {
! 353: if (p->p_stat == SSTOP) {
! 354: LIST_FOREACH(p, &pg->pg_members, p_pglist) {
! 355: psignal(p, SIGHUP);
! 356: psignal(p, SIGCONT);
! 357: }
! 358: return;
! 359: }
! 360: }
! 361: }
! 362:
! 363: #ifdef DDB
! 364: void
! 365: proc_printit(struct proc *p, const char *modif, int (*pr)(const char *, ...))
! 366: {
! 367: static const char *const pstat[] = {
! 368: "idle", "run", "sleep", "stop", "zombie", "dead", "onproc"
! 369: };
! 370: char pstbuf[5];
! 371: const char *pst = pstbuf;
! 372:
! 373: if (p->p_stat < 1 || p->p_stat > sizeof(pstat) / sizeof(pstat[0]))
! 374: snprintf(pstbuf, sizeof(pstbuf), "%d", p->p_stat);
! 375: else
! 376: pst = pstat[(int)p->p_stat - 1];
! 377:
! 378: (*pr)("PROC (%s) pid=%d stat=%s flags=%b\n",
! 379: p->p_comm, p->p_pid, pst, p->p_flag, P_BITS);
! 380: (*pr)(" pri=%u, usrpri=%u, nice=%d\n",
! 381: p->p_priority, p->p_usrpri, p->p_nice);
! 382: (*pr)(" forw=%p, back=%p, list=%p,%p\n",
! 383: p->p_forw, p->p_back, p->p_list.le_next, p->p_list.le_prev);
! 384: (*pr)(" user=%p, vmspace=%p\n",
! 385: p->p_addr, p->p_vmspace);
! 386: (*pr)(" estcpu=%u, cpticks=%d, pctcpu=%u.%u%, swtime=%u\n",
! 387: p->p_estcpu, p->p_cpticks, p->p_pctcpu / 100, p->p_pctcpu % 100,
! 388: p->p_swtime);
! 389: (*pr)(" user=%llu, sys=%llu, intr=%llu\n",
! 390: p->p_uticks, p->p_sticks, p->p_iticks);
! 391: }
! 392: #include <machine/db_machdep.h>
! 393:
! 394: #include <ddb/db_interface.h>
! 395: #include <ddb/db_output.h>
! 396:
! 397: void
! 398: db_show_all_procs(db_expr_t addr, int haddr, db_expr_t count, char *modif)
! 399: {
! 400: char *mode;
! 401: int doingzomb = 0;
! 402: struct proc *p, *pp;
! 403:
! 404: if (modif[0] == 0)
! 405: modif[0] = 'n'; /* default == normal mode */
! 406:
! 407: mode = "mawn";
! 408: while (*mode && *mode != modif[0])
! 409: mode++;
! 410: if (*mode == 0 || *mode == 'm') {
! 411: db_printf("usage: show all procs [/a] [/n] [/w]\n");
! 412: db_printf("\t/a == show process address info\n");
! 413: db_printf("\t/n == show normal process info [default]\n");
! 414: db_printf("\t/w == show process wait/emul info\n");
! 415: return;
! 416: }
! 417:
! 418: p = LIST_FIRST(&allproc);
! 419:
! 420: switch (*mode) {
! 421:
! 422: case 'a':
! 423: db_printf(" PID %-10s %18s %18s %18s\n",
! 424: "COMMAND", "STRUCT PROC *", "UAREA *", "VMSPACE/VM_MAP");
! 425: break;
! 426: case 'n':
! 427: db_printf(" PID %5s %5s %5s S %10s %-12s %-16s\n",
! 428: "PPID", "PGRP", "UID", "FLAGS", "WAIT", "COMMAND");
! 429: break;
! 430: case 'w':
! 431: db_printf(" PID %-16s %-8s %18s %s\n",
! 432: "COMMAND", "EMUL", "WAIT-CHANNEL", "WAIT-MSG");
! 433: break;
! 434: }
! 435:
! 436: while (p != 0) {
! 437: pp = p->p_pptr;
! 438: if (p->p_stat) {
! 439:
! 440: db_printf("%c%5d ", p == curproc ? '*' : ' ',
! 441: p->p_pid);
! 442:
! 443: switch (*mode) {
! 444:
! 445: case 'a':
! 446: db_printf("%-10.10s %18p %18p %18p\n",
! 447: p->p_comm, p, p->p_addr, p->p_vmspace);
! 448: break;
! 449:
! 450: case 'n':
! 451: db_printf("%5d %5d %5d %d %#10x "
! 452: "%-12.12s %-16s\n",
! 453: pp ? pp->p_pid : -1, p->p_pgrp->pg_id,
! 454: p->p_cred->p_ruid, p->p_stat, p->p_flag,
! 455: (p->p_wchan && p->p_wmesg) ?
! 456: p->p_wmesg : "", p->p_comm);
! 457: break;
! 458:
! 459: case 'w':
! 460: db_printf("%-16s %-8s %18p %s\n", p->p_comm,
! 461: p->p_emul->e_name, p->p_wchan,
! 462: (p->p_wchan && p->p_wmesg) ?
! 463: p->p_wmesg : "");
! 464: break;
! 465:
! 466: }
! 467: }
! 468: p = LIST_NEXT(p, p_list);
! 469: if (p == 0 && doingzomb == 0) {
! 470: doingzomb = 1;
! 471: p = LIST_FIRST(&zombproc);
! 472: }
! 473: }
! 474: }
! 475: #endif
! 476:
! 477: #ifdef DEBUG
! 478: void
! 479: pgrpdump(void)
! 480: {
! 481: struct pgrp *pgrp;
! 482: struct proc *p;
! 483: int i;
! 484:
! 485: for (i = 0; i <= pgrphash; i++) {
! 486: if (!LIST_EMPTY(&pgrphashtbl[i])) {
! 487: printf("\tindx %d\n", i);
! 488: LIST_FOREACH(pgrp, &pgrphashtbl[i], pg_hash) {
! 489: printf("\tpgrp %p, pgid %d, sess %p, sesscnt %d, mem %p\n",
! 490: pgrp, pgrp->pg_id, pgrp->pg_session,
! 491: pgrp->pg_session->s_count,
! 492: LIST_FIRST(&pgrp->pg_members));
! 493: LIST_FOREACH(p, &pgrp->pg_members, p_pglist) {
! 494: printf("\t\tpid %d addr %p pgrp %p\n",
! 495: p->p_pid, p, p->p_pgrp);
! 496: }
! 497: }
! 498: }
! 499: }
! 500: }
! 501: #endif /* DEBUG */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to kern_proc.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / kern