1 /* 2 * (MPSAFE) 3 * 4 * Copyright (c) 1982, 1986, 1989, 1991, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by the University of 18 * California, Berkeley and its contributors. 19 * 4. Neither the name of the University nor the names of its contributors 20 * may be used to endorse or promote products derived from this software 21 * without specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 33 * SUCH DAMAGE. 34 * 35 * @(#)kern_proc.c 8.7 (Berkeley) 2/14/95 36 * $FreeBSD: src/sys/kern/kern_proc.c,v 1.63.2.9 2003/05/08 07:47:16 kbyanc Exp $ 37 * $DragonFly: src/sys/kern/kern_proc.c,v 1.45 2008/06/12 23:25:02 dillon Exp $ 38 */ 39 40 #include <sys/param.h> 41 #include <sys/systm.h> 42 #include <sys/kernel.h> 43 #include <sys/sysctl.h> 44 #include <sys/malloc.h> 45 #include <sys/proc.h> 46 #include <sys/jail.h> 47 #include <sys/filedesc.h> 48 #include <sys/tty.h> 49 #include <sys/dsched.h> 50 #include <sys/signalvar.h> 51 #include <sys/spinlock.h> 52 #include <vm/vm.h> 53 #include <sys/lock.h> 54 #include <vm/pmap.h> 55 #include <vm/vm_map.h> 56 #include <sys/user.h> 57 #include <machine/smp.h> 58 59 #include <sys/spinlock2.h> 60 #include <sys/mplock2.h> 61 62 static MALLOC_DEFINE(M_PGRP, "pgrp", "process group header"); 63 MALLOC_DEFINE(M_SESSION, "session", "session header"); 64 MALLOC_DEFINE(M_PROC, "proc", "Proc structures"); 65 MALLOC_DEFINE(M_LWP, "lwp", "lwp structures"); 66 MALLOC_DEFINE(M_SUBPROC, "subproc", "Proc sub-structures"); 67 68 int ps_showallprocs = 1; 69 static int ps_showallthreads = 1; 70 SYSCTL_INT(_security, OID_AUTO, ps_showallprocs, CTLFLAG_RW, 71 &ps_showallprocs, 0, 72 "Unprivileged processes can see proccesses with different UID/GID"); 73 SYSCTL_INT(_security, OID_AUTO, ps_showallthreads, CTLFLAG_RW, 74 &ps_showallthreads, 0, 75 "Unprivileged processes can see kernel threads"); 76 77 static void pgdelete(struct pgrp *); 78 static void orphanpg(struct pgrp *pg); 79 static pid_t proc_getnewpid_locked(int random_offset); 80 81 /* 82 * Other process lists 83 */ 84 struct pidhashhead *pidhashtbl; 85 u_long pidhash; 86 struct pgrphashhead *pgrphashtbl; 87 u_long pgrphash; 88 struct proclist allproc; 89 struct proclist zombproc; 90 91 /* 92 * Random component to nextpid generation. We mix in a random factor to make 93 * it a little harder to predict. We sanity check the modulus value to avoid 94 * doing it in critical paths. Don't let it be too small or we pointlessly 95 * waste randomness entropy, and don't let it be impossibly large. Using a 96 * modulus that is too big causes a LOT more process table scans and slows 97 * down fork processing as the pidchecked caching is defeated. 98 */ 99 static int randompid = 0; 100 101 /* 102 * No requirements. 103 */ 104 static int 105 sysctl_kern_randompid(SYSCTL_HANDLER_ARGS) 106 { 107 int error, pid; 108 109 pid = randompid; 110 error = sysctl_handle_int(oidp, &pid, 0, req); 111 if (error || !req->newptr) 112 return (error); 113 if (pid < 0 || pid > PID_MAX - 100) /* out of range */ 114 pid = PID_MAX - 100; 115 else if (pid < 2) /* NOP */ 116 pid = 0; 117 else if (pid < 100) /* Make it reasonable */ 118 pid = 100; 119 randompid = pid; 120 return (error); 121 } 122 123 SYSCTL_PROC(_kern, OID_AUTO, randompid, CTLTYPE_INT|CTLFLAG_RW, 124 0, 0, sysctl_kern_randompid, "I", "Random PID modulus"); 125 126 /* 127 * Initialize global process hashing structures. 128 * 129 * Called from the low level boot code only. 130 */ 131 void 132 procinit(void) 133 { 134 LIST_INIT(&allproc); 135 LIST_INIT(&zombproc); 136 lwkt_init(); 137 pidhashtbl = hashinit(maxproc / 4, M_PROC, &pidhash); 138 pgrphashtbl = hashinit(maxproc / 4, M_PROC, &pgrphash); 139 uihashinit(); 140 } 141 142 /* 143 * Is p an inferior of the current process? 144 * 145 * No requirements. 146 * The caller must hold proc_token if the caller wishes a stable result. 147 */ 148 int 149 inferior(struct proc *p) 150 { 151 lwkt_gettoken(&proc_token); 152 while (p != curproc) { 153 if (p->p_pid == 0) { 154 lwkt_reltoken(&proc_token); 155 return (0); 156 } 157 p = p->p_pptr; 158 } 159 lwkt_reltoken(&proc_token); 160 return (1); 161 } 162 163 /* 164 * Locate a process by number 165 * 166 * XXX TODO - change API to PHOLD() the returned process ? 167 * 168 * No requirements. 169 * The caller must hold proc_token if the caller wishes a stable result. 170 */ 171 struct proc * 172 pfind(pid_t pid) 173 { 174 struct proc *p; 175 176 lwkt_gettoken(&proc_token); 177 LIST_FOREACH(p, PIDHASH(pid), p_hash) { 178 if (p->p_pid == pid) { 179 lwkt_reltoken(&proc_token); 180 return (p); 181 } 182 } 183 lwkt_reltoken(&proc_token); 184 return (NULL); 185 } 186 187 /* 188 * Locate a process group by number 189 * 190 * No requirements. 191 * The caller must hold proc_token if the caller wishes a stable result. 192 */ 193 struct pgrp * 194 pgfind(pid_t pgid) 195 { 196 struct pgrp *pgrp; 197 198 lwkt_gettoken(&proc_token); 199 LIST_FOREACH(pgrp, PGRPHASH(pgid), pg_hash) { 200 if (pgrp->pg_id == pgid) { 201 lwkt_reltoken(&proc_token); 202 return (pgrp); 203 } 204 } 205 lwkt_reltoken(&proc_token); 206 return (NULL); 207 } 208 209 /* 210 * Move p to a new or existing process group (and session) 211 * 212 * No requirements. 213 */ 214 int 215 enterpgrp(struct proc *p, pid_t pgid, int mksess) 216 { 217 struct pgrp *pgrp; 218 int error; 219 220 lwkt_gettoken(&proc_token); 221 pgrp = pgfind(pgid); 222 223 KASSERT(pgrp == NULL || !mksess, 224 ("enterpgrp: setsid into non-empty pgrp")); 225 KASSERT(!SESS_LEADER(p), 226 ("enterpgrp: session leader attempted setpgrp")); 227 228 if (pgrp == NULL) { 229 pid_t savepid = p->p_pid; 230 struct proc *np; 231 /* 232 * new process group 233 */ 234 KASSERT(p->p_pid == pgid, 235 ("enterpgrp: new pgrp and pid != pgid")); 236 if ((np = pfind(savepid)) == NULL || np != p) { 237 error = ESRCH; 238 goto fatal; 239 } 240 MALLOC(pgrp, struct pgrp *, sizeof(struct pgrp), 241 M_PGRP, M_WAITOK); 242 if (mksess) { 243 struct session *sess; 244 245 /* 246 * new session 247 */ 248 MALLOC(sess, struct session *, sizeof(struct session), 249 M_SESSION, M_WAITOK); 250 sess->s_leader = p; 251 sess->s_sid = p->p_pid; 252 sess->s_count = 1; 253 sess->s_ttyvp = NULL; 254 sess->s_ttyp = NULL; 255 bcopy(p->p_session->s_login, sess->s_login, 256 sizeof(sess->s_login)); 257 p->p_flag &= ~P_CONTROLT; 258 pgrp->pg_session = sess; 259 KASSERT(p == curproc, 260 ("enterpgrp: mksession and p != curproc")); 261 } else { 262 pgrp->pg_session = p->p_session; 263 sess_hold(pgrp->pg_session); 264 } 265 pgrp->pg_id = pgid; 266 LIST_INIT(&pgrp->pg_members); 267 LIST_INSERT_HEAD(PGRPHASH(pgid), pgrp, pg_hash); 268 pgrp->pg_jobc = 0; 269 SLIST_INIT(&pgrp->pg_sigiolst); 270 lockinit(&pgrp->pg_lock, "pgwt", 0, 0); 271 } else if (pgrp == p->p_pgrp) { 272 goto done; 273 } 274 275 /* 276 * Adjust eligibility of affected pgrps to participate in job control. 277 * Increment eligibility counts before decrementing, otherwise we 278 * could reach 0 spuriously during the first call. 279 */ 280 fixjobc(p, pgrp, 1); 281 fixjobc(p, p->p_pgrp, 0); 282 283 LIST_REMOVE(p, p_pglist); 284 if (LIST_EMPTY(&p->p_pgrp->pg_members)) 285 pgdelete(p->p_pgrp); 286 p->p_pgrp = pgrp; 287 LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist); 288 done: 289 error = 0; 290 fatal: 291 lwkt_reltoken(&proc_token); 292 return (error); 293 } 294 295 /* 296 * Remove process from process group 297 * 298 * No requirements. 299 */ 300 int 301 leavepgrp(struct proc *p) 302 { 303 lwkt_gettoken(&proc_token); 304 LIST_REMOVE(p, p_pglist); 305 if (LIST_EMPTY(&p->p_pgrp->pg_members)) 306 pgdelete(p->p_pgrp); 307 p->p_pgrp = NULL; 308 lwkt_reltoken(&proc_token); 309 return (0); 310 } 311 312 /* 313 * Delete a process group 314 * 315 * The caller must hold proc_token. 316 */ 317 static void 318 pgdelete(struct pgrp *pgrp) 319 { 320 /* 321 * Reset any sigio structures pointing to us as a result of 322 * F_SETOWN with our pgid. 323 */ 324 funsetownlst(&pgrp->pg_sigiolst); 325 326 if (pgrp->pg_session->s_ttyp != NULL && 327 pgrp->pg_session->s_ttyp->t_pgrp == pgrp) 328 pgrp->pg_session->s_ttyp->t_pgrp = NULL; 329 LIST_REMOVE(pgrp, pg_hash); 330 sess_rele(pgrp->pg_session); 331 kfree(pgrp, M_PGRP); 332 } 333 334 /* 335 * Adjust the ref count on a session structure. When the ref count falls to 336 * zero the tty is disassociated from the session and the session structure 337 * is freed. Note that tty assocation is not itself ref-counted. 338 * 339 * No requirements. 340 */ 341 void 342 sess_hold(struct session *sp) 343 { 344 lwkt_gettoken(&tty_token); 345 ++sp->s_count; 346 lwkt_reltoken(&tty_token); 347 } 348 349 /* 350 * No requirements. 351 */ 352 void 353 sess_rele(struct session *sp) 354 { 355 KKASSERT(sp->s_count > 0); 356 lwkt_gettoken(&tty_token); 357 if (--sp->s_count == 0) { 358 if (sp->s_ttyp && sp->s_ttyp->t_session) { 359 #ifdef TTY_DO_FULL_CLOSE 360 /* FULL CLOSE, see ttyclearsession() */ 361 KKASSERT(sp->s_ttyp->t_session == sp); 362 sp->s_ttyp->t_session = NULL; 363 #else 364 /* HALF CLOSE, see ttyclearsession() */ 365 if (sp->s_ttyp->t_session == sp) 366 sp->s_ttyp->t_session = NULL; 367 #endif 368 } 369 kfree(sp, M_SESSION); 370 } 371 lwkt_reltoken(&tty_token); 372 } 373 374 /* 375 * Adjust pgrp jobc counters when specified process changes process group. 376 * We count the number of processes in each process group that "qualify" 377 * the group for terminal job control (those with a parent in a different 378 * process group of the same session). If that count reaches zero, the 379 * process group becomes orphaned. Check both the specified process' 380 * process group and that of its children. 381 * entering == 0 => p is leaving specified group. 382 * entering == 1 => p is entering specified group. 383 * 384 * No requirements. 385 */ 386 void 387 fixjobc(struct proc *p, struct pgrp *pgrp, int entering) 388 { 389 struct pgrp *hispgrp; 390 struct session *mysession; 391 392 /* 393 * Check p's parent to see whether p qualifies its own process 394 * group; if so, adjust count for p's process group. 395 */ 396 lwkt_gettoken(&proc_token); 397 mysession = pgrp->pg_session; 398 if ((hispgrp = p->p_pptr->p_pgrp) != pgrp && 399 hispgrp->pg_session == mysession) { 400 if (entering) 401 pgrp->pg_jobc++; 402 else if (--pgrp->pg_jobc == 0) 403 orphanpg(pgrp); 404 } 405 406 /* 407 * Check this process' children to see whether they qualify 408 * their process groups; if so, adjust counts for children's 409 * process groups. 410 */ 411 LIST_FOREACH(p, &p->p_children, p_sibling) { 412 if ((hispgrp = p->p_pgrp) != pgrp && 413 hispgrp->pg_session == mysession && 414 p->p_stat != SZOMB) { 415 if (entering) 416 hispgrp->pg_jobc++; 417 else if (--hispgrp->pg_jobc == 0) 418 orphanpg(hispgrp); 419 } 420 } 421 lwkt_reltoken(&proc_token); 422 } 423 424 /* 425 * A process group has become orphaned; 426 * if there are any stopped processes in the group, 427 * hang-up all process in that group. 428 * 429 * The caller must hold proc_token. 430 */ 431 static void 432 orphanpg(struct pgrp *pg) 433 { 434 struct proc *p; 435 436 LIST_FOREACH(p, &pg->pg_members, p_pglist) { 437 if (p->p_stat == SSTOP) { 438 LIST_FOREACH(p, &pg->pg_members, p_pglist) { 439 ksignal(p, SIGHUP); 440 ksignal(p, SIGCONT); 441 } 442 return; 443 } 444 } 445 } 446 447 /* 448 * Add a new process to the allproc list and the PID hash. This 449 * also assigns a pid to the new process. 450 * 451 * No requirements. 452 */ 453 void 454 proc_add_allproc(struct proc *p) 455 { 456 int random_offset; 457 458 if ((random_offset = randompid) != 0) { 459 get_mplock(); 460 random_offset = karc4random() % random_offset; 461 rel_mplock(); 462 } 463 464 lwkt_gettoken(&proc_token); 465 p->p_pid = proc_getnewpid_locked(random_offset); 466 LIST_INSERT_HEAD(&allproc, p, p_list); 467 LIST_INSERT_HEAD(PIDHASH(p->p_pid), p, p_hash); 468 lwkt_reltoken(&proc_token); 469 } 470 471 /* 472 * Calculate a new process pid. This function is integrated into 473 * proc_add_allproc() to guarentee that the new pid is not reused before 474 * the new process can be added to the allproc list. 475 * 476 * The caller must hold proc_token. 477 */ 478 static 479 pid_t 480 proc_getnewpid_locked(int random_offset) 481 { 482 static pid_t nextpid; 483 static pid_t pidchecked; 484 struct proc *p; 485 486 /* 487 * Find an unused process ID. We remember a range of unused IDs 488 * ready to use (from nextpid+1 through pidchecked-1). 489 */ 490 nextpid = nextpid + 1 + random_offset; 491 retry: 492 /* 493 * If the process ID prototype has wrapped around, 494 * restart somewhat above 0, as the low-numbered procs 495 * tend to include daemons that don't exit. 496 */ 497 if (nextpid >= PID_MAX) { 498 nextpid = nextpid % PID_MAX; 499 if (nextpid < 100) 500 nextpid += 100; 501 pidchecked = 0; 502 } 503 if (nextpid >= pidchecked) { 504 int doingzomb = 0; 505 506 pidchecked = PID_MAX; 507 /* 508 * Scan the active and zombie procs to check whether this pid 509 * is in use. Remember the lowest pid that's greater 510 * than nextpid, so we can avoid checking for a while. 511 */ 512 p = LIST_FIRST(&allproc); 513 again: 514 for (; p != 0; p = LIST_NEXT(p, p_list)) { 515 while (p->p_pid == nextpid || 516 p->p_pgrp->pg_id == nextpid || 517 p->p_session->s_sid == nextpid) { 518 nextpid++; 519 if (nextpid >= pidchecked) 520 goto retry; 521 } 522 if (p->p_pid > nextpid && pidchecked > p->p_pid) 523 pidchecked = p->p_pid; 524 if (p->p_pgrp->pg_id > nextpid && 525 pidchecked > p->p_pgrp->pg_id) 526 pidchecked = p->p_pgrp->pg_id; 527 if (p->p_session->s_sid > nextpid && 528 pidchecked > p->p_session->s_sid) 529 pidchecked = p->p_session->s_sid; 530 } 531 if (!doingzomb) { 532 doingzomb = 1; 533 p = LIST_FIRST(&zombproc); 534 goto again; 535 } 536 } 537 return(nextpid); 538 } 539 540 /* 541 * Called from exit1 to remove a process from the allproc 542 * list and move it to the zombie list. 543 * 544 * No requirements. 545 */ 546 void 547 proc_move_allproc_zombie(struct proc *p) 548 { 549 lwkt_gettoken(&proc_token); 550 while (p->p_lock) { 551 tsleep(p, 0, "reap1", hz / 10); 552 } 553 LIST_REMOVE(p, p_list); 554 LIST_INSERT_HEAD(&zombproc, p, p_list); 555 LIST_REMOVE(p, p_hash); 556 p->p_stat = SZOMB; 557 lwkt_reltoken(&proc_token); 558 dsched_exit_proc(p); 559 } 560 561 /* 562 * This routine is called from kern_wait() and will remove the process 563 * from the zombie list and the sibling list. This routine will block 564 * if someone has a lock on the proces (p_lock). 565 * 566 * No requirements. 567 */ 568 void 569 proc_remove_zombie(struct proc *p) 570 { 571 lwkt_gettoken(&proc_token); 572 while (p->p_lock) { 573 tsleep(p, 0, "reap1", hz / 10); 574 } 575 LIST_REMOVE(p, p_list); /* off zombproc */ 576 LIST_REMOVE(p, p_sibling); 577 lwkt_reltoken(&proc_token); 578 } 579 580 /* 581 * Scan all processes on the allproc list. The process is automatically 582 * held for the callback. A return value of -1 terminates the loop. 583 * 584 * No requirements. 585 * The callback is made with the process held and proc_token held. 586 */ 587 void 588 allproc_scan(int (*callback)(struct proc *, void *), void *data) 589 { 590 struct proc *p; 591 int r; 592 593 lwkt_gettoken(&proc_token); 594 LIST_FOREACH(p, &allproc, p_list) { 595 PHOLD(p); 596 r = callback(p, data); 597 PRELE(p); 598 if (r < 0) 599 break; 600 } 601 lwkt_reltoken(&proc_token); 602 } 603 604 /* 605 * Scan all lwps of processes on the allproc list. The lwp is automatically 606 * held for the callback. A return value of -1 terminates the loop. 607 * 608 * No requirements. 609 * The callback is made with the proces and lwp both held, and proc_token held. 610 */ 611 void 612 alllwp_scan(int (*callback)(struct lwp *, void *), void *data) 613 { 614 struct proc *p; 615 struct lwp *lp; 616 int r = 0; 617 618 lwkt_gettoken(&proc_token); 619 LIST_FOREACH(p, &allproc, p_list) { 620 PHOLD(p); 621 FOREACH_LWP_IN_PROC(lp, p) { 622 LWPHOLD(lp); 623 r = callback(lp, data); 624 LWPRELE(lp); 625 } 626 PRELE(p); 627 if (r < 0) 628 break; 629 } 630 lwkt_reltoken(&proc_token); 631 } 632 633 /* 634 * Scan all processes on the zombproc list. The process is automatically 635 * held for the callback. A return value of -1 terminates the loop. 636 * 637 * No requirements. 638 * The callback is made with the proces held and proc_token held. 639 */ 640 void 641 zombproc_scan(int (*callback)(struct proc *, void *), void *data) 642 { 643 struct proc *p; 644 int r; 645 646 lwkt_gettoken(&proc_token); 647 LIST_FOREACH(p, &zombproc, p_list) { 648 PHOLD(p); 649 r = callback(p, data); 650 PRELE(p); 651 if (r < 0) 652 break; 653 } 654 lwkt_reltoken(&proc_token); 655 } 656 657 #include "opt_ddb.h" 658 #ifdef DDB 659 #include <ddb/ddb.h> 660 661 /* 662 * Debugging only 663 */ 664 DB_SHOW_COMMAND(pgrpdump, pgrpdump) 665 { 666 struct pgrp *pgrp; 667 struct proc *p; 668 int i; 669 670 for (i = 0; i <= pgrphash; i++) { 671 if (!LIST_EMPTY(&pgrphashtbl[i])) { 672 kprintf("\tindx %d\n", i); 673 LIST_FOREACH(pgrp, &pgrphashtbl[i], pg_hash) { 674 kprintf( 675 "\tpgrp %p, pgid %ld, sess %p, sesscnt %d, mem %p\n", 676 (void *)pgrp, (long)pgrp->pg_id, 677 (void *)pgrp->pg_session, 678 pgrp->pg_session->s_count, 679 (void *)LIST_FIRST(&pgrp->pg_members)); 680 LIST_FOREACH(p, &pgrp->pg_members, p_pglist) { 681 kprintf("\t\tpid %ld addr %p pgrp %p\n", 682 (long)p->p_pid, (void *)p, 683 (void *)p->p_pgrp); 684 } 685 } 686 } 687 } 688 } 689 #endif /* DDB */ 690 691 /* 692 * Locate a process on the zombie list. Return a process or NULL. 693 * 694 * The caller must hold proc_token if a stable result is desired. 695 * No other requirements. 696 */ 697 struct proc * 698 zpfind(pid_t pid) 699 { 700 struct proc *p; 701 702 lwkt_gettoken(&proc_token); 703 LIST_FOREACH(p, &zombproc, p_list) { 704 if (p->p_pid == pid) { 705 lwkt_reltoken(&proc_token); 706 return (p); 707 } 708 } 709 lwkt_reltoken(&proc_token); 710 return (NULL); 711 } 712 713 /* 714 * The caller must hold proc_token. 715 */ 716 static int 717 sysctl_out_proc(struct proc *p, struct sysctl_req *req, int flags) 718 { 719 struct kinfo_proc ki; 720 struct lwp *lp; 721 int skp = 0, had_output = 0; 722 int error; 723 724 bzero(&ki, sizeof(ki)); 725 fill_kinfo_proc(p, &ki); 726 if ((flags & KERN_PROC_FLAG_LWP) == 0) 727 skp = 1; 728 error = 0; 729 FOREACH_LWP_IN_PROC(lp, p) { 730 LWPHOLD(lp); 731 fill_kinfo_lwp(lp, &ki.kp_lwp); 732 had_output = 1; 733 error = SYSCTL_OUT(req, &ki, sizeof(ki)); 734 LWPRELE(lp); 735 if (error) 736 break; 737 if (skp) 738 break; 739 } 740 /* We need to output at least the proc, even if there is no lwp. */ 741 if (had_output == 0) { 742 error = SYSCTL_OUT(req, &ki, sizeof(ki)); 743 } 744 return (error); 745 } 746 747 /* 748 * The caller must hold proc_token. 749 */ 750 static int 751 sysctl_out_proc_kthread(struct thread *td, struct sysctl_req *req, int flags) 752 { 753 struct kinfo_proc ki; 754 int error; 755 756 fill_kinfo_proc_kthread(td, &ki); 757 error = SYSCTL_OUT(req, &ki, sizeof(ki)); 758 if (error) 759 return error; 760 return(0); 761 } 762 763 /* 764 * No requirements. 765 */ 766 static int 767 sysctl_kern_proc(SYSCTL_HANDLER_ARGS) 768 { 769 int *name = (int*) arg1; 770 int oid = oidp->oid_number; 771 u_int namelen = arg2; 772 struct proc *p; 773 struct proclist *plist; 774 struct thread *td; 775 int doingzomb, flags = 0; 776 int error = 0; 777 int n; 778 int origcpu; 779 struct ucred *cr1 = curproc->p_ucred; 780 781 flags = oid & KERN_PROC_FLAGMASK; 782 oid &= ~KERN_PROC_FLAGMASK; 783 784 if ((oid == KERN_PROC_ALL && namelen != 0) || 785 (oid != KERN_PROC_ALL && namelen != 1)) 786 return (EINVAL); 787 788 lwkt_gettoken(&proc_token); 789 if (oid == KERN_PROC_PID) { 790 p = pfind((pid_t)name[0]); 791 if (p == NULL) 792 goto post_threads; 793 if (!PRISON_CHECK(cr1, p->p_ucred)) 794 goto post_threads; 795 PHOLD(p); 796 error = sysctl_out_proc(p, req, flags); 797 PRELE(p); 798 goto post_threads; 799 } 800 801 if (!req->oldptr) { 802 /* overestimate by 5 procs */ 803 error = SYSCTL_OUT(req, 0, sizeof (struct kinfo_proc) * 5); 804 if (error) 805 goto post_threads; 806 } 807 for (doingzomb = 0; doingzomb <= 1; doingzomb++) { 808 if (doingzomb) 809 plist = &zombproc; 810 else 811 plist = &allproc; 812 LIST_FOREACH(p, plist, p_list) { 813 /* 814 * Show a user only their processes. 815 */ 816 if ((!ps_showallprocs) && p_trespass(cr1, p->p_ucred)) 817 continue; 818 /* 819 * Skip embryonic processes. 820 */ 821 if (p->p_stat == SIDL) 822 continue; 823 /* 824 * TODO - make more efficient (see notes below). 825 * do by session. 826 */ 827 switch (oid) { 828 case KERN_PROC_PGRP: 829 /* could do this by traversing pgrp */ 830 if (p->p_pgrp == NULL || 831 p->p_pgrp->pg_id != (pid_t)name[0]) 832 continue; 833 break; 834 835 case KERN_PROC_TTY: 836 if ((p->p_flag & P_CONTROLT) == 0 || 837 p->p_session == NULL || 838 p->p_session->s_ttyp == NULL || 839 dev2udev(p->p_session->s_ttyp->t_dev) != 840 (udev_t)name[0]) 841 continue; 842 break; 843 844 case KERN_PROC_UID: 845 if (p->p_ucred == NULL || 846 p->p_ucred->cr_uid != (uid_t)name[0]) 847 continue; 848 break; 849 850 case KERN_PROC_RUID: 851 if (p->p_ucred == NULL || 852 p->p_ucred->cr_ruid != (uid_t)name[0]) 853 continue; 854 break; 855 } 856 857 if (!PRISON_CHECK(cr1, p->p_ucred)) 858 continue; 859 PHOLD(p); 860 error = sysctl_out_proc(p, req, flags); 861 PRELE(p); 862 if (error) 863 goto post_threads; 864 } 865 } 866 867 /* 868 * Iterate over all active cpus and scan their thread list. Start 869 * with the next logical cpu and end with our original cpu. We 870 * migrate our own thread to each target cpu in order to safely scan 871 * its thread list. In the last loop we migrate back to our original 872 * cpu. 873 */ 874 origcpu = mycpu->gd_cpuid; 875 if (!ps_showallthreads || jailed(cr1)) 876 goto post_threads; 877 878 for (n = 1; n <= ncpus; ++n) { 879 globaldata_t rgd; 880 int nid; 881 882 nid = (origcpu + n) % ncpus; 883 if ((smp_active_mask & (1 << nid)) == 0) 884 continue; 885 rgd = globaldata_find(nid); 886 lwkt_setcpu_self(rgd); 887 888 TAILQ_FOREACH(td, &mycpu->gd_tdallq, td_allq) { 889 if (td->td_proc) 890 continue; 891 switch (oid) { 892 case KERN_PROC_PGRP: 893 case KERN_PROC_TTY: 894 case KERN_PROC_UID: 895 case KERN_PROC_RUID: 896 continue; 897 default: 898 break; 899 } 900 lwkt_hold(td); 901 error = sysctl_out_proc_kthread(td, req, doingzomb); 902 lwkt_rele(td); 903 if (error) 904 goto post_threads; 905 } 906 } 907 post_threads: 908 lwkt_reltoken(&proc_token); 909 return (error); 910 } 911 912 /* 913 * This sysctl allows a process to retrieve the argument list or process 914 * title for another process without groping around in the address space 915 * of the other process. It also allow a process to set its own "process 916 * title to a string of its own choice. 917 * 918 * No requirements. 919 */ 920 static int 921 sysctl_kern_proc_args(SYSCTL_HANDLER_ARGS) 922 { 923 int *name = (int*) arg1; 924 u_int namelen = arg2; 925 struct proc *p; 926 struct pargs *pa; 927 int error = 0; 928 struct ucred *cr1 = curproc->p_ucred; 929 930 if (namelen != 1) 931 return (EINVAL); 932 933 lwkt_gettoken(&proc_token); 934 p = pfind((pid_t)name[0]); 935 if (p == NULL) 936 goto done; 937 938 if ((!ps_argsopen) && p_trespass(cr1, p->p_ucred)) 939 goto done; 940 941 if (req->newptr && curproc != p) { 942 error = EPERM; 943 goto done; 944 } 945 946 PHOLD(p); 947 if (req->oldptr && p->p_args != NULL) { 948 error = SYSCTL_OUT(req, p->p_args->ar_args, 949 p->p_args->ar_length); 950 } 951 if (req->newptr == NULL) { 952 PRELE(p); 953 goto done; 954 } 955 956 if (p->p_args && --p->p_args->ar_ref == 0) 957 FREE(p->p_args, M_PARGS); 958 p->p_args = NULL; 959 960 if (req->newlen + sizeof(struct pargs) > ps_arg_cache_limit) { 961 PRELE(p); 962 goto done; 963 } 964 965 MALLOC(pa, struct pargs *, sizeof(struct pargs) + req->newlen, 966 M_PARGS, M_WAITOK); 967 pa->ar_ref = 1; 968 pa->ar_length = req->newlen; 969 error = SYSCTL_IN(req, pa->ar_args, req->newlen); 970 if (!error) 971 p->p_args = pa; 972 else 973 FREE(pa, M_PARGS); 974 PRELE(p); 975 done: 976 lwkt_reltoken(&proc_token); 977 return (error); 978 } 979 980 SYSCTL_NODE(_kern, KERN_PROC, proc, CTLFLAG_RD, 0, "Process table"); 981 982 SYSCTL_PROC(_kern_proc, KERN_PROC_ALL, all, CTLFLAG_RD|CTLTYPE_STRUCT, 983 0, 0, sysctl_kern_proc, "S,proc", "Return entire process table"); 984 985 SYSCTL_NODE(_kern_proc, KERN_PROC_PGRP, pgrp, CTLFLAG_RD, 986 sysctl_kern_proc, "Process table"); 987 988 SYSCTL_NODE(_kern_proc, KERN_PROC_TTY, tty, CTLFLAG_RD, 989 sysctl_kern_proc, "Process table"); 990 991 SYSCTL_NODE(_kern_proc, KERN_PROC_UID, uid, CTLFLAG_RD, 992 sysctl_kern_proc, "Process table"); 993 994 SYSCTL_NODE(_kern_proc, KERN_PROC_RUID, ruid, CTLFLAG_RD, 995 sysctl_kern_proc, "Process table"); 996 997 SYSCTL_NODE(_kern_proc, KERN_PROC_PID, pid, CTLFLAG_RD, 998 sysctl_kern_proc, "Process table"); 999 1000 SYSCTL_NODE(_kern_proc, (KERN_PROC_ALL | KERN_PROC_FLAG_LWP), all_lwp, CTLFLAG_RD, 1001 sysctl_kern_proc, "Process table"); 1002 1003 SYSCTL_NODE(_kern_proc, (KERN_PROC_PGRP | KERN_PROC_FLAG_LWP), pgrp_lwp, CTLFLAG_RD, 1004 sysctl_kern_proc, "Process table"); 1005 1006 SYSCTL_NODE(_kern_proc, (KERN_PROC_TTY | KERN_PROC_FLAG_LWP), tty_lwp, CTLFLAG_RD, 1007 sysctl_kern_proc, "Process table"); 1008 1009 SYSCTL_NODE(_kern_proc, (KERN_PROC_UID | KERN_PROC_FLAG_LWP), uid_lwp, CTLFLAG_RD, 1010 sysctl_kern_proc, "Process table"); 1011 1012 SYSCTL_NODE(_kern_proc, (KERN_PROC_RUID | KERN_PROC_FLAG_LWP), ruid_lwp, CTLFLAG_RD, 1013 sysctl_kern_proc, "Process table"); 1014 1015 SYSCTL_NODE(_kern_proc, (KERN_PROC_PID | KERN_PROC_FLAG_LWP), pid_lwp, CTLFLAG_RD, 1016 sysctl_kern_proc, "Process table"); 1017 1018 SYSCTL_NODE(_kern_proc, KERN_PROC_ARGS, args, CTLFLAG_RW | CTLFLAG_ANYBODY, 1019 sysctl_kern_proc_args, "Process argument list"); 1020