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