delegation.h File Reference

#include "nfs41.h"

Include dependency graph for delegation.h:

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

Go to the source code of this file.

Macros
#define	DELEGATION_RETURN_ON_CONFLICT

Functions
void	nfs41_delegation_ref (IN nfs41_delegation_state *state)
void	nfs41_delegation_deref (IN nfs41_delegation_state *state)
void	nfs41_client_delegation_free (IN nfs41_client *client)
int	nfs41_delegation_granted (IN nfs41_session *session, IN nfs41_path_fh *parent, IN nfs41_path_fh *file, IN open_delegation4 *delegation, IN bool_t try_recovery, OUT nfs41_delegation_state **deleg_out)
int	nfs41_delegate_open (IN nfs41_open_state *state, IN uint32_t create, IN OPTIONAL nfs41_file_info *createattrs, OUT nfs41_file_info *info)
int	nfs41_delegation_to_open (IN nfs41_open_state *open, IN bool_t try_recovery)
void	nfs41_delegation_remove_srvopen (IN nfs41_session *session, IN nfs41_path_fh *file)
int	nfs41_delegation_return (IN nfs41_session *session, IN nfs41_path_fh *file, IN enum open_delegation_type4 access, IN bool_t truncate)
int	nfs41_delegation_recall (IN nfs41_client *client, IN nfs41_fh *fh, IN const stateid4 *stateid, IN bool_t truncate)
int	nfs41_delegation_getattr (IN nfs41_client *client, IN const nfs41_fh *fh, IN const bitmap4 *attr_request, OUT nfs41_file_info *info)
int	nfs41_client_delegation_recovery (IN nfs41_client *client)
int	nfs41_client_delegation_return_lru (IN nfs41_client *client)

Macro Definition Documentation

DELEGATION_RETURN_ON_CONFLICT

#define DELEGATION_RETURN_ON_CONFLICT

Definition at line 29 of file delegation.h.

Function Documentation

nfs41_client_delegation_free()

void nfs41_client_delegation_free

(

IN nfs41_client *

client

)

Definition at line 828 of file delegation.c.

{
    struct list_entry *entry, *tmp;
 
    EnterCriticalSection(&client->state.lock);
    list_for_each_tmp (entry, tmp, &client->state.delegations) {
        list_remove(entry);
        nfs41_delegation_deref(deleg_entry(entry));
    }
    LeaveCriticalSection(&client->state.lock);
}

Referenced by nfs41_client_free().

nfs41_client_delegation_recovery()

int nfs41_client_delegation_recovery

(

IN nfs41_client *

client

)

Definition at line 861 of file delegation.c.

{
    struct list_entry *entry, *tmp;
    nfs41_delegation_state *deleg;
    int status = NFS4_OK;
 
    list_for_each_tmp(entry, tmp, &client->state.delegations) {
        deleg = list_container(entry, nfs41_delegation_state, client_entry);
 
        status = delegation_recovery_status(deleg);
        switch (status) {
        case NFS4ERR_DELEG_REVOKED:
            /* the delegation was reclaimed, but flagged as recalled;
             * return it with try_recovery=FALSE */
            status = delegation_return(client, deleg, FALSE, FALSE);
            break;
 
        case NFS4ERR_BADHANDLE:
            /* reclaim failed, so we have no delegation state on the server;
             * 'forget' the delegation without trying to return it */
            delegation_remove(client, deleg);
            status = NFS4_OK;
            break;
        }
 
        if (status == NFS4ERR_BADSESSION)
            goto out;
    }
 
    /* use DELEGPURGE to indicate that we're done reclaiming delegations */
    status = nfs41_delegpurge(client->session);
 
    /* support for DELEGPURGE is optional; ignore any errors but BADSESSION */
    if (status != NFS4ERR_BADSESSION)
        status = NFS4_OK;
out:
    return status;
}

Referenced by nfs41_client_state_revoked(), and nfs41_recover_client_state().

nfs41_client_delegation_return_lru()

int nfs41_client_delegation_return_lru

(

IN nfs41_client *

client

)

Definition at line 902 of file delegation.c.

{
    struct list_entry *entry;
    nfs41_delegation_state *state = NULL;
    int status = NFS4ERR_BADHANDLE;
 
    /* starting from the least recently opened, find and return
     * the first delegation that's not 'in use' (currently open) */
 
    /* TODO: use a more robust algorithm, taking into account:
     *  -number of total opens
     *  -time since last operation on an associated open, or
     *  -number of operations/second over last n seconds */
    EnterCriticalSection(&client->state.lock);
    list_for_each(entry, &client->state.delegations) {
        state = deleg_entry(entry);
 
        /* skip if it's currently in use for an open; note that ref_count
         * can't go from 1 to 2 without holding client->state.lock */
        if (state->ref_count > 1)
            continue;
 
        AcquireSRWLockExclusive(&state->lock);
        if (state->status == DELEGATION_GRANTED) {
            /* start returning the delegation */
            state->status = DELEGATION_RETURNING;
            status = NFS4ERR_DELEG_REVOKED;
        }
        ReleaseSRWLockExclusive(&state->lock);
 
        if (status == NFS4ERR_DELEG_REVOKED)
            break;
    }
    LeaveCriticalSection(&client->state.lock);
 
    if (status == NFS4ERR_DELEG_REVOKED)
        status = delegation_return(client, state, FALSE, TRUE);
    return status;
}

Referenced by open_update_cache().

nfs41_delegate_open()

int nfs41_delegate_open	(	IN nfs41_open_state *	state,
		IN uint32_t	create,
		IN OPTIONAL nfs41_file_info *	createattrs,
		OUT nfs41_file_info *	info
	)

Definition at line 462 of file delegation.c.

{
    nfs41_client *client = state->session->client;
    nfs41_path_fh *file = &state->file;
    uint32_t access = state->share_access;
    uint32_t deny = state->share_deny;
    nfs41_delegation_state *deleg;
    stateid_arg stateid;
    int status;
 
    /* search for a delegation with this filehandle */
    status = delegation_find(client, &file->fh, deleg_file_cmp, &deleg);
    if (status)
        goto out;
 
    AcquireSRWLockExclusive(&deleg->lock);
    if (deleg->status != DELEGATION_GRANTED) {
        /* the delegation is being returned, wait for it to finish */
        while (deleg->status != DELEGATION_RETURNED)
            SleepConditionVariableSRW(&deleg->cond, &deleg->lock, INFINITE, 0);
        status = NFS4ERR_BADHANDLE;
    }
    else if (!delegation_compatible(deleg->state.type, create, access, deny)) {
#ifdef DELEGATION_RETURN_ON_CONFLICT
        /* this open will conflict, start the delegation return */
        deleg->status = DELEGATION_RETURNING;
        status = NFS4ERR_DELEG_REVOKED;
#else
        status = NFS4ERR_BADHANDLE;
#endif
    } else if (create == OPEN4_CREATE) {
        /* copy the stateid for SETATTR */
        stateid.open = NULL;
        stateid.delegation = deleg;
        stateid.type = STATEID_DELEG_FILE;
        memcpy(&stateid.stateid, &deleg->state.stateid, sizeof(stateid4));
    }
    if (!status) {
        dprintf(1, "nfs41_delegate_open: updating srv_open from %x to %x\n", 
            deleg->srv_open, state->srv_open);
        deleg->srv_open = state->srv_open;
    }
    ReleaseSRWLockExclusive(&deleg->lock);
 
    if (status == NFS4ERR_DELEG_REVOKED)
        goto out_return;
    if (status)
        goto out_deleg;
 
    if (create == OPEN4_CREATE) {
        memcpy(info, createattrs, sizeof(nfs41_file_info));
 
        /* write delegations allow us to simulate OPEN4_CREATE with SETATTR */
        status = delegation_truncate(deleg, client, &stateid, info);
        if (status)
            goto out_deleg;
    }
 
    /* TODO: check access against deleg->state.permissions or send ACCESS */
 
    state->delegation.state = deleg;
    status = NFS4_OK;
out:
    return status;
 
out_return:
    delegation_return(client, deleg, create == OPEN4_CREATE, TRUE);
 
out_deleg:
    nfs41_delegation_deref(deleg);
    goto out;
}

Referenced by open_or_delegate().

nfs41_delegation_deref()

void nfs41_delegation_deref

(

IN nfs41_delegation_state *

state

)

Definition at line 79 of file delegation.c.

{
    const LONG count = InterlockedDecrement(&state->ref_count);
    dprintf(DGLVL, "nfs41_delegation_deref(%s) count %d\n",
        state->path.path, count);
    if (count == 0)
        free(state);
}

Referenced by delegation_recall_thread(), delegation_remove(), nfs41_client_delegation_free(), nfs41_delegate_open(), nfs41_delegation_getattr(), nfs41_delegation_recall(), nfs41_delegation_remove_srvopen(), nfs41_delegation_return(), and open_state_free().

nfs41_delegation_getattr()

int nfs41_delegation_getattr	(	IN nfs41_client *	client,
		IN const nfs41_fh *	fh,
		IN const bitmap4 *	attr_request,
		OUT nfs41_file_info *	info
	)

Definition at line 783 of file delegation.c.

{
    nfs41_delegation_state *deleg;
    uint64_t fileid;
    int status;
 
    dprintf(2, "--> nfs41_delegation_getattr()\n");
 
    /* search for a delegation on this file handle */
    status = delegation_find(client, fh, deleg_fh_cmp, &deleg);
    if (status)
        goto out;
 
    AcquireSRWLockShared(&deleg->lock);
    fileid = deleg->file.fh.fileid;
    if (deleg->status != DELEGATION_GRANTED ||
        deleg->state.type != OPEN_DELEGATE_WRITE) {
        status = NFS4ERR_BADHANDLE;
    }
    ReleaseSRWLockShared(&deleg->lock);
    if (status)
        goto out_deleg;
 
    ZeroMemory(info, sizeof(nfs41_file_info));
 
    /* find attributes for the given fileid */
    status = nfs41_attr_cache_lookup(
        client_name_cache(client), fileid, info);
    if (status) {
        status = NFS4ERR_BADHANDLE;
        goto out_deleg;
    }
out_deleg:
    nfs41_delegation_deref(deleg);
out:
    dprintf(DGLVL, "<-- nfs41_delegation_getattr() returning %s\n",
        nfs_error_string(status));
    return status;
}

Referenced by handle_cb_getattr().

nfs41_delegation_granted()

int nfs41_delegation_granted	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	parent,
		IN nfs41_path_fh *	file,
		IN open_delegation4 *	delegation,
		IN bool_t	try_recovery,
		OUT nfs41_delegation_state **	deleg_out
	)

Definition at line 330 of file delegation.c.

{
    stateid_arg stateid;
    nfs41_client *client = session->client;
    nfs41_delegation_state *state;
    int status = NO_ERROR;
 
    if (delegation->type != OPEN_DELEGATE_READ &&
        delegation->type != OPEN_DELEGATE_WRITE)
        goto out;
 
    if (delegation->recalled) {
        status = NFS4ERR_DELEG_REVOKED;
        goto out_return;
    }
 
    /* allocate the delegation state */
    status = delegation_create(parent, file, delegation, &state);
    if (status)
        goto out_return;
 
    /* register the delegation with the client */
    EnterCriticalSection(&client->state.lock);
    /* XXX: check for duplicates by fh and stateid? */
    list_add_tail(&client->state.delegations, &state->client_entry);
    LeaveCriticalSection(&client->state.lock);
 
    nfs41_delegation_ref(state); /* return a reference */
    *deleg_out = state;
out:
    return status;
 
out_return: /* return the delegation on failure */
    memcpy(&stateid.stateid, &delegation->stateid, sizeof(stateid4));
    stateid.type = STATEID_DELEG_FILE;
    stateid.open = NULL;
    stateid.delegation = NULL;
    nfs41_delegreturn(session, file, &stateid, try_recovery);
    goto out;
}

Referenced by do_open(), and recover_open().

nfs41_delegation_recall()

int nfs41_delegation_recall	(	IN nfs41_client *	client,
		IN nfs41_fh *	fh,
		IN const stateid4 *	stateid,
		IN bool_t	truncate
	)

Definition at line 703 of file delegation.c.

{
    nfs41_delegation_state *deleg;
    struct recall_thread_args *args;
    int status;
 
    dprintf(2, "--> nfs41_delegation_recall()\n");
 
    /* search for the delegation by stateid instead of filehandle;
     * deleg_file_cmp() relies on a proper superblock and fileid,
     * which we don't get with CB_RECALL */
    status = delegation_find(client, stateid, deleg_stateid_cmp, &deleg);
    if (status)
        goto out;
 
    AcquireSRWLockExclusive(&deleg->lock);
    if (deleg->state.recalled) {
        /* return BADHANDLE if we've already responded to CB_RECALL */
        status = NFS4ERR_BADHANDLE;
    } else {
        deleg->state.recalled = 1;
 
        if (deleg->status == DELEGATION_GRANTED) {
            /* start the delegation return */
            deleg->status = DELEGATION_RETURNING;
            status = NFS4ERR_DELEG_REVOKED;
        } /* else return NFS4_OK */
    }
    ReleaseSRWLockExclusive(&deleg->lock);
 
    if (status != NFS4ERR_DELEG_REVOKED)
        goto out_deleg;
 
    /* allocate thread arguments */
    args = calloc(1, sizeof(struct recall_thread_args));
    if (args == NULL) {
        status = NFS4ERR_SERVERFAULT;
        eprintf("nfs41_delegation_recall() failed to allocate arguments\n");
        goto out_deleg;
    }
 
    /* hold a reference on the root */
    nfs41_root_ref(client->root);
    args->client = client;
    args->delegation = deleg;
    args->truncate = truncate;
 
    /* the callback thread can't make rpc calls, so spawn a separate thread */
    if (_beginthreadex(NULL, 0, delegation_recall_thread, args, 0, NULL) == 0) {
        status = NFS4ERR_SERVERFAULT;
        eprintf("nfs41_delegation_recall() failed to start thread\n");
        goto out_args;
    }
    status = NFS4_OK;
out:
    dprintf(DGLVL, "<-- nfs41_delegation_recall() returning %s\n",
        nfs_error_string(status));
    return status;
 
out_args:
    free(args);
    nfs41_root_deref(client->root);
out_deleg:
    nfs41_delegation_deref(deleg);
    goto out;
}

Referenced by handle_cb_recall().

nfs41_delegation_ref()

void nfs41_delegation_ref

(

IN nfs41_delegation_state *

state

)

Definition at line 71 of file delegation.c.

{
    const LONG count = InterlockedIncrement(&state->ref_count);
    dprintf(DGLVL, "nfs41_delegation_ref(%s) count %d\n",
        state->path.path, count);
}

Referenced by delegation_find(), and nfs41_delegation_granted().

nfs41_delegation_remove_srvopen()

void nfs41_delegation_remove_srvopen	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	file
	)

Definition at line 610 of file delegation.c.

{
    nfs41_delegation_state *deleg = NULL;
 
    /* find a delegation for this file */
    if (delegation_find(session->client, &file->fh, deleg_file_cmp, &deleg))
        return;
    dprintf(1, "nfs41_delegation_remove_srvopen: removing reference to "
        "srv_open=%x\n", deleg->srv_open);
    AcquireSRWLockExclusive(&deleg->lock);
    deleg->srv_open = NULL;
    ReleaseSRWLockExclusive(&deleg->lock);
    nfs41_delegation_deref(deleg);
}

Referenced by handle_close().

nfs41_delegation_return()

int nfs41_delegation_return	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	file,
		IN enum open_delegation_type4	access,
		IN bool_t	truncate
	)

Definition at line 629 of file delegation.c.

{
    nfs41_client *client = session->client;
    nfs41_delegation_state *deleg;
    int status;
 
    /* find a delegation for this file */
    status = delegation_find(client, &file->fh, deleg_file_cmp, &deleg);
    if (status)
        goto out;
 
    AcquireSRWLockExclusive(&deleg->lock);
    if (deleg->status == DELEGATION_GRANTED) {
        /* return unless delegation is write and access is read */
        if (deleg->state.type != OPEN_DELEGATE_WRITE
            || access != OPEN_DELEGATE_READ) {
            deleg->status = DELEGATION_RETURNING;
            status = NFS4ERR_DELEG_REVOKED;
        }
    } else {
        /* the delegation is being returned, wait for it to finish */
        while (deleg->status == DELEGATION_RETURNING)
            SleepConditionVariableSRW(&deleg->cond, &deleg->lock, INFINITE, 0);
        status = NFS4ERR_BADHANDLE;
    }
    ReleaseSRWLockExclusive(&deleg->lock);
 
    if (status == NFS4ERR_DELEG_REVOKED) {
        delegation_return(client, deleg, truncate, TRUE);
        status = NFS4_OK;
    }
 
    nfs41_delegation_deref(deleg);
out:
    return status;
}

Referenced by cancel_open(), handle_close(), handle_nfs41_remove(), handle_nfs41_set_size(), handle_open(), handle_setacl(), and handle_setexattr().

nfs41_delegation_to_open()

int nfs41_delegation_to_open	(	IN nfs41_open_state *	open,
		IN bool_t	try_recovery
	)

Definition at line 539 of file delegation.c.

{
    open_delegation4 ignore;
    open_claim4 claim;
    stateid4 open_stateid = { 0 };
    stateid_arg deleg_stateid;
    int status = NFS4_OK;
 
    AcquireSRWLockExclusive(&open->lock);
    if (open->delegation.state == NULL) /* no delegation to reclaim */
        goto out_unlock;
 
    if (open->do_close) /* already have an open stateid */
        goto out_unlock;
 
    /* if another thread is reclaiming the open stateid,
     * wait for it to finish before returning success */
    if (open->delegation.reclaim) {
        do {
            SleepConditionVariableSRW(&open->delegation.cond, &open->lock,
                INFINITE, 0);
        } while (open->delegation.reclaim);
        if (open->do_close)
            goto out_unlock;
    }
    open->delegation.reclaim = 1;
 
    AcquireSRWLockShared(&open->delegation.state->lock);
    deleg_stateid.open = open;
    deleg_stateid.delegation = NULL;
    deleg_stateid.type = STATEID_DELEG_FILE;
    memcpy(&deleg_stateid.stateid, &open->delegation.state->state.stateid,
        sizeof(stateid4));
    ReleaseSRWLockShared(&open->delegation.state->lock);
 
    ReleaseSRWLockExclusive(&open->lock);
 
    /* send OPEN with CLAIM_DELEGATE_CUR */
    claim.claim = CLAIM_DELEGATE_CUR;
    claim.u.deleg_cur.delegate_stateid = &deleg_stateid;
    claim.u.deleg_cur.name = &open->file.name;
 
    status = nfs41_open(open->session, &open->parent, &open->file,
        &open->owner, &claim, open->share_access, open->share_deny,
        OPEN4_NOCREATE, 0, NULL, try_recovery, &open_stateid, &ignore, NULL);
 
    AcquireSRWLockExclusive(&open->lock);
    if (status == NFS4_OK) {
        /* save the new open stateid */
        memcpy(&open->stateid, &open_stateid, sizeof(stateid4));
        open->do_close = 1;
    } else if (open->do_close && (status == NFS4ERR_BAD_STATEID ||
        status == NFS4ERR_STALE_STATEID || status == NFS4ERR_EXPIRED)) {
        /* something triggered client state recovery, and the open stateid
         * has already been reclaimed; see recover_stateid_delegation() */
        status = NFS4_OK;
    }
    open->delegation.reclaim = 0;
 
    /* signal anyone waiting on the open stateid */
    WakeAllConditionVariable(&open->delegation.cond);
out_unlock:
    ReleaseSRWLockExclusive(&open->lock);
    if (status)
        eprintf("nfs41_delegation_to_open(%p) failed with %s\n",
            open, nfs_error_string(status));
    return status;
}

Referenced by delegation_return(), and handle_lock().