nfs41: return correct errors on callback replays version 3
Subsystems (2)
cover nfs41: return correct errors on callback replays version 3
nfs41: return correct errors on callback replays version 3
Responded to Tronds comments, fixed bugs in cb_recall_slot, and resize slot table on session reset.
The first three patches clean up callback processing 0001-nfs41-fix-wrong-error-on-callback-header-xdr-overflo.patch 0002-nfs41-directly-encode-back-channel-error.patch 0003-nfs41-remove-uneeded-checks-in-callback-processing.patch
These next two implement correct error returns for v4.1 callback replays. Since our back channel has a ca_maxrequestsize_cached = 0, a replay with cachethis set to true results in a NFS4ERR_TOO_BIG_TO_CACHE error. This code is set up to do a real DRC.
A replay with cachethis set to false returns a NFS4ERR_RETRY_UNCACHED_REP error.
0004-nfs41-prepare-for-back-channel-drc.patch 0005-nfs41-back-channel-drc-minimal-implementation.patch
ADDED:
0006-nfs41-implement-cb_recall_slot.patch
The fore channel session is drained, then the new highest_slot is set.
0007-nfs41-resize-slot-table-in-reset.patch The slot table size is renegotiated on session reset.
TODO: The callback code currently returns NFS4ERR_RESOURCE on all xdr overflows. This is correct for v4.0, incorrect for v4.1.
Testing:
Modified nfsv4.1 pynfs server tested cb_recall replays with the cb_sequence cachethis set to False and to True.
Modified nfs4.1 pyNFS server sends CB_RECALL_SLOT call during the Connectathon basic big file test which uses all available slots.
Connectathon tests pass.
-->Andy
PATCH 1/7 nfs41: fix wrong error on callback header xdr overflow
From: Andy Adamson <[email protected]>
Set NFS4ERR_RESOURCE as CB_COMPOUND status and do not return an op on decode_op_hdr or encode_op_hdr buffer overflow.
NFS4ERR_RESOURCE is correct for v4.0. Will fix the return for v4.1 along with all the other NFS4ERR_RESOURCE errors in a later patch.
--- fs/nfs/callback_xdr.c | 28 ++++++++++++++++++---------- 1 files changed, 18 insertions(+), 10 deletions(-)
fs/nfs/callback_xdr.c +18 -10
@@ -28,6 +28,9 @@#define NFSDBG_FACILITY NFSDBG_CALLBACK +/* Internal error code */ +#define NFS4ERR_RESOURCE_HDR 11050 +typedef __be32 (*callback_process_op_t )(void *,void *);typedef __be32 (*callback_decode_arg_t )(struct svc_rqst *,struct xdr_stream *,void *);typedef __be32 (*callback_encode_res_t )(struct svc_rqst *,struct xdr_stream *,void *);
@@ -173,7 +176,7 @@ static __be32 decode_op_hdr(struct xdr_stream *xdr, unsigned int *op)__be32 *p; p =read_buf (xdr,4 );if (unlikely (p ==NULL )) -return htonl (NFS4ERR_RESOURCE ); +return htonl (NFS4ERR_RESOURCE_HDR ); *op =ntohl (*p);return 0 ; }
@@ -465,7 +468,7 @@ static __be32 encode_op_hdr(struct xdr_stream *xdr, uint32_t op, __be32 res) p =xdr_reserve_space (xdr,8 );if (unlikely (p ==NULL )) -return htonl (NFS4ERR_RESOURCE ); +return htonl (NFS4ERR_RESOURCE_HDR ); *p++ =htonl (op); *p = res;return 0 ;
@@ -605,17 +608,15 @@ static __be32 process_op(uint32_t minorversion, int nop, struct xdr_stream *xdr_out, void *resp) { struct callback_op *op = &callback_ops[0]; -unsigned int op_nr =OP_CB_ILLEGAL ; +unsigned int op_nr;__be32 status;long maxlen;__be32 res;dprintk ("%s: start\n" , __func__); status =decode_op_hdr (xdr_in, &op_nr); -if (unlikely (status)) { - status =htonl (NFS4ERR_OP_ILLEGAL ); - goto out; - } +if (unlikely (status)) +return status;dprintk ("%s: minorversion=%d nop=%d op_nr=%u\n" , __func__, minorversion, nop, op_nr);
@@ -624,7 +625,7 @@ static __be32 process_op(uint32_t minorversion, int nop,preprocess_nfs4_op (op_nr, &op);if (status ==htonl (NFS4ERR_OP_ILLEGAL )) op_nr =OP_CB_ILLEGAL ; -out: + maxlen = xdr_out->end - xdr_out->p;if (maxlen >0 && maxlen <PAGE_SIZE ) {if (likely (status ==0 && op->decode_args !=NULL ))
@@ -635,8 +636,8 @@ out: status =htonl (NFS4ERR_RESOURCE ); res =encode_op_hdr (xdr_out, op_nr, status); -if (status ==0 ) - status = res; +if (unlikely (res)) +return res;if (op->encode_res !=NULL && status ==0 ) status = op->encode_res (rqstp, xdr_out, resp);dprintk ("%s: done, status = %d\n" , __func__,ntohl (status));
@@ -677,6 +678,13 @@ static __be32 nfs4_callback_compound(struct svc_rqst *rqstp, void *argp, void *r nops++; } +/* Buffer overflow in decode_ops_hdr or encode_ops_hdr. Return +* resource error in cb_compound status without returning op */ +if (unlikely (status ==htonl (NFS4ERR_RESOURCE_HDR ))) { + status =htonl (NFS4ERR_RESOURCE ); + nops--; + } + *hdr_res.status = status; *hdr_res.nops =htonl (nops);dprintk ("%s: done, status = %u\n" , __func__,ntohl (status));
Signature · 1 line
1.6.5.2
PATCH 2/7 nfs41: directly encode back channel error
From: Andy Adamson <[email protected]>
Skip all other processing when error is encountered.
--- fs/nfs/callback_xdr.c | 5 ++++- 1 files changed, 4 insertions(+), 1 deletions(-)
fs/nfs/callback_xdr.c +4 -1
@@ -625,16 +625,19 @@ static __be32 process_op(uint32_t minorversion, int nop,preprocess_nfs4_op (op_nr, &op);if (status ==htonl (NFS4ERR_OP_ILLEGAL )) op_nr =OP_CB_ILLEGAL ; +if (status) + goto encode_hdr; maxlen = xdr_out->end - xdr_out->p;if (maxlen >0 && maxlen <PAGE_SIZE ) { -if (likely (status ==0 && op->decode_args !=NULL )) +if (likely (op->decode_args !=NULL )) status = op->decode_args (rqstp, xdr_in, argp);if (likely (status ==0 && op->process_op !=NULL )) status = op->process_op (argp, resp); }else status =htonl (NFS4ERR_RESOURCE ); +encode_hdr: res =encode_op_hdr (xdr_out, op_nr, status);if (unlikely (res))return res;
Signature · 1 line
1.6.5.2
PATCH 3/7 nfs41: remove uneeded checks in callback processing
From: Andy Adamson <[email protected]>
All callback operations have arguments to decode and require processing. The preprocess_nfs4X_op functions catch unsupported or illegal ops so decode_args and process_op pointers are always non NULL.
--- fs/nfs/callback_xdr.c | 5 ++--- 1 files changed, 2 insertions(+), 3 deletions(-)
fs/nfs/callback_xdr.c +2 -3
@@ -630,9 +630,8 @@ static __be32 process_op(uint32_t minorversion, int nop, maxlen = xdr_out->end - xdr_out->p;if (maxlen >0 && maxlen <PAGE_SIZE ) { -if (likely (op->decode_args !=NULL )) - status = op->decode_args (rqstp, xdr_in, argp); -if (likely (status ==0 && op->process_op !=NULL )) + status = op->decode_args (rqstp, xdr_in, argp); +if (likely (status ==0 )) status = op->process_op (argp, resp); }else status =htonl (NFS4ERR_RESOURCE );
Signature · 1 line
1.6.5.2
PATCH 4/7 nfs41: prepare for back channel drc
From: Andy Adamson <[email protected]>
Make all cb_sequence arguments available to verify_seqid which will make replay decisions.
--- fs/nfs/callback_proc.c | 19 +++++++++---------- 1 files changed, 9 insertions(+), 10 deletions(-)
fs/nfs/callback_proc.c +9 -10
@@ -153,34 +153,34 @@ int nfs41_validate_delegation_stateid(struct nfs_delegation *delegation, const n* a single outstanding callback request at a time. */ static int -validate_seqid (struct nfs4_slot_table *tbl,u32 slotid,u32 seqid) +validate_seqid (struct nfs4_slot_table *tbl,struct cb_sequenceargs * args) {struct nfs4_slot *slot;dprintk ("%s enter. slotid %d seqid %d\n" , - __func__, slotid, seqid); + __func__, args->csa_slotid, args->csa_sequenceid); -if (slotid >NFS41_BC_MAX_CALLBACKS ) +if (args->csa_slotid >NFS41_BC_MAX_CALLBACKS )return htonl (NFS4ERR_BADSLOT ); - slot = tbl->slots + slotid; + slot = tbl->slots + args->csa_slotid;dprintk ("%s slot table seqid: %d\n" , __func__, slot->seq_nr);/* Normal */ -if (likely (seqid == slot->seq_nr +1 )) { +if (likely (args->csa_sequenceid == slot->seq_nr +1 )) { slot->seq_nr++;return htonl (NFS4_OK ); }/* Replay */ -if (seqid == slot->seq_nr) { +if (args->csa_sequenceid == slot->seq_nr) {dprintk ("%s seqid %d is a replay - no DRC available\n" , - __func__, seqid); + __func__, args->csa_sequenceid);return htonl (NFS4_OK ); }/* Wraparound */ -if (seqid ==1 && (slot->seq_nr +1 ) ==0 ) { +if (args->csa_sequenceid ==1 && (slot->seq_nr +1 ) ==0 ) { slot->seq_nr =1 ;return htonl (NFS4_OK ); }
@@ -241,8 +241,7 @@ unsigned nfs4_callback_sequence(struct cb_sequenceargs *args,if (clp ==NULL ) goto out; - status =validate_seqid (&clp->cl_session->bc_slot_table, - args->csa_slotid, args->csa_sequenceid); + status =validate_seqid (&clp->cl_session->bc_slot_table, args);if (status) goto out_putclient;
Signature · 1 line
1.6.5.2
PATCH 5/7 nfs41: back channel drc minimal implementation
From: Andy Adamson <[email protected]>
For now the back channel ca_maxresponsesize_cached is 0 and there is no backchannel DRC. Return NFS4ERR_REP_TOO_BIG_TO_CACHE when a cb_sequence cachethis is true. When it is false, return NFS4ERR_RETRY_UNCACHED_REP as the next operation error.
Remember the replay error accross compound operation processing.
--- fs/nfs/callback_proc.c | 25 +++++++++++++++++-------- fs/nfs/callback_xdr.c | 19 +++++++++++++++---- 2 files changed, 32 insertions(+), 12 deletions(-)
fs/nfs/callback_proc.c +17 -8
@@ -143,9 +143,8 @@ int nfs41_validate_delegation_stateid(struct nfs_delegation *delegation, const n* Return success if the sequenceID is one more than what we last saw on * this slot, accounting for wraparound. Increments the slot's sequence. * -* We don't yet implement a duplicate request cache, so at this time -* we will log replays, and process them as if we had not seen them before, -* but we don't bump the sequence in the slot. Not too worried about it, +* We don't yet implement a duplicate request cache, instead we set the +* back channel ca_maxresponsesize_cached to zero. This is OK for now * since we only currently implement idempotent callbacks anyway. * * We have a single slot backchannel at this time, so we don't bother
@@ -174,9 +173,15 @@ validate_seqid(struct nfs4_slot_table *tbl, struct cb_sequenceargs * args)/* Replay */ if (args->csa_sequenceid == slot->seq_nr) { -dprintk ("%s seqid %d is a replay - no DRC available\n" , +dprintk ("%s seqid %d is a replay\n" , __func__, args->csa_sequenceid); -return htonl (NFS4_OK ); +/* Signal process_op to set this error on next op */ +if (args->csa_cachethis ==0 ) +return htonl (NFS4ERR_RETRY_UNCACHED_REP ); + +/* The ca_maxresponsesize_cached is 0 with no DRC */ +else if (args->csa_cachethis ==1 ) +return htonl (NFS4ERR_REP_TOO_BIG_TO_CACHE ); }/* Wraparound */
@@ -255,9 +260,13 @@ unsigned nfs4_callback_sequence(struct cb_sequenceargs *args, out_putclient:nfs_put_client (clp); out: -dprintk ("%s: exit with status = %d\n" , __func__,ntohl (status)); - res->csr_status = status; -return res->csr_status; +if (status ==htonl (NFS4ERR_RETRY_UNCACHED_REP )) + res->csr_status =0 ; +else + res->csr_status = status; +dprintk ("%s: exit with status = %d res->csr_status %d\n" , __func__, +ntohl (status),ntohl (res->csr_status)); +return status; }unsigned nfs4_callback_recallany (struct cb_recallanyargs *args,void *dummy)
fs/nfs/callback_xdr.c +15 -4
@@ -605,7 +605,7 @@ preprocess_nfs4_op(unsigned int op_nr, struct callback_op **op)static __be32 process_op (uint32_t minorversion,int nop,struct svc_rqst *rqstp,struct xdr_stream *xdr_in,void *argp, -struct xdr_stream *xdr_out,void *resp) +struct xdr_stream *xdr_out,void *resp,int * drc_status) {struct callback_op *op = &callback_ops[0 ];unsigned int op_nr;
@@ -628,6 +628,11 @@ static __be32 process_op(uint32_t minorversion, int nop,if (status) goto encode_hdr; +if (*drc_status) { + status = *drc_status; + goto encode_hdr; + } + maxlen = xdr_out->end - xdr_out->p;if (maxlen >0 && maxlen <PAGE_SIZE ) { status = op->decode_args (rqstp, xdr_in, argp);
@@ -636,6 +641,12 @@ static __be32 process_op(uint32_t minorversion, int nop, }else status =htonl (NFS4ERR_RESOURCE ); +/* Only set by OP_CB_SEQUENCE processing */ +if (status ==htonl (NFS4ERR_RETRY_UNCACHED_REP )) { + *drc_status = status; + status =0 ; + } + encode_hdr: res =encode_op_hdr (xdr_out, op_nr, status);if (unlikely (res))
@@ -655,7 +666,7 @@ static __be32 nfs4_callback_compound(struct svc_rqst *rqstp, void *argp, void *rstruct cb_compound_hdr_res hdr_res = {NULL };struct xdr_stream xdr_in, xdr_out;__be32 *p; -__be32 status; +__be32 status, drc_status =0 ;unsigned int nops =0 ;dprintk ("%s: start\n" , __func__);
@@ -675,8 +686,8 @@ static __be32 nfs4_callback_compound(struct svc_rqst *rqstp, void *argp, void *rreturn rpc_system_err;while (status ==0 && nops != hdr_arg.nops) { - status =process_op (hdr_arg.minorversion, nops, - rqstp, &xdr_in, argp, &xdr_out, resp); + status =process_op (hdr_arg.minorversion, nops, rqstp, + &xdr_in, argp, &xdr_out, resp, &drc_status); nops++; }
Signature · 1 line
1.6.5.2
PATCH 6/7 nfs41: implement cb_recall_slot
From: Andy Adamson <[email protected]>
Drain the fore channel and reset the max_slots to the new value.
--- fs/nfs/callback.h | 8 ++++++++ fs/nfs/callback_proc.c | 32 ++++++++++++++++++++++++++++++++ fs/nfs/callback_xdr.c | 22 +++++++++++++++++++++- fs/nfs/nfs4_fs.h | 2 ++ fs/nfs/nfs4state.c | 43 +++++++++++++++++++++++++++++++++++++++++++ include/linux/nfs_fs_sb.h | 2 ++ 6 files changed, 108 insertions(+), 1 deletions(-)
fs/nfs/callback.h +8 -0
@@ -119,6 +119,14 @@ struct cb_recallanyargs { };extern unsigned nfs4_callback_recallany (struct cb_recallanyargs *args,void *dummy); + +struct cb_recallslotargs { +struct sockaddr *crsa_addr; +uint32_t crsa_target_max_slots; +}; +extern unsigned nfs4_callback_recallslot (struct cb_recallslotargs *args, +void *dummy); +#endif /* CONFIG_NFS_V4_1 */ extern __be32 nfs4_callback_getattr (struct cb_getattrargs *args,struct cb_getattrres *res);
fs/nfs/callback_proc.c +32 -0
@@ -297,4 +297,36 @@ out:dprintk ("%s: exit with status = %d\n" , __func__,ntohl (status)); return status; } + +/* Reduce the fore channel's max_slots to the target value */ +unsigned nfs4_callback_recallslot (struct cb_recallslotargs *args,void *dummy) +{ +struct nfs_client *clp; +struct nfs4_slot_table *fc_tbl; +int status; + + status =htonl (NFS4ERR_OP_NOT_IN_SESSION ); + clp =nfs_find_client (args->crsa_addr,4 ); +if (clp ==NULL ) + goto out; + +dprintk ("NFS: CB_RECALL_SLOT request from %s target max slots %d\n" , +rpc_peeraddr2str (clp->cl_rpcclient,RPC_DISPLAY_ADDR ), + args->crsa_target_max_slots); + + fc_tbl = &clp->cl_session->fc_slot_table; + + status =htonl (NFS4ERR_BAD_HIGH_SLOT ); +if (args->crsa_target_max_slots >= fc_tbl->max_slots || + args->crsa_target_max_slots <1 ) + goto out; + + fc_tbl->target_max_slots = args->crsa_target_max_slots; +nfs41_handle_recall_slot (clp); + status =htonl (NFS4_OK ); +nfs_put_client (clp);/* balance nfs_find_client */ +out: +dprintk ("%s: exit with status = %d\n" , __func__,ntohl (status)); +return status; +}#endif /* CONFIG_NFS_V4_1 */
fs/nfs/callback_xdr.c +21 -1
@@ -24,6 +24,7 @@#define CB_OP_SEQUENCE_RES_MAXSZ (CB_OP_HDR_RES_MAXSZ + \ 4 + 1 + 3)#define CB_OP_RECALLANY_RES_MAXSZ (CB_OP_HDR_RES_MAXSZ) +#define CB_OP_RECALLSLOT_RES_MAXSZ (CB_OP_HDR_RES_MAXSZ)#endif /* CONFIG_NFS_V4_1 */ #define NFSDBG_FACILITY NFSDBG_CALLBACK
@@ -349,6 +350,20 @@ static unsigned decode_recallany_args(struct svc_rqst *rqstp, return 0; } +static unsigned decode_recallslot_args (struct svc_rqst *rqstp, +struct xdr_stream *xdr, +struct cb_recallslotargs *args) +{ +__be32 *p; + + args->crsa_addr =svc_addr (rqstp); + p =read_buf (xdr,4 ); +if (unlikely (p ==NULL )) +return htonl (NFS4ERR_BADXDR ); + args->crsa_target_max_slots =ntohl (*p++); +return 0 ; +} +#endif /* CONFIG_NFS_V4_1 */ static __be32 encode_string (struct xdr_stream *xdr,unsigned int len,const char *str)
@@ -557,6 +572,7 @@ preprocess_nfs41_op(int nop, unsigned int op_nr, struct callback_op **op)case OP_CB_RECALL :case OP_CB_SEQUENCE :case OP_CB_RECALL_ANY : +case OP_CB_RECALL_SLOT : *op = &callback_ops[op_nr];break ;
@@ -565,7 +581,6 @@ preprocess_nfs41_op(int nop, unsigned int op_nr, struct callback_op **op)case OP_CB_NOTIFY :case OP_CB_PUSH_DELEG :case OP_CB_RECALLABLE_OBJ_AVAIL : -case OP_CB_RECALL_SLOT :case OP_CB_WANTS_CANCELLED :case OP_CB_NOTIFY_LOCK :return htonl (NFS4ERR_NOTSUPP );
@@ -734,6 +749,11 @@ static struct callback_op callback_ops[] = { .decode_args = (callback_decode_arg_t)decode_recallany_args, .res_maxsize = CB_OP_RECALLANY_RES_MAXSZ, }, + [OP_CB_RECALL_SLOT] = { + .process_op = (callback_process_op_t)nfs4_callback_recallslot, + .decode_args = (callback_decode_arg_t)decode_recallslot_args, + .res_maxsize = CB_OP_RECALLSLOT_RES_MAXSZ, + },#endif /* CONFIG_NFS_V4_1 */ };
fs/nfs/nfs4_fs.h +2 -0
@@ -46,6 +46,7 @@ enum nfs4_client_state {NFS4CLNT_DELEGRETURN ,NFS4CLNT_SESSION_RESET ,NFS4CLNT_SESSION_DRAINING , + NFS4CLNT_RECALL_SLOT, };/*
@@ -278,6 +279,7 @@ extern void nfs4_schedule_state_recovery(struct nfs_client *);extern void nfs4_schedule_state_manager (struct nfs_client *);extern int nfs4_state_mark_reclaim_nograce (struct nfs_client *clp,struct nfs4_state *state);extern void nfs41_handle_sequence_flag_errors (struct nfs_client *clp,u32 flags); +extern void nfs41_handle_recall_slot (struct nfs_client *clp);extern void nfs4_put_lock_state (struct nfs4_lock_state *lsp);extern int nfs4_set_lock_state (struct nfs4_state *state,struct file_lock *fl);extern void nfs4_copy_stateid (nfs4_stateid *,struct nfs4_state *,fl_owner_t );
fs/nfs/nfs4state.c +43 -0
61 lines not on this page · raw message
include/linux/nfs_fs_sb.h +2 -0
@@ -193,6 +193,8 @@ struct nfs4_slot_table {int max_slots;/* # slots in table */ int highest_used_slotid;/* sent to server on each SEQ. * op for dynamic resizing */ +int target_max_slots;/* Set by CB_RECALL_SLOT as +* the new max_slots */ };static inline int slot_idx (struct nfs4_slot_table *tbl,struct nfs4_slot *sp)
Signature · 1 line
1.6.5.2
PATCH 7/7 nfs41: resize slot table in reset
From: Andy Adamson <[email protected]>
When session is reset, client can renegotiate slot table size.
--- fs/nfs/nfs4proc.c | 40 +++++++++++++++++++++------------------- 1 files changed, 21 insertions(+), 19 deletions(-)
fs/nfs/nfs4proc.c +21 -19
@@ -4573,26 +4573,32 @@ int nfs4_proc_get_lease_time(struct nfs_client *clp, struct nfs_fsinfo *fsinfo)/* * Reset a slot table */ -static int nfs4_reset_slot_table (struct nfs4_slot_table *tbl,int max_slots, -int old_max_slots,int ivalue) +static int nfs4_reset_slot_table (struct nfs4_slot_table *tbl,u32 max_reqs, +int ivalue) { +struct nfs4_slot *new =NULL ;int i;int ret =0 ; -dprintk ("--> %s: max_reqs=%u, tbl %p\n" , __func__, max_slots, tbl); +dprintk ("--> %s: max_reqs=%u, tbl->max_slots %d\n" , __func__, + max_reqs, tbl->max_slots); -/* -* Until we have dynamic slot table adjustment, insist -* upon the same slot table size -*/ -if (max_slots != old_max_slots) { -dprintk ("%s reset slot table does't match old\n" , - __func__); - ret = -EINVAL ;/*XXX NFS4ERR_REQ_TOO_BIG ? */ - goto out; +/* Does the newly negotiated max_reqs match the existing slot table? */ +if (max_reqs != tbl->max_slots) { + ret = -ENOMEM ; + new =kmalloc (max_reqs *sizeof (struct nfs4_slot ), +GFP_KERNEL ); +if (!new) + goto out; + ret =0 ; +kfree (tbl->slots); }spin_lock (&tbl->slot_tbl_lock); -for (i =0 ; i < max_slots; ++i) +if (new) { + tbl->slots = new; + tbl->max_slots = max_reqs; + } +for (i =0 ; i < tbl->max_slots; ++i) tbl->slots[i].seq_nr = ivalue;spin_unlock (&tbl->slot_tbl_lock); dprintk("%s: tbl=%p slots=%p max_slots=%d\n", __func__,
@@ -4610,16 +4616,12 @@ static int nfs4_reset_slot_tables(struct nfs4_session *session)int status; status =nfs4_reset_slot_table (&session->fc_slot_table, - session->fc_attrs.max_reqs, - session->fc_slot_table.max_slots, -1 ); + session->fc_attrs.max_reqs,1 );if (status)return status; status =nfs4_reset_slot_table (&session->bc_slot_table, - session->bc_attrs.max_reqs, - session->bc_slot_table.max_slots, -0 ); + session->bc_attrs.max_reqs,0 );return status; }
Signature · 1 line
1.6.5.2
Re: [PATCH 6/7] nfs41: implement cb_recall_slot
In reply to [email protected]On Thu, 2010-01-14 at 17:45 -0500, [email protected] wrote:=20
Quoted 11 lines
From: Andy Adamson <[email protected]>
=20
Drain the fore channel and reset themax_slotsto the new value. =20Signed-off-by Andy Adamson <[email protected]>--- fs/nfs/callback.h | 8 ++++++++ fs/nfs/callback_proc.c | 32 ++++++++++++++++++++++++++++++++ fs/nfs/callback_xdr.c | 22 +++++++++++++++++++++- fs/nfs/nfs4_fs.h | 2 ++
fs/nfs/nfs4state.c| 43 +++++++++++++++++++++++++++++++++++=
++++++++
Quoted 2 lines
include/linux/nfs_fs_sb.h | 2 ++ 6 files changed, 108 insertions(+), 1 deletions(-)
CC [M] fs/nfs/nfs4state.o/home/trondmy/devel/linux/linux_nfs-2.6/fs/nfs/nfs4state.c: In function =E2=80=98nfs4_state_manager=E2=80=99:/home/trondmy/devel/linux/linux_nfs-2.6/fs/nfs/nfs4state.c:1437: error:
implicit declaration of function =E2=80=98nfs4_recall_slot=E2=80=99 make[2]: *** [fs/nfs/nfs4state.o] Error 1
make[1]: *** [fs/nfs/nfs4state.o] Error 2
make: *** [sub-make] Error 2
Does not compile without CONFIG_NFS_V4_1
Trond