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