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