describe ap (Kirk); delete lfs_mntinvalbuf, lfs_vinvalbuf, add

[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 f4a30e7..c43e132 100644 (file)
--- a/usr/src/sys/ufs/ffs/ufs_lookup.c
+++ b/usr/src/sys/ufs/ffs/ufs_lookup.c
@@ -4,7 +4,7 @@
  *
  * %sccs.include.redist.c%
  *
  *
  * %sccs.include.redist.c%
  *

- *     @(#)ufs_lookup.c        7.40 (Berkeley) %G%
+ *     @(#)ufs_lookup.c        7.50 (Berkeley) %G%

  */
 
 #include <sys/param.h>
  */
 
 #include <sys/param.h>


@@ -27,14 +27,16 @@ 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 cnp->cn_nameiop 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
  * 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


@@ -63,45 +65,53 @@ int dirchk = 0;
  * NOTE: (LOOKUP | LOCKPARENT) currently returns the parent inode unlocked.
  */
 int
  * NOTE: (LOOKUP | LOCKPARENT) currently returns the parent inode unlocked.
  */
 int

-ufs_lookup(dvp, vpp, cnp)
-       struct vnode *dvp;
-       struct vnode **vpp;
-       struct componentname *cnp;
+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 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;
        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;

-       int slotoffset;                 /* 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;                    /* prev entry dp->i_offset */
+       doff_t endsearch;               /* offset to end directory search */
+       doff_t prevoff;                 /* prev entry dp->i_offset */

        struct inode *pdp;              /* saved dp during symlink work */
        struct inode *pdp;              /* saved dp during symlink work */

-       struct vnode *tdp;              /* returned by VOP_VGET */
-       off_t enduseful;                /* pointer past last used dir slot */
+       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 */
        u_long bmask;                   /* block offset mask */
        int lockparent;                 /* 1 => lockparent flag is set */
        int wantparent;                 /* 1 => wantparent or lockparent flag */

-       int error;
-       struct vnode *vdp = dvp;        /* saved for one special case */
+       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;
 
        bp = NULL;
        slotoffset = -1;
        *vpp = NULL;

-       dp = VTOI(dvp);
-       lockparent = cnp->cn_flags & LOCKPARENT;
-       wantparent = cnp->cn_flags & (LOCKPARENT|WANTPARENT);
+       vdp = ap->a_dvp;
+       dp = VTOI(vdp);
+       lockparent = flags & LOCKPARENT;
+       wantparent = flags & (LOCKPARENT|WANTPARENT);

 
        /*
         * Check accessiblity of directory.
         */
        if ((dp->i_mode & IFMT) != IFDIR)
                return (ENOTDIR);
 
        /*
         * Check accessiblity of directory.
         */
        if ((dp->i_mode & IFMT) != IFDIR)
                return (ENOTDIR);

-       if (error = ufs_access(dvp, VEXEC, cnp->cn_cred, cnp->cn_proc))
+       if (error = VOP_ACCESS(vdp, VEXEC, cred, cnp->cn_proc))

                return (error);
 
        /*
                return (error);
 
        /*


@@ -111,41 +121,31 @@ ufs_lookup(dvp, vpp, cnp)
         * 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(dvp, vpp, cnp)) {
+       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 (dvp == ndp->ni_rdir && (cnp->cn_flags & 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.
                 */

-               /*
-                * The borrowing of variables
-                * here is somewhat confusing.  Usually, dvp/dp
-                * is the directory being searched.
-                * Here it's the target returned from the cache.
-                */

                pdp = dp;
                dp = VTOI(*vpp);
                pdp = dp;
                dp = VTOI(*vpp);

-               dvp = *vpp;
-               vpid = dvp->v_id;
+               vdp = *vpp;
+               vpid = vdp->v_id;

                if (pdp == dp) {   /* lookup on "." */
                if (pdp == dp) {   /* lookup on "." */

-                       VREF(dvp);
+                       VREF(vdp);

                        error = 0;
                        error = 0;

-               } else if (cnp->cn_flags & ISDOTDOT) {
+               } else if (flags & ISDOTDOT) {

                        IUNLOCK(pdp);
                        IUNLOCK(pdp);

-                       error = vget(dvp);
-                       if (!error && lockparent && (cnp->cn_flags & ISLASTCN))
+                       error = vget(vdp);
+                       if (!error && lockparent && (flags & ISLASTCN))

                                ILOCK(pdp);
                } else {
                                ILOCK(pdp);
                } else {

-                       error = vget(dvp);
-                       if (!lockparent || error || !(cnp->cn_flags & ISLASTCN))
+                       error = vget(vdp);
+                       if (!lockparent || error || !(flags & ISLASTCN))

                                IUNLOCK(pdp);
                }
                /*
                                IUNLOCK(pdp);
                }
                /*


@@ -153,16 +153,16 @@ ufs_lookup(dvp, vpp, cnp)
                 * while we were waiting for the lock.
                 */
                if (!error) {
                 * while we were waiting for the lock.
                 */
                if (!error) {

-                       if (vpid == dvp->v_id)
+                       if (vpid == vdp->v_id)

                                return (0);
                        ufs_iput(dp);
                        if (lockparent && pdp != dp &&
                                return (0);
                        ufs_iput(dp);
                        if (lockparent && pdp != dp &&

-                           (cnp->cn_flags & ISLASTCN))
+                           (flags & ISLASTCN))

                                IUNLOCK(pdp);
                }
                ILOCK(pdp);
                dp = pdp;
                                IUNLOCK(pdp);
                }
                ILOCK(pdp);
                dp = pdp;

-               dvp = ITOV(dp);
+               vdp = ITOV(dp);

                *vpp = NULL;
        }
 
                *vpp = NULL;
        }
 


@@ -173,12 +173,12 @@ ufs_lookup(dvp, vpp, cnp)
         * case it doesn't already exist.
         */
        slotstatus = FOUND;
         * case it doesn't already exist.
         */
        slotstatus = FOUND;

-       if ((cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME) &&
-           (cnp->cn_flags & ISLASTCN)) {
+       slotfreespace = slotsize = slotneeded = 0;
+       if ((nameiop == CREATE || nameiop == RENAME) &&
+           (flags & ISLASTCN)) {

                slotstatus = NONE;
                slotstatus = NONE;

-               slotfreespace = 0;
-               slotneeded = ((sizeof (struct direct) - (MAXNAMLEN + 1)) +
-                       ((cnp->cn_namelen + 1 + 3) &~ 3));
+               slotneeded = (sizeof(struct direct) - MAXNAMLEN +
+                       cnp->cn_namelen + 3) &~ 3;

        }
 
        /*
        }
 
        /*


@@ -192,19 +192,21 @@ ufs_lookup(dvp, vpp, cnp)
         * profiling time and hence has been removed in the interest
         * of simplicity.
         */
         * profiling time and hence has been removed in the interest
         * of simplicity.
         */

-       bmask = VFSTOUFS(dvp->v_mount)->um_mountp->mnt_stat.f_iosize - 1;
-       if (cnp->cn_nameiop != LOOKUP || dp->i_diroff == 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) {
            dp->i_diroff > dp->i_size) {

+               entryoffsetinblock = 0;

                dp->i_offset = 0;
                numdirpasses = 1;
        } else {
                dp->i_offset = dp->i_diroff;
                if ((entryoffsetinblock = dp->i_offset & bmask) &&
                dp->i_offset = 0;
                numdirpasses = 1;
        } else {
                dp->i_offset = dp->i_diroff;
                if ((entryoffsetinblock = dp->i_offset & bmask) &&

-                   (error = VOP_BLKATOFF(dvp, dp->i_offset, NULL, &bp)))
+                   (error = VOP_BLKATOFF(vdp, (off_t)dp->i_offset, NULL, &bp)))

                        return (error);
                numdirpasses = 2;
                nchstats.ncs_2passes++;
        }
                        return (error);
                numdirpasses = 2;
                nchstats.ncs_2passes++;
        }

+       prevoff = dp->i_offset;

        endsearch = roundup(dp->i_size, DIRBLKSIZ);
        enduseful = 0;
 
        endsearch = roundup(dp->i_size, DIRBLKSIZ);
        enduseful = 0;
 


@@ -217,7 +219,8 @@ searchloop:
                if ((dp->i_offset & bmask) == 0) {
                        if (bp != NULL)
                                brelse(bp);
                if ((dp->i_offset & bmask) == 0) {
                        if (bp != NULL)
                                brelse(bp);

-                       if (error = VOP_BLKATOFF(dvp, dp->i_offset, NULL, &bp))
+                       if (error =
+                           VOP_BLKATOFF(vdp, (off_t)dp->i_offset, NULL, &bp))

                                return (error);
                        entryoffsetinblock = 0;
                }
                                return (error);
                        entryoffsetinblock = 0;
                }


@@ -239,7 +242,7 @@ 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 && ufs_dirbadentry(ep, entryoffsetinblock)) {
+                   dirchk && ufs_dirbadentry(vdp, ep, entryoffsetinblock)) {

                        int i;
 
                        ufs_dirbad(dp, dp->i_offset, "mangled entry");
                        int i;
 
                        ufs_dirbad(dp, dp->i_offset, "mangled entry");


@@ -259,7 +262,7 @@ 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;


@@ -282,9 +285,17 @@ searchloop:
                 * Check for a name match.
                 */
                if (ep->d_ino) {
                 * Check for a name match.
                 */
                if (ep->d_ino) {

-                       if (ep->d_namlen == cnp->cn_namelen &&
+#                      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,
                            !bcmp(cnp->cn_nameptr, ep->d_name,

-                               (unsigned)ep->d_namlen)) {
+                               (unsigned)namlen)) {

                                /*
                                 * Save directory entry's inode number and
                                 * reclen in ndp->ni_ufs area, and release
                                /*
                                 * Save directory entry's inode number and
                                 * reclen in ndp->ni_ufs area, and release


@@ -320,13 +331,13 @@ 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 ((cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME) &&
-           (cnp->cn_flags & ISLASTCN) && 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(dvp, VWRITE, cnp->cn_cred, cnp->cn_proc))
+               if (error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_proc))

                        return (error);
                /*
                 * Return an indication of where the new directory
                        return (error);
                /*
                 * Return an indication of where the new directory


@@ -365,12 +376,13 @@ searchloop:
                cnp->cn_flags |= SAVENAME;
                if (!lockparent)
                        IUNLOCK(dp);
                cnp->cn_flags |= SAVENAME;
                if (!lockparent)
                        IUNLOCK(dp);

+               return (EJUSTRETURN);

        }
        /*
         * Insert name into cache (as non-existent) if appropriate.
         */
        }
        /*
         * Insert name into cache (as non-existent) if appropriate.
         */

-       if ((cnp->cn_flags & MAKEENTRY) && cnp->cn_nameiop != CREATE)
-               cache_enter(dvp, *vpp, cnp);
+       if ((flags & MAKEENTRY) && nameiop != CREATE)
+               cache_enter(vdp, *vpp, cnp);

        return (ENOENT);
 
 found:
        return (ENOENT);
 
 found:


@@ -380,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) {
+       if (entryoffsetinblock + DIRSIZ(FSFMT(vdp), ep) > dp->i_size) {

                ufs_dirbad(dp, dp->i_offset, "i_size too small");
                ufs_dirbad(dp, dp->i_offset, "i_size too small");

-               dp->i_size = entryoffsetinblock + DIRSIZ(ep);
+               dp->i_size = entryoffsetinblock + DIRSIZ(FSFMT(vdp), ep);

                dp->i_flag |= IUPD|ICHG;
        }
 
                dp->i_flag |= IUPD|ICHG;
        }
 


@@ -391,7 +403,7 @@ 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 ((cnp->cn_flags & ISLASTCN) && cnp->cn_nameiop == LOOKUP)
+       if ((flags & ISLASTCN) && nameiop == LOOKUP)

                dp->i_diroff = dp->i_offset &~ (DIRBLKSIZ - 1);
 
        /*
                dp->i_diroff = dp->i_offset &~ (DIRBLKSIZ - 1);
 
        /*


@@ -401,11 +413,11 @@ 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 (cnp->cn_nameiop == DELETE && (cnp->cn_flags & ISLASTCN)) {
+       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(dvp, VWRITE, cnp->cn_cred, cnp->cn_proc))
+               if (error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_proc))

                        return (error);
                /*
                 * Return pointer to current entry in dp->i_offset,
                        return (error);
                /*
                 * Return pointer to current entry in dp->i_offset,


@@ -422,7 +434,7 @@ found:
                        *vpp = vdp;
                        return (0);
                }
                        *vpp = vdp;
                        return (0);
                }

-               if (error = VOP_VGET(dvp, dp->i_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


@@ -431,9 +443,9 @@ found:
                 * implements append-only directories.
                 */
                if ((dp->i_mode & ISVTX) &&
                 * implements append-only directories.
                 */
                if ((dp->i_mode & ISVTX) &&

-                   cnp->cn_cred->cr_uid != 0 &&
-                   cnp->cn_cred->cr_uid != dp->i_uid &&
-                   VTOI(tdp)->i_uid != cnp->cn_cred->cr_uid) {
+                   cred->cr_uid != 0 &&
+                   cred->cr_uid != dp->i_uid &&
+                   VTOI(tdp)->i_uid != cred->cr_uid) {

                        vput(tdp);
                        return (EPERM);
                }
                        vput(tdp);
                        return (EPERM);
                }


@@ -449,9 +461,9 @@ 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 (cnp->cn_nameiop == RENAME && wantparent &&
-           (cnp->cn_flags & ISLASTCN)) {
-               if (error = ufs_access(dvp, VWRITE, cnp->cn_cred, cnp->cn_proc))
+       if (nameiop == RENAME && wantparent &&
+           (flags & ISLASTCN)) {
+               if (error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_proc))

                        return (error);
                /*
                 * Careful about locking second inode.
                        return (error);
                /*
                 * Careful about locking second inode.


@@ -459,7 +471,7 @@ found:
                 */
                if (dp->i_number == dp->i_ino)
                        return (EISDIR);
                 */
                if (dp->i_number == dp->i_ino)
                        return (EISDIR);

-               if (error = VOP_VGET(dvp, dp->i_ino, &tdp))
+               if (error = VFS_VGET(vdp->v_mount, dp->i_ino, &tdp))

                        return (error);
                *vpp = tdp;
                cnp->cn_flags |= SAVENAME;
                        return (error);
                *vpp = tdp;
                cnp->cn_flags |= SAVENAME;


@@ -488,22 +500,22 @@ found:
         * that point backwards in the directory structure.
         */
        pdp = dp;
         * that point backwards in the directory structure.
         */
        pdp = dp;

-       if (cnp->cn_flags & ISDOTDOT) {
+       if (flags & ISDOTDOT) {

                IUNLOCK(pdp);   /* race to get the inode */
                IUNLOCK(pdp);   /* race to get the inode */

-               if (error = VOP_VGET(dvp, dp->i_ino, &tdp)) {
+               if (error = VFS_VGET(vdp->v_mount, dp->i_ino, &tdp)) {

                        ILOCK(pdp);
                        return (error);
                }
                        ILOCK(pdp);
                        return (error);
                }

-               if (lockparent && (cnp->cn_flags & ISLASTCN))
+               if (lockparent && (flags & ISLASTCN))

                        ILOCK(pdp);
                *vpp = tdp;
        } else if (dp->i_number == dp->i_ino) {
                        ILOCK(pdp);
                *vpp = tdp;
        } else if (dp->i_number == dp->i_ino) {

-               VREF(dvp);      /* we want ourself, ie "." */
-               *vpp = dvp;
+               VREF(vdp);      /* we want ourself, ie "." */
+               *vpp = vdp;

        } else {
        } else {

-               if (error = VOP_VGET(dvp, dp->i_ino, &tdp))
+               if (error = VFS_VGET(vdp->v_mount, dp->i_ino, &tdp))

                        return (error);
                        return (error);

-               if (!lockparent || !(cnp->cn_flags & ISLASTCN))
+               if (!lockparent || !(flags & ISLASTCN))

                        IUNLOCK(pdp);
                *vpp = tdp;
        }
                        IUNLOCK(pdp);
                *vpp = tdp;
        }


@@ -511,15 +523,15 @@ found:
        /*
         * Insert name into cache if appropriate.
         */
        /*
         * Insert name into cache if appropriate.
         */

-       if (cnp->cn_flags & MAKEENTRY)
-               cache_enter(dvp, *vpp, cnp);
+       if (flags & MAKEENTRY)
+               cache_enter(vdp, *vpp, cnp);

        return (0);
 }
 
 void
 ufs_dirbad(ip, offset, how)
        struct inode *ip;
        return (0);
 }
 
 void
 ufs_dirbad(ip, offset, how)
        struct inode *ip;

-       off_t offset;
+       doff_t offset;

        char *how;
 {
        struct mount *mp;
        char *how;
 {
        struct mount *mp;


@@ -540,20 +552,30 @@ ufs_dirbad(ip, offset, how)
  *     name must be as long as advertised, and null terminated
  */
 int
  *     name must be as long as advertised, and null terminated
  */
 int

-ufs_dirbadentry(ep, entryoffsetinblock)
+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) {
+           ep->d_reclen < DIRSIZ(FSFMT(dp), ep) || namlen > MAXNAMLEN) {

                /*return (1); */
                printf("First bad\n");
                goto bad;
        }
                /*return (1); */
                printf("First bad\n");
                goto bad;
        }

-       for (i = 0; i < ep->d_namlen; i++)
+       for (i = 0; i < namlen; i++)

                if (ep->d_name[i] == '\0') {
                        /*return (1); */
                        printf("Second bad\n");
                if (ep->d_name[i] == '\0') {
                        /*return (1); */
                        printf("Second bad\n");


@@ -563,8 +585,6 @@ ufs_dirbadentry(ep, entryoffsetinblock)
                goto bad;
        return (ep->d_name[i]);
 bad:
                goto bad;
        return (ep->d_name[i]);
 bad:

-printf("ufs_dirbadentry: jumping out: reclen: %d namlen %d ino %d name %s\n",
-       ep->d_reclen, ep->d_namlen, ep->d_ino, ep->d_name );

        return(1);
 }
 
        return(1);
 }
 


@@ -600,7 +620,17 @@ ufs_direnter(ip, dvp, cnp)
        newdir.d_ino = ip->i_number;
        newdir.d_namlen = cnp->cn_namelen;
        bcopy(cnp->cn_nameptr, newdir.d_name, (unsigned)cnp->cn_namelen + 1);
        newdir.d_ino = ip->i_number;
        newdir.d_namlen = cnp->cn_namelen;
        bcopy(cnp->cn_nameptr, newdir.d_name, (unsigned)cnp->cn_namelen + 1);

-       newentrysize = DIRSIZ(&newdir);
+       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 dp->i_count is 0, then namei could find no
        if (dp->i_count == 0) {
                /*
                 * If dp->i_count is 0, then namei could find no


@@ -653,7 +683,7 @@ ufs_direnter(ip, dvp, cnp)
        /*
         * Get the block containing the space for the new directory entry.
         */
        /*
         * Get the block containing the space for the new directory entry.
         */

-       if (error = VOP_BLKATOFF(dvp, dp->i_offset, &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
                return (error);
        /*
         * Find space for the new entry. In the simple case, the entry at


@@ -663,7 +693,7 @@ ufs_direnter(ip, dvp, cnp)
         * space.
         */
        ep = (struct direct *)dirbuf;
         * space.
         */
        ep = (struct direct *)dirbuf;

-       dsize = DIRSIZ(ep);
+       dsize = DIRSIZ(FSFMT(dvp), ep);

        spacefree = ep->d_reclen - dsize;
        for (loc = ep->d_reclen; loc < dp->i_count; ) {
                nep = (struct direct *)(dirbuf + loc);
        spacefree = ep->d_reclen - dsize;
        for (loc = ep->d_reclen; loc < dp->i_count; ) {
                nep = (struct direct *)(dirbuf + loc);


@@ -675,7 +705,7 @@ ufs_direnter(ip, dvp, cnp)
                        /* 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);


@@ -699,7 +729,8 @@ ufs_direnter(ip, dvp, cnp)
        error = VOP_BWRITE(bp);
        dp->i_flag |= IUPD|ICHG;
        if (!error && dp->i_endoff && dp->i_endoff < dp->i_size)
        error = VOP_BWRITE(bp);
        dp->i_flag |= IUPD|ICHG;
        if (!error && dp->i_endoff && dp->i_endoff < dp->i_size)

-               error = VOP_TRUNCATE(dvp, (u_long)dp->i_endoff, IO_SYNC);
+               error = VOP_TRUNCATE(dvp, (off_t)dp->i_endoff, IO_SYNC,
+                   cnp->cn_cred, cnp->cn_proc);

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


@@ -730,7 +761,8 @@ ufs_dirremove(dvp, cnp)
                /*
                 * First entry in block: set d_ino to zero.
                 */
                /*
                 * First entry in block: set d_ino to zero.
                 */

-               if (error = VOP_BLKATOFF(dvp, dp->i_offset, (char **)&ep, &bp))
+               if (error =
+                   VOP_BLKATOFF(dvp, (off_t)dp->i_offset, (char **)&ep, &bp))

                        return (error);
                ep->d_ino = 0;
                error = VOP_BWRITE(bp);
                        return (error);
                ep->d_ino = 0;
                error = VOP_BWRITE(bp);


@@ -740,8 +772,8 @@ ufs_dirremove(dvp, cnp)
        /*
         * Collapse new free space into previous entry.
         */
        /*
         * Collapse new free space into previous entry.
         */

-       if (error = VOP_BLKATOFF(dvp,
-           dp->i_offset - dp->i_count, (char **)&ep, &bp))
+       if (error = VOP_BLKATOFF(dvp, (off_t)(dp->i_offset - dp->i_count),
+           (char **)&ep, &bp))

                return (error);
        ep->d_reclen += dp->i_reclen;
        error = VOP_BWRITE(bp);
                return (error);
        ep->d_reclen += dp->i_reclen;
        error = VOP_BWRITE(bp);


@@ -761,11 +793,14 @@ ufs_dirrewrite(dp, ip, cnp)
 {
        struct buf *bp;
        struct direct *ep;
 {
        struct buf *bp;
        struct direct *ep;

+       struct vnode *vdp = ITOV(dp);

        int error;
 
        int error;
 

-       if (error = VOP_BLKATOFF(ITOV(dp), dp->i_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;

+       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);
        error = VOP_BWRITE(bp);
        dp->i_flag |= IUPD|ICHG;
        return (error);


@@ -789,7 +824,7 @@ ufs_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) {


@@ -808,16 +843,24 @@ ufs_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;


@@ -839,7 +882,7 @@ ufs_checkpath(source, target, cred)
        struct dirtemplate dirbuf;
        register struct inode *ip;
        struct vnode *vp;
        struct dirtemplate dirbuf;
        register struct inode *ip;
        struct vnode *vp;

-       int error, rootino;
+       int error, rootino, namlen;

 
        ip = target;
        if (ip->i_number == source->i_number) {
 
        ip = target;
        if (ip->i_number == source->i_number) {


@@ -862,7 +905,15 @@ ufs_checkpath(source, target, cred)
                        IO_NODELOCKED, cred, (int *)0, (struct proc *)0);
                if (error != 0)
                        break;
                        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;


@@ -875,7 +926,7 @@ ufs_checkpath(source, target, cred)
                if (dirbuf.dotdot_ino == rootino)
                        break;
                ufs_iput(ip);
                if (dirbuf.dotdot_ino == rootino)
                        break;
                ufs_iput(ip);

-               if (error = VOP_VGET(vp, dirbuf.dotdot_ino, &vp))
+               if (error = VFS_VGET(vp->v_mount, dirbuf.dotdot_ino, &vp))

                        break;
                ip = VTOI(vp);
        }
                        break;
                ip = VTOI(vp);
        }