projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
new calling convension for system calls
[unix-history] / usr / src / sys / kern / vfs_syscalls.c
diff --git a/usr/src/sys/kern/vfs_syscalls.c b/usr/src/sys/kern/vfs_syscalls.c
index c3e3003..7c018f0 100644 (file)
--- a/usr/src/sys/kern/vfs_syscalls.c
+++ b/usr/src/sys/kern/vfs_syscalls.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.
  *
- *     @(#)vfs_syscalls.c      7.18 (Berkeley) %G%
+ *     @(#)vfs_syscalls.c      7.48 (Berkeley) %G%
  */
 
 #include "param.h"
  */
 
 #include "param.h"
@@ -24,12 +24,14 @@
 #include "file.h"
 #include "stat.h"
 #include "vnode.h"
 #include "file.h"
 #include "stat.h"
 #include "vnode.h"
-#include "../ufs/inode.h"
 #include "mount.h"
 #include "proc.h"
 #include "uio.h"
 #include "malloc.h"
 
 #include "mount.h"
 #include "proc.h"
 #include "uio.h"
 #include "malloc.h"
 
+#undef RETURN
+#define RETURN(val)    { u.u_error = (val); if (u.u_spare[0] != 0) panic("lock count"); return (u.u_error); }
+
 /*
  * Virtual File System System Calls
  */
 /*
  * Virtual File System System Calls
  */
@@ -37,24 +39,26 @@
 /*
  * mount system call
  */
 /*
  * mount system call
  */
-mount(scp)
-       register struct syscontext *scp;
-{
-       register struct a {
+/* ARGSUSED */
+mount(p, uap, retval)
+       register struct proc *p;
+       register struct args {
                int     type;
                char    *dir;
                int     flags;
                caddr_t data;
                int     type;
                char    *dir;
                int     flags;
                caddr_t data;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp = &u.u_nd;
        register struct vnode *vp;
        register struct mount *mp;
        register struct vnode *vp;
        register struct mount *mp;
-       int error;
+       int error, flag;
 
        /*
         * Must be super user
         */
 
        /*
         * Must be super user
         */
-       if (error = suser(scp->sc_cred, &scp->sc_acflag))
+       if (error = suser(ndp->ni_cred, &u.u_acflag))
                RETURN (error);
        /*
         * Get vnode to be covered
                RETURN (error);
        /*
         * Get vnode to be covered
@@ -65,7 +69,7 @@ mount(scp)
        if (error = namei(ndp))
                RETURN (error);
        vp = ndp->ni_vp;
        if (error = namei(ndp))
                RETURN (error);
        vp = ndp->ni_vp;
-       if (uap->flags & M_UPDATE) {
+       if (uap->flags & MNT_UPDATE) {
                if ((vp->v_flag & VROOT) == 0) {
                        vput(vp);
                        RETURN (EINVAL);
                if ((vp->v_flag & VROOT) == 0) {
                        vput(vp);
                        RETURN (EINVAL);
@@ -75,16 +79,18 @@ mount(scp)
                 * We allow going from read-only to read-write,
                 * but not from read-write to read-only.
                 */
                 * We allow going from read-only to read-write,
                 * but not from read-write to read-only.
                 */
-               if ((mp->m_flag & M_RDONLY) == 0 &&
-                   (uap->flags & M_RDONLY) != 0) {
+               if ((mp->mnt_flag & MNT_RDONLY) == 0 &&
+                   (uap->flags & MNT_RDONLY) != 0) {
                        vput(vp);
                        RETURN (EOPNOTSUPP);    /* Needs translation */
                }
                        vput(vp);
                        RETURN (EOPNOTSUPP);    /* Needs translation */
                }
-               mp->m_flag |= M_UPDATE;
+               flag = mp->mnt_flag;
+               mp->mnt_flag |= MNT_UPDATE;
                VOP_UNLOCK(vp);
                goto update;
        }
                VOP_UNLOCK(vp);
                goto update;
        }
-       if (vp->v_count != 1) {
+       vinvalbuf(vp, 1);
+       if (vp->v_usecount != 1) {
                vput(vp);
                RETURN (EBUSY);
        }
                vput(vp);
                RETURN (EBUSY);
        }
@@ -92,7 +98,7 @@ mount(scp)
                vput(vp);
                RETURN (ENOTDIR);
        }
                vput(vp);
                RETURN (ENOTDIR);
        }
-       if (uap->type > MOUNT_MAXTYPE ||
+       if ((unsigned long)uap->type > MOUNT_MAXTYPE ||
            vfssw[uap->type] == (struct vfsops *)0) {
                vput(vp);
                RETURN (ENODEV);
            vfssw[uap->type] == (struct vfsops *)0) {
                vput(vp);
                RETURN (ENODEV);
@@ -103,9 +109,10 @@ mount(scp)
         */
        mp = (struct mount *)malloc((u_long)sizeof(struct mount),
                M_MOUNT, M_WAITOK);
         */
        mp = (struct mount *)malloc((u_long)sizeof(struct mount),
                M_MOUNT, M_WAITOK);
-       mp->m_op = vfssw[uap->type];
-       mp->m_flag = 0;
-       mp->m_exroot = 0;
+       mp->mnt_op = vfssw[uap->type];
+       mp->mnt_flag = 0;
+       mp->mnt_exroot = 0;
+       mp->mnt_mounth = NULLVP;
        if (error = vfs_lock(mp)) {
                free((caddr_t)mp, M_MOUNT);
                vput(vp);
        if (error = vfs_lock(mp)) {
                free((caddr_t)mp, M_MOUNT);
                vput(vp);
@@ -117,48 +124,50 @@ mount(scp)
                vput(vp);
                RETURN (EBUSY);
        }
                vput(vp);
                RETURN (EBUSY);
        }
-       /*
-        * Put the new filesystem on the mount list after root.
-        */
-       mp->m_next = rootfs->m_next;
-       mp->m_prev = rootfs;
-       rootfs->m_next = mp;
-       mp->m_next->m_prev = mp;
        vp->v_mountedhere = mp;
        vp->v_mountedhere = mp;
-       mp->m_vnodecovered = vp;
+       mp->mnt_vnodecovered = vp;
 update:
        /*
         * Set the mount level flags.
         */
 update:
        /*
         * Set the mount level flags.
         */
-       if (uap->flags & M_RDONLY)
-               mp->m_flag |= M_RDONLY;
+       if (uap->flags & MNT_RDONLY)
+               mp->mnt_flag |= MNT_RDONLY;
        else
        else
-               mp->m_flag &= ~M_RDONLY;
-       if (uap->flags & M_NOSUID)
-               mp->m_flag |= M_NOSUID;
+               mp->mnt_flag &= ~MNT_RDONLY;
+       if (uap->flags & MNT_NOSUID)
+               mp->mnt_flag |= MNT_NOSUID;
        else
        else
-               mp->m_flag &= ~M_NOSUID;
-       if (uap->flags & M_NOEXEC)
-               mp->m_flag |= M_NOEXEC;
+               mp->mnt_flag &= ~MNT_NOSUID;
+       if (uap->flags & MNT_NOEXEC)
+               mp->mnt_flag |= MNT_NOEXEC;
        else
        else
-               mp->m_flag &= ~M_NOEXEC;
-       if (uap->flags & M_NODEV)
-               mp->m_flag |= M_NODEV;
+               mp->mnt_flag &= ~MNT_NOEXEC;
+       if (uap->flags & MNT_NODEV)
+               mp->mnt_flag |= MNT_NODEV;
        else
        else
-               mp->m_flag &= ~M_NODEV;
-       if (uap->flags & M_SYNCHRONOUS)
-               mp->m_flag |= M_SYNCHRONOUS;
+               mp->mnt_flag &= ~MNT_NODEV;
+       if (uap->flags & MNT_SYNCHRONOUS)
+               mp->mnt_flag |= MNT_SYNCHRONOUS;
        else
        else
-               mp->m_flag &= ~M_SYNCHRONOUS;
+               mp->mnt_flag &= ~MNT_SYNCHRONOUS;
        /*
         * Mount the filesystem.
         */
        error = VFS_MOUNT(mp, uap->dir, uap->data, ndp);
        /*
         * Mount the filesystem.
         */
        error = VFS_MOUNT(mp, uap->dir, uap->data, ndp);
-       if (mp->m_flag & M_UPDATE) {
-               mp->m_flag &= ~M_UPDATE;
+       if (mp->mnt_flag & MNT_UPDATE) {
+               mp->mnt_flag &= ~MNT_UPDATE;
                vrele(vp);
                vrele(vp);
+               if (error)
+                       mp->mnt_flag = flag;
                RETURN (error);
        }
                RETURN (error);
        }
+       /*
+        * Put the new filesystem on the mount list after root.
+        */
+       mp->mnt_next = rootfs->mnt_next;
+       mp->mnt_prev = rootfs;
+       rootfs->mnt_next = mp;
+       mp->mnt_next->mnt_prev = mp;
        cache_purge(vp);
        if (!error) {
                VOP_UNLOCK(vp);
        cache_purge(vp);
        if (!error) {
                VOP_UNLOCK(vp);
@@ -178,23 +187,24 @@ update:
  * Note: unmount takes a path to the vnode mounted on as argument,
  * not special file (as before).
  */
  * Note: unmount takes a path to the vnode mounted on as argument,
  * not special file (as before).
  */
-unmount(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+/* ARGSUSED */
+unmount(p, uap, retval)
+       register struct proc *p;
+       register struct args {
                char    *pathp;
                int     flags;
                char    *pathp;
                int     flags;
-       } *uap = (struct a *)scp->sc_ap;
+       } *uap;
+       int *retval;
+{
        register struct vnode *vp;
        register struct vnode *vp;
-       register struct mount *mp;
-       register struct nameidata *ndp = &scp->sc_nd;
-       struct vnode *coveredvp;
+       register struct nameidata *ndp = &u.u_nd;
+       struct mount *mp;
        int error;
 
        /*
         * Must be super user
         */
        int error;
 
        /*
         * Must be super user
         */
-       if (error = suser(scp->sc_cred, &scp->sc_acflag))
+       if (error = suser(ndp->ni_cred, &u.u_acflag))
                RETURN (error);
 
        ndp->ni_nameiop = LOOKUP | LOCKLEAF | FOLLOW;
                RETURN (error);
 
        ndp->ni_nameiop = LOOKUP | LOCKLEAF | FOLLOW;
@@ -212,18 +222,32 @@ unmount(scp)
        }
        mp = vp->v_mount;
        vput(vp);
        }
        mp = vp->v_mount;
        vput(vp);
-       /*
-        * Do the unmount.
-        */
-       coveredvp = mp->m_vnodecovered;
+       RETURN (dounmount(mp, uap->flags));
+}
+
+/*
+ * Do an unmount.
+ */
+dounmount(mp, flags)
+       register struct mount *mp;
+       int flags;
+{
+       struct vnode *coveredvp;
+       int error;
+
+       coveredvp = mp->mnt_vnodecovered;
+       if (vfs_busy(mp))
+               return (EBUSY);
+       mp->mnt_flag |= MNT_UNMOUNT;
        if (error = vfs_lock(mp))
        if (error = vfs_lock(mp))
-               RETURN (error);
+               return (error);
 
        xumount(mp);            /* remove unused sticky files from text table */
        cache_purgevfs(mp);     /* remove cache entries for this file sys */
 
        xumount(mp);            /* remove unused sticky files from text table */
        cache_purgevfs(mp);     /* remove cache entries for this file sys */
-       VFS_SYNC(mp, MNT_WAIT);
-
-       error = VFS_UNMOUNT(mp, uap->flags);
+       if ((error = VFS_SYNC(mp, MNT_WAIT)) == 0 || (flags & MNT_FORCE))
+               error = VFS_UNMOUNT(mp, flags);
+       mp->mnt_flag &= ~MNT_UNMOUNT;
+       vfs_unbusy(mp);
        if (error) {
                vfs_unlock(mp);
        } else {
        if (error) {
                vfs_unlock(mp);
        } else {
@@ -231,145 +255,220 @@ unmount(scp)
                vfs_remove(mp);
                free((caddr_t)mp, M_MOUNT);
        }
                vfs_remove(mp);
                free((caddr_t)mp, M_MOUNT);
        }
-       RETURN (error);
+       return (error);
 }
 
 /*
  * Sync system call.
  * Sync each mounted filesystem.
  */
 }
 
 /*
  * Sync system call.
  * Sync each mounted filesystem.
  */
-sync(scp)
-       register struct syscontext *scp;
+/* ARGSUSED */
+sync(p, uap, retval)
+       register struct proc *p;
+       struct args *uap;
+       int *retval;
 {
        register struct mount *mp;
 {
        register struct mount *mp;
+       struct mount *omp;
 
        mp = rootfs;
        do {
 
        mp = rootfs;
        do {
-               if ((mp->m_flag & M_RDONLY) == 0)
+               /*
+                * The lock check below is to avoid races with mount
+                * and unmount.
+                */
+               if ((mp->mnt_flag & (MNT_MLOCK|MNT_RDONLY|MNT_MPBUSY)) == 0 &&
+                   !vfs_busy(mp)) {
                        VFS_SYNC(mp, MNT_NOWAIT);
                        VFS_SYNC(mp, MNT_NOWAIT);
-               mp = mp->m_next;
+                       omp = mp;
+                       mp = mp->mnt_next;
+                       vfs_unbusy(omp);
+               } else
+                       mp = mp->mnt_next;
        } while (mp != rootfs);
 }
 
 /*
        } while (mp != rootfs);
 }
 
 /*
- * get filesystem statistics
+ * operate on filesystem quotas
  */
  */
-statfs(scp)
-       register struct syscontext *scp;
+/* ARGSUSED */
+quotactl(p, uap, retval)
+       register struct proc *p;
+       register struct args {
+               char *path;
+               int cmd;
+               int uid;
+               caddr_t arg;
+       } *uap;
+       int *retval;
 {
 {
-       struct a {
+       register struct mount *mp;
+       register struct nameidata *ndp = &u.u_nd;
+       int error;
+
+       ndp->ni_nameiop = LOOKUP | FOLLOW;
+       ndp->ni_segflg = UIO_USERSPACE;
+       ndp->ni_dirp = uap->path;
+       if (error = namei(ndp))
+               RETURN (error);
+       mp = ndp->ni_vp->v_mount;
+       vrele(ndp->ni_vp);
+       RETURN (VFS_QUOTACTL(mp, uap->cmd, uap->uid, uap->arg));
+}
+
+/*
+ * get filesystem statistics
+ */
+/* ARGSUSED */
+statfs(p, uap, retval)
+       register struct proc *p;
+       register struct args {
                char *path;
                struct statfs *buf;
                char *path;
                struct statfs *buf;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct vnode *vp;
-       register struct nameidata *ndp = &scp->sc_nd;
-       struct statfs sb;
+       } *uap;
+       int *retval;
+{
+       register struct mount *mp;
+       register struct nameidata *ndp = &u.u_nd;
+       register struct statfs *sp;
        int error;
 
        int error;
 
-       ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
+       ndp->ni_nameiop = LOOKUP | FOLLOW;
        ndp->ni_segflg = UIO_USERSPACE;
        ndp->ni_dirp = uap->path;
        if (error = namei(ndp))
                RETURN (error);
        ndp->ni_segflg = UIO_USERSPACE;
        ndp->ni_dirp = uap->path;
        if (error = namei(ndp))
                RETURN (error);
-       vp = ndp->ni_vp;
-       if (error = VFS_STATFS(vp->v_mount, &sb))
-               goto out;
-       error = copyout((caddr_t)&sb, (caddr_t)uap->buf, sizeof(sb));
-out:
-       vput(vp);
-       RETURN (error);
+       mp = ndp->ni_vp->v_mount;
+       sp = &mp->mnt_stat;
+       vrele(ndp->ni_vp);
+       if (error = VFS_STATFS(mp, sp))
+               RETURN (error);
+       sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
+       RETURN (copyout((caddr_t)sp, (caddr_t)uap->buf, sizeof(*sp)));
 }
 
 }
 
-fstatfs(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+/*
+ * get filesystem statistics
+ */
+/* ARGSUSED */
+fstatfs(p, uap, retval)
+       register struct proc *p;
+       register struct args {
                int fd;
                struct statfs *buf;
                int fd;
                struct statfs *buf;
-       } *uap = (struct a *)scp->sc_ap;
+       } *uap;
+       int *retval;
+{
        struct file *fp;
        struct file *fp;
-       struct statfs sb;
+       struct mount *mp;
+       register struct statfs *sp;
        int error;
 
        int error;
 
-       if (error = getvnode(scp->sc_ofile, uap->fd, &fp))
+       if (error = getvnode(u.u_ofile, uap->fd, &fp))
                RETURN (error);
                RETURN (error);
-       if (error = VFS_STATFS(((struct vnode *)fp->f_data)->v_mount, &sb))
+       mp = ((struct vnode *)fp->f_data)->v_mount;
+       sp = &mp->mnt_stat;
+       if (error = VFS_STATFS(mp, sp))
                RETURN (error);
                RETURN (error);
-       RETURN (copyout((caddr_t)&sb, (caddr_t)uap->buf, sizeof(sb)));
+       sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
+       RETURN (copyout((caddr_t)sp, (caddr_t)uap->buf, sizeof(*sp)));
 }
 
 /*
  * get statistics on all filesystems
  */
 }
 
 /*
  * get statistics on all filesystems
  */
-getfsstat(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+getfsstat(p, uap, retval)
+       register struct proc *p;
+       register struct args {
                struct statfs *buf;
                long bufsize;
                struct statfs *buf;
                long bufsize;
-       } *uap = (struct a *)scp->sc_ap;
+               int flags;
+       } *uap;
+       int *retval;
+{
        register struct mount *mp;
        register struct mount *mp;
-       register struct statfs *sfsp;
+       register struct statfs *sp;
+       caddr_t sfsp;
        long count, maxcount, error;
 
        maxcount = uap->bufsize / sizeof(struct statfs);
        long count, maxcount, error;
 
        maxcount = uap->bufsize / sizeof(struct statfs);
-       sfsp = uap->buf;
+       sfsp = (caddr_t)uap->buf;
        mp = rootfs;
        count = 0;
        do {
        mp = rootfs;
        count = 0;
        do {
-               count++;
-               if (sfsp && count <= maxcount &&
-                   ((mp->m_flag & M_MLOCK) == 0)) {
-                       if (error = VFS_STATFS(mp, sfsp))
+               if (sfsp && count < maxcount &&
+                   ((mp->mnt_flag & MNT_MLOCK) == 0)) {
+                       sp = &mp->mnt_stat;
+                       /*
+                        * If MNT_NOWAIT is specified, do not refresh the
+                        * fsstat cache. MNT_WAIT overrides MNT_NOWAIT.
+                        */
+                       if (((uap->flags & MNT_NOWAIT) == 0 ||
+                           (uap->flags & MNT_WAIT)) &&
+                           (error = VFS_STATFS(mp, sp))) {
+                               mp = mp->mnt_prev;
+                               continue;
+                       }
+                       sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
+                       if (error = copyout((caddr_t)sp, sfsp, sizeof(*sp)))
                                RETURN (error);
                                RETURN (error);
-                       sfsp++;
+                       sfsp += sizeof(*sp);
                }
                }
-               mp = mp->m_prev;
+               count++;
+               mp = mp->mnt_prev;
        } while (mp != rootfs);
        if (sfsp && count > maxcount)
        } while (mp != rootfs);
        if (sfsp && count > maxcount)
-               scp->sc_retval1 = maxcount;
+               *retval = maxcount;
        else
        else
-               scp->sc_retval1 = count;
+               *retval = count;
        RETURN (0);
 }
 
 /*
  * Change current working directory to a given file descriptor.
  */
        RETURN (0);
 }
 
 /*
  * Change current working directory to a given file descriptor.
  */
-fchdir(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+/* ARGSUSED */
+fchdir(p, uap, retval)
+       register struct proc *p;
+       struct args {
                int     fd;
                int     fd;
-       } *uap = (struct a *)scp->sc_ap;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp = &u.u_nd;
        register struct vnode *vp;
        struct file *fp;
        int error;
 
        register struct vnode *vp;
        struct file *fp;
        int error;
 
-       if (error = getvnode(scp->sc_ofile, uap->fd, &fp))
+       if (error = getvnode(u.u_ofile, uap->fd, &fp))
                RETURN (error);
        vp = (struct vnode *)fp->f_data;
        VOP_LOCK(vp);
        if (vp->v_type != VDIR)
                error = ENOTDIR;
        else
                RETURN (error);
        vp = (struct vnode *)fp->f_data;
        VOP_LOCK(vp);
        if (vp->v_type != VDIR)
                error = ENOTDIR;
        else
-               error = VOP_ACCESS(vp, VEXEC, scp->sc_cred);
+               error = VOP_ACCESS(vp, VEXEC, ndp->ni_cred);
        VOP_UNLOCK(vp);
        VOP_UNLOCK(vp);
-       vrele(scp->sc_cdir);
-       scp->sc_cdir = vp;
-       RETURN (error);
+       if (error)
+               RETURN (error);
+       VREF(vp);
+       vrele(ndp->ni_cdir);
+       ndp->ni_cdir = vp;
+       RETURN (0);
 }
 
 /*
  * Change current working directory (``.'').
  */
 }
 
 /*
  * Change current working directory (``.'').
  */
-chdir(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+/* ARGSUSED */
+chdir(p, uap, retval)
+       register struct proc *p;
+       struct args {
                char    *fname;
                char    *fname;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp = &u.u_nd;
        int error;
 
        ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
        int error;
 
        ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
@@ -377,32 +476,35 @@ chdir(scp)
        ndp->ni_dirp = uap->fname;
        if (error = chdirec(ndp))
                RETURN (error);
        ndp->ni_dirp = uap->fname;
        if (error = chdirec(ndp))
                RETURN (error);
-       vrele(scp->sc_cdir);
-       scp->sc_cdir = ndp->ni_vp;
+       vrele(ndp->ni_cdir);
+       ndp->ni_cdir = ndp->ni_vp;
        RETURN (0);
 }
 
 /*
  * Change notion of root (``/'') directory.
  */
        RETURN (0);
 }
 
 /*
  * Change notion of root (``/'') directory.
  */
-chroot(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+/* ARGSUSED */
+chroot(p, uap, retval)
+       register struct proc *p;
+       struct args {
                char    *fname;
                char    *fname;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp = &u.u_nd;
        int error;
 
        int error;
 
-       if (error = suser(scp->sc_cred, &scp->sc_acflag))
+       if (error = suser(ndp->ni_cred, &u.u_acflag))
                RETURN (error);
        ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
        ndp->ni_segflg = UIO_USERSPACE;
        ndp->ni_dirp = uap->fname;
        if (error = chdirec(ndp))
                RETURN (error);
                RETURN (error);
        ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
        ndp->ni_segflg = UIO_USERSPACE;
        ndp->ni_dirp = uap->fname;
        if (error = chdirec(ndp))
                RETURN (error);
-       vrele(scp->sc_rdir);
-       scp->sc_rdir = ndp->ni_vp;
+       if (ndp->ni_rdir != NULL)
+               vrele(ndp->ni_rdir);
+       ndp->ni_rdir = ndp->ni_vp;
        RETURN (0);
 }
 
        RETURN (0);
 }
 
@@ -430,93 +532,95 @@ chdirec(ndp)
 
 /*
  * Open system call.
 
 /*
  * Open system call.
+ * Check permissions, allocate an open file structure,
+ * and call the device open routine if any.
  */
  */
-open(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+open(p, uap, retval)
+       register struct proc *p;
+       register struct args {
                char    *fname;
                int     mode;
                int     crtmode;
                char    *fname;
                int     mode;
                int     crtmode;
-       } *uap = (struct a *) scp->sc_ap;
-       struct nameidata *ndp = &scp->sc_nd;
-
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       RETURN (copen(scp, uap->mode-FOPEN, uap->crtmode &~ scp->sc_cmask, ndp,
-               &scp->sc_retval1));
-}
-
-/*
- * Creat system call.
- */
-creat(scp)
-       register struct syscontext *scp;
-{
-       struct a {
-               char    *fname;
-               int     fmode;
-       } *uap = (struct a *)scp->sc_ap;
-       struct nameidata *ndp = &scp->sc_nd;
-
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       RETURN (copen(scp, FWRITE|FCREAT|FTRUNC, uap->fmode &~ scp->sc_cmask,
-               ndp, &scp->sc_retval1));
-}
-
-/*
- * Common code for open and creat.
- * Check permissions, allocate an open file structure,
- * and call the device open routine if any.
- */
-copen(scp, fmode, cmode, ndp, resultfd)
-       register struct syscontext *scp;
-       int fmode, cmode;
-       struct nameidata *ndp;
-       int *resultfd;
+       } *uap;
+       int *retval;
 {
 {
+       struct nameidata *ndp = &u.u_nd;
        register struct file *fp;
        register struct file *fp;
+       int fmode, cmode;
        struct file *nfp;
        int indx, error;
        extern struct fileops vnops;
 
        if (error = falloc(&nfp, &indx))
        struct file *nfp;
        int indx, error;
        extern struct fileops vnops;
 
        if (error = falloc(&nfp, &indx))
-               return (error);
+               RETURN (error);
        fp = nfp;
        fp = nfp;
-       scp->sc_retval1 = indx; /* XXX for fdopen() */
-       if (error = vn_open(ndp, fmode, (cmode & 07777) &~ ISVTX)) {
-               scp->sc_ofile[indx] = NULL;
+       fmode = uap->mode - FOPEN;
+       cmode = ((uap->crtmode &~ u.u_cmask) & 07777) &~ S_ISVTX;
+       ndp->ni_segflg = UIO_USERSPACE;
+       ndp->ni_dirp = uap->fname;
+       u.u_r.u_rv.R_val1 = indx;               /* XXX for fdopen() */
+       if (error = vn_open(ndp, fmode, cmode)) {
                crfree(fp->f_cred);
                fp->f_count--;
                crfree(fp->f_cred);
                fp->f_count--;
-               return (error);
+               if (error == EJUSTRETURN) {     /* XXX from fdopen */
+                       *retval = indx;
+                       RETURN (0);
+               }
+               if (error == ERESTART)
+                       error = EINTR;
+               u.u_ofile[indx] = NULL;
+               RETURN (error);
        }
        fp->f_flag = fmode & FMASK;
        fp->f_type = DTYPE_VNODE;
        fp->f_ops = &vnops;
        fp->f_data = (caddr_t)ndp->ni_vp;
        }
        fp->f_flag = fmode & FMASK;
        fp->f_type = DTYPE_VNODE;
        fp->f_ops = &vnops;
        fp->f_data = (caddr_t)ndp->ni_vp;
-       if (resultfd)
-               *resultfd = indx;
-       return (0);
+       *retval = indx;
+       RETURN (0);
 }
 
 /*
 }
 
 /*
- * Mknod system call
+ * Creat system call.
  */
  */
-mknod(scp)
-       register struct syscontext *scp;
+creat(p, uap, retval)
+       struct proc *p;
+       register struct args {
+               char    *fname;
+               int     fmode;
+       } *uap;
+       int *retval;
 {
 {
-       register struct a {
+       struct args {
+               char    *fname;
+               int     mode;
+               int     crtmode;
+       } openuap;
+
+       openuap.fname = uap->fname;
+       openuap.crtmode = uap->fmode;
+       openuap.mode = O_WRONLY | O_CREAT | O_TRUNC;
+       RETURN (open(p, &openuap, retval));
+}
+
+/*
+ * Mknod system call
+ */
+/* ARGSUSED */
+mknod(p, uap, retval)
+       register struct proc *p;
+       register struct args {
                char    *fname;
                int     fmode;
                int     dev;
                char    *fname;
                int     fmode;
                int     dev;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp = &u.u_nd;
        register struct vnode *vp;
        struct vattr vattr;
        int error;
 
        register struct vnode *vp;
        struct vattr vattr;
        int error;
 
-       if (error = suser(scp->sc_cred, &scp->sc_acflag))
+       if (error = suser(ndp->ni_cred, &u.u_acflag))
                RETURN (error);
        ndp->ni_nameiop = CREATE | LOCKPARENT;
        ndp->ni_segflg = UIO_USERSPACE;
                RETURN (error);
        ndp->ni_nameiop = CREATE | LOCKPARENT;
        ndp->ni_segflg = UIO_USERSPACE;
@@ -528,23 +632,23 @@ mknod(scp)
                error = EEXIST;
                goto out;
        }
                error = EEXIST;
                goto out;
        }
-       vattr_null(&vattr);
-       switch (uap->fmode & IFMT) {
+       VATTR_NULL(&vattr);
+       switch (uap->fmode & S_IFMT) {
 
 
-       case IFMT:      /* used by badsect to flag bad sectors */
+       case S_IFMT:    /* used by badsect to flag bad sectors */
                vattr.va_type = VBAD;
                break;
                vattr.va_type = VBAD;
                break;
-       case IFCHR:
+       case S_IFCHR:
                vattr.va_type = VCHR;
                break;
                vattr.va_type = VCHR;
                break;
-       case IFBLK:
+       case S_IFBLK:
                vattr.va_type = VBLK;
                break;
        default:
                error = EINVAL;
                goto out;
        }
                vattr.va_type = VBLK;
                break;
        default:
                error = EINVAL;
                goto out;
        }
-       vattr.va_mode = (uap->fmode & 07777) &~ scp->sc_cmask;
+       vattr.va_mode = (uap->fmode & 07777) &~ u.u_cmask;
        vattr.va_rdev = uap->dev;
 out:
        if (error)
        vattr.va_rdev = uap->dev;
 out:
        if (error)
@@ -555,16 +659,54 @@ out:
 }
 
 /*
 }
 
 /*
- * link system call
+ * Mkfifo system call
  */
  */
-link(scp)
-       register struct syscontext *scp;
+/* ARGSUSED */
+mkfifo(p, uap, retval)
+       register struct proc *p;
+       register struct args {
+               char    *fname;
+               int     fmode;
+       } *uap;
+       int *retval;
 {
 {
-       register struct a {
+       register struct nameidata *ndp = &u.u_nd;
+       struct vattr vattr;
+       int error;
+
+#ifndef FIFO
+       RETURN (EOPNOTSUPP);
+#else
+       ndp->ni_nameiop = CREATE | LOCKPARENT;
+       ndp->ni_segflg = UIO_USERSPACE;
+       ndp->ni_dirp = uap->fname;
+       if (error = namei(ndp))
+               RETURN (error);
+       if (ndp->ni_vp != NULL) {
+               VOP_ABORTOP(ndp);
+               RETURN (EEXIST);
+       } else {
+               VATTR_NULL(&vattr);
+               vattr.va_type = VFIFO;
+               vattr.va_mode = (uap->fmode & 07777) &~ u.u_cmask;
+       }
+       RETURN (VOP_MKNOD(ndp, &vattr, ndp->ni_cred));
+#endif /* FIFO */
+}
+
+/*
+ * link system call
+ */
+/* ARGSUSED */
+link(p, uap, retval)
+       register struct proc *p;
+       register struct args {
                char    *target;
                char    *linkname;
                char    *target;
                char    *linkname;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp = &u.u_nd;
        register struct vnode *vp, *xp;
        int error;
 
        register struct vnode *vp, *xp;
        int error;
 
@@ -575,7 +717,7 @@ link(scp)
                RETURN (error);
        vp = ndp->ni_vp;
        if (vp->v_type == VDIR &&
                RETURN (error);
        vp = ndp->ni_vp;
        if (vp->v_type == VDIR &&
-           (error = suser(scp->sc_cred, &scp->sc_acflag)))
+           (error = suser(ndp->ni_cred, &u.u_acflag)))
                goto out1;
        ndp->ni_nameiop = CREATE | LOCKPARENT;
        ndp->ni_dirp = (caddr_t)uap->linkname;
                goto out1;
        ndp->ni_nameiop = CREATE | LOCKPARENT;
        ndp->ni_dirp = (caddr_t)uap->linkname;
@@ -602,14 +744,16 @@ out1:
 /*
  * symlink -- make a symbolic link
  */
 /*
  * symlink -- make a symbolic link
  */
-symlink(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+/* ARGSUSED */
+symlink(p, uap, retval)
+       register struct proc *p;
+       register struct args {
                char    *target;
                char    *linkname;
                char    *target;
                char    *linkname;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp = &u.u_nd;
        register struct vnode *vp;
        struct vattr vattr;
        char *target;
        register struct vnode *vp;
        struct vattr vattr;
        char *target;
@@ -629,8 +773,8 @@ symlink(scp)
                goto out;
        }
        vp = ndp->ni_dvp;
                goto out;
        }
        vp = ndp->ni_dvp;
-       vattr_null(&vattr);
-       vattr.va_mode = 0777 &~ scp->sc_cmask;
+       VATTR_NULL(&vattr);
+       vattr.va_mode = 0777 &~ u.u_cmask;
 out:
        if (error)
                VOP_ABORTOP(ndp);
 out:
        if (error)
                VOP_ABORTOP(ndp);
@@ -646,13 +790,15 @@ out1:
  * Hard to avoid races here, especially
  * in unlinking directories.
  */
  * Hard to avoid races here, especially
  * in unlinking directories.
  */
-unlink(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+/* ARGSUSED */
+unlink(p, uap, retval)
+       register struct proc *p;
+       struct args {
                char    *fname;
                char    *fname;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp = &u.u_nd;
        register struct vnode *vp;
        int error;
 
        register struct vnode *vp;
        int error;
 
@@ -663,7 +809,7 @@ unlink(scp)
                RETURN (error);
        vp = ndp->ni_vp;
        if (vp->v_type == VDIR &&
                RETURN (error);
        vp = ndp->ni_vp;
        if (vp->v_type == VDIR &&
-           (error = suser(scp->sc_cred, &scp->sc_acflag)))
+           (error = suser(ndp->ni_cred, &u.u_acflag)))
                goto out;
        /*
         * Don't unlink a mounted file.
                goto out;
        /*
         * Don't unlink a mounted file.
@@ -685,20 +831,22 @@ out:
 /*
  * Seek system call
  */
 /*
  * Seek system call
  */
-lseek(scp)
-       register struct syscontext *scp;
-{
-       register struct file *fp;
-       register struct a {
+lseek(p, uap, retval)
+       register struct proc *p;
+       register struct args {
                int     fdes;
                off_t   off;
                int     sbase;
                int     fdes;
                off_t   off;
                int     sbase;
-       } *uap = (struct a *)scp->sc_ap;
+       } *uap;
+       off_t *retval;
+{
+       struct ucred *cred = u.u_nd.ni_cred;
+       register struct file *fp;
        struct vattr vattr;
        int error;
 
        if ((unsigned)uap->fdes >= NOFILE ||
        struct vattr vattr;
        int error;
 
        if ((unsigned)uap->fdes >= NOFILE ||
-           (fp = scp->sc_ofile[uap->fdes]) == NULL)
+           (fp = u.u_ofile[uap->fdes]) == NULL)
                RETURN (EBADF);
        if (fp->f_type != DTYPE_VNODE)
                RETURN (ESPIPE);
                RETURN (EBADF);
        if (fp->f_type != DTYPE_VNODE)
                RETURN (ESPIPE);
@@ -710,7 +858,7 @@ lseek(scp)
 
        case L_XTND:
                if (error = VOP_GETATTR((struct vnode *)fp->f_data,
 
        case L_XTND:
                if (error = VOP_GETATTR((struct vnode *)fp->f_data,
-                   &vattr, scp->sc_cred))
+                   &vattr, cred))
                        RETURN (error);
                fp->f_offset = uap->off + vattr.va_size;
                break;
                        RETURN (error);
                fp->f_offset = uap->off + vattr.va_size;
                break;
@@ -722,28 +870,31 @@ lseek(scp)
        default:
                RETURN (EINVAL);
        }
        default:
                RETURN (EINVAL);
        }
-       scp->sc_offset = fp->f_offset;
+       *retval = fp->f_offset;
        RETURN (0);
 }
 
 /*
  * Access system call
  */
        RETURN (0);
 }
 
 /*
  * Access system call
  */
-saccess(scp)
-       register struct syscontext *scp;
-{
-       register struct a {
+/* ARGSUSED */
+saccess(p, uap, retval)
+       register struct proc *p;
+       register struct args {
                char    *fname;
                int     fmode;
                char    *fname;
                int     fmode;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp = &u.u_nd;
+       register struct ucred *cred = ndp->ni_cred;
        register struct vnode *vp;
        int error, mode, svuid, svgid;
 
        register struct vnode *vp;
        int error, mode, svuid, svgid;
 
-       svuid = scp->sc_uid;
-       svgid = scp->sc_gid;
-       scp->sc_uid = scp->sc_ruid;
-       scp->sc_gid = scp->sc_rgid;
+       svuid = cred->cr_uid;
+       svgid = cred->cr_groups[0];
+       cred->cr_uid = p->p_ruid;
+       cred->cr_groups[0] = p->p_rgid;
        ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
        ndp->ni_segflg = UIO_USERSPACE;
        ndp->ni_dirp = uap->fname;
        ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
        ndp->ni_segflg = UIO_USERSPACE;
        ndp->ni_dirp = uap->fname;
@@ -761,49 +912,62 @@ saccess(scp)
                        mode |= VWRITE;
                if (uap->fmode & X_OK)
                        mode |= VEXEC;
                        mode |= VWRITE;
                if (uap->fmode & X_OK)
                        mode |= VEXEC;
-               if ((error = vn_writechk(vp)) == 0)
+               if ((mode & VWRITE) == 0 || (error = vn_writechk(vp)) == 0)
                        error = VOP_ACCESS(vp, mode, ndp->ni_cred);
        }
        vput(vp);
 out1:
                        error = VOP_ACCESS(vp, mode, ndp->ni_cred);
        }
        vput(vp);
 out1:
-       scp->sc_uid = svuid;
-       scp->sc_gid = svgid;
+       cred->cr_uid = svuid;
+       cred->cr_groups[0] = svgid;
        RETURN (error);
 }
 
 /*
  * Stat system call.  This version follows links.
  */
        RETURN (error);
 }
 
 /*
  * Stat system call.  This version follows links.
  */
-stat(scp)
-       struct syscontext *scp;
+/* ARGSUSED */
+stat(p, uap, retval)
+       register struct proc *p;
+       register struct args {
+               char    *fname;
+               struct stat *ub;
+       } *uap;
+       int *retval;
 {
 {
+       register struct nameidata *ndp = &u.u_nd;
+       struct stat sb;
+       int error;
 
 
-       stat1(scp, FOLLOW);
+       ndp->ni_nameiop = LOOKUP | LOCKLEAF | FOLLOW;
+       ndp->ni_segflg = UIO_USERSPACE;
+       ndp->ni_dirp = uap->fname;
+       if (error = namei(ndp))
+               RETURN (error);
+       error = vn_stat(ndp->ni_vp, &sb);
+       vput(ndp->ni_vp);
+       if (error)
+               RETURN (error);
+       error = copyout((caddr_t)&sb, (caddr_t)uap->ub, sizeof (sb));
+       RETURN (error);
 }
 
 /*
  * Lstat system call.  This version does not follow links.
  */
 }
 
 /*
  * Lstat system call.  This version does not follow links.
  */
-lstat(scp)
-       struct syscontext *scp;
-{
-
-       stat1(scp, NOFOLLOW);
-}
-
-stat1(scp, follow)
-       register struct syscontext *scp;
-       int follow;
-{
-       register struct a {
+/* ARGSUSED */
+lstat(p, uap, retval)
+       register struct proc *p;
+       register struct args {
                char    *fname;
                struct stat *ub;
                char    *fname;
                struct stat *ub;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp = &u.u_nd;
        struct stat sb;
        int error;
 
        struct stat sb;
        int error;
 
-       ndp->ni_nameiop = LOOKUP | LOCKLEAF | follow;
+       ndp->ni_nameiop = LOOKUP | LOCKLEAF | NOFOLLOW;
        ndp->ni_segflg = UIO_USERSPACE;
        ndp->ni_dirp = uap->fname;
        if (error = namei(ndp))
        ndp->ni_segflg = UIO_USERSPACE;
        ndp->ni_dirp = uap->fname;
        if (error = namei(ndp))
@@ -819,15 +983,17 @@ stat1(scp, follow)
 /*
  * Return target name of a symbolic link
  */
 /*
  * Return target name of a symbolic link
  */
-readlink(scp)
-       register struct syscontext *scp;
-{
-       register struct a {
+/* ARGSUSED */
+readlink(p, uap, retval)
+       register struct proc *p;
+       register struct args {
                char    *name;
                char    *buf;
                int     count;
                char    *name;
                char    *buf;
                int     count;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp = &u.u_nd;
        register struct vnode *vp;
        struct iovec aiov;
        struct uio auio;
        register struct vnode *vp;
        struct iovec aiov;
        struct uio auio;
@@ -854,21 +1020,23 @@ readlink(scp)
        error = VOP_READLINK(vp, &auio, ndp->ni_cred);
 out:
        vput(vp);
        error = VOP_READLINK(vp, &auio, ndp->ni_cred);
 out:
        vput(vp);
-       scp->sc_retval1 = uap->count - auio.uio_resid;
+       *retval = uap->count - auio.uio_resid;
        RETURN (error);
 }
 
 /*
  * Change flags of a file given path name.
  */
        RETURN (error);
 }
 
 /*
  * Change flags of a file given path name.
  */
-chflags(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+/* ARGSUSED */
+chflags(p, uap, retval)
+       register struct proc *p;
+       register struct args {
                char    *fname;
                int     flags;
                char    *fname;
                int     flags;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp = &u.u_nd;
        register struct vnode *vp;
        struct vattr vattr;
        int error;
        register struct vnode *vp;
        struct vattr vattr;
        int error;
@@ -876,12 +1044,12 @@ chflags(scp)
        ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
        ndp->ni_segflg = UIO_USERSPACE;
        ndp->ni_dirp = uap->fname;
        ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
        ndp->ni_segflg = UIO_USERSPACE;
        ndp->ni_dirp = uap->fname;
-       vattr_null(&vattr);
+       VATTR_NULL(&vattr);
        vattr.va_flags = uap->flags;
        if (error = namei(ndp))
                RETURN (error);
        vp = ndp->ni_vp;
        vattr.va_flags = uap->flags;
        if (error = namei(ndp))
                RETURN (error);
        vp = ndp->ni_vp;
-       if (vp->v_mount->m_flag & M_RDONLY) {
+       if (vp->v_mount->mnt_flag & MNT_RDONLY) {
                error = EROFS;
                goto out;
        }
                error = EROFS;
                goto out;
        }
@@ -894,25 +1062,27 @@ out:
 /*
  * Change flags of a file given a file descriptor.
  */
 /*
  * Change flags of a file given a file descriptor.
  */
-fchflags(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+/* ARGSUSED */
+fchflags(p, uap, retval)
+       register struct proc *p;
+       register struct args {
                int     fd;
                int     flags;
                int     fd;
                int     flags;
-       } *uap = (struct a *)scp->sc_ap;
+       } *uap;
+       int *retval;
+{
        struct vattr vattr;
        struct vnode *vp;
        struct file *fp;
        int error;
 
        struct vattr vattr;
        struct vnode *vp;
        struct file *fp;
        int error;
 
-       if (error = getvnode(scp->sc_ofile, uap->fd, &fp))
+       if (error = getvnode(u.u_ofile, uap->fd, &fp))
                RETURN (error);
                RETURN (error);
-       vattr_null(&vattr);
+       VATTR_NULL(&vattr);
        vattr.va_flags = uap->flags;
        vp = (struct vnode *)fp->f_data;
        VOP_LOCK(vp);
        vattr.va_flags = uap->flags;
        vp = (struct vnode *)fp->f_data;
        VOP_LOCK(vp);
-       if (vp->v_mount->m_flag & M_RDONLY) {
+       if (vp->v_mount->mnt_flag & MNT_RDONLY) {
                error = EROFS;
                goto out;
        }
                error = EROFS;
                goto out;
        }
@@ -925,14 +1095,16 @@ out:
 /*
  * Change mode of a file given path name.
  */
 /*
  * Change mode of a file given path name.
  */
-chmod(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+/* ARGSUSED */
+chmod(p, uap, retval)
+       register struct proc *p;
+       register struct args {
                char    *fname;
                int     fmode;
                char    *fname;
                int     fmode;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp = &u.u_nd;
        register struct vnode *vp;
        struct vattr vattr;
        int error;
        register struct vnode *vp;
        struct vattr vattr;
        int error;
@@ -940,12 +1112,12 @@ chmod(scp)
        ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
        ndp->ni_segflg = UIO_USERSPACE;
        ndp->ni_dirp = uap->fname;
        ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
        ndp->ni_segflg = UIO_USERSPACE;
        ndp->ni_dirp = uap->fname;
-       vattr_null(&vattr);
+       VATTR_NULL(&vattr);
        vattr.va_mode = uap->fmode & 07777;
        if (error = namei(ndp))
                RETURN (error);
        vp = ndp->ni_vp;
        vattr.va_mode = uap->fmode & 07777;
        if (error = namei(ndp))
                RETURN (error);
        vp = ndp->ni_vp;
-       if (vp->v_mount->m_flag & M_RDONLY) {
+       if (vp->v_mount->mnt_flag & MNT_RDONLY) {
                error = EROFS;
                goto out;
        }
                error = EROFS;
                goto out;
        }
@@ -958,25 +1130,27 @@ out:
 /*
  * Change mode of a file given a file descriptor.
  */
 /*
  * Change mode of a file given a file descriptor.
  */
-fchmod(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+/* ARGSUSED */
+fchmod(p, uap, retval)
+       register struct proc *p;
+       register struct args {
                int     fd;
                int     fmode;
                int     fd;
                int     fmode;
-       } *uap = (struct a *)scp->sc_ap;
+       } *uap;
+       int *retval;
+{
        struct vattr vattr;
        struct vnode *vp;
        struct file *fp;
        int error;
 
        struct vattr vattr;
        struct vnode *vp;
        struct file *fp;
        int error;
 
-       if (error = getvnode(scp->sc_ofile, uap->fd, &fp))
+       if (error = getvnode(u.u_ofile, uap->fd, &fp))
                RETURN (error);
                RETURN (error);
-       vattr_null(&vattr);
+       VATTR_NULL(&vattr);
        vattr.va_mode = uap->fmode & 07777;
        vp = (struct vnode *)fp->f_data;
        VOP_LOCK(vp);
        vattr.va_mode = uap->fmode & 07777;
        vp = (struct vnode *)fp->f_data;
        VOP_LOCK(vp);
-       if (vp->v_mount->m_flag & M_RDONLY) {
+       if (vp->v_mount->mnt_flag & MNT_RDONLY) {
                error = EROFS;
                goto out;
        }
                error = EROFS;
                goto out;
        }
@@ -989,15 +1163,17 @@ out:
 /*
  * Set ownership given a path name.
  */
 /*
  * Set ownership given a path name.
  */
-chown(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+/* ARGSUSED */
+chown(p, uap, retval)
+       register struct proc *p;
+       register struct args {
                char    *fname;
                int     uid;
                int     gid;
                char    *fname;
                int     uid;
                int     gid;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp = &u.u_nd;
        register struct vnode *vp;
        struct vattr vattr;
        int error;
        register struct vnode *vp;
        struct vattr vattr;
        int error;
@@ -1005,13 +1181,13 @@ chown(scp)
        ndp->ni_nameiop = LOOKUP | NOFOLLOW | LOCKLEAF;
        ndp->ni_segflg = UIO_USERSPACE;
        ndp->ni_dirp = uap->fname;
        ndp->ni_nameiop = LOOKUP | NOFOLLOW | LOCKLEAF;
        ndp->ni_segflg = UIO_USERSPACE;
        ndp->ni_dirp = uap->fname;
-       vattr_null(&vattr);
+       VATTR_NULL(&vattr);
        vattr.va_uid = uap->uid;
        vattr.va_gid = uap->gid;
        if (error = namei(ndp))
                RETURN (error);
        vp = ndp->ni_vp;
        vattr.va_uid = uap->uid;
        vattr.va_gid = uap->gid;
        if (error = namei(ndp))
                RETURN (error);
        vp = ndp->ni_vp;
-       if (vp->v_mount->m_flag & M_RDONLY) {
+       if (vp->v_mount->mnt_flag & MNT_RDONLY) {
                error = EROFS;
                goto out;
        }
                error = EROFS;
                goto out;
        }
@@ -1024,27 +1200,29 @@ out:
 /*
  * Set ownership given a file descriptor.
  */
 /*
  * Set ownership given a file descriptor.
  */
-fchown(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+/* ARGSUSED */
+fchown(p, uap, retval)
+       register struct proc *p;
+       register struct args {
                int     fd;
                int     uid;
                int     gid;
                int     fd;
                int     uid;
                int     gid;
-       } *uap = (struct a *)scp->sc_ap;
+       } *uap;
+       int *retval;
+{
        struct vattr vattr;
        struct vnode *vp;
        struct file *fp;
        int error;
 
        struct vattr vattr;
        struct vnode *vp;
        struct file *fp;
        int error;
 
-       if (error = getvnode(scp->sc_ofile, uap->fd, &fp))
+       if (error = getvnode(u.u_ofile, uap->fd, &fp))
                RETURN (error);
                RETURN (error);
-       vattr_null(&vattr);
+       VATTR_NULL(&vattr);
        vattr.va_uid = uap->uid;
        vattr.va_gid = uap->gid;
        vp = (struct vnode *)fp->f_data;
        VOP_LOCK(vp);
        vattr.va_uid = uap->uid;
        vattr.va_gid = uap->gid;
        vp = (struct vnode *)fp->f_data;
        VOP_LOCK(vp);
-       if (vp->v_mount->m_flag & M_RDONLY) {
+       if (vp->v_mount->mnt_flag & MNT_RDONLY) {
                error = EROFS;
                goto out;
        }
                error = EROFS;
                goto out;
        }
@@ -1054,14 +1232,19 @@ out:
        RETURN (error);
 }
 
        RETURN (error);
 }
 
-utimes(scp)
-       register struct syscontext *scp;
-{
-       register struct a {
+/*
+ * Set the access and modification times of a file.
+ */
+/* ARGSUSED */
+utimes(p, uap, retval)
+       register struct proc *p;
+       register struct args {
                char    *fname;
                struct  timeval *tptr;
                char    *fname;
                struct  timeval *tptr;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp = &u.u_nd;
        register struct vnode *vp;
        struct timeval tv[2];
        struct vattr vattr;
        register struct vnode *vp;
        struct timeval tv[2];
        struct vattr vattr;
@@ -1072,13 +1255,13 @@ utimes(scp)
        ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
        ndp->ni_segflg = UIO_USERSPACE;
        ndp->ni_dirp = uap->fname;
        ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
        ndp->ni_segflg = UIO_USERSPACE;
        ndp->ni_dirp = uap->fname;
-       vattr_null(&vattr);
+       VATTR_NULL(&vattr);
        vattr.va_atime = tv[0];
        vattr.va_mtime = tv[1];
        if (error = namei(ndp))
                RETURN (error);
        vp = ndp->ni_vp;
        vattr.va_atime = tv[0];
        vattr.va_mtime = tv[1];
        if (error = namei(ndp))
                RETURN (error);
        vp = ndp->ni_vp;
-       if (vp->v_mount->m_flag & M_RDONLY) {
+       if (vp->v_mount->mnt_flag & MNT_RDONLY) {
                error = EROFS;
                goto out;
        }
                error = EROFS;
                goto out;
        }
@@ -1091,14 +1274,16 @@ out:
 /*
  * Truncate a file given its path name.
  */
 /*
  * Truncate a file given its path name.
  */
-truncate(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+/* ARGSUSED */
+truncate(p, uap, retval)
+       register struct proc *p;
+       register struct args {
                char    *fname;
                off_t   length;
                char    *fname;
                off_t   length;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp = &u.u_nd;
        register struct vnode *vp;
        struct vattr vattr;
        int error;
        register struct vnode *vp;
        struct vattr vattr;
        int error;
@@ -1106,7 +1291,7 @@ truncate(scp)
        ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
        ndp->ni_segflg = UIO_USERSPACE;
        ndp->ni_dirp = uap->fname;
        ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
        ndp->ni_segflg = UIO_USERSPACE;
        ndp->ni_dirp = uap->fname;
-       vattr_null(&vattr);
+       VATTR_NULL(&vattr);
        vattr.va_size = uap->length;
        if (error = namei(ndp))
                RETURN (error);
        vattr.va_size = uap->length;
        if (error = namei(ndp))
                RETURN (error);
@@ -1127,23 +1312,25 @@ out:
 /*
  * Truncate a file given a file descriptor.
  */
 /*
  * Truncate a file given a file descriptor.
  */
-ftruncate(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+/* ARGSUSED */
+ftruncate(p, uap, retval)
+       register struct proc *p;
+       register struct args {
                int     fd;
                off_t   length;
                int     fd;
                off_t   length;
-       } *uap = (struct a *)scp->sc_ap;
+       } *uap;
+       int *retval;
+{
        struct vattr vattr;
        struct vnode *vp;
        struct file *fp;
        int error;
 
        struct vattr vattr;
        struct vnode *vp;
        struct file *fp;
        int error;
 
-       if (error = getvnode(scp->sc_ofile, uap->fd, &fp))
+       if (error = getvnode(u.u_ofile, uap->fd, &fp))
                RETURN (error);
        if ((fp->f_flag & FWRITE) == 0)
                RETURN (EINVAL);
                RETURN (error);
        if ((fp->f_flag & FWRITE) == 0)
                RETURN (EINVAL);
-       vattr_null(&vattr);
+       VATTR_NULL(&vattr);
        vattr.va_size = uap->length;
        vp = (struct vnode *)fp->f_data;
        VOP_LOCK(vp);
        vattr.va_size = uap->length;
        vp = (struct vnode *)fp->f_data;
        VOP_LOCK(vp);
@@ -1162,18 +1349,24 @@ out:
 /*
  * Synch an open file.
  */
 /*
  * Synch an open file.
  */
-fsync(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+/* ARGSUSED */
+fsync(p, uap, retval)
+       register struct proc *p;
+       struct args {
                int     fd;
                int     fd;
-       } *uap = (struct a *)scp->sc_ap;
+       } *uap;
+       int *retval;
+{
+       register struct vnode *vp;
        struct file *fp;
        int error;
 
        struct file *fp;
        int error;
 
-       if (error = getvnode(scp->sc_ofile, uap->fd, &fp))
+       if (error = getvnode(u.u_ofile, uap->fd, &fp))
                RETURN (error);
                RETURN (error);
-       error = VOP_FSYNC((struct vnode *)fp->f_data, fp->f_flag, fp->f_cred);
+       vp = (struct vnode *)fp->f_data;
+       VOP_LOCK(vp);
+       error = VOP_FSYNC(vp, fp->f_flag, fp->f_cred, MNT_WAIT);
+       VOP_UNLOCK(vp);
        RETURN (error);
 }
 
        RETURN (error);
 }
 
@@ -1183,15 +1376,17 @@ fsync(scp)
  * Source and destination must either both be directories, or both
  * not be directories.  If target is a directory, it must be empty.
  */
  * Source and destination must either both be directories, or both
  * not be directories.  If target is a directory, it must be empty.
  */
-rename(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+/* ARGSUSED */
+rename(p, uap, retval)
+       register struct proc *p;
+       register struct args {
                char    *from;
                char    *to;
                char    *from;
                char    *to;
-       } *uap = (struct a *)scp->sc_ap;
+       } *uap;
+       int *retval;
+{
        register struct vnode *tvp, *fvp, *tdvp;
        register struct vnode *tvp, *fvp, *tdvp;
-       register struct nameidata *ndp = &scp->sc_nd;
+       register struct nameidata *ndp = &u.u_nd;
        struct nameidata tond;
        int error;
 
        struct nameidata tond;
        int error;
 
@@ -1250,14 +1445,16 @@ out1:
 /*
  * Mkdir system call
  */
 /*
  * Mkdir system call
  */
-mkdir(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+/* ARGSUSED */
+mkdir(p, uap, retval)
+       register struct proc *p;
+       register struct args {
                char    *name;
                int     dmode;
                char    *name;
                int     dmode;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp = &u.u_nd;
        register struct vnode *vp;
        struct vattr vattr;
        int error;
        register struct vnode *vp;
        struct vattr vattr;
        int error;
@@ -1272,9 +1469,9 @@ mkdir(scp)
                VOP_ABORTOP(ndp);
                RETURN (EEXIST);
        }
                VOP_ABORTOP(ndp);
                RETURN (EEXIST);
        }
-       vattr_null(&vattr);
+       VATTR_NULL(&vattr);
        vattr.va_type = VDIR;
        vattr.va_type = VDIR;
-       vattr.va_mode = (uap->dmode & 0777) &~ scp->sc_cmask;
+       vattr.va_mode = (uap->dmode & 0777) &~ u.u_cmask;
        error = VOP_MKDIR(ndp, &vattr);
        if (!error)
                vput(ndp->ni_vp);
        error = VOP_MKDIR(ndp, &vattr);
        if (!error)
                vput(ndp->ni_vp);
@@ -1284,13 +1481,15 @@ mkdir(scp)
 /*
  * Rmdir system call.
  */
 /*
  * Rmdir system call.
  */
-rmdir(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+/* ARGSUSED */
+rmdir(p, uap, retval)
+       register struct proc *p;
+       struct args {
                char    *name;
                char    *name;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp = &u.u_nd;
        register struct vnode *vp;
        int error;
 
        register struct vnode *vp;
        int error;
 
@@ -1327,25 +1526,30 @@ out:
 /*
  * Read a block of directory entries in a file system independent format
  */
 /*
  * Read a block of directory entries in a file system independent format
  */
-getdirentries(scp)
-       register struct syscontext *scp;
-{
-       register struct a {
+getdirentries(p, uap, retval)
+       register struct proc *p;
+       register struct args {
                int     fd;
                char    *buf;
                unsigned count;
                long    *basep;
                int     fd;
                char    *buf;
                unsigned count;
                long    *basep;
-       } *uap = (struct a *)scp->sc_ap;
+       } *uap;
+       int *retval;
+{
+       register struct vnode *vp;
        struct file *fp;
        struct uio auio;
        struct iovec aiov;
        off_t off;
        struct file *fp;
        struct uio auio;
        struct iovec aiov;
        off_t off;
-       int error;
+       int error, eofflag;
 
 
-       if (error = getvnode(scp->sc_ofile, uap->fd, &fp))
+       if (error = getvnode(u.u_ofile, uap->fd, &fp))
                RETURN (error);
        if ((fp->f_flag & FREAD) == 0)
                RETURN (EBADF);
                RETURN (error);
        if ((fp->f_flag & FREAD) == 0)
                RETURN (EBADF);
+       vp = (struct vnode *)fp->f_data;
+       if (vp->v_type != VDIR)
+               RETURN (EINVAL);
        aiov.iov_base = uap->buf;
        aiov.iov_len = uap->count;
        auio.uio_iov = &aiov;
        aiov.iov_base = uap->buf;
        aiov.iov_len = uap->count;
        auio.uio_iov = &aiov;
@@ -1353,31 +1557,75 @@ getdirentries(scp)
        auio.uio_rw = UIO_READ;
        auio.uio_segflg = UIO_USERSPACE;
        auio.uio_resid = uap->count;
        auio.uio_rw = UIO_READ;
        auio.uio_segflg = UIO_USERSPACE;
        auio.uio_resid = uap->count;
-       off = fp->f_offset;
-       if (error = VOP_READDIR((struct vnode *)fp->f_data, &auio,
-           &(fp->f_offset), fp->f_cred))
+       VOP_LOCK(vp);
+       auio.uio_offset = off = fp->f_offset;
+       error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag);
+       fp->f_offset = auio.uio_offset;
+       VOP_UNLOCK(vp);
+       if (error)
                RETURN (error);
                RETURN (error);
-       error = copyout((caddr_t)&off, (caddr_t)uap->basep,
-               sizeof(long));
-       scp->sc_retval1 = uap->count - auio.uio_resid;
+       error = copyout((caddr_t)&off, (caddr_t)uap->basep, sizeof(long));
+       *retval = uap->count - auio.uio_resid;
        RETURN (error);
 }
 
 /*
  * mode mask for creation of files
  */
        RETURN (error);
 }
 
 /*
  * mode mask for creation of files
  */
-umask(scp)
-       register struct syscontext *scp;
-{
-       register struct a {
+mode_t
+umask(p, uap, retval)
+       register struct proc *p;
+       struct args {
                int     mask;
                int     mask;
-       } *uap = (struct a *)scp->sc_ap;
+       } *uap;
+       int *retval;
+{
 
 
-       scp->sc_retval1 = scp->sc_cmask;
-       scp->sc_cmask = uap->mask & 07777;
+       *retval = u.u_cmask;
+       u.u_cmask = uap->mask & 07777;
        RETURN (0);
 }
 
        RETURN (0);
 }
 
+/*
+ * Void all references to file by ripping underlying filesystem
+ * away from vnode.
+ */
+/* ARGSUSED */
+revoke(p, uap, retval)
+       register struct proc *p;
+       register struct args {
+               char    *fname;
+               int     flags;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp = &u.u_nd;
+       register struct vnode *vp;
+       struct vattr vattr;
+       int error;
+
+       ndp->ni_nameiop = LOOKUP | FOLLOW;
+       ndp->ni_segflg = UIO_USERSPACE;
+       ndp->ni_dirp = uap->fname;
+       if (error = namei(ndp))
+               RETURN (error);
+       vp = ndp->ni_vp;
+       if (vp->v_type != VCHR && vp->v_type != VBLK) {
+               error = EINVAL;
+               goto out;
+       }
+       if (error = VOP_GETATTR(vp, &vattr, ndp->ni_cred))
+               goto out;
+       if (ndp->ni_cred->cr_uid != vattr.va_uid ||
+           (error = suser(ndp->ni_cred, &u.u_acflag)))
+               goto out;
+       if (vp->v_usecount > 1 || (vp->v_flag & VALIASED))
+               vgoneall(vp);
+out:
+       vrele(vp);
+       RETURN (error);
+}
+
 getvnode(ofile, fdes, fpp)
        struct file *ofile[];
        struct file **fpp;
 getvnode(ofile, fdes, fpp)
        struct file *ofile[];
        struct file **fpp;
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.