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 86832f3..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.37 (Berkeley) %G%
+ *     @(#)kern_sysctl.c       8.8 (Berkeley) %G%

  */
 
 /*
  */
 
 /*


@@ -16,6 +16,7 @@
 
 #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>


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


@@ -46,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:


@@ -90,14 +95,12 @@ 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;
        case CTL_MACHDEP:
                fn = cpu_sysctl;
                break;
                break;
        case CTL_MACHDEP:
                fn = cpu_sysctl;
                break;

-#endif

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


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


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


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


@@ -162,7 +165,7 @@ 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 */


@@ -178,24 +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_MAXPROC:
                return (sysctl_int(oldp, oldlenp, newp, newlen, &maxproc));
        case KERN_MAXFILES:
                return (sysctl_int(oldp, oldlenp, newp, newlen, &maxfiles));

-       case KERN_MAXVNODES:
-               return(sysctl_int(oldp, oldlenp, newp, newlen, &desiredvnodes));

        case KERN_ARGMAX:
                return (sysctl_rdint(oldp, oldlenp, newp, ARG_MAX));
        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)) ||


@@ -205,18 +198,44 @@ 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));
 #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);
 #endif
        default:
                return (EOPNOTSUPP);


@@ -294,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:


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


@@ -523,12 +542,12 @@ 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.
                 */
                /*
                 * Skip embryonic processes.
                 */


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


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


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


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


@@ -663,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:


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