1 /* $OpenBSD: kern_proc.c,v 1.55 2014/01/20 21:19:28 guenther 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 processlist allprocess; 64 struct processlist zombprocess; 65 struct proclist allproc; 66 67 struct pool proc_pool; 68 struct pool process_pool; 69 struct pool rusage_pool; 70 struct pool ucred_pool; 71 struct pool pgrp_pool; 72 struct pool session_pool; 73 struct pool pcred_pool; 74 75 static void orphanpg(struct pgrp *); 76 #ifdef DEBUG 77 void pgrpdump(void); 78 #endif 79 80 /* 81 * Initialize global process hashing structures. 82 */ 83 void 84 procinit(void) 85 { 86 LIST_INIT(&allprocess); 87 LIST_INIT(&zombprocess); 88 LIST_INIT(&allproc); 89 90 91 pidhashtbl = hashinit(maxthread / 4, M_PROC, M_NOWAIT, &pidhash); 92 pgrphashtbl = hashinit(maxprocess / 4, M_PROC, M_NOWAIT, &pgrphash); 93 uihashtbl = hashinit(maxprocess / 16, M_PROC, M_NOWAIT, &uihash); 94 if (!pidhashtbl || !pgrphashtbl || !uihashtbl) 95 panic("procinit: malloc"); 96 97 pool_init(&proc_pool, sizeof(struct proc), 0, 0, 0, "procpl", 98 &pool_allocator_nointr); 99 pool_init(&process_pool, sizeof(struct process), 0, 0, 0, "processpl", 100 &pool_allocator_nointr); 101 pool_init(&rusage_pool, sizeof(struct rusage), 0, 0, 0, "zombiepl", 102 &pool_allocator_nointr); 103 pool_init(&ucred_pool, sizeof(struct ucred), 0, 0, 0, "ucredpl", 104 &pool_allocator_nointr); 105 pool_init(&pgrp_pool, sizeof(struct pgrp), 0, 0, 0, "pgrppl", 106 &pool_allocator_nointr); 107 pool_init(&session_pool, sizeof(struct session), 0, 0, 0, "sessionpl", 108 &pool_allocator_nointr); 109 pool_init(&pcred_pool, sizeof(struct pcred), 0, 0, 0, "pcredpl", 110 &pool_allocator_nointr); 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); 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 p 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 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 by number 184 */ 185 struct process * 186 prfind(pid_t pid) 187 { 188 struct proc *p; 189 190 LIST_FOREACH(p, PIDHASH(pid), p_hash) 191 if (p->p_pid == pid) 192 return (p->p_flag & P_THREAD ? NULL : p->p_p); 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 * Move p to a new or existing process group (and session) 212 * Caller provides a pre-allocated pgrp and session that should 213 * be freed if they are not used. 214 * XXX need proctree lock 215 */ 216 int 217 enterpgrp(struct process *pr, pid_t pgid, struct pgrp *newpgrp, 218 struct session *newsess) 219 { 220 struct pgrp *pgrp = pgfind(pgid); 221 222 #ifdef DIAGNOSTIC 223 if (pgrp != NULL && newsess) /* firewalls */ 224 panic("enterpgrp: setsid into non-empty pgrp"); 225 if (SESS_LEADER(pr)) 226 panic("enterpgrp: session leader attempted setpgrp"); 227 #endif 228 if (pgrp == NULL) { 229 /* 230 * new process group 231 */ 232 #ifdef DIAGNOSTIC 233 if (pr->ps_pid != pgid) 234 panic("enterpgrp: new pgrp and pid != pgid"); 235 #endif 236 237 pgrp = newpgrp; 238 if (newsess) { 239 /* 240 * new session 241 */ 242 newsess->s_leader = pr; 243 newsess->s_count = 1; 244 newsess->s_ttyvp = NULL; 245 newsess->s_ttyp = NULL; 246 bcopy(pr->ps_session->s_login, newsess->s_login, 247 sizeof(newsess->s_login)); 248 atomic_clearbits_int(&pr->ps_flags, PS_CONTROLT); 249 pgrp->pg_session = newsess; 250 #ifdef DIAGNOSTIC 251 if (pr != curproc->p_p) 252 panic("enterpgrp: mksession but not curproc"); 253 #endif 254 } else { 255 pgrp->pg_session = pr->ps_session; 256 pgrp->pg_session->s_count++; 257 } 258 pgrp->pg_id = pgid; 259 LIST_INIT(&pgrp->pg_members); 260 LIST_INSERT_HEAD(PGRPHASH(pgid), pgrp, pg_hash); 261 pgrp->pg_jobc = 0; 262 } else if (pgrp == pr->ps_pgrp) { 263 if (newsess) 264 pool_put(&session_pool, newsess); 265 pool_put(&pgrp_pool, newpgrp); 266 return (0); 267 } else { 268 if (newsess) 269 pool_put(&session_pool, newsess); 270 pool_put(&pgrp_pool, newpgrp); 271 } 272 273 /* 274 * Adjust eligibility of affected pgrps to participate in job control. 275 * Increment eligibility counts before decrementing, otherwise we 276 * could reach 0 spuriously during the first call. 277 */ 278 fixjobc(pr, pgrp, 1); 279 fixjobc(pr, pr->ps_pgrp, 0); 280 281 LIST_REMOVE(pr, ps_pglist); 282 if (LIST_EMPTY(&pr->ps_pgrp->pg_members)) 283 pgdelete(pr->ps_pgrp); 284 pr->ps_pgrp = pgrp; 285 LIST_INSERT_HEAD(&pgrp->pg_members, pr, ps_pglist); 286 return (0); 287 } 288 289 /* 290 * remove process from process group 291 */ 292 void 293 leavepgrp(struct process *pr) 294 { 295 296 LIST_REMOVE(pr, ps_pglist); 297 if (LIST_EMPTY(&pr->ps_pgrp->pg_members)) 298 pgdelete(pr->ps_pgrp); 299 pr->ps_pgrp = 0; 300 } 301 302 /* 303 * delete a process group 304 */ 305 void 306 pgdelete(struct pgrp *pgrp) 307 { 308 309 if (pgrp->pg_session->s_ttyp != NULL && 310 pgrp->pg_session->s_ttyp->t_pgrp == pgrp) 311 pgrp->pg_session->s_ttyp->t_pgrp = NULL; 312 LIST_REMOVE(pgrp, pg_hash); 313 SESSRELE(pgrp->pg_session); 314 pool_put(&pgrp_pool, pgrp); 315 } 316 317 /* 318 * Adjust pgrp jobc counters when specified process changes process group. 319 * We count the number of processes in each process group that "qualify" 320 * the group for terminal job control (those with a parent in a different 321 * process group of the same session). If that count reaches zero, the 322 * process group becomes orphaned. Check both the specified process' 323 * process group and that of its children. 324 * entering == 0 => pr is leaving specified group. 325 * entering == 1 => pr is entering specified group. 326 * XXX need proctree lock 327 */ 328 void 329 fixjobc(struct process *pr, struct pgrp *pgrp, int entering) 330 { 331 struct pgrp *hispgrp; 332 struct session *mysession = pgrp->pg_session; 333 334 /* 335 * Check pr's parent to see whether pr qualifies its own process 336 * group; if so, adjust count for pr's process group. 337 */ 338 if ((hispgrp = pr->ps_pptr->ps_pgrp) != pgrp && 339 hispgrp->pg_session == mysession) { 340 if (entering) 341 pgrp->pg_jobc++; 342 else if (--pgrp->pg_jobc == 0) 343 orphanpg(pgrp); 344 } 345 346 /* 347 * Check this process' children to see whether they qualify 348 * their process groups; if so, adjust counts for children's 349 * process groups. 350 */ 351 LIST_FOREACH(pr, &pr->ps_children, ps_sibling) 352 if ((hispgrp = pr->ps_pgrp) != pgrp && 353 hispgrp->pg_session == mysession && 354 P_ZOMBIE(pr->ps_mainproc) == 0) { 355 if (entering) 356 hispgrp->pg_jobc++; 357 else if (--hispgrp->pg_jobc == 0) 358 orphanpg(hispgrp); 359 } 360 } 361 362 /* 363 * A process group has become orphaned; 364 * if there are any stopped processes in the group, 365 * hang-up all process in that group. 366 */ 367 static void 368 orphanpg(struct pgrp *pg) 369 { 370 struct process *pr; 371 372 LIST_FOREACH(pr, &pg->pg_members, ps_pglist) { 373 if (pr->ps_mainproc->p_stat == SSTOP) { 374 LIST_FOREACH(pr, &pg->pg_members, ps_pglist) { 375 prsignal(pr, SIGHUP); 376 prsignal(pr, SIGCONT); 377 } 378 return; 379 } 380 } 381 } 382 383 #ifdef DDB 384 void 385 proc_printit(struct proc *p, const char *modif, 386 int (*pr)(const char *, ...) __attribute__((__format__(__kprintf__,1,2)))) 387 { 388 static const char *const pstat[] = { 389 "idle", "run", "sleep", "stop", "zombie", "dead", "onproc" 390 }; 391 char pstbuf[5]; 392 const char *pst = pstbuf; 393 394 395 if (p->p_stat < 1 || p->p_stat > sizeof(pstat) / sizeof(pstat[0])) 396 snprintf(pstbuf, sizeof(pstbuf), "%d", p->p_stat); 397 else 398 pst = pstat[(int)p->p_stat - 1]; 399 400 (*pr)("PROC (%s) pid=%d stat=%s\n", p->p_comm, p->p_pid, pst); 401 (*pr)(" flags process=%b proc=%b\n", 402 p->p_p->ps_flags, PS_BITS, p->p_flag, P_BITS); 403 (*pr)(" pri=%u, usrpri=%u, nice=%d\n", 404 p->p_priority, p->p_usrpri, p->p_p->ps_nice); 405 (*pr)(" forw=%p, list=%p,%p\n", 406 TAILQ_NEXT(p, p_runq), p->p_list.le_next, p->p_list.le_prev); 407 (*pr)(" process=%p user=%p, vmspace=%p\n", 408 p->p_p, p->p_addr, p->p_vmspace); 409 (*pr)(" estcpu=%u, cpticks=%d, pctcpu=%u.%u, swtime=%u\n", 410 p->p_estcpu, p->p_cpticks, p->p_pctcpu / 100, p->p_pctcpu % 100, 411 p->p_swtime); 412 (*pr)(" user=%u, sys=%u, intr=%u\n", 413 p->p_uticks, p->p_sticks, p->p_iticks); 414 } 415 #include <machine/db_machdep.h> 416 417 #include <ddb/db_interface.h> 418 #include <ddb/db_output.h> 419 420 void 421 db_show_all_procs(db_expr_t addr, int haddr, db_expr_t count, char *modif) 422 { 423 char *mode; 424 int doingzomb = 0; 425 struct proc *p; 426 struct process *pr, *ppr; 427 428 if (modif[0] == 0) 429 modif[0] = 'n'; /* default == normal mode */ 430 431 mode = "mawn"; 432 while (*mode && *mode != modif[0]) 433 mode++; 434 if (*mode == 0 || *mode == 'm') { 435 db_printf("usage: show all procs [/a] [/n] [/w]\n"); 436 db_printf("\t/a == show process address info\n"); 437 db_printf("\t/n == show normal process info [default]\n"); 438 db_printf("\t/w == show process wait/emul info\n"); 439 return; 440 } 441 442 pr = LIST_FIRST(&allprocess); 443 444 switch (*mode) { 445 446 case 'a': 447 db_printf(" PID %-10s %18s %18s %18s\n", 448 "COMMAND", "STRUCT PROC *", "UAREA *", "VMSPACE/VM_MAP"); 449 break; 450 case 'n': 451 db_printf(" PID %5s %5s %5s S %10s %-12s %-16s\n", 452 "PPID", "PGRP", "UID", "FLAGS", "WAIT", "COMMAND"); 453 break; 454 case 'w': 455 db_printf(" PID %-16s %-8s %18s %s\n", 456 "COMMAND", "EMUL", "WAIT-CHANNEL", "WAIT-MSG"); 457 break; 458 } 459 460 while (pr != NULL) { 461 ppr = pr->ps_pptr; 462 463 TAILQ_FOREACH(p, &pr->ps_threads, p_thr_link) { 464 if (p->p_stat) { 465 db_printf("%c%5d ", p == curproc ? '*' : ' ', 466 p->p_pid); 467 468 switch (*mode) { 469 470 case 'a': 471 db_printf("%-10.10s %18p %18p %18p\n", 472 p->p_comm, p, p->p_addr, p->p_vmspace); 473 break; 474 475 case 'n': 476 db_printf("%5d %5d %5d %d %#10x " 477 "%-12.12s %-16s\n", 478 ppr ? ppr->ps_pid : -1, 479 pr->ps_pgrp ? pr->ps_pgrp->pg_id : -1, 480 pr->ps_cred->p_ruid, p->p_stat, 481 p->p_flag | pr->ps_flags, 482 (p->p_wchan && p->p_wmesg) ? 483 p->p_wmesg : "", p->p_comm); 484 break; 485 486 case 'w': 487 db_printf("%-16s %-8s %18p %s\n", p->p_comm, 488 p->p_emul->e_name, p->p_wchan, 489 (p->p_wchan && p->p_wmesg) ? 490 p->p_wmesg : ""); 491 break; 492 493 } 494 } 495 } 496 pr = LIST_NEXT(pr, ps_list); 497 if (pr == NULL && doingzomb == 0) { 498 doingzomb = 1; 499 pr = LIST_FIRST(&zombprocess); 500 } 501 } 502 } 503 #endif 504 505 #ifdef DEBUG 506 void 507 pgrpdump(void) 508 { 509 struct pgrp *pgrp; 510 struct process *pr; 511 int i; 512 513 for (i = 0; i <= pgrphash; i++) { 514 if (!LIST_EMPTY(&pgrphashtbl[i])) { 515 printf("\tindx %d\n", i); 516 LIST_FOREACH(pgrp, &pgrphashtbl[i], pg_hash) { 517 printf("\tpgrp %p, pgid %d, sess %p, sesscnt %d, mem %p\n", 518 pgrp, pgrp->pg_id, pgrp->pg_session, 519 pgrp->pg_session->s_count, 520 LIST_FIRST(&pgrp->pg_members)); 521 LIST_FOREACH(pr, &pgrp->pg_members, ps_pglist) { 522 printf("\t\tpid %d addr %p pgrp %p\n", 523 pr->ps_pid, pr, pr->ps_pgrp); 524 } 525 } 526 } 527 } 528 } 529 #endif /* DEBUG */ 530