use vn_close rather than vrele after vn_open

[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 4f6d916..61920f5 100644 (file)
--- a/usr/src/sys/kern/vfs_syscalls.c
+++ b/usr/src/sys/kern/vfs_syscalls.c
@@ -1,402 +1,921 @@
  /*
  /*
- * Copyright (c) 1982 Regents of the University of California.
- * All rights reserved.  The Berkeley software License Agreement
- * specifies the terms and conditions for redistribution.
+ * Copyright (c) 1989 The Regents of the University of California.
+ * All rights reserved.
   *
   *
- *     @(#)vfs_syscalls.c      6.23 (Berkeley) %G%
+ * %sccs.include.redist.c%
+ *
+ *     @(#)vfs_syscalls.c      7.74 (Berkeley) %G%
   */
  
  #include "param.h"
  #include "systm.h"
   */
  
  #include "param.h"
  #include "systm.h"
-#include "dir.h"
-#include "user.h"
+#include "namei.h"
+#include "filedesc.h"
  #include "kernel.h"
  #include "file.h"
  #include "stat.h"
  #include "kernel.h"
  #include "file.h"
  #include "stat.h"
-#include "inode.h"
-#include "fs.h"
-#include "buf.h"
+#include "vnode.h"
+#include "mount.h"
  #include "proc.h"
  #include "proc.h"
-#include "quota.h"
  #include "uio.h"
  #include "uio.h"
-#include "socket.h"
-#include "socketvar.h"
-#include "mount.h"
+#include "malloc.h"
  
  
-extern struct fileops inodeops;
-struct file *getinode();
+/*
+ * Virtual File System System Calls
+ */
  
  /*
  
  /*
- * Change current working directory (``.'').
+ * Mount system call.
   */
   */
-chdir()
+/* ARGSUSED */
+mount(p, uap, retval)
+       struct proc *p;
+       register struct args {
+               int     type;
+               char    *dir;
+               int     flags;
+               caddr_t data;
+       } *uap;
+       int *retval;
  {
  {
+       register struct nameidata *ndp;
+       register struct vnode *vp;
+       register struct mount *mp;
+       int error, flag;
+       struct nameidata nd;
  
  
-       chdirec(&u.u_cdir);
+       /*
+        * Must be super user
+        */
+       if (error = suser(p->p_ucred, &p->p_acflag))
+               return (error);
+       /*
+        * Get vnode to be covered
+        */
+       ndp = &nd;
+       ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
+       ndp->ni_segflg = UIO_USERSPACE;
+       ndp->ni_dirp = uap->dir;
+       if (error = namei(ndp, p))
+               return (error);
+       vp = ndp->ni_vp;
+       if (uap->flags & MNT_UPDATE) {
+               if ((vp->v_flag & VROOT) == 0) {
+                       vput(vp);
+                       return (EINVAL);
+               }
+               mp = vp->v_mount;
+               /*
+                * We allow going from read-only to read-write,
+                * but not from read-write to read-only.
+                */
+               if ((mp->mnt_flag & MNT_RDONLY) == 0 &&
+                   (uap->flags & MNT_RDONLY) != 0) {
+                       vput(vp);
+                       return (EOPNOTSUPP);    /* Needs translation */
+               }
+               flag = mp->mnt_flag;
+               mp->mnt_flag |= MNT_UPDATE;
+               VOP_UNLOCK(vp);
+               goto update;
+       }
+       vinvalbuf(vp, 1);
+       if (vp->v_usecount != 1) {
+               vput(vp);
+               return (EBUSY);
+       }
+       if (vp->v_type != VDIR) {
+               vput(vp);
+               return (ENOTDIR);
+       }
+       if ((unsigned long)uap->type > MOUNT_MAXTYPE ||
+           vfssw[uap->type] == (struct vfsops *)0) {
+               vput(vp);
+               return (ENODEV);
+       }
+
+       /*
+        * Allocate and initialize the file system.
+        */
+       mp = (struct mount *)malloc((u_long)sizeof(struct mount),
+               M_MOUNT, M_WAITOK);
+       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);
+               return (error);
+       }
+       if (vp->v_mountedhere != (struct mount *)0) {
+               vfs_unlock(mp);
+               free((caddr_t)mp, M_MOUNT);
+               vput(vp);
+               return (EBUSY);
+       }
+       vp->v_mountedhere = mp;
+       mp->mnt_vnodecovered = vp;
+update:
+       /*
+        * Set the mount level flags.
+        */
+       if (uap->flags & MNT_RDONLY)
+               mp->mnt_flag |= MNT_RDONLY;
+       else
+               mp->mnt_flag &= ~MNT_RDONLY;
+       if (uap->flags & MNT_NOSUID)
+               mp->mnt_flag |= MNT_NOSUID;
+       else
+               mp->mnt_flag &= ~MNT_NOSUID;
+       if (uap->flags & MNT_NOEXEC)
+               mp->mnt_flag |= MNT_NOEXEC;
+       else
+               mp->mnt_flag &= ~MNT_NOEXEC;
+       if (uap->flags & MNT_NODEV)
+               mp->mnt_flag |= MNT_NODEV;
+       else
+               mp->mnt_flag &= ~MNT_NODEV;
+       if (uap->flags & MNT_SYNCHRONOUS)
+               mp->mnt_flag |= MNT_SYNCHRONOUS;
+       else
+               mp->mnt_flag &= ~MNT_SYNCHRONOUS;
+       /*
+        * Mount the filesystem.
+        */
+       error = VFS_MOUNT(mp, uap->dir, uap->data, ndp, p);
+       if (mp->mnt_flag & MNT_UPDATE) {
+               mp->mnt_flag &= ~MNT_UPDATE;
+               vrele(vp);
+               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);
+               error = VFS_START(mp, 0, p);
+       } else {
+               vfs_remove(mp);
+               free((caddr_t)mp, M_MOUNT);
+               vput(vp);
+       }
+       return (error);
  }
  
  /*
  }
  
  /*
- * Change notion of root (``/'') directory.
+ * Unmount system call.
+ *
+ * Note: unmount takes a path to the vnode mounted on as argument,
+ * not special file (as before).
   */
   */
-chroot()
+/* ARGSUSED */
+unmount(p, uap, retval)
+       struct proc *p;
+       register struct args {
+               char    *pathp;
+               int     flags;
+       } *uap;
+       int *retval;
  {
  {
+       register struct vnode *vp;
+       register struct nameidata *ndp;
+       struct mount *mp;
+       int error;
+       struct nameidata nd;
  
  
-       if (suser())
-               chdirec(&u.u_rdir);
+       /*
+        * Must be super user
+        */
+       if (error = suser(p->p_ucred, &p->p_acflag))
+               return (error);
+
+       ndp = &nd;
+       ndp->ni_nameiop = LOOKUP | LOCKLEAF | FOLLOW;
+       ndp->ni_segflg = UIO_USERSPACE;
+       ndp->ni_dirp = uap->pathp;
+       if (error = namei(ndp, p))
+               return (error);
+       vp = ndp->ni_vp;
+       /*
+        * Must be the root of the filesystem
+        */
+       if ((vp->v_flag & VROOT) == 0) {
+               vput(vp);
+               return (EINVAL);
+       }
+       mp = vp->v_mount;
+       vput(vp);
+       return (dounmount(mp, uap->flags, p));
  }
  
  /*
  }
  
  /*
- * Common routine for chroot and chdir.
+ * Do an unmount.
   */
   */
-chdirec(ipp)
-       register struct inode **ipp;
+dounmount(mp, flags, p)
+       register struct mount *mp;
+       int flags;
+       struct proc *p;
  {
  {
-       register struct inode *ip;
-       struct a {
-               char    *fname;
-       } *uap = (struct a *)u.u_ap;
-       register struct nameidata *ndp = &u.u_nd;
+       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))
+               return (error);
+
+       vnode_pager_umount(mp); /* release cached vnodes */
+       cache_purgevfs(mp);     /* remove cache entries for this file sys */
+       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);
+               free((caddr_t)mp, M_MOUNT);
+       }
+       return (error);
+}
+
+/*
+ * Sync system call.
+ * Sync each mounted filesystem.
+ */
+/* ARGSUSED */
+sync(p, uap, retval)
+       struct proc *p;
+       void *uap;
+       int *retval;
+{
+       register struct mount *mp;
+       struct mount *omp;
+
+       mp = rootfs;
+       do {
+               /*
+                * 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);
+                       omp = mp;
+                       mp = mp->mnt_next;
+                       vfs_unbusy(omp);
+               } else
+                       mp = mp->mnt_next;
+       } while (mp != rootfs);
+       return (0);
+}
+
+/*
+ * Operate on filesystem quotas.
+ */
+/* ARGSUSED */
+quotactl(p, uap, retval)
+       struct proc *p;
+       register struct args {
+               char *path;
+               int cmd;
+               int uid;
+               caddr_t arg;
+       } *uap;
+       int *retval;
+{
+       register struct mount *mp;
+       register struct nameidata *ndp;
+       int error;
+       struct nameidata nd;
  
  
+       ndp = &nd;
         ndp->ni_nameiop = LOOKUP | FOLLOW;
         ndp->ni_segflg = UIO_USERSPACE;
         ndp->ni_nameiop = LOOKUP | FOLLOW;
         ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       ip = namei(ndp);
-       if (ip == NULL)
-               return;
-       if ((ip->i_mode&IFMT) != IFDIR) {
-               u.u_error = ENOTDIR;
-               goto bad;
-       }
-       if (access(ip, IEXEC))
-               goto bad;
-       IUNLOCK(ip);
-       if (*ipp)
-               irele(*ipp);
-       *ipp = ip;
-       return;
-
-bad:
-       iput(ip);
+       ndp->ni_dirp = uap->path;
+       if (error = namei(ndp, p))
+               return (error);
+       mp = ndp->ni_vp->v_mount;
+       vrele(ndp->ni_vp);
+       return (VFS_QUOTACTL(mp, uap->cmd, uap->uid, uap->arg, p));
  }
  
  /*
  }
  
  /*
- * Open system call.
+ * Get filesystem statistics.
   */
   */
-open()
+/* ARGSUSED */
+statfs(p, uap, retval)
+       struct proc *p;
+       register struct args {
+               char *path;
+               struct statfs *buf;
+       } *uap;
+       int *retval;
  {
  {
-       struct a {
-               char    *fname;
-               int     mode;
-               int     crtmode;
-       } *uap = (struct a *) u.u_ap;
+       register struct mount *mp;
+       register struct nameidata *ndp;
+       register struct statfs *sp;
+       int error;
+       struct nameidata nd;
  
  
-       copen(uap->mode-FOPEN, uap->crtmode, uap->fname);
+       ndp = &nd;
+       ndp->ni_nameiop = LOOKUP | FOLLOW;
+       ndp->ni_segflg = UIO_USERSPACE;
+       ndp->ni_dirp = uap->path;
+       if (error = namei(ndp, p))
+               return (error);
+       mp = ndp->ni_vp->v_mount;
+       sp = &mp->mnt_stat;
+       vrele(ndp->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)));
  }
  
  /*
  }
  
  /*
- * Creat system call.
+ * Get filesystem statistics.
+ */
+/* ARGSUSED */
+fstatfs(p, uap, retval)
+       struct proc *p;
+       register struct args {
+               int fd;
+               struct statfs *buf;
+       } *uap;
+       int *retval;
+{
+       struct file *fp;
+       struct mount *mp;
+       register struct statfs *sp;
+       int error;
+
+       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.
+ */
+getfsstat(p, uap, retval)
+       struct proc *p;
+       register struct args {
+               struct statfs *buf;
+               long bufsize;
+               int flags;
+       } *uap;
+       int *retval;
+{
+       register struct mount *mp;
+       register struct statfs *sp;
+       caddr_t sfsp;
+       long count, maxcount, error;
+
+       maxcount = uap->bufsize / sizeof(struct statfs);
+       sfsp = (caddr_t)uap->buf;
+       mp = rootfs;
+       count = 0;
+       do {
+               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);
+               }
+               count++;
+               mp = mp->mnt_prev;
+       } while (mp != rootfs);
+       if (sfsp && count > maxcount)
+               *retval = maxcount;
+       else
+               *retval = count;
+       return (0);
+}
+
+/*
+ * Change current working directory to a given file descriptor.
   */
   */
-creat()
+/* ARGSUSED */
+fchdir(p, uap, retval)
+       struct proc *p;
+       struct args {
+               int     fd;
+       } *uap;
+       int *retval;
  {
  {
-       struct a {
+       register struct filedesc *fdp = p->p_fd;
+       register struct vnode *vp;
+       struct file *fp;
+       int 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
+               error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p);
+       VOP_UNLOCK(vp);
+       if (error)
+               return (error);
+       VREF(vp);
+       vrele(fdp->fd_cdir);
+       fdp->fd_cdir = vp;
+       return (0);
+}
+
+/*
+ * Change current working directory (``.'').
+ */
+/* ARGSUSED */
+chdir(p, uap, retval)
+       struct proc *p;
+       struct args {
                 char    *fname;
                 char    *fname;
-               int     fmode;
-       } *uap = (struct a *)u.u_ap;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp;
+       register struct filedesc *fdp = p->p_fd;
+       int error;
+       struct nameidata nd;
  
  
-       copen(FWRITE|FCREAT|FTRUNC, uap->fmode, uap->fname);
+       ndp = &nd;
+       ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
+       ndp->ni_segflg = UIO_USERSPACE;
+       ndp->ni_dirp = uap->fname;
+       if (error = chdirec(ndp, p))
+               return (error);
+       vrele(fdp->fd_cdir);
+       fdp->fd_cdir = ndp->ni_vp;
+       return (0);
  }
  
  /*
  }
  
  /*
- * Common code for open and creat.
+ * Change notion of root (``/'') directory.
+ */
+/* ARGSUSED */
+chroot(p, uap, retval)
+       struct proc *p;
+       struct args {
+               char    *fname;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp;
+       register struct filedesc *fdp = p->p_fd;
+       int error;
+       struct nameidata nd;
+
+       if (error = suser(p->p_ucred, &p->p_acflag))
+               return (error);
+       ndp = &nd;
+       ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
+       ndp->ni_segflg = UIO_USERSPACE;
+       ndp->ni_dirp = uap->fname;
+       if (error = chdirec(ndp, p))
+               return (error);
+       if (fdp->fd_rdir != NULL)
+               vrele(fdp->fd_rdir);
+       fdp->fd_rdir = ndp->ni_vp;
+       return (0);
+}
+
+/*
+ * Common routine for chroot and chdir.
+ */
+chdirec(ndp, p)
+       struct nameidata *ndp;
+       struct proc *p;
+{
+       struct vnode *vp;
+       int error;
+
+       if (error = namei(ndp, p))
+               return (error);
+       vp = ndp->ni_vp;
+       if (vp->v_type != VDIR)
+               error = ENOTDIR;
+       else
+               error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p);
+       VOP_UNLOCK(vp);
+       if (error)
+               vrele(vp);
+       return (error);
+}
+
+/*
+ * Open system call.
   * Check permissions, allocate an open file structure,
   * and call the device open routine if any.
   */
   * Check permissions, allocate an open file structure,
   * and call the device open routine if any.
   */
-copen(mode, arg, fname)
-       register int mode;
-       int arg;
-       caddr_t fname;
+open(p, uap, retval)
+       struct proc *p;
+       register struct args {
+               char    *fname;
+               int     mode;
+               int     crtmode;
+       } *uap;
+       int *retval;
  {
  {
-       register struct inode *ip;
+       struct nameidata *ndp;
+       register struct filedesc *fdp = p->p_fd;
         register struct file *fp;
         register struct file *fp;
-       register struct nameidata *ndp = &u.u_nd;
-       int indx;
-
-       fp = falloc();
-       if (fp == NULL)
-               return;
-       indx = u.u_r.r_val1;
+       register struct vnode *vp;
+       int fmode, cmode;
+       struct file *nfp;
+       int type, indx, error;
+       struct flock lf;
+       struct nameidata nd;
+       extern struct fileops vnops;
+
+       if (error = falloc(p, &nfp, &indx))
+               return (error);
+       fp = nfp;
+       fmode = FFLAGS(uap->mode);
+       cmode = ((uap->crtmode &~ fdp->fd_cmask) & 07777) &~ S_ISVTX;
+       ndp = &nd;
         ndp->ni_segflg = UIO_USERSPACE;
         ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = fname;
-       if (mode&FCREAT) {
-               if (mode & FEXCL)
-                       ndp->ni_nameiop = CREATE;
-               else
-                       ndp->ni_nameiop = CREATE | FOLLOW;
-               ip = namei(ndp);
-               if (ip == NULL) {
-                       if (u.u_error)
-                               goto bad1;
-                       ip = maknode(arg&07777&(~ISVTX), ndp);
-                       if (ip == NULL)
-                               goto bad1;
-                       mode &= ~FTRUNC;
-               } else {
-                       if (mode&FEXCL) {
-                               u.u_error = EEXIST;
-                               goto bad;
-                       }
-                       mode &= ~FCREAT;
+       ndp->ni_dirp = uap->fname;
+       p->p_dupfd = -indx - 1;                 /* XXX check for fdopen */
+       if (error = vn_open(ndp, p, 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);
                 }
                 }
-       } else {
-               ndp->ni_nameiop = LOOKUP | FOLLOW;
-               ip = namei(ndp);
-               if (ip == NULL)
-                       goto bad1;
+               if (error == ERESTART)
+                       error = EINTR;
+               fdp->fd_ofiles[indx] = NULL;
+               return (error);
         }
         }
-       if ((ip->i_mode & IFMT) == IFSOCK) {
-               u.u_error = EOPNOTSUPP;
-               goto bad;
-       }
-       if ((mode&FCREAT) == 0) {
-               if (mode&FREAD)
-                       if (access(ip, IREAD))
-                               goto bad;
-               if (mode&(FWRITE|FTRUNC)) {
-                       if (access(ip, IWRITE))
-                               goto bad;
-                       if ((ip->i_mode&IFMT) == IFDIR) {
-                               u.u_error = EISDIR;
-                               goto bad;
-                       }
+       vp = ndp->ni_vp;
+       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;
         }
         }
-       if (mode&FTRUNC)
-               itrunc(ip, (u_long)0);
-       IUNLOCK(ip);
-       fp->f_flag = mode&FMASK;
-       fp->f_type = DTYPE_INODE;
-       fp->f_ops = &inodeops;
-       fp->f_data = (caddr_t)ip;
-       if (setjmp(&u.u_qsave)) {
-               if (u.u_error == 0)
-                       u.u_error = EINTR;
-               u.u_ofile[indx] = NULL;
-               closef(fp);
-               return;
-       }
-       u.u_error = openi(ip, mode);
-       if (u.u_error == 0)
-               return;
-       ILOCK(ip);
-bad:
-       iput(ip);
-bad1:
-       u.u_ofile[indx] = NULL;
-       fp->f_count--;
+       VOP_UNLOCK(vp);
+       fp->f_type = DTYPE_VNODE;
+       fp->f_ops = &vnops;
+       fp->f_data = (caddr_t)vp;
+       *retval = indx;
+       return (0);
  }
  
  }
  
+#ifdef COMPAT_43
  /*
  /*
- * Mknod system call
+ * Creat system call.
   */
   */
-mknod()
+ocreat(p, uap, retval)
+       struct proc *p;
+       register struct args {
+               char    *fname;
+               int     fmode;
+       } *uap;
+       int *retval;
  {
  {
-       register struct inode *ip;
-       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 *)u.u_ap;
-       register struct nameidata *ndp = &u.u_nd;
-
-       if (!suser())
-               return;
-       ndp->ni_nameiop = CREATE;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp;
+       register struct vnode *vp;
+       struct vattr vattr;
+       int error;
+       struct nameidata nd;
+
+       if (error = suser(p->p_ucred, &p->p_acflag))
+               return (error);
+       ndp = &nd;
+       ndp->ni_nameiop = CREATE | LOCKPARENT;
         ndp->ni_segflg = UIO_USERSPACE;
         ndp->ni_dirp = uap->fname;
         ndp->ni_segflg = UIO_USERSPACE;
         ndp->ni_dirp = uap->fname;
-       ip = namei(ndp);
-       if (ip != NULL) {
-               u.u_error = EEXIST;
+       if (error = namei(ndp, p))
+               return (error);
+       vp = ndp->ni_vp;
+       if (vp != NULL) {
+               error = EEXIST;
                 goto out;
         }
                 goto out;
         }
-       if (u.u_error)
-               return;
-       ip = maknode(uap->fmode, ndp);
-       if (ip == NULL)
-               return;
-       switch (ip->i_mode & IFMT) {
-
-       case IFMT:      /* used by badsect to flag bad sectors */
-       case IFCHR:
-       case IFBLK:
-               if (uap->dev) {
-                       /*
-                        * Want to be able to use this to make badblock
-                        * inodes, so don't truncate the dev number.
-                        */
-                       ip->i_rdev = uap->dev;
-                       ip->i_flag |= IACC|IUPD|ICHG;
-               }
-       }
+       VATTR_NULL(&vattr);
+       switch (uap->fmode & S_IFMT) {
  
  
+       case S_IFMT:    /* used by badsect to flag bad sectors */
+               vattr.va_type = VBAD;
+               break;
+       case S_IFCHR:
+               vattr.va_type = VCHR;
+               break;
+       case S_IFBLK:
+               vattr.va_type = VBLK;
+               break;
+       default:
+               error = EINVAL;
+               goto out;
+       }
+       vattr.va_mode = (uap->fmode & 07777) &~ p->p_fd->fd_cmask;
+       vattr.va_rdev = uap->dev;
  out:
  out:
-       iput(ip);
+       if (!error) {
+               error = VOP_MKNOD(ndp, &vattr, p->p_ucred, p);
+       } else {
+               VOP_ABORTOP(ndp);
+               if (ndp->ni_dvp == vp)
+                       vrele(ndp->ni_dvp);
+               else
+                       vput(ndp->ni_dvp);
+               if (vp)
+                       vrele(vp);
+       }
+       return (error);
  }
  
  /*
  }
  
  /*
- * link system call
+ * Mkfifo system call.
   */
   */
-link()
+/* ARGSUSED */
+mkfifo(p, uap, retval)
+       struct proc *p;
+       register struct args {
+               char    *fname;
+               int     fmode;
+       } *uap;
+       int *retval;
  {
  {
-       register struct inode *ip, *xp;
-       register struct a {
+       register struct nameidata *ndp;
+       struct vattr vattr;
+       int error;
+       struct nameidata nd;
+
+#ifndef FIFO
+       return (EOPNOTSUPP);
+#else
+       ndp = &nd;
+       ndp->ni_nameiop = CREATE | LOCKPARENT;
+       ndp->ni_segflg = UIO_USERSPACE;
+       ndp->ni_dirp = uap->fname;
+       if (error = namei(ndp, p))
+               return (error);
+       if (ndp->ni_vp != NULL) {
+               VOP_ABORTOP(ndp);
+               if (ndp->ni_dvp == ndp->ni_vp)
+                       vrele(ndp->ni_dvp);
+               else
+                       vput(ndp->ni_dvp);
+               vrele(ndp->ni_vp);
+               return (EEXIST);
+       }
+       VATTR_NULL(&vattr);
+       vattr.va_type = VFIFO;
+       vattr.va_mode = (uap->fmode & 07777) &~ p->p_fd->fd_cmask;
+       return (VOP_MKNOD(ndp, &vattr, p->p_ucred, p));
+#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 *)u.u_ap;
-       register struct nameidata *ndp = &u.u_nd;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp;
+       register struct vnode *vp, *xp;
+       int error;
+       struct nameidata nd;
  
  
+       ndp = &nd;
         ndp->ni_nameiop = LOOKUP | FOLLOW;
         ndp->ni_segflg = UIO_USERSPACE;
         ndp->ni_dirp = uap->target;
         ndp->ni_nameiop = LOOKUP | FOLLOW;
         ndp->ni_segflg = UIO_USERSPACE;
         ndp->ni_dirp = uap->target;
-       ip = namei(ndp);        /* well, this routine is doomed anyhow */
-       if (ip == NULL)
-               return;
-       if ((ip->i_mode&IFMT) == IFDIR && !suser()) {
-               iput(ip);
-               return;
-       }
-       ip->i_nlink++;
-       ip->i_flag |= ICHG;
-       iupdat(ip, &time, &time, 1);
-       IUNLOCK(ip);
-       ndp->ni_nameiop = CREATE;
-       ndp->ni_segflg = UIO_USERSPACE;
+       if (error = namei(ndp, p))
+               return (error);
+       vp = ndp->ni_vp;
+       if (vp->v_type == VDIR &&
+           (error = suser(p->p_ucred, &p->p_acflag)))
+               goto out1;
+       ndp->ni_nameiop = CREATE | LOCKPARENT;
         ndp->ni_dirp = (caddr_t)uap->linkname;
         ndp->ni_dirp = (caddr_t)uap->linkname;
-       xp = namei(ndp);
+       if (error = namei(ndp, p))
+               goto out1;
+       xp = ndp->ni_vp;
         if (xp != NULL) {
         if (xp != NULL) {
-               u.u_error = EEXIST;
-               iput(xp);
-               goto out;
-       }
-       if (u.u_error)
-               goto out;
-       if (ndp->ni_pdir->i_dev != ip->i_dev) {
-               iput(ndp->ni_pdir);
-               u.u_error = EXDEV;
+               error = EEXIST;
                 goto out;
         }
                 goto out;
         }
-       u.u_error = direnter(ip, ndp);
+       xp = ndp->ni_dvp;
+       if (vp->v_mount != xp->v_mount)
+               error = EXDEV;
  out:
  out:
-       if (u.u_error) {
-               ip->i_nlink--;
-               ip->i_flag |= ICHG;
+       if (!error) {
+               error = VOP_LINK(vp, ndp, p);
+       } else {
+               VOP_ABORTOP(ndp);
+               if (ndp->ni_dvp == ndp->ni_vp)
+                       vrele(ndp->ni_dvp);
+               else
+                       vput(ndp->ni_dvp);
+               if (ndp->ni_vp)
+                       vrele(ndp->ni_vp);
         }
         }
-       irele(ip);
+out1:
+       vrele(vp);
+       return (error);
  }
  
  /*
  }
  
  /*
- * symlink -- make a symbolic link
+ * Make a symbolic link.
   */
   */
-symlink()
-{
-       register struct a {
+/* ARGSUSED */
+symlink(p, uap, retval)
+       struct proc *p;
+       register struct args {
                 char    *target;
                 char    *linkname;
                 char    *target;
                 char    *linkname;
-       } *uap = (struct a *)u.u_ap;
-       register struct inode *ip;
-       register char *tp;
-       register c, nc;
-       register struct nameidata *ndp = &u.u_nd;
-
-       tp = uap->target;
-       nc = 0;
-       while (c = fubyte(tp)) {
-               if (c < 0) {
-                       u.u_error = EFAULT;
-                       return;
-               }
-               tp++;
-               nc++;
-       }
-       ndp->ni_nameiop = CREATE;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp;
+       struct vattr vattr;
+       char *target;
+       int error;
+       struct nameidata nd;
+
+       ndp = &nd;
         ndp->ni_segflg = UIO_USERSPACE;
         ndp->ni_dirp = uap->linkname;
         ndp->ni_segflg = UIO_USERSPACE;
         ndp->ni_dirp = uap->linkname;
-       ip = namei(ndp);
-       if (ip) {
-               iput(ip);
-               u.u_error = EEXIST;
-               return;
+       MALLOC(target, char *, MAXPATHLEN, M_NAMEI, M_WAITOK);
+       if (error = copyinstr(uap->target, target, MAXPATHLEN, (u_int *)0))
+               goto out;
+       ndp->ni_nameiop = CREATE | LOCKPARENT;
+       if (error = namei(ndp, p))
+               goto out;
+       if (ndp->ni_vp) {
+               VOP_ABORTOP(ndp);
+               if (ndp->ni_dvp == ndp->ni_vp)
+                       vrele(ndp->ni_dvp);
+               else
+                       vput(ndp->ni_dvp);
+               vrele(ndp->ni_vp);
+               error = EEXIST;
+               goto out;
         }
         }
-       if (u.u_error)
-               return;
-       ip = maknode(IFLNK | 0777, ndp);
-       if (ip == NULL)
-               return;
-       u.u_error = rdwri(UIO_WRITE, ip, uap->target, nc, (off_t)0, 0,
-           (int *)0);
-       /* handle u.u_error != 0 */
-       iput(ip);
+       VATTR_NULL(&vattr);
+       vattr.va_mode = 0777 &~ p->p_fd->fd_cmask;
+       error = VOP_SYMLINK(ndp, &vattr, target, p);
+out:
+       FREE(target, M_NAMEI);
+       return (error);
  }
  
  /*
  }
  
  /*
- * Unlink system call.
- * Hard to avoid races here, especially
- * in unlinking directories.
+ * Delete a name from the filesystem.
   */
   */
-unlink()
-{
-       struct a {
+/* ARGSUSED */
+unlink(p, uap, retval)
+       struct proc *p;
+       struct args {
                 char    *fname;
                 char    *fname;
-       } *uap = (struct a *)u.u_ap;
-       register struct inode *ip, *dp;
-       register struct nameidata *ndp = &u.u_nd;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp;
+       register struct vnode *vp;
+       int error;
+       struct nameidata nd;
  
  
-       ndp->ni_nameiop = DELETE | LOCKPARENT;
+       ndp = &nd;
+       ndp->ni_nameiop = DELETE | LOCKPARENT | LOCKLEAF;
         ndp->ni_segflg = UIO_USERSPACE;
         ndp->ni_dirp = uap->fname;
         ndp->ni_segflg = UIO_USERSPACE;
         ndp->ni_dirp = uap->fname;
-       ip = namei(ndp);
-       if (ip == NULL)
-               return;
-       dp = ndp->ni_pdir;
-       if ((ip->i_mode&IFMT) == IFDIR && !suser())
+       if (error = namei(ndp, p))
+               return (error);
+       vp = ndp->ni_vp;
+       if (vp->v_type == VDIR &&
+           (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 (ip->i_dev != dp->i_dev) {
-               u.u_error = EBUSY;
+       if (vp->v_flag & VROOT) {
+               error = EBUSY;
                 goto out;
         }
                 goto out;
         }
-       if (ip->i_flag&ITEXT)
-               xrele(ip);      /* try once to free text */
-       if (dirremove(ndp)) {
-               ip->i_nlink--;
-               ip->i_flag |= ICHG;
-       }
+       (void) vnode_pager_uncache(vp);
  out:
  out:
-       if (dp == ip)
-               irele(ip);
-       else
-               iput(ip);
-       iput(dp);
+       if (!error) {
+               error = VOP_REMOVE(ndp, p);
+       } else {
+               VOP_ABORTOP(ndp);
+               if (ndp->ni_dvp == vp)
+                       vrele(ndp->ni_dvp);
+               else
+                       vput(ndp->ni_dvp);
+               vput(vp);
+       }
+       return (error);
  }
  
  /*
  }
  
  /*
- * Seek system call
+ * Seek system call.
   */
   */
-lseek()
-{
-       register struct file *fp;
-       register struct a {
-               int     fd;
+lseek(p, uap, retval)
+       struct proc *p;
+       register struct args {
+               int     fdes;
                 off_t   off;
                 int     sbase;
                 off_t   off;
                 int     sbase;
-       } *uap = (struct a *)u.u_ap;
-
-       GETF(fp, uap->fd);
-       if (fp->f_type != DTYPE_INODE) {
-               u.u_error = ESPIPE;
-               return;
-       }
+       } *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;
+
+       if ((unsigned)uap->fdes >= fdp->fd_nfiles ||
+           (fp = fdp->fd_ofiles[uap->fdes]) == NULL)
+               return (EBADF);
+       if (fp->f_type != DTYPE_VNODE)
+               return (ESPIPE);
         switch (uap->sbase) {
  
         case L_INCR:
         switch (uap->sbase) {
  
         case L_INCR:
@@ -404,7 +923,10 @@ lseek()
                 break;
  
         case L_XTND:
                 break;
  
         case L_XTND:
-               fp->f_offset = uap->off + ((struct inode *)fp->f_data)->i_size;
+               if (error = VOP_GETATTR((struct vnode *)fp->f_data,
+                   &vattr, cred, p))
+                       return (error);
+               fp->f_offset = uap->off + vattr.va_size;
                 break;
  
         case L_SET:
                 break;
  
         case L_SET:
@@ -412,957 +934,837 @@ lseek()
                 break;
  
         default:
                 break;
  
         default:
-               u.u_error = EINVAL;
-               return;
+               return (EINVAL);
         }
         }
-       u.u_r.r_off = fp->f_offset;
+       *retval = fp->f_offset;
+       return (0);
  }
  
  /*
  }
  
  /*
- * Access system call
+ * Check access permissions.
   */
   */
-saccess()
-{
-       register svuid, svgid;
-       register struct inode *ip;
-       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 *)u.u_ap;
-       register struct nameidata *ndp = &u.u_nd;
-
-       svuid = u.u_uid;
-       svgid = u.u_gid;
-       u.u_uid = u.u_ruid;
-       u.u_gid = u.u_rgid;
-       ndp->ni_nameiop = LOOKUP | FOLLOW;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp;
+       register struct ucred *cred = p->p_ucred;
+       register struct vnode *vp;
+       int error, mode, svuid, svgid;
+       struct nameidata nd;
+
+       ndp = &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;
+       ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
         ndp->ni_segflg = UIO_USERSPACE;
         ndp->ni_dirp = uap->fname;
         ndp->ni_segflg = UIO_USERSPACE;
         ndp->ni_dirp = uap->fname;
-       ip = namei(ndp);
-       if (ip != NULL) {
-               if ((uap->fmode&R_OK) && access(ip, IREAD))
-                       goto done;
-               if ((uap->fmode&W_OK) && access(ip, IWRITE))
-                       goto done;
-               if ((uap->fmode&X_OK) && access(ip, IEXEC))
-                       goto done;
-done:
-               iput(ip);
+       if (error = namei(ndp, p))
+               goto out1;
+       vp = ndp->ni_vp;
+       /*
+        * fmode == 0 means only check for exist
+        */
+       if (uap->fmode) {
+               mode = 0;
+               if (uap->fmode & R_OK)
+                       mode |= VREAD;
+               if (uap->fmode & W_OK)
+                       mode |= VWRITE;
+               if (uap->fmode & X_OK)
+                       mode |= VEXEC;
+               if ((mode & VWRITE) == 0 || (error = vn_writechk(vp)) == 0)
+                       error = VOP_ACCESS(vp, mode, cred, p);
         }
         }
-       u.u_uid = svuid;
-       u.u_gid = svgid;
+       vput(vp);
+out1:
+       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()
+/* ARGSUSED */
+stat(p, uap, retval)
+       struct proc *p;
+       register struct args {
+               char    *fname;
+               struct stat *ub;
+       } *uap;
+       int *retval;
  {
  {
+       register struct nameidata *ndp;
+       struct stat sb;
+       int error;
+       struct nameidata nd;
  
  
-       stat1(FOLLOW);
+       ndp = &nd;
+       ndp->ni_nameiop = LOOKUP | LOCKLEAF | FOLLOW;
+       ndp->ni_segflg = UIO_USERSPACE;
+       ndp->ni_dirp = uap->fname;
+       if (error = namei(ndp, p))
+               return (error);
+       error = vn_stat(ndp->ni_vp, &sb, p);
+       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()
-{
-
-       stat1(NOFOLLOW);
-}
-
-stat1(follow)
-       int follow;
-{
-       register struct inode *ip;
-       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 *)u.u_ap;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp;
         struct stat sb;
         struct stat sb;
-       register struct nameidata *ndp = &u.u_nd;
+       int error;
+       struct nameidata nd;
  
  
-       ndp->ni_nameiop = LOOKUP | follow;
+       ndp = &nd;
+       ndp->ni_nameiop = LOOKUP | LOCKLEAF | NOFOLLOW;
         ndp->ni_segflg = UIO_USERSPACE;
         ndp->ni_dirp = uap->fname;
         ndp->ni_segflg = UIO_USERSPACE;
         ndp->ni_dirp = uap->fname;
-       ip = namei(ndp);
-       if (ip == NULL)
-               return;
-       (void) ino_stat(ip, &sb);
-       iput(ip);
-       u.u_error = copyout((caddr_t)&sb, (caddr_t)uap->ub, sizeof (sb));
+       if (error = namei(ndp, p))
+               return (error);
+       error = vn_stat(ndp->ni_vp, &sb, p);
+       vput(ndp->ni_vp);
+       if (error)
+               return (error);
+       error = copyout((caddr_t)&sb, (caddr_t)uap->ub, sizeof (sb));
+       return (error);
  }
  
  /*
  }
  
  /*
- * Return target name of a symbolic link
+ * Return target name of a symbolic link.
   */
   */
-readlink()
-{
-       register struct inode *ip;
-       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 *)u.u_ap;
-       register struct nameidata *ndp = &u.u_nd;
-       int resid;
-
-       ndp->ni_nameiop = LOOKUP;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp;
+       register struct vnode *vp;
+       struct iovec aiov;
+       struct uio auio;
+       int error;
+       struct nameidata nd;
+
+       ndp = &nd;
+       ndp->ni_nameiop = LOOKUP | LOCKLEAF;
         ndp->ni_segflg = UIO_USERSPACE;
         ndp->ni_dirp = uap->name;
         ndp->ni_segflg = UIO_USERSPACE;
         ndp->ni_dirp = uap->name;
-       ip = namei(ndp);
-       if (ip == NULL)
-               return;
-       if ((ip->i_mode&IFMT) != IFLNK) {
-               u.u_error = EINVAL;
+       if (error = namei(ndp, p))
+               return (error);
+       vp = ndp->ni_vp;
+       if (vp->v_type != VLNK) {
+               error = EINVAL;
                 goto out;
         }
                 goto out;
         }
-       u.u_error = rdwri(UIO_READ, ip, uap->buf, uap->count, (off_t)0, 0,
-           &resid);
+       aiov.iov_base = uap->buf;
+       aiov.iov_len = uap->count;
+       auio.uio_iov = &aiov;
+       auio.uio_iovcnt = 1;
+       auio.uio_offset = 0;
+       auio.uio_rw = UIO_READ;
+       auio.uio_segflg = UIO_USERSPACE;
+       auio.uio_procp = p;
+       auio.uio_resid = uap->count;
+       error = VOP_READLINK(vp, &auio, p->p_ucred);
  out:
  out:
-       iput(ip);
-       u.u_r.r_val1 = uap->count - resid;
+       vput(vp);
+       *retval = uap->count - auio.uio_resid;
+       return (error);
  }
  
  /*
  }
  
  /*
- * Change mode of a file given path name.
+ * Change flags of a file given path name.
   */
   */
-chmod()
-{
-       struct inode *ip;
-       struct a {
+/* ARGSUSED */
+chflags(p, uap, retval)
+       struct proc *p;
+       register struct args {
                 char    *fname;
                 char    *fname;
-               int     fmode;
-       } *uap = (struct a *)u.u_ap;
+               int     flags;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp;
+       register struct vnode *vp;
+       struct vattr vattr;
+       int error;
+       struct nameidata nd;
  
  
-       if ((ip = owner(uap->fname, FOLLOW)) == NULL)
-               return;
-       u.u_error = chmod1(ip, uap->fmode);
-       iput(ip);
+       ndp = &nd;
+       ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
+       ndp->ni_segflg = UIO_USERSPACE;
+       ndp->ni_dirp = uap->fname;
+       if (error = namei(ndp, p))
+               return (error);
+       vp = ndp->ni_vp;
+       if (vp->v_mount->mnt_flag & MNT_RDONLY) {
+               error = EROFS;
+               goto out;
+       }
+       VATTR_NULL(&vattr);
+       vattr.va_flags = uap->flags;
+       error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
+out:
+       vput(vp);
+       return (error);
  }
  
  /*
  }
  
  /*
- * Change mode of a file given a file descriptor.
+ * Change flags of a file given a file descriptor.
   */
   */
-fchmod()
-{
-       struct a {
+/* ARGSUSED */
+fchflags(p, uap, retval)
+       struct proc *p;
+       register struct args {
                 int     fd;
                 int     fd;
+               int     flags;
+       } *uap;
+       int *retval;
+{
+       struct vattr vattr;
+       struct vnode *vp;
+       struct file *fp;
+       int error;
+
+       if (error = getvnode(p->p_fd, uap->fd, &fp))
+               return (error);
+       vp = (struct vnode *)fp->f_data;
+       VOP_LOCK(vp);
+       if (vp->v_mount->mnt_flag & MNT_RDONLY) {
+               error = EROFS;
+               goto out;
+       }
+       VATTR_NULL(&vattr);
+       vattr.va_flags = uap->flags;
+       error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
+out:
+       VOP_UNLOCK(vp);
+       return (error);
+}
+
+/*
+ * Change mode of a file given path name.
+ */
+/* ARGSUSED */
+chmod(p, uap, retval)
+       struct proc *p;
+       register struct args {
+               char    *fname;
                 int     fmode;
                 int     fmode;
-       } *uap = (struct a *)u.u_ap;
-       register struct inode *ip;
-       register struct file *fp;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp;
+       register struct vnode *vp;
+       struct vattr vattr;
+       int error;
+       struct nameidata nd;
  
  
-       fp = getinode(uap->fd);
-       if (fp == NULL)
-               return;
-       ip = (struct inode *)fp->f_data;
-       if (u.u_uid != ip->i_uid && !suser())
-               return;
-       ILOCK(ip);
-       u.u_error = chmod1(ip, uap->fmode);
-       IUNLOCK(ip);
+       ndp = &nd;
+       ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
+       ndp->ni_segflg = UIO_USERSPACE;
+       ndp->ni_dirp = uap->fname;
+       if (error = namei(ndp, p))
+               return (error);
+       vp = ndp->ni_vp;
+       if (vp->v_mount->mnt_flag & MNT_RDONLY) {
+               error = EROFS;
+               goto out;
+       }
+       VATTR_NULL(&vattr);
+       vattr.va_mode = uap->fmode & 07777;
+       error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
+out:
+       vput(vp);
+       return (error);
  }
  
  /*
  }
  
  /*
- * Change the mode on a file.
- * Inode must be locked before calling.
+ * Change mode of a file given a file descriptor.
   */
   */
-chmod1(ip, mode)
-       register struct inode *ip;
-       register int mode;
+/* ARGSUSED */
+fchmod(p, uap, retval)
+       struct proc *p;
+       register struct args {
+               int     fd;
+               int     fmode;
+       } *uap;
+       int *retval;
  {
  {
-
-       if (ip->i_fs->fs_ronly)
-               return (EROFS);
-       ip->i_mode &= ~07777;
-       if (u.u_uid) {
-               if ((ip->i_mode & IFMT) != IFDIR)
-                       mode &= ~ISVTX;
-               if (!groupmember(ip->i_gid))
-                       mode &= ~ISGID;
+       struct vattr vattr;
+       struct vnode *vp;
+       struct file *fp;
+       int error;
+
+       if (error = getvnode(p->p_fd, uap->fd, &fp))
+               return (error);
+       vp = (struct vnode *)fp->f_data;
+       VOP_LOCK(vp);
+       if (vp->v_mount->mnt_flag & MNT_RDONLY) {
+               error = EROFS;
+               goto out;
         }
         }
-       ip->i_mode |= mode&07777;
-       ip->i_flag |= ICHG;
-       if (ip->i_flag&ITEXT && (ip->i_mode&ISVTX)==0)
-               xrele(ip);
-       return (0);
+       VATTR_NULL(&vattr);
+       vattr.va_mode = uap->fmode & 07777;
+       error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
+out:
+       VOP_UNLOCK(vp);
+       return (error);
  }
  
  /*
   * Set ownership given a path name.
   */
  }
  
  /*
   * Set ownership given a path name.
   */
-chown()
-{
-       struct inode *ip;
-       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 *)u.u_ap;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp;
+       register struct vnode *vp;
+       struct vattr vattr;
+       int error;
+       struct nameidata nd;
  
  
-       if ((ip = owner(uap->fname, NOFOLLOW)) == NULL)
-               return;
-       u.u_error = chown1(ip, uap->uid, uap->gid);
-       iput(ip);
+       ndp = &nd;
+       ndp->ni_nameiop = LOOKUP | NOFOLLOW | LOCKLEAF;
+       ndp->ni_segflg = UIO_USERSPACE;
+       ndp->ni_dirp = uap->fname;
+       if (error = namei(ndp, p))
+               return (error);
+       vp = ndp->ni_vp;
+       if (vp->v_mount->mnt_flag & MNT_RDONLY) {
+               error = EROFS;
+               goto out;
+       }
+       VATTR_NULL(&vattr);
+       vattr.va_uid = uap->uid;
+       vattr.va_gid = uap->gid;
+       error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
+out:
+       vput(vp);
+       return (error);
  }
  
  /*
   * Set ownership given a file descriptor.
   */
  }
  
  /*
   * Set ownership given a file descriptor.
   */
-fchown()
-{
-       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 *)u.u_ap;
-       register struct inode *ip;
-       register struct file *fp;
-
-       fp = getinode(uap->fd);
-       if (fp == NULL)
-               return;
-       ip = (struct inode *)fp->f_data;
-       ILOCK(ip);
-       u.u_error = chown1(ip, uap->uid, uap->gid);
-       IUNLOCK(ip);
+       } *uap;
+       int *retval;
+{
+       struct vattr vattr;
+       struct vnode *vp;
+       struct file *fp;
+       int error;
+
+       if (error = getvnode(p->p_fd, uap->fd, &fp))
+               return (error);
+       vp = (struct vnode *)fp->f_data;
+       VOP_LOCK(vp);
+       if (vp->v_mount->mnt_flag & MNT_RDONLY) {
+               error = EROFS;
+               goto out;
+       }
+       VATTR_NULL(&vattr);
+       vattr.va_uid = uap->uid;
+       vattr.va_gid = uap->gid;
+       error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
+out:
+       VOP_UNLOCK(vp);
+       return (error);
  }
  
  /*
  }
  
  /*
- * Perform chown operation on inode ip;
- * inode must be locked prior to call.
+ * Set the access and modification times of a file.
   */
   */
-chown1(ip, uid, gid)
-       register struct inode *ip;
-       int uid, gid;
-{
-#ifdef QUOTA
-       register long change;
-#endif
-
-       if (ip->i_fs->fs_ronly)
-               return (EROFS);
-       if (uid == -1)
-               uid = ip->i_uid;
-       if (gid == -1)
-               gid = ip->i_gid;
-       if (uid != ip->i_uid && !suser())
-               return (u.u_error);
-       if (gid != ip->i_gid && !groupmember((gid_t)gid) && !suser())
-               return (u.u_error);
-#ifdef QUOTA
-       if (ip->i_uid == uid)           /* this just speeds things a little */
-               change = 0;
-       else
-               change = ip->i_blocks;
-       (void) chkdq(ip, -change, 1);
-       (void) chkiq(ip->i_dev, ip, ip->i_uid, 1);
-       dqrele(ip->i_dquot);
-#endif
-       ip->i_uid = uid;
-       ip->i_gid = gid;
-       ip->i_flag |= ICHG;
-       if (u.u_ruid != 0)
-               ip->i_mode &= ~(ISUID|ISGID);
-#ifdef QUOTA
-       ip->i_dquot = inoquota(ip);
-       (void) chkdq(ip, change, 1);
-       (void) chkiq(ip->i_dev, (struct inode *)NULL, (uid_t)uid, 1);
-       return (u.u_error);             /* should == 0 ALWAYS !! */
-#else
-       return (0);
-#endif
-}
-
-utimes()
-{
-       register struct a {
+/* ARGSUSED */
+utimes(p, uap, retval)
+       struct proc *p;
+       register struct args {
                 char    *fname;
                 struct  timeval *tptr;
                 char    *fname;
                 struct  timeval *tptr;
-       } *uap = (struct a *)u.u_ap;
-       register struct inode *ip;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp;
+       register struct vnode *vp;
         struct timeval tv[2];
         struct timeval tv[2];
-
-       if ((ip = owner(uap->fname, FOLLOW)) == NULL)
-               return;
-       if (ip->i_fs->fs_ronly) {
-               u.u_error = EROFS;
-               iput(ip);
-               return;
-       }
-       u.u_error = copyin((caddr_t)uap->tptr, (caddr_t)tv, sizeof (tv));
-       if (u.u_error == 0) {
-               ip->i_flag |= IACC|IUPD|ICHG;
-               iupdat(ip, &tv[0], &tv[1], 0);
+       struct vattr vattr;
+       int error;
+       struct nameidata nd;
+
+       if (error = copyin((caddr_t)uap->tptr, (caddr_t)tv, sizeof (tv)))
+               return (error);
+       ndp = &nd;
+       ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
+       ndp->ni_segflg = UIO_USERSPACE;
+       ndp->ni_dirp = uap->fname;
+       if (error = namei(ndp, p))
+               return (error);
+       vp = ndp->ni_vp;
+       if (vp->v_mount->mnt_flag & MNT_RDONLY) {
+               error = EROFS;
+               goto out;
         }
         }
-       iput(ip);
-}
-
-/*
- * Flush any pending I/O.
- */
-sync()
-{
-
-       update();
+       VATTR_NULL(&vattr);
+       vattr.va_atime = tv[0];
+       vattr.va_mtime = tv[1];
+       error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
+out:
+       vput(vp);
+       return (error);
  }
  
  /*
   * Truncate a file given its path name.
   */
  }
  
  /*
   * Truncate a file given its path name.
   */
-truncate()
-{
-       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 *)u.u_ap;
-       struct inode *ip;
-       register struct nameidata *ndp = &u.u_nd;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp;
+       register struct vnode *vp;
+       struct vattr vattr;
+       int error;
+       struct nameidata nd;
  
  
-       ndp->ni_nameiop = LOOKUP | FOLLOW;
+       ndp = &nd;
+       ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
         ndp->ni_segflg = UIO_USERSPACE;
         ndp->ni_dirp = uap->fname;
         ndp->ni_segflg = UIO_USERSPACE;
         ndp->ni_dirp = uap->fname;
-       ip = namei(ndp);
-       if (ip == NULL)
-               return;
-       if (access(ip, IWRITE))
-               goto bad;
-       if ((ip->i_mode&IFMT) == IFDIR) {
-               u.u_error = EISDIR;
-               goto bad;
+       if (error = namei(ndp, p))
+               return (error);
+       vp = ndp->ni_vp;
+       if (vp->v_type == VDIR) {
+               error = EISDIR;
+               goto out;
         }
         }
-       itrunc(ip, (u_long)uap->length);
-bad:
-       iput(ip);
+       if ((error = vn_writechk(vp)) ||
+           (error = VOP_ACCESS(vp, VWRITE, p->p_ucred, p)))
+               goto out;
+       VATTR_NULL(&vattr);
+       vattr.va_size = uap->length;
+       error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
+out:
+       vput(vp);
+       return (error);
  }
  
  /*
   * Truncate a file given a file descriptor.
   */
  }
  
  /*
   * Truncate a file given a file descriptor.
   */
-ftruncate()
-{
-       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 *)u.u_ap;
-       struct inode *ip;
+       } *uap;
+       int *retval;
+{
+       struct vattr vattr;
+       struct vnode *vp;
         struct file *fp;
         struct file *fp;
-
-       fp = getinode(uap->fd);
-       if (fp == NULL)
-               return;
-       if ((fp->f_flag&FWRITE) == 0) {
-               u.u_error = EINVAL;
-               return;
+       int error;
+
+       if (error = getvnode(p->p_fd, uap->fd, &fp))
+               return (error);
+       if ((fp->f_flag & FWRITE) == 0)
+               return (EINVAL);
+       vp = (struct vnode *)fp->f_data;
+       VOP_LOCK(vp);
+       if (vp->v_type == VDIR) {
+               error = EISDIR;
+               goto out;
         }
         }
-       ip = (struct inode *)fp->f_data;
-       ILOCK(ip);
-       itrunc(ip, (u_long)uap->length);
-       IUNLOCK(ip);
+       if (error = vn_writechk(vp))
+               goto out;
+       VATTR_NULL(&vattr);
+       vattr.va_size = uap->length;
+       error = VOP_SETATTR(vp, &vattr, fp->f_cred, p);
+out:
+       VOP_UNLOCK(vp);
+       return (error);
  }
  
  /*
   * Synch an open file.
   */
  }
  
  /*
   * Synch an open file.
   */
-fsync()
-{
-       struct a {
+/* ARGSUSED */
+fsync(p, uap, retval)
+       struct proc *p;
+       struct args {
                 int     fd;
                 int     fd;
-       } *uap = (struct a *)u.u_ap;
-       struct inode *ip;
+       } *uap;
+       int *retval;
+{
+       register struct vnode *vp;
         struct file *fp;
         struct file *fp;
-
-       fp = getinode(uap->fd);
-       if (fp == NULL)
-               return;
-       ip = (struct inode *)fp->f_data;
-       ILOCK(ip);
-       syncip(ip);
-       IUNLOCK(ip);
+       int 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);
  }
  
  /*
   * Rename system call.
  }
  
  /*
   * Rename system call.
- *     rename("foo", "bar");
- * is essentially
- *     unlink("bar");
- *     link("foo", "bar");
- *     unlink("foo");
- * but ``atomically''.  Can't do full commit without saving state in the
- * inode on disk which isn't feasible at this time.  Best we can do is
- * always guarantee the target exists.
- *
- * Basic algorithm is:
- *
- * 1) Bump link count on source while we're linking it to the
- *    target.  This also insure the inode won't be deleted out
- *    from underneath us while we work (it may be truncated by
- *    a concurrent `trunc' or `open' for creation).
- * 2) Link source to destination.  If destination already exists,
- *    delete it first.
- * 3) Unlink source reference to inode if still around. If a
- *    directory was moved and the parent of the destination
- *    is different from the source, patch the ".." entry in the
- *    directory.
   *
   * 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()
-{
-       struct a {
+/* ARGSUSED */
+rename(p, uap, retval)
+       struct proc *p;
+       register struct args {
                 char    *from;
                 char    *to;
                 char    *from;
                 char    *to;
-       } *uap = (struct a *)u.u_ap;
-       register struct inode *ip, *xp, *dp;
-       struct dirtemplate dirbuf;
-       int doingdirectory = 0, oldparent = 0, newparent = 0;
-       register struct nameidata *ndp = &u.u_nd;
-       int error = 0;
-
-       ndp->ni_nameiop = DELETE | LOCKPARENT;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->from;
-       ip = namei(ndp);
-       if (ip == NULL)
-               return;
-       dp = ndp->ni_pdir;
-       if ((ip->i_mode&IFMT) == IFDIR) {
-               register struct direct *d;
-
-               d = &ndp->ni_dent;
-               /*
-                * Avoid ".", "..", and aliases of "." for obvious reasons.
-                */
-               if ((d->d_namlen == 1 && d->d_name[0] == '.') ||
-                   (d->d_namlen == 2 && bcmp(d->d_name, "..", 2) == 0) ||
-                   (dp == ip) || (ip->i_flag & IRENAME)) {
-                       iput(dp);
-                       if (dp == ip)
-                               irele(ip);
-                       else
-                               iput(ip);
-                       u.u_error = EINVAL;
-                       return;
-               }
-               ip->i_flag |= IRENAME;
-               oldparent = dp->i_number;
-               doingdirectory++;
-       }
-       iput(dp);
-
-       /*
-        * 1) Bump link count while we're moving stuff
-        *    around.  If we crash somewhere before
-        *    completing our work, the link count
-        *    may be wrong, but correctable.
-        */
-       ip->i_nlink++;
-       ip->i_flag |= ICHG;
-       iupdat(ip, &time, &time, 1);
-       IUNLOCK(ip);
-
-       /*
-        * When the target exists, both the directory
-        * and target inodes are returned locked.
-        */
-       ndp->ni_nameiop = CREATE | LOCKPARENT | NOCACHE;
-       ndp->ni_dirp = (caddr_t)uap->to;
-       xp = namei(ndp);
-       if (u.u_error) {
-               error = u.u_error;
-               goto out;
-       }
-       dp = ndp->ni_pdir;
-       /*
-        * If ".." must be changed (ie the directory gets a new
-        * parent) then the source directory must not be in the
-        * directory heirarchy above the target, as this would
-        * orphan everything below the source directory. Also
-        * the user must have write permission in the source so
-        * as to be able to change "..". We must repeat the call 
-        * to namei, as the parent directory is unlocked by the
-        * call to checkpath().
-        */
-       if (oldparent != dp->i_number)
-               newparent = dp->i_number;
-       if (doingdirectory && newparent) {
-               if (access(ip, IWRITE))
-                       goto bad;
-               do {
-                       dp = ndp->ni_pdir;
-                       if (xp != NULL)
-                               iput(xp);
-                       u.u_error = checkpath(ip, dp);
-                       if (u.u_error)
-                               goto out;
-                       xp = namei(ndp);
-                       if (u.u_error) {
-                               error = u.u_error;
-                               goto out;
-                       }
-               } while (dp != ndp->ni_pdir);
+       } *uap;
+       int *retval;
+{
+       register struct vnode *tvp, *fvp, *tdvp;
+       struct nameidata fromnd, tond;
+       int error;
+
+       fromnd.ni_nameiop = DELETE | WANTPARENT | SAVESTART;
+       fromnd.ni_segflg = UIO_USERSPACE;
+       fromnd.ni_dirp = uap->from;
+       if (error = namei(&fromnd, p))
+               return (error);
+       fvp = fromnd.ni_vp;
+       tond.ni_nameiop = RENAME | LOCKPARENT | LOCKLEAF | NOCACHE | SAVESTART;
+       tond.ni_segflg = UIO_USERSPACE;
+       tond.ni_dirp = uap->to;
+       if (error = namei(&tond, p)) {
+               VOP_ABORTOP(&fromnd);
+               vrele(fromnd.ni_dvp);
+               vrele(fvp);
+               goto out1;
         }
         }
-       /*
-        * 2) If target doesn't exist, link the target
-        *    to the source and unlink the source. 
-        *    Otherwise, rewrite the target directory
-        *    entry to reference the source inode and
-        *    expunge the original entry's existence.
-        */
-       if (xp == NULL) {
-               if (dp->i_dev != ip->i_dev) {
-                       error = EXDEV;
-                       goto bad;
-               }
-               /*
-                * Account for ".." in new directory.
-                * When source and destination have the same
-                * parent we don't fool with the link count.
-                */
-               if (doingdirectory && newparent) {
-                       dp->i_nlink++;
-                       dp->i_flag |= ICHG;
-                       iupdat(dp, &time, &time, 1);
-               }
-               error = direnter(ip, ndp);
-               if (error)
+       tdvp = tond.ni_dvp;
+       tvp = tond.ni_vp;
+       if (tvp != NULL) {
+               if (fvp->v_type == VDIR && tvp->v_type != VDIR) {
+                       error = ENOTDIR;
                         goto out;
                         goto out;
-       } else {
-               if (xp->i_dev != dp->i_dev || xp->i_dev != ip->i_dev) {
-                       error = EXDEV;
-                       goto bad;
-               }
-               /*
-                * Short circuit rename(foo, foo).
-                */
-               if (xp->i_number == ip->i_number)
-                       goto bad;
-               /*
-                * If the parent directory is "sticky", then the user must
-                * own the parent directory, or the destination of the rename,
-                * otherwise the destination may not be changed (except by
-                * root). This implements append-only directories.
-                */
-               if ((dp->i_mode & ISVTX) && u.u_uid != 0 &&
-                   u.u_uid != dp->i_uid && xp->i_uid != u.u_uid) {
-                       error = EPERM;
-                       goto bad;
-               }
-               /*
-                * Target must be empty if a directory
-                * and have no links to it.
-                * Also, insure source and target are
-                * compatible (both directories, or both
-                * not directories).
-                */
-               if ((xp->i_mode&IFMT) == IFDIR) {
-                       if (!dirempty(xp, dp->i_number) || xp->i_nlink > 2) {
-                               error = ENOTEMPTY;
-                               goto bad;
-                       }
-                       if (!doingdirectory) {
-                               error = ENOTDIR;
-                               goto bad;
-                       }
-                       cacheinval(dp);
-               } else if (doingdirectory) {
+               } else if (fvp->v_type != VDIR && tvp->v_type == VDIR) {
                         error = EISDIR;
                         error = EISDIR;
-                       goto bad;
-               }
-               dirrewrite(dp, ip, ndp);
-               if (u.u_error) {
-                       error = u.u_error;
-                       goto bad1;
-               }
-               /*
-                * Adjust the link count of the target to
-                * reflect the dirrewrite above.  If this is
-                * a directory it is empty and there are
-                * no links to it, so we can squash the inode and
-                * any space associated with it.  We disallowed
-                * renaming over top of a directory with links to
-                * it above, as the remaining link would point to
-                * a directory without "." or ".." entries.
-                */
-               xp->i_nlink--;
-               if (doingdirectory) {
-                       if (--xp->i_nlink != 0)
-                               panic("rename: linked directory");
-                       itrunc(xp, (u_long)0);
-               }
-               xp->i_flag |= ICHG;
-               iput(xp);
-               xp = NULL;
-       }
-
-       /*
-        * 3) Unlink the source.
-        */
-       ndp->ni_nameiop = DELETE | LOCKPARENT;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->from;
-       xp = namei(ndp);
-       if (xp != NULL)
-               dp = ndp->ni_pdir;
-       else
-               dp = NULL;
-       /*
-        * Insure that the directory entry still exists and has not
-        * changed while the new name has been entered. If the source is
-        * a file then the entry may have been unlinked or renamed. In
-        * either case there is no further work to be done. If the source
-        * is a directory then it cannot have been rmdir'ed; its link
-        * count of three would cause a rmdir to fail with ENOTEMPTY.
-        * The IRENAME flag insures that it cannot be moved by another
-        * rename.
-        */
-       if (xp != ip) {
-               if (doingdirectory)
-                       panic("rename: lost dir entry");
-       } else {
-               /*
-                * If the source is a directory with a
-                * new parent, the link count of the old
-                * parent directory must be decremented
-                * and ".." set to point to the new parent.
-                */
-               if (doingdirectory && newparent) {
-                       dp->i_nlink--;
-                       dp->i_flag |= ICHG;
-                       error = rdwri(UIO_READ, xp, (caddr_t)&dirbuf,
-                               sizeof (struct dirtemplate), (off_t)0, 1,
-                               (int *)0);
-                       if (error == 0) {
-                               if (dirbuf.dotdot_namlen != 2 ||
-                                   dirbuf.dotdot_name[0] != '.' ||
-                                   dirbuf.dotdot_name[1] != '.') {
-                                       printf("rename: mangled dir\n");
-                               } else {
-                                       dirbuf.dotdot_ino = newparent;
-                                       (void) rdwri(UIO_WRITE, xp,
-                                           (caddr_t)&dirbuf,
-                                           sizeof (struct dirtemplate),
-                                           (off_t)0, 1, (int *)0);
-                                       cacheinval(dp);
-                               }
-                       }
+                       goto out;
                 }
                 }
-               if (dirremove(ndp)) {
-                       xp->i_nlink--;
-                       xp->i_flag |= ICHG;
+               if (fvp->v_mount != tvp->v_mount) {
+                       error = EXDEV;
+                       goto out;
                 }
                 }
-               xp->i_flag &= ~IRENAME;
-               if (error == 0)         /* XXX conservative */
-                       error = u.u_error;
         }
         }
-       if (dp)
-               iput(dp);
-       if (xp)
-               iput(xp);
-       irele(ip);
-       if (error)
-               u.u_error = error;
-       return;
-
-bad:
-       iput(dp);
-bad1:
-       if (xp)
-               iput(xp);
-out:
-       ip->i_nlink--;
-       ip->i_flag |= ICHG;
-       irele(ip);
-       if (error)
-               u.u_error = error;
-}
-
-/*
- * Make a new file.
- */
-struct inode *
-maknode(mode, ndp)
-       int mode;
-       register struct nameidata *ndp;
-{
-       register struct inode *ip;
-       register struct inode *pdir = ndp->ni_pdir;
-       ino_t ipref;
-
-       if ((mode & IFMT) == IFDIR)
-               ipref = dirpref(pdir->i_fs);
-       else
-               ipref = pdir->i_number;
-       ip = ialloc(pdir, ipref, mode);
-       if (ip == NULL) {
-               iput(pdir);
-               return (NULL);
+       if (fvp->v_mount != tdvp->v_mount) {
+               error = EXDEV;
+               goto out;
         }
         }
-#ifdef QUOTA
-       if (ip->i_dquot != NODQUOT)
-               panic("maknode: dquot");
-#endif
-       ip->i_flag |= IACC|IUPD|ICHG;
-       if ((mode & IFMT) == 0)
-               mode |= IFREG;
-       ip->i_mode = mode & ~u.u_cmask;
-       ip->i_nlink = 1;
-       ip->i_uid = u.u_uid;
-       ip->i_gid = pdir->i_gid;
-       if (ip->i_mode & ISGID && !groupmember(ip->i_gid))
-               ip->i_mode &= ~ISGID;
-#ifdef QUOTA
-       ip->i_dquot = inoquota(ip);
-#endif
-
+       if (fvp == tdvp)
+               error = EINVAL;
         /*
         /*
-        * Make sure inode goes to disk before directory entry.
+        * 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.
          */
          */
-       iupdat(ip, &time, &time, 1);
-       u.u_error = direnter(ip, ndp);
-       if (u.u_error) {
-               /*
-                * Write error occurred trying to update directory
-                * so must deallocate the inode.
-                */
-               ip->i_nlink = 0;
-               ip->i_flag |= ICHG;
-               iput(ip);
-               return (NULL);
+       if (fvp == tvp && fromnd.ni_dvp == tdvp &&
+           fromnd.ni_namelen == tond.ni_namelen &&
+           !bcmp(fromnd.ni_ptr, tond.ni_ptr, fromnd.ni_namelen))
+               error = -1;
+out:
+       if (!error) {
+               error = VOP_RENAME(&fromnd, &tond, p);
+       } else {
+               VOP_ABORTOP(&tond);
+               if (tdvp == tvp)
+                       vrele(tdvp);
+               else
+                       vput(tdvp);
+               if (tvp)
+                       vput(tvp);
+               VOP_ABORTOP(&fromnd);
+               vrele(fromnd.ni_dvp);
+               vrele(fvp);
         }
         }
-       return (ip);
+       p->p_spare[1]--;
+       vrele(tond.ni_startdir);
+       FREE(tond.ni_pnbuf, M_NAMEI);
+out1:
+       p->p_spare[1]--;
+       vrele(fromnd.ni_startdir);
+       FREE(fromnd.ni_pnbuf, M_NAMEI);
+       if (error == -1)
+               return (0);
+       return (error);
  }
  
  /*
  }
  
  /*
- * A virgin directory (no blushing please).
+ * Mkdir system call.
   */
   */
-struct dirtemplate mastertemplate = {
-       0, 12, 1, ".",
-       0, DIRBLKSIZ - 12, 2, ".."
-};
-
-/*
- * Mkdir system call
- */
-mkdir()
-{
-       struct a {
+/* ARGSUSED */
+mkdir(p, uap, retval)
+       struct proc *p;
+       register struct args {
                 char    *name;
                 int     dmode;
                 char    *name;
                 int     dmode;
-       } *uap = (struct a *)u.u_ap;
-       register struct inode *ip, *dp;
-       struct dirtemplate dirtemplate;
-       register struct nameidata *ndp = &u.u_nd;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp;
+       register struct vnode *vp;
+       struct vattr vattr;
+       int error;
+       struct nameidata nd;
  
  
-       ndp->ni_nameiop = CREATE;
+       ndp = &nd;
+       ndp->ni_nameiop = CREATE | LOCKPARENT;
         ndp->ni_segflg = UIO_USERSPACE;
         ndp->ni_dirp = uap->name;
         ndp->ni_segflg = UIO_USERSPACE;
         ndp->ni_dirp = uap->name;
-       ip = namei(ndp);
-       if (u.u_error)
-               return;
-       if (ip != NULL) {
-               iput(ip);
-               u.u_error = EEXIST;
-               return;
-       }
-       dp = ndp->ni_pdir;
-       uap->dmode &= 0777;
-       uap->dmode |= IFDIR;
-       /*
-        * Must simulate part of maknode here
-        * in order to acquire the inode, but
-        * not have it entered in the parent
-        * directory.  The entry is made later
-        * after writing "." and ".." entries out.
-        */
-       ip = ialloc(dp, dirpref(dp->i_fs), uap->dmode);
-       if (ip == NULL) {
-               iput(dp);
-               return;
-       }
-#ifdef QUOTA
-       if (ip->i_dquot != NODQUOT)
-               panic("mkdir: dquot");
-#endif
-       ip->i_flag |= IACC|IUPD|ICHG;
-       ip->i_mode = uap->dmode & ~u.u_cmask;
-       ip->i_nlink = 2;
-       ip->i_uid = u.u_uid;
-       ip->i_gid = dp->i_gid;
-#ifdef QUOTA
-       ip->i_dquot = inoquota(ip);
-#endif
-       iupdat(ip, &time, &time, 1);
-
-       /*
-        * Bump link count in parent directory
-        * to reflect work done below.  Should
-        * be done before reference is created
-        * so reparation is possible if we crash.
-        */
-       dp->i_nlink++;
-       dp->i_flag |= ICHG;
-       iupdat(dp, &time, &time, 1);
-
-       /*
-        * Initialize directory with "."
-        * and ".." from static template.
-        */
-       dirtemplate = mastertemplate;
-       dirtemplate.dot_ino = ip->i_number;
-       dirtemplate.dotdot_ino = dp->i_number;
-       u.u_error = rdwri(UIO_WRITE, ip, (caddr_t)&dirtemplate,
-               sizeof (dirtemplate), (off_t)0, 1, (int *)0);
-       if (u.u_error) {
-               dp->i_nlink--;
-               dp->i_flag |= ICHG;
-               goto bad;
-       }
-       if (DIRBLKSIZ > ip->i_fs->fs_fsize)
-               panic("mkdir: blksize");     /* XXX - should grow with bmap() */
-       else
-               ip->i_size = DIRBLKSIZ;
-       /*
-        * Directory all set up, now
-        * install the entry for it in
-        * the parent directory.
-        */
-       u.u_error = direnter(ip, ndp);
-       dp = NULL;
-       if (u.u_error) {
-               ndp->ni_nameiop = LOOKUP | NOCACHE;
-               ndp->ni_segflg = UIO_USERSPACE;
-               ndp->ni_dirp = uap->name;
-               dp = namei(ndp);
-               if (dp) {
-                       dp->i_nlink--;
-                       dp->i_flag |= ICHG;
-               }
-       }
-bad:
-       /*
-        * No need to do an explicit itrunc here,
-        * irele will do this for us because we set
-        * the link count to 0.
-        */
-       if (u.u_error) {
-               ip->i_nlink = 0;
-               ip->i_flag |= ICHG;
+       if (error = namei(ndp, p))
+               return (error);
+       vp = ndp->ni_vp;
+       if (vp != NULL) {
+               VOP_ABORTOP(ndp);
+               if (ndp->ni_dvp == vp)
+                       vrele(ndp->ni_dvp);
+               else
+                       vput(ndp->ni_dvp);
+               vrele(vp);
+               return (EEXIST);
         }
         }
-       if (dp)
-               iput(dp);
-       iput(ip);
+       VATTR_NULL(&vattr);
+       vattr.va_type = VDIR;
+       vattr.va_mode = (uap->dmode & 0777) &~ p->p_fd->fd_cmask;
+       error = VOP_MKDIR(ndp, &vattr, p);
+       if (!error)
+               vput(ndp->ni_vp);
+       return (error);
  }
  
  /*
   * Rmdir system call.
   */
  }
  
  /*
   * Rmdir system call.
   */
-rmdir()
-{
-       struct a {
+/* ARGSUSED */
+rmdir(p, uap, retval)
+       struct proc *p;
+       struct args {
                 char    *name;
                 char    *name;
-       } *uap = (struct a *)u.u_ap;
-       register struct inode *ip, *dp;
-       register struct nameidata *ndp = &u.u_nd;
+       } *uap;
+       int *retval;
+{
+       register struct nameidata *ndp;
+       register struct vnode *vp;
+       int error;
+       struct nameidata nd;
  
  
-       ndp->ni_nameiop = DELETE | LOCKPARENT;
+       ndp = &nd;
+       ndp->ni_nameiop = DELETE | LOCKPARENT | LOCKLEAF;
         ndp->ni_segflg = UIO_USERSPACE;
         ndp->ni_dirp = uap->name;
         ndp->ni_segflg = UIO_USERSPACE;
         ndp->ni_dirp = uap->name;
-       ip = namei(ndp);
-       if (ip == NULL)
-               return;
-       dp = ndp->ni_pdir;
-       /*
-        * No rmdir "." please.
-        */
-       if (dp == ip) {
-               irele(dp);
-               iput(ip);
-               u.u_error = EINVAL;
-               return;
-       }
-       if ((ip->i_mode&IFMT) != IFDIR) {
-               u.u_error = ENOTDIR;
-               goto out;
-       }
-       /*
-        * Don't remove a mounted on directory.
-        */
-       if (ip->i_dev != dp->i_dev) {
-               u.u_error = EBUSY;
+       if (error = namei(ndp, p))
+               return (error);
+       vp = ndp->ni_vp;
+       if (vp->v_type != VDIR) {
+               error = ENOTDIR;
                 goto out;
         }
         /*
                 goto out;
         }
         /*
-        * Verify the directory is empty (and valid).
-        * (Rmdir ".." won't be valid since
-        *  ".." will contain a reference to
-        *  the current directory and thus be
-        *  non-empty.)
+        * No rmdir "." please.
          */
          */
-       if (ip->i_nlink != 2 || !dirempty(ip, dp->i_number)) {
-               u.u_error = ENOTEMPTY;
+       if (ndp->ni_dvp == vp) {
+               error = EINVAL;
                 goto out;
         }
         /*
                 goto out;
         }
         /*
-        * Delete reference to directory before purging
-        * inode.  If we crash in between, the directory
-        * will be reattached to lost+found,
+        * The root of a mounted filesystem cannot be deleted.
          */
          */
-       if (dirremove(ndp) == 0)
-               goto out;
-       dp->i_nlink--;
-       dp->i_flag |= ICHG;
-       cacheinval(dp);
-       iput(dp);
-       dp = NULL;
-       /*
-        * Truncate inode.  The only stuff left
-        * in the directory is "." and "..".  The
-        * "." reference is inconsequential since
-        * we're quashing it.  The ".." reference
-        * has already been adjusted above.  We've
-        * removed the "." reference and the reference
-        * in the parent directory, but there may be
-        * other hard links so decrement by 2 and
-        * worry about them later.
-        */
-       ip->i_nlink -= 2;
-       itrunc(ip, (u_long)0);
-       cacheinval(ip);
+       if (vp->v_flag & VROOT)
+               error = EBUSY;
  out:
  out:
-       if (dp)
-               iput(dp);
-       iput(ip);
+       if (!error) {
+               error = VOP_RMDIR(ndp, p);
+       } else {
+               VOP_ABORTOP(ndp);
+               if (ndp->ni_dvp == vp)
+                       vrele(ndp->ni_dvp);
+               else
+                       vput(ndp->ni_dvp);
+               vput(vp);
+       }
+       return (error);
  }
  
  }
  
-struct file *
-getinode(fdes)
-       int fdes;
+/*
+ * Read a block of directory entries in a file system independent format.
+ */
+getdirentries(p, uap, retval)
+       struct proc *p;
+       register struct args {
+               int     fd;
+               char    *buf;
+               unsigned count;
+               long    *basep;
+       } *uap;
+       int *retval;
  {
  {
+       register struct vnode *vp;
         struct file *fp;
         struct file *fp;
+       struct uio auio;
+       struct iovec aiov;
+       off_t off;
+       int error, eofflag;
+
+       if (error = getvnode(p->p_fd, uap->fd, &fp))
+               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;
+       auio.uio_iovcnt = 1;
+       auio.uio_rw = UIO_READ;
+       auio.uio_segflg = UIO_USERSPACE;
+       auio.uio_procp = p;
+       auio.uio_resid = uap->count;
+       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);
+}
  
  
-       if ((unsigned)fdes >= NOFILE || (fp = u.u_ofile[fdes]) == NULL) {
-               u.u_error = EBADF;
-               return ((struct file *)0);
-       }
-       if (fp->f_type != DTYPE_INODE) {
-               u.u_error = EINVAL;
-               return ((struct file *)0);
+/*
+ * Set the mode mask for creation of filesystem nodes.
+ */
+mode_t
+umask(p, uap, retval)
+       struct proc *p;
+       struct args {
+               int     mask;
+       } *uap;
+       int *retval;
+{
+       register struct filedesc *fdp = p->p_fd;
+
+       *retval = fdp->fd_cmask;
+       fdp->fd_cmask = uap->mask & 07777;
+       return (0);
+}
+
+/*
+ * 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 nameidata *ndp;
+       register struct vnode *vp;
+       struct vattr vattr;
+       int error;
+       struct nameidata nd;
+
+       ndp = &nd;
+       ndp->ni_nameiop = LOOKUP | FOLLOW;
+       ndp->ni_segflg = UIO_USERSPACE;
+       ndp->ni_dirp = uap->fname;
+       if (error = namei(ndp, p))
+               return (error);
+       vp = ndp->ni_vp;
+       if (vp->v_type != VCHR && vp->v_type != VBLK) {
+               error = EINVAL;
+               goto out;
         }
         }
-       return (fp);
+       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);
  }
  
  /*
  }
  
  /*
- * mode mask for creation of files
+ * Convert a user file descriptor to a kernel file entry.
   */
   */
-umask()
+getvnode(fdp, fdes, fpp)
+       struct filedesc *fdp;
+       struct file **fpp;
+       int fdes;
  {
  {
-       register struct a {
-               int     mask;
-       } *uap = (struct a *)u.u_ap;
+       struct file *fp;
  
  
-       u.u_r.r_val1 = u.u_cmask;
-       u.u_cmask = uap->mask & 07777;
+       if ((unsigned)fdes >= fdp->fd_nfiles ||
+           (fp = fdp->fd_ofiles[fdes]) == NULL)
+               return (EBADF);
+       if (fp->f_type != DTYPE_VNODE)
+               return (EINVAL);
+       *fpp = fp;
+       return (0);
  }
  }