![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hfs_lookup.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / hfs|
Return to hfs_lookup.c CVS log | Up to [Apple XNU] / XNU / bsd / hfs |
1.1 ! root 1: /* ! 2: * Copyright (c) 1999 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: /* ! 23: * Copyright (c) 1989, 1993 ! 24: * The Regents of the University of California. All rights reserved. ! 25: * (c) UNIX System Laboratories, Inc. ! 26: * All or some portions of this file are derived from material licensed ! 27: * to the University of California by American Telephone and Telegraph ! 28: * Co. or Unix System Laboratories, Inc. and are reproduced herein with ! 29: * the permission of UNIX System Laboratories, Inc. ! 30: * ! 31: * Redistribution and use in source and binary forms, with or without ! 32: * modification, are permitted provided that the following conditions ! 33: * are met: ! 34: * 1. Redistributions of source code must retain the above copyright ! 35: * notice, this list of conditions and the following disclaimer. ! 36: * 2. Redistributions in binary form must reproduce the above copyright ! 37: * notice, this list of conditions and the following disclaimer in the ! 38: * documentation and/or other materials provided with the distribution. ! 39: * 3. All advertising materials mentioning features or use of this software ! 40: * must display the following acknowledgement: ! 41: * This product includes software developed by the University of ! 42: * California, Berkeley and its contributors. ! 43: * 4. Neither the name of the University nor the names of its contributors ! 44: * may be used to endorse or promote products derived from this software ! 45: * without specific prior written permission. ! 46: * ! 47: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 48: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 49: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 50: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 51: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 52: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 53: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 54: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 55: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 56: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 57: * SUCH DAMAGE. ! 58: * ! 59: * @(#)hfs_lookup.c 1.0 ! 60: * derived from @(#)ufs_lookup.c 8.15 (Berkeley) 6/16/95 ! 61: * ! 62: * (c) 1998-1999 Apple Computer, Inc. All Rights Reserved ! 63: * (c) 1990, 1992 NeXT Computer, Inc. All Rights Reserved ! 64: * ! 65: * ! 66: * hfs_lookup.c -- code to handle directory traversal on HFS/HFS+ volume ! 67: * ! 68: * MODIFICATION HISTORY: ! 69: * 21-May-1999 Don Brady Add support for HFS rooting. ! 70: * 25-Feb-1999 Clark Warner Fixed the error case of VFS_VGGET when ! 71: * processing DotDot (..) to relock parent ! 72: * 23-Feb-1999 Pat Dirks Finish cleanup around Don's last fix in "." and ".." handling. ! 73: * 11-Nov-1998 Don Brady Take out VFS_VGET that got added as part of previous fix. ! 74: * 14-Oct-1998 Don Brady Fix locking policy volation in hfs_lookup for ".." case ! 75: * (radar #2279902). ! 76: * 4-Jun-1998 Pat Dirks Split off from hfs_vnodeops.c ! 77: */ ! 78: ! 79: #include <sys/param.h> ! 80: #include <sys/namei.h> ! 81: #include <sys/buf.h> ! 82: #include <sys/file.h> ! 83: #include <sys/mount.h> ! 84: #include <sys/vnode.h> ! 85: #include <paths.h> ! 86: ! 87: #include "hfs.h" ! 88: #include "hfs_dbg.h" ! 89: #include "hfscommon/headers/FileMgrInternal.h" ! 90: ! 91: u_int16_t GetForkFromName(struct componentname *cnp); ! 92: int hfs_vget_sibling(struct vnode *vdp, u_int16_t forkType, struct vnode **vpp); ! 93: int hfs_vget_catinfo(struct vnode *parent_vp, struct hfsCatalogInfo *catInfo, u_int32_t forkType, struct vnode **target_vpp); ! 94: ! 95: /* ! 96: * XXX SER fork strings. ! 97: * Put these someplace better ! 98: */ ! 99: #define gHFSForkIdentStr "/" ! 100: #define gDataForkNameStr "data" ! 101: #define gRsrcForkNameStr "rsrc" ! 102: ! 103: ! 104: extern int cache_lookup(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp); ! 105: extern void cache_enter(struct vnode *dvp, struct vnode *vp, struct componentname *cnp); ! 106: ! 107: #if DBG_VOP_TEST_LOCKS ! 108: extern void DbgVopTest(int maxSlots, int retval, VopDbgStoreRec *VopDbgStore, char *funcname); ! 109: #endif ! 110: ! 111: /***************************************************************************** ! 112: * ! 113: * Operations on vnodes ! 114: * ! 115: *****************************************************************************/ ! 116: ! 117: ! 118: /* ! 119: * FROM FREEBSD 3.1 ! 120: * Convert a component of a pathname into a pointer to a locked hfsnode. ! 121: * This is a very central and rather complicated routine. ! 122: * If the file system is not maintained in a strict tree hierarchy, ! 123: * this can result in a deadlock situation (see comments in code below). ! 124: * ! 125: * The cnp->cn_nameiop argument is LOOKUP, CREATE, RENAME, or DELETE depending ! 126: * on whether the name is to be looked up, created, renamed, or deleted. ! 127: * When CREATE, RENAME, or DELETE is specified, information usable in ! 128: * creating, renaming, or deleting a directory entry may be calculated. ! 129: * Notice that these are the only operations that can affect the directory of the target. ! 130: * ! 131: * If flag has LOCKPARENT or'ed into it and the target of the pathname ! 132: * exists, lookup returns both the target and its parent directory locked. ! 133: * When creating or renaming and LOCKPARENT is specified, the target may ! 134: * not be ".". When deleting and LOCKPARENT is specified, the target may ! 135: * be "."., but the caller must check to ensure it does an vrele and vput ! 136: * instead of two vputs. ! 137: * ! 138: * LOCKPARENT and WANTPARENT actually refer to the parent of the last item, ! 139: * so if ISLASTCN is not set, they should be ignored. Also they are mutually exclusive, or ! 140: * WANTPARENT really implies DONTLOCKPARENT. Either of them set means that the calling ! 141: * routine wants to access the parent of the target, locked or unlocked. ! 142: * ! 143: * Keeping the parent locked as long as possible protects from other processes ! 144: * looking up the same item, so it has to be locked until the hfsnode is totally finished ! 145: * ! 146: * This routine is actually used as VOP_CACHEDLOOKUP method, and the ! 147: * filesystem employs the generic hfs_cache_lookup() as VOP_LOOKUP ! 148: * method. ! 149: * ! 150: * hfs_cache_lookup() performs the following for us: ! 151: * check that it is a directory ! 152: * check accessibility of directory ! 153: * check for modification attempts on read-only mounts ! 154: * if name found in cache ! 155: * if at end of path and deleting or creating ! 156: * drop it ! 157: * else ! 158: * return name. ! 159: * return VOP_CACHEDLOOKUP() ! 160: * ! 161: * Overall outline of hfs_lookup: ! 162: * ! 163: * handle simple cases of . and .. ! 164: * search for name in directory, to found or notfound ! 165: * notfound: ! 166: * if creating, return locked directory, leaving info on available slots ! 167: * else return error ! 168: * found: ! 169: * if at end of path and deleting, return information to allow delete ! 170: * if at end of path and rewriting (RENAME and LOCKPARENT), lock target ! 171: * inode and return info to allow rewrite ! 172: * if not at end, add name to cache; if at end and neither creating ! 173: * nor deleting, add name to cache ! 174: */ ! 175: ! 176: /* ! 177: * Lookup *nm in directory *pvp, return it in *a_vpp. ! 178: * **a_vpp is held on exit. ! 179: * We create a hfsnode for the file, but we do NOT open the file here. ! 180: ! 181: #% lookup dvp L ? ? ! 182: #% lookup vpp - L - ! 183: ! 184: IN struct vnode *dvp - Parent node of file; ! 185: INOUT struct vnode **vpp - node of target file, its a new node if the target vnode did not exist; ! 186: IN struct componentname *cnp - Name of file; ! 187: ! 188: * When should we lock parent_hp in here ?? ! 189: */ ! 190: ! 191: int ! 192: hfs_lookup(ap) ! 193: struct vop_cachedlookup_args /* { ! 194: struct vnode *a_dvp; ! 195: struct vnode **a_vpp; ! 196: struct componentname *a_cnp; ! 197: } */ *ap; ! 198: { ! 199: struct vnode *parent_vp; ! 200: struct vnode *target_vp; ! 201: struct vnode *tparent_vp; ! 202: struct hfsnode *parent_hp; /* parent */ ! 203: struct componentname *cnp; ! 204: struct ucred *cred; ! 205: struct proc *p; ! 206: struct hfsCatalogInfo catInfo; ! 207: u_int32_t parent_id; ! 208: u_int32_t nodeID; ! 209: u_int16_t targetLen; ! 210: u_int16_t forkType; ! 211: int flags; ! 212: int lockparent; /* !0 => lockparent flag is set */ ! 213: int wantparent; /* !0 => wantparent or lockparent flag */ ! 214: int nameiop; ! 215: int retval; ! 216: u_char isDot, isDotDot, found; ! 217: DBG_FUNC_NAME("lookup"); ! 218: DBG_VOP_LOCKS_DECL(2); ! 219: DBG_VOP_LOCKS_INIT(0,ap->a_dvp, VOPDBG_LOCKED, VOPDBG_IGNORE, VOPDBG_IGNORE, VOPDBG_POS); ! 220: DBG_VOP_LOCKS_INIT(1,*ap->a_vpp, VOPDBG_IGNORE, VOPDBG_LOCKED, VOPDBG_IGNORE, VOPDBG_POS); ! 221: DBG_VOP_PRINT_FUNCNAME();DBG_VOP_CONT(("\n")); ! 222: DBG_HFS_NODE_CHECK(ap->a_dvp); ! 223: ! 224: ! 225: /* ! 226: * Do initial setup ! 227: */ ! 228: parent_vp = ap->a_dvp; ! 229: cnp = ap->a_cnp; ! 230: parent_hp = VTOH(parent_vp); /* parent */ ! 231: target_vp = NULL; ! 232: targetLen = cnp->cn_namelen; ! 233: nameiop = cnp->cn_nameiop; ! 234: cred = cnp->cn_cred; ! 235: p = cnp->cn_proc; ! 236: lockparent = cnp->cn_flags & LOCKPARENT; ! 237: wantparent = cnp->cn_flags & (LOCKPARENT|WANTPARENT); ! 238: flags = cnp->cn_flags; ! 239: parent_id = H_FILEID(parent_hp); ! 240: nodeID = kUnknownID; ! 241: found = FALSE; ! 242: isDot = FALSE; ! 243: isDotDot = FALSE; ! 244: catInfo.hint = 0; ! 245: retval = E_NONE; ! 246: forkType = kUndefinedFork; ! 247: ! 248: ! 249: ! 250: /* ! 251: * We now have a segment name to search for, and a directory to search. ! 252: * ! 253: */ ! 254: ! 255: /* ! 256: * First check to see if it is a . or .., else look it up. ! 257: */ ! 258: ! 259: if (flags & ISDOTDOT) { /* Wanting the parent */ ! 260: isDotDot = TRUE; ! 261: found = TRUE; /* .. is always defined */ ! 262: nodeID = H_DIRID(parent_hp); ! 263: } /* Wanting ourselves */ ! 264: else if ((cnp->cn_nameptr[0] == '.') && (targetLen == 1)) { ! 265: isDot = TRUE; ! 266: found = TRUE; /* We always know who we are */ ! 267: } ! 268: else { /* Wanting something else */ ! 269: /* lock catalog b-tree */ ! 270: retval = hfs_metafilelocking(VTOHFS(parent_vp), kHFSCatalogFileID, LK_SHARED, p); ! 271: if (retval) ! 272: goto Err_Exit; ! 273: ! 274: catInfo.hint = kNoHint; ! 275: retval = hfsLookup (VTOVCB(parent_vp), parent_id, cnp->cn_nameptr, targetLen, &catInfo); ! 276: ! 277: /* unlock catalog b-tree */ ! 278: (void) hfs_metafilelocking(VTOHFS(parent_vp), kHFSCatalogFileID, LK_RELEASE, p); ! 279: ! 280: if (retval == E_NONE) ! 281: found = TRUE; ! 282: }; ! 283: ! 284: ! 285: /* ! 286: * At this point we know IF we have a valid dir/name. ! 287: */ ! 288: ! 289: ! 290: retval = E_NONE; ! 291: if (! found) { ! 292: /* ! 293: * This is a non-existing entry ! 294: * ! 295: * If creating, and at end of pathname and current ! 296: * directory has not been removed, then can consider ! 297: * allowing file to be created. ! 298: */ ! 299: if ((nameiop == CREATE || nameiop == RENAME || ! 300: (nameiop == DELETE && ! 301: (ap->a_cnp->cn_flags & DOWHITEOUT) && ! 302: (ap->a_cnp->cn_flags & ISWHITEOUT))) && ! 303: (flags & ISLASTCN)) { ! 304: /* ! 305: * Access for write is interpreted as allowing ! 306: * creation of files in the directory. ! 307: */ ! 308: retval = VOP_ACCESS(parent_vp, VWRITE, cred, cnp->cn_proc); ! 309: if (retval) ! 310: return (retval); ! 311: ! 312: cnp->cn_flags |= SAVENAME; ! 313: if (!lockparent) ! 314: VOP_UNLOCK(parent_vp, 0, p); ! 315: retval = EJUSTRETURN; ! 316: goto Err_Exit; ! 317: } ! 318: ! 319: /* ! 320: * Insert name into cache (as non-existent) if appropriate. ! 321: */ ! 322: ! 323: /* ! 324: * XXX SER - Here we would store the name in cache as non-existant if not trying to create it, but, ! 325: * the name cache IS case-sensitive, thus maybe showing a negative hit, when the name ! 326: * is only different by case. So hfs does not support negative caching. Something to look at. ! 327: * (See radar 2293594 for a failed example) ! 328: if ((cnp->cn_flags & MAKEENTRY) && nameiop != CREATE) ! 329: cache_enter(parent_vp, *vpp, cnp); ! 330: */ ! 331: ! 332: retval = ENOENT; ! 333: } ! 334: else { ! 335: /* ! 336: * We have found an entry ! 337: * ! 338: * Here we have to decide what type of vnode to create. ! 339: * There are 3 type of objects that are given: ! 340: * 1. '.': return the same dp ! 341: * 2. '..' return the parent of dp, always a VDIR ! 342: * 3. catinfo rec: return depending on type: ! 343: * A. VDIR, nodeType is kCatalogFolderNode ! 344: * B. VLINK nodeType is kCatalogFileNode, the mode is IFLNK (esp. if it is a link to a directory e.g. bar/link/foo) ! 345: * C. VREG, nodeType is kCatalogFileNode, forkType at this point is unknown ! 346: * To determine the forkType, we can use this algorithm (\0 in the strings mean the NULL character): ! 347: * a. forkType is kDataType iff ISLASTCN is set (as in the case of the default fork e.g. data/foo). ! 348: * b. forkType is kDataType iff ISLASTCN is not set and the namePtr is followed by "/?AppleHFSFork/data\0" ! 349: * c. forkType is kRsrcType iff ISLASTCN is not set and the namePtr is followed by "/?AppleHFSFork/rsrc\0" ! 350: * If the latter two are correct, then we 'consume' the remaining of the name buffer ! 351: * and set the cnp as appropriate. ! 352: * Anything else returns an retval ! 353: */ ! 354: ! 355: ! 356: /* ! 357: * If deleting, and at end of pathname, return ! 358: * parameters which can be used to remove file. ! 359: * If the wantparent flag isn't set, we return only ! 360: * the directory (in ndp->ndvp), otherwise we go ! 361: * on and lock the hfsnode, being careful with ".". ! 362: * ! 363: * Forks cannot be deleted so scan-ahead is illegal, so just return the default fork ! 364: */ ! 365: if (nameiop == DELETE && (flags & ISLASTCN)) { ! 366: /* ! 367: * Write access to directory required to delete files. ! 368: */ ! 369: retval = VOP_ACCESS(parent_vp, VWRITE, cred, cnp->cn_proc); ! 370: if (retval) ! 371: goto Err_Exit; ! 372: ! 373: if (isDot) { /* Want to return ourselves */ ! 374: VREF(parent_vp); ! 375: target_vp = parent_vp; ! 376: goto Err_Exit; ! 377: } ! 378: else if (isDotDot) { ! 379: retval = VFS_VGET(parent_vp->v_mount, &nodeID, &target_vp); ! 380: if (retval) ! 381: goto Err_Exit; ! 382: } ! 383: else { ! 384: retval = hfs_vget_catinfo(parent_vp, &catInfo, kAnyFork, &target_vp); ! 385: if (retval) ! 386: goto Err_Exit; ! 387: }; ! 388: ! 389: ! 390: /* ! 391: * If directory is "sticky", then user must own ! 392: * the directory, or the file in it, else she ! 393: * may not delete it (unless she's root). This ! 394: * implements append-only directories. ! 395: */ ! 396: if ((parent_hp->h_meta->h_mode & ISVTX) && ! 397: cred->cr_uid != 0 && ! 398: cred->cr_uid != parent_hp->h_meta->h_uid && ! 399: target_vp->v_type != VLNK && ! 400: VTOH(target_vp)->h_meta->h_uid != cred->cr_uid) { ! 401: VPUT(target_vp); ! 402: retval = EPERM; ! 403: goto Err_Exit; ! 404: } ! 405: #if HFS_HARDLINKS ! 406: /* ! 407: * If this is a link node then we need to save the name ! 408: * (of the link) so we can delete it from the catalog b-tree. ! 409: * In this case, hfs_remove will then free the component name. ! 410: */ ! 411: if (target_vp && (VTOH(target_vp)->h_meta->h_metaflags & IN_DATANODE)) ! 412: cnp->cn_flags |= SAVENAME; ! 413: #endif ! 414: ! 415: if (!lockparent) ! 416: VOP_UNLOCK(parent_vp, 0, p); ! 417: goto Err_Exit; ! 418: }; ! 419: ! 420: /* ! 421: * If rewriting 'RENAME', return the hfsnode and the ! 422: * information required to rewrite the present directory ! 423: */ ! 424: if (nameiop == RENAME && wantparent && (cnp->cn_flags & ISLASTCN)) { ! 425: ! 426: if ((retval = VOP_ACCESS(parent_vp, VWRITE, cred, cnp->cn_proc)) != 0) ! 427: goto Err_Exit; ! 428: ! 429: /* ! 430: * Careful about locking second inode. ! 431: * This can only occur if the target is ".". like 'mv foo/bar foo/.' ! 432: */ ! 433: if (isDot) { ! 434: retval = EISDIR; ! 435: goto Err_Exit; ! 436: } ! 437: else if (isDotDot) { ! 438: retval = VFS_VGET(parent_vp->v_mount, &nodeID, &target_vp); ! 439: if (retval) ! 440: goto Err_Exit; ! 441: } ! 442: else { ! 443: /* If then name differs in case, then act like it does not exist ! 444: * This allows renaming foo->Foo ! 445: */ ! 446: if (strncmp(cnp->cn_nameptr, catInfo.spec.name, targetLen)) { ! 447: if (!lockparent) ! 448: VOP_UNLOCK(parent_vp, 0, p); ! 449: retval = EJUSTRETURN; ! 450: goto Err_Exit; ! 451: }; ! 452: ! 453: retval = hfs_vget_catinfo(parent_vp, &catInfo, kAnyFork, &target_vp); ! 454: if (retval) ! 455: goto Err_Exit; ! 456: }; ! 457: ! 458: cnp->cn_flags |= SAVENAME; ! 459: if (!lockparent) ! 460: VOP_UNLOCK(parent_vp, 0, p); ! 461: goto Err_Exit; ! 462: /* Finished...all is well, goto the end */ ! 463: }; ! 464: ! 465: /* ! 466: * Step through the translation in the name. We do not `vput' the ! 467: * directory because we may need it again if a symbolic link ! 468: * is relative to the current directory. Instead we save it ! 469: * unlocked as "tparent_vp". We must get the target hfsnode before unlocking ! 470: * the directory to insure that the hfsnode will not be removed ! 471: * before we get it. We prevent deadlock by always fetching ! 472: * inodes from the root, moving down the directory tree. Thus ! 473: * when following backward pointers ".." we must unlock the ! 474: * parent directory before getting the requested directory. ! 475: * There is a potential race condition here if both the current ! 476: * and parent directories are removed before the VFS_VGET for the ! 477: * hfsnode associated with ".." returns. We hope that this occurs ! 478: * infrequently since we cannot avoid this race condition without ! 479: * implementing a sophisticated deadlock detection algorithm. ! 480: * Note also that this simple deadlock detection scheme will not ! 481: * work if the file system has any hard links other than ".." ! 482: * that point backwards in the directory structure. ! 483: */ ! 484: ! 485: tparent_vp = parent_vp; ! 486: if (isDotDot) { ! 487: VOP_UNLOCK(tparent_vp, 0, p); /* race to get the inode */ ! 488: if ((retval = VFS_VGET(parent_vp->v_mount, &nodeID, &target_vp))) { ! 489: vn_lock(tparent_vp, LK_EXCLUSIVE | LK_RETRY, p); ! 490: goto Err_Exit; ! 491: } ! 492: if (lockparent && (flags & ISLASTCN) && ! 493: (retval = vn_lock(tparent_vp, LK_EXCLUSIVE, p))) { ! 494: vput(target_vp); ! 495: goto Err_Exit; ! 496: } ! 497: } ! 498: else if (isDot) { ! 499: VREF(parent_vp); /* we want ourself, ie "." */ ! 500: target_vp = parent_vp; ! 501: } ! 502: else { ! 503: mode_t mode; ! 504: /* ! 505: * Determine what fork to get, currenty 3 scenarios are supported: ! 506: * 1. ./foo: if it is a dir, return a VDIR else return data fork ! 507: * 2. ./foo/.__Fork/data: return data fork ! 508: * 3. ./foo/.__Fork/rsrc: return resource fork ! 509: * So the algorithm is: ! 510: * If the object is a directory ! 511: * then return a VDIR vnode ! 512: * else if ISLASTCN is true ! 513: * then get the vnode with forkType=kDataFork ! 514: * else ! 515: * compare with the remaining cnp buffer with "/.__Fork/" ! 516: * if a match ! 517: * then compare string after that with either 'data' or 'rsrc' ! 518: * if match ! 519: * then ! 520: * 'consume' rest of cnp, setting appropriate values and flags ! 521: * return vnode depending on match ! 522: * else ! 523: * bad fork name ! 524: * else ! 525: * illegal path after a file object ! 526: */ ! 527: ! 528: mode = (mode_t)(catInfo.nodeData.cnd_permissions & 0x0000FFFF); ! 529: ! 530: if (catInfo.nodeData.cnd_type == kCatalogFolderNode) { ! 531: forkType = kDirectory; /* Really ignored */ ! 532: } ! 533: else if ((mode & IFMT) == IFLNK) { ! 534: forkType = kDataFork; ! 535: } /* After this point, nodeType should be a file */ ! 536: else if (flags & ISLASTCN) { /* Create a default fork */ ! 537: forkType = kDataFork; ! 538: } ! 539: else { /* determine what fork was specified */ ! 540: forkType = GetForkFromName(cnp); ! 541: flags |= ISLASTCN; /* To know to unlock the parent if needed */ ! 542: }; /* else */ ! 543: ! 544: ! 545: /* If couldn't determine what type of fork, leave */ ! 546: if (forkType == kUndefinedFork) { ! 547: retval = EISDIR; ! 548: goto Err_Exit; ! 549: }; ! 550: ! 551: /* Get the vnode now that what type of fork is known */ ! 552: DBG_ASSERT((forkType==kDirectory) || (forkType==kDataFork) || (forkType==kRsrcFork)); ! 553: retval = hfs_vget_catinfo(tparent_vp, &catInfo, forkType, &target_vp); ! 554: if (retval != E_NONE) ! 555: goto Err_Exit; ! 556: ! 557: if (!lockparent || !(flags & ISLASTCN)) ! 558: VOP_UNLOCK(tparent_vp, 0, p); ! 559: ! 560: }; /* else found */ ! 561: ! 562: ! 563: /* ! 564: * Insert name in cache if wanted. ! 565: */ ! 566: if (cnp->cn_flags & MAKEENTRY) { ! 567: /* ! 568: * XXX SER - Might be good idea to bcopy(catInfo.nodeData.fsspec.name, cnp->cn_nameptr) ! 569: * to "normalize" the name cache. This will avoid polluting the name cache with ! 570: * names that are different in case, and allow negative caching ! 571: */ ! 572: cache_enter(parent_vp, target_vp, cnp); ! 573: } ! 574: ! 575: ! 576: }; /* else found == TRUE */ ! 577: ! 578: Err_Exit: ! 579: ! 580: *ap->a_vpp = target_vp; ! 581: ! 582: DBG_VOP_UPDATE_VP(1, *ap->a_vpp); ! 583: DBG_VOP_LOOKUP_TEST (funcname, cnp, parent_vp, target_vp); ! 584: DBG_VOP_LOCKS_TEST(E_NONE); ! 585: DBG_VOP_PRINT_FUNCNAME(); ! 586: if (retval == E_NONE) { ! 587: DBG_VOP_CONT(("Success\n")); ! 588: } else { ! 589: DBG_VOP_CONT(("Fails\n")); ! 590: } ! 591: ! 592: return (retval); ! 593: } ! 594: ! 595: ! 596: ! 597: /* ! 598: * Based on vn_cache_lookup (which is vfs_cache_lookup in FreeBSD 3.1) ! 599: * ! 600: * Name caching works as follows: ! 601: * ! 602: * Names found by directory scans are retained in a cache ! 603: * for future reference. It is managed LRU, so frequently ! 604: * used names will hang around. Cache is indexed by hash value ! 605: * obtained from (vp, name) where vp refers to the directory ! 606: * containing name. ! 607: * ! 608: * If it is a "negative" entry, (i.e. for a name that is known NOT to ! 609: * exist) the vnode pointer will be NULL. ! 610: * ! 611: * Upon reaching the last segment of a path, if the reference ! 612: * is for DELETE, or NOCACHE is set (rewrite), and the ! 613: * name is located in the cache, it will be dropped. ! 614: * ! 615: * In hfs, since a name can represent multiple forks, it cannot ! 616: * be known what fork the name matches, so further checks have to be done. ! 617: * Currently a policy of first requested, is the one stored, is followed. ! 618: * ! 619: * SER XXX If this proves inadequate maybe we can munge the name to contain a fork reference ! 620: * like foo -> foo.d for the data fork. ! 621: */ ! 622: ! 623: int ! 624: hfs_cache_lookup(ap) ! 625: struct vop_lookup_args /* { ! 626: struct vnode *a_dvp; ! 627: struct vnode **a_vpp; ! 628: struct componentname *a_cnp; ! 629: } */ *ap; ! 630: { ! 631: struct vnode *vdp; ! 632: struct vnode *pdp; ! 633: int lockparent; ! 634: int error; ! 635: struct vnode **vpp = ap->a_vpp; ! 636: struct componentname *cnp = ap->a_cnp; ! 637: struct ucred *cred = cnp->cn_cred; ! 638: int flags = cnp->cn_flags; ! 639: struct proc *p = cnp->cn_proc; ! 640: struct hfsnode *hp; ! 641: u_int32_t vpid; /* capability number of vnode */ ! 642: DBG_FUNC_NAME("cache_lookup"); ! 643: DBG_VOP_LOCKS_DECL(2); ! 644: DBG_VOP_LOCKS_INIT(0,ap->a_dvp, VOPDBG_LOCKED, VOPDBG_IGNORE, VOPDBG_IGNORE, VOPDBG_POS); ! 645: DBG_VOP_LOCKS_INIT(1,*ap->a_vpp, VOPDBG_IGNORE, VOPDBG_LOCKED, VOPDBG_IGNORE, VOPDBG_POS); ! 646: DBG_VOP_PRINT_FUNCNAME();DBG_VOP_CONT(("\n")); ! 647: DBG_VOP_CONT(("\tTarget: "));DBG_VOP_PRINT_CPN_INFO(ap->a_cnp);DBG_VOP_CONT(("\n")); ! 648: DBG_HFS_NODE_CHECK(ap->a_dvp); ! 649: ! 650: *vpp = NULL; ! 651: vdp = ap->a_dvp; ! 652: lockparent = flags & LOCKPARENT; ! 653: ! 654: if (vdp->v_type != VDIR) ! 655: return (ENOTDIR); ! 656: ! 657: if ((flags & ISLASTCN) && (vdp->v_mount->mnt_flag & MNT_RDONLY) && ! 658: (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) ! 659: return (EROFS); ! 660: ! 661: error = VOP_ACCESS(vdp, VEXEC, cred, cnp->cn_proc); ! 662: ! 663: if (error) ! 664: return (error); ! 665: ! 666: /* ! 667: * Lookup an entry in the cache ! 668: * If the lookup succeeds, the vnode is returned in *vpp, and a status of -1 is ! 669: * returned. If the lookup determines that the name does not exist ! 670: * (negative cacheing), a status of ENOENT is returned. If the lookup ! 671: * fails, a status of zero is returned. ! 672: */ ! 673: error = cache_lookup(vdp, vpp, cnp); ! 674: ! 675: if (error == 0) { /* Unsuccessfull */ ! 676: DBG_VOP(("\tWas not in name cache\n")); ! 677: error = hfs_lookup(ap); ! 678: #if HFS_HARDLINKS ! 679: if (error) ! 680: return (error); ! 681: /* ! 682: * If this is a hard-link vnode then we need to update ! 683: * the name (of the link) and update the parent ID. This ! 684: * enables getattrlist calls to return correct link info. ! 685: */ ! 686: hp = VTOH(*ap->a_vpp); ! 687: if ((flags & ISLASTCN) && (hp->h_meta->h_metaflags & IN_DATANODE)) { ! 688: H_DIRID(hp) = H_FILEID(VTOH(ap->a_dvp)); ! 689: hfs_set_metaname(cnp->cn_nameptr, hp->h_meta); ! 690: } ! 691: #endif ! 692: return (error); ! 693: }; ! 694: ! 695: DBG_VOP(("\tName was found in the name cache")); ! 696: if (error == ENOENT) { ! 697: DBG_VOP_CONT((" though it was a NEGATIVE HIT\n")); ! 698: return (error); ! 699: }; ! 700: DBG_VOP_CONT(("\n")); ! 701: ! 702: #if HFS_HARDLINKS ! 703: /* ! 704: * If this is a hard-link vnode then we need to update ! 705: * the name (of the link) and update the parent ID. This ! 706: * enables getattrlist calls to return correct link info. ! 707: */ ! 708: hp = VTOH(*vpp); ! 709: if ((flags & ISLASTCN) && (hp->h_meta->h_metaflags & IN_DATANODE)) { ! 710: H_DIRID(hp) = H_FILEID(VTOH(vdp)); ! 711: hfs_set_metaname(cnp->cn_nameptr, hp->h_meta); ! 712: } ! 713: #endif ! 714: ! 715: /* We have a name that matched */ ! 716: pdp = vdp; ! 717: vdp = *vpp; ! 718: vpid = vdp->v_id; ! 719: if (pdp == vdp) { /* lookup on "." */ ! 720: VREF(vdp); ! 721: error = 0; ! 722: } else if (flags & ISDOTDOT) { ! 723: /* ! 724: * Carefull on the locking policy, ! 725: * remember we always lock from parent to child, so have ! 726: * to release lock on child before trying to lock parent ! 727: * then regain lock if needed ! 728: */ ! 729: VOP_UNLOCK(pdp, 0, p); ! 730: error = vget(vdp, LK_EXCLUSIVE, p); ! 731: if (!error && lockparent && (flags & ISLASTCN)) ! 732: error = vn_lock(pdp, LK_EXCLUSIVE, p); ! 733: } else { ! 734: /* ! 735: * Check to see if a specific fork is not being requested. ! 736: * ! 737: * If it is a file and not the last path item ! 738: * then check if its a proper fork ! 739: * If it is, check to see if the matched vnode is the same fork ! 740: * else see if the proper fork exists. ! 741: * If it does, return that one, else do VOP_CACHEDLOOKUP() ! 742: * Notice that nothing is done if an undefined fork is named. Just leave and let lookup() ! 743: * handle strange cases. ! 744: * ! 745: * XXX SER Notice that when the target is not what was in the name cache, ! 746: * it is locked, before trying to get its sibling. Could this be a problem since both ! 747: * siblings can be locked, but not in a determinalistic order???? ! 748: */ ! 749: u_int16_t forkType; ! 750: ! 751: error = vget(vdp, LK_EXCLUSIVE, p); ! 752: if ((! error) && (vdp->v_type == VREG) && (vpid == vdp->v_id)) { ! 753: if (!(flags & ISLASTCN)) { ! 754: forkType = GetForkFromName(cnp); ! 755: if (forkType != kUndefinedFork) { ! 756: flags |= ISLASTCN; ! 757: if (H_FORKTYPE(VTOH(vdp)) != forkType) { ! 758: error = hfs_vget_sibling(vdp, forkType, vpp); ! 759: vput(vdp); ! 760: if (! error) { ! 761: vdp = *vpp; ! 762: vpid = vdp->v_id; ! 763: } ! 764: } ! 765: } ! 766: } ! 767: else { ! 768: /* Its the last item, so we want the data fork */ ! 769: if (H_FORKTYPE(VTOH(vdp)) != kDataFork) { ! 770: error = hfs_vget_sibling(vdp, kDataFork, vpp); ! 771: vput(vdp); ! 772: if (! error) { ! 773: vdp = *vpp; ! 774: vpid = vdp->v_id; ! 775: } ! 776: } ! 777: }; ! 778: }; ! 779: if (!lockparent || error || !(flags & ISLASTCN)) ! 780: VOP_UNLOCK(pdp, 0, p); ! 781: }; ! 782: /* ! 783: * Check that the capability number did not change ! 784: * while we were waiting for the lock. ! 785: */ ! 786: if (!error) { ! 787: if (vpid == vdp->v_id) ! 788: return (0); /* HERE IS THE NORMAL EXIT FOR CACHE LOOKUP!!!! */ ! 789: /* ! 790: * The above is the NORMAL exit, after this point is an error ! 791: * condition. ! 792: */ ! 793: vput(vdp); ! 794: if (lockparent && pdp != vdp && (flags & ISLASTCN)) ! 795: VOP_UNLOCK(pdp, 0, p); ! 796: } ! 797: error = vn_lock(pdp, LK_EXCLUSIVE, p); ! 798: if (error) ! 799: return (error); ! 800: return (hfs_lookup(ap)); ! 801: } ! 802: ! 803: /* ! 804: * Parses a componentname and sees if the remaining path ! 805: * contains a hfs named fork specifier. If it does set the ! 806: * componentname to consume the rest of the path, and ! 807: * return the forkType ! 808: */ ! 809: ! 810: u_int16_t GetForkFromName(struct componentname *cnp) ! 811: { ! 812: u_int16_t forkType = kUndefinedFork; ! 813: char *tcp = cnp->cn_nameptr + cnp->cn_namelen; ! 814: ! 815: if (bcmp(tcp, _PATH_FORKSPECIFIER, sizeof(_PATH_FORKSPECIFIER) - 1) == 0) { ! 816: /* Its a HFS fork, so far */ ! 817: tcp += (sizeof(_PATH_FORKSPECIFIER) - 1); ! 818: if (bcmp(tcp, _PATH_DATANAME, sizeof(_PATH_DATANAME)) == 0) { ! 819: forkType = kDataFork; ! 820: cnp->cn_consume = sizeof(_PATH_FORKSPECIFIER) + sizeof(_PATH_DATANAME) - 2; ! 821: } ! 822: else if (bcmp(tcp, _PATH_RSRCNAME, sizeof(_PATH_RSRCNAME)) == 0) { ! 823: forkType = kRsrcFork; ! 824: cnp->cn_consume = sizeof(_PATH_FORKSPECIFIER) + sizeof(_PATH_RSRCNAME) - 2; ! 825: }; /* else if */ ! 826: }; /* if bcmp */ ! 827: ! 828: ! 829: /* XXX SER For backwards compatability...keep it */ ! 830: if (forkType == kUndefinedFork) { ! 831: tcp = cnp->cn_nameptr + cnp->cn_namelen; ! 832: if (bcmp(tcp, gHFSForkIdentStr, sizeof(gHFSForkIdentStr) - 1) == 0) { ! 833: /* Its a HFS fork, so far */ ! 834: tcp += (sizeof(gHFSForkIdentStr) - 1); ! 835: if (bcmp(tcp, gDataForkNameStr, sizeof(gDataForkNameStr)) == 0) { ! 836: forkType = kDataFork; ! 837: cnp->cn_consume = sizeof(gHFSForkIdentStr) + sizeof(gDataForkNameStr) - 2; ! 838: } ! 839: else if (bcmp(tcp, gRsrcForkNameStr, sizeof(gRsrcForkNameStr)) == 0) { ! 840: forkType = kRsrcFork; ! 841: cnp->cn_consume = sizeof(gHFSForkIdentStr) + sizeof(gRsrcForkNameStr) - 2; ! 842: }; /* else if */ ! 843: }; /* if bcmp */ ! 844: }; ! 845: ! 846: return forkType; ! 847: } ! 848: ! 849: #if DBG_VOP_TEST_LOCKS ! 850: ! 851: void DbgLookupTest( char *funcname, struct componentname *cnp, struct vnode *dvp, struct vnode *vp) ! 852: { ! 853: if (! (hfs_dbg_lookup || hfs_dbg_all)) ! 854: return; ! 855: ! 856: ! 857: if (dvp) { ! 858: if (lockstatus(&VTOH(dvp)->h_lock)) { ! 859: DBG_LOOKUP (("%s: Parent vnode exited LOCKED", funcname)); ! 860: } ! 861: else { ! 862: DBG_LOOKUP (("%s: Parent vnode exited UNLOCKED", funcname)); ! 863: } ! 864: } ! 865: ! 866: if (vp) { ! 867: if (vp==dvp) ! 868: { ! 869: DBG_LOOKUP (("%s: Target and Parent are the same", funcname)); ! 870: } ! 871: else { ! 872: if (lockstatus(&VTOH(vp)->h_lock)) { ! 873: DBG_LOOKUP (("%s: Found vnode exited LOCKED", funcname)); ! 874: } ! 875: else { ! 876: DBG_LOOKUP (("%s: Found vnode exited LOCKED", funcname)); ! 877: } ! 878: } ! 879: DBG_LOOKUP (("%s: Found vnode 0x%x has vtype of %d\n ", funcname, (u_int)vp, vp->v_type)); ! 880: } ! 881: else ! 882: DBG_LOOKUP (("%s: Found vnode exited NULL\n", funcname)); ! 883: ! 884: ! 885: } ! 886: ! 887: #endif /* DBG_VOP_TEST_LOCKS */ ! 888:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.