calls to chdirec didn't pass 'p'.

[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..0c0d108 100644 (file)
--- a/usr/src/sys/kern/vfs_syscalls.c
+++ b/usr/src/sys/kern/vfs_syscalls.c
@@ -2,100 +2,102 @@
   * Copyright (c) 1989 The Regents of the University of California.
   * All rights reserved.
   *
   * Copyright (c) 1989 The Regents of the University of California.
   * All rights reserved.
   *
- * Redistribution and use in source and binary forms are permitted
- * provided that the above copyright notice and this paragraph are
- * duplicated in all such forms and that any documentation,
- * advertising materials, and other materials related to such
- * distribution and use acknowledge that the software was developed
- * by the University of California, Berkeley.  The name of the
- * University may not be used to endorse or promote products derived
- * from this software without specific prior written permission.
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ * %sccs.include.redist.c%
   *
   *
- *     @(#)vfs_syscalls.c      7.18 (Berkeley) %G%
+ *     @(#)vfs_syscalls.c      7.79 (Berkeley) %G%
   */
  
  #include "param.h"
  #include "systm.h"
   */
  
  #include "param.h"
  #include "systm.h"
-#include "syscontext.h"
+#include "namei.h"
+#include "filedesc.h"
  #include "kernel.h"
  #include "file.h"
  #include "stat.h"
  #include "vnode.h"
  #include "kernel.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"
  
+#ifdef REF_DIAGNOSTIC
+#define CURCOUNT (curproc ? curproc->p_spare[0] : 0)
+#define CHECKPOINTREF int oldrefcount = CURCOUNT;
+#define CHECKREFS(F) if (oldrefcount != CURCOUNT) \
+       printf("REFCOUNT: %s, old=%d, new=%d\n", (F), oldrefcount, CURCOUNT);
+#else
+#define CHECKPOINTREF
+#define CHECKREFS(D)
+#endif
+
  /*
   * Virtual File System System Calls
   */
  
  /*
  /*
   * Virtual File System System Calls
   */
  
  /*
- * mount system call
+ * Mount system call.
   */
   */
-mount(scp)
-       register struct syscontext *scp;
-{
-       register struct a {
+/* ARGSUSED */
+mount(p, uap, retval)
+       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 vnode *vp;
         register struct mount *mp;
         register struct vnode *vp;
         register struct mount *mp;
-       int error;
+       int error, flag;
+       struct nameidata nd;
  
         /*
          * Must be super user
          */
  
         /*
          * Must be super user
          */
-       if (error = suser(scp->sc_cred, &scp->sc_acflag))
-               RETURN (error);
+       if (error = suser(p->p_ucred, &p->p_acflag))
+               return (error);
         /*
          * Get vnode to be covered
          */
         /*
          * Get vnode to be covered
          */
-       ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->dir;
-       if (error = namei(ndp))
-               RETURN (error);
-       vp = ndp->ni_vp;
-       if (uap->flags & M_UPDATE) {
+       NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->dir, p);
+       if (error = namei(&nd))
+               return (error);
+       vp = nd.ni_vp;
+       if (uap->flags & MNT_UPDATE) {
                 if ((vp->v_flag & VROOT) == 0) {
                         vput(vp);
                 if ((vp->v_flag & VROOT) == 0) {
                         vput(vp);
-                       RETURN (EINVAL);
+                       return (EINVAL);
                 }
                 mp = vp->v_mount;
                 /*
                  * We allow going from read-only to read-write,
                  * but not from read-write to read-only.
                  */
                 }
                 mp = vp->v_mount;
                 /*
                  * 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);
                         vput(vp);
-                       RETURN (EOPNOTSUPP);    /* Needs translation */
+                       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);
                 vput(vp);
-               RETURN (EBUSY);
+               return (EBUSY);
         }
         if (vp->v_type != VDIR) {
                 vput(vp);
         }
         if (vp->v_type != VDIR) {
                 vput(vp);
-               RETURN (ENOTDIR);
+               return (ENOTDIR);
         }
         }
-       if (uap->type > MOUNT_MAXTYPE ||
+       if ((unsigned long)uap->type > MOUNT_MAXTYPE ||
             vfssw[uap->type] == (struct vfsops *)0) {
                 vput(vp);
             vfssw[uap->type] == (struct vfsops *)0) {
                 vput(vp);
-               RETURN (ENODEV);
+               return (ENODEV);
         }
  
         /*
         }
  
         /*
@@ -103,73 +105,75 @@ 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_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);
-               RETURN (error);
+               return (error);
         }
         if (vp->v_mountedhere != (struct mount *)0) {
                 vfs_unlock(mp);
                 free((caddr_t)mp, M_MOUNT);
                 vput(vp);
         }
         if (vp->v_mountedhere != (struct mount *)0) {
                 vfs_unlock(mp);
                 free((caddr_t)mp, M_MOUNT);
                 vput(vp);
-               RETURN (EBUSY);
+               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.
          */
         /*
          * Mount the filesystem.
          */
-       error = VFS_MOUNT(mp, uap->dir, uap->data, ndp);
-       if (mp->m_flag & M_UPDATE) {
-               mp->m_flag &= ~M_UPDATE;
+       error = VFS_MOUNT(mp, uap->dir, uap->data, &nd, p);
+       if (mp->mnt_flag & MNT_UPDATE) {
+               mp->mnt_flag &= ~MNT_UPDATE;
                 vrele(vp);
                 vrele(vp);
-               RETURN (error);
+               if (error)
+                       mp->mnt_flag = flag;
+               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);
                 vfs_unlock(mp);
         cache_purge(vp);
         if (!error) {
                 VOP_UNLOCK(vp);
                 vfs_unlock(mp);
-               error = VFS_START(mp, 0);
+               error = VFS_START(mp, 0, p);
         } else {
                 vfs_remove(mp);
                 free((caddr_t)mp, M_MOUNT);
                 vput(vp);
         }
         } else {
                 vfs_remove(mp);
                 free((caddr_t)mp, M_MOUNT);
                 vput(vp);
         }
-       RETURN (error);
+       return (error);
  }
  
  /*
  }
  
  /*
@@ -178,239 +182,329 @@ 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)
+       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;
+       struct mount *mp;
         int error;
         int error;
+       struct nameidata nd;
  
         /*
          * Must be super user
          */
  
         /*
          * Must be super user
          */
-       if (error = suser(scp->sc_cred, &scp->sc_acflag))
-               RETURN (error);
+       if (error = suser(p->p_ucred, &p->p_acflag))
+               return (error);
  
  
-       ndp->ni_nameiop = LOOKUP | LOCKLEAF | FOLLOW;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->pathp;
-       if (error = namei(ndp))
-               RETURN (error);
-       vp = ndp->ni_vp;
+       NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->pathp, p);
+       if (error = namei(&nd))
+               return (error);
+       vp = nd.ni_vp;
         /*
          * Must be the root of the filesystem
          */
         if ((vp->v_flag & VROOT) == 0) {
                 vput(vp);
         /*
          * Must be the root of the filesystem
          */
         if ((vp->v_flag & VROOT) == 0) {
                 vput(vp);
-               RETURN (EINVAL);
+               return (EINVAL);
         }
         mp = vp->v_mount;
         vput(vp);
         }
         mp = vp->v_mount;
         vput(vp);
-       /*
-        * Do the unmount.
-        */
-       coveredvp = mp->m_vnodecovered;
+       return (dounmount(mp, uap->flags, p));
+}
+
+/*
+ * Do an unmount.
+ */
+dounmount(mp, flags, p)
+       register struct mount *mp;
+       int flags;
+       struct proc *p;
+{
+       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 */
+       vnode_pager_umount(mp); /* release cached vnodes */
         cache_purgevfs(mp);     /* remove cache entries for this file sys */
         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, p);
+       mp->mnt_flag &= ~MNT_UNMOUNT;
+       vfs_unbusy(mp);
         if (error) {
                 vfs_unlock(mp);
         } else {
                 vrele(coveredvp);
                 vfs_remove(mp);
         if (error) {
                 vfs_unlock(mp);
         } else {
                 vrele(coveredvp);
                 vfs_remove(mp);
+               if (mp->mnt_mounth != NULL)
+                       panic("unmount: dangling vnode");
                 free((caddr_t)mp, M_MOUNT);
         }
                 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)
+       struct proc *p;
+       void *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);
+       return (0);
  }
  
  /*
  }
  
  /*
- * get filesystem statistics
+ * Operate on filesystem quotas.
   */
   */
-statfs(scp)
-       register struct syscontext *scp;
+/* ARGSUSED */
+quotactl(p, uap, retval)
+       struct proc *p;
+       register struct args {
+               char *path;
+               int cmd;
+               int uid;
+               caddr_t arg;
+       } *uap;
+       int *retval;
  {
  {
-       struct a {
+       register struct mount *mp;
+       int error;
+       struct nameidata nd;
+
+       NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
+       if (error = namei(&nd))
+               return (error);
+       mp = nd.ni_vp->v_mount;
+       vrele(nd.ni_vp);
+       return (VFS_QUOTACTL(mp, uap->cmd, uap->uid, uap->arg, p));
+}
+
+/*
+ * Get filesystem statistics.
+ */
+/* ARGSUSED */
+statfs(p, uap, retval)
+       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 statfs *sp;
         int error;
         int error;
+       struct nameidata nd;
  
  
-       ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
-       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);
+       NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
+       if (error = namei(&nd))
+               return (error);
+       mp = nd.ni_vp->v_mount;
+       sp = &mp->mnt_stat;
+       vrele(nd.ni_vp);
+       if (error = VFS_STATFS(mp, sp, p))
+               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)
+       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))
-               RETURN (error);
-       if (error = VFS_STATFS(((struct vnode *)fp->f_data)->v_mount, &sb))
-               RETURN (error);
-       RETURN (copyout((caddr_t)&sb, (caddr_t)uap->buf, sizeof(sb)));
+       if (error = getvnode(p->p_fd, uap->fd, &fp))
+               return (error);
+       mp = ((struct vnode *)fp->f_data)->v_mount;
+       sp = &mp->mnt_stat;
+       if (error = VFS_STATFS(mp, sp, p))
+               return (error);
+       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)
+       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))
-                               RETURN (error);
-                       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, p))) {
+                               mp = mp->mnt_prev;
+                               continue;
+                       }
+                       sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
+                       if (error = copyout((caddr_t)sp, sfsp, sizeof(*sp)))
+                               return (error);
+                       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;
-       RETURN (0);
+               *retval = count;
+       return (0);
  }
  
  /*
   * Change current working directory to a given file descriptor.
   */
  }
  
  /*
   * Change current working directory to a given file descriptor.
   */
-fchdir(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+/* ARGSUSED */
+fchdir(p, uap, retval)
+       struct proc *p;
+       struct args {
                 int     fd;
                 int     fd;
-       } *uap = (struct a *)scp->sc_ap;
+       } *uap;
+       int *retval;
+{
+       register struct filedesc *fdp = p->p_fd;
         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))
-               RETURN (error);
+       if (error = getvnode(fdp, uap->fd, &fp))
+               return (error);
         vp = (struct vnode *)fp->f_data;
         VOP_LOCK(vp);
         if (vp->v_type != VDIR)
                 error = ENOTDIR;
         else
         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, p->p_ucred, p);
         VOP_UNLOCK(vp);
         VOP_UNLOCK(vp);
-       vrele(scp->sc_cdir);
-       scp->sc_cdir = vp;
-       RETURN (error);
+       if (error)
+               return (error);
+       VREF(vp);
+       vrele(fdp->fd_cdir);
+       fdp->fd_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)
+       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 filedesc *fdp = p->p_fd;
         int error;
         int error;
+       struct nameidata nd;
  
  
-       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_cdir);
-       scp->sc_cdir = ndp->ni_vp;
-       RETURN (0);
+       NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->fname, p);
+       if (error = chdirec(&nd, p))
+               return (error);
+       vrele(fdp->fd_cdir);
+       fdp->fd_cdir = nd.ni_vp;
+       return (0);
  }
  
  /*
   * Change notion of root (``/'') directory.
   */
  }
  
  /*
   * Change notion of root (``/'') directory.
   */
-chroot(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+/* ARGSUSED */
+chroot(p, uap, retval)
+       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 filedesc *fdp = p->p_fd;
         int error;
         int error;
+       struct nameidata nd;
  
  
-       if (error = suser(scp->sc_cred, &scp->sc_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);
-       vrele(scp->sc_rdir);
-       scp->sc_rdir = ndp->ni_vp;
-       RETURN (0);
+       if (error = suser(p->p_ucred, &p->p_acflag))
+               return (error);
+       NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->fname, p);
+       if (error = chdirec(&nd, p))
+               return (error);
+       if (fdp->fd_rdir != NULL)
+               vrele(fdp->fd_rdir);
+       fdp->fd_rdir = nd.ni_vp;
+       return (0);
  }
  
  /*
   * Common routine for chroot and chdir.
   */
  }
  
  /*
   * Common routine for chroot and chdir.
   */
-chdirec(ndp)
+chdirec(ndp, p)
         register struct nameidata *ndp;
         register struct nameidata *ndp;
+       struct proc *p;
  {
         struct vnode *vp;
         int error;
  {
         struct vnode *vp;
         int error;
@@ -421,7 +515,7 @@ chdirec(ndp)
         if (vp->v_type != VDIR)
                 error = ENOTDIR;
         else
         if (vp->v_type != VDIR)
                 error = ENOTDIR;
         else
-               error = VOP_ACCESS(vp, VEXEC, ndp->ni_cred);
+               error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p);
         VOP_UNLOCK(vp);
         if (error)
                 vrele(vp);
         VOP_UNLOCK(vp);
         if (error)
                 vrele(vp);
@@ -430,278 +524,378 @@ 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)
+       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;
  {
  {
+       register struct filedesc *fdp = p->p_fd;
         register struct file *fp;
         register struct file *fp;
+       register struct vnode *vp;
+       int fmode, cmode;
         struct file *nfp;
         struct file *nfp;
-       int indx, error;
+       int type, indx, error;
+       struct flock lf;
+       struct nameidata nd;
         extern struct fileops vnops;
  
         extern struct fileops vnops;
  
-       if (error = falloc(&nfp, &indx))
+       if (error = falloc(p, &nfp, &indx))
                 return (error);
         fp = nfp;
                 return (error);
         fp = nfp;
-       scp->sc_retval1 = indx; /* XXX for fdopen() */
-       if (error = vn_open(ndp, fmode, (cmode & 07777) &~ ISVTX)) {
-               scp->sc_ofile[indx] = NULL;
-               crfree(fp->f_cred);
-               fp->f_count--;
+       fmode = FFLAGS(uap->mode);
+       cmode = ((uap->crtmode &~ fdp->fd_cmask) & 07777) &~ S_ISVTX;
+       NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->fname, p);
+       p->p_dupfd = -indx - 1;                 /* XXX check for fdopen */
+       if (error = vn_open(&nd, fmode, cmode)) {
+               ffree(fp);
+               if (error == ENODEV &&          /* XXX from fdopen */
+                   p->p_dupfd >= 0 &&
+                   (error = dupfdopen(fdp, indx, p->p_dupfd, fmode)) == 0) {
+                       *retval = indx;
+                       return (0);
+               }
+               if (error == ERESTART)
+                       error = EINTR;
+               fdp->fd_ofiles[indx] = NULL;
                 return (error);
         }
                 return (error);
         }
+       vp = nd.ni_vp;
         fp->f_flag = fmode & FMASK;
         fp->f_flag = fmode & FMASK;
+       if (fmode & (O_EXLOCK | O_SHLOCK)) {
+               lf.l_whence = SEEK_SET;
+               lf.l_start = 0;
+               lf.l_len = 0;
+               if (fmode & O_EXLOCK)
+                       lf.l_type = F_WRLCK;
+               else
+                       lf.l_type = F_RDLCK;
+               type = F_FLOCK;
+               if ((fmode & FNONBLOCK) == 0)
+                       type |= F_WAIT;
+               if (error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, type)) {
+                       VOP_UNLOCK(vp);
+                       (void) vn_close(vp, fp->f_flag, fp->f_cred, p);
+                       ffree(fp);
+                       fdp->fd_ofiles[indx] = NULL;
+                       return (error);
+               }
+               fp->f_flag |= FHASLOCK;
+       }
+       VOP_UNLOCK(vp);
         fp->f_type = DTYPE_VNODE;
         fp->f_ops = &vnops;
         fp->f_type = DTYPE_VNODE;
         fp->f_ops = &vnops;
-       fp->f_data = (caddr_t)ndp->ni_vp;
-       if (resultfd)
-               *resultfd = indx;
+       fp->f_data = (caddr_t)vp;
+       *retval = indx;
         return (0);
  }
  
         return (0);
  }
  
+#ifdef COMPAT_43
  /*
  /*
- * Mknod system call
+ * Creat system call.
   */
   */
-mknod(scp)
-       register struct syscontext *scp;
+ocreat(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));
+}
+#endif /* COMPAT_43 */
+
+/*
+ * Mknod system call.
+ */
+/* ARGSUSED */
+mknod(p, uap, retval)
+       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 vnode *vp;
         struct vattr vattr;
         int error;
         register struct vnode *vp;
         struct vattr vattr;
         int error;
+       struct nameidata nd;
  
  
-       if (error = suser(scp->sc_cred, &scp->sc_acflag))
-               RETURN (error);
-       ndp->ni_nameiop = CREATE | LOCKPARENT;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       if (error = namei(ndp))
-               RETURN (error);
-       vp = ndp->ni_vp;
+       CHECKPOINTREF;
+       if (error = suser(p->p_ucred, &p->p_acflag))
+               return (error);
+       NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, uap->fname, p);
+       if (error = namei(&nd))
+               return (error);
+       vp = nd.ni_vp;
         if (vp != NULL) {
                 error = EEXIST;
                 goto out;
         }
         if (vp != NULL) {
                 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) &~ p->p_fd->fd_cmask;
         vattr.va_rdev = uap->dev;
  out:
         vattr.va_rdev = uap->dev;
  out:
-       if (error)
-               VOP_ABORTOP(ndp);
-       else
-               error = VOP_MKNOD(ndp, &vattr, ndp->ni_cred);
-       RETURN (error);
+       if (!error) {
+               LEASE_CHECK(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
+               error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr);
+       } else {
+               VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
+               if (nd.ni_dvp == vp)
+                       vrele(nd.ni_dvp);
+               else
+                       vput(nd.ni_dvp);
+               if (vp)
+                       vrele(vp);
+       }
+       CHECKREFS("mknod");
+       return (error);
  }
  
  /*
  }
  
  /*
- * link system call
+ * Mkfifo system call.
   */
   */
-link(scp)
-       register struct syscontext *scp;
+/* ARGSUSED */
+mkfifo(p, uap, retval)
+       struct proc *p;
+       register struct args {
+               char    *fname;
+               int     fmode;
+       } *uap;
+       int *retval;
  {
  {
-       register struct a {
+       struct vattr vattr;
+       int error;
+       struct nameidata nd;
+
+#ifndef FIFO
+       return (EOPNOTSUPP);
+#else
+       NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, uap->fname, p);
+       if (error = namei(&nd))
+               return (error);
+       if (nd.ni_vp != NULL) {
+               VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
+               if (nd.ni_dvp == nd.ni_vp)
+                       vrele(nd.ni_dvp);
+               else
+                       vput(nd.ni_dvp);
+               vrele(nd.ni_vp);
+               return (EEXIST);
+       }
+       VATTR_NULL(&vattr);
+       vattr.va_type = VFIFO;
+       vattr.va_mode = (uap->fmode & 07777) &~ p->p_fd->fd_cmask;
+       LEASE_CHECK(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
+       return (VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr));
+#endif /* FIFO */
+}
+
+/*
+ * Link system call.
+ */
+/* ARGSUSED */
+link(p, uap, retval)
+       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 vnode *vp, *xp;
         int error;
         register struct vnode *vp, *xp;
         int error;
+       struct nameidata nd;
  
  
-       ndp->ni_nameiop = LOOKUP | FOLLOW;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->target;
-       if (error = namei(ndp))
-               RETURN (error);
-       vp = ndp->ni_vp;
+       CHECKPOINTREF;
+       NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->target, p);
+       if (error = namei(&nd))
+               return (error);
+       vp = nd.ni_vp;
         if (vp->v_type == VDIR &&
         if (vp->v_type == VDIR &&
-           (error = suser(scp->sc_cred, &scp->sc_acflag)))
+           (error = suser(p->p_ucred, &p->p_acflag)))
                 goto out1;
                 goto out1;
-       ndp->ni_nameiop = CREATE | LOCKPARENT;
-       ndp->ni_dirp = (caddr_t)uap->linkname;
-       if (error = namei(ndp))
+       nd.ni_cnd.cn_nameiop = CREATE;
+       nd.ni_cnd.cn_flags = LOCKPARENT;
+       nd.ni_dirp = (caddr_t)uap->linkname;
+       if (error = namei(&nd))
                 goto out1;
                 goto out1;
-       xp = ndp->ni_vp;
+       xp = nd.ni_vp;
         if (xp != NULL) {
                 error = EEXIST;
                 goto out;
         }
         if (xp != NULL) {
                 error = EEXIST;
                 goto out;
         }
-       xp = ndp->ni_dvp;
+       xp = nd.ni_dvp;
         if (vp->v_mount != xp->v_mount)
                 error = EXDEV;
  out:
         if (vp->v_mount != xp->v_mount)
                 error = EXDEV;
  out:
-       if (error)
-               VOP_ABORTOP(ndp);
-       else
-               error = VOP_LINK(vp, ndp);
+       if (!error) {
+               LEASE_CHECK(xp, p, p->p_ucred, LEASE_WRITE);
+               LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
+               error = VOP_LINK(vp, nd.ni_dvp, &nd.ni_cnd);
+       } else {
+               VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
+               if (nd.ni_dvp == nd.ni_vp)
+                       vrele(nd.ni_dvp);
+               else
+                       vput(nd.ni_dvp);
+               if (nd.ni_vp)
+                       vrele(nd.ni_vp);
+       }
  out1:
         vrele(vp);
  out1:
         vrele(vp);
-       RETURN (error);
+       CHECKREFS("link");
+       return (error);
  }
  
  /*
  }
  
  /*
- * symlink -- make a symbolic link
+ * Make a symbolic link.
   */
   */
-symlink(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+/* ARGSUSED */
+symlink(p, uap, retval)
+       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;
-       register struct vnode *vp;
+       } *uap;
+       int *retval;
+{
         struct vattr vattr;
         char *target;
         int error;
         struct vattr vattr;
         char *target;
         int error;
+       struct nameidata nd;
  
  
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->linkname;
+       CHECKPOINTREF;
         MALLOC(target, char *, MAXPATHLEN, M_NAMEI, M_WAITOK);
         if (error = copyinstr(uap->target, target, MAXPATHLEN, (u_int *)0))
         MALLOC(target, char *, MAXPATHLEN, M_NAMEI, M_WAITOK);
         if (error = copyinstr(uap->target, target, MAXPATHLEN, (u_int *)0))
-               goto out1;
-       ndp->ni_nameiop = CREATE | LOCKPARENT;
-       if (error = namei(ndp))
-               goto out1;
-       vp = ndp->ni_vp;
-       if (vp) {
+               goto out;
+       NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, uap->linkname, p);
+       if (error = namei(&nd))
+               goto out;
+       if (nd.ni_vp) {
+               VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
+               if (nd.ni_dvp == nd.ni_vp)
+                       vrele(nd.ni_dvp);
+               else
+                       vput(nd.ni_dvp);
+               vrele(nd.ni_vp);
                 error = EEXIST;
                 goto out;
         }
                 error = EEXIST;
                 goto out;
         }
-       vp = ndp->ni_dvp;
-       vattr_null(&vattr);
-       vattr.va_mode = 0777 &~ scp->sc_cmask;
+       VATTR_NULL(&vattr);
+       vattr.va_mode = 0777 &~ p->p_fd->fd_cmask;
+       LEASE_CHECK(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
+       error = VOP_SYMLINK(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr, target);
  out:
  out:
-       if (error)
-               VOP_ABORTOP(ndp);
-       else
-               error = VOP_SYMLINK(ndp, &vattr, target);
-out1:
         FREE(target, M_NAMEI);
         FREE(target, M_NAMEI);
-       RETURN (error);
+       CHECKREFS("symlink");
+       return (error);
  }
  
  /*
  }
  
  /*
- * Unlink system call.
- * Hard to avoid races here, especially
- * in unlinking directories.
+ * Delete a name from the filesystem.
   */
   */
-unlink(scp)
-       register struct syscontext *scp;
+/* ARGSUSED */
+unlink(p, uap, retval)
+       struct proc *p;
+       struct args {
+               char    *name;
+       } *uap;
+       int *retval;
  {
  {
-       struct a {
-               char    *fname;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
         register struct vnode *vp;
         int error;
         register struct vnode *vp;
         int error;
+       struct nameidata nd;
  
  
-       ndp->ni_nameiop = DELETE | LOCKPARENT | LOCKLEAF;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       if (error = namei(ndp))
-               RETURN (error);
-       vp = ndp->ni_vp;
+       CHECKPOINTREF;
+       NDINIT(&nd, DELETE, LOCKPARENT | LOCKLEAF, UIO_USERSPACE, uap->name, p);
+       if (error = namei(&nd))
+               return (error);
+       vp = nd.ni_vp;
         if (vp->v_type == VDIR &&
         if (vp->v_type == VDIR &&
-           (error = suser(scp->sc_cred, &scp->sc_acflag)))
+           (error = suser(p->p_ucred, &p->p_acflag)))
                 goto out;
         /*
                 goto out;
         /*
-        * Don't unlink a mounted file.
+        * The root of a mounted filesystem cannot be deleted.
          */
         if (vp->v_flag & VROOT) {
                 error = EBUSY;
                 goto out;
         }
          */
         if (vp->v_flag & VROOT) {
                 error = EBUSY;
                 goto out;
         }
-       if (vp->v_flag & VTEXT)
-               xrele(vp);      /* try once to free text */
+       (void) vnode_pager_uncache(vp);
  out:
  out:
-       if (error)
-               VOP_ABORTOP(ndp);
-       else
-               error = VOP_REMOVE(ndp);
-       RETURN (error);
+       if (!error) {
+               LEASE_CHECK(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
+               LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
+               error = VOP_REMOVE(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd);
+       } else {
+               VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
+               if (nd.ni_dvp == vp)
+                       vrele(nd.ni_dvp);
+               else
+                       vput(nd.ni_dvp);
+               vput(vp);
+       }
+       CHECKREFS("unlink");
+       return (error);
  }
  
  /*
  }
  
  /*
- * Seek system call
+ * Seek system call.
   */
   */
-lseek(scp)
-       register struct syscontext *scp;
-{
-       register struct file *fp;
-       register struct a {
+lseek(p, uap, retval)
+       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 = p->p_ucred;
+       register struct filedesc *fdp = p->p_fd;
+       register struct file *fp;
         struct vattr vattr;
         int error;
  
         struct vattr vattr;
         int error;
  
-       if ((unsigned)uap->fdes >= NOFILE ||
-           (fp = scp->sc_ofile[uap->fdes]) == NULL)
-               RETURN (EBADF);
+       if ((unsigned)uap->fdes >= fdp->fd_nfiles ||
+           (fp = fdp->fd_ofiles[uap->fdes]) == NULL)
+               return (EBADF);
         if (fp->f_type != DTYPE_VNODE)
         if (fp->f_type != DTYPE_VNODE)
-               RETURN (ESPIPE);
+               return (ESPIPE);
         switch (uap->sbase) {
  
         case L_INCR:
         switch (uap->sbase) {
  
         case L_INCR:
@@ -710,8 +904,8 @@ 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))
-                       RETURN (error);
+                   &vattr, cred, p))
+                       return (error);
                 fp->f_offset = uap->off + vattr.va_size;
                 break;
  
                 fp->f_offset = uap->off + vattr.va_size;
                 break;
  
@@ -720,36 +914,37 @@ lseek(scp)
                 break;
  
         default:
                 break;
  
         default:
-               RETURN (EINVAL);
+               return (EINVAL);
         }
         }
-       scp->sc_offset = fp->f_offset;
-       RETURN (0);
+       *retval = fp->f_offset;
+       return (0);
  }
  
  /*
  }
  
  /*
- * Access system call
+ * Check access permissions.
   */
   */
-saccess(scp)
-       register struct syscontext *scp;
-{
-       register struct a {
+/* ARGSUSED */
+saccess(p, uap, retval)
+       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 ucred *cred = p->p_ucred;
         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;
-       ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       if (error = namei(ndp))
+       struct nameidata nd;
+
+       svuid = cred->cr_uid;
+       svgid = cred->cr_groups[0];
+       cred->cr_uid = p->p_cred->p_ruid;
+       cred->cr_groups[0] = p->p_cred->p_rgid;
+       NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->fname, p);
+       if (error = namei(&nd))
                 goto out1;
                 goto out1;
-       vp = ndp->ni_vp;
+       vp = nd.ni_vp;
         /*
          * fmode == 0 means only check for exist
          */
         /*
          * fmode == 0 means only check for exist
          */
@@ -761,84 +956,96 @@ 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)
-                       error = VOP_ACCESS(vp, mode, ndp->ni_cred);
+               if ((mode & VWRITE) == 0 || (error = vn_writechk(vp)) == 0)
+                       error = VOP_ACCESS(vp, mode, cred, p);
         }
         vput(vp);
  out1:
         }
         vput(vp);
  out1:
-       scp->sc_uid = svuid;
-       scp->sc_gid = svgid;
-       RETURN (error);
+       cred->cr_uid = svuid;
+       cred->cr_groups[0] = svgid;
+       return (error);
  }
  
  /*
  }
  
  /*
- * Stat system call.  This version follows links.
+ * Stat system call.
+ * This version follows links.
   */
   */
-stat(scp)
-       struct syscontext *scp;
+/* ARGSUSED */
+stat(p, uap, retval)
+       struct proc *p;
+       register struct args {
+               char    *fname;
+               struct stat *ub;
+       } *uap;
+       int *retval;
  {
  {
+       struct stat sb;
+       int error;
+       struct nameidata nd;
  
  
-       stat1(scp, FOLLOW);
+       NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->fname, p);
+       if (error = namei(&nd))
+               return (error);
+       error = vn_stat(nd.ni_vp, &sb, p);
+       vput(nd.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)
+       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;
+{
         struct stat sb;
         int error;
         struct stat sb;
         int error;
+       struct nameidata nd;
  
  
-       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);
+       NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF, UIO_USERSPACE, uap->fname, p);
+       if (error = namei(&nd))
+               return (error);
+       error = vn_stat(nd.ni_vp, &sb, p);
+       vput(nd.ni_vp);
         if (error)
         if (error)
-               RETURN (error);
+               return (error);
         error = copyout((caddr_t)&sb, (caddr_t)uap->ub, sizeof (sb));
         error = copyout((caddr_t)&sb, (caddr_t)uap->ub, sizeof (sb));
-       RETURN (error);
+       return (error);
  }
  
  /*
  }
  
  /*
- * 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)
+       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 vnode *vp;
         struct iovec aiov;
         struct uio auio;
         int error;
         register struct vnode *vp;
         struct iovec aiov;
         struct uio auio;
         int error;
+       struct nameidata nd;
  
  
-       ndp->ni_nameiop = LOOKUP | LOCKLEAF;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->name;
-       if (error = namei(ndp))
-               RETURN (error);
-       vp = ndp->ni_vp;
+       CHECKPOINTREF;
+       NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF, UIO_USERSPACE, uap->name, p);
+       if (error = namei(&nd))
+               return (error);
+       vp = nd.ni_vp;
         if (vp->v_type != VLNK) {
                 error = EINVAL;
                 goto out;
         if (vp->v_type != VLNK) {
                 error = EINVAL;
                 goto out;
@@ -850,301 +1057,320 @@ readlink(scp)
         auio.uio_offset = 0;
         auio.uio_rw = UIO_READ;
         auio.uio_segflg = UIO_USERSPACE;
         auio.uio_offset = 0;
         auio.uio_rw = UIO_READ;
         auio.uio_segflg = UIO_USERSPACE;
+       auio.uio_procp = p;
         auio.uio_resid = uap->count;
         auio.uio_resid = uap->count;
-       error = VOP_READLINK(vp, &auio, ndp->ni_cred);
+       error = VOP_READLINK(vp, &auio, p->p_ucred);
  out:
         vput(vp);
  out:
         vput(vp);
-       scp->sc_retval1 = uap->count - auio.uio_resid;
-       RETURN (error);
+       *retval = uap->count - auio.uio_resid;
+       CHECKREFS("readlink");
+       return (error);
  }
  
  /*
   * Change flags of a file given path name.
   */
  }
  
  /*
   * Change flags of a file given path name.
   */
-chflags(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+/* ARGSUSED */
+chflags(p, uap, retval)
+       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 vnode *vp;
         struct vattr vattr;
         int error;
         register struct vnode *vp;
         struct vattr vattr;
         int error;
+       struct nameidata nd;
  
  
-       ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       vattr_null(&vattr);
-       vattr.va_flags = uap->flags;
-       if (error = namei(ndp))
-               RETURN (error);
-       vp = ndp->ni_vp;
-       if (vp->v_mount->m_flag & M_RDONLY) {
+       NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->fname, p);
+       if (error = namei(&nd))
+               return (error);
+       vp = nd.ni_vp;
+       if (vp->v_mount->mnt_flag & MNT_RDONLY) {
                 error = EROFS;
                 goto out;
         }
                 error = EROFS;
                 goto out;
         }
-       error = VOP_SETATTR(vp, &vattr, ndp->ni_cred);
+       VATTR_NULL(&vattr);
+       vattr.va_flags = uap->flags;
+       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
+       error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
  out:
         vput(vp);
  out:
         vput(vp);
-       RETURN (error);
+       return (error);
  }
  
  /*
   * 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)
+       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))
-               RETURN (error);
-       vattr_null(&vattr);
-       vattr.va_flags = uap->flags;
+       if (error = getvnode(p->p_fd, uap->fd, &fp))
+               return (error);
         vp = (struct vnode *)fp->f_data;
         VOP_LOCK(vp);
         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;
         }
-       error = VOP_SETATTR(vp, &vattr, fp->f_cred);
+       VATTR_NULL(&vattr);
+       vattr.va_flags = uap->flags;
+       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
+       error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
  out:
         VOP_UNLOCK(vp);
  out:
         VOP_UNLOCK(vp);
-       RETURN (error);
+       return (error);
  }
  
  /*
   * 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)
+       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 vnode *vp;
         struct vattr vattr;
         int error;
         register struct vnode *vp;
         struct vattr vattr;
         int error;
+       struct nameidata nd;
  
  
-       ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       vattr_null(&vattr);
-       vattr.va_mode = uap->fmode & 07777;
-       if (error = namei(ndp))
-               RETURN (error);
-       vp = ndp->ni_vp;
-       if (vp->v_mount->m_flag & M_RDONLY) {
+       NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->fname, p);
+       if (error = namei(&nd))
+               return (error);
+       vp = nd.ni_vp;
+       if (vp->v_mount->mnt_flag & MNT_RDONLY) {
                 error = EROFS;
                 goto out;
         }
                 error = EROFS;
                 goto out;
         }
-       error = VOP_SETATTR(vp, &vattr, ndp->ni_cred);
+       VATTR_NULL(&vattr);
+       vattr.va_mode = uap->fmode & 07777;
+       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
+       error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
  out:
         vput(vp);
  out:
         vput(vp);
-       RETURN (error);
+       return (error);
  }
  
  /*
   * 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)
+       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))
-               RETURN (error);
-       vattr_null(&vattr);
-       vattr.va_mode = uap->fmode & 07777;
+       if (error = getvnode(p->p_fd, uap->fd, &fp))
+               return (error);
         vp = (struct vnode *)fp->f_data;
         VOP_LOCK(vp);
         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;
         }
-       error = VOP_SETATTR(vp, &vattr, fp->f_cred);
+       VATTR_NULL(&vattr);
+       vattr.va_mode = uap->fmode & 07777;
+       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
+       error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
  out:
         VOP_UNLOCK(vp);
  out:
         VOP_UNLOCK(vp);
-       RETURN (error);
+       return (error);
  }
  
  /*
   * 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)
+       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 vnode *vp;
         struct vattr vattr;
         int error;
         register struct vnode *vp;
         struct vattr vattr;
         int error;
+       struct nameidata nd;
  
  
-       ndp->ni_nameiop = LOOKUP | NOFOLLOW | LOCKLEAF;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       vattr_null(&vattr);
-       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) {
+       NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF, UIO_USERSPACE, uap->fname, p);
+       if (error = namei(&nd))
+               return (error);
+       vp = nd.ni_vp;
+       if (vp->v_mount->mnt_flag & MNT_RDONLY) {
                 error = EROFS;
                 goto out;
         }
                 error = EROFS;
                 goto out;
         }
-       error = VOP_SETATTR(vp, &vattr, ndp->ni_cred);
+       VATTR_NULL(&vattr);
+       vattr.va_uid = uap->uid;
+       vattr.va_gid = uap->gid;
+       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
+       error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
  out:
         vput(vp);
  out:
         vput(vp);
-       RETURN (error);
+       return (error);
  }
  
  /*
   * 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)
+       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))
-               RETURN (error);
-       vattr_null(&vattr);
-       vattr.va_uid = uap->uid;
-       vattr.va_gid = uap->gid;
+       if (error = getvnode(p->p_fd, uap->fd, &fp))
+               return (error);
         vp = (struct vnode *)fp->f_data;
         VOP_LOCK(vp);
         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;
         }
-       error = VOP_SETATTR(vp, &vattr, fp->f_cred);
+       VATTR_NULL(&vattr);
+       vattr.va_uid = uap->uid;
+       vattr.va_gid = uap->gid;
+       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
+       error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
  out:
         VOP_UNLOCK(vp);
  out:
         VOP_UNLOCK(vp);
-       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)
+       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 vnode *vp;
         struct timeval tv[2];
         struct vattr vattr;
         int error;
         register struct vnode *vp;
         struct timeval tv[2];
         struct vattr vattr;
         int error;
+       struct nameidata nd;
  
         if (error = copyin((caddr_t)uap->tptr, (caddr_t)tv, sizeof (tv)))
  
         if (error = copyin((caddr_t)uap->tptr, (caddr_t)tv, sizeof (tv)))
-               RETURN (error);
-       ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       vattr_null(&vattr);
-       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) {
+               return (error);
+       NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->fname, p);
+       if (error = namei(&nd))
+               return (error);
+       vp = nd.ni_vp;
+       if (vp->v_mount->mnt_flag & MNT_RDONLY) {
                 error = EROFS;
                 goto out;
         }
                 error = EROFS;
                 goto out;
         }
-       error = VOP_SETATTR(vp, &vattr, ndp->ni_cred);
+       VATTR_NULL(&vattr);
+       vattr.va_atime = tv[0];
+       vattr.va_mtime = tv[1];
+       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
+       error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
  out:
         vput(vp);
  out:
         vput(vp);
-       RETURN (error);
+       return (error);
  }
  
  /*
   * 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)
+       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 vnode *vp;
         struct vattr vattr;
         int error;
         register struct vnode *vp;
         struct vattr vattr;
         int error;
+       struct nameidata nd;
  
  
-       ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       vattr_null(&vattr);
-       vattr.va_size = uap->length;
-       if (error = namei(ndp))
-               RETURN (error);
-       vp = ndp->ni_vp;
+       NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->fname, p);
+       if (error = namei(&nd))
+               return (error);
+       vp = nd.ni_vp;
         if (vp->v_type == VDIR) {
                 error = EISDIR;
                 goto out;
         }
         if ((error = vn_writechk(vp)) ||
         if (vp->v_type == VDIR) {
                 error = EISDIR;
                 goto out;
         }
         if ((error = vn_writechk(vp)) ||
-           (error = VOP_ACCESS(vp, VWRITE, ndp->ni_cred)))
+           (error = VOP_ACCESS(vp, VWRITE, p->p_ucred, p)))
                 goto out;
                 goto out;
-       error = VOP_SETATTR(vp, &vattr, ndp->ni_cred);
+       VATTR_NULL(&vattr);
+       vattr.va_size = uap->length;
+       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
+       error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
  out:
         vput(vp);
  out:
         vput(vp);
-       RETURN (error);
+       return (error);
  }
  
  /*
   * 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)
+       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))
-               RETURN (error);
+       if (error = getvnode(p->p_fd, uap->fd, &fp))
+               return (error);
         if ((fp->f_flag & FWRITE) == 0)
         if ((fp->f_flag & FWRITE) == 0)
-               RETURN (EINVAL);
-       vattr_null(&vattr);
-       vattr.va_size = uap->length;
+               return (EINVAL);
         vp = (struct vnode *)fp->f_data;
         VOP_LOCK(vp);
         if (vp->v_type == VDIR) {
         vp = (struct vnode *)fp->f_data;
         VOP_LOCK(vp);
         if (vp->v_type == VDIR) {
@@ -1153,28 +1379,37 @@ ftruncate(scp)
         }
         if (error = vn_writechk(vp))
                 goto out;
         }
         if (error = vn_writechk(vp))
                 goto out;
-       error = VOP_SETATTR(vp, &vattr, fp->f_cred);
+       VATTR_NULL(&vattr);
+       vattr.va_size = uap->length;
+       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
+       error = VOP_SETATTR(vp, &vattr, fp->f_cred, p);
  out:
         VOP_UNLOCK(vp);
  out:
         VOP_UNLOCK(vp);
-       RETURN (error);
+       return (error);
  }
  
  /*
   * Synch an open file.
   */
  }
  
  /*
   * Synch an open file.
   */
-fsync(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+/* ARGSUSED */
+fsync(p, uap, retval)
+       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))
-               RETURN (error);
-       error = VOP_FSYNC((struct vnode *)fp->f_data, fp->f_flag, fp->f_cred);
-       RETURN (error);
+       if (error = getvnode(p->p_fd, uap->fd, &fp))
+               return (error);
+       vp = (struct vnode *)fp->f_data;
+       VOP_LOCK(vp);
+       error = VOP_FSYNC(vp, fp->f_flag, fp->f_cred, MNT_WAIT, p);
+       VOP_UNLOCK(vp);
+       return (error);
  }
  
  /*
  }
  
  /*
@@ -1183,29 +1418,33 @@ 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)
+       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;
-       struct nameidata tond;
+       struct nameidata fromnd, tond;
         int error;
  
         int error;
  
-       ndp->ni_nameiop = DELETE | WANTPARENT;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->from;
-       if (error = namei(ndp))
-               RETURN (error);
-       fvp = ndp->ni_vp;
-       nddup(ndp, &tond);
-       tond.ni_nameiop = RENAME | LOCKPARENT | LOCKLEAF | NOCACHE;
-       tond.ni_segflg = UIO_USERSPACE;
-       tond.ni_dirp = uap->to;
-       error = namei(&tond);
+       CHECKPOINTREF;
+       NDINIT(&fromnd, DELETE, WANTPARENT | SAVESTART, UIO_USERSPACE,
+               uap->from, p);
+       if (error = namei(&fromnd))
+               return (error);
+       fvp = fromnd.ni_vp;
+       NDINIT(&tond, RENAME, LOCKPARENT | LOCKLEAF | NOCACHE | SAVESTART,
+               UIO_USERSPACE, uap->to, p);
+       if (error = namei(&tond)) {
+               VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd);
+               vrele(fromnd.ni_dvp);
+               vrele(fvp);
+               goto out1;
+       }
         tdvp = tond.ni_dvp;
         tvp = tond.ni_vp;
         if (tvp != NULL) {
         tdvp = tond.ni_dvp;
         tvp = tond.ni_vp;
         if (tvp != NULL) {
@@ -1216,10 +1455,10 @@ rename(scp)
                         error = EISDIR;
                         goto out;
                 }
                         error = EISDIR;
                         goto out;
                 }
-       }
-       if (error) {
-               VOP_ABORTOP(ndp);
-               goto out1;
+               if (fvp->v_mount != tvp->v_mount) {
+                       error = EXDEV;
+                       goto out;
+               }
         }
         if (fvp->v_mount != tdvp->v_mount) {
                 error = EXDEV;
         }
         if (fvp->v_mount != tdvp->v_mount) {
                 error = EXDEV;
@@ -1228,78 +1467,112 @@ rename(scp)
         if (fvp == tdvp)
                 error = EINVAL;
         /*
         if (fvp == tdvp)
                 error = EINVAL;
         /*
-        * If source is the same as the destination,
+        * If source is the same as the destination (that is the
+        * same inode number with the same name in the same directory),
          * then there is nothing to do.
          */
          * then there is nothing to do.
          */
-       if (fvp == tvp)
+       if (fvp == tvp && fromnd.ni_dvp == tdvp &&
+           fromnd.ni_cnd.cn_namelen == tond.ni_cnd.cn_namelen &&
+           !bcmp(fromnd.ni_cnd.cn_nameptr, tond.ni_cnd.cn_nameptr,
+             fromnd.ni_cnd.cn_namelen))
                 error = -1;
  out:
                 error = -1;
  out:
-       if (error) {
-               VOP_ABORTOP(&tond);
-               VOP_ABORTOP(ndp);
+       if (!error) {
+               LEASE_CHECK(tdvp, p, p->p_ucred, LEASE_WRITE);
+               if (fromnd.ni_dvp != tdvp)
+                       LEASE_CHECK(fromnd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
+               if (tvp)
+                       LEASE_CHECK(tvp, p, p->p_ucred, LEASE_WRITE);
+               error = VOP_RENAME(fromnd.ni_dvp, fromnd.ni_vp, &fromnd.ni_cnd,
+                                  tond.ni_dvp, tond.ni_vp, &tond.ni_cnd);
         } else {
         } else {
-               error = VOP_RENAME(ndp, &tond);
+               VOP_ABORTOP(tond.ni_dvp, &tond.ni_cnd);
+               if (tdvp == tvp)
+                       vrele(tdvp);
+               else
+                       vput(tdvp);
+               if (tvp)
+                       vput(tvp);
+               VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd);
+               vrele(fromnd.ni_dvp);
+               vrele(fvp);
         }
         }
+       p->p_spare[1]--;
+       vrele(tond.ni_startdir);
+       FREE(tond.ni_cnd.cn_pnbuf, M_NAMEI);
  out1:
  out1:
-       ndrele(&tond);
+       p->p_spare[1]--;
+       vrele(fromnd.ni_startdir);
+       FREE(fromnd.ni_cnd.cn_pnbuf, M_NAMEI);
+       CHECKREFS("rename");
         if (error == -1)
         if (error == -1)
-               RETURN (0);
-       RETURN (error);
+               return (0);
+       return (error);
  }
  
  /*
  }
  
  /*
- * Mkdir system call
+ * Mkdir system call.
   */
   */
-mkdir(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+/* ARGSUSED */
+mkdir(p, uap, retval)
+       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 vnode *vp;
         struct vattr vattr;
         int error;
         register struct vnode *vp;
         struct vattr vattr;
         int error;
+       struct nameidata nd;
  
  
-       ndp->ni_nameiop = CREATE | LOCKPARENT;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->name;
-       if (error = namei(ndp))
-               RETURN (error);
-       vp = ndp->ni_vp;
+       CHECKPOINTREF;
+       NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, uap->name, p);
+       if (error = namei(&nd))
+               return (error);
+       vp = nd.ni_vp;
         if (vp != NULL) {
         if (vp != NULL) {
-               VOP_ABORTOP(ndp);
-               RETURN (EEXIST);
+               VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
+               if (nd.ni_dvp == vp)
+                       vrele(nd.ni_dvp);
+               else
+                       vput(nd.ni_dvp);
+               vrele(vp);
+               CHECKREFS("mkdir1");
+               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;
-       error = VOP_MKDIR(ndp, &vattr);
+       vattr.va_mode = (uap->dmode & 0777) &~ p->p_fd->fd_cmask;
+       LEASE_CHECK(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
+       error = VOP_MKDIR(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr);
         if (!error)
         if (!error)
-               vput(ndp->ni_vp);
-       RETURN (error);
+               vput(nd.ni_vp);
+       CHECKREFS("mkdir2");
+       return (error);
  }
  
  /*
   * Rmdir system call.
   */
  }
  
  /*
   * Rmdir system call.
   */
-rmdir(scp)
-       register struct syscontext *scp;
-{
-       struct a {
+/* ARGSUSED */
+rmdir(p, uap, retval)
+       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 vnode *vp;
         int error;
         register struct vnode *vp;
         int error;
+       struct nameidata nd;
  
  
-       ndp->ni_nameiop = DELETE | LOCKPARENT | LOCKLEAF;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->name;
-       if (error = namei(ndp))
-               RETURN (error);
-       vp = ndp->ni_vp;
+       CHECKPOINTREF;
+       NDINIT(&nd, DELETE, LOCKPARENT | LOCKLEAF, UIO_USERSPACE, uap->name, p);
+       if (error = namei(&nd))
+               return (error);
+       vp = nd.ni_vp;
         if (vp->v_type != VDIR) {
                 error = ENOTDIR;
                 goto out;
         if (vp->v_type != VDIR) {
                 error = ENOTDIR;
                 goto out;
@@ -1307,85 +1580,146 @@ rmdir(scp)
         /*
          * No rmdir "." please.
          */
         /*
          * No rmdir "." please.
          */
-       if (ndp->ni_dvp == vp) {
+       if (nd.ni_dvp == vp) {
                 error = EINVAL;
                 goto out;
         }
         /*
                 error = EINVAL;
                 goto out;
         }
         /*
-        * Don't unlink a mounted file.
+        * The root of a mounted filesystem cannot be deleted.
          */
         if (vp->v_flag & VROOT)
                 error = EBUSY;
  out:
          */
         if (vp->v_flag & VROOT)
                 error = EBUSY;
  out:
-       if (error)
-               VOP_ABORTOP(ndp);
-       else
-               error = VOP_RMDIR(ndp);
-       RETURN (error);
+       if (!error) {
+               LEASE_CHECK(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
+               LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
+               error = VOP_RMDIR(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd);
+       } else {
+               VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
+               if (nd.ni_dvp == vp)
+                       vrele(nd.ni_dvp);
+               else
+                       vput(nd.ni_dvp);
+               vput(vp);
+       }
+       CHECKREFS("rmdir");
+       return (error);
  }
  
  /*
  }
  
  /*
- * 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)
+       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))
-               RETURN (error);
+       if (error = getvnode(p->p_fd, uap->fd, &fp))
+               return (error);
         if ((fp->f_flag & FREAD) == 0)
         if ((fp->f_flag & FREAD) == 0)
-               RETURN (EBADF);
+               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;
         auio.uio_iovcnt = 1;
         auio.uio_rw = UIO_READ;
         auio.uio_segflg = UIO_USERSPACE;
         aiov.iov_base = uap->buf;
         aiov.iov_len = uap->count;
         auio.uio_iov = &aiov;
         auio.uio_iovcnt = 1;
         auio.uio_rw = UIO_READ;
         auio.uio_segflg = UIO_USERSPACE;
+       auio.uio_procp = p;
         auio.uio_resid = uap->count;
         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))
-               RETURN (error);
-       error = copyout((caddr_t)&off, (caddr_t)uap->basep,
-               sizeof(long));
-       scp->sc_retval1 = uap->count - auio.uio_resid;
-       RETURN (error);
+       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);
+       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
+ * Set the mode mask for creation of filesystem nodes.
   */
   */
-umask(scp)
-       register struct syscontext *scp;
-{
-       register struct a {
+mode_t
+umask(p, uap, retval)
+       struct proc *p;
+       struct args {
                 int     mask;
                 int     mask;
-       } *uap = (struct a *)scp->sc_ap;
+       } *uap;
+       int *retval;
+{
+       register struct filedesc *fdp = p->p_fd;
  
  
-       scp->sc_retval1 = scp->sc_cmask;
-       scp->sc_cmask = uap->mask & 07777;
-       RETURN (0);
+       *retval = fdp->fd_cmask;
+       fdp->fd_cmask = uap->mask & 07777;
+       return (0);
  }
  
  }
  
-getvnode(ofile, fdes, fpp)
-       struct file *ofile[];
+/*
+ * Void all references to file by ripping underlying filesystem
+ * away from vnode.
+ */
+/* ARGSUSED */
+revoke(p, uap, retval)
+       struct proc *p;
+       register struct args {
+               char    *fname;
+       } *uap;
+       int *retval;
+{
+       register struct vnode *vp;
+       struct vattr vattr;
+       int error;
+       struct nameidata nd;
+
+       NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->fname, p);
+       if (error = namei(&nd))
+               return (error);
+       vp = nd.ni_vp;
+       if (vp->v_type != VCHR && vp->v_type != VBLK) {
+               error = EINVAL;
+               goto out;
+       }
+       if (error = VOP_GETATTR(vp, &vattr, p->p_ucred, p))
+               goto out;
+       if (p->p_ucred->cr_uid != vattr.va_uid &&
+           (error = suser(p->p_ucred, &p->p_acflag)))
+               goto out;
+       if (vp->v_usecount > 1 || (vp->v_flag & VALIASED))
+               vgoneall(vp);
+out:
+       vrele(vp);
+       return (error);
+}
+
+/*
+ * Convert a user file descriptor to a kernel file entry.
+ */
+getvnode(fdp, fdes, fpp)
+       struct filedesc *fdp;
         struct file **fpp;
         int fdes;
  {
         struct file *fp;
  
         struct file **fpp;
         int fdes;
  {
         struct file *fp;
  
-       if ((unsigned)fdes >= NOFILE || (fp = ofile[fdes]) == NULL)
+       if ((unsigned)fdes >= fdp->fd_nfiles ||
+           (fp = fdp->fd_ofiles[fdes]) == NULL)
                 return (EBADF);
         if (fp->f_type != DTYPE_VNODE)
                 return (EINVAL);
                 return (EBADF);
         if (fp->f_type != DTYPE_VNODE)
                 return (EINVAL);