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 | argp->splice_ok = nfsd_read_splice_ok(rqstp: argp->rqstp); |
2528 | if (readcount > 1 || max_reply > PAGE_SIZE - auth_slack) |
2529 | argp->splice_ok = false; |
2530 | |
2531 | return true; |
2532 | } |
2533 | |
2534 | static __be32 nfsd4_encode_nfs_fh4(struct xdr_stream *xdr, |
2535 | struct knfsd_fh *fh_handle) |
2536 | { |
2537 | return nfsd4_encode_opaque(xdr, data: fh_handle->fh_raw, size: fh_handle->fh_size); |
2538 | } |
2539 | |
2540 | /* This is a frequently-encoded type; open-coded for speed */ |
2541 | static __be32 nfsd4_encode_nfstime4(struct xdr_stream *xdr, |
2542 | const struct timespec64 *tv) |
2543 | { |
2544 | __be32 *p; |
2545 | |
2546 | p = xdr_reserve_space(xdr, XDR_UNIT * 3); |
2547 | if (!p) |
2548 | return nfserr_resource; |
2549 | p = xdr_encode_hyper(p, val: tv->tv_sec); |
2550 | *p = cpu_to_be32(tv->tv_nsec); |
2551 | return nfs_ok; |
2552 | } |
2553 | |
2554 | static __be32 nfsd4_encode_specdata4(struct xdr_stream *xdr, |
2555 | unsigned int major, unsigned int minor) |
2556 | { |
2557 | __be32 status; |
2558 | |
2559 | status = nfsd4_encode_uint32_t(xdr, val: major); |
2560 | if (status != nfs_ok) |
2561 | return status; |
2562 | return nfsd4_encode_uint32_t(xdr, val: minor); |
2563 | } |
2564 | |
2565 | static __be32 |
2566 | nfsd4_encode_change_info4(struct xdr_stream *xdr, const struct nfsd4_change_info *c) |
2567 | { |
2568 | __be32 status; |
2569 | |
2570 | status = nfsd4_encode_bool(xdr, val: c->atomic); |
2571 | if (status != nfs_ok) |
2572 | return status; |
2573 | status = nfsd4_encode_changeid4(xdr, c->before_change); |
2574 | if (status != nfs_ok) |
2575 | return status; |
2576 | return nfsd4_encode_changeid4(xdr, c->after_change); |
2577 | } |
2578 | |
2579 | static __be32 nfsd4_encode_netaddr4(struct xdr_stream *xdr, |
2580 | const struct nfs42_netaddr *addr) |
2581 | { |
2582 | __be32 status; |
2583 | |
2584 | /* na_r_netid */ |
2585 | status = nfsd4_encode_opaque(xdr, data: addr->netid, size: addr->netid_len); |
2586 | if (status != nfs_ok) |
2587 | return status; |
2588 | /* na_r_addr */ |
2589 | return nfsd4_encode_opaque(xdr, data: addr->addr, size: addr->addr_len); |
2590 | } |
2591 | |
2592 | /* Encode as an array of strings the string given with components |
2593 | * separated @sep, escaped with esc_enter and esc_exit. |
2594 | */ |
2595 | static __be32 nfsd4_encode_components_esc(struct xdr_stream *xdr, char sep, |
2596 | char *components, char esc_enter, |
2597 | char esc_exit) |
2598 | { |
2599 | __be32 *p; |
2600 | __be32 pathlen; |
2601 | int pathlen_offset; |
2602 | int strlen, count=0; |
2603 | char *str, *end, *next; |
2604 | |
2605 | dprintk("nfsd4_encode_components(%s)\n" , components); |
2606 | |
2607 | pathlen_offset = xdr->buf->len; |
2608 | p = xdr_reserve_space(xdr, nbytes: 4); |
2609 | if (!p) |
2610 | return nfserr_resource; |
2611 | p++; /* We will fill this in with @count later */ |
2612 | |
2613 | end = str = components; |
2614 | while (*end) { |
2615 | bool found_esc = false; |
2616 | |
2617 | /* try to parse as esc_start, ..., esc_end, sep */ |
2618 | if (*str == esc_enter) { |
2619 | for (; *end && (*end != esc_exit); end++) |
2620 | /* find esc_exit or end of string */; |
2621 | next = end + 1; |
2622 | if (*end && (!*next || *next == sep)) { |
2623 | str++; |
2624 | found_esc = true; |
2625 | } |
2626 | } |
2627 | |
2628 | if (!found_esc) |
2629 | for (; *end && (*end != sep); end++) |
2630 | /* find sep or end of string */; |
2631 | |
2632 | strlen = end - str; |
2633 | if (strlen) { |
2634 | p = xdr_reserve_space(xdr, nbytes: strlen + 4); |
2635 | if (!p) |
2636 | return nfserr_resource; |
2637 | p = xdr_encode_opaque(p, ptr: str, len: strlen); |
2638 | count++; |
2639 | } |
2640 | else |
2641 | end++; |
2642 | if (found_esc) |
2643 | end = next; |
2644 | |
2645 | str = end; |
2646 | } |
2647 | pathlen = htonl(count); |
2648 | write_bytes_to_xdr_buf(xdr->buf, pathlen_offset, &pathlen, 4); |
2649 | return 0; |
2650 | } |
2651 | |
2652 | /* Encode as an array of strings the string given with components |
2653 | * separated @sep. |
2654 | */ |
2655 | static __be32 nfsd4_encode_components(struct xdr_stream *xdr, char sep, |
2656 | char *components) |
2657 | { |
2658 | return nfsd4_encode_components_esc(xdr, sep, components, esc_enter: 0, esc_exit: 0); |
2659 | } |
2660 | |
2661 | static __be32 nfsd4_encode_fs_location4(struct xdr_stream *xdr, |
2662 | struct nfsd4_fs_location *location) |
2663 | { |
2664 | __be32 status; |
2665 | |
2666 | status = nfsd4_encode_components_esc(xdr, sep: ':', components: location->hosts, |
2667 | esc_enter: '[', esc_exit: ']'); |
2668 | if (status) |
2669 | return status; |
2670 | status = nfsd4_encode_components(xdr, sep: '/', components: location->path); |
2671 | if (status) |
2672 | return status; |
2673 | return nfs_ok; |
2674 | } |
2675 | |
2676 | static __be32 nfsd4_encode_pathname4(struct xdr_stream *xdr, |
2677 | const struct path *root, |
2678 | const struct path *path) |
2679 | { |
2680 | struct path cur = *path; |
2681 | __be32 *p; |
2682 | struct dentry **components = NULL; |
2683 | unsigned int ncomponents = 0; |
2684 | __be32 err = nfserr_jukebox; |
2685 | |
2686 | dprintk("nfsd4_encode_components(" ); |
2687 | |
2688 | path_get(&cur); |
2689 | /* First walk the path up to the nfsd root, and store the |
2690 | * dentries/path components in an array. |
2691 | */ |
2692 | for (;;) { |
2693 | if (path_equal(path1: &cur, path2: root)) |
2694 | break; |
2695 | if (cur.dentry == cur.mnt->mnt_root) { |
2696 | if (follow_up(&cur)) |
2697 | continue; |
2698 | goto out_free; |
2699 | } |
2700 | if ((ncomponents & 15) == 0) { |
2701 | struct dentry **new; |
2702 | new = krealloc(objp: components, |
2703 | new_size: sizeof(*new) * (ncomponents + 16), |
2704 | GFP_KERNEL); |
2705 | if (!new) |
2706 | goto out_free; |
2707 | components = new; |
2708 | } |
2709 | components[ncomponents++] = cur.dentry; |
2710 | cur.dentry = dget_parent(dentry: cur.dentry); |
2711 | } |
2712 | err = nfserr_resource; |
2713 | p = xdr_reserve_space(xdr, nbytes: 4); |
2714 | if (!p) |
2715 | goto out_free; |
2716 | *p++ = cpu_to_be32(ncomponents); |
2717 | |
2718 | while (ncomponents) { |
2719 | struct dentry *dentry = components[ncomponents - 1]; |
2720 | unsigned int len; |
2721 | |
2722 | spin_lock(lock: &dentry->d_lock); |
2723 | len = dentry->d_name.len; |
2724 | p = xdr_reserve_space(xdr, nbytes: len + 4); |
2725 | if (!p) { |
2726 | spin_unlock(lock: &dentry->d_lock); |
2727 | goto out_free; |
2728 | } |
2729 | p = xdr_encode_opaque(p, ptr: dentry->d_name.name, len); |
2730 | dprintk("/%pd" , dentry); |
2731 | spin_unlock(lock: &dentry->d_lock); |
2732 | dput(dentry); |
2733 | ncomponents--; |
2734 | } |
2735 | |
2736 | err = 0; |
2737 | out_free: |
2738 | dprintk(")\n" ); |
2739 | while (ncomponents) |
2740 | dput(components[--ncomponents]); |
2741 | kfree(objp: components); |
2742 | path_put(&cur); |
2743 | return err; |
2744 | } |
2745 | |
2746 | static __be32 nfsd4_encode_fs_locations4(struct xdr_stream *xdr, |
2747 | struct svc_rqst *rqstp, |
2748 | struct svc_export *exp) |
2749 | { |
2750 | struct nfsd4_fs_locations *fslocs = &exp->ex_fslocs; |
2751 | struct svc_export *exp_ps; |
2752 | unsigned int i; |
2753 | __be32 status; |
2754 | |
2755 | /* fs_root */ |
2756 | exp_ps = rqst_find_fsidzero_export(rqstp); |
2757 | if (IS_ERR(ptr: exp_ps)) |
2758 | return nfserrno(errno: PTR_ERR(ptr: exp_ps)); |
2759 | status = nfsd4_encode_pathname4(xdr, root: &exp_ps->ex_path, path: &exp->ex_path); |
2760 | exp_put(exp: exp_ps); |
2761 | if (status != nfs_ok) |
2762 | return status; |
2763 | |
2764 | /* locations<> */ |
2765 | if (xdr_stream_encode_u32(xdr, n: fslocs->locations_count) != XDR_UNIT) |
2766 | return nfserr_resource; |
2767 | for (i = 0; i < fslocs->locations_count; i++) { |
2768 | status = nfsd4_encode_fs_location4(xdr, location: &fslocs->locations[i]); |
2769 | if (status != nfs_ok) |
2770 | return status; |
2771 | } |
2772 | |
2773 | return nfs_ok; |
2774 | } |
2775 | |
2776 | static __be32 nfsd4_encode_nfsace4(struct xdr_stream *xdr, struct svc_rqst *rqstp, |
2777 | struct nfs4_ace *ace) |
2778 | { |
2779 | __be32 status; |
2780 | |
2781 | /* type */ |
2782 | status = nfsd4_encode_acetype4(xdr, ace->type); |
2783 | if (status != nfs_ok) |
2784 | return nfserr_resource; |
2785 | /* flag */ |
2786 | status = nfsd4_encode_aceflag4(xdr, ace->flag); |
2787 | if (status != nfs_ok) |
2788 | return nfserr_resource; |
2789 | /* access mask */ |
2790 | status = nfsd4_encode_acemask4(xdr, ace->access_mask & NFS4_ACE_MASK_ALL); |
2791 | if (status != nfs_ok) |
2792 | return nfserr_resource; |
2793 | /* who */ |
2794 | if (ace->whotype != NFS4_ACL_WHO_NAMED) |
2795 | return nfs4_acl_write_who(xdr, who: ace->whotype); |
2796 | if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP) |
2797 | return nfsd4_encode_group(xdr, rqstp, ace->who_gid); |
2798 | return nfsd4_encode_user(xdr, rqstp, ace->who_uid); |
2799 | } |
2800 | |
2801 | #define WORD0_ABSENT_FS_ATTRS (FATTR4_WORD0_FS_LOCATIONS | FATTR4_WORD0_FSID | \ |
2802 | FATTR4_WORD0_RDATTR_ERROR) |
2803 | #define WORD1_ABSENT_FS_ATTRS FATTR4_WORD1_MOUNTED_ON_FILEID |
2804 | #define WORD2_ABSENT_FS_ATTRS 0 |
2805 | |
2806 | #ifdef CONFIG_NFSD_V4_SECURITY_LABEL |
2807 | static inline __be32 |
2808 | nfsd4_encode_security_label(struct xdr_stream *xdr, struct svc_rqst *rqstp, |
2809 | void *context, int len) |
2810 | { |
2811 | __be32 *p; |
2812 | |
2813 | p = xdr_reserve_space(xdr, nbytes: len + 4 + 4 + 4); |
2814 | if (!p) |
2815 | return nfserr_resource; |
2816 | |
2817 | /* |
2818 | * For now we use a 0 here to indicate the null translation; in |
2819 | * the future we may place a call to translation code here. |
2820 | */ |
2821 | *p++ = cpu_to_be32(0); /* lfs */ |
2822 | *p++ = cpu_to_be32(0); /* pi */ |
2823 | p = xdr_encode_opaque(p, ptr: context, len); |
2824 | return 0; |
2825 | } |
2826 | #else |
2827 | static inline __be32 |
2828 | nfsd4_encode_security_label(struct xdr_stream *xdr, struct svc_rqst *rqstp, |
2829 | void *context, int len) |
2830 | { return 0; } |
2831 | #endif |
2832 | |
2833 | static __be32 fattr_handle_absent_fs(u32 *bmval0, u32 *bmval1, u32 *bmval2, u32 *rdattr_err) |
2834 | { |
2835 | /* As per referral draft: */ |
2836 | if (*bmval0 & ~WORD0_ABSENT_FS_ATTRS || |
2837 | *bmval1 & ~WORD1_ABSENT_FS_ATTRS) { |
2838 | if (*bmval0 & FATTR4_WORD0_RDATTR_ERROR || |
2839 | *bmval0 & FATTR4_WORD0_FS_LOCATIONS) |
2840 | *rdattr_err = NFSERR_MOVED; |
2841 | else |
2842 | return nfserr_moved; |
2843 | } |
2844 | *bmval0 &= WORD0_ABSENT_FS_ATTRS; |
2845 | *bmval1 &= WORD1_ABSENT_FS_ATTRS; |
2846 | *bmval2 &= WORD2_ABSENT_FS_ATTRS; |
2847 | return 0; |
2848 | } |
2849 | |
2850 | |
2851 | static int nfsd4_get_mounted_on_ino(struct svc_export *exp, u64 *pino) |
2852 | { |
2853 | struct path path = exp->ex_path; |
2854 | struct kstat stat; |
2855 | int err; |
2856 | |
2857 | path_get(&path); |
2858 | while (follow_up(&path)) { |
2859 | if (path.dentry != path.mnt->mnt_root) |
2860 | break; |
2861 | } |
2862 | err = vfs_getattr(&path, &stat, STATX_INO, AT_STATX_SYNC_AS_STAT); |
2863 | path_put(&path); |
2864 | if (!err) |
2865 | *pino = stat.ino; |
2866 | return err; |
2867 | } |
2868 | |
2869 | static __be32 |
2870 | nfsd4_encode_bitmap4(struct xdr_stream *xdr, u32 bmval0, u32 bmval1, u32 bmval2) |
2871 | { |
2872 | __be32 *p; |
2873 | |
2874 | if (bmval2) { |
2875 | p = xdr_reserve_space(xdr, XDR_UNIT * 4); |
2876 | if (!p) |
2877 | goto out_resource; |
2878 | *p++ = cpu_to_be32(3); |
2879 | *p++ = cpu_to_be32(bmval0); |
2880 | *p++ = cpu_to_be32(bmval1); |
2881 | *p++ = cpu_to_be32(bmval2); |
2882 | } else if (bmval1) { |
2883 | p = xdr_reserve_space(xdr, XDR_UNIT * 3); |
2884 | if (!p) |
2885 | goto out_resource; |
2886 | *p++ = cpu_to_be32(2); |
2887 | *p++ = cpu_to_be32(bmval0); |
2888 | *p++ = cpu_to_be32(bmval1); |
2889 | } else { |
2890 | p = xdr_reserve_space(xdr, XDR_UNIT * 2); |
2891 | if (!p) |
2892 | goto out_resource; |
2893 | *p++ = cpu_to_be32(1); |
2894 | *p++ = cpu_to_be32(bmval0); |
2895 | } |
2896 | |
2897 | return nfs_ok; |
2898 | out_resource: |
2899 | return nfserr_resource; |
2900 | } |
2901 | |
2902 | struct nfsd4_fattr_args { |
2903 | struct svc_rqst *rqstp; |
2904 | struct svc_fh *fhp; |
2905 | struct svc_export *exp; |
2906 | struct dentry *dentry; |
2907 | struct kstat stat; |
2908 | struct kstatfs statfs; |
2909 | struct nfs4_acl *acl; |
2910 | u64 size; |
2911 | #ifdef CONFIG_NFSD_V4_SECURITY_LABEL |
2912 | void *context; |
2913 | int contextlen; |
2914 | #endif |
2915 | u32 rdattr_err; |
2916 | bool contextsupport; |
2917 | bool ignore_crossmnt; |
2918 | }; |
2919 | |
2920 | typedef __be32(*nfsd4_enc_attr)(struct xdr_stream *xdr, |
2921 | const struct nfsd4_fattr_args *args); |
2922 | |
2923 | static __be32 nfsd4_encode_fattr4__noop(struct xdr_stream *xdr, |
2924 | const struct nfsd4_fattr_args *args) |
2925 | { |
2926 | return nfs_ok; |
2927 | } |
2928 | |
2929 | static __be32 nfsd4_encode_fattr4__true(struct xdr_stream *xdr, |
2930 | const struct nfsd4_fattr_args *args) |
2931 | { |
2932 | return nfsd4_encode_bool(xdr, val: true); |
2933 | } |
2934 | |
2935 | static __be32 nfsd4_encode_fattr4__false(struct xdr_stream *xdr, |
2936 | const struct nfsd4_fattr_args *args) |
2937 | { |
2938 | return nfsd4_encode_bool(xdr, val: false); |
2939 | } |
2940 | |
2941 | static __be32 nfsd4_encode_fattr4_supported_attrs(struct xdr_stream *xdr, |
2942 | const struct nfsd4_fattr_args *args) |
2943 | { |
2944 | struct nfsd4_compoundres *resp = args->rqstp->rq_resp; |
2945 | u32 minorversion = resp->cstate.minorversion; |
2946 | u32 supp[3]; |
2947 | |
2948 | memcpy(supp, nfsd_suppattrs[minorversion], sizeof(supp)); |
2949 | if (!IS_POSIXACL(d_inode(args->dentry))) |
2950 | supp[0] &= ~FATTR4_WORD0_ACL; |
2951 | if (!args->contextsupport) |
2952 | supp[2] &= ~FATTR4_WORD2_SECURITY_LABEL; |
2953 | |
2954 | return nfsd4_encode_bitmap4(xdr, bmval0: supp[0], bmval1: supp[1], bmval2: supp[2]); |
2955 | } |
2956 | |
2957 | static __be32 nfsd4_encode_fattr4_type(struct xdr_stream *xdr, |
2958 | const struct nfsd4_fattr_args *args) |
2959 | { |
2960 | __be32 *p; |
2961 | |
2962 | p = xdr_reserve_space(xdr, XDR_UNIT); |
2963 | if (!p) |
2964 | return nfserr_resource; |
2965 | |
2966 | switch (args->stat.mode & S_IFMT) { |
2967 | case S_IFIFO: |
2968 | *p = cpu_to_be32(NF4FIFO); |
2969 | break; |
2970 | case S_IFCHR: |
2971 | *p = cpu_to_be32(NF4CHR); |
2972 | break; |
2973 | case S_IFDIR: |
2974 | *p = cpu_to_be32(NF4DIR); |
2975 | break; |
2976 | case S_IFBLK: |
2977 | *p = cpu_to_be32(NF4BLK); |
2978 | break; |
2979 | case S_IFLNK: |
2980 | *p = cpu_to_be32(NF4LNK); |
2981 | break; |
2982 | case S_IFREG: |
2983 | *p = cpu_to_be32(NF4REG); |
2984 | break; |
2985 | case S_IFSOCK: |
2986 | *p = cpu_to_be32(NF4SOCK); |
2987 | break; |
2988 | default: |
2989 | return nfserr_serverfault; |
2990 | } |
2991 | |
2992 | return nfs_ok; |
2993 | } |
2994 | |
2995 | static __be32 nfsd4_encode_fattr4_fh_expire_type(struct xdr_stream *xdr, |
2996 | const struct nfsd4_fattr_args *args) |
2997 | { |
2998 | u32 mask; |
2999 | |
3000 | mask = NFS4_FH_PERSISTENT; |
3001 | if (!(args->exp->ex_flags & NFSEXP_NOSUBTREECHECK)) |
3002 | mask |= NFS4_FH_VOL_RENAME; |
3003 | return nfsd4_encode_uint32_t(xdr, val: mask); |
3004 | } |
3005 | |
3006 | static __be32 nfsd4_encode_fattr4_change(struct xdr_stream *xdr, |
3007 | const struct nfsd4_fattr_args *args) |
3008 | { |
3009 | const struct svc_export *exp = args->exp; |
3010 | u64 c; |
3011 | |
3012 | if (unlikely(exp->ex_flags & NFSEXP_V4ROOT)) { |
3013 | u32 flush_time = convert_to_wallclock(sinceboot: exp->cd->flush_time); |
3014 | |
3015 | if (xdr_stream_encode_u32(xdr, n: flush_time) != XDR_UNIT) |
3016 | return nfserr_resource; |
3017 | if (xdr_stream_encode_u32(xdr, n: 0) != XDR_UNIT) |
3018 | return nfserr_resource; |
3019 | return nfs_ok; |
3020 | } |
3021 | |
3022 | c = nfsd4_change_attribute(stat: &args->stat, inode: d_inode(dentry: args->dentry)); |
3023 | return nfsd4_encode_changeid4(xdr, c); |
3024 | } |
3025 | |
3026 | static __be32 nfsd4_encode_fattr4_size(struct xdr_stream *xdr, |
3027 | const struct nfsd4_fattr_args *args) |
3028 | { |
3029 | return nfsd4_encode_uint64_t(xdr, val: args->size); |
3030 | } |
3031 | |
3032 | static __be32 nfsd4_encode_fattr4_fsid(struct xdr_stream *xdr, |
3033 | const struct nfsd4_fattr_args *args) |
3034 | { |
3035 | __be32 *p; |
3036 | |
3037 | p = xdr_reserve_space(xdr, XDR_UNIT * 2 + XDR_UNIT * 2); |
3038 | if (!p) |
3039 | return nfserr_resource; |
3040 | |
3041 | if (unlikely(args->exp->ex_fslocs.migrated)) { |
3042 | p = xdr_encode_hyper(p, NFS4_REFERRAL_FSID_MAJOR); |
3043 | xdr_encode_hyper(p, NFS4_REFERRAL_FSID_MINOR); |
3044 | return nfs_ok; |
3045 | } |
3046 | switch (fsid_source(fhp: args->fhp)) { |
3047 | case FSIDSOURCE_FSID: |
3048 | p = xdr_encode_hyper(p, val: (u64)args->exp->ex_fsid); |
3049 | xdr_encode_hyper(p, val: (u64)0); |
3050 | break; |
3051 | case FSIDSOURCE_DEV: |
3052 | *p++ = xdr_zero; |
3053 | *p++ = cpu_to_be32(MAJOR(args->stat.dev)); |
3054 | *p++ = xdr_zero; |
3055 | *p = cpu_to_be32(MINOR(args->stat.dev)); |
3056 | break; |
3057 | case FSIDSOURCE_UUID: |
3058 | xdr_encode_opaque_fixed(p, ptr: args->exp->ex_uuid, EX_UUID_LEN); |
3059 | break; |
3060 | } |
3061 | |
3062 | return nfs_ok; |
3063 | } |
3064 | |
3065 | static __be32 nfsd4_encode_fattr4_lease_time(struct xdr_stream *xdr, |
3066 | const struct nfsd4_fattr_args *args) |
3067 | { |
3068 | struct nfsd_net *nn = net_generic(SVC_NET(args->rqstp), id: nfsd_net_id); |
3069 | |
3070 | return nfsd4_encode_nfs_lease4(xdr, nn->nfsd4_lease); |
3071 | } |
3072 | |
3073 | static __be32 nfsd4_encode_fattr4_rdattr_error(struct xdr_stream *xdr, |
3074 | const struct nfsd4_fattr_args *args) |
3075 | { |
3076 | return nfsd4_encode_uint32_t(xdr, val: args->rdattr_err); |
3077 | } |
3078 | |
3079 | static __be32 nfsd4_encode_fattr4_aclsupport(struct xdr_stream *xdr, |
3080 | const struct nfsd4_fattr_args *args) |
3081 | { |
3082 | u32 mask; |
3083 | |
3084 | mask = 0; |
3085 | if (IS_POSIXACL(d_inode(args->dentry))) |
3086 | mask = ACL4_SUPPORT_ALLOW_ACL | ACL4_SUPPORT_DENY_ACL; |
3087 | return nfsd4_encode_uint32_t(xdr, val: mask); |
3088 | } |
3089 | |
3090 | static __be32 nfsd4_encode_fattr4_acl(struct xdr_stream *xdr, |
3091 | const struct nfsd4_fattr_args *args) |
3092 | { |
3093 | struct nfs4_acl *acl = args->acl; |
3094 | struct nfs4_ace *ace; |
3095 | __be32 status; |
3096 | |
3097 | /* nfsace4<> */ |
3098 | if (!acl) { |
3099 | if (xdr_stream_encode_u32(xdr, n: 0) != XDR_UNIT) |
3100 | return nfserr_resource; |
3101 | } else { |
3102 | if (xdr_stream_encode_u32(xdr, n: acl->naces) != XDR_UNIT) |
3103 | return nfserr_resource; |
3104 | for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) { |
3105 | status = nfsd4_encode_nfsace4(xdr, rqstp: args->rqstp, ace); |
3106 | if (status != nfs_ok) |
3107 | return status; |
3108 | } |
3109 | } |
3110 | return nfs_ok; |
3111 | } |
3112 | |
3113 | static __be32 nfsd4_encode_fattr4_filehandle(struct xdr_stream *xdr, |
3114 | const struct nfsd4_fattr_args *args) |
3115 | { |
3116 | return nfsd4_encode_nfs_fh4(xdr, fh_handle: &args->fhp->fh_handle); |
3117 | } |
3118 | |
3119 | static __be32 nfsd4_encode_fattr4_fileid(struct xdr_stream *xdr, |
3120 | const struct nfsd4_fattr_args *args) |
3121 | { |
3122 | return nfsd4_encode_uint64_t(xdr, val: args->stat.ino); |
3123 | } |
3124 | |
3125 | static __be32 nfsd4_encode_fattr4_files_avail(struct xdr_stream *xdr, |
3126 | const struct nfsd4_fattr_args *args) |
3127 | { |
3128 | return nfsd4_encode_uint64_t(xdr, val: args->statfs.f_ffree); |
3129 | } |
3130 | |
3131 | static __be32 nfsd4_encode_fattr4_files_free(struct xdr_stream *xdr, |
3132 | const struct nfsd4_fattr_args *args) |
3133 | { |
3134 | return nfsd4_encode_uint64_t(xdr, val: args->statfs.f_ffree); |
3135 | } |
3136 | |
3137 | static __be32 nfsd4_encode_fattr4_files_total(struct xdr_stream *xdr, |
3138 | const struct nfsd4_fattr_args *args) |
3139 | { |
3140 | return nfsd4_encode_uint64_t(xdr, val: args->statfs.f_files); |
3141 | } |
3142 | |
3143 | static __be32 nfsd4_encode_fattr4_fs_locations(struct xdr_stream *xdr, |
3144 | const struct nfsd4_fattr_args *args) |
3145 | { |
3146 | return nfsd4_encode_fs_locations4(xdr, rqstp: args->rqstp, exp: args->exp); |
3147 | } |
3148 | |
3149 | static __be32 nfsd4_encode_fattr4_maxfilesize(struct xdr_stream *xdr, |
3150 | const struct nfsd4_fattr_args *args) |
3151 | { |
3152 | struct super_block *sb = args->exp->ex_path.mnt->mnt_sb; |
3153 | |
3154 | return nfsd4_encode_uint64_t(xdr, val: sb->s_maxbytes); |
3155 | } |
3156 | |
3157 | static __be32 nfsd4_encode_fattr4_maxlink(struct xdr_stream *xdr, |
3158 | const struct nfsd4_fattr_args *args) |
3159 | { |
3160 | return nfsd4_encode_uint32_t(xdr, val: 255); |
3161 | } |
3162 | |
3163 | static __be32 nfsd4_encode_fattr4_maxname(struct xdr_stream *xdr, |
3164 | const struct nfsd4_fattr_args *args) |
3165 | { |
3166 | return nfsd4_encode_uint32_t(xdr, val: args->statfs.f_namelen); |
3167 | } |
3168 | |
3169 | static __be32 nfsd4_encode_fattr4_maxread(struct xdr_stream *xdr, |
3170 | const struct nfsd4_fattr_args *args) |
3171 | { |
3172 | return nfsd4_encode_uint64_t(xdr, val: svc_max_payload(rqstp: args->rqstp)); |
3173 | } |
3174 | |
3175 | static __be32 nfsd4_encode_fattr4_maxwrite(struct xdr_stream *xdr, |
3176 | const struct nfsd4_fattr_args *args) |
3177 | { |
3178 | return nfsd4_encode_uint64_t(xdr, val: svc_max_payload(rqstp: args->rqstp)); |
3179 | } |
3180 | |
3181 | static __be32 nfsd4_encode_fattr4_mode(struct xdr_stream *xdr, |
3182 | const struct nfsd4_fattr_args *args) |
3183 | { |
3184 | return nfsd4_encode_mode4(xdr, args->stat.mode & S_IALLUGO); |
3185 | } |
3186 | |
3187 | static __be32 nfsd4_encode_fattr4_numlinks(struct xdr_stream *xdr, |
3188 | const struct nfsd4_fattr_args *args) |
3189 | { |
3190 | return nfsd4_encode_uint32_t(xdr, val: args->stat.nlink); |
3191 | } |
3192 | |
3193 | static __be32 nfsd4_encode_fattr4_owner(struct xdr_stream *xdr, |
3194 | const struct nfsd4_fattr_args *args) |
3195 | { |
3196 | return nfsd4_encode_user(xdr, args->rqstp, args->stat.uid); |
3197 | } |
3198 | |
3199 | static __be32 nfsd4_encode_fattr4_owner_group(struct xdr_stream *xdr, |
3200 | const struct nfsd4_fattr_args *args) |
3201 | { |
3202 | return nfsd4_encode_group(xdr, args->rqstp, args->stat.gid); |
3203 | } |
3204 | |
3205 | static __be32 nfsd4_encode_fattr4_rawdev(struct xdr_stream *xdr, |
3206 | const struct nfsd4_fattr_args *args) |
3207 | { |
3208 | return nfsd4_encode_specdata4(xdr, MAJOR(args->stat.rdev), |
3209 | MINOR(args->stat.rdev)); |
3210 | } |
3211 | |
3212 | static __be32 nfsd4_encode_fattr4_space_avail(struct xdr_stream *xdr, |
3213 | const struct nfsd4_fattr_args *args) |
3214 | { |
3215 | u64 avail = (u64)args->statfs.f_bavail * (u64)args->statfs.f_bsize; |
3216 | |
3217 | return nfsd4_encode_uint64_t(xdr, val: avail); |
3218 | } |
3219 | |
3220 | static __be32 nfsd4_encode_fattr4_space_free(struct xdr_stream *xdr, |
3221 | const struct nfsd4_fattr_args *args) |
3222 | { |
3223 | u64 free = (u64)args->statfs.f_bfree * (u64)args->statfs.f_bsize; |
3224 | |
3225 | return nfsd4_encode_uint64_t(xdr, val: free); |
3226 | } |
3227 | |
3228 | static __be32 nfsd4_encode_fattr4_space_total(struct xdr_stream *xdr, |
3229 | const struct nfsd4_fattr_args *args) |
3230 | { |
3231 | u64 total = (u64)args->statfs.f_blocks * (u64)args->statfs.f_bsize; |
3232 | |
3233 | return nfsd4_encode_uint64_t(xdr, val: total); |
3234 | } |
3235 | |
3236 | static __be32 nfsd4_encode_fattr4_space_used(struct xdr_stream *xdr, |
3237 | const struct nfsd4_fattr_args *args) |
3238 | { |
3239 | return nfsd4_encode_uint64_t(xdr, val: (u64)args->stat.blocks << 9); |
3240 | } |
3241 | |
3242 | static __be32 nfsd4_encode_fattr4_time_access(struct xdr_stream *xdr, |
3243 | const struct nfsd4_fattr_args *args) |
3244 | { |
3245 | return nfsd4_encode_nfstime4(xdr, tv: &args->stat.atime); |
3246 | } |
3247 | |
3248 | static __be32 nfsd4_encode_fattr4_time_create(struct xdr_stream *xdr, |
3249 | const struct nfsd4_fattr_args *args) |
3250 | { |
3251 | return nfsd4_encode_nfstime4(xdr, tv: &args->stat.btime); |
3252 | } |
3253 | |
3254 | /* |
3255 | * ctime (in NFSv4, time_metadata) is not writeable, and the client |
3256 | * doesn't really care what resolution could theoretically be stored by |
3257 | * the filesystem. |
3258 | * |
3259 | * The client cares how close together changes can be while still |
3260 | * guaranteeing ctime changes. For most filesystems (which have |
3261 | * timestamps with nanosecond fields) that is limited by the resolution |
3262 | * of the time returned from current_time() (which I'm assuming to be |
3263 | * 1/HZ). |
3264 | */ |
3265 | static __be32 nfsd4_encode_fattr4_time_delta(struct xdr_stream *xdr, |
3266 | const struct nfsd4_fattr_args *args) |
3267 | { |
3268 | const struct inode *inode = d_inode(dentry: args->dentry); |
3269 | u32 ns = max_t(u32, NSEC_PER_SEC/HZ, inode->i_sb->s_time_gran); |
3270 | struct timespec64 ts = ns_to_timespec64(nsec: ns); |
3271 | |
3272 | return nfsd4_encode_nfstime4(xdr, tv: &ts); |
3273 | } |
3274 | |
3275 | static __be32 nfsd4_encode_fattr4_time_metadata(struct xdr_stream *xdr, |
3276 | const struct nfsd4_fattr_args *args) |
3277 | { |
3278 | return nfsd4_encode_nfstime4(xdr, tv: &args->stat.ctime); |
3279 | } |
3280 | |
3281 | static __be32 nfsd4_encode_fattr4_time_modify(struct xdr_stream *xdr, |
3282 | const struct nfsd4_fattr_args *args) |
3283 | { |
3284 | return nfsd4_encode_nfstime4(xdr, tv: &args->stat.mtime); |
3285 | } |
3286 | |
3287 | static __be32 nfsd4_encode_fattr4_mounted_on_fileid(struct xdr_stream *xdr, |
3288 | const struct nfsd4_fattr_args *args) |
3289 | { |
3290 | u64 ino; |
3291 | int err; |
3292 | |
3293 | if (!args->ignore_crossmnt && |
3294 | args->dentry == args->exp->ex_path.mnt->mnt_root) { |
3295 | err = nfsd4_get_mounted_on_ino(exp: args->exp, pino: &ino); |
3296 | if (err) |
3297 | return nfserrno(errno: err); |
3298 | } else |
3299 | ino = args->stat.ino; |
3300 | |
3301 | return nfsd4_encode_uint64_t(xdr, val: ino); |
3302 | } |
3303 | |
3304 | #ifdef CONFIG_NFSD_PNFS |
3305 | |
3306 | static __be32 nfsd4_encode_fattr4_fs_layout_types(struct xdr_stream *xdr, |
3307 | const struct nfsd4_fattr_args *args) |
3308 | { |
3309 | unsigned long mask = args->exp->ex_layout_types; |
3310 | int i; |
3311 | |
3312 | /* Hamming weight of @mask is the number of layout types to return */ |
3313 | if (xdr_stream_encode_u32(xdr, n: hweight_long(w: mask)) != XDR_UNIT) |
3314 | return nfserr_resource; |
3315 | for (i = LAYOUT_NFSV4_1_FILES; i < LAYOUT_TYPE_MAX; ++i) |
3316 | if (mask & BIT(i)) { |
3317 | /* layouttype4 */ |
3318 | if (xdr_stream_encode_u32(xdr, n: i) != XDR_UNIT) |
3319 | return nfserr_resource; |
3320 | } |
3321 | return nfs_ok; |
3322 | } |
3323 | |
3324 | static __be32 nfsd4_encode_fattr4_layout_types(struct xdr_stream *xdr, |
3325 | const struct nfsd4_fattr_args *args) |
3326 | { |
3327 | unsigned long mask = args->exp->ex_layout_types; |
3328 | int i; |
3329 | |
3330 | /* Hamming weight of @mask is the number of layout types to return */ |
3331 | if (xdr_stream_encode_u32(xdr, n: hweight_long(w: mask)) != XDR_UNIT) |
3332 | return nfserr_resource; |
3333 | for (i = LAYOUT_NFSV4_1_FILES; i < LAYOUT_TYPE_MAX; ++i) |
3334 | if (mask & BIT(i)) { |
3335 | /* layouttype4 */ |
3336 | if (xdr_stream_encode_u32(xdr, n: i) != XDR_UNIT) |
3337 | return nfserr_resource; |
3338 | } |
3339 | return nfs_ok; |
3340 | } |
3341 | |
3342 | static __be32 nfsd4_encode_fattr4_layout_blksize(struct xdr_stream *xdr, |
3343 | const struct nfsd4_fattr_args *args) |
3344 | { |
3345 | return nfsd4_encode_uint32_t(xdr, val: args->stat.blksize); |
3346 | } |
3347 | |
3348 | #endif |
3349 | |
3350 | static __be32 nfsd4_encode_fattr4_suppattr_exclcreat(struct xdr_stream *xdr, |
3351 | const struct nfsd4_fattr_args *args) |
3352 | { |
3353 | struct nfsd4_compoundres *resp = args->rqstp->rq_resp; |
3354 | u32 supp[3]; |
3355 | |
3356 | memcpy(supp, nfsd_suppattrs[resp->cstate.minorversion], sizeof(supp)); |
3357 | supp[0] &= NFSD_SUPPATTR_EXCLCREAT_WORD0; |
3358 | supp[1] &= NFSD_SUPPATTR_EXCLCREAT_WORD1; |
3359 | supp[2] &= NFSD_SUPPATTR_EXCLCREAT_WORD2; |
3360 | |
3361 | return nfsd4_encode_bitmap4(xdr, bmval0: supp[0], bmval1: supp[1], bmval2: supp[2]); |
3362 | } |
3363 | |
3364 | #ifdef CONFIG_NFSD_V4_SECURITY_LABEL |
3365 | static __be32 nfsd4_encode_fattr4_sec_label(struct xdr_stream *xdr, |
3366 | const struct nfsd4_fattr_args *args) |
3367 | { |
3368 | return nfsd4_encode_security_label(xdr, rqstp: args->rqstp, |
3369 | context: args->context, len: args->contextlen); |
3370 | } |
3371 | #endif |
3372 | |
3373 | static __be32 nfsd4_encode_fattr4_xattr_support(struct xdr_stream *xdr, |
3374 | const struct nfsd4_fattr_args *args) |
3375 | { |
3376 | int err = xattr_supports_user_prefix(inode: d_inode(dentry: args->dentry)); |
3377 | |
3378 | return nfsd4_encode_bool(xdr, val: err == 0); |
3379 | } |
3380 | |
3381 | static const nfsd4_enc_attr nfsd4_enc_fattr4_encode_ops[] = { |
3382 | [FATTR4_SUPPORTED_ATTRS] = nfsd4_encode_fattr4_supported_attrs, |
3383 | [FATTR4_TYPE] = nfsd4_encode_fattr4_type, |
3384 | [FATTR4_FH_EXPIRE_TYPE] = nfsd4_encode_fattr4_fh_expire_type, |
3385 | [FATTR4_CHANGE] = nfsd4_encode_fattr4_change, |
3386 | [FATTR4_SIZE] = nfsd4_encode_fattr4_size, |
3387 | [FATTR4_LINK_SUPPORT] = nfsd4_encode_fattr4__true, |
3388 | [FATTR4_SYMLINK_SUPPORT] = nfsd4_encode_fattr4__true, |
3389 | [FATTR4_NAMED_ATTR] = nfsd4_encode_fattr4__false, |
3390 | [FATTR4_FSID] = nfsd4_encode_fattr4_fsid, |
3391 | [FATTR4_UNIQUE_HANDLES] = nfsd4_encode_fattr4__true, |
3392 | [FATTR4_LEASE_TIME] = nfsd4_encode_fattr4_lease_time, |
3393 | [FATTR4_RDATTR_ERROR] = nfsd4_encode_fattr4_rdattr_error, |
3394 | [FATTR4_ACL] = nfsd4_encode_fattr4_acl, |
3395 | [FATTR4_ACLSUPPORT] = nfsd4_encode_fattr4_aclsupport, |
3396 | [FATTR4_ARCHIVE] = nfsd4_encode_fattr4__noop, |
3397 | [FATTR4_CANSETTIME] = nfsd4_encode_fattr4__true, |
3398 | [FATTR4_CASE_INSENSITIVE] = nfsd4_encode_fattr4__false, |
3399 | [FATTR4_CASE_PRESERVING] = nfsd4_encode_fattr4__true, |
3400 | [FATTR4_CHOWN_RESTRICTED] = nfsd4_encode_fattr4__true, |
3401 | [FATTR4_FILEHANDLE] = nfsd4_encode_fattr4_filehandle, |
3402 | [FATTR4_FILEID] = nfsd4_encode_fattr4_fileid, |
3403 | [FATTR4_FILES_AVAIL] = nfsd4_encode_fattr4_files_avail, |
3404 | [FATTR4_FILES_FREE] = nfsd4_encode_fattr4_files_free, |
3405 | [FATTR4_FILES_TOTAL] = nfsd4_encode_fattr4_files_total, |
3406 | [FATTR4_FS_LOCATIONS] = nfsd4_encode_fattr4_fs_locations, |
3407 | [FATTR4_HIDDEN] = nfsd4_encode_fattr4__noop, |
3408 | [FATTR4_HOMOGENEOUS] = nfsd4_encode_fattr4__true, |
3409 | [FATTR4_MAXFILESIZE] = nfsd4_encode_fattr4_maxfilesize, |
3410 | [FATTR4_MAXLINK] = nfsd4_encode_fattr4_maxlink, |
3411 | [FATTR4_MAXNAME] = nfsd4_encode_fattr4_maxname, |
3412 | [FATTR4_MAXREAD] = nfsd4_encode_fattr4_maxread, |
3413 | [FATTR4_MAXWRITE] = nfsd4_encode_fattr4_maxwrite, |
3414 | [FATTR4_MIMETYPE] = nfsd4_encode_fattr4__noop, |
3415 | [FATTR4_MODE] = nfsd4_encode_fattr4_mode, |
3416 | [FATTR4_NO_TRUNC] = nfsd4_encode_fattr4__true, |
3417 | [FATTR4_NUMLINKS] = nfsd4_encode_fattr4_numlinks, |
3418 | [FATTR4_OWNER] = nfsd4_encode_fattr4_owner, |
3419 | [FATTR4_OWNER_GROUP] = nfsd4_encode_fattr4_owner_group, |
3420 | [FATTR4_QUOTA_AVAIL_HARD] = nfsd4_encode_fattr4__noop, |
3421 | [FATTR4_QUOTA_AVAIL_SOFT] = nfsd4_encode_fattr4__noop, |
3422 | [FATTR4_QUOTA_USED] = nfsd4_encode_fattr4__noop, |
3423 | [FATTR4_RAWDEV] = nfsd4_encode_fattr4_rawdev, |
3424 | [FATTR4_SPACE_AVAIL] = nfsd4_encode_fattr4_space_avail, |
3425 | [FATTR4_SPACE_FREE] = nfsd4_encode_fattr4_space_free, |
3426 | [FATTR4_SPACE_TOTAL] = nfsd4_encode_fattr4_space_total, |
3427 | [FATTR4_SPACE_USED] = nfsd4_encode_fattr4_space_used, |
3428 | [FATTR4_SYSTEM] = nfsd4_encode_fattr4__noop, |
3429 | [FATTR4_TIME_ACCESS] = nfsd4_encode_fattr4_time_access, |
3430 | [FATTR4_TIME_ACCESS_SET] = nfsd4_encode_fattr4__noop, |
3431 | [FATTR4_TIME_BACKUP] = nfsd4_encode_fattr4__noop, |
3432 | [FATTR4_TIME_CREATE] = nfsd4_encode_fattr4_time_create, |
3433 | [FATTR4_TIME_DELTA] = nfsd4_encode_fattr4_time_delta, |
3434 | [FATTR4_TIME_METADATA] = nfsd4_encode_fattr4_time_metadata, |
3435 | [FATTR4_TIME_MODIFY] = nfsd4_encode_fattr4_time_modify, |
3436 | [FATTR4_TIME_MODIFY_SET] = nfsd4_encode_fattr4__noop, |
3437 | [FATTR4_MOUNTED_ON_FILEID] = nfsd4_encode_fattr4_mounted_on_fileid, |
3438 | [FATTR4_DIR_NOTIF_DELAY] = nfsd4_encode_fattr4__noop, |
3439 | [FATTR4_DIRENT_NOTIF_DELAY] = nfsd4_encode_fattr4__noop, |
3440 | [FATTR4_DACL] = nfsd4_encode_fattr4__noop, |
3441 | [FATTR4_SACL] = nfsd4_encode_fattr4__noop, |
3442 | [FATTR4_CHANGE_POLICY] = nfsd4_encode_fattr4__noop, |
3443 | [FATTR4_FS_STATUS] = nfsd4_encode_fattr4__noop, |
3444 | |
3445 | #ifdef CONFIG_NFSD_PNFS |
3446 | [FATTR4_FS_LAYOUT_TYPES] = nfsd4_encode_fattr4_fs_layout_types, |
3447 | [FATTR4_LAYOUT_HINT] = nfsd4_encode_fattr4__noop, |
3448 | [FATTR4_LAYOUT_TYPES] = nfsd4_encode_fattr4_layout_types, |
3449 | [FATTR4_LAYOUT_BLKSIZE] = nfsd4_encode_fattr4_layout_blksize, |
3450 | [FATTR4_LAYOUT_ALIGNMENT] = nfsd4_encode_fattr4__noop, |
3451 | #else |
3452 | [FATTR4_FS_LAYOUT_TYPES] = nfsd4_encode_fattr4__noop, |
3453 | [FATTR4_LAYOUT_HINT] = nfsd4_encode_fattr4__noop, |
3454 | [FATTR4_LAYOUT_TYPES] = nfsd4_encode_fattr4__noop, |
3455 | [FATTR4_LAYOUT_BLKSIZE] = nfsd4_encode_fattr4__noop, |
3456 | [FATTR4_LAYOUT_ALIGNMENT] = nfsd4_encode_fattr4__noop, |
3457 | #endif |
3458 | |
3459 | [FATTR4_FS_LOCATIONS_INFO] = nfsd4_encode_fattr4__noop, |
3460 | [FATTR4_MDSTHRESHOLD] = nfsd4_encode_fattr4__noop, |
3461 | [FATTR4_RETENTION_GET] = nfsd4_encode_fattr4__noop, |
3462 | [FATTR4_RETENTION_SET] = nfsd4_encode_fattr4__noop, |
3463 | [FATTR4_RETENTEVT_GET] = nfsd4_encode_fattr4__noop, |
3464 | [FATTR4_RETENTEVT_SET] = nfsd4_encode_fattr4__noop, |
3465 | [FATTR4_RETENTION_HOLD] = nfsd4_encode_fattr4__noop, |
3466 | [FATTR4_MODE_SET_MASKED] = nfsd4_encode_fattr4__noop, |
3467 | [FATTR4_SUPPATTR_EXCLCREAT] = nfsd4_encode_fattr4_suppattr_exclcreat, |
3468 | [FATTR4_FS_CHARSET_CAP] = nfsd4_encode_fattr4__noop, |
3469 | [FATTR4_CLONE_BLKSIZE] = nfsd4_encode_fattr4__noop, |
3470 | [FATTR4_SPACE_FREED] = nfsd4_encode_fattr4__noop, |
3471 | [FATTR4_CHANGE_ATTR_TYPE] = nfsd4_encode_fattr4__noop, |
3472 | |
3473 | #ifdef CONFIG_NFSD_V4_SECURITY_LABEL |
3474 | [FATTR4_SEC_LABEL] = nfsd4_encode_fattr4_sec_label, |
3475 | #else |
3476 | [FATTR4_SEC_LABEL] = nfsd4_encode_fattr4__noop, |
3477 | #endif |
3478 | |
3479 | [FATTR4_MODE_UMASK] = nfsd4_encode_fattr4__noop, |
3480 | [FATTR4_XATTR_SUPPORT] = nfsd4_encode_fattr4_xattr_support, |
3481 | }; |
3482 | |
3483 | /* |
3484 | * Note: @fhp can be NULL; in this case, we might have to compose the filehandle |
3485 | * ourselves. |
3486 | */ |
3487 | static __be32 |
3488 | nfsd4_encode_fattr4(struct svc_rqst *rqstp, struct xdr_stream *xdr, |
3489 | struct svc_fh *fhp, struct svc_export *exp, |
3490 | struct dentry *dentry, const u32 *bmval, |
3491 | int ignore_crossmnt) |
3492 | { |
3493 | DECLARE_BITMAP(attr_bitmap, ARRAY_SIZE(nfsd4_enc_fattr4_encode_ops)); |
3494 | struct nfsd4_fattr_args args; |
3495 | struct svc_fh *tempfh = NULL; |
3496 | int starting_len = xdr->buf->len; |
3497 | __be32 *attrlen_p, status; |
3498 | int attrlen_offset; |
3499 | u32 attrmask[3]; |
3500 | int err; |
3501 | struct nfsd4_compoundres *resp = rqstp->rq_resp; |
3502 | u32 minorversion = resp->cstate.minorversion; |
3503 | struct path path = { |
3504 | .mnt = exp->ex_path.mnt, |
3505 | .dentry = dentry, |
3506 | }; |
3507 | unsigned long bit; |
3508 | bool file_modified = false; |
3509 | u64 size = 0; |
3510 | |
3511 | WARN_ON_ONCE(bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1); |
3512 | WARN_ON_ONCE(!nfsd_attrs_supported(minorversion, bmval)); |
3513 | |
3514 | args.rqstp = rqstp; |
3515 | args.exp = exp; |
3516 | args.dentry = dentry; |
3517 | args.ignore_crossmnt = (ignore_crossmnt != 0); |
3518 | |
3519 | /* |
3520 | * Make a local copy of the attribute bitmap that can be modified. |
3521 | */ |
3522 | attrmask[0] = bmval[0]; |
3523 | attrmask[1] = bmval[1]; |
3524 | attrmask[2] = bmval[2]; |
3525 | |
3526 | args.rdattr_err = 0; |
3527 | if (exp->ex_fslocs.migrated) { |
3528 | status = fattr_handle_absent_fs(bmval0: &attrmask[0], bmval1: &attrmask[1], |
3529 | bmval2: &attrmask[2], rdattr_err: &args.rdattr_err); |
3530 | if (status) |
3531 | goto out; |
3532 | } |
3533 | args.size = 0; |
3534 | if (attrmask[0] & (FATTR4_WORD0_CHANGE | FATTR4_WORD0_SIZE)) { |
3535 | status = nfsd4_deleg_getattr_conflict(rqstp, inode: d_inode(dentry), |
3536 | file_modified: &file_modified, size: &size); |
3537 | if (status) |
3538 | goto out; |
3539 | } |
3540 | |
3541 | err = vfs_getattr(&path, &args.stat, |
3542 | STATX_BASIC_STATS | STATX_BTIME | STATX_CHANGE_COOKIE, |
3543 | AT_STATX_SYNC_AS_STAT); |
3544 | if (err) |
3545 | goto out_nfserr; |
3546 | if (file_modified) |
3547 | args.size = size; |
3548 | else |
3549 | args.size = args.stat.size; |
3550 | |
3551 | if (!(args.stat.result_mask & STATX_BTIME)) |
3552 | /* underlying FS does not offer btime so we can't share it */ |
3553 | attrmask[1] &= ~FATTR4_WORD1_TIME_CREATE; |
3554 | if ((attrmask[0] & (FATTR4_WORD0_FILES_AVAIL | FATTR4_WORD0_FILES_FREE | |
3555 | FATTR4_WORD0_FILES_TOTAL | FATTR4_WORD0_MAXNAME)) || |
3556 | (attrmask[1] & (FATTR4_WORD1_SPACE_AVAIL | FATTR4_WORD1_SPACE_FREE | |
3557 | FATTR4_WORD1_SPACE_TOTAL))) { |
3558 | err = vfs_statfs(&path, &args.statfs); |
3559 | if (err) |
3560 | goto out_nfserr; |
3561 | } |
3562 | if ((attrmask[0] & (FATTR4_WORD0_FILEHANDLE | FATTR4_WORD0_FSID)) && |
3563 | !fhp) { |
3564 | tempfh = kmalloc(size: sizeof(struct svc_fh), GFP_KERNEL); |
3565 | status = nfserr_jukebox; |
3566 | if (!tempfh) |
3567 | goto out; |
3568 | fh_init(fhp: tempfh, NFS4_FHSIZE); |
3569 | status = fh_compose(tempfh, exp, dentry, NULL); |
3570 | if (status) |
3571 | goto out; |
3572 | args.fhp = tempfh; |
3573 | } else |
3574 | args.fhp = fhp; |
3575 | |
3576 | args.acl = NULL; |
3577 | if (attrmask[0] & FATTR4_WORD0_ACL) { |
3578 | err = nfsd4_get_nfs4_acl(rqstp, dentry, acl: &args.acl); |
3579 | if (err == -EOPNOTSUPP) |
3580 | attrmask[0] &= ~FATTR4_WORD0_ACL; |
3581 | else if (err == -EINVAL) { |
3582 | status = nfserr_attrnotsupp; |
3583 | goto out; |
3584 | } else if (err != 0) |
3585 | goto out_nfserr; |
3586 | } |
3587 | |
3588 | args.contextsupport = false; |
3589 | |
3590 | #ifdef CONFIG_NFSD_V4_SECURITY_LABEL |
3591 | args.context = NULL; |
3592 | if ((attrmask[2] & FATTR4_WORD2_SECURITY_LABEL) || |
3593 | attrmask[0] & FATTR4_WORD0_SUPPORTED_ATTRS) { |
3594 | if (exp->ex_flags & NFSEXP_SECURITY_LABEL) |
3595 | err = security_inode_getsecctx(inode: d_inode(dentry), |
3596 | ctx: &args.context, ctxlen: &args.contextlen); |
3597 | else |
3598 | err = -EOPNOTSUPP; |
3599 | args.contextsupport = (err == 0); |
3600 | if (attrmask[2] & FATTR4_WORD2_SECURITY_LABEL) { |
3601 | if (err == -EOPNOTSUPP) |
3602 | attrmask[2] &= ~FATTR4_WORD2_SECURITY_LABEL; |
3603 | else if (err) |
3604 | goto out_nfserr; |
3605 | } |
3606 | } |
3607 | #endif /* CONFIG_NFSD_V4_SECURITY_LABEL */ |
3608 | |
3609 | /* attrmask */ |
3610 | status = nfsd4_encode_bitmap4(xdr, bmval0: attrmask[0], bmval1: attrmask[1], |
3611 | bmval2: attrmask[2]); |
3612 | if (status) |
3613 | goto out; |
3614 | |
3615 | /* attr_vals */ |
3616 | attrlen_offset = xdr->buf->len; |
3617 | attrlen_p = xdr_reserve_space(xdr, XDR_UNIT); |
3618 | if (!attrlen_p) |
3619 | goto out_resource; |
3620 | bitmap_from_arr32(bitmap: attr_bitmap, buf: attrmask, |
3621 | ARRAY_SIZE(nfsd4_enc_fattr4_encode_ops)); |
3622 | for_each_set_bit(bit, attr_bitmap, |
3623 | ARRAY_SIZE(nfsd4_enc_fattr4_encode_ops)) { |
3624 | status = nfsd4_enc_fattr4_encode_ops[bit](xdr, &args); |
3625 | if (status != nfs_ok) |
3626 | goto out; |
3627 | } |
3628 | *attrlen_p = cpu_to_be32(xdr->buf->len - attrlen_offset - XDR_UNIT); |
3629 | status = nfs_ok; |
3630 | |
3631 | out: |
3632 | #ifdef CONFIG_NFSD_V4_SECURITY_LABEL |
3633 | if (args.context) |
3634 | security_release_secctx(secdata: args.context, seclen: args.contextlen); |
3635 | #endif /* CONFIG_NFSD_V4_SECURITY_LABEL */ |
3636 | kfree(objp: args.acl); |
3637 | if (tempfh) { |
3638 | fh_put(tempfh); |
3639 | kfree(objp: tempfh); |
3640 | } |
3641 | if (status) |
3642 | xdr_truncate_encode(xdr, len: starting_len); |
3643 | return status; |
3644 | out_nfserr: |
3645 | status = nfserrno(errno: err); |
3646 | goto out; |
3647 | out_resource: |
3648 | status = nfserr_resource; |
3649 | goto out; |
3650 | } |
3651 | |
3652 | static void svcxdr_init_encode_from_buffer(struct xdr_stream *xdr, |
3653 | struct xdr_buf *buf, __be32 *p, int bytes) |
3654 | { |
3655 | xdr->scratch.iov_len = 0; |
3656 | memset(buf, 0, sizeof(struct xdr_buf)); |
3657 | buf->head[0].iov_base = p; |
3658 | buf->head[0].iov_len = 0; |
3659 | buf->len = 0; |
3660 | xdr->buf = buf; |
3661 | xdr->iov = buf->head; |
3662 | xdr->p = p; |
3663 | xdr->end = (void *)p + bytes; |
3664 | buf->buflen = bytes; |
3665 | } |
3666 | |
3667 | __be32 nfsd4_encode_fattr_to_buf(__be32 **p, int words, |
3668 | struct svc_fh *fhp, struct svc_export *exp, |
3669 | struct dentry *dentry, u32 *bmval, |
3670 | struct svc_rqst *rqstp, int ignore_crossmnt) |
3671 | { |
3672 | struct xdr_buf dummy; |
3673 | struct xdr_stream xdr; |
3674 | __be32 ret; |
3675 | |
3676 | svcxdr_init_encode_from_buffer(xdr: &xdr, buf: &dummy, p: *p, bytes: words << 2); |
3677 | ret = nfsd4_encode_fattr4(rqstp, xdr: &xdr, fhp, exp, dentry, bmval, |
3678 | ignore_crossmnt); |
3679 | *p = xdr.p; |
3680 | return ret; |
3681 | } |
3682 | |
3683 | /* |
3684 | * The buffer space for this field was reserved during a previous |
3685 | * call to nfsd4_encode_entry4(). |
3686 | */ |
3687 | static void nfsd4_encode_entry4_nfs_cookie4(const struct nfsd4_readdir *readdir, |
3688 | u64 offset) |
3689 | { |
3690 | __be64 cookie = cpu_to_be64(offset); |
3691 | struct xdr_stream *xdr = readdir->xdr; |
3692 | |
3693 | if (!readdir->cookie_offset) |
3694 | return; |
3695 | write_bytes_to_xdr_buf(xdr->buf, readdir->cookie_offset, &cookie, |
3696 | sizeof(cookie)); |
3697 | } |
3698 | |
3699 | static inline int attributes_need_mount(u32 *bmval) |
3700 | { |
3701 | if (bmval[0] & ~(FATTR4_WORD0_RDATTR_ERROR | FATTR4_WORD0_LEASE_TIME)) |
3702 | return 1; |
3703 | if (bmval[1] & ~FATTR4_WORD1_MOUNTED_ON_FILEID) |
3704 | return 1; |
3705 | return 0; |
3706 | } |
3707 | |
3708 | static __be32 |
3709 | nfsd4_encode_entry4_fattr(struct nfsd4_readdir *cd, const char *name, |
3710 | int namlen) |
3711 | { |
3712 | struct svc_export *exp = cd->rd_fhp->fh_export; |
3713 | struct dentry *dentry; |
3714 | __be32 nfserr; |
3715 | int ignore_crossmnt = 0; |
3716 | |
3717 | dentry = lookup_positive_unlocked(name, cd->rd_fhp->fh_dentry, namlen); |
3718 | if (IS_ERR(ptr: dentry)) |
3719 | return nfserrno(errno: PTR_ERR(ptr: dentry)); |
3720 | |
3721 | exp_get(exp); |
3722 | /* |
3723 | * In the case of a mountpoint, the client may be asking for |
3724 | * attributes that are only properties of the underlying filesystem |
3725 | * as opposed to the cross-mounted file system. In such a case, |
3726 | * we will not follow the cross mount and will fill the attribtutes |
3727 | * directly from the mountpoint dentry. |
3728 | */ |
3729 | if (nfsd_mountpoint(dentry, exp)) { |
3730 | int err; |
3731 | |
3732 | if (!(exp->ex_flags & NFSEXP_V4ROOT) |
3733 | && !attributes_need_mount(bmval: cd->rd_bmval)) { |
3734 | ignore_crossmnt = 1; |
3735 | goto out_encode; |
3736 | } |
3737 | /* |
3738 | * Why the heck aren't we just using nfsd_lookup?? |
3739 | * Different "."/".." handling? Something else? |
3740 | * At least, add a comment here to explain.... |
3741 | */ |
3742 | err = nfsd_cross_mnt(rqstp: cd->rd_rqstp, dpp: &dentry, expp: &exp); |
3743 | if (err) { |
3744 | nfserr = nfserrno(errno: err); |
3745 | goto out_put; |
3746 | } |
3747 | nfserr = check_nfsd_access(exp, rqstp: cd->rd_rqstp); |
3748 | if (nfserr) |
3749 | goto out_put; |
3750 | |
3751 | } |
3752 | out_encode: |
3753 | nfserr = nfsd4_encode_fattr4(rqstp: cd->rd_rqstp, xdr: cd->xdr, NULL, exp, dentry, |
3754 | bmval: cd->rd_bmval, ignore_crossmnt); |
3755 | out_put: |
3756 | dput(dentry); |
3757 | exp_put(exp); |
3758 | return nfserr; |
3759 | } |
3760 | |
3761 | static __be32 |
3762 | nfsd4_encode_entry4_rdattr_error(struct xdr_stream *xdr, __be32 nfserr) |
3763 | { |
3764 | __be32 status; |
3765 | |
3766 | /* attrmask */ |
3767 | status = nfsd4_encode_bitmap4(xdr, FATTR4_WORD0_RDATTR_ERROR, bmval1: 0, bmval2: 0); |
3768 | if (status != nfs_ok) |
3769 | return status; |
3770 | /* attr_vals */ |
3771 | if (xdr_stream_encode_u32(xdr, XDR_UNIT) != XDR_UNIT) |
3772 | return nfserr_resource; |
3773 | /* rdattr_error */ |
3774 | if (xdr_stream_encode_be32(xdr, n: nfserr) != XDR_UNIT) |
3775 | return nfserr_resource; |
3776 | return nfs_ok; |
3777 | } |
3778 | |
3779 | static int |
3780 | nfsd4_encode_entry4(void *ccdv, const char *name, int namlen, |
3781 | loff_t offset, u64 ino, unsigned int d_type) |
3782 | { |
3783 | struct readdir_cd *ccd = ccdv; |
3784 | struct nfsd4_readdir *cd = container_of(ccd, struct nfsd4_readdir, common); |
3785 | struct xdr_stream *xdr = cd->xdr; |
3786 | int start_offset = xdr->buf->len; |
3787 | int cookie_offset; |
3788 | u32 name_and_cookie; |
3789 | int entry_bytes; |
3790 | __be32 nfserr = nfserr_toosmall; |
3791 | |
3792 | /* In nfsv4, "." and ".." never make it onto the wire.. */ |
3793 | if (name && isdotent(name, namlen)) { |
3794 | cd->common.err = nfs_ok; |
3795 | return 0; |
3796 | } |
3797 | |
3798 | /* Encode the previous entry's cookie value */ |
3799 | nfsd4_encode_entry4_nfs_cookie4(readdir: cd, offset); |
3800 | |
3801 | if (xdr_stream_encode_item_present(xdr) != XDR_UNIT) |
3802 | goto fail; |
3803 | |
3804 | /* Reserve send buffer space for this entry's cookie value. */ |
3805 | cookie_offset = xdr->buf->len; |
3806 | if (nfsd4_encode_nfs_cookie4(xdr, OFFSET_MAX) != nfs_ok) |
3807 | goto fail; |
3808 | if (nfsd4_encode_component4(xdr, name, namlen) != nfs_ok) |
3809 | goto fail; |
3810 | nfserr = nfsd4_encode_entry4_fattr(cd, name, namlen); |
3811 | switch (nfserr) { |
3812 | case nfs_ok: |
3813 | break; |
3814 | case nfserr_resource: |
3815 | nfserr = nfserr_toosmall; |
3816 | goto fail; |
3817 | case nfserr_noent: |
3818 | xdr_truncate_encode(xdr, len: start_offset); |
3819 | goto skip_entry; |
3820 | case nfserr_jukebox: |
3821 | /* |
3822 | * The pseudoroot should only display dentries that lead to |
3823 | * exports. If we get EJUKEBOX here, then we can't tell whether |
3824 | * this entry should be included. Just fail the whole READDIR |
3825 | * with NFS4ERR_DELAY in that case, and hope that the situation |
3826 | * will resolve itself by the client's next attempt. |
3827 | */ |
3828 | if (cd->rd_fhp->fh_export->ex_flags & NFSEXP_V4ROOT) |
3829 | goto fail; |
3830 | fallthrough; |
3831 | default: |
3832 | /* |
3833 | * If the client requested the RDATTR_ERROR attribute, |
3834 | * we stuff the error code into this attribute |
3835 | * and continue. If this attribute was not requested, |
3836 | * then in accordance with the spec, we fail the |
3837 | * entire READDIR operation(!) |
3838 | */ |
3839 | if (!(cd->rd_bmval[0] & FATTR4_WORD0_RDATTR_ERROR)) |
3840 | goto fail; |
3841 | if (nfsd4_encode_entry4_rdattr_error(xdr, nfserr)) { |
3842 | nfserr = nfserr_toosmall; |
3843 | goto fail; |
3844 | } |
3845 | } |
3846 | nfserr = nfserr_toosmall; |
3847 | entry_bytes = xdr->buf->len - start_offset; |
3848 | if (entry_bytes > cd->rd_maxcount) |
3849 | goto fail; |
3850 | cd->rd_maxcount -= entry_bytes; |
3851 | /* |
3852 | * RFC 3530 14.2.24 describes rd_dircount as only a "hint", and |
3853 | * notes that it could be zero. If it is zero, then the server |
3854 | * should enforce only the rd_maxcount value. |
3855 | */ |
3856 | if (cd->rd_dircount) { |
3857 | name_and_cookie = 4 + 4 * XDR_QUADLEN(namlen) + 8; |
3858 | if (name_and_cookie > cd->rd_dircount && cd->cookie_offset) |
3859 | goto fail; |
3860 | cd->rd_dircount -= min(cd->rd_dircount, name_and_cookie); |
3861 | if (!cd->rd_dircount) |
3862 | cd->rd_maxcount = 0; |
3863 | } |
3864 | |
3865 | cd->cookie_offset = cookie_offset; |
3866 | skip_entry: |
3867 | cd->common.err = nfs_ok; |
3868 | return 0; |
3869 | fail: |
3870 | xdr_truncate_encode(xdr, len: start_offset); |
3871 | cd->common.err = nfserr; |
3872 | return -EINVAL; |
3873 | } |
3874 | |
3875 | static __be32 |
3876 | nfsd4_encode_verifier4(struct xdr_stream *xdr, const nfs4_verifier *verf) |
3877 | { |
3878 | __be32 *p; |
3879 | |
3880 | p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE); |
3881 | if (!p) |
3882 | return nfserr_resource; |
3883 | memcpy(p, verf->data, sizeof(verf->data)); |
3884 | return nfs_ok; |
3885 | } |
3886 | |
3887 | static __be32 |
3888 | nfsd4_encode_clientid4(struct xdr_stream *xdr, const clientid_t *clientid) |
3889 | { |
3890 | __be32 *p; |
3891 | |
3892 | p = xdr_reserve_space(xdr, nbytes: sizeof(__be64)); |
3893 | if (!p) |
3894 | return nfserr_resource; |
3895 | memcpy(p, clientid, sizeof(*clientid)); |
3896 | return nfs_ok; |
3897 | } |
3898 | |
3899 | /* This is a frequently-encoded item; open-coded for speed */ |
3900 | static __be32 |
3901 | nfsd4_encode_stateid4(struct xdr_stream *xdr, const stateid_t *sid) |
3902 | { |
3903 | __be32 *p; |
3904 | |
3905 | p = xdr_reserve_space(xdr, NFS4_STATEID_SIZE); |
3906 | if (!p) |
3907 | return nfserr_resource; |
3908 | *p++ = cpu_to_be32(sid->si_generation); |
3909 | memcpy(p, &sid->si_opaque, sizeof(sid->si_opaque)); |
3910 | return nfs_ok; |
3911 | } |
3912 | |
3913 | static __be32 |
3914 | nfsd4_encode_sessionid4(struct xdr_stream *xdr, |
3915 | const struct nfs4_sessionid *sessionid) |
3916 | { |
3917 | return nfsd4_encode_opaque_fixed(xdr, data: sessionid->data, |
3918 | NFS4_MAX_SESSIONID_LEN); |
3919 | } |
3920 | |
3921 | static __be32 |
3922 | nfsd4_encode_access(struct nfsd4_compoundres *resp, __be32 nfserr, |
3923 | union nfsd4_op_u *u) |
3924 | { |
3925 | struct nfsd4_access *access = &u->access; |
3926 | struct xdr_stream *xdr = resp->xdr; |
3927 | __be32 status; |
3928 | |
3929 | /* supported */ |
3930 | status = nfsd4_encode_uint32_t(xdr, val: access->ac_supported); |
3931 | if (status != nfs_ok) |
3932 | return status; |
3933 | /* access */ |
3934 | return nfsd4_encode_uint32_t(xdr, val: access->ac_resp_access); |
3935 | } |
3936 | |
3937 | static __be32 nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres *resp, __be32 nfserr, |
3938 | union nfsd4_op_u *u) |
3939 | { |
3940 | struct nfsd4_bind_conn_to_session *bcts = &u->bind_conn_to_session; |
3941 | struct xdr_stream *xdr = resp->xdr; |
3942 | |
3943 | /* bctsr_sessid */ |
3944 | nfserr = nfsd4_encode_sessionid4(xdr, sessionid: &bcts->sessionid); |
3945 | if (nfserr != nfs_ok) |
3946 | return nfserr; |
3947 | /* bctsr_dir */ |
3948 | if (xdr_stream_encode_u32(xdr, n: bcts->dir) != XDR_UNIT) |
3949 | return nfserr_resource; |
3950 | /* bctsr_use_conn_in_rdma_mode */ |
3951 | return nfsd4_encode_bool(xdr, val: false); |
3952 | } |
3953 | |
3954 | static __be32 |
3955 | nfsd4_encode_close(struct nfsd4_compoundres *resp, __be32 nfserr, |
3956 | union nfsd4_op_u *u) |
3957 | { |
3958 | struct nfsd4_close *close = &u->close; |
3959 | struct xdr_stream *xdr = resp->xdr; |
3960 | |
3961 | /* open_stateid */ |
3962 | return nfsd4_encode_stateid4(xdr, sid: &close->cl_stateid); |
3963 | } |
3964 | |
3965 | |
3966 | static __be32 |
3967 | nfsd4_encode_commit(struct nfsd4_compoundres *resp, __be32 nfserr, |
3968 | union nfsd4_op_u *u) |
3969 | { |
3970 | struct nfsd4_commit *commit = &u->commit; |
3971 | |
3972 | return nfsd4_encode_verifier4(xdr: resp->xdr, verf: &commit->co_verf); |
3973 | } |
3974 | |
3975 | static __be32 |
3976 | nfsd4_encode_create(struct nfsd4_compoundres *resp, __be32 nfserr, |
3977 | union nfsd4_op_u *u) |
3978 | { |
3979 | struct nfsd4_create *create = &u->create; |
3980 | struct xdr_stream *xdr = resp->xdr; |
3981 | |
3982 | /* cinfo */ |
3983 | nfserr = nfsd4_encode_change_info4(xdr, c: &create->cr_cinfo); |
3984 | if (nfserr) |
3985 | return nfserr; |
3986 | /* attrset */ |
3987 | return nfsd4_encode_bitmap4(xdr, bmval0: create->cr_bmval[0], |
3988 | bmval1: create->cr_bmval[1], bmval2: create->cr_bmval[2]); |
3989 | } |
3990 | |
3991 | static __be32 |
3992 | nfsd4_encode_getattr(struct nfsd4_compoundres *resp, __be32 nfserr, |
3993 | union nfsd4_op_u *u) |
3994 | { |
3995 | struct nfsd4_getattr *getattr = &u->getattr; |
3996 | struct svc_fh *fhp = getattr->ga_fhp; |
3997 | struct xdr_stream *xdr = resp->xdr; |
3998 | |
3999 | /* obj_attributes */ |
4000 | return nfsd4_encode_fattr4(rqstp: resp->rqstp, xdr, fhp, exp: fhp->fh_export, |
4001 | dentry: fhp->fh_dentry, bmval: getattr->ga_bmval, ignore_crossmnt: 0); |
4002 | } |
4003 | |
4004 | static __be32 |
4005 | nfsd4_encode_getfh(struct nfsd4_compoundres *resp, __be32 nfserr, |
4006 | union nfsd4_op_u *u) |
4007 | { |
4008 | struct xdr_stream *xdr = resp->xdr; |
4009 | struct svc_fh *fhp = u->getfh; |
4010 | |
4011 | /* object */ |
4012 | return nfsd4_encode_nfs_fh4(xdr, fh_handle: &fhp->fh_handle); |
4013 | } |
4014 | |
4015 | static __be32 |
4016 | nfsd4_encode_lock_owner4(struct xdr_stream *xdr, const clientid_t *clientid, |
4017 | const struct xdr_netobj *owner) |
4018 | { |
4019 | __be32 status; |
4020 | |
4021 | /* clientid */ |
4022 | status = nfsd4_encode_clientid4(xdr, clientid); |
4023 | if (status != nfs_ok) |
4024 | return status; |
4025 | /* owner */ |
4026 | return nfsd4_encode_opaque(xdr, data: owner->data, size: owner->len); |
4027 | } |
4028 | |
4029 | static __be32 |
4030 | nfsd4_encode_lock4denied(struct xdr_stream *xdr, |
4031 | const struct nfsd4_lock_denied *ld) |
4032 | { |
4033 | __be32 status; |
4034 | |
4035 | /* offset */ |
4036 | status = nfsd4_encode_offset4(xdr, ld->ld_start); |
4037 | if (status != nfs_ok) |
4038 | return status; |
4039 | /* length */ |
4040 | status = nfsd4_encode_length4(xdr, ld->ld_length); |
4041 | if (status != nfs_ok) |
4042 | return status; |
4043 | /* locktype */ |
4044 | if (xdr_stream_encode_u32(xdr, n: ld->ld_type) != XDR_UNIT) |
4045 | return nfserr_resource; |
4046 | /* owner */ |
4047 | return nfsd4_encode_lock_owner4(xdr, clientid: &ld->ld_clientid, |
4048 | owner: &ld->ld_owner); |
4049 | } |
4050 | |
4051 | static __be32 |
4052 | nfsd4_encode_lock(struct nfsd4_compoundres *resp, __be32 nfserr, |
4053 | union nfsd4_op_u *u) |
4054 | { |
4055 | struct nfsd4_lock *lock = &u->lock; |
4056 | struct xdr_stream *xdr = resp->xdr; |
4057 | __be32 status; |
4058 | |
4059 | switch (nfserr) { |
4060 | case nfs_ok: |
4061 | /* resok4 */ |
4062 | status = nfsd4_encode_stateid4(xdr, sid: &lock->lk_resp_stateid); |
4063 | break; |
4064 | case nfserr_denied: |
4065 | /* denied */ |
4066 | status = nfsd4_encode_lock4denied(xdr, ld: &lock->lk_denied); |
4067 | break; |
4068 | default: |
4069 | return nfserr; |
4070 | } |
4071 | return status != nfs_ok ? status : nfserr; |
4072 | } |
4073 | |
4074 | static __be32 |
4075 | nfsd4_encode_lockt(struct nfsd4_compoundres *resp, __be32 nfserr, |
4076 | union nfsd4_op_u *u) |
4077 | { |
4078 | struct nfsd4_lockt *lockt = &u->lockt; |
4079 | struct xdr_stream *xdr = resp->xdr; |
4080 | __be32 status; |
4081 | |
4082 | if (nfserr == nfserr_denied) { |
4083 | /* denied */ |
4084 | status = nfsd4_encode_lock4denied(xdr, ld: &lockt->lt_denied); |
4085 | if (status != nfs_ok) |
4086 | return status; |
4087 | } |
4088 | return nfserr; |
4089 | } |
4090 | |
4091 | static __be32 |
4092 | nfsd4_encode_locku(struct nfsd4_compoundres *resp, __be32 nfserr, |
4093 | union nfsd4_op_u *u) |
4094 | { |
4095 | struct nfsd4_locku *locku = &u->locku; |
4096 | struct xdr_stream *xdr = resp->xdr; |
4097 | |
4098 | /* lock_stateid */ |
4099 | return nfsd4_encode_stateid4(xdr, sid: &locku->lu_stateid); |
4100 | } |
4101 | |
4102 | |
4103 | static __be32 |
4104 | nfsd4_encode_link(struct nfsd4_compoundres *resp, __be32 nfserr, |
4105 | union nfsd4_op_u *u) |
4106 | { |
4107 | struct nfsd4_link *link = &u->link; |
4108 | struct xdr_stream *xdr = resp->xdr; |
4109 | |
4110 | return nfsd4_encode_change_info4(xdr, c: &link->li_cinfo); |
4111 | } |
4112 | |
4113 | /* |
4114 | * This implementation does not yet support returning an ACE in an |
4115 | * OPEN that offers a delegation. |
4116 | */ |
4117 | static __be32 |
4118 | nfsd4_encode_open_nfsace4(struct xdr_stream *xdr) |
4119 | { |
4120 | __be32 status; |
4121 | |
4122 | /* type */ |
4123 | status = nfsd4_encode_acetype4(xdr, NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE); |
4124 | if (status != nfs_ok) |
4125 | return nfserr_resource; |
4126 | /* flag */ |
4127 | status = nfsd4_encode_aceflag4(xdr, 0); |
4128 | if (status != nfs_ok) |
4129 | return nfserr_resource; |
4130 | /* access mask */ |
4131 | status = nfsd4_encode_acemask4(xdr, 0); |
4132 | if (status != nfs_ok) |
4133 | return nfserr_resource; |
4134 | /* who - empty for now */ |
4135 | if (xdr_stream_encode_u32(xdr, n: 0) != XDR_UNIT) |
4136 | return nfserr_resource; |
4137 | return nfs_ok; |
4138 | } |
4139 | |
4140 | static __be32 |
4141 | nfsd4_encode_open_read_delegation4(struct xdr_stream *xdr, struct nfsd4_open *open) |
4142 | { |
4143 | __be32 status; |
4144 | |
4145 | /* stateid */ |
4146 | status = nfsd4_encode_stateid4(xdr, sid: &open->op_delegate_stateid); |
4147 | if (status != nfs_ok) |
4148 | return status; |
4149 | /* recall */ |
4150 | status = nfsd4_encode_bool(xdr, val: open->op_recall); |
4151 | if (status != nfs_ok) |
4152 | return status; |
4153 | /* permissions */ |
4154 | return nfsd4_encode_open_nfsace4(xdr); |
4155 | } |
4156 | |
4157 | static __be32 |
4158 | nfsd4_encode_nfs_space_limit4(struct xdr_stream *xdr, u64 filesize) |
4159 | { |
4160 | /* limitby */ |
4161 | if (xdr_stream_encode_u32(xdr, n: NFS4_LIMIT_SIZE) != XDR_UNIT) |
4162 | return nfserr_resource; |
4163 | /* filesize */ |
4164 | return nfsd4_encode_uint64_t(xdr, val: filesize); |
4165 | } |
4166 | |
4167 | static __be32 |
4168 | nfsd4_encode_open_write_delegation4(struct xdr_stream *xdr, |
4169 | struct nfsd4_open *open) |
4170 | { |
4171 | __be32 status; |
4172 | |
4173 | /* stateid */ |
4174 | status = nfsd4_encode_stateid4(xdr, sid: &open->op_delegate_stateid); |
4175 | if (status != nfs_ok) |
4176 | return status; |
4177 | /* recall */ |
4178 | status = nfsd4_encode_bool(xdr, val: open->op_recall); |
4179 | if (status != nfs_ok) |
4180 | return status; |
4181 | /* space_limit */ |
4182 | status = nfsd4_encode_nfs_space_limit4(xdr, filesize: 0); |
4183 | if (status != nfs_ok) |
4184 | return status; |
4185 | return nfsd4_encode_open_nfsace4(xdr); |
4186 | } |
4187 | |
4188 | static __be32 |
4189 | nfsd4_encode_open_none_delegation4(struct xdr_stream *xdr, |
4190 | struct nfsd4_open *open) |
4191 | { |
4192 | __be32 status = nfs_ok; |
4193 | |
4194 | /* ond_why */ |
4195 | if (xdr_stream_encode_u32(xdr, n: open->op_why_no_deleg) != XDR_UNIT) |
4196 | return nfserr_resource; |
4197 | switch (open->op_why_no_deleg) { |
4198 | case WND4_CONTENTION: |
4199 | /* ond_server_will_push_deleg */ |
4200 | status = nfsd4_encode_bool(xdr, val: false); |
4201 | break; |
4202 | case WND4_RESOURCE: |
4203 | /* ond_server_will_signal_avail */ |
4204 | status = nfsd4_encode_bool(xdr, val: false); |
4205 | } |
4206 | return status; |
4207 | } |
4208 | |
4209 | static __be32 |
4210 | nfsd4_encode_open_delegation4(struct xdr_stream *xdr, struct nfsd4_open *open) |
4211 | { |
4212 | __be32 status; |
4213 | |
4214 | /* delegation_type */ |
4215 | if (xdr_stream_encode_u32(xdr, n: open->op_delegate_type) != XDR_UNIT) |
4216 | return nfserr_resource; |
4217 | switch (open->op_delegate_type) { |
4218 | case NFS4_OPEN_DELEGATE_NONE: |
4219 | status = nfs_ok; |
4220 | break; |
4221 | case NFS4_OPEN_DELEGATE_READ: |
4222 | /* read */ |
4223 | status = nfsd4_encode_open_read_delegation4(xdr, open); |
4224 | break; |
4225 | case NFS4_OPEN_DELEGATE_WRITE: |
4226 | /* write */ |
4227 | status = nfsd4_encode_open_write_delegation4(xdr, open); |
4228 | break; |
4229 | case NFS4_OPEN_DELEGATE_NONE_EXT: |
4230 | /* od_whynone */ |
4231 | status = nfsd4_encode_open_none_delegation4(xdr, open); |
4232 | break; |
4233 | default: |
4234 | status = nfserr_serverfault; |
4235 | } |
4236 | |
4237 | return status; |
4238 | } |
4239 | |
4240 | static __be32 |
4241 | nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr, |
4242 | union nfsd4_op_u *u) |
4243 | { |
4244 | struct nfsd4_open *open = &u->open; |
4245 | struct xdr_stream *xdr = resp->xdr; |
4246 | |
4247 | /* stateid */ |
4248 | nfserr = nfsd4_encode_stateid4(xdr, sid: &open->op_stateid); |
4249 | if (nfserr != nfs_ok) |
4250 | return nfserr; |
4251 | /* cinfo */ |
4252 | nfserr = nfsd4_encode_change_info4(xdr, c: &open->op_cinfo); |
4253 | if (nfserr != nfs_ok) |
4254 | return nfserr; |
4255 | /* rflags */ |
4256 | nfserr = nfsd4_encode_uint32_t(xdr, val: open->op_rflags); |
4257 | if (nfserr != nfs_ok) |
4258 | return nfserr; |
4259 | /* attrset */ |
4260 | nfserr = nfsd4_encode_bitmap4(xdr, bmval0: open->op_bmval[0], |
4261 | bmval1: open->op_bmval[1], bmval2: open->op_bmval[2]); |
4262 | if (nfserr != nfs_ok) |
4263 | return nfserr; |
4264 | /* delegation */ |
4265 | return nfsd4_encode_open_delegation4(xdr, open); |
4266 | } |
4267 | |
4268 | static __be32 |
4269 | nfsd4_encode_open_confirm(struct nfsd4_compoundres *resp, __be32 nfserr, |
4270 | union nfsd4_op_u *u) |
4271 | { |
4272 | struct nfsd4_open_confirm *oc = &u->open_confirm; |
4273 | struct xdr_stream *xdr = resp->xdr; |
4274 | |
4275 | /* open_stateid */ |
4276 | return nfsd4_encode_stateid4(xdr, sid: &oc->oc_resp_stateid); |
4277 | } |
4278 | |
4279 | static __be32 |
4280 | nfsd4_encode_open_downgrade(struct nfsd4_compoundres *resp, __be32 nfserr, |
4281 | union nfsd4_op_u *u) |
4282 | { |
4283 | struct nfsd4_open_downgrade *od = &u->open_downgrade; |
4284 | struct xdr_stream *xdr = resp->xdr; |
4285 | |
4286 | /* open_stateid */ |
4287 | return nfsd4_encode_stateid4(xdr, sid: &od->od_stateid); |
4288 | } |
4289 | |
4290 | /* |
4291 | * The operation of this function assumes that this is the only |
4292 | * READ operation in the COMPOUND. If there are multiple READs, |
4293 | * we use nfsd4_encode_readv(). |
4294 | */ |
4295 | static __be32 nfsd4_encode_splice_read( |
4296 | struct nfsd4_compoundres *resp, |
4297 | struct nfsd4_read *read, |
4298 | struct file *file, unsigned long maxcount) |
4299 | { |
4300 | struct xdr_stream *xdr = resp->xdr; |
4301 | struct xdr_buf *buf = xdr->buf; |
4302 | int status, space_left; |
4303 | __be32 nfserr; |
4304 | |
4305 | /* |
4306 | * Make sure there is room at the end of buf->head for |
4307 | * svcxdr_encode_opaque_pages() to create a tail buffer |
4308 | * to XDR-pad the payload. |
4309 | */ |
4310 | if (xdr->iov != xdr->buf->head || xdr->end - xdr->p < 1) |
4311 | return nfserr_resource; |
4312 | |
4313 | nfserr = nfsd_splice_read(rqstp: read->rd_rqstp, fhp: read->rd_fhp, |
4314 | file, offset: read->rd_offset, count: &maxcount, |
4315 | eof: &read->rd_eof); |
4316 | read->rd_length = maxcount; |
4317 | if (nfserr) |
4318 | goto out_err; |
4319 | svcxdr_encode_opaque_pages(rqstp: read->rd_rqstp, xdr, pages: buf->pages, |
4320 | base: buf->page_base, len: maxcount); |
4321 | status = svc_encode_result_payload(rqstp: read->rd_rqstp, |
4322 | offset: buf->head[0].iov_len, length: maxcount); |
4323 | if (status) { |
4324 | nfserr = nfserrno(errno: status); |
4325 | goto out_err; |
4326 | } |
4327 | |
4328 | /* |
4329 | * Prepare to encode subsequent operations. |
4330 | * |
4331 | * xdr_truncate_encode() is not safe to use after a successful |
4332 | * splice read has been done, so the following stream |
4333 | * manipulations are open-coded. |
4334 | */ |
4335 | space_left = min_t(int, (void *)xdr->end - (void *)xdr->p, |
4336 | buf->buflen - buf->len); |
4337 | buf->buflen = buf->len + space_left; |
4338 | xdr->end = (__be32 *)((void *)xdr->end + space_left); |
4339 | |
4340 | return nfs_ok; |
4341 | |
4342 | out_err: |
4343 | /* |
4344 | * nfsd_splice_actor may have already messed with the |
4345 | * page length; reset it so as not to confuse |
4346 | * xdr_truncate_encode in our caller. |
4347 | */ |
4348 | buf->page_len = 0; |
4349 | return nfserr; |
4350 | } |
4351 | |
4352 | static __be32 nfsd4_encode_readv(struct nfsd4_compoundres *resp, |
4353 | struct nfsd4_read *read, |
4354 | struct file *file, unsigned long maxcount) |
4355 | { |
4356 | struct xdr_stream *xdr = resp->xdr; |
4357 | unsigned int base = xdr->buf->page_len & ~PAGE_MASK; |
4358 | unsigned int starting_len = xdr->buf->len; |
4359 | __be32 zero = xdr_zero; |
4360 | __be32 nfserr; |
4361 | |
4362 | if (xdr_reserve_space_vec(xdr, nbytes: maxcount) < 0) |
4363 | return nfserr_resource; |
4364 | |
4365 | nfserr = nfsd_iter_read(rqstp: resp->rqstp, fhp: read->rd_fhp, file, |
4366 | offset: read->rd_offset, count: &maxcount, base, |
4367 | eof: &read->rd_eof); |
4368 | read->rd_length = maxcount; |
4369 | if (nfserr) |
4370 | return nfserr; |
4371 | if (svc_encode_result_payload(rqstp: resp->rqstp, offset: starting_len, length: maxcount)) |
4372 | return nfserr_io; |
4373 | xdr_truncate_encode(xdr, len: starting_len + xdr_align_size(n: maxcount)); |
4374 | |
4375 | write_bytes_to_xdr_buf(xdr->buf, starting_len + maxcount, &zero, |
4376 | xdr_pad_size(n: maxcount)); |
4377 | return nfs_ok; |
4378 | } |
4379 | |
4380 | static __be32 |
4381 | nfsd4_encode_read(struct nfsd4_compoundres *resp, __be32 nfserr, |
4382 | union nfsd4_op_u *u) |
4383 | { |
4384 | struct nfsd4_compoundargs *argp = resp->rqstp->rq_argp; |
4385 | struct nfsd4_read *read = &u->read; |
4386 | struct xdr_stream *xdr = resp->xdr; |
4387 | int starting_len = xdr->buf->len; |
4388 | bool splice_ok = argp->splice_ok; |
4389 | unsigned long maxcount; |
4390 | struct file *file; |
4391 | __be32 *p; |
4392 | |
4393 | if (nfserr) |
4394 | return nfserr; |
4395 | file = read->rd_nf->nf_file; |
4396 | |
4397 | p = xdr_reserve_space(xdr, nbytes: 8); /* eof flag and byte count */ |
4398 | if (!p) { |
4399 | WARN_ON_ONCE(splice_ok); |
4400 | return nfserr_resource; |
4401 | } |
4402 | if (resp->xdr->buf->page_len && splice_ok) { |
4403 | WARN_ON_ONCE(1); |
4404 | return nfserr_serverfault; |
4405 | } |
4406 | xdr_commit_encode(xdr); |
4407 | |
4408 | maxcount = min_t(unsigned long, read->rd_length, |
4409 | (xdr->buf->buflen - xdr->buf->len)); |
4410 | |
4411 | if (file->f_op->splice_read && splice_ok) |
4412 | nfserr = nfsd4_encode_splice_read(resp, read, file, maxcount); |
4413 | else |
4414 | nfserr = nfsd4_encode_readv(resp, read, file, maxcount); |
4415 | if (nfserr) { |
4416 | xdr_truncate_encode(xdr, len: starting_len); |
4417 | return nfserr; |
4418 | } |
4419 | |
4420 | p = xdr_encode_bool(p, n: read->rd_eof); |
4421 | *p = cpu_to_be32(read->rd_length); |
4422 | return nfs_ok; |
4423 | } |
4424 | |
4425 | static __be32 |
4426 | nfsd4_encode_readlink(struct nfsd4_compoundres *resp, __be32 nfserr, |
4427 | union nfsd4_op_u *u) |
4428 | { |
4429 | struct nfsd4_readlink *readlink = &u->readlink; |
4430 | __be32 *p, *maxcount_p, zero = xdr_zero; |
4431 | struct xdr_stream *xdr = resp->xdr; |
4432 | int length_offset = xdr->buf->len; |
4433 | int maxcount, status; |
4434 | |
4435 | maxcount_p = xdr_reserve_space(xdr, XDR_UNIT); |
4436 | if (!maxcount_p) |
4437 | return nfserr_resource; |
4438 | maxcount = PAGE_SIZE; |
4439 | |
4440 | p = xdr_reserve_space(xdr, nbytes: maxcount); |
4441 | if (!p) |
4442 | return nfserr_resource; |
4443 | /* |
4444 | * XXX: By default, vfs_readlink() will truncate symlinks if they |
4445 | * would overflow the buffer. Is this kosher in NFSv4? If not, one |
4446 | * easy fix is: if vfs_readlink() precisely fills the buffer, assume |
4447 | * that truncation occurred, and return NFS4ERR_RESOURCE. |
4448 | */ |
4449 | nfserr = nfsd_readlink(readlink->rl_rqstp, readlink->rl_fhp, |
4450 | (char *)p, &maxcount); |
4451 | if (nfserr == nfserr_isdir) |
4452 | nfserr = nfserr_inval; |
4453 | if (nfserr) |
4454 | goto out_err; |
4455 | status = svc_encode_result_payload(rqstp: readlink->rl_rqstp, offset: length_offset, |
4456 | length: maxcount); |
4457 | if (status) { |
4458 | nfserr = nfserrno(errno: status); |
4459 | goto out_err; |
4460 | } |
4461 | *maxcount_p = cpu_to_be32(maxcount); |
4462 | xdr_truncate_encode(xdr, len: length_offset + 4 + xdr_align_size(n: maxcount)); |
4463 | write_bytes_to_xdr_buf(xdr->buf, length_offset + 4 + maxcount, &zero, |
4464 | xdr_pad_size(n: maxcount)); |
4465 | return nfs_ok; |
4466 | |
4467 | out_err: |
4468 | xdr_truncate_encode(xdr, len: length_offset); |
4469 | return nfserr; |
4470 | } |
4471 | |
4472 | static __be32 nfsd4_encode_dirlist4(struct xdr_stream *xdr, |
4473 | struct nfsd4_readdir *readdir, |
4474 | u32 max_payload) |
4475 | { |
4476 | int bytes_left, maxcount, starting_len = xdr->buf->len; |
4477 | loff_t offset; |
4478 | __be32 status; |
4479 | |
4480 | /* |
4481 | * Number of bytes left for directory entries allowing for the |
4482 | * final 8 bytes of the readdir and a following failed op. |
4483 | */ |
4484 | bytes_left = xdr->buf->buflen - xdr->buf->len - |
4485 | COMPOUND_ERR_SLACK_SPACE - XDR_UNIT * 2; |
4486 | if (bytes_left < 0) |
4487 | return nfserr_resource; |
4488 | maxcount = min_t(u32, readdir->rd_maxcount, max_payload); |
4489 | |
4490 | /* |
4491 | * The RFC defines rd_maxcount as the size of the |
4492 | * READDIR4resok structure, which includes the verifier |
4493 | * and the 8 bytes encoded at the end of this function. |
4494 | */ |
4495 | if (maxcount < XDR_UNIT * 4) |
4496 | return nfserr_toosmall; |
4497 | maxcount = min_t(int, maxcount - XDR_UNIT * 4, bytes_left); |
4498 | |
4499 | /* RFC 3530 14.2.24 allows us to ignore dircount when it's 0 */ |
4500 | if (!readdir->rd_dircount) |
4501 | readdir->rd_dircount = max_payload; |
4502 | |
4503 | /* *entries */ |
4504 | readdir->xdr = xdr; |
4505 | readdir->rd_maxcount = maxcount; |
4506 | readdir->common.err = 0; |
4507 | readdir->cookie_offset = 0; |
4508 | offset = readdir->rd_cookie; |
4509 | status = nfsd_readdir(readdir->rd_rqstp, readdir->rd_fhp, &offset, |
4510 | &readdir->common, nfsd4_encode_entry4); |
4511 | if (status) |
4512 | return status; |
4513 | if (readdir->common.err == nfserr_toosmall && |
4514 | xdr->buf->len == starting_len) { |
4515 | /* No entries were encoded. Which limit did we hit? */ |
4516 | if (maxcount - XDR_UNIT * 4 < bytes_left) |
4517 | /* It was the fault of rd_maxcount */ |
4518 | return nfserr_toosmall; |
4519 | /* We ran out of buffer space */ |
4520 | return nfserr_resource; |
4521 | } |
4522 | /* Encode the final entry's cookie value */ |
4523 | nfsd4_encode_entry4_nfs_cookie4(readdir, offset); |
4524 | /* No entries follow */ |
4525 | if (xdr_stream_encode_item_absent(xdr) != XDR_UNIT) |
4526 | return nfserr_resource; |
4527 | |
4528 | /* eof */ |
4529 | return nfsd4_encode_bool(xdr, val: readdir->common.err == nfserr_eof); |
4530 | } |
4531 | |
4532 | static __be32 |
4533 | nfsd4_encode_readdir(struct nfsd4_compoundres *resp, __be32 nfserr, |
4534 | union nfsd4_op_u *u) |
4535 | { |
4536 | struct nfsd4_readdir *readdir = &u->readdir; |
4537 | struct xdr_stream *xdr = resp->xdr; |
4538 | int starting_len = xdr->buf->len; |
4539 | |
4540 | /* cookieverf */ |
4541 | nfserr = nfsd4_encode_verifier4(xdr, verf: &readdir->rd_verf); |
4542 | if (nfserr != nfs_ok) |
4543 | return nfserr; |
4544 | |
4545 | /* reply */ |
4546 | nfserr = nfsd4_encode_dirlist4(xdr, readdir, max_payload: svc_max_payload(rqstp: resp->rqstp)); |
4547 | if (nfserr != nfs_ok) |
4548 | xdr_truncate_encode(xdr, len: starting_len); |
4549 | return nfserr; |
4550 | } |
4551 | |
4552 | static __be32 |
4553 | nfsd4_encode_remove(struct nfsd4_compoundres *resp, __be32 nfserr, |
4554 | union nfsd4_op_u *u) |
4555 | { |
4556 | struct nfsd4_remove *remove = &u->remove; |
4557 | struct xdr_stream *xdr = resp->xdr; |
4558 | |
4559 | return nfsd4_encode_change_info4(xdr, c: &remove->rm_cinfo); |
4560 | } |
4561 | |
4562 | static __be32 |
4563 | nfsd4_encode_rename(struct nfsd4_compoundres *resp, __be32 nfserr, |
4564 | union nfsd4_op_u *u) |
4565 | { |
4566 | struct nfsd4_rename *rename = &u->rename; |
4567 | struct xdr_stream *xdr = resp->xdr; |
4568 | |
4569 | nfserr = nfsd4_encode_change_info4(xdr, c: &rename->rn_sinfo); |
4570 | if (nfserr) |
4571 | return nfserr; |
4572 | return nfsd4_encode_change_info4(xdr, c: &rename->rn_tinfo); |
4573 | } |
4574 | |
4575 | static __be32 |
4576 | nfsd4_encode_rpcsec_gss_info(struct xdr_stream *xdr, |
4577 | struct rpcsec_gss_info *info) |
4578 | { |
4579 | __be32 status; |
4580 | |
4581 | /* oid */ |
4582 | if (xdr_stream_encode_opaque(xdr, ptr: info->oid.data, len: info->oid.len) < 0) |
4583 | return nfserr_resource; |
4584 | /* qop */ |
4585 | status = nfsd4_encode_qop4(xdr, info->qop); |
4586 | if (status != nfs_ok) |
4587 | return status; |
4588 | /* service */ |
4589 | if (xdr_stream_encode_u32(xdr, n: info->service) != XDR_UNIT) |
4590 | return nfserr_resource; |
4591 | |
4592 | return nfs_ok; |
4593 | } |
4594 | |
4595 | static __be32 |
4596 | nfsd4_do_encode_secinfo(struct xdr_stream *xdr, struct svc_export *exp) |
4597 | { |
4598 | u32 i, nflavs, supported; |
4599 | struct exp_flavor_info *flavs; |
4600 | struct exp_flavor_info def_flavs[2]; |
4601 | static bool report = true; |
4602 | __be32 *flavorsp; |
4603 | __be32 status; |
4604 | |
4605 | if (exp->ex_nflavors) { |
4606 | flavs = exp->ex_flavors; |
4607 | nflavs = exp->ex_nflavors; |
4608 | } else { /* Handling of some defaults in absence of real secinfo: */ |
4609 | flavs = def_flavs; |
4610 | if (exp->ex_client->flavour->flavour == RPC_AUTH_UNIX) { |
4611 | nflavs = 2; |
4612 | flavs[0].pseudoflavor = RPC_AUTH_UNIX; |
4613 | flavs[1].pseudoflavor = RPC_AUTH_NULL; |
4614 | } else if (exp->ex_client->flavour->flavour == RPC_AUTH_GSS) { |
4615 | nflavs = 1; |
4616 | flavs[0].pseudoflavor |
4617 | = svcauth_gss_flavor(dom: exp->ex_client); |
4618 | } else { |
4619 | nflavs = 1; |
4620 | flavs[0].pseudoflavor |
4621 | = exp->ex_client->flavour->flavour; |
4622 | } |
4623 | } |
4624 | |
4625 | supported = 0; |
4626 | flavorsp = xdr_reserve_space(xdr, XDR_UNIT); |
4627 | if (!flavorsp) |
4628 | return nfserr_resource; |
4629 | |
4630 | for (i = 0; i < nflavs; i++) { |
4631 | rpc_authflavor_t pf = flavs[i].pseudoflavor; |
4632 | struct rpcsec_gss_info info; |
4633 | |
4634 | if (rpcauth_get_gssinfo(pf, &info) == 0) { |
4635 | supported++; |
4636 | |
4637 | /* flavor */ |
4638 | status = nfsd4_encode_uint32_t(xdr, val: RPC_AUTH_GSS); |
4639 | if (status != nfs_ok) |
4640 | return status; |
4641 | /* flavor_info */ |
4642 | status = nfsd4_encode_rpcsec_gss_info(xdr, info: &info); |
4643 | if (status != nfs_ok) |
4644 | return status; |
4645 | } else if (pf < RPC_AUTH_MAXFLAVOR) { |
4646 | supported++; |
4647 | |
4648 | /* flavor */ |
4649 | status = nfsd4_encode_uint32_t(xdr, val: pf); |
4650 | if (status != nfs_ok) |
4651 | return status; |
4652 | } else { |
4653 | if (report) |
4654 | pr_warn("NFS: SECINFO: security flavor %u " |
4655 | "is not supported\n" , pf); |
4656 | } |
4657 | } |
4658 | |
4659 | if (nflavs != supported) |
4660 | report = false; |
4661 | *flavorsp = cpu_to_be32(supported); |
4662 | return 0; |
4663 | } |
4664 | |
4665 | static __be32 |
4666 | nfsd4_encode_secinfo(struct nfsd4_compoundres *resp, __be32 nfserr, |
4667 | union nfsd4_op_u *u) |
4668 | { |
4669 | struct nfsd4_secinfo *secinfo = &u->secinfo; |
4670 | struct xdr_stream *xdr = resp->xdr; |
4671 | |
4672 | return nfsd4_do_encode_secinfo(xdr, exp: secinfo->si_exp); |
4673 | } |
4674 | |
4675 | static __be32 |
4676 | nfsd4_encode_secinfo_no_name(struct nfsd4_compoundres *resp, __be32 nfserr, |
4677 | union nfsd4_op_u *u) |
4678 | { |
4679 | struct nfsd4_secinfo_no_name *secinfo = &u->secinfo_no_name; |
4680 | struct xdr_stream *xdr = resp->xdr; |
4681 | |
4682 | return nfsd4_do_encode_secinfo(xdr, exp: secinfo->sin_exp); |
4683 | } |
4684 | |
4685 | static __be32 |
4686 | nfsd4_encode_setattr(struct nfsd4_compoundres *resp, __be32 nfserr, |
4687 | union nfsd4_op_u *u) |
4688 | { |
4689 | struct nfsd4_setattr *setattr = &u->setattr; |
4690 | __be32 status; |
4691 | |
4692 | switch (nfserr) { |
4693 | case nfs_ok: |
4694 | /* attrsset */ |
4695 | status = nfsd4_encode_bitmap4(xdr: resp->xdr, bmval0: setattr->sa_bmval[0], |
4696 | bmval1: setattr->sa_bmval[1], |
4697 | bmval2: setattr->sa_bmval[2]); |
4698 | break; |
4699 | default: |
4700 | /* attrsset */ |
4701 | status = nfsd4_encode_bitmap4(xdr: resp->xdr, bmval0: 0, bmval1: 0, bmval2: 0); |
4702 | } |
4703 | return status != nfs_ok ? status : nfserr; |
4704 | } |
4705 | |
4706 | static __be32 |
4707 | nfsd4_encode_setclientid(struct nfsd4_compoundres *resp, __be32 nfserr, |
4708 | union nfsd4_op_u *u) |
4709 | { |
4710 | struct nfsd4_setclientid *scd = &u->setclientid; |
4711 | struct xdr_stream *xdr = resp->xdr; |
4712 | |
4713 | if (!nfserr) { |
4714 | nfserr = nfsd4_encode_clientid4(xdr, clientid: &scd->se_clientid); |
4715 | if (nfserr != nfs_ok) |
4716 | goto out; |
4717 | nfserr = nfsd4_encode_verifier4(xdr, verf: &scd->se_confirm); |
4718 | } else if (nfserr == nfserr_clid_inuse) { |
4719 | /* empty network id */ |
4720 | if (xdr_stream_encode_u32(xdr, n: 0) < 0) { |
4721 | nfserr = nfserr_resource; |
4722 | goto out; |
4723 | } |
4724 | /* empty universal address */ |
4725 | if (xdr_stream_encode_u32(xdr, n: 0) < 0) { |
4726 | nfserr = nfserr_resource; |
4727 | goto out; |
4728 | } |
4729 | } |
4730 | out: |
4731 | return nfserr; |
4732 | } |
4733 | |
4734 | static __be32 |
4735 | nfsd4_encode_write(struct nfsd4_compoundres *resp, __be32 nfserr, |
4736 | union nfsd4_op_u *u) |
4737 | { |
4738 | struct nfsd4_write *write = &u->write; |
4739 | struct xdr_stream *xdr = resp->xdr; |
4740 | |
4741 | /* count */ |
4742 | nfserr = nfsd4_encode_count4(xdr, write->wr_bytes_written); |
4743 | if (nfserr) |
4744 | return nfserr; |
4745 | /* committed */ |
4746 | if (xdr_stream_encode_u32(xdr, n: write->wr_how_written) != XDR_UNIT) |
4747 | return nfserr_resource; |
4748 | /* writeverf */ |
4749 | return nfsd4_encode_verifier4(xdr, verf: &write->wr_verifier); |
4750 | } |
4751 | |
4752 | static __be32 |
4753 | nfsd4_encode_state_protect_ops4(struct xdr_stream *xdr, |
4754 | struct nfsd4_exchange_id *exid) |
4755 | { |
4756 | __be32 status; |
4757 | |
4758 | /* spo_must_enforce */ |
4759 | status = nfsd4_encode_bitmap4(xdr, bmval0: exid->spo_must_enforce[0], |
4760 | bmval1: exid->spo_must_enforce[1], |
4761 | bmval2: exid->spo_must_enforce[2]); |
4762 | if (status != nfs_ok) |
4763 | return status; |
4764 | /* spo_must_allow */ |
4765 | return nfsd4_encode_bitmap4(xdr, bmval0: exid->spo_must_allow[0], |
4766 | bmval1: exid->spo_must_allow[1], |
4767 | bmval2: exid->spo_must_allow[2]); |
4768 | } |
4769 | |
4770 | static __be32 |
4771 | nfsd4_encode_state_protect4_r(struct xdr_stream *xdr, struct nfsd4_exchange_id *exid) |
4772 | { |
4773 | __be32 status; |
4774 | |
4775 | if (xdr_stream_encode_u32(xdr, n: exid->spa_how) != XDR_UNIT) |
4776 | return nfserr_resource; |
4777 | switch (exid->spa_how) { |
4778 | case SP4_NONE: |
4779 | status = nfs_ok; |
4780 | break; |
4781 | case SP4_MACH_CRED: |
4782 | /* spr_mach_ops */ |
4783 | status = nfsd4_encode_state_protect_ops4(xdr, exid); |
4784 | break; |
4785 | default: |
4786 | status = nfserr_serverfault; |
4787 | } |
4788 | return status; |
4789 | } |
4790 | |
4791 | static __be32 |
4792 | nfsd4_encode_server_owner4(struct xdr_stream *xdr, struct svc_rqst *rqstp) |
4793 | { |
4794 | struct nfsd_net *nn = net_generic(SVC_NET(rqstp), id: nfsd_net_id); |
4795 | __be32 status; |
4796 | |
4797 | /* so_minor_id */ |
4798 | status = nfsd4_encode_uint64_t(xdr, val: 0); |
4799 | if (status != nfs_ok) |
4800 | return status; |
4801 | /* so_major_id */ |
4802 | return nfsd4_encode_opaque(xdr, data: nn->nfsd_name, strlen(nn->nfsd_name)); |
4803 | } |
4804 | |
4805 | static __be32 |
4806 | nfsd4_encode_exchange_id(struct nfsd4_compoundres *resp, __be32 nfserr, |
4807 | union nfsd4_op_u *u) |
4808 | { |
4809 | struct nfsd_net *nn = net_generic(SVC_NET(resp->rqstp), id: nfsd_net_id); |
4810 | struct nfsd4_exchange_id *exid = &u->exchange_id; |
4811 | struct xdr_stream *xdr = resp->xdr; |
4812 | |
4813 | /* eir_clientid */ |
4814 | nfserr = nfsd4_encode_clientid4(xdr, clientid: &exid->clientid); |
4815 | if (nfserr != nfs_ok) |
4816 | return nfserr; |
4817 | /* eir_sequenceid */ |
4818 | nfserr = nfsd4_encode_sequenceid4(xdr, exid->seqid); |
4819 | if (nfserr != nfs_ok) |
4820 | return nfserr; |
4821 | /* eir_flags */ |
4822 | nfserr = nfsd4_encode_uint32_t(xdr, val: exid->flags); |
4823 | if (nfserr != nfs_ok) |
4824 | return nfserr; |
4825 | /* eir_state_protect */ |
4826 | nfserr = nfsd4_encode_state_protect4_r(xdr, exid); |
4827 | if (nfserr != nfs_ok) |
4828 | return nfserr; |
4829 | /* eir_server_owner */ |
4830 | nfserr = nfsd4_encode_server_owner4(xdr, rqstp: resp->rqstp); |
4831 | if (nfserr != nfs_ok) |
4832 | return nfserr; |
4833 | /* eir_server_scope */ |
4834 | nfserr = nfsd4_encode_opaque(xdr, data: nn->nfsd_name, |
4835 | strlen(nn->nfsd_name)); |
4836 | if (nfserr != nfs_ok) |
4837 | return nfserr; |
4838 | /* eir_server_impl_id<1> */ |
4839 | if (xdr_stream_encode_u32(xdr, n: 0) != XDR_UNIT) |
4840 | return nfserr_resource; |
4841 | |
4842 | return nfs_ok; |
4843 | } |
4844 | |
4845 | static __be32 |
4846 | nfsd4_encode_channel_attrs4(struct xdr_stream *xdr, |
4847 | const struct nfsd4_channel_attrs *attrs) |
4848 | { |
4849 | __be32 status; |
4850 | |
4851 | /* ca_headerpadsize */ |
4852 | status = nfsd4_encode_count4(xdr, 0); |
4853 | if (status != nfs_ok) |
4854 | return status; |
4855 | /* ca_maxrequestsize */ |
4856 | status = nfsd4_encode_count4(xdr, attrs->maxreq_sz); |
4857 | if (status != nfs_ok) |
4858 | return status; |
4859 | /* ca_maxresponsesize */ |
4860 | status = nfsd4_encode_count4(xdr, attrs->maxresp_sz); |
4861 | if (status != nfs_ok) |
4862 | return status; |
4863 | /* ca_maxresponsesize_cached */ |
4864 | status = nfsd4_encode_count4(xdr, attrs->maxresp_cached); |
4865 | if (status != nfs_ok) |
4866 | return status; |
4867 | /* ca_maxoperations */ |
4868 | status = nfsd4_encode_count4(xdr, attrs->maxops); |
4869 | if (status != nfs_ok) |
4870 | return status; |
4871 | /* ca_maxrequests */ |
4872 | status = nfsd4_encode_count4(xdr, attrs->maxreqs); |
4873 | if (status != nfs_ok) |
4874 | return status; |
4875 | /* ca_rdma_ird<1> */ |
4876 | if (xdr_stream_encode_u32(xdr, n: attrs->nr_rdma_attrs) != XDR_UNIT) |
4877 | return nfserr_resource; |
4878 | if (attrs->nr_rdma_attrs) |
4879 | return nfsd4_encode_uint32_t(xdr, val: attrs->rdma_attrs); |
4880 | return nfs_ok; |
4881 | } |
4882 | |
4883 | static __be32 |
4884 | nfsd4_encode_create_session(struct nfsd4_compoundres *resp, __be32 nfserr, |
4885 | union nfsd4_op_u *u) |
4886 | { |
4887 | struct nfsd4_create_session *sess = &u->create_session; |
4888 | struct xdr_stream *xdr = resp->xdr; |
4889 | |
4890 | /* csr_sessionid */ |
4891 | nfserr = nfsd4_encode_sessionid4(xdr, sessionid: &sess->sessionid); |
4892 | if (nfserr != nfs_ok) |
4893 | return nfserr; |
4894 | /* csr_sequence */ |
4895 | nfserr = nfsd4_encode_sequenceid4(xdr, sess->seqid); |
4896 | if (nfserr != nfs_ok) |
4897 | return nfserr; |
4898 | /* csr_flags */ |
4899 | nfserr = nfsd4_encode_uint32_t(xdr, val: sess->flags); |
4900 | if (nfserr != nfs_ok) |
4901 | return nfserr; |
4902 | /* csr_fore_chan_attrs */ |
4903 | nfserr = nfsd4_encode_channel_attrs4(xdr, attrs: &sess->fore_channel); |
4904 | if (nfserr != nfs_ok) |
4905 | return nfserr; |
4906 | /* csr_back_chan_attrs */ |
4907 | return nfsd4_encode_channel_attrs4(xdr, attrs: &sess->back_channel); |
4908 | } |
4909 | |
4910 | static __be32 |
4911 | nfsd4_encode_sequence(struct nfsd4_compoundres *resp, __be32 nfserr, |
4912 | union nfsd4_op_u *u) |
4913 | { |
4914 | struct nfsd4_sequence *seq = &u->sequence; |
4915 | struct xdr_stream *xdr = resp->xdr; |
4916 | |
4917 | /* sr_sessionid */ |
4918 | nfserr = nfsd4_encode_sessionid4(xdr, sessionid: &seq->sessionid); |
4919 | if (nfserr != nfs_ok) |
4920 | return nfserr; |
4921 | /* sr_sequenceid */ |
4922 | nfserr = nfsd4_encode_sequenceid4(xdr, seq->seqid); |
4923 | if (nfserr != nfs_ok) |
4924 | return nfserr; |
4925 | /* sr_slotid */ |
4926 | nfserr = nfsd4_encode_slotid4(xdr, seq->slotid); |
4927 | if (nfserr != nfs_ok) |
4928 | return nfserr; |
4929 | /* Note slotid's are numbered from zero: */ |
4930 | /* sr_highest_slotid */ |
4931 | nfserr = nfsd4_encode_slotid4(xdr, seq->maxslots - 1); |
4932 | if (nfserr != nfs_ok) |
4933 | return nfserr; |
4934 | /* sr_target_highest_slotid */ |
4935 | nfserr = nfsd4_encode_slotid4(xdr, seq->maxslots - 1); |
4936 | if (nfserr != nfs_ok) |
4937 | return nfserr; |
4938 | /* sr_status_flags */ |
4939 | nfserr = nfsd4_encode_uint32_t(xdr, val: seq->status_flags); |
4940 | if (nfserr != nfs_ok) |
4941 | return nfserr; |
4942 | |
4943 | resp->cstate.data_offset = xdr->buf->len; /* DRC cache data pointer */ |
4944 | return nfs_ok; |
4945 | } |
4946 | |
4947 | static __be32 |
4948 | nfsd4_encode_test_stateid(struct nfsd4_compoundres *resp, __be32 nfserr, |
4949 | union nfsd4_op_u *u) |
4950 | { |
4951 | struct nfsd4_test_stateid *test_stateid = &u->test_stateid; |
4952 | struct nfsd4_test_stateid_id *stateid, *next; |
4953 | struct xdr_stream *xdr = resp->xdr; |
4954 | |
4955 | /* tsr_status_codes<> */ |
4956 | if (xdr_stream_encode_u32(xdr, n: test_stateid->ts_num_ids) != XDR_UNIT) |
4957 | return nfserr_resource; |
4958 | list_for_each_entry_safe(stateid, next, |
4959 | &test_stateid->ts_stateid_list, ts_id_list) { |
4960 | if (xdr_stream_encode_be32(xdr, n: stateid->ts_id_status) != XDR_UNIT) |
4961 | return nfserr_resource; |
4962 | } |
4963 | return nfs_ok; |
4964 | } |
4965 | |
4966 | #ifdef CONFIG_NFSD_PNFS |
4967 | static __be32 |
4968 | nfsd4_encode_device_addr4(struct xdr_stream *xdr, |
4969 | const struct nfsd4_getdeviceinfo *gdev) |
4970 | { |
4971 | u32 needed_len, starting_len = xdr->buf->len; |
4972 | const struct nfsd4_layout_ops *ops; |
4973 | __be32 status; |
4974 | |
4975 | /* da_layout_type */ |
4976 | if (xdr_stream_encode_u32(xdr, n: gdev->gd_layout_type) != XDR_UNIT) |
4977 | return nfserr_resource; |
4978 | /* da_addr_body */ |
4979 | ops = nfsd4_layout_ops[gdev->gd_layout_type]; |
4980 | status = ops->encode_getdeviceinfo(xdr, gdev); |
4981 | if (status != nfs_ok) { |
4982 | /* |
4983 | * Don't burden the layout drivers with enforcing |
4984 | * gd_maxcount. Just tell the client to come back |
4985 | * with a bigger buffer if it's not enough. |
4986 | */ |
4987 | if (xdr->buf->len + XDR_UNIT > gdev->gd_maxcount) |
4988 | goto toosmall; |
4989 | return status; |
4990 | } |
4991 | |
4992 | return nfs_ok; |
4993 | |
4994 | toosmall: |
4995 | needed_len = xdr->buf->len + XDR_UNIT; /* notifications */ |
4996 | xdr_truncate_encode(xdr, len: starting_len); |
4997 | |
4998 | status = nfsd4_encode_count4(xdr, needed_len); |
4999 | if (status != nfs_ok) |
5000 | return status; |
5001 | return nfserr_toosmall; |
5002 | } |
5003 | |
5004 | static __be32 |
5005 | nfsd4_encode_getdeviceinfo(struct nfsd4_compoundres *resp, __be32 nfserr, |
5006 | union nfsd4_op_u *u) |
5007 | { |
5008 | struct nfsd4_getdeviceinfo *gdev = &u->getdeviceinfo; |
5009 | struct xdr_stream *xdr = resp->xdr; |
5010 | |
5011 | /* gdir_device_addr */ |
5012 | nfserr = nfsd4_encode_device_addr4(xdr, gdev); |
5013 | if (nfserr) |
5014 | return nfserr; |
5015 | /* gdir_notification */ |
5016 | return nfsd4_encode_bitmap4(xdr, bmval0: gdev->gd_notify_types, bmval1: 0, bmval2: 0); |
5017 | } |
5018 | |
5019 | static __be32 |
5020 | nfsd4_encode_layout4(struct xdr_stream *xdr, const struct nfsd4_layoutget *lgp) |
5021 | { |
5022 | const struct nfsd4_layout_ops *ops = nfsd4_layout_ops[lgp->lg_layout_type]; |
5023 | __be32 status; |
5024 | |
5025 | /* lo_offset */ |
5026 | status = nfsd4_encode_offset4(xdr, lgp->lg_seg.offset); |
5027 | if (status != nfs_ok) |
5028 | return status; |
5029 | /* lo_length */ |
5030 | status = nfsd4_encode_length4(xdr, lgp->lg_seg.length); |
5031 | if (status != nfs_ok) |
5032 | return status; |
5033 | /* lo_iomode */ |
5034 | if (xdr_stream_encode_u32(xdr, n: lgp->lg_seg.iomode) != XDR_UNIT) |
5035 | return nfserr_resource; |
5036 | /* lo_content */ |
5037 | if (xdr_stream_encode_u32(xdr, n: lgp->lg_layout_type) != XDR_UNIT) |
5038 | return nfserr_resource; |
5039 | return ops->encode_layoutget(xdr, lgp); |
5040 | } |
5041 | |
5042 | static __be32 |
5043 | nfsd4_encode_layoutget(struct nfsd4_compoundres *resp, __be32 nfserr, |
5044 | union nfsd4_op_u *u) |
5045 | { |
5046 | struct nfsd4_layoutget *lgp = &u->layoutget; |
5047 | struct xdr_stream *xdr = resp->xdr; |
5048 | |
5049 | /* logr_return_on_close */ |
5050 | nfserr = nfsd4_encode_bool(xdr, val: true); |
5051 | if (nfserr != nfs_ok) |
5052 | return nfserr; |
5053 | /* logr_stateid */ |
5054 | nfserr = nfsd4_encode_stateid4(xdr, sid: &lgp->lg_sid); |
5055 | if (nfserr != nfs_ok) |
5056 | return nfserr; |
5057 | /* logr_layout<> */ |
5058 | if (xdr_stream_encode_u32(xdr, n: 1) != XDR_UNIT) |
5059 | return nfserr_resource; |
5060 | return nfsd4_encode_layout4(xdr, lgp); |
5061 | } |
5062 | |
5063 | static __be32 |
5064 | nfsd4_encode_layoutcommit(struct nfsd4_compoundres *resp, __be32 nfserr, |
5065 | union nfsd4_op_u *u) |
5066 | { |
5067 | struct nfsd4_layoutcommit *lcp = &u->layoutcommit; |
5068 | struct xdr_stream *xdr = resp->xdr; |
5069 | |
5070 | /* ns_sizechanged */ |
5071 | nfserr = nfsd4_encode_bool(xdr, val: lcp->lc_size_chg); |
5072 | if (nfserr != nfs_ok) |
5073 | return nfserr; |
5074 | if (lcp->lc_size_chg) |
5075 | /* ns_size */ |
5076 | return nfsd4_encode_length4(xdr, lcp->lc_newsize); |
5077 | return nfs_ok; |
5078 | } |
5079 | |
5080 | static __be32 |
5081 | nfsd4_encode_layoutreturn(struct nfsd4_compoundres *resp, __be32 nfserr, |
5082 | union nfsd4_op_u *u) |
5083 | { |
5084 | struct nfsd4_layoutreturn *lrp = &u->layoutreturn; |
5085 | struct xdr_stream *xdr = resp->xdr; |
5086 | |
5087 | /* lrs_present */ |
5088 | nfserr = nfsd4_encode_bool(xdr, val: lrp->lrs_present); |
5089 | if (nfserr != nfs_ok) |
5090 | return nfserr; |
5091 | if (lrp->lrs_present) |
5092 | /* lrs_stateid */ |
5093 | return nfsd4_encode_stateid4(xdr, sid: &lrp->lr_sid); |
5094 | return nfs_ok; |
5095 | } |
5096 | #endif /* CONFIG_NFSD_PNFS */ |
5097 | |
5098 | static __be32 |
5099 | nfsd4_encode_write_response4(struct xdr_stream *xdr, |
5100 | const struct nfsd4_copy *copy) |
5101 | { |
5102 | const struct nfsd42_write_res *write = ©->cp_res; |
5103 | u32 count = nfsd4_copy_is_sync(copy) ? 0 : 1; |
5104 | __be32 status; |
5105 | |
5106 | /* wr_callback_id<1> */ |
5107 | if (xdr_stream_encode_u32(xdr, n: count) != XDR_UNIT) |
5108 | return nfserr_resource; |
5109 | if (count) { |
5110 | status = nfsd4_encode_stateid4(xdr, sid: &write->cb_stateid); |
5111 | if (status != nfs_ok) |
5112 | return status; |
5113 | } |
5114 | |
5115 | /* wr_count */ |
5116 | status = nfsd4_encode_length4(xdr, write->wr_bytes_written); |
5117 | if (status != nfs_ok) |
5118 | return status; |
5119 | /* wr_committed */ |
5120 | if (xdr_stream_encode_u32(xdr, n: write->wr_stable_how) != XDR_UNIT) |
5121 | return nfserr_resource; |
5122 | /* wr_writeverf */ |
5123 | return nfsd4_encode_verifier4(xdr, verf: &write->wr_verifier); |
5124 | } |
5125 | |
5126 | static __be32 nfsd4_encode_copy_requirements4(struct xdr_stream *xdr, |
5127 | const struct nfsd4_copy *copy) |
5128 | { |
5129 | __be32 status; |
5130 | |
5131 | /* cr_consecutive */ |
5132 | status = nfsd4_encode_bool(xdr, val: true); |
5133 | if (status != nfs_ok) |
5134 | return status; |
5135 | /* cr_synchronous */ |
5136 | return nfsd4_encode_bool(xdr, val: nfsd4_copy_is_sync(copy)); |
5137 | } |
5138 | |
5139 | static __be32 |
5140 | nfsd4_encode_copy(struct nfsd4_compoundres *resp, __be32 nfserr, |
5141 | union nfsd4_op_u *u) |
5142 | { |
5143 | struct nfsd4_copy *copy = &u->copy; |
5144 | |
5145 | nfserr = nfsd4_encode_write_response4(xdr: resp->xdr, copy); |
5146 | if (nfserr != nfs_ok) |
5147 | return nfserr; |
5148 | return nfsd4_encode_copy_requirements4(xdr: resp->xdr, copy); |
5149 | } |
5150 | |
5151 | static __be32 |
5152 | nfsd4_encode_netloc4(struct xdr_stream *xdr, const struct nl4_server *ns) |
5153 | { |
5154 | __be32 status; |
5155 | |
5156 | if (xdr_stream_encode_u32(xdr, n: ns->nl4_type) != XDR_UNIT) |
5157 | return nfserr_resource; |
5158 | switch (ns->nl4_type) { |
5159 | case NL4_NETADDR: |
5160 | /* nl_addr */ |
5161 | status = nfsd4_encode_netaddr4(xdr, addr: &ns->u.nl4_addr); |
5162 | break; |
5163 | default: |
5164 | status = nfserr_serverfault; |
5165 | } |
5166 | return status; |
5167 | } |
5168 | |
5169 | static __be32 |
5170 | nfsd4_encode_copy_notify(struct nfsd4_compoundres *resp, __be32 nfserr, |
5171 | union nfsd4_op_u *u) |
5172 | { |
5173 | struct nfsd4_copy_notify *cn = &u->copy_notify; |
5174 | struct xdr_stream *xdr = resp->xdr; |
5175 | |
5176 | /* cnr_lease_time */ |
5177 | nfserr = nfsd4_encode_nfstime4(xdr, tv: &cn->cpn_lease_time); |
5178 | if (nfserr) |
5179 | return nfserr; |
5180 | /* cnr_stateid */ |
5181 | nfserr = nfsd4_encode_stateid4(xdr, sid: &cn->cpn_cnr_stateid); |
5182 | if (nfserr) |
5183 | return nfserr; |
5184 | /* cnr_source_server<> */ |
5185 | if (xdr_stream_encode_u32(xdr, n: 1) != XDR_UNIT) |
5186 | return nfserr_resource; |
5187 | return nfsd4_encode_netloc4(xdr, ns: cn->cpn_src); |
5188 | } |
5189 | |
5190 | static __be32 |
5191 | nfsd4_encode_offload_status(struct nfsd4_compoundres *resp, __be32 nfserr, |
5192 | union nfsd4_op_u *u) |
5193 | { |
5194 | struct nfsd4_offload_status *os = &u->offload_status; |
5195 | struct xdr_stream *xdr = resp->xdr; |
5196 | |
5197 | /* osr_count */ |
5198 | nfserr = nfsd4_encode_length4(xdr, os->count); |
5199 | if (nfserr != nfs_ok) |
5200 | return nfserr; |
5201 | /* osr_complete<1> */ |
5202 | if (xdr_stream_encode_u32(xdr, n: 0) != XDR_UNIT) |
5203 | return nfserr_resource; |
5204 | return nfs_ok; |
5205 | } |
5206 | |
5207 | static __be32 |
5208 | nfsd4_encode_read_plus_data(struct nfsd4_compoundres *resp, |
5209 | struct nfsd4_read *read) |
5210 | { |
5211 | struct nfsd4_compoundargs *argp = resp->rqstp->rq_argp; |
5212 | struct file *file = read->rd_nf->nf_file; |
5213 | struct xdr_stream *xdr = resp->xdr; |
5214 | bool splice_ok = argp->splice_ok; |
5215 | unsigned long maxcount; |
5216 | __be32 nfserr, *p; |
5217 | |
5218 | /* Content type, offset, byte count */ |
5219 | p = xdr_reserve_space(xdr, nbytes: 4 + 8 + 4); |
5220 | if (!p) |
5221 | return nfserr_io; |
5222 | if (resp->xdr->buf->page_len && splice_ok) { |
5223 | WARN_ON_ONCE(splice_ok); |
5224 | return nfserr_serverfault; |
5225 | } |
5226 | |
5227 | maxcount = min_t(unsigned long, read->rd_length, |
5228 | (xdr->buf->buflen - xdr->buf->len)); |
5229 | |
5230 | if (file->f_op->splice_read && splice_ok) |
5231 | nfserr = nfsd4_encode_splice_read(resp, read, file, maxcount); |
5232 | else |
5233 | nfserr = nfsd4_encode_readv(resp, read, file, maxcount); |
5234 | if (nfserr) |
5235 | return nfserr; |
5236 | |
5237 | *p++ = cpu_to_be32(NFS4_CONTENT_DATA); |
5238 | p = xdr_encode_hyper(p, val: read->rd_offset); |
5239 | *p = cpu_to_be32(read->rd_length); |
5240 | |
5241 | return nfs_ok; |
5242 | } |
5243 | |
5244 | static __be32 |
5245 | nfsd4_encode_read_plus(struct nfsd4_compoundres *resp, __be32 nfserr, |
5246 | union nfsd4_op_u *u) |
5247 | { |
5248 | struct nfsd4_read *read = &u->read; |
5249 | struct file *file = read->rd_nf->nf_file; |
5250 | struct xdr_stream *xdr = resp->xdr; |
5251 | int starting_len = xdr->buf->len; |
5252 | u32 segments = 0; |
5253 | __be32 *p; |
5254 | |
5255 | if (nfserr) |
5256 | return nfserr; |
5257 | |
5258 | /* eof flag, segment count */ |
5259 | p = xdr_reserve_space(xdr, nbytes: 4 + 4); |
5260 | if (!p) |
5261 | return nfserr_io; |
5262 | xdr_commit_encode(xdr); |
5263 | |
5264 | read->rd_eof = read->rd_offset >= i_size_read(inode: file_inode(f: file)); |
5265 | if (read->rd_eof) |
5266 | goto out; |
5267 | |
5268 | nfserr = nfsd4_encode_read_plus_data(resp, read); |
5269 | if (nfserr) { |
5270 | xdr_truncate_encode(xdr, len: starting_len); |
5271 | return nfserr; |
5272 | } |
5273 | |
5274 | segments++; |
5275 | |
5276 | out: |
5277 | p = xdr_encode_bool(p, n: read->rd_eof); |
5278 | *p = cpu_to_be32(segments); |
5279 | return nfserr; |
5280 | } |
5281 | |
5282 | static __be32 |
5283 | nfsd4_encode_seek(struct nfsd4_compoundres *resp, __be32 nfserr, |
5284 | union nfsd4_op_u *u) |
5285 | { |
5286 | struct nfsd4_seek *seek = &u->seek; |
5287 | struct xdr_stream *xdr = resp->xdr; |
5288 | |
5289 | /* sr_eof */ |
5290 | nfserr = nfsd4_encode_bool(xdr, val: seek->seek_eof); |
5291 | if (nfserr != nfs_ok) |
5292 | return nfserr; |
5293 | /* sr_offset */ |
5294 | return nfsd4_encode_offset4(xdr, seek->seek_pos); |
5295 | } |
5296 | |
5297 | static __be32 |
5298 | nfsd4_encode_noop(struct nfsd4_compoundres *resp, __be32 nfserr, |
5299 | union nfsd4_op_u *p) |
5300 | { |
5301 | return nfserr; |
5302 | } |
5303 | |
5304 | /* |
5305 | * Encode kmalloc-ed buffer in to XDR stream. |
5306 | */ |
5307 | static __be32 |
5308 | nfsd4_vbuf_to_stream(struct xdr_stream *xdr, char *buf, u32 buflen) |
5309 | { |
5310 | u32 cplen; |
5311 | __be32 *p; |
5312 | |
5313 | cplen = min_t(unsigned long, buflen, |
5314 | ((void *)xdr->end - (void *)xdr->p)); |
5315 | p = xdr_reserve_space(xdr, nbytes: cplen); |
5316 | if (!p) |
5317 | return nfserr_resource; |
5318 | |
5319 | memcpy(p, buf, cplen); |
5320 | buf += cplen; |
5321 | buflen -= cplen; |
5322 | |
5323 | while (buflen) { |
5324 | cplen = min_t(u32, buflen, PAGE_SIZE); |
5325 | p = xdr_reserve_space(xdr, nbytes: cplen); |
5326 | if (!p) |
5327 | return nfserr_resource; |
5328 | |
5329 | memcpy(p, buf, cplen); |
5330 | |
5331 | if (cplen < PAGE_SIZE) { |
5332 | /* |
5333 | * We're done, with a length that wasn't page |
5334 | * aligned, so possibly not word aligned. Pad |
5335 | * any trailing bytes with 0. |
5336 | */ |
5337 | xdr_encode_opaque_fixed(p, NULL, len: cplen); |
5338 | break; |
5339 | } |
5340 | |
5341 | buflen -= PAGE_SIZE; |
5342 | buf += PAGE_SIZE; |
5343 | } |
5344 | |
5345 | return 0; |
5346 | } |
5347 | |
5348 | static __be32 |
5349 | nfsd4_encode_getxattr(struct nfsd4_compoundres *resp, __be32 nfserr, |
5350 | union nfsd4_op_u *u) |
5351 | { |
5352 | struct nfsd4_getxattr *getxattr = &u->getxattr; |
5353 | struct xdr_stream *xdr = resp->xdr; |
5354 | __be32 *p, err; |
5355 | |
5356 | p = xdr_reserve_space(xdr, nbytes: 4); |
5357 | if (!p) |
5358 | return nfserr_resource; |
5359 | |
5360 | *p = cpu_to_be32(getxattr->getxa_len); |
5361 | |
5362 | if (getxattr->getxa_len == 0) |
5363 | return 0; |
5364 | |
5365 | err = nfsd4_vbuf_to_stream(xdr, buf: getxattr->getxa_buf, |
5366 | buflen: getxattr->getxa_len); |
5367 | |
5368 | kvfree(addr: getxattr->getxa_buf); |
5369 | |
5370 | return err; |
5371 | } |
5372 | |
5373 | static __be32 |
5374 | nfsd4_encode_setxattr(struct nfsd4_compoundres *resp, __be32 nfserr, |
5375 | union nfsd4_op_u *u) |
5376 | { |
5377 | struct nfsd4_setxattr *setxattr = &u->setxattr; |
5378 | struct xdr_stream *xdr = resp->xdr; |
5379 | |
5380 | return nfsd4_encode_change_info4(xdr, c: &setxattr->setxa_cinfo); |
5381 | } |
5382 | |
5383 | /* |
5384 | * See if there are cookie values that can be rejected outright. |
5385 | */ |
5386 | static __be32 |
5387 | nfsd4_listxattr_validate_cookie(struct nfsd4_listxattrs *listxattrs, |
5388 | u32 *offsetp) |
5389 | { |
5390 | u64 cookie = listxattrs->lsxa_cookie; |
5391 | |
5392 | /* |
5393 | * If the cookie is larger than the maximum number we can fit |
5394 | * in the buffer we just got back from vfs_listxattr, it's invalid. |
5395 | */ |
5396 | if (cookie > (listxattrs->lsxa_len) / (XATTR_USER_PREFIX_LEN + 2)) |
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 | __be64 wire_cookie; |
5416 | __be32 *p; |
5417 | u32 nuser; |
5418 | |
5419 | eof = 1; |
5420 | |
5421 | status = nfsd4_listxattr_validate_cookie(listxattrs, offsetp: &offset); |
5422 | if (status) |
5423 | goto out; |
5424 | |
5425 | /* |
5426 | * Reserve space for the cookie and the name array count. Record |
5427 | * the offsets to save them later. |
5428 | */ |
5429 | cookie_offset = xdr->buf->len; |
5430 | count_offset = cookie_offset + 8; |
5431 | p = xdr_reserve_space(xdr, XDR_UNIT * 3); |
5432 | if (!p) { |
5433 | status = nfserr_resource; |
5434 | goto out; |
5435 | } |
5436 | |
5437 | count = 0; |
5438 | left = listxattrs->lsxa_len; |
5439 | sp = listxattrs->lsxa_buf; |
5440 | nuser = 0; |
5441 | |
5442 | /* Bytes left is maxcount - 8 (cookie) - 4 (array count) */ |
5443 | xdrleft = listxattrs->lsxa_maxcount - XDR_UNIT * 3; |
5444 | |
5445 | while (left > 0 && xdrleft > 0) { |
5446 | slen = strlen(sp); |
5447 | |
5448 | /* |
5449 | * Check if this is a "user." attribute, skip it if not. |
5450 | */ |
5451 | if (strncmp(sp, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)) |
5452 | goto contloop; |
5453 | |
5454 | slen -= XATTR_USER_PREFIX_LEN; |
5455 | xdrlen = 4 + ((slen + 3) & ~3); |
5456 | /* Check if both entry and eof can fit in the XDR buffer */ |
5457 | if (xdrlen + XDR_UNIT > xdrleft) { |
5458 | if (count == 0) { |
5459 | /* |
5460 | * Can't even fit the first attribute name. |
5461 | */ |
5462 | status = nfserr_toosmall; |
5463 | goto out; |
5464 | } |
5465 | eof = 0; |
5466 | goto wreof; |
5467 | } |
5468 | |
5469 | left -= XATTR_USER_PREFIX_LEN; |
5470 | sp += XATTR_USER_PREFIX_LEN; |
5471 | if (nuser++ < offset) |
5472 | goto contloop; |
5473 | |
5474 | |
5475 | p = xdr_reserve_space(xdr, nbytes: xdrlen); |
5476 | if (!p) { |
5477 | status = nfserr_resource; |
5478 | goto out; |
5479 | } |
5480 | |
5481 | xdr_encode_opaque(p, ptr: sp, len: slen); |
5482 | |
5483 | xdrleft -= xdrlen; |
5484 | count++; |
5485 | contloop: |
5486 | sp += slen + 1; |
5487 | left -= slen + 1; |
5488 | } |
5489 | |
5490 | /* |
5491 | * If there were user attributes to copy, but we didn't copy |
5492 | * any, the offset was too large (e.g. the cookie was invalid). |
5493 | */ |
5494 | if (nuser > 0 && count == 0) { |
5495 | status = nfserr_badcookie; |
5496 | goto out; |
5497 | } |
5498 | |
5499 | wreof: |
5500 | p = xdr_reserve_space(xdr, nbytes: 4); |
5501 | if (!p) { |
5502 | status = nfserr_resource; |
5503 | goto out; |
5504 | } |
5505 | *p = cpu_to_be32(eof); |
5506 | |
5507 | cookie = offset + count; |
5508 | |
5509 | wire_cookie = cpu_to_be64(cookie); |
5510 | write_bytes_to_xdr_buf(xdr->buf, cookie_offset, &wire_cookie, 8); |
5511 | tmp = cpu_to_be32(count); |
5512 | write_bytes_to_xdr_buf(xdr->buf, count_offset, &tmp, 4); |
5513 | out: |
5514 | if (listxattrs->lsxa_len) |
5515 | kvfree(addr: listxattrs->lsxa_buf); |
5516 | return status; |
5517 | } |
5518 | |
5519 | static __be32 |
5520 | nfsd4_encode_removexattr(struct nfsd4_compoundres *resp, __be32 nfserr, |
5521 | union nfsd4_op_u *u) |
5522 | { |
5523 | struct nfsd4_removexattr *removexattr = &u->removexattr; |
5524 | struct xdr_stream *xdr = resp->xdr; |
5525 | |
5526 | return nfsd4_encode_change_info4(xdr, c: &removexattr->rmxa_cinfo); |
5527 | } |
5528 | |
5529 | typedef __be32(*nfsd4_enc)(struct nfsd4_compoundres *, __be32, union nfsd4_op_u *u); |
5530 | |
5531 | /* |
5532 | * Note: nfsd4_enc_ops vector is shared for v4.0 and v4.1 |
5533 | * since we don't need to filter out obsolete ops as this is |
5534 | * done in the decoding phase. |
5535 | */ |
5536 | static const nfsd4_enc nfsd4_enc_ops[] = { |
5537 | [OP_ACCESS] = nfsd4_encode_access, |
5538 | [OP_CLOSE] = nfsd4_encode_close, |
5539 | [OP_COMMIT] = nfsd4_encode_commit, |
5540 | [OP_CREATE] = nfsd4_encode_create, |
5541 | [OP_DELEGPURGE] = nfsd4_encode_noop, |
5542 | [OP_DELEGRETURN] = nfsd4_encode_noop, |
5543 | [OP_GETATTR] = nfsd4_encode_getattr, |
5544 | [OP_GETFH] = nfsd4_encode_getfh, |
5545 | [OP_LINK] = nfsd4_encode_link, |
5546 | [OP_LOCK] = nfsd4_encode_lock, |
5547 | [OP_LOCKT] = nfsd4_encode_lockt, |
5548 | [OP_LOCKU] = nfsd4_encode_locku, |
5549 | [OP_LOOKUP] = nfsd4_encode_noop, |
5550 | [OP_LOOKUPP] = nfsd4_encode_noop, |
5551 | [OP_NVERIFY] = nfsd4_encode_noop, |
5552 | [OP_OPEN] = nfsd4_encode_open, |
5553 | [OP_OPENATTR] = nfsd4_encode_noop, |
5554 | [OP_OPEN_CONFIRM] = nfsd4_encode_open_confirm, |
5555 | [OP_OPEN_DOWNGRADE] = nfsd4_encode_open_downgrade, |
5556 | [OP_PUTFH] = nfsd4_encode_noop, |
5557 | [OP_PUTPUBFH] = nfsd4_encode_noop, |
5558 | [OP_PUTROOTFH] = nfsd4_encode_noop, |
5559 | [OP_READ] = nfsd4_encode_read, |
5560 | [OP_READDIR] = nfsd4_encode_readdir, |
5561 | [OP_READLINK] = nfsd4_encode_readlink, |
5562 | [OP_REMOVE] = nfsd4_encode_remove, |
5563 | [OP_RENAME] = nfsd4_encode_rename, |
5564 | [OP_RENEW] = nfsd4_encode_noop, |
5565 | [OP_RESTOREFH] = nfsd4_encode_noop, |
5566 | [OP_SAVEFH] = nfsd4_encode_noop, |
5567 | [OP_SECINFO] = nfsd4_encode_secinfo, |
5568 | [OP_SETATTR] = nfsd4_encode_setattr, |
5569 | [OP_SETCLIENTID] = nfsd4_encode_setclientid, |
5570 | [OP_SETCLIENTID_CONFIRM] = nfsd4_encode_noop, |
5571 | [OP_VERIFY] = nfsd4_encode_noop, |
5572 | [OP_WRITE] = nfsd4_encode_write, |
5573 | [OP_RELEASE_LOCKOWNER] = nfsd4_encode_noop, |
5574 | |
5575 | /* NFSv4.1 operations */ |
5576 | [OP_BACKCHANNEL_CTL] = nfsd4_encode_noop, |
5577 | [OP_BIND_CONN_TO_SESSION] = nfsd4_encode_bind_conn_to_session, |
5578 | [OP_EXCHANGE_ID] = nfsd4_encode_exchange_id, |
5579 | [OP_CREATE_SESSION] = nfsd4_encode_create_session, |
5580 | [OP_DESTROY_SESSION] = nfsd4_encode_noop, |
5581 | [OP_FREE_STATEID] = nfsd4_encode_noop, |
5582 | [OP_GET_DIR_DELEGATION] = nfsd4_encode_noop, |
5583 | #ifdef CONFIG_NFSD_PNFS |
5584 | [OP_GETDEVICEINFO] = nfsd4_encode_getdeviceinfo, |
5585 | [OP_GETDEVICELIST] = nfsd4_encode_noop, |
5586 | [OP_LAYOUTCOMMIT] = nfsd4_encode_layoutcommit, |
5587 | [OP_LAYOUTGET] = nfsd4_encode_layoutget, |
5588 | [OP_LAYOUTRETURN] = nfsd4_encode_layoutreturn, |
5589 | #else |
5590 | [OP_GETDEVICEINFO] = nfsd4_encode_noop, |
5591 | [OP_GETDEVICELIST] = nfsd4_encode_noop, |
5592 | [OP_LAYOUTCOMMIT] = nfsd4_encode_noop, |
5593 | [OP_LAYOUTGET] = nfsd4_encode_noop, |
5594 | [OP_LAYOUTRETURN] = nfsd4_encode_noop, |
5595 | #endif |
5596 | [OP_SECINFO_NO_NAME] = nfsd4_encode_secinfo_no_name, |
5597 | [OP_SEQUENCE] = nfsd4_encode_sequence, |
5598 | [OP_SET_SSV] = nfsd4_encode_noop, |
5599 | [OP_TEST_STATEID] = nfsd4_encode_test_stateid, |
5600 | [OP_WANT_DELEGATION] = nfsd4_encode_noop, |
5601 | [OP_DESTROY_CLIENTID] = nfsd4_encode_noop, |
5602 | [OP_RECLAIM_COMPLETE] = nfsd4_encode_noop, |
5603 | |
5604 | /* NFSv4.2 operations */ |
5605 | [OP_ALLOCATE] = nfsd4_encode_noop, |
5606 | [OP_COPY] = nfsd4_encode_copy, |
5607 | [OP_COPY_NOTIFY] = nfsd4_encode_copy_notify, |
5608 | [OP_DEALLOCATE] = nfsd4_encode_noop, |
5609 | [OP_IO_ADVISE] = nfsd4_encode_noop, |
5610 | [OP_LAYOUTERROR] = nfsd4_encode_noop, |
5611 | [OP_LAYOUTSTATS] = nfsd4_encode_noop, |
5612 | [OP_OFFLOAD_CANCEL] = nfsd4_encode_noop, |
5613 | [OP_OFFLOAD_STATUS] = nfsd4_encode_offload_status, |
5614 | [OP_READ_PLUS] = nfsd4_encode_read_plus, |
5615 | [OP_SEEK] = nfsd4_encode_seek, |
5616 | [OP_WRITE_SAME] = nfsd4_encode_noop, |
5617 | [OP_CLONE] = nfsd4_encode_noop, |
5618 | |
5619 | /* RFC 8276 extended atributes operations */ |
5620 | [OP_GETXATTR] = nfsd4_encode_getxattr, |
5621 | [OP_SETXATTR] = nfsd4_encode_setxattr, |
5622 | [OP_LISTXATTRS] = nfsd4_encode_listxattrs, |
5623 | [OP_REMOVEXATTR] = nfsd4_encode_removexattr, |
5624 | }; |
5625 | |
5626 | /* |
5627 | * Calculate whether we still have space to encode repsize bytes. |
5628 | * There are two considerations: |
5629 | * - For NFS versions >=4.1, the size of the reply must stay within |
5630 | * session limits |
5631 | * - For all NFS versions, we must stay within limited preallocated |
5632 | * buffer space. |
5633 | * |
5634 | * This is called before the operation is processed, so can only provide |
5635 | * an upper estimate. For some nonidempotent operations (such as |
5636 | * getattr), it's not necessarily a problem if that estimate is wrong, |
5637 | * as we can fail it after processing without significant side effects. |
5638 | */ |
5639 | __be32 nfsd4_check_resp_size(struct nfsd4_compoundres *resp, u32 respsize) |
5640 | { |
5641 | struct xdr_buf *buf = &resp->rqstp->rq_res; |
5642 | struct nfsd4_slot *slot = resp->cstate.slot; |
5643 | |
5644 | if (buf->len + respsize <= buf->buflen) |
5645 | return nfs_ok; |
5646 | if (!nfsd4_has_session(cs: &resp->cstate)) |
5647 | return nfserr_resource; |
5648 | if (slot->sl_flags & NFSD4_SLOT_CACHETHIS) { |
5649 | WARN_ON_ONCE(1); |
5650 | return nfserr_rep_too_big_to_cache; |
5651 | } |
5652 | return nfserr_rep_too_big; |
5653 | } |
5654 | |
5655 | void |
5656 | nfsd4_encode_operation(struct nfsd4_compoundres *resp, struct nfsd4_op *op) |
5657 | { |
5658 | struct xdr_stream *xdr = resp->xdr; |
5659 | struct nfs4_stateowner *so = resp->cstate.replay_owner; |
5660 | struct svc_rqst *rqstp = resp->rqstp; |
5661 | const struct nfsd4_operation *opdesc = op->opdesc; |
5662 | int post_err_offset; |
5663 | nfsd4_enc encoder; |
5664 | __be32 *p; |
5665 | |
5666 | p = xdr_reserve_space(xdr, nbytes: 8); |
5667 | if (!p) |
5668 | goto release; |
5669 | *p++ = cpu_to_be32(op->opnum); |
5670 | post_err_offset = xdr->buf->len; |
5671 | |
5672 | if (op->opnum == OP_ILLEGAL) |
5673 | goto status; |
5674 | if (op->status && opdesc && |
5675 | !(opdesc->op_flags & OP_NONTRIVIAL_ERROR_ENCODE)) |
5676 | goto status; |
5677 | BUG_ON(op->opnum >= ARRAY_SIZE(nfsd4_enc_ops) || |
5678 | !nfsd4_enc_ops[op->opnum]); |
5679 | encoder = nfsd4_enc_ops[op->opnum]; |
5680 | op->status = encoder(resp, op->status, &op->u); |
5681 | if (op->status) |
5682 | trace_nfsd_compound_encode_err(rqstp, opnum: op->opnum, status: op->status); |
5683 | xdr_commit_encode(xdr); |
5684 | |
5685 | /* nfsd4_check_resp_size guarantees enough room for error status */ |
5686 | if (!op->status) { |
5687 | int space_needed = 0; |
5688 | if (!nfsd4_last_compound_op(rqstp)) |
5689 | space_needed = COMPOUND_ERR_SLACK_SPACE; |
5690 | op->status = nfsd4_check_resp_size(resp, respsize: space_needed); |
5691 | } |
5692 | if (op->status == nfserr_resource && nfsd4_has_session(cs: &resp->cstate)) { |
5693 | struct nfsd4_slot *slot = resp->cstate.slot; |
5694 | |
5695 | if (slot->sl_flags & NFSD4_SLOT_CACHETHIS) |
5696 | op->status = nfserr_rep_too_big_to_cache; |
5697 | else |
5698 | op->status = nfserr_rep_too_big; |
5699 | } |
5700 | if (op->status == nfserr_resource || |
5701 | op->status == nfserr_rep_too_big || |
5702 | op->status == nfserr_rep_too_big_to_cache) { |
5703 | /* |
5704 | * The operation may have already been encoded or |
5705 | * partially encoded. No op returns anything additional |
5706 | * in the case of one of these three errors, so we can |
5707 | * just truncate back to after the status. But it's a |
5708 | * bug if we had to do this on a non-idempotent op: |
5709 | */ |
5710 | warn_on_nonidempotent_op(op); |
5711 | xdr_truncate_encode(xdr, len: post_err_offset); |
5712 | } |
5713 | if (so) { |
5714 | int len = xdr->buf->len - post_err_offset; |
5715 | |
5716 | so->so_replay.rp_status = op->status; |
5717 | so->so_replay.rp_buflen = len; |
5718 | read_bytes_from_xdr_buf(xdr->buf, post_err_offset, |
5719 | so->so_replay.rp_buf, len); |
5720 | } |
5721 | status: |
5722 | *p = op->status; |
5723 | release: |
5724 | if (opdesc && opdesc->op_release) |
5725 | opdesc->op_release(&op->u); |
5726 | |
5727 | /* |
5728 | * Account for pages consumed while encoding this operation. |
5729 | * The xdr_stream primitives don't manage rq_next_page. |
5730 | */ |
5731 | rqstp->rq_next_page = xdr->page_ptr + 1; |
5732 | } |
5733 | |
5734 | /** |
5735 | * nfsd4_encode_replay - encode a result stored in the stateowner reply cache |
5736 | * @xdr: send buffer's XDR stream |
5737 | * @op: operation being replayed |
5738 | * |
5739 | * @op->replay->rp_buf contains the previously-sent already-encoded result. |
5740 | */ |
5741 | void nfsd4_encode_replay(struct xdr_stream *xdr, struct nfsd4_op *op) |
5742 | { |
5743 | struct nfs4_replay *rp = op->replay; |
5744 | |
5745 | trace_nfsd_stateowner_replay(opnum: op->opnum, rp); |
5746 | |
5747 | if (xdr_stream_encode_u32(xdr, n: op->opnum) != XDR_UNIT) |
5748 | return; |
5749 | if (xdr_stream_encode_be32(xdr, n: rp->rp_status) != XDR_UNIT) |
5750 | return; |
5751 | xdr_stream_encode_opaque_fixed(xdr, ptr: rp->rp_buf, len: rp->rp_buflen); |
5752 | } |
5753 | |
5754 | void nfsd4_release_compoundargs(struct svc_rqst *rqstp) |
5755 | { |
5756 | struct nfsd4_compoundargs *args = rqstp->rq_argp; |
5757 | |
5758 | if (args->ops != args->iops) { |
5759 | vfree(addr: args->ops); |
5760 | args->ops = args->iops; |
5761 | } |
5762 | while (args->to_free) { |
5763 | struct svcxdr_tmpbuf *tb = args->to_free; |
5764 | args->to_free = tb->next; |
5765 | kfree(objp: tb); |
5766 | } |
5767 | } |
5768 | |
5769 | bool |
5770 | nfs4svc_decode_compoundargs(struct svc_rqst *rqstp, struct xdr_stream *xdr) |
5771 | { |
5772 | struct nfsd4_compoundargs *args = rqstp->rq_argp; |
5773 | |
5774 | /* svcxdr_tmp_alloc */ |
5775 | args->to_free = NULL; |
5776 | |
5777 | args->xdr = xdr; |
5778 | args->ops = args->iops; |
5779 | args->rqstp = rqstp; |
5780 | |
5781 | return nfsd4_decode_compound(argp: args); |
5782 | } |
5783 | |
5784 | bool |
5785 | nfs4svc_encode_compoundres(struct svc_rqst *rqstp, struct xdr_stream *xdr) |
5786 | { |
5787 | struct nfsd4_compoundres *resp = rqstp->rq_resp; |
5788 | __be32 *p; |
5789 | |
5790 | /* |
5791 | * Send buffer space for the following items is reserved |
5792 | * at the top of nfsd4_proc_compound(). |
5793 | */ |
5794 | p = resp->statusp; |
5795 | |
5796 | *p++ = resp->cstate.status; |
5797 | *p++ = htonl(resp->taglen); |
5798 | memcpy(p, resp->tag, resp->taglen); |
5799 | p += XDR_QUADLEN(resp->taglen); |
5800 | *p++ = htonl(resp->opcnt); |
5801 | |
5802 | nfsd4_sequence_done(resp); |
5803 | return true; |
5804 | } |
5805 | |