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