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