projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
lseek (long form) is used too much to make it COMPAT_43
[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 b3c4135..cf61962 100644 (file)
--- a/usr/src/sys/kern/vfs_syscalls.c
+++ b/usr/src/sys/kern/vfs_syscalls.c
@@ -2,104 +2,109 @@
  * 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.42 (Berkeley) %G%
+ *     @(#)vfs_syscalls.c      7.109 (Berkeley) %G%
  */
 
  */
 
-#include "param.h"
-#include "systm.h"
-#include "syscontext.h"
-#include "kernel.h"
-#include "file.h"
-#include "stat.h"
-#include "vnode.h"
-#include "mount.h"
-#include "proc.h"
-#include "uio.h"
-#include "malloc.h"
-
-#undef RETURN
-#define RETURN(val)    { scp->u_error = (val); if (scp->u_spare[0] != 0) panic("lock count"); return; }
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/namei.h>
+#include <sys/filedesc.h>
+#include <sys/kernel.h>
+#include <sys/file.h>
+#include <sys/stat.h>
+#include <sys/vnode.h>
+#include <sys/mount.h>
+#include <sys/proc.h>
+#include <sys/uio.h>
+#include <sys/malloc.h>
+#include <sys/dirent.h>
+
+#include <vm/vm.h>
+#include <sys/sysctl.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;
+struct mount_args {
+       int     type;
+       char    *dir;
+       int     flags;
+       caddr_t data;
+};
+/* ARGSUSED */
+mount(p, uap, retval)
+       struct proc *p;
+       register struct mount_args *uap;
+       int *retval;
 {
 {
-       register struct a {
-               int     type;
-               char    *dir;
-               int     flags;
-               caddr_t data;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
        register struct vnode *vp;
        register struct mount *mp;
        int error, flag;
        register struct vnode *vp;
        register struct mount *mp;
        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;
                }
                mp = vp->v_mount;
+               flag = mp->mnt_flag;
                /*
                /*
-                * We allow going from read-only to read-write,
-                * but not from read-write to read-only.
+                * We only allow the filesystem to be reloaded if it
+                * is currently mounted read-only.
                 */
                 */
-               if ((mp->m_flag & M_RDONLY) == 0 &&
-                   (uap->flags & M_RDONLY) != 0) {
+               if ((uap->flags & MNT_RELOAD) &&
+                   ((mp->mnt_flag & MNT_RDONLY) == 0)) {
                        vput(vp);
                        vput(vp);
-                       RETURN (EOPNOTSUPP);    /* Needs translation */
+                       return (EOPNOTSUPP);    /* Needs translation */
                }
                }
-               flag = mp->m_flag;
-               mp->m_flag |= M_UPDATE;
+               mp->mnt_flag |=
+                   uap->flags & (MNT_RELOAD | MNT_FORCE | MNT_UPDATE);
                VOP_UNLOCK(vp);
                goto update;
        }
                VOP_UNLOCK(vp);
                goto update;
        }
-       vinvalbuf(vp, 1);
-       if (vp->v_usecount != 1) {
+       if (vp->v_usecount != 1 && (uap->flags & MNT_UNION) == 0) {
                vput(vp);
                vput(vp);
-               RETURN (EBUSY);
+               return (EBUSY);
        }
        }
+       if (error = vinvalbuf(vp, V_SAVE, p->p_ucred, p, 0, 0))
+               return (error);
        if (vp->v_type != VDIR) {
                vput(vp);
        if (vp->v_type != VDIR) {
                vput(vp);
-               RETURN (ENOTDIR);
+               return (ENOTDIR);
        }
        if ((unsigned long)uap->type > MOUNT_MAXTYPE ||
            vfssw[uap->type] == (struct vfsops *)0) {
                vput(vp);
        }
        if ((unsigned long)uap->type > MOUNT_MAXTYPE ||
            vfssw[uap->type] == (struct vfsops *)0) {
                vput(vp);
-               RETURN (ENODEV);
+               return (ENODEV);
        }
 
        /*
        }
 
        /*
@@ -107,76 +112,65 @@ 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->m_mounth = (struct vnode *)0;
+       bzero((char *)mp, (u_long)sizeof(struct mount));
+       mp->mnt_op = vfssw[uap->type];
        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);
        }
        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;
-       else
-               mp->m_flag &= ~M_RDONLY;
-       if (uap->flags & M_NOSUID)
-               mp->m_flag |= M_NOSUID;
-       else
-               mp->m_flag &= ~M_NOSUID;
-       if (uap->flags & M_NOEXEC)
-               mp->m_flag |= M_NOEXEC;
-       else
-               mp->m_flag &= ~M_NOEXEC;
-       if (uap->flags & M_NODEV)
-               mp->m_flag |= M_NODEV;
-       else
-               mp->m_flag &= ~M_NODEV;
-       if (uap->flags & M_SYNCHRONOUS)
-               mp->m_flag |= M_SYNCHRONOUS;
-       else
-               mp->m_flag &= ~M_SYNCHRONOUS;
+       if (uap->flags & MNT_RDONLY)
+               mp->mnt_flag |= MNT_RDONLY;
+       else if (mp->mnt_flag & MNT_RDONLY)
+               mp->mnt_flag |= MNT_WANTRDWR;
+       mp->mnt_flag &=~
+           (MNT_NOSUID | MNT_NOEXEC | MNT_NODEV | MNT_SYNCHRONOUS | MNT_UNION);
+       mp->mnt_flag |= uap->flags &
+           (MNT_NOSUID | MNT_NOEXEC | MNT_NODEV | MNT_SYNCHRONOUS | MNT_UNION);
        /*
         * 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) {
                vrele(vp);
                vrele(vp);
+               if (mp->mnt_flag & MNT_WANTRDWR)
+                       mp->mnt_flag &= ~MNT_RDONLY;
+               mp->mnt_flag &=~
+                   (MNT_UPDATE | MNT_RELOAD | MNT_FORCE | MNT_WANTRDWR);
                if (error)
                if (error)
-                       mp->m_flag = flag;
-               RETURN (error);
+                       mp->mnt_flag = flag;
+               return (error);
        }
        /*
         * Put the new filesystem on the mount list after root.
         */
        }
        /*
         * 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;
+       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);
 }
 
 /*
 }
 
 /*
@@ -185,66 +179,75 @@ 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 unmount_args {
+       char    *pathp;
+       int     flags;
+};
+/* ARGSUSED */
+unmount(p, uap, retval)
+       struct proc *p;
+       register struct unmount_args *uap;
+       int *retval;
 {
 {
-       struct a {
-               char    *pathp;
-               int     flags;
-       } *uap = (struct a *)scp->sc_ap;
        register struct vnode *vp;
        register struct vnode *vp;
-       register struct nameidata *ndp = &scp->sc_nd;
        struct mount *mp;
        int error;
        struct mount *mp;
        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);
-       RETURN (dounmount(mp, uap->flags));
+       return (dounmount(mp, uap->flags, p));
 }
 
 /*
  * Do an unmount.
  */
 }
 
 /*
  * Do an unmount.
  */
-dounmount(mp, flags)
+dounmount(mp, flags, p)
        register struct mount *mp;
        int flags;
        register struct mount *mp;
        int flags;
+       struct proc *p;
 {
        struct vnode *coveredvp;
        int error;
 
 {
        struct vnode *coveredvp;
        int error;
 
-       coveredvp = mp->m_vnodecovered;
+       coveredvp = mp->mnt_vnodecovered;
+       if (vfs_busy(mp))
+               return (EBUSY);
+       mp->mnt_flag |= MNT_UNMOUNT;
        if (error = vfs_lock(mp))
                return (error);
 
        if (error = vfs_lock(mp))
                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, flags);
+       if ((error = VFS_SYNC(mp, MNT_WAIT, p->p_ucred, p)) == 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);
        }
        return (error);
                free((caddr_t)mp, M_MOUNT);
        }
        return (error);
@@ -254,11 +257,22 @@ dounmount(mp, flags)
  * Sync system call.
  * Sync each mounted filesystem.
  */
  * Sync system call.
  * Sync each mounted filesystem.
  */
+#ifdef DIAGNOSTIC
+int syncprt = 0;
+struct ctldebug debug0 = { "syncprt", &syncprt };
+#endif
+
+struct sync_args {
+       int     dummy;
+};
 /* ARGSUSED */
 /* ARGSUSED */
-sync(scp)
-       struct syscontext *scp;
+sync(p, uap, retval)
+       struct proc *p;
+       struct sync_args *uap;
+       int *retval;
 {
        register struct mount *mp;
 {
        register struct mount *mp;
+       struct mount *omp;
 
        mp = rootfs;
        do {
 
        mp = rootfs;
        do {
@@ -266,74 +280,120 @@ sync(scp)
                 * The lock check below is to avoid races with mount
                 * and unmount.
                 */
                 * The lock check below is to avoid races with mount
                 * and unmount.
                 */
-               if ((mp->m_flag & (M_MLOCK|M_RDONLY)) == 0)
-                       VFS_SYNC(mp, MNT_NOWAIT);
-               mp = mp->m_next;
+               if ((mp->mnt_flag & (MNT_MLOCK|MNT_RDONLY|MNT_MPBUSY)) == 0 &&
+                   !vfs_busy(mp)) {
+                       VFS_SYNC(mp, MNT_NOWAIT, p->p_ucred, p);
+                       omp = mp;
+                       mp = mp->mnt_next;
+                       vfs_unbusy(omp);
+               } else
+                       mp = mp->mnt_next;
        } while (mp != rootfs);
        } while (mp != rootfs);
+#ifdef DIAGNOSTIC
+       if (syncprt)
+               vfs_bufstats();
+#endif /* DIAGNOSTIC */
+       return (0);
 }
 
 /*
 }
 
 /*
- * get filesystem statistics
+ * Operate on filesystem quotas.
  */
  */
-statfs(scp)
-       register struct syscontext *scp;
+struct quotactl_args {
+       char *path;
+       int cmd;
+       int uid;
+       caddr_t arg;
+};
+/* ARGSUSED */
+quotactl(p, uap, retval)
+       struct proc *p;
+       register struct quotactl_args *uap;
+       int *retval;
+{
+       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.
+ */
+struct statfs_args {
+       char *path;
+       struct statfs *buf;
+};
+/* ARGSUSED */
+statfs(p, uap, retval)
+       struct proc *p;
+       register struct statfs_args *uap;
+       int *retval;
 {
 {
-       struct a {
-               char *path;
-               struct statfs *buf;
-       } *uap = (struct a *)scp->sc_ap;
        register struct mount *mp;
        register struct mount *mp;
-       register struct nameidata *ndp = &scp->sc_nd;
        register struct statfs *sp;
        int error;
        register struct statfs *sp;
        int error;
+       struct nameidata nd;
 
 
-       ndp->ni_nameiop = LOOKUP | FOLLOW;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->path;
-       if (error = namei(ndp))
-               RETURN (error);
-       mp = ndp->ni_vp->v_mount;
-       sp = &mp->m_stat;
-       vrele(ndp->ni_vp);
-       if (error = VFS_STATFS(mp, sp))
-               RETURN (error);
-       sp->f_flags = mp->m_flag & M_VISFLAGMASK;
-       RETURN (copyout((caddr_t)sp, (caddr_t)uap->buf, sizeof(*sp)));
+       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;
+/*
+ * Get filesystem statistics.
+ */
+struct fstatfs_args {
+       int fd;
+       struct statfs *buf;
+};
+/* ARGSUSED */
+fstatfs(p, uap, retval)
+       struct proc *p;
+       register struct fstatfs_args *uap;
+       int *retval;
 {
 {
-       struct a {
-               int fd;
-               struct statfs *buf;
-       } *uap = (struct a *)scp->sc_ap;
        struct file *fp;
        struct mount *mp;
        register struct statfs *sp;
        int error;
 
        struct file *fp;
        struct mount *mp;
        register struct statfs *sp;
        int error;
 
-       if (error = getvnode(scp->sc_ofile, uap->fd, &fp))
-               RETURN (error);
+       if (error = getvnode(p->p_fd, uap->fd, &fp))
+               return (error);
        mp = ((struct vnode *)fp->f_data)->v_mount;
        mp = ((struct vnode *)fp->f_data)->v_mount;
-       sp = &mp->m_stat;
-       if (error = VFS_STATFS(mp, sp))
-               RETURN (error);
-       sp->f_flags = mp->m_flag & M_VISFLAGMASK;
-       RETURN (copyout((caddr_t)sp, (caddr_t)uap->buf, sizeof(*sp)));
+       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 getfsstat_args {
+       struct statfs *buf;
+       long bufsize;
+       int flags;
+};
+getfsstat(p, uap, retval)
+       struct proc *p;
+       register struct getfsstat_args *uap;
+       int *retval;
 {
 {
-       struct a {
-               struct statfs *buf;
-               long bufsize;
-               int flags;
-       } *uap = (struct a *)scp->sc_ap;
        register struct mount *mp;
        register struct statfs *sp;
        caddr_t sfsp;
        register struct mount *mp;
        register struct statfs *sp;
        caddr_t sfsp;
@@ -344,115 +404,125 @@ getfsstat(scp)
        mp = rootfs;
        count = 0;
        do {
        mp = rootfs;
        count = 0;
        do {
-               if (sfsp && count < maxcount && ((mp->m_flag & M_MLOCK) == 0)) {
-                       sp = &mp->m_stat;
+               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)) &&
                        /*
                         * If MNT_NOWAIT is specified, do not refresh the
                         * fsstat cache. MNT_WAIT overrides MNT_NOWAIT.
                         */
                        if (((uap->flags & MNT_NOWAIT) == 0 ||
                            (uap->flags & MNT_WAIT)) &&
-                           (error = VFS_STATFS(mp, sp))) {
-                               mp = mp->m_prev;
+                           (error = VFS_STATFS(mp, sp, p))) {
+                               mp = mp->mnt_prev;
                                continue;
                        }
                                continue;
                        }
-                       sp->f_flags = mp->m_flag & M_VISFLAGMASK;
+                       sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
                        if (error = copyout((caddr_t)sp, sfsp, sizeof(*sp)))
                        if (error = copyout((caddr_t)sp, sfsp, sizeof(*sp)))
-                               RETURN (error);
+                               return (error);
                        sfsp += sizeof(*sp);
                }
                count++;
                        sfsp += sizeof(*sp);
                }
                count++;
-               mp = mp->m_prev;
+               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 fchdir_args {
+       int     fd;
+};
+/* ARGSUSED */
+fchdir(p, uap, retval)
+       struct proc *p;
+       struct fchdir_args *uap;
+       int *retval;
 {
 {
-       struct a {
-               int     fd;
-       } *uap = (struct a *)scp->sc_ap;
+       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);
        if (error)
        VOP_UNLOCK(vp);
        if (error)
-               RETURN (error);
+               return (error);
        VREF(vp);
        VREF(vp);
-       vrele(scp->sc_cdir);
-       scp->sc_cdir = vp;
-       RETURN (0);
+       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 chdir_args {
+       char    *fname;
+};
+/* ARGSUSED */
+chdir(p, uap, retval)
+       struct proc *p;
+       struct chdir_args *uap;
+       int *retval;
 {
 {
-       struct a {
-               char    *fname;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
+       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 chroot_args {
+       char    *fname;
+};
+/* ARGSUSED */
+chroot(p, uap, retval)
+       struct proc *p;
+       struct chroot_args *uap;
+       int *retval;
 {
 {
-       struct a {
-               char    *fname;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
+       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);
-       if (scp->sc_rdir != NULL)
-               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;
@@ -463,7 +533,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);
@@ -472,107 +542,134 @@ chdirec(ndp)
 
 /*
  * Open system call.
 
 /*
  * Open system call.
- */
-open(scp)
-       register struct syscontext *scp;
-{
-       struct a {
-               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.
  */
  * 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;
+struct open_args {
+       char    *fname;
+       int     mode;
+       int     crtmode;
+};
+open(p, uap, retval)
+       struct proc *p;
+       register struct open_args *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) &~ S_ISVTX)) {
-               crfree(fp->f_cred);
-               fp->f_count--;
-               if (error == -1)        /* XXX from fdopen */
-                       return (0);     /* XXX from fdopen */
-               scp->sc_ofile[indx] = NULL;
+       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 || error == ENXIO) &&
+                   p->p_dupfd >= 0 &&                  /* XXX from fdopen */
+                   (error = dupfdopen(fdp, indx, p->p_dupfd,
+                                       fmode, error)) == 0) {
+                       *retval = indx;
+                       return (0);
+               }
+               if (error == ERESTART)
+                       error = EINTR;
+               fdp->fd_ofiles[indx] = NULL;
                return (error);
        }
                return (error);
        }
+       p->p_dupfd = 0;
+       vp = nd.ni_vp;
        fp->f_flag = fmode & FMASK;
        fp->f_type = DTYPE_VNODE;
        fp->f_ops = &vnops;
        fp->f_flag = fmode & FMASK;
        fp->f_type = DTYPE_VNODE;
        fp->f_ops = &vnops;
-       fp->f_data = (caddr_t)ndp->ni_vp;
-       if (resultfd)
-               *resultfd = indx;
+       fp->f_data = (caddr_t)vp;
+       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);
+       *retval = indx;
        return (0);
 }
 
        return (0);
 }
 
+#ifdef COMPAT_43
+/*
+ * Creat system call.
+ */
+struct ocreat_args {
+       char    *fname;
+       int     fmode;
+};
+ocreat(p, uap, retval)
+       struct proc *p;
+       register struct ocreat_args *uap;
+       int *retval;
+{
+       struct open_args 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
+ * Mknod system call.
  */
  */
-mknod(scp)
-       register struct syscontext *scp;
+struct mknod_args {
+       char    *fname;
+       int     fmode;
+       int     dev;
+};
+/* ARGSUSED */
+mknod(p, uap, retval)
+       struct proc *p;
+       register struct mknod_args *uap;
+       int *retval;
 {
 {
-       register struct a {
-               char    *fname;
-               int     fmode;
-               int     dev;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
        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);
+       VATTR_NULL(&vattr);
        switch (uap->fmode & S_IFMT) {
 
        case S_IFMT:    /* used by badsect to flag bad sectors */
        switch (uap->fmode & S_IFMT) {
 
        case S_IFMT:    /* used by badsect to flag bad sectors */
@@ -588,198 +685,242 @@ mknod(scp)
                error = EINVAL;
                goto out;
        }
                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);
 }
 
 /*
 }
 
 /*
- * Mkfifo system call
+ * Mkfifo system call.
  */
  */
-mkfifo(scp)
-       register struct syscontext *scp;
+struct mkfifo_args {
+       char    *fname;
+       int     fmode;
+};
+/* ARGSUSED */
+mkfifo(p, uap, retval)
+       struct proc *p;
+       register struct mkfifo_args *uap;
+       int *retval;
 {
 {
-       register struct a {
-               char    *fname;
-               int     fmode;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
        struct vattr vattr;
        int error;
        struct vattr vattr;
        int error;
+       struct nameidata nd;
 
 #ifndef FIFO
 
 #ifndef FIFO
-       RETURN (EOPNOTSUPP);
+       return (EOPNOTSUPP);
 #else
 #else
-       ndp->ni_nameiop = CREATE | LOCKPARENT;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       if (error = namei(ndp))
-               RETURN (error);
-       if (ndp->ni_vp != NULL) {
-               VOP_ABORTOP(ndp);
-               RETURN (EEXIST);
-       } else {
-               vattr_null(&vattr);
-               vattr.va_type = VFIFO;
-               vattr.va_mode = (uap->fmode & 07777) &~ scp->sc_cmask;
+       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);
        }
        }
-       RETURN (VOP_MKNOD(ndp, &vattr, ndp->ni_cred));
+       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 */
 }
 
 /*
 #endif /* FIFO */
 }
 
 /*
- * link system call
+ * Link system call.
  */
  */
-link(scp)
-       register struct syscontext *scp;
+struct link_args {
+       char    *target;
+       char    *linkname;
+};
+/* ARGSUSED */
+link(p, uap, retval)
+       struct proc *p;
+       register struct link_args *uap;
+       int *retval;
 {
 {
-       register struct a {
-               char    *target;
-               char    *linkname;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
        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;
-       if (vp->v_mount != xp->v_mount)
-               error = EXDEV;
+       xp = nd.ni_dvp;
 out:
 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(nd.ni_dvp, vp, &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 symlink_args {
+       char    *target;
+       char    *linkname;
+};
+/* ARGSUSED */
+symlink(p, uap, retval)
+       struct proc *p;
+       register struct symlink_args *uap;
+       int *retval;
 {
 {
-       struct a {
-               char    *target;
-               char    *linkname;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
-       register struct vnode *vp;
        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;
+struct unlink_args {
+       char    *name;
+};
+/* ARGSUSED */
+unlink(p, uap, retval)
+       struct proc *p;
+       struct unlink_args *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, UIO_USERSPACE, uap->name, p);
+       if (error = namei(&nd))
+               return (error);
+       vp = nd.ni_vp;
+       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
+       VOP_LOCK(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);
+               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);
 }
 
 }
 
+struct __lseek_args {
+       int     fdes;
+       int     pad;
+       off_t   off;
+       int     sbase;
+};
+
 /*
 /*
- * Seek system call
+ * Seek system call.
  */
  */
-lseek(scp)
-       register struct syscontext *scp;
+__lseek(p, uap, retval)
+       struct proc *p;
+       register struct __lseek_args *uap;
+       int *retval;
 {
 {
+       struct ucred *cred = p->p_ucred;
+       register struct filedesc *fdp = p->p_fd;
        register struct file *fp;
        register struct file *fp;
-       register struct a {
-               int     fdes;
-               off_t   off;
-               int     sbase;
-       } *uap = (struct a *)scp->sc_ap;
        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:
@@ -788,8 +929,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;
 
@@ -798,36 +939,65 @@ lseek(scp)
                break;
 
        default:
                break;
 
        default:
-               RETURN (EINVAL);
+               return (EINVAL);
        }
        }
-       scp->sc_offset = fp->f_offset;
-       RETURN (0);
+       *(off_t *)retval = fp->f_offset;
+       return (0);
+}
+
+/*
+ * Old lseek system call.
+ *
+ * XXX should be COMPAT_43, but too much breaks.
+ */
+struct lseek_args {
+       int     fdes;
+       long    off;
+       int     sbase;
+};
+lseek(p, uap, retval)
+       struct proc *p;
+       register struct lseek_args *uap;
+       int *retval;
+{
+       struct __lseek_args nuap;
+       off_t qret;
+       int error;
+
+       nuap.fdes = uap->fdes;
+       nuap.off = uap->off;
+       nuap.sbase = uap->sbase;
+       error = __lseek(p, &nuap, &qret);
+       *(long *)retval = qret;
+       return (error);
 }
 
 /*
 }
 
 /*
- * Access system call
+ * Check access permissions.
  */
  */
-saccess(scp)
-       register struct syscontext *scp;
+struct saccess_args {
+       char    *fname;
+       int     fmode;
+};
+/* ARGSUSED */
+saccess(p, uap, retval)
+       struct proc *p;
+       register struct saccess_args *uap;
+       int *retval;
 {
 {
-       register struct a {
-               char    *fname;
-               int     fmode;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
+       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
         */
@@ -840,83 +1010,220 @@ saccess(scp)
                if (uap->fmode & X_OK)
                        mode |= VEXEC;
                if ((mode & VWRITE) == 0 || (error = vn_writechk(vp)) == 0)
                if (uap->fmode & X_OK)
                        mode |= VEXEC;
                if ((mode & VWRITE) == 0 || (error = vn_writechk(vp)) == 0)
-                       error = VOP_ACCESS(vp, mode, ndp->ni_cred);
+                       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);
 }
 
 }
 
+#if defined(COMPAT_43) || defined(COMPAT_SUNOS)
 /*
 /*
- * Stat system call.  This version follows links.
+ * Stat system call.
+ * This version follows links.
  */
  */
-stat(scp)
-       struct syscontext *scp;
+struct ostat_args {
+       char    *fname;
+       struct ostat *ub;
+};
+/* ARGSUSED */
+ostat(p, uap, retval)
+       struct proc *p;
+       register struct ostat_args *uap;
+       int *retval;
 {
 {
+       struct stat sb;
+       struct ostat osb;
+       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);
+       cvtstat(&sb, &osb);
+       error = copyout((caddr_t)&osb, (caddr_t)uap->ub, sizeof (osb));
+       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;
+struct olstat_args {
+       char    *fname;
+       struct ostat *ub;
+};
+/* ARGSUSED */
+olstat(p, uap, retval)
+       struct proc *p;
+       register struct olstat_args *uap;
+       int *retval;
 {
 {
+       struct stat sb;
+       struct ostat osb;
+       int error;
+       struct nameidata nd;
 
 
-       stat1(scp, NOFOLLOW);
+       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)
+               return (error);
+       cvtstat(&sb, &osb);
+       error = copyout((caddr_t)&osb, (caddr_t)uap->ub, sizeof (osb));
+       return (error);
 }
 
 }
 
-stat1(scp, follow)
-       register struct syscontext *scp;
-       int follow;
+/*
+ * convert from an old to a new stat structure.
+ */
+cvtstat(st, ost)
+       struct stat *st;
+       struct ostat *ost;
+{
+
+       ost->st_dev = st->st_dev;
+       ost->st_ino = st->st_ino;
+       ost->st_mode = st->st_mode;
+       ost->st_nlink = st->st_nlink;
+       ost->st_uid = st->st_uid;
+       ost->st_gid = st->st_gid;
+       ost->st_rdev = st->st_rdev;
+       if (st->st_size < (quad_t)1 << 32)
+               ost->st_size = st->st_size;
+       else
+               ost->st_size = -2;
+       ost->st_atime = st->st_atime;
+       ost->st_mtime = st->st_mtime;
+       ost->st_ctime = st->st_ctime;
+       ost->st_blksize = st->st_blksize;
+       ost->st_blocks = st->st_blocks;
+       ost->st_flags = st->st_flags;
+       ost->st_gen = st->st_gen;
+}
+#endif /* COMPAT_43 || COMPAT_SUNOS */
+
+/*
+ * Stat system call.
+ * This version follows links.
+ */
+struct stat_args {
+       char    *fname;
+       struct stat *ub;
+};
+/* ARGSUSED */
+stat(p, uap, retval)
+       struct proc *p;
+       register struct stat_args *uap;
+       int *retval;
 {
 {
-       register struct a {
-               char    *fname;
-               struct stat *ub;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
        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, 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)
        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
+ * Lstat system call.
+ * This version does not follow links.
  */
  */
-readlink(scp)
-       register struct syscontext *scp;
+struct lstat_args {
+       char    *fname;
+       struct stat *ub;
+};
+/* ARGSUSED */
+lstat(p, uap, retval)
+       struct proc *p;
+       register struct lstat_args *uap;
+       int *retval;
+{
+       int error;
+       struct vnode *vp, *dvp;
+       struct stat sb, sb1;
+       struct nameidata nd;
+
+       NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | LOCKPARENT, UIO_USERSPACE,
+           uap->fname, p);
+       if (error = namei(&nd))
+               return (error);
+       /*
+        * For symbolic links, always return the attributes of its
+        * containing directory, except for mode, size, and links.
+        */
+       vp = nd.ni_vp;
+       dvp = nd.ni_dvp;
+       if (vp->v_type != VLNK) {
+               if (dvp == vp)
+                       vrele(dvp);
+               else
+                       vput(dvp);
+               error = vn_stat(vp, &sb, p);
+               vput(vp);
+               if (error)
+                       return (error);
+       } else {
+               error = vn_stat(dvp, &sb, p);
+               vput(dvp);
+               if (error) {
+                       vput(vp);
+                       return (error);
+               }
+               error = vn_stat(vp, &sb1, p);
+               vput(vp);
+               if (error)
+                       return (error);
+               sb.st_mode &= ~S_IFDIR;
+               sb.st_mode |= S_IFLNK;
+               sb.st_nlink = sb1.st_nlink;
+               sb.st_size = sb1.st_size;
+               sb.st_blocks = sb1.st_blocks;
+       }
+       error = copyout((caddr_t)&sb, (caddr_t)uap->ub, sizeof (sb));
+       return (error);
+}
+
+/*
+ * Return target name of a symbolic link.
+ */
+struct readlink_args {
+       char    *name;
+       char    *buf;
+       int     count;
+};
+/* ARGSUSED */
+readlink(p, uap, retval)
+       struct proc *p;
+       register struct readlink_args *uap;
+       int *retval;
 {
 {
-       register struct a {
-               char    *name;
-               char    *buf;
-               int     count;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
        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;
@@ -928,302 +1235,346 @@ 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 chflags_args {
+       char    *fname;
+       int     flags;
+};
+/* ARGSUSED */
+chflags(p, uap, retval)
+       struct proc *p;
+       register struct chflags_args *uap;
+       int *retval;
 {
 {
-       struct a {
-               char    *fname;
-               int     flags;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
        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, UIO_USERSPACE, uap->fname, p);
+       if (error = namei(&nd))
+               return (error);
+       vp = nd.ni_vp;
+       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
+       VOP_LOCK(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;
+       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 fchflags_args {
+       int     fd;
+       int     flags;
+};
+/* ARGSUSED */
+fchflags(p, uap, retval)
+       struct proc *p;
+       register struct fchflags_args *uap;
+       int *retval;
 {
 {
-       struct a {
-               int     fd;
-               int     flags;
-       } *uap = (struct a *)scp->sc_ap;
        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;
        vp = (struct vnode *)fp->f_data;
+       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
        VOP_LOCK(vp);
        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;
+       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 chmod_args {
+       char    *fname;
+       int     fmode;
+};
+/* ARGSUSED */
+chmod(p, uap, retval)
+       struct proc *p;
+       register struct chmod_args *uap;
+       int *retval;
 {
 {
-       struct a {
-               char    *fname;
-               int     fmode;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
        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, UIO_USERSPACE, uap->fname, p);
+       if (error = namei(&nd))
+               return (error);
+       vp = nd.ni_vp;
+       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
+       VOP_LOCK(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;
+       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 fchmod_args {
+       int     fd;
+       int     fmode;
+};
+/* ARGSUSED */
+fchmod(p, uap, retval)
+       struct proc *p;
+       register struct fchmod_args *uap;
+       int *retval;
 {
 {
-       struct a {
-               int     fd;
-               int     fmode;
-       } *uap = (struct a *)scp->sc_ap;
        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;
        vp = (struct vnode *)fp->f_data;
+       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
        VOP_LOCK(vp);
        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;
+       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 chown_args {
+       char    *fname;
+       int     uid;
+       int     gid;
+};
+/* ARGSUSED */
+chown(p, uap, retval)
+       struct proc *p;
+       register struct chown_args *uap;
+       int *retval;
 {
 {
-       struct a {
-               char    *fname;
-               int     uid;
-               int     gid;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
        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, UIO_USERSPACE, uap->fname, p);
+       if (error = namei(&nd))
+               return (error);
+       vp = nd.ni_vp;
+       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
+       VOP_LOCK(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;
+       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 fchown_args {
+       int     fd;
+       int     uid;
+       int     gid;
+};
+/* ARGSUSED */
+fchown(p, uap, retval)
+       struct proc *p;
+       register struct fchown_args *uap;
+       int *retval;
 {
 {
-       struct a {
-               int     fd;
-               int     uid;
-               int     gid;
-       } *uap = (struct a *)scp->sc_ap;
        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;
        vp = (struct vnode *)fp->f_data;
+       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
        VOP_LOCK(vp);
        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;
+       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;
+/*
+ * Set the access and modification times of a file.
+ */
+struct utimes_args {
+       char    *fname;
+       struct  timeval *tptr;
+};
+/* ARGSUSED */
+utimes(p, uap, retval)
+       struct proc *p;
+       register struct utimes_args *uap;
+       int *retval;
 {
 {
-       register struct a {
-               char    *fname;
-               struct  timeval *tptr;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
        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;
-
-       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) {
+       struct nameidata nd;
+
+       VATTR_NULL(&vattr);
+       if (uap->tptr == NULL) {
+               microtime(&tv[0]);
+               tv[1] = tv[0];
+               vattr.va_vaflags |= VA_UTIMES_NULL;
+       } else if (error = copyin((caddr_t)uap->tptr, (caddr_t)tv, sizeof (tv)))
+               return (error);
+       NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->fname, p);
+       if (error = namei(&nd))
+               return (error);
+       vp = nd.ni_vp;
+       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
+       VOP_LOCK(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.va_atime.ts_sec = tv[0].tv_sec;
+       vattr.va_atime.ts_nsec = tv[0].tv_usec * 1000;
+       vattr.va_mtime.ts_sec = tv[1].tv_sec;
+       vattr.va_mtime.ts_nsec = tv[1].tv_usec * 1000;
+       error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 out:
        vput(vp);
 out:
        vput(vp);
-       RETURN (error);
+       return (error);
 }
 
 }
 
+struct __truncate_args {
+       char    *fname;
+       int     pad;
+       off_t   length;
+};
+
 /*
  * Truncate a file given its path name.
  */
 /*
  * Truncate a file given its path name.
  */
-truncate(scp)
-       register struct syscontext *scp;
+/* ARGSUSED */
+__truncate(p, uap, retval)
+       struct proc *p;
+       register struct __truncate_args *uap;
+       int *retval;
 {
 {
-       struct a {
-               char    *fname;
-               off_t   length;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
        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, UIO_USERSPACE, uap->fname, p);
+       if (error = namei(&nd))
+               return (error);
+       vp = nd.ni_vp;
+       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
+       VOP_LOCK(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;
+       error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 out:
        vput(vp);
 out:
        vput(vp);
-       RETURN (error);
+       return (error);
 }
 
 }
 
+struct __ftruncate_args {
+       int     fd;
+       int     pad;
+       off_t   length;
+};
+
 /*
  * Truncate a file given a file descriptor.
  */
 /*
  * Truncate a file given a file descriptor.
  */
-ftruncate(scp)
-       register struct syscontext *scp;
+/* ARGSUSED */
+__ftruncate(p, uap, retval)
+       struct proc *p;
+       register struct __ftruncate_args *uap;
+       int *retval;
 {
 {
-       struct a {
-               int     fd;
-               off_t   length;
-       } *uap = (struct a *)scp->sc_ap;
        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;
        vp = (struct vnode *)fp->f_data;
+       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
        VOP_LOCK(vp);
        if (vp->v_type == VDIR) {
                error = EISDIR;
        VOP_LOCK(vp);
        if (vp->v_type == VDIR) {
                error = EISDIR;
@@ -1231,32 +1582,79 @@ 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;
+       error = VOP_SETATTR(vp, &vattr, fp->f_cred, p);
 out:
        VOP_UNLOCK(vp);
 out:
        VOP_UNLOCK(vp);
-       RETURN (error);
+       return (error);
 }
 
 }
 
+#if defined(COMPAT_43) || defined(COMPAT_SUNOS)
+/*
+ * Truncate a file given its path name.
+ */
+struct truncate_args {
+       char    *fname;
+       long    length;
+};
+/* ARGSUSED */
+truncate(p, uap, retval)
+       struct proc *p;
+       register struct truncate_args *uap;
+       int *retval;
+{
+       struct __truncate_args nuap;
+
+       nuap.fname = uap->fname;
+       nuap.length = uap->length;
+       return (__truncate(p, &nuap, retval));
+}
+
+/*
+ * Truncate a file given a file descriptor.
+ */
+struct ftruncate_args {
+       int     fd;
+       long    length;
+};
+/* ARGSUSED */
+ftruncate(p, uap, retval)
+       struct proc *p;
+       register struct ftruncate_args *uap;
+       int *retval;
+{
+       struct __ftruncate_args nuap;
+
+       nuap.fd = uap->fd;
+       nuap.length = uap->length;
+       return (__ftruncate(p, &nuap, retval));
+}
+#endif /* COMPAT_43 || COMPAT_SUNOS */
+
 /*
  * Synch an open file.
  */
 /*
  * Synch an open file.
  */
-fsync(scp)
-       register struct syscontext *scp;
+struct fsync_args {
+       int     fd;
+};
+/* ARGSUSED */
+fsync(p, uap, retval)
+       struct proc *p;
+       struct fsync_args *uap;
+       int *retval;
 {
 {
-       struct a {
-               int     fd;
-       } *uap = (struct a *)scp->sc_ap;
        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(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);
-       error = VOP_FSYNC(vp, fp->f_flag, fp->f_cred, MNT_WAIT);
+       error = VOP_FSYNC(vp, fp->f_cred, MNT_WAIT, p);
        VOP_UNLOCK(vp);
        VOP_UNLOCK(vp);
-       RETURN (error);
+       return (error);
 }
 
 /*
 }
 
 /*
@@ -1265,29 +1663,34 @@ 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 rename_args {
+       char    *from;
+       char    *to;
+};
+/* ARGSUSED */
+rename(p, uap, retval)
+       struct proc *p;
+       register struct rename_args *uap;
+       int *retval;
 {
 {
-       struct a {
-               char    *from;
-               char    *to;
-       } *uap = (struct a *)scp->sc_ap;
        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) {
@@ -1299,89 +1702,117 @@ rename(scp)
                        goto out;
                }
        }
                        goto out;
                }
        }
-       if (error) {
-               VOP_ABORTOP(ndp);
-               goto out1;
-       }
-       if (fvp->v_mount != tdvp->v_mount) {
-               error = EXDEV;
-               goto out;
-       }
        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 mkdir_args {
+       char    *name;
+       int     dmode;
+};
+/* ARGSUSED */
+mkdir(p, uap, retval)
+       struct proc *p;
+       register struct mkdir_args *uap;
+       int *retval;
 {
 {
-       struct a {
-               char    *name;
-               int     dmode;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
        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 rmdir_args {
+       char    *name;
+};
+/* ARGSUSED */
+rmdir(p, uap, retval)
+       struct proc *p;
+       struct rmdir_args *uap;
+       int *retval;
 {
 {
-       struct a {
-               char    *name;
-       } *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->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;
@@ -1389,128 +1820,260 @@ 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) {
+               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);
+}
+
+#ifdef COMPAT_43
+/*
+ * Read a block of directory entries in a file system independent format.
+ */
+struct ogetdirentries_args {
+       int     fd;
+       char    *buf;
+       unsigned count;
+       long    *basep;
+};
+ogetdirentries(p, uap, retval)
+       struct proc *p;
+       register struct ogetdirentries_args *uap;
+       int *retval;
+{
+       register struct vnode *vp;
+       struct file *fp;
+       struct uio auio, kuio;
+       struct iovec aiov, kiov;
+       struct dirent *dp, *edp;
+       caddr_t dirbuf;
+       int error, readcnt;
+       long loff;
+
+       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);
+       loff = auio.uio_offset = fp->f_offset;
+#      if (BYTE_ORDER != LITTLE_ENDIAN)
+               if (vp->v_mount->mnt_maxsymlinklen <= 0) {
+                       error = VOP_READDIR(vp, &auio, fp->f_cred);
+                       fp->f_offset = auio.uio_offset;
+               } else
+#      endif
+       {
+               kuio = auio;
+               kuio.uio_iov = &kiov;
+               kuio.uio_segflg = UIO_SYSSPACE;
+               kiov.iov_len = uap->count;
+               MALLOC(dirbuf, caddr_t, uap->count, M_TEMP, M_WAITOK);
+               kiov.iov_base = dirbuf;
+               error = VOP_READDIR(vp, &kuio, fp->f_cred);
+               fp->f_offset = kuio.uio_offset;
+               if (error == 0) {
+                       readcnt = uap->count - kuio.uio_resid;
+                       edp = (struct dirent *)&dirbuf[readcnt];
+                       for (dp = (struct dirent *)dirbuf; dp < edp; ) {
+#                              if (BYTE_ORDER == LITTLE_ENDIAN)
+                                       /*
+                                        * The expected low byte of
+                                        * dp->d_namlen is our dp->d_type.
+                                        * The high MBZ byte of dp->d_namlen
+                                        * is our dp->d_namlen.
+                                        */
+                                       dp->d_type = dp->d_namlen;
+                                       dp->d_namlen = 0;
+#                              else
+                                       /*
+                                        * The dp->d_type is the high byte
+                                        * of the expected dp->d_namlen,
+                                        * so must be zero'ed.
+                                        */
+                                       dp->d_type = 0;
+#                              endif
+                               if (dp->d_reclen > 0) {
+                                       dp = (struct dirent *)
+                                           ((char *)dp + dp->d_reclen);
+                               } else {
+                                       error = EIO;
+                                       break;
+                               }
+                       }
+                       if (dp >= edp)
+                               error = uiomove(dirbuf, readcnt, &auio);
+               }
+               FREE(dirbuf, M_TEMP);
+       }
+       VOP_UNLOCK(vp);
        if (error)
        if (error)
-               VOP_ABORTOP(ndp);
-       else
-               error = VOP_RMDIR(ndp);
-       RETURN (error);
+               return (error);
+       error = copyout((caddr_t)&loff, (caddr_t)uap->basep, sizeof(long));
+       *retval = uap->count - auio.uio_resid;
+       return (error);
 }
 }
+#endif
 
 /*
 
 /*
- * 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;
+struct getdirentries_args {
+       int     fd;
+       char    *buf;
+       unsigned count;
+       long    *basep;
+};
+getdirentries(p, uap, retval)
+       struct proc *p;
+       register struct getdirentries_args *uap;
+       int *retval;
 {
 {
-       register struct a {
-               int     fd;
-               char    *buf;
-               unsigned count;
-               long    *basep;
-       } *uap = (struct a *)scp->sc_ap;
        register struct vnode *vp;
        struct file *fp;
        struct uio auio;
        struct iovec aiov;
        register struct vnode *vp;
        struct file *fp;
        struct uio auio;
        struct iovec aiov;
-       off_t off;
-       int error, eofflag;
+       long loff;
+       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 & FREAD) == 0)
        if ((fp->f_flag & FREAD) == 0)
-               RETURN (EBADF);
+               return (EBADF);
        vp = (struct vnode *)fp->f_data;
        vp = (struct vnode *)fp->f_data;
+unionread:
        if (vp->v_type != VDIR)
        if (vp->v_type != VDIR)
-               RETURN (EINVAL);
+               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;
        VOP_LOCK(vp);
        auio.uio_resid = uap->count;
        VOP_LOCK(vp);
-       auio.uio_offset = off = fp->f_offset;
-       error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag);
+       loff = auio.uio_offset = fp->f_offset;
+       error = VOP_READDIR(vp, &auio, fp->f_cred);
        fp->f_offset = auio.uio_offset;
        VOP_UNLOCK(vp);
        if (error)
        fp->f_offset = auio.uio_offset;
        VOP_UNLOCK(vp);
        if (error)
-               RETURN (error);
-       error = copyout((caddr_t)&off, (caddr_t)uap->basep, sizeof(long));
-       scp->sc_retval1 = uap->count - auio.uio_resid;
-       RETURN (error);
+               return (error);
+       if ((uap->count == auio.uio_resid) &&
+           (vp->v_flag & VROOT) &&
+           (vp->v_mount->mnt_flag & MNT_UNION)) {
+               struct vnode *tvp = vp;
+               vp = vp->v_mount->mnt_vnodecovered;
+               VREF(vp);
+               fp->f_data = (caddr_t) vp;
+               fp->f_offset = 0;
+               vrele(tvp);
+               goto unionread;
+       }
+       error = copyout((caddr_t)&loff, (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;
+struct umask_args {
+       int     mask;
+};
+mode_t                         /* XXX */
+umask(p, uap, retval)
+       struct proc *p;
+       struct umask_args *uap;
+       int *retval;
 {
 {
-       register struct a {
-               int     mask;
-       } *uap = (struct a *)scp->sc_ap;
+       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);
 }
 
 /*
  * Void all references to file by ripping underlying filesystem
  * away from vnode.
  */
 }
 
 /*
  * Void all references to file by ripping underlying filesystem
  * away from vnode.
  */
-revoke(scp)
-       register struct syscontext *scp;
+struct revoke_args {
+       char    *fname;
+};
+/* ARGSUSED */
+revoke(p, uap, retval)
+       struct proc *p;
+       register struct revoke_args *uap;
+       int *retval;
 {
 {
-       struct a {
-               char    *fname;
-       } *uap = (struct a *)scp->sc_ap;
-       register struct nameidata *ndp = &scp->sc_nd;
        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;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       if (error = namei(ndp))
-               RETURN (error);
-       vp = ndp->ni_vp;
+       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 (vp->v_type != VCHR && vp->v_type != VBLK) {
                error = EINVAL;
                goto out;
        }
-       if (error = VOP_GETATTR(vp, &vattr, scp->sc_cred))
+       if (error = VOP_GETATTR(vp, &vattr, p->p_ucred, p))
                goto out;
                goto out;
-       if (scp->sc_uid != vattr.va_uid ||
-           (error = suser(scp->sc_cred, &scp->sc_acflag)))
+       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);
                goto out;
        if (vp->v_usecount > 1 || (vp->v_flag & VALIASED))
                vgoneall(vp);
 out:
        vrele(vp);
-       RETURN (error);
+       return (error);
 }
 
 }
 
-getvnode(ofile, fdes, fpp)
-       struct file *ofile[];
+/*
+ * 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);
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.