projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
add definition for ability to produce a backtrace
[unix-history] / usr / src / sys / kern / kern_fork.c
diff --git a/usr/src/sys/kern/kern_fork.c b/usr/src/sys/kern/kern_fork.c
index 529fb8c..d4f373d 100644 (file)
--- a/usr/src/sys/kern/kern_fork.c
+++ b/usr/src/sys/kern/kern_fork.c
@@ -1,31 +1,35 @@
 /*
 /*
- * Copyright (c) 1982, 1986, 1989, 1991 Regents of the University of California.
- * All rights reserved.
+ * Copyright (c) 1982, 1986, 1989, 1991, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ * (c) UNIX System Laboratories, Inc.
+ * All or some portions of this file are derived from material licensed
+ * to the University of California by American Telephone and Telegraph
+ * Co. or Unix System Laboratories, Inc. and are reproduced herein with
+ * the permission of UNIX System Laboratories, Inc.
  *
  * %sccs.include.redist.c%
  *
  *
  * %sccs.include.redist.c%
  *
- *     @(#)kern_fork.c 7.29 (Berkeley) %G%
+ *     @(#)kern_fork.c 8.8 (Berkeley) %G%
  */
 
  */
 
-#include "param.h"
-#include "systm.h"
-#include "map.h"
-#include "filedesc.h"
-#include "kernel.h"
-#include "malloc.h"
-#include "proc.h"
-#include "resourcevar.h"
-#include "vnode.h"
-#include "seg.h"
-#include "file.h"
-#include "acct.h"
-#include "ktrace.h"
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/map.h>
+#include <sys/filedesc.h>
+#include <sys/kernel.h>
+#include <sys/malloc.h>
+#include <sys/proc.h>
+#include <sys/resourcevar.h>
+#include <sys/vnode.h>
+#include <sys/file.h>
+#include <sys/acct.h>
+#include <sys/ktrace.h>
 
 /* ARGSUSED */
 fork(p, uap, retval)
        struct proc *p;
        void *uap;
 
 /* ARGSUSED */
 fork(p, uap, retval)
        struct proc *p;
        void *uap;
-       int retval[];
+       register_t *retval;
 {
 
        return (fork1(p, 0, retval));
 {
 
        return (fork1(p, 0, retval));
@@ -35,7 +39,7 @@ fork(p, uap, retval)
 vfork(p, uap, retval)
        struct proc *p;
        void *uap;
 vfork(p, uap, retval)
        struct proc *p;
        void *uap;
-       int retval[];
+       register_t *retval;
 {
 
        return (fork1(p, 1, retval));
 {
 
        return (fork1(p, 1, retval));
@@ -45,41 +49,45 @@ int nprocs = 1;             /* process 0 */
 
 fork1(p1, isvfork, retval)
        register struct proc *p1;
 
 fork1(p1, isvfork, retval)
        register struct proc *p1;
-       int isvfork, retval[];
+       int isvfork;
+       register_t *retval;
 {
        register struct proc *p2;
 {
        register struct proc *p2;
-       register int count, uid;
+       register uid_t uid;
+       struct proc *newproc;
+       struct proc **hash;
+       int count;
        static int nextpid, pidchecked = 0;
 
        static int nextpid, pidchecked = 0;
 
-       count = 0;
-       if ((uid = p1->p_ucred->cr_uid) != 0) {
-               for (p2 = allproc; p2; p2 = p2->p_nxt)
-                       if (p2->p_ucred->cr_uid == uid)
-                               count++;
-               for (p2 = zombproc; p2; p2 = p2->p_nxt)
-                       if (p2->p_ucred->cr_uid == uid)
-                               count++;
-       }
        /*
        /*
-        * Although process entries are dynamically entries,
-        * we still keep a global limit on the maximum number
-        * we will create.  Don't allow a nonprivileged user
-        * to exceed its current limit or to bring us within one
-        * of the global limit; don't let root exceed the limit.
-        * nprocs is the current number of processes,
-        * maxproc is the limit.
+        * Although process entries are dynamically created, we still keep
+        * a global limit on the maximum number we will create.  Don't allow
+        * a nonprivileged user to use the last process; don't let root
+        * exceed the limit. The variable nprocs is the current number of
+        * processes, maxproc is the limit.
         */
         */
-       if (nprocs >= maxproc || uid == 0 && nprocs >= maxproc + 1) {
+       uid = p1->p_cred->p_ruid;
+       if ((nprocs >= maxproc - 1 && uid != 0) || nprocs >= maxproc) {
                tablefull("proc");
                return (EAGAIN);
        }
                tablefull("proc");
                return (EAGAIN);
        }
-       if (count > p1->p_rlimit[RLIMIT_NPROC].rlim_cur)
+
+       /*
+        * Increment the count of procs running with this uid. Don't allow
+        * a nonprivileged user to exceed their current limit.
+        */
+       count = chgproccnt(uid, 1);
+       if (uid != 0 && count > p1->p_rlimit[RLIMIT_NPROC].rlim_cur) {
+               (void)chgproccnt(uid, -1);
                return (EAGAIN);
                return (EAGAIN);
+       }
+
+       /* Allocate new proc. */
+       MALLOC(newproc, struct proc *, sizeof(struct proc), M_PROC, M_WAITOK);
 
        /*
 
        /*
-        * Find an unused process ID.
-        * We remember a range of unused IDs ready to use
-        * (from nextpid+1 through pidchecked-1).
+        * Find an unused process ID.  We remember a range of unused IDs
+        * ready to use (from nextpid+1 through pidchecked-1).
         */
        nextpid++;
 retry:
         */
        nextpid++;
 retry:
@@ -101,10 +109,10 @@ retry:
                 * is in use.  Remember the lowest pid that's greater
                 * than nextpid, so we can avoid checking for a while.
                 */
                 * is in use.  Remember the lowest pid that's greater
                 * than nextpid, so we can avoid checking for a while.
                 */
-               p2 = allproc;
+               p2 = allproc.lh_first;
 again:
 again:
-               for (; p2 != NULL; p2 = p2->p_nxt) {
-                       if (p2->p_pid == nextpid ||
+               for (; p2 != 0; p2 = p2->p_list.le_next) {
+                       while (p2->p_pid == nextpid ||
                            p2->p_pgrp->pg_id == nextpid) {
                                nextpid++;
                                if (nextpid >= pidchecked)
                            p2->p_pgrp->pg_id == nextpid) {
                                nextpid++;
                                if (nextpid >= pidchecked)
@@ -118,24 +126,18 @@ again:
                }
                if (!doingzomb) {
                        doingzomb = 1;
                }
                if (!doingzomb) {
                        doingzomb = 1;
-                       p2 = zombproc;
+                       p2 = zombproc.lh_first;
                        goto again;
                }
        }
 
                        goto again;
                }
        }
 
-
-       /*
-        * Allocate new proc.
-        * Link onto allproc (this should probably be delayed).
-        */
-       MALLOC(p2, struct proc *, sizeof(struct proc), M_PROC, M_WAITOK);
        nprocs++;
        nprocs++;
-       p2->p_nxt = allproc;
-       p2->p_nxt->p_prev = &p2->p_nxt;         /* allproc is never NULL */
-       p2->p_prev = &allproc;
-       allproc = p2;
-       p2->p_link = NULL;                      /* shouldn't be necessary */
-       p2->p_rlink = NULL;                     /* shouldn't be necessary */
+       p2 = newproc;
+       p2->p_stat = SIDL;                      /* protect against others */
+       p2->p_pid = nextpid;
+       LIST_INSERT_HEAD(&allproc, p2, p_list);
+       p2->p_forw = p2->p_back = NULL;         /* shouldn't be necessary */
+       LIST_INSERT_HEAD(PIDHASH(p2->p_pid), p2, p_hash);
 
        /*
         * Make a proc table entry for the new process.
 
        /*
         * Make a proc table entry for the new process.
@@ -146,22 +148,26 @@ again:
            (unsigned) ((caddr_t)&p2->p_endzero - (caddr_t)&p2->p_startzero));
        bcopy(&p1->p_startcopy, &p2->p_startcopy,
            (unsigned) ((caddr_t)&p2->p_endcopy - (caddr_t)&p2->p_startcopy));
            (unsigned) ((caddr_t)&p2->p_endzero - (caddr_t)&p2->p_startzero));
        bcopy(&p1->p_startcopy, &p2->p_startcopy,
            (unsigned) ((caddr_t)&p2->p_endcopy - (caddr_t)&p2->p_startcopy));
-       p2->p_spare[0] = 0;     /* XXX - should be in zero range */
-       p2->p_spare[1] = 0;     /* XXX - should be in zero range */
-       p2->p_spare[2] = 0;     /* XXX - should be in zero range */
-       p2->p_spare[3] = 0;     /* XXX - should be in zero range */
 
        /*
         * Duplicate sub-structures as needed.
         * Increase reference counts on shared objects.
         * The p_stats and p_sigacts substructs are set in vm_fork.
         */
 
        /*
         * Duplicate sub-structures as needed.
         * Increase reference counts on shared objects.
         * The p_stats and p_sigacts substructs are set in vm_fork.
         */
+       p2->p_flag = P_INMEM;
+       if (p1->p_flag & P_PROFIL)
+               startprofclock(p2);
        MALLOC(p2->p_cred, struct pcred *, sizeof(struct pcred),
            M_SUBPROC, M_WAITOK);
        bcopy(p1->p_cred, p2->p_cred, sizeof(*p2->p_cred));
        p2->p_cred->p_refcnt = 1;
        crhold(p1->p_ucred);
 
        MALLOC(p2->p_cred, struct pcred *, sizeof(struct pcred),
            M_SUBPROC, M_WAITOK);
        bcopy(p1->p_cred, p2->p_cred, sizeof(*p2->p_cred));
        p2->p_cred->p_refcnt = 1;
        crhold(p1->p_ucred);
 
+       /* bump references to the text vnode (for procfs) */
+       p2->p_textvp = p1->p_textvp;
+       if (p2->p_textvp)
+               VREF(p2->p_textvp);
+
        p2->p_fd = fdcopy(p1);
        /*
         * If p_limit is still copy-on-write, bump refcnt,
        p2->p_fd = fdcopy(p1);
        /*
         * If p_limit is still copy-on-write, bump refcnt,
@@ -176,26 +182,15 @@ again:
                p2->p_limit->p_refcnt++;
        }
 
                p2->p_limit->p_refcnt++;
        }
 
-       p2->p_flag = SLOAD | (p1->p_flag & SHPUX);
-       if (p1->p_session->s_ttyvp != NULL && p1->p_flag & SCTTY)
-               p2->p_flag |= SCTTY;
+       if (p1->p_session->s_ttyvp != NULL && p1->p_flag & P_CONTROLT)
+               p2->p_flag |= P_CONTROLT;
        if (isvfork)
        if (isvfork)
-               p2->p_flag |= SPPWAIT;
-       p2->p_stat = SIDL;
-       p2->p_pid = nextpid;
-       {
-       struct proc **hash = &pidhash[PIDHASH(p2->p_pid)];
-
-       p2->p_hash = *hash;
-       *hash = p2;
-       }
-       p2->p_pgrpnxt = p1->p_pgrpnxt;
-       p1->p_pgrpnxt = p2;
+               p2->p_flag |= P_PPWAIT;
+       LIST_INSERT_AFTER(p1, p2, p_pglist);
        p2->p_pptr = p1;
        p2->p_pptr = p1;
-       p2->p_osptr = p1->p_cptr;
-       if (p1->p_cptr)
-               p1->p_cptr->p_ysptr = p2;
-       p1->p_cptr = p2;
+       LIST_INSERT_HEAD(&p1->p_children, p2, p_sibling);
+       LIST_INIT(&p2->p_children);
+
 #ifdef KTRACE
        /*
         * Copy traceflag and tracefile if enabled.
 #ifdef KTRACE
        /*
         * Copy traceflag and tracefile if enabled.
@@ -208,15 +203,11 @@ again:
        }
 #endif
 
        }
 #endif
 
-#if defined(tahoe)
-       p2->p_vmspace->p_ckey = p1->p_vmspace->p_ckey; /* XXX move this */
-#endif
-
        /*
         * This begins the section where we must prevent the parent
         * from being swapped.
         */
        /*
         * This begins the section where we must prevent the parent
         * from being swapped.
         */
-       p1->p_flag |= SKEEP;
+       p1->p_flag |= P_NOSWAP;
        /*
         * Set return values for child before vm_fork,
         * so they can be copied to child stack.
        /*
         * Set return values for child before vm_fork,
         * so they can be copied to child stack.
@@ -243,22 +234,22 @@ again:
         */
        (void) splhigh();
        p2->p_stat = SRUN;
         */
        (void) splhigh();
        p2->p_stat = SRUN;
-       setrq(p2);
+       setrunqueue(p2);
        (void) spl0();
 
        /*
         * Now can be swapped.
         */
        (void) spl0();
 
        /*
         * Now can be swapped.
         */
-       p1->p_flag &= ~SKEEP;
+       p1->p_flag &= ~P_NOSWAP;
 
        /*
 
        /*
-        * Preserve synchronization semantics of vfork.
-        * If waiting for child to exec or exit, set SPPWAIT
-        * on child, and sleep on our proc (in case of exit).
+        * Preserve synchronization semantics of vfork.  If waiting for
+        * child to exec or exit, set P_PPWAIT on child, and sleep on our
+        * proc (in case of exit).
         */
        if (isvfork)
         */
        if (isvfork)
-               while (p2->p_flag & SPPWAIT)
-                       tsleep((caddr_t)p1, PWAIT, "ppwait", 0);
+               while (p2->p_flag & P_PPWAIT)
+                       tsleep(p1, PWAIT, "ppwait", 0);
 
        /*
         * Return child pid to parent process,
 
        /*
         * Return child pid to parent process,
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.