1 /* $OpenBSD: kern_proc.c,v 1.80 2018/02/10 10:32:51 mpi 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 <ufs/ufs/quota.h> 43 #include <sys/uio.h> 44 #include <sys/malloc.h> 45 #include <sys/mbuf.h> 46 #include <sys/ioctl.h> 47 #include <sys/tty.h> 48 #include <sys/signalvar.h> 49 #include <sys/pool.h> 50 #include <sys/vnode.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 tidhashhead *tidhashtbl; 60 u_long tidhash; 61 struct pidhashhead *pidhashtbl; 62 u_long pidhash; 63 struct pgrphashhead *pgrphashtbl; 64 u_long pgrphash; 65 struct processlist allprocess; 66 struct processlist zombprocess; 67 struct proclist allproc; 68 69 struct pool proc_pool; 70 struct pool process_pool; 71 struct pool rusage_pool; 72 struct pool ucred_pool; 73 struct pool pgrp_pool; 74 struct pool session_pool; 75 76 static void orphanpg(struct pgrp *); 77 #ifdef DEBUG 78 void pgrpdump(void); 79 #endif 80 81 /* 82 * Initialize global process hashing structures. 83 */ 84 void 85 procinit(void) 86 { 87 LIST_INIT(&allprocess); 88 LIST_INIT(&zombprocess); 89 LIST_INIT(&allproc); 90 91 92 tidhashtbl = hashinit(maxthread / 4, M_PROC, M_NOWAIT, &tidhash); 93 pidhashtbl = hashinit(maxprocess / 4, M_PROC, M_NOWAIT, &pidhash); 94 pgrphashtbl = hashinit(maxprocess / 4, M_PROC, M_NOWAIT, &pgrphash); 95 uihashtbl = hashinit(maxprocess / 16, M_PROC, M_NOWAIT, &uihash); 96 if (!tidhashtbl || !pidhashtbl || !pgrphashtbl || !uihashtbl) 97 panic("procinit: malloc"); 98 99 pool_init(&proc_pool, sizeof(struct proc), 0, IPL_NONE, 100 PR_WAITOK, "procpl", NULL); 101 pool_init(&process_pool, sizeof(struct process), 0, IPL_NONE, 102 PR_WAITOK, "processpl", NULL); 103 pool_init(&rusage_pool, sizeof(struct rusage), 0, IPL_NONE, 104 PR_WAITOK, "zombiepl", NULL); 105 pool_init(&ucred_pool, sizeof(struct ucred), 0, IPL_NONE, 106 PR_WAITOK, "ucredpl", NULL); 107 pool_init(&pgrp_pool, sizeof(struct pgrp), 0, IPL_NONE, 108 PR_WAITOK, "pgrppl", NULL); 109 pool_init(&session_pool, sizeof(struct session), 0, IPL_NONE, 110 PR_WAITOK, "sessionpl", NULL); 111 } 112 113 struct uidinfo * 114 uid_find(uid_t uid) 115 { 116 struct uidinfo *uip, *nuip; 117 struct uihashhead *uipp; 118 119 uipp = UIHASH(uid); 120 LIST_FOREACH(uip, uipp, ui_hash) 121 if (uip->ui_uid == uid) 122 break; 123 if (uip) 124 return (uip); 125 nuip = malloc(sizeof(*nuip), M_PROC, M_WAITOK|M_ZERO); 126 LIST_FOREACH(uip, uipp, ui_hash) 127 if (uip->ui_uid == uid) 128 break; 129 if (uip) { 130 free(nuip, M_PROC, sizeof(*nuip)); 131 return (uip); 132 } 133 nuip->ui_uid = uid; 134 LIST_INSERT_HEAD(uipp, nuip, ui_hash); 135 136 return (nuip); 137 } 138 139 /* 140 * Change the count associated with number of threads 141 * a given user is using. 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 pr an inferior of parent? 157 */ 158 int 159 inferior(struct process *pr, struct process *parent) 160 { 161 162 for (; pr != parent; pr = pr->ps_pptr) 163 if (pr->ps_pid == 0 || pr->ps_pid == 1) 164 return (0); 165 return (1); 166 } 167 168 /* 169 * Locate a proc (thread) by number 170 */ 171 struct proc * 172 tfind(pid_t tid) 173 { 174 struct proc *p; 175 176 LIST_FOREACH(p, TIDHASH(tid), p_hash) 177 if (p->p_tid == tid) 178 return (p); 179 return (NULL); 180 } 181 182 /* 183 * Locate a process by number 184 */ 185 struct process * 186 prfind(pid_t pid) 187 { 188 struct process *pr; 189 190 LIST_FOREACH(pr, PIDHASH(pid), ps_hash) 191 if (pr->ps_pid == pid) 192 return (pr); 193 return (NULL); 194 } 195 196 /* 197 * Locate a process group by number 198 */ 199 struct pgrp * 200 pgfind(pid_t pgid) 201 { 202 struct pgrp *pgrp; 203 204 LIST_FOREACH(pgrp, PGRPHASH(pgid), pg_hash) 205 if (pgrp->pg_id == pgid) 206 return (pgrp); 207 return (NULL); 208 } 209 210 /* 211 * Locate a zombie process 212 */ 213 struct process * 214 zombiefind(pid_t pid) 215 { 216 struct process *pr; 217 218 LIST_FOREACH(pr, &zombprocess, ps_list) 219 if (pr->ps_pid == pid) 220 return (pr); 221 return (NULL); 222 } 223 224 /* 225 * Move p to a new or existing process group (and session) 226 * Caller provides a pre-allocated pgrp and session that should 227 * be freed if they are not used. 228 * XXX need proctree lock 229 */ 230 int 231 enterpgrp(struct process *pr, pid_t pgid, struct pgrp *newpgrp, 232 struct session *newsess) 233 { 234 struct pgrp *pgrp = pgfind(pgid); 235 236 #ifdef DIAGNOSTIC 237 if (pgrp != NULL && newsess) /* firewalls */ 238 panic("enterpgrp: setsid into non-empty pgrp"); 239 if (SESS_LEADER(pr)) 240 panic("enterpgrp: session leader attempted setpgrp"); 241 #endif 242 if (pgrp == NULL) { 243 /* 244 * new process group 245 */ 246 #ifdef DIAGNOSTIC 247 if (pr->ps_pid != pgid) 248 panic("enterpgrp: new pgrp and pid != pgid"); 249 #endif 250 251 pgrp = newpgrp; 252 if (newsess) { 253 /* 254 * new session 255 */ 256 newsess->s_leader = pr; 257 newsess->s_count = 1; 258 newsess->s_ttyvp = NULL; 259 newsess->s_ttyp = NULL; 260 memcpy(newsess->s_login, pr->ps_session->s_login, 261 sizeof(newsess->s_login)); 262 atomic_clearbits_int(&pr->ps_flags, PS_CONTROLT); 263 pgrp->pg_session = newsess; 264 #ifdef DIAGNOSTIC 265 if (pr != curproc->p_p) 266 panic("enterpgrp: mksession but not curproc"); 267 #endif 268 } else { 269 pgrp->pg_session = pr->ps_session; 270 pgrp->pg_session->s_count++; 271 } 272 pgrp->pg_id = pgid; 273 LIST_INIT(&pgrp->pg_members); 274 LIST_INSERT_HEAD(PGRPHASH(pgid), pgrp, pg_hash); 275 pgrp->pg_jobc = 0; 276 } else if (pgrp == pr->ps_pgrp) { 277 if (newsess) 278 pool_put(&session_pool, newsess); 279 pool_put(&pgrp_pool, newpgrp); 280 return (0); 281 } else { 282 if (newsess) 283 pool_put(&session_pool, newsess); 284 pool_put(&pgrp_pool, newpgrp); 285 } 286 287 /* 288 * Adjust eligibility of affected pgrps to participate in job control. 289 * Increment eligibility counts before decrementing, otherwise we 290 * could reach 0 spuriously during the first call. 291 */ 292 fixjobc(pr, pgrp, 1); 293 fixjobc(pr, pr->ps_pgrp, 0); 294 295 LIST_REMOVE(pr, ps_pglist); 296 if (LIST_EMPTY(&pr->ps_pgrp->pg_members)) 297 pgdelete(pr->ps_pgrp); 298 pr->ps_pgrp = pgrp; 299 LIST_INSERT_HEAD(&pgrp->pg_members, pr, ps_pglist); 300 return (0); 301 } 302 303 /* 304 * remove process from process group 305 */ 306 void 307 leavepgrp(struct process *pr) 308 { 309 310 if (pr->ps_session->s_verauthppid == pr->ps_pid) 311 zapverauth(pr->ps_session); 312 LIST_REMOVE(pr, ps_pglist); 313 if (LIST_EMPTY(&pr->ps_pgrp->pg_members)) 314 pgdelete(pr->ps_pgrp); 315 pr->ps_pgrp = 0; 316 } 317 318 /* 319 * delete a process group 320 */ 321 void 322 pgdelete(struct pgrp *pgrp) 323 { 324 325 if (pgrp->pg_session->s_ttyp != NULL && 326 pgrp->pg_session->s_ttyp->t_pgrp == pgrp) 327 pgrp->pg_session->s_ttyp->t_pgrp = NULL; 328 LIST_REMOVE(pgrp, pg_hash); 329 SESSRELE(pgrp->pg_session); 330 pool_put(&pgrp_pool, pgrp); 331 } 332 333 void 334 zapverauth(void *v) 335 { 336 struct session *sess = v; 337 sess->s_verauthuid = 0; 338 sess->s_verauthppid = 0; 339 } 340 341 /* 342 * Adjust pgrp jobc counters when specified process changes process group. 343 * We count the number of processes in each process group that "qualify" 344 * the group for terminal job control (those with a parent in a different 345 * process group of the same session). If that count reaches zero, the 346 * process group becomes orphaned. Check both the specified process' 347 * process group and that of its children. 348 * entering == 0 => pr is leaving specified group. 349 * entering == 1 => pr is entering specified group. 350 * XXX need proctree lock 351 */ 352 void 353 fixjobc(struct process *pr, struct pgrp *pgrp, int entering) 354 { 355 struct pgrp *hispgrp; 356 struct session *mysession = pgrp->pg_session; 357 358 /* 359 * Check pr's parent to see whether pr qualifies its own process 360 * group; if so, adjust count for pr's process group. 361 */ 362 if ((hispgrp = pr->ps_pptr->ps_pgrp) != pgrp && 363 hispgrp->pg_session == mysession) { 364 if (entering) 365 pgrp->pg_jobc++; 366 else if (--pgrp->pg_jobc == 0) 367 orphanpg(pgrp); 368 } 369 370 /* 371 * Check this process' children to see whether they qualify 372 * their process groups; if so, adjust counts for children's 373 * process groups. 374 */ 375 LIST_FOREACH(pr, &pr->ps_children, ps_sibling) 376 if ((hispgrp = pr->ps_pgrp) != pgrp && 377 hispgrp->pg_session == mysession && 378 (pr->ps_flags & PS_ZOMBIE) == 0) { 379 if (entering) 380 hispgrp->pg_jobc++; 381 else if (--hispgrp->pg_jobc == 0) 382 orphanpg(hispgrp); 383 } 384 } 385 386 void 387 killjobc(struct process *pr) 388 { 389 if (SESS_LEADER(pr)) { 390 struct session *sp = pr->ps_session; 391 392 if (sp->s_ttyvp) { 393 struct vnode *ovp; 394 395 /* 396 * Controlling process. 397 * Signal foreground pgrp, 398 * drain controlling terminal 399 * and revoke access to controlling terminal. 400 */ 401 if (sp->s_ttyp->t_session == sp) { 402 if (sp->s_ttyp->t_pgrp) 403 pgsignal(sp->s_ttyp->t_pgrp, SIGHUP, 1); 404 ttywait(sp->s_ttyp); 405 /* 406 * The tty could have been revoked 407 * if we blocked. 408 */ 409 if (sp->s_ttyvp) 410 VOP_REVOKE(sp->s_ttyvp, REVOKEALL); 411 } 412 ovp = sp->s_ttyvp; 413 sp->s_ttyvp = NULL; 414 if (ovp) 415 vrele(ovp); 416 /* 417 * s_ttyp is not zero'd; we use this to 418 * indicate that the session once had a 419 * controlling terminal. (for logging and 420 * informational purposes) 421 */ 422 } 423 sp->s_leader = NULL; 424 } 425 fixjobc(pr, pr->ps_pgrp, 0); 426 } 427 428 /* 429 * A process group has become orphaned; 430 * if there are any stopped processes in the group, 431 * hang-up all process in that group. 432 */ 433 static void 434 orphanpg(struct pgrp *pg) 435 { 436 struct process *pr; 437 438 LIST_FOREACH(pr, &pg->pg_members, ps_pglist) { 439 if (pr->ps_mainproc->p_stat == SSTOP) { 440 LIST_FOREACH(pr, &pg->pg_members, ps_pglist) { 441 prsignal(pr, SIGHUP); 442 prsignal(pr, SIGCONT); 443 } 444 return; 445 } 446 } 447 } 448 449 #ifdef DDB 450 void 451 proc_printit(struct proc *p, const char *modif, 452 int (*pr)(const char *, ...) __attribute__((__format__(__kprintf__,1,2)))) 453 { 454 static const char *const pstat[] = { 455 "idle", "run", "sleep", "stop", "zombie", "dead", "onproc" 456 }; 457 char pstbuf[5]; 458 const char *pst = pstbuf; 459 460 461 if (p->p_stat < 1 || p->p_stat > sizeof(pstat) / sizeof(pstat[0])) 462 snprintf(pstbuf, sizeof(pstbuf), "%d", p->p_stat); 463 else 464 pst = pstat[(int)p->p_stat - 1]; 465 466 (*pr)("PROC (%s) pid=%d stat=%s\n", p->p_p->ps_comm, p->p_tid, pst); 467 (*pr)(" flags process=%b proc=%b\n", 468 p->p_p->ps_flags, PS_BITS, p->p_flag, P_BITS); 469 (*pr)(" pri=%u, usrpri=%u, nice=%d\n", 470 p->p_priority, p->p_usrpri, p->p_p->ps_nice); 471 (*pr)(" forw=%p, list=%p,%p\n", 472 TAILQ_NEXT(p, p_runq), p->p_list.le_next, p->p_list.le_prev); 473 (*pr)(" process=%p user=%p, vmspace=%p\n", 474 p->p_p, p->p_addr, p->p_vmspace); 475 (*pr)(" estcpu=%u, cpticks=%d, pctcpu=%u.%u\n", 476 p->p_estcpu, p->p_cpticks, p->p_pctcpu / 100, p->p_pctcpu % 100); 477 (*pr)(" user=%u, sys=%u, intr=%u\n", 478 p->p_uticks, p->p_sticks, p->p_iticks); 479 } 480 #include <machine/db_machdep.h> 481 482 #include <ddb/db_output.h> 483 484 void 485 db_kill_cmd(db_expr_t addr, int have_addr, db_expr_t count, char *modif) 486 { 487 struct process *pr; 488 struct sigaction sa; 489 struct proc *p; 490 491 pr = prfind(addr); 492 if (pr == NULL) { 493 db_printf("%ld: No such process", addr); 494 return; 495 } 496 497 p = TAILQ_FIRST(&pr->ps_threads); 498 499 /* Send uncatchable SIGABRT for coredump */ 500 memset(&sa, 0, sizeof sa); 501 sa.sa_handler = SIG_DFL; 502 setsigvec(p, SIGABRT, &sa); 503 psignal(p, SIGABRT); 504 } 505 506 void 507 db_show_all_procs(db_expr_t addr, int haddr, db_expr_t count, char *modif) 508 { 509 char *mode; 510 int skipzomb = 0; 511 int has_kernel_lock = 0; 512 struct proc *p; 513 struct process *pr, *ppr; 514 515 if (modif[0] == 0) 516 modif[0] = 'n'; /* default == normal mode */ 517 518 mode = "mawno"; 519 while (*mode && *mode != modif[0]) 520 mode++; 521 if (*mode == 0 || *mode == 'm') { 522 db_printf("usage: show all procs [/a] [/n] [/w]\n"); 523 db_printf("\t/a == show process address info\n"); 524 db_printf("\t/n == show normal process info [default]\n"); 525 db_printf("\t/w == show process pgrp/wait info\n"); 526 db_printf("\t/o == show normal info for non-idle SONPROC\n"); 527 return; 528 } 529 530 pr = LIST_FIRST(&allprocess); 531 532 switch (*mode) { 533 534 case 'a': 535 db_printf(" TID %-9s %18s %18s %18s\n", 536 "COMMAND", "STRUCT PROC *", "UAREA *", "VMSPACE/VM_MAP"); 537 break; 538 case 'n': 539 db_printf(" PID %6s %5s %5s S %10s %-12s %-15s\n", 540 "TID", "PPID", "UID", "FLAGS", "WAIT", "COMMAND"); 541 break; 542 case 'w': 543 db_printf(" TID %-15s %-5s %18s %s\n", 544 "COMMAND", "PGRP", "WAIT-CHANNEL", "WAIT-MSG"); 545 break; 546 case 'o': 547 skipzomb = 1; 548 db_printf(" TID %5s %5s %10s %10s %3s %-30s\n", 549 "PID", "UID", "PRFLAGS", "PFLAGS", "CPU", "COMMAND"); 550 break; 551 } 552 553 while (pr != NULL) { 554 ppr = pr->ps_pptr; 555 556 TAILQ_FOREACH(p, &pr->ps_threads, p_thr_link) { 557 #ifdef MULTIPROCESSOR 558 if (__mp_lock_held(&kernel_lock, p->p_cpu)) 559 has_kernel_lock = 1; 560 else 561 has_kernel_lock = 0; 562 #endif 563 if (p->p_stat) { 564 if (*mode == 'o') { 565 if (p->p_stat != SONPROC) 566 continue; 567 if (p->p_cpu != NULL && p->p_cpu-> 568 ci_schedstate.spc_idleproc == p) 569 continue; 570 } 571 572 if (*mode == 'n') { 573 db_printf("%c%5d ", (p == curproc ? 574 '*' : ' '), pr->ps_pid); 575 } else { 576 db_printf("%c%6d ", (p == curproc ? 577 '*' : ' '), p->p_tid); 578 } 579 580 switch (*mode) { 581 582 case 'a': 583 db_printf("%-9.9s %18p %18p %18p\n", 584 pr->ps_comm, p, p->p_addr, p->p_vmspace); 585 break; 586 587 case 'n': 588 db_printf("%6d %5d %5d %d %#10x " 589 "%-12.12s %-15s\n", 590 p->p_tid, ppr ? ppr->ps_pid : -1, 591 pr->ps_ucred->cr_ruid, p->p_stat, 592 p->p_flag | pr->ps_flags, 593 (p->p_wchan && p->p_wmesg) ? 594 p->p_wmesg : "", pr->ps_comm); 595 break; 596 597 case 'w': 598 db_printf("%-15s %-5d %18p %s\n", 599 pr->ps_comm, (pr->ps_pgrp ? 600 pr->ps_pgrp->pg_id : -1), 601 p->p_wchan, 602 (p->p_wchan && p->p_wmesg) ? 603 p->p_wmesg : ""); 604 break; 605 606 case 'o': 607 db_printf("%5d %5d %#10x %#10x %3d" 608 "%c %-31s\n", 609 pr->ps_pid, pr->ps_ucred->cr_ruid, 610 pr->ps_flags, p->p_flag, 611 CPU_INFO_UNIT(p->p_cpu), 612 has_kernel_lock ? 'K' : ' ', 613 pr->ps_comm); 614 break; 615 616 } 617 } 618 } 619 pr = LIST_NEXT(pr, ps_list); 620 if (pr == NULL && skipzomb == 0) { 621 skipzomb = 1; 622 pr = LIST_FIRST(&zombprocess); 623 } 624 } 625 } 626 #endif 627 628 #ifdef DEBUG 629 void 630 pgrpdump(void) 631 { 632 struct pgrp *pgrp; 633 struct process *pr; 634 int i; 635 636 for (i = 0; i <= pgrphash; i++) { 637 if (!LIST_EMPTY(&pgrphashtbl[i])) { 638 printf("\tindx %d\n", i); 639 LIST_FOREACH(pgrp, &pgrphashtbl[i], pg_hash) { 640 printf("\tpgrp %p, pgid %d, sess %p, sesscnt %d, mem %p\n", 641 pgrp, pgrp->pg_id, pgrp->pg_session, 642 pgrp->pg_session->s_count, 643 LIST_FIRST(&pgrp->pg_members)); 644 LIST_FOREACH(pr, &pgrp->pg_members, ps_pglist) { 645 printf("\t\tpid %d addr %p pgrp %p\n", 646 pr->ps_pid, pr, pr->ps_pgrp); 647 } 648 } 649 } 650 } 651 } 652 #endif /* DEBUG */ 653