xnu-124.13.tar.gz

[apple/xnu.git] / bsd / hfs / hfs_lookup.c

/*
 * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 * Copyright (c) 1989, 1993
 *      The Regents of the University of California.  All rights reserved.
 * (c) UNIX System Laboratories, Inc.
 * All or some portions of this file are derived from material licensed
 * to the University of California by American Telephone and Telegraph
 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
 * the permission of UNIX System Laboratories, Inc.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *        notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *        notice, this list of conditions and the following disclaimer in the
 *        documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *        must display the following acknowledgement:
 *      This product includes software developed by the University of
 *      California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *        may be used to endorse or promote products derived from this software
 *        without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.      IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *      @(#)hfs_lookup.c        1.0
 *      derived from @(#)ufs_lookup.c   8.15 (Berkeley) 6/16/95
 *
 *      (c) 1998-1999   Apple Computer, Inc.     All Rights Reserved
 *      (c) 1990, 1992  NeXT Computer, Inc.     All Rights Reserved
 *      
 *
 *      hfs_lookup.c -- code to handle directory traversal on HFS/HFS+ volume
 *
 *      MODIFICATION HISTORY:
 *      21-May-1999 Don Brady           Add support for HFS rooting.
 *      25-Feb-1999 Clark Warner        Fixed the error case of VFS_VGGET when
 *                                      processing DotDot (..) to relock parent
 *      23-Feb-1999 Pat Dirks           Finish cleanup around Don's last fix in "." and ".." handling.
 *      11-Nov-1998 Don Brady           Take out VFS_VGET that got added as part of previous fix.
 *      14-Oct-1998 Don Brady           Fix locking policy volation in hfs_lookup for ".." case
 *                                                              (radar #2279902).
 *       4-Jun-1998 Pat Dirks           Split off from hfs_vnodeops.c
 */

#include <sys/param.h>
#include <sys/namei.h>
#include <sys/buf.h>
#include <sys/file.h>
#include <sys/mount.h>
#include <sys/vnode.h>
#include <sys/malloc.h>
#include <sys/paths.h>

#include        "hfs.h"
#include        "hfs_dbg.h"
#include        "hfscommon/headers/FileMgrInternal.h"

u_int16_t       GetForkFromName(struct componentname  *cnp);
int                     hfs_vget_sibling(struct vnode *vdp, u_int16_t forkType, struct vnode **vpp);
int             hfs_vget_catinfo(struct vnode *parent_vp, struct hfsCatalogInfo *catInfo, u_int32_t forkType, struct vnode **target_vpp);

/*
 *      XXX SER fork strings.
 * Put these someplace better
 */
#define gHFSForkIdentStr        "/"
#define gDataForkNameStr        "data"
#define gRsrcForkNameStr        "rsrc"


#if DBG_VOP_TEST_LOCKS
extern void DbgVopTest(int maxSlots, int retval, VopDbgStoreRec *VopDbgStore, char *funcname);
#endif

/*****************************************************************************
*
*       Operations on vnodes
*
*****************************************************************************/


/*      
 * FROM FREEBSD 3.1
 * Convert a component of a pathname into a pointer to a locked hfsnode.
 * This is a very central and rather complicated routine.
 * If the file system is not maintained in a strict tree hierarchy,
 * this can result in a deadlock situation (see comments in code below).
 *
 * The cnp->cn_nameiop argument is LOOKUP, CREATE, RENAME, or DELETE depending
 * on whether the name is to be looked up, created, renamed, or deleted.
 * When CREATE, RENAME, or DELETE is specified, information usable in
 * creating, renaming, or deleting a directory entry may be calculated.
 * Notice that these are the only operations that can affect the directory of the target.
 *
 * If flag has LOCKPARENT or'ed into it and the target of the pathname
 * exists, lookup returns both the target and its parent directory locked.
 * When creating or renaming and LOCKPARENT is specified, the target may
 * not be ".".  When deleting and LOCKPARENT is specified, the target may
 * be "."., but the caller must check to ensure it does an vrele and vput
 * instead of two vputs.
 *
 * LOCKPARENT and WANTPARENT actually refer to the parent of the last item,
 * so if ISLASTCN is not set, they should be ignored. Also they are mutually exclusive, or
 * WANTPARENT really implies DONTLOCKPARENT. Either of them set means that the calling
 * routine wants to access the parent of the target, locked or unlocked.
 *
 * Keeping the parent locked as long as possible protects from other processes
 * looking up the same item, so it has to be locked until the hfsnode is totally finished
 *
 * This routine is actually used as VOP_CACHEDLOOKUP method, and the
 * filesystem employs the generic hfs_cache_lookup() as VOP_LOOKUP
 * method.
 *
 * hfs_cache_lookup() performs the following for us:
 *      check that it is a directory
 *      check accessibility of directory
 *      check for modification attempts on read-only mounts
 *      if name found in cache
 *              if at end of path and deleting or creating
 *              drop it
 *               else
 *              return name.
 *      return VOP_CACHEDLOOKUP()
 *
 * Overall outline of hfs_lookup:
 *
 *      handle simple cases of . and ..
 *      search for name in directory, to found or notfound
 * notfound:
 *      if creating, return locked directory, leaving info on available slots
 *      else return error
 * found:
 *      if at end of path and deleting, return information to allow delete
 *      if at end of path and rewriting (RENAME and LOCKPARENT), lock target
 *        inode and return info to allow rewrite
 *      if not at end, add name to cache; if at end and neither creating
 *        nor deleting, add name to cache
 */

/*      
 *      Lookup *nm in directory *pvp, return it in *a_vpp.
 *      **a_vpp is held on exit.
 *      We create a hfsnode for the file, but we do NOT open the file here.

#% lookup       dvp L ? ?
#% lookup       vpp - L -

        IN struct vnode *dvp - Parent node of file;
        INOUT struct vnode **vpp - node of target file, its a new node if the target vnode did not exist;
        IN struct componentname *cnp - Name of file;

 *      When should we lock parent_hp in here ??
 */

int
hfs_lookup(ap)
        struct vop_cachedlookup_args /* {
                struct vnode *a_dvp;
                struct vnode **a_vpp;
                struct componentname *a_cnp;
        } */ *ap;
{
        struct vnode                                    *parent_vp;
        struct vnode                                    *target_vp;
        struct vnode                                    *tparent_vp;
        struct hfsnode                                  *parent_hp;                             /* parent */
        struct componentname                    *cnp;
        struct ucred                                    *cred;
        struct proc                                             *p;
        struct hfsCatalogInfo                   catInfo;
        u_int32_t                                               parent_id;
        u_int32_t                                               nodeID;
        u_int16_t                                               targetLen;
        u_int16_t                                               forkType;
        int                                                     flags;
        int                                                             lockparent;                                             /* !0 => lockparent flag is set */
        int                                                             wantparent;                                             /* !0 => wantparent or lockparent flag */
        int                                                             nameiop;
        int                                                             retval;
        u_char                                                  isDot, isDotDot, found;
        DBG_FUNC_NAME("lookup");
        DBG_VOP_LOCKS_DECL(2);
        DBG_VOP_LOCKS_INIT(0,ap->a_dvp, VOPDBG_LOCKED, VOPDBG_IGNORE, VOPDBG_IGNORE, VOPDBG_POS);
        DBG_VOP_LOCKS_INIT(1,*ap->a_vpp, VOPDBG_IGNORE, VOPDBG_LOCKED, VOPDBG_IGNORE, VOPDBG_POS);
        DBG_VOP_PRINT_FUNCNAME();DBG_VOP_CONT(("\n"));
        DBG_HFS_NODE_CHECK(ap->a_dvp);


        /*
         * Do initial setup
         */
        INIT_CATALOGDATA(&catInfo.nodeData, 0);
        parent_vp               = ap->a_dvp;
        cnp                             = ap->a_cnp;
        parent_hp               = VTOH(parent_vp);                              /* parent */
        target_vp               = NULL;
        targetLen               = cnp->cn_namelen;
        nameiop                 = cnp->cn_nameiop;
        cred                    = cnp->cn_cred;
        p                               = cnp->cn_proc;
        lockparent              = cnp->cn_flags & LOCKPARENT;
        wantparent              = cnp->cn_flags & (LOCKPARENT|WANTPARENT);
        flags                   = cnp->cn_flags;
        parent_id               = H_FILEID(parent_hp);
        nodeID                  = kUnknownID;
        found                   = FALSE;
        isDot                   = FALSE;
        isDotDot                = FALSE;
        retval                  = E_NONE;
        forkType                = kUndefinedFork;


        /*
         * We now have a segment name to search for, and a directory to search.
         *
         */

        /*
         * First check to see if it is a . or .., else look it up.
         */

        if (flags & ISDOTDOT) {                                                                 /* Wanting the parent */
                isDotDot = TRUE;
                found = TRUE;                                                                           /* .. is always defined */
                nodeID = H_DIRID(parent_hp);
        }                                                                                                               /* Wanting ourselves */
        else if ((cnp->cn_nameptr[0] == '.') && (targetLen == 1)) {
                isDot = TRUE;
                found = TRUE;                                                                           /* We always know who we are */
        } 
        else {                                                                                                  /* Wanting something else */
                catInfo.hint = kNoHint;

                /* lock catalog b-tree */
                retval = hfs_metafilelocking(VTOHFS(parent_vp), kHFSCatalogFileID, LK_SHARED, p);
                if (retval)
                           goto Err_Exit;

                retval = hfs_getcatalog (VTOVCB(parent_vp), parent_id, cnp->cn_nameptr, targetLen, &catInfo);
        
        /* unlock catalog b-tree */
                (void) hfs_metafilelocking(VTOHFS(parent_vp), kHFSCatalogFileID, LK_RELEASE, p);
        
                if (retval == E_NONE)
                        found = TRUE;
        };


        /*
         * At this point we know IF we have a valid dir/name.
         */


        retval = E_NONE;
        if (! found) {
        /*
         * This is a non-existing entry
         *
         * If creating, and at end of pathname and current
         * directory has not been removed, then can consider
         * allowing file to be created.
         */
        if ((nameiop == CREATE || nameiop == RENAME ||
                        (nameiop == DELETE &&
                        (ap->a_cnp->cn_flags & DOWHITEOUT) &&
                        (ap->a_cnp->cn_flags & ISWHITEOUT))) &&
                        (flags & ISLASTCN)) {
                /*
                 * Access for write is interpreted as allowing
                 * creation of files in the directory.
                 */
                retval = VOP_ACCESS(parent_vp, VWRITE, cred, cnp->cn_proc);
                if (retval)
                        return (retval);
        
                cnp->cn_flags |= SAVENAME;
                if (!lockparent)
                        VOP_UNLOCK(parent_vp, 0, p);
                retval = EJUSTRETURN;
                goto Err_Exit;
                }
        
                /*
                 * Insert name into cache (as non-existent) if appropriate.
                 */

                /*
                * XXX SER - Here we would store the name in cache as non-existant if not trying to create it, but,
        * the name cache IS case-sensitive, thus maybe showing a negative hit, when the name
        * is only different by case. So hfs does not support negative caching. Something to look at.
        * (See radar 2293594 for a failed example)
                if ((cnp->cn_flags & MAKEENTRY) && nameiop != CREATE)
                        cache_enter(parent_vp, *vpp, cnp);
                */
        
                retval = ENOENT;
        }
        else {
                /*
                 * We have found an entry
                 *
                 * Here we have to decide what type of vnode to create.
                 * There are 3 type of objects that are given:
                 * 1. '.': return the same dp
                 * 2. '..' return the parent of dp, always a VDIR
                 * 3. catinfo rec: return depending on type:
                 *  A. VDIR, nodeType is kCatalogFolderNode
                 *  B. VLINK nodeType is kCatalogFileNode, the mode is IFLNK (esp. if it is a link to a directory e.g. bar/link/foo)
                 *  C. VREG, nodeType is kCatalogFileNode, forkType at this point is unknown
                 * To determine the forkType, we can use this algorithm (\0 in the strings mean the NULL character):
                 * a. forkType is kDataType iff ISLASTCN is set (as in the case of the default fork e.g. data/foo).
                 * b. forkType is kDataType iff ISLASTCN is not set and the namePtr is followed by "/?AppleHFSFork/data\0"
                 * c. forkType is kRsrcType iff ISLASTCN is not set and the namePtr is followed by "/?AppleHFSFork/rsrc\0"
                 * If the latter two are correct, then we 'consume' the remaining of the name buffer
                 * and set the cnp as appropriate.
                 * Anything else returns an retval
                 */

                
                /*
                 * If deleting, and at end of pathname, return
                 * parameters which can be used to remove file.
                 * If the wantparent flag isn't set, we return only
                 * the directory (in ndp->ndvp), otherwise we go
                 * on and lock the hfsnode, being careful with ".".
                 *
                 * Forks cannot be deleted so scan-ahead is illegal, so just return the default fork
                 */
                if (nameiop == DELETE && (flags & ISLASTCN)) {
                        /*
                        * Write access to directory required to delete files.
                        */
                        retval = VOP_ACCESS(parent_vp, VWRITE, cred, cnp->cn_proc);
                        if (retval)
                                goto Err_Exit;
        
                        if (isDot) {                                    /* Want to return ourselves */
                                VREF(parent_vp);
                                target_vp = parent_vp;
                                goto Err_Exit;
                        }
                        else if (isDotDot) {
                                retval = VFS_VGET(parent_vp->v_mount, &nodeID, &target_vp);
                                if (retval)
                                        goto Err_Exit;
                        }
                        else {
                                retval = hfs_vget_catinfo(parent_vp, &catInfo, kAnyFork, &target_vp);
                                if (retval)
                                        goto Err_Exit;
                                CLEAN_CATALOGDATA(&catInfo.nodeData);
                        };


                        /*
                         * If directory is "sticky", then user must own
                         * the directory, or the file in it, else she
                         * may not delete it (unless she's root). This
                         * implements append-only directories.
                         */
                        if ((parent_hp->h_meta->h_mode & ISVTX) &&
                                (cred->cr_uid != 0) &&
                                (cred->cr_uid != parent_hp->h_meta->h_uid) &&
                                (target_vp->v_type != VLNK) &&
                                (hfs_owner_rights(target_vp, cred, p, false))) {
                                vput(target_vp);
                                retval = EPERM;
                                goto Err_Exit;
                        }
#if HFS_HARDLINKS
                        /*
                         * If this is a link node then we need to save the name
                         * (of the link) so we can delete it from the catalog b-tree.
                         * In this case, hfs_remove will then free the component name.
                         */
                        if (target_vp && (VTOH(target_vp)->h_meta->h_metaflags & IN_DATANODE))
                                cnp->cn_flags |= SAVENAME;
#endif
          
                        if (!lockparent)
                                VOP_UNLOCK(parent_vp, 0, p);
                        goto Err_Exit;
                 };
        
                /*
                 * If rewriting 'RENAME', return the hfsnode and the
                 * information required to rewrite the present directory
                 */
                if (nameiop == RENAME && wantparent && (cnp->cn_flags & ISLASTCN)) {
        
                        if ((retval = VOP_ACCESS(parent_vp, VWRITE, cred, cnp->cn_proc)) != 0)
                                goto Err_Exit;

                        /*
                         * Careful about locking second inode.
                         * This can only occur if the target is ".". like 'mv foo/bar foo/.'
                         */
                        if (isDot) {
                                retval = EISDIR;
                                goto Err_Exit;
                        }
                        else if (isDotDot) {
                                retval = VFS_VGET(parent_vp->v_mount, &nodeID, &target_vp);
                                if (retval)
                                        goto Err_Exit;
                        }
            else {
                /* If then name differs in case, then act like it does not exist
                 * This allows renaming foo->Foo
                 * Exclude length difference due to compose/decompe issues.
                 */
                if ((cnp->cn_namelen == catInfo.nodeData.cnm_length) &&
                    strncmp(cnp->cn_nameptr, catInfo.nodeData.cnm_nameptr, targetLen)) {
                    if (!lockparent)
                        VOP_UNLOCK(parent_vp, 0, p);
                    retval = EJUSTRETURN;
                    goto Err_Exit;
                };

                retval = hfs_vget_catinfo(parent_vp, &catInfo, kAnyFork, &target_vp);
                if (retval)
                    goto Err_Exit;

                CLEAN_CATALOGDATA(&catInfo.nodeData);   /* Should do nothing */
            };
                        
                        cnp->cn_flags |= SAVENAME;
                        if (!lockparent)
                                VOP_UNLOCK(parent_vp, 0, p);

                        goto Err_Exit;
                /* Finished...all is well, goto the end */
                 };
        
                /*
                 * Step through the translation in the name.  We do not `vput' the
                 * directory because we may need it again if a symbolic link
                 * is relative to the current directory.  Instead we save it
                 * unlocked as "tparent_vp".  We must get the target hfsnode before unlocking
                 * the directory to insure that the hfsnode will not be removed
                 * before we get it.  We prevent deadlock by always fetching
                 * inodes from the root, moving down the directory tree. Thus
                 * when following backward pointers ".." we must unlock the
                 * parent directory before getting the requested directory.
                 * There is a potential race condition here if both the current
                 * and parent directories are removed before the VFS_VGET for the
                 * hfsnode associated with ".." returns.  We hope that this occurs
                 * infrequently since we cannot avoid this race condition without
                 * implementing a sophisticated deadlock detection algorithm.
                 * Note also that this simple deadlock detection scheme will not
                 * work if the file system has any hard links other than ".."
                 * that point backwards in the directory structure.
                 */
        
                tparent_vp = parent_vp;
                if (isDotDot) {
                        VOP_UNLOCK(tparent_vp, 0, p);   /* race to get the inode */
                        if ((retval = VFS_VGET(parent_vp->v_mount, &nodeID, &target_vp))) {
                        vn_lock(tparent_vp, LK_EXCLUSIVE | LK_RETRY, p);
                        goto Err_Exit;
                }
                        if (lockparent && (flags & ISLASTCN) && (tparent_vp != target_vp) && 
                            (retval = vn_lock(tparent_vp, LK_EXCLUSIVE, p))) {
                                vput(target_vp);
                                goto Err_Exit;
                        }
                }
                else if (isDot) {
                        VREF(parent_vp);        /* we want ourself, ie "." */
                        target_vp = parent_vp;
                }
                else {
                        mode_t mode;
                        /* 
                         * Determine what fork to get, currenty 3 scenarios are supported:
                         * 1. ./foo: if it is a dir, return a VDIR else return data fork
                         * 2. ./foo/.__Fork/data: return data fork
                         * 3. ./foo/.__Fork/rsrc: return resource fork
                         * So the algorithm is:
                         * If the object is a directory
                         *      then return a VDIR vnode
                         * else if ISLASTCN is true
                         *      then get the vnode with forkType=kDataFork
                         * else
                         *      compare with the remaining cnp buffer with "/.__Fork/"
                         *      if a match
                         *              then compare string after that with either 'data' or 'rsrc'
                         *              if match
                         *                      then 
                         *                      'consume' rest of cnp, setting appropriate values and flags
                         *                      return vnode depending on match
                         *              else
                         *                      bad fork name
                         *      else
                         *              illegal path after a file object
                         */

                        mode = (mode_t)(catInfo.nodeData.cnd_mode);
                        
                        if (catInfo.nodeData.cnd_type == kCatalogFolderNode) {
                                forkType = kDirectory;                          /* Really ignored */
                        } 
                        else if ((mode & IFMT) == IFLNK) {
                                forkType = kDataFork;
                        }                                                                       /* After this point, nodeType should be a file */
                        else if (flags & ISLASTCN) {                    /* Create a default fork */
                                forkType = kDataFork;
                }
                        else {                                                                  /* determine what fork was specified */
                                forkType = GetForkFromName(cnp);
                                flags |= ISLASTCN;                                      /* To know to unlock the parent if needed */
                        };      /* else */

                        
                        /* If couldn't determine what type of fork, leave */
                        if (forkType == kUndefinedFork) {                               
                                retval = EISDIR;
                                goto Err_Exit;
                        };
                                
                        /* Get the vnode now that what type of fork is known */
                        DBG_ASSERT((forkType==kDirectory) || (forkType==kDataFork) || (forkType==kRsrcFork));
                        retval = hfs_vget_catinfo(tparent_vp, &catInfo, forkType, &target_vp);
                        if (retval != E_NONE)
                                goto Err_Exit;

                        if (!lockparent || !(flags & ISLASTCN))
                                VOP_UNLOCK(tparent_vp, 0, p);

                        CLEAN_CATALOGDATA(&catInfo.nodeData);

                };      /* else found */


                /*
                * Insert name in cache if wanted.
                 * Names with composed chars are not put into the name cache.
                 * Resource forks are not entered in the name cache. This
                 * avoids deadlocks.
                 */
                if ((cnp->cn_flags & MAKEENTRY)
                    && (cnp->cn_namelen == catInfo.nodeData.cnm_length)
                        && ((H_FORKTYPE(VTOH(target_vp))) != kRsrcFork))        {
                        /*
                         * XXX SER - Might be good idea to bcopy(catInfo.nodeData.fsspec.name, cnp->cn_nameptr)
                         * to "normalize" the name cache. This will avoid polluting the name cache with
                         * names that are different in case, and allow negative caching
                         */
                        cache_enter(parent_vp, target_vp, cnp);
                        }
        


        };      /* else found == TRUE */
        
Err_Exit:

        CLEAN_CATALOGDATA(&catInfo.nodeData);           /* Just to make sure */
        *ap->a_vpp = target_vp;

        DBG_VOP_UPDATE_VP(1, *ap->a_vpp);
        //DBG_VOP_LOOKUP_TEST (funcname, cnp, parent_vp, target_vp);
        //DBG_VOP_LOCKS_TEST(E_NONE);

        return (retval);
}



/*
 * Based on vn_cache_lookup (which is vfs_cache_lookup in FreeBSD 3.1)
 *
 * Name caching works as follows:
 *
 * Names found by directory scans are retained in a cache
 * for future reference.  It is managed LRU, so frequently
 * used names will hang around.  Cache is indexed by hash value
 * obtained from (vp, name) where vp refers to the directory
 * containing name.
 *
 * If it is a "negative" entry, (i.e. for a name that is known NOT to
 * exist) the vnode pointer will be NULL.
 *
 * Upon reaching the last segment of a path, if the reference
 * is for DELETE, or NOCACHE is set (rewrite), and the
 * name is located in the cache, it will be dropped.
 *
 * In hfs, since a name can represent multiple forks, it cannot
 * be known what fork the name matches, so further checks have to be done.
 * Currently a policy of first requested, is the one stored, is followed.
 *
 * SER XXX If this proves inadequate maybe we can munge the name to contain a fork reference
 * like foo -> foo.d for the data fork.
 */

int
hfs_cache_lookup(ap)
        struct vop_lookup_args /* {
                struct vnode *a_dvp;
                struct vnode **a_vpp;
                struct componentname *a_cnp;
        } */ *ap;
{
        struct vnode *vdp;
        struct vnode *pdp;
        int lockparent; 
        int error;
        struct vnode **vpp = ap->a_vpp;
        struct componentname *cnp = ap->a_cnp;
        struct ucred *cred = cnp->cn_cred;
        int flags = cnp->cn_flags;
        struct proc *p = cnp->cn_proc;
        struct hfsnode *hp;
        u_int32_t vpid; /* capability number of vnode */
        DBG_FUNC_NAME("cache_lookup");
        DBG_VOP_LOCKS_DECL(2);
        DBG_VOP_LOCKS_INIT(0,ap->a_dvp, VOPDBG_LOCKED, VOPDBG_IGNORE, VOPDBG_IGNORE, VOPDBG_POS);
        DBG_VOP_LOCKS_INIT(1,*ap->a_vpp, VOPDBG_IGNORE, VOPDBG_LOCKED, VOPDBG_IGNORE, VOPDBG_POS);
        DBG_VOP_PRINT_FUNCNAME();DBG_VOP_CONT(("\n"));
    DBG_VOP_CONT(("\tTarget: "));DBG_VOP_PRINT_CPN_INFO(ap->a_cnp);DBG_VOP_CONT(("\n"));
        DBG_HFS_NODE_CHECK(ap->a_dvp);

        *vpp = NULL;
        vdp = ap->a_dvp;
        lockparent = flags & LOCKPARENT;

        if (vdp->v_type != VDIR)
                                return (ENOTDIR);

        if ((flags & ISLASTCN) && (vdp->v_mount->mnt_flag & MNT_RDONLY) &&
                (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
                return (EROFS);

        error = VOP_ACCESS(vdp, VEXEC, cred, cnp->cn_proc);

        if (error)
                return (error);

        /*
         * Lookup an entry in the cache
         * If the lookup succeeds, the vnode is returned in *vpp, and a status of -1 is
         * returned. If the lookup determines that the name does not exist
         * (negative cacheing), a status of ENOENT is returned. If the lookup
         * fails, a status of zero is returned.
         */
        error = cache_lookup(vdp, vpp, cnp);

        if (error == 0)  {              /* Unsuccessfull */
                DBG_VOP(("\tWas not in name cache\n"));
                error = hfs_lookup(ap);
#if HFS_HARDLINKS
                if (error)
                        return (error);
                /*
                 * If this is a hard-link vnode then we need to update
                 * the name (of the link) and update the parent ID. This
                 * enables getattrlist calls to return correct link info.
                 */
                hp = VTOH(*ap->a_vpp);
                if ((flags & ISLASTCN) && (hp->h_meta->h_metaflags & IN_DATANODE)) {
                        H_DIRID(hp) = H_FILEID(VTOH(ap->a_dvp));
                        hfs_set_metaname(cnp->cn_nameptr, hp->h_meta, HTOHFS(hp));
                }
#endif
                return (error);
        };
        
        DBG_VOP(("\tName was found in the name cache"));
        if (error == ENOENT) {
                DBG_VOP_CONT((" though it was a NEGATIVE HIT\n"));
                return (error);
        };
        DBG_VOP_CONT(("\n"));
        
#if HFS_HARDLINKS
        /*
         * If this is a hard-link vnode then we need to update
         * the name (of the link) and update the parent ID. This
         * enables getattrlist calls to return correct link info.
         */
        hp = VTOH(*vpp);
        if ((flags & ISLASTCN) && (hp->h_meta->h_metaflags & IN_DATANODE)) {
                H_DIRID(hp) = H_FILEID(VTOH(vdp));
                hfs_set_metaname(cnp->cn_nameptr, hp->h_meta, HTOHFS(hp));
        }
#endif

        /* We have a name that matched */
        pdp = vdp;
        vdp = *vpp;
        vpid = vdp->v_id;
        if (pdp == vdp) {       /* lookup on "." */
                VREF(vdp);
                error = 0;
        } else if (flags & ISDOTDOT) {
                /* 
                 * Carefull on the locking policy,
                 * remember we always lock from parent to child, so have
                 * to release lock on child before trying to lock parent
                 * then regain lock if needed
                 */
                VOP_UNLOCK(pdp, 0, p);
                error = vget(vdp, LK_EXCLUSIVE, p);
                if (!error && lockparent && (flags & ISLASTCN))
                        error = vn_lock(pdp, LK_EXCLUSIVE, p);
        } else {
                /* 
                 * Check to see if a specific fork is not being requested.
                 *
                 * If it is a file and not the last path item
                 * then check if its a proper fork
                 *              If it is, check to see if the matched vnode is the same fork
                 *      else see if the proper fork exists.
                 *              If it does, return that one, else do VOP_CACHEDLOOKUP()
                 * Notice that nothing is done if an undefined fork is named. Just leave and let lookup()
                 * handle strange cases.
                 *
                 * XXX SER Notice that when the target is not what was in the name cache,
                 * it is locked, before trying to get its sibling. Could this be a problem since both 
                 * siblings can be locked, but not in a determinalistic order????
                 */
                u_int16_t       forkType;
                                 
                error = vget(vdp, LK_EXCLUSIVE, p);
                if ((! error) && (vdp->v_type == VREG) && (vpid == vdp->v_id)) {
                        if (!(flags & ISLASTCN)) {
                                forkType = GetForkFromName(cnp);
                                if (forkType != kUndefinedFork) {
                                        flags |= ISLASTCN;
                                        if (H_FORKTYPE(VTOH(vdp)) != forkType) {
                                                error = hfs_vget_sibling(vdp, forkType, vpp);
                                                vput(vdp);
                                                if (! error) {
                                                        vdp = *vpp;
                                                        vpid = vdp->v_id;
                                                }
                                        }
                                }
                        } 
                        else {
                                /* Its the last item, so we want the data fork */
                                if (H_FORKTYPE(VTOH(vdp)) != kDataFork) {
                                        error = hfs_vget_sibling(vdp, kDataFork, vpp);
                                        vput(vdp);
                                        if (! error) {
                                                vdp = *vpp;
                                                vpid = vdp->v_id;
                                        }
                                }
                        };
                };
                if (!lockparent || error || !(flags & ISLASTCN))
                        VOP_UNLOCK(pdp, 0, p);
        };
        /*
         * Check that the capability number did not change
         * while we were waiting for the lock.
         */
        if (!error) {
                if (vpid == vdp->v_id)
                        return (0);             /* HERE IS THE NORMAL EXIT FOR CACHE LOOKUP!!!! */
                /*
                 * The above is the NORMAL exit, after this point is an error
                 * condition.
                 */
                vput(vdp);
                if (lockparent && pdp != vdp && (flags & ISLASTCN))
                        VOP_UNLOCK(pdp, 0, p);
        }
        error = vn_lock(pdp, LK_EXCLUSIVE, p);
        if (error)
                return (error);
        return (hfs_lookup(ap));
}

/*
 *      Parses a componentname and sees if the remaining path
 *      contains a hfs named fork specifier. If it does set the
 *      componentname to consume the rest of the path, and
 *      return the forkType
 */

u_int16_t       GetForkFromName(struct componentname  *cnp)
{
        u_int16_t       forkType        = kUndefinedFork;
        char            *tcp            = cnp->cn_nameptr + cnp->cn_namelen;

        if (bcmp(tcp, _PATH_FORKSPECIFIER, sizeof(_PATH_FORKSPECIFIER) - 1) == 0) {             
                /* Its a HFS fork, so far */
                tcp += (sizeof(_PATH_FORKSPECIFIER) - 1);
                if (bcmp(tcp, _PATH_DATANAME, sizeof(_PATH_DATANAME)) == 0) {
                        forkType = kDataFork;
                        cnp->cn_consume = sizeof(_PATH_FORKSPECIFIER) + sizeof(_PATH_DATANAME) - 2;
                }
                else if (bcmp(tcp, _PATH_RSRCNAME, sizeof(_PATH_RSRCNAME)) == 0) {
                        forkType = kRsrcFork;
                        cnp->cn_consume = sizeof(_PATH_FORKSPECIFIER) + sizeof(_PATH_RSRCNAME) - 2;
                };      /* else if */
        };      /* if bcmp */   


        /* XXX SER For backwards compatability...keep it */
        if (forkType == kUndefinedFork) {
                tcp = cnp->cn_nameptr + cnp->cn_namelen;
        if (bcmp(tcp, gHFSForkIdentStr, sizeof(gHFSForkIdentStr) - 1) == 0) {           
                /* Its a HFS fork, so far */
                tcp += (sizeof(gHFSForkIdentStr) - 1);
                if (bcmp(tcp, gDataForkNameStr, sizeof(gDataForkNameStr)) == 0) {
                        forkType = kDataFork;
                        cnp->cn_consume = sizeof(gHFSForkIdentStr) + sizeof(gDataForkNameStr) - 2;
                }
                else if (bcmp(tcp, gRsrcForkNameStr, sizeof(gRsrcForkNameStr)) == 0) {
                        forkType = kRsrcFork;
                        cnp->cn_consume = sizeof(gHFSForkIdentStr) + sizeof(gRsrcForkNameStr) - 2;
                };      /* else if */
        };      /* if bcmp */                                                           
        };                                                      

        return forkType;        
}

#if DBG_VOP_TEST_LOCKS

void DbgLookupTest( char *funcname, struct componentname  *cnp, struct vnode *dvp, struct vnode *vp)
{
        if (! (hfs_dbg_lookup || hfs_dbg_all))
                return;
                
                
        if (dvp) {
                if (lockstatus(&VTOH(dvp)->h_lock)) {
                        DBG_LOOKUP (("%s: Parent vnode exited LOCKED", funcname));
                }
                else {
                        DBG_LOOKUP (("%s: Parent vnode exited UNLOCKED", funcname));
                }
        }

        if (vp) {
                if (vp==dvp)
                  {
                        DBG_LOOKUP (("%s: Target and Parent are the same", funcname));
                  }
                else {
                        if (lockstatus(&VTOH(vp)->h_lock)) {
                                DBG_LOOKUP (("%s: Found vnode exited LOCKED", funcname));
                        }
                        else {
                                DBG_LOOKUP (("%s: Found vnode exited LOCKED", funcname));
                        }
                }
                DBG_LOOKUP (("%s: Found vnode 0x%x has vtype of %d\n ", funcname, (u_int)vp, vp->v_type));
        }
        else
                DBG_LOOKUP (("%s: Found vnode exited NULL\n",  funcname));


}

#endif /* DBG_VOP_TEST_LOCKS */