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 6734531..3b91635 100644 (file)
--- a/usr/src/sys/kern/kern_sysctl.c
+++ b/usr/src/sys/kern/kern_sysctl.c
@@ -7,7 +7,7 @@
  *
  * %sccs.include.redist.c%
  *
  *
  * %sccs.include.redist.c%
  *

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

  */
 
 /*
  */
 
 /*


@@ -28,13 +28,16 @@
 #include <vm/vm.h>
 #include <sys/sysctl.h>
 
 #include <vm/vm.h>
 #include <sys/sysctl.h>
 

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

 sysctlfn kern_sysctl;
 sysctlfn hw_sysctl;
 #ifdef DEBUG
 sysctlfn debug_sysctl;
 #endif
 extern sysctlfn vm_sysctl;
 sysctlfn kern_sysctl;
 sysctlfn hw_sysctl;
 #ifdef DEBUG
 sysctlfn debug_sysctl;
 #endif
 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;
 


@@ -47,40 +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;
-};
-

 int
 __sysctl(p, uap, retval)
        struct proc *p;
 int
 __sysctl(p, uap, retval)
        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:


@@ -92,11 +95,9 @@ __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;
+       case CTL_VFS:
+               fn = vfs_sysctl;

                break;
                break;

-#endif

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


@@ -109,11 +110,11 @@ __sysctl(p, uap, retval)
                return (EOPNOTSUPP);
        }
 
                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;


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


@@ -138,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);
 }


@@ -312,7 +313,7 @@ debug_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
        if (namelen != 2)
                return (ENOTDIR);               /* overloaded */
        cdp = debugvars[name[0]];
        if (namelen != 2)
                return (ENOTDIR);               /* overloaded */
        cdp = debugvars[name[0]];

-       if (cdp->debugname == 0)
+       if (name[0] >= CTL_DEBUG_MAXID || cdp->debugname == 0)

                return (EOPNOTSUPP);
        switch (name[1]) {
        case CTL_DEBUG_NAME:
                return (EOPNOTSUPP);
        switch (name[1]) {
        case CTL_DEBUG_NAME:


@@ -508,7 +509,7 @@ sysctl_file(where, sizep)
        /*
         * followed by an array of file structures
         */
        /*
         * 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);


@@ -543,10 +544,10 @@ sysctl_doproc(name, namelen, where, sizep)
 
        if (namelen != 2 && !(namelen == 1 && name[0] == KERN_PROC_ALL))
                return (EINVAL);
 
        if (namelen != 2 && !(namelen == 1 && name[0] == KERN_PROC_ALL))
                return (EINVAL);

-       p = (struct proc *)allproc;
+       p = allproc.lh_first;

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

-       for (; p != NULL; p = p->p_next) {
+       for (; p != 0; p = p->p_list.le_next) {

                /*
                 * Skip embryonic processes.
                 */
                /*
                 * Skip embryonic processes.
                 */


@@ -601,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;
        }


@@ -685,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;
-};
-
-ogetkerninfo(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:


@@ -753,8 +759,8 @@ ogetkerninfo(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);
 }