SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/nfs/nfs4xdr.c

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