bsd/hfs/hfs_lookup.c

   1 /*
   2  * Copyright (c) 1999-2002 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 #define LEGACY_FORK_NAMES       0
  69
  70 #include <sys/param.h>
  71 #include <sys/buf.h>
  72 #include <sys/file.h>
  73 #include <sys/mount.h>
  74 #include <sys/vnode.h>
  75 #include <sys/namei.h>
  76 #include <sys/malloc.h>
  77 #include <sys/paths.h>
  78
  79 #include "hfs.h"
  80 #include "hfs_catalog.h"
  81 #include "hfs_cnode.h"
  82
  83
  84 static int forkcomponent(struct componentname *cnp, int *rsrcfork);
  85
  86 #define _PATH_DATAFORKSPEC      "/..namedfork/data"
  87
  88 #ifdef LEGACY_FORK_NAMES
  89 #define LEGACY_RSRCFORKSPEC     "/rsrc"
  90 #endif
  91
  92 /*
  93  * FROM FREEBSD 3.1
  94  * Convert a component of a pathname into a pointer to a locked cnode.
  95  * This is a very central and rather complicated routine.
  96  * If the file system is not maintained in a strict tree hierarchy,
  97  * this can result in a deadlock situation (see comments in code below).
  98  *
  99  * The cnp->cn_nameiop argument is LOOKUP, CREATE, RENAME, or DELETE depending
 100  * on whether the name is to be looked up, created, renamed, or deleted.
 101  * When CREATE, RENAME, or DELETE is specified, information usable in
 102  * creating, renaming, or deleting a directory entry may be calculated.
 103  * Notice that these are the only operations that can affect the directory of the target.
 104  *
 105  * If flag has LOCKPARENT or'ed into it and the target of the pathname
 106  * exists, lookup returns both the target and its parent directory locked.
 107  * When creating or renaming and LOCKPARENT is specified, the target may
 108  * not be ".".  When deleting and LOCKPARENT is specified, the target may
 109  * be "."., but the caller must check to ensure it does an vrele and vput
 110  * instead of two vputs.
 111  *
 112  * LOCKPARENT and WANTPARENT actually refer to the parent of the last item,
 113  * so if ISLASTCN is not set, they should be ignored. Also they are mutually exclusive, or
 114  * WANTPARENT really implies DONTLOCKPARENT. Either of them set means that the calling
 115  * routine wants to access the parent of the target, locked or unlocked.
 116  *
 117  * Keeping the parent locked as long as possible protects from other processes
 118  * looking up the same item, so it has to be locked until the cnode is totally finished
 119  *
 120  * This routine is actually used as VOP_CACHEDLOOKUP method, and the
 121  * filesystem employs the generic hfs_cache_lookup() as VOP_LOOKUP
 122  * method.
 123  *
 124  * hfs_cache_lookup() performs the following for us:
 125  *      check that it is a directory
 126  *      check accessibility of directory
 127  *      check for modification attempts on read-only mounts
 128  *      if name found in cache
 129  *              if at end of path and deleting or creating
 130  *              drop it
 131  *               else
 132  *              return name.
 133  *      return VOP_CACHEDLOOKUP()
 134  *
 135  * Overall outline of hfs_lookup:
 136  *
 137  *      handle simple cases of . and ..
 138  *      search for name in directory, to found or notfound
 139  * notfound:
 140  *      if creating, return locked directory, leaving info on available slots
 141  *      else return error
 142  * found:
 143  *      if at end of path and deleting, return information to allow delete
 144  *      if at end of path and rewriting (RENAME and LOCKPARENT), lock target
 145  *        cnode and return info to allow rewrite
 146  *      if not at end, add name to cache; if at end and neither creating
 147  *        nor deleting, add name to cache
 148  */
 149
 150 /*
 151  *      Lookup *nm in directory *pvp, return it in *a_vpp.
 152  *      **a_vpp is held on exit.
 153  *      We create a cnode for the file, but we do NOT open the file here.
 154
 155 #% lookup       dvp L ? ?
 156 #% lookup       vpp - L -
 157
 158         IN struct vnode *dvp - Parent node of file;
 159         INOUT struct vnode **vpp - node of target file, its a new node if
 160                 the target vnode did not exist;
 161         IN struct componentname *cnp - Name of file;
 162
 163  *      When should we lock parent_hp in here ??
 164  */
 165
 166 __private_extern__
 167 int
 168 hfs_lookup(ap)
 169         struct vop_cachedlookup_args /* {
 170                 struct vnode *a_dvp;
 171                 struct vnode **a_vpp;
 172                 struct componentname *a_cnp;
 173         } */ *ap;
 174 {
 175         struct vnode *dvp;      /* vnode for directory being searched */
 176         struct cnode *dcp;      /* cnode for directory being searched */
 177         struct vnode *tvp;      /* target vnode */
 178         struct hfsmount *hfsmp;
 179         struct componentname *cnp;
 180         struct ucred *cred;
 181         struct proc *p;
 182         int wantrsrc = 0;
 183         int forknamelen = 0;
 184         int flags;
 185         int wantparent;
 186         int nameiop;
 187         int retval = 0;
 188         int isDot;
 189         struct cat_desc desc = {0};
 190         struct cat_desc cndesc;
 191         struct cat_attr attr;
 192         struct cat_fork fork;
 193         struct vnode **vpp;
 194
 195         vpp = ap->a_vpp;
 196         cnp = ap->a_cnp;
 197         dvp = ap->a_dvp;
 198         dcp = VTOC(dvp);
 199         hfsmp = VTOHFS(dvp);
 200         *vpp = NULL;
 201         isDot = FALSE;
 202         tvp = NULL;
 203         nameiop = cnp->cn_nameiop;
 204         cred = cnp->cn_cred;
 205         p = cnp->cn_proc;
 206         flags = cnp->cn_flags;
 207         wantparent = flags & (LOCKPARENT|WANTPARENT);
 208
 209         /*
 210          * First check to see if it is a . or .., else look it up.
 211          */
 212         if (flags & ISDOTDOT) {         /* Wanting the parent */
 213                 goto found;     /* .. is always defined */
 214         } else if ((cnp->cn_nameptr[0] == '.') && (cnp->cn_namelen == 1)) {
 215                 isDot = TRUE;
 216                 goto found;     /* We always know who we are */
 217         } else {
 218                 /* Check fork suffix to see if we want the resource fork */
 219                 forknamelen = forkcomponent(cnp, &wantrsrc);
 220
 221                 /* No need to go to catalog if there are no children */
 222                 if (dcp->c_entries == 0)
 223                         goto notfound;
 224
 225                 bzero(&cndesc, sizeof(cndesc));
 226                 cndesc.cd_nameptr = cnp->cn_nameptr;
 227                 cndesc.cd_namelen = cnp->cn_namelen;
 228                 cndesc.cd_parentcnid = dcp->c_cnid;
 229                 cndesc.cd_hint = dcp->c_childhint;
 230
 231                 /* Lock catalog b-tree */
 232                 retval = hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_SHARED, p);
 233                 if (retval)
 234                            goto exit;
 235                 retval = cat_lookup(hfsmp, &cndesc, wantrsrc, &desc, &attr, &fork);
 236
 237                 if (retval == 0 && S_ISREG(attr.ca_mode) && attr.ca_blocks < fork.cf_blocks)
 238                         panic("hfs_lookup: bad ca_blocks (too small)");
 239
 240                 /* Unlock catalog b-tree */
 241                 (void) hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_RELEASE, p);
 242                 if (retval == 0) {
 243                         dcp->c_childhint = desc.cd_hint;
 244                         goto found;
 245                 }
 246 notfound:
 247                 /*
 248                  * This is a non-existing entry
 249                  *
 250                  * If creating, and at end of pathname and current
 251                  * directory has not been removed, then can consider
 252                  * allowing file to be created.
 253                  */
 254                 if ((nameiop == CREATE || nameiop == RENAME ||
 255                     (nameiop == DELETE &&
 256                     (ap->a_cnp->cn_flags & DOWHITEOUT) &&
 257                     (ap->a_cnp->cn_flags & ISWHITEOUT))) &&
 258                     (flags & ISLASTCN)) {
 259                         /*
 260                          * Access for write is interpreted as allowing
 261                          * creation of files in the directory.
 262                          */
 263                         retval = VOP_ACCESS(dvp, VWRITE, cred, cnp->cn_proc);
 264                         if (retval)
 265                                 goto exit;
 266
 267                         cnp->cn_flags |= SAVENAME;
 268                         if (!(flags & LOCKPARENT))
 269                                 VOP_UNLOCK(dvp, 0, p);
 270                         retval = EJUSTRETURN;
 271                         goto exit;
 272                 }
 273
 274                 /*
 275                  * Insert name into cache (as non-existent) if appropriate.
 276                  *
 277                  * Disable negative caching since HFS is case-insensitive.
 278                  */
 279 #if 0
 280                 if ((cnp->cn_flags & MAKEENTRY) && nameiop != CREATE)
 281                         cache_enter(dvp, *vpp, cnp);
 282 #endif
 283                 retval = ENOENT;
 284                 goto exit;
 285         }
 286
 287 found:
 288         /*
 289          * Process any fork specifiers
 290          */
 291         if (forknamelen && S_ISREG(attr.ca_mode)) {
 292                 /* fork names are only for lookups */
 293                 if ((nameiop != LOOKUP) && (nameiop != CREATE)) {
 294                         retval = EPERM;
 295                         goto exit;
 296                 }
 297                 cnp->cn_consume = forknamelen;
 298                 flags |= ISLASTCN;
 299         } else {
 300                 wantrsrc = 0;
 301                 forknamelen = 0;
 302         }
 303
 304         /*
 305          * If deleting, and at end of pathname, return
 306          * parameters which can be used to remove file.
 307          */
 308         if (nameiop == DELETE && (flags & ISLASTCN)) {
 309                 /*
 310                 * Write access to directory required to delete files.
 311                 */
 312                 if ((retval = VOP_ACCESS(dvp, VWRITE, cred, cnp->cn_proc)))
 313                         goto exit;
 314
 315                 if (isDot) {    /* Want to return ourselves */
 316                         VREF(dvp);
 317                         *vpp = dvp;
 318                         goto exit;
 319                 } else if (flags & ISDOTDOT) {
 320                         retval = hfs_getcnode(hfsmp, dcp->c_parentcnid,
 321                                 NULL, 0, NULL, NULL, &tvp);
 322                         if (retval)
 323                                 goto exit;
 324                 } else {
 325                         retval = hfs_getcnode(hfsmp, attr.ca_fileid,
 326                                 &desc, wantrsrc, &attr, &fork, &tvp);
 327                         if (retval)
 328                                 goto exit;
 329                 }
 330
 331                 /*
 332                  * If directory is "sticky", then user must own
 333                  * the directory, or the file in it, else she
 334                  * may not delete it (unless she's root). This
 335                  * implements append-only directories.
 336                  */
 337                 if ((dcp->c_mode & S_ISTXT) &&
 338                         (cred->cr_uid != 0) &&
 339                         (cred->cr_uid != dcp->c_uid) &&
 340                         (tvp->v_type != VLNK) &&
 341                         (hfs_owner_rights(hfsmp, VTOC(tvp)->c_uid, cred, p, false))) {
 342                         vput(tvp);
 343                         retval = EPERM;
 344                         goto exit;
 345                 }
 346
 347                 /*
 348                  * If this is a link node then we need to save the name
 349                  * (of the link) so we can delete it from the catalog b-tree.
 350                  * In this case, hfs_remove will then free the component name.
 351                  *
 352                  * DJB - IS THIS STILL NEEDED????
 353                  */
 354                 if (tvp && (VTOC(tvp)->c_flag & C_HARDLINK))
 355                         cnp->cn_flags |= SAVENAME;
 356
 357                 if (!(flags & LOCKPARENT))
 358                         VOP_UNLOCK(dvp, 0, p);
 359                 *vpp = tvp;
 360                 goto exit;
 361          }
 362
 363         /*
 364          * If renaming, return the cnode and save the current name.
 365          */
 366         if (nameiop == RENAME && wantparent && (flags & ISLASTCN)) {
 367                 if ((retval = VOP_ACCESS(dvp, VWRITE, cred, cnp->cn_proc)) != 0)
 368                         goto exit;
 369                 /*
 370                  * Careful about locking second cnode.
 371                  */
 372                 if (isDot) {
 373                         retval = EISDIR;
 374                         goto exit;
 375                 } else if (flags & ISDOTDOT) {
 376                         retval = hfs_getcnode(hfsmp, dcp->c_parentcnid,
 377                                 NULL, 0, NULL, NULL, &tvp);
 378                         if (retval)
 379                                 goto exit;
 380                 } else {
 381                         retval = hfs_getcnode(hfsmp, attr.ca_fileid,
 382                                 &desc, wantrsrc, &attr, &fork, &tvp);
 383                         if (retval)
 384                                 goto exit;
 385                 }
 386                 cnp->cn_flags |= SAVENAME;
 387                 if (!(flags & LOCKPARENT))
 388                         VOP_UNLOCK(dvp, 0, p);
 389                 *vpp = tvp;
 390                 goto exit;
 391          }
 392
 393         /*
 394          * We must get the target cnode before unlocking
 395          * the directory to insure that the cnode will not be removed
 396          * before we get it.  We prevent deadlock by always fetching
 397          * cnodes from the root, moving down the directory tree. Thus
 398          * when following backward pointers ".." we must unlock the
 399          * parent directory before getting the requested directory.
 400          * There is a potential race condition here if both the current
 401          * and parent directories are removed before the VFS_VGET for the
 402          * cnode associated with ".." returns.  We hope that this occurs
 403          * infrequently since we cannot avoid this race condition without
 404          * implementing a sophisticated deadlock detection algorithm.
 405          */
 406         if (flags & ISDOTDOT) {
 407                 VOP_UNLOCK(dvp, 0, p);  /* race to get the cnode */
 408                 retval = hfs_getcnode(hfsmp, dcp->c_parentcnid,
 409                         NULL, 0, NULL, NULL, &tvp);
 410                 if (retval) {
 411                         vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, p);
 412                         goto exit;
 413                 }
 414                 if ((flags & LOCKPARENT) && (flags & ISLASTCN) && (dvp != tvp) &&
 415                     (retval = vn_lock(dvp, LK_EXCLUSIVE, p))) {
 416                         vput(tvp);
 417                         goto exit;
 418                 }
 419                 *vpp = tvp;
 420         } else if (isDot) {
 421                 VREF(dvp);      /* we want ourself, ie "." */
 422                 *vpp = dvp;
 423         } else {
 424                 int type = (attr.ca_mode & S_IFMT);
 425
 426                 if (!(flags & ISLASTCN) && type != S_IFDIR && type != S_IFLNK) {
 427                         retval = ENOTDIR;
 428                         goto exit;
 429                 }
 430
 431                 retval = hfs_getcnode(hfsmp, attr.ca_fileid,
 432                         &desc, wantrsrc, &attr, &fork, &tvp);
 433                 if (retval)
 434                         goto exit;
 435
 436                 if (!(flags & LOCKPARENT) || !(flags & ISLASTCN))
 437                         VOP_UNLOCK(dvp, 0, p);
 438                 *vpp = tvp;
 439         }
 440
 441         /*
 442          * Insert name in cache if appropriate.
 443          *  - "." and ".." are not cached.
 444          *  - Resource fork names are not cached.
 445          *  - Names with composed chars are not cached.
 446          */
 447         if ((cnp->cn_flags & MAKEENTRY)
 448             && !isDot
 449             && !(flags & ISDOTDOT)
 450             && !wantrsrc
 451             && (cnp->cn_namelen == VTOC(*vpp)->c_desc.cd_namelen)) {
 452                 cache_enter(dvp, *vpp, cnp);
 453         }
 454
 455 exit:
 456         cat_releasedesc(&desc);
 457         return (retval);
 458 }
 459
 460
 461
 462 /*
 463  * Based on vn_cache_lookup (which is vfs_cache_lookup in FreeBSD 3.1)
 464  *
 465  * Name caching works as follows:
 466  *
 467  * Names found by directory scans are retained in a cache
 468  * for future reference.  It is managed LRU, so frequently
 469  * used names will hang around.  Cache is indexed by hash value
 470  * obtained from (vp, name) where vp refers to the directory
 471  * containing name.
 472  *
 473  * If it is a "negative" entry, (i.e. for a name that is known NOT to
 474  * exist) the vnode pointer will be NULL.
 475  *
 476  * Upon reaching the last segment of a path, if the reference
 477  * is for DELETE, or NOCACHE is set (rewrite), and the
 478  * name is located in the cache, it will be dropped.
 479  *
 480  */
 481
 482 __private_extern__
 483 int
 484 hfs_cache_lookup(ap)
 485         struct vop_lookup_args /* {
 486                 struct vnode *a_dvp;
 487                 struct vnode **a_vpp;
 488                 struct componentname *a_cnp;
 489         } */ *ap;
 490 {
 491         struct vnode *dvp;
 492         struct vnode *vp;
 493         struct cnode *cp;
 494         int lockparent;
 495         int error;
 496         struct vnode **vpp = ap->a_vpp;
 497         struct componentname *cnp = ap->a_cnp;
 498         struct ucred *cred = cnp->cn_cred;
 499         int flags = cnp->cn_flags;
 500         struct proc *p = cnp->cn_proc;
 501         u_long vpid;    /* capability number of vnode */
 502
 503         *vpp = NULL;
 504         dvp = ap->a_dvp;
 505         lockparent = flags & LOCKPARENT;
 506
 507         /*
 508          * Check accessiblity of directory.
 509          */
 510         if (dvp->v_type != VDIR)
 511                 return (ENOTDIR);
 512         if ((flags & ISLASTCN) && (dvp->v_mount->mnt_flag & MNT_RDONLY) &&
 513             (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
 514                 return (EROFS);
 515         if ((error = VOP_ACCESS(dvp, VEXEC, cred, cnp->cn_proc)))
 516                 return (error);
 517
 518         /*
 519          * Lookup an entry in the cache
 520          * If the lookup succeeds, the vnode is returned in *vpp, and a status of -1 is
 521          * returned. If the lookup determines that the name does not exist
 522          * (negative cacheing), a status of ENOENT is returned. If the lookup
 523          * fails, a status of zero is returned.
 524          */
 525         error = cache_lookup(dvp, vpp, cnp);
 526         if (error == 0)  {              /* Unsuccessfull */
 527                 error = hfs_lookup(ap);
 528                 return (error);
 529         }
 530
 531         if (error == ENOENT)
 532                 return (error);
 533
 534         /* We have a name that matched */
 535         vp = *vpp;
 536         vpid = vp->v_id;
 537
 538         /*
 539          * If this is a hard-link vnode then we need to update
 540          * the name (of the link), the parent ID, the cnid, the
 541          * text encoding and the catalog hint.  This enables
 542          * getattrlist calls to return the correct link info.
 543          */
 544         cp = VTOC(vp);
 545         if ((flags & ISLASTCN) && (cp->c_flag & C_HARDLINK) &&
 546              ((cp->c_parentcnid != VTOC(ap->a_dvp)->c_cnid) ||
 547               (bcmp(cnp->cn_nameptr, cp->c_desc.cd_nameptr, cp->c_desc.cd_namelen) != 0))) {
 548
 549                 struct cat_desc desc;
 550
 551                 /*
 552                  * Get an updated descriptor
 553                  */
 554                 bzero(&desc, sizeof(desc));
 555                 desc.cd_nameptr = cnp->cn_nameptr;
 556                 desc.cd_namelen = cnp->cn_namelen;
 557                 desc.cd_parentcnid = VTOC(ap->a_dvp)->c_cnid;
 558                 desc.cd_hint = VTOC(ap->a_dvp)->c_childhint;
 559                 if (cat_lookup(VTOHFS(vp), &desc, 0, &desc, NULL, NULL) == 0)
 560                         replace_desc(cp, &desc);
 561         }
 562
 563         if (dvp == vp) {        /* lookup on "." */
 564                 VREF(vp);
 565                 error = 0;
 566         } else if (flags & ISDOTDOT) {
 567                 /*
 568                  * Carefull on the locking policy,
 569                  * remember we always lock from parent to child, so have
 570                  * to release lock on child before trying to lock parent
 571                  * then regain lock if needed
 572                  */
 573                 VOP_UNLOCK(dvp, 0, p);
 574                 error = vget(vp, LK_EXCLUSIVE, p);
 575                 if (!error && lockparent && (flags & ISLASTCN))
 576                         error = vn_lock(dvp, LK_EXCLUSIVE, p);
 577         } else {
 578                 if ((flags & ISLASTCN) == 0 && vp->v_type == VREG) {
 579                         int wantrsrc = 0;
 580
 581                         cnp->cn_consume = forkcomponent(cnp, &wantrsrc);
 582
 583                         /* Fork names are only for lookups */
 584                         if (cnp->cn_consume &&
 585                             (cnp->cn_nameiop != LOOKUP && cnp->cn_nameiop != CREATE))
 586                                 return (EPERM);
 587                         /*
 588                          * We only store data forks in the name cache.
 589                          */
 590                         if (wantrsrc)
 591                                 return (hfs_lookup(ap));
 592                 }
 593                 error = vget(vp, LK_EXCLUSIVE, p);
 594                 if (!lockparent || error || !(flags & ISLASTCN))
 595                         VOP_UNLOCK(dvp, 0, p);
 596         }
 597         /*
 598          * Check that the capability number did not change
 599          * while we were waiting for the lock.
 600          */
 601         if (!error) {
 602                 if (vpid == vp->v_id)
 603                         return (0);
 604                 /*
 605                  * The above is the NORMAL exit, after this point is an error
 606                  * condition.
 607                  */
 608                 vput(vp);
 609                 if (lockparent && (dvp != vp) && (flags & ISLASTCN))
 610                         VOP_UNLOCK(dvp, 0, p);
 611         }
 612
 613         if ((error = vn_lock(dvp, LK_EXCLUSIVE, p)))
 614                 return (error);
 615
 616         return (hfs_lookup(ap));
 617 }
 618
 619
 620 /*
 621  * forkcomponent - look for a fork suffix in the component name
 622  *
 623  */
 624 static int
 625 forkcomponent(struct componentname *cnp, int *rsrcfork)
 626 {
 627         char *suffix = cnp->cn_nameptr + cnp->cn_namelen;
 628         int consume = 0;
 629
 630         *rsrcfork = 0;
 631         if (*suffix == '\0')
 632                 return (0);
 633         /*
 634          * There are only 3 valid fork suffixes:
 635          *      "/..namedfork/rsrc"
 636          *      "/..namedfork/data"
 637          *      "/rsrc"  (legacy)
 638          */
 639         if (bcmp(suffix, _PATH_RSRCFORKSPEC, sizeof(_PATH_RSRCFORKSPEC)) == 0) {
 640                 consume = sizeof(_PATH_RSRCFORKSPEC) - 1;
 641                 *rsrcfork = 1;
 642         } else if (bcmp(suffix, _PATH_DATAFORKSPEC, sizeof(_PATH_DATAFORKSPEC)) == 0) {
 643                 consume = sizeof(_PATH_DATAFORKSPEC) - 1;
 644         }
 645
 646 #ifdef LEGACY_FORK_NAMES
 647         else if (bcmp(suffix, LEGACY_RSRCFORKSPEC, sizeof(LEGACY_RSRCFORKSPEC)) == 0) {
 648                 consume = sizeof(LEGACY_RSRCFORKSPEC) - 1;
 649                 *rsrcfork = 1;
 650         }
 651 #endif
 652         return (consume);
 653 }
 654