#include <windows.h>
#include <strsafe.h>
#include <time.h>
#include <assert.h>
#include "nfs41_ops.h"
#include "nfs41_compound.h"
#include "name_cache.h"
#include "util.h"
#include "tree.h"
#include "daemon_debug.h"

Include dependency graph for name_cache.c:

Classes
struct	attr_cache_entry

struct	attr_cache

struct	name_cache_entry

struct	nfs41_name_cache

Macros
#define	NAME_CACHE_EXPIRATION 20 /* TODO: get from configuration */

#define	NAME_CACHE_MAX_SIZE 262144

#define	ATTR_ENTRY_SIZE sizeof(struct attr_cache_entry)

#define	attr_entry(pos) list_container(pos, struct attr_cache_entry, free_entry)

#define	NAME_ENTRY_SIZE sizeof(struct name_cache_entry)

#define	name_entry(pos) list_container(pos, struct name_cache_entry, exp_entry)

#define	SIZE_PER_ENTRY (ATTR_ENTRY_SIZE + NAME_ENTRY_SIZE)

#define	NAME_CACHE_MAX_ENTRIES (NAME_CACHE_MAX_SIZE / SIZE_PER_ENTRY)

#define	MAX_PUTFH_PER_COMPOUND 16

Enumerations
enum	{ NCLVL1 = 2 , NCLVL2 }

Functions
static __inline bool_t	is_delegation (IN enum open_delegation_type4 type)

	RB_HEAD (attr_tree, attr_cache_entry)

int	attr_cmp (struct attr_cache_entry lhs, struct attr_cache_entry rhs)

static int	attr_cache_entry_create (IN struct attr_cache cache, IN uint64_t fileid, OUT struct attr_cache_entry *entry_out)

static __inline void	attr_cache_entry_free (IN struct attr_cache cache, IN struct attr_cache_entry entry)

static __inline void	attr_cache_entry_ref (IN struct attr_cache cache, IN struct attr_cache_entry entry)

static __inline void	attr_cache_entry_deref (IN struct attr_cache cache, IN struct attr_cache_entry entry)

static __inline int	attr_cache_entry_expired (IN const struct attr_cache_entry *entry)

static int	attr_cache_init (IN struct attr_cache *cache, IN uint32_t max_entries)

static void	attr_cache_free (IN struct attr_cache *cache)

static struct attr_cache_entry *	attr_cache_search (IN struct attr_cache *cache, IN uint64_t fileid)

static int	attr_cache_insert (IN struct attr_cache cache, IN struct attr_cache_entry entry)

static int	attr_cache_find_or_create (IN struct attr_cache cache, IN uint64_t fileid, OUT struct attr_cache_entry *entry_out)

static void	attr_cache_update (IN struct attr_cache_entry entry, IN const nfs41_file_info info, IN enum open_delegation_type4 delegation)

static void	copy_attrs (OUT nfs41_file_info dst, IN const struct attr_cache_entry src)

	RB_HEAD (name_tree, name_cache_entry)

int	name_cmp (struct name_cache_entry lhs, struct name_cache_entry rhs)

static __inline bool_t	name_cache_enabled (IN struct nfs41_name_cache *cache)

static __inline void	name_cache_entry_rename (OUT struct name_cache_entry entry, IN const nfs41_component component)

static __inline void	name_cache_remove (IN struct name_cache_entry entry, IN struct name_cache_entry parent)

static void	name_cache_unlink_children_recursive (IN struct nfs41_name_cache cache, IN struct name_cache_entry parent)

static __inline void	name_cache_unlink (IN struct nfs41_name_cache cache, IN struct name_cache_entry entry)

static int	name_cache_entry_create (IN struct nfs41_name_cache cache, IN const nfs41_component component, OUT struct name_cache_entry **entry_out)

static void	name_cache_entry_accessed (IN struct nfs41_name_cache cache, IN struct name_cache_entry entry)

static void	name_cache_entry_updated (IN struct nfs41_name_cache cache, IN struct name_cache_entry entry)

static int	name_cache_entry_update (IN struct nfs41_name_cache cache, IN struct name_cache_entry entry, IN OPTIONAL const nfs41_fh fh, IN OPTIONAL const nfs41_file_info info, IN enum open_delegation_type4 delegation)

static int	name_cache_entry_changed (IN struct nfs41_name_cache cache, IN struct name_cache_entry entry, IN const change_info4 *cinfo)

static void	name_cache_entry_invalidate (IN struct nfs41_name_cache cache, IN struct name_cache_entry entry)

static struct name_cache_entry *	name_cache_search (IN struct nfs41_name_cache cache, IN struct name_cache_entry parent, IN const nfs41_component *component)

static int	entry_invis (IN struct name_cache_entry entry, OUT OPTIONAL bool_t is_negative)

static int	name_cache_lookup (IN struct nfs41_name_cache cache, IN bool_t skip_invis, IN const char path, IN const char path_end, OUT OPTIONAL const char remaining_path_out, OUT OPTIONAL struct name_cache_entry parent_out, OUT OPTIONAL struct name_cache_entry target_out, OUT OPTIONAL bool_t is_negative)

static int	name_cache_insert (IN struct name_cache_entry entry, IN struct name_cache_entry parent)

static int	name_cache_find_or_create (IN struct nfs41_name_cache cache, IN struct name_cache_entry parent, IN const nfs41_component component, OUT struct name_cache_entry *target_out)

int	nfs41_name_cache_create (OUT struct nfs41_name_cache **cache_out)

int	nfs41_name_cache_free (IN struct nfs41_name_cache **cache_out)

static __inline void	copy_fh (OUT nfs41_fh dst, IN OPTIONAL const struct name_cache_entry src)

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_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_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)

static bool_t	get_path_fhs (IN struct nfs41_name_cache cache, IN nfs41_abs_path path, IN OUT const char *path_pos, IN uint32_t max_components, OUT nfs41_path_fh files, OUT uint32_t *count)

static int	rpc_array_putfh (IN nfs41_session session, IN nfs41_path_fh files, IN uint32_t count, OUT uint32_t *valid_out)

static int	delete_stale_component (IN struct nfs41_name_cache cache, IN nfs41_session session, IN const nfs41_abs_path path, IN const nfs41_component component)

static __inline uint32_t	max_putfh_components (IN const nfs41_session *session)

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

Macro Definition Documentation

◆ attr_entry

#define attr_entry ( pos ) list_container(pos, struct attr_cache_entry, free_entry)

Definition at line 121 of file name_cache.c.

◆ ATTR_ENTRY_SIZE

#define ATTR_ENTRY_SIZE sizeof(struct attr_cache_entry)

Definition at line 103 of file name_cache.c.

◆ MAX_PUTFH_PER_COMPOUND

#define MAX_PUTFH_PER_COMPOUND 16

Definition at line 1231 of file name_cache.c.

◆ NAME_CACHE_EXPIRATION

#define NAME_CACHE_EXPIRATION 20 /* TODO: get from configuration */

Definition at line 42 of file name_cache.c.

◆ NAME_CACHE_MAX_ENTRIES

#define NAME_CACHE_MAX_ENTRIES (NAME_CACHE_MAX_SIZE / SIZE_PER_ENTRY)

Definition at line 750 of file name_cache.c.

◆ NAME_CACHE_MAX_SIZE

#define NAME_CACHE_MAX_SIZE 262144

Definition at line 45 of file name_cache.c.

◆ name_entry

#define name_entry ( pos ) list_container(pos, struct name_cache_entry, exp_entry)

Definition at line 399 of file name_cache.c.

◆ NAME_ENTRY_SIZE

#define NAME_ENTRY_SIZE sizeof(struct name_cache_entry)

Definition at line 373 of file name_cache.c.

◆ SIZE_PER_ENTRY

#define SIZE_PER_ENTRY (ATTR_ENTRY_SIZE + NAME_ENTRY_SIZE)

Definition at line 749 of file name_cache.c.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
NCLVL1
NCLVL2

Definition at line 36 of file name_cache.c.

     {
    NCLVL1 = 2,
    NCLVL2
};

Function Documentation

◆ attr_cache_entry_create()

static int attr_cache_entry_create	(	IN struct attr_cache *	cache,
		IN uint64_t	fileid,
		OUT struct attr_cache_entry **	entry_out
	)

static

Definition at line 123 of file name_cache.c.

{
    struct attr_cache_entry *entry;
    int status = NO_ERROR;
 
    /* get the next entry from free_entries and remove it */
    if (list_empty(&cache->free_entries)) {
        status = ERROR_OUTOFMEMORY;
        goto out;
    }
    entry = attr_entry(cache->free_entries.next);
    list_remove(&entry->free_entry);
 
    entry->fileid = fileid;
    entry->invalidated = FALSE;
    entry->delegated = FALSE;
    *entry_out = entry;
out:
    return status;
}

Referenced by attr_cache_find_or_create().

◆ attr_cache_entry_deref()

static __inline void attr_cache_entry_deref	(	IN struct attr_cache *	cache,
		IN struct attr_cache_entry *	entry
	)

static

Definition at line 166 of file name_cache.c.

{
    const uint32_t previous = entry->ref_count--;
    dprintf(NCLVL2, "attr_cache_entry_deref(%llu) %u -> %u\n",
        entry->fileid, previous, entry->ref_count);
 
    if (entry->ref_count == 0)
        attr_cache_entry_free(cache, entry);
}

Referenced by name_cache_entry_update(), name_cache_unlink(), and nfs41_name_cache_delegreturn().

◆ attr_cache_entry_expired()

static __inline int attr_cache_entry_expired ( IN const struct attr_cache_entry * entry )

static

Definition at line 178 of file name_cache.c.

{
    return entry->invalidated ||
        (!entry->delegated && time(NULL) > entry->expiration);
}

Referenced by entry_invis(), and nfs41_attr_cache_lookup().

◆ attr_cache_entry_free()

static __inline void attr_cache_entry_free	(	IN struct attr_cache *	cache,
		IN struct attr_cache_entry *	entry
	)

static

Definition at line 147 of file name_cache.c.

{
    dprintf(NCLVL1, "attr_cache_entry_free(%llu)\n", entry->fileid);
    RB_REMOVE(attr_tree, &cache->head, entry);
    /* add it back to free_entries */
    list_add_tail(&cache->free_entries, &entry->free_entry);
}

Referenced by attr_cache_entry_deref(), and attr_cache_find_or_create().

◆ attr_cache_entry_ref()

static __inline void attr_cache_entry_ref	(	IN struct attr_cache *	cache,
		IN struct attr_cache_entry *	entry
	)

static

Definition at line 157 of file name_cache.c.

{
    const uint32_t previous = entry->ref_count++;
    dprintf(NCLVL2, "attr_cache_entry_ref(%llu) %u -> %u\n",
        entry->fileid, previous, entry->ref_count);
}

Referenced by attr_cache_find_or_create(), and name_cache_entry_update().

◆ attr_cache_find_or_create()

static int attr_cache_find_or_create	(	IN struct attr_cache *	cache,
		IN uint64_t	fileid,
		OUT struct attr_cache_entry **	entry_out
	)

static

Definition at line 244 of file name_cache.c.

{
    struct attr_cache_entry *entry;
    int status = NO_ERROR;
 
    dprintf(NCLVL1, "--> attr_cache_find_or_create(%llu)\n", fileid);
 
    /* look for an existing entry */
    entry = attr_cache_search(cache, fileid);
    if (entry == NULL) {
        /* create and insert */
        status = attr_cache_entry_create(cache, fileid, &entry);
        if (status)
            goto out;
 
        status = attr_cache_insert(cache, entry);
        if (status)
            goto out_err_free;
    }
 
    /* take a reference on success */
    attr_cache_entry_ref(cache, entry);
 
out:
    *entry_out = entry;
    dprintf(NCLVL1, "<-- attr_cache_find_or_create() returning %d\n",
        status);
    return status;
 
out_err_free:
    attr_cache_entry_free(cache, entry);
    entry = NULL;
    goto out;
}

Referenced by name_cache_entry_update(), and nfs41_name_cache_insert().

◆ attr_cache_free()

static void attr_cache_free ( IN struct attr_cache * cache )

static

Definition at line 210 of file name_cache.c.

{
    /* free the pool */
    free(cache->pool);
    cache->pool = NULL;
    list_init(&cache->free_entries);
}

Referenced by nfs41_name_cache_free().

◆ attr_cache_init()

static int attr_cache_init	(	IN struct attr_cache *	cache,
		IN uint32_t	max_entries
	)

static

Definition at line 186 of file name_cache.c.

{
    uint32_t i;
    int status = NO_ERROR;
 
    /* allocate a pool of entries */
    cache->pool = calloc(max_entries, ATTR_ENTRY_SIZE);
    if (cache->pool == NULL) {
        status = GetLastError();
        goto out;
    }
 
    /* initialize the list of free entries */
    list_init(&cache->free_entries);
    for (i = 0; i < max_entries; i++) {
        list_init(&cache->pool[i].free_entry);
        list_add_tail(&cache->free_entries, &cache->pool[i].free_entry);
    }
out:
    return status;
}

Referenced by nfs41_name_cache_create().

◆ attr_cache_insert()

static int attr_cache_insert	(	IN struct attr_cache *	cache,
		IN struct attr_cache_entry *	entry
	)

static

Definition at line 229 of file name_cache.c.

{
    int status = NO_ERROR;
 
    dprintf(NCLVL2, "--> attr_cache_insert(%llu)\n", entry->fileid);
 
    if (RB_INSERT(attr_tree, &cache->head, entry))
        status = ERROR_FILE_EXISTS;
 
    dprintf(NCLVL2, "<-- attr_cache_insert() returning %d\n", status);
    return status;
}

Referenced by attr_cache_find_or_create().

◆ attr_cache_search()

static struct attr_cache_entry * attr_cache_search	(	IN struct attr_cache *	cache,
		IN uint64_t	fileid
	)

static

Definition at line 219 of file name_cache.c.

{
    /* find an entry that matches fileid */
    struct attr_cache_entry tmp;
    tmp.fileid = fileid;
    return RB_FIND(attr_tree, &cache->head, &tmp);
}

Referenced by attr_cache_find_or_create(), nfs41_attr_cache_lookup(), nfs41_attr_cache_update(), nfs41_name_cache_delegreturn(), and nfs41_name_cache_remove().

◆ attr_cache_update()

static void attr_cache_update	(	IN struct attr_cache_entry *	entry,
		IN const nfs41_file_info *	info,
		IN enum open_delegation_type4	delegation
	)

static

Definition at line 282 of file name_cache.c.

{
    /* update the attributes present in mask */
    if (info->attrmask.count >= 1) {
        if (info->attrmask.arr[0] & FATTR4_WORD0_TYPE)
            entry->type = (unsigned char)(info->type & NFS_FTYPE_MASK);
        if (info->attrmask.arr[0] & FATTR4_WORD0_CHANGE) {
            entry->change = info->change;
            /* revalidate whenever we get a change attribute */
            entry->invalidated = 0;
            entry->expiration = time(NULL) + NAME_CACHE_EXPIRATION;
        }
        if (info->attrmask.arr[0] & FATTR4_WORD0_SIZE)
            entry->size = info->size;
        if (info->attrmask.arr[0] & FATTR4_WORD0_HIDDEN)
            entry->hidden = info->hidden;
        if (info->attrmask.arr[0] & FATTR4_WORD0_ARCHIVE)
            entry->archive = info->archive;
    }
    if (info->attrmask.count >= 2) {
        if (info->attrmask.arr[1] & FATTR4_WORD1_MODE)
            entry->mode = info->mode;
        if (info->attrmask.arr[1] & FATTR4_WORD1_NUMLINKS)
            entry->numlinks = info->numlinks;
        if (info->attrmask.arr[1] & FATTR4_WORD1_TIME_ACCESS) {
            entry->time_access_s = info->time_access.seconds;
            entry->time_access_ns = info->time_access.nseconds;
        }
        if (info->attrmask.arr[1] & FATTR4_WORD1_TIME_CREATE) {
            entry->time_create_s = info->time_create.seconds;
            entry->time_create_ns = info->time_create.nseconds;
        }
        if (info->attrmask.arr[1] & FATTR4_WORD1_TIME_MODIFY) {
            entry->time_modify_s = info->time_modify.seconds;
            entry->time_modify_ns = info->time_modify.nseconds;
        }
        if (info->attrmask.arr[1] & FATTR4_WORD1_SYSTEM)
            entry->system = info->system;
    }
 
    if (is_delegation(delegation))
        entry->delegated = TRUE;
}

Referenced by name_cache_entry_update(), nfs41_attr_cache_update(), and nfs41_name_cache_insert().

◆ attr_cmp()

int attr_cmp	(	struct attr_cache_entry *	lhs,
		struct attr_cache_entry *	rhs
	)

Definition at line 113 of file name_cache.c.

{
    return lhs->fileid < rhs->fileid ? -1 : lhs->fileid > rhs->fileid;
}

Referenced by VfdMakeFileDesc().

◆ copy_attrs()

static void copy_attrs	(	OUT nfs41_file_info *	dst,
		IN const struct attr_cache_entry *	src
	)

static

Definition at line 329 of file name_cache.c.

{
    dst->change = src->change;
    dst->size = src->size;
    dst->time_access.seconds = src->time_access_s;
    dst->time_access.nseconds = src->time_access_ns;
    dst->time_create.seconds = src->time_create_s;
    dst->time_create.nseconds = src->time_create_ns;
    dst->time_modify.seconds = src->time_modify_s;
    dst->time_modify.nseconds = src->time_modify_ns;
    dst->type = src->type;
    dst->numlinks = src->numlinks;
    dst->mode = src->mode;
    dst->fileid = src->fileid;
    dst->hidden = src->hidden;
    dst->system = src->system;
    dst->archive = src->archive;
 
    dst->attrmask.count = 2;
    dst->attrmask.arr[0] = FATTR4_WORD0_TYPE | FATTR4_WORD0_CHANGE
        | FATTR4_WORD0_SIZE | FATTR4_WORD0_FILEID 
        | FATTR4_WORD0_HIDDEN | FATTR4_WORD0_ARCHIVE;
    dst->attrmask.arr[1] = FATTR4_WORD1_MODE
        | FATTR4_WORD1_NUMLINKS | FATTR4_WORD1_TIME_ACCESS
        | FATTR4_WORD1_TIME_CREATE | FATTR4_WORD1_TIME_MODIFY 
        | FATTR4_WORD1_SYSTEM;
}

Referenced by nfs41_attr_cache_lookup(), and nfs41_name_cache_lookup().

◆ copy_fh()

static __inline void copy_fh	(	OUT nfs41_fh *	dst,
		IN OPTIONAL const struct name_cache_entry *	src
	)

static

Definition at line 814 of file name_cache.c.

{
    if (src)
        fh_copy(dst, &src->fh);
    else
        dst->len = 0;
}

Referenced by nfs41_name_cache_lookup().

◆ delete_stale_component()

static int delete_stale_component	(	IN struct nfs41_name_cache *	cache,
		IN nfs41_session *	session,
		IN const nfs41_abs_path *	path,
		IN const nfs41_component *	component
	)

static

Definition at line 1327 of file name_cache.c.

{
    struct name_cache_entry *target;
    int status;
 
    dprintf(NCLVL1, "--> delete_stale_component('%s')\n",
        component->name);
 
    AcquireSRWLockExclusive(&cache->lock);
 
    status = name_cache_lookup(cache, 0, path->path,
        component->name + component->len, NULL, NULL, &target, NULL);
    if (status == NO_ERROR)
        name_cache_unlink(cache, target);
 
    ReleaseSRWLockExclusive(&cache->lock);
 
    dprintf(NCLVL1, "<-- delete_stale_component() returning %d\n", status);
    return status;
}

Referenced by nfs41_name_cache_remove_stale().

◆ entry_invis()

static int entry_invis	(	IN struct name_cache_entry *	entry,
		OUT OPTIONAL bool_t *	is_negative
	)

static

Definition at line 624 of file name_cache.c.

{
    /* name entry timer expired? */
    if (!list_empty(&entry->exp_entry) && time(NULL) > entry->expiration) {
        dprintf(NCLVL2, "name_entry_expired('%s')\n", entry->component);
        return 1;
    }
    /* negative lookup entry? */
    if (entry->attributes == NULL) {
        if (is_negative) *is_negative = 1;
        dprintf(NCLVL2, "name_entry_negative('%s')\n", entry->component);
        return 1;
    }
    /* attribute entry expired? */
    if (attr_cache_entry_expired(entry->attributes)) {
        dprintf(NCLVL2, "attr_entry_expired(%llu)\n",
            entry->attributes->fileid);
        return 1;
    }
    return 0;
}

Referenced by get_path_fhs(), and name_cache_lookup().

◆ get_path_fhs()

static bool_t get_path_fhs	(	IN struct nfs41_name_cache *	cache,
		IN nfs41_abs_path *	path,
		IN OUT const char **	path_pos,
		IN uint32_t	max_components,
		OUT nfs41_path_fh *	files,
		OUT uint32_t *	count
	)

static

Definition at line 1233 of file name_cache.c.

{
    struct name_cache_entry *target;
    const char *path_end = path->path + path->len;
    nfs41_component *name;
    uint32_t i;
    int status;
 
    *count = 0;
 
    AcquireSRWLockShared(&cache->lock);
 
    /* look up the parent of the first component */
    status = name_cache_lookup(cache, 1, path->path,
        *path_pos, NULL, NULL, &target, NULL);
    if (status)
        goto out_unlock;
 
    for (i = 0; i < max_components; i++) {
        files[i].path = path;
        name = &files[i].name;
 
        if (!next_component(*path_pos, path_end, name))
            break;
        *path_pos = name->name + name->len;
 
        target = name_cache_search(cache, target, name);
        if (target == NULL || entry_invis(target, NULL)) {
            if (is_last_component(name->name, path_end))
                status = ERROR_FILE_NOT_FOUND;
            else
                status = ERROR_PATH_NOT_FOUND;
            goto out_unlock;
        }
        /* make copies for use outside of cache->lock */
        fh_copy(&files[i].fh, &target->fh);
        (*count)++;
    }
 
out_unlock:
    ReleaseSRWLockShared(&cache->lock);
    return *count && status == 0;
}

Referenced by nfs41_name_cache_remove_stale().

◆ is_delegation()

static __inline bool_t is_delegation ( IN enum open_delegation_type4 type )

static

Definition at line 72 of file name_cache.c.

{
    return type == OPEN_DELEGATE_READ || type == OPEN_DELEGATE_WRITE;
}

Referenced by attr_cache_update(), name_cache_entry_update(), and nfs41_name_cache_insert().

◆ max_putfh_components()

static __inline uint32_t max_putfh_components ( IN const nfs41_session * session )

static

Definition at line 1352 of file name_cache.c.

{
    const uint32_t comps = session->fore_chan_attrs.ca_maxoperations - 1;
    return min(comps, MAX_PUTFH_PER_COMPOUND);
}

Referenced by nfs41_name_cache_remove_stale().

◆ name_cache_enabled()

static __inline bool_t name_cache_enabled ( IN struct nfs41_name_cache * cache )

static

Definition at line 401 of file name_cache.c.

{
    return cache->expiration > 0;
}

Referenced by nfs41_attr_cache_lookup(), nfs41_attr_cache_update(), nfs41_name_cache_delegreturn(), nfs41_name_cache_insert(), nfs41_name_cache_lookup(), nfs41_name_cache_remove(), nfs41_name_cache_remove_stale(), and nfs41_name_cache_rename().

◆ name_cache_entry_accessed()

static void name_cache_entry_accessed	(	IN struct nfs41_name_cache *	cache,
		IN struct name_cache_entry *	entry
	)

static

Definition at line 492 of file name_cache.c.

{
    /* move the entry to the front of cache->exp_entries, then do
     * the same for its parents, which are more costly to evict */
    while (entry) {
        /* if entry is delegated, it won't be in the list */
        if (!list_empty(&entry->exp_entry)) {
            list_remove(&entry->exp_entry);
            list_add_head(&cache->exp_entries, &entry->exp_entry);
        }
        if (entry == entry->parent)
            break;
        entry = entry->parent;
    }
}

Referenced by name_cache_entry_updated().

◆ name_cache_entry_changed()

static int name_cache_entry_changed	(	IN struct nfs41_name_cache *	cache,
		IN struct name_cache_entry *	entry,
		IN const change_info4 *	cinfo
	)

static

Definition at line 563 of file name_cache.c.

{
    if (entry->attributes == NULL)
        return FALSE;
 
    if (cinfo->after == entry->attributes->change ||
            (cinfo->atomic && cinfo->before == entry->attributes->change)) {
        entry->attributes->change = cinfo->after;
        name_cache_entry_updated(cache, entry);
        dprintf(NCLVL1, "name_cache_entry_changed('%s') has not changed. "
            "updated change=%llu\n", entry->component,
            entry->attributes->change);
        return FALSE;
    } else {
        dprintf(NCLVL1, "name_cache_entry_changed('%s') has changed: was %llu, "
            "got before=%llu\n", entry->component,
            entry->attributes->change, cinfo->before);
        return TRUE;
    }
}

Referenced by nfs41_name_cache_insert(), nfs41_name_cache_remove(), and nfs41_name_cache_rename().

◆ name_cache_entry_create()

static int name_cache_entry_create	(	IN struct nfs41_name_cache *	cache,
		IN const nfs41_component *	component,
		OUT struct name_cache_entry **	entry_out
	)

static

Definition at line 459 of file name_cache.c.

{
    int status = NO_ERROR;
    struct name_cache_entry *entry;
 
    if (cache->entries >= cache->max_entries) {
        /* scavenge the oldest entry */
        if (list_empty(&cache->exp_entries)) {
            status = ERROR_OUTOFMEMORY;
            goto out;
        }
        entry = name_entry(cache->exp_entries.prev);
        name_cache_unlink(cache, entry);
 
        dprintf(NCLVL2, "name_cache_entry_create('%s') scavenged 0x%p\n",
            component->name, entry);
    } else {
        /* take the next entry in the pool and add it to exp_entries */
        entry = &cache->pool[cache->entries++];
        list_init(&entry->exp_entry);
        list_add_tail(&cache->exp_entries, &entry->exp_entry);
    }
 
    name_cache_entry_rename(entry, component);
 
    *entry_out = entry;
out:
    return status;
}

Referenced by name_cache_find_or_create(), and nfs41_name_cache_insert().

◆ name_cache_entry_invalidate()

static void name_cache_entry_invalidate	(	IN struct nfs41_name_cache *	cache,
		IN struct name_cache_entry *	entry
	)

static

Definition at line 587 of file name_cache.c.

{
    dprintf(NCLVL1, "name_cache_entry_invalidate('%s')\n", entry->component);
 
    if (entry->attributes) {
        /* flag attributes so that entry_invis() will return true
         * if another entry attempts to use them */
        entry->attributes->invalidated = 1;
    }
    name_cache_unlink(cache, entry);
}

Referenced by nfs41_name_cache_insert(), nfs41_name_cache_remove(), and nfs41_name_cache_rename().

◆ name_cache_entry_rename()

static __inline void name_cache_entry_rename	(	OUT struct name_cache_entry *	entry,
		IN const nfs41_component *	component
	)

static

Definition at line 407 of file name_cache.c.

{
    StringCchCopyNA(entry->component, NFS41_MAX_COMPONENT_LEN,
        component->name, component->len);
    entry->component_len = component->len;
}

Referenced by name_cache_entry_create(), and nfs41_name_cache_rename().

◆ name_cache_entry_update()

static int name_cache_entry_update	(	IN struct nfs41_name_cache *	cache,
		IN struct name_cache_entry *	entry,
		IN OPTIONAL const nfs41_fh *	fh,
		IN OPTIONAL const nfs41_file_info *	info,
		IN enum open_delegation_type4	delegation
	)

static

Definition at line 519 of file name_cache.c.

{
    int status = NO_ERROR;
 
    if (fh)
        fh_copy(&entry->fh, fh);
    else
        entry->fh.len = 0;
 
    if (info) {
        if (entry->attributes == NULL) {
            /* negative -> positive entry, create the attributes */
            status = attr_cache_find_or_create(&cache->attributes,
                info->fileid, &entry->attributes);
            if (status)
                goto out;
        }
 
        attr_cache_update(entry->attributes, info, delegation);
 
        /* hold a reference as long as we have the delegation */
        if (is_delegation(delegation)) {
            attr_cache_entry_ref(&cache->attributes, entry->attributes);
            cache->delegations++;
        }
 
        /* keep the entry from expiring */
        if (entry->attributes->delegated)
            list_remove(&entry->exp_entry);
    } else if (entry->attributes) {
        /* positive -> negative entry, deref the attributes */
        attr_cache_entry_deref(&cache->attributes, entry->attributes);
        entry->attributes = NULL;
    }
    name_cache_entry_updated(cache, entry);
out:
    return status;
}

Referenced by nfs41_name_cache_insert(), nfs41_name_cache_remove(), and nfs41_name_cache_rename().

◆ name_cache_entry_updated()

static void name_cache_entry_updated	(	IN struct nfs41_name_cache *	cache,
		IN struct name_cache_entry *	entry
	)

static

Definition at line 510 of file name_cache.c.

{
    /* update the expiration timer */
    entry->expiration = time(NULL) + cache->expiration;
    name_cache_entry_accessed(cache, entry);
}

Referenced by name_cache_entry_changed(), name_cache_entry_update(), and nfs41_name_cache_delegreturn().

◆ name_cache_find_or_create()

static int name_cache_find_or_create	(	IN struct nfs41_name_cache *	cache,
		IN struct name_cache_entry *	parent,
		IN const nfs41_component *	component,
		OUT struct name_cache_entry **	target_out
	)

static

Definition at line 712 of file name_cache.c.

{
    int status = NO_ERROR;
 
    dprintf(NCLVL1, "--> name_cache_find_or_create('%.*s' under '%s')\n",
        component->len, component->name, parent->component);
 
    *target_out = name_cache_search(cache, parent, component);
    if (*target_out)
        goto out;
 
    status = name_cache_entry_create(cache, component, target_out);
    if (status)
        goto out;
 
    status = name_cache_insert(*target_out, parent);
    if (status)
        goto out_err;
 
out:
    dprintf(NCLVL1, "<-- name_cache_find_or_create() returning %d\n",
        status);
    return status;
 
out_err:
    *target_out = NULL;
    goto out;
}

Referenced by nfs41_name_cache_insert(), and nfs41_name_cache_rename().

◆ name_cache_insert()

static int name_cache_insert	(	IN struct name_cache_entry *	entry,
		IN struct name_cache_entry *	parent
	)

static

Definition at line 696 of file name_cache.c.

{
    int status = NO_ERROR;
 
    dprintf(NCLVL2, "--> name_cache_insert('%s')\n", entry->component);
 
    if (RB_INSERT(name_tree, &parent->rbchildren, entry))
        status = ERROR_FILE_EXISTS;
    entry->parent = parent;
 
    dprintf(NCLVL2, "<-- name_cache_insert() returning %u\n", status);
    return status;
}

Referenced by name_cache_find_or_create(), and nfs41_name_cache_rename().

◆ name_cache_lookup()

static int name_cache_lookup	(	IN struct nfs41_name_cache *	cache,
		IN bool_t	skip_invis,
		IN const char *	path,
		IN const char *	path_end,
		OUT OPTIONAL const char **	remaining_path_out,
		OUT OPTIONAL struct name_cache_entry **	parent_out,
		OUT OPTIONAL struct name_cache_entry **	target_out,
		OUT OPTIONAL bool_t *	is_negative
	)

static

Definition at line 648 of file name_cache.c.

{
    struct name_cache_entry *parent, *target;
    nfs41_component component;
    const char *path_pos;
    int status = NO_ERROR;
 
    dprintf(NCLVL1, "--> name_cache_lookup('%s')\n", path);
 
    parent = NULL;
    target = cache->root;
    component.name = path_pos = path;
 
    if (target == NULL || (skip_invis && entry_invis(target, is_negative))) {
        target = NULL;
        status = ERROR_PATH_NOT_FOUND;
        goto out;
    }
 
    while (next_component(path_pos, path_end, &component)) {
        parent = target;
        target = name_cache_search(cache, parent, &component);
        path_pos = component.name + component.len;
        if (target == NULL || (skip_invis && entry_invis(target, is_negative))) {
            target = NULL;
            if (is_last_component(component.name, path_end))
                status = ERROR_FILE_NOT_FOUND;
            else
                status = ERROR_PATH_NOT_FOUND;
            break;
        }
    }
out:
    if (remaining_path_out) *remaining_path_out = component.name;
    if (parent_out) *parent_out = parent;
    if (target_out) *target_out = target;
    dprintf(NCLVL1, "<-- name_cache_lookup() returning %d\n", status);
    return status;
}

Referenced by delete_stale_component(), get_path_fhs(), nfs41_name_cache_delegreturn(), nfs41_name_cache_insert(), nfs41_name_cache_lookup(), nfs41_name_cache_remove(), and nfs41_name_cache_rename().

◆ name_cache_remove()

static __inline void name_cache_remove	(	IN struct name_cache_entry *	entry,
		IN struct name_cache_entry *	parent
	)

static

Definition at line 416 of file name_cache.c.

{
    RB_REMOVE(name_tree, &parent->rbchildren, entry);
    entry->parent = NULL;
}

Referenced by name_cache_unlink(), and nfs41_name_cache_rename().

◆ name_cache_search()

static struct name_cache_entry * name_cache_search	(	IN struct nfs41_name_cache *	cache,
		IN struct name_cache_entry *	parent,
		IN const nfs41_component *	component
	)

static

Definition at line 601 of file name_cache.c.

{
    struct name_cache_entry tmp, *entry;
 
    dprintf(NCLVL2, "--> name_cache_search('%.*s' under '%s')\n",
        component->len, component->name, parent->component);
 
    StringCchCopyNA(tmp.component, NFS41_MAX_COMPONENT_LEN,
        component->name, component->len);
    tmp.component_len = component->len;
 
    entry = RB_FIND(name_tree, &parent->rbchildren, &tmp);
    if (entry)
        dprintf(NCLVL2, "<-- name_cache_search() "
            "found existing entry 0x%p\n", entry);
    else
        dprintf(NCLVL2, "<-- name_cache_search() returning NULL\n");
    return entry;
}

Referenced by get_path_fhs(), name_cache_find_or_create(), name_cache_lookup(), and nfs41_name_cache_rename().

◆ name_cache_unlink()

static __inline void name_cache_unlink	(	IN struct nfs41_name_cache *	cache,
		IN struct name_cache_entry *	entry
	)

static

Definition at line 428 of file name_cache.c.

{
    /* remove the entry from the tree */
    if (entry->parent)
        name_cache_remove(entry, entry->parent);
    else if (entry == cache->root)
        cache->root = NULL;
 
    /* unlink all of its children */
    name_cache_unlink_children_recursive(cache, entry);
    /* release the cached attributes */
    if (entry->attributes) {
        attr_cache_entry_deref(&cache->attributes, entry->attributes);
        entry->attributes = NULL;
    }
    /* move it to the end of exp_entries for scavenging */
    list_remove(&entry->exp_entry);
    list_add_tail(&cache->exp_entries, &entry->exp_entry);
}

Referenced by delete_stale_component(), name_cache_entry_create(), name_cache_entry_invalidate(), name_cache_unlink_children_recursive(), and nfs41_name_cache_rename().

◆ name_cache_unlink_children_recursive()

static void name_cache_unlink_children_recursive	(	IN struct nfs41_name_cache *	cache,
		IN struct name_cache_entry *	parent
	)

static

Definition at line 450 of file name_cache.c.

{
    struct name_cache_entry *entry, *tmp;
    RB_FOREACH_SAFE(entry, name_tree, &parent->rbchildren, tmp)
        name_cache_unlink(cache, entry);
}

Referenced by name_cache_unlink(), nfs41_name_cache_remove(), and nfs41_name_cache_rename().

◆ name_cmp()

int name_cmp	(	struct name_cache_entry *	lhs,
		struct name_cache_entry *	rhs
	)

Definition at line 375 of file name_cache.c.

{
    const int diff = rhs->component_len - lhs->component_len;
    return diff ? diff : strncmp(lhs->component, rhs->component, lhs->component_len);
}

◆ 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 struct nfs41_name_cache ** cache_out )

Definition at line 796 of file name_cache.c.

{
    struct nfs41_name_cache *cache = *cache_out;
    int status = NO_ERROR;
 
    dprintf(NCLVL1, "nfs41_name_cache_free()\n");
 
    /* free the attribute cache */
    attr_cache_free(&cache->attributes);
 
    /* free the name entry pool */
    free(cache->pool);
    free(cache);
    *cache_out = NULL;
    return status;
}

Referenced by server_free().

◆ 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().

◆ RB_HEAD() [1/2]

RB_HEAD	(	attr_tree	,
		attr_cache_entry
	)

◆ RB_HEAD() [2/2]

RB_HEAD	(	name_tree	,
		name_cache_entry
	)

◆ rpc_array_putfh()

static int rpc_array_putfh	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	files,
		IN uint32_t	count,
		OUT uint32_t *	valid_out
	)

static

Definition at line 1283 of file name_cache.c.

{
    nfs41_compound compound;
    nfs_argop4 argops[1+MAX_PUTFH_PER_COMPOUND];
    nfs_resop4 resops[1+MAX_PUTFH_PER_COMPOUND];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res = { 0 };
    nfs41_putfh_args putfh_args[MAX_PUTFH_PER_COMPOUND];
    nfs41_putfh_res putfh_res[MAX_PUTFH_PER_COMPOUND] = { 0 };
    uint32_t i;
    int status;
 
    *valid_out = 0;
 
    compound_init(&compound, argops, resops, "array_putfh");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 0);
 
    for (i = 0; i < count; i++){
        compound_add_op(&compound, OP_PUTFH, &putfh_args[i], &putfh_res[i]);
        putfh_args[i].file = &files[i];
        putfh_args[i].in_recovery = 1;
    }
 
    status = compound_encode_send_decode(session, &compound, TRUE);
    if (status) goto out;
 
    status = sequence_res.sr_status;
    if (status) goto out;
 
    for (i = 0; i < count; i++) {
        status = putfh_res[i].status;
        if (status) break;
    }
    *valid_out = i;
out:
    return status;
}

Referenced by nfs41_name_cache_remove_stale().

Classes

Macros

Enumerations

Functions

Macro Definition Documentation

◆ attr_entry

◆ ATTR_ENTRY_SIZE

◆ MAX_PUTFH_PER_COMPOUND

◆ NAME_CACHE_EXPIRATION

◆ NAME_CACHE_MAX_ENTRIES

◆ NAME_CACHE_MAX_SIZE

◆ name_entry

◆ NAME_ENTRY_SIZE

◆ SIZE_PER_ENTRY

Enumeration Type Documentation

◆ anonymous enum

Function Documentation

◆ attr_cache_entry_create()

◆ attr_cache_entry_deref()

◆ attr_cache_entry_expired()

◆ attr_cache_entry_free()

◆ attr_cache_entry_ref()

◆ attr_cache_find_or_create()

◆ attr_cache_free()

◆ attr_cache_init()

◆ attr_cache_insert()

◆ attr_cache_search()

◆ attr_cache_update()

◆ attr_cmp()

◆ copy_attrs()

◆ copy_fh()

◆ delete_stale_component()

◆ entry_invis()

◆ get_path_fhs()

◆ is_delegation()

◆ max_putfh_components()

◆ name_cache_enabled()

◆ name_cache_entry_accessed()

◆ name_cache_entry_changed()

◆ name_cache_entry_create()

◆ name_cache_entry_invalidate()

◆ name_cache_entry_rename()

◆ name_cache_entry_update()

◆ name_cache_entry_updated()

◆ name_cache_find_or_create()

◆ name_cache_insert()

◆ name_cache_lookup()

◆ name_cache_remove()

◆ name_cache_search()

◆ name_cache_unlink()

◆ name_cache_unlink_children_recursive()

◆ name_cmp()

◆ nfs41_attr_cache_lookup()

◆ nfs41_attr_cache_update()

◆ nfs41_name_cache_create()

◆ nfs41_name_cache_delegreturn()

◆ nfs41_name_cache_free()

◆ nfs41_name_cache_insert()

◆ nfs41_name_cache_lookup()

◆ nfs41_name_cache_remove()

◆ nfs41_name_cache_remove_stale()

◆ nfs41_name_cache_rename()

◆ RB_HEAD() [1/2]

◆ RB_HEAD() [2/2]

◆ rpc_array_putfh()