reactos/base/services/nfsd/nfs41_session.c

382 lines
11 KiB
C
Raw Normal View History

/* NFSv4.1 client for Windows
* Copyright <EFBFBD> 2012 The Regents of the University of Michigan
*
* Olga Kornievskaia <aglo@umich.edu>
* Casey Bodley <cbodley@umich.edu>
*
* This library is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; either version 2.1 of the License, or (at
* your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* without any warranty; without even the implied warranty of merchantability
* or fitness for a particular purpose. See the GNU Lesser General Public
* License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this library; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA
*/
#include <windows.h>
#include <process.h>
#include <stdio.h>
#include "nfs41_ops.h"
#include "nfs41_callback.h"
#include "util.h"
#include "daemon_debug.h"
/* after a CB_RECALL_SLOT or NFS4ERR_BADSLOT, wait a short time for the
* SEQUENCE.target_highest_slotid to catch up before updating max_slots again */
#define MAX_SLOTS_DELAY 2000 /* in milliseconds */
/* predicate for nfs41_slot_table.cond */
static int slot_table_avail(
IN const nfs41_slot_table *table)
{
return table->num_used < table->max_slots;
}
/* session slot mechanism */
static void init_slot_table(nfs41_slot_table *table)
{
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);
}
static void resize_slot_table(
IN nfs41_slot_table *table,
IN uint32_t target_highest_slotid)
{
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);
}
}
void nfs41_session_bump_seq(
IN nfs41_session *session,
IN uint32_t slotid,
IN uint32_t target_highest_slotid)
{
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);
}
void nfs41_session_free_slot(
IN nfs41_session *session,
IN uint32_t slotid)
{
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);
}
void nfs41_session_get_slot(
IN nfs41_session *session,
OUT uint32_t *slot,
OUT uint32_t *seqid,
OUT uint32_t *highest)
{
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);
}
int nfs41_session_recall_slot(
IN nfs41_session *session,
IN OUT uint32_t target_highest_slotid)
{
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;
}
int nfs41_session_bad_slot(
IN nfs41_session *session,
IN OUT nfs41_sequence_args *args)
{
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;
}
void nfs41_session_sequence(
nfs41_sequence_args *args,
nfs41_session *session,
bool_t cachethis)
{
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;
}
/* session renewal */
static unsigned int WINAPI renew_session(void *args)
{
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;
}
/* session creation */
static int session_alloc(
IN nfs41_client *client,
OUT nfs41_session **session_out)
{
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;
}
int nfs41_session_create(
IN nfs41_client *client,
IN nfs41_session **session_out)
{
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;
}
/* session renewal */
int nfs41_session_renew(
IN nfs41_session *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;
}
int nfs41_session_set_lease(
IN nfs41_session *session,
IN uint32_t lease_time)
{
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;
}
void nfs41_session_free(
IN nfs41_session *session)
{
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);
}