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