fs/nfs/nfs4xdr.c

0001 /*
0002  *  fs/nfs/nfs4xdr.c
0003  *
0004  *  Client-side XDR for NFSv4.
0005  *
0006  *  Copyright (c) 2002 The Regents of the University of Michigan.
0007  *  All rights reserved.
0008  *
0009  *  Kendrick Smith <kmsmith@umich.edu>
0010  *  Andy Adamson   <andros@umich.edu>
0011  *
0012  *  Redistribution and use in source and binary forms, with or without
0013  *  modification, are permitted provided that the following conditions
0014  *  are met:
0015  *
0016  *  1. Redistributions of source code must retain the above copyright
0017  *     notice, this list of conditions and the following disclaimer.
0018  *  2. Redistributions in binary form must reproduce the above copyright
0019  *     notice, this list of conditions and the following disclaimer in the
0020  *     documentation and/or other materials provided with the distribution.
0021  *  3. Neither the name of the University nor the names of its
0022  *     contributors may be used to endorse or promote products derived
0023  *     from this software without specific prior written permission.
0024  *
0025  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
0026  *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
0027  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
0028  *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
0029  *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
0030  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
0031  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
0032  *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
0033  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
0034  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
0035  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
0036  */
0037
0038 #include <linux/param.h>
0039 #include <linux/time.h>
0040 #include <linux/mm.h>
0041 #include <linux/errno.h>
0042 #include <linux/string.h>
0043 #include <linux/in.h>
0044 #include <linux/pagemap.h>
0045 #include <linux/proc_fs.h>
0046 #include <linux/kdev_t.h>
0047 #include <linux/module.h>
0048 #include <linux/utsname.h>
0049 #include <linux/sunrpc/clnt.h>
0050 #include <linux/sunrpc/msg_prot.h>
0051 #include <linux/sunrpc/gss_api.h>
0052 #include <linux/nfs.h>
0053 #include <linux/nfs4.h>
0054 #include <linux/nfs_fs.h>
0055
0056 #include "nfs4_fs.h"
0057 #include "nfs4trace.h"
0058 #include "internal.h"
0059 #include "nfs4idmap.h"
0060 #include "nfs4session.h"
0061 #include "pnfs.h"
0062 #include "netns.h"
0063
0064 #define NFSDBG_FACILITY     NFSDBG_XDR
0065
0066 /* Mapping from NFS error code to "errno" error code. */
0067 #define errno_NFSERR_IO     EIO
0068
0069 struct compound_hdr;
0070 static int nfs4_stat_to_errno(int);
0071 static void encode_layoutget(struct xdr_stream *xdr,
0072                  const struct nfs4_layoutget_args *args,
0073                  struct compound_hdr *hdr);
0074 static int decode_layoutget(struct xdr_stream *xdr, struct rpc_rqst *req,
0075                  struct nfs4_layoutget_res *res);
0076
0077 /* NFSv4 COMPOUND tags are only wanted for debugging purposes */
0078 #ifdef DEBUG
0079 #define NFS4_MAXTAGLEN      20
0080 #else
0081 #define NFS4_MAXTAGLEN      0
0082 #endif
0083
0084 /* lock,open owner id:
0085  * we currently use size 2 (u64) out of (NFS4_OPAQUE_LIMIT  >> 2)
0086  */
0087 #define pagepad_maxsz       (1)
0088 #define open_owner_id_maxsz (1 + 2 + 1 + 1 + 2)
0089 #define lock_owner_id_maxsz (1 + 1 + 4)
0090 #define decode_lockowner_maxsz  (1 + XDR_QUADLEN(IDMAP_NAMESZ))
0091 #define compound_encode_hdr_maxsz   (3 + (NFS4_MAXTAGLEN >> 2))
0092 #define compound_decode_hdr_maxsz   (3 + (NFS4_MAXTAGLEN >> 2))
0093 #define op_encode_hdr_maxsz (1)
0094 #define op_decode_hdr_maxsz (2)
0095 #define encode_stateid_maxsz    (XDR_QUADLEN(NFS4_STATEID_SIZE))
0096 #define decode_stateid_maxsz    (XDR_QUADLEN(NFS4_STATEID_SIZE))
0097 #define encode_verifier_maxsz   (XDR_QUADLEN(NFS4_VERIFIER_SIZE))
0098 #define decode_verifier_maxsz   (XDR_QUADLEN(NFS4_VERIFIER_SIZE))
0099 #define encode_putfh_maxsz  (op_encode_hdr_maxsz + 1 + \
0100                 (NFS4_FHSIZE >> 2))
0101 #define decode_putfh_maxsz  (op_decode_hdr_maxsz)
0102 #define encode_putrootfh_maxsz  (op_encode_hdr_maxsz)
0103 #define decode_putrootfh_maxsz  (op_decode_hdr_maxsz)
0104 #define encode_getfh_maxsz      (op_encode_hdr_maxsz)
0105 #define decode_getfh_maxsz      (op_decode_hdr_maxsz + 1 + \
0106                 ((3+NFS4_FHSIZE) >> 2))
0107 #define nfs4_fattr_bitmap_maxsz 4
0108 #define encode_getattr_maxsz    (op_encode_hdr_maxsz + nfs4_fattr_bitmap_maxsz)
0109 #define nfstime4_maxsz      (3)
0110 #define nfs4_name_maxsz     (1 + ((3 + NFS4_MAXNAMLEN) >> 2))
0111 #define nfs4_path_maxsz     (1 + ((3 + NFS4_MAXPATHLEN) >> 2))
0112 #define nfs4_owner_maxsz    (1 + XDR_QUADLEN(IDMAP_NAMESZ))
0113 #define nfs4_group_maxsz    (1 + XDR_QUADLEN(IDMAP_NAMESZ))
0114 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
0115 /* PI(4 bytes) + LFS(4 bytes) + 1(for null terminator?) + MAXLABELLEN */
0116 #define nfs4_label_maxsz    (4 + 4 + 1 + XDR_QUADLEN(NFS4_MAXLABELLEN))
0117 #else
0118 #define nfs4_label_maxsz    0
0119 #endif
0120 /* We support only one layout type per file system */
0121 #define decode_mdsthreshold_maxsz (1 + 1 + nfs4_fattr_bitmap_maxsz + 1 + 8)
0122 /* This is based on getfattr, which uses the most attributes: */
0123 #define nfs4_fattr_value_maxsz  (1 + (1 + 2 + 2 + 4 + 2 + 1 + 1 + 2 + 2 + \
0124                 3*nfstime4_maxsz + \
0125                 nfs4_owner_maxsz + \
0126                 nfs4_group_maxsz + nfs4_label_maxsz + \
0127                  decode_mdsthreshold_maxsz))
0128 #define nfs4_fattr_maxsz    (nfs4_fattr_bitmap_maxsz + \
0129                 nfs4_fattr_value_maxsz)
0130 #define decode_getattr_maxsz    (op_decode_hdr_maxsz + nfs4_fattr_maxsz)
0131 #define encode_attrs_maxsz  (nfs4_fattr_bitmap_maxsz + \
0132                  1 + 2 + 1 + \
0133                 nfs4_owner_maxsz + \
0134                 nfs4_group_maxsz + \
0135                 nfs4_label_maxsz + \
0136                 1 + nfstime4_maxsz + \
0137                 1 + nfstime4_maxsz)
0138 #define encode_savefh_maxsz     (op_encode_hdr_maxsz)
0139 #define decode_savefh_maxsz     (op_decode_hdr_maxsz)
0140 #define encode_restorefh_maxsz  (op_encode_hdr_maxsz)
0141 #define decode_restorefh_maxsz  (op_decode_hdr_maxsz)
0142 #define encode_fsinfo_maxsz (encode_getattr_maxsz)
0143 /* The 5 accounts for the PNFS attributes, and assumes that at most three
0144  * layout types will be returned.
0145  */
0146 #define decode_fsinfo_maxsz (op_decode_hdr_maxsz + \
0147                  nfs4_fattr_bitmap_maxsz + 1 + \
0148                  1 /* lease time */ + \
0149                  2 /* max filesize */ + \
0150                  2 /* max read */ + \
0151                  2 /* max write */ + \
0152                  nfstime4_maxsz /* time delta */ + \
0153                  5 /* fs layout types */ + \
0154                  1 /* layout blksize */ + \
0155                  1 /* clone blksize */ + \
0156                  1 /* change attr type */ + \
0157                  1 /* xattr support */)
0158 #define encode_renew_maxsz  (op_encode_hdr_maxsz + 3)
0159 #define decode_renew_maxsz  (op_decode_hdr_maxsz)
0160 #define encode_setclientid_maxsz \
0161                 (op_encode_hdr_maxsz + \
0162                 XDR_QUADLEN(NFS4_VERIFIER_SIZE) + \
0163                 /* client name */ \
0164                 1 + XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + \
0165                 1 /* sc_prog */ + \
0166                 1 + XDR_QUADLEN(RPCBIND_MAXNETIDLEN) + \
0167                 1 + XDR_QUADLEN(RPCBIND_MAXUADDRLEN) + \
0168                 1) /* sc_cb_ident */
0169 #define decode_setclientid_maxsz \
0170                 (op_decode_hdr_maxsz + \
0171                 2 /* clientid */ + \
0172                 XDR_QUADLEN(NFS4_VERIFIER_SIZE) + \
0173                 1 + XDR_QUADLEN(RPCBIND_MAXNETIDLEN) + \
0174                 1 + XDR_QUADLEN(RPCBIND_MAXUADDRLEN))
0175 #define encode_setclientid_confirm_maxsz \
0176                 (op_encode_hdr_maxsz + \
0177                 3 + (NFS4_VERIFIER_SIZE >> 2))
0178 #define decode_setclientid_confirm_maxsz \
0179                 (op_decode_hdr_maxsz)
0180 #define encode_lookup_maxsz (op_encode_hdr_maxsz + nfs4_name_maxsz)
0181 #define decode_lookup_maxsz (op_decode_hdr_maxsz)
0182 #define encode_lookupp_maxsz    (op_encode_hdr_maxsz)
0183 #define decode_lookupp_maxsz    (op_decode_hdr_maxsz)
0184 #define encode_share_access_maxsz \
0185                 (2)
0186 #define encode_createmode_maxsz (1 + encode_attrs_maxsz + encode_verifier_maxsz)
0187 #define encode_opentype_maxsz   (1 + encode_createmode_maxsz)
0188 #define encode_claim_null_maxsz (1 + nfs4_name_maxsz)
0189 #define encode_open_maxsz   (op_encode_hdr_maxsz + \
0190                 2 + encode_share_access_maxsz + 2 + \
0191                 open_owner_id_maxsz + \
0192                 encode_opentype_maxsz + \
0193                 encode_claim_null_maxsz)
0194 #define decode_space_limit_maxsz    (3)
0195 #define decode_ace_maxsz    (3 + nfs4_owner_maxsz)
0196 #define decode_delegation_maxsz (1 + decode_stateid_maxsz + 1 + \
0197                 decode_space_limit_maxsz + \
0198                 decode_ace_maxsz)
0199 #define decode_change_info_maxsz    (5)
0200 #define decode_open_maxsz   (op_decode_hdr_maxsz + \
0201                 decode_stateid_maxsz + \
0202                 decode_change_info_maxsz + 1 + \
0203                 nfs4_fattr_bitmap_maxsz + \
0204                 decode_delegation_maxsz)
0205 #define encode_open_confirm_maxsz \
0206                 (op_encode_hdr_maxsz + \
0207                  encode_stateid_maxsz + 1)
0208 #define decode_open_confirm_maxsz \
0209                 (op_decode_hdr_maxsz + \
0210                  decode_stateid_maxsz)
0211 #define encode_open_downgrade_maxsz \
0212                 (op_encode_hdr_maxsz + \
0213                  encode_stateid_maxsz + 1 + \
0214                  encode_share_access_maxsz)
0215 #define decode_open_downgrade_maxsz \
0216                 (op_decode_hdr_maxsz + \
0217                  decode_stateid_maxsz)
0218 #define encode_close_maxsz  (op_encode_hdr_maxsz + \
0219                  1 + encode_stateid_maxsz)
0220 #define decode_close_maxsz  (op_decode_hdr_maxsz + \
0221                  decode_stateid_maxsz)
0222 #define encode_setattr_maxsz    (op_encode_hdr_maxsz + \
0223                  encode_stateid_maxsz + \
0224                  encode_attrs_maxsz)
0225 #define decode_setattr_maxsz    (op_decode_hdr_maxsz + \
0226                  nfs4_fattr_bitmap_maxsz)
0227 #define encode_read_maxsz   (op_encode_hdr_maxsz + \
0228                  encode_stateid_maxsz + 3)
0229 #define decode_read_maxsz   (op_decode_hdr_maxsz + 2 + pagepad_maxsz)
0230 #define encode_readdir_maxsz    (op_encode_hdr_maxsz + \
0231                  2 + encode_verifier_maxsz + 5 + \
0232                 nfs4_label_maxsz)
0233 #define decode_readdir_maxsz    (op_decode_hdr_maxsz + \
0234                  decode_verifier_maxsz + pagepad_maxsz)
0235 #define encode_readlink_maxsz   (op_encode_hdr_maxsz)
0236 #define decode_readlink_maxsz   (op_decode_hdr_maxsz + 1 + pagepad_maxsz)
0237 #define encode_write_maxsz  (op_encode_hdr_maxsz + \
0238                  encode_stateid_maxsz + 4)
0239 #define decode_write_maxsz  (op_decode_hdr_maxsz + \
0240                  2 + decode_verifier_maxsz)
0241 #define encode_commit_maxsz (op_encode_hdr_maxsz + 3)
0242 #define decode_commit_maxsz (op_decode_hdr_maxsz + \
0243                  decode_verifier_maxsz)
0244 #define encode_remove_maxsz (op_encode_hdr_maxsz + \
0245                 nfs4_name_maxsz)
0246 #define decode_remove_maxsz (op_decode_hdr_maxsz + \
0247                  decode_change_info_maxsz)
0248 #define encode_rename_maxsz (op_encode_hdr_maxsz + \
0249                 2 * nfs4_name_maxsz)
0250 #define decode_rename_maxsz (op_decode_hdr_maxsz + \
0251                  decode_change_info_maxsz + \
0252                  decode_change_info_maxsz)
0253 #define encode_link_maxsz   (op_encode_hdr_maxsz + \
0254                 nfs4_name_maxsz)
0255 #define decode_link_maxsz   (op_decode_hdr_maxsz + decode_change_info_maxsz)
0256 #define encode_lockowner_maxsz  (7)
0257 #define encode_lock_maxsz   (op_encode_hdr_maxsz + \
0258                  7 + \
0259                  1 + encode_stateid_maxsz + 1 + \
0260                  encode_lockowner_maxsz)
0261 #define decode_lock_denied_maxsz \
0262                 (8 + decode_lockowner_maxsz)
0263 #define decode_lock_maxsz   (op_decode_hdr_maxsz + \
0264                  decode_lock_denied_maxsz)
0265 #define encode_lockt_maxsz  (op_encode_hdr_maxsz + 5 + \
0266                 encode_lockowner_maxsz)
0267 #define decode_lockt_maxsz  (op_decode_hdr_maxsz + \
0268                  decode_lock_denied_maxsz)
0269 #define encode_locku_maxsz  (op_encode_hdr_maxsz + 3 + \
0270                  encode_stateid_maxsz + \
0271                  4)
0272 #define decode_locku_maxsz  (op_decode_hdr_maxsz + \
0273                  decode_stateid_maxsz)
0274 #define encode_release_lockowner_maxsz \
0275                 (op_encode_hdr_maxsz + \
0276                  encode_lockowner_maxsz)
0277 #define decode_release_lockowner_maxsz \
0278                 (op_decode_hdr_maxsz)
0279 #define encode_access_maxsz (op_encode_hdr_maxsz + 1)
0280 #define decode_access_maxsz (op_decode_hdr_maxsz + 2)
0281 #define encode_symlink_maxsz    (op_encode_hdr_maxsz + \
0282                 1 + nfs4_name_maxsz + \
0283                 1 + \
0284                 nfs4_fattr_maxsz)
0285 #define decode_symlink_maxsz    (op_decode_hdr_maxsz + 8)
0286 #define encode_create_maxsz (op_encode_hdr_maxsz + \
0287                 1 + 2 + nfs4_name_maxsz + \
0288                 encode_attrs_maxsz)
0289 #define decode_create_maxsz (op_decode_hdr_maxsz + \
0290                 decode_change_info_maxsz + \
0291                 nfs4_fattr_bitmap_maxsz)
0292 #define encode_statfs_maxsz (encode_getattr_maxsz)
0293 #define decode_statfs_maxsz (decode_getattr_maxsz)
0294 #define encode_delegreturn_maxsz (op_encode_hdr_maxsz + 4)
0295 #define decode_delegreturn_maxsz (op_decode_hdr_maxsz)
0296 #define encode_getacl_maxsz (encode_getattr_maxsz)
0297 #define decode_getacl_maxsz (op_decode_hdr_maxsz + \
0298                  nfs4_fattr_bitmap_maxsz + 1 + pagepad_maxsz)
0299 #define encode_setacl_maxsz (op_encode_hdr_maxsz + \
0300                  encode_stateid_maxsz + 3)
0301 #define decode_setacl_maxsz (decode_setattr_maxsz)
0302 #define encode_fs_locations_maxsz \
0303                 (encode_getattr_maxsz)
0304 #define decode_fs_locations_maxsz \
0305                 (pagepad_maxsz)
0306 #define encode_secinfo_maxsz    (op_encode_hdr_maxsz + nfs4_name_maxsz)
0307 #define decode_secinfo_maxsz    (op_decode_hdr_maxsz + 1 + ((NFS_MAX_SECFLAVORS * (16 + GSS_OID_MAX_LEN)) / 4))
0308
0309 #if defined(CONFIG_NFS_V4_1)
0310 #define NFS4_MAX_MACHINE_NAME_LEN (64)
0311 #define IMPL_NAME_LIMIT (sizeof(utsname()->sysname) + sizeof(utsname()->release) + \
0312              sizeof(utsname()->version) + sizeof(utsname()->machine) + 8)
0313
0314 #define encode_exchange_id_maxsz (op_encode_hdr_maxsz + \
0315                 encode_verifier_maxsz + \
0316                 1 /* co_ownerid.len */ + \
0317                 /* eia_clientowner */ \
0318                 1 + XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + \
0319                 1 /* flags */ + \
0320                 1 /* spa_how */ + \
0321                 /* max is SP4_MACH_CRED (for now) */ + \
0322                 1 + NFS4_OP_MAP_NUM_WORDS + \
0323                 1 + NFS4_OP_MAP_NUM_WORDS + \
0324                 1 /* implementation id array of size 1 */ + \
0325                 1 /* nii_domain */ + \
0326                 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + \
0327                 1 /* nii_name */ + \
0328                 XDR_QUADLEN(IMPL_NAME_LIMIT) + \
0329                 3 /* nii_date */)
0330 #define decode_exchange_id_maxsz (op_decode_hdr_maxsz + \
0331                 2 /* eir_clientid */ + \
0332                 1 /* eir_sequenceid */ + \
0333                 1 /* eir_flags */ + \
0334                 1 /* spr_how */ + \
0335                   /* max is SP4_MACH_CRED (for now) */ + \
0336                 1 + NFS4_OP_MAP_NUM_WORDS + \
0337                 1 + NFS4_OP_MAP_NUM_WORDS + \
0338                 2 /* eir_server_owner.so_minor_id */ + \
0339                 /* eir_server_owner.so_major_id<> */ \
0340                 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 + \
0341                 /* eir_server_scope<> */ \
0342                 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 + \
0343                 1 /* eir_server_impl_id array length */ + \
0344                 1 /* nii_domain */ + \
0345                 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + \
0346                 1 /* nii_name */ + \
0347                 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + \
0348                 3 /* nii_date */)
0349 #define encode_channel_attrs_maxsz  (6 + 1 /* ca_rdma_ird.len (0) */)
0350 #define decode_channel_attrs_maxsz  (6 + \
0351                      1 /* ca_rdma_ird.len */ + \
0352                      1 /* ca_rdma_ird */)
0353 #define encode_create_session_maxsz  (op_encode_hdr_maxsz + \
0354                      2 /* csa_clientid */ + \
0355                      1 /* csa_sequence */ + \
0356                      1 /* csa_flags */ + \
0357                      encode_channel_attrs_maxsz + \
0358                      encode_channel_attrs_maxsz + \
0359                      1 /* csa_cb_program */ + \
0360                      1 /* csa_sec_parms.len (1) */ + \
0361                      1 /* cb_secflavor (AUTH_SYS) */ + \
0362                      1 /* stamp */ + \
0363                      1 /* machinename.len */ + \
0364                      XDR_QUADLEN(NFS4_MAX_MACHINE_NAME_LEN) + \
0365                      1 /* uid */ + \
0366                      1 /* gid */ + \
0367                      1 /* gids.len (0) */)
0368 #define decode_create_session_maxsz  (op_decode_hdr_maxsz + \
0369                      XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
0370                      1 /* csr_sequence */ + \
0371                      1 /* csr_flags */ + \
0372                      decode_channel_attrs_maxsz + \
0373                      decode_channel_attrs_maxsz)
0374 #define encode_bind_conn_to_session_maxsz  (op_encode_hdr_maxsz + \
0375                      /* bctsa_sessid */ \
0376                      XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
0377                      1 /* bctsa_dir */ + \
0378                      1 /* bctsa_use_conn_in_rdma_mode */)
0379 #define decode_bind_conn_to_session_maxsz  (op_decode_hdr_maxsz +   \
0380                      /* bctsr_sessid */ \
0381                      XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
0382                      1 /* bctsr_dir */ + \
0383                      1 /* bctsr_use_conn_in_rdma_mode */)
0384 #define encode_destroy_session_maxsz    (op_encode_hdr_maxsz + 4)
0385 #define decode_destroy_session_maxsz    (op_decode_hdr_maxsz)
0386 #define encode_destroy_clientid_maxsz   (op_encode_hdr_maxsz + 2)
0387 #define decode_destroy_clientid_maxsz   (op_decode_hdr_maxsz)
0388 #define encode_sequence_maxsz   (op_encode_hdr_maxsz + \
0389                 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + 4)
0390 #define decode_sequence_maxsz   (op_decode_hdr_maxsz + \
0391                 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + 5)
0392 #define encode_reclaim_complete_maxsz   (op_encode_hdr_maxsz + 4)
0393 #define decode_reclaim_complete_maxsz   (op_decode_hdr_maxsz + 4)
0394 #define encode_getdeviceinfo_maxsz (op_encode_hdr_maxsz + \
0395                 XDR_QUADLEN(NFS4_DEVICEID4_SIZE) + \
0396                 1 /* layout type */ + \
0397                 1 /* maxcount */ + \
0398                 1 /* bitmap size */ + \
0399                 1 /* notification bitmap length */ + \
0400                 1 /* notification bitmap, word 0 */)
0401 #define decode_getdeviceinfo_maxsz (op_decode_hdr_maxsz + \
0402                 1 /* layout type */ + \
0403                 1 /* opaque devaddr4 length */ + \
0404                   /* devaddr4 payload is read into page */ \
0405                 1 /* notification bitmap length */ + \
0406                 1 /* notification bitmap, word 0 */ + \
0407                 pagepad_maxsz /* possible XDR padding */)
0408 #define encode_layoutget_maxsz  (op_encode_hdr_maxsz + 10 + \
0409                 encode_stateid_maxsz)
0410 #define decode_layoutget_maxsz  (op_decode_hdr_maxsz + 8 + \
0411                 decode_stateid_maxsz + \
0412                 XDR_QUADLEN(PNFS_LAYOUT_MAXSIZE) + \
0413                 pagepad_maxsz)
0414 #define encode_layoutcommit_maxsz (op_encode_hdr_maxsz +          \
0415                 2 /* offset */ + \
0416                 2 /* length */ + \
0417                 1 /* reclaim */ + \
0418                 encode_stateid_maxsz + \
0419                 1 /* new offset (true) */ + \
0420                 2 /* last byte written */ + \
0421                 1 /* nt_timechanged (false) */ + \
0422                 1 /* layoutupdate4 layout type */ + \
0423                 1 /* layoutupdate4 opaqueue len */)
0424                   /* the actual content of layoutupdate4 should
0425                      be allocated by drivers and spliced in
0426                      using xdr_write_pages */
0427 #define decode_layoutcommit_maxsz (op_decode_hdr_maxsz + 3)
0428 #define encode_layoutreturn_maxsz (8 + op_encode_hdr_maxsz + \
0429                 encode_stateid_maxsz + \
0430                 1 + \
0431                 XDR_QUADLEN(NFS4_OPAQUE_LIMIT))
0432 #define decode_layoutreturn_maxsz (op_decode_hdr_maxsz + \
0433                 1 + decode_stateid_maxsz)
0434 #define encode_secinfo_no_name_maxsz (op_encode_hdr_maxsz + 1)
0435 #define decode_secinfo_no_name_maxsz decode_secinfo_maxsz
0436 #define encode_test_stateid_maxsz   (op_encode_hdr_maxsz + 2 + \
0437                      XDR_QUADLEN(NFS4_STATEID_SIZE))
0438 #define decode_test_stateid_maxsz   (op_decode_hdr_maxsz + 2 + 1)
0439 #define encode_free_stateid_maxsz   (op_encode_hdr_maxsz + 1 + \
0440                      XDR_QUADLEN(NFS4_STATEID_SIZE))
0441 #define decode_free_stateid_maxsz   (op_decode_hdr_maxsz)
0442 #else /* CONFIG_NFS_V4_1 */
0443 #define encode_sequence_maxsz   0
0444 #define decode_sequence_maxsz   0
0445 #define encode_layoutreturn_maxsz 0
0446 #define decode_layoutreturn_maxsz 0
0447 #define encode_layoutget_maxsz  0
0448 #define decode_layoutget_maxsz  0
0449 #endif /* CONFIG_NFS_V4_1 */
0450
0451 #define NFS4_enc_compound_sz    (1024)  /* XXX: large enough? */
0452 #define NFS4_dec_compound_sz    (1024)  /* XXX: large enough? */
0453 #define NFS4_enc_read_sz    (compound_encode_hdr_maxsz + \
0454                 encode_sequence_maxsz + \
0455                 encode_putfh_maxsz + \
0456                 encode_read_maxsz)
0457 #define NFS4_dec_read_sz    (compound_decode_hdr_maxsz + \
0458                 decode_sequence_maxsz + \
0459                 decode_putfh_maxsz + \
0460                 decode_read_maxsz)
0461 #define NFS4_enc_readlink_sz    (compound_encode_hdr_maxsz + \
0462                 encode_sequence_maxsz + \
0463                 encode_putfh_maxsz + \
0464                 encode_readlink_maxsz)
0465 #define NFS4_dec_readlink_sz    (compound_decode_hdr_maxsz + \
0466                 decode_sequence_maxsz + \
0467                 decode_putfh_maxsz + \
0468                 decode_readlink_maxsz)
0469 #define NFS4_enc_readdir_sz (compound_encode_hdr_maxsz + \
0470                 encode_sequence_maxsz + \
0471                 encode_putfh_maxsz + \
0472                 encode_readdir_maxsz)
0473 #define NFS4_dec_readdir_sz (compound_decode_hdr_maxsz + \
0474                 decode_sequence_maxsz + \
0475                 decode_putfh_maxsz + \
0476                 decode_readdir_maxsz)
0477 #define NFS4_enc_write_sz   (compound_encode_hdr_maxsz + \
0478                 encode_sequence_maxsz + \
0479                 encode_putfh_maxsz + \
0480                 encode_write_maxsz + \
0481                 encode_getattr_maxsz)
0482 #define NFS4_dec_write_sz   (compound_decode_hdr_maxsz + \
0483                 decode_sequence_maxsz + \
0484                 decode_putfh_maxsz + \
0485                 decode_write_maxsz + \
0486                 decode_getattr_maxsz)
0487 #define NFS4_enc_commit_sz  (compound_encode_hdr_maxsz + \
0488                 encode_sequence_maxsz + \
0489                 encode_putfh_maxsz + \
0490                 encode_commit_maxsz)
0491 #define NFS4_dec_commit_sz  (compound_decode_hdr_maxsz + \
0492                 decode_sequence_maxsz + \
0493                 decode_putfh_maxsz + \
0494                 decode_commit_maxsz)
0495 #define NFS4_enc_open_sz        (compound_encode_hdr_maxsz + \
0496                 encode_sequence_maxsz + \
0497                 encode_putfh_maxsz + \
0498                 encode_open_maxsz + \
0499                 encode_access_maxsz + \
0500                 encode_getfh_maxsz + \
0501                 encode_getattr_maxsz + \
0502                 encode_layoutget_maxsz)
0503 #define NFS4_dec_open_sz        (compound_decode_hdr_maxsz + \
0504                 decode_sequence_maxsz + \
0505                 decode_putfh_maxsz + \
0506                 decode_open_maxsz + \
0507                 decode_access_maxsz + \
0508                 decode_getfh_maxsz + \
0509                 decode_getattr_maxsz + \
0510                 decode_layoutget_maxsz)
0511 #define NFS4_enc_open_confirm_sz \
0512                 (compound_encode_hdr_maxsz + \
0513                  encode_putfh_maxsz + \
0514                  encode_open_confirm_maxsz)
0515 #define NFS4_dec_open_confirm_sz \
0516                 (compound_decode_hdr_maxsz + \
0517                  decode_putfh_maxsz + \
0518                  decode_open_confirm_maxsz)
0519 #define NFS4_enc_open_noattr_sz (compound_encode_hdr_maxsz + \
0520                     encode_sequence_maxsz + \
0521                     encode_putfh_maxsz + \
0522                     encode_open_maxsz + \
0523                     encode_access_maxsz + \
0524                     encode_getattr_maxsz + \
0525                     encode_layoutget_maxsz)
0526 #define NFS4_dec_open_noattr_sz (compound_decode_hdr_maxsz + \
0527                     decode_sequence_maxsz + \
0528                     decode_putfh_maxsz + \
0529                     decode_open_maxsz + \
0530                     decode_access_maxsz + \
0531                     decode_getattr_maxsz + \
0532                     decode_layoutget_maxsz)
0533 #define NFS4_enc_open_downgrade_sz \
0534                 (compound_encode_hdr_maxsz + \
0535                  encode_sequence_maxsz + \
0536                  encode_putfh_maxsz + \
0537                  encode_layoutreturn_maxsz + \
0538                  encode_open_downgrade_maxsz)
0539 #define NFS4_dec_open_downgrade_sz \
0540                 (compound_decode_hdr_maxsz + \
0541                  decode_sequence_maxsz + \
0542                  decode_putfh_maxsz + \
0543                  decode_layoutreturn_maxsz + \
0544                  decode_open_downgrade_maxsz)
0545 #define NFS4_enc_close_sz   (compound_encode_hdr_maxsz + \
0546                  encode_sequence_maxsz + \
0547                  encode_putfh_maxsz + \
0548                  encode_layoutreturn_maxsz + \
0549                  encode_close_maxsz + \
0550                  encode_getattr_maxsz)
0551 #define NFS4_dec_close_sz   (compound_decode_hdr_maxsz + \
0552                  decode_sequence_maxsz + \
0553                  decode_putfh_maxsz + \
0554                  decode_layoutreturn_maxsz + \
0555                  decode_close_maxsz + \
0556                  decode_getattr_maxsz)
0557 #define NFS4_enc_setattr_sz (compound_encode_hdr_maxsz + \
0558                  encode_sequence_maxsz + \
0559                  encode_putfh_maxsz + \
0560                  encode_setattr_maxsz + \
0561                  encode_getattr_maxsz)
0562 #define NFS4_dec_setattr_sz (compound_decode_hdr_maxsz + \
0563                  decode_sequence_maxsz + \
0564                  decode_putfh_maxsz + \
0565                  decode_setattr_maxsz + \
0566                  decode_getattr_maxsz)
0567 #define NFS4_enc_fsinfo_sz  (compound_encode_hdr_maxsz + \
0568                 encode_sequence_maxsz + \
0569                 encode_putfh_maxsz + \
0570                 encode_fsinfo_maxsz)
0571 #define NFS4_dec_fsinfo_sz  (compound_decode_hdr_maxsz + \
0572                 decode_sequence_maxsz + \
0573                 decode_putfh_maxsz + \
0574                 decode_fsinfo_maxsz)
0575 #define NFS4_enc_renew_sz   (compound_encode_hdr_maxsz + \
0576                 encode_renew_maxsz)
0577 #define NFS4_dec_renew_sz   (compound_decode_hdr_maxsz + \
0578                 decode_renew_maxsz)
0579 #define NFS4_enc_setclientid_sz (compound_encode_hdr_maxsz + \
0580                 encode_setclientid_maxsz)
0581 #define NFS4_dec_setclientid_sz (compound_decode_hdr_maxsz + \
0582                 decode_setclientid_maxsz)
0583 #define NFS4_enc_setclientid_confirm_sz \
0584                 (compound_encode_hdr_maxsz + \
0585                 encode_setclientid_confirm_maxsz)
0586 #define NFS4_dec_setclientid_confirm_sz \
0587                 (compound_decode_hdr_maxsz + \
0588                 decode_setclientid_confirm_maxsz)
0589 #define NFS4_enc_lock_sz        (compound_encode_hdr_maxsz + \
0590                 encode_sequence_maxsz + \
0591                 encode_putfh_maxsz + \
0592                 encode_lock_maxsz)
0593 #define NFS4_dec_lock_sz        (compound_decode_hdr_maxsz + \
0594                 decode_sequence_maxsz + \
0595                 decode_putfh_maxsz + \
0596                 decode_lock_maxsz)
0597 #define NFS4_enc_lockt_sz       (compound_encode_hdr_maxsz + \
0598                 encode_sequence_maxsz + \
0599                 encode_putfh_maxsz + \
0600                 encode_lockt_maxsz)
0601 #define NFS4_dec_lockt_sz       (compound_decode_hdr_maxsz + \
0602                  decode_sequence_maxsz + \
0603                  decode_putfh_maxsz + \
0604                  decode_lockt_maxsz)
0605 #define NFS4_enc_locku_sz       (compound_encode_hdr_maxsz + \
0606                 encode_sequence_maxsz + \
0607                 encode_putfh_maxsz + \
0608                 encode_locku_maxsz)
0609 #define NFS4_dec_locku_sz       (compound_decode_hdr_maxsz + \
0610                 decode_sequence_maxsz + \
0611                 decode_putfh_maxsz + \
0612                 decode_locku_maxsz)
0613 #define NFS4_enc_release_lockowner_sz \
0614                 (compound_encode_hdr_maxsz + \
0615                  encode_lockowner_maxsz)
0616 #define NFS4_dec_release_lockowner_sz \
0617                 (compound_decode_hdr_maxsz + \
0618                  decode_lockowner_maxsz)
0619 #define NFS4_enc_access_sz  (compound_encode_hdr_maxsz + \
0620                 encode_sequence_maxsz + \
0621                 encode_putfh_maxsz + \
0622                 encode_access_maxsz + \
0623                 encode_getattr_maxsz)
0624 #define NFS4_dec_access_sz  (compound_decode_hdr_maxsz + \
0625                 decode_sequence_maxsz + \
0626                 decode_putfh_maxsz + \
0627                 decode_access_maxsz + \
0628                 decode_getattr_maxsz)
0629 #define NFS4_enc_getattr_sz (compound_encode_hdr_maxsz + \
0630                 encode_sequence_maxsz + \
0631                 encode_putfh_maxsz + \
0632                 encode_getattr_maxsz + \
0633                 encode_renew_maxsz)
0634 #define NFS4_dec_getattr_sz (compound_decode_hdr_maxsz + \
0635                 decode_sequence_maxsz + \
0636                 decode_putfh_maxsz + \
0637                 decode_getattr_maxsz + \
0638                 decode_renew_maxsz)
0639 #define NFS4_enc_lookup_sz  (compound_encode_hdr_maxsz + \
0640                 encode_sequence_maxsz + \
0641                 encode_putfh_maxsz + \
0642                 encode_lookup_maxsz + \
0643                 encode_getattr_maxsz + \
0644                 encode_getfh_maxsz)
0645 #define NFS4_dec_lookup_sz  (compound_decode_hdr_maxsz + \
0646                 decode_sequence_maxsz + \
0647                 decode_putfh_maxsz + \
0648                 decode_lookup_maxsz + \
0649                 decode_getattr_maxsz + \
0650                 decode_getfh_maxsz)
0651 #define NFS4_enc_lookupp_sz (compound_encode_hdr_maxsz + \
0652                 encode_sequence_maxsz + \
0653                 encode_putfh_maxsz + \
0654                 encode_lookupp_maxsz + \
0655                 encode_getattr_maxsz + \
0656                 encode_getfh_maxsz)
0657 #define NFS4_dec_lookupp_sz (compound_decode_hdr_maxsz + \
0658                 decode_sequence_maxsz + \
0659                 decode_putfh_maxsz + \
0660                 decode_lookupp_maxsz + \
0661                 decode_getattr_maxsz + \
0662                 decode_getfh_maxsz)
0663 #define NFS4_enc_lookup_root_sz (compound_encode_hdr_maxsz + \
0664                 encode_sequence_maxsz + \
0665                 encode_putrootfh_maxsz + \
0666                 encode_getattr_maxsz + \
0667                 encode_getfh_maxsz)
0668 #define NFS4_dec_lookup_root_sz (compound_decode_hdr_maxsz + \
0669                 decode_sequence_maxsz + \
0670                 decode_putrootfh_maxsz + \
0671                 decode_getattr_maxsz + \
0672                 decode_getfh_maxsz)
0673 #define NFS4_enc_remove_sz  (compound_encode_hdr_maxsz + \
0674                 encode_sequence_maxsz + \
0675                 encode_putfh_maxsz + \
0676                 encode_remove_maxsz)
0677 #define NFS4_dec_remove_sz  (compound_decode_hdr_maxsz + \
0678                 decode_sequence_maxsz + \
0679                 decode_putfh_maxsz + \
0680                 decode_remove_maxsz)
0681 #define NFS4_enc_rename_sz  (compound_encode_hdr_maxsz + \
0682                 encode_sequence_maxsz + \
0683                 encode_putfh_maxsz + \
0684                 encode_savefh_maxsz + \
0685                 encode_putfh_maxsz + \
0686                 encode_rename_maxsz)
0687 #define NFS4_dec_rename_sz  (compound_decode_hdr_maxsz + \
0688                 decode_sequence_maxsz + \
0689                 decode_putfh_maxsz + \
0690                 decode_savefh_maxsz + \
0691                 decode_putfh_maxsz + \
0692                 decode_rename_maxsz)
0693 #define NFS4_enc_link_sz    (compound_encode_hdr_maxsz + \
0694                 encode_sequence_maxsz + \
0695                 encode_putfh_maxsz + \
0696                 encode_savefh_maxsz + \
0697                 encode_putfh_maxsz + \
0698                 encode_link_maxsz + \
0699                 encode_restorefh_maxsz + \
0700                 encode_getattr_maxsz)
0701 #define NFS4_dec_link_sz    (compound_decode_hdr_maxsz + \
0702                 decode_sequence_maxsz + \
0703                 decode_putfh_maxsz + \
0704                 decode_savefh_maxsz + \
0705                 decode_putfh_maxsz + \
0706                 decode_link_maxsz + \
0707                 decode_restorefh_maxsz + \
0708                 decode_getattr_maxsz)
0709 #define NFS4_enc_symlink_sz (compound_encode_hdr_maxsz + \
0710                 encode_sequence_maxsz + \
0711                 encode_putfh_maxsz + \
0712                 encode_symlink_maxsz + \
0713                 encode_getattr_maxsz + \
0714                 encode_getfh_maxsz)
0715 #define NFS4_dec_symlink_sz (compound_decode_hdr_maxsz + \
0716                 decode_sequence_maxsz + \
0717                 decode_putfh_maxsz + \
0718                 decode_symlink_maxsz + \
0719                 decode_getattr_maxsz + \
0720                 decode_getfh_maxsz)
0721 #define NFS4_enc_create_sz  (compound_encode_hdr_maxsz + \
0722                 encode_sequence_maxsz + \
0723                 encode_putfh_maxsz + \
0724                 encode_create_maxsz + \
0725                 encode_getfh_maxsz + \
0726                 encode_getattr_maxsz)
0727 #define NFS4_dec_create_sz  (compound_decode_hdr_maxsz + \
0728                 decode_sequence_maxsz + \
0729                 decode_putfh_maxsz + \
0730                 decode_create_maxsz + \
0731                 decode_getfh_maxsz + \
0732                 decode_getattr_maxsz)
0733 #define NFS4_enc_pathconf_sz    (compound_encode_hdr_maxsz + \
0734                 encode_sequence_maxsz + \
0735                 encode_putfh_maxsz + \
0736                 encode_getattr_maxsz)
0737 #define NFS4_dec_pathconf_sz    (compound_decode_hdr_maxsz + \
0738                 decode_sequence_maxsz + \
0739                 decode_putfh_maxsz + \
0740                 decode_getattr_maxsz)
0741 #define NFS4_enc_statfs_sz  (compound_encode_hdr_maxsz + \
0742                 encode_sequence_maxsz + \
0743                 encode_putfh_maxsz + \
0744                 encode_statfs_maxsz)
0745 #define NFS4_dec_statfs_sz  (compound_decode_hdr_maxsz + \
0746                 decode_sequence_maxsz + \
0747                 decode_putfh_maxsz + \
0748                 decode_statfs_maxsz)
0749 #define NFS4_enc_server_caps_sz (compound_encode_hdr_maxsz + \
0750                 encode_sequence_maxsz + \
0751                 encode_putfh_maxsz + \
0752                 encode_getattr_maxsz)
0753 #define NFS4_dec_server_caps_sz (compound_decode_hdr_maxsz + \
0754                 decode_sequence_maxsz + \
0755                 decode_putfh_maxsz + \
0756                 decode_getattr_maxsz)
0757 #define NFS4_enc_delegreturn_sz (compound_encode_hdr_maxsz + \
0758                 encode_sequence_maxsz + \
0759                 encode_putfh_maxsz + \
0760                 encode_layoutreturn_maxsz + \
0761                 encode_delegreturn_maxsz + \
0762                 encode_getattr_maxsz)
0763 #define NFS4_dec_delegreturn_sz (compound_decode_hdr_maxsz + \
0764                 decode_sequence_maxsz + \
0765                 decode_putfh_maxsz + \
0766                 decode_layoutreturn_maxsz + \
0767                 decode_delegreturn_maxsz + \
0768                 decode_getattr_maxsz)
0769 #define NFS4_enc_getacl_sz  (compound_encode_hdr_maxsz + \
0770                 encode_sequence_maxsz + \
0771                 encode_putfh_maxsz + \
0772                 encode_getacl_maxsz)
0773 #define NFS4_dec_getacl_sz  (compound_decode_hdr_maxsz + \
0774                 decode_sequence_maxsz + \
0775                 decode_putfh_maxsz + \
0776                 decode_getacl_maxsz)
0777 #define NFS4_enc_setacl_sz  (compound_encode_hdr_maxsz + \
0778                 encode_sequence_maxsz + \
0779                 encode_putfh_maxsz + \
0780                 encode_setacl_maxsz)
0781 #define NFS4_dec_setacl_sz  (compound_decode_hdr_maxsz + \
0782                 decode_sequence_maxsz + \
0783                 decode_putfh_maxsz + \
0784                 decode_setacl_maxsz)
0785 #define NFS4_enc_fs_locations_sz \
0786                 (compound_encode_hdr_maxsz + \
0787                  encode_sequence_maxsz + \
0788                  encode_putfh_maxsz + \
0789                  encode_lookup_maxsz + \
0790                  encode_fs_locations_maxsz + \
0791                  encode_renew_maxsz)
0792 #define NFS4_dec_fs_locations_sz \
0793                 (compound_decode_hdr_maxsz + \
0794                  decode_sequence_maxsz + \
0795                  decode_putfh_maxsz + \
0796                  decode_lookup_maxsz + \
0797                  decode_fs_locations_maxsz + \
0798                  decode_renew_maxsz)
0799 #define NFS4_enc_secinfo_sz     (compound_encode_hdr_maxsz + \
0800                 encode_sequence_maxsz + \
0801                 encode_putfh_maxsz + \
0802                 encode_secinfo_maxsz)
0803 #define NFS4_dec_secinfo_sz (compound_decode_hdr_maxsz + \
0804                 decode_sequence_maxsz + \
0805                 decode_putfh_maxsz + \
0806                 decode_secinfo_maxsz)
0807 #define NFS4_enc_fsid_present_sz \
0808                 (compound_encode_hdr_maxsz + \
0809                  encode_sequence_maxsz + \
0810                  encode_putfh_maxsz + \
0811                  encode_getfh_maxsz + \
0812                  encode_renew_maxsz)
0813 #define NFS4_dec_fsid_present_sz \
0814                 (compound_decode_hdr_maxsz + \
0815                  decode_sequence_maxsz + \
0816                  decode_putfh_maxsz + \
0817                  decode_getfh_maxsz + \
0818                  decode_renew_maxsz)
0819 #if defined(CONFIG_NFS_V4_1)
0820 #define NFS4_enc_bind_conn_to_session_sz \
0821                 (compound_encode_hdr_maxsz + \
0822                  encode_bind_conn_to_session_maxsz)
0823 #define NFS4_dec_bind_conn_to_session_sz \
0824                 (compound_decode_hdr_maxsz + \
0825                  decode_bind_conn_to_session_maxsz)
0826 #define NFS4_enc_exchange_id_sz \
0827                 (compound_encode_hdr_maxsz + \
0828                  encode_exchange_id_maxsz)
0829 #define NFS4_dec_exchange_id_sz \
0830                 (compound_decode_hdr_maxsz + \
0831                  decode_exchange_id_maxsz)
0832 #define NFS4_enc_create_session_sz \
0833                 (compound_encode_hdr_maxsz + \
0834                  encode_create_session_maxsz)
0835 #define NFS4_dec_create_session_sz \
0836                 (compound_decode_hdr_maxsz + \
0837                  decode_create_session_maxsz)
0838 #define NFS4_enc_destroy_session_sz (compound_encode_hdr_maxsz + \
0839                      encode_destroy_session_maxsz)
0840 #define NFS4_dec_destroy_session_sz (compound_decode_hdr_maxsz + \
0841                      decode_destroy_session_maxsz)
0842 #define NFS4_enc_destroy_clientid_sz    (compound_encode_hdr_maxsz + \
0843                      encode_destroy_clientid_maxsz)
0844 #define NFS4_dec_destroy_clientid_sz    (compound_decode_hdr_maxsz + \
0845                      decode_destroy_clientid_maxsz)
0846 #define NFS4_enc_sequence_sz \
0847                 (compound_decode_hdr_maxsz + \
0848                  encode_sequence_maxsz)
0849 #define NFS4_dec_sequence_sz \
0850                 (compound_decode_hdr_maxsz + \
0851                  decode_sequence_maxsz)
0852 #endif
0853 #define NFS4_enc_get_lease_time_sz  (compound_encode_hdr_maxsz + \
0854                      encode_sequence_maxsz + \
0855                      encode_putrootfh_maxsz + \
0856                      encode_fsinfo_maxsz)
0857 #define NFS4_dec_get_lease_time_sz  (compound_decode_hdr_maxsz + \
0858                      decode_sequence_maxsz + \
0859                      decode_putrootfh_maxsz + \
0860                      decode_fsinfo_maxsz)
0861 #if defined(CONFIG_NFS_V4_1)
0862 #define NFS4_enc_reclaim_complete_sz    (compound_encode_hdr_maxsz + \
0863                      encode_sequence_maxsz + \
0864                      encode_reclaim_complete_maxsz)
0865 #define NFS4_dec_reclaim_complete_sz    (compound_decode_hdr_maxsz + \
0866                      decode_sequence_maxsz + \
0867                      decode_reclaim_complete_maxsz)
0868 #define NFS4_enc_getdeviceinfo_sz (compound_encode_hdr_maxsz +    \
0869                 encode_sequence_maxsz +\
0870                 encode_getdeviceinfo_maxsz)
0871 #define NFS4_dec_getdeviceinfo_sz (compound_decode_hdr_maxsz +    \
0872                 decode_sequence_maxsz + \
0873                 decode_getdeviceinfo_maxsz)
0874 #define NFS4_enc_layoutget_sz   (compound_encode_hdr_maxsz + \
0875                 encode_sequence_maxsz + \
0876                 encode_putfh_maxsz +        \
0877                 encode_layoutget_maxsz)
0878 #define NFS4_dec_layoutget_sz   (compound_decode_hdr_maxsz + \
0879                 decode_sequence_maxsz + \
0880                 decode_putfh_maxsz +        \
0881                 decode_layoutget_maxsz)
0882 #define NFS4_enc_layoutcommit_sz (compound_encode_hdr_maxsz + \
0883                 encode_sequence_maxsz +\
0884                 encode_putfh_maxsz + \
0885                 encode_layoutcommit_maxsz + \
0886                 encode_getattr_maxsz)
0887 #define NFS4_dec_layoutcommit_sz (compound_decode_hdr_maxsz + \
0888                 decode_sequence_maxsz + \
0889                 decode_putfh_maxsz + \
0890                 decode_layoutcommit_maxsz + \
0891                 decode_getattr_maxsz)
0892 #define NFS4_enc_layoutreturn_sz (compound_encode_hdr_maxsz + \
0893                 encode_sequence_maxsz + \
0894                 encode_putfh_maxsz + \
0895                 encode_layoutreturn_maxsz)
0896 #define NFS4_dec_layoutreturn_sz (compound_decode_hdr_maxsz + \
0897                 decode_sequence_maxsz + \
0898                 decode_putfh_maxsz + \
0899                 decode_layoutreturn_maxsz)
0900 #define NFS4_enc_secinfo_no_name_sz (compound_encode_hdr_maxsz + \
0901                     encode_sequence_maxsz + \
0902                     encode_putrootfh_maxsz +\
0903                     encode_secinfo_no_name_maxsz)
0904 #define NFS4_dec_secinfo_no_name_sz (compound_decode_hdr_maxsz + \
0905                     decode_sequence_maxsz + \
0906                     decode_putrootfh_maxsz + \
0907                     decode_secinfo_no_name_maxsz)
0908 #define NFS4_enc_test_stateid_sz    (compound_encode_hdr_maxsz + \
0909                      encode_sequence_maxsz + \
0910                      encode_test_stateid_maxsz)
0911 #define NFS4_dec_test_stateid_sz    (compound_decode_hdr_maxsz + \
0912                      decode_sequence_maxsz + \
0913                      decode_test_stateid_maxsz)
0914 #define NFS4_enc_free_stateid_sz    (compound_encode_hdr_maxsz + \
0915                      encode_sequence_maxsz + \
0916                      encode_free_stateid_maxsz)
0917 #define NFS4_dec_free_stateid_sz    (compound_decode_hdr_maxsz + \
0918                      decode_sequence_maxsz + \
0919                      decode_free_stateid_maxsz)
0920
0921 const u32 nfs41_maxwrite_overhead = ((RPC_MAX_HEADER_WITH_AUTH +
0922                       compound_encode_hdr_maxsz +
0923                       encode_sequence_maxsz +
0924                       encode_putfh_maxsz +
0925                       encode_getattr_maxsz) *
0926                      XDR_UNIT);
0927
0928 const u32 nfs41_maxread_overhead = ((RPC_MAX_HEADER_WITH_AUTH +
0929                      compound_decode_hdr_maxsz +
0930                      decode_sequence_maxsz +
0931                      decode_putfh_maxsz) *
0932                     XDR_UNIT);
0933
0934 const u32 nfs41_maxgetdevinfo_overhead = ((RPC_MAX_REPHEADER_WITH_AUTH +
0935                        compound_decode_hdr_maxsz +
0936                        decode_sequence_maxsz) *
0937                       XDR_UNIT);
0938 EXPORT_SYMBOL_GPL(nfs41_maxgetdevinfo_overhead);
0939 #endif /* CONFIG_NFS_V4_1 */
0940
0941 static const umode_t nfs_type2fmt[] = {
0942     [NF4BAD] = 0,
0943     [NF4REG] = S_IFREG,
0944     [NF4DIR] = S_IFDIR,
0945     [NF4BLK] = S_IFBLK,
0946     [NF4CHR] = S_IFCHR,
0947     [NF4LNK] = S_IFLNK,
0948     [NF4SOCK] = S_IFSOCK,
0949     [NF4FIFO] = S_IFIFO,
0950     [NF4ATTRDIR] = 0,
0951     [NF4NAMEDATTR] = 0,
0952 };
0953
0954 struct compound_hdr {
0955     int32_t     status;
0956     uint32_t    nops;
0957     __be32 *    nops_p;
0958     uint32_t    taglen;
0959     char *      tag;
0960     uint32_t    replen;     /* expected reply words */
0961     u32     minorversion;
0962 };
0963
0964 static __be32 *reserve_space(struct xdr_stream *xdr, size_t nbytes)
0965 {
0966     __be32 *p = xdr_reserve_space(xdr, nbytes);
0967     BUG_ON(!p);
0968     return p;
0969 }
0970
0971 static void encode_opaque_fixed(struct xdr_stream *xdr, const void *buf, size_t len)
0972 {
0973     WARN_ON_ONCE(xdr_stream_encode_opaque_fixed(xdr, buf, len) < 0);
0974 }
0975
0976 static void encode_string(struct xdr_stream *xdr, unsigned int len, const char *str)
0977 {
0978     WARN_ON_ONCE(xdr_stream_encode_opaque(xdr, str, len) < 0);
0979 }
0980
0981 static void encode_uint32(struct xdr_stream *xdr, u32 n)
0982 {
0983     WARN_ON_ONCE(xdr_stream_encode_u32(xdr, n) < 0);
0984 }
0985
0986 static void encode_uint64(struct xdr_stream *xdr, u64 n)
0987 {
0988     WARN_ON_ONCE(xdr_stream_encode_u64(xdr, n) < 0);
0989 }
0990
0991 static ssize_t xdr_encode_bitmap4(struct xdr_stream *xdr,
0992         const __u32 *bitmap, size_t len)
0993 {
0994     ssize_t ret;
0995
0996     /* Trim empty words */
0997     while (len > 0 && bitmap[len-1] == 0)
0998         len--;
0999     ret = xdr_stream_encode_uint32_array(xdr, bitmap, len);
1000     if (WARN_ON_ONCE(ret < 0))
1001         return ret;
1002     return len;
1003 }
1004
1005 static size_t mask_bitmap4(const __u32 *bitmap, const __u32 *mask,
1006         __u32 *res, size_t len)
1007 {
1008     size_t i;
1009     __u32 tmp;
1010
1011     while (len > 0 && (bitmap[len-1] == 0 || mask[len-1] == 0))
1012         len--;
1013     for (i = len; i-- > 0;) {
1014         tmp = bitmap[i] & mask[i];
1015         res[i] = tmp;
1016     }
1017     return len;
1018 }
1019
1020 static void encode_nfs4_seqid(struct xdr_stream *xdr,
1021         const struct nfs_seqid *seqid)
1022 {
1023     if (seqid != NULL)
1024         encode_uint32(xdr, seqid->sequence->counter);
1025     else
1026         encode_uint32(xdr, 0);
1027 }
1028
1029 static void encode_compound_hdr(struct xdr_stream *xdr,
1030                 struct rpc_rqst *req,
1031                 struct compound_hdr *hdr)
1032 {
1033     __be32 *p;
1034
1035     /* initialize running count of expected bytes in reply.
1036      * NOTE: the replied tag SHOULD be the same is the one sent,
1037      * but this is not required as a MUST for the server to do so. */
1038     hdr->replen = 3 + hdr->taglen;
1039
1040     WARN_ON_ONCE(hdr->taglen > NFS4_MAXTAGLEN);
1041     encode_string(xdr, hdr->taglen, hdr->tag);
1042     p = reserve_space(xdr, 8);
1043     *p++ = cpu_to_be32(hdr->minorversion);
1044     hdr->nops_p = p;
1045     *p = cpu_to_be32(hdr->nops);
1046 }
1047
1048 static void encode_op_hdr(struct xdr_stream *xdr, enum nfs_opnum4 op,
1049         uint32_t replen,
1050         struct compound_hdr *hdr)
1051 {
1052     encode_uint32(xdr, op);
1053     hdr->nops++;
1054     hdr->replen += replen;
1055 }
1056
1057 static void encode_nops(struct compound_hdr *hdr)
1058 {
1059     WARN_ON_ONCE(hdr->nops > NFS4_MAX_OPS);
1060     *hdr->nops_p = htonl(hdr->nops);
1061 }
1062
1063 static void encode_nfs4_stateid(struct xdr_stream *xdr, const nfs4_stateid *stateid)
1064 {
1065     encode_opaque_fixed(xdr, stateid, NFS4_STATEID_SIZE);
1066 }
1067
1068 static void encode_nfs4_verifier(struct xdr_stream *xdr, const nfs4_verifier *verf)
1069 {
1070     encode_opaque_fixed(xdr, verf->data, NFS4_VERIFIER_SIZE);
1071 }
1072
1073 static __be32 *
1074 xdr_encode_nfstime4(__be32 *p, const struct timespec64 *t)
1075 {
1076     p = xdr_encode_hyper(p, t->tv_sec);
1077     *p++ = cpu_to_be32(t->tv_nsec);
1078     return p;
1079 }
1080
1081 static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap,
1082                 const struct nfs4_label *label,
1083                 const umode_t *umask,
1084                 const struct nfs_server *server,
1085                 const uint32_t attrmask[])
1086 {
1087     char owner_name[IDMAP_NAMESZ];
1088     char owner_group[IDMAP_NAMESZ];
1089     int owner_namelen = 0;
1090     int owner_grouplen = 0;
1091     __be32 *p;
1092     uint32_t len = 0;
1093     uint32_t bmval[3] = { 0 };
1094
1095     /*
1096      * We reserve enough space to write the entire attribute buffer at once.
1097      */
1098     if ((iap->ia_valid & ATTR_SIZE) && (attrmask[0] & FATTR4_WORD0_SIZE)) {
1099         bmval[0] |= FATTR4_WORD0_SIZE;
1100         len += 8;
1101     }
1102     if (iap->ia_valid & ATTR_MODE) {
1103         if (umask && (attrmask[2] & FATTR4_WORD2_MODE_UMASK)) {
1104             bmval[2] |= FATTR4_WORD2_MODE_UMASK;
1105             len += 8;
1106         } else if (attrmask[1] & FATTR4_WORD1_MODE) {
1107             bmval[1] |= FATTR4_WORD1_MODE;
1108             len += 4;
1109         }
1110     }
1111     if ((iap->ia_valid & ATTR_UID) && (attrmask[1] & FATTR4_WORD1_OWNER)) {
1112         owner_namelen = nfs_map_uid_to_name(server, iap->ia_uid, owner_name, IDMAP_NAMESZ);
1113         if (owner_namelen < 0) {
1114             dprintk("nfs: couldn't resolve uid %d to string\n",
1115                     from_kuid(&init_user_ns, iap->ia_uid));
1116             /* XXX */
1117             strcpy(owner_name, "nobody");
1118             owner_namelen = sizeof("nobody") - 1;
1119             /* goto out; */
1120         }
1121         bmval[1] |= FATTR4_WORD1_OWNER;
1122         len += 4 + (XDR_QUADLEN(owner_namelen) << 2);
1123     }
1124     if ((iap->ia_valid & ATTR_GID) &&
1125        (attrmask[1] & FATTR4_WORD1_OWNER_GROUP)) {
1126         owner_grouplen = nfs_map_gid_to_group(server, iap->ia_gid, owner_group, IDMAP_NAMESZ);
1127         if (owner_grouplen < 0) {
1128             dprintk("nfs: couldn't resolve gid %d to string\n",
1129                     from_kgid(&init_user_ns, iap->ia_gid));
1130             strcpy(owner_group, "nobody");
1131             owner_grouplen = sizeof("nobody") - 1;
1132             /* goto out; */
1133         }
1134         bmval[1] |= FATTR4_WORD1_OWNER_GROUP;
1135         len += 4 + (XDR_QUADLEN(owner_grouplen) << 2);
1136     }
1137     if (attrmask[1] & FATTR4_WORD1_TIME_ACCESS_SET) {
1138         if (iap->ia_valid & ATTR_ATIME_SET) {
1139             bmval[1] |= FATTR4_WORD1_TIME_ACCESS_SET;
1140             len += 4 + (nfstime4_maxsz << 2);
1141         } else if (iap->ia_valid & ATTR_ATIME) {
1142             bmval[1] |= FATTR4_WORD1_TIME_ACCESS_SET;
1143             len += 4;
1144         }
1145     }
1146     if (attrmask[1] & FATTR4_WORD1_TIME_MODIFY_SET) {
1147         if (iap->ia_valid & ATTR_MTIME_SET) {
1148             bmval[1] |= FATTR4_WORD1_TIME_MODIFY_SET;
1149             len += 4 + (nfstime4_maxsz << 2);
1150         } else if (iap->ia_valid & ATTR_MTIME) {
1151             bmval[1] |= FATTR4_WORD1_TIME_MODIFY_SET;
1152             len += 4;
1153         }
1154     }
1155
1156     if (label && (attrmask[2] & FATTR4_WORD2_SECURITY_LABEL)) {
1157         len += 4 + 4 + 4 + (XDR_QUADLEN(label->len) << 2);
1158         bmval[2] |= FATTR4_WORD2_SECURITY_LABEL;
1159     }
1160
1161     xdr_encode_bitmap4(xdr, bmval, ARRAY_SIZE(bmval));
1162     xdr_stream_encode_opaque_inline(xdr, (void **)&p, len);
1163
1164     if (bmval[0] & FATTR4_WORD0_SIZE)
1165         p = xdr_encode_hyper(p, iap->ia_size);
1166     if (bmval[1] & FATTR4_WORD1_MODE)
1167         *p++ = cpu_to_be32(iap->ia_mode & S_IALLUGO);
1168     if (bmval[1] & FATTR4_WORD1_OWNER)
1169         p = xdr_encode_opaque(p, owner_name, owner_namelen);
1170     if (bmval[1] & FATTR4_WORD1_OWNER_GROUP)
1171         p = xdr_encode_opaque(p, owner_group, owner_grouplen);
1172     if (bmval[1] & FATTR4_WORD1_TIME_ACCESS_SET) {
1173         if (iap->ia_valid & ATTR_ATIME_SET) {
1174             *p++ = cpu_to_be32(NFS4_SET_TO_CLIENT_TIME);
1175             p = xdr_encode_nfstime4(p, &iap->ia_atime);
1176         } else
1177             *p++ = cpu_to_be32(NFS4_SET_TO_SERVER_TIME);
1178     }
1179     if (bmval[1] & FATTR4_WORD1_TIME_MODIFY_SET) {
1180         if (iap->ia_valid & ATTR_MTIME_SET) {
1181             *p++ = cpu_to_be32(NFS4_SET_TO_CLIENT_TIME);
1182             p = xdr_encode_nfstime4(p, &iap->ia_mtime);
1183         } else
1184             *p++ = cpu_to_be32(NFS4_SET_TO_SERVER_TIME);
1185     }
1186     if (label && (bmval[2] & FATTR4_WORD2_SECURITY_LABEL)) {
1187         *p++ = cpu_to_be32(label->lfs);
1188         *p++ = cpu_to_be32(label->pi);
1189         *p++ = cpu_to_be32(label->len);
1190         p = xdr_encode_opaque_fixed(p, label->label, label->len);
1191     }
1192     if (bmval[2] & FATTR4_WORD2_MODE_UMASK) {
1193         *p++ = cpu_to_be32(iap->ia_mode & S_IALLUGO);
1194         *p++ = cpu_to_be32(*umask);
1195     }
1196
1197 /* out: */
1198 }
1199
1200 static void encode_access(struct xdr_stream *xdr, u32 access, struct compound_hdr *hdr)
1201 {
1202     encode_op_hdr(xdr, OP_ACCESS, decode_access_maxsz, hdr);
1203     encode_uint32(xdr, access);
1204 }
1205
1206 static void encode_close(struct xdr_stream *xdr, const struct nfs_closeargs *arg, struct compound_hdr *hdr)
1207 {
1208     encode_op_hdr(xdr, OP_CLOSE, decode_close_maxsz, hdr);
1209     encode_nfs4_seqid(xdr, arg->seqid);
1210     encode_nfs4_stateid(xdr, &arg->stateid);
1211 }
1212
1213 static void encode_commit(struct xdr_stream *xdr, const struct nfs_commitargs *args, struct compound_hdr *hdr)
1214 {
1215     __be32 *p;
1216
1217     encode_op_hdr(xdr, OP_COMMIT, decode_commit_maxsz, hdr);
1218     p = reserve_space(xdr, 12);
1219     p = xdr_encode_hyper(p, args->offset);
1220     *p = cpu_to_be32(args->count);
1221 }
1222
1223 static void encode_create(struct xdr_stream *xdr, const struct nfs4_create_arg *create, struct compound_hdr *hdr)
1224 {
1225     __be32 *p;
1226
1227     encode_op_hdr(xdr, OP_CREATE, decode_create_maxsz, hdr);
1228     encode_uint32(xdr, create->ftype);
1229
1230     switch (create->ftype) {
1231     case NF4LNK:
1232         p = reserve_space(xdr, 4);
1233         *p = cpu_to_be32(create->u.symlink.len);
1234         xdr_write_pages(xdr, create->u.symlink.pages, 0,
1235                 create->u.symlink.len);
1236         xdr->buf->flags |= XDRBUF_WRITE;
1237         break;
1238
1239     case NF4BLK: case NF4CHR:
1240         p = reserve_space(xdr, 8);
1241         *p++ = cpu_to_be32(create->u.device.specdata1);
1242         *p = cpu_to_be32(create->u.device.specdata2);
1243         break;
1244
1245     default:
1246         break;
1247     }
1248
1249     encode_string(xdr, create->name->len, create->name->name);
1250     encode_attrs(xdr, create->attrs, create->label, &create->umask,
1251             create->server, create->server->attr_bitmask);
1252 }
1253
1254 static void encode_getattr(struct xdr_stream *xdr,
1255         const __u32 *bitmap, const __u32 *mask, size_t len,
1256         struct compound_hdr *hdr)
1257 {
1258     __u32 masked_bitmap[nfs4_fattr_bitmap_maxsz];
1259
1260     encode_op_hdr(xdr, OP_GETATTR, decode_getattr_maxsz, hdr);
1261     if (mask) {
1262         if (WARN_ON_ONCE(len > ARRAY_SIZE(masked_bitmap)))
1263             len = ARRAY_SIZE(masked_bitmap);
1264         len = mask_bitmap4(bitmap, mask, masked_bitmap, len);
1265         bitmap = masked_bitmap;
1266     }
1267     xdr_encode_bitmap4(xdr, bitmap, len);
1268 }
1269
1270 static void encode_getfattr(struct xdr_stream *xdr, const u32* bitmask, struct compound_hdr *hdr)
1271 {
1272     encode_getattr(xdr, nfs4_fattr_bitmap, bitmask,
1273             ARRAY_SIZE(nfs4_fattr_bitmap), hdr);
1274 }
1275
1276 static void encode_getfattr_open(struct xdr_stream *xdr, const u32 *bitmask,
1277                  const u32 *open_bitmap,
1278                  struct compound_hdr *hdr)
1279 {
1280     encode_getattr(xdr, open_bitmap, bitmask, 3, hdr);
1281 }
1282
1283 static void encode_fsinfo(struct xdr_stream *xdr, const u32* bitmask, struct compound_hdr *hdr)
1284 {
1285     encode_getattr(xdr, nfs4_fsinfo_bitmap, bitmask,
1286             ARRAY_SIZE(nfs4_fsinfo_bitmap), hdr);
1287 }
1288
1289 static void encode_fs_locations(struct xdr_stream *xdr, const u32* bitmask, struct compound_hdr *hdr)
1290 {
1291     encode_getattr(xdr, nfs4_fs_locations_bitmap, bitmask,
1292             ARRAY_SIZE(nfs4_fs_locations_bitmap), hdr);
1293 }
1294
1295 static void encode_getfh(struct xdr_stream *xdr, struct compound_hdr *hdr)
1296 {
1297     encode_op_hdr(xdr, OP_GETFH, decode_getfh_maxsz, hdr);
1298 }
1299
1300 static void encode_link(struct xdr_stream *xdr, const struct qstr *name, struct compound_hdr *hdr)
1301 {
1302     encode_op_hdr(xdr, OP_LINK, decode_link_maxsz, hdr);
1303     encode_string(xdr, name->len, name->name);
1304 }
1305
1306 static inline int nfs4_lock_type(struct file_lock *fl, int block)
1307 {
1308     if (fl->fl_type == F_RDLCK)
1309         return block ? NFS4_READW_LT : NFS4_READ_LT;
1310     return block ? NFS4_WRITEW_LT : NFS4_WRITE_LT;
1311 }
1312
1313 static inline uint64_t nfs4_lock_length(struct file_lock *fl)
1314 {
1315     if (fl->fl_end == OFFSET_MAX)
1316         return ~(uint64_t)0;
1317     return fl->fl_end - fl->fl_start + 1;
1318 }
1319
1320 static void encode_lockowner(struct xdr_stream *xdr, const struct nfs_lowner *lowner)
1321 {
1322     __be32 *p;
1323
1324     p = reserve_space(xdr, 32);
1325     p = xdr_encode_hyper(p, lowner->clientid);
1326     *p++ = cpu_to_be32(20);
1327     p = xdr_encode_opaque_fixed(p, "lock id:", 8);
1328     *p++ = cpu_to_be32(lowner->s_dev);
1329     xdr_encode_hyper(p, lowner->id);
1330 }
1331
1332 /*
1333  * opcode,type,reclaim,offset,length,new_lock_owner = 32
1334  * open_seqid,open_stateid,lock_seqid,lock_owner.clientid, lock_owner.id = 40
1335  */
1336 static void encode_lock(struct xdr_stream *xdr, const struct nfs_lock_args *args, struct compound_hdr *hdr)
1337 {
1338     __be32 *p;
1339
1340     encode_op_hdr(xdr, OP_LOCK, decode_lock_maxsz, hdr);
1341     p = reserve_space(xdr, 28);
1342     *p++ = cpu_to_be32(nfs4_lock_type(args->fl, args->block));
1343     *p++ = cpu_to_be32(args->reclaim);
1344     p = xdr_encode_hyper(p, args->fl->fl_start);
1345     p = xdr_encode_hyper(p, nfs4_lock_length(args->fl));
1346     *p = cpu_to_be32(args->new_lock_owner);
1347     if (args->new_lock_owner){
1348         encode_nfs4_seqid(xdr, args->open_seqid);
1349         encode_nfs4_stateid(xdr, &args->open_stateid);
1350         encode_nfs4_seqid(xdr, args->lock_seqid);
1351         encode_lockowner(xdr, &args->lock_owner);
1352     }
1353     else {
1354         encode_nfs4_stateid(xdr, &args->lock_stateid);
1355         encode_nfs4_seqid(xdr, args->lock_seqid);
1356     }
1357 }
1358
1359 static void encode_lockt(struct xdr_stream *xdr, const struct nfs_lockt_args *args, struct compound_hdr *hdr)
1360 {
1361     __be32 *p;
1362
1363     encode_op_hdr(xdr, OP_LOCKT, decode_lockt_maxsz, hdr);
1364     p = reserve_space(xdr, 20);
1365     *p++ = cpu_to_be32(nfs4_lock_type(args->fl, 0));
1366     p = xdr_encode_hyper(p, args->fl->fl_start);
1367     p = xdr_encode_hyper(p, nfs4_lock_length(args->fl));
1368     encode_lockowner(xdr, &args->lock_owner);
1369 }
1370
1371 static void encode_locku(struct xdr_stream *xdr, const struct nfs_locku_args *args, struct compound_hdr *hdr)
1372 {
1373     __be32 *p;
1374
1375     encode_op_hdr(xdr, OP_LOCKU, decode_locku_maxsz, hdr);
1376     encode_uint32(xdr, nfs4_lock_type(args->fl, 0));
1377     encode_nfs4_seqid(xdr, args->seqid);
1378     encode_nfs4_stateid(xdr, &args->stateid);
1379     p = reserve_space(xdr, 16);
1380     p = xdr_encode_hyper(p, args->fl->fl_start);
1381     xdr_encode_hyper(p, nfs4_lock_length(args->fl));
1382 }
1383
1384 static void encode_release_lockowner(struct xdr_stream *xdr, const struct nfs_lowner *lowner, struct compound_hdr *hdr)
1385 {
1386     encode_op_hdr(xdr, OP_RELEASE_LOCKOWNER, decode_release_lockowner_maxsz, hdr);
1387     encode_lockowner(xdr, lowner);
1388 }
1389
1390 static void encode_lookup(struct xdr_stream *xdr, const struct qstr *name, struct compound_hdr *hdr)
1391 {
1392     encode_op_hdr(xdr, OP_LOOKUP, decode_lookup_maxsz, hdr);
1393     encode_string(xdr, name->len, name->name);
1394 }
1395
1396 static void encode_lookupp(struct xdr_stream *xdr, struct compound_hdr *hdr)
1397 {
1398     encode_op_hdr(xdr, OP_LOOKUPP, decode_lookupp_maxsz, hdr);
1399 }
1400
1401 static void encode_share_access(struct xdr_stream *xdr, u32 share_access)
1402 {
1403     __be32 *p;
1404
1405     p = reserve_space(xdr, 8);
1406     *p++ = cpu_to_be32(share_access);
1407     *p = cpu_to_be32(0);        /* for linux, share_deny = 0 always */
1408 }
1409
1410 static inline void encode_openhdr(struct xdr_stream *xdr, const struct nfs_openargs *arg)
1411 {
1412     __be32 *p;
1413  /*
1414  * opcode 4, seqid 4, share_access 4, share_deny 4, clientid 8, ownerlen 4,
1415  * owner 4 = 32
1416  */
1417     encode_nfs4_seqid(xdr, arg->seqid);
1418     encode_share_access(xdr, arg->share_access);
1419     p = reserve_space(xdr, 36);
1420     p = xdr_encode_hyper(p, arg->clientid);
1421     *p++ = cpu_to_be32(24);
1422     p = xdr_encode_opaque_fixed(p, "open id:", 8);
1423     *p++ = cpu_to_be32(arg->server->s_dev);
1424     *p++ = cpu_to_be32(arg->id.uniquifier);
1425     xdr_encode_hyper(p, arg->id.create_time);
1426 }
1427
1428 static inline void encode_createmode(struct xdr_stream *xdr, const struct nfs_openargs *arg)
1429 {
1430     __be32 *p;
1431
1432     p = reserve_space(xdr, 4);
1433     switch(arg->createmode) {
1434     case NFS4_CREATE_UNCHECKED:
1435         *p = cpu_to_be32(NFS4_CREATE_UNCHECKED);
1436         encode_attrs(xdr, arg->u.attrs, arg->label, &arg->umask,
1437                 arg->server, arg->server->attr_bitmask);
1438         break;
1439     case NFS4_CREATE_GUARDED:
1440         *p = cpu_to_be32(NFS4_CREATE_GUARDED);
1441         encode_attrs(xdr, arg->u.attrs, arg->label, &arg->umask,
1442                 arg->server, arg->server->attr_bitmask);
1443         break;
1444     case NFS4_CREATE_EXCLUSIVE:
1445         *p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE);
1446         encode_nfs4_verifier(xdr, &arg->u.verifier);
1447         break;
1448     case NFS4_CREATE_EXCLUSIVE4_1:
1449         *p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE4_1);
1450         encode_nfs4_verifier(xdr, &arg->u.verifier);
1451         encode_attrs(xdr, arg->u.attrs, arg->label, &arg->umask,
1452                 arg->server, arg->server->exclcreat_bitmask);
1453     }
1454 }
1455
1456 static void encode_opentype(struct xdr_stream *xdr, const struct nfs_openargs *arg)
1457 {
1458     __be32 *p;
1459
1460     p = reserve_space(xdr, 4);
1461     switch (arg->open_flags & O_CREAT) {
1462     case 0:
1463         *p = cpu_to_be32(NFS4_OPEN_NOCREATE);
1464         break;
1465     default:
1466         *p = cpu_to_be32(NFS4_OPEN_CREATE);
1467         encode_createmode(xdr, arg);
1468     }
1469 }
1470
1471 static inline void encode_delegation_type(struct xdr_stream *xdr, fmode_t delegation_type)
1472 {
1473     __be32 *p;
1474
1475     p = reserve_space(xdr, 4);
1476     switch (delegation_type) {
1477     case 0:
1478         *p = cpu_to_be32(NFS4_OPEN_DELEGATE_NONE);
1479         break;
1480     case FMODE_READ:
1481         *p = cpu_to_be32(NFS4_OPEN_DELEGATE_READ);
1482         break;
1483     case FMODE_WRITE|FMODE_READ:
1484         *p = cpu_to_be32(NFS4_OPEN_DELEGATE_WRITE);
1485         break;
1486     default:
1487         BUG();
1488     }
1489 }
1490
1491 static inline void encode_claim_null(struct xdr_stream *xdr, const struct qstr *name)
1492 {
1493     __be32 *p;
1494
1495     p = reserve_space(xdr, 4);
1496     *p = cpu_to_be32(NFS4_OPEN_CLAIM_NULL);
1497     encode_string(xdr, name->len, name->name);
1498 }
1499
1500 static inline void encode_claim_previous(struct xdr_stream *xdr, fmode_t type)
1501 {
1502     __be32 *p;
1503
1504     p = reserve_space(xdr, 4);
1505     *p = cpu_to_be32(NFS4_OPEN_CLAIM_PREVIOUS);
1506     encode_delegation_type(xdr, type);
1507 }
1508
1509 static inline void encode_claim_delegate_cur(struct xdr_stream *xdr, const struct qstr *name, const nfs4_stateid *stateid)
1510 {
1511     __be32 *p;
1512
1513     p = reserve_space(xdr, 4);
1514     *p = cpu_to_be32(NFS4_OPEN_CLAIM_DELEGATE_CUR);
1515     encode_nfs4_stateid(xdr, stateid);
1516     encode_string(xdr, name->len, name->name);
1517 }
1518
1519 static inline void encode_claim_fh(struct xdr_stream *xdr)
1520 {
1521     __be32 *p;
1522
1523     p = reserve_space(xdr, 4);
1524     *p = cpu_to_be32(NFS4_OPEN_CLAIM_FH);
1525 }
1526
1527 static inline void encode_claim_delegate_cur_fh(struct xdr_stream *xdr, const nfs4_stateid *stateid)
1528 {
1529     __be32 *p;
1530
1531     p = reserve_space(xdr, 4);
1532     *p = cpu_to_be32(NFS4_OPEN_CLAIM_DELEG_CUR_FH);
1533     encode_nfs4_stateid(xdr, stateid);
1534 }
1535
1536 static void encode_open(struct xdr_stream *xdr, const struct nfs_openargs *arg, struct compound_hdr *hdr)
1537 {
1538     encode_op_hdr(xdr, OP_OPEN, decode_open_maxsz, hdr);
1539     encode_openhdr(xdr, arg);
1540     encode_opentype(xdr, arg);
1541     switch (arg->claim) {
1542     case NFS4_OPEN_CLAIM_NULL:
1543         encode_claim_null(xdr, arg->name);
1544         break;
1545     case NFS4_OPEN_CLAIM_PREVIOUS:
1546         encode_claim_previous(xdr, arg->u.delegation_type);
1547         break;
1548     case NFS4_OPEN_CLAIM_DELEGATE_CUR:
1549         encode_claim_delegate_cur(xdr, arg->name, &arg->u.delegation);
1550         break;
1551     case NFS4_OPEN_CLAIM_FH:
1552         encode_claim_fh(xdr);
1553         break;
1554     case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
1555         encode_claim_delegate_cur_fh(xdr, &arg->u.delegation);
1556         break;
1557     default:
1558         BUG();
1559     }
1560 }
1561
1562 static void encode_open_confirm(struct xdr_stream *xdr, const struct nfs_open_confirmargs *arg, struct compound_hdr *hdr)
1563 {
1564     encode_op_hdr(xdr, OP_OPEN_CONFIRM, decode_open_confirm_maxsz, hdr);
1565     encode_nfs4_stateid(xdr, arg->stateid);
1566     encode_nfs4_seqid(xdr, arg->seqid);
1567 }
1568
1569 static void encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closeargs *arg, struct compound_hdr *hdr)
1570 {
1571     encode_op_hdr(xdr, OP_OPEN_DOWNGRADE, decode_open_downgrade_maxsz, hdr);
1572     encode_nfs4_stateid(xdr, &arg->stateid);
1573     encode_nfs4_seqid(xdr, arg->seqid);
1574     encode_share_access(xdr, arg->share_access);
1575 }
1576
1577 static void
1578 encode_putfh(struct xdr_stream *xdr, const struct nfs_fh *fh, struct compound_hdr *hdr)
1579 {
1580     encode_op_hdr(xdr, OP_PUTFH, decode_putfh_maxsz, hdr);
1581     encode_string(xdr, fh->size, fh->data);
1582 }
1583
1584 static void encode_putrootfh(struct xdr_stream *xdr, struct compound_hdr *hdr)
1585 {
1586     encode_op_hdr(xdr, OP_PUTROOTFH, decode_putrootfh_maxsz, hdr);
1587 }
1588
1589 static void encode_read(struct xdr_stream *xdr, const struct nfs_pgio_args *args,
1590             struct compound_hdr *hdr)
1591 {
1592     __be32 *p;
1593
1594     encode_op_hdr(xdr, OP_READ, decode_read_maxsz, hdr);
1595     encode_nfs4_stateid(xdr, &args->stateid);
1596
1597     p = reserve_space(xdr, 12);
1598     p = xdr_encode_hyper(p, args->offset);
1599     *p = cpu_to_be32(args->count);
1600 }
1601
1602 static void encode_readdir(struct xdr_stream *xdr, const struct nfs4_readdir_arg *readdir, struct rpc_rqst *req, struct compound_hdr *hdr)
1603 {
1604     uint32_t attrs[3] = {
1605         FATTR4_WORD0_RDATTR_ERROR,
1606         FATTR4_WORD1_MOUNTED_ON_FILEID,
1607     };
1608     uint32_t dircount = readdir->count;
1609     uint32_t maxcount = readdir->count;
1610     __be32 *p, verf[2];
1611     uint32_t attrlen = 0;
1612     unsigned int i;
1613
1614     if (readdir->plus) {
1615         attrs[0] |= FATTR4_WORD0_TYPE|FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE|
1616             FATTR4_WORD0_FSID|FATTR4_WORD0_FILEHANDLE|FATTR4_WORD0_FILEID;
1617         attrs[1] |= FATTR4_WORD1_MODE|FATTR4_WORD1_NUMLINKS|FATTR4_WORD1_OWNER|
1618             FATTR4_WORD1_OWNER_GROUP|FATTR4_WORD1_RAWDEV|
1619             FATTR4_WORD1_SPACE_USED|FATTR4_WORD1_TIME_ACCESS|
1620             FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY;
1621         attrs[2] |= FATTR4_WORD2_SECURITY_LABEL;
1622     }
1623     /* Use mounted_on_fileid only if the server supports it */
1624     if (!(readdir->bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID))
1625         attrs[0] |= FATTR4_WORD0_FILEID;
1626     for (i = 0; i < ARRAY_SIZE(attrs); i++) {
1627         attrs[i] &= readdir->bitmask[i];
1628         if (attrs[i] != 0)
1629             attrlen = i+1;
1630     }
1631
1632     encode_op_hdr(xdr, OP_READDIR, decode_readdir_maxsz, hdr);
1633     encode_uint64(xdr, readdir->cookie);
1634     encode_nfs4_verifier(xdr, &readdir->verifier);
1635     p = reserve_space(xdr, 12 + (attrlen << 2));
1636     *p++ = cpu_to_be32(dircount);
1637     *p++ = cpu_to_be32(maxcount);
1638     *p++ = cpu_to_be32(attrlen);
1639     for (i = 0; i < attrlen; i++)
1640         *p++ = cpu_to_be32(attrs[i]);
1641     memcpy(verf, readdir->verifier.data, sizeof(verf));
1642
1643     dprintk("%s: cookie = %llu, verifier = %08x:%08x, bitmap = %08x:%08x:%08x\n",
1644             __func__,
1645             (unsigned long long)readdir->cookie,
1646             verf[0], verf[1],
1647             attrs[0] & readdir->bitmask[0],
1648             attrs[1] & readdir->bitmask[1],
1649             attrs[2] & readdir->bitmask[2]);
1650 }
1651
1652 static void encode_readlink(struct xdr_stream *xdr, const struct nfs4_readlink *readlink, struct rpc_rqst *req, struct compound_hdr *hdr)
1653 {
1654     encode_op_hdr(xdr, OP_READLINK, decode_readlink_maxsz, hdr);
1655 }
1656
1657 static void encode_remove(struct xdr_stream *xdr, const struct qstr *name, struct compound_hdr *hdr)
1658 {
1659     encode_op_hdr(xdr, OP_REMOVE, decode_remove_maxsz, hdr);
1660     encode_string(xdr, name->len, name->name);
1661 }
1662
1663 static void encode_rename(struct xdr_stream *xdr, const struct qstr *oldname, const struct qstr *newname, struct compound_hdr *hdr)
1664 {
1665     encode_op_hdr(xdr, OP_RENAME, decode_rename_maxsz, hdr);
1666     encode_string(xdr, oldname->len, oldname->name);
1667     encode_string(xdr, newname->len, newname->name);
1668 }
1669
1670 static void encode_renew(struct xdr_stream *xdr, clientid4 clid,
1671              struct compound_hdr *hdr)
1672 {
1673     encode_op_hdr(xdr, OP_RENEW, decode_renew_maxsz, hdr);
1674     encode_uint64(xdr, clid);
1675 }
1676
1677 static void
1678 encode_restorefh(struct xdr_stream *xdr, struct compound_hdr *hdr)
1679 {
1680     encode_op_hdr(xdr, OP_RESTOREFH, decode_restorefh_maxsz, hdr);
1681 }
1682
1683 static void nfs4_acltype_to_bitmap(enum nfs4_acl_type type, __u32 bitmap[2])
1684 {
1685     switch (type) {
1686     default:
1687         bitmap[0] = FATTR4_WORD0_ACL;
1688         bitmap[1] = 0;
1689         break;
1690     case NFS4ACL_DACL:
1691         bitmap[0] = 0;
1692         bitmap[1] = FATTR4_WORD1_DACL;
1693         break;
1694     case NFS4ACL_SACL:
1695         bitmap[0] = 0;
1696         bitmap[1] = FATTR4_WORD1_SACL;
1697     }
1698 }
1699
1700 static void encode_setacl(struct xdr_stream *xdr,
1701               const struct nfs_setaclargs *arg,
1702               struct compound_hdr *hdr)
1703 {
1704     __u32 bitmap[2];
1705
1706     nfs4_acltype_to_bitmap(arg->acl_type, bitmap);
1707
1708     encode_op_hdr(xdr, OP_SETATTR, decode_setacl_maxsz, hdr);
1709     encode_nfs4_stateid(xdr, &zero_stateid);
1710     xdr_encode_bitmap4(xdr, bitmap, ARRAY_SIZE(bitmap));
1711     encode_uint32(xdr, arg->acl_len);
1712     xdr_write_pages(xdr, arg->acl_pages, 0, arg->acl_len);
1713 }
1714
1715 static void
1716 encode_savefh(struct xdr_stream *xdr, struct compound_hdr *hdr)
1717 {
1718     encode_op_hdr(xdr, OP_SAVEFH, decode_savefh_maxsz, hdr);
1719 }
1720
1721 static void encode_setattr(struct xdr_stream *xdr, const struct nfs_setattrargs *arg, const struct nfs_server *server, struct compound_hdr *hdr)
1722 {
1723     encode_op_hdr(xdr, OP_SETATTR, decode_setattr_maxsz, hdr);
1724     encode_nfs4_stateid(xdr, &arg->stateid);
1725     encode_attrs(xdr, arg->iap, arg->label, NULL, server,
1726             server->attr_bitmask);
1727 }
1728
1729 static void encode_setclientid(struct xdr_stream *xdr, const struct nfs4_setclientid *setclientid, struct compound_hdr *hdr)
1730 {
1731     __be32 *p;
1732
1733     encode_op_hdr(xdr, OP_SETCLIENTID, decode_setclientid_maxsz, hdr);
1734     encode_nfs4_verifier(xdr, setclientid->sc_verifier);
1735
1736     encode_string(xdr, strlen(setclientid->sc_clnt->cl_owner_id),
1737             setclientid->sc_clnt->cl_owner_id);
1738     p = reserve_space(xdr, 4);
1739     *p = cpu_to_be32(setclientid->sc_prog);
1740     encode_string(xdr, setclientid->sc_netid_len, setclientid->sc_netid);
1741     encode_string(xdr, setclientid->sc_uaddr_len, setclientid->sc_uaddr);
1742     p = reserve_space(xdr, 4);
1743     *p = cpu_to_be32(setclientid->sc_clnt->cl_cb_ident);
1744 }
1745
1746 static void encode_setclientid_confirm(struct xdr_stream *xdr, const struct nfs4_setclientid_res *arg, struct compound_hdr *hdr)
1747 {
1748     encode_op_hdr(xdr, OP_SETCLIENTID_CONFIRM,
1749             decode_setclientid_confirm_maxsz, hdr);
1750     encode_uint64(xdr, arg->clientid);
1751     encode_nfs4_verifier(xdr, &arg->confirm);
1752 }
1753
1754 static void encode_write(struct xdr_stream *xdr, const struct nfs_pgio_args *args,
1755              struct compound_hdr *hdr)
1756 {
1757     __be32 *p;
1758
1759     encode_op_hdr(xdr, OP_WRITE, decode_write_maxsz, hdr);
1760     encode_nfs4_stateid(xdr, &args->stateid);
1761
1762     p = reserve_space(xdr, 16);
1763     p = xdr_encode_hyper(p, args->offset);
1764     *p++ = cpu_to_be32(args->stable);
1765     *p = cpu_to_be32(args->count);
1766
1767     xdr_write_pages(xdr, args->pages, args->pgbase, args->count);
1768 }
1769
1770 static void encode_delegreturn(struct xdr_stream *xdr, const nfs4_stateid *stateid, struct compound_hdr *hdr)
1771 {
1772     encode_op_hdr(xdr, OP_DELEGRETURN, decode_delegreturn_maxsz, hdr);
1773     encode_nfs4_stateid(xdr, stateid);
1774 }
1775
1776 static void encode_secinfo(struct xdr_stream *xdr, const struct qstr *name, struct compound_hdr *hdr)
1777 {
1778     encode_op_hdr(xdr, OP_SECINFO, decode_secinfo_maxsz, hdr);
1779     encode_string(xdr, name->len, name->name);
1780 }
1781
1782 #if defined(CONFIG_NFS_V4_1)
1783 /* NFSv4.1 operations */
1784 static void encode_bind_conn_to_session(struct xdr_stream *xdr,
1785                    const struct nfs41_bind_conn_to_session_args *args,
1786                    struct compound_hdr *hdr)
1787 {
1788     __be32 *p;
1789
1790     encode_op_hdr(xdr, OP_BIND_CONN_TO_SESSION,
1791         decode_bind_conn_to_session_maxsz, hdr);
1792     encode_opaque_fixed(xdr, args->sessionid.data, NFS4_MAX_SESSIONID_LEN);
1793     p = xdr_reserve_space(xdr, 8);
1794     *p++ = cpu_to_be32(args->dir);
1795     *p = (args->use_conn_in_rdma_mode) ? cpu_to_be32(1) : cpu_to_be32(0);
1796 }
1797
1798 static void encode_op_map(struct xdr_stream *xdr, const struct nfs4_op_map *op_map)
1799 {
1800     unsigned int i;
1801     encode_uint32(xdr, NFS4_OP_MAP_NUM_WORDS);
1802     for (i = 0; i < NFS4_OP_MAP_NUM_WORDS; i++)
1803         encode_uint32(xdr, op_map->u.words[i]);
1804 }
1805
1806 static void encode_exchange_id(struct xdr_stream *xdr,
1807                    const struct nfs41_exchange_id_args *args,
1808                    struct compound_hdr *hdr)
1809 {
1810     __be32 *p;
1811     char impl_name[IMPL_NAME_LIMIT];
1812     int len = 0;
1813
1814     encode_op_hdr(xdr, OP_EXCHANGE_ID, decode_exchange_id_maxsz, hdr);
1815     encode_nfs4_verifier(xdr, &args->verifier);
1816
1817     encode_string(xdr, strlen(args->client->cl_owner_id),
1818             args->client->cl_owner_id);
1819
1820     encode_uint32(xdr, args->flags);
1821     encode_uint32(xdr, args->state_protect.how);
1822
1823     switch (args->state_protect.how) {
1824     case SP4_NONE:
1825         break;
1826     case SP4_MACH_CRED:
1827         encode_op_map(xdr, &args->state_protect.enforce);
1828         encode_op_map(xdr, &args->state_protect.allow);
1829         break;
1830     default:
1831         WARN_ON_ONCE(1);
1832         break;
1833     }
1834
1835     if (send_implementation_id &&
1836         sizeof(CONFIG_NFS_V4_1_IMPLEMENTATION_ID_DOMAIN) > 1 &&
1837         sizeof(CONFIG_NFS_V4_1_IMPLEMENTATION_ID_DOMAIN)
1838         <= sizeof(impl_name) + 1)
1839         len = snprintf(impl_name, sizeof(impl_name), "%s %s %s %s",
1840                    utsname()->sysname, utsname()->release,
1841                    utsname()->version, utsname()->machine);
1842
1843     if (len > 0) {
1844         encode_uint32(xdr, 1);  /* implementation id array length=1 */
1845
1846         encode_string(xdr,
1847             sizeof(CONFIG_NFS_V4_1_IMPLEMENTATION_ID_DOMAIN) - 1,
1848             CONFIG_NFS_V4_1_IMPLEMENTATION_ID_DOMAIN);
1849         encode_string(xdr, len, impl_name);
1850         /* just send zeros for nii_date - the date is in nii_name */
1851         p = reserve_space(xdr, 12);
1852         p = xdr_encode_hyper(p, 0);
1853         *p = cpu_to_be32(0);
1854     } else
1855         encode_uint32(xdr, 0);  /* implementation id array length=0 */
1856 }
1857
1858 static void encode_create_session(struct xdr_stream *xdr,
1859                   const struct nfs41_create_session_args *args,
1860                   struct compound_hdr *hdr)
1861 {
1862     __be32 *p;
1863     struct nfs_client *clp = args->client;
1864     struct rpc_clnt *clnt = clp->cl_rpcclient;
1865     struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
1866     u32 max_resp_sz_cached;
1867
1868     /*
1869      * Assumes OPEN is the biggest non-idempotent compound.
1870      * 2 is the verifier.
1871      */
1872     max_resp_sz_cached = (NFS4_dec_open_sz + RPC_REPHDRSIZE + 2)
1873                 * XDR_UNIT + RPC_MAX_AUTH_SIZE;
1874
1875     encode_op_hdr(xdr, OP_CREATE_SESSION, decode_create_session_maxsz, hdr);
1876     p = reserve_space(xdr, 16 + 2*28 + 20 + clnt->cl_nodelen + 12);
1877     p = xdr_encode_hyper(p, args->clientid);
1878     *p++ = cpu_to_be32(args->seqid);            /*Sequence id */
1879     *p++ = cpu_to_be32(args->flags);            /*flags */
1880
1881     /* Fore Channel */
1882     *p++ = cpu_to_be32(0);              /* header padding size */
1883     *p++ = cpu_to_be32(args->fc_attrs.max_rqst_sz); /* max req size */
1884     *p++ = cpu_to_be32(args->fc_attrs.max_resp_sz); /* max resp size */
1885     *p++ = cpu_to_be32(max_resp_sz_cached);     /* Max resp sz cached */
1886     *p++ = cpu_to_be32(args->fc_attrs.max_ops); /* max operations */
1887     *p++ = cpu_to_be32(args->fc_attrs.max_reqs);    /* max requests */
1888     *p++ = cpu_to_be32(0);              /* rdmachannel_attrs */
1889
1890     /* Back Channel */
1891     *p++ = cpu_to_be32(0);              /* header padding size */
1892     *p++ = cpu_to_be32(args->bc_attrs.max_rqst_sz); /* max req size */
1893     *p++ = cpu_to_be32(args->bc_attrs.max_resp_sz); /* max resp size */
1894     *p++ = cpu_to_be32(args->bc_attrs.max_resp_sz_cached);  /* Max resp sz cached */
1895     *p++ = cpu_to_be32(args->bc_attrs.max_ops); /* max operations */
1896     *p++ = cpu_to_be32(args->bc_attrs.max_reqs);    /* max requests */
1897     *p++ = cpu_to_be32(0);              /* rdmachannel_attrs */
1898
1899     *p++ = cpu_to_be32(args->cb_program);       /* cb_program */
1900     *p++ = cpu_to_be32(1);
1901     *p++ = cpu_to_be32(RPC_AUTH_UNIX);          /* auth_sys */
1902
1903     /* authsys_parms rfc1831 */
1904     *p++ = cpu_to_be32(ktime_to_ns(nn->boot_time)); /* stamp */
1905     p = xdr_encode_array(p, clnt->cl_nodename, clnt->cl_nodelen);
1906     *p++ = cpu_to_be32(0);              /* UID */
1907     *p++ = cpu_to_be32(0);              /* GID */
1908     *p = cpu_to_be32(0);                /* No more gids */
1909 }
1910
1911 static void encode_destroy_session(struct xdr_stream *xdr,
1912                    const struct nfs4_session *session,
1913                    struct compound_hdr *hdr)
1914 {
1915     encode_op_hdr(xdr, OP_DESTROY_SESSION, decode_destroy_session_maxsz, hdr);
1916     encode_opaque_fixed(xdr, session->sess_id.data, NFS4_MAX_SESSIONID_LEN);
1917 }
1918
1919 static void encode_destroy_clientid(struct xdr_stream *xdr,
1920                    uint64_t clientid,
1921                    struct compound_hdr *hdr)
1922 {
1923     encode_op_hdr(xdr, OP_DESTROY_CLIENTID, decode_destroy_clientid_maxsz, hdr);
1924     encode_uint64(xdr, clientid);
1925 }
1926
1927 static void encode_reclaim_complete(struct xdr_stream *xdr,
1928                     const struct nfs41_reclaim_complete_args *args,
1929                     struct compound_hdr *hdr)
1930 {
1931     encode_op_hdr(xdr, OP_RECLAIM_COMPLETE, decode_reclaim_complete_maxsz, hdr);
1932     encode_uint32(xdr, args->one_fs);
1933 }
1934 #endif /* CONFIG_NFS_V4_1 */
1935
1936 static void encode_sequence(struct xdr_stream *xdr,
1937                 const struct nfs4_sequence_args *args,
1938                 struct compound_hdr *hdr)
1939 {
1940 #if defined(CONFIG_NFS_V4_1)
1941     struct nfs4_session *session;
1942     struct nfs4_slot_table *tp;
1943     struct nfs4_slot *slot = args->sa_slot;
1944     __be32 *p;
1945
1946     tp = slot->table;
1947     session = tp->session;
1948     if (!session)
1949         return;
1950
1951     encode_op_hdr(xdr, OP_SEQUENCE, decode_sequence_maxsz, hdr);
1952
1953     /*
1954      * Sessionid + seqid + slotid + max slotid + cache_this
1955      */
1956     dprintk("%s: sessionid=%u:%u:%u:%u seqid=%d slotid=%d "
1957         "max_slotid=%d cache_this=%d\n",
1958         __func__,
1959         ((u32 *)session->sess_id.data)[0],
1960         ((u32 *)session->sess_id.data)[1],
1961         ((u32 *)session->sess_id.data)[2],
1962         ((u32 *)session->sess_id.data)[3],
1963         slot->seq_nr, slot->slot_nr,
1964         tp->highest_used_slotid, args->sa_cache_this);
1965     p = reserve_space(xdr, NFS4_MAX_SESSIONID_LEN + 16);
1966     p = xdr_encode_opaque_fixed(p, session->sess_id.data, NFS4_MAX_SESSIONID_LEN);
1967     *p++ = cpu_to_be32(slot->seq_nr);
1968     *p++ = cpu_to_be32(slot->slot_nr);
1969     *p++ = cpu_to_be32(tp->highest_used_slotid);
1970     *p = cpu_to_be32(args->sa_cache_this);
1971 #endif /* CONFIG_NFS_V4_1 */
1972 }
1973
1974 #ifdef CONFIG_NFS_V4_1
1975 static void
1976 encode_getdeviceinfo(struct xdr_stream *xdr,
1977              const struct nfs4_getdeviceinfo_args *args,
1978              struct compound_hdr *hdr)
1979 {
1980     __be32 *p;
1981
1982     encode_op_hdr(xdr, OP_GETDEVICEINFO, decode_getdeviceinfo_maxsz, hdr);
1983     p = reserve_space(xdr, NFS4_DEVICEID4_SIZE + 4 + 4);
1984     p = xdr_encode_opaque_fixed(p, args->pdev->dev_id.data,
1985                     NFS4_DEVICEID4_SIZE);
1986     *p++ = cpu_to_be32(args->pdev->layout_type);
1987     *p++ = cpu_to_be32(args->pdev->maxcount);   /* gdia_maxcount */
1988
1989     p = reserve_space(xdr, 4 + 4);
1990     *p++ = cpu_to_be32(1);          /* bitmap length */
1991     *p++ = cpu_to_be32(args->notify_types);
1992 }
1993
1994 static void
1995 encode_layoutget(struct xdr_stream *xdr,
1996               const struct nfs4_layoutget_args *args,
1997               struct compound_hdr *hdr)
1998 {
1999     __be32 *p;
2000
2001     encode_op_hdr(xdr, OP_LAYOUTGET, decode_layoutget_maxsz, hdr);
2002     p = reserve_space(xdr, 36);
2003     *p++ = cpu_to_be32(0);     /* Signal layout available */
2004     *p++ = cpu_to_be32(args->type);
2005     *p++ = cpu_to_be32(args->range.iomode);
2006     p = xdr_encode_hyper(p, args->range.offset);
2007     p = xdr_encode_hyper(p, args->range.length);
2008     p = xdr_encode_hyper(p, args->minlength);
2009     encode_nfs4_stateid(xdr, &args->stateid);
2010     encode_uint32(xdr, args->maxcount);
2011
2012     dprintk("%s: 1st type:0x%x iomode:%d off:%lu len:%lu mc:%d\n",
2013         __func__,
2014         args->type,
2015         args->range.iomode,
2016         (unsigned long)args->range.offset,
2017         (unsigned long)args->range.length,
2018         args->maxcount);
2019 }
2020
2021 static int
2022 encode_layoutcommit(struct xdr_stream *xdr,
2023             struct inode *inode,
2024             const struct nfs4_layoutcommit_args *args,
2025             struct compound_hdr *hdr)
2026 {
2027     __be32 *p;
2028
2029     dprintk("%s: lbw: %llu type: %d\n", __func__, args->lastbytewritten,
2030         NFS_SERVER(args->inode)->pnfs_curr_ld->id);
2031
2032     encode_op_hdr(xdr, OP_LAYOUTCOMMIT, decode_layoutcommit_maxsz, hdr);
2033     p = reserve_space(xdr, 20);
2034     /* Only whole file layouts */
2035     p = xdr_encode_hyper(p, 0); /* offset */
2036     p = xdr_encode_hyper(p, args->lastbytewritten + 1); /* length */
2037     *p = cpu_to_be32(0); /* reclaim */
2038     encode_nfs4_stateid(xdr, &args->stateid);
2039     if (args->lastbytewritten != U64_MAX) {
2040         p = reserve_space(xdr, 20);
2041         *p++ = cpu_to_be32(1); /* newoffset = TRUE */
2042         p = xdr_encode_hyper(p, args->lastbytewritten);
2043     } else {
2044         p = reserve_space(xdr, 12);
2045         *p++ = cpu_to_be32(0); /* newoffset = FALSE */
2046     }
2047     *p++ = cpu_to_be32(0); /* Never send time_modify_changed */
2048     *p++ = cpu_to_be32(NFS_SERVER(args->inode)->pnfs_curr_ld->id);/* type */
2049
2050     encode_uint32(xdr, args->layoutupdate_len);
2051     if (args->layoutupdate_pages)
2052         xdr_write_pages(xdr, args->layoutupdate_pages, 0,
2053                 args->layoutupdate_len);
2054
2055     return 0;
2056 }
2057
2058 static void
2059 encode_layoutreturn(struct xdr_stream *xdr,
2060             const struct nfs4_layoutreturn_args *args,
2061             struct compound_hdr *hdr)
2062 {
2063     __be32 *p;
2064
2065     encode_op_hdr(xdr, OP_LAYOUTRETURN, decode_layoutreturn_maxsz, hdr);
2066     p = reserve_space(xdr, 16);
2067     *p++ = cpu_to_be32(0);      /* reclaim. always 0 for now */
2068     *p++ = cpu_to_be32(args->layout_type);
2069     *p++ = cpu_to_be32(args->range.iomode);
2070     *p = cpu_to_be32(RETURN_FILE);
2071     p = reserve_space(xdr, 16);
2072     p = xdr_encode_hyper(p, args->range.offset);
2073     p = xdr_encode_hyper(p, args->range.length);
2074     spin_lock(&args->inode->i_lock);
2075     encode_nfs4_stateid(xdr, &args->stateid);
2076     spin_unlock(&args->inode->i_lock);
2077     if (args->ld_private->ops && args->ld_private->ops->encode)
2078         args->ld_private->ops->encode(xdr, args, args->ld_private);
2079     else
2080         encode_uint32(xdr, 0);
2081 }
2082
2083 static int
2084 encode_secinfo_no_name(struct xdr_stream *xdr,
2085                const struct nfs41_secinfo_no_name_args *args,
2086                struct compound_hdr *hdr)
2087 {
2088     encode_op_hdr(xdr, OP_SECINFO_NO_NAME, decode_secinfo_no_name_maxsz, hdr);
2089     encode_uint32(xdr, args->style);
2090     return 0;
2091 }
2092
2093 static void encode_test_stateid(struct xdr_stream *xdr,
2094                 const struct nfs41_test_stateid_args *args,
2095                 struct compound_hdr *hdr)
2096 {
2097     encode_op_hdr(xdr, OP_TEST_STATEID, decode_test_stateid_maxsz, hdr);
2098     encode_uint32(xdr, 1);
2099     encode_nfs4_stateid(xdr, args->stateid);
2100 }
2101
2102 static void encode_free_stateid(struct xdr_stream *xdr,
2103                 const struct nfs41_free_stateid_args *args,
2104                 struct compound_hdr *hdr)
2105 {
2106     encode_op_hdr(xdr, OP_FREE_STATEID, decode_free_stateid_maxsz, hdr);
2107     encode_nfs4_stateid(xdr, &args->stateid);
2108 }
2109 #else
2110 static inline void
2111 encode_layoutreturn(struct xdr_stream *xdr,
2112             const struct nfs4_layoutreturn_args *args,
2113             struct compound_hdr *hdr)
2114 {
2115 }
2116
2117 static void
2118 encode_layoutget(struct xdr_stream *xdr,
2119               const struct nfs4_layoutget_args *args,
2120               struct compound_hdr *hdr)
2121 {
2122 }
2123 #endif /* CONFIG_NFS_V4_1 */
2124
2125 /*
2126  * END OF "GENERIC" ENCODE ROUTINES.
2127  */
2128
2129 static u32 nfs4_xdr_minorversion(const struct nfs4_sequence_args *args)
2130 {
2131 #if defined(CONFIG_NFS_V4_1)
2132     struct nfs4_session *session = args->sa_slot->table->session;
2133     if (session)
2134         return session->clp->cl_mvops->minor_version;
2135 #endif /* CONFIG_NFS_V4_1 */
2136     return 0;
2137 }
2138
2139 /*
2140  * Encode an ACCESS request
2141  */
2142 static void nfs4_xdr_enc_access(struct rpc_rqst *req, struct xdr_stream *xdr,
2143                 const void *data)
2144 {
2145     const struct nfs4_accessargs *args = data;
2146     struct compound_hdr hdr = {
2147         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2148     };
2149
2150     encode_compound_hdr(xdr, req, &hdr);
2151     encode_sequence(xdr, &args->seq_args, &hdr);
2152     encode_putfh(xdr, args->fh, &hdr);
2153     encode_access(xdr, args->access, &hdr);
2154     if (args->bitmask)
2155         encode_getfattr(xdr, args->bitmask, &hdr);
2156     encode_nops(&hdr);
2157 }
2158
2159 /*
2160  * Encode LOOKUP request
2161  */
2162 static void nfs4_xdr_enc_lookup(struct rpc_rqst *req, struct xdr_stream *xdr,
2163                 const void *data)
2164 {
2165     const struct nfs4_lookup_arg *args = data;
2166     struct compound_hdr hdr = {
2167         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2168     };
2169
2170     encode_compound_hdr(xdr, req, &hdr);
2171     encode_sequence(xdr, &args->seq_args, &hdr);
2172     encode_putfh(xdr, args->dir_fh, &hdr);
2173     encode_lookup(xdr, args->name, &hdr);
2174     encode_getfh(xdr, &hdr);
2175     encode_getfattr(xdr, args->bitmask, &hdr);
2176     encode_nops(&hdr);
2177 }
2178
2179 /*
2180  * Encode LOOKUPP request
2181  */
2182 static void nfs4_xdr_enc_lookupp(struct rpc_rqst *req, struct xdr_stream *xdr,
2183         const void *data)
2184 {
2185     const struct nfs4_lookupp_arg *args = data;
2186     struct compound_hdr hdr = {
2187         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2188     };
2189
2190     encode_compound_hdr(xdr, req, &hdr);
2191     encode_sequence(xdr, &args->seq_args, &hdr);
2192     encode_putfh(xdr, args->fh, &hdr);
2193     encode_lookupp(xdr, &hdr);
2194     encode_getfh(xdr, &hdr);
2195     encode_getfattr(xdr, args->bitmask, &hdr);
2196     encode_nops(&hdr);
2197 }
2198
2199 /*
2200  * Encode LOOKUP_ROOT request
2201  */
2202 static void nfs4_xdr_enc_lookup_root(struct rpc_rqst *req,
2203                      struct xdr_stream *xdr,
2204                      const void *data)
2205 {
2206     const struct nfs4_lookup_root_arg *args = data;
2207     struct compound_hdr hdr = {
2208         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2209     };
2210
2211     encode_compound_hdr(xdr, req, &hdr);
2212     encode_sequence(xdr, &args->seq_args, &hdr);
2213     encode_putrootfh(xdr, &hdr);
2214     encode_getfh(xdr, &hdr);
2215     encode_getfattr(xdr, args->bitmask, &hdr);
2216     encode_nops(&hdr);
2217 }
2218
2219 /*
2220  * Encode REMOVE request
2221  */
2222 static void nfs4_xdr_enc_remove(struct rpc_rqst *req, struct xdr_stream *xdr,
2223                 const void *data)
2224 {
2225     const struct nfs_removeargs *args = data;
2226     struct compound_hdr hdr = {
2227         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2228     };
2229
2230     encode_compound_hdr(xdr, req, &hdr);
2231     encode_sequence(xdr, &args->seq_args, &hdr);
2232     encode_putfh(xdr, args->fh, &hdr);
2233     encode_remove(xdr, &args->name, &hdr);
2234     encode_nops(&hdr);
2235 }
2236
2237 /*
2238  * Encode RENAME request
2239  */
2240 static void nfs4_xdr_enc_rename(struct rpc_rqst *req, struct xdr_stream *xdr,
2241                 const void *data)
2242 {
2243     const struct nfs_renameargs *args = data;
2244     struct compound_hdr hdr = {
2245         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2246     };
2247
2248     encode_compound_hdr(xdr, req, &hdr);
2249     encode_sequence(xdr, &args->seq_args, &hdr);
2250     encode_putfh(xdr, args->old_dir, &hdr);
2251     encode_savefh(xdr, &hdr);
2252     encode_putfh(xdr, args->new_dir, &hdr);
2253     encode_rename(xdr, args->old_name, args->new_name, &hdr);
2254     encode_nops(&hdr);
2255 }
2256
2257 /*
2258  * Encode LINK request
2259  */
2260 static void nfs4_xdr_enc_link(struct rpc_rqst *req, struct xdr_stream *xdr,
2261                   const void *data)
2262 {
2263     const struct nfs4_link_arg *args = data;
2264     struct compound_hdr hdr = {
2265         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2266     };
2267
2268     encode_compound_hdr(xdr, req, &hdr);
2269     encode_sequence(xdr, &args->seq_args, &hdr);
2270     encode_putfh(xdr, args->fh, &hdr);
2271     encode_savefh(xdr, &hdr);
2272     encode_putfh(xdr, args->dir_fh, &hdr);
2273     encode_link(xdr, args->name, &hdr);
2274     encode_restorefh(xdr, &hdr);
2275     encode_getfattr(xdr, args->bitmask, &hdr);
2276     encode_nops(&hdr);
2277 }
2278
2279 /*
2280  * Encode CREATE request
2281  */
2282 static void nfs4_xdr_enc_create(struct rpc_rqst *req, struct xdr_stream *xdr,
2283                 const void *data)
2284 {
2285     const struct nfs4_create_arg *args = data;
2286     struct compound_hdr hdr = {
2287         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2288     };
2289
2290     encode_compound_hdr(xdr, req, &hdr);
2291     encode_sequence(xdr, &args->seq_args, &hdr);
2292     encode_putfh(xdr, args->dir_fh, &hdr);
2293     encode_create(xdr, args, &hdr);
2294     encode_getfh(xdr, &hdr);
2295     encode_getfattr(xdr, args->bitmask, &hdr);
2296     encode_nops(&hdr);
2297 }
2298
2299 /*
2300  * Encode SYMLINK request
2301  */
2302 static void nfs4_xdr_enc_symlink(struct rpc_rqst *req, struct xdr_stream *xdr,
2303                  const void *data)
2304 {
2305     const struct nfs4_create_arg *args = data;
2306
2307     nfs4_xdr_enc_create(req, xdr, args);
2308 }
2309
2310 /*
2311  * Encode GETATTR request
2312  */
2313 static void nfs4_xdr_enc_getattr(struct rpc_rqst *req, struct xdr_stream *xdr,
2314                  const void *data)
2315 {
2316     const struct nfs4_getattr_arg *args = data;
2317     struct compound_hdr hdr = {
2318         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2319     };
2320
2321     encode_compound_hdr(xdr, req, &hdr);
2322     encode_sequence(xdr, &args->seq_args, &hdr);
2323     encode_putfh(xdr, args->fh, &hdr);
2324     encode_getfattr(xdr, args->bitmask, &hdr);
2325     encode_nops(&hdr);
2326 }
2327
2328 /*
2329  * Encode a CLOSE request
2330  */
2331 static void nfs4_xdr_enc_close(struct rpc_rqst *req, struct xdr_stream *xdr,
2332                    const void *data)
2333 {
2334     const struct nfs_closeargs *args = data;
2335     struct compound_hdr hdr = {
2336         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2337     };
2338
2339     encode_compound_hdr(xdr, req, &hdr);
2340     encode_sequence(xdr, &args->seq_args, &hdr);
2341     encode_putfh(xdr, args->fh, &hdr);
2342     if (args->lr_args)
2343         encode_layoutreturn(xdr, args->lr_args, &hdr);
2344     if (args->bitmask != NULL)
2345         encode_getfattr(xdr, args->bitmask, &hdr);
2346     encode_close(xdr, args, &hdr);
2347     encode_nops(&hdr);
2348 }
2349
2350 /*
2351  * Encode an OPEN request
2352  */
2353 static void nfs4_xdr_enc_open(struct rpc_rqst *req, struct xdr_stream *xdr,
2354                   const void *data)
2355 {
2356     const struct nfs_openargs *args = data;
2357     struct compound_hdr hdr = {
2358         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2359     };
2360
2361     encode_compound_hdr(xdr, req, &hdr);
2362     encode_sequence(xdr, &args->seq_args, &hdr);
2363     encode_putfh(xdr, args->fh, &hdr);
2364     encode_open(xdr, args, &hdr);
2365     encode_getfh(xdr, &hdr);
2366     if (args->access)
2367         encode_access(xdr, args->access, &hdr);
2368     encode_getfattr_open(xdr, args->bitmask, args->open_bitmap, &hdr);
2369     if (args->lg_args) {
2370         encode_layoutget(xdr, args->lg_args, &hdr);
2371         rpc_prepare_reply_pages(req, args->lg_args->layout.pages, 0,
2372                     args->lg_args->layout.pglen,
2373                     hdr.replen - pagepad_maxsz);
2374     }
2375     encode_nops(&hdr);
2376 }
2377
2378 /*
2379  * Encode an OPEN_CONFIRM request
2380  */
2381 static void nfs4_xdr_enc_open_confirm(struct rpc_rqst *req,
2382                       struct xdr_stream *xdr,
2383                       const void *data)
2384 {
2385     const struct nfs_open_confirmargs *args = data;
2386     struct compound_hdr hdr = {
2387         .nops   = 0,
2388     };
2389
2390     encode_compound_hdr(xdr, req, &hdr);
2391     encode_putfh(xdr, args->fh, &hdr);
2392     encode_open_confirm(xdr, args, &hdr);
2393     encode_nops(&hdr);
2394 }
2395
2396 /*
2397  * Encode an OPEN request with no attributes.
2398  */
2399 static void nfs4_xdr_enc_open_noattr(struct rpc_rqst *req,
2400                      struct xdr_stream *xdr,
2401                      const void *data)
2402 {
2403     const struct nfs_openargs *args = data;
2404     struct compound_hdr hdr = {
2405         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2406     };
2407
2408     encode_compound_hdr(xdr, req, &hdr);
2409     encode_sequence(xdr, &args->seq_args, &hdr);
2410     encode_putfh(xdr, args->fh, &hdr);
2411     encode_open(xdr, args, &hdr);
2412     if (args->access)
2413         encode_access(xdr, args->access, &hdr);
2414     encode_getfattr_open(xdr, args->bitmask, args->open_bitmap, &hdr);
2415     if (args->lg_args) {
2416         encode_layoutget(xdr, args->lg_args, &hdr);
2417         rpc_prepare_reply_pages(req, args->lg_args->layout.pages, 0,
2418                     args->lg_args->layout.pglen,
2419                     hdr.replen - pagepad_maxsz);
2420     }
2421     encode_nops(&hdr);
2422 }
2423
2424 /*
2425  * Encode an OPEN_DOWNGRADE request
2426  */
2427 static void nfs4_xdr_enc_open_downgrade(struct rpc_rqst *req,
2428                     struct xdr_stream *xdr,
2429                     const void *data)
2430 {
2431     const struct nfs_closeargs *args = data;
2432     struct compound_hdr hdr = {
2433         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2434     };
2435
2436     encode_compound_hdr(xdr, req, &hdr);
2437     encode_sequence(xdr, &args->seq_args, &hdr);
2438     encode_putfh(xdr, args->fh, &hdr);
2439     if (args->lr_args)
2440         encode_layoutreturn(xdr, args->lr_args, &hdr);
2441     encode_open_downgrade(xdr, args, &hdr);
2442     encode_nops(&hdr);
2443 }
2444
2445 /*
2446  * Encode a LOCK request
2447  */
2448 static void nfs4_xdr_enc_lock(struct rpc_rqst *req, struct xdr_stream *xdr,
2449                   const void *data)
2450 {
2451     const struct nfs_lock_args *args = data;
2452     struct compound_hdr hdr = {
2453         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2454     };
2455
2456     encode_compound_hdr(xdr, req, &hdr);
2457     encode_sequence(xdr, &args->seq_args, &hdr);
2458     encode_putfh(xdr, args->fh, &hdr);
2459     encode_lock(xdr, args, &hdr);
2460     encode_nops(&hdr);
2461 }
2462
2463 /*
2464  * Encode a LOCKT request
2465  */
2466 static void nfs4_xdr_enc_lockt(struct rpc_rqst *req, struct xdr_stream *xdr,
2467                    const void *data)
2468 {
2469     const struct nfs_lockt_args *args = data;
2470     struct compound_hdr hdr = {
2471         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2472     };
2473
2474     encode_compound_hdr(xdr, req, &hdr);
2475     encode_sequence(xdr, &args->seq_args, &hdr);
2476     encode_putfh(xdr, args->fh, &hdr);
2477     encode_lockt(xdr, args, &hdr);
2478     encode_nops(&hdr);
2479 }
2480
2481 /*
2482  * Encode a LOCKU request
2483  */
2484 static void nfs4_xdr_enc_locku(struct rpc_rqst *req, struct xdr_stream *xdr,
2485                    const void *data)
2486 {
2487     const struct nfs_locku_args *args = data;
2488     struct compound_hdr hdr = {
2489         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2490     };
2491
2492     encode_compound_hdr(xdr, req, &hdr);
2493     encode_sequence(xdr, &args->seq_args, &hdr);
2494     encode_putfh(xdr, args->fh, &hdr);
2495     encode_locku(xdr, args, &hdr);
2496     encode_nops(&hdr);
2497 }
2498
2499 static void nfs4_xdr_enc_release_lockowner(struct rpc_rqst *req,
2500                        struct xdr_stream *xdr,
2501                        const void *data)
2502 {
2503     const struct nfs_release_lockowner_args *args = data;
2504     struct compound_hdr hdr = {
2505         .minorversion = 0,
2506     };
2507
2508     encode_compound_hdr(xdr, req, &hdr);
2509     encode_release_lockowner(xdr, &args->lock_owner, &hdr);
2510     encode_nops(&hdr);
2511 }
2512
2513 /*
2514  * Encode a READLINK request
2515  */
2516 static void nfs4_xdr_enc_readlink(struct rpc_rqst *req, struct xdr_stream *xdr,
2517                   const void *data)
2518 {
2519     const struct nfs4_readlink *args = data;
2520     struct compound_hdr hdr = {
2521         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2522     };
2523
2524     encode_compound_hdr(xdr, req, &hdr);
2525     encode_sequence(xdr, &args->seq_args, &hdr);
2526     encode_putfh(xdr, args->fh, &hdr);
2527     encode_readlink(xdr, args, req, &hdr);
2528
2529     rpc_prepare_reply_pages(req, args->pages, args->pgbase,
2530                 args->pglen, hdr.replen - pagepad_maxsz);
2531     encode_nops(&hdr);
2532 }
2533
2534 /*
2535  * Encode a READDIR request
2536  */
2537 static void nfs4_xdr_enc_readdir(struct rpc_rqst *req, struct xdr_stream *xdr,
2538                  const void *data)
2539 {
2540     const struct nfs4_readdir_arg *args = data;
2541     struct compound_hdr hdr = {
2542         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2543     };
2544
2545     encode_compound_hdr(xdr, req, &hdr);
2546     encode_sequence(xdr, &args->seq_args, &hdr);
2547     encode_putfh(xdr, args->fh, &hdr);
2548     encode_readdir(xdr, args, req, &hdr);
2549
2550     rpc_prepare_reply_pages(req, args->pages, args->pgbase,
2551                 args->count, hdr.replen - pagepad_maxsz);
2552     encode_nops(&hdr);
2553 }
2554
2555 /*
2556  * Encode a READ request
2557  */
2558 static void nfs4_xdr_enc_read(struct rpc_rqst *req, struct xdr_stream *xdr,
2559                   const void *data)
2560 {
2561     const struct nfs_pgio_args *args = data;
2562     struct compound_hdr hdr = {
2563         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2564     };
2565
2566     encode_compound_hdr(xdr, req, &hdr);
2567     encode_sequence(xdr, &args->seq_args, &hdr);
2568     encode_putfh(xdr, args->fh, &hdr);
2569     encode_read(xdr, args, &hdr);
2570
2571     rpc_prepare_reply_pages(req, args->pages, args->pgbase,
2572                 args->count, hdr.replen - pagepad_maxsz);
2573     req->rq_rcv_buf.flags |= XDRBUF_READ;
2574     encode_nops(&hdr);
2575 }
2576
2577 /*
2578  * Encode an SETATTR request
2579  */
2580 static void nfs4_xdr_enc_setattr(struct rpc_rqst *req, struct xdr_stream *xdr,
2581                  const void *data)
2582 {
2583     const struct nfs_setattrargs *args = data;
2584     struct compound_hdr hdr = {
2585         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2586     };
2587
2588     encode_compound_hdr(xdr, req, &hdr);
2589     encode_sequence(xdr, &args->seq_args, &hdr);
2590     encode_putfh(xdr, args->fh, &hdr);
2591     encode_setattr(xdr, args, args->server, &hdr);
2592     encode_getfattr(xdr, args->bitmask, &hdr);
2593     encode_nops(&hdr);
2594 }
2595
2596 /*
2597  * Encode a GETACL request
2598  */
2599 static void nfs4_xdr_enc_getacl(struct rpc_rqst *req, struct xdr_stream *xdr,
2600                 const void *data)
2601 {
2602     const struct nfs_getaclargs *args = data;
2603     struct compound_hdr hdr = {
2604         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2605     };
2606     __u32 nfs4_acl_bitmap[2];
2607     uint32_t replen;
2608
2609     nfs4_acltype_to_bitmap(args->acl_type, nfs4_acl_bitmap);
2610
2611     encode_compound_hdr(xdr, req, &hdr);
2612     encode_sequence(xdr, &args->seq_args, &hdr);
2613     encode_putfh(xdr, args->fh, &hdr);
2614     replen = hdr.replen + op_decode_hdr_maxsz;
2615     encode_getattr(xdr, nfs4_acl_bitmap, NULL,
2616             ARRAY_SIZE(nfs4_acl_bitmap), &hdr);
2617
2618     rpc_prepare_reply_pages(req, args->acl_pages, 0,
2619                 args->acl_len, replen);
2620     encode_nops(&hdr);
2621 }
2622
2623 /*
2624  * Encode a WRITE request
2625  */
2626 static void nfs4_xdr_enc_write(struct rpc_rqst *req, struct xdr_stream *xdr,
2627                    const void *data)
2628 {
2629     const struct nfs_pgio_args *args = data;
2630     struct compound_hdr hdr = {
2631         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2632     };
2633
2634     encode_compound_hdr(xdr, req, &hdr);
2635     encode_sequence(xdr, &args->seq_args, &hdr);
2636     encode_putfh(xdr, args->fh, &hdr);
2637     encode_write(xdr, args, &hdr);
2638     req->rq_snd_buf.flags |= XDRBUF_WRITE;
2639     if (args->bitmask)
2640         encode_getfattr(xdr, args->bitmask, &hdr);
2641     encode_nops(&hdr);
2642 }
2643
2644 /*
2645  *  a COMMIT request
2646  */
2647 static void nfs4_xdr_enc_commit(struct rpc_rqst *req, struct xdr_stream *xdr,
2648                 const void *data)
2649 {
2650     const struct nfs_commitargs *args = data;
2651     struct compound_hdr hdr = {
2652         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2653     };
2654
2655     encode_compound_hdr(xdr, req, &hdr);
2656     encode_sequence(xdr, &args->seq_args, &hdr);
2657     encode_putfh(xdr, args->fh, &hdr);
2658     encode_commit(xdr, args, &hdr);
2659     encode_nops(&hdr);
2660 }
2661
2662 /*
2663  * FSINFO request
2664  */
2665 static void nfs4_xdr_enc_fsinfo(struct rpc_rqst *req, struct xdr_stream *xdr,
2666                 const void *data)
2667 {
2668     const struct nfs4_fsinfo_arg *args = data;
2669     struct compound_hdr hdr = {
2670         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2671     };
2672
2673     encode_compound_hdr(xdr, req, &hdr);
2674     encode_sequence(xdr, &args->seq_args, &hdr);
2675     encode_putfh(xdr, args->fh, &hdr);
2676     encode_fsinfo(xdr, args->bitmask, &hdr);
2677     encode_nops(&hdr);
2678 }
2679
2680 /*
2681  * a PATHCONF request
2682  */
2683 static void nfs4_xdr_enc_pathconf(struct rpc_rqst *req, struct xdr_stream *xdr,
2684                   const void *data)
2685 {
2686     const struct nfs4_pathconf_arg *args = data;
2687     struct compound_hdr hdr = {
2688         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2689     };
2690
2691     encode_compound_hdr(xdr, req, &hdr);
2692     encode_sequence(xdr, &args->seq_args, &hdr);
2693     encode_putfh(xdr, args->fh, &hdr);
2694     encode_getattr(xdr, nfs4_pathconf_bitmap, args->bitmask,
2695             ARRAY_SIZE(nfs4_pathconf_bitmap), &hdr);
2696     encode_nops(&hdr);
2697 }
2698
2699 /*
2700  * a STATFS request
2701  */
2702 static void nfs4_xdr_enc_statfs(struct rpc_rqst *req, struct xdr_stream *xdr,
2703                 const void *data)
2704 {
2705     const struct nfs4_statfs_arg *args = data;
2706     struct compound_hdr hdr = {
2707         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2708     };
2709
2710     encode_compound_hdr(xdr, req, &hdr);
2711     encode_sequence(xdr, &args->seq_args, &hdr);
2712     encode_putfh(xdr, args->fh, &hdr);
2713     encode_getattr(xdr, nfs4_statfs_bitmap, args->bitmask,
2714             ARRAY_SIZE(nfs4_statfs_bitmap), &hdr);
2715     encode_nops(&hdr);
2716 }
2717
2718 /*
2719  * GETATTR_BITMAP request
2720  */
2721 static void nfs4_xdr_enc_server_caps(struct rpc_rqst *req,
2722                      struct xdr_stream *xdr,
2723                      const void *data)
2724 {
2725     const struct nfs4_server_caps_arg *args = data;
2726     const u32 *bitmask = args->bitmask;
2727     struct compound_hdr hdr = {
2728         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2729     };
2730
2731     encode_compound_hdr(xdr, req, &hdr);
2732     encode_sequence(xdr, &args->seq_args, &hdr);
2733     encode_putfh(xdr, args->fhandle, &hdr);
2734     encode_getattr(xdr, bitmask, NULL, 3, &hdr);
2735     encode_nops(&hdr);
2736 }
2737
2738 /*
2739  * a RENEW request
2740  */
2741 static void nfs4_xdr_enc_renew(struct rpc_rqst *req, struct xdr_stream *xdr,
2742                    const void *data)
2743
2744 {
2745     const struct nfs_client *clp = data;
2746     struct compound_hdr hdr = {
2747         .nops   = 0,
2748     };
2749
2750     encode_compound_hdr(xdr, req, &hdr);
2751     encode_renew(xdr, clp->cl_clientid, &hdr);
2752     encode_nops(&hdr);
2753 }
2754
2755 /*
2756  * a SETCLIENTID request
2757  */
2758 static void nfs4_xdr_enc_setclientid(struct rpc_rqst *req,
2759                      struct xdr_stream *xdr,
2760                      const void *data)
2761 {
2762     const struct nfs4_setclientid *sc = data;
2763     struct compound_hdr hdr = {
2764         .nops   = 0,
2765     };
2766
2767     encode_compound_hdr(xdr, req, &hdr);
2768     encode_setclientid(xdr, sc, &hdr);
2769     encode_nops(&hdr);
2770 }
2771
2772 /*
2773  * a SETCLIENTID_CONFIRM request
2774  */
2775 static void nfs4_xdr_enc_setclientid_confirm(struct rpc_rqst *req,
2776                          struct xdr_stream *xdr,
2777                          const void *data)
2778 {
2779     const struct nfs4_setclientid_res *arg = data;
2780     struct compound_hdr hdr = {
2781         .nops   = 0,
2782     };
2783
2784     encode_compound_hdr(xdr, req, &hdr);
2785     encode_setclientid_confirm(xdr, arg, &hdr);
2786     encode_nops(&hdr);
2787 }
2788
2789 /*
2790  * DELEGRETURN request
2791  */
2792 static void nfs4_xdr_enc_delegreturn(struct rpc_rqst *req,
2793                      struct xdr_stream *xdr,
2794                      const void *data)
2795 {
2796     const struct nfs4_delegreturnargs *args = data;
2797     struct compound_hdr hdr = {
2798         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2799     };
2800
2801     encode_compound_hdr(xdr, req, &hdr);
2802     encode_sequence(xdr, &args->seq_args, &hdr);
2803     encode_putfh(xdr, args->fhandle, &hdr);
2804     if (args->lr_args)
2805         encode_layoutreturn(xdr, args->lr_args, &hdr);
2806     if (args->bitmask)
2807         encode_getfattr(xdr, args->bitmask, &hdr);
2808     encode_delegreturn(xdr, args->stateid, &hdr);
2809     encode_nops(&hdr);
2810 }
2811
2812 /*
2813  * Encode FS_LOCATIONS request
2814  */
2815 static void nfs4_xdr_enc_fs_locations(struct rpc_rqst *req,
2816                       struct xdr_stream *xdr,
2817                       const void *data)
2818 {
2819     const struct nfs4_fs_locations_arg *args = data;
2820     struct compound_hdr hdr = {
2821         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2822     };
2823     uint32_t replen;
2824
2825     encode_compound_hdr(xdr, req, &hdr);
2826     encode_sequence(xdr, &args->seq_args, &hdr);
2827     if (args->migration) {
2828         encode_putfh(xdr, args->fh, &hdr);
2829         replen = hdr.replen;
2830         encode_fs_locations(xdr, args->bitmask, &hdr);
2831         if (args->renew)
2832             encode_renew(xdr, args->clientid, &hdr);
2833     } else {
2834         encode_putfh(xdr, args->dir_fh, &hdr);
2835         encode_lookup(xdr, args->name, &hdr);
2836         replen = hdr.replen;
2837         encode_fs_locations(xdr, args->bitmask, &hdr);
2838     }
2839
2840     rpc_prepare_reply_pages(req, (struct page **)&args->page, 0,
2841                 PAGE_SIZE, replen);
2842     encode_nops(&hdr);
2843 }
2844
2845 /*
2846  * Encode SECINFO request
2847  */
2848 static void nfs4_xdr_enc_secinfo(struct rpc_rqst *req,
2849                 struct xdr_stream *xdr,
2850                 const void *data)
2851 {
2852     const struct nfs4_secinfo_arg *args = data;
2853     struct compound_hdr hdr = {
2854         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2855     };
2856
2857     encode_compound_hdr(xdr, req, &hdr);
2858     encode_sequence(xdr, &args->seq_args, &hdr);
2859     encode_putfh(xdr, args->dir_fh, &hdr);
2860     encode_secinfo(xdr, args->name, &hdr);
2861     encode_nops(&hdr);
2862 }
2863
2864 /*
2865  * Encode FSID_PRESENT request
2866  */
2867 static void nfs4_xdr_enc_fsid_present(struct rpc_rqst *req,
2868                       struct xdr_stream *xdr,
2869                       const void *data)
2870 {
2871     const struct nfs4_fsid_present_arg *args = data;
2872     struct compound_hdr hdr = {
2873         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2874     };
2875
2876     encode_compound_hdr(xdr, req, &hdr);
2877     encode_sequence(xdr, &args->seq_args, &hdr);
2878     encode_putfh(xdr, args->fh, &hdr);
2879     encode_getfh(xdr, &hdr);
2880     if (args->renew)
2881         encode_renew(xdr, args->clientid, &hdr);
2882     encode_nops(&hdr);
2883 }
2884
2885 #if defined(CONFIG_NFS_V4_1)
2886 /*
2887  * BIND_CONN_TO_SESSION request
2888  */
2889 static void nfs4_xdr_enc_bind_conn_to_session(struct rpc_rqst *req,
2890                 struct xdr_stream *xdr,
2891                 const void *data)
2892 {
2893     const struct nfs41_bind_conn_to_session_args *args = data;
2894     struct compound_hdr hdr = {
2895         .minorversion = args->client->cl_mvops->minor_version,
2896     };
2897
2898     encode_compound_hdr(xdr, req, &hdr);
2899     encode_bind_conn_to_session(xdr, args, &hdr);
2900     encode_nops(&hdr);
2901 }
2902
2903 /*
2904  * EXCHANGE_ID request
2905  */
2906 static void nfs4_xdr_enc_exchange_id(struct rpc_rqst *req,
2907                      struct xdr_stream *xdr,
2908                      const void *data)
2909 {
2910     const struct nfs41_exchange_id_args *args = data;
2911     struct compound_hdr hdr = {
2912         .minorversion = args->client->cl_mvops->minor_version,
2913     };
2914
2915     encode_compound_hdr(xdr, req, &hdr);
2916     encode_exchange_id(xdr, args, &hdr);
2917     encode_nops(&hdr);
2918 }
2919
2920 /*
2921  * a CREATE_SESSION request
2922  */
2923 static void nfs4_xdr_enc_create_session(struct rpc_rqst *req,
2924                     struct xdr_stream *xdr,
2925                     const void *data)
2926 {
2927     const struct nfs41_create_session_args *args = data;
2928     struct compound_hdr hdr = {
2929         .minorversion = args->client->cl_mvops->minor_version,
2930     };
2931
2932     encode_compound_hdr(xdr, req, &hdr);
2933     encode_create_session(xdr, args, &hdr);
2934     encode_nops(&hdr);
2935 }
2936
2937 /*
2938  * a DESTROY_SESSION request
2939  */
2940 static void nfs4_xdr_enc_destroy_session(struct rpc_rqst *req,
2941                      struct xdr_stream *xdr,
2942                      const void *data)
2943 {
2944     const struct nfs4_session *session = data;
2945     struct compound_hdr hdr = {
2946         .minorversion = session->clp->cl_mvops->minor_version,
2947     };
2948
2949     encode_compound_hdr(xdr, req, &hdr);
2950     encode_destroy_session(xdr, session, &hdr);
2951     encode_nops(&hdr);
2952 }
2953
2954 /*
2955  * a DESTROY_CLIENTID request
2956  */
2957 static void nfs4_xdr_enc_destroy_clientid(struct rpc_rqst *req,
2958                      struct xdr_stream *xdr,
2959                      const void *data)
2960 {
2961     const struct nfs_client *clp = data;
2962     struct compound_hdr hdr = {
2963         .minorversion = clp->cl_mvops->minor_version,
2964     };
2965
2966     encode_compound_hdr(xdr, req, &hdr);
2967     encode_destroy_clientid(xdr, clp->cl_clientid, &hdr);
2968     encode_nops(&hdr);
2969 }
2970
2971 /*
2972  * a SEQUENCE request
2973  */
2974 static void nfs4_xdr_enc_sequence(struct rpc_rqst *req, struct xdr_stream *xdr,
2975                   const void *data)
2976 {
2977     const struct nfs4_sequence_args *args = data;
2978     struct compound_hdr hdr = {
2979         .minorversion = nfs4_xdr_minorversion(args),
2980     };
2981
2982     encode_compound_hdr(xdr, req, &hdr);
2983     encode_sequence(xdr, args, &hdr);
2984     encode_nops(&hdr);
2985 }
2986
2987 #endif
2988
2989 /*
2990  * a GET_LEASE_TIME request
2991  */
2992 static void nfs4_xdr_enc_get_lease_time(struct rpc_rqst *req,
2993                     struct xdr_stream *xdr,
2994                     const void *data)
2995 {
2996     const struct nfs4_get_lease_time_args *args = data;
2997     struct compound_hdr hdr = {
2998         .minorversion = nfs4_xdr_minorversion(&args->la_seq_args),
2999     };
3000     const u32 lease_bitmap[3] = { FATTR4_WORD0_LEASE_TIME };
3001
3002     encode_compound_hdr(xdr, req, &hdr);
3003     encode_sequence(xdr, &args->la_seq_args, &hdr);
3004     encode_putrootfh(xdr, &hdr);
3005     encode_fsinfo(xdr, lease_bitmap, &hdr);
3006     encode_nops(&hdr);
3007 }
3008
3009 #ifdef CONFIG_NFS_V4_1
3010
3011 /*
3012  * a RECLAIM_COMPLETE request
3013  */
3014 static void nfs4_xdr_enc_reclaim_complete(struct rpc_rqst *req,
3015                       struct xdr_stream *xdr,
3016                       const void *data)
3017 {
3018     const struct nfs41_reclaim_complete_args *args = data;
3019     struct compound_hdr hdr = {
3020         .minorversion = nfs4_xdr_minorversion(&args->seq_args)
3021     };
3022
3023     encode_compound_hdr(xdr, req, &hdr);
3024     encode_sequence(xdr, &args->seq_args, &hdr);
3025     encode_reclaim_complete(xdr, args, &hdr);
3026     encode_nops(&hdr);
3027 }
3028
3029 /*
3030  * Encode GETDEVICEINFO request
3031  */
3032 static void nfs4_xdr_enc_getdeviceinfo(struct rpc_rqst *req,
3033                        struct xdr_stream *xdr,
3034                        const void *data)
3035 {
3036     const struct nfs4_getdeviceinfo_args *args = data;
3037     struct compound_hdr hdr = {
3038         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
3039     };
3040     uint32_t replen;
3041
3042     encode_compound_hdr(xdr, req, &hdr);
3043     encode_sequence(xdr, &args->seq_args, &hdr);
3044
3045     replen = hdr.replen + op_decode_hdr_maxsz + 2;
3046
3047     encode_getdeviceinfo(xdr, args, &hdr);
3048
3049     /* set up reply kvec. device_addr4 opaque data is read into the
3050      * pages */
3051     rpc_prepare_reply_pages(req, args->pdev->pages, args->pdev->pgbase,
3052                 args->pdev->pglen, replen);
3053     encode_nops(&hdr);
3054 }
3055
3056 /*
3057  *  Encode LAYOUTGET request
3058  */
3059 static void nfs4_xdr_enc_layoutget(struct rpc_rqst *req,
3060                    struct xdr_stream *xdr,
3061                    const void *data)
3062 {
3063     const struct nfs4_layoutget_args *args = data;
3064     struct compound_hdr hdr = {
3065         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
3066     };
3067
3068     encode_compound_hdr(xdr, req, &hdr);
3069     encode_sequence(xdr, &args->seq_args, &hdr);
3070     encode_putfh(xdr, NFS_FH(args->inode), &hdr);
3071     encode_layoutget(xdr, args, &hdr);
3072
3073     rpc_prepare_reply_pages(req, args->layout.pages, 0,
3074                 args->layout.pglen, hdr.replen - pagepad_maxsz);
3075     encode_nops(&hdr);
3076 }
3077
3078 /*
3079  *  Encode LAYOUTCOMMIT request
3080  */
3081 static void nfs4_xdr_enc_layoutcommit(struct rpc_rqst *req,
3082                       struct xdr_stream *xdr,
3083                       const void *priv)
3084 {
3085     const struct nfs4_layoutcommit_args *args = priv;
3086     struct nfs4_layoutcommit_data *data =
3087         container_of(args, struct nfs4_layoutcommit_data, args);
3088     struct compound_hdr hdr = {
3089         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
3090     };
3091
3092     encode_compound_hdr(xdr, req, &hdr);
3093     encode_sequence(xdr, &args->seq_args, &hdr);
3094     encode_putfh(xdr, NFS_FH(args->inode), &hdr);
3095     encode_layoutcommit(xdr, data->args.inode, args, &hdr);
3096     encode_getfattr(xdr, args->bitmask, &hdr);
3097     encode_nops(&hdr);
3098 }
3099
3100 /*
3101  * Encode LAYOUTRETURN request
3102  */
3103 static void nfs4_xdr_enc_layoutreturn(struct rpc_rqst *req,
3104                       struct xdr_stream *xdr,
3105                       const void *data)
3106 {
3107     const struct nfs4_layoutreturn_args *args = data;
3108     struct compound_hdr hdr = {
3109         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
3110     };
3111
3112     encode_compound_hdr(xdr, req, &hdr);
3113     encode_sequence(xdr, &args->seq_args, &hdr);
3114     encode_putfh(xdr, NFS_FH(args->inode), &hdr);
3115     encode_layoutreturn(xdr, args, &hdr);
3116     encode_nops(&hdr);
3117 }
3118
3119 /*
3120  * Encode SECINFO_NO_NAME request
3121  */
3122 static void nfs4_xdr_enc_secinfo_no_name(struct rpc_rqst *req,
3123                     struct xdr_stream *xdr,
3124                     const void *data)
3125 {
3126     const struct nfs41_secinfo_no_name_args *args = data;
3127     struct compound_hdr hdr = {
3128         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
3129     };
3130
3131     encode_compound_hdr(xdr, req, &hdr);
3132     encode_sequence(xdr, &args->seq_args, &hdr);
3133     encode_putrootfh(xdr, &hdr);
3134     encode_secinfo_no_name(xdr, args, &hdr);
3135     encode_nops(&hdr);
3136 }
3137
3138 /*
3139  *  Encode TEST_STATEID request
3140  */
3141 static void nfs4_xdr_enc_test_stateid(struct rpc_rqst *req,
3142                       struct xdr_stream *xdr,
3143                       const void *data)
3144 {
3145     const struct nfs41_test_stateid_args *args = data;
3146     struct compound_hdr hdr = {
3147         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
3148     };
3149
3150     encode_compound_hdr(xdr, req, &hdr);
3151     encode_sequence(xdr, &args->seq_args, &hdr);
3152     encode_test_stateid(xdr, args, &hdr);
3153     encode_nops(&hdr);
3154 }
3155
3156 /*
3157  *  Encode FREE_STATEID request
3158  */
3159 static void nfs4_xdr_enc_free_stateid(struct rpc_rqst *req,
3160                      struct xdr_stream *xdr,
3161                      const void *data)
3162 {
3163     const struct nfs41_free_stateid_args *args = data;
3164     struct compound_hdr hdr = {
3165         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
3166     };
3167
3168     encode_compound_hdr(xdr, req, &hdr);
3169     encode_sequence(xdr, &args->seq_args, &hdr);
3170     encode_free_stateid(xdr, args, &hdr);
3171     encode_nops(&hdr);
3172 }
3173 #endif /* CONFIG_NFS_V4_1 */
3174
3175 static int decode_opaque_inline(struct xdr_stream *xdr, unsigned int *len, char **string)
3176 {
3177     ssize_t ret = xdr_stream_decode_opaque_inline(xdr, (void **)string,
3178             NFS4_OPAQUE_LIMIT);
3179     if (unlikely(ret < 0))
3180         return -EIO;
3181     *len = ret;
3182     return 0;
3183 }
3184
3185 static int decode_compound_hdr(struct xdr_stream *xdr, struct compound_hdr *hdr)
3186 {
3187     ssize_t ret;
3188     void *ptr;
3189     u32 tmp;
3190
3191     if (xdr_stream_decode_u32(xdr, &tmp) < 0)
3192         return -EIO;
3193     hdr->status = tmp;
3194
3195     ret = xdr_stream_decode_opaque_inline(xdr, &ptr, NFS4_OPAQUE_LIMIT);
3196     if (ret < 0)
3197         return -EIO;
3198     hdr->taglen = ret;
3199     hdr->tag = ptr;
3200
3201     if (xdr_stream_decode_u32(xdr, &tmp) < 0)
3202         return -EIO;
3203     hdr->nops = tmp;
3204     if (unlikely(hdr->nops < 1))
3205         return nfs4_stat_to_errno(hdr->status);
3206     return 0;
3207 }
3208
3209 static bool __decode_op_hdr(struct xdr_stream *xdr, enum nfs_opnum4 expected,
3210         int *nfs_retval)
3211 {
3212     __be32 *p;
3213     uint32_t opnum;
3214     int32_t nfserr;
3215
3216     p = xdr_inline_decode(xdr, 8);
3217     if (unlikely(!p))
3218         goto out_overflow;
3219     opnum = be32_to_cpup(p++);
3220     if (unlikely(opnum != expected))
3221         goto out_bad_operation;
3222     if (unlikely(*p != cpu_to_be32(NFS_OK)))
3223         goto out_status;
3224     *nfs_retval = 0;
3225     return true;
3226 out_status:
3227     nfserr = be32_to_cpup(p);
3228     trace_nfs4_xdr_status(xdr, opnum, nfserr);
3229     *nfs_retval = nfs4_stat_to_errno(nfserr);
3230     return true;
3231 out_bad_operation:
3232     trace_nfs4_xdr_bad_operation(xdr, opnum, expected);
3233     *nfs_retval = -EREMOTEIO;
3234     return false;
3235 out_overflow:
3236     *nfs_retval = -EIO;
3237     return false;
3238 }
3239
3240 static int decode_op_hdr(struct xdr_stream *xdr, enum nfs_opnum4 expected)
3241 {
3242     int retval;
3243
3244     __decode_op_hdr(xdr, expected, &retval);
3245     return retval;
3246 }
3247
3248 /* Dummy routine */
3249 static int decode_ace(struct xdr_stream *xdr, void *ace)
3250 {
3251     __be32 *p;
3252     unsigned int strlen;
3253     char *str;
3254
3255     p = xdr_inline_decode(xdr, 12);
3256     if (unlikely(!p))
3257         return -EIO;
3258     return decode_opaque_inline(xdr, &strlen, &str);
3259 }
3260
3261 static ssize_t
3262 decode_bitmap4(struct xdr_stream *xdr, uint32_t *bitmap, size_t sz)
3263 {
3264     ssize_t ret;
3265
3266     ret = xdr_stream_decode_uint32_array(xdr, bitmap, sz);
3267     if (likely(ret >= 0))
3268         return ret;
3269     if (ret != -EMSGSIZE)
3270         return -EIO;
3271     return sz;
3272 }
3273
3274 static int decode_attr_bitmap(struct xdr_stream *xdr, uint32_t *bitmap)
3275 {
3276     ssize_t ret;
3277     ret = decode_bitmap4(xdr, bitmap, 3);
3278     return ret < 0 ? ret : 0;
3279 }
3280
3281 static int decode_attr_length(struct xdr_stream *xdr, uint32_t *attrlen, unsigned int *savep)
3282 {
3283     __be32 *p;
3284
3285     p = xdr_inline_decode(xdr, 4);
3286     if (unlikely(!p))
3287         return -EIO;
3288     *attrlen = be32_to_cpup(p);
3289     *savep = xdr_stream_pos(xdr);
3290     return 0;
3291 }
3292
3293 static int decode_attr_supported(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *bitmask)
3294 {
3295     if (likely(bitmap[0] & FATTR4_WORD0_SUPPORTED_ATTRS)) {
3296         int ret;
3297         ret = decode_attr_bitmap(xdr, bitmask);
3298         if (unlikely(ret < 0))
3299             return ret;
3300         bitmap[0] &= ~FATTR4_WORD0_SUPPORTED_ATTRS;
3301     } else
3302         bitmask[0] = bitmask[1] = bitmask[2] = 0;
3303     dprintk("%s: bitmask=%08x:%08x:%08x\n", __func__,
3304         bitmask[0], bitmask[1], bitmask[2]);
3305     return 0;
3306 }
3307
3308 static int decode_attr_type(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *type)
3309 {
3310     __be32 *p;
3311     int ret = 0;
3312
3313     *type = 0;
3314     if (unlikely(bitmap[0] & (FATTR4_WORD0_TYPE - 1U)))
3315         return -EIO;
3316     if (likely(bitmap[0] & FATTR4_WORD0_TYPE)) {
3317         p = xdr_inline_decode(xdr, 4);
3318         if (unlikely(!p))
3319             return -EIO;
3320         *type = be32_to_cpup(p);
3321         if (*type < NF4REG || *type > NF4NAMEDATTR) {
3322             dprintk("%s: bad type %d\n", __func__, *type);
3323             return -EIO;
3324         }
3325         bitmap[0] &= ~FATTR4_WORD0_TYPE;
3326         ret = NFS_ATTR_FATTR_TYPE;
3327     }
3328     dprintk("%s: type=0%o\n", __func__, nfs_type2fmt[*type]);
3329     return ret;
3330 }
3331
3332 static int decode_attr_fh_expire_type(struct xdr_stream *xdr,
3333                       uint32_t *bitmap, uint32_t *type)
3334 {
3335     __be32 *p;
3336
3337     *type = 0;
3338     if (unlikely(bitmap[0] & (FATTR4_WORD0_FH_EXPIRE_TYPE - 1U)))
3339         return -EIO;
3340     if (likely(bitmap[0] & FATTR4_WORD0_FH_EXPIRE_TYPE)) {
3341         p = xdr_inline_decode(xdr, 4);
3342         if (unlikely(!p))
3343             return -EIO;
3344         *type = be32_to_cpup(p);
3345         bitmap[0] &= ~FATTR4_WORD0_FH_EXPIRE_TYPE;
3346     }
3347     dprintk("%s: expire type=0x%x\n", __func__, *type);
3348     return 0;
3349 }
3350
3351 static int decode_attr_change(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *change)
3352 {
3353     __be32 *p;
3354     int ret = 0;
3355
3356     *change = 0;
3357     if (unlikely(bitmap[0] & (FATTR4_WORD0_CHANGE - 1U)))
3358         return -EIO;
3359     if (likely(bitmap[0] & FATTR4_WORD0_CHANGE)) {
3360         p = xdr_inline_decode(xdr, 8);
3361         if (unlikely(!p))
3362             return -EIO;
3363         xdr_decode_hyper(p, change);
3364         bitmap[0] &= ~FATTR4_WORD0_CHANGE;
3365         ret = NFS_ATTR_FATTR_CHANGE;
3366     }
3367     dprintk("%s: change attribute=%Lu\n", __func__,
3368             (unsigned long long)*change);
3369     return ret;
3370 }
3371
3372 static int decode_attr_size(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *size)
3373 {
3374     __be32 *p;
3375     int ret = 0;
3376
3377     *size = 0;
3378     if (unlikely(bitmap[0] & (FATTR4_WORD0_SIZE - 1U)))
3379         return -EIO;
3380     if (likely(bitmap[0] & FATTR4_WORD0_SIZE)) {
3381         p = xdr_inline_decode(xdr, 8);
3382         if (unlikely(!p))
3383             return -EIO;
3384         xdr_decode_hyper(p, size);
3385         bitmap[0] &= ~FATTR4_WORD0_SIZE;
3386         ret = NFS_ATTR_FATTR_SIZE;
3387     }
3388     dprintk("%s: file size=%Lu\n", __func__, (unsigned long long)*size);
3389     return ret;
3390 }
3391
3392 static int decode_attr_link_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
3393 {
3394     __be32 *p;
3395
3396     *res = 0;
3397     if (unlikely(bitmap[0] & (FATTR4_WORD0_LINK_SUPPORT - 1U)))
3398         return -EIO;
3399     if (likely(bitmap[0] & FATTR4_WORD0_LINK_SUPPORT)) {
3400         p = xdr_inline_decode(xdr, 4);
3401         if (unlikely(!p))
3402             return -EIO;
3403         *res = be32_to_cpup(p);
3404         bitmap[0] &= ~FATTR4_WORD0_LINK_SUPPORT;
3405     }
3406     dprintk("%s: link support=%s\n", __func__, *res == 0 ? "false" : "true");
3407     return 0;
3408 }
3409
3410 static int decode_attr_symlink_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
3411 {
3412     __be32 *p;
3413
3414     *res = 0;
3415     if (unlikely(bitmap[0] & (FATTR4_WORD0_SYMLINK_SUPPORT - 1U)))
3416         return -EIO;
3417     if (likely(bitmap[0] & FATTR4_WORD0_SYMLINK_SUPPORT)) {
3418         p = xdr_inline_decode(xdr, 4);
3419         if (unlikely(!p))
3420             return -EIO;
3421         *res = be32_to_cpup(p);
3422         bitmap[0] &= ~FATTR4_WORD0_SYMLINK_SUPPORT;
3423     }
3424     dprintk("%s: symlink support=%s\n", __func__, *res == 0 ? "false" : "true");
3425     return 0;
3426 }
3427
3428 static int decode_attr_fsid(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_fsid *fsid)
3429 {
3430     __be32 *p;
3431     int ret = 0;
3432
3433     fsid->major = 0;
3434     fsid->minor = 0;
3435     if (unlikely(bitmap[0] & (FATTR4_WORD0_FSID - 1U)))
3436         return -EIO;
3437     if (likely(bitmap[0] & FATTR4_WORD0_FSID)) {
3438         p = xdr_inline_decode(xdr, 16);
3439         if (unlikely(!p))
3440             return -EIO;
3441         p = xdr_decode_hyper(p, &fsid->major);
3442         xdr_decode_hyper(p, &fsid->minor);
3443         bitmap[0] &= ~FATTR4_WORD0_FSID;
3444         ret = NFS_ATTR_FATTR_FSID;
3445     }
3446     dprintk("%s: fsid=(0x%Lx/0x%Lx)\n", __func__,
3447             (unsigned long long)fsid->major,
3448             (unsigned long long)fsid->minor);
3449     return ret;
3450 }
3451
3452 static int decode_attr_lease_time(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
3453 {
3454     __be32 *p;
3455
3456     *res = 60;
3457     if (unlikely(bitmap[0] & (FATTR4_WORD0_LEASE_TIME - 1U)))
3458         return -EIO;
3459     if (likely(bitmap[0] & FATTR4_WORD0_LEASE_TIME)) {
3460         p = xdr_inline_decode(xdr, 4);
3461         if (unlikely(!p))
3462             return -EIO;
3463         *res = be32_to_cpup(p);
3464         bitmap[0] &= ~FATTR4_WORD0_LEASE_TIME;
3465     }
3466     dprintk("%s: lease time=%u\n", __func__, (unsigned int)*res);
3467     return 0;
3468 }
3469
3470 static int decode_attr_error(struct xdr_stream *xdr, uint32_t *bitmap, int32_t *res)
3471 {
3472     __be32 *p;
3473
3474     if (unlikely(bitmap[0] & (FATTR4_WORD0_RDATTR_ERROR - 1U)))
3475         return -EIO;
3476     if (likely(bitmap[0] & FATTR4_WORD0_RDATTR_ERROR)) {
3477         p = xdr_inline_decode(xdr, 4);
3478         if (unlikely(!p))
3479             return -EIO;
3480         bitmap[0] &= ~FATTR4_WORD0_RDATTR_ERROR;
3481         *res = -be32_to_cpup(p);
3482     }
3483     return 0;
3484 }
3485
3486 static int decode_attr_exclcreat_supported(struct xdr_stream *xdr,
3487                  uint32_t *bitmap, uint32_t *bitmask)
3488 {
3489     if (likely(bitmap[2] & FATTR4_WORD2_SUPPATTR_EXCLCREAT)) {
3490         int ret;
3491         ret = decode_attr_bitmap(xdr, bitmask);
3492         if (unlikely(ret < 0))
3493             return ret;
3494         bitmap[2] &= ~FATTR4_WORD2_SUPPATTR_EXCLCREAT;
3495     } else
3496         bitmask[0] = bitmask[1] = bitmask[2] = 0;
3497     dprintk("%s: bitmask=%08x:%08x:%08x\n", __func__,
3498         bitmask[0], bitmask[1], bitmask[2]);
3499     return 0;
3500 }
3501
3502 static int decode_attr_filehandle(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_fh *fh)
3503 {
3504     __be32 *p;
3505     u32 len;
3506
3507     if (fh != NULL)
3508         memset(fh, 0, sizeof(*fh));
3509
3510     if (unlikely(bitmap[0] & (FATTR4_WORD0_FILEHANDLE - 1U)))
3511         return -EIO;
3512     if (likely(bitmap[0] & FATTR4_WORD0_FILEHANDLE)) {
3513         p = xdr_inline_decode(xdr, 4);
3514         if (unlikely(!p))
3515             return -EIO;
3516         len = be32_to_cpup(p);
3517         if (len > NFS4_FHSIZE || len == 0) {
3518             trace_nfs4_xdr_bad_filehandle(xdr, OP_READDIR,
3519                               NFS4ERR_BADHANDLE);
3520             return -EREMOTEIO;
3521         }
3522         p = xdr_inline_decode(xdr, len);
3523         if (unlikely(!p))
3524             return -EIO;
3525         if (fh != NULL) {
3526             memcpy(fh->data, p, len);
3527             fh->size = len;
3528         }
3529         bitmap[0] &= ~FATTR4_WORD0_FILEHANDLE;
3530     }
3531     return 0;
3532 }
3533
3534 static int decode_attr_aclsupport(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
3535 {
3536     __be32 *p;
3537
3538     *res = 0;
3539     if (unlikely(bitmap[0] & (FATTR4_WORD0_ACLSUPPORT - 1U)))
3540         return -EIO;
3541     if (likely(bitmap[0] & FATTR4_WORD0_ACLSUPPORT)) {
3542         p = xdr_inline_decode(xdr, 4);
3543         if (unlikely(!p))
3544             return -EIO;
3545         *res = be32_to_cpup(p);
3546         bitmap[0] &= ~FATTR4_WORD0_ACLSUPPORT;
3547     }
3548     dprintk("%s: ACLs supported=%u\n", __func__, (unsigned int)*res);
3549     return 0;
3550 }
3551
3552 static int decode_attr_case_insensitive(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
3553 {
3554     __be32 *p;
3555
3556     *res = 0;
3557     if (unlikely(bitmap[0] & (FATTR4_WORD0_CASE_INSENSITIVE - 1U)))
3558         return -EIO;
3559     if (likely(bitmap[0] & FATTR4_WORD0_CASE_INSENSITIVE)) {
3560         p = xdr_inline_decode(xdr, 4);
3561         if (unlikely(!p))
3562             return -EIO;
3563         *res = be32_to_cpup(p);
3564         bitmap[0] &= ~FATTR4_WORD0_CASE_INSENSITIVE;
3565     }
3566     dprintk("%s: case_insensitive=%s\n", __func__, *res == 0 ? "false" : "true");
3567     return 0;
3568 }
3569
3570 static int decode_attr_case_preserving(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
3571 {
3572     __be32 *p;
3573
3574     *res = 0;
3575     if (unlikely(bitmap[0] & (FATTR4_WORD0_CASE_PRESERVING - 1U)))
3576         return -EIO;
3577     if (likely(bitmap[0] & FATTR4_WORD0_CASE_PRESERVING)) {
3578         p = xdr_inline_decode(xdr, 4);
3579         if (unlikely(!p))
3580             return -EIO;
3581         *res = be32_to_cpup(p);
3582         bitmap[0] &= ~FATTR4_WORD0_CASE_PRESERVING;
3583     }
3584     dprintk("%s: case_preserving=%s\n", __func__, *res == 0 ? "false" : "true");
3585     return 0;
3586 }
3587
3588 static int decode_attr_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *fileid)
3589 {
3590     __be32 *p;
3591     int ret = 0;
3592
3593     *fileid = 0;
3594     if (unlikely(bitmap[0] & (FATTR4_WORD0_FILEID - 1U)))
3595         return -EIO;
3596     if (likely(bitmap[0] & FATTR4_WORD0_FILEID)) {
3597         p = xdr_inline_decode(xdr, 8);
3598         if (unlikely(!p))
3599             return -EIO;
3600         xdr_decode_hyper(p, fileid);
3601         bitmap[0] &= ~FATTR4_WORD0_FILEID;
3602         ret = NFS_ATTR_FATTR_FILEID;
3603     }
3604     dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid);
3605     return ret;
3606 }
3607
3608 static int decode_attr_mounted_on_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *fileid)
3609 {
3610     __be32 *p;
3611     int ret = 0;
3612
3613     *fileid = 0;
3614     if (unlikely(bitmap[1] & (FATTR4_WORD1_MOUNTED_ON_FILEID - 1U)))
3615         return -EIO;
3616     if (likely(bitmap[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)) {
3617         p = xdr_inline_decode(xdr, 8);
3618         if (unlikely(!p))
3619             return -EIO;
3620         xdr_decode_hyper(p, fileid);
3621         bitmap[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID;
3622         ret = NFS_ATTR_FATTR_MOUNTED_ON_FILEID;
3623     }
3624     dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid);
3625     return ret;
3626 }
3627
3628 static int decode_attr_files_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
3629 {
3630     __be32 *p;
3631     int status = 0;
3632
3633     *res = 0;
3634     if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_AVAIL - 1U)))
3635         return -EIO;
3636     if (likely(bitmap[0] & FATTR4_WORD0_FILES_AVAIL)) {
3637         p = xdr_inline_decode(xdr, 8);
3638         if (unlikely(!p))
3639             return -EIO;
3640         xdr_decode_hyper(p, res);
3641         bitmap[0] &= ~FATTR4_WORD0_FILES_AVAIL;
3642     }
3643     dprintk("%s: files avail=%Lu\n", __func__, (unsigned long long)*res);
3644     return status;
3645 }
3646
3647 static int decode_attr_files_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
3648 {
3649     __be32 *p;
3650     int status = 0;
3651
3652     *res = 0;
3653     if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_FREE - 1U)))
3654         return -EIO;
3655     if (likely(bitmap[0] & FATTR4_WORD0_FILES_FREE)) {
3656         p = xdr_inline_decode(xdr, 8);
3657         if (unlikely(!p))
3658             return -EIO;
3659         xdr_decode_hyper(p, res);
3660         bitmap[0] &= ~FATTR4_WORD0_FILES_FREE;
3661     }
3662     dprintk("%s: files free=%Lu\n", __func__, (unsigned long long)*res);
3663     return status;
3664 }
3665
3666 static int decode_attr_files_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
3667 {
3668     __be32 *p;
3669     int status = 0;
3670
3671     *res = 0;
3672     if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_TOTAL - 1U)))
3673         return -EIO;
3674     if (likely(bitmap[0] & FATTR4_WORD0_FILES_TOTAL)) {
3675         p = xdr_inline_decode(xdr, 8);
3676         if (unlikely(!p))
3677             return -EIO;
3678         xdr_decode_hyper(p, res);
3679         bitmap[0] &= ~FATTR4_WORD0_FILES_TOTAL;
3680     }
3681     dprintk("%s: files total=%Lu\n", __func__, (unsigned long long)*res);
3682     return status;
3683 }
3684
3685 static int decode_pathname(struct xdr_stream *xdr, struct nfs4_pathname *path)
3686 {
3687     u32 n;
3688     __be32 *p;
3689     int status = 0;
3690
3691     p = xdr_inline_decode(xdr, 4);
3692     if (unlikely(!p))
3693         return -EIO;
3694     n = be32_to_cpup(p);
3695     if (n == 0)
3696         goto root_path;
3697     dprintk("pathname4: ");
3698     if (n > NFS4_PATHNAME_MAXCOMPONENTS) {
3699         dprintk("cannot parse %d components in path\n", n);
3700         goto out_eio;
3701     }
3702     for (path->ncomponents = 0; path->ncomponents < n; path->ncomponents++) {
3703         struct nfs4_string *component = &path->components[path->ncomponents];
3704         status = decode_opaque_inline(xdr, &component->len, &component->data);
3705         if (unlikely(status != 0))
3706             goto out_eio;
3707         ifdebug (XDR)
3708             pr_cont("%s%.*s ",
3709                 (path->ncomponents != n ? "/ " : ""),
3710                 component->len, component->data);
3711     }
3712 out:
3713     return status;
3714 root_path:
3715 /* a root pathname is sent as a zero component4 */
3716     path->ncomponents = 1;
3717     path->components[0].len=0;
3718     path->components[0].data=NULL;
3719     dprintk("pathname4: /\n");
3720     goto out;
3721 out_eio:
3722     dprintk(" status %d", status);
3723     status = -EIO;
3724     goto out;
3725 }
3726
3727 static int decode_attr_fs_locations(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs4_fs_locations *res)
3728 {
3729     int n;
3730     __be32 *p;
3731     int status = -EIO;
3732
3733     if (unlikely(bitmap[0] & (FATTR4_WORD0_FS_LOCATIONS -1U)))
3734         goto out;
3735     status = 0;
3736     if (unlikely(!(bitmap[0] & FATTR4_WORD0_FS_LOCATIONS)))
3737         goto out;
3738     bitmap[0] &= ~FATTR4_WORD0_FS_LOCATIONS;
3739     status = -EIO;
3740     /* Ignore borken servers that return unrequested attrs */
3741     if (unlikely(res == NULL))
3742         goto out;
3743     dprintk("%s: fsroot:\n", __func__);
3744     status = decode_pathname(xdr, &res->fs_path);
3745     if (unlikely(status != 0))
3746         goto out;
3747     p = xdr_inline_decode(xdr, 4);
3748     if (unlikely(!p))
3749         goto out_eio;
3750     n = be32_to_cpup(p);
3751     for (res->nlocations = 0; res->nlocations < n; res->nlocations++) {
3752         u32 m;
3753         struct nfs4_fs_location *loc;
3754
3755         if (res->nlocations == NFS4_FS_LOCATIONS_MAXENTRIES)
3756             break;
3757         loc = &res->locations[res->nlocations];
3758         p = xdr_inline_decode(xdr, 4);
3759         if (unlikely(!p))
3760             goto out_eio;
3761         m = be32_to_cpup(p);
3762
3763         dprintk("%s: servers:\n", __func__);
3764         for (loc->nservers = 0; loc->nservers < m; loc->nservers++) {
3765             struct nfs4_string *server;
3766
3767             if (loc->nservers == NFS4_FS_LOCATION_MAXSERVERS) {
3768                 unsigned int i;
3769                 dprintk("%s: using first %u of %u servers "
3770                     "returned for location %u\n",
3771                         __func__,
3772                         NFS4_FS_LOCATION_MAXSERVERS,
3773                         m, res->nlocations);
3774                 for (i = loc->nservers; i < m; i++) {
3775                     unsigned int len;
3776                     char *data;
3777                     status = decode_opaque_inline(xdr, &len, &data);
3778                     if (unlikely(status != 0))
3779                         goto out_eio;
3780                 }
3781                 break;
3782             }
3783             server = &loc->servers[loc->nservers];
3784             status = decode_opaque_inline(xdr, &server->len, &server->data);
3785             if (unlikely(status != 0))
3786                 goto out_eio;
3787             dprintk("%s ", server->data);
3788         }
3789         status = decode_pathname(xdr, &loc->rootpath);
3790         if (unlikely(status != 0))
3791             goto out_eio;
3792     }
3793     if (res->nlocations != 0)
3794         status = NFS_ATTR_FATTR_V4_LOCATIONS;
3795 out:
3796     dprintk("%s: fs_locations done, error = %d\n", __func__, status);
3797     return status;
3798 out_eio:
3799     status = -EIO;
3800     goto out;
3801 }
3802
3803 static int decode_attr_maxfilesize(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
3804 {
3805     __be32 *p;
3806     int status = 0;
3807
3808     *res = 0;
3809     if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXFILESIZE - 1U)))
3810         return -EIO;
3811     if (likely(bitmap[0] & FATTR4_WORD0_MAXFILESIZE)) {
3812         p = xdr_inline_decode(xdr, 8);
3813         if (unlikely(!p))
3814             return -EIO;
3815         xdr_decode_hyper(p, res);
3816         bitmap[0] &= ~FATTR4_WORD0_MAXFILESIZE;
3817     }
3818     dprintk("%s: maxfilesize=%Lu\n", __func__, (unsigned long long)*res);
3819     return status;
3820 }
3821
3822 static int decode_attr_maxlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *maxlink)
3823 {
3824     __be32 *p;
3825     int status = 0;
3826
3827     *maxlink = 1;
3828     if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXLINK - 1U)))
3829         return -EIO;
3830     if (likely(bitmap[0] & FATTR4_WORD0_MAXLINK)) {
3831         p = xdr_inline_decode(xdr, 4);
3832         if (unlikely(!p))
3833             return -EIO;
3834         *maxlink = be32_to_cpup(p);
3835         bitmap[0] &= ~FATTR4_WORD0_MAXLINK;
3836     }
3837     dprintk("%s: maxlink=%u\n", __func__, *maxlink);
3838     return status;
3839 }
3840
3841 static int decode_attr_maxname(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *maxname)
3842 {
3843     __be32 *p;
3844     int status = 0;
3845
3846     *maxname = 1024;
3847     if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXNAME - 1U)))
3848         return -EIO;
3849     if (likely(bitmap[0] & FATTR4_WORD0_MAXNAME)) {
3850         p = xdr_inline_decode(xdr, 4);
3851         if (unlikely(!p))
3852             return -EIO;
3853         *maxname = be32_to_cpup(p);
3854         bitmap[0] &= ~FATTR4_WORD0_MAXNAME;
3855     }
3856     dprintk("%s: maxname=%u\n", __func__, *maxname);
3857     return status;
3858 }
3859
3860 static int decode_attr_maxread(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
3861 {
3862     __be32 *p;
3863     int status = 0;
3864
3865     *res = 1024;
3866     if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXREAD - 1U)))
3867         return -EIO;
3868     if (likely(bitmap[0] & FATTR4_WORD0_MAXREAD)) {
3869         uint64_t maxread;
3870         p = xdr_inline_decode(xdr, 8);
3871         if (unlikely(!p))
3872             return -EIO;
3873         xdr_decode_hyper(p, &maxread);
3874         if (maxread > 0x7FFFFFFF)
3875             maxread = 0x7FFFFFFF;
3876         *res = (uint32_t)maxread;
3877         bitmap[0] &= ~FATTR4_WORD0_MAXREAD;
3878     }
3879     dprintk("%s: maxread=%lu\n", __func__, (unsigned long)*res);
3880     return status;
3881 }
3882
3883 static int decode_attr_maxwrite(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
3884 {
3885     __be32 *p;
3886     int status = 0;
3887
3888     *res = 1024;
3889     if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXWRITE - 1U)))
3890         return -EIO;
3891     if (likely(bitmap[0] & FATTR4_WORD0_MAXWRITE)) {
3892         uint64_t maxwrite;
3893         p = xdr_inline_decode(xdr, 8);
3894         if (unlikely(!p))
3895             return -EIO;
3896         xdr_decode_hyper(p, &maxwrite);
3897         if (maxwrite > 0x7FFFFFFF)
3898             maxwrite = 0x7FFFFFFF;
3899         *res = (uint32_t)maxwrite;
3900         bitmap[0] &= ~FATTR4_WORD0_MAXWRITE;
3901     }
3902     dprintk("%s: maxwrite=%lu\n", __func__, (unsigned long)*res);
3903     return status;
3904 }
3905
3906 static int decode_attr_mode(struct xdr_stream *xdr, uint32_t *bitmap, umode_t *mode)
3907 {
3908     uint32_t tmp;
3909     __be32 *p;
3910     int ret = 0;
3911
3912     *mode = 0;
3913     if (unlikely(bitmap[1] & (FATTR4_WORD1_MODE - 1U)))
3914         return -EIO;
3915     if (likely(bitmap[1] & FATTR4_WORD1_MODE)) {
3916         p = xdr_inline_decode(xdr, 4);
3917         if (unlikely(!p))
3918             return -EIO;
3919         tmp = be32_to_cpup(p);
3920         *mode = tmp & ~S_IFMT;
3921         bitmap[1] &= ~FATTR4_WORD1_MODE;
3922         ret = NFS_ATTR_FATTR_MODE;
3923     }
3924     dprintk("%s: file mode=0%o\n", __func__, (unsigned int)*mode);
3925     return ret;
3926 }
3927
3928 static int decode_attr_nlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *nlink)
3929 {
3930     __be32 *p;
3931     int ret = 0;
3932
3933     *nlink = 1;
3934     if (unlikely(bitmap[1] & (FATTR4_WORD1_NUMLINKS - 1U)))
3935         return -EIO;
3936     if (likely(bitmap[1] & FATTR4_WORD1_NUMLINKS)) {
3937         p = xdr_inline_decode(xdr, 4);
3938         if (unlikely(!p))
3939             return -EIO;
3940         *nlink = be32_to_cpup(p);
3941         bitmap[1] &= ~FATTR4_WORD1_NUMLINKS;
3942         ret = NFS_ATTR_FATTR_NLINK;
3943     }
3944     dprintk("%s: nlink=%u\n", __func__, (unsigned int)*nlink);
3945     return ret;
3946 }
3947
3948 static ssize_t decode_nfs4_string(struct xdr_stream *xdr,
3949         struct nfs4_string *name, gfp_t gfp_flags)
3950 {
3951     ssize_t ret;
3952
3953     ret = xdr_stream_decode_string_dup(xdr, &name->data,
3954             XDR_MAX_NETOBJ, gfp_flags);
3955     name->len = 0;
3956     if (ret > 0)
3957         name->len = ret;
3958     return ret;
3959 }
3960
3961 static int decode_attr_owner(struct xdr_stream *xdr, uint32_t *bitmap,
3962         const struct nfs_server *server, kuid_t *uid,
3963         struct nfs4_string *owner_name)
3964 {
3965     ssize_t len;
3966     char *p;
3967
3968     *uid = make_kuid(&init_user_ns, -2);
3969     if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER - 1U)))
3970         return -EIO;
3971     if (!(bitmap[1] & FATTR4_WORD1_OWNER))
3972         return 0;
3973     bitmap[1] &= ~FATTR4_WORD1_OWNER;
3974
3975     if (owner_name != NULL) {
3976         len = decode_nfs4_string(xdr, owner_name, GFP_NOIO);
3977         if (len <= 0)
3978             goto out;
3979         dprintk("%s: name=%s\n", __func__, owner_name->data);
3980         return NFS_ATTR_FATTR_OWNER_NAME;
3981     } else {
3982         len = xdr_stream_decode_opaque_inline(xdr, (void **)&p,
3983                 XDR_MAX_NETOBJ);
3984         if (len <= 0 || nfs_map_name_to_uid(server, p, len, uid) != 0)
3985             goto out;
3986         dprintk("%s: uid=%d\n", __func__, (int)from_kuid(&init_user_ns, *uid));
3987         return NFS_ATTR_FATTR_OWNER;
3988     }
3989 out:
3990     if (len == -EBADMSG)
3991         return -EIO;
3992     return 0;
3993 }
3994
3995 static int decode_attr_group(struct xdr_stream *xdr, uint32_t *bitmap,
3996         const struct nfs_server *server, kgid_t *gid,
3997         struct nfs4_string *group_name)
3998 {
3999     ssize_t len;
4000     char *p;
4001
4002     *gid = make_kgid(&init_user_ns, -2);
4003     if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER_GROUP - 1U)))
4004         return -EIO;
4005     if (!(bitmap[1] & FATTR4_WORD1_OWNER_GROUP))
4006         return 0;
4007     bitmap[1] &= ~FATTR4_WORD1_OWNER_GROUP;
4008
4009     if (group_name != NULL) {
4010         len = decode_nfs4_string(xdr, group_name, GFP_NOIO);
4011         if (len <= 0)
4012             goto out;
4013         dprintk("%s: name=%s\n", __func__, group_name->data);
4014         return NFS_ATTR_FATTR_GROUP_NAME;
4015     } else {
4016         len = xdr_stream_decode_opaque_inline(xdr, (void **)&p,
4017                 XDR_MAX_NETOBJ);
4018         if (len <= 0 || nfs_map_group_to_gid(server, p, len, gid) != 0)
4019             goto out;
4020         dprintk("%s: gid=%d\n", __func__, (int)from_kgid(&init_user_ns, *gid));
4021         return NFS_ATTR_FATTR_GROUP;
4022     }
4023 out:
4024     if (len == -EBADMSG)
4025         return -EIO;
4026     return 0;
4027 }
4028
4029 static int decode_attr_rdev(struct xdr_stream *xdr, uint32_t *bitmap, dev_t *rdev)
4030 {
4031     uint32_t major = 0, minor = 0;
4032     __be32 *p;
4033     int ret = 0;
4034
4035     *rdev = MKDEV(0,0);
4036     if (unlikely(bitmap[1] & (FATTR4_WORD1_RAWDEV - 1U)))
4037         return -EIO;
4038     if (likely(bitmap[1] & FATTR4_WORD1_RAWDEV)) {
4039         dev_t tmp;
4040
4041         p = xdr_inline_decode(xdr, 8);
4042         if (unlikely(!p))
4043             return -EIO;
4044         major = be32_to_cpup(p++);
4045         minor = be32_to_cpup(p);
4046         tmp = MKDEV(major, minor);
4047         if (MAJOR(tmp) == major && MINOR(tmp) == minor)
4048             *rdev = tmp;
4049         bitmap[1] &= ~ FATTR4_WORD1_RAWDEV;
4050         ret = NFS_ATTR_FATTR_RDEV;
4051     }
4052     dprintk("%s: rdev=(0x%x:0x%x)\n", __func__, major, minor);
4053     return ret;
4054 }
4055
4056 static int decode_attr_space_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
4057 {
4058     __be32 *p;
4059     int status = 0;
4060
4061     *res = 0;
4062     if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_AVAIL - 1U)))
4063         return -EIO;
4064     if (likely(bitmap[1] & FATTR4_WORD1_SPACE_AVAIL)) {
4065         p = xdr_inline_decode(xdr, 8);
4066         if (unlikely(!p))
4067             return -EIO;
4068         xdr_decode_hyper(p, res);
4069         bitmap[1] &= ~FATTR4_WORD1_SPACE_AVAIL;
4070     }
4071     dprintk("%s: space avail=%Lu\n", __func__, (unsigned long long)*res);
4072     return status;
4073 }
4074
4075 static int decode_attr_space_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
4076 {
4077     __be32 *p;
4078     int status = 0;
4079
4080     *res = 0;
4081     if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_FREE - 1U)))
4082         return -EIO;
4083     if (likely(bitmap[1] & FATTR4_WORD1_SPACE_FREE)) {
4084         p = xdr_inline_decode(xdr, 8);
4085         if (unlikely(!p))
4086             return -EIO;
4087         xdr_decode_hyper(p, res);
4088         bitmap[1] &= ~FATTR4_WORD1_SPACE_FREE;
4089     }
4090     dprintk("%s: space free=%Lu\n", __func__, (unsigned long long)*res);
4091     return status;
4092 }
4093
4094 static int decode_attr_space_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
4095 {
4096     __be32 *p;
4097     int status = 0;
4098
4099     *res = 0;
4100     if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_TOTAL - 1U)))
4101         return -EIO;
4102     if (likely(bitmap[1] & FATTR4_WORD1_SPACE_TOTAL)) {
4103         p = xdr_inline_decode(xdr, 8);
4104         if (unlikely(!p))
4105             return -EIO;
4106         xdr_decode_hyper(p, res);
4107         bitmap[1] &= ~FATTR4_WORD1_SPACE_TOTAL;
4108     }
4109     dprintk("%s: space total=%Lu\n", __func__, (unsigned long long)*res);
4110     return status;
4111 }
4112
4113 static int decode_attr_space_used(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *used)
4114 {
4115     __be32 *p;
4116     int ret = 0;
4117
4118     *used = 0;
4119     if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_USED - 1U)))
4120         return -EIO;
4121     if (likely(bitmap[1] & FATTR4_WORD1_SPACE_USED)) {
4122         p = xdr_inline_decode(xdr, 8);
4123         if (unlikely(!p))
4124             return -EIO;
4125         xdr_decode_hyper(p, used);
4126         bitmap[1] &= ~FATTR4_WORD1_SPACE_USED;
4127         ret = NFS_ATTR_FATTR_SPACE_USED;
4128     }
4129     dprintk("%s: space used=%Lu\n", __func__,
4130             (unsigned long long)*used);
4131     return ret;
4132 }
4133
4134 static __be32 *
4135 xdr_decode_nfstime4(__be32 *p, struct timespec64 *t)
4136 {
4137     __u64 sec;
4138
4139     p = xdr_decode_hyper(p, &sec);
4140     t-> tv_sec = sec;
4141     t->tv_nsec = be32_to_cpup(p++);
4142     return p;
4143 }
4144
4145 static int decode_attr_time(struct xdr_stream *xdr, struct timespec64 *time)
4146 {
4147     __be32 *p;
4148
4149     p = xdr_inline_decode(xdr, nfstime4_maxsz << 2);
4150     if (unlikely(!p))
4151         return -EIO;
4152     xdr_decode_nfstime4(p, time);
4153     return 0;
4154 }
4155
4156 static int decode_attr_time_access(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec64 *time)
4157 {
4158     int status = 0;
4159
4160     time->tv_sec = 0;
4161     time->tv_nsec = 0;
4162     if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_ACCESS - 1U)))
4163         return -EIO;
4164     if (likely(bitmap[1] & FATTR4_WORD1_TIME_ACCESS)) {
4165         status = decode_attr_time(xdr, time);
4166         if (status == 0)
4167             status = NFS_ATTR_FATTR_ATIME;
4168         bitmap[1] &= ~FATTR4_WORD1_TIME_ACCESS;
4169     }
4170     dprintk("%s: atime=%lld\n", __func__, time->tv_sec);
4171     return status;
4172 }
4173
4174 static int decode_attr_time_metadata(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec64 *time)
4175 {
4176     int status = 0;
4177
4178     time->tv_sec = 0;
4179     time->tv_nsec = 0;
4180     if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_METADATA - 1U)))
4181         return -EIO;
4182     if (likely(bitmap[1] & FATTR4_WORD1_TIME_METADATA)) {
4183         status = decode_attr_time(xdr, time);
4184         if (status == 0)
4185             status = NFS_ATTR_FATTR_CTIME;
4186         bitmap[1] &= ~FATTR4_WORD1_TIME_METADATA;
4187     }
4188     dprintk("%s: ctime=%lld\n", __func__, time->tv_sec);
4189     return status;
4190 }
4191
4192 static int decode_attr_time_delta(struct xdr_stream *xdr, uint32_t *bitmap,
4193                   struct timespec64 *time)
4194 {
4195     int status = 0;
4196
4197     time->tv_sec = 0;
4198     time->tv_nsec = 0;
4199     if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_DELTA - 1U)))
4200         return -EIO;
4201     if (likely(bitmap[1] & FATTR4_WORD1_TIME_DELTA)) {
4202         status = decode_attr_time(xdr, time);
4203         bitmap[1] &= ~FATTR4_WORD1_TIME_DELTA;
4204     }
4205     dprintk("%s: time_delta=%lld %ld\n", __func__, time->tv_sec,
4206         time->tv_nsec);
4207     return status;
4208 }
4209
4210 static int decode_attr_security_label(struct xdr_stream *xdr, uint32_t *bitmap,
4211                     struct nfs4_label *label)
4212 {
4213     uint32_t pi = 0;
4214     uint32_t lfs = 0;
4215     __u32 len;
4216     __be32 *p;
4217     int status = 0;
4218
4219     if (unlikely(bitmap[2] & (FATTR4_WORD2_SECURITY_LABEL - 1U)))
4220         return -EIO;
4221     if (likely(bitmap[2] & FATTR4_WORD2_SECURITY_LABEL)) {
4222         p = xdr_inline_decode(xdr, 4);
4223         if (unlikely(!p))
4224             return -EIO;
4225         lfs = be32_to_cpup(p++);
4226         p = xdr_inline_decode(xdr, 4);
4227         if (unlikely(!p))
4228             return -EIO;
4229         pi = be32_to_cpup(p++);
4230         p = xdr_inline_decode(xdr, 4);
4231         if (unlikely(!p))
4232             return -EIO;
4233         len = be32_to_cpup(p++);
4234         p = xdr_inline_decode(xdr, len);
4235         if (unlikely(!p))
4236             return -EIO;
4237         if (len < NFS4_MAXLABELLEN) {
4238             if (label) {
4239                 if (label->len) {
4240                     if (label->len < len)
4241                         return -ERANGE;
4242                     memcpy(label->label, p, len);
4243                 }
4244                 label->len = len;
4245                 label->pi = pi;
4246                 label->lfs = lfs;
4247                 status = NFS_ATTR_FATTR_V4_SECURITY_LABEL;
4248             }
4249             bitmap[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
4250         } else
4251             printk(KERN_WARNING "%s: label too long (%u)!\n",
4252                     __func__, len);
4253         if (label && label->label)
4254             dprintk("%s: label=%.*s, len=%d, PI=%d, LFS=%d\n",
4255                 __func__, label->len, (char *)label->label,
4256                 label->len, label->pi, label->lfs);
4257     }
4258     return status;
4259 }
4260
4261 static int decode_attr_time_modify(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec64 *time)
4262 {
4263     int status = 0;
4264
4265     time->tv_sec = 0;
4266     time->tv_nsec = 0;
4267     if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_MODIFY - 1U)))
4268         return -EIO;
4269     if (likely(bitmap[1] & FATTR4_WORD1_TIME_MODIFY)) {
4270         status = decode_attr_time(xdr, time);
4271         if (status == 0)
4272             status = NFS_ATTR_FATTR_MTIME;
4273         bitmap[1] &= ~FATTR4_WORD1_TIME_MODIFY;
4274     }
4275     dprintk("%s: mtime=%lld\n", __func__, time->tv_sec);
4276     return status;
4277 }
4278
4279 static int decode_attr_xattrsupport(struct xdr_stream *xdr, uint32_t *bitmap,
4280                     uint32_t *res)
4281 {
4282     __be32 *p;
4283
4284     *res = 0;
4285     if (unlikely(bitmap[2] & (FATTR4_WORD2_XATTR_SUPPORT - 1U)))
4286         return -EIO;
4287     if (likely(bitmap[2] & FATTR4_WORD2_XATTR_SUPPORT)) {
4288         p = xdr_inline_decode(xdr, 4);
4289         if (unlikely(!p))
4290             return -EIO;
4291         *res = be32_to_cpup(p);
4292         bitmap[2] &= ~FATTR4_WORD2_XATTR_SUPPORT;
4293     }
4294     dprintk("%s: XATTR support=%s\n", __func__,
4295         *res == 0 ? "false" : "true");
4296     return 0;
4297 }
4298
4299 static int verify_attr_len(struct xdr_stream *xdr, unsigned int savep, uint32_t attrlen)
4300 {
4301     unsigned int attrwords = XDR_QUADLEN(attrlen);
4302     unsigned int nwords = (xdr_stream_pos(xdr) - savep) >> 2;
4303
4304     if (unlikely(attrwords != nwords)) {
4305         dprintk("%s: server returned incorrect attribute length: "
4306             "%u %c %u\n",
4307                 __func__,
4308                 attrwords << 2,
4309                 (attrwords < nwords) ? '<' : '>',
4310                 nwords << 2);
4311         return -EIO;
4312     }
4313     return 0;
4314 }
4315
4316 static int decode_change_info(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
4317 {
4318     __be32 *p;
4319
4320     p = xdr_inline_decode(xdr, 20);
4321     if (unlikely(!p))
4322         return -EIO;
4323     cinfo->atomic = be32_to_cpup(p++);
4324     p = xdr_decode_hyper(p, &cinfo->before);
4325     xdr_decode_hyper(p, &cinfo->after);
4326     return 0;
4327 }
4328
4329 static int decode_access(struct xdr_stream *xdr, u32 *supported, u32 *access)
4330 {
4331     __be32 *p;
4332     uint32_t supp, acc;
4333     int status;
4334
4335     status = decode_op_hdr(xdr, OP_ACCESS);
4336     if (status)
4337         return status;
4338     p = xdr_inline_decode(xdr, 8);
4339     if (unlikely(!p))
4340         return -EIO;
4341     supp = be32_to_cpup(p++);
4342     acc = be32_to_cpup(p);
4343     *supported = supp;
4344     *access = acc;
4345     return 0;
4346 }
4347
4348 static int decode_opaque_fixed(struct xdr_stream *xdr, void *buf, size_t len)
4349 {
4350     ssize_t ret = xdr_stream_decode_opaque_fixed(xdr, buf, len);
4351     if (unlikely(ret < 0))
4352         return -EIO;
4353     return 0;
4354 }
4355
4356 static int decode_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
4357 {
4358     return decode_opaque_fixed(xdr, stateid, NFS4_STATEID_SIZE);
4359 }
4360
4361 static int decode_open_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
4362 {
4363     stateid->type = NFS4_OPEN_STATEID_TYPE;
4364     return decode_stateid(xdr, stateid);
4365 }
4366
4367 static int decode_lock_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
4368 {
4369     stateid->type = NFS4_LOCK_STATEID_TYPE;
4370     return decode_stateid(xdr, stateid);
4371 }
4372
4373 static int decode_delegation_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
4374 {
4375     stateid->type = NFS4_DELEGATION_STATEID_TYPE;
4376     return decode_stateid(xdr, stateid);
4377 }
4378
4379 static int decode_invalid_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
4380 {
4381     nfs4_stateid dummy;
4382
4383     nfs4_stateid_copy(stateid, &invalid_stateid);
4384     return decode_stateid(xdr, &dummy);
4385 }
4386
4387 static int decode_close(struct xdr_stream *xdr, struct nfs_closeres *res)
4388 {
4389     int status;
4390
4391     status = decode_op_hdr(xdr, OP_CLOSE);
4392     if (status != -EIO)
4393         nfs_increment_open_seqid(status, res->seqid);
4394     if (!status)
4395         status = decode_invalid_stateid(xdr, &res->stateid);
4396     return status;
4397 }
4398
4399 static int decode_verifier(struct xdr_stream *xdr, void *verifier)
4400 {
4401     return decode_opaque_fixed(xdr, verifier, NFS4_VERIFIER_SIZE);
4402 }
4403
4404 static int decode_write_verifier(struct xdr_stream *xdr, struct nfs_write_verifier *verifier)
4405 {
4406     return decode_opaque_fixed(xdr, verifier->data, NFS4_VERIFIER_SIZE);
4407 }
4408
4409 static int decode_commit(struct xdr_stream *xdr, struct nfs_commitres *res)
4410 {
4411     struct nfs_writeverf *verf = res->verf;
4412     int status;
4413
4414     status = decode_op_hdr(xdr, OP_COMMIT);
4415     if (!status)
4416         status = decode_write_verifier(xdr, &verf->verifier);
4417     if (!status)
4418         verf->committed = NFS_FILE_SYNC;
4419     return status;
4420 }
4421
4422 static int decode_create(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
4423 {
4424     __be32 *p;
4425     uint32_t bmlen;
4426     int status;
4427
4428     status = decode_op_hdr(xdr, OP_CREATE);
4429     if (status)
4430         return status;
4431     if ((status = decode_change_info(xdr, cinfo)))
4432         return status;
4433     p = xdr_inline_decode(xdr, 4);
4434     if (unlikely(!p))
4435         return -EIO;
4436     bmlen = be32_to_cpup(p);
4437     p = xdr_inline_decode(xdr, bmlen << 2);
4438     if (likely(p))
4439         return 0;
4440     return -EIO;
4441 }
4442
4443 static int decode_server_caps(struct xdr_stream *xdr, struct nfs4_server_caps_res *res)
4444 {
4445     unsigned int savep;
4446     uint32_t attrlen, bitmap[3] = {0};
4447     int status;
4448
4449     if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
4450         goto xdr_error;
4451     if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
4452         goto xdr_error;
4453     if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
4454         goto xdr_error;
4455     if ((status = decode_attr_supported(xdr, bitmap, res->attr_bitmask)) != 0)
4456         goto xdr_error;
4457     if ((status = decode_attr_fh_expire_type(xdr, bitmap,
4458                          &res->fh_expire_type)) != 0)
4459         goto xdr_error;
4460     if ((status = decode_attr_link_support(xdr, bitmap, &res->has_links)) != 0)
4461         goto xdr_error;
4462     if ((status = decode_attr_symlink_support(xdr, bitmap, &res->has_symlinks)) != 0)
4463         goto xdr_error;
4464     if ((status = decode_attr_aclsupport(xdr, bitmap, &res->acl_bitmask)) != 0)
4465         goto xdr_error;
4466     if ((status = decode_attr_case_insensitive(xdr, bitmap, &res->case_insensitive)) != 0)
4467         goto xdr_error;
4468     if ((status = decode_attr_case_preserving(xdr, bitmap, &res->case_preserving)) != 0)
4469         goto xdr_error;
4470     if ((status = decode_attr_exclcreat_supported(xdr, bitmap,
4471                 res->exclcreat_bitmask)) != 0)
4472         goto xdr_error;
4473     status = verify_attr_len(xdr, savep, attrlen);
4474 xdr_error:
4475     dprintk("%s: xdr returned %d!\n", __func__, -status);
4476     return status;
4477 }
4478
4479 static int decode_statfs(struct xdr_stream *xdr, struct nfs_fsstat *fsstat)
4480 {
4481     unsigned int savep;
4482     uint32_t attrlen, bitmap[3] = {0};
4483     int status;
4484
4485     if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
4486         goto xdr_error;
4487     if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
4488         goto xdr_error;
4489     if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
4490         goto xdr_error;
4491
4492     if ((status = decode_attr_files_avail(xdr, bitmap, &fsstat->afiles)) != 0)
4493         goto xdr_error;
4494     if ((status = decode_attr_files_free(xdr, bitmap, &fsstat->ffiles)) != 0)
4495         goto xdr_error;
4496     if ((status = decode_attr_files_total(xdr, bitmap, &fsstat->tfiles)) != 0)
4497         goto xdr_error;
4498
4499     status = -EIO;
4500     if (unlikely(bitmap[0]))
4501         goto xdr_error;
4502
4503     if ((status = decode_attr_space_avail(xdr, bitmap, &fsstat->abytes)) != 0)
4504         goto xdr_error;
4505     if ((status = decode_attr_space_free(xdr, bitmap, &fsstat->fbytes)) != 0)
4506         goto xdr_error;
4507     if ((status = decode_attr_space_total(xdr, bitmap, &fsstat->tbytes)) != 0)
4508         goto xdr_error;
4509
4510     status = verify_attr_len(xdr, savep, attrlen);
4511 xdr_error:
4512     dprintk("%s: xdr returned %d!\n", __func__, -status);
4513     return status;
4514 }
4515
4516 static int decode_pathconf(struct xdr_stream *xdr, struct nfs_pathconf *pathconf)
4517 {
4518     unsigned int savep;
4519     uint32_t attrlen, bitmap[3] = {0};
4520     int status;
4521
4522     if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
4523         goto xdr_error;
4524     if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
4525         goto xdr_error;
4526     if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
4527         goto xdr_error;
4528
4529     if ((status = decode_attr_maxlink(xdr, bitmap, &pathconf->max_link)) != 0)
4530         goto xdr_error;
4531     if ((status = decode_attr_maxname(xdr, bitmap, &pathconf->max_namelen)) != 0)
4532         goto xdr_error;
4533
4534     status = verify_attr_len(xdr, savep, attrlen);
4535 xdr_error:
4536     dprintk("%s: xdr returned %d!\n", __func__, -status);
4537     return status;
4538 }
4539
4540 static int decode_threshold_hint(struct xdr_stream *xdr,
4541                   uint32_t *bitmap,
4542                   uint64_t *res,
4543                   uint32_t hint_bit)
4544 {
4545     __be32 *p;
4546
4547     *res = 0;
4548     if (likely(bitmap[0] & hint_bit)) {
4549         p = xdr_inline_decode(xdr, 8);
4550         if (unlikely(!p))
4551             return -EIO;
4552         xdr_decode_hyper(p, res);
4553     }
4554     return 0;
4555 }
4556
4557 static int decode_first_threshold_item4(struct xdr_stream *xdr,
4558                     struct nfs4_threshold *res)
4559 {
4560     __be32 *p;
4561     unsigned int savep;
4562     uint32_t bitmap[3] = {0,}, attrlen;
4563     int status;
4564
4565     /* layout type */
4566     p = xdr_inline_decode(xdr, 4);
4567     if (unlikely(!p))
4568         return -EIO;
4569     res->l_type = be32_to_cpup(p);
4570
4571     /* thi_hintset bitmap */
4572     status = decode_attr_bitmap(xdr, bitmap);
4573     if (status < 0)
4574         goto xdr_error;
4575
4576     /* thi_hintlist length */
4577     status = decode_attr_length(xdr, &attrlen, &savep);
4578     if (status < 0)
4579         goto xdr_error;
4580     /* thi_hintlist */
4581     status = decode_threshold_hint(xdr, bitmap, &res->rd_sz, THRESHOLD_RD);
4582     if (status < 0)
4583         goto xdr_error;
4584     status = decode_threshold_hint(xdr, bitmap, &res->wr_sz, THRESHOLD_WR);
4585     if (status < 0)
4586         goto xdr_error;
4587     status = decode_threshold_hint(xdr, bitmap, &res->rd_io_sz,
4588                        THRESHOLD_RD_IO);
4589     if (status < 0)
4590         goto xdr_error;
4591     status = decode_threshold_hint(xdr, bitmap, &res->wr_io_sz,
4592                        THRESHOLD_WR_IO);
4593     if (status < 0)
4594         goto xdr_error;
4595
4596     status = verify_attr_len(xdr, savep, attrlen);
4597     res->bm = bitmap[0];
4598
4599     dprintk("%s bm=0x%x rd_sz=%llu wr_sz=%llu rd_io=%llu wr_io=%llu\n",
4600          __func__, res->bm, res->rd_sz, res->wr_sz, res->rd_io_sz,
4601         res->wr_io_sz);
4602 xdr_error:
4603     dprintk("%s ret=%d!\n", __func__, status);
4604     return status;
4605 }
4606
4607 /*
4608  * Thresholds on pNFS direct I/O vrs MDS I/O
4609  */
4610 static int decode_attr_mdsthreshold(struct xdr_stream *xdr,
4611                     uint32_t *bitmap,
4612                     struct nfs4_threshold *res)
4613 {
4614     __be32 *p;
4615     int status = 0;
4616     uint32_t num;
4617
4618     if (unlikely(bitmap[2] & (FATTR4_WORD2_MDSTHRESHOLD - 1U)))
4619         return -EIO;
4620     if (bitmap[2] & FATTR4_WORD2_MDSTHRESHOLD) {
4621         /* Did the server return an unrequested attribute? */
4622         if (unlikely(res == NULL))
4623             return -EREMOTEIO;
4624         p = xdr_inline_decode(xdr, 4);
4625         if (unlikely(!p))
4626             return -EIO;
4627         num = be32_to_cpup(p);
4628         if (num == 0)
4629             return 0;
4630         if (num > 1)
4631             printk(KERN_INFO "%s: Warning: Multiple pNFS layout "
4632                 "drivers per filesystem not supported\n",
4633                 __func__);
4634
4635         status = decode_first_threshold_item4(xdr, res);
4636         bitmap[2] &= ~FATTR4_WORD2_MDSTHRESHOLD;
4637     }
4638     return status;
4639 }
4640
4641 static int decode_getfattr_attrs(struct xdr_stream *xdr, uint32_t *bitmap,
4642         struct nfs_fattr *fattr, struct nfs_fh *fh,
4643         struct nfs4_fs_locations *fs_loc, const struct nfs_server *server)
4644 {
4645     int status;
4646     umode_t fmode = 0;
4647     uint32_t type;
4648     int32_t err;
4649
4650     status = decode_attr_type(xdr, bitmap, &type);
4651     if (status < 0)
4652         goto xdr_error;
4653     fattr->mode = 0;
4654     if (status != 0) {
4655         fattr->mode |= nfs_type2fmt[type];
4656         fattr->valid |= status;
4657     }
4658
4659     status = decode_attr_change(xdr, bitmap, &fattr->change_attr);
4660     if (status < 0)
4661         goto xdr_error;
4662     fattr->valid |= status;
4663
4664     status = decode_attr_size(xdr, bitmap, &fattr->size);
4665     if (status < 0)
4666         goto xdr_error;
4667     fattr->valid |= status;
4668
4669     status = decode_attr_fsid(xdr, bitmap, &fattr->fsid);
4670     if (status < 0)
4671         goto xdr_error;
4672     fattr->valid |= status;
4673
4674     err = 0;
4675     status = decode_attr_error(xdr, bitmap, &err);
4676     if (status < 0)
4677         goto xdr_error;
4678
4679     status = decode_attr_filehandle(xdr, bitmap, fh);
4680     if (status < 0)
4681         goto xdr_error;
4682
4683     status = decode_attr_fileid(xdr, bitmap, &fattr->fileid);
4684     if (status < 0)
4685         goto xdr_error;
4686     fattr->valid |= status;
4687
4688     status = decode_attr_fs_locations(xdr, bitmap, fs_loc);
4689     if (status < 0)
4690         goto xdr_error;
4691     fattr->valid |= status;
4692
4693     status = -EIO;
4694     if (unlikely(bitmap[0]))
4695         goto xdr_error;
4696
4697     status = decode_attr_mode(xdr, bitmap, &fmode);
4698     if (status < 0)
4699         goto xdr_error;
4700     if (status != 0) {
4701         fattr->mode |= fmode;
4702         fattr->valid |= status;
4703     }
4704
4705     status = decode_attr_nlink(xdr, bitmap, &fattr->nlink);
4706     if (status < 0)
4707         goto xdr_error;
4708     fattr->valid |= status;
4709
4710     status = decode_attr_owner(xdr, bitmap, server, &fattr->uid, fattr->owner_name);
4711     if (status < 0)
4712         goto xdr_error;
4713     fattr->valid |= status;
4714
4715     status = decode_attr_group(xdr, bitmap, server, &fattr->gid, fattr->group_name);
4716     if (status < 0)
4717         goto xdr_error;
4718     fattr->valid |= status;
4719
4720     status = decode_attr_rdev(xdr, bitmap, &fattr->rdev);
4721     if (status < 0)
4722         goto xdr_error;
4723     fattr->valid |= status;
4724
4725     status = decode_attr_space_used(xdr, bitmap, &fattr->du.nfs3.used);
4726     if (status < 0)
4727         goto xdr_error;
4728     fattr->valid |= status;
4729
4730     status = decode_attr_time_access(xdr, bitmap, &fattr->atime);
4731     if (status < 0)
4732         goto xdr_error;
4733     fattr->valid |= status;
4734
4735     status = decode_attr_time_metadata(xdr, bitmap, &fattr->ctime);
4736     if (status < 0)
4737         goto xdr_error;
4738     fattr->valid |= status;
4739
4740     status = decode_attr_time_modify(xdr, bitmap, &fattr->mtime);
4741     if (status < 0)
4742         goto xdr_error;
4743     fattr->valid |= status;
4744
4745     status = decode_attr_mounted_on_fileid(xdr, bitmap, &fattr->mounted_on_fileid);
4746     if (status < 0)
4747         goto xdr_error;
4748     fattr->valid |= status;
4749
4750     status = -EIO;
4751     if (unlikely(bitmap[1]))
4752         goto xdr_error;
4753
4754     status = decode_attr_mdsthreshold(xdr, bitmap, fattr->mdsthreshold);
4755     if (status < 0)
4756         goto xdr_error;
4757
4758     if (fattr->label) {
4759         status = decode_attr_security_label(xdr, bitmap, fattr->label);
4760         if (status < 0)
4761             goto xdr_error;
4762         fattr->valid |= status;
4763     }
4764
4765 xdr_error:
4766     dprintk("%s: xdr returned %d\n", __func__, -status);
4767     return status;
4768 }
4769
4770 static int decode_getfattr_generic(struct xdr_stream *xdr, struct nfs_fattr *fattr,
4771         struct nfs_fh *fh, struct nfs4_fs_locations *fs_loc,
4772         const struct nfs_server *server)
4773 {
4774     unsigned int savep;
4775     uint32_t attrlen,
4776          bitmap[3] = {0};
4777     int status;
4778
4779     status = decode_op_hdr(xdr, OP_GETATTR);
4780     if (status < 0)
4781         goto xdr_error;
4782
4783     status = decode_attr_bitmap(xdr, bitmap);
4784     if (status < 0)
4785         goto xdr_error;
4786
4787     status = decode_attr_length(xdr, &attrlen, &savep);
4788     if (status < 0)
4789         goto xdr_error;
4790
4791     status = decode_getfattr_attrs(xdr, bitmap, fattr, fh, fs_loc, server);
4792     if (status < 0)
4793         goto xdr_error;
4794
4795     status = verify_attr_len(xdr, savep, attrlen);
4796 xdr_error:
4797     dprintk("%s: xdr returned %d\n", __func__, -status);
4798     return status;
4799 }
4800
4801 static int decode_getfattr(struct xdr_stream *xdr, struct nfs_fattr *fattr,
4802         const struct nfs_server *server)
4803 {
4804     return decode_getfattr_generic(xdr, fattr, NULL, NULL, server);
4805 }
4806
4807 /*
4808  * Decode potentially multiple layout types.
4809  */
4810 static int decode_pnfs_layout_types(struct xdr_stream *xdr,
4811                     struct nfs_fsinfo *fsinfo)
4812 {
4813     __be32 *p;
4814     uint32_t i;
4815
4816     p = xdr_inline_decode(xdr, 4);
4817     if (unlikely(!p))
4818         return -EIO;
4819     fsinfo->nlayouttypes = be32_to_cpup(p);
4820
4821     /* pNFS is not supported by the underlying file system */
4822     if (fsinfo->nlayouttypes == 0)
4823         return 0;
4824
4825     /* Decode and set first layout type, move xdr->p past unused types */
4826     p = xdr_inline_decode(xdr, fsinfo->nlayouttypes * 4);
4827     if (unlikely(!p))
4828         return -EIO;
4829
4830     /* If we get too many, then just cap it at the max */
4831     if (fsinfo->nlayouttypes > NFS_MAX_LAYOUT_TYPES) {
4832         printk(KERN_INFO "NFS: %s: Warning: Too many (%u) pNFS layout types\n",
4833             __func__, fsinfo->nlayouttypes);
4834         fsinfo->nlayouttypes = NFS_MAX_LAYOUT_TYPES;
4835     }
4836
4837     for(i = 0; i < fsinfo->nlayouttypes; ++i)
4838         fsinfo->layouttype[i] = be32_to_cpup(p++);
4839     return 0;
4840 }
4841
4842 /*
4843  * The type of file system exported.
4844  * Note we must ensure that layouttype is set in any non-error case.
4845  */
4846 static int decode_attr_pnfstype(struct xdr_stream *xdr, uint32_t *bitmap,
4847                 struct nfs_fsinfo *fsinfo)
4848 {
4849     int status = 0;
4850
4851     dprintk("%s: bitmap is %x\n", __func__, bitmap[1]);
4852     if (unlikely(bitmap[1] & (FATTR4_WORD1_FS_LAYOUT_TYPES - 1U)))
4853         return -EIO;
4854     if (bitmap[1] & FATTR4_WORD1_FS_LAYOUT_TYPES) {
4855         status = decode_pnfs_layout_types(xdr, fsinfo);
4856         bitmap[1] &= ~FATTR4_WORD1_FS_LAYOUT_TYPES;
4857     }
4858     return status;
4859 }
4860
4861 /*
4862  * The prefered block size for layout directed io
4863  */
4864 static int decode_attr_layout_blksize(struct xdr_stream *xdr, uint32_t *bitmap,
4865                       uint32_t *res)
4866 {
4867     __be32 *p;
4868
4869     dprintk("%s: bitmap is %x\n", __func__, bitmap[2]);
4870     *res = 0;
4871     if (bitmap[2] & FATTR4_WORD2_LAYOUT_BLKSIZE) {
4872         p = xdr_inline_decode(xdr, 4);
4873         if (unlikely(!p))
4874             return -EIO;
4875         *res = be32_to_cpup(p);
4876         bitmap[2] &= ~FATTR4_WORD2_LAYOUT_BLKSIZE;
4877     }
4878     return 0;
4879 }
4880
4881 /*
4882  * The granularity of a CLONE operation.
4883  */
4884 static int decode_attr_clone_blksize(struct xdr_stream *xdr, uint32_t *bitmap,
4885                      uint32_t *res)
4886 {
4887     __be32 *p;
4888
4889     dprintk("%s: bitmap is %x\n", __func__, bitmap[2]);
4890     *res = 0;
4891     if (bitmap[2] & FATTR4_WORD2_CLONE_BLKSIZE) {
4892         p = xdr_inline_decode(xdr, 4);
4893         if (unlikely(!p))
4894             return -EIO;
4895         *res = be32_to_cpup(p);
4896         bitmap[2] &= ~FATTR4_WORD2_CLONE_BLKSIZE;
4897     }
4898     return 0;
4899 }
4900
4901 static int decode_attr_change_attr_type(struct xdr_stream *xdr,
4902                     uint32_t *bitmap,
4903                     enum nfs4_change_attr_type *res)
4904 {
4905     u32 tmp = NFS4_CHANGE_TYPE_IS_UNDEFINED;
4906
4907     dprintk("%s: bitmap is %x\n", __func__, bitmap[2]);
4908     if (bitmap[2] & FATTR4_WORD2_CHANGE_ATTR_TYPE) {
4909         if (xdr_stream_decode_u32(xdr, &tmp))
4910             return -EIO;
4911         bitmap[2] &= ~FATTR4_WORD2_CHANGE_ATTR_TYPE;
4912     }
4913
4914     switch(tmp) {
4915     case NFS4_CHANGE_TYPE_IS_MONOTONIC_INCR:
4916     case NFS4_CHANGE_TYPE_IS_VERSION_COUNTER:
4917     case NFS4_CHANGE_TYPE_IS_VERSION_COUNTER_NOPNFS:
4918     case NFS4_CHANGE_TYPE_IS_TIME_METADATA:
4919         *res = tmp;
4920         break;
4921     default:
4922         *res = NFS4_CHANGE_TYPE_IS_UNDEFINED;
4923     }
4924     return 0;
4925 }
4926
4927 static int decode_fsinfo(struct xdr_stream *xdr, struct nfs_fsinfo *fsinfo)
4928 {
4929     unsigned int savep;
4930     uint32_t attrlen, bitmap[3];
4931     int status;
4932
4933     if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
4934         goto xdr_error;
4935     if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
4936         goto xdr_error;
4937     if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
4938         goto xdr_error;
4939
4940     fsinfo->rtmult = fsinfo->wtmult = 512;  /* ??? */
4941
4942     if ((status = decode_attr_lease_time(xdr, bitmap, &fsinfo->lease_time)) != 0)
4943         goto xdr_error;
4944     if ((status = decode_attr_maxfilesize(xdr, bitmap, &fsinfo->maxfilesize)) != 0)
4945         goto xdr_error;
4946     if ((status = decode_attr_maxread(xdr, bitmap, &fsinfo->rtmax)) != 0)
4947         goto xdr_error;
4948     fsinfo->rtpref = fsinfo->dtpref = fsinfo->rtmax;
4949     if ((status = decode_attr_maxwrite(xdr, bitmap, &fsinfo->wtmax)) != 0)
4950         goto xdr_error;
4951     fsinfo->wtpref = fsinfo->wtmax;
4952
4953     status = -EIO;
4954     if (unlikely(bitmap[0]))
4955         goto xdr_error;
4956
4957     status = decode_attr_time_delta(xdr, bitmap, &fsinfo->time_delta);
4958     if (status != 0)
4959         goto xdr_error;
4960     status = decode_attr_pnfstype(xdr, bitmap, fsinfo);
4961     if (status != 0)
4962         goto xdr_error;
4963
4964     status = -EIO;
4965     if (unlikely(bitmap[1]))
4966         goto xdr_error;
4967
4968     status = decode_attr_layout_blksize(xdr, bitmap, &fsinfo->blksize);
4969     if (status)
4970         goto xdr_error;
4971     status = decode_attr_clone_blksize(xdr, bitmap, &fsinfo->clone_blksize);
4972     if (status)
4973         goto xdr_error;
4974
4975     status = decode_attr_change_attr_type(xdr, bitmap,
4976                           &fsinfo->change_attr_type);
4977     if (status)
4978         goto xdr_error;
4979
4980     status = decode_attr_xattrsupport(xdr, bitmap,
4981                       &fsinfo->xattr_support);
4982     if (status)
4983         goto xdr_error;
4984
4985     status = verify_attr_len(xdr, savep, attrlen);
4986 xdr_error:
4987     dprintk("%s: xdr returned %d!\n", __func__, -status);
4988     return status;
4989 }
4990
4991 static int decode_getfh(struct xdr_stream *xdr, struct nfs_fh *fh)
4992 {
4993     __be32 *p;
4994     uint32_t len;
4995     int status;
4996
4997     /* Zero handle first to allow comparisons */
4998     memset(fh, 0, sizeof(*fh));
4999
5000     status = decode_op_hdr(xdr, OP_GETFH);
5001     if (status)
5002         return status;
5003
5004     p = xdr_inline_decode(xdr, 4);
5005     if (unlikely(!p))
5006         return -EIO;
5007     len = be32_to_cpup(p);
5008     if (len > NFS4_FHSIZE || len == 0) {
5009         trace_nfs4_xdr_bad_filehandle(xdr, OP_GETFH, NFS4ERR_BADHANDLE);
5010         return -EREMOTEIO;
5011     }
5012     fh->size = len;
5013     p = xdr_inline_decode(xdr, len);
5014     if (unlikely(!p))
5015         return -EIO;
5016     memcpy(fh->data, p, len);
5017     return 0;
5018 }
5019
5020 static int decode_link(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
5021 {
5022     int status;
5023
5024     status = decode_op_hdr(xdr, OP_LINK);
5025     if (status)
5026         return status;
5027     return decode_change_info(xdr, cinfo);
5028 }
5029
5030 /*
5031  * We create the owner, so we know a proper owner.id length is 4.
5032  */
5033 static int decode_lock_denied (struct xdr_stream *xdr, struct file_lock *fl)
5034 {
5035     uint64_t offset, length, clientid;
5036     __be32 *p;
5037     uint32_t namelen, type;
5038
5039     p = xdr_inline_decode(xdr, 32); /* read 32 bytes */
5040     if (unlikely(!p))
5041         return -EIO;
5042     p = xdr_decode_hyper(p, &offset); /* read 2 8-byte long words */
5043     p = xdr_decode_hyper(p, &length);
5044     type = be32_to_cpup(p++); /* 4 byte read */
5045     if (fl != NULL) { /* manipulate file lock */
5046         fl->fl_start = (loff_t)offset;
5047         fl->fl_end = fl->fl_start + (loff_t)length - 1;
5048         if (length == ~(uint64_t)0)
5049             fl->fl_end = OFFSET_MAX;
5050         fl->fl_type = F_WRLCK;
5051         if (type & 1)
5052             fl->fl_type = F_RDLCK;
5053         fl->fl_pid = 0;
5054     }
5055     p = xdr_decode_hyper(p, &clientid); /* read 8 bytes */
5056     namelen = be32_to_cpup(p); /* read 4 bytes */  /* have read all 32 bytes now */
5057     p = xdr_inline_decode(xdr, namelen); /* variable size field */
5058     if (likely(!p))
5059         return -EIO;
5060     return -NFS4ERR_DENIED;
5061 }
5062
5063 static int decode_lock(struct xdr_stream *xdr, struct nfs_lock_res *res)
5064 {
5065     int status;
5066
5067     status = decode_op_hdr(xdr, OP_LOCK);
5068     if (status == -EIO)
5069         goto out;
5070     if (status == 0) {
5071         status = decode_lock_stateid(xdr, &res->stateid);
5072         if (unlikely(status))
5073             goto out;
5074     } else if (status == -NFS4ERR_DENIED)
5075         status = decode_lock_denied(xdr, NULL);
5076     if (res->open_seqid != NULL)
5077         nfs_increment_open_seqid(status, res->open_seqid);
5078     nfs_increment_lock_seqid(status, res->lock_seqid);
5079 out:
5080     return status;
5081 }
5082
5083 static int decode_lockt(struct xdr_stream *xdr, struct nfs_lockt_res *res)
5084 {
5085     int status;
5086     status = decode_op_hdr(xdr, OP_LOCKT);
5087     if (status == -NFS4ERR_DENIED)
5088         return decode_lock_denied(xdr, res->denied);
5089     return status;
5090 }
5091
5092 static int decode_locku(struct xdr_stream *xdr, struct nfs_locku_res *res)
5093 {
5094     int status;
5095
5096     status = decode_op_hdr(xdr, OP_LOCKU);
5097     if (status != -EIO)
5098         nfs_increment_lock_seqid(status, res->seqid);
5099     if (status == 0)
5100         status = decode_lock_stateid(xdr, &res->stateid);
5101     return status;
5102 }
5103
5104 static int decode_release_lockowner(struct xdr_stream *xdr)
5105 {
5106     return decode_op_hdr(xdr, OP_RELEASE_LOCKOWNER);
5107 }
5108
5109 static int decode_lookup(struct xdr_stream *xdr)
5110 {
5111     return decode_op_hdr(xdr, OP_LOOKUP);
5112 }
5113
5114 static int decode_lookupp(struct xdr_stream *xdr)
5115 {
5116     return decode_op_hdr(xdr, OP_LOOKUPP);
5117 }
5118
5119 /* This is too sick! */
5120 static int decode_space_limit(struct xdr_stream *xdr,
5121         unsigned long *pagemod_limit)
5122 {
5123     __be32 *p;
5124     uint32_t limit_type, nblocks, blocksize;
5125     u64 maxsize = 0;
5126
5127     p = xdr_inline_decode(xdr, 12);
5128     if (unlikely(!p))
5129         return -EIO;
5130     limit_type = be32_to_cpup(p++);
5131     switch (limit_type) {
5132     case NFS4_LIMIT_SIZE:
5133         xdr_decode_hyper(p, &maxsize);
5134         break;
5135     case NFS4_LIMIT_BLOCKS:
5136         nblocks = be32_to_cpup(p++);
5137         blocksize = be32_to_cpup(p);
5138         maxsize = (uint64_t)nblocks * (uint64_t)blocksize;
5139     }
5140     maxsize >>= PAGE_SHIFT;
5141     *pagemod_limit = min_t(u64, maxsize, ULONG_MAX);
5142     return 0;
5143 }
5144
5145 static int decode_rw_delegation(struct xdr_stream *xdr,
5146         uint32_t delegation_type,
5147         struct nfs_openres *res)
5148 {
5149     __be32 *p;
5150     int status;
5151
5152     status = decode_delegation_stateid(xdr, &res->delegation);
5153     if (unlikely(status))
5154         return status;
5155     p = xdr_inline_decode(xdr, 4);
5156     if (unlikely(!p))
5157         return -EIO;
5158     res->do_recall = be32_to_cpup(p);
5159
5160     switch (delegation_type) {
5161     case NFS4_OPEN_DELEGATE_READ:
5162         res->delegation_type = FMODE_READ;
5163         break;
5164     case NFS4_OPEN_DELEGATE_WRITE:
5165         res->delegation_type = FMODE_WRITE|FMODE_READ;
5166         if (decode_space_limit(xdr, &res->pagemod_limit) < 0)
5167                 return -EIO;
5168     }
5169     return decode_ace(xdr, NULL);
5170 }
5171
5172 static int decode_no_delegation(struct xdr_stream *xdr, struct nfs_openres *res)
5173 {
5174     __be32 *p;
5175     uint32_t why_no_delegation;
5176
5177     p = xdr_inline_decode(xdr, 4);
5178     if (unlikely(!p))
5179         return -EIO;
5180     why_no_delegation = be32_to_cpup(p);
5181     switch (why_no_delegation) {
5182         case WND4_CONTENTION:
5183         case WND4_RESOURCE:
5184             xdr_inline_decode(xdr, 4);
5185             /* Ignore for now */
5186     }
5187     return 0;
5188 }
5189
5190 static int decode_delegation(struct xdr_stream *xdr, struct nfs_openres *res)
5191 {
5192     __be32 *p;
5193     uint32_t delegation_type;
5194
5195     p = xdr_inline_decode(xdr, 4);
5196     if (unlikely(!p))
5197         return -EIO;
5198     delegation_type = be32_to_cpup(p);
5199     res->delegation_type = 0;
5200     switch (delegation_type) {
5201     case NFS4_OPEN_DELEGATE_NONE:
5202         return 0;
5203     case NFS4_OPEN_DELEGATE_READ:
5204     case NFS4_OPEN_DELEGATE_WRITE:
5205         return decode_rw_delegation(xdr, delegation_type, res);
5206     case NFS4_OPEN_DELEGATE_NONE_EXT:
5207         return decode_no_delegation(xdr, res);
5208     }
5209     return -EIO;
5210 }
5211
5212 static int decode_open(struct xdr_stream *xdr, struct nfs_openres *res)
5213 {
5214     __be32 *p;
5215     uint32_t savewords, bmlen, i;
5216     int status;
5217
5218     if (!__decode_op_hdr(xdr, OP_OPEN, &status))
5219         return status;
5220     nfs_increment_open_seqid(status, res->seqid);
5221     if (status)
5222         return status;
5223     status = decode_open_stateid(xdr, &res->stateid);
5224     if (unlikely(status))
5225         return status;
5226
5227     decode_change_info(xdr, &res->cinfo);
5228
5229     p = xdr_inline_decode(xdr, 8);
5230     if (unlikely(!p))
5231         return -EIO;
5232     res->rflags = be32_to_cpup(p++);
5233     bmlen = be32_to_cpup(p);
5234     if (bmlen > 10)
5235         goto xdr_error;
5236
5237     p = xdr_inline_decode(xdr, bmlen << 2);
5238     if (unlikely(!p))
5239         return -EIO;
5240     savewords = min_t(uint32_t, bmlen, NFS4_BITMAP_SIZE);
5241     for (i = 0; i < savewords; ++i)
5242         res->attrset[i] = be32_to_cpup(p++);
5243     for (; i < NFS4_BITMAP_SIZE; i++)
5244         res->attrset[i] = 0;
5245
5246     return decode_delegation(xdr, res);
5247 xdr_error:
5248     dprintk("%s: Bitmap too large! Length = %u\n", __func__, bmlen);
5249     return -EIO;
5250 }
5251
5252 static int decode_open_confirm(struct xdr_stream *xdr, struct nfs_open_confirmres *res)
5253 {
5254     int status;
5255
5256     status = decode_op_hdr(xdr, OP_OPEN_CONFIRM);
5257     if (status != -EIO)
5258         nfs_increment_open_seqid(status, res->seqid);
5259     if (!status)
5260         status = decode_open_stateid(xdr, &res->stateid);
5261     return status;
5262 }
5263
5264 static int decode_open_downgrade(struct xdr_stream *xdr, struct nfs_closeres *res)
5265 {
5266     int status;
5267
5268     status = decode_op_hdr(xdr, OP_OPEN_DOWNGRADE);
5269     if (status != -EIO)
5270         nfs_increment_open_seqid(status, res->seqid);
5271     if (!status)
5272         status = decode_open_stateid(xdr, &res->stateid);
5273     return status;
5274 }
5275
5276 static int decode_putfh(struct xdr_stream *xdr)
5277 {
5278     return decode_op_hdr(xdr, OP_PUTFH);
5279 }
5280
5281 static int decode_putrootfh(struct xdr_stream *xdr)
5282 {
5283     return decode_op_hdr(xdr, OP_PUTROOTFH);
5284 }
5285
5286 static int decode_read(struct xdr_stream *xdr, struct rpc_rqst *req,
5287                struct nfs_pgio_res *res)
5288 {
5289     __be32 *p;
5290     uint32_t count, eof, recvd;
5291     int status;
5292
5293     status = decode_op_hdr(xdr, OP_READ);
5294     if (status)
5295         return status;
5296     p = xdr_inline_decode(xdr, 8);
5297     if (unlikely(!p))
5298         return -EIO;
5299     eof = be32_to_cpup(p++);
5300     count = be32_to_cpup(p);
5301     recvd = xdr_read_pages(xdr, count);
5302     if (count > recvd) {
5303         dprintk("NFS: server cheating in read reply: "
5304                 "count %u > recvd %u\n", count, recvd);
5305         count = recvd;
5306         eof = 0;
5307     }
5308     res->eof = eof;
5309     res->count = count;
5310     return 0;
5311 }
5312
5313 static int decode_readdir(struct xdr_stream *xdr, struct rpc_rqst *req, struct nfs4_readdir_res *readdir)
5314 {
5315     int     status;
5316     __be32      verf[2];
5317
5318     status = decode_op_hdr(xdr, OP_READDIR);
5319     if (!status)
5320         status = decode_verifier(xdr, readdir->verifier.data);
5321     if (unlikely(status))
5322         return status;
5323     memcpy(verf, readdir->verifier.data, sizeof(verf));
5324     dprintk("%s: verifier = %08x:%08x\n",
5325             __func__, verf[0], verf[1]);
5326     return xdr_read_pages(xdr, xdr->buf->page_len);
5327 }
5328
5329 static int decode_readlink(struct xdr_stream *xdr, struct rpc_rqst *req)
5330 {
5331     struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
5332     u32 len, recvd;
5333     __be32 *p;
5334     int status;
5335
5336     status = decode_op_hdr(xdr, OP_READLINK);
5337     if (status)
5338         return status;
5339
5340     /* Convert length of symlink */
5341     p = xdr_inline_decode(xdr, 4);
5342     if (unlikely(!p))
5343         return -EIO;
5344     len = be32_to_cpup(p);
5345     if (len >= rcvbuf->page_len || len <= 0) {
5346         dprintk("nfs: server returned giant symlink!\n");
5347         return -ENAMETOOLONG;
5348     }
5349     recvd = xdr_read_pages(xdr, len);
5350     if (recvd < len) {
5351         dprintk("NFS: server cheating in readlink reply: "
5352                 "count %u > recvd %u\n", len, recvd);
5353         return -EIO;
5354     }
5355     /*
5356      * The XDR encode routine has set things up so that
5357      * the link text will be copied directly into the
5358      * buffer.  We just have to do overflow-checking,
5359      * and null-terminate the text (the VFS expects
5360      * null-termination).
5361      */
5362     xdr_terminate_string(rcvbuf, len);
5363     return 0;
5364 }
5365
5366 static int decode_remove(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
5367 {
5368     int status;
5369
5370     status = decode_op_hdr(xdr, OP_REMOVE);
5371     if (status)
5372         goto out;
5373     status = decode_change_info(xdr, cinfo);
5374 out:
5375     return status;
5376 }
5377
5378 static int decode_rename(struct xdr_stream *xdr, struct nfs4_change_info *old_cinfo,
5379           struct nfs4_change_info *new_cinfo)
5380 {
5381     int status;
5382
5383     status = decode_op_hdr(xdr, OP_RENAME);
5384     if (status)
5385         goto out;
5386     if ((status = decode_change_info(xdr, old_cinfo)))
5387         goto out;
5388     status = decode_change_info(xdr, new_cinfo);
5389 out:
5390     return status;
5391 }
5392
5393 static int decode_renew(struct xdr_stream *xdr)
5394 {
5395     return decode_op_hdr(xdr, OP_RENEW);
5396 }
5397
5398 static int
5399 decode_restorefh(struct xdr_stream *xdr)
5400 {
5401     return decode_op_hdr(xdr, OP_RESTOREFH);
5402 }
5403
5404 static int decode_getacl(struct xdr_stream *xdr, struct rpc_rqst *req,
5405              struct nfs_getaclres *res, enum nfs4_acl_type type)
5406 {
5407     unsigned int savep;
5408     uint32_t attrlen,
5409          bitmap[3] = {0};
5410     int status;
5411
5412     res->acl_len = 0;
5413     if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
5414         goto out;
5415
5416     xdr_enter_page(xdr, xdr->buf->page_len);
5417
5418     if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
5419         goto out;
5420     if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
5421         goto out;
5422
5423     switch (type) {
5424     default:
5425         if (unlikely(bitmap[0] & (FATTR4_WORD0_ACL - 1U)))
5426             return -EIO;
5427         if (!(bitmap[0] & FATTR4_WORD0_ACL))
5428             return -EOPNOTSUPP;
5429         break;
5430     case NFS4ACL_DACL:
5431         if (unlikely(bitmap[0] || bitmap[1] & (FATTR4_WORD1_DACL - 1U)))
5432             return -EIO;
5433         if (!(bitmap[1] & FATTR4_WORD1_DACL))
5434             return -EOPNOTSUPP;
5435         break;
5436     case NFS4ACL_SACL:
5437         if (unlikely(bitmap[0] || bitmap[1] & (FATTR4_WORD1_SACL - 1U)))
5438             return -EIO;
5439         if (!(bitmap[1] & FATTR4_WORD1_SACL))
5440             return -EOPNOTSUPP;
5441     }
5442
5443     /* The bitmap (xdr len + bitmaps) and the attr xdr len words
5444      * are stored with the acl data to handle the problem of
5445      * variable length bitmaps.*/
5446     res->acl_data_offset = xdr_page_pos(xdr);
5447     res->acl_len = attrlen;
5448
5449     /* Check for receive buffer overflow */
5450     if (res->acl_len > xdr_stream_remaining(xdr) ||
5451         res->acl_len + res->acl_data_offset > xdr->buf->page_len) {
5452         res->acl_flags |= NFS4_ACL_TRUNC;
5453         dprintk("NFS: acl reply: attrlen %u > page_len %zu\n",
5454             attrlen, xdr_stream_remaining(xdr));
5455     }
5456 out:
5457     return status;
5458 }
5459
5460 static int
5461 decode_savefh(struct xdr_stream *xdr)
5462 {
5463     return decode_op_hdr(xdr, OP_SAVEFH);
5464 }
5465
5466 static int decode_setattr(struct xdr_stream *xdr)
5467 {
5468     int status;
5469
5470     status = decode_op_hdr(xdr, OP_SETATTR);
5471     if (status)
5472         return status;
5473     if (decode_bitmap4(xdr, NULL, 0) >= 0)
5474         return 0;
5475     return -EIO;
5476 }
5477
5478 static int decode_setclientid(struct xdr_stream *xdr, struct nfs4_setclientid_res *res)
5479 {
5480     __be32 *p;
5481     uint32_t opnum;
5482     int32_t nfserr;
5483
5484     p = xdr_inline_decode(xdr, 8);
5485     if (unlikely(!p))
5486         return -EIO;
5487     opnum = be32_to_cpup(p++);
5488     if (opnum != OP_SETCLIENTID) {
5489         dprintk("nfs: decode_setclientid: Server returned operation"
5490             " %d\n", opnum);
5491         return -EIO;
5492     }
5493     nfserr = be32_to_cpup(p);
5494     if (nfserr == NFS_OK) {
5495         p = xdr_inline_decode(xdr, 8 + NFS4_VERIFIER_SIZE);
5496         if (unlikely(!p))
5497             return -EIO;
5498         p = xdr_decode_hyper(p, &res->clientid);
5499         memcpy(res->confirm.data, p, NFS4_VERIFIER_SIZE);
5500     } else if (nfserr == NFSERR_CLID_INUSE) {
5501         uint32_t len;
5502
5503         /* skip netid string */
5504         p = xdr_inline_decode(xdr, 4);
5505         if (unlikely(!p))
5506             return -EIO;
5507         len = be32_to_cpup(p);
5508         p = xdr_inline_decode(xdr, len);
5509         if (unlikely(!p))
5510             return -EIO;
5511
5512         /* skip uaddr string */
5513         p = xdr_inline_decode(xdr, 4);
5514         if (unlikely(!p))
5515             return -EIO;
5516         len = be32_to_cpup(p);
5517         p = xdr_inline_decode(xdr, len);
5518         if (unlikely(!p))
5519             return -EIO;
5520         return -NFSERR_CLID_INUSE;
5521     } else
5522         return nfs4_stat_to_errno(nfserr);
5523
5524     return 0;
5525 }
5526
5527 static int decode_setclientid_confirm(struct xdr_stream *xdr)
5528 {
5529     return decode_op_hdr(xdr, OP_SETCLIENTID_CONFIRM);
5530 }
5531
5532 static int decode_write(struct xdr_stream *xdr, struct nfs_pgio_res *res)
5533 {
5534     __be32 *p;
5535     int status;
5536
5537     status = decode_op_hdr(xdr, OP_WRITE);
5538     if (status)
5539         return status;
5540
5541     p = xdr_inline_decode(xdr, 8);
5542     if (unlikely(!p))
5543         return -EIO;
5544     res->count = be32_to_cpup(p++);
5545     res->verf->committed = be32_to_cpup(p++);
5546     return decode_write_verifier(xdr, &res->verf->verifier);
5547 }
5548
5549 static int decode_delegreturn(struct xdr_stream *xdr)
5550 {
5551     return decode_op_hdr(xdr, OP_DELEGRETURN);
5552 }
5553
5554 static int decode_secinfo_gss(struct xdr_stream *xdr,
5555                   struct nfs4_secinfo4 *flavor)
5556 {
5557     u32 oid_len;
5558     __be32 *p;
5559
5560     p = xdr_inline_decode(xdr, 4);
5561     if (unlikely(!p))
5562         return -EIO;
5563     oid_len = be32_to_cpup(p);
5564     if (oid_len > GSS_OID_MAX_LEN)
5565         return -EINVAL;
5566
5567     p = xdr_inline_decode(xdr, oid_len);
5568     if (unlikely(!p))
5569         return -EIO;
5570     memcpy(flavor->flavor_info.oid.data, p, oid_len);
5571     flavor->flavor_info.oid.len = oid_len;
5572
5573     p = xdr_inline_decode(xdr, 8);
5574     if (unlikely(!p))
5575         return -EIO;
5576     flavor->flavor_info.qop = be32_to_cpup(p++);
5577     flavor->flavor_info.service = be32_to_cpup(p);
5578
5579     return 0;
5580 }
5581
5582 static int decode_secinfo_common(struct xdr_stream *xdr, struct nfs4_secinfo_res *res)
5583 {
5584     struct nfs4_secinfo4 *sec_flavor;
5585     unsigned int i, num_flavors;
5586     int status;
5587     __be32 *p;
5588
5589     p = xdr_inline_decode(xdr, 4);
5590     if (unlikely(!p))
5591         return -EIO;
5592
5593     res->flavors->num_flavors = 0;
5594     num_flavors = be32_to_cpup(p);
5595
5596     for (i = 0; i < num_flavors; i++) {
5597         sec_flavor = &res->flavors->flavors[i];
5598         if ((char *)&sec_flavor[1] - (char *)res->flavors > PAGE_SIZE)
5599             break;
5600
5601         p = xdr_inline_decode(xdr, 4);
5602         if (unlikely(!p))
5603             return -EIO;
5604         sec_flavor->flavor = be32_to_cpup(p);
5605
5606         if (sec_flavor->flavor == RPC_AUTH_GSS) {
5607             status = decode_secinfo_gss(xdr, sec_flavor);
5608             if (status)
5609                 goto out;
5610         }
5611         res->flavors->num_flavors++;
5612     }
5613
5614     status = 0;
5615 out:
5616     return status;
5617 }
5618
5619 static int decode_secinfo(struct xdr_stream *xdr, struct nfs4_secinfo_res *res)
5620 {
5621     int status = decode_op_hdr(xdr, OP_SECINFO);
5622     if (status)
5623         return status;
5624     return decode_secinfo_common(xdr, res);
5625 }
5626
5627 #if defined(CONFIG_NFS_V4_1)
5628 static int decode_secinfo_no_name(struct xdr_stream *xdr, struct nfs4_secinfo_res *res)
5629 {
5630     int status = decode_op_hdr(xdr, OP_SECINFO_NO_NAME);
5631     if (status)
5632         return status;
5633     return decode_secinfo_common(xdr, res);
5634 }
5635
5636 static int decode_op_map(struct xdr_stream *xdr, struct nfs4_op_map *op_map)
5637 {
5638     if (xdr_stream_decode_uint32_array(xdr, op_map->u.words,
5639                        ARRAY_SIZE(op_map->u.words)) < 0)
5640         return -EIO;
5641     return 0;
5642 }
5643
5644 static int decode_exchange_id(struct xdr_stream *xdr,
5645                   struct nfs41_exchange_id_res *res)
5646 {
5647     __be32 *p;
5648     uint32_t dummy;
5649     char *dummy_str;
5650     int status;
5651     uint32_t impl_id_count;
5652
5653     status = decode_op_hdr(xdr, OP_EXCHANGE_ID);
5654     if (status)
5655         return status;
5656
5657     p = xdr_inline_decode(xdr, 8);
5658     if (unlikely(!p))
5659         return -EIO;
5660     xdr_decode_hyper(p, &res->clientid);
5661     p = xdr_inline_decode(xdr, 12);
5662     if (unlikely(!p))
5663         return -EIO;
5664     res->seqid = be32_to_cpup(p++);
5665     res->flags = be32_to_cpup(p++);
5666
5667     res->state_protect.how = be32_to_cpup(p);
5668     switch (res->state_protect.how) {
5669     case SP4_NONE:
5670         break;
5671     case SP4_MACH_CRED:
5672         status = decode_op_map(xdr, &res->state_protect.enforce);
5673         if (status)
5674             return status;
5675         status = decode_op_map(xdr, &res->state_protect.allow);
5676         if (status)
5677             return status;
5678         break;
5679     default:
5680         WARN_ON_ONCE(1);
5681         return -EIO;
5682     }
5683
5684     /* server_owner4.so_minor_id */
5685     p = xdr_inline_decode(xdr, 8);
5686     if (unlikely(!p))
5687         return -EIO;
5688     p = xdr_decode_hyper(p, &res->server_owner->minor_id);
5689
5690     /* server_owner4.so_major_id */
5691     status = decode_opaque_inline(xdr, &dummy, &dummy_str);
5692     if (unlikely(status))
5693         return status;
5694     memcpy(res->server_owner->major_id, dummy_str, dummy);
5695     res->server_owner->major_id_sz = dummy;
5696
5697     /* server_scope4 */
5698     status = decode_opaque_inline(xdr, &dummy, &dummy_str);
5699     if (unlikely(status))
5700         return status;
5701     memcpy(res->server_scope->server_scope, dummy_str, dummy);
5702     res->server_scope->server_scope_sz = dummy;
5703
5704     /* Implementation Id */
5705     p = xdr_inline_decode(xdr, 4);
5706     if (unlikely(!p))
5707         return -EIO;
5708     impl_id_count = be32_to_cpup(p++);
5709
5710     if (impl_id_count) {
5711         /* nii_domain */
5712         status = decode_opaque_inline(xdr, &dummy, &dummy_str);
5713         if (unlikely(status))
5714             return status;
5715         memcpy(res->impl_id->domain, dummy_str, dummy);
5716
5717         /* nii_name */
5718         status = decode_opaque_inline(xdr, &dummy, &dummy_str);
5719         if (unlikely(status))
5720             return status;
5721         memcpy(res->impl_id->name, dummy_str, dummy);
5722
5723         /* nii_date */
5724         p = xdr_inline_decode(xdr, 12);
5725         if (unlikely(!p))
5726             return -EIO;
5727         p = xdr_decode_hyper(p, &res->impl_id->date.seconds);
5728         res->impl_id->date.nseconds = be32_to_cpup(p);
5729
5730         /* if there's more than one entry, ignore the rest */
5731     }
5732     return 0;
5733 }
5734
5735 static int decode_chan_attrs(struct xdr_stream *xdr,
5736                  struct nfs4_channel_attrs *attrs)
5737 {
5738     __be32 *p;
5739     u32 nr_attrs, val;
5740
5741     p = xdr_inline_decode(xdr, 28);
5742     if (unlikely(!p))
5743         return -EIO;
5744     val = be32_to_cpup(p++);    /* headerpadsz */
5745     if (val)
5746         return -EINVAL;     /* no support for header padding yet */
5747     attrs->max_rqst_sz = be32_to_cpup(p++);
5748     attrs->max_resp_sz = be32_to_cpup(p++);
5749     attrs->max_resp_sz_cached = be32_to_cpup(p++);
5750     attrs->max_ops = be32_to_cpup(p++);
5751     attrs->max_reqs = be32_to_cpup(p++);
5752     nr_attrs = be32_to_cpup(p);
5753     if (unlikely(nr_attrs > 1)) {
5754         printk(KERN_WARNING "NFS: %s: Invalid rdma channel attrs "
5755             "count %u\n", __func__, nr_attrs);
5756         return -EINVAL;
5757     }
5758     if (nr_attrs == 1) {
5759         p = xdr_inline_decode(xdr, 4); /* skip rdma_attrs */
5760         if (unlikely(!p))
5761             return -EIO;
5762     }
5763     return 0;
5764 }
5765
5766 static int decode_sessionid(struct xdr_stream *xdr, struct nfs4_sessionid *sid)
5767 {
5768     return decode_opaque_fixed(xdr, sid->data, NFS4_MAX_SESSIONID_LEN);
5769 }
5770
5771 static int decode_bind_conn_to_session(struct xdr_stream *xdr,
5772                 struct nfs41_bind_conn_to_session_res *res)
5773 {
5774     __be32 *p;
5775     int status;
5776
5777     status = decode_op_hdr(xdr, OP_BIND_CONN_TO_SESSION);
5778     if (!status)
5779         status = decode_sessionid(xdr, &res->sessionid);
5780     if (unlikely(status))
5781         return status;
5782
5783     /* dir flags, rdma mode bool */
5784     p = xdr_inline_decode(xdr, 8);
5785     if (unlikely(!p))
5786         return -EIO;
5787
5788     res->dir = be32_to_cpup(p++);
5789     if (res->dir == 0 || res->dir > NFS4_CDFS4_BOTH)
5790         return -EIO;
5791     if (be32_to_cpup(p) == 0)
5792         res->use_conn_in_rdma_mode = false;
5793     else
5794         res->use_conn_in_rdma_mode = true;
5795
5796     return 0;
5797 }
5798
5799 static int decode_create_session(struct xdr_stream *xdr,
5800                  struct nfs41_create_session_res *res)
5801 {
5802     __be32 *p;
5803     int status;
5804
5805     status = decode_op_hdr(xdr, OP_CREATE_SESSION);
5806     if (!status)
5807         status = decode_sessionid(xdr, &res->sessionid);
5808     if (unlikely(status))
5809         return status;
5810
5811     /* seqid, flags */
5812     p = xdr_inline_decode(xdr, 8);
5813     if (unlikely(!p))
5814         return -EIO;
5815     res->seqid = be32_to_cpup(p++);
5816     res->flags = be32_to_cpup(p);
5817
5818     /* Channel attributes */
5819     status = decode_chan_attrs(xdr, &res->fc_attrs);
5820     if (!status)
5821         status = decode_chan_attrs(xdr, &res->bc_attrs);
5822     return status;
5823 }
5824
5825 static int decode_destroy_session(struct xdr_stream *xdr, void *dummy)
5826 {
5827     return decode_op_hdr(xdr, OP_DESTROY_SESSION);
5828 }
5829
5830 static int decode_destroy_clientid(struct xdr_stream *xdr, void *dummy)
5831 {
5832     return decode_op_hdr(xdr, OP_DESTROY_CLIENTID);
5833 }
5834
5835 static int decode_reclaim_complete(struct xdr_stream *xdr, void *dummy)
5836 {
5837     return decode_op_hdr(xdr, OP_RECLAIM_COMPLETE);
5838 }
5839 #endif /* CONFIG_NFS_V4_1 */
5840
5841 static int decode_sequence(struct xdr_stream *xdr,
5842                struct nfs4_sequence_res *res,
5843                struct rpc_rqst *rqstp)
5844 {
5845 #if defined(CONFIG_NFS_V4_1)
5846     struct nfs4_session *session;
5847     struct nfs4_sessionid id;
5848     u32 dummy;
5849     int status;
5850     __be32 *p;
5851
5852     if (res->sr_slot == NULL)
5853         return 0;
5854     if (!res->sr_slot->table->session)
5855         return 0;
5856
5857     status = decode_op_hdr(xdr, OP_SEQUENCE);
5858     if (!status)
5859         status = decode_sessionid(xdr, &id);
5860     if (unlikely(status))
5861         goto out_err;
5862
5863     /*
5864      * If the server returns different values for sessionID, slotID or
5865      * sequence number, the server is looney tunes.
5866      */
5867     status = -EREMOTEIO;
5868     session = res->sr_slot->table->session;
5869
5870     if (memcmp(id.data, session->sess_id.data,
5871            NFS4_MAX_SESSIONID_LEN)) {
5872         dprintk("%s Invalid session id\n", __func__);
5873         goto out_err;
5874     }
5875
5876     p = xdr_inline_decode(xdr, 20);
5877     if (unlikely(!p))
5878         goto out_overflow;
5879
5880     /* seqid */
5881     dummy = be32_to_cpup(p++);
5882     if (dummy != res->sr_slot->seq_nr) {
5883         dprintk("%s Invalid sequence number\n", __func__);
5884         goto out_err;
5885     }
5886     /* slot id */
5887     dummy = be32_to_cpup(p++);
5888     if (dummy != res->sr_slot->slot_nr) {
5889         dprintk("%s Invalid slot id\n", __func__);
5890         goto out_err;
5891     }
5892     /* highest slot id */
5893     res->sr_highest_slotid = be32_to_cpup(p++);
5894     /* target highest slot id */
5895     res->sr_target_highest_slotid = be32_to_cpup(p++);
5896     /* result flags */
5897     res->sr_status_flags = be32_to_cpup(p);
5898     status = 0;
5899 out_err:
5900     res->sr_status = status;
5901     return status;
5902 out_overflow:
5903     status = -EIO;
5904     goto out_err;
5905 #else  /* CONFIG_NFS_V4_1 */
5906     return 0;
5907 #endif /* CONFIG_NFS_V4_1 */
5908 }
5909
5910 #if defined(CONFIG_NFS_V4_1)
5911 static int decode_layout_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
5912 {
5913     stateid->type = NFS4_LAYOUT_STATEID_TYPE;
5914     return decode_stateid(xdr, stateid);
5915 }
5916
5917 static int decode_getdeviceinfo(struct xdr_stream *xdr,
5918                 struct nfs4_getdeviceinfo_res *res)
5919 {
5920     struct pnfs_device *pdev = res->pdev;
5921     __be32 *p;
5922     uint32_t len, type;
5923     int status;
5924
5925     status = decode_op_hdr(xdr, OP_GETDEVICEINFO);
5926     if (status) {
5927         if (status == -ETOOSMALL) {
5928             p = xdr_inline_decode(xdr, 4);
5929             if (unlikely(!p))
5930                 return -EIO;
5931             pdev->mincount = be32_to_cpup(p);
5932             dprintk("%s: Min count too small. mincnt = %u\n",
5933                 __func__, pdev->mincount);
5934         }
5935         return status;
5936     }
5937
5938     p = xdr_inline_decode(xdr, 8);
5939     if (unlikely(!p))
5940         return -EIO;
5941     type = be32_to_cpup(p++);
5942     if (type != pdev->layout_type) {
5943         dprintk("%s: layout mismatch req: %u pdev: %u\n",
5944             __func__, pdev->layout_type, type);
5945         return -EINVAL;
5946     }
5947     /*
5948      * Get the length of the opaque device_addr4. xdr_read_pages places
5949      * the opaque device_addr4 in the xdr_buf->pages (pnfs_device->pages)
5950      * and places the remaining xdr data in xdr_buf->tail
5951      */
5952     pdev->mincount = be32_to_cpup(p);
5953     if (xdr_read_pages(xdr, pdev->mincount) != pdev->mincount)
5954         return -EIO;
5955
5956     /* Parse notification bitmap, verifying that it is zero. */
5957     p = xdr_inline_decode(xdr, 4);
5958     if (unlikely(!p))
5959         return -EIO;
5960     len = be32_to_cpup(p);
5961     if (len) {
5962         uint32_t i;
5963
5964         p = xdr_inline_decode(xdr, 4 * len);
5965         if (unlikely(!p))
5966             return -EIO;
5967
5968         res->notification = be32_to_cpup(p++);
5969         for (i = 1; i < len; i++) {
5970             if (be32_to_cpup(p++)) {
5971                 dprintk("%s: unsupported notification\n",
5972                     __func__);
5973                 return -EIO;
5974             }
5975         }
5976     }
5977     return 0;
5978 }
5979
5980 static int decode_layoutget(struct xdr_stream *xdr, struct rpc_rqst *req,
5981                 struct nfs4_layoutget_res *res)
5982 {
5983     __be32 *p;
5984     int status;
5985     u32 layout_count;
5986     u32 recvd;
5987
5988     status = decode_op_hdr(xdr, OP_LAYOUTGET);
5989     if (status)
5990         goto out;
5991     p = xdr_inline_decode(xdr, 4);
5992     if (unlikely(!p))
5993         goto out_overflow;
5994     res->return_on_close = be32_to_cpup(p);
5995     decode_layout_stateid(xdr, &res->stateid);
5996     p = xdr_inline_decode(xdr, 4);
5997     if (unlikely(!p))
5998         goto out_overflow;
5999     layout_count = be32_to_cpup(p);
6000     if (!layout_count) {
6001         dprintk("%s: server responded with empty layout array\n",
6002             __func__);
6003         status = -EINVAL;
6004         goto out;
6005     }
6006
6007     p = xdr_inline_decode(xdr, 28);
6008     if (unlikely(!p))
6009         goto out_overflow;
6010     p = xdr_decode_hyper(p, &res->range.offset);
6011     p = xdr_decode_hyper(p, &res->range.length);
6012     res->range.iomode = be32_to_cpup(p++);
6013     res->type = be32_to_cpup(p++);
6014     res->layoutp->len = be32_to_cpup(p);
6015
6016     dprintk("%s roff:%lu rlen:%lu riomode:%d, lo_type:0x%x, lo.len:%d\n",
6017         __func__,
6018         (unsigned long)res->range.offset,
6019         (unsigned long)res->range.length,
6020         res->range.iomode,
6021         res->type,
6022         res->layoutp->len);
6023
6024     recvd = xdr_read_pages(xdr, res->layoutp->len);
6025     if (res->layoutp->len > recvd) {
6026         dprintk("NFS: server cheating in layoutget reply: "
6027                 "layout len %u > recvd %u\n",
6028                 res->layoutp->len, recvd);
6029         status = -EINVAL;
6030         goto out;
6031     }
6032
6033     if (layout_count > 1) {
6034         /* We only handle a length one array at the moment.  Any
6035          * further entries are just ignored.  Note that this means
6036          * the client may see a response that is less than the
6037          * minimum it requested.
6038          */
6039         dprintk("%s: server responded with %d layouts, dropping tail\n",
6040             __func__, layout_count);
6041     }
6042
6043 out:
6044     res->status = status;
6045     return status;
6046 out_overflow:
6047     status = -EIO;
6048     goto out;
6049 }
6050
6051 static int decode_layoutreturn(struct xdr_stream *xdr,
6052                    struct nfs4_layoutreturn_res *res)
6053 {
6054     __be32 *p;
6055     int status;
6056
6057     status = decode_op_hdr(xdr, OP_LAYOUTRETURN);
6058     if (status)
6059         return status;
6060     p = xdr_inline_decode(xdr, 4);
6061     if (unlikely(!p))
6062         return -EIO;
6063     res->lrs_present = be32_to_cpup(p);
6064     if (res->lrs_present)
6065         status = decode_layout_stateid(xdr, &res->stateid);
6066     else
6067         nfs4_stateid_copy(&res->stateid, &invalid_stateid);
6068     return status;
6069 }
6070
6071 static int decode_layoutcommit(struct xdr_stream *xdr,
6072                    struct rpc_rqst *req,
6073                    struct nfs4_layoutcommit_res *res)
6074 {
6075     __be32 *p;
6076     __u32 sizechanged;
6077     int status;
6078
6079     status = decode_op_hdr(xdr, OP_LAYOUTCOMMIT);
6080     res->status = status;
6081     if (status)
6082         return status;
6083
6084     p = xdr_inline_decode(xdr, 4);
6085     if (unlikely(!p))
6086         return -EIO;
6087     sizechanged = be32_to_cpup(p);
6088
6089     if (sizechanged) {
6090         /* throw away new size */
6091         p = xdr_inline_decode(xdr, 8);
6092         if (unlikely(!p))
6093             return -EIO;
6094     }
6095     return 0;
6096 }
6097
6098 static int decode_test_stateid(struct xdr_stream *xdr,
6099                    struct nfs41_test_stateid_res *res)
6100 {
6101     __be32 *p;
6102     int status;
6103     int num_res;
6104
6105     status = decode_op_hdr(xdr, OP_TEST_STATEID);
6106     if (status)
6107         return status;
6108
6109     p = xdr_inline_decode(xdr, 4);
6110     if (unlikely(!p))
6111         return -EIO;
6112     num_res = be32_to_cpup(p++);
6113     if (num_res != 1)
6114         return -EIO;
6115
6116     p = xdr_inline_decode(xdr, 4);
6117     if (unlikely(!p))
6118         return -EIO;
6119     res->status = be32_to_cpup(p++);
6120
6121     return status;
6122 }
6123
6124 static int decode_free_stateid(struct xdr_stream *xdr,
6125                    struct nfs41_free_stateid_res *res)
6126 {
6127     res->status = decode_op_hdr(xdr, OP_FREE_STATEID);
6128     return res->status;
6129 }
6130 #else
6131 static inline
6132 int decode_layoutreturn(struct xdr_stream *xdr,
6133                    struct nfs4_layoutreturn_res *res)
6134 {
6135     return 0;
6136 }
6137
6138 static int decode_layoutget(struct xdr_stream *xdr, struct rpc_rqst *req,
6139                 struct nfs4_layoutget_res *res)
6140 {
6141     return 0;
6142 }
6143
6144 #endif /* CONFIG_NFS_V4_1 */
6145
6146 /*
6147  * END OF "GENERIC" DECODE ROUTINES.
6148  */
6149
6150 /*
6151  * Decode OPEN_DOWNGRADE response
6152  */
6153 static int nfs4_xdr_dec_open_downgrade(struct rpc_rqst *rqstp,
6154                        struct xdr_stream *xdr,
6155                        void *data)
6156 {
6157     struct nfs_closeres *res = data;
6158     struct compound_hdr hdr;
6159     int status;
6160
6161     status = decode_compound_hdr(xdr, &hdr);
6162     if (status)
6163         goto out;
6164     status = decode_sequence(xdr, &res->seq_res, rqstp);
6165     if (status)
6166         goto out;
6167     status = decode_putfh(xdr);
6168     if (status)
6169         goto out;
6170     if (res->lr_res) {
6171         status = decode_layoutreturn(xdr, res->lr_res);
6172         res->lr_ret = status;
6173         if (status)
6174             goto out;
6175     }
6176     status = decode_open_downgrade(xdr, res);
6177 out:
6178     return status;
6179 }
6180
6181 /*
6182  * Decode ACCESS response
6183  */
6184 static int nfs4_xdr_dec_access(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6185                    void *data)
6186 {
6187     struct nfs4_accessres *res = data;
6188     struct compound_hdr hdr;
6189     int status;
6190
6191     status = decode_compound_hdr(xdr, &hdr);
6192     if (status)
6193         goto out;
6194     status = decode_sequence(xdr, &res->seq_res, rqstp);
6195     if (status)
6196         goto out;
6197     status = decode_putfh(xdr);
6198     if (status != 0)
6199         goto out;
6200     status = decode_access(xdr, &res->supported, &res->access);
6201     if (status != 0)
6202         goto out;
6203     if (res->fattr)
6204         decode_getfattr(xdr, res->fattr, res->server);
6205 out:
6206     return status;
6207 }
6208
6209 /*
6210  * Decode LOOKUP response
6211  */
6212 static int nfs4_xdr_dec_lookup(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6213                    void *data)
6214 {
6215     struct nfs4_lookup_res *res = data;
6216     struct compound_hdr hdr;
6217     int status;
6218
6219     status = decode_compound_hdr(xdr, &hdr);
6220     if (status)
6221         goto out;
6222     status = decode_sequence(xdr, &res->seq_res, rqstp);
6223     if (status)
6224         goto out;
6225     status = decode_putfh(xdr);
6226     if (status)
6227         goto out;
6228     status = decode_lookup(xdr);
6229     if (status)
6230         goto out;
6231     status = decode_getfh(xdr, res->fh);
6232     if (status)
6233         goto out;
6234     status = decode_getfattr(xdr, res->fattr, res->server);
6235 out:
6236     return status;
6237 }
6238
6239 /*
6240  * Decode LOOKUPP response
6241  */
6242 static int nfs4_xdr_dec_lookupp(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6243         void *data)
6244 {
6245     struct nfs4_lookupp_res *res = data;
6246     struct compound_hdr hdr;
6247     int status;
6248
6249     status = decode_compound_hdr(xdr, &hdr);
6250     if (status)
6251         goto out;
6252     status = decode_sequence(xdr, &res->seq_res, rqstp);
6253     if (status)
6254         goto out;
6255     status = decode_putfh(xdr);
6256     if (status)
6257         goto out;
6258     status = decode_lookupp(xdr);
6259     if (status)
6260         goto out;
6261     status = decode_getfh(xdr, res->fh);
6262     if (status)
6263         goto out;
6264     status = decode_getfattr(xdr, res->fattr, res->server);
6265 out:
6266     return status;
6267 }
6268
6269 /*
6270  * Decode LOOKUP_ROOT response
6271  */
6272 static int nfs4_xdr_dec_lookup_root(struct rpc_rqst *rqstp,
6273                     struct xdr_stream *xdr,
6274                     void *data)
6275 {
6276     struct nfs4_lookup_res *res = data;
6277     struct compound_hdr hdr;
6278     int status;
6279
6280     status = decode_compound_hdr(xdr, &hdr);
6281     if (status)
6282         goto out;
6283     status = decode_sequence(xdr, &res->seq_res, rqstp);
6284     if (status)
6285         goto out;
6286     status = decode_putrootfh(xdr);
6287     if (status)
6288         goto out;
6289     status = decode_getfh(xdr, res->fh);
6290     if (status == 0)
6291         status = decode_getfattr(xdr, res->fattr, res->server);
6292 out:
6293     return status;
6294 }
6295
6296 /*
6297  * Decode REMOVE response
6298  */
6299 static int nfs4_xdr_dec_remove(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6300                    void *data)
6301 {
6302     struct nfs_removeres *res = data;
6303     struct compound_hdr hdr;
6304     int status;
6305
6306     status = decode_compound_hdr(xdr, &hdr);
6307     if (status)
6308         goto out;
6309     status = decode_sequence(xdr, &res->seq_res, rqstp);
6310     if (status)
6311         goto out;
6312     status = decode_putfh(xdr);
6313     if (status)
6314         goto out;
6315     status = decode_remove(xdr, &res->cinfo);
6316 out:
6317     return status;
6318 }
6319
6320 /*
6321  * Decode RENAME response
6322  */
6323 static int nfs4_xdr_dec_rename(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6324                    void *data)
6325 {
6326     struct nfs_renameres *res = data;
6327     struct compound_hdr hdr;
6328     int status;
6329
6330     status = decode_compound_hdr(xdr, &hdr);
6331     if (status)
6332         goto out;
6333     status = decode_sequence(xdr, &res->seq_res, rqstp);
6334     if (status)
6335         goto out;
6336     status = decode_putfh(xdr);
6337     if (status)
6338         goto out;
6339     status = decode_savefh(xdr);
6340     if (status)
6341         goto out;
6342     status = decode_putfh(xdr);
6343     if (status)
6344         goto out;
6345     status = decode_rename(xdr, &res->old_cinfo, &res->new_cinfo);
6346 out:
6347     return status;
6348 }
6349
6350 /*
6351  * Decode LINK response
6352  */
6353 static int nfs4_xdr_dec_link(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6354                  void *data)
6355 {
6356     struct nfs4_link_res *res = data;
6357     struct compound_hdr hdr;
6358     int status;
6359
6360     status = decode_compound_hdr(xdr, &hdr);
6361     if (status)
6362         goto out;
6363     status = decode_sequence(xdr, &res->seq_res, rqstp);
6364     if (status)
6365         goto out;
6366     status = decode_putfh(xdr);
6367     if (status)
6368         goto out;
6369     status = decode_savefh(xdr);
6370     if (status)
6371         goto out;
6372     status = decode_putfh(xdr);
6373     if (status)
6374         goto out;
6375     status = decode_link(xdr, &res->cinfo);
6376     if (status)
6377         goto out;
6378     /*
6379      * Note order: OP_LINK leaves the directory as the current
6380      *             filehandle.
6381      */
6382     status = decode_restorefh(xdr);
6383     if (status)
6384         goto out;
6385     decode_getfattr(xdr, res->fattr, res->server);
6386 out:
6387     return status;
6388 }
6389
6390 /*
6391  * Decode CREATE response
6392  */
6393 static int nfs4_xdr_dec_create(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6394                    void *data)
6395 {
6396     struct nfs4_create_res *res = data;
6397     struct compound_hdr hdr;
6398     int status;
6399
6400     status = decode_compound_hdr(xdr, &hdr);
6401     if (status)
6402         goto out;
6403     status = decode_sequence(xdr, &res->seq_res, rqstp);
6404     if (status)
6405         goto out;
6406     status = decode_putfh(xdr);
6407     if (status)
6408         goto out;
6409     status = decode_create(xdr, &res->dir_cinfo);
6410     if (status)
6411         goto out;
6412     status = decode_getfh(xdr, res->fh);
6413     if (status)
6414         goto out;
6415     decode_getfattr(xdr, res->fattr, res->server);
6416 out:
6417     return status;
6418 }
6419
6420 /*
6421  * Decode SYMLINK response
6422  */
6423 static int nfs4_xdr_dec_symlink(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6424                 void *res)
6425 {
6426     return nfs4_xdr_dec_create(rqstp, xdr, res);
6427 }
6428
6429 /*
6430  * Decode GETATTR response
6431  */
6432 static int nfs4_xdr_dec_getattr(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6433                 void *data)
6434 {
6435     struct nfs4_getattr_res *res = data;
6436     struct compound_hdr hdr;
6437     int status;
6438
6439     status = decode_compound_hdr(xdr, &hdr);
6440     if (status)
6441         goto out;
6442     status = decode_sequence(xdr, &res->seq_res, rqstp);
6443     if (status)
6444         goto out;
6445     status = decode_putfh(xdr);
6446     if (status)
6447         goto out;
6448     status = decode_getfattr(xdr, res->fattr, res->server);
6449 out:
6450     return status;
6451 }
6452
6453 /*
6454  * Encode an SETACL request
6455  */
6456 static void nfs4_xdr_enc_setacl(struct rpc_rqst *req, struct xdr_stream *xdr,
6457                 const void *data)
6458 {
6459     const struct nfs_setaclargs *args = data;
6460     struct compound_hdr hdr = {
6461         .minorversion = nfs4_xdr_minorversion(&args->seq_args),
6462     };
6463
6464     encode_compound_hdr(xdr, req, &hdr);
6465     encode_sequence(xdr, &args->seq_args, &hdr);
6466     encode_putfh(xdr, args->fh, &hdr);
6467     encode_setacl(xdr, args, &hdr);
6468     encode_nops(&hdr);
6469 }
6470
6471 /*
6472  * Decode SETACL response
6473  */
6474 static int
6475 nfs4_xdr_dec_setacl(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6476             void *data)
6477 {
6478     struct nfs_setaclres *res = data;
6479     struct compound_hdr hdr;
6480     int status;
6481
6482     status = decode_compound_hdr(xdr, &hdr);
6483     if (status)
6484         goto out;
6485     status = decode_sequence(xdr, &res->seq_res, rqstp);
6486     if (status)
6487         goto out;
6488     status = decode_putfh(xdr);
6489     if (status)
6490         goto out;
6491     status = decode_setattr(xdr);
6492 out:
6493     return status;
6494 }
6495
6496 /*
6497  * Decode GETACL response
6498  */
6499 static int
6500 nfs4_xdr_dec_getacl(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6501             void *data)
6502 {
6503     struct nfs_getaclres *res = data;
6504     struct compound_hdr hdr;
6505     int status;
6506
6507     if (res->acl_scratch != NULL)
6508         xdr_set_scratch_page(xdr, res->acl_scratch);
6509     status = decode_compound_hdr(xdr, &hdr);
6510     if (status)
6511         goto out;
6512     status = decode_sequence(xdr, &res->seq_res, rqstp);
6513     if (status)
6514         goto out;
6515     status = decode_putfh(xdr);
6516     if (status)
6517         goto out;
6518     status = decode_getacl(xdr, rqstp, res, res->acl_type);
6519
6520 out:
6521     return status;
6522 }
6523
6524 /*
6525  * Decode CLOSE response
6526  */
6527 static int nfs4_xdr_dec_close(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6528                   void *data)
6529 {
6530     struct nfs_closeres *res = data;
6531     struct compound_hdr hdr;
6532     int status;
6533
6534     status = decode_compound_hdr(xdr, &hdr);
6535     if (status)
6536         goto out;
6537     status = decode_sequence(xdr, &res->seq_res, rqstp);
6538     if (status)
6539         goto out;
6540     status = decode_putfh(xdr);
6541     if (status)
6542         goto out;
6543     if (res->lr_res) {
6544         status = decode_layoutreturn(xdr, res->lr_res);
6545         res->lr_ret = status;
6546         if (status)
6547             goto out;
6548     }
6549     if (res->fattr != NULL) {
6550         status = decode_getfattr(xdr, res->fattr, res->server);
6551         if (status != 0)
6552             goto out;
6553     }
6554     status = decode_close(xdr, res);
6555 out:
6556     return status;
6557 }
6558
6559 /*
6560  * Decode OPEN response
6561  */
6562 static int nfs4_xdr_dec_open(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6563                  void *data)
6564 {
6565     struct nfs_openres *res = data;
6566     struct compound_hdr hdr;
6567     int status;
6568
6569     status = decode_compound_hdr(xdr, &hdr);
6570     if (status)
6571         goto out;
6572     status = decode_sequence(xdr, &res->seq_res, rqstp);
6573     if (status)
6574         goto out;
6575     status = decode_putfh(xdr);
6576     if (status)
6577         goto out;
6578     status = decode_open(xdr, res);
6579     if (status)
6580         goto out;
6581     status = decode_getfh(xdr, &res->fh);
6582     if (status)
6583         goto out;
6584     if (res->access_request)
6585         decode_access(xdr, &res->access_supported, &res->access_result);
6586     decode_getfattr(xdr, res->f_attr, res->server);
6587     if (res->lg_res)
6588         decode_layoutget(xdr, rqstp, res->lg_res);
6589 out:
6590     return status;
6591 }
6592
6593 /*
6594  * Decode OPEN_CONFIRM response
6595  */
6596 static int nfs4_xdr_dec_open_confirm(struct rpc_rqst *rqstp,
6597                      struct xdr_stream *xdr,
6598                      void *data)
6599 {
6600     struct nfs_open_confirmres *res = data;
6601     struct compound_hdr hdr;
6602     int status;
6603
6604     status = decode_compound_hdr(xdr, &hdr);
6605     if (status)
6606         goto out;
6607     status = decode_putfh(xdr);
6608     if (status)
6609         goto out;
6610     status = decode_open_confirm(xdr, res);
6611 out:
6612     return status;
6613 }
6614
6615 /*
6616  * Decode OPEN response
6617  */
6618 static int nfs4_xdr_dec_open_noattr(struct rpc_rqst *rqstp,
6619                     struct xdr_stream *xdr,
6620                     void *data)
6621 {
6622     struct nfs_openres *res = data;
6623     struct compound_hdr hdr;
6624     int status;
6625
6626     status = decode_compound_hdr(xdr, &hdr);
6627     if (status)
6628         goto out;
6629     status = decode_sequence(xdr, &res->seq_res, rqstp);
6630     if (status)
6631         goto out;
6632     status = decode_putfh(xdr);
6633     if (status)
6634         goto out;
6635     status = decode_open(xdr, res);
6636     if (status)
6637         goto out;
6638     if (res->access_request)
6639         decode_access(xdr, &res->access_supported, &res->access_result);
6640     decode_getfattr(xdr, res->f_attr, res->server);
6641     if (res->lg_res)
6642         decode_layoutget(xdr, rqstp, res->lg_res);
6643 out:
6644     return status;
6645 }
6646
6647 /*
6648  * Decode SETATTR response
6649  */
6650 static int nfs4_xdr_dec_setattr(struct rpc_rqst *rqstp,
6651                 struct xdr_stream *xdr,
6652                 void *data)
6653 {
6654     struct nfs_setattrres *res = data;
6655     struct compound_hdr hdr;
6656     int status;
6657
6658     status = decode_compound_hdr(xdr, &hdr);
6659     if (status)
6660         goto out;
6661     status = decode_sequence(xdr, &res->seq_res, rqstp);
6662     if (status)
6663         goto out;
6664     status = decode_putfh(xdr);
6665     if (status)
6666         goto out;
6667     status = decode_setattr(xdr);
6668     if (status)
6669         goto out;
6670     decode_getfattr(xdr, res->fattr, res->server);
6671 out:
6672     return status;
6673 }
6674
6675 /*
6676  * Decode LOCK response
6677  */
6678 static int nfs4_xdr_dec_lock(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6679                  void *data)
6680 {
6681     struct nfs_lock_res *res = data;
6682     struct compound_hdr hdr;
6683     int status;
6684
6685     status = decode_compound_hdr(xdr, &hdr);
6686     if (status)
6687         goto out;
6688     status = decode_sequence(xdr, &res->seq_res, rqstp);
6689     if (status)
6690         goto out;
6691     status = decode_putfh(xdr);
6692     if (status)
6693         goto out;
6694     status = decode_lock(xdr, res);
6695 out:
6696     return status;
6697 }
6698
6699 /*
6700  * Decode LOCKT response
6701  */
6702 static int nfs4_xdr_dec_lockt(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6703                   void *data)
6704 {
6705     struct nfs_lockt_res *res = data;
6706     struct compound_hdr hdr;
6707     int status;
6708
6709     status = decode_compound_hdr(xdr, &hdr);
6710     if (status)
6711         goto out;
6712     status = decode_sequence(xdr, &res->seq_res, rqstp);
6713     if (status)
6714         goto out;
6715     status = decode_putfh(xdr);
6716     if (status)
6717         goto out;
6718     status = decode_lockt(xdr, res);
6719 out:
6720     return status;
6721 }
6722
6723 /*
6724  * Decode LOCKU response
6725  */
6726 static int nfs4_xdr_dec_locku(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6727                   void *data)
6728 {
6729     struct nfs_locku_res *res = data;
6730     struct compound_hdr hdr;
6731     int status;
6732
6733     status = decode_compound_hdr(xdr, &hdr);
6734     if (status)
6735         goto out;
6736     status = decode_sequence(xdr, &res->seq_res, rqstp);
6737     if (status)
6738         goto out;
6739     status = decode_putfh(xdr);
6740     if (status)
6741         goto out;
6742     status = decode_locku(xdr, res);
6743 out:
6744     return status;
6745 }
6746
6747 static int nfs4_xdr_dec_release_lockowner(struct rpc_rqst *rqstp,
6748                       struct xdr_stream *xdr, void *dummy)
6749 {
6750     struct compound_hdr hdr;
6751     int status;
6752
6753     status = decode_compound_hdr(xdr, &hdr);
6754     if (!status)
6755         status = decode_release_lockowner(xdr);
6756     return status;
6757 }
6758
6759 /*
6760  * Decode READLINK response
6761  */
6762 static int nfs4_xdr_dec_readlink(struct rpc_rqst *rqstp,
6763                  struct xdr_stream *xdr,
6764                  void *data)
6765 {
6766     struct nfs4_readlink_res *res = data;
6767     struct compound_hdr hdr;
6768     int status;
6769
6770     status = decode_compound_hdr(xdr, &hdr);
6771     if (status)
6772         goto out;
6773     status = decode_sequence(xdr, &res->seq_res, rqstp);
6774     if (status)
6775         goto out;
6776     status = decode_putfh(xdr);
6777     if (status)
6778         goto out;
6779     status = decode_readlink(xdr, rqstp);
6780 out:
6781     return status;
6782 }
6783
6784 /*
6785  * Decode READDIR response
6786  */
6787 static int nfs4_xdr_dec_readdir(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6788                 void *data)
6789 {
6790     struct nfs4_readdir_res *res = data;
6791     struct compound_hdr hdr;
6792     int status;
6793
6794     status = decode_compound_hdr(xdr, &hdr);
6795     if (status)
6796         goto out;
6797     status = decode_sequence(xdr, &res->seq_res, rqstp);
6798     if (status)
6799         goto out;
6800     status = decode_putfh(xdr);
6801     if (status)
6802         goto out;
6803     status = decode_readdir(xdr, rqstp, res);
6804 out:
6805     return status;
6806 }
6807
6808 /*
6809  * Decode Read response
6810  */
6811 static int nfs4_xdr_dec_read(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6812                  void *data)
6813 {
6814     struct nfs_pgio_res *res = data;
6815     struct compound_hdr hdr;
6816     int status;
6817
6818     status = decode_compound_hdr(xdr, &hdr);
6819     res->op_status = hdr.status;
6820     if (status)
6821         goto out;
6822     status = decode_sequence(xdr, &res->seq_res, rqstp);
6823     if (status)
6824         goto out;
6825     status = decode_putfh(xdr);
6826     if (status)
6827         goto out;
6828     status = decode_read(xdr, rqstp, res);
6829     if (!status)
6830         status = res->count;
6831 out:
6832     return status;
6833 }
6834
6835 /*
6836  * Decode WRITE response
6837  */
6838 static int nfs4_xdr_dec_write(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6839                   void *data)
6840 {
6841     struct nfs_pgio_res *res = data;
6842     struct compound_hdr hdr;
6843     int status;
6844
6845     status = decode_compound_hdr(xdr, &hdr);
6846     res->op_status = hdr.status;
6847     if (status)
6848         goto out;
6849     status = decode_sequence(xdr, &res->seq_res, rqstp);
6850     if (status)
6851         goto out;
6852     status = decode_putfh(xdr);
6853     if (status)
6854         goto out;
6855     status = decode_write(xdr, res);
6856     if (status)
6857         goto out;
6858     if (res->fattr)
6859         decode_getfattr(xdr, res->fattr, res->server);
6860     if (!status)
6861         status = res->count;
6862 out:
6863     return status;
6864 }
6865
6866 /*
6867  * Decode COMMIT response
6868  */
6869 static int nfs4_xdr_dec_commit(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6870                    void *data)
6871 {
6872     struct nfs_commitres *res = data;
6873     struct compound_hdr hdr;
6874     int status;
6875
6876     status = decode_compound_hdr(xdr, &hdr);
6877     res->op_status = hdr.status;
6878     if (status)
6879         goto out;
6880     status = decode_sequence(xdr, &res->seq_res, rqstp);
6881     if (status)
6882         goto out;
6883     status = decode_putfh(xdr);
6884     if (status)
6885         goto out;
6886     status = decode_commit(xdr, res);
6887 out:
6888     return status;
6889 }
6890
6891 /*
6892  * Decode FSINFO response
6893  */
6894 static int nfs4_xdr_dec_fsinfo(struct rpc_rqst *req, struct xdr_stream *xdr,
6895                    void *data)
6896 {
6897     struct nfs4_fsinfo_res *res = data;
6898     struct compound_hdr hdr;
6899     int status;
6900
6901     status = decode_compound_hdr(xdr, &hdr);
6902     if (!status)
6903         status = decode_sequence(xdr, &res->seq_res, req);
6904     if (!status)
6905         status = decode_putfh(xdr);
6906     if (!status)
6907         status = decode_fsinfo(xdr, res->fsinfo);
6908     return status;
6909 }
6910
6911 /*
6912  * Decode PATHCONF response
6913  */
6914 static int nfs4_xdr_dec_pathconf(struct rpc_rqst *req, struct xdr_stream *xdr,
6915                  void *data)
6916 {
6917     struct nfs4_pathconf_res *res = data;
6918     struct compound_hdr hdr;
6919     int status;
6920
6921     status = decode_compound_hdr(xdr, &hdr);
6922     if (!status)
6923         status = decode_sequence(xdr, &res->seq_res, req);
6924     if (!status)
6925         status = decode_putfh(xdr);
6926     if (!status)
6927         status = decode_pathconf(xdr, res->pathconf);
6928     return status;
6929 }
6930
6931 /*
6932  * Decode STATFS response
6933  */
6934 static int nfs4_xdr_dec_statfs(struct rpc_rqst *req, struct xdr_stream *xdr,
6935                    void *data)
6936 {
6937     struct nfs4_statfs_res *res = data;
6938     struct compound_hdr hdr;
6939     int status;
6940
6941     status = decode_compound_hdr(xdr, &hdr);
6942     if (!status)
6943         status = decode_sequence(xdr, &res->seq_res, req);
6944     if (!status)
6945         status = decode_putfh(xdr);
6946     if (!status)
6947         status = decode_statfs(xdr, res->fsstat);
6948     return status;
6949 }
6950
6951 /*
6952  * Decode GETATTR_BITMAP response
6953  */
6954 static int nfs4_xdr_dec_server_caps(struct rpc_rqst *req,
6955                     struct xdr_stream *xdr,
6956                     void *data)
6957 {
6958     struct nfs4_server_caps_res *res = data;
6959     struct compound_hdr hdr;
6960     int status;
6961
6962     status = decode_compound_hdr(xdr, &hdr);
6963     if (status)
6964         goto out;
6965     status = decode_sequence(xdr, &res->seq_res, req);
6966     if (status)
6967         goto out;
6968     status = decode_putfh(xdr);
6969     if (status)
6970         goto out;
6971     status = decode_server_caps(xdr, res);
6972 out:
6973     return status;
6974 }
6975
6976 /*
6977  * Decode RENEW response
6978  */
6979 static int nfs4_xdr_dec_renew(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6980                   void *__unused)
6981 {
6982     struct compound_hdr hdr;
6983     int status;
6984
6985     status = decode_compound_hdr(xdr, &hdr);
6986     if (!status)
6987         status = decode_renew(xdr);
6988     return status;
6989 }
6990
6991 /*
6992  * Decode SETCLIENTID response
6993  */
6994 static int nfs4_xdr_dec_setclientid(struct rpc_rqst *req,
6995                     struct xdr_stream *xdr,
6996                     void *data)
6997 {
6998     struct nfs4_setclientid_res *res = data;
6999     struct compound_hdr hdr;
7000     int status;
7001
7002     status = decode_compound_hdr(xdr, &hdr);
7003     if (!status)
7004         status = decode_setclientid(xdr, res);
7005     return status;
7006 }
7007
7008 /*
7009  * Decode SETCLIENTID_CONFIRM response
7010  */
7011 static int nfs4_xdr_dec_setclientid_confirm(struct rpc_rqst *req,
7012                         struct xdr_stream *xdr,
7013                         void *data)
7014 {
7015     struct compound_hdr hdr;
7016     int status;
7017
7018     status = decode_compound_hdr(xdr, &hdr);
7019     if (!status)
7020         status = decode_setclientid_confirm(xdr);
7021     return status;
7022 }
7023
7024 /*
7025  * Decode DELEGRETURN response
7026  */
7027 static int nfs4_xdr_dec_delegreturn(struct rpc_rqst *rqstp,
7028                     struct xdr_stream *xdr,
7029                     void *data)
7030 {
7031     struct nfs4_delegreturnres *res = data;
7032     struct compound_hdr hdr;
7033     int status;
7034
7035     status = decode_compound_hdr(xdr, &hdr);
7036     if (status)
7037         goto out;
7038     status = decode_sequence(xdr, &res->seq_res, rqstp);
7039     if (status)
7040         goto out;
7041     status = decode_putfh(xdr);
7042     if (status != 0)
7043         goto out;
7044     if (res->lr_res) {
7045         status = decode_layoutreturn(xdr, res->lr_res);
7046         res->lr_ret = status;
7047         if (status)
7048             goto out;
7049     }
7050     if (res->fattr) {
7051         status = decode_getfattr(xdr, res->fattr, res->server);
7052         if (status != 0)
7053             goto out;
7054     }
7055     status = decode_delegreturn(xdr);
7056 out:
7057     return status;
7058 }
7059
7060 /*
7061  * Decode FS_LOCATIONS response
7062  */
7063 static int nfs4_xdr_dec_fs_locations(struct rpc_rqst *req,
7064                      struct xdr_stream *xdr,
7065                      void *data)
7066 {
7067     struct nfs4_fs_locations_res *res = data;
7068     struct compound_hdr hdr;
7069     int status;
7070
7071     status = decode_compound_hdr(xdr, &hdr);
7072     if (status)
7073         goto out;
7074     status = decode_sequence(xdr, &res->seq_res, req);
7075     if (status)
7076         goto out;
7077     status = decode_putfh(xdr);
7078     if (status)
7079         goto out;
7080     if (res->migration) {
7081         xdr_enter_page(xdr, PAGE_SIZE);
7082         status = decode_getfattr_generic(xdr,
7083                     res->fs_locations->fattr,
7084                      NULL, res->fs_locations,
7085                      res->fs_locations->server);
7086         if (status)
7087             goto out;
7088         if (res->renew)
7089             status = decode_renew(xdr);
7090     } else {
7091         status = decode_lookup(xdr);
7092         if (status)
7093             goto out;
7094         xdr_enter_page(xdr, PAGE_SIZE);
7095         status = decode_getfattr_generic(xdr,
7096                     res->fs_locations->fattr,
7097                      NULL, res->fs_locations,
7098                      res->fs_locations->server);
7099     }
7100 out:
7101     return status;
7102 }
7103
7104 /*
7105  * Decode SECINFO response
7106  */
7107 static int nfs4_xdr_dec_secinfo(struct rpc_rqst *rqstp,
7108                 struct xdr_stream *xdr,
7109                 void *data)
7110 {
7111     struct nfs4_secinfo_res *res = data;
7112     struct compound_hdr hdr;
7113     int status;
7114
7115     status = decode_compound_hdr(xdr, &hdr);
7116     if (status)
7117         goto out;
7118     status = decode_sequence(xdr, &res->seq_res, rqstp);
7119     if (status)
7120         goto out;
7121     status = decode_putfh(xdr);
7122     if (status)
7123         goto out;
7124     status = decode_secinfo(xdr, res);
7125 out:
7126     return status;
7127 }
7128
7129 /*
7130  * Decode FSID_PRESENT response
7131  */
7132 static int nfs4_xdr_dec_fsid_present(struct rpc_rqst *rqstp,
7133                      struct xdr_stream *xdr,
7134                      void *data)
7135 {
7136     struct nfs4_fsid_present_res *res = data;
7137     struct compound_hdr hdr;
7138     int status;
7139
7140     status = decode_compound_hdr(xdr, &hdr);
7141     if (status)
7142         goto out;
7143     status = decode_sequence(xdr, &res->seq_res, rqstp);
7144     if (status)
7145         goto out;
7146     status = decode_putfh(xdr);
7147     if (status)
7148         goto out;
7149     status = decode_getfh(xdr, res->fh);
7150     if (status)
7151         goto out;
7152     if (res->renew)
7153         status = decode_renew(xdr);
7154 out:
7155     return status;
7156 }
7157
7158 #if defined(CONFIG_NFS_V4_1)
7159 /*
7160  * Decode BIND_CONN_TO_SESSION response
7161  */
7162 static int nfs4_xdr_dec_bind_conn_to_session(struct rpc_rqst *rqstp,
7163                     struct xdr_stream *xdr,
7164                     void *res)
7165 {
7166     struct compound_hdr hdr;
7167     int status;
7168
7169     status = decode_compound_hdr(xdr, &hdr);
7170     if (!status)
7171         status = decode_bind_conn_to_session(xdr, res);
7172     return status;
7173 }
7174
7175 /*
7176  * Decode EXCHANGE_ID response
7177  */
7178 static int nfs4_xdr_dec_exchange_id(struct rpc_rqst *rqstp,
7179                     struct xdr_stream *xdr,
7180                     void *res)
7181 {
7182     struct compound_hdr hdr;
7183     int status;
7184
7185     status = decode_compound_hdr(xdr, &hdr);
7186     if (!status)
7187         status = decode_exchange_id(xdr, res);
7188     return status;
7189 }
7190
7191 /*
7192  * Decode CREATE_SESSION response
7193  */
7194 static int nfs4_xdr_dec_create_session(struct rpc_rqst *rqstp,
7195                        struct xdr_stream *xdr,
7196                        void *res)
7197 {
7198     struct compound_hdr hdr;
7199     int status;
7200
7201     status = decode_compound_hdr(xdr, &hdr);
7202     if (!status)
7203         status = decode_create_session(xdr, res);
7204     return status;
7205 }
7206
7207 /*
7208  * Decode DESTROY_SESSION response
7209  */
7210 static int nfs4_xdr_dec_destroy_session(struct rpc_rqst *rqstp,
7211                     struct xdr_stream *xdr,
7212                     void *res)
7213 {
7214     struct compound_hdr hdr;
7215     int status;
7216
7217     status = decode_compound_hdr(xdr, &hdr);
7218     if (!status)
7219         status = decode_destroy_session(xdr, res);
7220     return status;
7221 }
7222
7223 /*
7224  * Decode DESTROY_CLIENTID response
7225  */
7226 static int nfs4_xdr_dec_destroy_clientid(struct rpc_rqst *rqstp,
7227                     struct xdr_stream *xdr,
7228                     void *res)
7229 {
7230     struct compound_hdr hdr;
7231     int status;
7232
7233     status = decode_compound_hdr(xdr, &hdr);
7234     if (!status)
7235         status = decode_destroy_clientid(xdr, res);
7236     return status;
7237 }
7238
7239 /*
7240  * Decode SEQUENCE response
7241  */
7242 static int nfs4_xdr_dec_sequence(struct rpc_rqst *rqstp,
7243                  struct xdr_stream *xdr,
7244                  void *res)
7245 {
7246     struct compound_hdr hdr;
7247     int status;
7248
7249     status = decode_compound_hdr(xdr, &hdr);
7250     if (!status)
7251         status = decode_sequence(xdr, res, rqstp);
7252     return status;
7253 }
7254
7255 #endif
7256
7257 /*
7258  * Decode GET_LEASE_TIME response
7259  */
7260 static int nfs4_xdr_dec_get_lease_time(struct rpc_rqst *rqstp,
7261                        struct xdr_stream *xdr,
7262                        void *data)
7263 {
7264     struct nfs4_get_lease_time_res *res = data;
7265     struct compound_hdr hdr;
7266     int status;
7267
7268     status = decode_compound_hdr(xdr, &hdr);
7269     if (!status)
7270         status = decode_sequence(xdr, &res->lr_seq_res, rqstp);
7271     if (!status)
7272         status = decode_putrootfh(xdr);
7273     if (!status)
7274         status = decode_fsinfo(xdr, res->lr_fsinfo);
7275     return status;
7276 }
7277
7278 #ifdef CONFIG_NFS_V4_1
7279
7280 /*
7281  * Decode RECLAIM_COMPLETE response
7282  */
7283 static int nfs4_xdr_dec_reclaim_complete(struct rpc_rqst *rqstp,
7284                      struct xdr_stream *xdr,
7285                      void *data)
7286 {
7287     struct nfs41_reclaim_complete_res *res = data;
7288     struct compound_hdr hdr;
7289     int status;
7290
7291     status = decode_compound_hdr(xdr, &hdr);
7292     if (!status)
7293         status = decode_sequence(xdr, &res->seq_res, rqstp);
7294     if (!status)
7295         status = decode_reclaim_complete(xdr, NULL);
7296     return status;
7297 }
7298
7299 /*
7300  * Decode GETDEVINFO response
7301  */
7302 static int nfs4_xdr_dec_getdeviceinfo(struct rpc_rqst *rqstp,
7303                       struct xdr_stream *xdr,
7304                       void *data)
7305 {
7306     struct nfs4_getdeviceinfo_res *res = data;
7307     struct compound_hdr hdr;
7308     int status;
7309
7310     status = decode_compound_hdr(xdr, &hdr);
7311     if (status != 0)
7312         goto out;
7313     status = decode_sequence(xdr, &res->seq_res, rqstp);
7314     if (status != 0)
7315         goto out;
7316     status = decode_getdeviceinfo(xdr, res);
7317 out:
7318     return status;
7319 }
7320
7321 /*
7322  * Decode LAYOUTGET response
7323  */
7324 static int nfs4_xdr_dec_layoutget(struct rpc_rqst *rqstp,
7325                   struct xdr_stream *xdr,
7326                   void *data)
7327 {
7328     struct nfs4_layoutget_res *res = data;
7329     struct compound_hdr hdr;
7330     int status;
7331
7332     status = decode_compound_hdr(xdr, &hdr);
7333     if (status)
7334         goto out;
7335     status = decode_sequence(xdr, &res->seq_res, rqstp);
7336     if (status)
7337         goto out;
7338     status = decode_putfh(xdr);
7339     if (status)
7340         goto out;
7341     status = decode_layoutget(xdr, rqstp, res);
7342 out:
7343     return status;
7344 }
7345
7346 /*
7347  * Decode LAYOUTRETURN response
7348  */
7349 static int nfs4_xdr_dec_layoutreturn(struct rpc_rqst *rqstp,
7350                      struct xdr_stream *xdr,
7351                      void *data)
7352 {
7353     struct nfs4_layoutreturn_res *res = data;
7354     struct compound_hdr hdr;
7355     int status;
7356
7357     status = decode_compound_hdr(xdr, &hdr);
7358     if (status)
7359         goto out;
7360     status = decode_sequence(xdr, &res->seq_res, rqstp);
7361     if (status)
7362         goto out;
7363     status = decode_putfh(xdr);
7364     if (status)
7365         goto out;
7366     status = decode_layoutreturn(xdr, res);
7367 out:
7368     return status;
7369 }
7370
7371 /*
7372  * Decode LAYOUTCOMMIT response
7373  */
7374 static int nfs4_xdr_dec_layoutcommit(struct rpc_rqst *rqstp,
7375                      struct xdr_stream *xdr,
7376                      void *data)
7377 {
7378     struct nfs4_layoutcommit_res *res = data;
7379     struct compound_hdr hdr;
7380     int status;
7381
7382     status = decode_compound_hdr(xdr, &hdr);
7383     if (status)
7384         goto out;
7385     status = decode_sequence(xdr, &res->seq_res, rqstp);
7386     if (status)
7387         goto out;
7388     status = decode_putfh(xdr);
7389     if (status)
7390         goto out;
7391     status = decode_layoutcommit(xdr, rqstp, res);
7392     if (status)
7393         goto out;
7394     decode_getfattr(xdr, res->fattr, res->server);
7395 out:
7396     return status;
7397 }
7398
7399 /*
7400  * Decode SECINFO_NO_NAME response
7401  */
7402 static int nfs4_xdr_dec_secinfo_no_name(struct rpc_rqst *rqstp,
7403                     struct xdr_stream *xdr,
7404                     void *data)
7405 {
7406     struct nfs4_secinfo_res *res = data;
7407     struct compound_hdr hdr;
7408     int status;
7409
7410     status = decode_compound_hdr(xdr, &hdr);
7411     if (status)
7412         goto out;
7413     status = decode_sequence(xdr, &res->seq_res, rqstp);
7414     if (status)
7415         goto out;
7416     status = decode_putrootfh(xdr);
7417     if (status)
7418         goto out;
7419     status = decode_secinfo_no_name(xdr, res);
7420 out:
7421     return status;
7422 }
7423
7424 /*
7425  * Decode TEST_STATEID response
7426  */
7427 static int nfs4_xdr_dec_test_stateid(struct rpc_rqst *rqstp,
7428                      struct xdr_stream *xdr,
7429                      void *data)
7430 {
7431     struct nfs41_test_stateid_res *res = data;
7432     struct compound_hdr hdr;
7433     int status;
7434
7435     status = decode_compound_hdr(xdr, &hdr);
7436     if (status)
7437         goto out;
7438     status = decode_sequence(xdr, &res->seq_res, rqstp);
7439     if (status)
7440         goto out;
7441     status = decode_test_stateid(xdr, res);
7442 out:
7443     return status;
7444 }
7445
7446 /*
7447  * Decode FREE_STATEID response
7448  */
7449 static int nfs4_xdr_dec_free_stateid(struct rpc_rqst *rqstp,
7450                      struct xdr_stream *xdr,
7451                      void *data)
7452 {
7453     struct nfs41_free_stateid_res *res = data;
7454     struct compound_hdr hdr;
7455     int status;
7456
7457     status = decode_compound_hdr(xdr, &hdr);
7458     if (status)
7459         goto out;
7460     status = decode_sequence(xdr, &res->seq_res, rqstp);
7461     if (status)
7462         goto out;
7463     status = decode_free_stateid(xdr, res);
7464 out:
7465     return status;
7466 }
7467 #endif /* CONFIG_NFS_V4_1 */
7468
7469 /**
7470  * nfs4_decode_dirent - Decode a single NFSv4 directory entry stored in
7471  *                      the local page cache.
7472  * @xdr: XDR stream where entry resides
7473  * @entry: buffer to fill in with entry data
7474  * @plus: boolean indicating whether this should be a readdirplus entry
7475  *
7476  * Returns zero if successful, otherwise a negative errno value is
7477  * returned.
7478  *
7479  * This function is not invoked during READDIR reply decoding, but
7480  * rather whenever an application invokes the getdents(2) system call
7481  * on a directory already in our cache.
7482  */
7483 int nfs4_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry,
7484                bool plus)
7485 {
7486     unsigned int savep;
7487     uint32_t bitmap[3] = {0};
7488     uint32_t len;
7489     uint64_t new_cookie;
7490     __be32 *p = xdr_inline_decode(xdr, 4);
7491     if (unlikely(!p))
7492         return -EAGAIN;
7493     if (*p == xdr_zero) {
7494         p = xdr_inline_decode(xdr, 4);
7495         if (unlikely(!p))
7496             return -EAGAIN;
7497         if (*p == xdr_zero)
7498             return -EAGAIN;
7499         entry->eof = 1;
7500         return -EBADCOOKIE;
7501     }
7502
7503     p = xdr_inline_decode(xdr, 12);
7504     if (unlikely(!p))
7505         return -EAGAIN;
7506     p = xdr_decode_hyper(p, &new_cookie);
7507     entry->len = be32_to_cpup(p);
7508
7509     p = xdr_inline_decode(xdr, entry->len);
7510     if (unlikely(!p))
7511         return -EAGAIN;
7512     entry->name = (const char *) p;
7513
7514     /*
7515      * In case the server doesn't return an inode number,
7516      * we fake one here.  (We don't use inode number 0,
7517      * since glibc seems to choke on it...)
7518      */
7519     entry->ino = 1;
7520     entry->fattr->valid = 0;
7521
7522     if (decode_attr_bitmap(xdr, bitmap) < 0)
7523         return -EAGAIN;
7524
7525     if (decode_attr_length(xdr, &len, &savep) < 0)
7526         return -EAGAIN;
7527
7528     if (decode_getfattr_attrs(xdr, bitmap, entry->fattr, entry->fh,
7529             NULL, entry->server) < 0)
7530         return -EAGAIN;
7531     if (entry->fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID)
7532         entry->ino = entry->fattr->mounted_on_fileid;
7533     else if (entry->fattr->valid & NFS_ATTR_FATTR_FILEID)
7534         entry->ino = entry->fattr->fileid;
7535
7536     entry->d_type = DT_UNKNOWN;
7537     if (entry->fattr->valid & NFS_ATTR_FATTR_TYPE)
7538         entry->d_type = nfs_umode_to_dtype(entry->fattr->mode);
7539
7540     entry->cookie = new_cookie;
7541
7542     return 0;
7543 }
7544
7545 /*
7546  * We need to translate between nfs status return values and
7547  * the local errno values which may not be the same.
7548  */
7549 static struct {
7550     int stat;
7551     int errno;
7552 } nfs_errtbl[] = {
7553     { NFS4_OK,      0       },
7554     { NFS4ERR_PERM,     -EPERM      },
7555     { NFS4ERR_NOENT,    -ENOENT     },
7556     { NFS4ERR_IO,       -errno_NFSERR_IO},
7557     { NFS4ERR_NXIO,     -ENXIO      },
7558     { NFS4ERR_ACCESS,   -EACCES     },
7559     { NFS4ERR_EXIST,    -EEXIST     },
7560     { NFS4ERR_XDEV,     -EXDEV      },
7561     { NFS4ERR_NOTDIR,   -ENOTDIR    },
7562     { NFS4ERR_ISDIR,    -EISDIR     },
7563     { NFS4ERR_INVAL,    -EINVAL     },
7564     { NFS4ERR_FBIG,     -EFBIG      },
7565     { NFS4ERR_NOSPC,    -ENOSPC     },
7566     { NFS4ERR_ROFS,     -EROFS      },
7567     { NFS4ERR_MLINK,    -EMLINK     },
7568     { NFS4ERR_NAMETOOLONG,  -ENAMETOOLONG   },
7569     { NFS4ERR_NOTEMPTY, -ENOTEMPTY  },
7570     { NFS4ERR_DQUOT,    -EDQUOT     },
7571     { NFS4ERR_STALE,    -ESTALE     },
7572     { NFS4ERR_BADHANDLE,    -EBADHANDLE },
7573     { NFS4ERR_BAD_COOKIE,   -EBADCOOKIE },
7574     { NFS4ERR_NOTSUPP,  -ENOTSUPP   },
7575     { NFS4ERR_TOOSMALL, -ETOOSMALL  },
7576     { NFS4ERR_SERVERFAULT,  -EREMOTEIO  },
7577     { NFS4ERR_BADTYPE,  -EBADTYPE   },
7578     { NFS4ERR_LOCKED,   -EAGAIN     },
7579     { NFS4ERR_SYMLINK,  -ELOOP      },
7580     { NFS4ERR_OP_ILLEGAL,   -EOPNOTSUPP },
7581     { NFS4ERR_DEADLOCK, -EDEADLK    },
7582     { NFS4ERR_NOXATTR,  -ENODATA    },
7583     { NFS4ERR_XATTR2BIG,    -E2BIG      },
7584     { -1,           -EIO        }
7585 };
7586
7587 /*
7588  * Convert an NFS error code to a local one.
7589  * This one is used jointly by NFSv2 and NFSv3.
7590  */
7591 static int
7592 nfs4_stat_to_errno(int stat)
7593 {
7594     int i;
7595     for (i = 0; nfs_errtbl[i].stat != -1; i++) {
7596         if (nfs_errtbl[i].stat == stat)
7597             return nfs_errtbl[i].errno;
7598     }
7599     if (stat <= 10000 || stat > 10100) {
7600         /* The server is looney tunes. */
7601         return -EREMOTEIO;
7602     }
7603     /* If we cannot translate the error, the recovery routines should
7604      * handle it.
7605      * Note: remaining NFSv4 error codes have values > 10000, so should
7606      * not conflict with native Linux error codes.
7607      */
7608     return -stat;
7609 }
7610
7611 #ifdef CONFIG_NFS_V4_2
7612 #include "nfs42xdr.c"
7613 #endif /* CONFIG_NFS_V4_2 */
7614
7615 #define PROC(proc, argtype, restype)                \
7616 [NFSPROC4_CLNT_##proc] = {                  \
7617     .p_proc   = NFSPROC4_COMPOUND,              \
7618     .p_encode = nfs4_xdr_##argtype,             \
7619     .p_decode = nfs4_xdr_##restype,             \
7620     .p_arglen = NFS4_##argtype##_sz,            \
7621     .p_replen = NFS4_##restype##_sz,            \
7622     .p_statidx = NFSPROC4_CLNT_##proc,          \
7623     .p_name   = #proc,                  \
7624 }
7625
7626 #define STUB(proc)      \
7627 [NFSPROC4_CLNT_##proc] = {  \
7628     .p_name = #proc,    \
7629 }
7630
7631 #if defined(CONFIG_NFS_V4_1)
7632 #define PROC41(proc, argtype, restype)              \
7633     PROC(proc, argtype, restype)
7634 #else
7635 #define PROC41(proc, argtype, restype)              \
7636     STUB(proc)
7637 #endif
7638
7639 #if defined(CONFIG_NFS_V4_2)
7640 #define PROC42(proc, argtype, restype)              \
7641     PROC(proc, argtype, restype)
7642 #else
7643 #define PROC42(proc, argtype, restype)              \
7644     STUB(proc)
7645 #endif
7646
7647 const struct rpc_procinfo nfs4_procedures[] = {
7648     PROC(READ,      enc_read,       dec_read),
7649     PROC(WRITE,     enc_write,      dec_write),
7650     PROC(COMMIT,        enc_commit,     dec_commit),
7651     PROC(OPEN,      enc_open,       dec_open),
7652     PROC(OPEN_CONFIRM,  enc_open_confirm,   dec_open_confirm),
7653     PROC(OPEN_NOATTR,   enc_open_noattr,    dec_open_noattr),
7654     PROC(OPEN_DOWNGRADE,    enc_open_downgrade, dec_open_downgrade),
7655     PROC(CLOSE,     enc_close,      dec_close),
7656     PROC(SETATTR,       enc_setattr,        dec_setattr),
7657     PROC(FSINFO,        enc_fsinfo,     dec_fsinfo),
7658     PROC(RENEW,     enc_renew,      dec_renew),
7659     PROC(SETCLIENTID,   enc_setclientid,    dec_setclientid),
7660     PROC(SETCLIENTID_CONFIRM, enc_setclientid_confirm, dec_setclientid_confirm),
7661     PROC(LOCK,      enc_lock,       dec_lock),
7662     PROC(LOCKT,     enc_lockt,      dec_lockt),
7663     PROC(LOCKU,     enc_locku,      dec_locku),
7664     PROC(ACCESS,        enc_access,     dec_access),
7665     PROC(GETATTR,       enc_getattr,        dec_getattr),
7666     PROC(LOOKUP,        enc_lookup,     dec_lookup),
7667     PROC(LOOKUP_ROOT,   enc_lookup_root,    dec_lookup_root),
7668     PROC(REMOVE,        enc_remove,     dec_remove),
7669     PROC(RENAME,        enc_rename,     dec_rename),
7670     PROC(LINK,      enc_link,       dec_link),
7671     PROC(SYMLINK,       enc_symlink,        dec_symlink),
7672     PROC(CREATE,        enc_create,     dec_create),
7673     PROC(PATHCONF,      enc_pathconf,       dec_pathconf),
7674     PROC(STATFS,        enc_statfs,     dec_statfs),
7675     PROC(READLINK,      enc_readlink,       dec_readlink),
7676     PROC(READDIR,       enc_readdir,        dec_readdir),
7677     PROC(SERVER_CAPS,   enc_server_caps,    dec_server_caps),
7678     PROC(DELEGRETURN,   enc_delegreturn,    dec_delegreturn),
7679     PROC(GETACL,        enc_getacl,     dec_getacl),
7680     PROC(SETACL,        enc_setacl,     dec_setacl),
7681     PROC(FS_LOCATIONS,  enc_fs_locations,   dec_fs_locations),
7682     PROC(RELEASE_LOCKOWNER, enc_release_lockowner,  dec_release_lockowner),
7683     PROC(SECINFO,       enc_secinfo,        dec_secinfo),
7684     PROC(FSID_PRESENT,  enc_fsid_present,   dec_fsid_present),
7685     PROC41(EXCHANGE_ID, enc_exchange_id,    dec_exchange_id),
7686     PROC41(CREATE_SESSION,  enc_create_session, dec_create_session),
7687     PROC41(DESTROY_SESSION, enc_destroy_session,    dec_destroy_session),
7688     PROC41(SEQUENCE,    enc_sequence,       dec_sequence),
7689     PROC(GET_LEASE_TIME,    enc_get_lease_time, dec_get_lease_time),
7690     PROC41(RECLAIM_COMPLETE,enc_reclaim_complete,   dec_reclaim_complete),
7691     PROC41(GETDEVICEINFO,   enc_getdeviceinfo,  dec_getdeviceinfo),
7692     PROC41(LAYOUTGET,   enc_layoutget,      dec_layoutget),
7693     PROC41(LAYOUTCOMMIT,    enc_layoutcommit,   dec_layoutcommit),
7694     PROC41(LAYOUTRETURN,    enc_layoutreturn,   dec_layoutreturn),
7695     PROC41(SECINFO_NO_NAME, enc_secinfo_no_name,    dec_secinfo_no_name),
7696     PROC41(TEST_STATEID,    enc_test_stateid,   dec_test_stateid),
7697     PROC41(FREE_STATEID,    enc_free_stateid,   dec_free_stateid),
7698     STUB(GETDEVICELIST),
7699     PROC41(BIND_CONN_TO_SESSION,
7700             enc_bind_conn_to_session, dec_bind_conn_to_session),
7701     PROC41(DESTROY_CLIENTID,enc_destroy_clientid,   dec_destroy_clientid),
7702     PROC42(SEEK,        enc_seek,       dec_seek),
7703     PROC42(ALLOCATE,    enc_allocate,       dec_allocate),
7704     PROC42(DEALLOCATE,  enc_deallocate,     dec_deallocate),
7705     PROC42(LAYOUTSTATS, enc_layoutstats,    dec_layoutstats),
7706     PROC42(CLONE,       enc_clone,      dec_clone),
7707     PROC42(COPY,        enc_copy,       dec_copy),
7708     PROC42(OFFLOAD_CANCEL,  enc_offload_cancel, dec_offload_cancel),
7709     PROC42(COPY_NOTIFY, enc_copy_notify,    dec_copy_notify),
7710     PROC(LOOKUPP,       enc_lookupp,        dec_lookupp),
7711     PROC42(LAYOUTERROR, enc_layouterror,    dec_layouterror),
7712     PROC42(GETXATTR,    enc_getxattr,       dec_getxattr),
7713     PROC42(SETXATTR,    enc_setxattr,       dec_setxattr),
7714     PROC42(LISTXATTRS,  enc_listxattrs,     dec_listxattrs),
7715     PROC42(REMOVEXATTR, enc_removexattr,    dec_removexattr),
7716     PROC42(READ_PLUS,   enc_read_plus,      dec_read_plus),
7717 };
7718
7719 static unsigned int nfs_version4_counts[ARRAY_SIZE(nfs4_procedures)];
7720 const struct rpc_version nfs_version4 = {
7721     .number         = 4,
7722     .nrprocs        = ARRAY_SIZE(nfs4_procedures),
7723     .procs          = nfs4_procedures,
7724     .counts         = nfs_version4_counts,
7725 };