Annotation of sys/kern/kern_fork.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: kern_fork.c,v 1.92 2007/07/25 23:11:52 art Exp $ */
! 2: /* $NetBSD: kern_fork.c,v 1.29 1996/02/09 18:59:34 christos Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1982, 1986, 1989, 1991, 1993
! 6: * The Regents of the University of California. All rights reserved.
! 7: * (c) UNIX System Laboratories, Inc.
! 8: * All or some portions of this file are derived from material licensed
! 9: * to the University of California by American Telephone and Telegraph
! 10: * Co. or Unix System Laboratories, Inc. and are reproduced herein with
! 11: * the permission of UNIX System Laboratories, Inc.
! 12: *
! 13: * Redistribution and use in source and binary forms, with or without
! 14: * modification, are permitted provided that the following conditions
! 15: * are met:
! 16: * 1. Redistributions of source code must retain the above copyright
! 17: * notice, this list of conditions and the following disclaimer.
! 18: * 2. Redistributions in binary form must reproduce the above copyright
! 19: * notice, this list of conditions and the following disclaimer in the
! 20: * documentation and/or other materials provided with the distribution.
! 21: * 3. Neither the name of the University nor the names of its contributors
! 22: * may be used to endorse or promote products derived from this software
! 23: * without specific prior written permission.
! 24: *
! 25: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 26: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 27: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 28: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 29: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 30: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 31: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 32: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 33: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 34: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 35: * SUCH DAMAGE.
! 36: *
! 37: * @(#)kern_fork.c 8.6 (Berkeley) 4/8/94
! 38: */
! 39:
! 40: #include <sys/param.h>
! 41: #include <sys/systm.h>
! 42: #include <sys/filedesc.h>
! 43: #include <sys/kernel.h>
! 44: #include <sys/malloc.h>
! 45: #include <sys/mount.h>
! 46: #include <sys/proc.h>
! 47: #include <sys/exec.h>
! 48: #include <sys/resourcevar.h>
! 49: #include <sys/signalvar.h>
! 50: #include <sys/vnode.h>
! 51: #include <sys/file.h>
! 52: #include <sys/acct.h>
! 53: #include <sys/ktrace.h>
! 54: #include <sys/sched.h>
! 55: #include <dev/rndvar.h>
! 56: #include <sys/pool.h>
! 57: #include <sys/mman.h>
! 58: #include <sys/ptrace.h>
! 59:
! 60: #include <sys/syscallargs.h>
! 61:
! 62: #include "systrace.h"
! 63: #include <dev/systrace.h>
! 64:
! 65: #include <uvm/uvm_extern.h>
! 66: #include <uvm/uvm_map.h>
! 67:
! 68: int nprocs = 1; /* process 0 */
! 69: int randompid; /* when set to 1, pid's go random */
! 70: pid_t lastpid;
! 71: struct forkstat forkstat;
! 72:
! 73: void fork_return(void *);
! 74: int pidtaken(pid_t);
! 75:
! 76: void process_new(struct proc *, struct proc *);
! 77:
! 78: void
! 79: fork_return(void *arg)
! 80: {
! 81: struct proc *p = (struct proc *)arg;
! 82:
! 83: if (p->p_flag & P_TRACED)
! 84: psignal(p, SIGTRAP);
! 85:
! 86: child_return(p);
! 87: }
! 88:
! 89: /*ARGSUSED*/
! 90: int
! 91: sys_fork(struct proc *p, void *v, register_t *retval)
! 92: {
! 93: int flags;
! 94:
! 95: flags = FORK_FORK;
! 96: if (p->p_ptmask & PTRACE_FORK)
! 97: flags |= FORK_PTRACE;
! 98: return (fork1(p, SIGCHLD, flags, NULL, 0,
! 99: fork_return, NULL, retval, NULL));
! 100: }
! 101:
! 102: /*ARGSUSED*/
! 103: int
! 104: sys_vfork(struct proc *p, void *v, register_t *retval)
! 105: {
! 106: return (fork1(p, SIGCHLD, FORK_VFORK|FORK_PPWAIT, NULL, 0, NULL,
! 107: NULL, retval, NULL));
! 108: }
! 109:
! 110: int
! 111: sys_rfork(struct proc *p, void *v, register_t *retval)
! 112: {
! 113: struct sys_rfork_args /* {
! 114: syscallarg(int) flags;
! 115: } */ *uap = v;
! 116:
! 117: int rforkflags;
! 118: int flags;
! 119:
! 120: flags = FORK_RFORK;
! 121: rforkflags = SCARG(uap, flags);
! 122:
! 123: if ((rforkflags & RFPROC) == 0)
! 124: return (EINVAL);
! 125:
! 126: switch(rforkflags & (RFFDG|RFCFDG)) {
! 127: case (RFFDG|RFCFDG):
! 128: return EINVAL;
! 129: case RFCFDG:
! 130: flags |= FORK_CLEANFILES;
! 131: break;
! 132: case RFFDG:
! 133: break;
! 134: default:
! 135: flags |= FORK_SHAREFILES;
! 136: break;
! 137: }
! 138:
! 139: if (rforkflags & RFNOWAIT)
! 140: flags |= FORK_NOZOMBIE;
! 141:
! 142: if (rforkflags & RFMEM)
! 143: flags |= FORK_SHAREVM;
! 144: #ifdef RTHREADS
! 145: if (rforkflags & RFTHREAD)
! 146: flags |= FORK_THREAD;
! 147: #endif
! 148:
! 149: return (fork1(p, SIGCHLD, flags, NULL, 0, NULL, NULL, retval, NULL));
! 150: }
! 151:
! 152: /*
! 153: * Allocate and initialize a new process.
! 154: */
! 155: void
! 156: process_new(struct proc *newproc, struct proc *parent)
! 157: {
! 158: struct process *pr;
! 159:
! 160: pr = pool_get(&process_pool, PR_WAITOK);
! 161: pr->ps_mainproc = newproc;
! 162: TAILQ_INIT(&pr->ps_threads);
! 163: TAILQ_INSERT_TAIL(&pr->ps_threads, newproc, p_thr_link);
! 164: newproc->p_p = pr;
! 165: }
! 166:
! 167: /* print the 'table full' message once per 10 seconds */
! 168: struct timeval fork_tfmrate = { 10, 0 };
! 169:
! 170: int
! 171: fork1(struct proc *p1, int exitsig, int flags, void *stack, size_t stacksize,
! 172: void (*func)(void *), void *arg, register_t *retval,
! 173: struct proc **rnewprocp)
! 174: {
! 175: struct proc *p2;
! 176: uid_t uid;
! 177: struct vmspace *vm;
! 178: int count;
! 179: vaddr_t uaddr;
! 180: int s;
! 181: extern void endtsleep(void *);
! 182: extern void realitexpire(void *);
! 183:
! 184: /*
! 185: * Although process entries are dynamically created, we still keep
! 186: * a global limit on the maximum number we will create. We reserve
! 187: * the last 5 processes to root. The variable nprocs is the current
! 188: * number of processes, maxproc is the limit.
! 189: */
! 190: uid = p1->p_cred->p_ruid;
! 191: if ((nprocs >= maxproc - 5 && uid != 0) || nprocs >= maxproc) {
! 192: static struct timeval lasttfm;
! 193:
! 194: if (ratecheck(&lasttfm, &fork_tfmrate))
! 195: tablefull("proc");
! 196: return (EAGAIN);
! 197: }
! 198: nprocs++;
! 199:
! 200: /*
! 201: * Increment the count of procs running with this uid. Don't allow
! 202: * a nonprivileged user to exceed their current limit.
! 203: */
! 204: count = chgproccnt(uid, 1);
! 205: if (uid != 0 && count > p1->p_rlimit[RLIMIT_NPROC].rlim_cur) {
! 206: (void)chgproccnt(uid, -1);
! 207: nprocs--;
! 208: return (EAGAIN);
! 209: }
! 210:
! 211: uaddr = uvm_km_alloc1(kernel_map, USPACE, USPACE_ALIGN, 1);
! 212: if (uaddr == 0) {
! 213: chgproccnt(uid, -1);
! 214: nprocs--;
! 215: return (ENOMEM);
! 216: }
! 217:
! 218: /*
! 219: * From now on, we're committed to the fork and cannot fail.
! 220: */
! 221:
! 222: /* Allocate new proc. */
! 223: p2 = pool_get(&proc_pool, PR_WAITOK);
! 224:
! 225: p2->p_stat = SIDL; /* protect against others */
! 226: p2->p_exitsig = exitsig;
! 227: p2->p_forw = p2->p_back = NULL;
! 228:
! 229: #ifdef RTHREADS
! 230: if (flags & FORK_THREAD) {
! 231: atomic_setbits_int(&p2->p_flag, P_THREAD);
! 232: p2->p_p = p1->p_p;
! 233: TAILQ_INSERT_TAIL(&p2->p_p->ps_threads, p2, p_thr_link);
! 234: } else {
! 235: process_new(p2, p1);
! 236: }
! 237: #else
! 238: process_new(p2, p1);
! 239: #endif
! 240:
! 241: /*
! 242: * Make a proc table entry for the new process.
! 243: * Start by zeroing the section of proc that is zero-initialized,
! 244: * then copy the section that is copied directly from the parent.
! 245: */
! 246: bzero(&p2->p_startzero,
! 247: (unsigned) ((caddr_t)&p2->p_endzero - (caddr_t)&p2->p_startzero));
! 248: bcopy(&p1->p_startcopy, &p2->p_startcopy,
! 249: (unsigned) ((caddr_t)&p2->p_endcopy - (caddr_t)&p2->p_startcopy));
! 250:
! 251: /*
! 252: * Initialize the timeouts.
! 253: */
! 254: timeout_set(&p2->p_sleep_to, endtsleep, p2);
! 255: timeout_set(&p2->p_realit_to, realitexpire, p2);
! 256:
! 257: p2->p_cpu = p1->p_cpu;
! 258:
! 259: /*
! 260: * Duplicate sub-structures as needed.
! 261: * Increase reference counts on shared objects.
! 262: * The p_stats and p_sigacts substructs are set in vm_fork.
! 263: */
! 264: p2->p_flag = 0;
! 265: p2->p_emul = p1->p_emul;
! 266: if (p1->p_flag & P_PROFIL)
! 267: startprofclock(p2);
! 268: atomic_setbits_int(&p2->p_flag, p1->p_flag & (P_SUGID | P_SUGIDEXEC));
! 269: if (flags & FORK_PTRACE)
! 270: atomic_setbits_int(&p2->p_flag, p1->p_flag & P_TRACED);
! 271: #ifdef RTHREADS
! 272: if (flags & FORK_THREAD) {
! 273: /* nothing */
! 274: } else
! 275: #endif
! 276: {
! 277: p2->p_p->ps_cred = pool_get(&pcred_pool, PR_WAITOK);
! 278: bcopy(p1->p_p->ps_cred, p2->p_p->ps_cred, sizeof(*p2->p_p->ps_cred));
! 279: p2->p_p->ps_cred->p_refcnt = 1;
! 280: crhold(p1->p_ucred);
! 281: }
! 282:
! 283: /* bump references to the text vnode (for procfs) */
! 284: p2->p_textvp = p1->p_textvp;
! 285: if (p2->p_textvp)
! 286: VREF(p2->p_textvp);
! 287:
! 288: if (flags & FORK_CLEANFILES)
! 289: p2->p_fd = fdinit(p1);
! 290: else if (flags & FORK_SHAREFILES)
! 291: p2->p_fd = fdshare(p1);
! 292: else
! 293: p2->p_fd = fdcopy(p1);
! 294:
! 295: /*
! 296: * If ps_limit is still copy-on-write, bump refcnt,
! 297: * otherwise get a copy that won't be modified.
! 298: * (If PL_SHAREMOD is clear, the structure is shared
! 299: * copy-on-write.)
! 300: */
! 301: #ifdef RTHREADS
! 302: if (flags & FORK_THREAD) {
! 303: /* nothing */
! 304: } else
! 305: #endif
! 306: {
! 307: if (p1->p_p->ps_limit->p_lflags & PL_SHAREMOD)
! 308: p2->p_p->ps_limit = limcopy(p1->p_p->ps_limit);
! 309: else {
! 310: p2->p_p->ps_limit = p1->p_p->ps_limit;
! 311: p2->p_p->ps_limit->p_refcnt++;
! 312: }
! 313: }
! 314:
! 315: if (p1->p_session->s_ttyvp != NULL && p1->p_flag & P_CONTROLT)
! 316: atomic_setbits_int(&p2->p_flag, P_CONTROLT);
! 317: if (flags & FORK_PPWAIT)
! 318: atomic_setbits_int(&p2->p_flag, P_PPWAIT);
! 319: p2->p_pptr = p1;
! 320: if (flags & FORK_NOZOMBIE)
! 321: atomic_setbits_int(&p2->p_flag, P_NOZOMBIE);
! 322: LIST_INIT(&p2->p_children);
! 323:
! 324: #ifdef KTRACE
! 325: /*
! 326: * Copy traceflag and tracefile if enabled.
! 327: * If not inherited, these were zeroed above.
! 328: */
! 329: if (p1->p_traceflag & KTRFAC_INHERIT) {
! 330: p2->p_traceflag = p1->p_traceflag;
! 331: if ((p2->p_tracep = p1->p_tracep) != NULL)
! 332: VREF(p2->p_tracep);
! 333: }
! 334: #endif
! 335:
! 336: /*
! 337: * set priority of child to be that of parent
! 338: * XXX should move p_estcpu into the region of struct proc which gets
! 339: * copied.
! 340: */
! 341: scheduler_fork_hook(p1, p2);
! 342:
! 343: /*
! 344: * Create signal actions for the child process.
! 345: */
! 346: if (flags & FORK_SIGHAND)
! 347: sigactsshare(p1, p2);
! 348: else
! 349: p2->p_sigacts = sigactsinit(p1);
! 350:
! 351: /*
! 352: * If emulation has process fork hook, call it now.
! 353: */
! 354: if (p2->p_emul->e_proc_fork)
! 355: (*p2->p_emul->e_proc_fork)(p2, p1);
! 356:
! 357: p2->p_addr = (struct user *)uaddr;
! 358:
! 359: /*
! 360: * Finish creating the child process. It will return through a
! 361: * different path later.
! 362: */
! 363: uvm_fork(p1, p2, ((flags & FORK_SHAREVM) ? TRUE : FALSE), stack,
! 364: stacksize, func ? func : child_return, arg ? arg : p2);
! 365:
! 366: timeout_set(&p2->p_stats->p_virt_to, virttimer_trampoline, p2);
! 367: timeout_set(&p2->p_stats->p_prof_to, proftimer_trampoline, p2);
! 368:
! 369: vm = p2->p_vmspace;
! 370:
! 371: if (flags & FORK_FORK) {
! 372: forkstat.cntfork++;
! 373: forkstat.sizfork += vm->vm_dsize + vm->vm_ssize;
! 374: } else if (flags & FORK_VFORK) {
! 375: forkstat.cntvfork++;
! 376: forkstat.sizvfork += vm->vm_dsize + vm->vm_ssize;
! 377: } else if (flags & FORK_RFORK) {
! 378: forkstat.cntrfork++;
! 379: forkstat.sizrfork += vm->vm_dsize + vm->vm_ssize;
! 380: } else {
! 381: forkstat.cntkthread++;
! 382: forkstat.sizkthread += vm->vm_dsize + vm->vm_ssize;
! 383: }
! 384:
! 385: /* Find an unused pid satisfying 1 <= lastpid <= PID_MAX */
! 386: do {
! 387: lastpid = 1 + (randompid ? arc4random() : lastpid) % PID_MAX;
! 388: } while (pidtaken(lastpid));
! 389: p2->p_pid = lastpid;
! 390:
! 391: LIST_INSERT_HEAD(&allproc, p2, p_list);
! 392: LIST_INSERT_HEAD(PIDHASH(p2->p_pid), p2, p_hash);
! 393: LIST_INSERT_HEAD(&p1->p_children, p2, p_sibling);
! 394: LIST_INSERT_AFTER(p1, p2, p_pglist);
! 395: if (p2->p_flag & P_TRACED) {
! 396: p2->p_oppid = p1->p_pid;
! 397: if (p2->p_pptr != p1->p_pptr)
! 398: proc_reparent(p2, p1->p_pptr);
! 399:
! 400: /*
! 401: * Set ptrace status.
! 402: */
! 403: if (flags & FORK_FORK) {
! 404: p2->p_ptstat = malloc(sizeof(*p2->p_ptstat),
! 405: M_SUBPROC, M_WAITOK);
! 406: p1->p_ptstat->pe_report_event = PTRACE_FORK;
! 407: p2->p_ptstat->pe_report_event = PTRACE_FORK;
! 408: p1->p_ptstat->pe_other_pid = p2->p_pid;
! 409: p2->p_ptstat->pe_other_pid = p1->p_pid;
! 410: }
! 411: }
! 412:
! 413: #if NSYSTRACE > 0
! 414: if (ISSET(p1->p_flag, P_SYSTRACE))
! 415: systrace_fork(p1, p2);
! 416: #endif
! 417:
! 418: /*
! 419: * Make child runnable, set start time, and add to run queue.
! 420: */
! 421: SCHED_LOCK(s);
! 422: getmicrotime(&p2->p_stats->p_start);
! 423: p2->p_acflag = AFORK;
! 424: p2->p_stat = SRUN;
! 425: setrunqueue(p2);
! 426: SCHED_UNLOCK(s);
! 427:
! 428: /*
! 429: * Notify any interested parties about the new process.
! 430: */
! 431: KNOTE(&p1->p_klist, NOTE_FORK | p2->p_pid);
! 432:
! 433: /*
! 434: * Update stats now that we know the fork was successfull.
! 435: */
! 436: uvmexp.forks++;
! 437: if (flags & FORK_PPWAIT)
! 438: uvmexp.forks_ppwait++;
! 439: if (flags & FORK_SHAREVM)
! 440: uvmexp.forks_sharevm++;
! 441:
! 442: /*
! 443: * Pass a pointer to the new process to the caller.
! 444: */
! 445: if (rnewprocp != NULL)
! 446: *rnewprocp = p2;
! 447:
! 448: /*
! 449: * Preserve synchronization semantics of vfork. If waiting for
! 450: * child to exec or exit, set P_PPWAIT on child, and sleep on our
! 451: * proc (in case of exit).
! 452: */
! 453: if (flags & FORK_PPWAIT)
! 454: while (p2->p_flag & P_PPWAIT)
! 455: tsleep(p1, PWAIT, "ppwait", 0);
! 456:
! 457: /*
! 458: * If we're tracing the child, alert the parent too.
! 459: */
! 460: if ((flags & FORK_PTRACE) && (p1->p_flag & P_TRACED))
! 461: psignal(p1, SIGTRAP);
! 462:
! 463: /*
! 464: * Return child pid to parent process,
! 465: * marking us as parent via retval[1].
! 466: */
! 467: if (retval != NULL) {
! 468: retval[0] = p2->p_pid;
! 469: retval[1] = 0;
! 470: }
! 471: return (0);
! 472: }
! 473:
! 474: /*
! 475: * Checks for current use of a pid, either as a pid or pgid.
! 476: */
! 477: int
! 478: pidtaken(pid_t pid)
! 479: {
! 480: struct proc *p;
! 481:
! 482: if (pfind(pid) != NULL)
! 483: return (1);
! 484: if (pgfind(pid) != NULL)
! 485: return (1);
! 486: LIST_FOREACH(p, &zombproc, p_list)
! 487: if (p->p_pid == pid || p->p_pgid == pid)
! 488: return (1);
! 489: return (0);
! 490: }
! 491:
! 492: #if defined(MULTIPROCESSOR)
! 493: /*
! 494: * XXX This is a slight hack to get newly-formed processes to
! 495: * XXX acquire the kernel lock as soon as they run.
! 496: */
! 497: void
! 498: proc_trampoline_mp(void)
! 499: {
! 500: struct proc *p;
! 501:
! 502: p = curproc;
! 503:
! 504: SCHED_ASSERT_UNLOCKED();
! 505: KERNEL_PROC_LOCK(p);
! 506: }
! 507: #endif
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to kern_fork.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / kern