fs/nfs/nfs3xdr.c

   1 /*
   2  * linux/fs/nfs/nfs3xdr.c
   3  *
   4  * XDR functions to encode/decode NFSv3 RPC arguments and results.
   5  *
   6  * Copyright (C) 1996, 1997 Olaf Kirch
   7  */
   8
   9 #include <linux/param.h>
  10 #include <linux/time.h>
  11 #include <linux/mm.h>
  12 #include <linux/errno.h>
  13 #include <linux/string.h>
  14 #include <linux/in.h>
  15 #include <linux/pagemap.h>
  16 #include <linux/proc_fs.h>
  17 #include <linux/kdev_t.h>
  18 #include <linux/sunrpc/clnt.h>
  19 #include <linux/nfs.h>
  20 #include <linux/nfs3.h>
  21 #include <linux/nfs_fs.h>
  22 #include <linux/nfsacl.h>
  23 #include "internal.h"
  24
  25 #define NFSDBG_FACILITY         NFSDBG_XDR
  26
  27 /* Mapping from NFS error code to "errno" error code. */
  28 #define errno_NFSERR_IO         EIO
  29
  30 /*
  31  * Declare the space requirements for NFS arguments and replies as
  32  * number of 32bit-words
  33  */
  34 #define NFS3_fhandle_sz         (1+16)
  35 #define NFS3_fh_sz              (NFS3_fhandle_sz)       /* shorthand */
  36 #define NFS3_sattr_sz           (15)
  37 #define NFS3_filename_sz        (1+(NFS3_MAXNAMLEN>>2))
  38 #define NFS3_path_sz            (1+(NFS3_MAXPATHLEN>>2))
  39 #define NFS3_fattr_sz           (21)
  40 #define NFS3_cookieverf_sz      (NFS3_COOKIEVERFSIZE>>2)
  41 #define NFS3_wcc_attr_sz        (6)
  42 #define NFS3_pre_op_attr_sz     (1+NFS3_wcc_attr_sz)
  43 #define NFS3_post_op_attr_sz    (1+NFS3_fattr_sz)
  44 #define NFS3_wcc_data_sz        (NFS3_pre_op_attr_sz+NFS3_post_op_attr_sz)
  45 #define NFS3_diropargs_sz       (NFS3_fh_sz+NFS3_filename_sz)
  46
  47 #define NFS3_getattrargs_sz     (NFS3_fh_sz)
  48 #define NFS3_setattrargs_sz     (NFS3_fh_sz+NFS3_sattr_sz+3)
  49 #define NFS3_lookupargs_sz      (NFS3_fh_sz+NFS3_filename_sz)
  50 #define NFS3_accessargs_sz      (NFS3_fh_sz+1)
  51 #define NFS3_readlinkargs_sz    (NFS3_fh_sz)
  52 #define NFS3_readargs_sz        (NFS3_fh_sz+3)
  53 #define NFS3_writeargs_sz       (NFS3_fh_sz+5)
  54 #define NFS3_createargs_sz      (NFS3_diropargs_sz+NFS3_sattr_sz)
  55 #define NFS3_mkdirargs_sz       (NFS3_diropargs_sz+NFS3_sattr_sz)
  56 #define NFS3_symlinkargs_sz     (NFS3_diropargs_sz+1+NFS3_sattr_sz)
  57 #define NFS3_mknodargs_sz       (NFS3_diropargs_sz+2+NFS3_sattr_sz)
  58 #define NFS3_removeargs_sz      (NFS3_fh_sz+NFS3_filename_sz)
  59 #define NFS3_renameargs_sz      (NFS3_diropargs_sz+NFS3_diropargs_sz)
  60 #define NFS3_linkargs_sz                (NFS3_fh_sz+NFS3_diropargs_sz)
  61 #define NFS3_readdirargs_sz     (NFS3_fh_sz+NFS3_cookieverf_sz+3)
  62 #define NFS3_readdirplusargs_sz (NFS3_fh_sz+NFS3_cookieverf_sz+4)
  63 #define NFS3_commitargs_sz      (NFS3_fh_sz+3)
  64
  65 #define NFS3_getattrres_sz      (1+NFS3_fattr_sz)
  66 #define NFS3_setattrres_sz      (1+NFS3_wcc_data_sz)
  67 #define NFS3_removeres_sz       (NFS3_setattrres_sz)
  68 #define NFS3_lookupres_sz       (1+NFS3_fh_sz+(2 * NFS3_post_op_attr_sz))
  69 #define NFS3_accessres_sz       (1+NFS3_post_op_attr_sz+1)
  70 #define NFS3_readlinkres_sz     (1+NFS3_post_op_attr_sz+1)
  71 #define NFS3_readres_sz         (1+NFS3_post_op_attr_sz+3)
  72 #define NFS3_writeres_sz        (1+NFS3_wcc_data_sz+4)
  73 #define NFS3_createres_sz       (1+NFS3_fh_sz+NFS3_post_op_attr_sz+NFS3_wcc_data_sz)
  74 #define NFS3_renameres_sz       (1+(2 * NFS3_wcc_data_sz))
  75 #define NFS3_linkres_sz         (1+NFS3_post_op_attr_sz+NFS3_wcc_data_sz)
  76 #define NFS3_readdirres_sz      (1+NFS3_post_op_attr_sz+2)
  77 #define NFS3_fsstatres_sz       (1+NFS3_post_op_attr_sz+13)
  78 #define NFS3_fsinfores_sz       (1+NFS3_post_op_attr_sz+12)
  79 #define NFS3_pathconfres_sz     (1+NFS3_post_op_attr_sz+6)
  80 #define NFS3_commitres_sz       (1+NFS3_wcc_data_sz+2)
  81
  82 #define ACL3_getaclargs_sz      (NFS3_fh_sz+1)
  83 #define ACL3_setaclargs_sz      (NFS3_fh_sz+1+ \
  84                                 XDR_QUADLEN(NFS_ACL_INLINE_BUFSIZE))
  85 #define ACL3_getaclres_sz       (1+NFS3_post_op_attr_sz+1+ \
  86                                 XDR_QUADLEN(NFS_ACL_INLINE_BUFSIZE))
  87 #define ACL3_setaclres_sz       (1+NFS3_post_op_attr_sz)
  88
  89 /*
  90  * Map file type to S_IFMT bits
  91  */
  92 static const umode_t nfs_type2fmt[] = {
  93         [NF3BAD] = 0,
  94         [NF3REG] = S_IFREG,
  95         [NF3DIR] = S_IFDIR,
  96         [NF3BLK] = S_IFBLK,
  97         [NF3CHR] = S_IFCHR,
  98         [NF3LNK] = S_IFLNK,
  99         [NF3SOCK] = S_IFSOCK,
 100         [NF3FIFO] = S_IFIFO,
 101 };
 102
 103 /*
 104  * While encoding arguments, set up the reply buffer in advance to
 105  * receive reply data directly into the page cache.
 106  */
 107 static void prepare_reply_buffer(struct rpc_rqst *req, struct page **pages,
 108                                  unsigned int base, unsigned int len,
 109                                  unsigned int bufsize)
 110 {
 111         struct rpc_auth *auth = req->rq_cred->cr_auth;
 112         unsigned int replen;
 113
 114         replen = RPC_REPHDRSIZE + auth->au_rslack + bufsize;
 115         xdr_inline_pages(&req->rq_rcv_buf, replen << 2, pages, base, len);
 116 }
 117
 118 /*
 119  * Handle decode buffer overflows out-of-line.
 120  */
 121 static void print_overflow_msg(const char *func, const struct xdr_stream *xdr)
 122 {
 123         dprintk("NFS: %s prematurely hit the end of our receive buffer. "
 124                 "Remaining buffer length is %tu words.\n",
 125                 func, xdr->end - xdr->p);
 126 }
 127
 128
 129 /*
 130  * Encode/decode NFSv3 basic data types
 131  *
 132  * Basic NFSv3 data types are defined in section 2.5 of RFC 1813:
 133  * "NFS Version 3 Protocol Specification".
 134  *
 135  * Not all basic data types have their own encoding and decoding
 136  * functions.  For run-time efficiency, some data types are encoded
 137  * or decoded inline.
 138  */
 139
 140 static void encode_uint32(struct xdr_stream *xdr, u32 value)
 141 {
 142         __be32 *p = xdr_reserve_space(xdr, 4);
 143         *p = cpu_to_be32(value);
 144 }
 145
 146 static int decode_uint32(struct xdr_stream *xdr, u32 *value)
 147 {
 148         __be32 *p;
 149
 150         p = xdr_inline_decode(xdr, 4);
 151         if (unlikely(p == NULL))
 152                 goto out_overflow;
 153         *value = be32_to_cpup(p);
 154         return 0;
 155 out_overflow:
 156         print_overflow_msg(__func__, xdr);
 157         return -EIO;
 158 }
 159
 160 static int decode_uint64(struct xdr_stream *xdr, u64 *value)
 161 {
 162         __be32 *p;
 163
 164         p = xdr_inline_decode(xdr, 8);
 165         if (unlikely(p == NULL))
 166                 goto out_overflow;
 167         xdr_decode_hyper(p, value);
 168         return 0;
 169 out_overflow:
 170         print_overflow_msg(__func__, xdr);
 171         return -EIO;
 172 }
 173
 174 /*
 175  * fileid3
 176  *
 177  *      typedef uint64 fileid3;
 178  */
 179 static __be32 *xdr_decode_fileid3(__be32 *p, u64 *fileid)
 180 {
 181         return xdr_decode_hyper(p, fileid);
 182 }
 183
 184 static int decode_fileid3(struct xdr_stream *xdr, u64 *fileid)
 185 {
 186         return decode_uint64(xdr, fileid);
 187 }
 188
 189 /*
 190  * filename3
 191  *
 192  *      typedef string filename3<>;
 193  */
 194 static void encode_filename3(struct xdr_stream *xdr,
 195                              const char *name, u32 length)
 196 {
 197         __be32 *p;
 198
 199         BUG_ON(length > NFS3_MAXNAMLEN);
 200         p = xdr_reserve_space(xdr, 4 + length);
 201         xdr_encode_opaque(p, name, length);
 202 }
 203
 204 static int decode_inline_filename3(struct xdr_stream *xdr,
 205                                    const char **name, u32 *length)
 206 {
 207         __be32 *p;
 208         u32 count;
 209
 210         p = xdr_inline_decode(xdr, 4);
 211         if (unlikely(p == NULL))
 212                 goto out_overflow;
 213         count = be32_to_cpup(p);
 214         if (count > NFS3_MAXNAMLEN)
 215                 goto out_nametoolong;
 216         p = xdr_inline_decode(xdr, count);
 217         if (unlikely(p == NULL))
 218                 goto out_overflow;
 219         *name = (const char *)p;
 220         *length = count;
 221         return 0;
 222
 223 out_nametoolong:
 224         dprintk("NFS: returned filename too long: %u\n", count);
 225         return -ENAMETOOLONG;
 226 out_overflow:
 227         print_overflow_msg(__func__, xdr);
 228         return -EIO;
 229 }
 230
 231 /*
 232  * nfspath3
 233  *
 234  *      typedef string nfspath3<>;
 235  */
 236 static void encode_nfspath3(struct xdr_stream *xdr, struct page **pages,
 237                             const u32 length)
 238 {
 239         BUG_ON(length > NFS3_MAXPATHLEN);
 240         encode_uint32(xdr, length);
 241         xdr_write_pages(xdr, pages, 0, length);
 242 }
 243
 244 static int decode_nfspath3(struct xdr_stream *xdr)
 245 {
 246         u32 recvd, count;
 247         size_t hdrlen;
 248         __be32 *p;
 249
 250         p = xdr_inline_decode(xdr, 4);
 251         if (unlikely(p == NULL))
 252                 goto out_overflow;
 253         count = be32_to_cpup(p);
 254         if (unlikely(count >= xdr->buf->page_len || count > NFS3_MAXPATHLEN))
 255                 goto out_nametoolong;
 256         hdrlen = (u8 *)xdr->p - (u8 *)xdr->iov->iov_base;
 257         recvd = xdr->buf->len - hdrlen;
 258         if (unlikely(count > recvd))
 259                 goto out_cheating;
 260
 261         xdr_read_pages(xdr, count);
 262         xdr_terminate_string(xdr->buf, count);
 263         return 0;
 264
 265 out_nametoolong:
 266         dprintk("NFS: returned pathname too long: %u\n", count);
 267         return -ENAMETOOLONG;
 268 out_cheating:
 269         dprintk("NFS: server cheating in pathname result: "
 270                 "count %u > recvd %u\n", count, recvd);
 271         return -EIO;
 272 out_overflow:
 273         print_overflow_msg(__func__, xdr);
 274         return -EIO;
 275 }
 276
 277 /*
 278  * cookie3
 279  *
 280  *      typedef uint64 cookie3
 281  */
 282 static __be32 *xdr_encode_cookie3(__be32 *p, u64 cookie)
 283 {
 284         return xdr_encode_hyper(p, cookie);
 285 }
 286
 287 static int decode_cookie3(struct xdr_stream *xdr, u64 *cookie)
 288 {
 289         return decode_uint64(xdr, cookie);
 290 }
 291
 292 /*
 293  * cookieverf3
 294  *
 295  *      typedef opaque cookieverf3[NFS3_COOKIEVERFSIZE];
 296  */
 297 static __be32 *xdr_encode_cookieverf3(__be32 *p, const __be32 *verifier)
 298 {
 299         memcpy(p, verifier, NFS3_COOKIEVERFSIZE);
 300         return p + XDR_QUADLEN(NFS3_COOKIEVERFSIZE);
 301 }
 302
 303 static int decode_cookieverf3(struct xdr_stream *xdr, __be32 *verifier)
 304 {
 305         __be32 *p;
 306
 307         p = xdr_inline_decode(xdr, NFS3_COOKIEVERFSIZE);
 308         if (unlikely(p == NULL))
 309                 goto out_overflow;
 310         memcpy(verifier, p, NFS3_COOKIEVERFSIZE);
 311         return 0;
 312 out_overflow:
 313         print_overflow_msg(__func__, xdr);
 314         return -EIO;
 315 }
 316
 317 /*
 318  * createverf3
 319  *
 320  *      typedef opaque createverf3[NFS3_CREATEVERFSIZE];
 321  */
 322 static void encode_createverf3(struct xdr_stream *xdr, const __be32 *verifier)
 323 {
 324         __be32 *p;
 325
 326         p = xdr_reserve_space(xdr, NFS3_CREATEVERFSIZE);
 327         memcpy(p, verifier, NFS3_CREATEVERFSIZE);
 328 }
 329
 330 static int decode_writeverf3(struct xdr_stream *xdr, __be32 *verifier)
 331 {
 332         __be32 *p;
 333
 334         p = xdr_inline_decode(xdr, NFS3_WRITEVERFSIZE);
 335         if (unlikely(p == NULL))
 336                 goto out_overflow;
 337         memcpy(verifier, p, NFS3_WRITEVERFSIZE);
 338         return 0;
 339 out_overflow:
 340         print_overflow_msg(__func__, xdr);
 341         return -EIO;
 342 }
 343
 344 /*
 345  * size3
 346  *
 347  *      typedef uint64 size3;
 348  */
 349 static __be32 *xdr_decode_size3(__be32 *p, u64 *size)
 350 {
 351         return xdr_decode_hyper(p, size);
 352 }
 353
 354 /*
 355  * nfsstat3
 356  *
 357  *      enum nfsstat3 {
 358  *              NFS3_OK = 0,
 359  *              ...
 360  *      }
 361  */
 362 #define NFS3_OK         NFS_OK
 363
 364 static int decode_nfsstat3(struct xdr_stream *xdr, enum nfs_stat *status)
 365 {
 366         __be32 *p;
 367
 368         p = xdr_inline_decode(xdr, 4);
 369         if (unlikely(p == NULL))
 370                 goto out_overflow;
 371         *status = be32_to_cpup(p);
 372         return 0;
 373 out_overflow:
 374         print_overflow_msg(__func__, xdr);
 375         return -EIO;
 376 }
 377
 378 /*
 379  * ftype3
 380  *
 381  *      enum ftype3 {
 382  *              NF3REG  = 1,
 383  *              NF3DIR  = 2,
 384  *              NF3BLK  = 3,
 385  *              NF3CHR  = 4,
 386  *              NF3LNK  = 5,
 387  *              NF3SOCK = 6,
 388  *              NF3FIFO = 7
 389  *      };
 390  */
 391 static void encode_ftype3(struct xdr_stream *xdr, const u32 type)
 392 {
 393         BUG_ON(type > NF3FIFO);
 394         encode_uint32(xdr, type);
 395 }
 396
 397 static __be32 *xdr_decode_ftype3(__be32 *p, umode_t *mode)
 398 {
 399         u32 type;
 400
 401         type = be32_to_cpup(p++);
 402         if (type > NF3FIFO)
 403                 type = NF3NON;
 404         *mode = nfs_type2fmt[type];
 405         return p;
 406 }
 407
 408 /*
 409  * specdata3
 410  *
 411  *     struct specdata3 {
 412  *             uint32  specdata1;
 413  *             uint32  specdata2;
 414  *     };
 415  */
 416 static void encode_specdata3(struct xdr_stream *xdr, const dev_t rdev)
 417 {
 418         __be32 *p;
 419
 420         p = xdr_reserve_space(xdr, 8);
 421         *p++ = cpu_to_be32(MAJOR(rdev));
 422         *p = cpu_to_be32(MINOR(rdev));
 423 }
 424
 425 static __be32 *xdr_decode_specdata3(__be32 *p, dev_t *rdev)
 426 {
 427         unsigned int major, minor;
 428
 429         major = be32_to_cpup(p++);
 430         minor = be32_to_cpup(p++);
 431         *rdev = MKDEV(major, minor);
 432         if (MAJOR(*rdev) != major || MINOR(*rdev) != minor)
 433                 *rdev = 0;
 434         return p;
 435 }
 436
 437 /*
 438  * nfs_fh3
 439  *
 440  *      struct nfs_fh3 {
 441  *              opaque       data<NFS3_FHSIZE>;
 442  *      };
 443  */
 444 static void encode_nfs_fh3(struct xdr_stream *xdr, const struct nfs_fh *fh)
 445 {
 446         __be32 *p;
 447
 448         BUG_ON(fh->size > NFS3_FHSIZE);
 449         p = xdr_reserve_space(xdr, 4 + fh->size);
 450         xdr_encode_opaque(p, fh->data, fh->size);
 451 }
 452
 453 static int decode_nfs_fh3(struct xdr_stream *xdr, struct nfs_fh *fh)
 454 {
 455         u32 length;
 456         __be32 *p;
 457
 458         p = xdr_inline_decode(xdr, 4);
 459         if (unlikely(p == NULL))
 460                 goto out_overflow;
 461         length = be32_to_cpup(p++);
 462         if (unlikely(length > NFS3_FHSIZE))
 463                 goto out_toobig;
 464         p = xdr_inline_decode(xdr, length);
 465         if (unlikely(p == NULL))
 466                 goto out_overflow;
 467         fh->size = length;
 468         memcpy(fh->data, p, length);
 469         return 0;
 470 out_toobig:
 471         dprintk("NFS: file handle size (%u) too big\n", length);
 472         return -E2BIG;
 473 out_overflow:
 474         print_overflow_msg(__func__, xdr);
 475         return -EIO;
 476 }
 477
 478 static void zero_nfs_fh3(struct nfs_fh *fh)
 479 {
 480         memset(fh, 0, sizeof(*fh));
 481 }
 482
 483 /*
 484  * nfstime3
 485  *
 486  *      struct nfstime3 {
 487  *              uint32  seconds;
 488  *              uint32  nseconds;
 489  *      };
 490  */
 491 static __be32 *xdr_encode_nfstime3(__be32 *p, const struct timespec *timep)
 492 {
 493         *p++ = cpu_to_be32(timep->tv_sec);
 494         *p++ = cpu_to_be32(timep->tv_nsec);
 495         return p;
 496 }
 497
 498 static __be32 *xdr_decode_nfstime3(__be32 *p, struct timespec *timep)
 499 {
 500         timep->tv_sec = be32_to_cpup(p++);
 501         timep->tv_nsec = be32_to_cpup(p++);
 502         return p;
 503 }
 504
 505 /*
 506  * sattr3
 507  *
 508  *      enum time_how {
 509  *              DONT_CHANGE             = 0,
 510  *              SET_TO_SERVER_TIME      = 1,
 511  *              SET_TO_CLIENT_TIME      = 2
 512  *      };
 513  *
 514  *      union set_mode3 switch (bool set_it) {
 515  *      case TRUE:
 516  *              mode3   mode;
 517  *      default:
 518  *              void;
 519  *      };
 520  *
 521  *      union set_uid3 switch (bool set_it) {
 522  *      case TRUE:
 523  *              uid3    uid;
 524  *      default:
 525  *              void;
 526  *      };
 527  *
 528  *      union set_gid3 switch (bool set_it) {
 529  *      case TRUE:
 530  *              gid3    gid;
 531  *      default:
 532  *              void;
 533  *      };
 534  *
 535  *      union set_size3 switch (bool set_it) {
 536  *      case TRUE:
 537  *              size3   size;
 538  *      default:
 539  *              void;
 540  *      };
 541  *
 542  *      union set_atime switch (time_how set_it) {
 543  *      case SET_TO_CLIENT_TIME:
 544  *              nfstime3        atime;
 545  *      default:
 546  *              void;
 547  *      };
 548  *
 549  *      union set_mtime switch (time_how set_it) {
 550  *      case SET_TO_CLIENT_TIME:
 551  *              nfstime3  mtime;
 552  *      default:
 553  *              void;
 554  *      };
 555  *
 556  *      struct sattr3 {
 557  *              set_mode3       mode;
 558  *              set_uid3        uid;
 559  *              set_gid3        gid;
 560  *              set_size3       size;
 561  *              set_atime       atime;
 562  *              set_mtime       mtime;
 563  *      };
 564  */
 565 static void encode_sattr3(struct xdr_stream *xdr, const struct iattr *attr)
 566 {
 567         u32 nbytes;
 568         __be32 *p;
 569
 570         /*
 571          * In order to make only a single xdr_reserve_space() call,
 572          * pre-compute the total number of bytes to be reserved.
 573          * Six boolean values, one for each set_foo field, are always
 574          * present in the encoded result, so start there.
 575          */
 576         nbytes = 6 * 4;
 577         if (attr->ia_valid & ATTR_MODE)
 578                 nbytes += 4;
 579         if (attr->ia_valid & ATTR_UID)
 580                 nbytes += 4;
 581         if (attr->ia_valid & ATTR_GID)
 582                 nbytes += 4;
 583         if (attr->ia_valid & ATTR_SIZE)
 584                 nbytes += 8;
 585         if (attr->ia_valid & ATTR_ATIME_SET)
 586                 nbytes += 8;
 587         if (attr->ia_valid & ATTR_MTIME_SET)
 588                 nbytes += 8;
 589         p = xdr_reserve_space(xdr, nbytes);
 590
 591         if (attr->ia_valid & ATTR_MODE) {
 592                 *p++ = xdr_one;
 593                 *p++ = cpu_to_be32(attr->ia_mode & S_IALLUGO);
 594         } else
 595                 *p++ = xdr_zero;
 596
 597         if (attr->ia_valid & ATTR_UID) {
 598                 *p++ = xdr_one;
 599                 *p++ = cpu_to_be32(attr->ia_uid);
 600         } else
 601                 *p++ = xdr_zero;
 602
 603         if (attr->ia_valid & ATTR_GID) {
 604                 *p++ = xdr_one;
 605                 *p++ = cpu_to_be32(attr->ia_gid);
 606         } else
 607                 *p++ = xdr_zero;
 608
 609         if (attr->ia_valid & ATTR_SIZE) {
 610                 *p++ = xdr_one;
 611                 p = xdr_encode_hyper(p, (u64)attr->ia_size);
 612         } else
 613                 *p++ = xdr_zero;
 614
 615         if (attr->ia_valid & ATTR_ATIME_SET) {
 616                 *p++ = xdr_two;
 617                 p = xdr_encode_nfstime3(p, &attr->ia_atime);
 618         } else if (attr->ia_valid & ATTR_ATIME) {
 619                 *p++ = xdr_one;
 620         } else
 621                 *p++ = xdr_zero;
 622
 623         if (attr->ia_valid & ATTR_MTIME_SET) {
 624                 *p++ = xdr_two;
 625                 xdr_encode_nfstime3(p, &attr->ia_mtime);
 626         } else if (attr->ia_valid & ATTR_MTIME) {
 627                 *p = xdr_one;
 628         } else
 629                 *p = xdr_zero;
 630 }
 631
 632 /*
 633  * fattr3
 634  *
 635  *      struct fattr3 {
 636  *              ftype3          type;
 637  *              mode3           mode;
 638  *              uint32          nlink;
 639  *              uid3            uid;
 640  *              gid3            gid;
 641  *              size3           size;
 642  *              size3           used;
 643  *              specdata3       rdev;
 644  *              uint64          fsid;
 645  *              fileid3         fileid;
 646  *              nfstime3        atime;
 647  *              nfstime3        mtime;
 648  *              nfstime3        ctime;
 649  *      };
 650  */
 651 static int decode_fattr3(struct xdr_stream *xdr, struct nfs_fattr *fattr)
 652 {
 653         umode_t fmode;
 654         __be32 *p;
 655
 656         p = xdr_inline_decode(xdr, NFS3_fattr_sz << 2);
 657         if (unlikely(p == NULL))
 658                 goto out_overflow;
 659
 660         p = xdr_decode_ftype3(p, &fmode);
 661
 662         fattr->mode = (be32_to_cpup(p++) & ~S_IFMT) | fmode;
 663         fattr->nlink = be32_to_cpup(p++);
 664         fattr->uid = be32_to_cpup(p++);
 665         fattr->gid = be32_to_cpup(p++);
 666
 667         p = xdr_decode_size3(p, &fattr->size);
 668         p = xdr_decode_size3(p, &fattr->du.nfs3.used);
 669         p = xdr_decode_specdata3(p, &fattr->rdev);
 670
 671         p = xdr_decode_hyper(p, &fattr->fsid.major);
 672         fattr->fsid.minor = 0;
 673
 674         p = xdr_decode_fileid3(p, &fattr->fileid);
 675         p = xdr_decode_nfstime3(p, &fattr->atime);
 676         p = xdr_decode_nfstime3(p, &fattr->mtime);
 677         xdr_decode_nfstime3(p, &fattr->ctime);
 678
 679         fattr->valid |= NFS_ATTR_FATTR_V3;
 680         return 0;
 681 out_overflow:
 682         print_overflow_msg(__func__, xdr);
 683         return -EIO;
 684 }
 685
 686 /*
 687  * post_op_attr
 688  *
 689  *      union post_op_attr switch (bool attributes_follow) {
 690  *      case TRUE:
 691  *              fattr3  attributes;
 692  *      case FALSE:
 693  *              void;
 694  *      };
 695  */
 696 static int decode_post_op_attr(struct xdr_stream *xdr, struct nfs_fattr *fattr)
 697 {
 698         __be32 *p;
 699
 700         p = xdr_inline_decode(xdr, 4);
 701         if (unlikely(p == NULL))
 702                 goto out_overflow;
 703         if (*p != xdr_zero)
 704                 return decode_fattr3(xdr, fattr);
 705         return 0;
 706 out_overflow:
 707         print_overflow_msg(__func__, xdr);
 708         return -EIO;
 709 }
 710
 711 /*
 712  * wcc_attr
 713  *      struct wcc_attr {
 714  *              size3           size;
 715  *              nfstime3        mtime;
 716  *              nfstime3        ctime;
 717  *      };
 718  */
 719 static int decode_wcc_attr(struct xdr_stream *xdr, struct nfs_fattr *fattr)
 720 {
 721         __be32 *p;
 722
 723         p = xdr_inline_decode(xdr, NFS3_wcc_attr_sz << 2);
 724         if (unlikely(p == NULL))
 725                 goto out_overflow;
 726
 727         fattr->valid |= NFS_ATTR_FATTR_PRESIZE
 728                 | NFS_ATTR_FATTR_PREMTIME
 729                 | NFS_ATTR_FATTR_PRECTIME;
 730
 731         p = xdr_decode_size3(p, &fattr->pre_size);
 732         p = xdr_decode_nfstime3(p, &fattr->pre_mtime);
 733         xdr_decode_nfstime3(p, &fattr->pre_ctime);
 734
 735         return 0;
 736 out_overflow:
 737         print_overflow_msg(__func__, xdr);
 738         return -EIO;
 739 }
 740
 741 /*
 742  * pre_op_attr
 743  *      union pre_op_attr switch (bool attributes_follow) {
 744  *      case TRUE:
 745  *              wcc_attr        attributes;
 746  *      case FALSE:
 747  *              void;
 748  *      };
 749  *
 750  * wcc_data
 751  *
 752  *      struct wcc_data {
 753  *              pre_op_attr     before;
 754  *              post_op_attr    after;
 755  *      };
 756  */
 757 static int decode_pre_op_attr(struct xdr_stream *xdr, struct nfs_fattr *fattr)
 758 {
 759         __be32 *p;
 760
 761         p = xdr_inline_decode(xdr, 4);
 762         if (unlikely(p == NULL))
 763                 goto out_overflow;
 764         if (*p != xdr_zero)
 765                 return decode_wcc_attr(xdr, fattr);
 766         return 0;
 767 out_overflow:
 768         print_overflow_msg(__func__, xdr);
 769         return -EIO;
 770 }
 771
 772 static int decode_wcc_data(struct xdr_stream *xdr, struct nfs_fattr *fattr)
 773 {
 774         int error;
 775
 776         error = decode_pre_op_attr(xdr, fattr);
 777         if (unlikely(error))
 778                 goto out;
 779         error = decode_post_op_attr(xdr, fattr);
 780 out:
 781         return error;
 782 }
 783
 784 /*
 785  * post_op_fh3
 786  *
 787  *      union post_op_fh3 switch (bool handle_follows) {
 788  *      case TRUE:
 789  *              nfs_fh3  handle;
 790  *      case FALSE:
 791  *              void;
 792  *      };
 793  */
 794 static int decode_post_op_fh3(struct xdr_stream *xdr, struct nfs_fh *fh)
 795 {
 796         __be32 *p = xdr_inline_decode(xdr, 4);
 797         if (unlikely(p == NULL))
 798                 goto out_overflow;
 799         if (*p != xdr_zero)
 800                 return decode_nfs_fh3(xdr, fh);
 801         zero_nfs_fh3(fh);
 802         return 0;
 803 out_overflow:
 804         print_overflow_msg(__func__, xdr);
 805         return -EIO;
 806 }
 807
 808 /*
 809  * diropargs3
 810  *
 811  *      struct diropargs3 {
 812  *              nfs_fh3         dir;
 813  *              filename3       name;
 814  *      };
 815  */
 816 static void encode_diropargs3(struct xdr_stream *xdr, const struct nfs_fh *fh,
 817                               const char *name, u32 length)
 818 {
 819         encode_nfs_fh3(xdr, fh);
 820         encode_filename3(xdr, name, length);
 821 }
 822
 823
 824 /*
 825  * NFSv3 XDR encode functions
 826  *
 827  * NFSv3 argument types are defined in section 3.3 of RFC 1813:
 828  * "NFS Version 3 Protocol Specification".
 829  */
 830
 831 /*
 832  * 3.3.1  GETATTR3args
 833  *
 834  *      struct GETATTR3args {
 835  *              nfs_fh3  object;
 836  *      };
 837  */
 838 static void nfs3_xdr_enc_getattr3args(struct rpc_rqst *req,
 839                                       struct xdr_stream *xdr,
 840                                       const struct nfs_fh *fh)
 841 {
 842         encode_nfs_fh3(xdr, fh);
 843 }
 844
 845 /*
 846  * 3.3.2  SETATTR3args
 847  *
 848  *      union sattrguard3 switch (bool check) {
 849  *      case TRUE:
 850  *              nfstime3  obj_ctime;
 851  *      case FALSE:
 852  *              void;
 853  *      };
 854  *
 855  *      struct SETATTR3args {
 856  *              nfs_fh3         object;
 857  *              sattr3          new_attributes;
 858  *              sattrguard3     guard;
 859  *      };
 860  */
 861 static void encode_sattrguard3(struct xdr_stream *xdr,
 862                                const struct nfs3_sattrargs *args)
 863 {
 864         __be32 *p;
 865
 866         if (args->guard) {
 867                 p = xdr_reserve_space(xdr, 4 + 8);
 868                 *p++ = xdr_one;
 869                 xdr_encode_nfstime3(p, &args->guardtime);
 870         } else {
 871                 p = xdr_reserve_space(xdr, 4);
 872                 *p = xdr_zero;
 873         }
 874 }
 875
 876 static void nfs3_xdr_enc_setattr3args(struct rpc_rqst *req,
 877                                       struct xdr_stream *xdr,
 878                                       const struct nfs3_sattrargs *args)
 879 {
 880         encode_nfs_fh3(xdr, args->fh);
 881         encode_sattr3(xdr, args->sattr);
 882         encode_sattrguard3(xdr, args);
 883 }
 884
 885 /*
 886  * 3.3.3  LOOKUP3args
 887  *
 888  *      struct LOOKUP3args {
 889  *              diropargs3  what;
 890  *      };
 891  */
 892 static void nfs3_xdr_enc_lookup3args(struct rpc_rqst *req,
 893                                      struct xdr_stream *xdr,
 894                                      const struct nfs3_diropargs *args)
 895 {
 896         encode_diropargs3(xdr, args->fh, args->name, args->len);
 897 }
 898
 899 /*
 900  * 3.3.4  ACCESS3args
 901  *
 902  *      struct ACCESS3args {
 903  *              nfs_fh3         object;
 904  *              uint32          access;
 905  *      };
 906  */
 907 static void encode_access3args(struct xdr_stream *xdr,
 908                                const struct nfs3_accessargs *args)
 909 {
 910         encode_nfs_fh3(xdr, args->fh);
 911         encode_uint32(xdr, args->access);
 912 }
 913
 914 static void nfs3_xdr_enc_access3args(struct rpc_rqst *req,
 915                                      struct xdr_stream *xdr,
 916                                      const struct nfs3_accessargs *args)
 917 {
 918         encode_access3args(xdr, args);
 919 }
 920
 921 /*
 922  * 3.3.5  READLINK3args
 923  *
 924  *      struct READLINK3args {
 925  *              nfs_fh3 symlink;
 926  *      };
 927  */
 928 static void nfs3_xdr_enc_readlink3args(struct rpc_rqst *req,
 929                                        struct xdr_stream *xdr,
 930                                        const struct nfs3_readlinkargs *args)
 931 {
 932         encode_nfs_fh3(xdr, args->fh);
 933         prepare_reply_buffer(req, args->pages, args->pgbase,
 934                                         args->pglen, NFS3_readlinkres_sz);
 935 }
 936
 937 /*
 938  * 3.3.6  READ3args
 939  *
 940  *      struct READ3args {
 941  *              nfs_fh3         file;
 942  *              offset3         offset;
 943  *              count3          count;
 944  *      };
 945  */
 946 static void encode_read3args(struct xdr_stream *xdr,
 947                              const struct nfs_readargs *args)
 948 {
 949         __be32 *p;
 950
 951         encode_nfs_fh3(xdr, args->fh);
 952
 953         p = xdr_reserve_space(xdr, 8 + 4);
 954         p = xdr_encode_hyper(p, args->offset);
 955         *p = cpu_to_be32(args->count);
 956 }
 957
 958 static void nfs3_xdr_enc_read3args(struct rpc_rqst *req,
 959                                    struct xdr_stream *xdr,
 960                                    const struct nfs_readargs *args)
 961 {
 962         encode_read3args(xdr, args);
 963         prepare_reply_buffer(req, args->pages, args->pgbase,
 964                                         args->count, NFS3_readres_sz);
 965         req->rq_rcv_buf.flags |= XDRBUF_READ;
 966 }
 967
 968 /*
 969  * 3.3.7  WRITE3args
 970  *
 971  *      enum stable_how {
 972  *              UNSTABLE  = 0,
 973  *              DATA_SYNC = 1,
 974  *              FILE_SYNC = 2
 975  *      };
 976  *
 977  *      struct WRITE3args {
 978  *              nfs_fh3         file;
 979  *              offset3         offset;
 980  *              count3          count;
 981  *              stable_how      stable;
 982  *              opaque          data<>;
 983  *      };
 984  */
 985 static void encode_write3args(struct xdr_stream *xdr,
 986                               const struct nfs_writeargs *args)
 987 {
 988         __be32 *p;
 989
 990         encode_nfs_fh3(xdr, args->fh);
 991
 992         p = xdr_reserve_space(xdr, 8 + 4 + 4 + 4);
 993         p = xdr_encode_hyper(p, args->offset);
 994         *p++ = cpu_to_be32(args->count);
 995         *p++ = cpu_to_be32(args->stable);
 996         *p = cpu_to_be32(args->count);
 997         xdr_write_pages(xdr, args->pages, args->pgbase, args->count);
 998 }
 999
1000 static void nfs3_xdr_enc_write3args(struct rpc_rqst *req,
1001                                     struct xdr_stream *xdr,
1002                                     const struct nfs_writeargs *args)
1003 {
1004         encode_write3args(xdr, args);
1005         xdr->buf->flags |= XDRBUF_WRITE;
1006 }
1007
1008 /*
1009  * 3.3.8  CREATE3args
1010  *
1011  *      enum createmode3 {
1012  *              UNCHECKED = 0,
1013  *              GUARDED   = 1,
1014  *              EXCLUSIVE = 2
1015  *      };
1016  *
1017  *      union createhow3 switch (createmode3 mode) {
1018  *      case UNCHECKED:
1019  *      case GUARDED:
1020  *              sattr3       obj_attributes;
1021  *      case EXCLUSIVE:
1022  *              createverf3  verf;
1023  *      };
1024  *
1025  *      struct CREATE3args {
1026  *              diropargs3      where;
1027  *              createhow3      how;
1028  *      };
1029  */
1030 static void encode_createhow3(struct xdr_stream *xdr,
1031                               const struct nfs3_createargs *args)
1032 {
1033         encode_uint32(xdr, args->createmode);
1034         switch (args->createmode) {
1035         case NFS3_CREATE_UNCHECKED:
1036         case NFS3_CREATE_GUARDED:
1037                 encode_sattr3(xdr, args->sattr);
1038                 break;
1039         case NFS3_CREATE_EXCLUSIVE:
1040                 encode_createverf3(xdr, args->verifier);
1041                 break;
1042         default:
1043                 BUG();
1044         }
1045 }
1046
1047 static void nfs3_xdr_enc_create3args(struct rpc_rqst *req,
1048                                      struct xdr_stream *xdr,
1049                                      const struct nfs3_createargs *args)
1050 {
1051         encode_diropargs3(xdr, args->fh, args->name, args->len);
1052         encode_createhow3(xdr, args);
1053 }
1054
1055 /*
1056  * 3.3.9  MKDIR3args
1057  *
1058  *      struct MKDIR3args {
1059  *              diropargs3      where;
1060  *              sattr3          attributes;
1061  *      };
1062  */
1063 static void nfs3_xdr_enc_mkdir3args(struct rpc_rqst *req,
1064                                     struct xdr_stream *xdr,
1065                                     const struct nfs3_mkdirargs *args)
1066 {
1067         encode_diropargs3(xdr, args->fh, args->name, args->len);
1068         encode_sattr3(xdr, args->sattr);
1069 }
1070
1071 /*
1072  * 3.3.10  SYMLINK3args
1073  *
1074  *      struct symlinkdata3 {
1075  *              sattr3          symlink_attributes;
1076  *              nfspath3        symlink_data;
1077  *      };
1078  *
1079  *      struct SYMLINK3args {
1080  *              diropargs3      where;
1081  *              symlinkdata3    symlink;
1082  *      };
1083  */
1084 static void encode_symlinkdata3(struct xdr_stream *xdr,
1085                                 const struct nfs3_symlinkargs *args)
1086 {
1087         encode_sattr3(xdr, args->sattr);
1088         encode_nfspath3(xdr, args->pages, args->pathlen);
1089 }
1090
1091 static void nfs3_xdr_enc_symlink3args(struct rpc_rqst *req,
1092                                       struct xdr_stream *xdr,
1093                                       const struct nfs3_symlinkargs *args)
1094 {
1095         encode_diropargs3(xdr, args->fromfh, args->fromname, args->fromlen);
1096         encode_symlinkdata3(xdr, args);
1097 }
1098
1099 /*
1100  * 3.3.11  MKNOD3args
1101  *
1102  *      struct devicedata3 {
1103  *              sattr3          dev_attributes;
1104  *              specdata3       spec;
1105  *      };
1106  *
1107  *      union mknoddata3 switch (ftype3 type) {
1108  *      case NF3CHR:
1109  *      case NF3BLK:
1110  *              devicedata3     device;
1111  *      case NF3SOCK:
1112  *      case NF3FIFO:
1113  *              sattr3          pipe_attributes;
1114  *      default:
1115  *              void;
1116  *      };
1117  *
1118  *      struct MKNOD3args {
1119  *              diropargs3      where;
1120  *              mknoddata3      what;
1121  *      };
1122  */
1123 static void encode_devicedata3(struct xdr_stream *xdr,
1124                                const struct nfs3_mknodargs *args)
1125 {
1126         encode_sattr3(xdr, args->sattr);
1127         encode_specdata3(xdr, args->rdev);
1128 }
1129
1130 static void encode_mknoddata3(struct xdr_stream *xdr,
1131                               const struct nfs3_mknodargs *args)
1132 {
1133         encode_ftype3(xdr, args->type);
1134         switch (args->type) {
1135         case NF3CHR:
1136         case NF3BLK:
1137                 encode_devicedata3(xdr, args);
1138                 break;
1139         case NF3SOCK:
1140         case NF3FIFO:
1141                 encode_sattr3(xdr, args->sattr);
1142                 break;
1143         case NF3REG:
1144         case NF3DIR:
1145                 break;
1146         default:
1147                 BUG();
1148         }
1149 }
1150
1151 static void nfs3_xdr_enc_mknod3args(struct rpc_rqst *req,
1152                                     struct xdr_stream *xdr,
1153                                     const struct nfs3_mknodargs *args)
1154 {
1155         encode_diropargs3(xdr, args->fh, args->name, args->len);
1156         encode_mknoddata3(xdr, args);
1157 }
1158
1159 /*
1160  * 3.3.12  REMOVE3args
1161  *
1162  *      struct REMOVE3args {
1163  *              diropargs3  object;
1164  *      };
1165  */
1166 static void nfs3_xdr_enc_remove3args(struct rpc_rqst *req,
1167                                      struct xdr_stream *xdr,
1168                                      const struct nfs_removeargs *args)
1169 {
1170         encode_diropargs3(xdr, args->fh, args->name.name, args->name.len);
1171 }
1172
1173 /*
1174  * 3.3.14  RENAME3args
1175  *
1176  *      struct RENAME3args {
1177  *              diropargs3      from;
1178  *              diropargs3      to;
1179  *      };
1180  */
1181 static void nfs3_xdr_enc_rename3args(struct rpc_rqst *req,
1182                                      struct xdr_stream *xdr,
1183                                      const struct nfs_renameargs *args)
1184 {
1185         const struct qstr *old = args->old_name;
1186         const struct qstr *new = args->new_name;
1187
1188         encode_diropargs3(xdr, args->old_dir, old->name, old->len);
1189         encode_diropargs3(xdr, args->new_dir, new->name, new->len);
1190 }
1191
1192 /*
1193  * 3.3.15  LINK3args
1194  *
1195  *      struct LINK3args {
1196  *              nfs_fh3         file;
1197  *              diropargs3      link;
1198  *      };
1199  */
1200 static void nfs3_xdr_enc_link3args(struct rpc_rqst *req,
1201                                    struct xdr_stream *xdr,
1202                                    const struct nfs3_linkargs *args)
1203 {
1204         encode_nfs_fh3(xdr, args->fromfh);
1205         encode_diropargs3(xdr, args->tofh, args->toname, args->tolen);
1206 }
1207
1208 /*
1209  * 3.3.16  READDIR3args
1210  *
1211  *      struct READDIR3args {
1212  *              nfs_fh3         dir;
1213  *              cookie3         cookie;
1214  *              cookieverf3     cookieverf;
1215  *              count3          count;
1216  *      };
1217  */
1218 static void encode_readdir3args(struct xdr_stream *xdr,
1219                                 const struct nfs3_readdirargs *args)
1220 {
1221         __be32 *p;
1222
1223         encode_nfs_fh3(xdr, args->fh);
1224
1225         p = xdr_reserve_space(xdr, 8 + NFS3_COOKIEVERFSIZE + 4);
1226         p = xdr_encode_cookie3(p, args->cookie);
1227         p = xdr_encode_cookieverf3(p, args->verf);
1228         *p = cpu_to_be32(args->count);
1229 }
1230
1231 static void nfs3_xdr_enc_readdir3args(struct rpc_rqst *req,
1232                                       struct xdr_stream *xdr,
1233                                       const struct nfs3_readdirargs *args)
1234 {
1235         encode_readdir3args(xdr, args);
1236         prepare_reply_buffer(req, args->pages, 0,
1237                                 args->count, NFS3_readdirres_sz);
1238 }
1239
1240 /*
1241  * 3.3.17  READDIRPLUS3args
1242  *
1243  *      struct READDIRPLUS3args {
1244  *              nfs_fh3         dir;
1245  *              cookie3         cookie;
1246  *              cookieverf3     cookieverf;
1247  *              count3          dircount;
1248  *              count3          maxcount;
1249  *      };
1250  */
1251 static void encode_readdirplus3args(struct xdr_stream *xdr,
1252                                     const struct nfs3_readdirargs *args)
1253 {
1254         __be32 *p;
1255
1256         encode_nfs_fh3(xdr, args->fh);
1257
1258         p = xdr_reserve_space(xdr, 8 + NFS3_COOKIEVERFSIZE + 4 + 4);
1259         p = xdr_encode_cookie3(p, args->cookie);
1260         p = xdr_encode_cookieverf3(p, args->verf);
1261
1262         /*
1263          * readdirplus: need dircount + buffer size.
1264          * We just make sure we make dircount big enough
1265          */
1266         *p++ = cpu_to_be32(args->count >> 3);
1267
1268         *p = cpu_to_be32(args->count);
1269 }
1270
1271 static void nfs3_xdr_enc_readdirplus3args(struct rpc_rqst *req,
1272                                           struct xdr_stream *xdr,
1273                                           const struct nfs3_readdirargs *args)
1274 {
1275         encode_readdirplus3args(xdr, args);
1276         prepare_reply_buffer(req, args->pages, 0,
1277                                 args->count, NFS3_readdirres_sz);
1278 }
1279
1280 /*
1281  * 3.3.21  COMMIT3args
1282  *
1283  *      struct COMMIT3args {
1284  *              nfs_fh3         file;
1285  *              offset3         offset;
1286  *              count3          count;
1287  *      };
1288  */
1289 static void encode_commit3args(struct xdr_stream *xdr,
1290                                const struct nfs_writeargs *args)
1291 {
1292         __be32 *p;
1293
1294         encode_nfs_fh3(xdr, args->fh);
1295
1296         p = xdr_reserve_space(xdr, 8 + 4);
1297         p = xdr_encode_hyper(p, args->offset);
1298         *p = cpu_to_be32(args->count);
1299 }
1300
1301 static void nfs3_xdr_enc_commit3args(struct rpc_rqst *req,
1302                                      struct xdr_stream *xdr,
1303                                      const struct nfs_writeargs *args)
1304 {
1305         encode_commit3args(xdr, args);
1306 }
1307
1308 #ifdef CONFIG_NFS_V3_ACL
1309
1310 static void nfs3_xdr_enc_getacl3args(struct rpc_rqst *req,
1311                                      struct xdr_stream *xdr,
1312                                      const struct nfs3_getaclargs *args)
1313 {
1314         encode_nfs_fh3(xdr, args->fh);
1315         encode_uint32(xdr, args->mask);
1316         if (args->mask & (NFS_ACL | NFS_DFACL))
1317                 prepare_reply_buffer(req, args->pages, 0,
1318                                         NFSACL_MAXPAGES << PAGE_SHIFT,
1319                                         ACL3_getaclres_sz);
1320 }
1321
1322 static void nfs3_xdr_enc_setacl3args(struct rpc_rqst *req,
1323                                      struct xdr_stream *xdr,
1324                                      const struct nfs3_setaclargs *args)
1325 {
1326         unsigned int base;
1327         int error;
1328
1329         encode_nfs_fh3(xdr, NFS_FH(args->inode));
1330         encode_uint32(xdr, args->mask);
1331         if (args->npages != 0)
1332                 xdr_write_pages(xdr, args->pages, 0, args->len);
1333
1334         base = req->rq_slen;
1335         error = nfsacl_encode(xdr->buf, base, args->inode,
1336                             (args->mask & NFS_ACL) ?
1337                             args->acl_access : NULL, 1, 0);
1338         BUG_ON(error < 0);
1339         error = nfsacl_encode(xdr->buf, base + error, args->inode,
1340                             (args->mask & NFS_DFACL) ?
1341                             args->acl_default : NULL, 1,
1342                             NFS_ACL_DEFAULT);
1343         BUG_ON(error < 0);
1344 }
1345
1346 #endif  /* CONFIG_NFS_V3_ACL */
1347
1348 /*
1349  * NFSv3 XDR decode functions
1350  *
1351  * NFSv3 result types are defined in section 3.3 of RFC 1813:
1352  * "NFS Version 3 Protocol Specification".
1353  */
1354
1355 /*
1356  * 3.3.1  GETATTR3res
1357  *
1358  *      struct GETATTR3resok {
1359  *              fattr3          obj_attributes;
1360  *      };
1361  *
1362  *      union GETATTR3res switch (nfsstat3 status) {
1363  *      case NFS3_OK:
1364  *              GETATTR3resok  resok;
1365  *      default:
1366  *              void;
1367  *      };
1368  */
1369 static int nfs3_xdr_dec_getattr3res(struct rpc_rqst *req, __be32 *p,
1370                                     struct nfs_fattr *result)
1371 {
1372         struct xdr_stream xdr;
1373         enum nfs_stat status;
1374         int error;
1375
1376         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1377         error = decode_nfsstat3(&xdr, &status);
1378         if (unlikely(error))
1379                 goto out;
1380         if (status != NFS3_OK)
1381                 goto out_default;
1382         error = decode_fattr3(&xdr, result);
1383 out:
1384         return error;
1385 out_default:
1386         return nfs_stat_to_errno(status);
1387 }
1388
1389 /*
1390  * 3.3.2  SETATTR3res
1391  *
1392  *      struct SETATTR3resok {
1393  *              wcc_data  obj_wcc;
1394  *      };
1395  *
1396  *      struct SETATTR3resfail {
1397  *              wcc_data  obj_wcc;
1398  *      };
1399  *
1400  *      union SETATTR3res switch (nfsstat3 status) {
1401  *      case NFS3_OK:
1402  *              SETATTR3resok   resok;
1403  *      default:
1404  *              SETATTR3resfail resfail;
1405  *      };
1406  */
1407 static int nfs3_xdr_dec_setattr3res(struct rpc_rqst *req, __be32 *p,
1408                                     struct nfs_fattr *result)
1409 {
1410         struct xdr_stream xdr;
1411         enum nfs_stat status;
1412         int error;
1413
1414         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1415         error = decode_nfsstat3(&xdr, &status);
1416         if (unlikely(error))
1417                 goto out;
1418         error = decode_wcc_data(&xdr, result);
1419         if (unlikely(error))
1420                 goto out;
1421         if (status != NFS3_OK)
1422                 goto out_status;
1423 out:
1424         return error;
1425 out_status:
1426         return nfs_stat_to_errno(status);
1427 }
1428
1429 /*
1430  * 3.3.3  LOOKUP3res
1431  *
1432  *      struct LOOKUP3resok {
1433  *              nfs_fh3         object;
1434  *              post_op_attr    obj_attributes;
1435  *              post_op_attr    dir_attributes;
1436  *      };
1437  *
1438  *      struct LOOKUP3resfail {
1439  *              post_op_attr    dir_attributes;
1440  *      };
1441  *
1442  *      union LOOKUP3res switch (nfsstat3 status) {
1443  *      case NFS3_OK:
1444  *              LOOKUP3resok    resok;
1445  *      default:
1446  *              LOOKUP3resfail  resfail;
1447  *      };
1448  */
1449 static int nfs3_xdr_dec_lookup3res(struct rpc_rqst *req, __be32 *p,
1450                                    struct nfs3_diropres *result)
1451 {
1452         struct xdr_stream xdr;
1453         enum nfs_stat status;
1454         int error;
1455
1456         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1457         error = decode_nfsstat3(&xdr, &status);
1458         if (unlikely(error))
1459                 goto out;
1460         if (status != NFS3_OK)
1461                 goto out_default;
1462         error = decode_nfs_fh3(&xdr, result->fh);
1463         if (unlikely(error))
1464                 goto out;
1465         error = decode_post_op_attr(&xdr, result->fattr);
1466         if (unlikely(error))
1467                 goto out;
1468         error = decode_post_op_attr(&xdr, result->dir_attr);
1469 out:
1470         return error;
1471 out_default:
1472         error = decode_post_op_attr(&xdr, result->dir_attr);
1473         if (unlikely(error))
1474                 goto out;
1475         return nfs_stat_to_errno(status);
1476 }
1477
1478 /*
1479  * 3.3.4  ACCESS3res
1480  *
1481  *      struct ACCESS3resok {
1482  *              post_op_attr    obj_attributes;
1483  *              uint32          access;
1484  *      };
1485  *
1486  *      struct ACCESS3resfail {
1487  *              post_op_attr    obj_attributes;
1488  *      };
1489  *
1490  *      union ACCESS3res switch (nfsstat3 status) {
1491  *      case NFS3_OK:
1492  *              ACCESS3resok    resok;
1493  *      default:
1494  *              ACCESS3resfail  resfail;
1495  *      };
1496  */
1497 static int nfs3_xdr_dec_access3res(struct rpc_rqst *req, __be32 *p,
1498                                    struct nfs3_accessres *result)
1499 {
1500         struct xdr_stream xdr;
1501         enum nfs_stat status;
1502         int error;
1503
1504         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1505         error = decode_nfsstat3(&xdr, &status);
1506         if (unlikely(error))
1507                 goto out;
1508         error = decode_post_op_attr(&xdr, result->fattr);
1509         if (unlikely(error))
1510                 goto out;
1511         if (status != NFS3_OK)
1512                 goto out_default;
1513         error = decode_uint32(&xdr, &result->access);
1514 out:
1515         return error;
1516 out_default:
1517         return nfs_stat_to_errno(status);
1518 }
1519
1520 /*
1521  * 3.3.5  READLINK3res
1522  *
1523  *      struct READLINK3resok {
1524  *              post_op_attr    symlink_attributes;
1525  *              nfspath3        data;
1526  *      };
1527  *
1528  *      struct READLINK3resfail {
1529  *              post_op_attr    symlink_attributes;
1530  *      };
1531  *
1532  *      union READLINK3res switch (nfsstat3 status) {
1533  *      case NFS3_OK:
1534  *              READLINK3resok  resok;
1535  *      default:
1536  *              READLINK3resfail resfail;
1537  *      };
1538  */
1539 static int nfs3_xdr_dec_readlink3res(struct rpc_rqst *req, __be32 *p,
1540                                      struct nfs_fattr *result)
1541 {
1542         struct xdr_stream xdr;
1543         enum nfs_stat status;
1544         int error;
1545
1546         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1547         error = decode_nfsstat3(&xdr, &status);
1548         if (unlikely(error))
1549                 goto out;
1550         error = decode_post_op_attr(&xdr, result);
1551         if (unlikely(error))
1552                 goto out;
1553         if (status != NFS3_OK)
1554                 goto out_default;
1555         error = decode_nfspath3(&xdr);
1556 out:
1557         return error;
1558 out_default:
1559         return nfs_stat_to_errno(status);
1560 }
1561
1562 /*
1563  * 3.3.6  READ3res
1564  *
1565  *      struct READ3resok {
1566  *              post_op_attr    file_attributes;
1567  *              count3          count;
1568  *              bool            eof;
1569  *              opaque          data<>;
1570  *      };
1571  *
1572  *      struct READ3resfail {
1573  *              post_op_attr    file_attributes;
1574  *      };
1575  *
1576  *      union READ3res switch (nfsstat3 status) {
1577  *      case NFS3_OK:
1578  *              READ3resok      resok;
1579  *      default:
1580  *              READ3resfail    resfail;
1581  *      };
1582  */
1583 static int decode_read3resok(struct xdr_stream *xdr,
1584                              struct nfs_readres *result)
1585 {
1586         u32 eof, count, ocount, recvd;
1587         size_t hdrlen;
1588         __be32 *p;
1589
1590         p = xdr_inline_decode(xdr, 4 + 4 + 4);
1591         if (unlikely(p == NULL))
1592                 goto out_overflow;
1593         count = be32_to_cpup(p++);
1594         eof = be32_to_cpup(p++);
1595         ocount = be32_to_cpup(p++);
1596         if (unlikely(ocount != count))
1597                 goto out_mismatch;
1598         hdrlen = (u8 *)xdr->p - (u8 *)xdr->iov->iov_base;
1599         recvd = xdr->buf->len - hdrlen;
1600         if (unlikely(count > recvd))
1601                 goto out_cheating;
1602
1603 out:
1604         xdr_read_pages(xdr, count);
1605         result->eof = eof;
1606         result->count = count;
1607         return count;
1608 out_mismatch:
1609         dprintk("NFS: READ count doesn't match length of opaque: "
1610                 "count %u != ocount %u\n", count, ocount);
1611         return -EIO;
1612 out_cheating:
1613         dprintk("NFS: server cheating in read result: "
1614                 "count %u > recvd %u\n", count, recvd);
1615         count = recvd;
1616         eof = 0;
1617         goto out;
1618 out_overflow:
1619         print_overflow_msg(__func__, xdr);
1620         return -EIO;
1621 }
1622
1623 static int nfs3_xdr_dec_read3res(struct rpc_rqst *req, __be32 *p,
1624                                  struct nfs_readres *result)
1625 {
1626         struct xdr_stream xdr;
1627         enum nfs_stat status;
1628         int error;
1629
1630         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1631         error = decode_nfsstat3(&xdr, &status);
1632         if (unlikely(error))
1633                 goto out;
1634         error = decode_post_op_attr(&xdr, result->fattr);
1635         if (unlikely(error))
1636                 goto out;
1637         if (status != NFS3_OK)
1638                 goto out_status;
1639         error = decode_read3resok(&xdr, result);
1640 out:
1641         return error;
1642 out_status:
1643         return nfs_stat_to_errno(status);
1644 }
1645
1646 /*
1647  * 3.3.7  WRITE3res
1648  *
1649  *      enum stable_how {
1650  *              UNSTABLE  = 0,
1651  *              DATA_SYNC = 1,
1652  *              FILE_SYNC = 2
1653  *      };
1654  *
1655  *      struct WRITE3resok {
1656  *              wcc_data        file_wcc;
1657  *              count3          count;
1658  *              stable_how      committed;
1659  *              writeverf3      verf;
1660  *      };
1661  *
1662  *      struct WRITE3resfail {
1663  *              wcc_data        file_wcc;
1664  *      };
1665  *
1666  *      union WRITE3res switch (nfsstat3 status) {
1667  *      case NFS3_OK:
1668  *              WRITE3resok     resok;
1669  *      default:
1670  *              WRITE3resfail   resfail;
1671  *      };
1672  */
1673 static int decode_write3resok(struct xdr_stream *xdr,
1674                               struct nfs_writeres *result)
1675 {
1676         __be32 *p;
1677
1678         p = xdr_inline_decode(xdr, 4 + 4 + NFS3_WRITEVERFSIZE);
1679         if (unlikely(p == NULL))
1680                 goto out_overflow;
1681         result->count = be32_to_cpup(p++);
1682         result->verf->committed = be32_to_cpup(p++);
1683         if (unlikely(result->verf->committed > NFS_FILE_SYNC))
1684                 goto out_badvalue;
1685         memcpy(result->verf->verifier, p, NFS3_WRITEVERFSIZE);
1686         return result->count;
1687 out_badvalue:
1688         dprintk("NFS: bad stable_how value: %u\n", result->verf->committed);
1689         return -EIO;
1690 out_overflow:
1691         print_overflow_msg(__func__, xdr);
1692         return -EIO;
1693 }
1694
1695 static int nfs3_xdr_dec_write3res(struct rpc_rqst *req, __be32 *p,
1696                                   struct nfs_writeres *result)
1697 {
1698         struct xdr_stream xdr;
1699         enum nfs_stat status;
1700         int error;
1701
1702         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1703         error = decode_nfsstat3(&xdr, &status);
1704         if (unlikely(error))
1705                 goto out;
1706         error = decode_wcc_data(&xdr, result->fattr);
1707         if (unlikely(error))
1708                 goto out;
1709         if (status != NFS3_OK)
1710                 goto out_status;
1711         error = decode_write3resok(&xdr, result);
1712 out:
1713         return error;
1714 out_status:
1715         return nfs_stat_to_errno(status);
1716 }
1717
1718 /*
1719  * 3.3.8  CREATE3res
1720  *
1721  *      struct CREATE3resok {
1722  *              post_op_fh3     obj;
1723  *              post_op_attr    obj_attributes;
1724  *              wcc_data        dir_wcc;
1725  *      };
1726  *
1727  *      struct CREATE3resfail {
1728  *              wcc_data        dir_wcc;
1729  *      };
1730  *
1731  *      union CREATE3res switch (nfsstat3 status) {
1732  *      case NFS3_OK:
1733  *              CREATE3resok    resok;
1734  *      default:
1735  *              CREATE3resfail  resfail;
1736  *      };
1737  */
1738 static int decode_create3resok(struct xdr_stream *xdr,
1739                                struct nfs3_diropres *result)
1740 {
1741         int error;
1742
1743         error = decode_post_op_fh3(xdr, result->fh);
1744         if (unlikely(error))
1745                 goto out;
1746         error = decode_post_op_attr(xdr, result->fattr);
1747         if (unlikely(error))
1748                 goto out;
1749         /* The server isn't required to return a file handle.
1750          * If it didn't, force the client to perform a LOOKUP
1751          * to determine the correct file handle and attribute
1752          * values for the new object. */
1753         if (result->fh->size == 0)
1754                 result->fattr->valid = 0;
1755         error = decode_wcc_data(xdr, result->dir_attr);
1756 out:
1757         return error;
1758 }
1759
1760 static int nfs3_xdr_dec_create3res(struct rpc_rqst *req, __be32 *p,
1761                                    struct nfs3_diropres *result)
1762 {
1763         struct xdr_stream xdr;
1764         enum nfs_stat status;
1765         int error;
1766
1767         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1768         error = decode_nfsstat3(&xdr, &status);
1769         if (unlikely(error))
1770                 goto out;
1771         if (status != NFS3_OK)
1772                 goto out_default;
1773         error = decode_create3resok(&xdr, result);
1774 out:
1775         return error;
1776 out_default:
1777         error = decode_wcc_data(&xdr, result->dir_attr);
1778         if (unlikely(error))
1779                 goto out;
1780         return nfs_stat_to_errno(status);
1781 }
1782
1783 /*
1784  * 3.3.12  REMOVE3res
1785  *
1786  *      struct REMOVE3resok {
1787  *              wcc_data    dir_wcc;
1788  *      };
1789  *
1790  *      struct REMOVE3resfail {
1791  *              wcc_data    dir_wcc;
1792  *      };
1793  *
1794  *      union REMOVE3res switch (nfsstat3 status) {
1795  *      case NFS3_OK:
1796  *              REMOVE3resok   resok;
1797  *      default:
1798  *              REMOVE3resfail resfail;
1799  *      };
1800  */
1801 static int nfs3_xdr_dec_remove3res(struct rpc_rqst *req, __be32 *p,
1802                                    struct nfs_removeres *result)
1803 {
1804         struct xdr_stream xdr;
1805         enum nfs_stat status;
1806         int error;
1807
1808         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1809         error = decode_nfsstat3(&xdr, &status);
1810         if (unlikely(error))
1811                 goto out;
1812         error = decode_wcc_data(&xdr, result->dir_attr);
1813         if (unlikely(error))
1814                 goto out;
1815         if (status != NFS3_OK)
1816                 goto out_status;
1817 out:
1818         return error;
1819 out_status:
1820         return nfs_stat_to_errno(status);
1821 }
1822
1823 /*
1824  * 3.3.14  RENAME3res
1825  *
1826  *      struct RENAME3resok {
1827  *              wcc_data        fromdir_wcc;
1828  *              wcc_data        todir_wcc;
1829  *      };
1830  *
1831  *      struct RENAME3resfail {
1832  *              wcc_data        fromdir_wcc;
1833  *              wcc_data        todir_wcc;
1834  *      };
1835  *
1836  *      union RENAME3res switch (nfsstat3 status) {
1837  *      case NFS3_OK:
1838  *              RENAME3resok   resok;
1839  *      default:
1840  *              RENAME3resfail resfail;
1841  *      };
1842  */
1843 static int nfs3_xdr_dec_rename3res(struct rpc_rqst *req, __be32 *p,
1844                                    struct nfs_renameres *result)
1845 {
1846         struct xdr_stream xdr;
1847         enum nfs_stat status;
1848         int error;
1849
1850         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1851         error = decode_nfsstat3(&xdr, &status);
1852         if (unlikely(error))
1853                 goto out;
1854         error = decode_wcc_data(&xdr, result->old_fattr);
1855         if (unlikely(error))
1856                 goto out;
1857         error = decode_wcc_data(&xdr, result->new_fattr);
1858         if (unlikely(error))
1859                 goto out;
1860         if (status != NFS3_OK)
1861                 goto out_status;
1862 out:
1863         return error;
1864 out_status:
1865         return nfs_stat_to_errno(status);
1866 }
1867
1868 /*
1869  * 3.3.15  LINK3res
1870  *
1871  *      struct LINK3resok {
1872  *              post_op_attr    file_attributes;
1873  *              wcc_data        linkdir_wcc;
1874  *      };
1875  *
1876  *      struct LINK3resfail {
1877  *              post_op_attr    file_attributes;
1878  *              wcc_data        linkdir_wcc;
1879  *      };
1880  *
1881  *      union LINK3res switch (nfsstat3 status) {
1882  *      case NFS3_OK:
1883  *              LINK3resok      resok;
1884  *      default:
1885  *              LINK3resfail    resfail;
1886  *      };
1887  */
1888 static int nfs3_xdr_dec_link3res(struct rpc_rqst *req, __be32 *p,
1889                                  struct nfs3_linkres *result)
1890 {
1891         struct xdr_stream xdr;
1892         enum nfs_stat status;
1893         int error;
1894
1895         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1896         error = decode_nfsstat3(&xdr, &status);
1897         if (unlikely(error))
1898                 goto out;
1899         error = decode_post_op_attr(&xdr, result->fattr);
1900         if (unlikely(error))
1901                 goto out;
1902         error = decode_wcc_data(&xdr, result->dir_attr);
1903         if (unlikely(error))
1904                 goto out;
1905         if (status != NFS3_OK)
1906                 goto out_status;
1907 out:
1908         return error;
1909 out_status:
1910         return nfs_stat_to_errno(status);
1911 }
1912
1913 /**
1914  * nfs3_decode_dirent - Decode a single NFSv3 directory entry stored in
1915  *                      the local page cache
1916  * @xdr: XDR stream where entry resides
1917  * @entry: buffer to fill in with entry data
1918  * @plus: boolean indicating whether this should be a readdirplus entry
1919  *
1920  * Returns zero if successful, otherwise a negative errno value is
1921  * returned.
1922  *
1923  * This function is not invoked during READDIR reply decoding, but
1924  * rather whenever an application invokes the getdents(2) system call
1925  * on a directory already in our cache.
1926  *
1927  * 3.3.16  entry3
1928  *
1929  *      struct entry3 {
1930  *              fileid3         fileid;
1931  *              filename3       name;
1932  *              cookie3         cookie;
1933  *              fhandle3        filehandle;
1934  *              post_op_attr3   attributes;
1935  *              entry3          *nextentry;
1936  *      };
1937  *
1938  * 3.3.17  entryplus3
1939  *      struct entryplus3 {
1940  *              fileid3         fileid;
1941  *              filename3       name;
1942  *              cookie3         cookie;
1943  *              post_op_attr    name_attributes;
1944  *              post_op_fh3     name_handle;
1945  *              entryplus3      *nextentry;
1946  *      };
1947  */
1948 int nfs3_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry,
1949                        int plus)
1950 {
1951         struct nfs_entry old = *entry;
1952         __be32 *p;
1953         int error;
1954
1955         p = xdr_inline_decode(xdr, 4);
1956         if (unlikely(p == NULL))
1957                 goto out_overflow;
1958         if (*p == xdr_zero) {
1959                 p = xdr_inline_decode(xdr, 4);
1960                 if (unlikely(p == NULL))
1961                         goto out_overflow;
1962                 if (*p == xdr_zero)
1963                         return -EAGAIN;
1964                 entry->eof = 1;
1965                 return -EBADCOOKIE;
1966         }
1967
1968         error = decode_fileid3(xdr, &entry->ino);
1969         if (unlikely(error))
1970                 return error;
1971
1972         error = decode_inline_filename3(xdr, &entry->name, &entry->len);
1973         if (unlikely(error))
1974                 return error;
1975
1976         entry->prev_cookie = entry->cookie;
1977         error = decode_cookie3(xdr, &entry->cookie);
1978         if (unlikely(error))
1979                 return error;
1980
1981         entry->d_type = DT_UNKNOWN;
1982
1983         if (plus) {
1984                 entry->fattr->valid = 0;
1985                 error = decode_post_op_attr(xdr, entry->fattr);
1986                 if (unlikely(error))
1987                         return error;
1988                 if (entry->fattr->valid & NFS_ATTR_FATTR_V3)
1989                         entry->d_type = nfs_umode_to_dtype(entry->fattr->mode);
1990
1991                 /* In fact, a post_op_fh3: */
1992                 p = xdr_inline_decode(xdr, 4);
1993                 if (unlikely(p == NULL))
1994                         goto out_overflow;
1995                 if (*p != xdr_zero) {
1996                         error = decode_nfs_fh3(xdr, entry->fh);
1997                         if (unlikely(error)) {
1998                                 if (error == -E2BIG)
1999                                         goto out_truncated;
2000                                 return error;
2001                         }
2002                 } else
2003                         zero_nfs_fh3(entry->fh);
2004         }
2005
2006         /* Peek at the next entry to see if we're at EOD */
2007         p = xdr_inline_peek(xdr, 4 + 4);
2008         entry->eof = 0;
2009         if (p != NULL)
2010                 entry->eof = (p[0] == xdr_zero) && (p[1] != xdr_zero);
2011         return 0;
2012
2013 out_overflow:
2014         print_overflow_msg(__func__, xdr);
2015         return -EAGAIN;
2016 out_truncated:
2017         dprintk("NFS: directory entry contains invalid file handle\n");
2018         *entry = old;
2019         return -EAGAIN;
2020 }
2021
2022 /*
2023  * 3.3.16  READDIR3res
2024  *
2025  *      struct dirlist3 {
2026  *              entry3          *entries;
2027  *              bool            eof;
2028  *      };
2029  *
2030  *      struct READDIR3resok {
2031  *              post_op_attr    dir_attributes;
2032  *              cookieverf3     cookieverf;
2033  *              dirlist3        reply;
2034  *      };
2035  *
2036  *      struct READDIR3resfail {
2037  *              post_op_attr    dir_attributes;
2038  *      };
2039  *
2040  *      union READDIR3res switch (nfsstat3 status) {
2041  *      case NFS3_OK:
2042  *              READDIR3resok   resok;
2043  *      default:
2044  *              READDIR3resfail resfail;
2045  *      };
2046  *
2047  * Read the directory contents into the page cache, but otherwise
2048  * don't touch them.  The actual decoding is done by nfs3_decode_entry()
2049  * during subsequent nfs_readdir() calls.
2050  */
2051 static int decode_dirlist3(struct xdr_stream *xdr)
2052 {
2053         u32 recvd, pglen;
2054         size_t hdrlen;
2055
2056         pglen = xdr->buf->page_len;
2057         hdrlen = (u8 *)xdr->p - (u8 *)xdr->iov->iov_base;
2058         recvd = xdr->buf->len - hdrlen;
2059         if (unlikely(pglen > recvd))
2060                 goto out_cheating;
2061 out:
2062         xdr_read_pages(xdr, pglen);
2063         return pglen;
2064 out_cheating:
2065         dprintk("NFS: server cheating in readdir result: "
2066                 "pglen %u > recvd %u\n", pglen, recvd);
2067         pglen = recvd;
2068         goto out;
2069 }
2070
2071 static int decode_readdir3resok(struct xdr_stream *xdr,
2072                                 struct nfs3_readdirres *result)
2073 {
2074         int error;
2075
2076         error = decode_post_op_attr(xdr, result->dir_attr);
2077         if (unlikely(error))
2078                 goto out;
2079         /* XXX: do we need to check if result->verf != NULL ? */
2080         error = decode_cookieverf3(xdr, result->verf);
2081         if (unlikely(error))
2082                 goto out;
2083         error = decode_dirlist3(xdr);
2084 out:
2085         return error;
2086 }
2087
2088 static int nfs3_xdr_dec_readdir3res(struct rpc_rqst *req, __be32 *p,
2089                                     struct nfs3_readdirres *result)
2090 {
2091         struct xdr_stream xdr;
2092         enum nfs_stat status;
2093         int error;
2094
2095         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
2096         error = decode_nfsstat3(&xdr, &status);
2097         if (unlikely(error))
2098                 goto out;
2099         if (status != NFS3_OK)
2100                 goto out_default;
2101         error = decode_readdir3resok(&xdr, result);
2102 out:
2103         return error;
2104 out_default:
2105         error = decode_post_op_attr(&xdr, result->dir_attr);
2106         if (unlikely(error))
2107                 goto out;
2108         return nfs_stat_to_errno(status);
2109 }
2110
2111 /*
2112  * 3.3.18  FSSTAT3res
2113  *
2114  *      struct FSSTAT3resok {
2115  *              post_op_attr    obj_attributes;
2116  *              size3           tbytes;
2117  *              size3           fbytes;
2118  *              size3           abytes;
2119  *              size3           tfiles;
2120  *              size3           ffiles;
2121  *              size3           afiles;
2122  *              uint32          invarsec;
2123  *      };
2124  *
2125  *      struct FSSTAT3resfail {
2126  *              post_op_attr    obj_attributes;
2127  *      };
2128  *
2129  *      union FSSTAT3res switch (nfsstat3 status) {
2130  *      case NFS3_OK:
2131  *              FSSTAT3resok    resok;
2132  *      default:
2133  *              FSSTAT3resfail  resfail;
2134  *      };
2135  */
2136 static int decode_fsstat3resok(struct xdr_stream *xdr,
2137                                struct nfs_fsstat *result)
2138 {
2139         __be32 *p;
2140
2141         p = xdr_inline_decode(xdr, 8 * 6 + 4);
2142         if (unlikely(p == NULL))
2143                 goto out_overflow;
2144         p = xdr_decode_size3(p, &result->tbytes);
2145         p = xdr_decode_size3(p, &result->fbytes);
2146         p = xdr_decode_size3(p, &result->abytes);
2147         p = xdr_decode_size3(p, &result->tfiles);
2148         p = xdr_decode_size3(p, &result->ffiles);
2149         xdr_decode_size3(p, &result->afiles);
2150         /* ignore invarsec */
2151         return 0;
2152 out_overflow:
2153         print_overflow_msg(__func__, xdr);
2154         return -EIO;
2155 }
2156
2157 static int nfs3_xdr_dec_fsstat3res(struct rpc_rqst *req, __be32 *p,
2158                                    struct nfs_fsstat *result)
2159 {
2160         struct xdr_stream xdr;
2161         enum nfs_stat status;
2162         int error;
2163
2164         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
2165         error = decode_nfsstat3(&xdr, &status);
2166         if (unlikely(error))
2167                 goto out;
2168         error = decode_post_op_attr(&xdr, result->fattr);
2169         if (unlikely(error))
2170                 goto out;
2171         if (status != NFS3_OK)
2172                 goto out_status;
2173         error = decode_fsstat3resok(&xdr, result);
2174 out:
2175         return error;
2176 out_status:
2177         return nfs_stat_to_errno(status);
2178 }
2179
2180 /*
2181  * 3.3.19  FSINFO3res
2182  *
2183  *      struct FSINFO3resok {
2184  *              post_op_attr    obj_attributes;
2185  *              uint32          rtmax;
2186  *              uint32          rtpref;
2187  *              uint32          rtmult;
2188  *              uint32          wtmax;
2189  *              uint32          wtpref;
2190  *              uint32          wtmult;
2191  *              uint32          dtpref;
2192  *              size3           maxfilesize;
2193  *              nfstime3        time_delta;
2194  *              uint32          properties;
2195  *      };
2196  *
2197  *      struct FSINFO3resfail {
2198  *              post_op_attr    obj_attributes;
2199  *      };
2200  *
2201  *      union FSINFO3res switch (nfsstat3 status) {
2202  *      case NFS3_OK:
2203  *              FSINFO3resok    resok;
2204  *      default:
2205  *              FSINFO3resfail  resfail;
2206  *      };
2207  */
2208 static int decode_fsinfo3resok(struct xdr_stream *xdr,
2209                                struct nfs_fsinfo *result)
2210 {
2211         __be32 *p;
2212
2213         p = xdr_inline_decode(xdr, 4 * 7 + 8 + 8 + 4);
2214         if (unlikely(p == NULL))
2215                 goto out_overflow;
2216         result->rtmax  = be32_to_cpup(p++);
2217         result->rtpref = be32_to_cpup(p++);
2218         result->rtmult = be32_to_cpup(p++);
2219         result->wtmax  = be32_to_cpup(p++);
2220         result->wtpref = be32_to_cpup(p++);
2221         result->wtmult = be32_to_cpup(p++);
2222         result->dtpref = be32_to_cpup(p++);
2223         p = xdr_decode_size3(p, &result->maxfilesize);
2224         xdr_decode_nfstime3(p, &result->time_delta);
2225
2226         /* ignore properties */
2227         result->lease_time = 0;
2228         return 0;
2229 out_overflow:
2230         print_overflow_msg(__func__, xdr);
2231         return -EIO;
2232 }
2233
2234 static int nfs3_xdr_dec_fsinfo3res(struct rpc_rqst *req, __be32 *p,
2235                                    struct nfs_fsinfo *result)
2236 {
2237         struct xdr_stream xdr;
2238         enum nfs_stat status;
2239         int error;
2240
2241         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
2242         error = decode_nfsstat3(&xdr, &status);
2243         if (unlikely(error))
2244                 goto out;
2245         error = decode_post_op_attr(&xdr, result->fattr);
2246         if (unlikely(error))
2247                 goto out;
2248         if (status != NFS3_OK)
2249                 goto out_status;
2250         error = decode_fsinfo3resok(&xdr, result);
2251 out:
2252         return error;
2253 out_status:
2254         return nfs_stat_to_errno(status);
2255 }
2256
2257 /*
2258  * 3.3.20  PATHCONF3res
2259  *
2260  *      struct PATHCONF3resok {
2261  *              post_op_attr    obj_attributes;
2262  *              uint32          linkmax;
2263  *              uint32          name_max;
2264  *              bool            no_trunc;
2265  *              bool            chown_restricted;
2266  *              bool            case_insensitive;
2267  *              bool            case_preserving;
2268  *      };
2269  *
2270  *      struct PATHCONF3resfail {
2271  *              post_op_attr    obj_attributes;
2272  *      };
2273  *
2274  *      union PATHCONF3res switch (nfsstat3 status) {
2275  *      case NFS3_OK:
2276  *              PATHCONF3resok  resok;
2277  *      default:
2278  *              PATHCONF3resfail resfail;
2279  *      };
2280  */
2281 static int decode_pathconf3resok(struct xdr_stream *xdr,
2282                                  struct nfs_pathconf *result)
2283 {
2284         __be32 *p;
2285
2286         p = xdr_inline_decode(xdr, 4 * 6);
2287         if (unlikely(p == NULL))
2288                 goto out_overflow;
2289         result->max_link = be32_to_cpup(p++);
2290         result->max_namelen = be32_to_cpup(p);
2291         /* ignore remaining fields */
2292         return 0;
2293 out_overflow:
2294         print_overflow_msg(__func__, xdr);
2295         return -EIO;
2296 }
2297
2298 static int nfs3_xdr_dec_pathconf3res(struct rpc_rqst *req, __be32 *p,
2299                                      struct nfs_pathconf *result)
2300 {
2301         struct xdr_stream xdr;
2302         enum nfs_stat status;
2303         int error;
2304
2305         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
2306         error = decode_nfsstat3(&xdr, &status);
2307         if (unlikely(error))
2308                 goto out;
2309         error = decode_post_op_attr(&xdr, result->fattr);
2310         if (unlikely(error))
2311                 goto out;
2312         if (status != NFS3_OK)
2313                 goto out_status;
2314         error = decode_pathconf3resok(&xdr, result);
2315 out:
2316         return error;
2317 out_status:
2318         return nfs_stat_to_errno(status);
2319 }
2320
2321 /*
2322  * 3.3.21  COMMIT3res
2323  *
2324  *      struct COMMIT3resok {
2325  *              wcc_data        file_wcc;
2326  *              writeverf3      verf;
2327  *      };
2328  *
2329  *      struct COMMIT3resfail {
2330  *              wcc_data        file_wcc;
2331  *      };
2332  *
2333  *      union COMMIT3res switch (nfsstat3 status) {
2334  *      case NFS3_OK:
2335  *              COMMIT3resok    resok;
2336  *      default:
2337  *              COMMIT3resfail  resfail;
2338  *      };
2339  */
2340 static int nfs3_xdr_dec_commit3res(struct rpc_rqst *req, __be32 *p,
2341                                    struct nfs_writeres *result)
2342 {
2343         struct xdr_stream xdr;
2344         enum nfs_stat status;
2345         int error;
2346
2347         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
2348         error = decode_nfsstat3(&xdr, &status);
2349         if (unlikely(error))
2350                 goto out;
2351         error = decode_wcc_data(&xdr, result->fattr);
2352         if (unlikely(error))
2353                 goto out;
2354         if (status != NFS3_OK)
2355                 goto out_status;
2356         error = decode_writeverf3(&xdr, result->verf->verifier);
2357 out:
2358         return error;
2359 out_status:
2360         return nfs_stat_to_errno(status);
2361 }
2362
2363 #ifdef CONFIG_NFS_V3_ACL
2364
2365 static inline int decode_getacl3resok(struct xdr_stream *xdr,
2366                                       struct nfs3_getaclres *result)
2367 {
2368         struct posix_acl **acl;
2369         unsigned int *aclcnt;
2370         size_t hdrlen;
2371         int error;
2372
2373         error = decode_post_op_attr(xdr, result->fattr);
2374         if (unlikely(error))
2375                 goto out;
2376         error = decode_uint32(xdr, &result->mask);
2377         if (unlikely(error))
2378                 goto out;
2379         error = -EINVAL;
2380         if (result->mask & ~(NFS_ACL|NFS_ACLCNT|NFS_DFACL|NFS_DFACLCNT))
2381                 goto out;
2382
2383         hdrlen = (u8 *)xdr->p - (u8 *)xdr->iov->iov_base;
2384
2385         acl = NULL;
2386         if (result->mask & NFS_ACL)
2387                 acl = &result->acl_access;
2388         aclcnt = NULL;
2389         if (result->mask & NFS_ACLCNT)
2390                 aclcnt = &result->acl_access_count;
2391         error = nfsacl_decode(xdr->buf, hdrlen, aclcnt, acl);
2392         if (unlikely(error <= 0))
2393                 goto out;
2394
2395         acl = NULL;
2396         if (result->mask & NFS_DFACL)
2397                 acl = &result->acl_default;
2398         aclcnt = NULL;
2399         if (result->mask & NFS_DFACLCNT)
2400                 aclcnt = &result->acl_default_count;
2401         error = nfsacl_decode(xdr->buf, hdrlen + error, aclcnt, acl);
2402         if (unlikely(error <= 0))
2403                 return error;
2404         error = 0;
2405 out:
2406         return error;
2407 }
2408
2409 static int nfs3_xdr_dec_getacl3res(struct rpc_rqst *req, __be32 *p,
2410                                    struct nfs3_getaclres *result)
2411 {
2412         struct xdr_stream xdr;
2413         enum nfs_stat status;
2414         int error;
2415
2416         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
2417         error = decode_nfsstat3(&xdr, &status);
2418         if (unlikely(error))
2419                 goto out;
2420         if (status != NFS3_OK)
2421                 goto out_default;
2422         error = decode_getacl3resok(&xdr, result);
2423 out:
2424         return error;
2425 out_default:
2426         return nfs_stat_to_errno(status);
2427 }
2428
2429 static int nfs3_xdr_dec_setacl3res(struct rpc_rqst *req, __be32 *p,
2430                                    struct nfs_fattr *result)
2431 {
2432         struct xdr_stream xdr;
2433         enum nfs_stat status;
2434         int error;
2435
2436         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
2437         error = decode_nfsstat3(&xdr, &status);
2438         if (unlikely(error))
2439                 goto out;
2440         if (status != NFS3_OK)
2441                 goto out_default;
2442         error = decode_post_op_attr(&xdr, result);
2443 out:
2444         return error;
2445 out_default:
2446         return nfs_stat_to_errno(status);
2447 }
2448
2449 #endif  /* CONFIG_NFS_V3_ACL */
2450
2451 #define PROC(proc, argtype, restype, timer)                             \
2452 [NFS3PROC_##proc] = {                                                   \
2453         .p_proc      = NFS3PROC_##proc,                                 \
2454         .p_encode    = (kxdreproc_t)nfs3_xdr_enc_##argtype##3args,      \
2455         .p_decode    = (kxdrproc_t)nfs3_xdr_dec_##restype##3res,        \
2456         .p_arglen    = NFS3_##argtype##args_sz,                         \
2457         .p_replen    = NFS3_##restype##res_sz,                          \
2458         .p_timer     = timer,                                           \
2459         .p_statidx   = NFS3PROC_##proc,                                 \
2460         .p_name      = #proc,                                           \
2461         }
2462
2463 struct rpc_procinfo     nfs3_procedures[] = {
2464         PROC(GETATTR,           getattr,        getattr,        1),
2465         PROC(SETATTR,           setattr,        setattr,        0),
2466         PROC(LOOKUP,            lookup,         lookup,         2),
2467         PROC(ACCESS,            access,         access,         1),
2468         PROC(READLINK,          readlink,       readlink,       3),
2469         PROC(READ,              read,           read,           3),
2470         PROC(WRITE,             write,          write,          4),
2471         PROC(CREATE,            create,         create,         0),
2472         PROC(MKDIR,             mkdir,          create,         0),
2473         PROC(SYMLINK,           symlink,        create,         0),
2474         PROC(MKNOD,             mknod,          create,         0),
2475         PROC(REMOVE,            remove,         remove,         0),
2476         PROC(RMDIR,             lookup,         setattr,        0),
2477         PROC(RENAME,            rename,         rename,         0),
2478         PROC(LINK,              link,           link,           0),
2479         PROC(READDIR,           readdir,        readdir,        3),
2480         PROC(READDIRPLUS,       readdirplus,    readdir,        3),
2481         PROC(FSSTAT,            getattr,        fsstat,         0),
2482         PROC(FSINFO,            getattr,        fsinfo,         0),
2483         PROC(PATHCONF,          getattr,        pathconf,       0),
2484         PROC(COMMIT,            commit,         commit,         5),
2485 };
2486
2487 struct rpc_version              nfs_version3 = {
2488         .number                 = 3,
2489         .nrprocs                = ARRAY_SIZE(nfs3_procedures),
2490         .procs                  = nfs3_procedures
2491 };
2492
2493 #ifdef CONFIG_NFS_V3_ACL
2494 static struct rpc_procinfo      nfs3_acl_procedures[] = {
2495         [ACLPROC3_GETACL] = {
2496                 .p_proc = ACLPROC3_GETACL,
2497                 .p_encode = (kxdreproc_t)nfs3_xdr_enc_getacl3args,
2498                 .p_decode = (kxdrproc_t)nfs3_xdr_dec_getacl3res,
2499                 .p_arglen = ACL3_getaclargs_sz,
2500                 .p_replen = ACL3_getaclres_sz,
2501                 .p_timer = 1,
2502                 .p_name = "GETACL",
2503         },
2504         [ACLPROC3_SETACL] = {
2505                 .p_proc = ACLPROC3_SETACL,
2506                 .p_encode = (kxdreproc_t)nfs3_xdr_enc_setacl3args,
2507                 .p_decode = (kxdrproc_t)nfs3_xdr_dec_setacl3res,
2508                 .p_arglen = ACL3_setaclargs_sz,
2509                 .p_replen = ACL3_setaclres_sz,
2510                 .p_timer = 0,
2511                 .p_name = "SETACL",
2512         },
2513 };
2514
2515 struct rpc_version              nfsacl_version3 = {
2516         .number                 = 3,
2517         .nrprocs                = sizeof(nfs3_acl_procedures)/
2518                                   sizeof(nfs3_acl_procedures[0]),
2519         .procs                  = nfs3_acl_procedures,
2520 };
2521 #endif  /* CONFIG_NFS_V3_ACL */