Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * linux/fs/nfs/nfs3xdr.c
0004  *
0005  * XDR functions to encode/decode NFSv3 RPC arguments and results.
0006  *
0007  * Copyright (C) 1996, 1997 Olaf Kirch
0008  */
0009 
0010 #include <linux/param.h>
0011 #include <linux/time.h>
0012 #include <linux/mm.h>
0013 #include <linux/errno.h>
0014 #include <linux/string.h>
0015 #include <linux/in.h>
0016 #include <linux/pagemap.h>
0017 #include <linux/proc_fs.h>
0018 #include <linux/kdev_t.h>
0019 #include <linux/sunrpc/clnt.h>
0020 #include <linux/nfs.h>
0021 #include <linux/nfs3.h>
0022 #include <linux/nfs_fs.h>
0023 #include <linux/nfsacl.h>
0024 #include "nfstrace.h"
0025 #include "internal.h"
0026 
0027 #define NFSDBG_FACILITY     NFSDBG_XDR
0028 
0029 /* Mapping from NFS error code to "errno" error code. */
0030 #define errno_NFSERR_IO     EIO
0031 
0032 /*
0033  * Declare the space requirements for NFS arguments and replies as
0034  * number of 32bit-words
0035  */
0036 #define NFS3_pagepad_sz     (1) /* Page padding */
0037 #define NFS3_fhandle_sz     (1+16)
0038 #define NFS3_fh_sz      (NFS3_fhandle_sz)   /* shorthand */
0039 #define NFS3_post_op_fh_sz  (1+NFS3_fh_sz)
0040 #define NFS3_sattr_sz       (15)
0041 #define NFS3_filename_sz    (1+(NFS3_MAXNAMLEN>>2))
0042 #define NFS3_path_sz        (1+(NFS3_MAXPATHLEN>>2))
0043 #define NFS3_fattr_sz       (21)
0044 #define NFS3_cookieverf_sz  (NFS3_COOKIEVERFSIZE>>2)
0045 #define NFS3_wcc_attr_sz    (6)
0046 #define NFS3_pre_op_attr_sz (1+NFS3_wcc_attr_sz)
0047 #define NFS3_post_op_attr_sz    (1+NFS3_fattr_sz)
0048 #define NFS3_wcc_data_sz    (NFS3_pre_op_attr_sz+NFS3_post_op_attr_sz)
0049 #define NFS3_diropargs_sz   (NFS3_fh_sz+NFS3_filename_sz)
0050 
0051 #define NFS3_getattrargs_sz (NFS3_fh_sz)
0052 #define NFS3_setattrargs_sz (NFS3_fh_sz+NFS3_sattr_sz+3)
0053 #define NFS3_lookupargs_sz  (NFS3_fh_sz+NFS3_filename_sz)
0054 #define NFS3_accessargs_sz  (NFS3_fh_sz+1)
0055 #define NFS3_readlinkargs_sz    (NFS3_fh_sz)
0056 #define NFS3_readargs_sz    (NFS3_fh_sz+3)
0057 #define NFS3_writeargs_sz   (NFS3_fh_sz+5)
0058 #define NFS3_createargs_sz  (NFS3_diropargs_sz+NFS3_sattr_sz)
0059 #define NFS3_mkdirargs_sz   (NFS3_diropargs_sz+NFS3_sattr_sz)
0060 #define NFS3_symlinkargs_sz (NFS3_diropargs_sz+1+NFS3_sattr_sz)
0061 #define NFS3_mknodargs_sz   (NFS3_diropargs_sz+2+NFS3_sattr_sz)
0062 #define NFS3_removeargs_sz  (NFS3_fh_sz+NFS3_filename_sz)
0063 #define NFS3_renameargs_sz  (NFS3_diropargs_sz+NFS3_diropargs_sz)
0064 #define NFS3_linkargs_sz        (NFS3_fh_sz+NFS3_diropargs_sz)
0065 #define NFS3_readdirargs_sz (NFS3_fh_sz+NFS3_cookieverf_sz+3)
0066 #define NFS3_readdirplusargs_sz (NFS3_fh_sz+NFS3_cookieverf_sz+4)
0067 #define NFS3_commitargs_sz  (NFS3_fh_sz+3)
0068 
0069 #define NFS3_getattrres_sz  (1+NFS3_fattr_sz)
0070 #define NFS3_setattrres_sz  (1+NFS3_wcc_data_sz)
0071 #define NFS3_removeres_sz   (NFS3_setattrres_sz)
0072 #define NFS3_lookupres_sz   (1+NFS3_fh_sz+(2 * NFS3_post_op_attr_sz))
0073 #define NFS3_accessres_sz   (1+NFS3_post_op_attr_sz+1)
0074 #define NFS3_readlinkres_sz (1+NFS3_post_op_attr_sz+1+NFS3_pagepad_sz)
0075 #define NFS3_readres_sz     (1+NFS3_post_op_attr_sz+3+NFS3_pagepad_sz)
0076 #define NFS3_writeres_sz    (1+NFS3_wcc_data_sz+4)
0077 #define NFS3_createres_sz   (1+NFS3_post_op_fh_sz+NFS3_post_op_attr_sz+NFS3_wcc_data_sz)
0078 #define NFS3_renameres_sz   (1+(2 * NFS3_wcc_data_sz))
0079 #define NFS3_linkres_sz     (1+NFS3_post_op_attr_sz+NFS3_wcc_data_sz)
0080 #define NFS3_readdirres_sz  (1+NFS3_post_op_attr_sz+2+NFS3_pagepad_sz)
0081 #define NFS3_fsstatres_sz   (1+NFS3_post_op_attr_sz+13)
0082 #define NFS3_fsinfores_sz   (1+NFS3_post_op_attr_sz+12)
0083 #define NFS3_pathconfres_sz (1+NFS3_post_op_attr_sz+6)
0084 #define NFS3_commitres_sz   (1+NFS3_wcc_data_sz+2)
0085 
0086 #define ACL3_getaclargs_sz  (NFS3_fh_sz+1)
0087 #define ACL3_setaclargs_sz  (NFS3_fh_sz+1+ \
0088                 XDR_QUADLEN(NFS_ACL_INLINE_BUFSIZE))
0089 #define ACL3_getaclres_sz   (1+NFS3_post_op_attr_sz+1+ \
0090                 XDR_QUADLEN(NFS_ACL_INLINE_BUFSIZE)+\
0091                 NFS3_pagepad_sz)
0092 #define ACL3_setaclres_sz   (1+NFS3_post_op_attr_sz)
0093 
0094 static int nfs3_stat_to_errno(enum nfs_stat);
0095 
0096 /*
0097  * Map file type to S_IFMT bits
0098  */
0099 static const umode_t nfs_type2fmt[] = {
0100     [NF3BAD] = 0,
0101     [NF3REG] = S_IFREG,
0102     [NF3DIR] = S_IFDIR,
0103     [NF3BLK] = S_IFBLK,
0104     [NF3CHR] = S_IFCHR,
0105     [NF3LNK] = S_IFLNK,
0106     [NF3SOCK] = S_IFSOCK,
0107     [NF3FIFO] = S_IFIFO,
0108 };
0109 
0110 static struct user_namespace *rpc_userns(const struct rpc_clnt *clnt)
0111 {
0112     if (clnt && clnt->cl_cred)
0113         return clnt->cl_cred->user_ns;
0114     return &init_user_ns;
0115 }
0116 
0117 static struct user_namespace *rpc_rqst_userns(const struct rpc_rqst *rqstp)
0118 {
0119     if (rqstp->rq_task)
0120         return rpc_userns(rqstp->rq_task->tk_client);
0121     return &init_user_ns;
0122 }
0123 
0124 /*
0125  * Encode/decode NFSv3 basic data types
0126  *
0127  * Basic NFSv3 data types are defined in section 2.5 of RFC 1813:
0128  * "NFS Version 3 Protocol Specification".
0129  *
0130  * Not all basic data types have their own encoding and decoding
0131  * functions.  For run-time efficiency, some data types are encoded
0132  * or decoded inline.
0133  */
0134 
0135 static void encode_uint32(struct xdr_stream *xdr, u32 value)
0136 {
0137     __be32 *p = xdr_reserve_space(xdr, 4);
0138     *p = cpu_to_be32(value);
0139 }
0140 
0141 static int decode_uint32(struct xdr_stream *xdr, u32 *value)
0142 {
0143     __be32 *p;
0144 
0145     p = xdr_inline_decode(xdr, 4);
0146     if (unlikely(!p))
0147         return -EIO;
0148     *value = be32_to_cpup(p);
0149     return 0;
0150 }
0151 
0152 static int decode_uint64(struct xdr_stream *xdr, u64 *value)
0153 {
0154     __be32 *p;
0155 
0156     p = xdr_inline_decode(xdr, 8);
0157     if (unlikely(!p))
0158         return -EIO;
0159     xdr_decode_hyper(p, value);
0160     return 0;
0161 }
0162 
0163 /*
0164  * fileid3
0165  *
0166  *  typedef uint64 fileid3;
0167  */
0168 static __be32 *xdr_decode_fileid3(__be32 *p, u64 *fileid)
0169 {
0170     return xdr_decode_hyper(p, fileid);
0171 }
0172 
0173 static int decode_fileid3(struct xdr_stream *xdr, u64 *fileid)
0174 {
0175     return decode_uint64(xdr, fileid);
0176 }
0177 
0178 /*
0179  * filename3
0180  *
0181  *  typedef string filename3<>;
0182  */
0183 static void encode_filename3(struct xdr_stream *xdr,
0184                  const char *name, u32 length)
0185 {
0186     __be32 *p;
0187 
0188     WARN_ON_ONCE(length > NFS3_MAXNAMLEN);
0189     p = xdr_reserve_space(xdr, 4 + length);
0190     xdr_encode_opaque(p, name, length);
0191 }
0192 
0193 static int decode_inline_filename3(struct xdr_stream *xdr,
0194                    const char **name, u32 *length)
0195 {
0196     __be32 *p;
0197     u32 count;
0198 
0199     p = xdr_inline_decode(xdr, 4);
0200     if (unlikely(!p))
0201         return -EIO;
0202     count = be32_to_cpup(p);
0203     if (count > NFS3_MAXNAMLEN)
0204         goto out_nametoolong;
0205     p = xdr_inline_decode(xdr, count);
0206     if (unlikely(!p))
0207         return -EIO;
0208     *name = (const char *)p;
0209     *length = count;
0210     return 0;
0211 
0212 out_nametoolong:
0213     dprintk("NFS: returned filename too long: %u\n", count);
0214     return -ENAMETOOLONG;
0215 }
0216 
0217 /*
0218  * nfspath3
0219  *
0220  *  typedef string nfspath3<>;
0221  */
0222 static void encode_nfspath3(struct xdr_stream *xdr, struct page **pages,
0223                 const u32 length)
0224 {
0225     encode_uint32(xdr, length);
0226     xdr_write_pages(xdr, pages, 0, length);
0227 }
0228 
0229 static int decode_nfspath3(struct xdr_stream *xdr)
0230 {
0231     u32 recvd, count;
0232     __be32 *p;
0233 
0234     p = xdr_inline_decode(xdr, 4);
0235     if (unlikely(!p))
0236         return -EIO;
0237     count = be32_to_cpup(p);
0238     if (unlikely(count >= xdr->buf->page_len || count > NFS3_MAXPATHLEN))
0239         goto out_nametoolong;
0240     recvd = xdr_read_pages(xdr, count);
0241     if (unlikely(count > recvd))
0242         goto out_cheating;
0243     xdr_terminate_string(xdr->buf, count);
0244     return 0;
0245 
0246 out_nametoolong:
0247     dprintk("NFS: returned pathname too long: %u\n", count);
0248     return -ENAMETOOLONG;
0249 out_cheating:
0250     dprintk("NFS: server cheating in pathname result: "
0251         "count %u > recvd %u\n", count, recvd);
0252     return -EIO;
0253 }
0254 
0255 /*
0256  * cookie3
0257  *
0258  *  typedef uint64 cookie3
0259  */
0260 static __be32 *xdr_encode_cookie3(__be32 *p, u64 cookie)
0261 {
0262     return xdr_encode_hyper(p, cookie);
0263 }
0264 
0265 static int decode_cookie3(struct xdr_stream *xdr, u64 *cookie)
0266 {
0267     return decode_uint64(xdr, cookie);
0268 }
0269 
0270 /*
0271  * cookieverf3
0272  *
0273  *  typedef opaque cookieverf3[NFS3_COOKIEVERFSIZE];
0274  */
0275 static __be32 *xdr_encode_cookieverf3(__be32 *p, const __be32 *verifier)
0276 {
0277     memcpy(p, verifier, NFS3_COOKIEVERFSIZE);
0278     return p + XDR_QUADLEN(NFS3_COOKIEVERFSIZE);
0279 }
0280 
0281 static int decode_cookieverf3(struct xdr_stream *xdr, __be32 *verifier)
0282 {
0283     __be32 *p;
0284 
0285     p = xdr_inline_decode(xdr, NFS3_COOKIEVERFSIZE);
0286     if (unlikely(!p))
0287         return -EIO;
0288     memcpy(verifier, p, NFS3_COOKIEVERFSIZE);
0289     return 0;
0290 }
0291 
0292 /*
0293  * createverf3
0294  *
0295  *  typedef opaque createverf3[NFS3_CREATEVERFSIZE];
0296  */
0297 static void encode_createverf3(struct xdr_stream *xdr, const __be32 *verifier)
0298 {
0299     __be32 *p;
0300 
0301     p = xdr_reserve_space(xdr, NFS3_CREATEVERFSIZE);
0302     memcpy(p, verifier, NFS3_CREATEVERFSIZE);
0303 }
0304 
0305 static int decode_writeverf3(struct xdr_stream *xdr, struct nfs_write_verifier *verifier)
0306 {
0307     __be32 *p;
0308 
0309     p = xdr_inline_decode(xdr, NFS3_WRITEVERFSIZE);
0310     if (unlikely(!p))
0311         return -EIO;
0312     memcpy(verifier->data, p, NFS3_WRITEVERFSIZE);
0313     return 0;
0314 }
0315 
0316 /*
0317  * size3
0318  *
0319  *  typedef uint64 size3;
0320  */
0321 static __be32 *xdr_decode_size3(__be32 *p, u64 *size)
0322 {
0323     return xdr_decode_hyper(p, size);
0324 }
0325 
0326 /*
0327  * nfsstat3
0328  *
0329  *  enum nfsstat3 {
0330  *      NFS3_OK = 0,
0331  *      ...
0332  *  }
0333  */
0334 #define NFS3_OK     NFS_OK
0335 
0336 static int decode_nfsstat3(struct xdr_stream *xdr, enum nfs_stat *status)
0337 {
0338     __be32 *p;
0339 
0340     p = xdr_inline_decode(xdr, 4);
0341     if (unlikely(!p))
0342         return -EIO;
0343     if (unlikely(*p != cpu_to_be32(NFS3_OK)))
0344         goto out_status;
0345     *status = 0;
0346     return 0;
0347 out_status:
0348     *status = be32_to_cpup(p);
0349     trace_nfs_xdr_status(xdr, (int)*status);
0350     return 0;
0351 }
0352 
0353 /*
0354  * ftype3
0355  *
0356  *  enum ftype3 {
0357  *      NF3REG  = 1,
0358  *      NF3DIR  = 2,
0359  *      NF3BLK  = 3,
0360  *      NF3CHR  = 4,
0361  *      NF3LNK  = 5,
0362  *      NF3SOCK = 6,
0363  *      NF3FIFO = 7
0364  *  };
0365  */
0366 static void encode_ftype3(struct xdr_stream *xdr, const u32 type)
0367 {
0368     encode_uint32(xdr, type);
0369 }
0370 
0371 static __be32 *xdr_decode_ftype3(__be32 *p, umode_t *mode)
0372 {
0373     u32 type;
0374 
0375     type = be32_to_cpup(p++);
0376     if (type > NF3FIFO)
0377         type = NF3NON;
0378     *mode = nfs_type2fmt[type];
0379     return p;
0380 }
0381 
0382 /*
0383  * specdata3
0384  *
0385  *     struct specdata3 {
0386  *             uint32  specdata1;
0387  *             uint32  specdata2;
0388  *     };
0389  */
0390 static void encode_specdata3(struct xdr_stream *xdr, const dev_t rdev)
0391 {
0392     __be32 *p;
0393 
0394     p = xdr_reserve_space(xdr, 8);
0395     *p++ = cpu_to_be32(MAJOR(rdev));
0396     *p = cpu_to_be32(MINOR(rdev));
0397 }
0398 
0399 static __be32 *xdr_decode_specdata3(__be32 *p, dev_t *rdev)
0400 {
0401     unsigned int major, minor;
0402 
0403     major = be32_to_cpup(p++);
0404     minor = be32_to_cpup(p++);
0405     *rdev = MKDEV(major, minor);
0406     if (MAJOR(*rdev) != major || MINOR(*rdev) != minor)
0407         *rdev = 0;
0408     return p;
0409 }
0410 
0411 /*
0412  * nfs_fh3
0413  *
0414  *  struct nfs_fh3 {
0415  *      opaque       data<NFS3_FHSIZE>;
0416  *  };
0417  */
0418 static void encode_nfs_fh3(struct xdr_stream *xdr, const struct nfs_fh *fh)
0419 {
0420     __be32 *p;
0421 
0422     WARN_ON_ONCE(fh->size > NFS3_FHSIZE);
0423     p = xdr_reserve_space(xdr, 4 + fh->size);
0424     xdr_encode_opaque(p, fh->data, fh->size);
0425 }
0426 
0427 static int decode_nfs_fh3(struct xdr_stream *xdr, struct nfs_fh *fh)
0428 {
0429     u32 length;
0430     __be32 *p;
0431 
0432     p = xdr_inline_decode(xdr, 4);
0433     if (unlikely(!p))
0434         return -EIO;
0435     length = be32_to_cpup(p++);
0436     if (unlikely(length > NFS3_FHSIZE || length == 0))
0437         goto out_toobig;
0438     p = xdr_inline_decode(xdr, length);
0439     if (unlikely(!p))
0440         return -EIO;
0441     fh->size = length;
0442     memcpy(fh->data, p, length);
0443     return 0;
0444 out_toobig:
0445     trace_nfs_xdr_bad_filehandle(xdr, NFSERR_BADHANDLE);
0446     return -E2BIG;
0447 }
0448 
0449 static void zero_nfs_fh3(struct nfs_fh *fh)
0450 {
0451     memset(fh, 0, sizeof(*fh));
0452 }
0453 
0454 /*
0455  * nfstime3
0456  *
0457  *  struct nfstime3 {
0458  *      uint32  seconds;
0459  *      uint32  nseconds;
0460  *  };
0461  */
0462 static __be32 *xdr_encode_nfstime3(__be32 *p, const struct timespec64 *timep)
0463 {
0464     *p++ = cpu_to_be32((u32)timep->tv_sec);
0465     *p++ = cpu_to_be32(timep->tv_nsec);
0466     return p;
0467 }
0468 
0469 static __be32 *xdr_decode_nfstime3(__be32 *p, struct timespec64 *timep)
0470 {
0471     timep->tv_sec = be32_to_cpup(p++);
0472     timep->tv_nsec = be32_to_cpup(p++);
0473     return p;
0474 }
0475 
0476 /*
0477  * sattr3
0478  *
0479  *  enum time_how {
0480  *      DONT_CHANGE     = 0,
0481  *      SET_TO_SERVER_TIME  = 1,
0482  *      SET_TO_CLIENT_TIME  = 2
0483  *  };
0484  *
0485  *  union set_mode3 switch (bool set_it) {
0486  *  case TRUE:
0487  *      mode3   mode;
0488  *  default:
0489  *      void;
0490  *  };
0491  *
0492  *  union set_uid3 switch (bool set_it) {
0493  *  case TRUE:
0494  *      uid3    uid;
0495  *  default:
0496  *      void;
0497  *  };
0498  *
0499  *  union set_gid3 switch (bool set_it) {
0500  *  case TRUE:
0501  *      gid3    gid;
0502  *  default:
0503  *      void;
0504  *  };
0505  *
0506  *  union set_size3 switch (bool set_it) {
0507  *  case TRUE:
0508  *      size3   size;
0509  *  default:
0510  *      void;
0511  *  };
0512  *
0513  *  union set_atime switch (time_how set_it) {
0514  *  case SET_TO_CLIENT_TIME:
0515  *      nfstime3    atime;
0516  *  default:
0517  *      void;
0518  *  };
0519  *
0520  *  union set_mtime switch (time_how set_it) {
0521  *  case SET_TO_CLIENT_TIME:
0522  *      nfstime3  mtime;
0523  *  default:
0524  *      void;
0525  *  };
0526  *
0527  *  struct sattr3 {
0528  *      set_mode3   mode;
0529  *      set_uid3    uid;
0530  *      set_gid3    gid;
0531  *      set_size3   size;
0532  *      set_atime   atime;
0533  *      set_mtime   mtime;
0534  *  };
0535  */
0536 static void encode_sattr3(struct xdr_stream *xdr, const struct iattr *attr,
0537         struct user_namespace *userns)
0538 {
0539     u32 nbytes;
0540     __be32 *p;
0541 
0542     /*
0543      * In order to make only a single xdr_reserve_space() call,
0544      * pre-compute the total number of bytes to be reserved.
0545      * Six boolean values, one for each set_foo field, are always
0546      * present in the encoded result, so start there.
0547      */
0548     nbytes = 6 * 4;
0549     if (attr->ia_valid & ATTR_MODE)
0550         nbytes += 4;
0551     if (attr->ia_valid & ATTR_UID)
0552         nbytes += 4;
0553     if (attr->ia_valid & ATTR_GID)
0554         nbytes += 4;
0555     if (attr->ia_valid & ATTR_SIZE)
0556         nbytes += 8;
0557     if (attr->ia_valid & ATTR_ATIME_SET)
0558         nbytes += 8;
0559     if (attr->ia_valid & ATTR_MTIME_SET)
0560         nbytes += 8;
0561     p = xdr_reserve_space(xdr, nbytes);
0562 
0563     if (attr->ia_valid & ATTR_MODE) {
0564         *p++ = xdr_one;
0565         *p++ = cpu_to_be32(attr->ia_mode & S_IALLUGO);
0566     } else
0567         *p++ = xdr_zero;
0568 
0569     if (attr->ia_valid & ATTR_UID) {
0570         *p++ = xdr_one;
0571         *p++ = cpu_to_be32(from_kuid_munged(userns, attr->ia_uid));
0572     } else
0573         *p++ = xdr_zero;
0574 
0575     if (attr->ia_valid & ATTR_GID) {
0576         *p++ = xdr_one;
0577         *p++ = cpu_to_be32(from_kgid_munged(userns, attr->ia_gid));
0578     } else
0579         *p++ = xdr_zero;
0580 
0581     if (attr->ia_valid & ATTR_SIZE) {
0582         *p++ = xdr_one;
0583         p = xdr_encode_hyper(p, (u64)attr->ia_size);
0584     } else
0585         *p++ = xdr_zero;
0586 
0587     if (attr->ia_valid & ATTR_ATIME_SET) {
0588         *p++ = xdr_two;
0589         p = xdr_encode_nfstime3(p, &attr->ia_atime);
0590     } else if (attr->ia_valid & ATTR_ATIME) {
0591         *p++ = xdr_one;
0592     } else
0593         *p++ = xdr_zero;
0594 
0595     if (attr->ia_valid & ATTR_MTIME_SET) {
0596         *p++ = xdr_two;
0597         xdr_encode_nfstime3(p, &attr->ia_mtime);
0598     } else if (attr->ia_valid & ATTR_MTIME) {
0599         *p = xdr_one;
0600     } else
0601         *p = xdr_zero;
0602 }
0603 
0604 /*
0605  * fattr3
0606  *
0607  *  struct fattr3 {
0608  *      ftype3      type;
0609  *      mode3       mode;
0610  *      uint32      nlink;
0611  *      uid3        uid;
0612  *      gid3        gid;
0613  *      size3       size;
0614  *      size3       used;
0615  *      specdata3   rdev;
0616  *      uint64      fsid;
0617  *      fileid3     fileid;
0618  *      nfstime3    atime;
0619  *      nfstime3    mtime;
0620  *      nfstime3    ctime;
0621  *  };
0622  */
0623 static int decode_fattr3(struct xdr_stream *xdr, struct nfs_fattr *fattr,
0624         struct user_namespace *userns)
0625 {
0626     umode_t fmode;
0627     __be32 *p;
0628 
0629     p = xdr_inline_decode(xdr, NFS3_fattr_sz << 2);
0630     if (unlikely(!p))
0631         return -EIO;
0632 
0633     p = xdr_decode_ftype3(p, &fmode);
0634 
0635     fattr->mode = (be32_to_cpup(p++) & ~S_IFMT) | fmode;
0636     fattr->nlink = be32_to_cpup(p++);
0637     fattr->uid = make_kuid(userns, be32_to_cpup(p++));
0638     if (!uid_valid(fattr->uid))
0639         goto out_uid;
0640     fattr->gid = make_kgid(userns, be32_to_cpup(p++));
0641     if (!gid_valid(fattr->gid))
0642         goto out_gid;
0643 
0644     p = xdr_decode_size3(p, &fattr->size);
0645     p = xdr_decode_size3(p, &fattr->du.nfs3.used);
0646     p = xdr_decode_specdata3(p, &fattr->rdev);
0647 
0648     p = xdr_decode_hyper(p, &fattr->fsid.major);
0649     fattr->fsid.minor = 0;
0650 
0651     p = xdr_decode_fileid3(p, &fattr->fileid);
0652     p = xdr_decode_nfstime3(p, &fattr->atime);
0653     p = xdr_decode_nfstime3(p, &fattr->mtime);
0654     xdr_decode_nfstime3(p, &fattr->ctime);
0655     fattr->change_attr = nfs_timespec_to_change_attr(&fattr->ctime);
0656 
0657     fattr->valid |= NFS_ATTR_FATTR_V3;
0658     return 0;
0659 out_uid:
0660     dprintk("NFS: returned invalid uid\n");
0661     return -EINVAL;
0662 out_gid:
0663     dprintk("NFS: returned invalid gid\n");
0664     return -EINVAL;
0665 }
0666 
0667 /*
0668  * post_op_attr
0669  *
0670  *  union post_op_attr switch (bool attributes_follow) {
0671  *  case TRUE:
0672  *      fattr3  attributes;
0673  *  case FALSE:
0674  *      void;
0675  *  };
0676  */
0677 static int decode_post_op_attr(struct xdr_stream *xdr, struct nfs_fattr *fattr,
0678         struct user_namespace *userns)
0679 {
0680     __be32 *p;
0681 
0682     p = xdr_inline_decode(xdr, 4);
0683     if (unlikely(!p))
0684         return -EIO;
0685     if (*p != xdr_zero)
0686         return decode_fattr3(xdr, fattr, userns);
0687     return 0;
0688 }
0689 
0690 /*
0691  * wcc_attr
0692  *  struct wcc_attr {
0693  *      size3       size;
0694  *      nfstime3    mtime;
0695  *      nfstime3    ctime;
0696  *  };
0697  */
0698 static int decode_wcc_attr(struct xdr_stream *xdr, struct nfs_fattr *fattr)
0699 {
0700     __be32 *p;
0701 
0702     p = xdr_inline_decode(xdr, NFS3_wcc_attr_sz << 2);
0703     if (unlikely(!p))
0704         return -EIO;
0705 
0706     fattr->valid |= NFS_ATTR_FATTR_PRESIZE
0707         | NFS_ATTR_FATTR_PRECHANGE
0708         | NFS_ATTR_FATTR_PREMTIME
0709         | NFS_ATTR_FATTR_PRECTIME;
0710 
0711     p = xdr_decode_size3(p, &fattr->pre_size);
0712     p = xdr_decode_nfstime3(p, &fattr->pre_mtime);
0713     xdr_decode_nfstime3(p, &fattr->pre_ctime);
0714     fattr->pre_change_attr = nfs_timespec_to_change_attr(&fattr->pre_ctime);
0715 
0716     return 0;
0717 }
0718 
0719 /*
0720  * pre_op_attr
0721  *  union pre_op_attr switch (bool attributes_follow) {
0722  *  case TRUE:
0723  *      wcc_attr    attributes;
0724  *  case FALSE:
0725  *      void;
0726  *  };
0727  *
0728  * wcc_data
0729  *
0730  *  struct wcc_data {
0731  *      pre_op_attr before;
0732  *      post_op_attr    after;
0733  *  };
0734  */
0735 static int decode_pre_op_attr(struct xdr_stream *xdr, struct nfs_fattr *fattr)
0736 {
0737     __be32 *p;
0738 
0739     p = xdr_inline_decode(xdr, 4);
0740     if (unlikely(!p))
0741         return -EIO;
0742     if (*p != xdr_zero)
0743         return decode_wcc_attr(xdr, fattr);
0744     return 0;
0745 }
0746 
0747 static int decode_wcc_data(struct xdr_stream *xdr, struct nfs_fattr *fattr,
0748         struct user_namespace *userns)
0749 {
0750     int error;
0751 
0752     error = decode_pre_op_attr(xdr, fattr);
0753     if (unlikely(error))
0754         goto out;
0755     error = decode_post_op_attr(xdr, fattr, userns);
0756 out:
0757     return error;
0758 }
0759 
0760 /*
0761  * post_op_fh3
0762  *
0763  *  union post_op_fh3 switch (bool handle_follows) {
0764  *  case TRUE:
0765  *      nfs_fh3  handle;
0766  *  case FALSE:
0767  *      void;
0768  *  };
0769  */
0770 static int decode_post_op_fh3(struct xdr_stream *xdr, struct nfs_fh *fh)
0771 {
0772     __be32 *p = xdr_inline_decode(xdr, 4);
0773     if (unlikely(!p))
0774         return -EIO;
0775     if (*p != xdr_zero)
0776         return decode_nfs_fh3(xdr, fh);
0777     zero_nfs_fh3(fh);
0778     return 0;
0779 }
0780 
0781 /*
0782  * diropargs3
0783  *
0784  *  struct diropargs3 {
0785  *      nfs_fh3     dir;
0786  *      filename3   name;
0787  *  };
0788  */
0789 static void encode_diropargs3(struct xdr_stream *xdr, const struct nfs_fh *fh,
0790                   const char *name, u32 length)
0791 {
0792     encode_nfs_fh3(xdr, fh);
0793     encode_filename3(xdr, name, length);
0794 }
0795 
0796 
0797 /*
0798  * NFSv3 XDR encode functions
0799  *
0800  * NFSv3 argument types are defined in section 3.3 of RFC 1813:
0801  * "NFS Version 3 Protocol Specification".
0802  */
0803 
0804 /*
0805  * 3.3.1  GETATTR3args
0806  *
0807  *  struct GETATTR3args {
0808  *      nfs_fh3  object;
0809  *  };
0810  */
0811 static void nfs3_xdr_enc_getattr3args(struct rpc_rqst *req,
0812                       struct xdr_stream *xdr,
0813                       const void *data)
0814 {
0815     const struct nfs_fh *fh = data;
0816 
0817     encode_nfs_fh3(xdr, fh);
0818 }
0819 
0820 /*
0821  * 3.3.2  SETATTR3args
0822  *
0823  *  union sattrguard3 switch (bool check) {
0824  *  case TRUE:
0825  *      nfstime3  obj_ctime;
0826  *  case FALSE:
0827  *      void;
0828  *  };
0829  *
0830  *  struct SETATTR3args {
0831  *      nfs_fh3     object;
0832  *      sattr3      new_attributes;
0833  *      sattrguard3 guard;
0834  *  };
0835  */
0836 static void encode_sattrguard3(struct xdr_stream *xdr,
0837                    const struct nfs3_sattrargs *args)
0838 {
0839     __be32 *p;
0840 
0841     if (args->guard) {
0842         p = xdr_reserve_space(xdr, 4 + 8);
0843         *p++ = xdr_one;
0844         xdr_encode_nfstime3(p, &args->guardtime);
0845     } else {
0846         p = xdr_reserve_space(xdr, 4);
0847         *p = xdr_zero;
0848     }
0849 }
0850 
0851 static void nfs3_xdr_enc_setattr3args(struct rpc_rqst *req,
0852                       struct xdr_stream *xdr,
0853                       const void *data)
0854 {
0855     const struct nfs3_sattrargs *args = data;
0856     encode_nfs_fh3(xdr, args->fh);
0857     encode_sattr3(xdr, args->sattr, rpc_rqst_userns(req));
0858     encode_sattrguard3(xdr, args);
0859 }
0860 
0861 /*
0862  * 3.3.3  LOOKUP3args
0863  *
0864  *  struct LOOKUP3args {
0865  *      diropargs3  what;
0866  *  };
0867  */
0868 static void nfs3_xdr_enc_lookup3args(struct rpc_rqst *req,
0869                      struct xdr_stream *xdr,
0870                      const void *data)
0871 {
0872     const struct nfs3_diropargs *args = data;
0873 
0874     encode_diropargs3(xdr, args->fh, args->name, args->len);
0875 }
0876 
0877 /*
0878  * 3.3.4  ACCESS3args
0879  *
0880  *  struct ACCESS3args {
0881  *      nfs_fh3     object;
0882  *      uint32      access;
0883  *  };
0884  */
0885 static void encode_access3args(struct xdr_stream *xdr,
0886                    const struct nfs3_accessargs *args)
0887 {
0888     encode_nfs_fh3(xdr, args->fh);
0889     encode_uint32(xdr, args->access);
0890 }
0891 
0892 static void nfs3_xdr_enc_access3args(struct rpc_rqst *req,
0893                      struct xdr_stream *xdr,
0894                      const void *data)
0895 {
0896     const struct nfs3_accessargs *args = data;
0897 
0898     encode_access3args(xdr, args);
0899 }
0900 
0901 /*
0902  * 3.3.5  READLINK3args
0903  *
0904  *  struct READLINK3args {
0905  *      nfs_fh3 symlink;
0906  *  };
0907  */
0908 static void nfs3_xdr_enc_readlink3args(struct rpc_rqst *req,
0909                        struct xdr_stream *xdr,
0910                        const void *data)
0911 {
0912     const struct nfs3_readlinkargs *args = data;
0913 
0914     encode_nfs_fh3(xdr, args->fh);
0915     rpc_prepare_reply_pages(req, args->pages, args->pgbase, args->pglen,
0916                 NFS3_readlinkres_sz - NFS3_pagepad_sz);
0917 }
0918 
0919 /*
0920  * 3.3.6  READ3args
0921  *
0922  *  struct READ3args {
0923  *      nfs_fh3     file;
0924  *      offset3     offset;
0925  *      count3      count;
0926  *  };
0927  */
0928 static void encode_read3args(struct xdr_stream *xdr,
0929                  const struct nfs_pgio_args *args)
0930 {
0931     __be32 *p;
0932 
0933     encode_nfs_fh3(xdr, args->fh);
0934 
0935     p = xdr_reserve_space(xdr, 8 + 4);
0936     p = xdr_encode_hyper(p, args->offset);
0937     *p = cpu_to_be32(args->count);
0938 }
0939 
0940 static void nfs3_xdr_enc_read3args(struct rpc_rqst *req,
0941                    struct xdr_stream *xdr,
0942                    const void *data)
0943 {
0944     const struct nfs_pgio_args *args = data;
0945     unsigned int replen = args->replen ? args->replen :
0946                          NFS3_readres_sz - NFS3_pagepad_sz;
0947 
0948     encode_read3args(xdr, args);
0949     rpc_prepare_reply_pages(req, args->pages, args->pgbase,
0950                 args->count, replen);
0951     req->rq_rcv_buf.flags |= XDRBUF_READ;
0952 }
0953 
0954 /*
0955  * 3.3.7  WRITE3args
0956  *
0957  *  enum stable_how {
0958  *      UNSTABLE  = 0,
0959  *      DATA_SYNC = 1,
0960  *      FILE_SYNC = 2
0961  *  };
0962  *
0963  *  struct WRITE3args {
0964  *      nfs_fh3     file;
0965  *      offset3     offset;
0966  *      count3      count;
0967  *      stable_how  stable;
0968  *      opaque      data<>;
0969  *  };
0970  */
0971 static void encode_write3args(struct xdr_stream *xdr,
0972                   const struct nfs_pgio_args *args)
0973 {
0974     __be32 *p;
0975 
0976     encode_nfs_fh3(xdr, args->fh);
0977 
0978     p = xdr_reserve_space(xdr, 8 + 4 + 4 + 4);
0979     p = xdr_encode_hyper(p, args->offset);
0980     *p++ = cpu_to_be32(args->count);
0981     *p++ = cpu_to_be32(args->stable);
0982     *p = cpu_to_be32(args->count);
0983     xdr_write_pages(xdr, args->pages, args->pgbase, args->count);
0984 }
0985 
0986 static void nfs3_xdr_enc_write3args(struct rpc_rqst *req,
0987                     struct xdr_stream *xdr,
0988                     const void *data)
0989 {
0990     const struct nfs_pgio_args *args = data;
0991 
0992     encode_write3args(xdr, args);
0993     xdr->buf->flags |= XDRBUF_WRITE;
0994 }
0995 
0996 /*
0997  * 3.3.8  CREATE3args
0998  *
0999  *  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     uint32_t dircount = args->count;
1265     uint32_t maxcount = args->count;
1266     __be32 *p;
1267 
1268     encode_nfs_fh3(xdr, args->fh);
1269 
1270     p = xdr_reserve_space(xdr, 8 + NFS3_COOKIEVERFSIZE + 4 + 4);
1271     p = xdr_encode_cookie3(p, args->cookie);
1272     p = xdr_encode_cookieverf3(p, args->verf);
1273 
1274     /*
1275      * readdirplus: need dircount + buffer size.
1276      * We just make sure we make dircount big enough
1277      */
1278     *p++ = cpu_to_be32(dircount);
1279     *p = cpu_to_be32(maxcount);
1280 }
1281 
1282 static void nfs3_xdr_enc_readdirplus3args(struct rpc_rqst *req,
1283                       struct xdr_stream *xdr,
1284                       const void *data)
1285 {
1286     const struct nfs3_readdirargs *args = data;
1287 
1288     encode_readdirplus3args(xdr, args);
1289     rpc_prepare_reply_pages(req, args->pages, 0, args->count,
1290                 NFS3_readdirres_sz - NFS3_pagepad_sz);
1291 }
1292 
1293 /*
1294  * 3.3.21  COMMIT3args
1295  *
1296  *  struct COMMIT3args {
1297  *      nfs_fh3     file;
1298  *      offset3     offset;
1299  *      count3      count;
1300  *  };
1301  */
1302 static void encode_commit3args(struct xdr_stream *xdr,
1303                    const struct nfs_commitargs *args)
1304 {
1305     __be32 *p;
1306 
1307     encode_nfs_fh3(xdr, args->fh);
1308 
1309     p = xdr_reserve_space(xdr, 8 + 4);
1310     p = xdr_encode_hyper(p, args->offset);
1311     *p = cpu_to_be32(args->count);
1312 }
1313 
1314 static void nfs3_xdr_enc_commit3args(struct rpc_rqst *req,
1315                      struct xdr_stream *xdr,
1316                      const void *data)
1317 {
1318     const struct nfs_commitargs *args = data;
1319 
1320     encode_commit3args(xdr, args);
1321 }
1322 
1323 #ifdef CONFIG_NFS_V3_ACL
1324 
1325 static void nfs3_xdr_enc_getacl3args(struct rpc_rqst *req,
1326                      struct xdr_stream *xdr,
1327                      const void *data)
1328 {
1329     const struct nfs3_getaclargs *args = data;
1330 
1331     encode_nfs_fh3(xdr, args->fh);
1332     encode_uint32(xdr, args->mask);
1333     if (args->mask & (NFS_ACL | NFS_DFACL)) {
1334         rpc_prepare_reply_pages(req, args->pages, 0,
1335                     NFSACL_MAXPAGES << PAGE_SHIFT,
1336                     ACL3_getaclres_sz - NFS3_pagepad_sz);
1337         req->rq_rcv_buf.flags |= XDRBUF_SPARSE_PAGES;
1338     }
1339 }
1340 
1341 static void nfs3_xdr_enc_setacl3args(struct rpc_rqst *req,
1342                      struct xdr_stream *xdr,
1343                      const void *data)
1344 {
1345     const struct nfs3_setaclargs *args = data;
1346     unsigned int base;
1347     int error;
1348 
1349     encode_nfs_fh3(xdr, NFS_FH(args->inode));
1350     encode_uint32(xdr, args->mask);
1351 
1352     base = req->rq_slen;
1353     if (args->npages != 0)
1354         xdr_write_pages(xdr, args->pages, 0, args->len);
1355     else
1356         xdr_reserve_space(xdr, args->len);
1357 
1358     error = nfsacl_encode(xdr->buf, base, args->inode,
1359                 (args->mask & NFS_ACL) ?
1360                 args->acl_access : NULL, 1, 0);
1361     /* FIXME: this is just broken */
1362     BUG_ON(error < 0);
1363     error = nfsacl_encode(xdr->buf, base + error, args->inode,
1364                 (args->mask & NFS_DFACL) ?
1365                 args->acl_default : NULL, 1,
1366                 NFS_ACL_DEFAULT);
1367     BUG_ON(error < 0);
1368 }
1369 
1370 #endif  /* CONFIG_NFS_V3_ACL */
1371 
1372 /*
1373  * NFSv3 XDR decode functions
1374  *
1375  * NFSv3 result types are defined in section 3.3 of RFC 1813:
1376  * "NFS Version 3 Protocol Specification".
1377  */
1378 
1379 /*
1380  * 3.3.1  GETATTR3res
1381  *
1382  *  struct GETATTR3resok {
1383  *      fattr3      obj_attributes;
1384  *  };
1385  *
1386  *  union GETATTR3res switch (nfsstat3 status) {
1387  *  case NFS3_OK:
1388  *      GETATTR3resok  resok;
1389  *  default:
1390  *      void;
1391  *  };
1392  */
1393 static int nfs3_xdr_dec_getattr3res(struct rpc_rqst *req,
1394                     struct xdr_stream *xdr,
1395                     void *result)
1396 {
1397     enum nfs_stat status;
1398     int error;
1399 
1400     error = decode_nfsstat3(xdr, &status);
1401     if (unlikely(error))
1402         goto out;
1403     if (status != NFS3_OK)
1404         goto out_default;
1405     error = decode_fattr3(xdr, result, rpc_rqst_userns(req));
1406 out:
1407     return error;
1408 out_default:
1409     return nfs3_stat_to_errno(status);
1410 }
1411 
1412 /*
1413  * 3.3.2  SETATTR3res
1414  *
1415  *  struct SETATTR3resok {
1416  *      wcc_data  obj_wcc;
1417  *  };
1418  *
1419  *  struct SETATTR3resfail {
1420  *      wcc_data  obj_wcc;
1421  *  };
1422  *
1423  *  union SETATTR3res switch (nfsstat3 status) {
1424  *  case NFS3_OK:
1425  *      SETATTR3resok   resok;
1426  *  default:
1427  *      SETATTR3resfail resfail;
1428  *  };
1429  */
1430 static int nfs3_xdr_dec_setattr3res(struct rpc_rqst *req,
1431                     struct xdr_stream *xdr,
1432                     void *result)
1433 {
1434     enum nfs_stat status;
1435     int error;
1436 
1437     error = decode_nfsstat3(xdr, &status);
1438     if (unlikely(error))
1439         goto out;
1440     error = decode_wcc_data(xdr, result, rpc_rqst_userns(req));
1441     if (unlikely(error))
1442         goto out;
1443     if (status != NFS3_OK)
1444         goto out_status;
1445 out:
1446     return error;
1447 out_status:
1448     return nfs3_stat_to_errno(status);
1449 }
1450 
1451 /*
1452  * 3.3.3  LOOKUP3res
1453  *
1454  *  struct LOOKUP3resok {
1455  *      nfs_fh3     object;
1456  *      post_op_attr    obj_attributes;
1457  *      post_op_attr    dir_attributes;
1458  *  };
1459  *
1460  *  struct LOOKUP3resfail {
1461  *      post_op_attr    dir_attributes;
1462  *  };
1463  *
1464  *  union LOOKUP3res switch (nfsstat3 status) {
1465  *  case NFS3_OK:
1466  *      LOOKUP3resok    resok;
1467  *  default:
1468  *      LOOKUP3resfail  resfail;
1469  *  };
1470  */
1471 static int nfs3_xdr_dec_lookup3res(struct rpc_rqst *req,
1472                    struct xdr_stream *xdr,
1473                    void *data)
1474 {
1475     struct user_namespace *userns = rpc_rqst_userns(req);
1476     struct nfs3_diropres *result = data;
1477     enum nfs_stat status;
1478     int error;
1479 
1480     error = decode_nfsstat3(xdr, &status);
1481     if (unlikely(error))
1482         goto out;
1483     if (status != NFS3_OK)
1484         goto out_default;
1485     error = decode_nfs_fh3(xdr, result->fh);
1486     if (unlikely(error))
1487         goto out;
1488     error = decode_post_op_attr(xdr, result->fattr, userns);
1489     if (unlikely(error))
1490         goto out;
1491     error = decode_post_op_attr(xdr, result->dir_attr, userns);
1492 out:
1493     return error;
1494 out_default:
1495     error = decode_post_op_attr(xdr, result->dir_attr, userns);
1496     if (unlikely(error))
1497         goto out;
1498     return nfs3_stat_to_errno(status);
1499 }
1500 
1501 /*
1502  * 3.3.4  ACCESS3res
1503  *
1504  *  struct ACCESS3resok {
1505  *      post_op_attr    obj_attributes;
1506  *      uint32      access;
1507  *  };
1508  *
1509  *  struct ACCESS3resfail {
1510  *      post_op_attr    obj_attributes;
1511  *  };
1512  *
1513  *  union ACCESS3res switch (nfsstat3 status) {
1514  *  case NFS3_OK:
1515  *      ACCESS3resok    resok;
1516  *  default:
1517  *      ACCESS3resfail  resfail;
1518  *  };
1519  */
1520 static int nfs3_xdr_dec_access3res(struct rpc_rqst *req,
1521                    struct xdr_stream *xdr,
1522                    void *data)
1523 {
1524     struct nfs3_accessres *result = data;
1525     enum nfs_stat status;
1526     int error;
1527 
1528     error = decode_nfsstat3(xdr, &status);
1529     if (unlikely(error))
1530         goto out;
1531     error = decode_post_op_attr(xdr, result->fattr, rpc_rqst_userns(req));
1532     if (unlikely(error))
1533         goto out;
1534     if (status != NFS3_OK)
1535         goto out_default;
1536     error = decode_uint32(xdr, &result->access);
1537 out:
1538     return error;
1539 out_default:
1540     return nfs3_stat_to_errno(status);
1541 }
1542 
1543 /*
1544  * 3.3.5  READLINK3res
1545  *
1546  *  struct READLINK3resok {
1547  *      post_op_attr    symlink_attributes;
1548  *      nfspath3    data;
1549  *  };
1550  *
1551  *  struct READLINK3resfail {
1552  *      post_op_attr    symlink_attributes;
1553  *  };
1554  *
1555  *  union READLINK3res switch (nfsstat3 status) {
1556  *  case NFS3_OK:
1557  *      READLINK3resok  resok;
1558  *  default:
1559  *      READLINK3resfail resfail;
1560  *  };
1561  */
1562 static int nfs3_xdr_dec_readlink3res(struct rpc_rqst *req,
1563                      struct xdr_stream *xdr,
1564                      void *result)
1565 {
1566     enum nfs_stat status;
1567     int error;
1568 
1569     error = decode_nfsstat3(xdr, &status);
1570     if (unlikely(error))
1571         goto out;
1572     error = decode_post_op_attr(xdr, result, rpc_rqst_userns(req));
1573     if (unlikely(error))
1574         goto out;
1575     if (status != NFS3_OK)
1576         goto out_default;
1577     error = decode_nfspath3(xdr);
1578 out:
1579     return error;
1580 out_default:
1581     return nfs3_stat_to_errno(status);
1582 }
1583 
1584 /*
1585  * 3.3.6  READ3res
1586  *
1587  *  struct READ3resok {
1588  *      post_op_attr    file_attributes;
1589  *      count3      count;
1590  *      bool        eof;
1591  *      opaque      data<>;
1592  *  };
1593  *
1594  *  struct READ3resfail {
1595  *      post_op_attr    file_attributes;
1596  *  };
1597  *
1598  *  union READ3res switch (nfsstat3 status) {
1599  *  case NFS3_OK:
1600  *      READ3resok  resok;
1601  *  default:
1602  *      READ3resfail    resfail;
1603  *  };
1604  */
1605 static int decode_read3resok(struct xdr_stream *xdr,
1606                  struct nfs_pgio_res *result)
1607 {
1608     u32 eof, count, ocount, recvd;
1609     __be32 *p;
1610 
1611     p = xdr_inline_decode(xdr, 4 + 4 + 4);
1612     if (unlikely(!p))
1613         return -EIO;
1614     count = be32_to_cpup(p++);
1615     eof = be32_to_cpup(p++);
1616     ocount = be32_to_cpup(p++);
1617     if (unlikely(ocount != count))
1618         goto out_mismatch;
1619     recvd = xdr_read_pages(xdr, count);
1620     if (unlikely(count > recvd))
1621         goto out_cheating;
1622 out:
1623     result->eof = eof;
1624     result->count = count;
1625     return count;
1626 out_mismatch:
1627     dprintk("NFS: READ count doesn't match length of opaque: "
1628         "count %u != ocount %u\n", count, ocount);
1629     return -EIO;
1630 out_cheating:
1631     dprintk("NFS: server cheating in read result: "
1632         "count %u > recvd %u\n", count, recvd);
1633     count = recvd;
1634     eof = 0;
1635     goto out;
1636 }
1637 
1638 static int nfs3_xdr_dec_read3res(struct rpc_rqst *req, struct xdr_stream *xdr,
1639                  void *data)
1640 {
1641     struct nfs_pgio_res *result = data;
1642     unsigned int pos;
1643     enum nfs_stat status;
1644     int error;
1645 
1646     pos = xdr_stream_pos(xdr);
1647     error = decode_nfsstat3(xdr, &status);
1648     if (unlikely(error))
1649         goto out;
1650     error = decode_post_op_attr(xdr, result->fattr, rpc_rqst_userns(req));
1651     if (unlikely(error))
1652         goto out;
1653     result->op_status = status;
1654     if (status != NFS3_OK)
1655         goto out_status;
1656     result->replen = 3 + ((xdr_stream_pos(xdr) - pos) >> 2);
1657     error = decode_read3resok(xdr, result);
1658 out:
1659     return error;
1660 out_status:
1661     return nfs3_stat_to_errno(status);
1662 }
1663 
1664 /*
1665  * 3.3.7  WRITE3res
1666  *
1667  *  enum stable_how {
1668  *      UNSTABLE  = 0,
1669  *      DATA_SYNC = 1,
1670  *      FILE_SYNC = 2
1671  *  };
1672  *
1673  *  struct WRITE3resok {
1674  *      wcc_data    file_wcc;
1675  *      count3      count;
1676  *      stable_how  committed;
1677  *      writeverf3  verf;
1678  *  };
1679  *
1680  *  struct WRITE3resfail {
1681  *      wcc_data    file_wcc;
1682  *  };
1683  *
1684  *  union WRITE3res switch (nfsstat3 status) {
1685  *  case NFS3_OK:
1686  *      WRITE3resok resok;
1687  *  default:
1688  *      WRITE3resfail   resfail;
1689  *  };
1690  */
1691 static int decode_write3resok(struct xdr_stream *xdr,
1692                   struct nfs_pgio_res *result)
1693 {
1694     __be32 *p;
1695 
1696     p = xdr_inline_decode(xdr, 4 + 4);
1697     if (unlikely(!p))
1698         return -EIO;
1699     result->count = be32_to_cpup(p++);
1700     result->verf->committed = be32_to_cpup(p++);
1701     if (unlikely(result->verf->committed > NFS_FILE_SYNC))
1702         goto out_badvalue;
1703     if (decode_writeverf3(xdr, &result->verf->verifier))
1704         return -EIO;
1705     return result->count;
1706 out_badvalue:
1707     dprintk("NFS: bad stable_how value: %u\n", result->verf->committed);
1708     return -EIO;
1709 }
1710 
1711 static int nfs3_xdr_dec_write3res(struct rpc_rqst *req, struct xdr_stream *xdr,
1712                   void *data)
1713 {
1714     struct nfs_pgio_res *result = data;
1715     enum nfs_stat status;
1716     int error;
1717 
1718     error = decode_nfsstat3(xdr, &status);
1719     if (unlikely(error))
1720         goto out;
1721     error = decode_wcc_data(xdr, result->fattr, rpc_rqst_userns(req));
1722     if (unlikely(error))
1723         goto out;
1724     result->op_status = status;
1725     if (status != NFS3_OK)
1726         goto out_status;
1727     error = decode_write3resok(xdr, result);
1728 out:
1729     return error;
1730 out_status:
1731     return nfs3_stat_to_errno(status);
1732 }
1733 
1734 /*
1735  * 3.3.8  CREATE3res
1736  *
1737  *  struct CREATE3resok {
1738  *      post_op_fh3 obj;
1739  *      post_op_attr    obj_attributes;
1740  *      wcc_data    dir_wcc;
1741  *  };
1742  *
1743  *  struct CREATE3resfail {
1744  *      wcc_data    dir_wcc;
1745  *  };
1746  *
1747  *  union CREATE3res switch (nfsstat3 status) {
1748  *  case NFS3_OK:
1749  *      CREATE3resok    resok;
1750  *  default:
1751  *      CREATE3resfail  resfail;
1752  *  };
1753  */
1754 static int decode_create3resok(struct xdr_stream *xdr,
1755                    struct nfs3_diropres *result,
1756                    struct user_namespace *userns)
1757 {
1758     int error;
1759 
1760     error = decode_post_op_fh3(xdr, result->fh);
1761     if (unlikely(error))
1762         goto out;
1763     error = decode_post_op_attr(xdr, result->fattr, userns);
1764     if (unlikely(error))
1765         goto out;
1766     /* The server isn't required to return a file handle.
1767      * If it didn't, force the client to perform a LOOKUP
1768      * to determine the correct file handle and attribute
1769      * values for the new object. */
1770     if (result->fh->size == 0)
1771         result->fattr->valid = 0;
1772     error = decode_wcc_data(xdr, result->dir_attr, userns);
1773 out:
1774     return error;
1775 }
1776 
1777 static int nfs3_xdr_dec_create3res(struct rpc_rqst *req,
1778                    struct xdr_stream *xdr,
1779                    void *data)
1780 {
1781     struct user_namespace *userns = rpc_rqst_userns(req);
1782     struct nfs3_diropres *result = data;
1783     enum nfs_stat status;
1784     int error;
1785 
1786     error = decode_nfsstat3(xdr, &status);
1787     if (unlikely(error))
1788         goto out;
1789     if (status != NFS3_OK)
1790         goto out_default;
1791     error = decode_create3resok(xdr, result, userns);
1792 out:
1793     return error;
1794 out_default:
1795     error = decode_wcc_data(xdr, result->dir_attr, userns);
1796     if (unlikely(error))
1797         goto out;
1798     return nfs3_stat_to_errno(status);
1799 }
1800 
1801 /*
1802  * 3.3.12  REMOVE3res
1803  *
1804  *  struct REMOVE3resok {
1805  *      wcc_data    dir_wcc;
1806  *  };
1807  *
1808  *  struct REMOVE3resfail {
1809  *      wcc_data    dir_wcc;
1810  *  };
1811  *
1812  *  union REMOVE3res switch (nfsstat3 status) {
1813  *  case NFS3_OK:
1814  *      REMOVE3resok   resok;
1815  *  default:
1816  *      REMOVE3resfail resfail;
1817  *  };
1818  */
1819 static int nfs3_xdr_dec_remove3res(struct rpc_rqst *req,
1820                    struct xdr_stream *xdr,
1821                    void *data)
1822 {
1823     struct nfs_removeres *result = data;
1824     enum nfs_stat status;
1825     int error;
1826 
1827     error = decode_nfsstat3(xdr, &status);
1828     if (unlikely(error))
1829         goto out;
1830     error = decode_wcc_data(xdr, result->dir_attr, rpc_rqst_userns(req));
1831     if (unlikely(error))
1832         goto out;
1833     if (status != NFS3_OK)
1834         goto out_status;
1835 out:
1836     return error;
1837 out_status:
1838     return nfs3_stat_to_errno(status);
1839 }
1840 
1841 /*
1842  * 3.3.14  RENAME3res
1843  *
1844  *  struct RENAME3resok {
1845  *      wcc_data    fromdir_wcc;
1846  *      wcc_data    todir_wcc;
1847  *  };
1848  *
1849  *  struct RENAME3resfail {
1850  *      wcc_data    fromdir_wcc;
1851  *      wcc_data    todir_wcc;
1852  *  };
1853  *
1854  *  union RENAME3res switch (nfsstat3 status) {
1855  *  case NFS3_OK:
1856  *      RENAME3resok   resok;
1857  *  default:
1858  *      RENAME3resfail resfail;
1859  *  };
1860  */
1861 static int nfs3_xdr_dec_rename3res(struct rpc_rqst *req,
1862                    struct xdr_stream *xdr,
1863                    void *data)
1864 {
1865     struct user_namespace *userns = rpc_rqst_userns(req);
1866     struct nfs_renameres *result = data;
1867     enum nfs_stat status;
1868     int error;
1869 
1870     error = decode_nfsstat3(xdr, &status);
1871     if (unlikely(error))
1872         goto out;
1873     error = decode_wcc_data(xdr, result->old_fattr, userns);
1874     if (unlikely(error))
1875         goto out;
1876     error = decode_wcc_data(xdr, result->new_fattr, userns);
1877     if (unlikely(error))
1878         goto out;
1879     if (status != NFS3_OK)
1880         goto out_status;
1881 out:
1882     return error;
1883 out_status:
1884     return nfs3_stat_to_errno(status);
1885 }
1886 
1887 /*
1888  * 3.3.15  LINK3res
1889  *
1890  *  struct LINK3resok {
1891  *      post_op_attr    file_attributes;
1892  *      wcc_data    linkdir_wcc;
1893  *  };
1894  *
1895  *  struct LINK3resfail {
1896  *      post_op_attr    file_attributes;
1897  *      wcc_data    linkdir_wcc;
1898  *  };
1899  *
1900  *  union LINK3res switch (nfsstat3 status) {
1901  *  case NFS3_OK:
1902  *      LINK3resok  resok;
1903  *  default:
1904  *      LINK3resfail    resfail;
1905  *  };
1906  */
1907 static int nfs3_xdr_dec_link3res(struct rpc_rqst *req, struct xdr_stream *xdr,
1908                  void *data)
1909 {
1910     struct user_namespace *userns = rpc_rqst_userns(req);
1911     struct nfs3_linkres *result = data;
1912     enum nfs_stat status;
1913     int error;
1914 
1915     error = decode_nfsstat3(xdr, &status);
1916     if (unlikely(error))
1917         goto out;
1918     error = decode_post_op_attr(xdr, result->fattr, userns);
1919     if (unlikely(error))
1920         goto out;
1921     error = decode_wcc_data(xdr, result->dir_attr, userns);
1922     if (unlikely(error))
1923         goto out;
1924     if (status != NFS3_OK)
1925         goto out_status;
1926 out:
1927     return error;
1928 out_status:
1929     return nfs3_stat_to_errno(status);
1930 }
1931 
1932 /**
1933  * nfs3_decode_dirent - Decode a single NFSv3 directory entry stored in
1934  *          the local page cache
1935  * @xdr: XDR stream where entry resides
1936  * @entry: buffer to fill in with entry data
1937  * @plus: boolean indicating whether this should be a readdirplus entry
1938  *
1939  * Returns zero if successful, otherwise a negative errno value is
1940  * returned.
1941  *
1942  * This function is not invoked during READDIR reply decoding, but
1943  * rather whenever an application invokes the getdents(2) system call
1944  * on a directory already in our cache.
1945  *
1946  * 3.3.16  entry3
1947  *
1948  *  struct entry3 {
1949  *      fileid3     fileid;
1950  *      filename3   name;
1951  *      cookie3     cookie;
1952  *      fhandle3    filehandle;
1953  *      post_op_attr3   attributes;
1954  *      entry3      *nextentry;
1955  *  };
1956  *
1957  * 3.3.17  entryplus3
1958  *  struct entryplus3 {
1959  *      fileid3     fileid;
1960  *      filename3   name;
1961  *      cookie3     cookie;
1962  *      post_op_attr    name_attributes;
1963  *      post_op_fh3 name_handle;
1964  *      entryplus3  *nextentry;
1965  *  };
1966  */
1967 int nfs3_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry,
1968                bool plus)
1969 {
1970     struct user_namespace *userns = rpc_userns(entry->server->client);
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 -EAGAIN;
1991 
1992     error = decode_inline_filename3(xdr, &entry->name, &entry->len);
1993     if (unlikely(error))
1994         return -EAGAIN;
1995 
1996     error = decode_cookie3(xdr, &new_cookie);
1997     if (unlikely(error))
1998         return -EAGAIN;
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 -EAGAIN;
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                 return -EAGAIN;
2023         } else
2024             zero_nfs_fh3(entry->fh);
2025     }
2026 
2027     entry->cookie = new_cookie;
2028 
2029     return 0;
2030 }
2031 
2032 /*
2033  * 3.3.16  READDIR3res
2034  *
2035  *  struct dirlist3 {
2036  *      entry3      *entries;
2037  *      bool        eof;
2038  *  };
2039  *
2040  *  struct READDIR3resok {
2041  *      post_op_attr    dir_attributes;
2042  *      cookieverf3 cookieverf;
2043  *      dirlist3    reply;
2044  *  };
2045  *
2046  *  struct READDIR3resfail {
2047  *      post_op_attr    dir_attributes;
2048  *  };
2049  *
2050  *  union READDIR3res switch (nfsstat3 status) {
2051  *  case NFS3_OK:
2052  *      READDIR3resok   resok;
2053  *  default:
2054  *      READDIR3resfail resfail;
2055  *  };
2056  *
2057  * Read the directory contents into the page cache, but otherwise
2058  * don't touch them.  The actual decoding is done by nfs3_decode_entry()
2059  * during subsequent nfs_readdir() calls.
2060  */
2061 static int decode_dirlist3(struct xdr_stream *xdr)
2062 {
2063     return xdr_read_pages(xdr, xdr->buf->page_len);
2064 }
2065 
2066 static int decode_readdir3resok(struct xdr_stream *xdr,
2067                 struct nfs3_readdirres *result,
2068                 struct user_namespace *userns)
2069 {
2070     int error;
2071 
2072     error = decode_post_op_attr(xdr, result->dir_attr, userns);
2073     if (unlikely(error))
2074         goto out;
2075     /* XXX: do we need to check if result->verf != NULL ? */
2076     error = decode_cookieverf3(xdr, result->verf);
2077     if (unlikely(error))
2078         goto out;
2079     error = decode_dirlist3(xdr);
2080 out:
2081     return error;
2082 }
2083 
2084 static int nfs3_xdr_dec_readdir3res(struct rpc_rqst *req,
2085                     struct xdr_stream *xdr,
2086                     void *data)
2087 {
2088     struct nfs3_readdirres *result = data;
2089     enum nfs_stat status;
2090     int error;
2091 
2092     error = decode_nfsstat3(xdr, &status);
2093     if (unlikely(error))
2094         goto out;
2095     if (status != NFS3_OK)
2096         goto out_default;
2097     error = decode_readdir3resok(xdr, result, rpc_rqst_userns(req));
2098 out:
2099     return error;
2100 out_default:
2101     error = decode_post_op_attr(xdr, result->dir_attr, rpc_rqst_userns(req));
2102     if (unlikely(error))
2103         goto out;
2104     return nfs3_stat_to_errno(status);
2105 }
2106 
2107 /*
2108  * 3.3.18  FSSTAT3res
2109  *
2110  *  struct FSSTAT3resok {
2111  *      post_op_attr    obj_attributes;
2112  *      size3       tbytes;
2113  *      size3       fbytes;
2114  *      size3       abytes;
2115  *      size3       tfiles;
2116  *      size3       ffiles;
2117  *      size3       afiles;
2118  *      uint32      invarsec;
2119  *  };
2120  *
2121  *  struct FSSTAT3resfail {
2122  *      post_op_attr    obj_attributes;
2123  *  };
2124  *
2125  *  union FSSTAT3res switch (nfsstat3 status) {
2126  *  case NFS3_OK:
2127  *      FSSTAT3resok    resok;
2128  *  default:
2129  *      FSSTAT3resfail  resfail;
2130  *  };
2131  */
2132 static int decode_fsstat3resok(struct xdr_stream *xdr,
2133                    struct nfs_fsstat *result)
2134 {
2135     __be32 *p;
2136 
2137     p = xdr_inline_decode(xdr, 8 * 6 + 4);
2138     if (unlikely(!p))
2139         return -EIO;
2140     p = xdr_decode_size3(p, &result->tbytes);
2141     p = xdr_decode_size3(p, &result->fbytes);
2142     p = xdr_decode_size3(p, &result->abytes);
2143     p = xdr_decode_size3(p, &result->tfiles);
2144     p = xdr_decode_size3(p, &result->ffiles);
2145     xdr_decode_size3(p, &result->afiles);
2146     /* ignore invarsec */
2147     return 0;
2148 }
2149 
2150 static int nfs3_xdr_dec_fsstat3res(struct rpc_rqst *req,
2151                    struct xdr_stream *xdr,
2152                    void *data)
2153 {
2154     struct nfs_fsstat *result = data;
2155     enum nfs_stat status;
2156     int error;
2157 
2158     error = decode_nfsstat3(xdr, &status);
2159     if (unlikely(error))
2160         goto out;
2161     error = decode_post_op_attr(xdr, result->fattr, rpc_rqst_userns(req));
2162     if (unlikely(error))
2163         goto out;
2164     if (status != NFS3_OK)
2165         goto out_status;
2166     error = decode_fsstat3resok(xdr, result);
2167 out:
2168     return error;
2169 out_status:
2170     return nfs3_stat_to_errno(status);
2171 }
2172 
2173 /*
2174  * 3.3.19  FSINFO3res
2175  *
2176  *  struct FSINFO3resok {
2177  *      post_op_attr    obj_attributes;
2178  *      uint32      rtmax;
2179  *      uint32      rtpref;
2180  *      uint32      rtmult;
2181  *      uint32      wtmax;
2182  *      uint32      wtpref;
2183  *      uint32      wtmult;
2184  *      uint32      dtpref;
2185  *      size3       maxfilesize;
2186  *      nfstime3    time_delta;
2187  *      uint32      properties;
2188  *  };
2189  *
2190  *  struct FSINFO3resfail {
2191  *      post_op_attr    obj_attributes;
2192  *  };
2193  *
2194  *  union FSINFO3res switch (nfsstat3 status) {
2195  *  case NFS3_OK:
2196  *      FSINFO3resok    resok;
2197  *  default:
2198  *      FSINFO3resfail  resfail;
2199  *  };
2200  */
2201 static int decode_fsinfo3resok(struct xdr_stream *xdr,
2202                    struct nfs_fsinfo *result)
2203 {
2204     __be32 *p;
2205 
2206     p = xdr_inline_decode(xdr, 4 * 7 + 8 + 8 + 4);
2207     if (unlikely(!p))
2208         return -EIO;
2209     result->rtmax  = be32_to_cpup(p++);
2210     result->rtpref = be32_to_cpup(p++);
2211     result->rtmult = be32_to_cpup(p++);
2212     result->wtmax  = be32_to_cpup(p++);
2213     result->wtpref = be32_to_cpup(p++);
2214     result->wtmult = be32_to_cpup(p++);
2215     result->dtpref = be32_to_cpup(p++);
2216     p = xdr_decode_size3(p, &result->maxfilesize);
2217     xdr_decode_nfstime3(p, &result->time_delta);
2218 
2219     /* ignore properties */
2220     result->lease_time = 0;
2221     result->change_attr_type = NFS4_CHANGE_TYPE_IS_UNDEFINED;
2222     result->xattr_support = 0;
2223     return 0;
2224 }
2225 
2226 static int nfs3_xdr_dec_fsinfo3res(struct rpc_rqst *req,
2227                    struct xdr_stream *xdr,
2228                    void *data)
2229 {
2230     struct nfs_fsinfo *result = data;
2231     enum nfs_stat status;
2232     int error;
2233 
2234     error = decode_nfsstat3(xdr, &status);
2235     if (unlikely(error))
2236         goto out;
2237     error = decode_post_op_attr(xdr, result->fattr, rpc_rqst_userns(req));
2238     if (unlikely(error))
2239         goto out;
2240     if (status != NFS3_OK)
2241         goto out_status;
2242     error = decode_fsinfo3resok(xdr, result);
2243 out:
2244     return error;
2245 out_status:
2246     return nfs3_stat_to_errno(status);
2247 }
2248 
2249 /*
2250  * 3.3.20  PATHCONF3res
2251  *
2252  *  struct PATHCONF3resok {
2253  *      post_op_attr    obj_attributes;
2254  *      uint32      linkmax;
2255  *      uint32      name_max;
2256  *      bool        no_trunc;
2257  *      bool        chown_restricted;
2258  *      bool        case_insensitive;
2259  *      bool        case_preserving;
2260  *  };
2261  *
2262  *  struct PATHCONF3resfail {
2263  *      post_op_attr    obj_attributes;
2264  *  };
2265  *
2266  *  union PATHCONF3res switch (nfsstat3 status) {
2267  *  case NFS3_OK:
2268  *      PATHCONF3resok  resok;
2269  *  default:
2270  *      PATHCONF3resfail resfail;
2271  *  };
2272  */
2273 static int decode_pathconf3resok(struct xdr_stream *xdr,
2274                  struct nfs_pathconf *result)
2275 {
2276     __be32 *p;
2277 
2278     p = xdr_inline_decode(xdr, 4 * 6);
2279     if (unlikely(!p))
2280         return -EIO;
2281     result->max_link = be32_to_cpup(p++);
2282     result->max_namelen = be32_to_cpup(p);
2283     /* ignore remaining fields */
2284     return 0;
2285 }
2286 
2287 static int nfs3_xdr_dec_pathconf3res(struct rpc_rqst *req,
2288                      struct xdr_stream *xdr,
2289                      void *data)
2290 {
2291     struct nfs_pathconf *result = data;
2292     enum nfs_stat status;
2293     int error;
2294 
2295     error = decode_nfsstat3(xdr, &status);
2296     if (unlikely(error))
2297         goto out;
2298     error = decode_post_op_attr(xdr, result->fattr, rpc_rqst_userns(req));
2299     if (unlikely(error))
2300         goto out;
2301     if (status != NFS3_OK)
2302         goto out_status;
2303     error = decode_pathconf3resok(xdr, result);
2304 out:
2305     return error;
2306 out_status:
2307     return nfs3_stat_to_errno(status);
2308 }
2309 
2310 /*
2311  * 3.3.21  COMMIT3res
2312  *
2313  *  struct COMMIT3resok {
2314  *      wcc_data    file_wcc;
2315  *      writeverf3  verf;
2316  *  };
2317  *
2318  *  struct COMMIT3resfail {
2319  *      wcc_data    file_wcc;
2320  *  };
2321  *
2322  *  union COMMIT3res switch (nfsstat3 status) {
2323  *  case NFS3_OK:
2324  *      COMMIT3resok    resok;
2325  *  default:
2326  *      COMMIT3resfail  resfail;
2327  *  };
2328  */
2329 static int nfs3_xdr_dec_commit3res(struct rpc_rqst *req,
2330                    struct xdr_stream *xdr,
2331                    void *data)
2332 {
2333     struct nfs_commitres *result = data;
2334     struct nfs_writeverf *verf = result->verf;
2335     enum nfs_stat status;
2336     int error;
2337 
2338     error = decode_nfsstat3(xdr, &status);
2339     if (unlikely(error))
2340         goto out;
2341     error = decode_wcc_data(xdr, result->fattr, rpc_rqst_userns(req));
2342     if (unlikely(error))
2343         goto out;
2344     result->op_status = status;
2345     if (status != NFS3_OK)
2346         goto out_status;
2347     error = decode_writeverf3(xdr, &verf->verifier);
2348     if (!error)
2349         verf->committed = NFS_FILE_SYNC;
2350 out:
2351     return error;
2352 out_status:
2353     return nfs3_stat_to_errno(status);
2354 }
2355 
2356 #ifdef CONFIG_NFS_V3_ACL
2357 
2358 static inline int decode_getacl3resok(struct xdr_stream *xdr,
2359                       struct nfs3_getaclres *result,
2360                       struct user_namespace *userns)
2361 {
2362     struct posix_acl **acl;
2363     unsigned int *aclcnt;
2364     size_t hdrlen;
2365     int error;
2366 
2367     error = decode_post_op_attr(xdr, result->fattr, userns);
2368     if (unlikely(error))
2369         goto out;
2370     error = decode_uint32(xdr, &result->mask);
2371     if (unlikely(error))
2372         goto out;
2373     error = -EINVAL;
2374     if (result->mask & ~(NFS_ACL|NFS_ACLCNT|NFS_DFACL|NFS_DFACLCNT))
2375         goto out;
2376 
2377     hdrlen = xdr_stream_pos(xdr);
2378 
2379     acl = NULL;
2380     if (result->mask & NFS_ACL)
2381         acl = &result->acl_access;
2382     aclcnt = NULL;
2383     if (result->mask & NFS_ACLCNT)
2384         aclcnt = &result->acl_access_count;
2385     error = nfsacl_decode(xdr->buf, hdrlen, aclcnt, acl);
2386     if (unlikely(error <= 0))
2387         goto out;
2388 
2389     acl = NULL;
2390     if (result->mask & NFS_DFACL)
2391         acl = &result->acl_default;
2392     aclcnt = NULL;
2393     if (result->mask & NFS_DFACLCNT)
2394         aclcnt = &result->acl_default_count;
2395     error = nfsacl_decode(xdr->buf, hdrlen + error, aclcnt, acl);
2396     if (unlikely(error <= 0))
2397         return error;
2398     error = 0;
2399 out:
2400     return error;
2401 }
2402 
2403 static int nfs3_xdr_dec_getacl3res(struct rpc_rqst *req,
2404                    struct xdr_stream *xdr,
2405                    void *result)
2406 {
2407     enum nfs_stat status;
2408     int error;
2409 
2410     error = decode_nfsstat3(xdr, &status);
2411     if (unlikely(error))
2412         goto out;
2413     if (status != NFS3_OK)
2414         goto out_default;
2415     error = decode_getacl3resok(xdr, result, rpc_rqst_userns(req));
2416 out:
2417     return error;
2418 out_default:
2419     return nfs3_stat_to_errno(status);
2420 }
2421 
2422 static int nfs3_xdr_dec_setacl3res(struct rpc_rqst *req,
2423                    struct xdr_stream *xdr,
2424                    void *result)
2425 {
2426     enum nfs_stat status;
2427     int error;
2428 
2429     error = decode_nfsstat3(xdr, &status);
2430     if (unlikely(error))
2431         goto out;
2432     if (status != NFS3_OK)
2433         goto out_default;
2434     error = decode_post_op_attr(xdr, result, rpc_rqst_userns(req));
2435 out:
2436     return error;
2437 out_default:
2438     return nfs3_stat_to_errno(status);
2439 }
2440 
2441 #endif  /* CONFIG_NFS_V3_ACL */
2442 
2443 
2444 /*
2445  * We need to translate between nfs status return values and
2446  * the local errno values which may not be the same.
2447  */
2448 static const struct {
2449     int stat;
2450     int errno;
2451 } nfs_errtbl[] = {
2452     { NFS_OK,       0       },
2453     { NFSERR_PERM,      -EPERM      },
2454     { NFSERR_NOENT,     -ENOENT     },
2455     { NFSERR_IO,        -errno_NFSERR_IO},
2456     { NFSERR_NXIO,      -ENXIO      },
2457 /*  { NFSERR_EAGAIN,    -EAGAIN     }, */
2458     { NFSERR_ACCES,     -EACCES     },
2459     { NFSERR_EXIST,     -EEXIST     },
2460     { NFSERR_XDEV,      -EXDEV      },
2461     { NFSERR_NODEV,     -ENODEV     },
2462     { NFSERR_NOTDIR,    -ENOTDIR    },
2463     { NFSERR_ISDIR,     -EISDIR     },
2464     { NFSERR_INVAL,     -EINVAL     },
2465     { NFSERR_FBIG,      -EFBIG      },
2466     { NFSERR_NOSPC,     -ENOSPC     },
2467     { NFSERR_ROFS,      -EROFS      },
2468     { NFSERR_MLINK,     -EMLINK     },
2469     { NFSERR_NAMETOOLONG,   -ENAMETOOLONG   },
2470     { NFSERR_NOTEMPTY,  -ENOTEMPTY  },
2471     { NFSERR_DQUOT,     -EDQUOT     },
2472     { NFSERR_STALE,     -ESTALE     },
2473     { NFSERR_REMOTE,    -EREMOTE    },
2474 #ifdef EWFLUSH
2475     { NFSERR_WFLUSH,    -EWFLUSH    },
2476 #endif
2477     { NFSERR_BADHANDLE, -EBADHANDLE },
2478     { NFSERR_NOT_SYNC,  -ENOTSYNC   },
2479     { NFSERR_BAD_COOKIE,    -EBADCOOKIE },
2480     { NFSERR_NOTSUPP,   -ENOTSUPP   },
2481     { NFSERR_TOOSMALL,  -ETOOSMALL  },
2482     { NFSERR_SERVERFAULT,   -EREMOTEIO  },
2483     { NFSERR_BADTYPE,   -EBADTYPE   },
2484     { NFSERR_JUKEBOX,   -EJUKEBOX   },
2485     { -1,           -EIO        }
2486 };
2487 
2488 /**
2489  * nfs3_stat_to_errno - convert an NFS status code to a local errno
2490  * @status: NFS status code to convert
2491  *
2492  * Returns a local errno value, or -EIO if the NFS status code is
2493  * not recognized.  This function is used jointly by NFSv2 and NFSv3.
2494  */
2495 static int nfs3_stat_to_errno(enum nfs_stat status)
2496 {
2497     int i;
2498 
2499     for (i = 0; nfs_errtbl[i].stat != -1; i++) {
2500         if (nfs_errtbl[i].stat == (int)status)
2501             return nfs_errtbl[i].errno;
2502     }
2503     dprintk("NFS: Unrecognized nfs status value: %u\n", status);
2504     return nfs_errtbl[i].errno;
2505 }
2506 
2507 
2508 #define PROC(proc, argtype, restype, timer)             \
2509 [NFS3PROC_##proc] = {                           \
2510     .p_proc      = NFS3PROC_##proc,                 \
2511     .p_encode    = nfs3_xdr_enc_##argtype##3args,           \
2512     .p_decode    = nfs3_xdr_dec_##restype##3res,            \
2513     .p_arglen    = NFS3_##argtype##args_sz,             \
2514     .p_replen    = NFS3_##restype##res_sz,              \
2515     .p_timer     = timer,                       \
2516     .p_statidx   = NFS3PROC_##proc,                 \
2517     .p_name      = #proc,                       \
2518     }
2519 
2520 const struct rpc_procinfo nfs3_procedures[] = {
2521     PROC(GETATTR,       getattr,    getattr,    1),
2522     PROC(SETATTR,       setattr,    setattr,    0),
2523     PROC(LOOKUP,        lookup,     lookup,     2),
2524     PROC(ACCESS,        access,     access,     1),
2525     PROC(READLINK,      readlink,   readlink,   3),
2526     PROC(READ,      read,       read,       3),
2527     PROC(WRITE,     write,      write,      4),
2528     PROC(CREATE,        create,     create,     0),
2529     PROC(MKDIR,     mkdir,      create,     0),
2530     PROC(SYMLINK,       symlink,    create,     0),
2531     PROC(MKNOD,     mknod,      create,     0),
2532     PROC(REMOVE,        remove,     remove,     0),
2533     PROC(RMDIR,     lookup,     setattr,    0),
2534     PROC(RENAME,        rename,     rename,     0),
2535     PROC(LINK,      link,       link,       0),
2536     PROC(READDIR,       readdir,    readdir,    3),
2537     PROC(READDIRPLUS,   readdirplus,    readdir,    3),
2538     PROC(FSSTAT,        getattr,    fsstat,     0),
2539     PROC(FSINFO,        getattr,    fsinfo,     0),
2540     PROC(PATHCONF,      getattr,    pathconf,   0),
2541     PROC(COMMIT,        commit,     commit,     5),
2542 };
2543 
2544 static unsigned int nfs_version3_counts[ARRAY_SIZE(nfs3_procedures)];
2545 const struct rpc_version nfs_version3 = {
2546     .number         = 3,
2547     .nrprocs        = ARRAY_SIZE(nfs3_procedures),
2548     .procs          = nfs3_procedures,
2549     .counts         = nfs_version3_counts,
2550 };
2551 
2552 #ifdef CONFIG_NFS_V3_ACL
2553 static const struct rpc_procinfo nfs3_acl_procedures[] = {
2554     [ACLPROC3_GETACL] = {
2555         .p_proc = ACLPROC3_GETACL,
2556         .p_encode = nfs3_xdr_enc_getacl3args,
2557         .p_decode = nfs3_xdr_dec_getacl3res,
2558         .p_arglen = ACL3_getaclargs_sz,
2559         .p_replen = ACL3_getaclres_sz,
2560         .p_timer = 1,
2561         .p_name = "GETACL",
2562     },
2563     [ACLPROC3_SETACL] = {
2564         .p_proc = ACLPROC3_SETACL,
2565         .p_encode = nfs3_xdr_enc_setacl3args,
2566         .p_decode = nfs3_xdr_dec_setacl3res,
2567         .p_arglen = ACL3_setaclargs_sz,
2568         .p_replen = ACL3_setaclres_sz,
2569         .p_timer = 0,
2570         .p_name = "SETACL",
2571     },
2572 };
2573 
2574 static unsigned int nfs3_acl_counts[ARRAY_SIZE(nfs3_acl_procedures)];
2575 const struct rpc_version nfsacl_version3 = {
2576     .number         = 3,
2577     .nrprocs        = ARRAY_SIZE(nfs3_acl_procedures),
2578     .procs          = nfs3_acl_procedures,
2579     .counts         = nfs3_acl_counts,
2580 };
2581 #endif  /* CONFIG_NFS_V3_ACL */
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!