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