always round down directory offset to a DIRBLK boundry

[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 febe481..2d9e3eb 100644 (file)
--- a/usr/src/sys/ufs/ffs/ufs_lookup.c
+++ b/usr/src/sys/ufs/ffs/ufs_lookup.c
@@ -3,7 +3,7 @@
  * All rights reserved.  The Berkeley software License Agreement
  * specifies the terms and conditions for redistribution.
  *
  * All rights reserved.  The Berkeley software License Agreement
  * specifies the terms and conditions for redistribution.
  *

- *     @(#)ufs_lookup.c        6.24 (Berkeley) %G%
+ *     @(#)ufs_lookup.c        6.30 (Berkeley) %G%

  */
 
 #include "param.h"
  */
 
 #include "param.h"


@@ -33,58 +33,55 @@ int dirchk = 0;
 #define        NHASH(h, i, d)  ((unsigned)((h) + (i) + 13 * (int)(d)) & ((NCHHASH)-1))
 #endif
 
 #define        NHASH(h, i, d)  ((unsigned)((h) + (i) + 13 * (int)(d)) & ((NCHHASH)-1))
 #endif
 

-union  nchash  {
-       union   nchash  *nch_head[2];
-       struct  nch     *nch_chain[2];
+union nchash {
+       union   nchash *nch_head[2];
+       struct  namecache *nch_chain[2];

 } nchash[NCHHASH];
 #define        nch_forw        nch_chain[0]
 #define        nch_back        nch_chain[1]
 
 } nchash[NCHHASH];
 #define        nch_forw        nch_chain[0]
 #define        nch_back        nch_chain[1]
 

-struct nch     *nchhead, **nchtail;    /* LRU chain pointers */
+struct namecache *nchhead, **nchtail;  /* LRU chain pointers */

 struct nchstats nchstats;              /* cache effectiveness statistics */
 
 /*
 struct nchstats nchstats;              /* cache effectiveness statistics */
 
 /*

- * Convert a pathname into a pointer to a locked inode,
- * with side effects usable in creating and removing files.
+ * Convert a pathname into a pointer to a locked inode.

  * This is a very central and rather complicated routine.
  * This is a very central and rather complicated routine.

- *
- * The segflg defines whether the name is to be copied from user
- * space or kernel space.
- *
- * The flag argument is (LOOKUP, CREATE, DELETE) depending on whether
- * the name is to be (looked up, created, deleted).  If flag has
- * LOCKPARENT or'ed into it and the target of the pathname exists,
- * namei returns both the target and its parent directory locked. 

  * If the file system is not maintained in a strict tree hierarchy,
  * If the file system is not maintained in a strict tree hierarchy,

- * this can result in a deadlock situation.  When creating and
+ * this can result in a deadlock situation (see comments in code below).
+ *
+ * The flag argument is LOOKUP, CREATE, or DELETE depending on whether
+ * the name is to be looked up, created, or deleted. When CREATE or
+ * DELETE is specified, information usable in creating or deleteing a
+ * directory entry is also calculated. If flag has LOCKPARENT or'ed
+ * into it and the target of the pathname exists, namei returns both
+ * the target and its parent directory locked. When creating 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 insure it does an irele and iput instead of two iputs.
  *
  * The FOLLOW flag is set when symbolic links are to be followed
  * when they occur at the end of the name translation process.
  * LOCKPARENT is specified, the target may not be ".".  When deleting
  * and LOCKPARENT is specified, the target may be ".", but the caller
  * must check to insure it does an irele and iput instead of two iputs.
  *
  * The FOLLOW flag is set when symbolic links are to be followed
  * when they occur at the end of the name translation process.

+ * Symbolic links are always followed for all other pathname
+ * components other than the last.

  *
  *

- * Name caching works as follows:
+ * The segflg defines whether the name is to be copied from user
+ * space or kernel space.

  *
  *

- *     names found by directory scans are retained in a cache
- *     for future reference.  It is managed LRU, so frequently
- *     used names will hang around.  Cache is indexed by hash value
- *     obtained from (ino,dev,name) where ino & dev refer to the
- *     directory containing name.
+ * Name caching works as follows:

  *
  *

- *     For simplicity (and economy of storage), names longer than
- *     some (small) maximum length are not cached, they occur
- *     infrequently in any case, and are almost never of interest.
+ * Names found by directory scans are retained in a cache
+ * for future reference.  It is managed LRU, so frequently
+ * used names will hang around.  Cache is indexed by hash value
+ * obtained from (ino,dev,name) where ino & dev refer to the
+ * directory containing name.

  *
  *

- *     Upon reaching the last segment of a path, if the reference
- *     is for DELETE, or NOCACHE is set (rewrite), and the
- *     name is located in the cache, it will be dropped.
+ * For simplicity (and economy of storage), names longer than
+ * a maximum length of NCHNAMLEN are not cached; they occur
+ * infrequently in any case, and are almost never of interest.

  *
  *

- *     We must be sure never to enter the name ".." into the cache
- *     because of the extremely kludgey way that rename() alters
- *     ".." in a situation like
- *             mv a/x b/x
- *     where x is a directory, and x/.. is the ".." in question.
+ * Upon reaching the last segment of a path, if the reference
+ * is for DELETE, or NOCACHE is set (rewrite), and the
+ * name is located in the cache, it will be dropped.

  *
  * Overall outline of namei:
  *
  *
  * Overall outline of namei:
  *


@@ -103,10 +100,11 @@ struct    nchstats nchstats;              /* cache effectiveness statistics */
  *     else return error
  * found:
  *     if at end of path and deleting, return information to allow delete
  *     else return error
  * found:
  *     if at end of path and deleting, return information to allow delete

- *     if at end of path and rewriting (create and LOCKPARENT), lock target
+ *     if at end of path and rewriting (CREATE and LOCKPARENT), lock target

  *       inode and return info to allow rewrite
  *     if .. and on mounted filesys, look in mount table for parent
  *       inode and return info to allow rewrite
  *     if .. and on mounted filesys, look in mount table for parent

- *     if not at end, if neither creating nor deleting, add name to cache
+ *     if not at end, add name to cache; if at end and neither creating
+ *       nor deleting, add name to cache

  * haveino:
  *     if symbolic link, massage name in buffer and continue at dirloop
  *     if more components of name, do next level at dirloop
  * haveino:
  *     if symbolic link, massage name in buffer and continue at dirloop
  *     if more components of name, do next level at dirloop


@@ -122,7 +120,7 @@ namei(ndp)
        register char *cp;              /* pointer into pathname argument */
 /* these variables refer to things which must be freed or unlocked */
        register struct inode *dp = 0;  /* the directory we are searching */
        register char *cp;              /* pointer into pathname argument */
 /* these variables refer to things which must be freed or unlocked */
        register struct inode *dp = 0;  /* the directory we are searching */

-       register struct nch *ncp;       /* cache slot for entry */
+       register struct namecache *ncp; /* cache slot for entry */

        register struct fs *fs;         /* file system that directory is in */
        register struct buf *bp = 0;    /* a buffer of directory entries */
        register struct direct *ep;     /* the current directory entry */
        register struct fs *fs;         /* file system that directory is in */
        register struct buf *bp = 0;    /* a buffer of directory entries */
        register struct direct *ep;     /* the current directory entry */


@@ -264,36 +262,34 @@ dirloop2:
                makeentry = 0;
        } else {
                nhp = &nchash[NHASH(hash, dp->i_number, dp->i_dev)];
                makeentry = 0;
        } else {
                nhp = &nchash[NHASH(hash, dp->i_number, dp->i_dev)];

-               for (ncp = nhp->nch_forw; ncp != (struct nch *)nhp;
+               for (ncp = nhp->nch_forw; ncp != (struct namecache *)nhp;

                    ncp = ncp->nc_forw) {
                        if (ncp->nc_ino == dp->i_number &&
                            ncp->nc_dev == dp->i_dev &&
                            ncp->nc_nlen == ndp->ni_dent.d_namlen &&
                            !bcmp(ncp->nc_name, ndp->ni_dent.d_name,
                    ncp = ncp->nc_forw) {
                        if (ncp->nc_ino == dp->i_number &&
                            ncp->nc_dev == dp->i_dev &&
                            ncp->nc_nlen == ndp->ni_dent.d_namlen &&
                            !bcmp(ncp->nc_name, ndp->ni_dent.d_name,

-                               ncp->nc_nlen))
+                               (unsigned)ncp->nc_nlen))

                                break;
                }
                                break;
                }

-
-               if (ncp == (struct nch *)nhp) {
+               if (ncp == (struct namecache *)nhp) {

                        nchstats.ncs_miss++;
                        ncp = NULL;
                } else {
                        nchstats.ncs_miss++;
                        ncp = NULL;
                } else {

-                       if (ncp->nc_id != ncp->nc_ip->i_id) {
+                       if (ncp->nc_id != ncp->nc_ip->i_id)

                                nchstats.ncs_falsehits++;
                                nchstats.ncs_falsehits++;

-                       } else if (!makeentry) {
+                       else if (!makeentry)

                                nchstats.ncs_badhits++;
                                nchstats.ncs_badhits++;

-                       } else {
-
-                                       /*
-                                        * move this slot to end of LRU
-                                        * chain, if not already there
-                                        */
+                       else {
+                               /*
+                                * move this slot to end of LRU
+                                * chain, if not already there
+                                */

                                if (ncp->nc_nxt) {
                                if (ncp->nc_nxt) {

-                                               /* remove from LRU chain */
+                                       /* remove from LRU chain */

                                        *ncp->nc_prev = ncp->nc_nxt;
                                        ncp->nc_nxt->nc_prev = ncp->nc_prev;
 
                                        *ncp->nc_prev = ncp->nc_nxt;
                                        ncp->nc_nxt->nc_prev = ncp->nc_prev;
 

-                                               /* and replace at end of it */
+                                       /* and replace at end of it */

                                        ncp->nc_nxt = NULL;
                                        ncp->nc_prev = nchtail;
                                        *nchtail = ncp;
                                        ncp->nc_nxt = NULL;
                                        ncp->nc_prev = nchtail;
                                        *nchtail = ncp;


@@ -309,10 +305,10 @@ dirloop2:
                                if (!isdotdot || dp != u.u_rdir)
                                        dp = ncp->nc_ip;
                                if (dp == NULL)
                                if (!isdotdot || dp != u.u_rdir)
                                        dp = ncp->nc_ip;
                                if (dp == NULL)

-                                       panic("nami: null cache ino");
-                               if (pdp == dp) {
+                                       panic("namei: null cache ino");
+                               if (pdp == dp)

                                        dp->i_count++;
                                        dp->i_count++;

-                               } else if (isdotdot) {
+                               else if (isdotdot) {

                                        IUNLOCK(pdp);
                                        igrab(dp);
                                } else {
                                        IUNLOCK(pdp);
                                        igrab(dp);
                                } else {


@@ -343,27 +339,21 @@ dirloop2:
                         * the cache entry is invalid, or otherwise don't
                         * want cache entry to exist.
                         */
                         * the cache entry is invalid, or otherwise don't
                         * want cache entry to exist.
                         */

-
-                               /* remove from LRU chain */
+                       /* remove from LRU chain */

                        *ncp->nc_prev = ncp->nc_nxt;
                        if (ncp->nc_nxt)
                                ncp->nc_nxt->nc_prev = ncp->nc_prev;
                        else
                                nchtail = ncp->nc_prev;
                        *ncp->nc_prev = ncp->nc_nxt;
                        if (ncp->nc_nxt)
                                ncp->nc_nxt->nc_prev = ncp->nc_prev;
                        else
                                nchtail = ncp->nc_prev;

-
-                               /* remove from hash chain */
-                       remque(ncp);
-
-                               /* insert at head of LRU list (first to grab) */
+                       remque(ncp);            /* remove from hash chain */
+                       /* insert at head of LRU list (first to grab) */

                        ncp->nc_nxt = nchhead;
                        ncp->nc_prev = &nchhead;
                        nchhead->nc_prev = &ncp->nc_nxt;
                        nchhead = ncp;
                        ncp->nc_nxt = nchhead;
                        ncp->nc_prev = &nchhead;
                        nchhead->nc_prev = &ncp->nc_nxt;
                        nchhead = ncp;

-
-                               /* and make a dummy hash chain */
+                       /* and make a dummy hash chain */

                        ncp->nc_forw = ncp;
                        ncp->nc_back = ncp;
                        ncp->nc_forw = ncp;
                        ncp->nc_back = ncp;

-

                        ncp = NULL;
                }
        }
                        ncp = NULL;
                }
        }


@@ -395,13 +385,8 @@ dirloop2:
                ndp->ni_offset = 0;
                numdirpasses = 1;
        } else {
                ndp->ni_offset = 0;
                numdirpasses = 1;
        } else {

-               if ((dp->i_flag & ICHG) || dp->i_ctime >= u.u_ncache.nc_time) {
-                       if (u.u_ncache.nc_prevoffset > dp->i_size)
-                               u.u_ncache.nc_prevoffset = 0;
-                       else
-                               u.u_ncache.nc_prevoffset &= ~(DIRBLKSIZ - 1);
-                       u.u_ncache.nc_time = time.tv_sec;
-               }
+               if (u.u_ncache.nc_prevoffset > dp->i_size)
+                       u.u_ncache.nc_prevoffset = 0;

                ndp->ni_offset = u.u_ncache.nc_prevoffset;
                entryoffsetinblock = blkoff(fs, ndp->ni_offset);
                if (entryoffsetinblock != 0) {
                ndp->ni_offset = u.u_ncache.nc_prevoffset;
                entryoffsetinblock = blkoff(fs, ndp->ni_offset);
                if (entryoffsetinblock != 0) {


@@ -430,7 +415,6 @@ searchloop:
                                goto bad;
                        entryoffsetinblock = 0;
                }
                                goto bad;
                        entryoffsetinblock = 0;
                }

-

                /*
                 * If still looking for a slot, and at a DIRBLKSIZE
                 * boundary, have to start looking for free space again.
                /*
                 * If still looking for a slot, and at a DIRBLKSIZE
                 * boundary, have to start looking for free space again.


@@ -440,7 +424,6 @@ searchloop:
                        slotoffset = -1;
                        slotfreespace = 0;
                }
                        slotoffset = -1;
                        slotfreespace = 0;
                }

-

                /*
                 * Get pointer to next entry.
                 * Full validation checks are slow, so we only check
                /*
                 * Get pointer to next entry.
                 * Full validation checks are slow, so we only check


@@ -449,7 +432,7 @@ searchloop:
                 * "dirchk" to be true.
                 */
                ep = (struct direct *)(bp->b_un.b_addr + entryoffsetinblock);
                 * "dirchk" to be true.
                 */
                ep = (struct direct *)(bp->b_un.b_addr + entryoffsetinblock);

-               if (ep->d_reclen <= 0 ||
+               if (ep->d_reclen == 0 ||

                    dirchk && dirbadentry(ep, entryoffsetinblock)) {
                        dirbad(dp, ndp->ni_offset, "mangled entry");
                        i = DIRBLKSIZ - (entryoffsetinblock & (DIRBLKSIZ - 1));
                    dirchk && dirbadentry(ep, entryoffsetinblock)) {
                        dirbad(dp, ndp->ni_offset, "mangled entry");
                        i = DIRBLKSIZ - (entryoffsetinblock & (DIRBLKSIZ - 1));


@@ -493,7 +476,7 @@ searchloop:
                if (ep->d_ino) {
                        if (ep->d_namlen == ndp->ni_dent.d_namlen &&
                            !bcmp(ndp->ni_dent.d_name, ep->d_name,
                if (ep->d_ino) {
                        if (ep->d_namlen == ndp->ni_dent.d_namlen &&
                            !bcmp(ndp->ni_dent.d_name, ep->d_name,

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

                                goto found;
                }
                prevoff = ndp->ni_offset;
                                goto found;
                }
                prevoff = ndp->ni_offset;


@@ -581,10 +564,9 @@ found:
         * in the cache as to where the entry was found.
         */
        if (*cp == '\0' && flag == LOOKUP) {
         * in the cache as to where the entry was found.
         */
        if (*cp == '\0' && flag == LOOKUP) {

-               u.u_ncache.nc_prevoffset = ndp->ni_offset;
+               u.u_ncache.nc_prevoffset = ndp->ni_offset &~ (DIRBLKSIZ - 1);

                u.u_ncache.nc_inumber = dp->i_number;
                u.u_ncache.nc_dev = dp->i_dev;
                u.u_ncache.nc_inumber = dp->i_number;
                u.u_ncache.nc_dev = dp->i_dev;

-               u.u_ncache.nc_time = time.tv_sec;

        }
        /*
         * Save directory entry's inode number and reclen in ndp->ni_dent,
        }
        /*
         * Save directory entry's inode number and reclen in ndp->ni_dent,


@@ -738,44 +720,38 @@ found:
        }
 
        /*
        }
 
        /*

-        * insert name into cache if appropriate
+        * Insert name into cache if appropriate.

         */
        if (makeentry) {
                if (ncp != NULL)
         */
        if (makeentry) {
                if (ncp != NULL)

-                       panic("nami: duplicating cache");
-
-                       /*
-                        * free the cache slot at head of lru chain
-                        */
+                       panic("namei: duplicating cache");
+               /*
+                * Free the cache slot at head of lru chain.
+                */

                if (ncp = nchhead) {
                if (ncp = nchhead) {

-                               /* remove from lru chain */
+                       /* remove from lru chain */

                        *ncp->nc_prev = ncp->nc_nxt;
                        if (ncp->nc_nxt)
                                ncp->nc_nxt->nc_prev = ncp->nc_prev;
                        else
                                nchtail = ncp->nc_prev;
                        *ncp->nc_prev = ncp->nc_nxt;
                        if (ncp->nc_nxt)
                                ncp->nc_nxt->nc_prev = ncp->nc_prev;
                        else
                                nchtail = ncp->nc_prev;

-
-                               /* remove from old hash chain */
-                       remque(ncp);
-
-                               /* grab the inode we just found */
+                       remque(ncp);            /* remove from old hash chain */
+                       /* grab the inode we just found */

                        ncp->nc_ip = dp;
                        ncp->nc_ip = dp;

-
-                               /* fill in cache info */
+                       /* fill in cache info */

                        ncp->nc_ino = pdp->i_number;    /* parents inum */
                        ncp->nc_dev = pdp->i_dev;       /* & device */
                        ncp->nc_idev = dp->i_dev;       /* our device */
                        ncp->nc_id = dp->i_id;          /* identifier */
                        ncp->nc_nlen = ndp->ni_dent.d_namlen;
                        ncp->nc_ino = pdp->i_number;    /* parents inum */
                        ncp->nc_dev = pdp->i_dev;       /* & device */
                        ncp->nc_idev = dp->i_dev;       /* our device */
                        ncp->nc_id = dp->i_id;          /* identifier */
                        ncp->nc_nlen = ndp->ni_dent.d_namlen;

-                       bcopy(ndp->ni_dent.d_name, ncp->nc_name, ncp->nc_nlen);
-
-                               /* link at end of lru chain */
+                       bcopy(ndp->ni_dent.d_name, ncp->nc_name,
+                           (unsigned)ncp->nc_nlen);
+                       /* link at end of lru chain */

                        ncp->nc_nxt = NULL;
                        ncp->nc_prev = nchtail;
                        *nchtail = ncp;
                        nchtail = &ncp->nc_nxt;
                        ncp->nc_nxt = NULL;
                        ncp->nc_prev = nchtail;
                        *nchtail = ncp;
                        nchtail = &ncp->nc_nxt;

-
-                               /* and insert on hash chain */
+                       /* and insert on hash chain */

                        insque(ncp, nhp);
                }
        }
                        insque(ncp, nhp);
                }
        }


@@ -801,7 +777,7 @@ haveino:
                ovbcopy(cp, nbp->b_un.b_addr + dp->i_size, pathlen);
                u.u_error =
                    rdwri(UIO_READ, dp, nbp->b_un.b_addr, (int)dp->i_size,
                ovbcopy(cp, nbp->b_un.b_addr + dp->i_size, pathlen);
                u.u_error =
                    rdwri(UIO_READ, dp, nbp->b_un.b_addr, (int)dp->i_size,

-                       0, 1, (int *)0);
+                       (off_t)0, 1, (int *)0);

                if (u.u_error)
                        goto bad2;
                cp = nbp->b_un.b_addr;
                if (u.u_error)
                        goto bad2;
                cp = nbp->b_un.b_addr;


@@ -865,7 +841,6 @@ dirbad(ip, offset, how)
 /*
  * Do consistency checking on a directory entry:
  *     record length must be multiple of 4
 /*
  * Do consistency checking on a directory entry:
  *     record length must be multiple of 4

- *     record length must not be non-negative

  *     entry must fit in rest of its DIRBLKSIZ block
  *     record must be large enough to contain entry
  *     name is not longer than MAXNAMLEN
  *     entry must fit in rest of its DIRBLKSIZ block
  *     record must be large enough to contain entry
  *     name is not longer than MAXNAMLEN


@@ -877,7 +852,7 @@ dirbadentry(ep, entryoffsetinblock)
 {
        register int i;
 
 {
        register int i;
 

-       if ((ep->d_reclen & 0x3) != 0 || ep->d_reclen <= 0 ||
+       if ((ep->d_reclen & 0x3) != 0 ||

            ep->d_reclen > DIRBLKSIZ - (entryoffsetinblock & (DIRBLKSIZ - 1)) ||
            ep->d_reclen < DIRSIZ(ep) || ep->d_namlen > MAXNAMLEN)
                return (1);
            ep->d_reclen > DIRBLKSIZ - (entryoffsetinblock & (DIRBLKSIZ - 1)) ||
            ep->d_reclen < DIRSIZ(ep) || ep->d_namlen > MAXNAMLEN)
                return (1);


@@ -947,7 +922,6 @@ direnter(ip, ndp)
         */
        if (ndp->ni_offset + ndp->ni_count > dp->i_size)
                dp->i_size = ndp->ni_offset + ndp->ni_count;
         */
        if (ndp->ni_offset + ndp->ni_count > dp->i_size)
                dp->i_size = ndp->ni_offset + ndp->ni_count;

-

        /*
         * Get the block containing the space for the new directory
         * entry.  Should return error by result instead of u.u_error.
        /*
         * Get the block containing the space for the new directory
         * entry.  Should return error by result instead of u.u_error.


@@ -957,7 +931,6 @@ direnter(ip, ndp)
                iput(dp);
                return (u.u_error);
        }
                iput(dp);
                return (u.u_error);
        }

-

        /*
         * Find space for the new entry.  In the simple case, the
         * entry at offset base will have the space.  If it does
        /*
         * Find space for the new entry.  In the simple case, the
         * entry at offset base will have the space.  If it does


@@ -1001,7 +974,7 @@ direnter(ip, ndp)
        bwrite(bp);
        dp->i_flag |= IUPD|ICHG;
        if (ndp->ni_endoff && ndp->ni_endoff < dp->i_size)
        bwrite(bp);
        dp->i_flag |= IUPD|ICHG;
        if (ndp->ni_endoff && ndp->ni_endoff < dp->i_size)

-               itrunc(dp, ndp->ni_endoff);
+               itrunc(dp, (u_long)ndp->ni_endoff);

        iput(dp);
        return (error);
 }
        iput(dp);
        return (error);
 }


@@ -1036,8 +1009,7 @@ dirremove(ndp)
                /*
                 * Collapse new free space into previous entry.
                 */
                /*
                 * Collapse new free space into previous entry.
                 */

-               bp = blkatoff(dp, (int)(ndp->ni_offset - ndp->ni_count),
-                       (char **)&ep);
+               bp = blkatoff(dp, ndp->ni_offset - ndp->ni_count, (char **)&ep);

                if (bp == 0)
                        return (0);
                ep->d_reclen += ndp->ni_dent.d_reclen;
                if (bp == 0)
                        return (0);
                ep->d_reclen += ndp->ni_dent.d_reclen;


@@ -1118,8 +1090,6 @@ dirempty(ip, parentino)
 #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) {

-               if (dp->d_reclen <= 0)
-                       return (0);

                error = rdwri(UIO_READ, ip, (caddr_t)dp, MINDIRSIZ,
                    off, 1, &count);
                /*
                error = rdwri(UIO_READ, ip, (caddr_t)dp, MINDIRSIZ,
                    off, 1, &count);
                /*


@@ -1128,6 +1098,9 @@ dirempty(ip, parentino)
                 */
                if (error || count != 0)
                        return (0);
                 */
                if (error || count != 0)
                        return (0);

+               /* avoid infinite loops */
+               if (dp->d_reclen == 0)
+                       return (0);

                /* skip empty entries */
                if (dp->d_ino == 0)
                        continue;
                /* skip empty entries */
                if (dp->d_ino == 0)
                        continue;


@@ -1213,23 +1186,19 @@ out:
 nchinit()
 {
        register union nchash *nchp;
 nchinit()
 {
        register union nchash *nchp;

-       register struct nch *ncp;
+       register struct namecache *ncp;

 
        nchhead = 0;
        nchtail = &nchhead;
 
        nchhead = 0;
        nchtail = &nchhead;

-
-       for (ncp = nch; ncp < &nch[nchsize]; ncp++) {
+       for (ncp = namecache; ncp < &namecache[nchsize]; ncp++) {

                ncp->nc_forw = ncp;                     /* hash chain */
                ncp->nc_back = ncp;
                ncp->nc_forw = ncp;                     /* hash chain */
                ncp->nc_back = ncp;

-

                ncp->nc_nxt = NULL;                     /* lru chain */
                *nchtail = ncp;
                ncp->nc_prev = nchtail;
                nchtail = &ncp->nc_nxt;
                ncp->nc_nxt = NULL;                     /* lru chain */
                *nchtail = ncp;
                ncp->nc_prev = nchtail;
                nchtail = &ncp->nc_nxt;

-

                /* all else is zero already */
        }
                /* all else is zero already */
        }

-

        for (nchp = nchash; nchp < &nchash[NCHHASH]; nchp++) {
                nchp->nch_head[0] = nchp;
                nchp->nch_head[1] = nchp;
        for (nchp = nchash; nchp < &nchash[NCHHASH]; nchp++) {
                nchp->nch_head[0] = nchp;
                nchp->nch_head[1] = nchp;


@@ -1247,39 +1216,31 @@ nchinit()
 nchinval(dev)
        register dev_t dev;
 {
 nchinval(dev)
        register dev_t dev;
 {

-       register struct nch *ncp, *nxtcp;
+       register struct namecache *ncp, *nxtcp;

 
        for (ncp = nchhead; ncp; ncp = nxtcp) {
                nxtcp = ncp->nc_nxt;
 
        for (ncp = nchhead; ncp; ncp = nxtcp) {
                nxtcp = ncp->nc_nxt;

-

                if (ncp->nc_ip == NULL ||
                    (ncp->nc_idev != dev && ncp->nc_dev != dev))
                        continue;
                if (ncp->nc_ip == NULL ||
                    (ncp->nc_idev != dev && ncp->nc_dev != dev))
                        continue;

-
-                       /* free the resources we had */
+               /* free the resources we had */

                ncp->nc_idev = NODEV;
                ncp->nc_dev = NODEV;
                ncp->nc_id = NULL;
                ncp->nc_ino = 0;
                ncp->nc_ip = NULL;
                ncp->nc_idev = NODEV;
                ncp->nc_dev = NODEV;
                ncp->nc_id = NULL;
                ncp->nc_ino = 0;
                ncp->nc_ip = NULL;

-
-
-                       /* remove the entry from its hash chain */
-               remque(ncp);
-                       /* and make a dummy one */
-               ncp->nc_forw = ncp;
+               remque(ncp);            /* remove entry from its hash chain */
+               ncp->nc_forw = ncp;     /* and make a dummy one */

                ncp->nc_back = ncp;
                ncp->nc_back = ncp;

-
-                       /* delete this entry from LRU chain */
+               /* delete this entry from LRU chain */

                *ncp->nc_prev = nxtcp;
                if (nxtcp)
                        nxtcp->nc_prev = ncp->nc_prev;
                else
                        nchtail = ncp->nc_prev;
                *ncp->nc_prev = nxtcp;
                if (nxtcp)
                        nxtcp->nc_prev = ncp->nc_prev;
                else
                        nchtail = ncp->nc_prev;

-
-                       /* cause rescan of list, it may have altered */
+               /* cause rescan of list, it may have altered */

                nxtcp = nchhead;
                nxtcp = nchhead;

-                       /* put the now-free entry at head of LRU */
+               /* put the now-free entry at head of LRU */

                ncp->nc_nxt = nxtcp;
                ncp->nc_prev = &nchhead;
                nxtcp->nc_prev = &ncp->nc_nxt;
                ncp->nc_nxt = nxtcp;
                ncp->nc_prev = &nchhead;
                nxtcp->nc_prev = &ncp->nc_nxt;


@@ -1292,9 +1253,8 @@ nchinval(dev)
  */
 cacheinvalall()
 {
  */
 cacheinvalall()
 {

-       register struct nch *ncp;
+       register struct namecache *ncp;

 
 

-       for (ncp = nch; ncp < &nch[nchsize]; ncp++) {
+       for (ncp = namecache; ncp < &namecache[nchsize]; ncp++)

                ncp->nc_id = 0;
                ncp->nc_id = 0;

-       }

 }
 }