Annotation of sys/kern/vfs_lookup.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: vfs_lookup.c,v 1.36 2007/08/07 07:41:59 thib Exp $ */
! 2: /* $NetBSD: vfs_lookup.c,v 1.17 1996/02/09 19:00:59 christos Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1982, 1986, 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: * @(#)vfs_lookup.c 8.6 (Berkeley) 11/21/94
! 38: */
! 39:
! 40: #include <sys/param.h>
! 41: #include <sys/systm.h>
! 42: #include <sys/syslimits.h>
! 43: #include <sys/time.h>
! 44: #include <sys/namei.h>
! 45: #include <sys/vnode.h>
! 46: #include <sys/mount.h>
! 47: #include <sys/errno.h>
! 48: #include <sys/malloc.h>
! 49: #include <sys/pool.h>
! 50: #include <sys/filedesc.h>
! 51: #include <sys/proc.h>
! 52: #include <sys/hash.h>
! 53:
! 54: #ifdef KTRACE
! 55: #include <sys/ktrace.h>
! 56: #endif
! 57:
! 58: #include <dev/systrace.h>
! 59: #include "systrace.h"
! 60:
! 61: /*
! 62: * Convert a pathname into a pointer to a vnode.
! 63: *
! 64: * The FOLLOW flag is set when symbolic links are to be followed
! 65: * when they occur at the end of the name translation process.
! 66: * Symbolic links are always followed for all other pathname
! 67: * components other than the last.
! 68: *
! 69: * If the LOCKLEAF flag is set, a locked vnode is returned.
! 70: *
! 71: * The segflg defines whether the name is to be copied from user
! 72: * space or kernel space.
! 73: *
! 74: * Overall outline of namei:
! 75: *
! 76: * copy in name
! 77: * get starting directory
! 78: * while (!done && !error) {
! 79: * call lookup to search path.
! 80: * if symbolic link, massage name in buffer and continue
! 81: * }
! 82: */
! 83: int
! 84: namei(struct nameidata *ndp)
! 85: {
! 86: struct filedesc *fdp; /* pointer to file descriptor state */
! 87: char *cp; /* pointer into pathname argument */
! 88: struct vnode *dp; /* the directory we are searching */
! 89: struct iovec aiov; /* uio for reading symbolic links */
! 90: struct uio auio;
! 91: int error, linklen;
! 92: struct componentname *cnp = &ndp->ni_cnd;
! 93: struct proc *p = cnp->cn_proc;
! 94:
! 95: ndp->ni_cnd.cn_cred = ndp->ni_cnd.cn_proc->p_ucred;
! 96: #ifdef DIAGNOSTIC
! 97: if (!cnp->cn_cred || !cnp->cn_proc)
! 98: panic ("namei: bad cred/proc");
! 99: if (cnp->cn_nameiop & (~OPMASK))
! 100: panic ("namei: nameiop contaminated with flags");
! 101: if (cnp->cn_flags & OPMASK)
! 102: panic ("namei: flags contaminated with nameiops");
! 103: #endif
! 104: fdp = cnp->cn_proc->p_fd;
! 105:
! 106: /*
! 107: * Get a buffer for the name to be translated, and copy the
! 108: * name into the buffer.
! 109: */
! 110: if ((cnp->cn_flags & HASBUF) == 0)
! 111: cnp->cn_pnbuf = pool_get(&namei_pool, PR_WAITOK);
! 112: if (ndp->ni_segflg == UIO_SYSSPACE)
! 113: error = copystr(ndp->ni_dirp, cnp->cn_pnbuf,
! 114: MAXPATHLEN, &ndp->ni_pathlen);
! 115: else
! 116: error = copyinstr(ndp->ni_dirp, cnp->cn_pnbuf,
! 117: MAXPATHLEN, &ndp->ni_pathlen);
! 118:
! 119: /*
! 120: * Fail on null pathnames
! 121: */
! 122: if (error == 0 && ndp->ni_pathlen == 1)
! 123: error = ENOENT;
! 124:
! 125: if (error) {
! 126: pool_put(&namei_pool, cnp->cn_pnbuf);
! 127: ndp->ni_vp = NULL;
! 128: return (error);
! 129: }
! 130:
! 131: #ifdef KTRACE
! 132: if (KTRPOINT(cnp->cn_proc, KTR_NAMEI))
! 133: ktrnamei(cnp->cn_proc, cnp->cn_pnbuf);
! 134: #endif
! 135: #if NSYSTRACE > 0
! 136: if (ISSET(cnp->cn_proc->p_flag, P_SYSTRACE))
! 137: systrace_namei(ndp);
! 138: #endif
! 139:
! 140: /*
! 141: * Strip trailing slashes, as requested
! 142: */
! 143: if (cnp->cn_flags & STRIPSLASHES) {
! 144: char *end = cnp->cn_pnbuf + ndp->ni_pathlen - 2;
! 145:
! 146: cp = end;
! 147: while (cp >= cnp->cn_pnbuf && (*cp == '/'))
! 148: cp--;
! 149:
! 150: /* Still some remaining characters in the buffer */
! 151: if (cp >= cnp->cn_pnbuf) {
! 152: ndp->ni_pathlen -= (end - cp);
! 153: *(cp + 1) = '\0';
! 154: }
! 155: }
! 156:
! 157: ndp->ni_loopcnt = 0;
! 158:
! 159: /*
! 160: * Get starting point for the translation.
! 161: */
! 162: if ((ndp->ni_rootdir = fdp->fd_rdir) == NULL)
! 163: ndp->ni_rootdir = rootvnode;
! 164: /*
! 165: * Check if starting from root directory or current directory.
! 166: */
! 167: if (cnp->cn_pnbuf[0] == '/') {
! 168: dp = ndp->ni_rootdir;
! 169: VREF(dp);
! 170: } else {
! 171: dp = fdp->fd_cdir;
! 172: VREF(dp);
! 173: }
! 174: for (;;) {
! 175: if (!dp->v_mount) {
! 176: /* Give up if the directory is no longer mounted */
! 177: pool_put(&namei_pool, cnp->cn_pnbuf);
! 178: return (ENOENT);
! 179: }
! 180: cnp->cn_nameptr = cnp->cn_pnbuf;
! 181: ndp->ni_startdir = dp;
! 182: if ((error = lookup(ndp)) != 0) {
! 183: pool_put(&namei_pool, cnp->cn_pnbuf);
! 184: return (error);
! 185: }
! 186: /*
! 187: * Check for symbolic link
! 188: */
! 189: if ((cnp->cn_flags & ISSYMLINK) == 0) {
! 190: if ((cnp->cn_flags & (SAVENAME | SAVESTART)) == 0)
! 191: pool_put(&namei_pool, cnp->cn_pnbuf);
! 192: else
! 193: cnp->cn_flags |= HASBUF;
! 194: return (0);
! 195: }
! 196: if ((cnp->cn_flags & LOCKPARENT) && (cnp->cn_flags & ISLASTCN))
! 197: VOP_UNLOCK(ndp->ni_dvp, 0, p);
! 198: if (ndp->ni_loopcnt++ >= MAXSYMLINKS) {
! 199: error = ELOOP;
! 200: break;
! 201: }
! 202: if (ndp->ni_pathlen > 1)
! 203: cp = pool_get(&namei_pool, PR_WAITOK);
! 204: else
! 205: cp = cnp->cn_pnbuf;
! 206: aiov.iov_base = cp;
! 207: aiov.iov_len = MAXPATHLEN;
! 208: auio.uio_iov = &aiov;
! 209: auio.uio_iovcnt = 1;
! 210: auio.uio_offset = 0;
! 211: auio.uio_rw = UIO_READ;
! 212: auio.uio_segflg = UIO_SYSSPACE;
! 213: auio.uio_procp = cnp->cn_proc;
! 214: auio.uio_resid = MAXPATHLEN;
! 215: error = VOP_READLINK(ndp->ni_vp, &auio, cnp->cn_cred);
! 216: if (error) {
! 217: badlink:
! 218: if (ndp->ni_pathlen > 1)
! 219: pool_put(&namei_pool, cp);
! 220: break;
! 221: }
! 222: linklen = MAXPATHLEN - auio.uio_resid;
! 223: if (linklen + ndp->ni_pathlen >= MAXPATHLEN) {
! 224: error = ENAMETOOLONG;
! 225: goto badlink;
! 226: }
! 227: if (ndp->ni_pathlen > 1) {
! 228: bcopy(ndp->ni_next, cp + linklen, ndp->ni_pathlen);
! 229: pool_put(&namei_pool, cnp->cn_pnbuf);
! 230: cnp->cn_pnbuf = cp;
! 231: } else
! 232: cnp->cn_pnbuf[linklen] = '\0';
! 233: ndp->ni_pathlen += linklen;
! 234: vput(ndp->ni_vp);
! 235: dp = ndp->ni_dvp;
! 236: /*
! 237: * Check if root directory should replace current directory.
! 238: */
! 239: if (cnp->cn_pnbuf[0] == '/') {
! 240: vrele(dp);
! 241: dp = ndp->ni_rootdir;
! 242: VREF(dp);
! 243: }
! 244: }
! 245: pool_put(&namei_pool, cnp->cn_pnbuf);
! 246: vrele(ndp->ni_dvp);
! 247: vput(ndp->ni_vp);
! 248: ndp->ni_vp = NULL;
! 249: return (error);
! 250: }
! 251:
! 252: /*
! 253: * Search a pathname.
! 254: * This is a very central and rather complicated routine.
! 255: *
! 256: * The pathname is pointed to by ni_ptr and is of length ni_pathlen.
! 257: * The starting directory is taken from ni_startdir. The pathname is
! 258: * descended until done, or a symbolic link is encountered. The variable
! 259: * ni_more is clear if the path is completed; it is set to one if a
! 260: * symbolic link needing interpretation is encountered.
! 261: *
! 262: * The flag argument is LOOKUP, CREATE, RENAME, or DELETE depending on
! 263: * whether the name is to be looked up, created, renamed, or deleted.
! 264: * When CREATE, RENAME, or DELETE is specified, information usable in
! 265: * creating, renaming, or deleting a directory entry may be calculated.
! 266: * If flag has LOCKPARENT or'ed into it, the parent directory is returned
! 267: * locked. If flag has WANTPARENT or'ed into it, the parent directory is
! 268: * returned unlocked. Otherwise the parent directory is not returned. If
! 269: * the target of the pathname exists and LOCKLEAF is or'ed into the flag
! 270: * the target is returned locked, otherwise it is returned unlocked.
! 271: * When creating or renaming and LOCKPARENT is specified, the target may not
! 272: * be ".". When deleting and LOCKPARENT is specified, the target may be ".".
! 273: *
! 274: * Overall outline of lookup:
! 275: *
! 276: * dirloop:
! 277: * identify next component of name at ndp->ni_ptr
! 278: * handle degenerate case where name is null string
! 279: * if .. and crossing mount points and on mounted filesys, find parent
! 280: * call VOP_LOOKUP routine for next component name
! 281: * directory vnode returned in ni_dvp, unlocked unless LOCKPARENT set
! 282: * component vnode returned in ni_vp (if it exists), locked.
! 283: * if result vnode is mounted on and crossing mount points,
! 284: * find mounted on vnode
! 285: * if more components of name, do next level at dirloop
! 286: * return the answer in ni_vp, locked if LOCKLEAF set
! 287: * if LOCKPARENT set, return locked parent in ni_dvp
! 288: * if WANTPARENT set, return unlocked parent in ni_dvp
! 289: */
! 290: int
! 291: lookup(struct nameidata *ndp)
! 292: {
! 293: char *cp; /* pointer into pathname argument */
! 294: struct vnode *dp = 0; /* the directory we are searching */
! 295: struct vnode *tdp; /* saved dp */
! 296: struct mount *mp; /* mount table entry */
! 297: int docache; /* == 0 do not cache last component */
! 298: int wantparent; /* 1 => wantparent or lockparent flag */
! 299: int rdonly; /* lookup read-only flag bit */
! 300: int error = 0;
! 301: int dpunlocked = 0; /* dp has already been unlocked */
! 302: int slashes;
! 303: struct componentname *cnp = &ndp->ni_cnd;
! 304: struct proc *p = cnp->cn_proc;
! 305: /*
! 306: * Setup: break out flag bits into variables.
! 307: */
! 308: wantparent = cnp->cn_flags & (LOCKPARENT | WANTPARENT);
! 309: docache = (cnp->cn_flags & NOCACHE) ^ NOCACHE;
! 310: if (cnp->cn_nameiop == DELETE ||
! 311: (wantparent && cnp->cn_nameiop != CREATE))
! 312: docache = 0;
! 313: rdonly = cnp->cn_flags & RDONLY;
! 314: ndp->ni_dvp = NULL;
! 315: cnp->cn_flags &= ~ISSYMLINK;
! 316: dp = ndp->ni_startdir;
! 317: ndp->ni_startdir = NULLVP;
! 318: vn_lock(dp, LK_EXCLUSIVE | LK_RETRY, p);
! 319:
! 320: /*
! 321: * If we have a leading string of slashes, remove them, and just make
! 322: * sure the current node is a directory.
! 323: */
! 324: cp = cnp->cn_nameptr;
! 325: if (*cp == '/') {
! 326: do {
! 327: cp++;
! 328: } while (*cp == '/');
! 329: ndp->ni_pathlen -= cp - cnp->cn_nameptr;
! 330: cnp->cn_nameptr = cp;
! 331:
! 332: if (dp->v_type != VDIR) {
! 333: error = ENOTDIR;
! 334: goto bad;
! 335: }
! 336:
! 337: /*
! 338: * If we've exhausted the path name, then just return the
! 339: * current node. If the caller requested the parent node (i.e.
! 340: * it's a CREATE, DELETE, or RENAME), and we don't have one
! 341: * (because this is the root directory), then we must fail.
! 342: */
! 343: if (cnp->cn_nameptr[0] == '\0') {
! 344: if (ndp->ni_dvp == NULL && wantparent) {
! 345: error = EISDIR;
! 346: goto bad;
! 347: }
! 348: ndp->ni_vp = dp;
! 349: cnp->cn_flags |= ISLASTCN;
! 350: goto terminal;
! 351: }
! 352: }
! 353:
! 354: dirloop:
! 355: /*
! 356: * Search a new directory.
! 357: *
! 358: * The cn_hash value is for use by vfs_cache.
! 359: * The last component of the filename is left accessible via
! 360: * cnp->cn_nameptr for callers that need the name. Callers needing
! 361: * the name set the SAVENAME flag. When done, they assume
! 362: * responsibility for freeing the pathname buffer.
! 363: */
! 364: cp = NULL;
! 365: cnp->cn_consume = 0;
! 366: cnp->cn_hash = hash32_stre(cnp->cn_nameptr, '/', &cp, HASHINIT);
! 367: cnp->cn_namelen = cp - cnp->cn_nameptr;
! 368: if (cnp->cn_namelen > NAME_MAX) {
! 369: error = ENAMETOOLONG;
! 370: goto bad;
! 371: }
! 372: #ifdef NAMEI_DIAGNOSTIC
! 373: { char c = *cp;
! 374: *cp = '\0';
! 375: printf("{%s}: ", cnp->cn_nameptr);
! 376: *cp = c; }
! 377: #endif
! 378: ndp->ni_pathlen -= cnp->cn_namelen;
! 379: ndp->ni_next = cp;
! 380: /*
! 381: * If this component is followed by a slash, then move the pointer to
! 382: * the next component forward, and remember that this component must be
! 383: * a directory.
! 384: */
! 385: if (*cp == '/') {
! 386: do {
! 387: cp++;
! 388: } while (*cp == '/');
! 389: slashes = cp - ndp->ni_next;
! 390: ndp->ni_pathlen -= slashes;
! 391: ndp->ni_next = cp;
! 392: cnp->cn_flags |= REQUIREDIR;
! 393: } else {
! 394: slashes = 0;
! 395: cnp->cn_flags &= ~REQUIREDIR;
! 396: }
! 397: /*
! 398: * We do special processing on the last component, whether or not it's
! 399: * a directory. Cache all intervening lookups, but not the final one.
! 400: */
! 401: if (*cp == '\0') {
! 402: if (docache)
! 403: cnp->cn_flags |= MAKEENTRY;
! 404: else
! 405: cnp->cn_flags &= ~MAKEENTRY;
! 406: cnp->cn_flags |= ISLASTCN;
! 407: } else {
! 408: cnp->cn_flags |= MAKEENTRY;
! 409: cnp->cn_flags &= ~ISLASTCN;
! 410: }
! 411: if (cnp->cn_namelen == 2 &&
! 412: cnp->cn_nameptr[1] == '.' && cnp->cn_nameptr[0] == '.')
! 413: cnp->cn_flags |= ISDOTDOT;
! 414: else
! 415: cnp->cn_flags &= ~ISDOTDOT;
! 416:
! 417: /*
! 418: * Handle "..": two special cases.
! 419: * 1. If at root directory (e.g. after chroot)
! 420: * or at absolute root directory
! 421: * then ignore it so can't get out.
! 422: * 2. If this vnode is the root of a mounted
! 423: * filesystem, then replace it with the
! 424: * vnode which was mounted on so we take the
! 425: * .. in the other file system.
! 426: */
! 427: if (cnp->cn_flags & ISDOTDOT) {
! 428: for (;;) {
! 429: if (dp == ndp->ni_rootdir || dp == rootvnode) {
! 430: ndp->ni_dvp = dp;
! 431: ndp->ni_vp = dp;
! 432: VREF(dp);
! 433: goto nextname;
! 434: }
! 435: if ((dp->v_flag & VROOT) == 0 ||
! 436: (cnp->cn_flags & NOCROSSMOUNT))
! 437: break;
! 438: tdp = dp;
! 439: dp = dp->v_mount->mnt_vnodecovered;
! 440: vput(tdp);
! 441: VREF(dp);
! 442: vn_lock(dp, LK_EXCLUSIVE | LK_RETRY, p);
! 443: }
! 444: }
! 445:
! 446: /*
! 447: * We now have a segment name to search for, and a directory to search.
! 448: */
! 449: ndp->ni_dvp = dp;
! 450: ndp->ni_vp = NULL;
! 451: cnp->cn_flags &= ~PDIRUNLOCK;
! 452:
! 453: if ((error = VOP_LOOKUP(dp, &ndp->ni_vp, cnp)) != 0) {
! 454: #ifdef DIAGNOSTIC
! 455: if (ndp->ni_vp != NULL)
! 456: panic("leaf should be empty");
! 457: #endif
! 458: #ifdef NAMEI_DIAGNOSTIC
! 459: printf("not found\n");
! 460: #endif
! 461: if (error != EJUSTRETURN)
! 462: goto bad;
! 463: /*
! 464: * If this was not the last component, or there were trailing
! 465: * slashes, then the name must exist.
! 466: */
! 467: if (cnp->cn_flags & REQUIREDIR) {
! 468: error = ENOENT;
! 469: goto bad;
! 470: }
! 471: /*
! 472: * If creating and at end of pathname, then can consider
! 473: * allowing file to be created.
! 474: */
! 475: if (rdonly || (ndp->ni_dvp->v_mount->mnt_flag & MNT_RDONLY)) {
! 476: error = EROFS;
! 477: goto bad;
! 478: }
! 479: /*
! 480: * We return with ni_vp NULL to indicate that the entry
! 481: * doesn't currently exist, leaving a pointer to the
! 482: * (possibly locked) directory inode in ndp->ni_dvp.
! 483: */
! 484: if (cnp->cn_flags & SAVESTART) {
! 485: ndp->ni_startdir = ndp->ni_dvp;
! 486: VREF(ndp->ni_startdir);
! 487: }
! 488: return (0);
! 489: }
! 490: #ifdef NAMEI_DIAGNOSTIC
! 491: printf("found\n");
! 492: #endif
! 493:
! 494: /*
! 495: * Take into account any additional components consumed by the
! 496: * underlying filesystem. This will include any trailing slashes after
! 497: * the last component consumed.
! 498: */
! 499: if (cnp->cn_consume > 0) {
! 500: if (cnp->cn_consume >= slashes) {
! 501: cnp->cn_flags &= ~REQUIREDIR;
! 502: }
! 503:
! 504: ndp->ni_pathlen -= cnp->cn_consume - slashes;
! 505: ndp->ni_next += cnp->cn_consume - slashes;
! 506: cnp->cn_consume = 0;
! 507: if (ndp->ni_next[0] == '\0')
! 508: cnp->cn_flags |= ISLASTCN;
! 509: }
! 510:
! 511: dp = ndp->ni_vp;
! 512: /*
! 513: * Check to see if the vnode has been mounted on;
! 514: * if so find the root of the mounted file system.
! 515: */
! 516: while (dp->v_type == VDIR && (mp = dp->v_mountedhere) &&
! 517: (cnp->cn_flags & NOCROSSMOUNT) == 0) {
! 518: if (vfs_busy(mp, VB_READ|VB_WAIT))
! 519: continue;
! 520: VOP_UNLOCK(dp, 0, p);
! 521: error = VFS_ROOT(mp, &tdp);
! 522: vfs_unbusy(mp);
! 523: if (error) {
! 524: dpunlocked = 1;
! 525: goto bad2;
! 526: }
! 527: vrele(dp);
! 528: ndp->ni_vp = dp = tdp;
! 529: }
! 530:
! 531: /*
! 532: * Check for symbolic link. Back up over any slashes that we skipped,
! 533: * as we will need them again.
! 534: */
! 535: if ((dp->v_type == VLNK) && (cnp->cn_flags & (FOLLOW|REQUIREDIR))) {
! 536: ndp->ni_pathlen += slashes;
! 537: ndp->ni_next -= slashes;
! 538: cnp->cn_flags |= ISSYMLINK;
! 539: return (0);
! 540: }
! 541:
! 542: /*
! 543: * Check for directory, if the component was followed by a series of
! 544: * slashes.
! 545: */
! 546: if ((dp->v_type != VDIR) && (cnp->cn_flags & REQUIREDIR)) {
! 547: error = ENOTDIR;
! 548: goto bad2;
! 549: }
! 550:
! 551: nextname:
! 552: /*
! 553: * Not a symbolic link. If this was not the last component, then
! 554: * continue at the next component, else return.
! 555: */
! 556: if (!(cnp->cn_flags & ISLASTCN)) {
! 557: cnp->cn_nameptr = ndp->ni_next;
! 558: vrele(ndp->ni_dvp);
! 559: goto dirloop;
! 560: }
! 561:
! 562: terminal:
! 563: /*
! 564: * Check for read-only file systems.
! 565: */
! 566: if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME) {
! 567: /*
! 568: * Disallow directory write attempts on read-only
! 569: * file systems.
! 570: */
! 571: if (rdonly || (dp->v_mount->mnt_flag & MNT_RDONLY) ||
! 572: (wantparent &&
! 573: (ndp->ni_dvp->v_mount->mnt_flag & MNT_RDONLY))) {
! 574: error = EROFS;
! 575: goto bad2;
! 576: }
! 577: }
! 578: if (ndp->ni_dvp != NULL) {
! 579: if (cnp->cn_flags & SAVESTART) {
! 580: ndp->ni_startdir = ndp->ni_dvp;
! 581: VREF(ndp->ni_startdir);
! 582: }
! 583: if (!wantparent)
! 584: vrele(ndp->ni_dvp);
! 585: }
! 586: if ((cnp->cn_flags & LOCKLEAF) == 0)
! 587: VOP_UNLOCK(dp, 0, p);
! 588: return (0);
! 589:
! 590: bad2:
! 591: if ((cnp->cn_flags & LOCKPARENT) && (cnp->cn_flags & ISLASTCN) &&
! 592: ((cnp->cn_flags & PDIRUNLOCK) == 0))
! 593: VOP_UNLOCK(ndp->ni_dvp, 0, p);
! 594: vrele(ndp->ni_dvp);
! 595: bad:
! 596: if (dpunlocked)
! 597: vrele(dp);
! 598: else
! 599: vput(dp);
! 600: ndp->ni_vp = NULL;
! 601: return (error);
! 602: }
! 603:
! 604: /*
! 605: * Reacquire a path name component.
! 606: */
! 607: int
! 608: relookup(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp)
! 609: {
! 610: struct proc *p = cnp->cn_proc;
! 611: struct vnode *dp = 0; /* the directory we are searching */
! 612: int wantparent; /* 1 => wantparent or lockparent flag */
! 613: int rdonly; /* lookup read-only flag bit */
! 614: int error = 0;
! 615: #ifdef NAMEI_DIAGNOSTIC
! 616: u_int32_t newhash; /* DEBUG: check name hash */
! 617: char *cp; /* DEBUG: check name ptr/len */
! 618: #endif
! 619:
! 620: /*
! 621: * Setup: break out flag bits into variables.
! 622: */
! 623: wantparent = cnp->cn_flags & (LOCKPARENT|WANTPARENT);
! 624: rdonly = cnp->cn_flags & RDONLY;
! 625: cnp->cn_flags &= ~ISSYMLINK;
! 626: dp = dvp;
! 627: vn_lock(dp, LK_EXCLUSIVE | LK_RETRY, p);
! 628:
! 629: /* dirloop: */
! 630: /*
! 631: * Search a new directory.
! 632: *
! 633: * The cn_hash value is for use by vfs_cache.
! 634: * The last component of the filename is left accessible via
! 635: * cnp->cn_nameptr for callers that need the name. Callers needing
! 636: * the name set the SAVENAME flag. When done, they assume
! 637: * responsibility for freeing the pathname buffer.
! 638: */
! 639: #ifdef NAMEI_DIAGNOSTIC
! 640: cp = NULL;
! 641: newhash = hash32_stre(cnp->cn_nameptr, '/', &cp, HASHINIT);
! 642: if (newhash != cnp->cn_hash)
! 643: panic("relookup: bad hash");
! 644: if (cnp->cn_namelen != cp - cnp->cn_nameptr)
! 645: panic ("relookup: bad len");
! 646: if (*cp != 0)
! 647: panic("relookup: not last component");
! 648: printf("{%s}: ", cnp->cn_nameptr);
! 649: #endif
! 650:
! 651: /*
! 652: * Check for degenerate name (e.g. / or "")
! 653: * which is a way of talking about a directory,
! 654: * e.g. like "/." or ".".
! 655: */
! 656: if (cnp->cn_nameptr[0] == '\0')
! 657: panic("relookup: null name");
! 658:
! 659: if (cnp->cn_flags & ISDOTDOT)
! 660: panic ("relookup: lookup on dot-dot");
! 661:
! 662: /*
! 663: * We now have a segment name to search for, and a directory to search.
! 664: */
! 665: if ((error = VOP_LOOKUP(dp, vpp, cnp)) != 0) {
! 666: #ifdef DIAGNOSTIC
! 667: if (*vpp != NULL)
! 668: panic("leaf should be empty");
! 669: #endif
! 670: if (error != EJUSTRETURN)
! 671: goto bad;
! 672: /*
! 673: * If creating and at end of pathname, then can consider
! 674: * allowing file to be created.
! 675: */
! 676: if (rdonly || (dvp->v_mount->mnt_flag & MNT_RDONLY)) {
! 677: error = EROFS;
! 678: goto bad;
! 679: }
! 680: /* ASSERT(dvp == ndp->ni_startdir) */
! 681: if (cnp->cn_flags & SAVESTART)
! 682: VREF(dvp);
! 683: /*
! 684: * We return with ni_vp NULL to indicate that the entry
! 685: * doesn't currently exist, leaving a pointer to the
! 686: * (possibly locked) directory inode in ndp->ni_dvp.
! 687: */
! 688: return (0);
! 689: }
! 690: dp = *vpp;
! 691:
! 692: #ifdef DIAGNOSTIC
! 693: /*
! 694: * Check for symbolic link
! 695: */
! 696: if (dp->v_type == VLNK && (cnp->cn_flags & FOLLOW))
! 697: panic ("relookup: symlink found.");
! 698: #endif
! 699:
! 700: /*
! 701: * Check for read-only file systems.
! 702: */
! 703: if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME) {
! 704: /*
! 705: * Disallow directory write attempts on read-only
! 706: * file systems.
! 707: */
! 708: if (rdonly || (dp->v_mount->mnt_flag & MNT_RDONLY) ||
! 709: (wantparent &&
! 710: (dvp->v_mount->mnt_flag & MNT_RDONLY))) {
! 711: error = EROFS;
! 712: goto bad2;
! 713: }
! 714: }
! 715: /* ASSERT(dvp == ndp->ni_startdir) */
! 716: if (cnp->cn_flags & SAVESTART)
! 717: VREF(dvp);
! 718: if (!wantparent)
! 719: vrele(dvp);
! 720: if ((cnp->cn_flags & LOCKLEAF) == 0)
! 721: VOP_UNLOCK(dp, 0, p);
! 722: return (0);
! 723:
! 724: bad2:
! 725: if ((cnp->cn_flags & LOCKPARENT) && (cnp->cn_flags & ISLASTCN))
! 726: VOP_UNLOCK(dvp, 0, p);
! 727: vrele(dvp);
! 728: bad:
! 729: vput(dp);
! 730: *vpp = NULL;
! 731: return (error);
! 732: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to vfs_lookup.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / kern