blob: fa6d72131c19e64565df105eeb9ed472bb180bf0 [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 Myklebustae461412009-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,
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
Chuck Lever9f06c712010-12-14 14:59:18 +0000967static void nfs3_xdr_enc_read3args(struct rpc_rqst *req,
968 struct xdr_stream *xdr,
969 const struct nfs_readargs *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,
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);
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,
1011 const struct nfs_writeargs *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
1345 xdr_reserve_space(xdr, NFS_ACL_INLINE_BUFSIZE);
1346
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,
1592 struct nfs_readres *result)
1593{
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,
Chuck Levere4f93232010-12-14 14:56:30 +00001628 struct nfs_readres *result)
1629{
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;
1639 if (status != NFS3_OK)
1640 goto out_status;
Chuck Leverbf269552010-12-14 14:59:29 +00001641 error = decode_read3resok(xdr, result);
Chuck Levere4f93232010-12-14 14:56:30 +00001642out:
1643 return error;
1644out_status:
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04001645 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00001646}
1647
1648/*
Chuck Levere4f93232010-12-14 14:56:30 +00001649 * 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 */
1675static int decode_write3resok(struct xdr_stream *xdr,
1676 struct nfs_writeres *result)
1677{
1678 __be32 *p;
1679
Trond Myklebust2f2c63b2012-06-08 11:56:09 -04001680 p = xdr_inline_decode(xdr, 4 + 4);
Chuck Levere4f93232010-12-14 14:56:30 +00001681 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;
Trond Myklebust2f2c63b2012-06-08 11:56:09 -04001687 if (decode_writeverf3(xdr, &result->verf->verifier))
1688 goto out_eio;
Chuck Levere4f93232010-12-14 14:56:30 +00001689 return result->count;
1690out_badvalue:
1691 dprintk("NFS: bad stable_how value: %u\n", result->verf->committed);
1692 return -EIO;
1693out_overflow:
1694 print_overflow_msg(__func__, xdr);
Trond Myklebust2f2c63b2012-06-08 11:56:09 -04001695out_eio:
Chuck Levere4f93232010-12-14 14:56:30 +00001696 return -EIO;
1697}
1698
Chuck Leverbf269552010-12-14 14:59:29 +00001699static int nfs3_xdr_dec_write3res(struct rpc_rqst *req, struct xdr_stream *xdr,
Chuck Levere4f93232010-12-14 14:56:30 +00001700 struct nfs_writeres *result)
1701{
Chuck Levere4f93232010-12-14 14:56:30 +00001702 enum nfs_stat status;
1703 int error;
1704
Chuck Leverbf269552010-12-14 14:59:29 +00001705 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00001706 if (unlikely(error))
1707 goto out;
Chuck Leverbf269552010-12-14 14:59:29 +00001708 error = decode_wcc_data(xdr, result->fattr);
Chuck Levere4f93232010-12-14 14:56:30 +00001709 if (unlikely(error))
1710 goto out;
1711 if (status != NFS3_OK)
1712 goto out_status;
Chuck Leverbf269552010-12-14 14:59:29 +00001713 error = decode_write3resok(xdr, result);
Chuck Levere4f93232010-12-14 14:56:30 +00001714out:
1715 return error;
1716out_status:
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04001717 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00001718}
1719
1720/*
Chuck Levere4f93232010-12-14 14:56:30 +00001721 * 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 */
1740static 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);
1758out:
1759 return error;
1760}
1761
Chuck Leverbf269552010-12-14 14:59:29 +00001762static int nfs3_xdr_dec_create3res(struct rpc_rqst *req,
1763 struct xdr_stream *xdr,
Chuck Levere4f93232010-12-14 14:56:30 +00001764 struct nfs3_diropres *result)
1765{
Chuck Levere4f93232010-12-14 14:56:30 +00001766 enum nfs_stat status;
1767 int error;
1768
Chuck Leverbf269552010-12-14 14:59:29 +00001769 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00001770 if (unlikely(error))
1771 goto out;
1772 if (status != NFS3_OK)
1773 goto out_default;
Chuck Leverbf269552010-12-14 14:59:29 +00001774 error = decode_create3resok(xdr, result);
Chuck Levere4f93232010-12-14 14:56:30 +00001775out:
1776 return error;
1777out_default:
Chuck Leverbf269552010-12-14 14:59:29 +00001778 error = decode_wcc_data(xdr, result->dir_attr);
Chuck Levere4f93232010-12-14 14:56:30 +00001779 if (unlikely(error))
1780 goto out;
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04001781 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00001782}
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 */
Chuck Leverbf269552010-12-14 14:59:29 +00001802static int nfs3_xdr_dec_remove3res(struct rpc_rqst *req,
1803 struct xdr_stream *xdr,
Chuck Levere4f93232010-12-14 14:56:30 +00001804 struct nfs_removeres *result)
1805{
Chuck Levere4f93232010-12-14 14:56:30 +00001806 enum nfs_stat status;
1807 int error;
1808
Chuck Leverbf269552010-12-14 14:59:29 +00001809 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00001810 if (unlikely(error))
1811 goto out;
Chuck Leverbf269552010-12-14 14:59:29 +00001812 error = decode_wcc_data(xdr, result->dir_attr);
Chuck Levere4f93232010-12-14 14:56:30 +00001813 if (unlikely(error))
1814 goto out;
1815 if (status != NFS3_OK)
1816 goto out_status;
1817out:
1818 return error;
1819out_status:
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04001820 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00001821}
1822
1823/*
Chuck Levere4f93232010-12-14 14:56:30 +00001824 * 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 */
Chuck Leverbf269552010-12-14 14:59:29 +00001843static int nfs3_xdr_dec_rename3res(struct rpc_rqst *req,
1844 struct xdr_stream *xdr,
Chuck Levere4f93232010-12-14 14:56:30 +00001845 struct nfs_renameres *result)
1846{
Chuck Levere4f93232010-12-14 14:56:30 +00001847 enum nfs_stat status;
1848 int error;
1849
Chuck Leverbf269552010-12-14 14:59:29 +00001850 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00001851 if (unlikely(error))
1852 goto out;
Chuck Leverbf269552010-12-14 14:59:29 +00001853 error = decode_wcc_data(xdr, result->old_fattr);
Chuck Levere4f93232010-12-14 14:56:30 +00001854 if (unlikely(error))
1855 goto out;
Chuck Leverbf269552010-12-14 14:59:29 +00001856 error = decode_wcc_data(xdr, result->new_fattr);
Chuck Levere4f93232010-12-14 14:56:30 +00001857 if (unlikely(error))
1858 goto out;
1859 if (status != NFS3_OK)
1860 goto out_status;
1861out:
1862 return error;
1863out_status:
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04001864 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00001865}
1866
1867/*
Chuck Levere4f93232010-12-14 14:56:30 +00001868 * 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 */
Chuck Leverbf269552010-12-14 14:59:29 +00001887static int nfs3_xdr_dec_link3res(struct rpc_rqst *req, struct xdr_stream *xdr,
Chuck Levere4f93232010-12-14 14:56:30 +00001888 struct nfs3_linkres *result)
1889{
Chuck Levere4f93232010-12-14 14:56:30 +00001890 enum nfs_stat status;
1891 int error;
1892
Chuck Leverbf269552010-12-14 14:59:29 +00001893 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00001894 if (unlikely(error))
1895 goto out;
Chuck Leverbf269552010-12-14 14:59:29 +00001896 error = decode_post_op_attr(xdr, result->fattr);
Chuck Levere4f93232010-12-14 14:56:30 +00001897 if (unlikely(error))
1898 goto out;
Chuck Leverbf269552010-12-14 14:59:29 +00001899 error = decode_wcc_data(xdr, result->dir_attr);
Chuck Levere4f93232010-12-14 14:56:30 +00001900 if (unlikely(error))
1901 goto out;
1902 if (status != NFS3_OK)
1903 goto out_status;
1904out:
1905 return error;
1906out_status:
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04001907 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00001908}
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
Chuck Levere4f93232010-12-14 14:56:30 +00001915 * @plus: boolean indicating whether this should be a readdirplus entry
1916 *
Chuck Lever573c4e12010-12-14 14:58:11 +00001917 * Returns zero if successful, otherwise a negative errno value is
1918 * returned.
Chuck Levere4f93232010-12-14 14:56:30 +00001919 *
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 */
Chuck Lever573c4e12010-12-14 14:58:11 +00001945int nfs3_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry,
1946 int plus)
Chuck Levere4f93232010-12-14 14:56:30 +00001947{
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)
Chuck Lever573c4e12010-12-14 14:58:11 +00001960 return -EAGAIN;
Chuck Levere4f93232010-12-14 14:56:30 +00001961 entry->eof = 1;
Chuck Lever573c4e12010-12-14 14:58:11 +00001962 return -EBADCOOKIE;
Chuck Levere4f93232010-12-14 14:56:30 +00001963 }
1964
1965 error = decode_fileid3(xdr, &entry->ino);
1966 if (unlikely(error))
Chuck Lever573c4e12010-12-14 14:58:11 +00001967 return error;
Chuck Levere4f93232010-12-14 14:56:30 +00001968
1969 error = decode_inline_filename3(xdr, &entry->name, &entry->len);
1970 if (unlikely(error))
Chuck Lever573c4e12010-12-14 14:58:11 +00001971 return error;
Chuck Levere4f93232010-12-14 14:56:30 +00001972
1973 entry->prev_cookie = entry->cookie;
1974 error = decode_cookie3(xdr, &entry->cookie);
1975 if (unlikely(error))
Chuck Lever573c4e12010-12-14 14:58:11 +00001976 return error;
Chuck Levere4f93232010-12-14 14:56:30 +00001977
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))
Chuck Lever573c4e12010-12-14 14:58:11 +00001984 return error;
Chuck Levere4f93232010-12-14 14:56:30 +00001985 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;
Chuck Lever573c4e12010-12-14 14:58:11 +00001997 return error;
Chuck Levere4f93232010-12-14 14:56:30 +00001998 }
1999 } else
2000 zero_nfs_fh3(entry->fh);
2001 }
2002
Chuck Lever573c4e12010-12-14 14:58:11 +00002003 return 0;
Chuck Levere4f93232010-12-14 14:56:30 +00002004
2005out_overflow:
2006 print_overflow_msg(__func__, xdr);
Chuck Lever573c4e12010-12-14 14:58:11 +00002007 return -EAGAIN;
Chuck Levere4f93232010-12-14 14:56:30 +00002008out_truncated:
2009 dprintk("NFS: directory entry contains invalid file handle\n");
2010 *entry = old;
Chuck Lever573c4e12010-12-14 14:58:11 +00002011 return -EAGAIN;
Chuck Levere4f93232010-12-14 14:56:30 +00002012}
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 */
2043static int decode_dirlist3(struct xdr_stream *xdr)
2044{
Trond Myklebust64bd5772012-06-20 22:35:05 -04002045 return xdr_read_pages(xdr, xdr->buf->page_len);
Chuck Levere4f93232010-12-14 14:56:30 +00002046}
2047
2048static 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);
2061out:
2062 return error;
2063}
2064
Chuck Leverbf269552010-12-14 14:59:29 +00002065static int nfs3_xdr_dec_readdir3res(struct rpc_rqst *req,
2066 struct xdr_stream *xdr,
Chuck Levere4f93232010-12-14 14:56:30 +00002067 struct nfs3_readdirres *result)
2068{
Chuck Levere4f93232010-12-14 14:56:30 +00002069 enum nfs_stat status;
2070 int error;
2071
Chuck Leverbf269552010-12-14 14:59:29 +00002072 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00002073 if (unlikely(error))
2074 goto out;
2075 if (status != NFS3_OK)
2076 goto out_default;
Chuck Leverbf269552010-12-14 14:59:29 +00002077 error = decode_readdir3resok(xdr, result);
Chuck Levere4f93232010-12-14 14:56:30 +00002078out:
2079 return error;
2080out_default:
Chuck Leverbf269552010-12-14 14:59:29 +00002081 error = decode_post_op_attr(xdr, result->dir_attr);
Chuck Levere4f93232010-12-14 14:56:30 +00002082 if (unlikely(error))
2083 goto out;
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04002084 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00002085}
2086
2087/*
Chuck Levere4f93232010-12-14 14:56:30 +00002088 * 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 */
2112static 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;
2128out_overflow:
2129 print_overflow_msg(__func__, xdr);
2130 return -EIO;
2131}
2132
Chuck Leverbf269552010-12-14 14:59:29 +00002133static int nfs3_xdr_dec_fsstat3res(struct rpc_rqst *req,
2134 struct xdr_stream *xdr,
Chuck Levere4f93232010-12-14 14:56:30 +00002135 struct nfs_fsstat *result)
2136{
Chuck Levere4f93232010-12-14 14:56:30 +00002137 enum nfs_stat status;
2138 int error;
2139
Chuck Leverbf269552010-12-14 14:59:29 +00002140 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00002141 if (unlikely(error))
2142 goto out;
Chuck Leverbf269552010-12-14 14:59:29 +00002143 error = decode_post_op_attr(xdr, result->fattr);
Chuck Levere4f93232010-12-14 14:56:30 +00002144 if (unlikely(error))
2145 goto out;
2146 if (status != NFS3_OK)
2147 goto out_status;
Chuck Leverbf269552010-12-14 14:59:29 +00002148 error = decode_fsstat3resok(xdr, result);
Chuck Levere4f93232010-12-14 14:56:30 +00002149out:
2150 return error;
2151out_status:
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04002152 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00002153}
2154
2155/*
Chuck Levere4f93232010-12-14 14:56:30 +00002156 * 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 */
2183static 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);
Chuck Leverf6048702010-12-14 14:57:02 +00002199 xdr_decode_nfstime3(p, &result->time_delta);
Chuck Levere4f93232010-12-14 14:56:30 +00002200
2201 /* ignore properties */
2202 result->lease_time = 0;
2203 return 0;
2204out_overflow:
2205 print_overflow_msg(__func__, xdr);
2206 return -EIO;
2207}
2208
Chuck Leverbf269552010-12-14 14:59:29 +00002209static int nfs3_xdr_dec_fsinfo3res(struct rpc_rqst *req,
2210 struct xdr_stream *xdr,
Chuck Levere4f93232010-12-14 14:56:30 +00002211 struct nfs_fsinfo *result)
2212{
Chuck Levere4f93232010-12-14 14:56:30 +00002213 enum nfs_stat status;
2214 int error;
2215
Chuck Leverbf269552010-12-14 14:59:29 +00002216 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00002217 if (unlikely(error))
2218 goto out;
Chuck Leverbf269552010-12-14 14:59:29 +00002219 error = decode_post_op_attr(xdr, result->fattr);
Chuck Levere4f93232010-12-14 14:56:30 +00002220 if (unlikely(error))
2221 goto out;
2222 if (status != NFS3_OK)
2223 goto out_status;
Chuck Leverbf269552010-12-14 14:59:29 +00002224 error = decode_fsinfo3resok(xdr, result);
Chuck Levere4f93232010-12-14 14:56:30 +00002225out:
2226 return error;
2227out_status:
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04002228 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00002229}
2230
2231/*
Chuck Levere4f93232010-12-14 14:56:30 +00002232 * 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 */
2255static 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;
2267out_overflow:
2268 print_overflow_msg(__func__, xdr);
2269 return -EIO;
2270}
2271
Chuck Leverbf269552010-12-14 14:59:29 +00002272static int nfs3_xdr_dec_pathconf3res(struct rpc_rqst *req,
2273 struct xdr_stream *xdr,
Chuck Levere4f93232010-12-14 14:56:30 +00002274 struct nfs_pathconf *result)
2275{
Chuck Levere4f93232010-12-14 14:56:30 +00002276 enum nfs_stat status;
2277 int error;
2278
Chuck Leverbf269552010-12-14 14:59:29 +00002279 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00002280 if (unlikely(error))
2281 goto out;
Chuck Leverbf269552010-12-14 14:59:29 +00002282 error = decode_post_op_attr(xdr, result->fattr);
Chuck Levere4f93232010-12-14 14:56:30 +00002283 if (unlikely(error))
2284 goto out;
2285 if (status != NFS3_OK)
2286 goto out_status;
Chuck Leverbf269552010-12-14 14:59:29 +00002287 error = decode_pathconf3resok(xdr, result);
Chuck Levere4f93232010-12-14 14:56:30 +00002288out:
2289 return error;
2290out_status:
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04002291 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00002292}
2293
2294/*
Chuck Levere4f93232010-12-14 14:56:30 +00002295 * 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 */
Chuck Leverbf269552010-12-14 14:59:29 +00002313static int nfs3_xdr_dec_commit3res(struct rpc_rqst *req,
2314 struct xdr_stream *xdr,
Fred Isaman0b7c0152012-04-20 14:47:39 -04002315 struct nfs_commitres *result)
Chuck Levere4f93232010-12-14 14:56:30 +00002316{
Chuck Levere4f93232010-12-14 14:56:30 +00002317 enum nfs_stat status;
2318 int error;
2319
Chuck Leverbf269552010-12-14 14:59:29 +00002320 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00002321 if (unlikely(error))
2322 goto out;
Chuck Leverbf269552010-12-14 14:59:29 +00002323 error = decode_wcc_data(xdr, result->fattr);
Chuck Levere4f93232010-12-14 14:56:30 +00002324 if (unlikely(error))
2325 goto out;
2326 if (status != NFS3_OK)
2327 goto out_status;
Trond Myklebust2f2c63b2012-06-08 11:56:09 -04002328 error = decode_writeverf3(xdr, &result->verf->verifier);
Chuck Levere4f93232010-12-14 14:56:30 +00002329out:
2330 return error;
2331out_status:
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04002332 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00002333}
2334
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +00002335#ifdef CONFIG_NFS_V3_ACL
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +00002336
Chuck Levere4f93232010-12-14 14:56:30 +00002337static 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
Trond Myklebust1aecca32012-06-21 11:41:29 -04002355 hdrlen = xdr_stream_pos(xdr);
Chuck Levere4f93232010-12-14 14:56:30 +00002356
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;
2377out:
2378 return error;
2379}
2380
Chuck Leverbf269552010-12-14 14:59:29 +00002381static int nfs3_xdr_dec_getacl3res(struct rpc_rqst *req,
2382 struct xdr_stream *xdr,
Chuck Levere4f93232010-12-14 14:56:30 +00002383 struct nfs3_getaclres *result)
2384{
Chuck Levere4f93232010-12-14 14:56:30 +00002385 enum nfs_stat status;
2386 int error;
2387
Chuck Leverbf269552010-12-14 14:59:29 +00002388 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00002389 if (unlikely(error))
2390 goto out;
2391 if (status != NFS3_OK)
2392 goto out_default;
Chuck Leverbf269552010-12-14 14:59:29 +00002393 error = decode_getacl3resok(xdr, result);
Chuck Levere4f93232010-12-14 14:56:30 +00002394out:
2395 return error;
2396out_default:
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04002397 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00002398}
2399
Chuck Leverbf269552010-12-14 14:59:29 +00002400static int nfs3_xdr_dec_setacl3res(struct rpc_rqst *req,
2401 struct xdr_stream *xdr,
Chuck Levere4f93232010-12-14 14:56:30 +00002402 struct nfs_fattr *result)
2403{
Chuck Levere4f93232010-12-14 14:56:30 +00002404 enum nfs_stat status;
2405 int error;
2406
Chuck Leverbf269552010-12-14 14:59:29 +00002407 error = decode_nfsstat3(xdr, &status);
Chuck Levere4f93232010-12-14 14:56:30 +00002408 if (unlikely(error))
2409 goto out;
2410 if (status != NFS3_OK)
2411 goto out_default;
Chuck Leverbf269552010-12-14 14:59:29 +00002412 error = decode_post_op_attr(xdr, result);
Chuck Levere4f93232010-12-14 14:56:30 +00002413out:
2414 return error;
2415out_default:
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04002416 return nfs3_stat_to_errno(status);
Chuck Levere4f93232010-12-14 14:56:30 +00002417}
2418
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +00002419#endif /* CONFIG_NFS_V3_ACL */
2420
Bryan Schumaker5e7e5a02012-05-10 16:47:18 -04002421
2422/*
2423 * We need to translate between nfs status return values and
2424 * the local errno values which may not be the same.
2425 */
2426static 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 */
2473static 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
Linus Torvalds1da177e2005-04-16 15:20:36 -07002486#define PROC(proc, argtype, restype, timer) \
2487[NFS3PROC_##proc] = { \
2488 .p_proc = NFS3PROC_##proc, \
Chuck Lever9f06c712010-12-14 14:59:18 +00002489 .p_encode = (kxdreproc_t)nfs3_xdr_enc_##argtype##3args, \
Chuck Leverbf269552010-12-14 14:59:29 +00002490 .p_decode = (kxdrdproc_t)nfs3_xdr_dec_##restype##3res, \
Chuck Leverad96b5b2010-12-14 14:56:01 +00002491 .p_arglen = NFS3_##argtype##args_sz, \
Chuck Leverf5fc3c502010-12-14 14:56:42 +00002492 .p_replen = NFS3_##restype##res_sz, \
Chuck Levercc0175c2006-03-20 13:44:22 -05002493 .p_timer = timer, \
2494 .p_statidx = NFS3PROC_##proc, \
2495 .p_name = #proc, \
Linus Torvalds1da177e2005-04-16 15:20:36 -07002496 }
2497
2498struct rpc_procinfo nfs3_procedures[] = {
Chuck Leverf5fc3c502010-12-14 14:56:42 +00002499 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),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002520};
2521
Trond Myklebusta613fa12012-01-20 13:53:56 -05002522const struct rpc_version nfs_version3 = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002523 .number = 3,
Tobias Klausere8c96f82006-03-24 03:15:34 -08002524 .nrprocs = ARRAY_SIZE(nfs3_procedures),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002525 .procs = nfs3_procedures
2526};
2527
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +00002528#ifdef CONFIG_NFS_V3_ACL
2529static struct rpc_procinfo nfs3_acl_procedures[] = {
2530 [ACLPROC3_GETACL] = {
2531 .p_proc = ACLPROC3_GETACL,
Chuck Lever9f06c712010-12-14 14:59:18 +00002532 .p_encode = (kxdreproc_t)nfs3_xdr_enc_getacl3args,
Chuck Leverbf269552010-12-14 14:59:29 +00002533 .p_decode = (kxdrdproc_t)nfs3_xdr_dec_getacl3res,
Chuck Lever2bea90d2007-03-29 16:47:53 -04002534 .p_arglen = ACL3_getaclargs_sz,
2535 .p_replen = ACL3_getaclres_sz,
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +00002536 .p_timer = 1,
Chuck Levercc0175c2006-03-20 13:44:22 -05002537 .p_name = "GETACL",
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +00002538 },
2539 [ACLPROC3_SETACL] = {
2540 .p_proc = ACLPROC3_SETACL,
Chuck Lever9f06c712010-12-14 14:59:18 +00002541 .p_encode = (kxdreproc_t)nfs3_xdr_enc_setacl3args,
Chuck Leverbf269552010-12-14 14:59:29 +00002542 .p_decode = (kxdrdproc_t)nfs3_xdr_dec_setacl3res,
Chuck Lever2bea90d2007-03-29 16:47:53 -04002543 .p_arglen = ACL3_setaclargs_sz,
2544 .p_replen = ACL3_setaclres_sz,
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +00002545 .p_timer = 0,
Chuck Levercc0175c2006-03-20 13:44:22 -05002546 .p_name = "SETACL",
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +00002547 },
2548};
2549
Trond Myklebusta613fa12012-01-20 13:53:56 -05002550const struct rpc_version nfsacl_version3 = {
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +00002551 .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 */