LCOV - code coverage report
Current view: top level - fs/nfs - nfs4xdr.c (source / functions) Hit Total Coverage
Test: Real Lines: 0 2543 0.0 %
Date: 2020-10-17 15:46:16 Functions: 0 270 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       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                 :            : 
      56                 :            : #include "nfs4_fs.h"
      57                 :            : #include "nfs4trace.h"
      58                 :            : #include "internal.h"
      59                 :            : #include "nfs4idmap.h"
      60                 :            : #include "nfs4session.h"
      61                 :            : #include "pnfs.h"
      62                 :            : #include "netns.h"
      63                 :            : 
      64                 :            : #define NFSDBG_FACILITY         NFSDBG_XDR
      65                 :            : 
      66                 :            : /* Mapping from NFS error code to "errno" error code. */
      67                 :            : #define errno_NFSERR_IO         EIO
      68                 :            : 
      69                 :            : struct compound_hdr;
      70                 :            : static int nfs4_stat_to_errno(int);
      71                 :            : static void encode_layoutget(struct xdr_stream *xdr,
      72                 :            :                              const struct nfs4_layoutget_args *args,
      73                 :            :                              struct compound_hdr *hdr);
      74                 :            : static int decode_layoutget(struct xdr_stream *xdr, struct rpc_rqst *req,
      75                 :            :                              struct nfs4_layoutget_res *res);
      76                 :            : 
      77                 :            : /* NFSv4 COMPOUND tags are only wanted for debugging purposes */
      78                 :            : #ifdef DEBUG
      79                 :            : #define NFS4_MAXTAGLEN          20
      80                 :            : #else
      81                 :            : #define NFS4_MAXTAGLEN          0
      82                 :            : #endif
      83                 :            : 
      84                 :            : /* lock,open owner id:
      85                 :            :  * we currently use size 2 (u64) out of (NFS4_OPAQUE_LIMIT  >> 2)
      86                 :            :  */
      87                 :            : #define open_owner_id_maxsz     (1 + 2 + 1 + 1 + 2)
      88                 :            : #define lock_owner_id_maxsz     (1 + 1 + 4)
      89                 :            : #define decode_lockowner_maxsz  (1 + XDR_QUADLEN(IDMAP_NAMESZ))
      90                 :            : #define compound_encode_hdr_maxsz       (3 + (NFS4_MAXTAGLEN >> 2))
      91                 :            : #define compound_decode_hdr_maxsz       (3 + (NFS4_MAXTAGLEN >> 2))
      92                 :            : #define op_encode_hdr_maxsz     (1)
      93                 :            : #define op_decode_hdr_maxsz     (2)
      94                 :            : #define encode_stateid_maxsz    (XDR_QUADLEN(NFS4_STATEID_SIZE))
      95                 :            : #define decode_stateid_maxsz    (XDR_QUADLEN(NFS4_STATEID_SIZE))
      96                 :            : #define encode_verifier_maxsz   (XDR_QUADLEN(NFS4_VERIFIER_SIZE))
      97                 :            : #define decode_verifier_maxsz   (XDR_QUADLEN(NFS4_VERIFIER_SIZE))
      98                 :            : #define encode_putfh_maxsz      (op_encode_hdr_maxsz + 1 + \
      99                 :            :                                 (NFS4_FHSIZE >> 2))
     100                 :            : #define decode_putfh_maxsz      (op_decode_hdr_maxsz)
     101                 :            : #define encode_putrootfh_maxsz  (op_encode_hdr_maxsz)
     102                 :            : #define decode_putrootfh_maxsz  (op_decode_hdr_maxsz)
     103                 :            : #define encode_getfh_maxsz      (op_encode_hdr_maxsz)
     104                 :            : #define decode_getfh_maxsz      (op_decode_hdr_maxsz + 1 + \
     105                 :            :                                 ((3+NFS4_FHSIZE) >> 2))
     106                 :            : #define nfs4_fattr_bitmap_maxsz 4
     107                 :            : #define encode_getattr_maxsz    (op_encode_hdr_maxsz + nfs4_fattr_bitmap_maxsz)
     108                 :            : #define nfstime4_maxsz          (3)
     109                 :            : #define nfs4_name_maxsz         (1 + ((3 + NFS4_MAXNAMLEN) >> 2))
     110                 :            : #define nfs4_path_maxsz         (1 + ((3 + NFS4_MAXPATHLEN) >> 2))
     111                 :            : #define nfs4_owner_maxsz        (1 + XDR_QUADLEN(IDMAP_NAMESZ))
     112                 :            : #define nfs4_group_maxsz        (1 + XDR_QUADLEN(IDMAP_NAMESZ))
     113                 :            : #ifdef CONFIG_NFS_V4_SECURITY_LABEL
     114                 :            : /* PI(4 bytes) + LFS(4 bytes) + 1(for null terminator?) + MAXLABELLEN */
     115                 :            : #define nfs4_label_maxsz        (4 + 4 + 1 + XDR_QUADLEN(NFS4_MAXLABELLEN))
     116                 :            : #else
     117                 :            : #define nfs4_label_maxsz        0
     118                 :            : #endif
     119                 :            : /* We support only one layout type per file system */
     120                 :            : #define decode_mdsthreshold_maxsz (1 + 1 + nfs4_fattr_bitmap_maxsz + 1 + 8)
     121                 :            : /* This is based on getfattr, which uses the most attributes: */
     122                 :            : #define nfs4_fattr_value_maxsz  (1 + (1 + 2 + 2 + 4 + 2 + 1 + 1 + 2 + 2 + \
     123                 :            :                                 3*nfstime4_maxsz + \
     124                 :            :                                 nfs4_owner_maxsz + \
     125                 :            :                                 nfs4_group_maxsz + nfs4_label_maxsz + \
     126                 :            :                                  decode_mdsthreshold_maxsz))
     127                 :            : #define nfs4_fattr_maxsz        (nfs4_fattr_bitmap_maxsz + \
     128                 :            :                                 nfs4_fattr_value_maxsz)
     129                 :            : #define decode_getattr_maxsz    (op_decode_hdr_maxsz + nfs4_fattr_maxsz)
     130                 :            : #define encode_attrs_maxsz      (nfs4_fattr_bitmap_maxsz + \
     131                 :            :                                  1 + 2 + 1 + \
     132                 :            :                                 nfs4_owner_maxsz + \
     133                 :            :                                 nfs4_group_maxsz + \
     134                 :            :                                 nfs4_label_maxsz + \
     135                 :            :                                 1 + nfstime4_maxsz + \
     136                 :            :                                 1 + nfstime4_maxsz)
     137                 :            : #define encode_savefh_maxsz     (op_encode_hdr_maxsz)
     138                 :            : #define decode_savefh_maxsz     (op_decode_hdr_maxsz)
     139                 :            : #define encode_restorefh_maxsz  (op_encode_hdr_maxsz)
     140                 :            : #define decode_restorefh_maxsz  (op_decode_hdr_maxsz)
     141                 :            : #define encode_fsinfo_maxsz     (encode_getattr_maxsz)
     142                 :            : /* The 5 accounts for the PNFS attributes, and assumes that at most three
     143                 :            :  * layout types will be returned.
     144                 :            :  */
     145                 :            : #define decode_fsinfo_maxsz     (op_decode_hdr_maxsz + \
     146                 :            :                                  nfs4_fattr_bitmap_maxsz + 4 + 8 + 5)
     147                 :            : #define encode_renew_maxsz      (op_encode_hdr_maxsz + 3)
     148                 :            : #define decode_renew_maxsz      (op_decode_hdr_maxsz)
     149                 :            : #define encode_setclientid_maxsz \
     150                 :            :                                 (op_encode_hdr_maxsz + \
     151                 :            :                                 XDR_QUADLEN(NFS4_VERIFIER_SIZE) + \
     152                 :            :                                 /* client name */ \
     153                 :            :                                 1 + XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + \
     154                 :            :                                 1 /* sc_prog */ + \
     155                 :            :                                 1 + XDR_QUADLEN(RPCBIND_MAXNETIDLEN) + \
     156                 :            :                                 1 + XDR_QUADLEN(RPCBIND_MAXUADDRLEN) + \
     157                 :            :                                 1) /* sc_cb_ident */
     158                 :            : #define decode_setclientid_maxsz \
     159                 :            :                                 (op_decode_hdr_maxsz + \
     160                 :            :                                 2 /* clientid */ + \
     161                 :            :                                 XDR_QUADLEN(NFS4_VERIFIER_SIZE) + \
     162                 :            :                                 1 + XDR_QUADLEN(RPCBIND_MAXNETIDLEN) + \
     163                 :            :                                 1 + XDR_QUADLEN(RPCBIND_MAXUADDRLEN))
     164                 :            : #define encode_setclientid_confirm_maxsz \
     165                 :            :                                 (op_encode_hdr_maxsz + \
     166                 :            :                                 3 + (NFS4_VERIFIER_SIZE >> 2))
     167                 :            : #define decode_setclientid_confirm_maxsz \
     168                 :            :                                 (op_decode_hdr_maxsz)
     169                 :            : #define encode_lookup_maxsz     (op_encode_hdr_maxsz + nfs4_name_maxsz)
     170                 :            : #define decode_lookup_maxsz     (op_decode_hdr_maxsz)
     171                 :            : #define encode_lookupp_maxsz    (op_encode_hdr_maxsz)
     172                 :            : #define decode_lookupp_maxsz    (op_decode_hdr_maxsz)
     173                 :            : #define encode_share_access_maxsz \
     174                 :            :                                 (2)
     175                 :            : #define encode_createmode_maxsz (1 + encode_attrs_maxsz + encode_verifier_maxsz)
     176                 :            : #define encode_opentype_maxsz   (1 + encode_createmode_maxsz)
     177                 :            : #define encode_claim_null_maxsz (1 + nfs4_name_maxsz)
     178                 :            : #define encode_open_maxsz       (op_encode_hdr_maxsz + \
     179                 :            :                                 2 + encode_share_access_maxsz + 2 + \
     180                 :            :                                 open_owner_id_maxsz + \
     181                 :            :                                 encode_opentype_maxsz + \
     182                 :            :                                 encode_claim_null_maxsz)
     183                 :            : #define decode_space_limit_maxsz        (3)
     184                 :            : #define decode_ace_maxsz        (3 + nfs4_owner_maxsz)
     185                 :            : #define decode_delegation_maxsz (1 + decode_stateid_maxsz + 1 + \
     186                 :            :                                 decode_space_limit_maxsz + \
     187                 :            :                                 decode_ace_maxsz)
     188                 :            : #define decode_change_info_maxsz        (5)
     189                 :            : #define decode_open_maxsz       (op_decode_hdr_maxsz + \
     190                 :            :                                 decode_stateid_maxsz + \
     191                 :            :                                 decode_change_info_maxsz + 1 + \
     192                 :            :                                 nfs4_fattr_bitmap_maxsz + \
     193                 :            :                                 decode_delegation_maxsz)
     194                 :            : #define encode_open_confirm_maxsz \
     195                 :            :                                 (op_encode_hdr_maxsz + \
     196                 :            :                                  encode_stateid_maxsz + 1)
     197                 :            : #define decode_open_confirm_maxsz \
     198                 :            :                                 (op_decode_hdr_maxsz + \
     199                 :            :                                  decode_stateid_maxsz)
     200                 :            : #define encode_open_downgrade_maxsz \
     201                 :            :                                 (op_encode_hdr_maxsz + \
     202                 :            :                                  encode_stateid_maxsz + 1 + \
     203                 :            :                                  encode_share_access_maxsz)
     204                 :            : #define decode_open_downgrade_maxsz \
     205                 :            :                                 (op_decode_hdr_maxsz + \
     206                 :            :                                  decode_stateid_maxsz)
     207                 :            : #define encode_close_maxsz      (op_encode_hdr_maxsz + \
     208                 :            :                                  1 + encode_stateid_maxsz)
     209                 :            : #define decode_close_maxsz      (op_decode_hdr_maxsz + \
     210                 :            :                                  decode_stateid_maxsz)
     211                 :            : #define encode_setattr_maxsz    (op_encode_hdr_maxsz + \
     212                 :            :                                  encode_stateid_maxsz + \
     213                 :            :                                  encode_attrs_maxsz)
     214                 :            : #define decode_setattr_maxsz    (op_decode_hdr_maxsz + \
     215                 :            :                                  nfs4_fattr_bitmap_maxsz)
     216                 :            : #define encode_read_maxsz       (op_encode_hdr_maxsz + \
     217                 :            :                                  encode_stateid_maxsz + 3)
     218                 :            : #define decode_read_maxsz       (op_decode_hdr_maxsz + 2 + 1)
     219                 :            : #define encode_readdir_maxsz    (op_encode_hdr_maxsz + \
     220                 :            :                                  2 + encode_verifier_maxsz + 5 + \
     221                 :            :                                 nfs4_label_maxsz)
     222                 :            : #define decode_readdir_maxsz    (op_decode_hdr_maxsz + \
     223                 :            :                                  decode_verifier_maxsz + 1)
     224                 :            : #define encode_readlink_maxsz   (op_encode_hdr_maxsz)
     225                 :            : #define decode_readlink_maxsz   (op_decode_hdr_maxsz + 1 + 1)
     226                 :            : #define encode_write_maxsz      (op_encode_hdr_maxsz + \
     227                 :            :                                  encode_stateid_maxsz + 4)
     228                 :            : #define decode_write_maxsz      (op_decode_hdr_maxsz + \
     229                 :            :                                  2 + decode_verifier_maxsz)
     230                 :            : #define encode_commit_maxsz     (op_encode_hdr_maxsz + 3)
     231                 :            : #define decode_commit_maxsz     (op_decode_hdr_maxsz + \
     232                 :            :                                  decode_verifier_maxsz)
     233                 :            : #define encode_remove_maxsz     (op_encode_hdr_maxsz + \
     234                 :            :                                 nfs4_name_maxsz)
     235                 :            : #define decode_remove_maxsz     (op_decode_hdr_maxsz + \
     236                 :            :                                  decode_change_info_maxsz)
     237                 :            : #define encode_rename_maxsz     (op_encode_hdr_maxsz + \
     238                 :            :                                 2 * nfs4_name_maxsz)
     239                 :            : #define decode_rename_maxsz     (op_decode_hdr_maxsz + \
     240                 :            :                                  decode_change_info_maxsz + \
     241                 :            :                                  decode_change_info_maxsz)
     242                 :            : #define encode_link_maxsz       (op_encode_hdr_maxsz + \
     243                 :            :                                 nfs4_name_maxsz)
     244                 :            : #define decode_link_maxsz       (op_decode_hdr_maxsz + decode_change_info_maxsz)
     245                 :            : #define encode_lockowner_maxsz  (7)
     246                 :            : #define encode_lock_maxsz       (op_encode_hdr_maxsz + \
     247                 :            :                                  7 + \
     248                 :            :                                  1 + encode_stateid_maxsz + 1 + \
     249                 :            :                                  encode_lockowner_maxsz)
     250                 :            : #define decode_lock_denied_maxsz \
     251                 :            :                                 (8 + decode_lockowner_maxsz)
     252                 :            : #define decode_lock_maxsz       (op_decode_hdr_maxsz + \
     253                 :            :                                  decode_lock_denied_maxsz)
     254                 :            : #define encode_lockt_maxsz      (op_encode_hdr_maxsz + 5 + \
     255                 :            :                                 encode_lockowner_maxsz)
     256                 :            : #define decode_lockt_maxsz      (op_decode_hdr_maxsz + \
     257                 :            :                                  decode_lock_denied_maxsz)
     258                 :            : #define encode_locku_maxsz      (op_encode_hdr_maxsz + 3 + \
     259                 :            :                                  encode_stateid_maxsz + \
     260                 :            :                                  4)
     261                 :            : #define decode_locku_maxsz      (op_decode_hdr_maxsz + \
     262                 :            :                                  decode_stateid_maxsz)
     263                 :            : #define encode_release_lockowner_maxsz \
     264                 :            :                                 (op_encode_hdr_maxsz + \
     265                 :            :                                  encode_lockowner_maxsz)
     266                 :            : #define decode_release_lockowner_maxsz \
     267                 :            :                                 (op_decode_hdr_maxsz)
     268                 :            : #define encode_access_maxsz     (op_encode_hdr_maxsz + 1)
     269                 :            : #define decode_access_maxsz     (op_decode_hdr_maxsz + 2)
     270                 :            : #define encode_symlink_maxsz    (op_encode_hdr_maxsz + \
     271                 :            :                                 1 + nfs4_name_maxsz + \
     272                 :            :                                 1 + \
     273                 :            :                                 nfs4_fattr_maxsz)
     274                 :            : #define decode_symlink_maxsz    (op_decode_hdr_maxsz + 8)
     275                 :            : #define encode_create_maxsz     (op_encode_hdr_maxsz + \
     276                 :            :                                 1 + 2 + nfs4_name_maxsz + \
     277                 :            :                                 encode_attrs_maxsz)
     278                 :            : #define decode_create_maxsz     (op_decode_hdr_maxsz + \
     279                 :            :                                 decode_change_info_maxsz + \
     280                 :            :                                 nfs4_fattr_bitmap_maxsz)
     281                 :            : #define encode_statfs_maxsz     (encode_getattr_maxsz)
     282                 :            : #define decode_statfs_maxsz     (decode_getattr_maxsz)
     283                 :            : #define encode_delegreturn_maxsz (op_encode_hdr_maxsz + 4)
     284                 :            : #define decode_delegreturn_maxsz (op_decode_hdr_maxsz)
     285                 :            : #define encode_getacl_maxsz     (encode_getattr_maxsz)
     286                 :            : #define decode_getacl_maxsz     (op_decode_hdr_maxsz + \
     287                 :            :                                  nfs4_fattr_bitmap_maxsz + 1 + 1)
     288                 :            : #define encode_setacl_maxsz     (op_encode_hdr_maxsz + \
     289                 :            :                                  encode_stateid_maxsz + 3)
     290                 :            : #define decode_setacl_maxsz     (decode_setattr_maxsz)
     291                 :            : #define encode_fs_locations_maxsz \
     292                 :            :                                 (encode_getattr_maxsz)
     293                 :            : #define decode_fs_locations_maxsz \
     294                 :            :                                 (1)
     295                 :            : #define encode_secinfo_maxsz    (op_encode_hdr_maxsz + nfs4_name_maxsz)
     296                 :            : #define decode_secinfo_maxsz    (op_decode_hdr_maxsz + 1 + ((NFS_MAX_SECFLAVORS * (16 + GSS_OID_MAX_LEN)) / 4))
     297                 :            : 
     298                 :            : #if defined(CONFIG_NFS_V4_1)
     299                 :            : #define NFS4_MAX_MACHINE_NAME_LEN (64)
     300                 :            : #define IMPL_NAME_LIMIT (sizeof(utsname()->sysname) + sizeof(utsname()->release) + \
     301                 :            :                          sizeof(utsname()->version) + sizeof(utsname()->machine) + 8)
     302                 :            : 
     303                 :            : #define encode_exchange_id_maxsz (op_encode_hdr_maxsz + \
     304                 :            :                                 encode_verifier_maxsz + \
     305                 :            :                                 1 /* co_ownerid.len */ + \
     306                 :            :                                 /* eia_clientowner */ \
     307                 :            :                                 1 + XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + \
     308                 :            :                                 1 /* flags */ + \
     309                 :            :                                 1 /* spa_how */ + \
     310                 :            :                                 /* max is SP4_MACH_CRED (for now) */ + \
     311                 :            :                                 1 + NFS4_OP_MAP_NUM_WORDS + \
     312                 :            :                                 1 + NFS4_OP_MAP_NUM_WORDS + \
     313                 :            :                                 1 /* implementation id array of size 1 */ + \
     314                 :            :                                 1 /* nii_domain */ + \
     315                 :            :                                 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + \
     316                 :            :                                 1 /* nii_name */ + \
     317                 :            :                                 XDR_QUADLEN(IMPL_NAME_LIMIT) + \
     318                 :            :                                 3 /* nii_date */)
     319                 :            : #define decode_exchange_id_maxsz (op_decode_hdr_maxsz + \
     320                 :            :                                 2 /* eir_clientid */ + \
     321                 :            :                                 1 /* eir_sequenceid */ + \
     322                 :            :                                 1 /* eir_flags */ + \
     323                 :            :                                 1 /* spr_how */ + \
     324                 :            :                                   /* max is SP4_MACH_CRED (for now) */ + \
     325                 :            :                                 1 + NFS4_OP_MAP_NUM_WORDS + \
     326                 :            :                                 1 + NFS4_OP_MAP_NUM_WORDS + \
     327                 :            :                                 2 /* eir_server_owner.so_minor_id */ + \
     328                 :            :                                 /* eir_server_owner.so_major_id<> */ \
     329                 :            :                                 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 + \
     330                 :            :                                 /* eir_server_scope<> */ \
     331                 :            :                                 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 + \
     332                 :            :                                 1 /* eir_server_impl_id array length */ + \
     333                 :            :                                 1 /* nii_domain */ + \
     334                 :            :                                 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + \
     335                 :            :                                 1 /* nii_name */ + \
     336                 :            :                                 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + \
     337                 :            :                                 3 /* nii_date */)
     338                 :            : #define encode_channel_attrs_maxsz  (6 + 1 /* ca_rdma_ird.len (0) */)
     339                 :            : #define decode_channel_attrs_maxsz  (6 + \
     340                 :            :                                      1 /* ca_rdma_ird.len */ + \
     341                 :            :                                      1 /* ca_rdma_ird */)
     342                 :            : #define encode_create_session_maxsz  (op_encode_hdr_maxsz + \
     343                 :            :                                      2 /* csa_clientid */ + \
     344                 :            :                                      1 /* csa_sequence */ + \
     345                 :            :                                      1 /* csa_flags */ + \
     346                 :            :                                      encode_channel_attrs_maxsz + \
     347                 :            :                                      encode_channel_attrs_maxsz + \
     348                 :            :                                      1 /* csa_cb_program */ + \
     349                 :            :                                      1 /* csa_sec_parms.len (1) */ + \
     350                 :            :                                      1 /* cb_secflavor (AUTH_SYS) */ + \
     351                 :            :                                      1 /* stamp */ + \
     352                 :            :                                      1 /* machinename.len */ + \
     353                 :            :                                      XDR_QUADLEN(NFS4_MAX_MACHINE_NAME_LEN) + \
     354                 :            :                                      1 /* uid */ + \
     355                 :            :                                      1 /* gid */ + \
     356                 :            :                                      1 /* gids.len (0) */)
     357                 :            : #define decode_create_session_maxsz  (op_decode_hdr_maxsz +     \
     358                 :            :                                      XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
     359                 :            :                                      1 /* csr_sequence */ + \
     360                 :            :                                      1 /* csr_flags */ + \
     361                 :            :                                      decode_channel_attrs_maxsz + \
     362                 :            :                                      decode_channel_attrs_maxsz)
     363                 :            : #define encode_bind_conn_to_session_maxsz  (op_encode_hdr_maxsz + \
     364                 :            :                                      /* bctsa_sessid */ \
     365                 :            :                                      XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
     366                 :            :                                      1 /* bctsa_dir */ + \
     367                 :            :                                      1 /* bctsa_use_conn_in_rdma_mode */)
     368                 :            : #define decode_bind_conn_to_session_maxsz  (op_decode_hdr_maxsz +       \
     369                 :            :                                      /* bctsr_sessid */ \
     370                 :            :                                      XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
     371                 :            :                                      1 /* bctsr_dir */ + \
     372                 :            :                                      1 /* bctsr_use_conn_in_rdma_mode */)
     373                 :            : #define encode_destroy_session_maxsz    (op_encode_hdr_maxsz + 4)
     374                 :            : #define decode_destroy_session_maxsz    (op_decode_hdr_maxsz)
     375                 :            : #define encode_destroy_clientid_maxsz   (op_encode_hdr_maxsz + 2)
     376                 :            : #define decode_destroy_clientid_maxsz   (op_decode_hdr_maxsz)
     377                 :            : #define encode_sequence_maxsz   (op_encode_hdr_maxsz + \
     378                 :            :                                 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + 4)
     379                 :            : #define decode_sequence_maxsz   (op_decode_hdr_maxsz + \
     380                 :            :                                 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + 5)
     381                 :            : #define encode_reclaim_complete_maxsz   (op_encode_hdr_maxsz + 4)
     382                 :            : #define decode_reclaim_complete_maxsz   (op_decode_hdr_maxsz + 4)
     383                 :            : #define encode_getdeviceinfo_maxsz (op_encode_hdr_maxsz + \
     384                 :            :                                 XDR_QUADLEN(NFS4_DEVICEID4_SIZE) + \
     385                 :            :                                 1 /* layout type */ + \
     386                 :            :                                 1 /* maxcount */ + \
     387                 :            :                                 1 /* bitmap size */ + \
     388                 :            :                                 1 /* notification bitmap length */ + \
     389                 :            :                                 1 /* notification bitmap, word 0 */)
     390                 :            : #define decode_getdeviceinfo_maxsz (op_decode_hdr_maxsz + \
     391                 :            :                                 1 /* layout type */ + \
     392                 :            :                                 1 /* opaque devaddr4 length */ + \
     393                 :            :                                   /* devaddr4 payload is read into page */ \
     394                 :            :                                 1 /* notification bitmap length */ + \
     395                 :            :                                 1 /* notification bitmap, word 0 */ + \
     396                 :            :                                 1 /* possible XDR padding */)
     397                 :            : #define encode_layoutget_maxsz  (op_encode_hdr_maxsz + 10 + \
     398                 :            :                                 encode_stateid_maxsz)
     399                 :            : #define decode_layoutget_maxsz  (op_decode_hdr_maxsz + 8 + \
     400                 :            :                                 decode_stateid_maxsz + \
     401                 :            :                                 XDR_QUADLEN(PNFS_LAYOUT_MAXSIZE) + 1)
     402                 :            : #define encode_layoutcommit_maxsz (op_encode_hdr_maxsz +          \
     403                 :            :                                 2 /* offset */ + \
     404                 :            :                                 2 /* length */ + \
     405                 :            :                                 1 /* reclaim */ + \
     406                 :            :                                 encode_stateid_maxsz + \
     407                 :            :                                 1 /* new offset (true) */ + \
     408                 :            :                                 2 /* last byte written */ + \
     409                 :            :                                 1 /* nt_timechanged (false) */ + \
     410                 :            :                                 1 /* layoutupdate4 layout type */ + \
     411                 :            :                                 1 /* layoutupdate4 opaqueue len */)
     412                 :            :                                   /* the actual content of layoutupdate4 should
     413                 :            :                                      be allocated by drivers and spliced in
     414                 :            :                                      using xdr_write_pages */
     415                 :            : #define decode_layoutcommit_maxsz (op_decode_hdr_maxsz + 3)
     416                 :            : #define encode_layoutreturn_maxsz (8 + op_encode_hdr_maxsz + \
     417                 :            :                                 encode_stateid_maxsz + \
     418                 :            :                                 1 + \
     419                 :            :                                 XDR_QUADLEN(NFS4_OPAQUE_LIMIT))
     420                 :            : #define decode_layoutreturn_maxsz (op_decode_hdr_maxsz + \
     421                 :            :                                 1 + decode_stateid_maxsz)
     422                 :            : #define encode_secinfo_no_name_maxsz (op_encode_hdr_maxsz + 1)
     423                 :            : #define decode_secinfo_no_name_maxsz decode_secinfo_maxsz
     424                 :            : #define encode_test_stateid_maxsz       (op_encode_hdr_maxsz + 2 + \
     425                 :            :                                          XDR_QUADLEN(NFS4_STATEID_SIZE))
     426                 :            : #define decode_test_stateid_maxsz       (op_decode_hdr_maxsz + 2 + 1)
     427                 :            : #define encode_free_stateid_maxsz       (op_encode_hdr_maxsz + 1 + \
     428                 :            :                                          XDR_QUADLEN(NFS4_STATEID_SIZE))
     429                 :            : #define decode_free_stateid_maxsz       (op_decode_hdr_maxsz)
     430                 :            : #else /* CONFIG_NFS_V4_1 */
     431                 :            : #define encode_sequence_maxsz   0
     432                 :            : #define decode_sequence_maxsz   0
     433                 :            : #define encode_layoutreturn_maxsz 0
     434                 :            : #define decode_layoutreturn_maxsz 0
     435                 :            : #define encode_layoutget_maxsz  0
     436                 :            : #define decode_layoutget_maxsz  0
     437                 :            : #endif /* CONFIG_NFS_V4_1 */
     438                 :            : 
     439                 :            : #define NFS4_enc_compound_sz    (1024)  /* XXX: large enough? */
     440                 :            : #define NFS4_dec_compound_sz    (1024)  /* XXX: large enough? */
     441                 :            : #define NFS4_enc_read_sz        (compound_encode_hdr_maxsz + \
     442                 :            :                                 encode_sequence_maxsz + \
     443                 :            :                                 encode_putfh_maxsz + \
     444                 :            :                                 encode_read_maxsz)
     445                 :            : #define NFS4_dec_read_sz        (compound_decode_hdr_maxsz + \
     446                 :            :                                 decode_sequence_maxsz + \
     447                 :            :                                 decode_putfh_maxsz + \
     448                 :            :                                 decode_read_maxsz)
     449                 :            : #define NFS4_enc_readlink_sz    (compound_encode_hdr_maxsz + \
     450                 :            :                                 encode_sequence_maxsz + \
     451                 :            :                                 encode_putfh_maxsz + \
     452                 :            :                                 encode_readlink_maxsz)
     453                 :            : #define NFS4_dec_readlink_sz    (compound_decode_hdr_maxsz + \
     454                 :            :                                 decode_sequence_maxsz + \
     455                 :            :                                 decode_putfh_maxsz + \
     456                 :            :                                 decode_readlink_maxsz)
     457                 :            : #define NFS4_enc_readdir_sz     (compound_encode_hdr_maxsz + \
     458                 :            :                                 encode_sequence_maxsz + \
     459                 :            :                                 encode_putfh_maxsz + \
     460                 :            :                                 encode_readdir_maxsz)
     461                 :            : #define NFS4_dec_readdir_sz     (compound_decode_hdr_maxsz + \
     462                 :            :                                 decode_sequence_maxsz + \
     463                 :            :                                 decode_putfh_maxsz + \
     464                 :            :                                 decode_readdir_maxsz)
     465                 :            : #define NFS4_enc_write_sz       (compound_encode_hdr_maxsz + \
     466                 :            :                                 encode_sequence_maxsz + \
     467                 :            :                                 encode_putfh_maxsz + \
     468                 :            :                                 encode_write_maxsz + \
     469                 :            :                                 encode_getattr_maxsz)
     470                 :            : #define NFS4_dec_write_sz       (compound_decode_hdr_maxsz + \
     471                 :            :                                 decode_sequence_maxsz + \
     472                 :            :                                 decode_putfh_maxsz + \
     473                 :            :                                 decode_write_maxsz + \
     474                 :            :                                 decode_getattr_maxsz)
     475                 :            : #define NFS4_enc_commit_sz      (compound_encode_hdr_maxsz + \
     476                 :            :                                 encode_sequence_maxsz + \
     477                 :            :                                 encode_putfh_maxsz + \
     478                 :            :                                 encode_commit_maxsz)
     479                 :            : #define NFS4_dec_commit_sz      (compound_decode_hdr_maxsz + \
     480                 :            :                                 decode_sequence_maxsz + \
     481                 :            :                                 decode_putfh_maxsz + \
     482                 :            :                                 decode_commit_maxsz)
     483                 :            : #define NFS4_enc_open_sz        (compound_encode_hdr_maxsz + \
     484                 :            :                                 encode_sequence_maxsz + \
     485                 :            :                                 encode_putfh_maxsz + \
     486                 :            :                                 encode_open_maxsz + \
     487                 :            :                                 encode_access_maxsz + \
     488                 :            :                                 encode_getfh_maxsz + \
     489                 :            :                                 encode_getattr_maxsz + \
     490                 :            :                                 encode_layoutget_maxsz)
     491                 :            : #define NFS4_dec_open_sz        (compound_decode_hdr_maxsz + \
     492                 :            :                                 decode_sequence_maxsz + \
     493                 :            :                                 decode_putfh_maxsz + \
     494                 :            :                                 decode_open_maxsz + \
     495                 :            :                                 decode_access_maxsz + \
     496                 :            :                                 decode_getfh_maxsz + \
     497                 :            :                                 decode_getattr_maxsz + \
     498                 :            :                                 decode_layoutget_maxsz)
     499                 :            : #define NFS4_enc_open_confirm_sz \
     500                 :            :                                 (compound_encode_hdr_maxsz + \
     501                 :            :                                  encode_putfh_maxsz + \
     502                 :            :                                  encode_open_confirm_maxsz)
     503                 :            : #define NFS4_dec_open_confirm_sz \
     504                 :            :                                 (compound_decode_hdr_maxsz + \
     505                 :            :                                  decode_putfh_maxsz + \
     506                 :            :                                  decode_open_confirm_maxsz)
     507                 :            : #define NFS4_enc_open_noattr_sz (compound_encode_hdr_maxsz + \
     508                 :            :                                         encode_sequence_maxsz + \
     509                 :            :                                         encode_putfh_maxsz + \
     510                 :            :                                         encode_open_maxsz + \
     511                 :            :                                         encode_access_maxsz + \
     512                 :            :                                         encode_getattr_maxsz + \
     513                 :            :                                         encode_layoutget_maxsz)
     514                 :            : #define NFS4_dec_open_noattr_sz (compound_decode_hdr_maxsz + \
     515                 :            :                                         decode_sequence_maxsz + \
     516                 :            :                                         decode_putfh_maxsz + \
     517                 :            :                                         decode_open_maxsz + \
     518                 :            :                                         decode_access_maxsz + \
     519                 :            :                                         decode_getattr_maxsz + \
     520                 :            :                                         decode_layoutget_maxsz)
     521                 :            : #define NFS4_enc_open_downgrade_sz \
     522                 :            :                                 (compound_encode_hdr_maxsz + \
     523                 :            :                                  encode_sequence_maxsz + \
     524                 :            :                                  encode_putfh_maxsz + \
     525                 :            :                                  encode_layoutreturn_maxsz + \
     526                 :            :                                  encode_open_downgrade_maxsz)
     527                 :            : #define NFS4_dec_open_downgrade_sz \
     528                 :            :                                 (compound_decode_hdr_maxsz + \
     529                 :            :                                  decode_sequence_maxsz + \
     530                 :            :                                  decode_putfh_maxsz + \
     531                 :            :                                  decode_layoutreturn_maxsz + \
     532                 :            :                                  decode_open_downgrade_maxsz)
     533                 :            : #define NFS4_enc_close_sz       (compound_encode_hdr_maxsz + \
     534                 :            :                                  encode_sequence_maxsz + \
     535                 :            :                                  encode_putfh_maxsz + \
     536                 :            :                                  encode_layoutreturn_maxsz + \
     537                 :            :                                  encode_close_maxsz + \
     538                 :            :                                  encode_getattr_maxsz)
     539                 :            : #define NFS4_dec_close_sz       (compound_decode_hdr_maxsz + \
     540                 :            :                                  decode_sequence_maxsz + \
     541                 :            :                                  decode_putfh_maxsz + \
     542                 :            :                                  decode_layoutreturn_maxsz + \
     543                 :            :                                  decode_close_maxsz + \
     544                 :            :                                  decode_getattr_maxsz)
     545                 :            : #define NFS4_enc_setattr_sz     (compound_encode_hdr_maxsz + \
     546                 :            :                                  encode_sequence_maxsz + \
     547                 :            :                                  encode_putfh_maxsz + \
     548                 :            :                                  encode_setattr_maxsz + \
     549                 :            :                                  encode_getattr_maxsz)
     550                 :            : #define NFS4_dec_setattr_sz     (compound_decode_hdr_maxsz + \
     551                 :            :                                  decode_sequence_maxsz + \
     552                 :            :                                  decode_putfh_maxsz + \
     553                 :            :                                  decode_setattr_maxsz + \
     554                 :            :                                  decode_getattr_maxsz)
     555                 :            : #define NFS4_enc_fsinfo_sz      (compound_encode_hdr_maxsz + \
     556                 :            :                                 encode_sequence_maxsz + \
     557                 :            :                                 encode_putfh_maxsz + \
     558                 :            :                                 encode_fsinfo_maxsz)
     559                 :            : #define NFS4_dec_fsinfo_sz      (compound_decode_hdr_maxsz + \
     560                 :            :                                 decode_sequence_maxsz + \
     561                 :            :                                 decode_putfh_maxsz + \
     562                 :            :                                 decode_fsinfo_maxsz)
     563                 :            : #define NFS4_enc_renew_sz       (compound_encode_hdr_maxsz + \
     564                 :            :                                 encode_renew_maxsz)
     565                 :            : #define NFS4_dec_renew_sz       (compound_decode_hdr_maxsz + \
     566                 :            :                                 decode_renew_maxsz)
     567                 :            : #define NFS4_enc_setclientid_sz (compound_encode_hdr_maxsz + \
     568                 :            :                                 encode_setclientid_maxsz)
     569                 :            : #define NFS4_dec_setclientid_sz (compound_decode_hdr_maxsz + \
     570                 :            :                                 decode_setclientid_maxsz)
     571                 :            : #define NFS4_enc_setclientid_confirm_sz \
     572                 :            :                                 (compound_encode_hdr_maxsz + \
     573                 :            :                                 encode_setclientid_confirm_maxsz)
     574                 :            : #define NFS4_dec_setclientid_confirm_sz \
     575                 :            :                                 (compound_decode_hdr_maxsz + \
     576                 :            :                                 decode_setclientid_confirm_maxsz)
     577                 :            : #define NFS4_enc_lock_sz        (compound_encode_hdr_maxsz + \
     578                 :            :                                 encode_sequence_maxsz + \
     579                 :            :                                 encode_putfh_maxsz + \
     580                 :            :                                 encode_lock_maxsz)
     581                 :            : #define NFS4_dec_lock_sz        (compound_decode_hdr_maxsz + \
     582                 :            :                                 decode_sequence_maxsz + \
     583                 :            :                                 decode_putfh_maxsz + \
     584                 :            :                                 decode_lock_maxsz)
     585                 :            : #define NFS4_enc_lockt_sz       (compound_encode_hdr_maxsz + \
     586                 :            :                                 encode_sequence_maxsz + \
     587                 :            :                                 encode_putfh_maxsz + \
     588                 :            :                                 encode_lockt_maxsz)
     589                 :            : #define NFS4_dec_lockt_sz       (compound_decode_hdr_maxsz + \
     590                 :            :                                  decode_sequence_maxsz + \
     591                 :            :                                  decode_putfh_maxsz + \
     592                 :            :                                  decode_lockt_maxsz)
     593                 :            : #define NFS4_enc_locku_sz       (compound_encode_hdr_maxsz + \
     594                 :            :                                 encode_sequence_maxsz + \
     595                 :            :                                 encode_putfh_maxsz + \
     596                 :            :                                 encode_locku_maxsz)
     597                 :            : #define NFS4_dec_locku_sz       (compound_decode_hdr_maxsz + \
     598                 :            :                                 decode_sequence_maxsz + \
     599                 :            :                                 decode_putfh_maxsz + \
     600                 :            :                                 decode_locku_maxsz)
     601                 :            : #define NFS4_enc_release_lockowner_sz \
     602                 :            :                                 (compound_encode_hdr_maxsz + \
     603                 :            :                                  encode_lockowner_maxsz)
     604                 :            : #define NFS4_dec_release_lockowner_sz \
     605                 :            :                                 (compound_decode_hdr_maxsz + \
     606                 :            :                                  decode_lockowner_maxsz)
     607                 :            : #define NFS4_enc_access_sz      (compound_encode_hdr_maxsz + \
     608                 :            :                                 encode_sequence_maxsz + \
     609                 :            :                                 encode_putfh_maxsz + \
     610                 :            :                                 encode_access_maxsz + \
     611                 :            :                                 encode_getattr_maxsz)
     612                 :            : #define NFS4_dec_access_sz      (compound_decode_hdr_maxsz + \
     613                 :            :                                 decode_sequence_maxsz + \
     614                 :            :                                 decode_putfh_maxsz + \
     615                 :            :                                 decode_access_maxsz + \
     616                 :            :                                 decode_getattr_maxsz)
     617                 :            : #define NFS4_enc_getattr_sz     (compound_encode_hdr_maxsz + \
     618                 :            :                                 encode_sequence_maxsz + \
     619                 :            :                                 encode_putfh_maxsz + \
     620                 :            :                                 encode_getattr_maxsz + \
     621                 :            :                                 encode_renew_maxsz)
     622                 :            : #define NFS4_dec_getattr_sz     (compound_decode_hdr_maxsz + \
     623                 :            :                                 decode_sequence_maxsz + \
     624                 :            :                                 decode_putfh_maxsz + \
     625                 :            :                                 decode_getattr_maxsz + \
     626                 :            :                                 decode_renew_maxsz)
     627                 :            : #define NFS4_enc_lookup_sz      (compound_encode_hdr_maxsz + \
     628                 :            :                                 encode_sequence_maxsz + \
     629                 :            :                                 encode_putfh_maxsz + \
     630                 :            :                                 encode_lookup_maxsz + \
     631                 :            :                                 encode_getattr_maxsz + \
     632                 :            :                                 encode_getfh_maxsz)
     633                 :            : #define NFS4_dec_lookup_sz      (compound_decode_hdr_maxsz + \
     634                 :            :                                 decode_sequence_maxsz + \
     635                 :            :                                 decode_putfh_maxsz + \
     636                 :            :                                 decode_lookup_maxsz + \
     637                 :            :                                 decode_getattr_maxsz + \
     638                 :            :                                 decode_getfh_maxsz)
     639                 :            : #define NFS4_enc_lookupp_sz     (compound_encode_hdr_maxsz + \
     640                 :            :                                 encode_sequence_maxsz + \
     641                 :            :                                 encode_putfh_maxsz + \
     642                 :            :                                 encode_lookupp_maxsz + \
     643                 :            :                                 encode_getattr_maxsz + \
     644                 :            :                                 encode_getfh_maxsz)
     645                 :            : #define NFS4_dec_lookupp_sz     (compound_decode_hdr_maxsz + \
     646                 :            :                                 decode_sequence_maxsz + \
     647                 :            :                                 decode_putfh_maxsz + \
     648                 :            :                                 decode_lookupp_maxsz + \
     649                 :            :                                 decode_getattr_maxsz + \
     650                 :            :                                 decode_getfh_maxsz)
     651                 :            : #define NFS4_enc_lookup_root_sz (compound_encode_hdr_maxsz + \
     652                 :            :                                 encode_sequence_maxsz + \
     653                 :            :                                 encode_putrootfh_maxsz + \
     654                 :            :                                 encode_getattr_maxsz + \
     655                 :            :                                 encode_getfh_maxsz)
     656                 :            : #define NFS4_dec_lookup_root_sz (compound_decode_hdr_maxsz + \
     657                 :            :                                 decode_sequence_maxsz + \
     658                 :            :                                 decode_putrootfh_maxsz + \
     659                 :            :                                 decode_getattr_maxsz + \
     660                 :            :                                 decode_getfh_maxsz)
     661                 :            : #define NFS4_enc_remove_sz      (compound_encode_hdr_maxsz + \
     662                 :            :                                 encode_sequence_maxsz + \
     663                 :            :                                 encode_putfh_maxsz + \
     664                 :            :                                 encode_remove_maxsz)
     665                 :            : #define NFS4_dec_remove_sz      (compound_decode_hdr_maxsz + \
     666                 :            :                                 decode_sequence_maxsz + \
     667                 :            :                                 decode_putfh_maxsz + \
     668                 :            :                                 decode_remove_maxsz)
     669                 :            : #define NFS4_enc_rename_sz      (compound_encode_hdr_maxsz + \
     670                 :            :                                 encode_sequence_maxsz + \
     671                 :            :                                 encode_putfh_maxsz + \
     672                 :            :                                 encode_savefh_maxsz + \
     673                 :            :                                 encode_putfh_maxsz + \
     674                 :            :                                 encode_rename_maxsz)
     675                 :            : #define NFS4_dec_rename_sz      (compound_decode_hdr_maxsz + \
     676                 :            :                                 decode_sequence_maxsz + \
     677                 :            :                                 decode_putfh_maxsz + \
     678                 :            :                                 decode_savefh_maxsz + \
     679                 :            :                                 decode_putfh_maxsz + \
     680                 :            :                                 decode_rename_maxsz)
     681                 :            : #define NFS4_enc_link_sz        (compound_encode_hdr_maxsz + \
     682                 :            :                                 encode_sequence_maxsz + \
     683                 :            :                                 encode_putfh_maxsz + \
     684                 :            :                                 encode_savefh_maxsz + \
     685                 :            :                                 encode_putfh_maxsz + \
     686                 :            :                                 encode_link_maxsz + \
     687                 :            :                                 encode_restorefh_maxsz + \
     688                 :            :                                 encode_getattr_maxsz)
     689                 :            : #define NFS4_dec_link_sz        (compound_decode_hdr_maxsz + \
     690                 :            :                                 decode_sequence_maxsz + \
     691                 :            :                                 decode_putfh_maxsz + \
     692                 :            :                                 decode_savefh_maxsz + \
     693                 :            :                                 decode_putfh_maxsz + \
     694                 :            :                                 decode_link_maxsz + \
     695                 :            :                                 decode_restorefh_maxsz + \
     696                 :            :                                 decode_getattr_maxsz)
     697                 :            : #define NFS4_enc_symlink_sz     (compound_encode_hdr_maxsz + \
     698                 :            :                                 encode_sequence_maxsz + \
     699                 :            :                                 encode_putfh_maxsz + \
     700                 :            :                                 encode_symlink_maxsz + \
     701                 :            :                                 encode_getattr_maxsz + \
     702                 :            :                                 encode_getfh_maxsz)
     703                 :            : #define NFS4_dec_symlink_sz     (compound_decode_hdr_maxsz + \
     704                 :            :                                 decode_sequence_maxsz + \
     705                 :            :                                 decode_putfh_maxsz + \
     706                 :            :                                 decode_symlink_maxsz + \
     707                 :            :                                 decode_getattr_maxsz + \
     708                 :            :                                 decode_getfh_maxsz)
     709                 :            : #define NFS4_enc_create_sz      (compound_encode_hdr_maxsz + \
     710                 :            :                                 encode_sequence_maxsz + \
     711                 :            :                                 encode_putfh_maxsz + \
     712                 :            :                                 encode_create_maxsz + \
     713                 :            :                                 encode_getfh_maxsz + \
     714                 :            :                                 encode_getattr_maxsz)
     715                 :            : #define NFS4_dec_create_sz      (compound_decode_hdr_maxsz + \
     716                 :            :                                 decode_sequence_maxsz + \
     717                 :            :                                 decode_putfh_maxsz + \
     718                 :            :                                 decode_create_maxsz + \
     719                 :            :                                 decode_getfh_maxsz + \
     720                 :            :                                 decode_getattr_maxsz)
     721                 :            : #define NFS4_enc_pathconf_sz    (compound_encode_hdr_maxsz + \
     722                 :            :                                 encode_sequence_maxsz + \
     723                 :            :                                 encode_putfh_maxsz + \
     724                 :            :                                 encode_getattr_maxsz)
     725                 :            : #define NFS4_dec_pathconf_sz    (compound_decode_hdr_maxsz + \
     726                 :            :                                 decode_sequence_maxsz + \
     727                 :            :                                 decode_putfh_maxsz + \
     728                 :            :                                 decode_getattr_maxsz)
     729                 :            : #define NFS4_enc_statfs_sz      (compound_encode_hdr_maxsz + \
     730                 :            :                                 encode_sequence_maxsz + \
     731                 :            :                                 encode_putfh_maxsz + \
     732                 :            :                                 encode_statfs_maxsz)
     733                 :            : #define NFS4_dec_statfs_sz      (compound_decode_hdr_maxsz + \
     734                 :            :                                 decode_sequence_maxsz + \
     735                 :            :                                 decode_putfh_maxsz + \
     736                 :            :                                 decode_statfs_maxsz)
     737                 :            : #define NFS4_enc_server_caps_sz (compound_encode_hdr_maxsz + \
     738                 :            :                                 encode_sequence_maxsz + \
     739                 :            :                                 encode_putfh_maxsz + \
     740                 :            :                                 encode_getattr_maxsz)
     741                 :            : #define NFS4_dec_server_caps_sz (compound_decode_hdr_maxsz + \
     742                 :            :                                 decode_sequence_maxsz + \
     743                 :            :                                 decode_putfh_maxsz + \
     744                 :            :                                 decode_getattr_maxsz)
     745                 :            : #define NFS4_enc_delegreturn_sz (compound_encode_hdr_maxsz + \
     746                 :            :                                 encode_sequence_maxsz + \
     747                 :            :                                 encode_putfh_maxsz + \
     748                 :            :                                 encode_layoutreturn_maxsz + \
     749                 :            :                                 encode_delegreturn_maxsz + \
     750                 :            :                                 encode_getattr_maxsz)
     751                 :            : #define NFS4_dec_delegreturn_sz (compound_decode_hdr_maxsz + \
     752                 :            :                                 decode_sequence_maxsz + \
     753                 :            :                                 decode_putfh_maxsz + \
     754                 :            :                                 decode_layoutreturn_maxsz + \
     755                 :            :                                 decode_delegreturn_maxsz + \
     756                 :            :                                 decode_getattr_maxsz)
     757                 :            : #define NFS4_enc_getacl_sz      (compound_encode_hdr_maxsz + \
     758                 :            :                                 encode_sequence_maxsz + \
     759                 :            :                                 encode_putfh_maxsz + \
     760                 :            :                                 encode_getacl_maxsz)
     761                 :            : #define NFS4_dec_getacl_sz      (compound_decode_hdr_maxsz + \
     762                 :            :                                 decode_sequence_maxsz + \
     763                 :            :                                 decode_putfh_maxsz + \
     764                 :            :                                 decode_getacl_maxsz)
     765                 :            : #define NFS4_enc_setacl_sz      (compound_encode_hdr_maxsz + \
     766                 :            :                                 encode_sequence_maxsz + \
     767                 :            :                                 encode_putfh_maxsz + \
     768                 :            :                                 encode_setacl_maxsz)
     769                 :            : #define NFS4_dec_setacl_sz      (compound_decode_hdr_maxsz + \
     770                 :            :                                 decode_sequence_maxsz + \
     771                 :            :                                 decode_putfh_maxsz + \
     772                 :            :                                 decode_setacl_maxsz)
     773                 :            : #define NFS4_enc_fs_locations_sz \
     774                 :            :                                 (compound_encode_hdr_maxsz + \
     775                 :            :                                  encode_sequence_maxsz + \
     776                 :            :                                  encode_putfh_maxsz + \
     777                 :            :                                  encode_lookup_maxsz + \
     778                 :            :                                  encode_fs_locations_maxsz + \
     779                 :            :                                  encode_renew_maxsz)
     780                 :            : #define NFS4_dec_fs_locations_sz \
     781                 :            :                                 (compound_decode_hdr_maxsz + \
     782                 :            :                                  decode_sequence_maxsz + \
     783                 :            :                                  decode_putfh_maxsz + \
     784                 :            :                                  decode_lookup_maxsz + \
     785                 :            :                                  decode_fs_locations_maxsz + \
     786                 :            :                                  decode_renew_maxsz)
     787                 :            : #define NFS4_enc_secinfo_sz     (compound_encode_hdr_maxsz + \
     788                 :            :                                 encode_sequence_maxsz + \
     789                 :            :                                 encode_putfh_maxsz + \
     790                 :            :                                 encode_secinfo_maxsz)
     791                 :            : #define NFS4_dec_secinfo_sz     (compound_decode_hdr_maxsz + \
     792                 :            :                                 decode_sequence_maxsz + \
     793                 :            :                                 decode_putfh_maxsz + \
     794                 :            :                                 decode_secinfo_maxsz)
     795                 :            : #define NFS4_enc_fsid_present_sz \
     796                 :            :                                 (compound_encode_hdr_maxsz + \
     797                 :            :                                  encode_sequence_maxsz + \
     798                 :            :                                  encode_putfh_maxsz + \
     799                 :            :                                  encode_getfh_maxsz + \
     800                 :            :                                  encode_renew_maxsz)
     801                 :            : #define NFS4_dec_fsid_present_sz \
     802                 :            :                                 (compound_decode_hdr_maxsz + \
     803                 :            :                                  decode_sequence_maxsz + \
     804                 :            :                                  decode_putfh_maxsz + \
     805                 :            :                                  decode_getfh_maxsz + \
     806                 :            :                                  decode_renew_maxsz)
     807                 :            : #if defined(CONFIG_NFS_V4_1)
     808                 :            : #define NFS4_enc_bind_conn_to_session_sz \
     809                 :            :                                 (compound_encode_hdr_maxsz + \
     810                 :            :                                  encode_bind_conn_to_session_maxsz)
     811                 :            : #define NFS4_dec_bind_conn_to_session_sz \
     812                 :            :                                 (compound_decode_hdr_maxsz + \
     813                 :            :                                  decode_bind_conn_to_session_maxsz)
     814                 :            : #define NFS4_enc_exchange_id_sz \
     815                 :            :                                 (compound_encode_hdr_maxsz + \
     816                 :            :                                  encode_exchange_id_maxsz)
     817                 :            : #define NFS4_dec_exchange_id_sz \
     818                 :            :                                 (compound_decode_hdr_maxsz + \
     819                 :            :                                  decode_exchange_id_maxsz)
     820                 :            : #define NFS4_enc_create_session_sz \
     821                 :            :                                 (compound_encode_hdr_maxsz + \
     822                 :            :                                  encode_create_session_maxsz)
     823                 :            : #define NFS4_dec_create_session_sz \
     824                 :            :                                 (compound_decode_hdr_maxsz + \
     825                 :            :                                  decode_create_session_maxsz)
     826                 :            : #define NFS4_enc_destroy_session_sz     (compound_encode_hdr_maxsz + \
     827                 :            :                                          encode_destroy_session_maxsz)
     828                 :            : #define NFS4_dec_destroy_session_sz     (compound_decode_hdr_maxsz + \
     829                 :            :                                          decode_destroy_session_maxsz)
     830                 :            : #define NFS4_enc_destroy_clientid_sz    (compound_encode_hdr_maxsz + \
     831                 :            :                                          encode_destroy_clientid_maxsz)
     832                 :            : #define NFS4_dec_destroy_clientid_sz    (compound_decode_hdr_maxsz + \
     833                 :            :                                          decode_destroy_clientid_maxsz)
     834                 :            : #define NFS4_enc_sequence_sz \
     835                 :            :                                 (compound_decode_hdr_maxsz + \
     836                 :            :                                  encode_sequence_maxsz)
     837                 :            : #define NFS4_dec_sequence_sz \
     838                 :            :                                 (compound_decode_hdr_maxsz + \
     839                 :            :                                  decode_sequence_maxsz)
     840                 :            : #endif
     841                 :            : #define NFS4_enc_get_lease_time_sz      (compound_encode_hdr_maxsz + \
     842                 :            :                                          encode_sequence_maxsz + \
     843                 :            :                                          encode_putrootfh_maxsz + \
     844                 :            :                                          encode_fsinfo_maxsz)
     845                 :            : #define NFS4_dec_get_lease_time_sz      (compound_decode_hdr_maxsz + \
     846                 :            :                                          decode_sequence_maxsz + \
     847                 :            :                                          decode_putrootfh_maxsz + \
     848                 :            :                                          decode_fsinfo_maxsz)
     849                 :            : #if defined(CONFIG_NFS_V4_1)
     850                 :            : #define NFS4_enc_reclaim_complete_sz    (compound_encode_hdr_maxsz + \
     851                 :            :                                          encode_sequence_maxsz + \
     852                 :            :                                          encode_reclaim_complete_maxsz)
     853                 :            : #define NFS4_dec_reclaim_complete_sz    (compound_decode_hdr_maxsz + \
     854                 :            :                                          decode_sequence_maxsz + \
     855                 :            :                                          decode_reclaim_complete_maxsz)
     856                 :            : #define NFS4_enc_getdeviceinfo_sz (compound_encode_hdr_maxsz +    \
     857                 :            :                                 encode_sequence_maxsz +\
     858                 :            :                                 encode_getdeviceinfo_maxsz)
     859                 :            : #define NFS4_dec_getdeviceinfo_sz (compound_decode_hdr_maxsz +    \
     860                 :            :                                 decode_sequence_maxsz + \
     861                 :            :                                 decode_getdeviceinfo_maxsz)
     862                 :            : #define NFS4_enc_layoutget_sz   (compound_encode_hdr_maxsz + \
     863                 :            :                                 encode_sequence_maxsz + \
     864                 :            :                                 encode_putfh_maxsz +        \
     865                 :            :                                 encode_layoutget_maxsz)
     866                 :            : #define NFS4_dec_layoutget_sz   (compound_decode_hdr_maxsz + \
     867                 :            :                                 decode_sequence_maxsz + \
     868                 :            :                                 decode_putfh_maxsz +        \
     869                 :            :                                 decode_layoutget_maxsz)
     870                 :            : #define NFS4_enc_layoutcommit_sz (compound_encode_hdr_maxsz + \
     871                 :            :                                 encode_sequence_maxsz +\
     872                 :            :                                 encode_putfh_maxsz + \
     873                 :            :                                 encode_layoutcommit_maxsz + \
     874                 :            :                                 encode_getattr_maxsz)
     875                 :            : #define NFS4_dec_layoutcommit_sz (compound_decode_hdr_maxsz + \
     876                 :            :                                 decode_sequence_maxsz + \
     877                 :            :                                 decode_putfh_maxsz + \
     878                 :            :                                 decode_layoutcommit_maxsz + \
     879                 :            :                                 decode_getattr_maxsz)
     880                 :            : #define NFS4_enc_layoutreturn_sz (compound_encode_hdr_maxsz + \
     881                 :            :                                 encode_sequence_maxsz + \
     882                 :            :                                 encode_putfh_maxsz + \
     883                 :            :                                 encode_layoutreturn_maxsz)
     884                 :            : #define NFS4_dec_layoutreturn_sz (compound_decode_hdr_maxsz + \
     885                 :            :                                 decode_sequence_maxsz + \
     886                 :            :                                 decode_putfh_maxsz + \
     887                 :            :                                 decode_layoutreturn_maxsz)
     888                 :            : #define NFS4_enc_secinfo_no_name_sz     (compound_encode_hdr_maxsz + \
     889                 :            :                                         encode_sequence_maxsz + \
     890                 :            :                                         encode_putrootfh_maxsz +\
     891                 :            :                                         encode_secinfo_no_name_maxsz)
     892                 :            : #define NFS4_dec_secinfo_no_name_sz     (compound_decode_hdr_maxsz + \
     893                 :            :                                         decode_sequence_maxsz + \
     894                 :            :                                         decode_putrootfh_maxsz + \
     895                 :            :                                         decode_secinfo_no_name_maxsz)
     896                 :            : #define NFS4_enc_test_stateid_sz        (compound_encode_hdr_maxsz + \
     897                 :            :                                          encode_sequence_maxsz + \
     898                 :            :                                          encode_test_stateid_maxsz)
     899                 :            : #define NFS4_dec_test_stateid_sz        (compound_decode_hdr_maxsz + \
     900                 :            :                                          decode_sequence_maxsz + \
     901                 :            :                                          decode_test_stateid_maxsz)
     902                 :            : #define NFS4_enc_free_stateid_sz        (compound_encode_hdr_maxsz + \
     903                 :            :                                          encode_sequence_maxsz + \
     904                 :            :                                          encode_free_stateid_maxsz)
     905                 :            : #define NFS4_dec_free_stateid_sz        (compound_decode_hdr_maxsz + \
     906                 :            :                                          decode_sequence_maxsz + \
     907                 :            :                                          decode_free_stateid_maxsz)
     908                 :            : 
     909                 :            : const u32 nfs41_maxwrite_overhead = ((RPC_MAX_HEADER_WITH_AUTH +
     910                 :            :                                       compound_encode_hdr_maxsz +
     911                 :            :                                       encode_sequence_maxsz +
     912                 :            :                                       encode_putfh_maxsz +
     913                 :            :                                       encode_getattr_maxsz) *
     914                 :            :                                      XDR_UNIT);
     915                 :            : 
     916                 :            : const u32 nfs41_maxread_overhead = ((RPC_MAX_HEADER_WITH_AUTH +
     917                 :            :                                      compound_decode_hdr_maxsz +
     918                 :            :                                      decode_sequence_maxsz +
     919                 :            :                                      decode_putfh_maxsz) *
     920                 :            :                                     XDR_UNIT);
     921                 :            : 
     922                 :            : const u32 nfs41_maxgetdevinfo_overhead = ((RPC_MAX_REPHEADER_WITH_AUTH +
     923                 :            :                                            compound_decode_hdr_maxsz +
     924                 :            :                                            decode_sequence_maxsz) *
     925                 :            :                                           XDR_UNIT);
     926                 :            : EXPORT_SYMBOL_GPL(nfs41_maxgetdevinfo_overhead);
     927                 :            : #endif /* CONFIG_NFS_V4_1 */
     928                 :            : 
     929                 :            : static const umode_t nfs_type2fmt[] = {
     930                 :            :         [NF4BAD] = 0,
     931                 :            :         [NF4REG] = S_IFREG,
     932                 :            :         [NF4DIR] = S_IFDIR,
     933                 :            :         [NF4BLK] = S_IFBLK,
     934                 :            :         [NF4CHR] = S_IFCHR,
     935                 :            :         [NF4LNK] = S_IFLNK,
     936                 :            :         [NF4SOCK] = S_IFSOCK,
     937                 :            :         [NF4FIFO] = S_IFIFO,
     938                 :            :         [NF4ATTRDIR] = 0,
     939                 :            :         [NF4NAMEDATTR] = 0,
     940                 :            : };
     941                 :            : 
     942                 :            : struct compound_hdr {
     943                 :            :         int32_t         status;
     944                 :            :         uint32_t        nops;
     945                 :            :         __be32 *        nops_p;
     946                 :            :         uint32_t        taglen;
     947                 :            :         char *          tag;
     948                 :            :         uint32_t        replen;         /* expected reply words */
     949                 :            :         u32             minorversion;
     950                 :            : };
     951                 :            : 
     952                 :          0 : static __be32 *reserve_space(struct xdr_stream *xdr, size_t nbytes)
     953                 :            : {
     954                 :          0 :         __be32 *p = xdr_reserve_space(xdr, nbytes);
     955                 :          0 :         BUG_ON(!p);
     956                 :          0 :         return p;
     957                 :            : }
     958                 :            : 
     959                 :          0 : static void encode_opaque_fixed(struct xdr_stream *xdr, const void *buf, size_t len)
     960                 :            : {
     961                 :          0 :         WARN_ON_ONCE(xdr_stream_encode_opaque_fixed(xdr, buf, len) < 0);
     962                 :          0 : }
     963                 :            : 
     964                 :          0 : static void encode_string(struct xdr_stream *xdr, unsigned int len, const char *str)
     965                 :            : {
     966                 :          0 :         WARN_ON_ONCE(xdr_stream_encode_opaque(xdr, str, len) < 0);
     967                 :          0 : }
     968                 :            : 
     969                 :          0 : static void encode_uint32(struct xdr_stream *xdr, u32 n)
     970                 :            : {
     971                 :          0 :         WARN_ON_ONCE(xdr_stream_encode_u32(xdr, n) < 0);
     972                 :          0 : }
     973                 :            : 
     974                 :          0 : static void encode_uint64(struct xdr_stream *xdr, u64 n)
     975                 :            : {
     976                 :          0 :         WARN_ON_ONCE(xdr_stream_encode_u64(xdr, n) < 0);
     977                 :          0 : }
     978                 :            : 
     979                 :          0 : static ssize_t xdr_encode_bitmap4(struct xdr_stream *xdr,
     980                 :            :                 const __u32 *bitmap, size_t len)
     981                 :            : {
     982                 :            :         ssize_t ret;
     983                 :            : 
     984                 :            :         /* Trim empty words */
     985                 :          0 :         while (len > 0 && bitmap[len-1] == 0)
     986                 :          0 :                 len--;
     987                 :          0 :         ret = xdr_stream_encode_uint32_array(xdr, bitmap, len);
     988                 :          0 :         if (WARN_ON_ONCE(ret < 0))
     989                 :            :                 return ret;
     990                 :          0 :         return len;
     991                 :            : }
     992                 :            : 
     993                 :          0 : static size_t mask_bitmap4(const __u32 *bitmap, const __u32 *mask,
     994                 :            :                 __u32 *res, size_t len)
     995                 :            : {
     996                 :            :         size_t i;
     997                 :            :         __u32 tmp;
     998                 :            : 
     999                 :          0 :         while (len > 0 && (bitmap[len-1] == 0 || mask[len-1] == 0))
    1000                 :          0 :                 len--;
    1001                 :          0 :         for (i = len; i-- > 0;) {
    1002                 :          0 :                 tmp = bitmap[i] & mask[i];
    1003                 :          0 :                 res[i] = tmp;
    1004                 :            :         }
    1005                 :          0 :         return len;
    1006                 :            : }
    1007                 :            : 
    1008                 :          0 : static void encode_nfs4_seqid(struct xdr_stream *xdr,
    1009                 :            :                 const struct nfs_seqid *seqid)
    1010                 :            : {
    1011                 :          0 :         if (seqid != NULL)
    1012                 :          0 :                 encode_uint32(xdr, seqid->sequence->counter);
    1013                 :            :         else
    1014                 :          0 :                 encode_uint32(xdr, 0);
    1015                 :          0 : }
    1016                 :            : 
    1017                 :          0 : static void encode_compound_hdr(struct xdr_stream *xdr,
    1018                 :            :                                 struct rpc_rqst *req,
    1019                 :            :                                 struct compound_hdr *hdr)
    1020                 :            : {
    1021                 :            :         __be32 *p;
    1022                 :            : 
    1023                 :            :         /* initialize running count of expected bytes in reply.
    1024                 :            :          * NOTE: the replied tag SHOULD be the same is the one sent,
    1025                 :            :          * but this is not required as a MUST for the server to do so. */
    1026                 :          0 :         hdr->replen = 3 + hdr->taglen;
    1027                 :            : 
    1028                 :          0 :         WARN_ON_ONCE(hdr->taglen > NFS4_MAXTAGLEN);
    1029                 :          0 :         encode_string(xdr, hdr->taglen, hdr->tag);
    1030                 :          0 :         p = reserve_space(xdr, 8);
    1031                 :          0 :         *p++ = cpu_to_be32(hdr->minorversion);
    1032                 :          0 :         hdr->nops_p = p;
    1033                 :          0 :         *p = cpu_to_be32(hdr->nops);
    1034                 :          0 : }
    1035                 :            : 
    1036                 :            : static void encode_op_hdr(struct xdr_stream *xdr, enum nfs_opnum4 op,
    1037                 :            :                 uint32_t replen,
    1038                 :            :                 struct compound_hdr *hdr)
    1039                 :            : {
    1040                 :          0 :         encode_uint32(xdr, op);
    1041                 :          0 :         hdr->nops++;
    1042                 :          0 :         hdr->replen += replen;
    1043                 :            : }
    1044                 :            : 
    1045                 :          0 : static void encode_nops(struct compound_hdr *hdr)
    1046                 :            : {
    1047                 :          0 :         WARN_ON_ONCE(hdr->nops > NFS4_MAX_OPS);
    1048                 :          0 :         *hdr->nops_p = htonl(hdr->nops);
    1049                 :          0 : }
    1050                 :            : 
    1051                 :            : static void encode_nfs4_stateid(struct xdr_stream *xdr, const nfs4_stateid *stateid)
    1052                 :            : {
    1053                 :          0 :         encode_opaque_fixed(xdr, stateid, NFS4_STATEID_SIZE);
    1054                 :            : }
    1055                 :            : 
    1056                 :            : static void encode_nfs4_verifier(struct xdr_stream *xdr, const nfs4_verifier *verf)
    1057                 :            : {
    1058                 :          0 :         encode_opaque_fixed(xdr, verf->data, NFS4_VERIFIER_SIZE);
    1059                 :            : }
    1060                 :            : 
    1061                 :            : static __be32 *
    1062                 :            : xdr_encode_nfstime4(__be32 *p, const struct timespec *t)
    1063                 :            : {
    1064                 :          0 :         p = xdr_encode_hyper(p, (__s64)t->tv_sec);
    1065                 :          0 :         *p++ = cpu_to_be32(t->tv_nsec);
    1066                 :            :         return p;
    1067                 :            : }
    1068                 :            : 
    1069                 :          0 : static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap,
    1070                 :            :                                 const struct nfs4_label *label,
    1071                 :            :                                 const umode_t *umask,
    1072                 :            :                                 const struct nfs_server *server,
    1073                 :            :                                 const uint32_t attrmask[])
    1074                 :            : {
    1075                 :            :         struct timespec ts;
    1076                 :            :         char owner_name[IDMAP_NAMESZ];
    1077                 :            :         char owner_group[IDMAP_NAMESZ];
    1078                 :            :         int owner_namelen = 0;
    1079                 :            :         int owner_grouplen = 0;
    1080                 :            :         __be32 *p;
    1081                 :            :         uint32_t len = 0;
    1082                 :          0 :         uint32_t bmval[3] = { 0 };
    1083                 :            : 
    1084                 :            :         /*
    1085                 :            :          * We reserve enough space to write the entire attribute buffer at once.
    1086                 :            :          */
    1087                 :          0 :         if ((iap->ia_valid & ATTR_SIZE) && (attrmask[0] & FATTR4_WORD0_SIZE)) {
    1088                 :          0 :                 bmval[0] |= FATTR4_WORD0_SIZE;
    1089                 :            :                 len += 8;
    1090                 :            :         }
    1091                 :          0 :         if (iap->ia_valid & ATTR_MODE) {
    1092                 :          0 :                 if (umask && (attrmask[2] & FATTR4_WORD2_MODE_UMASK)) {
    1093                 :          0 :                         bmval[2] |= FATTR4_WORD2_MODE_UMASK;
    1094                 :          0 :                         len += 8;
    1095                 :          0 :                 } else if (attrmask[1] & FATTR4_WORD1_MODE) {
    1096                 :          0 :                         bmval[1] |= FATTR4_WORD1_MODE;
    1097                 :          0 :                         len += 4;
    1098                 :            :                 }
    1099                 :            :         }
    1100                 :          0 :         if ((iap->ia_valid & ATTR_UID) && (attrmask[1] & FATTR4_WORD1_OWNER)) {
    1101                 :          0 :                 owner_namelen = nfs_map_uid_to_name(server, iap->ia_uid, owner_name, IDMAP_NAMESZ);
    1102                 :          0 :                 if (owner_namelen < 0) {
    1103                 :            :                         dprintk("nfs: couldn't resolve uid %d to string\n",
    1104                 :            :                                         from_kuid(&init_user_ns, iap->ia_uid));
    1105                 :            :                         /* XXX */
    1106                 :          0 :                         strcpy(owner_name, "nobody");
    1107                 :            :                         owner_namelen = sizeof("nobody") - 1;
    1108                 :            :                         /* goto out; */
    1109                 :            :                 }
    1110                 :          0 :                 bmval[1] |= FATTR4_WORD1_OWNER;
    1111                 :          0 :                 len += 4 + (XDR_QUADLEN(owner_namelen) << 2);
    1112                 :            :         }
    1113                 :          0 :         if ((iap->ia_valid & ATTR_GID) &&
    1114                 :          0 :            (attrmask[1] & FATTR4_WORD1_OWNER_GROUP)) {
    1115                 :          0 :                 owner_grouplen = nfs_map_gid_to_group(server, iap->ia_gid, owner_group, IDMAP_NAMESZ);
    1116                 :          0 :                 if (owner_grouplen < 0) {
    1117                 :            :                         dprintk("nfs: couldn't resolve gid %d to string\n",
    1118                 :            :                                         from_kgid(&init_user_ns, iap->ia_gid));
    1119                 :          0 :                         strcpy(owner_group, "nobody");
    1120                 :            :                         owner_grouplen = sizeof("nobody") - 1;
    1121                 :            :                         /* goto out; */
    1122                 :            :                 }
    1123                 :          0 :                 bmval[1] |= FATTR4_WORD1_OWNER_GROUP;
    1124                 :          0 :                 len += 4 + (XDR_QUADLEN(owner_grouplen) << 2);
    1125                 :            :         }
    1126                 :          0 :         if (attrmask[1] & FATTR4_WORD1_TIME_ACCESS_SET) {
    1127                 :          0 :                 if (iap->ia_valid & ATTR_ATIME_SET) {
    1128                 :          0 :                         bmval[1] |= FATTR4_WORD1_TIME_ACCESS_SET;
    1129                 :          0 :                         len += 4 + (nfstime4_maxsz << 2);
    1130                 :          0 :                 } else if (iap->ia_valid & ATTR_ATIME) {
    1131                 :          0 :                         bmval[1] |= FATTR4_WORD1_TIME_ACCESS_SET;
    1132                 :          0 :                         len += 4;
    1133                 :            :                 }
    1134                 :            :         }
    1135                 :          0 :         if (attrmask[1] & FATTR4_WORD1_TIME_MODIFY_SET) {
    1136                 :          0 :                 if (iap->ia_valid & ATTR_MTIME_SET) {
    1137                 :          0 :                         bmval[1] |= FATTR4_WORD1_TIME_MODIFY_SET;
    1138                 :          0 :                         len += 4 + (nfstime4_maxsz << 2);
    1139                 :          0 :                 } else if (iap->ia_valid & ATTR_MTIME) {
    1140                 :          0 :                         bmval[1] |= FATTR4_WORD1_TIME_MODIFY_SET;
    1141                 :          0 :                         len += 4;
    1142                 :            :                 }
    1143                 :            :         }
    1144                 :            : 
    1145                 :          0 :         if (label && (attrmask[2] & FATTR4_WORD2_SECURITY_LABEL)) {
    1146                 :          0 :                 len += 4 + 4 + 4 + (XDR_QUADLEN(label->len) << 2);
    1147                 :          0 :                 bmval[2] |= FATTR4_WORD2_SECURITY_LABEL;
    1148                 :            :         }
    1149                 :            : 
    1150                 :          0 :         xdr_encode_bitmap4(xdr, bmval, ARRAY_SIZE(bmval));
    1151                 :          0 :         xdr_stream_encode_opaque_inline(xdr, (void **)&p, len);
    1152                 :            : 
    1153                 :          0 :         if (bmval[0] & FATTR4_WORD0_SIZE)
    1154                 :          0 :                 p = xdr_encode_hyper(p, iap->ia_size);
    1155                 :          0 :         if (bmval[1] & FATTR4_WORD1_MODE)
    1156                 :          0 :                 *p++ = cpu_to_be32(iap->ia_mode & S_IALLUGO);
    1157                 :          0 :         if (bmval[1] & FATTR4_WORD1_OWNER)
    1158                 :          0 :                 p = xdr_encode_opaque(p, owner_name, owner_namelen);
    1159                 :          0 :         if (bmval[1] & FATTR4_WORD1_OWNER_GROUP)
    1160                 :          0 :                 p = xdr_encode_opaque(p, owner_group, owner_grouplen);
    1161                 :          0 :         if (bmval[1] & FATTR4_WORD1_TIME_ACCESS_SET) {
    1162                 :          0 :                 if (iap->ia_valid & ATTR_ATIME_SET) {
    1163                 :          0 :                         *p++ = cpu_to_be32(NFS4_SET_TO_CLIENT_TIME);
    1164                 :            :                         ts = timespec64_to_timespec(iap->ia_atime);
    1165                 :          0 :                         p = xdr_encode_nfstime4(p, &ts);
    1166                 :            :                 } else
    1167                 :          0 :                         *p++ = cpu_to_be32(NFS4_SET_TO_SERVER_TIME);
    1168                 :            :         }
    1169                 :          0 :         if (bmval[1] & FATTR4_WORD1_TIME_MODIFY_SET) {
    1170                 :          0 :                 if (iap->ia_valid & ATTR_MTIME_SET) {
    1171                 :          0 :                         *p++ = cpu_to_be32(NFS4_SET_TO_CLIENT_TIME);
    1172                 :            :                         ts = timespec64_to_timespec(iap->ia_mtime);
    1173                 :          0 :                         p = xdr_encode_nfstime4(p, &ts);
    1174                 :            :                 } else
    1175                 :          0 :                         *p++ = cpu_to_be32(NFS4_SET_TO_SERVER_TIME);
    1176                 :            :         }
    1177                 :          0 :         if (label && (bmval[2] & FATTR4_WORD2_SECURITY_LABEL)) {
    1178                 :          0 :                 *p++ = cpu_to_be32(label->lfs);
    1179                 :          0 :                 *p++ = cpu_to_be32(label->pi);
    1180                 :          0 :                 *p++ = cpu_to_be32(label->len);
    1181                 :          0 :                 p = xdr_encode_opaque_fixed(p, label->label, label->len);
    1182                 :            :         }
    1183                 :          0 :         if (bmval[2] & FATTR4_WORD2_MODE_UMASK) {
    1184                 :          0 :                 *p++ = cpu_to_be32(iap->ia_mode & S_IALLUGO);
    1185                 :          0 :                 *p++ = cpu_to_be32(*umask);
    1186                 :            :         }
    1187                 :            : 
    1188                 :            : /* out: */
    1189                 :          0 : }
    1190                 :            : 
    1191                 :          0 : static void encode_access(struct xdr_stream *xdr, u32 access, struct compound_hdr *hdr)
    1192                 :            : {
    1193                 :            :         encode_op_hdr(xdr, OP_ACCESS, decode_access_maxsz, hdr);
    1194                 :          0 :         encode_uint32(xdr, access);
    1195                 :          0 : }
    1196                 :            : 
    1197                 :          0 : static void encode_close(struct xdr_stream *xdr, const struct nfs_closeargs *arg, struct compound_hdr *hdr)
    1198                 :            : {
    1199                 :            :         encode_op_hdr(xdr, OP_CLOSE, decode_close_maxsz, hdr);
    1200                 :          0 :         encode_nfs4_seqid(xdr, arg->seqid);
    1201                 :          0 :         encode_nfs4_stateid(xdr, &arg->stateid);
    1202                 :          0 : }
    1203                 :            : 
    1204                 :          0 : static void encode_commit(struct xdr_stream *xdr, const struct nfs_commitargs *args, struct compound_hdr *hdr)
    1205                 :            : {
    1206                 :            :         __be32 *p;
    1207                 :            : 
    1208                 :            :         encode_op_hdr(xdr, OP_COMMIT, decode_commit_maxsz, hdr);
    1209                 :          0 :         p = reserve_space(xdr, 12);
    1210                 :          0 :         p = xdr_encode_hyper(p, args->offset);
    1211                 :          0 :         *p = cpu_to_be32(args->count);
    1212                 :          0 : }
    1213                 :            : 
    1214                 :          0 : static void encode_create(struct xdr_stream *xdr, const struct nfs4_create_arg *create, struct compound_hdr *hdr)
    1215                 :            : {
    1216                 :            :         __be32 *p;
    1217                 :            : 
    1218                 :            :         encode_op_hdr(xdr, OP_CREATE, decode_create_maxsz, hdr);
    1219                 :          0 :         encode_uint32(xdr, create->ftype);
    1220                 :            : 
    1221                 :          0 :         switch (create->ftype) {
    1222                 :            :         case NF4LNK:
    1223                 :          0 :                 p = reserve_space(xdr, 4);
    1224                 :          0 :                 *p = cpu_to_be32(create->u.symlink.len);
    1225                 :          0 :                 xdr_write_pages(xdr, create->u.symlink.pages, 0,
    1226                 :            :                                 create->u.symlink.len);
    1227                 :          0 :                 xdr->buf->flags |= XDRBUF_WRITE;
    1228                 :          0 :                 break;
    1229                 :            : 
    1230                 :            :         case NF4BLK: case NF4CHR:
    1231                 :          0 :                 p = reserve_space(xdr, 8);
    1232                 :          0 :                 *p++ = cpu_to_be32(create->u.device.specdata1);
    1233                 :          0 :                 *p = cpu_to_be32(create->u.device.specdata2);
    1234                 :          0 :                 break;
    1235                 :            : 
    1236                 :            :         default:
    1237                 :            :                 break;
    1238                 :            :         }
    1239                 :            : 
    1240                 :          0 :         encode_string(xdr, create->name->len, create->name->name);
    1241                 :          0 :         encode_attrs(xdr, create->attrs, create->label, &create->umask,
    1242                 :          0 :                         create->server, create->server->attr_bitmask);
    1243                 :          0 : }
    1244                 :            : 
    1245                 :          0 : static void encode_getattr(struct xdr_stream *xdr,
    1246                 :            :                 const __u32 *bitmap, const __u32 *mask, size_t len,
    1247                 :            :                 struct compound_hdr *hdr)
    1248                 :            : {
    1249                 :            :         __u32 masked_bitmap[nfs4_fattr_bitmap_maxsz];
    1250                 :            : 
    1251                 :            :         encode_op_hdr(xdr, OP_GETATTR, decode_getattr_maxsz, hdr);
    1252                 :          0 :         if (mask) {
    1253                 :          0 :                 if (WARN_ON_ONCE(len > ARRAY_SIZE(masked_bitmap)))
    1254                 :            :                         len = ARRAY_SIZE(masked_bitmap);
    1255                 :          0 :                 len = mask_bitmap4(bitmap, mask, masked_bitmap, len);
    1256                 :            :                 bitmap = masked_bitmap;
    1257                 :            :         }
    1258                 :          0 :         xdr_encode_bitmap4(xdr, bitmap, len);
    1259                 :          0 : }
    1260                 :            : 
    1261                 :            : static void encode_getfattr(struct xdr_stream *xdr, const u32* bitmask, struct compound_hdr *hdr)
    1262                 :            : {
    1263                 :          0 :         encode_getattr(xdr, nfs4_fattr_bitmap, bitmask,
    1264                 :            :                         ARRAY_SIZE(nfs4_fattr_bitmap), hdr);
    1265                 :            : }
    1266                 :            : 
    1267                 :            : static void encode_getfattr_open(struct xdr_stream *xdr, const u32 *bitmask,
    1268                 :            :                                  const u32 *open_bitmap,
    1269                 :            :                                  struct compound_hdr *hdr)
    1270                 :            : {
    1271                 :          0 :         encode_getattr(xdr, open_bitmap, bitmask, 3, hdr);
    1272                 :            : }
    1273                 :            : 
    1274                 :            : static void encode_fsinfo(struct xdr_stream *xdr, const u32* bitmask, struct compound_hdr *hdr)
    1275                 :            : {
    1276                 :          0 :         encode_getattr(xdr, nfs4_fsinfo_bitmap, bitmask,
    1277                 :            :                         ARRAY_SIZE(nfs4_fsinfo_bitmap), hdr);
    1278                 :            : }
    1279                 :            : 
    1280                 :            : static void encode_fs_locations(struct xdr_stream *xdr, const u32* bitmask, struct compound_hdr *hdr)
    1281                 :            : {
    1282                 :          0 :         encode_getattr(xdr, nfs4_fs_locations_bitmap, bitmask,
    1283                 :            :                         ARRAY_SIZE(nfs4_fs_locations_bitmap), hdr);
    1284                 :            : }
    1285                 :            : 
    1286                 :            : static void encode_getfh(struct xdr_stream *xdr, struct compound_hdr *hdr)
    1287                 :            : {
    1288                 :            :         encode_op_hdr(xdr, OP_GETFH, decode_getfh_maxsz, hdr);
    1289                 :            : }
    1290                 :            : 
    1291                 :          0 : static void encode_link(struct xdr_stream *xdr, const struct qstr *name, struct compound_hdr *hdr)
    1292                 :            : {
    1293                 :            :         encode_op_hdr(xdr, OP_LINK, decode_link_maxsz, hdr);
    1294                 :          0 :         encode_string(xdr, name->len, name->name);
    1295                 :          0 : }
    1296                 :            : 
    1297                 :            : static inline int nfs4_lock_type(struct file_lock *fl, int block)
    1298                 :            : {
    1299                 :          0 :         if (fl->fl_type == F_RDLCK)
    1300                 :          0 :                 return block ? NFS4_READW_LT : NFS4_READ_LT;
    1301                 :          0 :         return block ? NFS4_WRITEW_LT : NFS4_WRITE_LT;
    1302                 :            : }
    1303                 :            : 
    1304                 :            : static inline uint64_t nfs4_lock_length(struct file_lock *fl)
    1305                 :            : {
    1306                 :          0 :         if (fl->fl_end == OFFSET_MAX)
    1307                 :            :                 return ~(uint64_t)0;
    1308                 :          0 :         return fl->fl_end - fl->fl_start + 1;
    1309                 :            : }
    1310                 :            : 
    1311                 :          0 : static void encode_lockowner(struct xdr_stream *xdr, const struct nfs_lowner *lowner)
    1312                 :            : {
    1313                 :            :         __be32 *p;
    1314                 :            : 
    1315                 :          0 :         p = reserve_space(xdr, 32);
    1316                 :          0 :         p = xdr_encode_hyper(p, lowner->clientid);
    1317                 :          0 :         *p++ = cpu_to_be32(20);
    1318                 :          0 :         p = xdr_encode_opaque_fixed(p, "lock id:", 8);
    1319                 :          0 :         *p++ = cpu_to_be32(lowner->s_dev);
    1320                 :          0 :         xdr_encode_hyper(p, lowner->id);
    1321                 :          0 : }
    1322                 :            : 
    1323                 :            : /*
    1324                 :            :  * opcode,type,reclaim,offset,length,new_lock_owner = 32
    1325                 :            :  * open_seqid,open_stateid,lock_seqid,lock_owner.clientid, lock_owner.id = 40
    1326                 :            :  */
    1327                 :          0 : static void encode_lock(struct xdr_stream *xdr, const struct nfs_lock_args *args, struct compound_hdr *hdr)
    1328                 :            : {
    1329                 :            :         __be32 *p;
    1330                 :            : 
    1331                 :            :         encode_op_hdr(xdr, OP_LOCK, decode_lock_maxsz, hdr);
    1332                 :          0 :         p = reserve_space(xdr, 28);
    1333                 :          0 :         *p++ = cpu_to_be32(nfs4_lock_type(args->fl, args->block));
    1334                 :          0 :         *p++ = cpu_to_be32(args->reclaim);
    1335                 :          0 :         p = xdr_encode_hyper(p, args->fl->fl_start);
    1336                 :          0 :         p = xdr_encode_hyper(p, nfs4_lock_length(args->fl));
    1337                 :          0 :         *p = cpu_to_be32(args->new_lock_owner);
    1338                 :          0 :         if (args->new_lock_owner){
    1339                 :          0 :                 encode_nfs4_seqid(xdr, args->open_seqid);
    1340                 :          0 :                 encode_nfs4_stateid(xdr, &args->open_stateid);
    1341                 :          0 :                 encode_nfs4_seqid(xdr, args->lock_seqid);
    1342                 :          0 :                 encode_lockowner(xdr, &args->lock_owner);
    1343                 :            :         }
    1344                 :            :         else {
    1345                 :          0 :                 encode_nfs4_stateid(xdr, &args->lock_stateid);
    1346                 :          0 :                 encode_nfs4_seqid(xdr, args->lock_seqid);
    1347                 :            :         }
    1348                 :          0 : }
    1349                 :            : 
    1350                 :          0 : static void encode_lockt(struct xdr_stream *xdr, const struct nfs_lockt_args *args, struct compound_hdr *hdr)
    1351                 :            : {
    1352                 :            :         __be32 *p;
    1353                 :            : 
    1354                 :            :         encode_op_hdr(xdr, OP_LOCKT, decode_lockt_maxsz, hdr);
    1355                 :          0 :         p = reserve_space(xdr, 20);
    1356                 :          0 :         *p++ = cpu_to_be32(nfs4_lock_type(args->fl, 0));
    1357                 :          0 :         p = xdr_encode_hyper(p, args->fl->fl_start);
    1358                 :          0 :         p = xdr_encode_hyper(p, nfs4_lock_length(args->fl));
    1359                 :          0 :         encode_lockowner(xdr, &args->lock_owner);
    1360                 :          0 : }
    1361                 :            : 
    1362                 :          0 : static void encode_locku(struct xdr_stream *xdr, const struct nfs_locku_args *args, struct compound_hdr *hdr)
    1363                 :            : {
    1364                 :            :         __be32 *p;
    1365                 :            : 
    1366                 :            :         encode_op_hdr(xdr, OP_LOCKU, decode_locku_maxsz, hdr);
    1367                 :          0 :         encode_uint32(xdr, nfs4_lock_type(args->fl, 0));
    1368                 :          0 :         encode_nfs4_seqid(xdr, args->seqid);
    1369                 :          0 :         encode_nfs4_stateid(xdr, &args->stateid);
    1370                 :          0 :         p = reserve_space(xdr, 16);
    1371                 :          0 :         p = xdr_encode_hyper(p, args->fl->fl_start);
    1372                 :          0 :         xdr_encode_hyper(p, nfs4_lock_length(args->fl));
    1373                 :          0 : }
    1374                 :            : 
    1375                 :          0 : static void encode_release_lockowner(struct xdr_stream *xdr, const struct nfs_lowner *lowner, struct compound_hdr *hdr)
    1376                 :            : {
    1377                 :            :         encode_op_hdr(xdr, OP_RELEASE_LOCKOWNER, decode_release_lockowner_maxsz, hdr);
    1378                 :          0 :         encode_lockowner(xdr, lowner);
    1379                 :          0 : }
    1380                 :            : 
    1381                 :          0 : static void encode_lookup(struct xdr_stream *xdr, const struct qstr *name, struct compound_hdr *hdr)
    1382                 :            : {
    1383                 :            :         encode_op_hdr(xdr, OP_LOOKUP, decode_lookup_maxsz, hdr);
    1384                 :          0 :         encode_string(xdr, name->len, name->name);
    1385                 :          0 : }
    1386                 :            : 
    1387                 :            : static void encode_lookupp(struct xdr_stream *xdr, struct compound_hdr *hdr)
    1388                 :            : {
    1389                 :            :         encode_op_hdr(xdr, OP_LOOKUPP, decode_lookupp_maxsz, hdr);
    1390                 :            : }
    1391                 :            : 
    1392                 :            : static void encode_share_access(struct xdr_stream *xdr, u32 share_access)
    1393                 :            : {
    1394                 :            :         __be32 *p;
    1395                 :            : 
    1396                 :          0 :         p = reserve_space(xdr, 8);
    1397                 :          0 :         *p++ = cpu_to_be32(share_access);
    1398                 :          0 :         *p = cpu_to_be32(0);            /* for linux, share_deny = 0 always */
    1399                 :            : }
    1400                 :            : 
    1401                 :          0 : static inline void encode_openhdr(struct xdr_stream *xdr, const struct nfs_openargs *arg)
    1402                 :            : {
    1403                 :            :         __be32 *p;
    1404                 :            :  /*
    1405                 :            :  * opcode 4, seqid 4, share_access 4, share_deny 4, clientid 8, ownerlen 4,
    1406                 :            :  * owner 4 = 32
    1407                 :            :  */
    1408                 :          0 :         encode_nfs4_seqid(xdr, arg->seqid);
    1409                 :          0 :         encode_share_access(xdr, arg->share_access);
    1410                 :          0 :         p = reserve_space(xdr, 36);
    1411                 :          0 :         p = xdr_encode_hyper(p, arg->clientid);
    1412                 :          0 :         *p++ = cpu_to_be32(24);
    1413                 :          0 :         p = xdr_encode_opaque_fixed(p, "open id:", 8);
    1414                 :          0 :         *p++ = cpu_to_be32(arg->server->s_dev);
    1415                 :          0 :         *p++ = cpu_to_be32(arg->id.uniquifier);
    1416                 :          0 :         xdr_encode_hyper(p, arg->id.create_time);
    1417                 :          0 : }
    1418                 :            : 
    1419                 :          0 : static inline void encode_createmode(struct xdr_stream *xdr, const struct nfs_openargs *arg)
    1420                 :            : {
    1421                 :            :         __be32 *p;
    1422                 :            : 
    1423                 :          0 :         p = reserve_space(xdr, 4);
    1424                 :          0 :         switch(arg->createmode) {
    1425                 :            :         case NFS4_CREATE_UNCHECKED:
    1426                 :          0 :                 *p = cpu_to_be32(NFS4_CREATE_UNCHECKED);
    1427                 :          0 :                 encode_attrs(xdr, arg->u.attrs, arg->label, &arg->umask,
    1428                 :          0 :                                 arg->server, arg->server->attr_bitmask);
    1429                 :          0 :                 break;
    1430                 :            :         case NFS4_CREATE_GUARDED:
    1431                 :          0 :                 *p = cpu_to_be32(NFS4_CREATE_GUARDED);
    1432                 :          0 :                 encode_attrs(xdr, arg->u.attrs, arg->label, &arg->umask,
    1433                 :          0 :                                 arg->server, arg->server->attr_bitmask);
    1434                 :          0 :                 break;
    1435                 :            :         case NFS4_CREATE_EXCLUSIVE:
    1436                 :          0 :                 *p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE);
    1437                 :            :                 encode_nfs4_verifier(xdr, &arg->u.verifier);
    1438                 :            :                 break;
    1439                 :            :         case NFS4_CREATE_EXCLUSIVE4_1:
    1440                 :          0 :                 *p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE4_1);
    1441                 :            :                 encode_nfs4_verifier(xdr, &arg->u.verifier);
    1442                 :          0 :                 encode_attrs(xdr, arg->u.attrs, arg->label, &arg->umask,
    1443                 :          0 :                                 arg->server, arg->server->exclcreat_bitmask);
    1444                 :            :         }
    1445                 :          0 : }
    1446                 :            : 
    1447                 :          0 : static void encode_opentype(struct xdr_stream *xdr, const struct nfs_openargs *arg)
    1448                 :            : {
    1449                 :            :         __be32 *p;
    1450                 :            : 
    1451                 :          0 :         p = reserve_space(xdr, 4);
    1452                 :          0 :         switch (arg->open_flags & O_CREAT) {
    1453                 :            :         case 0:
    1454                 :          0 :                 *p = cpu_to_be32(NFS4_OPEN_NOCREATE);
    1455                 :          0 :                 break;
    1456                 :            :         default:
    1457                 :          0 :                 *p = cpu_to_be32(NFS4_OPEN_CREATE);
    1458                 :          0 :                 encode_createmode(xdr, arg);
    1459                 :            :         }
    1460                 :          0 : }
    1461                 :            : 
    1462                 :          0 : static inline void encode_delegation_type(struct xdr_stream *xdr, fmode_t delegation_type)
    1463                 :            : {
    1464                 :            :         __be32 *p;
    1465                 :            : 
    1466                 :          0 :         p = reserve_space(xdr, 4);
    1467                 :          0 :         switch (delegation_type) {
    1468                 :            :         case 0:
    1469                 :          0 :                 *p = cpu_to_be32(NFS4_OPEN_DELEGATE_NONE);
    1470                 :          0 :                 break;
    1471                 :            :         case FMODE_READ:
    1472                 :          0 :                 *p = cpu_to_be32(NFS4_OPEN_DELEGATE_READ);
    1473                 :          0 :                 break;
    1474                 :            :         case FMODE_WRITE|FMODE_READ:
    1475                 :          0 :                 *p = cpu_to_be32(NFS4_OPEN_DELEGATE_WRITE);
    1476                 :          0 :                 break;
    1477                 :            :         default:
    1478                 :          0 :                 BUG();
    1479                 :            :         }
    1480                 :          0 : }
    1481                 :            : 
    1482                 :          0 : static inline void encode_claim_null(struct xdr_stream *xdr, const struct qstr *name)
    1483                 :            : {
    1484                 :            :         __be32 *p;
    1485                 :            : 
    1486                 :          0 :         p = reserve_space(xdr, 4);
    1487                 :          0 :         *p = cpu_to_be32(NFS4_OPEN_CLAIM_NULL);
    1488                 :          0 :         encode_string(xdr, name->len, name->name);
    1489                 :          0 : }
    1490                 :            : 
    1491                 :          0 : static inline void encode_claim_previous(struct xdr_stream *xdr, fmode_t type)
    1492                 :            : {
    1493                 :            :         __be32 *p;
    1494                 :            : 
    1495                 :          0 :         p = reserve_space(xdr, 4);
    1496                 :          0 :         *p = cpu_to_be32(NFS4_OPEN_CLAIM_PREVIOUS);
    1497                 :          0 :         encode_delegation_type(xdr, type);
    1498                 :          0 : }
    1499                 :            : 
    1500                 :          0 : static inline void encode_claim_delegate_cur(struct xdr_stream *xdr, const struct qstr *name, const nfs4_stateid *stateid)
    1501                 :            : {
    1502                 :            :         __be32 *p;
    1503                 :            : 
    1504                 :          0 :         p = reserve_space(xdr, 4);
    1505                 :          0 :         *p = cpu_to_be32(NFS4_OPEN_CLAIM_DELEGATE_CUR);
    1506                 :            :         encode_nfs4_stateid(xdr, stateid);
    1507                 :          0 :         encode_string(xdr, name->len, name->name);
    1508                 :          0 : }
    1509                 :            : 
    1510                 :            : static inline void encode_claim_fh(struct xdr_stream *xdr)
    1511                 :            : {
    1512                 :            :         __be32 *p;
    1513                 :            : 
    1514                 :          0 :         p = reserve_space(xdr, 4);
    1515                 :          0 :         *p = cpu_to_be32(NFS4_OPEN_CLAIM_FH);
    1516                 :            : }
    1517                 :            : 
    1518                 :          0 : static inline void encode_claim_delegate_cur_fh(struct xdr_stream *xdr, const nfs4_stateid *stateid)
    1519                 :            : {
    1520                 :            :         __be32 *p;
    1521                 :            : 
    1522                 :          0 :         p = reserve_space(xdr, 4);
    1523                 :          0 :         *p = cpu_to_be32(NFS4_OPEN_CLAIM_DELEG_CUR_FH);
    1524                 :            :         encode_nfs4_stateid(xdr, stateid);
    1525                 :          0 : }
    1526                 :            : 
    1527                 :          0 : static void encode_open(struct xdr_stream *xdr, const struct nfs_openargs *arg, struct compound_hdr *hdr)
    1528                 :            : {
    1529                 :            :         encode_op_hdr(xdr, OP_OPEN, decode_open_maxsz, hdr);
    1530                 :          0 :         encode_openhdr(xdr, arg);
    1531                 :          0 :         encode_opentype(xdr, arg);
    1532                 :          0 :         switch (arg->claim) {
    1533                 :            :         case NFS4_OPEN_CLAIM_NULL:
    1534                 :          0 :                 encode_claim_null(xdr, arg->name);
    1535                 :          0 :                 break;
    1536                 :            :         case NFS4_OPEN_CLAIM_PREVIOUS:
    1537                 :          0 :                 encode_claim_previous(xdr, arg->u.delegation_type);
    1538                 :          0 :                 break;
    1539                 :            :         case NFS4_OPEN_CLAIM_DELEGATE_CUR:
    1540                 :          0 :                 encode_claim_delegate_cur(xdr, arg->name, &arg->u.delegation);
    1541                 :          0 :                 break;
    1542                 :            :         case NFS4_OPEN_CLAIM_FH:
    1543                 :            :                 encode_claim_fh(xdr);
    1544                 :            :                 break;
    1545                 :            :         case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
    1546                 :          0 :                 encode_claim_delegate_cur_fh(xdr, &arg->u.delegation);
    1547                 :          0 :                 break;
    1548                 :            :         default:
    1549                 :          0 :                 BUG();
    1550                 :            :         }
    1551                 :          0 : }
    1552                 :            : 
    1553                 :          0 : static void encode_open_confirm(struct xdr_stream *xdr, const struct nfs_open_confirmargs *arg, struct compound_hdr *hdr)
    1554                 :            : {
    1555                 :            :         encode_op_hdr(xdr, OP_OPEN_CONFIRM, decode_open_confirm_maxsz, hdr);
    1556                 :          0 :         encode_nfs4_stateid(xdr, arg->stateid);
    1557                 :          0 :         encode_nfs4_seqid(xdr, arg->seqid);
    1558                 :          0 : }
    1559                 :            : 
    1560                 :          0 : static void encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closeargs *arg, struct compound_hdr *hdr)
    1561                 :            : {
    1562                 :            :         encode_op_hdr(xdr, OP_OPEN_DOWNGRADE, decode_open_downgrade_maxsz, hdr);
    1563                 :          0 :         encode_nfs4_stateid(xdr, &arg->stateid);
    1564                 :          0 :         encode_nfs4_seqid(xdr, arg->seqid);
    1565                 :          0 :         encode_share_access(xdr, arg->share_access);
    1566                 :          0 : }
    1567                 :            : 
    1568                 :            : static void
    1569                 :          0 : encode_putfh(struct xdr_stream *xdr, const struct nfs_fh *fh, struct compound_hdr *hdr)
    1570                 :            : {
    1571                 :            :         encode_op_hdr(xdr, OP_PUTFH, decode_putfh_maxsz, hdr);
    1572                 :          0 :         encode_string(xdr, fh->size, fh->data);
    1573                 :          0 : }
    1574                 :            : 
    1575                 :            : static void encode_putrootfh(struct xdr_stream *xdr, struct compound_hdr *hdr)
    1576                 :            : {
    1577                 :            :         encode_op_hdr(xdr, OP_PUTROOTFH, decode_putrootfh_maxsz, hdr);
    1578                 :            : }
    1579                 :            : 
    1580                 :          0 : static void encode_read(struct xdr_stream *xdr, const struct nfs_pgio_args *args,
    1581                 :            :                         struct compound_hdr *hdr)
    1582                 :            : {
    1583                 :            :         __be32 *p;
    1584                 :            : 
    1585                 :            :         encode_op_hdr(xdr, OP_READ, decode_read_maxsz, hdr);
    1586                 :          0 :         encode_nfs4_stateid(xdr, &args->stateid);
    1587                 :            : 
    1588                 :          0 :         p = reserve_space(xdr, 12);
    1589                 :          0 :         p = xdr_encode_hyper(p, args->offset);
    1590                 :          0 :         *p = cpu_to_be32(args->count);
    1591                 :          0 : }
    1592                 :            : 
    1593                 :          0 : static void encode_readdir(struct xdr_stream *xdr, const struct nfs4_readdir_arg *readdir, struct rpc_rqst *req, struct compound_hdr *hdr)
    1594                 :            : {
    1595                 :          0 :         uint32_t attrs[3] = {
    1596                 :            :                 FATTR4_WORD0_RDATTR_ERROR,
    1597                 :            :                 FATTR4_WORD1_MOUNTED_ON_FILEID,
    1598                 :            :         };
    1599                 :          0 :         uint32_t dircount = readdir->count >> 1;
    1600                 :            :         __be32 *p, verf[2];
    1601                 :            :         uint32_t attrlen = 0;
    1602                 :            :         unsigned int i;
    1603                 :            : 
    1604                 :          0 :         if (readdir->plus) {
    1605                 :          0 :                 attrs[0] |= FATTR4_WORD0_TYPE|FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE|
    1606                 :            :                         FATTR4_WORD0_FSID|FATTR4_WORD0_FILEHANDLE|FATTR4_WORD0_FILEID;
    1607                 :          0 :                 attrs[1] |= FATTR4_WORD1_MODE|FATTR4_WORD1_NUMLINKS|FATTR4_WORD1_OWNER|
    1608                 :            :                         FATTR4_WORD1_OWNER_GROUP|FATTR4_WORD1_RAWDEV|
    1609                 :            :                         FATTR4_WORD1_SPACE_USED|FATTR4_WORD1_TIME_ACCESS|
    1610                 :            :                         FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY;
    1611                 :          0 :                 attrs[2] |= FATTR4_WORD2_SECURITY_LABEL;
    1612                 :          0 :                 dircount >>= 1;
    1613                 :            :         }
    1614                 :            :         /* Use mounted_on_fileid only if the server supports it */
    1615                 :          0 :         if (!(readdir->bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID))
    1616                 :          0 :                 attrs[0] |= FATTR4_WORD0_FILEID;
    1617                 :          0 :         for (i = 0; i < ARRAY_SIZE(attrs); i++) {
    1618                 :          0 :                 attrs[i] &= readdir->bitmask[i];
    1619                 :          0 :                 if (attrs[i] != 0)
    1620                 :          0 :                         attrlen = i+1;
    1621                 :            :         }
    1622                 :            : 
    1623                 :            :         encode_op_hdr(xdr, OP_READDIR, decode_readdir_maxsz, hdr);
    1624                 :          0 :         encode_uint64(xdr, readdir->cookie);
    1625                 :            :         encode_nfs4_verifier(xdr, &readdir->verifier);
    1626                 :          0 :         p = reserve_space(xdr, 12 + (attrlen << 2));
    1627                 :          0 :         *p++ = cpu_to_be32(dircount);
    1628                 :          0 :         *p++ = cpu_to_be32(readdir->count);
    1629                 :          0 :         *p++ = cpu_to_be32(attrlen);
    1630                 :          0 :         for (i = 0; i < attrlen; i++)
    1631                 :          0 :                 *p++ = cpu_to_be32(attrs[i]);
    1632                 :          0 :         memcpy(verf, readdir->verifier.data, sizeof(verf));
    1633                 :            : 
    1634                 :            :         dprintk("%s: cookie = %llu, verifier = %08x:%08x, bitmap = %08x:%08x:%08x\n",
    1635                 :            :                         __func__,
    1636                 :            :                         (unsigned long long)readdir->cookie,
    1637                 :            :                         verf[0], verf[1],
    1638                 :            :                         attrs[0] & readdir->bitmask[0],
    1639                 :            :                         attrs[1] & readdir->bitmask[1],
    1640                 :            :                         attrs[2] & readdir->bitmask[2]);
    1641                 :          0 : }
    1642                 :            : 
    1643                 :            : static void encode_readlink(struct xdr_stream *xdr, const struct nfs4_readlink *readlink, struct rpc_rqst *req, struct compound_hdr *hdr)
    1644                 :            : {
    1645                 :            :         encode_op_hdr(xdr, OP_READLINK, decode_readlink_maxsz, hdr);
    1646                 :            : }
    1647                 :            : 
    1648                 :          0 : static void encode_remove(struct xdr_stream *xdr, const struct qstr *name, struct compound_hdr *hdr)
    1649                 :            : {
    1650                 :            :         encode_op_hdr(xdr, OP_REMOVE, decode_remove_maxsz, hdr);
    1651                 :          0 :         encode_string(xdr, name->len, name->name);
    1652                 :          0 : }
    1653                 :            : 
    1654                 :          0 : static void encode_rename(struct xdr_stream *xdr, const struct qstr *oldname, const struct qstr *newname, struct compound_hdr *hdr)
    1655                 :            : {
    1656                 :            :         encode_op_hdr(xdr, OP_RENAME, decode_rename_maxsz, hdr);
    1657                 :          0 :         encode_string(xdr, oldname->len, oldname->name);
    1658                 :          0 :         encode_string(xdr, newname->len, newname->name);
    1659                 :          0 : }
    1660                 :            : 
    1661                 :          0 : static void encode_renew(struct xdr_stream *xdr, clientid4 clid,
    1662                 :            :                          struct compound_hdr *hdr)
    1663                 :            : {
    1664                 :            :         encode_op_hdr(xdr, OP_RENEW, decode_renew_maxsz, hdr);
    1665                 :          0 :         encode_uint64(xdr, clid);
    1666                 :          0 : }
    1667                 :            : 
    1668                 :            : static void
    1669                 :            : encode_restorefh(struct xdr_stream *xdr, struct compound_hdr *hdr)
    1670                 :            : {
    1671                 :            :         encode_op_hdr(xdr, OP_RESTOREFH, decode_restorefh_maxsz, hdr);
    1672                 :            : }
    1673                 :            : 
    1674                 :            : static void
    1675                 :          0 : encode_setacl(struct xdr_stream *xdr, const struct nfs_setaclargs *arg,
    1676                 :            :                 struct compound_hdr *hdr)
    1677                 :            : {
    1678                 :            :         __be32 *p;
    1679                 :            : 
    1680                 :            :         encode_op_hdr(xdr, OP_SETATTR, decode_setacl_maxsz, hdr);
    1681                 :            :         encode_nfs4_stateid(xdr, &zero_stateid);
    1682                 :          0 :         p = reserve_space(xdr, 2*4);
    1683                 :          0 :         *p++ = cpu_to_be32(1);
    1684                 :          0 :         *p = cpu_to_be32(FATTR4_WORD0_ACL);
    1685                 :          0 :         p = reserve_space(xdr, 4);
    1686                 :          0 :         *p = cpu_to_be32(arg->acl_len);
    1687                 :          0 :         xdr_write_pages(xdr, arg->acl_pages, 0, arg->acl_len);
    1688                 :          0 : }
    1689                 :            : 
    1690                 :            : static void
    1691                 :            : encode_savefh(struct xdr_stream *xdr, struct compound_hdr *hdr)
    1692                 :            : {
    1693                 :            :         encode_op_hdr(xdr, OP_SAVEFH, decode_savefh_maxsz, hdr);
    1694                 :            : }
    1695                 :            : 
    1696                 :          0 : static void encode_setattr(struct xdr_stream *xdr, const struct nfs_setattrargs *arg, const struct nfs_server *server, struct compound_hdr *hdr)
    1697                 :            : {
    1698                 :            :         encode_op_hdr(xdr, OP_SETATTR, decode_setattr_maxsz, hdr);
    1699                 :          0 :         encode_nfs4_stateid(xdr, &arg->stateid);
    1700                 :          0 :         encode_attrs(xdr, arg->iap, arg->label, NULL, server,
    1701                 :          0 :                         server->attr_bitmask);
    1702                 :          0 : }
    1703                 :            : 
    1704                 :          0 : static void encode_setclientid(struct xdr_stream *xdr, const struct nfs4_setclientid *setclientid, struct compound_hdr *hdr)
    1705                 :            : {
    1706                 :            :         __be32 *p;
    1707                 :            : 
    1708                 :            :         encode_op_hdr(xdr, OP_SETCLIENTID, decode_setclientid_maxsz, hdr);
    1709                 :          0 :         encode_nfs4_verifier(xdr, setclientid->sc_verifier);
    1710                 :            : 
    1711                 :          0 :         encode_string(xdr, strlen(setclientid->sc_clnt->cl_owner_id),
    1712                 :            :                         setclientid->sc_clnt->cl_owner_id);
    1713                 :          0 :         p = reserve_space(xdr, 4);
    1714                 :          0 :         *p = cpu_to_be32(setclientid->sc_prog);
    1715                 :          0 :         encode_string(xdr, setclientid->sc_netid_len, setclientid->sc_netid);
    1716                 :          0 :         encode_string(xdr, setclientid->sc_uaddr_len, setclientid->sc_uaddr);
    1717                 :          0 :         p = reserve_space(xdr, 4);
    1718                 :          0 :         *p = cpu_to_be32(setclientid->sc_clnt->cl_cb_ident);
    1719                 :          0 : }
    1720                 :            : 
    1721                 :          0 : static void encode_setclientid_confirm(struct xdr_stream *xdr, const struct nfs4_setclientid_res *arg, struct compound_hdr *hdr)
    1722                 :            : {
    1723                 :            :         encode_op_hdr(xdr, OP_SETCLIENTID_CONFIRM,
    1724                 :            :                         decode_setclientid_confirm_maxsz, hdr);
    1725                 :          0 :         encode_uint64(xdr, arg->clientid);
    1726                 :            :         encode_nfs4_verifier(xdr, &arg->confirm);
    1727                 :          0 : }
    1728                 :            : 
    1729                 :          0 : static void encode_write(struct xdr_stream *xdr, const struct nfs_pgio_args *args,
    1730                 :            :                          struct compound_hdr *hdr)
    1731                 :            : {
    1732                 :            :         __be32 *p;
    1733                 :            : 
    1734                 :            :         encode_op_hdr(xdr, OP_WRITE, decode_write_maxsz, hdr);
    1735                 :          0 :         encode_nfs4_stateid(xdr, &args->stateid);
    1736                 :            : 
    1737                 :          0 :         p = reserve_space(xdr, 16);
    1738                 :          0 :         p = xdr_encode_hyper(p, args->offset);
    1739                 :          0 :         *p++ = cpu_to_be32(args->stable);
    1740                 :          0 :         *p = cpu_to_be32(args->count);
    1741                 :            : 
    1742                 :          0 :         xdr_write_pages(xdr, args->pages, args->pgbase, args->count);
    1743                 :          0 : }
    1744                 :            : 
    1745                 :          0 : static void encode_delegreturn(struct xdr_stream *xdr, const nfs4_stateid *stateid, struct compound_hdr *hdr)
    1746                 :            : {
    1747                 :            :         encode_op_hdr(xdr, OP_DELEGRETURN, decode_delegreturn_maxsz, hdr);
    1748                 :            :         encode_nfs4_stateid(xdr, stateid);
    1749                 :          0 : }
    1750                 :            : 
    1751                 :          0 : static void encode_secinfo(struct xdr_stream *xdr, const struct qstr *name, struct compound_hdr *hdr)
    1752                 :            : {
    1753                 :            :         encode_op_hdr(xdr, OP_SECINFO, decode_secinfo_maxsz, hdr);
    1754                 :          0 :         encode_string(xdr, name->len, name->name);
    1755                 :          0 : }
    1756                 :            : 
    1757                 :            : #if defined(CONFIG_NFS_V4_1)
    1758                 :            : /* NFSv4.1 operations */
    1759                 :          0 : static void encode_bind_conn_to_session(struct xdr_stream *xdr,
    1760                 :            :                                    const struct nfs41_bind_conn_to_session_args *args,
    1761                 :            :                                    struct compound_hdr *hdr)
    1762                 :            : {
    1763                 :            :         __be32 *p;
    1764                 :            : 
    1765                 :            :         encode_op_hdr(xdr, OP_BIND_CONN_TO_SESSION,
    1766                 :            :                 decode_bind_conn_to_session_maxsz, hdr);
    1767                 :          0 :         encode_opaque_fixed(xdr, args->sessionid.data, NFS4_MAX_SESSIONID_LEN);
    1768                 :          0 :         p = xdr_reserve_space(xdr, 8);
    1769                 :          0 :         *p++ = cpu_to_be32(args->dir);
    1770                 :          0 :         *p = (args->use_conn_in_rdma_mode) ? cpu_to_be32(1) : cpu_to_be32(0);
    1771                 :          0 : }
    1772                 :            : 
    1773                 :          0 : static void encode_op_map(struct xdr_stream *xdr, const struct nfs4_op_map *op_map)
    1774                 :            : {
    1775                 :            :         unsigned int i;
    1776                 :          0 :         encode_uint32(xdr, NFS4_OP_MAP_NUM_WORDS);
    1777                 :          0 :         for (i = 0; i < NFS4_OP_MAP_NUM_WORDS; i++)
    1778                 :          0 :                 encode_uint32(xdr, op_map->u.words[i]);
    1779                 :          0 : }
    1780                 :            : 
    1781                 :          0 : static void encode_exchange_id(struct xdr_stream *xdr,
    1782                 :            :                                const struct nfs41_exchange_id_args *args,
    1783                 :            :                                struct compound_hdr *hdr)
    1784                 :            : {
    1785                 :            :         __be32 *p;
    1786                 :            :         char impl_name[IMPL_NAME_LIMIT];
    1787                 :            :         int len = 0;
    1788                 :            : 
    1789                 :            :         encode_op_hdr(xdr, OP_EXCHANGE_ID, decode_exchange_id_maxsz, hdr);
    1790                 :            :         encode_nfs4_verifier(xdr, &args->verifier);
    1791                 :            : 
    1792                 :          0 :         encode_string(xdr, strlen(args->client->cl_owner_id),
    1793                 :            :                         args->client->cl_owner_id);
    1794                 :            : 
    1795                 :          0 :         encode_uint32(xdr, args->flags);
    1796                 :          0 :         encode_uint32(xdr, args->state_protect.how);
    1797                 :            : 
    1798                 :          0 :         switch (args->state_protect.how) {
    1799                 :            :         case SP4_NONE:
    1800                 :            :                 break;
    1801                 :            :         case SP4_MACH_CRED:
    1802                 :          0 :                 encode_op_map(xdr, &args->state_protect.enforce);
    1803                 :          0 :                 encode_op_map(xdr, &args->state_protect.allow);
    1804                 :          0 :                 break;
    1805                 :            :         default:
    1806                 :          0 :                 WARN_ON_ONCE(1);
    1807                 :            :                 break;
    1808                 :            :         }
    1809                 :            : 
    1810                 :          0 :         if (send_implementation_id &&
    1811                 :          0 :             sizeof(CONFIG_NFS_V4_1_IMPLEMENTATION_ID_DOMAIN) > 1 &&
    1812                 :            :             sizeof(CONFIG_NFS_V4_1_IMPLEMENTATION_ID_DOMAIN)
    1813                 :            :                 <= sizeof(impl_name) + 1)
    1814                 :          0 :                 len = snprintf(impl_name, sizeof(impl_name), "%s %s %s %s",
    1815                 :          0 :                                utsname()->sysname, utsname()->release,
    1816                 :          0 :                                utsname()->version, utsname()->machine);
    1817                 :            : 
    1818                 :          0 :         if (len > 0) {
    1819                 :          0 :                 encode_uint32(xdr, 1);  /* implementation id array length=1 */
    1820                 :            : 
    1821                 :          0 :                 encode_string(xdr,
    1822                 :            :                         sizeof(CONFIG_NFS_V4_1_IMPLEMENTATION_ID_DOMAIN) - 1,
    1823                 :            :                         CONFIG_NFS_V4_1_IMPLEMENTATION_ID_DOMAIN);
    1824                 :          0 :                 encode_string(xdr, len, impl_name);
    1825                 :            :                 /* just send zeros for nii_date - the date is in nii_name */
    1826                 :          0 :                 p = reserve_space(xdr, 12);
    1827                 :            :                 p = xdr_encode_hyper(p, 0);
    1828                 :          0 :                 *p = cpu_to_be32(0);
    1829                 :            :         } else
    1830                 :          0 :                 encode_uint32(xdr, 0);  /* implementation id array length=0 */
    1831                 :          0 : }
    1832                 :            : 
    1833                 :          0 : static void encode_create_session(struct xdr_stream *xdr,
    1834                 :            :                                   const struct nfs41_create_session_args *args,
    1835                 :            :                                   struct compound_hdr *hdr)
    1836                 :            : {
    1837                 :            :         __be32 *p;
    1838                 :          0 :         struct nfs_client *clp = args->client;
    1839                 :          0 :         struct rpc_clnt *clnt = clp->cl_rpcclient;
    1840                 :          0 :         struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
    1841                 :            :         u32 max_resp_sz_cached;
    1842                 :            : 
    1843                 :            :         /*
    1844                 :            :          * Assumes OPEN is the biggest non-idempotent compound.
    1845                 :            :          * 2 is the verifier.
    1846                 :            :          */
    1847                 :            :         max_resp_sz_cached = (NFS4_dec_open_sz + RPC_REPHDRSIZE + 2)
    1848                 :            :                                 * XDR_UNIT + RPC_MAX_AUTH_SIZE;
    1849                 :            : 
    1850                 :            :         encode_op_hdr(xdr, OP_CREATE_SESSION, decode_create_session_maxsz, hdr);
    1851                 :          0 :         p = reserve_space(xdr, 16 + 2*28 + 20 + clnt->cl_nodelen + 12);
    1852                 :          0 :         p = xdr_encode_hyper(p, args->clientid);
    1853                 :          0 :         *p++ = cpu_to_be32(args->seqid);                     /*Sequence id */
    1854                 :          0 :         *p++ = cpu_to_be32(args->flags);                     /*flags */
    1855                 :            : 
    1856                 :            :         /* Fore Channel */
    1857                 :          0 :         *p++ = cpu_to_be32(0);                          /* header padding size */
    1858                 :          0 :         *p++ = cpu_to_be32(args->fc_attrs.max_rqst_sz);      /* max req size */
    1859                 :          0 :         *p++ = cpu_to_be32(args->fc_attrs.max_resp_sz);      /* max resp size */
    1860                 :          0 :         *p++ = cpu_to_be32(max_resp_sz_cached);         /* Max resp sz cached */
    1861                 :          0 :         *p++ = cpu_to_be32(args->fc_attrs.max_ops);  /* max operations */
    1862                 :          0 :         *p++ = cpu_to_be32(args->fc_attrs.max_reqs); /* max requests */
    1863                 :          0 :         *p++ = cpu_to_be32(0);                          /* rdmachannel_attrs */
    1864                 :            : 
    1865                 :            :         /* Back Channel */
    1866                 :          0 :         *p++ = cpu_to_be32(0);                          /* header padding size */
    1867                 :          0 :         *p++ = cpu_to_be32(args->bc_attrs.max_rqst_sz);      /* max req size */
    1868                 :          0 :         *p++ = cpu_to_be32(args->bc_attrs.max_resp_sz);      /* max resp size */
    1869                 :          0 :         *p++ = cpu_to_be32(args->bc_attrs.max_resp_sz_cached);       /* Max resp sz cached */
    1870                 :          0 :         *p++ = cpu_to_be32(args->bc_attrs.max_ops);  /* max operations */
    1871                 :          0 :         *p++ = cpu_to_be32(args->bc_attrs.max_reqs); /* max requests */
    1872                 :          0 :         *p++ = cpu_to_be32(0);                          /* rdmachannel_attrs */
    1873                 :            : 
    1874                 :          0 :         *p++ = cpu_to_be32(args->cb_program);                /* cb_program */
    1875                 :          0 :         *p++ = cpu_to_be32(1);
    1876                 :          0 :         *p++ = cpu_to_be32(RPC_AUTH_UNIX);                      /* auth_sys */
    1877                 :            : 
    1878                 :            :         /* authsys_parms rfc1831 */
    1879                 :          0 :         *p++ = cpu_to_be32(ktime_to_ns(nn->boot_time));      /* stamp */
    1880                 :          0 :         p = xdr_encode_array(p, clnt->cl_nodename, clnt->cl_nodelen);
    1881                 :          0 :         *p++ = cpu_to_be32(0);                          /* UID */
    1882                 :          0 :         *p++ = cpu_to_be32(0);                          /* GID */
    1883                 :          0 :         *p = cpu_to_be32(0);                            /* No more gids */
    1884                 :          0 : }
    1885                 :            : 
    1886                 :          0 : static void encode_destroy_session(struct xdr_stream *xdr,
    1887                 :            :                                    const struct nfs4_session *session,
    1888                 :            :                                    struct compound_hdr *hdr)
    1889                 :            : {
    1890                 :            :         encode_op_hdr(xdr, OP_DESTROY_SESSION, decode_destroy_session_maxsz, hdr);
    1891                 :          0 :         encode_opaque_fixed(xdr, session->sess_id.data, NFS4_MAX_SESSIONID_LEN);
    1892                 :          0 : }
    1893                 :            : 
    1894                 :          0 : static void encode_destroy_clientid(struct xdr_stream *xdr,
    1895                 :            :                                    uint64_t clientid,
    1896                 :            :                                    struct compound_hdr *hdr)
    1897                 :            : {
    1898                 :            :         encode_op_hdr(xdr, OP_DESTROY_CLIENTID, decode_destroy_clientid_maxsz, hdr);
    1899                 :          0 :         encode_uint64(xdr, clientid);
    1900                 :          0 : }
    1901                 :            : 
    1902                 :          0 : static void encode_reclaim_complete(struct xdr_stream *xdr,
    1903                 :            :                                     const struct nfs41_reclaim_complete_args *args,
    1904                 :            :                                     struct compound_hdr *hdr)
    1905                 :            : {
    1906                 :            :         encode_op_hdr(xdr, OP_RECLAIM_COMPLETE, decode_reclaim_complete_maxsz, hdr);
    1907                 :          0 :         encode_uint32(xdr, args->one_fs);
    1908                 :          0 : }
    1909                 :            : #endif /* CONFIG_NFS_V4_1 */
    1910                 :            : 
    1911                 :          0 : static void encode_sequence(struct xdr_stream *xdr,
    1912                 :            :                             const struct nfs4_sequence_args *args,
    1913                 :            :                             struct compound_hdr *hdr)
    1914                 :            : {
    1915                 :            : #if defined(CONFIG_NFS_V4_1)
    1916                 :            :         struct nfs4_session *session;
    1917                 :            :         struct nfs4_slot_table *tp;
    1918                 :          0 :         struct nfs4_slot *slot = args->sa_slot;
    1919                 :            :         __be32 *p;
    1920                 :            : 
    1921                 :          0 :         tp = slot->table;
    1922                 :          0 :         session = tp->session;
    1923                 :          0 :         if (!session)
    1924                 :          0 :                 return;
    1925                 :            : 
    1926                 :            :         encode_op_hdr(xdr, OP_SEQUENCE, decode_sequence_maxsz, hdr);
    1927                 :            : 
    1928                 :            :         /*
    1929                 :            :          * Sessionid + seqid + slotid + max slotid + cache_this
    1930                 :            :          */
    1931                 :            :         dprintk("%s: sessionid=%u:%u:%u:%u seqid=%d slotid=%d "
    1932                 :            :                 "max_slotid=%d cache_this=%d\n",
    1933                 :            :                 __func__,
    1934                 :            :                 ((u32 *)session->sess_id.data)[0],
    1935                 :            :                 ((u32 *)session->sess_id.data)[1],
    1936                 :            :                 ((u32 *)session->sess_id.data)[2],
    1937                 :            :                 ((u32 *)session->sess_id.data)[3],
    1938                 :            :                 slot->seq_nr, slot->slot_nr,
    1939                 :            :                 tp->highest_used_slotid, args->sa_cache_this);
    1940                 :          0 :         p = reserve_space(xdr, NFS4_MAX_SESSIONID_LEN + 16);
    1941                 :          0 :         p = xdr_encode_opaque_fixed(p, session->sess_id.data, NFS4_MAX_SESSIONID_LEN);
    1942                 :          0 :         *p++ = cpu_to_be32(slot->seq_nr);
    1943                 :          0 :         *p++ = cpu_to_be32(slot->slot_nr);
    1944                 :          0 :         *p++ = cpu_to_be32(tp->highest_used_slotid);
    1945                 :          0 :         *p = cpu_to_be32(args->sa_cache_this);
    1946                 :            : #endif /* CONFIG_NFS_V4_1 */
    1947                 :            : }
    1948                 :            : 
    1949                 :            : #ifdef CONFIG_NFS_V4_1
    1950                 :            : static void
    1951                 :          0 : encode_getdeviceinfo(struct xdr_stream *xdr,
    1952                 :            :                      const struct nfs4_getdeviceinfo_args *args,
    1953                 :            :                      struct compound_hdr *hdr)
    1954                 :            : {
    1955                 :            :         __be32 *p;
    1956                 :            : 
    1957                 :            :         encode_op_hdr(xdr, OP_GETDEVICEINFO, decode_getdeviceinfo_maxsz, hdr);
    1958                 :          0 :         p = reserve_space(xdr, NFS4_DEVICEID4_SIZE + 4 + 4);
    1959                 :          0 :         p = xdr_encode_opaque_fixed(p, args->pdev->dev_id.data,
    1960                 :            :                                     NFS4_DEVICEID4_SIZE);
    1961                 :          0 :         *p++ = cpu_to_be32(args->pdev->layout_type);
    1962                 :          0 :         *p++ = cpu_to_be32(args->pdev->maxcount); /* gdia_maxcount */
    1963                 :            : 
    1964                 :          0 :         p = reserve_space(xdr, 4 + 4);
    1965                 :          0 :         *p++ = cpu_to_be32(1);                  /* bitmap length */
    1966                 :          0 :         *p++ = cpu_to_be32(args->notify_types);
    1967                 :          0 : }
    1968                 :            : 
    1969                 :            : static void
    1970                 :          0 : encode_layoutget(struct xdr_stream *xdr,
    1971                 :            :                       const struct nfs4_layoutget_args *args,
    1972                 :            :                       struct compound_hdr *hdr)
    1973                 :            : {
    1974                 :            :         __be32 *p;
    1975                 :            : 
    1976                 :            :         encode_op_hdr(xdr, OP_LAYOUTGET, decode_layoutget_maxsz, hdr);
    1977                 :          0 :         p = reserve_space(xdr, 36);
    1978                 :          0 :         *p++ = cpu_to_be32(0);     /* Signal layout available */
    1979                 :          0 :         *p++ = cpu_to_be32(args->type);
    1980                 :          0 :         *p++ = cpu_to_be32(args->range.iomode);
    1981                 :          0 :         p = xdr_encode_hyper(p, args->range.offset);
    1982                 :          0 :         p = xdr_encode_hyper(p, args->range.length);
    1983                 :          0 :         p = xdr_encode_hyper(p, args->minlength);
    1984                 :          0 :         encode_nfs4_stateid(xdr, &args->stateid);
    1985                 :          0 :         encode_uint32(xdr, args->maxcount);
    1986                 :            : 
    1987                 :            :         dprintk("%s: 1st type:0x%x iomode:%d off:%lu len:%lu mc:%d\n",
    1988                 :            :                 __func__,
    1989                 :            :                 args->type,
    1990                 :            :                 args->range.iomode,
    1991                 :            :                 (unsigned long)args->range.offset,
    1992                 :            :                 (unsigned long)args->range.length,
    1993                 :            :                 args->maxcount);
    1994                 :          0 : }
    1995                 :            : 
    1996                 :            : static int
    1997                 :          0 : encode_layoutcommit(struct xdr_stream *xdr,
    1998                 :            :                     struct inode *inode,
    1999                 :            :                     const struct nfs4_layoutcommit_args *args,
    2000                 :            :                     struct compound_hdr *hdr)
    2001                 :            : {
    2002                 :            :         __be32 *p;
    2003                 :            : 
    2004                 :            :         dprintk("%s: lbw: %llu type: %d\n", __func__, args->lastbytewritten,
    2005                 :            :                 NFS_SERVER(args->inode)->pnfs_curr_ld->id);
    2006                 :            : 
    2007                 :            :         encode_op_hdr(xdr, OP_LAYOUTCOMMIT, decode_layoutcommit_maxsz, hdr);
    2008                 :          0 :         p = reserve_space(xdr, 20);
    2009                 :            :         /* Only whole file layouts */
    2010                 :            :         p = xdr_encode_hyper(p, 0); /* offset */
    2011                 :          0 :         p = xdr_encode_hyper(p, args->lastbytewritten + 1);  /* length */
    2012                 :          0 :         *p = cpu_to_be32(0); /* reclaim */
    2013                 :          0 :         encode_nfs4_stateid(xdr, &args->stateid);
    2014                 :          0 :         if (args->lastbytewritten != U64_MAX) {
    2015                 :          0 :                 p = reserve_space(xdr, 20);
    2016                 :          0 :                 *p++ = cpu_to_be32(1); /* newoffset = TRUE */
    2017                 :          0 :                 p = xdr_encode_hyper(p, args->lastbytewritten);
    2018                 :            :         } else {
    2019                 :          0 :                 p = reserve_space(xdr, 12);
    2020                 :          0 :                 *p++ = cpu_to_be32(0); /* newoffset = FALSE */
    2021                 :            :         }
    2022                 :          0 :         *p++ = cpu_to_be32(0); /* Never send time_modify_changed */
    2023                 :          0 :         *p++ = cpu_to_be32(NFS_SERVER(args->inode)->pnfs_curr_ld->id);/* type */
    2024                 :            : 
    2025                 :          0 :         encode_uint32(xdr, args->layoutupdate_len);
    2026                 :          0 :         if (args->layoutupdate_pages)
    2027                 :          0 :                 xdr_write_pages(xdr, args->layoutupdate_pages, 0,
    2028                 :            :                                 args->layoutupdate_len);
    2029                 :            : 
    2030                 :          0 :         return 0;
    2031                 :            : }
    2032                 :            : 
    2033                 :            : static void
    2034                 :          0 : encode_layoutreturn(struct xdr_stream *xdr,
    2035                 :            :                     const struct nfs4_layoutreturn_args *args,
    2036                 :            :                     struct compound_hdr *hdr)
    2037                 :            : {
    2038                 :            :         __be32 *p;
    2039                 :            : 
    2040                 :            :         encode_op_hdr(xdr, OP_LAYOUTRETURN, decode_layoutreturn_maxsz, hdr);
    2041                 :          0 :         p = reserve_space(xdr, 16);
    2042                 :          0 :         *p++ = cpu_to_be32(0);          /* reclaim. always 0 for now */
    2043                 :          0 :         *p++ = cpu_to_be32(args->layout_type);
    2044                 :          0 :         *p++ = cpu_to_be32(args->range.iomode);
    2045                 :          0 :         *p = cpu_to_be32(RETURN_FILE);
    2046                 :          0 :         p = reserve_space(xdr, 16);
    2047                 :          0 :         p = xdr_encode_hyper(p, args->range.offset);
    2048                 :          0 :         p = xdr_encode_hyper(p, args->range.length);
    2049                 :          0 :         spin_lock(&args->inode->i_lock);
    2050                 :          0 :         encode_nfs4_stateid(xdr, &args->stateid);
    2051                 :          0 :         spin_unlock(&args->inode->i_lock);
    2052                 :          0 :         if (args->ld_private->ops && args->ld_private->ops->encode)
    2053                 :          0 :                 args->ld_private->ops->encode(xdr, args, args->ld_private);
    2054                 :            :         else
    2055                 :          0 :                 encode_uint32(xdr, 0);
    2056                 :          0 : }
    2057                 :            : 
    2058                 :            : static int
    2059                 :          0 : encode_secinfo_no_name(struct xdr_stream *xdr,
    2060                 :            :                        const struct nfs41_secinfo_no_name_args *args,
    2061                 :            :                        struct compound_hdr *hdr)
    2062                 :            : {
    2063                 :            :         encode_op_hdr(xdr, OP_SECINFO_NO_NAME, decode_secinfo_no_name_maxsz, hdr);
    2064                 :          0 :         encode_uint32(xdr, args->style);
    2065                 :          0 :         return 0;
    2066                 :            : }
    2067                 :            : 
    2068                 :          0 : static void encode_test_stateid(struct xdr_stream *xdr,
    2069                 :            :                                 const struct nfs41_test_stateid_args *args,
    2070                 :            :                                 struct compound_hdr *hdr)
    2071                 :            : {
    2072                 :            :         encode_op_hdr(xdr, OP_TEST_STATEID, decode_test_stateid_maxsz, hdr);
    2073                 :          0 :         encode_uint32(xdr, 1);
    2074                 :          0 :         encode_nfs4_stateid(xdr, args->stateid);
    2075                 :          0 : }
    2076                 :            : 
    2077                 :          0 : static void encode_free_stateid(struct xdr_stream *xdr,
    2078                 :            :                                 const struct nfs41_free_stateid_args *args,
    2079                 :            :                                 struct compound_hdr *hdr)
    2080                 :            : {
    2081                 :            :         encode_op_hdr(xdr, OP_FREE_STATEID, decode_free_stateid_maxsz, hdr);
    2082                 :          0 :         encode_nfs4_stateid(xdr, &args->stateid);
    2083                 :          0 : }
    2084                 :            : #else
    2085                 :            : static inline void
    2086                 :            : encode_layoutreturn(struct xdr_stream *xdr,
    2087                 :            :                     const struct nfs4_layoutreturn_args *args,
    2088                 :            :                     struct compound_hdr *hdr)
    2089                 :            : {
    2090                 :            : }
    2091                 :            : 
    2092                 :            : static void
    2093                 :            : encode_layoutget(struct xdr_stream *xdr,
    2094                 :            :                       const struct nfs4_layoutget_args *args,
    2095                 :            :                       struct compound_hdr *hdr)
    2096                 :            : {
    2097                 :            : }
    2098                 :            : #endif /* CONFIG_NFS_V4_1 */
    2099                 :            : 
    2100                 :            : /*
    2101                 :            :  * END OF "GENERIC" ENCODE ROUTINES.
    2102                 :            :  */
    2103                 :            : 
    2104                 :            : static u32 nfs4_xdr_minorversion(const struct nfs4_sequence_args *args)
    2105                 :            : {
    2106                 :            : #if defined(CONFIG_NFS_V4_1)
    2107                 :          0 :         struct nfs4_session *session = args->sa_slot->table->session;
    2108                 :          0 :         if (session)
    2109                 :          0 :                 return session->clp->cl_mvops->minor_version;
    2110                 :            : #endif /* CONFIG_NFS_V4_1 */
    2111                 :            :         return 0;
    2112                 :            : }
    2113                 :            : 
    2114                 :            : /*
    2115                 :            :  * Encode an ACCESS request
    2116                 :            :  */
    2117                 :          0 : static void nfs4_xdr_enc_access(struct rpc_rqst *req, struct xdr_stream *xdr,
    2118                 :            :                                 const void *data)
    2119                 :            : {
    2120                 :            :         const struct nfs4_accessargs *args = data;
    2121                 :          0 :         struct compound_hdr hdr = {
    2122                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2123                 :            :         };
    2124                 :            : 
    2125                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2126                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2127                 :          0 :         encode_putfh(xdr, args->fh, &hdr);
    2128                 :          0 :         encode_access(xdr, args->access, &hdr);
    2129                 :          0 :         if (args->bitmask)
    2130                 :            :                 encode_getfattr(xdr, args->bitmask, &hdr);
    2131                 :          0 :         encode_nops(&hdr);
    2132                 :          0 : }
    2133                 :            : 
    2134                 :            : /*
    2135                 :            :  * Encode LOOKUP request
    2136                 :            :  */
    2137                 :          0 : static void nfs4_xdr_enc_lookup(struct rpc_rqst *req, struct xdr_stream *xdr,
    2138                 :            :                                 const void *data)
    2139                 :            : {
    2140                 :            :         const struct nfs4_lookup_arg *args = data;
    2141                 :          0 :         struct compound_hdr hdr = {
    2142                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2143                 :            :         };
    2144                 :            : 
    2145                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2146                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2147                 :          0 :         encode_putfh(xdr, args->dir_fh, &hdr);
    2148                 :          0 :         encode_lookup(xdr, args->name, &hdr);
    2149                 :            :         encode_getfh(xdr, &hdr);
    2150                 :          0 :         encode_getfattr(xdr, args->bitmask, &hdr);
    2151                 :          0 :         encode_nops(&hdr);
    2152                 :          0 : }
    2153                 :            : 
    2154                 :            : /*
    2155                 :            :  * Encode LOOKUPP request
    2156                 :            :  */
    2157                 :          0 : static void nfs4_xdr_enc_lookupp(struct rpc_rqst *req, struct xdr_stream *xdr,
    2158                 :            :                 const void *data)
    2159                 :            : {
    2160                 :            :         const struct nfs4_lookupp_arg *args = data;
    2161                 :          0 :         struct compound_hdr hdr = {
    2162                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2163                 :            :         };
    2164                 :            : 
    2165                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2166                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2167                 :          0 :         encode_putfh(xdr, args->fh, &hdr);
    2168                 :            :         encode_lookupp(xdr, &hdr);
    2169                 :            :         encode_getfh(xdr, &hdr);
    2170                 :          0 :         encode_getfattr(xdr, args->bitmask, &hdr);
    2171                 :          0 :         encode_nops(&hdr);
    2172                 :          0 : }
    2173                 :            : 
    2174                 :            : /*
    2175                 :            :  * Encode LOOKUP_ROOT request
    2176                 :            :  */
    2177                 :          0 : static void nfs4_xdr_enc_lookup_root(struct rpc_rqst *req,
    2178                 :            :                                      struct xdr_stream *xdr,
    2179                 :            :                                      const void *data)
    2180                 :            : {
    2181                 :            :         const struct nfs4_lookup_root_arg *args = data;
    2182                 :          0 :         struct compound_hdr hdr = {
    2183                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2184                 :            :         };
    2185                 :            : 
    2186                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2187                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2188                 :            :         encode_putrootfh(xdr, &hdr);
    2189                 :            :         encode_getfh(xdr, &hdr);
    2190                 :          0 :         encode_getfattr(xdr, args->bitmask, &hdr);
    2191                 :          0 :         encode_nops(&hdr);
    2192                 :          0 : }
    2193                 :            : 
    2194                 :            : /*
    2195                 :            :  * Encode REMOVE request
    2196                 :            :  */
    2197                 :          0 : static void nfs4_xdr_enc_remove(struct rpc_rqst *req, struct xdr_stream *xdr,
    2198                 :            :                                 const void *data)
    2199                 :            : {
    2200                 :            :         const struct nfs_removeargs *args = data;
    2201                 :          0 :         struct compound_hdr hdr = {
    2202                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2203                 :            :         };
    2204                 :            : 
    2205                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2206                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2207                 :          0 :         encode_putfh(xdr, args->fh, &hdr);
    2208                 :          0 :         encode_remove(xdr, &args->name, &hdr);
    2209                 :          0 :         encode_nops(&hdr);
    2210                 :          0 : }
    2211                 :            : 
    2212                 :            : /*
    2213                 :            :  * Encode RENAME request
    2214                 :            :  */
    2215                 :          0 : static void nfs4_xdr_enc_rename(struct rpc_rqst *req, struct xdr_stream *xdr,
    2216                 :            :                                 const void *data)
    2217                 :            : {
    2218                 :            :         const struct nfs_renameargs *args = data;
    2219                 :          0 :         struct compound_hdr hdr = {
    2220                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2221                 :            :         };
    2222                 :            : 
    2223                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2224                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2225                 :          0 :         encode_putfh(xdr, args->old_dir, &hdr);
    2226                 :            :         encode_savefh(xdr, &hdr);
    2227                 :          0 :         encode_putfh(xdr, args->new_dir, &hdr);
    2228                 :          0 :         encode_rename(xdr, args->old_name, args->new_name, &hdr);
    2229                 :          0 :         encode_nops(&hdr);
    2230                 :          0 : }
    2231                 :            : 
    2232                 :            : /*
    2233                 :            :  * Encode LINK request
    2234                 :            :  */
    2235                 :          0 : static void nfs4_xdr_enc_link(struct rpc_rqst *req, struct xdr_stream *xdr,
    2236                 :            :                               const void *data)
    2237                 :            : {
    2238                 :            :         const struct nfs4_link_arg *args = data;
    2239                 :          0 :         struct compound_hdr hdr = {
    2240                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2241                 :            :         };
    2242                 :            : 
    2243                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2244                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2245                 :          0 :         encode_putfh(xdr, args->fh, &hdr);
    2246                 :            :         encode_savefh(xdr, &hdr);
    2247                 :          0 :         encode_putfh(xdr, args->dir_fh, &hdr);
    2248                 :          0 :         encode_link(xdr, args->name, &hdr);
    2249                 :            :         encode_restorefh(xdr, &hdr);
    2250                 :          0 :         encode_getfattr(xdr, args->bitmask, &hdr);
    2251                 :          0 :         encode_nops(&hdr);
    2252                 :          0 : }
    2253                 :            : 
    2254                 :            : /*
    2255                 :            :  * Encode CREATE request
    2256                 :            :  */
    2257                 :          0 : static void nfs4_xdr_enc_create(struct rpc_rqst *req, struct xdr_stream *xdr,
    2258                 :            :                                 const void *data)
    2259                 :            : {
    2260                 :            :         const struct nfs4_create_arg *args = data;
    2261                 :          0 :         struct compound_hdr hdr = {
    2262                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2263                 :            :         };
    2264                 :            : 
    2265                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2266                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2267                 :          0 :         encode_putfh(xdr, args->dir_fh, &hdr);
    2268                 :          0 :         encode_create(xdr, args, &hdr);
    2269                 :            :         encode_getfh(xdr, &hdr);
    2270                 :          0 :         encode_getfattr(xdr, args->bitmask, &hdr);
    2271                 :          0 :         encode_nops(&hdr);
    2272                 :          0 : }
    2273                 :            : 
    2274                 :            : /*
    2275                 :            :  * Encode SYMLINK request
    2276                 :            :  */
    2277                 :          0 : static void nfs4_xdr_enc_symlink(struct rpc_rqst *req, struct xdr_stream *xdr,
    2278                 :            :                                  const void *data)
    2279                 :            : {
    2280                 :            :         const struct nfs4_create_arg *args = data;
    2281                 :            : 
    2282                 :          0 :         nfs4_xdr_enc_create(req, xdr, args);
    2283                 :          0 : }
    2284                 :            : 
    2285                 :            : /*
    2286                 :            :  * Encode GETATTR request
    2287                 :            :  */
    2288                 :          0 : static void nfs4_xdr_enc_getattr(struct rpc_rqst *req, struct xdr_stream *xdr,
    2289                 :            :                                  const void *data)
    2290                 :            : {
    2291                 :            :         const struct nfs4_getattr_arg *args = data;
    2292                 :          0 :         struct compound_hdr hdr = {
    2293                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2294                 :            :         };
    2295                 :            : 
    2296                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2297                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2298                 :          0 :         encode_putfh(xdr, args->fh, &hdr);
    2299                 :          0 :         encode_getfattr(xdr, args->bitmask, &hdr);
    2300                 :          0 :         encode_nops(&hdr);
    2301                 :          0 : }
    2302                 :            : 
    2303                 :            : /*
    2304                 :            :  * Encode a CLOSE request
    2305                 :            :  */
    2306                 :          0 : static void nfs4_xdr_enc_close(struct rpc_rqst *req, struct xdr_stream *xdr,
    2307                 :            :                                const void *data)
    2308                 :            : {
    2309                 :            :         const struct nfs_closeargs *args = data;
    2310                 :          0 :         struct compound_hdr hdr = {
    2311                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2312                 :            :         };
    2313                 :            : 
    2314                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2315                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2316                 :          0 :         encode_putfh(xdr, args->fh, &hdr);
    2317                 :          0 :         if (args->lr_args)
    2318                 :          0 :                 encode_layoutreturn(xdr, args->lr_args, &hdr);
    2319                 :          0 :         if (args->bitmask != NULL)
    2320                 :            :                 encode_getfattr(xdr, args->bitmask, &hdr);
    2321                 :          0 :         encode_close(xdr, args, &hdr);
    2322                 :          0 :         encode_nops(&hdr);
    2323                 :          0 : }
    2324                 :            : 
    2325                 :            : /*
    2326                 :            :  * Encode an OPEN request
    2327                 :            :  */
    2328                 :          0 : static void nfs4_xdr_enc_open(struct rpc_rqst *req, struct xdr_stream *xdr,
    2329                 :            :                               const void *data)
    2330                 :            : {
    2331                 :            :         const struct nfs_openargs *args = data;
    2332                 :          0 :         struct compound_hdr hdr = {
    2333                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2334                 :            :         };
    2335                 :            : 
    2336                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2337                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2338                 :          0 :         encode_putfh(xdr, args->fh, &hdr);
    2339                 :          0 :         encode_open(xdr, args, &hdr);
    2340                 :            :         encode_getfh(xdr, &hdr);
    2341                 :          0 :         if (args->access)
    2342                 :          0 :                 encode_access(xdr, args->access, &hdr);
    2343                 :          0 :         encode_getfattr_open(xdr, args->bitmask, args->open_bitmap, &hdr);
    2344                 :          0 :         if (args->lg_args) {
    2345                 :          0 :                 encode_layoutget(xdr, args->lg_args, &hdr);
    2346                 :          0 :                 rpc_prepare_reply_pages(req, args->lg_args->layout.pages, 0,
    2347                 :            :                                         args->lg_args->layout.pglen,
    2348                 :            :                                         hdr.replen);
    2349                 :            :         }
    2350                 :          0 :         encode_nops(&hdr);
    2351                 :          0 : }
    2352                 :            : 
    2353                 :            : /*
    2354                 :            :  * Encode an OPEN_CONFIRM request
    2355                 :            :  */
    2356                 :          0 : static void nfs4_xdr_enc_open_confirm(struct rpc_rqst *req,
    2357                 :            :                                       struct xdr_stream *xdr,
    2358                 :            :                                       const void *data)
    2359                 :            : {
    2360                 :            :         const struct nfs_open_confirmargs *args = data;
    2361                 :          0 :         struct compound_hdr hdr = {
    2362                 :            :                 .nops   = 0,
    2363                 :            :         };
    2364                 :            : 
    2365                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2366                 :          0 :         encode_putfh(xdr, args->fh, &hdr);
    2367                 :          0 :         encode_open_confirm(xdr, args, &hdr);
    2368                 :          0 :         encode_nops(&hdr);
    2369                 :          0 : }
    2370                 :            : 
    2371                 :            : /*
    2372                 :            :  * Encode an OPEN request with no attributes.
    2373                 :            :  */
    2374                 :          0 : static void nfs4_xdr_enc_open_noattr(struct rpc_rqst *req,
    2375                 :            :                                      struct xdr_stream *xdr,
    2376                 :            :                                      const void *data)
    2377                 :            : {
    2378                 :            :         const struct nfs_openargs *args = data;
    2379                 :          0 :         struct compound_hdr hdr = {
    2380                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2381                 :            :         };
    2382                 :            : 
    2383                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2384                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2385                 :          0 :         encode_putfh(xdr, args->fh, &hdr);
    2386                 :          0 :         encode_open(xdr, args, &hdr);
    2387                 :          0 :         if (args->access)
    2388                 :          0 :                 encode_access(xdr, args->access, &hdr);
    2389                 :          0 :         encode_getfattr_open(xdr, args->bitmask, args->open_bitmap, &hdr);
    2390                 :          0 :         if (args->lg_args) {
    2391                 :          0 :                 encode_layoutget(xdr, args->lg_args, &hdr);
    2392                 :          0 :                 rpc_prepare_reply_pages(req, args->lg_args->layout.pages, 0,
    2393                 :            :                                         args->lg_args->layout.pglen,
    2394                 :            :                                         hdr.replen);
    2395                 :            :         }
    2396                 :          0 :         encode_nops(&hdr);
    2397                 :          0 : }
    2398                 :            : 
    2399                 :            : /*
    2400                 :            :  * Encode an OPEN_DOWNGRADE request
    2401                 :            :  */
    2402                 :          0 : static void nfs4_xdr_enc_open_downgrade(struct rpc_rqst *req,
    2403                 :            :                                         struct xdr_stream *xdr,
    2404                 :            :                                         const void *data)
    2405                 :            : {
    2406                 :            :         const struct nfs_closeargs *args = data;
    2407                 :          0 :         struct compound_hdr hdr = {
    2408                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2409                 :            :         };
    2410                 :            : 
    2411                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2412                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2413                 :          0 :         encode_putfh(xdr, args->fh, &hdr);
    2414                 :          0 :         if (args->lr_args)
    2415                 :          0 :                 encode_layoutreturn(xdr, args->lr_args, &hdr);
    2416                 :          0 :         encode_open_downgrade(xdr, args, &hdr);
    2417                 :          0 :         encode_nops(&hdr);
    2418                 :          0 : }
    2419                 :            : 
    2420                 :            : /*
    2421                 :            :  * Encode a LOCK request
    2422                 :            :  */
    2423                 :          0 : static void nfs4_xdr_enc_lock(struct rpc_rqst *req, struct xdr_stream *xdr,
    2424                 :            :                               const void *data)
    2425                 :            : {
    2426                 :            :         const struct nfs_lock_args *args = data;
    2427                 :          0 :         struct compound_hdr hdr = {
    2428                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2429                 :            :         };
    2430                 :            : 
    2431                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2432                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2433                 :          0 :         encode_putfh(xdr, args->fh, &hdr);
    2434                 :          0 :         encode_lock(xdr, args, &hdr);
    2435                 :          0 :         encode_nops(&hdr);
    2436                 :          0 : }
    2437                 :            : 
    2438                 :            : /*
    2439                 :            :  * Encode a LOCKT request
    2440                 :            :  */
    2441                 :          0 : static void nfs4_xdr_enc_lockt(struct rpc_rqst *req, struct xdr_stream *xdr,
    2442                 :            :                                const void *data)
    2443                 :            : {
    2444                 :            :         const struct nfs_lockt_args *args = data;
    2445                 :          0 :         struct compound_hdr hdr = {
    2446                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2447                 :            :         };
    2448                 :            : 
    2449                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2450                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2451                 :          0 :         encode_putfh(xdr, args->fh, &hdr);
    2452                 :          0 :         encode_lockt(xdr, args, &hdr);
    2453                 :          0 :         encode_nops(&hdr);
    2454                 :          0 : }
    2455                 :            : 
    2456                 :            : /*
    2457                 :            :  * Encode a LOCKU request
    2458                 :            :  */
    2459                 :          0 : static void nfs4_xdr_enc_locku(struct rpc_rqst *req, struct xdr_stream *xdr,
    2460                 :            :                                const void *data)
    2461                 :            : {
    2462                 :            :         const struct nfs_locku_args *args = data;
    2463                 :          0 :         struct compound_hdr hdr = {
    2464                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2465                 :            :         };
    2466                 :            : 
    2467                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2468                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2469                 :          0 :         encode_putfh(xdr, args->fh, &hdr);
    2470                 :          0 :         encode_locku(xdr, args, &hdr);
    2471                 :          0 :         encode_nops(&hdr);
    2472                 :          0 : }
    2473                 :            : 
    2474                 :          0 : static void nfs4_xdr_enc_release_lockowner(struct rpc_rqst *req,
    2475                 :            :                                            struct xdr_stream *xdr,
    2476                 :            :                                            const void *data)
    2477                 :            : {
    2478                 :            :         const struct nfs_release_lockowner_args *args = data;
    2479                 :          0 :         struct compound_hdr hdr = {
    2480                 :            :                 .minorversion = 0,
    2481                 :            :         };
    2482                 :            : 
    2483                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2484                 :          0 :         encode_release_lockowner(xdr, &args->lock_owner, &hdr);
    2485                 :          0 :         encode_nops(&hdr);
    2486                 :          0 : }
    2487                 :            : 
    2488                 :            : /*
    2489                 :            :  * Encode a READLINK request
    2490                 :            :  */
    2491                 :          0 : static void nfs4_xdr_enc_readlink(struct rpc_rqst *req, struct xdr_stream *xdr,
    2492                 :            :                                   const void *data)
    2493                 :            : {
    2494                 :            :         const struct nfs4_readlink *args = data;
    2495                 :          0 :         struct compound_hdr hdr = {
    2496                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2497                 :            :         };
    2498                 :            : 
    2499                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2500                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2501                 :          0 :         encode_putfh(xdr, args->fh, &hdr);
    2502                 :            :         encode_readlink(xdr, args, req, &hdr);
    2503                 :            : 
    2504                 :          0 :         rpc_prepare_reply_pages(req, args->pages, args->pgbase,
    2505                 :            :                                 args->pglen, hdr.replen);
    2506                 :          0 :         encode_nops(&hdr);
    2507                 :          0 : }
    2508                 :            : 
    2509                 :            : /*
    2510                 :            :  * Encode a READDIR request
    2511                 :            :  */
    2512                 :          0 : static void nfs4_xdr_enc_readdir(struct rpc_rqst *req, struct xdr_stream *xdr,
    2513                 :            :                                  const void *data)
    2514                 :            : {
    2515                 :            :         const struct nfs4_readdir_arg *args = data;
    2516                 :          0 :         struct compound_hdr hdr = {
    2517                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2518                 :            :         };
    2519                 :            : 
    2520                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2521                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2522                 :          0 :         encode_putfh(xdr, args->fh, &hdr);
    2523                 :          0 :         encode_readdir(xdr, args, req, &hdr);
    2524                 :            : 
    2525                 :          0 :         rpc_prepare_reply_pages(req, args->pages, args->pgbase,
    2526                 :            :                                 args->count, hdr.replen);
    2527                 :          0 :         encode_nops(&hdr);
    2528                 :          0 : }
    2529                 :            : 
    2530                 :            : /*
    2531                 :            :  * Encode a READ request
    2532                 :            :  */
    2533                 :          0 : static void nfs4_xdr_enc_read(struct rpc_rqst *req, struct xdr_stream *xdr,
    2534                 :            :                               const void *data)
    2535                 :            : {
    2536                 :            :         const struct nfs_pgio_args *args = data;
    2537                 :          0 :         struct compound_hdr hdr = {
    2538                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2539                 :            :         };
    2540                 :            : 
    2541                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2542                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2543                 :          0 :         encode_putfh(xdr, args->fh, &hdr);
    2544                 :          0 :         encode_read(xdr, args, &hdr);
    2545                 :            : 
    2546                 :          0 :         rpc_prepare_reply_pages(req, args->pages, args->pgbase,
    2547                 :            :                                 args->count, hdr.replen);
    2548                 :          0 :         req->rq_rcv_buf.flags |= XDRBUF_READ;
    2549                 :          0 :         encode_nops(&hdr);
    2550                 :          0 : }
    2551                 :            : 
    2552                 :            : /*
    2553                 :            :  * Encode an SETATTR request
    2554                 :            :  */
    2555                 :          0 : static void nfs4_xdr_enc_setattr(struct rpc_rqst *req, struct xdr_stream *xdr,
    2556                 :            :                                  const void *data)
    2557                 :            : {
    2558                 :            :         const struct nfs_setattrargs *args = data;
    2559                 :          0 :         struct compound_hdr hdr = {
    2560                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2561                 :            :         };
    2562                 :            : 
    2563                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2564                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2565                 :          0 :         encode_putfh(xdr, args->fh, &hdr);
    2566                 :          0 :         encode_setattr(xdr, args, args->server, &hdr);
    2567                 :          0 :         encode_getfattr(xdr, args->bitmask, &hdr);
    2568                 :          0 :         encode_nops(&hdr);
    2569                 :          0 : }
    2570                 :            : 
    2571                 :            : /*
    2572                 :            :  * Encode a GETACL request
    2573                 :            :  */
    2574                 :          0 : static void nfs4_xdr_enc_getacl(struct rpc_rqst *req, struct xdr_stream *xdr,
    2575                 :            :                                 const void *data)
    2576                 :            : {
    2577                 :            :         const struct nfs_getaclargs *args = data;
    2578                 :          0 :         struct compound_hdr hdr = {
    2579                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2580                 :            :         };
    2581                 :          0 :         const __u32 nfs4_acl_bitmap[1] = {
    2582                 :            :                 [0] = FATTR4_WORD0_ACL,
    2583                 :            :         };
    2584                 :            :         uint32_t replen;
    2585                 :            : 
    2586                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2587                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2588                 :          0 :         encode_putfh(xdr, args->fh, &hdr);
    2589                 :          0 :         replen = hdr.replen + op_decode_hdr_maxsz;
    2590                 :          0 :         encode_getattr(xdr, nfs4_acl_bitmap, NULL,
    2591                 :            :                         ARRAY_SIZE(nfs4_acl_bitmap), &hdr);
    2592                 :            : 
    2593                 :          0 :         rpc_prepare_reply_pages(req, args->acl_pages, 0,
    2594                 :            :                                 args->acl_len, replen + 1);
    2595                 :          0 :         encode_nops(&hdr);
    2596                 :          0 : }
    2597                 :            : 
    2598                 :            : /*
    2599                 :            :  * Encode a WRITE request
    2600                 :            :  */
    2601                 :          0 : static void nfs4_xdr_enc_write(struct rpc_rqst *req, struct xdr_stream *xdr,
    2602                 :            :                                const void *data)
    2603                 :            : {
    2604                 :            :         const struct nfs_pgio_args *args = data;
    2605                 :          0 :         struct compound_hdr hdr = {
    2606                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2607                 :            :         };
    2608                 :            : 
    2609                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2610                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2611                 :          0 :         encode_putfh(xdr, args->fh, &hdr);
    2612                 :          0 :         encode_write(xdr, args, &hdr);
    2613                 :          0 :         req->rq_snd_buf.flags |= XDRBUF_WRITE;
    2614                 :          0 :         if (args->bitmask)
    2615                 :            :                 encode_getfattr(xdr, args->bitmask, &hdr);
    2616                 :          0 :         encode_nops(&hdr);
    2617                 :          0 : }
    2618                 :            : 
    2619                 :            : /*
    2620                 :            :  *  a COMMIT request
    2621                 :            :  */
    2622                 :          0 : static void nfs4_xdr_enc_commit(struct rpc_rqst *req, struct xdr_stream *xdr,
    2623                 :            :                                 const void *data)
    2624                 :            : {
    2625                 :            :         const struct nfs_commitargs *args = data;
    2626                 :          0 :         struct compound_hdr hdr = {
    2627                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2628                 :            :         };
    2629                 :            : 
    2630                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2631                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2632                 :          0 :         encode_putfh(xdr, args->fh, &hdr);
    2633                 :          0 :         encode_commit(xdr, args, &hdr);
    2634                 :          0 :         encode_nops(&hdr);
    2635                 :          0 : }
    2636                 :            : 
    2637                 :            : /*
    2638                 :            :  * FSINFO request
    2639                 :            :  */
    2640                 :          0 : static void nfs4_xdr_enc_fsinfo(struct rpc_rqst *req, struct xdr_stream *xdr,
    2641                 :            :                                 const void *data)
    2642                 :            : {
    2643                 :            :         const struct nfs4_fsinfo_arg *args = data;
    2644                 :          0 :         struct compound_hdr hdr = {
    2645                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2646                 :            :         };
    2647                 :            : 
    2648                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2649                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2650                 :          0 :         encode_putfh(xdr, args->fh, &hdr);
    2651                 :          0 :         encode_fsinfo(xdr, args->bitmask, &hdr);
    2652                 :          0 :         encode_nops(&hdr);
    2653                 :          0 : }
    2654                 :            : 
    2655                 :            : /*
    2656                 :            :  * a PATHCONF request
    2657                 :            :  */
    2658                 :          0 : static void nfs4_xdr_enc_pathconf(struct rpc_rqst *req, struct xdr_stream *xdr,
    2659                 :            :                                   const void *data)
    2660                 :            : {
    2661                 :            :         const struct nfs4_pathconf_arg *args = data;
    2662                 :          0 :         struct compound_hdr hdr = {
    2663                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2664                 :            :         };
    2665                 :            : 
    2666                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2667                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2668                 :          0 :         encode_putfh(xdr, args->fh, &hdr);
    2669                 :          0 :         encode_getattr(xdr, nfs4_pathconf_bitmap, args->bitmask,
    2670                 :            :                         ARRAY_SIZE(nfs4_pathconf_bitmap), &hdr);
    2671                 :          0 :         encode_nops(&hdr);
    2672                 :          0 : }
    2673                 :            : 
    2674                 :            : /*
    2675                 :            :  * a STATFS request
    2676                 :            :  */
    2677                 :          0 : static void nfs4_xdr_enc_statfs(struct rpc_rqst *req, struct xdr_stream *xdr,
    2678                 :            :                                 const void *data)
    2679                 :            : {
    2680                 :            :         const struct nfs4_statfs_arg *args = data;
    2681                 :          0 :         struct compound_hdr hdr = {
    2682                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2683                 :            :         };
    2684                 :            : 
    2685                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2686                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2687                 :          0 :         encode_putfh(xdr, args->fh, &hdr);
    2688                 :          0 :         encode_getattr(xdr, nfs4_statfs_bitmap, args->bitmask,
    2689                 :            :                         ARRAY_SIZE(nfs4_statfs_bitmap), &hdr);
    2690                 :          0 :         encode_nops(&hdr);
    2691                 :          0 : }
    2692                 :            : 
    2693                 :            : /*
    2694                 :            :  * GETATTR_BITMAP request
    2695                 :            :  */
    2696                 :          0 : static void nfs4_xdr_enc_server_caps(struct rpc_rqst *req,
    2697                 :            :                                      struct xdr_stream *xdr,
    2698                 :            :                                      const void *data)
    2699                 :            : {
    2700                 :            :         const struct nfs4_server_caps_arg *args = data;
    2701                 :          0 :         const u32 *bitmask = args->bitmask;
    2702                 :          0 :         struct compound_hdr hdr = {
    2703                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2704                 :            :         };
    2705                 :            : 
    2706                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2707                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2708                 :          0 :         encode_putfh(xdr, args->fhandle, &hdr);
    2709                 :          0 :         encode_getattr(xdr, bitmask, NULL, 3, &hdr);
    2710                 :          0 :         encode_nops(&hdr);
    2711                 :          0 : }
    2712                 :            : 
    2713                 :            : /*
    2714                 :            :  * a RENEW request
    2715                 :            :  */
    2716                 :          0 : static void nfs4_xdr_enc_renew(struct rpc_rqst *req, struct xdr_stream *xdr,
    2717                 :            :                                const void *data)
    2718                 :            : 
    2719                 :            : {
    2720                 :            :         const struct nfs_client *clp = data;
    2721                 :          0 :         struct compound_hdr hdr = {
    2722                 :            :                 .nops   = 0,
    2723                 :            :         };
    2724                 :            : 
    2725                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2726                 :          0 :         encode_renew(xdr, clp->cl_clientid, &hdr);
    2727                 :          0 :         encode_nops(&hdr);
    2728                 :          0 : }
    2729                 :            : 
    2730                 :            : /*
    2731                 :            :  * a SETCLIENTID request
    2732                 :            :  */
    2733                 :          0 : static void nfs4_xdr_enc_setclientid(struct rpc_rqst *req,
    2734                 :            :                                      struct xdr_stream *xdr,
    2735                 :            :                                      const void *data)
    2736                 :            : {
    2737                 :            :         const struct nfs4_setclientid *sc = data;
    2738                 :          0 :         struct compound_hdr hdr = {
    2739                 :            :                 .nops   = 0,
    2740                 :            :         };
    2741                 :            : 
    2742                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2743                 :          0 :         encode_setclientid(xdr, sc, &hdr);
    2744                 :          0 :         encode_nops(&hdr);
    2745                 :          0 : }
    2746                 :            : 
    2747                 :            : /*
    2748                 :            :  * a SETCLIENTID_CONFIRM request
    2749                 :            :  */
    2750                 :          0 : static void nfs4_xdr_enc_setclientid_confirm(struct rpc_rqst *req,
    2751                 :            :                                              struct xdr_stream *xdr,
    2752                 :            :                                              const void *data)
    2753                 :            : {
    2754                 :            :         const struct nfs4_setclientid_res *arg = data;
    2755                 :          0 :         struct compound_hdr hdr = {
    2756                 :            :                 .nops   = 0,
    2757                 :            :         };
    2758                 :            : 
    2759                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2760                 :          0 :         encode_setclientid_confirm(xdr, arg, &hdr);
    2761                 :          0 :         encode_nops(&hdr);
    2762                 :          0 : }
    2763                 :            : 
    2764                 :            : /*
    2765                 :            :  * DELEGRETURN request
    2766                 :            :  */
    2767                 :          0 : static void nfs4_xdr_enc_delegreturn(struct rpc_rqst *req,
    2768                 :            :                                      struct xdr_stream *xdr,
    2769                 :            :                                      const void *data)
    2770                 :            : {
    2771                 :            :         const struct nfs4_delegreturnargs *args = data;
    2772                 :          0 :         struct compound_hdr hdr = {
    2773                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2774                 :            :         };
    2775                 :            : 
    2776                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2777                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2778                 :          0 :         encode_putfh(xdr, args->fhandle, &hdr);
    2779                 :          0 :         if (args->lr_args)
    2780                 :          0 :                 encode_layoutreturn(xdr, args->lr_args, &hdr);
    2781                 :          0 :         if (args->bitmask)
    2782                 :            :                 encode_getfattr(xdr, args->bitmask, &hdr);
    2783                 :          0 :         encode_delegreturn(xdr, args->stateid, &hdr);
    2784                 :          0 :         encode_nops(&hdr);
    2785                 :          0 : }
    2786                 :            : 
    2787                 :            : /*
    2788                 :            :  * Encode FS_LOCATIONS request
    2789                 :            :  */
    2790                 :          0 : static void nfs4_xdr_enc_fs_locations(struct rpc_rqst *req,
    2791                 :            :                                       struct xdr_stream *xdr,
    2792                 :            :                                       const void *data)
    2793                 :            : {
    2794                 :            :         const struct nfs4_fs_locations_arg *args = data;
    2795                 :          0 :         struct compound_hdr hdr = {
    2796                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2797                 :            :         };
    2798                 :            :         uint32_t replen;
    2799                 :            : 
    2800                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2801                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2802                 :          0 :         if (args->migration) {
    2803                 :          0 :                 encode_putfh(xdr, args->fh, &hdr);
    2804                 :          0 :                 replen = hdr.replen;
    2805                 :          0 :                 encode_fs_locations(xdr, args->bitmask, &hdr);
    2806                 :          0 :                 if (args->renew)
    2807                 :          0 :                         encode_renew(xdr, args->clientid, &hdr);
    2808                 :            :         } else {
    2809                 :          0 :                 encode_putfh(xdr, args->dir_fh, &hdr);
    2810                 :          0 :                 encode_lookup(xdr, args->name, &hdr);
    2811                 :          0 :                 replen = hdr.replen;
    2812                 :          0 :                 encode_fs_locations(xdr, args->bitmask, &hdr);
    2813                 :            :         }
    2814                 :            : 
    2815                 :          0 :         rpc_prepare_reply_pages(req, (struct page **)&args->page, 0,
    2816                 :            :                                 PAGE_SIZE, replen + 1);
    2817                 :          0 :         encode_nops(&hdr);
    2818                 :          0 : }
    2819                 :            : 
    2820                 :            : /*
    2821                 :            :  * Encode SECINFO request
    2822                 :            :  */
    2823                 :          0 : static void nfs4_xdr_enc_secinfo(struct rpc_rqst *req,
    2824                 :            :                                 struct xdr_stream *xdr,
    2825                 :            :                                 const void *data)
    2826                 :            : {
    2827                 :            :         const struct nfs4_secinfo_arg *args = data;
    2828                 :          0 :         struct compound_hdr hdr = {
    2829                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2830                 :            :         };
    2831                 :            : 
    2832                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2833                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2834                 :          0 :         encode_putfh(xdr, args->dir_fh, &hdr);
    2835                 :          0 :         encode_secinfo(xdr, args->name, &hdr);
    2836                 :          0 :         encode_nops(&hdr);
    2837                 :          0 : }
    2838                 :            : 
    2839                 :            : /*
    2840                 :            :  * Encode FSID_PRESENT request
    2841                 :            :  */
    2842                 :          0 : static void nfs4_xdr_enc_fsid_present(struct rpc_rqst *req,
    2843                 :            :                                       struct xdr_stream *xdr,
    2844                 :            :                                       const void *data)
    2845                 :            : {
    2846                 :            :         const struct nfs4_fsid_present_arg *args = data;
    2847                 :          0 :         struct compound_hdr hdr = {
    2848                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    2849                 :            :         };
    2850                 :            : 
    2851                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2852                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    2853                 :          0 :         encode_putfh(xdr, args->fh, &hdr);
    2854                 :            :         encode_getfh(xdr, &hdr);
    2855                 :          0 :         if (args->renew)
    2856                 :          0 :                 encode_renew(xdr, args->clientid, &hdr);
    2857                 :          0 :         encode_nops(&hdr);
    2858                 :          0 : }
    2859                 :            : 
    2860                 :            : #if defined(CONFIG_NFS_V4_1)
    2861                 :            : /*
    2862                 :            :  * BIND_CONN_TO_SESSION request
    2863                 :            :  */
    2864                 :          0 : static void nfs4_xdr_enc_bind_conn_to_session(struct rpc_rqst *req,
    2865                 :            :                                 struct xdr_stream *xdr,
    2866                 :            :                                 const void *data)
    2867                 :            : {
    2868                 :            :         const struct nfs41_bind_conn_to_session_args *args = data;
    2869                 :          0 :         struct compound_hdr hdr = {
    2870                 :          0 :                 .minorversion = args->client->cl_mvops->minor_version,
    2871                 :            :         };
    2872                 :            : 
    2873                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2874                 :          0 :         encode_bind_conn_to_session(xdr, args, &hdr);
    2875                 :          0 :         encode_nops(&hdr);
    2876                 :          0 : }
    2877                 :            : 
    2878                 :            : /*
    2879                 :            :  * EXCHANGE_ID request
    2880                 :            :  */
    2881                 :          0 : static void nfs4_xdr_enc_exchange_id(struct rpc_rqst *req,
    2882                 :            :                                      struct xdr_stream *xdr,
    2883                 :            :                                      const void *data)
    2884                 :            : {
    2885                 :            :         const struct nfs41_exchange_id_args *args = data;
    2886                 :          0 :         struct compound_hdr hdr = {
    2887                 :          0 :                 .minorversion = args->client->cl_mvops->minor_version,
    2888                 :            :         };
    2889                 :            : 
    2890                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2891                 :          0 :         encode_exchange_id(xdr, args, &hdr);
    2892                 :          0 :         encode_nops(&hdr);
    2893                 :          0 : }
    2894                 :            : 
    2895                 :            : /*
    2896                 :            :  * a CREATE_SESSION request
    2897                 :            :  */
    2898                 :          0 : static void nfs4_xdr_enc_create_session(struct rpc_rqst *req,
    2899                 :            :                                         struct xdr_stream *xdr,
    2900                 :            :                                         const void *data)
    2901                 :            : {
    2902                 :            :         const struct nfs41_create_session_args *args = data;
    2903                 :          0 :         struct compound_hdr hdr = {
    2904                 :          0 :                 .minorversion = args->client->cl_mvops->minor_version,
    2905                 :            :         };
    2906                 :            : 
    2907                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2908                 :          0 :         encode_create_session(xdr, args, &hdr);
    2909                 :          0 :         encode_nops(&hdr);
    2910                 :          0 : }
    2911                 :            : 
    2912                 :            : /*
    2913                 :            :  * a DESTROY_SESSION request
    2914                 :            :  */
    2915                 :          0 : static void nfs4_xdr_enc_destroy_session(struct rpc_rqst *req,
    2916                 :            :                                          struct xdr_stream *xdr,
    2917                 :            :                                          const void *data)
    2918                 :            : {
    2919                 :            :         const struct nfs4_session *session = data;
    2920                 :          0 :         struct compound_hdr hdr = {
    2921                 :          0 :                 .minorversion = session->clp->cl_mvops->minor_version,
    2922                 :            :         };
    2923                 :            : 
    2924                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2925                 :          0 :         encode_destroy_session(xdr, session, &hdr);
    2926                 :          0 :         encode_nops(&hdr);
    2927                 :          0 : }
    2928                 :            : 
    2929                 :            : /*
    2930                 :            :  * a DESTROY_CLIENTID request
    2931                 :            :  */
    2932                 :          0 : static void nfs4_xdr_enc_destroy_clientid(struct rpc_rqst *req,
    2933                 :            :                                          struct xdr_stream *xdr,
    2934                 :            :                                          const void *data)
    2935                 :            : {
    2936                 :            :         const struct nfs_client *clp = data;
    2937                 :          0 :         struct compound_hdr hdr = {
    2938                 :          0 :                 .minorversion = clp->cl_mvops->minor_version,
    2939                 :            :         };
    2940                 :            : 
    2941                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2942                 :          0 :         encode_destroy_clientid(xdr, clp->cl_clientid, &hdr);
    2943                 :          0 :         encode_nops(&hdr);
    2944                 :          0 : }
    2945                 :            : 
    2946                 :            : /*
    2947                 :            :  * a SEQUENCE request
    2948                 :            :  */
    2949                 :          0 : static void nfs4_xdr_enc_sequence(struct rpc_rqst *req, struct xdr_stream *xdr,
    2950                 :            :                                   const void *data)
    2951                 :            : {
    2952                 :            :         const struct nfs4_sequence_args *args = data;
    2953                 :          0 :         struct compound_hdr hdr = {
    2954                 :            :                 .minorversion = nfs4_xdr_minorversion(args),
    2955                 :            :         };
    2956                 :            : 
    2957                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2958                 :          0 :         encode_sequence(xdr, args, &hdr);
    2959                 :          0 :         encode_nops(&hdr);
    2960                 :          0 : }
    2961                 :            : 
    2962                 :            : #endif
    2963                 :            : 
    2964                 :            : /*
    2965                 :            :  * a GET_LEASE_TIME request
    2966                 :            :  */
    2967                 :          0 : static void nfs4_xdr_enc_get_lease_time(struct rpc_rqst *req,
    2968                 :            :                                         struct xdr_stream *xdr,
    2969                 :            :                                         const void *data)
    2970                 :            : {
    2971                 :            :         const struct nfs4_get_lease_time_args *args = data;
    2972                 :          0 :         struct compound_hdr hdr = {
    2973                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->la_seq_args),
    2974                 :            :         };
    2975                 :          0 :         const u32 lease_bitmap[3] = { FATTR4_WORD0_LEASE_TIME };
    2976                 :            : 
    2977                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2978                 :          0 :         encode_sequence(xdr, &args->la_seq_args, &hdr);
    2979                 :            :         encode_putrootfh(xdr, &hdr);
    2980                 :            :         encode_fsinfo(xdr, lease_bitmap, &hdr);
    2981                 :          0 :         encode_nops(&hdr);
    2982                 :          0 : }
    2983                 :            : 
    2984                 :            : #ifdef CONFIG_NFS_V4_1
    2985                 :            : 
    2986                 :            : /*
    2987                 :            :  * a RECLAIM_COMPLETE request
    2988                 :            :  */
    2989                 :          0 : static void nfs4_xdr_enc_reclaim_complete(struct rpc_rqst *req,
    2990                 :            :                                           struct xdr_stream *xdr,
    2991                 :            :                                           const void *data)
    2992                 :            : {
    2993                 :            :         const struct nfs41_reclaim_complete_args *args = data;
    2994                 :          0 :         struct compound_hdr hdr = {
    2995                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args)
    2996                 :            :         };
    2997                 :            : 
    2998                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    2999                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    3000                 :          0 :         encode_reclaim_complete(xdr, args, &hdr);
    3001                 :          0 :         encode_nops(&hdr);
    3002                 :          0 : }
    3003                 :            : 
    3004                 :            : /*
    3005                 :            :  * Encode GETDEVICEINFO request
    3006                 :            :  */
    3007                 :          0 : static void nfs4_xdr_enc_getdeviceinfo(struct rpc_rqst *req,
    3008                 :            :                                        struct xdr_stream *xdr,
    3009                 :            :                                        const void *data)
    3010                 :            : {
    3011                 :            :         const struct nfs4_getdeviceinfo_args *args = data;
    3012                 :          0 :         struct compound_hdr hdr = {
    3013                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    3014                 :            :         };
    3015                 :            : 
    3016                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    3017                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    3018                 :          0 :         encode_getdeviceinfo(xdr, args, &hdr);
    3019                 :            : 
    3020                 :            :         /* set up reply kvec. Subtract notification bitmap max size (2)
    3021                 :            :          * so that notification bitmap is put in xdr_buf tail */
    3022                 :          0 :         rpc_prepare_reply_pages(req, args->pdev->pages, args->pdev->pgbase,
    3023                 :          0 :                                 args->pdev->pglen, hdr.replen - 2);
    3024                 :          0 :         encode_nops(&hdr);
    3025                 :          0 : }
    3026                 :            : 
    3027                 :            : /*
    3028                 :            :  *  Encode LAYOUTGET request
    3029                 :            :  */
    3030                 :          0 : static void nfs4_xdr_enc_layoutget(struct rpc_rqst *req,
    3031                 :            :                                    struct xdr_stream *xdr,
    3032                 :            :                                    const void *data)
    3033                 :            : {
    3034                 :            :         const struct nfs4_layoutget_args *args = data;
    3035                 :          0 :         struct compound_hdr hdr = {
    3036                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    3037                 :            :         };
    3038                 :            : 
    3039                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    3040                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    3041                 :          0 :         encode_putfh(xdr, NFS_FH(args->inode), &hdr);
    3042                 :          0 :         encode_layoutget(xdr, args, &hdr);
    3043                 :            : 
    3044                 :          0 :         rpc_prepare_reply_pages(req, args->layout.pages, 0,
    3045                 :            :                                 args->layout.pglen, hdr.replen);
    3046                 :          0 :         encode_nops(&hdr);
    3047                 :          0 : }
    3048                 :            : 
    3049                 :            : /*
    3050                 :            :  *  Encode LAYOUTCOMMIT request
    3051                 :            :  */
    3052                 :          0 : static void nfs4_xdr_enc_layoutcommit(struct rpc_rqst *req,
    3053                 :            :                                       struct xdr_stream *xdr,
    3054                 :            :                                       const void *priv)
    3055                 :            : {
    3056                 :            :         const struct nfs4_layoutcommit_args *args = priv;
    3057                 :            :         struct nfs4_layoutcommit_data *data =
    3058                 :            :                 container_of(args, struct nfs4_layoutcommit_data, args);
    3059                 :          0 :         struct compound_hdr hdr = {
    3060                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    3061                 :            :         };
    3062                 :            : 
    3063                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    3064                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    3065                 :          0 :         encode_putfh(xdr, NFS_FH(args->inode), &hdr);
    3066                 :          0 :         encode_layoutcommit(xdr, data->args.inode, args, &hdr);
    3067                 :          0 :         encode_getfattr(xdr, args->bitmask, &hdr);
    3068                 :          0 :         encode_nops(&hdr);
    3069                 :          0 : }
    3070                 :            : 
    3071                 :            : /*
    3072                 :            :  * Encode LAYOUTRETURN request
    3073                 :            :  */
    3074                 :          0 : static void nfs4_xdr_enc_layoutreturn(struct rpc_rqst *req,
    3075                 :            :                                       struct xdr_stream *xdr,
    3076                 :            :                                       const void *data)
    3077                 :            : {
    3078                 :            :         const struct nfs4_layoutreturn_args *args = data;
    3079                 :          0 :         struct compound_hdr hdr = {
    3080                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    3081                 :            :         };
    3082                 :            : 
    3083                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    3084                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    3085                 :          0 :         encode_putfh(xdr, NFS_FH(args->inode), &hdr);
    3086                 :          0 :         encode_layoutreturn(xdr, args, &hdr);
    3087                 :          0 :         encode_nops(&hdr);
    3088                 :          0 : }
    3089                 :            : 
    3090                 :            : /*
    3091                 :            :  * Encode SECINFO_NO_NAME request
    3092                 :            :  */
    3093                 :          0 : static void nfs4_xdr_enc_secinfo_no_name(struct rpc_rqst *req,
    3094                 :            :                                         struct xdr_stream *xdr,
    3095                 :            :                                         const void *data)
    3096                 :            : {
    3097                 :            :         const struct nfs41_secinfo_no_name_args *args = data;
    3098                 :          0 :         struct compound_hdr hdr = {
    3099                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    3100                 :            :         };
    3101                 :            : 
    3102                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    3103                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    3104                 :            :         encode_putrootfh(xdr, &hdr);
    3105                 :          0 :         encode_secinfo_no_name(xdr, args, &hdr);
    3106                 :          0 :         encode_nops(&hdr);
    3107                 :          0 : }
    3108                 :            : 
    3109                 :            : /*
    3110                 :            :  *  Encode TEST_STATEID request
    3111                 :            :  */
    3112                 :          0 : static void nfs4_xdr_enc_test_stateid(struct rpc_rqst *req,
    3113                 :            :                                       struct xdr_stream *xdr,
    3114                 :            :                                       const void *data)
    3115                 :            : {
    3116                 :            :         const struct nfs41_test_stateid_args *args = data;
    3117                 :          0 :         struct compound_hdr hdr = {
    3118                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    3119                 :            :         };
    3120                 :            : 
    3121                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    3122                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    3123                 :          0 :         encode_test_stateid(xdr, args, &hdr);
    3124                 :          0 :         encode_nops(&hdr);
    3125                 :          0 : }
    3126                 :            : 
    3127                 :            : /*
    3128                 :            :  *  Encode FREE_STATEID request
    3129                 :            :  */
    3130                 :          0 : static void nfs4_xdr_enc_free_stateid(struct rpc_rqst *req,
    3131                 :            :                                      struct xdr_stream *xdr,
    3132                 :            :                                      const void *data)
    3133                 :            : {
    3134                 :            :         const struct nfs41_free_stateid_args *args = data;
    3135                 :          0 :         struct compound_hdr hdr = {
    3136                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    3137                 :            :         };
    3138                 :            : 
    3139                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    3140                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    3141                 :          0 :         encode_free_stateid(xdr, args, &hdr);
    3142                 :          0 :         encode_nops(&hdr);
    3143                 :          0 : }
    3144                 :            : #endif /* CONFIG_NFS_V4_1 */
    3145                 :            : 
    3146                 :            : static int decode_opaque_inline(struct xdr_stream *xdr, unsigned int *len, char **string)
    3147                 :            : {
    3148                 :          0 :         ssize_t ret = xdr_stream_decode_opaque_inline(xdr, (void **)string,
    3149                 :            :                         NFS4_OPAQUE_LIMIT);
    3150                 :          0 :         if (unlikely(ret < 0))
    3151                 :            :                 return -EIO;
    3152                 :          0 :         *len = ret;
    3153                 :            :         return 0;
    3154                 :            : }
    3155                 :            : 
    3156                 :          0 : static int decode_compound_hdr(struct xdr_stream *xdr, struct compound_hdr *hdr)
    3157                 :            : {
    3158                 :            :         __be32 *p;
    3159                 :            : 
    3160                 :          0 :         p = xdr_inline_decode(xdr, 8);
    3161                 :          0 :         if (unlikely(!p))
    3162                 :            :                 return -EIO;
    3163                 :          0 :         hdr->status = be32_to_cpup(p++);
    3164                 :          0 :         hdr->taglen = be32_to_cpup(p);
    3165                 :            : 
    3166                 :          0 :         p = xdr_inline_decode(xdr, hdr->taglen + 4);
    3167                 :          0 :         if (unlikely(!p))
    3168                 :            :                 return -EIO;
    3169                 :          0 :         hdr->tag = (char *)p;
    3170                 :          0 :         p += XDR_QUADLEN(hdr->taglen);
    3171                 :          0 :         hdr->nops = be32_to_cpup(p);
    3172                 :          0 :         if (unlikely(hdr->nops < 1))
    3173                 :          0 :                 return nfs4_stat_to_errno(hdr->status);
    3174                 :            :         return 0;
    3175                 :            : }
    3176                 :            : 
    3177                 :          0 : static bool __decode_op_hdr(struct xdr_stream *xdr, enum nfs_opnum4 expected,
    3178                 :            :                 int *nfs_retval)
    3179                 :            : {
    3180                 :            :         __be32 *p;
    3181                 :            :         uint32_t opnum;
    3182                 :            :         int32_t nfserr;
    3183                 :            : 
    3184                 :          0 :         p = xdr_inline_decode(xdr, 8);
    3185                 :          0 :         if (unlikely(!p))
    3186                 :            :                 goto out_overflow;
    3187                 :            :         opnum = be32_to_cpup(p++);
    3188                 :          0 :         if (unlikely(opnum != expected))
    3189                 :            :                 goto out_bad_operation;
    3190                 :          0 :         if (unlikely(*p != cpu_to_be32(NFS_OK)))
    3191                 :            :                 goto out_status;
    3192                 :          0 :         *nfs_retval = 0;
    3193                 :          0 :         return true;
    3194                 :            : out_status:
    3195                 :          0 :         nfserr = be32_to_cpup(p);
    3196                 :          0 :         trace_nfs4_xdr_status(xdr, opnum, nfserr);
    3197                 :          0 :         *nfs_retval = nfs4_stat_to_errno(nfserr);
    3198                 :          0 :         return true;
    3199                 :            : out_bad_operation:
    3200                 :            :         dprintk("nfs: Server returned operation"
    3201                 :            :                 " %d but we issued a request for %d\n",
    3202                 :            :                         opnum, expected);
    3203                 :          0 :         *nfs_retval = -EREMOTEIO;
    3204                 :          0 :         return false;
    3205                 :            : out_overflow:
    3206                 :          0 :         *nfs_retval = -EIO;
    3207                 :          0 :         return false;
    3208                 :            : }
    3209                 :            : 
    3210                 :            : static int decode_op_hdr(struct xdr_stream *xdr, enum nfs_opnum4 expected)
    3211                 :            : {
    3212                 :            :         int retval;
    3213                 :            : 
    3214                 :          0 :         __decode_op_hdr(xdr, expected, &retval);
    3215                 :          0 :         return retval;
    3216                 :            : }
    3217                 :            : 
    3218                 :            : /* Dummy routine */
    3219                 :          0 : static int decode_ace(struct xdr_stream *xdr, void *ace)
    3220                 :            : {
    3221                 :            :         __be32 *p;
    3222                 :            :         unsigned int strlen;
    3223                 :            :         char *str;
    3224                 :            : 
    3225                 :          0 :         p = xdr_inline_decode(xdr, 12);
    3226                 :          0 :         if (unlikely(!p))
    3227                 :            :                 return -EIO;
    3228                 :          0 :         return decode_opaque_inline(xdr, &strlen, &str);
    3229                 :            : }
    3230                 :            : 
    3231                 :            : static ssize_t
    3232                 :            : decode_bitmap4(struct xdr_stream *xdr, uint32_t *bitmap, size_t sz)
    3233                 :            : {
    3234                 :            :         ssize_t ret;
    3235                 :            : 
    3236                 :          0 :         ret = xdr_stream_decode_uint32_array(xdr, bitmap, sz);
    3237                 :          0 :         if (likely(ret >= 0))
    3238                 :            :                 return ret;
    3239                 :          0 :         if (ret != -EMSGSIZE)
    3240                 :            :                 return -EIO;
    3241                 :            :         return sz;
    3242                 :            : }
    3243                 :            : 
    3244                 :          0 : static int decode_attr_bitmap(struct xdr_stream *xdr, uint32_t *bitmap)
    3245                 :            : {
    3246                 :            :         ssize_t ret;
    3247                 :            :         ret = decode_bitmap4(xdr, bitmap, 3);
    3248                 :          0 :         return ret < 0 ? ret : 0;
    3249                 :            : }
    3250                 :            : 
    3251                 :          0 : static int decode_attr_length(struct xdr_stream *xdr, uint32_t *attrlen, unsigned int *savep)
    3252                 :            : {
    3253                 :            :         __be32 *p;
    3254                 :            : 
    3255                 :          0 :         p = xdr_inline_decode(xdr, 4);
    3256                 :          0 :         if (unlikely(!p))
    3257                 :            :                 return -EIO;
    3258                 :          0 :         *attrlen = be32_to_cpup(p);
    3259                 :          0 :         *savep = xdr_stream_pos(xdr);
    3260                 :          0 :         return 0;
    3261                 :            : }
    3262                 :            : 
    3263                 :          0 : static int decode_attr_supported(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *bitmask)
    3264                 :            : {
    3265                 :          0 :         if (likely(bitmap[0] & FATTR4_WORD0_SUPPORTED_ATTRS)) {
    3266                 :            :                 int ret;
    3267                 :          0 :                 ret = decode_attr_bitmap(xdr, bitmask);
    3268                 :          0 :                 if (unlikely(ret < 0))
    3269                 :            :                         return ret;
    3270                 :          0 :                 bitmap[0] &= ~FATTR4_WORD0_SUPPORTED_ATTRS;
    3271                 :            :         } else
    3272                 :          0 :                 bitmask[0] = bitmask[1] = bitmask[2] = 0;
    3273                 :            :         dprintk("%s: bitmask=%08x:%08x:%08x\n", __func__,
    3274                 :            :                 bitmask[0], bitmask[1], bitmask[2]);
    3275                 :            :         return 0;
    3276                 :            : }
    3277                 :            : 
    3278                 :          0 : static int decode_attr_type(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *type)
    3279                 :            : {
    3280                 :            :         __be32 *p;
    3281                 :            :         int ret = 0;
    3282                 :            : 
    3283                 :          0 :         *type = 0;
    3284                 :          0 :         if (unlikely(bitmap[0] & (FATTR4_WORD0_TYPE - 1U)))
    3285                 :            :                 return -EIO;
    3286                 :          0 :         if (likely(bitmap[0] & FATTR4_WORD0_TYPE)) {
    3287                 :          0 :                 p = xdr_inline_decode(xdr, 4);
    3288                 :          0 :                 if (unlikely(!p))
    3289                 :            :                         return -EIO;
    3290                 :          0 :                 *type = be32_to_cpup(p);
    3291                 :          0 :                 if (*type < NF4REG || *type > NF4NAMEDATTR) {
    3292                 :            :                         dprintk("%s: bad type %d\n", __func__, *type);
    3293                 :            :                         return -EIO;
    3294                 :            :                 }
    3295                 :          0 :                 bitmap[0] &= ~FATTR4_WORD0_TYPE;
    3296                 :            :                 ret = NFS_ATTR_FATTR_TYPE;
    3297                 :            :         }
    3298                 :            :         dprintk("%s: type=0%o\n", __func__, nfs_type2fmt[*type]);
    3299                 :          0 :         return ret;
    3300                 :            : }
    3301                 :            : 
    3302                 :          0 : static int decode_attr_fh_expire_type(struct xdr_stream *xdr,
    3303                 :            :                                       uint32_t *bitmap, uint32_t *type)
    3304                 :            : {
    3305                 :            :         __be32 *p;
    3306                 :            : 
    3307                 :          0 :         *type = 0;
    3308                 :          0 :         if (unlikely(bitmap[0] & (FATTR4_WORD0_FH_EXPIRE_TYPE - 1U)))
    3309                 :            :                 return -EIO;
    3310                 :          0 :         if (likely(bitmap[0] & FATTR4_WORD0_FH_EXPIRE_TYPE)) {
    3311                 :          0 :                 p = xdr_inline_decode(xdr, 4);
    3312                 :          0 :                 if (unlikely(!p))
    3313                 :            :                         return -EIO;
    3314                 :          0 :                 *type = be32_to_cpup(p);
    3315                 :          0 :                 bitmap[0] &= ~FATTR4_WORD0_FH_EXPIRE_TYPE;
    3316                 :            :         }
    3317                 :            :         dprintk("%s: expire type=0x%x\n", __func__, *type);
    3318                 :            :         return 0;
    3319                 :            : }
    3320                 :            : 
    3321                 :          0 : static int decode_attr_change(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *change)
    3322                 :            : {
    3323                 :            :         __be32 *p;
    3324                 :            :         int ret = 0;
    3325                 :            : 
    3326                 :          0 :         *change = 0;
    3327                 :          0 :         if (unlikely(bitmap[0] & (FATTR4_WORD0_CHANGE - 1U)))
    3328                 :            :                 return -EIO;
    3329                 :          0 :         if (likely(bitmap[0] & FATTR4_WORD0_CHANGE)) {
    3330                 :          0 :                 p = xdr_inline_decode(xdr, 8);
    3331                 :          0 :                 if (unlikely(!p))
    3332                 :            :                         return -EIO;
    3333                 :            :                 xdr_decode_hyper(p, change);
    3334                 :          0 :                 bitmap[0] &= ~FATTR4_WORD0_CHANGE;
    3335                 :            :                 ret = NFS_ATTR_FATTR_CHANGE;
    3336                 :            :         }
    3337                 :            :         dprintk("%s: change attribute=%Lu\n", __func__,
    3338                 :            :                         (unsigned long long)*change);
    3339                 :          0 :         return ret;
    3340                 :            : }
    3341                 :            : 
    3342                 :          0 : static int decode_attr_size(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *size)
    3343                 :            : {
    3344                 :            :         __be32 *p;
    3345                 :            :         int ret = 0;
    3346                 :            : 
    3347                 :          0 :         *size = 0;
    3348                 :          0 :         if (unlikely(bitmap[0] & (FATTR4_WORD0_SIZE - 1U)))
    3349                 :            :                 return -EIO;
    3350                 :          0 :         if (likely(bitmap[0] & FATTR4_WORD0_SIZE)) {
    3351                 :          0 :                 p = xdr_inline_decode(xdr, 8);
    3352                 :          0 :                 if (unlikely(!p))
    3353                 :            :                         return -EIO;
    3354                 :            :                 xdr_decode_hyper(p, size);
    3355                 :          0 :                 bitmap[0] &= ~FATTR4_WORD0_SIZE;
    3356                 :            :                 ret = NFS_ATTR_FATTR_SIZE;
    3357                 :            :         }
    3358                 :            :         dprintk("%s: file size=%Lu\n", __func__, (unsigned long long)*size);
    3359                 :          0 :         return ret;
    3360                 :            : }
    3361                 :            : 
    3362                 :          0 : static int decode_attr_link_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
    3363                 :            : {
    3364                 :            :         __be32 *p;
    3365                 :            : 
    3366                 :          0 :         *res = 0;
    3367                 :          0 :         if (unlikely(bitmap[0] & (FATTR4_WORD0_LINK_SUPPORT - 1U)))
    3368                 :            :                 return -EIO;
    3369                 :          0 :         if (likely(bitmap[0] & FATTR4_WORD0_LINK_SUPPORT)) {
    3370                 :          0 :                 p = xdr_inline_decode(xdr, 4);
    3371                 :          0 :                 if (unlikely(!p))
    3372                 :            :                         return -EIO;
    3373                 :          0 :                 *res = be32_to_cpup(p);
    3374                 :          0 :                 bitmap[0] &= ~FATTR4_WORD0_LINK_SUPPORT;
    3375                 :            :         }
    3376                 :            :         dprintk("%s: link support=%s\n", __func__, *res == 0 ? "false" : "true");
    3377                 :            :         return 0;
    3378                 :            : }
    3379                 :            : 
    3380                 :          0 : static int decode_attr_symlink_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
    3381                 :            : {
    3382                 :            :         __be32 *p;
    3383                 :            : 
    3384                 :          0 :         *res = 0;
    3385                 :          0 :         if (unlikely(bitmap[0] & (FATTR4_WORD0_SYMLINK_SUPPORT - 1U)))
    3386                 :            :                 return -EIO;
    3387                 :          0 :         if (likely(bitmap[0] & FATTR4_WORD0_SYMLINK_SUPPORT)) {
    3388                 :          0 :                 p = xdr_inline_decode(xdr, 4);
    3389                 :          0 :                 if (unlikely(!p))
    3390                 :            :                         return -EIO;
    3391                 :          0 :                 *res = be32_to_cpup(p);
    3392                 :          0 :                 bitmap[0] &= ~FATTR4_WORD0_SYMLINK_SUPPORT;
    3393                 :            :         }
    3394                 :            :         dprintk("%s: symlink support=%s\n", __func__, *res == 0 ? "false" : "true");
    3395                 :            :         return 0;
    3396                 :            : }
    3397                 :            : 
    3398                 :          0 : static int decode_attr_fsid(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_fsid *fsid)
    3399                 :            : {
    3400                 :            :         __be32 *p;
    3401                 :            :         int ret = 0;
    3402                 :            : 
    3403                 :          0 :         fsid->major = 0;
    3404                 :          0 :         fsid->minor = 0;
    3405                 :          0 :         if (unlikely(bitmap[0] & (FATTR4_WORD0_FSID - 1U)))
    3406                 :            :                 return -EIO;
    3407                 :          0 :         if (likely(bitmap[0] & FATTR4_WORD0_FSID)) {
    3408                 :          0 :                 p = xdr_inline_decode(xdr, 16);
    3409                 :          0 :                 if (unlikely(!p))
    3410                 :            :                         return -EIO;
    3411                 :            :                 p = xdr_decode_hyper(p, &fsid->major);
    3412                 :            :                 xdr_decode_hyper(p, &fsid->minor);
    3413                 :          0 :                 bitmap[0] &= ~FATTR4_WORD0_FSID;
    3414                 :            :                 ret = NFS_ATTR_FATTR_FSID;
    3415                 :            :         }
    3416                 :            :         dprintk("%s: fsid=(0x%Lx/0x%Lx)\n", __func__,
    3417                 :            :                         (unsigned long long)fsid->major,
    3418                 :            :                         (unsigned long long)fsid->minor);
    3419                 :          0 :         return ret;
    3420                 :            : }
    3421                 :            : 
    3422                 :          0 : static int decode_attr_lease_time(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
    3423                 :            : {
    3424                 :            :         __be32 *p;
    3425                 :            : 
    3426                 :          0 :         *res = 60;
    3427                 :          0 :         if (unlikely(bitmap[0] & (FATTR4_WORD0_LEASE_TIME - 1U)))
    3428                 :            :                 return -EIO;
    3429                 :          0 :         if (likely(bitmap[0] & FATTR4_WORD0_LEASE_TIME)) {
    3430                 :          0 :                 p = xdr_inline_decode(xdr, 4);
    3431                 :          0 :                 if (unlikely(!p))
    3432                 :            :                         return -EIO;
    3433                 :          0 :                 *res = be32_to_cpup(p);
    3434                 :          0 :                 bitmap[0] &= ~FATTR4_WORD0_LEASE_TIME;
    3435                 :            :         }
    3436                 :            :         dprintk("%s: lease time=%u\n", __func__, (unsigned int)*res);
    3437                 :            :         return 0;
    3438                 :            : }
    3439                 :            : 
    3440                 :          0 : static int decode_attr_error(struct xdr_stream *xdr, uint32_t *bitmap, int32_t *res)
    3441                 :            : {
    3442                 :            :         __be32 *p;
    3443                 :            : 
    3444                 :          0 :         if (unlikely(bitmap[0] & (FATTR4_WORD0_RDATTR_ERROR - 1U)))
    3445                 :            :                 return -EIO;
    3446                 :          0 :         if (likely(bitmap[0] & FATTR4_WORD0_RDATTR_ERROR)) {
    3447                 :          0 :                 p = xdr_inline_decode(xdr, 4);
    3448                 :          0 :                 if (unlikely(!p))
    3449                 :            :                         return -EIO;
    3450                 :          0 :                 bitmap[0] &= ~FATTR4_WORD0_RDATTR_ERROR;
    3451                 :          0 :                 *res = -be32_to_cpup(p);
    3452                 :            :         }
    3453                 :            :         return 0;
    3454                 :            : }
    3455                 :            : 
    3456                 :          0 : static int decode_attr_exclcreat_supported(struct xdr_stream *xdr,
    3457                 :            :                                  uint32_t *bitmap, uint32_t *bitmask)
    3458                 :            : {
    3459                 :          0 :         if (likely(bitmap[2] & FATTR4_WORD2_SUPPATTR_EXCLCREAT)) {
    3460                 :            :                 int ret;
    3461                 :          0 :                 ret = decode_attr_bitmap(xdr, bitmask);
    3462                 :          0 :                 if (unlikely(ret < 0))
    3463                 :            :                         return ret;
    3464                 :          0 :                 bitmap[2] &= ~FATTR4_WORD2_SUPPATTR_EXCLCREAT;
    3465                 :            :         } else
    3466                 :          0 :                 bitmask[0] = bitmask[1] = bitmask[2] = 0;
    3467                 :            :         dprintk("%s: bitmask=%08x:%08x:%08x\n", __func__,
    3468                 :            :                 bitmask[0], bitmask[1], bitmask[2]);
    3469                 :            :         return 0;
    3470                 :            : }
    3471                 :            : 
    3472                 :          0 : static int decode_attr_filehandle(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_fh *fh)
    3473                 :            : {
    3474                 :            :         __be32 *p;
    3475                 :            :         u32 len;
    3476                 :            : 
    3477                 :          0 :         if (fh != NULL)
    3478                 :          0 :                 memset(fh, 0, sizeof(*fh));
    3479                 :            : 
    3480                 :          0 :         if (unlikely(bitmap[0] & (FATTR4_WORD0_FILEHANDLE - 1U)))
    3481                 :            :                 return -EIO;
    3482                 :          0 :         if (likely(bitmap[0] & FATTR4_WORD0_FILEHANDLE)) {
    3483                 :          0 :                 p = xdr_inline_decode(xdr, 4);
    3484                 :          0 :                 if (unlikely(!p))
    3485                 :            :                         return -EIO;
    3486                 :            :                 len = be32_to_cpup(p);
    3487                 :          0 :                 if (len > NFS4_FHSIZE)
    3488                 :            :                         return -EIO;
    3489                 :          0 :                 p = xdr_inline_decode(xdr, len);
    3490                 :          0 :                 if (unlikely(!p))
    3491                 :            :                         return -EIO;
    3492                 :          0 :                 if (fh != NULL) {
    3493                 :          0 :                         memcpy(fh->data, p, len);
    3494                 :          0 :                         fh->size = len;
    3495                 :            :                 }
    3496                 :          0 :                 bitmap[0] &= ~FATTR4_WORD0_FILEHANDLE;
    3497                 :            :         }
    3498                 :            :         return 0;
    3499                 :            : }
    3500                 :            : 
    3501                 :          0 : static int decode_attr_aclsupport(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
    3502                 :            : {
    3503                 :            :         __be32 *p;
    3504                 :            : 
    3505                 :          0 :         *res = 0;
    3506                 :          0 :         if (unlikely(bitmap[0] & (FATTR4_WORD0_ACLSUPPORT - 1U)))
    3507                 :            :                 return -EIO;
    3508                 :          0 :         if (likely(bitmap[0] & FATTR4_WORD0_ACLSUPPORT)) {
    3509                 :          0 :                 p = xdr_inline_decode(xdr, 4);
    3510                 :          0 :                 if (unlikely(!p))
    3511                 :            :                         return -EIO;
    3512                 :          0 :                 *res = be32_to_cpup(p);
    3513                 :          0 :                 bitmap[0] &= ~FATTR4_WORD0_ACLSUPPORT;
    3514                 :            :         }
    3515                 :            :         dprintk("%s: ACLs supported=%u\n", __func__, (unsigned int)*res);
    3516                 :            :         return 0;
    3517                 :            : }
    3518                 :            : 
    3519                 :          0 : static int decode_attr_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *fileid)
    3520                 :            : {
    3521                 :            :         __be32 *p;
    3522                 :            :         int ret = 0;
    3523                 :            : 
    3524                 :          0 :         *fileid = 0;
    3525                 :          0 :         if (unlikely(bitmap[0] & (FATTR4_WORD0_FILEID - 1U)))
    3526                 :            :                 return -EIO;
    3527                 :          0 :         if (likely(bitmap[0] & FATTR4_WORD0_FILEID)) {
    3528                 :          0 :                 p = xdr_inline_decode(xdr, 8);
    3529                 :          0 :                 if (unlikely(!p))
    3530                 :            :                         return -EIO;
    3531                 :            :                 xdr_decode_hyper(p, fileid);
    3532                 :          0 :                 bitmap[0] &= ~FATTR4_WORD0_FILEID;
    3533                 :            :                 ret = NFS_ATTR_FATTR_FILEID;
    3534                 :            :         }
    3535                 :            :         dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid);
    3536                 :          0 :         return ret;
    3537                 :            : }
    3538                 :            : 
    3539                 :          0 : static int decode_attr_mounted_on_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *fileid)
    3540                 :            : {
    3541                 :            :         __be32 *p;
    3542                 :            :         int ret = 0;
    3543                 :            : 
    3544                 :          0 :         *fileid = 0;
    3545                 :          0 :         if (unlikely(bitmap[1] & (FATTR4_WORD1_MOUNTED_ON_FILEID - 1U)))
    3546                 :            :                 return -EIO;
    3547                 :          0 :         if (likely(bitmap[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)) {
    3548                 :          0 :                 p = xdr_inline_decode(xdr, 8);
    3549                 :          0 :                 if (unlikely(!p))
    3550                 :            :                         return -EIO;
    3551                 :            :                 xdr_decode_hyper(p, fileid);
    3552                 :          0 :                 bitmap[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID;
    3553                 :            :                 ret = NFS_ATTR_FATTR_MOUNTED_ON_FILEID;
    3554                 :            :         }
    3555                 :            :         dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid);
    3556                 :          0 :         return ret;
    3557                 :            : }
    3558                 :            : 
    3559                 :          0 : static int decode_attr_files_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
    3560                 :            : {
    3561                 :            :         __be32 *p;
    3562                 :            :         int status = 0;
    3563                 :            : 
    3564                 :          0 :         *res = 0;
    3565                 :          0 :         if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_AVAIL - 1U)))
    3566                 :            :                 return -EIO;
    3567                 :          0 :         if (likely(bitmap[0] & FATTR4_WORD0_FILES_AVAIL)) {
    3568                 :          0 :                 p = xdr_inline_decode(xdr, 8);
    3569                 :          0 :                 if (unlikely(!p))
    3570                 :            :                         return -EIO;
    3571                 :            :                 xdr_decode_hyper(p, res);
    3572                 :          0 :                 bitmap[0] &= ~FATTR4_WORD0_FILES_AVAIL;
    3573                 :            :         }
    3574                 :            :         dprintk("%s: files avail=%Lu\n", __func__, (unsigned long long)*res);
    3575                 :            :         return status;
    3576                 :            : }
    3577                 :            : 
    3578                 :          0 : static int decode_attr_files_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
    3579                 :            : {
    3580                 :            :         __be32 *p;
    3581                 :            :         int status = 0;
    3582                 :            : 
    3583                 :          0 :         *res = 0;
    3584                 :          0 :         if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_FREE - 1U)))
    3585                 :            :                 return -EIO;
    3586                 :          0 :         if (likely(bitmap[0] & FATTR4_WORD0_FILES_FREE)) {
    3587                 :          0 :                 p = xdr_inline_decode(xdr, 8);
    3588                 :          0 :                 if (unlikely(!p))
    3589                 :            :                         return -EIO;
    3590                 :            :                 xdr_decode_hyper(p, res);
    3591                 :          0 :                 bitmap[0] &= ~FATTR4_WORD0_FILES_FREE;
    3592                 :            :         }
    3593                 :            :         dprintk("%s: files free=%Lu\n", __func__, (unsigned long long)*res);
    3594                 :            :         return status;
    3595                 :            : }
    3596                 :            : 
    3597                 :          0 : static int decode_attr_files_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
    3598                 :            : {
    3599                 :            :         __be32 *p;
    3600                 :            :         int status = 0;
    3601                 :            : 
    3602                 :          0 :         *res = 0;
    3603                 :          0 :         if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_TOTAL - 1U)))
    3604                 :            :                 return -EIO;
    3605                 :          0 :         if (likely(bitmap[0] & FATTR4_WORD0_FILES_TOTAL)) {
    3606                 :          0 :                 p = xdr_inline_decode(xdr, 8);
    3607                 :          0 :                 if (unlikely(!p))
    3608                 :            :                         return -EIO;
    3609                 :            :                 xdr_decode_hyper(p, res);
    3610                 :          0 :                 bitmap[0] &= ~FATTR4_WORD0_FILES_TOTAL;
    3611                 :            :         }
    3612                 :            :         dprintk("%s: files total=%Lu\n", __func__, (unsigned long long)*res);
    3613                 :            :         return status;
    3614                 :            : }
    3615                 :            : 
    3616                 :          0 : static int decode_pathname(struct xdr_stream *xdr, struct nfs4_pathname *path)
    3617                 :            : {
    3618                 :            :         u32 n;
    3619                 :            :         __be32 *p;
    3620                 :            :         int status = 0;
    3621                 :            : 
    3622                 :          0 :         p = xdr_inline_decode(xdr, 4);
    3623                 :          0 :         if (unlikely(!p))
    3624                 :            :                 return -EIO;
    3625                 :            :         n = be32_to_cpup(p);
    3626                 :          0 :         if (n == 0)
    3627                 :            :                 goto root_path;
    3628                 :            :         dprintk("pathname4: ");
    3629                 :          0 :         if (n > NFS4_PATHNAME_MAXCOMPONENTS) {
    3630                 :            :                 dprintk("cannot parse %d components in path\n", n);
    3631                 :            :                 goto out_eio;
    3632                 :            :         }
    3633                 :          0 :         for (path->ncomponents = 0; path->ncomponents < n; path->ncomponents++) {
    3634                 :            :                 struct nfs4_string *component = &path->components[path->ncomponents];
    3635                 :          0 :                 status = decode_opaque_inline(xdr, &component->len, &component->data);
    3636                 :          0 :                 if (unlikely(status != 0))
    3637                 :            :                         goto out_eio;
    3638                 :            :                 ifdebug (XDR)
    3639                 :            :                         pr_cont("%s%.*s ",
    3640                 :            :                                 (path->ncomponents != n ? "/ " : ""),
    3641                 :            :                                 component->len, component->data);
    3642                 :            :         }
    3643                 :            : out:
    3644                 :          0 :         return status;
    3645                 :            : root_path:
    3646                 :            : /* a root pathname is sent as a zero component4 */
    3647                 :          0 :         path->ncomponents = 1;
    3648                 :          0 :         path->components[0].len=0;
    3649                 :          0 :         path->components[0].data=NULL;
    3650                 :            :         dprintk("pathname4: /\n");
    3651                 :          0 :         goto out;
    3652                 :            : out_eio:
    3653                 :            :         dprintk(" status %d", status);
    3654                 :            :         status = -EIO;
    3655                 :            :         goto out;
    3656                 :            : }
    3657                 :            : 
    3658                 :          0 : static int decode_attr_fs_locations(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs4_fs_locations *res)
    3659                 :            : {
    3660                 :            :         int n;
    3661                 :            :         __be32 *p;
    3662                 :            :         int status = -EIO;
    3663                 :            : 
    3664                 :          0 :         if (unlikely(bitmap[0] & (FATTR4_WORD0_FS_LOCATIONS -1U)))
    3665                 :            :                 goto out;
    3666                 :            :         status = 0;
    3667                 :          0 :         if (unlikely(!(bitmap[0] & FATTR4_WORD0_FS_LOCATIONS)))
    3668                 :            :                 goto out;
    3669                 :          0 :         bitmap[0] &= ~FATTR4_WORD0_FS_LOCATIONS;
    3670                 :            :         status = -EIO;
    3671                 :            :         /* Ignore borken servers that return unrequested attrs */
    3672                 :          0 :         if (unlikely(res == NULL))
    3673                 :            :                 goto out;
    3674                 :            :         dprintk("%s: fsroot:\n", __func__);
    3675                 :          0 :         status = decode_pathname(xdr, &res->fs_path);
    3676                 :          0 :         if (unlikely(status != 0))
    3677                 :            :                 goto out;
    3678                 :          0 :         p = xdr_inline_decode(xdr, 4);
    3679                 :          0 :         if (unlikely(!p))
    3680                 :            :                 goto out_eio;
    3681                 :          0 :         n = be32_to_cpup(p);
    3682                 :          0 :         if (n <= 0)
    3683                 :            :                 goto out_eio;
    3684                 :          0 :         for (res->nlocations = 0; res->nlocations < n; res->nlocations++) {
    3685                 :            :                 u32 m;
    3686                 :            :                 struct nfs4_fs_location *loc;
    3687                 :            : 
    3688                 :          0 :                 if (res->nlocations == NFS4_FS_LOCATIONS_MAXENTRIES)
    3689                 :            :                         break;
    3690                 :            :                 loc = &res->locations[res->nlocations];
    3691                 :          0 :                 p = xdr_inline_decode(xdr, 4);
    3692                 :          0 :                 if (unlikely(!p))
    3693                 :            :                         goto out_eio;
    3694                 :            :                 m = be32_to_cpup(p);
    3695                 :            : 
    3696                 :            :                 dprintk("%s: servers:\n", __func__);
    3697                 :          0 :                 for (loc->nservers = 0; loc->nservers < m; loc->nservers++) {
    3698                 :            :                         struct nfs4_string *server;
    3699                 :            : 
    3700                 :          0 :                         if (loc->nservers == NFS4_FS_LOCATION_MAXSERVERS) {
    3701                 :            :                                 unsigned int i;
    3702                 :            :                                 dprintk("%s: using first %u of %u servers "
    3703                 :            :                                         "returned for location %u\n",
    3704                 :            :                                                 __func__,
    3705                 :            :                                                 NFS4_FS_LOCATION_MAXSERVERS,
    3706                 :            :                                                 m, res->nlocations);
    3707                 :          0 :                                 for (i = loc->nservers; i < m; i++) {
    3708                 :            :                                         unsigned int len;
    3709                 :            :                                         char *data;
    3710                 :            :                                         status = decode_opaque_inline(xdr, &len, &data);
    3711                 :          0 :                                         if (unlikely(status != 0))
    3712                 :            :                                                 goto out_eio;
    3713                 :            :                                 }
    3714                 :            :                                 break;
    3715                 :            :                         }
    3716                 :            :                         server = &loc->servers[loc->nservers];
    3717                 :          0 :                         status = decode_opaque_inline(xdr, &server->len, &server->data);
    3718                 :          0 :                         if (unlikely(status != 0))
    3719                 :            :                                 goto out_eio;
    3720                 :            :                         dprintk("%s ", server->data);
    3721                 :            :                 }
    3722                 :          0 :                 status = decode_pathname(xdr, &loc->rootpath);
    3723                 :          0 :                 if (unlikely(status != 0))
    3724                 :            :                         goto out_eio;
    3725                 :            :         }
    3726                 :          0 :         if (res->nlocations != 0)
    3727                 :            :                 status = NFS_ATTR_FATTR_V4_LOCATIONS;
    3728                 :            : out:
    3729                 :            :         dprintk("%s: fs_locations done, error = %d\n", __func__, status);
    3730                 :          0 :         return status;
    3731                 :            : out_eio:
    3732                 :            :         status = -EIO;
    3733                 :            :         goto out;
    3734                 :            : }
    3735                 :            : 
    3736                 :          0 : static int decode_attr_maxfilesize(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
    3737                 :            : {
    3738                 :            :         __be32 *p;
    3739                 :            :         int status = 0;
    3740                 :            : 
    3741                 :          0 :         *res = 0;
    3742                 :          0 :         if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXFILESIZE - 1U)))
    3743                 :            :                 return -EIO;
    3744                 :          0 :         if (likely(bitmap[0] & FATTR4_WORD0_MAXFILESIZE)) {
    3745                 :          0 :                 p = xdr_inline_decode(xdr, 8);
    3746                 :          0 :                 if (unlikely(!p))
    3747                 :            :                         return -EIO;
    3748                 :            :                 xdr_decode_hyper(p, res);
    3749                 :          0 :                 bitmap[0] &= ~FATTR4_WORD0_MAXFILESIZE;
    3750                 :            :         }
    3751                 :            :         dprintk("%s: maxfilesize=%Lu\n", __func__, (unsigned long long)*res);
    3752                 :            :         return status;
    3753                 :            : }
    3754                 :            : 
    3755                 :          0 : static int decode_attr_maxlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *maxlink)
    3756                 :            : {
    3757                 :            :         __be32 *p;
    3758                 :            :         int status = 0;
    3759                 :            : 
    3760                 :          0 :         *maxlink = 1;
    3761                 :          0 :         if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXLINK - 1U)))
    3762                 :            :                 return -EIO;
    3763                 :          0 :         if (likely(bitmap[0] & FATTR4_WORD0_MAXLINK)) {
    3764                 :          0 :                 p = xdr_inline_decode(xdr, 4);
    3765                 :          0 :                 if (unlikely(!p))
    3766                 :            :                         return -EIO;
    3767                 :          0 :                 *maxlink = be32_to_cpup(p);
    3768                 :          0 :                 bitmap[0] &= ~FATTR4_WORD0_MAXLINK;
    3769                 :            :         }
    3770                 :            :         dprintk("%s: maxlink=%u\n", __func__, *maxlink);
    3771                 :            :         return status;
    3772                 :            : }
    3773                 :            : 
    3774                 :          0 : static int decode_attr_maxname(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *maxname)
    3775                 :            : {
    3776                 :            :         __be32 *p;
    3777                 :            :         int status = 0;
    3778                 :            : 
    3779                 :          0 :         *maxname = 1024;
    3780                 :          0 :         if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXNAME - 1U)))
    3781                 :            :                 return -EIO;
    3782                 :          0 :         if (likely(bitmap[0] & FATTR4_WORD0_MAXNAME)) {
    3783                 :          0 :                 p = xdr_inline_decode(xdr, 4);
    3784                 :          0 :                 if (unlikely(!p))
    3785                 :            :                         return -EIO;
    3786                 :          0 :                 *maxname = be32_to_cpup(p);
    3787                 :          0 :                 bitmap[0] &= ~FATTR4_WORD0_MAXNAME;
    3788                 :            :         }
    3789                 :            :         dprintk("%s: maxname=%u\n", __func__, *maxname);
    3790                 :            :         return status;
    3791                 :            : }
    3792                 :            : 
    3793                 :          0 : static int decode_attr_maxread(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
    3794                 :            : {
    3795                 :            :         __be32 *p;
    3796                 :            :         int status = 0;
    3797                 :            : 
    3798                 :          0 :         *res = 1024;
    3799                 :          0 :         if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXREAD - 1U)))
    3800                 :            :                 return -EIO;
    3801                 :          0 :         if (likely(bitmap[0] & FATTR4_WORD0_MAXREAD)) {
    3802                 :            :                 uint64_t maxread;
    3803                 :          0 :                 p = xdr_inline_decode(xdr, 8);
    3804                 :          0 :                 if (unlikely(!p))
    3805                 :            :                         return -EIO;
    3806                 :            :                 xdr_decode_hyper(p, &maxread);
    3807                 :          0 :                 if (maxread > 0x7FFFFFFF)
    3808                 :            :                         maxread = 0x7FFFFFFF;
    3809                 :          0 :                 *res = (uint32_t)maxread;
    3810                 :          0 :                 bitmap[0] &= ~FATTR4_WORD0_MAXREAD;
    3811                 :            :         }
    3812                 :            :         dprintk("%s: maxread=%lu\n", __func__, (unsigned long)*res);
    3813                 :            :         return status;
    3814                 :            : }
    3815                 :            : 
    3816                 :          0 : static int decode_attr_maxwrite(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
    3817                 :            : {
    3818                 :            :         __be32 *p;
    3819                 :            :         int status = 0;
    3820                 :            : 
    3821                 :          0 :         *res = 1024;
    3822                 :          0 :         if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXWRITE - 1U)))
    3823                 :            :                 return -EIO;
    3824                 :          0 :         if (likely(bitmap[0] & FATTR4_WORD0_MAXWRITE)) {
    3825                 :            :                 uint64_t maxwrite;
    3826                 :          0 :                 p = xdr_inline_decode(xdr, 8);
    3827                 :          0 :                 if (unlikely(!p))
    3828                 :            :                         return -EIO;
    3829                 :            :                 xdr_decode_hyper(p, &maxwrite);
    3830                 :          0 :                 if (maxwrite > 0x7FFFFFFF)
    3831                 :            :                         maxwrite = 0x7FFFFFFF;
    3832                 :          0 :                 *res = (uint32_t)maxwrite;
    3833                 :          0 :                 bitmap[0] &= ~FATTR4_WORD0_MAXWRITE;
    3834                 :            :         }
    3835                 :            :         dprintk("%s: maxwrite=%lu\n", __func__, (unsigned long)*res);
    3836                 :            :         return status;
    3837                 :            : }
    3838                 :            : 
    3839                 :          0 : static int decode_attr_mode(struct xdr_stream *xdr, uint32_t *bitmap, umode_t *mode)
    3840                 :            : {
    3841                 :            :         uint32_t tmp;
    3842                 :            :         __be32 *p;
    3843                 :            :         int ret = 0;
    3844                 :            : 
    3845                 :          0 :         *mode = 0;
    3846                 :          0 :         if (unlikely(bitmap[1] & (FATTR4_WORD1_MODE - 1U)))
    3847                 :            :                 return -EIO;
    3848                 :          0 :         if (likely(bitmap[1] & FATTR4_WORD1_MODE)) {
    3849                 :          0 :                 p = xdr_inline_decode(xdr, 4);
    3850                 :          0 :                 if (unlikely(!p))
    3851                 :            :                         return -EIO;
    3852                 :            :                 tmp = be32_to_cpup(p);
    3853                 :          0 :                 *mode = tmp & ~S_IFMT;
    3854                 :          0 :                 bitmap[1] &= ~FATTR4_WORD1_MODE;
    3855                 :            :                 ret = NFS_ATTR_FATTR_MODE;
    3856                 :            :         }
    3857                 :            :         dprintk("%s: file mode=0%o\n", __func__, (unsigned int)*mode);
    3858                 :          0 :         return ret;
    3859                 :            : }
    3860                 :            : 
    3861                 :          0 : static int decode_attr_nlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *nlink)
    3862                 :            : {
    3863                 :            :         __be32 *p;
    3864                 :            :         int ret = 0;
    3865                 :            : 
    3866                 :          0 :         *nlink = 1;
    3867                 :          0 :         if (unlikely(bitmap[1] & (FATTR4_WORD1_NUMLINKS - 1U)))
    3868                 :            :                 return -EIO;
    3869                 :          0 :         if (likely(bitmap[1] & FATTR4_WORD1_NUMLINKS)) {
    3870                 :          0 :                 p = xdr_inline_decode(xdr, 4);
    3871                 :          0 :                 if (unlikely(!p))
    3872                 :            :                         return -EIO;
    3873                 :          0 :                 *nlink = be32_to_cpup(p);
    3874                 :          0 :                 bitmap[1] &= ~FATTR4_WORD1_NUMLINKS;
    3875                 :            :                 ret = NFS_ATTR_FATTR_NLINK;
    3876                 :            :         }
    3877                 :            :         dprintk("%s: nlink=%u\n", __func__, (unsigned int)*nlink);
    3878                 :          0 :         return ret;
    3879                 :            : }
    3880                 :            : 
    3881                 :            : static ssize_t decode_nfs4_string(struct xdr_stream *xdr,
    3882                 :            :                 struct nfs4_string *name, gfp_t gfp_flags)
    3883                 :            : {
    3884                 :            :         ssize_t ret;
    3885                 :            : 
    3886                 :          0 :         ret = xdr_stream_decode_string_dup(xdr, &name->data,
    3887                 :            :                         XDR_MAX_NETOBJ, gfp_flags);
    3888                 :          0 :         name->len = 0;
    3889                 :          0 :         if (ret > 0)
    3890                 :          0 :                 name->len = ret;
    3891                 :            :         return ret;
    3892                 :            : }
    3893                 :            : 
    3894                 :          0 : static int decode_attr_owner(struct xdr_stream *xdr, uint32_t *bitmap,
    3895                 :            :                 const struct nfs_server *server, kuid_t *uid,
    3896                 :            :                 struct nfs4_string *owner_name)
    3897                 :            : {
    3898                 :            :         ssize_t len;
    3899                 :            :         char *p;
    3900                 :            : 
    3901                 :          0 :         *uid = make_kuid(&init_user_ns, -2);
    3902                 :          0 :         if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER - 1U)))
    3903                 :            :                 return -EIO;
    3904                 :          0 :         if (!(bitmap[1] & FATTR4_WORD1_OWNER))
    3905                 :            :                 return 0;
    3906                 :          0 :         bitmap[1] &= ~FATTR4_WORD1_OWNER;
    3907                 :            : 
    3908                 :          0 :         if (owner_name != NULL) {
    3909                 :            :                 len = decode_nfs4_string(xdr, owner_name, GFP_NOIO);
    3910                 :          0 :                 if (len <= 0)
    3911                 :            :                         goto out;
    3912                 :            :                 dprintk("%s: name=%s\n", __func__, owner_name->data);
    3913                 :            :                 return NFS_ATTR_FATTR_OWNER_NAME;
    3914                 :            :         } else {
    3915                 :          0 :                 len = xdr_stream_decode_opaque_inline(xdr, (void **)&p,
    3916                 :            :                                 XDR_MAX_NETOBJ);
    3917                 :          0 :                 if (len <= 0 || nfs_map_name_to_uid(server, p, len, uid) != 0)
    3918                 :            :                         goto out;
    3919                 :            :                 dprintk("%s: uid=%d\n", __func__, (int)from_kuid(&init_user_ns, *uid));
    3920                 :            :                 return NFS_ATTR_FATTR_OWNER;
    3921                 :            :         }
    3922                 :            : out:
    3923                 :          0 :         if (len == -EBADMSG)
    3924                 :            :                 return -EIO;
    3925                 :          0 :         return 0;
    3926                 :            : }
    3927                 :            : 
    3928                 :          0 : static int decode_attr_group(struct xdr_stream *xdr, uint32_t *bitmap,
    3929                 :            :                 const struct nfs_server *server, kgid_t *gid,
    3930                 :            :                 struct nfs4_string *group_name)
    3931                 :            : {
    3932                 :            :         ssize_t len;
    3933                 :            :         char *p;
    3934                 :            : 
    3935                 :          0 :         *gid = make_kgid(&init_user_ns, -2);
    3936                 :          0 :         if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER_GROUP - 1U)))
    3937                 :            :                 return -EIO;
    3938                 :          0 :         if (!(bitmap[1] & FATTR4_WORD1_OWNER_GROUP))
    3939                 :            :                 return 0;
    3940                 :          0 :         bitmap[1] &= ~FATTR4_WORD1_OWNER_GROUP;
    3941                 :            : 
    3942                 :          0 :         if (group_name != NULL) {
    3943                 :            :                 len = decode_nfs4_string(xdr, group_name, GFP_NOIO);
    3944                 :          0 :                 if (len <= 0)
    3945                 :            :                         goto out;
    3946                 :            :                 dprintk("%s: name=%s\n", __func__, group_name->data);
    3947                 :            :                 return NFS_ATTR_FATTR_GROUP_NAME;
    3948                 :            :         } else {
    3949                 :          0 :                 len = xdr_stream_decode_opaque_inline(xdr, (void **)&p,
    3950                 :            :                                 XDR_MAX_NETOBJ);
    3951                 :          0 :                 if (len <= 0 || nfs_map_group_to_gid(server, p, len, gid) != 0)
    3952                 :            :                         goto out;
    3953                 :            :                 dprintk("%s: gid=%d\n", __func__, (int)from_kgid(&init_user_ns, *gid));
    3954                 :            :                 return NFS_ATTR_FATTR_GROUP;
    3955                 :            :         }
    3956                 :            : out:
    3957                 :          0 :         if (len == -EBADMSG)
    3958                 :            :                 return -EIO;
    3959                 :          0 :         return 0;
    3960                 :            : }
    3961                 :            : 
    3962                 :          0 : static int decode_attr_rdev(struct xdr_stream *xdr, uint32_t *bitmap, dev_t *rdev)
    3963                 :            : {
    3964                 :            :         uint32_t major = 0, minor = 0;
    3965                 :            :         __be32 *p;
    3966                 :            :         int ret = 0;
    3967                 :            : 
    3968                 :          0 :         *rdev = MKDEV(0,0);
    3969                 :          0 :         if (unlikely(bitmap[1] & (FATTR4_WORD1_RAWDEV - 1U)))
    3970                 :            :                 return -EIO;
    3971                 :          0 :         if (likely(bitmap[1] & FATTR4_WORD1_RAWDEV)) {
    3972                 :            :                 dev_t tmp;
    3973                 :            : 
    3974                 :          0 :                 p = xdr_inline_decode(xdr, 8);
    3975                 :          0 :                 if (unlikely(!p))
    3976                 :            :                         return -EIO;
    3977                 :            :                 major = be32_to_cpup(p++);
    3978                 :            :                 minor = be32_to_cpup(p);
    3979                 :          0 :                 tmp = MKDEV(major, minor);
    3980                 :          0 :                 if (MAJOR(tmp) == major && MINOR(tmp) == minor)
    3981                 :          0 :                         *rdev = tmp;
    3982                 :          0 :                 bitmap[1] &= ~ FATTR4_WORD1_RAWDEV;
    3983                 :            :                 ret = NFS_ATTR_FATTR_RDEV;
    3984                 :            :         }
    3985                 :            :         dprintk("%s: rdev=(0x%x:0x%x)\n", __func__, major, minor);
    3986                 :          0 :         return ret;
    3987                 :            : }
    3988                 :            : 
    3989                 :          0 : static int decode_attr_space_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
    3990                 :            : {
    3991                 :            :         __be32 *p;
    3992                 :            :         int status = 0;
    3993                 :            : 
    3994                 :          0 :         *res = 0;
    3995                 :          0 :         if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_AVAIL - 1U)))
    3996                 :            :                 return -EIO;
    3997                 :          0 :         if (likely(bitmap[1] & FATTR4_WORD1_SPACE_AVAIL)) {
    3998                 :          0 :                 p = xdr_inline_decode(xdr, 8);
    3999                 :          0 :                 if (unlikely(!p))
    4000                 :            :                         return -EIO;
    4001                 :            :                 xdr_decode_hyper(p, res);
    4002                 :          0 :                 bitmap[1] &= ~FATTR4_WORD1_SPACE_AVAIL;
    4003                 :            :         }
    4004                 :            :         dprintk("%s: space avail=%Lu\n", __func__, (unsigned long long)*res);
    4005                 :            :         return status;
    4006                 :            : }
    4007                 :            : 
    4008                 :          0 : static int decode_attr_space_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
    4009                 :            : {
    4010                 :            :         __be32 *p;
    4011                 :            :         int status = 0;
    4012                 :            : 
    4013                 :          0 :         *res = 0;
    4014                 :          0 :         if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_FREE - 1U)))
    4015                 :            :                 return -EIO;
    4016                 :          0 :         if (likely(bitmap[1] & FATTR4_WORD1_SPACE_FREE)) {
    4017                 :          0 :                 p = xdr_inline_decode(xdr, 8);
    4018                 :          0 :                 if (unlikely(!p))
    4019                 :            :                         return -EIO;
    4020                 :            :                 xdr_decode_hyper(p, res);
    4021                 :          0 :                 bitmap[1] &= ~FATTR4_WORD1_SPACE_FREE;
    4022                 :            :         }
    4023                 :            :         dprintk("%s: space free=%Lu\n", __func__, (unsigned long long)*res);
    4024                 :            :         return status;
    4025                 :            : }
    4026                 :            : 
    4027                 :          0 : static int decode_attr_space_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
    4028                 :            : {
    4029                 :            :         __be32 *p;
    4030                 :            :         int status = 0;
    4031                 :            : 
    4032                 :          0 :         *res = 0;
    4033                 :          0 :         if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_TOTAL - 1U)))
    4034                 :            :                 return -EIO;
    4035                 :          0 :         if (likely(bitmap[1] & FATTR4_WORD1_SPACE_TOTAL)) {
    4036                 :          0 :                 p = xdr_inline_decode(xdr, 8);
    4037                 :          0 :                 if (unlikely(!p))
    4038                 :            :                         return -EIO;
    4039                 :            :                 xdr_decode_hyper(p, res);
    4040                 :          0 :                 bitmap[1] &= ~FATTR4_WORD1_SPACE_TOTAL;
    4041                 :            :         }
    4042                 :            :         dprintk("%s: space total=%Lu\n", __func__, (unsigned long long)*res);
    4043                 :            :         return status;
    4044                 :            : }
    4045                 :            : 
    4046                 :          0 : static int decode_attr_space_used(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *used)
    4047                 :            : {
    4048                 :            :         __be32 *p;
    4049                 :            :         int ret = 0;
    4050                 :            : 
    4051                 :          0 :         *used = 0;
    4052                 :          0 :         if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_USED - 1U)))
    4053                 :            :                 return -EIO;
    4054                 :          0 :         if (likely(bitmap[1] & FATTR4_WORD1_SPACE_USED)) {
    4055                 :          0 :                 p = xdr_inline_decode(xdr, 8);
    4056                 :          0 :                 if (unlikely(!p))
    4057                 :            :                         return -EIO;
    4058                 :            :                 xdr_decode_hyper(p, used);
    4059                 :          0 :                 bitmap[1] &= ~FATTR4_WORD1_SPACE_USED;
    4060                 :            :                 ret = NFS_ATTR_FATTR_SPACE_USED;
    4061                 :            :         }
    4062                 :            :         dprintk("%s: space used=%Lu\n", __func__,
    4063                 :            :                         (unsigned long long)*used);
    4064                 :          0 :         return ret;
    4065                 :            : }
    4066                 :            : 
    4067                 :            : static __be32 *
    4068                 :            : xdr_decode_nfstime4(__be32 *p, struct timespec *t)
    4069                 :            : {
    4070                 :            :         __u64 sec;
    4071                 :            : 
    4072                 :            :         p = xdr_decode_hyper(p, &sec);
    4073                 :          0 :         t-> tv_sec = (time_t)sec;
    4074                 :          0 :         t->tv_nsec = be32_to_cpup(p++);
    4075                 :            :         return p;
    4076                 :            : }
    4077                 :            : 
    4078                 :          0 : static int decode_attr_time(struct xdr_stream *xdr, struct timespec *time)
    4079                 :            : {
    4080                 :            :         __be32 *p;
    4081                 :            : 
    4082                 :          0 :         p = xdr_inline_decode(xdr, nfstime4_maxsz << 2);
    4083                 :          0 :         if (unlikely(!p))
    4084                 :            :                 return -EIO;
    4085                 :            :         xdr_decode_nfstime4(p, time);
    4086                 :          0 :         return 0;
    4087                 :            : }
    4088                 :            : 
    4089                 :          0 : static int decode_attr_time_access(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
    4090                 :            : {
    4091                 :            :         int status = 0;
    4092                 :            : 
    4093                 :          0 :         time->tv_sec = 0;
    4094                 :          0 :         time->tv_nsec = 0;
    4095                 :          0 :         if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_ACCESS - 1U)))
    4096                 :            :                 return -EIO;
    4097                 :          0 :         if (likely(bitmap[1] & FATTR4_WORD1_TIME_ACCESS)) {
    4098                 :          0 :                 status = decode_attr_time(xdr, time);
    4099                 :          0 :                 if (status == 0)
    4100                 :            :                         status = NFS_ATTR_FATTR_ATIME;
    4101                 :          0 :                 bitmap[1] &= ~FATTR4_WORD1_TIME_ACCESS;
    4102                 :            :         }
    4103                 :            :         dprintk("%s: atime=%ld\n", __func__, (long)time->tv_sec);
    4104                 :          0 :         return status;
    4105                 :            : }
    4106                 :            : 
    4107                 :          0 : static int decode_attr_time_metadata(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
    4108                 :            : {
    4109                 :            :         int status = 0;
    4110                 :            : 
    4111                 :          0 :         time->tv_sec = 0;
    4112                 :          0 :         time->tv_nsec = 0;
    4113                 :          0 :         if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_METADATA - 1U)))
    4114                 :            :                 return -EIO;
    4115                 :          0 :         if (likely(bitmap[1] & FATTR4_WORD1_TIME_METADATA)) {
    4116                 :          0 :                 status = decode_attr_time(xdr, time);
    4117                 :          0 :                 if (status == 0)
    4118                 :            :                         status = NFS_ATTR_FATTR_CTIME;
    4119                 :          0 :                 bitmap[1] &= ~FATTR4_WORD1_TIME_METADATA;
    4120                 :            :         }
    4121                 :            :         dprintk("%s: ctime=%ld\n", __func__, (long)time->tv_sec);
    4122                 :          0 :         return status;
    4123                 :            : }
    4124                 :            : 
    4125                 :          0 : static int decode_attr_time_delta(struct xdr_stream *xdr, uint32_t *bitmap,
    4126                 :            :                                   struct timespec *time)
    4127                 :            : {
    4128                 :            :         int status = 0;
    4129                 :            : 
    4130                 :          0 :         time->tv_sec = 0;
    4131                 :          0 :         time->tv_nsec = 0;
    4132                 :          0 :         if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_DELTA - 1U)))
    4133                 :            :                 return -EIO;
    4134                 :          0 :         if (likely(bitmap[1] & FATTR4_WORD1_TIME_DELTA)) {
    4135                 :          0 :                 status = decode_attr_time(xdr, time);
    4136                 :          0 :                 bitmap[1] &= ~FATTR4_WORD1_TIME_DELTA;
    4137                 :            :         }
    4138                 :            :         dprintk("%s: time_delta=%ld %ld\n", __func__, (long)time->tv_sec,
    4139                 :            :                 (long)time->tv_nsec);
    4140                 :          0 :         return status;
    4141                 :            : }
    4142                 :            : 
    4143                 :          0 : static int decode_attr_security_label(struct xdr_stream *xdr, uint32_t *bitmap,
    4144                 :            :                                         struct nfs4_label *label)
    4145                 :            : {
    4146                 :            :         uint32_t pi = 0;
    4147                 :            :         uint32_t lfs = 0;
    4148                 :            :         __u32 len;
    4149                 :            :         __be32 *p;
    4150                 :            :         int status = 0;
    4151                 :            : 
    4152                 :          0 :         if (unlikely(bitmap[2] & (FATTR4_WORD2_SECURITY_LABEL - 1U)))
    4153                 :            :                 return -EIO;
    4154                 :          0 :         if (likely(bitmap[2] & FATTR4_WORD2_SECURITY_LABEL)) {
    4155                 :          0 :                 p = xdr_inline_decode(xdr, 4);
    4156                 :          0 :                 if (unlikely(!p))
    4157                 :            :                         return -EIO;
    4158                 :            :                 lfs = be32_to_cpup(p++);
    4159                 :          0 :                 p = xdr_inline_decode(xdr, 4);
    4160                 :          0 :                 if (unlikely(!p))
    4161                 :            :                         return -EIO;
    4162                 :            :                 pi = be32_to_cpup(p++);
    4163                 :          0 :                 p = xdr_inline_decode(xdr, 4);
    4164                 :          0 :                 if (unlikely(!p))
    4165                 :            :                         return -EIO;
    4166                 :            :                 len = be32_to_cpup(p++);
    4167                 :          0 :                 p = xdr_inline_decode(xdr, len);
    4168                 :          0 :                 if (unlikely(!p))
    4169                 :            :                         return -EIO;
    4170                 :          0 :                 if (len < NFS4_MAXLABELLEN) {
    4171                 :          0 :                         if (label) {
    4172                 :          0 :                                 if (label->len) {
    4173                 :          0 :                                         if (label->len < len)
    4174                 :            :                                                 return -ERANGE;
    4175                 :          0 :                                         memcpy(label->label, p, len);
    4176                 :            :                                 }
    4177                 :          0 :                                 label->len = len;
    4178                 :          0 :                                 label->pi = pi;
    4179                 :          0 :                                 label->lfs = lfs;
    4180                 :            :                                 status = NFS_ATTR_FATTR_V4_SECURITY_LABEL;
    4181                 :            :                         }
    4182                 :          0 :                         bitmap[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
    4183                 :            :                 } else
    4184                 :          0 :                         printk(KERN_WARNING "%s: label too long (%u)!\n",
    4185                 :            :                                         __func__, len);
    4186                 :            :         }
    4187                 :            :         if (label && label->label)
    4188                 :            :                 dprintk("%s: label=%s, len=%d, PI=%d, LFS=%d\n", __func__,
    4189                 :            :                         (char *)label->label, label->len, label->pi, label->lfs);
    4190                 :          0 :         return status;
    4191                 :            : }
    4192                 :            : 
    4193                 :          0 : static int decode_attr_time_modify(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
    4194                 :            : {
    4195                 :            :         int status = 0;
    4196                 :            : 
    4197                 :          0 :         time->tv_sec = 0;
    4198                 :          0 :         time->tv_nsec = 0;
    4199                 :          0 :         if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_MODIFY - 1U)))
    4200                 :            :                 return -EIO;
    4201                 :          0 :         if (likely(bitmap[1] & FATTR4_WORD1_TIME_MODIFY)) {
    4202                 :          0 :                 status = decode_attr_time(xdr, time);
    4203                 :          0 :                 if (status == 0)
    4204                 :            :                         status = NFS_ATTR_FATTR_MTIME;
    4205                 :          0 :                 bitmap[1] &= ~FATTR4_WORD1_TIME_MODIFY;
    4206                 :            :         }
    4207                 :            :         dprintk("%s: mtime=%ld\n", __func__, (long)time->tv_sec);
    4208                 :          0 :         return status;
    4209                 :            : }
    4210                 :            : 
    4211                 :            : static int verify_attr_len(struct xdr_stream *xdr, unsigned int savep, uint32_t attrlen)
    4212                 :            : {
    4213                 :          0 :         unsigned int attrwords = XDR_QUADLEN(attrlen);
    4214                 :          0 :         unsigned int nwords = (xdr_stream_pos(xdr) - savep) >> 2;
    4215                 :            : 
    4216                 :          0 :         if (unlikely(attrwords != nwords)) {
    4217                 :            :                 dprintk("%s: server returned incorrect attribute length: "
    4218                 :            :                         "%u %c %u\n",
    4219                 :            :                                 __func__,
    4220                 :            :                                 attrwords << 2,
    4221                 :            :                                 (attrwords < nwords) ? '<' : '>',
    4222                 :            :                                 nwords << 2);
    4223                 :            :                 return -EIO;
    4224                 :            :         }
    4225                 :            :         return 0;
    4226                 :            : }
    4227                 :            : 
    4228                 :          0 : static int decode_change_info(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
    4229                 :            : {
    4230                 :            :         __be32 *p;
    4231                 :            : 
    4232                 :          0 :         p = xdr_inline_decode(xdr, 20);
    4233                 :          0 :         if (unlikely(!p))
    4234                 :            :                 return -EIO;
    4235                 :          0 :         cinfo->atomic = be32_to_cpup(p++);
    4236                 :            :         p = xdr_decode_hyper(p, &cinfo->before);
    4237                 :            :         xdr_decode_hyper(p, &cinfo->after);
    4238                 :          0 :         return 0;
    4239                 :            : }
    4240                 :            : 
    4241                 :          0 : static int decode_access(struct xdr_stream *xdr, u32 *supported, u32 *access)
    4242                 :            : {
    4243                 :            :         __be32 *p;
    4244                 :            :         uint32_t supp, acc;
    4245                 :            :         int status;
    4246                 :            : 
    4247                 :            :         status = decode_op_hdr(xdr, OP_ACCESS);
    4248                 :          0 :         if (status)
    4249                 :            :                 return status;
    4250                 :          0 :         p = xdr_inline_decode(xdr, 8);
    4251                 :          0 :         if (unlikely(!p))
    4252                 :            :                 return -EIO;
    4253                 :            :         supp = be32_to_cpup(p++);
    4254                 :            :         acc = be32_to_cpup(p);
    4255                 :          0 :         *supported = supp;
    4256                 :          0 :         *access = acc;
    4257                 :          0 :         return 0;
    4258                 :            : }
    4259                 :            : 
    4260                 :            : static int decode_opaque_fixed(struct xdr_stream *xdr, void *buf, size_t len)
    4261                 :            : {
    4262                 :          0 :         ssize_t ret = xdr_stream_decode_opaque_fixed(xdr, buf, len);
    4263                 :          0 :         if (unlikely(ret < 0))
    4264                 :            :                 return -EIO;
    4265                 :            :         return 0;
    4266                 :            : }
    4267                 :            : 
    4268                 :            : static int decode_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
    4269                 :            : {
    4270                 :            :         return decode_opaque_fixed(xdr, stateid, NFS4_STATEID_SIZE);
    4271                 :            : }
    4272                 :            : 
    4273                 :            : static int decode_open_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
    4274                 :            : {
    4275                 :          0 :         stateid->type = NFS4_OPEN_STATEID_TYPE;
    4276                 :            :         return decode_stateid(xdr, stateid);
    4277                 :            : }
    4278                 :            : 
    4279                 :            : static int decode_lock_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
    4280                 :            : {
    4281                 :          0 :         stateid->type = NFS4_LOCK_STATEID_TYPE;
    4282                 :            :         return decode_stateid(xdr, stateid);
    4283                 :            : }
    4284                 :            : 
    4285                 :            : static int decode_delegation_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
    4286                 :            : {
    4287                 :          0 :         stateid->type = NFS4_DELEGATION_STATEID_TYPE;
    4288                 :            :         return decode_stateid(xdr, stateid);
    4289                 :            : }
    4290                 :            : 
    4291                 :          0 : static int decode_invalid_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
    4292                 :            : {
    4293                 :            :         nfs4_stateid dummy;
    4294                 :            : 
    4295                 :            :         nfs4_stateid_copy(stateid, &invalid_stateid);
    4296                 :          0 :         return decode_stateid(xdr, &dummy);
    4297                 :            : }
    4298                 :            : 
    4299                 :          0 : static int decode_close(struct xdr_stream *xdr, struct nfs_closeres *res)
    4300                 :            : {
    4301                 :            :         int status;
    4302                 :            : 
    4303                 :            :         status = decode_op_hdr(xdr, OP_CLOSE);
    4304                 :          0 :         if (status != -EIO)
    4305                 :          0 :                 nfs_increment_open_seqid(status, res->seqid);
    4306                 :          0 :         if (!status)
    4307                 :          0 :                 status = decode_invalid_stateid(xdr, &res->stateid);
    4308                 :          0 :         return status;
    4309                 :            : }
    4310                 :            : 
    4311                 :            : static int decode_verifier(struct xdr_stream *xdr, void *verifier)
    4312                 :            : {
    4313                 :            :         return decode_opaque_fixed(xdr, verifier, NFS4_VERIFIER_SIZE);
    4314                 :            : }
    4315                 :            : 
    4316                 :            : static int decode_write_verifier(struct xdr_stream *xdr, struct nfs_write_verifier *verifier)
    4317                 :            : {
    4318                 :          0 :         return decode_opaque_fixed(xdr, verifier->data, NFS4_VERIFIER_SIZE);
    4319                 :            : }
    4320                 :            : 
    4321                 :          0 : static int decode_commit(struct xdr_stream *xdr, struct nfs_commitres *res)
    4322                 :            : {
    4323                 :          0 :         struct nfs_writeverf *verf = res->verf;
    4324                 :            :         int status;
    4325                 :            : 
    4326                 :            :         status = decode_op_hdr(xdr, OP_COMMIT);
    4327                 :          0 :         if (!status)
    4328                 :            :                 status = decode_write_verifier(xdr, &verf->verifier);
    4329                 :          0 :         if (!status)
    4330                 :          0 :                 verf->committed = NFS_FILE_SYNC;
    4331                 :          0 :         return status;
    4332                 :            : }
    4333                 :            : 
    4334                 :          0 : static int decode_create(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
    4335                 :            : {
    4336                 :            :         __be32 *p;
    4337                 :            :         uint32_t bmlen;
    4338                 :            :         int status;
    4339                 :            : 
    4340                 :            :         status = decode_op_hdr(xdr, OP_CREATE);
    4341                 :          0 :         if (status)
    4342                 :            :                 return status;
    4343                 :          0 :         if ((status = decode_change_info(xdr, cinfo)))
    4344                 :            :                 return status;
    4345                 :          0 :         p = xdr_inline_decode(xdr, 4);
    4346                 :          0 :         if (unlikely(!p))
    4347                 :            :                 return -EIO;
    4348                 :            :         bmlen = be32_to_cpup(p);
    4349                 :          0 :         p = xdr_inline_decode(xdr, bmlen << 2);
    4350                 :          0 :         if (likely(p))
    4351                 :            :                 return 0;
    4352                 :          0 :         return -EIO;
    4353                 :            : }
    4354                 :            : 
    4355                 :          0 : static int decode_server_caps(struct xdr_stream *xdr, struct nfs4_server_caps_res *res)
    4356                 :            : {
    4357                 :            :         unsigned int savep;
    4358                 :          0 :         uint32_t attrlen, bitmap[3] = {0};
    4359                 :            :         int status;
    4360                 :            : 
    4361                 :          0 :         if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
    4362                 :            :                 goto xdr_error;
    4363                 :          0 :         if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
    4364                 :            :                 goto xdr_error;
    4365                 :          0 :         if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
    4366                 :            :                 goto xdr_error;
    4367                 :          0 :         if ((status = decode_attr_supported(xdr, bitmap, res->attr_bitmask)) != 0)
    4368                 :            :                 goto xdr_error;
    4369                 :          0 :         if ((status = decode_attr_fh_expire_type(xdr, bitmap,
    4370                 :          0 :                                                  &res->fh_expire_type)) != 0)
    4371                 :            :                 goto xdr_error;
    4372                 :          0 :         if ((status = decode_attr_link_support(xdr, bitmap, &res->has_links)) != 0)
    4373                 :            :                 goto xdr_error;
    4374                 :          0 :         if ((status = decode_attr_symlink_support(xdr, bitmap, &res->has_symlinks)) != 0)
    4375                 :            :                 goto xdr_error;
    4376                 :          0 :         if ((status = decode_attr_aclsupport(xdr, bitmap, &res->acl_bitmask)) != 0)
    4377                 :            :                 goto xdr_error;
    4378                 :          0 :         if ((status = decode_attr_exclcreat_supported(xdr, bitmap,
    4379                 :          0 :                                 res->exclcreat_bitmask)) != 0)
    4380                 :            :                 goto xdr_error;
    4381                 :          0 :         status = verify_attr_len(xdr, savep, attrlen);
    4382                 :            : xdr_error:
    4383                 :            :         dprintk("%s: xdr returned %d!\n", __func__, -status);
    4384                 :          0 :         return status;
    4385                 :            : }
    4386                 :            : 
    4387                 :          0 : static int decode_statfs(struct xdr_stream *xdr, struct nfs_fsstat *fsstat)
    4388                 :            : {
    4389                 :            :         unsigned int savep;
    4390                 :          0 :         uint32_t attrlen, bitmap[3] = {0};
    4391                 :            :         int status;
    4392                 :            : 
    4393                 :          0 :         if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
    4394                 :            :                 goto xdr_error;
    4395                 :          0 :         if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
    4396                 :            :                 goto xdr_error;
    4397                 :          0 :         if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
    4398                 :            :                 goto xdr_error;
    4399                 :            : 
    4400                 :          0 :         if ((status = decode_attr_files_avail(xdr, bitmap, &fsstat->afiles)) != 0)
    4401                 :            :                 goto xdr_error;
    4402                 :          0 :         if ((status = decode_attr_files_free(xdr, bitmap, &fsstat->ffiles)) != 0)
    4403                 :            :                 goto xdr_error;
    4404                 :          0 :         if ((status = decode_attr_files_total(xdr, bitmap, &fsstat->tfiles)) != 0)
    4405                 :            :                 goto xdr_error;
    4406                 :            : 
    4407                 :            :         status = -EIO;
    4408                 :          0 :         if (unlikely(bitmap[0]))
    4409                 :            :                 goto xdr_error;
    4410                 :            : 
    4411                 :          0 :         if ((status = decode_attr_space_avail(xdr, bitmap, &fsstat->abytes)) != 0)
    4412                 :            :                 goto xdr_error;
    4413                 :          0 :         if ((status = decode_attr_space_free(xdr, bitmap, &fsstat->fbytes)) != 0)
    4414                 :            :                 goto xdr_error;
    4415                 :          0 :         if ((status = decode_attr_space_total(xdr, bitmap, &fsstat->tbytes)) != 0)
    4416                 :            :                 goto xdr_error;
    4417                 :            : 
    4418                 :          0 :         status = verify_attr_len(xdr, savep, attrlen);
    4419                 :            : xdr_error:
    4420                 :            :         dprintk("%s: xdr returned %d!\n", __func__, -status);
    4421                 :          0 :         return status;
    4422                 :            : }
    4423                 :            : 
    4424                 :          0 : static int decode_pathconf(struct xdr_stream *xdr, struct nfs_pathconf *pathconf)
    4425                 :            : {
    4426                 :            :         unsigned int savep;
    4427                 :          0 :         uint32_t attrlen, bitmap[3] = {0};
    4428                 :            :         int status;
    4429                 :            : 
    4430                 :          0 :         if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
    4431                 :            :                 goto xdr_error;
    4432                 :          0 :         if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
    4433                 :            :                 goto xdr_error;
    4434                 :          0 :         if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
    4435                 :            :                 goto xdr_error;
    4436                 :            : 
    4437                 :          0 :         if ((status = decode_attr_maxlink(xdr, bitmap, &pathconf->max_link)) != 0)
    4438                 :            :                 goto xdr_error;
    4439                 :          0 :         if ((status = decode_attr_maxname(xdr, bitmap, &pathconf->max_namelen)) != 0)
    4440                 :            :                 goto xdr_error;
    4441                 :            : 
    4442                 :          0 :         status = verify_attr_len(xdr, savep, attrlen);
    4443                 :            : xdr_error:
    4444                 :            :         dprintk("%s: xdr returned %d!\n", __func__, -status);
    4445                 :          0 :         return status;
    4446                 :            : }
    4447                 :            : 
    4448                 :          0 : static int decode_threshold_hint(struct xdr_stream *xdr,
    4449                 :            :                                   uint32_t *bitmap,
    4450                 :            :                                   uint64_t *res,
    4451                 :            :                                   uint32_t hint_bit)
    4452                 :            : {
    4453                 :            :         __be32 *p;
    4454                 :            : 
    4455                 :          0 :         *res = 0;
    4456                 :          0 :         if (likely(bitmap[0] & hint_bit)) {
    4457                 :          0 :                 p = xdr_inline_decode(xdr, 8);
    4458                 :          0 :                 if (unlikely(!p))
    4459                 :            :                         return -EIO;
    4460                 :            :                 xdr_decode_hyper(p, res);
    4461                 :            :         }
    4462                 :            :         return 0;
    4463                 :            : }
    4464                 :            : 
    4465                 :          0 : static int decode_first_threshold_item4(struct xdr_stream *xdr,
    4466                 :            :                                         struct nfs4_threshold *res)
    4467                 :            : {
    4468                 :            :         __be32 *p;
    4469                 :            :         unsigned int savep;
    4470                 :          0 :         uint32_t bitmap[3] = {0,}, attrlen;
    4471                 :            :         int status;
    4472                 :            : 
    4473                 :            :         /* layout type */
    4474                 :          0 :         p = xdr_inline_decode(xdr, 4);
    4475                 :          0 :         if (unlikely(!p))
    4476                 :            :                 return -EIO;
    4477                 :          0 :         res->l_type = be32_to_cpup(p);
    4478                 :            : 
    4479                 :            :         /* thi_hintset bitmap */
    4480                 :          0 :         status = decode_attr_bitmap(xdr, bitmap);
    4481                 :          0 :         if (status < 0)
    4482                 :            :                 goto xdr_error;
    4483                 :            : 
    4484                 :            :         /* thi_hintlist length */
    4485                 :          0 :         status = decode_attr_length(xdr, &attrlen, &savep);
    4486                 :          0 :         if (status < 0)
    4487                 :            :                 goto xdr_error;
    4488                 :            :         /* thi_hintlist */
    4489                 :          0 :         status = decode_threshold_hint(xdr, bitmap, &res->rd_sz, THRESHOLD_RD);
    4490                 :          0 :         if (status < 0)
    4491                 :            :                 goto xdr_error;
    4492                 :          0 :         status = decode_threshold_hint(xdr, bitmap, &res->wr_sz, THRESHOLD_WR);
    4493                 :          0 :         if (status < 0)
    4494                 :            :                 goto xdr_error;
    4495                 :          0 :         status = decode_threshold_hint(xdr, bitmap, &res->rd_io_sz,
    4496                 :            :                                        THRESHOLD_RD_IO);
    4497                 :          0 :         if (status < 0)
    4498                 :            :                 goto xdr_error;
    4499                 :          0 :         status = decode_threshold_hint(xdr, bitmap, &res->wr_io_sz,
    4500                 :            :                                        THRESHOLD_WR_IO);
    4501                 :          0 :         if (status < 0)
    4502                 :            :                 goto xdr_error;
    4503                 :            : 
    4504                 :          0 :         status = verify_attr_len(xdr, savep, attrlen);
    4505                 :          0 :         res->bm = bitmap[0];
    4506                 :            : 
    4507                 :            :         dprintk("%s bm=0x%x rd_sz=%llu wr_sz=%llu rd_io=%llu wr_io=%llu\n",
    4508                 :            :                  __func__, res->bm, res->rd_sz, res->wr_sz, res->rd_io_sz,
    4509                 :            :                 res->wr_io_sz);
    4510                 :            : xdr_error:
    4511                 :            :         dprintk("%s ret=%d!\n", __func__, status);
    4512                 :          0 :         return status;
    4513                 :            : }
    4514                 :            : 
    4515                 :            : /*
    4516                 :            :  * Thresholds on pNFS direct I/O vrs MDS I/O
    4517                 :            :  */
    4518                 :          0 : static int decode_attr_mdsthreshold(struct xdr_stream *xdr,
    4519                 :            :                                     uint32_t *bitmap,
    4520                 :            :                                     struct nfs4_threshold *res)
    4521                 :            : {
    4522                 :            :         __be32 *p;
    4523                 :            :         int status = 0;
    4524                 :            :         uint32_t num;
    4525                 :            : 
    4526                 :          0 :         if (unlikely(bitmap[2] & (FATTR4_WORD2_MDSTHRESHOLD - 1U)))
    4527                 :            :                 return -EIO;
    4528                 :          0 :         if (bitmap[2] & FATTR4_WORD2_MDSTHRESHOLD) {
    4529                 :            :                 /* Did the server return an unrequested attribute? */
    4530                 :          0 :                 if (unlikely(res == NULL))
    4531                 :            :                         return -EREMOTEIO;
    4532                 :          0 :                 p = xdr_inline_decode(xdr, 4);
    4533                 :          0 :                 if (unlikely(!p))
    4534                 :            :                         return -EIO;
    4535                 :            :                 num = be32_to_cpup(p);
    4536                 :          0 :                 if (num == 0)
    4537                 :            :                         return 0;
    4538                 :          0 :                 if (num > 1)
    4539                 :          0 :                         printk(KERN_INFO "%s: Warning: Multiple pNFS layout "
    4540                 :            :                                 "drivers per filesystem not supported\n",
    4541                 :            :                                 __func__);
    4542                 :            : 
    4543                 :          0 :                 status = decode_first_threshold_item4(xdr, res);
    4544                 :          0 :                 bitmap[2] &= ~FATTR4_WORD2_MDSTHRESHOLD;
    4545                 :            :         }
    4546                 :          0 :         return status;
    4547                 :            : }
    4548                 :            : 
    4549                 :          0 : static int decode_getfattr_attrs(struct xdr_stream *xdr, uint32_t *bitmap,
    4550                 :            :                 struct nfs_fattr *fattr, struct nfs_fh *fh,
    4551                 :            :                 struct nfs4_fs_locations *fs_loc, struct nfs4_label *label,
    4552                 :            :                 const struct nfs_server *server)
    4553                 :            : {
    4554                 :            :         int status;
    4555                 :          0 :         umode_t fmode = 0;
    4556                 :            :         uint32_t type;
    4557                 :            :         int32_t err;
    4558                 :            : 
    4559                 :          0 :         status = decode_attr_type(xdr, bitmap, &type);
    4560                 :          0 :         if (status < 0)
    4561                 :            :                 goto xdr_error;
    4562                 :          0 :         fattr->mode = 0;
    4563                 :          0 :         if (status != 0) {
    4564                 :          0 :                 fattr->mode |= nfs_type2fmt[type];
    4565                 :          0 :                 fattr->valid |= status;
    4566                 :            :         }
    4567                 :            : 
    4568                 :          0 :         status = decode_attr_change(xdr, bitmap, &fattr->change_attr);
    4569                 :          0 :         if (status < 0)
    4570                 :            :                 goto xdr_error;
    4571                 :          0 :         fattr->valid |= status;
    4572                 :            : 
    4573                 :          0 :         status = decode_attr_size(xdr, bitmap, &fattr->size);
    4574                 :          0 :         if (status < 0)
    4575                 :            :                 goto xdr_error;
    4576                 :          0 :         fattr->valid |= status;
    4577                 :            : 
    4578                 :          0 :         status = decode_attr_fsid(xdr, bitmap, &fattr->fsid);
    4579                 :          0 :         if (status < 0)
    4580                 :            :                 goto xdr_error;
    4581                 :          0 :         fattr->valid |= status;
    4582                 :            : 
    4583                 :          0 :         err = 0;
    4584                 :          0 :         status = decode_attr_error(xdr, bitmap, &err);
    4585                 :          0 :         if (status < 0)
    4586                 :            :                 goto xdr_error;
    4587                 :            : 
    4588                 :          0 :         status = decode_attr_filehandle(xdr, bitmap, fh);
    4589                 :          0 :         if (status < 0)
    4590                 :            :                 goto xdr_error;
    4591                 :            : 
    4592                 :          0 :         status = decode_attr_fileid(xdr, bitmap, &fattr->fileid);
    4593                 :          0 :         if (status < 0)
    4594                 :            :                 goto xdr_error;
    4595                 :          0 :         fattr->valid |= status;
    4596                 :            : 
    4597                 :          0 :         status = decode_attr_fs_locations(xdr, bitmap, fs_loc);
    4598                 :          0 :         if (status < 0)
    4599                 :            :                 goto xdr_error;
    4600                 :          0 :         fattr->valid |= status;
    4601                 :            : 
    4602                 :            :         status = -EIO;
    4603                 :          0 :         if (unlikely(bitmap[0]))
    4604                 :            :                 goto xdr_error;
    4605                 :            : 
    4606                 :          0 :         status = decode_attr_mode(xdr, bitmap, &fmode);
    4607                 :          0 :         if (status < 0)
    4608                 :            :                 goto xdr_error;
    4609                 :          0 :         if (status != 0) {
    4610                 :          0 :                 fattr->mode |= fmode;
    4611                 :          0 :                 fattr->valid |= status;
    4612                 :            :         }
    4613                 :            : 
    4614                 :          0 :         status = decode_attr_nlink(xdr, bitmap, &fattr->nlink);
    4615                 :          0 :         if (status < 0)
    4616                 :            :                 goto xdr_error;
    4617                 :          0 :         fattr->valid |= status;
    4618                 :            : 
    4619                 :          0 :         status = decode_attr_owner(xdr, bitmap, server, &fattr->uid, fattr->owner_name);
    4620                 :          0 :         if (status < 0)
    4621                 :            :                 goto xdr_error;
    4622                 :          0 :         fattr->valid |= status;
    4623                 :            : 
    4624                 :          0 :         status = decode_attr_group(xdr, bitmap, server, &fattr->gid, fattr->group_name);
    4625                 :          0 :         if (status < 0)
    4626                 :            :                 goto xdr_error;
    4627                 :          0 :         fattr->valid |= status;
    4628                 :            : 
    4629                 :          0 :         status = decode_attr_rdev(xdr, bitmap, &fattr->rdev);
    4630                 :          0 :         if (status < 0)
    4631                 :            :                 goto xdr_error;
    4632                 :          0 :         fattr->valid |= status;
    4633                 :            : 
    4634                 :          0 :         status = decode_attr_space_used(xdr, bitmap, &fattr->du.nfs3.used);
    4635                 :          0 :         if (status < 0)
    4636                 :            :                 goto xdr_error;
    4637                 :          0 :         fattr->valid |= status;
    4638                 :            : 
    4639                 :          0 :         status = decode_attr_time_access(xdr, bitmap, &fattr->atime);
    4640                 :          0 :         if (status < 0)
    4641                 :            :                 goto xdr_error;
    4642                 :          0 :         fattr->valid |= status;
    4643                 :            : 
    4644                 :          0 :         status = decode_attr_time_metadata(xdr, bitmap, &fattr->ctime);
    4645                 :          0 :         if (status < 0)
    4646                 :            :                 goto xdr_error;
    4647                 :          0 :         fattr->valid |= status;
    4648                 :            : 
    4649                 :          0 :         status = decode_attr_time_modify(xdr, bitmap, &fattr->mtime);
    4650                 :          0 :         if (status < 0)
    4651                 :            :                 goto xdr_error;
    4652                 :          0 :         fattr->valid |= status;
    4653                 :            : 
    4654                 :          0 :         status = decode_attr_mounted_on_fileid(xdr, bitmap, &fattr->mounted_on_fileid);
    4655                 :          0 :         if (status < 0)
    4656                 :            :                 goto xdr_error;
    4657                 :          0 :         fattr->valid |= status;
    4658                 :            : 
    4659                 :            :         status = -EIO;
    4660                 :          0 :         if (unlikely(bitmap[1]))
    4661                 :            :                 goto xdr_error;
    4662                 :            : 
    4663                 :          0 :         status = decode_attr_mdsthreshold(xdr, bitmap, fattr->mdsthreshold);
    4664                 :          0 :         if (status < 0)
    4665                 :            :                 goto xdr_error;
    4666                 :            : 
    4667                 :          0 :         if (label) {
    4668                 :          0 :                 status = decode_attr_security_label(xdr, bitmap, label);
    4669                 :          0 :                 if (status < 0)
    4670                 :            :                         goto xdr_error;
    4671                 :          0 :                 fattr->valid |= status;
    4672                 :            :         }
    4673                 :            : 
    4674                 :            : xdr_error:
    4675                 :            :         dprintk("%s: xdr returned %d\n", __func__, -status);
    4676                 :          0 :         return status;
    4677                 :            : }
    4678                 :            : 
    4679                 :          0 : static int decode_getfattr_generic(struct xdr_stream *xdr, struct nfs_fattr *fattr,
    4680                 :            :                 struct nfs_fh *fh, struct nfs4_fs_locations *fs_loc,
    4681                 :            :                 struct nfs4_label *label, const struct nfs_server *server)
    4682                 :            : {
    4683                 :            :         unsigned int savep;
    4684                 :            :         uint32_t attrlen,
    4685                 :          0 :                  bitmap[3] = {0};
    4686                 :            :         int status;
    4687                 :            : 
    4688                 :            :         status = decode_op_hdr(xdr, OP_GETATTR);
    4689                 :          0 :         if (status < 0)
    4690                 :            :                 goto xdr_error;
    4691                 :            : 
    4692                 :          0 :         status = decode_attr_bitmap(xdr, bitmap);
    4693                 :          0 :         if (status < 0)
    4694                 :            :                 goto xdr_error;
    4695                 :            : 
    4696                 :          0 :         status = decode_attr_length(xdr, &attrlen, &savep);
    4697                 :          0 :         if (status < 0)
    4698                 :            :                 goto xdr_error;
    4699                 :            : 
    4700                 :          0 :         status = decode_getfattr_attrs(xdr, bitmap, fattr, fh, fs_loc,
    4701                 :            :                                         label, server);
    4702                 :          0 :         if (status < 0)
    4703                 :            :                 goto xdr_error;
    4704                 :            : 
    4705                 :          0 :         status = verify_attr_len(xdr, savep, attrlen);
    4706                 :            : xdr_error:
    4707                 :            :         dprintk("%s: xdr returned %d\n", __func__, -status);
    4708                 :          0 :         return status;
    4709                 :            : }
    4710                 :            : 
    4711                 :            : static int decode_getfattr_label(struct xdr_stream *xdr, struct nfs_fattr *fattr,
    4712                 :            :                 struct nfs4_label *label, const struct nfs_server *server)
    4713                 :            : {
    4714                 :          0 :         return decode_getfattr_generic(xdr, fattr, NULL, NULL, label, server);
    4715                 :            : }
    4716                 :            : 
    4717                 :            : static int decode_getfattr(struct xdr_stream *xdr, struct nfs_fattr *fattr,
    4718                 :            :                 const struct nfs_server *server)
    4719                 :            : {
    4720                 :          0 :         return decode_getfattr_generic(xdr, fattr, NULL, NULL, NULL, server);
    4721                 :            : }
    4722                 :            : 
    4723                 :            : /*
    4724                 :            :  * Decode potentially multiple layout types.
    4725                 :            :  */
    4726                 :          0 : static int decode_pnfs_layout_types(struct xdr_stream *xdr,
    4727                 :            :                                     struct nfs_fsinfo *fsinfo)
    4728                 :            : {
    4729                 :            :         __be32 *p;
    4730                 :            :         uint32_t i;
    4731                 :            : 
    4732                 :          0 :         p = xdr_inline_decode(xdr, 4);
    4733                 :          0 :         if (unlikely(!p))
    4734                 :            :                 return -EIO;
    4735                 :          0 :         fsinfo->nlayouttypes = be32_to_cpup(p);
    4736                 :            : 
    4737                 :            :         /* pNFS is not supported by the underlying file system */
    4738                 :          0 :         if (fsinfo->nlayouttypes == 0)
    4739                 :            :                 return 0;
    4740                 :            : 
    4741                 :            :         /* Decode and set first layout type, move xdr->p past unused types */
    4742                 :          0 :         p = xdr_inline_decode(xdr, fsinfo->nlayouttypes * 4);
    4743                 :          0 :         if (unlikely(!p))
    4744                 :            :                 return -EIO;
    4745                 :            : 
    4746                 :            :         /* If we get too many, then just cap it at the max */
    4747                 :          0 :         if (fsinfo->nlayouttypes > NFS_MAX_LAYOUT_TYPES) {
    4748                 :          0 :                 printk(KERN_INFO "NFS: %s: Warning: Too many (%u) pNFS layout types\n",
    4749                 :            :                         __func__, fsinfo->nlayouttypes);
    4750                 :          0 :                 fsinfo->nlayouttypes = NFS_MAX_LAYOUT_TYPES;
    4751                 :            :         }
    4752                 :            : 
    4753                 :          0 :         for(i = 0; i < fsinfo->nlayouttypes; ++i)
    4754                 :          0 :                 fsinfo->layouttype[i] = be32_to_cpup(p++);
    4755                 :            :         return 0;
    4756                 :            : }
    4757                 :            : 
    4758                 :            : /*
    4759                 :            :  * The type of file system exported.
    4760                 :            :  * Note we must ensure that layouttype is set in any non-error case.
    4761                 :            :  */
    4762                 :          0 : static int decode_attr_pnfstype(struct xdr_stream *xdr, uint32_t *bitmap,
    4763                 :            :                                 struct nfs_fsinfo *fsinfo)
    4764                 :            : {
    4765                 :            :         int status = 0;
    4766                 :            : 
    4767                 :            :         dprintk("%s: bitmap is %x\n", __func__, bitmap[1]);
    4768                 :          0 :         if (unlikely(bitmap[1] & (FATTR4_WORD1_FS_LAYOUT_TYPES - 1U)))
    4769                 :            :                 return -EIO;
    4770                 :          0 :         if (bitmap[1] & FATTR4_WORD1_FS_LAYOUT_TYPES) {
    4771                 :          0 :                 status = decode_pnfs_layout_types(xdr, fsinfo);
    4772                 :          0 :                 bitmap[1] &= ~FATTR4_WORD1_FS_LAYOUT_TYPES;
    4773                 :            :         }
    4774                 :          0 :         return status;
    4775                 :            : }
    4776                 :            : 
    4777                 :            : /*
    4778                 :            :  * The prefered block size for layout directed io
    4779                 :            :  */
    4780                 :          0 : static int decode_attr_layout_blksize(struct xdr_stream *xdr, uint32_t *bitmap,
    4781                 :            :                                       uint32_t *res)
    4782                 :            : {
    4783                 :            :         __be32 *p;
    4784                 :            : 
    4785                 :            :         dprintk("%s: bitmap is %x\n", __func__, bitmap[2]);
    4786                 :          0 :         *res = 0;
    4787                 :          0 :         if (bitmap[2] & FATTR4_WORD2_LAYOUT_BLKSIZE) {
    4788                 :          0 :                 p = xdr_inline_decode(xdr, 4);
    4789                 :          0 :                 if (unlikely(!p))
    4790                 :            :                         return -EIO;
    4791                 :          0 :                 *res = be32_to_cpup(p);
    4792                 :          0 :                 bitmap[2] &= ~FATTR4_WORD2_LAYOUT_BLKSIZE;
    4793                 :            :         }
    4794                 :            :         return 0;
    4795                 :            : }
    4796                 :            : 
    4797                 :            : /*
    4798                 :            :  * The granularity of a CLONE operation.
    4799                 :            :  */
    4800                 :          0 : static int decode_attr_clone_blksize(struct xdr_stream *xdr, uint32_t *bitmap,
    4801                 :            :                                      uint32_t *res)
    4802                 :            : {
    4803                 :            :         __be32 *p;
    4804                 :            : 
    4805                 :            :         dprintk("%s: bitmap is %x\n", __func__, bitmap[2]);
    4806                 :          0 :         *res = 0;
    4807                 :          0 :         if (bitmap[2] & FATTR4_WORD2_CLONE_BLKSIZE) {
    4808                 :          0 :                 p = xdr_inline_decode(xdr, 4);
    4809                 :          0 :                 if (unlikely(!p))
    4810                 :            :                         return -EIO;
    4811                 :          0 :                 *res = be32_to_cpup(p);
    4812                 :          0 :                 bitmap[2] &= ~FATTR4_WORD2_CLONE_BLKSIZE;
    4813                 :            :         }
    4814                 :            :         return 0;
    4815                 :            : }
    4816                 :            : 
    4817                 :          0 : static int decode_fsinfo(struct xdr_stream *xdr, struct nfs_fsinfo *fsinfo)
    4818                 :            : {
    4819                 :            :         unsigned int savep;
    4820                 :            :         uint32_t attrlen, bitmap[3];
    4821                 :            :         int status;
    4822                 :            : 
    4823                 :          0 :         if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
    4824                 :            :                 goto xdr_error;
    4825                 :          0 :         if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
    4826                 :            :                 goto xdr_error;
    4827                 :          0 :         if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
    4828                 :            :                 goto xdr_error;
    4829                 :            : 
    4830                 :          0 :         fsinfo->rtmult = fsinfo->wtmult = 512;    /* ??? */
    4831                 :            : 
    4832                 :          0 :         if ((status = decode_attr_lease_time(xdr, bitmap, &fsinfo->lease_time)) != 0)
    4833                 :            :                 goto xdr_error;
    4834                 :          0 :         if ((status = decode_attr_maxfilesize(xdr, bitmap, &fsinfo->maxfilesize)) != 0)
    4835                 :            :                 goto xdr_error;
    4836                 :          0 :         if ((status = decode_attr_maxread(xdr, bitmap, &fsinfo->rtmax)) != 0)
    4837                 :            :                 goto xdr_error;
    4838                 :          0 :         fsinfo->rtpref = fsinfo->dtpref = fsinfo->rtmax;
    4839                 :          0 :         if ((status = decode_attr_maxwrite(xdr, bitmap, &fsinfo->wtmax)) != 0)
    4840                 :            :                 goto xdr_error;
    4841                 :          0 :         fsinfo->wtpref = fsinfo->wtmax;
    4842                 :            : 
    4843                 :            :         status = -EIO;
    4844                 :          0 :         if (unlikely(bitmap[0]))
    4845                 :            :                 goto xdr_error;
    4846                 :            : 
    4847                 :          0 :         status = decode_attr_time_delta(xdr, bitmap, &fsinfo->time_delta);
    4848                 :          0 :         if (status != 0)
    4849                 :            :                 goto xdr_error;
    4850                 :          0 :         status = decode_attr_pnfstype(xdr, bitmap, fsinfo);
    4851                 :          0 :         if (status != 0)
    4852                 :            :                 goto xdr_error;
    4853                 :            : 
    4854                 :            :         status = -EIO;
    4855                 :          0 :         if (unlikely(bitmap[1]))
    4856                 :            :                 goto xdr_error;
    4857                 :            : 
    4858                 :          0 :         status = decode_attr_layout_blksize(xdr, bitmap, &fsinfo->blksize);
    4859                 :          0 :         if (status)
    4860                 :            :                 goto xdr_error;
    4861                 :          0 :         status = decode_attr_clone_blksize(xdr, bitmap, &fsinfo->clone_blksize);
    4862                 :          0 :         if (status)
    4863                 :            :                 goto xdr_error;
    4864                 :            : 
    4865                 :          0 :         status = verify_attr_len(xdr, savep, attrlen);
    4866                 :            : xdr_error:
    4867                 :            :         dprintk("%s: xdr returned %d!\n", __func__, -status);
    4868                 :          0 :         return status;
    4869                 :            : }
    4870                 :            : 
    4871                 :          0 : static int decode_getfh(struct xdr_stream *xdr, struct nfs_fh *fh)
    4872                 :            : {
    4873                 :            :         __be32 *p;
    4874                 :            :         uint32_t len;
    4875                 :            :         int status;
    4876                 :            : 
    4877                 :            :         /* Zero handle first to allow comparisons */
    4878                 :          0 :         memset(fh, 0, sizeof(*fh));
    4879                 :            : 
    4880                 :            :         status = decode_op_hdr(xdr, OP_GETFH);
    4881                 :          0 :         if (status)
    4882                 :            :                 return status;
    4883                 :            : 
    4884                 :          0 :         p = xdr_inline_decode(xdr, 4);
    4885                 :          0 :         if (unlikely(!p))
    4886                 :            :                 return -EIO;
    4887                 :            :         len = be32_to_cpup(p);
    4888                 :          0 :         if (len > NFS4_FHSIZE)
    4889                 :            :                 return -EIO;
    4890                 :          0 :         fh->size = len;
    4891                 :          0 :         p = xdr_inline_decode(xdr, len);
    4892                 :          0 :         if (unlikely(!p))
    4893                 :            :                 return -EIO;
    4894                 :          0 :         memcpy(fh->data, p, len);
    4895                 :          0 :         return 0;
    4896                 :            : }
    4897                 :            : 
    4898                 :          0 : static int decode_link(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
    4899                 :            : {
    4900                 :            :         int status;
    4901                 :            : 
    4902                 :            :         status = decode_op_hdr(xdr, OP_LINK);
    4903                 :          0 :         if (status)
    4904                 :            :                 return status;
    4905                 :          0 :         return decode_change_info(xdr, cinfo);
    4906                 :            : }
    4907                 :            : 
    4908                 :            : /*
    4909                 :            :  * We create the owner, so we know a proper owner.id length is 4.
    4910                 :            :  */
    4911                 :          0 : static int decode_lock_denied (struct xdr_stream *xdr, struct file_lock *fl)
    4912                 :            : {
    4913                 :            :         uint64_t offset, length, clientid;
    4914                 :            :         __be32 *p;
    4915                 :            :         uint32_t namelen, type;
    4916                 :            : 
    4917                 :          0 :         p = xdr_inline_decode(xdr, 32); /* read 32 bytes */
    4918                 :          0 :         if (unlikely(!p))
    4919                 :            :                 return -EIO;
    4920                 :            :         p = xdr_decode_hyper(p, &offset); /* read 2 8-byte long words */
    4921                 :            :         p = xdr_decode_hyper(p, &length);
    4922                 :            :         type = be32_to_cpup(p++); /* 4 byte read */
    4923                 :          0 :         if (fl != NULL) { /* manipulate file lock */
    4924                 :          0 :                 fl->fl_start = (loff_t)offset;
    4925                 :          0 :                 fl->fl_end = fl->fl_start + (loff_t)length - 1;
    4926                 :          0 :                 if (length == ~(uint64_t)0)
    4927                 :          0 :                         fl->fl_end = OFFSET_MAX;
    4928                 :          0 :                 fl->fl_type = F_WRLCK;
    4929                 :          0 :                 if (type & 1)
    4930                 :          0 :                         fl->fl_type = F_RDLCK;
    4931                 :          0 :                 fl->fl_pid = 0;
    4932                 :            :         }
    4933                 :            :         p = xdr_decode_hyper(p, &clientid); /* read 8 bytes */
    4934                 :            :         namelen = be32_to_cpup(p); /* read 4 bytes */  /* have read all 32 bytes now */
    4935                 :          0 :         p = xdr_inline_decode(xdr, namelen); /* variable size field */
    4936                 :          0 :         if (likely(!p))
    4937                 :            :                 return -EIO;
    4938                 :          0 :         return -NFS4ERR_DENIED;
    4939                 :            : }
    4940                 :            : 
    4941                 :          0 : static int decode_lock(struct xdr_stream *xdr, struct nfs_lock_res *res)
    4942                 :            : {
    4943                 :            :         int status;
    4944                 :            : 
    4945                 :            :         status = decode_op_hdr(xdr, OP_LOCK);
    4946                 :          0 :         if (status == -EIO)
    4947                 :            :                 goto out;
    4948                 :          0 :         if (status == 0) {
    4949                 :          0 :                 status = decode_lock_stateid(xdr, &res->stateid);
    4950                 :          0 :                 if (unlikely(status))
    4951                 :            :                         goto out;
    4952                 :          0 :         } else if (status == -NFS4ERR_DENIED)
    4953                 :          0 :                 status = decode_lock_denied(xdr, NULL);
    4954                 :          0 :         if (res->open_seqid != NULL)
    4955                 :          0 :                 nfs_increment_open_seqid(status, res->open_seqid);
    4956                 :          0 :         nfs_increment_lock_seqid(status, res->lock_seqid);
    4957                 :            : out:
    4958                 :          0 :         return status;
    4959                 :            : }
    4960                 :            : 
    4961                 :          0 : static int decode_lockt(struct xdr_stream *xdr, struct nfs_lockt_res *res)
    4962                 :            : {
    4963                 :            :         int status;
    4964                 :            :         status = decode_op_hdr(xdr, OP_LOCKT);
    4965                 :          0 :         if (status == -NFS4ERR_DENIED)
    4966                 :          0 :                 return decode_lock_denied(xdr, res->denied);
    4967                 :            :         return status;
    4968                 :            : }
    4969                 :            : 
    4970                 :          0 : static int decode_locku(struct xdr_stream *xdr, struct nfs_locku_res *res)
    4971                 :            : {
    4972                 :            :         int status;
    4973                 :            : 
    4974                 :            :         status = decode_op_hdr(xdr, OP_LOCKU);
    4975                 :          0 :         if (status != -EIO)
    4976                 :          0 :                 nfs_increment_lock_seqid(status, res->seqid);
    4977                 :          0 :         if (status == 0)
    4978                 :          0 :                 status = decode_lock_stateid(xdr, &res->stateid);
    4979                 :          0 :         return status;
    4980                 :            : }
    4981                 :            : 
    4982                 :            : static int decode_release_lockowner(struct xdr_stream *xdr)
    4983                 :            : {
    4984                 :            :         return decode_op_hdr(xdr, OP_RELEASE_LOCKOWNER);
    4985                 :            : }
    4986                 :            : 
    4987                 :            : static int decode_lookup(struct xdr_stream *xdr)
    4988                 :            : {
    4989                 :            :         return decode_op_hdr(xdr, OP_LOOKUP);
    4990                 :            : }
    4991                 :            : 
    4992                 :            : static int decode_lookupp(struct xdr_stream *xdr)
    4993                 :            : {
    4994                 :            :         return decode_op_hdr(xdr, OP_LOOKUPP);
    4995                 :            : }
    4996                 :            : 
    4997                 :            : /* This is too sick! */
    4998                 :          0 : static int decode_space_limit(struct xdr_stream *xdr,
    4999                 :            :                 unsigned long *pagemod_limit)
    5000                 :            : {
    5001                 :            :         __be32 *p;
    5002                 :            :         uint32_t limit_type, nblocks, blocksize;
    5003                 :            :         u64 maxsize = 0;
    5004                 :            : 
    5005                 :          0 :         p = xdr_inline_decode(xdr, 12);
    5006                 :          0 :         if (unlikely(!p))
    5007                 :            :                 return -EIO;
    5008                 :          0 :         limit_type = be32_to_cpup(p++);
    5009                 :          0 :         switch (limit_type) {
    5010                 :            :         case NFS4_LIMIT_SIZE:
    5011                 :            :                 xdr_decode_hyper(p, &maxsize);
    5012                 :            :                 break;
    5013                 :            :         case NFS4_LIMIT_BLOCKS:
    5014                 :            :                 nblocks = be32_to_cpup(p++);
    5015                 :            :                 blocksize = be32_to_cpup(p);
    5016                 :          0 :                 maxsize = (uint64_t)nblocks * (uint64_t)blocksize;
    5017                 :            :         }
    5018                 :          0 :         maxsize >>= PAGE_SHIFT;
    5019                 :          0 :         *pagemod_limit = min_t(u64, maxsize, ULONG_MAX);
    5020                 :          0 :         return 0;
    5021                 :            : }
    5022                 :            : 
    5023                 :          0 : static int decode_rw_delegation(struct xdr_stream *xdr,
    5024                 :            :                 uint32_t delegation_type,
    5025                 :            :                 struct nfs_openres *res)
    5026                 :            : {
    5027                 :            :         __be32 *p;
    5028                 :            :         int status;
    5029                 :            : 
    5030                 :          0 :         status = decode_delegation_stateid(xdr, &res->delegation);
    5031                 :          0 :         if (unlikely(status))
    5032                 :            :                 return status;
    5033                 :          0 :         p = xdr_inline_decode(xdr, 4);
    5034                 :          0 :         if (unlikely(!p))
    5035                 :            :                 return -EIO;
    5036                 :          0 :         res->do_recall = be32_to_cpup(p);
    5037                 :            : 
    5038                 :          0 :         switch (delegation_type) {
    5039                 :            :         case NFS4_OPEN_DELEGATE_READ:
    5040                 :          0 :                 res->delegation_type = FMODE_READ;
    5041                 :          0 :                 break;
    5042                 :            :         case NFS4_OPEN_DELEGATE_WRITE:
    5043                 :          0 :                 res->delegation_type = FMODE_WRITE|FMODE_READ;
    5044                 :          0 :                 if (decode_space_limit(xdr, &res->pagemod_limit) < 0)
    5045                 :            :                                 return -EIO;
    5046                 :            :         }
    5047                 :          0 :         return decode_ace(xdr, NULL);
    5048                 :            : }
    5049                 :            : 
    5050                 :          0 : static int decode_no_delegation(struct xdr_stream *xdr, struct nfs_openres *res)
    5051                 :            : {
    5052                 :            :         __be32 *p;
    5053                 :            :         uint32_t why_no_delegation;
    5054                 :            : 
    5055                 :          0 :         p = xdr_inline_decode(xdr, 4);
    5056                 :          0 :         if (unlikely(!p))
    5057                 :            :                 return -EIO;
    5058                 :            :         why_no_delegation = be32_to_cpup(p);
    5059                 :          0 :         switch (why_no_delegation) {
    5060                 :            :                 case WND4_CONTENTION:
    5061                 :            :                 case WND4_RESOURCE:
    5062                 :          0 :                         xdr_inline_decode(xdr, 4);
    5063                 :            :                         /* Ignore for now */
    5064                 :            :         }
    5065                 :            :         return 0;
    5066                 :            : }
    5067                 :            : 
    5068                 :          0 : static int decode_delegation(struct xdr_stream *xdr, struct nfs_openres *res)
    5069                 :            : {
    5070                 :            :         __be32 *p;
    5071                 :            :         uint32_t delegation_type;
    5072                 :            : 
    5073                 :          0 :         p = xdr_inline_decode(xdr, 4);
    5074                 :          0 :         if (unlikely(!p))
    5075                 :            :                 return -EIO;
    5076                 :            :         delegation_type = be32_to_cpup(p);
    5077                 :          0 :         res->delegation_type = 0;
    5078                 :          0 :         switch (delegation_type) {
    5079                 :            :         case NFS4_OPEN_DELEGATE_NONE:
    5080                 :            :                 return 0;
    5081                 :            :         case NFS4_OPEN_DELEGATE_READ:
    5082                 :            :         case NFS4_OPEN_DELEGATE_WRITE:
    5083                 :          0 :                 return decode_rw_delegation(xdr, delegation_type, res);
    5084                 :            :         case NFS4_OPEN_DELEGATE_NONE_EXT:
    5085                 :          0 :                 return decode_no_delegation(xdr, res);
    5086                 :            :         }
    5087                 :          0 :         return -EIO;
    5088                 :            : }
    5089                 :            : 
    5090                 :          0 : static int decode_open(struct xdr_stream *xdr, struct nfs_openres *res)
    5091                 :            : {
    5092                 :            :         __be32 *p;
    5093                 :            :         uint32_t savewords, bmlen, i;
    5094                 :            :         int status;
    5095                 :            : 
    5096                 :          0 :         if (!__decode_op_hdr(xdr, OP_OPEN, &status))
    5097                 :          0 :                 return status;
    5098                 :          0 :         nfs_increment_open_seqid(status, res->seqid);
    5099                 :          0 :         if (status)
    5100                 :            :                 return status;
    5101                 :          0 :         status = decode_open_stateid(xdr, &res->stateid);
    5102                 :          0 :         if (unlikely(status))
    5103                 :            :                 return status;
    5104                 :            : 
    5105                 :          0 :         decode_change_info(xdr, &res->cinfo);
    5106                 :            : 
    5107                 :          0 :         p = xdr_inline_decode(xdr, 8);
    5108                 :          0 :         if (unlikely(!p))
    5109                 :            :                 return -EIO;
    5110                 :          0 :         res->rflags = be32_to_cpup(p++);
    5111                 :            :         bmlen = be32_to_cpup(p);
    5112                 :          0 :         if (bmlen > 10)
    5113                 :            :                 goto xdr_error;
    5114                 :            : 
    5115                 :          0 :         p = xdr_inline_decode(xdr, bmlen << 2);
    5116                 :          0 :         if (unlikely(!p))
    5117                 :            :                 return -EIO;
    5118                 :          0 :         savewords = min_t(uint32_t, bmlen, NFS4_BITMAP_SIZE);
    5119                 :          0 :         for (i = 0; i < savewords; ++i)
    5120                 :          0 :                 res->attrset[i] = be32_to_cpup(p++);
    5121                 :          0 :         for (; i < NFS4_BITMAP_SIZE; i++)
    5122                 :          0 :                 res->attrset[i] = 0;
    5123                 :            : 
    5124                 :          0 :         return decode_delegation(xdr, res);
    5125                 :            : xdr_error:
    5126                 :            :         dprintk("%s: Bitmap too large! Length = %u\n", __func__, bmlen);
    5127                 :            :         return -EIO;
    5128                 :            : }
    5129                 :            : 
    5130                 :          0 : static int decode_open_confirm(struct xdr_stream *xdr, struct nfs_open_confirmres *res)
    5131                 :            : {
    5132                 :            :         int status;
    5133                 :            : 
    5134                 :            :         status = decode_op_hdr(xdr, OP_OPEN_CONFIRM);
    5135                 :          0 :         if (status != -EIO)
    5136                 :          0 :                 nfs_increment_open_seqid(status, res->seqid);
    5137                 :          0 :         if (!status)
    5138                 :          0 :                 status = decode_open_stateid(xdr, &res->stateid);
    5139                 :          0 :         return status;
    5140                 :            : }
    5141                 :            : 
    5142                 :          0 : static int decode_open_downgrade(struct xdr_stream *xdr, struct nfs_closeres *res)
    5143                 :            : {
    5144                 :            :         int status;
    5145                 :            : 
    5146                 :            :         status = decode_op_hdr(xdr, OP_OPEN_DOWNGRADE);
    5147                 :          0 :         if (status != -EIO)
    5148                 :          0 :                 nfs_increment_open_seqid(status, res->seqid);
    5149                 :          0 :         if (!status)
    5150                 :          0 :                 status = decode_open_stateid(xdr, &res->stateid);
    5151                 :          0 :         return status;
    5152                 :            : }
    5153                 :            : 
    5154                 :            : static int decode_putfh(struct xdr_stream *xdr)
    5155                 :            : {
    5156                 :            :         return decode_op_hdr(xdr, OP_PUTFH);
    5157                 :            : }
    5158                 :            : 
    5159                 :            : static int decode_putrootfh(struct xdr_stream *xdr)
    5160                 :            : {
    5161                 :            :         return decode_op_hdr(xdr, OP_PUTROOTFH);
    5162                 :            : }
    5163                 :            : 
    5164                 :          0 : static int decode_read(struct xdr_stream *xdr, struct rpc_rqst *req,
    5165                 :            :                        struct nfs_pgio_res *res)
    5166                 :            : {
    5167                 :            :         __be32 *p;
    5168                 :            :         uint32_t count, eof, recvd;
    5169                 :            :         int status;
    5170                 :            : 
    5171                 :            :         status = decode_op_hdr(xdr, OP_READ);
    5172                 :          0 :         if (status)
    5173                 :            :                 return status;
    5174                 :          0 :         p = xdr_inline_decode(xdr, 8);
    5175                 :          0 :         if (unlikely(!p))
    5176                 :            :                 return -EIO;
    5177                 :            :         eof = be32_to_cpup(p++);
    5178                 :            :         count = be32_to_cpup(p);
    5179                 :          0 :         recvd = xdr_read_pages(xdr, count);
    5180                 :          0 :         if (count > recvd) {
    5181                 :            :                 dprintk("NFS: server cheating in read reply: "
    5182                 :            :                                 "count %u > recvd %u\n", count, recvd);
    5183                 :            :                 count = recvd;
    5184                 :            :                 eof = 0;
    5185                 :            :         }
    5186                 :          0 :         res->eof = eof;
    5187                 :          0 :         res->count = count;
    5188                 :          0 :         return 0;
    5189                 :            : }
    5190                 :            : 
    5191                 :          0 : static int decode_readdir(struct xdr_stream *xdr, struct rpc_rqst *req, struct nfs4_readdir_res *readdir)
    5192                 :            : {
    5193                 :            :         int             status;
    5194                 :            :         __be32          verf[2];
    5195                 :            : 
    5196                 :            :         status = decode_op_hdr(xdr, OP_READDIR);
    5197                 :          0 :         if (!status)
    5198                 :          0 :                 status = decode_verifier(xdr, readdir->verifier.data);
    5199                 :          0 :         if (unlikely(status))
    5200                 :            :                 return status;
    5201                 :          0 :         memcpy(verf, readdir->verifier.data, sizeof(verf));
    5202                 :            :         dprintk("%s: verifier = %08x:%08x\n",
    5203                 :            :                         __func__, verf[0], verf[1]);
    5204                 :          0 :         return xdr_read_pages(xdr, xdr->buf->page_len);
    5205                 :            : }
    5206                 :            : 
    5207                 :          0 : static int decode_readlink(struct xdr_stream *xdr, struct rpc_rqst *req)
    5208                 :            : {
    5209                 :          0 :         struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
    5210                 :            :         u32 len, recvd;
    5211                 :            :         __be32 *p;
    5212                 :            :         int status;
    5213                 :            : 
    5214                 :            :         status = decode_op_hdr(xdr, OP_READLINK);
    5215                 :          0 :         if (status)
    5216                 :            :                 return status;
    5217                 :            : 
    5218                 :            :         /* Convert length of symlink */
    5219                 :          0 :         p = xdr_inline_decode(xdr, 4);
    5220                 :          0 :         if (unlikely(!p))
    5221                 :            :                 return -EIO;
    5222                 :            :         len = be32_to_cpup(p);
    5223                 :          0 :         if (len >= rcvbuf->page_len || len <= 0) {
    5224                 :            :                 dprintk("nfs: server returned giant symlink!\n");
    5225                 :            :                 return -ENAMETOOLONG;
    5226                 :            :         }
    5227                 :          0 :         recvd = xdr_read_pages(xdr, len);
    5228                 :          0 :         if (recvd < len) {
    5229                 :            :                 dprintk("NFS: server cheating in readlink reply: "
    5230                 :            :                                 "count %u > recvd %u\n", len, recvd);
    5231                 :            :                 return -EIO;
    5232                 :            :         }
    5233                 :            :         /*
    5234                 :            :          * The XDR encode routine has set things up so that
    5235                 :            :          * the link text will be copied directly into the
    5236                 :            :          * buffer.  We just have to do overflow-checking,
    5237                 :            :          * and and null-terminate the text (the VFS expects
    5238                 :            :          * null-termination).
    5239                 :            :          */
    5240                 :          0 :         xdr_terminate_string(rcvbuf, len);
    5241                 :          0 :         return 0;
    5242                 :            : }
    5243                 :            : 
    5244                 :          0 : static int decode_remove(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
    5245                 :            : {
    5246                 :            :         int status;
    5247                 :            : 
    5248                 :            :         status = decode_op_hdr(xdr, OP_REMOVE);
    5249                 :          0 :         if (status)
    5250                 :            :                 goto out;
    5251                 :          0 :         status = decode_change_info(xdr, cinfo);
    5252                 :            : out:
    5253                 :          0 :         return status;
    5254                 :            : }
    5255                 :            : 
    5256                 :          0 : static int decode_rename(struct xdr_stream *xdr, struct nfs4_change_info *old_cinfo,
    5257                 :            :               struct nfs4_change_info *new_cinfo)
    5258                 :            : {
    5259                 :            :         int status;
    5260                 :            : 
    5261                 :            :         status = decode_op_hdr(xdr, OP_RENAME);
    5262                 :          0 :         if (status)
    5263                 :            :                 goto out;
    5264                 :          0 :         if ((status = decode_change_info(xdr, old_cinfo)))
    5265                 :            :                 goto out;
    5266                 :          0 :         status = decode_change_info(xdr, new_cinfo);
    5267                 :            : out:
    5268                 :          0 :         return status;
    5269                 :            : }
    5270                 :            : 
    5271                 :            : static int decode_renew(struct xdr_stream *xdr)
    5272                 :            : {
    5273                 :            :         return decode_op_hdr(xdr, OP_RENEW);
    5274                 :            : }
    5275                 :            : 
    5276                 :            : static int
    5277                 :            : decode_restorefh(struct xdr_stream *xdr)
    5278                 :            : {
    5279                 :            :         return decode_op_hdr(xdr, OP_RESTOREFH);
    5280                 :            : }
    5281                 :            : 
    5282                 :          0 : static int decode_getacl(struct xdr_stream *xdr, struct rpc_rqst *req,
    5283                 :            :                          struct nfs_getaclres *res)
    5284                 :            : {
    5285                 :            :         unsigned int savep;
    5286                 :            :         uint32_t attrlen,
    5287                 :          0 :                  bitmap[3] = {0};
    5288                 :            :         int status;
    5289                 :            :         unsigned int pg_offset;
    5290                 :            : 
    5291                 :          0 :         res->acl_len = 0;
    5292                 :          0 :         if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
    5293                 :            :                 goto out;
    5294                 :            : 
    5295                 :          0 :         xdr_enter_page(xdr, xdr->buf->page_len);
    5296                 :            : 
    5297                 :            :         /* Calculate the offset of the page data */
    5298                 :          0 :         pg_offset = xdr->buf->head[0].iov_len;
    5299                 :            : 
    5300                 :          0 :         if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
    5301                 :            :                 goto out;
    5302                 :          0 :         if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
    5303                 :            :                 goto out;
    5304                 :            : 
    5305                 :          0 :         if (unlikely(bitmap[0] & (FATTR4_WORD0_ACL - 1U)))
    5306                 :            :                 return -EIO;
    5307                 :          0 :         if (likely(bitmap[0] & FATTR4_WORD0_ACL)) {
    5308                 :            : 
    5309                 :            :                 /* The bitmap (xdr len + bitmaps) and the attr xdr len words
    5310                 :            :                  * are stored with the acl data to handle the problem of
    5311                 :            :                  * variable length bitmaps.*/
    5312                 :          0 :                 res->acl_data_offset = xdr_stream_pos(xdr) - pg_offset;
    5313                 :          0 :                 res->acl_len = attrlen;
    5314                 :            : 
    5315                 :            :                 /* Check for receive buffer overflow */
    5316                 :          0 :                 if (res->acl_len > (xdr->nwords << 2) ||
    5317                 :          0 :                     res->acl_len + res->acl_data_offset > xdr->buf->page_len) {
    5318                 :          0 :                         res->acl_flags |= NFS4_ACL_TRUNC;
    5319                 :            :                         dprintk("NFS: acl reply: attrlen %u > page_len %u\n",
    5320                 :            :                                         attrlen, xdr->nwords << 2);
    5321                 :            :                 }
    5322                 :            :         } else
    5323                 :            :                 status = -EOPNOTSUPP;
    5324                 :            : 
    5325                 :            : out:
    5326                 :          0 :         return status;
    5327                 :            : }
    5328                 :            : 
    5329                 :            : static int
    5330                 :            : decode_savefh(struct xdr_stream *xdr)
    5331                 :            : {
    5332                 :            :         return decode_op_hdr(xdr, OP_SAVEFH);
    5333                 :            : }
    5334                 :            : 
    5335                 :          0 : static int decode_setattr(struct xdr_stream *xdr)
    5336                 :            : {
    5337                 :            :         int status;
    5338                 :            : 
    5339                 :            :         status = decode_op_hdr(xdr, OP_SETATTR);
    5340                 :          0 :         if (status)
    5341                 :            :                 return status;
    5342                 :          0 :         if (decode_bitmap4(xdr, NULL, 0) >= 0)
    5343                 :            :                 return 0;
    5344                 :          0 :         return -EIO;
    5345                 :            : }
    5346                 :            : 
    5347                 :          0 : static int decode_setclientid(struct xdr_stream *xdr, struct nfs4_setclientid_res *res)
    5348                 :            : {
    5349                 :            :         __be32 *p;
    5350                 :            :         uint32_t opnum;
    5351                 :            :         int32_t nfserr;
    5352                 :            : 
    5353                 :          0 :         p = xdr_inline_decode(xdr, 8);
    5354                 :          0 :         if (unlikely(!p))
    5355                 :            :                 return -EIO;
    5356                 :            :         opnum = be32_to_cpup(p++);
    5357                 :          0 :         if (opnum != OP_SETCLIENTID) {
    5358                 :            :                 dprintk("nfs: decode_setclientid: Server returned operation"
    5359                 :            :                         " %d\n", opnum);
    5360                 :            :                 return -EIO;
    5361                 :            :         }
    5362                 :          0 :         nfserr = be32_to_cpup(p);
    5363                 :          0 :         if (nfserr == NFS_OK) {
    5364                 :          0 :                 p = xdr_inline_decode(xdr, 8 + NFS4_VERIFIER_SIZE);
    5365                 :          0 :                 if (unlikely(!p))
    5366                 :            :                         return -EIO;
    5367                 :            :                 p = xdr_decode_hyper(p, &res->clientid);
    5368                 :          0 :                 memcpy(res->confirm.data, p, NFS4_VERIFIER_SIZE);
    5369                 :          0 :         } else if (nfserr == NFSERR_CLID_INUSE) {
    5370                 :            :                 uint32_t len;
    5371                 :            : 
    5372                 :            :                 /* skip netid string */
    5373                 :          0 :                 p = xdr_inline_decode(xdr, 4);
    5374                 :          0 :                 if (unlikely(!p))
    5375                 :            :                         return -EIO;
    5376                 :            :                 len = be32_to_cpup(p);
    5377                 :          0 :                 p = xdr_inline_decode(xdr, len);
    5378                 :          0 :                 if (unlikely(!p))
    5379                 :            :                         return -EIO;
    5380                 :            : 
    5381                 :            :                 /* skip uaddr string */
    5382                 :          0 :                 p = xdr_inline_decode(xdr, 4);
    5383                 :          0 :                 if (unlikely(!p))
    5384                 :            :                         return -EIO;
    5385                 :            :                 len = be32_to_cpup(p);
    5386                 :          0 :                 p = xdr_inline_decode(xdr, len);
    5387                 :          0 :                 if (unlikely(!p))
    5388                 :            :                         return -EIO;
    5389                 :          0 :                 return -NFSERR_CLID_INUSE;
    5390                 :            :         } else
    5391                 :          0 :                 return nfs4_stat_to_errno(nfserr);
    5392                 :            : 
    5393                 :          0 :         return 0;
    5394                 :            : }
    5395                 :            : 
    5396                 :            : static int decode_setclientid_confirm(struct xdr_stream *xdr)
    5397                 :            : {
    5398                 :            :         return decode_op_hdr(xdr, OP_SETCLIENTID_CONFIRM);
    5399                 :            : }
    5400                 :            : 
    5401                 :          0 : static int decode_write(struct xdr_stream *xdr, struct nfs_pgio_res *res)
    5402                 :            : {
    5403                 :            :         __be32 *p;
    5404                 :            :         int status;
    5405                 :            : 
    5406                 :            :         status = decode_op_hdr(xdr, OP_WRITE);
    5407                 :          0 :         if (status)
    5408                 :            :                 return status;
    5409                 :            : 
    5410                 :          0 :         p = xdr_inline_decode(xdr, 8);
    5411                 :          0 :         if (unlikely(!p))
    5412                 :            :                 return -EIO;
    5413                 :          0 :         res->count = be32_to_cpup(p++);
    5414                 :          0 :         res->verf->committed = be32_to_cpup(p++);
    5415                 :          0 :         return decode_write_verifier(xdr, &res->verf->verifier);
    5416                 :            : }
    5417                 :            : 
    5418                 :            : static int decode_delegreturn(struct xdr_stream *xdr)
    5419                 :            : {
    5420                 :            :         return decode_op_hdr(xdr, OP_DELEGRETURN);
    5421                 :            : }
    5422                 :            : 
    5423                 :          0 : static int decode_secinfo_gss(struct xdr_stream *xdr,
    5424                 :            :                               struct nfs4_secinfo4 *flavor)
    5425                 :            : {
    5426                 :            :         u32 oid_len;
    5427                 :            :         __be32 *p;
    5428                 :            : 
    5429                 :          0 :         p = xdr_inline_decode(xdr, 4);
    5430                 :          0 :         if (unlikely(!p))
    5431                 :            :                 return -EIO;
    5432                 :            :         oid_len = be32_to_cpup(p);
    5433                 :          0 :         if (oid_len > GSS_OID_MAX_LEN)
    5434                 :            :                 return -EINVAL;
    5435                 :            : 
    5436                 :          0 :         p = xdr_inline_decode(xdr, oid_len);
    5437                 :          0 :         if (unlikely(!p))
    5438                 :            :                 return -EIO;
    5439                 :          0 :         memcpy(flavor->flavor_info.oid.data, p, oid_len);
    5440                 :          0 :         flavor->flavor_info.oid.len = oid_len;
    5441                 :            : 
    5442                 :          0 :         p = xdr_inline_decode(xdr, 8);
    5443                 :          0 :         if (unlikely(!p))
    5444                 :            :                 return -EIO;
    5445                 :          0 :         flavor->flavor_info.qop = be32_to_cpup(p++);
    5446                 :          0 :         flavor->flavor_info.service = be32_to_cpup(p);
    5447                 :            : 
    5448                 :          0 :         return 0;
    5449                 :            : }
    5450                 :            : 
    5451                 :          0 : static int decode_secinfo_common(struct xdr_stream *xdr, struct nfs4_secinfo_res *res)
    5452                 :            : {
    5453                 :            :         struct nfs4_secinfo4 *sec_flavor;
    5454                 :            :         unsigned int i, num_flavors;
    5455                 :            :         int status;
    5456                 :            :         __be32 *p;
    5457                 :            : 
    5458                 :          0 :         p = xdr_inline_decode(xdr, 4);
    5459                 :          0 :         if (unlikely(!p))
    5460                 :            :                 return -EIO;
    5461                 :            : 
    5462                 :          0 :         res->flavors->num_flavors = 0;
    5463                 :            :         num_flavors = be32_to_cpup(p);
    5464                 :            : 
    5465                 :          0 :         for (i = 0; i < num_flavors; i++) {
    5466                 :          0 :                 sec_flavor = &res->flavors->flavors[i];
    5467                 :          0 :                 if ((char *)&sec_flavor[1] - (char *)res->flavors > PAGE_SIZE)
    5468                 :            :                         break;
    5469                 :            : 
    5470                 :          0 :                 p = xdr_inline_decode(xdr, 4);
    5471                 :          0 :                 if (unlikely(!p))
    5472                 :            :                         return -EIO;
    5473                 :          0 :                 sec_flavor->flavor = be32_to_cpup(p);
    5474                 :            : 
    5475                 :          0 :                 if (sec_flavor->flavor == RPC_AUTH_GSS) {
    5476                 :          0 :                         status = decode_secinfo_gss(xdr, sec_flavor);
    5477                 :          0 :                         if (status)
    5478                 :            :                                 goto out;
    5479                 :            :                 }
    5480                 :          0 :                 res->flavors->num_flavors++;
    5481                 :            :         }
    5482                 :            : 
    5483                 :            :         status = 0;
    5484                 :            : out:
    5485                 :          0 :         return status;
    5486                 :            : }
    5487                 :            : 
    5488                 :          0 : static int decode_secinfo(struct xdr_stream *xdr, struct nfs4_secinfo_res *res)
    5489                 :            : {
    5490                 :            :         int status = decode_op_hdr(xdr, OP_SECINFO);
    5491                 :          0 :         if (status)
    5492                 :            :                 return status;
    5493                 :          0 :         return decode_secinfo_common(xdr, res);
    5494                 :            : }
    5495                 :            : 
    5496                 :            : #if defined(CONFIG_NFS_V4_1)
    5497                 :          0 : static int decode_secinfo_no_name(struct xdr_stream *xdr, struct nfs4_secinfo_res *res)
    5498                 :            : {
    5499                 :            :         int status = decode_op_hdr(xdr, OP_SECINFO_NO_NAME);
    5500                 :          0 :         if (status)
    5501                 :            :                 return status;
    5502                 :          0 :         return decode_secinfo_common(xdr, res);
    5503                 :            : }
    5504                 :            : 
    5505                 :          0 : static int decode_op_map(struct xdr_stream *xdr, struct nfs4_op_map *op_map)
    5506                 :            : {
    5507                 :            :         __be32 *p;
    5508                 :            :         uint32_t bitmap_words;
    5509                 :            :         unsigned int i;
    5510                 :            : 
    5511                 :          0 :         p = xdr_inline_decode(xdr, 4);
    5512                 :          0 :         if (!p)
    5513                 :            :                 return -EIO;
    5514                 :            :         bitmap_words = be32_to_cpup(p++);
    5515                 :          0 :         if (bitmap_words > NFS4_OP_MAP_NUM_WORDS)
    5516                 :            :                 return -EIO;
    5517                 :          0 :         p = xdr_inline_decode(xdr, 4 * bitmap_words);
    5518                 :          0 :         for (i = 0; i < bitmap_words; i++)
    5519                 :          0 :                 op_map->u.words[i] = be32_to_cpup(p++);
    5520                 :            : 
    5521                 :            :         return 0;
    5522                 :            : }
    5523                 :            : 
    5524                 :          0 : static int decode_exchange_id(struct xdr_stream *xdr,
    5525                 :            :                               struct nfs41_exchange_id_res *res)
    5526                 :            : {
    5527                 :            :         __be32 *p;
    5528                 :            :         uint32_t dummy;
    5529                 :            :         char *dummy_str;
    5530                 :            :         int status;
    5531                 :            :         uint32_t impl_id_count;
    5532                 :            : 
    5533                 :            :         status = decode_op_hdr(xdr, OP_EXCHANGE_ID);
    5534                 :          0 :         if (status)
    5535                 :            :                 return status;
    5536                 :            : 
    5537                 :          0 :         p = xdr_inline_decode(xdr, 8);
    5538                 :          0 :         if (unlikely(!p))
    5539                 :            :                 return -EIO;
    5540                 :            :         xdr_decode_hyper(p, &res->clientid);
    5541                 :          0 :         p = xdr_inline_decode(xdr, 12);
    5542                 :          0 :         if (unlikely(!p))
    5543                 :            :                 return -EIO;
    5544                 :          0 :         res->seqid = be32_to_cpup(p++);
    5545                 :          0 :         res->flags = be32_to_cpup(p++);
    5546                 :            : 
    5547                 :          0 :         res->state_protect.how = be32_to_cpup(p);
    5548                 :          0 :         switch (res->state_protect.how) {
    5549                 :            :         case SP4_NONE:
    5550                 :            :                 break;
    5551                 :            :         case SP4_MACH_CRED:
    5552                 :          0 :                 status = decode_op_map(xdr, &res->state_protect.enforce);
    5553                 :          0 :                 if (status)
    5554                 :            :                         return status;
    5555                 :          0 :                 status = decode_op_map(xdr, &res->state_protect.allow);
    5556                 :          0 :                 if (status)
    5557                 :            :                         return status;
    5558                 :            :                 break;
    5559                 :            :         default:
    5560                 :          0 :                 WARN_ON_ONCE(1);
    5561                 :            :                 return -EIO;
    5562                 :            :         }
    5563                 :            : 
    5564                 :            :         /* server_owner4.so_minor_id */
    5565                 :          0 :         p = xdr_inline_decode(xdr, 8);
    5566                 :          0 :         if (unlikely(!p))
    5567                 :            :                 return -EIO;
    5568                 :          0 :         p = xdr_decode_hyper(p, &res->server_owner->minor_id);
    5569                 :            : 
    5570                 :            :         /* server_owner4.so_major_id */
    5571                 :            :         status = decode_opaque_inline(xdr, &dummy, &dummy_str);
    5572                 :          0 :         if (unlikely(status))
    5573                 :            :                 return status;
    5574                 :          0 :         memcpy(res->server_owner->major_id, dummy_str, dummy);
    5575                 :          0 :         res->server_owner->major_id_sz = dummy;
    5576                 :            : 
    5577                 :            :         /* server_scope4 */
    5578                 :            :         status = decode_opaque_inline(xdr, &dummy, &dummy_str);
    5579                 :          0 :         if (unlikely(status))
    5580                 :            :                 return status;
    5581                 :          0 :         memcpy(res->server_scope->server_scope, dummy_str, dummy);
    5582                 :          0 :         res->server_scope->server_scope_sz = dummy;
    5583                 :            : 
    5584                 :            :         /* Implementation Id */
    5585                 :          0 :         p = xdr_inline_decode(xdr, 4);
    5586                 :          0 :         if (unlikely(!p))
    5587                 :            :                 return -EIO;
    5588                 :            :         impl_id_count = be32_to_cpup(p++);
    5589                 :            : 
    5590                 :          0 :         if (impl_id_count) {
    5591                 :            :                 /* nii_domain */
    5592                 :            :                 status = decode_opaque_inline(xdr, &dummy, &dummy_str);
    5593                 :          0 :                 if (unlikely(status))
    5594                 :            :                         return status;
    5595                 :          0 :                 memcpy(res->impl_id->domain, dummy_str, dummy);
    5596                 :            : 
    5597                 :            :                 /* nii_name */
    5598                 :            :                 status = decode_opaque_inline(xdr, &dummy, &dummy_str);
    5599                 :          0 :                 if (unlikely(status))
    5600                 :            :                         return status;
    5601                 :          0 :                 memcpy(res->impl_id->name, dummy_str, dummy);
    5602                 :            : 
    5603                 :            :                 /* nii_date */
    5604                 :          0 :                 p = xdr_inline_decode(xdr, 12);
    5605                 :          0 :                 if (unlikely(!p))
    5606                 :            :                         return -EIO;
    5607                 :          0 :                 p = xdr_decode_hyper(p, &res->impl_id->date.seconds);
    5608                 :          0 :                 res->impl_id->date.nseconds = be32_to_cpup(p);
    5609                 :            : 
    5610                 :            :                 /* if there's more than one entry, ignore the rest */
    5611                 :            :         }
    5612                 :            :         return 0;
    5613                 :            : }
    5614                 :            : 
    5615                 :          0 : static int decode_chan_attrs(struct xdr_stream *xdr,
    5616                 :            :                              struct nfs4_channel_attrs *attrs)
    5617                 :            : {
    5618                 :            :         __be32 *p;
    5619                 :            :         u32 nr_attrs, val;
    5620                 :            : 
    5621                 :          0 :         p = xdr_inline_decode(xdr, 28);
    5622                 :          0 :         if (unlikely(!p))
    5623                 :            :                 return -EIO;
    5624                 :            :         val = be32_to_cpup(p++);        /* headerpadsz */
    5625                 :          0 :         if (val)
    5626                 :            :                 return -EINVAL;         /* no support for header padding yet */
    5627                 :          0 :         attrs->max_rqst_sz = be32_to_cpup(p++);
    5628                 :          0 :         attrs->max_resp_sz = be32_to_cpup(p++);
    5629                 :          0 :         attrs->max_resp_sz_cached = be32_to_cpup(p++);
    5630                 :          0 :         attrs->max_ops = be32_to_cpup(p++);
    5631                 :          0 :         attrs->max_reqs = be32_to_cpup(p++);
    5632                 :            :         nr_attrs = be32_to_cpup(p);
    5633                 :          0 :         if (unlikely(nr_attrs > 1)) {
    5634                 :          0 :                 printk(KERN_WARNING "NFS: %s: Invalid rdma channel attrs "
    5635                 :            :                         "count %u\n", __func__, nr_attrs);
    5636                 :          0 :                 return -EINVAL;
    5637                 :            :         }
    5638                 :          0 :         if (nr_attrs == 1) {
    5639                 :          0 :                 p = xdr_inline_decode(xdr, 4); /* skip rdma_attrs */
    5640                 :          0 :                 if (unlikely(!p))
    5641                 :            :                         return -EIO;
    5642                 :            :         }
    5643                 :            :         return 0;
    5644                 :            : }
    5645                 :            : 
    5646                 :            : static int decode_sessionid(struct xdr_stream *xdr, struct nfs4_sessionid *sid)
    5647                 :            : {
    5648                 :          0 :         return decode_opaque_fixed(xdr, sid->data, NFS4_MAX_SESSIONID_LEN);
    5649                 :            : }
    5650                 :            : 
    5651                 :          0 : static int decode_bind_conn_to_session(struct xdr_stream *xdr,
    5652                 :            :                                 struct nfs41_bind_conn_to_session_res *res)
    5653                 :            : {
    5654                 :            :         __be32 *p;
    5655                 :            :         int status;
    5656                 :            : 
    5657                 :            :         status = decode_op_hdr(xdr, OP_BIND_CONN_TO_SESSION);
    5658                 :          0 :         if (!status)
    5659                 :            :                 status = decode_sessionid(xdr, &res->sessionid);
    5660                 :          0 :         if (unlikely(status))
    5661                 :            :                 return status;
    5662                 :            : 
    5663                 :            :         /* dir flags, rdma mode bool */
    5664                 :          0 :         p = xdr_inline_decode(xdr, 8);
    5665                 :          0 :         if (unlikely(!p))
    5666                 :            :                 return -EIO;
    5667                 :            : 
    5668                 :          0 :         res->dir = be32_to_cpup(p++);
    5669                 :          0 :         if (res->dir == 0 || res->dir > NFS4_CDFS4_BOTH)
    5670                 :            :                 return -EIO;
    5671                 :          0 :         if (be32_to_cpup(p) == 0)
    5672                 :          0 :                 res->use_conn_in_rdma_mode = false;
    5673                 :            :         else
    5674                 :          0 :                 res->use_conn_in_rdma_mode = true;
    5675                 :            : 
    5676                 :            :         return 0;
    5677                 :            : }
    5678                 :            : 
    5679                 :          0 : static int decode_create_session(struct xdr_stream *xdr,
    5680                 :            :                                  struct nfs41_create_session_res *res)
    5681                 :            : {
    5682                 :            :         __be32 *p;
    5683                 :            :         int status;
    5684                 :            : 
    5685                 :            :         status = decode_op_hdr(xdr, OP_CREATE_SESSION);
    5686                 :          0 :         if (!status)
    5687                 :            :                 status = decode_sessionid(xdr, &res->sessionid);
    5688                 :          0 :         if (unlikely(status))
    5689                 :            :                 return status;
    5690                 :            : 
    5691                 :            :         /* seqid, flags */
    5692                 :          0 :         p = xdr_inline_decode(xdr, 8);
    5693                 :          0 :         if (unlikely(!p))
    5694                 :            :                 return -EIO;
    5695                 :          0 :         res->seqid = be32_to_cpup(p++);
    5696                 :          0 :         res->flags = be32_to_cpup(p);
    5697                 :            : 
    5698                 :            :         /* Channel attributes */
    5699                 :          0 :         status = decode_chan_attrs(xdr, &res->fc_attrs);
    5700                 :          0 :         if (!status)
    5701                 :          0 :                 status = decode_chan_attrs(xdr, &res->bc_attrs);
    5702                 :          0 :         return status;
    5703                 :            : }
    5704                 :            : 
    5705                 :            : static int decode_destroy_session(struct xdr_stream *xdr, void *dummy)
    5706                 :            : {
    5707                 :            :         return decode_op_hdr(xdr, OP_DESTROY_SESSION);
    5708                 :            : }
    5709                 :            : 
    5710                 :            : static int decode_destroy_clientid(struct xdr_stream *xdr, void *dummy)
    5711                 :            : {
    5712                 :            :         return decode_op_hdr(xdr, OP_DESTROY_CLIENTID);
    5713                 :            : }
    5714                 :            : 
    5715                 :            : static int decode_reclaim_complete(struct xdr_stream *xdr, void *dummy)
    5716                 :            : {
    5717                 :            :         return decode_op_hdr(xdr, OP_RECLAIM_COMPLETE);
    5718                 :            : }
    5719                 :            : #endif /* CONFIG_NFS_V4_1 */
    5720                 :            : 
    5721                 :          0 : static int decode_sequence(struct xdr_stream *xdr,
    5722                 :            :                            struct nfs4_sequence_res *res,
    5723                 :            :                            struct rpc_rqst *rqstp)
    5724                 :            : {
    5725                 :            : #if defined(CONFIG_NFS_V4_1)
    5726                 :            :         struct nfs4_session *session;
    5727                 :            :         struct nfs4_sessionid id;
    5728                 :            :         u32 dummy;
    5729                 :            :         int status;
    5730                 :            :         __be32 *p;
    5731                 :            : 
    5732                 :          0 :         if (res->sr_slot == NULL)
    5733                 :            :                 return 0;
    5734                 :          0 :         if (!res->sr_slot->table->session)
    5735                 :            :                 return 0;
    5736                 :            : 
    5737                 :            :         status = decode_op_hdr(xdr, OP_SEQUENCE);
    5738                 :          0 :         if (!status)
    5739                 :            :                 status = decode_sessionid(xdr, &id);
    5740                 :          0 :         if (unlikely(status))
    5741                 :            :                 goto out_err;
    5742                 :            : 
    5743                 :            :         /*
    5744                 :            :          * If the server returns different values for sessionID, slotID or
    5745                 :            :          * sequence number, the server is looney tunes.
    5746                 :            :          */
    5747                 :            :         status = -EREMOTEIO;
    5748                 :          0 :         session = res->sr_slot->table->session;
    5749                 :            : 
    5750                 :          0 :         if (memcmp(id.data, session->sess_id.data,
    5751                 :            :                    NFS4_MAX_SESSIONID_LEN)) {
    5752                 :            :                 dprintk("%s Invalid session id\n", __func__);
    5753                 :            :                 goto out_err;
    5754                 :            :         }
    5755                 :            : 
    5756                 :          0 :         p = xdr_inline_decode(xdr, 20);
    5757                 :          0 :         if (unlikely(!p))
    5758                 :            :                 goto out_overflow;
    5759                 :            : 
    5760                 :            :         /* seqid */
    5761                 :            :         dummy = be32_to_cpup(p++);
    5762                 :          0 :         if (dummy != res->sr_slot->seq_nr) {
    5763                 :            :                 dprintk("%s Invalid sequence number\n", __func__);
    5764                 :            :                 goto out_err;
    5765                 :            :         }
    5766                 :            :         /* slot id */
    5767                 :            :         dummy = be32_to_cpup(p++);
    5768                 :          0 :         if (dummy != res->sr_slot->slot_nr) {
    5769                 :            :                 dprintk("%s Invalid slot id\n", __func__);
    5770                 :            :                 goto out_err;
    5771                 :            :         }
    5772                 :            :         /* highest slot id */
    5773                 :          0 :         res->sr_highest_slotid = be32_to_cpup(p++);
    5774                 :            :         /* target highest slot id */
    5775                 :          0 :         res->sr_target_highest_slotid = be32_to_cpup(p++);
    5776                 :            :         /* result flags */
    5777                 :          0 :         res->sr_status_flags = be32_to_cpup(p);
    5778                 :            :         status = 0;
    5779                 :            : out_err:
    5780                 :          0 :         res->sr_status = status;
    5781                 :          0 :         return status;
    5782                 :            : out_overflow:
    5783                 :            :         status = -EIO;
    5784                 :            :         goto out_err;
    5785                 :            : #else  /* CONFIG_NFS_V4_1 */
    5786                 :            :         return 0;
    5787                 :            : #endif /* CONFIG_NFS_V4_1 */
    5788                 :            : }
    5789                 :            : 
    5790                 :            : #if defined(CONFIG_NFS_V4_1)
    5791                 :            : static int decode_layout_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
    5792                 :            : {
    5793                 :          0 :         stateid->type = NFS4_LAYOUT_STATEID_TYPE;
    5794                 :            :         return decode_stateid(xdr, stateid);
    5795                 :            : }
    5796                 :            : 
    5797                 :          0 : static int decode_getdeviceinfo(struct xdr_stream *xdr,
    5798                 :            :                                 struct nfs4_getdeviceinfo_res *res)
    5799                 :            : {
    5800                 :          0 :         struct pnfs_device *pdev = res->pdev;
    5801                 :            :         __be32 *p;
    5802                 :            :         uint32_t len, type;
    5803                 :            :         int status;
    5804                 :            : 
    5805                 :            :         status = decode_op_hdr(xdr, OP_GETDEVICEINFO);
    5806                 :          0 :         if (status) {
    5807                 :          0 :                 if (status == -ETOOSMALL) {
    5808                 :          0 :                         p = xdr_inline_decode(xdr, 4);
    5809                 :          0 :                         if (unlikely(!p))
    5810                 :            :                                 return -EIO;
    5811                 :          0 :                         pdev->mincount = be32_to_cpup(p);
    5812                 :            :                         dprintk("%s: Min count too small. mincnt = %u\n",
    5813                 :            :                                 __func__, pdev->mincount);
    5814                 :            :                 }
    5815                 :          0 :                 return status;
    5816                 :            :         }
    5817                 :            : 
    5818                 :          0 :         p = xdr_inline_decode(xdr, 8);
    5819                 :          0 :         if (unlikely(!p))
    5820                 :            :                 return -EIO;
    5821                 :            :         type = be32_to_cpup(p++);
    5822                 :          0 :         if (type != pdev->layout_type) {
    5823                 :            :                 dprintk("%s: layout mismatch req: %u pdev: %u\n",
    5824                 :            :                         __func__, pdev->layout_type, type);
    5825                 :            :                 return -EINVAL;
    5826                 :            :         }
    5827                 :            :         /*
    5828                 :            :          * Get the length of the opaque device_addr4. xdr_read_pages places
    5829                 :            :          * the opaque device_addr4 in the xdr_buf->pages (pnfs_device->pages)
    5830                 :            :          * and places the remaining xdr data in xdr_buf->tail
    5831                 :            :          */
    5832                 :          0 :         pdev->mincount = be32_to_cpup(p);
    5833                 :          0 :         if (xdr_read_pages(xdr, pdev->mincount) != pdev->mincount)
    5834                 :            :                 return -EIO;
    5835                 :            : 
    5836                 :            :         /* Parse notification bitmap, verifying that it is zero. */
    5837                 :          0 :         p = xdr_inline_decode(xdr, 4);
    5838                 :          0 :         if (unlikely(!p))
    5839                 :            :                 return -EIO;
    5840                 :            :         len = be32_to_cpup(p);
    5841                 :          0 :         if (len) {
    5842                 :            :                 uint32_t i;
    5843                 :            : 
    5844                 :          0 :                 p = xdr_inline_decode(xdr, 4 * len);
    5845                 :          0 :                 if (unlikely(!p))
    5846                 :            :                         return -EIO;
    5847                 :            : 
    5848                 :          0 :                 res->notification = be32_to_cpup(p++);
    5849                 :          0 :                 for (i = 1; i < len; i++) {
    5850                 :          0 :                         if (be32_to_cpup(p++)) {
    5851                 :            :                                 dprintk("%s: unsupported notification\n",
    5852                 :            :                                         __func__);
    5853                 :            :                                 return -EIO;
    5854                 :            :                         }
    5855                 :            :                 }
    5856                 :            :         }
    5857                 :            :         return 0;
    5858                 :            : }
    5859                 :            : 
    5860                 :          0 : static int decode_layoutget(struct xdr_stream *xdr, struct rpc_rqst *req,
    5861                 :            :                             struct nfs4_layoutget_res *res)
    5862                 :            : {
    5863                 :            :         __be32 *p;
    5864                 :            :         int status;
    5865                 :            :         u32 layout_count;
    5866                 :            :         u32 recvd;
    5867                 :            : 
    5868                 :            :         status = decode_op_hdr(xdr, OP_LAYOUTGET);
    5869                 :          0 :         if (status)
    5870                 :            :                 goto out;
    5871                 :          0 :         p = xdr_inline_decode(xdr, 4);
    5872                 :          0 :         if (unlikely(!p))
    5873                 :            :                 goto out_overflow;
    5874                 :          0 :         res->return_on_close = be32_to_cpup(p);
    5875                 :          0 :         decode_layout_stateid(xdr, &res->stateid);
    5876                 :          0 :         p = xdr_inline_decode(xdr, 4);
    5877                 :          0 :         if (unlikely(!p))
    5878                 :            :                 goto out_overflow;
    5879                 :            :         layout_count = be32_to_cpup(p);
    5880                 :          0 :         if (!layout_count) {
    5881                 :            :                 dprintk("%s: server responded with empty layout array\n",
    5882                 :            :                         __func__);
    5883                 :            :                 status = -EINVAL;
    5884                 :            :                 goto out;
    5885                 :            :         }
    5886                 :            : 
    5887                 :          0 :         p = xdr_inline_decode(xdr, 28);
    5888                 :          0 :         if (unlikely(!p))
    5889                 :            :                 goto out_overflow;
    5890                 :            :         p = xdr_decode_hyper(p, &res->range.offset);
    5891                 :            :         p = xdr_decode_hyper(p, &res->range.length);
    5892                 :          0 :         res->range.iomode = be32_to_cpup(p++);
    5893                 :          0 :         res->type = be32_to_cpup(p++);
    5894                 :          0 :         res->layoutp->len = be32_to_cpup(p);
    5895                 :            : 
    5896                 :            :         dprintk("%s roff:%lu rlen:%lu riomode:%d, lo_type:0x%x, lo.len:%d\n",
    5897                 :            :                 __func__,
    5898                 :            :                 (unsigned long)res->range.offset,
    5899                 :            :                 (unsigned long)res->range.length,
    5900                 :            :                 res->range.iomode,
    5901                 :            :                 res->type,
    5902                 :            :                 res->layoutp->len);
    5903                 :            : 
    5904                 :          0 :         recvd = xdr_read_pages(xdr, res->layoutp->len);
    5905                 :          0 :         if (res->layoutp->len > recvd) {
    5906                 :            :                 dprintk("NFS: server cheating in layoutget reply: "
    5907                 :            :                                 "layout len %u > recvd %u\n",
    5908                 :            :                                 res->layoutp->len, recvd);
    5909                 :            :                 status = -EINVAL;
    5910                 :          0 :                 goto out;
    5911                 :            :         }
    5912                 :            : 
    5913                 :            :         if (layout_count > 1) {
    5914                 :            :                 /* We only handle a length one array at the moment.  Any
    5915                 :            :                  * further entries are just ignored.  Note that this means
    5916                 :            :                  * the client may see a response that is less than the
    5917                 :            :                  * minimum it requested.
    5918                 :            :                  */
    5919                 :            :                 dprintk("%s: server responded with %d layouts, dropping tail\n",
    5920                 :            :                         __func__, layout_count);
    5921                 :            :         }
    5922                 :            : 
    5923                 :            : out:
    5924                 :          0 :         res->status = status;
    5925                 :          0 :         return status;
    5926                 :            : out_overflow:
    5927                 :            :         status = -EIO;
    5928                 :            :         goto out;
    5929                 :            : }
    5930                 :            : 
    5931                 :          0 : static int decode_layoutreturn(struct xdr_stream *xdr,
    5932                 :            :                                struct nfs4_layoutreturn_res *res)
    5933                 :            : {
    5934                 :            :         __be32 *p;
    5935                 :            :         int status;
    5936                 :            : 
    5937                 :            :         status = decode_op_hdr(xdr, OP_LAYOUTRETURN);
    5938                 :          0 :         if (status)
    5939                 :            :                 return status;
    5940                 :          0 :         p = xdr_inline_decode(xdr, 4);
    5941                 :          0 :         if (unlikely(!p))
    5942                 :            :                 return -EIO;
    5943                 :          0 :         res->lrs_present = be32_to_cpup(p);
    5944                 :          0 :         if (res->lrs_present)
    5945                 :          0 :                 status = decode_layout_stateid(xdr, &res->stateid);
    5946                 :            :         else
    5947                 :            :                 nfs4_stateid_copy(&res->stateid, &invalid_stateid);
    5948                 :          0 :         return status;
    5949                 :            : }
    5950                 :            : 
    5951                 :          0 : static int decode_layoutcommit(struct xdr_stream *xdr,
    5952                 :            :                                struct rpc_rqst *req,
    5953                 :            :                                struct nfs4_layoutcommit_res *res)
    5954                 :            : {
    5955                 :            :         __be32 *p;
    5956                 :            :         __u32 sizechanged;
    5957                 :            :         int status;
    5958                 :            : 
    5959                 :            :         status = decode_op_hdr(xdr, OP_LAYOUTCOMMIT);
    5960                 :          0 :         res->status = status;
    5961                 :          0 :         if (status)
    5962                 :            :                 return status;
    5963                 :            : 
    5964                 :          0 :         p = xdr_inline_decode(xdr, 4);
    5965                 :          0 :         if (unlikely(!p))
    5966                 :            :                 return -EIO;
    5967                 :            :         sizechanged = be32_to_cpup(p);
    5968                 :            : 
    5969                 :          0 :         if (sizechanged) {
    5970                 :            :                 /* throw away new size */
    5971                 :          0 :                 p = xdr_inline_decode(xdr, 8);
    5972                 :          0 :                 if (unlikely(!p))
    5973                 :            :                         return -EIO;
    5974                 :            :         }
    5975                 :            :         return 0;
    5976                 :            : }
    5977                 :            : 
    5978                 :          0 : static int decode_test_stateid(struct xdr_stream *xdr,
    5979                 :            :                                struct nfs41_test_stateid_res *res)
    5980                 :            : {
    5981                 :            :         __be32 *p;
    5982                 :            :         int status;
    5983                 :            :         int num_res;
    5984                 :            : 
    5985                 :            :         status = decode_op_hdr(xdr, OP_TEST_STATEID);
    5986                 :          0 :         if (status)
    5987                 :            :                 return status;
    5988                 :            : 
    5989                 :          0 :         p = xdr_inline_decode(xdr, 4);
    5990                 :          0 :         if (unlikely(!p))
    5991                 :            :                 return -EIO;
    5992                 :            :         num_res = be32_to_cpup(p++);
    5993                 :          0 :         if (num_res != 1)
    5994                 :            :                 return -EIO;
    5995                 :            : 
    5996                 :          0 :         p = xdr_inline_decode(xdr, 4);
    5997                 :          0 :         if (unlikely(!p))
    5998                 :            :                 return -EIO;
    5999                 :          0 :         res->status = be32_to_cpup(p++);
    6000                 :            : 
    6001                 :          0 :         return status;
    6002                 :            : }
    6003                 :            : 
    6004                 :            : static int decode_free_stateid(struct xdr_stream *xdr,
    6005                 :            :                                struct nfs41_free_stateid_res *res)
    6006                 :            : {
    6007                 :          0 :         res->status = decode_op_hdr(xdr, OP_FREE_STATEID);
    6008                 :            :         return res->status;
    6009                 :            : }
    6010                 :            : #else
    6011                 :            : static inline
    6012                 :            : int decode_layoutreturn(struct xdr_stream *xdr,
    6013                 :            :                                struct nfs4_layoutreturn_res *res)
    6014                 :            : {
    6015                 :            :         return 0;
    6016                 :            : }
    6017                 :            : 
    6018                 :            : static int decode_layoutget(struct xdr_stream *xdr, struct rpc_rqst *req,
    6019                 :            :                             struct nfs4_layoutget_res *res)
    6020                 :            : {
    6021                 :            :         return 0;
    6022                 :            : }
    6023                 :            : 
    6024                 :            : #endif /* CONFIG_NFS_V4_1 */
    6025                 :            : 
    6026                 :            : /*
    6027                 :            :  * END OF "GENERIC" DECODE ROUTINES.
    6028                 :            :  */
    6029                 :            : 
    6030                 :            : /*
    6031                 :            :  * Decode OPEN_DOWNGRADE response
    6032                 :            :  */
    6033                 :          0 : static int nfs4_xdr_dec_open_downgrade(struct rpc_rqst *rqstp,
    6034                 :            :                                        struct xdr_stream *xdr,
    6035                 :            :                                        void *data)
    6036                 :            : {
    6037                 :            :         struct nfs_closeres *res = data;
    6038                 :            :         struct compound_hdr hdr;
    6039                 :            :         int status;
    6040                 :            : 
    6041                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6042                 :          0 :         if (status)
    6043                 :            :                 goto out;
    6044                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    6045                 :          0 :         if (status)
    6046                 :            :                 goto out;
    6047                 :            :         status = decode_putfh(xdr);
    6048                 :          0 :         if (status)
    6049                 :            :                 goto out;
    6050                 :          0 :         if (res->lr_res) {
    6051                 :          0 :                 status = decode_layoutreturn(xdr, res->lr_res);
    6052                 :          0 :                 res->lr_ret = status;
    6053                 :          0 :                 if (status)
    6054                 :            :                         goto out;
    6055                 :            :         }
    6056                 :          0 :         status = decode_open_downgrade(xdr, res);
    6057                 :            : out:
    6058                 :          0 :         return status;
    6059                 :            : }
    6060                 :            : 
    6061                 :            : /*
    6062                 :            :  * Decode ACCESS response
    6063                 :            :  */
    6064                 :          0 : static int nfs4_xdr_dec_access(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
    6065                 :            :                                void *data)
    6066                 :            : {
    6067                 :            :         struct nfs4_accessres *res = data;
    6068                 :            :         struct compound_hdr hdr;
    6069                 :            :         int status;
    6070                 :            : 
    6071                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6072                 :          0 :         if (status)
    6073                 :            :                 goto out;
    6074                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    6075                 :          0 :         if (status)
    6076                 :            :                 goto out;
    6077                 :            :         status = decode_putfh(xdr);
    6078                 :          0 :         if (status != 0)
    6079                 :            :                 goto out;
    6080                 :          0 :         status = decode_access(xdr, &res->supported, &res->access);
    6081                 :          0 :         if (status != 0)
    6082                 :            :                 goto out;
    6083                 :          0 :         if (res->fattr)
    6084                 :          0 :                 decode_getfattr(xdr, res->fattr, res->server);
    6085                 :            : out:
    6086                 :          0 :         return status;
    6087                 :            : }
    6088                 :            : 
    6089                 :            : /*
    6090                 :            :  * Decode LOOKUP response
    6091                 :            :  */
    6092                 :          0 : static int nfs4_xdr_dec_lookup(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
    6093                 :            :                                void *data)
    6094                 :            : {
    6095                 :            :         struct nfs4_lookup_res *res = data;
    6096                 :            :         struct compound_hdr hdr;
    6097                 :            :         int status;
    6098                 :            : 
    6099                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6100                 :          0 :         if (status)
    6101                 :            :                 goto out;
    6102                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    6103                 :          0 :         if (status)
    6104                 :            :                 goto out;
    6105                 :            :         status = decode_putfh(xdr);
    6106                 :          0 :         if (status)
    6107                 :            :                 goto out;
    6108                 :            :         status = decode_lookup(xdr);
    6109                 :          0 :         if (status)
    6110                 :            :                 goto out;
    6111                 :          0 :         status = decode_getfh(xdr, res->fh);
    6112                 :          0 :         if (status)
    6113                 :            :                 goto out;
    6114                 :          0 :         status = decode_getfattr_label(xdr, res->fattr, res->label, res->server);
    6115                 :            : out:
    6116                 :          0 :         return status;
    6117                 :            : }
    6118                 :            : 
    6119                 :            : /*
    6120                 :            :  * Decode LOOKUPP response
    6121                 :            :  */
    6122                 :          0 : static int nfs4_xdr_dec_lookupp(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
    6123                 :            :                 void *data)
    6124                 :            : {
    6125                 :            :         struct nfs4_lookupp_res *res = data;
    6126                 :            :         struct compound_hdr hdr;
    6127                 :            :         int status;
    6128                 :            : 
    6129                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6130                 :          0 :         if (status)
    6131                 :            :                 goto out;
    6132                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    6133                 :          0 :         if (status)
    6134                 :            :                 goto out;
    6135                 :            :         status = decode_putfh(xdr);
    6136                 :          0 :         if (status)
    6137                 :            :                 goto out;
    6138                 :            :         status = decode_lookupp(xdr);
    6139                 :          0 :         if (status)
    6140                 :            :                 goto out;
    6141                 :          0 :         status = decode_getfh(xdr, res->fh);
    6142                 :          0 :         if (status)
    6143                 :            :                 goto out;
    6144                 :          0 :         status = decode_getfattr_label(xdr, res->fattr, res->label, res->server);
    6145                 :            : out:
    6146                 :          0 :         return status;
    6147                 :            : }
    6148                 :            : 
    6149                 :            : /*
    6150                 :            :  * Decode LOOKUP_ROOT response
    6151                 :            :  */
    6152                 :          0 : static int nfs4_xdr_dec_lookup_root(struct rpc_rqst *rqstp,
    6153                 :            :                                     struct xdr_stream *xdr,
    6154                 :            :                                     void *data)
    6155                 :            : {
    6156                 :            :         struct nfs4_lookup_res *res = data;
    6157                 :            :         struct compound_hdr hdr;
    6158                 :            :         int status;
    6159                 :            : 
    6160                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6161                 :          0 :         if (status)
    6162                 :            :                 goto out;
    6163                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    6164                 :          0 :         if (status)
    6165                 :            :                 goto out;
    6166                 :            :         status = decode_putrootfh(xdr);
    6167                 :          0 :         if (status)
    6168                 :            :                 goto out;
    6169                 :          0 :         status = decode_getfh(xdr, res->fh);
    6170                 :          0 :         if (status == 0)
    6171                 :          0 :                 status = decode_getfattr_label(xdr, res->fattr,
    6172                 :            :                                                 res->label, res->server);
    6173                 :            : out:
    6174                 :          0 :         return status;
    6175                 :            : }
    6176                 :            : 
    6177                 :            : /*
    6178                 :            :  * Decode REMOVE response
    6179                 :            :  */
    6180                 :          0 : static int nfs4_xdr_dec_remove(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
    6181                 :            :                                void *data)
    6182                 :            : {
    6183                 :            :         struct nfs_removeres *res = data;
    6184                 :            :         struct compound_hdr hdr;
    6185                 :            :         int status;
    6186                 :            : 
    6187                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6188                 :          0 :         if (status)
    6189                 :            :                 goto out;
    6190                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    6191                 :          0 :         if (status)
    6192                 :            :                 goto out;
    6193                 :            :         status = decode_putfh(xdr);
    6194                 :          0 :         if (status)
    6195                 :            :                 goto out;
    6196                 :          0 :         status = decode_remove(xdr, &res->cinfo);
    6197                 :            : out:
    6198                 :          0 :         return status;
    6199                 :            : }
    6200                 :            : 
    6201                 :            : /*
    6202                 :            :  * Decode RENAME response
    6203                 :            :  */
    6204                 :          0 : static int nfs4_xdr_dec_rename(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
    6205                 :            :                                void *data)
    6206                 :            : {
    6207                 :            :         struct nfs_renameres *res = data;
    6208                 :            :         struct compound_hdr hdr;
    6209                 :            :         int status;
    6210                 :            : 
    6211                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6212                 :          0 :         if (status)
    6213                 :            :                 goto out;
    6214                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    6215                 :          0 :         if (status)
    6216                 :            :                 goto out;
    6217                 :            :         status = decode_putfh(xdr);
    6218                 :          0 :         if (status)
    6219                 :            :                 goto out;
    6220                 :            :         status = decode_savefh(xdr);
    6221                 :          0 :         if (status)
    6222                 :            :                 goto out;
    6223                 :            :         status = decode_putfh(xdr);
    6224                 :          0 :         if (status)
    6225                 :            :                 goto out;
    6226                 :          0 :         status = decode_rename(xdr, &res->old_cinfo, &res->new_cinfo);
    6227                 :            : out:
    6228                 :          0 :         return status;
    6229                 :            : }
    6230                 :            : 
    6231                 :            : /*
    6232                 :            :  * Decode LINK response
    6233                 :            :  */
    6234                 :          0 : static int nfs4_xdr_dec_link(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
    6235                 :            :                              void *data)
    6236                 :            : {
    6237                 :            :         struct nfs4_link_res *res = data;
    6238                 :            :         struct compound_hdr hdr;
    6239                 :            :         int status;
    6240                 :            : 
    6241                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6242                 :          0 :         if (status)
    6243                 :            :                 goto out;
    6244                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    6245                 :          0 :         if (status)
    6246                 :            :                 goto out;
    6247                 :            :         status = decode_putfh(xdr);
    6248                 :          0 :         if (status)
    6249                 :            :                 goto out;
    6250                 :            :         status = decode_savefh(xdr);
    6251                 :          0 :         if (status)
    6252                 :            :                 goto out;
    6253                 :            :         status = decode_putfh(xdr);
    6254                 :          0 :         if (status)
    6255                 :            :                 goto out;
    6256                 :          0 :         status = decode_link(xdr, &res->cinfo);
    6257                 :          0 :         if (status)
    6258                 :            :                 goto out;
    6259                 :            :         /*
    6260                 :            :          * Note order: OP_LINK leaves the directory as the current
    6261                 :            :          *             filehandle.
    6262                 :            :          */
    6263                 :            :         status = decode_restorefh(xdr);
    6264                 :          0 :         if (status)
    6265                 :            :                 goto out;
    6266                 :          0 :         decode_getfattr_label(xdr, res->fattr, res->label, res->server);
    6267                 :            : out:
    6268                 :          0 :         return status;
    6269                 :            : }
    6270                 :            : 
    6271                 :            : /*
    6272                 :            :  * Decode CREATE response
    6273                 :            :  */
    6274                 :          0 : static int nfs4_xdr_dec_create(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
    6275                 :            :                                void *data)
    6276                 :            : {
    6277                 :            :         struct nfs4_create_res *res = data;
    6278                 :            :         struct compound_hdr hdr;
    6279                 :            :         int status;
    6280                 :            : 
    6281                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6282                 :          0 :         if (status)
    6283                 :            :                 goto out;
    6284                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    6285                 :          0 :         if (status)
    6286                 :            :                 goto out;
    6287                 :            :         status = decode_putfh(xdr);
    6288                 :          0 :         if (status)
    6289                 :            :                 goto out;
    6290                 :          0 :         status = decode_create(xdr, &res->dir_cinfo);
    6291                 :          0 :         if (status)
    6292                 :            :                 goto out;
    6293                 :          0 :         status = decode_getfh(xdr, res->fh);
    6294                 :          0 :         if (status)
    6295                 :            :                 goto out;
    6296                 :          0 :         decode_getfattr_label(xdr, res->fattr, res->label, res->server);
    6297                 :            : out:
    6298                 :          0 :         return status;
    6299                 :            : }
    6300                 :            : 
    6301                 :            : /*
    6302                 :            :  * Decode SYMLINK response
    6303                 :            :  */
    6304                 :          0 : static int nfs4_xdr_dec_symlink(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
    6305                 :            :                                 void *res)
    6306                 :            : {
    6307                 :          0 :         return nfs4_xdr_dec_create(rqstp, xdr, res);
    6308                 :            : }
    6309                 :            : 
    6310                 :            : /*
    6311                 :            :  * Decode GETATTR response
    6312                 :            :  */
    6313                 :          0 : static int nfs4_xdr_dec_getattr(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
    6314                 :            :                                 void *data)
    6315                 :            : {
    6316                 :            :         struct nfs4_getattr_res *res = data;
    6317                 :            :         struct compound_hdr hdr;
    6318                 :            :         int status;
    6319                 :            : 
    6320                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6321                 :          0 :         if (status)
    6322                 :            :                 goto out;
    6323                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    6324                 :          0 :         if (status)
    6325                 :            :                 goto out;
    6326                 :            :         status = decode_putfh(xdr);
    6327                 :          0 :         if (status)
    6328                 :            :                 goto out;
    6329                 :          0 :         status = decode_getfattr_label(xdr, res->fattr, res->label, res->server);
    6330                 :            : out:
    6331                 :          0 :         return status;
    6332                 :            : }
    6333                 :            : 
    6334                 :            : /*
    6335                 :            :  * Encode an SETACL request
    6336                 :            :  */
    6337                 :          0 : static void nfs4_xdr_enc_setacl(struct rpc_rqst *req, struct xdr_stream *xdr,
    6338                 :            :                                 const void *data)
    6339                 :            : {
    6340                 :            :         const struct nfs_setaclargs *args = data;
    6341                 :          0 :         struct compound_hdr hdr = {
    6342                 :            :                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
    6343                 :            :         };
    6344                 :            : 
    6345                 :          0 :         encode_compound_hdr(xdr, req, &hdr);
    6346                 :          0 :         encode_sequence(xdr, &args->seq_args, &hdr);
    6347                 :          0 :         encode_putfh(xdr, args->fh, &hdr);
    6348                 :          0 :         encode_setacl(xdr, args, &hdr);
    6349                 :          0 :         encode_nops(&hdr);
    6350                 :          0 : }
    6351                 :            : 
    6352                 :            : /*
    6353                 :            :  * Decode SETACL response
    6354                 :            :  */
    6355                 :            : static int
    6356                 :          0 : nfs4_xdr_dec_setacl(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
    6357                 :            :                     void *data)
    6358                 :            : {
    6359                 :            :         struct nfs_setaclres *res = data;
    6360                 :            :         struct compound_hdr hdr;
    6361                 :            :         int status;
    6362                 :            : 
    6363                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6364                 :          0 :         if (status)
    6365                 :            :                 goto out;
    6366                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    6367                 :          0 :         if (status)
    6368                 :            :                 goto out;
    6369                 :            :         status = decode_putfh(xdr);
    6370                 :          0 :         if (status)
    6371                 :            :                 goto out;
    6372                 :          0 :         status = decode_setattr(xdr);
    6373                 :            : out:
    6374                 :          0 :         return status;
    6375                 :            : }
    6376                 :            : 
    6377                 :            : /*
    6378                 :            :  * Decode GETACL response
    6379                 :            :  */
    6380                 :            : static int
    6381                 :          0 : nfs4_xdr_dec_getacl(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
    6382                 :            :                     void *data)
    6383                 :            : {
    6384                 :            :         struct nfs_getaclres *res = data;
    6385                 :            :         struct compound_hdr hdr;
    6386                 :            :         int status;
    6387                 :            : 
    6388                 :          0 :         if (res->acl_scratch != NULL) {
    6389                 :            :                 void *p = page_address(res->acl_scratch);
    6390                 :          0 :                 xdr_set_scratch_buffer(xdr, p, PAGE_SIZE);
    6391                 :            :         }
    6392                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6393                 :          0 :         if (status)
    6394                 :            :                 goto out;
    6395                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    6396                 :          0 :         if (status)
    6397                 :            :                 goto out;
    6398                 :            :         status = decode_putfh(xdr);
    6399                 :          0 :         if (status)
    6400                 :            :                 goto out;
    6401                 :          0 :         status = decode_getacl(xdr, rqstp, res);
    6402                 :            : 
    6403                 :            : out:
    6404                 :          0 :         return status;
    6405                 :            : }
    6406                 :            : 
    6407                 :            : /*
    6408                 :            :  * Decode CLOSE response
    6409                 :            :  */
    6410                 :          0 : static int nfs4_xdr_dec_close(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
    6411                 :            :                               void *data)
    6412                 :            : {
    6413                 :            :         struct nfs_closeres *res = data;
    6414                 :            :         struct compound_hdr hdr;
    6415                 :            :         int status;
    6416                 :            : 
    6417                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6418                 :          0 :         if (status)
    6419                 :            :                 goto out;
    6420                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    6421                 :          0 :         if (status)
    6422                 :            :                 goto out;
    6423                 :            :         status = decode_putfh(xdr);
    6424                 :          0 :         if (status)
    6425                 :            :                 goto out;
    6426                 :          0 :         if (res->lr_res) {
    6427                 :          0 :                 status = decode_layoutreturn(xdr, res->lr_res);
    6428                 :          0 :                 res->lr_ret = status;
    6429                 :          0 :                 if (status)
    6430                 :            :                         goto out;
    6431                 :            :         }
    6432                 :          0 :         if (res->fattr != NULL) {
    6433                 :          0 :                 status = decode_getfattr(xdr, res->fattr, res->server);
    6434                 :          0 :                 if (status != 0)
    6435                 :            :                         goto out;
    6436                 :            :         }
    6437                 :          0 :         status = decode_close(xdr, res);
    6438                 :            : out:
    6439                 :          0 :         return status;
    6440                 :            : }
    6441                 :            : 
    6442                 :            : /*
    6443                 :            :  * Decode OPEN response
    6444                 :            :  */
    6445                 :          0 : static int nfs4_xdr_dec_open(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
    6446                 :            :                              void *data)
    6447                 :            : {
    6448                 :            :         struct nfs_openres *res = data;
    6449                 :            :         struct compound_hdr hdr;
    6450                 :            :         int status;
    6451                 :            : 
    6452                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6453                 :          0 :         if (status)
    6454                 :            :                 goto out;
    6455                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    6456                 :          0 :         if (status)
    6457                 :            :                 goto out;
    6458                 :            :         status = decode_putfh(xdr);
    6459                 :          0 :         if (status)
    6460                 :            :                 goto out;
    6461                 :          0 :         status = decode_open(xdr, res);
    6462                 :          0 :         if (status)
    6463                 :            :                 goto out;
    6464                 :          0 :         status = decode_getfh(xdr, &res->fh);
    6465                 :          0 :         if (status)
    6466                 :            :                 goto out;
    6467                 :          0 :         if (res->access_request)
    6468                 :          0 :                 decode_access(xdr, &res->access_supported, &res->access_result);
    6469                 :          0 :         decode_getfattr_label(xdr, res->f_attr, res->f_label, res->server);
    6470                 :          0 :         if (res->lg_res)
    6471                 :          0 :                 decode_layoutget(xdr, rqstp, res->lg_res);
    6472                 :            : out:
    6473                 :          0 :         return status;
    6474                 :            : }
    6475                 :            : 
    6476                 :            : /*
    6477                 :            :  * Decode OPEN_CONFIRM response
    6478                 :            :  */
    6479                 :          0 : static int nfs4_xdr_dec_open_confirm(struct rpc_rqst *rqstp,
    6480                 :            :                                      struct xdr_stream *xdr,
    6481                 :            :                                      void *data)
    6482                 :            : {
    6483                 :            :         struct nfs_open_confirmres *res = data;
    6484                 :            :         struct compound_hdr hdr;
    6485                 :            :         int status;
    6486                 :            : 
    6487                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6488                 :          0 :         if (status)
    6489                 :            :                 goto out;
    6490                 :            :         status = decode_putfh(xdr);
    6491                 :          0 :         if (status)
    6492                 :            :                 goto out;
    6493                 :          0 :         status = decode_open_confirm(xdr, res);
    6494                 :            : out:
    6495                 :          0 :         return status;
    6496                 :            : }
    6497                 :            : 
    6498                 :            : /*
    6499                 :            :  * Decode OPEN response
    6500                 :            :  */
    6501                 :          0 : static int nfs4_xdr_dec_open_noattr(struct rpc_rqst *rqstp,
    6502                 :            :                                     struct xdr_stream *xdr,
    6503                 :            :                                     void *data)
    6504                 :            : {
    6505                 :            :         struct nfs_openres *res = data;
    6506                 :            :         struct compound_hdr hdr;
    6507                 :            :         int status;
    6508                 :            : 
    6509                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6510                 :          0 :         if (status)
    6511                 :            :                 goto out;
    6512                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    6513                 :          0 :         if (status)
    6514                 :            :                 goto out;
    6515                 :            :         status = decode_putfh(xdr);
    6516                 :          0 :         if (status)
    6517                 :            :                 goto out;
    6518                 :          0 :         status = decode_open(xdr, res);
    6519                 :          0 :         if (status)
    6520                 :            :                 goto out;
    6521                 :          0 :         if (res->access_request)
    6522                 :          0 :                 decode_access(xdr, &res->access_supported, &res->access_result);
    6523                 :          0 :         decode_getfattr(xdr, res->f_attr, res->server);
    6524                 :          0 :         if (res->lg_res)
    6525                 :          0 :                 decode_layoutget(xdr, rqstp, res->lg_res);
    6526                 :            : out:
    6527                 :          0 :         return status;
    6528                 :            : }
    6529                 :            : 
    6530                 :            : /*
    6531                 :            :  * Decode SETATTR response
    6532                 :            :  */
    6533                 :          0 : static int nfs4_xdr_dec_setattr(struct rpc_rqst *rqstp,
    6534                 :            :                                 struct xdr_stream *xdr,
    6535                 :            :                                 void *data)
    6536                 :            : {
    6537                 :            :         struct nfs_setattrres *res = data;
    6538                 :            :         struct compound_hdr hdr;
    6539                 :            :         int status;
    6540                 :            : 
    6541                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6542                 :          0 :         if (status)
    6543                 :            :                 goto out;
    6544                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    6545                 :          0 :         if (status)
    6546                 :            :                 goto out;
    6547                 :            :         status = decode_putfh(xdr);
    6548                 :          0 :         if (status)
    6549                 :            :                 goto out;
    6550                 :          0 :         status = decode_setattr(xdr);
    6551                 :          0 :         if (status)
    6552                 :            :                 goto out;
    6553                 :          0 :         decode_getfattr_label(xdr, res->fattr, res->label, res->server);
    6554                 :            : out:
    6555                 :          0 :         return status;
    6556                 :            : }
    6557                 :            : 
    6558                 :            : /*
    6559                 :            :  * Decode LOCK response
    6560                 :            :  */
    6561                 :          0 : static int nfs4_xdr_dec_lock(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
    6562                 :            :                              void *data)
    6563                 :            : {
    6564                 :            :         struct nfs_lock_res *res = data;
    6565                 :            :         struct compound_hdr hdr;
    6566                 :            :         int status;
    6567                 :            : 
    6568                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6569                 :          0 :         if (status)
    6570                 :            :                 goto out;
    6571                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    6572                 :          0 :         if (status)
    6573                 :            :                 goto out;
    6574                 :            :         status = decode_putfh(xdr);
    6575                 :          0 :         if (status)
    6576                 :            :                 goto out;
    6577                 :          0 :         status = decode_lock(xdr, res);
    6578                 :            : out:
    6579                 :          0 :         return status;
    6580                 :            : }
    6581                 :            : 
    6582                 :            : /*
    6583                 :            :  * Decode LOCKT response
    6584                 :            :  */
    6585                 :          0 : static int nfs4_xdr_dec_lockt(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
    6586                 :            :                               void *data)
    6587                 :            : {
    6588                 :            :         struct nfs_lockt_res *res = data;
    6589                 :            :         struct compound_hdr hdr;
    6590                 :            :         int status;
    6591                 :            : 
    6592                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6593                 :          0 :         if (status)
    6594                 :            :                 goto out;
    6595                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    6596                 :          0 :         if (status)
    6597                 :            :                 goto out;
    6598                 :            :         status = decode_putfh(xdr);
    6599                 :          0 :         if (status)
    6600                 :            :                 goto out;
    6601                 :          0 :         status = decode_lockt(xdr, res);
    6602                 :            : out:
    6603                 :          0 :         return status;
    6604                 :            : }
    6605                 :            : 
    6606                 :            : /*
    6607                 :            :  * Decode LOCKU response
    6608                 :            :  */
    6609                 :          0 : static int nfs4_xdr_dec_locku(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
    6610                 :            :                               void *data)
    6611                 :            : {
    6612                 :            :         struct nfs_locku_res *res = data;
    6613                 :            :         struct compound_hdr hdr;
    6614                 :            :         int status;
    6615                 :            : 
    6616                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6617                 :          0 :         if (status)
    6618                 :            :                 goto out;
    6619                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    6620                 :          0 :         if (status)
    6621                 :            :                 goto out;
    6622                 :            :         status = decode_putfh(xdr);
    6623                 :          0 :         if (status)
    6624                 :            :                 goto out;
    6625                 :          0 :         status = decode_locku(xdr, res);
    6626                 :            : out:
    6627                 :          0 :         return status;
    6628                 :            : }
    6629                 :            : 
    6630                 :          0 : static int nfs4_xdr_dec_release_lockowner(struct rpc_rqst *rqstp,
    6631                 :            :                                           struct xdr_stream *xdr, void *dummy)
    6632                 :            : {
    6633                 :            :         struct compound_hdr hdr;
    6634                 :            :         int status;
    6635                 :            : 
    6636                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6637                 :          0 :         if (!status)
    6638                 :            :                 status = decode_release_lockowner(xdr);
    6639                 :          0 :         return status;
    6640                 :            : }
    6641                 :            : 
    6642                 :            : /*
    6643                 :            :  * Decode READLINK response
    6644                 :            :  */
    6645                 :          0 : static int nfs4_xdr_dec_readlink(struct rpc_rqst *rqstp,
    6646                 :            :                                  struct xdr_stream *xdr,
    6647                 :            :                                  void *data)
    6648                 :            : {
    6649                 :            :         struct nfs4_readlink_res *res = data;
    6650                 :            :         struct compound_hdr hdr;
    6651                 :            :         int status;
    6652                 :            : 
    6653                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6654                 :          0 :         if (status)
    6655                 :            :                 goto out;
    6656                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    6657                 :          0 :         if (status)
    6658                 :            :                 goto out;
    6659                 :            :         status = decode_putfh(xdr);
    6660                 :          0 :         if (status)
    6661                 :            :                 goto out;
    6662                 :          0 :         status = decode_readlink(xdr, rqstp);
    6663                 :            : out:
    6664                 :          0 :         return status;
    6665                 :            : }
    6666                 :            : 
    6667                 :            : /*
    6668                 :            :  * Decode READDIR response
    6669                 :            :  */
    6670                 :          0 : static int nfs4_xdr_dec_readdir(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
    6671                 :            :                                 void *data)
    6672                 :            : {
    6673                 :            :         struct nfs4_readdir_res *res = data;
    6674                 :            :         struct compound_hdr hdr;
    6675                 :            :         int status;
    6676                 :            : 
    6677                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6678                 :          0 :         if (status)
    6679                 :            :                 goto out;
    6680                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    6681                 :          0 :         if (status)
    6682                 :            :                 goto out;
    6683                 :            :         status = decode_putfh(xdr);
    6684                 :          0 :         if (status)
    6685                 :            :                 goto out;
    6686                 :          0 :         status = decode_readdir(xdr, rqstp, res);
    6687                 :            : out:
    6688                 :          0 :         return status;
    6689                 :            : }
    6690                 :            : 
    6691                 :            : /*
    6692                 :            :  * Decode Read response
    6693                 :            :  */
    6694                 :          0 : static int nfs4_xdr_dec_read(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
    6695                 :            :                              void *data)
    6696                 :            : {
    6697                 :            :         struct nfs_pgio_res *res = data;
    6698                 :            :         struct compound_hdr hdr;
    6699                 :            :         int status;
    6700                 :            : 
    6701                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6702                 :          0 :         res->op_status = hdr.status;
    6703                 :          0 :         if (status)
    6704                 :            :                 goto out;
    6705                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    6706                 :          0 :         if (status)
    6707                 :            :                 goto out;
    6708                 :            :         status = decode_putfh(xdr);
    6709                 :          0 :         if (status)
    6710                 :            :                 goto out;
    6711                 :          0 :         status = decode_read(xdr, rqstp, res);
    6712                 :          0 :         if (!status)
    6713                 :          0 :                 status = res->count;
    6714                 :            : out:
    6715                 :          0 :         return status;
    6716                 :            : }
    6717                 :            : 
    6718                 :            : /*
    6719                 :            :  * Decode WRITE response
    6720                 :            :  */
    6721                 :          0 : static int nfs4_xdr_dec_write(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
    6722                 :            :                               void *data)
    6723                 :            : {
    6724                 :            :         struct nfs_pgio_res *res = data;
    6725                 :            :         struct compound_hdr hdr;
    6726                 :            :         int status;
    6727                 :            : 
    6728                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6729                 :          0 :         res->op_status = hdr.status;
    6730                 :          0 :         if (status)
    6731                 :            :                 goto out;
    6732                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    6733                 :          0 :         if (status)
    6734                 :            :                 goto out;
    6735                 :            :         status = decode_putfh(xdr);
    6736                 :          0 :         if (status)
    6737                 :            :                 goto out;
    6738                 :          0 :         status = decode_write(xdr, res);
    6739                 :          0 :         if (status)
    6740                 :            :                 goto out;
    6741                 :          0 :         if (res->fattr)
    6742                 :          0 :                 decode_getfattr(xdr, res->fattr, res->server);
    6743                 :          0 :         if (!status)
    6744                 :          0 :                 status = res->count;
    6745                 :            : out:
    6746                 :          0 :         return status;
    6747                 :            : }
    6748                 :            : 
    6749                 :            : /*
    6750                 :            :  * Decode COMMIT response
    6751                 :            :  */
    6752                 :          0 : static int nfs4_xdr_dec_commit(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
    6753                 :            :                                void *data)
    6754                 :            : {
    6755                 :            :         struct nfs_commitres *res = data;
    6756                 :            :         struct compound_hdr hdr;
    6757                 :            :         int status;
    6758                 :            : 
    6759                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6760                 :          0 :         res->op_status = hdr.status;
    6761                 :          0 :         if (status)
    6762                 :            :                 goto out;
    6763                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    6764                 :          0 :         if (status)
    6765                 :            :                 goto out;
    6766                 :            :         status = decode_putfh(xdr);
    6767                 :          0 :         if (status)
    6768                 :            :                 goto out;
    6769                 :          0 :         status = decode_commit(xdr, res);
    6770                 :            : out:
    6771                 :          0 :         return status;
    6772                 :            : }
    6773                 :            : 
    6774                 :            : /*
    6775                 :            :  * Decode FSINFO response
    6776                 :            :  */
    6777                 :          0 : static int nfs4_xdr_dec_fsinfo(struct rpc_rqst *req, struct xdr_stream *xdr,
    6778                 :            :                                void *data)
    6779                 :            : {
    6780                 :            :         struct nfs4_fsinfo_res *res = data;
    6781                 :            :         struct compound_hdr hdr;
    6782                 :            :         int status;
    6783                 :            : 
    6784                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6785                 :          0 :         if (!status)
    6786                 :          0 :                 status = decode_sequence(xdr, &res->seq_res, req);
    6787                 :          0 :         if (!status)
    6788                 :            :                 status = decode_putfh(xdr);
    6789                 :          0 :         if (!status)
    6790                 :          0 :                 status = decode_fsinfo(xdr, res->fsinfo);
    6791                 :          0 :         return status;
    6792                 :            : }
    6793                 :            : 
    6794                 :            : /*
    6795                 :            :  * Decode PATHCONF response
    6796                 :            :  */
    6797                 :          0 : static int nfs4_xdr_dec_pathconf(struct rpc_rqst *req, struct xdr_stream *xdr,
    6798                 :            :                                  void *data)
    6799                 :            : {
    6800                 :            :         struct nfs4_pathconf_res *res = data;
    6801                 :            :         struct compound_hdr hdr;
    6802                 :            :         int status;
    6803                 :            : 
    6804                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6805                 :          0 :         if (!status)
    6806                 :          0 :                 status = decode_sequence(xdr, &res->seq_res, req);
    6807                 :          0 :         if (!status)
    6808                 :            :                 status = decode_putfh(xdr);
    6809                 :          0 :         if (!status)
    6810                 :          0 :                 status = decode_pathconf(xdr, res->pathconf);
    6811                 :          0 :         return status;
    6812                 :            : }
    6813                 :            : 
    6814                 :            : /*
    6815                 :            :  * Decode STATFS response
    6816                 :            :  */
    6817                 :          0 : static int nfs4_xdr_dec_statfs(struct rpc_rqst *req, struct xdr_stream *xdr,
    6818                 :            :                                void *data)
    6819                 :            : {
    6820                 :            :         struct nfs4_statfs_res *res = data;
    6821                 :            :         struct compound_hdr hdr;
    6822                 :            :         int status;
    6823                 :            : 
    6824                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6825                 :          0 :         if (!status)
    6826                 :          0 :                 status = decode_sequence(xdr, &res->seq_res, req);
    6827                 :          0 :         if (!status)
    6828                 :            :                 status = decode_putfh(xdr);
    6829                 :          0 :         if (!status)
    6830                 :          0 :                 status = decode_statfs(xdr, res->fsstat);
    6831                 :          0 :         return status;
    6832                 :            : }
    6833                 :            : 
    6834                 :            : /*
    6835                 :            :  * Decode GETATTR_BITMAP response
    6836                 :            :  */
    6837                 :          0 : static int nfs4_xdr_dec_server_caps(struct rpc_rqst *req,
    6838                 :            :                                     struct xdr_stream *xdr,
    6839                 :            :                                     void *data)
    6840                 :            : {
    6841                 :            :         struct nfs4_server_caps_res *res = data;
    6842                 :            :         struct compound_hdr hdr;
    6843                 :            :         int status;
    6844                 :            : 
    6845                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6846                 :          0 :         if (status)
    6847                 :            :                 goto out;
    6848                 :          0 :         status = decode_sequence(xdr, &res->seq_res, req);
    6849                 :          0 :         if (status)
    6850                 :            :                 goto out;
    6851                 :            :         status = decode_putfh(xdr);
    6852                 :          0 :         if (status)
    6853                 :            :                 goto out;
    6854                 :          0 :         status = decode_server_caps(xdr, res);
    6855                 :            : out:
    6856                 :          0 :         return status;
    6857                 :            : }
    6858                 :            : 
    6859                 :            : /*
    6860                 :            :  * Decode RENEW response
    6861                 :            :  */
    6862                 :          0 : static int nfs4_xdr_dec_renew(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
    6863                 :            :                               void *__unused)
    6864                 :            : {
    6865                 :            :         struct compound_hdr hdr;
    6866                 :            :         int status;
    6867                 :            : 
    6868                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6869                 :          0 :         if (!status)
    6870                 :            :                 status = decode_renew(xdr);
    6871                 :          0 :         return status;
    6872                 :            : }
    6873                 :            : 
    6874                 :            : /*
    6875                 :            :  * Decode SETCLIENTID response
    6876                 :            :  */
    6877                 :          0 : static int nfs4_xdr_dec_setclientid(struct rpc_rqst *req,
    6878                 :            :                                     struct xdr_stream *xdr,
    6879                 :            :                                     void *data)
    6880                 :            : {
    6881                 :            :         struct nfs4_setclientid_res *res = data;
    6882                 :            :         struct compound_hdr hdr;
    6883                 :            :         int status;
    6884                 :            : 
    6885                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6886                 :          0 :         if (!status)
    6887                 :          0 :                 status = decode_setclientid(xdr, res);
    6888                 :          0 :         return status;
    6889                 :            : }
    6890                 :            : 
    6891                 :            : /*
    6892                 :            :  * Decode SETCLIENTID_CONFIRM response
    6893                 :            :  */
    6894                 :          0 : static int nfs4_xdr_dec_setclientid_confirm(struct rpc_rqst *req,
    6895                 :            :                                             struct xdr_stream *xdr,
    6896                 :            :                                             void *data)
    6897                 :            : {
    6898                 :            :         struct compound_hdr hdr;
    6899                 :            :         int status;
    6900                 :            : 
    6901                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6902                 :          0 :         if (!status)
    6903                 :            :                 status = decode_setclientid_confirm(xdr);
    6904                 :          0 :         return status;
    6905                 :            : }
    6906                 :            : 
    6907                 :            : /*
    6908                 :            :  * Decode DELEGRETURN response
    6909                 :            :  */
    6910                 :          0 : static int nfs4_xdr_dec_delegreturn(struct rpc_rqst *rqstp,
    6911                 :            :                                     struct xdr_stream *xdr,
    6912                 :            :                                     void *data)
    6913                 :            : {
    6914                 :            :         struct nfs4_delegreturnres *res = data;
    6915                 :            :         struct compound_hdr hdr;
    6916                 :            :         int status;
    6917                 :            : 
    6918                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6919                 :          0 :         if (status)
    6920                 :            :                 goto out;
    6921                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    6922                 :          0 :         if (status)
    6923                 :            :                 goto out;
    6924                 :            :         status = decode_putfh(xdr);
    6925                 :          0 :         if (status != 0)
    6926                 :            :                 goto out;
    6927                 :          0 :         if (res->lr_res) {
    6928                 :          0 :                 status = decode_layoutreturn(xdr, res->lr_res);
    6929                 :          0 :                 res->lr_ret = status;
    6930                 :          0 :                 if (status)
    6931                 :            :                         goto out;
    6932                 :            :         }
    6933                 :          0 :         if (res->fattr) {
    6934                 :          0 :                 status = decode_getfattr(xdr, res->fattr, res->server);
    6935                 :          0 :                 if (status != 0)
    6936                 :            :                         goto out;
    6937                 :            :         }
    6938                 :            :         status = decode_delegreturn(xdr);
    6939                 :            : out:
    6940                 :          0 :         return status;
    6941                 :            : }
    6942                 :            : 
    6943                 :            : /*
    6944                 :            :  * Decode FS_LOCATIONS response
    6945                 :            :  */
    6946                 :          0 : static int nfs4_xdr_dec_fs_locations(struct rpc_rqst *req,
    6947                 :            :                                      struct xdr_stream *xdr,
    6948                 :            :                                      void *data)
    6949                 :            : {
    6950                 :            :         struct nfs4_fs_locations_res *res = data;
    6951                 :            :         struct compound_hdr hdr;
    6952                 :            :         int status;
    6953                 :            : 
    6954                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6955                 :          0 :         if (status)
    6956                 :            :                 goto out;
    6957                 :          0 :         status = decode_sequence(xdr, &res->seq_res, req);
    6958                 :          0 :         if (status)
    6959                 :            :                 goto out;
    6960                 :            :         status = decode_putfh(xdr);
    6961                 :          0 :         if (status)
    6962                 :            :                 goto out;
    6963                 :          0 :         if (res->migration) {
    6964                 :          0 :                 xdr_enter_page(xdr, PAGE_SIZE);
    6965                 :          0 :                 status = decode_getfattr_generic(xdr,
    6966                 :          0 :                                         &res->fs_locations->fattr,
    6967                 :            :                                          NULL, res->fs_locations,
    6968                 :            :                                          NULL, res->fs_locations->server);
    6969                 :          0 :                 if (status)
    6970                 :            :                         goto out;
    6971                 :          0 :                 if (res->renew)
    6972                 :            :                         status = decode_renew(xdr);
    6973                 :            :         } else {
    6974                 :            :                 status = decode_lookup(xdr);
    6975                 :          0 :                 if (status)
    6976                 :            :                         goto out;
    6977                 :          0 :                 xdr_enter_page(xdr, PAGE_SIZE);
    6978                 :          0 :                 status = decode_getfattr_generic(xdr,
    6979                 :          0 :                                         &res->fs_locations->fattr,
    6980                 :            :                                          NULL, res->fs_locations,
    6981                 :            :                                          NULL, res->fs_locations->server);
    6982                 :            :         }
    6983                 :            : out:
    6984                 :          0 :         return status;
    6985                 :            : }
    6986                 :            : 
    6987                 :            : /*
    6988                 :            :  * Decode SECINFO response
    6989                 :            :  */
    6990                 :          0 : static int nfs4_xdr_dec_secinfo(struct rpc_rqst *rqstp,
    6991                 :            :                                 struct xdr_stream *xdr,
    6992                 :            :                                 void *data)
    6993                 :            : {
    6994                 :            :         struct nfs4_secinfo_res *res = data;
    6995                 :            :         struct compound_hdr hdr;
    6996                 :            :         int status;
    6997                 :            : 
    6998                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    6999                 :          0 :         if (status)
    7000                 :            :                 goto out;
    7001                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    7002                 :          0 :         if (status)
    7003                 :            :                 goto out;
    7004                 :            :         status = decode_putfh(xdr);
    7005                 :          0 :         if (status)
    7006                 :            :                 goto out;
    7007                 :          0 :         status = decode_secinfo(xdr, res);
    7008                 :            : out:
    7009                 :          0 :         return status;
    7010                 :            : }
    7011                 :            : 
    7012                 :            : /*
    7013                 :            :  * Decode FSID_PRESENT response
    7014                 :            :  */
    7015                 :          0 : static int nfs4_xdr_dec_fsid_present(struct rpc_rqst *rqstp,
    7016                 :            :                                      struct xdr_stream *xdr,
    7017                 :            :                                      void *data)
    7018                 :            : {
    7019                 :            :         struct nfs4_fsid_present_res *res = data;
    7020                 :            :         struct compound_hdr hdr;
    7021                 :            :         int status;
    7022                 :            : 
    7023                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    7024                 :          0 :         if (status)
    7025                 :            :                 goto out;
    7026                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    7027                 :          0 :         if (status)
    7028                 :            :                 goto out;
    7029                 :            :         status = decode_putfh(xdr);
    7030                 :          0 :         if (status)
    7031                 :            :                 goto out;
    7032                 :          0 :         status = decode_getfh(xdr, res->fh);
    7033                 :          0 :         if (status)
    7034                 :            :                 goto out;
    7035                 :          0 :         if (res->renew)
    7036                 :            :                 status = decode_renew(xdr);
    7037                 :            : out:
    7038                 :          0 :         return status;
    7039                 :            : }
    7040                 :            : 
    7041                 :            : #if defined(CONFIG_NFS_V4_1)
    7042                 :            : /*
    7043                 :            :  * Decode BIND_CONN_TO_SESSION response
    7044                 :            :  */
    7045                 :          0 : static int nfs4_xdr_dec_bind_conn_to_session(struct rpc_rqst *rqstp,
    7046                 :            :                                         struct xdr_stream *xdr,
    7047                 :            :                                         void *res)
    7048                 :            : {
    7049                 :            :         struct compound_hdr hdr;
    7050                 :            :         int status;
    7051                 :            : 
    7052                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    7053                 :          0 :         if (!status)
    7054                 :          0 :                 status = decode_bind_conn_to_session(xdr, res);
    7055                 :          0 :         return status;
    7056                 :            : }
    7057                 :            : 
    7058                 :            : /*
    7059                 :            :  * Decode EXCHANGE_ID response
    7060                 :            :  */
    7061                 :          0 : static int nfs4_xdr_dec_exchange_id(struct rpc_rqst *rqstp,
    7062                 :            :                                     struct xdr_stream *xdr,
    7063                 :            :                                     void *res)
    7064                 :            : {
    7065                 :            :         struct compound_hdr hdr;
    7066                 :            :         int status;
    7067                 :            : 
    7068                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    7069                 :          0 :         if (!status)
    7070                 :          0 :                 status = decode_exchange_id(xdr, res);
    7071                 :          0 :         return status;
    7072                 :            : }
    7073                 :            : 
    7074                 :            : /*
    7075                 :            :  * Decode CREATE_SESSION response
    7076                 :            :  */
    7077                 :          0 : static int nfs4_xdr_dec_create_session(struct rpc_rqst *rqstp,
    7078                 :            :                                        struct xdr_stream *xdr,
    7079                 :            :                                        void *res)
    7080                 :            : {
    7081                 :            :         struct compound_hdr hdr;
    7082                 :            :         int status;
    7083                 :            : 
    7084                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    7085                 :          0 :         if (!status)
    7086                 :          0 :                 status = decode_create_session(xdr, res);
    7087                 :          0 :         return status;
    7088                 :            : }
    7089                 :            : 
    7090                 :            : /*
    7091                 :            :  * Decode DESTROY_SESSION response
    7092                 :            :  */
    7093                 :          0 : static int nfs4_xdr_dec_destroy_session(struct rpc_rqst *rqstp,
    7094                 :            :                                         struct xdr_stream *xdr,
    7095                 :            :                                         void *res)
    7096                 :            : {
    7097                 :            :         struct compound_hdr hdr;
    7098                 :            :         int status;
    7099                 :            : 
    7100                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    7101                 :          0 :         if (!status)
    7102                 :            :                 status = decode_destroy_session(xdr, res);
    7103                 :          0 :         return status;
    7104                 :            : }
    7105                 :            : 
    7106                 :            : /*
    7107                 :            :  * Decode DESTROY_CLIENTID response
    7108                 :            :  */
    7109                 :          0 : static int nfs4_xdr_dec_destroy_clientid(struct rpc_rqst *rqstp,
    7110                 :            :                                         struct xdr_stream *xdr,
    7111                 :            :                                         void *res)
    7112                 :            : {
    7113                 :            :         struct compound_hdr hdr;
    7114                 :            :         int status;
    7115                 :            : 
    7116                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    7117                 :          0 :         if (!status)
    7118                 :            :                 status = decode_destroy_clientid(xdr, res);
    7119                 :          0 :         return status;
    7120                 :            : }
    7121                 :            : 
    7122                 :            : /*
    7123                 :            :  * Decode SEQUENCE response
    7124                 :            :  */
    7125                 :          0 : static int nfs4_xdr_dec_sequence(struct rpc_rqst *rqstp,
    7126                 :            :                                  struct xdr_stream *xdr,
    7127                 :            :                                  void *res)
    7128                 :            : {
    7129                 :            :         struct compound_hdr hdr;
    7130                 :            :         int status;
    7131                 :            : 
    7132                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    7133                 :          0 :         if (!status)
    7134                 :          0 :                 status = decode_sequence(xdr, res, rqstp);
    7135                 :          0 :         return status;
    7136                 :            : }
    7137                 :            : 
    7138                 :            : #endif
    7139                 :            : 
    7140                 :            : /*
    7141                 :            :  * Decode GET_LEASE_TIME response
    7142                 :            :  */
    7143                 :          0 : static int nfs4_xdr_dec_get_lease_time(struct rpc_rqst *rqstp,
    7144                 :            :                                        struct xdr_stream *xdr,
    7145                 :            :                                        void *data)
    7146                 :            : {
    7147                 :            :         struct nfs4_get_lease_time_res *res = data;
    7148                 :            :         struct compound_hdr hdr;
    7149                 :            :         int status;
    7150                 :            : 
    7151                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    7152                 :          0 :         if (!status)
    7153                 :          0 :                 status = decode_sequence(xdr, &res->lr_seq_res, rqstp);
    7154                 :          0 :         if (!status)
    7155                 :            :                 status = decode_putrootfh(xdr);
    7156                 :          0 :         if (!status)
    7157                 :          0 :                 status = decode_fsinfo(xdr, res->lr_fsinfo);
    7158                 :          0 :         return status;
    7159                 :            : }
    7160                 :            : 
    7161                 :            : #ifdef CONFIG_NFS_V4_1
    7162                 :            : 
    7163                 :            : /*
    7164                 :            :  * Decode RECLAIM_COMPLETE response
    7165                 :            :  */
    7166                 :          0 : static int nfs4_xdr_dec_reclaim_complete(struct rpc_rqst *rqstp,
    7167                 :            :                                          struct xdr_stream *xdr,
    7168                 :            :                                          void *data)
    7169                 :            : {
    7170                 :            :         struct nfs41_reclaim_complete_res *res = data;
    7171                 :            :         struct compound_hdr hdr;
    7172                 :            :         int status;
    7173                 :            : 
    7174                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    7175                 :          0 :         if (!status)
    7176                 :          0 :                 status = decode_sequence(xdr, &res->seq_res, rqstp);
    7177                 :          0 :         if (!status)
    7178                 :            :                 status = decode_reclaim_complete(xdr, NULL);
    7179                 :          0 :         return status;
    7180                 :            : }
    7181                 :            : 
    7182                 :            : /*
    7183                 :            :  * Decode GETDEVINFO response
    7184                 :            :  */
    7185                 :          0 : static int nfs4_xdr_dec_getdeviceinfo(struct rpc_rqst *rqstp,
    7186                 :            :                                       struct xdr_stream *xdr,
    7187                 :            :                                       void *data)
    7188                 :            : {
    7189                 :            :         struct nfs4_getdeviceinfo_res *res = data;
    7190                 :            :         struct compound_hdr hdr;
    7191                 :            :         int status;
    7192                 :            : 
    7193                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    7194                 :          0 :         if (status != 0)
    7195                 :            :                 goto out;
    7196                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    7197                 :          0 :         if (status != 0)
    7198                 :            :                 goto out;
    7199                 :          0 :         status = decode_getdeviceinfo(xdr, res);
    7200                 :            : out:
    7201                 :          0 :         return status;
    7202                 :            : }
    7203                 :            : 
    7204                 :            : /*
    7205                 :            :  * Decode LAYOUTGET response
    7206                 :            :  */
    7207                 :          0 : static int nfs4_xdr_dec_layoutget(struct rpc_rqst *rqstp,
    7208                 :            :                                   struct xdr_stream *xdr,
    7209                 :            :                                   void *data)
    7210                 :            : {
    7211                 :            :         struct nfs4_layoutget_res *res = data;
    7212                 :            :         struct compound_hdr hdr;
    7213                 :            :         int status;
    7214                 :            : 
    7215                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    7216                 :          0 :         if (status)
    7217                 :            :                 goto out;
    7218                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    7219                 :          0 :         if (status)
    7220                 :            :                 goto out;
    7221                 :            :         status = decode_putfh(xdr);
    7222                 :          0 :         if (status)
    7223                 :            :                 goto out;
    7224                 :          0 :         status = decode_layoutget(xdr, rqstp, res);
    7225                 :            : out:
    7226                 :          0 :         return status;
    7227                 :            : }
    7228                 :            : 
    7229                 :            : /*
    7230                 :            :  * Decode LAYOUTRETURN response
    7231                 :            :  */
    7232                 :          0 : static int nfs4_xdr_dec_layoutreturn(struct rpc_rqst *rqstp,
    7233                 :            :                                      struct xdr_stream *xdr,
    7234                 :            :                                      void *data)
    7235                 :            : {
    7236                 :            :         struct nfs4_layoutreturn_res *res = data;
    7237                 :            :         struct compound_hdr hdr;
    7238                 :            :         int status;
    7239                 :            : 
    7240                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    7241                 :          0 :         if (status)
    7242                 :            :                 goto out;
    7243                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    7244                 :          0 :         if (status)
    7245                 :            :                 goto out;
    7246                 :            :         status = decode_putfh(xdr);
    7247                 :          0 :         if (status)
    7248                 :            :                 goto out;
    7249                 :          0 :         status = decode_layoutreturn(xdr, res);
    7250                 :            : out:
    7251                 :          0 :         return status;
    7252                 :            : }
    7253                 :            : 
    7254                 :            : /*
    7255                 :            :  * Decode LAYOUTCOMMIT response
    7256                 :            :  */
    7257                 :          0 : static int nfs4_xdr_dec_layoutcommit(struct rpc_rqst *rqstp,
    7258                 :            :                                      struct xdr_stream *xdr,
    7259                 :            :                                      void *data)
    7260                 :            : {
    7261                 :            :         struct nfs4_layoutcommit_res *res = data;
    7262                 :            :         struct compound_hdr hdr;
    7263                 :            :         int status;
    7264                 :            : 
    7265                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    7266                 :          0 :         if (status)
    7267                 :            :                 goto out;
    7268                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    7269                 :          0 :         if (status)
    7270                 :            :                 goto out;
    7271                 :            :         status = decode_putfh(xdr);
    7272                 :          0 :         if (status)
    7273                 :            :                 goto out;
    7274                 :          0 :         status = decode_layoutcommit(xdr, rqstp, res);
    7275                 :          0 :         if (status)
    7276                 :            :                 goto out;
    7277                 :          0 :         decode_getfattr(xdr, res->fattr, res->server);
    7278                 :            : out:
    7279                 :          0 :         return status;
    7280                 :            : }
    7281                 :            : 
    7282                 :            : /*
    7283                 :            :  * Decode SECINFO_NO_NAME response
    7284                 :            :  */
    7285                 :          0 : static int nfs4_xdr_dec_secinfo_no_name(struct rpc_rqst *rqstp,
    7286                 :            :                                         struct xdr_stream *xdr,
    7287                 :            :                                         void *data)
    7288                 :            : {
    7289                 :            :         struct nfs4_secinfo_res *res = data;
    7290                 :            :         struct compound_hdr hdr;
    7291                 :            :         int status;
    7292                 :            : 
    7293                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    7294                 :          0 :         if (status)
    7295                 :            :                 goto out;
    7296                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    7297                 :          0 :         if (status)
    7298                 :            :                 goto out;
    7299                 :            :         status = decode_putrootfh(xdr);
    7300                 :          0 :         if (status)
    7301                 :            :                 goto out;
    7302                 :          0 :         status = decode_secinfo_no_name(xdr, res);
    7303                 :            : out:
    7304                 :          0 :         return status;
    7305                 :            : }
    7306                 :            : 
    7307                 :            : /*
    7308                 :            :  * Decode TEST_STATEID response
    7309                 :            :  */
    7310                 :          0 : static int nfs4_xdr_dec_test_stateid(struct rpc_rqst *rqstp,
    7311                 :            :                                      struct xdr_stream *xdr,
    7312                 :            :                                      void *data)
    7313                 :            : {
    7314                 :            :         struct nfs41_test_stateid_res *res = data;
    7315                 :            :         struct compound_hdr hdr;
    7316                 :            :         int status;
    7317                 :            : 
    7318                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    7319                 :          0 :         if (status)
    7320                 :            :                 goto out;
    7321                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    7322                 :          0 :         if (status)
    7323                 :            :                 goto out;
    7324                 :          0 :         status = decode_test_stateid(xdr, res);
    7325                 :            : out:
    7326                 :          0 :         return status;
    7327                 :            : }
    7328                 :            : 
    7329                 :            : /*
    7330                 :            :  * Decode FREE_STATEID response
    7331                 :            :  */
    7332                 :          0 : static int nfs4_xdr_dec_free_stateid(struct rpc_rqst *rqstp,
    7333                 :            :                                      struct xdr_stream *xdr,
    7334                 :            :                                      void *data)
    7335                 :            : {
    7336                 :            :         struct nfs41_free_stateid_res *res = data;
    7337                 :            :         struct compound_hdr hdr;
    7338                 :            :         int status;
    7339                 :            : 
    7340                 :          0 :         status = decode_compound_hdr(xdr, &hdr);
    7341                 :          0 :         if (status)
    7342                 :            :                 goto out;
    7343                 :          0 :         status = decode_sequence(xdr, &res->seq_res, rqstp);
    7344                 :          0 :         if (status)
    7345                 :            :                 goto out;
    7346                 :            :         status = decode_free_stateid(xdr, res);
    7347                 :            : out:
    7348                 :          0 :         return status;
    7349                 :            : }
    7350                 :            : #endif /* CONFIG_NFS_V4_1 */
    7351                 :            : 
    7352                 :            : /**
    7353                 :            :  * nfs4_decode_dirent - Decode a single NFSv4 directory entry stored in
    7354                 :            :  *                      the local page cache.
    7355                 :            :  * @xdr: XDR stream where entry resides
    7356                 :            :  * @entry: buffer to fill in with entry data
    7357                 :            :  * @plus: boolean indicating whether this should be a readdirplus entry
    7358                 :            :  *
    7359                 :            :  * Returns zero if successful, otherwise a negative errno value is
    7360                 :            :  * returned.
    7361                 :            :  *
    7362                 :            :  * This function is not invoked during READDIR reply decoding, but
    7363                 :            :  * rather whenever an application invokes the getdents(2) system call
    7364                 :            :  * on a directory already in our cache.
    7365                 :            :  */
    7366                 :          0 : int nfs4_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry,
    7367                 :            :                        bool plus)
    7368                 :            : {
    7369                 :            :         unsigned int savep;
    7370                 :          0 :         uint32_t bitmap[3] = {0};
    7371                 :            :         uint32_t len;
    7372                 :            :         uint64_t new_cookie;
    7373                 :          0 :         __be32 *p = xdr_inline_decode(xdr, 4);
    7374                 :          0 :         if (unlikely(!p))
    7375                 :            :                 return -EAGAIN;
    7376                 :          0 :         if (*p == xdr_zero) {
    7377                 :          0 :                 p = xdr_inline_decode(xdr, 4);
    7378                 :          0 :                 if (unlikely(!p))
    7379                 :            :                         return -EAGAIN;
    7380                 :          0 :                 if (*p == xdr_zero)
    7381                 :            :                         return -EAGAIN;
    7382                 :          0 :                 entry->eof = 1;
    7383                 :          0 :                 return -EBADCOOKIE;
    7384                 :            :         }
    7385                 :            : 
    7386                 :          0 :         p = xdr_inline_decode(xdr, 12);
    7387                 :          0 :         if (unlikely(!p))
    7388                 :            :                 return -EAGAIN;
    7389                 :            :         p = xdr_decode_hyper(p, &new_cookie);
    7390                 :          0 :         entry->len = be32_to_cpup(p);
    7391                 :            : 
    7392                 :          0 :         p = xdr_inline_decode(xdr, entry->len);
    7393                 :          0 :         if (unlikely(!p))
    7394                 :            :                 return -EAGAIN;
    7395                 :          0 :         entry->name = (const char *) p;
    7396                 :            : 
    7397                 :            :         /*
    7398                 :            :          * In case the server doesn't return an inode number,
    7399                 :            :          * we fake one here.  (We don't use inode number 0,
    7400                 :            :          * since glibc seems to choke on it...)
    7401                 :            :          */
    7402                 :          0 :         entry->ino = 1;
    7403                 :          0 :         entry->fattr->valid = 0;
    7404                 :            : 
    7405                 :          0 :         if (decode_attr_bitmap(xdr, bitmap) < 0)
    7406                 :            :                 return -EAGAIN;
    7407                 :            : 
    7408                 :          0 :         if (decode_attr_length(xdr, &len, &savep) < 0)
    7409                 :            :                 return -EAGAIN;
    7410                 :            : 
    7411                 :          0 :         if (decode_getfattr_attrs(xdr, bitmap, entry->fattr, entry->fh,
    7412                 :          0 :                         NULL, entry->label, entry->server) < 0)
    7413                 :            :                 return -EAGAIN;
    7414                 :          0 :         if (entry->fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID)
    7415                 :          0 :                 entry->ino = entry->fattr->mounted_on_fileid;
    7416                 :          0 :         else if (entry->fattr->valid & NFS_ATTR_FATTR_FILEID)
    7417                 :          0 :                 entry->ino = entry->fattr->fileid;
    7418                 :            : 
    7419                 :          0 :         entry->d_type = DT_UNKNOWN;
    7420                 :          0 :         if (entry->fattr->valid & NFS_ATTR_FATTR_TYPE)
    7421                 :          0 :                 entry->d_type = nfs_umode_to_dtype(entry->fattr->mode);
    7422                 :            : 
    7423                 :          0 :         entry->prev_cookie = entry->cookie;
    7424                 :          0 :         entry->cookie = new_cookie;
    7425                 :            : 
    7426                 :          0 :         return 0;
    7427                 :            : }
    7428                 :            : 
    7429                 :            : /*
    7430                 :            :  * We need to translate between nfs status return values and
    7431                 :            :  * the local errno values which may not be the same.
    7432                 :            :  */
    7433                 :            : static struct {
    7434                 :            :         int stat;
    7435                 :            :         int errno;
    7436                 :            : } nfs_errtbl[] = {
    7437                 :            :         { NFS4_OK,              0               },
    7438                 :            :         { NFS4ERR_PERM,         -EPERM          },
    7439                 :            :         { NFS4ERR_NOENT,        -ENOENT         },
    7440                 :            :         { NFS4ERR_IO,           -errno_NFSERR_IO},
    7441                 :            :         { NFS4ERR_NXIO,         -ENXIO          },
    7442                 :            :         { NFS4ERR_ACCESS,       -EACCES         },
    7443                 :            :         { NFS4ERR_EXIST,        -EEXIST         },
    7444                 :            :         { NFS4ERR_XDEV,         -EXDEV          },
    7445                 :            :         { NFS4ERR_NOTDIR,       -ENOTDIR        },
    7446                 :            :         { NFS4ERR_ISDIR,        -EISDIR         },
    7447                 :            :         { NFS4ERR_INVAL,        -EINVAL         },
    7448                 :            :         { NFS4ERR_FBIG,         -EFBIG          },
    7449                 :            :         { NFS4ERR_NOSPC,        -ENOSPC         },
    7450                 :            :         { NFS4ERR_ROFS,         -EROFS          },
    7451                 :            :         { NFS4ERR_MLINK,        -EMLINK         },
    7452                 :            :         { NFS4ERR_NAMETOOLONG,  -ENAMETOOLONG   },
    7453                 :            :         { NFS4ERR_NOTEMPTY,     -ENOTEMPTY      },
    7454                 :            :         { NFS4ERR_DQUOT,        -EDQUOT         },
    7455                 :            :         { NFS4ERR_STALE,        -ESTALE         },
    7456                 :            :         { NFS4ERR_BADHANDLE,    -EBADHANDLE     },
    7457                 :            :         { NFS4ERR_BAD_COOKIE,   -EBADCOOKIE     },
    7458                 :            :         { NFS4ERR_NOTSUPP,      -ENOTSUPP       },
    7459                 :            :         { NFS4ERR_TOOSMALL,     -ETOOSMALL      },
    7460                 :            :         { NFS4ERR_SERVERFAULT,  -EREMOTEIO      },
    7461                 :            :         { NFS4ERR_BADTYPE,      -EBADTYPE       },
    7462                 :            :         { NFS4ERR_LOCKED,       -EAGAIN         },
    7463                 :            :         { NFS4ERR_SYMLINK,      -ELOOP          },
    7464                 :            :         { NFS4ERR_OP_ILLEGAL,   -EOPNOTSUPP     },
    7465                 :            :         { NFS4ERR_DEADLOCK,     -EDEADLK        },
    7466                 :            :         { -1,                   -EIO            }
    7467                 :            : };
    7468                 :            : 
    7469                 :            : /*
    7470                 :            :  * Convert an NFS error code to a local one.
    7471                 :            :  * This one is used jointly by NFSv2 and NFSv3.
    7472                 :            :  */
    7473                 :            : static int
    7474                 :            : nfs4_stat_to_errno(int stat)
    7475                 :            : {
    7476                 :            :         int i;
    7477                 :          0 :         for (i = 0; nfs_errtbl[i].stat != -1; i++) {
    7478                 :          0 :                 if (nfs_errtbl[i].stat == stat)
    7479                 :          0 :                         return nfs_errtbl[i].errno;
    7480                 :            :         }
    7481                 :          0 :         if (stat <= 10000 || stat > 10100) {
    7482                 :            :                 /* The server is looney tunes. */
    7483                 :            :                 return -EREMOTEIO;
    7484                 :            :         }
    7485                 :            :         /* If we cannot translate the error, the recovery routines should
    7486                 :            :          * handle it.
    7487                 :            :          * Note: remaining NFSv4 error codes have values > 10000, so should
    7488                 :            :          * not conflict with native Linux error codes.
    7489                 :            :          */
    7490                 :          0 :         return -stat;
    7491                 :            : }
    7492                 :            : 
    7493                 :            : #ifdef CONFIG_NFS_V4_2
    7494                 :            : #include "nfs42xdr.c"
    7495                 :            : #endif /* CONFIG_NFS_V4_2 */
    7496                 :            : 
    7497                 :            : #define PROC(proc, argtype, restype)                            \
    7498                 :            : [NFSPROC4_CLNT_##proc] = {                                      \
    7499                 :            :         .p_proc   = NFSPROC4_COMPOUND,                          \
    7500                 :            :         .p_encode = nfs4_xdr_##argtype,                         \
    7501                 :            :         .p_decode = nfs4_xdr_##restype,                         \
    7502                 :            :         .p_arglen = NFS4_##argtype##_sz,                        \
    7503                 :            :         .p_replen = NFS4_##restype##_sz,                        \
    7504                 :            :         .p_statidx = NFSPROC4_CLNT_##proc,                      \
    7505                 :            :         .p_name   = #proc,                                      \
    7506                 :            : }
    7507                 :            : 
    7508                 :            : #define STUB(proc)              \
    7509                 :            : [NFSPROC4_CLNT_##proc] = {      \
    7510                 :            :         .p_name = #proc,        \
    7511                 :            : }
    7512                 :            : 
    7513                 :            : #if defined(CONFIG_NFS_V4_1)
    7514                 :            : #define PROC41(proc, argtype, restype)                          \
    7515                 :            :         PROC(proc, argtype, restype)
    7516                 :            : #else
    7517                 :            : #define PROC41(proc, argtype, restype)                          \
    7518                 :            :         STUB(proc)
    7519                 :            : #endif
    7520                 :            : 
    7521                 :            : #if defined(CONFIG_NFS_V4_2)
    7522                 :            : #define PROC42(proc, argtype, restype)                          \
    7523                 :            :         PROC(proc, argtype, restype)
    7524                 :            : #else
    7525                 :            : #define PROC42(proc, argtype, restype)                          \
    7526                 :            :         STUB(proc)
    7527                 :            : #endif
    7528                 :            : 
    7529                 :            : const struct rpc_procinfo nfs4_procedures[] = {
    7530                 :            :         PROC(READ,              enc_read,               dec_read),
    7531                 :            :         PROC(WRITE,             enc_write,              dec_write),
    7532                 :            :         PROC(COMMIT,            enc_commit,             dec_commit),
    7533                 :            :         PROC(OPEN,              enc_open,               dec_open),
    7534                 :            :         PROC(OPEN_CONFIRM,      enc_open_confirm,       dec_open_confirm),
    7535                 :            :         PROC(OPEN_NOATTR,       enc_open_noattr,        dec_open_noattr),
    7536                 :            :         PROC(OPEN_DOWNGRADE,    enc_open_downgrade,     dec_open_downgrade),
    7537                 :            :         PROC(CLOSE,             enc_close,              dec_close),
    7538                 :            :         PROC(SETATTR,           enc_setattr,            dec_setattr),
    7539                 :            :         PROC(FSINFO,            enc_fsinfo,             dec_fsinfo),
    7540                 :            :         PROC(RENEW,             enc_renew,              dec_renew),
    7541                 :            :         PROC(SETCLIENTID,       enc_setclientid,        dec_setclientid),
    7542                 :            :         PROC(SETCLIENTID_CONFIRM, enc_setclientid_confirm, dec_setclientid_confirm),
    7543                 :            :         PROC(LOCK,              enc_lock,               dec_lock),
    7544                 :            :         PROC(LOCKT,             enc_lockt,              dec_lockt),
    7545                 :            :         PROC(LOCKU,             enc_locku,              dec_locku),
    7546                 :            :         PROC(ACCESS,            enc_access,             dec_access),
    7547                 :            :         PROC(GETATTR,           enc_getattr,            dec_getattr),
    7548                 :            :         PROC(LOOKUP,            enc_lookup,             dec_lookup),
    7549                 :            :         PROC(LOOKUP_ROOT,       enc_lookup_root,        dec_lookup_root),
    7550                 :            :         PROC(REMOVE,            enc_remove,             dec_remove),
    7551                 :            :         PROC(RENAME,            enc_rename,             dec_rename),
    7552                 :            :         PROC(LINK,              enc_link,               dec_link),
    7553                 :            :         PROC(SYMLINK,           enc_symlink,            dec_symlink),
    7554                 :            :         PROC(CREATE,            enc_create,             dec_create),
    7555                 :            :         PROC(PATHCONF,          enc_pathconf,           dec_pathconf),
    7556                 :            :         PROC(STATFS,            enc_statfs,             dec_statfs),
    7557                 :            :         PROC(READLINK,          enc_readlink,           dec_readlink),
    7558                 :            :         PROC(READDIR,           enc_readdir,            dec_readdir),
    7559                 :            :         PROC(SERVER_CAPS,       enc_server_caps,        dec_server_caps),
    7560                 :            :         PROC(DELEGRETURN,       enc_delegreturn,        dec_delegreturn),
    7561                 :            :         PROC(GETACL,            enc_getacl,             dec_getacl),
    7562                 :            :         PROC(SETACL,            enc_setacl,             dec_setacl),
    7563                 :            :         PROC(FS_LOCATIONS,      enc_fs_locations,       dec_fs_locations),
    7564                 :            :         PROC(RELEASE_LOCKOWNER, enc_release_lockowner,  dec_release_lockowner),
    7565                 :            :         PROC(SECINFO,           enc_secinfo,            dec_secinfo),
    7566                 :            :         PROC(FSID_PRESENT,      enc_fsid_present,       dec_fsid_present),
    7567                 :            :         PROC41(EXCHANGE_ID,     enc_exchange_id,        dec_exchange_id),
    7568                 :            :         PROC41(CREATE_SESSION,  enc_create_session,     dec_create_session),
    7569                 :            :         PROC41(DESTROY_SESSION, enc_destroy_session,    dec_destroy_session),
    7570                 :            :         PROC41(SEQUENCE,        enc_sequence,           dec_sequence),
    7571                 :            :         PROC(GET_LEASE_TIME,    enc_get_lease_time,     dec_get_lease_time),
    7572                 :            :         PROC41(RECLAIM_COMPLETE,enc_reclaim_complete,   dec_reclaim_complete),
    7573                 :            :         PROC41(GETDEVICEINFO,   enc_getdeviceinfo,      dec_getdeviceinfo),
    7574                 :            :         PROC41(LAYOUTGET,       enc_layoutget,          dec_layoutget),
    7575                 :            :         PROC41(LAYOUTCOMMIT,    enc_layoutcommit,       dec_layoutcommit),
    7576                 :            :         PROC41(LAYOUTRETURN,    enc_layoutreturn,       dec_layoutreturn),
    7577                 :            :         PROC41(SECINFO_NO_NAME, enc_secinfo_no_name,    dec_secinfo_no_name),
    7578                 :            :         PROC41(TEST_STATEID,    enc_test_stateid,       dec_test_stateid),
    7579                 :            :         PROC41(FREE_STATEID,    enc_free_stateid,       dec_free_stateid),
    7580                 :            :         STUB(GETDEVICELIST),
    7581                 :            :         PROC41(BIND_CONN_TO_SESSION,
    7582                 :            :                         enc_bind_conn_to_session, dec_bind_conn_to_session),
    7583                 :            :         PROC41(DESTROY_CLIENTID,enc_destroy_clientid,   dec_destroy_clientid),
    7584                 :            :         PROC42(SEEK,            enc_seek,               dec_seek),
    7585                 :            :         PROC42(ALLOCATE,        enc_allocate,           dec_allocate),
    7586                 :            :         PROC42(DEALLOCATE,      enc_deallocate,         dec_deallocate),
    7587                 :            :         PROC42(LAYOUTSTATS,     enc_layoutstats,        dec_layoutstats),
    7588                 :            :         PROC42(CLONE,           enc_clone,              dec_clone),
    7589                 :            :         PROC42(COPY,            enc_copy,               dec_copy),
    7590                 :            :         PROC42(OFFLOAD_CANCEL,  enc_offload_cancel,     dec_offload_cancel),
    7591                 :            :         PROC(LOOKUPP,           enc_lookupp,            dec_lookupp),
    7592                 :            :         PROC42(LAYOUTERROR,     enc_layouterror,        dec_layouterror),
    7593                 :            : };
    7594                 :            : 
    7595                 :            : static unsigned int nfs_version4_counts[ARRAY_SIZE(nfs4_procedures)];
    7596                 :            : const struct rpc_version nfs_version4 = {
    7597                 :            :         .number                 = 4,
    7598                 :            :         .nrprocs                = ARRAY_SIZE(nfs4_procedures),
    7599                 :            :         .procs                  = nfs4_procedures,
    7600                 :            :         .counts                 = nfs_version4_counts,
    7601                 :            : };
    7602                 :            : 
    7603                 :            : /*
    7604                 :            :  * Local variables:
    7605                 :            :  *  c-basic-offset: 8
    7606                 :            :  * End:
    7607                 :            :  */
    

Generated by: LCOV version 1.14