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