delegation.c File Reference

#include "delegation.h"
#include "nfs41_ops.h"
#include "name_cache.h"
#include "util.h"
#include "daemon_debug.h"
#include <devioctl.h>
#include "nfs41_driver.h"

Include dependency graph for delegation.c:

Go to the source code of this file.

Classes
struct	recall_thread_args

Macros
#define	DGLVL   2 /* dprintf level for delegation logging */
#define	open_entry(pos)   list_container(pos, nfs41_open_state, client_entry)
#define	lock_entry(pos)   list_container(pos, nfs41_lock_state, open_entry)
#define	deleg_entry(pos)   list_container(pos, nfs41_delegation_state, client_entry)

Functions
static int	delegation_create (IN const nfs41_path_fh *parent, IN const nfs41_path_fh *file, IN const open_delegation4 *delegation, OUT nfs41_delegation_state **deleg_out)
void	nfs41_delegation_ref (IN nfs41_delegation_state *state)
void	nfs41_delegation_deref (IN nfs41_delegation_state *state)
static void	delegation_remove (IN nfs41_client *client, IN nfs41_delegation_state *deleg)
static bool_t	has_delegated_locks (IN nfs41_open_state *open)
static int	open_deleg_cmp (const struct list_entry *entry, const void *value)
static nfs41_open_state *	deleg_open_find (IN struct client_state *state, IN const nfs41_delegation_state *deleg)
static bool_t	deleg_lock_find (IN nfs41_open_state *open, OUT nfs41_lock_state *lock_out)
static void	deleg_lock_update (IN nfs41_open_state *open, IN const nfs41_lock_state *source)
static int	delegation_flush_locks (IN nfs41_open_state *open, IN bool_t try_recovery)
static int	delegation_return (IN nfs41_client *client, IN nfs41_delegation_state *deleg, IN bool_t truncate, IN bool_t try_recovery)
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)
static int	deleg_file_cmp (const struct list_entry *entry, const void *value)
static bool_t	delegation_compatible (IN enum open_delegation_type4 type, IN uint32_t create, IN uint32_t access, IN uint32_t deny)
static int	delegation_find (IN nfs41_client *client, IN const void *value, IN list_compare_fn cmp, OUT nfs41_delegation_state **deleg_out)
static int	delegation_truncate (IN nfs41_delegation_state *deleg, IN nfs41_client *client, IN stateid_arg *stateid, IN nfs41_file_info *info)
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)
static unsigned int WINAPI	delegation_recall_thread (void *args)
static int	deleg_stateid_cmp (const struct list_entry *entry, const void *value)
int	nfs41_delegation_recall (IN nfs41_client *client, IN nfs41_fh *fh, IN const stateid4 *stateid, IN bool_t truncate)
static int	deleg_fh_cmp (const struct list_entry *entry, const void *value)
int	nfs41_delegation_getattr (IN nfs41_client *client, IN const nfs41_fh *fh, IN const bitmap4 *attr_request, OUT nfs41_file_info *info)
void	nfs41_client_delegation_free (IN nfs41_client *client)
static int	delegation_recovery_status (IN nfs41_delegation_state *deleg)
int	nfs41_client_delegation_recovery (IN nfs41_client *client)
int	nfs41_client_delegation_return_lru (IN nfs41_client *client)

Macro Definition Documentation

deleg_entry

#define deleg_entry

(

pos

)

list_container(pos, nfs41_delegation_state, client_entry)

Definition at line 377 of file delegation.c.

DGLVL

#define DGLVL   2 /* dprintf level for delegation logging */

Definition at line 32 of file delegation.c.

lock_entry

#define lock_entry

(

pos

)

list_container(pos, nfs41_lock_state, open_entry)

Definition at line 126 of file delegation.c.

open_entry

#define open_entry

(

pos

)

list_container(pos, nfs41_open_state, client_entry)

Definition at line 89 of file delegation.c.

Function Documentation

deleg_fh_cmp()

static int deleg_fh_cmp ( const struct list_entry *  entry, const void *  value  )

static

Definition at line 775 of file delegation.c.

{
    const nfs41_fh *lhs = &deleg_entry(entry)->file.fh;
    const nfs41_fh *rhs = (const nfs41_fh*)value;
    if (lhs->len != rhs->len) return -1;
    return memcmp(lhs->fh, rhs->fh, lhs->len);
}

Referenced by nfs41_delegation_getattr().

deleg_file_cmp()

static int deleg_file_cmp ( const struct list_entry *  entry, const void *  value  )

static

Definition at line 379 of file delegation.c.

{
    const nfs41_fh *lhs = &deleg_entry(entry)->file.fh;
    const nfs41_fh *rhs = (const nfs41_fh*)value;
    if (lhs->superblock != rhs->superblock) return -1;
    if (lhs->fileid != rhs->fileid) return -1;
    return 0;
}

Referenced by nfs41_delegate_open(), nfs41_delegation_remove_srvopen(), and nfs41_delegation_return().

deleg_lock_find()

static bool_t deleg_lock_find ( IN nfs41_open_state *  open, OUT nfs41_lock_state *  lock_out  )

static

Definition at line 173 of file delegation.c.

{
    struct list_entry *entry;
    bool_t found = FALSE;
 
    AcquireSRWLockShared(&open->lock);
    list_for_each(entry, &open->locks.list) {
        nfs41_lock_state *lock = lock_entry(entry);
        if (lock->delegated) {
            /* copy offset, length, type */
            lock_out->offset = lock->offset;
            lock_out->length = lock->length;
            lock_out->exclusive = lock->exclusive;
            lock_out->id = lock->id;
            found = TRUE;
            break;
        }
    }
    ReleaseSRWLockShared(&open->lock);
    return found;
}

Referenced by delegation_flush_locks().

deleg_lock_update()

static void deleg_lock_update ( IN nfs41_open_state *  open, IN const nfs41_lock_state *  source  )

static

Definition at line 198 of file delegation.c.

{
    struct list_entry *entry;
 
    AcquireSRWLockExclusive(&open->lock);
    list_for_each(entry, &open->locks.list) {
        nfs41_lock_state *lock = lock_entry(entry);
        if (lock->id == source->id) {
            lock->delegated = FALSE;
            break;
        }
    }
    ReleaseSRWLockExclusive(&open->lock);
}

Referenced by delegation_flush_locks().

deleg_open_find()

static nfs41_open_state * deleg_open_find ( IN struct client_state *  state, IN const nfs41_delegation_state *  deleg  )

static

Definition at line 155 of file delegation.c.

{
    struct list_entry *entry;
    nfs41_open_state *open = NULL;
 
    EnterCriticalSection(&state->lock);
    entry = list_search(&state->opens, deleg, open_deleg_cmp);
    if (entry) {
        open = open_entry(entry);
        nfs41_open_state_ref(open); /* return a reference */
    }
    LeaveCriticalSection(&state->lock);
    return open;
}

Referenced by delegation_return().

deleg_stateid_cmp()

static int deleg_stateid_cmp ( const struct list_entry *  entry, const void *  value  )

static

Definition at line 696 of file delegation.c.

{
    const stateid4 *lhs = &deleg_entry(entry)->state.stateid;
    const stateid4 *rhs = (const stateid4*)value;
    return memcmp(lhs->other, rhs->other, NFS4_STATEID_OTHER);
}

Referenced by nfs41_delegation_recall().

delegation_compatible()

static bool_t delegation_compatible ( IN enum open_delegation_type4  type, IN uint32_t  create, IN uint32_t  access, IN uint32_t  deny  )

static

Definition at line 388 of file delegation.c.

{
    switch (type) {
    case OPEN_DELEGATE_WRITE:
        /* An OPEN_DELEGATE_WRITE delegation allows the client to handle,
         * on its own, all opens. */
        return TRUE;
 
    case OPEN_DELEGATE_READ:
        /* An OPEN_DELEGATE_READ delegation allows a client to handle,
         * on its own, requests to open a file for reading that do not
         * deny OPEN4_SHARE_ACCESS_READ access to others. */
        if (create == OPEN4_CREATE)
            return FALSE;
        if (access & OPEN4_SHARE_ACCESS_WRITE || deny & OPEN4_SHARE_DENY_READ)
            return FALSE;
        return TRUE;
 
    default:
        return FALSE;
    }
}

Referenced by nfs41_delegate_open().

delegation_create()

static int delegation_create ( IN const nfs41_path_fh *  parent, IN const nfs41_path_fh *  file, IN const open_delegation4 *  delegation, OUT nfs41_delegation_state **  deleg_out  )

static

Definition at line 36 of file delegation.c.

{
    nfs41_delegation_state *state;
    int status = NO_ERROR;
 
    state = calloc(1, sizeof(nfs41_delegation_state));
    if (state == NULL) {
        status = GetLastError();
        goto out;
    }
 
    memcpy(&state->state, delegation, sizeof(open_delegation4));
 
    abs_path_copy(&state->path, file->path);
    path_fh_init(&state->file, &state->path);
    fh_copy(&state->file.fh, &file->fh);
    path_fh_init(&state->parent, &state->path);
    last_component(state->path.path, state->file.name.name,
        &state->parent.name);
    fh_copy(&state->parent.fh, &parent->fh);
 
    list_init(&state->client_entry);
    state->status = DELEGATION_GRANTED;
    InitializeSRWLock(&state->lock);
    InitializeConditionVariable(&state->cond);
    state->ref_count = 1;
    *deleg_out = state;
out:
    return status;
}

Referenced by nfs41_delegation_granted().

delegation_find()

static int delegation_find ( IN nfs41_client *  client, IN const void *  value, IN list_compare_fn  cmp, OUT nfs41_delegation_state **  deleg_out  )

static

Definition at line 415 of file delegation.c.

{
    struct list_entry *entry;
    int status = NFS4ERR_BADHANDLE;
 
    EnterCriticalSection(&client->state.lock);
    entry = list_search(&client->state.delegations, value, cmp);
    if (entry) {
        /* return a reference to the delegation */
        *deleg_out = deleg_entry(entry);
        nfs41_delegation_ref(*deleg_out);
 
        /* move to the 'most recently used' end of the list */
        list_remove(entry);
        list_add_tail(&client->state.delegations, entry);
        status = NFS4_OK;
    }
    LeaveCriticalSection(&client->state.lock);
    return status;
}

Referenced by nfs41_delegate_open(), nfs41_delegation_getattr(), nfs41_delegation_recall(), nfs41_delegation_remove_srvopen(), and nfs41_delegation_return().

delegation_flush_locks()

static int delegation_flush_locks ( IN nfs41_open_state *  open, IN bool_t  try_recovery  )

static

Definition at line 215 of file delegation.c.

{
    stateid_arg stateid;
    nfs41_lock_state lock;
    int status = NFS4_OK;
 
    stateid.open = open;
    stateid.delegation = NULL;
 
    /* get the starting open/lock stateid */
    AcquireSRWLockShared(&open->lock);
    if (open->locks.stateid.seqid) {
        memcpy(&stateid.stateid, &open->locks.stateid, sizeof(stateid4));
        stateid.type = STATEID_LOCK;
    } else {
        memcpy(&stateid.stateid, &open->stateid, sizeof(stateid4));
        stateid.type = STATEID_OPEN;
    }
    ReleaseSRWLockShared(&open->lock);
 
    /* send LOCK requests for each delegated lock range */
    while (deleg_lock_find(open, &lock)) {
        status = nfs41_lock(open->session, &open->file,
            &open->owner, lock.exclusive ? WRITE_LT : READ_LT,
            lock.offset, lock.length, FALSE, try_recovery, &stateid);
        if (status)
            break;
        deleg_lock_update(open, &lock);
    }
 
    /* save the updated lock stateid */
    if (stateid.type == STATEID_LOCK) {
        AcquireSRWLockExclusive(&open->lock);
        if (open->locks.stateid.seqid == 0) {
            /* if it's a new lock stateid, copy it in */
            memcpy(&open->locks.stateid, &stateid.stateid, sizeof(stateid4));
        } else if (stateid.stateid.seqid > open->locks.stateid.seqid) {
            /* update the seqid if it's more recent */
            open->locks.stateid.seqid = stateid.stateid.seqid;
        }
        ReleaseSRWLockExclusive(&open->lock);
    }
    return status;
}

Referenced by delegation_return().

delegation_recall_thread()

static unsigned int WINAPI delegation_recall_thread ( void *  args )

static

Definition at line 683 of file delegation.c.

{
    struct recall_thread_args *recall = (struct recall_thread_args*)args;
 
    delegation_return(recall->client, recall->delegation, recall->truncate, TRUE);
 
    /* clean up thread arguments */
    nfs41_delegation_deref(recall->delegation);
    nfs41_root_deref(recall->client->root);
    free(recall);
    return 0;
}

Referenced by nfs41_delegation_recall().

delegation_recovery_status()

static int delegation_recovery_status ( IN nfs41_delegation_state *  deleg )

static

Definition at line 842 of file delegation.c.

{
    int status = NFS4_OK;
 
    AcquireSRWLockExclusive(&deleg->lock);
    if (deleg->status == DELEGATION_GRANTED) {
        if (deleg->revoked) {
            deleg->status = DELEGATION_RETURNED;
            status = NFS4ERR_BADHANDLE;
        } else if (deleg->state.recalled) {
            deleg->status = DELEGATION_RETURNING;
            status = NFS4ERR_DELEG_REVOKED;
        }
    }
    ReleaseSRWLockExclusive(&deleg->lock);
    return status;
}

Referenced by nfs41_client_delegation_recovery().

delegation_remove()

static void delegation_remove ( IN nfs41_client *  client, IN nfs41_delegation_state *  deleg  )

static

Definition at line 91 of file delegation.c.

{
    struct list_entry *entry;
 
    /* remove from the client's list */
    EnterCriticalSection(&client->state.lock);
    list_remove(&deleg->client_entry);
 
    /* remove from each associated open */
    list_for_each(entry, &client->state.opens) {
        nfs41_open_state *open = open_entry(entry);
        AcquireSRWLockExclusive(&open->lock);
        if (open->delegation.state == deleg) {
            /* drop the delegation reference */
            nfs41_delegation_deref(open->delegation.state);
            open->delegation.state = NULL;
        }
        ReleaseSRWLockExclusive(&open->lock);
    }
    LeaveCriticalSection(&client->state.lock);
 
    /* signal threads waiting on delegreturn */
    AcquireSRWLockExclusive(&deleg->lock);
    deleg->status = DELEGATION_RETURNED;
    WakeAllConditionVariable(&deleg->cond);
    ReleaseSRWLockExclusive(&deleg->lock);
 
    /* release the client's reference */
    nfs41_delegation_deref(deleg);
}

Referenced by delegation_return(), and nfs41_client_delegation_recovery().

delegation_return()

static int delegation_return ( IN nfs41_client *  client, IN nfs41_delegation_state *  deleg, IN bool_t  truncate, IN bool_t  try_recovery  )

static

Definition at line 264 of file delegation.c.

{
    stateid_arg stateid;
    nfs41_open_state *open;
    int status;
 
    if (deleg->srv_open) {
        /* make an upcall to the kernel: invalide data cache */
        HANDLE pipe;
        unsigned char inbuf[sizeof(HANDLE)], *buffer = inbuf; 
        DWORD inbuf_len = sizeof(HANDLE), outbuf_len, dstatus;
        uint32_t length;
        dprintf(1, "delegation_return: making a downcall for srv_open=%x\n", 
            deleg->srv_open);
        pipe = CreateFile(NFS41_USER_DEVICE_NAME_A, GENERIC_READ|GENERIC_WRITE, 
                FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
        if (pipe == INVALID_HANDLE_VALUE) {
            eprintf("delegation_return: Unable to open downcall pipe %d\n", 
                GetLastError());
            goto out_downcall;
        }
        length = inbuf_len;
        safe_write(&buffer, &length, &deleg->srv_open, sizeof(HANDLE));
 
        dstatus = DeviceIoControl(pipe, IOCTL_NFS41_INVALCACHE, inbuf, inbuf_len,
            NULL, 0, (LPDWORD)&outbuf_len, NULL);
        if (!dstatus)
            eprintf("IOCTL_NFS41_INVALCACHE failed %d\n", GetLastError());
        CloseHandle(pipe);
    }
out_downcall:
 
    /* recover opens and locks associated with the delegation */
    while (open = deleg_open_find(&client->state, deleg)) {
        status = nfs41_delegation_to_open(open, try_recovery);
        if (status == NFS4_OK)
            status = delegation_flush_locks(open, try_recovery);
        nfs41_open_state_deref(open);
 
        if (status)
            break;
    }
 
    /* return the delegation */
    stateid.type = STATEID_DELEG_FILE;
    stateid.open = NULL;
    stateid.delegation = deleg;
    AcquireSRWLockShared(&deleg->lock);
    memcpy(&stateid.stateid, &deleg->state.stateid, sizeof(stateid4));
    ReleaseSRWLockShared(&deleg->lock);
 
    status = nfs41_delegreturn(client->session,
        &deleg->file, &stateid, try_recovery);
    if (status == NFS4ERR_BADSESSION)
        goto out;
 
    delegation_remove(client, deleg);
out:
    return status;
}

Referenced by delegation_recall_thread(), nfs41_client_delegation_recovery(), nfs41_client_delegation_return_lru(), nfs41_delegate_open(), and nfs41_delegation_return().

delegation_truncate()

static int delegation_truncate ( IN nfs41_delegation_state *  deleg, IN nfs41_client *  client, IN stateid_arg *  stateid, IN nfs41_file_info *  info  )

static

Definition at line 440 of file delegation.c.

{
    nfs41_superblock *superblock = deleg->file.fh.superblock;
 
    /* use SETATTR to truncate the file */
    info->attrmask.arr[1] |= FATTR4_WORD1_TIME_CREATE |
        FATTR4_WORD1_TIME_MODIFY_SET;
 
    get_nfs_time(&info->time_create);
    get_nfs_time(&info->time_modify);
    info->time_delta = &superblock->time_delta;
 
    /* mask out unsupported attributes */
    nfs41_superblock_supported_attrs(superblock, &info->attrmask);
 
    return nfs41_setattr(client->session, &deleg->file, stateid, info);
}

Referenced by nfs41_delegate_open().

has_delegated_locks()

static bool_t has_delegated_locks ( IN nfs41_open_state *  open )

static

Definition at line 128 of file delegation.c.

{
    struct list_entry *entry;
    list_for_each(entry, &open->locks.list) {
        if (lock_entry(entry)->delegated)
            return TRUE;
    }
    return FALSE;
}

Referenced by open_deleg_cmp().

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

open_deleg_cmp()

static int open_deleg_cmp ( const struct list_entry *  entry, const void *  value  )

static

Definition at line 139 of file delegation.c.

{
    nfs41_open_state *open = open_entry(entry);
    int result = -1;
 
    /* open must match the delegation and have state to reclaim */
    AcquireSRWLockShared(&open->lock);
    if (open->delegation.state != value) goto out;
    if (open->do_close && !has_delegated_locks(open)) goto out;
    result = 0;
out:
    ReleaseSRWLockShared(&open->lock);
    return result;
}

Referenced by deleg_open_find().