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