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-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

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

Cache object: 24fe1f75241f0d5af8b90a59b58a2399


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