1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * linux/fs/nfs/nfs2xdr.c |
4 | * |
5 | * XDR functions to encode/decode NFS RPC arguments and results. |
6 | * |
7 | * Copyright (C) 1992, 1993, 1994 Rick Sladkey |
8 | * Copyright (C) 1996 Olaf Kirch |
9 | * 04 Aug 1998 Ion Badulescu <ionut@cs.columbia.edu> |
10 | * FIFO's need special handling in NFSv2 |
11 | */ |
12 | |
13 | #include <linux/param.h> |
14 | #include <linux/time.h> |
15 | #include <linux/mm.h> |
16 | #include <linux/errno.h> |
17 | #include <linux/string.h> |
18 | #include <linux/in.h> |
19 | #include <linux/pagemap.h> |
20 | #include <linux/proc_fs.h> |
21 | #include <linux/sunrpc/clnt.h> |
22 | #include <linux/nfs.h> |
23 | #include <linux/nfs2.h> |
24 | #include <linux/nfs_fs.h> |
25 | #include "nfstrace.h" |
26 | #include "internal.h" |
27 | |
28 | #define NFSDBG_FACILITY NFSDBG_XDR |
29 | |
30 | /* Mapping from NFS error code to "errno" error code. */ |
31 | #define errno_NFSERR_IO EIO |
32 | |
33 | /* |
34 | * Declare the space requirements for NFS arguments and replies as |
35 | * number of 32bit-words |
36 | */ |
37 | #define NFS_pagepad_sz (1) /* Page padding */ |
38 | #define NFS_fhandle_sz (8) |
39 | #define NFS_sattr_sz (8) |
40 | #define NFS_filename_sz (1+(NFS2_MAXNAMLEN>>2)) |
41 | #define NFS_path_sz (1+(NFS2_MAXPATHLEN>>2)) |
42 | #define NFS_fattr_sz (17) |
43 | #define NFS_info_sz (5) |
44 | #define NFS_entry_sz (NFS_filename_sz+3) |
45 | |
46 | #define NFS_diropargs_sz (NFS_fhandle_sz+NFS_filename_sz) |
47 | #define NFS_removeargs_sz (NFS_fhandle_sz+NFS_filename_sz) |
48 | #define NFS_sattrargs_sz (NFS_fhandle_sz+NFS_sattr_sz) |
49 | #define NFS_readlinkargs_sz (NFS_fhandle_sz) |
50 | #define NFS_readargs_sz (NFS_fhandle_sz+3) |
51 | #define NFS_writeargs_sz (NFS_fhandle_sz+4) |
52 | #define NFS_createargs_sz (NFS_diropargs_sz+NFS_sattr_sz) |
53 | #define NFS_renameargs_sz (NFS_diropargs_sz+NFS_diropargs_sz) |
54 | #define NFS_linkargs_sz (NFS_fhandle_sz+NFS_diropargs_sz) |
55 | #define NFS_symlinkargs_sz (NFS_diropargs_sz+1+NFS_sattr_sz) |
56 | #define NFS_readdirargs_sz (NFS_fhandle_sz+2) |
57 | |
58 | #define NFS_attrstat_sz (1+NFS_fattr_sz) |
59 | #define NFS_diropres_sz (1+NFS_fhandle_sz+NFS_fattr_sz) |
60 | #define NFS_readlinkres_sz (2+NFS_pagepad_sz) |
61 | #define NFS_readres_sz (1+NFS_fattr_sz+1+NFS_pagepad_sz) |
62 | #define NFS_writeres_sz (NFS_attrstat_sz) |
63 | #define NFS_stat_sz (1) |
64 | #define NFS_readdirres_sz (1+NFS_pagepad_sz) |
65 | #define NFS_statfsres_sz (1+NFS_info_sz) |
66 | |
67 | static int nfs_stat_to_errno(enum nfs_stat); |
68 | |
69 | /* |
70 | * Encode/decode NFSv2 basic data types |
71 | * |
72 | * Basic NFSv2 data types are defined in section 2.3 of RFC 1094: |
73 | * "NFS: Network File System Protocol Specification". |
74 | * |
75 | * Not all basic data types have their own encoding and decoding |
76 | * functions. For run-time efficiency, some data types are encoded |
77 | * or decoded inline. |
78 | */ |
79 | |
80 | static struct user_namespace *rpc_userns(const struct rpc_clnt *clnt) |
81 | { |
82 | if (clnt && clnt->cl_cred) |
83 | return clnt->cl_cred->user_ns; |
84 | return &init_user_ns; |
85 | } |
86 | |
87 | static struct user_namespace *rpc_rqst_userns(const struct rpc_rqst *rqstp) |
88 | { |
89 | if (rqstp->rq_task) |
90 | return rpc_userns(clnt: rqstp->rq_task->tk_client); |
91 | return &init_user_ns; |
92 | } |
93 | |
94 | /* |
95 | * typedef opaque nfsdata<>; |
96 | */ |
97 | static int decode_nfsdata(struct xdr_stream *xdr, struct nfs_pgio_res *result) |
98 | { |
99 | u32 recvd, count; |
100 | __be32 *p; |
101 | |
102 | p = xdr_inline_decode(xdr, nbytes: 4); |
103 | if (unlikely(!p)) |
104 | return -EIO; |
105 | count = be32_to_cpup(p); |
106 | recvd = xdr_read_pages(xdr, len: count); |
107 | if (unlikely(count > recvd)) |
108 | goto out_cheating; |
109 | out: |
110 | result->eof = 0; /* NFSv2 does not pass EOF flag on the wire. */ |
111 | result->count = count; |
112 | return count; |
113 | out_cheating: |
114 | dprintk("NFS: server cheating in read result: " |
115 | "count %u > recvd %u\n" , count, recvd); |
116 | count = recvd; |
117 | goto out; |
118 | } |
119 | |
120 | /* |
121 | * enum stat { |
122 | * NFS_OK = 0, |
123 | * NFSERR_PERM = 1, |
124 | * NFSERR_NOENT = 2, |
125 | * NFSERR_IO = 5, |
126 | * NFSERR_NXIO = 6, |
127 | * NFSERR_ACCES = 13, |
128 | * NFSERR_EXIST = 17, |
129 | * NFSERR_NODEV = 19, |
130 | * NFSERR_NOTDIR = 20, |
131 | * NFSERR_ISDIR = 21, |
132 | * NFSERR_FBIG = 27, |
133 | * NFSERR_NOSPC = 28, |
134 | * NFSERR_ROFS = 30, |
135 | * NFSERR_NAMETOOLONG = 63, |
136 | * NFSERR_NOTEMPTY = 66, |
137 | * NFSERR_DQUOT = 69, |
138 | * NFSERR_STALE = 70, |
139 | * NFSERR_WFLUSH = 99 |
140 | * }; |
141 | */ |
142 | static int decode_stat(struct xdr_stream *xdr, enum nfs_stat *status) |
143 | { |
144 | __be32 *p; |
145 | |
146 | p = xdr_inline_decode(xdr, nbytes: 4); |
147 | if (unlikely(!p)) |
148 | return -EIO; |
149 | if (unlikely(*p != cpu_to_be32(NFS_OK))) |
150 | goto out_status; |
151 | *status = 0; |
152 | return 0; |
153 | out_status: |
154 | *status = be32_to_cpup(p); |
155 | trace_nfs_xdr_status(xdr, error: (int)*status); |
156 | return 0; |
157 | } |
158 | |
159 | /* |
160 | * 2.3.2. ftype |
161 | * |
162 | * enum ftype { |
163 | * NFNON = 0, |
164 | * NFREG = 1, |
165 | * NFDIR = 2, |
166 | * NFBLK = 3, |
167 | * NFCHR = 4, |
168 | * NFLNK = 5 |
169 | * }; |
170 | * |
171 | */ |
172 | static __be32 *xdr_decode_ftype(__be32 *p, u32 *type) |
173 | { |
174 | *type = be32_to_cpup(p: p++); |
175 | if (unlikely(*type > NF2FIFO)) |
176 | *type = NFBAD; |
177 | return p; |
178 | } |
179 | |
180 | /* |
181 | * 2.3.3. fhandle |
182 | * |
183 | * typedef opaque fhandle[FHSIZE]; |
184 | */ |
185 | static void encode_fhandle(struct xdr_stream *xdr, const struct nfs_fh *fh) |
186 | { |
187 | __be32 *p; |
188 | |
189 | p = xdr_reserve_space(xdr, NFS2_FHSIZE); |
190 | memcpy(p, fh->data, NFS2_FHSIZE); |
191 | } |
192 | |
193 | static int decode_fhandle(struct xdr_stream *xdr, struct nfs_fh *fh) |
194 | { |
195 | __be32 *p; |
196 | |
197 | p = xdr_inline_decode(xdr, NFS2_FHSIZE); |
198 | if (unlikely(!p)) |
199 | return -EIO; |
200 | fh->size = NFS2_FHSIZE; |
201 | memcpy(fh->data, p, NFS2_FHSIZE); |
202 | return 0; |
203 | } |
204 | |
205 | /* |
206 | * 2.3.4. timeval |
207 | * |
208 | * struct timeval { |
209 | * unsigned int seconds; |
210 | * unsigned int useconds; |
211 | * }; |
212 | */ |
213 | static __be32 *xdr_encode_time(__be32 *p, const struct timespec64 *timep) |
214 | { |
215 | *p++ = cpu_to_be32((u32)timep->tv_sec); |
216 | if (timep->tv_nsec != 0) |
217 | *p++ = cpu_to_be32(timep->tv_nsec / NSEC_PER_USEC); |
218 | else |
219 | *p++ = cpu_to_be32(0); |
220 | return p; |
221 | } |
222 | |
223 | /* |
224 | * Passing the invalid value useconds=1000000 is a Sun convention for |
225 | * "set to current server time". It's needed to make permissions checks |
226 | * for the "touch" program across v2 mounts to Solaris and Irix servers |
227 | * work correctly. See description of sattr in section 6.1 of "NFS |
228 | * Illustrated" by Brent Callaghan, Addison-Wesley, ISBN 0-201-32750-5. |
229 | */ |
230 | static __be32 *xdr_encode_current_server_time(__be32 *p, |
231 | const struct timespec64 *timep) |
232 | { |
233 | *p++ = cpu_to_be32(timep->tv_sec); |
234 | *p++ = cpu_to_be32(1000000); |
235 | return p; |
236 | } |
237 | |
238 | static __be32 *xdr_decode_time(__be32 *p, struct timespec64 *timep) |
239 | { |
240 | timep->tv_sec = be32_to_cpup(p: p++); |
241 | timep->tv_nsec = be32_to_cpup(p: p++) * NSEC_PER_USEC; |
242 | return p; |
243 | } |
244 | |
245 | /* |
246 | * 2.3.5. fattr |
247 | * |
248 | * struct fattr { |
249 | * ftype type; |
250 | * unsigned int mode; |
251 | * unsigned int nlink; |
252 | * unsigned int uid; |
253 | * unsigned int gid; |
254 | * unsigned int size; |
255 | * unsigned int blocksize; |
256 | * unsigned int rdev; |
257 | * unsigned int blocks; |
258 | * unsigned int fsid; |
259 | * unsigned int fileid; |
260 | * timeval atime; |
261 | * timeval mtime; |
262 | * timeval ctime; |
263 | * }; |
264 | * |
265 | */ |
266 | static int decode_fattr(struct xdr_stream *xdr, struct nfs_fattr *fattr, |
267 | struct user_namespace *userns) |
268 | { |
269 | u32 rdev, type; |
270 | __be32 *p; |
271 | |
272 | p = xdr_inline_decode(xdr, NFS_fattr_sz << 2); |
273 | if (unlikely(!p)) |
274 | return -EIO; |
275 | |
276 | fattr->valid |= NFS_ATTR_FATTR_V2; |
277 | |
278 | p = xdr_decode_ftype(p, type: &type); |
279 | |
280 | fattr->mode = be32_to_cpup(p: p++); |
281 | fattr->nlink = be32_to_cpup(p: p++); |
282 | fattr->uid = make_kuid(from: userns, be32_to_cpup(p: p++)); |
283 | if (!uid_valid(uid: fattr->uid)) |
284 | goto out_uid; |
285 | fattr->gid = make_kgid(from: userns, be32_to_cpup(p: p++)); |
286 | if (!gid_valid(gid: fattr->gid)) |
287 | goto out_gid; |
288 | |
289 | fattr->size = be32_to_cpup(p: p++); |
290 | fattr->du.nfs2.blocksize = be32_to_cpup(p: p++); |
291 | |
292 | rdev = be32_to_cpup(p: p++); |
293 | fattr->rdev = new_decode_dev(dev: rdev); |
294 | if (type == (u32)NFCHR && rdev == (u32)NFS2_FIFO_DEV) { |
295 | fattr->mode = (fattr->mode & ~S_IFMT) | S_IFIFO; |
296 | fattr->rdev = 0; |
297 | } |
298 | |
299 | fattr->du.nfs2.blocks = be32_to_cpup(p: p++); |
300 | fattr->fsid.major = be32_to_cpup(p: p++); |
301 | fattr->fsid.minor = 0; |
302 | fattr->fileid = be32_to_cpup(p: p++); |
303 | |
304 | p = xdr_decode_time(p, timep: &fattr->atime); |
305 | p = xdr_decode_time(p, timep: &fattr->mtime); |
306 | xdr_decode_time(p, timep: &fattr->ctime); |
307 | fattr->change_attr = nfs_timespec_to_change_attr(ts: &fattr->ctime); |
308 | |
309 | return 0; |
310 | out_uid: |
311 | dprintk("NFS: returned invalid uid\n" ); |
312 | return -EINVAL; |
313 | out_gid: |
314 | dprintk("NFS: returned invalid gid\n" ); |
315 | return -EINVAL; |
316 | } |
317 | |
318 | /* |
319 | * 2.3.6. sattr |
320 | * |
321 | * struct sattr { |
322 | * unsigned int mode; |
323 | * unsigned int uid; |
324 | * unsigned int gid; |
325 | * unsigned int size; |
326 | * timeval atime; |
327 | * timeval mtime; |
328 | * }; |
329 | */ |
330 | |
331 | #define NFS2_SATTR_NOT_SET (0xffffffff) |
332 | |
333 | static __be32 *xdr_time_not_set(__be32 *p) |
334 | { |
335 | *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); |
336 | *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); |
337 | return p; |
338 | } |
339 | |
340 | static void encode_sattr(struct xdr_stream *xdr, const struct iattr *attr, |
341 | struct user_namespace *userns) |
342 | { |
343 | __be32 *p; |
344 | |
345 | p = xdr_reserve_space(xdr, NFS_sattr_sz << 2); |
346 | |
347 | if (attr->ia_valid & ATTR_MODE) |
348 | *p++ = cpu_to_be32(attr->ia_mode); |
349 | else |
350 | *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); |
351 | if (attr->ia_valid & ATTR_UID) |
352 | *p++ = cpu_to_be32(from_kuid_munged(userns, attr->ia_uid)); |
353 | else |
354 | *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); |
355 | if (attr->ia_valid & ATTR_GID) |
356 | *p++ = cpu_to_be32(from_kgid_munged(userns, attr->ia_gid)); |
357 | else |
358 | *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); |
359 | if (attr->ia_valid & ATTR_SIZE) |
360 | *p++ = cpu_to_be32((u32)attr->ia_size); |
361 | else |
362 | *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); |
363 | |
364 | if (attr->ia_valid & ATTR_ATIME_SET) |
365 | p = xdr_encode_time(p, timep: &attr->ia_atime); |
366 | else if (attr->ia_valid & ATTR_ATIME) |
367 | p = xdr_encode_current_server_time(p, timep: &attr->ia_atime); |
368 | else |
369 | p = xdr_time_not_set(p); |
370 | if (attr->ia_valid & ATTR_MTIME_SET) |
371 | xdr_encode_time(p, timep: &attr->ia_mtime); |
372 | else if (attr->ia_valid & ATTR_MTIME) |
373 | xdr_encode_current_server_time(p, timep: &attr->ia_mtime); |
374 | else |
375 | xdr_time_not_set(p); |
376 | } |
377 | |
378 | /* |
379 | * 2.3.7. filename |
380 | * |
381 | * typedef string filename<MAXNAMLEN>; |
382 | */ |
383 | static void encode_filename(struct xdr_stream *xdr, |
384 | const char *name, u32 length) |
385 | { |
386 | __be32 *p; |
387 | |
388 | WARN_ON_ONCE(length > NFS2_MAXNAMLEN); |
389 | p = xdr_reserve_space(xdr, nbytes: 4 + length); |
390 | xdr_encode_opaque(p, ptr: name, len: length); |
391 | } |
392 | |
393 | static int decode_filename_inline(struct xdr_stream *xdr, |
394 | const char **name, u32 *length) |
395 | { |
396 | __be32 *p; |
397 | u32 count; |
398 | |
399 | p = xdr_inline_decode(xdr, nbytes: 4); |
400 | if (unlikely(!p)) |
401 | return -EIO; |
402 | count = be32_to_cpup(p); |
403 | if (count > NFS3_MAXNAMLEN) |
404 | goto out_nametoolong; |
405 | p = xdr_inline_decode(xdr, nbytes: count); |
406 | if (unlikely(!p)) |
407 | return -EIO; |
408 | *name = (const char *)p; |
409 | *length = count; |
410 | return 0; |
411 | out_nametoolong: |
412 | dprintk("NFS: returned filename too long: %u\n" , count); |
413 | return -ENAMETOOLONG; |
414 | } |
415 | |
416 | /* |
417 | * 2.3.8. path |
418 | * |
419 | * typedef string path<MAXPATHLEN>; |
420 | */ |
421 | static void encode_path(struct xdr_stream *xdr, struct page **pages, u32 length) |
422 | { |
423 | __be32 *p; |
424 | |
425 | p = xdr_reserve_space(xdr, nbytes: 4); |
426 | *p = cpu_to_be32(length); |
427 | xdr_write_pages(xdr, pages, base: 0, len: length); |
428 | } |
429 | |
430 | static int decode_path(struct xdr_stream *xdr) |
431 | { |
432 | u32 length, recvd; |
433 | __be32 *p; |
434 | |
435 | p = xdr_inline_decode(xdr, nbytes: 4); |
436 | if (unlikely(!p)) |
437 | return -EIO; |
438 | length = be32_to_cpup(p); |
439 | if (unlikely(length >= xdr->buf->page_len || length > NFS_MAXPATHLEN)) |
440 | goto out_size; |
441 | recvd = xdr_read_pages(xdr, len: length); |
442 | if (unlikely(length > recvd)) |
443 | goto out_cheating; |
444 | xdr_terminate_string(xdr->buf, length); |
445 | return 0; |
446 | out_size: |
447 | dprintk("NFS: returned pathname too long: %u\n" , length); |
448 | return -ENAMETOOLONG; |
449 | out_cheating: |
450 | dprintk("NFS: server cheating in pathname result: " |
451 | "length %u > received %u\n" , length, recvd); |
452 | return -EIO; |
453 | } |
454 | |
455 | /* |
456 | * 2.3.9. attrstat |
457 | * |
458 | * union attrstat switch (stat status) { |
459 | * case NFS_OK: |
460 | * fattr attributes; |
461 | * default: |
462 | * void; |
463 | * }; |
464 | */ |
465 | static int decode_attrstat(struct xdr_stream *xdr, struct nfs_fattr *result, |
466 | __u32 *op_status, |
467 | struct user_namespace *userns) |
468 | { |
469 | enum nfs_stat status; |
470 | int error; |
471 | |
472 | error = decode_stat(xdr, status: &status); |
473 | if (unlikely(error)) |
474 | goto out; |
475 | if (op_status) |
476 | *op_status = status; |
477 | if (status != NFS_OK) |
478 | goto out_default; |
479 | error = decode_fattr(xdr, fattr: result, userns); |
480 | out: |
481 | return error; |
482 | out_default: |
483 | return nfs_stat_to_errno(status); |
484 | } |
485 | |
486 | /* |
487 | * 2.3.10. diropargs |
488 | * |
489 | * struct diropargs { |
490 | * fhandle dir; |
491 | * filename name; |
492 | * }; |
493 | */ |
494 | static void encode_diropargs(struct xdr_stream *xdr, const struct nfs_fh *fh, |
495 | const char *name, u32 length) |
496 | { |
497 | encode_fhandle(xdr, fh); |
498 | encode_filename(xdr, name, length); |
499 | } |
500 | |
501 | /* |
502 | * 2.3.11. diropres |
503 | * |
504 | * union diropres switch (stat status) { |
505 | * case NFS_OK: |
506 | * struct { |
507 | * fhandle file; |
508 | * fattr attributes; |
509 | * } diropok; |
510 | * default: |
511 | * void; |
512 | * }; |
513 | */ |
514 | static int decode_diropok(struct xdr_stream *xdr, struct nfs_diropok *result, |
515 | struct user_namespace *userns) |
516 | { |
517 | int error; |
518 | |
519 | error = decode_fhandle(xdr, fh: result->fh); |
520 | if (unlikely(error)) |
521 | goto out; |
522 | error = decode_fattr(xdr, fattr: result->fattr, userns); |
523 | out: |
524 | return error; |
525 | } |
526 | |
527 | static int decode_diropres(struct xdr_stream *xdr, struct nfs_diropok *result, |
528 | struct user_namespace *userns) |
529 | { |
530 | enum nfs_stat status; |
531 | int error; |
532 | |
533 | error = decode_stat(xdr, status: &status); |
534 | if (unlikely(error)) |
535 | goto out; |
536 | if (status != NFS_OK) |
537 | goto out_default; |
538 | error = decode_diropok(xdr, result, userns); |
539 | out: |
540 | return error; |
541 | out_default: |
542 | return nfs_stat_to_errno(status); |
543 | } |
544 | |
545 | |
546 | /* |
547 | * NFSv2 XDR encode functions |
548 | * |
549 | * NFSv2 argument types are defined in section 2.2 of RFC 1094: |
550 | * "NFS: Network File System Protocol Specification". |
551 | */ |
552 | |
553 | static void nfs2_xdr_enc_fhandle(struct rpc_rqst *req, |
554 | struct xdr_stream *xdr, |
555 | const void *data) |
556 | { |
557 | const struct nfs_fh *fh = data; |
558 | |
559 | encode_fhandle(xdr, fh); |
560 | } |
561 | |
562 | /* |
563 | * 2.2.3. sattrargs |
564 | * |
565 | * struct sattrargs { |
566 | * fhandle file; |
567 | * sattr attributes; |
568 | * }; |
569 | */ |
570 | static void nfs2_xdr_enc_sattrargs(struct rpc_rqst *req, |
571 | struct xdr_stream *xdr, |
572 | const void *data) |
573 | { |
574 | const struct nfs_sattrargs *args = data; |
575 | |
576 | encode_fhandle(xdr, fh: args->fh); |
577 | encode_sattr(xdr, attr: args->sattr, userns: rpc_rqst_userns(rqstp: req)); |
578 | } |
579 | |
580 | static void nfs2_xdr_enc_diropargs(struct rpc_rqst *req, |
581 | struct xdr_stream *xdr, |
582 | const void *data) |
583 | { |
584 | const struct nfs_diropargs *args = data; |
585 | |
586 | encode_diropargs(xdr, fh: args->fh, name: args->name, length: args->len); |
587 | } |
588 | |
589 | static void nfs2_xdr_enc_readlinkargs(struct rpc_rqst *req, |
590 | struct xdr_stream *xdr, |
591 | const void *data) |
592 | { |
593 | const struct nfs_readlinkargs *args = data; |
594 | |
595 | encode_fhandle(xdr, fh: args->fh); |
596 | rpc_prepare_reply_pages(req, pages: args->pages, base: args->pgbase, len: args->pglen, |
597 | NFS_readlinkres_sz - NFS_pagepad_sz); |
598 | } |
599 | |
600 | /* |
601 | * 2.2.7. readargs |
602 | * |
603 | * struct readargs { |
604 | * fhandle file; |
605 | * unsigned offset; |
606 | * unsigned count; |
607 | * unsigned totalcount; |
608 | * }; |
609 | */ |
610 | static void encode_readargs(struct xdr_stream *xdr, |
611 | const struct nfs_pgio_args *args) |
612 | { |
613 | u32 offset = args->offset; |
614 | u32 count = args->count; |
615 | __be32 *p; |
616 | |
617 | encode_fhandle(xdr, fh: args->fh); |
618 | |
619 | p = xdr_reserve_space(xdr, nbytes: 4 + 4 + 4); |
620 | *p++ = cpu_to_be32(offset); |
621 | *p++ = cpu_to_be32(count); |
622 | *p = cpu_to_be32(count); |
623 | } |
624 | |
625 | static void nfs2_xdr_enc_readargs(struct rpc_rqst *req, |
626 | struct xdr_stream *xdr, |
627 | const void *data) |
628 | { |
629 | const struct nfs_pgio_args *args = data; |
630 | |
631 | encode_readargs(xdr, args); |
632 | rpc_prepare_reply_pages(req, pages: args->pages, base: args->pgbase, len: args->count, |
633 | NFS_readres_sz - NFS_pagepad_sz); |
634 | req->rq_rcv_buf.flags |= XDRBUF_READ; |
635 | } |
636 | |
637 | /* |
638 | * 2.2.9. writeargs |
639 | * |
640 | * struct writeargs { |
641 | * fhandle file; |
642 | * unsigned beginoffset; |
643 | * unsigned offset; |
644 | * unsigned totalcount; |
645 | * nfsdata data; |
646 | * }; |
647 | */ |
648 | static void encode_writeargs(struct xdr_stream *xdr, |
649 | const struct nfs_pgio_args *args) |
650 | { |
651 | u32 offset = args->offset; |
652 | u32 count = args->count; |
653 | __be32 *p; |
654 | |
655 | encode_fhandle(xdr, fh: args->fh); |
656 | |
657 | p = xdr_reserve_space(xdr, nbytes: 4 + 4 + 4 + 4); |
658 | *p++ = cpu_to_be32(offset); |
659 | *p++ = cpu_to_be32(offset); |
660 | *p++ = cpu_to_be32(count); |
661 | |
662 | /* nfsdata */ |
663 | *p = cpu_to_be32(count); |
664 | xdr_write_pages(xdr, pages: args->pages, base: args->pgbase, len: count); |
665 | } |
666 | |
667 | static void nfs2_xdr_enc_writeargs(struct rpc_rqst *req, |
668 | struct xdr_stream *xdr, |
669 | const void *data) |
670 | { |
671 | const struct nfs_pgio_args *args = data; |
672 | |
673 | encode_writeargs(xdr, args); |
674 | xdr->buf->flags |= XDRBUF_WRITE; |
675 | } |
676 | |
677 | /* |
678 | * 2.2.10. createargs |
679 | * |
680 | * struct createargs { |
681 | * diropargs where; |
682 | * sattr attributes; |
683 | * }; |
684 | */ |
685 | static void nfs2_xdr_enc_createargs(struct rpc_rqst *req, |
686 | struct xdr_stream *xdr, |
687 | const void *data) |
688 | { |
689 | const struct nfs_createargs *args = data; |
690 | |
691 | encode_diropargs(xdr, fh: args->fh, name: args->name, length: args->len); |
692 | encode_sattr(xdr, attr: args->sattr, userns: rpc_rqst_userns(rqstp: req)); |
693 | } |
694 | |
695 | static void nfs2_xdr_enc_removeargs(struct rpc_rqst *req, |
696 | struct xdr_stream *xdr, |
697 | const void *data) |
698 | { |
699 | const struct nfs_removeargs *args = data; |
700 | |
701 | encode_diropargs(xdr, fh: args->fh, name: args->name.name, length: args->name.len); |
702 | } |
703 | |
704 | /* |
705 | * 2.2.12. renameargs |
706 | * |
707 | * struct renameargs { |
708 | * diropargs from; |
709 | * diropargs to; |
710 | * }; |
711 | */ |
712 | static void nfs2_xdr_enc_renameargs(struct rpc_rqst *req, |
713 | struct xdr_stream *xdr, |
714 | const void *data) |
715 | { |
716 | const struct nfs_renameargs *args = data; |
717 | const struct qstr *old = args->old_name; |
718 | const struct qstr *new = args->new_name; |
719 | |
720 | encode_diropargs(xdr, fh: args->old_dir, name: old->name, length: old->len); |
721 | encode_diropargs(xdr, fh: args->new_dir, name: new->name, length: new->len); |
722 | } |
723 | |
724 | /* |
725 | * 2.2.13. linkargs |
726 | * |
727 | * struct linkargs { |
728 | * fhandle from; |
729 | * diropargs to; |
730 | * }; |
731 | */ |
732 | static void nfs2_xdr_enc_linkargs(struct rpc_rqst *req, |
733 | struct xdr_stream *xdr, |
734 | const void *data) |
735 | { |
736 | const struct nfs_linkargs *args = data; |
737 | |
738 | encode_fhandle(xdr, fh: args->fromfh); |
739 | encode_diropargs(xdr, fh: args->tofh, name: args->toname, length: args->tolen); |
740 | } |
741 | |
742 | /* |
743 | * 2.2.14. symlinkargs |
744 | * |
745 | * struct symlinkargs { |
746 | * diropargs from; |
747 | * path to; |
748 | * sattr attributes; |
749 | * }; |
750 | */ |
751 | static void nfs2_xdr_enc_symlinkargs(struct rpc_rqst *req, |
752 | struct xdr_stream *xdr, |
753 | const void *data) |
754 | { |
755 | const struct nfs_symlinkargs *args = data; |
756 | |
757 | encode_diropargs(xdr, fh: args->fromfh, name: args->fromname, length: args->fromlen); |
758 | encode_path(xdr, pages: args->pages, length: args->pathlen); |
759 | encode_sattr(xdr, attr: args->sattr, userns: rpc_rqst_userns(rqstp: req)); |
760 | } |
761 | |
762 | /* |
763 | * 2.2.17. readdirargs |
764 | * |
765 | * struct readdirargs { |
766 | * fhandle dir; |
767 | * nfscookie cookie; |
768 | * unsigned count; |
769 | * }; |
770 | */ |
771 | static void encode_readdirargs(struct xdr_stream *xdr, |
772 | const struct nfs_readdirargs *args) |
773 | { |
774 | __be32 *p; |
775 | |
776 | encode_fhandle(xdr, fh: args->fh); |
777 | |
778 | p = xdr_reserve_space(xdr, nbytes: 4 + 4); |
779 | *p++ = cpu_to_be32(args->cookie); |
780 | *p = cpu_to_be32(args->count); |
781 | } |
782 | |
783 | static void nfs2_xdr_enc_readdirargs(struct rpc_rqst *req, |
784 | struct xdr_stream *xdr, |
785 | const void *data) |
786 | { |
787 | const struct nfs_readdirargs *args = data; |
788 | |
789 | encode_readdirargs(xdr, args); |
790 | rpc_prepare_reply_pages(req, pages: args->pages, base: 0, len: args->count, |
791 | NFS_readdirres_sz - NFS_pagepad_sz); |
792 | } |
793 | |
794 | /* |
795 | * NFSv2 XDR decode functions |
796 | * |
797 | * NFSv2 result types are defined in section 2.2 of RFC 1094: |
798 | * "NFS: Network File System Protocol Specification". |
799 | */ |
800 | |
801 | static int nfs2_xdr_dec_stat(struct rpc_rqst *req, struct xdr_stream *xdr, |
802 | void *__unused) |
803 | { |
804 | enum nfs_stat status; |
805 | int error; |
806 | |
807 | error = decode_stat(xdr, status: &status); |
808 | if (unlikely(error)) |
809 | goto out; |
810 | if (status != NFS_OK) |
811 | goto out_default; |
812 | out: |
813 | return error; |
814 | out_default: |
815 | return nfs_stat_to_errno(status); |
816 | } |
817 | |
818 | static int nfs2_xdr_dec_attrstat(struct rpc_rqst *req, struct xdr_stream *xdr, |
819 | void *result) |
820 | { |
821 | return decode_attrstat(xdr, result, NULL, userns: rpc_rqst_userns(rqstp: req)); |
822 | } |
823 | |
824 | static int nfs2_xdr_dec_diropres(struct rpc_rqst *req, struct xdr_stream *xdr, |
825 | void *result) |
826 | { |
827 | return decode_diropres(xdr, result, userns: rpc_rqst_userns(rqstp: req)); |
828 | } |
829 | |
830 | /* |
831 | * 2.2.6. readlinkres |
832 | * |
833 | * union readlinkres switch (stat status) { |
834 | * case NFS_OK: |
835 | * path data; |
836 | * default: |
837 | * void; |
838 | * }; |
839 | */ |
840 | static int nfs2_xdr_dec_readlinkres(struct rpc_rqst *req, |
841 | struct xdr_stream *xdr, void *__unused) |
842 | { |
843 | enum nfs_stat status; |
844 | int error; |
845 | |
846 | error = decode_stat(xdr, status: &status); |
847 | if (unlikely(error)) |
848 | goto out; |
849 | if (status != NFS_OK) |
850 | goto out_default; |
851 | error = decode_path(xdr); |
852 | out: |
853 | return error; |
854 | out_default: |
855 | return nfs_stat_to_errno(status); |
856 | } |
857 | |
858 | /* |
859 | * 2.2.7. readres |
860 | * |
861 | * union readres switch (stat status) { |
862 | * case NFS_OK: |
863 | * fattr attributes; |
864 | * nfsdata data; |
865 | * default: |
866 | * void; |
867 | * }; |
868 | */ |
869 | static int nfs2_xdr_dec_readres(struct rpc_rqst *req, struct xdr_stream *xdr, |
870 | void *data) |
871 | { |
872 | struct nfs_pgio_res *result = data; |
873 | enum nfs_stat status; |
874 | int error; |
875 | |
876 | error = decode_stat(xdr, status: &status); |
877 | if (unlikely(error)) |
878 | goto out; |
879 | result->op_status = status; |
880 | if (status != NFS_OK) |
881 | goto out_default; |
882 | error = decode_fattr(xdr, fattr: result->fattr, userns: rpc_rqst_userns(rqstp: req)); |
883 | if (unlikely(error)) |
884 | goto out; |
885 | error = decode_nfsdata(xdr, result); |
886 | out: |
887 | return error; |
888 | out_default: |
889 | return nfs_stat_to_errno(status); |
890 | } |
891 | |
892 | static int nfs2_xdr_dec_writeres(struct rpc_rqst *req, struct xdr_stream *xdr, |
893 | void *data) |
894 | { |
895 | struct nfs_pgio_res *result = data; |
896 | |
897 | /* All NFSv2 writes are "file sync" writes */ |
898 | result->verf->committed = NFS_FILE_SYNC; |
899 | return decode_attrstat(xdr, result: result->fattr, op_status: &result->op_status, |
900 | userns: rpc_rqst_userns(rqstp: req)); |
901 | } |
902 | |
903 | /** |
904 | * nfs2_decode_dirent - Decode a single NFSv2 directory entry stored in |
905 | * the local page cache. |
906 | * @xdr: XDR stream where entry resides |
907 | * @entry: buffer to fill in with entry data |
908 | * @plus: boolean indicating whether this should be a readdirplus entry |
909 | * |
910 | * Returns zero if successful, otherwise a negative errno value is |
911 | * returned. |
912 | * |
913 | * This function is not invoked during READDIR reply decoding, but |
914 | * rather whenever an application invokes the getdents(2) system call |
915 | * on a directory already in our cache. |
916 | * |
917 | * 2.2.17. entry |
918 | * |
919 | * struct entry { |
920 | * unsigned fileid; |
921 | * filename name; |
922 | * nfscookie cookie; |
923 | * entry *nextentry; |
924 | * }; |
925 | */ |
926 | int nfs2_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry, |
927 | bool plus) |
928 | { |
929 | __be32 *p; |
930 | int error; |
931 | |
932 | p = xdr_inline_decode(xdr, nbytes: 4); |
933 | if (unlikely(!p)) |
934 | return -EAGAIN; |
935 | if (*p++ == xdr_zero) { |
936 | p = xdr_inline_decode(xdr, nbytes: 4); |
937 | if (unlikely(!p)) |
938 | return -EAGAIN; |
939 | if (*p++ == xdr_zero) |
940 | return -EAGAIN; |
941 | entry->eof = 1; |
942 | return -EBADCOOKIE; |
943 | } |
944 | |
945 | p = xdr_inline_decode(xdr, nbytes: 4); |
946 | if (unlikely(!p)) |
947 | return -EAGAIN; |
948 | entry->ino = be32_to_cpup(p); |
949 | |
950 | error = decode_filename_inline(xdr, name: &entry->name, length: &entry->len); |
951 | if (unlikely(error)) |
952 | return error == -ENAMETOOLONG ? -ENAMETOOLONG : -EAGAIN; |
953 | |
954 | /* |
955 | * The type (size and byte order) of nfscookie isn't defined in |
956 | * RFC 1094. This implementation assumes that it's an XDR uint32. |
957 | */ |
958 | p = xdr_inline_decode(xdr, nbytes: 4); |
959 | if (unlikely(!p)) |
960 | return -EAGAIN; |
961 | entry->cookie = be32_to_cpup(p); |
962 | |
963 | entry->d_type = DT_UNKNOWN; |
964 | |
965 | return 0; |
966 | } |
967 | |
968 | /* |
969 | * 2.2.17. readdirres |
970 | * |
971 | * union readdirres switch (stat status) { |
972 | * case NFS_OK: |
973 | * struct { |
974 | * entry *entries; |
975 | * bool eof; |
976 | * } readdirok; |
977 | * default: |
978 | * void; |
979 | * }; |
980 | * |
981 | * Read the directory contents into the page cache, but don't |
982 | * touch them. The actual decoding is done by nfs2_decode_dirent() |
983 | * during subsequent nfs_readdir() calls. |
984 | */ |
985 | static int decode_readdirok(struct xdr_stream *xdr) |
986 | { |
987 | return xdr_read_pages(xdr, len: xdr->buf->page_len); |
988 | } |
989 | |
990 | static int nfs2_xdr_dec_readdirres(struct rpc_rqst *req, |
991 | struct xdr_stream *xdr, void *__unused) |
992 | { |
993 | enum nfs_stat status; |
994 | int error; |
995 | |
996 | error = decode_stat(xdr, status: &status); |
997 | if (unlikely(error)) |
998 | goto out; |
999 | if (status != NFS_OK) |
1000 | goto out_default; |
1001 | error = decode_readdirok(xdr); |
1002 | out: |
1003 | return error; |
1004 | out_default: |
1005 | return nfs_stat_to_errno(status); |
1006 | } |
1007 | |
1008 | /* |
1009 | * 2.2.18. statfsres |
1010 | * |
1011 | * union statfsres (stat status) { |
1012 | * case NFS_OK: |
1013 | * struct { |
1014 | * unsigned tsize; |
1015 | * unsigned bsize; |
1016 | * unsigned blocks; |
1017 | * unsigned bfree; |
1018 | * unsigned bavail; |
1019 | * } info; |
1020 | * default: |
1021 | * void; |
1022 | * }; |
1023 | */ |
1024 | static int decode_info(struct xdr_stream *xdr, struct nfs2_fsstat *result) |
1025 | { |
1026 | __be32 *p; |
1027 | |
1028 | p = xdr_inline_decode(xdr, NFS_info_sz << 2); |
1029 | if (unlikely(!p)) |
1030 | return -EIO; |
1031 | result->tsize = be32_to_cpup(p: p++); |
1032 | result->bsize = be32_to_cpup(p: p++); |
1033 | result->blocks = be32_to_cpup(p: p++); |
1034 | result->bfree = be32_to_cpup(p: p++); |
1035 | result->bavail = be32_to_cpup(p); |
1036 | return 0; |
1037 | } |
1038 | |
1039 | static int nfs2_xdr_dec_statfsres(struct rpc_rqst *req, struct xdr_stream *xdr, |
1040 | void *result) |
1041 | { |
1042 | enum nfs_stat status; |
1043 | int error; |
1044 | |
1045 | error = decode_stat(xdr, status: &status); |
1046 | if (unlikely(error)) |
1047 | goto out; |
1048 | if (status != NFS_OK) |
1049 | goto out_default; |
1050 | error = decode_info(xdr, result); |
1051 | out: |
1052 | return error; |
1053 | out_default: |
1054 | return nfs_stat_to_errno(status); |
1055 | } |
1056 | |
1057 | |
1058 | /* |
1059 | * We need to translate between nfs status return values and |
1060 | * the local errno values which may not be the same. |
1061 | */ |
1062 | static const struct { |
1063 | int stat; |
1064 | int errno; |
1065 | } nfs_errtbl[] = { |
1066 | { NFS_OK, 0 }, |
1067 | { NFSERR_PERM, -EPERM }, |
1068 | { NFSERR_NOENT, -ENOENT }, |
1069 | { NFSERR_IO, -errno_NFSERR_IO}, |
1070 | { NFSERR_NXIO, -ENXIO }, |
1071 | /* { NFSERR_EAGAIN, -EAGAIN }, */ |
1072 | { NFSERR_ACCES, -EACCES }, |
1073 | { NFSERR_EXIST, -EEXIST }, |
1074 | { NFSERR_XDEV, -EXDEV }, |
1075 | { NFSERR_NODEV, -ENODEV }, |
1076 | { NFSERR_NOTDIR, -ENOTDIR }, |
1077 | { NFSERR_ISDIR, -EISDIR }, |
1078 | { NFSERR_INVAL, -EINVAL }, |
1079 | { NFSERR_FBIG, -EFBIG }, |
1080 | { NFSERR_NOSPC, -ENOSPC }, |
1081 | { NFSERR_ROFS, -EROFS }, |
1082 | { NFSERR_MLINK, -EMLINK }, |
1083 | { NFSERR_NAMETOOLONG, -ENAMETOOLONG }, |
1084 | { NFSERR_NOTEMPTY, -ENOTEMPTY }, |
1085 | { NFSERR_DQUOT, -EDQUOT }, |
1086 | { NFSERR_STALE, -ESTALE }, |
1087 | { NFSERR_REMOTE, -EREMOTE }, |
1088 | #ifdef EWFLUSH |
1089 | { NFSERR_WFLUSH, -EWFLUSH }, |
1090 | #endif |
1091 | { NFSERR_BADHANDLE, -EBADHANDLE }, |
1092 | { NFSERR_NOT_SYNC, -ENOTSYNC }, |
1093 | { NFSERR_BAD_COOKIE, -EBADCOOKIE }, |
1094 | { NFSERR_NOTSUPP, -ENOTSUPP }, |
1095 | { NFSERR_TOOSMALL, -ETOOSMALL }, |
1096 | { NFSERR_SERVERFAULT, -EREMOTEIO }, |
1097 | { NFSERR_BADTYPE, -EBADTYPE }, |
1098 | { NFSERR_JUKEBOX, -EJUKEBOX }, |
1099 | { -1, -EIO } |
1100 | }; |
1101 | |
1102 | /** |
1103 | * nfs_stat_to_errno - convert an NFS status code to a local errno |
1104 | * @status: NFS status code to convert |
1105 | * |
1106 | * Returns a local errno value, or -EIO if the NFS status code is |
1107 | * not recognized. This function is used jointly by NFSv2 and NFSv3. |
1108 | */ |
1109 | static int nfs_stat_to_errno(enum nfs_stat status) |
1110 | { |
1111 | int i; |
1112 | |
1113 | for (i = 0; nfs_errtbl[i].stat != -1; i++) { |
1114 | if (nfs_errtbl[i].stat == (int)status) |
1115 | return nfs_errtbl[i].errno; |
1116 | } |
1117 | dprintk("NFS: Unrecognized nfs status value: %u\n" , status); |
1118 | return nfs_errtbl[i].errno; |
1119 | } |
1120 | |
1121 | #define PROC(proc, argtype, restype, timer) \ |
1122 | [NFSPROC_##proc] = { \ |
1123 | .p_proc = NFSPROC_##proc, \ |
1124 | .p_encode = nfs2_xdr_enc_##argtype, \ |
1125 | .p_decode = nfs2_xdr_dec_##restype, \ |
1126 | .p_arglen = NFS_##argtype##_sz, \ |
1127 | .p_replen = NFS_##restype##_sz, \ |
1128 | .p_timer = timer, \ |
1129 | .p_statidx = NFSPROC_##proc, \ |
1130 | .p_name = #proc, \ |
1131 | } |
1132 | const struct rpc_procinfo nfs_procedures[] = { |
1133 | PROC(GETATTR, fhandle, attrstat, 1), |
1134 | PROC(SETATTR, sattrargs, attrstat, 0), |
1135 | PROC(LOOKUP, diropargs, diropres, 2), |
1136 | PROC(READLINK, readlinkargs, readlinkres, 3), |
1137 | PROC(READ, readargs, readres, 3), |
1138 | PROC(WRITE, writeargs, writeres, 4), |
1139 | PROC(CREATE, createargs, diropres, 0), |
1140 | PROC(REMOVE, removeargs, stat, 0), |
1141 | PROC(RENAME, renameargs, stat, 0), |
1142 | PROC(LINK, linkargs, stat, 0), |
1143 | PROC(SYMLINK, symlinkargs, stat, 0), |
1144 | PROC(MKDIR, createargs, diropres, 0), |
1145 | PROC(RMDIR, diropargs, stat, 0), |
1146 | PROC(READDIR, readdirargs, readdirres, 3), |
1147 | PROC(STATFS, fhandle, statfsres, 0), |
1148 | }; |
1149 | |
1150 | static unsigned int nfs_version2_counts[ARRAY_SIZE(nfs_procedures)]; |
1151 | const struct rpc_version nfs_version2 = { |
1152 | .number = 2, |
1153 | .nrprocs = ARRAY_SIZE(nfs_procedures), |
1154 | .procs = nfs_procedures, |
1155 | .counts = nfs_version2_counts, |
1156 | }; |
1157 | |