name_cache.h File Reference

#include "nfs41.h"

Include dependency graph for name_cache.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
static __inline struct nfs41_name_cache *	client_name_cache (IN nfs41_client *client)
static __inline struct nfs41_name_cache *	session_name_cache (IN nfs41_session *session)
int	nfs41_attr_cache_lookup (IN struct nfs41_name_cache *cache, IN uint64_t fileid, OUT nfs41_file_info *info_out)
int	nfs41_attr_cache_update (IN struct nfs41_name_cache *cache, IN uint64_t fileid, IN const nfs41_file_info *info)
int	nfs41_name_cache_create (OUT struct nfs41_name_cache **cache_out)
int	nfs41_name_cache_free (IN OUT struct nfs41_name_cache **cache_out)
int	nfs41_name_cache_lookup (IN struct nfs41_name_cache *cache, IN const char *path, IN const char *path_end, OUT OPTIONAL const char **remaining_path_out, OUT OPTIONAL nfs41_fh *parent_out, OUT OPTIONAL nfs41_fh *target_out, OUT OPTIONAL nfs41_file_info *info_out, OUT OPTIONAL bool_t *is_negative)
int	nfs41_name_cache_insert (IN struct nfs41_name_cache *cache, IN const char *path, IN const nfs41_component *name, IN OPTIONAL const nfs41_fh *fh, IN OPTIONAL const nfs41_file_info *info, IN OPTIONAL const change_info4 *cinfo, IN enum open_delegation_type4 delegation)
int	nfs41_name_cache_delegreturn (IN struct nfs41_name_cache *cache, IN uint64_t fileid, IN const char *path, IN const nfs41_component *name)
int	nfs41_name_cache_remove (IN struct nfs41_name_cache *cache, IN const char *path, IN const nfs41_component *name, IN uint64_t fileid, IN const change_info4 *cinfo)
int	nfs41_name_cache_rename (IN struct nfs41_name_cache *cache, IN const char *src_path, IN const nfs41_component *src_name, IN const change_info4 *src_cinfo, IN const char *dst_path, IN const nfs41_component *dst_name, IN const change_info4 *dst_cinfo)
int	nfs41_name_cache_remove_stale (IN struct nfs41_name_cache *cache, IN nfs41_session *session, IN nfs41_abs_path *path)

Function Documentation

client_name_cache()

static __inline struct nfs41_name_cache * client_name_cache ( IN nfs41_client *  client )

static

Definition at line 28 of file name_cache.h.

{
    return client_server(client)->name_cache;
}

Referenced by nfs41_delegation_getattr(), and session_name_cache().

nfs41_attr_cache_lookup()

int nfs41_attr_cache_lookup	(	IN struct nfs41_name_cache *	cache,
		IN uint64_t	fileid,
		OUT nfs41_file_info *	info_out
	)

Definition at line 859 of file name_cache.c.

{
    struct attr_cache_entry *entry;
    int status = NO_ERROR;
 
    dprintf(NCLVL1, "--> nfs41_attr_cache_lookup(%llu)\n", fileid);
 
    AcquireSRWLockShared(&cache->lock);
 
    if (!name_cache_enabled(cache)) {
        status = ERROR_NOT_SUPPORTED;
        goto out_unlock;
    }
 
    entry = attr_cache_search(&cache->attributes, fileid);
    if (entry == NULL || attr_cache_entry_expired(entry)) {
        status = ERROR_FILE_NOT_FOUND;
        goto out_unlock;
    }
 
    copy_attrs(info_out, entry);
 
out_unlock:
    ReleaseSRWLockShared(&cache->lock);
 
    dprintf(NCLVL1, "<-- nfs41_attr_cache_lookup() returning %d\n", status);
    return status;
}

Referenced by nfs41_cached_getattr(), and nfs41_delegation_getattr().

nfs41_attr_cache_update()

int nfs41_attr_cache_update	(	IN struct nfs41_name_cache *	cache,
		IN uint64_t	fileid,
		IN const nfs41_file_info *	info
	)

Definition at line 891 of file name_cache.c.

{
    struct attr_cache_entry *entry;
    int status = NO_ERROR;
 
    dprintf(NCLVL1, "--> nfs41_attr_cache_update(%llu)\n", fileid);
 
    AcquireSRWLockExclusive(&cache->lock);
 
    if (!name_cache_enabled(cache)) {
        status = ERROR_NOT_SUPPORTED;
        goto out_unlock;
    }
 
    entry = attr_cache_search(&cache->attributes, fileid);
    if (entry == NULL) {
        status = ERROR_FILE_NOT_FOUND;
        goto out_unlock;
    }
 
    attr_cache_update(entry, info, OPEN_DELEGATE_NONE);
 
out_unlock:
    ReleaseSRWLockExclusive(&cache->lock);
 
    dprintf(NCLVL1, "<-- nfs41_attr_cache_update() returning %d\n", status);
    return status;
}

Referenced by nfs41_close(), nfs41_commit(), nfs41_create(), nfs41_getattr(), nfs41_link(), nfs41_remove(), nfs41_rename(), nfs41_setattr(), nfs41_write(), open_update_cache(), and pnfs_rpc_layoutcommit().

nfs41_name_cache_create()

int nfs41_name_cache_create

(

OUT struct nfs41_name_cache **

cache_out

)

Definition at line 752 of file name_cache.c.

{
    struct nfs41_name_cache *cache;
    int status = NO_ERROR;
 
    dprintf(NCLVL1, "nfs41_name_cache_create()\n");
 
    /* allocate the cache */
    cache = calloc(1, sizeof(struct nfs41_name_cache));
    if (cache == NULL) {
        status = GetLastError();
        goto out;
    }
 
    list_init(&cache->exp_entries);
    cache->expiration = NAME_CACHE_EXPIRATION;
    cache->max_entries = NAME_CACHE_MAX_ENTRIES;
    cache->max_delegations = NAME_CACHE_MAX_ENTRIES / 2;
    InitializeSRWLock(&cache->lock);
 
    /* allocate a pool of entries */
    cache->pool = calloc(cache->max_entries, NAME_ENTRY_SIZE);
    if (cache->pool == NULL) {
        status = GetLastError();
        goto out_err_cache;
    }
 
    /* initialize the attribute cache */
    status = attr_cache_init(&cache->attributes, cache->max_entries);
    if (status)
        goto out_err_pool;
 
    *cache_out = cache;
out:
    return status;
 
out_err_pool:
    free(cache->pool);
out_err_cache:
    free(cache);
    goto out;
}

Referenced by server_create().

nfs41_name_cache_delegreturn()

int nfs41_name_cache_delegreturn	(	IN struct nfs41_name_cache *	cache,
		IN uint64_t	fileid,
		IN const char *	path,
		IN const nfs41_component *	name
	)

Definition at line 1012 of file name_cache.c.

{
    struct name_cache_entry *parent, *target;
    struct attr_cache_entry *attributes;
    int status;
 
    dprintf(NCLVL1, "--> nfs41_name_cache_delegreturn(%llu, '%s')\n",
        fileid, path);
 
    AcquireSRWLockExclusive(&cache->lock);
 
    if (!name_cache_enabled(cache)) {
        status = ERROR_NOT_SUPPORTED;
        goto out_unlock;
    }
 
    status = name_cache_lookup(cache, 0, path,
        name->name + name->len, NULL, &parent, &target, NULL);
    if (status == NO_ERROR) {
        /* put the name cache entry back on the exp_entries list */
        list_add_head(&cache->exp_entries, &target->exp_entry);
        name_cache_entry_updated(cache, target);
 
        attributes = target->attributes;
    } else {
        /* should still have an attr cache entry */
        attributes = attr_cache_search(&cache->attributes, fileid);
    }
 
    if (attributes == NULL) {
        status = ERROR_FILE_NOT_FOUND;
        goto out_unlock;
    }
 
    /* release the reference from name_cache_entry_update() */
    if (attributes->delegated) {
        attributes->delegated = FALSE;
        attr_cache_entry_deref(&cache->attributes, attributes);
        assert(cache->delegations > 0);
        cache->delegations--;
    }
    status = NO_ERROR;
 
out_unlock:
    ReleaseSRWLockExclusive(&cache->lock);
 
    dprintf(NCLVL1, "<-- nfs41_name_cache_delegreturn() returning %d\n", status);
    return status;
}

Referenced by nfs41_delegreturn().

nfs41_name_cache_free()

int nfs41_name_cache_free

(

IN OUT struct nfs41_name_cache **

cache_out

)

nfs41_name_cache_insert()

int nfs41_name_cache_insert	(	IN struct nfs41_name_cache *	cache,
		IN const char *	path,
		IN const nfs41_component *	name,
		IN OPTIONAL const nfs41_fh *	fh,
		IN OPTIONAL const nfs41_file_info *	info,
		IN OPTIONAL const change_info4 *	cinfo,
		IN enum open_delegation_type4	delegation
	)

Definition at line 923 of file name_cache.c.

{
    struct name_cache_entry *parent, *target;
    int status;
 
    dprintf(NCLVL1, "--> nfs41_name_cache_insert('%.*s')\n",
        name->name + name->len - path, path);
 
    AcquireSRWLockExclusive(&cache->lock);
 
    if (!name_cache_enabled(cache)) {
        status = ERROR_NOT_SUPPORTED;
        goto out_unlock;
    }
 
    /* limit the number of delegations to prevent attr cache starvation */
    if (is_delegation(delegation) &&
        cache->delegations >= cache->max_delegations) {
        status = ERROR_TOO_MANY_OPEN_FILES;
        goto out_unlock;
    }
 
    /* an empty path or component implies the root entry */
    if (path == NULL || name == NULL || name->len == 0) {
        /* create the root entry if it doesn't exist */
        if (cache->root == NULL) {
            const nfs41_component name = { "ROOT", 4 };
            status = name_cache_entry_create(cache, &name, &cache->root);
            if (status)
                goto out_err_deleg;
        }
        target = cache->root;
    } else {
        /* find/create an entry under its parent */
        status = name_cache_lookup(cache, 0, path,
            name->name, NULL, NULL, &parent, NULL);
        if (status)
            goto out_err_deleg;
 
        if (cinfo && name_cache_entry_changed(cache, parent, cinfo)) {
            name_cache_entry_invalidate(cache, parent);
            goto out_err_deleg;
        }
 
        status = name_cache_find_or_create(cache, parent, name, &target);
        if (status)
            goto out_err_deleg;
    }
 
    /* pass in the new fh/attributes */
    status = name_cache_entry_update(cache, target, fh, info, delegation);
    if (status)
        goto out_err_update;
 
out_unlock:
    ReleaseSRWLockExclusive(&cache->lock);
 
    dprintf(NCLVL1, "<-- nfs41_name_cache_insert() returning %d\n",
        status);
    return status;
 
out_err_update:
    /* a failure in name_cache_entry_update() leaves a negative entry
     * where there shouldn't be one; remove it from the cache */
    name_cache_entry_invalidate(cache, target);
 
out_err_deleg:
    if (is_delegation(delegation)) {
        /* we still need a reference to the attributes for the delegation */
        struct attr_cache_entry *attributes;
        status = attr_cache_find_or_create(&cache->attributes,
            info->fileid, &attributes);
        if (status == NO_ERROR) {
            attr_cache_update(attributes, info, delegation);
            cache->delegations++;
        }
        else
            status = ERROR_TOO_MANY_OPEN_FILES;
    }
    goto out_unlock;
}

Referenced by nfs41_create(), nfs41_link(), open_update_cache(), and server_lookup().

nfs41_name_cache_lookup()

int nfs41_name_cache_lookup	(	IN struct nfs41_name_cache *	cache,
		IN const char *	path,
		IN const char *	path_end,
		OUT OPTIONAL const char **	remaining_path_out,
		OUT OPTIONAL nfs41_fh *	parent_out,
		OUT OPTIONAL nfs41_fh *	target_out,
		OUT OPTIONAL nfs41_file_info *	info_out,
		OUT OPTIONAL bool_t *	is_negative
	)

Definition at line 824 of file name_cache.c.

{
    struct name_cache_entry *parent, *target;
    const char *path_pos = path;
    int status;
 
    AcquireSRWLockShared(&cache->lock);
 
    if (!name_cache_enabled(cache)) {
        status = ERROR_NOT_SUPPORTED;
        goto out_unlock;
    }
 
    status = name_cache_lookup(cache, 1, path, path_end,
        &path_pos, &parent, &target, is_negative);
 
    if (parent_out) copy_fh(parent_out, parent);
    if (target_out) copy_fh(target_out, target);
    if (info_out && target && target->attributes)
        copy_attrs(info_out, target->attributes);
 
out_unlock:
    ReleaseSRWLockShared(&cache->lock);
    if (remaining_path_out) *remaining_path_out = path_pos;
    return status;
}

Referenced by nfs41_lookup().

nfs41_name_cache_remove()

int nfs41_name_cache_remove	(	IN struct nfs41_name_cache *	cache,
		IN const char *	path,
		IN const nfs41_component *	name,
		IN uint64_t	fileid,
		IN const change_info4 *	cinfo
	)

Definition at line 1066 of file name_cache.c.

{
    struct name_cache_entry *parent, *target;
    struct attr_cache_entry *attributes = NULL;
    int status;
 
    dprintf(NCLVL1, "--> nfs41_name_cache_remove('%s')\n", path);
 
    AcquireSRWLockExclusive(&cache->lock);
 
    if (!name_cache_enabled(cache)) {
        status = ERROR_NOT_SUPPORTED;
        goto out_unlock;
    }
 
    status = name_cache_lookup(cache, 0, path,
        name->name + name->len, NULL, &parent, &target, NULL);
    if (status == ERROR_PATH_NOT_FOUND)
        goto out_attributes;
 
    if (cinfo && name_cache_entry_changed(cache, parent, cinfo)) {
        name_cache_entry_invalidate(cache, parent);
        goto out_attributes;
    }
 
    if (status == ERROR_FILE_NOT_FOUND)
        goto out_attributes;
 
    if (target->attributes)
        target->attributes->numlinks--;
 
    /* make this a negative entry and unlink children */
    name_cache_entry_update(cache, target, NULL, NULL, OPEN_DELEGATE_NONE);
    name_cache_unlink_children_recursive(cache, target);
 
out_unlock:
    ReleaseSRWLockExclusive(&cache->lock);
 
    dprintf(NCLVL1, "<-- nfs41_name_cache_remove() returning %d\n", status);
    return status;
 
out_attributes:
    /* in the presence of other links, we need to update numlinks
     * regardless of a failure to find the target entry */
    dprintf(NCLVL1, "nfs41_name_cache_remove: need to find attributes for %s\n", path);
    attributes = attr_cache_search(&cache->attributes, fileid);
    if (attributes)
        attributes->numlinks--;
    goto out_unlock;
}

Referenced by nfs41_remove().

nfs41_name_cache_remove_stale()

int nfs41_name_cache_remove_stale	(	IN struct nfs41_name_cache *	cache,
		IN nfs41_session *	session,
		IN nfs41_abs_path *	path
	)

Definition at line 1359 of file name_cache.c.

{
    nfs41_path_fh files[MAX_PUTFH_PER_COMPOUND];
    const char *path_pos = path->path;
    const char* const path_end = path->path + path->len;
    const uint32_t max_components = max_putfh_components(session);
    uint32_t count, index;
    int status = NO_ERROR;
 
    AcquireSRWLockShared(&cache->lock);
 
    /* if there's no cache, don't check any components */
    if (!name_cache_enabled(cache))
        path_pos = path_end;
 
    ReleaseSRWLockShared(&cache->lock);
 
    /* hold a lock on the path to protect against rename */
    AcquireSRWLockShared(&path->lock);
 
    while (get_path_fhs(cache, path, &path_pos, max_components, files, &count)) {
        status = rpc_array_putfh(session, files, count, &index);
 
        if (status == NFS4ERR_STALE || status == NFS4ERR_FHEXPIRED) {
            status = delete_stale_component(cache,
                session, path, &files[index].name);
            break;
        }
        if (status) {
            status = nfs_to_windows_error(status, ERROR_FILE_NOT_FOUND);
            break;
        }
    }
 
    ReleaseSRWLockShared(&path->lock);
 
    return status;
}

Referenced by compound_encode_send_decode().

nfs41_name_cache_rename()

int nfs41_name_cache_rename	(	IN struct nfs41_name_cache *	cache,
		IN const char *	src_path,
		IN const nfs41_component *	src_name,
		IN const change_info4 *	src_cinfo,
		IN const char *	dst_path,
		IN const nfs41_component *	dst_name,
		IN const change_info4 *	dst_cinfo
	)

Definition at line 1122 of file name_cache.c.

{
    struct name_cache_entry *src_parent, *src;
    struct name_cache_entry *dst_parent;
    int status = NO_ERROR;
 
    dprintf(NCLVL1, "--> nfs41_name_cache_rename('%s' to '%s')\n",
        src_path, dst_path);
 
    AcquireSRWLockExclusive(&cache->lock);
 
    if (!name_cache_enabled(cache)) {
        status = ERROR_NOT_SUPPORTED;
        goto out_unlock;
    }
 
    /* look up dst_parent */
    status = name_cache_lookup(cache, 0, dst_path,
        dst_name->name, NULL, NULL, &dst_parent, NULL);
    /* we can't create the dst entry without a parent */
    if (status || dst_parent->attributes == NULL) {
        /* if src exists, make it negative */
        dprintf(NCLVL1, "nfs41_name_cache_rename: adding negative cache "
            "entry for %.*s\n", src_name->len, src_name->name);
        status = name_cache_lookup(cache, 0, src_path,
            src_name->name + src_name->len, NULL, NULL, &src, NULL);
        if (status == NO_ERROR) {
            name_cache_entry_update(cache, src, NULL, NULL, OPEN_DELEGATE_NONE);
            name_cache_unlink_children_recursive(cache, src);
        }
        status = ERROR_PATH_NOT_FOUND;
        goto out_unlock;
    }
 
    /* look up src_parent and src */
    status = name_cache_lookup(cache, 0, src_path,
        src_name->name + src_name->len, NULL, &src_parent, &src, NULL);
    /* we can't create the dst entry without valid attributes */
    if (status || src->attributes == NULL) {
        /* remove dst if it exists */
        struct name_cache_entry *dst;
        dprintf(NCLVL1, "nfs41_name_cache_rename: removing negative cache "
            "entry for %.*s\n", dst_name->len, dst_name->name);
        dst = name_cache_search(cache, dst_parent, dst_name);
        if (dst) name_cache_unlink(cache, dst);
        goto out_unlock;
    }
 
    if (name_cache_entry_changed(cache, dst_parent, dst_cinfo)) {
        name_cache_entry_invalidate(cache, dst_parent);
        /* if dst_parent and src_parent are both gone,
         * we no longer have an entry to rename */
        if (dst_parent == src_parent)
            goto out_unlock;
    } else {
        struct name_cache_entry *existing;
        existing = name_cache_search(cache, dst_parent, dst_name);
        if (existing) {
            if (existing == src)
                goto out_unlock;
            /* remove the existing entry, but don't unlink it yet;
             * we may reuse it for a negative entry */
            name_cache_remove(existing, dst_parent);
        }
 
        /* move the src entry under dst_parent */
        name_cache_remove(src, src_parent);
        name_cache_entry_rename(src, dst_name);
        name_cache_insert(src, dst_parent);
 
        if (existing) {
            /* recycle 'existing' as the negative entry 'src' */
            name_cache_entry_rename(existing, src_name);
            name_cache_insert(existing, src_parent);
        }
        src = existing;
    }
 
    if (name_cache_entry_changed(cache, src_parent, src_cinfo)) {
        name_cache_entry_invalidate(cache, src_parent);
        goto out_unlock;
    }
 
    /* leave a negative entry where the file used to be */
    if (src == NULL) {
        /* src was moved, create a new entry in its place */
        status = name_cache_find_or_create(cache, src_parent, src_name, &src);
        if (status)
            goto out_unlock;
    }
    name_cache_entry_update(cache, src, NULL, NULL, OPEN_DELEGATE_NONE);
    name_cache_unlink_children_recursive(cache, src);
 
out_unlock:
    ReleaseSRWLockExclusive(&cache->lock);
 
    dprintf(NCLVL1, "<-- nfs41_name_cache_rename() returning %d\n", status);
    return status;
}

Referenced by nfs41_rename().

session_name_cache()

static __inline struct nfs41_name_cache * session_name_cache ( IN nfs41_session *  session )

static

Definition at line 34 of file name_cache.h.

{
    return client_name_cache(session->client);
}

Referenced by compound_encode_send_decode(), nfs41_cached_getattr(), nfs41_close(), nfs41_commit(), nfs41_create(), nfs41_delegreturn(), nfs41_getattr(), nfs41_link(), nfs41_lookup(), nfs41_remove(), nfs41_rename(), nfs41_setattr(), nfs41_write(), open_update_cache(), pnfs_rpc_layoutcommit(), and server_lookup().