![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vfs_lookup.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / vfs|
Return to vfs_lookup.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / vfs |
1.1 ! root 1: /* ! 2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights ! 7: * Reserved. This file contains Original Code and/or Modifications of ! 8: * Original Code as defined in and that are subject to the Apple Public ! 9: * Source License Version 1.1 (the "License"). You may not use this file ! 10: * except in compliance with the License. Please obtain a copy of the ! 11: * License at http://www.apple.com/publicsource and read it before using ! 12: * this file. ! 13: * ! 14: * The Original Code and all software distributed under the License are ! 15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 19: * License for the specific language governing rights and limitations ! 20: * under the License. ! 21: * ! 22: * @APPLE_LICENSE_HEADER_END@ ! 23: */ ! 24: ! 25: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */ ! 26: /* ! 27: * Copyright (c) 1982, 1986, 1989, 1993 ! 28: * The Regents of the University of California. All rights reserved. ! 29: * (c) UNIX System Laboratories, Inc. ! 30: * All or some portions of this file are derived from material licensed ! 31: * to the University of California by American Telephone and Telegraph ! 32: * Co. or Unix System Laboratories, Inc. and are reproduced herein with ! 33: * the permission of UNIX System Laboratories, Inc. ! 34: * ! 35: * Redistribution and use in source and binary forms, with or without ! 36: * modification, are permitted provided that the following conditions ! 37: * are met: ! 38: * 1. Redistributions of source code must retain the above copyright ! 39: * notice, this list of conditions and the following disclaimer. ! 40: * 2. Redistributions in binary form must reproduce the above copyright ! 41: * notice, this list of conditions and the following disclaimer in the ! 42: * documentation and/or other materials provided with the distribution. ! 43: * 3. All advertising materials mentioning features or use of this software ! 44: * must display the following acknowledgement: ! 45: * This product includes software developed by the University of ! 46: * California, Berkeley and its contributors. ! 47: * 4. Neither the name of the University nor the names of its contributors ! 48: * may be used to endorse or promote products derived from this software ! 49: * without specific prior written permission. ! 50: * ! 51: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 52: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 53: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 54: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 55: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 56: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 57: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 58: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 59: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 60: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 61: * SUCH DAMAGE. ! 62: * ! 63: * @(#)vfs_lookup.c 8.10 (Berkeley) 5/27/95 ! 64: */ ! 65: ! 66: #include <sys/param.h> ! 67: #include <sys/syslimits.h> ! 68: #include <sys/time.h> ! 69: #include <sys/namei.h> ! 70: #include <sys/vm.h> ! 71: #include <sys/vnode.h> ! 72: #include <sys/mount.h> ! 73: #include <sys/errno.h> ! 74: #include <sys/malloc.h> ! 75: #include <sys/filedesc.h> ! 76: #include <sys/proc.h> ! 77: ! 78: #if KTRACE ! 79: #include <sys/ktrace.h> ! 80: #endif ! 81: ! 82: /* ! 83: * Convert a pathname into a pointer to a locked inode. ! 84: * ! 85: * The FOLLOW flag is set when symbolic links are to be followed ! 86: * when they occur at the end of the name translation process. ! 87: * Symbolic links are always followed for all other pathname ! 88: * components other than the last. ! 89: * ! 90: * The segflg defines whether the name is to be copied from user ! 91: * space or kernel space. ! 92: * ! 93: * Overall outline of namei: ! 94: * ! 95: * copy in name ! 96: * get starting directory ! 97: * while (!done && !error) { ! 98: * call lookup to search path. ! 99: * if symbolic link, massage name in buffer and continue ! 100: * } ! 101: */ ! 102: int ! 103: namei(ndp) ! 104: register struct nameidata *ndp; ! 105: { ! 106: register struct filedesc *fdp; /* pointer to file descriptor state */ ! 107: register char *cp; /* pointer into pathname argument */ ! 108: register struct vnode *dp; /* the directory we are searching */ ! 109: struct iovec aiov; /* uio for reading symbolic links */ ! 110: struct uio auio; ! 111: int error, linklen; ! 112: struct componentname *cnp = &ndp->ni_cnd; ! 113: struct proc *p = cnp->cn_proc; ! 114: ! 115: ndp->ni_cnd.cn_cred = ndp->ni_cnd.cn_proc->p_ucred; ! 116: #if DIAGNOSTIC ! 117: if (!cnp->cn_cred || !cnp->cn_proc) ! 118: panic ("namei: bad cred/proc"); ! 119: if (cnp->cn_nameiop & (~OPMASK)) ! 120: panic ("namei: nameiop contaminated with flags"); ! 121: if (cnp->cn_flags & OPMASK) ! 122: panic ("namei: flags contaminated with nameiops"); ! 123: #endif ! 124: fdp = cnp->cn_proc->p_fd; ! 125: ! 126: /* ! 127: * Get a buffer for the name to be translated, and copy the ! 128: * name into the buffer. ! 129: */ ! 130: if ((cnp->cn_flags & HASBUF) == 0) { ! 131: MALLOC_ZONE(cnp->cn_pnbuf, caddr_t, ! 132: MAXPATHLEN, M_NAMEI, M_WAITOK); ! 133: cnp->cn_pnlen = MAXPATHLEN; ! 134: } ! 135: if (ndp->ni_segflg == UIO_SYSSPACE) ! 136: error = copystr(ndp->ni_dirp, cnp->cn_pnbuf, ! 137: MAXPATHLEN, &ndp->ni_pathlen); ! 138: else ! 139: error = copyinstr(ndp->ni_dirp, cnp->cn_pnbuf, ! 140: MAXPATHLEN, &ndp->ni_pathlen); ! 141: if (error) { ! 142: _FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI); ! 143: ndp->ni_vp = NULL; ! 144: return (error); ! 145: } ! 146: ndp->ni_loopcnt = 0; ! 147: // kprintf("namei: path =%s\n", cnp->cn_pnbuf); ! 148: #if KTRACE ! 149: if (KTRPOINT(cnp->cn_proc, KTR_NAMEI)) ! 150: ktrnamei(cnp->cn_proc->p_tracep, cnp->cn_pnbuf); ! 151: #endif ! 152: ! 153: /* ! 154: * Get starting point for the translation. ! 155: */ ! 156: if ((ndp->ni_rootdir = fdp->fd_rdir) == NULL) ! 157: ndp->ni_rootdir = rootvnode; ! 158: dp = fdp->fd_cdir; ! 159: VREF(dp); ! 160: for (;;) { ! 161: /* ! 162: * Check if root directory should replace current directory. ! 163: * Done at start of translation and after symbolic link. ! 164: */ ! 165: cnp->cn_nameptr = cnp->cn_pnbuf; ! 166: if (*(cnp->cn_nameptr) == '/') { ! 167: vrele(dp); ! 168: while (*(cnp->cn_nameptr) == '/') { ! 169: cnp->cn_nameptr++; ! 170: ndp->ni_pathlen--; ! 171: } ! 172: dp = ndp->ni_rootdir; ! 173: VREF(dp); ! 174: } ! 175: ndp->ni_startdir = dp; ! 176: if (error = lookup(ndp)) { ! 177: FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI); ! 178: return (error); ! 179: } ! 180: /* ! 181: * Check for symbolic link ! 182: */ ! 183: if ((cnp->cn_flags & ISSYMLINK) == 0) { ! 184: if ((cnp->cn_flags & (SAVENAME | SAVESTART)) == 0) { ! 185: FREE_ZONE(cnp->cn_pnbuf, ! 186: cnp->cn_pnlen, M_NAMEI); ! 187: } else { ! 188: cnp->cn_flags |= HASBUF; ! 189: } ! 190: return (0); ! 191: } ! 192: if ((cnp->cn_flags & LOCKPARENT) && ndp->ni_pathlen == 1) ! 193: VOP_UNLOCK(ndp->ni_dvp, 0, p); ! 194: if (ndp->ni_loopcnt++ >= MAXSYMLINKS) { ! 195: error = ELOOP; ! 196: break; ! 197: } ! 198: if (ndp->ni_pathlen > 1) { ! 199: MALLOC_ZONE(cp, char *, MAXPATHLEN, M_NAMEI, M_WAITOK); ! 200: } else { ! 201: cp = cnp->cn_pnbuf; ! 202: } ! 203: aiov.iov_base = cp; ! 204: aiov.iov_len = MAXPATHLEN; ! 205: auio.uio_iov = &aiov; ! 206: auio.uio_iovcnt = 1; ! 207: auio.uio_offset = 0; ! 208: auio.uio_rw = UIO_READ; ! 209: auio.uio_segflg = UIO_SYSSPACE; ! 210: auio.uio_procp = (struct proc *)0; ! 211: auio.uio_resid = MAXPATHLEN; ! 212: if (error = VOP_READLINK(ndp->ni_vp, &auio, cnp->cn_cred)) { ! 213: if (ndp->ni_pathlen > 1) ! 214: _FREE_ZONE(cp, MAXPATHLEN, M_NAMEI); ! 215: break; ! 216: } ! 217: linklen = MAXPATHLEN - auio.uio_resid; ! 218: if (linklen + ndp->ni_pathlen >= MAXPATHLEN) { ! 219: if (ndp->ni_pathlen > 1) ! 220: _FREE_ZONE(cp, MAXPATHLEN, M_NAMEI); ! 221: error = ENAMETOOLONG; ! 222: break; ! 223: } ! 224: if (ndp->ni_pathlen > 1) { ! 225: bcopy(ndp->ni_next, cp + linklen, ndp->ni_pathlen); ! 226: FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI); ! 227: cnp->cn_pnbuf = cp; ! 228: cnp->cn_pnlen = MAXPATHLEN; ! 229: } else ! 230: cnp->cn_pnbuf[linklen] = '\0'; ! 231: ndp->ni_pathlen += linklen; ! 232: vput(ndp->ni_vp); ! 233: dp = ndp->ni_dvp; ! 234: } ! 235: FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI); ! 236: vrele(ndp->ni_dvp); ! 237: vput(ndp->ni_vp); ! 238: ndp->ni_vp = NULL; ! 239: return (error); ! 240: } ! 241: ! 242: /* ! 243: * Search a pathname. ! 244: * This is a very central and rather complicated routine. ! 245: * ! 246: * The pathname is pointed to by ni_ptr and is of length ni_pathlen. ! 247: * The starting directory is taken from ni_startdir. The pathname is ! 248: * descended until done, or a symbolic link is encountered. The variable ! 249: * ni_more is clear if the path is completed; it is set to one if a ! 250: * symbolic link needing interpretation is encountered. ! 251: * ! 252: * The flag argument is LOOKUP, CREATE, RENAME, or DELETE depending on ! 253: * whether the name is to be looked up, created, renamed, or deleted. ! 254: * When CREATE, RENAME, or DELETE is specified, information usable in ! 255: * creating, renaming, or deleting a directory entry may be calculated. ! 256: * If flag has LOCKPARENT or'ed into it, the parent directory is returned ! 257: * locked. If flag has WANTPARENT or'ed into it, the parent directory is ! 258: * returned unlocked. Otherwise the parent directory is not returned. If ! 259: * the target of the pathname exists and LOCKLEAF is or'ed into the flag ! 260: * the target is returned locked, otherwise it is returned unlocked. ! 261: * When creating or renaming and LOCKPARENT is specified, the target may not ! 262: * be ".". When deleting and LOCKPARENT is specified, the target may be ".". ! 263: * ! 264: * Overall outline of lookup: ! 265: * ! 266: * dirloop: ! 267: * identify next component of name at ndp->ni_ptr ! 268: * handle degenerate case where name is null string ! 269: * if .. and crossing mount points and on mounted filesys, find parent ! 270: * call VOP_LOOKUP routine for next component name ! 271: * directory vnode returned in ni_dvp, unlocked unless LOCKPARENT set ! 272: * component vnode returned in ni_vp (if it exists), locked. ! 273: * if result vnode is mounted on and crossing mount points, ! 274: * find mounted on vnode ! 275: * if more components of name, do next level at dirloop ! 276: * return the answer in ni_vp, locked if LOCKLEAF set ! 277: * if LOCKPARENT set, return locked parent in ni_dvp ! 278: * if WANTPARENT set, return unlocked parent in ni_dvp ! 279: */ ! 280: int ! 281: lookup(ndp) ! 282: register struct nameidata *ndp; ! 283: { ! 284: register char *cp; /* pointer into pathname argument */ ! 285: register struct vnode *dp = 0; /* the directory we are searching */ ! 286: struct vnode *tdp; /* saved dp */ ! 287: struct mount *mp; /* mount table entry */ ! 288: int docache; /* == 0 do not cache last component */ ! 289: int wantparent; /* 1 => wantparent or lockparent flag */ ! 290: int rdonly; /* lookup read-only flag bit */ ! 291: int error = 0; ! 292: struct componentname *cnp = &ndp->ni_cnd; ! 293: struct proc *p = cnp->cn_proc; ! 294: int i; ! 295: ! 296: /* ! 297: * Setup: break out flag bits into variables. ! 298: */ ! 299: wantparent = cnp->cn_flags & (LOCKPARENT | WANTPARENT); ! 300: docache = (cnp->cn_flags & NOCACHE) ^ NOCACHE; ! 301: if (cnp->cn_nameiop == DELETE || ! 302: (wantparent && cnp->cn_nameiop != CREATE)) ! 303: docache = 0; ! 304: rdonly = cnp->cn_flags & RDONLY; ! 305: ndp->ni_dvp = NULL; ! 306: cnp->cn_flags &= ~ISSYMLINK; ! 307: dp = ndp->ni_startdir; ! 308: ndp->ni_startdir = NULLVP; ! 309: vn_lock(dp, LK_EXCLUSIVE | LK_RETRY, p); ! 310: ! 311: dirloop: ! 312: /* ! 313: * Search a new directory. ! 314: * ! 315: * The cn_hash value is for use by vfs_cache. ! 316: * The last component of the filename is left accessible via ! 317: * cnp->cn_nameptr for callers that need the name. Callers needing ! 318: * the name set the SAVENAME flag. When done, they assume ! 319: * responsibility for freeing the pathname buffer. ! 320: */ ! 321: cnp->cn_consume = 0; ! 322: cnp->cn_hash = 0; ! 323: for (cp = cnp->cn_nameptr, i=1; *cp != 0 && *cp != '/'; i++, cp++) ! 324: cnp->cn_hash += (unsigned char)*cp * i; ! 325: cnp->cn_namelen = cp - cnp->cn_nameptr; ! 326: if (cnp->cn_namelen > NAME_MAX) { ! 327: error = ENAMETOOLONG; ! 328: goto bad; ! 329: } ! 330: #ifdef NAMEI_DIAGNOSTIC ! 331: { char c = *cp; ! 332: *cp = '\0'; ! 333: printf("{%s}: ", cnp->cn_nameptr); ! 334: *cp = c; } ! 335: #endif ! 336: ndp->ni_pathlen -= cnp->cn_namelen; ! 337: ndp->ni_next = cp; ! 338: cnp->cn_flags |= MAKEENTRY; ! 339: if (*cp == '\0' && docache == 0) ! 340: cnp->cn_flags &= ~MAKEENTRY; ! 341: if (cnp->cn_namelen == 2 && ! 342: cnp->cn_nameptr[1] == '.' && cnp->cn_nameptr[0] == '.') ! 343: cnp->cn_flags |= ISDOTDOT; ! 344: else ! 345: cnp->cn_flags &= ~ISDOTDOT; ! 346: if (*ndp->ni_next == 0) ! 347: cnp->cn_flags |= ISLASTCN; ! 348: else ! 349: cnp->cn_flags &= ~ISLASTCN; ! 350: ! 351: ! 352: /* ! 353: * Check for degenerate name (e.g. / or "") ! 354: * which is a way of talking about a directory, ! 355: * e.g. like "/." or ".". ! 356: */ ! 357: if (cnp->cn_nameptr[0] == '\0') { ! 358: if (dp->v_type != VDIR) { ! 359: error = ENOTDIR; ! 360: goto bad; ! 361: } ! 362: if (cnp->cn_nameiop != LOOKUP) { ! 363: error = EISDIR; ! 364: goto bad; ! 365: } ! 366: if (wantparent) { ! 367: ndp->ni_dvp = dp; ! 368: VREF(dp); ! 369: } ! 370: ndp->ni_vp = dp; ! 371: if (!(cnp->cn_flags & (LOCKPARENT | LOCKLEAF))) ! 372: VOP_UNLOCK(dp, 0, p); ! 373: if (cnp->cn_flags & SAVESTART) ! 374: panic("lookup: SAVESTART"); ! 375: return (0); ! 376: } ! 377: ! 378: /* ! 379: * Handle "..": two special cases. ! 380: * 1. If at root directory (e.g. after chroot) ! 381: * or at absolute root directory ! 382: * then ignore it so can't get out. ! 383: * 2. If this vnode is the root of a mounted ! 384: * filesystem, then replace it with the ! 385: * vnode which was mounted on so we take the ! 386: * .. in the other file system. ! 387: */ ! 388: if (cnp->cn_flags & ISDOTDOT) { ! 389: for (;;) { ! 390: if (dp == ndp->ni_rootdir || dp == rootvnode) { ! 391: ndp->ni_dvp = dp; ! 392: ndp->ni_vp = dp; ! 393: VREF(dp); ! 394: goto nextname; ! 395: } ! 396: if ((dp->v_flag & VROOT) == 0 || ! 397: (cnp->cn_flags & NOCROSSMOUNT)) ! 398: break; ! 399: tdp = dp; ! 400: dp = dp->v_mount->mnt_vnodecovered; ! 401: vput(tdp); ! 402: VREF(dp); ! 403: vn_lock(dp, LK_EXCLUSIVE | LK_RETRY, p); ! 404: } ! 405: } ! 406: ! 407: /* ! 408: * We now have a segment name to search for, and a directory to search. ! 409: */ ! 410: unionlookup: ! 411: ndp->ni_dvp = dp; ! 412: ndp->ni_vp = NULL; ! 413: if (error = VOP_LOOKUP(dp, &ndp->ni_vp, cnp)) { ! 414: #if DIAGNOSTIC ! 415: if (ndp->ni_vp != NULL) ! 416: panic("leaf should be empty"); ! 417: #endif ! 418: #ifdef NAMEI_DIAGNOSTIC ! 419: printf("not found\n"); ! 420: #endif ! 421: if ((error == ENOENT) && ! 422: (dp->v_flag & VROOT) && ! 423: (dp->v_mount->mnt_flag & MNT_UNION)) { ! 424: tdp = dp; ! 425: dp = dp->v_mount->mnt_vnodecovered; ! 426: vput(tdp); ! 427: VREF(dp); ! 428: vn_lock(dp, LK_EXCLUSIVE | LK_RETRY, p); ! 429: goto unionlookup; ! 430: } ! 431: ! 432: if (error != EJUSTRETURN) ! 433: goto bad; ! 434: /* ! 435: * If creating and at end of pathname, then can consider ! 436: * allowing file to be created. ! 437: */ ! 438: if (rdonly) { ! 439: error = EROFS; ! 440: goto bad; ! 441: } ! 442: /* ! 443: * We return with ni_vp NULL to indicate that the entry ! 444: * doesn't currently exist, leaving a pointer to the ! 445: * (possibly locked) directory inode in ndp->ni_dvp. ! 446: */ ! 447: if (cnp->cn_flags & SAVESTART) { ! 448: ndp->ni_startdir = ndp->ni_dvp; ! 449: VREF(ndp->ni_startdir); ! 450: } ! 451: return (0); ! 452: } ! 453: #ifdef NAMEI_DIAGNOSTIC ! 454: printf("found\n"); ! 455: #endif ! 456: ! 457: /* ! 458: * Take into account any additional components consumed by ! 459: * the underlying filesystem. ! 460: */ ! 461: if (cnp->cn_consume > 0) { ! 462: cnp->cn_nameptr += cnp->cn_consume; ! 463: ndp->ni_next += cnp->cn_consume; ! 464: ndp->ni_pathlen -= cnp->cn_consume; ! 465: cnp->cn_consume = 0; ! 466: } ! 467: ! 468: dp = ndp->ni_vp; ! 469: /* ! 470: * Check to see if the vnode has been mounted on; ! 471: * if so find the root of the mounted file system. ! 472: */ ! 473: while (dp->v_type == VDIR && (mp = dp->v_mountedhere) && ! 474: (cnp->cn_flags & NOCROSSMOUNT) == 0) { ! 475: if (vfs_busy(mp, 0, 0, p)) ! 476: continue; ! 477: error = VFS_ROOT(mp, &tdp); ! 478: vfs_unbusy(mp, p); ! 479: if (error) ! 480: goto bad2; ! 481: vput(dp); ! 482: ndp->ni_vp = dp = tdp; ! 483: } ! 484: ! 485: /* ! 486: * Check for symbolic link ! 487: */ ! 488: if ((dp->v_type == VLNK) && ! 489: ((cnp->cn_flags & FOLLOW) || *ndp->ni_next == '/')) { ! 490: cnp->cn_flags |= ISSYMLINK; ! 491: return (0); ! 492: } ! 493: ! 494: nextname: ! 495: /* ! 496: * Not a symbolic link. If more pathname, ! 497: * continue at next component, else return. ! 498: */ ! 499: if (*ndp->ni_next == '/') { ! 500: cnp->cn_nameptr = ndp->ni_next; ! 501: while (*cnp->cn_nameptr == '/') { ! 502: cnp->cn_nameptr++; ! 503: ndp->ni_pathlen--; ! 504: } ! 505: vrele(ndp->ni_dvp); ! 506: goto dirloop; ! 507: } ! 508: /* ! 509: * Disallow directory write attempts on read-only file systems. ! 510: */ ! 511: if (rdonly && ! 512: (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) { ! 513: error = EROFS; ! 514: goto bad2; ! 515: } ! 516: if (cnp->cn_flags & SAVESTART) { ! 517: ndp->ni_startdir = ndp->ni_dvp; ! 518: VREF(ndp->ni_startdir); ! 519: } ! 520: if (!wantparent) ! 521: vrele(ndp->ni_dvp); ! 522: if ((cnp->cn_flags & LOCKLEAF) == 0) ! 523: VOP_UNLOCK(dp, 0, p); ! 524: return (0); ! 525: ! 526: bad2: ! 527: if ((cnp->cn_flags & LOCKPARENT) && *ndp->ni_next == '\0') ! 528: VOP_UNLOCK(ndp->ni_dvp, 0, p); ! 529: vrele(ndp->ni_dvp); ! 530: bad: ! 531: vput(dp); ! 532: ndp->ni_vp = NULL; ! 533: return (error); ! 534: } ! 535: ! 536: /* ! 537: * relookup - lookup a path name component ! 538: * Used by lookup to re-aquire things. ! 539: */ ! 540: int ! 541: relookup(dvp, vpp, cnp) ! 542: struct vnode *dvp, **vpp; ! 543: struct componentname *cnp; ! 544: { ! 545: struct proc *p = cnp->cn_proc; ! 546: struct vnode *dp = 0; /* the directory we are searching */ ! 547: int docache; /* == 0 do not cache last component */ ! 548: int wantparent; /* 1 => wantparent or lockparent flag */ ! 549: int rdonly; /* lookup read-only flag bit */ ! 550: int error = 0; ! 551: #ifdef NAMEI_DIAGNOSTIC ! 552: int newhash; /* DEBUG: check name hash */ ! 553: char *cp; /* DEBUG: check name ptr/len */ ! 554: #endif ! 555: ! 556: /* ! 557: * Setup: break out flag bits into variables. ! 558: */ ! 559: wantparent = cnp->cn_flags & (LOCKPARENT|WANTPARENT); ! 560: docache = (cnp->cn_flags & NOCACHE) ^ NOCACHE; ! 561: if (cnp->cn_nameiop == DELETE || ! 562: (wantparent && cnp->cn_nameiop != CREATE)) ! 563: docache = 0; ! 564: rdonly = cnp->cn_flags & RDONLY; ! 565: cnp->cn_flags &= ~ISSYMLINK; ! 566: dp = dvp; ! 567: vn_lock(dp, LK_EXCLUSIVE | LK_RETRY, p); ! 568: ! 569: /* dirloop: */ ! 570: /* ! 571: * Search a new directory. ! 572: * ! 573: * The cn_hash value is for use by vfs_cache. ! 574: * The last component of the filename is left accessible via ! 575: * cnp->cn_nameptr for callers that need the name. Callers needing ! 576: * the name set the SAVENAME flag. When done, they assume ! 577: * responsibility for freeing the pathname buffer. ! 578: */ ! 579: #ifdef NAMEI_DIAGNOSTIC ! 580: for (newhash = 0, cp = cnp->cn_nameptr; *cp != 0 && *cp != '/'; cp++) ! 581: newhash += (unsigned char)*cp; ! 582: if (newhash != cnp->cn_hash) ! 583: panic("relookup: bad hash"); ! 584: if (cnp->cn_namelen != cp - cnp->cn_nameptr) ! 585: panic ("relookup: bad len"); ! 586: if (*cp != 0) ! 587: panic("relookup: not last component"); ! 588: printf("{%s}: ", cnp->cn_nameptr); ! 589: #endif ! 590: ! 591: /* ! 592: * Check for degenerate name (e.g. / or "") ! 593: * which is a way of talking about a directory, ! 594: * e.g. like "/." or ".". ! 595: */ ! 596: if (cnp->cn_nameptr[0] == '\0') { ! 597: if (cnp->cn_nameiop != LOOKUP || wantparent) { ! 598: error = EISDIR; ! 599: goto bad; ! 600: } ! 601: if (dp->v_type != VDIR) { ! 602: error = ENOTDIR; ! 603: goto bad; ! 604: } ! 605: if (!(cnp->cn_flags & LOCKLEAF)) ! 606: VOP_UNLOCK(dp, 0, p); ! 607: *vpp = dp; ! 608: if (cnp->cn_flags & SAVESTART) ! 609: panic("lookup: SAVESTART"); ! 610: return (0); ! 611: } ! 612: ! 613: if (cnp->cn_flags & ISDOTDOT) ! 614: panic ("relookup: lookup on dot-dot"); ! 615: ! 616: /* ! 617: * We now have a segment name to search for, and a directory to search. ! 618: */ ! 619: if (error = VOP_LOOKUP(dp, vpp, cnp)) { ! 620: #if DIAGNOSTIC ! 621: if (*vpp != NULL) ! 622: panic("leaf should be empty"); ! 623: #endif ! 624: if (error != EJUSTRETURN) ! 625: goto bad; ! 626: /* ! 627: * If creating and at end of pathname, then can consider ! 628: * allowing file to be created. ! 629: */ ! 630: if (rdonly) { ! 631: error = EROFS; ! 632: goto bad; ! 633: } ! 634: /* ASSERT(dvp == ndp->ni_startdir) */ ! 635: if (cnp->cn_flags & SAVESTART) ! 636: VREF(dvp); ! 637: /* ! 638: * We return with ni_vp NULL to indicate that the entry ! 639: * doesn't currently exist, leaving a pointer to the ! 640: * (possibly locked) directory inode in ndp->ni_dvp. ! 641: */ ! 642: return (0); ! 643: } ! 644: dp = *vpp; ! 645: ! 646: #if DIAGNOSTIC ! 647: /* ! 648: * Check for symbolic link ! 649: */ ! 650: if (dp->v_type == VLNK && (cnp->cn_flags & FOLLOW)) ! 651: panic ("relookup: symlink found.\n"); ! 652: #endif ! 653: ! 654: /* ! 655: * Disallow directory write attempts on read-only file systems. ! 656: */ ! 657: if (rdonly && ! 658: (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) { ! 659: error = EROFS; ! 660: goto bad2; ! 661: } ! 662: /* ASSERT(dvp == ndp->ni_startdir) */ ! 663: if (cnp->cn_flags & SAVESTART) ! 664: VREF(dvp); ! 665: ! 666: if (!wantparent) ! 667: vrele(dvp); ! 668: if ((cnp->cn_flags & LOCKLEAF) == 0) ! 669: VOP_UNLOCK(dp, 0, p); ! 670: return (0); ! 671: ! 672: bad2: ! 673: if ((cnp->cn_flags & LOCKPARENT) && (cnp->cn_flags & ISLASTCN)) ! 674: VOP_UNLOCK(dvp, 0, p); ! 675: vrele(dvp); ! 676: bad: ! 677: vput(dp); ! 678: *vpp = NULL; ! 679: return (error); ! 680: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.