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 31067a7..3b91635 100644 (file)
--- a/usr/src/sys/kern/kern_sysctl.c
+++ b/usr/src/sys/kern/kern_sysctl.c
@@ -1,201 +1,619 @@
-/*
- * 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.

  *
  * %sccs.include.redist.c%
  *
  *
  * %sccs.include.redist.c%
  *

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

  */
 
 #include <sys/param.h>
  */
 
 #include <sys/param.h>

+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/malloc.h>

 #include <sys/proc.h>
 #include <sys/proc.h>

-#include <sys/kinfo.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 <sys/ioctl.h>
 #include <sys/tty.h>

-#include <sys/buf.h>
-#include <sys/file.h>
-

 #include <vm/vm.h>
 #include <vm/vm.h>

+#include <sys/sysctl.h>

 
 

-#include <sys/kinfo_proc.h>
+#include <sys/mount.h>
+#include <sys/syscallargs.h>

 
 

-#define snderr(e) { error = (e); goto release;}
-extern int kinfo_doproc(), kinfo_rtable(), kinfo_vnode(), kinfo_file();
-extern int kinfo_meter(), kinfo_loadavg(), kinfo_clockrate();
-struct kinfo_lock kinfo_lock;
+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;

 
 

-struct getkerninfo_args {
-       int     op;
-       char    *where;
-       int     *size;
-       int     arg;
-};
-/* ARGSUSED */
-getkerninfo(p, uap, retval)
+/*
+ * 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;
        struct proc *p;

-       register struct getkerninfo_args *uap;
-       int *retval;
+       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;

 {
 {

-       int bufsize;            /* max size of users buffer */
-       int needed, locked, (*server)(), error = 0;
-
-       switch (ki_type(uap->op)) {
-
-       case KINFO_PROC:
-               server = kinfo_doproc;
+       int error, dolock = 1;
+       size_t savelen, oldlen = 0;
+       sysctlfn *fn;
+       int name[CTL_MAXNAME];
+
+       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);
+
+       switch (name[0]) {
+       case CTL_KERN:
+               fn = kern_sysctl;
+               if (name[2] == KERN_VNODE)      /* XXX */
+                       dolock = 0;

                break;
                break;

-
-       case KINFO_RT:
-               server = kinfo_rtable;
+       case CTL_HW:
+               fn = hw_sysctl;

                break;
                break;

-
-       case KINFO_VNODE:
-               server = kinfo_vnode;
+       case CTL_VM:
+               fn = vm_sysctl;

                break;
                break;

-
-       case KINFO_FILE:
-               server = kinfo_file;
+       case CTL_NET:
+               fn = net_sysctl;

                break;
                break;

-
-       case KINFO_METER:
-               server = kinfo_meter;
+       case CTL_VFS:
+               fn = vfs_sysctl;

                break;
                break;

-
-       case KINFO_LOADAVG:
-               server = kinfo_loadavg;
+       case CTL_MACHDEP:
+               fn = cpu_sysctl;

                break;
                break;

-
-       case KINFO_CLOCKRATE:
-               server = kinfo_clockrate;
+#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:
+               return (EOPNOTSUPP);
+       }
+       /* NOTREACHED */
+}

 
 

+/*
+ * 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:
        default:

-               error = EINVAL;
-               goto done;
+               return (EOPNOTSUPP);

        }
        }

-       if (uap->where == NULL || uap->size == NULL) {
-               error = (*server)(uap->op, NULL, NULL, uap->arg, &needed);
-               goto done;
+       /* NOTREACHED */
+}
+
+#ifdef DEBUG
+/*
+ * Debugging related system variables.
+ */
+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);

        }
        }

-       if (error = copyin((caddr_t)uap->size, (caddr_t)&bufsize,
-           sizeof (bufsize)))
-               goto done;
-       while (kinfo_lock.kl_lock) {
-               kinfo_lock.kl_want = 1;
-               sleep((caddr_t)&kinfo_lock, PRIBIO+1);
-               kinfo_lock.kl_locked++;
+       /* NOTREACHED */
+}
+#endif /* DEBUG */
+
+/*
+ * 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;
+
+       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);

        }
        }

-       kinfo_lock.kl_lock = 1;
-
-       if (!useracc(uap->where, bufsize, B_WRITE))
-               snderr(EFAULT);
-       if (server != kinfo_vnode)      /* XXX */
-               vslock(uap->where, bufsize);
-       locked = bufsize;
-       error = (*server)(uap->op, uap->where, &bufsize, uap->arg, &needed);
-       if (server != kinfo_vnode)      /* XXX */
-               vsunlock(uap->where, locked, B_WRITE);
-       if (error == 0)
-               error = copyout((caddr_t)&bufsize,
-                               (caddr_t)uap->size, sizeof (bufsize));
-release:
-       kinfo_lock.kl_lock = 0;
-       if (kinfo_lock.kl_want) {
-               kinfo_lock.kl_want = 0;
-               wakeup((caddr_t)&kinfo_lock);
+       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);

        }
        }

-done:
-       if (!error)
-               *retval = needed;
+       if (error == 0 && newp)
+               error = copyin(newp, sp, len);

        return (error);
 }
 
        return (error);
 }
 

-/* 
- * try over estimating by 5 procs 
+/*
+ * Validate parameters and get old parameters
+ * for a structure oriented sysctl function.

  */
  */

-#define KINFO_PROCSLOP (5 * sizeof (struct kinfo_proc))
+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);
+}

 
 

-kinfo_doproc(op, where, acopysize, arg, aneeded)
-       int op;
+/*
+ * Get file structures.
+ */
+sysctl_file(where, sizep)

        char *where;
        char *where;

-       int *acopysize, arg, *aneeded;
+       size_t *sizep;
+{
+       int buflen, error;
+       struct file *fp;
+       char *start = where;
+
+       buflen = *sizep;
+       if (where == NULL) {
+               /*
+                * overestimate by 10 files
+                */
+               *sizep = sizeof(filehead) + (nfiles + 10) * sizeof(struct file);
+               return (0);
+       }
+
+       /*
+        * first copyout filehead
+        */
+       if (buflen < sizeof(filehead)) {
+               *sizep = 0;
+               return (0);
+       }
+       if (error = copyout((caddr_t)&filehead, where, sizeof(filehead)))
+               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);
+}
+
+/*
+ * 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;
+       size_t *sizep;

 {
        register struct proc *p;
        register struct kinfo_proc *dp = (struct kinfo_proc *)where;
 {
        register struct proc *p;
        register struct kinfo_proc *dp = (struct kinfo_proc *)where;

-       register needed = 0;
-       int buflen = where != NULL ? *acopysize : 0;
+       register int needed = 0;
+       int buflen = where != NULL ? *sizep : 0;

        int doingzomb;
        struct eproc eproc;
        int error = 0;
 
        int doingzomb;
        struct eproc eproc;
        int error = 0;
 

-       p = (struct proc *)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;
                /*
                 * 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_ucred->cr_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_cred->p_ruid != (uid_t)arg)
+               case KERN_PROC_RUID:
+                       if (p->p_cred->p_ruid != (uid_t)name[1])

                                continue;
                        break;
                }
                                continue;
                        break;
                }

-               if (buflen >= sizeof (struct kinfo_proc)) {
+               if (buflen >= sizeof(struct kinfo_proc)) {

                        fill_eproc(p, &eproc);
                        fill_eproc(p, &eproc);

-                       if (error = copyout((caddr_t)p, &dp->kp_proc, 
-                           sizeof (struct proc)))
+                       if (error = copyout((caddr_t)p, &dp->kp_proc,
+                           sizeof(struct proc)))

                                return (error);
                                return (error);

-                       if (error = copyout((caddr_t)&eproc, &dp->kp_eproc, 
-                           sizeof (eproc)))
+                       if (error = copyout((caddr_t)&eproc, &dp->kp_eproc,
+                           sizeof(eproc)))

                                return (error);
                        dp++;
                                return (error);
                        dp++;

-                       buflen -= sizeof (struct kinfo_proc);
+                       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 = (caddr_t)dp - where;
-       else
-               needed += KINFO_PROCSLOP;
-       *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);
 }
 


@@ -224,7 +642,11 @@ fill_eproc(p, ep)
        } else {
                register struct vmspace *vm = p->p_vmspace;
 
        } 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;
                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;
                ep->e_vm.vm_tsize = vm->vm_tsize;
                ep->e_vm.vm_dsize = vm->vm_dsize;
                ep->e_vm.vm_ssize = vm->vm_ssize;


@@ -238,7 +660,7 @@ fill_eproc(p, ep)
                ep->e_ppid = 0;
        ep->e_pgid = p->p_pgrp->pg_id;
        ep->e_jobc = p->p_pgrp->pg_jobc;
                ep->e_ppid = 0;
        ep->e_pgid = p->p_pgrp->pg_id;
        ep->e_jobc = p->p_pgrp->pg_jobc;

-       if ((p->p_flag&SCTTY) && 
+       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;
             (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;


@@ -254,56 +676,92 @@ fill_eproc(p, ep)
        ep->e_xccount = ep->e_xswrss = 0;
 }
 
        ep->e_xccount = ep->e_xswrss = 0;
 }
 

-/*
- * Get file structures.
- */
-kinfo_file(op, where, acopysize, arg, aneeded)
-       int op;
-       register char *where;
-       int *acopysize, arg, *aneeded;
+#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 buflen, needed, error;
-       struct file *fp;
-       char *start = where;
+       int error, name[5];
+       size_t size;

 
 

-       if (where == NULL) {
-               /*
-                * overestimate by 10 files
-                */
-               *aneeded = sizeof (filehead) + 
-                       (nfiles + 10) * sizeof (struct file);
-               return (0);
-       }
-       buflen = *acopysize;
-       needed = 0;
+       if (SCARG(uap, size) && (error = copyin((caddr_t)SCARG(uap, size),
+           (caddr_t)&size, sizeof(size))))
+               return (error);

 
 

-       /*
-        * first copyout filehead
-        */
-       if (buflen > sizeof (filehead)) {
-               if (error = copyout((caddr_t)&filehead, where,
-                   sizeof (filehead)))
-                       return (error);
-               buflen -= sizeof (filehead);
-               where += sizeof (filehead);
-       }
-       needed += sizeof (filehead);
+       switch (SCARG(uap, op) & 0xff00) {

 
 

-       /*
-        * followed by an array of file structures
-        */
-       for (fp = filehead; fp != NULL; fp = fp->f_filef) {
-               if (buflen > sizeof (struct file)) {
-                       if (error = copyout((caddr_t)fp, where,
-                           sizeof (struct file)))
-                               return (error);
-                       buflen -= sizeof (struct file);
-                       where += sizeof (struct file);
-               }
-               needed += sizeof (struct file);
-       }
-       *acopysize = where - start;
-       *aneeded = needed;
+       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;

 
 

-       return (0);
+       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 */