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