1 /* 2 * Copyright (c) 1982, 1986, 1989, 1991, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 4. Neither the name of the University nor the names of its contributors 14 * may be used to endorse or promote products derived from this software 15 * without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * @(#)kern_proc.c 8.7 (Berkeley) 2/14/95 30 * $FreeBSD$ 31 */ 32 33 #include <sys/cdefs.h> 34 __FBSDID("$FreeBSD$"); 35 36 #include "opt_ktrace.h" 37 #include "opt_kstack_pages.h" 38 39 #include <sys/param.h> 40 #include <sys/systm.h> 41 #include <sys/kernel.h> 42 #include <sys/lock.h> 43 #include <sys/malloc.h> 44 #include <sys/mutex.h> 45 #include <sys/proc.h> 46 #include <sys/sysent.h> 47 #include <sys/sched.h> 48 #include <sys/smp.h> 49 #include <sys/sysctl.h> 50 #include <sys/filedesc.h> 51 #include <sys/tty.h> 52 #include <sys/signalvar.h> 53 #include <sys/sx.h> 54 #include <sys/user.h> 55 #include <sys/jail.h> 56 #ifdef KTRACE 57 #include <sys/uio.h> 58 #include <sys/ktrace.h> 59 #endif 60 61 #include <vm/vm.h> 62 #include <vm/vm_extern.h> 63 #include <vm/pmap.h> 64 #include <vm/vm_map.h> 65 #include <vm/uma.h> 66 #include <machine/critical.h> 67 68 MALLOC_DEFINE(M_PGRP, "pgrp", "process group header"); 69 MALLOC_DEFINE(M_SESSION, "session", "session header"); 70 static MALLOC_DEFINE(M_PROC, "proc", "Proc structures"); 71 MALLOC_DEFINE(M_SUBPROC, "subproc", "Proc sub-structures"); 72 73 static void doenterpgrp(struct proc *, struct pgrp *); 74 static void orphanpg(struct pgrp *pg); 75 static void pgadjustjobc(struct pgrp *pgrp, int entering); 76 static void pgdelete(struct pgrp *); 77 static int proc_ctor(void *mem, int size, void *arg, int flags); 78 static void proc_dtor(void *mem, int size, void *arg); 79 static int proc_init(void *mem, int size, int flags); 80 static void proc_fini(void *mem, int size); 81 82 /* 83 * Other process lists 84 */ 85 struct pidhashhead *pidhashtbl; 86 u_long pidhash; 87 struct pgrphashhead *pgrphashtbl; 88 u_long pgrphash; 89 struct proclist allproc; 90 struct proclist zombproc; 91 struct sx allproc_lock; 92 struct sx proctree_lock; 93 struct mtx pargs_ref_lock; 94 struct mtx ppeers_lock; 95 uma_zone_t proc_zone; 96 uma_zone_t ithread_zone; 97 98 int kstack_pages = KSTACK_PAGES; 99 int uarea_pages = UAREA_PAGES; 100 SYSCTL_INT(_kern, OID_AUTO, kstack_pages, CTLFLAG_RD, &kstack_pages, 0, ""); 101 SYSCTL_INT(_kern, OID_AUTO, uarea_pages, CTLFLAG_RD, &uarea_pages, 0, ""); 102 103 CTASSERT(sizeof(struct kinfo_proc) == KINFO_PROC_SIZE); 104 105 /* 106 * Initialize global process hashing structures. 107 */ 108 void 109 procinit() 110 { 111 112 sx_init(&allproc_lock, "allproc"); 113 sx_init(&proctree_lock, "proctree"); 114 mtx_init(&pargs_ref_lock, "struct pargs.ref", NULL, MTX_DEF); 115 mtx_init(&ppeers_lock, "p_peers", NULL, MTX_DEF); 116 LIST_INIT(&allproc); 117 LIST_INIT(&zombproc); 118 pidhashtbl = hashinit(maxproc / 4, M_PROC, &pidhash); 119 pgrphashtbl = hashinit(maxproc / 4, M_PROC, &pgrphash); 120 proc_zone = uma_zcreate("PROC", sched_sizeof_proc(), 121 proc_ctor, proc_dtor, proc_init, proc_fini, 122 UMA_ALIGN_PTR, UMA_ZONE_NOFREE); 123 uihashinit(); 124 } 125 126 /* 127 * Prepare a proc for use. 128 */ 129 static int 130 proc_ctor(void *mem, int size, void *arg, int flags) 131 { 132 struct proc *p; 133 134 p = (struct proc *)mem; 135 return (0); 136 } 137 138 /* 139 * Reclaim a proc after use. 140 */ 141 static void 142 proc_dtor(void *mem, int size, void *arg) 143 { 144 struct proc *p; 145 struct thread *td; 146 #ifdef INVARIANTS 147 struct ksegrp *kg; 148 #endif 149 150 /* INVARIANTS checks go here */ 151 p = (struct proc *)mem; 152 td = FIRST_THREAD_IN_PROC(p); 153 #ifdef INVARIANTS 154 KASSERT((p->p_numthreads == 1), 155 ("bad number of threads in exiting process")); 156 KASSERT((td != NULL), ("proc_dtor: bad thread pointer")); 157 kg = FIRST_KSEGRP_IN_PROC(p); 158 KASSERT((kg != NULL), ("proc_dtor: bad kg pointer")); 159 #endif 160 161 /* Dispose of an alternate kstack, if it exists. 162 * XXX What if there are more than one thread in the proc? 163 * The first thread in the proc is special and not 164 * freed, so you gotta do this here. 165 */ 166 if (((p->p_flag & P_KTHREAD) != 0) && (td->td_altkstack != 0)) 167 vm_thread_dispose_altkstack(td); 168 } 169 170 /* 171 * Initialize type-stable parts of a proc (when newly created). 172 */ 173 static int 174 proc_init(void *mem, int size, int flags) 175 { 176 struct proc *p; 177 struct thread *td; 178 struct ksegrp *kg; 179 180 p = (struct proc *)mem; 181 p->p_sched = (struct p_sched *)&p[1]; 182 vm_proc_new(p); 183 td = thread_alloc(); 184 kg = ksegrp_alloc(); 185 bzero(&p->p_mtx, sizeof(struct mtx)); 186 mtx_init(&p->p_mtx, "process lock", NULL, MTX_DEF | MTX_DUPOK); 187 proc_linkup(p, kg, td); 188 sched_newproc(p, kg, td); 189 return (0); 190 } 191 192 /* 193 * Tear down type-stable parts of a proc (just before being discarded) 194 */ 195 static void 196 proc_fini(void *mem, int size) 197 { 198 struct proc *p; 199 struct thread *td; 200 struct ksegrp *kg; 201 202 p = (struct proc *)mem; 203 KASSERT((p->p_numthreads == 1), 204 ("bad number of threads in freeing process")); 205 td = FIRST_THREAD_IN_PROC(p); 206 KASSERT((td != NULL), ("proc_fini: bad thread pointer")); 207 kg = FIRST_KSEGRP_IN_PROC(p); 208 KASSERT((kg != NULL), ("proc_fini: bad kg pointer")); 209 vm_proc_dispose(p); 210 sched_destroyproc(p); 211 thread_free(td); 212 ksegrp_free(kg); 213 mtx_destroy(&p->p_mtx); 214 } 215 216 /* 217 * Is p an inferior of the current process? 218 */ 219 int 220 inferior(p) 221 register struct proc *p; 222 { 223 224 sx_assert(&proctree_lock, SX_LOCKED); 225 for (; p != curproc; p = p->p_pptr) 226 if (p->p_pid == 0) 227 return (0); 228 return (1); 229 } 230 231 /* 232 * Locate a process by number; return only "live" processes -- i.e., neither 233 * zombies nor newly born but incompletely initialized processes. By not 234 * returning processes in the PRS_NEW state, we allow callers to avoid 235 * testing for that condition to avoid dereferencing p_ucred, et al. 236 */ 237 struct proc * 238 pfind(pid) 239 register pid_t pid; 240 { 241 register struct proc *p; 242 243 sx_slock(&allproc_lock); 244 LIST_FOREACH(p, PIDHASH(pid), p_hash) 245 if (p->p_pid == pid) { 246 if (p->p_state == PRS_NEW) { 247 p = NULL; 248 break; 249 } 250 PROC_LOCK(p); 251 break; 252 } 253 sx_sunlock(&allproc_lock); 254 return (p); 255 } 256 257 /* 258 * Locate a process group by number. 259 * The caller must hold proctree_lock. 260 */ 261 struct pgrp * 262 pgfind(pgid) 263 register pid_t pgid; 264 { 265 register struct pgrp *pgrp; 266 267 sx_assert(&proctree_lock, SX_LOCKED); 268 269 LIST_FOREACH(pgrp, PGRPHASH(pgid), pg_hash) { 270 if (pgrp->pg_id == pgid) { 271 PGRP_LOCK(pgrp); 272 return (pgrp); 273 } 274 } 275 return (NULL); 276 } 277 278 /* 279 * Create a new process group. 280 * pgid must be equal to the pid of p. 281 * Begin a new session if required. 282 */ 283 int 284 enterpgrp(p, pgid, pgrp, sess) 285 register struct proc *p; 286 pid_t pgid; 287 struct pgrp *pgrp; 288 struct session *sess; 289 { 290 struct pgrp *pgrp2; 291 292 sx_assert(&proctree_lock, SX_XLOCKED); 293 294 KASSERT(pgrp != NULL, ("enterpgrp: pgrp == NULL")); 295 KASSERT(p->p_pid == pgid, 296 ("enterpgrp: new pgrp and pid != pgid")); 297 298 pgrp2 = pgfind(pgid); 299 300 KASSERT(pgrp2 == NULL, 301 ("enterpgrp: pgrp with pgid exists")); 302 KASSERT(!SESS_LEADER(p), 303 ("enterpgrp: session leader attempted setpgrp")); 304 305 mtx_init(&pgrp->pg_mtx, "process group", NULL, MTX_DEF | MTX_DUPOK); 306 307 if (sess != NULL) { 308 /* 309 * new session 310 */ 311 mtx_init(&sess->s_mtx, "session", NULL, MTX_DEF); 312 PROC_LOCK(p); 313 p->p_flag &= ~P_CONTROLT; 314 PROC_UNLOCK(p); 315 PGRP_LOCK(pgrp); 316 sess->s_leader = p; 317 sess->s_sid = p->p_pid; 318 sess->s_count = 1; 319 sess->s_ttyvp = NULL; 320 sess->s_ttyp = NULL; 321 bcopy(p->p_session->s_login, sess->s_login, 322 sizeof(sess->s_login)); 323 pgrp->pg_session = sess; 324 KASSERT(p == curproc, 325 ("enterpgrp: mksession and p != curproc")); 326 } else { 327 pgrp->pg_session = p->p_session; 328 SESS_LOCK(pgrp->pg_session); 329 pgrp->pg_session->s_count++; 330 SESS_UNLOCK(pgrp->pg_session); 331 PGRP_LOCK(pgrp); 332 } 333 pgrp->pg_id = pgid; 334 LIST_INIT(&pgrp->pg_members); 335 336 /* 337 * As we have an exclusive lock of proctree_lock, 338 * this should not deadlock. 339 */ 340 LIST_INSERT_HEAD(PGRPHASH(pgid), pgrp, pg_hash); 341 pgrp->pg_jobc = 0; 342 SLIST_INIT(&pgrp->pg_sigiolst); 343 PGRP_UNLOCK(pgrp); 344 345 doenterpgrp(p, pgrp); 346 347 return (0); 348 } 349 350 /* 351 * Move p to an existing process group 352 */ 353 int 354 enterthispgrp(p, pgrp) 355 register struct proc *p; 356 struct pgrp *pgrp; 357 { 358 359 sx_assert(&proctree_lock, SX_XLOCKED); 360 PROC_LOCK_ASSERT(p, MA_NOTOWNED); 361 PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED); 362 PGRP_LOCK_ASSERT(p->p_pgrp, MA_NOTOWNED); 363 SESS_LOCK_ASSERT(p->p_session, MA_NOTOWNED); 364 KASSERT(pgrp->pg_session == p->p_session, 365 ("%s: pgrp's session %p, p->p_session %p.\n", 366 __func__, 367 pgrp->pg_session, 368 p->p_session)); 369 KASSERT(pgrp != p->p_pgrp, 370 ("%s: p belongs to pgrp.", __func__)); 371 372 doenterpgrp(p, pgrp); 373 374 return (0); 375 } 376 377 /* 378 * Move p to a process group 379 */ 380 static void 381 doenterpgrp(p, pgrp) 382 struct proc *p; 383 struct pgrp *pgrp; 384 { 385 struct pgrp *savepgrp; 386 387 sx_assert(&proctree_lock, SX_XLOCKED); 388 PROC_LOCK_ASSERT(p, MA_NOTOWNED); 389 PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED); 390 PGRP_LOCK_ASSERT(p->p_pgrp, MA_NOTOWNED); 391 SESS_LOCK_ASSERT(p->p_session, MA_NOTOWNED); 392 393 savepgrp = p->p_pgrp; 394 395 /* 396 * Adjust eligibility of affected pgrps to participate in job control. 397 * Increment eligibility counts before decrementing, otherwise we 398 * could reach 0 spuriously during the first call. 399 */ 400 fixjobc(p, pgrp, 1); 401 fixjobc(p, p->p_pgrp, 0); 402 403 PGRP_LOCK(pgrp); 404 PGRP_LOCK(savepgrp); 405 PROC_LOCK(p); 406 LIST_REMOVE(p, p_pglist); 407 p->p_pgrp = pgrp; 408 PROC_UNLOCK(p); 409 LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist); 410 PGRP_UNLOCK(savepgrp); 411 PGRP_UNLOCK(pgrp); 412 if (LIST_EMPTY(&savepgrp->pg_members)) 413 pgdelete(savepgrp); 414 } 415 416 /* 417 * remove process from process group 418 */ 419 int 420 leavepgrp(p) 421 register struct proc *p; 422 { 423 struct pgrp *savepgrp; 424 425 sx_assert(&proctree_lock, SX_XLOCKED); 426 savepgrp = p->p_pgrp; 427 PGRP_LOCK(savepgrp); 428 PROC_LOCK(p); 429 LIST_REMOVE(p, p_pglist); 430 p->p_pgrp = NULL; 431 PROC_UNLOCK(p); 432 PGRP_UNLOCK(savepgrp); 433 if (LIST_EMPTY(&savepgrp->pg_members)) 434 pgdelete(savepgrp); 435 return (0); 436 } 437 438 /* 439 * delete a process group 440 */ 441 static void 442 pgdelete(pgrp) 443 register struct pgrp *pgrp; 444 { 445 struct session *savesess; 446 int i; 447 448 sx_assert(&proctree_lock, SX_XLOCKED); 449 PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED); 450 SESS_LOCK_ASSERT(pgrp->pg_session, MA_NOTOWNED); 451 452 /* 453 * Reset any sigio structures pointing to us as a result of 454 * F_SETOWN with our pgid. 455 */ 456 funsetownlst(&pgrp->pg_sigiolst); 457 458 PGRP_LOCK(pgrp); 459 if (pgrp->pg_session->s_ttyp != NULL && 460 pgrp->pg_session->s_ttyp->t_pgrp == pgrp) 461 pgrp->pg_session->s_ttyp->t_pgrp = NULL; 462 LIST_REMOVE(pgrp, pg_hash); 463 savesess = pgrp->pg_session; 464 SESS_LOCK(savesess); 465 i = --savesess->s_count; 466 SESS_UNLOCK(savesess); 467 PGRP_UNLOCK(pgrp); 468 if (i == 0) { 469 if (savesess->s_ttyp != NULL) 470 ttyrel(savesess->s_ttyp); 471 mtx_destroy(&savesess->s_mtx); 472 FREE(savesess, M_SESSION); 473 } 474 mtx_destroy(&pgrp->pg_mtx); 475 FREE(pgrp, M_PGRP); 476 } 477 478 static void 479 pgadjustjobc(pgrp, entering) 480 struct pgrp *pgrp; 481 int entering; 482 { 483 484 PGRP_LOCK(pgrp); 485 if (entering) 486 pgrp->pg_jobc++; 487 else { 488 --pgrp->pg_jobc; 489 if (pgrp->pg_jobc == 0) 490 orphanpg(pgrp); 491 } 492 PGRP_UNLOCK(pgrp); 493 } 494 495 /* 496 * Adjust pgrp jobc counters when specified process changes process group. 497 * We count the number of processes in each process group that "qualify" 498 * the group for terminal job control (those with a parent in a different 499 * process group of the same session). If that count reaches zero, the 500 * process group becomes orphaned. Check both the specified process' 501 * process group and that of its children. 502 * entering == 0 => p is leaving specified group. 503 * entering == 1 => p is entering specified group. 504 */ 505 void 506 fixjobc(p, pgrp, entering) 507 register struct proc *p; 508 register struct pgrp *pgrp; 509 int entering; 510 { 511 register struct pgrp *hispgrp; 512 register struct session *mysession; 513 514 sx_assert(&proctree_lock, SX_LOCKED); 515 PROC_LOCK_ASSERT(p, MA_NOTOWNED); 516 PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED); 517 SESS_LOCK_ASSERT(pgrp->pg_session, MA_NOTOWNED); 518 519 /* 520 * Check p's parent to see whether p qualifies its own process 521 * group; if so, adjust count for p's process group. 522 */ 523 mysession = pgrp->pg_session; 524 if ((hispgrp = p->p_pptr->p_pgrp) != pgrp && 525 hispgrp->pg_session == mysession) 526 pgadjustjobc(pgrp, entering); 527 528 /* 529 * Check this process' children to see whether they qualify 530 * their process groups; if so, adjust counts for children's 531 * process groups. 532 */ 533 LIST_FOREACH(p, &p->p_children, p_sibling) { 534 hispgrp = p->p_pgrp; 535 if (hispgrp == pgrp || 536 hispgrp->pg_session != mysession) 537 continue; 538 PROC_LOCK(p); 539 if (p->p_state == PRS_ZOMBIE) { 540 PROC_UNLOCK(p); 541 continue; 542 } 543 PROC_UNLOCK(p); 544 pgadjustjobc(hispgrp, entering); 545 } 546 } 547 548 /* 549 * A process group has become orphaned; 550 * if there are any stopped processes in the group, 551 * hang-up all process in that group. 552 */ 553 static void 554 orphanpg(pg) 555 struct pgrp *pg; 556 { 557 register struct proc *p; 558 559 PGRP_LOCK_ASSERT(pg, MA_OWNED); 560 561 LIST_FOREACH(p, &pg->pg_members, p_pglist) { 562 PROC_LOCK(p); 563 if (P_SHOULDSTOP(p)) { 564 PROC_UNLOCK(p); 565 LIST_FOREACH(p, &pg->pg_members, p_pglist) { 566 PROC_LOCK(p); 567 psignal(p, SIGHUP); 568 psignal(p, SIGCONT); 569 PROC_UNLOCK(p); 570 } 571 return; 572 } 573 PROC_UNLOCK(p); 574 } 575 } 576 577 #include "opt_ddb.h" 578 #ifdef DDB 579 #include <ddb/ddb.h> 580 581 DB_SHOW_COMMAND(pgrpdump, pgrpdump) 582 { 583 register struct pgrp *pgrp; 584 register struct proc *p; 585 register int i; 586 587 for (i = 0; i <= pgrphash; i++) { 588 if (!LIST_EMPTY(&pgrphashtbl[i])) { 589 printf("\tindx %d\n", i); 590 LIST_FOREACH(pgrp, &pgrphashtbl[i], pg_hash) { 591 printf( 592 "\tpgrp %p, pgid %ld, sess %p, sesscnt %d, mem %p\n", 593 (void *)pgrp, (long)pgrp->pg_id, 594 (void *)pgrp->pg_session, 595 pgrp->pg_session->s_count, 596 (void *)LIST_FIRST(&pgrp->pg_members)); 597 LIST_FOREACH(p, &pgrp->pg_members, p_pglist) { 598 printf("\t\tpid %ld addr %p pgrp %p\n", 599 (long)p->p_pid, (void *)p, 600 (void *)p->p_pgrp); 601 } 602 } 603 } 604 } 605 } 606 #endif /* DDB */ 607 void 608 fill_kinfo_thread(struct thread *td, struct kinfo_proc *kp); 609 610 /* 611 * Fill in a kinfo_proc structure for the specified process. 612 * Must be called with the target process locked. 613 */ 614 void 615 fill_kinfo_proc(struct proc *p, struct kinfo_proc *kp) 616 { 617 fill_kinfo_thread(FIRST_THREAD_IN_PROC(p), kp); 618 } 619 620 void 621 fill_kinfo_thread(struct thread *td, struct kinfo_proc *kp) 622 { 623 struct proc *p; 624 struct thread *td0; 625 struct ksegrp *kg; 626 struct tty *tp; 627 struct session *sp; 628 struct timeval tv; 629 struct sigacts *ps; 630 631 p = td->td_proc; 632 633 bzero(kp, sizeof(*kp)); 634 635 kp->ki_structsize = sizeof(*kp); 636 kp->ki_paddr = p; 637 PROC_LOCK_ASSERT(p, MA_OWNED); 638 kp->ki_addr =/* p->p_addr; */0; /* XXXKSE */ 639 kp->ki_args = p->p_args; 640 kp->ki_textvp = p->p_textvp; 641 #ifdef KTRACE 642 kp->ki_tracep = p->p_tracevp; 643 mtx_lock(&ktrace_mtx); 644 kp->ki_traceflag = p->p_traceflag; 645 mtx_unlock(&ktrace_mtx); 646 #endif 647 kp->ki_fd = p->p_fd; 648 kp->ki_vmspace = p->p_vmspace; 649 if (p->p_ucred) { 650 kp->ki_uid = p->p_ucred->cr_uid; 651 kp->ki_ruid = p->p_ucred->cr_ruid; 652 kp->ki_svuid = p->p_ucred->cr_svuid; 653 /* XXX bde doesn't like KI_NGROUPS */ 654 kp->ki_ngroups = min(p->p_ucred->cr_ngroups, KI_NGROUPS); 655 bcopy(p->p_ucred->cr_groups, kp->ki_groups, 656 kp->ki_ngroups * sizeof(gid_t)); 657 kp->ki_rgid = p->p_ucred->cr_rgid; 658 kp->ki_svgid = p->p_ucred->cr_svgid; 659 } 660 if (p->p_sigacts) { 661 ps = p->p_sigacts; 662 mtx_lock(&ps->ps_mtx); 663 kp->ki_sigignore = ps->ps_sigignore; 664 kp->ki_sigcatch = ps->ps_sigcatch; 665 mtx_unlock(&ps->ps_mtx); 666 } 667 mtx_lock_spin(&sched_lock); 668 if (p->p_state != PRS_NEW && 669 p->p_state != PRS_ZOMBIE && 670 p->p_vmspace != NULL) { 671 struct vmspace *vm = p->p_vmspace; 672 673 kp->ki_size = vm->vm_map.size; 674 kp->ki_rssize = vmspace_resident_count(vm); /*XXX*/ 675 if (p->p_sflag & PS_INMEM) 676 kp->ki_rssize += UAREA_PAGES; 677 FOREACH_THREAD_IN_PROC(p, td0) { 678 if (!TD_IS_SWAPPED(td0)) 679 kp->ki_rssize += td0->td_kstack_pages; 680 if (td0->td_altkstack_obj != NULL) 681 kp->ki_rssize += td0->td_altkstack_pages; 682 } 683 kp->ki_swrss = vm->vm_swrss; 684 kp->ki_tsize = vm->vm_tsize; 685 kp->ki_dsize = vm->vm_dsize; 686 kp->ki_ssize = vm->vm_ssize; 687 } 688 if ((p->p_sflag & PS_INMEM) && p->p_stats) { 689 kp->ki_start = p->p_stats->p_start; 690 timevaladd(&kp->ki_start, &boottime); 691 kp->ki_rusage = p->p_stats->p_ru; 692 calcru(p, &kp->ki_rusage.ru_utime, &kp->ki_rusage.ru_stime, 693 NULL); 694 kp->ki_childstime = p->p_stats->p_cru.ru_stime; 695 kp->ki_childutime = p->p_stats->p_cru.ru_utime; 696 /* Some callers want child-times in a single value */ 697 kp->ki_childtime = kp->ki_childstime; 698 timevaladd(&kp->ki_childtime, &kp->ki_childutime); 699 } 700 kp->ki_sflag = p->p_sflag; 701 kp->ki_swtime = p->p_swtime; 702 kp->ki_pid = p->p_pid; 703 kp->ki_nice = p->p_nice; 704 bintime2timeval(&p->p_runtime, &tv); 705 kp->ki_runtime = tv.tv_sec * (u_int64_t)1000000 + tv.tv_usec; 706 if (p->p_state != PRS_ZOMBIE) { 707 #if 0 708 if (td == NULL) { 709 /* XXXKSE: This should never happen. */ 710 printf("fill_kinfo_proc(): pid %d has no threads!\n", 711 p->p_pid); 712 mtx_unlock_spin(&sched_lock); 713 return; 714 } 715 #endif 716 if (td->td_wmesg != NULL) { 717 strlcpy(kp->ki_wmesg, td->td_wmesg, 718 sizeof(kp->ki_wmesg)); 719 } 720 if (TD_ON_LOCK(td)) { 721 kp->ki_kiflag |= KI_LOCKBLOCK; 722 strlcpy(kp->ki_lockname, td->td_lockname, 723 sizeof(kp->ki_lockname)); 724 } 725 726 if (p->p_state == PRS_NORMAL) { /* XXXKSE very approximate */ 727 if (TD_ON_RUNQ(td) || 728 TD_CAN_RUN(td) || 729 TD_IS_RUNNING(td)) { 730 kp->ki_stat = SRUN; 731 } else if (P_SHOULDSTOP(p)) { 732 kp->ki_stat = SSTOP; 733 } else if (TD_IS_SLEEPING(td)) { 734 kp->ki_stat = SSLEEP; 735 } else if (TD_ON_LOCK(td)) { 736 kp->ki_stat = SLOCK; 737 } else { 738 kp->ki_stat = SWAIT; 739 } 740 } else { 741 kp->ki_stat = SIDL; 742 } 743 744 kg = td->td_ksegrp; 745 746 /* things in the KSE GROUP */ 747 kp->ki_estcpu = kg->kg_estcpu; 748 kp->ki_slptime = kg->kg_slptime; 749 kp->ki_pri.pri_user = kg->kg_user_pri; 750 kp->ki_pri.pri_class = kg->kg_pri_class; 751 752 /* Things in the thread */ 753 kp->ki_wchan = td->td_wchan; 754 kp->ki_pri.pri_level = td->td_priority; 755 kp->ki_pri.pri_native = td->td_base_pri; 756 kp->ki_lastcpu = td->td_lastcpu; 757 kp->ki_oncpu = td->td_oncpu; 758 kp->ki_tdflags = td->td_flags; 759 kp->ki_tid = td->td_tid; 760 kp->ki_numthreads = p->p_numthreads; 761 kp->ki_pcb = td->td_pcb; 762 kp->ki_kstack = (void *)td->td_kstack; 763 kp->ki_pctcpu = sched_pctcpu(td); 764 765 /* We can't get this anymore but ps etc never used it anyway. */ 766 kp->ki_rqindex = 0; 767 768 } else { 769 kp->ki_stat = SZOMB; 770 } 771 mtx_unlock_spin(&sched_lock); 772 sp = NULL; 773 tp = NULL; 774 if (p->p_pgrp) { 775 kp->ki_pgid = p->p_pgrp->pg_id; 776 kp->ki_jobc = p->p_pgrp->pg_jobc; 777 sp = p->p_pgrp->pg_session; 778 779 if (sp != NULL) { 780 kp->ki_sid = sp->s_sid; 781 SESS_LOCK(sp); 782 strlcpy(kp->ki_login, sp->s_login, 783 sizeof(kp->ki_login)); 784 if (sp->s_ttyvp) 785 kp->ki_kiflag |= KI_CTTY; 786 if (SESS_LEADER(p)) 787 kp->ki_kiflag |= KI_SLEADER; 788 tp = sp->s_ttyp; 789 SESS_UNLOCK(sp); 790 } 791 } 792 if ((p->p_flag & P_CONTROLT) && tp != NULL) { 793 kp->ki_tdev = dev2udev(tp->t_dev); 794 kp->ki_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID; 795 if (tp->t_session) 796 kp->ki_tsid = tp->t_session->s_sid; 797 } else 798 kp->ki_tdev = NODEV; 799 if (p->p_comm[0] != '\0') { 800 strlcpy(kp->ki_comm, p->p_comm, sizeof(kp->ki_comm)); 801 strlcpy(kp->ki_ocomm, p->p_comm, sizeof(kp->ki_ocomm)); 802 } 803 if (p->p_sysent && p->p_sysent->sv_name != NULL && 804 p->p_sysent->sv_name[0] != '\0') 805 strlcpy(kp->ki_emul, p->p_sysent->sv_name, sizeof(kp->ki_emul)); 806 kp->ki_siglist = p->p_siglist; 807 SIGSETOR(kp->ki_siglist, td->td_siglist); 808 kp->ki_sigmask = td->td_sigmask; 809 kp->ki_xstat = p->p_xstat; 810 kp->ki_acflag = p->p_acflag; 811 kp->ki_flag = p->p_flag; 812 /* If jailed(p->p_ucred), emulate the old P_JAILED flag. */ 813 if (jailed(p->p_ucred)) 814 kp->ki_flag |= P_JAILED; 815 kp->ki_lock = p->p_lock; 816 if (p->p_pptr) 817 kp->ki_ppid = p->p_pptr->p_pid; 818 } 819 820 /* 821 * Locate a zombie process by number 822 */ 823 struct proc * 824 zpfind(pid_t pid) 825 { 826 struct proc *p; 827 828 sx_slock(&allproc_lock); 829 LIST_FOREACH(p, &zombproc, p_list) 830 if (p->p_pid == pid) { 831 PROC_LOCK(p); 832 break; 833 } 834 sx_sunlock(&allproc_lock); 835 return (p); 836 } 837 838 #define KERN_PROC_ZOMBMASK 0x3 839 #define KERN_PROC_NOTHREADS 0x4 840 841 /* 842 * Must be called with the process locked and will return with it unlocked. 843 */ 844 static int 845 sysctl_out_proc(struct proc *p, struct sysctl_req *req, int flags) 846 { 847 struct thread *td; 848 struct kinfo_proc kinfo_proc; 849 int error = 0; 850 struct proc *np; 851 pid_t pid = p->p_pid; 852 853 PROC_LOCK_ASSERT(p, MA_OWNED); 854 855 if (flags & KERN_PROC_NOTHREADS) { 856 fill_kinfo_proc(p, &kinfo_proc); 857 PROC_UNLOCK(p); 858 error = SYSCTL_OUT(req, (caddr_t)&kinfo_proc, 859 sizeof(kinfo_proc)); 860 PROC_LOCK(p); 861 } else { 862 _PHOLD(p); 863 FOREACH_THREAD_IN_PROC(p, td) { 864 fill_kinfo_thread(td, &kinfo_proc); 865 PROC_UNLOCK(p); 866 error = SYSCTL_OUT(req, (caddr_t)&kinfo_proc, 867 sizeof(kinfo_proc)); 868 PROC_LOCK(p); 869 if (error) 870 break; 871 } 872 _PRELE(p); 873 } 874 PROC_UNLOCK(p); 875 if (error) 876 return (error); 877 if (flags & KERN_PROC_ZOMBMASK) 878 np = zpfind(pid); 879 else { 880 if (pid == 0) 881 return (0); 882 np = pfind(pid); 883 } 884 if (np == NULL) 885 return EAGAIN; 886 if (np != p) { 887 PROC_UNLOCK(np); 888 return EAGAIN; 889 } 890 PROC_UNLOCK(np); 891 return (0); 892 } 893 894 static int 895 sysctl_kern_proc(SYSCTL_HANDLER_ARGS) 896 { 897 int *name = (int*) arg1; 898 u_int namelen = arg2; 899 struct proc *p; 900 int flags, doingzomb, oid_number; 901 int error = 0; 902 903 oid_number = oidp->oid_number; 904 if (oid_number != KERN_PROC_ALL && 905 (oid_number & KERN_PROC_INC_THREAD) == 0) 906 flags = KERN_PROC_NOTHREADS; 907 else { 908 flags = 0; 909 oid_number &= ~KERN_PROC_INC_THREAD; 910 } 911 if (oid_number == KERN_PROC_PID) { 912 if (namelen != 1) 913 return (EINVAL); 914 p = pfind((pid_t)name[0]); 915 if (!p) 916 return (ESRCH); 917 if ((error = p_cansee(curthread, p))) { 918 PROC_UNLOCK(p); 919 return (error); 920 } 921 error = sysctl_out_proc(p, req, flags); 922 return (error); 923 } 924 925 switch (oid_number) { 926 case KERN_PROC_ALL: 927 if (namelen != 0) 928 return (EINVAL); 929 break; 930 case KERN_PROC_PROC: 931 if (namelen != 0 && namelen != 1) 932 return (EINVAL); 933 break; 934 default: 935 if (namelen != 1) 936 return (EINVAL); 937 break; 938 } 939 940 if (!req->oldptr) { 941 /* overestimate by 5 procs */ 942 error = SYSCTL_OUT(req, 0, sizeof (struct kinfo_proc) * 5); 943 if (error) 944 return (error); 945 } 946 error = sysctl_wire_old_buffer(req, 0); 947 if (error != 0) 948 return (error); 949 sx_slock(&allproc_lock); 950 for (doingzomb=0 ; doingzomb < 2 ; doingzomb++) { 951 if (!doingzomb) 952 p = LIST_FIRST(&allproc); 953 else 954 p = LIST_FIRST(&zombproc); 955 for (; p != 0; p = LIST_NEXT(p, p_list)) { 956 /* 957 * Skip embryonic processes. 958 */ 959 mtx_lock_spin(&sched_lock); 960 if (p->p_state == PRS_NEW) { 961 mtx_unlock_spin(&sched_lock); 962 continue; 963 } 964 mtx_unlock_spin(&sched_lock); 965 PROC_LOCK(p); 966 /* 967 * Show a user only appropriate processes. 968 */ 969 if (p_cansee(curthread, p)) { 970 PROC_UNLOCK(p); 971 continue; 972 } 973 /* 974 * TODO - make more efficient (see notes below). 975 * do by session. 976 */ 977 switch (oid_number) { 978 979 case KERN_PROC_GID: 980 if (p->p_ucred == NULL || 981 p->p_ucred->cr_gid != (gid_t)name[0]) { 982 PROC_UNLOCK(p); 983 continue; 984 } 985 break; 986 987 case KERN_PROC_PGRP: 988 /* could do this by traversing pgrp */ 989 if (p->p_pgrp == NULL || 990 p->p_pgrp->pg_id != (pid_t)name[0]) { 991 PROC_UNLOCK(p); 992 continue; 993 } 994 break; 995 996 case KERN_PROC_RGID: 997 if (p->p_ucred == NULL || 998 p->p_ucred->cr_rgid != (gid_t)name[0]) { 999 PROC_UNLOCK(p); 1000 continue; 1001 } 1002 break; 1003 1004 case KERN_PROC_SESSION: 1005 if (p->p_session == NULL || 1006 p->p_session->s_sid != (pid_t)name[0]) { 1007 PROC_UNLOCK(p); 1008 continue; 1009 } 1010 break; 1011 1012 case KERN_PROC_TTY: 1013 if ((p->p_flag & P_CONTROLT) == 0 || 1014 p->p_session == NULL) { 1015 PROC_UNLOCK(p); 1016 continue; 1017 } 1018 SESS_LOCK(p->p_session); 1019 if (p->p_session->s_ttyp == NULL || 1020 dev2udev(p->p_session->s_ttyp->t_dev) != 1021 (dev_t)name[0]) { 1022 SESS_UNLOCK(p->p_session); 1023 PROC_UNLOCK(p); 1024 continue; 1025 } 1026 SESS_UNLOCK(p->p_session); 1027 break; 1028 1029 case KERN_PROC_UID: 1030 if (p->p_ucred == NULL || 1031 p->p_ucred->cr_uid != (uid_t)name[0]) { 1032 PROC_UNLOCK(p); 1033 continue; 1034 } 1035 break; 1036 1037 case KERN_PROC_RUID: 1038 if (p->p_ucred == NULL || 1039 p->p_ucred->cr_ruid != (uid_t)name[0]) { 1040 PROC_UNLOCK(p); 1041 continue; 1042 } 1043 break; 1044 1045 case KERN_PROC_PROC: 1046 break; 1047 1048 default: 1049 break; 1050 1051 } 1052 1053 error = sysctl_out_proc(p, req, flags | doingzomb); 1054 if (error) { 1055 sx_sunlock(&allproc_lock); 1056 return (error); 1057 } 1058 } 1059 } 1060 sx_sunlock(&allproc_lock); 1061 return (0); 1062 } 1063 1064 struct pargs * 1065 pargs_alloc(int len) 1066 { 1067 struct pargs *pa; 1068 1069 MALLOC(pa, struct pargs *, sizeof(struct pargs) + len, M_PARGS, 1070 M_WAITOK); 1071 pa->ar_ref = 1; 1072 pa->ar_length = len; 1073 return (pa); 1074 } 1075 1076 void 1077 pargs_free(struct pargs *pa) 1078 { 1079 1080 FREE(pa, M_PARGS); 1081 } 1082 1083 void 1084 pargs_hold(struct pargs *pa) 1085 { 1086 1087 if (pa == NULL) 1088 return; 1089 PARGS_LOCK(pa); 1090 pa->ar_ref++; 1091 PARGS_UNLOCK(pa); 1092 } 1093 1094 void 1095 pargs_drop(struct pargs *pa) 1096 { 1097 1098 if (pa == NULL) 1099 return; 1100 PARGS_LOCK(pa); 1101 if (--pa->ar_ref == 0) { 1102 PARGS_UNLOCK(pa); 1103 pargs_free(pa); 1104 } else 1105 PARGS_UNLOCK(pa); 1106 } 1107 1108 /* 1109 * This sysctl allows a process to retrieve the argument list or process 1110 * title for another process without groping around in the address space 1111 * of the other process. It also allow a process to set its own "process 1112 * title to a string of its own choice. 1113 */ 1114 static int 1115 sysctl_kern_proc_args(SYSCTL_HANDLER_ARGS) 1116 { 1117 int *name = (int*) arg1; 1118 u_int namelen = arg2; 1119 struct pargs *newpa, *pa; 1120 struct proc *p; 1121 int error = 0; 1122 1123 if (namelen != 1) 1124 return (EINVAL); 1125 1126 p = pfind((pid_t)name[0]); 1127 if (!p) 1128 return (ESRCH); 1129 1130 if ((error = p_cansee(curthread, p)) != 0) { 1131 PROC_UNLOCK(p); 1132 return (error); 1133 } 1134 1135 if (req->newptr && curproc != p) { 1136 PROC_UNLOCK(p); 1137 return (EPERM); 1138 } 1139 1140 pa = p->p_args; 1141 pargs_hold(pa); 1142 PROC_UNLOCK(p); 1143 if (req->oldptr != NULL && pa != NULL) 1144 error = SYSCTL_OUT(req, pa->ar_args, pa->ar_length); 1145 pargs_drop(pa); 1146 if (error != 0 || req->newptr == NULL) 1147 return (error); 1148 1149 if (req->newlen + sizeof(struct pargs) > ps_arg_cache_limit) 1150 return (ENOMEM); 1151 newpa = pargs_alloc(req->newlen); 1152 error = SYSCTL_IN(req, newpa->ar_args, req->newlen); 1153 if (error != 0) { 1154 pargs_free(newpa); 1155 return (error); 1156 } 1157 PROC_LOCK(p); 1158 pa = p->p_args; 1159 p->p_args = newpa; 1160 PROC_UNLOCK(p); 1161 pargs_drop(pa); 1162 return (0); 1163 } 1164 1165 static int 1166 sysctl_kern_proc_sv_name(SYSCTL_HANDLER_ARGS) 1167 { 1168 struct proc *p; 1169 char *sv_name; 1170 int *name; 1171 int namelen; 1172 int error; 1173 1174 namelen = arg2; 1175 if (namelen != 1) 1176 return (EINVAL); 1177 1178 name = (int *)arg1; 1179 if ((p = pfind((pid_t)name[0])) == NULL) 1180 return (ESRCH); 1181 if ((error = p_cansee(curthread, p))) { 1182 PROC_UNLOCK(p); 1183 return (error); 1184 } 1185 sv_name = p->p_sysent->sv_name; 1186 PROC_UNLOCK(p); 1187 return (sysctl_handle_string(oidp, sv_name, 0, req)); 1188 } 1189 1190 1191 SYSCTL_NODE(_kern, KERN_PROC, proc, CTLFLAG_RD, 0, "Process table"); 1192 1193 SYSCTL_PROC(_kern_proc, KERN_PROC_ALL, all, CTLFLAG_RD|CTLTYPE_STRUCT, 1194 0, 0, sysctl_kern_proc, "S,proc", "Return entire process table"); 1195 1196 SYSCTL_NODE(_kern_proc, KERN_PROC_GID, gid, CTLFLAG_RD, 1197 sysctl_kern_proc, "Process table"); 1198 1199 SYSCTL_NODE(_kern_proc, KERN_PROC_PGRP, pgrp, CTLFLAG_RD, 1200 sysctl_kern_proc, "Process table"); 1201 1202 SYSCTL_NODE(_kern_proc, KERN_PROC_RGID, rgid, CTLFLAG_RD, 1203 sysctl_kern_proc, "Process table"); 1204 1205 SYSCTL_NODE(_kern_proc, KERN_PROC_SESSION, sid, CTLFLAG_RD, 1206 sysctl_kern_proc, "Process table"); 1207 1208 SYSCTL_NODE(_kern_proc, KERN_PROC_TTY, tty, CTLFLAG_RD, 1209 sysctl_kern_proc, "Process table"); 1210 1211 SYSCTL_NODE(_kern_proc, KERN_PROC_UID, uid, CTLFLAG_RD, 1212 sysctl_kern_proc, "Process table"); 1213 1214 SYSCTL_NODE(_kern_proc, KERN_PROC_RUID, ruid, CTLFLAG_RD, 1215 sysctl_kern_proc, "Process table"); 1216 1217 SYSCTL_NODE(_kern_proc, KERN_PROC_PID, pid, CTLFLAG_RD, 1218 sysctl_kern_proc, "Process table"); 1219 1220 SYSCTL_NODE(_kern_proc, KERN_PROC_PROC, proc, CTLFLAG_RD, 1221 sysctl_kern_proc, "Return process table, no threads"); 1222 1223 SYSCTL_NODE(_kern_proc, KERN_PROC_ARGS, args, CTLFLAG_RW | CTLFLAG_ANYBODY, 1224 sysctl_kern_proc_args, "Process argument list"); 1225 1226 SYSCTL_NODE(_kern_proc, KERN_PROC_SV_NAME, sv_name, CTLFLAG_RD, 1227 sysctl_kern_proc_sv_name, "Process syscall vector name (ABI type)"); 1228 1229 SYSCTL_NODE(_kern_proc, (KERN_PROC_GID | KERN_PROC_INC_THREAD), gid_td, 1230 CTLFLAG_RD, sysctl_kern_proc, "Process table"); 1231 1232 SYSCTL_NODE(_kern_proc, (KERN_PROC_PGRP | KERN_PROC_INC_THREAD), pgrp_td, 1233 CTLFLAG_RD, sysctl_kern_proc, "Process table"); 1234 1235 SYSCTL_NODE(_kern_proc, (KERN_PROC_RGID | KERN_PROC_INC_THREAD), rgid_td, 1236 CTLFLAG_RD, sysctl_kern_proc, "Process table"); 1237 1238 SYSCTL_NODE(_kern_proc, (KERN_PROC_SESSION | KERN_PROC_INC_THREAD), sid_td, 1239 CTLFLAG_RD, sysctl_kern_proc, "Process table"); 1240 1241 SYSCTL_NODE(_kern_proc, (KERN_PROC_TTY | KERN_PROC_INC_THREAD), tty_td, 1242 CTLFLAG_RD, sysctl_kern_proc, "Process table"); 1243 1244 SYSCTL_NODE(_kern_proc, (KERN_PROC_UID | KERN_PROC_INC_THREAD), uid_td, 1245 CTLFLAG_RD, sysctl_kern_proc, "Process table"); 1246 1247 SYSCTL_NODE(_kern_proc, (KERN_PROC_RUID | KERN_PROC_INC_THREAD), ruid_td, 1248 CTLFLAG_RD, sysctl_kern_proc, "Process table"); 1249 1250 SYSCTL_NODE(_kern_proc, (KERN_PROC_PID | KERN_PROC_INC_THREAD), pid_td, 1251 CTLFLAG_RD, sysctl_kern_proc, "Process table"); 1252 1253 SYSCTL_NODE(_kern_proc, (KERN_PROC_PROC | KERN_PROC_INC_THREAD), proc_td, 1254 CTLFLAG_RD, sysctl_kern_proc, "Return process table, no threads"); 1255