blob: 9b04c2e6fffc3f306f3c598b7c4557beff653c8e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#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>
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +000022#include <linux/nfsacl.h>
David Howellsf7b422b2006-06-09 09:34:33 -040023#include "internal.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
25#define NFSDBG_FACILITY NFSDBG_XDR
26
27/* Mapping from NFS error code to "errno" error code. */
28#define errno_NFSERR_IO EIO
29
Linus Torvalds1da177e2005-04-16 15:20:36 -070030/*
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)
Chuck Leverd9c407b2010-12-14 14:55:50 +000040#define NFS3_cookieverf_sz (NFS3_COOKIEVERFSIZE>>2)
Chuck Leverf5fc3c502010-12-14 14:56:42 +000041#define NFS3_wcc_attr_sz (6)
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#define NFS3_pre_op_attr_sz (1+NFS3_wcc_attr_sz)
43#define NFS3_post_op_attr_sz (1+NFS3_fattr_sz)
Chuck Leverf5fc3c502010-12-14 14:56:42 +000044#define NFS3_wcc_data_sz (NFS3_pre_op_attr_sz+NFS3_post_op_attr_sz)
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#define NFS3_diropargs_sz (NFS3_fh_sz+NFS3_filename_sz)
Chuck Leverad96b5b2010-12-14 14:56:01 +000046
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)
Linus Torvalds1da177e2005-04-16 15:20:36 -070050#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)
Chuck Lever94a6d752006-08-22 20:06:23 -040056#define NFS3_symlinkargs_sz (NFS3_diropargs_sz+1+NFS3_sattr_sz)
Linus Torvalds1da177e2005-04-16 15:20:36 -070057#define NFS3_mknodargs_sz (NFS3_diropargs_sz+2+NFS3_sattr_sz)
Chuck Leverad96b5b2010-12-14 14:56:01 +000058#define NFS3_removeargs_sz (NFS3_fh_sz+NFS3_filename_sz)
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#define NFS3_renameargs_sz (NFS3_diropargs_sz+NFS3_diropargs_sz)
60#define NFS3_linkargs_sz (NFS3_fh_sz+NFS3_diropargs_sz)
Chuck Leverd9c407b2010-12-14 14:55:50 +000061#define NFS3_readdirargs_sz (NFS3_fh_sz+NFS3_cookieverf_sz+3)
62#define NFS3_readdirplusargs_sz (NFS3_fh_sz+NFS3_cookieverf_sz+4)
Linus Torvalds1da177e2005-04-16 15:20:36 -070063#define NFS3_commitargs_sz (NFS3_fh_sz+3)
64
Chuck Leverf5fc3c502010-12-14 14:56:42 +000065#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)
Linus Torvalds1da177e2005-04-16 15:20:36 -070068#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
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +000082#define ACL3_getaclargs_sz (NFS3_fh_sz+1)
Trond Myklebustae46141f2009-03-10 20:33:18 -040083#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))
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +000087#define ACL3_setaclres_sz (1+NFS3_post_op_attr_sz)
88
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -040089static int nfs3_stat_to_errno(enum nfs_stat);
90
Linus Torvalds1da177e2005-04-16 15:20:36 -070091/*
92 * Map file type to S_IFMT bits
93 */
Trond Myklebustbca79472009-03-11 14:10:26 -040094static 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,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103};
104
105/*
Chuck Leverd9c407b2010-12-14 14:55:50 +0000106 * While encoding arguments, set up the reply buffer in advance to
107 * receive reply data directly into the page cache.
108 */
109static 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
Chuck Levere4f93232010-12-14 14:56:30 +0000120/*
121 * Handle decode buffer overflows out-of-line.
122 */
123static 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
Chuck Leverd9c407b2010-12-14 14:55:50 +0000130
131/*
Chuck Leverd9c407b2010-12-14 14:55:50 +0000132 * 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
142static 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
Chuck Levere4f93232010-12-14 14:56:30 +0000148static 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;
157out_overflow:
158 print_overflow_msg(__func__, xdr);
159 return -EIO;
160}
161
162static 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;
171out_overflow:
172 print_overflow_msg(__func__, xdr);
173 return -EIO;
174}
175
176/*
177 * fileid3
178 *
179 * typedef uint64 fileid3;
180 */
Chuck Leverf6048702010-12-14 14:57:02 +0000181static __be32 *xdr_decode_fileid3(__be32 *p, u64 *fileid)
182{
183 return xdr_decode_hyper(p, fileid);
184}
185
Chuck Levere4f93232010-12-14 14:56:30 +0000186static int decode_fileid3(struct xdr_stream *xdr, u64 *fileid)
187{
188 return decode_uint64(xdr, fileid);
189}
190
Chuck Leverd9c407b2010-12-14 14:55:50 +0000191/*
192 * filename3
193 *
194 * typedef string filename3<>;
195 */
196static void encode_filename3(struct xdr_stream *xdr,
197 const char *name, u32 length)
198{
199 __be32 *p;
200
Trond Myklebust7fc38842012-10-15 11:51:21 -0400201 WARN_ON_ONCE(length > NFS3_MAXNAMLEN);
Chuck Leverd9c407b2010-12-14 14:55:50 +0000202 p = xdr_reserve_space(xdr, 4 + length);
203 xdr_encode_opaque(p, name, length);
204}
205
Chuck Levere4f93232010-12-14 14:56:30 +0000206static 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
225out_nametoolong:
226 dprintk("NFS: returned filename too long: %u\n", count);
227 return -ENAMETOOLONG;
228out_overflow:
229 print_overflow_msg(__func__, xdr);
230 return -EIO;
231}
232
Chuck Leverd9c407b2010-12-14 14:55:50 +0000233/*
234 * nfspath3
235 *
236 * typedef string nfspath3<>;
237 */
238static void encode_nfspath3(struct xdr_stream *xdr, struct page **pages,
239 const u32 length)
240{
Chuck Leverd9c407b2010-12-14 14:55:50 +0000241 encode_uint32(xdr, length);
242 xdr_write_pages(xdr, pages, 0, length);
243}
244
Chuck Levere4f93232010-12-14 14:56:30 +0000245static int decode_nfspath3(struct xdr_stream *xdr)
246{
247 u32 recvd, count;
Chuck Levere4f93232010-12-14 14:56:30 +0000248 __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;
Trond Myklebust64bd5772012-06-20 22:35:05 -0400256 recvd = xdr_read_pages(xdr, count);
Chuck Levere4f93232010-12-14 14:56:30 +0000257 if (unlikely(count > recvd))
258 goto out_cheating;
Chuck Levere4f93232010-12-14 14:56:30 +0000259 xdr_terminate_string(xdr->buf, count);
260 return 0;
261
262out_nametoolong:
263 dprintk("NFS: returned pathname too long: %u\n", count);
264 return -ENAMETOOLONG;
265out_cheating:
266 dprintk("NFS: server cheating in pathname result: "
267 "count %u > recvd %u\n", count, recvd);
268 return -EIO;
269out_overflow:
270 print_overflow_msg(__func__, xdr);
271 return -EIO;
272}
273
Chuck Leverd9c407b2010-12-14 14:55:50 +0000274/*
275 * cookie3
276 *
277 * typedef uint64 cookie3
278 */
279static __be32 *xdr_encode_cookie3(__be32 *p, u64 cookie)
280{
281 return xdr_encode_hyper(p, cookie);
282}
283
Chuck Levere4f93232010-12-14 14:56:30 +0000284static int decode_cookie3(struct xdr_stream *xdr, u64 *cookie)
285{
286 return decode_uint64(xdr, cookie);
287}
288
Chuck Leverd9c407b2010-12-14 14:55:50 +0000289/*
290 * cookieverf3
291 *
292 * typedef opaque cookieverf3[NFS3_COOKIEVERFSIZE];
293 */
294static __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
Chuck Levere4f93232010-12-14 14:56:30 +0000300static 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;
309out_overflow:
310 print_overflow_msg(__func__, xdr);
311 return -EIO;
312}
313
Chuck Leverd9c407b2010-12-14 14:55:50 +0000314/*
315 * createverf3
316 *
317 * typedef opaque createverf3[NFS3_CREATEVERFSIZE];
318 */
319static 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
Trond Myklebust2f2c63b2012-06-08 11:56:09 -0400327static int decode_writeverf3(struct xdr_stream *xdr, struct nfs_write_verifier *verifier)
Chuck Levere4f93232010-12-14 14:56:30 +0000328{
329 __be32 *p;
330
331 p = xdr_inline_decode(xdr, NFS3_WRITEVERFSIZE);
332 if (unlikely(p == NULL))
333 goto out_overflow;
Trond Myklebust2f2c63b2012-06-08 11:56:09 -0400334 memcpy(verifier->data, p, NFS3_WRITEVERFSIZE);
Chuck Levere4f93232010-12-14 14:56:30 +0000335 return 0;
336out_overflow:
337 print_overflow_msg(__func__, xdr);
338 return -EIO;
339}
340
341/*
342 * size3
343 *
344 * typedef uint64 size3;
345 */
346static __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
361static 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;
370out_overflow:
371 print_overflow_msg(__func__, xdr);
372 return -EIO;
373}
374
Chuck Leverd9c407b2010-12-14 14:55:50 +0000375/*
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 */
388static void encode_ftype3(struct xdr_stream *xdr, const u32 type)
389{
Chuck Leverd9c407b2010-12-14 14:55:50 +0000390 encode_uint32(xdr, type);
391}
392
Chuck Leverf6048702010-12-14 14:57:02 +0000393static __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
Chuck Leverd9c407b2010-12-14 14:55:50 +0000404/*
405 * specdata3
406 *
407 * struct specdata3 {
408 * uint32 specdata1;
409 * uint32 specdata2;
410 * };
411 */
412static 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
Chuck Leverf6048702010-12-14 14:57:02 +0000421static __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
Chuck Leverd9c407b2010-12-14 14:55:50 +0000433/*
434 * nfs_fh3
435 *
436 * struct nfs_fh3 {
437 * opaque data<NFS3_FHSIZE>;
438 * };
439 */
440static void encode_nfs_fh3(struct xdr_stream *xdr, const struct nfs_fh *fh)
441{
442 __be32 *p;
443
Trond Myklebust7fc38842012-10-15 11:51:21 -0400444 WARN_ON_ONCE(fh->size > NFS3_FHSIZE);
Chuck Leverd9c407b2010-12-14 14:55:50 +0000445 p = xdr_reserve_space(xdr, 4 + fh->size);
446 xdr_encode_opaque(p, fh->data, fh->size);
447}
448
Chuck Levere4f93232010-12-14 14:56:30 +0000449static 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;
466out_toobig:
467 dprintk("NFS: file handle size (%u) too big\n", length);
468 return -E2BIG;
469out_overflow:
470 print_overflow_msg(__func__, xdr);
471 return -EIO;
472}
473
474static void zero_nfs_fh3(struct nfs_fh *fh)
475{
476 memset(fh, 0, sizeof(*fh));
477}
478
Chuck Leverd9c407b2010-12-14 14:55:50 +0000479/*
Chuck Lever9d5a6432010-12-14 14:56:20 +0000480 * nfstime3
481 *
482 * struct nfstime3 {
483 * uint32 seconds;
484 * uint32 nseconds;
485 * };
486 */
487static __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
Chuck Leverf6048702010-12-14 14:57:02 +0000494static __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
Chuck Lever9d5a6432010-12-14 14:56:20 +0000501/*
Chuck Leverd9c407b2010-12-14 14:55:50 +0000502 * 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 */
561static 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
Chuck Lever9d5a6432010-12-14 14:56:20 +0000587 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;
Eric W. Biederman57a38da2013-02-01 03:50:00 -0800595 *p++ = cpu_to_be32(from_kuid(&init_user_ns, attr->ia_uid));
Chuck Lever9d5a6432010-12-14 14:56:20 +0000596 } else
597 *p++ = xdr_zero;
598
599 if (attr->ia_valid & ATTR_GID) {
600 *p++ = xdr_one;
Eric W. Biederman57a38da2013-02-01 03:50:00 -0800601 *p++ = cpu_to_be32(from_kgid(&init_user_ns, attr->ia_gid));
Chuck Lever9d5a6432010-12-14 14:56:20 +0000602 } 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;
Chuck Leverd9c407b2010-12-14 14:55:50 +0000626}
627
628/*
Chuck Levere4f93232010-12-14 14:56:30 +0000629 * 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 */
647static int decode_fattr3(struct xdr_stream *xdr, struct nfs_fattr *fattr)
648{
Chuck Leverf6048702010-12-14 14:57:02 +0000649 umode_t fmode;
Chuck Levere4f93232010-12-14 14:56:30 +0000650 __be32 *p;
651
652 p = xdr_inline_decode(xdr, NFS3_fattr_sz << 2);
653 if (unlikely(p == NULL))
654 goto out_overflow;
Chuck Leverf6048702010-12-14 14:57:02 +0000655
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++);
Eric W. Biederman57a38da2013-02-01 03:50:00 -0800660 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;
Chuck Leverf6048702010-12-14 14:57:02 +0000666
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);
Trond Myklebust3a1556e2012-04-27 13:48:18 -0400678 fattr->change_attr = nfs_timespec_to_change_attr(&fattr->ctime);
Chuck Leverf6048702010-12-14 14:57:02 +0000679
680 fattr->valid |= NFS_ATTR_FATTR_V3;
Chuck Levere4f93232010-12-14 14:56:30 +0000681 return 0;
Eric W. Biederman57a38da2013-02-01 03:50:00 -0800682out_uid:
683 dprintk("NFS: returned invalid uid\n");
684 return -EINVAL;
685out_gid:
686 dprintk("NFS: returned invalid gid\n");
687 return -EINVAL;
Chuck Levere4f93232010-12-14 14:56:30 +0000688out_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 */
703static 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;
713out_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 */
726static 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;
Chuck Leverf6048702010-12-14 14:57:02 +0000733
734 fattr->valid |= NFS_ATTR_FATTR_PRESIZE
Trond Myklebust3a1556e2012-04-27 13:48:18 -0400735 | NFS_ATTR_FATTR_PRECHANGE
Chuck Leverf6048702010-12-14 14:57:02 +0000736 | 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);
Trond Myklebust3a1556e2012-04-27 13:48:18 -0400742 fattr->pre_change_attr = nfs_timespec_to_change_attr(&fattr->pre_ctime);
Chuck Leverf6048702010-12-14 14:57:02 +0000743
Chuck Levere4f93232010-12-14 14:56:30 +0000744 return 0;
745out_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 */
766static 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;
776out_overflow:
777 print_overflow_msg(__func__, xdr);
778 return -EIO;
779}
780
781static 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);
789out:
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 */
803static 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;
812out_overflow:
813 print_overflow_msg(__func__, xdr);
814 return -EIO;
815}
816
817/*
Chuck Leverd9c407b2010-12-14 14:55:50 +0000818 * diropargs3
819 *
820 * struct diropargs3 {
821 * nfs_fh3 dir;
822 * filename3 name;
823 * };
824 */
825static 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833/*
Chuck Lever499ff712010-12-14 14:56:10 +0000834 * NFSv3 XDR encode functions
835 *
836 * NFSv3 argument types are defined in section 3.3 of RFC 1813:
837 * "NFS Version 3 Protocol Specification".
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 */
839
840/*
Chuck Leverd9c407b2010-12-14 14:55:50 +0000841 * 3.3.1 GETATTR3args
842 *
843 * struct GETATTR3args {
844 * nfs_fh3 object;
845 * };
846 */
Chuck Lever9f06c712010-12-14 14:59:18 +0000847static void nfs3_xdr_enc_getattr3args(struct rpc_rqst *req,
848 struct xdr_stream *xdr,
849 const struct nfs_fh *fh)
Chuck Leverd9c407b2010-12-14 14:55:50 +0000850{
Chuck Lever9f06c712010-12-14 14:59:18 +0000851 encode_nfs_fh3(xdr, fh);
Chuck Leverd9c407b2010-12-14 14:55:50 +0000852}
853
854/*
Chuck Leverd9c407b2010-12-14 14:55:50 +0000855 * 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 */
870static 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;
Chuck Lever9d5a6432010-12-14 14:56:20 +0000878 xdr_encode_nfstime3(p, &args->guardtime);
Chuck Leverd9c407b2010-12-14 14:55:50 +0000879 } else {
880 p = xdr_reserve_space(xdr, 4);
881 *p = xdr_zero;
882 }
883}
884
Chuck Lever9f06c712010-12-14 14:59:18 +0000885static void nfs3_xdr_enc_setattr3args(struct rpc_rqst *req,
886 struct xdr_stream *xdr,
887 const struct nfs3_sattrargs *args)
Chuck Leverd9c407b2010-12-14 14:55:50 +0000888{
Chuck Lever9f06c712010-12-14 14:59:18 +0000889 encode_nfs_fh3(xdr, args->fh);
890 encode_sattr3(xdr, args->sattr);
891 encode_sattrguard3(xdr, args);
Chuck Leverd9c407b2010-12-14 14:55:50 +0000892}
893
894/*
Chuck Leverd9c407b2010-12-14 14:55:50 +0000895 * 3.3.3 LOOKUP3args
896 *
897 * struct LOOKUP3args {
898 * diropargs3 what;
899 * };
900 */
Chuck Lever9f06c712010-12-14 14:59:18 +0000901static void nfs3_xdr_enc_lookup3args(struct rpc_rqst *req,
902 struct xdr_stream *xdr,
903 const struct nfs3_diropargs *args)
Chuck Leverd9c407b2010-12-14 14:55:50 +0000904{
Chuck Lever9f06c712010-12-14 14:59:18 +0000905 encode_diropargs3(xdr, args->fh, args->name, args->len);
Chuck Leverd9c407b2010-12-14 14:55:50 +0000906}
907
908/*
Chuck Leverd9c407b2010-12-14 14:55:50 +0000909 * 3.3.4 ACCESS3args
910 *
911 * struct ACCESS3args {
912 * nfs_fh3 object;
913 * uint32 access;
914 * };
915 */
916static 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
Chuck Lever9f06c712010-12-14 14:59:18 +0000923static void nfs3_xdr_enc_access3args(struct rpc_rqst *req,
924 struct xdr_stream *xdr,
925 const struct nfs3_accessargs *args)
Chuck Leverd9c407b2010-12-14 14:55:50 +0000926{
Chuck Lever9f06c712010-12-14 14:59:18 +0000927 encode_access3args(xdr, args);
Chuck Leverd9c407b2010-12-14 14:55:50 +0000928}
929
930/*
931 * 3.3.5 READLINK3args
932 *
933 * struct READLINK3args {
934 * nfs_fh3 symlink;
935 * };
936 */
Chuck Lever9f06c712010-12-14 14:59:18 +0000937static void nfs3_xdr_enc_readlink3args(struct rpc_rqst *req,
938 struct xdr_stream *xdr,
939 const struct nfs3_readlinkargs *args)
Chuck Leverd9c407b2010-12-14 14:55:50 +0000940{
Chuck Lever9f06c712010-12-14 14:59:18 +0000941 encode_nfs_fh3(xdr, args->fh);
Chuck Leverd9c407b2010-12-14 14:55:50 +0000942 prepare_reply_buffer(req, args->pages, args->pgbase,
943 args->pglen, NFS3_readlinkres_sz);
Chuck Leverd9c407b2010-12-14 14:55:50 +0000944}
945
946/*
Chuck Leverd9c407b2010-12-14 14:55:50 +0000947 * 3.3.6 READ3args
948 *
949 * struct READ3args {
950 * nfs_fh3 file;
951 * offset3 offset;
952 * count3 count;
953 * };
954 */
955static void encode_read3args(struct xdr_stream *xdr,
Anna Schumaker3c6b8992014-05-06 09:12:24 -0400956 const struct nfs_pgio_args *args)
Chuck Leverd9c407b2010-12-14 14:55:50 +0000957{
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
Chuck Lever9f06c712010-12-14 14:59:18 +0000967static void nfs3_xdr_enc_read3args(struct rpc_rqst *req,
968 struct xdr_stream *xdr,
Anna Schumaker3c6b8992014-05-06 09:12:24 -0400969 const struct nfs_pgio_args *args)
Chuck Leverd9c407b2010-12-14 14:55:50 +0000970{
Chuck Lever9f06c712010-12-14 14:59:18 +0000971 encode_read3args(xdr, args);
Chuck Leverd9c407b2010-12-14 14:55:50 +0000972 prepare_reply_buffer(req, args->pages, args->pgbase,
973 args->count, NFS3_readres_sz);
974 req->rq_rcv_buf.flags |= XDRBUF_READ;
Chuck Leverd9c407b2010-12-14 14:55:50 +0000975}
976
977/*
Chuck Leverd9c407b2010-12-14 14:55:50 +0000978 * 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 */
994static void encode_write3args(struct xdr_stream *xdr,
Anna Schumaker3c6b8992014-05-06 09:12:24 -0400995 const struct nfs_pgio_args *args)
Chuck Leverd9c407b2010-12-14 14:55:50 +0000996{
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);
Chuck Leverd9c407b2010-12-14 14:55:50 +00001004 *p++ = cpu_to_be32(args->stable);
Chuck Leverd9c407b2010-12-14 14:55:50 +00001005 *p = cpu_to_be32(args->count);
1006 xdr_write_pages(xdr, args->pages, args->pgbase, args->count);
1007}
1008
Chuck Lever9f06c712010-12-14 14:59:18 +00001009static void nfs3_xdr_enc_write3args(struct rpc_rqst *req,
1010 struct xdr_stream *xdr,
Anna Schumaker3c6b8992014-05-06 09:12:24 -04001011 const struct nfs_pgio_args *args)
Chuck Leverd9c407b2010-12-14 14:55:50 +00001012{
Chuck Lever9f06c712010-12-14 14:59:18 +00001013 encode_write3args(xdr, args);
1014 xdr->buf->flags |= XDRBUF_WRITE;
Chuck Leverd9c407b2010-12-14 14:55:50 +00001015}
1016
1017/*
Chuck Leverd9c407b2010-12-14 14:55:50 +00001018 * 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 */
1039static 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
Chuck Lever9f06c712010-12-14 14:59:18 +00001056static void nfs3_xdr_enc_create3args(struct rpc_rqst *req,
1057 struct xdr_stream *xdr,
1058 const struct nfs3_createargs *args)
Chuck Leverd9c407b2010-12-14 14:55:50 +00001059{
Chuck Lever9f06c712010-12-14 14:59:18 +00001060 encode_diropargs3(xdr, args->fh, args->name, args->len);
1061 encode_createhow3(xdr, args);
Chuck Leverd9c407b2010-12-14 14:55:50 +00001062}
1063
1064/*
Chuck Leverd9c407b2010-12-14 14:55:50 +00001065 * 3.3.9 MKDIR3args
1066 *
1067 * struct MKDIR3args {
1068 * diropargs3 where;
1069 * sattr3 attributes;
1070 * };
1071 */
Chuck Lever9f06c712010-12-14 14:59:18 +00001072static void nfs3_xdr_enc_mkdir3args(struct rpc_rqst *req,
1073 struct xdr_stream *xdr,
1074 const struct nfs3_mkdirargs *args)
Chuck Leverd9c407b2010-12-14 14:55:50 +00001075{
Chuck Lever9f06c712010-12-14 14:59:18 +00001076 encode_diropargs3(xdr, args->fh, args->name, args->len);
1077 encode_sattr3(xdr, args->sattr);
Chuck Leverd9c407b2010-12-14 14:55:50 +00001078}
1079
1080/*
Chuck Leverd9c407b2010-12-14 14:55:50 +00001081 * 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 */
1093static 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
Chuck Lever9f06c712010-12-14 14:59:18 +00001100static void nfs3_xdr_enc_symlink3args(struct rpc_rqst *req,
1101 struct xdr_stream *xdr,
1102 const struct nfs3_symlinkargs *args)
Chuck Leverd9c407b2010-12-14 14:55:50 +00001103{
Chuck Lever9f06c712010-12-14 14:59:18 +00001104 encode_diropargs3(xdr, args->fromfh, args->fromname, args->fromlen);
1105 encode_symlinkdata3(xdr, args);
Chuck Leverd9c407b2010-12-14 14:55:50 +00001106}
1107
1108/*
Chuck Leverd9c407b2010-12-14 14:55:50 +00001109 * 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 */
1132static 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
1139static 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
Chuck Lever9f06c712010-12-14 14:59:18 +00001160static void nfs3_xdr_enc_mknod3args(struct rpc_rqst *req,
1161 struct xdr_stream *xdr,
1162 const struct nfs3_mknodargs *args)
Chuck Leverd9c407b2010-12-14 14:55:50 +00001163{
Chuck Lever9f06c712010-12-14 14:59:18 +00001164 encode_diropargs3(xdr, args->fh, args->name, args->len);
1165 encode_mknoddata3(xdr, args);
Chuck Leverd9c407b2010-12-14 14:55:50 +00001166}
1167
1168/*
1169 * 3.3.12 REMOVE3args
1170 *
1171 * struct REMOVE3args {
1172 * diropargs3 object;
1173 * };
1174 */
Chuck Lever9f06c712010-12-14 14:59:18 +00001175static void nfs3_xdr_enc_remove3args(struct rpc_rqst *req,
1176 struct xdr_stream *xdr,
1177 const struct nfs_removeargs *args)
Chuck Leverd9c407b2010-12-14 14:55:50 +00001178{
Chuck Lever9f06c712010-12-14 14:59:18 +00001179 encode_diropargs3(xdr, args->fh, args->name.name, args->name.len);
Chuck Leverd9c407b2010-12-14 14:55:50 +00001180}
1181
1182/*
Chuck Leverd9c407b2010-12-14 14:55:50 +00001183 * 3.3.14 RENAME3args
1184 *
1185 * struct RENAME3args {
1186 * diropargs3 from;
1187 * diropargs3 to;
1188 * };
1189 */
Chuck Lever9f06c712010-12-14 14:59:18 +00001190static void nfs3_xdr_enc_rename3args(struct rpc_rqst *req,
1191 struct xdr_stream *xdr,
1192 const struct nfs_renameargs *args)
Chuck Leverd9c407b2010-12-14 14:55:50 +00001193{
1194 const struct qstr *old = args->old_name;
1195 const struct qstr *new = args->new_name;
Chuck Leverd9c407b2010-12-14 14:55:50 +00001196
Chuck Lever9f06c712010-12-14 14:59:18 +00001197 encode_diropargs3(xdr, args->old_dir, old->name, old->len);
1198 encode_diropargs3(xdr, args->new_dir, new->name, new->len);
Chuck Leverd9c407b2010-12-14 14:55:50 +00001199}
1200
1201/*
Chuck Leverd9c407b2010-12-14 14:55:50 +00001202 * 3.3.15 LINK3args
1203 *
1204 * struct LINK3args {
1205 * nfs_fh3 file;
1206 * diropargs3 link;
1207 * };
1208 */
Chuck Lever9f06c712010-12-14 14:59:18 +00001209static void nfs3_xdr_enc_link3args(struct rpc_rqst *req,
1210 struct xdr_stream *xdr,
1211 const struct nfs3_linkargs *args)
Chuck Leverd9c407b2010-12-14 14:55:50 +00001212{
Chuck Lever9f06c712010-12-14 14:59:18 +00001213 encode_nfs_fh3(xdr, args->fromfh);
1214 encode_diropargs3(xdr, args->tofh, args->toname, args->tolen);
Chuck Leverd9c407b2010-12-14 14:55:50 +00001215}
1216
1217/*
Chuck Leverd9c407b2010-12-14 14:55:50 +00001218 * 3.3.16 READDIR3args
1219 *
1220 * struct READDIR3args {
1221 * nfs_fh3 dir;
1222 * cookie3 cookie;
1223 * cookieverf3 cookieverf;
1224 * count3 count;
1225 * };
1226 */
1227static 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
Chuck Lever9f06c712010-12-14 14:59:18 +00001240static void nfs3_xdr_enc_readdir3args(struct rpc_rqst *req,
1241 struct xdr_stream *xdr,
1242 const struct nfs3_readdirargs *args)
Chuck Leverd9c407b2010-12-14 14:55:50 +00001243{
Chuck Lever9f06c712010-12-14 14:59:18 +00001244 encode_readdir3args(xdr, args);
Chuck Leverd9c407b2010-12-14 14:55:50 +00001245 prepare_reply_buffer(req, args->pages, 0,
1246 args->count, NFS3_readdirres_sz);
Chuck Leverd9c407b2010-12-14 14:55:50 +00001247}
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 */
1260static 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
Chuck Lever9f06c712010-12-14 14:59:18 +00001280static void nfs3_xdr_enc_readdirplus3args(struct rpc_rqst *req,
1281 struct xdr_stream *xdr,
1282 const struct nfs3_readdirargs *args)
Chuck Leverd9c407b2010-12-14 14:55:50 +00001283{
Chuck Lever9f06c712010-12-14 14:59:18 +00001284 encode_readdirplus3args(xdr, args);
Chuck Leverd9c407b2010-12-14 14:55:50 +00001285 prepare_reply_buffer(req, args->pages, 0,
1286 args->count, NFS3_readdirres_sz);
Chuck Leverd9c407b2010-12-14 14:55:50 +00001287}
1288
1289/*
Chuck Leverd9c407b2010-12-14 14:55:50 +00001290 * 3.3.21 COMMIT3args
1291 *
1292 * struct COMMIT3args {
1293 * nfs_fh3 file;
1294 * offset3 offset;
1295 * count3 count;
1296 * };
1297 */
1298static void encode_commit3args(struct xdr_stream *xdr,
Fred Isaman0b7c0152012-04-20 14:47:39 -04001299 const struct nfs_commitargs *args)
Chuck Leverd9c407b2010-12-14 14:55:50 +00001300{
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
Chuck Lever9f06c712010-12-14 14:59:18 +00001310static void nfs3_xdr_enc_commit3args(struct rpc_rqst *req,
1311 struct xdr_stream *xdr,
Fred Isaman0b7c0152012-04-20 14:47:39 -04001312 const struct nfs_commitargs *args)
Chuck Leverd9c407b2010-12-14 14:55:50 +00001313{
Chuck Lever9f06c712010-12-14 14:59:18 +00001314 encode_commit3args(xdr, args);
Chuck Leverd9c407b2010-12-14 14:55:50 +00001315}
1316
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +00001317#ifdef CONFIG_NFS_V3_ACL
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +00001318
Chuck Lever9f06c712010-12-14 14:59:18 +00001319static void nfs3_xdr_enc_getacl3args(struct rpc_rqst *req,
1320 struct xdr_stream *xdr,
1321 const struct nfs3_getaclargs *args)
Chuck Leverd9c407b2010-12-14 14:55:50 +00001322{
Chuck Lever9f06c712010-12-14 14:59:18 +00001323 encode_nfs_fh3(xdr, args->fh);
1324 encode_uint32(xdr, args->mask);
Chuck Leverd9c407b2010-12-14 14:55:50 +00001325 if (args->mask & (NFS_ACL | NFS_DFACL))
1326 prepare_reply_buffer(req, args->pages, 0,
1327 NFSACL_MAXPAGES << PAGE_SHIFT,
1328 ACL3_getaclres_sz);
Chuck Leverd9c407b2010-12-14 14:55:50 +00001329}
1330
Chuck Lever9f06c712010-12-14 14:59:18 +00001331static void nfs3_xdr_enc_setacl3args(struct rpc_rqst *req,
1332 struct xdr_stream *xdr,
1333 const struct nfs3_setaclargs *args)
Chuck Leverd9c407b2010-12-14 14:55:50 +00001334{
Chuck Leverd9c407b2010-12-14 14:55:50 +00001335 unsigned int base;
1336 int error;
1337
Chuck Lever9f06c712010-12-14 14:59:18 +00001338 encode_nfs_fh3(xdr, NFS_FH(args->inode));
1339 encode_uint32(xdr, args->mask);
Chuck Leverd9c407b2010-12-14 14:55:50 +00001340
1341 base = req->rq_slen;
Chuck Leveree5dc772011-01-21 03:05:18 +00001342 if (args->npages != 0)
1343 xdr_write_pages(xdr, args->pages, 0, args->len);
1344 else
Chuck Leverd683cc42015-05-26 11:53:52 -04001345 xdr_reserve_space(xdr, args->len);
Chuck Leveree5dc772011-01-21 03:05:18 +00001346
Chuck Lever9f06c712010-12-14 14:59:18 +00001347 error = nfsacl_encode(xdr->buf, base, args->inode,
Chuck Leverd9c407b2010-12-14 14:55:50 +00001348 (args->mask & NFS_ACL) ?
1349 args->acl_access : NULL, 1, 0);
Trond Myklebust7fc38842012-10-15 11:51:21 -04001350 /* FIXME: this is just broken */
Chuck Leverd9c407b2010-12-14 14:55:50 +00001351 BUG_ON(error < 0);
Chuck Lever9f06c712010-12-14 14:59:18 +00001352 error = nfsacl_encode(xdr->buf, base + error, args->inode,
Chuck Leverd9c407b2010-12-14 14:55:50 +00001353 (args->mask & NFS_DFACL) ?
1354 args->acl_default : NULL, 1,
1355 NFS_ACL_DEFAULT);
1356 BUG_ON(error < 0);
Chuck Leverd9c407b2010-12-14 14:55:50 +00001357}
1358
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +00001359#endif /* CONFIG_NFS_V3_ACL */
1360
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361/*
Chuck Leverb2cdd9c2010-12-14 14:56:52 +00001362 * NFSv3 XDR decode functions
1363 *
1364 * NFSv3 result types are defined in section 3.3 of RFC 1813:
1365 * "NFS Version 3 Protocol Specification".
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 */
1367
1368/*
Chuck Levere4f93232010-12-14 14:56:30 +00001369 * 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 */
Chuck Leverbf269552010-12-14 14:59:29 +00001382static int nfs3_xdr_dec_getattr3res(struct rpc_rqst *req,
1383 struct xdr_stream *xdr,
Chuck Levere4f93232010-12-14 14:56:30 +00001384 struct nfs_fattr *result)
1385{
Chuck Levere4f93232010-12-14 14:56:30 +00001386 enum nfs_stat status;
1387 int error;
1388
Chuck Leverbf269552010-12-14 14:59:29 +00001389 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00001390 if (unlikely(error))
1391 goto out;
1392 if (status != NFS3_OK)
1393 goto out_default;
Chuck Leverbf269552010-12-14 14:59:29 +00001394 error = decode_fattr3(xdr, result);
Chuck Levere4f93232010-12-14 14:56:30 +00001395out:
1396 return error;
1397out_default:
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04001398 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00001399}
1400
1401/*
Chuck Levere4f93232010-12-14 14:56:30 +00001402 * 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 */
Chuck Leverbf269552010-12-14 14:59:29 +00001419static int nfs3_xdr_dec_setattr3res(struct rpc_rqst *req,
1420 struct xdr_stream *xdr,
Chuck Levere4f93232010-12-14 14:56:30 +00001421 struct nfs_fattr *result)
1422{
Chuck Levere4f93232010-12-14 14:56:30 +00001423 enum nfs_stat status;
1424 int error;
1425
Chuck Leverbf269552010-12-14 14:59:29 +00001426 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00001427 if (unlikely(error))
1428 goto out;
Chuck Leverbf269552010-12-14 14:59:29 +00001429 error = decode_wcc_data(xdr, result);
Chuck Levere4f93232010-12-14 14:56:30 +00001430 if (unlikely(error))
1431 goto out;
1432 if (status != NFS3_OK)
1433 goto out_status;
1434out:
1435 return error;
1436out_status:
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04001437 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00001438}
1439
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440/*
Chuck Levere4f93232010-12-14 14:56:30 +00001441 * 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 */
Chuck Leverbf269552010-12-14 14:59:29 +00001460static int nfs3_xdr_dec_lookup3res(struct rpc_rqst *req,
1461 struct xdr_stream *xdr,
Chuck Levere4f93232010-12-14 14:56:30 +00001462 struct nfs3_diropres *result)
1463{
Chuck Levere4f93232010-12-14 14:56:30 +00001464 enum nfs_stat status;
1465 int error;
1466
Chuck Leverbf269552010-12-14 14:59:29 +00001467 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00001468 if (unlikely(error))
1469 goto out;
1470 if (status != NFS3_OK)
1471 goto out_default;
Chuck Leverbf269552010-12-14 14:59:29 +00001472 error = decode_nfs_fh3(xdr, result->fh);
Chuck Levere4f93232010-12-14 14:56:30 +00001473 if (unlikely(error))
1474 goto out;
Chuck Leverbf269552010-12-14 14:59:29 +00001475 error = decode_post_op_attr(xdr, result->fattr);
Chuck Levere4f93232010-12-14 14:56:30 +00001476 if (unlikely(error))
1477 goto out;
Chuck Leverbf269552010-12-14 14:59:29 +00001478 error = decode_post_op_attr(xdr, result->dir_attr);
Chuck Levere4f93232010-12-14 14:56:30 +00001479out:
1480 return error;
1481out_default:
Chuck Leverbf269552010-12-14 14:59:29 +00001482 error = decode_post_op_attr(xdr, result->dir_attr);
Chuck Levere4f93232010-12-14 14:56:30 +00001483 if (unlikely(error))
1484 goto out;
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04001485 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00001486}
1487
1488/*
Chuck Levere4f93232010-12-14 14:56:30 +00001489 * 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 */
Chuck Leverbf269552010-12-14 14:59:29 +00001507static int nfs3_xdr_dec_access3res(struct rpc_rqst *req,
1508 struct xdr_stream *xdr,
Chuck Levere4f93232010-12-14 14:56:30 +00001509 struct nfs3_accessres *result)
1510{
Chuck Levere4f93232010-12-14 14:56:30 +00001511 enum nfs_stat status;
1512 int error;
1513
Chuck Leverbf269552010-12-14 14:59:29 +00001514 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00001515 if (unlikely(error))
1516 goto out;
Chuck Leverbf269552010-12-14 14:59:29 +00001517 error = decode_post_op_attr(xdr, result->fattr);
Chuck Levere4f93232010-12-14 14:56:30 +00001518 if (unlikely(error))
1519 goto out;
1520 if (status != NFS3_OK)
1521 goto out_default;
Chuck Leverbf269552010-12-14 14:59:29 +00001522 error = decode_uint32(xdr, &result->access);
Chuck Levere4f93232010-12-14 14:56:30 +00001523out:
1524 return error;
1525out_default:
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04001526 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00001527}
1528
1529/*
Chuck Levere4f93232010-12-14 14:56:30 +00001530 * 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 */
Chuck Leverbf269552010-12-14 14:59:29 +00001548static int nfs3_xdr_dec_readlink3res(struct rpc_rqst *req,
1549 struct xdr_stream *xdr,
Chuck Levere4f93232010-12-14 14:56:30 +00001550 struct nfs_fattr *result)
1551{
Chuck Levere4f93232010-12-14 14:56:30 +00001552 enum nfs_stat status;
1553 int error;
1554
Chuck Leverbf269552010-12-14 14:59:29 +00001555 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00001556 if (unlikely(error))
1557 goto out;
Chuck Leverbf269552010-12-14 14:59:29 +00001558 error = decode_post_op_attr(xdr, result);
Chuck Levere4f93232010-12-14 14:56:30 +00001559 if (unlikely(error))
1560 goto out;
1561 if (status != NFS3_OK)
1562 goto out_default;
Chuck Leverbf269552010-12-14 14:59:29 +00001563 error = decode_nfspath3(xdr);
Chuck Levere4f93232010-12-14 14:56:30 +00001564out:
1565 return error;
1566out_default:
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04001567 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00001568}
1569
1570/*
Chuck Levere4f93232010-12-14 14:56:30 +00001571 * 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 */
1591static int decode_read3resok(struct xdr_stream *xdr,
Anna Schumaker9137bdf2014-05-06 09:12:25 -04001592 struct nfs_pgio_res *result)
Chuck Levere4f93232010-12-14 14:56:30 +00001593{
1594 u32 eof, count, ocount, recvd;
Chuck Levere4f93232010-12-14 14:56:30 +00001595 __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;
Trond Myklebust64bd5772012-06-20 22:35:05 -04001605 recvd = xdr_read_pages(xdr, count);
Chuck Levere4f93232010-12-14 14:56:30 +00001606 if (unlikely(count > recvd))
1607 goto out_cheating;
Chuck Levere4f93232010-12-14 14:56:30 +00001608out:
Chuck Levere4f93232010-12-14 14:56:30 +00001609 result->eof = eof;
1610 result->count = count;
1611 return count;
1612out_mismatch:
1613 dprintk("NFS: READ count doesn't match length of opaque: "
1614 "count %u != ocount %u\n", count, ocount);
1615 return -EIO;
1616out_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;
1622out_overflow:
1623 print_overflow_msg(__func__, xdr);
1624 return -EIO;
1625}
1626
Chuck Leverbf269552010-12-14 14:59:29 +00001627static int nfs3_xdr_dec_read3res(struct rpc_rqst *req, struct xdr_stream *xdr,
Anna Schumaker9137bdf2014-05-06 09:12:25 -04001628 struct nfs_pgio_res *result)
Chuck Levere4f93232010-12-14 14:56:30 +00001629{
Chuck Levere4f93232010-12-14 14:56:30 +00001630 enum nfs_stat status;
1631 int error;
1632
Chuck Leverbf269552010-12-14 14:59:29 +00001633 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00001634 if (unlikely(error))
1635 goto out;
Chuck Leverbf269552010-12-14 14:59:29 +00001636 error = decode_post_op_attr(xdr, result->fattr);
Chuck Levere4f93232010-12-14 14:56:30 +00001637 if (unlikely(error))
1638 goto out;
Peng Taoaabff4d2014-08-27 10:47:14 +08001639 result->op_status = status;
Chuck Levere4f93232010-12-14 14:56:30 +00001640 if (status != NFS3_OK)
1641 goto out_status;
Chuck Leverbf269552010-12-14 14:59:29 +00001642 error = decode_read3resok(xdr, result);
Chuck Levere4f93232010-12-14 14:56:30 +00001643out:
1644 return error;
1645out_status:
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04001646 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00001647}
1648
1649/*
Chuck Levere4f93232010-12-14 14:56:30 +00001650 * 3.3.7 WRITE3res
1651 *
1652 * enum stable_how {
1653 * UNSTABLE = 0,
1654 * DATA_SYNC = 1,
1655 * FILE_SYNC = 2
1656 * };
1657 *
1658 * struct WRITE3resok {
1659 * wcc_data file_wcc;
1660 * count3 count;
1661 * stable_how committed;
1662 * writeverf3 verf;
1663 * };
1664 *
1665 * struct WRITE3resfail {
1666 * wcc_data file_wcc;
1667 * };
1668 *
1669 * union WRITE3res switch (nfsstat3 status) {
1670 * case NFS3_OK:
1671 * WRITE3resok resok;
1672 * default:
1673 * WRITE3resfail resfail;
1674 * };
1675 */
1676static int decode_write3resok(struct xdr_stream *xdr,
Anna Schumaker9137bdf2014-05-06 09:12:25 -04001677 struct nfs_pgio_res *result)
Chuck Levere4f93232010-12-14 14:56:30 +00001678{
1679 __be32 *p;
1680
Trond Myklebust2f2c63b2012-06-08 11:56:09 -04001681 p = xdr_inline_decode(xdr, 4 + 4);
Chuck Levere4f93232010-12-14 14:56:30 +00001682 if (unlikely(p == NULL))
1683 goto out_overflow;
1684 result->count = be32_to_cpup(p++);
1685 result->verf->committed = be32_to_cpup(p++);
1686 if (unlikely(result->verf->committed > NFS_FILE_SYNC))
1687 goto out_badvalue;
Trond Myklebust2f2c63b2012-06-08 11:56:09 -04001688 if (decode_writeverf3(xdr, &result->verf->verifier))
1689 goto out_eio;
Chuck Levere4f93232010-12-14 14:56:30 +00001690 return result->count;
1691out_badvalue:
1692 dprintk("NFS: bad stable_how value: %u\n", result->verf->committed);
1693 return -EIO;
1694out_overflow:
1695 print_overflow_msg(__func__, xdr);
Trond Myklebust2f2c63b2012-06-08 11:56:09 -04001696out_eio:
Chuck Levere4f93232010-12-14 14:56:30 +00001697 return -EIO;
1698}
1699
Chuck Leverbf269552010-12-14 14:59:29 +00001700static int nfs3_xdr_dec_write3res(struct rpc_rqst *req, struct xdr_stream *xdr,
Anna Schumaker9137bdf2014-05-06 09:12:25 -04001701 struct nfs_pgio_res *result)
Chuck Levere4f93232010-12-14 14:56:30 +00001702{
Chuck Levere4f93232010-12-14 14:56:30 +00001703 enum nfs_stat status;
1704 int error;
1705
Chuck Leverbf269552010-12-14 14:59:29 +00001706 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00001707 if (unlikely(error))
1708 goto out;
Chuck Leverbf269552010-12-14 14:59:29 +00001709 error = decode_wcc_data(xdr, result->fattr);
Chuck Levere4f93232010-12-14 14:56:30 +00001710 if (unlikely(error))
1711 goto out;
Peng Taoaabff4d2014-08-27 10:47:14 +08001712 result->op_status = status;
Chuck Levere4f93232010-12-14 14:56:30 +00001713 if (status != NFS3_OK)
1714 goto out_status;
Chuck Leverbf269552010-12-14 14:59:29 +00001715 error = decode_write3resok(xdr, result);
Chuck Levere4f93232010-12-14 14:56:30 +00001716out:
1717 return error;
1718out_status:
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04001719 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00001720}
1721
1722/*
Chuck Levere4f93232010-12-14 14:56:30 +00001723 * 3.3.8 CREATE3res
1724 *
1725 * struct CREATE3resok {
1726 * post_op_fh3 obj;
1727 * post_op_attr obj_attributes;
1728 * wcc_data dir_wcc;
1729 * };
1730 *
1731 * struct CREATE3resfail {
1732 * wcc_data dir_wcc;
1733 * };
1734 *
1735 * union CREATE3res switch (nfsstat3 status) {
1736 * case NFS3_OK:
1737 * CREATE3resok resok;
1738 * default:
1739 * CREATE3resfail resfail;
1740 * };
1741 */
1742static int decode_create3resok(struct xdr_stream *xdr,
1743 struct nfs3_diropres *result)
1744{
1745 int error;
1746
1747 error = decode_post_op_fh3(xdr, result->fh);
1748 if (unlikely(error))
1749 goto out;
1750 error = decode_post_op_attr(xdr, result->fattr);
1751 if (unlikely(error))
1752 goto out;
1753 /* The server isn't required to return a file handle.
1754 * If it didn't, force the client to perform a LOOKUP
1755 * to determine the correct file handle and attribute
1756 * values for the new object. */
1757 if (result->fh->size == 0)
1758 result->fattr->valid = 0;
1759 error = decode_wcc_data(xdr, result->dir_attr);
1760out:
1761 return error;
1762}
1763
Chuck Leverbf269552010-12-14 14:59:29 +00001764static int nfs3_xdr_dec_create3res(struct rpc_rqst *req,
1765 struct xdr_stream *xdr,
Chuck Levere4f93232010-12-14 14:56:30 +00001766 struct nfs3_diropres *result)
1767{
Chuck Levere4f93232010-12-14 14:56:30 +00001768 enum nfs_stat status;
1769 int error;
1770
Chuck Leverbf269552010-12-14 14:59:29 +00001771 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00001772 if (unlikely(error))
1773 goto out;
1774 if (status != NFS3_OK)
1775 goto out_default;
Chuck Leverbf269552010-12-14 14:59:29 +00001776 error = decode_create3resok(xdr, result);
Chuck Levere4f93232010-12-14 14:56:30 +00001777out:
1778 return error;
1779out_default:
Chuck Leverbf269552010-12-14 14:59:29 +00001780 error = decode_wcc_data(xdr, result->dir_attr);
Chuck Levere4f93232010-12-14 14:56:30 +00001781 if (unlikely(error))
1782 goto out;
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04001783 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00001784}
1785
1786/*
1787 * 3.3.12 REMOVE3res
1788 *
1789 * struct REMOVE3resok {
1790 * wcc_data dir_wcc;
1791 * };
1792 *
1793 * struct REMOVE3resfail {
1794 * wcc_data dir_wcc;
1795 * };
1796 *
1797 * union REMOVE3res switch (nfsstat3 status) {
1798 * case NFS3_OK:
1799 * REMOVE3resok resok;
1800 * default:
1801 * REMOVE3resfail resfail;
1802 * };
1803 */
Chuck Leverbf269552010-12-14 14:59:29 +00001804static int nfs3_xdr_dec_remove3res(struct rpc_rqst *req,
1805 struct xdr_stream *xdr,
Chuck Levere4f93232010-12-14 14:56:30 +00001806 struct nfs_removeres *result)
1807{
Chuck Levere4f93232010-12-14 14:56:30 +00001808 enum nfs_stat status;
1809 int error;
1810
Chuck Leverbf269552010-12-14 14:59:29 +00001811 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00001812 if (unlikely(error))
1813 goto out;
Chuck Leverbf269552010-12-14 14:59:29 +00001814 error = decode_wcc_data(xdr, result->dir_attr);
Chuck Levere4f93232010-12-14 14:56:30 +00001815 if (unlikely(error))
1816 goto out;
1817 if (status != NFS3_OK)
1818 goto out_status;
1819out:
1820 return error;
1821out_status:
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04001822 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00001823}
1824
1825/*
Chuck Levere4f93232010-12-14 14:56:30 +00001826 * 3.3.14 RENAME3res
1827 *
1828 * struct RENAME3resok {
1829 * wcc_data fromdir_wcc;
1830 * wcc_data todir_wcc;
1831 * };
1832 *
1833 * struct RENAME3resfail {
1834 * wcc_data fromdir_wcc;
1835 * wcc_data todir_wcc;
1836 * };
1837 *
1838 * union RENAME3res switch (nfsstat3 status) {
1839 * case NFS3_OK:
1840 * RENAME3resok resok;
1841 * default:
1842 * RENAME3resfail resfail;
1843 * };
1844 */
Chuck Leverbf269552010-12-14 14:59:29 +00001845static int nfs3_xdr_dec_rename3res(struct rpc_rqst *req,
1846 struct xdr_stream *xdr,
Chuck Levere4f93232010-12-14 14:56:30 +00001847 struct nfs_renameres *result)
1848{
Chuck Levere4f93232010-12-14 14:56:30 +00001849 enum nfs_stat status;
1850 int error;
1851
Chuck Leverbf269552010-12-14 14:59:29 +00001852 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00001853 if (unlikely(error))
1854 goto out;
Chuck Leverbf269552010-12-14 14:59:29 +00001855 error = decode_wcc_data(xdr, result->old_fattr);
Chuck Levere4f93232010-12-14 14:56:30 +00001856 if (unlikely(error))
1857 goto out;
Chuck Leverbf269552010-12-14 14:59:29 +00001858 error = decode_wcc_data(xdr, result->new_fattr);
Chuck Levere4f93232010-12-14 14:56:30 +00001859 if (unlikely(error))
1860 goto out;
1861 if (status != NFS3_OK)
1862 goto out_status;
1863out:
1864 return error;
1865out_status:
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04001866 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00001867}
1868
1869/*
Chuck Levere4f93232010-12-14 14:56:30 +00001870 * 3.3.15 LINK3res
1871 *
1872 * struct LINK3resok {
1873 * post_op_attr file_attributes;
1874 * wcc_data linkdir_wcc;
1875 * };
1876 *
1877 * struct LINK3resfail {
1878 * post_op_attr file_attributes;
1879 * wcc_data linkdir_wcc;
1880 * };
1881 *
1882 * union LINK3res switch (nfsstat3 status) {
1883 * case NFS3_OK:
1884 * LINK3resok resok;
1885 * default:
1886 * LINK3resfail resfail;
1887 * };
1888 */
Chuck Leverbf269552010-12-14 14:59:29 +00001889static int nfs3_xdr_dec_link3res(struct rpc_rqst *req, struct xdr_stream *xdr,
Chuck Levere4f93232010-12-14 14:56:30 +00001890 struct nfs3_linkres *result)
1891{
Chuck Levere4f93232010-12-14 14:56:30 +00001892 enum nfs_stat status;
1893 int error;
1894
Chuck Leverbf269552010-12-14 14:59:29 +00001895 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00001896 if (unlikely(error))
1897 goto out;
Chuck Leverbf269552010-12-14 14:59:29 +00001898 error = decode_post_op_attr(xdr, result->fattr);
Chuck Levere4f93232010-12-14 14:56:30 +00001899 if (unlikely(error))
1900 goto out;
Chuck Leverbf269552010-12-14 14:59:29 +00001901 error = decode_wcc_data(xdr, result->dir_attr);
Chuck Levere4f93232010-12-14 14:56:30 +00001902 if (unlikely(error))
1903 goto out;
1904 if (status != NFS3_OK)
1905 goto out_status;
1906out:
1907 return error;
1908out_status:
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04001909 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00001910}
1911
1912/**
1913 * nfs3_decode_dirent - Decode a single NFSv3 directory entry stored in
1914 * the local page cache
1915 * @xdr: XDR stream where entry resides
1916 * @entry: buffer to fill in with entry data
Chuck Levere4f93232010-12-14 14:56:30 +00001917 * @plus: boolean indicating whether this should be a readdirplus entry
1918 *
Chuck Lever573c4e12010-12-14 14:58:11 +00001919 * Returns zero if successful, otherwise a negative errno value is
1920 * returned.
Chuck Levere4f93232010-12-14 14:56:30 +00001921 *
1922 * This function is not invoked during READDIR reply decoding, but
1923 * rather whenever an application invokes the getdents(2) system call
1924 * on a directory already in our cache.
1925 *
1926 * 3.3.16 entry3
1927 *
1928 * struct entry3 {
1929 * fileid3 fileid;
1930 * filename3 name;
1931 * cookie3 cookie;
1932 * fhandle3 filehandle;
1933 * post_op_attr3 attributes;
1934 * entry3 *nextentry;
1935 * };
1936 *
1937 * 3.3.17 entryplus3
1938 * struct entryplus3 {
1939 * fileid3 fileid;
1940 * filename3 name;
1941 * cookie3 cookie;
1942 * post_op_attr name_attributes;
1943 * post_op_fh3 name_handle;
1944 * entryplus3 *nextentry;
1945 * };
1946 */
Chuck Lever573c4e12010-12-14 14:58:11 +00001947int nfs3_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry,
1948 int plus)
Chuck Levere4f93232010-12-14 14:56:30 +00001949{
1950 struct nfs_entry old = *entry;
1951 __be32 *p;
1952 int error;
1953
1954 p = xdr_inline_decode(xdr, 4);
1955 if (unlikely(p == NULL))
1956 goto out_overflow;
1957 if (*p == xdr_zero) {
1958 p = xdr_inline_decode(xdr, 4);
1959 if (unlikely(p == NULL))
1960 goto out_overflow;
1961 if (*p == xdr_zero)
Chuck Lever573c4e12010-12-14 14:58:11 +00001962 return -EAGAIN;
Chuck Levere4f93232010-12-14 14:56:30 +00001963 entry->eof = 1;
Chuck Lever573c4e12010-12-14 14:58:11 +00001964 return -EBADCOOKIE;
Chuck Levere4f93232010-12-14 14:56:30 +00001965 }
1966
1967 error = decode_fileid3(xdr, &entry->ino);
1968 if (unlikely(error))
Chuck Lever573c4e12010-12-14 14:58:11 +00001969 return error;
Chuck Levere4f93232010-12-14 14:56:30 +00001970
1971 error = decode_inline_filename3(xdr, &entry->name, &entry->len);
1972 if (unlikely(error))
Chuck Lever573c4e12010-12-14 14:58:11 +00001973 return error;
Chuck Levere4f93232010-12-14 14:56:30 +00001974
1975 entry->prev_cookie = entry->cookie;
1976 error = decode_cookie3(xdr, &entry->cookie);
1977 if (unlikely(error))
Chuck Lever573c4e12010-12-14 14:58:11 +00001978 return error;
Chuck Levere4f93232010-12-14 14:56:30 +00001979
1980 entry->d_type = DT_UNKNOWN;
1981
1982 if (plus) {
1983 entry->fattr->valid = 0;
1984 error = decode_post_op_attr(xdr, entry->fattr);
1985 if (unlikely(error))
Chuck Lever573c4e12010-12-14 14:58:11 +00001986 return error;
Chuck Levere4f93232010-12-14 14:56:30 +00001987 if (entry->fattr->valid & NFS_ATTR_FATTR_V3)
1988 entry->d_type = nfs_umode_to_dtype(entry->fattr->mode);
1989
Trond Myklebust1ae04b22015-02-23 16:15:00 -05001990 if (entry->fattr->fileid != entry->ino) {
1991 entry->fattr->mounted_on_fileid = entry->ino;
1992 entry->fattr->valid |= NFS_ATTR_FATTR_MOUNTED_ON_FILEID;
1993 }
1994
Chuck Levere4f93232010-12-14 14:56:30 +00001995 /* In fact, a post_op_fh3: */
1996 p = xdr_inline_decode(xdr, 4);
1997 if (unlikely(p == NULL))
1998 goto out_overflow;
1999 if (*p != xdr_zero) {
2000 error = decode_nfs_fh3(xdr, entry->fh);
2001 if (unlikely(error)) {
2002 if (error == -E2BIG)
2003 goto out_truncated;
Chuck Lever573c4e12010-12-14 14:58:11 +00002004 return error;
Chuck Levere4f93232010-12-14 14:56:30 +00002005 }
2006 } else
2007 zero_nfs_fh3(entry->fh);
2008 }
2009
Chuck Lever573c4e12010-12-14 14:58:11 +00002010 return 0;
Chuck Levere4f93232010-12-14 14:56:30 +00002011
2012out_overflow:
2013 print_overflow_msg(__func__, xdr);
Chuck Lever573c4e12010-12-14 14:58:11 +00002014 return -EAGAIN;
Chuck Levere4f93232010-12-14 14:56:30 +00002015out_truncated:
2016 dprintk("NFS: directory entry contains invalid file handle\n");
2017 *entry = old;
Chuck Lever573c4e12010-12-14 14:58:11 +00002018 return -EAGAIN;
Chuck Levere4f93232010-12-14 14:56:30 +00002019}
2020
2021/*
2022 * 3.3.16 READDIR3res
2023 *
2024 * struct dirlist3 {
2025 * entry3 *entries;
2026 * bool eof;
2027 * };
2028 *
2029 * struct READDIR3resok {
2030 * post_op_attr dir_attributes;
2031 * cookieverf3 cookieverf;
2032 * dirlist3 reply;
2033 * };
2034 *
2035 * struct READDIR3resfail {
2036 * post_op_attr dir_attributes;
2037 * };
2038 *
2039 * union READDIR3res switch (nfsstat3 status) {
2040 * case NFS3_OK:
2041 * READDIR3resok resok;
2042 * default:
2043 * READDIR3resfail resfail;
2044 * };
2045 *
2046 * Read the directory contents into the page cache, but otherwise
2047 * don't touch them. The actual decoding is done by nfs3_decode_entry()
2048 * during subsequent nfs_readdir() calls.
2049 */
2050static int decode_dirlist3(struct xdr_stream *xdr)
2051{
Trond Myklebust64bd5772012-06-20 22:35:05 -04002052 return xdr_read_pages(xdr, xdr->buf->page_len);
Chuck Levere4f93232010-12-14 14:56:30 +00002053}
2054
2055static int decode_readdir3resok(struct xdr_stream *xdr,
2056 struct nfs3_readdirres *result)
2057{
2058 int error;
2059
2060 error = decode_post_op_attr(xdr, result->dir_attr);
2061 if (unlikely(error))
2062 goto out;
2063 /* XXX: do we need to check if result->verf != NULL ? */
2064 error = decode_cookieverf3(xdr, result->verf);
2065 if (unlikely(error))
2066 goto out;
2067 error = decode_dirlist3(xdr);
2068out:
2069 return error;
2070}
2071
Chuck Leverbf269552010-12-14 14:59:29 +00002072static int nfs3_xdr_dec_readdir3res(struct rpc_rqst *req,
2073 struct xdr_stream *xdr,
Chuck Levere4f93232010-12-14 14:56:30 +00002074 struct nfs3_readdirres *result)
2075{
Chuck Levere4f93232010-12-14 14:56:30 +00002076 enum nfs_stat status;
2077 int error;
2078
Chuck Leverbf269552010-12-14 14:59:29 +00002079 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00002080 if (unlikely(error))
2081 goto out;
2082 if (status != NFS3_OK)
2083 goto out_default;
Chuck Leverbf269552010-12-14 14:59:29 +00002084 error = decode_readdir3resok(xdr, result);
Chuck Levere4f93232010-12-14 14:56:30 +00002085out:
2086 return error;
2087out_default:
Chuck Leverbf269552010-12-14 14:59:29 +00002088 error = decode_post_op_attr(xdr, result->dir_attr);
Chuck Levere4f93232010-12-14 14:56:30 +00002089 if (unlikely(error))
2090 goto out;
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04002091 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00002092}
2093
2094/*
Chuck Levere4f93232010-12-14 14:56:30 +00002095 * 3.3.18 FSSTAT3res
2096 *
2097 * struct FSSTAT3resok {
2098 * post_op_attr obj_attributes;
2099 * size3 tbytes;
2100 * size3 fbytes;
2101 * size3 abytes;
2102 * size3 tfiles;
2103 * size3 ffiles;
2104 * size3 afiles;
2105 * uint32 invarsec;
2106 * };
2107 *
2108 * struct FSSTAT3resfail {
2109 * post_op_attr obj_attributes;
2110 * };
2111 *
2112 * union FSSTAT3res switch (nfsstat3 status) {
2113 * case NFS3_OK:
2114 * FSSTAT3resok resok;
2115 * default:
2116 * FSSTAT3resfail resfail;
2117 * };
2118 */
2119static int decode_fsstat3resok(struct xdr_stream *xdr,
2120 struct nfs_fsstat *result)
2121{
2122 __be32 *p;
2123
2124 p = xdr_inline_decode(xdr, 8 * 6 + 4);
2125 if (unlikely(p == NULL))
2126 goto out_overflow;
2127 p = xdr_decode_size3(p, &result->tbytes);
2128 p = xdr_decode_size3(p, &result->fbytes);
2129 p = xdr_decode_size3(p, &result->abytes);
2130 p = xdr_decode_size3(p, &result->tfiles);
2131 p = xdr_decode_size3(p, &result->ffiles);
2132 xdr_decode_size3(p, &result->afiles);
2133 /* ignore invarsec */
2134 return 0;
2135out_overflow:
2136 print_overflow_msg(__func__, xdr);
2137 return -EIO;
2138}
2139
Chuck Leverbf269552010-12-14 14:59:29 +00002140static int nfs3_xdr_dec_fsstat3res(struct rpc_rqst *req,
2141 struct xdr_stream *xdr,
Chuck Levere4f93232010-12-14 14:56:30 +00002142 struct nfs_fsstat *result)
2143{
Chuck Levere4f93232010-12-14 14:56:30 +00002144 enum nfs_stat status;
2145 int error;
2146
Chuck Leverbf269552010-12-14 14:59:29 +00002147 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00002148 if (unlikely(error))
2149 goto out;
Chuck Leverbf269552010-12-14 14:59:29 +00002150 error = decode_post_op_attr(xdr, result->fattr);
Chuck Levere4f93232010-12-14 14:56:30 +00002151 if (unlikely(error))
2152 goto out;
2153 if (status != NFS3_OK)
2154 goto out_status;
Chuck Leverbf269552010-12-14 14:59:29 +00002155 error = decode_fsstat3resok(xdr, result);
Chuck Levere4f93232010-12-14 14:56:30 +00002156out:
2157 return error;
2158out_status:
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04002159 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00002160}
2161
2162/*
Chuck Levere4f93232010-12-14 14:56:30 +00002163 * 3.3.19 FSINFO3res
2164 *
2165 * struct FSINFO3resok {
2166 * post_op_attr obj_attributes;
2167 * uint32 rtmax;
2168 * uint32 rtpref;
2169 * uint32 rtmult;
2170 * uint32 wtmax;
2171 * uint32 wtpref;
2172 * uint32 wtmult;
2173 * uint32 dtpref;
2174 * size3 maxfilesize;
2175 * nfstime3 time_delta;
2176 * uint32 properties;
2177 * };
2178 *
2179 * struct FSINFO3resfail {
2180 * post_op_attr obj_attributes;
2181 * };
2182 *
2183 * union FSINFO3res switch (nfsstat3 status) {
2184 * case NFS3_OK:
2185 * FSINFO3resok resok;
2186 * default:
2187 * FSINFO3resfail resfail;
2188 * };
2189 */
2190static int decode_fsinfo3resok(struct xdr_stream *xdr,
2191 struct nfs_fsinfo *result)
2192{
2193 __be32 *p;
2194
2195 p = xdr_inline_decode(xdr, 4 * 7 + 8 + 8 + 4);
2196 if (unlikely(p == NULL))
2197 goto out_overflow;
2198 result->rtmax = be32_to_cpup(p++);
2199 result->rtpref = be32_to_cpup(p++);
2200 result->rtmult = be32_to_cpup(p++);
2201 result->wtmax = be32_to_cpup(p++);
2202 result->wtpref = be32_to_cpup(p++);
2203 result->wtmult = be32_to_cpup(p++);
2204 result->dtpref = be32_to_cpup(p++);
2205 p = xdr_decode_size3(p, &result->maxfilesize);
Chuck Leverf6048702010-12-14 14:57:02 +00002206 xdr_decode_nfstime3(p, &result->time_delta);
Chuck Levere4f93232010-12-14 14:56:30 +00002207
2208 /* ignore properties */
2209 result->lease_time = 0;
2210 return 0;
2211out_overflow:
2212 print_overflow_msg(__func__, xdr);
2213 return -EIO;
2214}
2215
Chuck Leverbf269552010-12-14 14:59:29 +00002216static int nfs3_xdr_dec_fsinfo3res(struct rpc_rqst *req,
2217 struct xdr_stream *xdr,
Chuck Levere4f93232010-12-14 14:56:30 +00002218 struct nfs_fsinfo *result)
2219{
Chuck Levere4f93232010-12-14 14:56:30 +00002220 enum nfs_stat status;
2221 int error;
2222
Chuck Leverbf269552010-12-14 14:59:29 +00002223 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00002224 if (unlikely(error))
2225 goto out;
Chuck Leverbf269552010-12-14 14:59:29 +00002226 error = decode_post_op_attr(xdr, result->fattr);
Chuck Levere4f93232010-12-14 14:56:30 +00002227 if (unlikely(error))
2228 goto out;
2229 if (status != NFS3_OK)
2230 goto out_status;
Chuck Leverbf269552010-12-14 14:59:29 +00002231 error = decode_fsinfo3resok(xdr, result);
Chuck Levere4f93232010-12-14 14:56:30 +00002232out:
2233 return error;
2234out_status:
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04002235 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00002236}
2237
2238/*
Chuck Levere4f93232010-12-14 14:56:30 +00002239 * 3.3.20 PATHCONF3res
2240 *
2241 * struct PATHCONF3resok {
2242 * post_op_attr obj_attributes;
2243 * uint32 linkmax;
2244 * uint32 name_max;
2245 * bool no_trunc;
2246 * bool chown_restricted;
2247 * bool case_insensitive;
2248 * bool case_preserving;
2249 * };
2250 *
2251 * struct PATHCONF3resfail {
2252 * post_op_attr obj_attributes;
2253 * };
2254 *
2255 * union PATHCONF3res switch (nfsstat3 status) {
2256 * case NFS3_OK:
2257 * PATHCONF3resok resok;
2258 * default:
2259 * PATHCONF3resfail resfail;
2260 * };
2261 */
2262static int decode_pathconf3resok(struct xdr_stream *xdr,
2263 struct nfs_pathconf *result)
2264{
2265 __be32 *p;
2266
2267 p = xdr_inline_decode(xdr, 4 * 6);
2268 if (unlikely(p == NULL))
2269 goto out_overflow;
2270 result->max_link = be32_to_cpup(p++);
2271 result->max_namelen = be32_to_cpup(p);
2272 /* ignore remaining fields */
2273 return 0;
2274out_overflow:
2275 print_overflow_msg(__func__, xdr);
2276 return -EIO;
2277}
2278
Chuck Leverbf269552010-12-14 14:59:29 +00002279static int nfs3_xdr_dec_pathconf3res(struct rpc_rqst *req,
2280 struct xdr_stream *xdr,
Chuck Levere4f93232010-12-14 14:56:30 +00002281 struct nfs_pathconf *result)
2282{
Chuck Levere4f93232010-12-14 14:56:30 +00002283 enum nfs_stat status;
2284 int error;
2285
Chuck Leverbf269552010-12-14 14:59:29 +00002286 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00002287 if (unlikely(error))
2288 goto out;
Chuck Leverbf269552010-12-14 14:59:29 +00002289 error = decode_post_op_attr(xdr, result->fattr);
Chuck Levere4f93232010-12-14 14:56:30 +00002290 if (unlikely(error))
2291 goto out;
2292 if (status != NFS3_OK)
2293 goto out_status;
Chuck Leverbf269552010-12-14 14:59:29 +00002294 error = decode_pathconf3resok(xdr, result);
Chuck Levere4f93232010-12-14 14:56:30 +00002295out:
2296 return error;
2297out_status:
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04002298 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00002299}
2300
2301/*
Chuck Levere4f93232010-12-14 14:56:30 +00002302 * 3.3.21 COMMIT3res
2303 *
2304 * struct COMMIT3resok {
2305 * wcc_data file_wcc;
2306 * writeverf3 verf;
2307 * };
2308 *
2309 * struct COMMIT3resfail {
2310 * wcc_data file_wcc;
2311 * };
2312 *
2313 * union COMMIT3res switch (nfsstat3 status) {
2314 * case NFS3_OK:
2315 * COMMIT3resok resok;
2316 * default:
2317 * COMMIT3resfail resfail;
2318 * };
2319 */
Chuck Leverbf269552010-12-14 14:59:29 +00002320static int nfs3_xdr_dec_commit3res(struct rpc_rqst *req,
2321 struct xdr_stream *xdr,
Fred Isaman0b7c0152012-04-20 14:47:39 -04002322 struct nfs_commitres *result)
Chuck Levere4f93232010-12-14 14:56:30 +00002323{
Chuck Levere4f93232010-12-14 14:56:30 +00002324 enum nfs_stat status;
2325 int error;
2326
Chuck Leverbf269552010-12-14 14:59:29 +00002327 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00002328 if (unlikely(error))
2329 goto out;
Chuck Leverbf269552010-12-14 14:59:29 +00002330 error = decode_wcc_data(xdr, result->fattr);
Chuck Levere4f93232010-12-14 14:56:30 +00002331 if (unlikely(error))
2332 goto out;
Peng Taoaabff4d2014-08-27 10:47:14 +08002333 result->op_status = status;
Chuck Levere4f93232010-12-14 14:56:30 +00002334 if (status != NFS3_OK)
2335 goto out_status;
Trond Myklebust2f2c63b2012-06-08 11:56:09 -04002336 error = decode_writeverf3(xdr, &result->verf->verifier);
Chuck Levere4f93232010-12-14 14:56:30 +00002337out:
2338 return error;
2339out_status:
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04002340 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00002341}
2342
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +00002343#ifdef CONFIG_NFS_V3_ACL
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +00002344
Chuck Levere4f93232010-12-14 14:56:30 +00002345static inline int decode_getacl3resok(struct xdr_stream *xdr,
2346 struct nfs3_getaclres *result)
2347{
2348 struct posix_acl **acl;
2349 unsigned int *aclcnt;
2350 size_t hdrlen;
2351 int error;
2352
2353 error = decode_post_op_attr(xdr, result->fattr);
2354 if (unlikely(error))
2355 goto out;
2356 error = decode_uint32(xdr, &result->mask);
2357 if (unlikely(error))
2358 goto out;
2359 error = -EINVAL;
2360 if (result->mask & ~(NFS_ACL|NFS_ACLCNT|NFS_DFACL|NFS_DFACLCNT))
2361 goto out;
2362
Trond Myklebust1aecca32012-06-21 11:41:29 -04002363 hdrlen = xdr_stream_pos(xdr);
Chuck Levere4f93232010-12-14 14:56:30 +00002364
2365 acl = NULL;
2366 if (result->mask & NFS_ACL)
2367 acl = &result->acl_access;
2368 aclcnt = NULL;
2369 if (result->mask & NFS_ACLCNT)
2370 aclcnt = &result->acl_access_count;
2371 error = nfsacl_decode(xdr->buf, hdrlen, aclcnt, acl);
2372 if (unlikely(error <= 0))
2373 goto out;
2374
2375 acl = NULL;
2376 if (result->mask & NFS_DFACL)
2377 acl = &result->acl_default;
2378 aclcnt = NULL;
2379 if (result->mask & NFS_DFACLCNT)
2380 aclcnt = &result->acl_default_count;
2381 error = nfsacl_decode(xdr->buf, hdrlen + error, aclcnt, acl);
2382 if (unlikely(error <= 0))
2383 return error;
2384 error = 0;
2385out:
2386 return error;
2387}
2388
Chuck Leverbf269552010-12-14 14:59:29 +00002389static int nfs3_xdr_dec_getacl3res(struct rpc_rqst *req,
2390 struct xdr_stream *xdr,
Chuck Levere4f93232010-12-14 14:56:30 +00002391 struct nfs3_getaclres *result)
2392{
Chuck Levere4f93232010-12-14 14:56:30 +00002393 enum nfs_stat status;
2394 int error;
2395
Chuck Leverbf269552010-12-14 14:59:29 +00002396 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00002397 if (unlikely(error))
2398 goto out;
2399 if (status != NFS3_OK)
2400 goto out_default;
Chuck Leverbf269552010-12-14 14:59:29 +00002401 error = decode_getacl3resok(xdr, result);
Chuck Levere4f93232010-12-14 14:56:30 +00002402out:
2403 return error;
2404out_default:
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04002405 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00002406}
2407
Chuck Leverbf269552010-12-14 14:59:29 +00002408static int nfs3_xdr_dec_setacl3res(struct rpc_rqst *req,
2409 struct xdr_stream *xdr,
Chuck Levere4f93232010-12-14 14:56:30 +00002410 struct nfs_fattr *result)
2411{
Chuck Levere4f93232010-12-14 14:56:30 +00002412 enum nfs_stat status;
2413 int error;
2414
Chuck Leverbf269552010-12-14 14:59:29 +00002415 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00002416 if (unlikely(error))
2417 goto out;
2418 if (status != NFS3_OK)
2419 goto out_default;
Chuck Leverbf269552010-12-14 14:59:29 +00002420 error = decode_post_op_attr(xdr, result);
Chuck Levere4f93232010-12-14 14:56:30 +00002421out:
2422 return error;
2423out_default:
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04002424 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00002425}
2426
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +00002427#endif /* CONFIG_NFS_V3_ACL */
2428
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04002429
2430/*
2431 * We need to translate between nfs status return values and
2432 * the local errno values which may not be the same.
2433 */
2434static const struct {
2435 int stat;
2436 int errno;
2437} nfs_errtbl[] = {
2438 { NFS_OK, 0 },
2439 { NFSERR_PERM, -EPERM },
2440 { NFSERR_NOENT, -ENOENT },
2441 { NFSERR_IO, -errno_NFSERR_IO},
2442 { NFSERR_NXIO, -ENXIO },
2443/* { NFSERR_EAGAIN, -EAGAIN }, */
2444 { NFSERR_ACCES, -EACCES },
2445 { NFSERR_EXIST, -EEXIST },
2446 { NFSERR_XDEV, -EXDEV },
2447 { NFSERR_NODEV, -ENODEV },
2448 { NFSERR_NOTDIR, -ENOTDIR },
2449 { NFSERR_ISDIR, -EISDIR },
2450 { NFSERR_INVAL, -EINVAL },
2451 { NFSERR_FBIG, -EFBIG },
2452 { NFSERR_NOSPC, -ENOSPC },
2453 { NFSERR_ROFS, -EROFS },
2454 { NFSERR_MLINK, -EMLINK },
2455 { NFSERR_NAMETOOLONG, -ENAMETOOLONG },
2456 { NFSERR_NOTEMPTY, -ENOTEMPTY },
2457 { NFSERR_DQUOT, -EDQUOT },
2458 { NFSERR_STALE, -ESTALE },
2459 { NFSERR_REMOTE, -EREMOTE },
2460#ifdef EWFLUSH
2461 { NFSERR_WFLUSH, -EWFLUSH },
2462#endif
2463 { NFSERR_BADHANDLE, -EBADHANDLE },
2464 { NFSERR_NOT_SYNC, -ENOTSYNC },
2465 { NFSERR_BAD_COOKIE, -EBADCOOKIE },
2466 { NFSERR_NOTSUPP, -ENOTSUPP },
2467 { NFSERR_TOOSMALL, -ETOOSMALL },
2468 { NFSERR_SERVERFAULT, -EREMOTEIO },
2469 { NFSERR_BADTYPE, -EBADTYPE },
2470 { NFSERR_JUKEBOX, -EJUKEBOX },
2471 { -1, -EIO }
2472};
2473
2474/**
2475 * nfs3_stat_to_errno - convert an NFS status code to a local errno
2476 * @status: NFS status code to convert
2477 *
2478 * Returns a local errno value, or -EIO if the NFS status code is
2479 * not recognized. This function is used jointly by NFSv2 and NFSv3.
2480 */
2481static int nfs3_stat_to_errno(enum nfs_stat status)
2482{
2483 int i;
2484
2485 for (i = 0; nfs_errtbl[i].stat != -1; i++) {
2486 if (nfs_errtbl[i].stat == (int)status)
2487 return nfs_errtbl[i].errno;
2488 }
2489 dprintk("NFS: Unrecognized nfs status value: %u\n", status);
2490 return nfs_errtbl[i].errno;
2491}
2492
2493
Linus Torvalds1da177e2005-04-16 15:20:36 -07002494#define PROC(proc, argtype, restype, timer) \
2495[NFS3PROC_##proc] = { \
2496 .p_proc = NFS3PROC_##proc, \
Chuck Lever9f06c712010-12-14 14:59:18 +00002497 .p_encode = (kxdreproc_t)nfs3_xdr_enc_##argtype##3args, \
Chuck Leverbf269552010-12-14 14:59:29 +00002498 .p_decode = (kxdrdproc_t)nfs3_xdr_dec_##restype##3res, \
Chuck Leverad96b5b2010-12-14 14:56:01 +00002499 .p_arglen = NFS3_##argtype##args_sz, \
Chuck Leverf5fc3c502010-12-14 14:56:42 +00002500 .p_replen = NFS3_##restype##res_sz, \
Chuck Levercc0175c2006-03-20 13:44:22 -05002501 .p_timer = timer, \
2502 .p_statidx = NFS3PROC_##proc, \
2503 .p_name = #proc, \
Linus Torvalds1da177e2005-04-16 15:20:36 -07002504 }
2505
2506struct rpc_procinfo nfs3_procedures[] = {
Chuck Leverf5fc3c502010-12-14 14:56:42 +00002507 PROC(GETATTR, getattr, getattr, 1),
2508 PROC(SETATTR, setattr, setattr, 0),
2509 PROC(LOOKUP, lookup, lookup, 2),
2510 PROC(ACCESS, access, access, 1),
2511 PROC(READLINK, readlink, readlink, 3),
2512 PROC(READ, read, read, 3),
2513 PROC(WRITE, write, write, 4),
2514 PROC(CREATE, create, create, 0),
2515 PROC(MKDIR, mkdir, create, 0),
2516 PROC(SYMLINK, symlink, create, 0),
2517 PROC(MKNOD, mknod, create, 0),
2518 PROC(REMOVE, remove, remove, 0),
2519 PROC(RMDIR, lookup, setattr, 0),
2520 PROC(RENAME, rename, rename, 0),
2521 PROC(LINK, link, link, 0),
2522 PROC(READDIR, readdir, readdir, 3),
2523 PROC(READDIRPLUS, readdirplus, readdir, 3),
2524 PROC(FSSTAT, getattr, fsstat, 0),
2525 PROC(FSINFO, getattr, fsinfo, 0),
2526 PROC(PATHCONF, getattr, pathconf, 0),
2527 PROC(COMMIT, commit, commit, 5),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002528};
2529
Trond Myklebusta613fa12012-01-20 13:53:56 -05002530const struct rpc_version nfs_version3 = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002531 .number = 3,
Tobias Klausere8c96f82006-03-24 03:15:34 -08002532 .nrprocs = ARRAY_SIZE(nfs3_procedures),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002533 .procs = nfs3_procedures
2534};
2535
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +00002536#ifdef CONFIG_NFS_V3_ACL
2537static struct rpc_procinfo nfs3_acl_procedures[] = {
2538 [ACLPROC3_GETACL] = {
2539 .p_proc = ACLPROC3_GETACL,
Chuck Lever9f06c712010-12-14 14:59:18 +00002540 .p_encode = (kxdreproc_t)nfs3_xdr_enc_getacl3args,
Chuck Leverbf269552010-12-14 14:59:29 +00002541 .p_decode = (kxdrdproc_t)nfs3_xdr_dec_getacl3res,
Chuck Lever2bea90d2007-03-29 16:47:53 -04002542 .p_arglen = ACL3_getaclargs_sz,
2543 .p_replen = ACL3_getaclres_sz,
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +00002544 .p_timer = 1,
Chuck Levercc0175c2006-03-20 13:44:22 -05002545 .p_name = "GETACL",
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +00002546 },
2547 [ACLPROC3_SETACL] = {
2548 .p_proc = ACLPROC3_SETACL,
Chuck Lever9f06c712010-12-14 14:59:18 +00002549 .p_encode = (kxdreproc_t)nfs3_xdr_enc_setacl3args,
Chuck Leverbf269552010-12-14 14:59:29 +00002550 .p_decode = (kxdrdproc_t)nfs3_xdr_dec_setacl3res,
Chuck Lever2bea90d2007-03-29 16:47:53 -04002551 .p_arglen = ACL3_setaclargs_sz,
2552 .p_replen = ACL3_setaclres_sz,
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +00002553 .p_timer = 0,
Chuck Levercc0175c2006-03-20 13:44:22 -05002554 .p_name = "SETACL",
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +00002555 },
2556};
2557
Trond Myklebusta613fa12012-01-20 13:53:56 -05002558const struct rpc_version nfsacl_version3 = {
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +00002559 .number = 3,
2560 .nrprocs = sizeof(nfs3_acl_procedures)/
2561 sizeof(nfs3_acl_procedures[0]),
2562 .procs = nfs3_acl_procedures,
2563};
2564#endif /* CONFIG_NFS_V3_ACL */