new calling convension for system calls

[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 551ea2c..b8d0763 100644 (file)
--- a/usr/src/sys/kern/kern_sysctl.c
+++ b/usr/src/sys/kern/kern_sysctl.c
@@ -14,7 +14,7 @@
  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  *
  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  *

- *     @(#)kern_sysctl.c       7.5 (Berkeley) %G%
+ *     @(#)kern_sysctl.c       7.8 (Berkeley) %G%

  */
 
 #include "param.h"
  */
 
 #include "param.h"


@@ -29,7 +29,7 @@
 
 
 #define snderr(e) { error = (e); goto release;}
 
 
 #define snderr(e) { error = (e); goto release;}

-extern int kinfo_doproc(), kinfo_rtable();
+extern int kinfo_doproc(), kinfo_rtable(), kinfo_vnode();

 struct kinfo_lock kinfo_lock;
 
 getkerninfo()
 struct kinfo_lock kinfo_lock;
 
 getkerninfo()


@@ -42,12 +42,11 @@ getkerninfo()
        } *uap = (struct a *)u.u_ap;
 
        int     bufsize,        /* max size of users buffer */
        } *uap = (struct a *)u.u_ap;
 
        int     bufsize,        /* max size of users buffer */

-               copysize,       /* size copied */

                needed, locked, (*server)(), error = 0;
 
        if (error = copyin((caddr_t)uap->size,
                                (caddr_t)&bufsize, sizeof (bufsize)))
                needed, locked, (*server)(), error = 0;
 
        if (error = copyin((caddr_t)uap->size,
                                (caddr_t)&bufsize, sizeof (bufsize)))

-               goto bad;
+               goto done;

 
        switch (ki_type(uap->op)) {
 
 
        switch (ki_type(uap->op)) {
 


@@ -59,9 +58,17 @@ getkerninfo()
                server = kinfo_rtable;
                break;
 
                server = kinfo_rtable;
                break;
 

+       case KINFO_VNODE:
+               server = kinfo_vnode;
+               break;
+

        default:
                error = EINVAL;
        default:
                error = EINVAL;

-               goto bad;
+               goto done;
+       }
+       if (uap->where == NULL || uap->size == NULL) {
+               error = (*server)(uap->op, NULL, NULL, uap->arg, &needed);
+               goto done;

        }
        while (kinfo_lock.kl_lock) {
                kinfo_lock.kl_want++;
        }
        while (kinfo_lock.kl_lock) {
                kinfo_lock.kl_want++;


@@ -71,31 +78,27 @@ getkerninfo()
        }
        kinfo_lock.kl_lock++;
 
        }
        kinfo_lock.kl_lock++;
 

-       if (error = (*server)(uap->op, NULL, NULL, uap->arg, &needed))
-               goto release;
-       if (uap->where == NULL || uap->size == NULL)
-               goto release;  /* only want estimate of bufsize */
-       locked = copysize = MIN(needed, bufsize);
-       if (!useracc(uap->where, copysize, B_WRITE))
+       if (!useracc(uap->where, bufsize, B_WRITE))

                snderr(EFAULT);
        /*
         * lock down target pages - NEED DEADLOCK AVOIDANCE
         */
                snderr(EFAULT);
        /*
         * lock down target pages - NEED DEADLOCK AVOIDANCE
         */

-       if (copysize > ((int)ptob(freemem) - (20 * 1024)))      /* XXX */
+       if (bufsize > ((int)ptob(freemem) - (20 * 1024)))       /* XXX */

                snderr(ENOMEM);
                snderr(ENOMEM);

-       vslock(uap->where, copysize);
-       error = (*server)(uap->op, uap->where, &copysize, uap->arg, &needed);
-       vsunlock(uap->where, locked, B_WRITE);
-       if (error)
-               goto release;
-       error = copyout((caddr_t)&copysize,
-                               (caddr_t)uap->size, sizeof (copysize));
-
+       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--;
        if (kinfo_lock.kl_want)
                wakeup(&kinfo_lock);
 release:
        kinfo_lock.kl_lock--;
        if (kinfo_lock.kl_want)
                wakeup(&kinfo_lock);

-bad:
+done:

        if (error)
                u.u_error = error;
        else
        if (error)
                u.u_error = error;
        else


@@ -107,9 +110,6 @@ bad:
  */
 #define KINFO_PROCSLOP (5 * sizeof (struct kinfo_proc))
 
  */
 #define KINFO_PROCSLOP (5 * sizeof (struct kinfo_proc))
 

-int kinfo_proc_userfailed;
-int kinfo_proc_wefailed;
-

 kinfo_doproc(op, where, acopysize, arg, aneeded)
        char *where;
        int *acopysize, *aneeded;
 kinfo_doproc(op, where, acopysize, arg, aneeded)
        char *where;
        int *acopysize, *aneeded;


@@ -172,12 +172,15 @@ again:
                            sizeof (struct proc)))
                                return (error);
                        dp += sizeof (struct proc);
                            sizeof (struct proc)))
                                return (error);
                        dp += sizeof (struct proc);

+                       /*
+                        *      XXX NEED ALLIGNMENT
+                        */

                        eproc.e_paddr = p;
                        eproc.e_sess = p->p_pgrp->pg_session;
                        eproc.e_pgid = p->p_pgrp->pg_id;
                        eproc.e_jobc = p->p_pgrp->pg_jobc;
                        eproc.e_paddr = p;
                        eproc.e_sess = p->p_pgrp->pg_session;
                        eproc.e_pgid = p->p_pgrp->pg_id;
                        eproc.e_jobc = p->p_pgrp->pg_jobc;

-                       tp = p->p_pgrp->pg_session->s_ttyp;
-                       if ((p->p_flag&SCTTY) && tp != NULL) {
+                       if (tp = p->p_pgrp->pg_session->s_ttyp) {
+                               /* up to caller to check for SCTTY */

                                eproc.e_tdev = tp->t_dev;
                                eproc.e_tpgid = tp->t_pgrp ? 
                                        tp->t_pgrp->pg_id : -1;
                                eproc.e_tdev = tp->t_dev;
                                eproc.e_tpgid = tp->t_pgrp ? 
                                        tp->t_pgrp->pg_id : -1;