1 /* 2 * Copyright (c) 1982, 1986, 1989, 1991, 1993 3 * The Regents of the University of California. All rights reserved. 4 * (c) UNIX System Laboratories, Inc. 5 * All or some portions of this file are derived from material licensed 6 * to the University of California by American Telephone and Telegraph 7 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 8 * the permission of UNIX System Laboratories, Inc. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the University of 21 * California, Berkeley and its contributors. 22 * 4. Neither the name of the University nor the names of its contributors 23 * may be used to endorse or promote products derived from this software 24 * without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 29 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 36 * SUCH DAMAGE. 37 * 38 * @(#)kern_exit.c 8.7 (Berkeley) 2/12/94 39 * $FreeBSD: src/sys/kern/kern_exit.c,v 1.92.2.11 2003/01/13 22:51:16 dillon Exp $ 40 * $DragonFly: src/sys/kern/kern_exit.c,v 1.91 2008/05/18 20:02:02 nth Exp $ 41 */ 42 43 #include "opt_compat.h" 44 #include "opt_ktrace.h" 45 46 #include <sys/param.h> 47 #include <sys/systm.h> 48 #include <sys/sysproto.h> 49 #include <sys/kernel.h> 50 #include <sys/malloc.h> 51 #include <sys/proc.h> 52 #include <sys/ktrace.h> 53 #include <sys/pioctl.h> 54 #include <sys/tty.h> 55 #include <sys/wait.h> 56 #include <sys/vnode.h> 57 #include <sys/resourcevar.h> 58 #include <sys/signalvar.h> 59 #include <sys/taskqueue.h> 60 #include <sys/ptrace.h> 61 #include <sys/acct.h> /* for acct_process() function prototype */ 62 #include <sys/filedesc.h> 63 #include <sys/shm.h> 64 #include <sys/sem.h> 65 #include <sys/jail.h> 66 #include <sys/kern_syscall.h> 67 #include <sys/upcall.h> 68 #include <sys/caps.h> 69 #include <sys/unistd.h> 70 #include <sys/eventhandler.h> 71 #include <sys/dsched.h> 72 73 #include <vm/vm.h> 74 #include <vm/vm_param.h> 75 #include <sys/lock.h> 76 #include <vm/pmap.h> 77 #include <vm/vm_map.h> 78 #include <vm/vm_extern.h> 79 #include <sys/user.h> 80 81 #include <sys/refcount.h> 82 #include <sys/thread2.h> 83 #include <sys/sysref2.h> 84 #include <sys/mplock2.h> 85 86 static void reaplwps(void *context, int dummy); 87 static void reaplwp(struct lwp *lp); 88 static void killlwps(struct lwp *lp); 89 90 static MALLOC_DEFINE(M_ATEXIT, "atexit", "atexit callback"); 91 static MALLOC_DEFINE(M_ZOMBIE, "zombie", "zombie proc status"); 92 93 static struct lwkt_token deadlwp_token = LWKT_TOKEN_INITIALIZER(deadlwp_token); 94 95 /* 96 * callout list for things to do at exit time 97 */ 98 struct exitlist { 99 exitlist_fn function; 100 TAILQ_ENTRY(exitlist) next; 101 }; 102 103 TAILQ_HEAD(exit_list_head, exitlist); 104 static struct exit_list_head exit_list = TAILQ_HEAD_INITIALIZER(exit_list); 105 106 /* 107 * LWP reaper data 108 */ 109 struct task *deadlwp_task[MAXCPU]; 110 struct lwplist deadlwp_list[MAXCPU]; 111 112 /* 113 * exit -- 114 * Death of process. 115 * 116 * SYS_EXIT_ARGS(int rval) 117 */ 118 int 119 sys_exit(struct exit_args *uap) 120 { 121 exit1(W_EXITCODE(uap->rval, 0)); 122 /* NOTREACHED */ 123 } 124 125 /* 126 * Extended exit -- 127 * Death of a lwp or process with optional bells and whistles. 128 * 129 * MPALMOSTSAFE 130 */ 131 int 132 sys_extexit(struct extexit_args *uap) 133 { 134 struct proc *p = curproc; 135 int action, who; 136 int error; 137 138 action = EXTEXIT_ACTION(uap->how); 139 who = EXTEXIT_WHO(uap->how); 140 141 /* Check parameters before we might perform some action */ 142 switch (who) { 143 case EXTEXIT_PROC: 144 case EXTEXIT_LWP: 145 break; 146 default: 147 return (EINVAL); 148 } 149 150 switch (action) { 151 case EXTEXIT_SIMPLE: 152 break; 153 case EXTEXIT_SETINT: 154 error = copyout(&uap->status, uap->addr, sizeof(uap->status)); 155 if (error) 156 return (error); 157 break; 158 default: 159 return (EINVAL); 160 } 161 162 lwkt_gettoken(&p->p_token); 163 164 switch (who) { 165 case EXTEXIT_LWP: 166 /* 167 * Be sure only to perform a simple lwp exit if there is at 168 * least one more lwp in the proc, which will call exit1() 169 * later, otherwise the proc will be an UNDEAD and not even a 170 * SZOMB! 171 */ 172 if (p->p_nthreads > 1) { 173 lwp_exit(0); /* called w/ p_token held */ 174 /* NOT REACHED */ 175 } 176 /* else last lwp in proc: do the real thing */ 177 /* FALLTHROUGH */ 178 default: /* to help gcc */ 179 case EXTEXIT_PROC: 180 lwkt_reltoken(&p->p_token); 181 exit1(W_EXITCODE(uap->status, 0)); 182 /* NOTREACHED */ 183 } 184 185 /* NOTREACHED */ 186 lwkt_reltoken(&p->p_token); /* safety */ 187 } 188 189 /* 190 * Kill all lwps associated with the current process except the 191 * current lwp. Return an error if we race another thread trying to 192 * do the same thing and lose the race. 193 * 194 * If forexec is non-zero the current thread and process flags are 195 * cleaned up so they can be reused. 196 * 197 * Caller must hold curproc->p_token 198 */ 199 int 200 killalllwps(int forexec) 201 { 202 struct lwp *lp = curthread->td_lwp; 203 struct proc *p = lp->lwp_proc; 204 205 /* 206 * Interlock against P_WEXIT. Only one of the process's thread 207 * is allowed to do the master exit. 208 */ 209 if (p->p_flags & P_WEXIT) 210 return (EALREADY); 211 p->p_flags |= P_WEXIT; 212 213 /* 214 * Interlock with LWP_MP_WEXIT and kill any remaining LWPs 215 */ 216 atomic_set_int(&lp->lwp_mpflags, LWP_MP_WEXIT); 217 if (p->p_nthreads > 1) 218 killlwps(lp); 219 220 /* 221 * If doing this for an exec, clean up the remaining thread 222 * (us) for continuing operation after all the other threads 223 * have been killed. 224 */ 225 if (forexec) { 226 atomic_clear_int(&lp->lwp_mpflags, LWP_MP_WEXIT); 227 p->p_flags &= ~P_WEXIT; 228 } 229 return(0); 230 } 231 232 /* 233 * Kill all LWPs except the current one. Do not try to signal 234 * LWPs which have exited on their own or have already been 235 * signaled. 236 */ 237 static void 238 killlwps(struct lwp *lp) 239 { 240 struct proc *p = lp->lwp_proc; 241 struct lwp *tlp; 242 243 /* 244 * Kill the remaining LWPs. We must send the signal before setting 245 * LWP_MP_WEXIT. The setting of WEXIT is optional but helps reduce 246 * races. tlp must be held across the call as it might block and 247 * allow the target lwp to rip itself out from under our loop. 248 */ 249 FOREACH_LWP_IN_PROC(tlp, p) { 250 LWPHOLD(tlp); 251 lwkt_gettoken(&tlp->lwp_token); 252 if ((tlp->lwp_mpflags & LWP_MP_WEXIT) == 0) { 253 lwpsignal(p, tlp, SIGKILL); 254 atomic_set_int(&tlp->lwp_mpflags, LWP_MP_WEXIT); 255 } 256 lwkt_reltoken(&tlp->lwp_token); 257 LWPRELE(tlp); 258 } 259 260 /* 261 * Wait for everything to clear out. 262 */ 263 while (p->p_nthreads > 1) { 264 tsleep(&p->p_nthreads, 0, "killlwps", 0); 265 } 266 } 267 268 /* 269 * Exit: deallocate address space and other resources, change proc state 270 * to zombie, and unlink proc from allproc and parent's lists. Save exit 271 * status and rusage for wait(). Check for child processes and orphan them. 272 */ 273 void 274 exit1(int rv) 275 { 276 struct thread *td = curthread; 277 struct proc *p = td->td_proc; 278 struct lwp *lp = td->td_lwp; 279 struct proc *q, *nq; 280 struct vmspace *vm; 281 struct vnode *vtmp; 282 struct exitlist *ep; 283 int error; 284 285 lwkt_gettoken(&p->p_token); 286 287 if (p->p_pid == 1) { 288 kprintf("init died (signal %d, exit %d)\n", 289 WTERMSIG(rv), WEXITSTATUS(rv)); 290 panic("Going nowhere without my init!"); 291 } 292 varsymset_clean(&p->p_varsymset); 293 lockuninit(&p->p_varsymset.vx_lock); 294 295 /* 296 * Kill all lwps associated with the current process, return an 297 * error if we race another thread trying to do the same thing 298 * and lose the race. 299 */ 300 error = killalllwps(0); 301 if (error) { 302 lwp_exit(0); 303 /* NOT REACHED */ 304 } 305 306 caps_exit(lp->lwp_thread); 307 308 /* are we a task leader? */ 309 if (p == p->p_leader) { 310 struct kill_args killArgs; 311 killArgs.signum = SIGKILL; 312 q = p->p_peers; 313 while(q) { 314 killArgs.pid = q->p_pid; 315 /* 316 * The interface for kill is better 317 * than the internal signal 318 */ 319 sys_kill(&killArgs); 320 nq = q; 321 q = q->p_peers; 322 } 323 while (p->p_peers) 324 tsleep((caddr_t)p, 0, "exit1", 0); 325 } 326 327 #ifdef PGINPROF 328 vmsizmon(); 329 #endif 330 STOPEVENT(p, S_EXIT, rv); 331 wakeup(&p->p_stype); /* Wakeup anyone in procfs' PIOCWAIT */ 332 333 /* 334 * Check if any loadable modules need anything done at process exit. 335 * e.g. SYSV IPC stuff 336 * XXX what if one of these generates an error? 337 */ 338 p->p_xstat = rv; 339 EVENTHANDLER_INVOKE(process_exit, p); 340 341 /* 342 * XXX: imho, the eventhandler stuff is much cleaner than this. 343 * Maybe we should move everything to use eventhandler. 344 */ 345 TAILQ_FOREACH(ep, &exit_list, next) 346 (*ep->function)(td); 347 348 if (p->p_flags & P_PROFIL) 349 stopprofclock(p); 350 351 SIGEMPTYSET(p->p_siglist); 352 SIGEMPTYSET(lp->lwp_siglist); 353 if (timevalisset(&p->p_realtimer.it_value)) 354 callout_stop_sync(&p->p_ithandle); 355 356 /* 357 * Reset any sigio structures pointing to us as a result of 358 * F_SETOWN with our pid. 359 */ 360 funsetownlst(&p->p_sigiolst); 361 362 /* 363 * Close open files and release open-file table. 364 * This may block! 365 */ 366 fdfree(p, NULL); 367 368 if(p->p_leader->p_peers) { 369 q = p->p_leader; 370 while(q->p_peers != p) 371 q = q->p_peers; 372 q->p_peers = p->p_peers; 373 wakeup((caddr_t)p->p_leader); 374 } 375 376 /* 377 * XXX Shutdown SYSV semaphores 378 */ 379 semexit(p); 380 381 KKASSERT(p->p_numposixlocks == 0); 382 383 /* The next two chunks should probably be moved to vmspace_exit. */ 384 vm = p->p_vmspace; 385 386 /* 387 * Release upcalls associated with this process 388 */ 389 if (vm->vm_upcalls) 390 upc_release(vm, lp); 391 392 /* 393 * Clean up data related to virtual kernel operation. Clean up 394 * any vkernel context related to the current lwp now so we can 395 * destroy p_vkernel. 396 */ 397 if (p->p_vkernel) { 398 vkernel_lwp_exit(lp); 399 vkernel_exit(p); 400 } 401 402 /* 403 * Release user portion of address space. 404 * This releases references to vnodes, 405 * which could cause I/O if the file has been unlinked. 406 * Need to do this early enough that we can still sleep. 407 * Can't free the entire vmspace as the kernel stack 408 * may be mapped within that space also. 409 * 410 * Processes sharing the same vmspace may exit in one order, and 411 * get cleaned up by vmspace_exit() in a different order. The 412 * last exiting process to reach this point releases as much of 413 * the environment as it can, and the last process cleaned up 414 * by vmspace_exit() (which decrements exitingcnt) cleans up the 415 * remainder. 416 */ 417 vmspace_exitbump(vm); 418 sysref_put(&vm->vm_sysref); 419 420 if (SESS_LEADER(p)) { 421 struct session *sp = p->p_session; 422 423 if (sp->s_ttyvp) { 424 /* 425 * We are the controlling process. Signal the 426 * foreground process group, drain the controlling 427 * terminal, and revoke access to the controlling 428 * terminal. 429 * 430 * NOTE: while waiting for the process group to exit 431 * it is possible that one of the processes in the 432 * group will revoke the tty, so the ttyclosesession() 433 * function will re-check sp->s_ttyvp. 434 */ 435 if (sp->s_ttyp && (sp->s_ttyp->t_session == sp)) { 436 if (sp->s_ttyp->t_pgrp) 437 pgsignal(sp->s_ttyp->t_pgrp, SIGHUP, 1); 438 ttywait(sp->s_ttyp); 439 ttyclosesession(sp, 1); /* also revoke */ 440 } 441 /* 442 * Release the tty. If someone has it open via 443 * /dev/tty then close it (since they no longer can 444 * once we've NULL'd it out). 445 */ 446 ttyclosesession(sp, 0); 447 448 /* 449 * s_ttyp is not zero'd; we use this to indicate 450 * that the session once had a controlling terminal. 451 * (for logging and informational purposes) 452 */ 453 } 454 sp->s_leader = NULL; 455 } 456 fixjobc(p, p->p_pgrp, 0); 457 (void)acct_process(p); 458 #ifdef KTRACE 459 /* 460 * release trace file 461 */ 462 if (p->p_tracenode) 463 ktrdestroy(&p->p_tracenode); 464 p->p_traceflag = 0; 465 #endif 466 /* 467 * Release reference to text vnode 468 */ 469 if ((vtmp = p->p_textvp) != NULL) { 470 p->p_textvp = NULL; 471 vrele(vtmp); 472 } 473 474 /* Release namecache handle to text file */ 475 if (p->p_textnch.ncp) 476 cache_drop(&p->p_textnch); 477 478 /* 479 * We have to handle PPWAIT here or proc_move_allproc_zombie() 480 * will block on the PHOLD() the parent is doing. 481 */ 482 if (p->p_flags & P_PPWAIT) { 483 p->p_flags &= ~P_PPWAIT; 484 wakeup(p->p_pptr); 485 } 486 487 /* 488 * Move the process to the zombie list. This will block 489 * until the process p_lock count reaches 0. The process will 490 * not be reaped until TDF_EXITING is set by cpu_thread_exit(), 491 * which is called from cpu_proc_exit(). 492 */ 493 proc_move_allproc_zombie(p); 494 495 /* 496 * Reparent all of this process's children to the init process. 497 * We must hold initproc->p_token in order to mess with 498 * initproc->p_children. We already hold p->p_token (to remove 499 * the children from our list). 500 */ 501 q = LIST_FIRST(&p->p_children); 502 if (q) { 503 lwkt_gettoken(&initproc->p_token); 504 while (q) { 505 nq = LIST_NEXT(q, p_sibling); 506 LIST_REMOVE(q, p_sibling); 507 LIST_INSERT_HEAD(&initproc->p_children, q, p_sibling); 508 q->p_pptr = initproc; 509 q->p_sigparent = SIGCHLD; 510 /* 511 * Traced processes are killed 512 * since their existence means someone is screwing up. 513 */ 514 if (q->p_flags & P_TRACED) { 515 q->p_flags &= ~P_TRACED; 516 ksignal(q, SIGKILL); 517 } 518 q = nq; 519 } 520 lwkt_reltoken(&initproc->p_token); 521 wakeup(initproc); 522 } 523 524 /* 525 * Save exit status and final rusage info, adding in child rusage 526 * info and self times. 527 */ 528 calcru_proc(p, &p->p_ru); 529 ruadd(&p->p_ru, &p->p_cru); 530 531 /* 532 * notify interested parties of our demise. 533 */ 534 KNOTE(&p->p_klist, NOTE_EXIT); 535 536 /* 537 * Notify parent that we're gone. If parent has the PS_NOCLDWAIT 538 * flag set, notify process 1 instead (and hope it will handle 539 * this situation). 540 */ 541 if (p->p_pptr->p_sigacts->ps_flag & PS_NOCLDWAIT) { 542 struct proc *pp = p->p_pptr; 543 544 PHOLD(pp); 545 proc_reparent(p, initproc); 546 547 /* 548 * If this was the last child of our parent, notify 549 * parent, so in case he was wait(2)ing, he will 550 * continue. This function interlocks with pptr->p_token. 551 */ 552 if (LIST_EMPTY(&pp->p_children)) 553 wakeup((caddr_t)pp); 554 PRELE(pp); 555 } 556 557 /* lwkt_gettoken(&proc_token); */ 558 q = p->p_pptr; 559 PHOLD(q); 560 if (p->p_sigparent && q != initproc) { 561 ksignal(q, p->p_sigparent); 562 } else { 563 ksignal(q, SIGCHLD); 564 } 565 566 p->p_flags &= ~P_TRACED; 567 wakeup(p->p_pptr); 568 569 PRELE(q); 570 /* lwkt_reltoken(&proc_token); */ 571 /* NOTE: p->p_pptr can get ripped out */ 572 /* 573 * cpu_exit is responsible for clearing curproc, since 574 * it is heavily integrated with the thread/switching sequence. 575 * 576 * Other substructures are freed from wait(). 577 */ 578 plimit_free(p); 579 580 /* 581 * Release the current user process designation on the process so 582 * the userland scheduler can work in someone else. 583 */ 584 p->p_usched->release_curproc(lp); 585 586 /* 587 * Finally, call machine-dependent code to release as many of the 588 * lwp's resources as we can and halt execution of this thread. 589 */ 590 lwp_exit(1); 591 } 592 593 /* 594 * Eventually called by every exiting LWP 595 * 596 * p->p_token must be held. mplock may be held and will be released. 597 */ 598 void 599 lwp_exit(int masterexit) 600 { 601 struct thread *td = curthread; 602 struct lwp *lp = td->td_lwp; 603 struct proc *p = lp->lwp_proc; 604 int dowake = 0; 605 606 /* 607 * lwp_exit() may be called without setting LWP_MP_WEXIT, so 608 * make sure it is set here. 609 */ 610 ASSERT_LWKT_TOKEN_HELD(&p->p_token); 611 atomic_set_int(&lp->lwp_mpflags, LWP_MP_WEXIT); 612 613 /* 614 * Clean up any virtualization 615 */ 616 if (lp->lwp_vkernel) 617 vkernel_lwp_exit(lp); 618 619 /* 620 * Clean up select/poll support 621 */ 622 kqueue_terminate(&lp->lwp_kqueue); 623 624 /* 625 * Clean up any syscall-cached ucred 626 */ 627 if (td->td_ucred) { 628 crfree(td->td_ucred); 629 td->td_ucred = NULL; 630 } 631 632 /* 633 * Nobody actually wakes us when the lock 634 * count reaches zero, so just wait one tick. 635 */ 636 while (lp->lwp_lock > 0) 637 tsleep(lp, 0, "lwpexit", 1); 638 639 /* Hand down resource usage to our proc */ 640 ruadd(&p->p_ru, &lp->lwp_ru); 641 642 /* 643 * If we don't hold the process until the LWP is reaped wait*() 644 * may try to dispose of its vmspace before all the LWPs have 645 * actually terminated. 646 */ 647 PHOLD(p); 648 649 /* 650 * Do any remaining work that might block on us. We should be 651 * coded such that further blocking is ok after decrementing 652 * p_nthreads but don't take the chance. 653 */ 654 dsched_exit_thread(td); 655 biosched_done(curthread); 656 657 /* 658 * We have to use the reaper for all the LWPs except the one doing 659 * the master exit. The LWP doing the master exit can just be 660 * left on p_lwps and the process reaper will deal with it 661 * synchronously, which is much faster. 662 * 663 * Wakeup anyone waiting on p_nthreads to drop to 1 or 0. 664 * 665 * The process is left held until the reaper calls lwp_dispose() on 666 * the lp (after calling lwp_wait()). 667 */ 668 if (masterexit == 0) { 669 lwp_rb_tree_RB_REMOVE(&p->p_lwp_tree, lp); 670 --p->p_nthreads; 671 if (p->p_nthreads <= 1) 672 dowake = 1; 673 lwkt_gettoken(&deadlwp_token); 674 LIST_INSERT_HEAD(&deadlwp_list[mycpuid], lp, u.lwp_reap_entry); 675 taskqueue_enqueue(taskqueue_thread[mycpuid], 676 deadlwp_task[mycpuid]); 677 lwkt_reltoken(&deadlwp_token); 678 } else { 679 --p->p_nthreads; 680 if (p->p_nthreads <= 1) 681 dowake = 1; 682 } 683 684 /* 685 * Release p_token. Issue the wakeup() on p_nthreads if necessary, 686 * as late as possible to give us a chance to actually deschedule and 687 * switch away before another cpu core hits reaplwp(). 688 */ 689 lwkt_reltoken(&p->p_token); 690 if (dowake) 691 wakeup(&p->p_nthreads); 692 cpu_lwp_exit(); 693 } 694 695 /* 696 * Wait until a lwp is completely dead. The final interlock in this drama 697 * is when TDF_EXITING is set in cpu_thread_exit() just before the final 698 * switchout. 699 * 700 * At the point TDF_EXITING is set a complete exit is accomplished when 701 * TDF_RUNNING and TDF_PREEMPT_LOCK are both clear. 702 * 703 * Returns non-zero on success, and zero if the caller needs to retry 704 * the lwp_wait(). 705 */ 706 static int 707 lwp_wait(struct lwp *lp) 708 { 709 struct thread *td = lp->lwp_thread;; 710 711 KKASSERT(lwkt_preempted_proc() != lp); 712 713 /* 714 * Wait until the lp has entered its low level exit and wait 715 * until other cores with refs on the lp (e.g. for ps or signaling) 716 * release them. 717 */ 718 if (lp->lwp_lock > 0) { 719 tsleep(lp, 0, "lwpwait1", 1); 720 return(0); 721 } 722 723 /* 724 * Wait until the thread is no longer references and no longer 725 * runnable or preempted (i.e. finishes its low level exit). 726 */ 727 if (td->td_refs) { 728 tsleep(td, 0, "lwpwait2", 1); 729 return(0); 730 } 731 732 /* 733 * The lwp's thread may still be in the middle 734 * of switching away, we can't rip its stack out from 735 * under it until TDF_EXITING is set and both 736 * TDF_RUNNING and TDF_PREEMPT_LOCK are clear. 737 * TDF_PREEMPT_LOCK must be checked because TDF_RUNNING 738 * will be cleared temporarily if a thread gets 739 * preempted. 740 * 741 * YYY no wakeup occurs, so we simply return failure 742 * and let the caller deal with sleeping and calling 743 * us again. 744 */ 745 if ((td->td_flags & (TDF_RUNNING | 746 TDF_PREEMPT_LOCK | 747 TDF_EXITING)) != TDF_EXITING) { 748 tsleep(lp, 0, "lwpwait2", 1); 749 return (0); 750 } 751 KASSERT((td->td_flags & (TDF_RUNQ|TDF_TSLEEPQ)) == 0, 752 ("lwp_wait: td %p (%s) still on run or sleep queue", 753 td, td->td_comm)); 754 return (1); 755 } 756 757 /* 758 * Release the resources associated with a lwp. 759 * The lwp must be completely dead. 760 */ 761 void 762 lwp_dispose(struct lwp *lp) 763 { 764 struct thread *td = lp->lwp_thread;; 765 766 KKASSERT(lwkt_preempted_proc() != lp); 767 KKASSERT(td->td_refs == 0); 768 KKASSERT((td->td_flags & (TDF_RUNNING | 769 TDF_PREEMPT_LOCK | 770 TDF_EXITING)) == TDF_EXITING); 771 772 PRELE(lp->lwp_proc); 773 lp->lwp_proc = NULL; 774 if (td != NULL) { 775 td->td_proc = NULL; 776 td->td_lwp = NULL; 777 lp->lwp_thread = NULL; 778 lwkt_free_thread(td); 779 } 780 kfree(lp, M_LWP); 781 } 782 783 /* 784 * MPSAFE 785 */ 786 int 787 sys_wait4(struct wait_args *uap) 788 { 789 struct rusage rusage; 790 int error, status; 791 792 error = kern_wait(uap->pid, (uap->status ? &status : NULL), 793 uap->options, (uap->rusage ? &rusage : NULL), 794 &uap->sysmsg_result); 795 796 if (error == 0 && uap->status) 797 error = copyout(&status, uap->status, sizeof(*uap->status)); 798 if (error == 0 && uap->rusage) 799 error = copyout(&rusage, uap->rusage, sizeof(*uap->rusage)); 800 return (error); 801 } 802 803 /* 804 * wait1() 805 * 806 * wait_args(int pid, int *status, int options, struct rusage *rusage) 807 * 808 * MPALMOSTSAFE 809 */ 810 int 811 kern_wait(pid_t pid, int *status, int options, struct rusage *rusage, int *res) 812 { 813 struct thread *td = curthread; 814 struct lwp *lp; 815 struct proc *q = td->td_proc; 816 struct proc *p, *t; 817 struct pargs *pa; 818 struct sigacts *ps; 819 int nfound, error; 820 821 if (pid == 0) 822 pid = -q->p_pgid; 823 if (options &~ (WUNTRACED|WNOHANG|WCONTINUED|WLINUXCLONE)) 824 return (EINVAL); 825 826 lwkt_gettoken(&q->p_token); 827 loop: 828 /* 829 * All sorts of things can change due to blocking so we have to loop 830 * all the way back up here. 831 * 832 * The problem is that if a process group is stopped and the parent 833 * is doing a wait*(..., WUNTRACED, ...), it will see the STOP 834 * of the child and then stop itself when it tries to return from the 835 * system call. When the process group is resumed the parent will 836 * then get the STOP status even though the child has now resumed 837 * (a followup wait*() will get the CONT status). 838 * 839 * Previously the CONT would overwrite the STOP because the tstop 840 * was handled within tsleep(), and the parent would only see 841 * the CONT when both are stopped and continued together. This little 842 * two-line hack restores this effect. 843 */ 844 while (q->p_stat == SSTOP) 845 tstop(); 846 847 nfound = 0; 848 849 /* 850 * Loop on children. 851 * 852 * NOTE: We don't want to break q's p_token in the loop for the 853 * case where no children are found or we risk breaking the 854 * interlock between child and parent. 855 */ 856 LIST_FOREACH(p, &q->p_children, p_sibling) { 857 if (pid != WAIT_ANY && 858 p->p_pid != pid && p->p_pgid != -pid) { 859 continue; 860 } 861 862 /* 863 * This special case handles a kthread spawned by linux_clone 864 * (see linux_misc.c). The linux_wait4 and linux_waitpid 865 * functions need to be able to distinguish between waiting 866 * on a process and waiting on a thread. It is a thread if 867 * p_sigparent is not SIGCHLD, and the WLINUXCLONE option 868 * signifies we want to wait for threads and not processes. 869 */ 870 if ((p->p_sigparent != SIGCHLD) ^ 871 ((options & WLINUXCLONE) != 0)) { 872 continue; 873 } 874 875 nfound++; 876 if (p->p_stat == SZOMB) { 877 /* 878 * We may go into SZOMB with threads still present. 879 * We must wait for them to exit before we can reap 880 * the master thread, otherwise we may race reaping 881 * non-master threads. 882 */ 883 lwkt_gettoken(&p->p_token); 884 while (p->p_nthreads > 0) { 885 tsleep(&p->p_nthreads, 0, "lwpzomb", hz); 886 } 887 888 /* 889 * Reap any LWPs left in p->p_lwps. This is usually 890 * just the last LWP. This must be done before 891 * we loop on p_lock since the lwps hold a ref on 892 * it as a vmspace interlock. 893 * 894 * Once that is accomplished p_nthreads had better 895 * be zero. 896 */ 897 while ((lp = RB_ROOT(&p->p_lwp_tree)) != NULL) { 898 lwp_rb_tree_RB_REMOVE(&p->p_lwp_tree, lp); 899 reaplwp(lp); 900 } 901 KKASSERT(p->p_nthreads == 0); 902 903 /* 904 * Don't do anything really bad until all references 905 * to the process go away. This may include other 906 * LWPs which are still in the process of being 907 * reaped. We can't just pull the rug out from under 908 * them because they may still be using the VM space. 909 * 910 * Certain kernel facilities such as /proc will also 911 * put a hold on the process for short periods of 912 * time. 913 */ 914 PSTALL(p, "reap3", 0); 915 916 /* Take care of our return values. */ 917 *res = p->p_pid; 918 p->p_usched->heuristic_exiting(td->td_lwp, p); 919 920 if (status) 921 *status = p->p_xstat; 922 if (rusage) 923 *rusage = p->p_ru; 924 /* 925 * If we got the child via a ptrace 'attach', 926 * we need to give it back to the old parent. 927 */ 928 if (p->p_oppid && (t = pfind(p->p_oppid)) != NULL) { 929 p->p_oppid = 0; 930 proc_reparent(p, t); 931 ksignal(t, SIGCHLD); 932 wakeup((caddr_t)t); 933 error = 0; 934 PRELE(t); 935 lwkt_reltoken(&p->p_token); 936 goto done; 937 } 938 939 /* 940 * Unlink the proc from its process group so that 941 * the following operations won't lead to an 942 * inconsistent state for processes running down 943 * the zombie list. 944 */ 945 proc_remove_zombie(p); 946 lwkt_reltoken(&p->p_token); 947 leavepgrp(p); 948 949 p->p_xstat = 0; 950 ruadd(&q->p_cru, &p->p_ru); 951 952 /* 953 * Decrement the count of procs running with this uid. 954 */ 955 chgproccnt(p->p_ucred->cr_ruidinfo, -1, 0); 956 957 /* 958 * Free up credentials. 959 */ 960 crfree(p->p_ucred); 961 p->p_ucred = NULL; 962 963 /* 964 * Remove unused arguments 965 */ 966 pa = p->p_args; 967 p->p_args = NULL; 968 if (pa && refcount_release(&pa->ar_ref)) { 969 kfree(pa, M_PARGS); 970 pa = NULL; 971 } 972 973 ps = p->p_sigacts; 974 p->p_sigacts = NULL; 975 if (ps && refcount_release(&ps->ps_refcnt)) { 976 kfree(ps, M_SUBPROC); 977 ps = NULL; 978 } 979 980 /* 981 * Our exitingcount was incremented when the process 982 * became a zombie, now that the process has been 983 * removed from (almost) all lists we should be able 984 * to safely destroy its vmspace. Wait for any current 985 * holders to go away (so the vmspace remains stable), 986 * then scrap it. 987 */ 988 PSTALL(p, "reap4", 0); 989 vmspace_exitfree(p); 990 PSTALL(p, "reap5", 0); 991 992 kfree(p, M_PROC); 993 atomic_add_int(&nprocs, -1); 994 error = 0; 995 goto done; 996 } 997 if (p->p_stat == SSTOP && (p->p_flags & P_WAITED) == 0 && 998 ((p->p_flags & P_TRACED) || (options & WUNTRACED))) { 999 lwkt_gettoken(&p->p_token); 1000 p->p_flags |= P_WAITED; 1001 1002 *res = p->p_pid; 1003 p->p_usched->heuristic_exiting(td->td_lwp, p); 1004 if (status) 1005 *status = W_STOPCODE(p->p_xstat); 1006 /* Zero rusage so we get something consistent. */ 1007 if (rusage) 1008 bzero(rusage, sizeof(rusage)); 1009 error = 0; 1010 lwkt_reltoken(&p->p_token); 1011 goto done; 1012 } 1013 if ((options & WCONTINUED) && (p->p_flags & P_CONTINUED)) { 1014 lwkt_gettoken(&p->p_token); 1015 *res = p->p_pid; 1016 p->p_usched->heuristic_exiting(td->td_lwp, p); 1017 p->p_flags &= ~P_CONTINUED; 1018 1019 if (status) 1020 *status = SIGCONT; 1021 error = 0; 1022 lwkt_reltoken(&p->p_token); 1023 goto done; 1024 } 1025 } 1026 if (nfound == 0) { 1027 error = ECHILD; 1028 goto done; 1029 } 1030 if (options & WNOHANG) { 1031 *res = 0; 1032 error = 0; 1033 goto done; 1034 } 1035 1036 /* 1037 * Wait for signal - interlocked using q->p_token. 1038 */ 1039 error = tsleep(q, PCATCH, "wait", 0); 1040 if (error) { 1041 done: 1042 lwkt_reltoken(&q->p_token); 1043 return (error); 1044 } 1045 goto loop; 1046 } 1047 1048 /* 1049 * Make process 'parent' the new parent of process 'child'. 1050 * 1051 * p_children/p_sibling requires the parent's token, and 1052 * changing pptr requires the child's token, so we have to 1053 * get three tokens to do this operation. 1054 */ 1055 void 1056 proc_reparent(struct proc *child, struct proc *parent) 1057 { 1058 struct proc *opp = child->p_pptr; 1059 1060 if (opp == parent) 1061 return; 1062 PHOLD(opp); 1063 PHOLD(parent); 1064 lwkt_gettoken(&opp->p_token); 1065 lwkt_gettoken(&child->p_token); 1066 lwkt_gettoken(&parent->p_token); 1067 KKASSERT(child->p_pptr == opp); 1068 LIST_REMOVE(child, p_sibling); 1069 LIST_INSERT_HEAD(&parent->p_children, child, p_sibling); 1070 child->p_pptr = parent; 1071 lwkt_reltoken(&parent->p_token); 1072 lwkt_reltoken(&child->p_token); 1073 lwkt_reltoken(&opp->p_token); 1074 PRELE(parent); 1075 PRELE(opp); 1076 } 1077 1078 /* 1079 * The next two functions are to handle adding/deleting items on the 1080 * exit callout list 1081 * 1082 * at_exit(): 1083 * Take the arguments given and put them onto the exit callout list, 1084 * However first make sure that it's not already there. 1085 * returns 0 on success. 1086 */ 1087 1088 int 1089 at_exit(exitlist_fn function) 1090 { 1091 struct exitlist *ep; 1092 1093 #ifdef INVARIANTS 1094 /* Be noisy if the programmer has lost track of things */ 1095 if (rm_at_exit(function)) 1096 kprintf("WARNING: exit callout entry (%p) already present\n", 1097 function); 1098 #endif 1099 ep = kmalloc(sizeof(*ep), M_ATEXIT, M_NOWAIT); 1100 if (ep == NULL) 1101 return (ENOMEM); 1102 ep->function = function; 1103 TAILQ_INSERT_TAIL(&exit_list, ep, next); 1104 return (0); 1105 } 1106 1107 /* 1108 * Scan the exit callout list for the given item and remove it. 1109 * Returns the number of items removed (0 or 1) 1110 */ 1111 int 1112 rm_at_exit(exitlist_fn function) 1113 { 1114 struct exitlist *ep; 1115 1116 TAILQ_FOREACH(ep, &exit_list, next) { 1117 if (ep->function == function) { 1118 TAILQ_REMOVE(&exit_list, ep, next); 1119 kfree(ep, M_ATEXIT); 1120 return(1); 1121 } 1122 } 1123 return (0); 1124 } 1125 1126 /* 1127 * LWP reaper related code. 1128 */ 1129 static void 1130 reaplwps(void *context, int dummy) 1131 { 1132 struct lwplist *lwplist = context; 1133 struct lwp *lp; 1134 1135 lwkt_gettoken(&deadlwp_token); 1136 while ((lp = LIST_FIRST(lwplist))) { 1137 LIST_REMOVE(lp, u.lwp_reap_entry); 1138 reaplwp(lp); 1139 } 1140 lwkt_reltoken(&deadlwp_token); 1141 } 1142 1143 static void 1144 reaplwp(struct lwp *lp) 1145 { 1146 while (lwp_wait(lp) == 0) 1147 ; 1148 lwp_dispose(lp); 1149 } 1150 1151 static void 1152 deadlwp_init(void) 1153 { 1154 int cpu; 1155 1156 for (cpu = 0; cpu < ncpus; cpu++) { 1157 LIST_INIT(&deadlwp_list[cpu]); 1158 deadlwp_task[cpu] = kmalloc(sizeof(*deadlwp_task[cpu]), 1159 M_DEVBUF, M_WAITOK); 1160 TASK_INIT(deadlwp_task[cpu], 0, reaplwps, &deadlwp_list[cpu]); 1161 } 1162 } 1163 1164 SYSINIT(deadlwpinit, SI_SUB_CONFIGURE, SI_ORDER_ANY, deadlwp_init, NULL); 1165