Annotation of sys/ufs/ext2fs/ext2fs_lookup.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: ext2fs_lookup.c,v 1.23 2007/06/17 20:15:25 jasper Exp $ */
! 2: /* $NetBSD: ext2fs_lookup.c,v 1.16 2000/08/03 20:29:26 thorpej Exp $ */
! 3:
! 4: /*
! 5: * Modified for NetBSD 1.2E
! 6: * May 1997, Manuel Bouyer
! 7: * Laboratoire d'informatique de Paris VI
! 8: */
! 9: /*
! 10: * modified for Lites 1.1
! 11: *
! 12: * Aug 1995, Godmar Back (gback@cs.utah.edu)
! 13: * University of Utah, Department of Computer Science
! 14: */
! 15: /*
! 16: * Copyright (c) 1989, 1993
! 17: * The Regents of the University of California. All rights reserved.
! 18: * (c) UNIX System Laboratories, Inc.
! 19: * All or some portions of this file are derived from material licensed
! 20: * to the University of California by American Telephone and Telegraph
! 21: * Co. or Unix System Laboratories, Inc. and are reproduced herein with
! 22: * the permission of UNIX System Laboratories, Inc.
! 23: *
! 24: * Redistribution and use in source and binary forms, with or without
! 25: * modification, are permitted provided that the following conditions
! 26: * are met:
! 27: * 1. Redistributions of source code must retain the above copyright
! 28: * notice, this list of conditions and the following disclaimer.
! 29: * 2. Redistributions in binary form must reproduce the above copyright
! 30: * notice, this list of conditions and the following disclaimer in the
! 31: * documentation and/or other materials provided with the distribution.
! 32: * 3. Neither the name of the University nor the names of its contributors
! 33: * may be used to endorse or promote products derived from this software
! 34: * without specific prior written permission.
! 35: *
! 36: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 37: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 38: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 39: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 40: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 41: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 42: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 43: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 44: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 45: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 46: * SUCH DAMAGE.
! 47: *
! 48: * @(#)ufs_lookup.c 8.6 (Berkeley) 4/1/94
! 49: */
! 50:
! 51: #include <sys/param.h>
! 52: #include <sys/systm.h>
! 53: #include <sys/namei.h>
! 54: #include <sys/buf.h>
! 55: #include <sys/file.h>
! 56: #include <sys/mount.h>
! 57: #include <sys/vnode.h>
! 58: #include <sys/malloc.h>
! 59: #include <sys/dirent.h>
! 60:
! 61: #include <ufs/ufs/quota.h>
! 62: #include <ufs/ufs/inode.h>
! 63: #include <ufs/ufs/ufsmount.h>
! 64: #include <ufs/ufs/ufs_extern.h>
! 65:
! 66: #include <ufs/ext2fs/ext2fs_extern.h>
! 67: #include <ufs/ext2fs/ext2fs_dir.h>
! 68: #include <ufs/ext2fs/ext2fs.h>
! 69:
! 70: extern int dirchk;
! 71:
! 72: static void ext2fs_dirconv2ffs(struct ext2fs_direct *e2dir,
! 73: struct dirent *ffsdir);
! 74: static int ext2fs_dirbadentry(struct vnode *dp,
! 75: struct ext2fs_direct *de,
! 76: int entryoffsetinblock);
! 77:
! 78: /*
! 79: * the problem that is tackled below is the fact that FFS
! 80: * includes the terminating zero on disk while EXT2FS doesn't
! 81: * this implies that we need to introduce some padding.
! 82: * For instance, a filename "sbin" has normally a reclen 12
! 83: * in EXT2, but 16 in FFS.
! 84: * This reminds me of that Pepsi commercial: 'Kid saved a lousy nine cents...'
! 85: * If it wasn't for that, the complete ufs code for directories would
! 86: * have worked w/o changes (except for the difference in DIRBLKSIZ)
! 87: */
! 88: static void
! 89: ext2fs_dirconv2ffs(struct ext2fs_direct *e2dir, struct dirent *ffsdir)
! 90: {
! 91: memset(ffsdir, 0, sizeof(struct dirent));
! 92: ffsdir->d_fileno = fs2h32(e2dir->e2d_ino);
! 93: ffsdir->d_namlen = e2dir->e2d_namlen;
! 94:
! 95: ffsdir->d_type = DT_UNKNOWN; /* don't know more here */
! 96: #ifdef DIAGNOSTIC
! 97: /*
! 98: * XXX Rigth now this can't happen, but if one day
! 99: * MAXNAMLEN != E2FS_MAXNAMLEN we should handle this more gracefully !
! 100: */
! 101: /* XXX: e2d_namlen is to small for such comparison
! 102: if (e2dir->e2d_namlen > MAXNAMLEN)
! 103: panic("ext2fs: e2dir->e2d_namlen");
! 104: */
! 105: #endif
! 106: strncpy(ffsdir->d_name, e2dir->e2d_name, ffsdir->d_namlen);
! 107:
! 108: /* Godmar thinks: since e2dir->e2d_reclen can be big and means
! 109: nothing anyway, we compute our own reclen according to what
! 110: we think is right
! 111: */
! 112: ffsdir->d_reclen = DIRENT_SIZE(ffsdir);
! 113: }
! 114:
! 115: /*
! 116: * Vnode op for reading directories.
! 117: *
! 118: * Convert the on-disk entries to <sys/dirent.h> entries.
! 119: * the problem is that the conversion will blow up some entries by four bytes,
! 120: * so it can't be done in place. This is too bad. Right now the conversion is
! 121: * done entry by entry, the converted entry is sent via uiomove.
! 122: *
! 123: * XXX allocate a buffer, convert as many entries as possible, then send
! 124: * the whole buffer to uiomove
! 125: */
! 126: int
! 127: ext2fs_readdir(void *v)
! 128: {
! 129: struct vop_readdir_args *ap = v;
! 130: struct uio *uio = ap->a_uio;
! 131: int error;
! 132: size_t e2fs_count, readcnt, entries;
! 133: struct vnode *vp = ap->a_vp;
! 134: struct m_ext2fs *fs = VTOI(vp)->i_e2fs;
! 135:
! 136: struct ext2fs_direct *dp;
! 137: struct dirent dstd;
! 138: struct uio auio;
! 139: struct iovec aiov;
! 140: caddr_t dirbuf;
! 141: off_t off = uio->uio_offset;
! 142: u_long *cookies = NULL;
! 143: int nc = 0, ncookies = 0;
! 144: int e2d_reclen;
! 145:
! 146: if (vp->v_type != VDIR)
! 147: return (ENOTDIR);
! 148:
! 149: e2fs_count = uio->uio_resid;
! 150: entries = (uio->uio_offset + e2fs_count) & (fs->e2fs_bsize - 1);
! 151:
! 152: /* Make sure we don't return partial entries. */
! 153: if (e2fs_count <= entries)
! 154: return (EINVAL);
! 155:
! 156: e2fs_count -= entries;
! 157: auio = *uio;
! 158: auio.uio_iov = &aiov;
! 159: auio.uio_iovcnt = 1;
! 160: auio.uio_segflg = UIO_SYSSPACE;
! 161: aiov.iov_len = e2fs_count;
! 162: auio.uio_resid = e2fs_count;
! 163: MALLOC(dirbuf, caddr_t, e2fs_count, M_TEMP, M_WAITOK);
! 164: if (ap->a_ncookies) {
! 165: nc = ncookies = e2fs_count / 16;
! 166: cookies = malloc(sizeof (off_t) * ncookies, M_TEMP, M_WAITOK);
! 167: *ap->a_cookies = cookies;
! 168: }
! 169: memset(dirbuf, 0, e2fs_count);
! 170: aiov.iov_base = dirbuf;
! 171:
! 172: error = VOP_READ(ap->a_vp, &auio, 0, ap->a_cred);
! 173: if (error == 0) {
! 174: readcnt = e2fs_count - auio.uio_resid;
! 175: for (dp = (struct ext2fs_direct *)dirbuf;
! 176: (char *)dp < (char *)dirbuf + readcnt; ) {
! 177: e2d_reclen = fs2h16(dp->e2d_reclen);
! 178: if (e2d_reclen == 0) {
! 179: error = EIO;
! 180: break;
! 181: }
! 182: ext2fs_dirconv2ffs(dp, &dstd);
! 183: if(dstd.d_reclen > uio->uio_resid) {
! 184: break;
! 185: }
! 186: if ((error = uiomove((caddr_t)&dstd, dstd.d_reclen, uio)) != 0) {
! 187: break;
! 188: }
! 189: off = off + e2d_reclen;
! 190: if (cookies != NULL) {
! 191: *cookies++ = off;
! 192: if (--ncookies <= 0){
! 193: break; /* out of cookies */
! 194: }
! 195: }
! 196: /* advance dp */
! 197: dp = (struct ext2fs_direct *) ((char *)dp + e2d_reclen);
! 198: }
! 199: /* we need to correct uio_offset */
! 200: uio->uio_offset = off;
! 201: }
! 202: FREE(dirbuf, M_TEMP);
! 203: *ap->a_eofflag = ext2fs_size(VTOI(ap->a_vp)) <= uio->uio_offset;
! 204: if (ap->a_ncookies) {
! 205: if (error) {
! 206: free(*ap->a_cookies, M_TEMP);
! 207: *ap->a_ncookies = 0;
! 208: *ap->a_cookies = NULL;
! 209: } else
! 210: *ap->a_ncookies = nc - ncookies;
! 211: }
! 212: return (error);
! 213: }
! 214:
! 215: /*
! 216: * Convert a component of a pathname into a pointer to a locked inode.
! 217: * This is a very central and rather complicated routine.
! 218: * If the file system is not maintained in a strict tree hierarchy,
! 219: * this can result in a deadlock situation (see comments in code below).
! 220: *
! 221: * The cnp->cn_nameiop argument is LOOKUP, CREATE, RENAME, or DELETE depending
! 222: * on whether the name is to be looked up, created, renamed, or deleted.
! 223: * When CREATE, RENAME, or DELETE is specified, information usable in
! 224: * creating, renaming, or deleting a directory entry may be calculated.
! 225: * If flag has LOCKPARENT or'ed into it and the target of the pathname
! 226: * exists, lookup returns both the target and its parent directory locked.
! 227: * When creating or renaming and LOCKPARENT is specified, the target may
! 228: * not be ".". When deleting and LOCKPARENT is specified, the target may
! 229: * be "."., but the caller must check to ensure it does an vrele and vput
! 230: * instead of two vputs.
! 231: *
! 232: * Overall outline of ext2fs_lookup:
! 233: *
! 234: * check accessibility of directory
! 235: * look for name in cache, if found, then if at end of path
! 236: * and deleting or creating, drop it, else return name
! 237: * search for name in directory, to found or notfound
! 238: * notfound:
! 239: * if creating, return locked directory, leaving info on available slots
! 240: * else return error
! 241: * found:
! 242: * if at end of path and deleting, return information to allow delete
! 243: * if at end of path and rewriting (RENAME and LOCKPARENT), lock target
! 244: * inode and return info to allow rewrite
! 245: * if not at end, add name to cache; if at end and neither creating
! 246: * nor deleting, add name to cache
! 247: */
! 248: int
! 249: ext2fs_lookup(void *v)
! 250: {
! 251: struct vop_lookup_args *ap = v;
! 252: struct vnode *vdp; /* vnode for directory being searched */
! 253: struct inode *dp; /* inode for directory being searched */
! 254: struct buf *bp; /* a buffer of directory entries */
! 255: struct ext2fs_direct *ep; /* the current directory entry */
! 256: int entryoffsetinblock; /* offset of ep in bp's buffer */
! 257: enum {NONE, COMPACT, FOUND} slotstatus;
! 258: doff_t slotoffset; /* offset of area with free space */
! 259: int slotsize; /* size of area at slotoffset */
! 260: int slotfreespace; /* amount of space free in slot */
! 261: int slotneeded; /* size of the entry we're seeking */
! 262: int numdirpasses; /* strategy for directory search */
! 263: doff_t endsearch; /* offset to end directory search */
! 264: doff_t prevoff; /* prev entry dp->i_offset */
! 265: struct vnode *pdp; /* saved dp during symlink work */
! 266: struct vnode *tdp; /* returned by VFS_VGET */
! 267: doff_t enduseful; /* pointer past last used dir slot */
! 268: u_long bmask; /* block offset mask */
! 269: int lockparent; /* 1 => lockparent flag is set */
! 270: int wantparent; /* 1 => wantparent or lockparent flag */
! 271: int namlen, error;
! 272: struct vnode **vpp = ap->a_vpp;
! 273: struct componentname *cnp = ap->a_cnp;
! 274: struct ucred *cred = cnp->cn_cred;
! 275: int flags = cnp->cn_flags;
! 276: int nameiop = cnp->cn_nameiop;
! 277: struct proc *p = cnp->cn_proc;
! 278: int dirblksize = VTOI(ap->a_dvp)->i_e2fs->e2fs_bsize;
! 279:
! 280: bp = NULL;
! 281: slotoffset = -1;
! 282: *vpp = NULL;
! 283: vdp = ap->a_dvp;
! 284: dp = VTOI(vdp);
! 285: lockparent = flags & LOCKPARENT;
! 286: wantparent = flags & (LOCKPARENT|WANTPARENT);
! 287: /*
! 288: * Check accessiblity of directory.
! 289: */
! 290: if ((error = VOP_ACCESS(vdp, VEXEC, cred, cnp->cn_proc)) != 0)
! 291: return (error);
! 292:
! 293: if ((flags & ISLASTCN) && (vdp->v_mount->mnt_flag & MNT_RDONLY) &&
! 294: (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
! 295: return (EROFS);
! 296:
! 297: /*
! 298: * We now have a segment name to search for, and a directory to search.
! 299: *
! 300: * Before tediously performing a linear scan of the directory,
! 301: * check the name cache to see if the directory/name pair
! 302: * we are looking for is known already.
! 303: */
! 304: if ((error = cache_lookup(vdp, vpp, cnp)) >= 0)
! 305: return (error);
! 306:
! 307: /*
! 308: * Suppress search for slots unless creating
! 309: * file and at end of pathname, in which case
! 310: * we watch for a place to put the new file in
! 311: * case it doesn't already exist.
! 312: */
! 313: slotstatus = FOUND;
! 314: slotfreespace = slotsize = slotneeded = 0;
! 315: if ((nameiop == CREATE || nameiop == RENAME) &&
! 316: (flags & ISLASTCN)) {
! 317: slotstatus = NONE;
! 318: slotneeded = EXT2FS_DIRSIZ(cnp->cn_namelen);
! 319: }
! 320:
! 321: /*
! 322: * If there is cached information on a previous search of
! 323: * this directory, pick up where we last left off.
! 324: * We cache only lookups as these are the most common
! 325: * and have the greatest payoff. Caching CREATE has little
! 326: * benefit as it usually must search the entire directory
! 327: * to determine that the entry does not exist. Caching the
! 328: * location of the last DELETE or RENAME has not reduced
! 329: * profiling time and hence has been removed in the interest
! 330: * of simplicity.
! 331: */
! 332: bmask = VFSTOUFS(vdp->v_mount)->um_mountp->mnt_stat.f_iosize - 1;
! 333: if (nameiop != LOOKUP || dp->i_diroff == 0 ||
! 334: dp->i_diroff >ext2fs_size(dp)) {
! 335: entryoffsetinblock = 0;
! 336: dp->i_offset = 0;
! 337: numdirpasses = 1;
! 338: } else {
! 339: dp->i_offset = dp->i_diroff;
! 340: if ((entryoffsetinblock = dp->i_offset & bmask) &&
! 341: (error = ext2fs_bufatoff(dp, (off_t)dp->i_offset,
! 342: NULL, &bp)))
! 343: return (error);
! 344: numdirpasses = 2;
! 345: }
! 346: prevoff = dp->i_offset;
! 347: endsearch = roundup(ext2fs_size(dp), dirblksize);
! 348: enduseful = 0;
! 349:
! 350: searchloop:
! 351: while (dp->i_offset < endsearch) {
! 352: /*
! 353: * If necessary, get the next directory block.
! 354: */
! 355: if ((dp->i_offset & bmask) == 0) {
! 356: if (bp != NULL)
! 357: brelse(bp);
! 358: error = ext2fs_bufatoff(dp, (off_t)dp->i_offset,
! 359: NULL, &bp);
! 360: if (error != 0)
! 361: return (error);
! 362: entryoffsetinblock = 0;
! 363: }
! 364: /*
! 365: * If still looking for a slot, and at a dirblksize
! 366: * boundary, have to start looking for free space again.
! 367: */
! 368: if (slotstatus == NONE &&
! 369: (entryoffsetinblock & (dirblksize - 1)) == 0) {
! 370: slotoffset = -1;
! 371: slotfreespace = 0;
! 372: }
! 373: /*
! 374: * Get pointer to next entry.
! 375: * Full validation checks are slow, so we only check
! 376: * enough to insure forward progress through the
! 377: * directory. Complete checks can be run by patching
! 378: * "dirchk" to be true.
! 379: */
! 380: ep = (struct ext2fs_direct *)
! 381: ((char *)bp->b_data + entryoffsetinblock);
! 382: if (ep->e2d_reclen == 0 ||
! 383: (dirchk &&
! 384: ext2fs_dirbadentry(vdp, ep, entryoffsetinblock))) {
! 385: int i;
! 386: ufs_dirbad(dp, dp->i_offset, "mangled entry");
! 387: i = dirblksize -
! 388: (entryoffsetinblock & (dirblksize - 1));
! 389: dp->i_offset += i;
! 390: entryoffsetinblock += i;
! 391: continue;
! 392: }
! 393:
! 394: /*
! 395: * If an appropriate sized slot has not yet been found,
! 396: * check to see if one is available. Also accumulate space
! 397: * in the current block so that we can determine if
! 398: * compaction is viable.
! 399: */
! 400: if (slotstatus != FOUND) {
! 401: int size = fs2h16(ep->e2d_reclen);
! 402:
! 403: if (ep->e2d_ino != 0)
! 404: size -= EXT2FS_DIRSIZ(ep->e2d_namlen);
! 405: if (size > 0) {
! 406: if (size >= slotneeded) {
! 407: slotstatus = FOUND;
! 408: slotoffset = dp->i_offset;
! 409: slotsize = fs2h16(ep->e2d_reclen);
! 410: } else if (slotstatus == NONE) {
! 411: slotfreespace += size;
! 412: if (slotoffset == -1)
! 413: slotoffset = dp->i_offset;
! 414: if (slotfreespace >= slotneeded) {
! 415: slotstatus = COMPACT;
! 416: slotsize = dp->i_offset +
! 417: fs2h16(ep->e2d_reclen) - slotoffset;
! 418: }
! 419: }
! 420: }
! 421: }
! 422:
! 423: /*
! 424: * Check for a name match.
! 425: */
! 426: if (ep->e2d_ino) {
! 427: namlen = ep->e2d_namlen;
! 428: if (namlen == cnp->cn_namelen &&
! 429: !memcmp(cnp->cn_nameptr, ep->e2d_name,
! 430: (unsigned)namlen)) {
! 431: /*
! 432: * Save directory entry's inode number and
! 433: * reclen in ndp->ni_ufs area, and release
! 434: * directory buffer.
! 435: */
! 436: dp->i_ino = fs2h32(ep->e2d_ino);
! 437: dp->i_reclen = fs2h16(ep->e2d_reclen);
! 438: brelse(bp);
! 439: goto found;
! 440: }
! 441: }
! 442: prevoff = dp->i_offset;
! 443: dp->i_offset += fs2h16(ep->e2d_reclen);
! 444: entryoffsetinblock += fs2h16(ep->e2d_reclen);
! 445: if (ep->e2d_ino)
! 446: enduseful = dp->i_offset;
! 447: }
! 448: /* notfound: */
! 449: /*
! 450: * If we started in the middle of the directory and failed
! 451: * to find our target, we must check the beginning as well.
! 452: */
! 453: if (numdirpasses == 2) {
! 454: numdirpasses--;
! 455: dp->i_offset = 0;
! 456: endsearch = dp->i_diroff;
! 457: goto searchloop;
! 458: }
! 459: if (bp != NULL)
! 460: brelse(bp);
! 461: /*
! 462: * If creating, and at end of pathname and current
! 463: * directory has not been removed, then can consider
! 464: * allowing file to be created.
! 465: */
! 466: if ((nameiop == CREATE || nameiop == RENAME) &&
! 467: (flags & ISLASTCN) && dp->i_e2fs_nlink != 0) {
! 468: /*
! 469: * Creation of files on a read-only mounted file system
! 470: * is pointless, so don't proceed any further.
! 471: */
! 472: if (vdp->v_mount->mnt_flag & MNT_RDONLY)
! 473: return (EROFS);
! 474: /*
! 475: * Access for write is interpreted as allowing
! 476: * creation of files in the directory.
! 477: */
! 478: if ((error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_proc)) != 0)
! 479: return (error);
! 480: /*
! 481: * Return an indication of where the new directory
! 482: * entry should be put. If we didn't find a slot,
! 483: * then set dp->i_count to 0 indicating
! 484: * that the new slot belongs at the end of the
! 485: * directory. If we found a slot, then the new entry
! 486: * can be put in the range from dp->i_offset to
! 487: * dp->i_offset + dp->i_count.
! 488: */
! 489: if (slotstatus == NONE) {
! 490: dp->i_offset = roundup(ext2fs_size(dp), dirblksize);
! 491: dp->i_count = 0;
! 492: enduseful = dp->i_offset;
! 493: } else {
! 494: dp->i_offset = slotoffset;
! 495: dp->i_count = slotsize;
! 496: if (enduseful < slotoffset + slotsize)
! 497: enduseful = slotoffset + slotsize;
! 498: }
! 499: dp->i_endoff = roundup(enduseful, dirblksize);
! 500: dp->i_flag |= IN_CHANGE | IN_UPDATE;
! 501: /*
! 502: * We return with the directory locked, so that
! 503: * the parameters we set up above will still be
! 504: * valid if we actually decide to do a direnter().
! 505: * We return ni_vp == NULL to indicate that the entry
! 506: * does not currently exist; we leave a pointer to
! 507: * the (locked) directory inode in ndp->ni_dvp.
! 508: * The pathname buffer is saved so that the name
! 509: * can be obtained later.
! 510: *
! 511: * NB - if the directory is unlocked, then this
! 512: * information cannot be used.
! 513: */
! 514: cnp->cn_flags |= SAVENAME;
! 515: if (!lockparent) {
! 516: VOP_UNLOCK(vdp, 0, p);
! 517: cnp->cn_flags |= PDIRUNLOCK;
! 518: }
! 519: return (EJUSTRETURN);
! 520: }
! 521: /*
! 522: * Insert name into cache (as non-existent) if appropriate.
! 523: */
! 524: if ((cnp->cn_flags & MAKEENTRY) && nameiop != CREATE)
! 525: cache_enter(vdp, *vpp, cnp);
! 526: return (ENOENT);
! 527:
! 528: found:
! 529: /*
! 530: * Check that directory length properly reflects presence
! 531: * of this entry.
! 532: */
! 533: if (entryoffsetinblock + EXT2FS_DIRSIZ(ep->e2d_namlen)
! 534: > ext2fs_size(dp)) {
! 535: ufs_dirbad(dp, dp->i_offset, "i_size too small");
! 536: error = ext2fs_setsize(dp,
! 537: entryoffsetinblock + EXT2FS_DIRSIZ(ep->e2d_namlen));
! 538: if (error) {
! 539: brelse(bp);
! 540: return(error);
! 541: }
! 542: dp->i_flag |= IN_CHANGE | IN_UPDATE;
! 543: }
! 544:
! 545: /*
! 546: * Found component in pathname.
! 547: * If the final component of path name, save information
! 548: * in the cache as to where the entry was found.
! 549: */
! 550: if ((flags & ISLASTCN) && nameiop == LOOKUP)
! 551: dp->i_diroff = dp->i_offset &~ (dirblksize - 1);
! 552:
! 553: /*
! 554: * If deleting, and at end of pathname, return
! 555: * parameters which can be used to remove file.
! 556: * If the wantparent flag isn't set, we return only
! 557: * the directory (in ndp->ni_dvp), otherwise we go
! 558: * on and lock the inode, being careful with ".".
! 559: */
! 560: if (nameiop == DELETE && (flags & ISLASTCN)) {
! 561: /*
! 562: * Write access to directory required to delete files.
! 563: */
! 564: if ((error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_proc)) != 0)
! 565: return (error);
! 566: /*
! 567: * Return pointer to current entry in dp->i_offset,
! 568: * and distance past previous entry (if there
! 569: * is a previous entry in this block) in dp->i_count.
! 570: * Save directory inode pointer in ndp->ni_dvp for dirremove().
! 571: */
! 572: if ((dp->i_offset & (dirblksize - 1)) == 0)
! 573: dp->i_count = 0;
! 574: else
! 575: dp->i_count = dp->i_offset - prevoff;
! 576: if (dp->i_number == dp->i_ino) {
! 577: VREF(vdp);
! 578: *vpp = vdp;
! 579: return (0);
! 580: }
! 581: if ((error = VFS_VGET(vdp->v_mount, dp->i_ino, &tdp)) != 0)
! 582: return (error);
! 583: /*
! 584: * If directory is "sticky", then user must own
! 585: * the directory, or the file in it, else she
! 586: * may not delete it (unless she's root). This
! 587: * implements append-only directories.
! 588: */
! 589: if ((dp->i_e2fs_mode & ISVTX) &&
! 590: cred->cr_uid != 0 &&
! 591: cred->cr_uid != dp->i_e2fs_uid &&
! 592: VTOI(tdp)->i_e2fs_uid != cred->cr_uid) {
! 593: vput(tdp);
! 594: return (EPERM);
! 595: }
! 596: *vpp = tdp;
! 597: if (!lockparent) {
! 598: VOP_UNLOCK(vdp, 0, p);
! 599: cnp->cn_flags |= PDIRUNLOCK;
! 600: }
! 601: return (0);
! 602: }
! 603:
! 604: /*
! 605: * If rewriting (RENAME), return the inode and the
! 606: * information required to rewrite the present directory
! 607: * Must get inode of directory entry to verify it's a
! 608: * regular file, or empty directory.
! 609: */
! 610: if (nameiop == RENAME && wantparent &&
! 611: (flags & ISLASTCN)) {
! 612: if ((error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_proc)) != 0)
! 613: return (error);
! 614: /*
! 615: * Careful about locking second inode.
! 616: * This can only occur if the target is ".".
! 617: */
! 618: if (dp->i_number == dp->i_ino)
! 619: return (EISDIR);
! 620: if ((error = VFS_VGET(vdp->v_mount, dp->i_ino, &tdp)) != 0)
! 621: return (error);
! 622: *vpp = tdp;
! 623: cnp->cn_flags |= SAVENAME;
! 624: if (!lockparent) {
! 625: VOP_UNLOCK(vdp, 0, p);
! 626: cnp->cn_flags |= PDIRUNLOCK;
! 627: }
! 628: return (0);
! 629: }
! 630:
! 631: /*
! 632: * Step through the translation in the name. We do not `vput' the
! 633: * directory because we may need it again if a symbolic link
! 634: * is relative to the current directory. Instead we save it
! 635: * unlocked as "pdp". We must get the target inode before unlocking
! 636: * the directory to insure that the inode will not be removed
! 637: * before we get it. We prevent deadlock by always fetching
! 638: * inodes from the root, moving down the directory tree. Thus
! 639: * when following backward pointers ".." we must unlock the
! 640: * parent directory before getting the requested directory.
! 641: * There is a potential race condition here if both the current
! 642: * and parent directories are removed before the VFS_VGET for the
! 643: * inode associated with ".." returns. We hope that this occurs
! 644: * infrequently since we cannot avoid this race condition without
! 645: * implementing a sophisticated deadlock detection algorithm.
! 646: * Note also that this simple deadlock detection scheme will not
! 647: * work if the file system has any hard links other than ".."
! 648: * that point backwards in the directory structure.
! 649: */
! 650: pdp = vdp;
! 651: if (flags & ISDOTDOT) {
! 652: VOP_UNLOCK(pdp, 0, p); /* race to get the inode */
! 653: cnp->cn_flags |= PDIRUNLOCK;
! 654: if ((error = VFS_VGET(vdp->v_mount, dp->i_ino, &tdp)) != 0) {
! 655: if (vn_lock(pdp, LK_EXCLUSIVE | LK_RETRY, p) == 0)
! 656: cnp->cn_flags &= ~PDIRUNLOCK;
! 657: return (error);
! 658: }
! 659: if (lockparent && (flags & ISLASTCN)) {
! 660: if ((error = vn_lock(pdp, LK_EXCLUSIVE, p)) != 0) {
! 661: vput(tdp);
! 662: return (error);
! 663: }
! 664: cnp->cn_flags &= ~PDIRUNLOCK;
! 665: }
! 666: *vpp = tdp;
! 667: } else if (dp->i_number == dp->i_ino) {
! 668: VREF(vdp); /* we want ourself, ie "." */
! 669: *vpp = vdp;
! 670: } else {
! 671: if ((error = VFS_VGET(vdp->v_mount, dp->i_ino, &tdp)) != 0)
! 672: return (error);
! 673: if (!lockparent || !(flags & ISLASTCN)) {
! 674: VOP_UNLOCK(pdp, 0, p);
! 675: cnp->cn_flags |= PDIRUNLOCK;
! 676: }
! 677: *vpp = tdp;
! 678: }
! 679:
! 680: /*
! 681: * Insert name into cache if appropriate.
! 682: */
! 683: if (cnp->cn_flags & MAKEENTRY)
! 684: cache_enter(vdp, *vpp, cnp);
! 685: return (0);
! 686: }
! 687:
! 688: /*
! 689: * Do consistency checking on a directory entry:
! 690: * record length must be multiple of 4
! 691: * entry must fit in rest of its dirblksize block
! 692: * record must be large enough to contain entry
! 693: * name is not longer than MAXNAMLEN
! 694: * name must be as long as advertised, and null terminated
! 695: */
! 696: /*
! 697: * changed so that it confirms to ext2fs_check_dir_entry
! 698: */
! 699: static int
! 700: ext2fs_dirbadentry(struct vnode *dp, struct ext2fs_direct *de,
! 701: int entryoffsetinblock)
! 702: {
! 703: int dirblksize = VTOI(dp)->i_e2fs->e2fs_bsize;
! 704:
! 705: char * error_msg = NULL;
! 706: int reclen = fs2h16(de->e2d_reclen);
! 707: int namlen = de->e2d_namlen;
! 708:
! 709: if (reclen < EXT2FS_DIRSIZ(1)) /* e2d_namlen = 1 */
! 710: error_msg = "rec_len is smaller than minimal";
! 711: else if (reclen % 4 != 0)
! 712: error_msg = "rec_len % 4 != 0";
! 713: else if (reclen < EXT2FS_DIRSIZ(namlen))
! 714: error_msg = "reclen is too small for name_len";
! 715: else if (entryoffsetinblock + reclen > dirblksize)
! 716: error_msg = "directory entry across blocks";
! 717: else if (fs2h32(de->e2d_ino) >
! 718: VTOI(dp)->i_e2fs->e2fs.e2fs_icount)
! 719: error_msg = "inode out of bounds";
! 720:
! 721: if (error_msg != NULL) {
! 722: printf( "bad directory entry: %s\n"
! 723: "offset=%d, inode=%lu, rec_len=%d, name_len=%d \n",
! 724: error_msg, entryoffsetinblock,
! 725: (unsigned long) fs2h32(de->e2d_ino),
! 726: reclen, namlen);
! 727: panic("ext2fs_dirbadentry");
! 728: }
! 729: return error_msg == NULL ? 0 : 1;
! 730: }
! 731:
! 732: /*
! 733: * Write a directory entry after a call to namei, using the parameters
! 734: * that it left in nameidata. The argument ip is the inode which the new
! 735: * directory entry will refer to. Dvp is a pointer to the directory to
! 736: * be written, which was left locked by namei. Remaining parameters
! 737: * (dp->i_offset, dp->i_count) indicate how the space for the new
! 738: * entry is to be obtained.
! 739: */
! 740: int
! 741: ext2fs_direnter(struct inode *ip, struct vnode *dvp,
! 742: struct componentname *cnp)
! 743: {
! 744: struct ext2fs_direct *ep, *nep;
! 745: struct inode *dp;
! 746: struct buf *bp;
! 747: struct ext2fs_direct newdir;
! 748: struct iovec aiov;
! 749: struct uio auio;
! 750: u_int dsize;
! 751: int error, loc, newentrysize, spacefree;
! 752: char *dirbuf;
! 753: int dirblksize = ip->i_e2fs->e2fs_bsize;
! 754:
! 755:
! 756: #ifdef DIAGNOSTIC
! 757: if ((cnp->cn_flags & SAVENAME) == 0)
! 758: panic("direnter: missing name");
! 759: #endif
! 760: dp = VTOI(dvp);
! 761: newdir.e2d_ino = h2fs32(ip->i_number);
! 762: newdir.e2d_namlen = cnp->cn_namelen;
! 763: if (ip->i_e2fs->e2fs.e2fs_rev > E2FS_REV0 &&
! 764: (ip->i_e2fs->e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE)) {
! 765: newdir.e2d_type = inot2ext2dt(IFTODT(ip->i_e2fs_mode));
! 766: } else {
! 767: newdir.e2d_type = 0;
! 768: };
! 769: memcpy(newdir.e2d_name, cnp->cn_nameptr, (unsigned)cnp->cn_namelen + 1);
! 770: newentrysize = EXT2FS_DIRSIZ(cnp->cn_namelen);
! 771: if (dp->i_count == 0) {
! 772: /*
! 773: * If dp->i_count is 0, then namei could find no
! 774: * space in the directory. Here, dp->i_offset will
! 775: * be on a directory block boundary and we will write the
! 776: * new entry into a fresh block.
! 777: */
! 778: if (dp->i_offset & (dirblksize - 1))
! 779: panic("ext2fs_direnter: newblk");
! 780: auio.uio_offset = dp->i_offset;
! 781: newdir.e2d_reclen = h2fs16(dirblksize);
! 782: auio.uio_resid = newentrysize;
! 783: aiov.iov_len = newentrysize;
! 784: aiov.iov_base = (caddr_t)&newdir;
! 785: auio.uio_iov = &aiov;
! 786: auio.uio_iovcnt = 1;
! 787: auio.uio_rw = UIO_WRITE;
! 788: auio.uio_segflg = UIO_SYSSPACE;
! 789: auio.uio_procp = (struct proc *)0;
! 790: error = VOP_WRITE(dvp, &auio, IO_SYNC, cnp->cn_cred);
! 791: if (dirblksize >
! 792: VFSTOUFS(dvp->v_mount)->um_mountp->mnt_stat.f_bsize)
! 793: /* XXX should grow with balloc() */
! 794: panic("ext2fs_direnter: frag size");
! 795: else if (!error) {
! 796: error = ext2fs_setsize(dp,
! 797: roundup(ext2fs_size(dp), dirblksize));
! 798: if (error)
! 799: return (error);
! 800: dp->i_flag |= IN_CHANGE;
! 801: }
! 802: return (error);
! 803: }
! 804:
! 805: /*
! 806: * If dp->i_count is non-zero, then namei found space
! 807: * for the new entry in the range dp->i_offset to
! 808: * dp->i_offset + dp->i_count in the directory.
! 809: * To use this space, we may have to compact the entries located
! 810: * there, by copying them together towards the beginning of the
! 811: * block, leaving the free space in one usable chunk at the end.
! 812: */
! 813:
! 814: /*
! 815: * Get the block containing the space for the new directory entry.
! 816: */
! 817: if ((error = ext2fs_bufatoff(dp, (off_t)dp->i_offset, &dirbuf, &bp))
! 818: != 0)
! 819: return (error);
! 820: /*
! 821: * Find space for the new entry. In the simple case, the entry at
! 822: * offset base will have the space. If it does not, then namei
! 823: * arranged that compacting the region dp->i_offset to
! 824: * dp->i_offset + dp->i_count would yield the
! 825: * space.
! 826: */
! 827: ep = (struct ext2fs_direct *)dirbuf;
! 828: dsize = EXT2FS_DIRSIZ(ep->e2d_namlen);
! 829: spacefree = fs2h16(ep->e2d_reclen) - dsize;
! 830: for (loc = fs2h16(ep->e2d_reclen); loc < dp->i_count; ) {
! 831: nep = (struct ext2fs_direct *)(dirbuf + loc);
! 832: if (ep->e2d_ino) {
! 833: /* trim the existing slot */
! 834: ep->e2d_reclen = h2fs16(dsize);
! 835: ep = (struct ext2fs_direct *)((char *)ep + dsize);
! 836: } else {
! 837: /* overwrite; nothing there; header is ours */
! 838: spacefree += dsize;
! 839: }
! 840: dsize = EXT2FS_DIRSIZ(nep->e2d_namlen);
! 841: spacefree += fs2h16(nep->e2d_reclen) - dsize;
! 842: loc += fs2h16(nep->e2d_reclen);
! 843: memcpy((caddr_t)ep, (caddr_t)nep, dsize);
! 844: }
! 845: /*
! 846: * Update the pointer fields in the previous entry (if any),
! 847: * copy in the new entry, and write out the block.
! 848: */
! 849: if (ep->e2d_ino == 0) {
! 850: #ifdef DIAGNOSTIC
! 851: if (spacefree + dsize < newentrysize)
! 852: panic("ext2fs_direnter: compact1");
! 853: #endif
! 854: newdir.e2d_reclen = h2fs16(spacefree + dsize);
! 855: } else {
! 856: #ifdef DIAGNOSTIC
! 857: if (spacefree < newentrysize) {
! 858: printf("ext2fs_direnter: compact2 %u %u",
! 859: (u_int)spacefree, (u_int)newentrysize);
! 860: panic("ext2fs_direnter: compact2");
! 861: }
! 862: #endif
! 863: newdir.e2d_reclen = h2fs16(spacefree);
! 864: ep->e2d_reclen = h2fs16(dsize);
! 865: ep = (struct ext2fs_direct *)((char *)ep + dsize);
! 866: }
! 867: memcpy((caddr_t)ep, (caddr_t)&newdir, (u_int)newentrysize);
! 868: error = VOP_BWRITE(bp);
! 869: dp->i_flag |= IN_CHANGE | IN_UPDATE;
! 870: if (!error && dp->i_endoff && dp->i_endoff < ext2fs_size(dp))
! 871: error = ext2fs_truncate(dp, (off_t)dp->i_endoff, IO_SYNC,
! 872: cnp->cn_cred);
! 873: return (error);
! 874: }
! 875:
! 876: /*
! 877: * Remove a directory entry after a call to namei, using
! 878: * the parameters which it left in nameidata. The entry
! 879: * dp->i_offset contains the offset into the directory of the
! 880: * entry to be eliminated. The dp->i_count field contains the
! 881: * size of the previous record in the directory. If this
! 882: * is 0, the first entry is being deleted, so we need only
! 883: * zero the inode number to mark the entry as free. If the
! 884: * entry is not the first in the directory, we must reclaim
! 885: * the space of the now empty record by adding the record size
! 886: * to the size of the previous entry.
! 887: */
! 888: int
! 889: ext2fs_dirremove(struct vnode *dvp, struct componentname *cnp)
! 890: {
! 891: struct inode *dp;
! 892: struct ext2fs_direct *ep;
! 893: struct buf *bp;
! 894: int error;
! 895:
! 896: dp = VTOI(dvp);
! 897: if (dp->i_count == 0) {
! 898: /*
! 899: * First entry in block: set d_ino to zero.
! 900: */
! 901: error = ext2fs_bufatoff(dp, (off_t)dp->i_offset, (char **)&ep,
! 902: &bp);
! 903: if (error != 0)
! 904: return (error);
! 905: ep->e2d_ino = 0;
! 906: error = VOP_BWRITE(bp);
! 907: dp->i_flag |= IN_CHANGE | IN_UPDATE;
! 908: return (error);
! 909: }
! 910: /*
! 911: * Collapse new free space into previous entry.
! 912: */
! 913: error = ext2fs_bufatoff(dp, (off_t)(dp->i_offset - dp->i_count),
! 914: (char **)&ep, &bp);
! 915: if (error != 0)
! 916: return (error);
! 917: ep->e2d_reclen = h2fs16(fs2h16(ep->e2d_reclen) + dp->i_reclen);
! 918: error = VOP_BWRITE(bp);
! 919: dp->i_flag |= IN_CHANGE | IN_UPDATE;
! 920: return (error);
! 921: }
! 922:
! 923: /*
! 924: * Rewrite an existing directory entry to point at the inode
! 925: * supplied. The parameters describing the directory entry are
! 926: * set up by a call to namei.
! 927: */
! 928: int
! 929: ext2fs_dirrewrite(struct inode *dp, struct inode *ip,
! 930: struct componentname *cnp)
! 931: {
! 932: struct buf *bp;
! 933: struct ext2fs_direct *ep;
! 934: int error;
! 935:
! 936: error = ext2fs_bufatoff(dp, (off_t)dp->i_offset, (char **)&ep, &bp);
! 937: if (error != 0)
! 938: return (error);
! 939: ep->e2d_ino = h2fs32(ip->i_number);
! 940: if (ip->i_e2fs->e2fs.e2fs_rev > E2FS_REV0 &&
! 941: (ip->i_e2fs->e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE)) {
! 942: ep->e2d_type = inot2ext2dt(IFTODT(ip->i_e2fs_mode));
! 943: } else {
! 944: ep->e2d_type = 0;
! 945: }
! 946: error = VOP_BWRITE(bp);
! 947: dp->i_flag |= IN_CHANGE | IN_UPDATE;
! 948: return (error);
! 949: }
! 950:
! 951: /*
! 952: * Check if a directory is empty or not.
! 953: * Inode supplied must be locked.
! 954: *
! 955: * Using a struct dirtemplate here is not precisely
! 956: * what we want, but better than using a struct ext2fs_direct.
! 957: *
! 958: * NB: does not handle corrupted directories.
! 959: */
! 960: int
! 961: ext2fs_dirempty(struct inode *ip, ino_t parentino, struct ucred *cred)
! 962: {
! 963: off_t off;
! 964: struct ext2fs_dirtemplate dbuf;
! 965: struct ext2fs_direct *dp = (struct ext2fs_direct *)&dbuf;
! 966: int error, namlen;
! 967: size_t count;
! 968:
! 969: #define MINDIRSIZ (sizeof (struct ext2fs_dirtemplate) / 2)
! 970:
! 971: for (off = 0; off < ext2fs_size(ip); off += fs2h16(dp->e2d_reclen)) {
! 972: error = vn_rdwr(UIO_READ, ITOV(ip), (caddr_t)dp, MINDIRSIZ, off,
! 973: UIO_SYSSPACE, IO_NODELOCKED, cred, &count, (struct proc *)0);
! 974: /*
! 975: * Since we read MINDIRSIZ, residual must
! 976: * be 0 unless we're at end of file.
! 977: */
! 978: if (error || count != 0)
! 979: return (0);
! 980: /* avoid infinite loops */
! 981: if (dp->e2d_reclen == 0)
! 982: return (0);
! 983: /* skip empty entries */
! 984: if (dp->e2d_ino == 0)
! 985: continue;
! 986: /* accept only "." and ".." */
! 987: namlen = dp->e2d_namlen;
! 988: if (namlen > 2)
! 989: return (0);
! 990: if (dp->e2d_name[0] != '.')
! 991: return (0);
! 992: /*
! 993: * At this point namlen must be 1 or 2.
! 994: * 1 implies ".", 2 implies ".." if second
! 995: * char is also "."
! 996: */
! 997: if (namlen == 1)
! 998: continue;
! 999: if (dp->e2d_name[1] == '.' && fs2h32(dp->e2d_ino) == parentino)
! 1000: continue;
! 1001: return (0);
! 1002: }
! 1003: return (1);
! 1004: }
! 1005:
! 1006: /*
! 1007: * Check if source directory is in the path of the target directory.
! 1008: * Target is supplied locked, source is unlocked.
! 1009: * The target is always vput before returning.
! 1010: */
! 1011: int
! 1012: ext2fs_checkpath(struct inode *source, struct inode *target,
! 1013: struct ucred *cred)
! 1014: {
! 1015: struct vnode *vp;
! 1016: int error, rootino, namlen;
! 1017: struct ext2fs_dirtemplate dirbuf;
! 1018: u_int32_t ino;
! 1019:
! 1020: vp = ITOV(target);
! 1021: if (target->i_number == source->i_number) {
! 1022: error = EEXIST;
! 1023: goto out;
! 1024: }
! 1025: rootino = ROOTINO;
! 1026: error = 0;
! 1027: if (target->i_number == rootino)
! 1028: goto out;
! 1029:
! 1030: for (;;) {
! 1031: if (vp->v_type != VDIR) {
! 1032: error = ENOTDIR;
! 1033: break;
! 1034: }
! 1035: error = vn_rdwr(UIO_READ, vp, (caddr_t)&dirbuf,
! 1036: sizeof (struct ext2fs_dirtemplate), (off_t)0,
! 1037: UIO_SYSSPACE, IO_NODELOCKED, cred, (size_t *)0,
! 1038: (struct proc *)0);
! 1039: if (error != 0)
! 1040: break;
! 1041: namlen = dirbuf.dotdot_namlen;
! 1042: if (namlen != 2 ||
! 1043: dirbuf.dotdot_name[0] != '.' ||
! 1044: dirbuf.dotdot_name[1] != '.') {
! 1045: error = ENOTDIR;
! 1046: break;
! 1047: }
! 1048: ino = fs2h32(dirbuf.dotdot_ino);
! 1049: if (ino == source->i_number) {
! 1050: error = EINVAL;
! 1051: break;
! 1052: }
! 1053: if (ino == rootino)
! 1054: break;
! 1055: vput(vp);
! 1056: error = VFS_VGET(vp->v_mount, ino, &vp);
! 1057: if (error != 0) {
! 1058: vp = NULL;
! 1059: break;
! 1060: }
! 1061: }
! 1062:
! 1063: out:
! 1064: if (error == ENOTDIR) {
! 1065: printf("checkpath: .. not a directory\n");
! 1066: panic("checkpath");
! 1067: }
! 1068: if (vp != NULL)
! 1069: vput(vp);
! 1070: return (error);
! 1071: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ext2fs_lookup.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / ufs / ext2fs