nfs41_compound.h File Reference

#include "nfs41.h"

Include dependency graph for nfs41_compound.h:

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

Go to the source code of this file.

Classes
struct	__nfs_argop4
struct	__nfs41_compound_args
struct	__nfs_resop4
struct	__nfs41_compound_res
struct	__nfs41_compound

Typedefs
typedef struct __nfs_argop4	nfs_argop4
typedef struct __nfs41_compound_args	nfs41_compound_args
typedef struct __nfs_resop4	nfs_resop4
typedef struct __nfs41_compound_res	nfs41_compound_res
typedef struct __nfs41_compound	nfs41_compound

Functions
int	compound_error (int status)
void	compound_init (nfs41_compound *compound, nfs_argop4 *argops, nfs_resop4 *resops, const char *tag)
void	compound_add_op (nfs41_compound *compound, uint32_t opnum, void *arg, void *res)
int	compound_encode_send_decode (nfs41_session *session, nfs41_compound *compound, bool_t try_recovery)

Typedef Documentation

nfs41_compound

typedef struct __nfs41_compound nfs41_compound

nfs41_compound_args

typedef struct __nfs41_compound_args nfs41_compound_args

nfs41_compound_res

typedef struct __nfs41_compound_res nfs41_compound_res

nfs_argop4

typedef struct __nfs_argop4 nfs_argop4

nfs_resop4

typedef struct __nfs_resop4 nfs_resop4

Function Documentation

compound_add_op()

void compound_add_op	(	nfs41_compound *	compound,
		uint32_t	opnum,
		void *	arg,
		void *	res
	)

Definition at line 61 of file nfs41_compound.c.

{
    const uint32_t i = compound->args.argarray_count++;
    const uint32_t j = compound->res.resarray_count++;
    compound->args.argarray[i].op = opnum;
    compound->args.argarray[i].arg = arg;
    compound->res.resarray[j].op = opnum;
    compound->res.resarray[j].res = res;
}

Referenced by lookup_rpc(), nfs41_access(), nfs41_bind_conn_to_session(), nfs41_close(), nfs41_commit(), nfs41_create(), nfs41_create_session(), nfs41_delegpurge(), nfs41_delegreturn(), nfs41_destroy_clientid(), nfs41_destroy_session(), nfs41_exchange_id(), 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_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().

compound_encode_send_decode()

int compound_encode_send_decode	(	nfs41_session *	session,
		nfs41_compound *	compound,
		bool_t	try_recovery
	)

Definition at line 137 of file nfs41_compound.c.

{
    int status, retry_count = 0, delayby = 0, secinfo_status;
    nfs41_sequence_args *args = (nfs41_sequence_args *)
        compound->args.argarray[0].arg;
    uint32_t saved_sec_flavor;
    AUTH *saved_auth;
    int op1 = compound->args.argarray[0].op;
 
retry:
    /* send compound */
    retry_count++;
    set_expected_res(compound);
    status = nfs41_send_compound(session->client->rpc,
        (char *)&compound->args, (char *)&compound->res);
    // bump sequence number if sequence op succeeded.
    if (compound->res.resarray_count > 0 && 
            compound->res.resarray[0].op == OP_SEQUENCE) {
        nfs41_sequence_res *seq = 
            (nfs41_sequence_res *)compound->res.resarray[0].res;
        if (seq->sr_status == NFS4_OK) {
            // returned slotid must be the same we sent
            if (seq->sr_resok4.sr_slotid != args->sa_slotid) {
                eprintf("[session] sr_slotid=%d != sa_slotid=%d\n",
                    seq->sr_resok4.sr_slotid, args->sa_slotid);
                status = NFS4ERR_IO;
                goto out_free_slot;
            }
            // returned sessionid must be the same we sent
            if (memcmp(seq->sr_resok4.sr_sessionid, args->sa_sessionid, 
                    NFS4_SESSIONID_SIZE)) {
                eprintf("[session] sr_sessionid != sa_sessionid\n");
                print_hexbuf(1, (unsigned char *)"sr_sessionid", 
                    seq->sr_resok4.sr_sessionid, NFS4_SESSIONID_SIZE);
                print_hexbuf(1, (unsigned char *)"sa_sessionid", 
                    args->sa_sessionid, NFS4_SESSIONID_SIZE);
                status = NFS4ERR_IO;
                goto out_free_slot;
            }
            if (seq->sr_resok4.sr_status_flags) 
                print_sr_status_flags(1, seq->sr_resok4.sr_status_flags);
 
            nfs41_session_bump_seq(session, args->sa_slotid,
                seq->sr_resok4.sr_target_highest_slotid);
 
            /* check sequence status flags for state revocation */
            if (try_recovery && seq->sr_resok4.sr_status_flags)
                nfs41_recover_sequence_flags(session,
                    seq->sr_resok4.sr_status_flags);
        }
    }
 
    if (status) {
        eprintf("nfs41_send_compound failed %d for seqid=%d, slotid=%d\n", 
            status, args->sa_sequenceid, args->sa_slotid);
        status = NFS4ERR_IO;
        goto out_free_slot;
    }
 
    if (compound->res.status != NFS4_OK)
        dprintf(1, "\n################ %s ################\n\n",
            nfs_error_string(compound->res.status));
 
    switch (compound->res.status) {
    case NFS4_OK:
        break;
 
    case NFS4ERR_STALE_CLIENTID:
        if (!try_recovery)
            goto out;
        if (!nfs41_recovery_start_or_wait(session->client))
            goto do_retry;
        // try to create a new client
        status = nfs41_client_renew(session->client);
 
        nfs41_recovery_finish(session->client);
        if (status) {
            eprintf("nfs41_client_renew() failed with %d\n", status);
            status = ERROR_BAD_NET_RESP;
            goto out;
        }
        if (op1 == OP_CREATE_SESSION) {
            nfs41_create_session_args *csa = (nfs41_create_session_args*)
                compound->args.argarray[0].arg;
            AcquireSRWLockShared(&session->client->exid_lock);
            csa->csa_clientid = session->client->clnt_id;
            csa->csa_sequence = session->client->seq_id;
            AcquireSRWLockShared(&session->client->exid_lock);
        }
        goto do_retry;
 
    case NFS4ERR_BADSESSION:
        if (!try_recovery)
            goto out;
        if (!nfs41_recovery_start_or_wait(session->client))
            goto do_retry;
        // try to create a new session
        status = nfs41_recover_session(session, FALSE);
 
        nfs41_recovery_finish(session->client);
        if (status) {
            eprintf("nfs41_recover_session() failed with %d\n", status);
            status = ERROR_BAD_NET_RESP;
            goto out;
        }
        goto do_retry;
 
    case NFS4ERR_EXPIRED: /* revoked by lease expiration */
    case NFS4ERR_BAD_STATEID:
    case NFS4ERR_STALE_STATEID: /* server reboot */
        if (op1 == OP_SEQUENCE)
            nfs41_session_free_slot(session, args->sa_slotid);
        if (try_recovery && nfs41_recover_stateid(session,
                &compound->args.argarray[compound->res.resarray_count-1]))
            goto do_retry;
        goto out;
 
    case NFS4ERR_BADSLOT:
        /* free the slot and retry with a new one */
        if (op1 != OP_SEQUENCE || nfs41_session_bad_slot(session, args))
            goto out;
        goto retry;
 
    case NFS4ERR_GRACE:
    case NFS4ERR_DELAY:
#define RETRY_INDEFINITELY
#ifndef RETRY_INDEFINITELY
#define NUMBER_2_RETRY 19
#endif
 
#ifndef RETRY_INDEFINITELY
        if (retry_count < NUMBER_2_RETRY) {
#endif
            if (op1 == OP_SEQUENCE)
                nfs41_session_free_slot(session, args->sa_slotid);
            if (compound->res.status == NFS4ERR_GRACE)
                delayby = 5000;
            else
                delayby = 500*retry_count;
            dprintf(1, "Compound returned %s: sleeping for %ums..\n", 
                (compound->res.status==NFS4ERR_GRACE)?"NFS4ERR_GRACE":"NFS4ERR_DELAY",
                delayby);
            Sleep(delayby);
            dprintf(1, "Attempting to resend compound.\n");
            goto do_retry;
#ifndef RETRY_INDEFINITELY
        }
#endif
        break;
 
    case NFS4ERR_FHEXPIRED: /* TODO: recover expired volatile filehandles */
        status = NFS4ERR_STALE; /* for now, treat them as ERR_STALE */
        /* no break */
    case NFS4ERR_STALE:
        {
            nfs_argop4 *argarray = compound->args.argarray;
            struct nfs41_name_cache *name_cache =
                session_name_cache(session);
            nfs41_putfh_args *putfh;
            uint32_t i, start = 0;
 
            /* NFS4ERR_STALE generally comes from a PUTFH operation. in
             * this case, remove its filehandle from the name cache. but
             * because COMPOUNDs are not atomic, a file can be removed
             * between PUTFH and the operation that uses it. in this
             * case, we can't tell which PUTFH operation is to blame, so
             * we must invalidate filehandles of all PUTFH operations in
             * the COMPOUND */
 
            if (argarray[compound->res.resarray_count-1].op == OP_PUTFH)
                start = compound->res.resarray_count-1;
 
            for (i = start; i < compound->res.resarray_count; i++) {
                if (argarray[i].op == OP_PUTFH) {
                    putfh = (nfs41_putfh_args*)argarray[i].arg;
 
                    if (!putfh->in_recovery && putfh->file->path)
                        nfs41_name_cache_remove_stale(name_cache,
                            session, putfh->file->path);
                }
            }
        }
        break;
    case NFS4ERR_WRONGSEC:
        {
            nfs41_secinfo_info secinfo[MAX_SECINFOS] = { 0 };
            uint32_t rcount = compound->res.resarray_count;
            nfs_argop4 *argarray = compound->args.argarray;
            uint32_t op = argarray[rcount-1].op;
            nfs41_putfh_args *putfh;
            nfs41_path_fh *file = NULL;
            switch(op) {
            case OP_PUTFH:
            case OP_RESTOREFH:
            case OP_LINK:
            case OP_RENAME:
            case OP_PUTROOTFH:
            case OP_LOOKUP:
            case OP_OPEN:
            case OP_SECINFO_NO_NAME:
            case OP_SECINFO:
                if (op1 == OP_SEQUENCE)
                    nfs41_session_free_slot(session, args->sa_slotid);
                /* from: 2.6.3.1.1.5.  Put Filehandle Operation + SECINFO/SECINFO_NO_NAME
                 * The NFSv4.1 server MUST NOT return NFS4ERR_WRONGSEC to a put
                 * filehandle operation that is immediately followed by SECINFO or
                 * SECINFO_NO_NAME.  The NFSv4.1 server MUST NOT return NFS4ERR_WRONGSEC
                 * from SECINFO or SECINFO_NO_NAME.
                 */
                if (op1 == OP_SEQUENCE &&
                        (argarray[1].op == OP_PUTFH || 
                        argarray[1].op == OP_PUTROOTFH) &&
                        (argarray[2].op == OP_SECINFO_NO_NAME ||
                        argarray[2].op == OP_SECINFO)) {
                    dprintf(1, "SECINFO: BROKEN SERVER\n");
                    goto out;
                }
                if (!try_recovery)
                    goto out;
                if (!nfs41_recovery_start_or_wait(session->client))
                    goto do_retry;
 
                saved_sec_flavor = session->client->rpc->sec_flavor;
                saved_auth = session->client->rpc->rpc->cl_auth;
                if (op == OP_LOOKUP || op == OP_OPEN) {
                    const nfs41_component *name;
                    nfs41_path_fh tmp = { 0 };                   
                    nfs41_getfh_res *getfh;
                    nfs41_lookup_args *largs;
                    nfs41_op_open_args *oargs;
                    if (argarray[rcount-2].op == OP_PUTFH) {
                        putfh = (nfs41_putfh_args *)argarray[rcount-2].arg;
                        file = putfh->file;
                    } else if (argarray[rcount-2].op == OP_GETATTR &&
                               argarray[rcount-3].op == OP_GETFH) {
                        getfh = (nfs41_getfh_res *)compound->res.resarray[rcount-3].res;
                        memcpy(&tmp.fh, getfh->fh, sizeof(nfs41_fh));
                        file = &tmp;
                    }
                    else {
                        nfs41_recovery_finish(session->client);
                        goto out;
                    }
 
                    if (op == OP_LOOKUP) {
                        largs = (nfs41_lookup_args *)argarray[rcount-1].arg;
                        name = largs->name;
                    } else if (op == OP_OPEN) {
                        oargs = (nfs41_op_open_args *)argarray[rcount-1].arg;
                        name = oargs->claim->u.null.filename;
                    }
                    secinfo_status = nfs41_secinfo(session, file, name, secinfo);
                    if (secinfo_status) {
                        eprintf("nfs41_secinfo failed with %d\n", secinfo_status);
                        nfs41_recovery_finish(session->client);
                        if (secinfo_status == NFS4ERR_BADSESSION) {
                            if (op1 == OP_SEQUENCE)
                                nfs41_session_free_slot(session, args->sa_slotid);
                            goto do_retry;
                        }
                        goto out_free_slot;
                    }
                }
                else {                    
                    if (op == OP_PUTFH) {
                        putfh = (nfs41_putfh_args *)argarray[rcount-1].arg;
                        file = putfh->file;
                    } 
                    secinfo_status = nfs41_secinfo_noname(session, file, secinfo);
                    if (secinfo_status) {
                        eprintf("nfs41_secinfo_noname failed with %d\n", 
                            secinfo_status);
                        nfs41_recovery_finish(session->client);
                        if (op1 == OP_SEQUENCE)
                            nfs41_session_free_slot(session, args->sa_slotid);
                        goto out_free_slot;
                    }
                }
                secinfo_status = create_new_rpc_auth(session, op, secinfo);
                if (!secinfo_status) {
                    auth_destroy(saved_auth);
                    nfs41_recovery_finish(session->client);
                    // Need to retry only 
                    goto do_retry;
                } else {
                    AcquireSRWLockExclusive(&session->client->rpc->lock);
                    session->client->rpc->sec_flavor = saved_sec_flavor;
                    session->client->rpc->rpc->cl_auth = saved_auth;
                    ReleaseSRWLockExclusive(&session->client->rpc->lock);
                    nfs41_recovery_finish(session->client);
                }                
                break;
            }
        }
    }
    if (compound->res.resarray[0].op == OP_SEQUENCE) {
        nfs41_sequence_res *seq = 
            (nfs41_sequence_res *)compound->res.resarray[0].res;
        if (seq->sr_status == NFS4_OK && session->client->rpc->needcb &&
                (seq->sr_resok4.sr_status_flags & SEQ4_STATUS_CB_PATH_DOWN)) {
            nfs41_session_free_slot(session, args->sa_slotid);
            nfs41_bind_conn_to_session(session->client->rpc,
                session->session_id, CDFC4_BACK_OR_BOTH);
            goto out;
        }
    }
out_free_slot:
    if (op1 == OP_SEQUENCE)
        nfs41_session_free_slot(session, args->sa_slotid);
out:
    return status;
 
do_retry:
    if (compound->res.resarray[0].op == OP_SEQUENCE)
        nfs41_session_get_slot(session, &args->sa_slotid,
            &args->sa_sequenceid, &args->sa_highest_slotid);
    goto retry;
}

Referenced by lookup_rpc(), nfs41_access(), nfs41_close(), nfs41_commit(), nfs41_create(), nfs41_create_session(), nfs41_delegpurge(), nfs41_delegreturn(), nfs41_destroy_session(), 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_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().

compound_error()

int compound_error

(

int

status

)

Definition at line 34 of file nfs41_compound.c.

{
    if (status != NFS4_OK)
        dprintf(1, "COMPOUND failed with status %d.\n", status);
    return status;
}

Referenced by lookup_rpc(), nfs41_access(), nfs41_bind_conn_to_session(), nfs41_close(), nfs41_commit(), nfs41_create(), nfs41_create_session(), nfs41_delegpurge(), nfs41_delegreturn(), nfs41_destroy_clientid(), nfs41_exchange_id(), 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_rpc_openattr(), nfs41_secinfo(), nfs41_secinfo_noname(), nfs41_send_sequence(), nfs41_setattr(), nfs41_test_stateid(), nfs41_unlock(), nfs41_want_delegation(), nfs41_write(), pnfs_rpc_getdeviceinfo(), pnfs_rpc_layoutcommit(), pnfs_rpc_layoutget(), and pnfs_rpc_layoutreturn().

compound_init()

void compound_init	(	nfs41_compound *	compound,
		nfs_argop4 *	argops,
		nfs_resop4 *	resops,
		const char *	tag
	)

Definition at line 41 of file nfs41_compound.c.

{
    /* initialize args */
    compound->args.tag_len = (uint32_t)strlen(tag);
    memcpy(compound->args.tag, tag, compound->args.tag_len);
    compound->args.minorversion = 1;
    compound->args.argarray_count = 0;
    compound->args.argarray = argops;
 
    /* initialize results */
    ZeroMemory(&compound->res, sizeof(nfs41_compound_res));
    compound->res.tag_len = NFS4_OPAQUE_LIMIT;
    compound->res.resarray_count = 0;
    compound->res.resarray = resops;
}

Referenced by lookup_rpc(), nfs41_access(), nfs41_bind_conn_to_session(), nfs41_close(), nfs41_commit(), nfs41_create(), nfs41_create_session(), nfs41_delegpurge(), nfs41_delegreturn(), nfs41_destroy_clientid(), nfs41_destroy_session(), nfs41_exchange_id(), 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_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().