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_fork.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  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_fork.c 8.6 (Berkeley) 4/8/94
   35  */
   36 
   37 #include <sys/cdefs.h>
   38 __FBSDID("$FreeBSD: releng/11.0/sys/kern/kern_fork.c 303789 2016-08-06 08:20:58Z kib $");
   39 
   40 #include "opt_ktrace.h"
   41 #include "opt_kstack_pages.h"
   42 
   43 #include <sys/param.h>
   44 #include <sys/systm.h>
   45 #include <sys/sysproto.h>
   46 #include <sys/eventhandler.h>
   47 #include <sys/fcntl.h>
   48 #include <sys/filedesc.h>
   49 #include <sys/jail.h>
   50 #include <sys/kernel.h>
   51 #include <sys/kthread.h>
   52 #include <sys/sysctl.h>
   53 #include <sys/lock.h>
   54 #include <sys/malloc.h>
   55 #include <sys/mutex.h>
   56 #include <sys/priv.h>
   57 #include <sys/proc.h>
   58 #include <sys/procdesc.h>
   59 #include <sys/pioctl.h>
   60 #include <sys/ptrace.h>
   61 #include <sys/racct.h>
   62 #include <sys/resourcevar.h>
   63 #include <sys/sched.h>
   64 #include <sys/syscall.h>
   65 #include <sys/vmmeter.h>
   66 #include <sys/vnode.h>
   67 #include <sys/acct.h>
   68 #include <sys/ktr.h>
   69 #include <sys/ktrace.h>
   70 #include <sys/unistd.h> 
   71 #include <sys/sdt.h>
   72 #include <sys/sx.h>
   73 #include <sys/sysent.h>
   74 #include <sys/signalvar.h>
   75 
   76 #include <security/audit/audit.h>
   77 #include <security/mac/mac_framework.h>
   78 
   79 #include <vm/vm.h>
   80 #include <vm/pmap.h>
   81 #include <vm/vm_map.h>
   82 #include <vm/vm_extern.h>
   83 #include <vm/uma.h>
   84 #include <vm/vm_domain.h>
   85 
   86 #ifdef KDTRACE_HOOKS
   87 #include <sys/dtrace_bsd.h>
   88 dtrace_fork_func_t      dtrace_fasttrap_fork;
   89 #endif
   90 
   91 SDT_PROVIDER_DECLARE(proc);
   92 SDT_PROBE_DEFINE3(proc, , , create, "struct proc *", "struct proc *", "int");
   93 
   94 #ifndef _SYS_SYSPROTO_H_
   95 struct fork_args {
   96         int     dummy;
   97 };
   98 #endif
   99 
  100 /* ARGSUSED */
  101 int
  102 sys_fork(struct thread *td, struct fork_args *uap)
  103 {
  104         struct fork_req fr;
  105         int error, pid;
  106 
  107         bzero(&fr, sizeof(fr));
  108         fr.fr_flags = RFFDG | RFPROC;
  109         fr.fr_pidp = &pid;
  110         error = fork1(td, &fr);
  111         if (error == 0) {
  112                 td->td_retval[0] = pid;
  113                 td->td_retval[1] = 0;
  114         }
  115         return (error);
  116 }
  117 
  118 /* ARGUSED */
  119 int
  120 sys_pdfork(struct thread *td, struct pdfork_args *uap)
  121 {
  122         struct fork_req fr;
  123         int error, fd, pid;
  124 
  125         bzero(&fr, sizeof(fr));
  126         fr.fr_flags = RFFDG | RFPROC | RFPROCDESC;
  127         fr.fr_pidp = &pid;
  128         fr.fr_pd_fd = &fd;
  129         fr.fr_pd_flags = uap->flags;
  130         /*
  131          * It is necessary to return fd by reference because 0 is a valid file
  132          * descriptor number, and the child needs to be able to distinguish
  133          * itself from the parent using the return value.
  134          */
  135         error = fork1(td, &fr);
  136         if (error == 0) {
  137                 td->td_retval[0] = pid;
  138                 td->td_retval[1] = 0;
  139                 error = copyout(&fd, uap->fdp, sizeof(fd));
  140         }
  141         return (error);
  142 }
  143 
  144 /* ARGSUSED */
  145 int
  146 sys_vfork(struct thread *td, struct vfork_args *uap)
  147 {
  148         struct fork_req fr;
  149         int error, pid;
  150 
  151         bzero(&fr, sizeof(fr));
  152         fr.fr_flags = RFFDG | RFPROC | RFPPWAIT | RFMEM;
  153         fr.fr_pidp = &pid;
  154         error = fork1(td, &fr);
  155         if (error == 0) {
  156                 td->td_retval[0] = pid;
  157                 td->td_retval[1] = 0;
  158         }
  159         return (error);
  160 }
  161 
  162 int
  163 sys_rfork(struct thread *td, struct rfork_args *uap)
  164 {
  165         struct fork_req fr;
  166         int error, pid;
  167 
  168         /* Don't allow kernel-only flags. */
  169         if ((uap->flags & RFKERNELONLY) != 0)
  170                 return (EINVAL);
  171 
  172         AUDIT_ARG_FFLAGS(uap->flags);
  173         bzero(&fr, sizeof(fr));
  174         fr.fr_flags = uap->flags;
  175         fr.fr_pidp = &pid;
  176         error = fork1(td, &fr);
  177         if (error == 0) {
  178                 td->td_retval[0] = pid;
  179                 td->td_retval[1] = 0;
  180         }
  181         return (error);
  182 }
  183 
  184 int     nprocs = 1;             /* process 0 */
  185 int     lastpid = 0;
  186 SYSCTL_INT(_kern, OID_AUTO, lastpid, CTLFLAG_RD, &lastpid, 0, 
  187     "Last used PID");
  188 
  189 /*
  190  * Random component to lastpid generation.  We mix in a random factor to make
  191  * it a little harder to predict.  We sanity check the modulus value to avoid
  192  * doing it in critical paths.  Don't let it be too small or we pointlessly
  193  * waste randomness entropy, and don't let it be impossibly large.  Using a
  194  * modulus that is too big causes a LOT more process table scans and slows
  195  * down fork processing as the pidchecked caching is defeated.
  196  */
  197 static int randompid = 0;
  198 
  199 static int
  200 sysctl_kern_randompid(SYSCTL_HANDLER_ARGS)
  201 {
  202         int error, pid;
  203 
  204         error = sysctl_wire_old_buffer(req, sizeof(int));
  205         if (error != 0)
  206                 return(error);
  207         sx_xlock(&allproc_lock);
  208         pid = randompid;
  209         error = sysctl_handle_int(oidp, &pid, 0, req);
  210         if (error == 0 && req->newptr != NULL) {
  211                 if (pid < 0 || pid > pid_max - 100)     /* out of range */
  212                         pid = pid_max - 100;
  213                 else if (pid < 2)                       /* NOP */
  214                         pid = 0;
  215                 else if (pid < 100)                     /* Make it reasonable */
  216                         pid = 100;
  217                 randompid = pid;
  218         }
  219         sx_xunlock(&allproc_lock);
  220         return (error);
  221 }
  222 
  223 SYSCTL_PROC(_kern, OID_AUTO, randompid, CTLTYPE_INT|CTLFLAG_RW,
  224     0, 0, sysctl_kern_randompid, "I", "Random PID modulus");
  225 
  226 static int
  227 fork_findpid(int flags)
  228 {
  229         struct proc *p;
  230         int trypid;
  231         static int pidchecked = 0;
  232 
  233         /*
  234          * Requires allproc_lock in order to iterate over the list
  235          * of processes, and proctree_lock to access p_pgrp.
  236          */
  237         sx_assert(&allproc_lock, SX_LOCKED);
  238         sx_assert(&proctree_lock, SX_LOCKED);
  239 
  240         /*
  241          * Find an unused process ID.  We remember a range of unused IDs
  242          * ready to use (from lastpid+1 through pidchecked-1).
  243          *
  244          * If RFHIGHPID is set (used during system boot), do not allocate
  245          * low-numbered pids.
  246          */
  247         trypid = lastpid + 1;
  248         if (flags & RFHIGHPID) {
  249                 if (trypid < 10)
  250                         trypid = 10;
  251         } else {
  252                 if (randompid)
  253                         trypid += arc4random() % randompid;
  254         }
  255 retry:
  256         /*
  257          * If the process ID prototype has wrapped around,
  258          * restart somewhat above 0, as the low-numbered procs
  259          * tend to include daemons that don't exit.
  260          */
  261         if (trypid >= pid_max) {
  262                 trypid = trypid % pid_max;
  263                 if (trypid < 100)
  264                         trypid += 100;
  265                 pidchecked = 0;
  266         }
  267         if (trypid >= pidchecked) {
  268                 int doingzomb = 0;
  269 
  270                 pidchecked = PID_MAX;
  271                 /*
  272                  * Scan the active and zombie procs to check whether this pid
  273                  * is in use.  Remember the lowest pid that's greater
  274                  * than trypid, so we can avoid checking for a while.
  275                  *
  276                  * Avoid reuse of the process group id, session id or
  277                  * the reaper subtree id.  Note that for process group
  278                  * and sessions, the amount of reserved pids is
  279                  * limited by process limit.  For the subtree ids, the
  280                  * id is kept reserved only while there is a
  281                  * non-reaped process in the subtree, so amount of
  282                  * reserved pids is limited by process limit times
  283                  * two.
  284                  */
  285                 p = LIST_FIRST(&allproc);
  286 again:
  287                 for (; p != NULL; p = LIST_NEXT(p, p_list)) {
  288                         while (p->p_pid == trypid ||
  289                             p->p_reapsubtree == trypid ||
  290                             (p->p_pgrp != NULL &&
  291                             (p->p_pgrp->pg_id == trypid ||
  292                             (p->p_session != NULL &&
  293                             p->p_session->s_sid == trypid)))) {
  294                                 trypid++;
  295                                 if (trypid >= pidchecked)
  296                                         goto retry;
  297                         }
  298                         if (p->p_pid > trypid && pidchecked > p->p_pid)
  299                                 pidchecked = p->p_pid;
  300                         if (p->p_pgrp != NULL) {
  301                                 if (p->p_pgrp->pg_id > trypid &&
  302                                     pidchecked > p->p_pgrp->pg_id)
  303                                         pidchecked = p->p_pgrp->pg_id;
  304                                 if (p->p_session != NULL &&
  305                                     p->p_session->s_sid > trypid &&
  306                                     pidchecked > p->p_session->s_sid)
  307                                         pidchecked = p->p_session->s_sid;
  308                         }
  309                 }
  310                 if (!doingzomb) {
  311                         doingzomb = 1;
  312                         p = LIST_FIRST(&zombproc);
  313                         goto again;
  314                 }
  315         }
  316 
  317         /*
  318          * RFHIGHPID does not mess with the lastpid counter during boot.
  319          */
  320         if (flags & RFHIGHPID)
  321                 pidchecked = 0;
  322         else
  323                 lastpid = trypid;
  324 
  325         return (trypid);
  326 }
  327 
  328 static int
  329 fork_norfproc(struct thread *td, int flags)
  330 {
  331         int error;
  332         struct proc *p1;
  333 
  334         KASSERT((flags & RFPROC) == 0,
  335             ("fork_norfproc called with RFPROC set"));
  336         p1 = td->td_proc;
  337 
  338         if (((p1->p_flag & (P_HADTHREADS|P_SYSTEM)) == P_HADTHREADS) &&
  339             (flags & (RFCFDG | RFFDG))) {
  340                 PROC_LOCK(p1);
  341                 if (thread_single(p1, SINGLE_BOUNDARY)) {
  342                         PROC_UNLOCK(p1);
  343                         return (ERESTART);
  344                 }
  345                 PROC_UNLOCK(p1);
  346         }
  347 
  348         error = vm_forkproc(td, NULL, NULL, NULL, flags);
  349         if (error)
  350                 goto fail;
  351 
  352         /*
  353          * Close all file descriptors.
  354          */
  355         if (flags & RFCFDG) {
  356                 struct filedesc *fdtmp;
  357                 fdtmp = fdinit(td->td_proc->p_fd, false);
  358                 fdescfree(td);
  359                 p1->p_fd = fdtmp;
  360         }
  361 
  362         /*
  363          * Unshare file descriptors (from parent).
  364          */
  365         if (flags & RFFDG)
  366                 fdunshare(td);
  367 
  368 fail:
  369         if (((p1->p_flag & (P_HADTHREADS|P_SYSTEM)) == P_HADTHREADS) &&
  370             (flags & (RFCFDG | RFFDG))) {
  371                 PROC_LOCK(p1);
  372                 thread_single_end(p1, SINGLE_BOUNDARY);
  373                 PROC_UNLOCK(p1);
  374         }
  375         return (error);
  376 }
  377 
  378 static void
  379 do_fork(struct thread *td, struct fork_req *fr, struct proc *p2, struct thread *td2,
  380     struct vmspace *vm2, struct file *fp_procdesc)
  381 {
  382         struct proc *p1, *pptr;
  383         int trypid;
  384         struct filedesc *fd;
  385         struct filedesc_to_leader *fdtol;
  386         struct sigacts *newsigacts;
  387 
  388         sx_assert(&proctree_lock, SX_SLOCKED);
  389         sx_assert(&allproc_lock, SX_XLOCKED);
  390 
  391         p1 = td->td_proc;
  392 
  393         trypid = fork_findpid(fr->fr_flags);
  394 
  395         sx_sunlock(&proctree_lock);
  396 
  397         p2->p_state = PRS_NEW;          /* protect against others */
  398         p2->p_pid = trypid;
  399         AUDIT_ARG_PID(p2->p_pid);
  400         LIST_INSERT_HEAD(&allproc, p2, p_list);
  401         allproc_gen++;
  402         LIST_INSERT_HEAD(PIDHASH(p2->p_pid), p2, p_hash);
  403         tidhash_add(td2);
  404         PROC_LOCK(p2);
  405         PROC_LOCK(p1);
  406 
  407         sx_xunlock(&allproc_lock);
  408 
  409         bcopy(&p1->p_startcopy, &p2->p_startcopy,
  410             __rangeof(struct proc, p_startcopy, p_endcopy));
  411         pargs_hold(p2->p_args);
  412 
  413         PROC_UNLOCK(p1);
  414 
  415         bzero(&p2->p_startzero,
  416             __rangeof(struct proc, p_startzero, p_endzero));
  417 
  418         /* Tell the prison that we exist. */
  419         prison_proc_hold(p2->p_ucred->cr_prison);
  420 
  421         PROC_UNLOCK(p2);
  422 
  423         /*
  424          * Malloc things while we don't hold any locks.
  425          */
  426         if (fr->fr_flags & RFSIGSHARE)
  427                 newsigacts = NULL;
  428         else
  429                 newsigacts = sigacts_alloc();
  430 
  431         /*
  432          * Copy filedesc.
  433          */
  434         if (fr->fr_flags & RFCFDG) {
  435                 fd = fdinit(p1->p_fd, false);
  436                 fdtol = NULL;
  437         } else if (fr->fr_flags & RFFDG) {
  438                 fd = fdcopy(p1->p_fd);
  439                 fdtol = NULL;
  440         } else {
  441                 fd = fdshare(p1->p_fd);
  442                 if (p1->p_fdtol == NULL)
  443                         p1->p_fdtol = filedesc_to_leader_alloc(NULL, NULL,
  444                             p1->p_leader);
  445                 if ((fr->fr_flags & RFTHREAD) != 0) {
  446                         /*
  447                          * Shared file descriptor table, and shared
  448                          * process leaders.
  449                          */
  450                         fdtol = p1->p_fdtol;
  451                         FILEDESC_XLOCK(p1->p_fd);
  452                         fdtol->fdl_refcount++;
  453                         FILEDESC_XUNLOCK(p1->p_fd);
  454                 } else {
  455                         /* 
  456                          * Shared file descriptor table, and different
  457                          * process leaders.
  458                          */
  459                         fdtol = filedesc_to_leader_alloc(p1->p_fdtol,
  460                             p1->p_fd, p2);
  461                 }
  462         }
  463         /*
  464          * Make a proc table entry for the new process.
  465          * Start by zeroing the section of proc that is zero-initialized,
  466          * then copy the section that is copied directly from the parent.
  467          */
  468 
  469         PROC_LOCK(p2);
  470         PROC_LOCK(p1);
  471 
  472         bzero(&td2->td_startzero,
  473             __rangeof(struct thread, td_startzero, td_endzero));
  474 
  475         bcopy(&td->td_startcopy, &td2->td_startcopy,
  476             __rangeof(struct thread, td_startcopy, td_endcopy));
  477 
  478         bcopy(&p2->p_comm, &td2->td_name, sizeof(td2->td_name));
  479         td2->td_sigstk = td->td_sigstk;
  480         td2->td_flags = TDF_INMEM;
  481         td2->td_lend_user_pri = PRI_MAX;
  482 
  483 #ifdef VIMAGE
  484         td2->td_vnet = NULL;
  485         td2->td_vnet_lpush = NULL;
  486 #endif
  487 
  488         /*
  489          * Allow the scheduler to initialize the child.
  490          */
  491         thread_lock(td);
  492         sched_fork(td, td2);
  493         thread_unlock(td);
  494 
  495         /*
  496          * Duplicate sub-structures as needed.
  497          * Increase reference counts on shared objects.
  498          */
  499         p2->p_flag = P_INMEM;
  500         p2->p_flag2 = p1->p_flag2 & (P2_NOTRACE | P2_NOTRACE_EXEC);
  501         p2->p_swtick = ticks;
  502         if (p1->p_flag & P_PROFIL)
  503                 startprofclock(p2);
  504 
  505         /*
  506          * Whilst the proc lock is held, copy the VM domain data out
  507          * using the VM domain method.
  508          */
  509         vm_domain_policy_init(&p2->p_vm_dom_policy);
  510         vm_domain_policy_localcopy(&p2->p_vm_dom_policy,
  511             &p1->p_vm_dom_policy);
  512 
  513         if (fr->fr_flags & RFSIGSHARE) {
  514                 p2->p_sigacts = sigacts_hold(p1->p_sigacts);
  515         } else {
  516                 sigacts_copy(newsigacts, p1->p_sigacts);
  517                 p2->p_sigacts = newsigacts;
  518         }
  519 
  520         if (fr->fr_flags & RFTSIGZMB)
  521                 p2->p_sigparent = RFTSIGNUM(fr->fr_flags);
  522         else if (fr->fr_flags & RFLINUXTHPN)
  523                 p2->p_sigparent = SIGUSR1;
  524         else
  525                 p2->p_sigparent = SIGCHLD;
  526 
  527         p2->p_textvp = p1->p_textvp;
  528         p2->p_fd = fd;
  529         p2->p_fdtol = fdtol;
  530 
  531         if (p1->p_flag2 & P2_INHERIT_PROTECTED) {
  532                 p2->p_flag |= P_PROTECTED;
  533                 p2->p_flag2 |= P2_INHERIT_PROTECTED;
  534         }
  535 
  536         /*
  537          * p_limit is copy-on-write.  Bump its refcount.
  538          */
  539         lim_fork(p1, p2);
  540 
  541         thread_cow_get_proc(td2, p2);
  542 
  543         pstats_fork(p1->p_stats, p2->p_stats);
  544 
  545         PROC_UNLOCK(p1);
  546         PROC_UNLOCK(p2);
  547 
  548         /* Bump references to the text vnode (for procfs). */
  549         if (p2->p_textvp)
  550                 vref(p2->p_textvp);
  551 
  552         /*
  553          * Set up linkage for kernel based threading.
  554          */
  555         if ((fr->fr_flags & RFTHREAD) != 0) {
  556                 mtx_lock(&ppeers_lock);
  557                 p2->p_peers = p1->p_peers;
  558                 p1->p_peers = p2;
  559                 p2->p_leader = p1->p_leader;
  560                 mtx_unlock(&ppeers_lock);
  561                 PROC_LOCK(p1->p_leader);
  562                 if ((p1->p_leader->p_flag & P_WEXIT) != 0) {
  563                         PROC_UNLOCK(p1->p_leader);
  564                         /*
  565                          * The task leader is exiting, so process p1 is
  566                          * going to be killed shortly.  Since p1 obviously
  567                          * isn't dead yet, we know that the leader is either
  568                          * sending SIGKILL's to all the processes in this
  569                          * task or is sleeping waiting for all the peers to
  570                          * exit.  We let p1 complete the fork, but we need
  571                          * to go ahead and kill the new process p2 since
  572                          * the task leader may not get a chance to send
  573                          * SIGKILL to it.  We leave it on the list so that
  574                          * the task leader will wait for this new process
  575                          * to commit suicide.
  576                          */
  577                         PROC_LOCK(p2);
  578                         kern_psignal(p2, SIGKILL);
  579                         PROC_UNLOCK(p2);
  580                 } else
  581                         PROC_UNLOCK(p1->p_leader);
  582         } else {
  583                 p2->p_peers = NULL;
  584                 p2->p_leader = p2;
  585         }
  586 
  587         sx_xlock(&proctree_lock);
  588         PGRP_LOCK(p1->p_pgrp);
  589         PROC_LOCK(p2);
  590         PROC_LOCK(p1);
  591 
  592         /*
  593          * Preserve some more flags in subprocess.  P_PROFIL has already
  594          * been preserved.
  595          */
  596         p2->p_flag |= p1->p_flag & P_SUGID;
  597         td2->td_pflags |= (td->td_pflags & TDP_ALTSTACK) | TDP_FORKING;
  598         SESS_LOCK(p1->p_session);
  599         if (p1->p_session->s_ttyvp != NULL && p1->p_flag & P_CONTROLT)
  600                 p2->p_flag |= P_CONTROLT;
  601         SESS_UNLOCK(p1->p_session);
  602         if (fr->fr_flags & RFPPWAIT)
  603                 p2->p_flag |= P_PPWAIT;
  604 
  605         p2->p_pgrp = p1->p_pgrp;
  606         LIST_INSERT_AFTER(p1, p2, p_pglist);
  607         PGRP_UNLOCK(p1->p_pgrp);
  608         LIST_INIT(&p2->p_children);
  609         LIST_INIT(&p2->p_orphans);
  610 
  611         callout_init_mtx(&p2->p_itcallout, &p2->p_mtx, 0);
  612 
  613         /*
  614          * If PF_FORK is set, the child process inherits the
  615          * procfs ioctl flags from its parent.
  616          */
  617         if (p1->p_pfsflags & PF_FORK) {
  618                 p2->p_stops = p1->p_stops;
  619                 p2->p_pfsflags = p1->p_pfsflags;
  620         }
  621 
  622         /*
  623          * This begins the section where we must prevent the parent
  624          * from being swapped.
  625          */
  626         _PHOLD(p1);
  627         PROC_UNLOCK(p1);
  628 
  629         /*
  630          * Attach the new process to its parent.
  631          *
  632          * If RFNOWAIT is set, the newly created process becomes a child
  633          * of init.  This effectively disassociates the child from the
  634          * parent.
  635          */
  636         if ((fr->fr_flags & RFNOWAIT) != 0) {
  637                 pptr = p1->p_reaper;
  638                 p2->p_reaper = pptr;
  639         } else {
  640                 p2->p_reaper = (p1->p_treeflag & P_TREE_REAPER) != 0 ?
  641                     p1 : p1->p_reaper;
  642                 pptr = p1;
  643         }
  644         p2->p_pptr = pptr;
  645         LIST_INSERT_HEAD(&pptr->p_children, p2, p_sibling);
  646         LIST_INIT(&p2->p_reaplist);
  647         LIST_INSERT_HEAD(&p2->p_reaper->p_reaplist, p2, p_reapsibling);
  648         if (p2->p_reaper == p1)
  649                 p2->p_reapsubtree = p2->p_pid;
  650         sx_xunlock(&proctree_lock);
  651 
  652         /* Inform accounting that we have forked. */
  653         p2->p_acflag = AFORK;
  654         PROC_UNLOCK(p2);
  655 
  656 #ifdef KTRACE
  657         ktrprocfork(p1, p2);
  658 #endif
  659 
  660         /*
  661          * Finish creating the child process.  It will return via a different
  662          * execution path later.  (ie: directly into user mode)
  663          */
  664         vm_forkproc(td, p2, td2, vm2, fr->fr_flags);
  665 
  666         if (fr->fr_flags == (RFFDG | RFPROC)) {
  667                 PCPU_INC(cnt.v_forks);
  668                 PCPU_ADD(cnt.v_forkpages, p2->p_vmspace->vm_dsize +
  669                     p2->p_vmspace->vm_ssize);
  670         } else if (fr->fr_flags == (RFFDG | RFPROC | RFPPWAIT | RFMEM)) {
  671                 PCPU_INC(cnt.v_vforks);
  672                 PCPU_ADD(cnt.v_vforkpages, p2->p_vmspace->vm_dsize +
  673                     p2->p_vmspace->vm_ssize);
  674         } else if (p1 == &proc0) {
  675                 PCPU_INC(cnt.v_kthreads);
  676                 PCPU_ADD(cnt.v_kthreadpages, p2->p_vmspace->vm_dsize +
  677                     p2->p_vmspace->vm_ssize);
  678         } else {
  679                 PCPU_INC(cnt.v_rforks);
  680                 PCPU_ADD(cnt.v_rforkpages, p2->p_vmspace->vm_dsize +
  681                     p2->p_vmspace->vm_ssize);
  682         }
  683 
  684         /*
  685          * Associate the process descriptor with the process before anything
  686          * can happen that might cause that process to need the descriptor.
  687          * However, don't do this until after fork(2) can no longer fail.
  688          */
  689         if (fr->fr_flags & RFPROCDESC)
  690                 procdesc_new(p2, fr->fr_pd_flags);
  691 
  692         /*
  693          * Both processes are set up, now check if any loadable modules want
  694          * to adjust anything.
  695          */
  696         EVENTHANDLER_INVOKE(process_fork, p1, p2, fr->fr_flags);
  697 
  698         /*
  699          * Set the child start time and mark the process as being complete.
  700          */
  701         PROC_LOCK(p2);
  702         PROC_LOCK(p1);
  703         microuptime(&p2->p_stats->p_start);
  704         PROC_SLOCK(p2);
  705         p2->p_state = PRS_NORMAL;
  706         PROC_SUNLOCK(p2);
  707 
  708 #ifdef KDTRACE_HOOKS
  709         /*
  710          * Tell the DTrace fasttrap provider about the new process so that any
  711          * tracepoints inherited from the parent can be removed. We have to do
  712          * this only after p_state is PRS_NORMAL since the fasttrap module will
  713          * use pfind() later on.
  714          */
  715         if ((fr->fr_flags & RFMEM) == 0 && dtrace_fasttrap_fork)
  716                 dtrace_fasttrap_fork(p1, p2);
  717 #endif
  718         /*
  719          * Hold the process so that it cannot exit after we make it runnable,
  720          * but before we wait for the debugger.
  721          */
  722         _PHOLD(p2);
  723         if ((p1->p_flag & (P_TRACED | P_FOLLOWFORK)) == (P_TRACED |
  724             P_FOLLOWFORK)) {
  725                 /*
  726                  * Arrange for debugger to receive the fork event.
  727                  *
  728                  * We can report PL_FLAG_FORKED regardless of
  729                  * P_FOLLOWFORK settings, but it does not make a sense
  730                  * for runaway child.
  731                  */
  732                 td->td_dbgflags |= TDB_FORK;
  733                 td->td_dbg_forked = p2->p_pid;
  734                 td2->td_dbgflags |= TDB_STOPATFORK;
  735         }
  736         if (fr->fr_flags & RFPPWAIT) {
  737                 td->td_pflags |= TDP_RFPPWAIT;
  738                 td->td_rfppwait_p = p2;
  739         }
  740         PROC_UNLOCK(p2);
  741 
  742         /*
  743          * Now can be swapped.
  744          */
  745         _PRELE(p1);
  746         PROC_UNLOCK(p1);
  747 
  748         /*
  749          * Tell any interested parties about the new process.
  750          */
  751         knote_fork(p1->p_klist, p2->p_pid);
  752         SDT_PROBE3(proc, , , create, p2, p1, fr->fr_flags);
  753 
  754         if (fr->fr_flags & RFPROCDESC) {
  755                 procdesc_finit(p2->p_procdesc, fp_procdesc);
  756                 fdrop(fp_procdesc, td);
  757         }
  758 
  759         if ((fr->fr_flags & RFSTOPPED) == 0) {
  760                 /*
  761                  * If RFSTOPPED not requested, make child runnable and
  762                  * add to run queue.
  763                  */
  764                 thread_lock(td2);
  765                 TD_SET_CAN_RUN(td2);
  766                 sched_add(td2, SRQ_BORING);
  767                 thread_unlock(td2);
  768                 if (fr->fr_pidp != NULL)
  769                         *fr->fr_pidp = p2->p_pid;
  770         } else {
  771                 *fr->fr_procp = p2;
  772         }
  773 
  774         PROC_LOCK(p2);
  775         /*
  776          * Wait until debugger is attached to child.
  777          */
  778         while (td2->td_proc == p2 && (td2->td_dbgflags & TDB_STOPATFORK) != 0)
  779                 cv_wait(&p2->p_dbgwait, &p2->p_mtx);
  780         _PRELE(p2);
  781         racct_proc_fork_done(p2);
  782         PROC_UNLOCK(p2);
  783 }
  784 
  785 int
  786 fork1(struct thread *td, struct fork_req *fr)
  787 {
  788         struct proc *p1, *newproc;
  789         struct thread *td2;
  790         struct vmspace *vm2;
  791         struct file *fp_procdesc;
  792         vm_ooffset_t mem_charged;
  793         int error, nprocs_new, ok;
  794         static int curfail;
  795         static struct timeval lastfail;
  796         int flags, pages;
  797 
  798         flags = fr->fr_flags;
  799         pages = fr->fr_pages;
  800 
  801         if ((flags & RFSTOPPED) != 0)
  802                 MPASS(fr->fr_procp != NULL && fr->fr_pidp == NULL);
  803         else
  804                 MPASS(fr->fr_procp == NULL);
  805 
  806         /* Check for the undefined or unimplemented flags. */
  807         if ((flags & ~(RFFLAGS | RFTSIGFLAGS(RFTSIGMASK))) != 0)
  808                 return (EINVAL);
  809 
  810         /* Signal value requires RFTSIGZMB. */
  811         if ((flags & RFTSIGFLAGS(RFTSIGMASK)) != 0 && (flags & RFTSIGZMB) == 0)
  812                 return (EINVAL);
  813 
  814         /* Can't copy and clear. */
  815         if ((flags & (RFFDG|RFCFDG)) == (RFFDG|RFCFDG))
  816                 return (EINVAL);
  817 
  818         /* Check the validity of the signal number. */
  819         if ((flags & RFTSIGZMB) != 0 && (u_int)RFTSIGNUM(flags) > _SIG_MAXSIG)
  820                 return (EINVAL);
  821 
  822         if ((flags & RFPROCDESC) != 0) {
  823                 /* Can't not create a process yet get a process descriptor. */
  824                 if ((flags & RFPROC) == 0)
  825                         return (EINVAL);
  826 
  827                 /* Must provide a place to put a procdesc if creating one. */
  828                 if (fr->fr_pd_fd == NULL)
  829                         return (EINVAL);
  830 
  831                 /* Check if we are using supported flags. */
  832                 if ((fr->fr_pd_flags & ~PD_ALLOWED_AT_FORK) != 0)
  833                         return (EINVAL);
  834         }
  835 
  836         p1 = td->td_proc;
  837 
  838         /*
  839          * Here we don't create a new process, but we divorce
  840          * certain parts of a process from itself.
  841          */
  842         if ((flags & RFPROC) == 0) {
  843                 if (fr->fr_procp != NULL)
  844                         *fr->fr_procp = NULL;
  845                 else if (fr->fr_pidp != NULL)
  846                         *fr->fr_pidp = 0;
  847                 return (fork_norfproc(td, flags));
  848         }
  849 
  850         fp_procdesc = NULL;
  851         newproc = NULL;
  852         vm2 = NULL;
  853 
  854         /*
  855          * Increment the nprocs resource before allocations occur.
  856          * Although process entries are dynamically created, we still
  857          * keep a global limit on the maximum number we will
  858          * create. There are hard-limits as to the number of processes
  859          * that can run, established by the KVA and memory usage for
  860          * the process data.
  861          *
  862          * Don't allow a nonprivileged user to use the last ten
  863          * processes; don't let root exceed the limit.
  864          */
  865         nprocs_new = atomic_fetchadd_int(&nprocs, 1) + 1;
  866         if ((nprocs_new >= maxproc - 10 && priv_check_cred(td->td_ucred,
  867             PRIV_MAXPROC, 0) != 0) || nprocs_new >= maxproc) {
  868                 error = EAGAIN;
  869                 sx_xlock(&allproc_lock);
  870                 if (ppsratecheck(&lastfail, &curfail, 1)) {
  871                         printf("maxproc limit exceeded by uid %u (pid %d); "
  872                             "see tuning(7) and login.conf(5)\n",
  873                             td->td_ucred->cr_ruid, p1->p_pid);
  874                 }
  875                 sx_xunlock(&allproc_lock);
  876                 goto fail2;
  877         }
  878 
  879         /*
  880          * If required, create a process descriptor in the parent first; we
  881          * will abandon it if something goes wrong. We don't finit() until
  882          * later.
  883          */
  884         if (flags & RFPROCDESC) {
  885                 error = procdesc_falloc(td, &fp_procdesc, fr->fr_pd_fd,
  886                     fr->fr_pd_flags, fr->fr_pd_fcaps);
  887                 if (error != 0)
  888                         goto fail2;
  889         }
  890 
  891         mem_charged = 0;
  892         if (pages == 0)
  893                 pages = kstack_pages;
  894         /* Allocate new proc. */
  895         newproc = uma_zalloc(proc_zone, M_WAITOK);
  896         td2 = FIRST_THREAD_IN_PROC(newproc);
  897         if (td2 == NULL) {
  898                 td2 = thread_alloc(pages);
  899                 if (td2 == NULL) {
  900                         error = ENOMEM;
  901                         goto fail2;
  902                 }
  903                 proc_linkup(newproc, td2);
  904         } else {
  905                 if (td2->td_kstack == 0 || td2->td_kstack_pages != pages) {
  906                         if (td2->td_kstack != 0)
  907                                 vm_thread_dispose(td2);
  908                         if (!thread_alloc_stack(td2, pages)) {
  909                                 error = ENOMEM;
  910                                 goto fail2;
  911                         }
  912                 }
  913         }
  914 
  915         if ((flags & RFMEM) == 0) {
  916                 vm2 = vmspace_fork(p1->p_vmspace, &mem_charged);
  917                 if (vm2 == NULL) {
  918                         error = ENOMEM;
  919                         goto fail2;
  920                 }
  921                 if (!swap_reserve(mem_charged)) {
  922                         /*
  923                          * The swap reservation failed. The accounting
  924                          * from the entries of the copied vm2 will be
  925                          * subtracted in vmspace_free(), so force the
  926                          * reservation there.
  927                          */
  928                         swap_reserve_force(mem_charged);
  929                         error = ENOMEM;
  930                         goto fail2;
  931                 }
  932         } else
  933                 vm2 = NULL;
  934 
  935         /*
  936          * XXX: This is ugly; when we copy resource usage, we need to bump
  937          *      per-cred resource counters.
  938          */
  939         proc_set_cred_init(newproc, crhold(td->td_ucred));
  940 
  941         /*
  942          * Initialize resource accounting for the child process.
  943          */
  944         error = racct_proc_fork(p1, newproc);
  945         if (error != 0) {
  946                 error = EAGAIN;
  947                 goto fail1;
  948         }
  949 
  950 #ifdef MAC
  951         mac_proc_init(newproc);
  952 #endif
  953         newproc->p_klist = knlist_alloc(&newproc->p_mtx);
  954         STAILQ_INIT(&newproc->p_ktr);
  955 
  956         /* We have to lock the process tree while we look for a pid. */
  957         sx_slock(&proctree_lock);
  958         sx_xlock(&allproc_lock);
  959 
  960         /*
  961          * Increment the count of procs running with this uid. Don't allow
  962          * a nonprivileged user to exceed their current limit.
  963          *
  964          * XXXRW: Can we avoid privilege here if it's not needed?
  965          */
  966         error = priv_check_cred(td->td_ucred, PRIV_PROC_LIMIT, 0);
  967         if (error == 0)
  968                 ok = chgproccnt(td->td_ucred->cr_ruidinfo, 1, 0);
  969         else {
  970                 ok = chgproccnt(td->td_ucred->cr_ruidinfo, 1,
  971                     lim_cur(td, RLIMIT_NPROC));
  972         }
  973         if (ok) {
  974                 do_fork(td, fr, newproc, td2, vm2, fp_procdesc);
  975                 return (0);
  976         }
  977 
  978         error = EAGAIN;
  979         sx_sunlock(&proctree_lock);
  980         sx_xunlock(&allproc_lock);
  981 #ifdef MAC
  982         mac_proc_destroy(newproc);
  983 #endif
  984         racct_proc_exit(newproc);
  985 fail1:
  986         crfree(newproc->p_ucred);
  987         newproc->p_ucred = NULL;
  988 fail2:
  989         if (vm2 != NULL)
  990                 vmspace_free(vm2);
  991         uma_zfree(proc_zone, newproc);
  992         if ((flags & RFPROCDESC) != 0 && fp_procdesc != NULL) {
  993                 fdclose(td, fp_procdesc, *fr->fr_pd_fd);
  994                 fdrop(fp_procdesc, td);
  995         }
  996         atomic_add_int(&nprocs, -1);
  997         pause("fork", hz / 2);
  998         return (error);
  999 }
 1000 
 1001 /*
 1002  * Handle the return of a child process from fork1().  This function
 1003  * is called from the MD fork_trampoline() entry point.
 1004  */
 1005 void
 1006 fork_exit(void (*callout)(void *, struct trapframe *), void *arg,
 1007     struct trapframe *frame)
 1008 {
 1009         struct proc *p;
 1010         struct thread *td;
 1011         struct thread *dtd;
 1012 
 1013         td = curthread;
 1014         p = td->td_proc;
 1015         KASSERT(p->p_state == PRS_NORMAL, ("executing process is still new"));
 1016 
 1017         CTR4(KTR_PROC, "fork_exit: new thread %p (td_sched %p, pid %d, %s)",
 1018             td, td_get_sched(td), p->p_pid, td->td_name);
 1019 
 1020         sched_fork_exit(td);
 1021         /*
 1022         * Processes normally resume in mi_switch() after being
 1023         * cpu_switch()'ed to, but when children start up they arrive here
 1024         * instead, so we must do much the same things as mi_switch() would.
 1025         */
 1026         if ((dtd = PCPU_GET(deadthread))) {
 1027                 PCPU_SET(deadthread, NULL);
 1028                 thread_stash(dtd);
 1029         }
 1030         thread_unlock(td);
 1031 
 1032         /*
 1033          * cpu_fork_kthread_handler intercepts this function call to
 1034          * have this call a non-return function to stay in kernel mode.
 1035          * initproc has its own fork handler, but it does return.
 1036          */
 1037         KASSERT(callout != NULL, ("NULL callout in fork_exit"));
 1038         callout(arg, frame);
 1039 
 1040         /*
 1041          * Check if a kernel thread misbehaved and returned from its main
 1042          * function.
 1043          */
 1044         if (p->p_flag & P_KPROC) {
 1045                 printf("Kernel thread \"%s\" (pid %d) exited prematurely.\n",
 1046                     td->td_name, p->p_pid);
 1047                 kthread_exit();
 1048         }
 1049         mtx_assert(&Giant, MA_NOTOWNED);
 1050 
 1051         if (p->p_sysent->sv_schedtail != NULL)
 1052                 (p->p_sysent->sv_schedtail)(td);
 1053         td->td_pflags &= ~TDP_FORKING;
 1054 }
 1055 
 1056 /*
 1057  * Simplified back end of syscall(), used when returning from fork()
 1058  * directly into user mode.  This function is passed in to fork_exit()
 1059  * as the first parameter and is called when returning to a new
 1060  * userland process.
 1061  */
 1062 void
 1063 fork_return(struct thread *td, struct trapframe *frame)
 1064 {
 1065         struct proc *p, *dbg;
 1066 
 1067         p = td->td_proc;
 1068         if (td->td_dbgflags & TDB_STOPATFORK) {
 1069                 sx_xlock(&proctree_lock);
 1070                 PROC_LOCK(p);
 1071                 if ((p->p_pptr->p_flag & (P_TRACED | P_FOLLOWFORK)) ==
 1072                     (P_TRACED | P_FOLLOWFORK)) {
 1073                         /*
 1074                          * If debugger still wants auto-attach for the
 1075                          * parent's children, do it now.
 1076                          */
 1077                         dbg = p->p_pptr->p_pptr;
 1078                         p->p_flag |= P_TRACED;
 1079                         p->p_oppid = p->p_pptr->p_pid;
 1080                         CTR2(KTR_PTRACE,
 1081                     "fork_return: attaching to new child pid %d: oppid %d",
 1082                             p->p_pid, p->p_oppid);
 1083                         proc_reparent(p, dbg);
 1084                         sx_xunlock(&proctree_lock);
 1085                         td->td_dbgflags |= TDB_CHILD | TDB_SCX;
 1086                         ptracestop(td, SIGSTOP);
 1087                         td->td_dbgflags &= ~(TDB_CHILD | TDB_SCX);
 1088                 } else {
 1089                         /*
 1090                          * ... otherwise clear the request.
 1091                          */
 1092                         sx_xunlock(&proctree_lock);
 1093                         td->td_dbgflags &= ~TDB_STOPATFORK;
 1094                         cv_broadcast(&p->p_dbgwait);
 1095                 }
 1096                 PROC_UNLOCK(p);
 1097         } else if (p->p_flag & P_TRACED || td->td_dbgflags & TDB_BORN) {
 1098                 /*
 1099                  * This is the start of a new thread in a traced
 1100                  * process.  Report a system call exit event.
 1101                  */
 1102                 PROC_LOCK(p);
 1103                 td->td_dbgflags |= TDB_SCX;
 1104                 _STOPEVENT(p, S_SCX, td->td_dbg_sc_code);
 1105                 if ((p->p_stops & S_PT_SCX) != 0 ||
 1106                     (td->td_dbgflags & TDB_BORN) != 0)
 1107                         ptracestop(td, SIGTRAP);
 1108                 td->td_dbgflags &= ~(TDB_SCX | TDB_BORN);
 1109                 PROC_UNLOCK(p);
 1110         }
 1111 
 1112         userret(td, frame);
 1113 
 1114 #ifdef KTRACE
 1115         if (KTRPOINT(td, KTR_SYSRET))
 1116                 ktrsysret(SYS_fork, 0, 0);
 1117 #endif
 1118 }

Cache object: d099e23109f930a7dd1ca614fe294e8b


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