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