1 | /* |
2 | * Server-side XDR for NFSv4 |
3 | * |
4 | * Copyright (c) 2002 The Regents of the University of Michigan. |
5 | * All rights reserved. |
6 | * |
7 | * Kendrick Smith <kmsmith@umich.edu> |
8 | * Andy Adamson <andros@umich.edu> |
9 | * |
10 | * Redistribution and use in source and binary forms, with or without |
11 | * modification, are permitted provided that the following conditions |
12 | * are met: |
13 | * |
14 | * 1. Redistributions of source code must retain the above copyright |
15 | * notice, this list of conditions and the following disclaimer. |
16 | * 2. Redistributions in binary form must reproduce the above copyright |
17 | * notice, this list of conditions and the following disclaimer in the |
18 | * documentation and/or other materials provided with the distribution. |
19 | * 3. Neither the name of the University nor the names of its |
20 | * contributors may be used to endorse or promote products derived |
21 | * from this software without specific prior written permission. |
22 | * |
23 | * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED |
24 | * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
25 | * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
26 | * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
27 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
28 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
29 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR |
30 | * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF |
31 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
32 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
33 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
34 | */ |
35 | |
36 | #include <linux/file.h> |
37 | #include <linux/slab.h> |
38 | #include <linux/namei.h> |
39 | #include <linux/statfs.h> |
40 | #include <linux/utsname.h> |
41 | #include <linux/pagemap.h> |
42 | #include <linux/sunrpc/svcauth_gss.h> |
43 | #include <linux/sunrpc/addr.h> |
44 | #include <linux/xattr.h> |
45 | #include <linux/vmalloc.h> |
46 | |
47 | #include <uapi/linux/xattr.h> |
48 | |
49 | #include "idmap.h" |
50 | #include "acl.h" |
51 | #include "xdr4.h" |
52 | #include "vfs.h" |
53 | #include "state.h" |
54 | #include "cache.h" |
55 | #include "netns.h" |
56 | #include "pnfs.h" |
57 | #include "filecache.h" |
58 | |
59 | #include "trace.h" |
60 | |
61 | #ifdef CONFIG_NFSD_V4_SECURITY_LABEL |
62 | #include <linux/security.h> |
63 | #endif |
64 | |
65 | |
66 | #define NFSDDBG_FACILITY NFSDDBG_XDR |
67 | |
68 | const u32 nfsd_suppattrs[3][3] = { |
69 | {NFSD4_SUPPORTED_ATTRS_WORD0, |
70 | NFSD4_SUPPORTED_ATTRS_WORD1, |
71 | NFSD4_SUPPORTED_ATTRS_WORD2}, |
72 | |
73 | {NFSD4_1_SUPPORTED_ATTRS_WORD0, |
74 | NFSD4_1_SUPPORTED_ATTRS_WORD1, |
75 | NFSD4_1_SUPPORTED_ATTRS_WORD2}, |
76 | |
77 | {NFSD4_1_SUPPORTED_ATTRS_WORD0, |
78 | NFSD4_1_SUPPORTED_ATTRS_WORD1, |
79 | NFSD4_2_SUPPORTED_ATTRS_WORD2}, |
80 | }; |
81 | |
82 | /* |
83 | * As per referral draft, the fsid for a referral MUST be different from the fsid of the containing |
84 | * directory in order to indicate to the client that a filesystem boundary is present |
85 | * We use a fixed fsid for a referral |
86 | */ |
87 | #define NFS4_REFERRAL_FSID_MAJOR 0x8000000ULL |
88 | #define NFS4_REFERRAL_FSID_MINOR 0x8000000ULL |
89 | |
90 | static __be32 |
91 | check_filename(char *str, int len) |
92 | { |
93 | int i; |
94 | |
95 | if (len == 0) |
96 | return nfserr_inval; |
97 | if (len > NFS4_MAXNAMLEN) |
98 | return nfserr_nametoolong; |
99 | if (isdotent(str, len)) |
100 | return nfserr_badname; |
101 | for (i = 0; i < len; i++) |
102 | if (str[i] == '/') |
103 | return nfserr_badname; |
104 | return 0; |
105 | } |
106 | |
107 | static int zero_clientid(clientid_t *clid) |
108 | { |
109 | return (clid->cl_boot == 0) && (clid->cl_id == 0); |
110 | } |
111 | |
112 | /** |
113 | * svcxdr_tmpalloc - allocate memory to be freed after compound processing |
114 | * @argp: NFSv4 compound argument structure |
115 | * @len: length of buffer to allocate |
116 | * |
117 | * Allocates a buffer of size @len to be freed when processing the compound |
118 | * operation described in @argp finishes. |
119 | */ |
120 | static void * |
121 | svcxdr_tmpalloc(struct nfsd4_compoundargs *argp, u32 len) |
122 | { |
123 | struct svcxdr_tmpbuf *tb; |
124 | |
125 | tb = kmalloc(size: sizeof(*tb) + len, GFP_KERNEL); |
126 | if (!tb) |
127 | return NULL; |
128 | tb->next = argp->to_free; |
129 | argp->to_free = tb; |
130 | return tb->buf; |
131 | } |
132 | |
133 | /* |
134 | * For xdr strings that need to be passed to other kernel api's |
135 | * as null-terminated strings. |
136 | * |
137 | * Note null-terminating in place usually isn't safe since the |
138 | * buffer might end on a page boundary. |
139 | */ |
140 | static char * |
141 | svcxdr_dupstr(struct nfsd4_compoundargs *argp, void *buf, u32 len) |
142 | { |
143 | char *p = svcxdr_tmpalloc(argp, len: len + 1); |
144 | |
145 | if (!p) |
146 | return NULL; |
147 | memcpy(p, buf, len); |
148 | p[len] = '\0'; |
149 | return p; |
150 | } |
151 | |
152 | static void * |
153 | svcxdr_savemem(struct nfsd4_compoundargs *argp, __be32 *p, u32 len) |
154 | { |
155 | __be32 *tmp; |
156 | |
157 | /* |
158 | * The location of the decoded data item is stable, |
159 | * so @p is OK to use. This is the common case. |
160 | */ |
161 | if (p != argp->xdr->scratch.iov_base) |
162 | return p; |
163 | |
164 | tmp = svcxdr_tmpalloc(argp, len); |
165 | if (!tmp) |
166 | return NULL; |
167 | memcpy(tmp, p, len); |
168 | return tmp; |
169 | } |
170 | |
171 | /* |
172 | * NFSv4 basic data type decoders |
173 | */ |
174 | |
175 | /* |
176 | * This helper handles variable-length opaques which belong to protocol |
177 | * elements that this implementation does not support. |
178 | */ |
179 | static __be32 |
180 | nfsd4_decode_ignored_string(struct nfsd4_compoundargs *argp, u32 maxlen) |
181 | { |
182 | u32 len; |
183 | |
184 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &len) < 0) |
185 | return nfserr_bad_xdr; |
186 | if (maxlen && len > maxlen) |
187 | return nfserr_bad_xdr; |
188 | if (!xdr_inline_decode(xdr: argp->xdr, nbytes: len)) |
189 | return nfserr_bad_xdr; |
190 | |
191 | return nfs_ok; |
192 | } |
193 | |
194 | static __be32 |
195 | nfsd4_decode_opaque(struct nfsd4_compoundargs *argp, struct xdr_netobj *o) |
196 | { |
197 | __be32 *p; |
198 | u32 len; |
199 | |
200 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &len) < 0) |
201 | return nfserr_bad_xdr; |
202 | if (len == 0 || len > NFS4_OPAQUE_LIMIT) |
203 | return nfserr_bad_xdr; |
204 | p = xdr_inline_decode(xdr: argp->xdr, nbytes: len); |
205 | if (!p) |
206 | return nfserr_bad_xdr; |
207 | o->data = svcxdr_savemem(argp, p, len); |
208 | if (!o->data) |
209 | return nfserr_jukebox; |
210 | o->len = len; |
211 | |
212 | return nfs_ok; |
213 | } |
214 | |
215 | static __be32 |
216 | nfsd4_decode_component4(struct nfsd4_compoundargs *argp, char **namp, u32 *lenp) |
217 | { |
218 | __be32 *p, status; |
219 | |
220 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: lenp) < 0) |
221 | return nfserr_bad_xdr; |
222 | p = xdr_inline_decode(xdr: argp->xdr, nbytes: *lenp); |
223 | if (!p) |
224 | return nfserr_bad_xdr; |
225 | status = check_filename(str: (char *)p, len: *lenp); |
226 | if (status) |
227 | return status; |
228 | *namp = svcxdr_savemem(argp, p, len: *lenp); |
229 | if (!*namp) |
230 | return nfserr_jukebox; |
231 | |
232 | return nfs_ok; |
233 | } |
234 | |
235 | static __be32 |
236 | nfsd4_decode_nfstime4(struct nfsd4_compoundargs *argp, struct timespec64 *tv) |
237 | { |
238 | __be32 *p; |
239 | |
240 | p = xdr_inline_decode(xdr: argp->xdr, XDR_UNIT * 3); |
241 | if (!p) |
242 | return nfserr_bad_xdr; |
243 | p = xdr_decode_hyper(p, valp: &tv->tv_sec); |
244 | tv->tv_nsec = be32_to_cpup(p: p++); |
245 | if (tv->tv_nsec >= (u32)1000000000) |
246 | return nfserr_inval; |
247 | return nfs_ok; |
248 | } |
249 | |
250 | static __be32 |
251 | nfsd4_decode_verifier4(struct nfsd4_compoundargs *argp, nfs4_verifier *verf) |
252 | { |
253 | __be32 *p; |
254 | |
255 | p = xdr_inline_decode(xdr: argp->xdr, NFS4_VERIFIER_SIZE); |
256 | if (!p) |
257 | return nfserr_bad_xdr; |
258 | memcpy(verf->data, p, sizeof(verf->data)); |
259 | return nfs_ok; |
260 | } |
261 | |
262 | /** |
263 | * nfsd4_decode_bitmap4 - Decode an NFSv4 bitmap4 |
264 | * @argp: NFSv4 compound argument structure |
265 | * @bmval: pointer to an array of u32's to decode into |
266 | * @bmlen: size of the @bmval array |
267 | * |
268 | * The server needs to return nfs_ok rather than nfserr_bad_xdr when |
269 | * encountering bitmaps containing bits it does not recognize. This |
270 | * includes bits in bitmap words past WORDn, where WORDn is the last |
271 | * bitmap WORD the implementation currently supports. Thus we are |
272 | * careful here to simply ignore bits in bitmap words that this |
273 | * implementation has yet to support explicitly. |
274 | * |
275 | * Return values: |
276 | * %nfs_ok: @bmval populated successfully |
277 | * %nfserr_bad_xdr: the encoded bitmap was invalid |
278 | */ |
279 | static __be32 |
280 | nfsd4_decode_bitmap4(struct nfsd4_compoundargs *argp, u32 *bmval, u32 bmlen) |
281 | { |
282 | ssize_t status; |
283 | |
284 | status = xdr_stream_decode_uint32_array(xdr: argp->xdr, array: bmval, array_size: bmlen); |
285 | return status == -EBADMSG ? nfserr_bad_xdr : nfs_ok; |
286 | } |
287 | |
288 | static __be32 |
289 | nfsd4_decode_nfsace4(struct nfsd4_compoundargs *argp, struct nfs4_ace *ace) |
290 | { |
291 | __be32 *p, status; |
292 | u32 length; |
293 | |
294 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &ace->type) < 0) |
295 | return nfserr_bad_xdr; |
296 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &ace->flag) < 0) |
297 | return nfserr_bad_xdr; |
298 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &ace->access_mask) < 0) |
299 | return nfserr_bad_xdr; |
300 | |
301 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &length) < 0) |
302 | return nfserr_bad_xdr; |
303 | p = xdr_inline_decode(xdr: argp->xdr, nbytes: length); |
304 | if (!p) |
305 | return nfserr_bad_xdr; |
306 | ace->whotype = nfs4_acl_get_whotype((char *)p, length); |
307 | if (ace->whotype != NFS4_ACL_WHO_NAMED) |
308 | status = nfs_ok; |
309 | else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP) |
310 | status = nfsd_map_name_to_gid(argp->rqstp, |
311 | (char *)p, length, &ace->who_gid); |
312 | else |
313 | status = nfsd_map_name_to_uid(argp->rqstp, |
314 | (char *)p, length, &ace->who_uid); |
315 | |
316 | return status; |
317 | } |
318 | |
319 | /* A counted array of nfsace4's */ |
320 | static noinline __be32 |
321 | nfsd4_decode_acl(struct nfsd4_compoundargs *argp, struct nfs4_acl **acl) |
322 | { |
323 | struct nfs4_ace *ace; |
324 | __be32 status; |
325 | u32 count; |
326 | |
327 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &count) < 0) |
328 | return nfserr_bad_xdr; |
329 | |
330 | if (count > xdr_stream_remaining(xdr: argp->xdr) / 20) |
331 | /* |
332 | * Even with 4-byte names there wouldn't be |
333 | * space for that many aces; something fishy is |
334 | * going on: |
335 | */ |
336 | return nfserr_fbig; |
337 | |
338 | *acl = svcxdr_tmpalloc(argp, len: nfs4_acl_bytes(entries: count)); |
339 | if (*acl == NULL) |
340 | return nfserr_jukebox; |
341 | |
342 | (*acl)->naces = count; |
343 | for (ace = (*acl)->aces; ace < (*acl)->aces + count; ace++) { |
344 | status = nfsd4_decode_nfsace4(argp, ace); |
345 | if (status) |
346 | return status; |
347 | } |
348 | |
349 | return nfs_ok; |
350 | } |
351 | |
352 | static noinline __be32 |
353 | nfsd4_decode_security_label(struct nfsd4_compoundargs *argp, |
354 | struct xdr_netobj *label) |
355 | { |
356 | u32 lfs, pi, length; |
357 | __be32 *p; |
358 | |
359 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &lfs) < 0) |
360 | return nfserr_bad_xdr; |
361 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &pi) < 0) |
362 | return nfserr_bad_xdr; |
363 | |
364 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &length) < 0) |
365 | return nfserr_bad_xdr; |
366 | if (length > NFS4_MAXLABELLEN) |
367 | return nfserr_badlabel; |
368 | p = xdr_inline_decode(xdr: argp->xdr, nbytes: length); |
369 | if (!p) |
370 | return nfserr_bad_xdr; |
371 | label->len = length; |
372 | label->data = svcxdr_dupstr(argp, buf: p, len: length); |
373 | if (!label->data) |
374 | return nfserr_jukebox; |
375 | |
376 | return nfs_ok; |
377 | } |
378 | |
379 | static __be32 |
380 | nfsd4_decode_fattr4(struct nfsd4_compoundargs *argp, u32 *bmval, u32 bmlen, |
381 | struct iattr *iattr, struct nfs4_acl **acl, |
382 | struct xdr_netobj *label, int *umask) |
383 | { |
384 | unsigned int starting_pos; |
385 | u32 attrlist4_count; |
386 | __be32 *p, status; |
387 | |
388 | iattr->ia_valid = 0; |
389 | status = nfsd4_decode_bitmap4(argp, bmval, bmlen); |
390 | if (status) |
391 | return nfserr_bad_xdr; |
392 | |
393 | if (bmval[0] & ~NFSD_WRITEABLE_ATTRS_WORD0 |
394 | || bmval[1] & ~NFSD_WRITEABLE_ATTRS_WORD1 |
395 | || bmval[2] & ~NFSD_WRITEABLE_ATTRS_WORD2) { |
396 | if (nfsd_attrs_supported(minorversion: argp->minorversion, bmval)) |
397 | return nfserr_inval; |
398 | return nfserr_attrnotsupp; |
399 | } |
400 | |
401 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &attrlist4_count) < 0) |
402 | return nfserr_bad_xdr; |
403 | starting_pos = xdr_stream_pos(xdr: argp->xdr); |
404 | |
405 | if (bmval[0] & FATTR4_WORD0_SIZE) { |
406 | u64 size; |
407 | |
408 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: &size) < 0) |
409 | return nfserr_bad_xdr; |
410 | iattr->ia_size = size; |
411 | iattr->ia_valid |= ATTR_SIZE; |
412 | } |
413 | if (bmval[0] & FATTR4_WORD0_ACL) { |
414 | status = nfsd4_decode_acl(argp, acl); |
415 | if (status) |
416 | return status; |
417 | } else |
418 | *acl = NULL; |
419 | if (bmval[1] & FATTR4_WORD1_MODE) { |
420 | u32 mode; |
421 | |
422 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &mode) < 0) |
423 | return nfserr_bad_xdr; |
424 | iattr->ia_mode = mode; |
425 | iattr->ia_mode &= (S_IFMT | S_IALLUGO); |
426 | iattr->ia_valid |= ATTR_MODE; |
427 | } |
428 | if (bmval[1] & FATTR4_WORD1_OWNER) { |
429 | u32 length; |
430 | |
431 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &length) < 0) |
432 | return nfserr_bad_xdr; |
433 | p = xdr_inline_decode(xdr: argp->xdr, nbytes: length); |
434 | if (!p) |
435 | return nfserr_bad_xdr; |
436 | status = nfsd_map_name_to_uid(argp->rqstp, (char *)p, length, |
437 | &iattr->ia_uid); |
438 | if (status) |
439 | return status; |
440 | iattr->ia_valid |= ATTR_UID; |
441 | } |
442 | if (bmval[1] & FATTR4_WORD1_OWNER_GROUP) { |
443 | u32 length; |
444 | |
445 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &length) < 0) |
446 | return nfserr_bad_xdr; |
447 | p = xdr_inline_decode(xdr: argp->xdr, nbytes: length); |
448 | if (!p) |
449 | return nfserr_bad_xdr; |
450 | status = nfsd_map_name_to_gid(argp->rqstp, (char *)p, length, |
451 | &iattr->ia_gid); |
452 | if (status) |
453 | return status; |
454 | iattr->ia_valid |= ATTR_GID; |
455 | } |
456 | if (bmval[1] & FATTR4_WORD1_TIME_ACCESS_SET) { |
457 | u32 set_it; |
458 | |
459 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &set_it) < 0) |
460 | return nfserr_bad_xdr; |
461 | switch (set_it) { |
462 | case NFS4_SET_TO_CLIENT_TIME: |
463 | status = nfsd4_decode_nfstime4(argp, tv: &iattr->ia_atime); |
464 | if (status) |
465 | return status; |
466 | iattr->ia_valid |= (ATTR_ATIME | ATTR_ATIME_SET); |
467 | break; |
468 | case NFS4_SET_TO_SERVER_TIME: |
469 | iattr->ia_valid |= ATTR_ATIME; |
470 | break; |
471 | default: |
472 | return nfserr_bad_xdr; |
473 | } |
474 | } |
475 | if (bmval[1] & FATTR4_WORD1_TIME_CREATE) { |
476 | struct timespec64 ts; |
477 | |
478 | /* No Linux filesystem supports setting this attribute. */ |
479 | bmval[1] &= ~FATTR4_WORD1_TIME_CREATE; |
480 | status = nfsd4_decode_nfstime4(argp, tv: &ts); |
481 | if (status) |
482 | return status; |
483 | } |
484 | if (bmval[1] & FATTR4_WORD1_TIME_MODIFY_SET) { |
485 | u32 set_it; |
486 | |
487 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &set_it) < 0) |
488 | return nfserr_bad_xdr; |
489 | switch (set_it) { |
490 | case NFS4_SET_TO_CLIENT_TIME: |
491 | status = nfsd4_decode_nfstime4(argp, tv: &iattr->ia_mtime); |
492 | if (status) |
493 | return status; |
494 | iattr->ia_valid |= (ATTR_MTIME | ATTR_MTIME_SET); |
495 | break; |
496 | case NFS4_SET_TO_SERVER_TIME: |
497 | iattr->ia_valid |= ATTR_MTIME; |
498 | break; |
499 | default: |
500 | return nfserr_bad_xdr; |
501 | } |
502 | } |
503 | label->len = 0; |
504 | if (IS_ENABLED(CONFIG_NFSD_V4_SECURITY_LABEL) && |
505 | bmval[2] & FATTR4_WORD2_SECURITY_LABEL) { |
506 | status = nfsd4_decode_security_label(argp, label); |
507 | if (status) |
508 | return status; |
509 | } |
510 | if (bmval[2] & FATTR4_WORD2_MODE_UMASK) { |
511 | u32 mode, mask; |
512 | |
513 | if (!umask) |
514 | return nfserr_bad_xdr; |
515 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &mode) < 0) |
516 | return nfserr_bad_xdr; |
517 | iattr->ia_mode = mode & (S_IFMT | S_IALLUGO); |
518 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &mask) < 0) |
519 | return nfserr_bad_xdr; |
520 | *umask = mask & S_IRWXUGO; |
521 | iattr->ia_valid |= ATTR_MODE; |
522 | } |
523 | |
524 | /* request sanity: did attrlist4 contain the expected number of words? */ |
525 | if (attrlist4_count != xdr_stream_pos(xdr: argp->xdr) - starting_pos) |
526 | return nfserr_bad_xdr; |
527 | |
528 | return nfs_ok; |
529 | } |
530 | |
531 | static __be32 |
532 | nfsd4_decode_stateid4(struct nfsd4_compoundargs *argp, stateid_t *sid) |
533 | { |
534 | __be32 *p; |
535 | |
536 | p = xdr_inline_decode(xdr: argp->xdr, NFS4_STATEID_SIZE); |
537 | if (!p) |
538 | return nfserr_bad_xdr; |
539 | sid->si_generation = be32_to_cpup(p: p++); |
540 | memcpy(&sid->si_opaque, p, sizeof(sid->si_opaque)); |
541 | return nfs_ok; |
542 | } |
543 | |
544 | static __be32 |
545 | nfsd4_decode_clientid4(struct nfsd4_compoundargs *argp, clientid_t *clientid) |
546 | { |
547 | __be32 *p; |
548 | |
549 | p = xdr_inline_decode(xdr: argp->xdr, nbytes: sizeof(__be64)); |
550 | if (!p) |
551 | return nfserr_bad_xdr; |
552 | memcpy(clientid, p, sizeof(*clientid)); |
553 | return nfs_ok; |
554 | } |
555 | |
556 | static __be32 |
557 | nfsd4_decode_state_owner4(struct nfsd4_compoundargs *argp, |
558 | clientid_t *clientid, struct xdr_netobj *owner) |
559 | { |
560 | __be32 status; |
561 | |
562 | status = nfsd4_decode_clientid4(argp, clientid); |
563 | if (status) |
564 | return status; |
565 | return nfsd4_decode_opaque(argp, o: owner); |
566 | } |
567 | |
568 | #ifdef CONFIG_NFSD_PNFS |
569 | static __be32 |
570 | nfsd4_decode_deviceid4(struct nfsd4_compoundargs *argp, |
571 | struct nfsd4_deviceid *devid) |
572 | { |
573 | __be32 *p; |
574 | |
575 | p = xdr_inline_decode(xdr: argp->xdr, NFS4_DEVICEID4_SIZE); |
576 | if (!p) |
577 | return nfserr_bad_xdr; |
578 | memcpy(devid, p, sizeof(*devid)); |
579 | return nfs_ok; |
580 | } |
581 | |
582 | static __be32 |
583 | nfsd4_decode_layoutupdate4(struct nfsd4_compoundargs *argp, |
584 | struct nfsd4_layoutcommit *lcp) |
585 | { |
586 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &lcp->lc_layout_type) < 0) |
587 | return nfserr_bad_xdr; |
588 | if (lcp->lc_layout_type < LAYOUT_NFSV4_1_FILES) |
589 | return nfserr_bad_xdr; |
590 | if (lcp->lc_layout_type >= LAYOUT_TYPE_MAX) |
591 | return nfserr_bad_xdr; |
592 | |
593 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &lcp->lc_up_len) < 0) |
594 | return nfserr_bad_xdr; |
595 | if (lcp->lc_up_len > 0) { |
596 | lcp->lc_up_layout = xdr_inline_decode(xdr: argp->xdr, nbytes: lcp->lc_up_len); |
597 | if (!lcp->lc_up_layout) |
598 | return nfserr_bad_xdr; |
599 | } |
600 | |
601 | return nfs_ok; |
602 | } |
603 | |
604 | static __be32 |
605 | nfsd4_decode_layoutreturn4(struct nfsd4_compoundargs *argp, |
606 | struct nfsd4_layoutreturn *lrp) |
607 | { |
608 | __be32 status; |
609 | |
610 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &lrp->lr_return_type) < 0) |
611 | return nfserr_bad_xdr; |
612 | switch (lrp->lr_return_type) { |
613 | case RETURN_FILE: |
614 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: &lrp->lr_seg.offset) < 0) |
615 | return nfserr_bad_xdr; |
616 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: &lrp->lr_seg.length) < 0) |
617 | return nfserr_bad_xdr; |
618 | status = nfsd4_decode_stateid4(argp, sid: &lrp->lr_sid); |
619 | if (status) |
620 | return status; |
621 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &lrp->lrf_body_len) < 0) |
622 | return nfserr_bad_xdr; |
623 | if (lrp->lrf_body_len > 0) { |
624 | lrp->lrf_body = xdr_inline_decode(xdr: argp->xdr, nbytes: lrp->lrf_body_len); |
625 | if (!lrp->lrf_body) |
626 | return nfserr_bad_xdr; |
627 | } |
628 | break; |
629 | case RETURN_FSID: |
630 | case RETURN_ALL: |
631 | lrp->lr_seg.offset = 0; |
632 | lrp->lr_seg.length = NFS4_MAX_UINT64; |
633 | break; |
634 | default: |
635 | return nfserr_bad_xdr; |
636 | } |
637 | |
638 | return nfs_ok; |
639 | } |
640 | |
641 | #endif /* CONFIG_NFSD_PNFS */ |
642 | |
643 | static __be32 |
644 | nfsd4_decode_sessionid4(struct nfsd4_compoundargs *argp, |
645 | struct nfs4_sessionid *sessionid) |
646 | { |
647 | __be32 *p; |
648 | |
649 | p = xdr_inline_decode(xdr: argp->xdr, NFS4_MAX_SESSIONID_LEN); |
650 | if (!p) |
651 | return nfserr_bad_xdr; |
652 | memcpy(sessionid->data, p, sizeof(sessionid->data)); |
653 | return nfs_ok; |
654 | } |
655 | |
656 | /* Defined in Appendix A of RFC 5531 */ |
657 | static __be32 |
658 | nfsd4_decode_authsys_parms(struct nfsd4_compoundargs *argp, |
659 | struct nfsd4_cb_sec *cbs) |
660 | { |
661 | u32 stamp, gidcount, uid, gid; |
662 | __be32 *p, status; |
663 | |
664 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &stamp) < 0) |
665 | return nfserr_bad_xdr; |
666 | /* machine name */ |
667 | status = nfsd4_decode_ignored_string(argp, maxlen: 255); |
668 | if (status) |
669 | return status; |
670 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &uid) < 0) |
671 | return nfserr_bad_xdr; |
672 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &gid) < 0) |
673 | return nfserr_bad_xdr; |
674 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &gidcount) < 0) |
675 | return nfserr_bad_xdr; |
676 | if (gidcount > 16) |
677 | return nfserr_bad_xdr; |
678 | p = xdr_inline_decode(xdr: argp->xdr, nbytes: gidcount << 2); |
679 | if (!p) |
680 | return nfserr_bad_xdr; |
681 | if (cbs->flavor == (u32)(-1)) { |
682 | struct user_namespace *userns = nfsd_user_namespace(rqstp: argp->rqstp); |
683 | |
684 | kuid_t kuid = make_kuid(from: userns, uid); |
685 | kgid_t kgid = make_kgid(from: userns, gid); |
686 | if (uid_valid(uid: kuid) && gid_valid(gid: kgid)) { |
687 | cbs->uid = kuid; |
688 | cbs->gid = kgid; |
689 | cbs->flavor = RPC_AUTH_UNIX; |
690 | } else { |
691 | dprintk("RPC_AUTH_UNIX with invalid uid or gid, ignoring!\n" ); |
692 | } |
693 | } |
694 | |
695 | return nfs_ok; |
696 | } |
697 | |
698 | static __be32 |
699 | nfsd4_decode_gss_cb_handles4(struct nfsd4_compoundargs *argp, |
700 | struct nfsd4_cb_sec *cbs) |
701 | { |
702 | __be32 status; |
703 | u32 service; |
704 | |
705 | dprintk("RPC_AUTH_GSS callback secflavor not supported!\n" ); |
706 | |
707 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &service) < 0) |
708 | return nfserr_bad_xdr; |
709 | if (service < RPC_GSS_SVC_NONE || service > RPC_GSS_SVC_PRIVACY) |
710 | return nfserr_bad_xdr; |
711 | /* gcbp_handle_from_server */ |
712 | status = nfsd4_decode_ignored_string(argp, maxlen: 0); |
713 | if (status) |
714 | return status; |
715 | /* gcbp_handle_from_client */ |
716 | status = nfsd4_decode_ignored_string(argp, maxlen: 0); |
717 | if (status) |
718 | return status; |
719 | |
720 | return nfs_ok; |
721 | } |
722 | |
723 | /* a counted array of callback_sec_parms4 items */ |
724 | static __be32 |
725 | nfsd4_decode_cb_sec(struct nfsd4_compoundargs *argp, struct nfsd4_cb_sec *cbs) |
726 | { |
727 | u32 i, secflavor, nr_secflavs; |
728 | __be32 status; |
729 | |
730 | /* callback_sec_params4 */ |
731 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &nr_secflavs) < 0) |
732 | return nfserr_bad_xdr; |
733 | if (nr_secflavs) |
734 | cbs->flavor = (u32)(-1); |
735 | else |
736 | /* Is this legal? Be generous, take it to mean AUTH_NONE: */ |
737 | cbs->flavor = 0; |
738 | |
739 | for (i = 0; i < nr_secflavs; ++i) { |
740 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &secflavor) < 0) |
741 | return nfserr_bad_xdr; |
742 | switch (secflavor) { |
743 | case RPC_AUTH_NULL: |
744 | /* void */ |
745 | if (cbs->flavor == (u32)(-1)) |
746 | cbs->flavor = RPC_AUTH_NULL; |
747 | break; |
748 | case RPC_AUTH_UNIX: |
749 | status = nfsd4_decode_authsys_parms(argp, cbs); |
750 | if (status) |
751 | return status; |
752 | break; |
753 | case RPC_AUTH_GSS: |
754 | status = nfsd4_decode_gss_cb_handles4(argp, cbs); |
755 | if (status) |
756 | return status; |
757 | break; |
758 | default: |
759 | return nfserr_inval; |
760 | } |
761 | } |
762 | |
763 | return nfs_ok; |
764 | } |
765 | |
766 | |
767 | /* |
768 | * NFSv4 operation argument decoders |
769 | */ |
770 | |
771 | static __be32 |
772 | nfsd4_decode_access(struct nfsd4_compoundargs *argp, |
773 | union nfsd4_op_u *u) |
774 | { |
775 | struct nfsd4_access *access = &u->access; |
776 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &access->ac_req_access) < 0) |
777 | return nfserr_bad_xdr; |
778 | return nfs_ok; |
779 | } |
780 | |
781 | static __be32 |
782 | nfsd4_decode_close(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u) |
783 | { |
784 | struct nfsd4_close *close = &u->close; |
785 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &close->cl_seqid) < 0) |
786 | return nfserr_bad_xdr; |
787 | return nfsd4_decode_stateid4(argp, sid: &close->cl_stateid); |
788 | } |
789 | |
790 | |
791 | static __be32 |
792 | nfsd4_decode_commit(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u) |
793 | { |
794 | struct nfsd4_commit *commit = &u->commit; |
795 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: &commit->co_offset) < 0) |
796 | return nfserr_bad_xdr; |
797 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &commit->co_count) < 0) |
798 | return nfserr_bad_xdr; |
799 | memset(&commit->co_verf, 0, sizeof(commit->co_verf)); |
800 | return nfs_ok; |
801 | } |
802 | |
803 | static __be32 |
804 | nfsd4_decode_create(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u) |
805 | { |
806 | struct nfsd4_create *create = &u->create; |
807 | __be32 *p, status; |
808 | |
809 | memset(create, 0, sizeof(*create)); |
810 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &create->cr_type) < 0) |
811 | return nfserr_bad_xdr; |
812 | switch (create->cr_type) { |
813 | case NF4LNK: |
814 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &create->cr_datalen) < 0) |
815 | return nfserr_bad_xdr; |
816 | p = xdr_inline_decode(xdr: argp->xdr, nbytes: create->cr_datalen); |
817 | if (!p) |
818 | return nfserr_bad_xdr; |
819 | create->cr_data = svcxdr_dupstr(argp, buf: p, len: create->cr_datalen); |
820 | if (!create->cr_data) |
821 | return nfserr_jukebox; |
822 | break; |
823 | case NF4BLK: |
824 | case NF4CHR: |
825 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &create->cr_specdata1) < 0) |
826 | return nfserr_bad_xdr; |
827 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &create->cr_specdata2) < 0) |
828 | return nfserr_bad_xdr; |
829 | break; |
830 | case NF4SOCK: |
831 | case NF4FIFO: |
832 | case NF4DIR: |
833 | default: |
834 | break; |
835 | } |
836 | status = nfsd4_decode_component4(argp, namp: &create->cr_name, |
837 | lenp: &create->cr_namelen); |
838 | if (status) |
839 | return status; |
840 | status = nfsd4_decode_fattr4(argp, bmval: create->cr_bmval, |
841 | ARRAY_SIZE(create->cr_bmval), |
842 | iattr: &create->cr_iattr, acl: &create->cr_acl, |
843 | label: &create->cr_label, umask: &create->cr_umask); |
844 | if (status) |
845 | return status; |
846 | |
847 | return nfs_ok; |
848 | } |
849 | |
850 | static inline __be32 |
851 | nfsd4_decode_delegreturn(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u) |
852 | { |
853 | struct nfsd4_delegreturn *dr = &u->delegreturn; |
854 | return nfsd4_decode_stateid4(argp, sid: &dr->dr_stateid); |
855 | } |
856 | |
857 | static inline __be32 |
858 | nfsd4_decode_getattr(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u) |
859 | { |
860 | struct nfsd4_getattr *getattr = &u->getattr; |
861 | memset(getattr, 0, sizeof(*getattr)); |
862 | return nfsd4_decode_bitmap4(argp, bmval: getattr->ga_bmval, |
863 | ARRAY_SIZE(getattr->ga_bmval)); |
864 | } |
865 | |
866 | static __be32 |
867 | nfsd4_decode_link(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u) |
868 | { |
869 | struct nfsd4_link *link = &u->link; |
870 | memset(link, 0, sizeof(*link)); |
871 | return nfsd4_decode_component4(argp, namp: &link->li_name, lenp: &link->li_namelen); |
872 | } |
873 | |
874 | static __be32 |
875 | nfsd4_decode_open_to_lock_owner4(struct nfsd4_compoundargs *argp, |
876 | struct nfsd4_lock *lock) |
877 | { |
878 | __be32 status; |
879 | |
880 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &lock->lk_new_open_seqid) < 0) |
881 | return nfserr_bad_xdr; |
882 | status = nfsd4_decode_stateid4(argp, sid: &lock->lk_new_open_stateid); |
883 | if (status) |
884 | return status; |
885 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &lock->lk_new_lock_seqid) < 0) |
886 | return nfserr_bad_xdr; |
887 | return nfsd4_decode_state_owner4(argp, clientid: &lock->lk_new_clientid, |
888 | owner: &lock->lk_new_owner); |
889 | } |
890 | |
891 | static __be32 |
892 | nfsd4_decode_exist_lock_owner4(struct nfsd4_compoundargs *argp, |
893 | struct nfsd4_lock *lock) |
894 | { |
895 | __be32 status; |
896 | |
897 | status = nfsd4_decode_stateid4(argp, sid: &lock->lk_old_lock_stateid); |
898 | if (status) |
899 | return status; |
900 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &lock->lk_old_lock_seqid) < 0) |
901 | return nfserr_bad_xdr; |
902 | |
903 | return nfs_ok; |
904 | } |
905 | |
906 | static __be32 |
907 | nfsd4_decode_locker4(struct nfsd4_compoundargs *argp, struct nfsd4_lock *lock) |
908 | { |
909 | if (xdr_stream_decode_bool(xdr: argp->xdr, ptr: &lock->lk_is_new) < 0) |
910 | return nfserr_bad_xdr; |
911 | if (lock->lk_is_new) |
912 | return nfsd4_decode_open_to_lock_owner4(argp, lock); |
913 | return nfsd4_decode_exist_lock_owner4(argp, lock); |
914 | } |
915 | |
916 | static __be32 |
917 | nfsd4_decode_lock(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u) |
918 | { |
919 | struct nfsd4_lock *lock = &u->lock; |
920 | memset(lock, 0, sizeof(*lock)); |
921 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &lock->lk_type) < 0) |
922 | return nfserr_bad_xdr; |
923 | if ((lock->lk_type < NFS4_READ_LT) || (lock->lk_type > NFS4_WRITEW_LT)) |
924 | return nfserr_bad_xdr; |
925 | if (xdr_stream_decode_bool(xdr: argp->xdr, ptr: &lock->lk_reclaim) < 0) |
926 | return nfserr_bad_xdr; |
927 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: &lock->lk_offset) < 0) |
928 | return nfserr_bad_xdr; |
929 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: &lock->lk_length) < 0) |
930 | return nfserr_bad_xdr; |
931 | return nfsd4_decode_locker4(argp, lock); |
932 | } |
933 | |
934 | static __be32 |
935 | nfsd4_decode_lockt(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u) |
936 | { |
937 | struct nfsd4_lockt *lockt = &u->lockt; |
938 | memset(lockt, 0, sizeof(*lockt)); |
939 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &lockt->lt_type) < 0) |
940 | return nfserr_bad_xdr; |
941 | if ((lockt->lt_type < NFS4_READ_LT) || (lockt->lt_type > NFS4_WRITEW_LT)) |
942 | return nfserr_bad_xdr; |
943 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: &lockt->lt_offset) < 0) |
944 | return nfserr_bad_xdr; |
945 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: &lockt->lt_length) < 0) |
946 | return nfserr_bad_xdr; |
947 | return nfsd4_decode_state_owner4(argp, clientid: &lockt->lt_clientid, |
948 | owner: &lockt->lt_owner); |
949 | } |
950 | |
951 | static __be32 |
952 | nfsd4_decode_locku(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u) |
953 | { |
954 | struct nfsd4_locku *locku = &u->locku; |
955 | __be32 status; |
956 | |
957 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &locku->lu_type) < 0) |
958 | return nfserr_bad_xdr; |
959 | if ((locku->lu_type < NFS4_READ_LT) || (locku->lu_type > NFS4_WRITEW_LT)) |
960 | return nfserr_bad_xdr; |
961 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &locku->lu_seqid) < 0) |
962 | return nfserr_bad_xdr; |
963 | status = nfsd4_decode_stateid4(argp, sid: &locku->lu_stateid); |
964 | if (status) |
965 | return status; |
966 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: &locku->lu_offset) < 0) |
967 | return nfserr_bad_xdr; |
968 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: &locku->lu_length) < 0) |
969 | return nfserr_bad_xdr; |
970 | |
971 | return nfs_ok; |
972 | } |
973 | |
974 | static __be32 |
975 | nfsd4_decode_lookup(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u) |
976 | { |
977 | struct nfsd4_lookup *lookup = &u->lookup; |
978 | return nfsd4_decode_component4(argp, namp: &lookup->lo_name, lenp: &lookup->lo_len); |
979 | } |
980 | |
981 | static __be32 |
982 | nfsd4_decode_createhow4(struct nfsd4_compoundargs *argp, struct nfsd4_open *open) |
983 | { |
984 | __be32 status; |
985 | |
986 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &open->op_createmode) < 0) |
987 | return nfserr_bad_xdr; |
988 | switch (open->op_createmode) { |
989 | case NFS4_CREATE_UNCHECKED: |
990 | case NFS4_CREATE_GUARDED: |
991 | status = nfsd4_decode_fattr4(argp, bmval: open->op_bmval, |
992 | ARRAY_SIZE(open->op_bmval), |
993 | iattr: &open->op_iattr, acl: &open->op_acl, |
994 | label: &open->op_label, umask: &open->op_umask); |
995 | if (status) |
996 | return status; |
997 | break; |
998 | case NFS4_CREATE_EXCLUSIVE: |
999 | status = nfsd4_decode_verifier4(argp, verf: &open->op_verf); |
1000 | if (status) |
1001 | return status; |
1002 | break; |
1003 | case NFS4_CREATE_EXCLUSIVE4_1: |
1004 | if (argp->minorversion < 1) |
1005 | return nfserr_bad_xdr; |
1006 | status = nfsd4_decode_verifier4(argp, verf: &open->op_verf); |
1007 | if (status) |
1008 | return status; |
1009 | status = nfsd4_decode_fattr4(argp, bmval: open->op_bmval, |
1010 | ARRAY_SIZE(open->op_bmval), |
1011 | iattr: &open->op_iattr, acl: &open->op_acl, |
1012 | label: &open->op_label, umask: &open->op_umask); |
1013 | if (status) |
1014 | return status; |
1015 | break; |
1016 | default: |
1017 | return nfserr_bad_xdr; |
1018 | } |
1019 | |
1020 | return nfs_ok; |
1021 | } |
1022 | |
1023 | static __be32 |
1024 | nfsd4_decode_openflag4(struct nfsd4_compoundargs *argp, struct nfsd4_open *open) |
1025 | { |
1026 | __be32 status; |
1027 | |
1028 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &open->op_create) < 0) |
1029 | return nfserr_bad_xdr; |
1030 | switch (open->op_create) { |
1031 | case NFS4_OPEN_NOCREATE: |
1032 | break; |
1033 | case NFS4_OPEN_CREATE: |
1034 | status = nfsd4_decode_createhow4(argp, open); |
1035 | if (status) |
1036 | return status; |
1037 | break; |
1038 | default: |
1039 | return nfserr_bad_xdr; |
1040 | } |
1041 | |
1042 | return nfs_ok; |
1043 | } |
1044 | |
1045 | static __be32 nfsd4_decode_share_access(struct nfsd4_compoundargs *argp, u32 *share_access, u32 *deleg_want, u32 *deleg_when) |
1046 | { |
1047 | u32 w; |
1048 | |
1049 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &w) < 0) |
1050 | return nfserr_bad_xdr; |
1051 | *share_access = w & NFS4_SHARE_ACCESS_MASK; |
1052 | *deleg_want = w & NFS4_SHARE_WANT_MASK; |
1053 | if (deleg_when) |
1054 | *deleg_when = w & NFS4_SHARE_WHEN_MASK; |
1055 | |
1056 | switch (w & NFS4_SHARE_ACCESS_MASK) { |
1057 | case NFS4_SHARE_ACCESS_READ: |
1058 | case NFS4_SHARE_ACCESS_WRITE: |
1059 | case NFS4_SHARE_ACCESS_BOTH: |
1060 | break; |
1061 | default: |
1062 | return nfserr_bad_xdr; |
1063 | } |
1064 | w &= ~NFS4_SHARE_ACCESS_MASK; |
1065 | if (!w) |
1066 | return nfs_ok; |
1067 | if (!argp->minorversion) |
1068 | return nfserr_bad_xdr; |
1069 | switch (w & NFS4_SHARE_WANT_MASK) { |
1070 | case NFS4_SHARE_WANT_NO_PREFERENCE: |
1071 | case NFS4_SHARE_WANT_READ_DELEG: |
1072 | case NFS4_SHARE_WANT_WRITE_DELEG: |
1073 | case NFS4_SHARE_WANT_ANY_DELEG: |
1074 | case NFS4_SHARE_WANT_NO_DELEG: |
1075 | case NFS4_SHARE_WANT_CANCEL: |
1076 | break; |
1077 | default: |
1078 | return nfserr_bad_xdr; |
1079 | } |
1080 | w &= ~NFS4_SHARE_WANT_MASK; |
1081 | if (!w) |
1082 | return nfs_ok; |
1083 | |
1084 | if (!deleg_when) /* open_downgrade */ |
1085 | return nfserr_inval; |
1086 | switch (w) { |
1087 | case NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL: |
1088 | case NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED: |
1089 | case (NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL | |
1090 | NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED): |
1091 | return nfs_ok; |
1092 | } |
1093 | return nfserr_bad_xdr; |
1094 | } |
1095 | |
1096 | static __be32 nfsd4_decode_share_deny(struct nfsd4_compoundargs *argp, u32 *x) |
1097 | { |
1098 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: x) < 0) |
1099 | return nfserr_bad_xdr; |
1100 | /* Note: unlike access bits, deny bits may be zero. */ |
1101 | if (*x & ~NFS4_SHARE_DENY_BOTH) |
1102 | return nfserr_bad_xdr; |
1103 | |
1104 | return nfs_ok; |
1105 | } |
1106 | |
1107 | static __be32 |
1108 | nfsd4_decode_open_claim4(struct nfsd4_compoundargs *argp, |
1109 | struct nfsd4_open *open) |
1110 | { |
1111 | __be32 status; |
1112 | |
1113 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &open->op_claim_type) < 0) |
1114 | return nfserr_bad_xdr; |
1115 | switch (open->op_claim_type) { |
1116 | case NFS4_OPEN_CLAIM_NULL: |
1117 | case NFS4_OPEN_CLAIM_DELEGATE_PREV: |
1118 | status = nfsd4_decode_component4(argp, namp: &open->op_fname, |
1119 | lenp: &open->op_fnamelen); |
1120 | if (status) |
1121 | return status; |
1122 | break; |
1123 | case NFS4_OPEN_CLAIM_PREVIOUS: |
1124 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &open->op_delegate_type) < 0) |
1125 | return nfserr_bad_xdr; |
1126 | break; |
1127 | case NFS4_OPEN_CLAIM_DELEGATE_CUR: |
1128 | status = nfsd4_decode_stateid4(argp, sid: &open->op_delegate_stateid); |
1129 | if (status) |
1130 | return status; |
1131 | status = nfsd4_decode_component4(argp, namp: &open->op_fname, |
1132 | lenp: &open->op_fnamelen); |
1133 | if (status) |
1134 | return status; |
1135 | break; |
1136 | case NFS4_OPEN_CLAIM_FH: |
1137 | case NFS4_OPEN_CLAIM_DELEG_PREV_FH: |
1138 | if (argp->minorversion < 1) |
1139 | return nfserr_bad_xdr; |
1140 | /* void */ |
1141 | break; |
1142 | case NFS4_OPEN_CLAIM_DELEG_CUR_FH: |
1143 | if (argp->minorversion < 1) |
1144 | return nfserr_bad_xdr; |
1145 | status = nfsd4_decode_stateid4(argp, sid: &open->op_delegate_stateid); |
1146 | if (status) |
1147 | return status; |
1148 | break; |
1149 | default: |
1150 | return nfserr_bad_xdr; |
1151 | } |
1152 | |
1153 | return nfs_ok; |
1154 | } |
1155 | |
1156 | static __be32 |
1157 | nfsd4_decode_open(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u) |
1158 | { |
1159 | struct nfsd4_open *open = &u->open; |
1160 | __be32 status; |
1161 | u32 dummy; |
1162 | |
1163 | memset(open, 0, sizeof(*open)); |
1164 | |
1165 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &open->op_seqid) < 0) |
1166 | return nfserr_bad_xdr; |
1167 | /* deleg_want is ignored */ |
1168 | status = nfsd4_decode_share_access(argp, share_access: &open->op_share_access, |
1169 | deleg_want: &open->op_deleg_want, deleg_when: &dummy); |
1170 | if (status) |
1171 | return status; |
1172 | status = nfsd4_decode_share_deny(argp, x: &open->op_share_deny); |
1173 | if (status) |
1174 | return status; |
1175 | status = nfsd4_decode_state_owner4(argp, clientid: &open->op_clientid, |
1176 | owner: &open->op_owner); |
1177 | if (status) |
1178 | return status; |
1179 | status = nfsd4_decode_openflag4(argp, open); |
1180 | if (status) |
1181 | return status; |
1182 | return nfsd4_decode_open_claim4(argp, open); |
1183 | } |
1184 | |
1185 | static __be32 |
1186 | nfsd4_decode_open_confirm(struct nfsd4_compoundargs *argp, |
1187 | union nfsd4_op_u *u) |
1188 | { |
1189 | struct nfsd4_open_confirm *open_conf = &u->open_confirm; |
1190 | __be32 status; |
1191 | |
1192 | if (argp->minorversion >= 1) |
1193 | return nfserr_notsupp; |
1194 | |
1195 | status = nfsd4_decode_stateid4(argp, sid: &open_conf->oc_req_stateid); |
1196 | if (status) |
1197 | return status; |
1198 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &open_conf->oc_seqid) < 0) |
1199 | return nfserr_bad_xdr; |
1200 | |
1201 | memset(&open_conf->oc_resp_stateid, 0, |
1202 | sizeof(open_conf->oc_resp_stateid)); |
1203 | return nfs_ok; |
1204 | } |
1205 | |
1206 | static __be32 |
1207 | nfsd4_decode_open_downgrade(struct nfsd4_compoundargs *argp, |
1208 | union nfsd4_op_u *u) |
1209 | { |
1210 | struct nfsd4_open_downgrade *open_down = &u->open_downgrade; |
1211 | __be32 status; |
1212 | |
1213 | memset(open_down, 0, sizeof(*open_down)); |
1214 | status = nfsd4_decode_stateid4(argp, sid: &open_down->od_stateid); |
1215 | if (status) |
1216 | return status; |
1217 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &open_down->od_seqid) < 0) |
1218 | return nfserr_bad_xdr; |
1219 | /* deleg_want is ignored */ |
1220 | status = nfsd4_decode_share_access(argp, share_access: &open_down->od_share_access, |
1221 | deleg_want: &open_down->od_deleg_want, NULL); |
1222 | if (status) |
1223 | return status; |
1224 | return nfsd4_decode_share_deny(argp, x: &open_down->od_share_deny); |
1225 | } |
1226 | |
1227 | static __be32 |
1228 | nfsd4_decode_putfh(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u) |
1229 | { |
1230 | struct nfsd4_putfh *putfh = &u->putfh; |
1231 | __be32 *p; |
1232 | |
1233 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &putfh->pf_fhlen) < 0) |
1234 | return nfserr_bad_xdr; |
1235 | if (putfh->pf_fhlen > NFS4_FHSIZE) |
1236 | return nfserr_bad_xdr; |
1237 | p = xdr_inline_decode(xdr: argp->xdr, nbytes: putfh->pf_fhlen); |
1238 | if (!p) |
1239 | return nfserr_bad_xdr; |
1240 | putfh->pf_fhval = svcxdr_savemem(argp, p, len: putfh->pf_fhlen); |
1241 | if (!putfh->pf_fhval) |
1242 | return nfserr_jukebox; |
1243 | |
1244 | putfh->no_verify = false; |
1245 | return nfs_ok; |
1246 | } |
1247 | |
1248 | static __be32 |
1249 | nfsd4_decode_putpubfh(struct nfsd4_compoundargs *argp, union nfsd4_op_u *p) |
1250 | { |
1251 | if (argp->minorversion == 0) |
1252 | return nfs_ok; |
1253 | return nfserr_notsupp; |
1254 | } |
1255 | |
1256 | static __be32 |
1257 | nfsd4_decode_read(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u) |
1258 | { |
1259 | struct nfsd4_read *read = &u->read; |
1260 | __be32 status; |
1261 | |
1262 | memset(read, 0, sizeof(*read)); |
1263 | status = nfsd4_decode_stateid4(argp, sid: &read->rd_stateid); |
1264 | if (status) |
1265 | return status; |
1266 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: &read->rd_offset) < 0) |
1267 | return nfserr_bad_xdr; |
1268 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &read->rd_length) < 0) |
1269 | return nfserr_bad_xdr; |
1270 | |
1271 | return nfs_ok; |
1272 | } |
1273 | |
1274 | static __be32 |
1275 | nfsd4_decode_readdir(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u) |
1276 | { |
1277 | struct nfsd4_readdir *readdir = &u->readdir; |
1278 | __be32 status; |
1279 | |
1280 | memset(readdir, 0, sizeof(*readdir)); |
1281 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: &readdir->rd_cookie) < 0) |
1282 | return nfserr_bad_xdr; |
1283 | status = nfsd4_decode_verifier4(argp, verf: &readdir->rd_verf); |
1284 | if (status) |
1285 | return status; |
1286 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &readdir->rd_dircount) < 0) |
1287 | return nfserr_bad_xdr; |
1288 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &readdir->rd_maxcount) < 0) |
1289 | return nfserr_bad_xdr; |
1290 | if (xdr_stream_decode_uint32_array(xdr: argp->xdr, array: readdir->rd_bmval, |
1291 | ARRAY_SIZE(readdir->rd_bmval)) < 0) |
1292 | return nfserr_bad_xdr; |
1293 | |
1294 | return nfs_ok; |
1295 | } |
1296 | |
1297 | static __be32 |
1298 | nfsd4_decode_remove(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u) |
1299 | { |
1300 | struct nfsd4_remove *remove = &u->remove; |
1301 | memset(&remove->rm_cinfo, 0, sizeof(remove->rm_cinfo)); |
1302 | return nfsd4_decode_component4(argp, namp: &remove->rm_name, lenp: &remove->rm_namelen); |
1303 | } |
1304 | |
1305 | static __be32 |
1306 | nfsd4_decode_rename(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u) |
1307 | { |
1308 | struct nfsd4_rename *rename = &u->rename; |
1309 | __be32 status; |
1310 | |
1311 | memset(rename, 0, sizeof(*rename)); |
1312 | status = nfsd4_decode_component4(argp, namp: &rename->rn_sname, lenp: &rename->rn_snamelen); |
1313 | if (status) |
1314 | return status; |
1315 | return nfsd4_decode_component4(argp, namp: &rename->rn_tname, lenp: &rename->rn_tnamelen); |
1316 | } |
1317 | |
1318 | static __be32 |
1319 | nfsd4_decode_renew(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u) |
1320 | { |
1321 | clientid_t *clientid = &u->renew; |
1322 | return nfsd4_decode_clientid4(argp, clientid); |
1323 | } |
1324 | |
1325 | static __be32 |
1326 | nfsd4_decode_secinfo(struct nfsd4_compoundargs *argp, |
1327 | union nfsd4_op_u *u) |
1328 | { |
1329 | struct nfsd4_secinfo *secinfo = &u->secinfo; |
1330 | secinfo->si_exp = NULL; |
1331 | return nfsd4_decode_component4(argp, namp: &secinfo->si_name, lenp: &secinfo->si_namelen); |
1332 | } |
1333 | |
1334 | static __be32 |
1335 | nfsd4_decode_setattr(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u) |
1336 | { |
1337 | struct nfsd4_setattr *setattr = &u->setattr; |
1338 | __be32 status; |
1339 | |
1340 | memset(setattr, 0, sizeof(*setattr)); |
1341 | status = nfsd4_decode_stateid4(argp, sid: &setattr->sa_stateid); |
1342 | if (status) |
1343 | return status; |
1344 | return nfsd4_decode_fattr4(argp, bmval: setattr->sa_bmval, |
1345 | ARRAY_SIZE(setattr->sa_bmval), |
1346 | iattr: &setattr->sa_iattr, acl: &setattr->sa_acl, |
1347 | label: &setattr->sa_label, NULL); |
1348 | } |
1349 | |
1350 | static __be32 |
1351 | nfsd4_decode_setclientid(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u) |
1352 | { |
1353 | struct nfsd4_setclientid *setclientid = &u->setclientid; |
1354 | __be32 *p, status; |
1355 | |
1356 | memset(setclientid, 0, sizeof(*setclientid)); |
1357 | |
1358 | if (argp->minorversion >= 1) |
1359 | return nfserr_notsupp; |
1360 | |
1361 | status = nfsd4_decode_verifier4(argp, verf: &setclientid->se_verf); |
1362 | if (status) |
1363 | return status; |
1364 | status = nfsd4_decode_opaque(argp, o: &setclientid->se_name); |
1365 | if (status) |
1366 | return status; |
1367 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &setclientid->se_callback_prog) < 0) |
1368 | return nfserr_bad_xdr; |
1369 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &setclientid->se_callback_netid_len) < 0) |
1370 | return nfserr_bad_xdr; |
1371 | p = xdr_inline_decode(xdr: argp->xdr, nbytes: setclientid->se_callback_netid_len); |
1372 | if (!p) |
1373 | return nfserr_bad_xdr; |
1374 | setclientid->se_callback_netid_val = svcxdr_savemem(argp, p, |
1375 | len: setclientid->se_callback_netid_len); |
1376 | if (!setclientid->se_callback_netid_val) |
1377 | return nfserr_jukebox; |
1378 | |
1379 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &setclientid->se_callback_addr_len) < 0) |
1380 | return nfserr_bad_xdr; |
1381 | p = xdr_inline_decode(xdr: argp->xdr, nbytes: setclientid->se_callback_addr_len); |
1382 | if (!p) |
1383 | return nfserr_bad_xdr; |
1384 | setclientid->se_callback_addr_val = svcxdr_savemem(argp, p, |
1385 | len: setclientid->se_callback_addr_len); |
1386 | if (!setclientid->se_callback_addr_val) |
1387 | return nfserr_jukebox; |
1388 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &setclientid->se_callback_ident) < 0) |
1389 | return nfserr_bad_xdr; |
1390 | |
1391 | return nfs_ok; |
1392 | } |
1393 | |
1394 | static __be32 |
1395 | nfsd4_decode_setclientid_confirm(struct nfsd4_compoundargs *argp, |
1396 | union nfsd4_op_u *u) |
1397 | { |
1398 | struct nfsd4_setclientid_confirm *scd_c = &u->setclientid_confirm; |
1399 | __be32 status; |
1400 | |
1401 | if (argp->minorversion >= 1) |
1402 | return nfserr_notsupp; |
1403 | |
1404 | status = nfsd4_decode_clientid4(argp, clientid: &scd_c->sc_clientid); |
1405 | if (status) |
1406 | return status; |
1407 | return nfsd4_decode_verifier4(argp, verf: &scd_c->sc_confirm); |
1408 | } |
1409 | |
1410 | /* Also used for NVERIFY */ |
1411 | static __be32 |
1412 | nfsd4_decode_verify(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u) |
1413 | { |
1414 | struct nfsd4_verify *verify = &u->verify; |
1415 | __be32 *p, status; |
1416 | |
1417 | memset(verify, 0, sizeof(*verify)); |
1418 | |
1419 | status = nfsd4_decode_bitmap4(argp, bmval: verify->ve_bmval, |
1420 | ARRAY_SIZE(verify->ve_bmval)); |
1421 | if (status) |
1422 | return status; |
1423 | |
1424 | /* For convenience's sake, we compare raw xdr'd attributes in |
1425 | * nfsd4_proc_verify */ |
1426 | |
1427 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &verify->ve_attrlen) < 0) |
1428 | return nfserr_bad_xdr; |
1429 | p = xdr_inline_decode(xdr: argp->xdr, nbytes: verify->ve_attrlen); |
1430 | if (!p) |
1431 | return nfserr_bad_xdr; |
1432 | verify->ve_attrval = svcxdr_savemem(argp, p, len: verify->ve_attrlen); |
1433 | if (!verify->ve_attrval) |
1434 | return nfserr_jukebox; |
1435 | |
1436 | return nfs_ok; |
1437 | } |
1438 | |
1439 | static __be32 |
1440 | nfsd4_decode_write(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u) |
1441 | { |
1442 | struct nfsd4_write *write = &u->write; |
1443 | __be32 status; |
1444 | |
1445 | status = nfsd4_decode_stateid4(argp, sid: &write->wr_stateid); |
1446 | if (status) |
1447 | return status; |
1448 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: &write->wr_offset) < 0) |
1449 | return nfserr_bad_xdr; |
1450 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &write->wr_stable_how) < 0) |
1451 | return nfserr_bad_xdr; |
1452 | if (write->wr_stable_how > NFS_FILE_SYNC) |
1453 | return nfserr_bad_xdr; |
1454 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &write->wr_buflen) < 0) |
1455 | return nfserr_bad_xdr; |
1456 | if (!xdr_stream_subsegment(xdr: argp->xdr, subbuf: &write->wr_payload, len: write->wr_buflen)) |
1457 | return nfserr_bad_xdr; |
1458 | |
1459 | write->wr_bytes_written = 0; |
1460 | write->wr_how_written = 0; |
1461 | memset(&write->wr_verifier, 0, sizeof(write->wr_verifier)); |
1462 | return nfs_ok; |
1463 | } |
1464 | |
1465 | static __be32 |
1466 | nfsd4_decode_release_lockowner(struct nfsd4_compoundargs *argp, |
1467 | union nfsd4_op_u *u) |
1468 | { |
1469 | struct nfsd4_release_lockowner *rlockowner = &u->release_lockowner; |
1470 | __be32 status; |
1471 | |
1472 | if (argp->minorversion >= 1) |
1473 | return nfserr_notsupp; |
1474 | |
1475 | status = nfsd4_decode_state_owner4(argp, clientid: &rlockowner->rl_clientid, |
1476 | owner: &rlockowner->rl_owner); |
1477 | if (status) |
1478 | return status; |
1479 | |
1480 | if (argp->minorversion && !zero_clientid(clid: &rlockowner->rl_clientid)) |
1481 | return nfserr_inval; |
1482 | |
1483 | return nfs_ok; |
1484 | } |
1485 | |
1486 | static __be32 nfsd4_decode_backchannel_ctl(struct nfsd4_compoundargs *argp, |
1487 | union nfsd4_op_u *u) |
1488 | { |
1489 | struct nfsd4_backchannel_ctl *bc = &u->backchannel_ctl; |
1490 | memset(bc, 0, sizeof(*bc)); |
1491 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &bc->bc_cb_program) < 0) |
1492 | return nfserr_bad_xdr; |
1493 | return nfsd4_decode_cb_sec(argp, cbs: &bc->bc_cb_sec); |
1494 | } |
1495 | |
1496 | static __be32 nfsd4_decode_bind_conn_to_session(struct nfsd4_compoundargs *argp, |
1497 | union nfsd4_op_u *u) |
1498 | { |
1499 | struct nfsd4_bind_conn_to_session *bcts = &u->bind_conn_to_session; |
1500 | u32 use_conn_in_rdma_mode; |
1501 | __be32 status; |
1502 | |
1503 | memset(bcts, 0, sizeof(*bcts)); |
1504 | status = nfsd4_decode_sessionid4(argp, sessionid: &bcts->sessionid); |
1505 | if (status) |
1506 | return status; |
1507 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &bcts->dir) < 0) |
1508 | return nfserr_bad_xdr; |
1509 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &use_conn_in_rdma_mode) < 0) |
1510 | return nfserr_bad_xdr; |
1511 | |
1512 | return nfs_ok; |
1513 | } |
1514 | |
1515 | static __be32 |
1516 | nfsd4_decode_state_protect_ops(struct nfsd4_compoundargs *argp, |
1517 | struct nfsd4_exchange_id *exid) |
1518 | { |
1519 | __be32 status; |
1520 | |
1521 | status = nfsd4_decode_bitmap4(argp, bmval: exid->spo_must_enforce, |
1522 | ARRAY_SIZE(exid->spo_must_enforce)); |
1523 | if (status) |
1524 | return nfserr_bad_xdr; |
1525 | status = nfsd4_decode_bitmap4(argp, bmval: exid->spo_must_allow, |
1526 | ARRAY_SIZE(exid->spo_must_allow)); |
1527 | if (status) |
1528 | return nfserr_bad_xdr; |
1529 | |
1530 | return nfs_ok; |
1531 | } |
1532 | |
1533 | /* |
1534 | * This implementation currently does not support SP4_SSV. |
1535 | * This decoder simply skips over these arguments. |
1536 | */ |
1537 | static noinline __be32 |
1538 | nfsd4_decode_ssv_sp_parms(struct nfsd4_compoundargs *argp, |
1539 | struct nfsd4_exchange_id *exid) |
1540 | { |
1541 | u32 count, window, num_gss_handles; |
1542 | __be32 status; |
1543 | |
1544 | /* ssp_ops */ |
1545 | status = nfsd4_decode_state_protect_ops(argp, exid); |
1546 | if (status) |
1547 | return status; |
1548 | |
1549 | /* ssp_hash_algs<> */ |
1550 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &count) < 0) |
1551 | return nfserr_bad_xdr; |
1552 | while (count--) { |
1553 | status = nfsd4_decode_ignored_string(argp, maxlen: 0); |
1554 | if (status) |
1555 | return status; |
1556 | } |
1557 | |
1558 | /* ssp_encr_algs<> */ |
1559 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &count) < 0) |
1560 | return nfserr_bad_xdr; |
1561 | while (count--) { |
1562 | status = nfsd4_decode_ignored_string(argp, maxlen: 0); |
1563 | if (status) |
1564 | return status; |
1565 | } |
1566 | |
1567 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &window) < 0) |
1568 | return nfserr_bad_xdr; |
1569 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &num_gss_handles) < 0) |
1570 | return nfserr_bad_xdr; |
1571 | |
1572 | return nfs_ok; |
1573 | } |
1574 | |
1575 | static __be32 |
1576 | nfsd4_decode_state_protect4_a(struct nfsd4_compoundargs *argp, |
1577 | struct nfsd4_exchange_id *exid) |
1578 | { |
1579 | __be32 status; |
1580 | |
1581 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &exid->spa_how) < 0) |
1582 | return nfserr_bad_xdr; |
1583 | switch (exid->spa_how) { |
1584 | case SP4_NONE: |
1585 | break; |
1586 | case SP4_MACH_CRED: |
1587 | status = nfsd4_decode_state_protect_ops(argp, exid); |
1588 | if (status) |
1589 | return status; |
1590 | break; |
1591 | case SP4_SSV: |
1592 | status = nfsd4_decode_ssv_sp_parms(argp, exid); |
1593 | if (status) |
1594 | return status; |
1595 | break; |
1596 | default: |
1597 | return nfserr_bad_xdr; |
1598 | } |
1599 | |
1600 | return nfs_ok; |
1601 | } |
1602 | |
1603 | static __be32 |
1604 | nfsd4_decode_nfs_impl_id4(struct nfsd4_compoundargs *argp, |
1605 | struct nfsd4_exchange_id *exid) |
1606 | { |
1607 | __be32 status; |
1608 | u32 count; |
1609 | |
1610 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &count) < 0) |
1611 | return nfserr_bad_xdr; |
1612 | switch (count) { |
1613 | case 0: |
1614 | break; |
1615 | case 1: |
1616 | /* Note that RFC 8881 places no length limit on |
1617 | * nii_domain, but this implementation permits no |
1618 | * more than NFS4_OPAQUE_LIMIT bytes */ |
1619 | status = nfsd4_decode_opaque(argp, o: &exid->nii_domain); |
1620 | if (status) |
1621 | return status; |
1622 | /* Note that RFC 8881 places no length limit on |
1623 | * nii_name, but this implementation permits no |
1624 | * more than NFS4_OPAQUE_LIMIT bytes */ |
1625 | status = nfsd4_decode_opaque(argp, o: &exid->nii_name); |
1626 | if (status) |
1627 | return status; |
1628 | status = nfsd4_decode_nfstime4(argp, tv: &exid->nii_time); |
1629 | if (status) |
1630 | return status; |
1631 | break; |
1632 | default: |
1633 | return nfserr_bad_xdr; |
1634 | } |
1635 | |
1636 | return nfs_ok; |
1637 | } |
1638 | |
1639 | static __be32 |
1640 | nfsd4_decode_exchange_id(struct nfsd4_compoundargs *argp, |
1641 | union nfsd4_op_u *u) |
1642 | { |
1643 | struct nfsd4_exchange_id *exid = &u->exchange_id; |
1644 | __be32 status; |
1645 | |
1646 | memset(exid, 0, sizeof(*exid)); |
1647 | status = nfsd4_decode_verifier4(argp, verf: &exid->verifier); |
1648 | if (status) |
1649 | return status; |
1650 | status = nfsd4_decode_opaque(argp, o: &exid->clname); |
1651 | if (status) |
1652 | return status; |
1653 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &exid->flags) < 0) |
1654 | return nfserr_bad_xdr; |
1655 | status = nfsd4_decode_state_protect4_a(argp, exid); |
1656 | if (status) |
1657 | return status; |
1658 | return nfsd4_decode_nfs_impl_id4(argp, exid); |
1659 | } |
1660 | |
1661 | static __be32 |
1662 | nfsd4_decode_channel_attrs4(struct nfsd4_compoundargs *argp, |
1663 | struct nfsd4_channel_attrs *ca) |
1664 | { |
1665 | __be32 *p; |
1666 | |
1667 | p = xdr_inline_decode(xdr: argp->xdr, XDR_UNIT * 7); |
1668 | if (!p) |
1669 | return nfserr_bad_xdr; |
1670 | |
1671 | /* headerpadsz is ignored */ |
1672 | p++; |
1673 | ca->maxreq_sz = be32_to_cpup(p: p++); |
1674 | ca->maxresp_sz = be32_to_cpup(p: p++); |
1675 | ca->maxresp_cached = be32_to_cpup(p: p++); |
1676 | ca->maxops = be32_to_cpup(p: p++); |
1677 | ca->maxreqs = be32_to_cpup(p: p++); |
1678 | ca->nr_rdma_attrs = be32_to_cpup(p); |
1679 | switch (ca->nr_rdma_attrs) { |
1680 | case 0: |
1681 | break; |
1682 | case 1: |
1683 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &ca->rdma_attrs) < 0) |
1684 | return nfserr_bad_xdr; |
1685 | break; |
1686 | default: |
1687 | return nfserr_bad_xdr; |
1688 | } |
1689 | |
1690 | return nfs_ok; |
1691 | } |
1692 | |
1693 | static __be32 |
1694 | nfsd4_decode_create_session(struct nfsd4_compoundargs *argp, |
1695 | union nfsd4_op_u *u) |
1696 | { |
1697 | struct nfsd4_create_session *sess = &u->create_session; |
1698 | __be32 status; |
1699 | |
1700 | memset(sess, 0, sizeof(*sess)); |
1701 | status = nfsd4_decode_clientid4(argp, clientid: &sess->clientid); |
1702 | if (status) |
1703 | return status; |
1704 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &sess->seqid) < 0) |
1705 | return nfserr_bad_xdr; |
1706 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &sess->flags) < 0) |
1707 | return nfserr_bad_xdr; |
1708 | status = nfsd4_decode_channel_attrs4(argp, ca: &sess->fore_channel); |
1709 | if (status) |
1710 | return status; |
1711 | status = nfsd4_decode_channel_attrs4(argp, ca: &sess->back_channel); |
1712 | if (status) |
1713 | return status; |
1714 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &sess->callback_prog) < 0) |
1715 | return nfserr_bad_xdr; |
1716 | return nfsd4_decode_cb_sec(argp, cbs: &sess->cb_sec); |
1717 | } |
1718 | |
1719 | static __be32 |
1720 | nfsd4_decode_destroy_session(struct nfsd4_compoundargs *argp, |
1721 | union nfsd4_op_u *u) |
1722 | { |
1723 | struct nfsd4_destroy_session *destroy_session = &u->destroy_session; |
1724 | return nfsd4_decode_sessionid4(argp, sessionid: &destroy_session->sessionid); |
1725 | } |
1726 | |
1727 | static __be32 |
1728 | nfsd4_decode_free_stateid(struct nfsd4_compoundargs *argp, |
1729 | union nfsd4_op_u *u) |
1730 | { |
1731 | struct nfsd4_free_stateid *free_stateid = &u->free_stateid; |
1732 | return nfsd4_decode_stateid4(argp, sid: &free_stateid->fr_stateid); |
1733 | } |
1734 | |
1735 | #ifdef CONFIG_NFSD_PNFS |
1736 | static __be32 |
1737 | nfsd4_decode_getdeviceinfo(struct nfsd4_compoundargs *argp, |
1738 | union nfsd4_op_u *u) |
1739 | { |
1740 | struct nfsd4_getdeviceinfo *gdev = &u->getdeviceinfo; |
1741 | __be32 status; |
1742 | |
1743 | memset(gdev, 0, sizeof(*gdev)); |
1744 | status = nfsd4_decode_deviceid4(argp, devid: &gdev->gd_devid); |
1745 | if (status) |
1746 | return status; |
1747 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &gdev->gd_layout_type) < 0) |
1748 | return nfserr_bad_xdr; |
1749 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &gdev->gd_maxcount) < 0) |
1750 | return nfserr_bad_xdr; |
1751 | if (xdr_stream_decode_uint32_array(xdr: argp->xdr, |
1752 | array: &gdev->gd_notify_types, array_size: 1) < 0) |
1753 | return nfserr_bad_xdr; |
1754 | |
1755 | return nfs_ok; |
1756 | } |
1757 | |
1758 | static __be32 |
1759 | nfsd4_decode_layoutcommit(struct nfsd4_compoundargs *argp, |
1760 | union nfsd4_op_u *u) |
1761 | { |
1762 | struct nfsd4_layoutcommit *lcp = &u->layoutcommit; |
1763 | __be32 *p, status; |
1764 | |
1765 | memset(lcp, 0, sizeof(*lcp)); |
1766 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: &lcp->lc_seg.offset) < 0) |
1767 | return nfserr_bad_xdr; |
1768 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: &lcp->lc_seg.length) < 0) |
1769 | return nfserr_bad_xdr; |
1770 | if (xdr_stream_decode_bool(xdr: argp->xdr, ptr: &lcp->lc_reclaim) < 0) |
1771 | return nfserr_bad_xdr; |
1772 | status = nfsd4_decode_stateid4(argp, sid: &lcp->lc_sid); |
1773 | if (status) |
1774 | return status; |
1775 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &lcp->lc_newoffset) < 0) |
1776 | return nfserr_bad_xdr; |
1777 | if (lcp->lc_newoffset) { |
1778 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: &lcp->lc_last_wr) < 0) |
1779 | return nfserr_bad_xdr; |
1780 | } else |
1781 | lcp->lc_last_wr = 0; |
1782 | p = xdr_inline_decode(xdr: argp->xdr, XDR_UNIT); |
1783 | if (!p) |
1784 | return nfserr_bad_xdr; |
1785 | if (xdr_item_is_present(p)) { |
1786 | status = nfsd4_decode_nfstime4(argp, tv: &lcp->lc_mtime); |
1787 | if (status) |
1788 | return status; |
1789 | } else { |
1790 | lcp->lc_mtime.tv_nsec = UTIME_NOW; |
1791 | } |
1792 | return nfsd4_decode_layoutupdate4(argp, lcp); |
1793 | } |
1794 | |
1795 | static __be32 |
1796 | nfsd4_decode_layoutget(struct nfsd4_compoundargs *argp, |
1797 | union nfsd4_op_u *u) |
1798 | { |
1799 | struct nfsd4_layoutget *lgp = &u->layoutget; |
1800 | __be32 status; |
1801 | |
1802 | memset(lgp, 0, sizeof(*lgp)); |
1803 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &lgp->lg_signal) < 0) |
1804 | return nfserr_bad_xdr; |
1805 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &lgp->lg_layout_type) < 0) |
1806 | return nfserr_bad_xdr; |
1807 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &lgp->lg_seg.iomode) < 0) |
1808 | return nfserr_bad_xdr; |
1809 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: &lgp->lg_seg.offset) < 0) |
1810 | return nfserr_bad_xdr; |
1811 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: &lgp->lg_seg.length) < 0) |
1812 | return nfserr_bad_xdr; |
1813 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: &lgp->lg_minlength) < 0) |
1814 | return nfserr_bad_xdr; |
1815 | status = nfsd4_decode_stateid4(argp, sid: &lgp->lg_sid); |
1816 | if (status) |
1817 | return status; |
1818 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &lgp->lg_maxcount) < 0) |
1819 | return nfserr_bad_xdr; |
1820 | |
1821 | return nfs_ok; |
1822 | } |
1823 | |
1824 | static __be32 |
1825 | nfsd4_decode_layoutreturn(struct nfsd4_compoundargs *argp, |
1826 | union nfsd4_op_u *u) |
1827 | { |
1828 | struct nfsd4_layoutreturn *lrp = &u->layoutreturn; |
1829 | memset(lrp, 0, sizeof(*lrp)); |
1830 | if (xdr_stream_decode_bool(xdr: argp->xdr, ptr: &lrp->lr_reclaim) < 0) |
1831 | return nfserr_bad_xdr; |
1832 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &lrp->lr_layout_type) < 0) |
1833 | return nfserr_bad_xdr; |
1834 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &lrp->lr_seg.iomode) < 0) |
1835 | return nfserr_bad_xdr; |
1836 | return nfsd4_decode_layoutreturn4(argp, lrp); |
1837 | } |
1838 | #endif /* CONFIG_NFSD_PNFS */ |
1839 | |
1840 | static __be32 nfsd4_decode_secinfo_no_name(struct nfsd4_compoundargs *argp, |
1841 | union nfsd4_op_u *u) |
1842 | { |
1843 | struct nfsd4_secinfo_no_name *sin = &u->secinfo_no_name; |
1844 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &sin->sin_style) < 0) |
1845 | return nfserr_bad_xdr; |
1846 | |
1847 | sin->sin_exp = NULL; |
1848 | return nfs_ok; |
1849 | } |
1850 | |
1851 | static __be32 |
1852 | nfsd4_decode_sequence(struct nfsd4_compoundargs *argp, |
1853 | union nfsd4_op_u *u) |
1854 | { |
1855 | struct nfsd4_sequence *seq = &u->sequence; |
1856 | __be32 *p, status; |
1857 | |
1858 | status = nfsd4_decode_sessionid4(argp, sessionid: &seq->sessionid); |
1859 | if (status) |
1860 | return status; |
1861 | p = xdr_inline_decode(xdr: argp->xdr, XDR_UNIT * 4); |
1862 | if (!p) |
1863 | return nfserr_bad_xdr; |
1864 | seq->seqid = be32_to_cpup(p: p++); |
1865 | seq->slotid = be32_to_cpup(p: p++); |
1866 | seq->maxslots = be32_to_cpup(p: p++); |
1867 | seq->cachethis = be32_to_cpup(p); |
1868 | |
1869 | seq->status_flags = 0; |
1870 | return nfs_ok; |
1871 | } |
1872 | |
1873 | static __be32 |
1874 | nfsd4_decode_test_stateid(struct nfsd4_compoundargs *argp, |
1875 | union nfsd4_op_u *u) |
1876 | { |
1877 | struct nfsd4_test_stateid *test_stateid = &u->test_stateid; |
1878 | struct nfsd4_test_stateid_id *stateid; |
1879 | __be32 status; |
1880 | u32 i; |
1881 | |
1882 | memset(test_stateid, 0, sizeof(*test_stateid)); |
1883 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &test_stateid->ts_num_ids) < 0) |
1884 | return nfserr_bad_xdr; |
1885 | |
1886 | INIT_LIST_HEAD(list: &test_stateid->ts_stateid_list); |
1887 | for (i = 0; i < test_stateid->ts_num_ids; i++) { |
1888 | stateid = svcxdr_tmpalloc(argp, len: sizeof(*stateid)); |
1889 | if (!stateid) |
1890 | return nfserr_jukebox; |
1891 | INIT_LIST_HEAD(list: &stateid->ts_id_list); |
1892 | list_add_tail(new: &stateid->ts_id_list, head: &test_stateid->ts_stateid_list); |
1893 | status = nfsd4_decode_stateid4(argp, sid: &stateid->ts_id_stateid); |
1894 | if (status) |
1895 | return status; |
1896 | } |
1897 | |
1898 | return nfs_ok; |
1899 | } |
1900 | |
1901 | static __be32 nfsd4_decode_destroy_clientid(struct nfsd4_compoundargs *argp, |
1902 | union nfsd4_op_u *u) |
1903 | { |
1904 | struct nfsd4_destroy_clientid *dc = &u->destroy_clientid; |
1905 | return nfsd4_decode_clientid4(argp, clientid: &dc->clientid); |
1906 | } |
1907 | |
1908 | static __be32 nfsd4_decode_reclaim_complete(struct nfsd4_compoundargs *argp, |
1909 | union nfsd4_op_u *u) |
1910 | { |
1911 | struct nfsd4_reclaim_complete *rc = &u->reclaim_complete; |
1912 | if (xdr_stream_decode_bool(xdr: argp->xdr, ptr: &rc->rca_one_fs) < 0) |
1913 | return nfserr_bad_xdr; |
1914 | return nfs_ok; |
1915 | } |
1916 | |
1917 | static __be32 |
1918 | nfsd4_decode_fallocate(struct nfsd4_compoundargs *argp, |
1919 | union nfsd4_op_u *u) |
1920 | { |
1921 | struct nfsd4_fallocate *fallocate = &u->allocate; |
1922 | __be32 status; |
1923 | |
1924 | status = nfsd4_decode_stateid4(argp, sid: &fallocate->falloc_stateid); |
1925 | if (status) |
1926 | return status; |
1927 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: &fallocate->falloc_offset) < 0) |
1928 | return nfserr_bad_xdr; |
1929 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: &fallocate->falloc_length) < 0) |
1930 | return nfserr_bad_xdr; |
1931 | |
1932 | return nfs_ok; |
1933 | } |
1934 | |
1935 | static __be32 nfsd4_decode_nl4_server(struct nfsd4_compoundargs *argp, |
1936 | struct nl4_server *ns) |
1937 | { |
1938 | struct nfs42_netaddr *naddr; |
1939 | __be32 *p; |
1940 | |
1941 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &ns->nl4_type) < 0) |
1942 | return nfserr_bad_xdr; |
1943 | |
1944 | /* currently support for 1 inter-server source server */ |
1945 | switch (ns->nl4_type) { |
1946 | case NL4_NETADDR: |
1947 | naddr = &ns->u.nl4_addr; |
1948 | |
1949 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &naddr->netid_len) < 0) |
1950 | return nfserr_bad_xdr; |
1951 | if (naddr->netid_len > RPCBIND_MAXNETIDLEN) |
1952 | return nfserr_bad_xdr; |
1953 | |
1954 | p = xdr_inline_decode(xdr: argp->xdr, nbytes: naddr->netid_len); |
1955 | if (!p) |
1956 | return nfserr_bad_xdr; |
1957 | memcpy(naddr->netid, p, naddr->netid_len); |
1958 | |
1959 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &naddr->addr_len) < 0) |
1960 | return nfserr_bad_xdr; |
1961 | if (naddr->addr_len > RPCBIND_MAXUADDRLEN) |
1962 | return nfserr_bad_xdr; |
1963 | |
1964 | p = xdr_inline_decode(xdr: argp->xdr, nbytes: naddr->addr_len); |
1965 | if (!p) |
1966 | return nfserr_bad_xdr; |
1967 | memcpy(naddr->addr, p, naddr->addr_len); |
1968 | break; |
1969 | default: |
1970 | return nfserr_bad_xdr; |
1971 | } |
1972 | |
1973 | return nfs_ok; |
1974 | } |
1975 | |
1976 | static __be32 |
1977 | nfsd4_decode_copy(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u) |
1978 | { |
1979 | struct nfsd4_copy *copy = &u->copy; |
1980 | u32 consecutive, i, count, sync; |
1981 | struct nl4_server *ns_dummy; |
1982 | __be32 status; |
1983 | |
1984 | memset(copy, 0, sizeof(*copy)); |
1985 | status = nfsd4_decode_stateid4(argp, sid: ©->cp_src_stateid); |
1986 | if (status) |
1987 | return status; |
1988 | status = nfsd4_decode_stateid4(argp, sid: ©->cp_dst_stateid); |
1989 | if (status) |
1990 | return status; |
1991 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: ©->cp_src_pos) < 0) |
1992 | return nfserr_bad_xdr; |
1993 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: ©->cp_dst_pos) < 0) |
1994 | return nfserr_bad_xdr; |
1995 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: ©->cp_count) < 0) |
1996 | return nfserr_bad_xdr; |
1997 | /* ca_consecutive: we always do consecutive copies */ |
1998 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &consecutive) < 0) |
1999 | return nfserr_bad_xdr; |
2000 | if (xdr_stream_decode_bool(xdr: argp->xdr, ptr: &sync) < 0) |
2001 | return nfserr_bad_xdr; |
2002 | nfsd4_copy_set_sync(copy, sync); |
2003 | |
2004 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &count) < 0) |
2005 | return nfserr_bad_xdr; |
2006 | copy->cp_src = svcxdr_tmpalloc(argp, len: sizeof(*copy->cp_src)); |
2007 | if (copy->cp_src == NULL) |
2008 | return nfserr_jukebox; |
2009 | if (count == 0) { /* intra-server copy */ |
2010 | __set_bit(NFSD4_COPY_F_INTRA, ©->cp_flags); |
2011 | return nfs_ok; |
2012 | } |
2013 | |
2014 | /* decode all the supplied server addresses but use only the first */ |
2015 | status = nfsd4_decode_nl4_server(argp, ns: copy->cp_src); |
2016 | if (status) |
2017 | return status; |
2018 | |
2019 | ns_dummy = kmalloc(size: sizeof(struct nl4_server), GFP_KERNEL); |
2020 | if (ns_dummy == NULL) |
2021 | return nfserr_jukebox; |
2022 | for (i = 0; i < count - 1; i++) { |
2023 | status = nfsd4_decode_nl4_server(argp, ns: ns_dummy); |
2024 | if (status) { |
2025 | kfree(objp: ns_dummy); |
2026 | return status; |
2027 | } |
2028 | } |
2029 | kfree(objp: ns_dummy); |
2030 | |
2031 | return nfs_ok; |
2032 | } |
2033 | |
2034 | static __be32 |
2035 | nfsd4_decode_copy_notify(struct nfsd4_compoundargs *argp, |
2036 | union nfsd4_op_u *u) |
2037 | { |
2038 | struct nfsd4_copy_notify *cn = &u->copy_notify; |
2039 | __be32 status; |
2040 | |
2041 | memset(cn, 0, sizeof(*cn)); |
2042 | cn->cpn_src = svcxdr_tmpalloc(argp, len: sizeof(*cn->cpn_src)); |
2043 | if (cn->cpn_src == NULL) |
2044 | return nfserr_jukebox; |
2045 | cn->cpn_dst = svcxdr_tmpalloc(argp, len: sizeof(*cn->cpn_dst)); |
2046 | if (cn->cpn_dst == NULL) |
2047 | return nfserr_jukebox; |
2048 | |
2049 | status = nfsd4_decode_stateid4(argp, sid: &cn->cpn_src_stateid); |
2050 | if (status) |
2051 | return status; |
2052 | return nfsd4_decode_nl4_server(argp, ns: cn->cpn_dst); |
2053 | } |
2054 | |
2055 | static __be32 |
2056 | nfsd4_decode_offload_status(struct nfsd4_compoundargs *argp, |
2057 | union nfsd4_op_u *u) |
2058 | { |
2059 | struct nfsd4_offload_status *os = &u->offload_status; |
2060 | os->count = 0; |
2061 | os->status = 0; |
2062 | return nfsd4_decode_stateid4(argp, sid: &os->stateid); |
2063 | } |
2064 | |
2065 | static __be32 |
2066 | nfsd4_decode_seek(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u) |
2067 | { |
2068 | struct nfsd4_seek *seek = &u->seek; |
2069 | __be32 status; |
2070 | |
2071 | status = nfsd4_decode_stateid4(argp, sid: &seek->seek_stateid); |
2072 | if (status) |
2073 | return status; |
2074 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: &seek->seek_offset) < 0) |
2075 | return nfserr_bad_xdr; |
2076 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &seek->seek_whence) < 0) |
2077 | return nfserr_bad_xdr; |
2078 | |
2079 | seek->seek_eof = 0; |
2080 | seek->seek_pos = 0; |
2081 | return nfs_ok; |
2082 | } |
2083 | |
2084 | static __be32 |
2085 | nfsd4_decode_clone(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u) |
2086 | { |
2087 | struct nfsd4_clone *clone = &u->clone; |
2088 | __be32 status; |
2089 | |
2090 | status = nfsd4_decode_stateid4(argp, sid: &clone->cl_src_stateid); |
2091 | if (status) |
2092 | return status; |
2093 | status = nfsd4_decode_stateid4(argp, sid: &clone->cl_dst_stateid); |
2094 | if (status) |
2095 | return status; |
2096 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: &clone->cl_src_pos) < 0) |
2097 | return nfserr_bad_xdr; |
2098 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: &clone->cl_dst_pos) < 0) |
2099 | return nfserr_bad_xdr; |
2100 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: &clone->cl_count) < 0) |
2101 | return nfserr_bad_xdr; |
2102 | |
2103 | return nfs_ok; |
2104 | } |
2105 | |
2106 | /* |
2107 | * XDR data that is more than PAGE_SIZE in size is normally part of a |
2108 | * read or write. However, the size of extended attributes is limited |
2109 | * by the maximum request size, and then further limited by the underlying |
2110 | * filesystem limits. This can exceed PAGE_SIZE (currently, XATTR_SIZE_MAX |
2111 | * is 64k). Since there is no kvec- or page-based interface to xattrs, |
2112 | * and we're not dealing with contiguous pages, we need to do some copying. |
2113 | */ |
2114 | |
2115 | /* |
2116 | * Decode data into buffer. |
2117 | */ |
2118 | static __be32 |
2119 | nfsd4_vbuf_from_vector(struct nfsd4_compoundargs *argp, struct xdr_buf *xdr, |
2120 | char **bufp, u32 buflen) |
2121 | { |
2122 | struct page **pages = xdr->pages; |
2123 | struct kvec *head = xdr->head; |
2124 | char *tmp, *dp; |
2125 | u32 len; |
2126 | |
2127 | if (buflen <= head->iov_len) { |
2128 | /* |
2129 | * We're in luck, the head has enough space. Just return |
2130 | * the head, no need for copying. |
2131 | */ |
2132 | *bufp = head->iov_base; |
2133 | return 0; |
2134 | } |
2135 | |
2136 | tmp = svcxdr_tmpalloc(argp, len: buflen); |
2137 | if (tmp == NULL) |
2138 | return nfserr_jukebox; |
2139 | |
2140 | dp = tmp; |
2141 | memcpy(dp, head->iov_base, head->iov_len); |
2142 | buflen -= head->iov_len; |
2143 | dp += head->iov_len; |
2144 | |
2145 | while (buflen > 0) { |
2146 | len = min_t(u32, buflen, PAGE_SIZE); |
2147 | memcpy(dp, page_address(*pages), len); |
2148 | |
2149 | buflen -= len; |
2150 | dp += len; |
2151 | pages++; |
2152 | } |
2153 | |
2154 | *bufp = tmp; |
2155 | return 0; |
2156 | } |
2157 | |
2158 | /* |
2159 | * Get a user extended attribute name from the XDR buffer. |
2160 | * It will not have the "user." prefix, so prepend it. |
2161 | * Lastly, check for nul characters in the name. |
2162 | */ |
2163 | static __be32 |
2164 | nfsd4_decode_xattr_name(struct nfsd4_compoundargs *argp, char **namep) |
2165 | { |
2166 | char *name, *sp, *dp; |
2167 | u32 namelen, cnt; |
2168 | __be32 *p; |
2169 | |
2170 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &namelen) < 0) |
2171 | return nfserr_bad_xdr; |
2172 | if (namelen > (XATTR_NAME_MAX - XATTR_USER_PREFIX_LEN)) |
2173 | return nfserr_nametoolong; |
2174 | if (namelen == 0) |
2175 | return nfserr_bad_xdr; |
2176 | p = xdr_inline_decode(xdr: argp->xdr, nbytes: namelen); |
2177 | if (!p) |
2178 | return nfserr_bad_xdr; |
2179 | name = svcxdr_tmpalloc(argp, len: namelen + XATTR_USER_PREFIX_LEN + 1); |
2180 | if (!name) |
2181 | return nfserr_jukebox; |
2182 | memcpy(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN); |
2183 | |
2184 | /* |
2185 | * Copy the extended attribute name over while checking for 0 |
2186 | * characters. |
2187 | */ |
2188 | sp = (char *)p; |
2189 | dp = name + XATTR_USER_PREFIX_LEN; |
2190 | cnt = namelen; |
2191 | |
2192 | while (cnt-- > 0) { |
2193 | if (*sp == '\0') |
2194 | return nfserr_bad_xdr; |
2195 | *dp++ = *sp++; |
2196 | } |
2197 | *dp = '\0'; |
2198 | |
2199 | *namep = name; |
2200 | |
2201 | return nfs_ok; |
2202 | } |
2203 | |
2204 | /* |
2205 | * A GETXATTR op request comes without a length specifier. We just set the |
2206 | * maximum length for the reply based on XATTR_SIZE_MAX and the maximum |
2207 | * channel reply size. nfsd_getxattr will probe the length of the xattr, |
2208 | * check it against getxa_len, and allocate + return the value. |
2209 | */ |
2210 | static __be32 |
2211 | nfsd4_decode_getxattr(struct nfsd4_compoundargs *argp, |
2212 | union nfsd4_op_u *u) |
2213 | { |
2214 | struct nfsd4_getxattr *getxattr = &u->getxattr; |
2215 | __be32 status; |
2216 | u32 maxcount; |
2217 | |
2218 | memset(getxattr, 0, sizeof(*getxattr)); |
2219 | status = nfsd4_decode_xattr_name(argp, namep: &getxattr->getxa_name); |
2220 | if (status) |
2221 | return status; |
2222 | |
2223 | maxcount = svc_max_payload(rqstp: argp->rqstp); |
2224 | maxcount = min_t(u32, XATTR_SIZE_MAX, maxcount); |
2225 | |
2226 | getxattr->getxa_len = maxcount; |
2227 | return nfs_ok; |
2228 | } |
2229 | |
2230 | static __be32 |
2231 | nfsd4_decode_setxattr(struct nfsd4_compoundargs *argp, |
2232 | union nfsd4_op_u *u) |
2233 | { |
2234 | struct nfsd4_setxattr *setxattr = &u->setxattr; |
2235 | u32 flags, maxcount, size; |
2236 | __be32 status; |
2237 | |
2238 | memset(setxattr, 0, sizeof(*setxattr)); |
2239 | |
2240 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &flags) < 0) |
2241 | return nfserr_bad_xdr; |
2242 | |
2243 | if (flags > SETXATTR4_REPLACE) |
2244 | return nfserr_inval; |
2245 | setxattr->setxa_flags = flags; |
2246 | |
2247 | status = nfsd4_decode_xattr_name(argp, namep: &setxattr->setxa_name); |
2248 | if (status) |
2249 | return status; |
2250 | |
2251 | maxcount = svc_max_payload(rqstp: argp->rqstp); |
2252 | maxcount = min_t(u32, XATTR_SIZE_MAX, maxcount); |
2253 | |
2254 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &size) < 0) |
2255 | return nfserr_bad_xdr; |
2256 | if (size > maxcount) |
2257 | return nfserr_xattr2big; |
2258 | |
2259 | setxattr->setxa_len = size; |
2260 | if (size > 0) { |
2261 | struct xdr_buf payload; |
2262 | |
2263 | if (!xdr_stream_subsegment(xdr: argp->xdr, subbuf: &payload, len: size)) |
2264 | return nfserr_bad_xdr; |
2265 | status = nfsd4_vbuf_from_vector(argp, xdr: &payload, |
2266 | bufp: &setxattr->setxa_buf, buflen: size); |
2267 | } |
2268 | |
2269 | return nfs_ok; |
2270 | } |
2271 | |
2272 | static __be32 |
2273 | nfsd4_decode_listxattrs(struct nfsd4_compoundargs *argp, |
2274 | union nfsd4_op_u *u) |
2275 | { |
2276 | struct nfsd4_listxattrs *listxattrs = &u->listxattrs; |
2277 | u32 maxcount; |
2278 | |
2279 | memset(listxattrs, 0, sizeof(*listxattrs)); |
2280 | |
2281 | if (xdr_stream_decode_u64(xdr: argp->xdr, ptr: &listxattrs->lsxa_cookie) < 0) |
2282 | return nfserr_bad_xdr; |
2283 | |
2284 | /* |
2285 | * If the cookie is too large to have even one user.x attribute |
2286 | * plus trailing '\0' left in a maximum size buffer, it's invalid. |
2287 | */ |
2288 | if (listxattrs->lsxa_cookie >= |
2289 | (XATTR_LIST_MAX / (XATTR_USER_PREFIX_LEN + 2))) |
2290 | return nfserr_badcookie; |
2291 | |
2292 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &maxcount) < 0) |
2293 | return nfserr_bad_xdr; |
2294 | if (maxcount < 8) |
2295 | /* Always need at least 2 words (length and one character) */ |
2296 | return nfserr_inval; |
2297 | |
2298 | maxcount = min(maxcount, svc_max_payload(argp->rqstp)); |
2299 | listxattrs->lsxa_maxcount = maxcount; |
2300 | |
2301 | return nfs_ok; |
2302 | } |
2303 | |
2304 | static __be32 |
2305 | nfsd4_decode_removexattr(struct nfsd4_compoundargs *argp, |
2306 | union nfsd4_op_u *u) |
2307 | { |
2308 | struct nfsd4_removexattr *removexattr = &u->removexattr; |
2309 | memset(removexattr, 0, sizeof(*removexattr)); |
2310 | return nfsd4_decode_xattr_name(argp, namep: &removexattr->rmxa_name); |
2311 | } |
2312 | |
2313 | static __be32 |
2314 | nfsd4_decode_noop(struct nfsd4_compoundargs *argp, union nfsd4_op_u *p) |
2315 | { |
2316 | return nfs_ok; |
2317 | } |
2318 | |
2319 | static __be32 |
2320 | nfsd4_decode_notsupp(struct nfsd4_compoundargs *argp, union nfsd4_op_u *p) |
2321 | { |
2322 | return nfserr_notsupp; |
2323 | } |
2324 | |
2325 | typedef __be32(*nfsd4_dec)(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u); |
2326 | |
2327 | static const nfsd4_dec nfsd4_dec_ops[] = { |
2328 | [OP_ACCESS] = nfsd4_decode_access, |
2329 | [OP_CLOSE] = nfsd4_decode_close, |
2330 | [OP_COMMIT] = nfsd4_decode_commit, |
2331 | [OP_CREATE] = nfsd4_decode_create, |
2332 | [OP_DELEGPURGE] = nfsd4_decode_notsupp, |
2333 | [OP_DELEGRETURN] = nfsd4_decode_delegreturn, |
2334 | [OP_GETATTR] = nfsd4_decode_getattr, |
2335 | [OP_GETFH] = nfsd4_decode_noop, |
2336 | [OP_LINK] = nfsd4_decode_link, |
2337 | [OP_LOCK] = nfsd4_decode_lock, |
2338 | [OP_LOCKT] = nfsd4_decode_lockt, |
2339 | [OP_LOCKU] = nfsd4_decode_locku, |
2340 | [OP_LOOKUP] = nfsd4_decode_lookup, |
2341 | [OP_LOOKUPP] = nfsd4_decode_noop, |
2342 | [OP_NVERIFY] = nfsd4_decode_verify, |
2343 | [OP_OPEN] = nfsd4_decode_open, |
2344 | [OP_OPENATTR] = nfsd4_decode_notsupp, |
2345 | [OP_OPEN_CONFIRM] = nfsd4_decode_open_confirm, |
2346 | [OP_OPEN_DOWNGRADE] = nfsd4_decode_open_downgrade, |
2347 | [OP_PUTFH] = nfsd4_decode_putfh, |
2348 | [OP_PUTPUBFH] = nfsd4_decode_putpubfh, |
2349 | [OP_PUTROOTFH] = nfsd4_decode_noop, |
2350 | [OP_READ] = nfsd4_decode_read, |
2351 | [OP_READDIR] = nfsd4_decode_readdir, |
2352 | [OP_READLINK] = nfsd4_decode_noop, |
2353 | [OP_REMOVE] = nfsd4_decode_remove, |
2354 | [OP_RENAME] = nfsd4_decode_rename, |
2355 | [OP_RENEW] = nfsd4_decode_renew, |
2356 | [OP_RESTOREFH] = nfsd4_decode_noop, |
2357 | [OP_SAVEFH] = nfsd4_decode_noop, |
2358 | [OP_SECINFO] = nfsd4_decode_secinfo, |
2359 | [OP_SETATTR] = nfsd4_decode_setattr, |
2360 | [OP_SETCLIENTID] = nfsd4_decode_setclientid, |
2361 | [OP_SETCLIENTID_CONFIRM] = nfsd4_decode_setclientid_confirm, |
2362 | [OP_VERIFY] = nfsd4_decode_verify, |
2363 | [OP_WRITE] = nfsd4_decode_write, |
2364 | [OP_RELEASE_LOCKOWNER] = nfsd4_decode_release_lockowner, |
2365 | |
2366 | /* new operations for NFSv4.1 */ |
2367 | [OP_BACKCHANNEL_CTL] = nfsd4_decode_backchannel_ctl, |
2368 | [OP_BIND_CONN_TO_SESSION] = nfsd4_decode_bind_conn_to_session, |
2369 | [OP_EXCHANGE_ID] = nfsd4_decode_exchange_id, |
2370 | [OP_CREATE_SESSION] = nfsd4_decode_create_session, |
2371 | [OP_DESTROY_SESSION] = nfsd4_decode_destroy_session, |
2372 | [OP_FREE_STATEID] = nfsd4_decode_free_stateid, |
2373 | [OP_GET_DIR_DELEGATION] = nfsd4_decode_notsupp, |
2374 | #ifdef CONFIG_NFSD_PNFS |
2375 | [OP_GETDEVICEINFO] = nfsd4_decode_getdeviceinfo, |
2376 | [OP_GETDEVICELIST] = nfsd4_decode_notsupp, |
2377 | [OP_LAYOUTCOMMIT] = nfsd4_decode_layoutcommit, |
2378 | [OP_LAYOUTGET] = nfsd4_decode_layoutget, |
2379 | [OP_LAYOUTRETURN] = nfsd4_decode_layoutreturn, |
2380 | #else |
2381 | [OP_GETDEVICEINFO] = nfsd4_decode_notsupp, |
2382 | [OP_GETDEVICELIST] = nfsd4_decode_notsupp, |
2383 | [OP_LAYOUTCOMMIT] = nfsd4_decode_notsupp, |
2384 | [OP_LAYOUTGET] = nfsd4_decode_notsupp, |
2385 | [OP_LAYOUTRETURN] = nfsd4_decode_notsupp, |
2386 | #endif |
2387 | [OP_SECINFO_NO_NAME] = nfsd4_decode_secinfo_no_name, |
2388 | [OP_SEQUENCE] = nfsd4_decode_sequence, |
2389 | [OP_SET_SSV] = nfsd4_decode_notsupp, |
2390 | [OP_TEST_STATEID] = nfsd4_decode_test_stateid, |
2391 | [OP_WANT_DELEGATION] = nfsd4_decode_notsupp, |
2392 | [OP_DESTROY_CLIENTID] = nfsd4_decode_destroy_clientid, |
2393 | [OP_RECLAIM_COMPLETE] = nfsd4_decode_reclaim_complete, |
2394 | |
2395 | /* new operations for NFSv4.2 */ |
2396 | [OP_ALLOCATE] = nfsd4_decode_fallocate, |
2397 | [OP_COPY] = nfsd4_decode_copy, |
2398 | [OP_COPY_NOTIFY] = nfsd4_decode_copy_notify, |
2399 | [OP_DEALLOCATE] = nfsd4_decode_fallocate, |
2400 | [OP_IO_ADVISE] = nfsd4_decode_notsupp, |
2401 | [OP_LAYOUTERROR] = nfsd4_decode_notsupp, |
2402 | [OP_LAYOUTSTATS] = nfsd4_decode_notsupp, |
2403 | [OP_OFFLOAD_CANCEL] = nfsd4_decode_offload_status, |
2404 | [OP_OFFLOAD_STATUS] = nfsd4_decode_offload_status, |
2405 | [OP_READ_PLUS] = nfsd4_decode_read, |
2406 | [OP_SEEK] = nfsd4_decode_seek, |
2407 | [OP_WRITE_SAME] = nfsd4_decode_notsupp, |
2408 | [OP_CLONE] = nfsd4_decode_clone, |
2409 | /* RFC 8276 extended atributes operations */ |
2410 | [OP_GETXATTR] = nfsd4_decode_getxattr, |
2411 | [OP_SETXATTR] = nfsd4_decode_setxattr, |
2412 | [OP_LISTXATTRS] = nfsd4_decode_listxattrs, |
2413 | [OP_REMOVEXATTR] = nfsd4_decode_removexattr, |
2414 | }; |
2415 | |
2416 | static inline bool |
2417 | nfsd4_opnum_in_range(struct nfsd4_compoundargs *argp, struct nfsd4_op *op) |
2418 | { |
2419 | if (op->opnum < FIRST_NFS4_OP) |
2420 | return false; |
2421 | else if (argp->minorversion == 0 && op->opnum > LAST_NFS40_OP) |
2422 | return false; |
2423 | else if (argp->minorversion == 1 && op->opnum > LAST_NFS41_OP) |
2424 | return false; |
2425 | else if (argp->minorversion == 2 && op->opnum > LAST_NFS42_OP) |
2426 | return false; |
2427 | return true; |
2428 | } |
2429 | |
2430 | static bool |
2431 | nfsd4_decode_compound(struct nfsd4_compoundargs *argp) |
2432 | { |
2433 | struct nfsd4_op *op; |
2434 | bool cachethis = false; |
2435 | int auth_slack= argp->rqstp->rq_auth_slack; |
2436 | int max_reply = auth_slack + 8; /* opcnt, status */ |
2437 | int readcount = 0; |
2438 | int readbytes = 0; |
2439 | __be32 *p; |
2440 | int i; |
2441 | |
2442 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &argp->taglen) < 0) |
2443 | return false; |
2444 | max_reply += XDR_UNIT; |
2445 | argp->tag = NULL; |
2446 | if (unlikely(argp->taglen)) { |
2447 | if (argp->taglen > NFSD4_MAX_TAGLEN) |
2448 | return false; |
2449 | p = xdr_inline_decode(xdr: argp->xdr, nbytes: argp->taglen); |
2450 | if (!p) |
2451 | return false; |
2452 | argp->tag = svcxdr_savemem(argp, p, len: argp->taglen); |
2453 | if (!argp->tag) |
2454 | return false; |
2455 | max_reply += xdr_align_size(n: argp->taglen); |
2456 | } |
2457 | |
2458 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &argp->minorversion) < 0) |
2459 | return false; |
2460 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &argp->client_opcnt) < 0) |
2461 | return false; |
2462 | argp->opcnt = min_t(u32, argp->client_opcnt, |
2463 | NFSD_MAX_OPS_PER_COMPOUND); |
2464 | |
2465 | if (argp->opcnt > ARRAY_SIZE(argp->iops)) { |
2466 | argp->ops = vcalloc(n: argp->opcnt, size: sizeof(*argp->ops)); |
2467 | if (!argp->ops) { |
2468 | argp->ops = argp->iops; |
2469 | return false; |
2470 | } |
2471 | } |
2472 | |
2473 | if (argp->minorversion > NFSD_SUPPORTED_MINOR_VERSION) |
2474 | argp->opcnt = 0; |
2475 | |
2476 | for (i = 0; i < argp->opcnt; i++) { |
2477 | op = &argp->ops[i]; |
2478 | op->replay = NULL; |
2479 | op->opdesc = NULL; |
2480 | |
2481 | if (xdr_stream_decode_u32(xdr: argp->xdr, ptr: &op->opnum) < 0) |
2482 | return false; |
2483 | if (nfsd4_opnum_in_range(argp, op)) { |
2484 | op->opdesc = OPDESC(op); |
2485 | op->status = nfsd4_dec_ops[op->opnum](argp, &op->u); |
2486 | if (op->status != nfs_ok) |
2487 | trace_nfsd_compound_decode_err(rqstp: argp->rqstp, |
2488 | args_opcnt: argp->opcnt, resp_opcnt: i, |
2489 | opnum: op->opnum, |
2490 | status: op->status); |
2491 | } else { |
2492 | op->opnum = OP_ILLEGAL; |
2493 | op->status = nfserr_op_illegal; |
2494 | } |
2495 | |
2496 | /* |
2497 | * We'll try to cache the result in the DRC if any one |
2498 | * op in the compound wants to be cached: |
2499 | */ |
2500 | cachethis |= nfsd4_cache_this_op(op); |
2501 | |
2502 | if (op->opnum == OP_READ || op->opnum == OP_READ_PLUS) { |
2503 | readcount++; |
2504 | readbytes += nfsd4_max_reply(rqstp: argp->rqstp, op); |
2505 | } else |
2506 | max_reply += nfsd4_max_reply(rqstp: argp->rqstp, op); |
2507 | /* |
2508 | * OP_LOCK and OP_LOCKT may return a conflicting lock. |
2509 | * (Special case because it will just skip encoding this |
2510 | * if it runs out of xdr buffer space, and it is the only |
2511 | * operation that behaves this way.) |
2512 | */ |
2513 | if (op->opnum == OP_LOCK || op->opnum == OP_LOCKT) |
2514 | max_reply += NFS4_OPAQUE_LIMIT; |
2515 | |
2516 | if (op->status) { |
2517 | argp->opcnt = i+1; |
2518 | break; |
2519 | } |
2520 | } |
2521 | /* Sessions make the DRC unnecessary: */ |
2522 | if (argp->minorversion) |
2523 | cachethis = false; |
2524 | svc_reserve(rqstp: argp->rqstp, space: max_reply + readbytes); |
2525 | argp->rqstp->rq_cachetype = cachethis ? RC_REPLBUFF : RC_NOCACHE; |
2526 | |
2527 | if (readcount > 1 || max_reply > PAGE_SIZE - auth_slack) |
2528 | clear_bit(nr: RQ_SPLICE_OK, addr: &argp->rqstp->rq_flags); |
2529 | |
2530 | return true; |
2531 | } |
2532 | |
2533 | static __be32 nfsd4_encode_nfs_fh4(struct xdr_stream *xdr, |
2534 | struct knfsd_fh *fh_handle) |
2535 | { |
2536 | return nfsd4_encode_opaque(xdr, data: fh_handle->fh_raw, size: fh_handle->fh_size); |
2537 | } |
2538 | |
2539 | /* This is a frequently-encoded type; open-coded for speed */ |
2540 | static __be32 nfsd4_encode_nfstime4(struct xdr_stream *xdr, |
2541 | const struct timespec64 *tv) |
2542 | { |
2543 | __be32 *p; |
2544 | |
2545 | p = xdr_reserve_space(xdr, XDR_UNIT * 3); |
2546 | if (!p) |
2547 | return nfserr_resource; |
2548 | p = xdr_encode_hyper(p, val: tv->tv_sec); |
2549 | *p = cpu_to_be32(tv->tv_nsec); |
2550 | return nfs_ok; |
2551 | } |
2552 | |
2553 | static __be32 nfsd4_encode_specdata4(struct xdr_stream *xdr, |
2554 | unsigned int major, unsigned int minor) |
2555 | { |
2556 | __be32 status; |
2557 | |
2558 | status = nfsd4_encode_uint32_t(xdr, val: major); |
2559 | if (status != nfs_ok) |
2560 | return status; |
2561 | return nfsd4_encode_uint32_t(xdr, val: minor); |
2562 | } |
2563 | |
2564 | static __be32 |
2565 | nfsd4_encode_change_info4(struct xdr_stream *xdr, const struct nfsd4_change_info *c) |
2566 | { |
2567 | __be32 status; |
2568 | |
2569 | status = nfsd4_encode_bool(xdr, val: c->atomic); |
2570 | if (status != nfs_ok) |
2571 | return status; |
2572 | status = nfsd4_encode_changeid4(xdr, c->before_change); |
2573 | if (status != nfs_ok) |
2574 | return status; |
2575 | return nfsd4_encode_changeid4(xdr, c->after_change); |
2576 | } |
2577 | |
2578 | static __be32 nfsd4_encode_netaddr4(struct xdr_stream *xdr, |
2579 | const struct nfs42_netaddr *addr) |
2580 | { |
2581 | __be32 status; |
2582 | |
2583 | /* na_r_netid */ |
2584 | status = nfsd4_encode_opaque(xdr, data: addr->netid, size: addr->netid_len); |
2585 | if (status != nfs_ok) |
2586 | return status; |
2587 | /* na_r_addr */ |
2588 | return nfsd4_encode_opaque(xdr, data: addr->addr, size: addr->addr_len); |
2589 | } |
2590 | |
2591 | /* Encode as an array of strings the string given with components |
2592 | * separated @sep, escaped with esc_enter and esc_exit. |
2593 | */ |
2594 | static __be32 nfsd4_encode_components_esc(struct xdr_stream *xdr, char sep, |
2595 | char *components, char esc_enter, |
2596 | char esc_exit) |
2597 | { |
2598 | __be32 *p; |
2599 | __be32 pathlen; |
2600 | int pathlen_offset; |
2601 | int strlen, count=0; |
2602 | char *str, *end, *next; |
2603 | |
2604 | dprintk("nfsd4_encode_components(%s)\n" , components); |
2605 | |
2606 | pathlen_offset = xdr->buf->len; |
2607 | p = xdr_reserve_space(xdr, nbytes: 4); |
2608 | if (!p) |
2609 | return nfserr_resource; |
2610 | p++; /* We will fill this in with @count later */ |
2611 | |
2612 | end = str = components; |
2613 | while (*end) { |
2614 | bool found_esc = false; |
2615 | |
2616 | /* try to parse as esc_start, ..., esc_end, sep */ |
2617 | if (*str == esc_enter) { |
2618 | for (; *end && (*end != esc_exit); end++) |
2619 | /* find esc_exit or end of string */; |
2620 | next = end + 1; |
2621 | if (*end && (!*next || *next == sep)) { |
2622 | str++; |
2623 | found_esc = true; |
2624 | } |
2625 | } |
2626 | |
2627 | if (!found_esc) |
2628 | for (; *end && (*end != sep); end++) |
2629 | /* find sep or end of string */; |
2630 | |
2631 | strlen = end - str; |
2632 | if (strlen) { |
2633 | p = xdr_reserve_space(xdr, nbytes: strlen + 4); |
2634 | if (!p) |
2635 | return nfserr_resource; |
2636 | p = xdr_encode_opaque(p, ptr: str, len: strlen); |
2637 | count++; |
2638 | } |
2639 | else |
2640 | end++; |
2641 | if (found_esc) |
2642 | end = next; |
2643 | |
2644 | str = end; |
2645 | } |
2646 | pathlen = htonl(count); |
2647 | write_bytes_to_xdr_buf(xdr->buf, pathlen_offset, &pathlen, 4); |
2648 | return 0; |
2649 | } |
2650 | |
2651 | /* Encode as an array of strings the string given with components |
2652 | * separated @sep. |
2653 | */ |
2654 | static __be32 nfsd4_encode_components(struct xdr_stream *xdr, char sep, |
2655 | char *components) |
2656 | { |
2657 | return nfsd4_encode_components_esc(xdr, sep, components, esc_enter: 0, esc_exit: 0); |
2658 | } |
2659 | |
2660 | static __be32 nfsd4_encode_fs_location4(struct xdr_stream *xdr, |
2661 | struct nfsd4_fs_location *location) |
2662 | { |
2663 | __be32 status; |
2664 | |
2665 | status = nfsd4_encode_components_esc(xdr, sep: ':', components: location->hosts, |
2666 | esc_enter: '[', esc_exit: ']'); |
2667 | if (status) |
2668 | return status; |
2669 | status = nfsd4_encode_components(xdr, sep: '/', components: location->path); |
2670 | if (status) |
2671 | return status; |
2672 | return nfs_ok; |
2673 | } |
2674 | |
2675 | static __be32 nfsd4_encode_pathname4(struct xdr_stream *xdr, |
2676 | const struct path *root, |
2677 | const struct path *path) |
2678 | { |
2679 | struct path cur = *path; |
2680 | __be32 *p; |
2681 | struct dentry **components = NULL; |
2682 | unsigned int ncomponents = 0; |
2683 | __be32 err = nfserr_jukebox; |
2684 | |
2685 | dprintk("nfsd4_encode_components(" ); |
2686 | |
2687 | path_get(&cur); |
2688 | /* First walk the path up to the nfsd root, and store the |
2689 | * dentries/path components in an array. |
2690 | */ |
2691 | for (;;) { |
2692 | if (path_equal(path1: &cur, path2: root)) |
2693 | break; |
2694 | if (cur.dentry == cur.mnt->mnt_root) { |
2695 | if (follow_up(&cur)) |
2696 | continue; |
2697 | goto out_free; |
2698 | } |
2699 | if ((ncomponents & 15) == 0) { |
2700 | struct dentry **new; |
2701 | new = krealloc(objp: components, |
2702 | new_size: sizeof(*new) * (ncomponents + 16), |
2703 | GFP_KERNEL); |
2704 | if (!new) |
2705 | goto out_free; |
2706 | components = new; |
2707 | } |
2708 | components[ncomponents++] = cur.dentry; |
2709 | cur.dentry = dget_parent(dentry: cur.dentry); |
2710 | } |
2711 | err = nfserr_resource; |
2712 | p = xdr_reserve_space(xdr, nbytes: 4); |
2713 | if (!p) |
2714 | goto out_free; |
2715 | *p++ = cpu_to_be32(ncomponents); |
2716 | |
2717 | while (ncomponents) { |
2718 | struct dentry *dentry = components[ncomponents - 1]; |
2719 | unsigned int len; |
2720 | |
2721 | spin_lock(lock: &dentry->d_lock); |
2722 | len = dentry->d_name.len; |
2723 | p = xdr_reserve_space(xdr, nbytes: len + 4); |
2724 | if (!p) { |
2725 | spin_unlock(lock: &dentry->d_lock); |
2726 | goto out_free; |
2727 | } |
2728 | p = xdr_encode_opaque(p, ptr: dentry->d_name.name, len); |
2729 | dprintk("/%pd" , dentry); |
2730 | spin_unlock(lock: &dentry->d_lock); |
2731 | dput(dentry); |
2732 | ncomponents--; |
2733 | } |
2734 | |
2735 | err = 0; |
2736 | out_free: |
2737 | dprintk(")\n" ); |
2738 | while (ncomponents) |
2739 | dput(components[--ncomponents]); |
2740 | kfree(objp: components); |
2741 | path_put(&cur); |
2742 | return err; |
2743 | } |
2744 | |
2745 | static __be32 nfsd4_encode_fs_locations4(struct xdr_stream *xdr, |
2746 | struct svc_rqst *rqstp, |
2747 | struct svc_export *exp) |
2748 | { |
2749 | struct nfsd4_fs_locations *fslocs = &exp->ex_fslocs; |
2750 | struct svc_export *exp_ps; |
2751 | unsigned int i; |
2752 | __be32 status; |
2753 | |
2754 | /* fs_root */ |
2755 | exp_ps = rqst_find_fsidzero_export(rqstp); |
2756 | if (IS_ERR(ptr: exp_ps)) |
2757 | return nfserrno(errno: PTR_ERR(ptr: exp_ps)); |
2758 | status = nfsd4_encode_pathname4(xdr, root: &exp_ps->ex_path, path: &exp->ex_path); |
2759 | exp_put(exp: exp_ps); |
2760 | if (status != nfs_ok) |
2761 | return status; |
2762 | |
2763 | /* locations<> */ |
2764 | if (xdr_stream_encode_u32(xdr, n: fslocs->locations_count) != XDR_UNIT) |
2765 | return nfserr_resource; |
2766 | for (i = 0; i < fslocs->locations_count; i++) { |
2767 | status = nfsd4_encode_fs_location4(xdr, location: &fslocs->locations[i]); |
2768 | if (status != nfs_ok) |
2769 | return status; |
2770 | } |
2771 | |
2772 | return nfs_ok; |
2773 | } |
2774 | |
2775 | static __be32 nfsd4_encode_nfsace4(struct xdr_stream *xdr, struct svc_rqst *rqstp, |
2776 | struct nfs4_ace *ace) |
2777 | { |
2778 | __be32 status; |
2779 | |
2780 | /* type */ |
2781 | status = nfsd4_encode_acetype4(xdr, ace->type); |
2782 | if (status != nfs_ok) |
2783 | return nfserr_resource; |
2784 | /* flag */ |
2785 | status = nfsd4_encode_aceflag4(xdr, ace->flag); |
2786 | if (status != nfs_ok) |
2787 | return nfserr_resource; |
2788 | /* access mask */ |
2789 | status = nfsd4_encode_acemask4(xdr, ace->access_mask & NFS4_ACE_MASK_ALL); |
2790 | if (status != nfs_ok) |
2791 | return nfserr_resource; |
2792 | /* who */ |
2793 | if (ace->whotype != NFS4_ACL_WHO_NAMED) |
2794 | return nfs4_acl_write_who(xdr, who: ace->whotype); |
2795 | if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP) |
2796 | return nfsd4_encode_group(xdr, rqstp, ace->who_gid); |
2797 | return nfsd4_encode_user(xdr, rqstp, ace->who_uid); |
2798 | } |
2799 | |
2800 | #define WORD0_ABSENT_FS_ATTRS (FATTR4_WORD0_FS_LOCATIONS | FATTR4_WORD0_FSID | \ |
2801 | FATTR4_WORD0_RDATTR_ERROR) |
2802 | #define WORD1_ABSENT_FS_ATTRS FATTR4_WORD1_MOUNTED_ON_FILEID |
2803 | #define WORD2_ABSENT_FS_ATTRS 0 |
2804 | |
2805 | #ifdef CONFIG_NFSD_V4_SECURITY_LABEL |
2806 | static inline __be32 |
2807 | nfsd4_encode_security_label(struct xdr_stream *xdr, struct svc_rqst *rqstp, |
2808 | void *context, int len) |
2809 | { |
2810 | __be32 *p; |
2811 | |
2812 | p = xdr_reserve_space(xdr, nbytes: len + 4 + 4 + 4); |
2813 | if (!p) |
2814 | return nfserr_resource; |
2815 | |
2816 | /* |
2817 | * For now we use a 0 here to indicate the null translation; in |
2818 | * the future we may place a call to translation code here. |
2819 | */ |
2820 | *p++ = cpu_to_be32(0); /* lfs */ |
2821 | *p++ = cpu_to_be32(0); /* pi */ |
2822 | p = xdr_encode_opaque(p, ptr: context, len); |
2823 | return 0; |
2824 | } |
2825 | #else |
2826 | static inline __be32 |
2827 | nfsd4_encode_security_label(struct xdr_stream *xdr, struct svc_rqst *rqstp, |
2828 | void *context, int len) |
2829 | { return 0; } |
2830 | #endif |
2831 | |
2832 | static __be32 fattr_handle_absent_fs(u32 *bmval0, u32 *bmval1, u32 *bmval2, u32 *rdattr_err) |
2833 | { |
2834 | /* As per referral draft: */ |
2835 | if (*bmval0 & ~WORD0_ABSENT_FS_ATTRS || |
2836 | *bmval1 & ~WORD1_ABSENT_FS_ATTRS) { |
2837 | if (*bmval0 & FATTR4_WORD0_RDATTR_ERROR || |
2838 | *bmval0 & FATTR4_WORD0_FS_LOCATIONS) |
2839 | *rdattr_err = NFSERR_MOVED; |
2840 | else |
2841 | return nfserr_moved; |
2842 | } |
2843 | *bmval0 &= WORD0_ABSENT_FS_ATTRS; |
2844 | *bmval1 &= WORD1_ABSENT_FS_ATTRS; |
2845 | *bmval2 &= WORD2_ABSENT_FS_ATTRS; |
2846 | return 0; |
2847 | } |
2848 | |
2849 | |
2850 | static int nfsd4_get_mounted_on_ino(struct svc_export *exp, u64 *pino) |
2851 | { |
2852 | struct path path = exp->ex_path; |
2853 | struct kstat stat; |
2854 | int err; |
2855 | |
2856 | path_get(&path); |
2857 | while (follow_up(&path)) { |
2858 | if (path.dentry != path.mnt->mnt_root) |
2859 | break; |
2860 | } |
2861 | err = vfs_getattr(&path, &stat, STATX_INO, AT_STATX_SYNC_AS_STAT); |
2862 | path_put(&path); |
2863 | if (!err) |
2864 | *pino = stat.ino; |
2865 | return err; |
2866 | } |
2867 | |
2868 | static __be32 |
2869 | nfsd4_encode_bitmap4(struct xdr_stream *xdr, u32 bmval0, u32 bmval1, u32 bmval2) |
2870 | { |
2871 | __be32 *p; |
2872 | |
2873 | if (bmval2) { |
2874 | p = xdr_reserve_space(xdr, XDR_UNIT * 4); |
2875 | if (!p) |
2876 | goto out_resource; |
2877 | *p++ = cpu_to_be32(3); |
2878 | *p++ = cpu_to_be32(bmval0); |
2879 | *p++ = cpu_to_be32(bmval1); |
2880 | *p++ = cpu_to_be32(bmval2); |
2881 | } else if (bmval1) { |
2882 | p = xdr_reserve_space(xdr, XDR_UNIT * 3); |
2883 | if (!p) |
2884 | goto out_resource; |
2885 | *p++ = cpu_to_be32(2); |
2886 | *p++ = cpu_to_be32(bmval0); |
2887 | *p++ = cpu_to_be32(bmval1); |
2888 | } else { |
2889 | p = xdr_reserve_space(xdr, XDR_UNIT * 2); |
2890 | if (!p) |
2891 | goto out_resource; |
2892 | *p++ = cpu_to_be32(1); |
2893 | *p++ = cpu_to_be32(bmval0); |
2894 | } |
2895 | |
2896 | return nfs_ok; |
2897 | out_resource: |
2898 | return nfserr_resource; |
2899 | } |
2900 | |
2901 | struct nfsd4_fattr_args { |
2902 | struct svc_rqst *rqstp; |
2903 | struct svc_fh *fhp; |
2904 | struct svc_export *exp; |
2905 | struct dentry *dentry; |
2906 | struct kstat stat; |
2907 | struct kstatfs statfs; |
2908 | struct nfs4_acl *acl; |
2909 | u64 size; |
2910 | #ifdef CONFIG_NFSD_V4_SECURITY_LABEL |
2911 | void *context; |
2912 | int contextlen; |
2913 | #endif |
2914 | u32 rdattr_err; |
2915 | bool contextsupport; |
2916 | bool ignore_crossmnt; |
2917 | }; |
2918 | |
2919 | typedef __be32(*nfsd4_enc_attr)(struct xdr_stream *xdr, |
2920 | const struct nfsd4_fattr_args *args); |
2921 | |
2922 | static __be32 nfsd4_encode_fattr4__noop(struct xdr_stream *xdr, |
2923 | const struct nfsd4_fattr_args *args) |
2924 | { |
2925 | return nfs_ok; |
2926 | } |
2927 | |
2928 | static __be32 nfsd4_encode_fattr4__true(struct xdr_stream *xdr, |
2929 | const struct nfsd4_fattr_args *args) |
2930 | { |
2931 | return nfsd4_encode_bool(xdr, val: true); |
2932 | } |
2933 | |
2934 | static __be32 nfsd4_encode_fattr4__false(struct xdr_stream *xdr, |
2935 | const struct nfsd4_fattr_args *args) |
2936 | { |
2937 | return nfsd4_encode_bool(xdr, val: false); |
2938 | } |
2939 | |
2940 | static __be32 nfsd4_encode_fattr4_supported_attrs(struct xdr_stream *xdr, |
2941 | const struct nfsd4_fattr_args *args) |
2942 | { |
2943 | struct nfsd4_compoundres *resp = args->rqstp->rq_resp; |
2944 | u32 minorversion = resp->cstate.minorversion; |
2945 | u32 supp[3]; |
2946 | |
2947 | memcpy(supp, nfsd_suppattrs[minorversion], sizeof(supp)); |
2948 | if (!IS_POSIXACL(d_inode(args->dentry))) |
2949 | supp[0] &= ~FATTR4_WORD0_ACL; |
2950 | if (!args->contextsupport) |
2951 | supp[2] &= ~FATTR4_WORD2_SECURITY_LABEL; |
2952 | |
2953 | return nfsd4_encode_bitmap4(xdr, bmval0: supp[0], bmval1: supp[1], bmval2: supp[2]); |
2954 | } |
2955 | |
2956 | static __be32 nfsd4_encode_fattr4_type(struct xdr_stream *xdr, |
2957 | const struct nfsd4_fattr_args *args) |
2958 | { |
2959 | __be32 *p; |
2960 | |
2961 | p = xdr_reserve_space(xdr, XDR_UNIT); |
2962 | if (!p) |
2963 | return nfserr_resource; |
2964 | |
2965 | switch (args->stat.mode & S_IFMT) { |
2966 | case S_IFIFO: |
2967 | *p = cpu_to_be32(NF4FIFO); |
2968 | break; |
2969 | case S_IFCHR: |
2970 | *p = cpu_to_be32(NF4CHR); |
2971 | break; |
2972 | case S_IFDIR: |
2973 | *p = cpu_to_be32(NF4DIR); |
2974 | break; |
2975 | case S_IFBLK: |
2976 | *p = cpu_to_be32(NF4BLK); |
2977 | break; |
2978 | case S_IFLNK: |
2979 | *p = cpu_to_be32(NF4LNK); |
2980 | break; |
2981 | case S_IFREG: |
2982 | *p = cpu_to_be32(NF4REG); |
2983 | break; |
2984 | case S_IFSOCK: |
2985 | *p = cpu_to_be32(NF4SOCK); |
2986 | break; |
2987 | default: |
2988 | return nfserr_serverfault; |
2989 | } |
2990 | |
2991 | return nfs_ok; |
2992 | } |
2993 | |
2994 | static __be32 nfsd4_encode_fattr4_fh_expire_type(struct xdr_stream *xdr, |
2995 | const struct nfsd4_fattr_args *args) |
2996 | { |
2997 | u32 mask; |
2998 | |
2999 | mask = NFS4_FH_PERSISTENT; |
3000 | if (!(args->exp->ex_flags & NFSEXP_NOSUBTREECHECK)) |
3001 | mask |= NFS4_FH_VOL_RENAME; |
3002 | return nfsd4_encode_uint32_t(xdr, val: mask); |
3003 | } |
3004 | |
3005 | static __be32 nfsd4_encode_fattr4_change(struct xdr_stream *xdr, |
3006 | const struct nfsd4_fattr_args *args) |
3007 | { |
3008 | const struct svc_export *exp = args->exp; |
3009 | u64 c; |
3010 | |
3011 | if (unlikely(exp->ex_flags & NFSEXP_V4ROOT)) { |
3012 | u32 flush_time = convert_to_wallclock(sinceboot: exp->cd->flush_time); |
3013 | |
3014 | if (xdr_stream_encode_u32(xdr, n: flush_time) != XDR_UNIT) |
3015 | return nfserr_resource; |
3016 | if (xdr_stream_encode_u32(xdr, n: 0) != XDR_UNIT) |
3017 | return nfserr_resource; |
3018 | return nfs_ok; |
3019 | } |
3020 | |
3021 | c = nfsd4_change_attribute(stat: &args->stat, inode: d_inode(dentry: args->dentry)); |
3022 | return nfsd4_encode_changeid4(xdr, c); |
3023 | } |
3024 | |
3025 | static __be32 nfsd4_encode_fattr4_size(struct xdr_stream *xdr, |
3026 | const struct nfsd4_fattr_args *args) |
3027 | { |
3028 | return nfsd4_encode_uint64_t(xdr, val: args->size); |
3029 | } |
3030 | |
3031 | static __be32 nfsd4_encode_fattr4_fsid(struct xdr_stream *xdr, |
3032 | const struct nfsd4_fattr_args *args) |
3033 | { |
3034 | __be32 *p; |
3035 | |
3036 | p = xdr_reserve_space(xdr, XDR_UNIT * 2 + XDR_UNIT * 2); |
3037 | if (!p) |
3038 | return nfserr_resource; |
3039 | |
3040 | if (unlikely(args->exp->ex_fslocs.migrated)) { |
3041 | p = xdr_encode_hyper(p, NFS4_REFERRAL_FSID_MAJOR); |
3042 | xdr_encode_hyper(p, NFS4_REFERRAL_FSID_MINOR); |
3043 | return nfs_ok; |
3044 | } |
3045 | switch (fsid_source(fhp: args->fhp)) { |
3046 | case FSIDSOURCE_FSID: |
3047 | p = xdr_encode_hyper(p, val: (u64)args->exp->ex_fsid); |
3048 | xdr_encode_hyper(p, val: (u64)0); |
3049 | break; |
3050 | case FSIDSOURCE_DEV: |
3051 | *p++ = xdr_zero; |
3052 | *p++ = cpu_to_be32(MAJOR(args->stat.dev)); |
3053 | *p++ = xdr_zero; |
3054 | *p = cpu_to_be32(MINOR(args->stat.dev)); |
3055 | break; |
3056 | case FSIDSOURCE_UUID: |
3057 | xdr_encode_opaque_fixed(p, ptr: args->exp->ex_uuid, EX_UUID_LEN); |
3058 | break; |
3059 | } |
3060 | |
3061 | return nfs_ok; |
3062 | } |
3063 | |
3064 | static __be32 nfsd4_encode_fattr4_lease_time(struct xdr_stream *xdr, |
3065 | const struct nfsd4_fattr_args *args) |
3066 | { |
3067 | struct nfsd_net *nn = net_generic(SVC_NET(args->rqstp), id: nfsd_net_id); |
3068 | |
3069 | return nfsd4_encode_nfs_lease4(xdr, nn->nfsd4_lease); |
3070 | } |
3071 | |
3072 | static __be32 nfsd4_encode_fattr4_rdattr_error(struct xdr_stream *xdr, |
3073 | const struct nfsd4_fattr_args *args) |
3074 | { |
3075 | return nfsd4_encode_uint32_t(xdr, val: args->rdattr_err); |
3076 | } |
3077 | |
3078 | static __be32 nfsd4_encode_fattr4_aclsupport(struct xdr_stream *xdr, |
3079 | const struct nfsd4_fattr_args *args) |
3080 | { |
3081 | u32 mask; |
3082 | |
3083 | mask = 0; |
3084 | if (IS_POSIXACL(d_inode(args->dentry))) |
3085 | mask = ACL4_SUPPORT_ALLOW_ACL | ACL4_SUPPORT_DENY_ACL; |
3086 | return nfsd4_encode_uint32_t(xdr, val: mask); |
3087 | } |
3088 | |
3089 | static __be32 nfsd4_encode_fattr4_acl(struct xdr_stream *xdr, |
3090 | const struct nfsd4_fattr_args *args) |
3091 | { |
3092 | struct nfs4_acl *acl = args->acl; |
3093 | struct nfs4_ace *ace; |
3094 | __be32 status; |
3095 | |
3096 | /* nfsace4<> */ |
3097 | if (!acl) { |
3098 | if (xdr_stream_encode_u32(xdr, n: 0) != XDR_UNIT) |
3099 | return nfserr_resource; |
3100 | } else { |
3101 | if (xdr_stream_encode_u32(xdr, n: acl->naces) != XDR_UNIT) |
3102 | return nfserr_resource; |
3103 | for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) { |
3104 | status = nfsd4_encode_nfsace4(xdr, rqstp: args->rqstp, ace); |
3105 | if (status != nfs_ok) |
3106 | return status; |
3107 | } |
3108 | } |
3109 | return nfs_ok; |
3110 | } |
3111 | |
3112 | static __be32 nfsd4_encode_fattr4_filehandle(struct xdr_stream *xdr, |
3113 | const struct nfsd4_fattr_args *args) |
3114 | { |
3115 | return nfsd4_encode_nfs_fh4(xdr, fh_handle: &args->fhp->fh_handle); |
3116 | } |
3117 | |
3118 | static __be32 nfsd4_encode_fattr4_fileid(struct xdr_stream *xdr, |
3119 | const struct nfsd4_fattr_args *args) |
3120 | { |
3121 | return nfsd4_encode_uint64_t(xdr, val: args->stat.ino); |
3122 | } |
3123 | |
3124 | static __be32 nfsd4_encode_fattr4_files_avail(struct xdr_stream *xdr, |
3125 | const struct nfsd4_fattr_args *args) |
3126 | { |
3127 | return nfsd4_encode_uint64_t(xdr, val: args->statfs.f_ffree); |
3128 | } |
3129 | |
3130 | static __be32 nfsd4_encode_fattr4_files_free(struct xdr_stream *xdr, |
3131 | const struct nfsd4_fattr_args *args) |
3132 | { |
3133 | return nfsd4_encode_uint64_t(xdr, val: args->statfs.f_ffree); |
3134 | } |
3135 | |
3136 | static __be32 nfsd4_encode_fattr4_files_total(struct xdr_stream *xdr, |
3137 | const struct nfsd4_fattr_args *args) |
3138 | { |
3139 | return nfsd4_encode_uint64_t(xdr, val: args->statfs.f_files); |
3140 | } |
3141 | |
3142 | static __be32 nfsd4_encode_fattr4_fs_locations(struct xdr_stream *xdr, |
3143 | const struct nfsd4_fattr_args *args) |
3144 | { |
3145 | return nfsd4_encode_fs_locations4(xdr, rqstp: args->rqstp, exp: args->exp); |
3146 | } |
3147 | |
3148 | static __be32 nfsd4_encode_fattr4_maxfilesize(struct xdr_stream *xdr, |
3149 | const struct nfsd4_fattr_args *args) |
3150 | { |
3151 | struct super_block *sb = args->exp->ex_path.mnt->mnt_sb; |
3152 | |
3153 | return nfsd4_encode_uint64_t(xdr, val: sb->s_maxbytes); |
3154 | } |
3155 | |
3156 | static __be32 nfsd4_encode_fattr4_maxlink(struct xdr_stream *xdr, |
3157 | const struct nfsd4_fattr_args *args) |
3158 | { |
3159 | return nfsd4_encode_uint32_t(xdr, val: 255); |
3160 | } |
3161 | |
3162 | static __be32 nfsd4_encode_fattr4_maxname(struct xdr_stream *xdr, |
3163 | const struct nfsd4_fattr_args *args) |
3164 | { |
3165 | return nfsd4_encode_uint32_t(xdr, val: args->statfs.f_namelen); |
3166 | } |
3167 | |
3168 | static __be32 nfsd4_encode_fattr4_maxread(struct xdr_stream *xdr, |
3169 | const struct nfsd4_fattr_args *args) |
3170 | { |
3171 | return nfsd4_encode_uint64_t(xdr, val: svc_max_payload(rqstp: args->rqstp)); |
3172 | } |
3173 | |
3174 | static __be32 nfsd4_encode_fattr4_maxwrite(struct xdr_stream *xdr, |
3175 | const struct nfsd4_fattr_args *args) |
3176 | { |
3177 | return nfsd4_encode_uint64_t(xdr, val: svc_max_payload(rqstp: args->rqstp)); |
3178 | } |
3179 | |
3180 | static __be32 nfsd4_encode_fattr4_mode(struct xdr_stream *xdr, |
3181 | const struct nfsd4_fattr_args *args) |
3182 | { |
3183 | return nfsd4_encode_mode4(xdr, args->stat.mode & S_IALLUGO); |
3184 | } |
3185 | |
3186 | static __be32 nfsd4_encode_fattr4_numlinks(struct xdr_stream *xdr, |
3187 | const struct nfsd4_fattr_args *args) |
3188 | { |
3189 | return nfsd4_encode_uint32_t(xdr, val: args->stat.nlink); |
3190 | } |
3191 | |
3192 | static __be32 nfsd4_encode_fattr4_owner(struct xdr_stream *xdr, |
3193 | const struct nfsd4_fattr_args *args) |
3194 | { |
3195 | return nfsd4_encode_user(xdr, args->rqstp, args->stat.uid); |
3196 | } |
3197 | |
3198 | static __be32 nfsd4_encode_fattr4_owner_group(struct xdr_stream *xdr, |
3199 | const struct nfsd4_fattr_args *args) |
3200 | { |
3201 | return nfsd4_encode_group(xdr, args->rqstp, args->stat.gid); |
3202 | } |
3203 | |
3204 | static __be32 nfsd4_encode_fattr4_rawdev(struct xdr_stream *xdr, |
3205 | const struct nfsd4_fattr_args *args) |
3206 | { |
3207 | return nfsd4_encode_specdata4(xdr, MAJOR(args->stat.rdev), |
3208 | MINOR(args->stat.rdev)); |
3209 | } |
3210 | |
3211 | static __be32 nfsd4_encode_fattr4_space_avail(struct xdr_stream *xdr, |
3212 | const struct nfsd4_fattr_args *args) |
3213 | { |
3214 | u64 avail = (u64)args->statfs.f_bavail * (u64)args->statfs.f_bsize; |
3215 | |
3216 | return nfsd4_encode_uint64_t(xdr, val: avail); |
3217 | } |
3218 | |
3219 | static __be32 nfsd4_encode_fattr4_space_free(struct xdr_stream *xdr, |
3220 | const struct nfsd4_fattr_args *args) |
3221 | { |
3222 | u64 free = (u64)args->statfs.f_bfree * (u64)args->statfs.f_bsize; |
3223 | |
3224 | return nfsd4_encode_uint64_t(xdr, val: free); |
3225 | } |
3226 | |
3227 | static __be32 nfsd4_encode_fattr4_space_total(struct xdr_stream *xdr, |
3228 | const struct nfsd4_fattr_args *args) |
3229 | { |
3230 | u64 total = (u64)args->statfs.f_blocks * (u64)args->statfs.f_bsize; |
3231 | |
3232 | return nfsd4_encode_uint64_t(xdr, val: total); |
3233 | } |
3234 | |
3235 | static __be32 nfsd4_encode_fattr4_space_used(struct xdr_stream *xdr, |
3236 | const struct nfsd4_fattr_args *args) |
3237 | { |
3238 | return nfsd4_encode_uint64_t(xdr, val: (u64)args->stat.blocks << 9); |
3239 | } |
3240 | |
3241 | static __be32 nfsd4_encode_fattr4_time_access(struct xdr_stream *xdr, |
3242 | const struct nfsd4_fattr_args *args) |
3243 | { |
3244 | return nfsd4_encode_nfstime4(xdr, tv: &args->stat.atime); |
3245 | } |
3246 | |
3247 | static __be32 nfsd4_encode_fattr4_time_create(struct xdr_stream *xdr, |
3248 | const struct nfsd4_fattr_args *args) |
3249 | { |
3250 | return nfsd4_encode_nfstime4(xdr, tv: &args->stat.btime); |
3251 | } |
3252 | |
3253 | /* |
3254 | * ctime (in NFSv4, time_metadata) is not writeable, and the client |
3255 | * doesn't really care what resolution could theoretically be stored by |
3256 | * the filesystem. |
3257 | * |
3258 | * The client cares how close together changes can be while still |
3259 | * guaranteeing ctime changes. For most filesystems (which have |
3260 | * timestamps with nanosecond fields) that is limited by the resolution |
3261 | * of the time returned from current_time() (which I'm assuming to be |
3262 | * 1/HZ). |
3263 | */ |
3264 | static __be32 nfsd4_encode_fattr4_time_delta(struct xdr_stream *xdr, |
3265 | const struct nfsd4_fattr_args *args) |
3266 | { |
3267 | const struct inode *inode = d_inode(dentry: args->dentry); |
3268 | u32 ns = max_t(u32, NSEC_PER_SEC/HZ, inode->i_sb->s_time_gran); |
3269 | struct timespec64 ts = ns_to_timespec64(nsec: ns); |
3270 | |
3271 | return nfsd4_encode_nfstime4(xdr, tv: &ts); |
3272 | } |
3273 | |
3274 | static __be32 nfsd4_encode_fattr4_time_metadata(struct xdr_stream *xdr, |
3275 | const struct nfsd4_fattr_args *args) |
3276 | { |
3277 | return nfsd4_encode_nfstime4(xdr, tv: &args->stat.ctime); |
3278 | } |
3279 | |
3280 | static __be32 nfsd4_encode_fattr4_time_modify(struct xdr_stream *xdr, |
3281 | const struct nfsd4_fattr_args *args) |
3282 | { |
3283 | return nfsd4_encode_nfstime4(xdr, tv: &args->stat.mtime); |
3284 | } |
3285 | |
3286 | static __be32 nfsd4_encode_fattr4_mounted_on_fileid(struct xdr_stream *xdr, |
3287 | const struct nfsd4_fattr_args *args) |
3288 | { |
3289 | u64 ino; |
3290 | int err; |
3291 | |
3292 | if (!args->ignore_crossmnt && |
3293 | args->dentry == args->exp->ex_path.mnt->mnt_root) { |
3294 | err = nfsd4_get_mounted_on_ino(exp: args->exp, pino: &ino); |
3295 | if (err) |
3296 | return nfserrno(errno: err); |
3297 | } else |
3298 | ino = args->stat.ino; |
3299 | |
3300 | return nfsd4_encode_uint64_t(xdr, val: ino); |
3301 | } |
3302 | |
3303 | #ifdef CONFIG_NFSD_PNFS |
3304 | |
3305 | static __be32 nfsd4_encode_fattr4_fs_layout_types(struct xdr_stream *xdr, |
3306 | const struct nfsd4_fattr_args *args) |
3307 | { |
3308 | unsigned long mask = args->exp->ex_layout_types; |
3309 | int i; |
3310 | |
3311 | /* Hamming weight of @mask is the number of layout types to return */ |
3312 | if (xdr_stream_encode_u32(xdr, n: hweight_long(w: mask)) != XDR_UNIT) |
3313 | return nfserr_resource; |
3314 | for (i = LAYOUT_NFSV4_1_FILES; i < LAYOUT_TYPE_MAX; ++i) |
3315 | if (mask & BIT(i)) { |
3316 | /* layouttype4 */ |
3317 | if (xdr_stream_encode_u32(xdr, n: i) != XDR_UNIT) |
3318 | return nfserr_resource; |
3319 | } |
3320 | return nfs_ok; |
3321 | } |
3322 | |
3323 | static __be32 nfsd4_encode_fattr4_layout_types(struct xdr_stream *xdr, |
3324 | const struct nfsd4_fattr_args *args) |
3325 | { |
3326 | unsigned long mask = args->exp->ex_layout_types; |
3327 | int i; |
3328 | |
3329 | /* Hamming weight of @mask is the number of layout types to return */ |
3330 | if (xdr_stream_encode_u32(xdr, n: hweight_long(w: mask)) != XDR_UNIT) |
3331 | return nfserr_resource; |
3332 | for (i = LAYOUT_NFSV4_1_FILES; i < LAYOUT_TYPE_MAX; ++i) |
3333 | if (mask & BIT(i)) { |
3334 | /* layouttype4 */ |
3335 | if (xdr_stream_encode_u32(xdr, n: i) != XDR_UNIT) |
3336 | return nfserr_resource; |
3337 | } |
3338 | return nfs_ok; |
3339 | } |
3340 | |
3341 | static __be32 nfsd4_encode_fattr4_layout_blksize(struct xdr_stream *xdr, |
3342 | const struct nfsd4_fattr_args *args) |
3343 | { |
3344 | return nfsd4_encode_uint32_t(xdr, val: args->stat.blksize); |
3345 | } |
3346 | |
3347 | #endif |
3348 | |
3349 | static __be32 nfsd4_encode_fattr4_suppattr_exclcreat(struct xdr_stream *xdr, |
3350 | const struct nfsd4_fattr_args *args) |
3351 | { |
3352 | struct nfsd4_compoundres *resp = args->rqstp->rq_resp; |
3353 | u32 supp[3]; |
3354 | |
3355 | memcpy(supp, nfsd_suppattrs[resp->cstate.minorversion], sizeof(supp)); |
3356 | supp[0] &= NFSD_SUPPATTR_EXCLCREAT_WORD0; |
3357 | supp[1] &= NFSD_SUPPATTR_EXCLCREAT_WORD1; |
3358 | supp[2] &= NFSD_SUPPATTR_EXCLCREAT_WORD2; |
3359 | |
3360 | return nfsd4_encode_bitmap4(xdr, bmval0: supp[0], bmval1: supp[1], bmval2: supp[2]); |
3361 | } |
3362 | |
3363 | #ifdef CONFIG_NFSD_V4_SECURITY_LABEL |
3364 | static __be32 nfsd4_encode_fattr4_sec_label(struct xdr_stream *xdr, |
3365 | const struct nfsd4_fattr_args *args) |
3366 | { |
3367 | return nfsd4_encode_security_label(xdr, rqstp: args->rqstp, |
3368 | context: args->context, len: args->contextlen); |
3369 | } |
3370 | #endif |
3371 | |
3372 | static __be32 nfsd4_encode_fattr4_xattr_support(struct xdr_stream *xdr, |
3373 | const struct nfsd4_fattr_args *args) |
3374 | { |
3375 | int err = xattr_supports_user_prefix(inode: d_inode(dentry: args->dentry)); |
3376 | |
3377 | return nfsd4_encode_bool(xdr, val: err == 0); |
3378 | } |
3379 | |
3380 | static const nfsd4_enc_attr nfsd4_enc_fattr4_encode_ops[] = { |
3381 | [FATTR4_SUPPORTED_ATTRS] = nfsd4_encode_fattr4_supported_attrs, |
3382 | [FATTR4_TYPE] = nfsd4_encode_fattr4_type, |
3383 | [FATTR4_FH_EXPIRE_TYPE] = nfsd4_encode_fattr4_fh_expire_type, |
3384 | [FATTR4_CHANGE] = nfsd4_encode_fattr4_change, |
3385 | [FATTR4_SIZE] = nfsd4_encode_fattr4_size, |
3386 | [FATTR4_LINK_SUPPORT] = nfsd4_encode_fattr4__true, |
3387 | [FATTR4_SYMLINK_SUPPORT] = nfsd4_encode_fattr4__true, |
3388 | [FATTR4_NAMED_ATTR] = nfsd4_encode_fattr4__false, |
3389 | [FATTR4_FSID] = nfsd4_encode_fattr4_fsid, |
3390 | [FATTR4_UNIQUE_HANDLES] = nfsd4_encode_fattr4__true, |
3391 | [FATTR4_LEASE_TIME] = nfsd4_encode_fattr4_lease_time, |
3392 | [FATTR4_RDATTR_ERROR] = nfsd4_encode_fattr4_rdattr_error, |
3393 | [FATTR4_ACL] = nfsd4_encode_fattr4_acl, |
3394 | [FATTR4_ACLSUPPORT] = nfsd4_encode_fattr4_aclsupport, |
3395 | [FATTR4_ARCHIVE] = nfsd4_encode_fattr4__noop, |
3396 | [FATTR4_CANSETTIME] = nfsd4_encode_fattr4__true, |
3397 | [FATTR4_CASE_INSENSITIVE] = nfsd4_encode_fattr4__false, |
3398 | [FATTR4_CASE_PRESERVING] = nfsd4_encode_fattr4__true, |
3399 | [FATTR4_CHOWN_RESTRICTED] = nfsd4_encode_fattr4__true, |
3400 | [FATTR4_FILEHANDLE] = nfsd4_encode_fattr4_filehandle, |
3401 | [FATTR4_FILEID] = nfsd4_encode_fattr4_fileid, |
3402 | [FATTR4_FILES_AVAIL] = nfsd4_encode_fattr4_files_avail, |
3403 | [FATTR4_FILES_FREE] = nfsd4_encode_fattr4_files_free, |
3404 | [FATTR4_FILES_TOTAL] = nfsd4_encode_fattr4_files_total, |
3405 | [FATTR4_FS_LOCATIONS] = nfsd4_encode_fattr4_fs_locations, |
3406 | [FATTR4_HIDDEN] = nfsd4_encode_fattr4__noop, |
3407 | [FATTR4_HOMOGENEOUS] = nfsd4_encode_fattr4__true, |
3408 | [FATTR4_MAXFILESIZE] = nfsd4_encode_fattr4_maxfilesize, |
3409 | [FATTR4_MAXLINK] = nfsd4_encode_fattr4_maxlink, |
3410 | [FATTR4_MAXNAME] = nfsd4_encode_fattr4_maxname, |
3411 | [FATTR4_MAXREAD] = nfsd4_encode_fattr4_maxread, |
3412 | [FATTR4_MAXWRITE] = nfsd4_encode_fattr4_maxwrite, |
3413 | [FATTR4_MIMETYPE] = nfsd4_encode_fattr4__noop, |
3414 | [FATTR4_MODE] = nfsd4_encode_fattr4_mode, |
3415 | [FATTR4_NO_TRUNC] = nfsd4_encode_fattr4__true, |
3416 | [FATTR4_NUMLINKS] = nfsd4_encode_fattr4_numlinks, |
3417 | [FATTR4_OWNER] = nfsd4_encode_fattr4_owner, |
3418 | [FATTR4_OWNER_GROUP] = nfsd4_encode_fattr4_owner_group, |
3419 | [FATTR4_QUOTA_AVAIL_HARD] = nfsd4_encode_fattr4__noop, |
3420 | [FATTR4_QUOTA_AVAIL_SOFT] = nfsd4_encode_fattr4__noop, |
3421 | [FATTR4_QUOTA_USED] = nfsd4_encode_fattr4__noop, |
3422 | [FATTR4_RAWDEV] = nfsd4_encode_fattr4_rawdev, |
3423 | [FATTR4_SPACE_AVAIL] = nfsd4_encode_fattr4_space_avail, |
3424 | [FATTR4_SPACE_FREE] = nfsd4_encode_fattr4_space_free, |
3425 | [FATTR4_SPACE_TOTAL] = nfsd4_encode_fattr4_space_total, |
3426 | [FATTR4_SPACE_USED] = nfsd4_encode_fattr4_space_used, |
3427 | [FATTR4_SYSTEM] = nfsd4_encode_fattr4__noop, |
3428 | [FATTR4_TIME_ACCESS] = nfsd4_encode_fattr4_time_access, |
3429 | [FATTR4_TIME_ACCESS_SET] = nfsd4_encode_fattr4__noop, |
3430 | [FATTR4_TIME_BACKUP] = nfsd4_encode_fattr4__noop, |
3431 | [FATTR4_TIME_CREATE] = nfsd4_encode_fattr4_time_create, |
3432 | [FATTR4_TIME_DELTA] = nfsd4_encode_fattr4_time_delta, |
3433 | [FATTR4_TIME_METADATA] = nfsd4_encode_fattr4_time_metadata, |
3434 | [FATTR4_TIME_MODIFY] = nfsd4_encode_fattr4_time_modify, |
3435 | [FATTR4_TIME_MODIFY_SET] = nfsd4_encode_fattr4__noop, |
3436 | [FATTR4_MOUNTED_ON_FILEID] = nfsd4_encode_fattr4_mounted_on_fileid, |
3437 | [FATTR4_DIR_NOTIF_DELAY] = nfsd4_encode_fattr4__noop, |
3438 | [FATTR4_DIRENT_NOTIF_DELAY] = nfsd4_encode_fattr4__noop, |
3439 | [FATTR4_DACL] = nfsd4_encode_fattr4__noop, |
3440 | [FATTR4_SACL] = nfsd4_encode_fattr4__noop, |
3441 | [FATTR4_CHANGE_POLICY] = nfsd4_encode_fattr4__noop, |
3442 | [FATTR4_FS_STATUS] = nfsd4_encode_fattr4__noop, |
3443 | |
3444 | #ifdef CONFIG_NFSD_PNFS |
3445 | [FATTR4_FS_LAYOUT_TYPES] = nfsd4_encode_fattr4_fs_layout_types, |
3446 | [FATTR4_LAYOUT_HINT] = nfsd4_encode_fattr4__noop, |
3447 | [FATTR4_LAYOUT_TYPES] = nfsd4_encode_fattr4_layout_types, |
3448 | [FATTR4_LAYOUT_BLKSIZE] = nfsd4_encode_fattr4_layout_blksize, |
3449 | [FATTR4_LAYOUT_ALIGNMENT] = nfsd4_encode_fattr4__noop, |
3450 | #else |
3451 | [FATTR4_FS_LAYOUT_TYPES] = nfsd4_encode_fattr4__noop, |
3452 | [FATTR4_LAYOUT_HINT] = nfsd4_encode_fattr4__noop, |
3453 | [FATTR4_LAYOUT_TYPES] = nfsd4_encode_fattr4__noop, |
3454 | [FATTR4_LAYOUT_BLKSIZE] = nfsd4_encode_fattr4__noop, |
3455 | [FATTR4_LAYOUT_ALIGNMENT] = nfsd4_encode_fattr4__noop, |
3456 | #endif |
3457 | |
3458 | [FATTR4_FS_LOCATIONS_INFO] = nfsd4_encode_fattr4__noop, |
3459 | [FATTR4_MDSTHRESHOLD] = nfsd4_encode_fattr4__noop, |
3460 | [FATTR4_RETENTION_GET] = nfsd4_encode_fattr4__noop, |
3461 | [FATTR4_RETENTION_SET] = nfsd4_encode_fattr4__noop, |
3462 | [FATTR4_RETENTEVT_GET] = nfsd4_encode_fattr4__noop, |
3463 | [FATTR4_RETENTEVT_SET] = nfsd4_encode_fattr4__noop, |
3464 | [FATTR4_RETENTION_HOLD] = nfsd4_encode_fattr4__noop, |
3465 | [FATTR4_MODE_SET_MASKED] = nfsd4_encode_fattr4__noop, |
3466 | [FATTR4_SUPPATTR_EXCLCREAT] = nfsd4_encode_fattr4_suppattr_exclcreat, |
3467 | [FATTR4_FS_CHARSET_CAP] = nfsd4_encode_fattr4__noop, |
3468 | [FATTR4_CLONE_BLKSIZE] = nfsd4_encode_fattr4__noop, |
3469 | [FATTR4_SPACE_FREED] = nfsd4_encode_fattr4__noop, |
3470 | [FATTR4_CHANGE_ATTR_TYPE] = nfsd4_encode_fattr4__noop, |
3471 | |
3472 | #ifdef CONFIG_NFSD_V4_SECURITY_LABEL |
3473 | [FATTR4_SEC_LABEL] = nfsd4_encode_fattr4_sec_label, |
3474 | #else |
3475 | [FATTR4_SEC_LABEL] = nfsd4_encode_fattr4__noop, |
3476 | #endif |
3477 | |
3478 | [FATTR4_MODE_UMASK] = nfsd4_encode_fattr4__noop, |
3479 | [FATTR4_XATTR_SUPPORT] = nfsd4_encode_fattr4_xattr_support, |
3480 | }; |
3481 | |
3482 | /* |
3483 | * Note: @fhp can be NULL; in this case, we might have to compose the filehandle |
3484 | * ourselves. |
3485 | */ |
3486 | static __be32 |
3487 | nfsd4_encode_fattr4(struct svc_rqst *rqstp, struct xdr_stream *xdr, |
3488 | struct svc_fh *fhp, struct svc_export *exp, |
3489 | struct dentry *dentry, const u32 *bmval, |
3490 | int ignore_crossmnt) |
3491 | { |
3492 | struct nfsd4_fattr_args args; |
3493 | struct svc_fh *tempfh = NULL; |
3494 | int starting_len = xdr->buf->len; |
3495 | __be32 *attrlen_p, status; |
3496 | int attrlen_offset; |
3497 | int err; |
3498 | struct nfsd4_compoundres *resp = rqstp->rq_resp; |
3499 | u32 minorversion = resp->cstate.minorversion; |
3500 | struct path path = { |
3501 | .mnt = exp->ex_path.mnt, |
3502 | .dentry = dentry, |
3503 | }; |
3504 | union { |
3505 | u32 attrmask[3]; |
3506 | unsigned long mask[2]; |
3507 | } u; |
3508 | bool file_modified; |
3509 | unsigned long bit; |
3510 | u64 size = 0; |
3511 | |
3512 | WARN_ON_ONCE(bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1); |
3513 | WARN_ON_ONCE(!nfsd_attrs_supported(minorversion, bmval)); |
3514 | |
3515 | args.rqstp = rqstp; |
3516 | args.exp = exp; |
3517 | args.dentry = dentry; |
3518 | args.ignore_crossmnt = (ignore_crossmnt != 0); |
3519 | |
3520 | /* |
3521 | * Make a local copy of the attribute bitmap that can be modified. |
3522 | */ |
3523 | memset(&u, 0, sizeof(u)); |
3524 | u.attrmask[0] = bmval[0]; |
3525 | u.attrmask[1] = bmval[1]; |
3526 | u.attrmask[2] = bmval[2]; |
3527 | |
3528 | args.rdattr_err = 0; |
3529 | if (exp->ex_fslocs.migrated) { |
3530 | status = fattr_handle_absent_fs(bmval0: &u.attrmask[0], bmval1: &u.attrmask[1], |
3531 | bmval2: &u.attrmask[2], rdattr_err: &args.rdattr_err); |
3532 | if (status) |
3533 | goto out; |
3534 | } |
3535 | args.size = 0; |
3536 | if (u.attrmask[0] & (FATTR4_WORD0_CHANGE | FATTR4_WORD0_SIZE)) { |
3537 | status = nfsd4_deleg_getattr_conflict(rqstp, inode: d_inode(dentry), |
3538 | file_modified: &file_modified, size: &size); |
3539 | if (status) |
3540 | goto out; |
3541 | } |
3542 | |
3543 | err = vfs_getattr(&path, &args.stat, |
3544 | STATX_BASIC_STATS | STATX_BTIME | STATX_CHANGE_COOKIE, |
3545 | AT_STATX_SYNC_AS_STAT); |
3546 | if (err) |
3547 | goto out_nfserr; |
3548 | args.size = file_modified ? size : args.stat.size; |
3549 | |
3550 | if (!(args.stat.result_mask & STATX_BTIME)) |
3551 | /* underlying FS does not offer btime so we can't share it */ |
3552 | u.attrmask[1] &= ~FATTR4_WORD1_TIME_CREATE; |
3553 | if ((u.attrmask[0] & (FATTR4_WORD0_FILES_AVAIL | FATTR4_WORD0_FILES_FREE | |
3554 | FATTR4_WORD0_FILES_TOTAL | FATTR4_WORD0_MAXNAME)) || |
3555 | (u.attrmask[1] & (FATTR4_WORD1_SPACE_AVAIL | FATTR4_WORD1_SPACE_FREE | |
3556 | FATTR4_WORD1_SPACE_TOTAL))) { |
3557 | err = vfs_statfs(&path, &args.statfs); |
3558 | if (err) |
3559 | goto out_nfserr; |
3560 | } |
3561 | if ((u.attrmask[0] & (FATTR4_WORD0_FILEHANDLE | FATTR4_WORD0_FSID)) && |
3562 | !fhp) { |
3563 | tempfh = kmalloc(size: sizeof(struct svc_fh), GFP_KERNEL); |
3564 | status = nfserr_jukebox; |
3565 | if (!tempfh) |
3566 | goto out; |
3567 | fh_init(fhp: tempfh, NFS4_FHSIZE); |
3568 | status = fh_compose(tempfh, exp, dentry, NULL); |
3569 | if (status) |
3570 | goto out; |
3571 | args.fhp = tempfh; |
3572 | } else |
3573 | args.fhp = fhp; |
3574 | |
3575 | args.acl = NULL; |
3576 | if (u.attrmask[0] & FATTR4_WORD0_ACL) { |
3577 | err = nfsd4_get_nfs4_acl(rqstp, dentry, acl: &args.acl); |
3578 | if (err == -EOPNOTSUPP) |
3579 | u.attrmask[0] &= ~FATTR4_WORD0_ACL; |
3580 | else if (err == -EINVAL) { |
3581 | status = nfserr_attrnotsupp; |
3582 | goto out; |
3583 | } else if (err != 0) |
3584 | goto out_nfserr; |
3585 | } |
3586 | |
3587 | args.contextsupport = false; |
3588 | |
3589 | #ifdef CONFIG_NFSD_V4_SECURITY_LABEL |
3590 | args.context = NULL; |
3591 | if ((u.attrmask[2] & FATTR4_WORD2_SECURITY_LABEL) || |
3592 | u.attrmask[0] & FATTR4_WORD0_SUPPORTED_ATTRS) { |
3593 | if (exp->ex_flags & NFSEXP_SECURITY_LABEL) |
3594 | err = security_inode_getsecctx(inode: d_inode(dentry), |
3595 | ctx: &args.context, ctxlen: &args.contextlen); |
3596 | else |
3597 | err = -EOPNOTSUPP; |
3598 | args.contextsupport = (err == 0); |
3599 | if (u.attrmask[2] & FATTR4_WORD2_SECURITY_LABEL) { |
3600 | if (err == -EOPNOTSUPP) |
3601 | u.attrmask[2] &= ~FATTR4_WORD2_SECURITY_LABEL; |
3602 | else if (err) |
3603 | goto out_nfserr; |
3604 | } |
3605 | } |
3606 | #endif /* CONFIG_NFSD_V4_SECURITY_LABEL */ |
3607 | |
3608 | /* attrmask */ |
3609 | status = nfsd4_encode_bitmap4(xdr, bmval0: u.attrmask[0], |
3610 | bmval1: u.attrmask[1], bmval2: u.attrmask[2]); |
3611 | if (status) |
3612 | goto out; |
3613 | |
3614 | /* attr_vals */ |
3615 | attrlen_offset = xdr->buf->len; |
3616 | attrlen_p = xdr_reserve_space(xdr, XDR_UNIT); |
3617 | if (!attrlen_p) |
3618 | goto out_resource; |
3619 | for_each_set_bit(bit, (const unsigned long *)&u.mask, |
3620 | ARRAY_SIZE(nfsd4_enc_fattr4_encode_ops)) { |
3621 | status = nfsd4_enc_fattr4_encode_ops[bit](xdr, &args); |
3622 | if (status != nfs_ok) |
3623 | goto out; |
3624 | } |
3625 | *attrlen_p = cpu_to_be32(xdr->buf->len - attrlen_offset - XDR_UNIT); |
3626 | status = nfs_ok; |
3627 | |
3628 | out: |
3629 | #ifdef CONFIG_NFSD_V4_SECURITY_LABEL |
3630 | if (args.context) |
3631 | security_release_secctx(secdata: args.context, seclen: args.contextlen); |
3632 | #endif /* CONFIG_NFSD_V4_SECURITY_LABEL */ |
3633 | kfree(objp: args.acl); |
3634 | if (tempfh) { |
3635 | fh_put(tempfh); |
3636 | kfree(objp: tempfh); |
3637 | } |
3638 | if (status) |
3639 | xdr_truncate_encode(xdr, len: starting_len); |
3640 | return status; |
3641 | out_nfserr: |
3642 | status = nfserrno(errno: err); |
3643 | goto out; |
3644 | out_resource: |
3645 | status = nfserr_resource; |
3646 | goto out; |
3647 | } |
3648 | |
3649 | static void svcxdr_init_encode_from_buffer(struct xdr_stream *xdr, |
3650 | struct xdr_buf *buf, __be32 *p, int bytes) |
3651 | { |
3652 | xdr->scratch.iov_len = 0; |
3653 | memset(buf, 0, sizeof(struct xdr_buf)); |
3654 | buf->head[0].iov_base = p; |
3655 | buf->head[0].iov_len = 0; |
3656 | buf->len = 0; |
3657 | xdr->buf = buf; |
3658 | xdr->iov = buf->head; |
3659 | xdr->p = p; |
3660 | xdr->end = (void *)p + bytes; |
3661 | buf->buflen = bytes; |
3662 | } |
3663 | |
3664 | __be32 nfsd4_encode_fattr_to_buf(__be32 **p, int words, |
3665 | struct svc_fh *fhp, struct svc_export *exp, |
3666 | struct dentry *dentry, u32 *bmval, |
3667 | struct svc_rqst *rqstp, int ignore_crossmnt) |
3668 | { |
3669 | struct xdr_buf dummy; |
3670 | struct xdr_stream xdr; |
3671 | __be32 ret; |
3672 | |
3673 | svcxdr_init_encode_from_buffer(xdr: &xdr, buf: &dummy, p: *p, bytes: words << 2); |
3674 | ret = nfsd4_encode_fattr4(rqstp, xdr: &xdr, fhp, exp, dentry, bmval, |
3675 | ignore_crossmnt); |
3676 | *p = xdr.p; |
3677 | return ret; |
3678 | } |
3679 | |
3680 | /* |
3681 | * The buffer space for this field was reserved during a previous |
3682 | * call to nfsd4_encode_entry4(). |
3683 | */ |
3684 | static void nfsd4_encode_entry4_nfs_cookie4(const struct nfsd4_readdir *readdir, |
3685 | u64 offset) |
3686 | { |
3687 | __be64 cookie = cpu_to_be64(offset); |
3688 | struct xdr_stream *xdr = readdir->xdr; |
3689 | |
3690 | if (!readdir->cookie_offset) |
3691 | return; |
3692 | write_bytes_to_xdr_buf(xdr->buf, readdir->cookie_offset, &cookie, |
3693 | sizeof(cookie)); |
3694 | } |
3695 | |
3696 | static inline int attributes_need_mount(u32 *bmval) |
3697 | { |
3698 | if (bmval[0] & ~(FATTR4_WORD0_RDATTR_ERROR | FATTR4_WORD0_LEASE_TIME)) |
3699 | return 1; |
3700 | if (bmval[1] & ~FATTR4_WORD1_MOUNTED_ON_FILEID) |
3701 | return 1; |
3702 | return 0; |
3703 | } |
3704 | |
3705 | static __be32 |
3706 | nfsd4_encode_entry4_fattr(struct nfsd4_readdir *cd, const char *name, |
3707 | int namlen) |
3708 | { |
3709 | struct svc_export *exp = cd->rd_fhp->fh_export; |
3710 | struct dentry *dentry; |
3711 | __be32 nfserr; |
3712 | int ignore_crossmnt = 0; |
3713 | |
3714 | dentry = lookup_positive_unlocked(name, cd->rd_fhp->fh_dentry, namlen); |
3715 | if (IS_ERR(ptr: dentry)) |
3716 | return nfserrno(errno: PTR_ERR(ptr: dentry)); |
3717 | |
3718 | exp_get(exp); |
3719 | /* |
3720 | * In the case of a mountpoint, the client may be asking for |
3721 | * attributes that are only properties of the underlying filesystem |
3722 | * as opposed to the cross-mounted file system. In such a case, |
3723 | * we will not follow the cross mount and will fill the attribtutes |
3724 | * directly from the mountpoint dentry. |
3725 | */ |
3726 | if (nfsd_mountpoint(dentry, exp)) { |
3727 | int err; |
3728 | |
3729 | if (!(exp->ex_flags & NFSEXP_V4ROOT) |
3730 | && !attributes_need_mount(bmval: cd->rd_bmval)) { |
3731 | ignore_crossmnt = 1; |
3732 | goto out_encode; |
3733 | } |
3734 | /* |
3735 | * Why the heck aren't we just using nfsd_lookup?? |
3736 | * Different "."/".." handling? Something else? |
3737 | * At least, add a comment here to explain.... |
3738 | */ |
3739 | err = nfsd_cross_mnt(rqstp: cd->rd_rqstp, dpp: &dentry, expp: &exp); |
3740 | if (err) { |
3741 | nfserr = nfserrno(errno: err); |
3742 | goto out_put; |
3743 | } |
3744 | nfserr = check_nfsd_access(exp, rqstp: cd->rd_rqstp); |
3745 | if (nfserr) |
3746 | goto out_put; |
3747 | |
3748 | } |
3749 | out_encode: |
3750 | nfserr = nfsd4_encode_fattr4(rqstp: cd->rd_rqstp, xdr: cd->xdr, NULL, exp, dentry, |
3751 | bmval: cd->rd_bmval, ignore_crossmnt); |
3752 | out_put: |
3753 | dput(dentry); |
3754 | exp_put(exp); |
3755 | return nfserr; |
3756 | } |
3757 | |
3758 | static __be32 |
3759 | nfsd4_encode_entry4_rdattr_error(struct xdr_stream *xdr, __be32 nfserr) |
3760 | { |
3761 | __be32 status; |
3762 | |
3763 | /* attrmask */ |
3764 | status = nfsd4_encode_bitmap4(xdr, FATTR4_WORD0_RDATTR_ERROR, bmval1: 0, bmval2: 0); |
3765 | if (status != nfs_ok) |
3766 | return status; |
3767 | /* attr_vals */ |
3768 | if (xdr_stream_encode_u32(xdr, XDR_UNIT) != XDR_UNIT) |
3769 | return nfserr_resource; |
3770 | /* rdattr_error */ |
3771 | if (xdr_stream_encode_be32(xdr, n: nfserr) != XDR_UNIT) |
3772 | return nfserr_resource; |
3773 | return nfs_ok; |
3774 | } |
3775 | |
3776 | static int |
3777 | nfsd4_encode_entry4(void *ccdv, const char *name, int namlen, |
3778 | loff_t offset, u64 ino, unsigned int d_type) |
3779 | { |
3780 | struct readdir_cd *ccd = ccdv; |
3781 | struct nfsd4_readdir *cd = container_of(ccd, struct nfsd4_readdir, common); |
3782 | struct xdr_stream *xdr = cd->xdr; |
3783 | int start_offset = xdr->buf->len; |
3784 | int cookie_offset; |
3785 | u32 name_and_cookie; |
3786 | int entry_bytes; |
3787 | __be32 nfserr = nfserr_toosmall; |
3788 | |
3789 | /* In nfsv4, "." and ".." never make it onto the wire.. */ |
3790 | if (name && isdotent(name, namlen)) { |
3791 | cd->common.err = nfs_ok; |
3792 | return 0; |
3793 | } |
3794 | |
3795 | /* Encode the previous entry's cookie value */ |
3796 | nfsd4_encode_entry4_nfs_cookie4(readdir: cd, offset); |
3797 | |
3798 | if (xdr_stream_encode_item_present(xdr) != XDR_UNIT) |
3799 | goto fail; |
3800 | |
3801 | /* Reserve send buffer space for this entry's cookie value. */ |
3802 | cookie_offset = xdr->buf->len; |
3803 | if (nfsd4_encode_nfs_cookie4(xdr, OFFSET_MAX) != nfs_ok) |
3804 | goto fail; |
3805 | if (nfsd4_encode_component4(xdr, name, namlen) != nfs_ok) |
3806 | goto fail; |
3807 | nfserr = nfsd4_encode_entry4_fattr(cd, name, namlen); |
3808 | switch (nfserr) { |
3809 | case nfs_ok: |
3810 | break; |
3811 | case nfserr_resource: |
3812 | nfserr = nfserr_toosmall; |
3813 | goto fail; |
3814 | case nfserr_noent: |
3815 | xdr_truncate_encode(xdr, len: start_offset); |
3816 | goto skip_entry; |
3817 | case nfserr_jukebox: |
3818 | /* |
3819 | * The pseudoroot should only display dentries that lead to |
3820 | * exports. If we get EJUKEBOX here, then we can't tell whether |
3821 | * this entry should be included. Just fail the whole READDIR |
3822 | * with NFS4ERR_DELAY in that case, and hope that the situation |
3823 | * will resolve itself by the client's next attempt. |
3824 | */ |
3825 | if (cd->rd_fhp->fh_export->ex_flags & NFSEXP_V4ROOT) |
3826 | goto fail; |
3827 | fallthrough; |
3828 | default: |
3829 | /* |
3830 | * If the client requested the RDATTR_ERROR attribute, |
3831 | * we stuff the error code into this attribute |
3832 | * and continue. If this attribute was not requested, |
3833 | * then in accordance with the spec, we fail the |
3834 | * entire READDIR operation(!) |
3835 | */ |
3836 | if (!(cd->rd_bmval[0] & FATTR4_WORD0_RDATTR_ERROR)) |
3837 | goto fail; |
3838 | if (nfsd4_encode_entry4_rdattr_error(xdr, nfserr)) { |
3839 | nfserr = nfserr_toosmall; |
3840 | goto fail; |
3841 | } |
3842 | } |
3843 | nfserr = nfserr_toosmall; |
3844 | entry_bytes = xdr->buf->len - start_offset; |
3845 | if (entry_bytes > cd->rd_maxcount) |
3846 | goto fail; |
3847 | cd->rd_maxcount -= entry_bytes; |
3848 | /* |
3849 | * RFC 3530 14.2.24 describes rd_dircount as only a "hint", and |
3850 | * notes that it could be zero. If it is zero, then the server |
3851 | * should enforce only the rd_maxcount value. |
3852 | */ |
3853 | if (cd->rd_dircount) { |
3854 | name_and_cookie = 4 + 4 * XDR_QUADLEN(namlen) + 8; |
3855 | if (name_and_cookie > cd->rd_dircount && cd->cookie_offset) |
3856 | goto fail; |
3857 | cd->rd_dircount -= min(cd->rd_dircount, name_and_cookie); |
3858 | if (!cd->rd_dircount) |
3859 | cd->rd_maxcount = 0; |
3860 | } |
3861 | |
3862 | cd->cookie_offset = cookie_offset; |
3863 | skip_entry: |
3864 | cd->common.err = nfs_ok; |
3865 | return 0; |
3866 | fail: |
3867 | xdr_truncate_encode(xdr, len: start_offset); |
3868 | cd->common.err = nfserr; |
3869 | return -EINVAL; |
3870 | } |
3871 | |
3872 | static __be32 |
3873 | nfsd4_encode_verifier4(struct xdr_stream *xdr, const nfs4_verifier *verf) |
3874 | { |
3875 | __be32 *p; |
3876 | |
3877 | p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE); |
3878 | if (!p) |
3879 | return nfserr_resource; |
3880 | memcpy(p, verf->data, sizeof(verf->data)); |
3881 | return nfs_ok; |
3882 | } |
3883 | |
3884 | static __be32 |
3885 | nfsd4_encode_clientid4(struct xdr_stream *xdr, const clientid_t *clientid) |
3886 | { |
3887 | __be32 *p; |
3888 | |
3889 | p = xdr_reserve_space(xdr, nbytes: sizeof(__be64)); |
3890 | if (!p) |
3891 | return nfserr_resource; |
3892 | memcpy(p, clientid, sizeof(*clientid)); |
3893 | return nfs_ok; |
3894 | } |
3895 | |
3896 | /* This is a frequently-encoded item; open-coded for speed */ |
3897 | static __be32 |
3898 | nfsd4_encode_stateid4(struct xdr_stream *xdr, const stateid_t *sid) |
3899 | { |
3900 | __be32 *p; |
3901 | |
3902 | p = xdr_reserve_space(xdr, NFS4_STATEID_SIZE); |
3903 | if (!p) |
3904 | return nfserr_resource; |
3905 | *p++ = cpu_to_be32(sid->si_generation); |
3906 | memcpy(p, &sid->si_opaque, sizeof(sid->si_opaque)); |
3907 | return nfs_ok; |
3908 | } |
3909 | |
3910 | static __be32 |
3911 | nfsd4_encode_sessionid4(struct xdr_stream *xdr, |
3912 | const struct nfs4_sessionid *sessionid) |
3913 | { |
3914 | return nfsd4_encode_opaque_fixed(xdr, data: sessionid->data, |
3915 | NFS4_MAX_SESSIONID_LEN); |
3916 | } |
3917 | |
3918 | static __be32 |
3919 | nfsd4_encode_access(struct nfsd4_compoundres *resp, __be32 nfserr, |
3920 | union nfsd4_op_u *u) |
3921 | { |
3922 | struct nfsd4_access *access = &u->access; |
3923 | struct xdr_stream *xdr = resp->xdr; |
3924 | __be32 status; |
3925 | |
3926 | /* supported */ |
3927 | status = nfsd4_encode_uint32_t(xdr, val: access->ac_supported); |
3928 | if (status != nfs_ok) |
3929 | return status; |
3930 | /* access */ |
3931 | return nfsd4_encode_uint32_t(xdr, val: access->ac_resp_access); |
3932 | } |
3933 | |
3934 | static __be32 nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres *resp, __be32 nfserr, |
3935 | union nfsd4_op_u *u) |
3936 | { |
3937 | struct nfsd4_bind_conn_to_session *bcts = &u->bind_conn_to_session; |
3938 | struct xdr_stream *xdr = resp->xdr; |
3939 | |
3940 | /* bctsr_sessid */ |
3941 | nfserr = nfsd4_encode_sessionid4(xdr, sessionid: &bcts->sessionid); |
3942 | if (nfserr != nfs_ok) |
3943 | return nfserr; |
3944 | /* bctsr_dir */ |
3945 | if (xdr_stream_encode_u32(xdr, n: bcts->dir) != XDR_UNIT) |
3946 | return nfserr_resource; |
3947 | /* bctsr_use_conn_in_rdma_mode */ |
3948 | return nfsd4_encode_bool(xdr, val: false); |
3949 | } |
3950 | |
3951 | static __be32 |
3952 | nfsd4_encode_close(struct nfsd4_compoundres *resp, __be32 nfserr, |
3953 | union nfsd4_op_u *u) |
3954 | { |
3955 | struct nfsd4_close *close = &u->close; |
3956 | struct xdr_stream *xdr = resp->xdr; |
3957 | |
3958 | /* open_stateid */ |
3959 | return nfsd4_encode_stateid4(xdr, sid: &close->cl_stateid); |
3960 | } |
3961 | |
3962 | |
3963 | static __be32 |
3964 | nfsd4_encode_commit(struct nfsd4_compoundres *resp, __be32 nfserr, |
3965 | union nfsd4_op_u *u) |
3966 | { |
3967 | struct nfsd4_commit *commit = &u->commit; |
3968 | |
3969 | return nfsd4_encode_verifier4(xdr: resp->xdr, verf: &commit->co_verf); |
3970 | } |
3971 | |
3972 | static __be32 |
3973 | nfsd4_encode_create(struct nfsd4_compoundres *resp, __be32 nfserr, |
3974 | union nfsd4_op_u *u) |
3975 | { |
3976 | struct nfsd4_create *create = &u->create; |
3977 | struct xdr_stream *xdr = resp->xdr; |
3978 | |
3979 | /* cinfo */ |
3980 | nfserr = nfsd4_encode_change_info4(xdr, c: &create->cr_cinfo); |
3981 | if (nfserr) |
3982 | return nfserr; |
3983 | /* attrset */ |
3984 | return nfsd4_encode_bitmap4(xdr, bmval0: create->cr_bmval[0], |
3985 | bmval1: create->cr_bmval[1], bmval2: create->cr_bmval[2]); |
3986 | } |
3987 | |
3988 | static __be32 |
3989 | nfsd4_encode_getattr(struct nfsd4_compoundres *resp, __be32 nfserr, |
3990 | union nfsd4_op_u *u) |
3991 | { |
3992 | struct nfsd4_getattr *getattr = &u->getattr; |
3993 | struct svc_fh *fhp = getattr->ga_fhp; |
3994 | struct xdr_stream *xdr = resp->xdr; |
3995 | |
3996 | /* obj_attributes */ |
3997 | return nfsd4_encode_fattr4(rqstp: resp->rqstp, xdr, fhp, exp: fhp->fh_export, |
3998 | dentry: fhp->fh_dentry, bmval: getattr->ga_bmval, ignore_crossmnt: 0); |
3999 | } |
4000 | |
4001 | static __be32 |
4002 | nfsd4_encode_getfh(struct nfsd4_compoundres *resp, __be32 nfserr, |
4003 | union nfsd4_op_u *u) |
4004 | { |
4005 | struct xdr_stream *xdr = resp->xdr; |
4006 | struct svc_fh *fhp = u->getfh; |
4007 | |
4008 | /* object */ |
4009 | return nfsd4_encode_nfs_fh4(xdr, fh_handle: &fhp->fh_handle); |
4010 | } |
4011 | |
4012 | static __be32 |
4013 | nfsd4_encode_lock_owner4(struct xdr_stream *xdr, const clientid_t *clientid, |
4014 | const struct xdr_netobj *owner) |
4015 | { |
4016 | __be32 status; |
4017 | |
4018 | /* clientid */ |
4019 | status = nfsd4_encode_clientid4(xdr, clientid); |
4020 | if (status != nfs_ok) |
4021 | return status; |
4022 | /* owner */ |
4023 | return nfsd4_encode_opaque(xdr, data: owner->data, size: owner->len); |
4024 | } |
4025 | |
4026 | static __be32 |
4027 | nfsd4_encode_lock4denied(struct xdr_stream *xdr, |
4028 | const struct nfsd4_lock_denied *ld) |
4029 | { |
4030 | __be32 status; |
4031 | |
4032 | /* offset */ |
4033 | status = nfsd4_encode_offset4(xdr, ld->ld_start); |
4034 | if (status != nfs_ok) |
4035 | return status; |
4036 | /* length */ |
4037 | status = nfsd4_encode_length4(xdr, ld->ld_length); |
4038 | if (status != nfs_ok) |
4039 | return status; |
4040 | /* locktype */ |
4041 | if (xdr_stream_encode_u32(xdr, n: ld->ld_type) != XDR_UNIT) |
4042 | return nfserr_resource; |
4043 | /* owner */ |
4044 | return nfsd4_encode_lock_owner4(xdr, clientid: &ld->ld_clientid, |
4045 | owner: &ld->ld_owner); |
4046 | } |
4047 | |
4048 | static __be32 |
4049 | nfsd4_encode_lock(struct nfsd4_compoundres *resp, __be32 nfserr, |
4050 | union nfsd4_op_u *u) |
4051 | { |
4052 | struct nfsd4_lock *lock = &u->lock; |
4053 | struct xdr_stream *xdr = resp->xdr; |
4054 | __be32 status; |
4055 | |
4056 | switch (nfserr) { |
4057 | case nfs_ok: |
4058 | /* resok4 */ |
4059 | status = nfsd4_encode_stateid4(xdr, sid: &lock->lk_resp_stateid); |
4060 | break; |
4061 | case nfserr_denied: |
4062 | /* denied */ |
4063 | status = nfsd4_encode_lock4denied(xdr, ld: &lock->lk_denied); |
4064 | break; |
4065 | default: |
4066 | return nfserr; |
4067 | } |
4068 | return status != nfs_ok ? status : nfserr; |
4069 | } |
4070 | |
4071 | static __be32 |
4072 | nfsd4_encode_lockt(struct nfsd4_compoundres *resp, __be32 nfserr, |
4073 | union nfsd4_op_u *u) |
4074 | { |
4075 | struct nfsd4_lockt *lockt = &u->lockt; |
4076 | struct xdr_stream *xdr = resp->xdr; |
4077 | __be32 status; |
4078 | |
4079 | if (nfserr == nfserr_denied) { |
4080 | /* denied */ |
4081 | status = nfsd4_encode_lock4denied(xdr, ld: &lockt->lt_denied); |
4082 | if (status != nfs_ok) |
4083 | return status; |
4084 | } |
4085 | return nfserr; |
4086 | } |
4087 | |
4088 | static __be32 |
4089 | nfsd4_encode_locku(struct nfsd4_compoundres *resp, __be32 nfserr, |
4090 | union nfsd4_op_u *u) |
4091 | { |
4092 | struct nfsd4_locku *locku = &u->locku; |
4093 | struct xdr_stream *xdr = resp->xdr; |
4094 | |
4095 | /* lock_stateid */ |
4096 | return nfsd4_encode_stateid4(xdr, sid: &locku->lu_stateid); |
4097 | } |
4098 | |
4099 | |
4100 | static __be32 |
4101 | nfsd4_encode_link(struct nfsd4_compoundres *resp, __be32 nfserr, |
4102 | union nfsd4_op_u *u) |
4103 | { |
4104 | struct nfsd4_link *link = &u->link; |
4105 | struct xdr_stream *xdr = resp->xdr; |
4106 | |
4107 | return nfsd4_encode_change_info4(xdr, c: &link->li_cinfo); |
4108 | } |
4109 | |
4110 | /* |
4111 | * This implementation does not yet support returning an ACE in an |
4112 | * OPEN that offers a delegation. |
4113 | */ |
4114 | static __be32 |
4115 | nfsd4_encode_open_nfsace4(struct xdr_stream *xdr) |
4116 | { |
4117 | __be32 status; |
4118 | |
4119 | /* type */ |
4120 | status = nfsd4_encode_acetype4(xdr, NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE); |
4121 | if (status != nfs_ok) |
4122 | return nfserr_resource; |
4123 | /* flag */ |
4124 | status = nfsd4_encode_aceflag4(xdr, 0); |
4125 | if (status != nfs_ok) |
4126 | return nfserr_resource; |
4127 | /* access mask */ |
4128 | status = nfsd4_encode_acemask4(xdr, 0); |
4129 | if (status != nfs_ok) |
4130 | return nfserr_resource; |
4131 | /* who - empty for now */ |
4132 | if (xdr_stream_encode_u32(xdr, n: 0) != XDR_UNIT) |
4133 | return nfserr_resource; |
4134 | return nfs_ok; |
4135 | } |
4136 | |
4137 | static __be32 |
4138 | nfsd4_encode_open_read_delegation4(struct xdr_stream *xdr, struct nfsd4_open *open) |
4139 | { |
4140 | __be32 status; |
4141 | |
4142 | /* stateid */ |
4143 | status = nfsd4_encode_stateid4(xdr, sid: &open->op_delegate_stateid); |
4144 | if (status != nfs_ok) |
4145 | return status; |
4146 | /* recall */ |
4147 | status = nfsd4_encode_bool(xdr, val: open->op_recall); |
4148 | if (status != nfs_ok) |
4149 | return status; |
4150 | /* permissions */ |
4151 | return nfsd4_encode_open_nfsace4(xdr); |
4152 | } |
4153 | |
4154 | static __be32 |
4155 | nfsd4_encode_nfs_space_limit4(struct xdr_stream *xdr, u64 filesize) |
4156 | { |
4157 | /* limitby */ |
4158 | if (xdr_stream_encode_u32(xdr, n: NFS4_LIMIT_SIZE) != XDR_UNIT) |
4159 | return nfserr_resource; |
4160 | /* filesize */ |
4161 | return nfsd4_encode_uint64_t(xdr, val: filesize); |
4162 | } |
4163 | |
4164 | static __be32 |
4165 | nfsd4_encode_open_write_delegation4(struct xdr_stream *xdr, |
4166 | struct nfsd4_open *open) |
4167 | { |
4168 | __be32 status; |
4169 | |
4170 | /* stateid */ |
4171 | status = nfsd4_encode_stateid4(xdr, sid: &open->op_delegate_stateid); |
4172 | if (status != nfs_ok) |
4173 | return status; |
4174 | /* recall */ |
4175 | status = nfsd4_encode_bool(xdr, val: open->op_recall); |
4176 | if (status != nfs_ok) |
4177 | return status; |
4178 | /* space_limit */ |
4179 | status = nfsd4_encode_nfs_space_limit4(xdr, filesize: 0); |
4180 | if (status != nfs_ok) |
4181 | return status; |
4182 | return nfsd4_encode_open_nfsace4(xdr); |
4183 | } |
4184 | |
4185 | static __be32 |
4186 | nfsd4_encode_open_none_delegation4(struct xdr_stream *xdr, |
4187 | struct nfsd4_open *open) |
4188 | { |
4189 | __be32 status = nfs_ok; |
4190 | |
4191 | /* ond_why */ |
4192 | if (xdr_stream_encode_u32(xdr, n: open->op_why_no_deleg) != XDR_UNIT) |
4193 | return nfserr_resource; |
4194 | switch (open->op_why_no_deleg) { |
4195 | case WND4_CONTENTION: |
4196 | /* ond_server_will_push_deleg */ |
4197 | status = nfsd4_encode_bool(xdr, val: false); |
4198 | break; |
4199 | case WND4_RESOURCE: |
4200 | /* ond_server_will_signal_avail */ |
4201 | status = nfsd4_encode_bool(xdr, val: false); |
4202 | } |
4203 | return status; |
4204 | } |
4205 | |
4206 | static __be32 |
4207 | nfsd4_encode_open_delegation4(struct xdr_stream *xdr, struct nfsd4_open *open) |
4208 | { |
4209 | __be32 status; |
4210 | |
4211 | /* delegation_type */ |
4212 | if (xdr_stream_encode_u32(xdr, n: open->op_delegate_type) != XDR_UNIT) |
4213 | return nfserr_resource; |
4214 | switch (open->op_delegate_type) { |
4215 | case NFS4_OPEN_DELEGATE_NONE: |
4216 | status = nfs_ok; |
4217 | break; |
4218 | case NFS4_OPEN_DELEGATE_READ: |
4219 | /* read */ |
4220 | status = nfsd4_encode_open_read_delegation4(xdr, open); |
4221 | break; |
4222 | case NFS4_OPEN_DELEGATE_WRITE: |
4223 | /* write */ |
4224 | status = nfsd4_encode_open_write_delegation4(xdr, open); |
4225 | break; |
4226 | case NFS4_OPEN_DELEGATE_NONE_EXT: |
4227 | /* od_whynone */ |
4228 | status = nfsd4_encode_open_none_delegation4(xdr, open); |
4229 | break; |
4230 | default: |
4231 | status = nfserr_serverfault; |
4232 | } |
4233 | |
4234 | return status; |
4235 | } |
4236 | |
4237 | static __be32 |
4238 | nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr, |
4239 | union nfsd4_op_u *u) |
4240 | { |
4241 | struct nfsd4_open *open = &u->open; |
4242 | struct xdr_stream *xdr = resp->xdr; |
4243 | |
4244 | /* stateid */ |
4245 | nfserr = nfsd4_encode_stateid4(xdr, sid: &open->op_stateid); |
4246 | if (nfserr != nfs_ok) |
4247 | return nfserr; |
4248 | /* cinfo */ |
4249 | nfserr = nfsd4_encode_change_info4(xdr, c: &open->op_cinfo); |
4250 | if (nfserr != nfs_ok) |
4251 | return nfserr; |
4252 | /* rflags */ |
4253 | nfserr = nfsd4_encode_uint32_t(xdr, val: open->op_rflags); |
4254 | if (nfserr != nfs_ok) |
4255 | return nfserr; |
4256 | /* attrset */ |
4257 | nfserr = nfsd4_encode_bitmap4(xdr, bmval0: open->op_bmval[0], |
4258 | bmval1: open->op_bmval[1], bmval2: open->op_bmval[2]); |
4259 | if (nfserr != nfs_ok) |
4260 | return nfserr; |
4261 | /* delegation */ |
4262 | return nfsd4_encode_open_delegation4(xdr, open); |
4263 | } |
4264 | |
4265 | static __be32 |
4266 | nfsd4_encode_open_confirm(struct nfsd4_compoundres *resp, __be32 nfserr, |
4267 | union nfsd4_op_u *u) |
4268 | { |
4269 | struct nfsd4_open_confirm *oc = &u->open_confirm; |
4270 | struct xdr_stream *xdr = resp->xdr; |
4271 | |
4272 | /* open_stateid */ |
4273 | return nfsd4_encode_stateid4(xdr, sid: &oc->oc_resp_stateid); |
4274 | } |
4275 | |
4276 | static __be32 |
4277 | nfsd4_encode_open_downgrade(struct nfsd4_compoundres *resp, __be32 nfserr, |
4278 | union nfsd4_op_u *u) |
4279 | { |
4280 | struct nfsd4_open_downgrade *od = &u->open_downgrade; |
4281 | struct xdr_stream *xdr = resp->xdr; |
4282 | |
4283 | /* open_stateid */ |
4284 | return nfsd4_encode_stateid4(xdr, sid: &od->od_stateid); |
4285 | } |
4286 | |
4287 | /* |
4288 | * The operation of this function assumes that this is the only |
4289 | * READ operation in the COMPOUND. If there are multiple READs, |
4290 | * we use nfsd4_encode_readv(). |
4291 | */ |
4292 | static __be32 nfsd4_encode_splice_read( |
4293 | struct nfsd4_compoundres *resp, |
4294 | struct nfsd4_read *read, |
4295 | struct file *file, unsigned long maxcount) |
4296 | { |
4297 | struct xdr_stream *xdr = resp->xdr; |
4298 | struct xdr_buf *buf = xdr->buf; |
4299 | int status, space_left; |
4300 | __be32 nfserr; |
4301 | |
4302 | /* |
4303 | * Make sure there is room at the end of buf->head for |
4304 | * svcxdr_encode_opaque_pages() to create a tail buffer |
4305 | * to XDR-pad the payload. |
4306 | */ |
4307 | if (xdr->iov != xdr->buf->head || xdr->end - xdr->p < 1) |
4308 | return nfserr_resource; |
4309 | |
4310 | nfserr = nfsd_splice_read(rqstp: read->rd_rqstp, fhp: read->rd_fhp, |
4311 | file, offset: read->rd_offset, count: &maxcount, |
4312 | eof: &read->rd_eof); |
4313 | read->rd_length = maxcount; |
4314 | if (nfserr) |
4315 | goto out_err; |
4316 | svcxdr_encode_opaque_pages(rqstp: read->rd_rqstp, xdr, pages: buf->pages, |
4317 | base: buf->page_base, len: maxcount); |
4318 | status = svc_encode_result_payload(rqstp: read->rd_rqstp, |
4319 | offset: buf->head[0].iov_len, length: maxcount); |
4320 | if (status) { |
4321 | nfserr = nfserrno(errno: status); |
4322 | goto out_err; |
4323 | } |
4324 | |
4325 | /* |
4326 | * Prepare to encode subsequent operations. |
4327 | * |
4328 | * xdr_truncate_encode() is not safe to use after a successful |
4329 | * splice read has been done, so the following stream |
4330 | * manipulations are open-coded. |
4331 | */ |
4332 | space_left = min_t(int, (void *)xdr->end - (void *)xdr->p, |
4333 | buf->buflen - buf->len); |
4334 | buf->buflen = buf->len + space_left; |
4335 | xdr->end = (__be32 *)((void *)xdr->end + space_left); |
4336 | |
4337 | return nfs_ok; |
4338 | |
4339 | out_err: |
4340 | /* |
4341 | * nfsd_splice_actor may have already messed with the |
4342 | * page length; reset it so as not to confuse |
4343 | * xdr_truncate_encode in our caller. |
4344 | */ |
4345 | buf->page_len = 0; |
4346 | return nfserr; |
4347 | } |
4348 | |
4349 | static __be32 nfsd4_encode_readv(struct nfsd4_compoundres *resp, |
4350 | struct nfsd4_read *read, |
4351 | struct file *file, unsigned long maxcount) |
4352 | { |
4353 | struct xdr_stream *xdr = resp->xdr; |
4354 | unsigned int base = xdr->buf->page_len & ~PAGE_MASK; |
4355 | unsigned int starting_len = xdr->buf->len; |
4356 | __be32 zero = xdr_zero; |
4357 | __be32 nfserr; |
4358 | |
4359 | if (xdr_reserve_space_vec(xdr, nbytes: maxcount) < 0) |
4360 | return nfserr_resource; |
4361 | |
4362 | nfserr = nfsd_iter_read(rqstp: resp->rqstp, fhp: read->rd_fhp, file, |
4363 | offset: read->rd_offset, count: &maxcount, base, |
4364 | eof: &read->rd_eof); |
4365 | read->rd_length = maxcount; |
4366 | if (nfserr) |
4367 | return nfserr; |
4368 | if (svc_encode_result_payload(rqstp: resp->rqstp, offset: starting_len, length: maxcount)) |
4369 | return nfserr_io; |
4370 | xdr_truncate_encode(xdr, len: starting_len + xdr_align_size(n: maxcount)); |
4371 | |
4372 | write_bytes_to_xdr_buf(xdr->buf, starting_len + maxcount, &zero, |
4373 | xdr_pad_size(n: maxcount)); |
4374 | return nfs_ok; |
4375 | } |
4376 | |
4377 | static __be32 |
4378 | nfsd4_encode_read(struct nfsd4_compoundres *resp, __be32 nfserr, |
4379 | union nfsd4_op_u *u) |
4380 | { |
4381 | struct nfsd4_read *read = &u->read; |
4382 | bool splice_ok = test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags); |
4383 | unsigned long maxcount; |
4384 | struct xdr_stream *xdr = resp->xdr; |
4385 | struct file *file; |
4386 | int starting_len = xdr->buf->len; |
4387 | __be32 *p; |
4388 | |
4389 | if (nfserr) |
4390 | return nfserr; |
4391 | file = read->rd_nf->nf_file; |
4392 | |
4393 | p = xdr_reserve_space(xdr, nbytes: 8); /* eof flag and byte count */ |
4394 | if (!p) { |
4395 | WARN_ON_ONCE(splice_ok); |
4396 | return nfserr_resource; |
4397 | } |
4398 | if (resp->xdr->buf->page_len && splice_ok) { |
4399 | WARN_ON_ONCE(1); |
4400 | return nfserr_serverfault; |
4401 | } |
4402 | xdr_commit_encode(xdr); |
4403 | |
4404 | maxcount = min_t(unsigned long, read->rd_length, |
4405 | (xdr->buf->buflen - xdr->buf->len)); |
4406 | |
4407 | if (file->f_op->splice_read && splice_ok) |
4408 | nfserr = nfsd4_encode_splice_read(resp, read, file, maxcount); |
4409 | else |
4410 | nfserr = nfsd4_encode_readv(resp, read, file, maxcount); |
4411 | if (nfserr) { |
4412 | xdr_truncate_encode(xdr, len: starting_len); |
4413 | return nfserr; |
4414 | } |
4415 | |
4416 | p = xdr_encode_bool(p, n: read->rd_eof); |
4417 | *p = cpu_to_be32(read->rd_length); |
4418 | return nfs_ok; |
4419 | } |
4420 | |
4421 | static __be32 |
4422 | nfsd4_encode_readlink(struct nfsd4_compoundres *resp, __be32 nfserr, |
4423 | union nfsd4_op_u *u) |
4424 | { |
4425 | struct nfsd4_readlink *readlink = &u->readlink; |
4426 | __be32 *p, *maxcount_p, zero = xdr_zero; |
4427 | struct xdr_stream *xdr = resp->xdr; |
4428 | int length_offset = xdr->buf->len; |
4429 | int maxcount, status; |
4430 | |
4431 | maxcount_p = xdr_reserve_space(xdr, XDR_UNIT); |
4432 | if (!maxcount_p) |
4433 | return nfserr_resource; |
4434 | maxcount = PAGE_SIZE; |
4435 | |
4436 | p = xdr_reserve_space(xdr, nbytes: maxcount); |
4437 | if (!p) |
4438 | return nfserr_resource; |
4439 | /* |
4440 | * XXX: By default, vfs_readlink() will truncate symlinks if they |
4441 | * would overflow the buffer. Is this kosher in NFSv4? If not, one |
4442 | * easy fix is: if vfs_readlink() precisely fills the buffer, assume |
4443 | * that truncation occurred, and return NFS4ERR_RESOURCE. |
4444 | */ |
4445 | nfserr = nfsd_readlink(readlink->rl_rqstp, readlink->rl_fhp, |
4446 | (char *)p, &maxcount); |
4447 | if (nfserr == nfserr_isdir) |
4448 | nfserr = nfserr_inval; |
4449 | if (nfserr) |
4450 | goto out_err; |
4451 | status = svc_encode_result_payload(rqstp: readlink->rl_rqstp, offset: length_offset, |
4452 | length: maxcount); |
4453 | if (status) { |
4454 | nfserr = nfserrno(errno: status); |
4455 | goto out_err; |
4456 | } |
4457 | *maxcount_p = cpu_to_be32(maxcount); |
4458 | xdr_truncate_encode(xdr, len: length_offset + 4 + xdr_align_size(n: maxcount)); |
4459 | write_bytes_to_xdr_buf(xdr->buf, length_offset + 4 + maxcount, &zero, |
4460 | xdr_pad_size(n: maxcount)); |
4461 | return nfs_ok; |
4462 | |
4463 | out_err: |
4464 | xdr_truncate_encode(xdr, len: length_offset); |
4465 | return nfserr; |
4466 | } |
4467 | |
4468 | static __be32 nfsd4_encode_dirlist4(struct xdr_stream *xdr, |
4469 | struct nfsd4_readdir *readdir, |
4470 | u32 max_payload) |
4471 | { |
4472 | int bytes_left, maxcount, starting_len = xdr->buf->len; |
4473 | loff_t offset; |
4474 | __be32 status; |
4475 | |
4476 | /* |
4477 | * Number of bytes left for directory entries allowing for the |
4478 | * final 8 bytes of the readdir and a following failed op. |
4479 | */ |
4480 | bytes_left = xdr->buf->buflen - xdr->buf->len - |
4481 | COMPOUND_ERR_SLACK_SPACE - XDR_UNIT * 2; |
4482 | if (bytes_left < 0) |
4483 | return nfserr_resource; |
4484 | maxcount = min_t(u32, readdir->rd_maxcount, max_payload); |
4485 | |
4486 | /* |
4487 | * The RFC defines rd_maxcount as the size of the |
4488 | * READDIR4resok structure, which includes the verifier |
4489 | * and the 8 bytes encoded at the end of this function. |
4490 | */ |
4491 | if (maxcount < XDR_UNIT * 4) |
4492 | return nfserr_toosmall; |
4493 | maxcount = min_t(int, maxcount - XDR_UNIT * 4, bytes_left); |
4494 | |
4495 | /* RFC 3530 14.2.24 allows us to ignore dircount when it's 0 */ |
4496 | if (!readdir->rd_dircount) |
4497 | readdir->rd_dircount = max_payload; |
4498 | |
4499 | /* *entries */ |
4500 | readdir->xdr = xdr; |
4501 | readdir->rd_maxcount = maxcount; |
4502 | readdir->common.err = 0; |
4503 | readdir->cookie_offset = 0; |
4504 | offset = readdir->rd_cookie; |
4505 | status = nfsd_readdir(readdir->rd_rqstp, readdir->rd_fhp, &offset, |
4506 | &readdir->common, nfsd4_encode_entry4); |
4507 | if (status) |
4508 | return status; |
4509 | if (readdir->common.err == nfserr_toosmall && |
4510 | xdr->buf->len == starting_len) { |
4511 | /* No entries were encoded. Which limit did we hit? */ |
4512 | if (maxcount - XDR_UNIT * 4 < bytes_left) |
4513 | /* It was the fault of rd_maxcount */ |
4514 | return nfserr_toosmall; |
4515 | /* We ran out of buffer space */ |
4516 | return nfserr_resource; |
4517 | } |
4518 | /* Encode the final entry's cookie value */ |
4519 | nfsd4_encode_entry4_nfs_cookie4(readdir, offset); |
4520 | /* No entries follow */ |
4521 | if (xdr_stream_encode_item_absent(xdr) != XDR_UNIT) |
4522 | return nfserr_resource; |
4523 | |
4524 | /* eof */ |
4525 | return nfsd4_encode_bool(xdr, val: readdir->common.err == nfserr_eof); |
4526 | } |
4527 | |
4528 | static __be32 |
4529 | nfsd4_encode_readdir(struct nfsd4_compoundres *resp, __be32 nfserr, |
4530 | union nfsd4_op_u *u) |
4531 | { |
4532 | struct nfsd4_readdir *readdir = &u->readdir; |
4533 | struct xdr_stream *xdr = resp->xdr; |
4534 | int starting_len = xdr->buf->len; |
4535 | |
4536 | /* cookieverf */ |
4537 | nfserr = nfsd4_encode_verifier4(xdr, verf: &readdir->rd_verf); |
4538 | if (nfserr != nfs_ok) |
4539 | return nfserr; |
4540 | |
4541 | /* reply */ |
4542 | nfserr = nfsd4_encode_dirlist4(xdr, readdir, max_payload: svc_max_payload(rqstp: resp->rqstp)); |
4543 | if (nfserr != nfs_ok) |
4544 | xdr_truncate_encode(xdr, len: starting_len); |
4545 | return nfserr; |
4546 | } |
4547 | |
4548 | static __be32 |
4549 | nfsd4_encode_remove(struct nfsd4_compoundres *resp, __be32 nfserr, |
4550 | union nfsd4_op_u *u) |
4551 | { |
4552 | struct nfsd4_remove *remove = &u->remove; |
4553 | struct xdr_stream *xdr = resp->xdr; |
4554 | |
4555 | return nfsd4_encode_change_info4(xdr, c: &remove->rm_cinfo); |
4556 | } |
4557 | |
4558 | static __be32 |
4559 | nfsd4_encode_rename(struct nfsd4_compoundres *resp, __be32 nfserr, |
4560 | union nfsd4_op_u *u) |
4561 | { |
4562 | struct nfsd4_rename *rename = &u->rename; |
4563 | struct xdr_stream *xdr = resp->xdr; |
4564 | |
4565 | nfserr = nfsd4_encode_change_info4(xdr, c: &rename->rn_sinfo); |
4566 | if (nfserr) |
4567 | return nfserr; |
4568 | return nfsd4_encode_change_info4(xdr, c: &rename->rn_tinfo); |
4569 | } |
4570 | |
4571 | static __be32 |
4572 | nfsd4_encode_rpcsec_gss_info(struct xdr_stream *xdr, |
4573 | struct rpcsec_gss_info *info) |
4574 | { |
4575 | __be32 status; |
4576 | |
4577 | /* oid */ |
4578 | if (xdr_stream_encode_opaque(xdr, ptr: info->oid.data, len: info->oid.len) < 0) |
4579 | return nfserr_resource; |
4580 | /* qop */ |
4581 | status = nfsd4_encode_qop4(xdr, info->qop); |
4582 | if (status != nfs_ok) |
4583 | return status; |
4584 | /* service */ |
4585 | if (xdr_stream_encode_u32(xdr, n: info->service) != XDR_UNIT) |
4586 | return nfserr_resource; |
4587 | |
4588 | return nfs_ok; |
4589 | } |
4590 | |
4591 | static __be32 |
4592 | nfsd4_do_encode_secinfo(struct xdr_stream *xdr, struct svc_export *exp) |
4593 | { |
4594 | u32 i, nflavs, supported; |
4595 | struct exp_flavor_info *flavs; |
4596 | struct exp_flavor_info def_flavs[2]; |
4597 | static bool report = true; |
4598 | __be32 *flavorsp; |
4599 | __be32 status; |
4600 | |
4601 | if (exp->ex_nflavors) { |
4602 | flavs = exp->ex_flavors; |
4603 | nflavs = exp->ex_nflavors; |
4604 | } else { /* Handling of some defaults in absence of real secinfo: */ |
4605 | flavs = def_flavs; |
4606 | if (exp->ex_client->flavour->flavour == RPC_AUTH_UNIX) { |
4607 | nflavs = 2; |
4608 | flavs[0].pseudoflavor = RPC_AUTH_UNIX; |
4609 | flavs[1].pseudoflavor = RPC_AUTH_NULL; |
4610 | } else if (exp->ex_client->flavour->flavour == RPC_AUTH_GSS) { |
4611 | nflavs = 1; |
4612 | flavs[0].pseudoflavor |
4613 | = svcauth_gss_flavor(dom: exp->ex_client); |
4614 | } else { |
4615 | nflavs = 1; |
4616 | flavs[0].pseudoflavor |
4617 | = exp->ex_client->flavour->flavour; |
4618 | } |
4619 | } |
4620 | |
4621 | supported = 0; |
4622 | flavorsp = xdr_reserve_space(xdr, XDR_UNIT); |
4623 | if (!flavorsp) |
4624 | return nfserr_resource; |
4625 | |
4626 | for (i = 0; i < nflavs; i++) { |
4627 | rpc_authflavor_t pf = flavs[i].pseudoflavor; |
4628 | struct rpcsec_gss_info info; |
4629 | |
4630 | if (rpcauth_get_gssinfo(pf, &info) == 0) { |
4631 | supported++; |
4632 | |
4633 | /* flavor */ |
4634 | status = nfsd4_encode_uint32_t(xdr, val: RPC_AUTH_GSS); |
4635 | if (status != nfs_ok) |
4636 | return status; |
4637 | /* flavor_info */ |
4638 | status = nfsd4_encode_rpcsec_gss_info(xdr, info: &info); |
4639 | if (status != nfs_ok) |
4640 | return status; |
4641 | } else if (pf < RPC_AUTH_MAXFLAVOR) { |
4642 | supported++; |
4643 | |
4644 | /* flavor */ |
4645 | status = nfsd4_encode_uint32_t(xdr, val: pf); |
4646 | if (status != nfs_ok) |
4647 | return status; |
4648 | } else { |
4649 | if (report) |
4650 | pr_warn("NFS: SECINFO: security flavor %u " |
4651 | "is not supported\n" , pf); |
4652 | } |
4653 | } |
4654 | |
4655 | if (nflavs != supported) |
4656 | report = false; |
4657 | *flavorsp = cpu_to_be32(supported); |
4658 | return 0; |
4659 | } |
4660 | |
4661 | static __be32 |
4662 | nfsd4_encode_secinfo(struct nfsd4_compoundres *resp, __be32 nfserr, |
4663 | union nfsd4_op_u *u) |
4664 | { |
4665 | struct nfsd4_secinfo *secinfo = &u->secinfo; |
4666 | struct xdr_stream *xdr = resp->xdr; |
4667 | |
4668 | return nfsd4_do_encode_secinfo(xdr, exp: secinfo->si_exp); |
4669 | } |
4670 | |
4671 | static __be32 |
4672 | nfsd4_encode_secinfo_no_name(struct nfsd4_compoundres *resp, __be32 nfserr, |
4673 | union nfsd4_op_u *u) |
4674 | { |
4675 | struct nfsd4_secinfo_no_name *secinfo = &u->secinfo_no_name; |
4676 | struct xdr_stream *xdr = resp->xdr; |
4677 | |
4678 | return nfsd4_do_encode_secinfo(xdr, exp: secinfo->sin_exp); |
4679 | } |
4680 | |
4681 | static __be32 |
4682 | nfsd4_encode_setattr(struct nfsd4_compoundres *resp, __be32 nfserr, |
4683 | union nfsd4_op_u *u) |
4684 | { |
4685 | struct nfsd4_setattr *setattr = &u->setattr; |
4686 | __be32 status; |
4687 | |
4688 | switch (nfserr) { |
4689 | case nfs_ok: |
4690 | /* attrsset */ |
4691 | status = nfsd4_encode_bitmap4(xdr: resp->xdr, bmval0: setattr->sa_bmval[0], |
4692 | bmval1: setattr->sa_bmval[1], |
4693 | bmval2: setattr->sa_bmval[2]); |
4694 | break; |
4695 | default: |
4696 | /* attrsset */ |
4697 | status = nfsd4_encode_bitmap4(xdr: resp->xdr, bmval0: 0, bmval1: 0, bmval2: 0); |
4698 | } |
4699 | return status != nfs_ok ? status : nfserr; |
4700 | } |
4701 | |
4702 | static __be32 |
4703 | nfsd4_encode_setclientid(struct nfsd4_compoundres *resp, __be32 nfserr, |
4704 | union nfsd4_op_u *u) |
4705 | { |
4706 | struct nfsd4_setclientid *scd = &u->setclientid; |
4707 | struct xdr_stream *xdr = resp->xdr; |
4708 | |
4709 | if (!nfserr) { |
4710 | nfserr = nfsd4_encode_clientid4(xdr, clientid: &scd->se_clientid); |
4711 | if (nfserr != nfs_ok) |
4712 | goto out; |
4713 | nfserr = nfsd4_encode_verifier4(xdr, verf: &scd->se_confirm); |
4714 | } else if (nfserr == nfserr_clid_inuse) { |
4715 | /* empty network id */ |
4716 | if (xdr_stream_encode_u32(xdr, n: 0) < 0) { |
4717 | nfserr = nfserr_resource; |
4718 | goto out; |
4719 | } |
4720 | /* empty universal address */ |
4721 | if (xdr_stream_encode_u32(xdr, n: 0) < 0) { |
4722 | nfserr = nfserr_resource; |
4723 | goto out; |
4724 | } |
4725 | } |
4726 | out: |
4727 | return nfserr; |
4728 | } |
4729 | |
4730 | static __be32 |
4731 | nfsd4_encode_write(struct nfsd4_compoundres *resp, __be32 nfserr, |
4732 | union nfsd4_op_u *u) |
4733 | { |
4734 | struct nfsd4_write *write = &u->write; |
4735 | struct xdr_stream *xdr = resp->xdr; |
4736 | |
4737 | /* count */ |
4738 | nfserr = nfsd4_encode_count4(xdr, write->wr_bytes_written); |
4739 | if (nfserr) |
4740 | return nfserr; |
4741 | /* committed */ |
4742 | if (xdr_stream_encode_u32(xdr, n: write->wr_how_written) != XDR_UNIT) |
4743 | return nfserr_resource; |
4744 | /* writeverf */ |
4745 | return nfsd4_encode_verifier4(xdr, verf: &write->wr_verifier); |
4746 | } |
4747 | |
4748 | static __be32 |
4749 | nfsd4_encode_state_protect_ops4(struct xdr_stream *xdr, |
4750 | struct nfsd4_exchange_id *exid) |
4751 | { |
4752 | __be32 status; |
4753 | |
4754 | /* spo_must_enforce */ |
4755 | status = nfsd4_encode_bitmap4(xdr, bmval0: exid->spo_must_enforce[0], |
4756 | bmval1: exid->spo_must_enforce[1], |
4757 | bmval2: exid->spo_must_enforce[2]); |
4758 | if (status != nfs_ok) |
4759 | return status; |
4760 | /* spo_must_allow */ |
4761 | return nfsd4_encode_bitmap4(xdr, bmval0: exid->spo_must_allow[0], |
4762 | bmval1: exid->spo_must_allow[1], |
4763 | bmval2: exid->spo_must_allow[2]); |
4764 | } |
4765 | |
4766 | static __be32 |
4767 | nfsd4_encode_state_protect4_r(struct xdr_stream *xdr, struct nfsd4_exchange_id *exid) |
4768 | { |
4769 | __be32 status; |
4770 | |
4771 | if (xdr_stream_encode_u32(xdr, n: exid->spa_how) != XDR_UNIT) |
4772 | return nfserr_resource; |
4773 | switch (exid->spa_how) { |
4774 | case SP4_NONE: |
4775 | status = nfs_ok; |
4776 | break; |
4777 | case SP4_MACH_CRED: |
4778 | /* spr_mach_ops */ |
4779 | status = nfsd4_encode_state_protect_ops4(xdr, exid); |
4780 | break; |
4781 | default: |
4782 | status = nfserr_serverfault; |
4783 | } |
4784 | return status; |
4785 | } |
4786 | |
4787 | static __be32 |
4788 | nfsd4_encode_server_owner4(struct xdr_stream *xdr, struct svc_rqst *rqstp) |
4789 | { |
4790 | struct nfsd_net *nn = net_generic(SVC_NET(rqstp), id: nfsd_net_id); |
4791 | __be32 status; |
4792 | |
4793 | /* so_minor_id */ |
4794 | status = nfsd4_encode_uint64_t(xdr, val: 0); |
4795 | if (status != nfs_ok) |
4796 | return status; |
4797 | /* so_major_id */ |
4798 | return nfsd4_encode_opaque(xdr, data: nn->nfsd_name, strlen(nn->nfsd_name)); |
4799 | } |
4800 | |
4801 | static __be32 |
4802 | nfsd4_encode_exchange_id(struct nfsd4_compoundres *resp, __be32 nfserr, |
4803 | union nfsd4_op_u *u) |
4804 | { |
4805 | struct nfsd_net *nn = net_generic(SVC_NET(resp->rqstp), id: nfsd_net_id); |
4806 | struct nfsd4_exchange_id *exid = &u->exchange_id; |
4807 | struct xdr_stream *xdr = resp->xdr; |
4808 | |
4809 | /* eir_clientid */ |
4810 | nfserr = nfsd4_encode_clientid4(xdr, clientid: &exid->clientid); |
4811 | if (nfserr != nfs_ok) |
4812 | return nfserr; |
4813 | /* eir_sequenceid */ |
4814 | nfserr = nfsd4_encode_sequenceid4(xdr, exid->seqid); |
4815 | if (nfserr != nfs_ok) |
4816 | return nfserr; |
4817 | /* eir_flags */ |
4818 | nfserr = nfsd4_encode_uint32_t(xdr, val: exid->flags); |
4819 | if (nfserr != nfs_ok) |
4820 | return nfserr; |
4821 | /* eir_state_protect */ |
4822 | nfserr = nfsd4_encode_state_protect4_r(xdr, exid); |
4823 | if (nfserr != nfs_ok) |
4824 | return nfserr; |
4825 | /* eir_server_owner */ |
4826 | nfserr = nfsd4_encode_server_owner4(xdr, rqstp: resp->rqstp); |
4827 | if (nfserr != nfs_ok) |
4828 | return nfserr; |
4829 | /* eir_server_scope */ |
4830 | nfserr = nfsd4_encode_opaque(xdr, data: nn->nfsd_name, |
4831 | strlen(nn->nfsd_name)); |
4832 | if (nfserr != nfs_ok) |
4833 | return nfserr; |
4834 | /* eir_server_impl_id<1> */ |
4835 | if (xdr_stream_encode_u32(xdr, n: 0) != XDR_UNIT) |
4836 | return nfserr_resource; |
4837 | |
4838 | return nfs_ok; |
4839 | } |
4840 | |
4841 | static __be32 |
4842 | nfsd4_encode_channel_attrs4(struct xdr_stream *xdr, |
4843 | const struct nfsd4_channel_attrs *attrs) |
4844 | { |
4845 | __be32 status; |
4846 | |
4847 | /* ca_headerpadsize */ |
4848 | status = nfsd4_encode_count4(xdr, 0); |
4849 | if (status != nfs_ok) |
4850 | return status; |
4851 | /* ca_maxrequestsize */ |
4852 | status = nfsd4_encode_count4(xdr, attrs->maxreq_sz); |
4853 | if (status != nfs_ok) |
4854 | return status; |
4855 | /* ca_maxresponsesize */ |
4856 | status = nfsd4_encode_count4(xdr, attrs->maxresp_sz); |
4857 | if (status != nfs_ok) |
4858 | return status; |
4859 | /* ca_maxresponsesize_cached */ |
4860 | status = nfsd4_encode_count4(xdr, attrs->maxresp_cached); |
4861 | if (status != nfs_ok) |
4862 | return status; |
4863 | /* ca_maxoperations */ |
4864 | status = nfsd4_encode_count4(xdr, attrs->maxops); |
4865 | if (status != nfs_ok) |
4866 | return status; |
4867 | /* ca_maxrequests */ |
4868 | status = nfsd4_encode_count4(xdr, attrs->maxreqs); |
4869 | if (status != nfs_ok) |
4870 | return status; |
4871 | /* ca_rdma_ird<1> */ |
4872 | if (xdr_stream_encode_u32(xdr, n: attrs->nr_rdma_attrs) != XDR_UNIT) |
4873 | return nfserr_resource; |
4874 | if (attrs->nr_rdma_attrs) |
4875 | return nfsd4_encode_uint32_t(xdr, val: attrs->rdma_attrs); |
4876 | return nfs_ok; |
4877 | } |
4878 | |
4879 | static __be32 |
4880 | nfsd4_encode_create_session(struct nfsd4_compoundres *resp, __be32 nfserr, |
4881 | union nfsd4_op_u *u) |
4882 | { |
4883 | struct nfsd4_create_session *sess = &u->create_session; |
4884 | struct xdr_stream *xdr = resp->xdr; |
4885 | |
4886 | /* csr_sessionid */ |
4887 | nfserr = nfsd4_encode_sessionid4(xdr, sessionid: &sess->sessionid); |
4888 | if (nfserr != nfs_ok) |
4889 | return nfserr; |
4890 | /* csr_sequence */ |
4891 | nfserr = nfsd4_encode_sequenceid4(xdr, sess->seqid); |
4892 | if (nfserr != nfs_ok) |
4893 | return nfserr; |
4894 | /* csr_flags */ |
4895 | nfserr = nfsd4_encode_uint32_t(xdr, val: sess->flags); |
4896 | if (nfserr != nfs_ok) |
4897 | return nfserr; |
4898 | /* csr_fore_chan_attrs */ |
4899 | nfserr = nfsd4_encode_channel_attrs4(xdr, attrs: &sess->fore_channel); |
4900 | if (nfserr != nfs_ok) |
4901 | return nfserr; |
4902 | /* csr_back_chan_attrs */ |
4903 | return nfsd4_encode_channel_attrs4(xdr, attrs: &sess->back_channel); |
4904 | } |
4905 | |
4906 | static __be32 |
4907 | nfsd4_encode_sequence(struct nfsd4_compoundres *resp, __be32 nfserr, |
4908 | union nfsd4_op_u *u) |
4909 | { |
4910 | struct nfsd4_sequence *seq = &u->sequence; |
4911 | struct xdr_stream *xdr = resp->xdr; |
4912 | |
4913 | /* sr_sessionid */ |
4914 | nfserr = nfsd4_encode_sessionid4(xdr, sessionid: &seq->sessionid); |
4915 | if (nfserr != nfs_ok) |
4916 | return nfserr; |
4917 | /* sr_sequenceid */ |
4918 | nfserr = nfsd4_encode_sequenceid4(xdr, seq->seqid); |
4919 | if (nfserr != nfs_ok) |
4920 | return nfserr; |
4921 | /* sr_slotid */ |
4922 | nfserr = nfsd4_encode_slotid4(xdr, seq->slotid); |
4923 | if (nfserr != nfs_ok) |
4924 | return nfserr; |
4925 | /* Note slotid's are numbered from zero: */ |
4926 | /* sr_highest_slotid */ |
4927 | nfserr = nfsd4_encode_slotid4(xdr, seq->maxslots - 1); |
4928 | if (nfserr != nfs_ok) |
4929 | return nfserr; |
4930 | /* sr_target_highest_slotid */ |
4931 | nfserr = nfsd4_encode_slotid4(xdr, seq->maxslots - 1); |
4932 | if (nfserr != nfs_ok) |
4933 | return nfserr; |
4934 | /* sr_status_flags */ |
4935 | nfserr = nfsd4_encode_uint32_t(xdr, val: seq->status_flags); |
4936 | if (nfserr != nfs_ok) |
4937 | return nfserr; |
4938 | |
4939 | resp->cstate.data_offset = xdr->buf->len; /* DRC cache data pointer */ |
4940 | return nfs_ok; |
4941 | } |
4942 | |
4943 | static __be32 |
4944 | nfsd4_encode_test_stateid(struct nfsd4_compoundres *resp, __be32 nfserr, |
4945 | union nfsd4_op_u *u) |
4946 | { |
4947 | struct nfsd4_test_stateid *test_stateid = &u->test_stateid; |
4948 | struct nfsd4_test_stateid_id *stateid, *next; |
4949 | struct xdr_stream *xdr = resp->xdr; |
4950 | |
4951 | /* tsr_status_codes<> */ |
4952 | if (xdr_stream_encode_u32(xdr, n: test_stateid->ts_num_ids) != XDR_UNIT) |
4953 | return nfserr_resource; |
4954 | list_for_each_entry_safe(stateid, next, |
4955 | &test_stateid->ts_stateid_list, ts_id_list) { |
4956 | if (xdr_stream_encode_be32(xdr, n: stateid->ts_id_status) != XDR_UNIT) |
4957 | return nfserr_resource; |
4958 | } |
4959 | return nfs_ok; |
4960 | } |
4961 | |
4962 | #ifdef CONFIG_NFSD_PNFS |
4963 | static __be32 |
4964 | nfsd4_encode_device_addr4(struct xdr_stream *xdr, |
4965 | const struct nfsd4_getdeviceinfo *gdev) |
4966 | { |
4967 | u32 needed_len, starting_len = xdr->buf->len; |
4968 | const struct nfsd4_layout_ops *ops; |
4969 | __be32 status; |
4970 | |
4971 | /* da_layout_type */ |
4972 | if (xdr_stream_encode_u32(xdr, n: gdev->gd_layout_type) != XDR_UNIT) |
4973 | return nfserr_resource; |
4974 | /* da_addr_body */ |
4975 | ops = nfsd4_layout_ops[gdev->gd_layout_type]; |
4976 | status = ops->encode_getdeviceinfo(xdr, gdev); |
4977 | if (status != nfs_ok) { |
4978 | /* |
4979 | * Don't burden the layout drivers with enforcing |
4980 | * gd_maxcount. Just tell the client to come back |
4981 | * with a bigger buffer if it's not enough. |
4982 | */ |
4983 | if (xdr->buf->len + XDR_UNIT > gdev->gd_maxcount) |
4984 | goto toosmall; |
4985 | return status; |
4986 | } |
4987 | |
4988 | return nfs_ok; |
4989 | |
4990 | toosmall: |
4991 | needed_len = xdr->buf->len + XDR_UNIT; /* notifications */ |
4992 | xdr_truncate_encode(xdr, len: starting_len); |
4993 | |
4994 | status = nfsd4_encode_count4(xdr, needed_len); |
4995 | if (status != nfs_ok) |
4996 | return status; |
4997 | return nfserr_toosmall; |
4998 | } |
4999 | |
5000 | static __be32 |
5001 | nfsd4_encode_getdeviceinfo(struct nfsd4_compoundres *resp, __be32 nfserr, |
5002 | union nfsd4_op_u *u) |
5003 | { |
5004 | struct nfsd4_getdeviceinfo *gdev = &u->getdeviceinfo; |
5005 | struct xdr_stream *xdr = resp->xdr; |
5006 | |
5007 | /* gdir_device_addr */ |
5008 | nfserr = nfsd4_encode_device_addr4(xdr, gdev); |
5009 | if (nfserr) |
5010 | return nfserr; |
5011 | /* gdir_notification */ |
5012 | return nfsd4_encode_bitmap4(xdr, bmval0: gdev->gd_notify_types, bmval1: 0, bmval2: 0); |
5013 | } |
5014 | |
5015 | static __be32 |
5016 | nfsd4_encode_layout4(struct xdr_stream *xdr, const struct nfsd4_layoutget *lgp) |
5017 | { |
5018 | const struct nfsd4_layout_ops *ops = nfsd4_layout_ops[lgp->lg_layout_type]; |
5019 | __be32 status; |
5020 | |
5021 | /* lo_offset */ |
5022 | status = nfsd4_encode_offset4(xdr, lgp->lg_seg.offset); |
5023 | if (status != nfs_ok) |
5024 | return status; |
5025 | /* lo_length */ |
5026 | status = nfsd4_encode_length4(xdr, lgp->lg_seg.length); |
5027 | if (status != nfs_ok) |
5028 | return status; |
5029 | /* lo_iomode */ |
5030 | if (xdr_stream_encode_u32(xdr, n: lgp->lg_seg.iomode) != XDR_UNIT) |
5031 | return nfserr_resource; |
5032 | /* lo_content */ |
5033 | if (xdr_stream_encode_u32(xdr, n: lgp->lg_layout_type) != XDR_UNIT) |
5034 | return nfserr_resource; |
5035 | return ops->encode_layoutget(xdr, lgp); |
5036 | } |
5037 | |
5038 | static __be32 |
5039 | nfsd4_encode_layoutget(struct nfsd4_compoundres *resp, __be32 nfserr, |
5040 | union nfsd4_op_u *u) |
5041 | { |
5042 | struct nfsd4_layoutget *lgp = &u->layoutget; |
5043 | struct xdr_stream *xdr = resp->xdr; |
5044 | |
5045 | /* logr_return_on_close */ |
5046 | nfserr = nfsd4_encode_bool(xdr, val: true); |
5047 | if (nfserr != nfs_ok) |
5048 | return nfserr; |
5049 | /* logr_stateid */ |
5050 | nfserr = nfsd4_encode_stateid4(xdr, sid: &lgp->lg_sid); |
5051 | if (nfserr != nfs_ok) |
5052 | return nfserr; |
5053 | /* logr_layout<> */ |
5054 | if (xdr_stream_encode_u32(xdr, n: 1) != XDR_UNIT) |
5055 | return nfserr_resource; |
5056 | return nfsd4_encode_layout4(xdr, lgp); |
5057 | } |
5058 | |
5059 | static __be32 |
5060 | nfsd4_encode_layoutcommit(struct nfsd4_compoundres *resp, __be32 nfserr, |
5061 | union nfsd4_op_u *u) |
5062 | { |
5063 | struct nfsd4_layoutcommit *lcp = &u->layoutcommit; |
5064 | struct xdr_stream *xdr = resp->xdr; |
5065 | |
5066 | /* ns_sizechanged */ |
5067 | nfserr = nfsd4_encode_bool(xdr, val: lcp->lc_size_chg); |
5068 | if (nfserr != nfs_ok) |
5069 | return nfserr; |
5070 | if (lcp->lc_size_chg) |
5071 | /* ns_size */ |
5072 | return nfsd4_encode_length4(xdr, lcp->lc_newsize); |
5073 | return nfs_ok; |
5074 | } |
5075 | |
5076 | static __be32 |
5077 | nfsd4_encode_layoutreturn(struct nfsd4_compoundres *resp, __be32 nfserr, |
5078 | union nfsd4_op_u *u) |
5079 | { |
5080 | struct nfsd4_layoutreturn *lrp = &u->layoutreturn; |
5081 | struct xdr_stream *xdr = resp->xdr; |
5082 | |
5083 | /* lrs_present */ |
5084 | nfserr = nfsd4_encode_bool(xdr, val: lrp->lrs_present); |
5085 | if (nfserr != nfs_ok) |
5086 | return nfserr; |
5087 | if (lrp->lrs_present) |
5088 | /* lrs_stateid */ |
5089 | return nfsd4_encode_stateid4(xdr, sid: &lrp->lr_sid); |
5090 | return nfs_ok; |
5091 | } |
5092 | #endif /* CONFIG_NFSD_PNFS */ |
5093 | |
5094 | static __be32 |
5095 | nfsd4_encode_write_response4(struct xdr_stream *xdr, |
5096 | const struct nfsd4_copy *copy) |
5097 | { |
5098 | const struct nfsd42_write_res *write = ©->cp_res; |
5099 | u32 count = nfsd4_copy_is_sync(copy) ? 0 : 1; |
5100 | __be32 status; |
5101 | |
5102 | /* wr_callback_id<1> */ |
5103 | if (xdr_stream_encode_u32(xdr, n: count) != XDR_UNIT) |
5104 | return nfserr_resource; |
5105 | if (count) { |
5106 | status = nfsd4_encode_stateid4(xdr, sid: &write->cb_stateid); |
5107 | if (status != nfs_ok) |
5108 | return status; |
5109 | } |
5110 | |
5111 | /* wr_count */ |
5112 | status = nfsd4_encode_length4(xdr, write->wr_bytes_written); |
5113 | if (status != nfs_ok) |
5114 | return status; |
5115 | /* wr_committed */ |
5116 | if (xdr_stream_encode_u32(xdr, n: write->wr_stable_how) != XDR_UNIT) |
5117 | return nfserr_resource; |
5118 | /* wr_writeverf */ |
5119 | return nfsd4_encode_verifier4(xdr, verf: &write->wr_verifier); |
5120 | } |
5121 | |
5122 | static __be32 nfsd4_encode_copy_requirements4(struct xdr_stream *xdr, |
5123 | const struct nfsd4_copy *copy) |
5124 | { |
5125 | __be32 status; |
5126 | |
5127 | /* cr_consecutive */ |
5128 | status = nfsd4_encode_bool(xdr, val: true); |
5129 | if (status != nfs_ok) |
5130 | return status; |
5131 | /* cr_synchronous */ |
5132 | return nfsd4_encode_bool(xdr, val: nfsd4_copy_is_sync(copy)); |
5133 | } |
5134 | |
5135 | static __be32 |
5136 | nfsd4_encode_copy(struct nfsd4_compoundres *resp, __be32 nfserr, |
5137 | union nfsd4_op_u *u) |
5138 | { |
5139 | struct nfsd4_copy *copy = &u->copy; |
5140 | |
5141 | nfserr = nfsd4_encode_write_response4(xdr: resp->xdr, copy); |
5142 | if (nfserr != nfs_ok) |
5143 | return nfserr; |
5144 | return nfsd4_encode_copy_requirements4(xdr: resp->xdr, copy); |
5145 | } |
5146 | |
5147 | static __be32 |
5148 | nfsd4_encode_netloc4(struct xdr_stream *xdr, const struct nl4_server *ns) |
5149 | { |
5150 | __be32 status; |
5151 | |
5152 | if (xdr_stream_encode_u32(xdr, n: ns->nl4_type) != XDR_UNIT) |
5153 | return nfserr_resource; |
5154 | switch (ns->nl4_type) { |
5155 | case NL4_NETADDR: |
5156 | /* nl_addr */ |
5157 | status = nfsd4_encode_netaddr4(xdr, addr: &ns->u.nl4_addr); |
5158 | break; |
5159 | default: |
5160 | status = nfserr_serverfault; |
5161 | } |
5162 | return status; |
5163 | } |
5164 | |
5165 | static __be32 |
5166 | nfsd4_encode_copy_notify(struct nfsd4_compoundres *resp, __be32 nfserr, |
5167 | union nfsd4_op_u *u) |
5168 | { |
5169 | struct nfsd4_copy_notify *cn = &u->copy_notify; |
5170 | struct xdr_stream *xdr = resp->xdr; |
5171 | |
5172 | /* cnr_lease_time */ |
5173 | nfserr = nfsd4_encode_nfstime4(xdr, tv: &cn->cpn_lease_time); |
5174 | if (nfserr) |
5175 | return nfserr; |
5176 | /* cnr_stateid */ |
5177 | nfserr = nfsd4_encode_stateid4(xdr, sid: &cn->cpn_cnr_stateid); |
5178 | if (nfserr) |
5179 | return nfserr; |
5180 | /* cnr_source_server<> */ |
5181 | if (xdr_stream_encode_u32(xdr, n: 1) != XDR_UNIT) |
5182 | return nfserr_resource; |
5183 | return nfsd4_encode_netloc4(xdr, ns: cn->cpn_src); |
5184 | } |
5185 | |
5186 | static __be32 |
5187 | nfsd4_encode_offload_status(struct nfsd4_compoundres *resp, __be32 nfserr, |
5188 | union nfsd4_op_u *u) |
5189 | { |
5190 | struct nfsd4_offload_status *os = &u->offload_status; |
5191 | struct xdr_stream *xdr = resp->xdr; |
5192 | |
5193 | /* osr_count */ |
5194 | nfserr = nfsd4_encode_length4(xdr, os->count); |
5195 | if (nfserr != nfs_ok) |
5196 | return nfserr; |
5197 | /* osr_complete<1> */ |
5198 | if (xdr_stream_encode_u32(xdr, n: 0) != XDR_UNIT) |
5199 | return nfserr_resource; |
5200 | return nfs_ok; |
5201 | } |
5202 | |
5203 | static __be32 |
5204 | nfsd4_encode_read_plus_data(struct nfsd4_compoundres *resp, |
5205 | struct nfsd4_read *read) |
5206 | { |
5207 | bool splice_ok = test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags); |
5208 | struct file *file = read->rd_nf->nf_file; |
5209 | struct xdr_stream *xdr = resp->xdr; |
5210 | unsigned long maxcount; |
5211 | __be32 nfserr, *p; |
5212 | |
5213 | /* Content type, offset, byte count */ |
5214 | p = xdr_reserve_space(xdr, nbytes: 4 + 8 + 4); |
5215 | if (!p) |
5216 | return nfserr_io; |
5217 | if (resp->xdr->buf->page_len && splice_ok) { |
5218 | WARN_ON_ONCE(splice_ok); |
5219 | return nfserr_serverfault; |
5220 | } |
5221 | |
5222 | maxcount = min_t(unsigned long, read->rd_length, |
5223 | (xdr->buf->buflen - xdr->buf->len)); |
5224 | |
5225 | if (file->f_op->splice_read && splice_ok) |
5226 | nfserr = nfsd4_encode_splice_read(resp, read, file, maxcount); |
5227 | else |
5228 | nfserr = nfsd4_encode_readv(resp, read, file, maxcount); |
5229 | if (nfserr) |
5230 | return nfserr; |
5231 | |
5232 | *p++ = cpu_to_be32(NFS4_CONTENT_DATA); |
5233 | p = xdr_encode_hyper(p, val: read->rd_offset); |
5234 | *p = cpu_to_be32(read->rd_length); |
5235 | |
5236 | return nfs_ok; |
5237 | } |
5238 | |
5239 | static __be32 |
5240 | nfsd4_encode_read_plus(struct nfsd4_compoundres *resp, __be32 nfserr, |
5241 | union nfsd4_op_u *u) |
5242 | { |
5243 | struct nfsd4_read *read = &u->read; |
5244 | struct file *file = read->rd_nf->nf_file; |
5245 | struct xdr_stream *xdr = resp->xdr; |
5246 | int starting_len = xdr->buf->len; |
5247 | u32 segments = 0; |
5248 | __be32 *p; |
5249 | |
5250 | if (nfserr) |
5251 | return nfserr; |
5252 | |
5253 | /* eof flag, segment count */ |
5254 | p = xdr_reserve_space(xdr, nbytes: 4 + 4); |
5255 | if (!p) |
5256 | return nfserr_io; |
5257 | xdr_commit_encode(xdr); |
5258 | |
5259 | read->rd_eof = read->rd_offset >= i_size_read(inode: file_inode(f: file)); |
5260 | if (read->rd_eof) |
5261 | goto out; |
5262 | |
5263 | nfserr = nfsd4_encode_read_plus_data(resp, read); |
5264 | if (nfserr) { |
5265 | xdr_truncate_encode(xdr, len: starting_len); |
5266 | return nfserr; |
5267 | } |
5268 | |
5269 | segments++; |
5270 | |
5271 | out: |
5272 | p = xdr_encode_bool(p, n: read->rd_eof); |
5273 | *p = cpu_to_be32(segments); |
5274 | return nfserr; |
5275 | } |
5276 | |
5277 | static __be32 |
5278 | nfsd4_encode_seek(struct nfsd4_compoundres *resp, __be32 nfserr, |
5279 | union nfsd4_op_u *u) |
5280 | { |
5281 | struct nfsd4_seek *seek = &u->seek; |
5282 | struct xdr_stream *xdr = resp->xdr; |
5283 | |
5284 | /* sr_eof */ |
5285 | nfserr = nfsd4_encode_bool(xdr, val: seek->seek_eof); |
5286 | if (nfserr != nfs_ok) |
5287 | return nfserr; |
5288 | /* sr_offset */ |
5289 | return nfsd4_encode_offset4(xdr, seek->seek_pos); |
5290 | } |
5291 | |
5292 | static __be32 |
5293 | nfsd4_encode_noop(struct nfsd4_compoundres *resp, __be32 nfserr, |
5294 | union nfsd4_op_u *p) |
5295 | { |
5296 | return nfserr; |
5297 | } |
5298 | |
5299 | /* |
5300 | * Encode kmalloc-ed buffer in to XDR stream. |
5301 | */ |
5302 | static __be32 |
5303 | nfsd4_vbuf_to_stream(struct xdr_stream *xdr, char *buf, u32 buflen) |
5304 | { |
5305 | u32 cplen; |
5306 | __be32 *p; |
5307 | |
5308 | cplen = min_t(unsigned long, buflen, |
5309 | ((void *)xdr->end - (void *)xdr->p)); |
5310 | p = xdr_reserve_space(xdr, nbytes: cplen); |
5311 | if (!p) |
5312 | return nfserr_resource; |
5313 | |
5314 | memcpy(p, buf, cplen); |
5315 | buf += cplen; |
5316 | buflen -= cplen; |
5317 | |
5318 | while (buflen) { |
5319 | cplen = min_t(u32, buflen, PAGE_SIZE); |
5320 | p = xdr_reserve_space(xdr, nbytes: cplen); |
5321 | if (!p) |
5322 | return nfserr_resource; |
5323 | |
5324 | memcpy(p, buf, cplen); |
5325 | |
5326 | if (cplen < PAGE_SIZE) { |
5327 | /* |
5328 | * We're done, with a length that wasn't page |
5329 | * aligned, so possibly not word aligned. Pad |
5330 | * any trailing bytes with 0. |
5331 | */ |
5332 | xdr_encode_opaque_fixed(p, NULL, len: cplen); |
5333 | break; |
5334 | } |
5335 | |
5336 | buflen -= PAGE_SIZE; |
5337 | buf += PAGE_SIZE; |
5338 | } |
5339 | |
5340 | return 0; |
5341 | } |
5342 | |
5343 | static __be32 |
5344 | nfsd4_encode_getxattr(struct nfsd4_compoundres *resp, __be32 nfserr, |
5345 | union nfsd4_op_u *u) |
5346 | { |
5347 | struct nfsd4_getxattr *getxattr = &u->getxattr; |
5348 | struct xdr_stream *xdr = resp->xdr; |
5349 | __be32 *p, err; |
5350 | |
5351 | p = xdr_reserve_space(xdr, nbytes: 4); |
5352 | if (!p) |
5353 | return nfserr_resource; |
5354 | |
5355 | *p = cpu_to_be32(getxattr->getxa_len); |
5356 | |
5357 | if (getxattr->getxa_len == 0) |
5358 | return 0; |
5359 | |
5360 | err = nfsd4_vbuf_to_stream(xdr, buf: getxattr->getxa_buf, |
5361 | buflen: getxattr->getxa_len); |
5362 | |
5363 | kvfree(addr: getxattr->getxa_buf); |
5364 | |
5365 | return err; |
5366 | } |
5367 | |
5368 | static __be32 |
5369 | nfsd4_encode_setxattr(struct nfsd4_compoundres *resp, __be32 nfserr, |
5370 | union nfsd4_op_u *u) |
5371 | { |
5372 | struct nfsd4_setxattr *setxattr = &u->setxattr; |
5373 | struct xdr_stream *xdr = resp->xdr; |
5374 | |
5375 | return nfsd4_encode_change_info4(xdr, c: &setxattr->setxa_cinfo); |
5376 | } |
5377 | |
5378 | /* |
5379 | * See if there are cookie values that can be rejected outright. |
5380 | */ |
5381 | static __be32 |
5382 | nfsd4_listxattr_validate_cookie(struct nfsd4_listxattrs *listxattrs, |
5383 | u32 *offsetp) |
5384 | { |
5385 | u64 cookie = listxattrs->lsxa_cookie; |
5386 | |
5387 | /* |
5388 | * If the cookie is larger than the maximum number we can fit |
5389 | * in either the buffer we just got back from vfs_listxattr, or, |
5390 | * XDR-encoded, in the return buffer, it's invalid. |
5391 | */ |
5392 | if (cookie > (listxattrs->lsxa_len) / (XATTR_USER_PREFIX_LEN + 2)) |
5393 | return nfserr_badcookie; |
5394 | |
5395 | if (cookie > (listxattrs->lsxa_maxcount / |
5396 | (XDR_QUADLEN(XATTR_USER_PREFIX_LEN + 2) + 4))) |
5397 | return nfserr_badcookie; |
5398 | |
5399 | *offsetp = (u32)cookie; |
5400 | return 0; |
5401 | } |
5402 | |
5403 | static __be32 |
5404 | nfsd4_encode_listxattrs(struct nfsd4_compoundres *resp, __be32 nfserr, |
5405 | union nfsd4_op_u *u) |
5406 | { |
5407 | struct nfsd4_listxattrs *listxattrs = &u->listxattrs; |
5408 | struct xdr_stream *xdr = resp->xdr; |
5409 | u32 cookie_offset, count_offset, eof; |
5410 | u32 left, xdrleft, slen, count; |
5411 | u32 xdrlen, offset; |
5412 | u64 cookie; |
5413 | char *sp; |
5414 | __be32 status, tmp; |
5415 | __be32 *p; |
5416 | u32 nuser; |
5417 | |
5418 | eof = 1; |
5419 | |
5420 | status = nfsd4_listxattr_validate_cookie(listxattrs, offsetp: &offset); |
5421 | if (status) |
5422 | goto out; |
5423 | |
5424 | /* |
5425 | * Reserve space for the cookie and the name array count. Record |
5426 | * the offsets to save them later. |
5427 | */ |
5428 | cookie_offset = xdr->buf->len; |
5429 | count_offset = cookie_offset + 8; |
5430 | p = xdr_reserve_space(xdr, nbytes: 12); |
5431 | if (!p) { |
5432 | status = nfserr_resource; |
5433 | goto out; |
5434 | } |
5435 | |
5436 | count = 0; |
5437 | left = listxattrs->lsxa_len; |
5438 | sp = listxattrs->lsxa_buf; |
5439 | nuser = 0; |
5440 | |
5441 | xdrleft = listxattrs->lsxa_maxcount; |
5442 | |
5443 | while (left > 0 && xdrleft > 0) { |
5444 | slen = strlen(sp); |
5445 | |
5446 | /* |
5447 | * Check if this is a "user." attribute, skip it if not. |
5448 | */ |
5449 | if (strncmp(sp, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)) |
5450 | goto contloop; |
5451 | |
5452 | slen -= XATTR_USER_PREFIX_LEN; |
5453 | xdrlen = 4 + ((slen + 3) & ~3); |
5454 | if (xdrlen > xdrleft) { |
5455 | if (count == 0) { |
5456 | /* |
5457 | * Can't even fit the first attribute name. |
5458 | */ |
5459 | status = nfserr_toosmall; |
5460 | goto out; |
5461 | } |
5462 | eof = 0; |
5463 | goto wreof; |
5464 | } |
5465 | |
5466 | left -= XATTR_USER_PREFIX_LEN; |
5467 | sp += XATTR_USER_PREFIX_LEN; |
5468 | if (nuser++ < offset) |
5469 | goto contloop; |
5470 | |
5471 | |
5472 | p = xdr_reserve_space(xdr, nbytes: xdrlen); |
5473 | if (!p) { |
5474 | status = nfserr_resource; |
5475 | goto out; |
5476 | } |
5477 | |
5478 | xdr_encode_opaque(p, ptr: sp, len: slen); |
5479 | |
5480 | xdrleft -= xdrlen; |
5481 | count++; |
5482 | contloop: |
5483 | sp += slen + 1; |
5484 | left -= slen + 1; |
5485 | } |
5486 | |
5487 | /* |
5488 | * If there were user attributes to copy, but we didn't copy |
5489 | * any, the offset was too large (e.g. the cookie was invalid). |
5490 | */ |
5491 | if (nuser > 0 && count == 0) { |
5492 | status = nfserr_badcookie; |
5493 | goto out; |
5494 | } |
5495 | |
5496 | wreof: |
5497 | p = xdr_reserve_space(xdr, nbytes: 4); |
5498 | if (!p) { |
5499 | status = nfserr_resource; |
5500 | goto out; |
5501 | } |
5502 | *p = cpu_to_be32(eof); |
5503 | |
5504 | cookie = offset + count; |
5505 | |
5506 | write_bytes_to_xdr_buf(xdr->buf, cookie_offset, &cookie, 8); |
5507 | tmp = cpu_to_be32(count); |
5508 | write_bytes_to_xdr_buf(xdr->buf, count_offset, &tmp, 4); |
5509 | out: |
5510 | if (listxattrs->lsxa_len) |
5511 | kvfree(addr: listxattrs->lsxa_buf); |
5512 | return status; |
5513 | } |
5514 | |
5515 | static __be32 |
5516 | nfsd4_encode_removexattr(struct nfsd4_compoundres *resp, __be32 nfserr, |
5517 | union nfsd4_op_u *u) |
5518 | { |
5519 | struct nfsd4_removexattr *removexattr = &u->removexattr; |
5520 | struct xdr_stream *xdr = resp->xdr; |
5521 | |
5522 | return nfsd4_encode_change_info4(xdr, c: &removexattr->rmxa_cinfo); |
5523 | } |
5524 | |
5525 | typedef __be32(*nfsd4_enc)(struct nfsd4_compoundres *, __be32, union nfsd4_op_u *u); |
5526 | |
5527 | /* |
5528 | * Note: nfsd4_enc_ops vector is shared for v4.0 and v4.1 |
5529 | * since we don't need to filter out obsolete ops as this is |
5530 | * done in the decoding phase. |
5531 | */ |
5532 | static const nfsd4_enc nfsd4_enc_ops[] = { |
5533 | [OP_ACCESS] = nfsd4_encode_access, |
5534 | [OP_CLOSE] = nfsd4_encode_close, |
5535 | [OP_COMMIT] = nfsd4_encode_commit, |
5536 | [OP_CREATE] = nfsd4_encode_create, |
5537 | [OP_DELEGPURGE] = nfsd4_encode_noop, |
5538 | [OP_DELEGRETURN] = nfsd4_encode_noop, |
5539 | [OP_GETATTR] = nfsd4_encode_getattr, |
5540 | [OP_GETFH] = nfsd4_encode_getfh, |
5541 | [OP_LINK] = nfsd4_encode_link, |
5542 | [OP_LOCK] = nfsd4_encode_lock, |
5543 | [OP_LOCKT] = nfsd4_encode_lockt, |
5544 | [OP_LOCKU] = nfsd4_encode_locku, |
5545 | [OP_LOOKUP] = nfsd4_encode_noop, |
5546 | [OP_LOOKUPP] = nfsd4_encode_noop, |
5547 | [OP_NVERIFY] = nfsd4_encode_noop, |
5548 | [OP_OPEN] = nfsd4_encode_open, |
5549 | [OP_OPENATTR] = nfsd4_encode_noop, |
5550 | [OP_OPEN_CONFIRM] = nfsd4_encode_open_confirm, |
5551 | [OP_OPEN_DOWNGRADE] = nfsd4_encode_open_downgrade, |
5552 | [OP_PUTFH] = nfsd4_encode_noop, |
5553 | [OP_PUTPUBFH] = nfsd4_encode_noop, |
5554 | [OP_PUTROOTFH] = nfsd4_encode_noop, |
5555 | [OP_READ] = nfsd4_encode_read, |
5556 | [OP_READDIR] = nfsd4_encode_readdir, |
5557 | [OP_READLINK] = nfsd4_encode_readlink, |
5558 | [OP_REMOVE] = nfsd4_encode_remove, |
5559 | [OP_RENAME] = nfsd4_encode_rename, |
5560 | [OP_RENEW] = nfsd4_encode_noop, |
5561 | [OP_RESTOREFH] = nfsd4_encode_noop, |
5562 | [OP_SAVEFH] = nfsd4_encode_noop, |
5563 | [OP_SECINFO] = nfsd4_encode_secinfo, |
5564 | [OP_SETATTR] = nfsd4_encode_setattr, |
5565 | [OP_SETCLIENTID] = nfsd4_encode_setclientid, |
5566 | [OP_SETCLIENTID_CONFIRM] = nfsd4_encode_noop, |
5567 | [OP_VERIFY] = nfsd4_encode_noop, |
5568 | [OP_WRITE] = nfsd4_encode_write, |
5569 | [OP_RELEASE_LOCKOWNER] = nfsd4_encode_noop, |
5570 | |
5571 | /* NFSv4.1 operations */ |
5572 | [OP_BACKCHANNEL_CTL] = nfsd4_encode_noop, |
5573 | [OP_BIND_CONN_TO_SESSION] = nfsd4_encode_bind_conn_to_session, |
5574 | [OP_EXCHANGE_ID] = nfsd4_encode_exchange_id, |
5575 | [OP_CREATE_SESSION] = nfsd4_encode_create_session, |
5576 | [OP_DESTROY_SESSION] = nfsd4_encode_noop, |
5577 | [OP_FREE_STATEID] = nfsd4_encode_noop, |
5578 | [OP_GET_DIR_DELEGATION] = nfsd4_encode_noop, |
5579 | #ifdef CONFIG_NFSD_PNFS |
5580 | [OP_GETDEVICEINFO] = nfsd4_encode_getdeviceinfo, |
5581 | [OP_GETDEVICELIST] = nfsd4_encode_noop, |
5582 | [OP_LAYOUTCOMMIT] = nfsd4_encode_layoutcommit, |
5583 | [OP_LAYOUTGET] = nfsd4_encode_layoutget, |
5584 | [OP_LAYOUTRETURN] = nfsd4_encode_layoutreturn, |
5585 | #else |
5586 | [OP_GETDEVICEINFO] = nfsd4_encode_noop, |
5587 | [OP_GETDEVICELIST] = nfsd4_encode_noop, |
5588 | [OP_LAYOUTCOMMIT] = nfsd4_encode_noop, |
5589 | [OP_LAYOUTGET] = nfsd4_encode_noop, |
5590 | [OP_LAYOUTRETURN] = nfsd4_encode_noop, |
5591 | #endif |
5592 | [OP_SECINFO_NO_NAME] = nfsd4_encode_secinfo_no_name, |
5593 | [OP_SEQUENCE] = nfsd4_encode_sequence, |
5594 | [OP_SET_SSV] = nfsd4_encode_noop, |
5595 | [OP_TEST_STATEID] = nfsd4_encode_test_stateid, |
5596 | [OP_WANT_DELEGATION] = nfsd4_encode_noop, |
5597 | [OP_DESTROY_CLIENTID] = nfsd4_encode_noop, |
5598 | [OP_RECLAIM_COMPLETE] = nfsd4_encode_noop, |
5599 | |
5600 | /* NFSv4.2 operations */ |
5601 | [OP_ALLOCATE] = nfsd4_encode_noop, |
5602 | [OP_COPY] = nfsd4_encode_copy, |
5603 | [OP_COPY_NOTIFY] = nfsd4_encode_copy_notify, |
5604 | [OP_DEALLOCATE] = nfsd4_encode_noop, |
5605 | [OP_IO_ADVISE] = nfsd4_encode_noop, |
5606 | [OP_LAYOUTERROR] = nfsd4_encode_noop, |
5607 | [OP_LAYOUTSTATS] = nfsd4_encode_noop, |
5608 | [OP_OFFLOAD_CANCEL] = nfsd4_encode_noop, |
5609 | [OP_OFFLOAD_STATUS] = nfsd4_encode_offload_status, |
5610 | [OP_READ_PLUS] = nfsd4_encode_read_plus, |
5611 | [OP_SEEK] = nfsd4_encode_seek, |
5612 | [OP_WRITE_SAME] = nfsd4_encode_noop, |
5613 | [OP_CLONE] = nfsd4_encode_noop, |
5614 | |
5615 | /* RFC 8276 extended atributes operations */ |
5616 | [OP_GETXATTR] = nfsd4_encode_getxattr, |
5617 | [OP_SETXATTR] = nfsd4_encode_setxattr, |
5618 | [OP_LISTXATTRS] = nfsd4_encode_listxattrs, |
5619 | [OP_REMOVEXATTR] = nfsd4_encode_removexattr, |
5620 | }; |
5621 | |
5622 | /* |
5623 | * Calculate whether we still have space to encode repsize bytes. |
5624 | * There are two considerations: |
5625 | * - For NFS versions >=4.1, the size of the reply must stay within |
5626 | * session limits |
5627 | * - For all NFS versions, we must stay within limited preallocated |
5628 | * buffer space. |
5629 | * |
5630 | * This is called before the operation is processed, so can only provide |
5631 | * an upper estimate. For some nonidempotent operations (such as |
5632 | * getattr), it's not necessarily a problem if that estimate is wrong, |
5633 | * as we can fail it after processing without significant side effects. |
5634 | */ |
5635 | __be32 nfsd4_check_resp_size(struct nfsd4_compoundres *resp, u32 respsize) |
5636 | { |
5637 | struct xdr_buf *buf = &resp->rqstp->rq_res; |
5638 | struct nfsd4_slot *slot = resp->cstate.slot; |
5639 | |
5640 | if (buf->len + respsize <= buf->buflen) |
5641 | return nfs_ok; |
5642 | if (!nfsd4_has_session(cs: &resp->cstate)) |
5643 | return nfserr_resource; |
5644 | if (slot->sl_flags & NFSD4_SLOT_CACHETHIS) { |
5645 | WARN_ON_ONCE(1); |
5646 | return nfserr_rep_too_big_to_cache; |
5647 | } |
5648 | return nfserr_rep_too_big; |
5649 | } |
5650 | |
5651 | void |
5652 | nfsd4_encode_operation(struct nfsd4_compoundres *resp, struct nfsd4_op *op) |
5653 | { |
5654 | struct xdr_stream *xdr = resp->xdr; |
5655 | struct nfs4_stateowner *so = resp->cstate.replay_owner; |
5656 | struct svc_rqst *rqstp = resp->rqstp; |
5657 | const struct nfsd4_operation *opdesc = op->opdesc; |
5658 | int post_err_offset; |
5659 | nfsd4_enc encoder; |
5660 | __be32 *p; |
5661 | |
5662 | p = xdr_reserve_space(xdr, nbytes: 8); |
5663 | if (!p) |
5664 | goto release; |
5665 | *p++ = cpu_to_be32(op->opnum); |
5666 | post_err_offset = xdr->buf->len; |
5667 | |
5668 | if (op->opnum == OP_ILLEGAL) |
5669 | goto status; |
5670 | if (op->status && opdesc && |
5671 | !(opdesc->op_flags & OP_NONTRIVIAL_ERROR_ENCODE)) |
5672 | goto status; |
5673 | BUG_ON(op->opnum >= ARRAY_SIZE(nfsd4_enc_ops) || |
5674 | !nfsd4_enc_ops[op->opnum]); |
5675 | encoder = nfsd4_enc_ops[op->opnum]; |
5676 | op->status = encoder(resp, op->status, &op->u); |
5677 | if (op->status) |
5678 | trace_nfsd_compound_encode_err(rqstp, opnum: op->opnum, status: op->status); |
5679 | xdr_commit_encode(xdr); |
5680 | |
5681 | /* nfsd4_check_resp_size guarantees enough room for error status */ |
5682 | if (!op->status) { |
5683 | int space_needed = 0; |
5684 | if (!nfsd4_last_compound_op(rqstp)) |
5685 | space_needed = COMPOUND_ERR_SLACK_SPACE; |
5686 | op->status = nfsd4_check_resp_size(resp, respsize: space_needed); |
5687 | } |
5688 | if (op->status == nfserr_resource && nfsd4_has_session(cs: &resp->cstate)) { |
5689 | struct nfsd4_slot *slot = resp->cstate.slot; |
5690 | |
5691 | if (slot->sl_flags & NFSD4_SLOT_CACHETHIS) |
5692 | op->status = nfserr_rep_too_big_to_cache; |
5693 | else |
5694 | op->status = nfserr_rep_too_big; |
5695 | } |
5696 | if (op->status == nfserr_resource || |
5697 | op->status == nfserr_rep_too_big || |
5698 | op->status == nfserr_rep_too_big_to_cache) { |
5699 | /* |
5700 | * The operation may have already been encoded or |
5701 | * partially encoded. No op returns anything additional |
5702 | * in the case of one of these three errors, so we can |
5703 | * just truncate back to after the status. But it's a |
5704 | * bug if we had to do this on a non-idempotent op: |
5705 | */ |
5706 | warn_on_nonidempotent_op(op); |
5707 | xdr_truncate_encode(xdr, len: post_err_offset); |
5708 | } |
5709 | if (so) { |
5710 | int len = xdr->buf->len - post_err_offset; |
5711 | |
5712 | so->so_replay.rp_status = op->status; |
5713 | so->so_replay.rp_buflen = len; |
5714 | read_bytes_from_xdr_buf(xdr->buf, post_err_offset, |
5715 | so->so_replay.rp_buf, len); |
5716 | } |
5717 | status: |
5718 | *p = op->status; |
5719 | release: |
5720 | if (opdesc && opdesc->op_release) |
5721 | opdesc->op_release(&op->u); |
5722 | |
5723 | /* |
5724 | * Account for pages consumed while encoding this operation. |
5725 | * The xdr_stream primitives don't manage rq_next_page. |
5726 | */ |
5727 | rqstp->rq_next_page = xdr->page_ptr + 1; |
5728 | } |
5729 | |
5730 | /* |
5731 | * Encode the reply stored in the stateowner reply cache |
5732 | * |
5733 | * XDR note: do not encode rp->rp_buflen: the buffer contains the |
5734 | * previously sent already encoded operation. |
5735 | */ |
5736 | void |
5737 | nfsd4_encode_replay(struct xdr_stream *xdr, struct nfsd4_op *op) |
5738 | { |
5739 | __be32 *p; |
5740 | struct nfs4_replay *rp = op->replay; |
5741 | |
5742 | p = xdr_reserve_space(xdr, nbytes: 8 + rp->rp_buflen); |
5743 | if (!p) { |
5744 | WARN_ON_ONCE(1); |
5745 | return; |
5746 | } |
5747 | *p++ = cpu_to_be32(op->opnum); |
5748 | *p++ = rp->rp_status; /* already xdr'ed */ |
5749 | |
5750 | p = xdr_encode_opaque_fixed(p, ptr: rp->rp_buf, len: rp->rp_buflen); |
5751 | } |
5752 | |
5753 | void nfsd4_release_compoundargs(struct svc_rqst *rqstp) |
5754 | { |
5755 | struct nfsd4_compoundargs *args = rqstp->rq_argp; |
5756 | |
5757 | if (args->ops != args->iops) { |
5758 | vfree(addr: args->ops); |
5759 | args->ops = args->iops; |
5760 | } |
5761 | while (args->to_free) { |
5762 | struct svcxdr_tmpbuf *tb = args->to_free; |
5763 | args->to_free = tb->next; |
5764 | kfree(objp: tb); |
5765 | } |
5766 | } |
5767 | |
5768 | bool |
5769 | nfs4svc_decode_compoundargs(struct svc_rqst *rqstp, struct xdr_stream *xdr) |
5770 | { |
5771 | struct nfsd4_compoundargs *args = rqstp->rq_argp; |
5772 | |
5773 | /* svcxdr_tmp_alloc */ |
5774 | args->to_free = NULL; |
5775 | |
5776 | args->xdr = xdr; |
5777 | args->ops = args->iops; |
5778 | args->rqstp = rqstp; |
5779 | |
5780 | return nfsd4_decode_compound(argp: args); |
5781 | } |
5782 | |
5783 | bool |
5784 | nfs4svc_encode_compoundres(struct svc_rqst *rqstp, struct xdr_stream *xdr) |
5785 | { |
5786 | struct nfsd4_compoundres *resp = rqstp->rq_resp; |
5787 | __be32 *p; |
5788 | |
5789 | /* |
5790 | * Send buffer space for the following items is reserved |
5791 | * at the top of nfsd4_proc_compound(). |
5792 | */ |
5793 | p = resp->statusp; |
5794 | |
5795 | *p++ = resp->cstate.status; |
5796 | *p++ = htonl(resp->taglen); |
5797 | memcpy(p, resp->tag, resp->taglen); |
5798 | p += XDR_QUADLEN(resp->taglen); |
5799 | *p++ = htonl(resp->opcnt); |
5800 | |
5801 | nfsd4_sequence_done(resp); |
5802 | return true; |
5803 | } |
5804 | |