sys/kern/kern_fork.c

   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  * 3. All advertising materials mentioning features or use of this software
  19  *    must display the following acknowledgement:
  20  *      This product includes software developed by the University of
  21  *      California, Berkeley and its contributors.
  22  * 4. Neither the name of the University nor the names of its contributors
  23  *    may be used to endorse or promote products derived from this software
  24  *    without specific prior written permission.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  36  * SUCH DAMAGE.
  37  *
  38  *      @(#)kern_fork.c 8.6 (Berkeley) 4/8/94
  39  * $FreeBSD$
  40  */
  41
  42 #include "opt_ktrace.h"
  43
  44 #include <sys/param.h>
  45 #include <sys/systm.h>
  46 #include <sys/sysproto.h>
  47 #include <sys/filedesc.h>
  48 #include <sys/kernel.h>
  49 #include <sys/sysctl.h>
  50 #include <sys/lock.h>
  51 #include <sys/malloc.h>
  52 #include <sys/mutex.h>
  53 #include <sys/proc.h>
  54 #include <sys/resourcevar.h>
  55 #include <sys/syscall.h>
  56 #include <sys/vnode.h>
  57 #include <sys/acct.h>
  58 #include <sys/ktr.h>
  59 #include <sys/ktrace.h>
  60 #include <sys/kthread.h>
  61 #include <sys/unistd.h>
  62 #include <sys/jail.h>
  63 #include <sys/sx.h>
  64
  65 #include <vm/vm.h>
  66 #include <vm/pmap.h>
  67 #include <vm/vm_map.h>
  68 #include <vm/vm_extern.h>
  69 #include <vm/vm_zone.h>
  70
  71 #include <sys/vmmeter.h>
  72 #include <sys/user.h>
  73
  74 static MALLOC_DEFINE(M_ATFORK, "atfork", "atfork callback");
  75
  76 /*
  77  * These are the stuctures used to create a callout list for things to do
  78  * when forking a process
  79  */
  80 struct forklist {
  81         forklist_fn function;
  82         TAILQ_ENTRY(forklist) next;
  83 };
  84
  85 static struct sx fork_list_lock;
  86
  87 TAILQ_HEAD(forklist_head, forklist);
  88 static struct forklist_head fork_list = TAILQ_HEAD_INITIALIZER(fork_list);
  89
  90 #ifndef _SYS_SYSPROTO_H_
  91 struct fork_args {
  92         int     dummy;
  93 };
  94 #endif
  95
  96 static void
  97 init_fork_list(void *data __unused)
  98 {
  99
 100         sx_init(&fork_list_lock, "fork list");
 101 }
 102 SYSINIT(fork_list, SI_SUB_INTRINSIC, SI_ORDER_ANY, init_fork_list, NULL);
 103
 104 /*
 105  * MPSAFE
 106  */
 107 /* ARGSUSED */
 108 int
 109 fork(td, uap)
 110         struct thread *td;
 111         struct fork_args *uap;
 112 {
 113         int error;
 114         struct proc *p2;
 115
 116         mtx_lock(&Giant);
 117         error = fork1(td, RFFDG | RFPROC, &p2);
 118         if (error == 0) {
 119                 td->td_retval[0] = p2->p_pid;
 120                 td->td_retval[1] = 0;
 121         }
 122         mtx_unlock(&Giant);
 123         return error;
 124 }
 125
 126 /*
 127  * MPSAFE
 128  */
 129 /* ARGSUSED */
 130 int
 131 vfork(td, uap)
 132         struct thread *td;
 133         struct vfork_args *uap;
 134 {
 135         int error;
 136         struct proc *p2;
 137
 138         mtx_lock(&Giant);
 139         error = fork1(td, RFFDG | RFPROC | RFPPWAIT | RFMEM, &p2);
 140         if (error == 0) {
 141                 td->td_retval[0] = p2->p_pid;
 142                 td->td_retval[1] = 0;
 143         }
 144         mtx_unlock(&Giant);
 145         return error;
 146 }
 147
 148 /*
 149  * MPSAFE
 150  */
 151 int
 152 rfork(td, uap)
 153         struct thread *td;
 154         struct rfork_args *uap;
 155 {
 156         int error;
 157         struct proc *p2;
 158
 159         /* Don't allow kernel only flags. */
 160         if ((uap->flags & RFKERNELONLY) != 0)
 161                 return (EINVAL);
 162         mtx_lock(&Giant);
 163         error = fork1(td, uap->flags, &p2);
 164         if (error == 0) {
 165                 td->td_retval[0] = p2 ? p2->p_pid : 0;
 166                 td->td_retval[1] = 0;
 167         }
 168         mtx_unlock(&Giant);
 169         return error;
 170 }
 171
 172
 173 int     nprocs = 1;                             /* process 0 */
 174 int     lastpid = 0;
 175 SYSCTL_INT(_kern, OID_AUTO, lastpid, CTLFLAG_RD, &lastpid, 0,
 176     "Last used PID");
 177
 178 /*
 179  * Random component to lastpid generation.  We mix in a random factor to make
 180  * it a little harder to predict.  We sanity check the modulus value to avoid
 181  * doing it in critical paths.  Don't let it be too small or we pointlessly
 182  * waste randomness entropy, and don't let it be impossibly large.  Using a
 183  * modulus that is too big causes a LOT more process table scans and slows
 184  * down fork processing as the pidchecked caching is defeated.
 185  */
 186 static int randompid = 0;
 187
 188 static int
 189 sysctl_kern_randompid(SYSCTL_HANDLER_ARGS)
 190 {
 191         int error, pid;
 192
 193         pid = randompid;
 194         error = sysctl_handle_int(oidp, &pid, 0, req);
 195         if (error || !req->newptr)
 196                 return (error);
 197         if (pid < 0 || pid > PID_MAX - 100)     /* out of range */
 198                 pid = PID_MAX - 100;
 199         else if (pid < 2)                       /* NOP */
 200                 pid = 0;
 201         else if (pid < 100)                     /* Make it reasonable */
 202                 pid = 100;
 203         randompid = pid;
 204         return (error);
 205 }
 206
 207 SYSCTL_PROC(_kern, OID_AUTO, randompid, CTLTYPE_INT|CTLFLAG_RW,
 208     0, 0, sysctl_kern_randompid, "I", "Random PID modulus");
 209
 210 #if 0
 211 void
 212 kse_init(struct kse *kse1, struct kse *kse2)
 213 {
 214 }
 215
 216 void
 217 thread_init(struct thread *thread1, struct thread *thread2)
 218 {
 219 }
 220
 221 void
 222 ksegrp_init(struct ksegrp *ksegrp1, struct ksegrp *ksegrp2)
 223 {
 224 }
 225 #endif
 226
 227 int
 228 fork1(td, flags, procp)
 229         struct thread *td;                      /* parent proc */
 230         int flags;
 231         struct proc **procp;                    /* child proc */
 232 {
 233         struct proc *p2, *pptr;
 234         uid_t uid;
 235         struct proc *newproc;
 236         int trypid;
 237         int ok;
 238         static int pidchecked = 0;
 239         struct forklist *ep;
 240         struct filedesc *fd;
 241         struct proc *p1 = td->td_proc;
 242
 243         GIANT_REQUIRED;
 244
 245         /* Can't copy and clear */
 246         if ((flags & (RFFDG|RFCFDG)) == (RFFDG|RFCFDG))
 247                 return (EINVAL);
 248
 249         /*
 250          * Here we don't create a new process, but we divorce
 251          * certain parts of a process from itself.
 252          */
 253         if ((flags & RFPROC) == 0) {
 254                 vm_forkproc(td, 0, flags);
 255
 256                 /*
 257                  * Close all file descriptors.
 258                  */
 259                 if (flags & RFCFDG) {
 260                         struct filedesc *fdtmp;
 261                         fdtmp = fdinit(td);     /* XXXKSE */
 262                         PROC_LOCK(p1);
 263                         fdfree(td);             /* XXXKSE */
 264                         p1->p_fd = fdtmp;
 265                         PROC_UNLOCK(p1);
 266                 }
 267
 268                 /*
 269                  * Unshare file descriptors (from parent.)
 270                  */
 271                 if (flags & RFFDG) {
 272                         FILEDESC_LOCK(p1->p_fd);
 273                         if (p1->p_fd->fd_refcnt > 1) {
 274                                 struct filedesc *newfd;
 275
 276                                 newfd = fdcopy(td);
 277                                 FILEDESC_UNLOCK(p1->p_fd);
 278                                 PROC_LOCK(p1);
 279                                 fdfree(td);
 280                                 p1->p_fd = newfd;
 281                                 PROC_UNLOCK(p1);
 282                         } else
 283                                 FILEDESC_UNLOCK(p1->p_fd);
 284                 }
 285                 *procp = NULL;
 286                 return (0);
 287         }
 288
 289         /*
 290          * Although process entries are dynamically created, we still keep
 291          * a global limit on the maximum number we will create.  Don't allow
 292          * a nonprivileged user to use the last process; don't let root
 293          * exceed the limit. The variable nprocs is the current number of
 294          * processes, maxproc is the limit.
 295          */
 296         uid = p1->p_ucred->cr_ruid;
 297         if ((nprocs >= maxproc - 1 && uid != 0) || nprocs >= maxproc) {
 298                 tablefull("proc");
 299                 return (EAGAIN);
 300         }
 301         /*
 302          * Increment the nprocs resource before blocking can occur.  There
 303          * are hard-limits as to the number of processes that can run.
 304          */
 305         nprocs++;
 306
 307         /*
 308          * Increment the count of procs running with this uid. Don't allow
 309          * a nonprivileged user to exceed their current limit.
 310          */
 311         ok = chgproccnt(p1->p_ucred->cr_ruidinfo, 1,
 312                 (uid != 0) ? p1->p_rlimit[RLIMIT_NPROC].rlim_cur : 0);
 313         if (!ok) {
 314                 /*
 315                  * Back out the process count
 316                  */
 317                 nprocs--;
 318                 return (EAGAIN);
 319         }
 320
 321         /* Allocate new proc. */
 322         newproc = zalloc(proc_zone);
 323
 324         /*
 325          * Setup linkage for kernel based threading
 326          */
 327         if((flags & RFTHREAD) != 0) {
 328                 newproc->p_peers = p1->p_peers;
 329                 p1->p_peers = newproc;
 330                 newproc->p_leader = p1->p_leader;
 331         } else {
 332                 newproc->p_peers = NULL;
 333                 newproc->p_leader = newproc;
 334         }
 335
 336         newproc->p_vmspace = NULL;
 337
 338         /*
 339          * Find an unused process ID.  We remember a range of unused IDs
 340          * ready to use (from lastpid+1 through pidchecked-1).
 341          *
 342          * If RFHIGHPID is set (used during system boot), do not allocate
 343          * low-numbered pids.
 344          */
 345         sx_xlock(&allproc_lock);
 346         trypid = lastpid + 1;
 347         if (flags & RFHIGHPID) {
 348                 if (trypid < 10) {
 349                         trypid = 10;
 350                 }
 351         } else {
 352                 if (randompid)
 353                         trypid += arc4random() % randompid;
 354         }
 355 retry:
 356         /*
 357          * If the process ID prototype has wrapped around,
 358          * restart somewhat above 0, as the low-numbered procs
 359          * tend to include daemons that don't exit.
 360          */
 361         if (trypid >= PID_MAX) {
 362                 trypid = trypid % PID_MAX;
 363                 if (trypid < 100)
 364                         trypid += 100;
 365                 pidchecked = 0;
 366         }
 367         if (trypid >= pidchecked) {
 368                 int doingzomb = 0;
 369
 370                 pidchecked = PID_MAX;
 371                 /*
 372                  * Scan the active and zombie procs to check whether this pid
 373                  * is in use.  Remember the lowest pid that's greater
 374                  * than trypid, so we can avoid checking for a while.
 375                  */
 376                 p2 = LIST_FIRST(&allproc);
 377 again:
 378                 for (; p2 != NULL; p2 = LIST_NEXT(p2, p_list)) {
 379                         while (p2->p_pid == trypid ||
 380                             p2->p_pgrp->pg_id == trypid ||
 381                             p2->p_session->s_sid == trypid) {
 382                                 trypid++;
 383                                 if (trypid >= pidchecked)
 384                                         goto retry;
 385                         }
 386                         if (p2->p_pid > trypid && pidchecked > p2->p_pid)
 387                                 pidchecked = p2->p_pid;
 388                         if (p2->p_pgrp->pg_id > trypid &&
 389                             pidchecked > p2->p_pgrp->pg_id)
 390                                 pidchecked = p2->p_pgrp->pg_id;
 391                         if (p2->p_session->s_sid > trypid &&
 392                             pidchecked > p2->p_session->s_sid)
 393                                 pidchecked = p2->p_session->s_sid;
 394                 }
 395                 if (!doingzomb) {
 396                         doingzomb = 1;
 397                         p2 = LIST_FIRST(&zombproc);
 398                         goto again;
 399                 }
 400         }
 401
 402         /*
 403          * RFHIGHPID does not mess with the lastpid counter during boot.
 404          */
 405         if (flags & RFHIGHPID)
 406                 pidchecked = 0;
 407         else
 408                 lastpid = trypid;
 409
 410         p2 = newproc;
 411         p2->p_stat = SIDL;                      /* protect against others */
 412         p2->p_pid = trypid;
 413         LIST_INSERT_HEAD(&allproc, p2, p_list);
 414         LIST_INSERT_HEAD(PIDHASH(p2->p_pid), p2, p_hash);
 415         sx_xunlock(&allproc_lock);
 416
 417         /*
 418          * Make a proc table entry for the new process.
 419          * Start by zeroing the section of proc that is zero-initialized,
 420          * then copy the section that is copied directly from the parent.
 421          */
 422         bzero(&p2->p_startzero,
 423             (unsigned) ((caddr_t)&p2->p_endzero - (caddr_t)&p2->p_startzero));
 424         bzero(&p2->p_kse.ke_startzero,
 425             (unsigned) ((caddr_t)&p2->p_kse.ke_endzero
 426                         - (caddr_t)&p2->p_kse.ke_startzero));
 427         bzero(&p2->p_thread.td_startzero,
 428             (unsigned) ((caddr_t)&p2->p_thread.td_endzero
 429                         - (caddr_t)&p2->p_thread.td_startzero));
 430         bzero(&p2->p_ksegrp.kg_startzero,
 431             (unsigned) ((caddr_t)&p2->p_ksegrp.kg_endzero
 432                         - (caddr_t)&p2->p_ksegrp.kg_startzero));
 433         PROC_LOCK(p1);
 434         bcopy(&p1->p_startcopy, &p2->p_startcopy,
 435             (unsigned) ((caddr_t)&p2->p_endcopy - (caddr_t)&p2->p_startcopy));
 436
 437         bcopy(&p1->p_kse.ke_startcopy, &p2->p_kse.ke_startcopy,
 438             (unsigned) ((caddr_t)&p2->p_kse.ke_endcopy
 439                         - (caddr_t)&p2->p_kse.ke_startcopy));
 440
 441         bcopy(&p1->p_thread.td_startcopy, &p2->p_thread.td_startcopy,
 442             (unsigned) ((caddr_t)&p2->p_thread.td_endcopy
 443                         - (caddr_t)&p2->p_thread.td_startcopy));
 444
 445         bcopy(&p1->p_ksegrp.kg_startcopy, &p2->p_ksegrp.kg_startcopy,
 446             (unsigned) ((caddr_t)&p2->p_ksegrp.kg_endcopy
 447                         - (caddr_t)&p2->p_ksegrp.kg_startcopy));
 448         PROC_UNLOCK(p1);
 449
 450         /*
 451          * XXXKSE Theoretically only the running thread would get copied
 452          * Others in the kernel would be 'aborted' in the child.
 453          * i.e return E*something*
 454          */
 455         proc_linkup(p2);
 456
 457         mtx_init(&p2->p_mtx, "process lock", MTX_DEF);
 458         PROC_LOCK(p2);
 459         /* note.. XXXKSE no pcb or u-area yet */
 460
 461         /*
 462          * Duplicate sub-structures as needed.
 463          * Increase reference counts on shared objects.
 464          * The p_stats and p_sigacts substructs are set in vm_forkproc.
 465          */
 466         p2->p_flag = 0;
 467         mtx_lock_spin(&sched_lock);
 468         p2->p_sflag = PS_INMEM;
 469         if (p1->p_sflag & PS_PROFIL)
 470                 startprofclock(p2);
 471         mtx_unlock_spin(&sched_lock);
 472         PROC_LOCK(p1);
 473         p2->p_ucred = crhold(p1->p_ucred);
 474         p2->p_thread.td_ucred = crhold(p2->p_ucred);    /* XXXKSE */
 475
 476         if (p2->p_args)
 477                 p2->p_args->ar_ref++;
 478
 479         if (flags & RFSIGSHARE) {
 480                 p2->p_procsig = p1->p_procsig;
 481                 p2->p_procsig->ps_refcnt++;
 482                 if (p1->p_sigacts == &p1->p_uarea->u_sigacts) {
 483                         struct sigacts *newsigacts;
 484
 485                         PROC_UNLOCK(p1);
 486                         PROC_UNLOCK(p2);
 487                         /* Create the shared sigacts structure */
 488                         MALLOC(newsigacts, struct sigacts *,
 489                             sizeof(struct sigacts), M_SUBPROC, M_WAITOK);
 490                         PROC_LOCK(p2);
 491                         PROC_LOCK(p1);
 492                         /*
 493                          * Set p_sigacts to the new shared structure.
 494                          * Note that this is updating p1->p_sigacts at the
 495                          * same time, since p_sigacts is just a pointer to
 496                          * the shared p_procsig->ps_sigacts.
 497                          */
 498                         p2->p_sigacts  = newsigacts;
 499                         *p2->p_sigacts = p1->p_uarea->u_sigacts;
 500                 }
 501         } else {
 502                 PROC_UNLOCK(p1);
 503                 PROC_UNLOCK(p2);
 504                 MALLOC(p2->p_procsig, struct procsig *, sizeof(struct procsig),
 505                     M_SUBPROC, M_WAITOK);
 506                 PROC_LOCK(p2);
 507                 PROC_LOCK(p1);
 508                 bcopy(p1->p_procsig, p2->p_procsig, sizeof(*p2->p_procsig));
 509                 p2->p_procsig->ps_refcnt = 1;
 510                 p2->p_sigacts = NULL;   /* finished in vm_forkproc() */
 511         }
 512         if (flags & RFLINUXTHPN)
 513                 p2->p_sigparent = SIGUSR1;
 514         else
 515                 p2->p_sigparent = SIGCHLD;
 516
 517         /* bump references to the text vnode (for procfs) */
 518         p2->p_textvp = p1->p_textvp;
 519         PROC_UNLOCK(p1);
 520         PROC_UNLOCK(p2);
 521         if (p2->p_textvp)
 522                 VREF(p2->p_textvp);
 523
 524         if (flags & RFCFDG)
 525                 fd = fdinit(td);
 526         else if (flags & RFFDG) {
 527                 FILEDESC_LOCK(p1->p_fd);
 528                 fd = fdcopy(td);
 529                 FILEDESC_UNLOCK(p1->p_fd);
 530         } else
 531                 fd = fdshare(p1);
 532         PROC_LOCK(p2);
 533         p2->p_fd = fd;
 534
 535         /*
 536          * If p_limit is still copy-on-write, bump refcnt,
 537          * otherwise get a copy that won't be modified.
 538          * (If PL_SHAREMOD is clear, the structure is shared
 539          * copy-on-write.)
 540          */
 541         PROC_LOCK(p1);
 542         if (p1->p_limit->p_lflags & PL_SHAREMOD)
 543                 p2->p_limit = limcopy(p1->p_limit);
 544         else {
 545                 p2->p_limit = p1->p_limit;
 546                 p2->p_limit->p_refcnt++;
 547         }
 548
 549         /*
 550          * Preserve some more flags in subprocess.  PS_PROFIL has already
 551          * been preserved.
 552          */
 553         p2->p_flag |= p1->p_flag & (P_SUGID | P_ALTSTACK);
 554         if (p1->p_session->s_ttyvp != NULL && p1->p_flag & P_CONTROLT)
 555                 p2->p_flag |= P_CONTROLT;
 556         if (flags & RFPPWAIT)
 557                 p2->p_flag |= P_PPWAIT;
 558
 559         LIST_INSERT_AFTER(p1, p2, p_pglist);
 560         PROC_UNLOCK(p1);
 561         PROC_UNLOCK(p2);
 562
 563         /*
 564          * Attach the new process to its parent.
 565          *
 566          * If RFNOWAIT is set, the newly created process becomes a child
 567          * of init.  This effectively disassociates the child from the
 568          * parent.
 569          */
 570         if (flags & RFNOWAIT)
 571                 pptr = initproc;
 572         else
 573                 pptr = p1;
 574         sx_xlock(&proctree_lock);
 575         PROC_LOCK(p2);
 576         p2->p_pptr = pptr;
 577         PROC_UNLOCK(p2);
 578         LIST_INSERT_HEAD(&pptr->p_children, p2, p_sibling);
 579         sx_xunlock(&proctree_lock);
 580         PROC_LOCK(p2);
 581         LIST_INIT(&p2->p_children);
 582         LIST_INIT(&p2->p_thread.td_contested); /* XXXKSE only 1 thread? */
 583
 584         callout_init(&p2->p_itcallout, 0);
 585         callout_init(&p2->p_thread.td_slpcallout, 1); /* XXXKSE */
 586
 587         PROC_LOCK(p1);
 588 #ifdef KTRACE
 589         /*
 590          * Copy traceflag and tracefile if enabled.  If not inherited,
 591          * these were zeroed above but we still could have a trace race
 592          * so make sure p2's p_tracep is NULL.
 593          */
 594         if ((p1->p_traceflag & KTRFAC_INHERIT) && p2->p_tracep == NULL) {
 595                 p2->p_traceflag = p1->p_traceflag;
 596                 if ((p2->p_tracep = p1->p_tracep) != NULL) {
 597                         PROC_UNLOCK(p1);
 598                         PROC_UNLOCK(p2);
 599                         VREF(p2->p_tracep);
 600                         PROC_LOCK(p2);
 601                         PROC_LOCK(p1);
 602                 }
 603         }
 604 #endif
 605
 606         /*
 607          * set priority of child to be that of parent
 608          * XXXKSE hey! copying the estcpu seems dodgy.. should split it..
 609          */
 610         mtx_lock_spin(&sched_lock);
 611         p2->p_ksegrp.kg_estcpu = p1->p_ksegrp.kg_estcpu;
 612         mtx_unlock_spin(&sched_lock);
 613
 614         /*
 615          * This begins the section where we must prevent the parent
 616          * from being swapped.
 617          */
 618         _PHOLD(p1);
 619         PROC_UNLOCK(p1);
 620         PROC_UNLOCK(p2);
 621
 622         /*
 623          * Finish creating the child process.  It will return via a different
 624          * execution path later.  (ie: directly into user mode)
 625          */
 626         vm_forkproc(td, p2, flags);
 627
 628         if (flags == (RFFDG | RFPROC)) {
 629                 cnt.v_forks++;
 630                 cnt.v_forkpages += p2->p_vmspace->vm_dsize + p2->p_vmspace->vm_ssize;
 631         } else if (flags == (RFFDG | RFPROC | RFPPWAIT | RFMEM)) {
 632                 cnt.v_vforks++;
 633                 cnt.v_vforkpages += p2->p_vmspace->vm_dsize + p2->p_vmspace->vm_ssize;
 634         } else if (p1 == &proc0) {
 635                 cnt.v_kthreads++;
 636                 cnt.v_kthreadpages += p2->p_vmspace->vm_dsize + p2->p_vmspace->vm_ssize;
 637         } else {
 638                 cnt.v_rforks++;
 639                 cnt.v_rforkpages += p2->p_vmspace->vm_dsize + p2->p_vmspace->vm_ssize;
 640         }
 641
 642         /*
 643          * Both processes are set up, now check if any loadable modules want
 644          * to adjust anything.
 645          *   What if they have an error? XXX
 646          */
 647         sx_slock(&fork_list_lock);
 648         TAILQ_FOREACH(ep, &fork_list, next) {
 649                 (*ep->function)(p1, p2, flags);
 650         }
 651         sx_sunlock(&fork_list_lock);
 652
 653         /*
 654          * If RFSTOPPED not requested, make child runnable and add to
 655          * run queue.
 656          */
 657         microtime(&(p2->p_stats->p_start));
 658         p2->p_acflag = AFORK;
 659         if ((flags & RFSTOPPED) == 0) {
 660                 mtx_lock_spin(&sched_lock);
 661                 p2->p_stat = SRUN;
 662                 setrunqueue(&p2->p_thread);
 663                 mtx_unlock_spin(&sched_lock);
 664         }
 665
 666         /*
 667          * Now can be swapped.
 668          */
 669         PROC_LOCK(p1);
 670         _PRELE(p1);
 671
 672         /*
 673          * tell any interested parties about the new process
 674          */
 675         KNOTE(&p1->p_klist, NOTE_FORK | p2->p_pid);
 676         PROC_UNLOCK(p1);
 677
 678         /*
 679          * Preserve synchronization semantics of vfork.  If waiting for
 680          * child to exec or exit, set P_PPWAIT on child, and sleep on our
 681          * proc (in case of exit).
 682          */
 683         PROC_LOCK(p2);
 684         while (p2->p_flag & P_PPWAIT)
 685                 msleep(p1, &p2->p_mtx, PWAIT, "ppwait", 0);
 686         PROC_UNLOCK(p2);
 687
 688         /*
 689          * Return child proc pointer to parent.
 690          */
 691         *procp = p2;
 692         return (0);
 693 }
 694
 695 /*
 696  * The next two functionms are general routines to handle adding/deleting
 697  * items on the fork callout list.
 698  *
 699  * at_fork():
 700  * Take the arguments given and put them onto the fork callout list,
 701  * However first make sure that it's not already there.
 702  * Returns 0 on success or a standard error number.
 703  */
 704
 705 int
 706 at_fork(function)
 707         forklist_fn function;
 708 {
 709         struct forklist *ep;
 710
 711 #ifdef INVARIANTS
 712         /* let the programmer know if he's been stupid */
 713         if (rm_at_fork(function))
 714                 printf("WARNING: fork callout entry (%p) already present\n",
 715                     function);
 716 #endif
 717         ep = malloc(sizeof(*ep), M_ATFORK, M_NOWAIT);
 718         if (ep == NULL)
 719                 return (ENOMEM);
 720         ep->function = function;
 721         sx_xlock(&fork_list_lock);
 722         TAILQ_INSERT_TAIL(&fork_list, ep, next);
 723         sx_xunlock(&fork_list_lock);
 724         return (0);
 725 }
 726
 727 /*
 728  * Scan the exit callout list for the given item and remove it..
 729  * Returns the number of items removed (0 or 1)
 730  */
 731
 732 int
 733 rm_at_fork(function)
 734         forklist_fn function;
 735 {
 736         struct forklist *ep;
 737
 738         sx_xlock(&fork_list_lock);
 739         TAILQ_FOREACH(ep, &fork_list, next) {
 740                 if (ep->function == function) {
 741                         TAILQ_REMOVE(&fork_list, ep, next);
 742                         sx_xunlock(&fork_list_lock);
 743                         free(ep, M_ATFORK);
 744                         return(1);
 745                 }
 746         }
 747         sx_xunlock(&fork_list_lock);
 748         return (0);
 749 }
 750
 751 /*
 752  * Handle the return of a child process from fork1().  This function
 753  * is called from the MD fork_trampoline() entry point.
 754  */
 755 void
 756 fork_exit(callout, arg, frame)
 757         void (*callout)(void *, struct trapframe *);
 758         void *arg;
 759         struct trapframe *frame;
 760 {
 761         struct thread *td = curthread;
 762         struct proc *p = td->td_proc;
 763
 764         td->td_kse->ke_oncpu = PCPU_GET(cpuid);
 765         /*
 766          * Setup the sched_lock state so that we can release it.
 767          */
 768         sched_lock.mtx_lock = (uintptr_t)td;
 769         sched_lock.mtx_recurse = 0;
 770         td->td_critnest = 1;
 771         td->td_savecrit = CRITICAL_FORK;
 772         CTR3(KTR_PROC, "fork_exit: new proc %p (pid %d, %s)", p, p->p_pid,
 773             p->p_comm);
 774         if (PCPU_GET(switchtime.tv_sec) == 0)
 775                 microuptime(PCPU_PTR(switchtime));
 776         PCPU_SET(switchticks, ticks);
 777         mtx_unlock_spin(&sched_lock);
 778
 779         /*
 780          * cpu_set_fork_handler intercepts this function call to
 781          * have this call a non-return function to stay in kernel mode.
 782          * initproc has its own fork handler, but it does return.
 783          */
 784         KASSERT(callout != NULL, ("NULL callout in fork_exit"));
 785         callout(arg, frame);
 786
 787         /*
 788          * Check if a kernel thread misbehaved and returned from its main
 789          * function.
 790          */
 791         PROC_LOCK(p);
 792         if (p->p_flag & P_KTHREAD) {
 793                 PROC_UNLOCK(p);
 794                 mtx_lock(&Giant);
 795                 printf("Kernel thread \"%s\" (pid %d) exited prematurely.\n",
 796                     p->p_comm, p->p_pid);
 797                 kthread_exit(0);
 798         }
 799         PROC_UNLOCK(p);
 800         mtx_lock(&Giant);
 801         crfree(td->td_ucred);
 802         mtx_unlock(&Giant);
 803         td->td_ucred = NULL;
 804         mtx_assert(&Giant, MA_NOTOWNED);
 805 }
 806
 807 /*
 808  * Simplified back end of syscall(), used when returning from fork()
 809  * directly into user mode.  Giant is not held on entry, and must not
 810  * be held on return.  This function is passed in to fork_exit() as the
 811  * first parameter and is called when returning to a new userland process.
 812  */
 813 void
 814 fork_return(td, frame)
 815         struct thread *td;
 816         struct trapframe *frame;
 817 {
 818
 819         userret(td, frame, 0);
 820 #ifdef KTRACE
 821         if (KTRPOINT(td->td_proc, KTR_SYSRET)) {
 822                 ktrsysret(td->td_proc->p_tracep, SYS_fork, 0, 0);
 823         }
 824 #endif
 825         mtx_assert(&Giant, MA_NOTOWNED);
 826 }