Annotation of sys/ufs/ufs/ufs_lookup.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: ufs_lookup.c,v 1.37 2007/06/01 23:47:57 deraadt Exp $ */
! 2: /* $NetBSD: ufs_lookup.c,v 1.7 1996/02/09 22:36:06 christos Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1989, 1993
! 6: * The Regents of the University of California. All rights reserved.
! 7: * (c) UNIX System Laboratories, Inc.
! 8: * All or some portions of this file are derived from material licensed
! 9: * to the University of California by American Telephone and Telegraph
! 10: * Co. or Unix System Laboratories, Inc. and are reproduced herein with
! 11: * the permission of UNIX System Laboratories, Inc.
! 12: *
! 13: * Redistribution and use in source and binary forms, with or without
! 14: * modification, are permitted provided that the following conditions
! 15: * are met:
! 16: * 1. Redistributions of source code must retain the above copyright
! 17: * notice, this list of conditions and the following disclaimer.
! 18: * 2. Redistributions in binary form must reproduce the above copyright
! 19: * notice, this list of conditions and the following disclaimer in the
! 20: * documentation and/or other materials provided with the distribution.
! 21: * 3. Neither the name of the University nor the names of its contributors
! 22: * may be used to endorse or promote products derived from this software
! 23: * without specific prior written permission.
! 24: *
! 25: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 26: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 27: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 28: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 29: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 30: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 31: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 32: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 33: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 34: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 35: * SUCH DAMAGE.
! 36: *
! 37: * @(#)ufs_lookup.c 8.9 (Berkeley) 8/11/94
! 38: */
! 39:
! 40: #include <sys/param.h>
! 41: #include <sys/systm.h>
! 42: #include <sys/kernel.h>
! 43: #include <sys/namei.h>
! 44: #include <sys/buf.h>
! 45: #include <sys/file.h>
! 46: #include <sys/stat.h>
! 47: #include <sys/mount.h>
! 48: #include <sys/vnode.h>
! 49:
! 50: #include <uvm/uvm_extern.h>
! 51:
! 52: #include <ufs/ufs/quota.h>
! 53: #include <ufs/ufs/inode.h>
! 54: #include <ufs/ufs/dir.h>
! 55: #ifdef UFS_DIRHASH
! 56: #include <ufs/ufs/dirhash.h>
! 57: #endif
! 58: #include <ufs/ufs/ufsmount.h>
! 59: #include <ufs/ufs/ufs_extern.h>
! 60:
! 61: extern struct nchstats nchstats;
! 62:
! 63: #ifdef DIAGNOSTIC
! 64: int dirchk = 1;
! 65: #else
! 66: int dirchk = 0;
! 67: #endif
! 68:
! 69: #define FSFMT(vp) ((vp)->v_mount->mnt_maxsymlinklen <= 0)
! 70:
! 71: /*
! 72: * Convert a component of a pathname into a pointer to a locked inode.
! 73: * This is a very central and rather complicated routine.
! 74: * If the file system is not maintained in a strict tree hierarchy,
! 75: * this can result in a deadlock situation (see comments in code below).
! 76: *
! 77: * The cnp->cn_nameiop argument is LOOKUP, CREATE, RENAME, or DELETE depending
! 78: * on whether the name is to be looked up, created, renamed, or deleted.
! 79: * When CREATE, RENAME, or DELETE is specified, information usable in
! 80: * creating, renaming, or deleting a directory entry may be calculated.
! 81: * If flag has LOCKPARENT or'ed into it and the target of the pathname
! 82: * exists, lookup returns both the target and its parent directory locked.
! 83: * When creating or renaming and LOCKPARENT is specified, the target may
! 84: * not be ".". When deleting and LOCKPARENT is specified, the target may
! 85: * be "."., but the caller must check to ensure it does an vrele and vput
! 86: * instead of two vputs.
! 87: *
! 88: * Overall outline of ufs_lookup:
! 89: *
! 90: * check accessibility of directory
! 91: * look for name in cache, if found, then if at end of path
! 92: * and deleting or creating, drop it, else return name
! 93: * search for name in directory, to found or notfound
! 94: * notfound:
! 95: * if creating, return locked directory, leaving info on available slots
! 96: * else return error
! 97: * found:
! 98: * if at end of path and deleting, return information to allow delete
! 99: * if at end of path and rewriting (RENAME and LOCKPARENT), lock target
! 100: * inode and return info to allow rewrite
! 101: * if not at end, add name to cache; if at end and neither creating
! 102: * nor deleting, add name to cache
! 103: */
! 104: int
! 105: ufs_lookup(void *v)
! 106: {
! 107: struct vop_lookup_args *ap = v;
! 108: struct vnode *vdp; /* vnode for directory being searched */
! 109: struct inode *dp; /* inode for directory being searched */
! 110: struct buf *bp; /* a buffer of directory entries */
! 111: struct direct *ep; /* the current directory entry */
! 112: int entryoffsetinblock; /* offset of ep in bp's buffer */
! 113: enum {NONE, COMPACT, FOUND} slotstatus;
! 114: doff_t slotoffset; /* offset of area with free space */
! 115: int slotsize; /* size of area at slotoffset */
! 116: int slotfreespace; /* amount of space free in slot */
! 117: int slotneeded; /* size of the entry we're seeking */
! 118: int numdirpasses; /* strategy for directory search */
! 119: doff_t endsearch; /* offset to end directory search */
! 120: doff_t prevoff; /* prev entry dp->i_offset */
! 121: struct vnode *pdp; /* saved dp during symlink work */
! 122: struct vnode *tdp; /* returned by VFS_VGET */
! 123: doff_t enduseful; /* pointer past last used dir slot */
! 124: u_long bmask; /* block offset mask */
! 125: int lockparent; /* 1 => lockparent flag is set */
! 126: int wantparent; /* 1 => wantparent or lockparent flag */
! 127: int namlen, error;
! 128: struct vnode **vpp = ap->a_vpp;
! 129: struct componentname *cnp = ap->a_cnp;
! 130: struct ucred *cred = cnp->cn_cred;
! 131: int flags;
! 132: int nameiop = cnp->cn_nameiop;
! 133: struct proc *p = cnp->cn_proc;
! 134:
! 135: cnp->cn_flags &= ~PDIRUNLOCK;
! 136: flags = cnp->cn_flags;
! 137:
! 138: bp = NULL;
! 139: slotoffset = -1;
! 140: *vpp = NULL;
! 141: vdp = ap->a_dvp;
! 142: dp = VTOI(vdp);
! 143: lockparent = flags & LOCKPARENT;
! 144: wantparent = flags & (LOCKPARENT|WANTPARENT);
! 145:
! 146: /*
! 147: * Check accessiblity of directory.
! 148: */
! 149: if ((DIP(dp, mode) & IFMT) != IFDIR)
! 150: return (ENOTDIR);
! 151: if ((error = VOP_ACCESS(vdp, VEXEC, cred, cnp->cn_proc)) != 0)
! 152: return (error);
! 153:
! 154: if ((flags & ISLASTCN) && (vdp->v_mount->mnt_flag & MNT_RDONLY) &&
! 155: (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
! 156: return (EROFS);
! 157:
! 158: /*
! 159: * We now have a segment name to search for, and a directory to search.
! 160: *
! 161: * Before tediously performing a linear scan of the directory,
! 162: * check the name cache to see if the directory/name pair
! 163: * we are looking for is known already.
! 164: */
! 165: if ((error = cache_lookup(vdp, vpp, cnp)) >= 0)
! 166: return (error);
! 167:
! 168: /*
! 169: * Suppress search for slots unless creating
! 170: * file and at end of pathname, in which case
! 171: * we watch for a place to put the new file in
! 172: * case it doesn't already exist.
! 173: */
! 174: slotstatus = FOUND;
! 175: slotfreespace = slotsize = slotneeded = 0;
! 176: if ((nameiop == CREATE || nameiop == RENAME) &&
! 177: (flags & ISLASTCN)) {
! 178: slotstatus = NONE;
! 179: slotneeded = (sizeof(struct direct) - MAXNAMLEN +
! 180: cnp->cn_namelen + 3) &~ 3;
! 181: }
! 182:
! 183: /*
! 184: * If there is cached information on a previous search of
! 185: * this directory, pick up where we last left off.
! 186: * We cache only lookups as these are the most common
! 187: * and have the greatest payoff. Caching CREATE has little
! 188: * benefit as it usually must search the entire directory
! 189: * to determine that the entry does not exist. Caching the
! 190: * location of the last DELETE or RENAME has not reduced
! 191: * profiling time and hence has been removed in the interest
! 192: * of simplicity.
! 193: */
! 194: bmask = VFSTOUFS(vdp->v_mount)->um_mountp->mnt_stat.f_iosize - 1;
! 195:
! 196: #ifdef UFS_DIRHASH
! 197: /*
! 198: * Use dirhash for fast operations on large directories. The logic
! 199: * to determine whether to hash the directory is contained within
! 200: * ufsdirhash_build(); a zero return means that it decided to hash
! 201: * this directory and it successfully built up the hash table.
! 202: */
! 203: if (ufsdirhash_build(dp) == 0) {
! 204: /* Look for a free slot if needed. */
! 205: enduseful = DIP(dp, size);
! 206: if (slotstatus != FOUND) {
! 207: slotoffset = ufsdirhash_findfree(dp, slotneeded,
! 208: &slotsize);
! 209: if (slotoffset >= 0) {
! 210: slotstatus = COMPACT;
! 211: enduseful = ufsdirhash_enduseful(dp);
! 212: if (enduseful < 0)
! 213: enduseful = DIP(dp, size);
! 214: }
! 215: }
! 216: /* Look up the component. */
! 217: numdirpasses = 1;
! 218: entryoffsetinblock = 0; /* silence compiler warning */
! 219: switch (ufsdirhash_lookup(dp, cnp->cn_nameptr, cnp->cn_namelen,
! 220: &dp->i_offset, &bp, nameiop == DELETE ? &prevoff : NULL)) {
! 221: case 0:
! 222: ep = (struct direct *)((char *)bp->b_data +
! 223: (dp->i_offset & bmask));
! 224: goto foundentry;
! 225: case ENOENT:
! 226: #define roundup2(x, y) (((x)+((y)-1))&(~((y)-1))) /* if y is powers of two */
! 227: dp->i_offset = roundup2(DIP(dp, size), DIRBLKSIZ);
! 228: goto notfound;
! 229: default:
! 230: /* Something failed; just do a linear search. */
! 231: break;
! 232: }
! 233: }
! 234: #endif /* UFS_DIRHASH */
! 235:
! 236: if (nameiop != LOOKUP || dp->i_diroff == 0 ||
! 237: dp->i_diroff >= DIP(dp, size)) {
! 238: entryoffsetinblock = 0;
! 239: dp->i_offset = 0;
! 240: numdirpasses = 1;
! 241: } else {
! 242: dp->i_offset = dp->i_diroff;
! 243: if ((entryoffsetinblock = dp->i_offset & bmask) &&
! 244: (error = UFS_BUFATOFF(dp, (off_t)dp->i_offset, NULL, &bp)))
! 245: return (error);
! 246: numdirpasses = 2;
! 247: nchstats.ncs_2passes++;
! 248: }
! 249: prevoff = dp->i_offset;
! 250: endsearch = roundup(DIP(dp, size), DIRBLKSIZ);
! 251: enduseful = 0;
! 252:
! 253: searchloop:
! 254: while (dp->i_offset < endsearch) {
! 255: /*
! 256: * If necessary, get the next directory block.
! 257: */
! 258: if ((dp->i_offset & bmask) == 0) {
! 259: if (bp != NULL)
! 260: brelse(bp);
! 261: error = UFS_BUFATOFF(dp, (off_t)dp->i_offset, NULL,
! 262: &bp);
! 263: if (error)
! 264: return (error);
! 265: entryoffsetinblock = 0;
! 266: }
! 267: /*
! 268: * If still looking for a slot, and at a DIRBLKSIZE
! 269: * boundary, have to start looking for free space again.
! 270: */
! 271: if (slotstatus == NONE &&
! 272: (entryoffsetinblock & (DIRBLKSIZ - 1)) == 0) {
! 273: slotoffset = -1;
! 274: slotfreespace = 0;
! 275: }
! 276: /*
! 277: * Get pointer to next entry.
! 278: * Full validation checks are slow, so we only check
! 279: * enough to insure forward progress through the
! 280: * directory. Complete checks can be run by patching
! 281: * "dirchk" to be true.
! 282: */
! 283: ep = (struct direct *)((char *)bp->b_data + entryoffsetinblock);
! 284: if (ep->d_reclen == 0 ||
! 285: (dirchk && ufs_dirbadentry(vdp, ep, entryoffsetinblock))) {
! 286: int i;
! 287:
! 288: ufs_dirbad(dp, dp->i_offset, "mangled entry");
! 289: i = DIRBLKSIZ - (entryoffsetinblock & (DIRBLKSIZ - 1));
! 290: dp->i_offset += i;
! 291: entryoffsetinblock += i;
! 292: continue;
! 293: }
! 294:
! 295: /*
! 296: * If an appropriate sized slot has not yet been found,
! 297: * check to see if one is available. Also accumulate space
! 298: * in the current block so that we can determine if
! 299: * compaction is viable.
! 300: */
! 301: if (slotstatus != FOUND) {
! 302: int size = ep->d_reclen;
! 303:
! 304: if (ep->d_ino != 0)
! 305: size -= DIRSIZ(FSFMT(vdp), ep);
! 306: if (size > 0) {
! 307: if (size >= slotneeded) {
! 308: slotstatus = FOUND;
! 309: slotoffset = dp->i_offset;
! 310: slotsize = ep->d_reclen;
! 311: } else if (slotstatus == NONE) {
! 312: slotfreespace += size;
! 313: if (slotoffset == -1)
! 314: slotoffset = dp->i_offset;
! 315: if (slotfreespace >= slotneeded) {
! 316: slotstatus = COMPACT;
! 317: slotsize = dp->i_offset +
! 318: ep->d_reclen - slotoffset;
! 319: }
! 320: }
! 321: }
! 322: }
! 323:
! 324: /*
! 325: * Check for a name match.
! 326: */
! 327: if (ep->d_ino) {
! 328: # if (BYTE_ORDER == LITTLE_ENDIAN)
! 329: if (vdp->v_mount->mnt_maxsymlinklen > 0)
! 330: namlen = ep->d_namlen;
! 331: else
! 332: namlen = ep->d_type;
! 333: # else
! 334: namlen = ep->d_namlen;
! 335: # endif
! 336: if (namlen == cnp->cn_namelen &&
! 337: !bcmp(cnp->cn_nameptr, ep->d_name,
! 338: (unsigned)namlen)) {
! 339: #ifdef UFS_DIRHASH
! 340: foundentry:
! 341: #endif
! 342: /*
! 343: * Save directory entry's inode number and
! 344: * reclen in ndp->ni_ufs area, and release
! 345: * directory buffer.
! 346: */
! 347: dp->i_ino = ep->d_ino;
! 348: dp->i_reclen = ep->d_reclen;
! 349: goto found;
! 350: }
! 351: }
! 352: prevoff = dp->i_offset;
! 353: dp->i_offset += ep->d_reclen;
! 354: entryoffsetinblock += ep->d_reclen;
! 355: if (ep->d_ino)
! 356: enduseful = dp->i_offset;
! 357: }
! 358: #ifdef UFS_DIRHASH
! 359: notfound:
! 360: #endif
! 361: /*
! 362: * If we started in the middle of the directory and failed
! 363: * to find our target, we must check the beginning as well.
! 364: */
! 365: if (numdirpasses == 2) {
! 366: numdirpasses--;
! 367: dp->i_offset = 0;
! 368: endsearch = dp->i_diroff;
! 369: goto searchloop;
! 370: }
! 371: if (bp != NULL)
! 372: brelse(bp);
! 373: /*
! 374: * If creating, and at end of pathname and current
! 375: * directory has not been removed, then can consider
! 376: * allowing file to be created.
! 377: */
! 378: if ((nameiop == CREATE || nameiop == RENAME) &&
! 379: (flags & ISLASTCN) && dp->i_effnlink != 0) {
! 380: /*
! 381: * Access for write is interpreted as allowing
! 382: * creation of files in the directory.
! 383: */
! 384: error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_proc);
! 385: if (error)
! 386: return (error);
! 387: /*
! 388: * Return an indication of where the new directory
! 389: * entry should be put. If we didn't find a slot,
! 390: * then set dp->i_count to 0 indicating
! 391: * that the new slot belongs at the end of the
! 392: * directory. If we found a slot, then the new entry
! 393: * can be put in the range from dp->i_offset to
! 394: * dp->i_offset + dp->i_count.
! 395: */
! 396: if (slotstatus == NONE) {
! 397: dp->i_offset = roundup(DIP(dp, size), DIRBLKSIZ);
! 398: dp->i_count = 0;
! 399: enduseful = dp->i_offset;
! 400: } else if (nameiop == DELETE) {
! 401: dp->i_offset = slotoffset;
! 402: if ((dp->i_offset & (DIRBLKSIZ - 1)) == 0)
! 403: dp->i_count = 0;
! 404: else
! 405: dp->i_count = dp->i_offset - prevoff;
! 406: } else {
! 407: dp->i_offset = slotoffset;
! 408: dp->i_count = slotsize;
! 409: if (enduseful < slotoffset + slotsize)
! 410: enduseful = slotoffset + slotsize;
! 411: }
! 412: dp->i_endoff = roundup(enduseful, DIRBLKSIZ);
! 413: /*
! 414: * We return with the directory locked, so that
! 415: * the parameters we set up above will still be
! 416: * valid if we actually decide to do a direnter().
! 417: * We return ni_vp == NULL to indicate that the entry
! 418: * does not currently exist; we leave a pointer to
! 419: * the (locked) directory inode in ndp->ni_dvp.
! 420: * The pathname buffer is saved so that the name
! 421: * can be obtained later.
! 422: *
! 423: * NB - if the directory is unlocked, then this
! 424: * information cannot be used.
! 425: */
! 426: cnp->cn_flags |= SAVENAME;
! 427: if (!lockparent) {
! 428: VOP_UNLOCK(vdp, 0, p);
! 429: cnp->cn_flags |= PDIRUNLOCK;
! 430: }
! 431: return (EJUSTRETURN);
! 432: }
! 433: /*
! 434: * Insert name into cache (as non-existent) if appropriate.
! 435: */
! 436: if ((cnp->cn_flags & MAKEENTRY) && nameiop != CREATE)
! 437: cache_enter(vdp, *vpp, cnp);
! 438: return (ENOENT);
! 439:
! 440: found:
! 441: if (numdirpasses == 2)
! 442: nchstats.ncs_pass2++;
! 443: /*
! 444: * Check that directory length properly reflects presence
! 445: * of this entry.
! 446: */
! 447: if (dp->i_offset + DIRSIZ(FSFMT(vdp), ep) > DIP(dp, size)) {
! 448: ufs_dirbad(dp, dp->i_offset, "i_ffs_size too small");
! 449: DIP_ASSIGN(dp, size, dp->i_offset + DIRSIZ(FSFMT(vdp), ep));
! 450: dp->i_flag |= IN_CHANGE | IN_UPDATE;
! 451: }
! 452: brelse(bp);
! 453:
! 454: /*
! 455: * Found component in pathname.
! 456: * If the final component of path name, save information
! 457: * in the cache as to where the entry was found.
! 458: */
! 459: if ((flags & ISLASTCN) && nameiop == LOOKUP)
! 460: dp->i_diroff = dp->i_offset &~ (DIRBLKSIZ - 1);
! 461:
! 462: /*
! 463: * If deleting, and at end of pathname, return
! 464: * parameters which can be used to remove file.
! 465: * If the wantparent flag isn't set, we return only
! 466: * the directory (in ndp->ni_dvp), otherwise we go
! 467: * on and lock the inode, being careful with ".".
! 468: */
! 469: if (nameiop == DELETE && (flags & ISLASTCN)) {
! 470: /*
! 471: * Write access to directory required to delete files.
! 472: */
! 473: error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_proc);
! 474: if (error)
! 475: return (error);
! 476: /*
! 477: * Return pointer to current entry in dp->i_offset,
! 478: * and distance past previous entry (if there
! 479: * is a previous entry in this block) in dp->i_count.
! 480: * Save directory inode pointer in ndp->ni_dvp for dirremove().
! 481: */
! 482: if ((dp->i_offset & (DIRBLKSIZ - 1)) == 0)
! 483: dp->i_count = 0;
! 484: else
! 485: dp->i_count = dp->i_offset - prevoff;
! 486: if (dp->i_number == dp->i_ino) {
! 487: VREF(vdp);
! 488: *vpp = vdp;
! 489: return (0);
! 490: }
! 491: error = VFS_VGET(vdp->v_mount, dp->i_ino, &tdp);
! 492: if (error)
! 493: return (error);
! 494: /*
! 495: * If directory is "sticky", then user must own
! 496: * the directory, or the file in it, else she
! 497: * may not delete it (unless she's root). This
! 498: * implements append-only directories.
! 499: */
! 500: if ((DIP(dp, mode) & ISVTX) &&
! 501: cred->cr_uid != 0 &&
! 502: cred->cr_uid != DIP(dp, uid) &&
! 503: DIP(VTOI(tdp), uid) != cred->cr_uid) {
! 504: vput(tdp);
! 505: return (EPERM);
! 506: }
! 507: *vpp = tdp;
! 508: if (!lockparent) {
! 509: VOP_UNLOCK(vdp, 0, p);
! 510: cnp->cn_flags |= PDIRUNLOCK;
! 511: }
! 512: return (0);
! 513: }
! 514:
! 515: /*
! 516: * If rewriting (RENAME), return the inode and the
! 517: * information required to rewrite the present directory
! 518: * Must get inode of directory entry to verify it's a
! 519: * regular file, or empty directory.
! 520: */
! 521: if (nameiop == RENAME && wantparent &&
! 522: (flags & ISLASTCN)) {
! 523: error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_proc);
! 524: if (error)
! 525: return (error);
! 526: /*
! 527: * Careful about locking second inode.
! 528: * This can only occur if the target is ".".
! 529: */
! 530: if (dp->i_number == dp->i_ino)
! 531: return (EISDIR);
! 532: error = VFS_VGET(vdp->v_mount, dp->i_ino, &tdp);
! 533: if (error)
! 534: return (error);
! 535: *vpp = tdp;
! 536: cnp->cn_flags |= SAVENAME;
! 537: if (!lockparent) {
! 538: VOP_UNLOCK(vdp, 0, p);
! 539: cnp->cn_flags |= PDIRUNLOCK;
! 540: }
! 541: return (0);
! 542: }
! 543:
! 544: /*
! 545: * Step through the translation in the name. We do not `vput' the
! 546: * directory because we may need it again if a symbolic link
! 547: * is relative to the current directory. Instead we save it
! 548: * unlocked as "pdp". We must get the target inode before unlocking
! 549: * the directory to insure that the inode will not be removed
! 550: * before we get it. We prevent deadlock by always fetching
! 551: * inodes from the root, moving down the directory tree. Thus
! 552: * when following backward pointers ".." we must unlock the
! 553: * parent directory before getting the requested directory.
! 554: * There is a potential race condition here if both the current
! 555: * and parent directories are removed before the VFS_VGET for the
! 556: * inode associated with ".." returns. We hope that this occurs
! 557: * infrequently since we cannot avoid this race condition without
! 558: * implementing a sophisticated deadlock detection algorithm.
! 559: * Note also that this simple deadlock detection scheme will not
! 560: * work if the file system has any hard links other than ".."
! 561: * that point backwards in the directory structure.
! 562: */
! 563: pdp = vdp;
! 564: if (flags & ISDOTDOT) {
! 565: VOP_UNLOCK(pdp, 0, p); /* race to get the inode */
! 566: cnp->cn_flags |= PDIRUNLOCK;
! 567: error = VFS_VGET(vdp->v_mount, dp->i_ino, &tdp);
! 568: if (error) {
! 569: if (vn_lock(pdp, LK_EXCLUSIVE | LK_RETRY, p) == 0)
! 570: cnp->cn_flags &= ~PDIRUNLOCK;
! 571: return (error);
! 572: }
! 573: if (lockparent && (flags & ISLASTCN)) {
! 574: if ((error = vn_lock(pdp, LK_EXCLUSIVE, p))) {
! 575: vput(tdp);
! 576: return (error);
! 577: }
! 578: cnp->cn_flags &= ~PDIRUNLOCK;
! 579: }
! 580: *vpp = tdp;
! 581: } else if (dp->i_number == dp->i_ino) {
! 582: VREF(vdp); /* we want ourself, ie "." */
! 583: *vpp = vdp;
! 584: } else {
! 585: error = VFS_VGET(vdp->v_mount, dp->i_ino, &tdp);
! 586: if (error)
! 587: return (error);
! 588: if (!lockparent || !(flags & ISLASTCN)) {
! 589: VOP_UNLOCK(pdp, 0, p);
! 590: cnp->cn_flags |= PDIRUNLOCK;
! 591: }
! 592: *vpp = tdp;
! 593: }
! 594:
! 595: /*
! 596: * Insert name into cache if appropriate.
! 597: */
! 598: if (cnp->cn_flags & MAKEENTRY)
! 599: cache_enter(vdp, *vpp, cnp);
! 600: return (0);
! 601: }
! 602:
! 603: void
! 604: ufs_dirbad(struct inode *ip, doff_t offset, char *how)
! 605: {
! 606: struct mount *mp;
! 607:
! 608: mp = ITOV(ip)->v_mount;
! 609: (void)printf("%s: bad dir ino %d at offset %d: %s\n",
! 610: mp->mnt_stat.f_mntonname, ip->i_number, offset, how);
! 611: if ((mp->mnt_stat.f_flags & MNT_RDONLY) == 0)
! 612: panic("bad dir");
! 613: }
! 614:
! 615: /*
! 616: * Do consistency checking on a directory entry:
! 617: * record length must be multiple of 4
! 618: * entry must fit in rest of its DIRBLKSIZ block
! 619: * record must be large enough to contain entry
! 620: * name is not longer than MAXNAMLEN
! 621: * name must be as long as advertised, and null terminated
! 622: */
! 623: int
! 624: ufs_dirbadentry(struct vnode *dp, struct direct *ep, int entryoffsetinblock)
! 625: {
! 626: int i;
! 627: int namlen;
! 628:
! 629: # if (BYTE_ORDER == LITTLE_ENDIAN)
! 630: if (dp->v_mount->mnt_maxsymlinklen > 0)
! 631: namlen = ep->d_namlen;
! 632: else
! 633: namlen = ep->d_type;
! 634: # else
! 635: namlen = ep->d_namlen;
! 636: # endif
! 637: if ((ep->d_reclen & 0x3) != 0 ||
! 638: ep->d_reclen > DIRBLKSIZ - (entryoffsetinblock & (DIRBLKSIZ - 1)) ||
! 639: ep->d_reclen < DIRSIZ(FSFMT(dp), ep) || namlen > MAXNAMLEN) {
! 640: /*return (1); */
! 641: printf("First bad\n");
! 642: goto bad;
! 643: }
! 644: if (ep->d_ino == 0)
! 645: return (0);
! 646: for (i = 0; i < namlen; i++)
! 647: if (ep->d_name[i] == '\0') {
! 648: /*return (1); */
! 649: printf("Second bad\n");
! 650: goto bad;
! 651: }
! 652: if (ep->d_name[i])
! 653: goto bad;
! 654: return (0);
! 655: bad:
! 656: return (1);
! 657: }
! 658:
! 659: /*
! 660: * Construct a new directory entry after a call to namei, using the
! 661: * parameters that it left in the componentname argument cnp. The
! 662: * argument ip is the inode to which the new directory entry will refer.
! 663: */
! 664: void
! 665: ufs_makedirentry(struct inode *ip, struct componentname *cnp,
! 666: struct direct *newdirp)
! 667: {
! 668: #ifdef DIAGNOSTIC
! 669: if ((cnp->cn_flags & SAVENAME) == 0)
! 670: panic("ufs_makedirentry: missing name");
! 671: #endif
! 672: newdirp->d_ino = ip->i_number;
! 673: newdirp->d_namlen = cnp->cn_namelen;
! 674: bcopy(cnp->cn_nameptr, newdirp->d_name, (unsigned)cnp->cn_namelen + 1);
! 675: if (ITOV(ip)->v_mount->mnt_maxsymlinklen > 0)
! 676: newdirp->d_type = IFTODT(DIP(ip, mode));
! 677: else {
! 678: newdirp->d_type = 0;
! 679: # if (BYTE_ORDER == LITTLE_ENDIAN)
! 680: { u_char tmp = newdirp->d_namlen;
! 681: newdirp->d_namlen = newdirp->d_type;
! 682: newdirp->d_type = tmp; }
! 683: # endif
! 684: }
! 685: }
! 686:
! 687: /*
! 688: * Write a directory entry after a call to namei, using the parameters
! 689: * that it left in nameidata. The argument dirp is the new directory
! 690: * entry contents. Dvp is a pointer to the directory to be written,
! 691: * which was left locked by namei. Remaining parameters (dp->i_offset,
! 692: * dp->i_count) indicate how the space for the new entry is to be obtained.
! 693: * Non-null bp indicates that a directory is being created (for the
! 694: * soft dependency code).
! 695: */
! 696: int
! 697: ufs_direnter(struct vnode *dvp, struct vnode *tvp, struct direct *dirp,
! 698: struct componentname *cnp, struct buf *newdirbp)
! 699: {
! 700: struct ucred *cr;
! 701: struct proc *p;
! 702: int newentrysize;
! 703: struct inode *dp;
! 704: struct buf *bp;
! 705: u_int dsize;
! 706: struct direct *ep, *nep;
! 707: int error, ret, blkoff, loc, spacefree, flags;
! 708: char *dirbuf;
! 709:
! 710: error = 0;
! 711: cr = cnp->cn_cred;
! 712: p = cnp->cn_proc;
! 713: dp = VTOI(dvp);
! 714: newentrysize = DIRSIZ(FSFMT(dvp), dirp);
! 715:
! 716: if (dp->i_count == 0) {
! 717: /*
! 718: * If dp->i_count is 0, then namei could find no
! 719: * space in the directory. Here, dp->i_offset will
! 720: * be on a directory block boundary and we will write the
! 721: * new entry into a fresh block.
! 722: */
! 723: if (dp->i_offset & (DIRBLKSIZ - 1))
! 724: panic("ufs_direnter: newblk");
! 725: flags = B_CLRBUF;
! 726: if (!DOINGSOFTDEP(dvp))
! 727: flags |= B_SYNC;
! 728: if ((error = UFS_BUF_ALLOC(dp, (off_t)dp->i_offset, DIRBLKSIZ,
! 729: cr, flags, &bp)) != 0) {
! 730: if (DOINGSOFTDEP(dvp) && newdirbp != NULL)
! 731: bdwrite(newdirbp);
! 732: return (error);
! 733: }
! 734: DIP_ASSIGN(dp, size, dp->i_offset + DIRBLKSIZ);
! 735: dp->i_flag |= IN_CHANGE | IN_UPDATE;
! 736: uvm_vnp_setsize(dvp, DIP(dp, size));
! 737: dirp->d_reclen = DIRBLKSIZ;
! 738: blkoff = dp->i_offset &
! 739: (VFSTOUFS(dvp->v_mount)->um_mountp->mnt_stat.f_iosize - 1);
! 740: bcopy((caddr_t)dirp, (caddr_t)bp->b_data + blkoff,newentrysize);
! 741:
! 742: #ifdef UFS_DIRHASH
! 743: if (dp->i_dirhash != NULL) {
! 744: ufsdirhash_newblk(dp, dp->i_offset);
! 745: ufsdirhash_add(dp, dirp, dp->i_offset);
! 746: ufsdirhash_checkblock(dp, (char *)bp->b_data + blkoff,
! 747: dp->i_offset);
! 748: }
! 749: #endif
! 750:
! 751: if (DOINGSOFTDEP(dvp)) {
! 752: /*
! 753: * Ensure that the entire newly allocated block is a
! 754: * valid directory so that future growth within the
! 755: * block does not have to ensure that the block is
! 756: * written before the inode.
! 757: */
! 758: blkoff += DIRBLKSIZ;
! 759: while (blkoff < bp->b_bcount) {
! 760: ((struct direct *)
! 761: (bp->b_data + blkoff))->d_reclen = DIRBLKSIZ;
! 762: blkoff += DIRBLKSIZ;
! 763: }
! 764: if (softdep_setup_directory_add(bp, dp, dp->i_offset,
! 765: dirp->d_ino, newdirbp, 1) == 0) {
! 766: bdwrite(bp);
! 767: return (UFS_UPDATE(dp, 0));
! 768: }
! 769: /* We have just allocated a directory block in an
! 770: * indirect block. Rather than tracking when it gets
! 771: * claimed by the inode, we simply do a VOP_FSYNC
! 772: * now to ensure that it is there (in case the user
! 773: * does a future fsync). Note that we have to unlock
! 774: * the inode for the entry that we just entered, as
! 775: * the VOP_FSYNC may need to lock other inodes which
! 776: * can lead to deadlock if we also hold a lock on
! 777: * the newly entered node.
! 778: */
! 779: if ((error = VOP_BWRITE(bp)))
! 780: return (error);
! 781: if (tvp != NULL)
! 782: VOP_UNLOCK(tvp, 0, p);
! 783: error = VOP_FSYNC(dvp, p->p_ucred, MNT_WAIT, p);
! 784: if (tvp != NULL)
! 785: vn_lock(tvp, LK_EXCLUSIVE | LK_RETRY, p);
! 786: return (error);
! 787: }
! 788: error = VOP_BWRITE(bp);
! 789: ret = UFS_UPDATE(dp, !DOINGSOFTDEP(dvp));
! 790: if (error == 0)
! 791: return (ret);
! 792: return (error);
! 793: }
! 794:
! 795: /*
! 796: * If dp->i_count is non-zero, then namei found space for the new
! 797: * entry in the range dp->i_offset to dp->i_offset + dp->i_count
! 798: * in the directory. To use this space, we may have to compact
! 799: * the entries located there, by copying them together towards the
! 800: * beginning of the block, leaving the free space in one usable
! 801: * chunk at the end.
! 802: */
! 803:
! 804: /*
! 805: * Increase size of directory if entry eats into new space.
! 806: * This should never push the size past a new multiple of
! 807: * DIRBLKSIZE.
! 808: *
! 809: * N.B. - THIS IS AN ARTIFACT OF 4.2 AND SHOULD NEVER HAPPEN.
! 810: */
! 811: if (dp->i_offset + dp->i_count > DIP(dp, size))
! 812: DIP_ASSIGN(dp, size, dp->i_offset + dp->i_count);
! 813: /*
! 814: * Get the block containing the space for the new directory entry.
! 815: */
! 816: if ((error = UFS_BUFATOFF(dp, (off_t)dp->i_offset, &dirbuf, &bp))
! 817: != 0) {
! 818: if (DOINGSOFTDEP(dvp) && newdirbp != NULL)
! 819: bdwrite(newdirbp);
! 820: return (error);
! 821: }
! 822: /*
! 823: * Find space for the new entry. In the simple case, the entry at
! 824: * offset base will have the space. If it does not, then namei
! 825: * arranged that compacting the region dp->i_offset to
! 826: * dp->i_offset + dp->i_count would yield the space.
! 827: */
! 828: ep = (struct direct *)dirbuf;
! 829: dsize = ep->d_ino ? DIRSIZ(FSFMT(dvp), ep) : 0;
! 830: spacefree = ep->d_reclen - dsize;
! 831: for (loc = ep->d_reclen; loc < dp->i_count; ) {
! 832: nep = (struct direct *)(dirbuf + loc);
! 833:
! 834: /* Trim the existing slot (NB: dsize may be zero). */
! 835: ep->d_reclen = dsize;
! 836: ep = (struct direct *)((char *)ep + dsize);
! 837:
! 838: /* Read nep->d_reclen now as the bcopy() may clobber it. */
! 839: loc += nep->d_reclen;
! 840: if (nep->d_ino == 0) {
! 841: /*
! 842: * A mid-block unused entry. Such entries are
! 843: * never created by the kernel, but fsck_ffs
! 844: * can create them (and it doesn't fix them).
! 845: *
! 846: * Add up the free space, and initialise the
! 847: * relocated entry since we don't bcopy it.
! 848: */
! 849: spacefree += nep->d_reclen;
! 850: ep->d_ino = 0;
! 851: dsize = 0;
! 852: continue;
! 853: }
! 854: dsize = DIRSIZ(FSFMT(dvp), nep);
! 855: spacefree += nep->d_reclen - dsize;
! 856: #ifdef UFS_DIRHASH
! 857: if (dp->i_dirhash != NULL)
! 858: ufsdirhash_move(dp, nep,
! 859: dp->i_offset + ((char *)nep - dirbuf),
! 860: dp->i_offset + ((char *)ep - dirbuf));
! 861: #endif
! 862: if (DOINGSOFTDEP(dvp))
! 863: softdep_change_directoryentry_offset(dp, dirbuf,
! 864: (caddr_t)nep, (caddr_t)ep, dsize);
! 865: else
! 866: bcopy((caddr_t)nep, (caddr_t)ep, dsize);
! 867: }
! 868: /*
! 869: * Here, `ep' points to a directory entry containing `dsize' in-use
! 870: * bytes followed by `spacefree' unused bytes. If ep->d_ino == 0,
! 871: * then the entry is completely unused (dsize == 0). The value
! 872: * of ep->d_reclen is always indeterminate.
! 873: *
! 874: * Update the pointer fields in the previous entry (if any),
! 875: * copy in the new entry, and write out the block.
! 876: */
! 877: if (ep->d_ino == 0) {
! 878: if (spacefree + dsize < newentrysize)
! 879: panic("ufs_direnter: compact1");
! 880: dirp->d_reclen = spacefree + dsize;
! 881: } else {
! 882: if (spacefree < newentrysize)
! 883: panic("ufs_direnter: compact2");
! 884: dirp->d_reclen = spacefree;
! 885: ep->d_reclen = dsize;
! 886: ep = (struct direct *)((char *)ep + dsize);
! 887: }
! 888:
! 889: #ifdef UFS_DIRHASH
! 890: if (dp->i_dirhash != NULL && (ep->d_ino == 0 ||
! 891: dirp->d_reclen == spacefree))
! 892: ufsdirhash_add(dp, dirp, dp->i_offset + ((char *)ep - dirbuf));
! 893: #endif
! 894: bcopy((caddr_t)dirp, (caddr_t)ep, (u_int)newentrysize);
! 895: #ifdef UFS_DIRHASH
! 896: if (dp->i_dirhash != NULL)
! 897: ufsdirhash_checkblock(dp, dirbuf -
! 898: (dp->i_offset & (DIRBLKSIZ - 1)),
! 899: dp->i_offset & ~(DIRBLKSIZ - 1));
! 900: #endif
! 901:
! 902: if (DOINGSOFTDEP(dvp)) {
! 903: (void)softdep_setup_directory_add(bp, dp,
! 904: dp->i_offset + (caddr_t)ep - dirbuf,
! 905: dirp->d_ino, newdirbp, 0);
! 906: bdwrite(bp);
! 907: } else {
! 908: error = VOP_BWRITE(bp);
! 909: }
! 910: dp->i_flag |= IN_CHANGE | IN_UPDATE;
! 911:
! 912: /*
! 913: * If all went well, and the directory can be shortened, proceed
! 914: * with the truncation. Note that we have to unlock the inode for
! 915: * the entry that we just entered, as the truncation may need to
! 916: * lock other inodes which can lead to deadlock if we also hold a
! 917: * lock on the newly entered node.
! 918: */
! 919:
! 920: if (error == 0 && dp->i_endoff && dp->i_endoff < DIP(dp, size)) {
! 921: if (tvp != NULL)
! 922: VOP_UNLOCK(tvp, 0, p);
! 923: #ifdef UFS_DIRHASH
! 924: if (dp->i_dirhash != NULL)
! 925: ufsdirhash_dirtrunc(dp, dp->i_endoff);
! 926: #endif
! 927:
! 928:
! 929: error = UFS_TRUNCATE(dp, (off_t)dp->i_endoff, IO_SYNC, cr);
! 930:
! 931: if (tvp != NULL)
! 932: vn_lock(tvp, LK_EXCLUSIVE | LK_RETRY, p);
! 933: }
! 934: return (error);
! 935: }
! 936:
! 937: /*
! 938: * Remove a directory entry after a call to namei, using
! 939: * the parameters which it left in nameidata. The entry
! 940: * dp->i_offset contains the offset into the directory of the
! 941: * entry to be eliminated. The dp->i_count field contains the
! 942: * size of the previous record in the directory. If this
! 943: * is 0, the first entry is being deleted, so we need only
! 944: * zero the inode number to mark the entry as free. If the
! 945: * entry is not the first in the directory, we must reclaim
! 946: * the space of the now empty record by adding the record size
! 947: * to the size of the previous entry.
! 948: */
! 949: int
! 950: ufs_dirremove(struct vnode *dvp, struct inode *ip, int flags, int isrmdir)
! 951: {
! 952: struct inode *dp;
! 953: struct direct *ep;
! 954: struct buf *bp;
! 955: int error;
! 956:
! 957: dp = VTOI(dvp);
! 958:
! 959: if ((error = UFS_BUFATOFF(dp,
! 960: (off_t)(dp->i_offset - dp->i_count), (char **)&ep, &bp)) != 0)
! 961: return (error);
! 962: #ifdef UFS_DIRHASH
! 963: /*
! 964: * Remove the dirhash entry. This is complicated by the fact
! 965: * that `ep' is the previous entry when dp->i_count != 0.
! 966: */
! 967: if (dp->i_dirhash != NULL)
! 968: ufsdirhash_remove(dp, (dp->i_count == 0) ? ep :
! 969: (struct direct *)((char *)ep + ep->d_reclen), dp->i_offset);
! 970: #endif
! 971:
! 972: if (dp->i_count == 0) {
! 973: /*
! 974: * First entry in block: set d_ino to zero.
! 975: */
! 976: ep->d_ino = 0;
! 977: } else {
! 978: /*
! 979: * Collapse new free space into previous entry.
! 980: */
! 981: ep->d_reclen += dp->i_reclen;
! 982: }
! 983: #ifdef UFS_DIRHASH
! 984: if (dp->i_dirhash != NULL)
! 985: ufsdirhash_checkblock(dp, (char *)ep -
! 986: ((dp->i_offset - dp->i_count) & (DIRBLKSIZ - 1)),
! 987: dp->i_offset & ~(DIRBLKSIZ - 1));
! 988: #endif
! 989: if (DOINGSOFTDEP(dvp)) {
! 990: if (ip) {
! 991: ip->i_effnlink--;
! 992: softdep_change_linkcnt(ip, 0);
! 993: softdep_setup_remove(bp, dp, ip, isrmdir);
! 994: }
! 995: if (softdep_slowdown(dvp)) {
! 996: error = bwrite(bp);
! 997: } else {
! 998: bdwrite(bp);
! 999: error = 0;
! 1000: }
! 1001: } else {
! 1002: if (ip) {
! 1003: ip->i_effnlink--;
! 1004: DIP_ADD(ip, nlink, -1);
! 1005: ip->i_flag |= IN_CHANGE;
! 1006: }
! 1007: if (DOINGASYNC(dvp) && dp->i_count != 0) {
! 1008: bdwrite(bp);
! 1009: error = 0;
! 1010: } else
! 1011: error = bwrite(bp);
! 1012: }
! 1013: dp->i_flag |= IN_CHANGE | IN_UPDATE;
! 1014: return (error);
! 1015: }
! 1016:
! 1017: /*
! 1018: * Rewrite an existing directory entry to point at the inode
! 1019: * supplied. The parameters describing the directory entry are
! 1020: * set up by a call to namei.
! 1021: */
! 1022: int
! 1023: ufs_dirrewrite(struct inode *dp, struct inode *oip, ino_t newinum, int newtype,
! 1024: int isrmdir)
! 1025: {
! 1026: struct buf *bp;
! 1027: struct direct *ep;
! 1028: struct vnode *vdp = ITOV(dp);
! 1029: int error;
! 1030:
! 1031: error = UFS_BUFATOFF(dp, (off_t)dp->i_offset, (char **)&ep, &bp);
! 1032: if (error)
! 1033: return (error);
! 1034: ep->d_ino = newinum;
! 1035: if (vdp->v_mount->mnt_maxsymlinklen > 0)
! 1036: ep->d_type = newtype;
! 1037: oip->i_effnlink--;
! 1038: if (DOINGSOFTDEP(vdp)) {
! 1039: softdep_change_linkcnt(oip, 0);
! 1040: softdep_setup_directory_change(bp, dp, oip, newinum, isrmdir);
! 1041: bdwrite(bp);
! 1042: } else {
! 1043: DIP_ADD(oip, nlink, -1);
! 1044: oip->i_flag |= IN_CHANGE;
! 1045: if (DOINGASYNC(vdp)) {
! 1046: bdwrite(bp);
! 1047: error = 0;
! 1048: } else {
! 1049: error = VOP_BWRITE(bp);
! 1050: }
! 1051: }
! 1052: dp->i_flag |= IN_CHANGE | IN_UPDATE;
! 1053: return (error);
! 1054: }
! 1055:
! 1056: /*
! 1057: * Check if a directory is empty or not.
! 1058: * Inode supplied must be locked.
! 1059: *
! 1060: * Using a struct dirtemplate here is not precisely
! 1061: * what we want, but better than using a struct direct.
! 1062: *
! 1063: * NB: does not handle corrupted directories.
! 1064: */
! 1065: int
! 1066: ufs_dirempty(struct inode *ip, ino_t parentino, struct ucred *cred)
! 1067: {
! 1068: off_t off, m;
! 1069: struct dirtemplate dbuf;
! 1070: struct direct *dp = (struct direct *)&dbuf;
! 1071: int error, namlen;
! 1072: size_t count;
! 1073: #define MINDIRSIZ (sizeof (struct dirtemplate) / 2)
! 1074:
! 1075: m = DIP(ip, size);
! 1076: for (off = 0; off < m; off += dp->d_reclen) {
! 1077: error = vn_rdwr(UIO_READ, ITOV(ip), (caddr_t)dp, MINDIRSIZ, off,
! 1078: UIO_SYSSPACE, IO_NODELOCKED, cred, &count, (struct proc *)0);
! 1079: /*
! 1080: * Since we read MINDIRSIZ, residual must
! 1081: * be 0 unless we're at end of file.
! 1082: */
! 1083: if (error || count != 0)
! 1084: return (0);
! 1085: /* avoid infinite loops */
! 1086: if (dp->d_reclen == 0)
! 1087: return (0);
! 1088: /* skip empty entries */
! 1089: if (dp->d_ino == 0)
! 1090: continue;
! 1091: /* accept only "." and ".." */
! 1092: # if (BYTE_ORDER == LITTLE_ENDIAN)
! 1093: if (ITOV(ip)->v_mount->mnt_maxsymlinklen > 0)
! 1094: namlen = dp->d_namlen;
! 1095: else
! 1096: namlen = dp->d_type;
! 1097: # else
! 1098: namlen = dp->d_namlen;
! 1099: # endif
! 1100: if (namlen > 2)
! 1101: return (0);
! 1102: if (dp->d_name[0] != '.')
! 1103: return (0);
! 1104: /*
! 1105: * At this point namlen must be 1 or 2.
! 1106: * 1 implies ".", 2 implies ".." if second
! 1107: * char is also "."
! 1108: */
! 1109: if (namlen == 1 && dp->d_ino == ip->i_number)
! 1110: continue;
! 1111: if (dp->d_name[1] == '.' && dp->d_ino == parentino)
! 1112: continue;
! 1113: return (0);
! 1114: }
! 1115: return (1);
! 1116: }
! 1117:
! 1118: /*
! 1119: * Check if source directory is in the path of the target directory.
! 1120: * Target is supplied locked, source is unlocked.
! 1121: * The target is always vput before returning.
! 1122: */
! 1123: int
! 1124: ufs_checkpath(struct inode *source, struct inode *target, struct ucred *cred)
! 1125: {
! 1126: struct vnode *vp;
! 1127: int error, rootino, namlen;
! 1128: struct dirtemplate dirbuf;
! 1129:
! 1130: vp = ITOV(target);
! 1131: if (target->i_number == source->i_number) {
! 1132: error = EEXIST;
! 1133: goto out;
! 1134: }
! 1135: rootino = ROOTINO;
! 1136: error = 0;
! 1137: if (target->i_number == rootino)
! 1138: goto out;
! 1139:
! 1140: for (;;) {
! 1141: if (vp->v_type != VDIR) {
! 1142: error = ENOTDIR;
! 1143: break;
! 1144: }
! 1145: error = vn_rdwr(UIO_READ, vp, (caddr_t)&dirbuf,
! 1146: sizeof (struct dirtemplate), (off_t)0, UIO_SYSSPACE,
! 1147: IO_NODELOCKED, cred, NULL, (struct proc *)0);
! 1148: if (error != 0)
! 1149: break;
! 1150: # if (BYTE_ORDER == LITTLE_ENDIAN)
! 1151: if (vp->v_mount->mnt_maxsymlinklen > 0)
! 1152: namlen = dirbuf.dotdot_namlen;
! 1153: else
! 1154: namlen = dirbuf.dotdot_type;
! 1155: # else
! 1156: namlen = dirbuf.dotdot_namlen;
! 1157: # endif
! 1158: if (namlen != 2 ||
! 1159: dirbuf.dotdot_name[0] != '.' ||
! 1160: dirbuf.dotdot_name[1] != '.') {
! 1161: error = ENOTDIR;
! 1162: break;
! 1163: }
! 1164: if (dirbuf.dotdot_ino == source->i_number) {
! 1165: error = EINVAL;
! 1166: break;
! 1167: }
! 1168: if (dirbuf.dotdot_ino == rootino)
! 1169: break;
! 1170: vput(vp);
! 1171: error = VFS_VGET(vp->v_mount, dirbuf.dotdot_ino, &vp);
! 1172: if (error) {
! 1173: vp = NULL;
! 1174: break;
! 1175: }
! 1176: }
! 1177:
! 1178: out:
! 1179: if (error == ENOTDIR)
! 1180: printf("checkpath: .. not a directory\n");
! 1181: if (vp != NULL)
! 1182: vput(vp);
! 1183: return (error);
! 1184: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ufs_lookup.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / ufs / ufs