![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ufs_lookup.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / ufs|
Return to ufs_lookup.c CVS log | Up to [Net/2] / Net2 / ufs |
1.1 ! root 1: /* ! 2: * Copyright (c) 1989 The Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms, with or without ! 6: * modification, are permitted provided that the following conditions ! 7: * are met: ! 8: * 1. Redistributions of source code must retain the above copyright ! 9: * notice, this list of conditions and the following disclaimer. ! 10: * 2. Redistributions in binary form must reproduce the above copyright ! 11: * notice, this list of conditions and the following disclaimer in the ! 12: * documentation and/or other materials provided with the distribution. ! 13: * 3. All advertising materials mentioning features or use of this software ! 14: * must display the following acknowledgement: ! 15: * This product includes software developed by the University of ! 16: * California, Berkeley and its contributors. ! 17: * 4. Neither the name of the University nor the names of its contributors ! 18: * may be used to endorse or promote products derived from this software ! 19: * without specific prior written permission. ! 20: * ! 21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 31: * SUCH DAMAGE. ! 32: * ! 33: * @(#)ufs_lookup.c 7.33 (Berkeley) 5/19/91 ! 34: */ ! 35: ! 36: #include "param.h" ! 37: #include "namei.h" ! 38: #include "buf.h" ! 39: #include "file.h" ! 40: #include "vnode.h" ! 41: ! 42: #include "quota.h" ! 43: #include "inode.h" ! 44: #include "dir.h" ! 45: #include "fs.h" ! 46: ! 47: struct nchstats nchstats; ! 48: #ifdef DIAGNOSTIC ! 49: int dirchk = 1; ! 50: #else ! 51: int dirchk = 0; ! 52: #endif ! 53: ! 54: /* ! 55: * Convert a component of a pathname into a pointer to a locked inode. ! 56: * This is a very central and rather complicated routine. ! 57: * If the file system is not maintained in a strict tree hierarchy, ! 58: * this can result in a deadlock situation (see comments in code below). ! 59: * ! 60: * The flag argument is LOOKUP, CREATE, RENAME, or DELETE depending on ! 61: * whether the name is to be looked up, created, renamed, or deleted. ! 62: * When CREATE, RENAME, or DELETE is specified, information usable in ! 63: * creating, renaming, or deleting a directory entry may be calculated. ! 64: * If flag has LOCKPARENT or'ed into it and the target of the pathname ! 65: * exists, lookup returns both the target and its parent directory locked. ! 66: * When creating or renaming and LOCKPARENT is specified, the target may ! 67: * not be ".". When deleting and LOCKPARENT is specified, the target may ! 68: * be "."., but the caller must check to ensure it does an vrele and iput ! 69: * instead of two iputs. ! 70: * ! 71: * Overall outline of ufs_lookup: ! 72: * ! 73: * check accessibility of directory ! 74: * look for name in cache, if found, then if at end of path ! 75: * and deleting or creating, drop it, else return name ! 76: * search for name in directory, to found or notfound ! 77: * notfound: ! 78: * if creating, return locked directory, leaving info on available slots ! 79: * else return error ! 80: * found: ! 81: * if at end of path and deleting, return information to allow delete ! 82: * if at end of path and rewriting (RENAME and LOCKPARENT), lock target ! 83: * inode and return info to allow rewrite ! 84: * if not at end, add name to cache; if at end and neither creating ! 85: * nor deleting, add name to cache ! 86: * ! 87: * NOTE: (LOOKUP | LOCKPARENT) currently returns the parent inode unlocked. ! 88: */ ! 89: ufs_lookup(vdp, ndp, p) ! 90: register struct vnode *vdp; ! 91: register struct nameidata *ndp; ! 92: struct proc *p; ! 93: { ! 94: register struct inode *dp; /* the directory we are searching */ ! 95: register struct fs *fs; /* file system that directory is in */ ! 96: struct buf *bp = 0; /* a buffer of directory entries */ ! 97: register struct direct *ep; /* the current directory entry */ ! 98: int entryoffsetinblock; /* offset of ep in bp's buffer */ ! 99: enum {NONE, COMPACT, FOUND} slotstatus; ! 100: int slotoffset = -1; /* offset of area with free space */ ! 101: int slotsize; /* size of area at slotoffset */ ! 102: int slotfreespace; /* amount of space free in slot */ ! 103: int slotneeded; /* size of the entry we're seeking */ ! 104: int numdirpasses; /* strategy for directory search */ ! 105: int endsearch; /* offset to end directory search */ ! 106: int prevoff; /* ndp->ni_ufs.ufs_offset of previous entry */ ! 107: struct inode *pdp; /* saved dp during symlink work */ ! 108: struct inode *tdp; /* returned by iget */ ! 109: off_t enduseful; /* pointer past last used dir slot */ ! 110: int flag; /* LOOKUP, CREATE, RENAME, or DELETE */ ! 111: int lockparent; /* 1 => lockparent flag is set */ ! 112: int wantparent; /* 1 => wantparent or lockparent flag */ ! 113: int error; ! 114: ! 115: ndp->ni_dvp = vdp; ! 116: ndp->ni_vp = NULL; ! 117: dp = VTOI(vdp); ! 118: fs = dp->i_fs; ! 119: lockparent = ndp->ni_nameiop & LOCKPARENT; ! 120: flag = ndp->ni_nameiop & OPMASK; ! 121: wantparent = ndp->ni_nameiop & (LOCKPARENT|WANTPARENT); ! 122: ! 123: /* ! 124: * Check accessiblity of directory. ! 125: */ ! 126: if ((dp->i_mode&IFMT) != IFDIR) ! 127: return (ENOTDIR); ! 128: if (error = ufs_access(vdp, VEXEC, ndp->ni_cred, p)) ! 129: return (error); ! 130: ! 131: /* ! 132: * We now have a segment name to search for, and a directory to search. ! 133: * ! 134: * Before tediously performing a linear scan of the directory, ! 135: * check the name cache to see if the directory/name pair ! 136: * we are looking for is known already. ! 137: */ ! 138: if (error = cache_lookup(ndp)) { ! 139: int vpid; /* capability number of vnode */ ! 140: ! 141: if (error == ENOENT) ! 142: return (error); ! 143: #ifdef PARANOID ! 144: if (vdp == ndp->ni_rdir && ndp->ni_isdotdot) ! 145: panic("ufs_lookup: .. through root"); ! 146: #endif ! 147: /* ! 148: * Get the next vnode in the path. ! 149: * See comment below starting `Step through' for ! 150: * an explaination of the locking protocol. ! 151: */ ! 152: pdp = dp; ! 153: dp = VTOI(ndp->ni_vp); ! 154: vdp = ndp->ni_vp; ! 155: vpid = vdp->v_id; ! 156: if (pdp == dp) { ! 157: VREF(vdp); ! 158: error = 0; ! 159: } else if (ndp->ni_isdotdot) { ! 160: IUNLOCK(pdp); ! 161: error = vget(vdp); ! 162: if (!error && lockparent && *ndp->ni_next == '\0') ! 163: ILOCK(pdp); ! 164: } else { ! 165: error = vget(vdp); ! 166: if (!lockparent || error || *ndp->ni_next != '\0') ! 167: IUNLOCK(pdp); ! 168: } ! 169: /* ! 170: * Check that the capability number did not change ! 171: * while we were waiting for the lock. ! 172: */ ! 173: if (!error) { ! 174: if (vpid == vdp->v_id) ! 175: return (0); ! 176: iput(dp); ! 177: if (lockparent && pdp != dp && *ndp->ni_next == '\0') ! 178: IUNLOCK(pdp); ! 179: } ! 180: ILOCK(pdp); ! 181: dp = pdp; ! 182: vdp = ITOV(dp); ! 183: ndp->ni_vp = NULL; ! 184: } ! 185: ! 186: /* ! 187: * Suppress search for slots unless creating ! 188: * file and at end of pathname, in which case ! 189: * we watch for a place to put the new file in ! 190: * case it doesn't already exist. ! 191: */ ! 192: slotstatus = FOUND; ! 193: if ((flag == CREATE || flag == RENAME) && *ndp->ni_next == 0) { ! 194: slotstatus = NONE; ! 195: slotfreespace = 0; ! 196: slotneeded = ((sizeof (struct direct) - (MAXNAMLEN + 1)) + ! 197: ((ndp->ni_namelen + 1 + 3) &~ 3)); ! 198: } ! 199: ! 200: /* ! 201: * If there is cached information on a previous search of ! 202: * this directory, pick up where we last left off. ! 203: * We cache only lookups as these are the most common ! 204: * and have the greatest payoff. Caching CREATE has little ! 205: * benefit as it usually must search the entire directory ! 206: * to determine that the entry does not exist. Caching the ! 207: * location of the last DELETE or RENAME has not reduced ! 208: * profiling time and hence has been removed in the interest ! 209: * of simplicity. ! 210: */ ! 211: if (flag != LOOKUP || dp->i_diroff == 0 || dp->i_diroff > dp->i_size) { ! 212: ndp->ni_ufs.ufs_offset = 0; ! 213: numdirpasses = 1; ! 214: } else { ! 215: ndp->ni_ufs.ufs_offset = dp->i_diroff; ! 216: entryoffsetinblock = blkoff(fs, ndp->ni_ufs.ufs_offset); ! 217: if (entryoffsetinblock != 0) { ! 218: if (error = blkatoff(dp, ndp->ni_ufs.ufs_offset, ! 219: (char **)0, &bp)) ! 220: return (error); ! 221: } ! 222: numdirpasses = 2; ! 223: nchstats.ncs_2passes++; ! 224: } ! 225: endsearch = roundup(dp->i_size, DIRBLKSIZ); ! 226: enduseful = 0; ! 227: ! 228: searchloop: ! 229: while (ndp->ni_ufs.ufs_offset < endsearch) { ! 230: /* ! 231: * If offset is on a block boundary, ! 232: * read the next directory block. ! 233: * Release previous if it exists. ! 234: */ ! 235: if (blkoff(fs, ndp->ni_ufs.ufs_offset) == 0) { ! 236: if (bp != NULL) ! 237: brelse(bp); ! 238: if (error = blkatoff(dp, ndp->ni_ufs.ufs_offset, ! 239: (char **)0, &bp)) ! 240: return (error); ! 241: entryoffsetinblock = 0; ! 242: } ! 243: /* ! 244: * If still looking for a slot, and at a DIRBLKSIZE ! 245: * boundary, have to start looking for free space again. ! 246: */ ! 247: if (slotstatus == NONE && ! 248: (entryoffsetinblock & (DIRBLKSIZ - 1)) == 0) { ! 249: slotoffset = -1; ! 250: slotfreespace = 0; ! 251: } ! 252: /* ! 253: * Get pointer to next entry. ! 254: * Full validation checks are slow, so we only check ! 255: * enough to insure forward progress through the ! 256: * directory. Complete checks can be run by patching ! 257: * "dirchk" to be true. ! 258: */ ! 259: ep = (struct direct *)(bp->b_un.b_addr + entryoffsetinblock); ! 260: if (ep->d_reclen == 0 || ! 261: dirchk && dirbadentry(ep, entryoffsetinblock)) { ! 262: int i; ! 263: ! 264: dirbad(dp, ndp->ni_ufs.ufs_offset, "mangled entry"); ! 265: i = DIRBLKSIZ - (entryoffsetinblock & (DIRBLKSIZ - 1)); ! 266: ndp->ni_ufs.ufs_offset += i; ! 267: entryoffsetinblock += i; ! 268: continue; ! 269: } ! 270: ! 271: /* ! 272: * If an appropriate sized slot has not yet been found, ! 273: * check to see if one is available. Also accumulate space ! 274: * in the current block so that we can determine if ! 275: * compaction is viable. ! 276: */ ! 277: if (slotstatus != FOUND) { ! 278: int size = ep->d_reclen; ! 279: ! 280: if (ep->d_ino != 0) ! 281: size -= DIRSIZ(ep); ! 282: if (size > 0) { ! 283: if (size >= slotneeded) { ! 284: slotstatus = FOUND; ! 285: slotoffset = ndp->ni_ufs.ufs_offset; ! 286: slotsize = ep->d_reclen; ! 287: } else if (slotstatus == NONE) { ! 288: slotfreespace += size; ! 289: if (slotoffset == -1) ! 290: slotoffset = ! 291: ndp->ni_ufs.ufs_offset; ! 292: if (slotfreespace >= slotneeded) { ! 293: slotstatus = COMPACT; ! 294: slotsize = ! 295: ndp->ni_ufs.ufs_offset + ! 296: ep->d_reclen - slotoffset; ! 297: } ! 298: } ! 299: } ! 300: } ! 301: ! 302: /* ! 303: * Check for a name match. ! 304: */ ! 305: if (ep->d_ino) { ! 306: if (ep->d_namlen == ndp->ni_namelen && ! 307: !bcmp(ndp->ni_ptr, ep->d_name, ! 308: (unsigned)ep->d_namlen)) { ! 309: /* ! 310: * Save directory entry's inode number and ! 311: * reclen in ndp->ni_ufs area, and release ! 312: * directory buffer. ! 313: */ ! 314: ndp->ni_ufs.ufs_ino = ep->d_ino; ! 315: ndp->ni_ufs.ufs_reclen = ep->d_reclen; ! 316: brelse(bp); ! 317: goto found; ! 318: } ! 319: } ! 320: prevoff = ndp->ni_ufs.ufs_offset; ! 321: ndp->ni_ufs.ufs_offset += ep->d_reclen; ! 322: entryoffsetinblock += ep->d_reclen; ! 323: if (ep->d_ino) ! 324: enduseful = ndp->ni_ufs.ufs_offset; ! 325: } ! 326: /* notfound: */ ! 327: /* ! 328: * If we started in the middle of the directory and failed ! 329: * to find our target, we must check the beginning as well. ! 330: */ ! 331: if (numdirpasses == 2) { ! 332: numdirpasses--; ! 333: ndp->ni_ufs.ufs_offset = 0; ! 334: endsearch = dp->i_diroff; ! 335: goto searchloop; ! 336: } ! 337: if (bp != NULL) ! 338: brelse(bp); ! 339: /* ! 340: * If creating, and at end of pathname and current ! 341: * directory has not been removed, then can consider ! 342: * allowing file to be created. ! 343: */ ! 344: if ((flag == CREATE || flag == RENAME) && ! 345: *ndp->ni_next == 0 && dp->i_nlink != 0) { ! 346: /* ! 347: * Access for write is interpreted as allowing ! 348: * creation of files in the directory. ! 349: */ ! 350: if (error = ufs_access(vdp, VWRITE, ndp->ni_cred, p)) ! 351: return (error); ! 352: /* ! 353: * Return an indication of where the new directory ! 354: * entry should be put. If we didn't find a slot, ! 355: * then set ndp->ni_ufs.ufs_count to 0 indicating ! 356: * that the new slot belongs at the end of the ! 357: * directory. If we found a slot, then the new entry ! 358: * can be put in the range from ndp->ni_ufs.ufs_offset ! 359: * to ndp->ni_ufs.ufs_offset + ndp->ni_ufs.ufs_count. ! 360: */ ! 361: if (slotstatus == NONE) { ! 362: ndp->ni_ufs.ufs_offset = roundup(dp->i_size, DIRBLKSIZ); ! 363: ndp->ni_ufs.ufs_count = 0; ! 364: enduseful = ndp->ni_ufs.ufs_offset; ! 365: } else { ! 366: ndp->ni_ufs.ufs_offset = slotoffset; ! 367: ndp->ni_ufs.ufs_count = slotsize; ! 368: if (enduseful < slotoffset + slotsize) ! 369: enduseful = slotoffset + slotsize; ! 370: } ! 371: ndp->ni_ufs.ufs_endoff = roundup(enduseful, DIRBLKSIZ); ! 372: dp->i_flag |= IUPD|ICHG; ! 373: /* ! 374: * We return with the directory locked, so that ! 375: * the parameters we set up above will still be ! 376: * valid if we actually decide to do a direnter(). ! 377: * We return ni_vp == NULL to indicate that the entry ! 378: * does not currently exist; we leave a pointer to ! 379: * the (locked) directory inode in ndp->ni_dvp. ! 380: * The pathname buffer is saved so that the name ! 381: * can be obtained later. ! 382: * ! 383: * NB - if the directory is unlocked, then this ! 384: * information cannot be used. ! 385: */ ! 386: ndp->ni_nameiop |= SAVENAME; ! 387: if (!lockparent) ! 388: IUNLOCK(dp); ! 389: } ! 390: /* ! 391: * Insert name into cache (as non-existent) if appropriate. ! 392: */ ! 393: if (ndp->ni_makeentry && flag != CREATE) ! 394: cache_enter(ndp); ! 395: return (ENOENT); ! 396: ! 397: found: ! 398: if (numdirpasses == 2) ! 399: nchstats.ncs_pass2++; ! 400: /* ! 401: * Check that directory length properly reflects presence ! 402: * of this entry. ! 403: */ ! 404: if (entryoffsetinblock + DIRSIZ(ep) > dp->i_size) { ! 405: dirbad(dp, ndp->ni_ufs.ufs_offset, "i_size too small"); ! 406: dp->i_size = entryoffsetinblock + DIRSIZ(ep); ! 407: dp->i_flag |= IUPD|ICHG; ! 408: } ! 409: ! 410: /* ! 411: * Found component in pathname. ! 412: * If the final component of path name, save information ! 413: * in the cache as to where the entry was found. ! 414: */ ! 415: if (*ndp->ni_next == '\0' && flag == LOOKUP) ! 416: dp->i_diroff = ndp->ni_ufs.ufs_offset &~ (DIRBLKSIZ - 1); ! 417: ! 418: /* ! 419: * If deleting, and at end of pathname, return ! 420: * parameters which can be used to remove file. ! 421: * If the wantparent flag isn't set, we return only ! 422: * the directory (in ndp->ni_dvp), otherwise we go ! 423: * on and lock the inode, being careful with ".". ! 424: */ ! 425: if (flag == DELETE && *ndp->ni_next == 0) { ! 426: /* ! 427: * Write access to directory required to delete files. ! 428: */ ! 429: if (error = ufs_access(vdp, VWRITE, ndp->ni_cred, p)) ! 430: return (error); ! 431: /* ! 432: * Return pointer to current entry in ndp->ni_ufs.ufs_offset, ! 433: * and distance past previous entry (if there ! 434: * is a previous entry in this block) in ndp->ni_ufs.ufs_count. ! 435: * Save directory inode pointer in ndp->ni_dvp for dirremove(). ! 436: */ ! 437: if ((ndp->ni_ufs.ufs_offset&(DIRBLKSIZ-1)) == 0) ! 438: ndp->ni_ufs.ufs_count = 0; ! 439: else ! 440: ndp->ni_ufs.ufs_count = ndp->ni_ufs.ufs_offset - prevoff; ! 441: if (dp->i_number == ndp->ni_ufs.ufs_ino) { ! 442: VREF(vdp); ! 443: ndp->ni_vp = vdp; ! 444: return (0); ! 445: } ! 446: if (error = iget(dp, ndp->ni_ufs.ufs_ino, &tdp)) ! 447: return (error); ! 448: /* ! 449: * If directory is "sticky", then user must own ! 450: * the directory, or the file in it, else she ! 451: * may not delete it (unless she's root). This ! 452: * implements append-only directories. ! 453: */ ! 454: if ((dp->i_mode & ISVTX) && ! 455: ndp->ni_cred->cr_uid != 0 && ! 456: ndp->ni_cred->cr_uid != dp->i_uid && ! 457: tdp->i_uid != ndp->ni_cred->cr_uid) { ! 458: iput(tdp); ! 459: return (EPERM); ! 460: } ! 461: ndp->ni_vp = ITOV(tdp); ! 462: if (!lockparent) ! 463: IUNLOCK(dp); ! 464: return (0); ! 465: } ! 466: ! 467: /* ! 468: * If rewriting (RENAME), return the inode and the ! 469: * information required to rewrite the present directory ! 470: * Must get inode of directory entry to verify it's a ! 471: * regular file, or empty directory. ! 472: */ ! 473: if (flag == RENAME && wantparent && *ndp->ni_next == 0) { ! 474: if (error = ufs_access(vdp, VWRITE, ndp->ni_cred, p)) ! 475: return (error); ! 476: /* ! 477: * Careful about locking second inode. ! 478: * This can only occur if the target is ".". ! 479: */ ! 480: if (dp->i_number == ndp->ni_ufs.ufs_ino) ! 481: return (EISDIR); ! 482: if (error = iget(dp, ndp->ni_ufs.ufs_ino, &tdp)) ! 483: return (error); ! 484: ndp->ni_vp = ITOV(tdp); ! 485: ndp->ni_nameiop |= SAVENAME; ! 486: if (!lockparent) ! 487: IUNLOCK(dp); ! 488: return (0); ! 489: } ! 490: ! 491: /* ! 492: * Step through the translation in the name. We do not `iput' the ! 493: * directory because we may need it again if a symbolic link ! 494: * is relative to the current directory. Instead we save it ! 495: * unlocked as "pdp". We must get the target inode before unlocking ! 496: * the directory to insure that the inode will not be removed ! 497: * before we get it. We prevent deadlock by always fetching ! 498: * inodes from the root, moving down the directory tree. Thus ! 499: * when following backward pointers ".." we must unlock the ! 500: * parent directory before getting the requested directory. ! 501: * There is a potential race condition here if both the current ! 502: * and parent directories are removed before the `iget' for the ! 503: * inode associated with ".." returns. We hope that this occurs ! 504: * infrequently since we cannot avoid this race condition without ! 505: * implementing a sophisticated deadlock detection algorithm. ! 506: * Note also that this simple deadlock detection scheme will not ! 507: * work if the file system has any hard links other than ".." ! 508: * that point backwards in the directory structure. ! 509: */ ! 510: pdp = dp; ! 511: if (ndp->ni_isdotdot) { ! 512: IUNLOCK(pdp); /* race to get the inode */ ! 513: if (error = iget(dp, ndp->ni_ufs.ufs_ino, &tdp)) { ! 514: ILOCK(pdp); ! 515: return (error); ! 516: } ! 517: if (lockparent && *ndp->ni_next == '\0') ! 518: ILOCK(pdp); ! 519: ndp->ni_vp = ITOV(tdp); ! 520: } else if (dp->i_number == ndp->ni_ufs.ufs_ino) { ! 521: VREF(vdp); /* we want ourself, ie "." */ ! 522: ndp->ni_vp = vdp; ! 523: } else { ! 524: if (error = iget(dp, ndp->ni_ufs.ufs_ino, &tdp)) ! 525: return (error); ! 526: if (!lockparent || *ndp->ni_next != '\0') ! 527: IUNLOCK(pdp); ! 528: ndp->ni_vp = ITOV(tdp); ! 529: } ! 530: ! 531: /* ! 532: * Insert name into cache if appropriate. ! 533: */ ! 534: if (ndp->ni_makeentry) ! 535: cache_enter(ndp); ! 536: return (0); ! 537: } ! 538: ! 539: ! 540: dirbad(ip, offset, how) ! 541: struct inode *ip; ! 542: off_t offset; ! 543: char *how; ! 544: { ! 545: ! 546: printf("%s: bad dir ino %d at offset %d: %s\n", ! 547: ip->i_fs->fs_fsmnt, ip->i_number, offset, how); ! 548: if (ip->i_fs->fs_ronly == 0) ! 549: panic("bad dir"); ! 550: } ! 551: ! 552: /* ! 553: * Do consistency checking on a directory entry: ! 554: * record length must be multiple of 4 ! 555: * entry must fit in rest of its DIRBLKSIZ block ! 556: * record must be large enough to contain entry ! 557: * name is not longer than MAXNAMLEN ! 558: * name must be as long as advertised, and null terminated ! 559: */ ! 560: dirbadentry(ep, entryoffsetinblock) ! 561: register struct direct *ep; ! 562: int entryoffsetinblock; ! 563: { ! 564: register int i; ! 565: ! 566: if ((ep->d_reclen & 0x3) != 0 || ! 567: ep->d_reclen > DIRBLKSIZ - (entryoffsetinblock & (DIRBLKSIZ - 1)) || ! 568: ep->d_reclen < DIRSIZ(ep) || ep->d_namlen > MAXNAMLEN) ! 569: return (1); ! 570: for (i = 0; i < ep->d_namlen; i++) ! 571: if (ep->d_name[i] == '\0') ! 572: return (1); ! 573: return (ep->d_name[i]); ! 574: } ! 575: ! 576: /* ! 577: * Write a directory entry after a call to namei, using the parameters ! 578: * that it left in nameidata. The argument ip is the inode which the new ! 579: * directory entry will refer to. The nameidata field ndp->ni_dvp is a ! 580: * pointer to the directory to be written, which was left locked by namei. ! 581: * Remaining parameters (ndp->ni_ufs.ufs_offset, ndp->ni_ufs.ufs_count) ! 582: * indicate how the space for the new entry is to be obtained. ! 583: */ ! 584: direnter(ip, ndp) ! 585: struct inode *ip; ! 586: register struct nameidata *ndp; ! 587: { ! 588: register struct direct *ep, *nep; ! 589: register struct inode *dp = VTOI(ndp->ni_dvp); ! 590: struct buf *bp; ! 591: int loc, spacefree, error = 0; ! 592: u_int dsize; ! 593: int newentrysize; ! 594: char *dirbuf; ! 595: struct uio auio; ! 596: struct iovec aiov; ! 597: struct direct newdir; ! 598: ! 599: #ifdef DIAGNOSTIC ! 600: if ((ndp->ni_nameiop & SAVENAME) == 0) ! 601: panic("direnter: missing name"); ! 602: #endif ! 603: newdir.d_ino = ip->i_number; ! 604: newdir.d_namlen = ndp->ni_namelen; ! 605: bcopy(ndp->ni_ptr, newdir.d_name, (unsigned)ndp->ni_namelen + 1); ! 606: newentrysize = DIRSIZ(&newdir); ! 607: if (ndp->ni_ufs.ufs_count == 0) { ! 608: /* ! 609: * If ndp->ni_ufs.ufs_count is 0, then namei could find no ! 610: * space in the directory. Here, ndp->ni_ufs.ufs_offset will ! 611: * be on a directory block boundary and we will write the ! 612: * new entry into a fresh block. ! 613: */ ! 614: if (ndp->ni_ufs.ufs_offset & (DIRBLKSIZ - 1)) ! 615: panic("wdir: newblk"); ! 616: auio.uio_offset = ndp->ni_ufs.ufs_offset; ! 617: newdir.d_reclen = DIRBLKSIZ; ! 618: auio.uio_resid = newentrysize; ! 619: aiov.iov_len = newentrysize; ! 620: aiov.iov_base = (caddr_t)&newdir; ! 621: auio.uio_iov = &aiov; ! 622: auio.uio_iovcnt = 1; ! 623: auio.uio_rw = UIO_WRITE; ! 624: auio.uio_segflg = UIO_SYSSPACE; ! 625: auio.uio_procp = (struct proc *)0; ! 626: error = ufs_write(ndp->ni_dvp, &auio, IO_SYNC, ndp->ni_cred); ! 627: if (DIRBLKSIZ > dp->i_fs->fs_fsize) { ! 628: panic("wdir: blksize"); /* XXX - should grow w/balloc */ ! 629: } else if (!error) { ! 630: dp->i_size = roundup(dp->i_size, DIRBLKSIZ); ! 631: dp->i_flag |= ICHG; ! 632: } ! 633: return (error); ! 634: } ! 635: ! 636: /* ! 637: * If ndp->ni_ufs.ufs_count is non-zero, then namei found space ! 638: * for the new entry in the range ndp->ni_ufs.ufs_offset to ! 639: * ndp->ni_ufs.ufs_offset + ndp->ni_ufs.ufs_count in the directory. ! 640: * To use this space, we may have to compact the entries located ! 641: * there, by copying them together towards the beginning of the ! 642: * block, leaving the free space in one usable chunk at the end. ! 643: */ ! 644: ! 645: /* ! 646: * Increase size of directory if entry eats into new space. ! 647: * This should never push the size past a new multiple of ! 648: * DIRBLKSIZE. ! 649: * ! 650: * N.B. - THIS IS AN ARTIFACT OF 4.2 AND SHOULD NEVER HAPPEN. ! 651: */ ! 652: if (ndp->ni_ufs.ufs_offset + ndp->ni_ufs.ufs_count > dp->i_size) ! 653: dp->i_size = ndp->ni_ufs.ufs_offset + ndp->ni_ufs.ufs_count; ! 654: /* ! 655: * Get the block containing the space for the new directory entry. ! 656: */ ! 657: if (error = blkatoff(dp, ndp->ni_ufs.ufs_offset, (char **)&dirbuf, &bp)) ! 658: return (error); ! 659: /* ! 660: * Find space for the new entry. In the simple case, the entry at ! 661: * offset base will have the space. If it does not, then namei ! 662: * arranged that compacting the region ndp->ni_ufs.ufs_offset to ! 663: * ndp->ni_ufs.ufs_offset + ndp->ni_ufs.ufs_count would yield the ! 664: * space. ! 665: */ ! 666: ep = (struct direct *)dirbuf; ! 667: dsize = DIRSIZ(ep); ! 668: spacefree = ep->d_reclen - dsize; ! 669: for (loc = ep->d_reclen; loc < ndp->ni_ufs.ufs_count; ) { ! 670: nep = (struct direct *)(dirbuf + loc); ! 671: if (ep->d_ino) { ! 672: /* trim the existing slot */ ! 673: ep->d_reclen = dsize; ! 674: ep = (struct direct *)((char *)ep + dsize); ! 675: } else { ! 676: /* overwrite; nothing there; header is ours */ ! 677: spacefree += dsize; ! 678: } ! 679: dsize = DIRSIZ(nep); ! 680: spacefree += nep->d_reclen - dsize; ! 681: loc += nep->d_reclen; ! 682: bcopy((caddr_t)nep, (caddr_t)ep, dsize); ! 683: } ! 684: /* ! 685: * Update the pointer fields in the previous entry (if any), ! 686: * copy in the new entry, and write out the block. ! 687: */ ! 688: if (ep->d_ino == 0) { ! 689: if (spacefree + dsize < newentrysize) ! 690: panic("wdir: compact1"); ! 691: newdir.d_reclen = spacefree + dsize; ! 692: } else { ! 693: if (spacefree < newentrysize) ! 694: panic("wdir: compact2"); ! 695: newdir.d_reclen = spacefree; ! 696: ep->d_reclen = dsize; ! 697: ep = (struct direct *)((char *)ep + dsize); ! 698: } ! 699: bcopy((caddr_t)&newdir, (caddr_t)ep, (u_int)newentrysize); ! 700: error = bwrite(bp); ! 701: dp->i_flag |= IUPD|ICHG; ! 702: if (!error && ndp->ni_ufs.ufs_endoff && ! 703: ndp->ni_ufs.ufs_endoff < dp->i_size) ! 704: error = itrunc(dp, (u_long)ndp->ni_ufs.ufs_endoff, IO_SYNC); ! 705: return (error); ! 706: } ! 707: ! 708: /* ! 709: * Remove a directory entry after a call to namei, using ! 710: * the parameters which it left in nameidata. The entry ! 711: * ni_ufs.ufs_offset contains the offset into the directory of the ! 712: * entry to be eliminated. The ni_ufs.ufs_count field contains the ! 713: * size of the previous record in the directory. If this ! 714: * is 0, the first entry is being deleted, so we need only ! 715: * zero the inode number to mark the entry as free. If the ! 716: * entry is not the first in the directory, we must reclaim ! 717: * the space of the now empty record by adding the record size ! 718: * to the size of the previous entry. ! 719: */ ! 720: dirremove(ndp) ! 721: register struct nameidata *ndp; ! 722: { ! 723: register struct inode *dp = VTOI(ndp->ni_dvp); ! 724: struct direct *ep; ! 725: struct buf *bp; ! 726: int error; ! 727: ! 728: if (ndp->ni_ufs.ufs_count == 0) { ! 729: /* ! 730: * First entry in block: set d_ino to zero. ! 731: */ ! 732: error = blkatoff(dp, ndp->ni_ufs.ufs_offset, (char **)&ep, &bp); ! 733: if (error) ! 734: return (error); ! 735: ep->d_ino = 0; ! 736: error = bwrite(bp); ! 737: dp->i_flag |= IUPD|ICHG; ! 738: return (error); ! 739: } ! 740: /* ! 741: * Collapse new free space into previous entry. ! 742: */ ! 743: if (error = blkatoff(dp, ndp->ni_ufs.ufs_offset - ndp->ni_ufs.ufs_count, ! 744: (char **)&ep, &bp)) { ! 745: return (error); ! 746: } ! 747: ep->d_reclen += ndp->ni_ufs.ufs_reclen; ! 748: error = bwrite(bp); ! 749: dp->i_flag |= IUPD|ICHG; ! 750: return (error); ! 751: } ! 752: ! 753: /* ! 754: * Rewrite an existing directory entry to point at the inode ! 755: * supplied. The parameters describing the directory entry are ! 756: * set up by a call to namei. ! 757: */ ! 758: dirrewrite(dp, ip, ndp) ! 759: struct inode *dp, *ip; ! 760: struct nameidata *ndp; ! 761: { ! 762: struct direct *ep; ! 763: struct buf *bp; ! 764: int error; ! 765: ! 766: if (error = blkatoff(dp, ndp->ni_ufs.ufs_offset, (char **)&ep, &bp)) ! 767: return (error); ! 768: ep->d_ino = ip->i_number; ! 769: error = bwrite(bp); ! 770: dp->i_flag |= IUPD|ICHG; ! 771: return (error); ! 772: } ! 773: ! 774: /* ! 775: * Return buffer with contents of block "offset" ! 776: * from the beginning of directory "ip". If "res" ! 777: * is non-zero, fill it in with a pointer to the ! 778: * remaining space in the directory. ! 779: */ ! 780: blkatoff(ip, offset, res, bpp) ! 781: struct inode *ip; ! 782: off_t offset; ! 783: char **res; ! 784: struct buf **bpp; ! 785: { ! 786: register struct fs *fs = ip->i_fs; ! 787: daddr_t lbn = lblkno(fs, offset); ! 788: int bsize = blksize(fs, ip, lbn); ! 789: struct buf *bp; ! 790: daddr_t bn; ! 791: int error; ! 792: ! 793: *bpp = 0; ! 794: if (error = bread(ITOV(ip), lbn, bsize, NOCRED, &bp)) { ! 795: brelse(bp); ! 796: return (error); ! 797: } ! 798: if (res) ! 799: *res = bp->b_un.b_addr + blkoff(fs, offset); ! 800: *bpp = bp; ! 801: return (0); ! 802: } ! 803: ! 804: /* ! 805: * Check if a directory is empty or not. ! 806: * Inode supplied must be locked. ! 807: * ! 808: * Using a struct dirtemplate here is not precisely ! 809: * what we want, but better than using a struct direct. ! 810: * ! 811: * NB: does not handle corrupted directories. ! 812: */ ! 813: dirempty(ip, parentino, cred) ! 814: register struct inode *ip; ! 815: ino_t parentino; ! 816: struct ucred *cred; ! 817: { ! 818: register off_t off; ! 819: struct dirtemplate dbuf; ! 820: register struct direct *dp = (struct direct *)&dbuf; ! 821: int error, count; ! 822: #define MINDIRSIZ (sizeof (struct dirtemplate) / 2) ! 823: ! 824: for (off = 0; off < ip->i_size; off += dp->d_reclen) { ! 825: error = vn_rdwr(UIO_READ, ITOV(ip), (caddr_t)dp, MINDIRSIZ, off, ! 826: UIO_SYSSPACE, IO_NODELOCKED, cred, &count, (struct proc *)0); ! 827: /* ! 828: * Since we read MINDIRSIZ, residual must ! 829: * be 0 unless we're at end of file. ! 830: */ ! 831: if (error || count != 0) ! 832: return (0); ! 833: /* avoid infinite loops */ ! 834: if (dp->d_reclen == 0) ! 835: return (0); ! 836: /* skip empty entries */ ! 837: if (dp->d_ino == 0) ! 838: continue; ! 839: /* accept only "." and ".." */ ! 840: if (dp->d_namlen > 2) ! 841: return (0); ! 842: if (dp->d_name[0] != '.') ! 843: return (0); ! 844: /* ! 845: * At this point d_namlen must be 1 or 2. ! 846: * 1 implies ".", 2 implies ".." if second ! 847: * char is also "." ! 848: */ ! 849: if (dp->d_namlen == 1) ! 850: continue; ! 851: if (dp->d_name[1] == '.' && dp->d_ino == parentino) ! 852: continue; ! 853: return (0); ! 854: } ! 855: return (1); ! 856: } ! 857: ! 858: /* ! 859: * Check if source directory is in the path of the target directory. ! 860: * Target is supplied locked, source is unlocked. ! 861: * The target is always iput() before returning. ! 862: */ ! 863: checkpath(source, target, cred) ! 864: struct inode *source, *target; ! 865: struct ucred *cred; ! 866: { ! 867: struct dirtemplate dirbuf; ! 868: struct inode *ip; ! 869: int error = 0; ! 870: ! 871: ip = target; ! 872: if (ip->i_number == source->i_number) { ! 873: error = EEXIST; ! 874: goto out; ! 875: } ! 876: if (ip->i_number == ROOTINO) ! 877: goto out; ! 878: ! 879: for (;;) { ! 880: if ((ip->i_mode&IFMT) != IFDIR) { ! 881: error = ENOTDIR; ! 882: break; ! 883: } ! 884: error = vn_rdwr(UIO_READ, ITOV(ip), (caddr_t)&dirbuf, ! 885: sizeof (struct dirtemplate), (off_t)0, UIO_SYSSPACE, ! 886: IO_NODELOCKED, cred, (int *)0, (struct proc *)0); ! 887: if (error != 0) ! 888: break; ! 889: if (dirbuf.dotdot_namlen != 2 || ! 890: dirbuf.dotdot_name[0] != '.' || ! 891: dirbuf.dotdot_name[1] != '.') { ! 892: error = ENOTDIR; ! 893: break; ! 894: } ! 895: if (dirbuf.dotdot_ino == source->i_number) { ! 896: error = EINVAL; ! 897: break; ! 898: } ! 899: if (dirbuf.dotdot_ino == ROOTINO) ! 900: break; ! 901: iput(ip); ! 902: if (error = iget(ip, dirbuf.dotdot_ino, &ip)) ! 903: break; ! 904: } ! 905: ! 906: out: ! 907: if (error == ENOTDIR) ! 908: printf("checkpath: .. not a directory\n"); ! 909: if (ip != NULL) ! 910: iput(ip); ! 911: return (error); ! 912: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.