fs/nfs/nfs4xdr.c

   1 /*
   2  *  fs/nfs/nfs4xdr.c
   3  *
   4  *  Client-side XDR for NFSv4.
   5  *
   6  *  Copyright (c) 2002 The Regents of the University of Michigan.
   7  *  All rights reserved.
   8  *
   9  *  Kendrick Smith <kmsmith@umich.edu>
  10  *  Andy Adamson   <andros@umich.edu>
  11  *
  12  *  Redistribution and use in source and binary forms, with or without
  13  *  modification, are permitted provided that the following conditions
  14  *  are met:
  15  *
  16  *  1. Redistributions of source code must retain the above copyright
  17  *     notice, this list of conditions and the following disclaimer.
  18  *  2. Redistributions in binary form must reproduce the above copyright
  19  *     notice, this list of conditions and the following disclaimer in the
  20  *     documentation and/or other materials provided with the distribution.
  21  *  3. Neither the name of the University nor the names of its
  22  *     contributors may be used to endorse or promote products derived
  23  *     from this software without specific prior written permission.
  24  *
  25  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  26  *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  27  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  28  *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  29  *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  30  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  31  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  32  *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  33  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  34  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  35  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36  */
  37
  38 #include <linux/param.h>
  39 #include <linux/time.h>
  40 #include <linux/mm.h>
  41 #include <linux/slab.h>
  42 #include <linux/utsname.h>
  43 #include <linux/errno.h>
  44 #include <linux/string.h>
  45 #include <linux/in.h>
  46 #include <linux/pagemap.h>
  47 #include <linux/proc_fs.h>
  48 #include <linux/kdev_t.h>
  49 #include <linux/sunrpc/clnt.h>
  50 #include <linux/nfs.h>
  51 #include <linux/nfs4.h>
  52 #include <linux/nfs_fs.h>
  53 #include <linux/nfs_idmap.h>
  54 #include "nfs4_fs.h"
  55
  56 #define NFSDBG_FACILITY         NFSDBG_XDR
  57
  58 /* Mapping from NFS error code to "errno" error code. */
  59 #define errno_NFSERR_IO         EIO
  60
  61 static int nfs4_stat_to_errno(int);
  62
  63 /* NFSv4 COMPOUND tags are only wanted for debugging purposes */
  64 #ifdef DEBUG
  65 #define NFS4_MAXTAGLEN          20
  66 #else
  67 #define NFS4_MAXTAGLEN          0
  68 #endif
  69
  70 /* lock,open owner id:
  71  * we currently use size 2 (u64) out of (NFS4_OPAQUE_LIMIT  >> 2)
  72  */
  73 #define open_owner_id_maxsz     (1 + 4)
  74 #define lock_owner_id_maxsz     (1 + 4)
  75 #define decode_lockowner_maxsz  (1 + XDR_QUADLEN(IDMAP_NAMESZ))
  76 #define compound_encode_hdr_maxsz       (3 + (NFS4_MAXTAGLEN >> 2))
  77 #define compound_decode_hdr_maxsz       (3 + (NFS4_MAXTAGLEN >> 2))
  78 #define op_encode_hdr_maxsz     (1)
  79 #define op_decode_hdr_maxsz     (2)
  80 #define encode_stateid_maxsz    (XDR_QUADLEN(NFS4_STATEID_SIZE))
  81 #define decode_stateid_maxsz    (XDR_QUADLEN(NFS4_STATEID_SIZE))
  82 #define encode_verifier_maxsz   (XDR_QUADLEN(NFS4_VERIFIER_SIZE))
  83 #define decode_verifier_maxsz   (XDR_QUADLEN(NFS4_VERIFIER_SIZE))
  84 #define encode_putfh_maxsz      (op_encode_hdr_maxsz + 1 + \
  85                                 (NFS4_FHSIZE >> 2))
  86 #define decode_putfh_maxsz      (op_decode_hdr_maxsz)
  87 #define encode_putrootfh_maxsz  (op_encode_hdr_maxsz)
  88 #define decode_putrootfh_maxsz  (op_decode_hdr_maxsz)
  89 #define encode_getfh_maxsz      (op_encode_hdr_maxsz)
  90 #define decode_getfh_maxsz      (op_decode_hdr_maxsz + 1 + \
  91                                 ((3+NFS4_FHSIZE) >> 2))
  92 #define nfs4_fattr_bitmap_maxsz 3
  93 #define encode_getattr_maxsz    (op_encode_hdr_maxsz + nfs4_fattr_bitmap_maxsz)
  94 #define nfs4_name_maxsz         (1 + ((3 + NFS4_MAXNAMLEN) >> 2))
  95 #define nfs4_path_maxsz         (1 + ((3 + NFS4_MAXPATHLEN) >> 2))
  96 #define nfs4_owner_maxsz        (1 + XDR_QUADLEN(IDMAP_NAMESZ))
  97 #define nfs4_group_maxsz        (1 + XDR_QUADLEN(IDMAP_NAMESZ))
  98 /* This is based on getfattr, which uses the most attributes: */
  99 #define nfs4_fattr_value_maxsz  (1 + (1 + 2 + 2 + 4 + 2 + 1 + 1 + 2 + 2 + \
 100                                 3 + 3 + 3 + nfs4_owner_maxsz + nfs4_group_maxsz))
 101 #define nfs4_fattr_maxsz        (nfs4_fattr_bitmap_maxsz + \
 102                                 nfs4_fattr_value_maxsz)
 103 #define decode_getattr_maxsz    (op_decode_hdr_maxsz + nfs4_fattr_maxsz)
 104 #define encode_attrs_maxsz      (nfs4_fattr_bitmap_maxsz + \
 105                                  1 + 2 + 1 + \
 106                                 nfs4_owner_maxsz + \
 107                                 nfs4_group_maxsz + \
 108                                 4 + 4)
 109 #define encode_savefh_maxsz     (op_encode_hdr_maxsz)
 110 #define decode_savefh_maxsz     (op_decode_hdr_maxsz)
 111 #define encode_restorefh_maxsz  (op_encode_hdr_maxsz)
 112 #define decode_restorefh_maxsz  (op_decode_hdr_maxsz)
 113 #define encode_fsinfo_maxsz     (encode_getattr_maxsz)
 114 #define decode_fsinfo_maxsz     (op_decode_hdr_maxsz + 11)
 115 #define encode_renew_maxsz      (op_encode_hdr_maxsz + 3)
 116 #define decode_renew_maxsz      (op_decode_hdr_maxsz)
 117 #define encode_setclientid_maxsz \
 118                                 (op_encode_hdr_maxsz + \
 119                                 XDR_QUADLEN(NFS4_VERIFIER_SIZE) + \
 120                                 XDR_QUADLEN(NFS4_SETCLIENTID_NAMELEN) + \
 121                                 1 /* sc_prog */ + \
 122                                 XDR_QUADLEN(RPCBIND_MAXNETIDLEN) + \
 123                                 XDR_QUADLEN(RPCBIND_MAXUADDRLEN) + \
 124                                 1) /* sc_cb_ident */
 125 #define decode_setclientid_maxsz \
 126                                 (op_decode_hdr_maxsz + \
 127                                 2 + \
 128                                 1024) /* large value for CLID_INUSE */
 129 #define encode_setclientid_confirm_maxsz \
 130                                 (op_encode_hdr_maxsz + \
 131                                 3 + (NFS4_VERIFIER_SIZE >> 2))
 132 #define decode_setclientid_confirm_maxsz \
 133                                 (op_decode_hdr_maxsz)
 134 #define encode_lookup_maxsz     (op_encode_hdr_maxsz + nfs4_name_maxsz)
 135 #define decode_lookup_maxsz     (op_decode_hdr_maxsz)
 136 #define encode_share_access_maxsz \
 137                                 (2)
 138 #define encode_createmode_maxsz (1 + encode_attrs_maxsz)
 139 #define encode_opentype_maxsz   (1 + encode_createmode_maxsz)
 140 #define encode_claim_null_maxsz (1 + nfs4_name_maxsz)
 141 #define encode_open_maxsz       (op_encode_hdr_maxsz + \
 142                                 2 + encode_share_access_maxsz + 2 + \
 143                                 open_owner_id_maxsz + \
 144                                 encode_opentype_maxsz + \
 145                                 encode_claim_null_maxsz)
 146 #define decode_ace_maxsz        (3 + nfs4_owner_maxsz)
 147 #define decode_delegation_maxsz (1 + decode_stateid_maxsz + 1 + \
 148                                 decode_ace_maxsz)
 149 #define decode_change_info_maxsz        (5)
 150 #define decode_open_maxsz       (op_decode_hdr_maxsz + \
 151                                 decode_stateid_maxsz + \
 152                                 decode_change_info_maxsz + 1 + \
 153                                 nfs4_fattr_bitmap_maxsz + \
 154                                 decode_delegation_maxsz)
 155 #define encode_open_confirm_maxsz \
 156                                 (op_encode_hdr_maxsz + \
 157                                  encode_stateid_maxsz + 1)
 158 #define decode_open_confirm_maxsz \
 159                                 (op_decode_hdr_maxsz + \
 160                                  decode_stateid_maxsz)
 161 #define encode_open_downgrade_maxsz \
 162                                 (op_encode_hdr_maxsz + \
 163                                  encode_stateid_maxsz + 1 + \
 164                                  encode_share_access_maxsz)
 165 #define decode_open_downgrade_maxsz \
 166                                 (op_decode_hdr_maxsz + \
 167                                  decode_stateid_maxsz)
 168 #define encode_close_maxsz      (op_encode_hdr_maxsz + \
 169                                  1 + encode_stateid_maxsz)
 170 #define decode_close_maxsz      (op_decode_hdr_maxsz + \
 171                                  decode_stateid_maxsz)
 172 #define encode_setattr_maxsz    (op_encode_hdr_maxsz + \
 173                                  encode_stateid_maxsz + \
 174                                  encode_attrs_maxsz)
 175 #define decode_setattr_maxsz    (op_decode_hdr_maxsz + \
 176                                  nfs4_fattr_bitmap_maxsz)
 177 #define encode_read_maxsz       (op_encode_hdr_maxsz + \
 178                                  encode_stateid_maxsz + 3)
 179 #define decode_read_maxsz       (op_decode_hdr_maxsz + 2)
 180 #define encode_readdir_maxsz    (op_encode_hdr_maxsz + \
 181                                  2 + encode_verifier_maxsz + 5)
 182 #define decode_readdir_maxsz    (op_decode_hdr_maxsz + \
 183                                  decode_verifier_maxsz)
 184 #define encode_readlink_maxsz   (op_encode_hdr_maxsz)
 185 #define decode_readlink_maxsz   (op_decode_hdr_maxsz + 1)
 186 #define encode_write_maxsz      (op_encode_hdr_maxsz + \
 187                                  encode_stateid_maxsz + 4)
 188 #define decode_write_maxsz      (op_decode_hdr_maxsz + \
 189                                  2 + decode_verifier_maxsz)
 190 #define encode_commit_maxsz     (op_encode_hdr_maxsz + 3)
 191 #define decode_commit_maxsz     (op_decode_hdr_maxsz + \
 192                                  decode_verifier_maxsz)
 193 #define encode_remove_maxsz     (op_encode_hdr_maxsz + \
 194                                 nfs4_name_maxsz)
 195 #define decode_remove_maxsz     (op_decode_hdr_maxsz + \
 196                                  decode_change_info_maxsz)
 197 #define encode_rename_maxsz     (op_encode_hdr_maxsz + \
 198                                 2 * nfs4_name_maxsz)
 199 #define decode_rename_maxsz     (op_decode_hdr_maxsz + \
 200                                  decode_change_info_maxsz + \
 201                                  decode_change_info_maxsz)
 202 #define encode_link_maxsz       (op_encode_hdr_maxsz + \
 203                                 nfs4_name_maxsz)
 204 #define decode_link_maxsz       (op_decode_hdr_maxsz + decode_change_info_maxsz)
 205 #define encode_lock_maxsz       (op_encode_hdr_maxsz + \
 206                                  7 + \
 207                                  1 + encode_stateid_maxsz + 8)
 208 #define decode_lock_denied_maxsz \
 209                                 (8 + decode_lockowner_maxsz)
 210 #define decode_lock_maxsz       (op_decode_hdr_maxsz + \
 211                                  decode_lock_denied_maxsz)
 212 #define encode_lockt_maxsz      (op_encode_hdr_maxsz + 12)
 213 #define decode_lockt_maxsz      (op_decode_hdr_maxsz + \
 214                                  decode_lock_denied_maxsz)
 215 #define encode_locku_maxsz      (op_encode_hdr_maxsz + 3 + \
 216                                  encode_stateid_maxsz + \
 217                                  4)
 218 #define decode_locku_maxsz      (op_decode_hdr_maxsz + \
 219                                  decode_stateid_maxsz)
 220 #define encode_access_maxsz     (op_encode_hdr_maxsz + 1)
 221 #define decode_access_maxsz     (op_decode_hdr_maxsz + 2)
 222 #define encode_symlink_maxsz    (op_encode_hdr_maxsz + \
 223                                 1 + nfs4_name_maxsz + \
 224                                 1 + \
 225                                 nfs4_fattr_maxsz)
 226 #define decode_symlink_maxsz    (op_decode_hdr_maxsz + 8)
 227 #define encode_create_maxsz     (op_encode_hdr_maxsz + \
 228                                 1 + 2 + nfs4_name_maxsz + \
 229                                 encode_attrs_maxsz)
 230 #define decode_create_maxsz     (op_decode_hdr_maxsz + \
 231                                 decode_change_info_maxsz + \
 232                                 nfs4_fattr_bitmap_maxsz)
 233 #define encode_statfs_maxsz     (encode_getattr_maxsz)
 234 #define decode_statfs_maxsz     (decode_getattr_maxsz)
 235 #define encode_delegreturn_maxsz (op_encode_hdr_maxsz + 4)
 236 #define decode_delegreturn_maxsz (op_decode_hdr_maxsz)
 237 #define encode_getacl_maxsz     (encode_getattr_maxsz)
 238 #define decode_getacl_maxsz     (op_decode_hdr_maxsz + \
 239                                  nfs4_fattr_bitmap_maxsz + 1)
 240 #define encode_setacl_maxsz     (op_encode_hdr_maxsz + \
 241                                  encode_stateid_maxsz + 3)
 242 #define decode_setacl_maxsz     (decode_setattr_maxsz)
 243 #define encode_fs_locations_maxsz \
 244                                 (encode_getattr_maxsz)
 245 #define decode_fs_locations_maxsz \
 246                                 (0)
 247
 248 #if defined(CONFIG_NFS_V4_1)
 249 #define NFS4_MAX_MACHINE_NAME_LEN (64)
 250
 251 #define encode_exchange_id_maxsz (op_encode_hdr_maxsz + \
 252                                 encode_verifier_maxsz + \
 253                                 1 /* co_ownerid.len */ + \
 254                                 XDR_QUADLEN(NFS4_EXCHANGE_ID_LEN) + \
 255                                 1 /* flags */ + \
 256                                 1 /* spa_how */ + \
 257                                 0 /* SP4_NONE (for now) */ + \
 258                                 1 /* zero implemetation id array */)
 259 #define decode_exchange_id_maxsz (op_decode_hdr_maxsz + \
 260                                 2 /* eir_clientid */ + \
 261                                 1 /* eir_sequenceid */ + \
 262                                 1 /* eir_flags */ + \
 263                                 1 /* spr_how */ + \
 264                                 0 /* SP4_NONE (for now) */ + \
 265                                 2 /* eir_server_owner.so_minor_id */ + \
 266                                 /* eir_server_owner.so_major_id<> */ \
 267                                 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 + \
 268                                 /* eir_server_scope<> */ \
 269                                 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 + \
 270                                 1 /* eir_server_impl_id array length */ + \
 271                                 0 /* ignored eir_server_impl_id contents */)
 272 #define encode_channel_attrs_maxsz  (6 + 1 /* ca_rdma_ird.len (0) */)
 273 #define decode_channel_attrs_maxsz  (6 + \
 274                                      1 /* ca_rdma_ird.len */ + \
 275                                      1 /* ca_rdma_ird */)
 276 #define encode_create_session_maxsz  (op_encode_hdr_maxsz + \
 277                                      2 /* csa_clientid */ + \
 278                                      1 /* csa_sequence */ + \
 279                                      1 /* csa_flags */ + \
 280                                      encode_channel_attrs_maxsz + \
 281                                      encode_channel_attrs_maxsz + \
 282                                      1 /* csa_cb_program */ + \
 283                                      1 /* csa_sec_parms.len (1) */ + \
 284                                      1 /* cb_secflavor (AUTH_SYS) */ + \
 285                                      1 /* stamp */ + \
 286                                      1 /* machinename.len */ + \
 287                                      XDR_QUADLEN(NFS4_MAX_MACHINE_NAME_LEN) + \
 288                                      1 /* uid */ + \
 289                                      1 /* gid */ + \
 290                                      1 /* gids.len (0) */)
 291 #define decode_create_session_maxsz  (op_decode_hdr_maxsz +     \
 292                                      XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
 293                                      1 /* csr_sequence */ + \
 294                                      1 /* csr_flags */ + \
 295                                      decode_channel_attrs_maxsz + \
 296                                      decode_channel_attrs_maxsz)
 297 #define encode_sequence_maxsz   0 /* stub */
 298 #define decode_sequence_maxsz   0 /* stub */
 299 #else /* CONFIG_NFS_V4_1 */
 300 #define encode_sequence_maxsz   0
 301 #define decode_sequence_maxsz   0
 302 #endif /* CONFIG_NFS_V4_1 */
 303
 304 #define NFS4_enc_compound_sz    (1024)  /* XXX: large enough? */
 305 #define NFS4_dec_compound_sz    (1024)  /* XXX: large enough? */
 306 #define NFS4_enc_read_sz        (compound_encode_hdr_maxsz + \
 307                                 encode_sequence_maxsz + \
 308                                 encode_putfh_maxsz + \
 309                                 encode_read_maxsz)
 310 #define NFS4_dec_read_sz        (compound_decode_hdr_maxsz + \
 311                                 decode_sequence_maxsz + \
 312                                 decode_putfh_maxsz + \
 313                                 decode_read_maxsz)
 314 #define NFS4_enc_readlink_sz    (compound_encode_hdr_maxsz + \
 315                                 encode_sequence_maxsz + \
 316                                 encode_putfh_maxsz + \
 317                                 encode_readlink_maxsz)
 318 #define NFS4_dec_readlink_sz    (compound_decode_hdr_maxsz + \
 319                                 decode_sequence_maxsz + \
 320                                 decode_putfh_maxsz + \
 321                                 decode_readlink_maxsz)
 322 #define NFS4_enc_readdir_sz     (compound_encode_hdr_maxsz + \
 323                                 encode_sequence_maxsz + \
 324                                 encode_putfh_maxsz + \
 325                                 encode_readdir_maxsz)
 326 #define NFS4_dec_readdir_sz     (compound_decode_hdr_maxsz + \
 327                                 decode_sequence_maxsz + \
 328                                 decode_putfh_maxsz + \
 329                                 decode_readdir_maxsz)
 330 #define NFS4_enc_write_sz       (compound_encode_hdr_maxsz + \
 331                                 encode_sequence_maxsz + \
 332                                 encode_putfh_maxsz + \
 333                                 encode_write_maxsz + \
 334                                 encode_getattr_maxsz)
 335 #define NFS4_dec_write_sz       (compound_decode_hdr_maxsz + \
 336                                 decode_sequence_maxsz + \
 337                                 decode_putfh_maxsz + \
 338                                 decode_write_maxsz + \
 339                                 decode_getattr_maxsz)
 340 #define NFS4_enc_commit_sz      (compound_encode_hdr_maxsz + \
 341                                 encode_sequence_maxsz + \
 342                                 encode_putfh_maxsz + \
 343                                 encode_commit_maxsz + \
 344                                 encode_getattr_maxsz)
 345 #define NFS4_dec_commit_sz      (compound_decode_hdr_maxsz + \
 346                                 decode_sequence_maxsz + \
 347                                 decode_putfh_maxsz + \
 348                                 decode_commit_maxsz + \
 349                                 decode_getattr_maxsz)
 350 #define NFS4_enc_open_sz        (compound_encode_hdr_maxsz + \
 351                                 encode_sequence_maxsz + \
 352                                 encode_putfh_maxsz + \
 353                                 encode_savefh_maxsz + \
 354                                 encode_open_maxsz + \
 355                                 encode_getfh_maxsz + \
 356                                 encode_getattr_maxsz + \
 357                                 encode_restorefh_maxsz + \
 358                                 encode_getattr_maxsz)
 359 #define NFS4_dec_open_sz        (compound_decode_hdr_maxsz + \
 360                                 decode_sequence_maxsz + \
 361                                 decode_putfh_maxsz + \
 362                                 decode_savefh_maxsz + \
 363                                 decode_open_maxsz + \
 364                                 decode_getfh_maxsz + \
 365                                 decode_getattr_maxsz + \
 366                                 decode_restorefh_maxsz + \
 367                                 decode_getattr_maxsz)
 368 #define NFS4_enc_open_confirm_sz \
 369                                 (compound_encode_hdr_maxsz + \
 370                                  encode_putfh_maxsz + \
 371                                  encode_open_confirm_maxsz)
 372 #define NFS4_dec_open_confirm_sz \
 373                                 (compound_decode_hdr_maxsz + \
 374                                  decode_putfh_maxsz + \
 375                                  decode_open_confirm_maxsz)
 376 #define NFS4_enc_open_noattr_sz (compound_encode_hdr_maxsz + \
 377                                         encode_sequence_maxsz + \
 378                                         encode_putfh_maxsz + \
 379                                         encode_open_maxsz + \
 380                                         encode_getattr_maxsz)
 381 #define NFS4_dec_open_noattr_sz (compound_decode_hdr_maxsz + \
 382                                         decode_sequence_maxsz + \
 383                                         decode_putfh_maxsz + \
 384                                         decode_open_maxsz + \
 385                                         decode_getattr_maxsz)
 386 #define NFS4_enc_open_downgrade_sz \
 387                                 (compound_encode_hdr_maxsz + \
 388                                  encode_sequence_maxsz + \
 389                                  encode_putfh_maxsz + \
 390                                  encode_open_downgrade_maxsz + \
 391                                  encode_getattr_maxsz)
 392 #define NFS4_dec_open_downgrade_sz \
 393                                 (compound_decode_hdr_maxsz + \
 394                                  decode_sequence_maxsz + \
 395                                  decode_putfh_maxsz + \
 396                                  decode_open_downgrade_maxsz + \
 397                                  decode_getattr_maxsz)
 398 #define NFS4_enc_close_sz       (compound_encode_hdr_maxsz + \
 399                                  encode_sequence_maxsz + \
 400                                  encode_putfh_maxsz + \
 401                                  encode_close_maxsz + \
 402                                  encode_getattr_maxsz)
 403 #define NFS4_dec_close_sz       (compound_decode_hdr_maxsz + \
 404                                  decode_sequence_maxsz + \
 405                                  decode_putfh_maxsz + \
 406                                  decode_close_maxsz + \
 407                                  decode_getattr_maxsz)
 408 #define NFS4_enc_setattr_sz     (compound_encode_hdr_maxsz + \
 409                                  encode_sequence_maxsz + \
 410                                  encode_putfh_maxsz + \
 411                                  encode_setattr_maxsz + \
 412                                  encode_getattr_maxsz)
 413 #define NFS4_dec_setattr_sz     (compound_decode_hdr_maxsz + \
 414                                  decode_sequence_maxsz + \
 415                                  decode_putfh_maxsz + \
 416                                  decode_setattr_maxsz + \
 417                                  decode_getattr_maxsz)
 418 #define NFS4_enc_fsinfo_sz      (compound_encode_hdr_maxsz + \
 419                                 encode_sequence_maxsz + \
 420                                 encode_putfh_maxsz + \
 421                                 encode_fsinfo_maxsz)
 422 #define NFS4_dec_fsinfo_sz      (compound_decode_hdr_maxsz + \
 423                                 decode_sequence_maxsz + \
 424                                 decode_putfh_maxsz + \
 425                                 decode_fsinfo_maxsz)
 426 #define NFS4_enc_renew_sz       (compound_encode_hdr_maxsz + \
 427                                 encode_renew_maxsz)
 428 #define NFS4_dec_renew_sz       (compound_decode_hdr_maxsz + \
 429                                 decode_renew_maxsz)
 430 #define NFS4_enc_setclientid_sz (compound_encode_hdr_maxsz + \
 431                                 encode_setclientid_maxsz)
 432 #define NFS4_dec_setclientid_sz (compound_decode_hdr_maxsz + \
 433                                 decode_setclientid_maxsz)
 434 #define NFS4_enc_setclientid_confirm_sz \
 435                                 (compound_encode_hdr_maxsz + \
 436                                 encode_setclientid_confirm_maxsz + \
 437                                 encode_putrootfh_maxsz + \
 438                                 encode_fsinfo_maxsz)
 439 #define NFS4_dec_setclientid_confirm_sz \
 440                                 (compound_decode_hdr_maxsz + \
 441                                 decode_setclientid_confirm_maxsz + \
 442                                 decode_putrootfh_maxsz + \
 443                                 decode_fsinfo_maxsz)
 444 #define NFS4_enc_lock_sz        (compound_encode_hdr_maxsz + \
 445                                 encode_sequence_maxsz + \
 446                                 encode_putfh_maxsz + \
 447                                 encode_lock_maxsz)
 448 #define NFS4_dec_lock_sz        (compound_decode_hdr_maxsz + \
 449                                 decode_sequence_maxsz + \
 450                                 decode_putfh_maxsz + \
 451                                 decode_lock_maxsz)
 452 #define NFS4_enc_lockt_sz       (compound_encode_hdr_maxsz + \
 453                                 encode_sequence_maxsz + \
 454                                 encode_putfh_maxsz + \
 455                                 encode_lockt_maxsz)
 456 #define NFS4_dec_lockt_sz       (compound_decode_hdr_maxsz + \
 457                                  decode_sequence_maxsz + \
 458                                  decode_putfh_maxsz + \
 459                                  decode_lockt_maxsz)
 460 #define NFS4_enc_locku_sz       (compound_encode_hdr_maxsz + \
 461                                 encode_sequence_maxsz + \
 462                                 encode_putfh_maxsz + \
 463                                 encode_locku_maxsz)
 464 #define NFS4_dec_locku_sz       (compound_decode_hdr_maxsz + \
 465                                 decode_sequence_maxsz + \
 466                                 decode_putfh_maxsz + \
 467                                 decode_locku_maxsz)
 468 #define NFS4_enc_access_sz      (compound_encode_hdr_maxsz + \
 469                                 encode_sequence_maxsz + \
 470                                 encode_putfh_maxsz + \
 471                                 encode_access_maxsz + \
 472                                 encode_getattr_maxsz)
 473 #define NFS4_dec_access_sz      (compound_decode_hdr_maxsz + \
 474                                 decode_sequence_maxsz + \
 475                                 decode_putfh_maxsz + \
 476                                 decode_access_maxsz + \
 477                                 decode_getattr_maxsz)
 478 #define NFS4_enc_getattr_sz     (compound_encode_hdr_maxsz + \
 479                                 encode_sequence_maxsz + \
 480                                 encode_putfh_maxsz + \
 481                                 encode_getattr_maxsz)
 482 #define NFS4_dec_getattr_sz     (compound_decode_hdr_maxsz + \
 483                                 decode_sequence_maxsz + \
 484                                 decode_putfh_maxsz + \
 485                                 decode_getattr_maxsz)
 486 #define NFS4_enc_lookup_sz      (compound_encode_hdr_maxsz + \
 487                                 encode_sequence_maxsz + \
 488                                 encode_putfh_maxsz + \
 489                                 encode_lookup_maxsz + \
 490                                 encode_getattr_maxsz + \
 491                                 encode_getfh_maxsz)
 492 #define NFS4_dec_lookup_sz      (compound_decode_hdr_maxsz + \
 493                                 decode_sequence_maxsz + \
 494                                 decode_putfh_maxsz + \
 495                                 decode_lookup_maxsz + \
 496                                 decode_getattr_maxsz + \
 497                                 decode_getfh_maxsz)
 498 #define NFS4_enc_lookup_root_sz (compound_encode_hdr_maxsz + \
 499                                 encode_sequence_maxsz + \
 500                                 encode_putrootfh_maxsz + \
 501                                 encode_getattr_maxsz + \
 502                                 encode_getfh_maxsz)
 503 #define NFS4_dec_lookup_root_sz (compound_decode_hdr_maxsz + \
 504                                 decode_sequence_maxsz + \
 505                                 decode_putrootfh_maxsz + \
 506                                 decode_getattr_maxsz + \
 507                                 decode_getfh_maxsz)
 508 #define NFS4_enc_remove_sz      (compound_encode_hdr_maxsz + \
 509                                 encode_sequence_maxsz + \
 510                                 encode_putfh_maxsz + \
 511                                 encode_remove_maxsz + \
 512                                 encode_getattr_maxsz)
 513 #define NFS4_dec_remove_sz      (compound_decode_hdr_maxsz + \
 514                                 decode_sequence_maxsz + \
 515                                 decode_putfh_maxsz + \
 516                                 decode_remove_maxsz + \
 517                                 decode_getattr_maxsz)
 518 #define NFS4_enc_rename_sz      (compound_encode_hdr_maxsz + \
 519                                 encode_sequence_maxsz + \
 520                                 encode_putfh_maxsz + \
 521                                 encode_savefh_maxsz + \
 522                                 encode_putfh_maxsz + \
 523                                 encode_rename_maxsz + \
 524                                 encode_getattr_maxsz + \
 525                                 encode_restorefh_maxsz + \
 526                                 encode_getattr_maxsz)
 527 #define NFS4_dec_rename_sz      (compound_decode_hdr_maxsz + \
 528                                 decode_sequence_maxsz + \
 529                                 decode_putfh_maxsz + \
 530                                 decode_savefh_maxsz + \
 531                                 decode_putfh_maxsz + \
 532                                 decode_rename_maxsz + \
 533                                 decode_getattr_maxsz + \
 534                                 decode_restorefh_maxsz + \
 535                                 decode_getattr_maxsz)
 536 #define NFS4_enc_link_sz        (compound_encode_hdr_maxsz + \
 537                                 encode_sequence_maxsz + \
 538                                 encode_putfh_maxsz + \
 539                                 encode_savefh_maxsz + \
 540                                 encode_putfh_maxsz + \
 541                                 encode_link_maxsz + \
 542                                 decode_getattr_maxsz + \
 543                                 encode_restorefh_maxsz + \
 544                                 decode_getattr_maxsz)
 545 #define NFS4_dec_link_sz        (compound_decode_hdr_maxsz + \
 546                                 decode_sequence_maxsz + \
 547                                 decode_putfh_maxsz + \
 548                                 decode_savefh_maxsz + \
 549                                 decode_putfh_maxsz + \
 550                                 decode_link_maxsz + \
 551                                 decode_getattr_maxsz + \
 552                                 decode_restorefh_maxsz + \
 553                                 decode_getattr_maxsz)
 554 #define NFS4_enc_symlink_sz     (compound_encode_hdr_maxsz + \
 555                                 encode_sequence_maxsz + \
 556                                 encode_putfh_maxsz + \
 557                                 encode_symlink_maxsz + \
 558                                 encode_getattr_maxsz + \
 559                                 encode_getfh_maxsz)
 560 #define NFS4_dec_symlink_sz     (compound_decode_hdr_maxsz + \
 561                                 decode_sequence_maxsz + \
 562                                 decode_putfh_maxsz + \
 563                                 decode_symlink_maxsz + \
 564                                 decode_getattr_maxsz + \
 565                                 decode_getfh_maxsz)
 566 #define NFS4_enc_create_sz      (compound_encode_hdr_maxsz + \
 567                                 encode_sequence_maxsz + \
 568                                 encode_putfh_maxsz + \
 569                                 encode_savefh_maxsz + \
 570                                 encode_create_maxsz + \
 571                                 encode_getfh_maxsz + \
 572                                 encode_getattr_maxsz + \
 573                                 encode_restorefh_maxsz + \
 574                                 encode_getattr_maxsz)
 575 #define NFS4_dec_create_sz      (compound_decode_hdr_maxsz + \
 576                                 decode_sequence_maxsz + \
 577                                 decode_putfh_maxsz + \
 578                                 decode_savefh_maxsz + \
 579                                 decode_create_maxsz + \
 580                                 decode_getfh_maxsz + \
 581                                 decode_getattr_maxsz + \
 582                                 decode_restorefh_maxsz + \
 583                                 decode_getattr_maxsz)
 584 #define NFS4_enc_pathconf_sz    (compound_encode_hdr_maxsz + \
 585                                 encode_sequence_maxsz + \
 586                                 encode_putfh_maxsz + \
 587                                 encode_getattr_maxsz)
 588 #define NFS4_dec_pathconf_sz    (compound_decode_hdr_maxsz + \
 589                                 decode_sequence_maxsz + \
 590                                 decode_putfh_maxsz + \
 591                                 decode_getattr_maxsz)
 592 #define NFS4_enc_statfs_sz      (compound_encode_hdr_maxsz + \
 593                                 encode_sequence_maxsz + \
 594                                 encode_putfh_maxsz + \
 595                                 encode_statfs_maxsz)
 596 #define NFS4_dec_statfs_sz      (compound_decode_hdr_maxsz + \
 597                                 decode_sequence_maxsz + \
 598                                 decode_putfh_maxsz + \
 599                                 decode_statfs_maxsz)
 600 #define NFS4_enc_server_caps_sz (compound_encode_hdr_maxsz + \
 601                                 encode_sequence_maxsz + \
 602                                 encode_putfh_maxsz + \
 603                                 encode_getattr_maxsz)
 604 #define NFS4_dec_server_caps_sz (compound_decode_hdr_maxsz + \
 605                                 decode_sequence_maxsz + \
 606                                 decode_putfh_maxsz + \
 607                                 decode_getattr_maxsz)
 608 #define NFS4_enc_delegreturn_sz (compound_encode_hdr_maxsz + \
 609                                 encode_sequence_maxsz + \
 610                                 encode_putfh_maxsz + \
 611                                 encode_delegreturn_maxsz + \
 612                                 encode_getattr_maxsz)
 613 #define NFS4_dec_delegreturn_sz (compound_decode_hdr_maxsz + \
 614                                 decode_sequence_maxsz + \
 615                                 decode_delegreturn_maxsz + \
 616                                 decode_getattr_maxsz)
 617 #define NFS4_enc_getacl_sz      (compound_encode_hdr_maxsz + \
 618                                 encode_sequence_maxsz + \
 619                                 encode_putfh_maxsz + \
 620                                 encode_getacl_maxsz)
 621 #define NFS4_dec_getacl_sz      (compound_decode_hdr_maxsz + \
 622                                 decode_sequence_maxsz + \
 623                                 decode_putfh_maxsz + \
 624                                 decode_getacl_maxsz)
 625 #define NFS4_enc_setacl_sz      (compound_encode_hdr_maxsz + \
 626                                 encode_sequence_maxsz + \
 627                                 encode_putfh_maxsz + \
 628                                 encode_setacl_maxsz)
 629 #define NFS4_dec_setacl_sz      (compound_decode_hdr_maxsz + \
 630                                 decode_sequence_maxsz + \
 631                                 decode_putfh_maxsz + \
 632                                 decode_setacl_maxsz)
 633 #define NFS4_enc_fs_locations_sz \
 634                                 (compound_encode_hdr_maxsz + \
 635                                  encode_sequence_maxsz + \
 636                                  encode_putfh_maxsz + \
 637                                  encode_lookup_maxsz + \
 638                                  encode_fs_locations_maxsz)
 639 #define NFS4_dec_fs_locations_sz \
 640                                 (compound_decode_hdr_maxsz + \
 641                                  decode_sequence_maxsz + \
 642                                  decode_putfh_maxsz + \
 643                                  decode_lookup_maxsz + \
 644                                  decode_fs_locations_maxsz)
 645 #if defined(CONFIG_NFS_V4_1)
 646 #define NFS4_enc_exchange_id_sz \
 647                                 (compound_encode_hdr_maxsz + \
 648                                  encode_exchange_id_maxsz)
 649 #define NFS4_dec_exchange_id_sz \
 650                                 (compound_decode_hdr_maxsz + \
 651                                  decode_exchange_id_maxsz)
 652 #define NFS4_enc_create_session_sz \
 653                                 (compound_encode_hdr_maxsz + \
 654                                  encode_create_session_maxsz)
 655 #define NFS4_dec_create_session_sz \
 656                                 (compound_decode_hdr_maxsz + \
 657                                  decode_create_session_maxsz)
 658 #define NFS4_enc_get_lease_time_sz      (compound_encode_hdr_maxsz + \
 659                                          encode_sequence_maxsz + \
 660                                          encode_putrootfh_maxsz + \
 661                                          encode_fsinfo_maxsz)
 662 #define NFS4_dec_get_lease_time_sz      (compound_decode_hdr_maxsz + \
 663                                          decode_sequence_maxsz + \
 664                                          decode_putrootfh_maxsz + \
 665                                          decode_fsinfo_maxsz)
 666 #endif /* CONFIG_NFS_V4_1 */
 667
 668 static const umode_t nfs_type2fmt[] = {
 669         [NF4BAD] = 0,
 670         [NF4REG] = S_IFREG,
 671         [NF4DIR] = S_IFDIR,
 672         [NF4BLK] = S_IFBLK,
 673         [NF4CHR] = S_IFCHR,
 674         [NF4LNK] = S_IFLNK,
 675         [NF4SOCK] = S_IFSOCK,
 676         [NF4FIFO] = S_IFIFO,
 677         [NF4ATTRDIR] = 0,
 678         [NF4NAMEDATTR] = 0,
 679 };
 680
 681 struct compound_hdr {
 682         int32_t         status;
 683         uint32_t        nops;
 684         __be32 *        nops_p;
 685         uint32_t        taglen;
 686         char *          tag;
 687         uint32_t        replen;         /* expected reply words */
 688         u32             minorversion;
 689 };
 690
 691 /*
 692  * START OF "GENERIC" ENCODE ROUTINES.
 693  *   These may look a little ugly since they are imported from a "generic"
 694  * set of XDR encode/decode routines which are intended to be shared by
 695  * all of our NFSv4 implementations (OpenBSD, MacOS X...).
 696  *
 697  * If the pain of reading these is too great, it should be a straightforward
 698  * task to translate them into Linux-specific versions which are more
 699  * consistent with the style used in NFSv2/v3...
 700  */
 701 #define WRITE32(n)               *p++ = htonl(n)
 702 #define WRITE64(n)               do {                           \
 703         *p++ = htonl((uint32_t)((n) >> 32));                            \
 704         *p++ = htonl((uint32_t)(n));                                    \
 705 } while (0)
 706 #define WRITEMEM(ptr,nbytes)     do {                           \
 707         p = xdr_encode_opaque_fixed(p, ptr, nbytes);            \
 708 } while (0)
 709
 710 #define RESERVE_SPACE(nbytes)   do {                            \
 711         p = xdr_reserve_space(xdr, nbytes);                     \
 712         BUG_ON(!p);                                             \
 713 } while (0)
 714
 715 static void encode_string(struct xdr_stream *xdr, unsigned int len, const char *str)
 716 {
 717         __be32 *p;
 718
 719         p = xdr_reserve_space(xdr, 4 + len);
 720         BUG_ON(p == NULL);
 721         xdr_encode_opaque(p, str, len);
 722 }
 723
 724 static void encode_compound_hdr(struct xdr_stream *xdr,
 725                                 struct rpc_rqst *req,
 726                                 struct compound_hdr *hdr)
 727 {
 728         __be32 *p;
 729         struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
 730
 731         /* initialize running count of expected bytes in reply.
 732          * NOTE: the replied tag SHOULD be the same is the one sent,
 733          * but this is not required as a MUST for the server to do so. */
 734         hdr->replen = RPC_REPHDRSIZE + auth->au_rslack + 3 + hdr->taglen;
 735
 736         dprintk("encode_compound: tag=%.*s\n", (int)hdr->taglen, hdr->tag);
 737         BUG_ON(hdr->taglen > NFS4_MAXTAGLEN);
 738         RESERVE_SPACE(12+(XDR_QUADLEN(hdr->taglen)<<2));
 739         WRITE32(hdr->taglen);
 740         WRITEMEM(hdr->tag, hdr->taglen);
 741         WRITE32(hdr->minorversion);
 742         hdr->nops_p = p;
 743         WRITE32(hdr->nops);
 744 }
 745
 746 static void encode_nops(struct compound_hdr *hdr)
 747 {
 748         BUG_ON(hdr->nops > NFS4_MAX_OPS);
 749         *hdr->nops_p = htonl(hdr->nops);
 750 }
 751
 752 static void encode_nfs4_verifier(struct xdr_stream *xdr, const nfs4_verifier *verf)
 753 {
 754         __be32 *p;
 755
 756         p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE);
 757         BUG_ON(p == NULL);
 758         xdr_encode_opaque_fixed(p, verf->data, NFS4_VERIFIER_SIZE);
 759 }
 760
 761 static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const struct nfs_server *server)
 762 {
 763         char owner_name[IDMAP_NAMESZ];
 764         char owner_group[IDMAP_NAMESZ];
 765         int owner_namelen = 0;
 766         int owner_grouplen = 0;
 767         __be32 *p;
 768         __be32 *q;
 769         int len;
 770         uint32_t bmval0 = 0;
 771         uint32_t bmval1 = 0;
 772
 773         /*
 774          * We reserve enough space to write the entire attribute buffer at once.
 775          * In the worst-case, this would be
 776          *   12(bitmap) + 4(attrlen) + 8(size) + 4(mode) + 4(atime) + 4(mtime)
 777          *          = 36 bytes, plus any contribution from variable-length fields
 778          *            such as owner/group.
 779          */
 780         len = 16;
 781
 782         /* Sigh */
 783         if (iap->ia_valid & ATTR_SIZE)
 784                 len += 8;
 785         if (iap->ia_valid & ATTR_MODE)
 786                 len += 4;
 787         if (iap->ia_valid & ATTR_UID) {
 788                 owner_namelen = nfs_map_uid_to_name(server->nfs_client, iap->ia_uid, owner_name);
 789                 if (owner_namelen < 0) {
 790                         dprintk("nfs: couldn't resolve uid %d to string\n",
 791                                         iap->ia_uid);
 792                         /* XXX */
 793                         strcpy(owner_name, "nobody");
 794                         owner_namelen = sizeof("nobody") - 1;
 795                         /* goto out; */
 796                 }
 797                 len += 4 + (XDR_QUADLEN(owner_namelen) << 2);
 798         }
 799         if (iap->ia_valid & ATTR_GID) {
 800                 owner_grouplen = nfs_map_gid_to_group(server->nfs_client, iap->ia_gid, owner_group);
 801                 if (owner_grouplen < 0) {
 802                         dprintk("nfs: couldn't resolve gid %d to string\n",
 803                                         iap->ia_gid);
 804                         strcpy(owner_group, "nobody");
 805                         owner_grouplen = sizeof("nobody") - 1;
 806                         /* goto out; */
 807                 }
 808                 len += 4 + (XDR_QUADLEN(owner_grouplen) << 2);
 809         }
 810         if (iap->ia_valid & ATTR_ATIME_SET)
 811                 len += 16;
 812         else if (iap->ia_valid & ATTR_ATIME)
 813                 len += 4;
 814         if (iap->ia_valid & ATTR_MTIME_SET)
 815                 len += 16;
 816         else if (iap->ia_valid & ATTR_MTIME)
 817                 len += 4;
 818         RESERVE_SPACE(len);
 819
 820         /*
 821          * We write the bitmap length now, but leave the bitmap and the attribute
 822          * buffer length to be backfilled at the end of this routine.
 823          */
 824         WRITE32(2);
 825         q = p;
 826         p += 3;
 827
 828         if (iap->ia_valid & ATTR_SIZE) {
 829                 bmval0 |= FATTR4_WORD0_SIZE;
 830                 WRITE64(iap->ia_size);
 831         }
 832         if (iap->ia_valid & ATTR_MODE) {
 833                 bmval1 |= FATTR4_WORD1_MODE;
 834                 WRITE32(iap->ia_mode & S_IALLUGO);
 835         }
 836         if (iap->ia_valid & ATTR_UID) {
 837                 bmval1 |= FATTR4_WORD1_OWNER;
 838                 WRITE32(owner_namelen);
 839                 WRITEMEM(owner_name, owner_namelen);
 840         }
 841         if (iap->ia_valid & ATTR_GID) {
 842                 bmval1 |= FATTR4_WORD1_OWNER_GROUP;
 843                 WRITE32(owner_grouplen);
 844                 WRITEMEM(owner_group, owner_grouplen);
 845         }
 846         if (iap->ia_valid & ATTR_ATIME_SET) {
 847                 bmval1 |= FATTR4_WORD1_TIME_ACCESS_SET;
 848                 WRITE32(NFS4_SET_TO_CLIENT_TIME);
 849                 WRITE32(0);
 850                 WRITE32(iap->ia_mtime.tv_sec);
 851                 WRITE32(iap->ia_mtime.tv_nsec);
 852         }
 853         else if (iap->ia_valid & ATTR_ATIME) {
 854                 bmval1 |= FATTR4_WORD1_TIME_ACCESS_SET;
 855                 WRITE32(NFS4_SET_TO_SERVER_TIME);
 856         }
 857         if (iap->ia_valid & ATTR_MTIME_SET) {
 858                 bmval1 |= FATTR4_WORD1_TIME_MODIFY_SET;
 859                 WRITE32(NFS4_SET_TO_CLIENT_TIME);
 860                 WRITE32(0);
 861                 WRITE32(iap->ia_mtime.tv_sec);
 862                 WRITE32(iap->ia_mtime.tv_nsec);
 863         }
 864         else if (iap->ia_valid & ATTR_MTIME) {
 865                 bmval1 |= FATTR4_WORD1_TIME_MODIFY_SET;
 866                 WRITE32(NFS4_SET_TO_SERVER_TIME);
 867         }
 868
 869         /*
 870          * Now we backfill the bitmap and the attribute buffer length.
 871          */
 872         if (len != ((char *)p - (char *)q) + 4) {
 873                 printk(KERN_ERR "nfs: Attr length error, %u != %Zu\n",
 874                                 len, ((char *)p - (char *)q) + 4);
 875                 BUG();
 876         }
 877         len = (char *)p - (char *)q - 12;
 878         *q++ = htonl(bmval0);
 879         *q++ = htonl(bmval1);
 880         *q++ = htonl(len);
 881
 882 /* out: */
 883 }
 884
 885 static void encode_access(struct xdr_stream *xdr, u32 access, struct compound_hdr *hdr)
 886 {
 887         __be32 *p;
 888
 889         RESERVE_SPACE(8);
 890         WRITE32(OP_ACCESS);
 891         WRITE32(access);
 892         hdr->nops++;
 893         hdr->replen += decode_access_maxsz;
 894 }
 895
 896 static void encode_close(struct xdr_stream *xdr, const struct nfs_closeargs *arg, struct compound_hdr *hdr)
 897 {
 898         __be32 *p;
 899
 900         RESERVE_SPACE(8+NFS4_STATEID_SIZE);
 901         WRITE32(OP_CLOSE);
 902         WRITE32(arg->seqid->sequence->counter);
 903         WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE);
 904         hdr->nops++;
 905         hdr->replen += decode_close_maxsz;
 906 }
 907
 908 static void encode_commit(struct xdr_stream *xdr, const struct nfs_writeargs *args, struct compound_hdr *hdr)
 909 {
 910         __be32 *p;
 911
 912         RESERVE_SPACE(16);
 913         WRITE32(OP_COMMIT);
 914         WRITE64(args->offset);
 915         WRITE32(args->count);
 916         hdr->nops++;
 917         hdr->replen += decode_commit_maxsz;
 918 }
 919
 920 static void encode_create(struct xdr_stream *xdr, const struct nfs4_create_arg *create, struct compound_hdr *hdr)
 921 {
 922         __be32 *p;
 923
 924         RESERVE_SPACE(8);
 925         WRITE32(OP_CREATE);
 926         WRITE32(create->ftype);
 927
 928         switch (create->ftype) {
 929         case NF4LNK:
 930                 RESERVE_SPACE(4);
 931                 WRITE32(create->u.symlink.len);
 932                 xdr_write_pages(xdr, create->u.symlink.pages, 0, create->u.symlink.len);
 933                 break;
 934
 935         case NF4BLK: case NF4CHR:
 936                 RESERVE_SPACE(8);
 937                 WRITE32(create->u.device.specdata1);
 938                 WRITE32(create->u.device.specdata2);
 939                 break;
 940
 941         default:
 942                 break;
 943         }
 944
 945         RESERVE_SPACE(4 + create->name->len);
 946         WRITE32(create->name->len);
 947         WRITEMEM(create->name->name, create->name->len);
 948         hdr->nops++;
 949         hdr->replen += decode_create_maxsz;
 950
 951         encode_attrs(xdr, create->attrs, create->server);
 952 }
 953
 954 static void encode_getattr_one(struct xdr_stream *xdr, uint32_t bitmap, struct compound_hdr *hdr)
 955 {
 956         __be32 *p;
 957
 958         RESERVE_SPACE(12);
 959         WRITE32(OP_GETATTR);
 960         WRITE32(1);
 961         WRITE32(bitmap);
 962         hdr->nops++;
 963         hdr->replen += decode_getattr_maxsz;
 964 }
 965
 966 static void encode_getattr_two(struct xdr_stream *xdr, uint32_t bm0, uint32_t bm1, struct compound_hdr *hdr)
 967 {
 968         __be32 *p;
 969
 970         RESERVE_SPACE(16);
 971         WRITE32(OP_GETATTR);
 972         WRITE32(2);
 973         WRITE32(bm0);
 974         WRITE32(bm1);
 975         hdr->nops++;
 976         hdr->replen += decode_getattr_maxsz;
 977 }
 978
 979 static void encode_getfattr(struct xdr_stream *xdr, const u32* bitmask, struct compound_hdr *hdr)
 980 {
 981         encode_getattr_two(xdr, bitmask[0] & nfs4_fattr_bitmap[0],
 982                            bitmask[1] & nfs4_fattr_bitmap[1], hdr);
 983 }
 984
 985 static void encode_fsinfo(struct xdr_stream *xdr, const u32* bitmask, struct compound_hdr *hdr)
 986 {
 987         encode_getattr_two(xdr, bitmask[0] & nfs4_fsinfo_bitmap[0],
 988                            bitmask[1] & nfs4_fsinfo_bitmap[1], hdr);
 989 }
 990
 991 static void encode_fs_locations(struct xdr_stream *xdr, const u32* bitmask, struct compound_hdr *hdr)
 992 {
 993         encode_getattr_two(xdr, bitmask[0] & nfs4_fs_locations_bitmap[0],
 994                            bitmask[1] & nfs4_fs_locations_bitmap[1], hdr);
 995 }
 996
 997 static void encode_getfh(struct xdr_stream *xdr, struct compound_hdr *hdr)
 998 {
 999         __be32 *p;
1000
1001         RESERVE_SPACE(4);
1002         WRITE32(OP_GETFH);
1003         hdr->nops++;
1004         hdr->replen += decode_getfh_maxsz;
1005 }
1006
1007 static void encode_link(struct xdr_stream *xdr, const struct qstr *name, struct compound_hdr *hdr)
1008 {
1009         __be32 *p;
1010
1011         RESERVE_SPACE(8 + name->len);
1012         WRITE32(OP_LINK);
1013         WRITE32(name->len);
1014         WRITEMEM(name->name, name->len);
1015         hdr->nops++;
1016         hdr->replen += decode_link_maxsz;
1017 }
1018
1019 static inline int nfs4_lock_type(struct file_lock *fl, int block)
1020 {
1021         if ((fl->fl_type & (F_RDLCK|F_WRLCK|F_UNLCK)) == F_RDLCK)
1022                 return block ? NFS4_READW_LT : NFS4_READ_LT;
1023         return block ? NFS4_WRITEW_LT : NFS4_WRITE_LT;
1024 }
1025
1026 static inline uint64_t nfs4_lock_length(struct file_lock *fl)
1027 {
1028         if (fl->fl_end == OFFSET_MAX)
1029                 return ~(uint64_t)0;
1030         return fl->fl_end - fl->fl_start + 1;
1031 }
1032
1033 /*
1034  * opcode,type,reclaim,offset,length,new_lock_owner = 32
1035  * open_seqid,open_stateid,lock_seqid,lock_owner.clientid, lock_owner.id = 40
1036  */
1037 static void encode_lock(struct xdr_stream *xdr, const struct nfs_lock_args *args, struct compound_hdr *hdr)
1038 {
1039         __be32 *p;
1040
1041         RESERVE_SPACE(32);
1042         WRITE32(OP_LOCK);
1043         WRITE32(nfs4_lock_type(args->fl, args->block));
1044         WRITE32(args->reclaim);
1045         WRITE64(args->fl->fl_start);
1046         WRITE64(nfs4_lock_length(args->fl));
1047         WRITE32(args->new_lock_owner);
1048         if (args->new_lock_owner){
1049                 RESERVE_SPACE(4+NFS4_STATEID_SIZE+32);
1050                 WRITE32(args->open_seqid->sequence->counter);
1051                 WRITEMEM(args->open_stateid->data, NFS4_STATEID_SIZE);
1052                 WRITE32(args->lock_seqid->sequence->counter);
1053                 WRITE64(args->lock_owner.clientid);
1054                 WRITE32(16);
1055                 WRITEMEM("lock id:", 8);
1056                 WRITE64(args->lock_owner.id);
1057         }
1058         else {
1059                 RESERVE_SPACE(NFS4_STATEID_SIZE+4);
1060                 WRITEMEM(args->lock_stateid->data, NFS4_STATEID_SIZE);
1061                 WRITE32(args->lock_seqid->sequence->counter);
1062         }
1063         hdr->nops++;
1064         hdr->replen += decode_lock_maxsz;
1065 }
1066
1067 static void encode_lockt(struct xdr_stream *xdr, const struct nfs_lockt_args *args, struct compound_hdr *hdr)
1068 {
1069         __be32 *p;
1070
1071         RESERVE_SPACE(52);
1072         WRITE32(OP_LOCKT);
1073         WRITE32(nfs4_lock_type(args->fl, 0));
1074         WRITE64(args->fl->fl_start);
1075         WRITE64(nfs4_lock_length(args->fl));
1076         WRITE64(args->lock_owner.clientid);
1077         WRITE32(16);
1078         WRITEMEM("lock id:", 8);
1079         WRITE64(args->lock_owner.id);
1080         hdr->nops++;
1081         hdr->replen += decode_lockt_maxsz;
1082 }
1083
1084 static void encode_locku(struct xdr_stream *xdr, const struct nfs_locku_args *args, struct compound_hdr *hdr)
1085 {
1086         __be32 *p;
1087
1088         RESERVE_SPACE(12+NFS4_STATEID_SIZE+16);
1089         WRITE32(OP_LOCKU);
1090         WRITE32(nfs4_lock_type(args->fl, 0));
1091         WRITE32(args->seqid->sequence->counter);
1092         WRITEMEM(args->stateid->data, NFS4_STATEID_SIZE);
1093         WRITE64(args->fl->fl_start);
1094         WRITE64(nfs4_lock_length(args->fl));
1095         hdr->nops++;
1096         hdr->replen += decode_locku_maxsz;
1097 }
1098
1099 static void encode_lookup(struct xdr_stream *xdr, const struct qstr *name, struct compound_hdr *hdr)
1100 {
1101         int len = name->len;
1102         __be32 *p;
1103
1104         RESERVE_SPACE(8 + len);
1105         WRITE32(OP_LOOKUP);
1106         WRITE32(len);
1107         WRITEMEM(name->name, len);
1108         hdr->nops++;
1109         hdr->replen += decode_lookup_maxsz;
1110 }
1111
1112 static void encode_share_access(struct xdr_stream *xdr, fmode_t fmode)
1113 {
1114         __be32 *p;
1115
1116         RESERVE_SPACE(8);
1117         switch (fmode & (FMODE_READ|FMODE_WRITE)) {
1118         case FMODE_READ:
1119                 WRITE32(NFS4_SHARE_ACCESS_READ);
1120                 break;
1121         case FMODE_WRITE:
1122                 WRITE32(NFS4_SHARE_ACCESS_WRITE);
1123                 break;
1124         case FMODE_READ|FMODE_WRITE:
1125                 WRITE32(NFS4_SHARE_ACCESS_BOTH);
1126                 break;
1127         default:
1128                 WRITE32(0);
1129         }
1130         WRITE32(0);             /* for linux, share_deny = 0 always */
1131 }
1132
1133 static inline void encode_openhdr(struct xdr_stream *xdr, const struct nfs_openargs *arg)
1134 {
1135         __be32 *p;
1136  /*
1137  * opcode 4, seqid 4, share_access 4, share_deny 4, clientid 8, ownerlen 4,
1138  * owner 4 = 32
1139  */
1140         RESERVE_SPACE(8);
1141         WRITE32(OP_OPEN);
1142         WRITE32(arg->seqid->sequence->counter);
1143         encode_share_access(xdr, arg->fmode);
1144         RESERVE_SPACE(28);
1145         WRITE64(arg->clientid);
1146         WRITE32(16);
1147         WRITEMEM("open id:", 8);
1148         WRITE64(arg->id);
1149 }
1150
1151 static inline void encode_createmode(struct xdr_stream *xdr, const struct nfs_openargs *arg)
1152 {
1153         __be32 *p;
1154
1155         RESERVE_SPACE(4);
1156         switch(arg->open_flags & O_EXCL) {
1157         case 0:
1158                 WRITE32(NFS4_CREATE_UNCHECKED);
1159                 encode_attrs(xdr, arg->u.attrs, arg->server);
1160                 break;
1161         default:
1162                 WRITE32(NFS4_CREATE_EXCLUSIVE);
1163                 encode_nfs4_verifier(xdr, &arg->u.verifier);
1164         }
1165 }
1166
1167 static void encode_opentype(struct xdr_stream *xdr, const struct nfs_openargs *arg)
1168 {
1169         __be32 *p;
1170
1171         RESERVE_SPACE(4);
1172         switch (arg->open_flags & O_CREAT) {
1173         case 0:
1174                 WRITE32(NFS4_OPEN_NOCREATE);
1175                 break;
1176         default:
1177                 BUG_ON(arg->claim != NFS4_OPEN_CLAIM_NULL);
1178                 WRITE32(NFS4_OPEN_CREATE);
1179                 encode_createmode(xdr, arg);
1180         }
1181 }
1182
1183 static inline void encode_delegation_type(struct xdr_stream *xdr, fmode_t delegation_type)
1184 {
1185         __be32 *p;
1186
1187         RESERVE_SPACE(4);
1188         switch (delegation_type) {
1189         case 0:
1190                 WRITE32(NFS4_OPEN_DELEGATE_NONE);
1191                 break;
1192         case FMODE_READ:
1193                 WRITE32(NFS4_OPEN_DELEGATE_READ);
1194                 break;
1195         case FMODE_WRITE|FMODE_READ:
1196                 WRITE32(NFS4_OPEN_DELEGATE_WRITE);
1197                 break;
1198         default:
1199                 BUG();
1200         }
1201 }
1202
1203 static inline void encode_claim_null(struct xdr_stream *xdr, const struct qstr *name)
1204 {
1205         __be32 *p;
1206
1207         RESERVE_SPACE(4);
1208         WRITE32(NFS4_OPEN_CLAIM_NULL);
1209         encode_string(xdr, name->len, name->name);
1210 }
1211
1212 static inline void encode_claim_previous(struct xdr_stream *xdr, fmode_t type)
1213 {
1214         __be32 *p;
1215
1216         RESERVE_SPACE(4);
1217         WRITE32(NFS4_OPEN_CLAIM_PREVIOUS);
1218         encode_delegation_type(xdr, type);
1219 }
1220
1221 static inline void encode_claim_delegate_cur(struct xdr_stream *xdr, const struct qstr *name, const nfs4_stateid *stateid)
1222 {
1223         __be32 *p;
1224
1225         RESERVE_SPACE(4+NFS4_STATEID_SIZE);
1226         WRITE32(NFS4_OPEN_CLAIM_DELEGATE_CUR);
1227         WRITEMEM(stateid->data, NFS4_STATEID_SIZE);
1228         encode_string(xdr, name->len, name->name);
1229 }
1230
1231 static void encode_open(struct xdr_stream *xdr, const struct nfs_openargs *arg, struct compound_hdr *hdr)
1232 {
1233         encode_openhdr(xdr, arg);
1234         encode_opentype(xdr, arg);
1235         switch (arg->claim) {
1236         case NFS4_OPEN_CLAIM_NULL:
1237                 encode_claim_null(xdr, arg->name);
1238                 break;
1239         case NFS4_OPEN_CLAIM_PREVIOUS:
1240                 encode_claim_previous(xdr, arg->u.delegation_type);
1241                 break;
1242         case NFS4_OPEN_CLAIM_DELEGATE_CUR:
1243                 encode_claim_delegate_cur(xdr, arg->name, &arg->u.delegation);
1244                 break;
1245         default:
1246                 BUG();
1247         }
1248         hdr->nops++;
1249         hdr->replen += decode_open_maxsz;
1250 }
1251
1252 static void encode_open_confirm(struct xdr_stream *xdr, const struct nfs_open_confirmargs *arg, struct compound_hdr *hdr)
1253 {
1254         __be32 *p;
1255
1256         RESERVE_SPACE(4+NFS4_STATEID_SIZE+4);
1257         WRITE32(OP_OPEN_CONFIRM);
1258         WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE);
1259         WRITE32(arg->seqid->sequence->counter);
1260         hdr->nops++;
1261         hdr->replen += decode_open_confirm_maxsz;
1262 }
1263
1264 static void encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closeargs *arg, struct compound_hdr *hdr)
1265 {
1266         __be32 *p;
1267
1268         RESERVE_SPACE(4+NFS4_STATEID_SIZE+4);
1269         WRITE32(OP_OPEN_DOWNGRADE);
1270         WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE);
1271         WRITE32(arg->seqid->sequence->counter);
1272         encode_share_access(xdr, arg->fmode);
1273         hdr->nops++;
1274         hdr->replen += decode_open_downgrade_maxsz;
1275 }
1276
1277 static void
1278 encode_putfh(struct xdr_stream *xdr, const struct nfs_fh *fh, struct compound_hdr *hdr)
1279 {
1280         int len = fh->size;
1281         __be32 *p;
1282
1283         RESERVE_SPACE(8 + len);
1284         WRITE32(OP_PUTFH);
1285         WRITE32(len);
1286         WRITEMEM(fh->data, len);
1287         hdr->nops++;
1288         hdr->replen += decode_putfh_maxsz;
1289 }
1290
1291 static void encode_putrootfh(struct xdr_stream *xdr, struct compound_hdr *hdr)
1292 {
1293         __be32 *p;
1294
1295         RESERVE_SPACE(4);
1296         WRITE32(OP_PUTROOTFH);
1297         hdr->nops++;
1298         hdr->replen += decode_putrootfh_maxsz;
1299 }
1300
1301 static void encode_stateid(struct xdr_stream *xdr, const struct nfs_open_context *ctx)
1302 {
1303         nfs4_stateid stateid;
1304         __be32 *p;
1305
1306         RESERVE_SPACE(NFS4_STATEID_SIZE);
1307         if (ctx->state != NULL) {
1308                 nfs4_copy_stateid(&stateid, ctx->state, ctx->lockowner);
1309                 WRITEMEM(stateid.data, NFS4_STATEID_SIZE);
1310         } else
1311                 WRITEMEM(zero_stateid.data, NFS4_STATEID_SIZE);
1312 }
1313
1314 static void encode_read(struct xdr_stream *xdr, const struct nfs_readargs *args, struct compound_hdr *hdr)
1315 {
1316         __be32 *p;
1317
1318         RESERVE_SPACE(4);
1319         WRITE32(OP_READ);
1320
1321         encode_stateid(xdr, args->context);
1322
1323         RESERVE_SPACE(12);
1324         WRITE64(args->offset);
1325         WRITE32(args->count);
1326         hdr->nops++;
1327         hdr->replen += decode_read_maxsz;
1328 }
1329
1330 static void encode_readdir(struct xdr_stream *xdr, const struct nfs4_readdir_arg *readdir, struct rpc_rqst *req, struct compound_hdr *hdr)
1331 {
1332         uint32_t attrs[2] = {
1333                 FATTR4_WORD0_RDATTR_ERROR|FATTR4_WORD0_FILEID,
1334                 FATTR4_WORD1_MOUNTED_ON_FILEID,
1335         };
1336         __be32 *p;
1337
1338         RESERVE_SPACE(12+NFS4_VERIFIER_SIZE+20);
1339         WRITE32(OP_READDIR);
1340         WRITE64(readdir->cookie);
1341         WRITEMEM(readdir->verifier.data, NFS4_VERIFIER_SIZE);
1342         WRITE32(readdir->count >> 1);  /* We're not doing readdirplus */
1343         WRITE32(readdir->count);
1344         WRITE32(2);
1345         /* Switch to mounted_on_fileid if the server supports it */
1346         if (readdir->bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)
1347                 attrs[0] &= ~FATTR4_WORD0_FILEID;
1348         else
1349                 attrs[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID;
1350         WRITE32(attrs[0] & readdir->bitmask[0]);
1351         WRITE32(attrs[1] & readdir->bitmask[1]);
1352         hdr->nops++;
1353         hdr->replen += decode_readdir_maxsz;
1354         dprintk("%s: cookie = %Lu, verifier = %08x:%08x, bitmap = %08x:%08x\n",
1355                         __func__,
1356                         (unsigned long long)readdir->cookie,
1357                         ((u32 *)readdir->verifier.data)[0],
1358                         ((u32 *)readdir->verifier.data)[1],
1359                         attrs[0] & readdir->bitmask[0],
1360                         attrs[1] & readdir->bitmask[1]);
1361 }
1362
1363 static void encode_readlink(struct xdr_stream *xdr, const struct nfs4_readlink *readlink, struct rpc_rqst *req, struct compound_hdr *hdr)
1364 {
1365         __be32 *p;
1366
1367         RESERVE_SPACE(4);
1368         WRITE32(OP_READLINK);
1369         hdr->nops++;
1370         hdr->replen += decode_readlink_maxsz;
1371 }
1372
1373 static void encode_remove(struct xdr_stream *xdr, const struct qstr *name, struct compound_hdr *hdr)
1374 {
1375         __be32 *p;
1376
1377         RESERVE_SPACE(8 + name->len);
1378         WRITE32(OP_REMOVE);
1379         WRITE32(name->len);
1380         WRITEMEM(name->name, name->len);
1381         hdr->nops++;
1382         hdr->replen += decode_remove_maxsz;
1383 }
1384
1385 static void encode_rename(struct xdr_stream *xdr, const struct qstr *oldname, const struct qstr *newname, struct compound_hdr *hdr)
1386 {
1387         __be32 *p;
1388
1389         RESERVE_SPACE(8 + oldname->len);
1390         WRITE32(OP_RENAME);
1391         WRITE32(oldname->len);
1392         WRITEMEM(oldname->name, oldname->len);
1393
1394         RESERVE_SPACE(4 + newname->len);
1395         WRITE32(newname->len);
1396         WRITEMEM(newname->name, newname->len);
1397         hdr->nops++;
1398         hdr->replen += decode_rename_maxsz;
1399 }
1400
1401 static void encode_renew(struct xdr_stream *xdr, const struct nfs_client *client_stateid, struct compound_hdr *hdr)
1402 {
1403         __be32 *p;
1404
1405         RESERVE_SPACE(12);
1406         WRITE32(OP_RENEW);
1407         WRITE64(client_stateid->cl_clientid);
1408         hdr->nops++;
1409         hdr->replen += decode_renew_maxsz;
1410 }
1411
1412 static void
1413 encode_restorefh(struct xdr_stream *xdr, struct compound_hdr *hdr)
1414 {
1415         __be32 *p;
1416
1417         RESERVE_SPACE(4);
1418         WRITE32(OP_RESTOREFH);
1419         hdr->nops++;
1420         hdr->replen += decode_restorefh_maxsz;
1421 }
1422
1423 static int
1424 encode_setacl(struct xdr_stream *xdr, struct nfs_setaclargs *arg, struct compound_hdr *hdr)
1425 {
1426         __be32 *p;
1427
1428         RESERVE_SPACE(4+NFS4_STATEID_SIZE);
1429         WRITE32(OP_SETATTR);
1430         WRITEMEM(zero_stateid.data, NFS4_STATEID_SIZE);
1431         RESERVE_SPACE(2*4);
1432         WRITE32(1);
1433         WRITE32(FATTR4_WORD0_ACL);
1434         if (arg->acl_len % 4)
1435                 return -EINVAL;
1436         RESERVE_SPACE(4);
1437         WRITE32(arg->acl_len);
1438         xdr_write_pages(xdr, arg->acl_pages, arg->acl_pgbase, arg->acl_len);
1439         hdr->nops++;
1440         hdr->replen += decode_setacl_maxsz;
1441         return 0;
1442 }
1443
1444 static void
1445 encode_savefh(struct xdr_stream *xdr, struct compound_hdr *hdr)
1446 {
1447         __be32 *p;
1448
1449         RESERVE_SPACE(4);
1450         WRITE32(OP_SAVEFH);
1451         hdr->nops++;
1452         hdr->replen += decode_savefh_maxsz;
1453 }
1454
1455 static void encode_setattr(struct xdr_stream *xdr, const struct nfs_setattrargs *arg, const struct nfs_server *server, struct compound_hdr *hdr)
1456 {
1457         __be32 *p;
1458
1459         RESERVE_SPACE(4+NFS4_STATEID_SIZE);
1460         WRITE32(OP_SETATTR);
1461         WRITEMEM(arg->stateid.data, NFS4_STATEID_SIZE);
1462         hdr->nops++;
1463         hdr->replen += decode_setattr_maxsz;
1464         encode_attrs(xdr, arg->iap, server);
1465 }
1466
1467 static void encode_setclientid(struct xdr_stream *xdr, const struct nfs4_setclientid *setclientid, struct compound_hdr *hdr)
1468 {
1469         __be32 *p;
1470
1471         RESERVE_SPACE(4 + NFS4_VERIFIER_SIZE);
1472         WRITE32(OP_SETCLIENTID);
1473         WRITEMEM(setclientid->sc_verifier->data, NFS4_VERIFIER_SIZE);
1474
1475         encode_string(xdr, setclientid->sc_name_len, setclientid->sc_name);
1476         RESERVE_SPACE(4);
1477         WRITE32(setclientid->sc_prog);
1478         encode_string(xdr, setclientid->sc_netid_len, setclientid->sc_netid);
1479         encode_string(xdr, setclientid->sc_uaddr_len, setclientid->sc_uaddr);
1480         RESERVE_SPACE(4);
1481         WRITE32(setclientid->sc_cb_ident);
1482         hdr->nops++;
1483         hdr->replen += decode_setclientid_maxsz;
1484 }
1485
1486 static void encode_setclientid_confirm(struct xdr_stream *xdr, const struct nfs_client *client_state, struct compound_hdr *hdr)
1487 {
1488         __be32 *p;
1489
1490         RESERVE_SPACE(12 + NFS4_VERIFIER_SIZE);
1491         WRITE32(OP_SETCLIENTID_CONFIRM);
1492         WRITE64(client_state->cl_clientid);
1493         WRITEMEM(client_state->cl_confirm.data, NFS4_VERIFIER_SIZE);
1494         hdr->nops++;
1495         hdr->replen += decode_setclientid_confirm_maxsz;
1496 }
1497
1498 static void encode_write(struct xdr_stream *xdr, const struct nfs_writeargs *args, struct compound_hdr *hdr)
1499 {
1500         __be32 *p;
1501
1502         RESERVE_SPACE(4);
1503         WRITE32(OP_WRITE);
1504
1505         encode_stateid(xdr, args->context);
1506
1507         RESERVE_SPACE(16);
1508         WRITE64(args->offset);
1509         WRITE32(args->stable);
1510         WRITE32(args->count);
1511
1512         xdr_write_pages(xdr, args->pages, args->pgbase, args->count);
1513         hdr->nops++;
1514         hdr->replen += decode_write_maxsz;
1515 }
1516
1517 static void encode_delegreturn(struct xdr_stream *xdr, const nfs4_stateid *stateid, struct compound_hdr *hdr)
1518 {
1519         __be32 *p;
1520
1521         RESERVE_SPACE(4+NFS4_STATEID_SIZE);
1522
1523         WRITE32(OP_DELEGRETURN);
1524         WRITEMEM(stateid->data, NFS4_STATEID_SIZE);
1525         hdr->nops++;
1526         hdr->replen += decode_delegreturn_maxsz;
1527 }
1528
1529 #if defined(CONFIG_NFS_V4_1)
1530 /* NFSv4.1 operations */
1531 static void encode_exchange_id(struct xdr_stream *xdr,
1532                                struct nfs41_exchange_id_args *args,
1533                                struct compound_hdr *hdr)
1534 {
1535         __be32 *p;
1536
1537         RESERVE_SPACE(4 + sizeof(args->verifier->data));
1538         WRITE32(OP_EXCHANGE_ID);
1539         WRITEMEM(args->verifier->data, sizeof(args->verifier->data));
1540
1541         encode_string(xdr, args->id_len, args->id);
1542
1543         RESERVE_SPACE(12);
1544         WRITE32(args->flags);
1545         WRITE32(0);     /* zero length state_protect4_a */
1546         WRITE32(0);     /* zero length implementation id array */
1547         hdr->nops++;
1548         hdr->replen += decode_exchange_id_maxsz;
1549 }
1550
1551 static void encode_create_session(struct xdr_stream *xdr,
1552                                   struct nfs41_create_session_args *args,
1553                                   struct compound_hdr *hdr)
1554 {
1555         __be32 *p;
1556         char machine_name[NFS4_MAX_MACHINE_NAME_LEN];
1557         uint32_t len;
1558         struct nfs_client *clp = args->client;
1559
1560         RESERVE_SPACE(4);
1561         WRITE32(OP_CREATE_SESSION);
1562
1563         RESERVE_SPACE(8);
1564         WRITE64(clp->cl_ex_clid);
1565
1566         RESERVE_SPACE(8);
1567         WRITE32(clp->cl_seqid);                 /*Sequence id */
1568         WRITE32(args->flags);                   /*flags */
1569
1570         RESERVE_SPACE(2*28);                    /* 2 channel_attrs */
1571         /* Fore Channel */
1572         WRITE32(args->fc_attrs.headerpadsz);    /* header padding size */
1573         WRITE32(args->fc_attrs.max_rqst_sz);    /* max req size */
1574         WRITE32(args->fc_attrs.max_resp_sz);    /* max resp size */
1575         WRITE32(args->fc_attrs.max_resp_sz_cached);     /* Max resp sz cached */
1576         WRITE32(args->fc_attrs.max_ops);        /* max operations */
1577         WRITE32(args->fc_attrs.max_reqs);       /* max requests */
1578         WRITE32(0);                             /* rdmachannel_attrs */
1579
1580         /* Back Channel */
1581         WRITE32(args->fc_attrs.headerpadsz);    /* header padding size */
1582         WRITE32(args->bc_attrs.max_rqst_sz);    /* max req size */
1583         WRITE32(args->bc_attrs.max_resp_sz);    /* max resp size */
1584         WRITE32(args->bc_attrs.max_resp_sz_cached);     /* Max resp sz cached */
1585         WRITE32(args->bc_attrs.max_ops);        /* max operations */
1586         WRITE32(args->bc_attrs.max_reqs);       /* max requests */
1587         WRITE32(0);                             /* rdmachannel_attrs */
1588
1589         RESERVE_SPACE(4);
1590         WRITE32(args->cb_program);              /* cb_program */
1591
1592         RESERVE_SPACE(4);                       /* # of security flavors */
1593         WRITE32(1);
1594
1595         RESERVE_SPACE(4);
1596         WRITE32(RPC_AUTH_UNIX);                 /* auth_sys */
1597
1598         /* authsys_parms rfc1831 */
1599         RESERVE_SPACE(4);
1600         WRITE32((u32)clp->cl_boot_time.tv_nsec);        /* stamp */
1601         len = scnprintf(machine_name, sizeof(machine_name), "%s",
1602                         clp->cl_ipaddr);
1603         RESERVE_SPACE(16 + len);
1604         WRITE32(len);
1605         WRITEMEM(machine_name, len);
1606         WRITE32(0);                             /* UID */
1607         WRITE32(0);                             /* GID */
1608         WRITE32(0);                             /* No more gids */
1609         hdr->nops++;
1610         hdr->replen += decode_create_session_maxsz;
1611 }
1612 #endif /* CONFIG_NFS_V4_1 */
1613
1614 static void encode_sequence(struct xdr_stream *xdr,
1615                             const struct nfs4_sequence_args *args,
1616                             struct compound_hdr *hdr)
1617 {
1618 #if defined(CONFIG_NFS_V4_1)
1619         struct nfs4_session *session = args->sa_session;
1620
1621         if (!session)
1622                 return;
1623
1624         /* stub */
1625         hdr->nops++;
1626         hdr->replen += decode_sequence_maxsz;
1627 #endif /* CONFIG_NFS_V4_1 */
1628 }
1629
1630 /*
1631  * END OF "GENERIC" ENCODE ROUTINES.
1632  */
1633
1634 static u32 nfs4_xdr_minorversion(const struct nfs4_sequence_args *args)
1635 {
1636 #if defined(CONFIG_NFS_V4_1)
1637         if (args->sa_session)
1638                 return args->sa_session->clp->cl_minorversion;
1639 #endif /* CONFIG_NFS_V4_1 */
1640         return 0;
1641 }
1642
1643 /*
1644  * Encode an ACCESS request
1645  */
1646 static int nfs4_xdr_enc_access(struct rpc_rqst *req, __be32 *p, const struct nfs4_accessargs *args)
1647 {
1648         struct xdr_stream xdr;
1649         struct compound_hdr hdr = {
1650                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
1651         };
1652
1653         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1654         encode_compound_hdr(&xdr, req, &hdr);
1655         encode_sequence(&xdr, &args->seq_args, &hdr);
1656         encode_putfh(&xdr, args->fh, &hdr);
1657         encode_access(&xdr, args->access, &hdr);
1658         encode_getfattr(&xdr, args->bitmask, &hdr);
1659         encode_nops(&hdr);
1660         return 0;
1661 }
1662
1663 /*
1664  * Encode LOOKUP request
1665  */
1666 static int nfs4_xdr_enc_lookup(struct rpc_rqst *req, __be32 *p, const struct nfs4_lookup_arg *args)
1667 {
1668         struct xdr_stream xdr;
1669         struct compound_hdr hdr = {
1670                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
1671         };
1672
1673         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1674         encode_compound_hdr(&xdr, req, &hdr);
1675         encode_sequence(&xdr, &args->seq_args, &hdr);
1676         encode_putfh(&xdr, args->dir_fh, &hdr);
1677         encode_lookup(&xdr, args->name, &hdr);
1678         encode_getfh(&xdr, &hdr);
1679         encode_getfattr(&xdr, args->bitmask, &hdr);
1680         encode_nops(&hdr);
1681         return 0;
1682 }
1683
1684 /*
1685  * Encode LOOKUP_ROOT request
1686  */
1687 static int nfs4_xdr_enc_lookup_root(struct rpc_rqst *req, __be32 *p, const struct nfs4_lookup_root_arg *args)
1688 {
1689         struct xdr_stream xdr;
1690         struct compound_hdr hdr = {
1691                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
1692         };
1693
1694         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1695         encode_compound_hdr(&xdr, req, &hdr);
1696         encode_sequence(&xdr, &args->seq_args, &hdr);
1697         encode_putrootfh(&xdr, &hdr);
1698         encode_getfh(&xdr, &hdr);
1699         encode_getfattr(&xdr, args->bitmask, &hdr);
1700         encode_nops(&hdr);
1701         return 0;
1702 }
1703
1704 /*
1705  * Encode REMOVE request
1706  */
1707 static int nfs4_xdr_enc_remove(struct rpc_rqst *req, __be32 *p, const struct nfs_removeargs *args)
1708 {
1709         struct xdr_stream xdr;
1710         struct compound_hdr hdr = {
1711                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
1712         };
1713
1714         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1715         encode_compound_hdr(&xdr, req, &hdr);
1716         encode_sequence(&xdr, &args->seq_args, &hdr);
1717         encode_putfh(&xdr, args->fh, &hdr);
1718         encode_remove(&xdr, &args->name, &hdr);
1719         encode_getfattr(&xdr, args->bitmask, &hdr);
1720         encode_nops(&hdr);
1721         return 0;
1722 }
1723
1724 /*
1725  * Encode RENAME request
1726  */
1727 static int nfs4_xdr_enc_rename(struct rpc_rqst *req, __be32 *p, const struct nfs4_rename_arg *args)
1728 {
1729         struct xdr_stream xdr;
1730         struct compound_hdr hdr = {
1731                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
1732         };
1733
1734         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1735         encode_compound_hdr(&xdr, req, &hdr);
1736         encode_sequence(&xdr, &args->seq_args, &hdr);
1737         encode_putfh(&xdr, args->old_dir, &hdr);
1738         encode_savefh(&xdr, &hdr);
1739         encode_putfh(&xdr, args->new_dir, &hdr);
1740         encode_rename(&xdr, args->old_name, args->new_name, &hdr);
1741         encode_getfattr(&xdr, args->bitmask, &hdr);
1742         encode_restorefh(&xdr, &hdr);
1743         encode_getfattr(&xdr, args->bitmask, &hdr);
1744         encode_nops(&hdr);
1745         return 0;
1746 }
1747
1748 /*
1749  * Encode LINK request
1750  */
1751 static int nfs4_xdr_enc_link(struct rpc_rqst *req, __be32 *p, const struct nfs4_link_arg *args)
1752 {
1753         struct xdr_stream xdr;
1754         struct compound_hdr hdr = {
1755                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
1756         };
1757
1758         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1759         encode_compound_hdr(&xdr, req, &hdr);
1760         encode_sequence(&xdr, &args->seq_args, &hdr);
1761         encode_putfh(&xdr, args->fh, &hdr);
1762         encode_savefh(&xdr, &hdr);
1763         encode_putfh(&xdr, args->dir_fh, &hdr);
1764         encode_link(&xdr, args->name, &hdr);
1765         encode_getfattr(&xdr, args->bitmask, &hdr);
1766         encode_restorefh(&xdr, &hdr);
1767         encode_getfattr(&xdr, args->bitmask, &hdr);
1768         encode_nops(&hdr);
1769         return 0;
1770 }
1771
1772 /*
1773  * Encode CREATE request
1774  */
1775 static int nfs4_xdr_enc_create(struct rpc_rqst *req, __be32 *p, const struct nfs4_create_arg *args)
1776 {
1777         struct xdr_stream xdr;
1778         struct compound_hdr hdr = {
1779                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
1780         };
1781
1782         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1783         encode_compound_hdr(&xdr, req, &hdr);
1784         encode_sequence(&xdr, &args->seq_args, &hdr);
1785         encode_putfh(&xdr, args->dir_fh, &hdr);
1786         encode_savefh(&xdr, &hdr);
1787         encode_create(&xdr, args, &hdr);
1788         encode_getfh(&xdr, &hdr);
1789         encode_getfattr(&xdr, args->bitmask, &hdr);
1790         encode_restorefh(&xdr, &hdr);
1791         encode_getfattr(&xdr, args->bitmask, &hdr);
1792         encode_nops(&hdr);
1793         return 0;
1794 }
1795
1796 /*
1797  * Encode SYMLINK request
1798  */
1799 static int nfs4_xdr_enc_symlink(struct rpc_rqst *req, __be32 *p, const struct nfs4_create_arg *args)
1800 {
1801         return nfs4_xdr_enc_create(req, p, args);
1802 }
1803
1804 /*
1805  * Encode GETATTR request
1806  */
1807 static int nfs4_xdr_enc_getattr(struct rpc_rqst *req, __be32 *p, const struct nfs4_getattr_arg *args)
1808 {
1809         struct xdr_stream xdr;
1810         struct compound_hdr hdr = {
1811                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
1812         };
1813
1814         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1815         encode_compound_hdr(&xdr, req, &hdr);
1816         encode_sequence(&xdr, &args->seq_args, &hdr);
1817         encode_putfh(&xdr, args->fh, &hdr);
1818         encode_getfattr(&xdr, args->bitmask, &hdr);
1819         encode_nops(&hdr);
1820         return 0;
1821 }
1822
1823 /*
1824  * Encode a CLOSE request
1825  */
1826 static int nfs4_xdr_enc_close(struct rpc_rqst *req, __be32 *p, struct nfs_closeargs *args)
1827 {
1828         struct xdr_stream xdr;
1829         struct compound_hdr hdr = {
1830                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
1831         };
1832
1833         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1834         encode_compound_hdr(&xdr, req, &hdr);
1835         encode_sequence(&xdr, &args->seq_args, &hdr);
1836         encode_putfh(&xdr, args->fh, &hdr);
1837         encode_close(&xdr, args, &hdr);
1838         encode_getfattr(&xdr, args->bitmask, &hdr);
1839         encode_nops(&hdr);
1840         return 0;
1841 }
1842
1843 /*
1844  * Encode an OPEN request
1845  */
1846 static int nfs4_xdr_enc_open(struct rpc_rqst *req, __be32 *p, struct nfs_openargs *args)
1847 {
1848         struct xdr_stream xdr;
1849         struct compound_hdr hdr = {
1850                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
1851         };
1852
1853         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1854         encode_compound_hdr(&xdr, req, &hdr);
1855         encode_sequence(&xdr, &args->seq_args, &hdr);
1856         encode_putfh(&xdr, args->fh, &hdr);
1857         encode_savefh(&xdr, &hdr);
1858         encode_open(&xdr, args, &hdr);
1859         encode_getfh(&xdr, &hdr);
1860         encode_getfattr(&xdr, args->bitmask, &hdr);
1861         encode_restorefh(&xdr, &hdr);
1862         encode_getfattr(&xdr, args->bitmask, &hdr);
1863         encode_nops(&hdr);
1864         return 0;
1865 }
1866
1867 /*
1868  * Encode an OPEN_CONFIRM request
1869  */
1870 static int nfs4_xdr_enc_open_confirm(struct rpc_rqst *req, __be32 *p, struct nfs_open_confirmargs *args)
1871 {
1872         struct xdr_stream xdr;
1873         struct compound_hdr hdr = {
1874                 .nops   = 0,
1875         };
1876
1877         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1878         encode_compound_hdr(&xdr, req, &hdr);
1879         encode_putfh(&xdr, args->fh, &hdr);
1880         encode_open_confirm(&xdr, args, &hdr);
1881         encode_nops(&hdr);
1882         return 0;
1883 }
1884
1885 /*
1886  * Encode an OPEN request with no attributes.
1887  */
1888 static int nfs4_xdr_enc_open_noattr(struct rpc_rqst *req, __be32 *p, struct nfs_openargs *args)
1889 {
1890         struct xdr_stream xdr;
1891         struct compound_hdr hdr = {
1892                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
1893         };
1894
1895         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1896         encode_compound_hdr(&xdr, req, &hdr);
1897         encode_sequence(&xdr, &args->seq_args, &hdr);
1898         encode_putfh(&xdr, args->fh, &hdr);
1899         encode_open(&xdr, args, &hdr);
1900         encode_getfattr(&xdr, args->bitmask, &hdr);
1901         encode_nops(&hdr);
1902         return 0;
1903 }
1904
1905 /*
1906  * Encode an OPEN_DOWNGRADE request
1907  */
1908 static int nfs4_xdr_enc_open_downgrade(struct rpc_rqst *req, __be32 *p, struct nfs_closeargs *args)
1909 {
1910         struct xdr_stream xdr;
1911         struct compound_hdr hdr = {
1912                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
1913         };
1914
1915         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1916         encode_compound_hdr(&xdr, req, &hdr);
1917         encode_sequence(&xdr, &args->seq_args, &hdr);
1918         encode_putfh(&xdr, args->fh, &hdr);
1919         encode_open_downgrade(&xdr, args, &hdr);
1920         encode_getfattr(&xdr, args->bitmask, &hdr);
1921         encode_nops(&hdr);
1922         return 0;
1923 }
1924
1925 /*
1926  * Encode a LOCK request
1927  */
1928 static int nfs4_xdr_enc_lock(struct rpc_rqst *req, __be32 *p, struct nfs_lock_args *args)
1929 {
1930         struct xdr_stream xdr;
1931         struct compound_hdr hdr = {
1932                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
1933         };
1934
1935         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1936         encode_compound_hdr(&xdr, req, &hdr);
1937         encode_sequence(&xdr, &args->seq_args, &hdr);
1938         encode_putfh(&xdr, args->fh, &hdr);
1939         encode_lock(&xdr, args, &hdr);
1940         encode_nops(&hdr);
1941         return 0;
1942 }
1943
1944 /*
1945  * Encode a LOCKT request
1946  */
1947 static int nfs4_xdr_enc_lockt(struct rpc_rqst *req, __be32 *p, struct nfs_lockt_args *args)
1948 {
1949         struct xdr_stream xdr;
1950         struct compound_hdr hdr = {
1951                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
1952         };
1953
1954         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1955         encode_compound_hdr(&xdr, req, &hdr);
1956         encode_sequence(&xdr, &args->seq_args, &hdr);
1957         encode_putfh(&xdr, args->fh, &hdr);
1958         encode_lockt(&xdr, args, &hdr);
1959         encode_nops(&hdr);
1960         return 0;
1961 }
1962
1963 /*
1964  * Encode a LOCKU request
1965  */
1966 static int nfs4_xdr_enc_locku(struct rpc_rqst *req, __be32 *p, struct nfs_locku_args *args)
1967 {
1968         struct xdr_stream xdr;
1969         struct compound_hdr hdr = {
1970                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
1971         };
1972
1973         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1974         encode_compound_hdr(&xdr, req, &hdr);
1975         encode_sequence(&xdr, &args->seq_args, &hdr);
1976         encode_putfh(&xdr, args->fh, &hdr);
1977         encode_locku(&xdr, args, &hdr);
1978         encode_nops(&hdr);
1979         return 0;
1980 }
1981
1982 /*
1983  * Encode a READLINK request
1984  */
1985 static int nfs4_xdr_enc_readlink(struct rpc_rqst *req, __be32 *p, const struct nfs4_readlink *args)
1986 {
1987         struct xdr_stream xdr;
1988         struct compound_hdr hdr = {
1989                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
1990         };
1991
1992         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1993         encode_compound_hdr(&xdr, req, &hdr);
1994         encode_sequence(&xdr, &args->seq_args, &hdr);
1995         encode_putfh(&xdr, args->fh, &hdr);
1996         encode_readlink(&xdr, args, req, &hdr);
1997
1998         xdr_inline_pages(&req->rq_rcv_buf, hdr.replen << 2, args->pages,
1999                         args->pgbase, args->pglen);
2000         encode_nops(&hdr);
2001         return 0;
2002 }
2003
2004 /*
2005  * Encode a READDIR request
2006  */
2007 static int nfs4_xdr_enc_readdir(struct rpc_rqst *req, __be32 *p, const struct nfs4_readdir_arg *args)
2008 {
2009         struct xdr_stream xdr;
2010         struct compound_hdr hdr = {
2011                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2012         };
2013
2014         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2015         encode_compound_hdr(&xdr, req, &hdr);
2016         encode_sequence(&xdr, &args->seq_args, &hdr);
2017         encode_putfh(&xdr, args->fh, &hdr);
2018         encode_readdir(&xdr, args, req, &hdr);
2019
2020         xdr_inline_pages(&req->rq_rcv_buf, hdr.replen << 2, args->pages,
2021                          args->pgbase, args->count);
2022         dprintk("%s: inlined page args = (%u, %p, %u, %u)\n",
2023                         __func__, hdr.replen << 2, args->pages,
2024                         args->pgbase, args->count);
2025         encode_nops(&hdr);
2026         return 0;
2027 }
2028
2029 /*
2030  * Encode a READ request
2031  */
2032 static int nfs4_xdr_enc_read(struct rpc_rqst *req, __be32 *p, struct nfs_readargs *args)
2033 {
2034         struct xdr_stream xdr;
2035         struct compound_hdr hdr = {
2036                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2037         };
2038
2039         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2040         encode_compound_hdr(&xdr, req, &hdr);
2041         encode_sequence(&xdr, &args->seq_args, &hdr);
2042         encode_putfh(&xdr, args->fh, &hdr);
2043         encode_read(&xdr, args, &hdr);
2044
2045         xdr_inline_pages(&req->rq_rcv_buf, hdr.replen << 2,
2046                          args->pages, args->pgbase, args->count);
2047         req->rq_rcv_buf.flags |= XDRBUF_READ;
2048         encode_nops(&hdr);
2049         return 0;
2050 }
2051
2052 /*
2053  * Encode an SETATTR request
2054  */
2055 static int nfs4_xdr_enc_setattr(struct rpc_rqst *req, __be32 *p, struct nfs_setattrargs *args)
2056 {
2057         struct xdr_stream xdr;
2058         struct compound_hdr hdr = {
2059                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2060         };
2061
2062         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2063         encode_compound_hdr(&xdr, req, &hdr);
2064         encode_sequence(&xdr, &args->seq_args, &hdr);
2065         encode_putfh(&xdr, args->fh, &hdr);
2066         encode_setattr(&xdr, args, args->server, &hdr);
2067         encode_getfattr(&xdr, args->bitmask, &hdr);
2068         encode_nops(&hdr);
2069         return 0;
2070 }
2071
2072 /*
2073  * Encode a GETACL request
2074  */
2075 static int
2076 nfs4_xdr_enc_getacl(struct rpc_rqst *req, __be32 *p,
2077                 struct nfs_getaclargs *args)
2078 {
2079         struct xdr_stream xdr;
2080         struct compound_hdr hdr = {
2081                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2082         };
2083         uint32_t replen;
2084
2085         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2086         encode_compound_hdr(&xdr, req, &hdr);
2087         encode_sequence(&xdr, &args->seq_args, &hdr);
2088         encode_putfh(&xdr, args->fh, &hdr);
2089         replen = hdr.replen + nfs4_fattr_bitmap_maxsz + 1;
2090         encode_getattr_two(&xdr, FATTR4_WORD0_ACL, 0, &hdr);
2091
2092         xdr_inline_pages(&req->rq_rcv_buf, replen << 2,
2093                 args->acl_pages, args->acl_pgbase, args->acl_len);
2094         encode_nops(&hdr);
2095         return 0;
2096 }
2097
2098 /*
2099  * Encode a WRITE request
2100  */
2101 static int nfs4_xdr_enc_write(struct rpc_rqst *req, __be32 *p, struct nfs_writeargs *args)
2102 {
2103         struct xdr_stream xdr;
2104         struct compound_hdr hdr = {
2105                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2106         };
2107
2108         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2109         encode_compound_hdr(&xdr, req, &hdr);
2110         encode_sequence(&xdr, &args->seq_args, &hdr);
2111         encode_putfh(&xdr, args->fh, &hdr);
2112         encode_write(&xdr, args, &hdr);
2113         req->rq_snd_buf.flags |= XDRBUF_WRITE;
2114         encode_getfattr(&xdr, args->bitmask, &hdr);
2115         encode_nops(&hdr);
2116         return 0;
2117 }
2118
2119 /*
2120  *  a COMMIT request
2121  */
2122 static int nfs4_xdr_enc_commit(struct rpc_rqst *req, __be32 *p, struct nfs_writeargs *args)
2123 {
2124         struct xdr_stream xdr;
2125         struct compound_hdr hdr = {
2126                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2127         };
2128
2129         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2130         encode_compound_hdr(&xdr, req, &hdr);
2131         encode_sequence(&xdr, &args->seq_args, &hdr);
2132         encode_putfh(&xdr, args->fh, &hdr);
2133         encode_commit(&xdr, args, &hdr);
2134         encode_getfattr(&xdr, args->bitmask, &hdr);
2135         encode_nops(&hdr);
2136         return 0;
2137 }
2138
2139 /*
2140  * FSINFO request
2141  */
2142 static int nfs4_xdr_enc_fsinfo(struct rpc_rqst *req, __be32 *p, struct nfs4_fsinfo_arg *args)
2143 {
2144         struct xdr_stream xdr;
2145         struct compound_hdr hdr = {
2146                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2147         };
2148
2149         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2150         encode_compound_hdr(&xdr, req, &hdr);
2151         encode_sequence(&xdr, &args->seq_args, &hdr);
2152         encode_putfh(&xdr, args->fh, &hdr);
2153         encode_fsinfo(&xdr, args->bitmask, &hdr);
2154         encode_nops(&hdr);
2155         return 0;
2156 }
2157
2158 /*
2159  * a PATHCONF request
2160  */
2161 static int nfs4_xdr_enc_pathconf(struct rpc_rqst *req, __be32 *p, const struct nfs4_pathconf_arg *args)
2162 {
2163         struct xdr_stream xdr;
2164         struct compound_hdr hdr = {
2165                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2166         };
2167
2168         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2169         encode_compound_hdr(&xdr, req, &hdr);
2170         encode_sequence(&xdr, &args->seq_args, &hdr);
2171         encode_putfh(&xdr, args->fh, &hdr);
2172         encode_getattr_one(&xdr, args->bitmask[0] & nfs4_pathconf_bitmap[0],
2173                            &hdr);
2174         encode_nops(&hdr);
2175         return 0;
2176 }
2177
2178 /*
2179  * a STATFS request
2180  */
2181 static int nfs4_xdr_enc_statfs(struct rpc_rqst *req, __be32 *p, const struct nfs4_statfs_arg *args)
2182 {
2183         struct xdr_stream xdr;
2184         struct compound_hdr hdr = {
2185                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2186         };
2187
2188         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2189         encode_compound_hdr(&xdr, req, &hdr);
2190         encode_sequence(&xdr, &args->seq_args, &hdr);
2191         encode_putfh(&xdr, args->fh, &hdr);
2192         encode_getattr_two(&xdr, args->bitmask[0] & nfs4_statfs_bitmap[0],
2193                            args->bitmask[1] & nfs4_statfs_bitmap[1], &hdr);
2194         encode_nops(&hdr);
2195         return 0;
2196 }
2197
2198 /*
2199  * GETATTR_BITMAP request
2200  */
2201 static int nfs4_xdr_enc_server_caps(struct rpc_rqst *req, __be32 *p,
2202                                     struct nfs4_server_caps_arg *args)
2203 {
2204         struct xdr_stream xdr;
2205         struct compound_hdr hdr = {
2206                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2207         };
2208
2209         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2210         encode_compound_hdr(&xdr, req, &hdr);
2211         encode_sequence(&xdr, &args->seq_args, &hdr);
2212         encode_putfh(&xdr, args->fhandle, &hdr);
2213         encode_getattr_one(&xdr, FATTR4_WORD0_SUPPORTED_ATTRS|
2214                            FATTR4_WORD0_LINK_SUPPORT|
2215                            FATTR4_WORD0_SYMLINK_SUPPORT|
2216                            FATTR4_WORD0_ACLSUPPORT, &hdr);
2217         encode_nops(&hdr);
2218         return 0;
2219 }
2220
2221 /*
2222  * a RENEW request
2223  */
2224 static int nfs4_xdr_enc_renew(struct rpc_rqst *req, __be32 *p, struct nfs_client *clp)
2225 {
2226         struct xdr_stream xdr;
2227         struct compound_hdr hdr = {
2228                 .nops   = 0,
2229         };
2230
2231         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2232         encode_compound_hdr(&xdr, req, &hdr);
2233         encode_renew(&xdr, clp, &hdr);
2234         encode_nops(&hdr);
2235         return 0;
2236 }
2237
2238 /*
2239  * a SETCLIENTID request
2240  */
2241 static int nfs4_xdr_enc_setclientid(struct rpc_rqst *req, __be32 *p, struct nfs4_setclientid *sc)
2242 {
2243         struct xdr_stream xdr;
2244         struct compound_hdr hdr = {
2245                 .nops   = 0,
2246         };
2247
2248         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2249         encode_compound_hdr(&xdr, req, &hdr);
2250         encode_setclientid(&xdr, sc, &hdr);
2251         encode_nops(&hdr);
2252         return 0;
2253 }
2254
2255 /*
2256  * a SETCLIENTID_CONFIRM request
2257  */
2258 static int nfs4_xdr_enc_setclientid_confirm(struct rpc_rqst *req, __be32 *p, struct nfs_client *clp)
2259 {
2260         struct xdr_stream xdr;
2261         struct compound_hdr hdr = {
2262                 .nops   = 0,
2263         };
2264         const u32 lease_bitmap[2] = { FATTR4_WORD0_LEASE_TIME, 0 };
2265
2266         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2267         encode_compound_hdr(&xdr, req, &hdr);
2268         encode_setclientid_confirm(&xdr, clp, &hdr);
2269         encode_putrootfh(&xdr, &hdr);
2270         encode_fsinfo(&xdr, lease_bitmap, &hdr);
2271         encode_nops(&hdr);
2272         return 0;
2273 }
2274
2275 /*
2276  * DELEGRETURN request
2277  */
2278 static int nfs4_xdr_enc_delegreturn(struct rpc_rqst *req, __be32 *p, const struct nfs4_delegreturnargs *args)
2279 {
2280         struct xdr_stream xdr;
2281         struct compound_hdr hdr = {
2282                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2283         };
2284
2285         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2286         encode_compound_hdr(&xdr, req, &hdr);
2287         encode_sequence(&xdr, &args->seq_args, &hdr);
2288         encode_putfh(&xdr, args->fhandle, &hdr);
2289         encode_delegreturn(&xdr, args->stateid, &hdr);
2290         encode_getfattr(&xdr, args->bitmask, &hdr);
2291         encode_nops(&hdr);
2292         return 0;
2293 }
2294
2295 /*
2296  * Encode FS_LOCATIONS request
2297  */
2298 static int nfs4_xdr_enc_fs_locations(struct rpc_rqst *req, __be32 *p, struct nfs4_fs_locations_arg *args)
2299 {
2300         struct xdr_stream xdr;
2301         struct compound_hdr hdr = {
2302                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
2303         };
2304         uint32_t replen;
2305
2306         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2307         encode_compound_hdr(&xdr, req, &hdr);
2308         encode_sequence(&xdr, &args->seq_args, &hdr);
2309         encode_putfh(&xdr, args->dir_fh, &hdr);
2310         encode_lookup(&xdr, args->name, &hdr);
2311         replen = hdr.replen;    /* get the attribute into args->page */
2312         encode_fs_locations(&xdr, args->bitmask, &hdr);
2313
2314         xdr_inline_pages(&req->rq_rcv_buf, replen << 2, &args->page,
2315                         0, PAGE_SIZE);
2316         encode_nops(&hdr);
2317         return 0;
2318 }
2319
2320 #if defined(CONFIG_NFS_V4_1)
2321 /*
2322  * EXCHANGE_ID request
2323  */
2324 static int nfs4_xdr_enc_exchange_id(struct rpc_rqst *req, uint32_t *p,
2325                                     struct nfs41_exchange_id_args *args)
2326 {
2327         struct xdr_stream xdr;
2328         struct compound_hdr hdr = {
2329                 .minorversion = args->client->cl_minorversion,
2330         };
2331
2332         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2333         encode_compound_hdr(&xdr, req, &hdr);
2334         encode_exchange_id(&xdr, args, &hdr);
2335         encode_nops(&hdr);
2336         return 0;
2337 }
2338
2339 /*
2340  * a CREATE_SESSION request
2341  */
2342 static int nfs4_xdr_enc_create_session(struct rpc_rqst *req, uint32_t *p,
2343                                        struct nfs41_create_session_args *args)
2344 {
2345         struct xdr_stream xdr;
2346         struct compound_hdr hdr = {
2347                 .minorversion = args->client->cl_minorversion,
2348         };
2349
2350         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2351         encode_compound_hdr(&xdr, req, &hdr);
2352         encode_create_session(&xdr, args, &hdr);
2353         encode_nops(&hdr);
2354         return 0;
2355 }
2356
2357 /*
2358  * a GET_LEASE_TIME request
2359  */
2360 static int nfs4_xdr_enc_get_lease_time(struct rpc_rqst *req, uint32_t *p,
2361                                        struct nfs4_get_lease_time_args *args)
2362 {
2363         struct xdr_stream xdr;
2364         struct compound_hdr hdr = {
2365                 .minorversion = nfs4_xdr_minorversion(&args->la_seq_args),
2366         };
2367         const u32 lease_bitmap[2] = { FATTR4_WORD0_LEASE_TIME, 0 };
2368
2369         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2370         encode_compound_hdr(&xdr, req, &hdr);
2371         encode_sequence(&xdr, &args->la_seq_args, &hdr);
2372         encode_putrootfh(&xdr, &hdr);
2373         encode_fsinfo(&xdr, lease_bitmap, &hdr);
2374         encode_nops(&hdr);
2375         return 0;
2376 }
2377 #endif /* CONFIG_NFS_V4_1 */
2378
2379 /*
2380  * START OF "GENERIC" DECODE ROUTINES.
2381  *   These may look a little ugly since they are imported from a "generic"
2382  * set of XDR encode/decode routines which are intended to be shared by
2383  * all of our NFSv4 implementations (OpenBSD, MacOS X...).
2384  *
2385  * If the pain of reading these is too great, it should be a straightforward
2386  * task to translate them into Linux-specific versions which are more
2387  * consistent with the style used in NFSv2/v3...
2388  */
2389 #define READ32(x)         (x) = ntohl(*p++)
2390 #define READ64(x)         do {                  \
2391         (x) = (u64)ntohl(*p++) << 32;           \
2392         (x) |= ntohl(*p++);                     \
2393 } while (0)
2394 #define READTIME(x)       do {                  \
2395         p++;                                    \
2396         (x.tv_sec) = ntohl(*p++);               \
2397         (x.tv_nsec) = ntohl(*p++);              \
2398 } while (0)
2399 #define COPYMEM(x,nbytes) do {                  \
2400         memcpy((x), p, nbytes);                 \
2401         p += XDR_QUADLEN(nbytes);               \
2402 } while (0)
2403
2404 #define READ_BUF(nbytes)  do { \
2405         p = xdr_inline_decode(xdr, nbytes); \
2406         if (unlikely(!p)) { \
2407                 dprintk("nfs: %s: prematurely hit end of receive" \
2408                                 " buffer\n", __func__); \
2409                 dprintk("nfs: %s: xdr->p=%p, bytes=%u, xdr->end=%p\n", \
2410                                 __func__, xdr->p, nbytes, xdr->end); \
2411                 return -EIO; \
2412         } \
2413 } while (0)
2414
2415 static int decode_opaque_inline(struct xdr_stream *xdr, unsigned int *len, char **string)
2416 {
2417         __be32 *p;
2418
2419         READ_BUF(4);
2420         READ32(*len);
2421         READ_BUF(*len);
2422         *string = (char *)p;
2423         return 0;
2424 }
2425
2426 static int decode_compound_hdr(struct xdr_stream *xdr, struct compound_hdr *hdr)
2427 {
2428         __be32 *p;
2429
2430         READ_BUF(8);
2431         READ32(hdr->status);
2432         READ32(hdr->taglen);
2433
2434         READ_BUF(hdr->taglen + 4);
2435         hdr->tag = (char *)p;
2436         p += XDR_QUADLEN(hdr->taglen);
2437         READ32(hdr->nops);
2438         if (unlikely(hdr->nops < 1))
2439                 return nfs4_stat_to_errno(hdr->status);
2440         return 0;
2441 }
2442
2443 static int decode_op_hdr(struct xdr_stream *xdr, enum nfs_opnum4 expected)
2444 {
2445         __be32 *p;
2446         uint32_t opnum;
2447         int32_t nfserr;
2448
2449         READ_BUF(8);
2450         READ32(opnum);
2451         if (opnum != expected) {
2452                 dprintk("nfs: Server returned operation"
2453                         " %d but we issued a request for %d\n",
2454                                 opnum, expected);
2455                 return -EIO;
2456         }
2457         READ32(nfserr);
2458         if (nfserr != NFS_OK)
2459                 return nfs4_stat_to_errno(nfserr);
2460         return 0;
2461 }
2462
2463 /* Dummy routine */
2464 static int decode_ace(struct xdr_stream *xdr, void *ace, struct nfs_client *clp)
2465 {
2466         __be32 *p;
2467         unsigned int strlen;
2468         char *str;
2469
2470         READ_BUF(12);
2471         return decode_opaque_inline(xdr, &strlen, &str);
2472 }
2473
2474 static int decode_attr_bitmap(struct xdr_stream *xdr, uint32_t *bitmap)
2475 {
2476         uint32_t bmlen;
2477         __be32 *p;
2478
2479         READ_BUF(4);
2480         READ32(bmlen);
2481
2482         bitmap[0] = bitmap[1] = 0;
2483         READ_BUF((bmlen << 2));
2484         if (bmlen > 0) {
2485                 READ32(bitmap[0]);
2486                 if (bmlen > 1)
2487                         READ32(bitmap[1]);
2488         }
2489         return 0;
2490 }
2491
2492 static inline int decode_attr_length(struct xdr_stream *xdr, uint32_t *attrlen, __be32 **savep)
2493 {
2494         __be32 *p;
2495
2496         READ_BUF(4);
2497         READ32(*attrlen);
2498         *savep = xdr->p;
2499         return 0;
2500 }
2501
2502 static int decode_attr_supported(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *bitmask)
2503 {
2504         if (likely(bitmap[0] & FATTR4_WORD0_SUPPORTED_ATTRS)) {
2505                 decode_attr_bitmap(xdr, bitmask);
2506                 bitmap[0] &= ~FATTR4_WORD0_SUPPORTED_ATTRS;
2507         } else
2508                 bitmask[0] = bitmask[1] = 0;
2509         dprintk("%s: bitmask=%08x:%08x\n", __func__, bitmask[0], bitmask[1]);
2510         return 0;
2511 }
2512
2513 static int decode_attr_type(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *type)
2514 {
2515         __be32 *p;
2516         int ret = 0;
2517
2518         *type = 0;
2519         if (unlikely(bitmap[0] & (FATTR4_WORD0_TYPE - 1U)))
2520                 return -EIO;
2521         if (likely(bitmap[0] & FATTR4_WORD0_TYPE)) {
2522                 READ_BUF(4);
2523                 READ32(*type);
2524                 if (*type < NF4REG || *type > NF4NAMEDATTR) {
2525                         dprintk("%s: bad type %d\n", __func__, *type);
2526                         return -EIO;
2527                 }
2528                 bitmap[0] &= ~FATTR4_WORD0_TYPE;
2529                 ret = NFS_ATTR_FATTR_TYPE;
2530         }
2531         dprintk("%s: type=0%o\n", __func__, nfs_type2fmt[*type]);
2532         return ret;
2533 }
2534
2535 static int decode_attr_change(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *change)
2536 {
2537         __be32 *p;
2538         int ret = 0;
2539
2540         *change = 0;
2541         if (unlikely(bitmap[0] & (FATTR4_WORD0_CHANGE - 1U)))
2542                 return -EIO;
2543         if (likely(bitmap[0] & FATTR4_WORD0_CHANGE)) {
2544                 READ_BUF(8);
2545                 READ64(*change);
2546                 bitmap[0] &= ~FATTR4_WORD0_CHANGE;
2547                 ret = NFS_ATTR_FATTR_CHANGE;
2548         }
2549         dprintk("%s: change attribute=%Lu\n", __func__,
2550                         (unsigned long long)*change);
2551         return ret;
2552 }
2553
2554 static int decode_attr_size(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *size)
2555 {
2556         __be32 *p;
2557         int ret = 0;
2558
2559         *size = 0;
2560         if (unlikely(bitmap[0] & (FATTR4_WORD0_SIZE - 1U)))
2561                 return -EIO;
2562         if (likely(bitmap[0] & FATTR4_WORD0_SIZE)) {
2563                 READ_BUF(8);
2564                 READ64(*size);
2565                 bitmap[0] &= ~FATTR4_WORD0_SIZE;
2566                 ret = NFS_ATTR_FATTR_SIZE;
2567         }
2568         dprintk("%s: file size=%Lu\n", __func__, (unsigned long long)*size);
2569         return ret;
2570 }
2571
2572 static int decode_attr_link_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
2573 {
2574         __be32 *p;
2575
2576         *res = 0;
2577         if (unlikely(bitmap[0] & (FATTR4_WORD0_LINK_SUPPORT - 1U)))
2578                 return -EIO;
2579         if (likely(bitmap[0] & FATTR4_WORD0_LINK_SUPPORT)) {
2580                 READ_BUF(4);
2581                 READ32(*res);
2582                 bitmap[0] &= ~FATTR4_WORD0_LINK_SUPPORT;
2583         }
2584         dprintk("%s: link support=%s\n", __func__, *res == 0 ? "false" : "true");
2585         return 0;
2586 }
2587
2588 static int decode_attr_symlink_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
2589 {
2590         __be32 *p;
2591
2592         *res = 0;
2593         if (unlikely(bitmap[0] & (FATTR4_WORD0_SYMLINK_SUPPORT - 1U)))
2594                 return -EIO;
2595         if (likely(bitmap[0] & FATTR4_WORD0_SYMLINK_SUPPORT)) {
2596                 READ_BUF(4);
2597                 READ32(*res);
2598                 bitmap[0] &= ~FATTR4_WORD0_SYMLINK_SUPPORT;
2599         }
2600         dprintk("%s: symlink support=%s\n", __func__, *res == 0 ? "false" : "true");
2601         return 0;
2602 }
2603
2604 static int decode_attr_fsid(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_fsid *fsid)
2605 {
2606         __be32 *p;
2607         int ret = 0;
2608
2609         fsid->major = 0;
2610         fsid->minor = 0;
2611         if (unlikely(bitmap[0] & (FATTR4_WORD0_FSID - 1U)))
2612                 return -EIO;
2613         if (likely(bitmap[0] & FATTR4_WORD0_FSID)) {
2614                 READ_BUF(16);
2615                 READ64(fsid->major);
2616                 READ64(fsid->minor);
2617                 bitmap[0] &= ~FATTR4_WORD0_FSID;
2618                 ret = NFS_ATTR_FATTR_FSID;
2619         }
2620         dprintk("%s: fsid=(0x%Lx/0x%Lx)\n", __func__,
2621                         (unsigned long long)fsid->major,
2622                         (unsigned long long)fsid->minor);
2623         return ret;
2624 }
2625
2626 static int decode_attr_lease_time(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
2627 {
2628         __be32 *p;
2629
2630         *res = 60;
2631         if (unlikely(bitmap[0] & (FATTR4_WORD0_LEASE_TIME - 1U)))
2632                 return -EIO;
2633         if (likely(bitmap[0] & FATTR4_WORD0_LEASE_TIME)) {
2634                 READ_BUF(4);
2635                 READ32(*res);
2636                 bitmap[0] &= ~FATTR4_WORD0_LEASE_TIME;
2637         }
2638         dprintk("%s: file size=%u\n", __func__, (unsigned int)*res);
2639         return 0;
2640 }
2641
2642 static int decode_attr_aclsupport(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
2643 {
2644         __be32 *p;
2645
2646         *res = ACL4_SUPPORT_ALLOW_ACL|ACL4_SUPPORT_DENY_ACL;
2647         if (unlikely(bitmap[0] & (FATTR4_WORD0_ACLSUPPORT - 1U)))
2648                 return -EIO;
2649         if (likely(bitmap[0] & FATTR4_WORD0_ACLSUPPORT)) {
2650                 READ_BUF(4);
2651                 READ32(*res);
2652                 bitmap[0] &= ~FATTR4_WORD0_ACLSUPPORT;
2653         }
2654         dprintk("%s: ACLs supported=%u\n", __func__, (unsigned int)*res);
2655         return 0;
2656 }
2657
2658 static int decode_attr_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *fileid)
2659 {
2660         __be32 *p;
2661         int ret = 0;
2662
2663         *fileid = 0;
2664         if (unlikely(bitmap[0] & (FATTR4_WORD0_FILEID - 1U)))
2665                 return -EIO;
2666         if (likely(bitmap[0] & FATTR4_WORD0_FILEID)) {
2667                 READ_BUF(8);
2668                 READ64(*fileid);
2669                 bitmap[0] &= ~FATTR4_WORD0_FILEID;
2670                 ret = NFS_ATTR_FATTR_FILEID;
2671         }
2672         dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid);
2673         return ret;
2674 }
2675
2676 static int decode_attr_mounted_on_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *fileid)
2677 {
2678         __be32 *p;
2679         int ret = 0;
2680
2681         *fileid = 0;
2682         if (unlikely(bitmap[1] & (FATTR4_WORD1_MOUNTED_ON_FILEID - 1U)))
2683                 return -EIO;
2684         if (likely(bitmap[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)) {
2685                 READ_BUF(8);
2686                 READ64(*fileid);
2687                 bitmap[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID;
2688                 ret = NFS_ATTR_FATTR_FILEID;
2689         }
2690         dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid);
2691         return ret;
2692 }
2693
2694 static int decode_attr_files_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
2695 {
2696         __be32 *p;
2697         int status = 0;
2698
2699         *res = 0;
2700         if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_AVAIL - 1U)))
2701                 return -EIO;
2702         if (likely(bitmap[0] & FATTR4_WORD0_FILES_AVAIL)) {
2703                 READ_BUF(8);
2704                 READ64(*res);
2705                 bitmap[0] &= ~FATTR4_WORD0_FILES_AVAIL;
2706         }
2707         dprintk("%s: files avail=%Lu\n", __func__, (unsigned long long)*res);
2708         return status;
2709 }
2710
2711 static int decode_attr_files_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
2712 {
2713         __be32 *p;
2714         int status = 0;
2715
2716         *res = 0;
2717         if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_FREE - 1U)))
2718                 return -EIO;
2719         if (likely(bitmap[0] & FATTR4_WORD0_FILES_FREE)) {
2720                 READ_BUF(8);
2721                 READ64(*res);
2722                 bitmap[0] &= ~FATTR4_WORD0_FILES_FREE;
2723         }
2724         dprintk("%s: files free=%Lu\n", __func__, (unsigned long long)*res);
2725         return status;
2726 }
2727
2728 static int decode_attr_files_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
2729 {
2730         __be32 *p;
2731         int status = 0;
2732
2733         *res = 0;
2734         if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_TOTAL - 1U)))
2735                 return -EIO;
2736         if (likely(bitmap[0] & FATTR4_WORD0_FILES_TOTAL)) {
2737                 READ_BUF(8);
2738                 READ64(*res);
2739                 bitmap[0] &= ~FATTR4_WORD0_FILES_TOTAL;
2740         }
2741         dprintk("%s: files total=%Lu\n", __func__, (unsigned long long)*res);
2742         return status;
2743 }
2744
2745 static int decode_pathname(struct xdr_stream *xdr, struct nfs4_pathname *path)
2746 {
2747         u32 n;
2748         __be32 *p;
2749         int status = 0;
2750
2751         READ_BUF(4);
2752         READ32(n);
2753         if (n == 0)
2754                 goto root_path;
2755         dprintk("path ");
2756         path->ncomponents = 0;
2757         while (path->ncomponents < n) {
2758                 struct nfs4_string *component = &path->components[path->ncomponents];
2759                 status = decode_opaque_inline(xdr, &component->len, &component->data);
2760                 if (unlikely(status != 0))
2761                         goto out_eio;
2762                 if (path->ncomponents != n)
2763                         dprintk("/");
2764                 dprintk("%s", component->data);
2765                 if (path->ncomponents < NFS4_PATHNAME_MAXCOMPONENTS)
2766                         path->ncomponents++;
2767                 else {
2768                         dprintk("cannot parse %d components in path\n", n);
2769                         goto out_eio;
2770                 }
2771         }
2772 out:
2773         dprintk("\n");
2774         return status;
2775 root_path:
2776 /* a root pathname is sent as a zero component4 */
2777         path->ncomponents = 1;
2778         path->components[0].len=0;
2779         path->components[0].data=NULL;
2780         dprintk("path /\n");
2781         goto out;
2782 out_eio:
2783         dprintk(" status %d", status);
2784         status = -EIO;
2785         goto out;
2786 }
2787
2788 static int decode_attr_fs_locations(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs4_fs_locations *res)
2789 {
2790         int n;
2791         __be32 *p;
2792         int status = -EIO;
2793
2794         if (unlikely(bitmap[0] & (FATTR4_WORD0_FS_LOCATIONS -1U)))
2795                 goto out;
2796         status = 0;
2797         if (unlikely(!(bitmap[0] & FATTR4_WORD0_FS_LOCATIONS)))
2798                 goto out;
2799         dprintk("%s: fsroot ", __func__);
2800         status = decode_pathname(xdr, &res->fs_path);
2801         if (unlikely(status != 0))
2802                 goto out;
2803         READ_BUF(4);
2804         READ32(n);
2805         if (n <= 0)
2806                 goto out_eio;
2807         res->nlocations = 0;
2808         while (res->nlocations < n) {
2809                 u32 m;
2810                 struct nfs4_fs_location *loc = &res->locations[res->nlocations];
2811
2812                 READ_BUF(4);
2813                 READ32(m);
2814
2815                 loc->nservers = 0;
2816                 dprintk("%s: servers ", __func__);
2817                 while (loc->nservers < m) {
2818                         struct nfs4_string *server = &loc->servers[loc->nservers];
2819                         status = decode_opaque_inline(xdr, &server->len, &server->data);
2820                         if (unlikely(status != 0))
2821                                 goto out_eio;
2822                         dprintk("%s ", server->data);
2823                         if (loc->nservers < NFS4_FS_LOCATION_MAXSERVERS)
2824                                 loc->nservers++;
2825                         else {
2826                                 unsigned int i;
2827                                 dprintk("%s: using first %u of %u servers "
2828                                         "returned for location %u\n",
2829                                                 __func__,
2830                                                 NFS4_FS_LOCATION_MAXSERVERS,
2831                                                 m, res->nlocations);
2832                                 for (i = loc->nservers; i < m; i++) {
2833                                         unsigned int len;
2834                                         char *data;
2835                                         status = decode_opaque_inline(xdr, &len, &data);
2836                                         if (unlikely(status != 0))
2837                                                 goto out_eio;
2838                                 }
2839                         }
2840                 }
2841                 status = decode_pathname(xdr, &loc->rootpath);
2842                 if (unlikely(status != 0))
2843                         goto out_eio;
2844                 if (res->nlocations < NFS4_FS_LOCATIONS_MAXENTRIES)
2845                         res->nlocations++;
2846         }
2847         if (res->nlocations != 0)
2848                 status = NFS_ATTR_FATTR_V4_REFERRAL;
2849 out:
2850         dprintk("%s: fs_locations done, error = %d\n", __func__, status);
2851         return status;
2852 out_eio:
2853         status = -EIO;
2854         goto out;
2855 }
2856
2857 static int decode_attr_maxfilesize(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
2858 {
2859         __be32 *p;
2860         int status = 0;
2861
2862         *res = 0;
2863         if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXFILESIZE - 1U)))
2864                 return -EIO;
2865         if (likely(bitmap[0] & FATTR4_WORD0_MAXFILESIZE)) {
2866                 READ_BUF(8);
2867                 READ64(*res);
2868                 bitmap[0] &= ~FATTR4_WORD0_MAXFILESIZE;
2869         }
2870         dprintk("%s: maxfilesize=%Lu\n", __func__, (unsigned long long)*res);
2871         return status;
2872 }
2873
2874 static int decode_attr_maxlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *maxlink)
2875 {
2876         __be32 *p;
2877         int status = 0;
2878
2879         *maxlink = 1;
2880         if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXLINK - 1U)))
2881                 return -EIO;
2882         if (likely(bitmap[0] & FATTR4_WORD0_MAXLINK)) {
2883                 READ_BUF(4);
2884                 READ32(*maxlink);
2885                 bitmap[0] &= ~FATTR4_WORD0_MAXLINK;
2886         }
2887         dprintk("%s: maxlink=%u\n", __func__, *maxlink);
2888         return status;
2889 }
2890
2891 static int decode_attr_maxname(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *maxname)
2892 {
2893         __be32 *p;
2894         int status = 0;
2895
2896         *maxname = 1024;
2897         if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXNAME - 1U)))
2898                 return -EIO;
2899         if (likely(bitmap[0] & FATTR4_WORD0_MAXNAME)) {
2900                 READ_BUF(4);
2901                 READ32(*maxname);
2902                 bitmap[0] &= ~FATTR4_WORD0_MAXNAME;
2903         }
2904         dprintk("%s: maxname=%u\n", __func__, *maxname);
2905         return status;
2906 }
2907
2908 static int decode_attr_maxread(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
2909 {
2910         __be32 *p;
2911         int status = 0;
2912
2913         *res = 1024;
2914         if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXREAD - 1U)))
2915                 return -EIO;
2916         if (likely(bitmap[0] & FATTR4_WORD0_MAXREAD)) {
2917                 uint64_t maxread;
2918                 READ_BUF(8);
2919                 READ64(maxread);
2920                 if (maxread > 0x7FFFFFFF)
2921                         maxread = 0x7FFFFFFF;
2922                 *res = (uint32_t)maxread;
2923                 bitmap[0] &= ~FATTR4_WORD0_MAXREAD;
2924         }
2925         dprintk("%s: maxread=%lu\n", __func__, (unsigned long)*res);
2926         return status;
2927 }
2928
2929 static int decode_attr_maxwrite(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
2930 {
2931         __be32 *p;
2932         int status = 0;
2933
2934         *res = 1024;
2935         if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXWRITE - 1U)))
2936                 return -EIO;
2937         if (likely(bitmap[0] & FATTR4_WORD0_MAXWRITE)) {
2938                 uint64_t maxwrite;
2939                 READ_BUF(8);
2940                 READ64(maxwrite);
2941                 if (maxwrite > 0x7FFFFFFF)
2942                         maxwrite = 0x7FFFFFFF;
2943                 *res = (uint32_t)maxwrite;
2944                 bitmap[0] &= ~FATTR4_WORD0_MAXWRITE;
2945         }
2946         dprintk("%s: maxwrite=%lu\n", __func__, (unsigned long)*res);
2947         return status;
2948 }
2949
2950 static int decode_attr_mode(struct xdr_stream *xdr, uint32_t *bitmap, umode_t *mode)
2951 {
2952         uint32_t tmp;
2953         __be32 *p;
2954         int ret = 0;
2955
2956         *mode = 0;
2957         if (unlikely(bitmap[1] & (FATTR4_WORD1_MODE - 1U)))
2958                 return -EIO;
2959         if (likely(bitmap[1] & FATTR4_WORD1_MODE)) {
2960                 READ_BUF(4);
2961                 READ32(tmp);
2962                 *mode = tmp & ~S_IFMT;
2963                 bitmap[1] &= ~FATTR4_WORD1_MODE;
2964                 ret = NFS_ATTR_FATTR_MODE;
2965         }
2966         dprintk("%s: file mode=0%o\n", __func__, (unsigned int)*mode);
2967         return ret;
2968 }
2969
2970 static int decode_attr_nlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *nlink)
2971 {
2972         __be32 *p;
2973         int ret = 0;
2974
2975         *nlink = 1;
2976         if (unlikely(bitmap[1] & (FATTR4_WORD1_NUMLINKS - 1U)))
2977                 return -EIO;
2978         if (likely(bitmap[1] & FATTR4_WORD1_NUMLINKS)) {
2979                 READ_BUF(4);
2980                 READ32(*nlink);
2981                 bitmap[1] &= ~FATTR4_WORD1_NUMLINKS;
2982                 ret = NFS_ATTR_FATTR_NLINK;
2983         }
2984         dprintk("%s: nlink=%u\n", __func__, (unsigned int)*nlink);
2985         return ret;
2986 }
2987
2988 static int decode_attr_owner(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_client *clp, uint32_t *uid)
2989 {
2990         uint32_t len;
2991         __be32 *p;
2992         int ret = 0;
2993
2994         *uid = -2;
2995         if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER - 1U)))
2996                 return -EIO;
2997         if (likely(bitmap[1] & FATTR4_WORD1_OWNER)) {
2998                 READ_BUF(4);
2999                 READ32(len);
3000                 READ_BUF(len);
3001                 if (len < XDR_MAX_NETOBJ) {
3002                         if (nfs_map_name_to_uid(clp, (char *)p, len, uid) == 0)
3003                                 ret = NFS_ATTR_FATTR_OWNER;
3004                         else
3005                                 dprintk("%s: nfs_map_name_to_uid failed!\n",
3006                                                 __func__);
3007                 } else
3008                         dprintk("%s: name too long (%u)!\n",
3009                                         __func__, len);
3010                 bitmap[1] &= ~FATTR4_WORD1_OWNER;
3011         }
3012         dprintk("%s: uid=%d\n", __func__, (int)*uid);
3013         return ret;
3014 }
3015
3016 static int decode_attr_group(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_client *clp, uint32_t *gid)
3017 {
3018         uint32_t len;
3019         __be32 *p;
3020         int ret = 0;
3021
3022         *gid = -2;
3023         if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER_GROUP - 1U)))
3024                 return -EIO;
3025         if (likely(bitmap[1] & FATTR4_WORD1_OWNER_GROUP)) {
3026                 READ_BUF(4);
3027                 READ32(len);
3028                 READ_BUF(len);
3029                 if (len < XDR_MAX_NETOBJ) {
3030                         if (nfs_map_group_to_gid(clp, (char *)p, len, gid) == 0)
3031                                 ret = NFS_ATTR_FATTR_GROUP;
3032                         else
3033                                 dprintk("%s: nfs_map_group_to_gid failed!\n",
3034                                                 __func__);
3035                 } else
3036                         dprintk("%s: name too long (%u)!\n",
3037                                         __func__, len);
3038                 bitmap[1] &= ~FATTR4_WORD1_OWNER_GROUP;
3039         }
3040         dprintk("%s: gid=%d\n", __func__, (int)*gid);
3041         return ret;
3042 }
3043
3044 static int decode_attr_rdev(struct xdr_stream *xdr, uint32_t *bitmap, dev_t *rdev)
3045 {
3046         uint32_t major = 0, minor = 0;
3047         __be32 *p;
3048         int ret = 0;
3049
3050         *rdev = MKDEV(0,0);
3051         if (unlikely(bitmap[1] & (FATTR4_WORD1_RAWDEV - 1U)))
3052                 return -EIO;
3053         if (likely(bitmap[1] & FATTR4_WORD1_RAWDEV)) {
3054                 dev_t tmp;
3055
3056                 READ_BUF(8);
3057                 READ32(major);
3058                 READ32(minor);
3059                 tmp = MKDEV(major, minor);
3060                 if (MAJOR(tmp) == major && MINOR(tmp) == minor)
3061                         *rdev = tmp;
3062                 bitmap[1] &= ~ FATTR4_WORD1_RAWDEV;
3063                 ret = NFS_ATTR_FATTR_RDEV;
3064         }
3065         dprintk("%s: rdev=(0x%x:0x%x)\n", __func__, major, minor);
3066         return ret;
3067 }
3068
3069 static int decode_attr_space_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
3070 {
3071         __be32 *p;
3072         int status = 0;
3073
3074         *res = 0;
3075         if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_AVAIL - 1U)))
3076                 return -EIO;
3077         if (likely(bitmap[1] & FATTR4_WORD1_SPACE_AVAIL)) {
3078                 READ_BUF(8);
3079                 READ64(*res);
3080                 bitmap[1] &= ~FATTR4_WORD1_SPACE_AVAIL;
3081         }
3082         dprintk("%s: space avail=%Lu\n", __func__, (unsigned long long)*res);
3083         return status;
3084 }
3085
3086 static int decode_attr_space_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
3087 {
3088         __be32 *p;
3089         int status = 0;
3090
3091         *res = 0;
3092         if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_FREE - 1U)))
3093                 return -EIO;
3094         if (likely(bitmap[1] & FATTR4_WORD1_SPACE_FREE)) {
3095                 READ_BUF(8);
3096                 READ64(*res);
3097                 bitmap[1] &= ~FATTR4_WORD1_SPACE_FREE;
3098         }
3099         dprintk("%s: space free=%Lu\n", __func__, (unsigned long long)*res);
3100         return status;
3101 }
3102
3103 static int decode_attr_space_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
3104 {
3105         __be32 *p;
3106         int status = 0;
3107
3108         *res = 0;
3109         if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_TOTAL - 1U)))
3110                 return -EIO;
3111         if (likely(bitmap[1] & FATTR4_WORD1_SPACE_TOTAL)) {
3112                 READ_BUF(8);
3113                 READ64(*res);
3114                 bitmap[1] &= ~FATTR4_WORD1_SPACE_TOTAL;
3115         }
3116         dprintk("%s: space total=%Lu\n", __func__, (unsigned long long)*res);
3117         return status;
3118 }
3119
3120 static int decode_attr_space_used(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *used)
3121 {
3122         __be32 *p;
3123         int ret = 0;
3124
3125         *used = 0;
3126         if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_USED - 1U)))
3127                 return -EIO;
3128         if (likely(bitmap[1] & FATTR4_WORD1_SPACE_USED)) {
3129                 READ_BUF(8);
3130                 READ64(*used);
3131                 bitmap[1] &= ~FATTR4_WORD1_SPACE_USED;
3132                 ret = NFS_ATTR_FATTR_SPACE_USED;
3133         }
3134         dprintk("%s: space used=%Lu\n", __func__,
3135                         (unsigned long long)*used);
3136         return ret;
3137 }
3138
3139 static int decode_attr_time(struct xdr_stream *xdr, struct timespec *time)
3140 {
3141         __be32 *p;
3142         uint64_t sec;
3143         uint32_t nsec;
3144
3145         READ_BUF(12);
3146         READ64(sec);
3147         READ32(nsec);
3148         time->tv_sec = (time_t)sec;
3149         time->tv_nsec = (long)nsec;
3150         return 0;
3151 }
3152
3153 static int decode_attr_time_access(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
3154 {
3155         int status = 0;
3156
3157         time->tv_sec = 0;
3158         time->tv_nsec = 0;
3159         if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_ACCESS - 1U)))
3160                 return -EIO;
3161         if (likely(bitmap[1] & FATTR4_WORD1_TIME_ACCESS)) {
3162                 status = decode_attr_time(xdr, time);
3163                 if (status == 0)
3164                         status = NFS_ATTR_FATTR_ATIME;
3165                 bitmap[1] &= ~FATTR4_WORD1_TIME_ACCESS;
3166         }
3167         dprintk("%s: atime=%ld\n", __func__, (long)time->tv_sec);
3168         return status;
3169 }
3170
3171 static int decode_attr_time_metadata(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
3172 {
3173         int status = 0;
3174
3175         time->tv_sec = 0;
3176         time->tv_nsec = 0;
3177         if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_METADATA - 1U)))
3178                 return -EIO;
3179         if (likely(bitmap[1] & FATTR4_WORD1_TIME_METADATA)) {
3180                 status = decode_attr_time(xdr, time);
3181                 if (status == 0)
3182                         status = NFS_ATTR_FATTR_CTIME;
3183                 bitmap[1] &= ~FATTR4_WORD1_TIME_METADATA;
3184         }
3185         dprintk("%s: ctime=%ld\n", __func__, (long)time->tv_sec);
3186         return status;
3187 }
3188
3189 static int decode_attr_time_modify(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
3190 {
3191         int status = 0;
3192
3193         time->tv_sec = 0;
3194         time->tv_nsec = 0;
3195         if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_MODIFY - 1U)))
3196                 return -EIO;
3197         if (likely(bitmap[1] & FATTR4_WORD1_TIME_MODIFY)) {
3198                 status = decode_attr_time(xdr, time);
3199                 if (status == 0)
3200                         status = NFS_ATTR_FATTR_MTIME;
3201                 bitmap[1] &= ~FATTR4_WORD1_TIME_MODIFY;
3202         }
3203         dprintk("%s: mtime=%ld\n", __func__, (long)time->tv_sec);
3204         return status;
3205 }
3206
3207 static int verify_attr_len(struct xdr_stream *xdr, __be32 *savep, uint32_t attrlen)
3208 {
3209         unsigned int attrwords = XDR_QUADLEN(attrlen);
3210         unsigned int nwords = xdr->p - savep;
3211
3212         if (unlikely(attrwords != nwords)) {
3213                 dprintk("%s: server returned incorrect attribute length: "
3214                         "%u %c %u\n",
3215                                 __func__,
3216                                 attrwords << 2,
3217                                 (attrwords < nwords) ? '<' : '>',
3218                                 nwords << 2);
3219                 return -EIO;
3220         }
3221         return 0;
3222 }
3223
3224 static int decode_change_info(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
3225 {
3226         __be32 *p;
3227
3228         READ_BUF(20);
3229         READ32(cinfo->atomic);
3230         READ64(cinfo->before);
3231         READ64(cinfo->after);
3232         return 0;
3233 }
3234
3235 static int decode_access(struct xdr_stream *xdr, struct nfs4_accessres *access)
3236 {
3237         __be32 *p;
3238         uint32_t supp, acc;
3239         int status;
3240
3241         status = decode_op_hdr(xdr, OP_ACCESS);
3242         if (status)
3243                 return status;
3244         READ_BUF(8);
3245         READ32(supp);
3246         READ32(acc);
3247         access->supported = supp;
3248         access->access = acc;
3249         return 0;
3250 }
3251
3252 static int decode_close(struct xdr_stream *xdr, struct nfs_closeres *res)
3253 {
3254         __be32 *p;
3255         int status;
3256
3257         status = decode_op_hdr(xdr, OP_CLOSE);
3258         if (status != -EIO)
3259                 nfs_increment_open_seqid(status, res->seqid);
3260         if (status)
3261                 return status;
3262         READ_BUF(NFS4_STATEID_SIZE);
3263         COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
3264         return 0;
3265 }
3266
3267 static int decode_commit(struct xdr_stream *xdr, struct nfs_writeres *res)
3268 {
3269         __be32 *p;
3270         int status;
3271
3272         status = decode_op_hdr(xdr, OP_COMMIT);
3273         if (status)
3274                 return status;
3275         READ_BUF(8);
3276         COPYMEM(res->verf->verifier, 8);
3277         return 0;
3278 }
3279
3280 static int decode_create(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
3281 {
3282         __be32 *p;
3283         uint32_t bmlen;
3284         int status;
3285
3286         status = decode_op_hdr(xdr, OP_CREATE);
3287         if (status)
3288                 return status;
3289         if ((status = decode_change_info(xdr, cinfo)))
3290                 return status;
3291         READ_BUF(4);
3292         READ32(bmlen);
3293         READ_BUF(bmlen << 2);
3294         return 0;
3295 }
3296
3297 static int decode_server_caps(struct xdr_stream *xdr, struct nfs4_server_caps_res *res)
3298 {
3299         __be32 *savep;
3300         uint32_t attrlen, bitmap[2] = {0};
3301         int status;
3302
3303         if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
3304                 goto xdr_error;
3305         if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
3306                 goto xdr_error;
3307         if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
3308                 goto xdr_error;
3309         if ((status = decode_attr_supported(xdr, bitmap, res->attr_bitmask)) != 0)
3310                 goto xdr_error;
3311         if ((status = decode_attr_link_support(xdr, bitmap, &res->has_links)) != 0)
3312                 goto xdr_error;
3313         if ((status = decode_attr_symlink_support(xdr, bitmap, &res->has_symlinks)) != 0)
3314                 goto xdr_error;
3315         if ((status = decode_attr_aclsupport(xdr, bitmap, &res->acl_bitmask)) != 0)
3316                 goto xdr_error;
3317         status = verify_attr_len(xdr, savep, attrlen);
3318 xdr_error:
3319         dprintk("%s: xdr returned %d!\n", __func__, -status);
3320         return status;
3321 }
3322
3323 static int decode_statfs(struct xdr_stream *xdr, struct nfs_fsstat *fsstat)
3324 {
3325         __be32 *savep;
3326         uint32_t attrlen, bitmap[2] = {0};
3327         int status;
3328
3329         if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
3330                 goto xdr_error;
3331         if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
3332                 goto xdr_error;
3333         if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
3334                 goto xdr_error;
3335
3336         if ((status = decode_attr_files_avail(xdr, bitmap, &fsstat->afiles)) != 0)
3337                 goto xdr_error;
3338         if ((status = decode_attr_files_free(xdr, bitmap, &fsstat->ffiles)) != 0)
3339                 goto xdr_error;
3340         if ((status = decode_attr_files_total(xdr, bitmap, &fsstat->tfiles)) != 0)
3341                 goto xdr_error;
3342         if ((status = decode_attr_space_avail(xdr, bitmap, &fsstat->abytes)) != 0)
3343                 goto xdr_error;
3344         if ((status = decode_attr_space_free(xdr, bitmap, &fsstat->fbytes)) != 0)
3345                 goto xdr_error;
3346         if ((status = decode_attr_space_total(xdr, bitmap, &fsstat->tbytes)) != 0)
3347                 goto xdr_error;
3348
3349         status = verify_attr_len(xdr, savep, attrlen);
3350 xdr_error:
3351         dprintk("%s: xdr returned %d!\n", __func__, -status);
3352         return status;
3353 }
3354
3355 static int decode_pathconf(struct xdr_stream *xdr, struct nfs_pathconf *pathconf)
3356 {
3357         __be32 *savep;
3358         uint32_t attrlen, bitmap[2] = {0};
3359         int status;
3360
3361         if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
3362                 goto xdr_error;
3363         if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
3364                 goto xdr_error;
3365         if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
3366                 goto xdr_error;
3367
3368         if ((status = decode_attr_maxlink(xdr, bitmap, &pathconf->max_link)) != 0)
3369                 goto xdr_error;
3370         if ((status = decode_attr_maxname(xdr, bitmap, &pathconf->max_namelen)) != 0)
3371                 goto xdr_error;
3372
3373         status = verify_attr_len(xdr, savep, attrlen);
3374 xdr_error:
3375         dprintk("%s: xdr returned %d!\n", __func__, -status);
3376         return status;
3377 }
3378
3379 static int decode_getfattr(struct xdr_stream *xdr, struct nfs_fattr *fattr, const struct nfs_server *server)
3380 {
3381         __be32 *savep;
3382         uint32_t attrlen,
3383                  bitmap[2] = {0},
3384                  type;
3385         int status;
3386         umode_t fmode = 0;
3387         uint64_t fileid;
3388
3389         status = decode_op_hdr(xdr, OP_GETATTR);
3390         if (status < 0)
3391                 goto xdr_error;
3392
3393         status = decode_attr_bitmap(xdr, bitmap);
3394         if (status < 0)
3395                 goto xdr_error;
3396
3397         status = decode_attr_length(xdr, &attrlen, &savep);
3398         if (status < 0)
3399                 goto xdr_error;
3400
3401
3402         status = decode_attr_type(xdr, bitmap, &type);
3403         if (status < 0)
3404                 goto xdr_error;
3405         fattr->mode = 0;
3406         if (status != 0) {
3407                 fattr->mode |= nfs_type2fmt[type];
3408                 fattr->valid |= status;
3409         }
3410
3411         status = decode_attr_change(xdr, bitmap, &fattr->change_attr);
3412         if (status < 0)
3413                 goto xdr_error;
3414         fattr->valid |= status;
3415
3416         status = decode_attr_size(xdr, bitmap, &fattr->size);
3417         if (status < 0)
3418                 goto xdr_error;
3419         fattr->valid |= status;
3420
3421         status = decode_attr_fsid(xdr, bitmap, &fattr->fsid);
3422         if (status < 0)
3423                 goto xdr_error;
3424         fattr->valid |= status;
3425
3426         status = decode_attr_fileid(xdr, bitmap, &fattr->fileid);
3427         if (status < 0)
3428                 goto xdr_error;
3429         fattr->valid |= status;
3430
3431         status = decode_attr_fs_locations(xdr, bitmap, container_of(fattr,
3432                                                 struct nfs4_fs_locations,
3433                                                 fattr));
3434         if (status < 0)
3435                 goto xdr_error;
3436         fattr->valid |= status;
3437
3438         status = decode_attr_mode(xdr, bitmap, &fmode);
3439         if (status < 0)
3440                 goto xdr_error;
3441         if (status != 0) {
3442                 fattr->mode |= fmode;
3443                 fattr->valid |= status;
3444         }
3445
3446         status = decode_attr_nlink(xdr, bitmap, &fattr->nlink);
3447         if (status < 0)
3448                 goto xdr_error;
3449         fattr->valid |= status;
3450
3451         status = decode_attr_owner(xdr, bitmap, server->nfs_client, &fattr->uid);
3452         if (status < 0)
3453                 goto xdr_error;
3454         fattr->valid |= status;
3455
3456         status = decode_attr_group(xdr, bitmap, server->nfs_client, &fattr->gid);
3457         if (status < 0)
3458                 goto xdr_error;
3459         fattr->valid |= status;
3460
3461         status = decode_attr_rdev(xdr, bitmap, &fattr->rdev);
3462         if (status < 0)
3463                 goto xdr_error;
3464         fattr->valid |= status;
3465
3466         status = decode_attr_space_used(xdr, bitmap, &fattr->du.nfs3.used);
3467         if (status < 0)
3468                 goto xdr_error;
3469         fattr->valid |= status;
3470
3471         status = decode_attr_time_access(xdr, bitmap, &fattr->atime);
3472         if (status < 0)
3473                 goto xdr_error;
3474         fattr->valid |= status;
3475
3476         status = decode_attr_time_metadata(xdr, bitmap, &fattr->ctime);
3477         if (status < 0)
3478                 goto xdr_error;
3479         fattr->valid |= status;
3480
3481         status = decode_attr_time_modify(xdr, bitmap, &fattr->mtime);
3482         if (status < 0)
3483                 goto xdr_error;
3484         fattr->valid |= status;
3485
3486         status = decode_attr_mounted_on_fileid(xdr, bitmap, &fileid);
3487         if (status < 0)
3488                 goto xdr_error;
3489         if (status != 0 && !(fattr->valid & status)) {
3490                 fattr->fileid = fileid;
3491                 fattr->valid |= status;
3492         }
3493
3494         status = verify_attr_len(xdr, savep, attrlen);
3495 xdr_error:
3496         dprintk("%s: xdr returned %d\n", __func__, -status);
3497         return status;
3498 }
3499
3500
3501 static int decode_fsinfo(struct xdr_stream *xdr, struct nfs_fsinfo *fsinfo)
3502 {
3503         __be32 *savep;
3504         uint32_t attrlen, bitmap[2];
3505         int status;
3506
3507         if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
3508                 goto xdr_error;
3509         if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
3510                 goto xdr_error;
3511         if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
3512                 goto xdr_error;
3513
3514         fsinfo->rtmult = fsinfo->wtmult = 512;  /* ??? */
3515
3516         if ((status = decode_attr_lease_time(xdr, bitmap, &fsinfo->lease_time)) != 0)
3517                 goto xdr_error;
3518         if ((status = decode_attr_maxfilesize(xdr, bitmap, &fsinfo->maxfilesize)) != 0)
3519                 goto xdr_error;
3520         if ((status = decode_attr_maxread(xdr, bitmap, &fsinfo->rtmax)) != 0)
3521                 goto xdr_error;
3522         fsinfo->rtpref = fsinfo->dtpref = fsinfo->rtmax;
3523         if ((status = decode_attr_maxwrite(xdr, bitmap, &fsinfo->wtmax)) != 0)
3524                 goto xdr_error;
3525         fsinfo->wtpref = fsinfo->wtmax;
3526
3527         status = verify_attr_len(xdr, savep, attrlen);
3528 xdr_error:
3529         dprintk("%s: xdr returned %d!\n", __func__, -status);
3530         return status;
3531 }
3532
3533 static int decode_getfh(struct xdr_stream *xdr, struct nfs_fh *fh)
3534 {
3535         __be32 *p;
3536         uint32_t len;
3537         int status;
3538
3539         /* Zero handle first to allow comparisons */
3540         memset(fh, 0, sizeof(*fh));
3541
3542         status = decode_op_hdr(xdr, OP_GETFH);
3543         if (status)
3544                 return status;
3545
3546         READ_BUF(4);
3547         READ32(len);
3548         if (len > NFS4_FHSIZE)
3549                 return -EIO;
3550         fh->size = len;
3551         READ_BUF(len);
3552         COPYMEM(fh->data, len);
3553         return 0;
3554 }
3555
3556 static int decode_link(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
3557 {
3558         int status;
3559
3560         status = decode_op_hdr(xdr, OP_LINK);
3561         if (status)
3562                 return status;
3563         return decode_change_info(xdr, cinfo);
3564 }
3565
3566 /*
3567  * We create the owner, so we know a proper owner.id length is 4.
3568  */
3569 static int decode_lock_denied (struct xdr_stream *xdr, struct file_lock *fl)
3570 {
3571         uint64_t offset, length, clientid;
3572         __be32 *p;
3573         uint32_t namelen, type;
3574
3575         READ_BUF(32);
3576         READ64(offset);
3577         READ64(length);
3578         READ32(type);
3579         if (fl != NULL) {
3580                 fl->fl_start = (loff_t)offset;
3581                 fl->fl_end = fl->fl_start + (loff_t)length - 1;
3582                 if (length == ~(uint64_t)0)
3583                         fl->fl_end = OFFSET_MAX;
3584                 fl->fl_type = F_WRLCK;
3585                 if (type & 1)
3586                         fl->fl_type = F_RDLCK;
3587                 fl->fl_pid = 0;
3588         }
3589         READ64(clientid);
3590         READ32(namelen);
3591         READ_BUF(namelen);
3592         return -NFS4ERR_DENIED;
3593 }
3594
3595 static int decode_lock(struct xdr_stream *xdr, struct nfs_lock_res *res)
3596 {
3597         __be32 *p;
3598         int status;
3599
3600         status = decode_op_hdr(xdr, OP_LOCK);
3601         if (status == -EIO)
3602                 goto out;
3603         if (status == 0) {
3604                 READ_BUF(NFS4_STATEID_SIZE);
3605                 COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
3606         } else if (status == -NFS4ERR_DENIED)
3607                 status = decode_lock_denied(xdr, NULL);
3608         if (res->open_seqid != NULL)
3609                 nfs_increment_open_seqid(status, res->open_seqid);
3610         nfs_increment_lock_seqid(status, res->lock_seqid);
3611 out:
3612         return status;
3613 }
3614
3615 static int decode_lockt(struct xdr_stream *xdr, struct nfs_lockt_res *res)
3616 {
3617         int status;
3618         status = decode_op_hdr(xdr, OP_LOCKT);
3619         if (status == -NFS4ERR_DENIED)
3620                 return decode_lock_denied(xdr, res->denied);
3621         return status;
3622 }
3623
3624 static int decode_locku(struct xdr_stream *xdr, struct nfs_locku_res *res)
3625 {
3626         __be32 *p;
3627         int status;
3628
3629         status = decode_op_hdr(xdr, OP_LOCKU);
3630         if (status != -EIO)
3631                 nfs_increment_lock_seqid(status, res->seqid);
3632         if (status == 0) {
3633                 READ_BUF(NFS4_STATEID_SIZE);
3634                 COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
3635         }
3636         return status;
3637 }
3638
3639 static int decode_lookup(struct xdr_stream *xdr)
3640 {
3641         return decode_op_hdr(xdr, OP_LOOKUP);
3642 }
3643
3644 /* This is too sick! */
3645 static int decode_space_limit(struct xdr_stream *xdr, u64 *maxsize)
3646 {
3647         __be32 *p;
3648         uint32_t limit_type, nblocks, blocksize;
3649
3650         READ_BUF(12);
3651         READ32(limit_type);
3652         switch (limit_type) {
3653         case 1:
3654                 READ64(*maxsize);
3655                 break;
3656         case 2:
3657                 READ32(nblocks);
3658                 READ32(blocksize);
3659                 *maxsize = (uint64_t)nblocks * (uint64_t)blocksize;
3660         }
3661         return 0;
3662 }
3663
3664 static int decode_delegation(struct xdr_stream *xdr, struct nfs_openres *res)
3665 {
3666         __be32 *p;
3667         uint32_t delegation_type;
3668
3669         READ_BUF(4);
3670         READ32(delegation_type);
3671         if (delegation_type == NFS4_OPEN_DELEGATE_NONE) {
3672                 res->delegation_type = 0;
3673                 return 0;
3674         }
3675         READ_BUF(NFS4_STATEID_SIZE+4);
3676         COPYMEM(res->delegation.data, NFS4_STATEID_SIZE);
3677         READ32(res->do_recall);
3678
3679         switch (delegation_type) {
3680         case NFS4_OPEN_DELEGATE_READ:
3681                 res->delegation_type = FMODE_READ;
3682                 break;
3683         case NFS4_OPEN_DELEGATE_WRITE:
3684                 res->delegation_type = FMODE_WRITE|FMODE_READ;
3685                 if (decode_space_limit(xdr, &res->maxsize) < 0)
3686                                 return -EIO;
3687         }
3688         return decode_ace(xdr, NULL, res->server->nfs_client);
3689 }
3690
3691 static int decode_open(struct xdr_stream *xdr, struct nfs_openres *res)
3692 {
3693         __be32 *p;
3694         uint32_t savewords, bmlen, i;
3695         int status;
3696
3697         status = decode_op_hdr(xdr, OP_OPEN);
3698         if (status != -EIO)
3699                 nfs_increment_open_seqid(status, res->seqid);
3700         if (status)
3701                 return status;
3702         READ_BUF(NFS4_STATEID_SIZE);
3703         COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
3704
3705         decode_change_info(xdr, &res->cinfo);
3706
3707         READ_BUF(8);
3708         READ32(res->rflags);
3709         READ32(bmlen);
3710         if (bmlen > 10)
3711                 goto xdr_error;
3712
3713         READ_BUF(bmlen << 2);
3714         savewords = min_t(uint32_t, bmlen, NFS4_BITMAP_SIZE);
3715         for (i = 0; i < savewords; ++i)
3716                 READ32(res->attrset[i]);
3717         for (; i < NFS4_BITMAP_SIZE; i++)
3718                 res->attrset[i] = 0;
3719
3720         return decode_delegation(xdr, res);
3721 xdr_error:
3722         dprintk("%s: Bitmap too large! Length = %u\n", __func__, bmlen);
3723         return -EIO;
3724 }
3725
3726 static int decode_open_confirm(struct xdr_stream *xdr, struct nfs_open_confirmres *res)
3727 {
3728         __be32 *p;
3729         int status;
3730
3731         status = decode_op_hdr(xdr, OP_OPEN_CONFIRM);
3732         if (status != -EIO)
3733                 nfs_increment_open_seqid(status, res->seqid);
3734         if (status)
3735                 return status;
3736         READ_BUF(NFS4_STATEID_SIZE);
3737         COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
3738         return 0;
3739 }
3740
3741 static int decode_open_downgrade(struct xdr_stream *xdr, struct nfs_closeres *res)
3742 {
3743         __be32 *p;
3744         int status;
3745
3746         status = decode_op_hdr(xdr, OP_OPEN_DOWNGRADE);
3747         if (status != -EIO)
3748                 nfs_increment_open_seqid(status, res->seqid);
3749         if (status)
3750                 return status;
3751         READ_BUF(NFS4_STATEID_SIZE);
3752         COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
3753         return 0;
3754 }
3755
3756 static int decode_putfh(struct xdr_stream *xdr)
3757 {
3758         return decode_op_hdr(xdr, OP_PUTFH);
3759 }
3760
3761 static int decode_putrootfh(struct xdr_stream *xdr)
3762 {
3763         return decode_op_hdr(xdr, OP_PUTROOTFH);
3764 }
3765
3766 static int decode_read(struct xdr_stream *xdr, struct rpc_rqst *req, struct nfs_readres *res)
3767 {
3768         struct kvec *iov = req->rq_rcv_buf.head;
3769         __be32 *p;
3770         uint32_t count, eof, recvd, hdrlen;
3771         int status;
3772
3773         status = decode_op_hdr(xdr, OP_READ);
3774         if (status)
3775                 return status;
3776         READ_BUF(8);
3777         READ32(eof);
3778         READ32(count);
3779         hdrlen = (u8 *) p - (u8 *) iov->iov_base;
3780         recvd = req->rq_rcv_buf.len - hdrlen;
3781         if (count > recvd) {
3782                 dprintk("NFS: server cheating in read reply: "
3783                                 "count %u > recvd %u\n", count, recvd);
3784                 count = recvd;
3785                 eof = 0;
3786         }
3787         xdr_read_pages(xdr, count);
3788         res->eof = eof;
3789         res->count = count;
3790         return 0;
3791 }
3792
3793 static int decode_readdir(struct xdr_stream *xdr, struct rpc_rqst *req, struct nfs4_readdir_res *readdir)
3794 {
3795         struct xdr_buf  *rcvbuf = &req->rq_rcv_buf;
3796         struct page     *page = *rcvbuf->pages;
3797         struct kvec     *iov = rcvbuf->head;
3798         size_t          hdrlen;
3799         u32             recvd, pglen = rcvbuf->page_len;
3800         __be32          *end, *entry, *p, *kaddr;
3801         unsigned int    nr = 0;
3802         int             status;
3803
3804         status = decode_op_hdr(xdr, OP_READDIR);
3805         if (status)
3806                 return status;
3807         READ_BUF(8);
3808         COPYMEM(readdir->verifier.data, 8);
3809         dprintk("%s: verifier = %08x:%08x\n",
3810                         __func__,
3811                         ((u32 *)readdir->verifier.data)[0],
3812                         ((u32 *)readdir->verifier.data)[1]);
3813
3814
3815         hdrlen = (char *) p - (char *) iov->iov_base;
3816         recvd = rcvbuf->len - hdrlen;
3817         if (pglen > recvd)
3818                 pglen = recvd;
3819         xdr_read_pages(xdr, pglen);
3820
3821         BUG_ON(pglen + readdir->pgbase > PAGE_CACHE_SIZE);
3822         kaddr = p = kmap_atomic(page, KM_USER0);
3823         end = p + ((pglen + readdir->pgbase) >> 2);
3824         entry = p;
3825
3826         /* Make sure the packet actually has a value_follows and EOF entry */
3827         if ((entry + 1) > end)
3828                 goto short_pkt;
3829
3830         for (; *p++; nr++) {
3831                 u32 len, attrlen, xlen;
3832                 if (end - p < 3)
3833                         goto short_pkt;
3834                 dprintk("cookie = %Lu, ", *((unsigned long long *)p));
3835                 p += 2;                 /* cookie */
3836                 len = ntohl(*p++);      /* filename length */
3837                 if (len > NFS4_MAXNAMLEN) {
3838                         dprintk("NFS: giant filename in readdir (len 0x%x)\n",
3839                                         len);
3840                         goto err_unmap;
3841                 }
3842                 xlen = XDR_QUADLEN(len);
3843                 if (end - p < xlen + 1)
3844                         goto short_pkt;
3845                 dprintk("filename = %*s\n", len, (char *)p);
3846                 p += xlen;
3847                 len = ntohl(*p++);      /* bitmap length */
3848                 if (end - p < len + 1)
3849                         goto short_pkt;
3850                 p += len;
3851                 attrlen = XDR_QUADLEN(ntohl(*p++));
3852                 if (end - p < attrlen + 2)
3853                         goto short_pkt;
3854                 p += attrlen;           /* attributes */
3855                 entry = p;
3856         }
3857         /*
3858          * Apparently some server sends responses that are a valid size, but
3859          * contain no entries, and have value_follows==0 and EOF==0. For
3860          * those, just set the EOF marker.
3861          */
3862         if (!nr && entry[1] == 0) {
3863                 dprintk("NFS: readdir reply truncated!\n");
3864                 entry[1] = 1;
3865         }
3866 out:
3867         kunmap_atomic(kaddr, KM_USER0);
3868         return 0;
3869 short_pkt:
3870         /*
3871          * When we get a short packet there are 2 possibilities. We can
3872          * return an error, or fix up the response to look like a valid
3873          * response and return what we have so far. If there are no
3874          * entries and the packet was short, then return -EIO. If there
3875          * are valid entries in the response, return them and pretend that
3876          * the call was successful, but incomplete. The caller can retry the
3877          * readdir starting at the last cookie.
3878          */
3879         dprintk("%s: short packet at entry %d\n", __func__, nr);
3880         entry[0] = entry[1] = 0;
3881         if (nr)
3882                 goto out;
3883 err_unmap:
3884         kunmap_atomic(kaddr, KM_USER0);
3885         return -errno_NFSERR_IO;
3886 }
3887
3888 static int decode_readlink(struct xdr_stream *xdr, struct rpc_rqst *req)
3889 {
3890         struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
3891         struct kvec *iov = rcvbuf->head;
3892         size_t hdrlen;
3893         u32 len, recvd;
3894         __be32 *p;
3895         char *kaddr;
3896         int status;
3897
3898         status = decode_op_hdr(xdr, OP_READLINK);
3899         if (status)
3900                 return status;
3901
3902         /* Convert length of symlink */
3903         READ_BUF(4);
3904         READ32(len);
3905         if (len >= rcvbuf->page_len || len <= 0) {
3906                 dprintk("nfs: server returned giant symlink!\n");
3907                 return -ENAMETOOLONG;
3908         }
3909         hdrlen = (char *) xdr->p - (char *) iov->iov_base;
3910         recvd = req->rq_rcv_buf.len - hdrlen;
3911         if (recvd < len) {
3912                 dprintk("NFS: server cheating in readlink reply: "
3913                                 "count %u > recvd %u\n", len, recvd);
3914                 return -EIO;
3915         }
3916         xdr_read_pages(xdr, len);
3917         /*
3918          * The XDR encode routine has set things up so that
3919          * the link text will be copied directly into the
3920          * buffer.  We just have to do overflow-checking,
3921          * and and null-terminate the text (the VFS expects
3922          * null-termination).
3923          */
3924         kaddr = (char *)kmap_atomic(rcvbuf->pages[0], KM_USER0);
3925         kaddr[len+rcvbuf->page_base] = '\0';
3926         kunmap_atomic(kaddr, KM_USER0);
3927         return 0;
3928 }
3929
3930 static int decode_remove(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
3931 {
3932         int status;
3933
3934         status = decode_op_hdr(xdr, OP_REMOVE);
3935         if (status)
3936                 goto out;
3937         status = decode_change_info(xdr, cinfo);
3938 out:
3939         return status;
3940 }
3941
3942 static int decode_rename(struct xdr_stream *xdr, struct nfs4_change_info *old_cinfo,
3943               struct nfs4_change_info *new_cinfo)
3944 {
3945         int status;
3946
3947         status = decode_op_hdr(xdr, OP_RENAME);
3948         if (status)
3949                 goto out;
3950         if ((status = decode_change_info(xdr, old_cinfo)))
3951                 goto out;
3952         status = decode_change_info(xdr, new_cinfo);
3953 out:
3954         return status;
3955 }
3956
3957 static int decode_renew(struct xdr_stream *xdr)
3958 {
3959         return decode_op_hdr(xdr, OP_RENEW);
3960 }
3961
3962 static int
3963 decode_restorefh(struct xdr_stream *xdr)
3964 {
3965         return decode_op_hdr(xdr, OP_RESTOREFH);
3966 }
3967
3968 static int decode_getacl(struct xdr_stream *xdr, struct rpc_rqst *req,
3969                 size_t *acl_len)
3970 {
3971         __be32 *savep;
3972         uint32_t attrlen,
3973                  bitmap[2] = {0};
3974         struct kvec *iov = req->rq_rcv_buf.head;
3975         int status;
3976
3977         *acl_len = 0;
3978         if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
3979                 goto out;
3980         if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
3981                 goto out;
3982         if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
3983                 goto out;
3984
3985         if (unlikely(bitmap[0] & (FATTR4_WORD0_ACL - 1U)))
3986                 return -EIO;
3987         if (likely(bitmap[0] & FATTR4_WORD0_ACL)) {
3988                 size_t hdrlen;
3989                 u32 recvd;
3990
3991                 /* We ignore &savep and don't do consistency checks on
3992                  * the attr length.  Let userspace figure it out.... */
3993                 hdrlen = (u8 *)xdr->p - (u8 *)iov->iov_base;
3994                 recvd = req->rq_rcv_buf.len - hdrlen;
3995                 if (attrlen > recvd) {
3996                         dprintk("NFS: server cheating in getattr"
3997                                         " acl reply: attrlen %u > recvd %u\n",
3998                                         attrlen, recvd);
3999                         return -EINVAL;
4000                 }
4001                 xdr_read_pages(xdr, attrlen);
4002                 *acl_len = attrlen;
4003         } else
4004                 status = -EOPNOTSUPP;
4005
4006 out:
4007         return status;
4008 }
4009
4010 static int
4011 decode_savefh(struct xdr_stream *xdr)
4012 {
4013         return decode_op_hdr(xdr, OP_SAVEFH);
4014 }
4015
4016 static int decode_setattr(struct xdr_stream *xdr)
4017 {
4018         __be32 *p;
4019         uint32_t bmlen;
4020         int status;
4021
4022         status = decode_op_hdr(xdr, OP_SETATTR);
4023         if (status)
4024                 return status;
4025         READ_BUF(4);
4026         READ32(bmlen);
4027         READ_BUF(bmlen << 2);
4028         return 0;
4029 }
4030
4031 static int decode_setclientid(struct xdr_stream *xdr, struct nfs_client *clp)
4032 {
4033         __be32 *p;
4034         uint32_t opnum;
4035         int32_t nfserr;
4036
4037         READ_BUF(8);
4038         READ32(opnum);
4039         if (opnum != OP_SETCLIENTID) {
4040                 dprintk("nfs: decode_setclientid: Server returned operation"
4041                         " %d\n", opnum);
4042                 return -EIO;
4043         }
4044         READ32(nfserr);
4045         if (nfserr == NFS_OK) {
4046                 READ_BUF(8 + NFS4_VERIFIER_SIZE);
4047                 READ64(clp->cl_clientid);
4048                 COPYMEM(clp->cl_confirm.data, NFS4_VERIFIER_SIZE);
4049         } else if (nfserr == NFSERR_CLID_INUSE) {
4050                 uint32_t len;
4051
4052                 /* skip netid string */
4053                 READ_BUF(4);
4054                 READ32(len);
4055                 READ_BUF(len);
4056
4057                 /* skip uaddr string */
4058                 READ_BUF(4);
4059                 READ32(len);
4060                 READ_BUF(len);
4061                 return -NFSERR_CLID_INUSE;
4062         } else
4063                 return nfs4_stat_to_errno(nfserr);
4064
4065         return 0;
4066 }
4067
4068 static int decode_setclientid_confirm(struct xdr_stream *xdr)
4069 {
4070         return decode_op_hdr(xdr, OP_SETCLIENTID_CONFIRM);
4071 }
4072
4073 static int decode_write(struct xdr_stream *xdr, struct nfs_writeres *res)
4074 {
4075         __be32 *p;
4076         int status;
4077
4078         status = decode_op_hdr(xdr, OP_WRITE);
4079         if (status)
4080                 return status;
4081
4082         READ_BUF(16);
4083         READ32(res->count);
4084         READ32(res->verf->committed);
4085         COPYMEM(res->verf->verifier, 8);
4086         return 0;
4087 }
4088
4089 static int decode_delegreturn(struct xdr_stream *xdr)
4090 {
4091         return decode_op_hdr(xdr, OP_DELEGRETURN);
4092 }
4093
4094 #if defined(CONFIG_NFS_V4_1)
4095 static int decode_exchange_id(struct xdr_stream *xdr,
4096                               struct nfs41_exchange_id_res *res)
4097 {
4098         __be32 *p;
4099         uint32_t dummy;
4100         int status;
4101         struct nfs_client *clp = res->client;
4102
4103         status = decode_op_hdr(xdr, OP_EXCHANGE_ID);
4104         if (status)
4105                 return status;
4106
4107         READ_BUF(8);
4108         READ64(clp->cl_ex_clid);
4109         READ_BUF(12);
4110         READ32(clp->cl_seqid);
4111         READ32(clp->cl_exchange_flags);
4112
4113         /* We ask for SP4_NONE */
4114         READ32(dummy);
4115         if (dummy != SP4_NONE)
4116                 return -EIO;
4117
4118         /* Throw away minor_id */
4119         READ_BUF(8);
4120
4121         /* Throw away Major id */
4122         READ_BUF(4);
4123         READ32(dummy);
4124         READ_BUF(dummy);
4125
4126         /* Throw away server_scope */
4127         READ_BUF(4);
4128         READ32(dummy);
4129         READ_BUF(dummy);
4130
4131         /* Throw away Implementation id array */
4132         READ_BUF(4);
4133         READ32(dummy);
4134         READ_BUF(dummy);
4135
4136         return 0;
4137 }
4138
4139 static int decode_chan_attrs(struct xdr_stream *xdr,
4140                              struct nfs4_channel_attrs *attrs)
4141 {
4142         __be32 *p;
4143         u32 nr_attrs;
4144
4145         READ_BUF(28);
4146         READ32(attrs->headerpadsz);
4147         READ32(attrs->max_rqst_sz);
4148         READ32(attrs->max_resp_sz);
4149         READ32(attrs->max_resp_sz_cached);
4150         READ32(attrs->max_ops);
4151         READ32(attrs->max_reqs);
4152         READ32(nr_attrs);
4153         if (unlikely(nr_attrs > 1)) {
4154                 printk(KERN_WARNING "%s: Invalid rdma channel attrs count %u\n",
4155                         __func__, nr_attrs);
4156                 return -EINVAL;
4157         }
4158         if (nr_attrs == 1)
4159                 READ_BUF(4); /* skip rdma_attrs */
4160         return 0;
4161 }
4162
4163 static int decode_create_session(struct xdr_stream *xdr,
4164                                  struct nfs41_create_session_res *res)
4165 {
4166         __be32 *p;
4167         int status;
4168         struct nfs_client *clp = res->client;
4169         struct nfs4_session *session = clp->cl_session;
4170
4171         status = decode_op_hdr(xdr, OP_CREATE_SESSION);
4172
4173         if (status)
4174                 return status;
4175
4176         /* sessionid */
4177         READ_BUF(NFS4_MAX_SESSIONID_LEN);
4178         COPYMEM(&session->sess_id, NFS4_MAX_SESSIONID_LEN);
4179
4180         /* seqid, flags */
4181         READ_BUF(8);
4182         READ32(clp->cl_seqid);
4183         READ32(session->flags);
4184
4185         /* Channel attributes */
4186         status = decode_chan_attrs(xdr, &session->fc_attrs);
4187         if (!status)
4188                 status = decode_chan_attrs(xdr, &session->bc_attrs);
4189         return status;
4190 }
4191 #endif /* CONFIG_NFS_V4_1 */
4192
4193 static int decode_sequence(struct xdr_stream *xdr,
4194                            struct nfs4_sequence_res *res,
4195                            struct rpc_rqst *rqstp)
4196 {
4197 #if defined(CONFIG_NFS_V4_1)
4198         if (!res->sr_session)
4199                 return 0;
4200
4201         /* stub */
4202 #endif /* CONFIG_NFS_V4_1 */
4203
4204         return 0;
4205 }
4206
4207 /*
4208  * END OF "GENERIC" DECODE ROUTINES.
4209  */
4210
4211 /*
4212  * Decode OPEN_DOWNGRADE response
4213  */
4214 static int nfs4_xdr_dec_open_downgrade(struct rpc_rqst *rqstp, __be32 *p, struct nfs_closeres *res)
4215 {
4216         struct xdr_stream xdr;
4217         struct compound_hdr hdr;
4218         int status;
4219
4220         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4221         status = decode_compound_hdr(&xdr, &hdr);
4222         if (status)
4223                 goto out;
4224         status = decode_sequence(&xdr, &res->seq_res, rqstp);
4225         if (status)
4226                 goto out;
4227         status = decode_putfh(&xdr);
4228         if (status)
4229                 goto out;
4230         status = decode_open_downgrade(&xdr, res);
4231         if (status != 0)
4232                 goto out;
4233         decode_getfattr(&xdr, res->fattr, res->server);
4234 out:
4235         return status;
4236 }
4237
4238 /*
4239  * Decode ACCESS response
4240  */
4241 static int nfs4_xdr_dec_access(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_accessres *res)
4242 {
4243         struct xdr_stream xdr;
4244         struct compound_hdr hdr;
4245         int status;
4246
4247         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4248         status = decode_compound_hdr(&xdr, &hdr);
4249         if (status)
4250                 goto out;
4251         status = decode_sequence(&xdr, &res->seq_res, rqstp);
4252         if (status)
4253                 goto out;
4254         status = decode_putfh(&xdr);
4255         if (status != 0)
4256                 goto out;
4257         status = decode_access(&xdr, res);
4258         if (status != 0)
4259                 goto out;
4260         decode_getfattr(&xdr, res->fattr, res->server);
4261 out:
4262         return status;
4263 }
4264
4265 /*
4266  * Decode LOOKUP response
4267  */
4268 static int nfs4_xdr_dec_lookup(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_lookup_res *res)
4269 {
4270         struct xdr_stream xdr;
4271         struct compound_hdr hdr;
4272         int status;
4273
4274         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4275         status = decode_compound_hdr(&xdr, &hdr);
4276         if (status)
4277                 goto out;
4278         status = decode_sequence(&xdr, &res->seq_res, rqstp);
4279         if (status)
4280                 goto out;
4281         if ((status = decode_putfh(&xdr)) != 0)
4282                 goto out;
4283         if ((status = decode_lookup(&xdr)) != 0)
4284                 goto out;
4285         if ((status = decode_getfh(&xdr, res->fh)) != 0)
4286                 goto out;
4287         status = decode_getfattr(&xdr, res->fattr, res->server);
4288 out:
4289         return status;
4290 }
4291
4292 /*
4293  * Decode LOOKUP_ROOT response
4294  */
4295 static int nfs4_xdr_dec_lookup_root(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_lookup_res *res)
4296 {
4297         struct xdr_stream xdr;
4298         struct compound_hdr hdr;
4299         int status;
4300
4301         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4302         status = decode_compound_hdr(&xdr, &hdr);
4303         if (status)
4304                 goto out;
4305         status = decode_sequence(&xdr, &res->seq_res, rqstp);
4306         if (status)
4307                 goto out;
4308         if ((status = decode_putrootfh(&xdr)) != 0)
4309                 goto out;
4310         if ((status = decode_getfh(&xdr, res->fh)) == 0)
4311                 status = decode_getfattr(&xdr, res->fattr, res->server);
4312 out:
4313         return status;
4314 }
4315
4316 /*
4317  * Decode REMOVE response
4318  */
4319 static int nfs4_xdr_dec_remove(struct rpc_rqst *rqstp, __be32 *p, struct nfs_removeres *res)
4320 {
4321         struct xdr_stream xdr;
4322         struct compound_hdr hdr;
4323         int status;
4324
4325         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4326         status = decode_compound_hdr(&xdr, &hdr);
4327         if (status)
4328                 goto out;
4329         status = decode_sequence(&xdr, &res->seq_res, rqstp);
4330         if (status)
4331                 goto out;
4332         if ((status = decode_putfh(&xdr)) != 0)
4333                 goto out;
4334         if ((status = decode_remove(&xdr, &res->cinfo)) != 0)
4335                 goto out;
4336         decode_getfattr(&xdr, &res->dir_attr, res->server);
4337 out:
4338         return status;
4339 }
4340
4341 /*
4342  * Decode RENAME response
4343  */
4344 static int nfs4_xdr_dec_rename(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_rename_res *res)
4345 {
4346         struct xdr_stream xdr;
4347         struct compound_hdr hdr;
4348         int status;
4349
4350         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4351         status = decode_compound_hdr(&xdr, &hdr);
4352         if (status)
4353                 goto out;
4354         status = decode_sequence(&xdr, &res->seq_res, rqstp);
4355         if (status)
4356                 goto out;
4357         if ((status = decode_putfh(&xdr)) != 0)
4358                 goto out;
4359         if ((status = decode_savefh(&xdr)) != 0)
4360                 goto out;
4361         if ((status = decode_putfh(&xdr)) != 0)
4362                 goto out;
4363         if ((status = decode_rename(&xdr, &res->old_cinfo, &res->new_cinfo)) != 0)
4364                 goto out;
4365         /* Current FH is target directory */
4366         if (decode_getfattr(&xdr, res->new_fattr, res->server) != 0)
4367                 goto out;
4368         if ((status = decode_restorefh(&xdr)) != 0)
4369                 goto out;
4370         decode_getfattr(&xdr, res->old_fattr, res->server);
4371 out:
4372         return status;
4373 }
4374
4375 /*
4376  * Decode LINK response
4377  */
4378 static int nfs4_xdr_dec_link(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_link_res *res)
4379 {
4380         struct xdr_stream xdr;
4381         struct compound_hdr hdr;
4382         int status;
4383
4384         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4385         status = decode_compound_hdr(&xdr, &hdr);
4386         if (status)
4387                 goto out;
4388         status = decode_sequence(&xdr, &res->seq_res, rqstp);
4389         if (status)
4390                 goto out;
4391         if ((status = decode_putfh(&xdr)) != 0)
4392                 goto out;
4393         if ((status = decode_savefh(&xdr)) != 0)
4394                 goto out;
4395         if ((status = decode_putfh(&xdr)) != 0)
4396                 goto out;
4397         if ((status = decode_link(&xdr, &res->cinfo)) != 0)
4398                 goto out;
4399         /*
4400          * Note order: OP_LINK leaves the directory as the current
4401          *             filehandle.
4402          */
4403         if (decode_getfattr(&xdr, res->dir_attr, res->server) != 0)
4404                 goto out;
4405         if ((status = decode_restorefh(&xdr)) != 0)
4406                 goto out;
4407         decode_getfattr(&xdr, res->fattr, res->server);
4408 out:
4409         return status;
4410 }
4411
4412 /*
4413  * Decode CREATE response
4414  */
4415 static int nfs4_xdr_dec_create(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_create_res *res)
4416 {
4417         struct xdr_stream xdr;
4418         struct compound_hdr hdr;
4419         int status;
4420
4421         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4422         status = decode_compound_hdr(&xdr, &hdr);
4423         if (status)
4424                 goto out;
4425         status = decode_sequence(&xdr, &res->seq_res, rqstp);
4426         if (status)
4427                 goto out;
4428         if ((status = decode_putfh(&xdr)) != 0)
4429                 goto out;
4430         if ((status = decode_savefh(&xdr)) != 0)
4431                 goto out;
4432         if ((status = decode_create(&xdr,&res->dir_cinfo)) != 0)
4433                 goto out;
4434         if ((status = decode_getfh(&xdr, res->fh)) != 0)
4435                 goto out;
4436         if (decode_getfattr(&xdr, res->fattr, res->server) != 0)
4437                 goto out;
4438         if ((status = decode_restorefh(&xdr)) != 0)
4439                 goto out;
4440         decode_getfattr(&xdr, res->dir_fattr, res->server);
4441 out:
4442         return status;
4443 }
4444
4445 /*
4446  * Decode SYMLINK response
4447  */
4448 static int nfs4_xdr_dec_symlink(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_create_res *res)
4449 {
4450         return nfs4_xdr_dec_create(rqstp, p, res);
4451 }
4452
4453 /*
4454  * Decode GETATTR response
4455  */
4456 static int nfs4_xdr_dec_getattr(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_getattr_res *res)
4457 {
4458         struct xdr_stream xdr;
4459         struct compound_hdr hdr;
4460         int status;
4461
4462         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4463         status = decode_compound_hdr(&xdr, &hdr);
4464         if (status)
4465                 goto out;
4466         status = decode_sequence(&xdr, &res->seq_res, rqstp);
4467         if (status)
4468                 goto out;
4469         status = decode_putfh(&xdr);
4470         if (status)
4471                 goto out;
4472         status = decode_getfattr(&xdr, res->fattr, res->server);
4473 out:
4474         return status;
4475 }
4476
4477 /*
4478  * Encode an SETACL request
4479  */
4480 static int
4481 nfs4_xdr_enc_setacl(struct rpc_rqst *req, __be32 *p, struct nfs_setaclargs *args)
4482 {
4483         struct xdr_stream xdr;
4484         struct compound_hdr hdr = {
4485                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
4486         };
4487         int status;
4488
4489         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
4490         encode_compound_hdr(&xdr, req, &hdr);
4491         encode_sequence(&xdr, &args->seq_args, &hdr);
4492         encode_putfh(&xdr, args->fh, &hdr);
4493         status = encode_setacl(&xdr, args, &hdr);
4494         encode_nops(&hdr);
4495         return status;
4496 }
4497
4498 /*
4499  * Decode SETACL response
4500  */
4501 static int
4502 nfs4_xdr_dec_setacl(struct rpc_rqst *rqstp, __be32 *p,
4503                     struct nfs_setaclres *res)
4504 {
4505         struct xdr_stream xdr;
4506         struct compound_hdr hdr;
4507         int status;
4508
4509         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4510         status = decode_compound_hdr(&xdr, &hdr);
4511         if (status)
4512                 goto out;
4513         status = decode_sequence(&xdr, &res->seq_res, rqstp);
4514         if (status)
4515                 goto out;
4516         status = decode_putfh(&xdr);
4517         if (status)
4518                 goto out;
4519         status = decode_setattr(&xdr);
4520 out:
4521         return status;
4522 }
4523
4524 /*
4525  * Decode GETACL response
4526  */
4527 static int
4528 nfs4_xdr_dec_getacl(struct rpc_rqst *rqstp, __be32 *p,
4529                     struct nfs_getaclres *res)
4530 {
4531         struct xdr_stream xdr;
4532         struct compound_hdr hdr;
4533         int status;
4534
4535         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4536         status = decode_compound_hdr(&xdr, &hdr);
4537         if (status)
4538                 goto out;
4539         status = decode_sequence(&xdr, &res->seq_res, rqstp);
4540         if (status)
4541                 goto out;
4542         status = decode_putfh(&xdr);
4543         if (status)
4544                 goto out;
4545         status = decode_getacl(&xdr, rqstp, &res->acl_len);
4546
4547 out:
4548         return status;
4549 }
4550
4551 /*
4552  * Decode CLOSE response
4553  */
4554 static int nfs4_xdr_dec_close(struct rpc_rqst *rqstp, __be32 *p, struct nfs_closeres *res)
4555 {
4556         struct xdr_stream xdr;
4557         struct compound_hdr hdr;
4558         int status;
4559
4560         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4561         status = decode_compound_hdr(&xdr, &hdr);
4562         if (status)
4563                 goto out;
4564         status = decode_sequence(&xdr, &res->seq_res, rqstp);
4565         if (status)
4566                 goto out;
4567         status = decode_putfh(&xdr);
4568         if (status)
4569                 goto out;
4570         status = decode_close(&xdr, res);
4571         if (status != 0)
4572                 goto out;
4573         /*
4574          * Note: Server may do delete on close for this file
4575          *      in which case the getattr call will fail with
4576          *      an ESTALE error. Shouldn't be a problem,
4577          *      though, since fattr->valid will remain unset.
4578          */
4579         decode_getfattr(&xdr, res->fattr, res->server);
4580 out:
4581         return status;
4582 }
4583
4584 /*
4585  * Decode OPEN response
4586  */
4587 static int nfs4_xdr_dec_open(struct rpc_rqst *rqstp, __be32 *p, struct nfs_openres *res)
4588 {
4589         struct xdr_stream xdr;
4590         struct compound_hdr hdr;
4591         int status;
4592
4593         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4594         status = decode_compound_hdr(&xdr, &hdr);
4595         if (status)
4596                 goto out;
4597         status = decode_sequence(&xdr, &res->seq_res, rqstp);
4598         if (status)
4599                 goto out;
4600         status = decode_putfh(&xdr);
4601         if (status)
4602                 goto out;
4603         status = decode_savefh(&xdr);
4604         if (status)
4605                 goto out;
4606         status = decode_open(&xdr, res);
4607         if (status)
4608                 goto out;
4609         if (decode_getfh(&xdr, &res->fh) != 0)
4610                 goto out;
4611         if (decode_getfattr(&xdr, res->f_attr, res->server) != 0)
4612                 goto out;
4613         if (decode_restorefh(&xdr) != 0)
4614                 goto out;
4615         decode_getfattr(&xdr, res->dir_attr, res->server);
4616 out:
4617         return status;
4618 }
4619
4620 /*
4621  * Decode OPEN_CONFIRM response
4622  */
4623 static int nfs4_xdr_dec_open_confirm(struct rpc_rqst *rqstp, __be32 *p, struct nfs_open_confirmres *res)
4624 {
4625         struct xdr_stream xdr;
4626         struct compound_hdr hdr;
4627         int status;
4628
4629         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4630         status = decode_compound_hdr(&xdr, &hdr);
4631         if (status)
4632                 goto out;
4633         status = decode_putfh(&xdr);
4634         if (status)
4635                 goto out;
4636         status = decode_open_confirm(&xdr, res);
4637 out:
4638         return status;
4639 }
4640
4641 /*
4642  * Decode OPEN response
4643  */
4644 static int nfs4_xdr_dec_open_noattr(struct rpc_rqst *rqstp, __be32 *p, struct nfs_openres *res)
4645 {
4646         struct xdr_stream xdr;
4647         struct compound_hdr hdr;
4648         int status;
4649
4650         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4651         status = decode_compound_hdr(&xdr, &hdr);
4652         if (status)
4653                 goto out;
4654         status = decode_sequence(&xdr, &res->seq_res, rqstp);
4655         if (status)
4656                 goto out;
4657         status = decode_putfh(&xdr);
4658         if (status)
4659                 goto out;
4660         status = decode_open(&xdr, res);
4661         if (status)
4662                 goto out;
4663         decode_getfattr(&xdr, res->f_attr, res->server);
4664 out:
4665         return status;
4666 }
4667
4668 /*
4669  * Decode SETATTR response
4670  */
4671 static int nfs4_xdr_dec_setattr(struct rpc_rqst *rqstp, __be32 *p, struct nfs_setattrres *res)
4672 {
4673         struct xdr_stream xdr;
4674         struct compound_hdr hdr;
4675         int status;
4676
4677         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4678         status = decode_compound_hdr(&xdr, &hdr);
4679         if (status)
4680                 goto out;
4681         status = decode_sequence(&xdr, &res->seq_res, rqstp);
4682         if (status)
4683                 goto out;
4684         status = decode_putfh(&xdr);
4685         if (status)
4686                 goto out;
4687         status = decode_setattr(&xdr);
4688         if (status)
4689                 goto out;
4690         decode_getfattr(&xdr, res->fattr, res->server);
4691 out:
4692         return status;
4693 }
4694
4695 /*
4696  * Decode LOCK response
4697  */
4698 static int nfs4_xdr_dec_lock(struct rpc_rqst *rqstp, __be32 *p, struct nfs_lock_res *res)
4699 {
4700         struct xdr_stream xdr;
4701         struct compound_hdr hdr;
4702         int status;
4703
4704         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4705         status = decode_compound_hdr(&xdr, &hdr);
4706         if (status)
4707                 goto out;
4708         status = decode_sequence(&xdr, &res->seq_res, rqstp);
4709         if (status)
4710                 goto out;
4711         status = decode_putfh(&xdr);
4712         if (status)
4713                 goto out;
4714         status = decode_lock(&xdr, res);
4715 out:
4716         return status;
4717 }
4718
4719 /*
4720  * Decode LOCKT response
4721  */
4722 static int nfs4_xdr_dec_lockt(struct rpc_rqst *rqstp, __be32 *p, struct nfs_lockt_res *res)
4723 {
4724         struct xdr_stream xdr;
4725         struct compound_hdr hdr;
4726         int status;
4727
4728         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4729         status = decode_compound_hdr(&xdr, &hdr);
4730         if (status)
4731                 goto out;
4732         status = decode_sequence(&xdr, &res->seq_res, rqstp);
4733         if (status)
4734                 goto out;
4735         status = decode_putfh(&xdr);
4736         if (status)
4737                 goto out;
4738         status = decode_lockt(&xdr, res);
4739 out:
4740         return status;
4741 }
4742
4743 /*
4744  * Decode LOCKU response
4745  */
4746 static int nfs4_xdr_dec_locku(struct rpc_rqst *rqstp, __be32 *p, struct nfs_locku_res *res)
4747 {
4748         struct xdr_stream xdr;
4749         struct compound_hdr hdr;
4750         int status;
4751
4752         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4753         status = decode_compound_hdr(&xdr, &hdr);
4754         if (status)
4755                 goto out;
4756         status = decode_sequence(&xdr, &res->seq_res, rqstp);
4757         if (status)
4758                 goto out;
4759         status = decode_putfh(&xdr);
4760         if (status)
4761                 goto out;
4762         status = decode_locku(&xdr, res);
4763 out:
4764         return status;
4765 }
4766
4767 /*
4768  * Decode READLINK response
4769  */
4770 static int nfs4_xdr_dec_readlink(struct rpc_rqst *rqstp, __be32 *p,
4771                                  struct nfs4_readlink_res *res)
4772 {
4773         struct xdr_stream xdr;
4774         struct compound_hdr hdr;
4775         int status;
4776
4777         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4778         status = decode_compound_hdr(&xdr, &hdr);
4779         if (status)
4780                 goto out;
4781         status = decode_sequence(&xdr, &res->seq_res, rqstp);
4782         if (status)
4783                 goto out;
4784         status = decode_putfh(&xdr);
4785         if (status)
4786                 goto out;
4787         status = decode_readlink(&xdr, rqstp);
4788 out:
4789         return status;
4790 }
4791
4792 /*
4793  * Decode READDIR response
4794  */
4795 static int nfs4_xdr_dec_readdir(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_readdir_res *res)
4796 {
4797         struct xdr_stream xdr;
4798         struct compound_hdr hdr;
4799         int status;
4800
4801         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4802         status = decode_compound_hdr(&xdr, &hdr);
4803         if (status)
4804                 goto out;
4805         status = decode_sequence(&xdr, &res->seq_res, rqstp);
4806         if (status)
4807                 goto out;
4808         status = decode_putfh(&xdr);
4809         if (status)
4810                 goto out;
4811         status = decode_readdir(&xdr, rqstp, res);
4812 out:
4813         return status;
4814 }
4815
4816 /*
4817  * Decode Read response
4818  */
4819 static int nfs4_xdr_dec_read(struct rpc_rqst *rqstp, __be32 *p, struct nfs_readres *res)
4820 {
4821         struct xdr_stream xdr;
4822         struct compound_hdr hdr;
4823         int status;
4824
4825         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4826         status = decode_compound_hdr(&xdr, &hdr);
4827         if (status)
4828                 goto out;
4829         status = decode_sequence(&xdr, &res->seq_res, rqstp);
4830         if (status)
4831                 goto out;
4832         status = decode_putfh(&xdr);
4833         if (status)
4834                 goto out;
4835         status = decode_read(&xdr, rqstp, res);
4836         if (!status)
4837                 status = res->count;
4838 out:
4839         return status;
4840 }
4841
4842 /*
4843  * Decode WRITE response
4844  */
4845 static int nfs4_xdr_dec_write(struct rpc_rqst *rqstp, __be32 *p, struct nfs_writeres *res)
4846 {
4847         struct xdr_stream xdr;
4848         struct compound_hdr hdr;
4849         int status;
4850
4851         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4852         status = decode_compound_hdr(&xdr, &hdr);
4853         if (status)
4854                 goto out;
4855         status = decode_sequence(&xdr, &res->seq_res, rqstp);
4856         if (status)
4857                 goto out;
4858         status = decode_putfh(&xdr);
4859         if (status)
4860                 goto out;
4861         status = decode_write(&xdr, res);
4862         if (status)
4863                 goto out;
4864         decode_getfattr(&xdr, res->fattr, res->server);
4865         if (!status)
4866                 status = res->count;
4867 out:
4868         return status;
4869 }
4870
4871 /*
4872  * Decode COMMIT response
4873  */
4874 static int nfs4_xdr_dec_commit(struct rpc_rqst *rqstp, __be32 *p, struct nfs_writeres *res)
4875 {
4876         struct xdr_stream xdr;
4877         struct compound_hdr hdr;
4878         int status;
4879
4880         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4881         status = decode_compound_hdr(&xdr, &hdr);
4882         if (status)
4883                 goto out;
4884         status = decode_sequence(&xdr, &res->seq_res, rqstp);
4885         if (status)
4886                 goto out;
4887         status = decode_putfh(&xdr);
4888         if (status)
4889                 goto out;
4890         status = decode_commit(&xdr, res);
4891         if (status)
4892                 goto out;
4893         decode_getfattr(&xdr, res->fattr, res->server);
4894 out:
4895         return status;
4896 }
4897
4898 /*
4899  * FSINFO request
4900  */
4901 static int nfs4_xdr_dec_fsinfo(struct rpc_rqst *req, __be32 *p,
4902                                struct nfs4_fsinfo_res *res)
4903 {
4904         struct xdr_stream xdr;
4905         struct compound_hdr hdr;
4906         int status;
4907
4908         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
4909         status = decode_compound_hdr(&xdr, &hdr);
4910         if (!status)
4911                 status = decode_sequence(&xdr, &res->seq_res, req);
4912         if (!status)
4913                 status = decode_putfh(&xdr);
4914         if (!status)
4915                 status = decode_fsinfo(&xdr, res->fsinfo);
4916         return status;
4917 }
4918
4919 /*
4920  * PATHCONF request
4921  */
4922 static int nfs4_xdr_dec_pathconf(struct rpc_rqst *req, __be32 *p,
4923                                  struct nfs4_pathconf_res *res)
4924 {
4925         struct xdr_stream xdr;
4926         struct compound_hdr hdr;
4927         int status;
4928
4929         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
4930         status = decode_compound_hdr(&xdr, &hdr);
4931         if (!status)
4932                 status = decode_sequence(&xdr, &res->seq_res, req);
4933         if (!status)
4934                 status = decode_putfh(&xdr);
4935         if (!status)
4936                 status = decode_pathconf(&xdr, res->pathconf);
4937         return status;
4938 }
4939
4940 /*
4941  * STATFS request
4942  */
4943 static int nfs4_xdr_dec_statfs(struct rpc_rqst *req, __be32 *p,
4944                                struct nfs4_statfs_res *res)
4945 {
4946         struct xdr_stream xdr;
4947         struct compound_hdr hdr;
4948         int status;
4949
4950         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
4951         status = decode_compound_hdr(&xdr, &hdr);
4952         if (!status)
4953                 status = decode_sequence(&xdr, &res->seq_res, req);
4954         if (!status)
4955                 status = decode_putfh(&xdr);
4956         if (!status)
4957                 status = decode_statfs(&xdr, res->fsstat);
4958         return status;
4959 }
4960
4961 /*
4962  * GETATTR_BITMAP request
4963  */
4964 static int nfs4_xdr_dec_server_caps(struct rpc_rqst *req, __be32 *p, struct nfs4_server_caps_res *res)
4965 {
4966         struct xdr_stream xdr;
4967         struct compound_hdr hdr;
4968         int status;
4969
4970         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
4971         status = decode_compound_hdr(&xdr, &hdr);
4972         if (status)
4973                 goto out;
4974         status = decode_sequence(&xdr, &res->seq_res, req);
4975         if (status)
4976                 goto out;
4977         if ((status = decode_putfh(&xdr)) != 0)
4978                 goto out;
4979         status = decode_server_caps(&xdr, res);
4980 out:
4981         return status;
4982 }
4983
4984 /*
4985  * Decode RENEW response
4986  */
4987 static int nfs4_xdr_dec_renew(struct rpc_rqst *rqstp, __be32 *p, void *dummy)
4988 {
4989         struct xdr_stream xdr;
4990         struct compound_hdr hdr;
4991         int status;
4992
4993         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4994         status = decode_compound_hdr(&xdr, &hdr);
4995         if (!status)
4996                 status = decode_renew(&xdr);
4997         return status;
4998 }
4999
5000 /*
5001  * a SETCLIENTID request
5002  */
5003 static int nfs4_xdr_dec_setclientid(struct rpc_rqst *req, __be32 *p,
5004                 struct nfs_client *clp)
5005 {
5006         struct xdr_stream xdr;
5007         struct compound_hdr hdr;
5008         int status;
5009
5010         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
5011         status = decode_compound_hdr(&xdr, &hdr);
5012         if (!status)
5013                 status = decode_setclientid(&xdr, clp);
5014         return status;
5015 }
5016
5017 /*
5018  * a SETCLIENTID_CONFIRM request
5019  */
5020 static int nfs4_xdr_dec_setclientid_confirm(struct rpc_rqst *req, __be32 *p, struct nfs_fsinfo *fsinfo)
5021 {
5022         struct xdr_stream xdr;
5023         struct compound_hdr hdr;
5024         int status;
5025
5026         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
5027         status = decode_compound_hdr(&xdr, &hdr);
5028         if (!status)
5029                 status = decode_setclientid_confirm(&xdr);
5030         if (!status)
5031                 status = decode_putrootfh(&xdr);
5032         if (!status)
5033                 status = decode_fsinfo(&xdr, fsinfo);
5034         return status;
5035 }
5036
5037 /*
5038  * DELEGRETURN request
5039  */
5040 static int nfs4_xdr_dec_delegreturn(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_delegreturnres *res)
5041 {
5042         struct xdr_stream xdr;
5043         struct compound_hdr hdr;
5044         int status;
5045
5046         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
5047         status = decode_compound_hdr(&xdr, &hdr);
5048         if (status)
5049                 goto out;
5050         status = decode_sequence(&xdr, &res->seq_res, rqstp);
5051         if (status)
5052                 goto out;
5053         status = decode_putfh(&xdr);
5054         if (status != 0)
5055                 goto out;
5056         status = decode_delegreturn(&xdr);
5057         decode_getfattr(&xdr, res->fattr, res->server);
5058 out:
5059         return status;
5060 }
5061
5062 /*
5063  * FS_LOCATIONS request
5064  */
5065 static int nfs4_xdr_dec_fs_locations(struct rpc_rqst *req, __be32 *p,
5066                                      struct nfs4_fs_locations_res *res)
5067 {
5068         struct xdr_stream xdr;
5069         struct compound_hdr hdr;
5070         int status;
5071
5072         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
5073         status = decode_compound_hdr(&xdr, &hdr);
5074         if (status)
5075                 goto out;
5076         status = decode_sequence(&xdr, &res->seq_res, req);
5077         if (status)
5078                 goto out;
5079         if ((status = decode_putfh(&xdr)) != 0)
5080                 goto out;
5081         if ((status = decode_lookup(&xdr)) != 0)
5082                 goto out;
5083         xdr_enter_page(&xdr, PAGE_SIZE);
5084         status = decode_getfattr(&xdr, &res->fs_locations->fattr,
5085                                  res->fs_locations->server);
5086 out:
5087         return status;
5088 }
5089
5090 #if defined(CONFIG_NFS_V4_1)
5091 /*
5092  * EXCHANGE_ID request
5093  */
5094 static int nfs4_xdr_dec_exchange_id(struct rpc_rqst *rqstp, uint32_t *p,
5095                                     void *res)
5096 {
5097         struct xdr_stream xdr;
5098         struct compound_hdr hdr;
5099         int status;
5100
5101         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
5102         status = decode_compound_hdr(&xdr, &hdr);
5103         if (!status)
5104                 status = decode_exchange_id(&xdr, res);
5105         return status;
5106 }
5107
5108 /*
5109  * a CREATE_SESSION request
5110  */
5111 static int nfs4_xdr_dec_create_session(struct rpc_rqst *rqstp, uint32_t *p,
5112                                        struct nfs41_create_session_res *res)
5113 {
5114         struct xdr_stream xdr;
5115         struct compound_hdr hdr;
5116         int status;
5117
5118         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
5119         status = decode_compound_hdr(&xdr, &hdr);
5120         if (!status)
5121                 status = decode_create_session(&xdr, res);
5122         return status;
5123 }
5124
5125 /*
5126  * a GET_LEASE_TIME request
5127  */
5128 static int nfs4_xdr_dec_get_lease_time(struct rpc_rqst *rqstp, uint32_t *p,
5129                                        struct nfs4_get_lease_time_res *res)
5130 {
5131         struct xdr_stream xdr;
5132         struct compound_hdr hdr;
5133         int status;
5134
5135         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
5136         status = decode_compound_hdr(&xdr, &hdr);
5137         if (!status)
5138                 status = decode_sequence(&xdr, &res->lr_seq_res, rqstp);
5139         if (!status)
5140                 status = decode_putrootfh(&xdr);
5141         if (!status)
5142                 status = decode_fsinfo(&xdr, res->lr_fsinfo);
5143         return status;
5144 }
5145 #endif /* CONFIG_NFS_V4_1 */
5146
5147 __be32 *nfs4_decode_dirent(__be32 *p, struct nfs_entry *entry, int plus)
5148 {
5149         uint32_t bitmap[2] = {0};
5150         uint32_t len;
5151
5152         if (!*p++) {
5153                 if (!*p)
5154                         return ERR_PTR(-EAGAIN);
5155                 entry->eof = 1;
5156                 return ERR_PTR(-EBADCOOKIE);
5157         }
5158
5159         entry->prev_cookie = entry->cookie;
5160         p = xdr_decode_hyper(p, &entry->cookie);
5161         entry->len = ntohl(*p++);
5162         entry->name = (const char *) p;
5163         p += XDR_QUADLEN(entry->len);
5164
5165         /*
5166          * In case the server doesn't return an inode number,
5167          * we fake one here.  (We don't use inode number 0,
5168          * since glibc seems to choke on it...)
5169          */
5170         entry->ino = 1;
5171
5172         len = ntohl(*p++);              /* bitmap length */
5173         if (len-- > 0) {
5174                 bitmap[0] = ntohl(*p++);
5175                 if (len-- > 0) {
5176                         bitmap[1] = ntohl(*p++);
5177                         p += len;
5178                 }
5179         }
5180         len = XDR_QUADLEN(ntohl(*p++)); /* attribute buffer length */
5181         if (len > 0) {
5182                 if (bitmap[0] & FATTR4_WORD0_RDATTR_ERROR) {
5183                         bitmap[0] &= ~FATTR4_WORD0_RDATTR_ERROR;
5184                         /* Ignore the return value of rdattr_error for now */
5185                         p++;
5186                         len--;
5187                 }
5188                 if (bitmap[0] == 0 && bitmap[1] == FATTR4_WORD1_MOUNTED_ON_FILEID)
5189                         xdr_decode_hyper(p, &entry->ino);
5190                 else if (bitmap[0] == FATTR4_WORD0_FILEID)
5191                         xdr_decode_hyper(p, &entry->ino);
5192                 p += len;
5193         }
5194
5195         entry->eof = !p[0] && p[1];
5196         return p;
5197 }
5198
5199 /*
5200  * We need to translate between nfs status return values and
5201  * the local errno values which may not be the same.
5202  */
5203 static struct {
5204         int stat;
5205         int errno;
5206 } nfs_errtbl[] = {
5207         { NFS4_OK,              0               },
5208         { NFS4ERR_PERM,         -EPERM          },
5209         { NFS4ERR_NOENT,        -ENOENT         },
5210         { NFS4ERR_IO,           -errno_NFSERR_IO},
5211         { NFS4ERR_NXIO,         -ENXIO          },
5212         { NFS4ERR_ACCESS,       -EACCES         },
5213         { NFS4ERR_EXIST,        -EEXIST         },
5214         { NFS4ERR_XDEV,         -EXDEV          },
5215         { NFS4ERR_NOTDIR,       -ENOTDIR        },
5216         { NFS4ERR_ISDIR,        -EISDIR         },
5217         { NFS4ERR_INVAL,        -EINVAL         },
5218         { NFS4ERR_FBIG,         -EFBIG          },
5219         { NFS4ERR_NOSPC,        -ENOSPC         },
5220         { NFS4ERR_ROFS,         -EROFS          },
5221         { NFS4ERR_MLINK,        -EMLINK         },
5222         { NFS4ERR_NAMETOOLONG,  -ENAMETOOLONG   },
5223         { NFS4ERR_NOTEMPTY,     -ENOTEMPTY      },
5224         { NFS4ERR_DQUOT,        -EDQUOT         },
5225         { NFS4ERR_STALE,        -ESTALE         },
5226         { NFS4ERR_BADHANDLE,    -EBADHANDLE     },
5227         { NFS4ERR_BADOWNER,     -EINVAL         },
5228         { NFS4ERR_BADNAME,      -EINVAL         },
5229         { NFS4ERR_BAD_COOKIE,   -EBADCOOKIE     },
5230         { NFS4ERR_NOTSUPP,      -ENOTSUPP       },
5231         { NFS4ERR_TOOSMALL,     -ETOOSMALL      },
5232         { NFS4ERR_SERVERFAULT,  -ESERVERFAULT   },
5233         { NFS4ERR_BADTYPE,      -EBADTYPE       },
5234         { NFS4ERR_LOCKED,       -EAGAIN         },
5235         { NFS4ERR_RESOURCE,     -EREMOTEIO      },
5236         { NFS4ERR_SYMLINK,      -ELOOP          },
5237         { NFS4ERR_OP_ILLEGAL,   -EOPNOTSUPP     },
5238         { NFS4ERR_DEADLOCK,     -EDEADLK        },
5239         { NFS4ERR_WRONGSEC,     -EPERM          }, /* FIXME: this needs
5240                                                     * to be handled by a
5241                                                     * middle-layer.
5242                                                     */
5243         { -1,                   -EIO            }
5244 };
5245
5246 /*
5247  * Convert an NFS error code to a local one.
5248  * This one is used jointly by NFSv2 and NFSv3.
5249  */
5250 static int
5251 nfs4_stat_to_errno(int stat)
5252 {
5253         int i;
5254         for (i = 0; nfs_errtbl[i].stat != -1; i++) {
5255                 if (nfs_errtbl[i].stat == stat)
5256                         return nfs_errtbl[i].errno;
5257         }
5258         if (stat <= 10000 || stat > 10100) {
5259                 /* The server is looney tunes. */
5260                 return -ESERVERFAULT;
5261         }
5262         /* If we cannot translate the error, the recovery routines should
5263          * handle it.
5264          * Note: remaining NFSv4 error codes have values > 10000, so should
5265          * not conflict with native Linux error codes.
5266          */
5267         return -stat;
5268 }
5269
5270 #define PROC(proc, argtype, restype)                            \
5271 [NFSPROC4_CLNT_##proc] = {                                      \
5272         .p_proc   = NFSPROC4_COMPOUND,                          \
5273         .p_encode = (kxdrproc_t) nfs4_xdr_##argtype,            \
5274         .p_decode = (kxdrproc_t) nfs4_xdr_##restype,            \
5275         .p_arglen = NFS4_##argtype##_sz,                        \
5276         .p_replen = NFS4_##restype##_sz,                        \
5277         .p_statidx = NFSPROC4_CLNT_##proc,                      \
5278         .p_name   = #proc,                                      \
5279 }
5280
5281 struct rpc_procinfo     nfs4_procedures[] = {
5282   PROC(READ,            enc_read,       dec_read),
5283   PROC(WRITE,           enc_write,      dec_write),
5284   PROC(COMMIT,          enc_commit,     dec_commit),
5285   PROC(OPEN,            enc_open,       dec_open),
5286   PROC(OPEN_CONFIRM,    enc_open_confirm,       dec_open_confirm),
5287   PROC(OPEN_NOATTR,     enc_open_noattr,        dec_open_noattr),
5288   PROC(OPEN_DOWNGRADE,  enc_open_downgrade,     dec_open_downgrade),
5289   PROC(CLOSE,           enc_close,      dec_close),
5290   PROC(SETATTR,         enc_setattr,    dec_setattr),
5291   PROC(FSINFO,          enc_fsinfo,     dec_fsinfo),
5292   PROC(RENEW,           enc_renew,      dec_renew),
5293   PROC(SETCLIENTID,     enc_setclientid,        dec_setclientid),
5294   PROC(SETCLIENTID_CONFIRM,     enc_setclientid_confirm,        dec_setclientid_confirm),
5295   PROC(LOCK,            enc_lock,       dec_lock),
5296   PROC(LOCKT,           enc_lockt,      dec_lockt),
5297   PROC(LOCKU,           enc_locku,      dec_locku),
5298   PROC(ACCESS,          enc_access,     dec_access),
5299   PROC(GETATTR,         enc_getattr,    dec_getattr),
5300   PROC(LOOKUP,          enc_lookup,     dec_lookup),
5301   PROC(LOOKUP_ROOT,     enc_lookup_root,        dec_lookup_root),
5302   PROC(REMOVE,          enc_remove,     dec_remove),
5303   PROC(RENAME,          enc_rename,     dec_rename),
5304   PROC(LINK,            enc_link,       dec_link),
5305   PROC(SYMLINK,         enc_symlink,    dec_symlink),
5306   PROC(CREATE,          enc_create,     dec_create),
5307   PROC(PATHCONF,        enc_pathconf,   dec_pathconf),
5308   PROC(STATFS,          enc_statfs,     dec_statfs),
5309   PROC(READLINK,        enc_readlink,   dec_readlink),
5310   PROC(READDIR,         enc_readdir,    dec_readdir),
5311   PROC(SERVER_CAPS,     enc_server_caps, dec_server_caps),
5312   PROC(DELEGRETURN,     enc_delegreturn, dec_delegreturn),
5313   PROC(GETACL,          enc_getacl,     dec_getacl),
5314   PROC(SETACL,          enc_setacl,     dec_setacl),
5315   PROC(FS_LOCATIONS,    enc_fs_locations, dec_fs_locations),
5316 #if defined(CONFIG_NFS_V4_1)
5317   PROC(EXCHANGE_ID,     enc_exchange_id,        dec_exchange_id),
5318   PROC(CREATE_SESSION,  enc_create_session,     dec_create_session),
5319   PROC(GET_LEASE_TIME,  enc_get_lease_time,     dec_get_lease_time),
5320 #endif /* CONFIG_NFS_V4_1 */
5321 };
5322
5323 struct rpc_version              nfs_version4 = {
5324         .number                 = 4,
5325         .nrprocs                = ARRAY_SIZE(nfs4_procedures),
5326         .procs                  = nfs4_procedures
5327 };
5328
5329 /*
5330  * Local variables:
5331  *  c-basic-offset: 8
5332  * End:
5333  */