add definition for ability to produce a backtrace

[unix-history] / usr / src / sys / kern / kern_sysctl.c

diff --git a/usr/src/sys/kern/kern_sysctl.c b/usr/src/sys/kern/kern_sysctl.c
index de77589..3b91635 100644 (file)
--- a/usr/src/sys/kern/kern_sysctl.c
+++ b/usr/src/sys/kern/kern_sysctl.c
@@ -1,199 +1,767 @@
-/*
- * Copyright (c) 1982, 1986, 1989 Regents of the University of California.
- * All rights reserved.
+/*-
+ * Copyright (c) 1982, 1986, 1989, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Mike Karels at Berkeley Software Design, Inc.

  *
  *

- * Redistribution and use in source and binary forms are permitted
- * provided that the above copyright notice and this paragraph are
- * duplicated in all such forms and that any documentation,
- * advertising materials, and other materials related to such
- * distribution and use acknowledge that the software was developed
- * by the University of California, Berkeley.  The name of the
- * University may not be used to endorse or promote products derived
- * from this software without specific prior written permission.
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ * %sccs.include.redist.c%

  *
  *

- *     @(#)kern_sysctl.c       7.1 (Berkeley) %G%
+ *     @(#)kern_sysctl.c       8.8 (Berkeley) %G%
+ */
+
+/*
+ * sysctl system call.

  */
 
  */
 

-#include "kinfo.h"
-#include "vm.h"
-#include "ioctl.h"
-#include "tty.h"
-#include "buf.h"
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/malloc.h>
+#include <sys/proc.h>
+#include <sys/file.h>
+#include <sys/vnode.h>
+#include <sys/unistd.h>
+#include <sys/buf.h>
+#include <sys/ioctl.h>
+#include <sys/tty.h>
+#include <vm/vm.h>
+#include <sys/sysctl.h>
+
+#include <sys/mount.h>
+#include <sys/syscallargs.h>

 
 

-/* TODO - gather stats on average and max time spent */
-getkinfo()
+sysctlfn kern_sysctl;
+sysctlfn hw_sysctl;
+#ifdef DEBUG
+sysctlfn debug_sysctl;
+#endif
+extern sysctlfn vm_sysctl;
+extern sysctlfn vfs_sysctl;
+extern sysctlfn net_sysctl;
+extern sysctlfn cpu_sysctl;
+
+/*
+ * Locking and stats
+ */
+static struct sysctl_lock {
+       int     sl_lock;
+       int     sl_want;
+       int     sl_locked;
+} memlock;
+
+int
+__sysctl(p, uap, retval)
+       struct proc *p;
+       register struct __sysctl_args /* {
+               syscallarg(int *) name;
+               syscallarg(u_int) namelen;
+               syscallarg(void *) old;
+               syscallarg(size_t *) oldlenp;
+               syscallarg(void *) new;
+               syscallarg(size_t) newlen;
+       } */ *uap;
+       register_t *retval;

 {
 {

-       register struct a {
-               int     op;
-               char    *where;
-               int     *size;
-               int     arg;
-       } *uap = (struct a *)u.u_ap;
-       int wanted;
+       int error, dolock = 1;
+       size_t savelen, oldlen = 0;
+       sysctlfn *fn;
+       int name[CTL_MAXNAME];

 
 

-       switch (ki_type(uap->op)) {
+       if (SCARG(uap, new) != NULL &&
+           (error = suser(p->p_ucred, &p->p_acflag)))
+               return (error);
+       /*
+        * all top-level sysctl names are non-terminal
+        */
+       if (SCARG(uap, namelen) > CTL_MAXNAME || SCARG(uap, namelen) < 2)
+               return (EINVAL);
+       if (error =
+           copyin(SCARG(uap, name), &name, SCARG(uap, namelen) * sizeof(int)))
+               return (error);

 
 

-       case KINFO_PROC:
-               u.u_error = kinfo_proc(uap->op, (char *)uap->where, 
-                                      (int *)uap->size, uap->arg, &wanted);
-               if (!u.u_error)
-                       u.u_r.r_val1 = wanted;
+       switch (name[0]) {
+       case CTL_KERN:
+               fn = kern_sysctl;
+               if (name[2] == KERN_VNODE)      /* XXX */
+                       dolock = 0;
+               break;
+       case CTL_HW:
+               fn = hw_sysctl;
+               break;
+       case CTL_VM:
+               fn = vm_sysctl;
+               break;
+       case CTL_NET:
+               fn = net_sysctl;
+               break;
+       case CTL_VFS:
+               fn = vfs_sysctl;
+               break;
+       case CTL_MACHDEP:
+               fn = cpu_sysctl;
+               break;
+#ifdef DEBUG
+       case CTL_DEBUG:
+               fn = debug_sysctl;

                break;
                break;

+#endif
+       default:
+               return (EOPNOTSUPP);
+       }

 
 

+       if (SCARG(uap, oldlenp) &&
+           (error = copyin(SCARG(uap, oldlenp), &oldlen, sizeof(oldlen))))
+               return (error);
+       if (SCARG(uap, old) != NULL) {
+               if (!useracc(SCARG(uap, old), oldlen, B_WRITE))
+                       return (EFAULT);
+               while (memlock.sl_lock) {
+                       memlock.sl_want = 1;
+                       sleep((caddr_t)&memlock, PRIBIO+1);
+                       memlock.sl_locked++;
+               }
+               memlock.sl_lock = 1;
+               if (dolock)
+                       vslock(SCARG(uap, old), oldlen);
+               savelen = oldlen;
+       }
+       error = (*fn)(name + 1, SCARG(uap, namelen) - 1, SCARG(uap, old),
+           &oldlen, SCARG(uap, new), SCARG(uap, newlen), p);
+       if (SCARG(uap, old) != NULL) {
+               if (dolock)
+                       vsunlock(SCARG(uap, old), savelen, B_WRITE);
+               memlock.sl_lock = 0;
+               if (memlock.sl_want) {
+                       memlock.sl_want = 0;
+                       wakeup((caddr_t)&memlock);
+               }
+       }
+       if (error)
+               return (error);
+       if (SCARG(uap, oldlenp))
+               error = copyout(&oldlen, SCARG(uap, oldlenp), sizeof(oldlen));
+       *retval = oldlen;
+       return (0);
+}
+
+/*
+ * Attributes stored in the kernel.
+ */
+char hostname[MAXHOSTNAMELEN];
+int hostnamelen;
+long hostid;
+int securelevel;
+
+/*
+ * kernel related system variables.
+ */
+kern_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
+       int *name;
+       u_int namelen;
+       void *oldp;
+       size_t *oldlenp;
+       void *newp;
+       size_t newlen;
+       struct proc *p;
+{
+       int error, level, inthostid;
+       extern char ostype[], osrelease[], version[];
+
+       /* all sysctl names at this level are terminal */
+       if (namelen != 1 && !(name[0] == KERN_PROC || name[0] == KERN_PROF))
+               return (ENOTDIR);               /* overloaded */
+
+       switch (name[0]) {
+       case KERN_OSTYPE:
+               return (sysctl_rdstring(oldp, oldlenp, newp, ostype));
+       case KERN_OSRELEASE:
+               return (sysctl_rdstring(oldp, oldlenp, newp, osrelease));
+       case KERN_OSREV:
+               return (sysctl_rdint(oldp, oldlenp, newp, BSD));
+       case KERN_VERSION:
+               return (sysctl_rdstring(oldp, oldlenp, newp, version));
+       case KERN_MAXVNODES:
+               return(sysctl_int(oldp, oldlenp, newp, newlen, &desiredvnodes));
+       case KERN_MAXPROC:
+               return (sysctl_int(oldp, oldlenp, newp, newlen, &maxproc));
+       case KERN_MAXFILES:
+               return (sysctl_int(oldp, oldlenp, newp, newlen, &maxfiles));
+       case KERN_ARGMAX:
+               return (sysctl_rdint(oldp, oldlenp, newp, ARG_MAX));
+       case KERN_SECURELVL:
+               level = securelevel;
+               if ((error = sysctl_int(oldp, oldlenp, newp, newlen, &level)) ||
+                   newp == NULL)
+                       return (error);
+               if (level < securelevel && p->p_pid != 1)
+                       return (EPERM);
+               securelevel = level;
+               return (0);
+       case KERN_HOSTNAME:
+               error = sysctl_string(oldp, oldlenp, newp, newlen,
+                   hostname, sizeof(hostname));
+               if (newp && !error)
+                       hostnamelen = newlen;
+               return (error);
+       case KERN_HOSTID:
+               inthostid = hostid;  /* XXX assumes sizeof long <= sizeof int */
+               error =  sysctl_int(oldp, oldlenp, newp, newlen, &inthostid);
+               hostid = inthostid;
+               return (error);
+       case KERN_CLOCKRATE:
+               return (sysctl_clockrate(oldp, oldlenp));
+       case KERN_BOOTTIME:
+               return (sysctl_rdstruct(oldp, oldlenp, newp, &boottime,
+                   sizeof(struct timeval)));
+       case KERN_VNODE:
+               return (sysctl_vnode(oldp, oldlenp));
+       case KERN_PROC:
+               return (sysctl_doproc(name + 1, namelen - 1, oldp, oldlenp));
+       case KERN_FILE:
+               return (sysctl_file(oldp, oldlenp));
+#ifdef GPROF
+       case KERN_PROF:
+               return (sysctl_doprof(name + 1, namelen - 1, oldp, oldlenp,
+                   newp, newlen));
+#endif
+       case KERN_POSIX1:
+               return (sysctl_rdint(oldp, oldlenp, newp, _POSIX_VERSION));
+       case KERN_NGROUPS:
+               return (sysctl_rdint(oldp, oldlenp, newp, NGROUPS_MAX));
+       case KERN_JOB_CONTROL:
+               return (sysctl_rdint(oldp, oldlenp, newp, 1));
+       case KERN_SAVED_IDS:
+#ifdef _POSIX_SAVED_IDS
+               return (sysctl_rdint(oldp, oldlenp, newp, 1));
+#else
+               return (sysctl_rdint(oldp, oldlenp, newp, 0));
+#endif

        default:
        default:

-               u.u_error = EINVAL;
+               return (EOPNOTSUPP);

        }
        }

+       /* NOTREACHED */
+}

 
 

-       return;
+/*
+ * hardware related system variables.
+ */
+hw_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
+       int *name;
+       u_int namelen;
+       void *oldp;
+       size_t *oldlenp;
+       void *newp;
+       size_t newlen;
+       struct proc *p;
+{
+       extern char machine[], cpu_model[];
+
+       /* all sysctl names at this level are terminal */
+       if (namelen != 1)
+               return (ENOTDIR);               /* overloaded */
+
+       switch (name[0]) {
+       case HW_MACHINE:
+               return (sysctl_rdstring(oldp, oldlenp, newp, machine));
+       case HW_MODEL:
+               return (sysctl_rdstring(oldp, oldlenp, newp, cpu_model));
+       case HW_NCPU:
+               return (sysctl_rdint(oldp, oldlenp, newp, 1));  /* XXX */
+       case HW_BYTEORDER:
+               return (sysctl_rdint(oldp, oldlenp, newp, BYTE_ORDER));
+       case HW_PHYSMEM:
+               return (sysctl_rdint(oldp, oldlenp, newp, ctob(physmem)));
+       case HW_USERMEM:
+               return (sysctl_rdint(oldp, oldlenp, newp,
+                   ctob(physmem - cnt.v_wire_count)));
+       case HW_PAGESIZE:
+               return (sysctl_rdint(oldp, oldlenp, newp, PAGE_SIZE));
+       default:
+               return (EOPNOTSUPP);
+       }
+       /* NOTREACHED */

 }
 
 }
 

-/* 
- * try over estimating by 5 procs 
+#ifdef DEBUG
+/*
+ * Debugging related system variables.

  */
  */

-#define KINFO_PROCSLOP (5 * sizeof (struct kinfo_proc))
+struct ctldebug debug0, debug1, debug2, debug3, debug4;
+struct ctldebug debug5, debug6, debug7, debug8, debug9;
+struct ctldebug debug10, debug11, debug12, debug13, debug14;
+struct ctldebug debug15, debug16, debug17, debug18, debug19;
+static struct ctldebug *debugvars[CTL_DEBUG_MAXID] = {
+       &debug0, &debug1, &debug2, &debug3, &debug4,
+       &debug5, &debug6, &debug7, &debug8, &debug9,
+       &debug10, &debug11, &debug12, &debug13, &debug14,
+       &debug15, &debug16, &debug17, &debug18, &debug19,
+};
+int
+debug_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
+       int *name;
+       u_int namelen;
+       void *oldp;
+       size_t *oldlenp;
+       void *newp;
+       size_t newlen;
+       struct proc *p;
+{
+       struct ctldebug *cdp;
+
+       /* all sysctl names at this level are name and field */
+       if (namelen != 2)
+               return (ENOTDIR);               /* overloaded */
+       cdp = debugvars[name[0]];
+       if (name[0] >= CTL_DEBUG_MAXID || cdp->debugname == 0)
+               return (EOPNOTSUPP);
+       switch (name[1]) {
+       case CTL_DEBUG_NAME:
+               return (sysctl_rdstring(oldp, oldlenp, newp, cdp->debugname));
+       case CTL_DEBUG_VALUE:
+               return (sysctl_int(oldp, oldlenp, newp, newlen, cdp->debugvar));
+       default:
+               return (EOPNOTSUPP);
+       }
+       /* NOTREACHED */
+}
+#endif /* DEBUG */

 
 

-int kinfo_proc_userfailed;
-int kinfo_proc_wefailed;
+/*
+ * Validate parameters and get old / set new parameters
+ * for an integer-valued sysctl function.
+ */
+sysctl_int(oldp, oldlenp, newp, newlen, valp)
+       void *oldp;
+       size_t *oldlenp;
+       void *newp;
+       size_t newlen;
+       int *valp;
+{
+       int error = 0;

 
 

-kinfo_proc(op, where, asize, arg, awanted)
+       if (oldp && *oldlenp < sizeof(int))
+               return (ENOMEM);
+       if (newp && newlen != sizeof(int))
+               return (EINVAL);
+       *oldlenp = sizeof(int);
+       if (oldp)
+               error = copyout(valp, oldp, sizeof(int));
+       if (error == 0 && newp)
+               error = copyin(newp, valp, sizeof(int));
+       return (error);
+}
+
+/*
+ * As above, but read-only.
+ */
+sysctl_rdint(oldp, oldlenp, newp, val)
+       void *oldp;
+       size_t *oldlenp;
+       void *newp;
+       int val;
+{
+       int error = 0;
+
+       if (oldp && *oldlenp < sizeof(int))
+               return (ENOMEM);
+       if (newp)
+               return (EPERM);
+       *oldlenp = sizeof(int);
+       if (oldp)
+               error = copyout((caddr_t)&val, oldp, sizeof(int));
+       return (error);
+}
+
+/*
+ * Validate parameters and get old / set new parameters
+ * for a string-valued sysctl function.
+ */
+sysctl_string(oldp, oldlenp, newp, newlen, str, maxlen)
+       void *oldp;
+       size_t *oldlenp;
+       void *newp;
+       size_t newlen;
+       char *str;
+       int maxlen;
+{
+       int len, error = 0;
+
+       len = strlen(str) + 1;
+       if (oldp && *oldlenp < len)
+               return (ENOMEM);
+       if (newp && newlen >= maxlen)
+               return (EINVAL);
+       if (oldp) {
+               *oldlenp = len;
+               error = copyout(str, oldp, len);
+       }
+       if (error == 0 && newp) {
+               error = copyin(newp, str, newlen);
+               str[newlen] = 0;
+       }
+       return (error);
+}
+
+/*
+ * As above, but read-only.
+ */
+sysctl_rdstring(oldp, oldlenp, newp, str)
+       void *oldp;
+       size_t *oldlenp;
+       void *newp;
+       char *str;
+{
+       int len, error = 0;
+
+       len = strlen(str) + 1;
+       if (oldp && *oldlenp < len)
+               return (ENOMEM);
+       if (newp)
+               return (EPERM);
+       *oldlenp = len;
+       if (oldp)
+               error = copyout(str, oldp, len);
+       return (error);
+}
+
+/*
+ * Validate parameters and get old / set new parameters
+ * for a structure oriented sysctl function.
+ */
+sysctl_struct(oldp, oldlenp, newp, newlen, sp, len)
+       void *oldp;
+       size_t *oldlenp;
+       void *newp;
+       size_t newlen;
+       void *sp;
+       int len;
+{
+       int error = 0;
+
+       if (oldp && *oldlenp < len)
+               return (ENOMEM);
+       if (newp && newlen > len)
+               return (EINVAL);
+       if (oldp) {
+               *oldlenp = len;
+               error = copyout(sp, oldp, len);
+       }
+       if (error == 0 && newp)
+               error = copyin(newp, sp, len);
+       return (error);
+}
+
+/*
+ * Validate parameters and get old parameters
+ * for a structure oriented sysctl function.
+ */
+sysctl_rdstruct(oldp, oldlenp, newp, sp, len)
+       void *oldp;
+       size_t *oldlenp;
+       void *newp, *sp;
+       int len;
+{
+       int error = 0;
+
+       if (oldp && *oldlenp < len)
+               return (ENOMEM);
+       if (newp)
+               return (EPERM);
+       *oldlenp = len;
+       if (oldp)
+               error = copyout(sp, oldp, len);
+       return (error);
+}
+
+/*
+ * Get file structures.
+ */
+sysctl_file(where, sizep)

        char *where;
        char *where;

-       int *asize, *awanted;
+       size_t *sizep;

 {
 {

-       int     bufsize,        /* max size of users buffer */
-               copysize,       /* size copied */
-               needed; 
-       int locked;
-       int error;
+       int buflen, error;
+       struct file *fp;
+       char *start = where;

 
 

-       if (error = kinfo_doprocs(op, NULL, NULL, arg, &needed))
-               return (error);
-       if (where == NULL || asize == NULL) {
-               *awanted = needed;
+       buflen = *sizep;
+       if (where == NULL) {
+               /*
+                * overestimate by 10 files
+                */
+               *sizep = sizeof(filehead) + (nfiles + 10) * sizeof(struct file);

                return (0);
        }
                return (0);
        }

-       if (error = copyin((caddr_t)asize, (caddr_t)&bufsize, sizeof (bufsize)))
-               return (error);
-       needed += KINFO_PROCSLOP;
-       locked = copysize = MIN(needed, bufsize);
-       if (!useracc(where, copysize, B_WRITE))
-               return (EFAULT);
+

        /*
        /*

-        * lock down target pages - NEED DEADLOCK AVOIDANCE
+        * first copyout filehead

         */
         */

-       if (copysize > ((int)ptob(freemem) - (20 * 1024)))      /* XXX */
-               return (ENOMEM);
-       vslock(where, copysize);
-       error = kinfo_doprocs(op, where, &copysize, arg, &needed);
-       vsunlock(where, locked, B_WRITE);
-       if (error)
-               return (error);
-       *awanted = needed;
-       if (error = copyout((caddr_t)&copysize, (caddr_t)asize,
-           sizeof (copysize)))
+       if (buflen < sizeof(filehead)) {
+               *sizep = 0;
+               return (0);
+       }
+       if (error = copyout((caddr_t)&filehead, where, sizeof(filehead)))

                return (error);
                return (error);

-       
+       buflen -= sizeof(filehead);
+       where += sizeof(filehead);
+
+       /*
+        * followed by an array of file structures
+        */
+       for (fp = filehead.lh_first; fp != 0; fp = fp->f_list.le_next) {
+               if (buflen < sizeof(struct file)) {
+                       *sizep = where - start;
+                       return (ENOMEM);
+               }
+               if (error = copyout((caddr_t)fp, where, sizeof (struct file)))
+                       return (error);
+               buflen -= sizeof(struct file);
+               where += sizeof(struct file);
+       }
+       *sizep = where - start;

        return (0);
 }
 
        return (0);
 }
 

-kinfo_doprocs(op, where, acopysize, arg, aneeded)
+/*
+ * try over estimating by 5 procs
+ */
+#define KERN_PROCSLOP  (5 * sizeof (struct kinfo_proc))
+
+sysctl_doproc(name, namelen, where, sizep)
+       int *name;
+       u_int namelen;

        char *where;
        char *where;

-       int *acopysize, *aneeded;
+       size_t *sizep;

 {
        register struct proc *p;
 {
        register struct proc *p;

-       register caddr_t dp = (caddr_t)where;
-       register needed = 0;
-       int buflen;
+       register struct kinfo_proc *dp = (struct kinfo_proc *)where;
+       register int needed = 0;
+       int buflen = where != NULL ? *sizep : 0;

        int doingzomb;
        int doingzomb;

-       struct {
-               struct  proc *paddr;
-               struct  session *session;
-               pid_t   pgid;
-               short   jobc;
-               dev_t   ttydev;
-               pid_t   ttypgid;
-               struct  session *ttysession;
-       } extra;
-       struct tty *tp;
+       struct eproc eproc;

        int error = 0;
 
        int error = 0;
 

-       if (where != NULL)
-               buflen = *acopysize;
-
-       p = allproc;
+       if (namelen != 2 && !(namelen == 1 && name[0] == KERN_PROC_ALL))
+               return (EINVAL);
+       p = allproc.lh_first;

        doingzomb = 0;
 again:
        doingzomb = 0;
 again:

-       for (; p != NULL; p = p->p_nxt) {
-               /* 
+       for (; p != 0; p = p->p_list.le_next) {
+               /*
+                * Skip embryonic processes.
+                */
+               if (p->p_stat == SIDL)
+                       continue;
+               /*

                 * TODO - make more efficient (see notes below).
                 * TODO - make more efficient (see notes below).

-                * do by session. 
+                * do by session.

                 */
                 */

-               switch (ki_op(op)) {
+               switch (name[0]) {

 
 

-               case KINFO_PROC_PID:
+               case KERN_PROC_PID:

                        /* could do this with just a lookup */
                        /* could do this with just a lookup */

-                       if (p->p_pid != (pid_t)arg)
+                       if (p->p_pid != (pid_t)name[1])

                                continue;
                        break;
 
                                continue;
                        break;
 

-               case KINFO_PROC_PGRP:
+               case KERN_PROC_PGRP:

                        /* could do this by traversing pgrp */
                        /* could do this by traversing pgrp */

-                       if (p->p_pgrp->pg_id != (pid_t)arg)
+                       if (p->p_pgrp->pg_id != (pid_t)name[1])

                                continue;
                        break;
 
                                continue;
                        break;
 

-               case KINFO_PROC_TTY:
-                       if ((p->p_flag&SCTTY) == 0 || 
+               case KERN_PROC_TTY:
+                       if ((p->p_flag & P_CONTROLT) == 0 ||

                            p->p_session->s_ttyp == NULL ||
                            p->p_session->s_ttyp == NULL ||

-                           p->p_session->s_ttyp->t_dev != (dev_t)arg)
+                           p->p_session->s_ttyp->t_dev != (dev_t)name[1])

                                continue;
                        break;
 
                                continue;
                        break;
 

-               case KINFO_PROC_UID:
-                       if (p->p_uid != (uid_t)arg)
+               case KERN_PROC_UID:
+                       if (p->p_ucred->cr_uid != (uid_t)name[1])

                                continue;
                        break;
 
                                continue;
                        break;
 

-               case KINFO_PROC_RUID:
-                       if (p->p_ruid != (uid_t)arg)
+               case KERN_PROC_RUID:
+                       if (p->p_cred->p_ruid != (uid_t)name[1])

                                continue;
                        break;
                }
                                continue;
                        break;
                }

-               if (where != NULL && buflen >= sizeof (struct kinfo_proc)) {
-                       if (error = copyout((caddr_t)p, dp, 
-                           sizeof (struct proc)))
+               if (buflen >= sizeof(struct kinfo_proc)) {
+                       fill_eproc(p, &eproc);
+                       if (error = copyout((caddr_t)p, &dp->kp_proc,
+                           sizeof(struct proc)))

                                return (error);
                                return (error);

-                       dp += sizeof (struct proc);
-                       extra.paddr = p;
-                       extra.session = p->p_pgrp->pg_session;
-                       extra.pgid = p->p_pgrp->pg_id;
-                       extra.jobc = p->p_pgrp->pg_jobc;
-                       tp = p->p_pgrp->pg_session->s_ttyp;
-                       if ((p->p_flag&SCTTY) && tp != NULL) {
-                               extra.ttydev = tp->t_dev;
-                               extra.ttypgid = tp->t_pgrp ? 
-                                       tp->t_pgrp->pg_id : -1;
-                               extra.ttysession = tp->t_session;
-                       } else
-                               extra.ttydev = NODEV;
-                       if (error = copyout((caddr_t)&extra, dp, 
-                           sizeof (extra)))
+                       if (error = copyout((caddr_t)&eproc, &dp->kp_eproc,
+                           sizeof(eproc)))

                                return (error);
                                return (error);

-                       dp += sizeof (extra);
-                       buflen -= sizeof (struct kinfo_proc);
+                       dp++;
+                       buflen -= sizeof(struct kinfo_proc);

                }
                }

-               needed += sizeof (struct kinfo_proc);
+               needed += sizeof(struct kinfo_proc);

        }
        if (doingzomb == 0) {
        }
        if (doingzomb == 0) {

-               p = zombproc;
+               p = zombproc.lh_first;

                doingzomb++;
                goto again;
        }
                doingzomb++;
                goto again;
        }

-       if (where != NULL)
-               *acopysize = dp - where;
-       *aneeded = needed;
-
+       if (where != NULL) {
+               *sizep = (caddr_t)dp - where;
+               if (needed > *sizep)
+                       return (ENOMEM);
+       } else {
+               needed += KERN_PROCSLOP;
+               *sizep = needed;
+       }

        return (0);
 }
        return (0);
 }

+
+/*
+ * Fill in an eproc structure for the specified process.
+ */
+void
+fill_eproc(p, ep)
+       register struct proc *p;
+       register struct eproc *ep;
+{
+       register struct tty *tp;
+
+       ep->e_paddr = p;
+       ep->e_sess = p->p_pgrp->pg_session;
+       ep->e_pcred = *p->p_cred;
+       ep->e_ucred = *p->p_ucred;
+       if (p->p_stat == SIDL || p->p_stat == SZOMB) {
+               ep->e_vm.vm_rssize = 0;
+               ep->e_vm.vm_tsize = 0;
+               ep->e_vm.vm_dsize = 0;
+               ep->e_vm.vm_ssize = 0;
+#ifndef sparc
+               /* ep->e_vm.vm_pmap = XXX; */
+#endif
+       } else {
+               register struct vmspace *vm = p->p_vmspace;
+
+#ifdef pmap_resident_count
+               ep->e_vm.vm_rssize = pmap_resident_count(&vm->vm_pmap); /*XXX*/
+#else
+               ep->e_vm.vm_rssize = vm->vm_rssize;
+#endif
+               ep->e_vm.vm_tsize = vm->vm_tsize;
+               ep->e_vm.vm_dsize = vm->vm_dsize;
+               ep->e_vm.vm_ssize = vm->vm_ssize;
+#ifndef sparc
+               ep->e_vm.vm_pmap = vm->vm_pmap;
+#endif
+       }
+       if (p->p_pptr)
+               ep->e_ppid = p->p_pptr->p_pid;
+       else
+               ep->e_ppid = 0;
+       ep->e_pgid = p->p_pgrp->pg_id;
+       ep->e_jobc = p->p_pgrp->pg_jobc;
+       if ((p->p_flag & P_CONTROLT) &&
+            (tp = ep->e_sess->s_ttyp)) {
+               ep->e_tdev = tp->t_dev;
+               ep->e_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
+               ep->e_tsess = tp->t_session;
+       } else
+               ep->e_tdev = NODEV;
+       ep->e_flag = ep->e_sess->s_ttyvp ? EPROC_CTTY : 0;
+       if (SESS_LEADER(p))
+               ep->e_flag |= EPROC_SLEADER;
+       if (p->p_wmesg)
+               strncpy(ep->e_wmesg, p->p_wmesg, WMESGLEN);
+       ep->e_xsize = ep->e_xrssize = 0;
+       ep->e_xccount = ep->e_xswrss = 0;
+}
+
+#ifdef COMPAT_43
+#include <sys/socket.h>
+#define        KINFO_PROC              (0<<8)
+#define        KINFO_RT                (1<<8)
+#define        KINFO_VNODE             (2<<8)
+#define        KINFO_FILE              (3<<8)
+#define        KINFO_METER             (4<<8)
+#define        KINFO_LOADAVG           (5<<8)
+#define        KINFO_CLOCKRATE         (6<<8)
+
+compat_43_getkerninfo(p, uap, retval)
+       struct proc *p;
+       register struct compat_43_getkerninfo_args /* {
+               syscallarg(int) op;
+               syscallarg(char *) where;
+               syscallarg(int *) size;
+               syscallarg(int) arg;
+       } */ *uap;
+       register_t *retval;
+{
+       int error, name[5];
+       size_t size;
+
+       if (SCARG(uap, size) && (error = copyin((caddr_t)SCARG(uap, size),
+           (caddr_t)&size, sizeof(size))))
+               return (error);
+
+       switch (SCARG(uap, op) & 0xff00) {
+
+       case KINFO_RT:
+               name[0] = PF_ROUTE;
+               name[1] = 0;
+               name[2] = (SCARG(uap, op) & 0xff0000) >> 16;
+               name[3] = SCARG(uap, op) & 0xff;
+               name[4] = SCARG(uap, arg);
+               error =
+                   net_sysctl(name, 5, SCARG(uap, where), &size, NULL, 0, p);
+               break;
+
+       case KINFO_VNODE:
+               name[0] = KERN_VNODE;
+               error =
+                   kern_sysctl(name, 1, SCARG(uap, where), &size, NULL, 0, p);
+               break;
+
+       case KINFO_PROC:
+               name[0] = KERN_PROC;
+               name[1] = SCARG(uap, op) & 0xff;
+               name[2] = SCARG(uap, arg);
+               error =
+                   kern_sysctl(name, 3, SCARG(uap, where), &size, NULL, 0, p);
+               break;
+
+       case KINFO_FILE:
+               name[0] = KERN_FILE;
+               error =
+                   kern_sysctl(name, 1, SCARG(uap, where), &size, NULL, 0, p);
+               break;
+
+       case KINFO_METER:
+               name[0] = VM_METER;
+               error =
+                   vm_sysctl(name, 1, SCARG(uap, where), &size, NULL, 0, p);
+               break;
+
+       case KINFO_LOADAVG:
+               name[0] = VM_LOADAVG;
+               error =
+                   vm_sysctl(name, 1, SCARG(uap, where), &size, NULL, 0, p);
+               break;
+
+       case KINFO_CLOCKRATE:
+               name[0] = KERN_CLOCKRATE;
+               error =
+                   kern_sysctl(name, 1, SCARG(uap, where), &size, NULL, 0, p);
+               break;
+
+       default:
+               return (EOPNOTSUPP);
+       }
+       if (error)
+               return (error);
+       *retval = size;
+       if (SCARG(uap, size))
+               error = copyout((caddr_t)&size, (caddr_t)SCARG(uap, size),
+                   sizeof(size));
+       return (error);
+}
+#endif /* COMPAT_43 */