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  -  FREEBSD11  -  FREEBSD10  -  FREEBSD9  -  FREEBSD92  -  FREEBSD91  -  FREEBSD90  -  FREEBSD8  -  FREEBSD82  -  FREEBSD81  -  FREEBSD80  -  FREEBSD7  -  FREEBSD74  -  FREEBSD73  -  FREEBSD72  -  FREEBSD71  -  FREEBSD70  -  FREEBSD6  -  FREEBSD64  -  FREEBSD63  -  FREEBSD62  -  FREEBSD61  -  FREEBSD60  -  FREEBSD5  -  FREEBSD55  -  FREEBSD54  -  FREEBSD53  -  FREEBSD52  -  FREEBSD51  -  FREEBSD50  -  FREEBSD4  -  FREEBSD3  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

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

Cache object: e5636eec1d206d6727a9c5b2130da7ae


[ 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.