sys/kern/kern_fork.c

   1 /*      $NetBSD: kern_fork.c,v 1.174 2009/10/21 21:12:06 rmind Exp $    */
   2
   3 /*-
   4  * Copyright (c) 1999, 2001, 2004, 2006, 2007, 2008 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
   9  * NASA Ames Research Center, by Charles M. Hannum, and by Andrew Doran.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30  * POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 /*
  34  * Copyright (c) 1982, 1986, 1989, 1991, 1993
  35  *      The Regents of the University of California.  All rights reserved.
  36  * (c) UNIX System Laboratories, Inc.
  37  * All or some portions of this file are derived from material licensed
  38  * to the University of California by American Telephone and Telegraph
  39  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  40  * the permission of UNIX System Laboratories, Inc.
  41  *
  42  * Redistribution and use in source and binary forms, with or without
  43  * modification, are permitted provided that the following conditions
  44  * are met:
  45  * 1. Redistributions of source code must retain the above copyright
  46  *    notice, this list of conditions and the following disclaimer.
  47  * 2. Redistributions in binary form must reproduce the above copyright
  48  *    notice, this list of conditions and the following disclaimer in the
  49  *    documentation and/or other materials provided with the distribution.
  50  * 3. Neither the name of the University nor the names of its contributors
  51  *    may be used to endorse or promote products derived from this software
  52  *    without specific prior written permission.
  53  *
  54  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  55  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  56  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  57  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  58  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  59  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  60  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  61  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  62  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  63  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  64  * SUCH DAMAGE.
  65  *
  66  *      @(#)kern_fork.c 8.8 (Berkeley) 2/14/95
  67  */
  68
  69 #include <sys/cdefs.h>
  70 __KERNEL_RCSID(0, "$NetBSD: kern_fork.c,v 1.174 2009/10/21 21:12:06 rmind Exp $");
  71
  72 #include "opt_ktrace.h"
  73
  74 #include <sys/param.h>
  75 #include <sys/systm.h>
  76 #include <sys/filedesc.h>
  77 #include <sys/kernel.h>
  78 #include <sys/pool.h>
  79 #include <sys/mount.h>
  80 #include <sys/proc.h>
  81 #include <sys/ras.h>
  82 #include <sys/resourcevar.h>
  83 #include <sys/vnode.h>
  84 #include <sys/file.h>
  85 #include <sys/acct.h>
  86 #include <sys/ktrace.h>
  87 #include <sys/vmmeter.h>
  88 #include <sys/sched.h>
  89 #include <sys/signalvar.h>
  90 #include <sys/kauth.h>
  91 #include <sys/atomic.h>
  92 #include <sys/syscallargs.h>
  93 #include <sys/uidinfo.h>
  94
  95 #include <uvm/uvm_extern.h>
  96
  97 u_int   nprocs = 1;             /* process 0 */
  98
  99 /*
 100  * Number of ticks to sleep if fork() would fail due to process hitting
 101  * limits. Exported in miliseconds to userland via sysctl.
 102  */
 103 int     forkfsleep = 0;
 104
 105 /*ARGSUSED*/
 106 int
 107 sys_fork(struct lwp *l, const void *v, register_t *retval)
 108 {
 109
 110         return (fork1(l, 0, SIGCHLD, NULL, 0, NULL, NULL, retval, NULL));
 111 }
 112
 113 /*
 114  * vfork(2) system call compatible with 4.4BSD (i.e. BSD with Mach VM).
 115  * Address space is not shared, but parent is blocked until child exit.
 116  */
 117 /*ARGSUSED*/
 118 int
 119 sys_vfork(struct lwp *l, const void *v, register_t *retval)
 120 {
 121
 122         return (fork1(l, FORK_PPWAIT, SIGCHLD, NULL, 0, NULL, NULL,
 123             retval, NULL));
 124 }
 125
 126 /*
 127  * New vfork(2) system call for NetBSD, which implements original 3BSD vfork(2)
 128  * semantics.  Address space is shared, and parent is blocked until child exit.
 129  */
 130 /*ARGSUSED*/
 131 int
 132 sys___vfork14(struct lwp *l, const void *v, register_t *retval)
 133 {
 134
 135         return (fork1(l, FORK_PPWAIT|FORK_SHAREVM, SIGCHLD, NULL, 0,
 136             NULL, NULL, retval, NULL));
 137 }
 138
 139 /*
 140  * Linux-compatible __clone(2) system call.
 141  */
 142 int
 143 sys___clone(struct lwp *l, const struct sys___clone_args *uap, register_t *retval)
 144 {
 145         /* {
 146                 syscallarg(int) flags;
 147                 syscallarg(void *) stack;
 148         } */
 149         int flags, sig;
 150
 151         /*
 152          * We don't support the CLONE_PID or CLONE_PTRACE flags.
 153          */
 154         if (SCARG(uap, flags) & (CLONE_PID|CLONE_PTRACE))
 155                 return (EINVAL);
 156
 157         /*
 158          * Linux enforces CLONE_VM with CLONE_SIGHAND, do same.
 159          */
 160         if (SCARG(uap, flags) & CLONE_SIGHAND
 161             && (SCARG(uap, flags) & CLONE_VM) == 0)
 162                 return (EINVAL);
 163
 164         flags = 0;
 165
 166         if (SCARG(uap, flags) & CLONE_VM)
 167                 flags |= FORK_SHAREVM;
 168         if (SCARG(uap, flags) & CLONE_FS)
 169                 flags |= FORK_SHARECWD;
 170         if (SCARG(uap, flags) & CLONE_FILES)
 171                 flags |= FORK_SHAREFILES;
 172         if (SCARG(uap, flags) & CLONE_SIGHAND)
 173                 flags |= FORK_SHARESIGS;
 174         if (SCARG(uap, flags) & CLONE_VFORK)
 175                 flags |= FORK_PPWAIT;
 176
 177         sig = SCARG(uap, flags) & CLONE_CSIGNAL;
 178         if (sig < 0 || sig >= _NSIG)
 179                 return (EINVAL);
 180
 181         /*
 182          * Note that the Linux API does not provide a portable way of
 183          * specifying the stack area; the caller must know if the stack
 184          * grows up or down.  So, we pass a stack size of 0, so that the
 185          * code that makes this adjustment is a noop.
 186          */
 187         return (fork1(l, flags, sig, SCARG(uap, stack), 0,
 188             NULL, NULL, retval, NULL));
 189 }
 190
 191 /* print the 'table full' message once per 10 seconds */
 192 struct timeval fork_tfmrate = { 10, 0 };
 193
 194 /*
 195  * General fork call.  Note that another LWP in the process may call exec()
 196  * or exit() while we are forking.  It's safe to continue here, because
 197  * neither operation will complete until all LWPs have exited the process.
 198  */
 199 int
 200 fork1(struct lwp *l1, int flags, int exitsig, void *stack, size_t stacksize,
 201     void (*func)(void *), void *arg, register_t *retval,
 202     struct proc **rnewprocp)
 203 {
 204         struct proc     *p1, *p2, *parent;
 205         struct plimit   *p1_lim;
 206         uid_t           uid;
 207         struct lwp      *l2;
 208         int             count;
 209         vaddr_t         uaddr;
 210         int             tmp;
 211         int             tnprocs;
 212         int             error = 0;
 213
 214         p1 = l1->l_proc;
 215         uid = kauth_cred_getuid(l1->l_cred);
 216         tnprocs = atomic_inc_uint_nv(&nprocs);
 217
 218         /*
 219          * Although process entries are dynamically created, we still keep
 220          * a global limit on the maximum number we will create.
 221          */
 222         if (__predict_false(tnprocs >= maxproc))
 223                 error = -1;
 224         else
 225                 error = kauth_authorize_process(l1->l_cred,
 226                     KAUTH_PROCESS_FORK, p1, KAUTH_ARG(tnprocs), NULL, NULL);
 227
 228         if (error) {
 229                 static struct timeval lasttfm;
 230                 atomic_dec_uint(&nprocs);
 231                 if (ratecheck(&lasttfm, &fork_tfmrate))
 232                         tablefull("proc", "increase kern.maxproc or NPROC");
 233                 if (forkfsleep)
 234                         kpause("forkmx", false, forkfsleep, NULL);
 235                 return (EAGAIN);
 236         }
 237
 238         /*
 239          * Enforce limits.
 240          */
 241         count = chgproccnt(uid, 1);
 242         if (kauth_authorize_generic(l1->l_cred, KAUTH_GENERIC_ISSUSER, NULL) !=
 243             0 && __predict_false(count > p1->p_rlimit[RLIMIT_NPROC].rlim_cur)) {
 244                 (void)chgproccnt(uid, -1);
 245                 atomic_dec_uint(&nprocs);
 246                 if (forkfsleep)
 247                         kpause("forkulim", false, forkfsleep, NULL);
 248                 return (EAGAIN);
 249         }
 250
 251         /*
 252          * Allocate virtual address space for the U-area now, while it
 253          * is still easy to abort the fork operation if we're out of
 254          * kernel virtual address space.
 255          */
 256         uaddr = uvm_uarea_alloc();
 257         if (__predict_false(uaddr == 0)) {
 258                 (void)chgproccnt(uid, -1);
 259                 atomic_dec_uint(&nprocs);
 260                 return (ENOMEM);
 261         }
 262
 263         /*
 264          * We are now committed to the fork.  From here on, we may
 265          * block on resources, but resource allocation may NOT fail.
 266          */
 267
 268         /* Allocate new proc. */
 269         p2 = proc_alloc();
 270
 271         /*
 272          * Make a proc table entry for the new process.
 273          * Start by zeroing the section of proc that is zero-initialized,
 274          * then copy the section that is copied directly from the parent.
 275          */
 276         memset(&p2->p_startzero, 0,
 277             (unsigned) ((char *)&p2->p_endzero - (char *)&p2->p_startzero));
 278         memcpy(&p2->p_startcopy, &p1->p_startcopy,
 279             (unsigned) ((char *)&p2->p_endcopy - (char *)&p2->p_startcopy));
 280
 281         CIRCLEQ_INIT(&p2->p_sigpend.sp_info);
 282
 283         LIST_INIT(&p2->p_lwps);
 284         LIST_INIT(&p2->p_sigwaiters);
 285
 286         /*
 287          * Duplicate sub-structures as needed.
 288          * Increase reference counts on shared objects.
 289          * Inherit flags we want to keep.  The flags related to SIGCHLD
 290          * handling are important in order to keep a consistent behaviour
 291          * for the child after the fork.
 292          */
 293         p2->p_flag = p1->p_flag & (PK_SUGID | PK_NOCLDWAIT | PK_CLDSIGIGN);
 294         p2->p_emul = p1->p_emul;
 295         p2->p_execsw = p1->p_execsw;
 296
 297         if (flags & FORK_SYSTEM) {
 298                 /*
 299                  * Mark it as a system process.  Set P_NOCLDWAIT so that
 300                  * children are reparented to init(8) when they exit.
 301                  * init(8) can easily wait them out for us.
 302                  */
 303                 p2->p_flag |= (PK_SYSTEM | PK_NOCLDWAIT);
 304         }
 305
 306         mutex_init(&p2->p_stmutex, MUTEX_DEFAULT, IPL_HIGH);
 307         mutex_init(&p2->p_auxlock, MUTEX_DEFAULT, IPL_NONE);
 308         rw_init(&p2->p_reflock);
 309         cv_init(&p2->p_waitcv, "wait");
 310         cv_init(&p2->p_lwpcv, "lwpwait");
 311
 312         /*
 313          * Share a lock between the processes if they are to share signal
 314          * state: we must synchronize access to it.
 315          */
 316         if (flags & FORK_SHARESIGS) {
 317                 p2->p_lock = p1->p_lock;
 318                 mutex_obj_hold(p1->p_lock);
 319         } else
 320                 p2->p_lock = mutex_obj_alloc(MUTEX_DEFAULT, IPL_NONE);
 321
 322         kauth_proc_fork(p1, p2);
 323
 324         p2->p_raslist = NULL;
 325 #if defined(__HAVE_RAS)
 326         ras_fork(p1, p2);
 327 #endif
 328
 329         /* bump references to the text vnode (for procfs) */
 330         p2->p_textvp = p1->p_textvp;
 331         if (p2->p_textvp)
 332                 vref(p2->p_textvp);
 333
 334         if (flags & FORK_SHAREFILES)
 335                 fd_share(p2);
 336         else if (flags & FORK_CLEANFILES)
 337                 p2->p_fd = fd_init(NULL);
 338         else
 339                 p2->p_fd = fd_copy();
 340
 341         if (flags & FORK_SHARECWD)
 342                 cwdshare(p2);
 343         else
 344                 p2->p_cwdi = cwdinit();
 345
 346         /*
 347          * p_limit (rlimit stuff) is usually copy-on-write, so we just need
 348          * to bump pl_refcnt.
 349          * However in some cases (see compat irix, and plausibly from clone)
 350          * the parent and child share limits - in which case nothing else
 351          * must have a copy of the limits (PL_SHAREMOD is set).
 352          */
 353         if (__predict_false(flags & FORK_SHARELIMIT))
 354                 lim_privatise(p1, 1);
 355         p1_lim = p1->p_limit;
 356         if (p1_lim->pl_flags & PL_WRITEABLE && !(flags & FORK_SHARELIMIT))
 357                 p2->p_limit = lim_copy(p1_lim);
 358         else {
 359                 lim_addref(p1_lim);
 360                 p2->p_limit = p1_lim;
 361         }
 362
 363         p2->p_lflag = ((flags & FORK_PPWAIT) ? PL_PPWAIT : 0);
 364         p2->p_sflag = 0;
 365         p2->p_slflag = 0;
 366         parent = (flags & FORK_NOWAIT) ? initproc : p1;
 367         p2->p_pptr = parent;
 368         p2->p_ppid = parent->p_pid;
 369         LIST_INIT(&p2->p_children);
 370
 371         p2->p_aio = NULL;
 372
 373 #ifdef KTRACE
 374         /*
 375          * Copy traceflag and tracefile if enabled.
 376          * If not inherited, these were zeroed above.
 377          */
 378         if (p1->p_traceflag & KTRFAC_INHERIT) {
 379                 mutex_enter(&ktrace_lock);
 380                 p2->p_traceflag = p1->p_traceflag;
 381                 if ((p2->p_tracep = p1->p_tracep) != NULL)
 382                         ktradref(p2);
 383                 mutex_exit(&ktrace_lock);
 384         }
 385 #endif
 386
 387         /*
 388          * Create signal actions for the child process.
 389          */
 390         p2->p_sigacts = sigactsinit(p1, flags & FORK_SHARESIGS);
 391         mutex_enter(p1->p_lock);
 392         p2->p_sflag |=
 393             (p1->p_sflag & (PS_STOPFORK | PS_STOPEXEC | PS_NOCLDSTOP));
 394         sched_proc_fork(p1, p2);
 395         mutex_exit(p1->p_lock);
 396
 397         p2->p_stflag = p1->p_stflag;
 398
 399         /*
 400          * p_stats.
 401          * Copy parts of p_stats, and zero out the rest.
 402          */
 403         p2->p_stats = pstatscopy(p1->p_stats);
 404
 405         /*
 406          * If emulation has process fork hook, call it now.
 407          */
 408         if (p2->p_emul->e_proc_fork)
 409                 (*p2->p_emul->e_proc_fork)(p2, p1, flags);
 410
 411         /*
 412          * ...and finally, any other random fork hooks that subsystems
 413          * might have registered.
 414          */
 415         doforkhooks(p2, p1);
 416
 417         uvm_proc_fork(p1, p2, (flags & FORK_SHAREVM) ? true : false);
 418
 419         /*
 420          * Finish creating the child process.
 421          * It will return through a different path later.
 422          */
 423         lwp_create(l1, p2, uaddr, (flags & FORK_PPWAIT) ? LWP_VFORK : 0,
 424             stack, stacksize, (func != NULL) ? func : child_return, arg, &l2,
 425             l1->l_class);
 426
 427         /*
 428          * It's now safe for the scheduler and other processes to see the
 429          * child process.
 430          */
 431         mutex_enter(proc_lock);
 432
 433         if (p1->p_session->s_ttyvp != NULL && p1->p_lflag & PL_CONTROLT)
 434                 p2->p_lflag |= PL_CONTROLT;
 435
 436         LIST_INSERT_HEAD(&parent->p_children, p2, p_sibling);
 437         p2->p_exitsig = exitsig;                /* signal for parent on exit */
 438
 439         LIST_INSERT_AFTER(p1, p2, p_pglist);
 440         LIST_INSERT_HEAD(&allproc, p2, p_list);
 441
 442         p2->p_trace_enabled = trace_is_enabled(p2);
 443 #ifdef __HAVE_SYSCALL_INTERN
 444         (*p2->p_emul->e_syscall_intern)(p2);
 445 #endif
 446
 447         /*
 448          * Update stats now that we know the fork was successful.
 449          */
 450         uvmexp.forks++;
 451         if (flags & FORK_PPWAIT)
 452                 uvmexp.forks_ppwait++;
 453         if (flags & FORK_SHAREVM)
 454                 uvmexp.forks_sharevm++;
 455
 456         /*
 457          * Pass a pointer to the new process to the caller.
 458          */
 459         if (rnewprocp != NULL)
 460                 *rnewprocp = p2;
 461
 462         if (ktrpoint(KTR_EMUL))
 463                 p2->p_traceflag |= KTRFAC_TRC_EMUL;
 464
 465         /*
 466          * Notify any interested parties about the new process.
 467          */
 468         if (!SLIST_EMPTY(&p1->p_klist)) {
 469                 mutex_exit(proc_lock);
 470                 KNOTE(&p1->p_klist, NOTE_FORK | p2->p_pid);
 471                 mutex_enter(proc_lock);
 472         }
 473
 474         /*
 475          * Make child runnable, set start time, and add to run queue except
 476          * if the parent requested the child to start in SSTOP state.
 477          */
 478         tmp = (p2->p_userret != NULL ? LW_WUSERRET : 0);
 479         mutex_enter(p2->p_lock);
 480
 481         /*
 482          * Start profiling.
 483          */
 484         if ((p2->p_stflag & PST_PROFIL) != 0) {
 485                 mutex_spin_enter(&p2->p_stmutex);
 486                 startprofclock(p2);
 487                 mutex_spin_exit(&p2->p_stmutex);
 488         }
 489
 490         getmicrotime(&p2->p_stats->p_start);
 491         p2->p_acflag = AFORK;
 492         lwp_lock(l2);
 493         if (p2->p_sflag & PS_STOPFORK) {
 494                 p2->p_nrlwps = 0;
 495                 p2->p_stat = SSTOP;
 496                 p2->p_waited = 0;
 497                 p1->p_nstopchild++;
 498                 l2->l_stat = LSSTOP;
 499                 l2->l_flag |= tmp;
 500                 lwp_unlock(l2);
 501         } else {
 502                 p2->p_nrlwps = 1;
 503                 p2->p_stat = SACTIVE;
 504                 l2->l_stat = LSRUN;
 505                 l2->l_flag |= tmp;
 506                 sched_enqueue(l2, false);
 507                 lwp_unlock(l2);
 508         }
 509
 510         mutex_exit(p2->p_lock);
 511
 512         /*
 513          * Preserve synchronization semantics of vfork.  If waiting for
 514          * child to exec or exit, set PL_PPWAIT on child, and sleep on our
 515          * proc (in case of exit).
 516          */
 517         while (p2->p_lflag & PL_PPWAIT)
 518                 cv_wait(&p1->p_waitcv, proc_lock);
 519
 520         mutex_exit(proc_lock);
 521
 522         /*
 523          * Return child pid to parent process,
 524          * marking us as parent via retval[1].
 525          */
 526         if (retval != NULL) {
 527                 retval[0] = p2->p_pid;
 528                 retval[1] = 0;
 529         }
 530
 531         return (0);
 532 }