1 /* $OpenBSD: kern_exit.c,v 1.236 2024/10/08 11:57:59 claudio Exp $ */ 2 /* $NetBSD: kern_exit.c,v 1.39 1996/04/22 01:38:25 christos Exp $ */ 3 4 /* 5 * Copyright (c) 1982, 1986, 1989, 1991, 1993 6 * The Regents of the University of California. All rights reserved. 7 * (c) UNIX System Laboratories, Inc. 8 * All or some portions of this file are derived from material licensed 9 * to the University of California by American Telephone and Telegraph 10 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 11 * the permission of UNIX System Laboratories, Inc. 12 * 13 * Redistribution and use in source and binary forms, with or without 14 * modification, are permitted provided that the following conditions 15 * are met: 16 * 1. Redistributions of source code must retain the above copyright 17 * notice, this list of conditions and the following disclaimer. 18 * 2. Redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution. 21 * 3. Neither the name of the University nor the names of its contributors 22 * may be used to endorse or promote products derived from this software 23 * without specific prior written permission. 24 * 25 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 28 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 30 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 31 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 32 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 33 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 34 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 35 * SUCH DAMAGE. 36 * 37 * @(#)kern_exit.c 8.7 (Berkeley) 2/12/94 38 */ 39 40 #include <sys/param.h> 41 #include <sys/systm.h> 42 #include <sys/proc.h> 43 #include <sys/time.h> 44 #include <sys/resource.h> 45 #include <sys/wait.h> 46 #include <sys/vnode.h> 47 #include <sys/malloc.h> 48 #include <sys/resourcevar.h> 49 #include <sys/ptrace.h> 50 #include <sys/acct.h> 51 #include <sys/filedesc.h> 52 #include <sys/signalvar.h> 53 #include <sys/sched.h> 54 #include <sys/ktrace.h> 55 #include <sys/pool.h> 56 #include <sys/mutex.h> 57 #ifdef SYSVSEM 58 #include <sys/sem.h> 59 #endif 60 #include <sys/witness.h> 61 62 #include <sys/mount.h> 63 #include <sys/syscallargs.h> 64 65 #include <uvm/uvm_extern.h> 66 67 #include "kcov.h" 68 #if NKCOV > 0 69 #include <sys/kcov.h> 70 #endif 71 72 void proc_finish_wait(struct proc *, struct process *); 73 void process_clear_orphan(struct process *); 74 void process_zap(struct process *); 75 void proc_free(struct proc *); 76 void unveil_destroy(struct process *ps); 77 78 /* 79 * exit -- 80 * Death of process. 81 */ 82 int 83 sys_exit(struct proc *p, void *v, register_t *retval) 84 { 85 struct sys_exit_args /* { 86 syscallarg(int) rval; 87 } */ *uap = v; 88 89 exit1(p, SCARG(uap, rval), 0, EXIT_NORMAL); 90 /* NOTREACHED */ 91 return (0); 92 } 93 94 int 95 sys___threxit(struct proc *p, void *v, register_t *retval) 96 { 97 struct sys___threxit_args /* { 98 syscallarg(pid_t *) notdead; 99 } */ *uap = v; 100 101 if (SCARG(uap, notdead) != NULL) { 102 pid_t zero = 0; 103 if (copyout(&zero, SCARG(uap, notdead), sizeof(zero))) 104 psignal(p, SIGSEGV); 105 } 106 exit1(p, 0, 0, EXIT_THREAD); 107 108 return (0); 109 } 110 111 /* 112 * Exit: deallocate address space and other resources, change proc state 113 * to zombie, and unlink proc from allproc and parent's lists. Save exit 114 * status and rusage for wait(). Check for child processes and orphan them. 115 */ 116 void 117 exit1(struct proc *p, int xexit, int xsig, int flags) 118 { 119 struct process *pr, *qr, *nqr; 120 struct rusage *rup; 121 122 atomic_setbits_int(&p->p_flag, P_WEXIT); 123 124 pr = p->p_p; 125 126 /* single-threaded? */ 127 if (!P_HASSIBLING(p)) { 128 flags = EXIT_NORMAL; 129 } else { 130 /* nope, multi-threaded */ 131 if (flags == EXIT_NORMAL) 132 single_thread_set(p, SINGLE_EXIT); 133 } 134 135 if (flags == EXIT_NORMAL && !(pr->ps_flags & PS_EXITING)) { 136 if (pr->ps_pid == 1) 137 panic("init died (signal %d, exit %d)", xsig, xexit); 138 139 atomic_setbits_int(&pr->ps_flags, PS_EXITING); 140 pr->ps_xexit = xexit; 141 pr->ps_xsig = xsig; 142 143 /* 144 * If parent is waiting for us to exit or exec, PS_PPWAIT 145 * is set; we wake up the parent early to avoid deadlock. 146 */ 147 if (pr->ps_flags & PS_PPWAIT) { 148 atomic_clearbits_int(&pr->ps_flags, PS_PPWAIT); 149 atomic_clearbits_int(&pr->ps_pptr->ps_flags, 150 PS_ISPWAIT); 151 wakeup(pr->ps_pptr); 152 } 153 154 /* Wait for concurrent `allprocess' loops */ 155 refcnt_finalize(&pr->ps_refcnt, "psdtor"); 156 } 157 158 /* unlink ourselves from the active threads */ 159 mtx_enter(&pr->ps_mtx); 160 TAILQ_REMOVE(&pr->ps_threads, p, p_thr_link); 161 pr->ps_threadcnt--; 162 pr->ps_exitcnt++; 163 164 /* 165 * if somebody else wants to take us to single threaded mode, 166 * count ourselves out. 167 */ 168 if (pr->ps_single) { 169 if (--pr->ps_singlecnt == 0) 170 wakeup(&pr->ps_singlecnt); 171 } 172 173 /* proc is off ps_threads list so update accounting of process now */ 174 tuagg_add_runtime(); 175 tuagg_add_process(p->p_p, p); 176 177 if ((p->p_flag & P_THREAD) == 0) { 178 /* main thread gotta wait because it has the pid, et al */ 179 while (pr->ps_threadcnt + pr->ps_exitcnt > 1) 180 msleep_nsec(&pr->ps_threads, &pr->ps_mtx, PWAIT, 181 "thrdeath", INFSLP); 182 } 183 mtx_leave(&pr->ps_mtx); 184 185 rup = pr->ps_ru; 186 if (rup == NULL) { 187 rup = pool_get(&rusage_pool, PR_WAITOK | PR_ZERO); 188 if (pr->ps_ru == NULL) { 189 pr->ps_ru = rup; 190 } else { 191 pool_put(&rusage_pool, rup); 192 rup = pr->ps_ru; 193 } 194 } 195 p->p_siglist = 0; 196 if ((p->p_flag & P_THREAD) == 0) 197 pr->ps_siglist = 0; 198 199 kqpoll_exit(); 200 201 #if NKCOV > 0 202 kcov_exit(p); 203 #endif 204 205 if ((p->p_flag & P_THREAD) == 0) { 206 if (pr->ps_flags & PS_PROFIL) 207 stopprofclock(pr); 208 209 sigio_freelist(&pr->ps_sigiolst); 210 211 /* close open files and release open-file table */ 212 fdfree(p); 213 214 cancel_all_itimers(); 215 216 timeout_del(&pr->ps_rucheck_to); 217 #ifdef SYSVSEM 218 semexit(pr); 219 #endif 220 killjobc(pr); 221 #ifdef ACCOUNTING 222 acct_process(p); 223 #endif 224 225 #ifdef KTRACE 226 /* release trace file */ 227 if (pr->ps_tracevp) 228 ktrcleartrace(pr); 229 #endif 230 231 unveil_destroy(pr); 232 233 free(pr->ps_pin.pn_pins, M_PINSYSCALL, 234 pr->ps_pin.pn_npins * sizeof(u_int)); 235 free(pr->ps_libcpin.pn_pins, M_PINSYSCALL, 236 pr->ps_libcpin.pn_npins * sizeof(u_int)); 237 238 /* 239 * If parent has the SAS_NOCLDWAIT flag set, we're not 240 * going to become a zombie. 241 */ 242 if (pr->ps_pptr->ps_sigacts->ps_sigflags & SAS_NOCLDWAIT) 243 atomic_setbits_int(&pr->ps_flags, PS_NOZOMBIE); 244 } 245 246 p->p_fd = NULL; /* zap the thread's copy */ 247 248 /* Release the thread's read reference of resource limit structure. */ 249 if (p->p_limit != NULL) { 250 struct plimit *limit; 251 252 limit = p->p_limit; 253 p->p_limit = NULL; 254 lim_free(limit); 255 } 256 257 /* 258 * Remove proc from pidhash chain and allproc so looking 259 * it up won't work. We will put the proc on the 260 * deadproc list later (using the p_hash member), and 261 * wake up the reaper when we do. If this is the last 262 * thread of a process that isn't PS_NOZOMBIE, we'll put 263 * the process on the zombprocess list below. 264 */ 265 /* 266 * NOTE: WE ARE NO LONGER ALLOWED TO SLEEP! 267 */ 268 p->p_stat = SDEAD; 269 270 LIST_REMOVE(p, p_hash); 271 LIST_REMOVE(p, p_list); 272 273 if ((p->p_flag & P_THREAD) == 0) { 274 LIST_REMOVE(pr, ps_hash); 275 LIST_REMOVE(pr, ps_list); 276 277 if ((pr->ps_flags & PS_NOZOMBIE) == 0) 278 LIST_INSERT_HEAD(&zombprocess, pr, ps_list); 279 else { 280 /* 281 * Not going to be a zombie, so it's now off all 282 * the lists scanned by ispidtaken(), so block 283 * fast reuse of the pid now. 284 */ 285 freepid(pr->ps_pid); 286 } 287 288 /* 289 * Reparent children to their original parent, in case 290 * they were being traced, or to init(8). 291 */ 292 qr = LIST_FIRST(&pr->ps_children); 293 if (qr) /* only need this if any child is S_ZOMB */ 294 wakeup(initprocess); 295 for (; qr != NULL; qr = nqr) { 296 nqr = LIST_NEXT(qr, ps_sibling); 297 /* 298 * Traced processes are killed since their 299 * existence means someone is screwing up. 300 */ 301 mtx_enter(&qr->ps_mtx); 302 if (qr->ps_flags & PS_TRACED && 303 !(qr->ps_flags & PS_EXITING)) { 304 process_untrace(qr); 305 mtx_leave(&qr->ps_mtx); 306 307 /* 308 * If single threading is active, 309 * direct the signal to the active 310 * thread to avoid deadlock. 311 */ 312 if (qr->ps_single) 313 ptsignal(qr->ps_single, SIGKILL, 314 STHREAD); 315 else 316 prsignal(qr, SIGKILL); 317 } else { 318 process_reparent(qr, initprocess); 319 mtx_leave(&qr->ps_mtx); 320 } 321 } 322 323 /* 324 * Make sure orphans won't remember the exiting process. 325 */ 326 while ((qr = LIST_FIRST(&pr->ps_orphans)) != NULL) { 327 mtx_enter(&qr->ps_mtx); 328 KASSERT(qr->ps_oppid == pr->ps_pid); 329 qr->ps_oppid = 0; 330 process_clear_orphan(qr); 331 mtx_leave(&qr->ps_mtx); 332 } 333 } 334 335 /* add thread's accumulated rusage into the process's total */ 336 ruadd(rup, &p->p_ru); 337 338 /* 339 * clear %cpu usage during swap 340 */ 341 p->p_pctcpu = 0; 342 343 if ((p->p_flag & P_THREAD) == 0) { 344 /* 345 * Final thread has died, so add on our children's rusage 346 * and calculate the total times. 347 */ 348 calcru(&pr->ps_tu, &rup->ru_utime, &rup->ru_stime, NULL); 349 ruadd(rup, &pr->ps_cru); 350 351 /* 352 * Notify parent that we're gone. If we're not going to 353 * become a zombie, reparent to process 1 (init) so that 354 * we can wake our original parent to possibly unblock 355 * wait4() to return ECHILD. 356 */ 357 mtx_enter(&pr->ps_mtx); 358 if (pr->ps_flags & PS_NOZOMBIE) { 359 struct process *ppr = pr->ps_pptr; 360 process_reparent(pr, initprocess); 361 wakeup(ppr); 362 } 363 mtx_leave(&pr->ps_mtx); 364 } 365 366 /* just a thread? check if last one standing. */ 367 if (p->p_flag & P_THREAD) { 368 /* scheduler_wait_hook(pr->ps_mainproc, p); XXX */ 369 mtx_enter(&pr->ps_mtx); 370 pr->ps_exitcnt--; 371 if (pr->ps_threadcnt + pr->ps_exitcnt == 1) 372 wakeup(&pr->ps_threads); 373 mtx_leave(&pr->ps_mtx); 374 } 375 376 /* 377 * Other substructures are freed from reaper and wait(). 378 */ 379 380 /* 381 * Finally, call machine-dependent code to switch to a new 382 * context (possibly the idle context). Once we are no longer 383 * using the dead process's vmspace and stack, exit2() will be 384 * called to schedule those resources to be released by the 385 * reaper thread. 386 * 387 * Note that cpu_exit() will end with a call equivalent to 388 * cpu_switch(), finishing our execution (pun intended). 389 */ 390 cpu_exit(p); 391 panic("cpu_exit returned"); 392 } 393 394 /* 395 * Locking of this proclist is special; it's accessed in a 396 * critical section of process exit, and thus locking it can't 397 * modify interrupt state. We use a simple spin lock for this 398 * proclist. We use the p_hash member to linkup to deadproc. 399 */ 400 struct mutex deadproc_mutex = 401 MUTEX_INITIALIZER_FLAGS(IPL_NONE, "deadproc", MTX_NOWITNESS); 402 struct proclist deadproc = LIST_HEAD_INITIALIZER(deadproc); 403 404 /* 405 * We are called from sched_idle() once it is safe to schedule the 406 * dead process's resources to be freed. So this is not allowed to sleep. 407 * 408 * We lock the deadproc list, place the proc on that list (using 409 * the p_hash member), and wake up the reaper. 410 */ 411 void 412 exit2(struct proc *p) 413 { 414 /* account the remainder of time spent in exit1() */ 415 mtx_enter(&p->p_p->ps_mtx); 416 tuagg_add_process(p->p_p, p); 417 mtx_leave(&p->p_p->ps_mtx); 418 419 mtx_enter(&deadproc_mutex); 420 LIST_INSERT_HEAD(&deadproc, p, p_hash); 421 mtx_leave(&deadproc_mutex); 422 423 wakeup(&deadproc); 424 } 425 426 void 427 proc_free(struct proc *p) 428 { 429 crfree(p->p_ucred); 430 pool_put(&proc_pool, p); 431 atomic_dec_int(&nthreads); 432 } 433 434 /* 435 * Process reaper. This is run by a kernel thread to free the resources 436 * of a dead process. Once the resources are free, the process becomes 437 * a zombie, and the parent is allowed to read the undead's status. 438 */ 439 void 440 reaper(void *arg) 441 { 442 struct proc *p; 443 444 KERNEL_UNLOCK(); 445 446 SCHED_ASSERT_UNLOCKED(); 447 448 for (;;) { 449 mtx_enter(&deadproc_mutex); 450 while ((p = LIST_FIRST(&deadproc)) == NULL) 451 msleep_nsec(&deadproc, &deadproc_mutex, PVM, "reaper", 452 INFSLP); 453 454 /* Remove us from the deadproc list. */ 455 LIST_REMOVE(p, p_hash); 456 mtx_leave(&deadproc_mutex); 457 458 WITNESS_THREAD_EXIT(p); 459 460 /* 461 * Free the VM resources we're still holding on to. 462 * We must do this from a valid thread because doing 463 * so may block. 464 */ 465 uvm_uarea_free(p); 466 p->p_vmspace = NULL; /* zap the thread's copy */ 467 468 if (p->p_flag & P_THREAD) { 469 /* Just a thread */ 470 proc_free(p); 471 } else { 472 struct process *pr = p->p_p; 473 474 /* Release the rest of the process's vmspace */ 475 uvm_exit(pr); 476 477 KERNEL_LOCK(); 478 if ((pr->ps_flags & PS_NOZOMBIE) == 0) { 479 /* Process is now a true zombie. */ 480 atomic_setbits_int(&pr->ps_flags, PS_ZOMBIE); 481 } 482 483 /* Notify listeners of our demise and clean up. */ 484 knote_processexit(pr); 485 486 if (pr->ps_flags & PS_ZOMBIE) { 487 /* Post SIGCHLD and wake up parent. */ 488 prsignal(pr->ps_pptr, SIGCHLD); 489 wakeup(pr->ps_pptr); 490 } else { 491 /* No one will wait for us, just zap it. */ 492 process_zap(pr); 493 } 494 KERNEL_UNLOCK(); 495 } 496 } 497 } 498 499 int 500 dowait6(struct proc *q, idtype_t idtype, id_t id, int *statusp, int options, 501 struct rusage *rusage, siginfo_t *info, register_t *retval) 502 { 503 int nfound; 504 struct process *pr; 505 struct proc *p; 506 int error; 507 508 if (info != NULL) 509 memset(info, 0, sizeof(*info)); 510 511 loop: 512 nfound = 0; 513 LIST_FOREACH(pr, &q->p_p->ps_children, ps_sibling) { 514 if ((pr->ps_flags & PS_NOZOMBIE) || 515 (idtype == P_PID && id != pr->ps_pid) || 516 (idtype == P_PGID && id != pr->ps_pgid)) 517 continue; 518 519 p = pr->ps_mainproc; 520 521 nfound++; 522 if ((options & WEXITED) && (pr->ps_flags & PS_ZOMBIE)) { 523 *retval = pr->ps_pid; 524 if (info != NULL) { 525 info->si_pid = pr->ps_pid; 526 info->si_uid = pr->ps_ucred->cr_uid; 527 info->si_signo = SIGCHLD; 528 if (pr->ps_xsig == 0) { 529 info->si_code = CLD_EXITED; 530 info->si_status = pr->ps_xexit; 531 } else if (WCOREDUMP(pr->ps_xsig)) { 532 info->si_code = CLD_DUMPED; 533 info->si_status = _WSTATUS(pr->ps_xsig); 534 } else { 535 info->si_code = CLD_KILLED; 536 info->si_status = _WSTATUS(pr->ps_xsig); 537 } 538 } 539 540 if (statusp != NULL) 541 *statusp = W_EXITCODE(pr->ps_xexit, 542 pr->ps_xsig); 543 if (rusage != NULL) 544 memcpy(rusage, pr->ps_ru, sizeof(*rusage)); 545 if ((options & WNOWAIT) == 0) 546 proc_finish_wait(q, pr); 547 return (0); 548 } 549 if ((options & WTRAPPED) && 550 (pr->ps_flags & PS_TRACED) && 551 (pr->ps_flags & PS_WAITED) == 0 && pr->ps_single && 552 pr->ps_single->p_stat == SSTOP) { 553 if (single_thread_wait(pr, 0)) 554 goto loop; 555 556 if ((options & WNOWAIT) == 0) 557 atomic_setbits_int(&pr->ps_flags, PS_WAITED); 558 559 *retval = pr->ps_pid; 560 if (info != NULL) { 561 info->si_pid = pr->ps_pid; 562 info->si_uid = pr->ps_ucred->cr_uid; 563 info->si_signo = SIGCHLD; 564 info->si_code = CLD_TRAPPED; 565 info->si_status = pr->ps_xsig; 566 } 567 568 if (statusp != NULL) 569 *statusp = W_STOPCODE(pr->ps_xsig); 570 if (rusage != NULL) 571 memset(rusage, 0, sizeof(*rusage)); 572 return (0); 573 } 574 if (p->p_stat == SSTOP && 575 (pr->ps_flags & PS_WAITED) == 0 && 576 (p->p_flag & P_SUSPSINGLE) == 0 && 577 ((pr->ps_flags & PS_TRACED) || 578 (options & WUNTRACED))) { 579 if ((options & WNOWAIT) == 0) 580 atomic_setbits_int(&pr->ps_flags, PS_WAITED); 581 582 *retval = pr->ps_pid; 583 if (info != 0) { 584 info->si_pid = pr->ps_pid; 585 info->si_uid = pr->ps_ucred->cr_uid; 586 info->si_signo = SIGCHLD; 587 info->si_code = CLD_STOPPED; 588 info->si_status = pr->ps_xsig; 589 } 590 591 if (statusp != NULL) 592 *statusp = W_STOPCODE(pr->ps_xsig); 593 if (rusage != NULL) 594 memset(rusage, 0, sizeof(*rusage)); 595 return (0); 596 } 597 if ((options & WCONTINUED) && (pr->ps_flags & PS_CONTINUED)) { 598 if ((options & WNOWAIT) == 0) 599 atomic_clearbits_int(&pr->ps_flags, 600 PS_CONTINUED); 601 602 *retval = pr->ps_pid; 603 if (info != NULL) { 604 info->si_pid = pr->ps_pid; 605 info->si_uid = pr->ps_ucred->cr_uid; 606 info->si_signo = SIGCHLD; 607 info->si_code = CLD_CONTINUED; 608 info->si_status = SIGCONT; 609 } 610 611 if (statusp != NULL) 612 *statusp = _WCONTINUED; 613 if (rusage != NULL) 614 memset(rusage, 0, sizeof(*rusage)); 615 return (0); 616 } 617 } 618 /* 619 * Look in the orphans list too, to allow the parent to 620 * collect its child's exit status even if child is being 621 * debugged. 622 * 623 * Debugger detaches from the parent upon successful 624 * switch-over from parent to child. At this point due to 625 * re-parenting the parent loses the child to debugger and a 626 * wait4(2) call would report that it has no children to wait 627 * for. By maintaining a list of orphans we allow the parent 628 * to successfully wait until the child becomes a zombie. 629 */ 630 if (nfound == 0) { 631 LIST_FOREACH(pr, &q->p_p->ps_orphans, ps_orphan) { 632 if ((pr->ps_flags & PS_NOZOMBIE) || 633 (idtype == P_PID && id != pr->ps_pid) || 634 (idtype == P_PGID && id != pr->ps_pgid)) 635 continue; 636 nfound++; 637 break; 638 } 639 } 640 if (nfound == 0) 641 return (ECHILD); 642 if (options & WNOHANG) { 643 *retval = 0; 644 return (0); 645 } 646 if ((error = tsleep_nsec(q->p_p, PWAIT | PCATCH, "wait", INFSLP)) != 0) 647 return (error); 648 goto loop; 649 } 650 651 int 652 sys_wait4(struct proc *q, void *v, register_t *retval) 653 { 654 struct sys_wait4_args /* { 655 syscallarg(pid_t) pid; 656 syscallarg(int *) status; 657 syscallarg(int) options; 658 syscallarg(struct rusage *) rusage; 659 } */ *uap = v; 660 struct rusage ru; 661 pid_t pid = SCARG(uap, pid); 662 int options = SCARG(uap, options); 663 int status, error; 664 idtype_t idtype; 665 id_t id; 666 667 if (SCARG(uap, options) &~ (WUNTRACED|WNOHANG|WCONTINUED)) 668 return (EINVAL); 669 options |= WEXITED | WTRAPPED; 670 671 if (SCARG(uap, pid) == WAIT_MYPGRP) { 672 idtype = P_PGID; 673 id = q->p_p->ps_pgid; 674 } else if (SCARG(uap, pid) == WAIT_ANY) { 675 idtype = P_ALL; 676 id = 0; 677 } else if (pid < 0) { 678 idtype = P_PGID; 679 id = -pid; 680 } else { 681 idtype = P_PID; 682 id = pid; 683 } 684 685 error = dowait6(q, idtype, id, 686 SCARG(uap, status) ? &status : NULL, options, 687 SCARG(uap, rusage) ? &ru : NULL, NULL, retval); 688 if (error == 0 && *retval > 0 && SCARG(uap, status)) { 689 error = copyout(&status, SCARG(uap, status), sizeof(status)); 690 } 691 if (error == 0 && *retval > 0 && SCARG(uap, rusage)) { 692 error = copyout(&ru, SCARG(uap, rusage), sizeof(ru)); 693 #ifdef KTRACE 694 if (error == 0 && KTRPOINT(q, KTR_STRUCT)) 695 ktrrusage(q, &ru); 696 #endif 697 } 698 return (error); 699 } 700 701 int 702 sys_waitid(struct proc *q, void *v, register_t *retval) 703 { 704 struct sys_waitid_args /* { 705 syscallarg(idtype_t) idtype; 706 syscallarg(id_t) id; 707 syscallarg(siginfo_t) info; 708 syscallarg(int) options; 709 } */ *uap = v; 710 siginfo_t info; 711 idtype_t idtype = SCARG(uap, idtype); 712 int options = SCARG(uap, options); 713 int error; 714 715 if (options &~ (WSTOPPED|WCONTINUED|WEXITED|WTRAPPED|WNOHANG|WNOWAIT)) 716 return (EINVAL); 717 if ((options & (WSTOPPED|WCONTINUED|WEXITED|WTRAPPED)) == 0) 718 return (EINVAL); 719 if (idtype != P_ALL && idtype != P_PID && idtype != P_PGID) 720 return (EINVAL); 721 722 error = dowait6(q, idtype, SCARG(uap, id), NULL, 723 options, NULL, &info, retval); 724 if (error == 0) { 725 error = copyout(&info, SCARG(uap, info), sizeof(info)); 726 #ifdef KTRACE 727 if (error == 0 && KTRPOINT(q, KTR_STRUCT)) 728 ktrsiginfo(q, &info); 729 #endif 730 } 731 if (error == 0) 732 *retval = 0; 733 return (error); 734 } 735 736 void 737 proc_finish_wait(struct proc *waiter, struct process *pr) 738 { 739 struct process *tr; 740 struct rusage *rup; 741 742 /* 743 * If we got the child via a ptrace 'attach', 744 * we need to give it back to the old parent. 745 */ 746 mtx_enter(&pr->ps_mtx); 747 if (pr->ps_oppid != 0 && (pr->ps_oppid != pr->ps_ppid) && 748 (tr = prfind(pr->ps_oppid))) { 749 pr->ps_oppid = 0; 750 atomic_clearbits_int(&pr->ps_flags, PS_TRACED); 751 process_reparent(pr, tr); 752 mtx_leave(&pr->ps_mtx); 753 prsignal(tr, SIGCHLD); 754 wakeup(tr); 755 } else { 756 mtx_leave(&pr->ps_mtx); 757 scheduler_wait_hook(waiter, pr->ps_mainproc); 758 rup = &waiter->p_p->ps_cru; 759 ruadd(rup, pr->ps_ru); 760 LIST_REMOVE(pr, ps_list); /* off zombprocess */ 761 freepid(pr->ps_pid); 762 process_zap(pr); 763 } 764 } 765 766 /* 767 * give process back to original parent or init(8) 768 */ 769 void 770 process_untrace(struct process *pr) 771 { 772 struct process *ppr = NULL; 773 774 KASSERT(pr->ps_flags & PS_TRACED); 775 MUTEX_ASSERT_LOCKED(&pr->ps_mtx); 776 777 if (pr->ps_oppid != 0 && 778 (pr->ps_oppid != pr->ps_ppid)) 779 ppr = prfind(pr->ps_oppid); 780 781 /* not being traced any more */ 782 pr->ps_oppid = 0; 783 atomic_clearbits_int(&pr->ps_flags, PS_TRACED); 784 process_reparent(pr, ppr ? ppr : initprocess); 785 } 786 787 void 788 process_clear_orphan(struct process *pr) 789 { 790 if (pr->ps_flags & PS_ORPHAN) { 791 LIST_REMOVE(pr, ps_orphan); 792 atomic_clearbits_int(&pr->ps_flags, PS_ORPHAN); 793 } 794 } 795 796 /* 797 * make process 'parent' the new parent of process 'child'. 798 */ 799 void 800 process_reparent(struct process *child, struct process *parent) 801 { 802 803 if (child->ps_pptr == parent) 804 return; 805 806 KASSERT(child->ps_oppid == 0 || 807 child->ps_oppid == child->ps_ppid); 808 809 LIST_REMOVE(child, ps_sibling); 810 LIST_INSERT_HEAD(&parent->ps_children, child, ps_sibling); 811 812 process_clear_orphan(child); 813 if (child->ps_flags & PS_TRACED) { 814 atomic_setbits_int(&child->ps_flags, PS_ORPHAN); 815 LIST_INSERT_HEAD(&child->ps_pptr->ps_orphans, child, ps_orphan); 816 } 817 818 MUTEX_ASSERT_LOCKED(&child->ps_mtx); 819 child->ps_pptr = parent; 820 child->ps_ppid = parent->ps_pid; 821 } 822 823 void 824 process_zap(struct process *pr) 825 { 826 struct vnode *otvp; 827 struct proc *p = pr->ps_mainproc; 828 829 /* 830 * Finally finished with old proc entry. 831 * Unlink it from its process group and free it. 832 */ 833 leavepgrp(pr); 834 LIST_REMOVE(pr, ps_sibling); 835 process_clear_orphan(pr); 836 837 /* 838 * Decrement the count of procs running with this uid. 839 */ 840 (void)chgproccnt(pr->ps_ucred->cr_ruid, -1); 841 842 /* 843 * Release reference to text vnode 844 */ 845 otvp = pr->ps_textvp; 846 pr->ps_textvp = NULL; 847 if (otvp) 848 vrele(otvp); 849 850 KASSERT(pr->ps_threadcnt == 0); 851 KASSERT(pr->ps_exitcnt == 1); 852 if (pr->ps_ptstat != NULL) 853 free(pr->ps_ptstat, M_SUBPROC, sizeof(*pr->ps_ptstat)); 854 pool_put(&rusage_pool, pr->ps_ru); 855 KASSERT(TAILQ_EMPTY(&pr->ps_threads)); 856 sigactsfree(pr->ps_sigacts); 857 lim_free(pr->ps_limit); 858 crfree(pr->ps_ucred); 859 pool_put(&process_pool, pr); 860 nprocesses--; 861 862 proc_free(p); 863 } 864