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