recovery.h File Reference

#include "nfs41.h"

Include dependency graph for recovery.h:

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

Go to the source code of this file.

Functions
bool_t	nfs41_recovery_start_or_wait (IN nfs41_client *client)
void	nfs41_recovery_finish (IN nfs41_client *client)
int	nfs41_recover_session (IN nfs41_session *session, IN bool_t client_state_lost)
void	nfs41_recover_sequence_flags (IN nfs41_session *session, IN uint32_t flags)
int	nfs41_recover_client_state (IN nfs41_session *session, IN nfs41_client *client)
void	nfs41_client_state_revoked (IN nfs41_session *session, IN nfs41_client *client, IN uint32_t revoked)
bool_t	nfs41_recover_stateid (IN nfs41_session *session, IN struct __nfs_argop4 *argop)

Function Documentation

nfs41_client_state_revoked()

void nfs41_client_state_revoked	(	IN nfs41_session *	session,
		IN nfs41_client *	client,
		IN uint32_t	revoked
	)

Definition at line 633 of file recovery.c.

{
    const struct cb_layoutrecall_args recall = { PNFS_LAYOUTTYPE_FILE,
        PNFS_IOMODE_ANY, TRUE, { PNFS_RETURN_ALL } };
    struct list_entry empty, *opens;
    struct client_state *clientstate = &session->client->state;
    stateid_arg *stateids = NULL;
    uint32_t *statuses = NULL;
    uint32_t i, count;
    bool_t grace = TRUE;
    bool_t want_supported = TRUE;
 
    EnterCriticalSection(&clientstate->lock);
 
    if (revoked == SEQ4_STATUS_RECALLABLE_STATE_REVOKED) {
        /* only delegations were revoked. use an empty list for opens */
        list_init(&empty);
        opens = ∅
    } else {
        opens = &clientstate->opens;
    }
 
    /* get an array of the client's stateids */
    count = stateid_array(&clientstate->delegations,
        opens, &stateids, &statuses);
    if (count == 0)
        goto out;
 
    /* determine which stateids were revoked with TEST_STATEID */
    if ((revoked & SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED) == 0)
        nfs41_test_stateid(session, stateids, count, statuses);
 
    /* free all revoked stateids with FREE_STATEID */
    for (i = 0; i < count; i++)
        if (statuses[i])
            nfs41_free_stateid(session, &stateids[i].stateid);
 
    /* revoke all of the client's layouts */
    pnfs_file_layout_recall(client, &recall);
 
    /* recover the revoked stateids */
    for (i = 0; i < count; i++) {
        if (statuses[i]) {
            if (stateids[i].type == STATEID_DELEG_FILE)
                stateids[i].delegation->revoked = TRUE;
            else if (stateids[i].type == STATEID_OPEN)
                recover_open(session, stateids[i].open, &grace);
            else if (stateids[i].type == STATEID_LOCK)
                recover_locks(session, stateids[i].open, &grace);
        }
    }
    for (i = 0; i < count; i++) {
        /* delegations that weren't recovered by recover_open() */
        if (statuses[i] && stateids[i].type == STATEID_DELEG_FILE
            && stateids[i].delegation->revoked)
            recover_delegation(session, stateids[i].delegation,
                &grace, &want_supported);
    }
 
    nfs41_client_delegation_recovery(client);
out:
    LeaveCriticalSection(&clientstate->lock);
    free(stateids);
    free(statuses);
}

Referenced by nfs41_recover_sequence_flags().

nfs41_recover_client_state()

int nfs41_recover_client_state	(	IN nfs41_session *	session,
		IN nfs41_client *	client
	)

Definition at line 487 of file recovery.c.

{
    const struct cb_layoutrecall_args recall = { PNFS_LAYOUTTYPE_FILE,
        PNFS_IOMODE_ANY, TRUE, { PNFS_RETURN_ALL } };
    struct client_state *state = &session->client->state;
    struct list_entry *entry;
    nfs41_open_state *open;
    nfs41_delegation_state *deleg;
    bool_t grace = TRUE;
    bool_t want_supported = TRUE;
    int status = NFS4_OK;
 
    EnterCriticalSection(&state->lock);
 
    /* flag all delegations as revoked until successful recovery;
     * recover_open() and recover_delegation_open() will only ask
     * for delegations when revoked = TRUE */
    list_for_each(entry, &state->delegations) {
        deleg = list_container(entry, nfs41_delegation_state, client_entry);
        deleg->revoked = TRUE;
    }
 
    /* recover each of the client's opens and associated delegations */
    list_for_each(entry, &state->opens) {
        open = list_container(entry, nfs41_open_state, client_entry);
        status = recover_open(session, open, &grace);
        if (status == NFS4_OK)
            status = recover_locks(session, open, &grace);
        if (status == NFS4ERR_BADSESSION)
            goto unlock;
    }
 
    /* recover delegations that weren't associated with any opens */
    list_for_each(entry, &state->delegations) {
        deleg = list_container(entry, nfs41_delegation_state, client_entry);
        if (deleg->revoked) {
            status = recover_delegation(session,
                deleg, &grace, &want_supported);
            if (status == NFS4ERR_BADSESSION)
                goto unlock;
        }
    }
 
    /* return any delegations that were reclaimed as 'recalled' */
    status = nfs41_client_delegation_recovery(client);
unlock:
    LeaveCriticalSection(&state->lock);
 
    /* revoke all of the client's layouts */
    pnfs_file_layout_recall(client, &recall);
 
    if (grace && status != NFS4ERR_BADSESSION) {
        /* send reclaim_complete, but don't fail on errors */
        nfs41_reclaim_complete(session);
    }
    return status;
}

Referenced by nfs41_recover_sequence_flags(), and nfs41_recover_session().

nfs41_recover_sequence_flags()

void nfs41_recover_sequence_flags	(	IN nfs41_session *	session,
		IN uint32_t	flags
	)

Definition at line 98 of file recovery.c.

{
    const uint32_t revoked = flags &
        (SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED
        | SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED
        | SEQ4_STATUS_ADMIN_STATE_REVOKED
        | SEQ4_STATUS_RECALLABLE_STATE_REVOKED);
    const uint32_t restarted = flags &
        SEQ4_STATUS_RESTART_RECLAIM_NEEDED;
 
    /* no state recovery needed */
    if (revoked == 0 && restarted == 0)
        return;
 
    if (!nfs41_recovery_start_or_wait(session->client))
        return;
 
    if (revoked) {
        /* free stateids and attempt to recover them */
        nfs41_client_state_revoked(session, session->client, revoked);
 
        /* if RESTART_RECLAIM_NEEDED is also set, just do RECLAIM_COMPLETE */
        if (restarted) nfs41_reclaim_complete(session);
 
    } else if (restarted) {
        /* do server reboot state recovery */
        uint32_t status = nfs41_recover_client_state(session, session->client);
        if (status == NFS4ERR_BADSESSION) {
            /* recover the session and finish state recovery */
            nfs41_recover_session(session, TRUE);
        }
    }
 
    nfs41_recovery_finish(session->client);
}

Referenced by compound_encode_send_decode().

nfs41_recover_session()

int nfs41_recover_session	(	IN nfs41_session *	session,
		IN bool_t	client_state_lost
	)

Definition at line 69 of file recovery.c.

{
    enum nfsstat4 status = NFS4_OK;
 
restart_recovery:
    /* recover the session */
    status = nfs41_session_renew(session);
 
    if (status == NFS4ERR_STALE_CLIENTID) {
        /* recover the client */
        client_state_lost = TRUE;
        status = nfs41_client_renew(session->client);
        if (status == NFS4_OK)
            goto restart_recovery; /* resume session recovery */
 
        eprintf("nfs41_client_renew() failed with %d\n", status);
    } else if (status) {
        eprintf("nfs41_session_renew() failed with %d\n", status);
    } else if (client_state_lost) {
        /* recover the client's state */
        status = nfs41_recover_client_state(session, session->client);
        if (status == NFS4ERR_BADSESSION)
            goto restart_recovery;
    }
    return status;
}

Referenced by compound_encode_send_decode(), and nfs41_recover_sequence_flags().

nfs41_recover_stateid()

bool_t nfs41_recover_stateid	(	IN nfs41_session *	session,
		IN struct __nfs_argop4 *	argop
	)

nfs41_recovery_finish()

void nfs41_recovery_finish

(

IN nfs41_client *

client

)

Definition at line 57 of file recovery.c.

{
    EnterCriticalSection(&client->recovery.lock);
    dprintf(1, "Finished recovery for client %llu\n", client->clnt_id);
    client->recovery.in_recovery = FALSE;
    WakeAllConditionVariable(&client->recovery.cond);
    LeaveCriticalSection(&client->recovery.lock);
}

Referenced by compound_encode_send_decode(), and nfs41_recover_sequence_flags().

nfs41_recovery_start_or_wait()

bool_t nfs41_recovery_start_or_wait

(

IN nfs41_client *

client

)

Definition at line 34 of file recovery.c.

{
    bool_t status = TRUE;
 
    EnterCriticalSection(&client->recovery.lock);
 
    if (!client->recovery.in_recovery) {
        dprintf(1, "Entering recovery mode for client %llu\n", client->clnt_id);
        client->recovery.in_recovery = TRUE;
    } else {
        status = FALSE;
        dprintf(1, "Waiting for recovery of client %llu\n", client->clnt_id);
        while (client->recovery.in_recovery)
            SleepConditionVariableCS(&client->recovery.cond,
                &client->recovery.lock, INFINITE);
        dprintf(1, "Woke up after recovery of client %llu\n", client->clnt_id);
    }
 
    LeaveCriticalSection(&client->recovery.lock);
    return status;
}

Referenced by compound_encode_send_decode(), and nfs41_recover_sequence_flags().