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 int nfs3_xdr_enc_getattr3args(struct rpc_rqst *req, __be32 *p,
 839                                      const struct nfs_fh *fh)
 840 {
 841         struct xdr_stream xdr;
 842
 843         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
 844         encode_nfs_fh3(&xdr, fh);
 845         return 0;
 846 }
 847
 848 /*
 849  * 3.3.2  SETATTR3args
 850  *
 851  *      union sattrguard3 switch (bool check) {
 852  *      case TRUE:
 853  *              nfstime3  obj_ctime;
 854  *      case FALSE:
 855  *              void;
 856  *      };
 857  *
 858  *      struct SETATTR3args {
 859  *              nfs_fh3         object;
 860  *              sattr3          new_attributes;
 861  *              sattrguard3     guard;
 862  *      };
 863  */
 864 static void encode_sattrguard3(struct xdr_stream *xdr,
 865                                const struct nfs3_sattrargs *args)
 866 {
 867         __be32 *p;
 868
 869         if (args->guard) {
 870                 p = xdr_reserve_space(xdr, 4 + 8);
 871                 *p++ = xdr_one;
 872                 xdr_encode_nfstime3(p, &args->guardtime);
 873         } else {
 874                 p = xdr_reserve_space(xdr, 4);
 875                 *p = xdr_zero;
 876         }
 877 }
 878
 879 static int nfs3_xdr_enc_setattr3args(struct rpc_rqst *req, __be32 *p,
 880                                      const struct nfs3_sattrargs *args)
 881 {
 882         struct xdr_stream xdr;
 883
 884         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
 885         encode_nfs_fh3(&xdr, args->fh);
 886         encode_sattr3(&xdr, args->sattr);
 887         encode_sattrguard3(&xdr, args);
 888         return 0;
 889 }
 890
 891 /*
 892  * 3.3.3  LOOKUP3args
 893  *
 894  *      struct LOOKUP3args {
 895  *              diropargs3  what;
 896  *      };
 897  */
 898 static int nfs3_xdr_enc_lookup3args(struct rpc_rqst *req, __be32 *p,
 899                                     const struct nfs3_diropargs *args)
 900 {
 901         struct xdr_stream xdr;
 902
 903         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
 904         encode_diropargs3(&xdr, args->fh, args->name, args->len);
 905         return 0;
 906 }
 907
 908 /*
 909  * 3.3.4  ACCESS3args
 910  *
 911  *      struct ACCESS3args {
 912  *              nfs_fh3         object;
 913  *              uint32          access;
 914  *      };
 915  */
 916 static void encode_access3args(struct xdr_stream *xdr,
 917                                const struct nfs3_accessargs *args)
 918 {
 919         encode_nfs_fh3(xdr, args->fh);
 920         encode_uint32(xdr, args->access);
 921 }
 922
 923 static int nfs3_xdr_enc_access3args(struct rpc_rqst *req, __be32 *p,
 924                                     const struct nfs3_accessargs *args)
 925 {
 926         struct xdr_stream xdr;
 927
 928         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
 929         encode_access3args(&xdr, args);
 930         return 0;
 931 }
 932
 933 /*
 934  * 3.3.5  READLINK3args
 935  *
 936  *      struct READLINK3args {
 937  *              nfs_fh3 symlink;
 938  *      };
 939  */
 940 static int nfs3_xdr_enc_readlink3args(struct rpc_rqst *req, __be32 *p,
 941                                       const struct nfs3_readlinkargs *args)
 942 {
 943         struct xdr_stream xdr;
 944
 945         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
 946         encode_nfs_fh3(&xdr, args->fh);
 947         prepare_reply_buffer(req, args->pages, args->pgbase,
 948                                         args->pglen, NFS3_readlinkres_sz);
 949         return 0;
 950 }
 951
 952 /*
 953  * 3.3.6  READ3args
 954  *
 955  *      struct READ3args {
 956  *              nfs_fh3         file;
 957  *              offset3         offset;
 958  *              count3          count;
 959  *      };
 960  */
 961 static void encode_read3args(struct xdr_stream *xdr,
 962                              const struct nfs_readargs *args)
 963 {
 964         __be32 *p;
 965
 966         encode_nfs_fh3(xdr, args->fh);
 967
 968         p = xdr_reserve_space(xdr, 8 + 4);
 969         p = xdr_encode_hyper(p, args->offset);
 970         *p = cpu_to_be32(args->count);
 971 }
 972
 973 static int nfs3_xdr_enc_read3args(struct rpc_rqst *req, __be32 *p,
 974                                   const struct nfs_readargs *args)
 975 {
 976         struct xdr_stream xdr;
 977
 978         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
 979         encode_read3args(&xdr, args);
 980         prepare_reply_buffer(req, args->pages, args->pgbase,
 981                                         args->count, NFS3_readres_sz);
 982         req->rq_rcv_buf.flags |= XDRBUF_READ;
 983         return 0;
 984 }
 985
 986 /*
 987  * 3.3.7  WRITE3args
 988  *
 989  *      enum stable_how {
 990  *              UNSTABLE  = 0,
 991  *              DATA_SYNC = 1,
 992  *              FILE_SYNC = 2
 993  *      };
 994  *
 995  *      struct WRITE3args {
 996  *              nfs_fh3         file;
 997  *              offset3         offset;
 998  *              count3          count;
 999  *              stable_how      stable;
1000  *              opaque          data<>;
1001  *      };
1002  */
1003 static void encode_write3args(struct xdr_stream *xdr,
1004                               const struct nfs_writeargs *args)
1005 {
1006         __be32 *p;
1007
1008         encode_nfs_fh3(xdr, args->fh);
1009
1010         p = xdr_reserve_space(xdr, 8 + 4 + 4 + 4);
1011         p = xdr_encode_hyper(p, args->offset);
1012         *p++ = cpu_to_be32(args->count);
1013         *p++ = cpu_to_be32(args->stable);
1014         *p = cpu_to_be32(args->count);
1015         xdr_write_pages(xdr, args->pages, args->pgbase, args->count);
1016 }
1017
1018 static int nfs3_xdr_enc_write3args(struct rpc_rqst *req, __be32 *p,
1019                                    const struct nfs_writeargs *args)
1020 {
1021         struct xdr_stream xdr;
1022
1023         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1024         encode_write3args(&xdr, args);
1025         xdr.buf->flags |= XDRBUF_WRITE;
1026         return 0;
1027 }
1028
1029 /*
1030  * 3.3.8  CREATE3args
1031  *
1032  *      enum createmode3 {
1033  *              UNCHECKED = 0,
1034  *              GUARDED   = 1,
1035  *              EXCLUSIVE = 2
1036  *      };
1037  *
1038  *      union createhow3 switch (createmode3 mode) {
1039  *      case UNCHECKED:
1040  *      case GUARDED:
1041  *              sattr3       obj_attributes;
1042  *      case EXCLUSIVE:
1043  *              createverf3  verf;
1044  *      };
1045  *
1046  *      struct CREATE3args {
1047  *              diropargs3      where;
1048  *              createhow3      how;
1049  *      };
1050  */
1051 static void encode_createhow3(struct xdr_stream *xdr,
1052                               const struct nfs3_createargs *args)
1053 {
1054         encode_uint32(xdr, args->createmode);
1055         switch (args->createmode) {
1056         case NFS3_CREATE_UNCHECKED:
1057         case NFS3_CREATE_GUARDED:
1058                 encode_sattr3(xdr, args->sattr);
1059                 break;
1060         case NFS3_CREATE_EXCLUSIVE:
1061                 encode_createverf3(xdr, args->verifier);
1062                 break;
1063         default:
1064                 BUG();
1065         }
1066 }
1067
1068 static int nfs3_xdr_enc_create3args(struct rpc_rqst *req, __be32 *p,
1069                                     const struct nfs3_createargs *args)
1070 {
1071         struct xdr_stream xdr;
1072
1073         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1074         encode_diropargs3(&xdr, args->fh, args->name, args->len);
1075         encode_createhow3(&xdr, args);
1076         return 0;
1077 }
1078
1079 /*
1080  * 3.3.9  MKDIR3args
1081  *
1082  *      struct MKDIR3args {
1083  *              diropargs3      where;
1084  *              sattr3          attributes;
1085  *      };
1086  */
1087 static int nfs3_xdr_enc_mkdir3args(struct rpc_rqst *req, __be32 *p,
1088                                    const struct nfs3_mkdirargs *args)
1089 {
1090         struct xdr_stream xdr;
1091
1092         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1093         encode_diropargs3(&xdr, args->fh, args->name, args->len);
1094         encode_sattr3(&xdr, args->sattr);
1095         return 0;
1096 }
1097
1098 /*
1099  * 3.3.10  SYMLINK3args
1100  *
1101  *      struct symlinkdata3 {
1102  *              sattr3          symlink_attributes;
1103  *              nfspath3        symlink_data;
1104  *      };
1105  *
1106  *      struct SYMLINK3args {
1107  *              diropargs3      where;
1108  *              symlinkdata3    symlink;
1109  *      };
1110  */
1111 static void encode_symlinkdata3(struct xdr_stream *xdr,
1112                                 const struct nfs3_symlinkargs *args)
1113 {
1114         encode_sattr3(xdr, args->sattr);
1115         encode_nfspath3(xdr, args->pages, args->pathlen);
1116 }
1117
1118 static int nfs3_xdr_enc_symlink3args(struct rpc_rqst *req, __be32 *p,
1119                                      const struct nfs3_symlinkargs *args)
1120 {
1121         struct xdr_stream xdr;
1122
1123         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1124         encode_diropargs3(&xdr, args->fromfh, args->fromname, args->fromlen);
1125         encode_symlinkdata3(&xdr, args);
1126         return 0;
1127 }
1128
1129 /*
1130  * 3.3.11  MKNOD3args
1131  *
1132  *      struct devicedata3 {
1133  *              sattr3          dev_attributes;
1134  *              specdata3       spec;
1135  *      };
1136  *
1137  *      union mknoddata3 switch (ftype3 type) {
1138  *      case NF3CHR:
1139  *      case NF3BLK:
1140  *              devicedata3     device;
1141  *      case NF3SOCK:
1142  *      case NF3FIFO:
1143  *              sattr3          pipe_attributes;
1144  *      default:
1145  *              void;
1146  *      };
1147  *
1148  *      struct MKNOD3args {
1149  *              diropargs3      where;
1150  *              mknoddata3      what;
1151  *      };
1152  */
1153 static void encode_devicedata3(struct xdr_stream *xdr,
1154                                const struct nfs3_mknodargs *args)
1155 {
1156         encode_sattr3(xdr, args->sattr);
1157         encode_specdata3(xdr, args->rdev);
1158 }
1159
1160 static void encode_mknoddata3(struct xdr_stream *xdr,
1161                               const struct nfs3_mknodargs *args)
1162 {
1163         encode_ftype3(xdr, args->type);
1164         switch (args->type) {
1165         case NF3CHR:
1166         case NF3BLK:
1167                 encode_devicedata3(xdr, args);
1168                 break;
1169         case NF3SOCK:
1170         case NF3FIFO:
1171                 encode_sattr3(xdr, args->sattr);
1172                 break;
1173         case NF3REG:
1174         case NF3DIR:
1175                 break;
1176         default:
1177                 BUG();
1178         }
1179 }
1180
1181 static int nfs3_xdr_enc_mknod3args(struct rpc_rqst *req, __be32 *p,
1182                                    const struct nfs3_mknodargs *args)
1183 {
1184         struct xdr_stream xdr;
1185
1186         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1187         encode_diropargs3(&xdr, args->fh, args->name, args->len);
1188         encode_mknoddata3(&xdr, args);
1189         return 0;
1190 }
1191
1192 /*
1193  * 3.3.12  REMOVE3args
1194  *
1195  *      struct REMOVE3args {
1196  *              diropargs3  object;
1197  *      };
1198  */
1199 static int nfs3_xdr_enc_remove3args(struct rpc_rqst *req, __be32 *p,
1200                                     const struct nfs_removeargs *args)
1201 {
1202         struct xdr_stream xdr;
1203
1204         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1205         encode_diropargs3(&xdr, args->fh, args->name.name, args->name.len);
1206         return 0;
1207 }
1208
1209 /*
1210  * 3.3.14  RENAME3args
1211  *
1212  *      struct RENAME3args {
1213  *              diropargs3      from;
1214  *              diropargs3      to;
1215  *      };
1216  */
1217 static int nfs3_xdr_enc_rename3args(struct rpc_rqst *req, __be32 *p,
1218                                     const struct nfs_renameargs *args)
1219 {
1220         const struct qstr *old = args->old_name;
1221         const struct qstr *new = args->new_name;
1222         struct xdr_stream xdr;
1223
1224         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1225         encode_diropargs3(&xdr, args->old_dir, old->name, old->len);
1226         encode_diropargs3(&xdr, args->new_dir, new->name, new->len);
1227         return 0;
1228 }
1229
1230 /*
1231  * 3.3.15  LINK3args
1232  *
1233  *      struct LINK3args {
1234  *              nfs_fh3         file;
1235  *              diropargs3      link;
1236  *      };
1237  */
1238 static int nfs3_xdr_enc_link3args(struct rpc_rqst *req, __be32 *p,
1239                                   const struct nfs3_linkargs *args)
1240 {
1241         struct xdr_stream xdr;
1242
1243         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1244         encode_nfs_fh3(&xdr, args->fromfh);
1245         encode_diropargs3(&xdr, args->tofh, args->toname, args->tolen);
1246         return 0;
1247 }
1248
1249 /*
1250  * 3.3.16  READDIR3args
1251  *
1252  *      struct READDIR3args {
1253  *              nfs_fh3         dir;
1254  *              cookie3         cookie;
1255  *              cookieverf3     cookieverf;
1256  *              count3          count;
1257  *      };
1258  */
1259 static void encode_readdir3args(struct xdr_stream *xdr,
1260                                 const struct nfs3_readdirargs *args)
1261 {
1262         __be32 *p;
1263
1264         encode_nfs_fh3(xdr, args->fh);
1265
1266         p = xdr_reserve_space(xdr, 8 + NFS3_COOKIEVERFSIZE + 4);
1267         p = xdr_encode_cookie3(p, args->cookie);
1268         p = xdr_encode_cookieverf3(p, args->verf);
1269         *p = cpu_to_be32(args->count);
1270 }
1271
1272 static int nfs3_xdr_enc_readdir3args(struct rpc_rqst *req, __be32 *p,
1273                                      const struct nfs3_readdirargs *args)
1274 {
1275         struct xdr_stream xdr;
1276
1277         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1278         encode_readdir3args(&xdr, args);
1279         prepare_reply_buffer(req, args->pages, 0,
1280                                 args->count, NFS3_readdirres_sz);
1281         return 0;
1282 }
1283
1284 /*
1285  * 3.3.17  READDIRPLUS3args
1286  *
1287  *      struct READDIRPLUS3args {
1288  *              nfs_fh3         dir;
1289  *              cookie3         cookie;
1290  *              cookieverf3     cookieverf;
1291  *              count3          dircount;
1292  *              count3          maxcount;
1293  *      };
1294  */
1295 static void encode_readdirplus3args(struct xdr_stream *xdr,
1296                                     const struct nfs3_readdirargs *args)
1297 {
1298         __be32 *p;
1299
1300         encode_nfs_fh3(xdr, args->fh);
1301
1302         p = xdr_reserve_space(xdr, 8 + NFS3_COOKIEVERFSIZE + 4 + 4);
1303         p = xdr_encode_cookie3(p, args->cookie);
1304         p = xdr_encode_cookieverf3(p, args->verf);
1305
1306         /*
1307          * readdirplus: need dircount + buffer size.
1308          * We just make sure we make dircount big enough
1309          */
1310         *p++ = cpu_to_be32(args->count >> 3);
1311
1312         *p = cpu_to_be32(args->count);
1313 }
1314
1315 static int nfs3_xdr_enc_readdirplus3args(struct rpc_rqst *req, __be32 *p,
1316                                          const struct nfs3_readdirargs *args)
1317 {
1318         struct xdr_stream xdr;
1319
1320         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1321         encode_readdirplus3args(&xdr, args);
1322         prepare_reply_buffer(req, args->pages, 0,
1323                                 args->count, NFS3_readdirres_sz);
1324         return 0;
1325 }
1326
1327 /*
1328  * 3.3.21  COMMIT3args
1329  *
1330  *      struct COMMIT3args {
1331  *              nfs_fh3         file;
1332  *              offset3         offset;
1333  *              count3          count;
1334  *      };
1335  */
1336 static void encode_commit3args(struct xdr_stream *xdr,
1337                                const struct nfs_writeargs *args)
1338 {
1339         __be32 *p;
1340
1341         encode_nfs_fh3(xdr, args->fh);
1342
1343         p = xdr_reserve_space(xdr, 8 + 4);
1344         p = xdr_encode_hyper(p, args->offset);
1345         *p = cpu_to_be32(args->count);
1346 }
1347
1348 static int nfs3_xdr_enc_commit3args(struct rpc_rqst *req, __be32 *p,
1349                                     const struct nfs_writeargs *args)
1350 {
1351         struct xdr_stream xdr;
1352
1353         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1354         encode_commit3args(&xdr, args);
1355         return 0;
1356 }
1357
1358 #ifdef CONFIG_NFS_V3_ACL
1359
1360 static int nfs3_xdr_enc_getacl3args(struct rpc_rqst *req, __be32 *p,
1361                                     const struct nfs3_getaclargs *args)
1362 {
1363         struct xdr_stream xdr;
1364
1365         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1366         encode_nfs_fh3(&xdr, args->fh);
1367         encode_uint32(&xdr, args->mask);
1368         if (args->mask & (NFS_ACL | NFS_DFACL))
1369                 prepare_reply_buffer(req, args->pages, 0,
1370                                         NFSACL_MAXPAGES << PAGE_SHIFT,
1371                                         ACL3_getaclres_sz);
1372         return 0;
1373 }
1374
1375 static int nfs3_xdr_enc_setacl3args(struct rpc_rqst *req, __be32 *p,
1376                                     const struct nfs3_setaclargs *args)
1377 {
1378         struct xdr_stream xdr;
1379         unsigned int base;
1380         int error;
1381
1382         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1383         encode_nfs_fh3(&xdr, NFS_FH(args->inode));
1384         encode_uint32(&xdr, args->mask);
1385         if (args->npages != 0)
1386                 xdr_write_pages(&xdr, args->pages, 0, args->len);
1387
1388         base = req->rq_slen;
1389         error = nfsacl_encode(xdr.buf, base, args->inode,
1390                             (args->mask & NFS_ACL) ?
1391                             args->acl_access : NULL, 1, 0);
1392         BUG_ON(error < 0);
1393         error = nfsacl_encode(xdr.buf, base + error, args->inode,
1394                             (args->mask & NFS_DFACL) ?
1395                             args->acl_default : NULL, 1,
1396                             NFS_ACL_DEFAULT);
1397         BUG_ON(error < 0);
1398         return 0;
1399 }
1400
1401 #endif  /* CONFIG_NFS_V3_ACL */
1402
1403 /*
1404  * NFSv3 XDR decode functions
1405  *
1406  * NFSv3 result types are defined in section 3.3 of RFC 1813:
1407  * "NFS Version 3 Protocol Specification".
1408  */
1409
1410 /*
1411  * 3.3.1  GETATTR3res
1412  *
1413  *      struct GETATTR3resok {
1414  *              fattr3          obj_attributes;
1415  *      };
1416  *
1417  *      union GETATTR3res switch (nfsstat3 status) {
1418  *      case NFS3_OK:
1419  *              GETATTR3resok  resok;
1420  *      default:
1421  *              void;
1422  *      };
1423  */
1424 static int nfs3_xdr_dec_getattr3res(struct rpc_rqst *req, __be32 *p,
1425                                     struct nfs_fattr *result)
1426 {
1427         struct xdr_stream xdr;
1428         enum nfs_stat status;
1429         int error;
1430
1431         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1432         error = decode_nfsstat3(&xdr, &status);
1433         if (unlikely(error))
1434                 goto out;
1435         if (status != NFS3_OK)
1436                 goto out_default;
1437         error = decode_fattr3(&xdr, result);
1438 out:
1439         return error;
1440 out_default:
1441         return nfs_stat_to_errno(status);
1442 }
1443
1444 /*
1445  * 3.3.2  SETATTR3res
1446  *
1447  *      struct SETATTR3resok {
1448  *              wcc_data  obj_wcc;
1449  *      };
1450  *
1451  *      struct SETATTR3resfail {
1452  *              wcc_data  obj_wcc;
1453  *      };
1454  *
1455  *      union SETATTR3res switch (nfsstat3 status) {
1456  *      case NFS3_OK:
1457  *              SETATTR3resok   resok;
1458  *      default:
1459  *              SETATTR3resfail resfail;
1460  *      };
1461  */
1462 static int nfs3_xdr_dec_setattr3res(struct rpc_rqst *req, __be32 *p,
1463                                     struct nfs_fattr *result)
1464 {
1465         struct xdr_stream xdr;
1466         enum nfs_stat status;
1467         int error;
1468
1469         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1470         error = decode_nfsstat3(&xdr, &status);
1471         if (unlikely(error))
1472                 goto out;
1473         error = decode_wcc_data(&xdr, result);
1474         if (unlikely(error))
1475                 goto out;
1476         if (status != NFS3_OK)
1477                 goto out_status;
1478 out:
1479         return error;
1480 out_status:
1481         return nfs_stat_to_errno(status);
1482 }
1483
1484 /*
1485  * 3.3.3  LOOKUP3res
1486  *
1487  *      struct LOOKUP3resok {
1488  *              nfs_fh3         object;
1489  *              post_op_attr    obj_attributes;
1490  *              post_op_attr    dir_attributes;
1491  *      };
1492  *
1493  *      struct LOOKUP3resfail {
1494  *              post_op_attr    dir_attributes;
1495  *      };
1496  *
1497  *      union LOOKUP3res switch (nfsstat3 status) {
1498  *      case NFS3_OK:
1499  *              LOOKUP3resok    resok;
1500  *      default:
1501  *              LOOKUP3resfail  resfail;
1502  *      };
1503  */
1504 static int nfs3_xdr_dec_lookup3res(struct rpc_rqst *req, __be32 *p,
1505                                    struct nfs3_diropres *result)
1506 {
1507         struct xdr_stream xdr;
1508         enum nfs_stat status;
1509         int error;
1510
1511         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1512         error = decode_nfsstat3(&xdr, &status);
1513         if (unlikely(error))
1514                 goto out;
1515         if (status != NFS3_OK)
1516                 goto out_default;
1517         error = decode_nfs_fh3(&xdr, result->fh);
1518         if (unlikely(error))
1519                 goto out;
1520         error = decode_post_op_attr(&xdr, result->fattr);
1521         if (unlikely(error))
1522                 goto out;
1523         error = decode_post_op_attr(&xdr, result->dir_attr);
1524 out:
1525         return error;
1526 out_default:
1527         error = decode_post_op_attr(&xdr, result->dir_attr);
1528         if (unlikely(error))
1529                 goto out;
1530         return nfs_stat_to_errno(status);
1531 }
1532
1533 /*
1534  * 3.3.4  ACCESS3res
1535  *
1536  *      struct ACCESS3resok {
1537  *              post_op_attr    obj_attributes;
1538  *              uint32          access;
1539  *      };
1540  *
1541  *      struct ACCESS3resfail {
1542  *              post_op_attr    obj_attributes;
1543  *      };
1544  *
1545  *      union ACCESS3res switch (nfsstat3 status) {
1546  *      case NFS3_OK:
1547  *              ACCESS3resok    resok;
1548  *      default:
1549  *              ACCESS3resfail  resfail;
1550  *      };
1551  */
1552 static int nfs3_xdr_dec_access3res(struct rpc_rqst *req, __be32 *p,
1553                                    struct nfs3_accessres *result)
1554 {
1555         struct xdr_stream xdr;
1556         enum nfs_stat status;
1557         int error;
1558
1559         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1560         error = decode_nfsstat3(&xdr, &status);
1561         if (unlikely(error))
1562                 goto out;
1563         error = decode_post_op_attr(&xdr, result->fattr);
1564         if (unlikely(error))
1565                 goto out;
1566         if (status != NFS3_OK)
1567                 goto out_default;
1568         error = decode_uint32(&xdr, &result->access);
1569 out:
1570         return error;
1571 out_default:
1572         return nfs_stat_to_errno(status);
1573 }
1574
1575 /*
1576  * 3.3.5  READLINK3res
1577  *
1578  *      struct READLINK3resok {
1579  *              post_op_attr    symlink_attributes;
1580  *              nfspath3        data;
1581  *      };
1582  *
1583  *      struct READLINK3resfail {
1584  *              post_op_attr    symlink_attributes;
1585  *      };
1586  *
1587  *      union READLINK3res switch (nfsstat3 status) {
1588  *      case NFS3_OK:
1589  *              READLINK3resok  resok;
1590  *      default:
1591  *              READLINK3resfail resfail;
1592  *      };
1593  */
1594 static int nfs3_xdr_dec_readlink3res(struct rpc_rqst *req, __be32 *p,
1595                                      struct nfs_fattr *result)
1596 {
1597         struct xdr_stream xdr;
1598         enum nfs_stat status;
1599         int error;
1600
1601         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1602         error = decode_nfsstat3(&xdr, &status);
1603         if (unlikely(error))
1604                 goto out;
1605         error = decode_post_op_attr(&xdr, result);
1606         if (unlikely(error))
1607                 goto out;
1608         if (status != NFS3_OK)
1609                 goto out_default;
1610         error = decode_nfspath3(&xdr);
1611 out:
1612         return error;
1613 out_default:
1614         return nfs_stat_to_errno(status);
1615 }
1616
1617 /*
1618  * 3.3.6  READ3res
1619  *
1620  *      struct READ3resok {
1621  *              post_op_attr    file_attributes;
1622  *              count3          count;
1623  *              bool            eof;
1624  *              opaque          data<>;
1625  *      };
1626  *
1627  *      struct READ3resfail {
1628  *              post_op_attr    file_attributes;
1629  *      };
1630  *
1631  *      union READ3res switch (nfsstat3 status) {
1632  *      case NFS3_OK:
1633  *              READ3resok      resok;
1634  *      default:
1635  *              READ3resfail    resfail;
1636  *      };
1637  */
1638 static int decode_read3resok(struct xdr_stream *xdr,
1639                              struct nfs_readres *result)
1640 {
1641         u32 eof, count, ocount, recvd;
1642         size_t hdrlen;
1643         __be32 *p;
1644
1645         p = xdr_inline_decode(xdr, 4 + 4 + 4);
1646         if (unlikely(p == NULL))
1647                 goto out_overflow;
1648         count = be32_to_cpup(p++);
1649         eof = be32_to_cpup(p++);
1650         ocount = be32_to_cpup(p++);
1651         if (unlikely(ocount != count))
1652                 goto out_mismatch;
1653         hdrlen = (u8 *)xdr->p - (u8 *)xdr->iov->iov_base;
1654         recvd = xdr->buf->len - hdrlen;
1655         if (unlikely(count > recvd))
1656                 goto out_cheating;
1657
1658 out:
1659         xdr_read_pages(xdr, count);
1660         result->eof = eof;
1661         result->count = count;
1662         return count;
1663 out_mismatch:
1664         dprintk("NFS: READ count doesn't match length of opaque: "
1665                 "count %u != ocount %u\n", count, ocount);
1666         return -EIO;
1667 out_cheating:
1668         dprintk("NFS: server cheating in read result: "
1669                 "count %u > recvd %u\n", count, recvd);
1670         count = recvd;
1671         eof = 0;
1672         goto out;
1673 out_overflow:
1674         print_overflow_msg(__func__, xdr);
1675         return -EIO;
1676 }
1677
1678 static int nfs3_xdr_dec_read3res(struct rpc_rqst *req, __be32 *p,
1679                                  struct nfs_readres *result)
1680 {
1681         struct xdr_stream xdr;
1682         enum nfs_stat status;
1683         int error;
1684
1685         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1686         error = decode_nfsstat3(&xdr, &status);
1687         if (unlikely(error))
1688                 goto out;
1689         error = decode_post_op_attr(&xdr, result->fattr);
1690         if (unlikely(error))
1691                 goto out;
1692         if (status != NFS3_OK)
1693                 goto out_status;
1694         error = decode_read3resok(&xdr, result);
1695 out:
1696         return error;
1697 out_status:
1698         return nfs_stat_to_errno(status);
1699 }
1700
1701 /*
1702  * 3.3.7  WRITE3res
1703  *
1704  *      enum stable_how {
1705  *              UNSTABLE  = 0,
1706  *              DATA_SYNC = 1,
1707  *              FILE_SYNC = 2
1708  *      };
1709  *
1710  *      struct WRITE3resok {
1711  *              wcc_data        file_wcc;
1712  *              count3          count;
1713  *              stable_how      committed;
1714  *              writeverf3      verf;
1715  *      };
1716  *
1717  *      struct WRITE3resfail {
1718  *              wcc_data        file_wcc;
1719  *      };
1720  *
1721  *      union WRITE3res switch (nfsstat3 status) {
1722  *      case NFS3_OK:
1723  *              WRITE3resok     resok;
1724  *      default:
1725  *              WRITE3resfail   resfail;
1726  *      };
1727  */
1728 static int decode_write3resok(struct xdr_stream *xdr,
1729                               struct nfs_writeres *result)
1730 {
1731         __be32 *p;
1732
1733         p = xdr_inline_decode(xdr, 4 + 4 + NFS3_WRITEVERFSIZE);
1734         if (unlikely(p == NULL))
1735                 goto out_overflow;
1736         result->count = be32_to_cpup(p++);
1737         result->verf->committed = be32_to_cpup(p++);
1738         if (unlikely(result->verf->committed > NFS_FILE_SYNC))
1739                 goto out_badvalue;
1740         memcpy(result->verf->verifier, p, NFS3_WRITEVERFSIZE);
1741         return result->count;
1742 out_badvalue:
1743         dprintk("NFS: bad stable_how value: %u\n", result->verf->committed);
1744         return -EIO;
1745 out_overflow:
1746         print_overflow_msg(__func__, xdr);
1747         return -EIO;
1748 }
1749
1750 static int nfs3_xdr_dec_write3res(struct rpc_rqst *req, __be32 *p,
1751                                   struct nfs_writeres *result)
1752 {
1753         struct xdr_stream xdr;
1754         enum nfs_stat status;
1755         int error;
1756
1757         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1758         error = decode_nfsstat3(&xdr, &status);
1759         if (unlikely(error))
1760                 goto out;
1761         error = decode_wcc_data(&xdr, result->fattr);
1762         if (unlikely(error))
1763                 goto out;
1764         if (status != NFS3_OK)
1765                 goto out_status;
1766         error = decode_write3resok(&xdr, result);
1767 out:
1768         return error;
1769 out_status:
1770         return nfs_stat_to_errno(status);
1771 }
1772
1773 /*
1774  * 3.3.8  CREATE3res
1775  *
1776  *      struct CREATE3resok {
1777  *              post_op_fh3     obj;
1778  *              post_op_attr    obj_attributes;
1779  *              wcc_data        dir_wcc;
1780  *      };
1781  *
1782  *      struct CREATE3resfail {
1783  *              wcc_data        dir_wcc;
1784  *      };
1785  *
1786  *      union CREATE3res switch (nfsstat3 status) {
1787  *      case NFS3_OK:
1788  *              CREATE3resok    resok;
1789  *      default:
1790  *              CREATE3resfail  resfail;
1791  *      };
1792  */
1793 static int decode_create3resok(struct xdr_stream *xdr,
1794                                struct nfs3_diropres *result)
1795 {
1796         int error;
1797
1798         error = decode_post_op_fh3(xdr, result->fh);
1799         if (unlikely(error))
1800                 goto out;
1801         error = decode_post_op_attr(xdr, result->fattr);
1802         if (unlikely(error))
1803                 goto out;
1804         /* The server isn't required to return a file handle.
1805          * If it didn't, force the client to perform a LOOKUP
1806          * to determine the correct file handle and attribute
1807          * values for the new object. */
1808         if (result->fh->size == 0)
1809                 result->fattr->valid = 0;
1810         error = decode_wcc_data(xdr, result->dir_attr);
1811 out:
1812         return error;
1813 }
1814
1815 static int nfs3_xdr_dec_create3res(struct rpc_rqst *req, __be32 *p,
1816                                    struct nfs3_diropres *result)
1817 {
1818         struct xdr_stream xdr;
1819         enum nfs_stat status;
1820         int error;
1821
1822         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1823         error = decode_nfsstat3(&xdr, &status);
1824         if (unlikely(error))
1825                 goto out;
1826         if (status != NFS3_OK)
1827                 goto out_default;
1828         error = decode_create3resok(&xdr, result);
1829 out:
1830         return error;
1831 out_default:
1832         error = decode_wcc_data(&xdr, result->dir_attr);
1833         if (unlikely(error))
1834                 goto out;
1835         return nfs_stat_to_errno(status);
1836 }
1837
1838 /*
1839  * 3.3.12  REMOVE3res
1840  *
1841  *      struct REMOVE3resok {
1842  *              wcc_data    dir_wcc;
1843  *      };
1844  *
1845  *      struct REMOVE3resfail {
1846  *              wcc_data    dir_wcc;
1847  *      };
1848  *
1849  *      union REMOVE3res switch (nfsstat3 status) {
1850  *      case NFS3_OK:
1851  *              REMOVE3resok   resok;
1852  *      default:
1853  *              REMOVE3resfail resfail;
1854  *      };
1855  */
1856 static int nfs3_xdr_dec_remove3res(struct rpc_rqst *req, __be32 *p,
1857                                    struct nfs_removeres *result)
1858 {
1859         struct xdr_stream xdr;
1860         enum nfs_stat status;
1861         int error;
1862
1863         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1864         error = decode_nfsstat3(&xdr, &status);
1865         if (unlikely(error))
1866                 goto out;
1867         error = decode_wcc_data(&xdr, result->dir_attr);
1868         if (unlikely(error))
1869                 goto out;
1870         if (status != NFS3_OK)
1871                 goto out_status;
1872 out:
1873         return error;
1874 out_status:
1875         return nfs_stat_to_errno(status);
1876 }
1877
1878 /*
1879  * 3.3.14  RENAME3res
1880  *
1881  *      struct RENAME3resok {
1882  *              wcc_data        fromdir_wcc;
1883  *              wcc_data        todir_wcc;
1884  *      };
1885  *
1886  *      struct RENAME3resfail {
1887  *              wcc_data        fromdir_wcc;
1888  *              wcc_data        todir_wcc;
1889  *      };
1890  *
1891  *      union RENAME3res switch (nfsstat3 status) {
1892  *      case NFS3_OK:
1893  *              RENAME3resok   resok;
1894  *      default:
1895  *              RENAME3resfail resfail;
1896  *      };
1897  */
1898 static int nfs3_xdr_dec_rename3res(struct rpc_rqst *req, __be32 *p,
1899                                    struct nfs_renameres *result)
1900 {
1901         struct xdr_stream xdr;
1902         enum nfs_stat status;
1903         int error;
1904
1905         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1906         error = decode_nfsstat3(&xdr, &status);
1907         if (unlikely(error))
1908                 goto out;
1909         error = decode_wcc_data(&xdr, result->old_fattr);
1910         if (unlikely(error))
1911                 goto out;
1912         error = decode_wcc_data(&xdr, result->new_fattr);
1913         if (unlikely(error))
1914                 goto out;
1915         if (status != NFS3_OK)
1916                 goto out_status;
1917 out:
1918         return error;
1919 out_status:
1920         return nfs_stat_to_errno(status);
1921 }
1922
1923 /*
1924  * 3.3.15  LINK3res
1925  *
1926  *      struct LINK3resok {
1927  *              post_op_attr    file_attributes;
1928  *              wcc_data        linkdir_wcc;
1929  *      };
1930  *
1931  *      struct LINK3resfail {
1932  *              post_op_attr    file_attributes;
1933  *              wcc_data        linkdir_wcc;
1934  *      };
1935  *
1936  *      union LINK3res switch (nfsstat3 status) {
1937  *      case NFS3_OK:
1938  *              LINK3resok      resok;
1939  *      default:
1940  *              LINK3resfail    resfail;
1941  *      };
1942  */
1943 static int nfs3_xdr_dec_link3res(struct rpc_rqst *req, __be32 *p,
1944                                  struct nfs3_linkres *result)
1945 {
1946         struct xdr_stream xdr;
1947         enum nfs_stat status;
1948         int error;
1949
1950         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1951         error = decode_nfsstat3(&xdr, &status);
1952         if (unlikely(error))
1953                 goto out;
1954         error = decode_post_op_attr(&xdr, result->fattr);
1955         if (unlikely(error))
1956                 goto out;
1957         error = decode_wcc_data(&xdr, result->dir_attr);
1958         if (unlikely(error))
1959                 goto out;
1960         if (status != NFS3_OK)
1961                 goto out_status;
1962 out:
1963         return error;
1964 out_status:
1965         return nfs_stat_to_errno(status);
1966 }
1967
1968 /**
1969  * nfs3_decode_dirent - Decode a single NFSv3 directory entry stored in
1970  *                      the local page cache
1971  * @xdr: XDR stream where entry resides
1972  * @entry: buffer to fill in with entry data
1973  * @server: nfs_server data for this directory
1974  * @plus: boolean indicating whether this should be a readdirplus entry
1975  *
1976  * Returns the position of the next item in the buffer, or an ERR_PTR.
1977  *
1978  * This function is not invoked during READDIR reply decoding, but
1979  * rather whenever an application invokes the getdents(2) system call
1980  * on a directory already in our cache.
1981  *
1982  * 3.3.16  entry3
1983  *
1984  *      struct entry3 {
1985  *              fileid3         fileid;
1986  *              filename3       name;
1987  *              cookie3         cookie;
1988  *              fhandle3        filehandle;
1989  *              post_op_attr3   attributes;
1990  *              entry3          *nextentry;
1991  *      };
1992  *
1993  * 3.3.17  entryplus3
1994  *      struct entryplus3 {
1995  *              fileid3         fileid;
1996  *              filename3       name;
1997  *              cookie3         cookie;
1998  *              post_op_attr    name_attributes;
1999  *              post_op_fh3     name_handle;
2000  *              entryplus3      *nextentry;
2001  *      };
2002  */
2003 __be32 *nfs3_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry,
2004                            struct nfs_server *server, int plus)
2005 {
2006         struct nfs_entry old = *entry;
2007         __be32 *p;
2008         int error;
2009
2010         p = xdr_inline_decode(xdr, 4);
2011         if (unlikely(p == NULL))
2012                 goto out_overflow;
2013         if (*p == xdr_zero) {
2014                 p = xdr_inline_decode(xdr, 4);
2015                 if (unlikely(p == NULL))
2016                         goto out_overflow;
2017                 if (*p == xdr_zero)
2018                         return ERR_PTR(-EAGAIN);
2019                 entry->eof = 1;
2020                 return ERR_PTR(-EBADCOOKIE);
2021         }
2022
2023         error = decode_fileid3(xdr, &entry->ino);
2024         if (unlikely(error))
2025                 return ERR_PTR(error);
2026
2027         error = decode_inline_filename3(xdr, &entry->name, &entry->len);
2028         if (unlikely(error))
2029                 return ERR_PTR(error);
2030
2031         entry->prev_cookie = entry->cookie;
2032         error = decode_cookie3(xdr, &entry->cookie);
2033         if (unlikely(error))
2034                 return ERR_PTR(error);
2035
2036         entry->d_type = DT_UNKNOWN;
2037
2038         if (plus) {
2039                 entry->fattr->valid = 0;
2040                 error = decode_post_op_attr(xdr, entry->fattr);
2041                 if (unlikely(error))
2042                         return ERR_PTR(error);
2043                 if (entry->fattr->valid & NFS_ATTR_FATTR_V3)
2044                         entry->d_type = nfs_umode_to_dtype(entry->fattr->mode);
2045
2046                 /* In fact, a post_op_fh3: */
2047                 p = xdr_inline_decode(xdr, 4);
2048                 if (unlikely(p == NULL))
2049                         goto out_overflow;
2050                 if (*p != xdr_zero) {
2051                         error = decode_nfs_fh3(xdr, entry->fh);
2052                         if (unlikely(error)) {
2053                                 if (error == -E2BIG)
2054                                         goto out_truncated;
2055                                 return ERR_PTR(error);
2056                         }
2057                 } else
2058                         zero_nfs_fh3(entry->fh);
2059         }
2060
2061         /* Peek at the next entry to see if we're at EOD */
2062         p = xdr_inline_peek(xdr, 4 + 4);
2063         entry->eof = 0;
2064         if (p != NULL)
2065                 entry->eof = (p[0] == xdr_zero) && (p[1] != xdr_zero);
2066         return p;
2067
2068 out_overflow:
2069         print_overflow_msg(__func__, xdr);
2070         return ERR_PTR(-EAGAIN);
2071 out_truncated:
2072         dprintk("NFS: directory entry contains invalid file handle\n");
2073         *entry = old;
2074         return ERR_PTR(-EAGAIN);
2075 }
2076
2077 /*
2078  * 3.3.16  READDIR3res
2079  *
2080  *      struct dirlist3 {
2081  *              entry3          *entries;
2082  *              bool            eof;
2083  *      };
2084  *
2085  *      struct READDIR3resok {
2086  *              post_op_attr    dir_attributes;
2087  *              cookieverf3     cookieverf;
2088  *              dirlist3        reply;
2089  *      };
2090  *
2091  *      struct READDIR3resfail {
2092  *              post_op_attr    dir_attributes;
2093  *      };
2094  *
2095  *      union READDIR3res switch (nfsstat3 status) {
2096  *      case NFS3_OK:
2097  *              READDIR3resok   resok;
2098  *      default:
2099  *              READDIR3resfail resfail;
2100  *      };
2101  *
2102  * Read the directory contents into the page cache, but otherwise
2103  * don't touch them.  The actual decoding is done by nfs3_decode_entry()
2104  * during subsequent nfs_readdir() calls.
2105  */
2106 static int decode_dirlist3(struct xdr_stream *xdr)
2107 {
2108         u32 recvd, pglen;
2109         size_t hdrlen;
2110
2111         pglen = xdr->buf->page_len;
2112         hdrlen = (u8 *)xdr->p - (u8 *)xdr->iov->iov_base;
2113         recvd = xdr->buf->len - hdrlen;
2114         if (unlikely(pglen > recvd))
2115                 goto out_cheating;
2116 out:
2117         xdr_read_pages(xdr, pglen);
2118         return pglen;
2119 out_cheating:
2120         dprintk("NFS: server cheating in readdir result: "
2121                 "pglen %u > recvd %u\n", pglen, recvd);
2122         pglen = recvd;
2123         goto out;
2124 }
2125
2126 static int decode_readdir3resok(struct xdr_stream *xdr,
2127                                 struct nfs3_readdirres *result)
2128 {
2129         int error;
2130
2131         error = decode_post_op_attr(xdr, result->dir_attr);
2132         if (unlikely(error))
2133                 goto out;
2134         /* XXX: do we need to check if result->verf != NULL ? */
2135         error = decode_cookieverf3(xdr, result->verf);
2136         if (unlikely(error))
2137                 goto out;
2138         error = decode_dirlist3(xdr);
2139 out:
2140         return error;
2141 }
2142
2143 static int nfs3_xdr_dec_readdir3res(struct rpc_rqst *req, __be32 *p,
2144                                     struct nfs3_readdirres *result)
2145 {
2146         struct xdr_stream xdr;
2147         enum nfs_stat status;
2148         int error;
2149
2150         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
2151         error = decode_nfsstat3(&xdr, &status);
2152         if (unlikely(error))
2153                 goto out;
2154         if (status != NFS3_OK)
2155                 goto out_default;
2156         error = decode_readdir3resok(&xdr, result);
2157 out:
2158         return error;
2159 out_default:
2160         error = decode_post_op_attr(&xdr, result->dir_attr);
2161         if (unlikely(error))
2162                 goto out;
2163         return nfs_stat_to_errno(status);
2164 }
2165
2166 /*
2167  * 3.3.18  FSSTAT3res
2168  *
2169  *      struct FSSTAT3resok {
2170  *              post_op_attr    obj_attributes;
2171  *              size3           tbytes;
2172  *              size3           fbytes;
2173  *              size3           abytes;
2174  *              size3           tfiles;
2175  *              size3           ffiles;
2176  *              size3           afiles;
2177  *              uint32          invarsec;
2178  *      };
2179  *
2180  *      struct FSSTAT3resfail {
2181  *              post_op_attr    obj_attributes;
2182  *      };
2183  *
2184  *      union FSSTAT3res switch (nfsstat3 status) {
2185  *      case NFS3_OK:
2186  *              FSSTAT3resok    resok;
2187  *      default:
2188  *              FSSTAT3resfail  resfail;
2189  *      };
2190  */
2191 static int decode_fsstat3resok(struct xdr_stream *xdr,
2192                                struct nfs_fsstat *result)
2193 {
2194         __be32 *p;
2195
2196         p = xdr_inline_decode(xdr, 8 * 6 + 4);
2197         if (unlikely(p == NULL))
2198                 goto out_overflow;
2199         p = xdr_decode_size3(p, &result->tbytes);
2200         p = xdr_decode_size3(p, &result->fbytes);
2201         p = xdr_decode_size3(p, &result->abytes);
2202         p = xdr_decode_size3(p, &result->tfiles);
2203         p = xdr_decode_size3(p, &result->ffiles);
2204         xdr_decode_size3(p, &result->afiles);
2205         /* ignore invarsec */
2206         return 0;
2207 out_overflow:
2208         print_overflow_msg(__func__, xdr);
2209         return -EIO;
2210 }
2211
2212 static int nfs3_xdr_dec_fsstat3res(struct rpc_rqst *req, __be32 *p,
2213                                    struct nfs_fsstat *result)
2214 {
2215         struct xdr_stream xdr;
2216         enum nfs_stat status;
2217         int error;
2218
2219         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
2220         error = decode_nfsstat3(&xdr, &status);
2221         if (unlikely(error))
2222                 goto out;
2223         error = decode_post_op_attr(&xdr, result->fattr);
2224         if (unlikely(error))
2225                 goto out;
2226         if (status != NFS3_OK)
2227                 goto out_status;
2228         error = decode_fsstat3resok(&xdr, result);
2229 out:
2230         return error;
2231 out_status:
2232         return nfs_stat_to_errno(status);
2233 }
2234
2235 /*
2236  * 3.3.19  FSINFO3res
2237  *
2238  *      struct FSINFO3resok {
2239  *              post_op_attr    obj_attributes;
2240  *              uint32          rtmax;
2241  *              uint32          rtpref;
2242  *              uint32          rtmult;
2243  *              uint32          wtmax;
2244  *              uint32          wtpref;
2245  *              uint32          wtmult;
2246  *              uint32          dtpref;
2247  *              size3           maxfilesize;
2248  *              nfstime3        time_delta;
2249  *              uint32          properties;
2250  *      };
2251  *
2252  *      struct FSINFO3resfail {
2253  *              post_op_attr    obj_attributes;
2254  *      };
2255  *
2256  *      union FSINFO3res switch (nfsstat3 status) {
2257  *      case NFS3_OK:
2258  *              FSINFO3resok    resok;
2259  *      default:
2260  *              FSINFO3resfail  resfail;
2261  *      };
2262  */
2263 static int decode_fsinfo3resok(struct xdr_stream *xdr,
2264                                struct nfs_fsinfo *result)
2265 {
2266         __be32 *p;
2267
2268         p = xdr_inline_decode(xdr, 4 * 7 + 8 + 8 + 4);
2269         if (unlikely(p == NULL))
2270                 goto out_overflow;
2271         result->rtmax  = be32_to_cpup(p++);
2272         result->rtpref = be32_to_cpup(p++);
2273         result->rtmult = be32_to_cpup(p++);
2274         result->wtmax  = be32_to_cpup(p++);
2275         result->wtpref = be32_to_cpup(p++);
2276         result->wtmult = be32_to_cpup(p++);
2277         result->dtpref = be32_to_cpup(p++);
2278         p = xdr_decode_size3(p, &result->maxfilesize);
2279         xdr_decode_nfstime3(p, &result->time_delta);
2280
2281         /* ignore properties */
2282         result->lease_time = 0;
2283         return 0;
2284 out_overflow:
2285         print_overflow_msg(__func__, xdr);
2286         return -EIO;
2287 }
2288
2289 static int nfs3_xdr_dec_fsinfo3res(struct rpc_rqst *req, __be32 *p,
2290                                    struct nfs_fsinfo *result)
2291 {
2292         struct xdr_stream xdr;
2293         enum nfs_stat status;
2294         int error;
2295
2296         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
2297         error = decode_nfsstat3(&xdr, &status);
2298         if (unlikely(error))
2299                 goto out;
2300         error = decode_post_op_attr(&xdr, result->fattr);
2301         if (unlikely(error))
2302                 goto out;
2303         if (status != NFS3_OK)
2304                 goto out_status;
2305         error = decode_fsinfo3resok(&xdr, result);
2306 out:
2307         return error;
2308 out_status:
2309         return nfs_stat_to_errno(status);
2310 }
2311
2312 /*
2313  * 3.3.20  PATHCONF3res
2314  *
2315  *      struct PATHCONF3resok {
2316  *              post_op_attr    obj_attributes;
2317  *              uint32          linkmax;
2318  *              uint32          name_max;
2319  *              bool            no_trunc;
2320  *              bool            chown_restricted;
2321  *              bool            case_insensitive;
2322  *              bool            case_preserving;
2323  *      };
2324  *
2325  *      struct PATHCONF3resfail {
2326  *              post_op_attr    obj_attributes;
2327  *      };
2328  *
2329  *      union PATHCONF3res switch (nfsstat3 status) {
2330  *      case NFS3_OK:
2331  *              PATHCONF3resok  resok;
2332  *      default:
2333  *              PATHCONF3resfail resfail;
2334  *      };
2335  */
2336 static int decode_pathconf3resok(struct xdr_stream *xdr,
2337                                  struct nfs_pathconf *result)
2338 {
2339         __be32 *p;
2340
2341         p = xdr_inline_decode(xdr, 4 * 6);
2342         if (unlikely(p == NULL))
2343                 goto out_overflow;
2344         result->max_link = be32_to_cpup(p++);
2345         result->max_namelen = be32_to_cpup(p);
2346         /* ignore remaining fields */
2347         return 0;
2348 out_overflow:
2349         print_overflow_msg(__func__, xdr);
2350         return -EIO;
2351 }
2352
2353 static int nfs3_xdr_dec_pathconf3res(struct rpc_rqst *req, __be32 *p,
2354                                      struct nfs_pathconf *result)
2355 {
2356         struct xdr_stream xdr;
2357         enum nfs_stat status;
2358         int error;
2359
2360         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
2361         error = decode_nfsstat3(&xdr, &status);
2362         if (unlikely(error))
2363                 goto out;
2364         error = decode_post_op_attr(&xdr, result->fattr);
2365         if (unlikely(error))
2366                 goto out;
2367         if (status != NFS3_OK)
2368                 goto out_status;
2369         error = decode_pathconf3resok(&xdr, result);
2370 out:
2371         return error;
2372 out_status:
2373         return nfs_stat_to_errno(status);
2374 }
2375
2376 /*
2377  * 3.3.21  COMMIT3res
2378  *
2379  *      struct COMMIT3resok {
2380  *              wcc_data        file_wcc;
2381  *              writeverf3      verf;
2382  *      };
2383  *
2384  *      struct COMMIT3resfail {
2385  *              wcc_data        file_wcc;
2386  *      };
2387  *
2388  *      union COMMIT3res switch (nfsstat3 status) {
2389  *      case NFS3_OK:
2390  *              COMMIT3resok    resok;
2391  *      default:
2392  *              COMMIT3resfail  resfail;
2393  *      };
2394  */
2395 static int nfs3_xdr_dec_commit3res(struct rpc_rqst *req, __be32 *p,
2396                                    struct nfs_writeres *result)
2397 {
2398         struct xdr_stream xdr;
2399         enum nfs_stat status;
2400         int error;
2401
2402         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
2403         error = decode_nfsstat3(&xdr, &status);
2404         if (unlikely(error))
2405                 goto out;
2406         error = decode_wcc_data(&xdr, result->fattr);
2407         if (unlikely(error))
2408                 goto out;
2409         if (status != NFS3_OK)
2410                 goto out_status;
2411         error = decode_writeverf3(&xdr, result->verf->verifier);
2412 out:
2413         return error;
2414 out_status:
2415         return nfs_stat_to_errno(status);
2416 }
2417
2418 #ifdef CONFIG_NFS_V3_ACL
2419
2420 static inline int decode_getacl3resok(struct xdr_stream *xdr,
2421                                       struct nfs3_getaclres *result)
2422 {
2423         struct posix_acl **acl;
2424         unsigned int *aclcnt;
2425         size_t hdrlen;
2426         int error;
2427
2428         error = decode_post_op_attr(xdr, result->fattr);
2429         if (unlikely(error))
2430                 goto out;
2431         error = decode_uint32(xdr, &result->mask);
2432         if (unlikely(error))
2433                 goto out;
2434         error = -EINVAL;
2435         if (result->mask & ~(NFS_ACL|NFS_ACLCNT|NFS_DFACL|NFS_DFACLCNT))
2436                 goto out;
2437
2438         hdrlen = (u8 *)xdr->p - (u8 *)xdr->iov->iov_base;
2439
2440         acl = NULL;
2441         if (result->mask & NFS_ACL)
2442                 acl = &result->acl_access;
2443         aclcnt = NULL;
2444         if (result->mask & NFS_ACLCNT)
2445                 aclcnt = &result->acl_access_count;
2446         error = nfsacl_decode(xdr->buf, hdrlen, aclcnt, acl);
2447         if (unlikely(error <= 0))
2448                 goto out;
2449
2450         acl = NULL;
2451         if (result->mask & NFS_DFACL)
2452                 acl = &result->acl_default;
2453         aclcnt = NULL;
2454         if (result->mask & NFS_DFACLCNT)
2455                 aclcnt = &result->acl_default_count;
2456         error = nfsacl_decode(xdr->buf, hdrlen + error, aclcnt, acl);
2457         if (unlikely(error <= 0))
2458                 return error;
2459         error = 0;
2460 out:
2461         return error;
2462 }
2463
2464 static int nfs3_xdr_dec_getacl3res(struct rpc_rqst *req, __be32 *p,
2465                                    struct nfs3_getaclres *result)
2466 {
2467         struct xdr_stream xdr;
2468         enum nfs_stat status;
2469         int error;
2470
2471         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
2472         error = decode_nfsstat3(&xdr, &status);
2473         if (unlikely(error))
2474                 goto out;
2475         if (status != NFS3_OK)
2476                 goto out_default;
2477         error = decode_getacl3resok(&xdr, result);
2478 out:
2479         return error;
2480 out_default:
2481         return nfs_stat_to_errno(status);
2482 }
2483
2484 static int nfs3_xdr_dec_setacl3res(struct rpc_rqst *req, __be32 *p,
2485                                    struct nfs_fattr *result)
2486 {
2487         struct xdr_stream xdr;
2488         enum nfs_stat status;
2489         int error;
2490
2491         xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
2492         error = decode_nfsstat3(&xdr, &status);
2493         if (unlikely(error))
2494                 goto out;
2495         if (status != NFS3_OK)
2496                 goto out_default;
2497         error = decode_post_op_attr(&xdr, result);
2498 out:
2499         return error;
2500 out_default:
2501         return nfs_stat_to_errno(status);
2502 }
2503
2504 #endif  /* CONFIG_NFS_V3_ACL */
2505
2506 #define PROC(proc, argtype, restype, timer)                             \
2507 [NFS3PROC_##proc] = {                                                   \
2508         .p_proc      = NFS3PROC_##proc,                                 \
2509         .p_encode    = (kxdrproc_t)nfs3_xdr_enc_##argtype##3args,       \
2510         .p_decode    = (kxdrproc_t)nfs3_xdr_dec_##restype##3res,        \
2511         .p_arglen    = NFS3_##argtype##args_sz,                         \
2512         .p_replen    = NFS3_##restype##res_sz,                          \
2513         .p_timer     = timer,                                           \
2514         .p_statidx   = NFS3PROC_##proc,                                 \
2515         .p_name      = #proc,                                           \
2516         }
2517
2518 struct rpc_procinfo     nfs3_procedures[] = {
2519         PROC(GETATTR,           getattr,        getattr,        1),
2520         PROC(SETATTR,           setattr,        setattr,        0),
2521         PROC(LOOKUP,            lookup,         lookup,         2),
2522         PROC(ACCESS,            access,         access,         1),
2523         PROC(READLINK,          readlink,       readlink,       3),
2524         PROC(READ,              read,           read,           3),
2525         PROC(WRITE,             write,          write,          4),
2526         PROC(CREATE,            create,         create,         0),
2527         PROC(MKDIR,             mkdir,          create,         0),
2528         PROC(SYMLINK,           symlink,        create,         0),
2529         PROC(MKNOD,             mknod,          create,         0),
2530         PROC(REMOVE,            remove,         remove,         0),
2531         PROC(RMDIR,             lookup,         setattr,        0),
2532         PROC(RENAME,            rename,         rename,         0),
2533         PROC(LINK,              link,           link,           0),
2534         PROC(READDIR,           readdir,        readdir,        3),
2535         PROC(READDIRPLUS,       readdirplus,    readdir,        3),
2536         PROC(FSSTAT,            getattr,        fsstat,         0),
2537         PROC(FSINFO,            getattr,        fsinfo,         0),
2538         PROC(PATHCONF,          getattr,        pathconf,       0),
2539         PROC(COMMIT,            commit,         commit,         5),
2540 };
2541
2542 struct rpc_version              nfs_version3 = {
2543         .number                 = 3,
2544         .nrprocs                = ARRAY_SIZE(nfs3_procedures),
2545         .procs                  = nfs3_procedures
2546 };
2547
2548 #ifdef CONFIG_NFS_V3_ACL
2549 static struct rpc_procinfo      nfs3_acl_procedures[] = {
2550         [ACLPROC3_GETACL] = {
2551                 .p_proc = ACLPROC3_GETACL,
2552                 .p_encode = (kxdrproc_t)nfs3_xdr_enc_getacl3args,
2553                 .p_decode = (kxdrproc_t)nfs3_xdr_dec_getacl3res,
2554                 .p_arglen = ACL3_getaclargs_sz,
2555                 .p_replen = ACL3_getaclres_sz,
2556                 .p_timer = 1,
2557                 .p_name = "GETACL",
2558         },
2559         [ACLPROC3_SETACL] = {
2560                 .p_proc = ACLPROC3_SETACL,
2561                 .p_encode = (kxdrproc_t)nfs3_xdr_enc_setacl3args,
2562                 .p_decode = (kxdrproc_t)nfs3_xdr_dec_setacl3res,
2563                 .p_arglen = ACL3_setaclargs_sz,
2564                 .p_replen = ACL3_setaclres_sz,
2565                 .p_timer = 0,
2566                 .p_name = "SETACL",
2567         },
2568 };
2569
2570 struct rpc_version              nfsacl_version3 = {
2571         .number                 = 3,
2572         .nrprocs                = sizeof(nfs3_acl_procedures)/
2573                                   sizeof(nfs3_acl_procedures[0]),
2574         .procs                  = nfs3_acl_procedures,
2575 };
2576 #endif  /* CONFIG_NFS_V3_ACL */