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

- * Copyright (c) 1982, 1986, 1989, 1993 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%
  *
  *
  * This code is derived from software contributed to Berkeley by
  * Mike Karels at Berkeley Software Design, Inc.
  *
  * %sccs.include.redist.c%
  *

- *     @(#)kern_sysctl.c       7.31 (Berkeley) %G%
+ *     @(#)kern_sysctl.c       8.8 (Berkeley) %G%

  */
 
 /*
  */
 
 /*


@@ -16,23 +16,28 @@
 
 #include <sys/param.h>
 #include <sys/systm.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/malloc.h>
 #include <sys/proc.h>
 #include <sys/file.h>

-#include <sys/sysctl.h>
+#include <sys/vnode.h>

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

 
 sysctlfn kern_sysctl;
 sysctlfn hw_sysctl;
 
 sysctlfn kern_sysctl;
 sysctlfn hw_sysctl;

+#ifdef DEBUG
+sysctlfn debug_sysctl;
+#endif

 extern sysctlfn vm_sysctl;
 extern sysctlfn vm_sysctl;

-extern sysctlfn fs_sysctl;
+extern sysctlfn vfs_sysctl;

 extern sysctlfn net_sysctl;
 extern sysctlfn cpu_sysctl;
 
 extern sysctlfn net_sysctl;
 extern sysctlfn cpu_sysctl;
 


@@ -45,39 +50,40 @@ static struct sysctl_lock {
        int     sl_locked;
 } memlock;
 
        int     sl_locked;
 } memlock;
 

-struct sysctl_args {
-       int     *name;
-       u_int   namelen;
-       void    *old;
-       size_t  *oldlenp;
-       void    *new;
-       size_t  newlen;
-};
-
-sysctl(p, uap, retval)
+int
+__sysctl(p, uap, retval)

        struct proc *p;
        struct proc *p;

-       register struct sysctl_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 error, dolock = 1;
 {
        int error, dolock = 1;

-       u_int savelen, oldlen = 0;
+       size_t savelen, oldlen = 0;

        sysctlfn *fn;
        int name[CTL_MAXNAME];
 
        sysctlfn *fn;
        int name[CTL_MAXNAME];
 

-       if (uap->new != NULL && (error = suser(p->p_ucred, &p->p_acflag)))
+       if (SCARG(uap, new) != NULL &&
+           (error = suser(p->p_ucred, &p->p_acflag)))

                return (error);
        /*
         * all top-level sysctl names are non-terminal
         */
                return (error);
        /*
         * all top-level sysctl names are non-terminal
         */

-       if (uap->namelen > CTL_MAXNAME || uap->namelen < 2)
+       if (SCARG(uap, namelen) > CTL_MAXNAME || SCARG(uap, namelen) < 2)

                return (EINVAL);
                return (EINVAL);

-       if (error = copyin(uap->name, &name, uap->namelen * sizeof(int)))
+       if (error =
+           copyin(SCARG(uap, name), &name, SCARG(uap, namelen) * sizeof(int)))

                return (error);
 
        switch (name[0]) {
        case CTL_KERN:
                fn = kern_sysctl;
                return (error);
 
        switch (name[0]) {
        case CTL_KERN:
                fn = kern_sysctl;

-               if (name[2] != KERN_VNODE)      /* XXX */
+               if (name[2] == KERN_VNODE)      /* XXX */

                        dolock = 0;
                break;
        case CTL_HW:
                        dolock = 0;
                break;
        case CTL_HW:


@@ -89,26 +95,26 @@ sysctl(p, uap, retval)
        case CTL_NET:
                fn = net_sysctl;
                break;
        case CTL_NET:
                fn = net_sysctl;
                break;

-#ifdef notyet
-       case CTL_FS:
-               fn = fs_sysctl;
-               break;
-       case CTL_DEBUG:
-               fn = debug_sysctl;
+       case CTL_VFS:
+               fn = vfs_sysctl;

                break;
        case CTL_MACHDEP:
                fn = cpu_sysctl;
                break;
                break;
        case CTL_MACHDEP:
                fn = cpu_sysctl;
                break;

+#ifdef DEBUG
+       case CTL_DEBUG:
+               fn = debug_sysctl;
+               break;

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

-       if (uap->oldlenp &&
-           (error = copyin(uap->oldlenp, &oldlen, sizeof(oldlen))))
+       if (SCARG(uap, oldlenp) &&
+           (error = copyin(SCARG(uap, oldlenp), &oldlen, sizeof(oldlen))))

                return (error);
                return (error);

-       if (uap->old != NULL) {
-               if (!useracc(uap->old, oldlen, B_WRITE))
+       if (SCARG(uap, old) != NULL) {
+               if (!useracc(SCARG(uap, old), oldlen, B_WRITE))

                        return (EFAULT);
                while (memlock.sl_lock) {
                        memlock.sl_want = 1;
                        return (EFAULT);
                while (memlock.sl_lock) {
                        memlock.sl_want = 1;


@@ -117,14 +123,14 @@ sysctl(p, uap, retval)
                }
                memlock.sl_lock = 1;
                if (dolock)
                }
                memlock.sl_lock = 1;
                if (dolock)

-                       vslock(uap->old, oldlen);
+                       vslock(SCARG(uap, old), oldlen);

                savelen = oldlen;
        }
                savelen = oldlen;
        }

-       error = (*fn)(name + 1, uap->namelen - 1, uap->old, &oldlen,
-           uap->new, uap->newlen, p);
-       if (uap->old != NULL) {
+       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)
                if (dolock)

-                       vsunlock(uap->old, savelen, B_WRITE);
+                       vsunlock(SCARG(uap, old), savelen, B_WRITE);

                memlock.sl_lock = 0;
                if (memlock.sl_want) {
                        memlock.sl_want = 0;
                memlock.sl_lock = 0;
                if (memlock.sl_want) {
                        memlock.sl_want = 0;


@@ -133,8 +139,8 @@ sysctl(p, uap, retval)
        }
        if (error)
                return (error);
        }
        if (error)
                return (error);

-       if (uap->oldlenp)
-               error = copyout(&oldlen, uap->oldlenp, sizeof(oldlen));
+       if (SCARG(uap, oldlenp))
+               error = copyout(&oldlen, SCARG(uap, oldlenp), sizeof(oldlen));

        *retval = oldlen;
        return (0);
 }
        *retval = oldlen;
        return (0);
 }


@@ -159,11 +165,11 @@ kern_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
        size_t newlen;
        struct proc *p;
 {
        size_t newlen;
        struct proc *p;
 {

-       int error, level;
+       int error, level, inthostid;

        extern char ostype[], osrelease[], version[];
 
        /* all sysctl names at this level are terminal */
        extern char ostype[], osrelease[], version[];
 
        /* all sysctl names at this level are terminal */

-       if (namelen != 1 && name[0] != KERN_PROC)
+       if (namelen != 1 && !(name[0] == KERN_PROC || name[0] == KERN_PROF))

                return (ENOTDIR);               /* overloaded */
 
        switch (name[0]) {
                return (ENOTDIR);               /* overloaded */
 
        switch (name[0]) {


@@ -175,22 +181,14 @@ kern_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
                return (sysctl_rdint(oldp, oldlenp, newp, BSD));
        case KERN_VERSION:
                return (sysctl_rdstring(oldp, oldlenp, newp, version));
                return (sysctl_rdint(oldp, oldlenp, newp, BSD));
        case KERN_VERSION:
                return (sysctl_rdstring(oldp, oldlenp, newp, version));

-       case KERN_POSIX1:
-               return (sysctl_rdint(oldp, oldlenp, newp, _POSIX_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_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_HOSTNAME:
-               error = sysctl_string(oldp, oldlenp, newp, newlen, 
-                   hostname, sizeof(hostname));
-               if (!error)
-                       hostnamelen = newlen;
-               return (error);
-       case KERN_HOSTID:
-               return (sysctl_int(oldp, oldlenp, newp, newlen, &hostid));

        case KERN_SECURELVL:
                level = securelevel;
                if ((error = sysctl_int(oldp, oldlenp, newp, newlen, &level)) ||
        case KERN_SECURELVL:
                level = securelevel;
                if ((error = sysctl_int(oldp, oldlenp, newp, newlen, &level)) ||


@@ -200,14 +198,45 @@ kern_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
                        return (EPERM);
                securelevel = level;
                return (0);
                        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_CLOCKRATE:
                return (sysctl_clockrate(oldp, oldlenp));

-       case KERN_FILE:
-               return (sysctl_file(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_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);
        }
        default:
                return (EOPNOTSUPP);
        }


@@ -239,8 +268,8 @@ hw_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
                return (sysctl_rdstring(oldp, oldlenp, newp, cpu_model));
        case HW_NCPU:
                return (sysctl_rdint(oldp, oldlenp, newp, 1));  /* XXX */
                return (sysctl_rdstring(oldp, oldlenp, newp, cpu_model));
        case HW_NCPU:
                return (sysctl_rdint(oldp, oldlenp, newp, 1));  /* XXX */

-       case HW_CPUSPEED:
-               return (sysctl_rdint(oldp, oldlenp, newp, cpuspeed));
+       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:
        case HW_PHYSMEM:
                return (sysctl_rdint(oldp, oldlenp, newp, ctob(physmem)));
        case HW_USERMEM:


@@ -254,6 +283,50 @@ hw_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
        /* NOTREACHED */
 }
 
        /* 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);
+       }
+       /* NOTREACHED */
+}
+#endif /* DEBUG */
+

 /*
  * Validate parameters and get old / set new parameters
  * for an integer-valued sysctl function.
 /*
  * Validate parameters and get old / set new parameters
  * for an integer-valued sysctl function.


@@ -352,6 +425,33 @@ sysctl_rdstring(oldp, oldlenp, newp, str)
        return (error);
 }
 
        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.
 /*
  * Validate parameters and get old parameters
  * for a structure oriented sysctl function.


@@ -403,13 +503,13 @@ sysctl_file(where, sizep)
        }
        if (error = copyout((caddr_t)&filehead, where, sizeof(filehead)))
                return (error);
        }
        if (error = copyout((caddr_t)&filehead, where, sizeof(filehead)))
                return (error);

-       buflen += sizeof(filehead);
+       buflen -= sizeof(filehead);

        where += sizeof(filehead);
 
        /*
         * followed by an array of file structures
         */
        where += sizeof(filehead);
 
        /*
         * followed by an array of file structures
         */

-       for (fp = filehead; fp != NULL; fp = fp->f_filef) {
+       for (fp = filehead.lh_first; fp != 0; fp = fp->f_list.le_next) {

                if (buflen < sizeof(struct file)) {
                        *sizep = where - start;
                        return (ENOMEM);
                if (buflen < sizeof(struct file)) {
                        *sizep = where - start;
                        return (ENOMEM);


@@ -423,8 +523,8 @@ sysctl_file(where, sizep)
        return (0);
 }
 
        return (0);
 }
 

-/* 
- * try over estimating by 5 procs 
+/*
+ * try over estimating by 5 procs

  */
 #define KERN_PROCSLOP  (5 * sizeof (struct kinfo_proc))
 
  */
 #define KERN_PROCSLOP  (5 * sizeof (struct kinfo_proc))
 


@@ -442,20 +542,20 @@ sysctl_doproc(name, namelen, where, sizep)
        struct eproc eproc;
        int error = 0;
 
        struct eproc eproc;
        int error = 0;
 

-       if (namelen != 2)
+       if (namelen != 2 && !(namelen == 1 && name[0] == KERN_PROC_ALL))

                return (EINVAL);
                return (EINVAL);

-       p = (struct proc *)allproc;
+       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 (name[0]) {
 
                 */
                switch (name[0]) {
 


@@ -472,7 +572,7 @@ again:
                        break;
 
                case KERN_PROC_TTY:
                        break;
 
                case KERN_PROC_TTY:

-                       if ((p->p_flag&SCTTY) == 0 || 
+                       if ((p->p_flag & P_CONTROLT) == 0 ||

                            p->p_session->s_ttyp == NULL ||
                            p->p_session->s_ttyp->t_dev != (dev_t)name[1])
                                continue;
                            p->p_session->s_ttyp == NULL ||
                            p->p_session->s_ttyp->t_dev != (dev_t)name[1])
                                continue;


@@ -490,10 +590,10 @@ again:
                }
                if (buflen >= sizeof(struct kinfo_proc)) {
                        fill_eproc(p, &eproc);
                }
                if (buflen >= sizeof(struct kinfo_proc)) {
                        fill_eproc(p, &eproc);

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

                            sizeof(struct proc)))
                                return (error);
                            sizeof(struct proc)))
                                return (error);

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

                            sizeof(eproc)))
                                return (error);
                        dp++;
                            sizeof(eproc)))
                                return (error);
                        dp++;


@@ -502,7 +602,7 @@ again:
                needed += sizeof(struct kinfo_proc);
        }
        if (doingzomb == 0) {
                needed += sizeof(struct kinfo_proc);
        }
        if (doingzomb == 0) {

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

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


@@ -542,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;


@@ -556,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;


@@ -582,66 +686,71 @@ fill_eproc(p, ep)
 #define        KINFO_LOADAVG           (5<<8)
 #define        KINFO_CLOCKRATE         (6<<8)
 
 #define        KINFO_LOADAVG           (5<<8)
 #define        KINFO_CLOCKRATE         (6<<8)
 

-struct getkerninfo_args {
-       int     op;
-       char    *where;
-       int     *size;
-       int     arg;
-};
-
-getkerninfo(p, uap, retval)
+compat_43_getkerninfo(p, uap, retval)

        struct proc *p;
        struct proc *p;

-       register struct getkerninfo_args *uap;
-       int *retval;
+       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];
 {
        int error, name[5];

-       u_int size;
+       size_t size;

 
 

-       if (uap->size &&
-           (error = copyin((caddr_t)uap->size, (caddr_t)&size, sizeof(size))))
+       if (SCARG(uap, size) && (error = copyin((caddr_t)SCARG(uap, size),
+           (caddr_t)&size, sizeof(size))))

                return (error);
 
                return (error);
 

-       switch (uap->op & 0xff00) {
+       switch (SCARG(uap, op) & 0xff00) {

 
        case KINFO_RT:
                name[0] = PF_ROUTE;
                name[1] = 0;
 
        case KINFO_RT:
                name[0] = PF_ROUTE;
                name[1] = 0;

-               name[2] = (uap->op & 0xff0000) >> 16;
-               name[3] = uap->op & 0xff;
-               name[4] = uap->arg;
-               error = net_sysctl(name, 5, uap->where, &size, NULL, 0, p);
+               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;
                break;
 
        case KINFO_VNODE:
                name[0] = KERN_VNODE;

-               error = kern_sysctl(name, 1, uap->where, &size, NULL, 0, p);
+               error =
+                   kern_sysctl(name, 1, SCARG(uap, where), &size, NULL, 0, p);

                break;
 
        case KINFO_PROC:
                name[0] = KERN_PROC;
                break;
 
        case KINFO_PROC:
                name[0] = KERN_PROC;

-               name[1] = uap->op & 0xff;
-               name[2] = uap->arg;
-               error = kern_sysctl(name, 3, uap->where, &size, NULL, 0, p);
+               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;
                break;
 
        case KINFO_FILE:
                name[0] = KERN_FILE;

-               error = kern_sysctl(name, 1, uap->where, &size, NULL, 0, p);
+               error =
+                   kern_sysctl(name, 1, SCARG(uap, where), &size, NULL, 0, p);

                break;
 
        case KINFO_METER:
                name[0] = VM_METER;
                break;
 
        case KINFO_METER:
                name[0] = VM_METER;

-               error = vm_sysctl(name, 1, uap->where, &size, NULL, 0, p);
+               error =
+                   vm_sysctl(name, 1, SCARG(uap, where), &size, NULL, 0, p);

                break;
 
        case KINFO_LOADAVG:
                name[0] = VM_LOADAVG;
                break;
 
        case KINFO_LOADAVG:
                name[0] = VM_LOADAVG;

-               error = vm_sysctl(name, 1, uap->where, &size, NULL, 0, p);
+               error =
+                   vm_sysctl(name, 1, SCARG(uap, where), &size, NULL, 0, p);

                break;
 
        case KINFO_CLOCKRATE:
                name[0] = KERN_CLOCKRATE;
                break;
 
        case KINFO_CLOCKRATE:
                name[0] = KERN_CLOCKRATE;

-               error = kern_sysctl(name, 1, uap->where, &size, NULL, 0, p);
+               error =
+                   kern_sysctl(name, 1, SCARG(uap, where), &size, NULL, 0, p);

                break;
 
        default:
                break;
 
        default:


@@ -650,8 +759,8 @@ getkerninfo(p, uap, retval)
        if (error)
                return (error);
        *retval = size;
        if (error)
                return (error);
        *retval = size;

-       if (uap->size)
-               error = copyout((caddr_t)&size, (caddr_t)uap->size,
+       if (SCARG(uap, size))
+               error = copyout((caddr_t)&size, (caddr_t)SCARG(uap, size),

                    sizeof(size));
        return (error);
 }
                    sizeof(size));
        return (error);
 }