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