X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/blobdiff_plain/23de9f204f2e6d2b17fd99eb756f5ca80ecb715a..411afe141c547ea5b12fbd60a10a02aad25f486f:/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 fc4389cfd1..a6338e4c99 100644 --- a/usr/src/sys/kern/vfs_lookup.c +++ b/usr/src/sys/kern/vfs_lookup.c @@ -1,4 +1,10 @@ -/* vfs_lookup.c 6.20 85/02/22 */ +/* + * 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" @@ -11,9 +17,9 @@ #include "conf.h" #include "uio.h" #include "kernel.h" +#include "malloc.h" struct buf *blkatoff(); -struct buf *freenamebuf; int dirchk = 0; /* @@ -27,58 +33,55 @@ int dirchk = 0; #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] -struct nch *nchhead, **nchtail; /* LRU chain pointers */ +struct namecache *nchhead, **nchtail; /* LRU chain pointers */ 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. - * - * 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, - * 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. + * 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: * @@ -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 - * 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 - * 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 @@ -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 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 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 */ @@ -136,7 +140,8 @@ namei(ndp) 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 ".." */ @@ -146,23 +151,17 @@ namei(ndp) 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. */ - 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) - 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 - 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; @@ -171,7 +170,7 @@ namei(ndp) /* * Get starting directory. */ - cp = nbp->b_un.b_addr; + cp = nbp; if (*cp == '/') { while (*cp == '/') cp++; @@ -208,13 +207,14 @@ dirloop2: 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; } + 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; } @@ -222,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] == '.'); + makeentry = 1; + if (*cp == '\0' && docache == 0) + makeentry = 0; /* * Check for degenerate name (e.g. / or "") @@ -233,8 +236,7 @@ dirloop2: u.u_error = EISDIR; goto bad; } - nbp->av_forw = freenamebuf; - freenamebuf = nbp; + FREE(nbp, M_NAMEI); return (dp); } @@ -250,39 +252,37 @@ dirloop2: */ 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)]; - 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->nc_nlen)) + (unsigned)ncp->nc_nlen)) break; } - - if (ncp == (struct nch *)nhp) { + if (ncp == (struct namecache *)nhp) { 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++; - } else if (*cp == '\0' && !docache) { + else if (!makeentry) 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) { - /* remove from LRU chain */ + /* remove from LRU chain */ *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; @@ -295,19 +295,18 @@ dirloop2: * 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) - panic("nami: null cache ino"); + panic("namei: null cache ino"); 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); } /* @@ -333,27 +332,21 @@ dirloop2: * 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; - - /* 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; - - /* and make a dummy hash chain */ + /* and make a dummy hash chain */ ncp->nc_forw = ncp; ncp->nc_back = ncp; - ncp = NULL; } } @@ -385,13 +378,8 @@ dirloop2: 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) { @@ -420,7 +408,6 @@ searchloop: goto bad; entryoffsetinblock = 0; } - /* * If still looking for a slot, and at a DIRBLKSIZE * boundary, have to start looking for free space again. @@ -430,7 +417,6 @@ searchloop: slotoffset = -1; slotfreespace = 0; } - /* * Get pointer to next entry. * Full validation checks are slow, so we only check @@ -439,7 +425,7 @@ searchloop: * "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)); @@ -483,7 +469,7 @@ searchloop: 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; @@ -537,8 +523,7 @@ searchloop: 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 @@ -571,16 +556,16 @@ found: * 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_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. */ - 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; @@ -633,8 +618,7 @@ found: } } } - nbp->av_forw = freenamebuf; - freenamebuf = nbp; + FREE(nbp, M_NAMEI); return (dp); } @@ -644,12 +628,13 @@ found: * 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; - 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++) - 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; @@ -685,8 +670,7 @@ found: iput(ndp->ni_pdir); goto bad; } - nbp->av_forw = freenamebuf; - freenamebuf = nbp; + FREE(nbp, M_NAMEI); return (dp); } @@ -726,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) - 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) { - /* 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; - - /* 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; - - /* 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; - 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; - - /* and insert on hash chain */ + /* and insert on hash chain */ insque(ncp, nhp); } } @@ -781,18 +756,21 @@ haveino: ((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; } - ovbcopy(cp, nbp->b_un.b_addr + dp->i_size, pathlen); + ovbcopy(cp, nbp + dp->i_size, pathlen); 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; - cp = nbp->b_un.b_addr; + cp = nbp; iput(dp); if (*cp == '/') { irele(pdp); @@ -820,8 +798,7 @@ haveino: irele(pdp); goto dirloop; } - nbp->av_forw = freenamebuf; - freenamebuf = nbp; + FREE(nbp, M_NAMEI); if (lockparent) ndp->ni_pdir = pdp; else @@ -834,8 +811,7 @@ bad: brelse(bp); if (dp) iput(dp); - nbp->av_forw = freenamebuf; - freenamebuf = nbp; + FREE(nbp, M_NAMEI); return (NULL); } @@ -853,7 +829,6 @@ dirbad(ip, offset, how) /* * 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 @@ -865,7 +840,7 @@ dirbadentry(ep, entryoffsetinblock) { 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); @@ -935,7 +910,6 @@ direnter(ip, ndp) */ 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. @@ -945,7 +919,6 @@ direnter(ip, ndp) 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 @@ -989,7 +962,7 @@ direnter(ip, ndp) 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); } @@ -1024,8 +997,7 @@ dirremove(ndp) /* * 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; @@ -1065,20 +1037,28 @@ blkatoff(ip, offset, res) { register struct fs *fs = ip->i_fs; daddr_t lbn = lblkno(fs, offset); - int base = blkoff(fs, offset); int bsize = blksize(fs, ip, lbn); - daddr_t bn = fsbtodb(fs, bmap(ip, lbn, B_WRITE, base, bsize)); register struct buf *bp; + daddr_t bn; + bn = bmap(ip, lbn, B_READ, bsize); 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) - *res = bp->b_un.b_addr + base; + *res = bp->b_un.b_addr + blkoff(fs, offset); return (bp); } @@ -1102,8 +1082,6 @@ dirempty(ip, parentino) #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); /* @@ -1112,6 +1090,9 @@ dirempty(ip, parentino) */ 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; @@ -1197,23 +1178,19 @@ out: nchinit() { register union nchash *nchp; - register struct nch *ncp; + register struct namecache *ncp; 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_nxt = NULL; /* lru chain */ *nchtail = ncp; ncp->nc_prev = nchtail; nchtail = &ncp->nc_nxt; - /* all else is zero already */ } - for (nchp = nchash; nchp < &nchash[NCHHASH]; nchp++) { nchp->nch_head[0] = nchp; nchp->nch_head[1] = nchp; @@ -1231,39 +1208,31 @@ nchinit() 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; - 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; - - - /* 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; - - /* 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; - - /* cause rescan of list, it may have altered */ + /* cause rescan of list, it may have altered */ 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; @@ -1276,9 +1245,8 @@ nchinval(dev) */ 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; - } }