projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
symbolic links take on user ownership of their containing directory
[unix-history] / usr / src / sys / ufs / ffs / ufs_lookup.c
diff --git a/usr/src/sys/ufs/ffs/ufs_lookup.c b/usr/src/sys/ufs/ffs/ufs_lookup.c
index 61ca9ae..17572c4 100644 (file)
--- a/usr/src/sys/ufs/ffs/ufs_lookup.c
+++ b/usr/src/sys/ufs/ffs/ufs_lookup.c
@@ -4,19 +4,21 @@
  *
  * %sccs.include.redist.c%
  *
  *
  * %sccs.include.redist.c%
  *
- *     @(#)ufs_lookup.c        7.33 (Berkeley) %G%
+ *     @(#)ufs_lookup.c        7.52 (Berkeley) %G%
  */
 
  */
 
-#include "param.h"
-#include "namei.h"
-#include "buf.h"
-#include "file.h"
-#include "vnode.h"
+#include <sys/param.h>
+#include <sys/namei.h>
+#include <sys/buf.h>
+#include <sys/file.h>
+#include <sys/mount.h>
+#include <sys/vnode.h>
 
 
-#include "quota.h"
-#include "inode.h"
-#include "dir.h"
-#include "fs.h"
+#include <ufs/ufs/quota.h>
+#include <ufs/ufs/inode.h>
+#include <ufs/ufs/dir.h>
+#include <ufs/ufs/ufsmount.h>
+#include <ufs/ufs/ufs_extern.h>
 
 struct nchstats nchstats;
 #ifdef DIAGNOSTIC
 
 struct nchstats nchstats;
 #ifdef DIAGNOSTIC
@@ -25,22 +27,24 @@ int dirchk = 1;
 int    dirchk = 0;
 #endif
 
 int    dirchk = 0;
 #endif
 
+#define FSFMT(vp)      ((vp)->v_mount->mnt_maxsymlinklen <= 0)
+
 /*
  * Convert a component of a pathname into a pointer to a locked inode.
  * This is a very central and rather complicated routine.
  * If the file system is not maintained in a strict tree hierarchy,
  * this can result in a deadlock situation (see comments in code below).
  *
 /*
  * Convert a component of a pathname into a pointer to a locked inode.
  * This is a very central and rather complicated routine.
  * If the file system is not maintained in a strict tree hierarchy,
  * this can result in a deadlock situation (see comments in code below).
  *
- * The flag argument is LOOKUP, CREATE, RENAME, or DELETE depending on
- * whether the name is to be looked up, created, renamed, or deleted.
+ * The cnp->cn_nameiop argument is LOOKUP, CREATE, RENAME, or DELETE depending
+ * on whether the name is to be looked up, created, renamed, or deleted.
  * When CREATE, RENAME, or DELETE is specified, information usable in
  * creating, renaming, or deleting a directory entry may be calculated.
  * If flag has LOCKPARENT or'ed into it and the target of the pathname
  * exists, lookup returns both the target and its parent directory locked.
  * When creating or renaming and LOCKPARENT is specified, the target may
  * not be ".".  When deleting and LOCKPARENT is specified, the target may
  * When CREATE, RENAME, or DELETE is specified, information usable in
  * creating, renaming, or deleting a directory entry may be calculated.
  * If flag has LOCKPARENT or'ed into it and the target of the pathname
  * exists, lookup returns both the target and its parent directory locked.
  * When creating or renaming and LOCKPARENT is specified, the target may
  * not be ".".  When deleting and LOCKPARENT is specified, the target may
- * be "."., but the caller must check to ensure it does an vrele and iput
- * instead of two iputs.
+ * be "."., but the caller must check to ensure it does an vrele and vput
+ * instead of two vputs.
  *
  * Overall outline of ufs_lookup:
  *
  *
  * Overall outline of ufs_lookup:
  *
@@ -60,46 +64,54 @@ int dirchk = 0;
  *
  * NOTE: (LOOKUP | LOCKPARENT) currently returns the parent inode unlocked.
  */
  *
  * NOTE: (LOOKUP | LOCKPARENT) currently returns the parent inode unlocked.
  */
-ufs_lookup(vdp, ndp, p)
-       register struct vnode *vdp;
-       register struct nameidata *ndp;
-       struct proc *p;
+int
+ufs_lookup(ap)
+       struct vop_lookup_args /* {
+               struct vnode *a_dvp;
+               struct vnode **a_vpp;
+               struct componentname *a_cnp;
+       } */ *ap;
 {
 {
-       register struct inode *dp;      /* the directory we are searching */
-       register struct fs *fs;         /* file system that directory is in */
-       struct buf *bp = 0;             /* a buffer of directory entries */
+       register struct vnode *vdp;     /* vnode for directory being searched */
+       register struct inode *dp;      /* inode for directory being searched */
+       struct buf *bp;                 /* a buffer of directory entries */
        register struct direct *ep;     /* the current directory entry */
        int entryoffsetinblock;         /* offset of ep in bp's buffer */
        enum {NONE, COMPACT, FOUND} slotstatus;
        register struct direct *ep;     /* the current directory entry */
        int entryoffsetinblock;         /* offset of ep in bp's buffer */
        enum {NONE, COMPACT, FOUND} slotstatus;
-       int slotoffset = -1;            /* offset of area with free space */
+       doff_t slotoffset;              /* offset of area with free space */
        int slotsize;                   /* size of area at slotoffset */
        int slotfreespace;              /* amount of space free in slot */
        int slotneeded;                 /* size of the entry we're seeking */
        int numdirpasses;               /* strategy for directory search */
        int slotsize;                   /* size of area at slotoffset */
        int slotfreespace;              /* amount of space free in slot */
        int slotneeded;                 /* size of the entry we're seeking */
        int numdirpasses;               /* strategy for directory search */
-       int endsearch;                  /* offset to end directory search */
-       int prevoff;                    /* ndp->ni_ufs.ufs_offset of previous entry */
-       struct inode *pdp;              /* saved dp during symlink work */
-       struct inode *tdp;              /* returned by iget */
-       off_t enduseful;                /* pointer past last used dir slot */
-       int flag;                       /* LOOKUP, CREATE, RENAME, or DELETE */
+       doff_t endsearch;               /* offset to end directory search */
+       doff_t prevoff;                 /* prev entry dp->i_offset */
+       struct vnode *pdp;              /* saved dp during symlink work */
+       struct vnode *tdp;              /* returned by VFS_VGET */
+       doff_t enduseful;               /* pointer past last used dir slot */
+       u_long bmask;                   /* block offset mask */
        int lockparent;                 /* 1 => lockparent flag is set */
        int wantparent;                 /* 1 => wantparent or lockparent flag */
        int lockparent;                 /* 1 => lockparent flag is set */
        int wantparent;                 /* 1 => wantparent or lockparent flag */
-       int error;
-
-       ndp->ni_dvp = vdp;
-       ndp->ni_vp = NULL;
+       int namlen, error;
+       struct vnode **vpp = ap->a_vpp;
+       struct componentname *cnp = ap->a_cnp;
+       struct ucred *cred = cnp->cn_cred;
+       int flags = cnp->cn_flags;
+       int nameiop = cnp->cn_nameiop;
+
+       bp = NULL;
+       slotoffset = -1;
+       *vpp = NULL;
+       vdp = ap->a_dvp;
        dp = VTOI(vdp);
        dp = VTOI(vdp);
-       fs = dp->i_fs;
-       lockparent = ndp->ni_nameiop & LOCKPARENT;
-       flag = ndp->ni_nameiop & OPMASK;
-       wantparent = ndp->ni_nameiop & (LOCKPARENT|WANTPARENT);
+       lockparent = flags & LOCKPARENT;
+       wantparent = flags & (LOCKPARENT|WANTPARENT);
 
        /*
         * Check accessiblity of directory.
         */
 
        /*
         * Check accessiblity of directory.
         */
-       if ((dp->i_mode&IFMT) != IFDIR)
+       if ((dp->i_mode & IFMT) != IFDIR)
                return (ENOTDIR);
                return (ENOTDIR);
-       if (error = ufs_access(vdp, VEXEC, ndp->ni_cred, p))
+       if (error = VOP_ACCESS(vdp, VEXEC, cred, cnp->cn_proc))
                return (error);
 
        /*
                return (error);
 
        /*
@@ -109,36 +121,32 @@ ufs_lookup(vdp, ndp, p)
         * check the name cache to see if the directory/name pair
         * we are looking for is known already.
         */
         * check the name cache to see if the directory/name pair
         * we are looking for is known already.
         */
-       if (error = cache_lookup(ndp)) {
+       if (error = cache_lookup(vdp, vpp, cnp)) {
                int vpid;       /* capability number of vnode */
 
                if (error == ENOENT)
                        return (error);
                int vpid;       /* capability number of vnode */
 
                if (error == ENOENT)
                        return (error);
-#ifdef PARANOID
-               if (vdp == ndp->ni_rdir && ndp->ni_isdotdot)
-                       panic("ufs_lookup: .. through root");
-#endif
                /*
                 * Get the next vnode in the path.
                 * See comment below starting `Step through' for
                 * an explaination of the locking protocol.
                 */
                /*
                 * Get the next vnode in the path.
                 * See comment below starting `Step through' for
                 * an explaination of the locking protocol.
                 */
-               pdp = dp;
-               dp = VTOI(ndp->ni_vp);
-               vdp = ndp->ni_vp;
+               pdp = vdp;
+               dp = VTOI(*vpp);
+               vdp = *vpp;
                vpid = vdp->v_id;
                vpid = vdp->v_id;
-               if (pdp == dp) {
+               if (pdp == vdp) {   /* lookup on "." */
                        VREF(vdp);
                        error = 0;
                        VREF(vdp);
                        error = 0;
-               } else if (ndp->ni_isdotdot) {
-                       IUNLOCK(pdp);
+               } else if (flags & ISDOTDOT) {
+                       VOP_UNLOCK(pdp);
                        error = vget(vdp);
                        error = vget(vdp);
-                       if (!error && lockparent && *ndp->ni_next == '\0')
-                               ILOCK(pdp);
+                       if (!error && lockparent && (flags & ISLASTCN))
+                               error = VOP_LOCK(pdp);
                } else {
                        error = vget(vdp);
                } else {
                        error = vget(vdp);
-                       if (!lockparent || error || *ndp->ni_next != '\0')
-                               IUNLOCK(pdp);
+                       if (!lockparent || error || !(flags & ISLASTCN))
+                               VOP_UNLOCK(pdp);
                }
                /*
                 * Check that the capability number did not change
                }
                /*
                 * Check that the capability number did not change
@@ -147,14 +155,15 @@ ufs_lookup(vdp, ndp, p)
                if (!error) {
                        if (vpid == vdp->v_id)
                                return (0);
                if (!error) {
                        if (vpid == vdp->v_id)
                                return (0);
-                       iput(dp);
-                       if (lockparent && pdp != dp && *ndp->ni_next == '\0')
-                               IUNLOCK(pdp);
+                       vput(vdp);
+                       if (lockparent && pdp != vdp && (flags & ISLASTCN))
+                               VOP_UNLOCK(pdp);
                }
                }
-               ILOCK(pdp);
-               dp = pdp;
-               vdp = ITOV(dp);
-               ndp->ni_vp = NULL;
+               if (error = VOP_LOCK(pdp))
+                       return (error);
+               vdp = pdp;
+               dp = VTOI(pdp);
+               *vpp = NULL;
        }
 
        /*
        }
 
        /*
@@ -164,11 +173,12 @@ ufs_lookup(vdp, ndp, p)
         * case it doesn't already exist.
         */
        slotstatus = FOUND;
         * case it doesn't already exist.
         */
        slotstatus = FOUND;
-       if ((flag == CREATE || flag == RENAME) && *ndp->ni_next == 0) {
+       slotfreespace = slotsize = slotneeded = 0;
+       if ((nameiop == CREATE || nameiop == RENAME) &&
+           (flags & ISLASTCN)) {
                slotstatus = NONE;
                slotstatus = NONE;
-               slotfreespace = 0;
-               slotneeded = ((sizeof (struct direct) - (MAXNAMLEN + 1)) +
-                       ((ndp->ni_namelen + 1 + 3) &~ 3));
+               slotneeded = (sizeof(struct direct) - MAXNAMLEN +
+                       cnp->cn_namelen + 3) &~ 3;
        }
 
        /*
        }
 
        /*
@@ -182,35 +192,35 @@ ufs_lookup(vdp, ndp, p)
         * profiling time and hence has been removed in the interest
         * of simplicity.
         */
         * profiling time and hence has been removed in the interest
         * of simplicity.
         */
-       if (flag != LOOKUP || dp->i_diroff == 0 || dp->i_diroff > dp->i_size) {
-               ndp->ni_ufs.ufs_offset = 0;
+       bmask = VFSTOUFS(vdp->v_mount)->um_mountp->mnt_stat.f_iosize - 1;
+       if (nameiop != LOOKUP || dp->i_diroff == 0 ||
+           dp->i_diroff > dp->i_size) {
+               entryoffsetinblock = 0;
+               dp->i_offset = 0;
                numdirpasses = 1;
        } else {
                numdirpasses = 1;
        } else {
-               ndp->ni_ufs.ufs_offset = dp->i_diroff;
-               entryoffsetinblock = blkoff(fs, ndp->ni_ufs.ufs_offset);
-               if (entryoffsetinblock != 0) {
-                       if (error = blkatoff(dp, ndp->ni_ufs.ufs_offset,
-                           (char **)0, &bp))
-                               return (error);
-               }
+               dp->i_offset = dp->i_diroff;
+               if ((entryoffsetinblock = dp->i_offset & bmask) &&
+                   (error = VOP_BLKATOFF(vdp, (off_t)dp->i_offset, NULL, &bp)))
+                       return (error);
                numdirpasses = 2;
                nchstats.ncs_2passes++;
        }
                numdirpasses = 2;
                nchstats.ncs_2passes++;
        }
+       prevoff = dp->i_offset;
        endsearch = roundup(dp->i_size, DIRBLKSIZ);
        enduseful = 0;
 
 searchloop:
        endsearch = roundup(dp->i_size, DIRBLKSIZ);
        enduseful = 0;
 
 searchloop:
-       while (ndp->ni_ufs.ufs_offset < endsearch) {
+       while (dp->i_offset < endsearch) {
                /*
                /*
-                * If offset is on a block boundary,
-                * read the next directory block.
-                * Release previous if it exists.
+                * If offset is on a block boundary, read the next directory
+                * block.  Release previous if it exists.
                 */
                 */
-               if (blkoff(fs, ndp->ni_ufs.ufs_offset) == 0) {
+               if ((dp->i_offset & bmask) == 0) {
                        if (bp != NULL)
                                brelse(bp);
                        if (bp != NULL)
                                brelse(bp);
-                       if (error = blkatoff(dp, ndp->ni_ufs.ufs_offset,
-                           (char **)0, &bp))
+                       if (error =
+                           VOP_BLKATOFF(vdp, (off_t)dp->i_offset, NULL, &bp))
                                return (error);
                        entryoffsetinblock = 0;
                }
                                return (error);
                        entryoffsetinblock = 0;
                }
@@ -232,12 +242,12 @@ searchloop:
                 */
                ep = (struct direct *)(bp->b_un.b_addr + entryoffsetinblock);
                if (ep->d_reclen == 0 ||
                 */
                ep = (struct direct *)(bp->b_un.b_addr + entryoffsetinblock);
                if (ep->d_reclen == 0 ||
-                   dirchk && dirbadentry(ep, entryoffsetinblock)) {
+                   dirchk && ufs_dirbadentry(vdp, ep, entryoffsetinblock)) {
                        int i;
 
                        int i;
 
-                       dirbad(dp, ndp->ni_ufs.ufs_offset, "mangled entry");
+                       ufs_dirbad(dp, dp->i_offset, "mangled entry");
                        i = DIRBLKSIZ - (entryoffsetinblock & (DIRBLKSIZ - 1));
                        i = DIRBLKSIZ - (entryoffsetinblock & (DIRBLKSIZ - 1));
-                       ndp->ni_ufs.ufs_offset += i;
+                       dp->i_offset += i;
                        entryoffsetinblock += i;
                        continue;
                }
                        entryoffsetinblock += i;
                        continue;
                }
@@ -252,21 +262,19 @@ searchloop:
                        int size = ep->d_reclen;
 
                        if (ep->d_ino != 0)
                        int size = ep->d_reclen;
 
                        if (ep->d_ino != 0)
-                               size -= DIRSIZ(ep);
+                               size -= DIRSIZ(FSFMT(vdp), ep);
                        if (size > 0) {
                                if (size >= slotneeded) {
                                        slotstatus = FOUND;
                        if (size > 0) {
                                if (size >= slotneeded) {
                                        slotstatus = FOUND;
-                                       slotoffset = ndp->ni_ufs.ufs_offset;
+                                       slotoffset = dp->i_offset;
                                        slotsize = ep->d_reclen;
                                } else if (slotstatus == NONE) {
                                        slotfreespace += size;
                                        if (slotoffset == -1)
                                        slotsize = ep->d_reclen;
                                } else if (slotstatus == NONE) {
                                        slotfreespace += size;
                                        if (slotoffset == -1)
-                                               slotoffset =
-                                                     ndp->ni_ufs.ufs_offset;
+                                               slotoffset = dp->i_offset;
                                        if (slotfreespace >= slotneeded) {
                                                slotstatus = COMPACT;
                                        if (slotfreespace >= slotneeded) {
                                                slotstatus = COMPACT;
-                                               slotsize =
-                                                     ndp->ni_ufs.ufs_offset +
+                                               slotsize = dp->i_offset +
                                                      ep->d_reclen - slotoffset;
                                        }
                                }
                                                      ep->d_reclen - slotoffset;
                                        }
                                }
@@ -277,25 +285,33 @@ searchloop:
                 * Check for a name match.
                 */
                if (ep->d_ino) {
                 * Check for a name match.
                 */
                if (ep->d_ino) {
-                       if (ep->d_namlen == ndp->ni_namelen &&
-                           !bcmp(ndp->ni_ptr, ep->d_name,
-                               (unsigned)ep->d_namlen)) {
+#                      if (BYTE_ORDER == LITTLE_ENDIAN)
+                               if (vdp->v_mount->mnt_maxsymlinklen > 0)
+                                       namlen = ep->d_namlen;
+                               else
+                                       namlen = ep->d_type;
+#                      else
+                               namlen = ep->d_namlen;
+#                      endif
+                       if (namlen == cnp->cn_namelen &&
+                           !bcmp(cnp->cn_nameptr, ep->d_name,
+                               (unsigned)namlen)) {
                                /*
                                 * Save directory entry's inode number and
                                 * reclen in ndp->ni_ufs area, and release
                                 * directory buffer.
                                 */
                                /*
                                 * Save directory entry's inode number and
                                 * reclen in ndp->ni_ufs area, and release
                                 * directory buffer.
                                 */
-                               ndp->ni_ufs.ufs_ino = ep->d_ino;
-                               ndp->ni_ufs.ufs_reclen = ep->d_reclen;
+                               dp->i_ino = ep->d_ino;
+                               dp->i_reclen = ep->d_reclen;
                                brelse(bp);
                                goto found;
                        }
                }
                                brelse(bp);
                                goto found;
                        }
                }
-               prevoff = ndp->ni_ufs.ufs_offset;
-               ndp->ni_ufs.ufs_offset += ep->d_reclen;
+               prevoff = dp->i_offset;
+               dp->i_offset += ep->d_reclen;
                entryoffsetinblock += ep->d_reclen;
                if (ep->d_ino)
                entryoffsetinblock += ep->d_reclen;
                if (ep->d_ino)
-                       enduseful = ndp->ni_ufs.ufs_offset;
+                       enduseful = dp->i_offset;
        }
 /* notfound: */
        /*
        }
 /* notfound: */
        /*
@@ -304,7 +320,7 @@ searchloop:
         */
        if (numdirpasses == 2) {
                numdirpasses--;
         */
        if (numdirpasses == 2) {
                numdirpasses--;
-               ndp->ni_ufs.ufs_offset = 0;
+               dp->i_offset = 0;
                endsearch = dp->i_diroff;
                goto searchloop;
        }
                endsearch = dp->i_diroff;
                goto searchloop;
        }
@@ -315,34 +331,34 @@ searchloop:
         * directory has not been removed, then can consider
         * allowing file to be created.
         */
         * directory has not been removed, then can consider
         * allowing file to be created.
         */
-       if ((flag == CREATE || flag == RENAME) &&
-           *ndp->ni_next == 0 && dp->i_nlink != 0) {
+       if ((nameiop == CREATE || nameiop == RENAME) &&
+           (flags & ISLASTCN) && dp->i_nlink != 0) {
                /*
                 * Access for write is interpreted as allowing
                 * creation of files in the directory.
                 */
                /*
                 * Access for write is interpreted as allowing
                 * creation of files in the directory.
                 */
-               if (error = ufs_access(vdp, VWRITE, ndp->ni_cred, p))
+               if (error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_proc))
                        return (error);
                /*
                 * Return an indication of where the new directory
                 * entry should be put.  If we didn't find a slot,
                        return (error);
                /*
                 * Return an indication of where the new directory
                 * entry should be put.  If we didn't find a slot,
-                * then set ndp->ni_ufs.ufs_count to 0 indicating
+                * then set dp->i_count to 0 indicating
                 * that the new slot belongs at the end of the
                 * directory. If we found a slot, then the new entry
                 * that the new slot belongs at the end of the
                 * directory. If we found a slot, then the new entry
-                * can be put in the range from ndp->ni_ufs.ufs_offset
-                * to ndp->ni_ufs.ufs_offset + ndp->ni_ufs.ufs_count.
+                * can be put in the range from dp->i_offset to
+                * dp->i_offset + dp->i_count.
                 */
                if (slotstatus == NONE) {
                 */
                if (slotstatus == NONE) {
-                       ndp->ni_ufs.ufs_offset = roundup(dp->i_size, DIRBLKSIZ);
-                       ndp->ni_ufs.ufs_count = 0;
-                       enduseful = ndp->ni_ufs.ufs_offset;
+                       dp->i_offset = roundup(dp->i_size, DIRBLKSIZ);
+                       dp->i_count = 0;
+                       enduseful = dp->i_offset;
                } else {
                } else {
-                       ndp->ni_ufs.ufs_offset = slotoffset;
-                       ndp->ni_ufs.ufs_count = slotsize;
+                       dp->i_offset = slotoffset;
+                       dp->i_count = slotsize;
                        if (enduseful < slotoffset + slotsize)
                                enduseful = slotoffset + slotsize;
                }
                        if (enduseful < slotoffset + slotsize)
                                enduseful = slotoffset + slotsize;
                }
-               ndp->ni_ufs.ufs_endoff = roundup(enduseful, DIRBLKSIZ);
+               dp->i_endoff = roundup(enduseful, DIRBLKSIZ);
                dp->i_flag |= IUPD|ICHG;
                /*
                 * We return with the directory locked, so that
                dp->i_flag |= IUPD|ICHG;
                /*
                 * We return with the directory locked, so that
@@ -357,15 +373,16 @@ searchloop:
                 * NB - if the directory is unlocked, then this
                 * information cannot be used.
                 */
                 * NB - if the directory is unlocked, then this
                 * information cannot be used.
                 */
-               ndp->ni_nameiop |= SAVENAME;
+               cnp->cn_flags |= SAVENAME;
                if (!lockparent)
                if (!lockparent)
-                       IUNLOCK(dp);
+                       VOP_UNLOCK(vdp);
+               return (EJUSTRETURN);
        }
        /*
         * Insert name into cache (as non-existent) if appropriate.
         */
        }
        /*
         * Insert name into cache (as non-existent) if appropriate.
         */
-       if (ndp->ni_makeentry && flag != CREATE)
-               cache_enter(ndp);
+       if ((cnp->cn_flags & MAKEENTRY) && nameiop != CREATE)
+               cache_enter(vdp, *vpp, cnp);
        return (ENOENT);
 
 found:
        return (ENOENT);
 
 found:
@@ -375,9 +392,9 @@ found:
         * Check that directory length properly reflects presence
         * of this entry.
         */
         * Check that directory length properly reflects presence
         * of this entry.
         */
-       if (entryoffsetinblock + DIRSIZ(ep) > dp->i_size) {
-               dirbad(dp, ndp->ni_ufs.ufs_offset, "i_size too small");
-               dp->i_size = entryoffsetinblock + DIRSIZ(ep);
+       if (entryoffsetinblock + DIRSIZ(FSFMT(vdp), ep) > dp->i_size) {
+               ufs_dirbad(dp, dp->i_offset, "i_size too small");
+               dp->i_size = entryoffsetinblock + DIRSIZ(FSFMT(vdp), ep);
                dp->i_flag |= IUPD|ICHG;
        }
 
                dp->i_flag |= IUPD|ICHG;
        }
 
@@ -386,8 +403,8 @@ found:
         * If the final component of path name, save information
         * in the cache as to where the entry was found.
         */
         * If the final component of path name, save information
         * in the cache as to where the entry was found.
         */
-       if (*ndp->ni_next == '\0' && flag == LOOKUP)
-               dp->i_diroff = ndp->ni_ufs.ufs_offset &~ (DIRBLKSIZ - 1);
+       if ((flags & ISLASTCN) && nameiop == LOOKUP)
+               dp->i_diroff = dp->i_offset &~ (DIRBLKSIZ - 1);
 
        /*
         * If deleting, and at end of pathname, return
 
        /*
         * If deleting, and at end of pathname, return
@@ -396,28 +413,28 @@ found:
         * the directory (in ndp->ni_dvp), otherwise we go
         * on and lock the inode, being careful with ".".
         */
         * the directory (in ndp->ni_dvp), otherwise we go
         * on and lock the inode, being careful with ".".
         */
-       if (flag == DELETE && *ndp->ni_next == 0) {
+       if (nameiop == DELETE && (flags & ISLASTCN)) {
                /*
                 * Write access to directory required to delete files.
                 */
                /*
                 * Write access to directory required to delete files.
                 */
-               if (error = ufs_access(vdp, VWRITE, ndp->ni_cred, p))
+               if (error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_proc))
                        return (error);
                /*
                        return (error);
                /*
-                * Return pointer to current entry in ndp->ni_ufs.ufs_offset,
+                * Return pointer to current entry in dp->i_offset,
                 * and distance past previous entry (if there
                 * and distance past previous entry (if there
-                * is a previous entry in this block) in ndp->ni_ufs.ufs_count.
+                * is a previous entry in this block) in dp->i_count.
                 * Save directory inode pointer in ndp->ni_dvp for dirremove().
                 */
                 * Save directory inode pointer in ndp->ni_dvp for dirremove().
                 */
-               if ((ndp->ni_ufs.ufs_offset&(DIRBLKSIZ-1)) == 0)
-                       ndp->ni_ufs.ufs_count = 0;
+               if ((dp->i_offset & (DIRBLKSIZ - 1)) == 0)
+                       dp->i_count = 0;
                else
                else
-                       ndp->ni_ufs.ufs_count = ndp->ni_ufs.ufs_offset - prevoff;
-               if (dp->i_number == ndp->ni_ufs.ufs_ino) {
+                       dp->i_count = dp->i_offset - prevoff;
+               if (dp->i_number == dp->i_ino) {
                        VREF(vdp);
                        VREF(vdp);
-                       ndp->ni_vp = vdp;
+                       *vpp = vdp;
                        return (0);
                }
                        return (0);
                }
-               if (error = iget(dp, ndp->ni_ufs.ufs_ino, &tdp))
+               if (error = VFS_VGET(vdp->v_mount, dp->i_ino, &tdp))
                        return (error);
                /*
                 * If directory is "sticky", then user must own
                        return (error);
                /*
                 * If directory is "sticky", then user must own
@@ -426,15 +443,15 @@ found:
                 * implements append-only directories.
                 */
                if ((dp->i_mode & ISVTX) &&
                 * implements append-only directories.
                 */
                if ((dp->i_mode & ISVTX) &&
-                   ndp->ni_cred->cr_uid != 0 &&
-                   ndp->ni_cred->cr_uid != dp->i_uid &&
-                   tdp->i_uid != ndp->ni_cred->cr_uid) {
-                       iput(tdp);
+                   cred->cr_uid != 0 &&
+                   cred->cr_uid != dp->i_uid &&
+                   VTOI(tdp)->i_uid != cred->cr_uid) {
+                       vput(tdp);
                        return (EPERM);
                }
                        return (EPERM);
                }
-               ndp->ni_vp = ITOV(tdp);
+               *vpp = tdp;
                if (!lockparent)
                if (!lockparent)
-                       IUNLOCK(dp);
+                       VOP_UNLOCK(vdp);
                return (0);
        }
 
                return (0);
        }
 
@@ -444,26 +461,27 @@ found:
         * Must get inode of directory entry to verify it's a
         * regular file, or empty directory.
         */
         * Must get inode of directory entry to verify it's a
         * regular file, or empty directory.
         */
-       if (flag == RENAME && wantparent && *ndp->ni_next == 0) {
-               if (error = ufs_access(vdp, VWRITE, ndp->ni_cred, p))
+       if (nameiop == RENAME && wantparent &&
+           (flags & ISLASTCN)) {
+               if (error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_proc))
                        return (error);
                /*
                 * Careful about locking second inode.
                 * This can only occur if the target is ".".
                 */
                        return (error);
                /*
                 * Careful about locking second inode.
                 * This can only occur if the target is ".".
                 */
-               if (dp->i_number == ndp->ni_ufs.ufs_ino)
+               if (dp->i_number == dp->i_ino)
                        return (EISDIR);
                        return (EISDIR);
-               if (error = iget(dp, ndp->ni_ufs.ufs_ino, &tdp))
+               if (error = VFS_VGET(vdp->v_mount, dp->i_ino, &tdp))
                        return (error);
                        return (error);
-               ndp->ni_vp = ITOV(tdp);
-               ndp->ni_nameiop |= SAVENAME;
+               *vpp = tdp;
+               cnp->cn_flags |= SAVENAME;
                if (!lockparent)
                if (!lockparent)
-                       IUNLOCK(dp);
+                       VOP_UNLOCK(vdp);
                return (0);
        }
 
        /*
                return (0);
        }
 
        /*
-        * Step through the translation in the name.  We do not `iput' the
+        * Step through the translation in the name.  We do not `vput' the
         * directory because we may need it again if a symbolic link
         * is relative to the current directory.  Instead we save it
         * unlocked as "pdp".  We must get the target inode before unlocking
         * directory because we may need it again if a symbolic link
         * is relative to the current directory.  Instead we save it
         * unlocked as "pdp".  We must get the target inode before unlocking
@@ -481,45 +499,50 @@ found:
         * work if the file system has any hard links other than ".."
         * that point backwards in the directory structure.
         */
         * work if the file system has any hard links other than ".."
         * that point backwards in the directory structure.
         */
-       pdp = dp;
-       if (ndp->ni_isdotdot) {
-               IUNLOCK(pdp);   /* race to get the inode */
-               if (error = iget(dp, ndp->ni_ufs.ufs_ino, &tdp)) {
-                       ILOCK(pdp);
+       pdp = vdp;
+       if (flags & ISDOTDOT) {
+               VOP_UNLOCK(pdp);        /* race to get the inode */
+               if (error = VFS_VGET(vdp->v_mount, dp->i_ino, &tdp)) {
+                       VOP_LOCK(pdp);
+                       return (error);
+               }
+               if (lockparent && (flags & ISLASTCN) &&
+                   (error = VOP_LOCK(pdp))) {
+                       vput(tdp);
                        return (error);
                }
                        return (error);
                }
-               if (lockparent && *ndp->ni_next == '\0')
-                       ILOCK(pdp);
-               ndp->ni_vp = ITOV(tdp);
-       } else if (dp->i_number == ndp->ni_ufs.ufs_ino) {
+               *vpp = tdp;
+       } else if (dp->i_number == dp->i_ino) {
                VREF(vdp);      /* we want ourself, ie "." */
                VREF(vdp);      /* we want ourself, ie "." */
-               ndp->ni_vp = vdp;
+               *vpp = vdp;
        } else {
        } else {
-               if (error = iget(dp, ndp->ni_ufs.ufs_ino, &tdp))
+               if (error = VFS_VGET(vdp->v_mount, dp->i_ino, &tdp))
                        return (error);
                        return (error);
-               if (!lockparent || *ndp->ni_next != '\0')
-                       IUNLOCK(pdp);
-               ndp->ni_vp = ITOV(tdp);
+               if (!lockparent || !(flags & ISLASTCN))
+                       VOP_UNLOCK(pdp);
+               *vpp = tdp;
        }
 
        /*
         * Insert name into cache if appropriate.
         */
        }
 
        /*
         * Insert name into cache if appropriate.
         */
-       if (ndp->ni_makeentry)
-               cache_enter(ndp);
+       if (cnp->cn_flags & MAKEENTRY)
+               cache_enter(vdp, *vpp, cnp);
        return (0);
 }
 
        return (0);
 }
 
-
-dirbad(ip, offset, how)
+void
+ufs_dirbad(ip, offset, how)
        struct inode *ip;
        struct inode *ip;
-       off_t offset;
+       doff_t offset;
        char *how;
 {
        char *how;
 {
+       struct mount *mp;
 
 
-       printf("%s: bad dir ino %d at offset %d: %s\n",
-           ip->i_fs->fs_fsmnt, ip->i_number, offset, how);
-       if (ip->i_fs->fs_ronly == 0)
+       mp = ITOV(ip)->v_mount;
+       (void)printf("%s: bad dir ino %d at offset %d: %s\n",
+           mp->mnt_stat.f_mntonname, ip->i_number, offset, how);
+       if ((mp->mnt_stat.f_flags & MNT_RDONLY) == 0)
                panic("bad dir");
 }
 
                panic("bad dir");
 }
 
@@ -531,63 +554,96 @@ dirbad(ip, offset, how)
  *     name is not longer than MAXNAMLEN
  *     name must be as long as advertised, and null terminated
  */
  *     name is not longer than MAXNAMLEN
  *     name must be as long as advertised, and null terminated
  */
-dirbadentry(ep, entryoffsetinblock)
+int
+ufs_dirbadentry(dp, ep, entryoffsetinblock)
+       struct vnode *dp;
        register struct direct *ep;
        int entryoffsetinblock;
 {
        register int i;
        register struct direct *ep;
        int entryoffsetinblock;
 {
        register int i;
+       int namlen;
 
 
+#      if (BYTE_ORDER == LITTLE_ENDIAN)
+               if (dp->v_mount->mnt_maxsymlinklen > 0)
+                       namlen = ep->d_namlen;
+               else
+                       namlen = ep->d_type;
+#      else
+               namlen = ep->d_namlen;
+#      endif
        if ((ep->d_reclen & 0x3) != 0 ||
            ep->d_reclen > DIRBLKSIZ - (entryoffsetinblock & (DIRBLKSIZ - 1)) ||
        if ((ep->d_reclen & 0x3) != 0 ||
            ep->d_reclen > DIRBLKSIZ - (entryoffsetinblock & (DIRBLKSIZ - 1)) ||
-           ep->d_reclen < DIRSIZ(ep) || ep->d_namlen > MAXNAMLEN)
-               return (1);
-       for (i = 0; i < ep->d_namlen; i++)
-               if (ep->d_name[i] == '\0')
-                       return (1);
+           ep->d_reclen < DIRSIZ(FSFMT(dp), ep) || namlen > MAXNAMLEN) {
+               /*return (1); */
+               printf("First bad\n");
+               goto bad;
+       }
+       for (i = 0; i < namlen; i++)
+               if (ep->d_name[i] == '\0') {
+                       /*return (1); */
+                       printf("Second bad\n");
+                       goto bad;
+       }
+       if (ep->d_name[i])
+               goto bad;
        return (ep->d_name[i]);
        return (ep->d_name[i]);
+bad:
+       return(1);
 }
 
 /*
  * Write a directory entry after a call to namei, using the parameters
  * that it left in nameidata.  The argument ip is the inode which the new
 }
 
 /*
  * Write a directory entry after a call to namei, using the parameters
  * that it left in nameidata.  The argument ip is the inode which the new
- * directory entry will refer to.  The nameidata field ndp->ni_dvp is a
- * pointer to the directory to be written, which was left locked by namei.
- * Remaining parameters (ndp->ni_ufs.ufs_offset, ndp->ni_ufs.ufs_count)
- * indicate how the space for the new entry is to be obtained.
+ * directory entry will refer to.  Dvp is a pointer to the directory to
+ * be written, which was left locked by namei. Remaining parameters
+ * (dp->i_offset, dp->i_count) indicate how the space for the new
+ * entry is to be obtained.
  */
  */
-direnter(ip, ndp)
+int
+ufs_direnter(ip, dvp, cnp)
        struct inode *ip;
        struct inode *ip;
-       register struct nameidata *ndp;
+       struct vnode *dvp;
+       register struct componentname *cnp;
 {
        register struct direct *ep, *nep;
 {
        register struct direct *ep, *nep;
-       register struct inode *dp = VTOI(ndp->ni_dvp);
+       register struct inode *dp;
        struct buf *bp;
        struct buf *bp;
-       int loc, spacefree, error = 0;
+       struct direct newdir;
+       struct iovec aiov;
+       struct uio auio;
        u_int dsize;
        u_int dsize;
-       int newentrysize;
+       int error, loc, newentrysize, spacefree;
        char *dirbuf;
        char *dirbuf;
-       struct uio auio;
-       struct iovec aiov;
-       struct direct newdir;
 
 #ifdef DIAGNOSTIC
 
 #ifdef DIAGNOSTIC
-       if ((ndp->ni_nameiop & SAVENAME) == 0)
+       if ((cnp->cn_flags & SAVENAME) == 0)
                panic("direnter: missing name");
 #endif
                panic("direnter: missing name");
 #endif
+       dp = VTOI(dvp);
        newdir.d_ino = ip->i_number;
        newdir.d_ino = ip->i_number;
-       newdir.d_namlen = ndp->ni_namelen;
-       bcopy(ndp->ni_ptr, newdir.d_name, (unsigned)ndp->ni_namelen + 1);
-       newentrysize = DIRSIZ(&newdir);
-       if (ndp->ni_ufs.ufs_count == 0) {
+       newdir.d_namlen = cnp->cn_namelen;
+       bcopy(cnp->cn_nameptr, newdir.d_name, (unsigned)cnp->cn_namelen + 1);
+       if (dvp->v_mount->mnt_maxsymlinklen > 0)
+               newdir.d_type = IFTODT(ip->i_mode);
+       else {
+               newdir.d_type = 0;
+#              if (BYTE_ORDER == LITTLE_ENDIAN)
+                       { u_char tmp = newdir.d_namlen;
+                       newdir.d_namlen = newdir.d_type;
+                       newdir.d_type = tmp; }
+#              endif
+       }
+       newentrysize = DIRSIZ(FSFMT(dvp), &newdir);
+       if (dp->i_count == 0) {
                /*
                /*
-                * If ndp->ni_ufs.ufs_count is 0, then namei could find no
-                * space in the directory. Here, ndp->ni_ufs.ufs_offset will
+                * If dp->i_count is 0, then namei could find no
+                * space in the directory. Here, dp->i_offset will
                 * be on a directory block boundary and we will write the
                 * new entry into a fresh block.
                 */
                 * be on a directory block boundary and we will write the
                 * new entry into a fresh block.
                 */
-               if (ndp->ni_ufs.ufs_offset & (DIRBLKSIZ - 1))
+               if (dp->i_offset & (DIRBLKSIZ - 1))
                        panic("wdir: newblk");
                        panic("wdir: newblk");
-               auio.uio_offset = ndp->ni_ufs.ufs_offset;
+               auio.uio_offset = dp->i_offset;
                newdir.d_reclen = DIRBLKSIZ;
                auio.uio_resid = newentrysize;
                aiov.iov_len = newentrysize;
                newdir.d_reclen = DIRBLKSIZ;
                auio.uio_resid = newentrysize;
                aiov.iov_len = newentrysize;
@@ -597,10 +653,12 @@ direnter(ip, ndp)
                auio.uio_rw = UIO_WRITE;
                auio.uio_segflg = UIO_SYSSPACE;
                auio.uio_procp = (struct proc *)0;
                auio.uio_rw = UIO_WRITE;
                auio.uio_segflg = UIO_SYSSPACE;
                auio.uio_procp = (struct proc *)0;
-               error = ufs_write(ndp->ni_dvp, &auio, IO_SYNC, ndp->ni_cred);
-               if (DIRBLKSIZ > dp->i_fs->fs_fsize) {
-                       panic("wdir: blksize"); /* XXX - should grow w/balloc */
-               } else if (!error) {
+               error = VOP_WRITE(dvp, &auio, IO_SYNC, cnp->cn_cred);
+               if (DIRBLKSIZ >
+                   VFSTOUFS(dvp->v_mount)->um_mountp->mnt_stat.f_bsize)
+                       /* XXX should grow with balloc() */
+                       panic("ufs_direnter: frag size");
+               else if (!error) {
                        dp->i_size = roundup(dp->i_size, DIRBLKSIZ);
                        dp->i_flag |= ICHG;
                }
                        dp->i_size = roundup(dp->i_size, DIRBLKSIZ);
                        dp->i_flag |= ICHG;
                }
@@ -608,9 +666,9 @@ direnter(ip, ndp)
        }
 
        /*
        }
 
        /*
-        * If ndp->ni_ufs.ufs_count is non-zero, then namei found space
-        * for the new entry in the range ndp->ni_ufs.ufs_offset to
-        * ndp->ni_ufs.ufs_offset + ndp->ni_ufs.ufs_count in the directory.
+        * If dp->i_count is non-zero, then namei found space
+        * for the new entry in the range dp->i_offset to
+        * dp->i_offset + dp->i_count in the directory.
         * To use this space, we may have to compact the entries located
         * there, by copying them together towards the beginning of the
         * block, leaving the free space in one usable chunk at the end.
         * To use this space, we may have to compact the entries located
         * there, by copying them together towards the beginning of the
         * block, leaving the free space in one usable chunk at the end.
@@ -623,24 +681,24 @@ direnter(ip, ndp)
         *
         * N.B. - THIS IS AN ARTIFACT OF 4.2 AND SHOULD NEVER HAPPEN.
         */
         *
         * N.B. - THIS IS AN ARTIFACT OF 4.2 AND SHOULD NEVER HAPPEN.
         */
-       if (ndp->ni_ufs.ufs_offset + ndp->ni_ufs.ufs_count > dp->i_size)
-               dp->i_size = ndp->ni_ufs.ufs_offset + ndp->ni_ufs.ufs_count;
+       if (dp->i_offset + dp->i_count > dp->i_size)
+               dp->i_size = dp->i_offset + dp->i_count;
        /*
         * Get the block containing the space for the new directory entry.
         */
        /*
         * Get the block containing the space for the new directory entry.
         */
-       if (error = blkatoff(dp, ndp->ni_ufs.ufs_offset, (char **)&dirbuf, &bp))
+       if (error = VOP_BLKATOFF(dvp, (off_t)dp->i_offset, &dirbuf, &bp))
                return (error);
        /*
         * Find space for the new entry. In the simple case, the entry at
         * offset base will have the space. If it does not, then namei
                return (error);
        /*
         * Find space for the new entry. In the simple case, the entry at
         * offset base will have the space. If it does not, then namei
-        * arranged that compacting the region ndp->ni_ufs.ufs_offset to
-        * ndp->ni_ufs.ufs_offset + ndp->ni_ufs.ufs_count would yield the
+        * arranged that compacting the region dp->i_offset to
+        * dp->i_offset + dp->i_count would yield the
         * space.
         */
        ep = (struct direct *)dirbuf;
         * space.
         */
        ep = (struct direct *)dirbuf;
-       dsize = DIRSIZ(ep);
+       dsize = DIRSIZ(FSFMT(dvp), ep);
        spacefree = ep->d_reclen - dsize;
        spacefree = ep->d_reclen - dsize;
-       for (loc = ep->d_reclen; loc < ndp->ni_ufs.ufs_count; ) {
+       for (loc = ep->d_reclen; loc < dp->i_count; ) {
                nep = (struct direct *)(dirbuf + loc);
                if (ep->d_ino) {
                        /* trim the existing slot */
                nep = (struct direct *)(dirbuf + loc);
                if (ep->d_ino) {
                        /* trim the existing slot */
@@ -650,7 +708,7 @@ direnter(ip, ndp)
                        /* overwrite; nothing there; header is ours */
                        spacefree += dsize;
                }
                        /* overwrite; nothing there; header is ours */
                        spacefree += dsize;
                }
-               dsize = DIRSIZ(nep);
+               dsize = DIRSIZ(FSFMT(dvp), nep);
                spacefree += nep->d_reclen - dsize;
                loc += nep->d_reclen;
                bcopy((caddr_t)nep, (caddr_t)ep, dsize);
                spacefree += nep->d_reclen - dsize;
                loc += nep->d_reclen;
                bcopy((caddr_t)nep, (caddr_t)ep, dsize);
@@ -671,19 +729,19 @@ direnter(ip, ndp)
                ep = (struct direct *)((char *)ep + dsize);
        }
        bcopy((caddr_t)&newdir, (caddr_t)ep, (u_int)newentrysize);
                ep = (struct direct *)((char *)ep + dsize);
        }
        bcopy((caddr_t)&newdir, (caddr_t)ep, (u_int)newentrysize);
-       error = bwrite(bp);
+       error = VOP_BWRITE(bp);
        dp->i_flag |= IUPD|ICHG;
        dp->i_flag |= IUPD|ICHG;
-       if (!error && ndp->ni_ufs.ufs_endoff &&
-           ndp->ni_ufs.ufs_endoff < dp->i_size)
-               error = itrunc(dp, (u_long)ndp->ni_ufs.ufs_endoff, IO_SYNC);
+       if (!error && dp->i_endoff && dp->i_endoff < dp->i_size)
+               error = VOP_TRUNCATE(dvp, (off_t)dp->i_endoff, IO_SYNC,
+                   cnp->cn_cred, cnp->cn_proc);
        return (error);
 }
 
 /*
  * Remove a directory entry after a call to namei, using
  * the parameters which it left in nameidata. The entry
        return (error);
 }
 
 /*
  * Remove a directory entry after a call to namei, using
  * the parameters which it left in nameidata. The entry
- * ni_ufs.ufs_offset contains the offset into the directory of the
- * entry to be eliminated.  The ni_ufs.ufs_count field contains the
+ * dp->i_offset contains the offset into the directory of the
+ * entry to be eliminated.  The dp->i_count field contains the
  * size of the previous record in the directory.  If this
  * is 0, the first entry is being deleted, so we need only
  * zero the inode number to mark the entry as free.  If the
  * size of the previous record in the directory.  If this
  * is 0, the first entry is being deleted, so we need only
  * zero the inode number to mark the entry as free.  If the
@@ -691,35 +749,37 @@ direnter(ip, ndp)
  * the space of the now empty record by adding the record size
  * to the size of the previous entry.
  */
  * the space of the now empty record by adding the record size
  * to the size of the previous entry.
  */
-dirremove(ndp)
-       register struct nameidata *ndp;
+int
+ufs_dirremove(dvp, cnp)
+       struct vnode *dvp;
+       struct componentname *cnp;
 {
 {
-       register struct inode *dp = VTOI(ndp->ni_dvp);
+       register struct inode *dp;
        struct direct *ep;
        struct buf *bp;
        int error;
 
        struct direct *ep;
        struct buf *bp;
        int error;
 
-       if (ndp->ni_ufs.ufs_count == 0) {
+       dp = VTOI(dvp);
+       if (dp->i_count == 0) {
                /*
                 * First entry in block: set d_ino to zero.
                 */
                /*
                 * First entry in block: set d_ino to zero.
                 */
-               error = blkatoff(dp, ndp->ni_ufs.ufs_offset, (char **)&ep, &bp);
-               if (error)
+               if (error =
+                   VOP_BLKATOFF(dvp, (off_t)dp->i_offset, (char **)&ep, &bp))
                        return (error);
                ep->d_ino = 0;
                        return (error);
                ep->d_ino = 0;
-               error = bwrite(bp);
+               error = VOP_BWRITE(bp);
                dp->i_flag |= IUPD|ICHG;
                return (error);
        }
        /*
         * Collapse new free space into previous entry.
         */
                dp->i_flag |= IUPD|ICHG;
                return (error);
        }
        /*
         * Collapse new free space into previous entry.
         */
-       if (error = blkatoff(dp, ndp->ni_ufs.ufs_offset - ndp->ni_ufs.ufs_count,
-           (char **)&ep, &bp)) {
+       if (error = VOP_BLKATOFF(dvp, (off_t)(dp->i_offset - dp->i_count),
+           (char **)&ep, &bp))
                return (error);
                return (error);
-       }
-       ep->d_reclen += ndp->ni_ufs.ufs_reclen;
-       error = bwrite(bp);
+       ep->d_reclen += dp->i_reclen;
+       error = VOP_BWRITE(bp);
        dp->i_flag |= IUPD|ICHG;
        return (error);
 }
        dp->i_flag |= IUPD|ICHG;
        return (error);
 }
@@ -729,52 +789,26 @@ dirremove(ndp)
  * supplied.  The parameters describing the directory entry are
  * set up by a call to namei.
  */
  * supplied.  The parameters describing the directory entry are
  * set up by a call to namei.
  */
-dirrewrite(dp, ip, ndp)
+int
+ufs_dirrewrite(dp, ip, cnp)
        struct inode *dp, *ip;
        struct inode *dp, *ip;
-       struct nameidata *ndp;
+       struct componentname *cnp;
 {
 {
-       struct direct *ep;
        struct buf *bp;
        struct buf *bp;
+       struct direct *ep;
+       struct vnode *vdp = ITOV(dp);
        int error;
 
        int error;
 
-       if (error = blkatoff(dp, ndp->ni_ufs.ufs_offset, (char **)&ep, &bp))
+       if (error = VOP_BLKATOFF(vdp, (off_t)dp->i_offset, (char **)&ep, &bp))
                return (error);
        ep->d_ino = ip->i_number;
                return (error);
        ep->d_ino = ip->i_number;
-       error = bwrite(bp);
+       if (vdp->v_mount->mnt_maxsymlinklen > 0)
+               ep->d_type = IFTODT(ip->i_mode);
+       error = VOP_BWRITE(bp);
        dp->i_flag |= IUPD|ICHG;
        return (error);
 }
 
        dp->i_flag |= IUPD|ICHG;
        return (error);
 }
 
-/*
- * Return buffer with contents of block "offset"
- * from the beginning of directory "ip".  If "res"
- * is non-zero, fill it in with a pointer to the
- * remaining space in the directory.
- */
-blkatoff(ip, offset, res, bpp)
-       struct inode *ip;
-       off_t offset;
-       char **res;
-       struct buf **bpp;
-{
-       register struct fs *fs = ip->i_fs;
-       daddr_t lbn = lblkno(fs, offset);
-       int bsize = blksize(fs, ip, lbn);
-       struct buf *bp;
-       daddr_t bn;
-       int error;
-
-       *bpp = 0;
-       if (error = bread(ITOV(ip), lbn, bsize, NOCRED, &bp)) {
-               brelse(bp);
-               return (error);
-       }
-       if (res)
-               *res = bp->b_un.b_addr + blkoff(fs, offset);
-       *bpp = bp;
-       return (0);
-}
-
 /*
  * Check if a directory is empty or not.
  * Inode supplied must be locked.
 /*
  * Check if a directory is empty or not.
  * Inode supplied must be locked.
@@ -784,7 +818,8 @@ blkatoff(ip, offset, res, bpp)
  *
  * NB: does not handle corrupted directories.
  */
  *
  * NB: does not handle corrupted directories.
  */
-dirempty(ip, parentino, cred)
+int
+ufs_dirempty(ip, parentino, cred)
        register struct inode *ip;
        ino_t parentino;
        struct ucred *cred;
        register struct inode *ip;
        ino_t parentino;
        struct ucred *cred;
@@ -792,7 +827,7 @@ dirempty(ip, parentino, cred)
        register off_t off;
        struct dirtemplate dbuf;
        register struct direct *dp = (struct direct *)&dbuf;
        register off_t off;
        struct dirtemplate dbuf;
        register struct direct *dp = (struct direct *)&dbuf;
-       int error, count;
+       int error, count, namlen;
 #define        MINDIRSIZ (sizeof (struct dirtemplate) / 2)
 
        for (off = 0; off < ip->i_size; off += dp->d_reclen) {
 #define        MINDIRSIZ (sizeof (struct dirtemplate) / 2)
 
        for (off = 0; off < ip->i_size; off += dp->d_reclen) {
@@ -811,16 +846,24 @@ dirempty(ip, parentino, cred)
                if (dp->d_ino == 0)
                        continue;
                /* accept only "." and ".." */
                if (dp->d_ino == 0)
                        continue;
                /* accept only "." and ".." */
-               if (dp->d_namlen > 2)
+#              if (BYTE_ORDER == LITTLE_ENDIAN)
+                       if (ITOV(ip)->v_mount->mnt_maxsymlinklen > 0)
+                               namlen = dp->d_namlen;
+                       else
+                               namlen = dp->d_type;
+#              else
+                       namlen = dp->d_namlen;
+#              endif
+               if (namlen > 2)
                        return (0);
                if (dp->d_name[0] != '.')
                        return (0);
                /*
                        return (0);
                if (dp->d_name[0] != '.')
                        return (0);
                /*
-                * At this point d_namlen must be 1 or 2.
+                * At this point namlen must be 1 or 2.
                 * 1 implies ".", 2 implies ".." if second
                 * char is also "."
                 */
                 * 1 implies ".", 2 implies ".." if second
                 * char is also "."
                 */
-               if (dp->d_namlen == 1)
+               if (namlen == 1)
                        continue;
                if (dp->d_name[1] == '.' && dp->d_ino == parentino)
                        continue;
                        continue;
                if (dp->d_name[1] == '.' && dp->d_ino == parentino)
                        continue;
@@ -832,35 +875,46 @@ dirempty(ip, parentino, cred)
 /*
  * Check if source directory is in the path of the target directory.
  * Target is supplied locked, source is unlocked.
 /*
  * Check if source directory is in the path of the target directory.
  * Target is supplied locked, source is unlocked.
- * The target is always iput() before returning.
+ * The target is always vput before returning.
  */
  */
-checkpath(source, target, cred)
+int
+ufs_checkpath(source, target, cred)
        struct inode *source, *target;
        struct ucred *cred;
 {
        struct inode *source, *target;
        struct ucred *cred;
 {
+       struct vnode *vp;
+       int error, rootino, namlen;
        struct dirtemplate dirbuf;
        struct dirtemplate dirbuf;
-       struct inode *ip;
-       int error = 0;
 
 
-       ip = target;
-       if (ip->i_number == source->i_number) {
+       vp = ITOV(target);
+       if (target->i_number == source->i_number) {
                error = EEXIST;
                goto out;
        }
                error = EEXIST;
                goto out;
        }
-       if (ip->i_number == ROOTINO)
+       rootino = ROOTINO;
+       error = 0;
+       if (target->i_number == rootino)
                goto out;
 
        for (;;) {
                goto out;
 
        for (;;) {
-               if ((ip->i_mode&IFMT) != IFDIR) {
+               if (vp->v_type != VDIR) {
                        error = ENOTDIR;
                        break;
                }
                        error = ENOTDIR;
                        break;
                }
-               error = vn_rdwr(UIO_READ, ITOV(ip), (caddr_t)&dirbuf,
+               error = vn_rdwr(UIO_READ, vp, (caddr_t)&dirbuf,
                        sizeof (struct dirtemplate), (off_t)0, UIO_SYSSPACE,
                        IO_NODELOCKED, cred, (int *)0, (struct proc *)0);
                if (error != 0)
                        break;
                        sizeof (struct dirtemplate), (off_t)0, UIO_SYSSPACE,
                        IO_NODELOCKED, cred, (int *)0, (struct proc *)0);
                if (error != 0)
                        break;
-               if (dirbuf.dotdot_namlen != 2 ||
+#              if (BYTE_ORDER == LITTLE_ENDIAN)
+                       if (vp->v_mount->mnt_maxsymlinklen > 0)
+                               namlen = dirbuf.dotdot_namlen;
+                       else
+                               namlen = dirbuf.dotdot_type;
+#              else
+                       namlen = dirbuf.dotdot_namlen;
+#              endif
+               if (namlen != 2 ||
                    dirbuf.dotdot_name[0] != '.' ||
                    dirbuf.dotdot_name[1] != '.') {
                        error = ENOTDIR;
                    dirbuf.dotdot_name[0] != '.' ||
                    dirbuf.dotdot_name[1] != '.') {
                        error = ENOTDIR;
@@ -870,17 +924,19 @@ checkpath(source, target, cred)
                        error = EINVAL;
                        break;
                }
                        error = EINVAL;
                        break;
                }
-               if (dirbuf.dotdot_ino == ROOTINO)
+               if (dirbuf.dotdot_ino == rootino)
                        break;
                        break;
-               iput(ip);
-               if (error = iget(ip, dirbuf.dotdot_ino, &ip))
+               vput(vp);
+               if (error = VFS_VGET(vp->v_mount, dirbuf.dotdot_ino, &vp)) {
+                       vp = NULL;
                        break;
                        break;
+               }
        }
 
 out:
        if (error == ENOTDIR)
                printf("checkpath: .. not a directory\n");
        }
 
 out:
        if (error == ENOTDIR)
                printf("checkpath: .. not a directory\n");
-       if (ip != NULL)
-               iput(ip);
+       if (vp != NULL)
+               vput(vp);
        return (error);
 }
        return (error);
 }
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.