fix olstat to give the correct symlink info

[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 5298471..af3252a 100644 (file)
--- a/usr/src/sys/kern/kern_fork.c
+++ b/usr/src/sys/kern/kern_fork.c
@@ -1,24 +1,29 @@
 /*
 /*

- * 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.38 (Berkeley) %G%
+ *     @(#)kern_fork.c 8.7 (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;
 
 struct fork_args {
        int     dummy;


@@ -50,33 +55,33 @@ fork1(p1, isvfork, retval)
        int isvfork, retval[];
 {
        register struct proc *p2;
        int isvfork, retval[];
 {
        register struct proc *p2;

-       register int count, uid;
+       register uid_t uid;

        struct proc *newproc;
        struct proc **hash;
        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 = (struct proc *)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 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 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.
+        * 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);
 
        /* Allocate new proc. */
        MALLOC(newproc, struct proc *, sizeof(struct proc), M_PROC, M_WAITOK);


@@ -105,9 +110,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 +127,19 @@ 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 +156,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 +165,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 +184,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 +209,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 +236,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,