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 9f40c9a..cf61962 100644 (file)
--- a/usr/src/sys/kern/vfs_syscalls.c
+++ b/usr/src/sys/kern/vfs_syscalls.c
@@ -4,26 +4,35 @@
  *
  * %sccs.include.redist.c%
  *
  *
  * %sccs.include.redist.c%
  *

- *     @(#)vfs_syscalls.c      7.76 (Berkeley) %G%
+ *     @(#)vfs_syscalls.c      7.109 (Berkeley) %G%

  */
 
  */
 

-#include "param.h"
-#include "systm.h"
-#include "namei.h"
-#include "filedesc.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"
-
-/* NEEDSWORK: debugging */
-#define CURCOUNT (curproc?curproc->p_spare[2]:0)
-#define CHECKPOINT int oldrefcount=CURCOUNT;
-#define CHECKCHECK(F) if (oldrefcount!=CURCOUNT) { printf("REFCOUNT: %s, old=%d, new=%d\n", (F), oldrefcount, CURCOUNT); }
+#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


@@ -32,18 +41,18 @@
 /*
  * Mount system call.
  */
 /*
  * Mount system call.
  */

+struct mount_args {
+       int     type;
+       char    *dir;
+       int     flags;
+       caddr_t data;
+};

 /* ARGSUSED */
 mount(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 mount(p, uap, retval)
        struct proc *p;

-       register struct args {
-               int     type;
-               char    *dir;
-               int     flags;
-               caddr_t data;
-       } *uap;
+       register struct mount_args *uap;

        int *retval;
 {
        int *retval;
 {

-       register struct nameidata *ndp;

        register struct vnode *vp;
        register struct mount *mp;
        int error, flag;
        register struct vnode *vp;
        register struct mount *mp;
        int error, flag;


@@ -57,38 +66,37 @@ mount(p, uap, retval)
        /*
         * Get vnode to be covered
         */
        /*
         * Get vnode to be covered
         */

-       ndp = &nd;
-       ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->dir;
-       if (error = namei(ndp, p))
+       NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->dir, p);
+       if (error = namei(&nd))

                return (error);
                return (error);

-       vp = ndp->ni_vp;
+       vp = nd.ni_vp;

        if (uap->flags & MNT_UPDATE) {
                if ((vp->v_flag & VROOT) == 0) {
                        vput(vp);
                        return (EINVAL);
                }
                mp = vp->v_mount;
        if (uap->flags & MNT_UPDATE) {
                if ((vp->v_flag & VROOT) == 0) {
                        vput(vp);
                        return (EINVAL);
                }
                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->mnt_flag & MNT_RDONLY) == 0 &&
-                   (uap->flags & MNT_RDONLY) != 0) {
+               if ((uap->flags & MNT_RELOAD) &&
+                   ((mp->mnt_flag & MNT_RDONLY) == 0)) {

                        vput(vp);
                        return (EOPNOTSUPP);    /* Needs translation */
                }
                        vput(vp);
                        return (EOPNOTSUPP);    /* Needs translation */
                }

-               flag = mp->mnt_flag;
-               mp->mnt_flag |= MNT_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);
                return (EBUSY);
        }
                vput(vp);
                return (EBUSY);
        }

+       if (error = vinvalbuf(vp, V_SAVE, p->p_ucred, p, 0, 0))
+               return (error);

        if (vp->v_type != VDIR) {
                vput(vp);
                return (ENOTDIR);
        if (vp->v_type != VDIR) {
                vput(vp);
                return (ENOTDIR);


@@ -104,9 +112,8 @@ mount(p, uap, retval)
         */
        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);

+       bzero((char *)mp, (u_long)sizeof(struct mount));

        mp->mnt_op = vfssw[uap->type];
        mp->mnt_op = vfssw[uap->type];

-       mp->mnt_flag = 0;
-       mp->mnt_mounth = NULLVP;

        if (error = vfs_lock(mp)) {
                free((caddr_t)mp, M_MOUNT);
                vput(vp);
        if (error = vfs_lock(mp)) {
                free((caddr_t)mp, M_MOUNT);
                vput(vp);


@@ -126,31 +133,22 @@ update:
         */
        if (uap->flags & MNT_RDONLY)
                mp->mnt_flag |= MNT_RDONLY;
         */
        if (uap->flags & MNT_RDONLY)
                mp->mnt_flag |= MNT_RDONLY;

-       else
-               mp->mnt_flag &= ~MNT_RDONLY;
-       if (uap->flags & MNT_NOSUID)
-               mp->mnt_flag |= MNT_NOSUID;
-       else
-               mp->mnt_flag &= ~MNT_NOSUID;
-       if (uap->flags & MNT_NOEXEC)
-               mp->mnt_flag |= MNT_NOEXEC;
-       else
-               mp->mnt_flag &= ~MNT_NOEXEC;
-       if (uap->flags & MNT_NODEV)
-               mp->mnt_flag |= MNT_NODEV;
-       else
-               mp->mnt_flag &= ~MNT_NODEV;
-       if (uap->flags & MNT_SYNCHRONOUS)
-               mp->mnt_flag |= MNT_SYNCHRONOUS;
-       else
-               mp->mnt_flag &= ~MNT_SYNCHRONOUS;
+       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, p);
+       error = VFS_MOUNT(mp, uap->dir, uap->data, &nd, p);

        if (mp->mnt_flag & MNT_UPDATE) {
        if (mp->mnt_flag & MNT_UPDATE) {

-               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)
                        mp->mnt_flag = flag;
                return (error);
                if (error)
                        mp->mnt_flag = flag;
                return (error);


@@ -181,17 +179,17 @@ 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).
  */

+struct unmount_args {
+       char    *pathp;
+       int     flags;
+};

 /* ARGSUSED */
 unmount(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 unmount(p, uap, retval)
        struct proc *p;

-       register struct args {
-               char    *pathp;
-               int     flags;
-       } *uap;
+       register struct unmount_args *uap;

        int *retval;
 {
        register struct vnode *vp;
        int *retval;
 {
        register struct vnode *vp;

-       register struct nameidata *ndp;

        struct mount *mp;
        int error;
        struct nameidata nd;
        struct mount *mp;
        int error;
        struct nameidata nd;


@@ -202,13 +200,10 @@ unmount(p, uap, retval)
        if (error = suser(p->p_ucred, &p->p_acflag))
                return (error);
 
        if (error = suser(p->p_ucred, &p->p_acflag))
                return (error);
 

-       ndp = &nd;
-       ndp->ni_nameiop = LOOKUP | LOCKLEAF | FOLLOW;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->pathp;
-       if (error = namei(ndp, p))
+       NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->pathp, p);
+       if (error = namei(&nd))

                return (error);
                return (error);

-       vp = ndp->ni_vp;
+       vp = nd.ni_vp;

        /*
         * Must be the root of the filesystem
         */
        /*
         * Must be the root of the filesystem
         */


@@ -241,7 +236,8 @@ dounmount(mp, flags, p)
 
        vnode_pager_umount(mp); /* release cached vnodes */
        cache_purgevfs(mp);     /* remove cache entries for this file sys */
 
        vnode_pager_umount(mp); /* release cached vnodes */
        cache_purgevfs(mp);     /* remove cache entries for this file sys */

-       if ((error = VFS_SYNC(mp, MNT_WAIT)) == 0 || (flags & MNT_FORCE))
+       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);
                error = VFS_UNMOUNT(mp, flags, p);
        mp->mnt_flag &= ~MNT_UNMOUNT;
        vfs_unbusy(mp);


@@ -250,6 +246,8 @@ dounmount(mp, flags, p)
        } else {
                vrele(coveredvp);
                vfs_remove(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);


@@ -259,10 +257,18 @@ dounmount(mp, flags, p)
  * 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 */
 sync(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 sync(p, uap, retval)
        struct proc *p;

-       void *uap;
+       struct sync_args *uap;

        int *retval;
 {
        register struct mount *mp;
        int *retval;
 {
        register struct mount *mp;


@@ -276,73 +282,71 @@ sync(p, uap, retval)
                 */
                if ((mp->mnt_flag & (MNT_MLOCK|MNT_RDONLY|MNT_MPBUSY)) == 0 &&
                    !vfs_busy(mp)) {
                 */
                if ((mp->mnt_flag & (MNT_MLOCK|MNT_RDONLY|MNT_MPBUSY)) == 0 &&
                    !vfs_busy(mp)) {

-                       VFS_SYNC(mp, MNT_NOWAIT);
+                       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);
                        omp = mp;
                        mp = mp->mnt_next;
                        vfs_unbusy(omp);
                } else
                        mp = mp->mnt_next;
        } while (mp != rootfs);

+#ifdef DIAGNOSTIC
+       if (syncprt)
+               vfs_bufstats();
+#endif /* DIAGNOSTIC */

        return (0);
 }
 
 /*
  * Operate on filesystem quotas.
  */
        return (0);
 }
 
 /*
  * Operate on filesystem quotas.
  */

+struct quotactl_args {
+       char *path;
+       int cmd;
+       int uid;
+       caddr_t arg;
+};

 /* ARGSUSED */
 quotactl(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 quotactl(p, uap, retval)
        struct proc *p;

-       register struct args {
-               char *path;
-               int cmd;
-               int uid;
-               caddr_t arg;
-       } *uap;
+       register struct quotactl_args *uap;

        int *retval;
 {
        register struct mount *mp;
        int *retval;
 {
        register struct mount *mp;

-       register struct nameidata *ndp;

        int error;
        struct nameidata nd;
 
        int error;
        struct nameidata nd;
 

-       ndp = &nd;
-       ndp->ni_nameiop = LOOKUP | FOLLOW;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->path;
-       if (error = namei(ndp, p))
+       NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
+       if (error = namei(&nd))

                return (error);
                return (error);

-       mp = ndp->ni_vp->v_mount;
-       vrele(ndp->ni_vp);
+       mp = nd.ni_vp->v_mount;
+       vrele(nd.ni_vp);

        return (VFS_QUOTACTL(mp, uap->cmd, uap->uid, uap->arg, p));
 }
 
 /*
  * Get filesystem statistics.
  */
        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;
 /* ARGSUSED */
 statfs(p, uap, retval)
        struct proc *p;

-       register struct args {
-               char *path;
-               struct statfs *buf;
-       } *uap;
+       register struct statfs_args *uap;

        int *retval;
 {
        register struct mount *mp;
        int *retval;
 {
        register struct mount *mp;

-       register struct nameidata *ndp;

        register struct statfs *sp;
        int error;
        struct nameidata nd;
 
        register struct statfs *sp;
        int error;
        struct nameidata nd;
 

-       ndp = &nd;
-       ndp->ni_nameiop = LOOKUP | FOLLOW;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->path;
-       if (error = namei(ndp, p))
+       NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p);
+       if (error = namei(&nd))

                return (error);
                return (error);

-       mp = ndp->ni_vp->v_mount;
+       mp = nd.ni_vp->v_mount;

        sp = &mp->mnt_stat;
        sp = &mp->mnt_stat;

-       vrele(ndp->ni_vp);
+       vrele(nd.ni_vp);

        if (error = VFS_STATFS(mp, sp, p))
                return (error);
        sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
        if (error = VFS_STATFS(mp, sp, p))
                return (error);
        sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;


@@ -352,13 +356,14 @@ statfs(p, uap, retval)
 /*
  * Get filesystem statistics.
  */
 /*
  * Get filesystem statistics.
  */

+struct fstatfs_args {
+       int fd;
+       struct statfs *buf;
+};

 /* ARGSUSED */
 fstatfs(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 fstatfs(p, uap, retval)
        struct proc *p;

-       register struct args {
-               int fd;
-               struct statfs *buf;
-       } *uap;
+       register struct fstatfs_args *uap;

        int *retval;
 {
        struct file *fp;
        int *retval;
 {
        struct file *fp;


@@ -379,13 +384,14 @@ fstatfs(p, uap, retval)
 /*
  * Get statistics on all filesystems.
  */
 /*
  * Get statistics on all filesystems.
  */

+struct getfsstat_args {
+       struct statfs *buf;
+       long bufsize;
+       int flags;
+};

 getfsstat(p, uap, retval)
        struct proc *p;
 getfsstat(p, uap, retval)
        struct proc *p;

-       register struct args {
-               struct statfs *buf;
-               long bufsize;
-               int flags;
-       } *uap;
+       register struct getfsstat_args *uap;

        int *retval;
 {
        register struct mount *mp;
        int *retval;
 {
        register struct mount *mp;


@@ -429,12 +435,13 @@ getfsstat(p, uap, retval)
 /*
  * Change current working directory to a given file descriptor.
  */
 /*
  * Change current working directory to a given file descriptor.
  */

+struct fchdir_args {
+       int     fd;
+};

 /* ARGSUSED */
 fchdir(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 fchdir(p, uap, retval)
        struct proc *p;

-       struct args {
-               int     fd;
-       } *uap;
+       struct fchdir_args *uap;

        int *retval;
 {
        register struct filedesc *fdp = p->p_fd;
        int *retval;
 {
        register struct filedesc *fdp = p->p_fd;


@@ -462,57 +469,51 @@ fchdir(p, uap, retval)
 /*
  * Change current working directory (``.'').
  */
 /*
  * Change current working directory (``.'').
  */

+struct chdir_args {
+       char    *fname;
+};

 /* ARGSUSED */
 chdir(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 chdir(p, uap, retval)
        struct proc *p;

-       struct args {
-               char    *fname;
-       } *uap;
+       struct chdir_args *uap;

        int *retval;
 {
        int *retval;
 {

-       register struct nameidata *ndp;

        register struct filedesc *fdp = p->p_fd;
        int error;
        struct nameidata nd;
 
        register struct filedesc *fdp = p->p_fd;
        int error;
        struct nameidata nd;
 

-       ndp = &nd;
-       ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       if (error = chdirec(ndp, p))
+       NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->fname, p);
+       if (error = chdirec(&nd, p))

                return (error);
        vrele(fdp->fd_cdir);
                return (error);
        vrele(fdp->fd_cdir);

-       fdp->fd_cdir = ndp->ni_vp;
+       fdp->fd_cdir = nd.ni_vp;

        return (0);
 }
 
 /*
  * Change notion of root (``/'') directory.
  */
        return (0);
 }
 
 /*
  * Change notion of root (``/'') directory.
  */

+struct chroot_args {
+       char    *fname;
+};

 /* ARGSUSED */
 chroot(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 chroot(p, uap, retval)
        struct proc *p;

-       struct args {
-               char    *fname;
-       } *uap;
+       struct chroot_args *uap;

        int *retval;
 {
        int *retval;
 {

-       register struct nameidata *ndp;

        register struct filedesc *fdp = p->p_fd;
        int error;
        struct nameidata nd;
 
        if (error = suser(p->p_ucred, &p->p_acflag))
                return (error);
        register struct filedesc *fdp = p->p_fd;
        int error;
        struct nameidata nd;
 
        if (error = suser(p->p_ucred, &p->p_acflag))
                return (error);

-       ndp = &nd;
-       ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       if (error = chdirec(ndp, p))
+       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);
                return (error);
        if (fdp->fd_rdir != NULL)
                vrele(fdp->fd_rdir);

-       fdp->fd_rdir = ndp->ni_vp;
+       fdp->fd_rdir = nd.ni_vp;

        return (0);
 }
 
        return (0);
 }
 


@@ -520,13 +521,13 @@ chroot(p, uap, retval)
  * Common routine for chroot and chdir.
  */
 chdirec(ndp, p)
  * Common routine for chroot and chdir.
  */
 chdirec(ndp, p)

-       struct nameidata *ndp;
+       register struct nameidata *ndp;

        struct proc *p;
 {
        struct vnode *vp;
        int error;
 
        struct proc *p;
 {
        struct vnode *vp;
        int error;
 

-       if (error = namei(ndp, p))
+       if (error = namei(ndp))

                return (error);
        vp = ndp->ni_vp;
        if (vp->v_type != VDIR)
                return (error);
        vp = ndp->ni_vp;
        if (vp->v_type != VDIR)


@@ -544,16 +545,16 @@ chdirec(ndp, p)
  * 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.
  */

+struct open_args {
+       char    *fname;
+       int     mode;
+       int     crtmode;
+};

 open(p, uap, retval)
        struct proc *p;
 open(p, uap, retval)
        struct proc *p;

-       register struct args {
-               char    *fname;
-               int     mode;
-               int     crtmode;
-       } *uap;
+       register struct open_args *uap;

        int *retval;
 {
        int *retval;
 {

-       struct nameidata *ndp;

        register struct filedesc *fdp = p->p_fd;
        register struct file *fp;
        register struct vnode *vp;
        register struct filedesc *fdp = p->p_fd;
        register struct file *fp;
        register struct vnode *vp;


@@ -569,15 +570,14 @@ open(p, uap, retval)
        fp = nfp;
        fmode = FFLAGS(uap->mode);
        cmode = ((uap->crtmode &~ fdp->fd_cmask) & 07777) &~ S_ISVTX;
        fp = nfp;
        fmode = FFLAGS(uap->mode);
        cmode = ((uap->crtmode &~ fdp->fd_cmask) & 07777) &~ S_ISVTX;

-       ndp = &nd;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
+       NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->fname, p);

        p->p_dupfd = -indx - 1;                 /* XXX check for fdopen */
        p->p_dupfd = -indx - 1;                 /* XXX check for fdopen */

-       if (error = vn_open(ndp, p, fmode, cmode)) {
+       if (error = vn_open(&nd, fmode, cmode)) {

                ffree(fp);
                ffree(fp);

-               if (error == ENODEV &&          /* XXX from fdopen */
-                   p->p_dupfd >= 0 &&
-                   (error = dupfdopen(fdp, indx, p->p_dupfd, fmode)) == 0) {
+               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);
                }
                        *retval = indx;
                        return (0);
                }


@@ -586,8 +586,12 @@ open(p, uap, retval)
                fdp->fd_ofiles[indx] = NULL;
                return (error);
        }
                fdp->fd_ofiles[indx] = NULL;
                return (error);
        }

-       vp = ndp->ni_vp;
+       p->p_dupfd = 0;
+       vp = nd.ni_vp;

        fp->f_flag = fmode & FMASK;
        fp->f_flag = fmode & FMASK;

+       fp->f_type = DTYPE_VNODE;
+       fp->f_ops = &vnops;
+       fp->f_data = (caddr_t)vp;

        if (fmode & (O_EXLOCK | O_SHLOCK)) {
                lf.l_whence = SEEK_SET;
                lf.l_start = 0;
        if (fmode & (O_EXLOCK | O_SHLOCK)) {
                lf.l_whence = SEEK_SET;
                lf.l_start = 0;


@@ -609,9 +613,6 @@ open(p, uap, retval)
                fp->f_flag |= FHASLOCK;
        }
        VOP_UNLOCK(vp);
                fp->f_flag |= FHASLOCK;
        }
        VOP_UNLOCK(vp);

-       fp->f_type = DTYPE_VNODE;
-       fp->f_ops = &vnops;
-       fp->f_data = (caddr_t)vp;

        *retval = indx;
        return (0);
 }
        *retval = indx;
        return (0);
 }


@@ -620,19 +621,16 @@ open(p, uap, retval)
 /*
  * Creat system call.
  */
 /*
  * Creat system call.
  */

+struct ocreat_args {
+       char    *fname;
+       int     fmode;
+};

 ocreat(p, uap, retval)
        struct proc *p;
 ocreat(p, uap, retval)
        struct proc *p;

-       register struct args {
-               char    *fname;
-               int     fmode;
-       } *uap;
+       register struct ocreat_args *uap;

        int *retval;
 {
        int *retval;
 {

-       struct args {
-               char    *fname;
-               int     mode;
-               int     crtmode;
-       } openuap;
+       struct open_args openuap;

 
        openuap.fname = uap->fname;
        openuap.crtmode = uap->fmode;
 
        openuap.fname = uap->fname;
        openuap.crtmode = uap->fmode;


@@ -644,32 +642,29 @@ ocreat(p, uap, retval)
 /*
  * Mknod system call.
  */
 /*
  * Mknod system call.
  */

+struct mknod_args {
+       char    *fname;
+       int     fmode;
+       int     dev;
+};

 /* ARGSUSED */
 mknod(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 mknod(p, uap, retval)
        struct proc *p;

-       register struct args {
-               char    *fname;
-               int     fmode;
-               int     dev;
-       } *uap;
+       register struct mknod_args *uap;

        int *retval;
 {
        int *retval;
 {

-       register struct nameidata *ndp;

        register struct vnode *vp;
        struct vattr vattr;
        int error;
        struct nameidata nd;
 
        register struct vnode *vp;
        struct vattr vattr;
        int error;
        struct nameidata nd;
 

-       CHECKPOINT;
+       CHECKPOINTREF;

        if (error = suser(p->p_ucred, &p->p_acflag))
                return (error);
        if (error = suser(p->p_ucred, &p->p_acflag))
                return (error);

-       ndp = &nd;
-       ndp->ni_nameiop = CREATE | LOCKPARENT;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       if (error = namei(ndp, p))
+       NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, uap->fname, p);
+       if (error = namei(&nd))

                return (error);
                return (error);

-       vp = ndp->ni_vp;
+       vp = nd.ni_vp;

        if (vp != NULL) {
                error = EEXIST;
                goto out;
        if (vp != NULL) {
                error = EEXIST;
                goto out;


@@ -694,34 +689,34 @@ mknod(p, uap, retval)
        vattr.va_rdev = uap->dev;
 out:
        if (!error) {
        vattr.va_rdev = uap->dev;
 out:
        if (!error) {

-               LEASE_CHECK(ndp->ni_dvp, p, p->p_ucred, LEASE_WRITE);
-               error = VOP_MKNOD(ndp->ni_dvp, &ndp->ni_vp, &ndp->ni_cnd, &vattr);
+               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 {
        } else {

-               VOP_ABORTOP(ndp->ni_dvp, &ndp->ni_cnd);
-               if (ndp->ni_dvp == vp)
-                       vrele(ndp->ni_dvp);
+               VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
+               if (nd.ni_dvp == vp)
+                       vrele(nd.ni_dvp);

                else
                else

-                       vput(ndp->ni_dvp);
+                       vput(nd.ni_dvp);

                if (vp)
                        vrele(vp);
        }
                if (vp)
                        vrele(vp);
        }

-       CHECKCHECK("mknod");
+       CHECKREFS("mknod");

        return (error);
 }
 
 /*
  * Mkfifo system call.
  */
        return (error);
 }
 
 /*
  * Mkfifo system call.
  */

+struct mkfifo_args {
+       char    *fname;
+       int     fmode;
+};

 /* ARGSUSED */
 mkfifo(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 mkfifo(p, uap, retval)
        struct proc *p;

-       register struct args {
-               char    *fname;
-               int     fmode;
-       } *uap;
+       register struct mkfifo_args *uap;

        int *retval;
 {
        int *retval;
 {

-       register struct nameidata *ndp;

        struct vattr vattr;
        int error;
        struct nameidata nd;
        struct vattr vattr;
        int error;
        struct nameidata nd;


@@ -729,161 +724,150 @@ mkfifo(p, uap, retval)
 #ifndef FIFO
        return (EOPNOTSUPP);
 #else
 #ifndef FIFO
        return (EOPNOTSUPP);
 #else

-       ndp = &nd;
-       ndp->ni_nameiop = CREATE | LOCKPARENT;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       if (error = namei(ndp, p))
+       NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, uap->fname, p);
+       if (error = namei(&nd))

                return (error);
                return (error);

-       if (ndp->ni_vp != NULL) {
-               VOP_ABORTOP(ndp->ni_dvp, &ndp->ni_cnd);
-               if (ndp->ni_dvp == ndp->ni_vp)
-                       vrele(ndp->ni_dvp);
+       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
                else

-                       vput(ndp->ni_dvp);
-               vrele(ndp->ni_vp);
+                       vput(nd.ni_dvp);
+               vrele(nd.ni_vp);

                return (EEXIST);
        }
        VATTR_NULL(&vattr);
        vattr.va_type = VFIFO;
        vattr.va_mode = (uap->fmode & 07777) &~ p->p_fd->fd_cmask;
                return (EEXIST);
        }
        VATTR_NULL(&vattr);
        vattr.va_type = VFIFO;
        vattr.va_mode = (uap->fmode & 07777) &~ p->p_fd->fd_cmask;

-       LEASE_CHECK(ndp->ni_dvp, p, p->p_ucred, LEASE_WRITE);
-       return (VOP_MKNOD(ndp->ni_dvp, &ndp->ni_vp, &ndp->ni_cnd, &vattr));
+       LEASE_CHECK(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
+       return (VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr));

 #endif /* FIFO */
 }
 
 /*
  * Link system call.
  */
 #endif /* FIFO */
 }
 
 /*
  * Link system call.
  */

+struct link_args {
+       char    *target;
+       char    *linkname;
+};

 /* ARGSUSED */
 link(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 link(p, uap, retval)
        struct proc *p;

-       register struct args {
-               char    *target;
-               char    *linkname;
-       } *uap;
+       register struct link_args *uap;

        int *retval;
 {
        int *retval;
 {

-       register struct nameidata *ndp;

        register struct vnode *vp, *xp;
        int error;
        struct nameidata nd;
 
        register struct vnode *vp, *xp;
        int error;
        struct nameidata nd;
 

-       CHECKPOINT;
-       ndp = &nd;
-       ndp->ni_nameiop = LOOKUP | FOLLOW;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->target;
-       if (error = namei(ndp, p))
+       CHECKPOINTREF;
+       NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->target, p);
+       if (error = namei(&nd))

                return (error);
                return (error);

-       vp = ndp->ni_vp;
+       vp = nd.ni_vp;

        if (vp->v_type == VDIR &&
            (error = suser(p->p_ucred, &p->p_acflag)))
                goto out1;
        if (vp->v_type == VDIR &&
            (error = suser(p->p_ucred, &p->p_acflag)))
                goto out1;

-       ndp->ni_nameiop = CREATE | LOCKPARENT;
-       ndp->ni_dirp = (caddr_t)uap->linkname;
-       if (error = namei(ndp, p))
+       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:
        if (!error) {
                LEASE_CHECK(xp, p, p->p_ucred, LEASE_WRITE);
                LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
 out:
        if (!error) {
                LEASE_CHECK(xp, p, p->p_ucred, LEASE_WRITE);
                LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);

-               error = VOP_LINK(vp, ndp->ni_dvp, &ndp->ni_cnd);
+               error = VOP_LINK(nd.ni_dvp, vp, &nd.ni_cnd);

        } else {
        } else {

-               VOP_ABORTOP(ndp->ni_dvp, &ndp->ni_cnd);
-               if (ndp->ni_dvp == ndp->ni_vp)
-                       vrele(ndp->ni_dvp);
+               VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
+               if (nd.ni_dvp == nd.ni_vp)
+                       vrele(nd.ni_dvp);

                else
                else

-                       vput(ndp->ni_dvp);
-               if (ndp->ni_vp)
-                       vrele(ndp->ni_vp);
+                       vput(nd.ni_dvp);
+               if (nd.ni_vp)
+                       vrele(nd.ni_vp);

        }
 out1:
        vrele(vp);
        }
 out1:
        vrele(vp);

-       CHECKCHECK("link");
+       CHECKREFS("link");

        return (error);
 }
 
 /*
  * Make a symbolic link.
  */
        return (error);
 }
 
 /*
  * Make a symbolic link.
  */

+struct symlink_args {
+       char    *target;
+       char    *linkname;
+};

 /* ARGSUSED */
 symlink(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 symlink(p, uap, retval)
        struct proc *p;

-       register struct args {
-               char    *target;
-               char    *linkname;
-       } *uap;
+       register struct symlink_args *uap;

        int *retval;
 {
        int *retval;
 {

-       register struct nameidata *ndp;

        struct vattr vattr;
        char *target;
        int error;
        struct nameidata nd;
 
        struct vattr vattr;
        char *target;
        int error;
        struct nameidata nd;
 

-       CHECKPOINT;
-       ndp = &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))
                goto out;
        MALLOC(target, char *, MAXPATHLEN, M_NAMEI, M_WAITOK);
        if (error = copyinstr(uap->target, target, MAXPATHLEN, (u_int *)0))
                goto out;

-       ndp->ni_nameiop = CREATE | LOCKPARENT;
-       if (error = namei(ndp, p))
+       NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, uap->linkname, p);
+       if (error = namei(&nd))

                goto out;
                goto out;

-       if (ndp->ni_vp) {
-               VOP_ABORTOP(ndp->ni_dvp, &ndp->ni_cnd);
-               if (ndp->ni_dvp == ndp->ni_vp)
-                       vrele(ndp->ni_dvp);
+       if (nd.ni_vp) {
+               VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
+               if (nd.ni_dvp == nd.ni_vp)
+                       vrele(nd.ni_dvp);

                else
                else

-                       vput(ndp->ni_dvp);
-               vrele(ndp->ni_vp);
+                       vput(nd.ni_dvp);
+               vrele(nd.ni_vp);

                error = EEXIST;
                goto out;
        }
        VATTR_NULL(&vattr);
        vattr.va_mode = 0777 &~ p->p_fd->fd_cmask;
                error = EEXIST;
                goto out;
        }
        VATTR_NULL(&vattr);
        vattr.va_mode = 0777 &~ p->p_fd->fd_cmask;

-       LEASE_CHECK(ndp->ni_dvp, p, p->p_ucred, LEASE_WRITE);
-       error = VOP_SYMLINK(ndp->ni_dvp, &ndp->ni_vp, &ndp->ni_cnd, &vattr, target);
+       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:
        FREE(target, M_NAMEI);
 out:
        FREE(target, M_NAMEI);

-       CHECKCHECK("symlink");
+       CHECKREFS("symlink");

        return (error);
 }
 
 /*
  * Delete a name from the filesystem.
  */
        return (error);
 }
 
 /*
  * Delete a name from the filesystem.
  */

+struct unlink_args {
+       char    *name;
+};

 /* ARGSUSED */
 unlink(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 unlink(p, uap, retval)
        struct proc *p;

-       struct args {
-               char    *fname;
-       } *uap;
+       struct unlink_args *uap;

        int *retval;
 {
        int *retval;
 {

-       register struct nameidata *ndp;

        register struct vnode *vp;
        int error;
        struct nameidata nd;
 
        register struct vnode *vp;
        int error;
        struct nameidata nd;
 

-       CHECKPOINT;
-       ndp = &nd;
-       ndp->ni_nameiop = DELETE | LOCKPARENT | LOCKLEAF;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       if (error = namei(ndp, p))
+       CHECKPOINTREF;
+       NDINIT(&nd, DELETE, LOCKPARENT, UIO_USERSPACE, uap->name, p);
+       if (error = namei(&nd))

                return (error);
                return (error);

-       vp = ndp->ni_vp;
+       vp = nd.ni_vp;
+       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
+       VOP_LOCK(vp);

        if (vp->v_type == VDIR &&
            (error = suser(p->p_ucred, &p->p_acflag)))
                goto out;
        if (vp->v_type == VDIR &&
            (error = suser(p->p_ucred, &p->p_acflag)))
                goto out;


@@ -897,32 +881,34 @@ unlink(p, uap, retval)
        (void) vnode_pager_uncache(vp);
 out:
        if (!error) {
        (void) vnode_pager_uncache(vp);
 out:
        if (!error) {

-               LEASE_CHECK(ndp->ni_dvp, p, p->p_ucred, LEASE_WRITE);
-               LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
-               error = VOP_REMOVE(ndp->ni_dvp, ndp->ni_vp, &ndp->ni_cnd);
+               LEASE_CHECK(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
+               error = VOP_REMOVE(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd);

        } else {
        } else {

-               VOP_ABORTOP(ndp->ni_dvp, &ndp->ni_cnd);
-               if (ndp->ni_dvp == vp)
-                       vrele(ndp->ni_dvp);
+               VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
+               if (nd.ni_dvp == vp)
+                       vrele(nd.ni_dvp);

                else
                else

-                       vput(ndp->ni_dvp);
+                       vput(nd.ni_dvp);

                vput(vp);
        }
                vput(vp);
        }

-       CHECKCHECK("unlink");
+       CHECKREFS("unlink");

        return (error);
 }
 
        return (error);
 }
 

+struct __lseek_args {
+       int     fdes;
+       int     pad;
+       off_t   off;
+       int     sbase;
+};
+

 /*
  * Seek system call.
  */
 /*
  * Seek system call.
  */

-lseek(p, uap, retval)
+__lseek(p, uap, retval)

        struct proc *p;
        struct proc *p;

-       register struct args {
-               int     fdes;
-               off_t   off;
-               int     sbase;
-       } *uap;
-       off_t *retval;
+       register struct __lseek_args *uap;
+       int *retval;

 {
        struct ucred *cred = p->p_ucred;
        register struct filedesc *fdp = p->p_fd;
 {
        struct ucred *cred = p->p_ucred;
        register struct filedesc *fdp = p->p_fd;


@@ -955,39 +941,63 @@ lseek(p, uap, retval)
        default:
                return (EINVAL);
        }
        default:
                return (EINVAL);
        }

-       *retval = fp->f_offset;
+       *(off_t *)retval = fp->f_offset;

        return (0);
 }
 
        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);
+}
+

 /*
  * Check access permissions.
  */
 /*
  * Check access permissions.
  */

+struct saccess_args {
+       char    *fname;
+       int     fmode;
+};

 /* ARGSUSED */
 saccess(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 saccess(p, uap, retval)
        struct proc *p;

-       register struct args {
-               char    *fname;
-               int     fmode;
-       } *uap;
+       register struct saccess_args *uap;

        int *retval;
 {
        int *retval;
 {

-       register struct nameidata *ndp;

        register struct ucred *cred = p->p_ucred;
        register struct vnode *vp;
        int error, mode, svuid, svgid;
        struct nameidata nd;
 
        register struct ucred *cred = p->p_ucred;
        register struct vnode *vp;
        int error, mode, svuid, svgid;
        struct nameidata nd;
 

-       ndp = &nd;

        svuid = cred->cr_uid;
        svgid = cred->cr_groups[0];
        cred->cr_uid = p->p_cred->p_ruid;
        cred->cr_groups[0] = p->p_cred->p_rgid;
        svuid = cred->cr_uid;
        svgid = cred->cr_groups[0];
        cred->cr_uid = p->p_cred->p_ruid;
        cred->cr_groups[0] = p->p_cred->p_rgid;

-       ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       if (error = namei(ndp, p))
+       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
         */


@@ -1009,35 +1019,35 @@ out1:
        return (error);
 }
 
        return (error);
 }
 

+#if defined(COMPAT_43) || defined(COMPAT_SUNOS)

 /*
  * Stat system call.
  * This version follows links.
  */
 /*
  * Stat system call.
  * This version follows links.
  */

+struct ostat_args {
+       char    *fname;
+       struct ostat *ub;
+};

 /* ARGSUSED */
 /* ARGSUSED */

-stat(p, uap, retval)
+ostat(p, uap, retval)

        struct proc *p;
        struct proc *p;

-       register struct args {
-               char    *fname;
-               struct stat *ub;
-       } *uap;
+       register struct ostat_args *uap;

        int *retval;
 {
        int *retval;
 {

-       register struct nameidata *ndp;

        struct stat sb;
        struct stat sb;

+       struct ostat osb;

        int error;
        struct nameidata nd;
 
        int error;
        struct nameidata nd;
 

-       ndp = &nd;
-       ndp->ni_nameiop = LOOKUP | LOCKLEAF | FOLLOW;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       if (error = namei(ndp, p))
+       NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->fname, p);
+       if (error = namei(&nd))

                return (error);
                return (error);

-       error = vn_stat(ndp->ni_vp, &sb, p);
-       vput(ndp->ni_vp);
+       error = vn_stat(nd.ni_vp, &sb, p);
+       vput(nd.ni_vp);

        if (error)
                return (error);
        if (error)
                return (error);

-       error = copyout((caddr_t)&sb, (caddr_t)uap->ub, sizeof (sb));
+       cvtstat(&sb, &osb);
+       error = copyout((caddr_t)&osb, (caddr_t)uap->ub, sizeof (osb));

        return (error);
 }
 
        return (error);
 }
 


@@ -1045,30 +1055,146 @@ stat(p, uap, retval)
  * Lstat system call.
  * This version does not follow links.
  */
  * Lstat system call.
  * This version does not follow links.
  */

+struct olstat_args {
+       char    *fname;
+       struct ostat *ub;
+};

 /* ARGSUSED */
 /* ARGSUSED */

-lstat(p, uap, retval)
+olstat(p, uap, retval)

        struct proc *p;
        struct proc *p;

-       register struct args {
-               char    *fname;
-               struct stat *ub;
-       } *uap;
+       register struct olstat_args *uap;

        int *retval;
 {
        int *retval;
 {

-       register struct nameidata *ndp;

        struct stat sb;
        struct stat sb;

+       struct ostat osb;

        int error;
        struct nameidata nd;
 
        int error;
        struct nameidata nd;
 

-       ndp = &nd;
-       ndp->ni_nameiop = LOOKUP | LOCKLEAF | NOFOLLOW;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       if (error = namei(ndp, p))
+       NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF, UIO_USERSPACE, uap->fname, p);
+       if (error = namei(&nd))

                return (error);
                return (error);

-       error = vn_stat(ndp->ni_vp, &sb, p);
-       vput(ndp->ni_vp);
+       error = vn_stat(nd.ni_vp, &sb, p);
+       vput(nd.ni_vp);

        if (error)
                return (error);
        if (error)
                return (error);

+       cvtstat(&sb, &osb);
+       error = copyout((caddr_t)&osb, (caddr_t)uap->ub, sizeof (osb));
+       return (error);
+}
+
+/*
+ * 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;
+{
+       struct stat sb;
+       int error;
+       struct nameidata nd;
+
+       NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->fname, p);
+       if (error = namei(&nd))
+               return (error);
+       error = vn_stat(nd.ni_vp, &sb, p);
+       vput(nd.ni_vp);
+       if (error)
+               return (error);
+       error = copyout((caddr_t)&sb, (caddr_t)uap->ub, sizeof (sb));
+       return (error);
+}
+
+/*
+ * Lstat system call.
+ * This version does not follow links.
+ */
+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);
 }
        error = copyout((caddr_t)&sb, (caddr_t)uap->ub, sizeof (sb));
        return (error);
 }


@@ -1076,31 +1202,28 @@ lstat(p, uap, retval)
 /*
  * Return target name of a symbolic link.
  */
 /*
  * Return target name of a symbolic link.
  */

+struct readlink_args {
+       char    *name;
+       char    *buf;
+       int     count;
+};

 /* ARGSUSED */
 readlink(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 readlink(p, uap, retval)
        struct proc *p;

-       register struct args {
-               char    *name;
-               char    *buf;
-               int     count;
-       } *uap;
+       register struct readlink_args *uap;

        int *retval;
 {
        int *retval;
 {

-       register struct nameidata *ndp;

        register struct vnode *vp;
        struct iovec aiov;
        struct uio auio;
        int error;
        struct nameidata nd;
 
        register struct vnode *vp;
        struct iovec aiov;
        struct uio auio;
        int error;
        struct nameidata nd;
 

-       CHECKPOINT;
-       ndp = &nd;
-       ndp->ni_nameiop = LOOKUP | LOCKLEAF;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->name;
-       if (error = namei(ndp, p))
+       CHECKPOINTREF;
+       NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF, UIO_USERSPACE, uap->name, p);
+       if (error = namei(&nd))

                return (error);
                return (error);

-       vp = ndp->ni_vp;
+       vp = nd.ni_vp;

        if (vp->v_type != VLNK) {
                error = EINVAL;
                goto out;
        if (vp->v_type != VLNK) {
                error = EINVAL;
                goto out;


@@ -1118,42 +1241,40 @@ readlink(p, uap, retval)
 out:
        vput(vp);
        *retval = uap->count - auio.uio_resid;
 out:
        vput(vp);
        *retval = uap->count - auio.uio_resid;

-       CHECKCHECK("readlink");
+       CHECKREFS("readlink");

        return (error);
 }
 
 /*
  * Change flags of a file given path name.
  */
        return (error);
 }
 
 /*
  * Change flags of a file given path name.
  */

+struct chflags_args {
+       char    *fname;
+       int     flags;
+};

 /* ARGSUSED */
 chflags(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 chflags(p, uap, retval)
        struct proc *p;

-       register struct args {
-               char    *fname;
-               int     flags;
-       } *uap;
+       register struct chflags_args *uap;

        int *retval;
 {
        int *retval;
 {

-       register struct nameidata *ndp;

        register struct vnode *vp;
        struct vattr vattr;
        int error;
        struct nameidata nd;
 
        register struct vnode *vp;
        struct vattr vattr;
        int error;
        struct nameidata nd;
 

-       ndp = &nd;
-       ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       if (error = namei(ndp, p))
+       NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->fname, p);
+       if (error = namei(&nd))

                return (error);
                return (error);

-       vp = ndp->ni_vp;
+       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;
        }
        VATTR_NULL(&vattr);
        vattr.va_flags = uap->flags;
        if (vp->v_mount->mnt_flag & MNT_RDONLY) {
                error = EROFS;
                goto out;
        }
        VATTR_NULL(&vattr);
        vattr.va_flags = uap->flags;

-       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);

        error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 out:
        vput(vp);
        error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 out:
        vput(vp);


@@ -1163,13 +1284,14 @@ out:
 /*
  * Change flags of a file given a file descriptor.
  */
 /*
  * Change flags of a file given a file descriptor.
  */

+struct fchflags_args {
+       int     fd;
+       int     flags;
+};

 /* ARGSUSED */
 fchflags(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 fchflags(p, uap, retval)
        struct proc *p;

-       register struct args {
-               int     fd;
-               int     flags;
-       } *uap;
+       register struct fchflags_args *uap;

        int *retval;
 {
        struct vattr vattr;
        int *retval;
 {
        struct vattr vattr;


@@ -1180,6 +1302,7 @@ fchflags(p, uap, retval)
        if (error = getvnode(p->p_fd, uap->fd, &fp))
                return (error);
        vp = (struct vnode *)fp->f_data;
        if (error = getvnode(p->p_fd, uap->fd, &fp))
                return (error);
        vp = (struct vnode *)fp->f_data;

+       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);

        VOP_LOCK(vp);
        if (vp->v_mount->mnt_flag & MNT_RDONLY) {
                error = EROFS;
        VOP_LOCK(vp);
        if (vp->v_mount->mnt_flag & MNT_RDONLY) {
                error = EROFS;


@@ -1187,7 +1310,6 @@ fchflags(p, uap, retval)
        }
        VATTR_NULL(&vattr);
        vattr.va_flags = uap->flags;
        }
        VATTR_NULL(&vattr);
        vattr.va_flags = uap->flags;

-       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);

        error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 out:
        VOP_UNLOCK(vp);
        error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 out:
        VOP_UNLOCK(vp);


@@ -1197,35 +1319,33 @@ out:
 /*
  * Change mode of a file given path name.
  */
 /*
  * Change mode of a file given path name.
  */

+struct chmod_args {
+       char    *fname;
+       int     fmode;
+};

 /* ARGSUSED */
 chmod(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 chmod(p, uap, retval)
        struct proc *p;

-       register struct args {
-               char    *fname;
-               int     fmode;
-       } *uap;
+       register struct chmod_args *uap;

        int *retval;
 {
        int *retval;
 {

-       register struct nameidata *ndp;

        register struct vnode *vp;
        struct vattr vattr;
        int error;
        struct nameidata nd;
 
        register struct vnode *vp;
        struct vattr vattr;
        int error;
        struct nameidata nd;
 

-       ndp = &nd;
-       ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       if (error = namei(ndp, p))
+       NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->fname, p);
+       if (error = namei(&nd))

                return (error);
                return (error);

-       vp = ndp->ni_vp;
+       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;
        }
        VATTR_NULL(&vattr);
        vattr.va_mode = uap->fmode & 07777;
        if (vp->v_mount->mnt_flag & MNT_RDONLY) {
                error = EROFS;
                goto out;
        }
        VATTR_NULL(&vattr);
        vattr.va_mode = uap->fmode & 07777;

-       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);

        error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 out:
        vput(vp);
        error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 out:
        vput(vp);


@@ -1235,13 +1355,14 @@ out:
 /*
  * Change mode of a file given a file descriptor.
  */
 /*
  * Change mode of a file given a file descriptor.
  */

+struct fchmod_args {
+       int     fd;
+       int     fmode;
+};

 /* ARGSUSED */
 fchmod(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 fchmod(p, uap, retval)
        struct proc *p;

-       register struct args {
-               int     fd;
-               int     fmode;
-       } *uap;
+       register struct fchmod_args *uap;

        int *retval;
 {
        struct vattr vattr;
        int *retval;
 {
        struct vattr vattr;


@@ -1252,6 +1373,7 @@ fchmod(p, uap, retval)
        if (error = getvnode(p->p_fd, uap->fd, &fp))
                return (error);
        vp = (struct vnode *)fp->f_data;
        if (error = getvnode(p->p_fd, uap->fd, &fp))
                return (error);
        vp = (struct vnode *)fp->f_data;

+       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);

        VOP_LOCK(vp);
        if (vp->v_mount->mnt_flag & MNT_RDONLY) {
                error = EROFS;
        VOP_LOCK(vp);
        if (vp->v_mount->mnt_flag & MNT_RDONLY) {
                error = EROFS;


@@ -1259,7 +1381,6 @@ fchmod(p, uap, retval)
        }
        VATTR_NULL(&vattr);
        vattr.va_mode = uap->fmode & 07777;
        }
        VATTR_NULL(&vattr);
        vattr.va_mode = uap->fmode & 07777;

-       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);

        error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 out:
        VOP_UNLOCK(vp);
        error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 out:
        VOP_UNLOCK(vp);


@@ -1269,29 +1390,28 @@ out:
 /*
  * Set ownership given a path name.
  */
 /*
  * Set ownership given a path name.
  */

+struct chown_args {
+       char    *fname;
+       int     uid;
+       int     gid;
+};

 /* ARGSUSED */
 chown(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 chown(p, uap, retval)
        struct proc *p;

-       register struct args {
-               char    *fname;
-               int     uid;
-               int     gid;
-       } *uap;
+       register struct chown_args *uap;

        int *retval;
 {
        int *retval;
 {

-       register struct nameidata *ndp;

        register struct vnode *vp;
        struct vattr vattr;
        int error;
        struct nameidata nd;
 
        register struct vnode *vp;
        struct vattr vattr;
        int error;
        struct nameidata nd;
 

-       ndp = &nd;
-       ndp->ni_nameiop = LOOKUP | NOFOLLOW | LOCKLEAF;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       if (error = namei(ndp, p))
+       NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, uap->fname, p);
+       if (error = namei(&nd))

                return (error);
                return (error);

-       vp = ndp->ni_vp;
+       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;
        if (vp->v_mount->mnt_flag & MNT_RDONLY) {
                error = EROFS;
                goto out;


@@ -1299,7 +1419,6 @@ chown(p, uap, retval)
        VATTR_NULL(&vattr);
        vattr.va_uid = uap->uid;
        vattr.va_gid = uap->gid;
        VATTR_NULL(&vattr);
        vattr.va_uid = uap->uid;
        vattr.va_gid = uap->gid;

-       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);

        error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 out:
        vput(vp);
        error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 out:
        vput(vp);


@@ -1309,14 +1428,15 @@ out:
 /*
  * Set ownership given a file descriptor.
  */
 /*
  * Set ownership given a file descriptor.
  */

+struct fchown_args {
+       int     fd;
+       int     uid;
+       int     gid;
+};

 /* ARGSUSED */
 fchown(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 fchown(p, uap, retval)
        struct proc *p;

-       register struct args {
-               int     fd;
-               int     uid;
-               int     gid;
-       } *uap;
+       register struct fchown_args *uap;

        int *retval;
 {
        struct vattr vattr;
        int *retval;
 {
        struct vattr vattr;


@@ -1327,6 +1447,7 @@ fchown(p, uap, retval)
        if (error = getvnode(p->p_fd, uap->fd, &fp))
                return (error);
        vp = (struct vnode *)fp->f_data;
        if (error = getvnode(p->p_fd, uap->fd, &fp))
                return (error);
        vp = (struct vnode *)fp->f_data;

+       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);

        VOP_LOCK(vp);
        if (vp->v_mount->mnt_flag & MNT_RDONLY) {
                error = EROFS;
        VOP_LOCK(vp);
        if (vp->v_mount->mnt_flag & MNT_RDONLY) {
                error = EROFS;


@@ -1335,7 +1456,6 @@ fchown(p, uap, retval)
        VATTR_NULL(&vattr);
        vattr.va_uid = uap->uid;
        vattr.va_gid = uap->gid;
        VATTR_NULL(&vattr);
        vattr.va_uid = uap->uid;
        vattr.va_gid = uap->gid;

-       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);

        error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 out:
        VOP_UNLOCK(vp);
        error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 out:
        VOP_UNLOCK(vp);


@@ -1345,70 +1465,75 @@ out:
 /*
  * Set the access and modification times of a file.
  */
 /*
  * 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;
 /* ARGSUSED */
 utimes(p, uap, retval)
        struct proc *p;

-       register struct args {
-               char    *fname;
-               struct  timeval *tptr;
-       } *uap;
+       register struct utimes_args *uap;

        int *retval;
 {
        int *retval;
 {

-       register struct nameidata *ndp;

        register struct vnode *vp;
        struct timeval tv[2];
        struct vattr vattr;
        int error;
        struct nameidata nd;
 
        register struct vnode *vp;
        struct timeval tv[2];
        struct vattr vattr;
        int error;
        struct nameidata nd;
 

-       if (error = copyin((caddr_t)uap->tptr, (caddr_t)tv, sizeof (tv)))
-               return (error);
-       ndp = &nd;
-       ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       if (error = namei(ndp, p))
+       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);
                return (error);

-       vp = ndp->ni_vp;
+       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;
        }
        if (vp->v_mount->mnt_flag & MNT_RDONLY) {
                error = EROFS;
                goto out;
        }

-       VATTR_NULL(&vattr);
-       vattr.va_atime = tv[0];
-       vattr.va_mtime = tv[1];
-       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
+       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);
        return (error);
 }
 
        error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 out:
        vput(vp);
        return (error);
 }
 

+struct __truncate_args {
+       char    *fname;
+       int     pad;
+       off_t   length;
+};
+

 /*
  * Truncate a file given its path name.
  */
 /* ARGSUSED */
 /*
  * Truncate a file given its path name.
  */
 /* ARGSUSED */

-truncate(p, uap, retval)
+__truncate(p, uap, retval)

        struct proc *p;
        struct proc *p;

-       register struct args {
-               char    *fname;
-               off_t   length;
-       } *uap;
+       register struct __truncate_args *uap;

        int *retval;
 {
        int *retval;
 {

-       register struct nameidata *ndp;

        register struct vnode *vp;
        struct vattr vattr;
        int error;
        struct nameidata nd;
 
        register struct vnode *vp;
        struct vattr vattr;
        int error;
        struct nameidata nd;
 

-       ndp = &nd;
-       ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       if (error = namei(ndp, p))
+       NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->fname, p);
+       if (error = namei(&nd))

                return (error);
                return (error);

-       vp = ndp->ni_vp;
+       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 (vp->v_type == VDIR) {
                error = EISDIR;
                goto out;


@@ -1418,23 +1543,25 @@ truncate(p, uap, retval)
                goto out;
        VATTR_NULL(&vattr);
        vattr.va_size = uap->length;
                goto out;
        VATTR_NULL(&vattr);
        vattr.va_size = uap->length;

-       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);

        error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 out:
        vput(vp);
        return (error);
 }
 
        error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 out:
        vput(vp);
        return (error);
 }
 

+struct __ftruncate_args {
+       int     fd;
+       int     pad;
+       off_t   length;
+};
+

 /*
  * Truncate a file given a file descriptor.
  */
 /* ARGSUSED */
 /*
  * Truncate a file given a file descriptor.
  */
 /* ARGSUSED */

-ftruncate(p, uap, retval)
+__ftruncate(p, uap, retval)

        struct proc *p;
        struct proc *p;

-       register struct args {
-               int     fd;
-               off_t   length;
-       } *uap;
+       register struct __ftruncate_args *uap;

        int *retval;
 {
        struct vattr vattr;
        int *retval;
 {
        struct vattr vattr;


@@ -1447,6 +1574,7 @@ ftruncate(p, uap, retval)
        if ((fp->f_flag & FWRITE) == 0)
                return (EINVAL);
        vp = (struct vnode *)fp->f_data;
        if ((fp->f_flag & FWRITE) == 0)
                return (EINVAL);
        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;


@@ -1456,22 +1584,64 @@ ftruncate(p, uap, retval)
                goto out;
        VATTR_NULL(&vattr);
        vattr.va_size = uap->length;
                goto out;
        VATTR_NULL(&vattr);
        vattr.va_size = uap->length;

-       LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);

        error = VOP_SETATTR(vp, &vattr, fp->f_cred, p);
 out:
        VOP_UNLOCK(vp);
        return (error);
 }
 
        error = VOP_SETATTR(vp, &vattr, fp->f_cred, p);
 out:
        VOP_UNLOCK(vp);
        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.
  */

+struct fsync_args {
+       int     fd;
+};

 /* ARGSUSED */
 fsync(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 fsync(p, uap, retval)
        struct proc *p;

-       struct args {
-               int     fd;
-       } *uap;
+       struct fsync_args *uap;

        int *retval;
 {
        register struct vnode *vp;
        int *retval;
 {
        register struct vnode *vp;


@@ -1482,7 +1652,7 @@ fsync(p, uap, retval)
                return (error);
        vp = (struct vnode *)fp->f_data;
        VOP_LOCK(vp);
                return (error);
        vp = (struct vnode *)fp->f_data;
        VOP_LOCK(vp);

-       error = VOP_FSYNC(vp, fp->f_flag, fp->f_cred, MNT_WAIT, p);
+       error = VOP_FSYNC(vp, fp->f_cred, MNT_WAIT, p);

        VOP_UNLOCK(vp);
        return (error);
 }
        VOP_UNLOCK(vp);
        return (error);
 }


@@ -1493,30 +1663,29 @@ fsync(p, uap, retval)
  * 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.
  */

+struct rename_args {
+       char    *from;
+       char    *to;
+};

 /* ARGSUSED */
 rename(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 rename(p, uap, retval)
        struct proc *p;

-       register struct args {
-               char    *from;
-               char    *to;
-       } *uap;
+       register struct rename_args *uap;

        int *retval;
 {
        register struct vnode *tvp, *fvp, *tdvp;
        struct nameidata fromnd, tond;
        int error;
 
        int *retval;
 {
        register struct vnode *tvp, *fvp, *tdvp;
        struct nameidata fromnd, tond;
        int error;
 

-       CHECKPOINT;
-       fromnd.ni_nameiop = DELETE | WANTPARENT | SAVESTART;
-       fromnd.ni_segflg = UIO_USERSPACE;
-       fromnd.ni_dirp = uap->from;
-       if (error = namei(&fromnd, p))
+       CHECKPOINTREF;
+       NDINIT(&fromnd, DELETE, WANTPARENT | SAVESTART, UIO_USERSPACE,
+               uap->from, p);
+       if (error = namei(&fromnd))

                return (error);
        fvp = fromnd.ni_vp;
                return (error);
        fvp = fromnd.ni_vp;

-       tond.ni_nameiop = RENAME | LOCKPARENT | LOCKLEAF | NOCACHE | SAVESTART;
-       tond.ni_segflg = UIO_USERSPACE;
-       tond.ni_dirp = uap->to;
-       if (error = namei(&tond, p)) {
+       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);
                VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd);
                vrele(fromnd.ni_dvp);
                vrele(fvp);


@@ -1532,14 +1701,6 @@ rename(p, uap, retval)
                        error = EISDIR;
                        goto out;
                }
                        error = EISDIR;
                        goto out;
                }

-               if (fvp->v_mount != tvp->v_mount) {
-                       error = EXDEV;
-                       goto out;
-               }
-       }
-       if (fvp->v_mount != tdvp->v_mount) {
-               error = EXDEV;
-               goto out;

        }
        if (fvp == tdvp)
                error = EINVAL;
        }
        if (fvp == tdvp)
                error = EINVAL;


@@ -1549,8 +1710,9 @@ rename(p, uap, retval)
         * then there is nothing to do.
         */
        if (fvp == tvp && fromnd.ni_dvp == tdvp &&
         * then there is nothing to do.
         */
        if (fvp == tvp && fromnd.ni_dvp == tdvp &&

-           fromnd.ni_namelen == tond.ni_namelen &&
-           !bcmp(fromnd.ni_ptr, tond.ni_ptr, fromnd.ni_namelen))
+           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:
        if (!error) {
                error = -1;
 out:
        if (!error) {


@@ -1559,14 +1721,8 @@ out:
                        LEASE_CHECK(fromnd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
                if (tvp)
                        LEASE_CHECK(tvp, p, p->p_ucred, LEASE_WRITE);
                        LEASE_CHECK(fromnd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
                if (tvp)
                        LEASE_CHECK(tvp, p, p->p_ucred, LEASE_WRITE);

-               if (fromnd.ni_startdir != fromnd.ni_dvp ||
-                   tond.ni_startdir != tond.ni_dvp)   /* NEEDSWORK: debug */
-                       printf ("rename: f.startdir=%x, dvp=%x; t.startdir=%x, dvp=%x\n", fromnd.ni_startdir, fromnd.ni_dvp, tond.ni_startdir, tond.ni_dvp);

                error = VOP_RENAME(fromnd.ni_dvp, fromnd.ni_vp, &fromnd.ni_cnd,
                                   tond.ni_dvp, tond.ni_vp, &tond.ni_cnd);
                error = VOP_RENAME(fromnd.ni_dvp, fromnd.ni_vp, &fromnd.ni_cnd,
                                   tond.ni_dvp, tond.ni_vp, &tond.ni_cnd);

-               if (fromnd.ni_startdir != fromnd.ni_dvp ||
-                   tond.ni_startdir != tond.ni_dvp)   /* NEEDSWORK: debug */
-                       printf ("rename: f.startdir=%x, dvp=%x; t.startdir=%x, dvp=%x\n", fromnd.ni_startdir, fromnd.ni_dvp, tond.ni_startdir, tond.ni_dvp);

        } else {
                VOP_ABORTOP(tond.ni_dvp, &tond.ni_cnd);
                if (tdvp == tvp)
        } else {
                VOP_ABORTOP(tond.ni_dvp, &tond.ni_cnd);
                if (tdvp == tvp)


@@ -1581,12 +1737,12 @@ out:
        }
        p->p_spare[1]--;
        vrele(tond.ni_startdir);
        }
        p->p_spare[1]--;
        vrele(tond.ni_startdir);

-       FREE(tond.ni_pnbuf, M_NAMEI);
+       FREE(tond.ni_cnd.cn_pnbuf, M_NAMEI);

 out1:
        p->p_spare[1]--;
        vrele(fromnd.ni_startdir);
 out1:
        p->p_spare[1]--;
        vrele(fromnd.ni_startdir);

-       FREE(fromnd.ni_pnbuf, M_NAMEI);
-       CHECKCHECK("rename");
+       FREE(fromnd.ni_cnd.cn_pnbuf, M_NAMEI);
+       CHECKREFS("rename");

        if (error == -1)
                return (0);
        return (error);
        if (error == -1)
                return (0);
        return (error);


@@ -1595,74 +1751,68 @@ out1:
 /*
  * Mkdir system call.
  */
 /*
  * Mkdir system call.
  */

+struct mkdir_args {
+       char    *name;
+       int     dmode;
+};

 /* ARGSUSED */
 mkdir(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 mkdir(p, uap, retval)
        struct proc *p;

-       register struct args {
-               char    *name;
-               int     dmode;
-       } *uap;
+       register struct mkdir_args *uap;

        int *retval;
 {
        int *retval;
 {

-       register struct nameidata *ndp;

        register struct vnode *vp;
        struct vattr vattr;
        int error;
        struct nameidata nd;
 
        register struct vnode *vp;
        struct vattr vattr;
        int error;
        struct nameidata nd;
 

-       CHECKPOINT;
-       ndp = &nd;
-       ndp->ni_nameiop = CREATE | LOCKPARENT;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->name;
-       if (error = namei(ndp, p))
+       CHECKPOINTREF;
+       NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, uap->name, p);
+       if (error = namei(&nd))

                return (error);
                return (error);

-       vp = ndp->ni_vp;
+       vp = nd.ni_vp;

        if (vp != NULL) {
        if (vp != NULL) {

-               VOP_ABORTOP(ndp->ni_dvp, &ndp->ni_cnd);
-               if (ndp->ni_dvp == vp)
-                       vrele(ndp->ni_dvp);
+               VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
+               if (nd.ni_dvp == vp)
+                       vrele(nd.ni_dvp);

                else
                else

-                       vput(ndp->ni_dvp);
+                       vput(nd.ni_dvp);

                vrele(vp);
                vrele(vp);

-               CHECKCHECK("mkdir1");
+               CHECKREFS("mkdir1");

                return (EEXIST);
        }
        VATTR_NULL(&vattr);
        vattr.va_type = VDIR;
        vattr.va_mode = (uap->dmode & 0777) &~ p->p_fd->fd_cmask;
                return (EEXIST);
        }
        VATTR_NULL(&vattr);
        vattr.va_type = VDIR;
        vattr.va_mode = (uap->dmode & 0777) &~ p->p_fd->fd_cmask;

-       LEASE_CHECK(ndp->ni_dvp, p, p->p_ucred, LEASE_WRITE);
-       error = VOP_MKDIR(ndp->ni_dvp, &ndp->ni_vp, &ndp->ni_cnd, &vattr);
+       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);
-       CHECKCHECK("mkdir2");
+               vput(nd.ni_vp);
+       CHECKREFS("mkdir2");

        return (error);
 }
 
 /*
  * Rmdir system call.
  */
        return (error);
 }
 
 /*
  * Rmdir system call.
  */

+struct rmdir_args {
+       char    *name;
+};

 /* ARGSUSED */
 rmdir(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 rmdir(p, uap, retval)
        struct proc *p;

-       struct args {
-               char    *name;
-       } *uap;
+       struct rmdir_args *uap;

        int *retval;
 {
        int *retval;
 {

-       register struct nameidata *ndp;

        register struct vnode *vp;
        int error;
        struct nameidata nd;
 
        register struct vnode *vp;
        int error;
        struct nameidata nd;
 

-       CHECKPOINT;
-       ndp = &nd;
-       ndp->ni_nameiop = DELETE | LOCKPARENT | LOCKLEAF;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->name;
-       if (error = namei(ndp, p))
+       CHECKPOINTREF;
+       NDINIT(&nd, DELETE, LOCKPARENT | LOCKLEAF, UIO_USERSPACE, uap->name, p);
+       if (error = namei(&nd))

                return (error);
                return (error);

-       vp = ndp->ni_vp;
+       vp = nd.ni_vp;

        if (vp->v_type != VDIR) {
                error = ENOTDIR;
                goto out;
        if (vp->v_type != VDIR) {
                error = ENOTDIR;
                goto out;


@@ -1670,7 +1820,7 @@ rmdir(p, uap, retval)
        /*
         * No rmdir "." please.
         */
        /*
         * No rmdir "." please.
         */

-       if (ndp->ni_dvp == vp) {
+       if (nd.ni_dvp == vp) {

                error = EINVAL;
                goto out;
        }
                error = EINVAL;
                goto out;
        }


@@ -1681,46 +1831,147 @@ rmdir(p, uap, retval)
                error = EBUSY;
 out:
        if (!error) {
                error = EBUSY;
 out:
        if (!error) {

-               LEASE_CHECK(ndp->ni_dvp, p, p->p_ucred, LEASE_WRITE);
+               LEASE_CHECK(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);

                LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);
                LEASE_CHECK(vp, p, p->p_ucred, LEASE_WRITE);

-               error = VOP_RMDIR(ndp->ni_dvp, ndp->ni_vp, &ndp->ni_cnd);
+               error = VOP_RMDIR(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd);

        } else {
        } else {

-               VOP_ABORTOP(ndp->ni_dvp, &ndp->ni_cnd);
-               if (ndp->ni_dvp == vp)
-                       vrele(ndp->ni_dvp);
+               VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
+               if (nd.ni_dvp == vp)
+                       vrele(nd.ni_dvp);

                else
                else

-                       vput(ndp->ni_dvp);
+                       vput(nd.ni_dvp);

                vput(vp);
        }
                vput(vp);
        }

-       CHECKCHECK("rmdir");
+       CHECKREFS("rmdir");

        return (error);
 }
 
        return (error);
 }
 

+#ifdef COMPAT_43

 /*
  * Read a block of directory entries in a file system independent format.
  */
 /*
  * 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)
+               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.
+ */
+struct getdirentries_args {
+       int     fd;
+       char    *buf;
+       unsigned count;
+       long    *basep;
+};

 getdirentries(p, uap, retval)
        struct proc *p;
 getdirentries(p, uap, retval)
        struct proc *p;

-       register struct args {
-               int     fd;
-               char    *buf;
-               unsigned count;
-               long    *basep;
-       } *uap;
+       register struct getdirentries_args *uap;

        int *retval;
 {
        register struct vnode *vp;
        struct file *fp;
        struct uio auio;
        struct iovec aiov;
        int *retval;
 {
        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(p->p_fd, uap->fd, &fp))
                return (error);
        if ((fp->f_flag & FREAD) == 0)
                return (EBADF);
        vp = (struct vnode *)fp->f_data;
 
        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;

+unionread:

        if (vp->v_type != VDIR)
                return (EINVAL);
        aiov.iov_base = uap->buf;
        if (vp->v_type != VDIR)
                return (EINVAL);
        aiov.iov_base = uap->buf;


@@ -1732,13 +1983,24 @@ getdirentries(p, uap, retval)
        auio.uio_procp = p;
        auio.uio_resid = uap->count;
        VOP_LOCK(vp);
        auio.uio_procp = p;
        auio.uio_resid = uap->count;
        VOP_LOCK(vp);

-       auio.uio_offset = off = fp->f_offset;
-       error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag);
+       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)
                return (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));
+       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);
 }
        *retval = uap->count - auio.uio_resid;
        return (error);
 }


@@ -1746,12 +2008,13 @@ getdirentries(p, uap, retval)
 /*
  * Set the mode mask for creation of filesystem nodes.
  */
 /*
  * Set the mode mask for creation of filesystem nodes.
  */

-mode_t
+struct umask_args {
+       int     mask;
+};
+mode_t                         /* XXX */

 umask(p, uap, retval)
        struct proc *p;
 umask(p, uap, retval)
        struct proc *p;

-       struct args {
-               int     mask;
-       } *uap;
+       struct umask_args *uap;

        int *retval;
 {
        register struct filedesc *fdp = p->p_fd;
        int *retval;
 {
        register struct filedesc *fdp = p->p_fd;


@@ -1765,27 +2028,24 @@ umask(p, uap, retval)
  * Void all references to file by ripping underlying filesystem
  * away from vnode.
  */
  * Void all references to file by ripping underlying filesystem
  * away from vnode.
  */

+struct revoke_args {
+       char    *fname;
+};

 /* ARGSUSED */
 revoke(p, uap, retval)
        struct proc *p;
 /* ARGSUSED */
 revoke(p, uap, retval)
        struct proc *p;

-       register struct args {
-               char    *fname;
-       } *uap;
+       register struct revoke_args *uap;

        int *retval;
 {
        int *retval;
 {

-       register struct nameidata *ndp;

        register struct vnode *vp;
        struct vattr vattr;
        int error;
        struct nameidata nd;
 
        register struct vnode *vp;
        struct vattr vattr;
        int error;
        struct nameidata nd;
 

-       ndp = &nd;
-       ndp->ni_nameiop = LOOKUP | FOLLOW;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       if (error = namei(ndp, p))
+       NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->fname, p);
+       if (error = namei(&nd))

                return (error);
                return (error);

-       vp = ndp->ni_vp;
+       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;