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