[apple/hfs.git] / livefiles_hfs_plugin / lf_hfs_lookup.c

//
//  lf_hfs_lookup.c
//  livefiles_hfs
//
//  Created by Yakov Ben Zaken on 25/03/2018.
//

#include "lf_hfs.h"
#include "lf_hfs_lookup.h"
#include "lf_hfs_cnode.h"
#include "lf_hfs_vfsutils.h"
#include "lf_hfs_link.h"

static int
hfs_lookup(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp, int *cnode_locked)
{
    struct cnode *dcp;    /* cnode for directory being searched */
    struct vnode *tvp;    /* target vnode */
    struct hfsmount *hfsmp;
    int flags;
    int nameiop;
    int retval = 0;
    struct cat_desc desc;
    struct cat_desc cndesc;
    struct cat_attr attr;
    struct cat_fork fork;
    int lockflags;
    int newvnode_flags = 0;
    
retry:
    newvnode_flags = 0;
    dcp = NULL;
    hfsmp = VTOHFS(dvp);
    *vpp = NULL;
    *cnode_locked = 0;
    tvp = NULL;
    nameiop = cnp->cn_nameiop;
    flags = cnp->cn_flags;
    bzero(&desc, sizeof(desc));

    if (hfs_lock(VTOC(dvp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT) != 0) {
        retval = ENOENT;  /* The parent no longer exists ? */
        goto exit;
    }
    dcp = VTOC(dvp);

    /*
     * Need to understand if we need this check.. as we took exclusive lock..
     */
    if (dcp->c_flag & C_DIR_MODIFICATION){
        hfs_unlock(dcp);
        usleep( 1000 );
        goto retry;
    }

    /*
     * We shouldn't need to go to the catalog if there are no children.
     * However, in the face of a minor disk corruption where the valence of
     * the directory is off, we could infinite loop here if we return ENOENT
     * even though there are actually items in the directory.  (create will
     * see the ENOENT, try to create something, which will return with
     * EEXIST over and over again).  As a result, always check the catalog.
     */

    bzero(&cndesc, sizeof(cndesc));
    cndesc.cd_nameptr = (const u_int8_t *)cnp->cn_nameptr;
    cndesc.cd_namelen = cnp->cn_namelen;
    cndesc.cd_parentcnid = dcp->c_fileid;
    cndesc.cd_hint = dcp->c_childhint;

    lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
    retval = cat_lookup(hfsmp, &cndesc, 0, &desc, &attr, &fork, NULL);
    hfs_systemfile_unlock(hfsmp, lockflags);

    if (retval == 0) {
        dcp->c_childhint = desc.cd_hint;
        /*
         * Note: We must drop the parent lock here before calling
         * hfs_getnewvnode (which takes the child lock).
         */
        hfs_unlock(dcp);
        dcp = NULL;

        /* Verify that the item just looked up isn't one of the hidden directories. */
        if (desc.cd_cnid == hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid ||
            desc.cd_cnid == hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid) {
            retval = ENOENT;
            goto exit;
        }
        goto found;
    }

    if (retval == HFS_ERESERVEDNAME) {
        /*
         * We found the name in the catalog, but it is unavailable
         * to us. The exact error to return to our caller depends
         * on the operation, and whether we've already reached the
         * last path component. In all cases, avoid a negative
         * cache entry, since someone else may be able to access
         * the name if their lookup is configured differently.
         */

        cnp->cn_flags &= ~MAKEENTRY;

        if (((flags & ISLASTCN) == 0) || ((nameiop == LOOKUP) || (nameiop == DELETE))) {
            /* A reserved name for a pure lookup is the same as the path not being present */
            retval = ENOENT;
        } else {
            /* A reserved name with intent to create must be rejected as impossible */
            retval = EEXIST;
        }
    }
    if (retval != ENOENT)
        goto exit;
    /*
     * 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) &&
        (flags & ISLASTCN) &&
        !(ISSET(dcp->c_flag, C_DELETED | C_NOEXISTS))) {
        retval = EJUSTRETURN;
        goto exit;
    }
    
    goto exit;

found:
    if (flags & ISLASTCN) {
        switch(nameiop) {
            case DELETE:
                cnp->cn_flags &= ~MAKEENTRY;
                break;

            case RENAME:
                cnp->cn_flags &= ~MAKEENTRY;
                break;
            default:
                break;
        }
    }

    int type = (attr.ca_mode & S_IFMT);

    if (!(flags & ISLASTCN) && (type != S_IFDIR) && (type != S_IFLNK)) {
        retval = ENOTDIR;
        goto exit;
    }
    /* Don't cache directory hardlink names. */
    if (attr.ca_recflags & kHFSHasLinkChainMask) {
        cnp->cn_flags &= ~MAKEENTRY;
    }
    /* Names with composed chars are not cached. */
    if (cnp->cn_namelen != desc.cd_namelen)
        cnp->cn_flags &= ~MAKEENTRY;
    
    retval = hfs_getnewvnode(hfsmp, dvp, cnp, &desc, 0, &attr, &fork, &tvp, &newvnode_flags);
    
    if (retval) {
        /*
         * If this was a create/rename operation lookup, then by this point
         * we expected to see the item returned from hfs_getnewvnode above.
         * In the create case, it would probably eventually bubble out an EEXIST
         * because the item existed when we were trying to create it.  In the
         * rename case, it would let us know that we need to go ahead and
         * delete it as part of the rename.  However, if we hit the condition below
         * then it means that we found the element during cat_lookup above, but
         * it is now no longer there.  We simply behave as though we never found
         * the element at all and return EJUSTRETURN.
         */
        if ((retval == ENOENT) &&
            ((cnp->cn_nameiop == CREATE) || (cnp->cn_nameiop == RENAME)) &&
            (flags & ISLASTCN)) {
            retval = EJUSTRETURN;
        }

        /*
         * If this was a straight lookup operation, we may need to redrive the entire
         * lookup starting from cat_lookup if the element was deleted as the result of
         * a rename operation.  Since rename is supposed to guarantee atomicity, then
         * lookups cannot fail because the underlying element is deleted as a result of
         * the rename call -- either they returned the looked up element prior to rename
         * or return the newer element.  If we are in this region, then all we can do is add
         * workarounds to guarantee the latter case. The element has already been deleted, so
         * we just re-try the lookup to ensure the caller gets the most recent element.
         */
        if ((retval == ENOENT) && (cnp->cn_nameiop == LOOKUP) &&
            (newvnode_flags & (GNV_CHASH_RENAMED | GNV_CAT_DELETED))) {
            if (dcp) {
                hfs_unlock (dcp);
            }
            /* get rid of any name buffers that may have lingered from the cat_lookup call */
            cat_releasedesc (&desc);
            goto retry;
        }

        /* Also, re-drive the lookup if the item we looked up was a hardlink, and the number
         * or name of hardlinks has changed in the interim between the cat_lookup above, and
         * our call to hfs_getnewvnode.  hfs_getnewvnode will validate the cattr we passed it
         * against what is actually in the catalog after the cnode is created.  If there were
         * any issues, it will bubble out ERECYCLE, which we need to swallow and use as the
         * key to redrive as well.  We need to special case this below because in this case,
         * it needs to occur regardless of the type of lookup we're doing here.
         */
        if ((retval == ERECYCLE) && (newvnode_flags & GNV_CAT_ATTRCHANGED)) {
            if (dcp) {
                hfs_unlock (dcp);
            }
            /* get rid of any name buffers that may have lingered from the cat_lookup call */
            cat_releasedesc (&desc);
            goto retry;
        }

        /* skip to the error-handling code if we can't retry */
        goto exit;
    }

    /*
     * Save the origin info for file and directory hardlinks.  Directory hardlinks
     * need the origin for '..' lookups, and file hardlinks need it to ensure that
     * competing lookups do not cause us to vend different hardlinks than the ones requested.
     */
    if (ISSET(VTOC(tvp)->c_flag, C_HARDLINK))
        hfs_savelinkorigin(VTOC(tvp), VTOC(dvp)->c_fileid);

    *cnode_locked = 1;
    *vpp = tvp;

exit:
    if (dcp) {
        hfs_unlock(dcp);
    }
    cat_releasedesc(&desc);

    return (retval);
}

int
hfs_vnop_lookup(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp)
{
    int error = 0;
    int cnode_locked = 0;
    *vpp = NULL;

    error = hfs_lookup(dvp, vpp, cnp, &cnode_locked);

    if (cnode_locked)
        hfs_unlock(VTOC(*vpp));
    
    return (error);
}
Commit	Line	Data
de8ee011 A	1	//
	2	// lf_hfs_lookup.c
	3	// livefiles_hfs
	4	//
	5	// Created by Yakov Ben Zaken on 25/03/2018.
	6	//
	7
	8	#include "lf_hfs.h"
	9	#include "lf_hfs_lookup.h"
	10	#include "lf_hfs_cnode.h"
	11	#include "lf_hfs_vfsutils.h"
	12	#include "lf_hfs_link.h"
	13
	14	static int
	15	hfs_lookup(struct vnode dvp, struct vnode vpp, struct componentname cnp, int *cnode_locked)
	16	{
	17	struct cnode dcp; / cnode for directory being searched */
	18	struct vnode tvp; / target vnode */
	19	struct hfsmount *hfsmp;
	20	int flags;
	21	int nameiop;
	22	int retval = 0;
	23	struct cat_desc desc;
	24	struct cat_desc cndesc;
	25	struct cat_attr attr;
	26	struct cat_fork fork;
	27	int lockflags;
	28	int newvnode_flags = 0;
	29
	30	retry:
	31	newvnode_flags = 0;
	32	dcp = NULL;
	33	hfsmp = VTOHFS(dvp);
	34	*vpp = NULL;
	35	*cnode_locked = 0;
	36	tvp = NULL;
	37	nameiop = cnp->cn_nameiop;
	38	flags = cnp->cn_flags;
	39	bzero(&desc, sizeof(desc));
	40
	41	if (hfs_lock(VTOC(dvp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT) != 0) {
	42	retval = ENOENT; /* The parent no longer exists ? */
	43	goto exit;
	44	}
	45	dcp = VTOC(dvp);
	46
	47	/*
	48	* Need to understand if we need this check.. as we took exclusive lock..
	49	*/
	50	if (dcp->c_flag & C_DIR_MODIFICATION){
	51	hfs_unlock(dcp);
	52	usleep( 1000 );
	53	goto retry;
	54	}
	55
	56	/*
	57	* We shouldn't need to go to the catalog if there are no children.
	58	* However, in the face of a minor disk corruption where the valence of
	59	* the directory is off, we could infinite loop here if we return ENOENT
	60	* even though there are actually items in the directory. (create will
	61	* see the ENOENT, try to create something, which will return with
	62	* EEXIST over and over again). As a result, always check the catalog.
	63	*/
	64
65	bzero(&cndesc, sizeof(cndesc));
66	cndesc.cd_nameptr = (const u_int8_t *)cnp->cn_nameptr;
67	cndesc.cd_namelen = cnp->cn_namelen;
68	cndesc.cd_parentcnid = dcp->c_fileid;
69	cndesc.cd_hint = dcp->c_childhint;
70
71	lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
72	retval = cat_lookup(hfsmp, &cndesc, 0, &desc, &attr, &fork, NULL);
73	hfs_systemfile_unlock(hfsmp, lockflags);
74
75	if (retval == 0) {
76	dcp->c_childhint = desc.cd_hint;
77	/*
78	* Note: We must drop the parent lock here before calling
79	* hfs_getnewvnode (which takes the child lock).
80	*/
81	hfs_unlock(dcp);
82	dcp = NULL;
83
84	/* Verify that the item just looked up isn't one of the hidden directories. */
85	if (desc.cd_cnid == hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid \|\|
86	desc.cd_cnid == hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid) {
87	retval = ENOENT;
88	goto exit;
89	}
90	goto found;
91	}
92
93	if (retval == HFS_ERESERVEDNAME) {
94	/*
95	* We found the name in the catalog, but it is unavailable
96	* to us. The exact error to return to our caller depends
97	* on the operation, and whether we've already reached the
98	* last path component. In all cases, avoid a negative
99	* cache entry, since someone else may be able to access
100	* the name if their lookup is configured differently.
101	*/
102
103	cnp->cn_flags &= ~MAKEENTRY;
104
105	if (((flags & ISLASTCN) == 0) \|\| ((nameiop == LOOKUP) \|\| (nameiop == DELETE))) {
106	/* A reserved name for a pure lookup is the same as the path not being present */
107	retval = ENOENT;
108	} else {
109	/* A reserved name with intent to create must be rejected as impossible */
110	retval = EEXIST;
111	}
112	}
113	if (retval != ENOENT)
114	goto exit;
115	/*
116	* This is a non-existing entry
117	*
118	* If creating, and at end of pathname and current
119	* directory has not been removed, then can consider
120	* allowing file to be created.
121	*/
122	if ((nameiop == CREATE \|\| nameiop == RENAME) &&
123	(flags & ISLASTCN) &&
124	!(ISSET(dcp->c_flag, C_DELETED \| C_NOEXISTS))) {
125	retval = EJUSTRETURN;
126	goto exit;
127	}
128
129	goto exit;
130
131	found:
132	if (flags & ISLASTCN) {
133	switch(nameiop) {
134	case DELETE:
135	cnp->cn_flags &= ~MAKEENTRY;
136	break;
137
138	case RENAME:
139	cnp->cn_flags &= ~MAKEENTRY;
140	break;
141	default:
142	break;
143	}
144	}
145
146	int type = (attr.ca_mode & S_IFMT);
147
148	if (!(flags & ISLASTCN) && (type != S_IFDIR) && (type != S_IFLNK)) {
149	retval = ENOTDIR;
150	goto exit;
151	}
152	/* Don't cache directory hardlink names. */
153	if (attr.ca_recflags & kHFSHasLinkChainMask) {
154	cnp->cn_flags &= ~MAKEENTRY;
155	}
156	/* Names with composed chars are not cached. */
157	if (cnp->cn_namelen != desc.cd_namelen)
158	cnp->cn_flags &= ~MAKEENTRY;
159
160	retval = hfs_getnewvnode(hfsmp, dvp, cnp, &desc, 0, &attr, &fork, &tvp, &newvnode_flags);
161
162	if (retval) {
163	/*
164	* If this was a create/rename operation lookup, then by this point
165	* we expected to see the item returned from hfs_getnewvnode above.
166	* In the create case, it would probably eventually bubble out an EEXIST
167	* because the item existed when we were trying to create it. In the
168	* rename case, it would let us know that we need to go ahead and
169	* delete it as part of the rename. However, if we hit the condition below
170	* then it means that we found the element during cat_lookup above, but
171	* it is now no longer there. We simply behave as though we never found
172	* the element at all and return EJUSTRETURN.
173	*/
174	if ((retval == ENOENT) &&
175	((cnp->cn_nameiop == CREATE) \|\| (cnp->cn_nameiop == RENAME)) &&
176	(flags & ISLASTCN)) {
177	retval = EJUSTRETURN;
178	}
179
180	/*
181	* If this was a straight lookup operation, we may need to redrive the entire
182	* lookup starting from cat_lookup if the element was deleted as the result of
183	* a rename operation. Since rename is supposed to guarantee atomicity, then
184	* lookups cannot fail because the underlying element is deleted as a result of
185	* the rename call -- either they returned the looked up element prior to rename
186	* or return the newer element. If we are in this region, then all we can do is add
187	* workarounds to guarantee the latter case. The element has already been deleted, so
188	* we just re-try the lookup to ensure the caller gets the most recent element.
189	*/
190	if ((retval == ENOENT) && (cnp->cn_nameiop == LOOKUP) &&
191	(newvnode_flags & (GNV_CHASH_RENAMED \| GNV_CAT_DELETED))) {
192	if (dcp) {
193	hfs_unlock (dcp);
194	}
195	/* get rid of any name buffers that may have lingered from the cat_lookup call */
196	cat_releasedesc (&desc);
197	goto retry;
198	}
199
200	/* Also, re-drive the lookup if the item we looked up was a hardlink, and the number
201	* or name of hardlinks has changed in the interim between the cat_lookup above, and
202	* our call to hfs_getnewvnode. hfs_getnewvnode will validate the cattr we passed it
203	* against what is actually in the catalog after the cnode is created. If there were
204	* any issues, it will bubble out ERECYCLE, which we need to swallow and use as the
205	* key to redrive as well. We need to special case this below because in this case,
206	* it needs to occur regardless of the type of lookup we're doing here.
207	*/
208	if ((retval == ERECYCLE) && (newvnode_flags & GNV_CAT_ATTRCHANGED)) {
209	if (dcp) {
210	hfs_unlock (dcp);
211	}
212	/* get rid of any name buffers that may have lingered from the cat_lookup call */
213	cat_releasedesc (&desc);
214	goto retry;
215	}
216
217	/* skip to the error-handling code if we can't retry */
218	goto exit;
219	}
220
221	/*
222	* Save the origin info for file and directory hardlinks. Directory hardlinks
223	* need the origin for '..' lookups, and file hardlinks need it to ensure that
224	* competing lookups do not cause us to vend different hardlinks than the ones requested.
225	*/
226	if (ISSET(VTOC(tvp)->c_flag, C_HARDLINK))
227	hfs_savelinkorigin(VTOC(tvp), VTOC(dvp)->c_fileid);
228
229	*cnode_locked = 1;
230	*vpp = tvp;
231
232	exit:
233	if (dcp) {
234	hfs_unlock(dcp);
235	}
236	cat_releasedesc(&desc);
237
238	return (retval);
239	}
240
241	int
242	hfs_vnop_lookup(struct vnode dvp, struct vnode vpp, struct componentname cnp)
243	{
244	int error = 0;
245	int cnode_locked = 0;
246	*vpp = NULL;
247
248	error = hfs_lookup(dvp, vpp, cnp, &cnode_locked);
249
250	if (cnode_locked)
251	hfs_unlock(VTOC(*vpp));
252
253	return (error);
254	}