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

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