fs/nfs/nfs3xdr.c

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