The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/kern/kern_exit.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * SPDX-License-Identifier: BSD-3-Clause
    3  *
    4  * Copyright (c) 1982, 1986, 1989, 1991, 1993
    5  *      The Regents of the University of California.  All rights reserved.
    6  * (c) UNIX System Laboratories, Inc.
    7  * All or some portions of this file are derived from material licensed
    8  * to the University of California by American Telephone and Telegraph
    9  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
   10  * the permission of UNIX System Laboratories, Inc.
   11  *
   12  * Redistribution and use in source and binary forms, with or without
   13  * modification, are permitted provided that the following conditions
   14  * are met:
   15  * 1. Redistributions of source code must retain the above copyright
   16  *    notice, this list of conditions and the following disclaimer.
   17  * 2. Redistributions in binary form must reproduce the above copyright
   18  *    notice, this list of conditions and the following disclaimer in the
   19  *    documentation and/or other materials provided with the distribution.
   20  * 3. Neither the name of the University nor the names of its contributors
   21  *    may be used to endorse or promote products derived from this software
   22  *    without specific prior written permission.
   23  *
   24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   34  * SUCH DAMAGE.
   35  *
   36  *      @(#)kern_exit.c 8.7 (Berkeley) 2/12/94
   37  */
   38 
   39 #include <sys/cdefs.h>
   40 __FBSDID("$FreeBSD$");
   41 
   42 #include "opt_ktrace.h"
   43 
   44 #include <sys/param.h>
   45 #include <sys/systm.h>
   46 #include <sys/sysproto.h>
   47 #include <sys/capsicum.h>
   48 #include <sys/eventhandler.h>
   49 #include <sys/kernel.h>
   50 #include <sys/malloc.h>
   51 #include <sys/lock.h>
   52 #include <sys/mutex.h>
   53 #include <sys/proc.h>
   54 #include <sys/procdesc.h>
   55 #include <sys/pioctl.h>
   56 #include <sys/jail.h>
   57 #include <sys/tty.h>
   58 #include <sys/wait.h>
   59 #include <sys/vmmeter.h>
   60 #include <sys/vnode.h>
   61 #include <sys/racct.h>
   62 #include <sys/resourcevar.h>
   63 #include <sys/sbuf.h>
   64 #include <sys/signalvar.h>
   65 #include <sys/sched.h>
   66 #include <sys/sx.h>
   67 #include <sys/syscallsubr.h>
   68 #include <sys/syslog.h>
   69 #include <sys/ptrace.h>
   70 #include <sys/acct.h>           /* for acct_process() function prototype */
   71 #include <sys/filedesc.h>
   72 #include <sys/sdt.h>
   73 #include <sys/shm.h>
   74 #include <sys/sem.h>
   75 #include <sys/timers.h>
   76 #include <sys/umtx.h>
   77 #ifdef KTRACE
   78 #include <sys/ktrace.h>
   79 #endif
   80 
   81 #include <security/audit/audit.h>
   82 #include <security/mac/mac_framework.h>
   83 
   84 #include <vm/vm.h>
   85 #include <vm/vm_extern.h>
   86 #include <vm/vm_param.h>
   87 #include <vm/pmap.h>
   88 #include <vm/vm_map.h>
   89 #include <vm/vm_page.h>
   90 #include <vm/uma.h>
   91 
   92 #ifdef KDTRACE_HOOKS
   93 #include <sys/dtrace_bsd.h>
   94 dtrace_execexit_func_t  dtrace_fasttrap_exit;
   95 #endif
   96 
   97 SDT_PROVIDER_DECLARE(proc);
   98 SDT_PROBE_DEFINE1(proc, , , exit, "int");
   99 
  100 /* Hook for NFS teardown procedure. */
  101 void (*nlminfo_release_p)(struct proc *p);
  102 
  103 EVENTHANDLER_LIST_DECLARE(process_exit);
  104 
  105 struct proc *
  106 proc_realparent(struct proc *child)
  107 {
  108         struct proc *p, *parent;
  109 
  110         sx_assert(&proctree_lock, SX_LOCKED);
  111         if ((child->p_treeflag & P_TREE_ORPHANED) == 0)
  112                 return (child->p_pptr->p_pid == child->p_oppid ?
  113                     child->p_pptr : child->p_reaper);
  114         for (p = child; (p->p_treeflag & P_TREE_FIRST_ORPHAN) == 0;) {
  115                 /* Cannot use LIST_PREV(), since the list head is not known. */
  116                 p = __containerof(p->p_orphan.le_prev, struct proc,
  117                     p_orphan.le_next);
  118                 KASSERT((p->p_treeflag & P_TREE_ORPHANED) != 0,
  119                     ("missing P_ORPHAN %p", p));
  120         }
  121         parent = __containerof(p->p_orphan.le_prev, struct proc,
  122             p_orphans.lh_first);
  123         return (parent);
  124 }
  125 
  126 void
  127 reaper_abandon_children(struct proc *p, bool exiting)
  128 {
  129         struct proc *p1, *p2, *ptmp;
  130 
  131         sx_assert(&proctree_lock, SX_LOCKED);
  132         KASSERT(p != initproc, ("reaper_abandon_children for initproc"));
  133         if ((p->p_treeflag & P_TREE_REAPER) == 0)
  134                 return;
  135         p1 = p->p_reaper;
  136         LIST_FOREACH_SAFE(p2, &p->p_reaplist, p_reapsibling, ptmp) {
  137                 LIST_REMOVE(p2, p_reapsibling);
  138                 p2->p_reaper = p1;
  139                 p2->p_reapsubtree = p->p_reapsubtree;
  140                 LIST_INSERT_HEAD(&p1->p_reaplist, p2, p_reapsibling);
  141                 if (exiting && p2->p_pptr == p) {
  142                         PROC_LOCK(p2);
  143                         proc_reparent(p2, p1, true);
  144                         PROC_UNLOCK(p2);
  145                 }
  146         }
  147         KASSERT(LIST_EMPTY(&p->p_reaplist), ("p_reaplist not empty"));
  148         p->p_treeflag &= ~P_TREE_REAPER;
  149 }
  150 
  151 void
  152 proc_clear_orphan(struct proc *p)
  153 {
  154         struct proc *p1;
  155 
  156         sx_assert(&proctree_lock, SA_XLOCKED);
  157         if ((p->p_treeflag & P_TREE_ORPHANED) == 0)
  158                 return;
  159         if ((p->p_treeflag & P_TREE_FIRST_ORPHAN) != 0) {
  160                 p1 = LIST_NEXT(p, p_orphan);
  161                 if (p1 != NULL)
  162                         p1->p_treeflag |= P_TREE_FIRST_ORPHAN;
  163                 p->p_treeflag &= ~P_TREE_FIRST_ORPHAN;
  164         }
  165         LIST_REMOVE(p, p_orphan);
  166         p->p_treeflag &= ~P_TREE_ORPHANED;
  167 }
  168 
  169 /*
  170  * exit -- death of process.
  171  */
  172 void
  173 sys_sys_exit(struct thread *td, struct sys_exit_args *uap)
  174 {
  175 
  176         exit1(td, uap->rval, 0);
  177         /* NOTREACHED */
  178 }
  179 
  180 /*
  181  * Exit: deallocate address space and other resources, change proc state to
  182  * zombie, and unlink proc from allproc and parent's lists.  Save exit status
  183  * and rusage for wait().  Check for child processes and orphan them.
  184  */
  185 void
  186 exit1(struct thread *td, int rval, int signo)
  187 {
  188         struct proc *p, *nq, *q, *t;
  189         struct thread *tdt;
  190         ksiginfo_t *ksi, *ksi1;
  191         int signal_parent;
  192 
  193         mtx_assert(&Giant, MA_NOTOWNED);
  194         KASSERT(rval == 0 || signo == 0, ("exit1 rv %d sig %d", rval, signo));
  195 
  196         p = td->td_proc;
  197         /*
  198          * XXX in case we're rebooting we just let init die in order to
  199          * work around an unsolved stack overflow seen very late during
  200          * shutdown on sparc64 when the gmirror worker process exists.
  201          */
  202         if (p == initproc && rebooting == 0) {
  203                 printf("init died (signal %d, exit %d)\n", signo, rval);
  204                 panic("Going nowhere without my init!");
  205         }
  206 
  207         /*
  208          * Deref SU mp, since the thread does not return to userspace.
  209          */
  210         td_softdep_cleanup(td);
  211 
  212         /*
  213          * MUST abort all other threads before proceeding past here.
  214          */
  215         PROC_LOCK(p);
  216         /*
  217          * First check if some other thread or external request got
  218          * here before us.  If so, act appropriately: exit or suspend.
  219          * We must ensure that stop requests are handled before we set
  220          * P_WEXIT.
  221          */
  222         thread_suspend_check(0);
  223         while (p->p_flag & P_HADTHREADS) {
  224                 /*
  225                  * Kill off the other threads. This requires
  226                  * some co-operation from other parts of the kernel
  227                  * so it may not be instantaneous.  With this state set
  228                  * any thread entering the kernel from userspace will
  229                  * thread_exit() in trap().  Any thread attempting to
  230                  * sleep will return immediately with EINTR or EWOULDBLOCK
  231                  * which will hopefully force them to back out to userland
  232                  * freeing resources as they go.  Any thread attempting
  233                  * to return to userland will thread_exit() from userret().
  234                  * thread_exit() will unsuspend us when the last of the
  235                  * other threads exits.
  236                  * If there is already a thread singler after resumption,
  237                  * calling thread_single will fail; in that case, we just
  238                  * re-check all suspension request, the thread should
  239                  * either be suspended there or exit.
  240                  */
  241                 if (!thread_single(p, SINGLE_EXIT))
  242                         /*
  243                          * All other activity in this process is now
  244                          * stopped.  Threading support has been turned
  245                          * off.
  246                          */
  247                         break;
  248                 /*
  249                  * Recheck for new stop or suspend requests which
  250                  * might appear while process lock was dropped in
  251                  * thread_single().
  252                  */
  253                 thread_suspend_check(0);
  254         }
  255         KASSERT(p->p_numthreads == 1,
  256             ("exit1: proc %p exiting with %d threads", p, p->p_numthreads));
  257         racct_sub(p, RACCT_NTHR, 1);
  258 
  259         /* Let event handler change exit status */
  260         p->p_xexit = rval;
  261         p->p_xsig = signo;
  262 
  263         /*
  264          * Wakeup anyone in procfs' PIOCWAIT.  They should have a hold
  265          * on our vmspace, so we should block below until they have
  266          * released their reference to us.  Note that if they have
  267          * requested S_EXIT stops we will block here until they ack
  268          * via PIOCCONT.
  269          */
  270         _STOPEVENT(p, S_EXIT, 0);
  271 
  272         /*
  273          * Ignore any pending request to stop due to a stop signal.
  274          * Once P_WEXIT is set, future requests will be ignored as
  275          * well.
  276          */
  277         p->p_flag &= ~P_STOPPED_SIG;
  278         KASSERT(!P_SHOULDSTOP(p), ("exiting process is stopped"));
  279 
  280         /*
  281          * Note that we are exiting and do another wakeup of anyone in
  282          * PIOCWAIT in case they aren't listening for S_EXIT stops or
  283          * decided to wait again after we told them we are exiting.
  284          */
  285         p->p_flag |= P_WEXIT;
  286         wakeup(&p->p_stype);
  287 
  288         /*
  289          * Wait for any processes that have a hold on our vmspace to
  290          * release their reference.
  291          */
  292         while (p->p_lock > 0)
  293                 msleep(&p->p_lock, &p->p_mtx, PWAIT, "exithold", 0);
  294 
  295         PROC_UNLOCK(p);
  296         /* Drain the limit callout while we don't have the proc locked */
  297         callout_drain(&p->p_limco);
  298 
  299 #ifdef AUDIT
  300         /*
  301          * The Sun BSM exit token contains two components: an exit status as
  302          * passed to exit(), and a return value to indicate what sort of exit
  303          * it was.  The exit status is WEXITSTATUS(rv), but it's not clear
  304          * what the return value is.
  305          */
  306         AUDIT_ARG_EXIT(rval, 0);
  307         AUDIT_SYSCALL_EXIT(0, td);
  308 #endif
  309 
  310         /* Are we a task leader with peers? */
  311         if (p->p_peers != NULL && p == p->p_leader) {
  312                 mtx_lock(&ppeers_lock);
  313                 q = p->p_peers;
  314                 while (q != NULL) {
  315                         PROC_LOCK(q);
  316                         kern_psignal(q, SIGKILL);
  317                         PROC_UNLOCK(q);
  318                         q = q->p_peers;
  319                 }
  320                 while (p->p_peers != NULL)
  321                         msleep(p, &ppeers_lock, PWAIT, "exit1", 0);
  322                 mtx_unlock(&ppeers_lock);
  323         }
  324 
  325         itimers_exit(p);
  326 
  327         /*
  328          * Check if any loadable modules need anything done at process exit.
  329          * E.g. SYSV IPC stuff.
  330          * Event handler could change exit status.
  331          * XXX what if one of these generates an error?
  332          */
  333         EVENTHANDLER_DIRECT_INVOKE(process_exit, p);
  334 
  335         /*
  336          * If parent is waiting for us to exit or exec,
  337          * P_PPWAIT is set; we will wakeup the parent below.
  338          */
  339         PROC_LOCK(p);
  340         stopprofclock(p);
  341         p->p_ptevents = 0;
  342 
  343         /*
  344          * Stop the real interval timer.  If the handler is currently
  345          * executing, prevent it from rearming itself and let it finish.
  346          */
  347         if (timevalisset(&p->p_realtimer.it_value) &&
  348             _callout_stop_safe(&p->p_itcallout, CS_EXECUTING, NULL) == 0) {
  349                 timevalclear(&p->p_realtimer.it_interval);
  350                 msleep(&p->p_itcallout, &p->p_mtx, PWAIT, "ritwait", 0);
  351                 KASSERT(!timevalisset(&p->p_realtimer.it_value),
  352                     ("realtime timer is still armed"));
  353         }
  354 
  355         PROC_UNLOCK(p);
  356 
  357         umtx_thread_exit(td);
  358 
  359         /*
  360          * Reset any sigio structures pointing to us as a result of
  361          * F_SETOWN with our pid.  The P_WEXIT flag interlocks with fsetown().
  362          */
  363         funsetownlst(&p->p_sigiolst);
  364 
  365         /*
  366          * If this process has an nlminfo data area (for lockd), release it
  367          */
  368         if (nlminfo_release_p != NULL && p->p_nlminfo != NULL)
  369                 (*nlminfo_release_p)(p);
  370 
  371         /*
  372          * Close open files and release open-file table.
  373          * This may block!
  374          */
  375         fdescfree(td);
  376 
  377         /*
  378          * If this thread tickled GEOM, we need to wait for the giggling to
  379          * stop before we return to userland
  380          */
  381         if (td->td_pflags & TDP_GEOM)
  382                 g_waitidle();
  383 
  384         /*
  385          * Remove ourself from our leader's peer list and wake our leader.
  386          */
  387         if (p->p_leader->p_peers != NULL) {
  388                 mtx_lock(&ppeers_lock);
  389                 if (p->p_leader->p_peers != NULL) {
  390                         q = p->p_leader;
  391                         while (q->p_peers != p)
  392                                 q = q->p_peers;
  393                         q->p_peers = p->p_peers;
  394                         wakeup(p->p_leader);
  395                 }
  396                 mtx_unlock(&ppeers_lock);
  397         }
  398 
  399         vmspace_exit(td);
  400         (void)acct_process(td);
  401 
  402 #ifdef KTRACE
  403         ktrprocexit(td);
  404 #endif
  405         /*
  406          * Release reference to text vnode
  407          */
  408         if (p->p_textvp != NULL) {
  409                 vrele(p->p_textvp);
  410                 p->p_textvp = NULL;
  411         }
  412 
  413         /*
  414          * Release our limits structure.
  415          */
  416         lim_free(p->p_limit);
  417         p->p_limit = NULL;
  418 
  419         tidhash_remove(td);
  420 
  421         /*
  422          * Call machine-dependent code to release any
  423          * machine-dependent resources other than the address space.
  424          * The address space is released by "vmspace_exitfree(p)" in
  425          * vm_waitproc().
  426          */
  427         cpu_exit(td);
  428 
  429         WITNESS_WARN(WARN_PANIC, NULL, "process (pid %d) exiting", p->p_pid);
  430 
  431         sx_xlock(&proctree_lock);
  432         /*
  433          * Remove proc from allproc queue and pidhash chain.
  434          * Place onto zombproc.  Unlink from parent's child list.
  435          */
  436         sx_xlock(&allproc_lock);
  437         LIST_REMOVE(p, p_list);
  438         LIST_INSERT_HEAD(&zombproc, p, p_list);
  439         LIST_REMOVE(p, p_hash);
  440         sx_xunlock(&allproc_lock);
  441 
  442         PROC_LOCK(p);
  443         p->p_flag &= ~(P_TRACED | P_PPWAIT | P_PPTRACE);
  444         PROC_UNLOCK(p);
  445 
  446         /*
  447          * killjobc() might drop and re-acquire proctree_lock to
  448          * revoke control tty if exiting process was a session leader.
  449          */
  450         killjobc();
  451 
  452         /*
  453          * Reparent all children processes:
  454          * - traced ones to the original parent (or init if we are that parent)
  455          * - the rest to init
  456          */
  457         q = LIST_FIRST(&p->p_children);
  458         if (q != NULL)          /* only need this if any child is S_ZOMB */
  459                 wakeup(q->p_reaper);
  460         for (; q != NULL; q = nq) {
  461                 nq = LIST_NEXT(q, p_sibling);
  462                 ksi = ksiginfo_alloc(TRUE);
  463                 PROC_LOCK(q);
  464                 q->p_sigparent = SIGCHLD;
  465 
  466                 if ((q->p_flag & P_TRACED) == 0) {
  467                         proc_reparent(q, q->p_reaper, true);
  468                         if (q->p_state == PRS_ZOMBIE) {
  469                                 /*
  470                                  * Inform reaper about the reparented
  471                                  * zombie, since wait(2) has something
  472                                  * new to report.  Guarantee queueing
  473                                  * of the SIGCHLD signal, similar to
  474                                  * the _exit() behaviour, by providing
  475                                  * our ksiginfo.  Ksi is freed by the
  476                                  * signal delivery.
  477                                  */
  478                                 if (q->p_ksi == NULL) {
  479                                         ksi1 = NULL;
  480                                 } else {
  481                                         ksiginfo_copy(q->p_ksi, ksi);
  482                                         ksi->ksi_flags |= KSI_INS;
  483                                         ksi1 = ksi;
  484                                         ksi = NULL;
  485                                 }
  486                                 PROC_LOCK(q->p_reaper);
  487                                 pksignal(q->p_reaper, SIGCHLD, ksi1);
  488                                 PROC_UNLOCK(q->p_reaper);
  489                         } else if (q->p_pdeathsig > 0) {
  490                                 /*
  491                                  * The child asked to received a signal
  492                                  * when we exit.
  493                                  */
  494                                 kern_psignal(q, q->p_pdeathsig);
  495                         }
  496                 } else {
  497                         /*
  498                          * Traced processes are killed since their existence
  499                          * means someone is screwing up.
  500                          */
  501                         t = proc_realparent(q);
  502                         if (t == p) {
  503                                 proc_reparent(q, q->p_reaper, true);
  504                         } else {
  505                                 PROC_LOCK(t);
  506                                 proc_reparent(q, t, true);
  507                                 PROC_UNLOCK(t);
  508                         }
  509                         /*
  510                          * Since q was found on our children list, the
  511                          * proc_reparent() call moved q to the orphan
  512                          * list due to present P_TRACED flag. Clear
  513                          * orphan link for q now while q is locked.
  514                          */
  515                         proc_clear_orphan(q);
  516                         q->p_flag &= ~(P_TRACED | P_STOPPED_TRACE);
  517                         q->p_flag2 &= ~P2_PTRACE_FSTP;
  518                         q->p_ptevents = 0;
  519                         FOREACH_THREAD_IN_PROC(q, tdt) {
  520                                 tdt->td_dbgflags &= ~(TDB_SUSPEND | TDB_XSIG |
  521                                     TDB_FSTP);
  522                         }
  523                         kern_psignal(q, SIGKILL);
  524                 }
  525                 PROC_UNLOCK(q);
  526                 if (ksi != NULL)
  527                         ksiginfo_free(ksi);
  528         }
  529 
  530         /*
  531          * Also get rid of our orphans.
  532          */
  533         while ((q = LIST_FIRST(&p->p_orphans)) != NULL) {
  534                 PROC_LOCK(q);
  535                 KASSERT(q->p_oppid == p->p_pid,
  536                     ("orphan %p of %p has unexpected oppid %d", q, p,
  537                     q->p_oppid));
  538                 q->p_oppid = q->p_reaper->p_pid;
  539 
  540                 /*
  541                  * If we are the real parent of this process
  542                  * but it has been reparented to a debugger, then
  543                  * check if it asked for a signal when we exit.
  544                  */
  545                 if (q->p_pdeathsig > 0)
  546                         kern_psignal(q, q->p_pdeathsig);
  547                 CTR2(KTR_PTRACE, "exit: pid %d, clearing orphan %d", p->p_pid,
  548                     q->p_pid);
  549                 proc_clear_orphan(q);
  550                 PROC_UNLOCK(q);
  551         }
  552 
  553         /* Save exit status. */
  554         PROC_LOCK(p);
  555         p->p_xthread = td;
  556 
  557 #ifdef KDTRACE_HOOKS
  558         /*
  559          * Tell the DTrace fasttrap provider about the exit if it
  560          * has declared an interest.
  561          */
  562         if (dtrace_fasttrap_exit)
  563                 dtrace_fasttrap_exit(p);
  564 #endif
  565 
  566         /*
  567          * Notify interested parties of our demise.
  568          */
  569         KNOTE_LOCKED(p->p_klist, NOTE_EXIT);
  570 
  571 #ifdef KDTRACE_HOOKS
  572         int reason = CLD_EXITED;
  573         if (WCOREDUMP(signo))
  574                 reason = CLD_DUMPED;
  575         else if (WIFSIGNALED(signo))
  576                 reason = CLD_KILLED;
  577         SDT_PROBE1(proc, , , exit, reason);
  578 #endif
  579 
  580         /*
  581          * If this is a process with a descriptor, we may not need to deliver
  582          * a signal to the parent.  proctree_lock is held over
  583          * procdesc_exit() to serialize concurrent calls to close() and
  584          * exit().
  585          */
  586         signal_parent = 0;
  587         if (p->p_procdesc == NULL || procdesc_exit(p)) {
  588                 /*
  589                  * Notify parent that we're gone.  If parent has the
  590                  * PS_NOCLDWAIT flag set, or if the handler is set to SIG_IGN,
  591                  * notify process 1 instead (and hope it will handle this
  592                  * situation).
  593                  */
  594                 PROC_LOCK(p->p_pptr);
  595                 mtx_lock(&p->p_pptr->p_sigacts->ps_mtx);
  596                 if (p->p_pptr->p_sigacts->ps_flag &
  597                     (PS_NOCLDWAIT | PS_CLDSIGIGN)) {
  598                         struct proc *pp;
  599 
  600                         mtx_unlock(&p->p_pptr->p_sigacts->ps_mtx);
  601                         pp = p->p_pptr;
  602                         PROC_UNLOCK(pp);
  603                         proc_reparent(p, p->p_reaper, true);
  604                         p->p_sigparent = SIGCHLD;
  605                         PROC_LOCK(p->p_pptr);
  606 
  607                         /*
  608                          * Notify parent, so in case he was wait(2)ing or
  609                          * executing waitpid(2) with our pid, he will
  610                          * continue.
  611                          */
  612                         wakeup(pp);
  613                 } else
  614                         mtx_unlock(&p->p_pptr->p_sigacts->ps_mtx);
  615 
  616                 if (p->p_pptr == p->p_reaper || p->p_pptr == initproc) {
  617                         signal_parent = 1;
  618                 } else if (p->p_sigparent != 0) {
  619                         if (p->p_sigparent == SIGCHLD) {
  620                                 signal_parent = 1;
  621                         } else { /* LINUX thread */
  622                                 signal_parent = 2;
  623                         }
  624                 }
  625         } else
  626                 PROC_LOCK(p->p_pptr);
  627         sx_xunlock(&proctree_lock);
  628 
  629         if (signal_parent == 1) {
  630                 childproc_exited(p);
  631         } else if (signal_parent == 2) {
  632                 kern_psignal(p->p_pptr, p->p_sigparent);
  633         }
  634 
  635         /* Tell the prison that we are gone. */
  636         prison_proc_free(p->p_ucred->cr_prison);
  637 
  638         /*
  639          * The state PRS_ZOMBIE prevents other proesses from sending
  640          * signal to the process, to avoid memory leak, we free memory
  641          * for signal queue at the time when the state is set.
  642          */
  643         sigqueue_flush(&p->p_sigqueue);
  644         sigqueue_flush(&td->td_sigqueue);
  645 
  646         /*
  647          * We have to wait until after acquiring all locks before
  648          * changing p_state.  We need to avoid all possible context
  649          * switches (including ones from blocking on a mutex) while
  650          * marked as a zombie.  We also have to set the zombie state
  651          * before we release the parent process' proc lock to avoid
  652          * a lost wakeup.  So, we first call wakeup, then we grab the
  653          * sched lock, update the state, and release the parent process'
  654          * proc lock.
  655          */
  656         wakeup(p->p_pptr);
  657         cv_broadcast(&p->p_pwait);
  658         sched_exit(p->p_pptr, td);
  659         PROC_SLOCK(p);
  660         p->p_state = PRS_ZOMBIE;
  661         PROC_UNLOCK(p->p_pptr);
  662 
  663         /*
  664          * Save our children's rusage information in our exit rusage.
  665          */
  666         PROC_STATLOCK(p);
  667         ruadd(&p->p_ru, &p->p_rux, &p->p_stats->p_cru, &p->p_crux);
  668         PROC_STATUNLOCK(p);
  669 
  670         /*
  671          * Make sure the scheduler takes this thread out of its tables etc.
  672          * This will also release this thread's reference to the ucred.
  673          * Other thread parts to release include pcb bits and such.
  674          */
  675         thread_exit();
  676 }
  677 
  678 
  679 #ifndef _SYS_SYSPROTO_H_
  680 struct abort2_args {
  681         char *why;
  682         int nargs;
  683         void **args;
  684 };
  685 #endif
  686 
  687 int
  688 sys_abort2(struct thread *td, struct abort2_args *uap)
  689 {
  690         struct proc *p = td->td_proc;
  691         struct sbuf *sb;
  692         void *uargs[16];
  693         int error, i, sig;
  694 
  695         /*
  696          * Do it right now so we can log either proper call of abort2(), or
  697          * note, that invalid argument was passed. 512 is big enough to
  698          * handle 16 arguments' descriptions with additional comments.
  699          */
  700         sb = sbuf_new(NULL, NULL, 512, SBUF_FIXEDLEN);
  701         sbuf_clear(sb);
  702         sbuf_printf(sb, "%s(pid %d uid %d) aborted: ",
  703             p->p_comm, p->p_pid, td->td_ucred->cr_uid);
  704         /*
  705          * Since we can't return from abort2(), send SIGKILL in cases, where
  706          * abort2() was called improperly
  707          */
  708         sig = SIGKILL;
  709         /* Prevent from DoSes from user-space. */
  710         if (uap->nargs < 0 || uap->nargs > 16)
  711                 goto out;
  712         if (uap->nargs > 0) {
  713                 if (uap->args == NULL)
  714                         goto out;
  715                 error = copyin(uap->args, uargs, uap->nargs * sizeof(void *));
  716                 if (error != 0)
  717                         goto out;
  718         }
  719         /*
  720          * Limit size of 'reason' string to 128. Will fit even when
  721          * maximal number of arguments was chosen to be logged.
  722          */
  723         if (uap->why != NULL) {
  724                 error = sbuf_copyin(sb, uap->why, 128);
  725                 if (error < 0)
  726                         goto out;
  727         } else {
  728                 sbuf_printf(sb, "(null)");
  729         }
  730         if (uap->nargs > 0) {
  731                 sbuf_printf(sb, "(");
  732                 for (i = 0;i < uap->nargs; i++)
  733                         sbuf_printf(sb, "%s%p", i == 0 ? "" : ", ", uargs[i]);
  734                 sbuf_printf(sb, ")");
  735         }
  736         /*
  737          * Final stage: arguments were proper, string has been
  738          * successfully copied from userspace, and copying pointers
  739          * from user-space succeed.
  740          */
  741         sig = SIGABRT;
  742 out:
  743         if (sig == SIGKILL) {
  744                 sbuf_trim(sb);
  745                 sbuf_printf(sb, " (Reason text inaccessible)");
  746         }
  747         sbuf_cat(sb, "\n");
  748         sbuf_finish(sb);
  749         log(LOG_INFO, "%s", sbuf_data(sb));
  750         sbuf_delete(sb);
  751         exit1(td, 0, sig);
  752         return (0);
  753 }
  754 
  755 
  756 #ifdef COMPAT_43
  757 /*
  758  * The dirty work is handled by kern_wait().
  759  */
  760 int
  761 owait(struct thread *td, struct owait_args *uap __unused)
  762 {
  763         int error, status;
  764 
  765         error = kern_wait(td, WAIT_ANY, &status, 0, NULL);
  766         if (error == 0)
  767                 td->td_retval[1] = status;
  768         return (error);
  769 }
  770 #endif /* COMPAT_43 */
  771 
  772 /*
  773  * The dirty work is handled by kern_wait().
  774  */
  775 int
  776 sys_wait4(struct thread *td, struct wait4_args *uap)
  777 {
  778         struct rusage ru, *rup;
  779         int error, status;
  780 
  781         if (uap->rusage != NULL)
  782                 rup = &ru;
  783         else
  784                 rup = NULL;
  785         error = kern_wait(td, uap->pid, &status, uap->options, rup);
  786         if (uap->status != NULL && error == 0 && td->td_retval[0] != 0)
  787                 error = copyout(&status, uap->status, sizeof(status));
  788         if (uap->rusage != NULL && error == 0 && td->td_retval[0] != 0)
  789                 error = copyout(&ru, uap->rusage, sizeof(struct rusage));
  790         return (error);
  791 }
  792 
  793 int
  794 sys_wait6(struct thread *td, struct wait6_args *uap)
  795 {
  796         struct __wrusage wru, *wrup;
  797         siginfo_t si, *sip;
  798         idtype_t idtype;
  799         id_t id;
  800         int error, status;
  801 
  802         idtype = uap->idtype;
  803         id = uap->id;
  804 
  805         if (uap->wrusage != NULL)
  806                 wrup = &wru;
  807         else
  808                 wrup = NULL;
  809 
  810         if (uap->info != NULL) {
  811                 sip = &si;
  812                 bzero(sip, sizeof(*sip));
  813         } else
  814                 sip = NULL;
  815 
  816         /*
  817          *  We expect all callers of wait6() to know about WEXITED and
  818          *  WTRAPPED.
  819          */
  820         error = kern_wait6(td, idtype, id, &status, uap->options, wrup, sip);
  821 
  822         if (uap->status != NULL && error == 0 && td->td_retval[0] != 0)
  823                 error = copyout(&status, uap->status, sizeof(status));
  824         if (uap->wrusage != NULL && error == 0 && td->td_retval[0] != 0)
  825                 error = copyout(&wru, uap->wrusage, sizeof(wru));
  826         if (uap->info != NULL && error == 0)
  827                 error = copyout(&si, uap->info, sizeof(si));
  828         return (error);
  829 }
  830 
  831 /*
  832  * Reap the remains of a zombie process and optionally return status and
  833  * rusage.  Asserts and will release both the proctree_lock and the process
  834  * lock as part of its work.
  835  */
  836 void
  837 proc_reap(struct thread *td, struct proc *p, int *status, int options)
  838 {
  839         struct proc *q, *t;
  840 
  841         sx_assert(&proctree_lock, SA_XLOCKED);
  842         PROC_LOCK_ASSERT(p, MA_OWNED);
  843         KASSERT(p->p_state == PRS_ZOMBIE, ("proc_reap: !PRS_ZOMBIE"));
  844 
  845         mtx_spin_wait_unlocked(&p->p_slock);
  846 
  847         q = td->td_proc;
  848 
  849         if (status)
  850                 *status = KW_EXITCODE(p->p_xexit, p->p_xsig);
  851         if (options & WNOWAIT) {
  852                 /*
  853                  *  Only poll, returning the status.  Caller does not wish to
  854                  * release the proc struct just yet.
  855                  */
  856                 PROC_UNLOCK(p);
  857                 sx_xunlock(&proctree_lock);
  858                 return;
  859         }
  860 
  861         PROC_LOCK(q);
  862         sigqueue_take(p->p_ksi);
  863         PROC_UNLOCK(q);
  864 
  865         /*
  866          * If we got the child via a ptrace 'attach', we need to give it back
  867          * to the old parent.
  868          */
  869         if (p->p_oppid != p->p_pptr->p_pid) {
  870                 PROC_UNLOCK(p);
  871                 t = proc_realparent(p);
  872                 PROC_LOCK(t);
  873                 PROC_LOCK(p);
  874                 CTR2(KTR_PTRACE,
  875                     "wait: traced child %d moved back to parent %d", p->p_pid,
  876                     t->p_pid);
  877                 proc_reparent(p, t, false);
  878                 PROC_UNLOCK(p);
  879                 pksignal(t, SIGCHLD, p->p_ksi);
  880                 wakeup(t);
  881                 cv_broadcast(&p->p_pwait);
  882                 PROC_UNLOCK(t);
  883                 sx_xunlock(&proctree_lock);
  884                 return;
  885         }
  886         PROC_UNLOCK(p);
  887 
  888         /*
  889          * Remove other references to this process to ensure we have an
  890          * exclusive reference.
  891          */
  892         sx_xlock(&allproc_lock);
  893         LIST_REMOVE(p, p_list); /* off zombproc */
  894         sx_xunlock(&allproc_lock);
  895         LIST_REMOVE(p, p_sibling);
  896         reaper_abandon_children(p, true);
  897         LIST_REMOVE(p, p_reapsibling);
  898         PROC_LOCK(p);
  899         proc_clear_orphan(p);
  900         PROC_UNLOCK(p);
  901         leavepgrp(p);
  902         if (p->p_procdesc != NULL)
  903                 procdesc_reap(p);
  904         sx_xunlock(&proctree_lock);
  905 
  906         PROC_LOCK(p);
  907         knlist_detach(p->p_klist);
  908         p->p_klist = NULL;
  909         PROC_UNLOCK(p);
  910 
  911         /*
  912          * Removal from allproc list and process group list paired with
  913          * PROC_LOCK which was executed during that time should guarantee
  914          * nothing can reach this process anymore. As such further locking
  915          * is unnecessary.
  916          */
  917         p->p_xexit = p->p_xsig = 0;             /* XXX: why? */
  918 
  919         PROC_LOCK(q);
  920         ruadd(&q->p_stats->p_cru, &q->p_crux, &p->p_ru, &p->p_rux);
  921         PROC_UNLOCK(q);
  922 
  923         /*
  924          * Decrement the count of procs running with this uid.
  925          */
  926         (void)chgproccnt(p->p_ucred->cr_ruidinfo, -1, 0);
  927 
  928         /*
  929          * Destroy resource accounting information associated with the process.
  930          */
  931 #ifdef RACCT
  932         if (racct_enable) {
  933                 PROC_LOCK(p);
  934                 racct_sub(p, RACCT_NPROC, 1);
  935                 PROC_UNLOCK(p);
  936         }
  937 #endif
  938         racct_proc_exit(p);
  939 
  940         /*
  941          * Free credentials, arguments, and sigacts.
  942          */
  943         crfree(p->p_ucred);
  944         proc_set_cred(p, NULL);
  945         pargs_drop(p->p_args);
  946         p->p_args = NULL;
  947         sigacts_free(p->p_sigacts);
  948         p->p_sigacts = NULL;
  949 
  950         /*
  951          * Do any thread-system specific cleanups.
  952          */
  953         thread_wait(p);
  954 
  955         /*
  956          * Give vm and machine-dependent layer a chance to free anything that
  957          * cpu_exit couldn't release while still running in process context.
  958          */
  959         vm_waitproc(p);
  960 #ifdef MAC
  961         mac_proc_destroy(p);
  962 #endif
  963 
  964         KASSERT(FIRST_THREAD_IN_PROC(p),
  965             ("proc_reap: no residual thread!"));
  966         uma_zfree(proc_zone, p);
  967         atomic_add_int(&nprocs, -1);
  968 }
  969 
  970 static int
  971 proc_to_reap(struct thread *td, struct proc *p, idtype_t idtype, id_t id,
  972     int *status, int options, struct __wrusage *wrusage, siginfo_t *siginfo,
  973     int check_only)
  974 {
  975         struct rusage *rup;
  976 
  977         sx_assert(&proctree_lock, SA_XLOCKED);
  978 
  979         PROC_LOCK(p);
  980 
  981         switch (idtype) {
  982         case P_ALL:
  983                 if (p->p_procdesc != NULL) {
  984                         PROC_UNLOCK(p);
  985                         return (0);
  986                 }
  987                 break;
  988         case P_PID:
  989                 if (p->p_pid != (pid_t)id) {
  990                         PROC_UNLOCK(p);
  991                         return (0);
  992                 }
  993                 break;
  994         case P_PGID:
  995                 if (p->p_pgid != (pid_t)id) {
  996                         PROC_UNLOCK(p);
  997                         return (0);
  998                 }
  999                 break;
 1000         case P_SID:
 1001                 if (p->p_session->s_sid != (pid_t)id) {
 1002                         PROC_UNLOCK(p);
 1003                         return (0);
 1004                 }
 1005                 break;
 1006         case P_UID:
 1007                 if (p->p_ucred->cr_uid != (uid_t)id) {
 1008                         PROC_UNLOCK(p);
 1009                         return (0);
 1010                 }
 1011                 break;
 1012         case P_GID:
 1013                 if (p->p_ucred->cr_gid != (gid_t)id) {
 1014                         PROC_UNLOCK(p);
 1015                         return (0);
 1016                 }
 1017                 break;
 1018         case P_JAILID:
 1019                 if (p->p_ucred->cr_prison->pr_id != (int)id) {
 1020                         PROC_UNLOCK(p);
 1021                         return (0);
 1022                 }
 1023                 break;
 1024         /*
 1025          * It seems that the thread structures get zeroed out
 1026          * at process exit.  This makes it impossible to
 1027          * support P_SETID, P_CID or P_CPUID.
 1028          */
 1029         default:
 1030                 PROC_UNLOCK(p);
 1031                 return (0);
 1032         }
 1033 
 1034         if (p_canwait(td, p)) {
 1035                 PROC_UNLOCK(p);
 1036                 return (0);
 1037         }
 1038 
 1039         if (((options & WEXITED) == 0) && (p->p_state == PRS_ZOMBIE)) {
 1040                 PROC_UNLOCK(p);
 1041                 return (0);
 1042         }
 1043 
 1044         /*
 1045          * This special case handles a kthread spawned by linux_clone
 1046          * (see linux_misc.c).  The linux_wait4 and linux_waitpid
 1047          * functions need to be able to distinguish between waiting
 1048          * on a process and waiting on a thread.  It is a thread if
 1049          * p_sigparent is not SIGCHLD, and the WLINUXCLONE option
 1050          * signifies we want to wait for threads and not processes.
 1051          */
 1052         if ((p->p_sigparent != SIGCHLD) ^
 1053             ((options & WLINUXCLONE) != 0)) {
 1054                 PROC_UNLOCK(p);
 1055                 return (0);
 1056         }
 1057 
 1058         if (siginfo != NULL) {
 1059                 bzero(siginfo, sizeof(*siginfo));
 1060                 siginfo->si_errno = 0;
 1061 
 1062                 /*
 1063                  * SUSv4 requires that the si_signo value is always
 1064                  * SIGCHLD. Obey it despite the rfork(2) interface
 1065                  * allows to request other signal for child exit
 1066                  * notification.
 1067                  */
 1068                 siginfo->si_signo = SIGCHLD;
 1069 
 1070                 /*
 1071                  *  This is still a rough estimate.  We will fix the
 1072                  *  cases TRAPPED, STOPPED, and CONTINUED later.
 1073                  */
 1074                 if (WCOREDUMP(p->p_xsig)) {
 1075                         siginfo->si_code = CLD_DUMPED;
 1076                         siginfo->si_status = WTERMSIG(p->p_xsig);
 1077                 } else if (WIFSIGNALED(p->p_xsig)) {
 1078                         siginfo->si_code = CLD_KILLED;
 1079                         siginfo->si_status = WTERMSIG(p->p_xsig);
 1080                 } else {
 1081                         siginfo->si_code = CLD_EXITED;
 1082                         siginfo->si_status = p->p_xexit;
 1083                 }
 1084 
 1085                 siginfo->si_pid = p->p_pid;
 1086                 siginfo->si_uid = p->p_ucred->cr_uid;
 1087 
 1088                 /*
 1089                  * The si_addr field would be useful additional
 1090                  * detail, but apparently the PC value may be lost
 1091                  * when we reach this point.  bzero() above sets
 1092                  * siginfo->si_addr to NULL.
 1093                  */
 1094         }
 1095 
 1096         /*
 1097          * There should be no reason to limit resources usage info to
 1098          * exited processes only.  A snapshot about any resources used
 1099          * by a stopped process may be exactly what is needed.
 1100          */
 1101         if (wrusage != NULL) {
 1102                 rup = &wrusage->wru_self;
 1103                 *rup = p->p_ru;
 1104                 PROC_STATLOCK(p);
 1105                 calcru(p, &rup->ru_utime, &rup->ru_stime);
 1106                 PROC_STATUNLOCK(p);
 1107 
 1108                 rup = &wrusage->wru_children;
 1109                 *rup = p->p_stats->p_cru;
 1110                 calccru(p, &rup->ru_utime, &rup->ru_stime);
 1111         }
 1112 
 1113         if (p->p_state == PRS_ZOMBIE && !check_only) {
 1114                 proc_reap(td, p, status, options);
 1115                 return (-1);
 1116         }
 1117         return (1);
 1118 }
 1119 
 1120 int
 1121 kern_wait(struct thread *td, pid_t pid, int *status, int options,
 1122     struct rusage *rusage)
 1123 {
 1124         struct __wrusage wru, *wrup;
 1125         idtype_t idtype;
 1126         id_t id;
 1127         int ret;
 1128 
 1129         /*
 1130          * Translate the special pid values into the (idtype, pid)
 1131          * pair for kern_wait6.  The WAIT_MYPGRP case is handled by
 1132          * kern_wait6() on its own.
 1133          */
 1134         if (pid == WAIT_ANY) {
 1135                 idtype = P_ALL;
 1136                 id = 0;
 1137         } else if (pid < 0) {
 1138                 idtype = P_PGID;
 1139                 id = (id_t)-pid;
 1140         } else {
 1141                 idtype = P_PID;
 1142                 id = (id_t)pid;
 1143         }
 1144 
 1145         if (rusage != NULL)
 1146                 wrup = &wru;
 1147         else
 1148                 wrup = NULL;
 1149 
 1150         /*
 1151          * For backward compatibility we implicitly add flags WEXITED
 1152          * and WTRAPPED here.
 1153          */
 1154         options |= WEXITED | WTRAPPED;
 1155         ret = kern_wait6(td, idtype, id, status, options, wrup, NULL);
 1156         if (rusage != NULL)
 1157                 *rusage = wru.wru_self;
 1158         return (ret);
 1159 }
 1160 
 1161 static void
 1162 report_alive_proc(struct thread *td, struct proc *p, siginfo_t *siginfo,
 1163     int *status, int options, int si_code)
 1164 {
 1165         bool cont;
 1166 
 1167         PROC_LOCK_ASSERT(p, MA_OWNED);
 1168         sx_assert(&proctree_lock, SA_XLOCKED);
 1169         MPASS(si_code == CLD_TRAPPED || si_code == CLD_STOPPED ||
 1170             si_code == CLD_CONTINUED);
 1171 
 1172         cont = si_code == CLD_CONTINUED;
 1173         if ((options & WNOWAIT) == 0) {
 1174                 if (cont)
 1175                         p->p_flag &= ~P_CONTINUED;
 1176                 else
 1177                         p->p_flag |= P_WAITED;
 1178                 PROC_LOCK(td->td_proc);
 1179                 sigqueue_take(p->p_ksi);
 1180                 PROC_UNLOCK(td->td_proc);
 1181         }
 1182         sx_xunlock(&proctree_lock);
 1183         if (siginfo != NULL) {
 1184                 siginfo->si_code = si_code;
 1185                 siginfo->si_status = cont ? SIGCONT : p->p_xsig;
 1186         }
 1187         if (status != NULL)
 1188                 *status = cont ? SIGCONT : W_STOPCODE(p->p_xsig);
 1189         PROC_UNLOCK(p);
 1190         td->td_retval[0] = p->p_pid;
 1191 }
 1192 
 1193 int
 1194 kern_wait6(struct thread *td, idtype_t idtype, id_t id, int *status,
 1195     int options, struct __wrusage *wrusage, siginfo_t *siginfo)
 1196 {
 1197         struct proc *p, *q;
 1198         pid_t pid;
 1199         int error, nfound, ret;
 1200         bool report;
 1201 
 1202         AUDIT_ARG_VALUE((int)idtype);   /* XXX - This is likely wrong! */
 1203         AUDIT_ARG_PID((pid_t)id);       /* XXX - This may be wrong! */
 1204         AUDIT_ARG_VALUE(options);
 1205 
 1206         q = td->td_proc;
 1207 
 1208         if ((pid_t)id == WAIT_MYPGRP && (idtype == P_PID || idtype == P_PGID)) {
 1209                 PROC_LOCK(q);
 1210                 id = (id_t)q->p_pgid;
 1211                 PROC_UNLOCK(q);
 1212                 idtype = P_PGID;
 1213         }
 1214 
 1215         /* If we don't know the option, just return. */
 1216         if ((options & ~(WUNTRACED | WNOHANG | WCONTINUED | WNOWAIT |
 1217             WEXITED | WTRAPPED | WLINUXCLONE)) != 0)
 1218                 return (EINVAL);
 1219         if ((options & (WEXITED | WUNTRACED | WCONTINUED | WTRAPPED)) == 0) {
 1220                 /*
 1221                  * We will be unable to find any matching processes,
 1222                  * because there are no known events to look for.
 1223                  * Prefer to return error instead of blocking
 1224                  * indefinitely.
 1225                  */
 1226                 return (EINVAL);
 1227         }
 1228 
 1229 loop:
 1230         if (q->p_flag & P_STATCHILD) {
 1231                 PROC_LOCK(q);
 1232                 q->p_flag &= ~P_STATCHILD;
 1233                 PROC_UNLOCK(q);
 1234         }
 1235         sx_xlock(&proctree_lock);
 1236 loop_locked:
 1237         nfound = 0;
 1238         LIST_FOREACH(p, &q->p_children, p_sibling) {
 1239                 pid = p->p_pid;
 1240                 ret = proc_to_reap(td, p, idtype, id, status, options,
 1241                     wrusage, siginfo, 0);
 1242                 if (ret == 0)
 1243                         continue;
 1244                 else if (ret != 1) {
 1245                         td->td_retval[0] = pid;
 1246                         return (0);
 1247                 }
 1248 
 1249                 nfound++;
 1250                 PROC_LOCK_ASSERT(p, MA_OWNED);
 1251 
 1252                 if ((options & WTRAPPED) != 0 &&
 1253                     (p->p_flag & P_TRACED) != 0) {
 1254                         PROC_SLOCK(p);
 1255                         report =
 1256                             ((p->p_flag & (P_STOPPED_TRACE | P_STOPPED_SIG)) &&
 1257                             p->p_suspcount == p->p_numthreads &&
 1258                             (p->p_flag & P_WAITED) == 0);
 1259                         PROC_SUNLOCK(p);
 1260                         if (report) {
 1261                         CTR4(KTR_PTRACE,
 1262                             "wait: returning trapped pid %d status %#x "
 1263                             "(xstat %d) xthread %d",
 1264                             p->p_pid, W_STOPCODE(p->p_xsig), p->p_xsig,
 1265                             p->p_xthread != NULL ?
 1266                             p->p_xthread->td_tid : -1);
 1267                                 report_alive_proc(td, p, siginfo, status,
 1268                                     options, CLD_TRAPPED);
 1269                                 return (0);
 1270                         }
 1271                 }
 1272                 if ((options & WUNTRACED) != 0 &&
 1273                     (p->p_flag & P_STOPPED_SIG) != 0) {
 1274                         PROC_SLOCK(p);
 1275                         report = (p->p_suspcount == p->p_numthreads &&
 1276                             ((p->p_flag & P_WAITED) == 0));
 1277                         PROC_SUNLOCK(p);
 1278                         if (report) {
 1279                                 report_alive_proc(td, p, siginfo, status,
 1280                                     options, CLD_STOPPED);
 1281                                 return (0);
 1282                         }
 1283                 }
 1284                 if ((options & WCONTINUED) != 0 &&
 1285                     (p->p_flag & P_CONTINUED) != 0) {
 1286                         report_alive_proc(td, p, siginfo, status, options,
 1287                             CLD_CONTINUED);
 1288                         return (0);
 1289                 }
 1290                 PROC_UNLOCK(p);
 1291         }
 1292 
 1293         /*
 1294          * Look in the orphans list too, to allow the parent to
 1295          * collect it's child exit status even if child is being
 1296          * debugged.
 1297          *
 1298          * Debugger detaches from the parent upon successful
 1299          * switch-over from parent to child.  At this point due to
 1300          * re-parenting the parent loses the child to debugger and a
 1301          * wait4(2) call would report that it has no children to wait
 1302          * for.  By maintaining a list of orphans we allow the parent
 1303          * to successfully wait until the child becomes a zombie.
 1304          */
 1305         if (nfound == 0) {
 1306                 LIST_FOREACH(p, &q->p_orphans, p_orphan) {
 1307                         ret = proc_to_reap(td, p, idtype, id, NULL, options,
 1308                             NULL, NULL, 1);
 1309                         if (ret != 0) {
 1310                                 KASSERT(ret != -1, ("reaped an orphan (pid %d)",
 1311                                     (int)td->td_retval[0]));
 1312                                 PROC_UNLOCK(p);
 1313                                 nfound++;
 1314                                 break;
 1315                         }
 1316                 }
 1317         }
 1318         if (nfound == 0) {
 1319                 sx_xunlock(&proctree_lock);
 1320                 return (ECHILD);
 1321         }
 1322         if (options & WNOHANG) {
 1323                 sx_xunlock(&proctree_lock);
 1324                 td->td_retval[0] = 0;
 1325                 return (0);
 1326         }
 1327         PROC_LOCK(q);
 1328         if (q->p_flag & P_STATCHILD) {
 1329                 q->p_flag &= ~P_STATCHILD;
 1330                 PROC_UNLOCK(q);
 1331                 goto loop_locked;
 1332         }
 1333         sx_xunlock(&proctree_lock);
 1334         error = msleep(q, &q->p_mtx, PWAIT | PCATCH | PDROP, "wait", 0);
 1335         if (error)
 1336                 return (error);
 1337         goto loop;
 1338 }
 1339 
 1340 void
 1341 proc_add_orphan(struct proc *child, struct proc *parent)
 1342 {
 1343 
 1344         sx_assert(&proctree_lock, SX_XLOCKED);
 1345         KASSERT((child->p_flag & P_TRACED) != 0,
 1346             ("proc_add_orphan: not traced"));
 1347 
 1348         if (LIST_EMPTY(&parent->p_orphans)) {
 1349                 child->p_treeflag |= P_TREE_FIRST_ORPHAN;
 1350                 LIST_INSERT_HEAD(&parent->p_orphans, child, p_orphan);
 1351         } else {
 1352                 LIST_INSERT_AFTER(LIST_FIRST(&parent->p_orphans),
 1353                     child, p_orphan);
 1354         }
 1355         child->p_treeflag |= P_TREE_ORPHANED;
 1356 }
 1357 
 1358 /*
 1359  * Make process 'parent' the new parent of process 'child'.
 1360  * Must be called with an exclusive hold of proctree lock.
 1361  */
 1362 void
 1363 proc_reparent(struct proc *child, struct proc *parent, bool set_oppid)
 1364 {
 1365 
 1366         sx_assert(&proctree_lock, SX_XLOCKED);
 1367         PROC_LOCK_ASSERT(child, MA_OWNED);
 1368         if (child->p_pptr == parent)
 1369                 return;
 1370 
 1371         PROC_LOCK(child->p_pptr);
 1372         sigqueue_take(child->p_ksi);
 1373         PROC_UNLOCK(child->p_pptr);
 1374         LIST_REMOVE(child, p_sibling);
 1375         LIST_INSERT_HEAD(&parent->p_children, child, p_sibling);
 1376 
 1377         proc_clear_orphan(child);
 1378         if ((child->p_flag & P_TRACED) != 0) {
 1379                 proc_add_orphan(child, child->p_pptr);
 1380         }
 1381 
 1382         child->p_pptr = parent;
 1383         if (set_oppid)
 1384                 child->p_oppid = parent->p_pid;
 1385 }

Cache object: f887e4eb765fbfd6f81dec7be5ccd355


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.