nfs41 client patch for 2.6.30
Subsystems (3)
v2 cover nfs41 client patch for 2.6.30
Trond,
I've integrated the latest client patches from Andy (with a few minor changes listed below) and updatedgit://linux-nfs.org/~bhalevy/linux-pnfs.git
branches:
nfs41-for-next nfs41-for-2.6.30 nfs41
nfs41-for-{next,2.6.30} contain all non-backchannel patches rebased onto {v2.6.29,nfs-2.6/for-next} respectively.
nfs41 contains the backchannel patches on top of nfs41-for-2.6.30.
changes since v1:
- fixed bisectability issues
- got rid of rpc_clnt.cl_private, use *session in seq args/res instead
- remove ifdefs around nfs_client_initdata.minorversion
- use kcalloc to allocate slot table
- alloc session with GFP_KERNEL
- moved nfs4_init_slot_table's definition from "sessions client infrastructure" to first usage, in "create_session operations".
- embed resp_len in nfs_getaclres
- moved new xdr op args/res definitions away from "client xdr definitions", to where they're first used.
- move find_slot and free_slot closer to where they're first used.
- Revert "NFS: fix decode_fs_locations_maxsz"
- nfs41: get fs_locations replen before encoding the GETATTR
- nfs41: get getacl replen before encoding the GETATTR
(changes from Andy's set)
- getaclres moved into right patch
- dropped "nfs41: stubs for nfs41 procedures"
- edited create_session, destroy_session, session setup, and session_reset for proc_{create,destroy}_session interface.
- reverse EXCHGID4_INVAL_FLAG_MASK_{A,R}
Here's the list of patches:
[PATCH v2 01/67] nfs41: common protocol definitions
[PATCH v2 02/67] nfs41: Add Kconfig symbols for NFSv4.1
[PATCH v2 03/67] nfs41: define NFS4_MAX_MINOR_VERSION based on CONFIG_NFS_V4_1 [PATCH v2 04/67] nfs41: add mount command option minorversion
[PATCH v2 05/67] nfs41: nfs_client.cl_minorversion
[PATCH v2 06/67] nfs41: Use mount minorversion option
[PATCH v2 07/67] nfs41: translate NFS4ERR_MINOR_VERS_MISMATCH to EPROTONOSUPPORT [PATCH v2 08/67] nfs41: client xdr definitions
[PATCH v2 09/67] nfs41: sessions client infrastructure
[PATCH v2 10/67] nfs41: use nfs4_server_caps_arg
[PATCH v2 11/67] nfs41: use nfs4_readlink_res
[PATCH v2 12/67] nfs41: use nfs4_statfs_res
[PATCH v2 13/67] nfs41: use nfs4_fsinfo_res
[PATCH v2 14/67] nfs41: use nfs4_pathconf_res
[PATCH v2 15/67] nfs41: use nfs4_getaclres
[PATCH v2 16/67] NFS: get rid of unused xdr decode_setattr(, res) argument [PATCH v2 17/67] nfs41: use nfs4_setaclres
[PATCH v2 18/67] nfs41: use nfs4_fs_locations_res
[PATCH v2 19/67] nfs41: introduce nfs4_call_sync
[PATCH v2 20/67] nfs41: nfs41: pass *session in seq_args and seq_res
[PATCH v2 21/67] nfs41: set up seq_res.sr_slotid
[PATCH v2 22/67] NFS: use decode_change_info_maxsz for xdr maxsz calculations [PATCH v2 23/67] NFS: define and initialize compound_hdr.replen
[PATCH v2 24/67] NFS: update hdr->replen for every encode op
[PATCH v2 25/67] NFS: use dynamically computed compound_hdr.replen for xdr_inline_pages offset [PATCH v2 26/67] nfs41: encode minorversion in compound header
[PATCH v2 27/67] nfs41: xdr {encode,decode}_sequence
[PATCH v2 28/67] nfs41: nfs4_setup_sequence
[PATCH v2 29/67] nfs41: find slot
[PATCH v2 30/67] nfs41: setup_sequence method
[PATCH v2 31/67] nfs41: free slot
[PATCH v2 32/67] nfs41: nfs41_sequence_free_slot
[PATCH v2 33/67] nfs41: nfs41_sequence_done
[PATCH v2 34/67] nfs41: nfs41_call_sync_done
[PATCH v2 35/67] nfs41: close sequence setup/done support
[PATCH v2 36/67] nfs41: open sequence setup/done support
[PATCH v2 37/67] nfs41: lock sequence setup/done support
[PATCH v2 38/67] nfs41: locku sequence setup/done support
[PATCH v2 39/67] nfs41: unlink sequence setup/done support
[PATCH v2 40/67] nfs41: read sequence setup/done support
[PATCH v2 41/67] nfs41 write sequence setup done support
[PATCH v2 42/67] nfs41 commit sequence setup done support
[PATCH v2 43/67] nfs41 delegreturn sequence setup done support
[PATCH v2 44/67] nfs41: exchange_id operation
[PATCH v2 45/67] nfs41: get_lease_time
[PATCH v2 46/67] nfs41: create_session operation
[PATCH v2 47/67] nfs41: verify session channel attribues
[PATCH v2 48/67] nfs41: use session attributes for rsize and wsize
[PATCH v2 49/67] nfs41: destroy_session operation
[PATCH v2 50/67] nfs41: enable nfs_client only nfs4_async_handle_error
[PATCH v2 51/67] nfs41: sequence operation
[PATCH v2 52/67] nfs41: reset the session slot table
[PATCH v2 53/67] nfs41: add session setup to the state manager
[PATCH v2 54/67] nfs41: add session reset to state manager
[PATCH v2 55/67] nfs41: sunrpc: Export the call prepare state for session reset [PATCH v2 56/67] nfs41: use rpc prepare call state for session reset
[PATCH v2 57/67] nfs41: kick start nfs41 session recovery when handling errors [PATCH v2 58/67] nfs41: schedule async session reset
[PATCH v2 59/67] nfs41: lease renewal
[PATCH v2 60/67] nfs41: support minorversion 1 for nfs4_check_lease
[PATCH v2 61/67] nfs41: introduce get_state_renewal_cred
[PATCH v2 62/67] nfs41: establish sessions-based clientid
[PATCH v2 63/67] nfs41: add a get_clid_cred function to nfs4_state_recovery_ops [PATCH v2 64/67] nfs41: get_clid_cred for EXCHANGE_ID
[PATCH v2 65/67] nfs41: recover lease in _nfs4_lookup_root
[PATCH v2 66/67] nfs41: fail mount on EXCHANGE_ID, CREATE_SESSION failure [PATCH v2 67/67] nfs41: increment_{open,lock}_seqid
Quoted 31 lines · Benny Halevy
Trond,
I've integrated the latest client patches from Andy (with a few minor changes listed below) and updated
git://linux-nfs.org/~bhalevy/linux-pnfs.git
branches:nfs41-for-next nfs41-for-2.6.30 nfs41nfs41-for-{next,2.6.30} contain all non-backchannel patches rebased onto {v2.6.29,nfs-2.6/for-next} respectively.
nfs41 contains the backchannel patches on top of nfs41-for-2.6.30.
changes since v1:
- fixed bisectability issues
- got rid of rpc_clnt.cl_private, use *session in seq args/res instead
- remove ifdefs around nfs_client_initdata.minorversion
- use kcalloc to allocate slot table
- alloc session withGFP_KERNEL
- moved nfs4_init_slot_table's definition from "sessions client infrastructure" to first usage, in "create_sessionoperations".
- embedresp_leninnfs_getaclres
- moved new xdr op args/res definitions away from "client xdr definitions", to where they're first used.
- movefind_slotandfree_slotcloser to where they're first used.
- Revert "NFS: fixdecode_fs_locations_maxsz"
- nfs41: getfs_locationsreplen before encoding the GETATTR
- nfs41: get getacl replen before encoding the GETATTR
Quoted 8 lines
(changes from Andy's set)
- getaclres moved into right patch
- dropped "nfs41: stubs for nfs41 procedures"
- editedcreate_session,destroy_session, session setup, andsession_resetfor proc_{create,destroy}_session interface.
- reverse EXCHGID4_INVAL_FLAG_MASK_{A,R}Here's the list of patches:
The patches are based off of nfs-2.6/for-next
for your convenience.
Benny
Quoted 72 lines
[PATCH v2 01/67] nfs41: common protocol definitions
[PATCH v2 02/67] nfs41: AddKconfigsymbols for NFSv4.1
[PATCH v2 03/67] nfs41: defineNFS4_MAX_MINOR_VERSIONbased onCONFIG_NFS_V4_1[PATCH v2 04/67] nfs41: add mount command option minorversion
[PATCH v2 05/67] nfs41: nfs_client.cl_minorversion
[PATCH v2 06/67] nfs41: Use mount minorversion option
[PATCH v2 07/67] nfs41: translateNFS4ERR_MINOR_VERS_MISMATCHto EPROTONOSUPPORT [PATCH v2 08/67] nfs41: client xdr definitions
[PATCH v2 09/67] nfs41: sessions client infrastructure
[PATCH v2 10/67] nfs41: usenfs4_server_caps_arg
[PATCH v2 11/67] nfs41: usenfs4_readlink_res
[PATCH v2 12/67] nfs41: usenfs4_statfs_res
[PATCH v2 13/67] nfs41: usenfs4_fsinfo_res
[PATCH v2 14/67] nfs41: usenfs4_pathconf_res
[PATCH v2 15/67] nfs41: usenfs4_getaclres
[PATCH v2 16/67] NFS: get rid of unused xdrdecode_setattr(, res)argument [PATCH v2 17/67] nfs41: usenfs4_setaclres
[PATCH v2 18/67] nfs41: usenfs4_fs_locations_res
[PATCH v2 19/67] nfs41: introducenfs4_call_sync
[PATCH v2 20/67] nfs41: nfs41: pass *session inseq_argsandseq_res
[PATCH v2 21/67] nfs41: set up seq_res.sr_slotid
[PATCH v2 22/67] NFS: usedecode_change_info_maxszfor xdr maxsz calculations [PATCH v2 23/67] NFS: define and initialize compound_hdr.replen
[PATCH v2 24/67] NFS: updatehdr->replenfor every encode op
[PATCH v2 25/67] NFS: use dynamically computed compound_hdr.replen forxdr_inline_pagesoffset [PATCH v2 26/67] nfs41: encode minorversion in compound header
[PATCH v2 27/67] nfs41: xdr {encode,decode}_sequence
[PATCH v2 28/67] nfs41:nfs4_setup_sequence
[PATCH v2 29/67] nfs41: find slot
[PATCH v2 30/67] nfs41:setup_sequencemethod
[PATCH v2 31/67] nfs41: free slot
[PATCH v2 32/67] nfs41:nfs41_sequence_free_slot
[PATCH v2 33/67] nfs41:nfs41_sequence_done
[PATCH v2 34/67] nfs41:nfs41_call_sync_done
[PATCH v2 35/67] nfs41: close sequence setup/done support
[PATCH v2 36/67] nfs41: open sequence setup/done support
[PATCH v2 37/67] nfs41: lock sequence setup/done support
[PATCH v2 38/67] nfs41: locku sequence setup/done support
[PATCH v2 39/67] nfs41: unlink sequence setup/done support
[PATCH v2 40/67] nfs41: read sequence setup/done support
[PATCH v2 41/67] nfs41 write sequence setup done support
[PATCH v2 42/67] nfs41 commit sequence setup done support
[PATCH v2 43/67] nfs41 delegreturn sequence setup done support
[PATCH v2 44/67] nfs41:exchange_idoperation
[PATCH v2 45/67] nfs41:get_lease_time
[PATCH v2 46/67] nfs41:create_sessionoperation
[PATCH v2 47/67] nfs41: verify session channel attribues
[PATCH v2 48/67] nfs41: use session attributes for rsize and wsize
[PATCH v2 49/67] nfs41:destroy_sessionoperation
[PATCH v2 50/67] nfs41: enablenfs_clientonlynfs4_async_handle_error
[PATCH v2 51/67] nfs41: sequence operation
[PATCH v2 52/67] nfs41: reset the session slot table
[PATCH v2 53/67] nfs41: add session setup to the state manager
[PATCH v2 54/67] nfs41: add session reset to state manager
[PATCH v2 55/67] nfs41: sunrpc: Export the call prepare state for session reset [PATCH v2 56/67] nfs41: use rpc prepare call state for session reset
[PATCH v2 57/67] nfs41: kick start nfs41 session recovery when handling errors [PATCH v2 58/67] nfs41: schedule async session reset
[PATCH v2 59/67] nfs41: lease renewal
[PATCH v2 60/67] nfs41: support minorversion 1 fornfs4_check_lease
[PATCH v2 61/67] nfs41: introduceget_state_renewal_cred
[PATCH v2 62/67] nfs41: establish sessions-based clientid
[PATCH v2 63/67] nfs41: add aget_clid_credfunction tonfs4_state_recovery_ops[PATCH v2 64/67] nfs41:get_clid_credforEXCHANGE_ID
[PATCH v2 65/67] nfs41: recover lease in_nfs4_lookup_root
[PATCH v2 66/67] nfs41: fail mount onEXCHANGE_ID,CREATE_SESSIONfailure [PATCH v2 67/67] nfs41: increment_{open,lock}_seqid
_______________________________________________
pNFS mailing list
[email protected]
http://linux-nfs.org/cgi-bin/mailman/listinfo/pnfs
PATCH v2 1/67 nfs41: common protocol definitions
In reply to Benny HalevyDefine all NFSv4.1 common operation and error code constants.
Note that some of the definitions are used by both the nfs41 client and the server code. This patch is duplicated in the nfs41 and nfsd41 sessions patchset.
--- include/linux/nfs4.h | 128 +++++++++++++++++++++++++++++++++++++++++++++++++- 1 files changed, 127 insertions(+), 1 deletions(-)
include/linux/nfs4.h +127 -1
@@ -21,6 +21,7 @@#define NFS4_FHSIZE 128#define NFS4_MAXPATHLEN PATH_MAX#define NFS4_MAXNAMLEN NAME_MAX +#define NFS4_MAX_SESSIONID_LEN 16#define NFS4_ACCESS_READ 0x0001#define NFS4_ACCESS_LOOKUP 0x0002
@@ -38,6 +39,7 @@#define NFS4_OPEN_RESULT_CONFIRM 0x0002#define NFS4_OPEN_RESULT_LOCKTYPE_POSIX 0x0004 +#define NFS4_SHARE_ACCESS_MASK 0x000F#define NFS4_SHARE_ACCESS_READ 0x0001#define NFS4_SHARE_ACCESS_WRITE 0x0002#define NFS4_SHARE_ACCESS_BOTH 0x0003
@@ -45,6 +47,19 @@#define NFS4_SHARE_DENY_WRITE 0x0002#define NFS4_SHARE_DENY_BOTH 0x0003 +/* nfs41 */ +#define NFS4_SHARE_WANT_MASK 0xFF00 +#define NFS4_SHARE_WANT_NO_PREFERENCE 0x0000 +#define NFS4_SHARE_WANT_READ_DELEG 0x0100 +#define NFS4_SHARE_WANT_WRITE_DELEG 0x0200 +#define NFS4_SHARE_WANT_ANY_DELEG 0x0300 +#define NFS4_SHARE_WANT_NO_DELEG 0x0400 +#define NFS4_SHARE_WANT_CANCEL 0x0500 + +#define NFS4_SHARE_WHEN_MASK 0xF0000 +#define NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL 0x10000 +#define NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED 0x20000 +#define NFS4_SET_TO_SERVER_TIME 0#define NFS4_SET_TO_CLIENT_TIME 1
@@ -88,6 +103,31 @@#define NFS4_ACE_GENERIC_EXECUTE 0x001200A0#define NFS4_ACE_MASK_ALL 0x001F01FF +#define EXCHGID4_FLAG_SUPP_MOVED_REFER 0x00000001 +#define EXCHGID4_FLAG_SUPP_MOVED_MIGR 0x00000002 +#define EXCHGID4_FLAG_USE_NON_PNFS 0x00010000 +#define EXCHGID4_FLAG_USE_PNFS_MDS 0x00020000 +#define EXCHGID4_FLAG_USE_PNFS_DS 0x00040000 +#define EXCHGID4_FLAG_UPD_CONFIRMED_REC_A 0x40000000 +#define EXCHGID4_FLAG_CONFIRMED_R 0x80000000 +/* +* Since the validity of these bits depends on whether +* they're set in the argument or response, have separate +* invalid flag masks for arg (_A) and resp (_R). +*/ +#define EXCHGID4_FLAG_MASK_A 0x40070003 +#define EXCHGID4_FLAG_MASK_R 0x80070003 + +#define SEQ4_STATUS_CB_PATH_DOWN 0x00000001 +#define SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRING 0x00000002 +#define SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRED 0x00000004 +#define SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED 0x00000008 +#define SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED 0x00000010 +#define SEQ4_STATUS_ADMIN_STATE_REVOKED 0x00000020 +#define SEQ4_STATUS_RECALLABLE_STATE_REVOKED 0x00000040 +#define SEQ4_STATUS_LEASE_MOVED 0x00000080 +#define SEQ4_STATUS_RESTART_RECLAIM_NEEDED 0x00000100 +#define NFS4_MAX_UINT64 (~(u64)0)enum nfs4_acl_whotype {
@@ -154,6 +194,28 @@ enum nfs_opnum4 {OP_VERIFY =37 ,OP_WRITE =38 ,OP_RELEASE_LOCKOWNER =39 , + +/* nfs41 */ +OP_BACKCHANNEL_CTL =40 , +OP_BIND_CONN_TO_SESSION =41 , +OP_EXCHANGE_ID =42 , +OP_CREATE_SESSION =43 , +OP_DESTROY_SESSION =44 , +OP_FREE_STATEID =45 , +OP_GET_DIR_DELEGATION =46 , +OP_GETDEVICEINFO =47 , +OP_GETDEVICELIST =48 , +OP_LAYOUTCOMMIT =49 , +OP_LAYOUTGET =50 , +OP_LAYOUTRETURN =51 , +OP_SECINFO_NO_NAME =52 , +OP_SEQUENCE =53 , +OP_SET_SSV =54 , +OP_TEST_STATEID =55 , +OP_WANT_DELEGATION =56 , +OP_DESTROY_CLIENTID =57 , +OP_RECLAIM_COMPLETE =58 , + OP_ILLEGAL = 10044, };
@@ -230,7 +292,48 @@ enum nfsstat4 {NFS4ERR_DEADLOCK =10045 ,NFS4ERR_FILE_OPEN =10046 ,NFS4ERR_ADMIN_REVOKED =10047 , - NFS4ERR_CB_PATH_DOWN = 10048 +NFS4ERR_CB_PATH_DOWN =10048 , + +/* nfs41 */ +NFS4ERR_BADIOMODE =10049 , +NFS4ERR_BADLAYOUT =10050 , +NFS4ERR_BAD_SESSION_DIGEST =10051 , +NFS4ERR_BADSESSION =10052 , +NFS4ERR_BADSLOT =10053 , +NFS4ERR_COMPLETE_ALREADY =10054 , +NFS4ERR_CONN_NOT_BOUND_TO_SESSION =10055 , +NFS4ERR_DELEG_ALREADY_WANTED =10056 , +NFS4ERR_BACK_CHAN_BUSY =10057 ,/* backchan reqs outstanding */ +NFS4ERR_LAYOUTTRYLATER =10058 , +NFS4ERR_LAYOUTUNAVAILABLE =10059 , +NFS4ERR_NOMATCHING_LAYOUT =10060 , +NFS4ERR_RECALLCONFLICT =10061 , +NFS4ERR_UNKNOWN_LAYOUTTYPE =10062 , +NFS4ERR_SEQ_MISORDERED =10063 ,/* unexpected seq.id in req */ +NFS4ERR_SEQUENCE_POS =10064 ,/* [CB_]SEQ. op not 1st op */ +NFS4ERR_REQ_TOO_BIG =10065 ,/* request too big */ +NFS4ERR_REP_TOO_BIG =10066 ,/* reply too big */ +NFS4ERR_REP_TOO_BIG_TO_CACHE =10067 ,/* rep. not all cached */ +NFS4ERR_RETRY_UNCACHED_REP =10068 ,/* retry & rep. uncached */ +NFS4ERR_UNSAFE_COMPOUND =10069 ,/* retry/recovery too hard */ +NFS4ERR_TOO_MANY_OPS =10070 ,/* too many ops in [CB_]COMP */ +NFS4ERR_OP_NOT_IN_SESSION =10071 ,/* op needs [CB_]SEQ. op */ +NFS4ERR_HASH_ALG_UNSUPP =10072 ,/* hash alg. not supp. */ +/* Error 10073 is unused. */ +NFS4ERR_CLIENTID_BUSY =10074 ,/* clientid has state */ +NFS4ERR_PNFS_IO_HOLE =10075 ,/* IO to _SPARSE file hole */ +NFS4ERR_SEQ_FALSE_RETRY =10076 ,/* retry not origional */ +NFS4ERR_BAD_HIGH_SLOT =10077 ,/* sequence arg bad */ +NFS4ERR_DEADSESSION =10078 ,/* persistent session dead */ +NFS4ERR_ENCR_ALG_UNSUPP =10079 ,/* SSV alg mismatch */ +NFS4ERR_PNFS_NO_LAYOUT =10080 ,/* direct I/O with no layout */ +NFS4ERR_NOT_ONLY_OP =10081 ,/* bad compound */ +NFS4ERR_WRONG_CRED =10082 ,/* permissions:state change */ +NFS4ERR_WRONG_TYPE =10083 ,/* current operation mismatch */ +NFS4ERR_DIRDELEG_UNAVAIL =10084 ,/* no directory delegation */ +NFS4ERR_REJECT_DELEG =10085 ,/* on callback */ +NFS4ERR_RETURNCONFLICT =10086 ,/* outstanding layoutreturn */ + NFS4ERR_DELEG_REVOKED = 10087, /* deleg./layout revoked */ };/*
@@ -391,6 +494,29 @@ enum {NFSPROC4_CLNT_GETACL ,NFSPROC4_CLNT_SETACL ,NFSPROC4_CLNT_FS_LOCATIONS , + +/* nfs41 */ +NFSPROC4_CLNT_EXCHANGE_ID , +NFSPROC4_CLNT_CREATE_SESSION , +NFSPROC4_CLNT_DESTROY_SESSION , +NFSPROC4_CLNT_SEQUENCE , + NFSPROC4_CLNT_GET_LEASE_TIME, +}; + +/* nfs41 types */ +struct nfs4_sessionid { +unsigned char data[NFS4_MAX_SESSIONID_LEN ]; +}; + +/* Create Session Flags */ +#define SESSION4_PERSIST 0x001 +#define SESSION4_BACK_CHAN 0x002 +#define SESSION4_RDMA 0x004 + +enum state_protect_how4 { +SP4_NONE =0 , +SP4_MACH_CRED =1 , +SP4_SSV =2 };#endif
Signature · 1 line
1.6.2.1
Re: [pnfs] [PATCH v2 01/67] nfs41: common protocol definitions
Quoted 5 lines · Benny Halevy
Define all NFSv4.1 common operation and error code constants.
Note that some of the definitions are used by both the nfs41 client and the server code. This patch is duplicated in the nfs41 and nfsd41 sessions patchset.
Oh, and, for what it's worth (and not being sure which route this may go in by):
--b.
Quoted 205 lines
Signed-off-by Andy Adamson<[email protected]>Signed-off-by Benny Halevy <[email protected]>[nfs41: add exchange id flags]Signed-off-by Mike Sager <[email protected]>Signed-off-by Benny Halevy <[email protected]>[removed server-only hunk changing NFSERR_REPLAY_ME]Signed-off-by Benny Halevy <[email protected]>[nfs41: add SEQ4_XX to nfs41-common-protocol]Signed-off-by Andy Adamson <[email protected]>Signed-off-by Benny Halevy <[email protected]>[nfs41: generic error code update][nfs41: reverse EXCHGID4_INVAL_FLAG_MASK_{A,R}]Signed-off-by Benny Halevy <[email protected]>--- include/linux/nfs4.h | 128 +++++++++++++++++++++++++++++++++++++++++++++++++- 1 files changed, 127 insertions(+), 1 deletions(-)include/linux/nfs4.h +127
-1@@ -21,6 +21,7 @@#define NFS4_FHSIZE 128#define NFS4_MAXPATHLEN PATH_MAX#define NFS4_MAXNAMLEN NAME_MAX +#define NFS4_MAX_SESSIONID_LEN 16#define NFS4_ACCESS_READ 0x0001#define NFS4_ACCESS_LOOKUP 0x0002@@ -38,6 +39,7 @@#define NFS4_OPEN_RESULT_CONFIRM 0x0002#define NFS4_OPEN_RESULT_LOCKTYPE_POSIX 0x0004 +#define NFS4_SHARE_ACCESS_MASK 0x000F#define NFS4_SHARE_ACCESS_READ 0x0001#define NFS4_SHARE_ACCESS_WRITE 0x0002#define NFS4_SHARE_ACCESS_BOTH 0x0003@@ -45,6 +47,19 @@#define NFS4_SHARE_DENY_WRITE 0x0002#define NFS4_SHARE_DENY_BOTH 0x0003 +/* nfs41 */ +#define NFS4_SHARE_WANT_MASK 0xFF00 +#define NFS4_SHARE_WANT_NO_PREFERENCE 0x0000 +#define NFS4_SHARE_WANT_READ_DELEG 0x0100 +#define NFS4_SHARE_WANT_WRITE_DELEG 0x0200 +#define NFS4_SHARE_WANT_ANY_DELEG 0x0300 +#define NFS4_SHARE_WANT_NO_DELEG 0x0400 +#define NFS4_SHARE_WANT_CANCEL 0x0500 + +#define NFS4_SHARE_WHEN_MASK 0xF0000 +#define NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL 0x10000 +#define NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED 0x20000 +#define NFS4_SET_TO_SERVER_TIME 0#define NFS4_SET_TO_CLIENT_TIME 1@@ -88,6 +103,31 @@#define NFS4_ACE_GENERIC_EXECUTE 0x001200A0#define NFS4_ACE_MASK_ALL 0x001F01FF +#define EXCHGID4_FLAG_SUPP_MOVED_REFER 0x00000001 +#define EXCHGID4_FLAG_SUPP_MOVED_MIGR 0x00000002 +#define EXCHGID4_FLAG_USE_NON_PNFS 0x00010000 +#define EXCHGID4_FLAG_USE_PNFS_MDS 0x00020000 +#define EXCHGID4_FLAG_USE_PNFS_DS 0x00040000 +#define EXCHGID4_FLAG_UPD_CONFIRMED_REC_A 0x40000000 +#define EXCHGID4_FLAG_CONFIRMED_R 0x80000000 +/* +* Since the validity of these bits depends on whether +* they're set in the argument or response, have separate +* invalid flag masks for arg (_A) and resp (_R). +*/ +#define EXCHGID4_FLAG_MASK_A 0x40070003 +#define EXCHGID4_FLAG_MASK_R 0x80070003 + +#define SEQ4_STATUS_CB_PATH_DOWN 0x00000001 +#define SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRING 0x00000002 +#define SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRED 0x00000004 +#define SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED 0x00000008 +#define SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED 0x00000010 +#define SEQ4_STATUS_ADMIN_STATE_REVOKED 0x00000020 +#define SEQ4_STATUS_RECALLABLE_STATE_REVOKED 0x00000040 +#define SEQ4_STATUS_LEASE_MOVED 0x00000080 +#define SEQ4_STATUS_RESTART_RECLAIM_NEEDED 0x00000100 +#define NFS4_MAX_UINT64 (~(u64)0)enum nfs4_acl_whotype {@@ -154,6 +194,28 @@ enum nfs_opnum4 {OP_VERIFY =37 ,OP_WRITE =38 ,OP_RELEASE_LOCKOWNER =39 , + +/* nfs41 */ +OP_BACKCHANNEL_CTL =40 , +OP_BIND_CONN_TO_SESSION =41 , +OP_EXCHANGE_ID =42 , +OP_CREATE_SESSION =43 , +OP_DESTROY_SESSION =44 , +OP_FREE_STATEID =45 , +OP_GET_DIR_DELEGATION =46 , +OP_GETDEVICEINFO =47 , +OP_GETDEVICELIST =48 , +OP_LAYOUTCOMMIT =49 , +OP_LAYOUTGET =50 , +OP_LAYOUTRETURN =51 , +OP_SECINFO_NO_NAME =52 , +OP_SEQUENCE =53 , +OP_SET_SSV =54 , +OP_TEST_STATEID =55 , +OP_WANT_DELEGATION =56 , +OP_DESTROY_CLIENTID =57 , +OP_RECLAIM_COMPLETE =58 , + OP_ILLEGAL = 10044, };@@ -230,7 +292,48 @@ enum nfsstat4 {NFS4ERR_DEADLOCK =10045 ,NFS4ERR_FILE_OPEN =10046 ,NFS4ERR_ADMIN_REVOKED =10047 , - NFS4ERR_CB_PATH_DOWN = 10048 +NFS4ERR_CB_PATH_DOWN =10048 , + +/* nfs41 */ +NFS4ERR_BADIOMODE =10049 , +NFS4ERR_BADLAYOUT =10050 , +NFS4ERR_BAD_SESSION_DIGEST =10051 , +NFS4ERR_BADSESSION =10052 , +NFS4ERR_BADSLOT =10053 , +NFS4ERR_COMPLETE_ALREADY =10054 , +NFS4ERR_CONN_NOT_BOUND_TO_SESSION =10055 , +NFS4ERR_DELEG_ALREADY_WANTED =10056 , +NFS4ERR_BACK_CHAN_BUSY =10057 ,/* backchan reqs outstanding */ +NFS4ERR_LAYOUTTRYLATER =10058 , +NFS4ERR_LAYOUTUNAVAILABLE =10059 , +NFS4ERR_NOMATCHING_LAYOUT =10060 , +NFS4ERR_RECALLCONFLICT =10061 , +NFS4ERR_UNKNOWN_LAYOUTTYPE =10062 , +NFS4ERR_SEQ_MISORDERED =10063 ,/* unexpected seq.id in req */ +NFS4ERR_SEQUENCE_POS =10064 ,/* [CB_]SEQ. op not 1st op */ +NFS4ERR_REQ_TOO_BIG =10065 ,/* request too big */ +NFS4ERR_REP_TOO_BIG =10066 ,/* reply too big */ +NFS4ERR_REP_TOO_BIG_TO_CACHE =10067 ,/* rep. not all cached */ +NFS4ERR_RETRY_UNCACHED_REP =10068 ,/* retry & rep. uncached */ +NFS4ERR_UNSAFE_COMPOUND =10069 ,/* retry/recovery too hard */ +NFS4ERR_TOO_MANY_OPS =10070 ,/* too many ops in [CB_]COMP */ +NFS4ERR_OP_NOT_IN_SESSION =10071 ,/* op needs [CB_]SEQ. op */ +NFS4ERR_HASH_ALG_UNSUPP =10072 ,/* hash alg. not supp. */ +/* Error 10073 is unused. */ +NFS4ERR_CLIENTID_BUSY =10074 ,/* clientid has state */ +NFS4ERR_PNFS_IO_HOLE =10075 ,/* IO to _SPARSE file hole */ +NFS4ERR_SEQ_FALSE_RETRY =10076 ,/* retry not origional */ +NFS4ERR_BAD_HIGH_SLOT =10077 ,/* sequence arg bad */ +NFS4ERR_DEADSESSION =10078 ,/* persistent session dead */ +NFS4ERR_ENCR_ALG_UNSUPP =10079 ,/* SSV alg mismatch */ +NFS4ERR_PNFS_NO_LAYOUT =10080 ,/* direct I/O with no layout */ +NFS4ERR_NOT_ONLY_OP =10081 ,/* bad compound */ +NFS4ERR_WRONG_CRED =10082 ,/* permissions:state change */ +NFS4ERR_WRONG_TYPE =10083 ,/* current operation mismatch */ +NFS4ERR_DIRDELEG_UNAVAIL =10084 ,/* no directory delegation */ +NFS4ERR_REJECT_DELEG =10085 ,/* on callback */ +NFS4ERR_RETURNCONFLICT =10086 ,/* outstanding layoutreturn */ + NFS4ERR_DELEG_REVOKED = 10087, /* deleg./layout revoked */ };/* @@ -391,6 +494,29 @@ enum {NFSPROC4_CLNT_GETACL ,NFSPROC4_CLNT_SETACL ,NFSPROC4_CLNT_FS_LOCATIONS , + +/* nfs41 */ +NFSPROC4_CLNT_EXCHANGE_ID , +NFSPROC4_CLNT_CREATE_SESSION , +NFSPROC4_CLNT_DESTROY_SESSION , +NFSPROC4_CLNT_SEQUENCE , + NFSPROC4_CLNT_GET_LEASE_TIME, +}; + +/* nfs41 types */ +struct nfs4_sessionid { +unsigned char data[NFS4_MAX_SESSIONID_LEN ]; +}; + +/* Create Session Flags */ +#define SESSION4_PERSIST 0x001 +#define SESSION4_BACK_CHAN 0x002 +#define SESSION4_RDMA 0x004 + +enum state_protect_how4 { +SP4_NONE =0 , +SP4_MACH_CRED =1 , +SP4_SSV =2 };#endif Signature · 6 lines
1.6.2.1 _______________________________________________ pNFS mailing list [email protected] http://linux-nfs.org/cgi-bin/mailman/listinfo/pnfs
PATCH v2 2/67 nfs41: Add Kconfig symbols for NFSv4.1
In reply to Benny HalevyFrom: Ricardo Labiaga <[email protected]>
Added CONFIG_NFS_V4_1 and made it depend upon CONFIG_NFS_V4 and EXPERIMENTAL. Indicate that CONFIG_NFS_V4_1 is for NFS developers at the moment
At the moment we're expecting folks trying out nfs41 to actively participate in the development process by helping us debug issues and ideally send patches to fix problems.
--- fs/nfs/Kconfig | 9 +++++++++ 1 files changed, 9 insertions(+), 0 deletions(-)
fs/nfs/Kconfig +9 -0
@@ -74,6 +74,15 @@ config NFS_V4 If unsure, say N. +config NFS_V4_1 + bool "NFS client support for NFSv4.1 (DEVELOPER ONLY)" + depends on NFS_V4 && EXPERIMENTAL + help + This option enables support for minor version 1 of the NFSv4 protocol + (draft-ietf-nfsv4-minorversion1) in the kernel's NFS client. + + Unless you're an NFS developer, say N. + config ROOT_NFS bool "Root file system on NFS" depends on NFS_FS=y && IP_PNP
Signature · 1 line
1.6.2.1
PATCH v2 3/67 nfs41: define NFS4_MAX_MINOR_VERSION based on CONFIG_NFS_V4_1
In reply to Benny HalevyFrom: Mike Sager <[email protected]>
If 4.1 isn't supported, NFS4_MAX_MINOR_VERSION will be 0.
--- include/linux/nfs4.h | 7 +++++++ 1 files changed, 7 insertions(+), 0 deletions(-)
include/linux/nfs4.h +7 -0
@@ -454,6 +454,13 @@ enum lock_type4 {#define NFSPROC4_NULL 0#define NFSPROC4_COMPOUND 1#define NFS4_MINOR_VERSION 0 + +#if defined(CONFIG_NFS_V4_1 ) +#define NFS4_MAX_MINOR_VERSION 1 +#else +#define NFS4_MAX_MINOR_VERSION 0 +#endif /* CONFIG_NFS_V4_1 */ +#define NFS4_DEBUG 1/* Index of predefined Linux client operations */
Signature · 1 line
1.6.2.1
PATCH v2 4/67 nfs41: add mount command option minorversion
In reply to Benny HalevyFrom: Mike Sager <[email protected]>
mount -t nfs4 -o minorversion=[0|1] specifies whether to use 4.0 or 4.1. By default, the minorversion is set to 0.
--- fs/nfs/internal.h | 1 + fs/nfs/super.c | 10 ++++++++++ 2 files changed, 11 insertions(+), 0 deletions(-)
fs/nfs/internal.h +1 -0
@@ -44,6 +44,7 @@ struct nfs_parsed_mount_data {unsigned int auth_flavor_len;rpc_authflavor_t auth_flavors[1 ];char *client_address; +unsigned int minorversion;char *fscache_uniq;struct {
fs/nfs/super.c +10 -0
@@ -91,6 +91,7 @@ enum { Opt_mountport, Opt_mountvers, Opt_nfsvers, + Opt_minorversion,/* Mount options that take string arguments */ Opt_sec, Opt_proto, Opt_mountproto, Opt_mounthost,
@@ -156,6 +157,7 @@ static const match_table_t nfs_mount_option_tokens = { { Opt_mountvers, "mountvers=%u" }, { Opt_nfsvers, "nfsvers=%u" }, { Opt_nfsvers, "vers=%u" }, + { Opt_minorversion, "minorversion=%u" }, { Opt_sec, "sec=%s" }, { Opt_proto, "proto=%s" },
@@ -1227,6 +1229,13 @@ static int nfs_parse_mount_options(char *raw,nfs_parse_invalid_value ("nfsvers" ); }break ; +case Opt_minorversion: +if (match_int (args, &option)) +return 0 ; +if (option <0 || option >NFS4_MAX_MINOR_VERSION ) +return 0 ; + mnt->minorversion = option; +break ;/* * options that take text values
@@ -2279,6 +2288,7 @@ static int nfs4_validate_mount_data(void *options, args->nfs_server.port =NFS_PORT ;/* 2049 unless user set port= */ args->auth_flavors[0 ] =RPC_AUTH_UNIX ; args->auth_flavor_len =0 ; + args->minorversion =0 ;switch (data->version) {case 1 :
Signature · 1 line
1.6.2.1
PATCH v2 5/67 nfs41: nfs_client.cl_minorversion
In reply to Benny HalevyThis field is set to the nfsv4 minor version for this mount.
Note: This patch sets the referral to the same minorversion as the current mount. Revisit in future patch.
--- fs/nfs/client.c | 9 ++++++--- include/linux/nfs_fs_sb.h | 3 ++- 2 files changed, 8 insertions(+), 4 deletions(-)
fs/nfs/client.c +6 -3
@@ -1101,7 +1101,8 @@ static int nfs4_set_client(struct nfs_server *server, const size_t addrlen, const char *ip_addr, rpc_authflavor_t authflavour, - int proto, const struct rpc_timeout *timeparms) + int proto, const struct rpc_timeout *timeparms, + u32 minorversion) { struct nfs_client_initdata cl_init = { .hostname = hostname,
@@ -1164,7 +1165,8 @@ static int nfs4_init_server(struct nfs_server *server, data->client_address, data->auth_flavors[0 ], data->nfs_server.protocol, - &timeparms); + &timeparms, + data->minorversion);if (error <0 ) goto error;
@@ -1282,7 +1284,8 @@ struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *data, parent_client->cl_ipaddr, data->authflavor, parent_server->client->cl_xprt->prot, - parent_server->client->cl_timeout); + parent_server->client->cl_timeout, + parent_client->cl_minorversion);if (error <0 ) goto error;
include/linux/nfs_fs_sb.h +2 -1
@@ -63,7 +63,8 @@ struct nfs_client {*/ char cl_ipaddr[48 ];unsigned char cl_id_uniquifier; -#endif +u32 cl_minorversion; +#endif /* CONFIG_NFS_V4 */ #ifdef CONFIG_NFS_FSCACHE struct fscache_cookie *fscache;/* client index cache cookie */
Signature · 1 line
1.6.2.1
PATCH v2 6/67 nfs41: Use mount minorversion option
In reply to Benny HalevyUse the mount minorversion option to initialize the nfs_client cl_minorversion and match it in nfs_match_client() when looking up a nfs_client.
--- fs/nfs/client.c | 7 ++++++- 1 files changed, 6 insertions(+), 1 deletions(-)
fs/nfs/client.c +6 -1
@@ -102,6 +102,7 @@ struct nfs_client_initdata {size_t addrlen;const struct nfs_rpc_ops *rpc_ops;int proto; +u32 minorversion; };/*
@@ -150,6 +151,7 @@ static struct nfs_client *nfs_alloc_client(const struct nfs_client_initdata *cl_rpc_init_wait_queue (&clp->cl_rpcwaitq,"NFS client" ); clp->cl_boot_time =CURRENT_TIME ; clp->cl_state =1 <<NFS4CLNT_LEASE_EXPIRED ; + clp->cl_minorversion = cl_init->minorversion;#endif cred =rpc_lookup_machine_cred ();if (!IS_ERR (cred))
@@ -420,7 +422,9 @@ static struct nfs_client *nfs_match_client(const struct nfs_client_initdata *datif (clp->cl_proto != data->proto)continue ; - +/* Match nfsv4 minorversion */ +if (clp->cl_minorversion != data->minorversion) +continue ;/* Match the full socket address */ if (!nfs_sockaddr_cmp (sap, clap))continue ;
@@ -1110,6 +1114,7 @@ static int nfs4_set_client(struct nfs_server *server, .addrlen = addrlen, .rpc_ops = &nfs_v4_clientops, .proto = proto, + .minorversion = minorversion, };struct nfs_client *clp;int error;
Signature · 1 line
1.6.2.1
PATCH v2 7/67 nfs41: translate NFS4ERR_MINOR_VERS_MISMATCH to EPROTONOSUPPORT
In reply to Benny HalevyTo be returned to the mount command when trying to mount a v4 server using minorversion 1.
--- fs/nfs/nfs4state.c | 2 ++ 1 files changed, 2 insertions(+), 0 deletions(-)
fs/nfs/nfs4state.c +2 -0
@@ -1107,6 +1107,8 @@ static int nfs4_reclaim_lease(struct nfs_client *clp)nfs4_clear_machine_cred (clp); status = -EAGAIN ; } +if (status == -NFS4ERR_MINOR_VERS_MISMATCH ) + status = -EPROTONOSUPPORT ; }return status; }
Signature · 1 line
1.6.2.1
PATCH v2 8/67 nfs41: client xdr definitions
In reply to Benny HalevyDefine stubs for sequence args and res data structures and embed them in all other nfs4 and nfs41 xdr types. They are needed for sending any op in a nfs41 compound rpc.
--- include/linux/nfs_xdr.h | 52 +++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 52 insertions(+), 0 deletions(-)
include/linux/nfs_xdr.h +52 -0
@@ -145,6 +145,15 @@ struct nfs4_change_info { };struct nfs_seqid ; + +struct nfs4_sequence_args { +/* stub */ +}; + +struct nfs4_sequence_res { +/* stub */ +}; +/* * Arguments to the open call. */
@@ -165,6 +174,7 @@ struct nfs_openargs {const struct nfs_server *server;/* Needed for ID mapping */ const u32 * bitmask;__u32 claim; +struct nfs4_sequence_args seq_args; };struct nfs_openres {
@@ -181,6 +191,7 @@ struct nfs_openres {__u32 do_recall;__u64 maxsize;__u32 attrset[NFS4_BITMAP_SIZE ]; +struct nfs4_sequence_res seq_res; };/*
@@ -206,6 +217,7 @@ struct nfs_closeargs {struct nfs_seqid * seqid;fmode_t fmode;const u32 * bitmask; +struct nfs4_sequence_args seq_args; };struct nfs_closeres {
@@ -213,6 +225,7 @@ struct nfs_closeres {struct nfs_fattr * fattr;struct nfs_seqid * seqid;const struct nfs_server *server; +struct nfs4_sequence_res seq_res; };/* * * Arguments to the lock,lockt, and locku call.
@@ -233,12 +246,14 @@ struct nfs_lock_args { unsigned char block : 1; unsigned char reclaim : 1; unsigned char new_lock_owner : 1; +struct nfs4_sequence_args seq_args; };struct nfs_lock_res {nfs4_stateid stateid;struct nfs_seqid * lock_seqid;struct nfs_seqid * open_seqid; +struct nfs4_sequence_res seq_res; };struct nfs_locku_args {
@@ -246,32 +261,38 @@ struct nfs_locku_args {struct file_lock * fl;struct nfs_seqid * seqid;nfs4_stateid * stateid; +struct nfs4_sequence_args seq_args; };struct nfs_locku_res {nfs4_stateid stateid;struct nfs_seqid * seqid; +struct nfs4_sequence_res seq_res; };struct nfs_lockt_args {struct nfs_fh * fh;struct file_lock * fl;struct nfs_lowner lock_owner; +struct nfs4_sequence_args seq_args; };struct nfs_lockt_res {struct file_lock * denied;/* LOCK, LOCKT failed */ +struct nfs4_sequence_res seq_res; };struct nfs4_delegreturnargs {const struct nfs_fh *fhandle;const nfs4_stateid *stateid;const u32 * bitmask; +struct nfs4_sequence_args seq_args; };struct nfs4_delegreturnres {struct nfs_fattr * fattr;const struct nfs_server *server; +struct nfs4_sequence_res seq_res; };/*
@@ -284,12 +305,14 @@ struct nfs_readargs {__u32 count;unsigned int pgbase;struct page ** pages; +struct nfs4_sequence_args seq_args; };struct nfs_readres {struct nfs_fattr * fattr;__u32 count;int eof; +struct nfs4_sequence_res seq_res; };/*
@@ -304,6 +327,7 @@ struct nfs_writeargs {unsigned int pgbase;struct page ** pages;const u32 * bitmask; +struct nfs4_sequence_args seq_args; };struct nfs_writeverf {
@@ -316,6 +340,7 @@ struct nfs_writeres {struct nfs_writeverf * verf;__u32 count;const struct nfs_server *server; +struct nfs4_sequence_res seq_res; };/*
@@ -325,12 +350,14 @@ struct nfs_removeargs {const struct nfs_fh *fh;struct qstr name;const u32 * bitmask; +struct nfs4_sequence_args seq_args; };struct nfs_removeres {const struct nfs_server *server;struct nfs4_change_info cinfo;struct nfs_fattr dir_attr; +struct nfs4_sequence_res seq_res; };/*
@@ -383,6 +410,7 @@ struct nfs_setattrargs {struct iattr * iap;const struct nfs_server * server;/* Needed for name mapping */ const u32 * bitmask; +struct nfs4_sequence_args seq_args; };struct nfs_setaclargs {
@@ -390,6 +418,7 @@ struct nfs_setaclargs {size_t acl_len;unsigned int acl_pgbase;struct page ** acl_pages; +struct nfs4_sequence_args seq_args; };struct nfs_getaclargs {
@@ -397,11 +426,13 @@ struct nfs_getaclargs {size_t acl_len;unsigned int acl_pgbase;struct page ** acl_pages; +struct nfs4_sequence_args seq_args; };struct nfs_setattrres {struct nfs_fattr * fattr;const struct nfs_server * server; +struct nfs4_sequence_res seq_res; };struct nfs_linkargs {
@@ -583,6 +614,7 @@ struct nfs4_accessargs {const struct nfs_fh * fh;const u32 * bitmask;u32 access; +struct nfs4_sequence_args seq_args; };struct nfs4_accessres {
@@ -590,6 +622,7 @@ struct nfs4_accessres {struct nfs_fattr * fattr;u32 supported;u32 access; +struct nfs4_sequence_res seq_res; };struct nfs4_create_arg {
@@ -609,6 +642,7 @@ struct nfs4_create_arg {const struct iattr * attrs;const struct nfs_fh * dir_fh;const u32 * bitmask; +struct nfs4_sequence_args seq_args; };struct nfs4_create_res {
@@ -617,21 +651,25 @@ struct nfs4_create_res {struct nfs_fattr * fattr;struct nfs4_change_info dir_cinfo;struct nfs_fattr * dir_fattr; +struct nfs4_sequence_res seq_res; };struct nfs4_fsinfo_arg {const struct nfs_fh * fh;const u32 * bitmask; +struct nfs4_sequence_args seq_args; };struct nfs4_getattr_arg {const struct nfs_fh * fh;const u32 * bitmask; +struct nfs4_sequence_args seq_args; };struct nfs4_getattr_res {const struct nfs_server * server;struct nfs_fattr * fattr; +struct nfs4_sequence_res seq_res; };struct nfs4_link_arg {
@@ -639,6 +677,7 @@ struct nfs4_link_arg {const struct nfs_fh * dir_fh;const struct qstr * name;const u32 * bitmask; +struct nfs4_sequence_args seq_args; };struct nfs4_link_res {
@@ -646,6 +685,7 @@ struct nfs4_link_res {struct nfs_fattr * fattr;struct nfs4_change_info cinfo;struct nfs_fattr * dir_attr; +struct nfs4_sequence_res seq_res; };
@@ -653,21 +693,25 @@ struct nfs4_lookup_arg {const struct nfs_fh * dir_fh;const struct qstr * name;const u32 * bitmask; +struct nfs4_sequence_args seq_args; };struct nfs4_lookup_res {const struct nfs_server * server;struct nfs_fattr * fattr;struct nfs_fh * fh; +struct nfs4_sequence_res seq_res; };struct nfs4_lookup_root_arg {const u32 * bitmask; +struct nfs4_sequence_args seq_args; };struct nfs4_pathconf_arg {const struct nfs_fh * fh;const u32 * bitmask; +struct nfs4_sequence_args seq_args; };struct nfs4_readdir_arg {
@@ -678,11 +722,13 @@ struct nfs4_readdir_arg {struct page ** pages;/* zero-copy data */ unsigned int pgbase;/* zero-copy data */ const u32 * bitmask; +struct nfs4_sequence_args seq_args; };struct nfs4_readdir_res {nfs4_verifier verifier;unsigned int pgbase; +struct nfs4_sequence_res seq_res; };struct nfs4_readlink {
@@ -690,6 +736,7 @@ struct nfs4_readlink {unsigned int pgbase;unsigned int pglen;/* zero-copy data */ struct page ** pages;/* zero-copy data */ +struct nfs4_sequence_args seq_args; };struct nfs4_rename_arg {
@@ -698,6 +745,7 @@ struct nfs4_rename_arg {const struct qstr * old_name;const struct qstr * new_name;const u32 * bitmask; +struct nfs4_sequence_args seq_args; };struct nfs4_rename_res {
@@ -706,6 +754,7 @@ struct nfs4_rename_res {struct nfs_fattr * old_fattr;struct nfs4_change_info new_cinfo;struct nfs_fattr * new_fattr; +struct nfs4_sequence_res seq_res; };#define NFS4_SETCLIENTID_NAMELEN (127)
@@ -724,6 +773,7 @@ struct nfs4_setclientid {struct nfs4_statfs_arg {const struct nfs_fh * fh;const u32 * bitmask; +struct nfs4_sequence_args seq_args; };struct nfs4_server_caps_res {
@@ -731,6 +781,7 @@ struct nfs4_server_caps_res {u32 acl_bitmask;u32 has_links;u32 has_symlinks; +struct nfs4_sequence_res seq_res; };struct nfs4_string {
@@ -765,6 +816,7 @@ struct nfs4_fs_locations_arg {const struct qstr *name;struct page *page;const u32 *bitmask; + struct nfs4_sequence_args seq_args; };#endif /* CONFIG_NFS_V4 */
Signature · 1 line
1.6.2.1
PATCH v2 9/67 nfs41: sessions client infrastructure
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
NFSv4.1 Sessions basic data types, initialization, and destruction.
The session is always associated with a struct nfs_client that holds the exchange_id results.
[remove extraneous rpc_clnt pointer, use the struct nfs_client cl_rpcclient. remove the rpc_clnt parameter from nfs4 nfs4_init_session]
[Use the presence of a session to determine behaviour instead of the minorversion number.]
[Rename nfs4_put_session() to nfs4_destroy_session() and call it from nfs4_free_client() not nfs4_free_server(). Also get rid of nfs4_get_session() and the ref_count in nfs4_session struct as keeping track of nfs_client should be sufficient]
[separated out removal of rpc_clnt parameter from nfs4_init_session ot a
patch of its own]
Moved session allocation into nfs4_init_client_minor_version, called from nfs4_init_client.
Leave rwise and wsize initialization in nfs4_init_session, called from nfs4_init_server.
Reverted moving of nfs_fsid definition to nfs_fs_sb.h
--- fs/nfs/client.c | 60 +++++++++++++++++++++++++++++++++++++++++++++ fs/nfs/internal.h | 12 +++++++++ fs/nfs/nfs4_fs.h | 4 +++ fs/nfs/nfs4proc.c | 34 +++++++++++++++++++++++++ include/linux/nfs_fs_sb.h | 49 ++++++++++++++++++++++++++++++++++++ include/linux/nfs_xdr.h | 15 +++++++++++ 6 files changed, 174 insertions(+), 0 deletions(-)
fs/nfs/client.c +60 -0
@@ -184,12 +184,27 @@ static void nfs4_shutdown_client(struct nfs_client *clp) }/* +* Clears/puts all minor version specific parts from an nfs_client struct +* reverting it to minorversion 0. +*/ +static void nfs4_clear_client_minor_version (struct nfs_client *clp) +{ +#ifdef CONFIG_NFS_V4_1 +if (nfs4_has_session (clp)) { +nfs4_destroy_session (clp->cl_session); + clp->cl_session =NULL ; + } +#endif /* CONFIG_NFS_V4_1 */ +} + +/* * Destroy a shared client record */ static void nfs_free_client (struct nfs_client *clp) {dprintk ("--> nfs_free_client(%u)\n" , clp->rpc_ops->version); +nfs4_clear_client_minor_version (clp);nfs4_shutdown_client (clp);nfs_fscache_release_client_cookie (clp);
@@ -1054,6 +1069,30 @@ error:#ifdef CONFIG_NFS_V4 /* +* Initialize the minor version specific parts of an NFS4 client record +*/ +static int nfs4_init_client_minor_version (struct nfs_client *clp) +{ +#if defined(CONFIG_NFS_V4_1 ) +if (clp->cl_minorversion) { +struct nfs4_session *session =NULL ; +/* +* Create the session and mark it expired. +* When a SEQUENCE operation encounters the expired session +* it will do session recovery to initialize it. +*/ + session =nfs4_alloc_session (clp); +if (!session) +return -ENOMEM ; + + clp->cl_session = session; + } +#endif /* CONFIG_NFS_V4_1 */ + +return 0 ; +} + +/* * Initialise an NFS4 client record */ static int nfs4_init_client(struct nfs_client *clp,
@@ -1087,6 +1126,10 @@ static int nfs4_init_client(struct nfs_client *clp, }__set_bit (NFS_CS_IDMAP , &clp->cl_res_state); + error =nfs4_init_client_minor_version (clp); +if (error <0 ) + goto error; +nfs_mark_client_ready (clp,NFS_CS_READY );return 0 ;
@@ -1144,6 +1187,21 @@ error: }/* +* Initialize a session. +* Note: save the mount rsize and wsize for create_server negotiation. +*/ +static void nfs4_init_session (struct nfs_client *clp, +unsigned int wsize,unsigned int rsize) +{ +#if defined(CONFIG_NFS_V4_1 ) +if (nfs4_has_session (clp)) { + clp->cl_session->fc_attrs.max_rqst_sz = wsize; + clp->cl_session->fc_attrs.max_resp_sz = rsize; + } +#endif /* CONFIG_NFS_V4_1 */ +} + +/* * Create a version 4 volume record */ static int nfs4_init_server(struct nfs_server *server,
@@ -1221,6 +1279,8 @@ struct nfs_server *nfs4_create_server(const struct nfs_parsed_mount_data *data,BUG_ON (!server->nfs_client->rpc_ops);BUG_ON (!server->nfs_client->rpc_ops->file_inode_ops); +nfs4_init_session (server->nfs_client, server->wsize, server->rsize); +/* Probe the root fh to retrieve its FSID */ error =nfs4_path_walk (server, mntfh, data->nfs_server.export_path);if (error <0 )
fs/nfs/internal.h +12 -0
@@ -207,6 +207,18 @@ extern int nfs4_path_walk(struct nfs_server *server,#endif /* +* Determine if sessions are in use. +*/ +static inline int nfs4_has_session (const struct nfs_client *clp) +{ +#ifdef CONFIG_NFS_V4_1 +if (clp->cl_session) +return 1 ; +#endif /* CONFIG_NFS_V4_1 */ +return 0 ; +} + +/* * Determine the device name as a string */ static inline char *nfs_devname(const struct vfsmount *mnt_parent,
fs/nfs/nfs4_fs.h +4 -0
@@ -202,6 +202,10 @@ extern int nfs4_proc_fs_locations(struct inode *dir, const struct qstr *name,extern struct nfs4_state_recovery_ops nfs4_reboot_recovery_ops;extern struct nfs4_state_recovery_ops nfs4_nograce_recovery_ops; +#if defined(CONFIG_NFS_V4_1 ) +extern void nfs4_destroy_session (struct nfs4_session *session); +extern struct nfs4_session *nfs4_alloc_session (struct nfs_client *clp); +#endif /* CONFIG_NFS_V4_1 */ extern const u32 nfs4_fattr_bitmap[2 ];extern const u32 nfs4_statfs_bitmap[2 ];
fs/nfs/nfs4proc.c +34 -0
@@ -3726,6 +3726,40 @@ int nfs4_proc_fs_locations(struct inode *dir, const struct qstr *name,return status; } +#ifdef CONFIG_NFS_V4_1 +/* Destroy the slot table */ +static void nfs4_destroy_slot_table (struct nfs4_session *session) +{ +if (session->fc_slot_table.slots ==NULL ) +return ; +kfree (session->fc_slot_table.slots); + session->fc_slot_table.slots =NULL ; +return ; +} + +struct nfs4_session *nfs4_alloc_session (struct nfs_client *clp) +{ +struct nfs4_session *session; +struct nfs4_slot_table *tbl; + + session =kzalloc (sizeof (struct nfs4_session ),GFP_KERNEL ); +if (!session) +return NULL ; + tbl = &session->fc_slot_table; +spin_lock_init (&tbl->slot_tbl_lock); +rpc_init_wait_queue (&tbl->slot_tbl_waitq,"Slot table" ); + session->clp = clp; +return session; +} + +void nfs4_destroy_session (struct nfs4_session *session) +{ +nfs4_destroy_slot_table (session); +kfree (session); +} + +#endif /* CONFIG_NFS_V4_1 */ +struct nfs4_state_recovery_ops nfs4_reboot_recovery_ops = { .owner_flag_bit =NFS_OWNER_RECLAIM_REBOOT , .state_flag_bit =NFS_STATE_RECLAIM_REBOOT ,
include/linux/nfs_fs_sb.h +49 -0
68 lines not on this page · raw message
include/linux/nfs_xdr.h +15 -0
@@ -146,6 +146,21 @@ struct nfs4_change_info {struct nfs_seqid ; +/* nfs41 sessions channel attributes */ +struct nfs4_channel_attrs { +u32 headerpadsz; +u32 max_rqst_sz; +u32 max_resp_sz; +u32 max_resp_sz_cached; +u32 max_ops; +u32 max_reqs; +}; + +/* nfs41 sessions slot seqid */ +struct nfs4_slot { +u32 seq_nr; +}; +struct nfs4_sequence_args {/* stub */ };
Signature · 1 line
1.6.2.1
PATCH v2 10/67 nfs41: use nfs4_server_caps_arg
In reply to Benny HalevyIn preparation for nfs41 sequence processing.
--- fs/nfs/nfs4proc.c | 5 ++++- fs/nfs/nfs4xdr.c | 5 +++-- include/linux/nfs_xdr.h | 5 +++++ 3 files changed, 12 insertions(+), 3 deletions(-)
fs/nfs/nfs4proc.c +4 -1
@@ -1584,10 +1584,13 @@ void nfs4_close_context(struct nfs_open_context *ctx, int is_sync)static int _nfs4_server_capabilities (struct nfs_server *server,struct nfs_fh *fhandle) { +struct nfs4_server_caps_arg args = { + .fhandle = fhandle, + };struct nfs4_server_caps_res res = {};struct rpc_message msg = { .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SERVER_CAPS ], - .rpc_argp = fhandle, + .rpc_argp = &args, .rpc_resp = &res, };int status;
fs/nfs/nfs4xdr.c +3 -2
@@ -1900,7 +1900,8 @@ static int nfs4_xdr_enc_statfs(struct rpc_rqst *req, __be32 *p, const struct nfs/* * GETATTR_BITMAP request */ -static int nfs4_xdr_enc_server_caps (struct rpc_rqst *req,__be32 *p,const struct nfs_fh *fhandle) +static int nfs4_xdr_enc_server_caps (struct rpc_rqst *req,__be32 *p, +struct nfs4_server_caps_arg *args) {struct xdr_stream xdr;struct compound_hdr hdr = {
@@ -1909,7 +1910,7 @@ static int nfs4_xdr_enc_server_caps(struct rpc_rqst *req, __be32 *p, const strucxdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, &hdr); -encode_putfh (&xdr, fhandle, &hdr); +encode_putfh (&xdr, args->fhandle, &hdr); encode_getattr_one(&xdr, FATTR4_WORD0_SUPPORTED_ATTRS| FATTR4_WORD0_LINK_SUPPORT| FATTR4_WORD0_SYMLINK_SUPPORT|
include/linux/nfs_xdr.h +5 -0
@@ -791,6 +791,11 @@ struct nfs4_statfs_arg {struct nfs4_sequence_args seq_args; }; +struct nfs4_server_caps_arg { +struct nfs_fh *fhandle; +struct nfs4_sequence_args seq_args; +}; +struct nfs4_server_caps_res {u32 attr_bitmask[2 ];u32 acl_bitmask;
Signature · 1 line
1.6.2.1
PATCH v2 11/67 nfs41: use nfs4_readlink_res
In reply to Benny HalevyIn preparation for nfs41 sequence processing.
--- fs/nfs/nfs4proc.c | 3 ++- fs/nfs/nfs4xdr.c | 3 ++- include/linux/nfs_xdr.h | 4 ++++ 3 files changed, 8 insertions(+), 2 deletions(-)
fs/nfs/nfs4proc.c +2 -1
@@ -1960,10 +1960,11 @@ static int _nfs4_proc_readlink(struct inode *inode, struct page *page, .pglen = pglen, .pages = &page, }; +struct nfs4_readlink_res res;struct rpc_message msg = { .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READLINK ], .rpc_argp = &args, - .rpc_resp =NULL , + .rpc_resp = &res, };return rpc_call_sync (NFS_CLIENT (inode), &msg,0 );
fs/nfs/nfs4xdr.c +2 -1
@@ -4235,7 +4235,8 @@ out:/* * Decode READLINK response */ -static int nfs4_xdr_dec_readlink (struct rpc_rqst *rqstp,__be32 *p,void *res) +static int nfs4_xdr_dec_readlink (struct rpc_rqst *rqstp,__be32 *p, +struct nfs4_readlink_res *res) {struct xdr_stream xdr;struct compound_hdr hdr;
include/linux/nfs_xdr.h +4 -0
@@ -754,6 +754,10 @@ struct nfs4_readlink {struct nfs4_sequence_args seq_args; }; +struct nfs4_readlink_res { +struct nfs4_sequence_res seq_res; +}; +struct nfs4_rename_arg {const struct nfs_fh * old_dir;const struct nfs_fh * new_dir;
Signature · 1 line
1.6.2.1
PATCH v2 12/67 nfs41: use nfs4_statfs_res
In reply to Benny HalevyIn preparation for nfs41 sequence processing.
--- fs/nfs/nfs4proc.c | 5 ++++- fs/nfs/nfs4xdr.c | 5 +++-- include/linux/nfs_xdr.h | 5 +++++ 3 files changed, 12 insertions(+), 3 deletions(-)
fs/nfs/nfs4proc.c +4 -1
@@ -2426,10 +2426,13 @@ static int _nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, .fh = fhandle, .bitmask = server->attr_bitmask, }; +struct nfs4_statfs_res res = { + .fsstat = fsstat, + };struct rpc_message msg = { .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_STATFS ], .rpc_argp = &args, - .rpc_resp = fsstat, + .rpc_resp = &res, };nfs_fattr_init (fsstat->fattr);
fs/nfs/nfs4xdr.c +3 -2
@@ -4387,7 +4387,8 @@ static int nfs4_xdr_dec_pathconf(struct rpc_rqst *req, __be32 *p, struct nfs_pat/* * STATFS request */ -static int nfs4_xdr_dec_statfs (struct rpc_rqst *req,__be32 *p,struct nfs_fsstat *fsstat) +static int nfs4_xdr_dec_statfs (struct rpc_rqst *req,__be32 *p, +struct nfs4_statfs_res *res) {struct xdr_stream xdr;struct compound_hdr hdr;
@@ -4398,7 +4399,7 @@ static int nfs4_xdr_dec_statfs(struct rpc_rqst *req, __be32 *p, struct nfs_fsstaif (!status) status =decode_putfh (&xdr);if (!status) - status =decode_statfs (&xdr, fsstat); + status =decode_statfs (&xdr, res->fsstat);return status; }
include/linux/nfs_xdr.h +5 -0
@@ -795,6 +795,11 @@ struct nfs4_statfs_arg {struct nfs4_sequence_args seq_args; }; +struct nfs4_statfs_res { +struct nfs_fsstat *fsstat; +struct nfs4_sequence_res seq_res; +}; +struct nfs4_server_caps_arg {struct nfs_fh *fhandle;struct nfs4_sequence_args seq_args;
Signature · 1 line
1.6.2.1
PATCH v2 13/67 nfs41: use nfs4_fsinfo_res
In reply to Benny HalevyIn preparation for nfs41 sequence processing.
--- fs/nfs/nfs4proc.c | 5 ++++- fs/nfs/nfs4xdr.c | 5 +++-- include/linux/nfs_xdr.h | 5 +++++ 3 files changed, 12 insertions(+), 3 deletions(-)
fs/nfs/nfs4proc.c +4 -1
@@ -2458,10 +2458,13 @@ static int _nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, .fh = fhandle, .bitmask = server->attr_bitmask, }; +struct nfs4_fsinfo_res res = { + .fsinfo = fsinfo, + };struct rpc_message msg = { .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSINFO ], .rpc_argp = &args, - .rpc_resp = fsinfo, + .rpc_resp = &res, };return rpc_call_sync (server->client, &msg,0 );
fs/nfs/nfs4xdr.c +3 -2
@@ -4351,7 +4351,8 @@ out:/* * FSINFO request */ -static int nfs4_xdr_dec_fsinfo (struct rpc_rqst *req,__be32 *p,struct nfs_fsinfo *fsinfo) +static int nfs4_xdr_dec_fsinfo (struct rpc_rqst *req,__be32 *p, +struct nfs4_fsinfo_res *res) {struct xdr_stream xdr;struct compound_hdr hdr;
@@ -4362,7 +4363,7 @@ static int nfs4_xdr_dec_fsinfo(struct rpc_rqst *req, __be32 *p, struct nfs_fsinfif (!status) status =decode_putfh (&xdr);if (!status) - status =decode_fsinfo (&xdr, fsinfo); + status =decode_fsinfo (&xdr, res->fsinfo);return status; }
include/linux/nfs_xdr.h +5 -0
@@ -675,6 +675,11 @@ struct nfs4_fsinfo_arg {struct nfs4_sequence_args seq_args; }; +struct nfs4_fsinfo_res { +struct nfs_fsinfo *fsinfo; +struct nfs4_sequence_res seq_res; +}; +struct nfs4_getattr_arg {const struct nfs_fh * fh;const u32 * bitmask;
Signature · 1 line
1.6.2.1
PATCH v2 14/67 nfs41: use nfs4_pathconf_res
In reply to Benny HalevyIn preparation for nfs41 sequence processing.
--- fs/nfs/nfs4proc.c | 5 ++++- fs/nfs/nfs4xdr.c | 5 +++-- include/linux/nfs_xdr.h | 5 +++++ 3 files changed, 12 insertions(+), 3 deletions(-)
fs/nfs/nfs4proc.c +4 -1
@@ -2496,10 +2496,13 @@ static int _nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle .fh = fhandle, .bitmask = server->attr_bitmask, }; +struct nfs4_pathconf_res res = { + .pathconf = pathconf, + };struct rpc_message msg = { .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_PATHCONF ], .rpc_argp = &args, - .rpc_resp = pathconf, + .rpc_resp = &res, };/* None of the pathconf attributes are mandatory to implement */
fs/nfs/nfs4xdr.c +3 -2
@@ -4370,7 +4370,8 @@ static int nfs4_xdr_dec_fsinfo(struct rpc_rqst *req, __be32 *p,/* * PATHCONF request */ -static int nfs4_xdr_dec_pathconf (struct rpc_rqst *req,__be32 *p,struct nfs_pathconf *pathconf) +static int nfs4_xdr_dec_pathconf (struct rpc_rqst *req,__be32 *p, +struct nfs4_pathconf_res *res) {struct xdr_stream xdr;struct compound_hdr hdr;
@@ -4381,7 +4382,7 @@ static int nfs4_xdr_dec_pathconf(struct rpc_rqst *req, __be32 *p, struct nfs_patif (!status) status =decode_putfh (&xdr);if (!status) - status =decode_pathconf (&xdr, pathconf); + status =decode_pathconf (&xdr, res->pathconf);return status; }
include/linux/nfs_xdr.h +5 -0
@@ -734,6 +734,11 @@ struct nfs4_pathconf_arg {struct nfs4_sequence_args seq_args; }; +struct nfs4_pathconf_res { +struct nfs_pathconf *pathconf; +struct nfs4_sequence_res seq_res; +}; +struct nfs4_readdir_arg {const struct nfs_fh * fh;u64 cookie;
Signature · 1 line
1.6.2.1
PATCH v2 15/67 nfs41: use nfs4_getaclres
In reply to Benny HalevyIn preparation for nfs41 sequence processing.
--- fs/nfs/nfs4proc.c | 20 +++++++++++--------- fs/nfs/nfs4xdr.c | 5 +++-- include/linux/nfs_xdr.h | 5 +++++ 3 files changed, 19 insertions(+), 11 deletions(-)
fs/nfs/nfs4proc.c +11 -9
@@ -2758,12 +2758,14 @@ static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t bu .acl_pages = pages, .acl_len = buflen, }; -size_t resp_len = buflen; +struct nfs_getaclres res = { + .acl_len = buflen, + };void *resp_buf;struct rpc_message msg = { .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETACL ], .rpc_argp = &args, - .rpc_resp = &resp_len, + .rpc_resp = &res, };struct page *localpage =NULL ;int ret;
@@ -2777,7 +2779,7 @@ static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t bureturn -ENOMEM ; args.acl_pages[0 ] = localpage; args.acl_pgbase =0 ; - resp_len = args.acl_len =PAGE_SIZE ; + args.acl_len =PAGE_SIZE ; }else { resp_buf = buf;buf_to_pages (buf, buflen, args.acl_pages, &args.acl_pgbase);
@@ -2785,18 +2787,18 @@ static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t bu ret =rpc_call_sync (NFS_CLIENT (inode), &msg,0 );if (ret) goto out_free; -if (resp_len > args.acl_len) -nfs4_write_cached_acl (inode,NULL , resp_len); +if (res.acl_len > args.acl_len) +nfs4_write_cached_acl (inode,NULL , res.acl_len);else -nfs4_write_cached_acl (inode, resp_buf, resp_len); +nfs4_write_cached_acl (inode, resp_buf, res.acl_len);if (buf) { ret = -ERANGE ; -if (resp_len > buflen) +if (res.acl_len > buflen) goto out_free;if (localpage) -memcpy (buf, resp_buf, resp_len); +memcpy (buf, resp_buf, res.acl_len); } - ret = resp_len; + ret = res.acl_len; out_free:if (localpage)__free_page (localpage);
fs/nfs/nfs4xdr.c +3 -2
@@ -4018,7 +4018,8 @@ out:* Decode GETACL response */ static int -nfs4_xdr_dec_getacl (struct rpc_rqst *rqstp,__be32 *p,size_t *acl_len) +nfs4_xdr_dec_getacl (struct rpc_rqst *rqstp,__be32 *p, +struct nfs_getaclres *res) {struct xdr_stream xdr;struct compound_hdr hdr;
@@ -4031,7 +4032,7 @@ nfs4_xdr_dec_getacl(struct rpc_rqst *rqstp, __be32 *p, size_t *acl_len) status =decode_putfh (&xdr);if (status) goto out; - status =decode_getacl (&xdr, rqstp, acl_len); + status =decode_getacl (&xdr, rqstp, &res->acl_len); out:return status;
include/linux/nfs_xdr.h +5 -0
@@ -444,6 +444,11 @@ struct nfs_getaclargs {struct nfs4_sequence_args seq_args; }; +struct nfs_getaclres { +size_t acl_len; +struct nfs4_sequence_res seq_res; +}; +struct nfs_setattrres {struct nfs_fattr * fattr;const struct nfs_server * server;
Signature · 1 line
1.6.2.1
PATCH v2 16/67 NFS: get rid of unused xdr decode_setattr(, res) argument
In reply to Benny Halevy--- fs/nfs/nfs4xdr.c | 6 +++--- 1 files changed, 3 insertions(+), 3 deletions(-)
fs/nfs/nfs4xdr.c +3 -3
@@ -3658,7 +3658,7 @@ decode_savefh(struct xdr_stream *xdr)return decode_op_hdr (xdr,OP_SAVEFH ); } -static int decode_setattr (struct xdr_stream *xdr,struct nfs_setattrres *res) +static int decode_setattr (struct xdr_stream *xdr) {__be32 *p;uint32_t bmlen;
@@ -4009,7 +4009,7 @@ nfs4_xdr_dec_setacl(struct rpc_rqst *rqstp, __be32 *p, void *res) status =decode_putfh (&xdr);if (status) goto out; - status =decode_setattr (&xdr, res); + status =decode_setattr (&xdr); out:return status; }
@@ -4162,7 +4162,7 @@ static int nfs4_xdr_dec_setattr(struct rpc_rqst *rqstp, __be32 *p, struct nfs_se status =decode_putfh (&xdr);if (status) goto out; - status =decode_setattr (&xdr, res); + status =decode_setattr (&xdr);if (status) goto out;decode_getfattr (&xdr, res->fattr, res->server);
Signature · 1 line
1.6.2.1
PATCH v2 17/67 nfs41: use nfs4_setaclres
In reply to Benny HalevyIn preparation for nfs41 sequence processing.
--- fs/nfs/nfs4proc.c | 3 ++- fs/nfs/nfs4xdr.c | 3 ++- include/linux/nfs_xdr.h | 4 ++++ 3 files changed, 8 insertions(+), 2 deletions(-)
fs/nfs/nfs4proc.c +2 -1
@@ -2845,10 +2845,11 @@ static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t bufl .acl_pages = pages, .acl_len = buflen, }; +struct nfs_setaclres res;struct rpc_message msg = { .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETACL ], .rpc_argp = &arg, - .rpc_resp =NULL , + .rpc_resp = &res, };int ret;
fs/nfs/nfs4xdr.c +2 -1
@@ -3996,7 +3996,8 @@ nfs4_xdr_enc_setacl(struct rpc_rqst *req, __be32 *p, struct nfs_setaclargs *args* Decode SETACL response */ static int -nfs4_xdr_dec_setacl (struct rpc_rqst *rqstp,__be32 *p,void *res) +nfs4_xdr_dec_setacl (struct rpc_rqst *rqstp,__be32 *p, +struct nfs_setaclres *res) {struct xdr_stream xdr;struct compound_hdr hdr;
include/linux/nfs_xdr.h +4 -0
@@ -436,6 +436,10 @@ struct nfs_setaclargs {struct nfs4_sequence_args seq_args; }; +struct nfs_setaclres { +struct nfs4_sequence_res seq_res; +}; +struct nfs_getaclargs {struct nfs_fh * fh;size_t acl_len;
Signature · 1 line
1.6.2.1
PATCH v2 18/67 nfs41: use nfs4_fs_locations_res
In reply to Benny HalevyIn preparation for nfs41 sequence processing.
--- fs/nfs/nfs4proc.c | 5 ++++- fs/nfs/nfs4xdr.c | 6 ++++-- include/linux/nfs_xdr.h | 5 +++++ 3 files changed, 13 insertions(+), 3 deletions(-)
fs/nfs/nfs4proc.c +4 -1
@@ -3725,10 +3725,13 @@ int nfs4_proc_fs_locations(struct inode *dir, const struct qstr *name, .page = page, .bitmask = bitmask, }; +struct nfs4_fs_locations_res res = { + .fs_locations = fs_locations, + };struct rpc_message msg = { .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS ], .rpc_argp = &args, - .rpc_resp = fs_locations, + .rpc_resp = &res, };int status;
fs/nfs/nfs4xdr.c +4 -2
@@ -4504,7 +4504,8 @@ out:/* * FS_LOCATIONS request */ -static int nfs4_xdr_dec_fs_locations (struct rpc_rqst *req,__be32 *p,struct nfs4_fs_locations *res) +static int nfs4_xdr_dec_fs_locations (struct rpc_rqst *req,__be32 *p, +struct nfs4_fs_locations_res *res) {struct xdr_stream xdr;struct compound_hdr hdr;
@@ -4519,7 +4520,8 @@ static int nfs4_xdr_dec_fs_locations(struct rpc_rqst *req, __be32 *p, struct nfsif ((status =decode_lookup (&xdr)) !=0 ) goto out;xdr_enter_page (&xdr,PAGE_SIZE ); - status =decode_getfattr (&xdr, &res->fattr, res->server); + status =decode_getfattr (&xdr, &res->fs_locations->fattr, + res->fs_locations->server); out:return status; }
include/linux/nfs_xdr.h +5 -0
@@ -867,6 +867,11 @@ struct nfs4_fs_locations_arg { struct nfs4_sequence_args seq_args; }; +struct nfs4_fs_locations_res { +struct nfs4_fs_locations *fs_locations; +struct nfs4_sequence_res seq_res; +}; +#endif /* CONFIG_NFS_V4 */ struct nfs_page ;
Signature · 1 line
1.6.2.1
PATCH v2 19/67 nfs41: introduce nfs4_call_sync
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Use nfs4_call_sync rather than rpc_call_sync to provide for a nfs41 sessions-enabled interface for sessions manipulation.
The nfs41 rpc logic uses the rpc_call_prepare method to recover and create the session, as well as selecting a free slot id and the rpc_call_done to free the slot and update slot table related metadata.
In the coming patches we'll add rpc prepare and done routines for setting up the sequence op and processing the sequence result.
As per 11-14-08 review.
Squash into "nfs41: introduce nfs4_call_sync" and "nfs41: nfs4_setup_sequence" Define two functions one for v4 and one for v41
add a pointer to struct nfs4_client to the correct one.
--- fs/nfs/client.c | 5 +++ fs/nfs/internal.h | 12 ++++++++ fs/nfs/nfs4proc.c | 67 ++++++++++++++++++++++++++++++++------------- include/linux/nfs_fs_sb.h | 8 +++++ 4 files changed, 73 insertions(+), 19 deletions(-)
fs/nfs/client.c +5 -0
@@ -194,6 +194,8 @@ static void nfs4_clear_client_minor_version(struct nfs_client *clp)nfs4_destroy_session (clp->cl_session); clp->cl_session = NULL; } + + clp->cl_call_sync = _nfs4_call_sync;#endif /* CONFIG_NFS_V4_1 */ }
@@ -1073,6 +1075,8 @@ error:*/ static int nfs4_init_client_minor_version (struct nfs_client *clp) { + clp->cl_call_sync = _nfs4_call_sync; +#if defined(CONFIG_NFS_V4_1 )if (clp->cl_minorversion) {struct nfs4_session *session =NULL ;
@@ -1086,6 +1090,7 @@ static int nfs4_init_client_minor_version(struct nfs_client *clp)return -ENOMEM ; clp->cl_session = session; + clp->cl_call_sync = _nfs4_call_sync_session; }#endif /* CONFIG_NFS_V4_1 */
fs/nfs/internal.h +12 -0
@@ -206,6 +206,18 @@ extern int nfs4_path_walk(struct nfs_server *server, const char *path);#endif +/* nfs4proc.c */ +extern int _nfs4_call_sync (struct nfs_server *server, +struct rpc_message *msg, +struct nfs4_sequence_args *args, +struct nfs4_sequence_res *res, +int cache_reply); +extern int _nfs4_call_sync_session (struct nfs_server *server, +struct rpc_message *msg, +struct nfs4_sequence_args *args, +struct nfs4_sequence_res *res, +int cache_reply); +/* * Determine if sessions are in use. */
fs/nfs/nfs4proc.c +48 -19
193 lines not on this page · raw message
include/linux/nfs_fs_sb.h +8 -0
@@ -12,6 +12,9 @@struct nfs4_session ;struct nfs_iostats ;struct nlm_host ; +struct nfs4_sequence_args ; +struct nfs4_sequence_res ; +struct nfs_server ;/* * The nfs_client identifies our client state to the server.
@@ -67,6 +70,11 @@ struct nfs_client {char cl_ipaddr[48 ];unsigned char cl_id_uniquifier;u32 cl_minorversion; +int (* cl_call_sync)(struct nfs_server *server, +struct rpc_message *msg, +struct nfs4_sequence_args *args, +struct nfs4_sequence_res *res, +int cache_reply);#endif /* CONFIG_NFS_V4 */ #ifdef CONFIG_NFS_V4_1
Signature · 1 line
1.6.2.1
PATCH v2 20/67 nfs41: nfs41: pass *session in seq_args and seq_res
In reply to Benny HalevyTo be used for getting the rpc's minorversion and for nfs41 xdr {en,de}coding of the sequence operation.
Reset the seq session ptrs for minorversion=0 rpc calls.
--- fs/nfs/nfs4proc.c | 1 + include/linux/nfs_xdr.h | 4 ++-- 2 files changed, 3 insertions(+), 2 deletions(-)
fs/nfs/nfs4proc.c +1 -0
@@ -291,6 +291,7 @@ int _nfs4_call_sync(struct nfs_server *server, struct nfs4_sequence_res *res, int cache_reply) { + args->sa_session = res->sr_session =NULL ;return rpc_call_sync (server->client, msg,0 ); }
include/linux/nfs_xdr.h +2 -2
@@ -162,11 +162,11 @@ struct nfs4_slot { };struct nfs4_sequence_args { -/* stub */ +struct nfs4_session *sa_session; };struct nfs4_sequence_res { -/* stub */ +struct nfs4_session *sr_session; };/*
Signature · 1 line
1.6.2.1
PATCH v2 21/67 nfs41: set up seq_res.sr_slotid
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Initialize nfs4_sequence_res sr_slotid to NFS4_MAX_SLOT_TABLE.
--- fs/nfs/nfs4proc.c | 5 +++++ fs/nfs/read.c | 1 + fs/nfs/unlink.c | 1 + fs/nfs/write.c | 2 ++ include/linux/nfs_xdr.h | 1 + 5 files changed, 10 insertions(+), 0 deletions(-)
fs/nfs/nfs4proc.c +5 -0
@@ -371,6 +371,7 @@ static struct nfs4_opendata *nfs4_opendata_alloc(struct path *path, p->o_arg.server = server; p->o_arg.bitmask = server->attr_bitmask; p->o_arg.claim =NFS4_OPEN_CLAIM_NULL ; + p->o_res.seq_res.sr_slotid =NFS4_MAX_SLOT_TABLE ;if (flags &O_EXCL ) {u32 *s = (u32 *) p->o_arg.u.verifier.data; s[0 ] = jiffies;
@@ -1463,6 +1464,7 @@ int nfs4_do_close(struct path *path, struct nfs4_state *state, int wait) calldata->res.fattr = &calldata->fattr; calldata->res.seqid = calldata->arg.seqid; calldata->res.server = server; + calldata->res.seq_res.sr_slotid =NFS4_MAX_SLOT_TABLE ; calldata->path.mnt =mntget (path->mnt); calldata->path.dentry =dget (path->dentry);
@@ -3091,6 +3093,7 @@ static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, comemcpy (&data->stateid, stateid,sizeof (data->stateid)); data->res.fattr = &data->fattr; data->res.server = server; + data->res.seq_res.sr_slotid =NFS4_MAX_SLOT_TABLE ;nfs_fattr_init (data->res.fattr); data->timestamp = jiffies; data->rpc_status =0 ;
@@ -3243,6 +3246,7 @@ static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl, p->arg.fl = &p->fl; p->arg.seqid = seqid; p->res.seqid = seqid; + p->res.seq_res.sr_slotid =NFS4_MAX_SLOT_TABLE ; p->arg.stateid = &lsp->ls_stateid; p->lsp = lsp;atomic_inc (&lsp->ls_count);
@@ -3415,6 +3419,7 @@ static struct nfs4_lockdata *nfs4_alloc_lockdata(struct file_lock *fl, p->arg.lock_owner.clientid = server->nfs_client->cl_clientid; p->arg.lock_owner.id = lsp->ls_id.id; p->res.lock_seqid = p->arg.lock_seqid; + p->res.seq_res.sr_slotid =NFS4_MAX_SLOT_TABLE ; p->lsp = lsp;atomic_inc (&lsp->ls_count); p->ctx =get_nfs_open_context (ctx);
fs/nfs/read.c +1 -0
@@ -46,6 +46,7 @@ struct nfs_read_data *nfs_readdata_alloc(unsigned int pagecount)memset (p,0 ,sizeof (*p));INIT_LIST_HEAD (&p->pages); p->npages = pagecount; + p->res.seq_res.sr_slotid =NFS4_MAX_SLOT_TABLE ;if (pagecount <=ARRAY_SIZE (p->page_array)) p->pagevec = p->page_array;else {
fs/nfs/unlink.c +1 -0
@@ -241,6 +241,7 @@ nfs_async_unlink(struct inode *dir, struct dentry *dentry) status =PTR_ERR (data->cred); goto out_free; } + data->res.seq_res.sr_slotid =NFS4_MAX_SLOT_TABLE ; status = -EBUSY ;spin_lock (&dentry->d_lock);
fs/nfs/write.c +2 -0
@@ -52,6 +52,7 @@ struct nfs_write_data *nfs_commitdata_alloc(void)if (p) {memset (p,0 ,sizeof (*p));INIT_LIST_HEAD (&p->pages); + p->res.seq_res.sr_slotid =NFS4_MAX_SLOT_TABLE ; }return p; }
@@ -71,6 +72,7 @@ struct nfs_write_data *nfs_writedata_alloc(unsigned int pagecount)memset (p,0 ,sizeof (*p));INIT_LIST_HEAD (&p->pages); p->npages = pagecount; + p->res.seq_res.sr_slotid =NFS4_MAX_SLOT_TABLE ;if (pagecount <=ARRAY_SIZE (p->page_array)) p->pagevec = p->page_array;else {
include/linux/nfs_xdr.h +1 -0
@@ -167,6 +167,7 @@ struct nfs4_sequence_args {struct nfs4_sequence_res {struct nfs4_session *sr_session; +u8 sr_slotid;/* slot used to send request */ };/*
Signature · 1 line
1.6.2.1
PATCH v2 22/67 NFS: use decode_change_info_maxsz for xdr maxsz calculations
In reply to Benny Halevy--- fs/nfs/nfs4xdr.c | 10 +++++++--- 1 files changed, 7 insertions(+), 3 deletions(-)
fs/nfs/nfs4xdr.c +7 -3
@@ -192,12 +192,16 @@ static int nfs4_stat_to_errno(int); decode_verifier_maxsz)#define encode_remove_maxsz (op_encode_hdr_maxsz + \ nfs4_name_maxsz) +#define decode_remove_maxsz (op_decode_hdr_maxsz + \ + decode_change_info_maxsz)#define encode_rename_maxsz (op_encode_hdr_maxsz + \ 2 * nfs4_name_maxsz) -#define decode_rename_maxsz (op_decode_hdr_maxsz + 5 + 5) +#define decode_rename_maxsz (op_decode_hdr_maxsz + \ + decode_change_info_maxsz + \ + decode_change_info_maxsz)#define encode_link_maxsz (op_encode_hdr_maxsz + \ nfs4_name_maxsz) -#define decode_link_maxsz (op_decode_hdr_maxsz + 5) +#define decode_link_maxsz (op_decode_hdr_maxsz + decode_change_info_maxsz)#define encode_lock_maxsz (op_encode_hdr_maxsz + \ 7 + \ 1 + encode_stateid_maxsz + 8)
@@ -414,7 +418,7 @@ static int nfs4_stat_to_errno(int); encode_getattr_maxsz)#define NFS4_dec_remove_sz (compound_decode_hdr_maxsz + \ decode_putfh_maxsz + \ - op_decode_hdr_maxsz + 5 + \ + decode_remove_maxsz + \ decode_getattr_maxsz)#define NFS4_enc_rename_sz (compound_encode_hdr_maxsz + \ encode_putfh_maxsz + \
Signature · 1 line
1.6.2.1
PATCH v2 23/67 NFS: define and initialize compound_hdr.replen
In reply to Benny Halevyreplen holds the running count of expected reply bytes.
repl will then be used by encoding routines for xdr_inline_pages offset after which data bytes are to be received directly into the xdr buffer pages.
NOTE: According to the nfsv4 and v4.1 RFCs, the replied tag SHOULD be the same is the one sent, but this is not required as a MUST for the server to do so. The server may screw us if it replies a tag of a different length in the compound result.
--- fs/nfs/nfs4xdr.c | 77 ++++++++++++++++++++++++++++++------------------------ 1 files changed, 43 insertions(+), 34 deletions(-)
fs/nfs/nfs4xdr.c +43 -34
@@ -545,6 +545,7 @@ struct compound_hdr {__be32 * nops_p;uint32_t taglen;char * tag; +uint32_t replen;/* expected reply words */ };/*
@@ -580,9 +581,17 @@ static void encode_string(struct xdr_stream *xdr, unsigned int len, const char *xdr_encode_opaque (p, str, len); } -static void encode_compound_hdr (struct xdr_stream *xdr,struct compound_hdr *hdr) +static void encode_compound_hdr (struct xdr_stream *xdr, +struct rpc_rqst *req, +struct compound_hdr *hdr) {__be32 *p; +struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth; + +/* initialize running count of expected bytes in reply. +* NOTE: the replied tag SHOULD be the same is the one sent, +* but this is not required as a MUST for the server to do so. */ + hdr->replen =RPC_REPHDRSIZE + auth->au_rslack +3 + hdr->taglen;dprintk ("encode_compound: tag=%.*s\n" , (int )hdr->taglen, hdr->tag);BUG_ON (hdr->taglen >NFS4_MAXTAGLEN );
@@ -1359,7 +1368,7 @@ static int nfs4_xdr_enc_access(struct rpc_rqst *req, __be32 *p, const struct nfs };xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_access (&xdr, args->access, &hdr);encode_getfattr (&xdr, args->bitmask, &hdr);
@@ -1378,7 +1387,7 @@ static int nfs4_xdr_enc_lookup(struct rpc_rqst *req, __be32 *p, const struct nfs };xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->dir_fh, &hdr);encode_lookup (&xdr, args->name, &hdr);encode_getfh (&xdr, &hdr);
@@ -1398,7 +1407,7 @@ static int nfs4_xdr_enc_lookup_root(struct rpc_rqst *req, __be32 *p, const struc };xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putrootfh (&xdr, &hdr);encode_getfh (&xdr, &hdr);encode_getfattr (&xdr, args->bitmask, &hdr);
@@ -1417,7 +1426,7 @@ static int nfs4_xdr_enc_remove(struct rpc_rqst *req, __be32 *p, const struct nfs };xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_remove (&xdr, &args->name, &hdr);encode_getfattr (&xdr, args->bitmask, &hdr);
@@ -1436,7 +1445,7 @@ static int nfs4_xdr_enc_rename(struct rpc_rqst *req, __be32 *p, const struct nfs };xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->old_dir, &hdr);encode_savefh (&xdr, &hdr);encode_putfh (&xdr, args->new_dir, &hdr);
@@ -1459,7 +1468,7 @@ static int nfs4_xdr_enc_link(struct rpc_rqst *req, __be32 *p, const struct nfs4_ };xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_savefh (&xdr, &hdr);encode_putfh (&xdr, args->dir_fh, &hdr);
@@ -1482,7 +1491,7 @@ static int nfs4_xdr_enc_create(struct rpc_rqst *req, __be32 *p, const struct nfs };xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->dir_fh, &hdr);encode_savefh (&xdr, &hdr);encode_create (&xdr, args, &hdr);
@@ -1513,7 +1522,7 @@ static int nfs4_xdr_enc_getattr(struct rpc_rqst *req, __be32 *p, const struct nf };xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_getfattr (&xdr, args->bitmask, &hdr);encode_nops (&hdr);
@@ -1531,7 +1540,7 @@ static int nfs4_xdr_enc_close(struct rpc_rqst *req, __be32 *p, struct nfs_closea };xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_close (&xdr, args, &hdr);encode_getfattr (&xdr, args->bitmask, &hdr);
@@ -1550,7 +1559,7 @@ static int nfs4_xdr_enc_open(struct rpc_rqst *req, __be32 *p, struct nfs_openarg };xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_savefh (&xdr, &hdr);encode_open (&xdr, args, &hdr);
@@ -1573,7 +1582,7 @@ static int nfs4_xdr_enc_open_confirm(struct rpc_rqst *req, __be32 *p, struct nfs };xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_open_confirm (&xdr, args, &hdr);encode_nops (&hdr);
@@ -1591,7 +1600,7 @@ static int nfs4_xdr_enc_open_noattr(struct rpc_rqst *req, __be32 *p, struct nfs_ };xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_open (&xdr, args, &hdr);encode_getfattr (&xdr, args->bitmask, &hdr);
@@ -1610,7 +1619,7 @@ static int nfs4_xdr_enc_open_downgrade(struct rpc_rqst *req, __be32 *p, struct n };xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_open_downgrade (&xdr, args, &hdr);encode_getfattr (&xdr, args->bitmask, &hdr);
@@ -1629,7 +1638,7 @@ static int nfs4_xdr_enc_lock(struct rpc_rqst *req, __be32 *p, struct nfs_lock_ar };xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_lock (&xdr, args, &hdr);encode_nops (&hdr);
@@ -1647,7 +1656,7 @@ static int nfs4_xdr_enc_lockt(struct rpc_rqst *req, __be32 *p, struct nfs_lockt_ };xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_lockt (&xdr, args, &hdr);encode_nops (&hdr);
@@ -1665,7 +1674,7 @@ static int nfs4_xdr_enc_locku(struct rpc_rqst *req, __be32 *p, struct nfs_locku_ };xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_locku (&xdr, args, &hdr);encode_nops (&hdr);
@@ -1685,7 +1694,7 @@ static int nfs4_xdr_enc_readlink(struct rpc_rqst *req, __be32 *p, const struct nunsigned int replen;xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_readlink (&xdr, args, req, &hdr);
@@ -1713,7 +1722,7 @@ static int nfs4_xdr_enc_readdir(struct rpc_rqst *req, __be32 *p, const struct nfint replen;xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_readdir (&xdr, args, req, &hdr);
@@ -1744,7 +1753,7 @@ static int nfs4_xdr_enc_read(struct rpc_rqst *req, __be32 *p, struct nfs_readargint replen;xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_read (&xdr, args, &hdr);
@@ -1771,7 +1780,7 @@ static int nfs4_xdr_enc_setattr(struct rpc_rqst *req, __be32 *p, struct nfs_seta };xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_setattr (&xdr, args, args->server, &hdr);encode_getfattr (&xdr, args->bitmask, &hdr);
@@ -1794,7 +1803,7 @@ nfs4_xdr_enc_getacl(struct rpc_rqst *req, __be32 *p,int replen;xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_getattr_two (&xdr,FATTR4_WORD0_ACL ,0 , &hdr);
@@ -1817,7 +1826,7 @@ static int nfs4_xdr_enc_write(struct rpc_rqst *req, __be32 *p, struct nfs_writea };xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_write (&xdr, args, &hdr); req->rq_snd_buf.flags |=XDRBUF_WRITE ;
@@ -1837,7 +1846,7 @@ static int nfs4_xdr_enc_commit(struct rpc_rqst *req, __be32 *p, struct nfs_write };xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_commit (&xdr, args, &hdr);encode_getfattr (&xdr, args->bitmask, &hdr);
@@ -1856,7 +1865,7 @@ static int nfs4_xdr_enc_fsinfo(struct rpc_rqst *req, __be32 *p, struct nfs4_fsin };xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_fsinfo (&xdr, args->bitmask, &hdr);encode_nops (&hdr);
@@ -1874,7 +1883,7 @@ static int nfs4_xdr_enc_pathconf(struct rpc_rqst *req, __be32 *p, const struct n };xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_getattr_one (&xdr, args->bitmask[0 ] & nfs4_pathconf_bitmap[0 ], &hdr);
@@ -1893,7 +1902,7 @@ static int nfs4_xdr_enc_statfs(struct rpc_rqst *req, __be32 *p, const struct nfs };xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_getattr_two (&xdr, args->bitmask[0 ] & nfs4_statfs_bitmap[0 ], args->bitmask[1 ] & nfs4_statfs_bitmap[1 ], &hdr);
@@ -1913,7 +1922,7 @@ static int nfs4_xdr_enc_server_caps(struct rpc_rqst *req, __be32 *p, };xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fhandle, &hdr); encode_getattr_one(&xdr, FATTR4_WORD0_SUPPORTED_ATTRS| FATTR4_WORD0_LINK_SUPPORT|
@@ -1934,7 +1943,7 @@ static int nfs4_xdr_enc_renew(struct rpc_rqst *req, __be32 *p, struct nfs_client };xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_renew (&xdr, clp, &hdr);encode_nops (&hdr);return 0 ;
@@ -1951,7 +1960,7 @@ static int nfs4_xdr_enc_setclientid(struct rpc_rqst *req, __be32 *p, struct nfs4 };xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_setclientid (&xdr, sc, &hdr);encode_nops (&hdr);return 0 ;
@@ -1969,7 +1978,7 @@ static int nfs4_xdr_enc_setclientid_confirm(struct rpc_rqst *req, __be32 *p, strconst u32 lease_bitmap[2 ] = {FATTR4_WORD0_LEASE_TIME ,0 };xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_setclientid_confirm (&xdr, clp, &hdr);encode_putrootfh (&xdr, &hdr);encode_fsinfo (&xdr, lease_bitmap, &hdr);
@@ -1988,7 +1997,7 @@ static int nfs4_xdr_enc_delegreturn(struct rpc_rqst *req, __be32 *p, const struc };xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fhandle, &hdr);encode_delegreturn (&xdr, args->stateid, &hdr);encode_getfattr (&xdr, args->bitmask, &hdr);
@@ -2009,7 +2018,7 @@ static int nfs4_xdr_enc_fs_locations(struct rpc_rqst *req, __be32 *p, struct nfsint replen;xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->dir_fh, &hdr);encode_lookup (&xdr, args->name, &hdr);encode_fs_locations (&xdr, args->bitmask, &hdr);
@@ -3989,7 +3998,7 @@ nfs4_xdr_enc_setacl(struct rpc_rqst *req, __be32 *p, struct nfs_setaclargs *argsint status;xdr_init_encode (&xdr, &req->rq_snd_buf, p); -encode_compound_hdr (&xdr, &hdr); +encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fh, &hdr); status =encode_setacl (&xdr, args, &hdr);encode_nops (&hdr);
Signature · 1 line
1.6.2.1
PATCH v2 24/67 NFS: update hdr->replen for every encode op
In reply to Benny Halevy--- fs/nfs/nfs4xdr.c | 31 +++++++++++++++++++++++++++++++ 1 files changed, 31 insertions(+), 0 deletions(-)
fs/nfs/nfs4xdr.c +31 -0
@@ -749,6 +749,7 @@ static void encode_access(struct xdr_stream *xdr, u32 access, struct compound_hdWRITE32 (OP_ACCESS );WRITE32 (access); hdr->nops++; + hdr->replen += decode_access_maxsz; }static void encode_close (struct xdr_stream *xdr,const struct nfs_closeargs *arg,struct compound_hdr *hdr)
@@ -760,6 +761,7 @@ static void encode_close(struct xdr_stream *xdr, const struct nfs_closeargs *argWRITE32 (arg->seqid->sequence->counter);WRITEMEM (arg->stateid->data,NFS4_STATEID_SIZE ); hdr->nops++; + hdr->replen += decode_close_maxsz; }static void encode_commit (struct xdr_stream *xdr,const struct nfs_writeargs *args,struct compound_hdr *hdr)
@@ -771,6 +773,7 @@ static void encode_commit(struct xdr_stream *xdr, const struct nfs_writeargs *arWRITE64 (args->offset);WRITE32 (args->count); hdr->nops++; + hdr->replen += decode_commit_maxsz; }static void encode_create (struct xdr_stream *xdr,const struct nfs4_create_arg *create,struct compound_hdr *hdr)
@@ -802,6 +805,7 @@ static void encode_create(struct xdr_stream *xdr, const struct nfs4_create_arg *WRITE32 (create->name->len);WRITEMEM (create->name->name, create->name->len); hdr->nops++; + hdr->replen += decode_create_maxsz;encode_attrs (xdr, create->attrs, create->server); }
@@ -815,6 +819,7 @@ static void encode_getattr_one(struct xdr_stream *xdr, uint32_t bitmap, struct cWRITE32 (1 );WRITE32 (bitmap); hdr->nops++; + hdr->replen += decode_getattr_maxsz; }static void encode_getattr_two (struct xdr_stream *xdr,uint32_t bm0,uint32_t bm1,struct compound_hdr *hdr)
@@ -827,6 +832,7 @@ static void encode_getattr_two(struct xdr_stream *xdr, uint32_t bm0, uint32_t bmWRITE32 (bm0);WRITE32 (bm1); hdr->nops++; + hdr->replen += decode_getattr_maxsz; }static void encode_getfattr (struct xdr_stream *xdr,const u32 * bitmask,struct compound_hdr *hdr)
@@ -854,6 +860,7 @@ static void encode_getfh(struct xdr_stream *xdr, struct compound_hdr *hdr)RESERVE_SPACE (4 );WRITE32 (OP_GETFH ); hdr->nops++; + hdr->replen += decode_getfh_maxsz; }static void encode_link (struct xdr_stream *xdr,const struct qstr *name,struct compound_hdr *hdr)
@@ -865,6 +872,7 @@ static void encode_link(struct xdr_stream *xdr, const struct qstr *name, structWRITE32 (name->len);WRITEMEM (name->name, name->len); hdr->nops++; + hdr->replen += decode_link_maxsz; }static inline int nfs4_lock_type (struct file_lock *fl,int block)
@@ -912,6 +920,7 @@ static void encode_lock(struct xdr_stream *xdr, const struct nfs_lock_args *argsWRITE32 (args->lock_seqid->sequence->counter); } hdr->nops++; + hdr->replen += decode_lock_maxsz; }static void encode_lockt (struct xdr_stream *xdr,const struct nfs_lockt_args *args,struct compound_hdr *hdr)
@@ -928,6 +937,7 @@ static void encode_lockt(struct xdr_stream *xdr, const struct nfs_lockt_args *arWRITEMEM ("lock id:" ,8 );WRITE64 (args->lock_owner.id); hdr->nops++; + hdr->replen += decode_lockt_maxsz; }static void encode_locku (struct xdr_stream *xdr,const struct nfs_locku_args *args,struct compound_hdr *hdr)
@@ -942,6 +952,7 @@ static void encode_locku(struct xdr_stream *xdr, const struct nfs_locku_args *arWRITE64 (args->fl->fl_start);WRITE64 (nfs4_lock_length (args->fl)); hdr->nops++; + hdr->replen += decode_locku_maxsz; }static void encode_lookup (struct xdr_stream *xdr,const struct qstr *name,struct compound_hdr *hdr)
@@ -954,6 +965,7 @@ static void encode_lookup(struct xdr_stream *xdr, const struct qstr *name, strucWRITE32 (len);WRITEMEM (name->name, len); hdr->nops++; + hdr->replen += decode_lookup_maxsz; }static void encode_share_access (struct xdr_stream *xdr,fmode_t fmode)
@@ -1093,6 +1105,7 @@ static void encode_open(struct xdr_stream *xdr, const struct nfs_openargs *arg,BUG (); } hdr->nops++; + hdr->replen += decode_open_maxsz; }static void encode_open_confirm (struct xdr_stream *xdr,const struct nfs_open_confirmargs *arg,struct compound_hdr *hdr)
@@ -1104,6 +1117,7 @@ static void encode_open_confirm(struct xdr_stream *xdr, const struct nfs_open_coWRITEMEM (arg->stateid->data,NFS4_STATEID_SIZE );WRITE32 (arg->seqid->sequence->counter); hdr->nops++; + hdr->replen += decode_open_confirm_maxsz; }static void encode_open_downgrade (struct xdr_stream *xdr,const struct nfs_closeargs *arg,struct compound_hdr *hdr)
@@ -1116,6 +1130,7 @@ static void encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closeWRITE32 (arg->seqid->sequence->counter);encode_share_access (xdr, arg->fmode); hdr->nops++; + hdr->replen += decode_open_downgrade_maxsz; } static void
@@ -1129,6 +1144,7 @@ encode_putfh(struct xdr_stream *xdr, const struct nfs_fh *fh, struct compound_hdWRITE32 (len);WRITEMEM (fh->data, len); hdr->nops++; + hdr->replen += decode_putfh_maxsz; }static void encode_putrootfh (struct xdr_stream *xdr,struct compound_hdr *hdr)
@@ -1138,6 +1154,7 @@ static void encode_putrootfh(struct xdr_stream *xdr, struct compound_hdr *hdr)RESERVE_SPACE (4 );WRITE32 (OP_PUTROOTFH ); hdr->nops++; + hdr->replen += decode_putrootfh_maxsz; }static void encode_stateid (struct xdr_stream *xdr,const struct nfs_open_context *ctx)
@@ -1166,6 +1183,7 @@ static void encode_read(struct xdr_stream *xdr, const struct nfs_readargs *args,WRITE64 (args->offset);WRITE32 (args->count); hdr->nops++; + hdr->replen += decode_read_maxsz; }static void encode_readdir (struct xdr_stream *xdr,const struct nfs4_readdir_arg *readdir,struct rpc_rqst *req,struct compound_hdr *hdr)
@@ -1191,6 +1209,7 @@ static void encode_readdir(struct xdr_stream *xdr, const struct nfs4_readdir_argWRITE32 (attrs[0 ] & readdir->bitmask[0 ]);WRITE32 (attrs[1 ] & readdir->bitmask[1 ]); hdr->nops++; + hdr->replen += decode_readdir_maxsz; dprintk("%s: cookie = %Lu, verifier = %08x:%08x, bitmap = %08x:%08x\n", __func__, (unsigned long long)readdir->cookie,
@@ -1207,6 +1226,7 @@ static void encode_readlink(struct xdr_stream *xdr, const struct nfs4_readlink *RESERVE_SPACE (4 );WRITE32 (OP_READLINK ); hdr->nops++; + hdr->replen += decode_readlink_maxsz; }static void encode_remove (struct xdr_stream *xdr,const struct qstr *name,struct compound_hdr *hdr)
@@ -1218,6 +1238,7 @@ static void encode_remove(struct xdr_stream *xdr, const struct qstr *name, strucWRITE32 (name->len);WRITEMEM (name->name, name->len); hdr->nops++; + hdr->replen += decode_remove_maxsz; }static void encode_rename (struct xdr_stream *xdr,const struct qstr *oldname,const struct qstr *newname,struct compound_hdr *hdr)
@@ -1233,6 +1254,7 @@ static void encode_rename(struct xdr_stream *xdr, const struct qstr *oldname, coWRITE32 (newname->len);WRITEMEM (newname->name, newname->len); hdr->nops++; + hdr->replen += decode_rename_maxsz; }static void encode_renew (struct xdr_stream *xdr,const struct nfs_client *client_stateid,struct compound_hdr *hdr)
@@ -1243,6 +1265,7 @@ static void encode_renew(struct xdr_stream *xdr, const struct nfs_client *clientWRITE32 (OP_RENEW );WRITE64 (client_stateid->cl_clientid); hdr->nops++; + hdr->replen += decode_renew_maxsz; } static void
@@ -1253,6 +1276,7 @@ encode_restorefh(struct xdr_stream *xdr, struct compound_hdr *hdr)RESERVE_SPACE (4 );WRITE32 (OP_RESTOREFH ); hdr->nops++; + hdr->replen += decode_restorefh_maxsz; } static int
@@ -1272,6 +1296,7 @@ encode_setacl(struct xdr_stream *xdr, struct nfs_setaclargs *arg, struct compounWRITE32 (arg->acl_len);xdr_write_pages (xdr, arg->acl_pages, arg->acl_pgbase, arg->acl_len); hdr->nops++; + hdr->replen += decode_setacl_maxsz;return 0 ; }
@@ -1283,6 +1308,7 @@ encode_savefh(struct xdr_stream *xdr, struct compound_hdr *hdr)RESERVE_SPACE (4 );WRITE32 (OP_SAVEFH ); hdr->nops++; + hdr->replen += decode_savefh_maxsz; }static void encode_setattr (struct xdr_stream *xdr,const struct nfs_setattrargs *arg,const struct nfs_server *server,struct compound_hdr *hdr)
@@ -1293,6 +1319,7 @@ static void encode_setattr(struct xdr_stream *xdr, const struct nfs_setattrargsWRITE32 (OP_SETATTR );WRITEMEM (arg->stateid.data,NFS4_STATEID_SIZE ); hdr->nops++; + hdr->replen += decode_setattr_maxsz;encode_attrs (xdr, arg->iap, server); }
@@ -1312,6 +1339,7 @@ static void encode_setclientid(struct xdr_stream *xdr, const struct nfs4_setclieRESERVE_SPACE (4 );WRITE32 (setclientid->sc_cb_ident); hdr->nops++; + hdr->replen += decode_setclientid_maxsz; }static void encode_setclientid_confirm (struct xdr_stream *xdr,const struct nfs_client *client_state,struct compound_hdr *hdr)
@@ -1323,6 +1351,7 @@ static void encode_setclientid_confirm(struct xdr_stream *xdr, const struct nfs_WRITE64 (client_state->cl_clientid);WRITEMEM (client_state->cl_confirm.data,NFS4_VERIFIER_SIZE ); hdr->nops++; + hdr->replen += decode_setclientid_confirm_maxsz; }static void encode_write (struct xdr_stream *xdr,const struct nfs_writeargs *args,struct compound_hdr *hdr)
@@ -1341,6 +1370,7 @@ static void encode_write(struct xdr_stream *xdr, const struct nfs_writeargs *argxdr_write_pages (xdr, args->pages, args->pgbase, args->count); hdr->nops++; + hdr->replen += decode_write_maxsz; }static void encode_delegreturn (struct xdr_stream *xdr,const nfs4_stateid *stateid,struct compound_hdr *hdr)
@@ -1352,6 +1382,7 @@ static void encode_delegreturn(struct xdr_stream *xdr, const nfs4_stateid *stateWRITE32 (OP_DELEGRETURN );WRITEMEM (stateid->data,NFS4_STATEID_SIZE ); hdr->nops++; + hdr->replen += decode_delegreturn_maxsz; }/* * END OF "GENERIC" ENCODE ROUTINES.
Signature · 1 line
1.6.2.1
PATCH v2 25/67 NFS: use dynamically computed compound_hdr.replen for xdr_inline_pages offset
In reply to Benny HalevyAs Trond suggested, rather than passing a constant to xdr_inline_pages, keep a running count of the expected reply bytes. In preparation for nfs41, where additional op sequence are expteced when talking to nfs41 servers.
--- fs/nfs/nfs4xdr.c | 48 ++++++++++-------------------------------------- 1 files changed, 10 insertions(+), 38 deletions(-)
fs/nfs/nfs4xdr.c +10 -38
@@ -1721,20 +1721,13 @@ static int nfs4_xdr_enc_readlink(struct rpc_rqst *req, __be32 *p, const struct nstruct compound_hdr hdr = { .nops =0 , }; -struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth; -unsigned int replen;xdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_readlink (&xdr, args, req, &hdr); -/* set up reply kvec -* toplevel_status + taglen + rescount + OP_PUTFH + status -* + OP_READLINK + status + string length = 8 -*/ - replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS4_dec_readlink_sz) <<2 ; -xdr_inline_pages (&req->rq_rcv_buf, replen, args->pages, +xdr_inline_pages (&req->rq_rcv_buf, hdr.replen <<2 , args->pages, args->pgbase, args->pglen);encode_nops (&hdr);return 0 ;
@@ -1749,23 +1742,16 @@ static int nfs4_xdr_enc_readdir(struct rpc_rqst *req, __be32 *p, const struct nfstruct compound_hdr hdr = { .nops =0 , }; -struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth; -int replen;xdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_readdir (&xdr, args, req, &hdr); -/* set up reply kvec -* toplevel_status + taglen + rescount + OP_PUTFH + status -* + OP_READDIR + status + verifer(2) = 9 -*/ - replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS4_dec_readdir_sz) <<2 ; -xdr_inline_pages (&req->rq_rcv_buf, replen, args->pages, +xdr_inline_pages (&req->rq_rcv_buf, hdr.replen <<2 , args->pages, args->pgbase, args->count);dprintk ("%s: inlined page args = (%u, %p, %u, %u)\n" , - __func__, replen, args->pages, + __func__, hdr.replen <<2 , args->pages, args->pgbase, args->count);encode_nops (&hdr);return 0 ;
@@ -1776,24 +1762,17 @@ static int nfs4_xdr_enc_readdir(struct rpc_rqst *req, __be32 *p, const struct nf*/ static int nfs4_xdr_enc_read (struct rpc_rqst *req,__be32 *p,struct nfs_readargs *args) { -struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;struct xdr_stream xdr;struct compound_hdr hdr = { .nops =0 , }; -int replen;xdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_read (&xdr, args, &hdr); -/* set up reply kvec -* toplevel status + taglen=0 + rescount + OP_PUTFH + status -* + OP_READ + status + eof + datalen = 9 -*/ - replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS4_dec_read_sz) <<2 ; -xdr_inline_pages (&req->rq_rcv_buf, replen, +xdr_inline_pages (&req->rq_rcv_buf, hdr.replen <<2 , args->pages, args->pgbase, args->count); req->rq_rcv_buf.flags |=XDRBUF_READ ;encode_nops (&hdr);
@@ -1827,20 +1806,18 @@ nfs4_xdr_enc_getacl(struct rpc_rqst *req, __be32 *p, struct nfs_getaclargs *args) {struct xdr_stream xdr; -struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;struct compound_hdr hdr = { .nops =0 , }; -int replen; +uint32_t replen;xdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->fh, &hdr); + replen = hdr.replen + nfs4_fattr_bitmap_maxsz +1 ;encode_getattr_two (&xdr,FATTR4_WORD0_ACL ,0 , &hdr); -/* set up reply buffer: */ - replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS4_dec_getacl_sz) <<2 ; -xdr_inline_pages (&req->rq_rcv_buf, replen, +xdr_inline_pages (&req->rq_rcv_buf, replen <<2 , args->acl_pages, args->acl_pgbase, args->acl_len);encode_nops (&hdr);return 0 ;
@@ -2045,21 +2022,16 @@ static int nfs4_xdr_enc_fs_locations(struct rpc_rqst *req, __be32 *p, struct nfsstruct compound_hdr hdr = { .nops =0 , }; -struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth; -int replen; +uint32_t replen;xdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr);encode_putfh (&xdr, args->dir_fh, &hdr);encode_lookup (&xdr, args->name, &hdr); + replen = hdr.replen;/* get the attribute into args->page */ encode_fs_locations (&xdr, args->bitmask, &hdr); -/* set up reply -* toplevel_status + OP_PUTFH + status -* + OP_LOOKUP + status + OP_GETATTR + status = 7 -*/ - replen = (RPC_REPHDRSIZE + auth->au_rslack +7 ) <<2 ; -xdr_inline_pages (&req->rq_rcv_buf, replen, &args->page, +xdr_inline_pages (&req->rq_rcv_buf, replen <<2 , &args->page,0 ,PAGE_SIZE );encode_nops (&hdr);return 0 ;
Signature · 1 line
1.6.2.1
PATCH v2 26/67 nfs41: encode minorversion in compound header
In reply to Benny Halevy--- fs/nfs/nfs4xdr.c | 70 ++++++++++++++++++++++++++++++----------------------- 1 files changed, 40 insertions(+), 30 deletions(-)
fs/nfs/nfs4xdr.c +40 -30
@@ -546,6 +546,7 @@ struct compound_hdr {uint32_t taglen;char * tag;uint32_t replen;/* expected reply words */ +u32 minorversion; };/*
@@ -598,7 +599,7 @@ static void encode_compound_hdr(struct xdr_stream *xdr,RESERVE_SPACE (12 +(XDR_QUADLEN (hdr->taglen)<<2 ));WRITE32 (hdr->taglen);WRITEMEM (hdr->tag, hdr->taglen); -WRITE32 (NFS4_MINOR_VERSION ); +WRITE32 (hdr->minorversion); hdr->nops_p = p;WRITE32 (hdr->nops); }
@@ -1388,6 +1389,15 @@ static void encode_delegreturn(struct xdr_stream *xdr, const nfs4_stateid *state* END OF "GENERIC" ENCODE ROUTINES. */ +static u32 nfs4_xdr_minorversion (const struct nfs4_sequence_args *args) +{ +#if defined(CONFIG_NFS_V4_1 ) +if (args->sa_session) +return args->sa_session->clp->cl_minorversion; +#endif /* CONFIG_NFS_V4_1 */ +return 0 ; +} +/* * Encode an ACCESS request */
@@ -1395,7 +1405,7 @@ static int nfs4_xdr_enc_access(struct rpc_rqst *req, __be32 *p, const struct nfs {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };xdr_init_encode (&xdr, &req->rq_snd_buf, p);
@@ -1414,7 +1424,7 @@ static int nfs4_xdr_enc_lookup(struct rpc_rqst *req, __be32 *p, const struct nfs {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };xdr_init_encode (&xdr, &req->rq_snd_buf, p);
@@ -1434,7 +1444,7 @@ static int nfs4_xdr_enc_lookup_root(struct rpc_rqst *req, __be32 *p, const struc {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };xdr_init_encode (&xdr, &req->rq_snd_buf, p);
@@ -1453,7 +1463,7 @@ static int nfs4_xdr_enc_remove(struct rpc_rqst *req, __be32 *p, const struct nfs {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };xdr_init_encode (&xdr, &req->rq_snd_buf, p);
@@ -1472,7 +1482,7 @@ static int nfs4_xdr_enc_rename(struct rpc_rqst *req, __be32 *p, const struct nfs {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };xdr_init_encode (&xdr, &req->rq_snd_buf, p);
@@ -1495,7 +1505,7 @@ static int nfs4_xdr_enc_link(struct rpc_rqst *req, __be32 *p, const struct nfs4_ {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };xdr_init_encode (&xdr, &req->rq_snd_buf, p);
@@ -1518,7 +1528,7 @@ static int nfs4_xdr_enc_create(struct rpc_rqst *req, __be32 *p, const struct nfs {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };xdr_init_encode (&xdr, &req->rq_snd_buf, p);
@@ -1549,7 +1559,7 @@ static int nfs4_xdr_enc_getattr(struct rpc_rqst *req, __be32 *p, const struct nf {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };xdr_init_encode (&xdr, &req->rq_snd_buf, p);
@@ -1567,7 +1577,7 @@ static int nfs4_xdr_enc_close(struct rpc_rqst *req, __be32 *p, struct nfs_closea {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };xdr_init_encode (&xdr, &req->rq_snd_buf, p);
@@ -1586,7 +1596,7 @@ static int nfs4_xdr_enc_open(struct rpc_rqst *req, __be32 *p, struct nfs_openarg {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };xdr_init_encode (&xdr, &req->rq_snd_buf, p);
@@ -1627,7 +1637,7 @@ static int nfs4_xdr_enc_open_noattr(struct rpc_rqst *req, __be32 *p, struct nfs_ {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };xdr_init_encode (&xdr, &req->rq_snd_buf, p);
@@ -1646,7 +1656,7 @@ static int nfs4_xdr_enc_open_downgrade(struct rpc_rqst *req, __be32 *p, struct n {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };xdr_init_encode (&xdr, &req->rq_snd_buf, p);
@@ -1665,7 +1675,7 @@ static int nfs4_xdr_enc_lock(struct rpc_rqst *req, __be32 *p, struct nfs_lock_ar {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };xdr_init_encode (&xdr, &req->rq_snd_buf, p);
@@ -1683,7 +1693,7 @@ static int nfs4_xdr_enc_lockt(struct rpc_rqst *req, __be32 *p, struct nfs_lockt_ {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };xdr_init_encode (&xdr, &req->rq_snd_buf, p);
@@ -1701,7 +1711,7 @@ static int nfs4_xdr_enc_locku(struct rpc_rqst *req, __be32 *p, struct nfs_locku_ {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };xdr_init_encode (&xdr, &req->rq_snd_buf, p);
@@ -1719,7 +1729,7 @@ static int nfs4_xdr_enc_readlink(struct rpc_rqst *req, __be32 *p, const struct n {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };xdr_init_encode (&xdr, &req->rq_snd_buf, p);
@@ -1740,7 +1750,7 @@ static int nfs4_xdr_enc_readdir(struct rpc_rqst *req, __be32 *p, const struct nf {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };xdr_init_encode (&xdr, &req->rq_snd_buf, p);
@@ -1764,7 +1774,7 @@ static int nfs4_xdr_enc_read(struct rpc_rqst *req, __be32 *p, struct nfs_readarg {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };xdr_init_encode (&xdr, &req->rq_snd_buf, p);
@@ -1786,7 +1796,7 @@ static int nfs4_xdr_enc_setattr(struct rpc_rqst *req, __be32 *p, struct nfs_seta {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };xdr_init_encode (&xdr, &req->rq_snd_buf, p);
@@ -1807,7 +1817,7 @@ nfs4_xdr_enc_getacl(struct rpc_rqst *req, __be32 *p, {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };uint32_t replen;
@@ -1830,7 +1840,7 @@ static int nfs4_xdr_enc_write(struct rpc_rqst *req, __be32 *p, struct nfs_writea {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };xdr_init_encode (&xdr, &req->rq_snd_buf, p);
@@ -1850,7 +1860,7 @@ static int nfs4_xdr_enc_commit(struct rpc_rqst *req, __be32 *p, struct nfs_write {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };xdr_init_encode (&xdr, &req->rq_snd_buf, p);
@@ -1869,7 +1879,7 @@ static int nfs4_xdr_enc_fsinfo(struct rpc_rqst *req, __be32 *p, struct nfs4_fsin {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };xdr_init_encode (&xdr, &req->rq_snd_buf, p);
@@ -1887,7 +1897,7 @@ static int nfs4_xdr_enc_pathconf(struct rpc_rqst *req, __be32 *p, const struct n {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };xdr_init_encode (&xdr, &req->rq_snd_buf, p);
@@ -1906,7 +1916,7 @@ static int nfs4_xdr_enc_statfs(struct rpc_rqst *req, __be32 *p, const struct nfs {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };xdr_init_encode (&xdr, &req->rq_snd_buf, p);
@@ -1926,7 +1936,7 @@ static int nfs4_xdr_enc_server_caps(struct rpc_rqst *req, __be32 *p, {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };xdr_init_encode (&xdr, &req->rq_snd_buf, p);
@@ -2001,7 +2011,7 @@ static int nfs4_xdr_enc_delegreturn(struct rpc_rqst *req, __be32 *p, const struc {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };xdr_init_encode (&xdr, &req->rq_snd_buf, p);
@@ -2020,7 +2030,7 @@ static int nfs4_xdr_enc_fs_locations(struct rpc_rqst *req, __be32 *p, struct nfs {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };uint32_t replen;
@@ -3996,7 +4006,7 @@ nfs4_xdr_enc_setacl(struct rpc_rqst *req, __be32 *p, struct nfs_setaclargs *args {struct xdr_stream xdr;struct compound_hdr hdr = { - .nops =0 , + .minorversion =nfs4_xdr_minorversion (&args->seq_args), };int status;
Signature · 1 line
1.6.2.1
PATCH v2 27/67 nfs41: xdr {encode,decode}_sequence
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Implement stubs for encode and decode sequence, defined as no-ops when CONFIG_NFS_V4_1 is not defined.
Add the nfsv41 encode and decode sizes. Add encode_sequence to all nfs4_enc_* routines and decode_sequence to all nfs4_dec_* routines as required by v41.
--- fs/nfs/nfs4xdr.c | 242 +++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 files changed, 232 insertions(+), 10 deletions(-)
fs/nfs/nfs4xdr.c +232 -10
@@ -244,43 +244,63 @@ static int nfs4_stat_to_errno(int); (encode_getattr_maxsz)#define decode_fs_locations_maxsz \ (0) + +#if defined(CONFIG_NFS_V4_1 ) +#define encode_sequence_maxsz 0/* stub */ +#define decode_sequence_maxsz 0/* stub */ +#else /* CONFIG_NFS_V4_1 */ +#define encode_sequence_maxsz 0 +#define decode_sequence_maxsz 0 +#endif /* CONFIG_NFS_V4_1 */ +#define NFS4_enc_compound_sz (1024)/* XXX: large enough? */ #define NFS4_dec_compound_sz (1024)/* XXX: large enough? */ #define NFS4_enc_read_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_read_maxsz)#define NFS4_dec_read_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_read_maxsz)#define NFS4_enc_readlink_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_readlink_maxsz)#define NFS4_dec_readlink_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_readlink_maxsz)#define NFS4_enc_readdir_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_readdir_maxsz)#define NFS4_dec_readdir_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_readdir_maxsz)#define NFS4_enc_write_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_write_maxsz + \ encode_getattr_maxsz)#define NFS4_dec_write_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_write_maxsz + \ decode_getattr_maxsz)#define NFS4_enc_commit_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_commit_maxsz + \ encode_getattr_maxsz)#define NFS4_dec_commit_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_commit_maxsz + \ decode_getattr_maxsz)#define NFS4_enc_open_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_savefh_maxsz + \ encode_open_maxsz + \
@@ -289,6 +309,7 @@ static int nfs4_stat_to_errno(int); encode_restorefh_maxsz + \ encode_getattr_maxsz)#define NFS4_dec_open_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_savefh_maxsz + \ decode_open_maxsz + \
@@ -305,43 +326,53 @@ static int nfs4_stat_to_errno(int); decode_putfh_maxsz + \ decode_open_confirm_maxsz)#define NFS4_enc_open_noattr_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_open_maxsz + \ encode_getattr_maxsz)#define NFS4_dec_open_noattr_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_open_maxsz + \ decode_getattr_maxsz)#define NFS4_enc_open_downgrade_sz \ (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_open_downgrade_maxsz + \ encode_getattr_maxsz)#define NFS4_dec_open_downgrade_sz \ (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_open_downgrade_maxsz + \ decode_getattr_maxsz)#define NFS4_enc_close_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_close_maxsz + \ encode_getattr_maxsz)#define NFS4_dec_close_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_close_maxsz + \ decode_getattr_maxsz)#define NFS4_enc_setattr_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_setattr_maxsz + \ encode_getattr_maxsz)#define NFS4_dec_setattr_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_setattr_maxsz + \ decode_getattr_maxsz)#define NFS4_enc_fsinfo_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_fsinfo_maxsz)#define NFS4_dec_fsinfo_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_fsinfo_maxsz)#define NFS4_enc_renew_sz (compound_encode_hdr_maxsz + \
@@ -363,64 +394,81 @@ static int nfs4_stat_to_errno(int); decode_putrootfh_maxsz + \ decode_fsinfo_maxsz)#define NFS4_enc_lock_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_lock_maxsz)#define NFS4_dec_lock_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_lock_maxsz)#define NFS4_enc_lockt_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_lockt_maxsz)#define NFS4_dec_lockt_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_lockt_maxsz)#define NFS4_enc_locku_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_locku_maxsz)#define NFS4_dec_locku_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_locku_maxsz)#define NFS4_enc_access_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_access_maxsz + \ encode_getattr_maxsz)#define NFS4_dec_access_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_access_maxsz + \ decode_getattr_maxsz)#define NFS4_enc_getattr_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_getattr_maxsz)#define NFS4_dec_getattr_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_getattr_maxsz)#define NFS4_enc_lookup_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_lookup_maxsz + \ encode_getattr_maxsz + \ encode_getfh_maxsz)#define NFS4_dec_lookup_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_lookup_maxsz + \ decode_getattr_maxsz + \ decode_getfh_maxsz)#define NFS4_enc_lookup_root_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putrootfh_maxsz + \ encode_getattr_maxsz + \ encode_getfh_maxsz)#define NFS4_dec_lookup_root_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putrootfh_maxsz + \ decode_getattr_maxsz + \ decode_getfh_maxsz)#define NFS4_enc_remove_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_remove_maxsz + \ encode_getattr_maxsz)#define NFS4_dec_remove_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_remove_maxsz + \ decode_getattr_maxsz)#define NFS4_enc_rename_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_savefh_maxsz + \ encode_putfh_maxsz + \
@@ -429,6 +477,7 @@ static int nfs4_stat_to_errno(int); encode_restorefh_maxsz + \ encode_getattr_maxsz)#define NFS4_dec_rename_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_savefh_maxsz + \ decode_putfh_maxsz + \
@@ -437,6 +486,7 @@ static int nfs4_stat_to_errno(int); decode_restorefh_maxsz + \ decode_getattr_maxsz)#define NFS4_enc_link_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_savefh_maxsz + \ encode_putfh_maxsz + \
@@ -445,6 +495,7 @@ static int nfs4_stat_to_errno(int); encode_restorefh_maxsz + \ decode_getattr_maxsz)#define NFS4_dec_link_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_savefh_maxsz + \ decode_putfh_maxsz + \
@@ -453,16 +504,19 @@ static int nfs4_stat_to_errno(int); decode_restorefh_maxsz + \ decode_getattr_maxsz)#define NFS4_enc_symlink_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_symlink_maxsz + \ encode_getattr_maxsz + \ encode_getfh_maxsz)#define NFS4_dec_symlink_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_symlink_maxsz + \ decode_getattr_maxsz + \ decode_getfh_maxsz)#define NFS4_enc_create_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_savefh_maxsz + \ encode_create_maxsz + \
@@ -471,6 +525,7 @@ static int nfs4_stat_to_errno(int); encode_restorefh_maxsz + \ encode_getattr_maxsz)#define NFS4_dec_create_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_savefh_maxsz + \ decode_create_maxsz + \
@@ -479,49 +534,63 @@ static int nfs4_stat_to_errno(int); decode_restorefh_maxsz + \ decode_getattr_maxsz)#define NFS4_enc_pathconf_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_getattr_maxsz)#define NFS4_dec_pathconf_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_getattr_maxsz)#define NFS4_enc_statfs_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_statfs_maxsz)#define NFS4_dec_statfs_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_statfs_maxsz)#define NFS4_enc_server_caps_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_getattr_maxsz)#define NFS4_dec_server_caps_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_getattr_maxsz)#define NFS4_enc_delegreturn_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_delegreturn_maxsz + \ encode_getattr_maxsz)#define NFS4_dec_delegreturn_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_delegreturn_maxsz + \ decode_getattr_maxsz)#define NFS4_enc_getacl_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_getacl_maxsz)#define NFS4_dec_getacl_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_getacl_maxsz)#define NFS4_enc_setacl_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_setacl_maxsz)#define NFS4_dec_setacl_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_setacl_maxsz)#define NFS4_enc_fs_locations_sz \ (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ encode_putfh_maxsz + \ encode_lookup_maxsz + \ encode_fs_locations_maxsz)#define NFS4_dec_fs_locations_sz \ (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_lookup_maxsz + \ decode_fs_locations_maxsz)
@@ -1385,6 +1454,24 @@ static void encode_delegreturn(struct xdr_stream *xdr, const nfs4_stateid *state hdr->nops++; hdr->replen += decode_delegreturn_maxsz; } + +/* NFSv4.1 operations */ +static void encode_sequence (struct xdr_stream *xdr, +const struct nfs4_sequence_args *args, +struct compound_hdr *hdr) +{ +#if defined(CONFIG_NFS_V4_1 ) +struct nfs4_session *session = args->sa_session; + +if (!session) +return ; + +/* stub */ + hdr->nops++; + hdr->replen += decode_sequence_maxsz; +#endif /* CONFIG_NFS_V4_1 */ +} +/* * END OF "GENERIC" ENCODE ROUTINES. */
@@ -1410,6 +1497,7 @@ static int nfs4_xdr_enc_access(struct rpc_rqst *req, __be32 *p, const struct nfsxdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_access (&xdr, args->access, &hdr);encode_getfattr (&xdr, args->bitmask, &hdr);
@@ -1429,6 +1517,7 @@ static int nfs4_xdr_enc_lookup(struct rpc_rqst *req, __be32 *p, const struct nfsxdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->dir_fh, &hdr);encode_lookup (&xdr, args->name, &hdr);encode_getfh (&xdr, &hdr);
@@ -1449,6 +1538,7 @@ static int nfs4_xdr_enc_lookup_root(struct rpc_rqst *req, __be32 *p, const strucxdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putrootfh (&xdr, &hdr);encode_getfh (&xdr, &hdr);encode_getfattr (&xdr, args->bitmask, &hdr);
@@ -1468,6 +1558,7 @@ static int nfs4_xdr_enc_remove(struct rpc_rqst *req, __be32 *p, const struct nfsxdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_remove (&xdr, &args->name, &hdr);encode_getfattr (&xdr, args->bitmask, &hdr);
@@ -1487,6 +1578,7 @@ static int nfs4_xdr_enc_rename(struct rpc_rqst *req, __be32 *p, const struct nfsxdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->old_dir, &hdr);encode_savefh (&xdr, &hdr);encode_putfh (&xdr, args->new_dir, &hdr);
@@ -1510,6 +1602,7 @@ static int nfs4_xdr_enc_link(struct rpc_rqst *req, __be32 *p, const struct nfs4_xdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_savefh (&xdr, &hdr);encode_putfh (&xdr, args->dir_fh, &hdr);
@@ -1533,6 +1626,7 @@ static int nfs4_xdr_enc_create(struct rpc_rqst *req, __be32 *p, const struct nfsxdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->dir_fh, &hdr);encode_savefh (&xdr, &hdr);encode_create (&xdr, args, &hdr);
@@ -1564,6 +1658,7 @@ static int nfs4_xdr_enc_getattr(struct rpc_rqst *req, __be32 *p, const struct nfxdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_getfattr (&xdr, args->bitmask, &hdr);encode_nops (&hdr);
@@ -1582,6 +1677,7 @@ static int nfs4_xdr_enc_close(struct rpc_rqst *req, __be32 *p, struct nfs_closeaxdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_close (&xdr, args, &hdr);encode_getfattr (&xdr, args->bitmask, &hdr);
@@ -1601,6 +1697,7 @@ static int nfs4_xdr_enc_open(struct rpc_rqst *req, __be32 *p, struct nfs_openargxdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_savefh (&xdr, &hdr);encode_open (&xdr, args, &hdr);
@@ -1642,6 +1739,7 @@ static int nfs4_xdr_enc_open_noattr(struct rpc_rqst *req, __be32 *p, struct nfs_xdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_open (&xdr, args, &hdr);encode_getfattr (&xdr, args->bitmask, &hdr);
@@ -1661,6 +1759,7 @@ static int nfs4_xdr_enc_open_downgrade(struct rpc_rqst *req, __be32 *p, struct nxdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_open_downgrade (&xdr, args, &hdr);encode_getfattr (&xdr, args->bitmask, &hdr);
@@ -1680,6 +1779,7 @@ static int nfs4_xdr_enc_lock(struct rpc_rqst *req, __be32 *p, struct nfs_lock_arxdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_lock (&xdr, args, &hdr);encode_nops (&hdr);
@@ -1698,6 +1798,7 @@ static int nfs4_xdr_enc_lockt(struct rpc_rqst *req, __be32 *p, struct nfs_lockt_xdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_lockt (&xdr, args, &hdr);encode_nops (&hdr);
@@ -1716,6 +1817,7 @@ static int nfs4_xdr_enc_locku(struct rpc_rqst *req, __be32 *p, struct nfs_locku_xdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_locku (&xdr, args, &hdr);encode_nops (&hdr);
@@ -1734,6 +1836,7 @@ static int nfs4_xdr_enc_readlink(struct rpc_rqst *req, __be32 *p, const struct nxdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_readlink (&xdr, args, req, &hdr);
@@ -1755,6 +1858,7 @@ static int nfs4_xdr_enc_readdir(struct rpc_rqst *req, __be32 *p, const struct nfxdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_readdir (&xdr, args, req, &hdr);
@@ -1779,6 +1883,7 @@ static int nfs4_xdr_enc_read(struct rpc_rqst *req, __be32 *p, struct nfs_readargxdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_read (&xdr, args, &hdr);
@@ -1801,6 +1906,7 @@ static int nfs4_xdr_enc_setattr(struct rpc_rqst *req, __be32 *p, struct nfs_setaxdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_setattr (&xdr, args, args->server, &hdr);encode_getfattr (&xdr, args->bitmask, &hdr);
@@ -1823,6 +1929,7 @@ nfs4_xdr_enc_getacl(struct rpc_rqst *req, __be32 *p,xdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->fh, &hdr); replen = hdr.replen + nfs4_fattr_bitmap_maxsz +1 ;encode_getattr_two (&xdr,FATTR4_WORD0_ACL ,0 , &hdr);
@@ -1845,6 +1952,7 @@ static int nfs4_xdr_enc_write(struct rpc_rqst *req, __be32 *p, struct nfs_writeaxdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_write (&xdr, args, &hdr); req->rq_snd_buf.flags |=XDRBUF_WRITE ;
@@ -1865,6 +1973,7 @@ static int nfs4_xdr_enc_commit(struct rpc_rqst *req, __be32 *p, struct nfs_writexdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_commit (&xdr, args, &hdr);encode_getfattr (&xdr, args->bitmask, &hdr);
@@ -1884,6 +1993,7 @@ static int nfs4_xdr_enc_fsinfo(struct rpc_rqst *req, __be32 *p, struct nfs4_fsinxdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_fsinfo (&xdr, args->bitmask, &hdr);encode_nops (&hdr);
@@ -1902,6 +2012,7 @@ static int nfs4_xdr_enc_pathconf(struct rpc_rqst *req, __be32 *p, const struct nxdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_getattr_one (&xdr, args->bitmask[0 ] & nfs4_pathconf_bitmap[0 ], &hdr);
@@ -1921,6 +2032,7 @@ static int nfs4_xdr_enc_statfs(struct rpc_rqst *req, __be32 *p, const struct nfsxdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->fh, &hdr);encode_getattr_two (&xdr, args->bitmask[0 ] & nfs4_statfs_bitmap[0 ], args->bitmask[1 ] & nfs4_statfs_bitmap[1 ], &hdr);
@@ -1941,6 +2053,7 @@ static int nfs4_xdr_enc_server_caps(struct rpc_rqst *req, __be32 *p,xdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->fhandle, &hdr); encode_getattr_one(&xdr, FATTR4_WORD0_SUPPORTED_ATTRS| FATTR4_WORD0_LINK_SUPPORT|
@@ -2016,6 +2129,7 @@ static int nfs4_xdr_enc_delegreturn(struct rpc_rqst *req, __be32 *p, const strucxdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->fhandle, &hdr);encode_delegreturn (&xdr, args->stateid, &hdr);encode_getfattr (&xdr, args->bitmask, &hdr);
@@ -2036,6 +2150,7 @@ static int nfs4_xdr_enc_fs_locations(struct rpc_rqst *req, __be32 *p, struct nfsxdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->dir_fh, &hdr);encode_lookup (&xdr, args->name, &hdr); replen = hdr.replen;/* get the attribute into args->page */
@@ -3762,6 +3877,20 @@ static int decode_delegreturn(struct xdr_stream *xdr)return decode_op_hdr (xdr,OP_DELEGRETURN ); } +static int decode_sequence (struct xdr_stream *xdr, +struct nfs4_sequence_res *res, +struct rpc_rqst *rqstp) +{ +#if defined(CONFIG_NFS_V4_1 ) +if (!res->sr_session) +return 0 ; + +/* stub */ +#endif /* CONFIG_NFS_V4_1 */ + +return 0 ; +} +/* * END OF "GENERIC" DECODE ROUTINES. */
@@ -3779,6 +3908,9 @@ static int nfs4_xdr_dec_open_downgrade(struct rpc_rqst *rqstp, __be32 *p, struct status =decode_compound_hdr (&xdr, &hdr);if (status) goto out; + status =decode_sequence (&xdr, &res->seq_res, rqstp); +if (status) + goto out; status =decode_putfh (&xdr);if (status) goto out;
@@ -3800,7 +3932,11 @@ static int nfs4_xdr_dec_access(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_acint status;xdr_init_decode (&xdr, &rqstp->rq_rcv_buf, p); -if ((status =decode_compound_hdr (&xdr, &hdr)) !=0 ) + status =decode_compound_hdr (&xdr, &hdr); +if (status) + goto out; + status =decode_sequence (&xdr, &res->seq_res, rqstp); +if (status) goto out; status =decode_putfh (&xdr);if (status !=0 )
@@ -3823,7 +3959,11 @@ static int nfs4_xdr_dec_lookup(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_loint status;xdr_init_decode (&xdr, &rqstp->rq_rcv_buf, p); -if ((status =decode_compound_hdr (&xdr, &hdr)) !=0 ) + status =decode_compound_hdr (&xdr, &hdr); +if (status) + goto out; + status =decode_sequence (&xdr, &res->seq_res, rqstp); +if (status) goto out;if ((status =decode_putfh (&xdr)) !=0 ) goto out;
@@ -3846,7 +3986,11 @@ static int nfs4_xdr_dec_lookup_root(struct rpc_rqst *rqstp, __be32 *p, struct nfint status;xdr_init_decode (&xdr, &rqstp->rq_rcv_buf, p); -if ((status =decode_compound_hdr (&xdr, &hdr)) !=0 ) + status =decode_compound_hdr (&xdr, &hdr); +if (status) + goto out; + status =decode_sequence (&xdr, &res->seq_res, rqstp); +if (status) goto out;if ((status =decode_putrootfh (&xdr)) !=0 ) goto out;
@@ -3866,7 +4010,11 @@ static int nfs4_xdr_dec_remove(struct rpc_rqst *rqstp, __be32 *p, struct nfs_remint status;xdr_init_decode (&xdr, &rqstp->rq_rcv_buf, p); -if ((status =decode_compound_hdr (&xdr, &hdr)) !=0 ) + status =decode_compound_hdr (&xdr, &hdr); +if (status) + goto out; + status =decode_sequence (&xdr, &res->seq_res, rqstp); +if (status) goto out;if ((status =decode_putfh (&xdr)) !=0 ) goto out;
@@ -3887,7 +4035,11 @@ static int nfs4_xdr_dec_rename(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_reint status;xdr_init_decode (&xdr, &rqstp->rq_rcv_buf, p); -if ((status =decode_compound_hdr (&xdr, &hdr)) !=0 ) + status =decode_compound_hdr (&xdr, &hdr); +if (status) + goto out; + status =decode_sequence (&xdr, &res->seq_res, rqstp); +if (status) goto out;if ((status =decode_putfh (&xdr)) !=0 ) goto out;
@@ -3917,7 +4069,11 @@ static int nfs4_xdr_dec_link(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_linkint status;xdr_init_decode (&xdr, &rqstp->rq_rcv_buf, p); -if ((status =decode_compound_hdr (&xdr, &hdr)) !=0 ) + status =decode_compound_hdr (&xdr, &hdr); +if (status) + goto out; + status =decode_sequence (&xdr, &res->seq_res, rqstp); +if (status) goto out;if ((status =decode_putfh (&xdr)) !=0 ) goto out;
@@ -3950,7 +4106,11 @@ static int nfs4_xdr_dec_create(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_crint status;xdr_init_decode (&xdr, &rqstp->rq_rcv_buf, p); -if ((status =decode_compound_hdr (&xdr, &hdr)) !=0 ) + status =decode_compound_hdr (&xdr, &hdr); +if (status) + goto out; + status =decode_sequence (&xdr, &res->seq_res, rqstp); +if (status) goto out;if ((status =decode_putfh (&xdr)) !=0 ) goto out;
@@ -3990,6 +4150,9 @@ static int nfs4_xdr_dec_getattr(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_g status =decode_compound_hdr (&xdr, &hdr);if (status) goto out; + status =decode_sequence (&xdr, &res->seq_res, rqstp); +if (status) + goto out; status =decode_putfh (&xdr);if (status) goto out;
@@ -4012,6 +4175,7 @@ nfs4_xdr_enc_setacl(struct rpc_rqst *req, __be32 *p, struct nfs_setaclargs *argsxdr_init_encode (&xdr, &req->rq_snd_buf, p);encode_compound_hdr (&xdr, req, &hdr); +encode_sequence (&xdr, &args->seq_args, &hdr);encode_putfh (&xdr, args->fh, &hdr); status =encode_setacl (&xdr, args, &hdr);encode_nops (&hdr);
@@ -4033,6 +4197,9 @@ nfs4_xdr_dec_setacl(struct rpc_rqst *rqstp, __be32 *p, status =decode_compound_hdr (&xdr, &hdr);if (status) goto out; + status =decode_sequence (&xdr, &res->seq_res, rqstp); +if (status) + goto out; status =decode_putfh (&xdr);if (status) goto out;
@@ -4056,6 +4223,9 @@ nfs4_xdr_dec_getacl(struct rpc_rqst *rqstp, __be32 *p, status =decode_compound_hdr (&xdr, &hdr);if (status) goto out; + status =decode_sequence (&xdr, &res->seq_res, rqstp); +if (status) + goto out; status =decode_putfh (&xdr);if (status) goto out;
@@ -4078,6 +4248,9 @@ static int nfs4_xdr_dec_close(struct rpc_rqst *rqstp, __be32 *p, struct nfs_clos status =decode_compound_hdr (&xdr, &hdr);if (status) goto out; + status =decode_sequence (&xdr, &res->seq_res, rqstp); +if (status) + goto out; status =decode_putfh (&xdr);if (status) goto out;
@@ -4108,6 +4281,9 @@ static int nfs4_xdr_dec_open(struct rpc_rqst *rqstp, __be32 *p, struct nfs_openr status =decode_compound_hdr (&xdr, &hdr);if (status) goto out; + status =decode_sequence (&xdr, &res->seq_res, rqstp); +if (status) + goto out; status =decode_putfh (&xdr);if (status) goto out;
@@ -4162,6 +4338,9 @@ static int nfs4_xdr_dec_open_noattr(struct rpc_rqst *rqstp, __be32 *p, struct nf status =decode_compound_hdr (&xdr, &hdr);if (status) goto out; + status =decode_sequence (&xdr, &res->seq_res, rqstp); +if (status) + goto out; status =decode_putfh (&xdr);if (status) goto out;
@@ -4186,6 +4365,9 @@ static int nfs4_xdr_dec_setattr(struct rpc_rqst *rqstp, __be32 *p, struct nfs_se status =decode_compound_hdr (&xdr, &hdr);if (status) goto out; + status =decode_sequence (&xdr, &res->seq_res, rqstp); +if (status) + goto out; status =decode_putfh (&xdr);if (status) goto out;
@@ -4210,6 +4392,9 @@ static int nfs4_xdr_dec_lock(struct rpc_rqst *rqstp, __be32 *p, struct nfs_lock_ status =decode_compound_hdr (&xdr, &hdr);if (status) goto out; + status =decode_sequence (&xdr, &res->seq_res, rqstp); +if (status) + goto out; status =decode_putfh (&xdr);if (status) goto out;
@@ -4231,6 +4416,9 @@ static int nfs4_xdr_dec_lockt(struct rpc_rqst *rqstp, __be32 *p, struct nfs_lock status =decode_compound_hdr (&xdr, &hdr);if (status) goto out; + status =decode_sequence (&xdr, &res->seq_res, rqstp); +if (status) + goto out; status =decode_putfh (&xdr);if (status) goto out;
@@ -4252,6 +4440,9 @@ static int nfs4_xdr_dec_locku(struct rpc_rqst *rqstp, __be32 *p, struct nfs_lock status =decode_compound_hdr (&xdr, &hdr);if (status) goto out; + status =decode_sequence (&xdr, &res->seq_res, rqstp); +if (status) + goto out; status =decode_putfh (&xdr);if (status) goto out;
@@ -4274,6 +4465,9 @@ static int nfs4_xdr_dec_readlink(struct rpc_rqst *rqstp, __be32 *p, status =decode_compound_hdr (&xdr, &hdr);if (status) goto out; + status =decode_sequence (&xdr, &res->seq_res, rqstp); +if (status) + goto out; status =decode_putfh (&xdr);if (status) goto out;
@@ -4295,6 +4489,9 @@ static int nfs4_xdr_dec_readdir(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_r status =decode_compound_hdr (&xdr, &hdr);if (status) goto out; + status =decode_sequence (&xdr, &res->seq_res, rqstp); +if (status) + goto out; status =decode_putfh (&xdr);if (status) goto out;
@@ -4316,6 +4513,9 @@ static int nfs4_xdr_dec_read(struct rpc_rqst *rqstp, __be32 *p, struct nfs_readr status =decode_compound_hdr (&xdr, &hdr);if (status) goto out; + status =decode_sequence (&xdr, &res->seq_res, rqstp); +if (status) + goto out; status =decode_putfh (&xdr);if (status) goto out;
@@ -4339,6 +4539,9 @@ static int nfs4_xdr_dec_write(struct rpc_rqst *rqstp, __be32 *p, struct nfs_writ status =decode_compound_hdr (&xdr, &hdr);if (status) goto out; + status =decode_sequence (&xdr, &res->seq_res, rqstp); +if (status) + goto out; status =decode_putfh (&xdr);if (status) goto out;
@@ -4365,6 +4568,9 @@ static int nfs4_xdr_dec_commit(struct rpc_rqst *rqstp, __be32 *p, struct nfs_wri status =decode_compound_hdr (&xdr, &hdr);if (status) goto out; + status =decode_sequence (&xdr, &res->seq_res, rqstp); +if (status) + goto out; status =decode_putfh (&xdr);if (status) goto out;
@@ -4389,6 +4595,8 @@ static int nfs4_xdr_dec_fsinfo(struct rpc_rqst *req, __be32 *p,xdr_init_decode (&xdr, &req->rq_rcv_buf, p); status =decode_compound_hdr (&xdr, &hdr);if (!status) + status =decode_sequence (&xdr, &res->seq_res, req); +if (!status) status =decode_putfh (&xdr);if (!status) status =decode_fsinfo (&xdr, res->fsinfo);
@@ -4408,6 +4616,8 @@ static int nfs4_xdr_dec_pathconf(struct rpc_rqst *req, __be32 *p,xdr_init_decode (&xdr, &req->rq_rcv_buf, p); status =decode_compound_hdr (&xdr, &hdr);if (!status) + status =decode_sequence (&xdr, &res->seq_res, req); +if (!status) status =decode_putfh (&xdr);if (!status) status =decode_pathconf (&xdr, res->pathconf);
@@ -4427,6 +4637,8 @@ static int nfs4_xdr_dec_statfs(struct rpc_rqst *req, __be32 *p,xdr_init_decode (&xdr, &req->rq_rcv_buf, p); status =decode_compound_hdr (&xdr, &hdr);if (!status) + status =decode_sequence (&xdr, &res->seq_res, req); +if (!status) status =decode_putfh (&xdr);if (!status) status =decode_statfs (&xdr, res->fsstat);
@@ -4443,7 +4655,11 @@ static int nfs4_xdr_dec_server_caps(struct rpc_rqst *req, __be32 *p, struct nfs4int status;xdr_init_decode (&xdr, &req->rq_rcv_buf, p); -if ((status =decode_compound_hdr (&xdr, &hdr)) !=0 ) + status =decode_compound_hdr (&xdr, &hdr); +if (status) + goto out; + status =decode_sequence (&xdr, &res->seq_res, req); +if (status) goto out;if ((status =decode_putfh (&xdr)) !=0 ) goto out;
@@ -4516,7 +4732,10 @@ static int nfs4_xdr_dec_delegreturn(struct rpc_rqst *rqstp, __be32 *p, struct nfxdr_init_decode (&xdr, &rqstp->rq_rcv_buf, p); status =decode_compound_hdr (&xdr, &hdr); -if (status !=0 ) +if (status) + goto out; + status =decode_sequence (&xdr, &res->seq_res, rqstp); +if (status) goto out; status =decode_putfh (&xdr);if (status !=0 )
@@ -4539,7 +4758,10 @@ static int nfs4_xdr_dec_fs_locations(struct rpc_rqst *req, __be32 *p,xdr_init_decode (&xdr, &req->rq_rcv_buf, p); status =decode_compound_hdr (&xdr, &hdr); -if (status !=0 ) +if (status) + goto out; + status =decode_sequence (&xdr, &res->seq_res, req); +if (status) goto out;if ((status =decode_putfh (&xdr)) !=0 ) goto out;
Signature · 1 line
1.6.2.1
PATCH v2 28/67 nfs41: nfs4_setup_sequence
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Perform the nfs4_setup_sequence in the rpc_call_prepare state.
If a session slot is not available, we will rpc_sleep_on the slot wait queue leaving the tk_action as rpc_call_prepare.
Once we have a session slot, hang on to it even through rpc_restart_calls. Ensure the nfs41_sequence_res sr_slot pointer is NULL before rpc_run_task is called as nfs41_setup_sequence will only find a new slot if it is NULL.
A future patch will call free slot after any rpc_restart_calls, and handle the rpc restart that result from a sequence operation error.
--- fs/nfs/nfs4proc.c | 100 +++++++++++++++++++++++++++++++++++++++++++++++++++- 1 files changed, 98 insertions(+), 2 deletions(-)
fs/nfs/nfs4proc.c +98 -2
@@ -273,14 +273,110 @@ static void renew_lease(const struct nfs_server *server, unsigned long timestamp#if defined(CONFIG_NFS_V4_1 ) +static int nfs41_setup_sequence (struct nfs4_session *session, +struct nfs4_sequence_args *args, +struct nfs4_sequence_res *res, +int cache_reply, +struct rpc_task *task) +{ +/* slot already allocated? */ +if (res->sr_slotid !=NFS4_MAX_SLOT_TABLE ) +return 0 ; + +memset (res,0 ,sizeof (*res)); + res->sr_slotid =NFS4_MAX_SLOT_TABLE ; +return 0 ; +} + +int nfs4_setup_sequence (struct nfs_client *clp, +struct nfs4_sequence_args *args, +struct nfs4_sequence_res *res, +int cache_reply, +struct rpc_task *task) +{ +int ret =0 ; + +dprintk ("--> %s clp %p session %p sr_slotid %d\n" , + __func__, clp, clp->cl_session, res->sr_slotid); + +if (!nfs4_has_session (clp)) + goto out; + ret =nfs41_setup_sequence (clp->cl_session, args, res, cache_reply, + task); +if (ret != -EAGAIN ) { +/* terminate rpc task */ + task->tk_status = ret; + task->tk_action =NULL ; + } +out: +dprintk ("<-- %s status=%d\n" , __func__, ret); +return ret; +} + +struct nfs41_call_sync_data { +struct nfs_client *clp; +struct nfs4_sequence_args *seq_args; +struct nfs4_sequence_res *seq_res; +int cache_reply; +}; + +static void nfs41_call_sync_prepare (struct rpc_task *task,void *calldata) +{ +struct nfs41_call_sync_data *data = calldata; + +dprintk ("--> %s data->clp->cl_session %p\n" , __func__, + data->clp->cl_session); +if (nfs4_setup_sequence (data->clp, data->seq_args, + data->seq_res, data->cache_reply, task)) +return ; +rpc_call_start (task); +} + +struct rpc_call_ops nfs41_call_sync_ops = { + .rpc_call_prepare = nfs41_call_sync_prepare, +}; + +static int nfs4_call_sync_sequence (struct nfs_client *clp, +struct rpc_clnt *clnt, +struct rpc_message *msg, +struct nfs4_sequence_args *args, +struct nfs4_sequence_res *res, +int cache_reply) +{ +int ret; +struct rpc_task *task; +struct nfs41_call_sync_data data = { + .clp = clp, + .seq_args = args, + .seq_res = res, + .cache_reply = cache_reply, + }; +struct rpc_task_setup task_setup = { + .rpc_client = clnt, + .rpc_message = msg, + .callback_ops = &nfs41_call_sync_ops, + .callback_data = &data + }; + + res->sr_slotid =NFS4_MAX_SLOT_TABLE ; + task =rpc_run_task (&task_setup); +if (IS_ERR (task)) + ret =PTR_ERR (task); +else { + ret = task->tk_status; +rpc_put_task (task); + } +return ret; +} +int _nfs4_call_sync_session (struct nfs_server *server,struct rpc_message *msg,struct nfs4_sequence_args *args,struct nfs4_sequence_res *res,int cache_reply) { -/* in preparation for setting up the sequence op */ -return rpc_call_sync (server->client, msg,0 ); +return nfs4_call_sync_sequence (server->nfs_client, server->client, + msg, args, res, cache_reply); }#endif /* CONFIG_NFS_V4_1 */
Signature · 1 line
1.6.2.1
PATCH v2 29/67 nfs41: find slot
In reply to Benny HalevyFind a free slot using bitmap-based allocation. Use the optimized ffz function to find a zero bit in the bitmap that indicates a free slot, starting the search from the 'lowest_free_slotid' position.
If found, mark the slot as used in the bitmap, get the slot's slotid and seqid, and update max_slotid to be used by the SEQUENCE operation.
Also, update lowest_free_slotid for next search.
If no free slot was found the caller has to wait for a free slot (outside the scope of this function)
--- fs/nfs/nfs4proc.c | 33 +++++++++++++++++++++++++++++++++ 1 files changed, 33 insertions(+), 0 deletions(-)
fs/nfs/nfs4proc.c +33 -0
@@ -273,6 +273,39 @@ static void renew_lease(const struct nfs_server *server, unsigned long timestamp#if defined(CONFIG_NFS_V4_1 ) +/* +* nfs4_find_slot - efficiently look for a free slot +* +* nfs4_find_slot looks for an unset bit in the used_slots bitmap. +* If found, we mark the slot as used, update the highest_used_slotid, +* and respectively set up the sequence operation args. +* The slot number is returned if found, or NFS4_MAX_SLOT_TABLE otherwise. +*/ +static u8 +nfs4_find_slot (struct nfs4_slot_table *tbl,struct rpc_task *task) +{ +int slotid; +u8 ret_id =NFS4_MAX_SLOT_TABLE ; +BUILD_BUG_ON ((u8 )NFS4_MAX_SLOT_TABLE != (int )NFS4_MAX_SLOT_TABLE ); + +spin_lock (&tbl->slot_tbl_lock); +dprintk ("--> %s used_slots=%04lx highest_used=%d max_slots=%d\n" , + __func__, tbl->used_slots[0 ], tbl->highest_used_slotid, + tbl->max_slots); + slotid =find_first_zero_bit (tbl->used_slots, tbl->max_slots); +if (slotid >= tbl->max_slots) + goto out; +__set_bit (slotid, tbl->used_slots); +if (slotid > tbl->highest_used_slotid) + tbl->highest_used_slotid = slotid; + ret_id = slotid; +out: +dprintk ("<-- %s used_slots=%04lx highest_used=%d slotid=%d \n" , + __func__, tbl->used_slots[0 ], tbl->highest_used_slotid, ret_id); +spin_unlock (&tbl->slot_tbl_lock); +return ret_id; +} + static int nfs41_setup_sequence(struct nfs4_session *session, struct nfs4_sequence_args *args, struct nfs4_sequence_res *res,
Signature · 1 line
1.6.2.1
PATCH v2 30/67 nfs41: setup_sequence method
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Allocate a slot in the session slot table and set the sequence op arguments.
Called at the rpc prepare stage.
Add a status to nfs41_sequence_res, initialize it to one so that we catch rpc level failures which do not go through decode_sequence which sets the new status field.
Note that upon an rpc level failure, we don't know if the server processed the sequence operation or not. Proceed as if the server did process the sequence operation.
As per 11-14-08 review
Otherwise there's a race (we've hit) with nfs4_free_slot where nfs41_setup_sequence sees a full slot table, unlocks slot_tbl_lock, nfs4_free_slots happen concurrently and call rpc_wake_up_next where there's nobody to wake up yet, context goes back to nfs41_setup_sequence which goes to sleep when the slot table is actually empty now and there's no-one to wake it up anymore.
--- fs/nfs/nfs4_fs.h | 10 ++++++++++ fs/nfs/nfs4proc.c | 34 ++++++++++++++++++++++++++++++++-- include/linux/nfs_xdr.h | 4 ++++ 3 files changed, 46 insertions(+), 2 deletions(-)
fs/nfs/nfs4_fs.h +10 -0
@@ -203,8 +203,18 @@ extern int nfs4_proc_fs_locations(struct inode *dir, const struct qstr *name,extern struct nfs4_state_recovery_ops nfs4_reboot_recovery_ops;extern struct nfs4_state_recovery_ops nfs4_nograce_recovery_ops;#if defined(CONFIG_NFS_V4_1 ) +extern int nfs4_setup_sequence (struct nfs_client *clp, +struct nfs4_sequence_args *args,struct nfs4_sequence_res *res, +int cache_reply,struct rpc_task *task);extern void nfs4_destroy_session (struct nfs4_session *session);extern struct nfs4_session *nfs4_alloc_session (struct nfs_client *clp); +#else /* CONFIG_NFS_v4_1 */ +static inline int nfs4_setup_sequence (struct nfs_client *clp, +struct nfs4_sequence_args *args,struct nfs4_sequence_res *res, +int cache_reply,struct rpc_task *task) +{ +return 0 ; +}#endif /* CONFIG_NFS_V4_1 */ extern const u32 nfs4_fattr_bitmap[2 ];
fs/nfs/nfs4proc.c +32 -2
@@ -280,6 +280,8 @@ static void renew_lease(const struct nfs_server *server, unsigned long timestamp* If found, we mark the slot as used, update the highest_used_slotid, * and respectively set up the sequence operation args. * The slot number is returned if found, or NFS4_MAX_SLOT_TABLE otherwise. +* +* Note: must be called with under the slot_tbl_lock. */ static u8 nfs4_find_slot (struct nfs4_slot_table *tbl,struct rpc_task *task)
@@ -288,7 +290,6 @@ nfs4_find_slot(struct nfs4_slot_table *tbl, struct rpc_task *task)u8 ret_id =NFS4_MAX_SLOT_TABLE ;BUILD_BUG_ON ((u8 )NFS4_MAX_SLOT_TABLE != (int )NFS4_MAX_SLOT_TABLE ); -spin_lock (&tbl->slot_tbl_lock);dprintk ("--> %s used_slots=%04lx highest_used=%d max_slots=%d\n" , __func__, tbl->used_slots[0 ], tbl->highest_used_slotid, tbl->max_slots);
@@ -302,7 +303,6 @@ nfs4_find_slot(struct nfs4_slot_table *tbl, struct rpc_task *task) out:dprintk ("<-- %s used_slots=%04lx highest_used=%d slotid=%d \n" , __func__, tbl->used_slots[0 ], tbl->highest_used_slotid, ret_id); -spin_unlock (&tbl->slot_tbl_lock);return ret_id; }
@@ -312,12 +312,42 @@ static int nfs41_setup_sequence(struct nfs4_session *session,int cache_reply, struct rpc_task *task) { + struct nfs4_slot *slot; +struct nfs4_slot_table *tbl; +u8 slotid; + +dprintk ("--> %s\n" , __func__);/* slot already allocated? */ if (res->sr_slotid !=NFS4_MAX_SLOT_TABLE )return 0 ;memset (res,0 ,sizeof (*res)); res->sr_slotid =NFS4_MAX_SLOT_TABLE ; + tbl = &session->fc_slot_table; + +spin_lock (&tbl->slot_tbl_lock); + slotid =nfs4_find_slot (tbl, task); +if (slotid ==NFS4_MAX_SLOT_TABLE ) { +rpc_sleep_on (&tbl->slot_tbl_waitq, task,NULL ); +spin_unlock (&tbl->slot_tbl_lock); +dprintk ("<-- %s: no free slots\n" , __func__); +return -EAGAIN ; + } +spin_unlock (&tbl->slot_tbl_lock); + + slot = tbl->slots + slotid; + args->sa_slotid = slotid; + args->sa_cache_this = cache_reply; + +dprintk ("<-- %s slotid=%d seqid=%d\n" , __func__, slotid, slot->seq_nr); + + res->sr_slotid = slotid; + res->sr_renewal_time = jiffies; +/* +* sr_status is only set in decode_sequence, and so will remain +* set to 1 if an rpc level failure occurs. +*/ + res->sr_status =1 ;return 0 ; }
include/linux/nfs_xdr.h +4 -0
@@ -163,11 +163,15 @@ struct nfs4_slot {struct nfs4_sequence_args {struct nfs4_session *sa_session; +u8 sa_slotid; +u8 sa_cache_this; };struct nfs4_sequence_res {struct nfs4_session *sr_session;u8 sr_slotid;/* slot used to send request */ +unsigned long sr_renewal_time; +int sr_status;/* sequence operation status */ };/*
Signature · 1 line
1.6.2.1
PATCH v2 31/67 nfs41: free slot
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Free a slot in the slot table.
Mark the slot as free in the bitmap-based allocation table by clearing a bit corresponding to the slotid.
Update lowest_free_slotid if freed slotid is lower than that. Update highest_used_slotid. In the case the freed slotid equals the highest_used_slotid, scan downwards for the next highest used slotid using the optimized fls* functions.
Finally, wake up thread waiting on slot_tbl_waitq for a free slot to become available.
While at it, obliterate lowest_free_slotid and fix-up related comments. As per review comment 21/85.
While at it, fix-up function comment.
Part of review comment 22/85.
Otherwise there's a race (we've hit) with nfs4_free_slot where nfs41_setup_sequence sees a full slot table, unlocks slot_tbl_lock, nfs4_free_slots happen concurrently and call rpc_wake_up_next where there's nobody to wake up yet, context goes back to nfs41_setup_sequence which goes to sleep when the slot table is actually empty now and there's no-one to wake it up anymore.
--- fs/nfs/nfs4proc.c | 36 ++++++++++++++++++++++++++++++++++++ 1 files changed, 36 insertions(+), 0 deletions(-)
fs/nfs/nfs4proc.c +36 -0
@@ -274,6 +274,42 @@ static void renew_lease(const struct nfs_server *server, unsigned long timestamp#if defined(CONFIG_NFS_V4_1 )/* +* nfs4_free_slot - free a slot and efficiently update slot table. +* +* freeing a slot is trivially done by clearing its respective bit +* in the bitmap. +* If the freed slotid equals highest_used_slotid we want to update it +* so that the server would be able to size down the slot table if needed, +* otherwise we know that the highest_used_slotid is still in use. +* When updating highest_used_slotid there may be "holes" in the bitmap +* so we need to scan down from highest_used_slotid to 0 looking for the now +* highest slotid in use. +* If none found, highest_used_slotid is set to -1. +*/ +static void +nfs4_free_slot (struct nfs4_slot_table *tbl,u8 free_slotid) +{ +int slotid = free_slotid; + +spin_lock (&tbl->slot_tbl_lock); +/* clear used bit in bitmap */ +__clear_bit (slotid, tbl->used_slots); + +/* update highest_used_slotid when it is freed */ +if (slotid == tbl->highest_used_slotid) { + slotid =find_last_bit (tbl->used_slots, tbl->max_slots); +if (slotid >=0 && slotid < tbl->max_slots) + tbl->highest_used_slotid = slotid; +else + tbl->highest_used_slotid =-1 ; + } +rpc_wake_up_next (&tbl->slot_tbl_waitq); +spin_unlock (&tbl->slot_tbl_lock); +dprintk ("%s: free_slotid %u highest_used_slotid %d\n" , __func__, + free_slotid, tbl->highest_used_slotid); +} + +/* * nfs4_find_slot - efficiently look for a free slot * * nfs4_find_slot looks for an unset bit in the used_slots bitmap.
Signature · 1 line
1.6.2.1
PATCH v2 32/67 nfs41: nfs41_sequence_free_slot
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
[from nfs41: separate free slot from sequence done]
Don't free the slot until after all rpc_restart_calls have completed. Session reset will require more work.
As noted by Trond, since we're using rpc_wake_up_next rather than rpc_wake_up() we must always wake up the next task in the queue either by going through nfs4_free_slot, or just calling rpc_wake_up_next if no slot is to be freed.
--- fs/nfs/internal.h | 14 ++++++++++++++ fs/nfs/nfs4proc.c | 21 +++++++++++++++++++++ 2 files changed, 35 insertions(+), 0 deletions(-)
fs/nfs/internal.h +14 -0
@@ -230,6 +230,20 @@ static inline int nfs4_has_session(const struct nfs_client *clp)return 0 ; } +#ifdef CONFIG_NFS_V4_1 +extern void nfs41_sequence_free_slot (const struct nfs_client *, +struct nfs4_sequence_res *res); +#endif /* CONFIG_NFS_V4_1 */ + +static inline void nfs4_sequence_free_slot (const struct nfs_client *clp, +struct nfs4_sequence_res *res) +{ +#ifdef CONFIG_NFS_V4_1 +if (nfs4_has_session (clp)) +nfs41_sequence_free_slot (clp, res); +#endif /* CONFIG_NFS_V4_1 */ +} +/* * Determine the device name as a string */
fs/nfs/nfs4proc.c +21 -0
@@ -309,6 +309,27 @@ nfs4_free_slot(struct nfs4_slot_table *tbl, u8 free_slotid) free_slotid, tbl->highest_used_slotid); } +void nfs41_sequence_free_slot (const struct nfs_client *clp, +struct nfs4_sequence_res *res) +{ +struct nfs4_slot_table *tbl; + +if (!nfs4_has_session (clp)) { +dprintk ("%s: No session\n" , __func__); +return ; + } + tbl = &clp->cl_session->fc_slot_table; +if (res->sr_slotid ==NFS4_MAX_SLOT_TABLE ) { +dprintk ("%s: No slot\n" , __func__); +/* just wake up the next guy waiting since +* we may have not consumed a slot after all */ +rpc_wake_up_next (&tbl->slot_tbl_waitq); +return ; + } +nfs4_free_slot (tbl, res->sr_slotid); + res->sr_slotid =NFS4_MAX_SLOT_TABLE ; +} +/* * nfs4_find_slot - efficiently look for a free slot *
Signature · 1 line
1.6.2.1
PATCH v2 33/67 nfs41: nfs41_sequence_done
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Handle session level errors, update slot sequence id and sessions bookeeping, free slot.
Don't free the slot until after all rpc_restart_calls have completed. Session reset will require more work.
--- fs/nfs/nfs4proc.c | 58 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 58 insertions(+), 0 deletions(-)
fs/nfs/nfs4proc.c +58 -0
@@ -330,6 +330,46 @@ void nfs41_sequence_free_slot(const struct nfs_client *clp, res->sr_slotid =NFS4_MAX_SLOT_TABLE ; } +static void nfs41_sequence_done (struct nfs_client *clp, +struct nfs4_sequence_res *res, +int rpc_status) +{ +unsigned long timestamp; +struct nfs4_slot_table *tbl; +struct nfs4_slot *slot; + +/* +* sr_status remains 1 if an RPC level error occurred. The server +* may or may not have processed the sequence operation.. +* Proceed as if the server received and processed the sequence +* operation. +*/ +if (res->sr_status ==1 ) + res->sr_status =NFS_OK ; + +/* -ERESTARTSYS can result in skipping nfs41_sequence_setup */ +if (res->sr_slotid ==NFS4_MAX_SLOT_TABLE ) + goto out; + + tbl = &clp->cl_session->fc_slot_table; + slot = tbl->slots + res->sr_slotid; + +if (res->sr_status ==0 ) { +/* Update the slot's sequence and clientid lease timer */ + ++slot->seq_nr; + timestamp = res->sr_renewal_time; +spin_lock (&clp->cl_lock); +if (time_before (clp->cl_last_renewal, timestamp)) + clp->cl_last_renewal = timestamp; +spin_unlock (&clp->cl_lock); +return ; + } +out: +/* The session may be reset by one of the error handlers. */ +dprintk ("%s: Error %d free the slot \n" , __func__, res->sr_status); +nfs41_sequence_free_slot (clp, res); +} +/* * nfs4_find_slot - efficiently look for a free slot *
@@ -515,6 +555,24 @@ int _nfs4_call_sync(struct nfs_server *server, (server)->nfs_client->cl_call_sync ((server), (msg), &(args)->seq_args, \ &(res)->seq_res, (cache_reply)) +static void nfs4_sequence_done (const struct nfs_server *server, +struct nfs4_sequence_res *res,int rpc_status) +{ +#ifdef CONFIG_NFS_V4_1 +if (nfs4_has_session (server->nfs_client)) +nfs41_sequence_done (server->nfs_client, res, rpc_status); +#endif /* CONFIG_NFS_V4_1 */ +} + +/* no restart, therefore free slot here */ +static void nfs4_sequence_done_free_slot (const struct nfs_server *server, +struct nfs4_sequence_res *res, +int rpc_status) +{ +nfs4_sequence_done (server, res, rpc_status); +nfs4_sequence_free_slot (server->nfs_client, res); +} +static void update_changeattr (struct inode *dir,struct nfs4_change_info *cinfo) {struct nfs_inode *nfsi =NFS_I (dir);
Signature · 1 line
1.6.2.1
PATCH v2 34/67 nfs41: nfs41_call_sync_done
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Implement nfs4.1 synchronous rpc_call_done method that essentially just calls nfs4_sequence_done, that turns around and calls nfs41_sequence_done for minorversion1 rpcs.
--- fs/nfs/nfs4proc.c | 9 +++++++++ 1 files changed, 9 insertions(+), 0 deletions(-)
fs/nfs/nfs4proc.c +9 -0
@@ -492,8 +492,17 @@ static void nfs41_call_sync_prepare(struct rpc_task *task, void *calldata)rpc_call_start (task); } +static void nfs41_call_sync_done (struct rpc_task *task,void *calldata) +{ +struct nfs41_call_sync_data *data = calldata; + +nfs41_sequence_done (data->clp, data->seq_res, task->tk_status); +nfs41_sequence_free_slot (data->clp, data->seq_res); +} +struct rpc_call_ops nfs41_call_sync_ops = { .rpc_call_prepare = nfs41_call_sync_prepare, + .rpc_call_done = nfs41_call_sync_done, }; static int nfs4_call_sync_sequence(struct nfs_client *clp,
Signature · 1 line
1.6.2.1
PATCH v2 35/67 nfs41: close sequence setup/done support
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Separate nfs4_close calls from nfs41: sequence setup/done support Call nfs4_sequence_done from respective rpc_call_done methods.
Note that we need to pass a pointer to the nfs_server in calls data for passing on to nfs4_sequence_done.
--- fs/nfs/nfs4proc.c | 8 +++++++- 1 files changed, 7 insertions(+), 1 deletions(-)
fs/nfs/nfs4proc.c +7 -1
@@ -1630,6 +1630,7 @@ static void nfs4_close_done(struct rpc_task *task, void *data)struct nfs4_state *state = calldata->state;struct nfs_server *server =NFS_SERVER (calldata->inode); +nfs4_sequence_done (server, &calldata->res.seq_res, task->tk_status);if (RPC_ASSASSINATED (task))return ;/* hmm. we are done with the inode, and in the process of freeing
@@ -1652,6 +1653,7 @@ static void nfs4_close_done(struct rpc_task *task, void *data)return ; } } +nfs4_sequence_free_slot (server->nfs_client, &calldata->res.seq_res);nfs_refresh_inode (calldata->inode, calldata->res.fattr); }
@@ -1692,6 +1694,10 @@ static void nfs4_close_prepare(struct rpc_task *task, void *data) calldata->arg.fmode =FMODE_WRITE ; } calldata->timestamp = jiffies; +if (nfs4_setup_sequence ((NFS_SERVER (calldata->inode))->nfs_client, + &calldata->arg.seq_args, &calldata->res.seq_res, +1 , task)) +return ;rpc_call_start (task); }
@@ -1731,7 +1737,7 @@ int nfs4_do_close(struct path *path, struct nfs4_state *state, int wait) };int status = -ENOMEM ; - calldata =kmalloc (sizeof (*calldata),GFP_KERNEL ); + calldata =kzalloc (sizeof (*calldata),GFP_KERNEL );if (calldata ==NULL ) goto out; calldata->inode = state->inode;
Signature · 1 line
1.6.2.1
PATCH v2 36/67 nfs41: open sequence setup/done support
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Separate nfs4_open calls from nfs41: sequence setup/done support Call nfs4_sequence_done from respective rpc_call_done methods.
Note that we need to pass a pointer to the nfs_server in calls data for passing on to nfs4_sequence_done.
--- fs/nfs/nfs4proc.c | 8 ++++++++ 1 files changed, 8 insertions(+), 0 deletions(-)
fs/nfs/nfs4proc.c +8 -0
@@ -1241,6 +1241,10 @@ static void nfs4_open_prepare(struct rpc_task *task, void *calldata)nfs_copy_fh (&data->o_res.fh, data->o_arg.fh); } data->timestamp = jiffies; +if (nfs4_setup_sequence (data->o_arg.server->nfs_client, + &data->o_arg.seq_args, + &data->o_res.seq_res,1 , task)) +return ;rpc_call_start (task);return ; out_no_action:
@@ -1253,6 +1257,10 @@ static void nfs4_open_done(struct rpc_task *task, void *calldata)struct nfs4_opendata *data = calldata; data->rpc_status = task->tk_status; + +nfs4_sequence_done_free_slot (data->o_arg.server, &data->o_res.seq_res, + task->tk_status); +if (RPC_ASSASSINATED (task))return ;if (task->tk_status ==0 ) {
Signature · 1 line
1.6.2.1
PATCH v2 37/67 nfs41: lock sequence setup/done support
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Separate nfs4_lock calls from nfs41: sequence setup/done support Call nfs4_sequence_done from respective rpc_call_done methods.
Note that we need to pass a pointer to the nfs_server in calls data for passing on to nfs4_sequence_done.
--- fs/nfs/nfs4proc.c | 8 ++++++++ 1 files changed, 8 insertions(+), 0 deletions(-)
fs/nfs/nfs4proc.c +8 -0
@@ -3691,6 +3691,7 @@ struct nfs4_lockdata {unsigned long timestamp;int rpc_status;int cancelled; +struct nfs_server *server; }; static struct nfs4_lockdata *nfs4_alloc_lockdata(struct file_lock *fl,
@@ -3718,6 +3719,7 @@ static struct nfs4_lockdata *nfs4_alloc_lockdata(struct file_lock *fl, p->res.lock_seqid = p->arg.lock_seqid; p->res.seq_res.sr_slotid =NFS4_MAX_SLOT_TABLE ; p->lsp = lsp; + p->server = server;atomic_inc (&lsp->ls_count); p->ctx =get_nfs_open_context (ctx);memcpy (&p->fl, fl,sizeof (p->fl));
@@ -3747,6 +3749,9 @@ static void nfs4_lock_prepare(struct rpc_task *task, void *calldata) }else data->arg.new_lock_owner =0 ; data->timestamp = jiffies; +if (nfs4_setup_sequence (data->server->nfs_client, &data->arg.seq_args, + &data->res.seq_res,1 , task)) +return ;rpc_call_start (task);dprintk ("%s: done!, ret = %d\n" , __func__, data->rpc_status); }
@@ -3757,6 +3762,9 @@ static void nfs4_lock_done(struct rpc_task *task, void *calldata)dprintk ("%s: begin!\n" , __func__); +nfs4_sequence_done_free_slot (data->server, &data->res.seq_res, + task->tk_status); + data->rpc_status = task->tk_status;if (RPC_ASSASSINATED (task)) goto out;
Signature · 1 line
1.6.2.1
PATCH v2 38/67 nfs41: locku sequence setup/done support
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Separate nfs4_locku calls from nfs41: sequence setup/done support Call nfs4_sequence_done from respective rpc_call_done methods.
Note that we need to pass a pointer to the nfs_server in calls data for passing on to nfs4_sequence_done.
--- fs/nfs/nfs4proc.c | 10 +++++++++- 1 files changed, 9 insertions(+), 1 deletions(-)
fs/nfs/nfs4proc.c +9 -1
@@ -3536,7 +3536,7 @@ static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl,struct nfs4_unlockdata *p;struct inode *inode = lsp->ls_state->inode; - p =kmalloc (sizeof (*p),GFP_KERNEL ); + p =kzalloc (sizeof (*p),GFP_KERNEL );if (p ==NULL )return NULL ; p->arg.fh =NFS_FH (inode);
@@ -3567,6 +3567,8 @@ static void nfs4_locku_done(struct rpc_task *task, void *data) {struct nfs4_unlockdata *calldata = data; +nfs4_sequence_done (calldata->server, &calldata->res.seq_res, + task->tk_status);if (RPC_ASSASSINATED (task))return ;switch (task->tk_status) {
@@ -3585,6 +3587,8 @@ static void nfs4_locku_done(struct rpc_task *task, void *data)if (nfs4_async_handle_error (task, calldata->server,NULL ) == -EAGAIN )rpc_restart_call (task); } +nfs4_sequence_free_slot (calldata->server->nfs_client, + &calldata->res.seq_res); }static void nfs4_locku_prepare (struct rpc_task *task,void *data)
@@ -3599,6 +3603,10 @@ static void nfs4_locku_prepare(struct rpc_task *task, void *data)return ; } calldata->timestamp = jiffies; +if (nfs4_setup_sequence (calldata->server->nfs_client, + &calldata->arg.seq_args, + &calldata->res.seq_res,1 , task)) +return ;rpc_call_start (task); }
Signature · 1 line
1.6.2.1
PATCH v2 39/67 nfs41: unlink sequence setup/done support
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Implement the rpc_call_prepare methods for asynchronuos nfs rpcs, call nfs41_setup_sequence from respective rpc_call_validate_args methods.
Call nfs4_sequence_done from respective rpc_call_done methods.
Note that we need to pass a pointer to the nfs_server in calls data for passing on to nfs4_sequence_done.
--- fs/nfs/nfs4proc.c | 2 ++ fs/nfs/unlink.c | 17 +++++++++++++++++ 2 files changed, 19 insertions(+), 0 deletions(-)
fs/nfs/nfs4proc.c +2 -0
@@ -2424,8 +2424,10 @@ static int nfs4_proc_unlink_done(struct rpc_task *task, struct inode *dir) {struct nfs_removeres *res = task->tk_msg.rpc_resp; +nfs4_sequence_done (res->server, &res->seq_res, task->tk_status);if (nfs4_async_handle_error (task, res->server,NULL ) == -EAGAIN )return 0 ; +nfs4_sequence_free_slot (res->server->nfs_client, &res->seq_res);update_changeattr (dir, &res->cinfo);nfs_post_op_update_inode (dir, &res->dir_attr);return 1 ;
fs/nfs/unlink.c +17 -0
@@ -15,6 +15,7 @@#include <linux/wait.h> #include "internal.h" +#include "nfs4_fs.h" struct nfs_unlinkdata {struct hlist_node list;
@@ -102,9 +103,25 @@ static void nfs_async_unlink_release(void *calldata)nfs_sb_deactive (sb); } +#if defined(CONFIG_NFS_V4_1 ) +void nfs_unlink_prepare (struct rpc_task *task,void *calldata) +{ +struct nfs_unlinkdata *data = calldata; +struct nfs_server *server =NFS_SERVER (data->dir); + +if (nfs4_setup_sequence (server->nfs_client, &data->args.seq_args, + &data->res.seq_res,1 , task)) +return ; +rpc_call_start (task); +} +#endif /* CONFIG_NFS_V4_1 */ +static const struct rpc_call_ops nfs_unlink_ops = { .rpc_call_done = nfs_async_unlink_done, .rpc_release = nfs_async_unlink_release, +#if defined(CONFIG_NFS_V4_1) + .rpc_call_prepare = nfs_unlink_prepare, +#endif /* CONFIG_NFS_V4_1 */ };static int nfs_do_call_unlink (struct dentry *parent,struct inode *dir,struct nfs_unlinkdata *data)
Signature · 1 line
1.6.2.1
PATCH v2 40/67 nfs41: read sequence setup/done support
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Implement the read rpc_call_prepare method for asynchronuos nfs rpcs, call nfs41_setup_sequence from respective rpc_call_validate_args methods.
Call nfs4_sequence_done from respective rpc_call_done methods.
Note that we need to pass a pointer to the nfs_server in calls data for passing on to nfs4_sequence_done.
--- fs/nfs/direct.c | 3 +++ fs/nfs/internal.h | 3 +++ fs/nfs/nfs4proc.c | 5 +++++ fs/nfs/read.c | 30 ++++++++++++++++++++++++++++-- 4 files changed, 39 insertions(+), 2 deletions(-)
fs/nfs/direct.c +3 -0
@@ -259,6 +259,9 @@ static void nfs_direct_read_release(void *calldata) }static const struct rpc_call_ops nfs_read_direct_ops = { +#if defined(CONFIG_NFS_V4_1) + .rpc_call_prepare = nfs_read_prepare, +#endif /* CONFIG_NFS_V4_1 */ .rpc_call_done = nfs_direct_read_result, .rpc_release = nfs_direct_read_release, };
fs/nfs/internal.h +3 -0
@@ -206,6 +206,9 @@ extern int nfs4_path_walk(struct nfs_server *server, const char *path);#endif +/* read.c */ +extern void nfs_read_prepare (struct rpc_task *task,void *calldata); +/* nfs4proc.c */ extern int _nfs4_call_sync(struct nfs_server *server, struct rpc_message *msg,
fs/nfs/nfs4proc.c +5 -0
@@ -2864,6 +2864,11 @@ static int nfs4_read_done(struct rpc_task *task, struct nfs_read_data *data) {struct nfs_server *server =NFS_SERVER (data->inode); +dprintk ("--> %s\n" , __func__); + +/* nfs4_sequence_free_slot called in the read rpc_call_done */ +nfs4_sequence_done (server, &data->res.seq_res, task->tk_status); +if (nfs4_async_handle_error (task, server, data->args.context->state) == -EAGAIN ) {rpc_restart_call (task);return -EAGAIN ;
fs/nfs/read.c +28 -2
@@ -22,6 +22,7 @@#include <asm/system.h> +#include "nfs4_fs.h" #include "internal.h" #include "iostat.h" #include "fscache.h"
@@ -358,19 +359,25 @@ static void nfs_readpage_retry(struct rpc_task *task, struct nfs_read_data *datastruct nfs_readres *resp = &data->res;if (resp->eof || resp->count == argp->count) -return ; + goto out;/* This is a short read! */ nfs_inc_stats (data->inode,NFSIOS_SHORTREAD );/* Has the server at least made some progress? */ if (resp->count ==0 ) -return ; + goto out;/* Yes, so retry the read at the end of the data */ argp->offset += resp->count; argp->pgbase += resp->count; argp->count -= resp->count;rpc_restart_call (task); +return ; +out: +nfs4_sequence_free_slot (NFS_SERVER (data->inode)->nfs_client, + &data->res.seq_res); +return ; + }/*
@@ -407,7 +414,23 @@ static void nfs_readpage_release_partial(void *calldata)nfs_readdata_release (calldata); } +#if defined(CONFIG_NFS_V4_1 ) +void nfs_read_prepare (struct rpc_task *task,void *calldata) +{ +struct nfs_read_data *data = calldata; + +if (nfs4_setup_sequence (NFS_SERVER (data->inode)->nfs_client, + &data->args.seq_args, &data->res.seq_res, +0 , task)) +return ; +rpc_call_start (task); +} +#endif /* CONFIG_NFS_V4_1 */ +static const struct rpc_call_ops nfs_read_partial_ops = { +#if defined(CONFIG_NFS_V4_1) + .rpc_call_prepare = nfs_read_prepare, +#endif /* CONFIG_NFS_V4_1 */ .rpc_call_done = nfs_readpage_result_partial, .rpc_release = nfs_readpage_release_partial, };
@@ -471,6 +494,9 @@ static void nfs_readpage_release_full(void *calldata) }static const struct rpc_call_ops nfs_read_full_ops = { +#if defined(CONFIG_NFS_V4_1) + .rpc_call_prepare = nfs_read_prepare, +#endif /* CONFIG_NFS_V4_1 */ .rpc_call_done = nfs_readpage_result_full, .rpc_release = nfs_readpage_release_full, };
Signature · 1 line
1.6.2.1
PATCH v2 41/67 nfs41 write sequence setup done support
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Separate write calls from nfs41: sequence setup/done support
Implement the write rpc_call_prepare method for asynchronuos nfs rpcs, call nfs41_setup_sequence from respective rpc_call_validate_args methods.
Call nfs4_sequence_done from respective rpc_call_done methods.
Note that we need to pass a pointer to the nfs_server in calls data for passing on to nfs4_sequence_done.
[nfs41: separate free slot from sequence done
--- fs/nfs/direct.c | 3 +++ fs/nfs/internal.h | 3 +++ fs/nfs/nfs4proc.c | 4 ++++ fs/nfs/write.c | 22 ++++++++++++++++++++++ 4 files changed, 32 insertions(+), 0 deletions(-)
fs/nfs/direct.c +3 -0
@@ -676,6 +676,9 @@ out_unlock: }static const struct rpc_call_ops nfs_write_direct_ops = { +#if defined(CONFIG_NFS_V4_1) + .rpc_call_prepare = nfs_write_prepare, +#endif /* CONFIG_NFS_V4_1 */ .rpc_call_done = nfs_direct_write_result, .rpc_release = nfs_direct_write_release, };
fs/nfs/internal.h +3 -0
@@ -209,6 +209,9 @@ extern int nfs4_path_walk(struct nfs_server *server,/* read.c */ extern void nfs_read_prepare (struct rpc_task *task,void *calldata); +/* write.c */ +extern void nfs_write_prepare (struct rpc_task *task,void *calldata); +/* nfs4proc.c */ extern int _nfs4_call_sync(struct nfs_server *server, struct rpc_message *msg,
fs/nfs/nfs4proc.c +4 -0
@@ -2890,6 +2890,10 @@ static int nfs4_write_done(struct rpc_task *task, struct nfs_write_data *data) {struct inode *inode = data->inode; +/* slot is freed in nfs_writeback_done */ +nfs4_sequence_done (NFS_SERVER (inode), &data->res.seq_res, + task->tk_status); +if (nfs4_async_handle_error (task,NFS_SERVER (inode), data->args.context->state) == -EAGAIN ) {rpc_restart_call (task);return -EAGAIN ;
fs/nfs/write.c +22 -0
@@ -25,6 +25,7 @@#include "delegation.h" #include "internal.h" #include "iostat.h" +#include "nfs4_fs.h" #define NFSDBG_FACILITY NFSDBG_PAGECACHE
@@ -1050,7 +1051,23 @@ out:nfs_writedata_release (calldata); } +#if defined(CONFIG_NFS_V4_1 ) +void nfs_write_prepare (struct rpc_task *task,void *calldata) +{ +struct nfs_write_data *data = calldata; +struct nfs_client *clp = (NFS_SERVER (data->inode))->nfs_client; + +if (nfs4_setup_sequence (clp, &data->args.seq_args, + &data->res.seq_res,1 , task)) +return ; +rpc_call_start (task); +} +#endif /* CONFIG_NFS_V4_1 */ +static const struct rpc_call_ops nfs_write_partial_ops = { +#if defined(CONFIG_NFS_V4_1) + .rpc_call_prepare = nfs_write_prepare, +#endif /* CONFIG_NFS_V4_1 */ .rpc_call_done = nfs_writeback_done_partial, .rpc_release = nfs_writeback_release_partial, };
@@ -1113,6 +1130,9 @@ remove_request: }static const struct rpc_call_ops nfs_write_full_ops = { +#if defined(CONFIG_NFS_V4_1) + .rpc_call_prepare = nfs_write_prepare, +#endif /* CONFIG_NFS_V4_1 */ .rpc_call_done = nfs_writeback_done_full, .rpc_release = nfs_writeback_release_full, };
@@ -1195,6 +1215,8 @@ int nfs_writeback_done(struct rpc_task *task, struct nfs_write_data *data)/* Can't do anything about it except throw an error. */ task->tk_status = -EIO ; } +nfs4_sequence_free_slot (NFS_SERVER (data->inode)->nfs_client, + &data->res.seq_res);return 0 ; }
Signature · 1 line
1.6.2.1
PATCH v2 42/67 nfs41 commit sequence setup done support
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Separate commit calls from nfs41: sequence setup/done support
Implement the commit rpc_call_prepare method for asynchronuos nfs rpcs, call nfs41_setup_sequence from respective rpc_call_validate_args methods.
Call nfs4_sequence_done from respective rpc_call_done methods.
Note that we need to pass a pointer to the nfs_server in calls data for passing on to nfs4_sequence_done.
--- fs/nfs/direct.c | 3 +++ fs/nfs/nfs4proc.c | 4 ++++ fs/nfs/write.c | 3 +++ 3 files changed, 10 insertions(+), 0 deletions(-)
fs/nfs/direct.c +3 -0
@@ -538,6 +538,9 @@ static void nfs_direct_commit_release(void *calldata) }static const struct rpc_call_ops nfs_commit_direct_ops = { +#if defined(CONFIG_NFS_V4_1) + .rpc_call_prepare = nfs_write_prepare, +#endif /* CONFIG_NFS_V4_1 */ .rpc_call_done = nfs_direct_commit_result, .rpc_release = nfs_direct_commit_release, };
fs/nfs/nfs4proc.c +4 -0
@@ -2920,10 +2920,14 @@ static int nfs4_commit_done(struct rpc_task *task, struct nfs_write_data *data) {struct inode *inode = data->inode; +nfs4_sequence_done (NFS_SERVER (inode), &data->res.seq_res, + task->tk_status);if (nfs4_async_handle_error (task,NFS_SERVER (inode),NULL ) == -EAGAIN ) {rpc_restart_call (task);return -EAGAIN ; } +nfs4_sequence_free_slot (NFS_SERVER (inode)->nfs_client, + &data->res.seq_res);nfs_refresh_inode (inode, data->res.fattr);return 0 ; }
fs/nfs/write.c +3 -0
@@ -1373,6 +1373,9 @@ static void nfs_commit_release(void *calldata) }static const struct rpc_call_ops nfs_commit_ops = { +#if defined(CONFIG_NFS_V4_1) + .rpc_call_prepare = nfs_write_prepare, +#endif /* CONFIG_NFS_V4_1 */ .rpc_call_done = nfs_commit_done, .rpc_release = nfs_commit_release, };
Signature · 1 line
1.6.2.1
PATCH v2 43/67 nfs41 delegreturn sequence setup done support
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Separate delegreturn calls from nfs41: sequence setup/done support
Implement the delegreturn rpc_call_prepare method for asynchronuos nfs rpcs, call nfs41_setup_sequence from respective rpc_call_validate_args methods.
Call nfs4_sequence_done from respective rpc_call_done methods.
Note that we need to pass a pointer to the nfs_server in calls data for passing on to nfs4_sequence_done.
--- fs/nfs/nfs4proc.c | 24 +++++++++++++++++++++++- 1 files changed, 23 insertions(+), 1 deletions(-)
fs/nfs/nfs4proc.c +23 -1
@@ -3363,6 +3363,10 @@ struct nfs4_delegreturndata {static void nfs4_delegreturn_done (struct rpc_task *task,void *calldata) {struct nfs4_delegreturndata *data = calldata; + +nfs4_sequence_done_free_slot (data->res.server, &data->res.seq_res, + task->tk_status); + data->rpc_status = task->tk_status;if (data->rpc_status ==0 )renew_lease (data->res.server, data->timestamp);
@@ -3373,7 +3377,25 @@ static void nfs4_delegreturn_release(void *calldata)kfree (calldata); } +#if defined(CONFIG_NFS_V4_1 ) +static void nfs4_delegreturn_prepare (struct rpc_task *task,void *data) +{ +struct nfs4_delegreturndata *d_data; + + d_data = (struct nfs4_delegreturndata *)data; + +if (nfs4_setup_sequence (d_data->res.server->nfs_client, + &d_data->args.seq_args, + &d_data->res.seq_res,1 , task)) +return ; +rpc_call_start (task); +} +#endif /* CONFIG_NFS_V4_1 */ +static const struct rpc_call_ops nfs4_delegreturn_ops = { +#if defined(CONFIG_NFS_V4_1) + .rpc_call_prepare = nfs4_delegreturn_prepare, +#endif /* CONFIG_NFS_V4_1 */ .rpc_call_done = nfs4_delegreturn_done, .rpc_release = nfs4_delegreturn_release, };
@@ -3395,7 +3417,7 @@ static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, co };int status =0 ; - data =kmalloc (sizeof (*data),GFP_KERNEL ); + data =kzalloc (sizeof (*data),GFP_KERNEL );if (data ==NULL )return -ENOMEM ; data->args.fhandle = &data->fh;
Signature · 1 line
1.6.2.1
PATCH v2 44/67 nfs41: exchange_id operation
In reply to Benny HalevyImplement the exchange_id operation conforming to
http://tools.ietf.org/html/draft-ietf-nfsv4-minorversion1-26
Unlike NFSv4.0, NFSv4.1 requires machine credentials. RPC_AUTH_GSS machine credentials will be passed into the kernel at mount time to be available for the exchange_id operation.
RPC_AUTH_UNIX root mounts can use the UNIX root credential. Store the root credential in the nfs_client struct.
Without a credential, NFSv4.1 state renewal fails.
--- fs/nfs/nfs4proc.c | 61 +++++++++++++++++++ fs/nfs/nfs4xdr.c | 141 ++++++++++++++++++++++++++++++++++++++++++++ include/linux/nfs4.h | 1 + include/linux/nfs_fs_sb.h | 6 ++ include/linux/nfs_xdr.h | 43 +++++++++++++ include/linux/nfsd/state.h | 1 - 6 files changed, 252 insertions(+), 1 deletions(-)
fs/nfs/nfs4proc.c +61 -0
@@ -48,6 +48,7 @@#include <linux/smp_lock.h> #include <linux/namei.h> #include <linux/mount.h> +#include <linux/module.h> #include "nfs4_fs.h" #include "delegation.h"
@@ -433,11 +434,13 @@ static int nfs41_setup_sequence(struct nfs4_session *session,spin_unlock (&tbl->slot_tbl_lock); slot = tbl->slots + slotid; + args->sa_session = session; args->sa_slotid = slotid; args->sa_cache_this = cache_reply;dprintk ("<-- %s slotid=%d seqid=%d\n" , __func__, slotid, slot->seq_nr); + res->sr_session = session; res->sr_slotid = slotid; res->sr_renewal_time = jiffies;/*
@@ -4131,6 +4134,64 @@ int nfs4_proc_fs_locations(struct inode *dir, const struct qstr *name, }#ifdef CONFIG_NFS_V4_1 +/* +* nfs4_proc_exchange_id() +* +* Since the clientid has expired, all compounds using sessions +* associated with the stale clientid will be returning +* NFS4ERR_BADSESSION in the sequence operation, and will therefore +* be in some phase of session reset. +*/ +static int nfs4_proc_exchange_id (struct nfs_client *clp,struct rpc_cred *cred) +{ +nfs4_verifier verifier; +struct nfs41_exchange_id_args args = { + .client = clp, + .flags = clp->cl_exchange_flags, + }; +struct nfs41_exchange_id_res res = { + .client = clp, + }; +int status; +struct rpc_message msg = { + .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_EXCHANGE_ID ], + .rpc_argp = &args, + .rpc_resp = &res, + .rpc_cred = cred, + }; +__be32 *p; + +dprintk ("--> %s\n" , __func__); +BUG_ON (clp ==NULL ); + p = (u32 *)verifier.data; + *p++ =htonl ((u32 )clp->cl_boot_time.tv_sec); + *p =htonl ((u32 )clp->cl_boot_time.tv_nsec); + args.verifier = &verifier; + +while (1 ) { + args.id_len =scnprintf (args.id,sizeof (args.id), +"%s/%s %u" , + clp->cl_ipaddr, +rpc_peeraddr2str (clp->cl_rpcclient, +RPC_DISPLAY_ADDR ), + clp->cl_id_uniquifier); + + status =rpc_call_sync (clp->cl_rpcclient, &msg,0 ); + +if (status !=NFS4ERR_CLID_INUSE ) +break ; + +if (signalled ()) +break ; + +if (++clp->cl_id_uniquifier ==0 ) +break ; + } + +dprintk ("<-- %s status= %d\n" , __func__, status); +return status; +} +/* Destroy the slot table */ static void nfs4_destroy_slot_table (struct nfs4_session *session) {
fs/nfs/nfs4xdr.c +141 -0
184 lines not on this page · raw message
include/linux/nfs4.h +1 -0
@@ -21,6 +21,7 @@#define NFS4_FHSIZE 128#define NFS4_MAXPATHLEN PATH_MAX#define NFS4_MAXNAMLEN NAME_MAX +#define NFS4_OPAQUE_LIMIT 1024#define NFS4_MAX_SESSIONID_LEN 16#define NFS4_ACCESS_READ 0x0001
include/linux/nfs_fs_sb.h +6 -0
@@ -78,6 +78,12 @@ struct nfs_client {#endif /* CONFIG_NFS_V4 */ #ifdef CONFIG_NFS_V4_1 +/* clientid returned from EXCHANGE_ID, used by session operations */ +u64 cl_ex_clid; +/* The sequence id to use for the next CREATE_SESSION */ +u32 cl_seqid; +/* The flags used for obtaining the clientid during EXCHANGE_ID */ +u32 cl_exchange_flags;struct nfs4_session *cl_session;/* sharred session */ #endif /* CONFIG_NFS_V4_1 */
include/linux/nfs_xdr.h +43 -0
49 lines not on this page · raw message
include/linux/nfsd/state.h +0 -1
@@ -41,7 +41,6 @@#include <linux/kref.h> #include <linux/sunrpc/clnt.h> -#define NFS4_OPAQUE_LIMIT 1024 typedef struct { u32 cl_boot; u32 cl_id;
Signature · 1 line
1.6.2.1
PATCH v2 45/67 nfs41: get_lease_time
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
get_lease_time uses the FSINFO rpc operation to
get the lease time attribute.
nfs4_get_lease_time() is only called from the state manager on session setup so don't recover from clientid or sequence level errors.
We do need to recover from NFS4ERR_DELAY or NFS4ERR_GRACE.
Use NFS4_POLL_RETRY_MIN - the Linux server returns NFS4ERR_DELAY when an upcall is needed to resolve an uncached export referenced by a file handle.
--- fs/nfs/nfs4proc.c | 94 +++++++++++++++++++++++++++++++++++++++++++++++ fs/nfs/nfs4xdr.c | 51 +++++++++++++++++++++++++ include/linux/nfs_xdr.h | 9 ++++ 3 files changed, 154 insertions(+), 0 deletions(-)
fs/nfs/nfs4proc.c +94 -0
@@ -4192,6 +4192,100 @@ static int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred)return status; } +struct nfs4_get_lease_time_data { +struct nfs4_get_lease_time_args *args; +struct nfs4_get_lease_time_res *res; +struct nfs_client *clp; +}; + +static void nfs4_get_lease_time_prepare (struct rpc_task *task, +void *calldata) +{ +int ret; +struct nfs4_get_lease_time_data *data = + (struct nfs4_get_lease_time_data *)calldata; + +dprintk ("--> %s\n" , __func__); +/* just setup sequence, do not trigger session recovery +since we're invoked within one */ + ret =nfs41_setup_sequence (data->clp->cl_session, + &data->args->la_seq_args, + &data->res->lr_seq_res,0 , task); + +BUG_ON (ret == -EAGAIN ); +rpc_call_start (task); +dprintk ("<-- %s\n" , __func__); +} + +/* +* Called from nfs4_state_manager thread for session setup, so don't recover +* from sequence operation or clientid errors. +*/ +static void nfs4_get_lease_time_done (struct rpc_task *task,void *calldata) +{ +struct nfs4_get_lease_time_data *data = + (struct nfs4_get_lease_time_data *)calldata; + +dprintk ("--> %s\n" , __func__); +nfs41_sequence_done (data->clp, &data->res->lr_seq_res, task->tk_status); +switch (task->tk_status) { +case -NFS4ERR_DELAY : +case -NFS4ERR_GRACE : +dprintk ("%s Retry: tk_status %d\n" , __func__, task->tk_status); +rpc_delay (task,NFS4_POLL_RETRY_MIN ); + task->tk_status =0 ; +rpc_restart_call (task); +return ; + } +nfs41_sequence_free_slot (data->clp, &data->res->lr_seq_res); +dprintk ("<-- %s\n" , __func__); +} + +struct rpc_call_ops nfs4_get_lease_time_ops = { + .rpc_call_prepare = nfs4_get_lease_time_prepare, + .rpc_call_done = nfs4_get_lease_time_done, +}; + +int nfs4_proc_get_lease_time (struct nfs_client *clp,struct nfs_fsinfo *fsinfo) +{ +struct rpc_task *task; +struct nfs4_get_lease_time_args args; +struct nfs4_get_lease_time_res res = { + .lr_fsinfo = fsinfo, + }; +struct nfs4_get_lease_time_data data = { + .args = &args, + .res = &res, + .clp = clp, + }; +struct rpc_message msg = { + .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GET_LEASE_TIME ], + .rpc_argp = &args, + .rpc_resp = &res, + }; +struct rpc_task_setup task_setup = { + .rpc_client = clp->cl_rpcclient, + .rpc_message = &msg, + .callback_ops = &nfs4_get_lease_time_ops, + .callback_data = &data + }; +int status; + + res.lr_seq_res.sr_slotid =NFS4_MAX_SLOT_TABLE ; +dprintk ("--> %s\n" , __func__); + task =rpc_run_task (&task_setup); + +if (IS_ERR (task)) + status =PTR_ERR (task); +else { + status = task->tk_status; +rpc_put_task (task); + } +dprintk ("<-- %s return %d\n" , __func__, status); + +return status; +} +/* Destroy the slot table */ static void nfs4_destroy_slot_table (struct nfs4_session *session) {
fs/nfs/nfs4xdr.c +51 -0
75 lines not on this page · raw message
include/linux/nfs_xdr.h +9 -0
@@ -174,6 +174,15 @@ struct nfs4_sequence_res {int sr_status;/* sequence operation status */ }; +struct nfs4_get_lease_time_args { +struct nfs4_sequence_args la_seq_args; +}; + +struct nfs4_get_lease_time_res { +struct nfs_fsinfo *lr_fsinfo; +struct nfs4_sequence_res lr_seq_res; +}; +/* * Arguments to the open call. */
Signature · 1 line
1.6.2.1
PATCH v2 46/67 nfs41: create_session operation
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Implement the create_session operation conforming to
http://tools.ietf.org/html/draft-ietf-nfsv4-minorversion1-26
Set the real fore channel max operations to preserve server resources.
Note: If the server returns < NFS4_MAX_OPS, the client will very soon get an NFS4ERR_TOO_MANY_OPS. A later patch will handle this.
Set the max_rqst_sz and max_resp_sz to PAGE_SIZE - we preallocate the buffers.
Set the back channel max_resp_sz_cached to zero to force the client to always set csa_cachethis to FALSE because the current implementation of the back channel DRC only supports caching the CB_SEQUENCE operation.
The client back channel server supports one slot, and desires 2 operations per compound.
Use the struct nfs_client cl_rpcclient.
--- fs/nfs/nfs4proc.c | 172 ++++++++++++++++++++++++++++++++++++++++++ fs/nfs/nfs4xdr.c | 189 +++++++++++++++++++++++++++++++++++++++++++++++ include/linux/nfs4.h | 10 +++ include/linux/nfs_xdr.h | 12 +++ 4 files changed, 383 insertions(+), 0 deletions(-)
fs/nfs/nfs4proc.c +172 -0
@@ -54,6 +54,7 @@#include "delegation.h" #include "internal.h" #include "iostat.h" +#include "callback.h" #define NFSDBG_FACILITY NFSDBG_PROC
@@ -4286,6 +4287,50 @@ int nfs4_proc_get_lease_time(struct nfs_client *clp, struct nfs_fsinfo *fsinfo)return status; } +/* +* Initialize slot table +*/ +static int nfs4_init_slot_table (struct nfs4_session *session) +{ +struct nfs4_slot_table *tbl = &session->fc_slot_table; +int i, max_slots = session->fc_attrs.max_reqs; +struct nfs4_slot *slot; +int ret = -ENOMEM ; + +BUG_ON (max_slots >NFS4_MAX_SLOT_TABLE ); + +dprintk ("--> %s: max_reqs=%u\n" , __func__, + session->fc_attrs.max_reqs); + + slot =kcalloc (max_slots,sizeof (struct nfs4_slot ),GFP_KERNEL ); +if (!slot) + goto out; +for (i =0 ; i < max_slots; ++i) + slot[i].seq_nr =1 ; + ret =0 ; + +spin_lock (&tbl->slot_tbl_lock); +if (tbl->slots !=NULL ) { +spin_unlock (&tbl->slot_tbl_lock); +dprintk ("%s: slot table already initialized. tbl=%p slots=%p\n" , + __func__, tbl, tbl->slots); +WARN_ON (1 ); + goto out_free; + } + tbl->max_slots = max_slots; + tbl->slots = slot; + tbl->highest_used_slotid =-1 ;/* no slot is currently used */ +spin_unlock (&tbl->slot_tbl_lock); +dprintk ("%s: tbl=%p slots=%p max_slots=%d\n" , __func__, + tbl, tbl->slots, tbl->max_slots); +out: +dprintk ("<-- %s: return %d\n" , __func__, ret); +return ret; +out_free: +kfree (slot); + goto out; +} +/* Destroy the slot table */ static void nfs4_destroy_slot_table (struct nfs4_session *session) {
@@ -4317,6 +4362,133 @@ void nfs4_destroy_session(struct nfs4_session *session) kfree(session); } +/* +* Initialize the values to be used by the client in CREATE_SESSION +* If nfs4_init_session set the fore channel request and response sizes, +* use them. +* +* Set the back channel max_resp_sz_cached to zero to force the client to +* always set csa_cachethis to FALSE because the current implementation +* of the back channel DRC only supports caching the CB_SEQUENCE operation. +*/ +static void nfs4_init_channel_attrs (struct nfs41_create_session_args *args) +{ +struct nfs4_session *session = args->client->cl_session; +unsigned int mxrqst_sz = session->fc_attrs.max_rqst_sz, + mxresp_sz = session->fc_attrs.max_resp_sz; + +if (mxrqst_sz ==0 ) + mxrqst_sz =NFS_MAX_FILE_IO_SIZE ; +if (mxresp_sz ==0 ) + mxresp_sz =NFS_MAX_FILE_IO_SIZE ; +/* Fore channel attributes */ + args->fc_attrs.headerpadsz =0 ; + args->fc_attrs.max_rqst_sz = mxrqst_sz; + args->fc_attrs.max_resp_sz = mxresp_sz; + args->fc_attrs.max_resp_sz_cached = mxresp_sz; + args->fc_attrs.max_ops =NFS4_MAX_OPS ; + args->fc_attrs.max_reqs = session->clp->cl_rpcclient->cl_xprt->max_reqs; + +dprintk ("%s: Fore Channel : max_rqst_sz=%u max_resp_sz=%u " +"max_resp_sz_cached=%u max_ops=%u max_reqs=%u\n" , + __func__, + args->fc_attrs.max_rqst_sz, args->fc_attrs.max_resp_sz, + args->fc_attrs.max_resp_sz_cached, args->fc_attrs.max_ops, + args->fc_attrs.max_reqs); + +/* Back channel attributes */ + args->bc_attrs.headerpadsz =0 ; + args->bc_attrs.max_rqst_sz =PAGE_SIZE ; + args->bc_attrs.max_resp_sz =PAGE_SIZE ; + args->bc_attrs.max_resp_sz_cached =0 ; + args->bc_attrs.max_ops =NFS4_MAX_BACK_CHANNEL_OPS ; + args->bc_attrs.max_reqs =1 ; + +dprintk ("%s: Back Channel : max_rqst_sz=%u max_resp_sz=%u " +"max_resp_sz_cached=%u max_ops=%u max_reqs=%u\n" , + __func__, + args->bc_attrs.max_rqst_sz, args->bc_attrs.max_resp_sz, + args->bc_attrs.max_resp_sz_cached, args->bc_attrs.max_ops, + args->bc_attrs.max_reqs); +} + +static int _nfs4_proc_create_session (struct nfs_client *clp) +{ +struct nfs4_session *session = clp->cl_session; +struct nfs41_create_session_args args = { + .client = clp, + .cb_program =NFS4_CALLBACK , + }; +struct nfs41_create_session_res res = { + .client = clp, + }; +struct rpc_message msg = { + .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE_SESSION ], + .rpc_argp = &args, + .rpc_resp = &res, + }; +int status; + +nfs4_init_channel_attrs (&args); + args.flags = (SESSION4_PERSIST ); + + status =rpc_call_sync (session->clp->cl_rpcclient, &msg,0 ); + +/* Set the negotiated values in the session's channel_attrs struct */ + +if (!status) { +/* Increment the clientid slot sequence id */ + clp->cl_seqid++; + } + +return status; +} + +/* +* Issues a CREATE_SESSION operation to the server. +* It is the responsibility of the caller to verify the session is +* expired before calling this routine. +*/ +int nfs4_proc_create_session (struct nfs_client *clp) +{ +int status; +unsigned *ptr; +struct nfs_fsinfo fsinfo; +struct nfs4_session *session = clp->cl_session; + +dprintk ("--> %s clp=%p session=%p\n" , __func__, clp, session); + + status =_nfs4_proc_create_session (clp); +if (status) + goto out; + +/* Init the fore channel */ + status =nfs4_init_slot_table (session); +dprintk ("fore channel slot table initialization returned %d\n" , status); +if (status) + goto out; + + ptr = (unsigned *)&session->sess_id.data[0 ]; +dprintk ("%s client>seqid %d sessionid %u:%u:%u:%u\n" , __func__, + clp->cl_seqid, ptr[0 ], ptr[1 ], ptr[2 ], ptr[3 ]); + +/* Get the lease time */ + status =nfs4_proc_get_lease_time (clp, &fsinfo); +if (status ==0 ) { +/* Update lease time and schedule renewal */ +spin_lock (&clp->cl_lock); + clp->cl_lease_time = fsinfo.lease_time *HZ ; + clp->cl_last_renewal = jiffies; +clear_bit (NFS4CLNT_LEASE_EXPIRED , &clp->cl_state); +spin_unlock (&clp->cl_lock); + +nfs4_schedule_state_renewal (clp); + } +out: +dprintk ("<-- %s\n" , __func__); +return status; +} +#endif /* CONFIG_NFS_V4_1 */ struct nfs4_state_recovery_ops nfs4_reboot_recovery_ops = {
fs/nfs/nfs4xdr.c +189 -0
243 lines not on this page · raw message
include/linux/nfs4.h +10 -0
@@ -131,6 +131,16 @@#define NFS4_MAX_UINT64 (~(u64)0) +/* An NFS4 sessions server must support at least NFS4_MAX_OPS operations. +* If a compound requires more operations, adjust NFS4_MAX_OPS accordingly. +*/ +#define NFS4_MAX_OPS 8 + +/* Our NFS4 client back channel server only wants the cb_sequene and the +* actual operation per compound +*/ +#define NFS4_MAX_BACK_CHANNEL_OPS 2 +enum nfs4_acl_whotype {NFS4_ACL_WHO_NAMED =0 ,NFS4_ACL_WHO_OWNER ,
include/linux/nfs_xdr.h +12 -0
@@ -929,6 +929,18 @@ struct nfs41_exchange_id_res {struct server_scope server_scope; struct nfs_impl_id4 impl_id; }; + +struct nfs41_create_session_args { +struct nfs_client *client; +uint32_t flags; +uint32_t cb_program; +struct nfs4_channel_attrs fc_attrs;/* Fore Channel */ +struct nfs4_channel_attrs bc_attrs;/* Back Channel */ +}; + +struct nfs41_create_session_res { +struct nfs_client *client; +};#endif /* CONFIG_NFS_V4_1 */ struct nfs_page ;
Signature · 1 line
1.6.2.1
PATCH v2 47/67 nfs41: verify session channel attribues
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Invalidate the session if the server returns invalid fore or back channel attributes.
Use a KERN_WARNING to report the fatal session estabishment error.
--- fs/nfs/nfs4proc.c | 50 ++++++++++++++++++++++++++++++++++++++++++++++++-- 1 files changed, 48 insertions(+), 2 deletions(-)
fs/nfs/nfs4proc.c +48 -2
@@ -4412,6 +4412,51 @@ static void nfs4_init_channel_attrs(struct nfs41_create_session_args *args) args->bc_attrs.max_reqs); } +static int _verify_channel_attr (char *chan,char *attr_name,u32 sent,u32 rcvd) +{ +if (rcvd <= sent) +return 0 ; +printk (KERN_WARNING "%s: Session INVALID: %s channel %s increased. " +"sent=%u rcvd=%u\n" , __func__, chan, attr_name, sent, rcvd); +return -EINVAL ; +} + +#define _verify_fore_channel_attr (_name_) \ + _verify_channel_attr("fore", #_name_, \ + args->fc_attrs._name_, \ + session->fc_attrs._name_) + +#define _verify_back_channel_attr (_name_) \ + _verify_channel_attr("back", #_name_, \ + args->bc_attrs._name_, \ + session->bc_attrs._name_) + +/* +* The server is not allowed to increase the fore channel header pad size, +* maximum response size, or maximum number of operations. +* +* The back channel attributes are only negotiatied down: We send what the +* (back channel) server insists upon. +*/ +static int nfs4_verify_channel_attrs (struct nfs41_create_session_args *args, +struct nfs4_session *session) +{ +int ret =0 ; + + ret |=_verify_fore_channel_attr (headerpadsz); + ret |=_verify_fore_channel_attr (max_resp_sz); + ret |=_verify_fore_channel_attr (max_ops); + + ret |=_verify_back_channel_attr (headerpadsz); + ret |=_verify_back_channel_attr (max_rqst_sz); + ret |=_verify_back_channel_attr (max_resp_sz); + ret |=_verify_back_channel_attr (max_resp_sz_cached); + ret |=_verify_back_channel_attr (max_ops); + ret |=_verify_back_channel_attr (max_reqs); + +return ret; +} +static int _nfs4_proc_create_session (struct nfs_client *clp) {struct nfs4_session *session = clp->cl_session;
@@ -4434,8 +4479,9 @@ static int _nfs4_proc_create_session(struct nfs_client *clp) status =rpc_call_sync (session->clp->cl_rpcclient, &msg,0 ); -/* Set the negotiated values in the session's channel_attrs struct */ - +if (!status) +/* Verify the session's negotiated channel_attrs values */ + status =nfs4_verify_channel_attrs (&args, session);if (!status) {/* Increment the clientid slot sequence id */ clp->cl_seqid++;
Signature · 1 line
1.6.2.1
PATCH v2 48/67 nfs41: use session attributes for rsize and wsize
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Set the mount points rsize and wsize to the negotiated session fore channel maximum response and requeset size. These values will be bound checked in nfs_server_set_fsinfo.
--- fs/nfs/client.c | 17 +++++++++++++++++ 1 files changed, 17 insertions(+), 0 deletions(-)
fs/nfs/client.c +17 -0
@@ -527,6 +527,21 @@ static void nfs_mark_client_ready(struct nfs_client *clp, int state) }/* +* Session has been established, and the client marked ready. +* Set the mount rsize and wsize with negotiated fore channel +* attributes which will be bound checked in nfs_server_set_fsinfo. +*/ +static void nfs4_session_set_rwsize (struct nfs_server *server) +{ +#ifdef CONFIG_NFS_V4_1 +if (!nfs4_has_session (server->nfs_client)) +return ; + server->rsize = server->nfs_client->cl_session->fc_attrs.max_resp_sz; + server->wsize = server->nfs_client->cl_session->fc_attrs.max_rqst_sz; +#endif /* CONFIG_NFS_V4_1 */ +} + +/* * Initialise the timeout values for a connection */ static void nfs_init_timeout_values(struct rpc_timeout *to, int proto,
@@ -1296,6 +1311,8 @@ struct nfs_server *nfs4_create_server(const struct nfs_parsed_mount_data *data, (unsigned long long) server->fsid.minor);dprintk ("Mount FH: %d\n" , mntfh->size); +nfs4_session_set_rwsize (server); + error =nfs_probe_fsinfo (server, mntfh, &fattr);if (error <0 ) goto error;
Signature · 1 line
1.6.2.1
PATCH v2 49/67 nfs41: destroy_session operation
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Implement the destroy_session operation conforming to
http://tools.ietf.org/html/draft-ietf-nfsv4-minorversion1-26
--- fs/nfs/nfs4proc.c | 30 +++++++++++++++++++++++++++ fs/nfs/nfs4xdr.c | 59 +++++++++++++++++++++++++++++++++++++++++++++++++++++ fs/nfs/super.c | 2 + 3 files changed, 91 insertions(+), 0 deletions(-)
fs/nfs/nfs4proc.c +30 -0
@@ -4535,6 +4535,36 @@ out: return status; } +/* +* Issue the over-the-wire RPC DESTROY_SESSION. +* The caller must serialize access to this routine. +*/ +int nfs4_proc_destroy_session (struct nfs4_session *session) +{ +int status =0 ; +struct rpc_message msg; + +dprintk ("--> nfs4_proc_destroy_session\n" ); + +/* session is still being setup */ +if (session->clp->cl_cons_state !=NFS_CS_READY ) +return status; + + msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_SESSION ]; + msg.rpc_argp = session; + msg.rpc_resp =NULL ; + msg.rpc_cred =NULL ; + status =rpc_call_sync (session->clp->cl_rpcclient, &msg,0 ); + +if (status) +printk (KERN_WARNING +"Got error %d from the server on DESTROY_SESSION. " +"Session has been destroyed regardless...\n" , status); + +dprintk ("<-- nfs4_proc_destroy_session\n" ); +return status; +} +#endif /* CONFIG_NFS_V4_1 */ struct nfs4_state_recovery_ops nfs4_reboot_recovery_ops = {
fs/nfs/nfs4xdr.c +59 -0
101 lines not on this page · raw message
fs/nfs/super.c +2 -0
@@ -2604,12 +2604,14 @@ static void nfs4_kill_super(struct super_block *sb) {struct nfs_server *server =NFS_SB (sb); +dprintk ("--> %s\n" , __func__);nfs_super_return_all_delegations (sb);kill_anon_super (sb);nfs4_renewd_prepare_shutdown (server);nfs_fscache_release_super_cookie (sb);nfs_free_server (server); +dprintk ("<-- %s\n" , __func__); }/*
Signature · 1 line
1.6.2.1
PATCH v2 50/67 nfs41: enable nfs_client only nfs4_async_handle_error
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
The session is per struct nfs_client, not per nfs_server. Allow the handler
to be called with no nfs_server which simplifies the nfs4_proc_async_sequence session renewal call and will let it be used by pnfs file layout data servers.
--- fs/nfs/nfs4proc.c | 13 +++++++++---- 1 files changed, 9 insertions(+), 4 deletions(-)
fs/nfs/nfs4proc.c +9 -4
@@ -3224,10 +3224,8 @@ static int nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen }static int -nfs4_async_handle_error (struct rpc_task *task,const struct nfs_server *server,struct nfs4_state *state) +_nfs4_async_handle_error (struct rpc_task *task,const struct nfs_server *server,struct nfs_client *clp,struct nfs4_state *state) { -struct nfs_client *clp = server->nfs_client; -if (!clp || task->tk_status >=0 )return 0 ;switch (task->tk_status) {
@@ -3247,7 +3245,8 @@ nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server, task->tk_status =0 ;return -EAGAIN ;case -NFS4ERR_DELAY : -nfs_inc_server_stats (server,NFSIOS_DELAY ); +if (server) +nfs_inc_server_stats (server,NFSIOS_DELAY );case -NFS4ERR_GRACE :rpc_delay (task,NFS4_POLL_RETRY_MAX ); task->tk_status =0 ;
@@ -3260,6 +3259,12 @@ nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server,return 0 ; } +static int +nfs4_async_handle_error (struct rpc_task *task,const struct nfs_server *server,struct nfs4_state *state) +{ +return _nfs4_async_handle_error (task, server, server->nfs_client, state); +} +int nfs4_proc_setclientid (struct nfs_client *clp,u32 program,unsigned short port,struct rpc_cred *cred) {nfs4_verifier sc_verifier;
Signature · 1 line
1.6.2.1
PATCH v2 51/67 nfs41: sequence operation
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Implement the sequence operation conforming to
http://tools.ietf.org/html/draft-ietf-nfsv4-minorversion1-26
Check returned sessionid, slotid and slot sequenceid in decode_sequence.
If the server returns different values for sessionID, slotID or slot sequence number than what was sent, the server is looney tunes.
Pass the sequence operation status to nfs41_sequence_done in order to determine when to increment the slot sequence ID.
Free slot is separated from sequence done.
--- fs/nfs/nfs4proc.c | 92 ++++++++++++++++++++++++++++++++++++++ fs/nfs/nfs4xdr.c | 127 ++++++++++++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 214 insertions(+), 5 deletions(-)
fs/nfs/nfs4proc.c +92 -0
@@ -4570,6 +4570,98 @@ int nfs4_proc_destroy_session(struct nfs4_session *session) return status; } +/* +* Renew the cl_session lease. +*/ +static int nfs4_proc_sequence (struct nfs_client *clp,struct rpc_cred *cred) +{ +struct nfs4_sequence_args args; +struct nfs4_sequence_res res; + +struct rpc_message msg = { + .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEQUENCE ], + .rpc_argp = &args, + .rpc_resp = &res, + .rpc_cred = cred, + }; + + args.sa_cache_this =0 ; + +return nfs4_call_sync_sequence (clp, clp->cl_rpcclient, &msg, &args, + &res,0 ); +} + +void nfs41_sequence_call_done (struct rpc_task *task,void *data) +{ +struct nfs_client *clp = (struct nfs_client *)data; + +nfs41_sequence_done (clp, task->tk_msg.rpc_resp, task->tk_status); + +if (task->tk_status <0 ) { +dprintk ("%s ERROR %d\n" , __func__, task->tk_status); + +if (_nfs4_async_handle_error (task,NULL , clp,NULL ) + == -EAGAIN ) { +rpc_restart_call (task); +return ; + } + } +nfs41_sequence_free_slot (clp, task->tk_msg.rpc_resp); +dprintk ("%s rpc_cred %p\n" , __func__, task->tk_msg.rpc_cred); + +put_rpccred (task->tk_msg.rpc_cred); +kfree (task->tk_msg.rpc_argp); +kfree (task->tk_msg.rpc_resp); + +dprintk ("<-- %s\n" , __func__); +} + +static void nfs41_sequence_prepare (struct rpc_task *task,void *data) +{ +struct nfs_client *clp; +struct nfs4_sequence_args *args; +struct nfs4_sequence_res *res; + + clp = (struct nfs_client *)data; + args = task->tk_msg.rpc_argp; + res = task->tk_msg.rpc_resp; + +if (nfs4_setup_sequence (clp, args, res,0 , task)) +return ; +rpc_call_start (task); +} + +static const struct rpc_call_ops nfs41_sequence_ops = { + .rpc_call_done = nfs41_sequence_call_done, + .rpc_call_prepare = nfs41_sequence_prepare, +}; + +static int nfs41_proc_async_sequence (struct nfs_client *clp, +struct rpc_cred *cred) +{ +struct nfs4_sequence_args *args; +struct nfs4_sequence_res *res; +struct rpc_message msg = { + .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEQUENCE ], + .rpc_cred = cred, + }; + + args =kzalloc (sizeof (*args),GFP_KERNEL ); +if (!args) +return -ENOMEM ; + res =kzalloc (sizeof (*res),GFP_KERNEL ); +if (!res) { +kfree (args); +return -ENOMEM ; + } + res->sr_slotid =NFS4_MAX_SLOT_TABLE ; + msg.rpc_argp = args; + msg.rpc_resp = res; + +return rpc_call_async (clp->cl_rpcclient, &msg,RPC_TASK_SOFT , + &nfs41_sequence_ops, (void *)clp); +} +#endif /* CONFIG_NFS_V4_1 */ struct nfs4_state_recovery_ops nfs4_reboot_recovery_ops = {
fs/nfs/nfs4xdr.c +122 -5
178 lines not on this page · raw message
Signature · 1 line
1.6.2.1
PATCH v2 52/67 nfs41: reset the session slot table
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Separated from nfs41: schedule async session reset
Do not kfree the session slot table upon session reset, just re-initialize it. Add a boolean to nfs4_proc_create_session to inidicate if this is a session reset or a session initialization.
--- fs/nfs/nfs4proc.c | 44 +++++++++++++++++++++++++++++++++++++++++--- 1 files changed, 41 insertions(+), 3 deletions(-)
fs/nfs/nfs4proc.c +41 -3
@@ -4292,6 +4292,37 @@ int nfs4_proc_get_lease_time(struct nfs_client *clp, struct nfs_fsinfo *fsinfo)return status; } +/* Reset a slot table */ +static int nfs4_reset_slot_table (struct nfs4_session *session) +{ +struct nfs4_slot_table *tbl = &session->fc_slot_table; +int i, max_slots = session->fc_attrs.max_reqs; +int old_max_slots = session->fc_slot_table.max_slots; +int ret =0 ; + +dprintk ("--> %s: max_reqs=%u, tbl %p\n" , __func__, + session->fc_attrs.max_reqs, tbl); + +/* 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; + } +spin_lock (&tbl->slot_tbl_lock); +for (i =0 ; i < max_slots; ++i) + tbl->slots[i].seq_nr =1 ; + tbl->highest_used_slotid =-1 ; +spin_unlock (&tbl->slot_tbl_lock); +dprintk ("%s: tbl=%p slots=%p max_slots=%d\n" , __func__, + tbl, tbl->slots, tbl->max_slots); +out: +dprintk ("<-- %s: return %d\n" , __func__, ret); +return ret; +} +/* * Initialize slot table */
@@ -4500,7 +4531,7 @@ static int _nfs4_proc_create_session(struct nfs_client *clp)* It is the responsibility of the caller to verify the session is * expired before calling this routine. */ -int nfs4_proc_create_session (struct nfs_client *clp) +int nfs4_proc_create_session (struct nfs_client *clp,int reset) {int status;unsigned *ptr;
@@ -4513,8 +4544,11 @@ int nfs4_proc_create_session(struct nfs_client *clp)if (status) goto out; -/* Init the fore channel */ - status =nfs4_init_slot_table (session); +/* Init or reset the fore channel */ +if (reset) + status =nfs4_reset_slot_table (session); +else + status =nfs4_init_slot_table (session);dprintk ("fore channel slot table initialization returned %d\n" , status);if (status) goto out;
@@ -4523,6 +4557,10 @@ int nfs4_proc_create_session(struct nfs_client *clp)dprintk ("%s client>seqid %d sessionid %u:%u:%u:%u\n" , __func__, clp->cl_seqid, ptr[0 ], ptr[1 ], ptr[2 ], ptr[3 ]); +if (reset) +/* Lease time is aleady set */ + goto out; +/* Get the lease time */ status =nfs4_proc_get_lease_time (clp, &fsinfo);if (status ==0 ) {
Signature · 1 line
1.6.2.1
PATCH v2 53/67 nfs41: add session setup to the state manager
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
At mount, nfs_alloc_client sets the cl_state NFS4CLNT_LEASE_EXPIRED bit and nfs4_alloc_session sets the NFS4CLNT_SESSION_SETUP bit, so both bits are set when nfs4_lookup_root calls nfs4_recover_expired_lease which schedules the nfs4_state_manager and waits for it to complete.
Place the session setup after the clientid establishment in nfs4_state_manager so that the session is setup right after the clientid has been established without rescheduling the state manager.
Unlike nfsv4.0, the nfs_client struct is not ready to use until the session has been established. Postpone marking the nfs_client struct to NFS_CS_READY until after a successful CREATE_SESSION call so that other threads cannot use the client until the session is established.
If the EXCHANGE_ID call fails and the session has not been setup (the NFS4CLNT_SESSION_SETUP bit is set), mark the client with the error and return.
If the session setup CREATE_SESSION call fails with NFS4ERR_STALE_CLIENTID which could occur due to server reboot or network partition inbetween the EXCHANGE_ID and CREATE_SESSION call, reset the NFS4CLNT_LEASE_EXPIRED and NFS4CLNT_SESSION_SETUP bits and try again.
If the CREATE_SESSION call fails with other errors, mark the client with the error and return.
[nfs41: NFS_CS_SESSION_SETUP cl_cons_state for back channel setup]
On session setup, the CREATE_SESSION reply races with the server back channel probe which needs to succeed to setup the back channel. Set a new cl_cons_state NFS_CS_SESSION_SETUP just prior to the CREATE_SESSION call and add it as a valid state to nfs_find_client so that the client back channel can find the nfs_client struct and won't drop the server backchannel probe. Use a new cl_cons_state so that NFSv4.0 back channel behaviour which only sets NFS_CS_READY is unchanged.
Adjust waiting on the nfs_client_active_wq accordingly.
--- fs/nfs/client.c | 10 ++++++---- fs/nfs/internal.h | 1 + fs/nfs/nfs4_fs.h | 2 ++ fs/nfs/nfs4proc.c | 10 ++++++++++ fs/nfs/nfs4state.c | 35 ++++++++++++++++++++++++++++++++++- include/linux/nfs_fs_sb.h | 1 + 6 files changed, 54 insertions(+), 5 deletions(-)
fs/nfs/client.c +6 -4
@@ -366,7 +366,8 @@ struct nfs_client *nfs_find_client(const struct sockaddr *addr, u32 nfsversion)struct sockaddr *clap = (struct sockaddr *)&clp->cl_addr;/* Don't match clients that failed to initialise properly */ -if (clp->cl_cons_state !=NFS_CS_READY ) +if (!(clp->cl_cons_state ==NFS_CS_READY || + clp->cl_cons_state ==NFS_CS_SESSION_INITING ))continue ;/* Different NFS versions cannot share the same nfs_client */
@@ -499,7 +500,7 @@ found_client:nfs_free_client (new); error =wait_event_killable (nfs_client_active_wq, - clp->cl_cons_state !=NFS_CS_INITING ); + clp->cl_cons_state <NFS_CS_INITING );if (error <0 ) {nfs_put_client (clp);return ERR_PTR (-ERESTARTSYS );
@@ -520,7 +521,7 @@ found_client:/* * Mark a server as ready or failed */ -static void nfs_mark_client_ready (struct nfs_client *clp,int state) +void nfs_mark_client_ready (struct nfs_client *clp,int state) { clp->cl_cons_state = state;wake_up_all (&nfs_client_active_wq);
@@ -1150,7 +1151,8 @@ static int nfs4_init_client(struct nfs_client *clp,if (error <0 ) goto error; -nfs_mark_client_ready (clp,NFS_CS_READY ); +if (!nfs4_has_session (clp)) +nfs_mark_client_ready (clp,NFS_CS_READY );return 0 ; error:
fs/nfs/internal.h +1 -0
@@ -100,6 +100,7 @@ extern void nfs_free_server(struct nfs_server *server);extern struct nfs_server *nfs_clone_server (struct nfs_server *,struct nfs_fh *,struct nfs_fattr *); +extern void nfs_mark_client_ready (struct nfs_client *clp,int state);#ifdef CONFIG_PROC_FS extern int __init nfs_fs_proc_init (void );extern void nfs_fs_proc_exit (void );
fs/nfs/nfs4_fs.h +2 -0
@@ -44,6 +44,7 @@ enum nfs4_client_state {NFS4CLNT_RECLAIM_REBOOT ,NFS4CLNT_RECLAIM_NOGRACE ,NFS4CLNT_DELEGRETURN , + NFS4CLNT_SESSION_SETUP, };/*
@@ -208,6 +209,7 @@ extern int nfs4_setup_sequence(struct nfs_client *clp, int cache_reply, struct rpc_task *task);extern void nfs4_destroy_session (struct nfs4_session *session);extern struct nfs4_session *nfs4_alloc_session (struct nfs_client *clp); +extern int nfs4_proc_create_session (struct nfs_client *,int reset);#else /* CONFIG_NFS_v4_1 */ static inline int nfs4_setup_sequence(struct nfs_client *clp, struct nfs4_sequence_args *args, struct nfs4_sequence_res *res,
fs/nfs/nfs4proc.c +10 -0
@@ -4385,6 +4385,16 @@ struct nfs4_session *nfs4_alloc_session(struct nfs_client *clp) session =kzalloc (sizeof (struct nfs4_session ),GFP_KERNEL );if (!session)return NULL ; + +set_bit (NFS4CLNT_SESSION_SETUP , &clp->cl_state); +/* +* The create session reply races with the server back +* channel probe. Mark the client NFS_CS_SESSION_INITING +* so that the client back channel can find the +* nfs_client struct +*/ + clp->cl_cons_state =NFS_CS_SESSION_INITING ; + tbl = &session->fc_slot_table;spin_lock_init (&tbl->slot_tbl_lock);rpc_init_wait_queue (&tbl->slot_tbl_waitq,"Slot table" );
fs/nfs/nfs4state.c +34 -1
@@ -1113,6 +1113,27 @@ static int nfs4_reclaim_lease(struct nfs_client *clp)return status; } +#ifdef CONFIG_NFS_V4_1 + +static int nfs4_initialize_session (struct nfs_client *clp) +{ +int status; + + status =nfs4_proc_create_session (clp,0 ); +if (!status) { +nfs_mark_client_ready (clp,NFS_CS_READY ); + }else if (status == -NFS4ERR_STALE_CLIENTID ) { +set_bit (NFS4CLNT_LEASE_EXPIRED , &clp->cl_state); +set_bit (NFS4CLNT_SESSION_SETUP , &clp->cl_state); + }else { +nfs_mark_client_ready (clp, status); + } +return status; +} +#else /* CONFIG_NFS_V4_1 */ +static int nfs4_initialize_session (struct nfs_client *clp) {return 0 ; } +#endif /* CONFIG_NFS_V4_1 */ +static void nfs4_state_manager (struct nfs_client *clp) {int status =0 ;
@@ -1126,6 +1147,9 @@ static void nfs4_state_manager(struct nfs_client *clp)set_bit (NFS4CLNT_LEASE_EXPIRED , &clp->cl_state);if (status == -EAGAIN )continue ; +if (clp->cl_cons_state == +NFS_CS_SESSION_INITING ) +nfs_mark_client_ready (clp, status); goto out_error; }clear_bit (NFS4CLNT_CHECK_LEASE , &clp->cl_state);
@@ -1136,7 +1160,16 @@ static void nfs4_state_manager(struct nfs_client *clp)if (status !=0 )continue ; } - +/* Setup the session */ +if (nfs4_has_session (clp) && +test_and_clear_bit (NFS4CLNT_SESSION_SETUP , &clp->cl_state)) { + status =nfs4_initialize_session (clp); +if (status) { +if (status == -NFS4ERR_STALE_CLIENTID ) +continue ; + goto out_error; + } + }/* First recover reboot state... */ if (test_and_clear_bit (NFS4CLNT_RECLAIM_REBOOT , &clp->cl_state)) { status =nfs4_do_reclaim (clp, &nfs4_reboot_recovery_ops);
include/linux/nfs_fs_sb.h +1 -0
@@ -24,6 +24,7 @@ struct nfs_client {int cl_cons_state;/* current construction state (-ve: init error) */ #define NFS_CS_READY 0/* ready to be used */ #define NFS_CS_INITING 1/* busy initialising */ +#define NFS_CS_SESSION_INITING 2/* busy initialising session */ unsigned long cl_res_state;/* NFS resources state */ #define NFS_CS_CALLBACK 1/* - callback started */ #define NFS_CS_IDMAP 2/* - idmap started */
Signature · 1 line
1.6.2.1
PATCH v2 54/67 nfs41: add session reset to state manager
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Move the code to reset a session from the session_reclaimer to the nfs4_state_manager. Destroy the session, and create a new one. Treat NFS4ERR_BADSESSION and NFS4ERR_DEADSESSION as a successful nfs4_proc_destroy_session. Signal nfs4_proc_create_session that this is a session reset so that the session slot table is re-used.
If the clientid is stale, set both NFS4CLNT_LEASE_EXPIRED and NFS4CLNT_SESSION_SETUP bits and retry.
Use a switch statement in nfs4_session_recovery_handle_error for future patche which will add handling for other errors.
If nfs4_do_reclaim gets a session reset error, nfs4_recovery_handle_error will set the NFS4CLNT_SESSION_SETUP bit, and the state manager should continue processing to reset the session.
--- fs/nfs/nfs4_fs.h | 1 + fs/nfs/nfs4state.c | 51 +++++++++++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 50 insertions(+), 2 deletions(-)
fs/nfs/nfs4_fs.h +1 -0
@@ -210,6 +210,7 @@ extern int nfs4_setup_sequence(struct nfs_client *clp,extern void nfs4_destroy_session (struct nfs4_session *session);extern struct nfs4_session *nfs4_alloc_session (struct nfs_client *clp);extern int nfs4_proc_create_session (struct nfs_client *,int reset); +extern int nfs4_proc_destroy_session (struct nfs4_session *);#else /* CONFIG_NFS_v4_1 */ static inline int nfs4_setup_sequence(struct nfs_client *clp, struct nfs4_sequence_args *args, struct nfs4_sequence_res *res,
fs/nfs/nfs4state.c +49 -2
89 lines not on this page · raw message
Signature · 1 line
1.6.2.1
PATCH v2 55/67 nfs41: sunrpc: Export the call prepare state for session reset
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
--- include/linux/sunrpc/clnt.h | 1 + include/linux/sunrpc/sched.h | 1 + net/sunrpc/clnt.c | 13 +++++++++++++ net/sunrpc/sched.c | 2 +- 4 files changed, 16 insertions(+), 1 deletions(-)
include/linux/sunrpc/clnt.h +1 -0
@@ -143,6 +143,7 @@ int rpc_call_sync(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags);struct rpc_task *rpc_call_null (struct rpc_clnt *clnt,struct rpc_cred *cred,int flags); +void rpc_restart_call_prepare (struct rpc_task *);void rpc_restart_call (struct rpc_task *);void rpc_setbufsize (struct rpc_clnt *,unsigned int ,unsigned int );size_t rpc_max_payload (struct rpc_clnt *);
include/linux/sunrpc/sched.h +1 -0
@@ -237,6 +237,7 @@ void rpc_show_tasks(void);int rpc_init_mempool (void );void rpc_destroy_mempool (void );extern struct workqueue_struct *rpciod_workqueue; +void rpc_prepare_task (struct rpc_task *task);static inline void rpc_exit (struct rpc_task *task,int status) {
net/sunrpc/clnt.c +13 -0
@@ -695,6 +695,19 @@ void rpc_force_rebind(struct rpc_clnt *clnt)EXPORT_SYMBOL_GPL (rpc_force_rebind);/* +* Restart an (async) RPC call from the call_prepare state. +* Usually called from within the exit handler. +*/ +void +rpc_restart_call_prepare (struct rpc_task *task) +{ +if (RPC_ASSASSINATED (task)) +return ; + task->tk_action = rpc_prepare_task; +} +EXPORT_SYMBOL_GPL (rpc_restart_call_prepare); + +/* * Restart an (async) RPC call. Usually called from within the * exit handler. */
net/sunrpc/sched.c +1 -1
@@ -569,7 +569,7 @@ EXPORT_SYMBOL_GPL(rpc_delay);/* * Helper to call task->tk_ops->rpc_call_prepare */ -static void rpc_prepare_task (struct rpc_task *task) +void rpc_prepare_task (struct rpc_task *task) { task->tk_ops->rpc_call_prepare (task, task->tk_calldata); }
Signature · 1 line
1.6.2.1
PATCH v2 56/67 nfs41: use rpc prepare call state for session reset
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
--- fs/nfs/internal.h | 4 ++++ fs/nfs/nfs4proc.c | 27 ++++++++++++++++++++------- fs/nfs/read.c | 2 +- fs/nfs/unlink.c | 2 +- fs/nfs/write.c | 8 ++++---- 5 files changed, 30 insertions(+), 13 deletions(-)
fs/nfs/internal.h +4 -0
@@ -148,6 +148,10 @@ extern __be32 * nfs_decode_dirent(__be32 *, struct nfs_entry *, int);extern struct rpc_procinfo nfs3_procedures[];extern __be32 *nfs3_decode_dirent (__be32 *,struct nfs_entry *,int ); +/* nfs4proc.c */ +extern void nfs4_restart_rpc (struct rpc_task *task, +const struct nfs_client *clp); +/* nfs4xdr.c */ #ifdef CONFIG_NFS_V4 extern __be32 *nfs4_decode_dirent (__be32 *p,struct nfs_entry *entry,int plus);
fs/nfs/nfs4proc.c +20 -7
@@ -586,6 +586,18 @@ static void nfs4_sequence_done_free_slot(const struct nfs_server *server,nfs4_sequence_free_slot (server->nfs_client, res); } +void nfs4_restart_rpc (struct rpc_task *task,const struct nfs_client *clp) +{ +#ifdef CONFIG_NFS_V4_1 +if (nfs4_has_session (clp) && +test_bit (NFS4CLNT_SESSION_SETUP , &clp->cl_state)) { +rpc_restart_call_prepare (task); +return ; + } +#endif /* CONFIG_NFS_V4_1 */ +rpc_restart_call (task); +} +static void update_changeattr (struct inode *dir,struct nfs4_change_info *cinfo) {struct nfs_inode *nfsi =NFS_I (dir);
@@ -1661,7 +1673,7 @@ static void nfs4_close_done(struct rpc_task *task, void *data)break ;default :if (nfs4_async_handle_error (task, server, state) == -EAGAIN ) { -rpc_restart_call (task); +nfs4_restart_rpc (task, server->nfs_client);return ; } }
@@ -2874,7 +2886,7 @@ static int nfs4_read_done(struct rpc_task *task, struct nfs_read_data *data)nfs4_sequence_done (server, &data->res.seq_res, task->tk_status);if (nfs4_async_handle_error (task, server, data->args.context->state) == -EAGAIN ) { -rpc_restart_call (task); +nfs4_restart_rpc (task, server->nfs_client);return -EAGAIN ; }
@@ -2899,7 +2911,7 @@ static int nfs4_write_done(struct rpc_task *task, struct nfs_write_data *data) task->tk_status);if (nfs4_async_handle_error (task,NFS_SERVER (inode), data->args.context->state) == -EAGAIN ) { -rpc_restart_call (task); +nfs4_restart_rpc (task,NFS_SERVER (inode)->nfs_client);return -EAGAIN ; }if (task->tk_status >=0 ) {
@@ -2927,7 +2939,7 @@ static int nfs4_commit_done(struct rpc_task *task, struct nfs_write_data *data)nfs4_sequence_done (NFS_SERVER (inode), &data->res.seq_res, task->tk_status);if (nfs4_async_handle_error (task,NFS_SERVER (inode),NULL ) == -EAGAIN ) { -rpc_restart_call (task); +nfs4_restart_rpc (task,NFS_SERVER (inode)->nfs_client);return -EAGAIN ; } nfs4_sequence_free_slot(NFS_SERVER(inode)->nfs_client,
@@ -3631,7 +3643,8 @@ static void nfs4_locku_done(struct rpc_task *task, void *data)break ;default :if (nfs4_async_handle_error (task, calldata->server,NULL ) == -EAGAIN ) -rpc_restart_call (task); +nfs4_restart_rpc (task, + calldata->server->nfs_client); }nfs4_sequence_free_slot (calldata->server->nfs_client, &calldata->res.seq_res);
@@ -4240,7 +4253,7 @@ static void nfs4_get_lease_time_done(struct rpc_task *task, void *calldata)dprintk ("%s Retry: tk_status %d\n" , __func__, task->tk_status);rpc_delay (task,NFS4_POLL_RETRY_MIN ); task->tk_status =0 ; -rpc_restart_call (task); +nfs4_restart_rpc (task, data->clp);return ; }nfs41_sequence_free_slot (data->clp, &data->res->lr_seq_res);
@@ -4650,7 +4663,7 @@ void nfs41_sequence_call_done(struct rpc_task *task, void *data)if (_nfs4_async_handle_error (task,NULL , clp,NULL ) == -EAGAIN ) { -rpc_restart_call (task); +nfs4_restart_rpc (task, clp);return ; } }
fs/nfs/read.c +1 -1
@@ -371,7 +371,7 @@ static void nfs_readpage_retry(struct rpc_task *task, struct nfs_read_data *data argp->offset += resp->count; argp->pgbase += resp->count; argp->count -= resp->count; -rpc_restart_call (task); +nfs4_restart_rpc (task,NFS_SERVER (data->inode)->nfs_client);return ; out: nfs4_sequence_free_slot(NFS_SERVER(data->inode)->nfs_client,
fs/nfs/unlink.c +1 -1
@@ -83,7 +83,7 @@ static void nfs_async_unlink_done(struct rpc_task *task, void *calldata)struct inode *dir = data->dir;if (!NFS_PROTO (dir)->unlink_done (task, dir)) -rpc_restart_call (task); +nfs4_restart_rpc (task,NFS_SERVER (dir)->nfs_client); }/**
fs/nfs/write.c +4 -4
@@ -1145,6 +1145,7 @@ int nfs_writeback_done(struct rpc_task *task, struct nfs_write_data *data) {struct nfs_writeargs *argp = &data->args;struct nfs_writeres *resp = &data->res; +struct nfs_server *server =NFS_SERVER (data->inode);int status; dprintk("NFS: %5u nfs_writeback_done (status %d)\n",
@@ -1177,7 +1178,7 @@ int nfs_writeback_done(struct rpc_task *task, struct nfs_write_data *data)if (time_before (complain, jiffies)) {dprintk ("NFS: faulty NFS server %s:" " (committed = %d) != (stable = %d)\n" , -NFS_SERVER (data->inode)->nfs_client->cl_hostname, + server->nfs_client->cl_hostname, resp->verf->committed, argp->stable); complain = jiffies +300 *HZ ; }
@@ -1203,7 +1204,7 @@ int nfs_writeback_done(struct rpc_task *task, struct nfs_write_data *data)*/ argp->stable =NFS_FILE_SYNC ; } -rpc_restart_call (task); +nfs4_restart_rpc (task, server->nfs_client);return -EAGAIN ; }if (time_before (complain, jiffies)) {
@@ -1215,8 +1216,7 @@ int nfs_writeback_done(struct rpc_task *task, struct nfs_write_data *data)/* Can't do anything about it except throw an error. */ task->tk_status = -EIO ; } -nfs4_sequence_free_slot (NFS_SERVER (data->inode)->nfs_client, - &data->res.seq_res); +nfs4_sequence_free_slot (server->nfs_client, &data->res.seq_res);return 0 ; }
Signature · 1 line
1.6.2.1
PATCH v2 57/67 nfs41: kick start nfs41 session recovery when handling errors
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Remove checking for any errors that the SEQUENCE operation does not return. -NFS4ERR_STALE_CLIENTID, NFS4ERR_EXPIRED, NFS4ERR_CB_PATH_DOWN, NFS4ERR_BACK_CHAN_BUSY, NFS4ERR_OP_NOT_IN_SESSION.
SEQUENCE operation error recovery is very primative, we only reset the session.
Remove checking for any errors that are returned by the SEQUENCE operation, but that resetting the session won't address. NFS4ERR_RETRY_UNCACHED_REP, NFS4ERR_SEQUENCE_POS,NFS4ERR_TOO_MANY_OPS.
Add error checking for missing SEQUENCE errors that a session reset will address.NFS4ERR_BAD_HIGH_SLOT, NFS4ERR_DEADSESSION, NFS4ERR_SEQ_FALSE_RETRY.
A reset of the session is currently our only response to a SEQUENCE operation error. Don't reset the session on errors where a new session won't help.
Don't reset the session on errors where a new session won't help.
Replace session state bit with nfs_client state bit. Set the NFS4CLNT_SESSION_SETUP bit upon a session related error in the sync/async error handlers.
[nfs41: _nfs4_async_handle_error fix session reset error list] Sequence operation errors that session reset could help. NFS4ERR_BADSESSIONNFS4ERR_BADSLOTNFS4ERR_BAD_HIGH_SLOTNFS4ERR_DEADSESSIONNFS4ERR_CONN_NOT_BOUND_TO_SESSIONNFS4ERR_SEQ_FALSE_RETRYNFS4ERR_SEQ_MISORDERED
Sequence operation errors that a session reset would not help
NFS4ERR_BADXDRNFS4ERR_DELAYNFS4ERR_REP_TOO_BIGNFS4ERR_REP_TOO_BIG_TO_CACHENFS4ERR_REQ_TOO_BIGNFS4ERR_RETRY_UNCACHED_REPNFS4ERR_SEQUENCE_POSNFS4ERR_TOO_MANY_OPS
--- fs/nfs/nfs4proc.c | 32 ++++++++++++++++++++++++++++++++ 1 files changed, 32 insertions(+), 0 deletions(-)
fs/nfs/nfs4proc.c +32 -0
@@ -249,7 +249,25 @@ static int nfs4_handle_exception(const struct nfs_server *server, int errorcode, ret =nfs4_wait_clnt_recover (clp);if (ret ==0 ) exception->retry =1 ; +#if !defined(CONFIG_NFS_V4_1 )break ; +#else /* !defined(CONFIG_NFS_V4_1) */ +if (!nfs4_has_session (server->nfs_client)) +break ; +/* FALLTHROUGH */ +case -NFS4ERR_BADSESSION : +case -NFS4ERR_BADSLOT : +case -NFS4ERR_BAD_HIGH_SLOT : +case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION : +case -NFS4ERR_DEADSESSION : +case -NFS4ERR_SEQ_FALSE_RETRY : +case -NFS4ERR_SEQ_MISORDERED : +dprintk ("%s ERROR: %d Reset session\n" , __func__, + errorcode); +set_bit (NFS4CLNT_SESSION_SETUP , &clp->cl_state); + exception->retry =1 ; +/* FALLTHROUGH */ +#endif /* !defined(CONFIG_NFS_V4_1) */ case -NFS4ERR_FILE_OPEN :case -NFS4ERR_GRACE :case -NFS4ERR_DELAY :
@@ -3256,6 +3274,20 @@ _nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server,rpc_wake_up_queued_task (&clp->cl_rpcwaitq, task); task->tk_status =0 ;return -EAGAIN ; +#if defined(CONFIG_NFS_V4_1 ) +case -NFS4ERR_BADSESSION : +case -NFS4ERR_BADSLOT : +case -NFS4ERR_BAD_HIGH_SLOT : +case -NFS4ERR_DEADSESSION : +case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION : +case -NFS4ERR_SEQ_FALSE_RETRY : +case -NFS4ERR_SEQ_MISORDERED : +dprintk ("%s ERROR %d, Reset session\n" , __func__, + task->tk_status); +set_bit (NFS4CLNT_SESSION_SETUP , &clp->cl_state); + task->tk_status =0 ; +return -EAGAIN ; +#endif /* CONFIG_NFS_V4_1 */ case -NFS4ERR_DELAY :if (server)nfs_inc_server_stats (server,NFSIOS_DELAY );
Signature · 1 line
1.6.2.1
PATCH v2 58/67 nfs41: schedule async session reset
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Define a new session reset state which is set upon a sequence operation error in both the sync and async error handlers.
Place all new requests and all but the last outstanding rpc on the slot_tbl_waitq. Spawn the recovery thread when the last slot is free. Call nfs4_proc_destroy_session, reinitialize the session, call nfs4_proc_create_session, clear the session reset state, and wake up the next task on the slot_tbl_waitq.
Return the nfs4_proc_destroy_session status to the session reclaimer and check for NFS4ERR_BADSESSION and NFS4ERR_DEADSESSION. Other destroy session errors should be handled in nfs4_proc_destroy_session where the call can be retried with adjusted arguments.
nfs41: make nfs4_wait_bit_killable public]
nfs4_wait_bit_killable to be used by NFSv4.1 session recover logic.
Replace the session reset state with the NFS4CLNT_SESSION_SETUP cl_state. Place all rpc tasks to sleep on the slot table waitqueue until the slot table is drained, then schedule state recovery and wait for it to complete.
Replaced by using the nfs4_state_manager.
--- fs/nfs/nfs4proc.c | 34 ++++++++++++++++++++++++++++++++++ 1 files changed, 34 insertions(+), 0 deletions(-)
fs/nfs/nfs4proc.c +34 -0
@@ -423,6 +423,22 @@ out:return ret_id; } +static int nfs4_recover_session (struct nfs4_session *session) +{ +struct nfs_client *clp = session->clp; +int ret; + +for (;;) { + ret =nfs4_wait_clnt_recover (clp); +if (ret !=0 ) +return ret; +if (!test_bit (NFS4CLNT_SESSION_SETUP , &clp->cl_state)) +break ; +nfs4_schedule_state_manager (clp); + } +return 0 ; +} + static int nfs41_setup_sequence(struct nfs4_session *session, struct nfs4_sequence_args *args, struct nfs4_sequence_res *res,
@@ -431,6 +447,7 @@ static int nfs41_setup_sequence(struct nfs4_session *session, {struct nfs4_slot *slot;struct nfs4_slot_table *tbl; +int status =0 ;u8 slotid;dprintk ("--> %s\n" , __func__);
@@ -443,6 +460,23 @@ static int nfs41_setup_sequence(struct nfs4_session *session, tbl = &session->fc_slot_table;spin_lock (&tbl->slot_tbl_lock); +if (test_bit (NFS4CLNT_SESSION_SETUP , &session->clp->cl_state)) { +if (tbl->highest_used_slotid !=-1 ) { +rpc_sleep_on (&tbl->slot_tbl_waitq, task,NULL ); +spin_unlock (&tbl->slot_tbl_lock); +dprintk ("<-- %s: Session reset: draining\n" , __func__); +return -EAGAIN ; + } + +/* The slot table is empty; start the reset thread */ +dprintk ("%s Session Reset\n" , __func__); +spin_unlock (&tbl->slot_tbl_lock); + status =nfs4_recover_session (session); +if (status) +return status; +spin_lock (&tbl->slot_tbl_lock); + } + slotid =nfs4_find_slot (tbl, task);if (slotid ==NFS4_MAX_SLOT_TABLE ) {rpc_sleep_on (&tbl->slot_tbl_waitq, task,NULL );
Signature · 1 line
1.6.2.1
PATCH v2 59/67 nfs41: lease renewal
In reply to Benny HalevySend a NFSv4.1 SEQUENCE op rather than RENEW that was deprecated in minorversion 1.
Use the nfs_client minorversion to select reboot_recover/ network_partition_recovery/state_renewal ops.
Note: we use reclaimer to create the nfs41 session before there are any cl_superblocks for the nfs_client.
moved to nfs4_state_maintenance_ops
--- fs/nfs/nfs4_fs.h | 6 ++++++ fs/nfs/nfs4proc.c | 24 ++++++++++++++++++++++++ fs/nfs/nfs4renewd.c | 4 +++- 3 files changed, 33 insertions(+), 1 deletions(-)
fs/nfs/nfs4_fs.h +6 -0
@@ -180,6 +180,10 @@ struct nfs4_state_recovery_ops {int (*recover_lock)(struct nfs4_state *,struct file_lock *); }; +struct nfs4_state_maintenance_ops { +int (*sched_state_renewal)(struct nfs_client *,struct rpc_cred *); +}; +extern struct dentry_operations nfs4_dentry_operations;extern const struct inode_operations nfs4_dir_inode_operations;
@@ -220,6 +224,8 @@ static inline int nfs4_setup_sequence(struct nfs_client *clp, }#endif /* CONFIG_NFS_V4_1 */ +extern struct nfs4_state_maintenance_ops *nfs4_state_renewal_ops[]; +extern const u32 nfs4_fattr_bitmap[2 ];extern const u32 nfs4_statfs_bitmap[2 ];extern const u32 nfs4_pathconf_bitmap[2 ];
fs/nfs/nfs4proc.c +24 -0
@@ -3031,6 +3031,9 @@ static void nfs4_renew_done(struct rpc_task *task, void *data)if (time_before (clp->cl_last_renewal,timestamp)) clp->cl_last_renewal = timestamp;spin_unlock (&clp->cl_lock); +dprintk ("%s calling put_rpccred on rpc_cred %p\n" , __func__, + task->tk_msg.rpc_cred); +put_rpccred (task->tk_msg.rpc_cred); }static const struct rpc_call_ops nfs4_renew_ops = {
@@ -4805,6 +4808,27 @@ struct nfs4_state_recovery_ops nfs4_nograce_recovery_ops = { .recover_lock = nfs4_lock_expired, }; +struct nfs4_state_maintenance_ops nfs40_state_renewal_ops = { + .sched_state_renewal = nfs4_proc_async_renew, +}; + +#if defined(CONFIG_NFS_V4_1 ) +struct nfs4_state_maintenance_ops nfs41_state_renewal_ops = { + .sched_state_renewal = nfs41_proc_async_sequence, +}; +#endif + +/* +* Per minor version reboot and network partition recovery ops +*/ + +struct nfs4_state_maintenance_ops *nfs4_state_renewal_ops[] = { + &nfs40_state_renewal_ops, +#if defined(CONFIG_NFS_V4_1) + &nfs41_state_renewal_ops, +#endif +}; +static const struct inode_operations nfs4_file_inode_operations = { .permission = nfs_permission, .getattr = nfs_getattr,
fs/nfs/nfs4renewd.c +3 -1
@@ -59,12 +59,14 @@void nfs4_renew_state (struct work_struct *work) { +struct nfs4_state_maintenance_ops *ops;struct nfs_client *clp = container_of(work, struct nfs_client, cl_renewd.work);struct rpc_cred *cred;long lease, timeout;unsigned long last, now; + ops = nfs4_state_renewal_ops[clp->cl_minorversion];dprintk ("%s: start\n" , __func__);/* Are there any active superblocks? */ if (list_empty (&clp->cl_superblocks))
@@ -86,7 +88,7 @@ nfs4_renew_state(struct work_struct *work)nfs_expire_all_delegations (clp); }else {/* Queue an asynchronous RENEW. */ -nfs4_proc_async_renew (clp, cred); + ops->sched_state_renewal (clp, cred);put_rpccred (cred); } timeout = (2 * lease) /3 ;
Signature · 1 line
1.6.2.1
PATCH v2 60/67 nfs41: support minorversion 1 for nfs4_check_lease
In reply to Benny Halevy[moved nfs4_get_renew_cred related changes to
"nfs41: introduce get_state_renewal_cred"]
--- fs/nfs/nfs4_fs.h | 1 + fs/nfs/nfs4proc.c | 2 ++ fs/nfs/nfs4state.c | 4 +++- 3 files changed, 6 insertions(+), 1 deletions(-)
fs/nfs/nfs4_fs.h +1 -0
@@ -182,6 +182,7 @@ struct nfs4_state_recovery_ops {struct nfs4_state_maintenance_ops {int (*sched_state_renewal)(struct nfs_client *,struct rpc_cred *); +int (*renew_lease)(struct nfs_client *,struct rpc_cred *); };extern struct dentry_operations nfs4_dentry_operations;
fs/nfs/nfs4proc.c +2 -0
@@ -4810,11 +4810,13 @@ struct nfs4_state_recovery_ops nfs4_nograce_recovery_ops = {struct nfs4_state_maintenance_ops nfs40_state_renewal_ops = { .sched_state_renewal = nfs4_proc_async_renew, + .renew_lease = nfs4_proc_renew, };#if defined(CONFIG_NFS_V4_1 )struct nfs4_state_maintenance_ops nfs41_state_renewal_ops = { .sched_state_renewal = nfs41_proc_async_sequence, + .renew_lease = nfs4_proc_sequence, };#endif
fs/nfs/nfs4state.c +3 -1
@@ -1083,6 +1083,8 @@ restart:static int nfs4_check_lease (struct nfs_client *clp) {struct rpc_cred *cred; +struct nfs4_state_maintenance_ops *ops = + nfs4_state_renewal_ops[clp->cl_minorversion];int status = -NFS4ERR_EXPIRED ;/* Is the client already known to have an expired lease? */
@@ -1094,7 +1096,7 @@ static int nfs4_check_lease(struct nfs_client *clp)if (cred ==NULL ) goto out; } - status =nfs4_proc_renew (clp, cred); + status = ops->renew_lease (clp, cred);put_rpccred (cred); out:nfs4_recovery_handle_error (clp, status);
Signature · 1 line
1.6.2.1
PATCH v2 61/67 nfs41: introduce get_state_renewal_cred
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Use the machine cred for sending SEQUENCE to renew the client's lease.
Since EXCHANGE_ID insists on using the machine credential, cl_ex_cred is not needed. nfs4_proc_exchange_id() is only called if the machine credential is available. Remove the credential logic from nfs4_proc_exchange_id.
--- fs/nfs/nfs4_fs.h | 5 +++++ fs/nfs/nfs4proc.c | 3 +++ fs/nfs/nfs4renewd.c | 2 +- fs/nfs/nfs4state.c | 18 +++++------------- 4 files changed, 14 insertions(+), 14 deletions(-)
fs/nfs/nfs4_fs.h +5 -0
@@ -182,6 +182,7 @@ struct nfs4_state_recovery_ops {struct nfs4_state_maintenance_ops {int (*sched_state_renewal)(struct nfs_client *,struct rpc_cred *); +struct rpc_cred * (*get_state_renewal_cred_locked)(struct nfs_client *);int (*renew_lease)(struct nfs_client *,struct rpc_cred *); };
@@ -240,7 +241,11 @@ extern void nfs4_kill_renewd(struct nfs_client *);extern void nfs4_renew_state (struct work_struct *);/* nfs4state.c */ +struct rpc_cred *nfs4_get_setclientid_cred (struct nfs_client *clp);struct rpc_cred *nfs4_get_renew_cred_locked (struct nfs_client *clp); +#if defined(CONFIG_NFS_V4_1 ) +struct rpc_cred *nfs4_get_machine_cred_locked (struct nfs_client *clp); +#endif /* CONFIG_NFS_V4_1 */ extern struct nfs4_state_owner *nfs4_get_state_owner (struct nfs_server *,struct rpc_cred *);extern void nfs4_put_state_owner (struct nfs4_state_owner *);
fs/nfs/nfs4proc.c +3 -0
@@ -4251,6 +4251,7 @@ static int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred)dprintk ("--> %s\n" , __func__);BUG_ON (clp ==NULL ); + p = (u32 *)verifier.data; *p++ =htonl ((u32 )clp->cl_boot_time.tv_sec); *p =htonl ((u32 )clp->cl_boot_time.tv_nsec);
@@ -4810,12 +4811,14 @@ struct nfs4_state_recovery_ops nfs4_nograce_recovery_ops = {struct nfs4_state_maintenance_ops nfs40_state_renewal_ops = { .sched_state_renewal = nfs4_proc_async_renew, + .get_state_renewal_cred_locked = nfs4_get_renew_cred_locked, .renew_lease = nfs4_proc_renew, };#if defined(CONFIG_NFS_V4_1 )struct nfs4_state_maintenance_ops nfs41_state_renewal_ops = { .sched_state_renewal = nfs41_proc_async_sequence, + .get_state_renewal_cred_locked = nfs4_get_machine_cred_locked, .renew_lease = nfs4_proc_sequence, };#endif
fs/nfs/nfs4renewd.c +1 -1
@@ -78,7 +78,7 @@ nfs4_renew_state(struct work_struct *work) timeout = (2 * lease) /3 + (long )last - (long )now;/* Are we close to a lease timeout? */ if (time_after (now, last + lease/3 )) { - cred =nfs4_get_renew_cred_locked (clp); + cred = ops->get_state_renewal_cred_locked (clp);spin_unlock (&clp->cl_lock);if (cred ==NULL ) {if (list_empty (&clp->cl_delegations)) {
fs/nfs/nfs4state.c +5 -13
@@ -77,7 +77,7 @@ static int nfs4_init_client(struct nfs_client *clp, struct rpc_cred *cred)return status; } -static struct rpc_cred *nfs4_get_machine_cred_locked (struct nfs_client *clp) +struct rpc_cred *nfs4_get_machine_cred_locked (struct nfs_client *clp) {struct rpc_cred *cred =NULL ;
@@ -114,17 +114,7 @@ struct rpc_cred *nfs4_get_renew_cred_locked(struct nfs_client *clp)return cred; } -static struct rpc_cred *nfs4_get_renew_cred (struct nfs_client *clp) -{ -struct rpc_cred *cred; - -spin_lock (&clp->cl_lock); - cred =nfs4_get_renew_cred_locked (clp); -spin_unlock (&clp->cl_lock); -return cred; -} - -static struct rpc_cred *nfs4_get_setclientid_cred (struct nfs_client *clp) +struct rpc_cred *nfs4_get_setclientid_cred (struct nfs_client *clp) {struct nfs4_state_owner *sp;struct rb_node *pos;
@@ -1090,7 +1080,9 @@ static int nfs4_check_lease(struct nfs_client *clp)/* Is the client already known to have an expired lease? */ if (test_bit (NFS4CLNT_LEASE_EXPIRED , &clp->cl_state))return 0 ; - cred =nfs4_get_renew_cred (clp); +spin_lock (&clp->cl_lock); + cred = ops->get_state_renewal_cred_locked (clp); +spin_unlock (&clp->cl_lock);if (cred ==NULL ) { cred =nfs4_get_setclientid_cred (clp);if (cred ==NULL )
Signature · 1 line
1.6.2.1
PATCH v2 62/67 nfs41: establish sessions-based clientid
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
nfsv4.1 clientid is established via EXCHANGE_ID rather than SETCLIENTID{,_CONFIRM}
This is implemented using a new establish_clid method in nfs4_state_recovery_ops.
nfs41: establish clientid via exchange id only if cred != NULL
Quoted 1 line
From 2.6.26
reclaimer()uses machine cred for setting up the client id
therefore it is never expected to be NULL.
--- fs/nfs/nfs4_fs.h | 6 ++++-- fs/nfs/nfs4proc.c | 40 ++++++++++++++++++++++++++++++++++++++-- fs/nfs/nfs4state.c | 12 ++++++++---- 3 files changed, 50 insertions(+), 8 deletions(-)
fs/nfs/nfs4_fs.h +4 -2
@@ -178,6 +178,7 @@ struct nfs4_state_recovery_ops {int state_flag_bit;int (*recover_open)(struct nfs4_state_owner *,struct nfs4_state *);int (*recover_lock)(struct nfs4_state *,struct file_lock *); +int (*establish_clid)(struct nfs_client *,struct rpc_cred *); };struct nfs4_state_maintenance_ops {
@@ -200,6 +201,7 @@ extern int nfs4_proc_setclientid(struct nfs_client *, u32, unsigned short, strucextern int nfs4_proc_setclientid_confirm (struct nfs_client *,struct rpc_cred *);extern int nfs4_proc_async_renew (struct nfs_client *,struct rpc_cred *);extern int nfs4_proc_renew (struct nfs_client *,struct rpc_cred *); +extern int nfs4_init_clientid (struct nfs_client *,struct rpc_cred *);extern int nfs4_do_close (struct path *path,struct nfs4_state *state,int wait);extern struct dentry *nfs4_atomic_open (struct inode *,struct dentry *,struct nameidata *);extern int nfs4_open_revalidate (struct inode *,struct dentry *,int ,struct nameidata *);
@@ -207,8 +209,8 @@ extern int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhextern int nfs4_proc_fs_locations (struct inode *dir,const struct qstr *name,struct nfs4_fs_locations *fs_locations,struct page *page); -extern struct nfs4_state_recovery_ops nfs4_reboot_recovery_ops; -extern struct nfs4_state_recovery_ops nfs4_nograce_recovery_ops; +extern struct nfs4_state_recovery_ops *nfs4_reboot_recovery_ops[]; +extern struct nfs4_state_recovery_ops *nfs4_nograce_recovery_ops[];#if defined(CONFIG_NFS_V4_1 ) extern int nfs4_setup_sequence(struct nfs_client *clp, struct nfs4_sequence_args *args, struct nfs4_sequence_res *res,
fs/nfs/nfs4proc.c +38 -2
@@ -4795,19 +4795,41 @@ static int nfs41_proc_async_sequence(struct nfs_client *clp,#endif /* CONFIG_NFS_V4_1 */ -struct nfs4_state_recovery_ops nfs4_reboot_recovery_ops = { +struct nfs4_state_recovery_ops nfs40_reboot_recovery_ops = { .owner_flag_bit =NFS_OWNER_RECLAIM_REBOOT , .state_flag_bit =NFS_STATE_RECLAIM_REBOOT , .recover_open = nfs4_open_reclaim, .recover_lock = nfs4_lock_reclaim, + .establish_clid = nfs4_init_clientid, }; -struct nfs4_state_recovery_ops nfs4_nograce_recovery_ops = { +#if defined(CONFIG_NFS_V4_1 ) +struct nfs4_state_recovery_ops nfs41_reboot_recovery_ops = { + .owner_flag_bit =NFS_OWNER_RECLAIM_REBOOT , + .state_flag_bit =NFS_STATE_RECLAIM_REBOOT , + .recover_open = nfs4_open_reclaim, + .recover_lock = nfs4_lock_reclaim, + .establish_clid = nfs4_proc_exchange_id, +}; +#endif /* CONFIG_NFS_V4_1 */ + +struct nfs4_state_recovery_ops nfs40_nograce_recovery_ops = { + .owner_flag_bit =NFS_OWNER_RECLAIM_NOGRACE , + .state_flag_bit =NFS_STATE_RECLAIM_NOGRACE , + .recover_open = nfs4_open_expired, + .recover_lock = nfs4_lock_expired, + .establish_clid = nfs4_init_clientid, +}; + +#if defined(CONFIG_NFS_V4_1 ) +struct nfs4_state_recovery_ops nfs41_nograce_recovery_ops = { .owner_flag_bit =NFS_OWNER_RECLAIM_NOGRACE , .state_flag_bit =NFS_STATE_RECLAIM_NOGRACE , .recover_open = nfs4_open_expired, .recover_lock = nfs4_lock_expired, + .establish_clid = nfs4_proc_exchange_id, }; +#endif /* CONFIG_NFS_V4_1 */ struct nfs4_state_maintenance_ops nfs40_state_renewal_ops = { .sched_state_renewal = nfs4_proc_async_renew,
@@ -4827,6 +4849,20 @@ struct nfs4_state_maintenance_ops nfs41_state_renewal_ops = {* Per minor version reboot and network partition recovery ops */ +struct nfs4_state_recovery_ops *nfs4_reboot_recovery_ops[] = { + &nfs40_reboot_recovery_ops, +#if defined(CONFIG_NFS_V4_1) + &nfs41_reboot_recovery_ops, +#endif +}; + +struct nfs4_state_recovery_ops *nfs4_nograce_recovery_ops[] = { + &nfs40_nograce_recovery_ops, +#if defined(CONFIG_NFS_V4_1) + &nfs41_nograce_recovery_ops, +#endif +}; +struct nfs4_state_maintenance_ops *nfs4_state_renewal_ops[] = { &nfs40_state_renewal_ops, #if defined(CONFIG_NFS_V4_1)
fs/nfs/nfs4state.c +8 -4
@@ -60,7 +60,7 @@ const nfs4_stateid zero_stateid;static LIST_HEAD (nfs4_clientid_list); -static int nfs4_init_client (struct nfs_client *clp,struct rpc_cred *cred) +int nfs4_init_clientid (struct nfs_client *clp,struct rpc_cred *cred) {unsigned short port;int status;
@@ -1098,11 +1098,13 @@ out:static int nfs4_reclaim_lease (struct nfs_client *clp) {struct rpc_cred *cred; +struct nfs4_state_recovery_ops *ops = + nfs4_reboot_recovery_ops[clp->cl_minorversion];int status = -ENOENT ; cred =nfs4_get_setclientid_cred (clp);if (cred !=NULL ) { - status =nfs4_init_client (clp, cred); + status = ops->establish_clid (clp, cred);put_rpccred (cred);/* Handle case where the user hasn't set up machine creds */ if (status == -EACCES && cred == clp->cl_machine_cred) {
@@ -1208,7 +1210,8 @@ static void nfs4_state_manager(struct nfs_client *clp) }/* First recover reboot state... */ if (test_and_clear_bit (NFS4CLNT_RECLAIM_REBOOT , &clp->cl_state)) { - status =nfs4_do_reclaim (clp, &nfs4_reboot_recovery_ops); + status =nfs4_do_reclaim (clp, + nfs4_reboot_recovery_ops[clp->cl_minorversion]);if (status == -NFS4ERR_STALE_CLIENTID )continue ;if (test_bit (NFS4CLNT_SESSION_SETUP , &clp->cl_state))
@@ -1219,7 +1222,8 @@ static void nfs4_state_manager(struct nfs_client *clp)/* Now recover expired state... */ if (test_and_clear_bit (NFS4CLNT_RECLAIM_NOGRACE , &clp->cl_state)) { - status =nfs4_do_reclaim (clp, &nfs4_nograce_recovery_ops); + status =nfs4_do_reclaim (clp, + nfs4_nograce_recovery_ops[clp->cl_minorversion]);if (status <0 ) {set_bit (NFS4CLNT_RECLAIM_NOGRACE , &clp->cl_state);if (status == -NFS4ERR_STALE_CLIENTID )
Signature · 1 line
1.6.2.1
PATCH v2 63/67 nfs41: add a get_clid_cred function to nfs4_state_recovery_ops
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
EXCHANGE_ID has different credential requirements than SETCLIENTID. Prepare for a separate credential function.
--- fs/nfs/nfs4_fs.h | 1 + fs/nfs/nfs4proc.c | 2 ++ fs/nfs/nfs4state.c | 2 +- 3 files changed, 4 insertions(+), 1 deletions(-)
fs/nfs/nfs4_fs.h +1 -0
@@ -179,6 +179,7 @@ struct nfs4_state_recovery_ops {int (*recover_open)(struct nfs4_state_owner *,struct nfs4_state *);int (*recover_lock)(struct nfs4_state *,struct file_lock *);int (*establish_clid)(struct nfs_client *,struct rpc_cred *); +struct rpc_cred * (*get_clid_cred)(struct nfs_client *); };struct nfs4_state_maintenance_ops {
fs/nfs/nfs4proc.c +2 -0
@@ -4801,6 +4801,7 @@ struct nfs4_state_recovery_ops nfs40_reboot_recovery_ops = { .recover_open = nfs4_open_reclaim, .recover_lock = nfs4_lock_reclaim, .establish_clid = nfs4_init_clientid, + .get_clid_cred = nfs4_get_setclientid_cred, };#if defined(CONFIG_NFS_V4_1 )
@@ -4819,6 +4820,7 @@ struct nfs4_state_recovery_ops nfs40_nograce_recovery_ops = { .recover_open = nfs4_open_expired, .recover_lock = nfs4_lock_expired, .establish_clid = nfs4_init_clientid, + .get_clid_cred = nfs4_get_setclientid_cred, };#if defined(CONFIG_NFS_V4_1 )
fs/nfs/nfs4state.c +1 -1
@@ -1102,7 +1102,7 @@ static int nfs4_reclaim_lease(struct nfs_client *clp) nfs4_reboot_recovery_ops[clp->cl_minorversion];int status = -ENOENT ; - cred =nfs4_get_setclientid_cred (clp); + cred = ops->get_clid_cred (clp);if (cred !=NULL ) { status = ops->establish_clid (clp, cred);put_rpccred (cred);
Signature · 1 line
1.6.2.1
PATCH v2 64/67 nfs41: get_clid_cred for EXCHANGE_ID
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
Unlike SETCLIENTID, EXCHANGE_ID requires a machine credential. Do not search for credentials other than the machine credential.
--- fs/nfs/nfs4_fs.h | 1 + fs/nfs/nfs4proc.c | 2 ++ fs/nfs/nfs4state.c | 14 ++++++++++++++ 3 files changed, 17 insertions(+), 0 deletions(-)
fs/nfs/nfs4_fs.h +1 -0
@@ -248,6 +248,7 @@ struct rpc_cred *nfs4_get_setclientid_cred(struct nfs_client *clp);struct rpc_cred *nfs4_get_renew_cred_locked (struct nfs_client *clp);#if defined(CONFIG_NFS_V4_1 )struct rpc_cred *nfs4_get_machine_cred_locked (struct nfs_client *clp); +struct rpc_cred *nfs4_get_exchange_id_cred (struct nfs_client *clp);#endif /* CONFIG_NFS_V4_1 */ extern struct nfs4_state_owner *nfs4_get_state_owner (struct nfs_server *,struct rpc_cred *);
fs/nfs/nfs4proc.c +2 -0
@@ -4811,6 +4811,7 @@ struct nfs4_state_recovery_ops nfs41_reboot_recovery_ops = { .recover_open = nfs4_open_reclaim, .recover_lock = nfs4_lock_reclaim, .establish_clid = nfs4_proc_exchange_id, + .get_clid_cred = nfs4_get_exchange_id_cred, };#endif /* CONFIG_NFS_V4_1 */
@@ -4830,6 +4831,7 @@ struct nfs4_state_recovery_ops nfs41_nograce_recovery_ops = { .recover_open = nfs4_open_expired, .recover_lock = nfs4_lock_expired, .establish_clid = nfs4_proc_exchange_id, + .get_clid_cred = nfs4_get_exchange_id_cred, };#endif /* CONFIG_NFS_V4_1 */
fs/nfs/nfs4state.c +14 -0
@@ -114,6 +114,20 @@ struct rpc_cred *nfs4_get_renew_cred_locked(struct nfs_client *clp)return cred; } +#if defined(CONFIG_NFS_V4_1 ) + +struct rpc_cred *nfs4_get_exchange_id_cred (struct nfs_client *clp) +{ +struct rpc_cred *cred; + +spin_lock (&clp->cl_lock); + cred =nfs4_get_machine_cred_locked (clp); +spin_unlock (&clp->cl_lock); +return cred; +} + +#endif /* CONFIG_NFS_V4_1 */ +struct rpc_cred *nfs4_get_setclientid_cred (struct nfs_client *clp) {struct nfs4_state_owner *sp;
Signature · 1 line
1.6.2.1
PATCH v2 65/67 nfs41: recover lease in _nfs4_lookup_root
In reply to Benny HalevyThis creates the nfsv4.1 session on mount.
--- fs/nfs/nfs4proc.c | 7 ++++++- 1 files changed, 6 insertions(+), 1 deletions(-)
fs/nfs/nfs4proc.c +6 -1
@@ -2036,8 +2036,13 @@ static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle, .rpc_argp = &args, .rpc_resp = &res, }; +int status; +nfs_fattr_init (info->fattr); -return nfs4_call_sync (server, &msg, &args, &res,0 ); + status =nfs4_recover_expired_lease (server); +if (!status) + status =nfs4_call_sync (server, &msg, &args, &res,0 ); +return status; } static int nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
Signature · 1 line
1.6.2.1
PATCH v2 66/67 nfs41: fail mount on EXCHANGE_ID, CREATE_SESSION failure
In reply to Benny HalevyFrom: Andy Adamson <[email protected]>
The nfs4_recover_expired_lease() call schedules the state manager thread and waits for it to complete. A negative cl_cons_state indicates that either the EXCHANGE_ID or the CREATE_SESSION failed. In this case return -EPROTONOSUPPORT which will be returned to the caller (mount).
Note that session setup either succeeds or fails prior to calling a SEQUENCE operation, so unlike the session_reclaimer NFS41_SESSION_ALLOC state, there is no need to test for session alloc (setup) in nfs4_setup_sequence.
--- fs/nfs/client.c | 16 ++++++++++++++++ fs/nfs/internal.h | 1 + fs/nfs/nfs4proc.c | 2 ++ 3 files changed, 19 insertions(+), 0 deletions(-)
fs/nfs/client.c +16 -0
@@ -528,6 +528,22 @@ void nfs_mark_client_ready(struct nfs_client *clp, int state) }/* +* With sessions, the client is not marked ready until after a +* successful EXCHANGE_ID and CREATE_SESSION. +* +* Map errors cl_cons_state errors to EPROTONOSUPPORT to indicate +* other versions of NFS can be tried. +*/ +int nfs4_check_client_ready (struct nfs_client *clp) +{ +if (!nfs4_has_session (clp)) +return 0 ; +if (clp->cl_cons_state <NFS_CS_READY ) +return -EPROTONOSUPPORT ; +return 0 ; +} + +/* * Session has been established, and the client marked ready. * Set the mount rsize and wsize with negotiated fore channel * attributes which will be bound checked in nfs_server_set_fsinfo.
fs/nfs/internal.h +1 -0
@@ -101,6 +101,7 @@ extern struct nfs_server *nfs_clone_server(struct nfs_server *, struct nfs_fh *, struct nfs_fattr *);extern void nfs_mark_client_ready (struct nfs_client *clp,int state); +extern int nfs4_check_client_ready (struct nfs_client *clp);#ifdef CONFIG_PROC_FS extern int __init nfs_fs_proc_init (void );extern void nfs_fs_proc_exit (void );
fs/nfs/nfs4proc.c +2 -0
@@ -2041,6 +2041,8 @@ static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,nfs_fattr_init (info->fattr); status =nfs4_recover_expired_lease (server);if (!status) + status =nfs4_check_client_ready (server->nfs_client); +if (!status) status =nfs4_call_sync (server, &msg, &args, &res,0 );return status; }
Signature · 1 line
1.6.2.1
PATCH v2 67/67 nfs41: increment_{open,lock}_seqid
In reply to Benny HalevyUnlike minorversion0, in nfsv4.1 the open and lock seqids need not be incremented by the client and should always be set to zero.
This is implemented using a new nfs_rpc_ops methods - increment_open_seqid and increment_lock_seqid
--- fs/nfs/nfs4proc.c | 2 ++ fs/nfs/nfs4state.c | 12 +++++++----- 2 files changed, 9 insertions(+), 5 deletions(-)
fs/nfs/nfs4proc.c +2 -0
@@ -1820,6 +1820,8 @@ int nfs4_do_close(struct path *path, struct nfs4_state *state, int wait) calldata->state = state; calldata->arg.fh =NFS_FH (state->inode); calldata->arg.stateid = &state->open_stateid; +if (nfs4_has_session (server->nfs_client)) +memset (calldata->arg.stateid->data,0 ,4 );/* clear seqid */ /* Serialization for the sequence id */ calldata->arg.seqid =nfs_alloc_seqid (&state->owner->so_seqid);if (calldata->arg.seqid ==NULL )
fs/nfs/nfs4state.c +7 -5
@@ -742,12 +742,14 @@ static void nfs_increment_seqid(int status, struct nfs_seqid *seqid)void nfs_increment_open_seqid (int status,struct nfs_seqid *seqid) { -if (status == -NFS4ERR_BAD_SEQID ) { -struct nfs4_state_owner *sp =container_of (seqid->sequence, - struct nfs4_state_owner, so_seqid); +struct nfs4_state_owner *sp =container_of (seqid->sequence, + struct nfs4_state_owner, so_seqid); +struct nfs_server *server = sp->so_server; + +if (status == -NFS4ERR_BAD_SEQID )nfs4_drop_state_owner (sp); - } -nfs_increment_seqid (status, seqid); +if (!nfs4_has_session (server->nfs_client)) +nfs_increment_seqid (status, seqid); }/*
Signature · 1 line
1.6.2.1
Quoted 6 lines · Benny Halevy
Trond,
I've integrated the latest client patches from Andy (with a few minor changes listed below) and updated
git://linux-nfs.org/~bhalevy/linux-pnfs.git
branches:
Quoted 6 lines
nfs41-for-next nfs41-for-2.6.30 nfs41nfs41-for-{next,2.6.30} contain all non-backchannel patches rebased onto {v2.6.29,nfs-2.6/for-next} respectively.
I've rebased it onto the latest mainline tree and put the result out ongit://git.linux-nfs.org/projects/trondmy/nfs-2.6.git#nfsv41
Signature · 6 lines
Trond Myklebust Linux NFS client maintainer NetApp [email protected] www.netapp.com
A message that is not in the archive (sent off-list or not yet received): 1238873829.22935.4.camel-rJ7iovZKK19ZJLDQqaL3InhyD016LWXt@public.gmane.org
Quoted 11 lines · Trond Myklebust
Quoted 10 lines · Benny Halevy
Trond,
I've integrated the latest client patches from Andy (with a few minor changes listed below) and updated
git://linux-nfs.org/~bhalevy/linux-pnfs.git
branches:nfs41-for-next nfs41-for-2.6.30 nfs41
Quoted 7 lines
Quoted 2 lines
nfs41-for-{next,2.6.30} contain all non-backchannel patches rebased onto {v2.6.29,nfs-2.6/for-next} respectively.
I've rebased it onto the latest mainline tree and put the result out on
git://git.linux-nfs.org/projects/trondmy/nfs-2.6.git#nfsv41
Thanks!
Benny