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