![[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 Darwin 0.x] / kernel / bsd / hfs|
Return to hfs_lookup.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / hfs |
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) 1989, 1993 ! 26: * The Regents of the University of California. All rights reserved. ! 27: * (c) UNIX System Laboratories, Inc. ! 28: * All or some portions of this file are derived from material licensed ! 29: * to the University of California by American Telephone and Telegraph ! 30: * Co. or Unix System Laboratories, Inc. and are reproduced herein with ! 31: * the permission of UNIX System Laboratories, Inc. ! 32: * ! 33: * Redistribution and use in source and binary forms, with or without ! 34: * modification, are permitted provided that the following conditions ! 35: * are met: ! 36: * 1. Redistributions of source code must retain the above copyright ! 37: * notice, this list of conditions and the following disclaimer. ! 38: * 2. Redistributions in binary form must reproduce the above copyright ! 39: * notice, this list of conditions and the following disclaimer in the ! 40: * documentation and/or other materials provided with the distribution. ! 41: * 3. All advertising materials mentioning features or use of this software ! 42: * must display the following acknowledgement: ! 43: * This product includes software developed by the University of ! 44: * California, Berkeley and its contributors. ! 45: * 4. Neither the name of the University nor the names of its contributors ! 46: * may be used to endorse or promote products derived from this software ! 47: * without specific prior written permission. ! 48: * ! 49: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 50: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 51: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 52: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 53: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 54: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 55: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 56: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 57: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 58: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 59: * SUCH DAMAGE. ! 60: * ! 61: * @(#)hfs_lookup.c 1.0 ! 62: * derived from @(#)ufs_lookup.c 8.15 (Berkeley) 6/16/95 ! 63: * ! 64: * (c) 1998 Apple Computer, Inc. All Rights Reserved ! 65: * (c) 1990, 1992 NeXT Computer, Inc. All Rights Reserved ! 66: * ! 67: * ! 68: * hfs_lookup.c -- code to handle directory traversal on HFS/HFS+ volume ! 69: * ! 70: * MODIFICATION HISTORY: ! 71: * 25-Feb-1999 Clark Warner Fixed the error case of VFS_VGGET when ! 72: * processing DotDot (..) to relock parent ! 73: * 23-Feb-1999 Pat Dirks Finish cleanup around Don's last fix in "." and ".." handling. ! 74: * 11-Nov-1998 Don Brady Take out VFS_VGET that got added as part of previous fix. ! 75: * 14-Oct-1998 Don Brady Fix locking policy volation in hfs_lookup for ".." case ! 76: * (radar #2279902). ! 77: * 4-Jun-1998 Pat Dirks Split off from hfs_vnodeops.c ! 78: */ ! 79: ! 80: #include <sys/param.h> ! 81: #include <sys/systm.h> ! 82: #include <sys/resourcevar.h> ! 83: #include <sys/kernel.h> ! 84: #include <sys/file.h> ! 85: #include <sys/stat.h> ! 86: #include <sys/buf.h> ! 87: #include <sys/proc.h> ! 88: #include <sys/conf.h> ! 89: #include <sys/mount.h> ! 90: #include <mach/machine/vm_types.h> ! 91: #include <sys/vnode.h> ! 92: //#include <sys/vnode_if.h> ! 93: #include <sys/malloc.h> ! 94: #include <sys/namei.h> ! 95: #include <sys/signalvar.h> ! 96: #include <sys/uio.h> ! 97: #include <sys/time.h> ! 98: #include <sys/attr.h> ! 99: #include <miscfs/specfs/specdev.h> ! 100: ! 101: #include <sys/vm.h> ! 102: #include <libkern/libkern.h> ! 103: #include <mach/machine/simple_lock.h> ! 104: #include <machine/spl.h> ! 105: ! 106: #include "hfs.h" ! 107: #include "hfs_dbg.h" ! 108: #include "hfscommon/headers/FileMgrInternal.h" ! 109: #include "hfscommon/headers/CatalogPrivate.h" ! 110: ! 111: extern void cache_purge (struct vnode *vp); ! 112: extern int cache_lookup (struct vnode *dvp, struct vnode **vpp, struct componentname *cnp); ! 113: extern void cache_enter (struct vnode *dvp, struct vnode *vpp, struct componentname *cnp); ! 114: ! 115: #if DBG_VOP_TEST_LOCKS ! 116: extern void DbgVopTest(int maxSlots, int retval, VopDbgStoreRec *VopDbgStore, char *funcname); ! 117: #endif ! 118: ! 119: /***************************************************************************** ! 120: * ! 121: * Operations on vnodes ! 122: * ! 123: *****************************************************************************/ ! 124: ! 125: /* From FreeBSD 2.2 MSDOS_LOOKUP ! 126: * When we search a directory the blocks containing directory entries are ! 127: * read and examined. The directory entries contain information that would ! 128: * normally be in the hfsnode of a unix filesystem. This means that some of ! 129: * a directory's contents may also be in memory resident denodes (sort of ! 130: * an hfsnode). This can cause problems if we are searching while some other ! 131: * process is modifying a directory. To prevent one process from accessing ! 132: * incompletely modified directory information we depend upon being the ! 133: * soul owner of a directory block. bread/brelse provide this service. ! 134: * This being the case, when a process modifies a directory it must first ! 135: * acquire the disk block that contains the directory entry to be modified. ! 136: * Then update the disk block and the denode, and then write the disk block ! 137: * out to disk. This way disk blocks containing directory entries and in ! 138: * memory denode's will be in synch. ! 139: */ ! 140: ! 141: /* FROM UNIX 63 ! 142: * Convert a component of a pathname into a pointer to a locked hfsnode. ! 143: * This is a very central and rather complicated routine. ! 144: * If the file system is not maintained in a strict tree hierarchy, ! 145: * this can result in a deadlock situation (see comments in code below). ! 146: * ! 147: * The flag argument is LOOKUP, CREATE, RENAME, or DELETE depending on ! 148: * whether the name is to be looked up, created, renamed, or deleted. ! 149: * When CREATE, RENAME, or DELETE is specified, information usable in ! 150: * creating, renaming, or deleting a directory entry may be calculated. ! 151: * If flag has LOCKPARENT or'ed into it, the parent directory is returned ! 152: * locked. If flag has WANTPARENT or'ed into it, the parent directory is ! 153: * returned unlocked. Otherwise the parent directory is not returned. If ! 154: * the target of the pathname exists and LOCKLEAF is or'ed into the flag ! 155: * the target is returned locked, otherwise it is returned unlocked. ! 156: * When creating or renaming and LOCKPARENT is specified, the target may not ! 157: * be ".". When deleting and LOCKPARENT is specified, the target may be ".". ! 158: * ! 159: * Overall outline of hfs_lookup: ! 160: * ! 161: * check accessibility of directory ! 162: * look for name in cache, if found, then if at end of path ! 163: * and deleting or creating, drop it, else return name ! 164: * search for name in directory, to found or notfound ! 165: * DoesntExist: ! 166: * if creating, return locked directory, leaving info on available slots ! 167: * else return retval ! 168: * Exists: ! 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: * hfsnode 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: * NOTE: (LOOKUP | LOCKPARENT) currently returns the parent hfsnode unlocked. ! 176: */ ! 177: ! 178: /* ! 179: * Lookup *nm in directory *pvp, return it in *a_vpp. ! 180: * **a_vpp is held on exit. ! 181: * We create a hfsnode for the file, but we do NOT open the file here. ! 182: ! 183: #% lookup dvp L ? ? ! 184: #% lookup vpp - L - ! 185: ! 186: IN struct vnode *dvp - Parent node of file; ! 187: INOUT struct vnode **vpp - node of target file, its a new node if the target vnode did not exist; ! 188: IN struct componentname *cnp - Name of file; ! 189: ! 190: * When should we lock parent_hp in here ?? ! 191: */ ! 192: ! 193: int ! 194: hfs_lookup(ap) ! 195: struct vop_lookup_args /* { ! 196: struct vnode *a_dvp; ! 197: struct vnode **a_vpp; ! 198: struct componentname *a_cnp; ! 199: } */ *ap; ! 200: { ! 201: struct vnode *parent_vp; ! 202: struct vnode *target_vp; ! 203: struct vnode *tparent_vp; ! 204: struct hfsnode *parent_hp; /* parent */ ! 205: struct hfsnode *target_hp; /* target */ ! 206: struct hfsmount *parent_hfs; ! 207: struct componentname *cnp; ! 208: struct ucred *cred; ! 209: struct proc *p; ! 210: struct hfsCatalogInfo catInfo; ! 211: u_long parent_id; ! 212: u_long lockparent; /* !0 => lockparent flag is set */ ! 213: u_long wantparent; /* !0 => wantparent or lockparent flag */ ! 214: u_short targetLen; ! 215: int nameiop; ! 216: int retval; ! 217: u_char isDot, isDotDot; ! 218: UInt32 nodeID; ! 219: UInt16 forkType; ! 220: DBG_FUNC_NAME("lookup"); ! 221: DBG_VOP_LOCKS_DECL(2); ! 222: DBG_VOP_LOCKS_INIT(0,ap->a_dvp, VOPDBG_LOCKED, VOPDBG_IGNORE, VOPDBG_IGNORE, VOPDBG_POS); ! 223: DBG_VOP_LOCKS_INIT(1,*ap->a_vpp, VOPDBG_IGNORE, VOPDBG_LOCKED, VOPDBG_IGNORE, VOPDBG_POS); ! 224: DBG_VOP_PRINT_FUNCNAME(); ! 225: DBG_VOP_PRINT_VNODE_INFO(ap->a_dvp);DBG_VOP_CONT(("\n")); ! 226: DBG_VOP_PRINT_FUNCNAME(); ! 227: DBG_VOP_CONT(("\tTarget: "));DBG_VOP_PRINT_CPN_INFO(ap->a_cnp);DBG_VOP_CONT(("\n")); ! 228: DBG_HFS_NODE_CHECK(ap->a_dvp); ! 229: DBG_ASSERT(ap->a_dvp!=NULL); ! 230: ! 231: ! 232: /* ! 233: * Do initial setup ! 234: */ ! 235: parent_vp = ap->a_dvp; ! 236: cnp = ap->a_cnp; ! 237: parent_hp = VTOH(parent_vp); /* parent */ ! 238: target_vp = NULL; ! 239: parent_hfs = VTOHFS(parent_vp); ! 240: targetLen = cnp->cn_namelen; ! 241: nameiop = cnp->cn_nameiop; ! 242: cred = cnp->cn_cred; ! 243: p = cnp->cn_proc; ! 244: lockparent = cnp->cn_flags & LOCKPARENT; ! 245: wantparent = cnp->cn_flags & (LOCKPARENT|WANTPARENT); ! 246: parent_id = H_FILEID(parent_hp); ! 247: nodeID = kUnknownID; ! 248: isDot = FALSE; ! 249: isDotDot = cnp->cn_flags & ISDOTDOT; ! 250: catInfo.hint = 0; ! 251: retval = E_NONE; ! 252: forkType = kDirCmplx; ! 253: ! 254: ! 255: /* ! 256: * Check accessiblity of directory. ! 257: */ ! 258: if ((parent_vp->v_type != VDIR) && (parent_vp->v_type != VCPLX)) { ! 259: DBG_ERR(("%s: Parent VNode '%s' is not a directory, its %d\n",funcname, H_NAME(parent_hp), parent_vp->v_type)); ! 260: retval = ENOTDIR; ! 261: goto Err_Exit; ! 262: }; ! 263: ! 264: /* ! 265: * Check accessiblity of directory. Only if it is non complex, since it would of been checked ! 266: * when looking up the complex node. The 'first' lookup's parent should alsways be a directory ! 267: */ ! 268: if ((parent_vp->v_type != VCPLX) && ((retval = VOP_ACCESS(parent_vp, VEXEC, cred, p)) != E_NONE)) { ! 269: DBG_ERR(("%s: No acces to parent %s, %s\n",funcname, H_NAME(parent_hp), ap->a_cnp->cn_nameptr)); ! 270: goto Err_Exit; ! 271: }; ! 272: ! 273: /* Check for accessibility of the file...is this a read-only volume */ ! 274: if ((cnp->cn_flags & ISLASTCN) && (VTOVFS(parent_vp)->mnt_flag & MNT_RDONLY) && ! 275: (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) { ! 276: DBG_ERR(("%s: Invalid cn_nameiop for read-only volume %s, %s\n",funcname, H_NAME(parent_hp), ap->a_cnp->cn_nameptr)); ! 277: retval = EROFS; ! 278: goto Err_Exit; ! 279: }; ! 280: ! 281: /* ! 282: * We now have a segment name to search for, and a directory to search. ! 283: * ! 284: * Before tediously performing a linear scan of the directory, ! 285: * check the name cache to see if the directory/name pair ! 286: * we are looking for is known already. ! 287: */ ! 288: retval = cache_lookup(parent_vp, &target_vp, cnp); ! 289: if (retval != E_NONE) { ! 290: u_long vpid; /* capability number of vnode */ ! 291: ! 292: DBG_VOP(("\tFound in name cache: ")); ! 293: if (retval == ENOENT) { ! 294: DBG_VOP_CONT((" As a non-entry\n")); ! 295: goto Err_Exit; ! 296: } ! 297: DBG_VOP_PRINT_VNODE_INFO(target_vp);DBG_VOP_CONT(("\n")); ! 298: /* ! 299: * Get the next vnode in the path. ! 300: * See comment below starting `Step through' for ! 301: * an explaination of the locking protocol. ! 302: */ ! 303: tparent_vp = parent_vp; ! 304: parent_vp = target_vp; ! 305: vpid = target_vp->v_id; ! 306: if (tparent_vp == parent_vp) { /* Lookup on '.' */ ! 307: VREF(parent_vp); ! 308: retval = E_NONE; ! 309: } else if (cnp->cn_flags & ISDOTDOT) { /* If getting our parent */ ! 310: VOP_UNLOCK(tparent_vp, 0, p); ! 311: retval = vget(parent_vp, LK_EXCLUSIVE, p); ! 312: if (!retval && lockparent && (cnp->cn_flags & ISLASTCN)) ! 313: retval = vn_lock(tparent_vp, LK_EXCLUSIVE, p); ! 314: } else { ! 315: retval = vget(parent_vp, LK_EXCLUSIVE, p); ! 316: if ((!retval) && (parent_vp->v_type == VCPLX) && (cnp->cn_flags & ISLASTCN)) { ! 317: target_vp = VTOH(parent_vp)->h_relative; ! 318: VPUT(parent_vp); ! 319: if (target_vp == NULL) { ! 320: parent_vp = tparent_vp; ! 321: goto Skip_NameCache; ! 322: } ! 323: parent_vp = target_vp; /* do the 'skipping' */ ! 324: vpid = parent_vp->v_id; ! 325: retval = vget(parent_vp, LK_EXCLUSIVE, p); ! 326: }; ! 327: if (!lockparent || retval || !(cnp->cn_flags & ISLASTCN)) ! 328: VOP_UNLOCK(tparent_vp, 0, p); ! 329: }; ! 330: ! 331: /* ! 332: * Check that the node number did not change ! 333: * while we were waiting for the lock. ! 334: */ ! 335: if (retval == E_NONE) { ! 336: if (vpid == parent_vp->v_id) { ! 337: goto Err_Exit; /* Did not change, Success! We have the node..we are finished */ ! 338: }; ! 339: ! 340: VPUT(parent_vp); ! 341: if (lockparent && tparent_vp != parent_vp && (cnp->cn_flags & ISLASTCN)) ! 342: VOP_UNLOCK(tparent_vp, 0, p); ! 343: }; ! 344: ! 345: retval = vn_lock(tparent_vp, LK_EXCLUSIVE, p); ! 346: if (retval) goto Err_Exit; ! 347: ! 348: parent_vp = tparent_vp; ! 349: target_vp = NULL; ! 350: }; ! 351: ! 352: Skip_NameCache: ; ! 353: ! 354: ! 355: /* ! 356: * Trivial cases for current and parent directories ! 357: */ ! 358: if(cnp->cn_nameptr[0] == (char)'.') { ! 359: /* . */ ! 360: if(targetLen == 1) { /* self */ ! 361: target_vp = parent_vp; ! 362: nodeID = H_FILEID(parent_hp); ! 363: isDot = TRUE; ! 364: catInfo.nodeData.nodeType = kCatalogFolderNode; ! 365: goto Exists; ! 366: }; ! 367: ! 368: /* .. */ ! 369: if((cnp->cn_nameptr[1] == '.') && (targetLen == 2)) { /* parent */ ! 370: isDotDot = TRUE; /* XXX Make doubly-sure this is set for now */ ! 371: nodeID = H_DIRID(parent_hp); ! 372: VOP_UNLOCK(parent_vp, 0, p); ! 373: retval = VFS_VGET(HTOVFS(parent_hp), &nodeID, &target_vp); ! 374: if (retval) { ! 375: vn_lock(parent_vp, LK_EXCLUSIVE | LK_RETRY, p); ! 376: goto Err_Exit; ! 377: } ! 378: ! 379: if (lockparent && (cnp->cn_flags & ISLASTCN)) { ! 380: retval = vn_lock(parent_vp, LK_EXCLUSIVE, p); ! 381: if (retval) { ! 382: VPUT(target_vp); ! 383: goto Err_Exit; ! 384: } ! 385: } ! 386: ! 387: if (target_vp == NULL) { ! 388: DBG_ERR(("%s: VFS_VGET FAILED on getting dir %ld: %d\n",funcname, H_DIRID(parent_hp), retval)); ! 389: goto Err_Exit; ! 390: } else { ! 391: target_hp = VTOH(target_vp); ! 392: nodeID = H_FILEID(target_hp); ! 393: catInfo.nodeData.nodeType = kCatalogFolderNode; ! 394: goto Exists; ! 395: }; ! 396: }; ! 397: }; ! 398: ! 399: ! 400: /* ! 401: * The file is not in the cache, nor is it a dot (or dot-dot), so do a hfs lookup ! 402: */ ! 403: ! 404: /* lock catalog b-tree */ ! 405: retval = hfs_metafilelocking(parent_hfs, kHFSCatalogFileID, LK_SHARED, p); /*XXX p might be wrongone! */ ! 406: if (retval) ! 407: goto Err_Exit; ! 408: ! 409: if (parent_vp->v_type == VCPLX) { ! 410: retval = hfsLookup (HFSTOVCB(parent_hfs), H_DIRID(parent_hp), H_NAME(parent_hp), -1, H_HINT(parent_hp), &catInfo); ! 411: } ! 412: else { ! 413: retval = hfsLookup (HFSTOVCB(parent_hfs), parent_id, cnp->cn_nameptr, targetLen, kNoHint, &catInfo); ! 414: } ! 415: ! 416: /* unlock catalog b-tree */ ! 417: (void) hfs_metafilelocking(parent_hfs, kHFSCatalogFileID, LK_RELEASE, p); ! 418: ! 419: nodeID = catInfo.nodeData.nodeID; ! 420: if (retval == E_NONE) { ! 421: goto Exists; ! 422: } else { ! 423: goto DoesntExist; ! 424: }; ! 425: ! 426: ! 427: DoesntExist: ; ! 428: ! 429: /* ! 430: * If we get here we didn't find the entry we were looking for. But ! 431: * that's ok if we are creating or renaming and are at the end of ! 432: * the pathname and the directory hasn't been removed. ! 433: */ ! 434: retval = E_NONE; ! 435: if ((nameiop == CREATE || nameiop == RENAME) && (cnp->cn_flags & ISLASTCN)) { ! 436: retval = VOP_ACCESS(parent_vp, VWRITE, cred, p); ! 437: if (retval) ! 438: goto Err_Exit; ! 439: ! 440: cnp->cn_flags |= SAVENAME; ! 441: if (!lockparent)/* leave searched dir locked? */ ! 442: VOP_UNLOCK(parent_vp, 0, p); ! 443: retval = EJUSTRETURN; ! 444: goto Err_Exit; ! 445: } ! 446: ! 447: /* ! 448: * XXX SER - Here we would store the name in cache as non-existant if not trying to create it, but, ! 449: * the name cache IS case-sensitive, thus maybe showing a negative hit, when the name ! 450: * is only different by case. So hfs does not support negative caching. Something to look at. ! 451: * (See radar 2293594 for a failed example) ! 452: */ ! 453: ! 454: retval = ENOENT; ! 455: goto Err_Exit; ! 456: ! 457: ! 458: Exists: ; ! 459: ! 460: DBG_ASSERT(nodeID != kUnknownID); ! 461: retval = E_NONE; ! 462: ! 463: if (target_vp) { ! 464: forkType = H_FORKTYPE(VTOH(target_vp)); ! 465: } else { ! 466: /* ! 467: * Here we have to decide what type of vnode to create ! 468: * If the parent is a directory, then the child can be one of four types: ! 469: * 1. VDIR, nodeType is kCatalogFolderNode, forkType will be kDirCmplx ! 470: * 2. VLINK, nodeType is kCatalogFileNode, forkType will be kDataFork ! 471: * 3. VREG, nodeType is kCatalogFileNode, forkType will be kDataFork ! 472: * 4. VCPLX, nodeType is kCatalogFileNode, forkType will be kDirCmplx ! 473: * To determine which of the latter three, we can use this algorithm: ! 474: * a. VREG iff ISLASTCN is set (as in the case of the default fork e.g. data/foo). ! 475: * b. VLINK iff the mode is IFLNK (esp. if it is a link to a directory e.g. bar/link/foo) ! 476: * c. VCPLX iff it is followed by a valid fork name. (foo/data) ! 477: * If the parent is a complex, then the child must have a valid fork name ! 478: */ ! 479: ! 480: if (parent_vp->v_type == VDIR) { ! 481: if (catInfo.nodeData.nodeType == kCatalogFolderNode) ! 482: forkType = kDirCmplx; ! 483: else if ((cnp->cn_flags & ISLASTCN) || ((catInfo.nodeData.permissions.permissions & IFMT)==IFLNK)) { ! 484: forkType = kDataFork; /* The defualt */ ! 485: //cnp->cn_flags &= ~MAKEENTRY; ! 486: } ! 487: else ! 488: forkType = kDirCmplx; /* complex */ ! 489: } ! 490: else if (parent_vp->v_type == VCPLX) { ! 491: if (! strcmp(cnp->cn_nameptr, kDataForkNameStr)) ! 492: forkType = kDataFork; ! 493: else if (! strcmp(cnp->cn_nameptr, kRsrcForkNameStr)) ! 494: forkType = kRsrcFork; ! 495: else { ! 496: if (!lockparent) /* leave parent dir locked? */ ! 497: VOP_UNLOCK(parent_vp, 0, p); ! 498: DBG_ERR(("%s: Searching for an illegal fork: %s\n", funcname, cnp->cn_nameptr)); ! 499: retval = ENOENT; ! 500: goto Err_Exit; ! 501: } ! 502: } ! 503: else ! 504: panic("Unexpected parent type for lookup"); ! 505: DBG_VOP(("\tExists: Parent v_type:%d, forkType:%d, target nodeType:0x%x\n", parent_vp->v_type, forkType, (u_int)catInfo.nodeData.nodeType)); ! 506: }; ! 507: ! 508: ! 509: /* ! 510: * If deleting and at the end of the path, then if we matched on ! 511: * "." then don't hfsget() Otherwise ! 512: * hfsget() the directory entry. ! 513: */ ! 514: /* ! 515: * If deleting, and at end of pathname, return ! 516: * parameters which can be used to remove file. ! 517: * If the wantparent flag isn't set, we return only ! 518: * the directory (in ndp->ndvp), otherwise we go ! 519: * on and lock the hfsnode, being careful with ".". ! 520: */ ! 521: if (nameiop == DELETE && (cnp->cn_flags & ISLASTCN)) { ! 522: /* ! 523: * Write access to directory required to delete files. ! 524: */ ! 525: retval = VOP_ACCESS(parent_vp, VWRITE, cred, p); ! 526: if (retval) ! 527: goto Err_Exit; ! 528: ! 529: if (isDot) { ! 530: VREF(parent_vp); ! 531: target_vp = parent_vp; ! 532: goto Err_Exit; ! 533: } ! 534: else if (target_vp == NULL) { ! 535: target_vp = hfs_vhashget(parent_hp->h_dev, nodeID, forkType); ! 536: if (target_vp == NULL) ! 537: retval = hfsGet (HTOVCB(parent_hp), &catInfo, forkType, parent_vp, &target_vp); ! 538: if (retval != E_NONE) ! 539: goto Err_Exit; ! 540: } ! 541: /* ! 542: * If directory is "sticky", then user must own ! 543: * the directory, or the file in it, else she ! 544: * may not delete it (unless she's root). This ! 545: * implements append-only directories. ! 546: */ ! 547: if ((parent_hp->h_meta->h_mode & ISVTX) && ! 548: cred->cr_uid != 0 && ! 549: cred->cr_uid != parent_hp->h_meta->h_uid && ! 550: target_vp->v_type != VLNK && ! 551: VTOH(target_vp)->h_meta->h_uid != cred->cr_uid) { ! 552: VPUT(target_vp); ! 553: retval = EPERM; ! 554: goto Err_Exit; ! 555: } ! 556: ! 557: if (!lockparent && !isDotDot) ! 558: VOP_UNLOCK(parent_vp, 0, p); ! 559: goto Err_Exit; ! 560: }; ! 561: ! 562: /* ! 563: * If rewriting 'RENAME', return the hfsnode and the ! 564: * information required to rewrite the present directory ! 565: */ ! 566: if (nameiop == RENAME && wantparent && (cnp->cn_flags & ISLASTCN)) { ! 567: ! 568: /* cant change root */ ! 569: if ((parent_id == kRootDirID) && isDot) { ! 570: retval = EISDIR; ! 571: goto Err_Exit; ! 572: }; ! 573: ! 574: if (target_vp == NULL) { ! 575: ! 576: /* Make sure that this is the correct name ie. same case */ ! 577: if (strncmp(cnp->cn_nameptr, catInfo.spec.name, targetLen)) { ! 578: if (!lockparent)/* leave searched dir locked? */ ! 579: VOP_UNLOCK(parent_vp, 0, p); ! 580: retval = EJUSTRETURN; ! 581: goto Err_Exit; ! 582: }; ! 583: ! 584: /* Create the vnode, looking in the cache first */ ! 585: target_vp = hfs_vhashget(parent_hp->h_dev, nodeID, forkType); ! 586: if (target_vp == NULL) ! 587: retval = hfsGet (HTOVCB(parent_hp), &catInfo, forkType, parent_vp, &target_vp); ! 588: if (retval != E_NONE) ! 589: goto Err_Exit; ! 590: }; ! 591: ! 592: if (!lockparent && !isDotDot) VOP_UNLOCK(parent_vp, 0, p); ! 593: cnp->cn_flags |= SAVENAME; ! 594: goto Err_Exit; ! 595: /* Finished...all is well, goto the end */ ! 596: }; ! 597: ! 598: /* ! 599: * Step through the translation in the name. We do not `vput' the ! 600: * directory because we may need it again if a symbolic link ! 601: * is relative to the current directory. Instead we save it ! 602: * unlocked as "tparent_vp". We must get the target hfsnode before unlocking ! 603: * the directory to insure that the hfsnode will not be removed ! 604: * before we get it. We prevent deadlock by always fetching ! 605: * inodes from the root, moving down the directory tree. Thus ! 606: * when following backward pointers ".." we must unlock the ! 607: * parent directory before getting the requested directory. ! 608: * There is a potential race condition here if both the current ! 609: * and parent directories are removed before the VFS_VGET for the ! 610: * hfsnode associated with ".." returns. We hope that this occurs ! 611: * infrequently since we cannot avoid this race condition without ! 612: * implementing a sophisticated deadlock detection algorithm. ! 613: * Note also that this simple deadlock detection scheme will not ! 614: * work if the file system has any hard links other than ".." ! 615: * that point backwards in the directory structure. ! 616: */ ! 617: ! 618: tparent_vp = parent_vp; ! 619: if (cnp->cn_flags & ISDOTDOT) { ! 620: #if 0 ! 621: VOP_UNLOCK(tparent_vp, 0, p); ! 622: /* radar #2286192 ! 623: * UFS does a VFS_VGET here but the code below is causing a hang so ! 624: * I'm taking it back out for now - DJB ! 625: */ ! 626: if ((retval = VFS_VGET(parent_vp->v_mount, &H_FILEID(parent_hp), &target_vp))) { ! 627: vn_lock(tparent_vp, LK_EXCLUSIVE | LK_RETRY, p); ! 628: goto Err_Exit; ! 629: } ! 630: if (lockparent && (cnp->cn_flags & ISLASTCN) ! 631: && (retval = vn_lock(tparent_vp, LK_EXCLUSIVE | LK_RETRY, p))) { ! 632: VPUT(target_vp); ! 633: goto Err_Exit; ! 634: } ! 635: #endif ! 636: } else if (isDot) { /* "." */ ! 637: VREF(parent_vp); ! 638: target_vp = parent_vp; ! 639: } else { ! 640: if (target_vp == NULL) ! 641: target_vp = hfs_vhashget(parent_hp->h_dev, nodeID, forkType); ! 642: if (target_vp == NULL) ! 643: retval = hfsGet(HTOVCB(parent_hp), &catInfo, forkType, parent_vp, &target_vp); ! 644: if (retval) ! 645: goto Err_Exit; ! 646: if (!lockparent || !(cnp->cn_flags & ISLASTCN)) ! 647: VOP_UNLOCK(tparent_vp, 0, p); ! 648: } ! 649: ! 650: /* ! 651: * Insert name in cache if wanted. ! 652: */ ! 653: if (cnp->cn_flags & MAKEENTRY) { ! 654: struct vnode *tp; ! 655: ! 656: /* If this is bypassing the complex vnode, get it, so we only store complex vnodes */ ! 657: if (target_vp->v_type != VREG) { ! 658: tp = target_vp; ! 659: } else { ! 660: if (parent_vp->v_type == VDIR) { ! 661: tp = VTOH(target_vp)->h_relative; ! 662: } else { ! 663: /* Parent node is complex node [already cached in earlier lookup]; ! 664: don't add anything else in the cache now. ! 665: ! 666: XXX Someday we may want to enter data/rsrc fork vnodes in the name cache... ! 667: */ ! 668: tp = NULL; ! 669: }; ! 670: }; ! 671: if (tp) { ! 672: DBG_ASSERT((tp->v_type==VDIR) || (tp->v_type==VCPLX) || (tp->v_type==VLNK)); ! 673: DBG_VOP(("\tStoring into name cache: target: 0x%x ", (u_int)target_vp)); DBG_VOP_PRINT_CPN_INFO(cnp); ! 674: DBG_VOP_CONT((" parent: "));DBG_VOP_PRINT_VNODE_INFO(parent_vp); DBG_VOP_CONT(("\n")); ! 675: cache_enter(parent_vp, tp, cnp); ! 676: }; ! 677: }; ! 678: ! 679: Err_Exit: ! 680: ! 681: *ap->a_vpp = target_vp; ! 682: ! 683: DBG_VOP_UPDATE_VP(1, *ap->a_vpp); ! 684: DBG_VOP_LOOKUP_TEST (funcname, cnp, parent_vp, target_vp); ! 685: DBG_VOP_LOCKS_TEST(E_NONE); ! 686: DBG_VOP_PRINT_FUNCNAME(); ! 687: if (retval == E_NONE) { ! 688: DBG_VOP_CONT(("Success\n")); ! 689: } else { ! 690: DBG_VOP_CONT(("Fails\n")); ! 691: } ! 692: ! 693: return (retval); ! 694: } ! 695: ! 696: ! 697: ! 698: ! 699: #if DBG_VOP_TEST_LOCKS ! 700: ! 701: void DbgLookupTest( char *funcname, struct componentname *cnp, struct vnode *dvp, struct vnode *vp) ! 702: { ! 703: int flags = cnp->cn_flags; ! 704: int nameiop = cnp->cn_nameiop; ! 705: ! 706: kprintf ("%X: %s: Action is: ", CURRENT_PROC->p_pid, funcname); ! 707: switch (nameiop) ! 708: { ! 709: case LOOKUP: ! 710: kprintf ("LOOKUP"); ! 711: break; ! 712: case CREATE: ! 713: kprintf ("CREATE"); ! 714: break; ! 715: case DELETE: ! 716: kprintf ("DELETE"); ! 717: break; ! 718: case RENAME: ! 719: kprintf ("RENAME"); ! 720: break; ! 721: default: ! 722: DBG_ERR (("!!!UNKNOWN!!!!")); ! 723: break; ! 724: } ! 725: kprintf (" flags: 0x%x ",flags ); ! 726: if (flags & LOCKPARENT) ! 727: kprintf (" LOCKPARENT"); ! 728: if (flags & ISLASTCN) ! 729: kprintf (" ISLASTCN"); ! 730: kprintf ("\n"); ! 731: ! 732: if (dvp) { ! 733: kprintf ("%X: %s: Parent vnode exited ", CURRENT_PROC->p_pid, funcname); ! 734: if (lockstatus(&VTOH(dvp)->h_lock)) { ! 735: kprintf ("LOCKED\n"); ! 736: } ! 737: else { ! 738: kprintf ("UNLOCKED\n"); ! 739: } ! 740: } ! 741: ! 742: if (vp) { ! 743: if (vp==dvp) ! 744: { ! 745: kprintf ("%X: %s: Target and Parent are the same\n", CURRENT_PROC->p_pid, funcname); ! 746: } ! 747: else { ! 748: kprintf ("%X: %s: Found vnode exited ", CURRENT_PROC->p_pid, funcname); ! 749: if (lockstatus(&VTOH(vp)->h_lock)) { ! 750: kprintf ("LOCKED\n"); ! 751: } ! 752: else { ! 753: kprintf ("UNLOCKED\n"); ! 754: } ! 755: } ! 756: kprintf ("%X: %s: Found vnode 0x%x has vtype of %d\n ", CURRENT_PROC->p_pid, funcname, (u_int)vp, vp->v_type); ! 757: } ! 758: else ! 759: kprintf ("%X: %s: Found vnode exited NULL\n", CURRENT_PROC->p_pid, funcname); ! 760: ! 761: ! 762: } ! 763: ! 764: #endif /* DBG_VOP_TEST_LOCKS */ ! 765:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.