projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
lint, add comments on %r
[unix-history] / usr / src / sys / kern / vfs_lookup.c
diff --git a/usr/src/sys/kern/vfs_lookup.c b/usr/src/sys/kern/vfs_lookup.c
index 661caf6..a6338e4 100644 (file)
--- a/usr/src/sys/kern/vfs_lookup.c
+++ b/usr/src/sys/kern/vfs_lookup.c
@@ -1,4 +1,10 @@
-/*     vfs_lookup.c    6.17    85/01/10        */
+/*
+ * Copyright (c) 1982, 1986 Regents of the University of California.
+ * All rights reserved.  The Berkeley software License Agreement
+ * specifies the terms and conditions for redistribution.
+ *
+ *     @(#)vfs_lookup.c        7.4 (Berkeley) %G%
+ */
 
 #include "param.h"
 #include "systm.h"
 
 #include "param.h"
 #include "systm.h"
@@ -11,9 +17,9 @@
 #include "conf.h"
 #include "uio.h"
 #include "kernel.h"
 #include "conf.h"
 #include "uio.h"
 #include "kernel.h"
+#include "malloc.h"
 
 struct buf *blkatoff();
 
 struct buf *blkatoff();
-struct buf *freenamebuf;
 int    dirchk = 0;
 
 /*
 int    dirchk = 0;
 
 /*
@@ -27,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:
  *
@@ -97,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
@@ -116,12 +120,12 @@ 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 */
        int entryoffsetinblock;         /* offset of ep in bp's buffer */
        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 */
        int entryoffsetinblock;         /* offset of ep in bp's buffer */
-       register struct buf *nbp;       /* buffer storing path name argument */
+       register caddr_t nbp;           /* buffer storing path name argument */
 /* these variables hold information about the search for a slot */
        enum {NONE, COMPACT, FOUND} slotstatus;
        int slotoffset = -1;            /* offset of area with free space */
 /* these variables hold information about the search for a slot */
        enum {NONE, COMPACT, FOUND} slotstatus;
        int slotoffset = -1;            /* offset of area with free space */
@@ -136,32 +140,28 @@ namei(ndp)
        struct inode *pdp;              /* saved dp during symlink work */
        int error, i;
        int lockparent;
        struct inode *pdp;              /* saved dp during symlink work */
        int error, i;
        int lockparent;
-       int docache;
+       int docache;                    /* == 0 do not cache last component */
+       int makeentry;                  /* != 0 if name to be added to cache */
        unsigned hash;                  /* value of name hash for entry */
        union nchash *nhp;              /* cache chain head for entry */
        int isdotdot;                   /* != 0 if current name is ".." */
        int flag;                       /* op ie, LOOKUP, CREATE, or DELETE */
        unsigned hash;                  /* value of name hash for entry */
        union nchash *nhp;              /* cache chain head for entry */
        int isdotdot;                   /* != 0 if current name is ".." */
        int flag;                       /* op ie, LOOKUP, CREATE, or DELETE */
+       off_t enduseful;                /* pointer past last used dir slot */
 
        lockparent = ndp->ni_nameiop & LOCKPARENT;
        docache = (ndp->ni_nameiop & NOCACHE) ^ NOCACHE;
        flag = ndp->ni_nameiop &~ (LOCKPARENT|NOCACHE|FOLLOW);
 
        lockparent = ndp->ni_nameiop & LOCKPARENT;
        docache = (ndp->ni_nameiop & NOCACHE) ^ NOCACHE;
        flag = ndp->ni_nameiop &~ (LOCKPARENT|NOCACHE|FOLLOW);
-       if (flag == DELETE)
+       if (flag == DELETE || lockparent)
                docache = 0;
        /*
         * Get a buffer for the name to be translated, and copy the
         * name into the buffer.
         */
                docache = 0;
        /*
         * Get a buffer for the name to be translated, and copy the
         * name into the buffer.
         */
-       nbp = freenamebuf;
-       if (nbp == NULL)
-               nbp = geteblk(MAXPATHLEN);
-       else
-               freenamebuf = nbp->av_forw;
+       MALLOC(nbp, caddr_t, MAXPATHLEN, M_NAMEI, M_WAITOK);
        if (ndp->ni_segflg == UIO_SYSSPACE)
        if (ndp->ni_segflg == UIO_SYSSPACE)
-               error = copystr(ndp->ni_dirp, nbp->b_un.b_addr, MAXPATHLEN,
-                   (u_int *)0);
+               error = copystr(ndp->ni_dirp, nbp, MAXPATHLEN, (u_int *)0);
        else
        else
-               error = copyinstr(ndp->ni_dirp, nbp->b_un.b_addr, MAXPATHLEN,
-                   (u_int *)0);
+               error = copyinstr(ndp->ni_dirp, nbp, MAXPATHLEN, (u_int *)0);
        if (error) {
                u.u_error = error;
                goto bad;
        if (error) {
                u.u_error = error;
                goto bad;
@@ -170,7 +170,7 @@ namei(ndp)
        /*
         * Get starting directory.
         */
        /*
         * Get starting directory.
         */
-       cp = nbp->b_un.b_addr;
+       cp = nbp;
        if (*cp == '/') {
                while (*cp == '/')
                        cp++;
        if (*cp == '/') {
                while (*cp == '/')
                        cp++;
@@ -182,6 +182,7 @@ namei(ndp)
        ILOCK(dp);
        dp->i_count++;
        ndp->ni_pdir = (struct inode *)0xc0000000;              /* illegal */
        ILOCK(dp);
        dp->i_count++;
        ndp->ni_pdir = (struct inode *)0xc0000000;              /* illegal */
+       ndp->ni_endoff = 0;
 
        /*
         * We come to dirloop to search a new directory.
 
        /*
         * We come to dirloop to search a new directory.
@@ -206,13 +207,14 @@ dirloop2:
        hash = 0;
        for (i = 0; *cp != 0 && *cp != '/'; cp++) {
                if (i >= MAXNAMLEN) {
        hash = 0;
        for (i = 0; *cp != 0 && *cp != '/'; cp++) {
                if (i >= MAXNAMLEN) {
-                       u.u_error = ENOENT;
-                       goto bad;
-               }
-               if ((*cp&0377) == ('/'|0200) || (*cp&0200) && flag != DELETE) {
-                       u.u_error = EPERM;
+                       u.u_error = ENAMETOOLONG;
                        goto bad;
                }
                        goto bad;
                }
+               if (*cp & 0200)
+                       if ((*cp&0377) == ('/'|0200) || flag != DELETE) {
+                               u.u_error = EINVAL;
+                               goto bad;
+                       }
                ndp->ni_dent.d_name[i++] = *cp;
                hash += (unsigned char)*cp * i;
        }
                ndp->ni_dent.d_name[i++] = *cp;
                hash += (unsigned char)*cp * i;
        }
@@ -220,6 +222,9 @@ dirloop2:
        ndp->ni_dent.d_name[i] = '\0';
        isdotdot = (i == 2 &&
                ndp->ni_dent.d_name[0] == '.' && ndp->ni_dent.d_name[1] == '.');
        ndp->ni_dent.d_name[i] = '\0';
        isdotdot = (i == 2 &&
                ndp->ni_dent.d_name[0] == '.' && ndp->ni_dent.d_name[1] == '.');
+       makeentry = 1;
+       if (*cp == '\0' && docache == 0)
+               makeentry = 0;
 
        /*
         * Check for degenerate name (e.g. / or "")
 
        /*
         * Check for degenerate name (e.g. / or "")
@@ -231,8 +236,7 @@ dirloop2:
                        u.u_error = EISDIR;
                        goto bad;
                }
                        u.u_error = EISDIR;
                        goto bad;
                }
-               nbp->av_forw = freenamebuf;
-               freenamebuf = nbp;
+               FREE(nbp, M_NAMEI);
                return (dp);
        }
 
                return (dp);
        }
 
@@ -248,39 +252,37 @@ dirloop2:
         */
        if (ndp->ni_dent.d_namlen > NCHNAMLEN) {
                nchstats.ncs_long++;
         */
        if (ndp->ni_dent.d_namlen > NCHNAMLEN) {
                nchstats.ncs_long++;
-               docache = 0;
+               makeentry = 0;
        } else {
                nhp = &nchash[NHASH(hash, dp->i_number, dp->i_dev)];
        } 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 (*cp == '\0' && !docache) {
+                       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;
@@ -293,19 +295,18 @@ dirloop2:
                                 * an explaination of the locking protocol.
                                 */
                                pdp = dp;
                                 * an explaination of the locking protocol.
                                 */
                                pdp = dp;
-                               dp = ncp->nc_ip;
+                               if (!isdotdot || dp != u.u_rdir)
+                                       dp = ncp->nc_ip;
                                if (dp == NULL)
                                if (dp == NULL)
-                                       panic("nami: null cache ino");
+                                       panic("namei: null cache ino");
                                if (pdp == dp)
                                        dp->i_count++;
                                if (pdp == dp)
                                        dp->i_count++;
-                               else {
-                                       if (isdotdot) {
-                                               IUNLOCK(pdp);
-                                               igrab(dp);
-                                       } else {
-                                               igrab(dp);
-                                               IUNLOCK(pdp);
-                                       }
+                               else if (isdotdot) {
+                                       IUNLOCK(pdp);
+                                       igrab(dp);
+                               } else {
+                                       igrab(dp);
+                                       IUNLOCK(pdp);
                                }
 
                                /*
                                }
 
                                /*
@@ -331,27 +332,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;
                }
        }
@@ -383,13 +378,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) {
@@ -401,6 +391,7 @@ dirloop2:
                nchstats.ncs_2passes++;
        }
        endsearch = roundup(dp->i_size, DIRBLKSIZ);
                nchstats.ncs_2passes++;
        }
        endsearch = roundup(dp->i_size, DIRBLKSIZ);
+       enduseful = 0;
 
 searchloop:
        while (ndp->ni_offset < endsearch) {
 
 searchloop:
        while (ndp->ni_offset < endsearch) {
@@ -417,7 +408,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.
@@ -427,7 +417,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
@@ -436,7 +425,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));
@@ -480,12 +469,14 @@ 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;
                ndp->ni_offset += ep->d_reclen;
                entryoffsetinblock += ep->d_reclen;
                                goto found;
                }
                prevoff = ndp->ni_offset;
                ndp->ni_offset += ep->d_reclen;
                entryoffsetinblock += ep->d_reclen;
+               if (ep->d_ino)
+                       enduseful = ndp->ni_offset;
        }
 /* notfound: */
        /*
        }
 /* notfound: */
        /*
@@ -521,15 +512,18 @@ searchloop:
                if (slotstatus == NONE) {
                        ndp->ni_offset = roundup(dp->i_size, DIRBLKSIZ);
                        ndp->ni_count = 0;
                if (slotstatus == NONE) {
                        ndp->ni_offset = roundup(dp->i_size, DIRBLKSIZ);
                        ndp->ni_count = 0;
+                       enduseful = ndp->ni_offset;
                } else {
                        ndp->ni_offset = slotoffset;
                        ndp->ni_count = slotsize;
                } else {
                        ndp->ni_offset = slotoffset;
                        ndp->ni_count = slotsize;
+                       if (enduseful < slotoffset + slotsize)
+                               enduseful = slotoffset + slotsize;
                }
                }
+               ndp->ni_endoff = roundup(enduseful, DIRBLKSIZ);
                dp->i_flag |= IUPD|ICHG;
                if (bp)
                        brelse(bp);
                dp->i_flag |= IUPD|ICHG;
                if (bp)
                        brelse(bp);
-               nbp->av_forw = freenamebuf;
-               freenamebuf = nbp;
+               FREE(nbp, M_NAMEI);
                /*
                 * We return with the directory locked, so that
                 * the parameters we set up above will still be
                /*
                 * We return with the directory locked, so that
                 * the parameters we set up above will still be
@@ -562,16 +556,16 @@ 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 in ndp->ni_dent,
+        * Save directory entry's inode number and reclen in ndp->ni_dent,
         * and release directory buffer.
         */
         * and release directory buffer.
         */
-       bcopy((caddr_t)ep, (caddr_t)&ndp->ni_dent, (u_int)DIRSIZ(ep));
+       ndp->ni_dent.d_ino = ep->d_ino;
+       ndp->ni_dent.d_reclen = ep->d_reclen;
        brelse(bp);
        bp = NULL;
 
        brelse(bp);
        bp = NULL;
 
@@ -624,8 +618,7 @@ found:
                                }
                        }
                }
                                }
                        }
                }
-               nbp->av_forw = freenamebuf;
-               freenamebuf = nbp;
+               FREE(nbp, M_NAMEI);
                return (dp);
        }
 
                return (dp);
        }
 
@@ -635,12 +628,13 @@ found:
         * in directory file system was mounted on.
         */
        if (isdotdot) {
         * in directory file system was mounted on.
         */
        if (isdotdot) {
-               if (dp == u.u_rdir)
+               if (dp == u.u_rdir) {
                        ndp->ni_dent.d_ino = dp->i_number;
                        ndp->ni_dent.d_ino = dp->i_number;
-               else if (ndp->ni_dent.d_ino == ROOTINO &&
+                       makeentry = 0;
+               } else if (ndp->ni_dent.d_ino == ROOTINO &&
                   dp->i_number == ROOTINO) {
                        for (i = 1; i < NMOUNT; i++)
                   dp->i_number == ROOTINO) {
                        for (i = 1; i < NMOUNT; i++)
-                       if (mount[i].m_bufp != NULL &&
+                       if (mount[i].m_fs != NULL &&
                           mount[i].m_dev == dp->i_dev) {
                                iput(dp);
                                dp = mount[i].m_inodp;
                           mount[i].m_dev == dp->i_dev) {
                                iput(dp);
                                dp = mount[i].m_inodp;
@@ -676,8 +670,7 @@ found:
                        iput(ndp->ni_pdir);
                        goto bad;
                }
                        iput(ndp->ni_pdir);
                        goto bad;
                }
-               nbp->av_forw = freenamebuf;
-               freenamebuf = nbp;
+               FREE(nbp, M_NAMEI);
                return (dp);
        }
 
                return (dp);
        }
 
@@ -717,47 +710,38 @@ found:
        }
 
        /*
        }
 
        /*
-        * insert name into cache (if we want it, and it isn't "." or "..")
-        *
-        * all other cases where making a cache entry would be wrong
-        * have already departed from the code sequence somewhere above.
+        * Insert name into cache if appropriate.
         */
         */
-       if (docache) {
+       if (makeentry) {
                if (ncp != NULL)
                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);
                }
        }
@@ -772,18 +756,21 @@ haveino:
            ((ndp->ni_nameiop & FOLLOW) || *cp == '/')) {
                u_int pathlen = strlen(cp) + 1;
 
            ((ndp->ni_nameiop & FOLLOW) || *cp == '/')) {
                u_int pathlen = strlen(cp) + 1;
 
-               if (dp->i_size + pathlen >= MAXPATHLEN - 1 ||
-                   ++nlink > MAXSYMLINKS) {
+               if (dp->i_size + pathlen >= MAXPATHLEN - 1) {
+                       u.u_error = ENAMETOOLONG;
+                       goto bad2;
+               }
+               if (++nlink > MAXSYMLINKS) {
                        u.u_error = ELOOP;
                        goto bad2;
                }
                        u.u_error = ELOOP;
                        goto bad2;
                }
-               ovbcopy(cp, nbp->b_un.b_addr + dp->i_size, pathlen);
+               ovbcopy(cp, nbp + dp->i_size, pathlen);
                u.u_error =
                u.u_error =
-                   rdwri(UIO_READ, dp, nbp->b_un.b_addr, (int)dp->i_size,
-                       0, 1, (int *)0);
+                   rdwri(UIO_READ, dp, nbp, (int)dp->i_size,
+                       (off_t)0, 1, (int *)0);
                if (u.u_error)
                        goto bad2;
                if (u.u_error)
                        goto bad2;
-               cp = nbp->b_un.b_addr;
+               cp = nbp;
                iput(dp);
                if (*cp == '/') {
                        irele(pdp);
                iput(dp);
                if (*cp == '/') {
                        irele(pdp);
@@ -811,8 +798,7 @@ haveino:
                irele(pdp);
                goto dirloop;
        }
                irele(pdp);
                goto dirloop;
        }
-       nbp->av_forw = freenamebuf;
-       freenamebuf = nbp;
+       FREE(nbp, M_NAMEI);
        if (lockparent)
                ndp->ni_pdir = pdp;
        else
        if (lockparent)
                ndp->ni_pdir = pdp;
        else
@@ -825,8 +811,7 @@ bad:
                brelse(bp);
        if (dp)
                iput(dp);
                brelse(bp);
        if (dp)
                iput(dp);
-       nbp->av_forw = freenamebuf;
-       freenamebuf = nbp;
+       FREE(nbp, M_NAMEI);
        return (NULL);
 }
 
        return (NULL);
 }
 
@@ -844,7 +829,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
@@ -856,7 +840,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);
@@ -879,6 +863,7 @@ direnter(ip, ndp)
        register struct nameidata *ndp;
 {
        register struct direct *ep, *nep;
        register struct nameidata *ndp;
 {
        register struct direct *ep, *nep;
+       register struct inode *dp = ndp->ni_pdir;
        struct buf *bp;
        int loc, spacefree, error = 0;
        u_int dsize;
        struct buf *bp;
        int loc, spacefree, error = 0;
        u_int dsize;
@@ -897,9 +882,13 @@ direnter(ip, ndp)
                if (ndp->ni_offset&(DIRBLKSIZ-1))
                        panic("wdir: newblk");
                ndp->ni_dent.d_reclen = DIRBLKSIZ;
                if (ndp->ni_offset&(DIRBLKSIZ-1))
                        panic("wdir: newblk");
                ndp->ni_dent.d_reclen = DIRBLKSIZ;
-               error = rdwri(UIO_WRITE, ndp->ni_pdir, (caddr_t)&ndp->ni_dent,
+               error = rdwri(UIO_WRITE, dp, (caddr_t)&ndp->ni_dent,
                    newentrysize, ndp->ni_offset, 1, (int *)0);
                    newentrysize, ndp->ni_offset, 1, (int *)0);
-               iput(ndp->ni_pdir);
+               if (DIRBLKSIZ > dp->i_fs->fs_fsize)
+                       panic("wdir: blksize"); /* XXX - should grow w/bmap() */
+               else
+                       dp->i_size = roundup(dp->i_size, DIRBLKSIZ);
+               iput(dp);
                return (error);
        }
 
                return (error);
        }
 
@@ -916,20 +905,20 @@ direnter(ip, ndp)
         * Increase size of directory if entry eats into new space.
         * This should never push the size past a new multiple of
         * DIRBLKSIZE.
         * Increase size of directory if entry eats into new space.
         * This should never push the size past a new multiple of
         * DIRBLKSIZE.
+        *
+        * N.B. - THIS IS AN ARTIFACT OF 4.2 AND SHOULD NEVER HAPPEN.
         */
         */
-       if (ndp->ni_offset + ndp->ni_count > ndp->ni_pdir->i_size)
-               ndp->ni_pdir->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.
         */
-       bp = blkatoff(ndp->ni_pdir, ndp->ni_offset, (char **)&dirbuf);
+       bp = blkatoff(dp, ndp->ni_offset, (char **)&dirbuf);
        if (bp == 0) {
        if (bp == 0) {
-               iput(ndp->ni_pdir);
+               iput(dp);
                return (u.u_error);
        }
                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
@@ -971,8 +960,10 @@ direnter(ip, ndp)
        }
        bcopy((caddr_t)&ndp->ni_dent, (caddr_t)ep, (u_int)newentrysize);
        bwrite(bp);
        }
        bcopy((caddr_t)&ndp->ni_dent, (caddr_t)ep, (u_int)newentrysize);
        bwrite(bp);
-       ndp->ni_pdir->i_flag |= IUPD|ICHG;
-       iput(ndp->ni_pdir);
+       dp->i_flag |= IUPD|ICHG;
+       if (ndp->ni_endoff && ndp->ni_endoff < dp->i_size)
+               itrunc(dp, (u_long)ndp->ni_endoff);
+       iput(dp);
        return (error);
 }
 
        return (error);
 }
 
@@ -1006,8 +997,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;
@@ -1047,20 +1037,28 @@ blkatoff(ip, offset, res)
 {
        register struct fs *fs = ip->i_fs;
        daddr_t lbn = lblkno(fs, offset);
 {
        register struct fs *fs = ip->i_fs;
        daddr_t lbn = lblkno(fs, offset);
-       int base = blkoff(fs, offset);
        int bsize = blksize(fs, ip, lbn);
        int bsize = blksize(fs, ip, lbn);
-       daddr_t bn = fsbtodb(fs, bmap(ip, lbn, B_WRITE, base, bsize));
        register struct buf *bp;
        register struct buf *bp;
+       daddr_t bn;
 
 
+       bn = bmap(ip, lbn, B_READ, bsize);
        if (u.u_error)
                return (0);
        if (u.u_error)
                return (0);
-       bp = bread(ip->i_dev, bn, bsize);
+       if (bn == (daddr_t)-1) {
+               dirbad(ip, offset, "hole in dir");
+               return (0);
+       }
+#ifdef SECSIZE
+       bp = bread(ip->i_dev, fsbtodb(fs, bn), bsize, fs->fs_dbsize);
+#else SECSIZE
+       bp = bread(ip->i_dev, fsbtodb(fs, bn), bsize);
+#endif SECSIZE
        if (bp->b_flags & B_ERROR) {
                brelse(bp);
                return (0);
        }
        if (res)
        if (bp->b_flags & B_ERROR) {
                brelse(bp);
                return (0);
        }
        if (res)
-               *res = bp->b_un.b_addr + base;
+               *res = bp->b_un.b_addr + blkoff(fs, offset);
        return (bp);
 }
 
        return (bp);
 }
 
@@ -1092,6 +1090,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;
@@ -1177,23 +1178,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;
@@ -1211,39 +1208,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;
@@ -1256,9 +1245,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;
-       }
 }
 }
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.