1 /* $NetBSD: kern_exit.c,v 1.193 2007/11/12 23:11:59 ad Exp $ */ 2 3 /*- 4 * Copyright (c) 1998, 1999, 2006, 2007 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility, 9 * NASA Ames Research Center, and by Andrew Doran. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. All advertising materials mentioning features or use of this software 20 * must display the following acknowledgement: 21 * This product includes software developed by the NetBSD 22 * Foundation, Inc. and its contributors. 23 * 4. Neither the name of The NetBSD Foundation nor the names of its 24 * contributors may be used to endorse or promote products derived 25 * from this software without specific prior written permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 * POSSIBILITY OF SUCH DAMAGE. 38 */ 39 40 /* 41 * Copyright (c) 1982, 1986, 1989, 1991, 1993 42 * The Regents of the University of California. All rights reserved. 43 * (c) UNIX System Laboratories, Inc. 44 * All or some portions of this file are derived from material licensed 45 * to the University of California by American Telephone and Telegraph 46 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 47 * the permission of UNIX System Laboratories, Inc. 48 * 49 * Redistribution and use in source and binary forms, with or without 50 * modification, are permitted provided that the following conditions 51 * are met: 52 * 1. Redistributions of source code must retain the above copyright 53 * notice, this list of conditions and the following disclaimer. 54 * 2. Redistributions in binary form must reproduce the above copyright 55 * notice, this list of conditions and the following disclaimer in the 56 * documentation and/or other materials provided with the distribution. 57 * 3. Neither the name of the University nor the names of its contributors 58 * may be used to endorse or promote products derived from this software 59 * without specific prior written permission. 60 * 61 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 62 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 63 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 64 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 65 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 66 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 67 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 68 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 69 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 70 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 71 * SUCH DAMAGE. 72 * 73 * @(#)kern_exit.c 8.10 (Berkeley) 2/23/95 74 */ 75 76 #include <sys/cdefs.h> 77 __KERNEL_RCSID(0, "$NetBSD: kern_exit.c,v 1.193 2007/11/12 23:11:59 ad Exp $"); 78 79 #include "opt_ktrace.h" 80 #include "opt_perfctrs.h" 81 #include "opt_systrace.h" 82 #include "opt_sysv.h" 83 84 #include <sys/param.h> 85 #include <sys/aio.h> 86 #include <sys/systm.h> 87 #include <sys/ioctl.h> 88 #include <sys/tty.h> 89 #include <sys/time.h> 90 #include <sys/resource.h> 91 #include <sys/kernel.h> 92 #include <sys/proc.h> 93 #include <sys/buf.h> 94 #include <sys/wait.h> 95 #include <sys/file.h> 96 #include <sys/vnode.h> 97 #include <sys/syslog.h> 98 #include <sys/malloc.h> 99 #include <sys/pool.h> 100 #include <sys/resourcevar.h> 101 #if defined(PERFCTRS) 102 #include <sys/pmc.h> 103 #endif 104 #include <sys/ptrace.h> 105 #include <sys/acct.h> 106 #include <sys/filedesc.h> 107 #include <sys/ras.h> 108 #include <sys/signalvar.h> 109 #include <sys/sched.h> 110 #include <sys/mount.h> 111 #include <sys/syscallargs.h> 112 #include <sys/systrace.h> 113 #include <sys/kauth.h> 114 #include <sys/sleepq.h> 115 #include <sys/lockdebug.h> 116 #include <sys/ktrace.h> 117 #include <sys/cpu.h> 118 #include <sys/lwpctl.h> 119 120 #include <uvm/uvm_extern.h> 121 122 #define DEBUG_EXIT 123 124 #ifdef DEBUG_EXIT 125 int debug_exit = 0; 126 #define DPRINTF(x) if (debug_exit) printf x 127 #else 128 #define DPRINTF(x) 129 #endif 130 131 static int find_stopped_child(struct proc *, pid_t, int, struct proc **, int *); 132 static void proc_free(struct proc *, struct rusage *); 133 134 /* 135 * Fill in the appropriate signal information, and signal the parent. 136 */ 137 static void 138 exit_psignal(struct proc *p, struct proc *pp, ksiginfo_t *ksi) 139 { 140 141 KSI_INIT(ksi); 142 if ((ksi->ksi_signo = P_EXITSIG(p)) == SIGCHLD) { 143 if (WIFSIGNALED(p->p_xstat)) { 144 if (WCOREDUMP(p->p_xstat)) 145 ksi->ksi_code = CLD_DUMPED; 146 else 147 ksi->ksi_code = CLD_KILLED; 148 } else { 149 ksi->ksi_code = CLD_EXITED; 150 } 151 } 152 /* 153 * We fill those in, even for non-SIGCHLD. 154 * It's safe to access p->p_cred unlocked here. 155 */ 156 ksi->ksi_pid = p->p_pid; 157 ksi->ksi_uid = kauth_cred_geteuid(p->p_cred); 158 ksi->ksi_status = p->p_xstat; 159 /* XXX: is this still valid? */ 160 ksi->ksi_utime = p->p_stats->p_ru.ru_utime.tv_sec; 161 ksi->ksi_stime = p->p_stats->p_ru.ru_stime.tv_sec; 162 } 163 164 /* 165 * exit -- 166 * Death of process. 167 */ 168 int 169 sys_exit(struct lwp *l, void *v, register_t *retval) 170 { 171 struct sys_exit_args /* { 172 syscallarg(int) rval; 173 } */ *uap = v; 174 struct proc *p = l->l_proc; 175 176 /* Don't call exit1() multiple times in the same process. */ 177 mutex_enter(&p->p_smutex); 178 if (p->p_sflag & PS_WEXIT) { 179 mutex_exit(&p->p_smutex); 180 lwp_exit(l); 181 } 182 183 /* exit1() will release the mutex. */ 184 exit1(l, W_EXITCODE(SCARG(uap, rval), 0)); 185 /* NOTREACHED */ 186 return (0); 187 } 188 189 /* 190 * Exit: deallocate address space and other resources, change proc state 191 * to zombie, and unlink proc from allproc and parent's lists. Save exit 192 * status and rusage for wait(). Check for child processes and orphan them. 193 * 194 * Must be called with p->p_smutex held. Does not return. 195 */ 196 void 197 exit1(struct lwp *l, int rv) 198 { 199 struct proc *p, *q, *nq; 200 ksiginfo_t ksi; 201 ksiginfoq_t kq; 202 int wakeinit; 203 204 p = l->l_proc; 205 206 KASSERT(mutex_owned(&p->p_smutex)); 207 208 if (__predict_false(p == initproc)) 209 panic("init died (signal %d, exit %d)", 210 WTERMSIG(rv), WEXITSTATUS(rv)); 211 212 p->p_sflag |= PS_WEXIT; 213 214 /* 215 * Force all other LWPs to exit before we do. Only then can we 216 * begin to tear down the rest of the process state. 217 */ 218 if (p->p_nlwps > 1) 219 exit_lwps(l); 220 221 ksiginfo_queue_init(&kq); 222 223 /* 224 * If we have been asked to stop on exit, do so now. 225 */ 226 if (p->p_sflag & PS_STOPEXIT) { 227 KERNEL_UNLOCK_ALL(l, &l->l_biglocks); 228 sigclearall(p, &contsigmask, &kq); 229 p->p_waited = 0; 230 mb_write(); 231 p->p_stat = SSTOP; 232 lwp_lock(l); 233 p->p_nrlwps--; 234 l->l_stat = LSSTOP; 235 mutex_exit(&p->p_smutex); 236 mi_switch(l); 237 KERNEL_LOCK(l->l_biglocks, l); 238 } else 239 mutex_exit(&p->p_smutex); 240 241 /* Destroy any lwpctl info. */ 242 if (p->p_lwpctl != NULL) 243 lwp_ctl_exit(); 244 245 /* Destroy all AIO works */ 246 aio_exit(p, p->p_aio); 247 248 /* 249 * Drain all remaining references that procfs, ptrace and others may 250 * have on the process. 251 */ 252 rw_enter(&p->p_reflock, RW_WRITER); 253 254 /* 255 * Bin any remaining signals and mark the process as dying so it will 256 * not be found for, e.g. signals. 257 */ 258 mutex_enter(&p->p_smutex); 259 sigfillset(&p->p_sigctx.ps_sigignore); 260 sigclearall(p, NULL, &kq); 261 p->p_stat = SDYING; 262 mutex_exit(&p->p_smutex); 263 ksiginfo_queue_drain(&kq); 264 265 DPRINTF(("exit1: %d.%d exiting.\n", p->p_pid, l->l_lid)); 266 267 #ifdef PGINPROF 268 vmsizmon(); 269 #endif 270 timers_free(p, TIMERS_ALL); 271 #if defined(__HAVE_RAS) 272 ras_purgeall(); 273 #endif 274 275 /* 276 * Close open files, release open-file table and free signal 277 * actions. This may block! 278 */ 279 fdfree(l); 280 cwdfree(p->p_cwdi); 281 p->p_cwdi = NULL; 282 doexithooks(p); 283 sigactsfree(p->p_sigacts); 284 285 /* 286 * Write out accounting data. 287 */ 288 (void)acct_process(l); 289 290 #ifdef KTRACE 291 /* 292 * Release trace file. 293 */ 294 if (p->p_tracep != NULL) { 295 mutex_enter(&ktrace_lock); 296 ktrderef(p); 297 mutex_exit(&ktrace_lock); 298 } 299 #endif 300 #ifdef SYSTRACE 301 systrace_sys_exit(p); 302 #endif 303 304 /* 305 * If emulation has process exit hook, call it now. 306 * Set the exit status now so that the exit hook has 307 * an opportunity to tweak it (COMPAT_LINUX requires 308 * this for thread group emulation) 309 */ 310 p->p_xstat = rv; 311 if (p->p_emul->e_proc_exit) 312 (*p->p_emul->e_proc_exit)(p); 313 314 /* Collect child u-areas. */ 315 uvm_uarea_drain(false); 316 317 /* 318 * Free the VM resources we're still holding on to. 319 * We must do this from a valid thread because doing 320 * so may block. This frees vmspace, which we don't 321 * need anymore. The only remaining lwp is the one 322 * we run at this moment, nothing runs in userland 323 * anymore. 324 */ 325 uvm_proc_exit(p); 326 327 /* 328 * While we can still block, and mark the LWP as unswappable to 329 * prevent conflicts with the with the swapper. We also shouldn't 330 * be swapped out, because we are about to exit and will release 331 * memory. 332 */ 333 uvm_lwp_hold(l); 334 335 /* 336 * Stop profiling. 337 */ 338 if ((p->p_stflag & PST_PROFIL) != 0) { 339 mutex_spin_enter(&p->p_stmutex); 340 stopprofclock(p); 341 mutex_spin_exit(&p->p_stmutex); 342 } 343 344 /* 345 * If parent is waiting for us to exit or exec, P_PPWAIT is set; we 346 * wake up the parent early to avoid deadlock. We can do this once 347 * the VM resources are released. 348 */ 349 mutex_enter(&proclist_lock); 350 351 mutex_enter(&p->p_smutex); 352 if (p->p_sflag & PS_PPWAIT) { 353 p->p_sflag &= ~PS_PPWAIT; 354 cv_broadcast(&p->p_pptr->p_waitcv); 355 } 356 mutex_exit(&p->p_smutex); 357 358 if (SESS_LEADER(p)) { 359 struct vnode *vprele = NULL, *vprevoke = NULL; 360 struct session *sp = p->p_session; 361 struct tty *tp; 362 363 if (sp->s_ttyvp) { 364 /* 365 * Controlling process. 366 * Signal foreground pgrp, 367 * drain controlling terminal 368 * and revoke access to controlling terminal. 369 */ 370 tp = sp->s_ttyp; 371 mutex_spin_enter(&tty_lock); 372 if (tp->t_session == sp) { 373 if (tp->t_pgrp) { 374 mutex_enter(&proclist_mutex); 375 pgsignal(tp->t_pgrp, SIGHUP, 1); 376 mutex_exit(&proclist_mutex); 377 } 378 /* we can't guarantee the revoke will do this */ 379 tp->t_pgrp = NULL; 380 tp->t_session = NULL; 381 mutex_spin_exit(&tty_lock); 382 SESSRELE(sp); 383 mutex_exit(&proclist_lock); 384 (void) ttywait(tp); 385 mutex_enter(&proclist_lock); 386 387 /* 388 * The tty could have been revoked 389 * if we blocked. 390 */ 391 vprevoke = sp->s_ttyvp; 392 } else 393 mutex_spin_exit(&tty_lock); 394 vprele = sp->s_ttyvp; 395 sp->s_ttyvp = NULL; 396 /* 397 * s_ttyp is not zero'd; we use this to indicate 398 * that the session once had a controlling terminal. 399 * (for logging and informational purposes) 400 */ 401 } 402 sp->s_leader = NULL; 403 404 if (vprevoke != NULL || vprele != NULL) { 405 mutex_exit(&proclist_lock); 406 if (vprevoke != NULL) 407 VOP_REVOKE(vprevoke, REVOKEALL); 408 if (vprele != NULL) 409 vrele(vprele); 410 mutex_enter(&proclist_lock); 411 } 412 } 413 mutex_enter(&proclist_mutex); 414 fixjobc(p, p->p_pgrp, 0); 415 mutex_exit(&proclist_mutex); 416 417 /* 418 * Finalize the last LWP's specificdata, as well as the 419 * specificdata for the proc itself. 420 */ 421 lwp_finispecific(l); 422 proc_finispecific(p); 423 424 /* 425 * Notify interested parties of our demise. 426 */ 427 KNOTE(&p->p_klist, NOTE_EXIT); 428 429 #if PERFCTRS 430 /* 431 * Save final PMC information in parent process & clean up. 432 */ 433 if (PMC_ENABLED(p)) { 434 pmc_save_context(p); 435 pmc_accumulate(p->p_pptr, p); 436 pmc_process_exit(p); 437 } 438 #endif 439 440 /* 441 * Reset p_opptr pointer of all former children which got 442 * traced by another process and were reparented. We reset 443 * it to NULL here; the trace detach code then reparents 444 * the child to initproc. We only check allproc list, since 445 * eventual former children on zombproc list won't reference 446 * p_opptr anymore. 447 */ 448 if (p->p_slflag & PSL_CHTRACED) { 449 PROCLIST_FOREACH(q, &allproc) { 450 if (q->p_opptr == p) 451 q->p_opptr = NULL; 452 } 453 } 454 455 /* 456 * Give orphaned children to init(8). 457 */ 458 q = LIST_FIRST(&p->p_children); 459 wakeinit = (q != NULL); 460 for (; q != NULL; q = nq) { 461 nq = LIST_NEXT(q, p_sibling); 462 463 /* 464 * Traced processes are killed since their existence 465 * means someone is screwing up. Since we reset the 466 * trace flags, the logic in sys_wait4() would not be 467 * triggered to reparent the process to its 468 * original parent, so we must do this here. 469 */ 470 if (q->p_slflag & PSL_TRACED) { 471 mutex_enter(&p->p_smutex); 472 q->p_slflag &= ~(PSL_TRACED|PSL_FSTRACE|PSL_SYSCALL); 473 mutex_exit(&p->p_smutex); 474 if (q->p_opptr != q->p_pptr) { 475 struct proc *t = q->p_opptr; 476 proc_reparent(q, t ? t : initproc); 477 q->p_opptr = NULL; 478 } else 479 proc_reparent(q, initproc); 480 killproc(q, "orphaned traced process"); 481 } else 482 proc_reparent(q, initproc); 483 } 484 485 /* 486 * Move proc from allproc to zombproc, it's now nearly ready to be 487 * collected by parent. 488 */ 489 mutex_enter(&proclist_mutex); 490 LIST_REMOVE(l, l_list); 491 LIST_REMOVE(p, p_list); 492 LIST_INSERT_HEAD(&zombproc, p, p_list); 493 494 /* 495 * Mark the process as dead. We must do this before we signal 496 * the parent. 497 */ 498 p->p_stat = SDEAD; 499 500 /* Put in front of parent's sibling list for parent to collect it */ 501 q = p->p_pptr; 502 q->p_nstopchild++; 503 if (LIST_FIRST(&q->p_children) != p) { 504 /* Put child where it can be found quickly */ 505 LIST_REMOVE(p, p_sibling); 506 LIST_INSERT_HEAD(&q->p_children, p, p_sibling); 507 } 508 mutex_exit(&proclist_mutex); 509 510 /* 511 * Notify parent that we're gone. If parent has the P_NOCLDWAIT 512 * flag set, notify init instead (and hope it will handle 513 * this situation). 514 */ 515 mutex_enter(&q->p_mutex); 516 if (q->p_flag & (PK_NOCLDWAIT|PK_CLDSIGIGN)) { 517 proc_reparent(p, initproc); 518 wakeinit = 1; 519 520 /* 521 * If this was the last child of our parent, notify 522 * parent, so in case he was wait(2)ing, he will 523 * continue. 524 */ 525 if (LIST_FIRST(&q->p_children) == NULL) 526 cv_broadcast(&q->p_waitcv); 527 } 528 mutex_exit(&q->p_mutex); 529 530 /* Reload parent pointer, since p may have been reparented above */ 531 q = p->p_pptr; 532 533 if ((p->p_slflag & PSL_FSTRACE) == 0 && p->p_exitsig != 0) { 534 exit_psignal(p, q, &ksi); 535 mutex_enter(&proclist_mutex); 536 kpsignal(q, &ksi, NULL); 537 mutex_exit(&proclist_mutex); 538 } 539 540 /* Calculate the final rusage info. */ 541 calcru(p, &p->p_stats->p_ru.ru_utime, &p->p_stats->p_ru.ru_stime, 542 NULL, NULL); 543 544 if (wakeinit) 545 cv_broadcast(&initproc->p_waitcv); 546 547 callout_destroy(&l->l_timeout_ch); 548 549 /* 550 * Remaining lwp resources will be freed in lwp_exit2() once we've 551 * switch to idle context; at that point, we will be marked as a 552 * full blown zombie. 553 * 554 * XXXSMP disable preemption. 555 */ 556 mutex_enter(&p->p_smutex); 557 lwp_drainrefs(l); 558 lwp_lock(l); 559 l->l_prflag &= ~LPR_DETACHED; 560 l->l_stat = LSZOMB; 561 lwp_unlock(l); 562 KASSERT(curlwp == l); 563 KASSERT(p->p_nrlwps == 1); 564 KASSERT(p->p_nlwps == 1); 565 p->p_stat = SZOMB; 566 p->p_nrlwps--; 567 p->p_nzlwps++; 568 p->p_ndlwps = 0; 569 mutex_exit(&p->p_smutex); 570 571 /* 572 * Signal the parent to collect us, and drop the proclist lock. 573 * Drop debugger/procfs lock; no new references can be gained. 574 */ 575 cv_broadcast(&p->p_pptr->p_waitcv); 576 mutex_exit(&proclist_lock); 577 rw_exit(&p->p_reflock); 578 579 /* Verify that we hold no locks other than the kernel lock. */ 580 #ifdef MULTIPROCESSOR 581 LOCKDEBUG_BARRIER(&kernel_lock, 0); 582 #else 583 LOCKDEBUG_BARRIER(NULL, 0); 584 #endif 585 586 /* 587 * NOTE: WE ARE NO LONGER ALLOWED TO SLEEP! 588 */ 589 590 /* 591 * Give machine-dependent code a chance to free any MD LWP 592 * resources. This must be done before uvm_lwp_exit(), in 593 * case these resources are in the PCB. 594 */ 595 #ifndef __NO_CPU_LWP_FREE 596 cpu_lwp_free(l, 1); 597 #endif 598 pmap_deactivate(l); 599 600 /* This process no longer needs to hold the kernel lock. */ 601 #ifdef notyet 602 /* XXXSMP hold in lwp_userret() */ 603 KERNEL_UNLOCK_LAST(l); 604 #else 605 KERNEL_UNLOCK_ALL(l, NULL); 606 #endif 607 608 lwp_exit_switchaway(l); 609 } 610 611 void 612 exit_lwps(struct lwp *l) 613 { 614 struct proc *p; 615 struct lwp *l2; 616 int error; 617 lwpid_t waited; 618 #if defined(MULTIPROCESSOR) 619 int nlocks; 620 #endif 621 622 KERNEL_UNLOCK_ALL(l, &nlocks); 623 624 p = l->l_proc; 625 KASSERT(mutex_owned(&p->p_smutex)); 626 627 retry: 628 /* 629 * Interrupt LWPs in interruptable sleep, unsuspend suspended 630 * LWPs and then wait for everyone else to finish. 631 */ 632 LIST_FOREACH(l2, &p->p_lwps, l_sibling) { 633 if (l2 == l) 634 continue; 635 lwp_lock(l2); 636 l2->l_flag |= LW_WEXIT; 637 if ((l2->l_stat == LSSLEEP && (l2->l_flag & LW_SINTR)) || 638 l2->l_stat == LSSUSPENDED || l2->l_stat == LSSTOP) { 639 /* setrunnable() will release the lock. */ 640 setrunnable(l2); 641 DPRINTF(("exit_lwps: Made %d.%d runnable\n", 642 p->p_pid, l2->l_lid)); 643 continue; 644 } 645 lwp_unlock(l2); 646 } 647 while (p->p_nlwps > 1) { 648 DPRINTF(("exit_lwps: waiting for %d LWPs (%d zombies)\n", 649 p->p_nlwps, p->p_nzlwps)); 650 error = lwp_wait1(l, 0, &waited, LWPWAIT_EXITCONTROL); 651 if (p->p_nlwps == 1) 652 break; 653 if (error == EDEADLK) { 654 /* 655 * LWPs can get suspended/slept behind us. 656 * (eg. sa_setwoken) 657 * kick them again and retry. 658 */ 659 goto retry; 660 } 661 if (error) 662 panic("exit_lwps: lwp_wait1 failed with error %d", 663 error); 664 DPRINTF(("exit_lwps: Got LWP %d from lwp_wait1()\n", waited)); 665 } 666 667 #if defined(MULTIPROCESSOR) 668 if (nlocks > 0) { 669 mutex_exit(&p->p_smutex); 670 KERNEL_LOCK(nlocks, l); 671 mutex_enter(&p->p_smutex); 672 } 673 #endif /* defined(MULTIPROCESSOR) */ 674 KASSERT(p->p_nlwps == 1); 675 } 676 677 int 678 do_sys_wait(struct lwp *l, int *pid, int *status, int options, 679 struct rusage *ru, int *was_zombie) 680 { 681 struct proc *child; 682 int error; 683 684 mutex_enter(&proclist_lock); 685 686 error = find_stopped_child(l->l_proc, *pid, options, &child, status); 687 688 if (child == NULL) { 689 mutex_exit(&proclist_lock); 690 *pid = 0; 691 return error; 692 } 693 694 *pid = child->p_pid; 695 696 if (child->p_stat == SZOMB) { 697 /* proc_free() will release the proclist_lock. */ 698 *was_zombie = 1; 699 if (options & WNOWAIT) 700 mutex_exit(&proclist_lock); 701 else { 702 KERNEL_LOCK(1, l); /* XXXSMP */ 703 proc_free(child, ru); 704 KERNEL_UNLOCK_ONE(l); /* XXXSMP */ 705 } 706 } else { 707 /* Child state must have been SSTOP. */ 708 *was_zombie = 0; 709 mutex_exit(&proclist_lock); 710 *status = W_STOPCODE(*status); 711 } 712 713 return 0; 714 } 715 716 int 717 sys_wait4(struct lwp *l, void *v, register_t *retval) 718 { 719 struct sys_wait4_args /* { 720 syscallarg(int) pid; 721 syscallarg(int *) status; 722 syscallarg(int) options; 723 syscallarg(struct rusage *) rusage; 724 } */ *uap = v; 725 int status, error; 726 int was_zombie; 727 struct rusage ru; 728 729 error = do_sys_wait(l, &SCARG(uap, pid), &status, SCARG(uap, options), 730 SCARG(uap, rusage) != NULL ? &ru : NULL, &was_zombie); 731 732 retval[0] = SCARG(uap, pid); 733 if (SCARG(uap, pid) == 0) 734 return error; 735 736 if (SCARG(uap, rusage)) 737 error = copyout(&ru, SCARG(uap, rusage), sizeof(ru)); 738 739 if (error == 0 && SCARG(uap, status)) 740 error = copyout(&status, SCARG(uap, status), sizeof(status)); 741 742 return error; 743 } 744 745 /* 746 * Scan list of child processes for a child process that has stopped or 747 * exited. Used by sys_wait4 and 'compat' equivalents. 748 * 749 * Must be called with the proclist_lock held, and may release 750 * while waiting. 751 */ 752 static int 753 find_stopped_child(struct proc *parent, pid_t pid, int options, 754 struct proc **child_p, int *status_p) 755 { 756 struct proc *child, *dead; 757 int error; 758 759 KASSERT(mutex_owned(&proclist_lock)); 760 761 if (options & ~(WUNTRACED|WNOHANG|WALTSIG|WALLSIG) 762 && !(options & WOPTSCHECKED)) { 763 *child_p = NULL; 764 return EINVAL; 765 } 766 767 if (pid == 0 && !(options & WOPTSCHECKED)) 768 pid = -parent->p_pgid; 769 770 for (;;) { 771 error = ECHILD; 772 dead = NULL; 773 774 mutex_enter(&proclist_mutex); 775 LIST_FOREACH(child, &parent->p_children, p_sibling) { 776 if (pid >= 0) { 777 if (child->p_pid != pid) { 778 child = p_find(pid, PFIND_ZOMBIE | 779 PFIND_LOCKED); 780 if (child == NULL || 781 child->p_pptr != parent) { 782 child = NULL; 783 break; 784 } 785 } 786 } else if (pid != WAIT_ANY && child->p_pgid != -pid) { 787 /* Child not in correct pgrp */ 788 continue; 789 } 790 791 /* 792 * Wait for processes with p_exitsig != SIGCHLD 793 * processes only if WALTSIG is set; wait for 794 * processes with p_exitsig == SIGCHLD only 795 * if WALTSIG is clear. 796 */ 797 if (((options & WALLSIG) == 0) && 798 (options & WALTSIG ? child->p_exitsig == SIGCHLD 799 : P_EXITSIG(child) != SIGCHLD)){ 800 if (child->p_pid == pid) { 801 child = NULL; 802 break; 803 } 804 continue; 805 } 806 807 error = 0; 808 if ((options & WNOZOMBIE) == 0) { 809 if (child->p_stat == SZOMB) 810 break; 811 if (child->p_stat == SDEAD) { 812 /* 813 * We may occasionally arrive here 814 * after receiving a signal, but 815 * immediatley before the child 816 * process is zombified. The wait 817 * will be short, so avoid returning 818 * to userspace. 819 */ 820 dead = child; 821 } 822 } 823 824 if (child->p_stat == SSTOP && 825 child->p_waited == 0 && 826 (child->p_slflag & PSL_TRACED || 827 options & WUNTRACED)) { 828 if ((options & WNOWAIT) == 0) { 829 child->p_waited = 1; 830 parent->p_nstopchild--; 831 } 832 break; 833 } 834 if (parent->p_nstopchild == 0 || child->p_pid == pid) { 835 child = NULL; 836 break; 837 } 838 } 839 840 if (child != NULL || error != 0 || 841 ((options & WNOHANG) != 0 && dead == NULL)) { 842 if (child != NULL) { 843 *status_p = child->p_xstat; 844 } 845 mutex_exit(&proclist_mutex); 846 *child_p = child; 847 return error; 848 } 849 850 /* 851 * Wait for another child process to stop. 852 */ 853 mutex_exit(&proclist_lock); 854 error = cv_wait_sig(&parent->p_waitcv, &proclist_mutex); 855 mutex_exit(&proclist_mutex); 856 mutex_enter(&proclist_lock); 857 858 if (error != 0) { 859 *child_p = NULL; 860 return error; 861 } 862 } 863 } 864 865 /* 866 * Free a process after parent has taken all the state info. Must be called 867 * with the proclist lock held, and will release before returning. 868 * 869 * *ru is returned to the caller, and must be freed by the caller. 870 */ 871 static void 872 proc_free(struct proc *p, struct rusage *ru) 873 { 874 struct proc *parent; 875 struct lwp *l; 876 ksiginfo_t ksi; 877 kauth_cred_t cred1, cred2; 878 uid_t uid; 879 880 KASSERT(mutex_owned(&proclist_lock)); 881 KASSERT(p->p_nlwps == 1); 882 KASSERT(p->p_nzlwps == 1); 883 KASSERT(p->p_nrlwps == 0); 884 KASSERT(p->p_stat == SZOMB); 885 886 /* 887 * If we got the child via ptrace(2) or procfs, and 888 * the parent is different (meaning the process was 889 * attached, rather than run as a child), then we need 890 * to give it back to the old parent, and send the 891 * parent the exit signal. The rest of the cleanup 892 * will be done when the old parent waits on the child. 893 */ 894 if ((p->p_slflag & PSL_TRACED) != 0) { 895 parent = p->p_pptr; 896 if (p->p_opptr != parent){ 897 mutex_enter(&p->p_smutex); 898 p->p_slflag &= ~(PSL_TRACED|PSL_FSTRACE|PSL_SYSCALL); 899 mutex_exit(&p->p_smutex); 900 parent = p->p_opptr; 901 if (parent == NULL) 902 parent = initproc; 903 proc_reparent(p, parent); 904 p->p_opptr = NULL; 905 if (p->p_exitsig != 0) { 906 exit_psignal(p, parent, &ksi); 907 mutex_enter(&proclist_mutex); 908 kpsignal(parent, &ksi, NULL); 909 mutex_exit(&proclist_mutex); 910 } 911 cv_broadcast(&parent->p_waitcv); 912 mutex_exit(&proclist_lock); 913 return; 914 } 915 } 916 917 /* 918 * Finally finished with old proc entry. Unlink it from its process 919 * group. 920 */ 921 leavepgrp(p); 922 923 parent = p->p_pptr; 924 sched_proc_exit(parent, p); 925 /* 926 * Add child times of exiting process onto its own times. 927 * This cannot be done any earlier else it might get done twice. 928 */ 929 ruadd(&p->p_stats->p_ru, &p->p_stats->p_cru); 930 ruadd(&parent->p_stats->p_cru, &p->p_stats->p_ru); 931 if (ru != NULL) 932 *ru = p->p_stats->p_ru; 933 p->p_xstat = 0; 934 935 /* 936 * At this point we are going to start freeing the final resources. 937 * If anyone tries to access the proc structure after here they will 938 * get a shock - bits are missing. Attempt to make it hard! We 939 * don't bother with any further locking past this point. 940 */ 941 mutex_enter(&proclist_mutex); 942 p->p_stat = SIDL; /* not even a zombie any more */ 943 LIST_REMOVE(p, p_list); /* off zombproc */ 944 parent = p->p_pptr; 945 p->p_pptr->p_nstopchild--; 946 mutex_exit(&proclist_mutex); 947 LIST_REMOVE(p, p_sibling); 948 949 /* 950 * Let pid be reallocated. 951 */ 952 proc_free_pid(p); 953 mutex_exit(&proclist_lock); 954 955 l = LIST_FIRST(&p->p_lwps); 956 957 /* 958 * Delay release until after lwp_free. 959 */ 960 cred2 = l->l_cred; 961 962 /* 963 * Free the last LWP's resources. 964 * 965 * lwp_free ensures the LWP is no longer running on another CPU. 966 */ 967 lwp_free(l, false, true); 968 969 /* 970 * Now no one except us can reach the process p. 971 */ 972 973 /* 974 * Decrement the count of procs running with this uid. 975 */ 976 cred1 = p->p_cred; 977 uid = kauth_cred_getuid(cred1); 978 (void)chgproccnt(uid, -1); 979 980 /* 981 * Release substructures. 982 */ 983 984 limfree(p->p_limit); 985 pstatsfree(p->p_stats); 986 kauth_cred_free(cred1); 987 kauth_cred_free(cred2); 988 989 /* 990 * Release reference to text vnode 991 */ 992 if (p->p_textvp) 993 vrele(p->p_textvp); 994 995 mutex_destroy(&p->p_raslock); 996 mutex_destroy(&p->p_mutex); 997 mutex_destroy(&p->p_stmutex); 998 mutex_destroy(&p->p_smutex); 999 cv_destroy(&p->p_waitcv); 1000 cv_destroy(&p->p_lwpcv); 1001 rw_destroy(&p->p_reflock); 1002 1003 pool_put(&proc_pool, p); 1004 1005 /* 1006 * Collect child u-areas. 1007 */ 1008 uvm_uarea_drain(false); 1009 } 1010 1011 /* 1012 * make process 'parent' the new parent of process 'child'. 1013 * 1014 * Must be called with proclist_lock lock held. 1015 */ 1016 void 1017 proc_reparent(struct proc *child, struct proc *parent) 1018 { 1019 1020 KASSERT(mutex_owned(&proclist_lock)); 1021 1022 if (child->p_pptr == parent) 1023 return; 1024 1025 mutex_enter(&proclist_mutex); 1026 if (child->p_stat == SZOMB || 1027 (child->p_stat == SSTOP && !child->p_waited)) { 1028 child->p_pptr->p_nstopchild--; 1029 parent->p_nstopchild++; 1030 } 1031 mutex_exit(&proclist_mutex); 1032 if (parent == initproc) 1033 child->p_exitsig = SIGCHLD; 1034 1035 LIST_REMOVE(child, p_sibling); 1036 LIST_INSERT_HEAD(&parent->p_children, child, p_sibling); 1037 child->p_pptr = parent; 1038 } 1039