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