nfs41_session.c File Reference

#include <windows.h>
#include <process.h>
#include <stdio.h>
#include "nfs41_ops.h"
#include "nfs41_callback.h"
#include "util.h"
#include "daemon_debug.h"

Include dependency graph for nfs41_session.c:

Go to the source code of this file.

Macros
#define	MAX_SLOTS_DELAY   2000 /* in milliseconds */

Functions
static int	slot_table_avail (IN const nfs41_slot_table *table)
static void	init_slot_table (nfs41_slot_table *table)
static void	resize_slot_table (IN nfs41_slot_table *table, IN uint32_t target_highest_slotid)
void	nfs41_session_bump_seq (IN nfs41_session *session, IN uint32_t slotid, IN uint32_t target_highest_slotid)
void	nfs41_session_free_slot (IN nfs41_session *session, IN uint32_t slotid)
void	nfs41_session_get_slot (IN nfs41_session *session, OUT uint32_t *slot, OUT uint32_t *seqid, OUT uint32_t *highest)
int	nfs41_session_recall_slot (IN nfs41_session *session, IN OUT uint32_t target_highest_slotid)
int	nfs41_session_bad_slot (IN nfs41_session *session, IN OUT nfs41_sequence_args *args)
void	nfs41_session_sequence (nfs41_sequence_args *args, nfs41_session *session, bool_t cachethis)
static unsigned int WINAPI	renew_session (void *args)
static int	session_alloc (IN nfs41_client *client, OUT nfs41_session **session_out)
int	nfs41_session_create (IN nfs41_client *client, IN nfs41_session **session_out)
int	nfs41_session_renew (IN nfs41_session *session)
int	nfs41_session_set_lease (IN nfs41_session *session, IN uint32_t lease_time)
void	nfs41_session_free (IN nfs41_session *session)

Macro Definition Documentation

MAX_SLOTS_DELAY

#define MAX_SLOTS_DELAY   2000 /* in milliseconds */

Definition at line 34 of file nfs41_session.c.

Referenced by nfs41_session_bad_slot(), and nfs41_session_recall_slot().

Function Documentation

init_slot_table()

static void init_slot_table ( nfs41_slot_table *  table )

static

Definition at line 45 of file nfs41_session.c.

Referenced by nfs41_session_renew(), and session_alloc().

{
    uint32_t i;
    EnterCriticalSection(&table->lock);
    table->max_slots = NFS41_MAX_NUM_SLOTS;
    for (i = 0; i < NFS41_MAX_NUM_SLOTS; i++) {
        table->seq_nums[i] = 1;
        table->used_slots[i] = 0;
    }
    table->highest_used = table->num_used = 0;
    table->target_delay = 0;

    /* wake any threads waiting on a slot */
    if (slot_table_avail(table))
        WakeAllConditionVariable(&table->cond);
    LeaveCriticalSection(&table->lock);
}

nfs41_session_bad_slot()

int nfs41_session_bad_slot	(	IN nfs41_session *	session,
		IN OUT nfs41_sequence_args *	args
	)

Definition at line 185 of file nfs41_session.c.

{
    nfs41_slot_table *table = &session->table;
    int status = NFS4ERR_BADSLOT;

    if (args->sa_slotid == 0) {
        eprintf("server bug detected: NFS4ERR_BADSLOT for slotid=0\n");
        goto out;
    }

    /* avoid using any slots >= bad_slotid */
    EnterCriticalSection(&table->lock);
    if (table->max_slots > args->sa_slotid) {
        resize_slot_table(table, args->sa_slotid);
        table->target_delay = GetTickCount64() + MAX_SLOTS_DELAY;
    }
    LeaveCriticalSection(&table->lock);

    /* get a new slot */
    nfs41_session_free_slot(session, args->sa_slotid);
    nfs41_session_get_slot(session, &args->sa_slotid,
        &args->sa_sequenceid, &args->sa_highest_slotid);
    status = NFS4_OK;
out:
    return status;
}

nfs41_session_bump_seq()

void nfs41_session_bump_seq	(	IN nfs41_session *	session,
		IN uint32_t	slotid,
		IN uint32_t	target_highest_slotid
	)

Definition at line 80 of file nfs41_session.c.

Referenced by compound_encode_send_decode(), and nfs41_root_session().

{
    nfs41_slot_table *table = &session->table;

    AcquireSRWLockShared(&session->client->session_lock);
    EnterCriticalSection(&table->lock);

    if (slotid < NFS41_MAX_NUM_SLOTS)
        table->seq_nums[slotid]++;

    /* adjust max_slots in response to changes in target_highest_slotid,
     * but not immediately after a CB_RECALL_SLOT or NFS4ERR_BADSLOT error */
    if (table->target_delay <= GetTickCount64())
        resize_slot_table(table, target_highest_slotid);

    LeaveCriticalSection(&table->lock);
    ReleaseSRWLockShared(&session->client->session_lock);
}

nfs41_session_create()

int nfs41_session_create	(	IN nfs41_client *	client,
		IN nfs41_session **	session_out
	)

Definition at line 278 of file nfs41_session.c.

Referenced by nfs41_root_session(), and root_client_create().

{
    nfs41_session *session;
    int status;

    status = session_alloc(client, &session);
    if (status) {
        eprintf("session_alloc() failed with %d\n", status);
        goto out;
    }

    AcquireSRWLockShared(&client->exid_lock);
    if (client->rpc->needcb)
        session->flags |= CREATE_SESSION4_FLAG_CONN_BACK_CHAN;
    session->flags |= CREATE_SESSION4_FLAG_PERSIST;
    ReleaseSRWLockShared(&client->exid_lock);

    status = nfs41_create_session(client, session, TRUE);
    if (status) {
        eprintf("nfs41_create_session failed %d\n", status);
        status = ERROR_BAD_NET_RESP;
        goto out_err;
    }

    AcquireSRWLockExclusive(&session->client->session_lock);
    client->session = session;
    session->isValidState = TRUE;
    ReleaseSRWLockExclusive(&session->client->session_lock);
    *session_out = session;
out:
    return status;

out_err:
    nfs41_session_free(session);
    goto out;
}

nfs41_session_free()

void nfs41_session_free

(

IN nfs41_session *

session

)

Definition at line 363 of file nfs41_session.c.

Referenced by nfs41_client_free(), nfs41_root_session(), and nfs41_session_create().

{
    AcquireSRWLockExclusive(&session->client->session_lock);
    if (valid_handle(session->renew_thread)) {
        dprintf(1, "nfs41_session_free: terminating session renewal thread\n");
        if (!TerminateThread(session->renew_thread, NO_ERROR))
            eprintf("failed to terminate renewal thread %p\n",
                session->renew_thread);
    }

    if (session->isValidState) {
        session->client->rpc->is_valid_session = FALSE;
        nfs41_destroy_session(session);
    }
    DeleteCriticalSection(&session->table.lock);
    ReleaseSRWLockExclusive(&session->client->session_lock);
    free(session);
}

nfs41_session_free_slot()

void nfs41_session_free_slot	(	IN nfs41_session *	session,
		IN uint32_t	slotid
	)

Definition at line 102 of file nfs41_session.c.

Referenced by compound_encode_send_decode(), nfs41_root_session(), and nfs41_session_bad_slot().

{
    nfs41_slot_table *table = &session->table;

    AcquireSRWLockShared(&session->client->session_lock);
    EnterCriticalSection(&table->lock);

    /* flag the slot as unused */
    if (slotid < NFS41_MAX_NUM_SLOTS && table->used_slots[slotid]) {
        table->used_slots[slotid] = 0;
        table->num_used--;
    }
    /* update highest_used if necessary */
    if (slotid == table->highest_used) {
        while (table->highest_used && !table->used_slots[table->highest_used])
            table->highest_used--;
    }
    dprintf(3, "freeing slot#=%d used=%d highest=%d\n",
        slotid, table->num_used, table->highest_used);

    /* wake any threads waiting on a slot */
    if (slot_table_avail(table))
        WakeAllConditionVariable(&table->cond);

    LeaveCriticalSection(&table->lock);
    ReleaseSRWLockShared(&session->client->session_lock);
}

nfs41_session_get_slot()

void nfs41_session_get_slot	(	IN nfs41_session *	session,
		OUT uint32_t *	slot,
		OUT uint32_t *	seqid,
		OUT uint32_t *	highest
	)

Definition at line 132 of file nfs41_session.c.

Referenced by compound_encode_send_decode(), nfs41_root_session(), nfs41_session_bad_slot(), and nfs41_session_sequence().

{
    nfs41_slot_table *table = &session->table;
    uint32_t i;

    AcquireSRWLockShared(&session->client->session_lock);
    EnterCriticalSection(&table->lock);

    /* wait for an available slot */
    while (!slot_table_avail(table))
        SleepConditionVariableCS(&table->cond, &table->lock, INFINITE);

    for (i = 0; i < table->max_slots; i++) {
        if (table->used_slots[i])
            continue;

        table->used_slots[i] = 1;
        table->num_used++;
        if (i > table->highest_used)
            table->highest_used = i;

        *slot = i;
        *seqid = table->seq_nums[i];
        *highest = table->highest_used;
        break;
    }
    LeaveCriticalSection(&table->lock);
    ReleaseSRWLockShared(&session->client->session_lock);

    dprintf(2, "session %p: using slot#=%d with seq#=%d highest=%d\n",
        session, *slot, *seqid, *highest);
}

nfs41_session_recall_slot()

int nfs41_session_recall_slot	(	IN nfs41_session *	session,
		IN OUT uint32_t	target_highest_slotid
	)

Definition at line 169 of file nfs41_session.c.

Referenced by handle_cb_recall_slot(), and nfs41_root_session().

{
    nfs41_slot_table *table = &session->table;

    AcquireSRWLockShared(&session->client->session_lock);
    EnterCriticalSection(&table->lock);
    resize_slot_table(table, target_highest_slotid);
    table->target_delay = GetTickCount64() + MAX_SLOTS_DELAY;
    LeaveCriticalSection(&table->lock);
    ReleaseSRWLockShared(&session->client->session_lock);

    return NFS4_OK;
}

nfs41_session_renew()

int nfs41_session_renew

(

IN nfs41_session *

session

)

Definition at line 318 of file nfs41_session.c.

Referenced by nfs41_recover_session(), and nfs41_root_session().

{
    int status;

    AcquireSRWLockExclusive(&session->client->session_lock);
    session->cb_session.cb_seqnum = 0;
    init_slot_table(&session->table);

    status = nfs41_create_session(session->client, session, FALSE);
    ReleaseSRWLockExclusive(&session->client->session_lock);
    return status;
}

nfs41_session_sequence()

void nfs41_session_sequence	(	nfs41_sequence_args *	args,
		nfs41_session *	session,
		bool_t	cachethis
	)

Definition at line 214 of file nfs41_session.c.

Referenced by lookup_rpc(), nfs41_access(), nfs41_close(), nfs41_commit(), nfs41_create(), nfs41_delegpurge(), nfs41_delegreturn(), nfs41_free_stateid(), nfs41_fs_locations(), nfs41_getattr(), nfs41_link(), nfs41_lock(), nfs41_open(), nfs41_read(), nfs41_readdir(), nfs41_readlink(), nfs41_reclaim_complete(), nfs41_remove(), nfs41_rename(), nfs41_root_session(), nfs41_rpc_openattr(), nfs41_secinfo(), nfs41_secinfo_noname(), nfs41_send_sequence(), nfs41_setattr(), nfs41_superblock_getattr(), nfs41_test_stateid(), nfs41_unlock(), nfs41_want_delegation(), nfs41_write(), pnfs_rpc_getdeviceinfo(), pnfs_rpc_layoutcommit(), pnfs_rpc_layoutget(), pnfs_rpc_layoutreturn(), and rpc_array_putfh().

{
    nfs41_session_get_slot(session, &args->sa_slotid, 
        &args->sa_sequenceid, &args->sa_highest_slotid);
    args->sa_sessionid = session->session_id;
    args->sa_cachethis = cachethis;
}

nfs41_session_set_lease()

int nfs41_session_set_lease	(	IN nfs41_session *	session,
		IN uint32_t	lease_time
	)

Definition at line 332 of file nfs41_session.c.

Referenced by nfs41_root_session(), and session_get_lease().

{
    int status = NO_ERROR;
    uint32_t thread_id;

    if (valid_handle(session->renew_thread)) {
        eprintf("nfs41_session_set_lease(): session "
            "renewal thread already started!\n");
        goto out;
    }

    if (lease_time == 0) {
        eprintf("nfs41_session_set_lease(): invalid lease_time=0\n");
        status = ERROR_INVALID_PARAMETER;
        goto out;
    }

    session->lease_time = lease_time;
    session->renew_thread = (HANDLE)_beginthreadex(NULL,
        0, renew_session, session, 0, &thread_id);
    if (!valid_handle(session->renew_thread)) {
        status = GetLastError();
        eprintf("_beginthreadex failed %d\n", status);
        goto out;
    }
out:
    return status;
}

renew_session()

static unsigned int WINAPI renew_session ( void *  args )

static

Definition at line 227 of file nfs41_session.c.

Referenced by nfs41_session_set_lease().

{
    int status = NO_ERROR;
    nfs41_session *session = (nfs41_session *)args;
    /* sleep for 2/3 of lease_time */
    const uint32_t sleep_time = (2 * session->lease_time*1000)/3;

    dprintf(1, "Creating renew_session thread: %p\n", session->renew_thread);
    while(1) {
        dprintf(1, "Going to sleep for %dmsecs\n", sleep_time);
        Sleep(sleep_time);
        status = nfs41_send_sequence(session);
        if (status)
            dprintf(1, "renewal thread: nfs41_send_sequence failed %d\n", status);
    }
    return status;
}

resize_slot_table()

static void resize_slot_table ( IN nfs41_slot_table *  table, IN uint32_t  target_highest_slotid  )

static

Definition at line 63 of file nfs41_session.c.

Referenced by nfs41_session_bad_slot(), nfs41_session_bump_seq(), and nfs41_session_recall_slot().

{
    if (target_highest_slotid >= NFS41_MAX_NUM_SLOTS)
        target_highest_slotid = NFS41_MAX_NUM_SLOTS - 1;

    if (table->max_slots != target_highest_slotid + 1) {
        dprintf(2, "updated max_slots %u to %u\n",
            table->max_slots, target_highest_slotid + 1);
        table->max_slots = target_highest_slotid + 1;

        if (slot_table_avail(table))
            WakeAllConditionVariable(&table->cond);
    }
}

session_alloc()

static int session_alloc ( IN nfs41_client *  client, OUT nfs41_session **  session_out  )

static

Definition at line 246 of file nfs41_session.c.

Referenced by nfs41_session_create().

{
    nfs41_session *session;
    int status = NO_ERROR;

    session = calloc(1, sizeof(nfs41_session));
    if (session == NULL) {
        status = GetLastError();
        goto out;
    }
    session->client = client;
    session->renew_thread = INVALID_HANDLE_VALUE;
    session->isValidState = FALSE;

    InitializeCriticalSection(&session->table.lock);
    InitializeConditionVariable(&session->table.cond);

    init_slot_table(&session->table);

    //initialize session lock
    InitializeSRWLock(&client->session_lock);

    /* initialize the back channel */
    nfs41_callback_session_init(session);

    *session_out = session;
out:
    return status;
}

slot_table_avail()

static int slot_table_avail ( IN const nfs41_slot_table *  table )

static

Definition at line 38 of file nfs41_session.c.

Referenced by init_slot_table(), nfs41_session_free_slot(), nfs41_session_get_slot(), and resize_slot_table().

{
    return table->num_used < table->max_slots;
}