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 d34785b..d4f373d 100644 (file)
--- a/usr/src/sys/kern/kern_fork.c
+++ b/usr/src/sys/kern/kern_fork.c
@@ -1,33 +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.39 (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 "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>

 
 

-struct fork_args {
-       int     dummy;
-};

 /* ARGSUSED */
 fork(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 fork(p, uap, retval)
        struct proc *p;

-       struct fork_args *uap;
-       int retval[];
+       void *uap;
+       register_t *retval;

 {
 
        return (fork1(p, 0, retval));
 {
 
        return (fork1(p, 0, retval));


@@ -36,8 +38,8 @@ fork(p, uap, retval)
 /* ARGSUSED */
 vfork(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 vfork(p, uap, retval)
        struct proc *p;

-       struct fork_args *uap;
-       int retval[];
+       void *uap;
+       register_t *retval;

 {
 
        return (fork1(p, 1, retval));
 {
 
        return (fork1(p, 1, retval));


@@ -47,7 +49,8 @@ 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 uid_t uid;
 {
        register struct proc *p2;
        register uid_t uid;


@@ -59,15 +62,16 @@ fork1(p1, isvfork, retval)
        /*
         * Although process entries are dynamically created, we still keep
         * a global limit on the maximum number we will create.  Don't allow
        /*
         * 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 bring the system within one of the global
-        * limit; don't let root exceed the limit. The variable nprocs is
-        * the current number of processes, maxproc is the limit.
+        * 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.

         */
        uid = p1->p_cred->p_ruid;
         */
        uid = p1->p_cred->p_ruid;

-       if (nprocs >= maxproc || uid == 0 && nprocs >= maxproc + 1) {
+       if ((nprocs >= maxproc - 1 && uid != 0) || nprocs >= maxproc) {

                tablefull("proc");
                return (EAGAIN);
        }
                tablefull("proc");
                return (EAGAIN);
        }

+

        /*
         * Increment the count of procs running with this uid. Don't allow
         * a nonprivileged user to exceed their current limit.
        /*
         * Increment the count of procs running with this uid. Don't allow
         * a nonprivileged user to exceed their current limit.


@@ -105,9 +109,9 @@ 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 = (struct proc *)allproc;
+               p2 = allproc.lh_first;

 again:
 again:

-               for (; p2 != NULL; p2 = p2->p_nxt) {
+               for (; p2 != 0; p2 = p2->p_list.le_next) {

                        while (p2->p_pid == nextpid ||
                            p2->p_pgrp->pg_id == nextpid) {
                                nextpid++;
                        while (p2->p_pid == nextpid ||
                            p2->p_pgrp->pg_id == nextpid) {
                                nextpid++;


@@ -122,28 +126,18 @@ again:
                }
                if (!doingzomb) {
                        doingzomb = 1;
                }
                if (!doingzomb) {
                        doingzomb = 1;

-                       p2 = zombproc;
+                       p2 = zombproc.lh_first;

                        goto again;
                }
        }
 
                        goto again;
                }
        }
 

-
-       /* Link onto allproc (this should probably be delayed). */

        nprocs++;
        p2 = newproc;
        p2->p_stat = SIDL;                      /* protect against others */
        p2->p_pid = nextpid;
        nprocs++;
        p2 = newproc;
        p2->p_stat = SIDL;                      /* protect against others */
        p2->p_pid = nextpid;

-       p2->p_nxt = (struct proc *)allproc;
-       p2->p_nxt->p_prev = &p2->p_nxt;         /* allproc is never NULL */
-       p2->p_prev = (struct proc **)&allproc;
-       allproc = p2;
-       p2->p_link = NULL;                      /* shouldn't be necessary */
-       p2->p_rlink = NULL;                     /* shouldn't be necessary */
-
-       /* Insert on the hash chain. */
-       hash = &pidhash[PIDHASH(p2->p_pid)];
-       p2->p_hash = *hash;
-       *hash = p2;
+       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.


@@ -160,8 +154,8 @@ again:
         * Increase reference counts on shared objects.
         * The p_stats and p_sigacts substructs are set in vm_fork.
         */
         * Increase reference counts on shared objects.
         * The p_stats and p_sigacts substructs are set in vm_fork.
         */

-       p2->p_flag = SLOAD | (p1->p_flag & SHPUX);
-       if (p1->p_flag & SPROFIL)
+       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);
                startprofclock(p2);
        MALLOC(p2->p_cred, struct pcred *, sizeof(struct pcred),
            M_SUBPROC, M_WAITOK);


@@ -169,6 +163,11 @@ again:
        p2->p_cred->p_refcnt = 1;
        crhold(p1->p_ucred);
 
        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,


@@ -183,17 +182,15 @@ again:
                p2->p_limit->p_refcnt++;
        }
 
                p2->p_limit->p_refcnt++;
        }
 

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


@@ -210,7 +207,7 @@ again:
         * 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.


@@ -237,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,