]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - fs/nfs/nfs42xdr.c
projects / mirror_ubuntu-jammy-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge ath-next from git://git.kernel.org/pub/scm/linux/kernel/git/kvalo/ath.git
[mirror_ubuntu-jammy-kernel.git] / fs / nfs / nfs42xdr.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2014 Anna Schumaker <Anna.Schumaker@Netapp.com>
4 */
5 #ifndef __LINUX_FS_NFS_NFS4_2XDR_H
6 #define __LINUX_FS_NFS_NFS4_2XDR_H
7
8 #include "nfs42.h"
9
10 #define encode_fallocate_maxsz (encode_stateid_maxsz + \
11 2 /* offset */ + \
12 2 /* length */)
13 #define NFS42_WRITE_RES_SIZE (1 /* wr_callback_id size */ +\
14 XDR_QUADLEN(NFS4_STATEID_SIZE) + \
15 2 /* wr_count */ + \
16 1 /* wr_committed */ + \
17 XDR_QUADLEN(NFS4_VERIFIER_SIZE))
18 #define encode_allocate_maxsz (op_encode_hdr_maxsz + \
19 encode_fallocate_maxsz)
20 #define decode_allocate_maxsz (op_decode_hdr_maxsz)
21 #define encode_copy_maxsz (op_encode_hdr_maxsz + \
22 XDR_QUADLEN(NFS4_STATEID_SIZE) + \
23 XDR_QUADLEN(NFS4_STATEID_SIZE) + \
24 2 + 2 + 2 + 1 + 1 + 1 +\
25 1 + /* One cnr_source_server */\
26 1 + /* nl4_type */ \
27 1 + XDR_QUADLEN(NFS4_OPAQUE_LIMIT))
28 #define decode_copy_maxsz (op_decode_hdr_maxsz + \
29 NFS42_WRITE_RES_SIZE + \
30 1 /* cr_consecutive */ + \
31 1 /* cr_synchronous */)
32 #define encode_offload_cancel_maxsz (op_encode_hdr_maxsz + \
33 XDR_QUADLEN(NFS4_STATEID_SIZE))
34 #define decode_offload_cancel_maxsz (op_decode_hdr_maxsz)
35 #define encode_copy_notify_maxsz (op_encode_hdr_maxsz + \
36 XDR_QUADLEN(NFS4_STATEID_SIZE) + \
37 1 + /* nl4_type */ \
38 1 + XDR_QUADLEN(NFS4_OPAQUE_LIMIT))
39 #define decode_copy_notify_maxsz (op_decode_hdr_maxsz + \
40 3 + /* cnr_lease_time */\
41 XDR_QUADLEN(NFS4_STATEID_SIZE) + \
42 1 + /* Support 1 cnr_source_server */\
43 1 + /* nl4_type */ \
44 1 + XDR_QUADLEN(NFS4_OPAQUE_LIMIT))
45 #define encode_deallocate_maxsz (op_encode_hdr_maxsz + \
46 encode_fallocate_maxsz)
47 #define decode_deallocate_maxsz (op_decode_hdr_maxsz)
48 #define encode_read_plus_maxsz (op_encode_hdr_maxsz + \
49 encode_stateid_maxsz + 3)
50 #define NFS42_READ_PLUS_SEGMENT_SIZE (1 /* data_content4 */ + \
51 2 /* data_info4.di_offset */ + \
52 2 /* data_info4.di_length */)
53 #define decode_read_plus_maxsz (op_decode_hdr_maxsz + \
54 1 /* rpr_eof */ + \
55 1 /* rpr_contents count */ + \
56 2 * NFS42_READ_PLUS_SEGMENT_SIZE)
57 #define encode_seek_maxsz (op_encode_hdr_maxsz + \
58 encode_stateid_maxsz + \
59 2 /* offset */ + \
60 1 /* whence */)
61 #define decode_seek_maxsz (op_decode_hdr_maxsz + \
62 1 /* eof */ + \
63 1 /* whence */ + \
64 2 /* offset */ + \
65 2 /* length */)
66 #define encode_io_info_maxsz 4
67 #define encode_layoutstats_maxsz (op_decode_hdr_maxsz + \
68 2 /* offset */ + \
69 2 /* length */ + \
70 encode_stateid_maxsz + \
71 encode_io_info_maxsz + \
72 encode_io_info_maxsz + \
73 1 /* opaque devaddr4 length */ + \
74 XDR_QUADLEN(PNFS_LAYOUTSTATS_MAXSIZE))
75 #define decode_layoutstats_maxsz (op_decode_hdr_maxsz)
76 #define encode_device_error_maxsz (XDR_QUADLEN(NFS4_DEVICEID4_SIZE) + \
77 1 /* status */ + 1 /* opnum */)
78 #define encode_layouterror_maxsz (op_decode_hdr_maxsz + \
79 2 /* offset */ + \
80 2 /* length */ + \
81 encode_stateid_maxsz + \
82 1 /* Array size */ + \
83 encode_device_error_maxsz)
84 #define decode_layouterror_maxsz (op_decode_hdr_maxsz)
85 #define encode_clone_maxsz (encode_stateid_maxsz + \
86 encode_stateid_maxsz + \
87 2 /* src offset */ + \
88 2 /* dst offset */ + \
89 2 /* count */)
90 #define decode_clone_maxsz (op_decode_hdr_maxsz)
91
92 #define NFS4_enc_allocate_sz (compound_encode_hdr_maxsz + \
93 encode_sequence_maxsz + \
94 encode_putfh_maxsz + \
95 encode_allocate_maxsz + \
96 encode_getattr_maxsz)
97 #define NFS4_dec_allocate_sz (compound_decode_hdr_maxsz + \
98 decode_sequence_maxsz + \
99 decode_putfh_maxsz + \
100 decode_allocate_maxsz + \
101 decode_getattr_maxsz)
102 #define NFS4_enc_copy_sz (compound_encode_hdr_maxsz + \
103 encode_sequence_maxsz + \
104 encode_putfh_maxsz + \
105 encode_savefh_maxsz + \
106 encode_putfh_maxsz + \
107 encode_copy_maxsz + \
108 encode_commit_maxsz)
109 #define NFS4_dec_copy_sz (compound_decode_hdr_maxsz + \
110 decode_sequence_maxsz + \
111 decode_putfh_maxsz + \
112 decode_savefh_maxsz + \
113 decode_putfh_maxsz + \
114 decode_copy_maxsz + \
115 decode_commit_maxsz)
116 #define NFS4_enc_offload_cancel_sz (compound_encode_hdr_maxsz + \
117 encode_sequence_maxsz + \
118 encode_putfh_maxsz + \
119 encode_offload_cancel_maxsz)
120 #define NFS4_dec_offload_cancel_sz (compound_decode_hdr_maxsz + \
121 decode_sequence_maxsz + \
122 decode_putfh_maxsz + \
123 decode_offload_cancel_maxsz)
124 #define NFS4_enc_copy_notify_sz (compound_encode_hdr_maxsz + \
125 encode_putfh_maxsz + \
126 encode_copy_notify_maxsz)
127 #define NFS4_dec_copy_notify_sz (compound_decode_hdr_maxsz + \
128 decode_putfh_maxsz + \
129 decode_copy_notify_maxsz)
130 #define NFS4_enc_deallocate_sz (compound_encode_hdr_maxsz + \
131 encode_sequence_maxsz + \
132 encode_putfh_maxsz + \
133 encode_deallocate_maxsz + \
134 encode_getattr_maxsz)
135 #define NFS4_dec_deallocate_sz (compound_decode_hdr_maxsz + \
136 decode_sequence_maxsz + \
137 decode_putfh_maxsz + \
138 decode_deallocate_maxsz + \
139 decode_getattr_maxsz)
140 #define NFS4_enc_read_plus_sz (compound_encode_hdr_maxsz + \
141 encode_sequence_maxsz + \
142 encode_putfh_maxsz + \
143 encode_read_plus_maxsz)
144 #define NFS4_dec_read_plus_sz (compound_decode_hdr_maxsz + \
145 decode_sequence_maxsz + \
146 decode_putfh_maxsz + \
147 decode_read_plus_maxsz)
148 #define NFS4_enc_seek_sz (compound_encode_hdr_maxsz + \
149 encode_sequence_maxsz + \
150 encode_putfh_maxsz + \
151 encode_seek_maxsz)
152 #define NFS4_dec_seek_sz (compound_decode_hdr_maxsz + \
153 decode_sequence_maxsz + \
154 decode_putfh_maxsz + \
155 decode_seek_maxsz)
156 #define NFS4_enc_layoutstats_sz (compound_encode_hdr_maxsz + \
157 encode_sequence_maxsz + \
158 encode_putfh_maxsz + \
159 PNFS_LAYOUTSTATS_MAXDEV * encode_layoutstats_maxsz)
160 #define NFS4_dec_layoutstats_sz (compound_decode_hdr_maxsz + \
161 decode_sequence_maxsz + \
162 decode_putfh_maxsz + \
163 PNFS_LAYOUTSTATS_MAXDEV * decode_layoutstats_maxsz)
164 #define NFS4_enc_layouterror_sz (compound_encode_hdr_maxsz + \
165 encode_sequence_maxsz + \
166 encode_putfh_maxsz + \
167 NFS42_LAYOUTERROR_MAX * \
168 encode_layouterror_maxsz)
169 #define NFS4_dec_layouterror_sz (compound_decode_hdr_maxsz + \
170 decode_sequence_maxsz + \
171 decode_putfh_maxsz + \
172 NFS42_LAYOUTERROR_MAX * \
173 decode_layouterror_maxsz)
174 #define NFS4_enc_clone_sz (compound_encode_hdr_maxsz + \
175 encode_sequence_maxsz + \
176 encode_putfh_maxsz + \
177 encode_savefh_maxsz + \
178 encode_putfh_maxsz + \
179 encode_clone_maxsz + \
180 encode_getattr_maxsz)
181 #define NFS4_dec_clone_sz (compound_decode_hdr_maxsz + \
182 decode_sequence_maxsz + \
183 decode_putfh_maxsz + \
184 decode_savefh_maxsz + \
185 decode_putfh_maxsz + \
186 decode_clone_maxsz + \
187 decode_getattr_maxsz)
188
189 /* Not limited by NFS itself, limited by the generic xattr code */
190 #define nfs4_xattr_name_maxsz XDR_QUADLEN(XATTR_NAME_MAX)
191
192 #define encode_getxattr_maxsz (op_encode_hdr_maxsz + 1 + \
193 nfs4_xattr_name_maxsz)
194 #define decode_getxattr_maxsz (op_decode_hdr_maxsz + 1 + pagepad_maxsz)
195 #define encode_setxattr_maxsz (op_encode_hdr_maxsz + \
196 1 + nfs4_xattr_name_maxsz + 1)
197 #define decode_setxattr_maxsz (op_decode_hdr_maxsz + decode_change_info_maxsz)
198 #define encode_listxattrs_maxsz (op_encode_hdr_maxsz + 2 + 1)
199 #define decode_listxattrs_maxsz (op_decode_hdr_maxsz + 2 + 1 + 1 + 1)
200 #define encode_removexattr_maxsz (op_encode_hdr_maxsz + 1 + \
201 nfs4_xattr_name_maxsz)
202 #define decode_removexattr_maxsz (op_decode_hdr_maxsz + \
203 decode_change_info_maxsz)
204
205 #define NFS4_enc_getxattr_sz (compound_encode_hdr_maxsz + \
206 encode_sequence_maxsz + \
207 encode_putfh_maxsz + \
208 encode_getxattr_maxsz)
209 #define NFS4_dec_getxattr_sz (compound_decode_hdr_maxsz + \
210 decode_sequence_maxsz + \
211 decode_putfh_maxsz + \
212 decode_getxattr_maxsz)
213 #define NFS4_enc_setxattr_sz (compound_encode_hdr_maxsz + \
214 encode_sequence_maxsz + \
215 encode_putfh_maxsz + \
216 encode_setxattr_maxsz)
217 #define NFS4_dec_setxattr_sz (compound_decode_hdr_maxsz + \
218 decode_sequence_maxsz + \
219 decode_putfh_maxsz + \
220 decode_setxattr_maxsz)
221 #define NFS4_enc_listxattrs_sz (compound_encode_hdr_maxsz + \
222 encode_sequence_maxsz + \
223 encode_putfh_maxsz + \
224 encode_listxattrs_maxsz)
225 #define NFS4_dec_listxattrs_sz (compound_decode_hdr_maxsz + \
226 decode_sequence_maxsz + \
227 decode_putfh_maxsz + \
228 decode_listxattrs_maxsz)
229 #define NFS4_enc_removexattr_sz (compound_encode_hdr_maxsz + \
230 encode_sequence_maxsz + \
231 encode_putfh_maxsz + \
232 encode_removexattr_maxsz)
233 #define NFS4_dec_removexattr_sz (compound_decode_hdr_maxsz + \
234 decode_sequence_maxsz + \
235 decode_putfh_maxsz + \
236 decode_removexattr_maxsz)
237
238 /*
239 * These values specify the maximum amount of data that is not
240 * associated with the extended attribute name or extended
241 * attribute list in the SETXATTR, GETXATTR and LISTXATTR
242 * respectively.
243 */
244 const u32 nfs42_maxsetxattr_overhead = ((RPC_MAX_HEADER_WITH_AUTH +
245 compound_encode_hdr_maxsz +
246 encode_sequence_maxsz +
247 encode_putfh_maxsz + 1 +
248 nfs4_xattr_name_maxsz)
249 * XDR_UNIT);
250
251 const u32 nfs42_maxgetxattr_overhead = ((RPC_MAX_HEADER_WITH_AUTH +
252 compound_decode_hdr_maxsz +
253 decode_sequence_maxsz +
254 decode_putfh_maxsz + 1) * XDR_UNIT);
255
256 const u32 nfs42_maxlistxattrs_overhead = ((RPC_MAX_HEADER_WITH_AUTH +
257 compound_decode_hdr_maxsz +
258 decode_sequence_maxsz +
259 decode_putfh_maxsz + 3) * XDR_UNIT);
260
261 static void encode_fallocate(struct xdr_stream *xdr,
262 const struct nfs42_falloc_args *args)
263 {
264 encode_nfs4_stateid(xdr, &args->falloc_stateid);
265 encode_uint64(xdr, args->falloc_offset);
266 encode_uint64(xdr, args->falloc_length);
267 }
268
269 static void encode_allocate(struct xdr_stream *xdr,
270 const struct nfs42_falloc_args *args,
271 struct compound_hdr *hdr)
272 {
273 encode_op_hdr(xdr, OP_ALLOCATE, decode_allocate_maxsz, hdr);
274 encode_fallocate(xdr, args);
275 }
276
277 static void encode_nl4_server(struct xdr_stream *xdr,
278 const struct nl4_server *ns)
279 {
280 encode_uint32(xdr, ns->nl4_type);
281 switch (ns->nl4_type) {
282 case NL4_NAME:
283 case NL4_URL:
284 encode_string(xdr, ns->u.nl4_str_sz, ns->u.nl4_str);
285 break;
286 case NL4_NETADDR:
287 encode_string(xdr, ns->u.nl4_addr.netid_len,
288 ns->u.nl4_addr.netid);
289 encode_string(xdr, ns->u.nl4_addr.addr_len,
290 ns->u.nl4_addr.addr);
291 break;
292 default:
293 WARN_ON_ONCE(1);
294 }
295 }
296
297 static void encode_copy(struct xdr_stream *xdr,
298 const struct nfs42_copy_args *args,
299 struct compound_hdr *hdr)
300 {
301 encode_op_hdr(xdr, OP_COPY, decode_copy_maxsz, hdr);
302 encode_nfs4_stateid(xdr, &args->src_stateid);
303 encode_nfs4_stateid(xdr, &args->dst_stateid);
304
305 encode_uint64(xdr, args->src_pos);
306 encode_uint64(xdr, args->dst_pos);
307 encode_uint64(xdr, args->count);
308
309 encode_uint32(xdr, 1); /* consecutive = true */
310 encode_uint32(xdr, args->sync);
311 if (args->cp_src == NULL) { /* intra-ssc */
312 encode_uint32(xdr, 0); /* no src server list */
313 return;
314 }
315 encode_uint32(xdr, 1); /* supporting 1 server */
316 encode_nl4_server(xdr, args->cp_src);
317 }
318
319 static void encode_offload_cancel(struct xdr_stream *xdr,
320 const struct nfs42_offload_status_args *args,
321 struct compound_hdr *hdr)
322 {
323 encode_op_hdr(xdr, OP_OFFLOAD_CANCEL, decode_offload_cancel_maxsz, hdr);
324 encode_nfs4_stateid(xdr, &args->osa_stateid);
325 }
326
327 static void encode_copy_notify(struct xdr_stream *xdr,
328 const struct nfs42_copy_notify_args *args,
329 struct compound_hdr *hdr)
330 {
331 encode_op_hdr(xdr, OP_COPY_NOTIFY, decode_copy_notify_maxsz, hdr);
332 encode_nfs4_stateid(xdr, &args->cna_src_stateid);
333 encode_nl4_server(xdr, &args->cna_dst);
334 }
335
336 static void encode_deallocate(struct xdr_stream *xdr,
337 const struct nfs42_falloc_args *args,
338 struct compound_hdr *hdr)
339 {
340 encode_op_hdr(xdr, OP_DEALLOCATE, decode_deallocate_maxsz, hdr);
341 encode_fallocate(xdr, args);
342 }
343
344 static void encode_read_plus(struct xdr_stream *xdr,
345 const struct nfs_pgio_args *args,
346 struct compound_hdr *hdr)
347 {
348 encode_op_hdr(xdr, OP_READ_PLUS, decode_read_plus_maxsz, hdr);
349 encode_nfs4_stateid(xdr, &args->stateid);
350 encode_uint64(xdr, args->offset);
351 encode_uint32(xdr, args->count);
352 }
353
354 static void encode_seek(struct xdr_stream *xdr,
355 const struct nfs42_seek_args *args,
356 struct compound_hdr *hdr)
357 {
358 encode_op_hdr(xdr, OP_SEEK, decode_seek_maxsz, hdr);
359 encode_nfs4_stateid(xdr, &args->sa_stateid);
360 encode_uint64(xdr, args->sa_offset);
361 encode_uint32(xdr, args->sa_what);
362 }
363
364 static void encode_layoutstats(struct xdr_stream *xdr,
365 const struct nfs42_layoutstat_args *args,
366 struct nfs42_layoutstat_devinfo *devinfo,
367 struct compound_hdr *hdr)
368 {
369 __be32 *p;
370
371 encode_op_hdr(xdr, OP_LAYOUTSTATS, decode_layoutstats_maxsz, hdr);
372 p = reserve_space(xdr, 8 + 8);
373 p = xdr_encode_hyper(p, devinfo->offset);
374 p = xdr_encode_hyper(p, devinfo->length);
375 encode_nfs4_stateid(xdr, &args->stateid);
376 p = reserve_space(xdr, 4*8 + NFS4_DEVICEID4_SIZE + 4);
377 p = xdr_encode_hyper(p, devinfo->read_count);
378 p = xdr_encode_hyper(p, devinfo->read_bytes);
379 p = xdr_encode_hyper(p, devinfo->write_count);
380 p = xdr_encode_hyper(p, devinfo->write_bytes);
381 p = xdr_encode_opaque_fixed(p, devinfo->dev_id.data,
382 NFS4_DEVICEID4_SIZE);
383 /* Encode layoutupdate4 */
384 *p++ = cpu_to_be32(devinfo->layout_type);
385 if (devinfo->ld_private.ops)
386 devinfo->ld_private.ops->encode(xdr, args,
387 &devinfo->ld_private);
388 else
389 encode_uint32(xdr, 0);
390 }
391
392 static void encode_clone(struct xdr_stream *xdr,
393 const struct nfs42_clone_args *args,
394 struct compound_hdr *hdr)
395 {
396 __be32 *p;
397
398 encode_op_hdr(xdr, OP_CLONE, decode_clone_maxsz, hdr);
399 encode_nfs4_stateid(xdr, &args->src_stateid);
400 encode_nfs4_stateid(xdr, &args->dst_stateid);
401 p = reserve_space(xdr, 3*8);
402 p = xdr_encode_hyper(p, args->src_offset);
403 p = xdr_encode_hyper(p, args->dst_offset);
404 xdr_encode_hyper(p, args->count);
405 }
406
407 static void encode_device_error(struct xdr_stream *xdr,
408 const struct nfs42_device_error *error)
409 {
410 __be32 *p;
411
412 p = reserve_space(xdr, NFS4_DEVICEID4_SIZE + 2*4);
413 p = xdr_encode_opaque_fixed(p, error->dev_id.data,
414 NFS4_DEVICEID4_SIZE);
415 *p++ = cpu_to_be32(error->status);
416 *p = cpu_to_be32(error->opnum);
417 }
418
419 static void encode_layouterror(struct xdr_stream *xdr,
420 const struct nfs42_layout_error *args,
421 struct compound_hdr *hdr)
422 {
423 __be32 *p;
424
425 encode_op_hdr(xdr, OP_LAYOUTERROR, decode_layouterror_maxsz, hdr);
426 p = reserve_space(xdr, 8 + 8);
427 p = xdr_encode_hyper(p, args->offset);
428 p = xdr_encode_hyper(p, args->length);
429 encode_nfs4_stateid(xdr, &args->stateid);
430 p = reserve_space(xdr, 4);
431 *p = cpu_to_be32(1);
432 encode_device_error(xdr, &args->errors[0]);
433 }
434
435 static void encode_setxattr(struct xdr_stream *xdr,
436 const struct nfs42_setxattrargs *arg,
437 struct compound_hdr *hdr)
438 {
439 __be32 *p;
440
441 BUILD_BUG_ON(XATTR_CREATE != SETXATTR4_CREATE);
442 BUILD_BUG_ON(XATTR_REPLACE != SETXATTR4_REPLACE);
443
444 encode_op_hdr(xdr, OP_SETXATTR, decode_setxattr_maxsz, hdr);
445 p = reserve_space(xdr, 4);
446 *p = cpu_to_be32(arg->xattr_flags);
447 encode_string(xdr, strlen(arg->xattr_name), arg->xattr_name);
448 p = reserve_space(xdr, 4);
449 *p = cpu_to_be32(arg->xattr_len);
450 if (arg->xattr_len)
451 xdr_write_pages(xdr, arg->xattr_pages, 0, arg->xattr_len);
452 }
453
454 static int decode_setxattr(struct xdr_stream *xdr,
455 struct nfs4_change_info *cinfo)
456 {
457 int status;
458
459 status = decode_op_hdr(xdr, OP_SETXATTR);
460 if (status)
461 goto out;
462 status = decode_change_info(xdr, cinfo);
463 out:
464 return status;
465 }
466
467
468 static void encode_getxattr(struct xdr_stream *xdr, const char *name,
469 struct compound_hdr *hdr)
470 {
471 encode_op_hdr(xdr, OP_GETXATTR, decode_getxattr_maxsz, hdr);
472 encode_string(xdr, strlen(name), name);
473 }
474
475 static int decode_getxattr(struct xdr_stream *xdr,
476 struct nfs42_getxattrres *res,
477 struct rpc_rqst *req)
478 {
479 int status;
480 __be32 *p;
481 u32 len, rdlen;
482
483 status = decode_op_hdr(xdr, OP_GETXATTR);
484 if (status)
485 return status;
486
487 p = xdr_inline_decode(xdr, 4);
488 if (unlikely(!p))
489 return -EIO;
490
491 len = be32_to_cpup(p);
492
493 /*
494 * Only check against the page length here. The actual
495 * requested length may be smaller, but that is only
496 * checked against after possibly caching a valid reply.
497 */
498 if (len > req->rq_rcv_buf.page_len)
499 return -ERANGE;
500
501 res->xattr_len = len;
502
503 if (len > 0) {
504 rdlen = xdr_read_pages(xdr, len);
505 if (rdlen < len)
506 return -EIO;
507 }
508
509 return 0;
510 }
511
512 static void encode_removexattr(struct xdr_stream *xdr, const char *name,
513 struct compound_hdr *hdr)
514 {
515 encode_op_hdr(xdr, OP_REMOVEXATTR, decode_removexattr_maxsz, hdr);
516 encode_string(xdr, strlen(name), name);
517 }
518
519
520 static int decode_removexattr(struct xdr_stream *xdr,
521 struct nfs4_change_info *cinfo)
522 {
523 int status;
524
525 status = decode_op_hdr(xdr, OP_REMOVEXATTR);
526 if (status)
527 goto out;
528
529 status = decode_change_info(xdr, cinfo);
530 out:
531 return status;
532 }
533
534 static void encode_listxattrs(struct xdr_stream *xdr,
535 const struct nfs42_listxattrsargs *arg,
536 struct compound_hdr *hdr)
537 {
538 __be32 *p;
539
540 encode_op_hdr(xdr, OP_LISTXATTRS, decode_listxattrs_maxsz, hdr);
541
542 p = reserve_space(xdr, 12);
543 if (unlikely(!p))
544 return;
545
546 p = xdr_encode_hyper(p, arg->cookie);
547 /*
548 * RFC 8276 says to specify the full max length of the LISTXATTRS
549 * XDR reply. Count is set to the XDR length of the names array
550 * plus the EOF marker. So, add the cookie and the names count.
551 */
552 *p = cpu_to_be32(arg->count + 8 + 4);
553 }
554
555 static int decode_listxattrs(struct xdr_stream *xdr,
556 struct nfs42_listxattrsres *res)
557 {
558 int status;
559 __be32 *p;
560 u32 count, len, ulen;
561 size_t left, copied;
562 char *buf;
563
564 status = decode_op_hdr(xdr, OP_LISTXATTRS);
565 if (status) {
566 /*
567 * Special case: for LISTXATTRS, NFS4ERR_TOOSMALL
568 * should be translated to ERANGE.
569 */
570 if (status == -ETOOSMALL)
571 status = -ERANGE;
572 goto out;
573 }
574
575 p = xdr_inline_decode(xdr, 8);
576 if (unlikely(!p))
577 return -EIO;
578
579 xdr_decode_hyper(p, &res->cookie);
580
581 p = xdr_inline_decode(xdr, 4);
582 if (unlikely(!p))
583 return -EIO;
584
585 left = res->xattr_len;
586 buf = res->xattr_buf;
587
588 count = be32_to_cpup(p);
589 copied = 0;
590
591 /*
592 * We have asked for enough room to encode the maximum number
593 * of possible attribute names, so everything should fit.
594 *
595 * But, don't rely on that assumption. Just decode entries
596 * until they don't fit anymore, just in case the server did
597 * something odd.
598 */
599 while (count--) {
600 p = xdr_inline_decode(xdr, 4);
601 if (unlikely(!p))
602 return -EIO;
603
604 len = be32_to_cpup(p);
605 if (len > (XATTR_NAME_MAX - XATTR_USER_PREFIX_LEN)) {
606 status = -ERANGE;
607 goto out;
608 }
609
610 p = xdr_inline_decode(xdr, len);
611 if (unlikely(!p))
612 return -EIO;
613
614 ulen = len + XATTR_USER_PREFIX_LEN + 1;
615 if (buf) {
616 if (ulen > left) {
617 status = -ERANGE;
618 goto out;
619 }
620
621 memcpy(buf, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN);
622 memcpy(buf + XATTR_USER_PREFIX_LEN, p, len);
623
624 buf[ulen - 1] = 0;
625 buf += ulen;
626 left -= ulen;
627 }
628 copied += ulen;
629 }
630
631 p = xdr_inline_decode(xdr, 4);
632 if (unlikely(!p))
633 return -EIO;
634
635 res->eof = be32_to_cpup(p);
636 res->copied = copied;
637
638 out:
639 if (status == -ERANGE && res->xattr_len == XATTR_LIST_MAX)
640 status = -E2BIG;
641
642 return status;
643 }
644
645 /*
646 * Encode ALLOCATE request
647 */
648 static void nfs4_xdr_enc_allocate(struct rpc_rqst *req,
649 struct xdr_stream *xdr,
650 const void *data)
651 {
652 const struct nfs42_falloc_args *args = data;
653 struct compound_hdr hdr = {
654 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
655 };
656
657 encode_compound_hdr(xdr, req, &hdr);
658 encode_sequence(xdr, &args->seq_args, &hdr);
659 encode_putfh(xdr, args->falloc_fh, &hdr);
660 encode_allocate(xdr, args, &hdr);
661 encode_getfattr(xdr, args->falloc_bitmask, &hdr);
662 encode_nops(&hdr);
663 }
664
665 static void encode_copy_commit(struct xdr_stream *xdr,
666 const struct nfs42_copy_args *args,
667 struct compound_hdr *hdr)
668 {
669 __be32 *p;
670
671 encode_op_hdr(xdr, OP_COMMIT, decode_commit_maxsz, hdr);
672 p = reserve_space(xdr, 12);
673 p = xdr_encode_hyper(p, args->dst_pos);
674 *p = cpu_to_be32(args->count);
675 }
676
677 /*
678 * Encode COPY request
679 */
680 static void nfs4_xdr_enc_copy(struct rpc_rqst *req,
681 struct xdr_stream *xdr,
682 const void *data)
683 {
684 const struct nfs42_copy_args *args = data;
685 struct compound_hdr hdr = {
686 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
687 };
688
689 encode_compound_hdr(xdr, req, &hdr);
690 encode_sequence(xdr, &args->seq_args, &hdr);
691 encode_putfh(xdr, args->src_fh, &hdr);
692 encode_savefh(xdr, &hdr);
693 encode_putfh(xdr, args->dst_fh, &hdr);
694 encode_copy(xdr, args, &hdr);
695 if (args->sync)
696 encode_copy_commit(xdr, args, &hdr);
697 encode_nops(&hdr);
698 }
699
700 /*
701 * Encode OFFLOAD_CANEL request
702 */
703 static void nfs4_xdr_enc_offload_cancel(struct rpc_rqst *req,
704 struct xdr_stream *xdr,
705 const void *data)
706 {
707 const struct nfs42_offload_status_args *args = data;
708 struct compound_hdr hdr = {
709 .minorversion = nfs4_xdr_minorversion(&args->osa_seq_args),
710 };
711
712 encode_compound_hdr(xdr, req, &hdr);
713 encode_sequence(xdr, &args->osa_seq_args, &hdr);
714 encode_putfh(xdr, args->osa_src_fh, &hdr);
715 encode_offload_cancel(xdr, args, &hdr);
716 encode_nops(&hdr);
717 }
718
719 /*
720 * Encode COPY_NOTIFY request
721 */
722 static void nfs4_xdr_enc_copy_notify(struct rpc_rqst *req,
723 struct xdr_stream *xdr,
724 const void *data)
725 {
726 const struct nfs42_copy_notify_args *args = data;
727 struct compound_hdr hdr = {
728 .minorversion = nfs4_xdr_minorversion(&args->cna_seq_args),
729 };
730
731 encode_compound_hdr(xdr, req, &hdr);
732 encode_sequence(xdr, &args->cna_seq_args, &hdr);
733 encode_putfh(xdr, args->cna_src_fh, &hdr);
734 encode_copy_notify(xdr, args, &hdr);
735 encode_nops(&hdr);
736 }
737
738 /*
739 * Encode DEALLOCATE request
740 */
741 static void nfs4_xdr_enc_deallocate(struct rpc_rqst *req,
742 struct xdr_stream *xdr,
743 const void *data)
744 {
745 const struct nfs42_falloc_args *args = data;
746 struct compound_hdr hdr = {
747 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
748 };
749
750 encode_compound_hdr(xdr, req, &hdr);
751 encode_sequence(xdr, &args->seq_args, &hdr);
752 encode_putfh(xdr, args->falloc_fh, &hdr);
753 encode_deallocate(xdr, args, &hdr);
754 encode_getfattr(xdr, args->falloc_bitmask, &hdr);
755 encode_nops(&hdr);
756 }
757
758 /*
759 * Encode READ_PLUS request
760 */
761 static void nfs4_xdr_enc_read_plus(struct rpc_rqst *req,
762 struct xdr_stream *xdr,
763 const void *data)
764 {
765 const struct nfs_pgio_args *args = data;
766 struct compound_hdr hdr = {
767 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
768 };
769
770 encode_compound_hdr(xdr, req, &hdr);
771 encode_sequence(xdr, &args->seq_args, &hdr);
772 encode_putfh(xdr, args->fh, &hdr);
773 encode_read_plus(xdr, args, &hdr);
774
775 rpc_prepare_reply_pages(req, args->pages, args->pgbase,
776 args->count, hdr.replen);
777 encode_nops(&hdr);
778 }
779
780 /*
781 * Encode SEEK request
782 */
783 static void nfs4_xdr_enc_seek(struct rpc_rqst *req,
784 struct xdr_stream *xdr,
785 const void *data)
786 {
787 const struct nfs42_seek_args *args = data;
788 struct compound_hdr hdr = {
789 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
790 };
791
792 encode_compound_hdr(xdr, req, &hdr);
793 encode_sequence(xdr, &args->seq_args, &hdr);
794 encode_putfh(xdr, args->sa_fh, &hdr);
795 encode_seek(xdr, args, &hdr);
796 encode_nops(&hdr);
797 }
798
799 /*
800 * Encode LAYOUTSTATS request
801 */
802 static void nfs4_xdr_enc_layoutstats(struct rpc_rqst *req,
803 struct xdr_stream *xdr,
804 const void *data)
805 {
806 const struct nfs42_layoutstat_args *args = data;
807 int i;
808
809 struct compound_hdr hdr = {
810 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
811 };
812
813 encode_compound_hdr(xdr, req, &hdr);
814 encode_sequence(xdr, &args->seq_args, &hdr);
815 encode_putfh(xdr, args->fh, &hdr);
816 WARN_ON(args->num_dev > PNFS_LAYOUTSTATS_MAXDEV);
817 for (i = 0; i < args->num_dev; i++)
818 encode_layoutstats(xdr, args, &args->devinfo[i], &hdr);
819 encode_nops(&hdr);
820 }
821
822 /*
823 * Encode CLONE request
824 */
825 static void nfs4_xdr_enc_clone(struct rpc_rqst *req,
826 struct xdr_stream *xdr,
827 const void *data)
828 {
829 const struct nfs42_clone_args *args = data;
830 struct compound_hdr hdr = {
831 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
832 };
833
834 encode_compound_hdr(xdr, req, &hdr);
835 encode_sequence(xdr, &args->seq_args, &hdr);
836 encode_putfh(xdr, args->src_fh, &hdr);
837 encode_savefh(xdr, &hdr);
838 encode_putfh(xdr, args->dst_fh, &hdr);
839 encode_clone(xdr, args, &hdr);
840 encode_getfattr(xdr, args->dst_bitmask, &hdr);
841 encode_nops(&hdr);
842 }
843
844 /*
845 * Encode LAYOUTERROR request
846 */
847 static void nfs4_xdr_enc_layouterror(struct rpc_rqst *req,
848 struct xdr_stream *xdr,
849 const void *data)
850 {
851 const struct nfs42_layouterror_args *args = data;
852 struct compound_hdr hdr = {
853 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
854 };
855 int i;
856
857 encode_compound_hdr(xdr, req, &hdr);
858 encode_sequence(xdr, &args->seq_args, &hdr);
859 encode_putfh(xdr, NFS_FH(args->inode), &hdr);
860 for (i = 0; i < args->num_errors; i++)
861 encode_layouterror(xdr, &args->errors[i], &hdr);
862 encode_nops(&hdr);
863 }
864
865 static int decode_allocate(struct xdr_stream *xdr, struct nfs42_falloc_res *res)
866 {
867 return decode_op_hdr(xdr, OP_ALLOCATE);
868 }
869
870 static int decode_write_response(struct xdr_stream *xdr,
871 struct nfs42_write_res *res)
872 {
873 __be32 *p;
874 int status, count;
875
876 p = xdr_inline_decode(xdr, 4);
877 if (unlikely(!p))
878 return -EIO;
879 count = be32_to_cpup(p);
880 if (count > 1)
881 return -EREMOTEIO;
882 else if (count == 1) {
883 status = decode_opaque_fixed(xdr, &res->stateid,
884 NFS4_STATEID_SIZE);
885 if (unlikely(status))
886 return -EIO;
887 }
888 p = xdr_inline_decode(xdr, 8 + 4);
889 if (unlikely(!p))
890 return -EIO;
891 p = xdr_decode_hyper(p, &res->count);
892 res->verifier.committed = be32_to_cpup(p);
893 return decode_verifier(xdr, &res->verifier.verifier);
894 }
895
896 static int decode_nl4_server(struct xdr_stream *xdr, struct nl4_server *ns)
897 {
898 struct nfs42_netaddr *naddr;
899 uint32_t dummy;
900 char *dummy_str;
901 __be32 *p;
902 int status;
903
904 /* nl_type */
905 p = xdr_inline_decode(xdr, 4);
906 if (unlikely(!p))
907 return -EIO;
908 ns->nl4_type = be32_to_cpup(p);
909 switch (ns->nl4_type) {
910 case NL4_NAME:
911 case NL4_URL:
912 status = decode_opaque_inline(xdr, &dummy, &dummy_str);
913 if (unlikely(status))
914 return status;
915 if (unlikely(dummy > NFS4_OPAQUE_LIMIT))
916 return -EIO;
917 memcpy(&ns->u.nl4_str, dummy_str, dummy);
918 ns->u.nl4_str_sz = dummy;
919 break;
920 case NL4_NETADDR:
921 naddr = &ns->u.nl4_addr;
922
923 /* netid string */
924 status = decode_opaque_inline(xdr, &dummy, &dummy_str);
925 if (unlikely(status))
926 return status;
927 if (unlikely(dummy > RPCBIND_MAXNETIDLEN))
928 return -EIO;
929 naddr->netid_len = dummy;
930 memcpy(naddr->netid, dummy_str, naddr->netid_len);
931
932 /* uaddr string */
933 status = decode_opaque_inline(xdr, &dummy, &dummy_str);
934 if (unlikely(status))
935 return status;
936 if (unlikely(dummy > RPCBIND_MAXUADDRLEN))
937 return -EIO;
938 naddr->addr_len = dummy;
939 memcpy(naddr->addr, dummy_str, naddr->addr_len);
940 break;
941 default:
942 WARN_ON_ONCE(1);
943 return -EIO;
944 }
945 return 0;
946 }
947
948 static int decode_copy_requirements(struct xdr_stream *xdr,
949 struct nfs42_copy_res *res) {
950 __be32 *p;
951
952 p = xdr_inline_decode(xdr, 4 + 4);
953 if (unlikely(!p))
954 return -EIO;
955
956 res->consecutive = be32_to_cpup(p++);
957 res->synchronous = be32_to_cpup(p++);
958 return 0;
959 }
960
961 static int decode_copy(struct xdr_stream *xdr, struct nfs42_copy_res *res)
962 {
963 int status;
964
965 status = decode_op_hdr(xdr, OP_COPY);
966 if (status == NFS4ERR_OFFLOAD_NO_REQS) {
967 status = decode_copy_requirements(xdr, res);
968 if (status)
969 return status;
970 return NFS4ERR_OFFLOAD_NO_REQS;
971 } else if (status)
972 return status;
973
974 status = decode_write_response(xdr, &res->write_res);
975 if (status)
976 return status;
977
978 return decode_copy_requirements(xdr, res);
979 }
980
981 static int decode_offload_cancel(struct xdr_stream *xdr,
982 struct nfs42_offload_status_res *res)
983 {
984 return decode_op_hdr(xdr, OP_OFFLOAD_CANCEL);
985 }
986
987 static int decode_copy_notify(struct xdr_stream *xdr,
988 struct nfs42_copy_notify_res *res)
989 {
990 __be32 *p;
991 int status, count;
992
993 status = decode_op_hdr(xdr, OP_COPY_NOTIFY);
994 if (status)
995 return status;
996 /* cnr_lease_time */
997 p = xdr_inline_decode(xdr, 12);
998 if (unlikely(!p))
999 return -EIO;
1000 p = xdr_decode_hyper(p, &res->cnr_lease_time.seconds);
1001 res->cnr_lease_time.nseconds = be32_to_cpup(p);
1002
1003 status = decode_opaque_fixed(xdr, &res->cnr_stateid, NFS4_STATEID_SIZE);
1004 if (unlikely(status))
1005 return -EIO;
1006
1007 /* number of source addresses */
1008 p = xdr_inline_decode(xdr, 4);
1009 if (unlikely(!p))
1010 return -EIO;
1011
1012 count = be32_to_cpup(p);
1013 if (count > 1)
1014 pr_warn("NFS: %s: nsvr %d > Supported. Use first servers\n",
1015 __func__, count);
1016
1017 status = decode_nl4_server(xdr, &res->cnr_src);
1018 if (unlikely(status))
1019 return -EIO;
1020 return 0;
1021 }
1022
1023 static int decode_deallocate(struct xdr_stream *xdr, struct nfs42_falloc_res *res)
1024 {
1025 return decode_op_hdr(xdr, OP_DEALLOCATE);
1026 }
1027
1028 static int decode_read_plus_data(struct xdr_stream *xdr,
1029 struct nfs_pgio_args *args,
1030 struct nfs_pgio_res *res)
1031 {
1032 uint32_t count, recvd;
1033 uint64_t offset;
1034 __be32 *p;
1035
1036 p = xdr_inline_decode(xdr, 8 + 4);
1037 if (!p)
1038 return 1;
1039
1040 p = xdr_decode_hyper(p, &offset);
1041 count = be32_to_cpup(p);
1042 recvd = xdr_align_data(xdr, res->count, xdr_align_size(count));
1043 if (recvd > count)
1044 recvd = count;
1045 if (res->count + recvd > args->count) {
1046 if (args->count > res->count)
1047 res->count += args->count - res->count;
1048 return 1;
1049 }
1050 res->count += recvd;
1051 if (count > recvd)
1052 return 1;
1053 return 0;
1054 }
1055
1056 static int decode_read_plus_hole(struct xdr_stream *xdr,
1057 struct nfs_pgio_args *args,
1058 struct nfs_pgio_res *res, uint32_t *eof)
1059 {
1060 uint64_t offset, length, recvd;
1061 __be32 *p;
1062
1063 p = xdr_inline_decode(xdr, 8 + 8);
1064 if (!p)
1065 return 1;
1066
1067 p = xdr_decode_hyper(p, &offset);
1068 p = xdr_decode_hyper(p, &length);
1069 if (offset != args->offset + res->count) {
1070 /* Server returned an out-of-sequence extent */
1071 if (offset > args->offset + res->count ||
1072 offset + length < args->offset + res->count) {
1073 dprintk("NFS: server returned out of sequence extent: "
1074 "offset/size = %llu/%llu != expected %llu\n",
1075 (unsigned long long)offset,
1076 (unsigned long long)length,
1077 (unsigned long long)(args->offset +
1078 res->count));
1079 return 1;
1080 }
1081 length -= args->offset + res->count - offset;
1082 }
1083 if (length + res->count > args->count) {
1084 *eof = 0;
1085 if (unlikely(res->count >= args->count))
1086 return 1;
1087 length = args->count - res->count;
1088 }
1089 recvd = xdr_expand_hole(xdr, res->count, length);
1090 res->count += recvd;
1091
1092 if (recvd < length)
1093 return 1;
1094 return 0;
1095 }
1096
1097 static int decode_read_plus(struct xdr_stream *xdr, struct nfs_pgio_res *res)
1098 {
1099 struct nfs_pgio_header *hdr =
1100 container_of(res, struct nfs_pgio_header, res);
1101 struct nfs_pgio_args *args = &hdr->args;
1102 uint32_t eof, segments, type;
1103 int status, i;
1104 __be32 *p;
1105
1106 status = decode_op_hdr(xdr, OP_READ_PLUS);
1107 if (status)
1108 return status;
1109
1110 p = xdr_inline_decode(xdr, 4 + 4);
1111 if (unlikely(!p))
1112 return -EIO;
1113
1114 res->count = 0;
1115 eof = be32_to_cpup(p++);
1116 segments = be32_to_cpup(p++);
1117 if (segments == 0)
1118 goto out;
1119
1120 for (i = 0; i < segments; i++) {
1121 p = xdr_inline_decode(xdr, 4);
1122 if (!p)
1123 goto early_out;
1124
1125 type = be32_to_cpup(p++);
1126 if (type == NFS4_CONTENT_DATA)
1127 status = decode_read_plus_data(xdr, args, res);
1128 else if (type == NFS4_CONTENT_HOLE)
1129 status = decode_read_plus_hole(xdr, args, res, &eof);
1130 else
1131 return -EINVAL;
1132
1133 if (status < 0)
1134 return status;
1135 if (status > 0)
1136 goto early_out;
1137 }
1138
1139 out:
1140 res->eof = eof;
1141 return 0;
1142 early_out:
1143 if (unlikely(!i))
1144 return -EIO;
1145 res->eof = 0;
1146 return 0;
1147 }
1148
1149 static int decode_seek(struct xdr_stream *xdr, struct nfs42_seek_res *res)
1150 {
1151 int status;
1152 __be32 *p;
1153
1154 status = decode_op_hdr(xdr, OP_SEEK);
1155 if (status)
1156 return status;
1157
1158 p = xdr_inline_decode(xdr, 4 + 8);
1159 if (unlikely(!p))
1160 return -EIO;
1161
1162 res->sr_eof = be32_to_cpup(p++);
1163 p = xdr_decode_hyper(p, &res->sr_offset);
1164 return 0;
1165 }
1166
1167 static int decode_layoutstats(struct xdr_stream *xdr)
1168 {
1169 return decode_op_hdr(xdr, OP_LAYOUTSTATS);
1170 }
1171
1172 static int decode_clone(struct xdr_stream *xdr)
1173 {
1174 return decode_op_hdr(xdr, OP_CLONE);
1175 }
1176
1177 static int decode_layouterror(struct xdr_stream *xdr)
1178 {
1179 return decode_op_hdr(xdr, OP_LAYOUTERROR);
1180 }
1181
1182 /*
1183 * Decode ALLOCATE request
1184 */
1185 static int nfs4_xdr_dec_allocate(struct rpc_rqst *rqstp,
1186 struct xdr_stream *xdr,
1187 void *data)
1188 {
1189 struct nfs42_falloc_res *res = data;
1190 struct compound_hdr hdr;
1191 int status;
1192
1193 status = decode_compound_hdr(xdr, &hdr);
1194 if (status)
1195 goto out;
1196 status = decode_sequence(xdr, &res->seq_res, rqstp);
1197 if (status)
1198 goto out;
1199 status = decode_putfh(xdr);
1200 if (status)
1201 goto out;
1202 status = decode_allocate(xdr, res);
1203 if (status)
1204 goto out;
1205 decode_getfattr(xdr, res->falloc_fattr, res->falloc_server);
1206 out:
1207 return status;
1208 }
1209
1210 /*
1211 * Decode COPY response
1212 */
1213 static int nfs4_xdr_dec_copy(struct rpc_rqst *rqstp,
1214 struct xdr_stream *xdr,
1215 void *data)
1216 {
1217 struct nfs42_copy_res *res = data;
1218 struct compound_hdr hdr;
1219 int status;
1220
1221 status = decode_compound_hdr(xdr, &hdr);
1222 if (status)
1223 goto out;
1224 status = decode_sequence(xdr, &res->seq_res, rqstp);
1225 if (status)
1226 goto out;
1227 status = decode_putfh(xdr);
1228 if (status)
1229 goto out;
1230 status = decode_savefh(xdr);
1231 if (status)
1232 goto out;
1233 status = decode_putfh(xdr);
1234 if (status)
1235 goto out;
1236 status = decode_copy(xdr, res);
1237 if (status)
1238 goto out;
1239 if (res->commit_res.verf)
1240 status = decode_commit(xdr, &res->commit_res);
1241 out:
1242 return status;
1243 }
1244
1245 /*
1246 * Decode OFFLOAD_CANCEL response
1247 */
1248 static int nfs4_xdr_dec_offload_cancel(struct rpc_rqst *rqstp,
1249 struct xdr_stream *xdr,
1250 void *data)
1251 {
1252 struct nfs42_offload_status_res *res = data;
1253 struct compound_hdr hdr;
1254 int status;
1255
1256 status = decode_compound_hdr(xdr, &hdr);
1257 if (status)
1258 goto out;
1259 status = decode_sequence(xdr, &res->osr_seq_res, rqstp);
1260 if (status)
1261 goto out;
1262 status = decode_putfh(xdr);
1263 if (status)
1264 goto out;
1265 status = decode_offload_cancel(xdr, res);
1266
1267 out:
1268 return status;
1269 }
1270
1271 /*
1272 * Decode COPY_NOTIFY response
1273 */
1274 static int nfs4_xdr_dec_copy_notify(struct rpc_rqst *rqstp,
1275 struct xdr_stream *xdr,
1276 void *data)
1277 {
1278 struct nfs42_copy_notify_res *res = data;
1279 struct compound_hdr hdr;
1280 int status;
1281
1282 status = decode_compound_hdr(xdr, &hdr);
1283 if (status)
1284 goto out;
1285 status = decode_sequence(xdr, &res->cnr_seq_res, rqstp);
1286 if (status)
1287 goto out;
1288 status = decode_putfh(xdr);
1289 if (status)
1290 goto out;
1291 status = decode_copy_notify(xdr, res);
1292
1293 out:
1294 return status;
1295 }
1296
1297 /*
1298 * Decode DEALLOCATE request
1299 */
1300 static int nfs4_xdr_dec_deallocate(struct rpc_rqst *rqstp,
1301 struct xdr_stream *xdr,
1302 void *data)
1303 {
1304 struct nfs42_falloc_res *res = data;
1305 struct compound_hdr hdr;
1306 int status;
1307
1308 status = decode_compound_hdr(xdr, &hdr);
1309 if (status)
1310 goto out;
1311 status = decode_sequence(xdr, &res->seq_res, rqstp);
1312 if (status)
1313 goto out;
1314 status = decode_putfh(xdr);
1315 if (status)
1316 goto out;
1317 status = decode_deallocate(xdr, res);
1318 if (status)
1319 goto out;
1320 decode_getfattr(xdr, res->falloc_fattr, res->falloc_server);
1321 out:
1322 return status;
1323 }
1324
1325 /*
1326 * Decode READ_PLUS request
1327 */
1328 static int nfs4_xdr_dec_read_plus(struct rpc_rqst *rqstp,
1329 struct xdr_stream *xdr,
1330 void *data)
1331 {
1332 struct nfs_pgio_res *res = data;
1333 struct compound_hdr hdr;
1334 int status;
1335
1336 status = decode_compound_hdr(xdr, &hdr);
1337 if (status)
1338 goto out;
1339 status = decode_sequence(xdr, &res->seq_res, rqstp);
1340 if (status)
1341 goto out;
1342 status = decode_putfh(xdr);
1343 if (status)
1344 goto out;
1345 status = decode_read_plus(xdr, res);
1346 if (!status)
1347 status = res->count;
1348 out:
1349 return status;
1350 }
1351
1352 /*
1353 * Decode SEEK request
1354 */
1355 static int nfs4_xdr_dec_seek(struct rpc_rqst *rqstp,
1356 struct xdr_stream *xdr,
1357 void *data)
1358 {
1359 struct nfs42_seek_res *res = data;
1360 struct compound_hdr hdr;
1361 int status;
1362
1363 status = decode_compound_hdr(xdr, &hdr);
1364 if (status)
1365 goto out;
1366 status = decode_sequence(xdr, &res->seq_res, rqstp);
1367 if (status)
1368 goto out;
1369 status = decode_putfh(xdr);
1370 if (status)
1371 goto out;
1372 status = decode_seek(xdr, res);
1373 out:
1374 return status;
1375 }
1376
1377 /*
1378 * Decode LAYOUTSTATS request
1379 */
1380 static int nfs4_xdr_dec_layoutstats(struct rpc_rqst *rqstp,
1381 struct xdr_stream *xdr,
1382 void *data)
1383 {
1384 struct nfs42_layoutstat_res *res = data;
1385 struct compound_hdr hdr;
1386 int status, i;
1387
1388 status = decode_compound_hdr(xdr, &hdr);
1389 if (status)
1390 goto out;
1391 status = decode_sequence(xdr, &res->seq_res, rqstp);
1392 if (status)
1393 goto out;
1394 status = decode_putfh(xdr);
1395 if (status)
1396 goto out;
1397 WARN_ON(res->num_dev > PNFS_LAYOUTSTATS_MAXDEV);
1398 for (i = 0; i < res->num_dev; i++) {
1399 status = decode_layoutstats(xdr);
1400 if (status)
1401 goto out;
1402 }
1403 out:
1404 res->rpc_status = status;
1405 return status;
1406 }
1407
1408 /*
1409 * Decode CLONE request
1410 */
1411 static int nfs4_xdr_dec_clone(struct rpc_rqst *rqstp,
1412 struct xdr_stream *xdr,
1413 void *data)
1414 {
1415 struct nfs42_clone_res *res = data;
1416 struct compound_hdr hdr;
1417 int status;
1418
1419 status = decode_compound_hdr(xdr, &hdr);
1420 if (status)
1421 goto out;
1422 status = decode_sequence(xdr, &res->seq_res, rqstp);
1423 if (status)
1424 goto out;
1425 status = decode_putfh(xdr);
1426 if (status)
1427 goto out;
1428 status = decode_savefh(xdr);
1429 if (status)
1430 goto out;
1431 status = decode_putfh(xdr);
1432 if (status)
1433 goto out;
1434 status = decode_clone(xdr);
1435 if (status)
1436 goto out;
1437 status = decode_getfattr(xdr, res->dst_fattr, res->server);
1438
1439 out:
1440 res->rpc_status = status;
1441 return status;
1442 }
1443
1444 /*
1445 * Decode LAYOUTERROR request
1446 */
1447 static int nfs4_xdr_dec_layouterror(struct rpc_rqst *rqstp,
1448 struct xdr_stream *xdr,
1449 void *data)
1450 {
1451 struct nfs42_layouterror_res *res = data;
1452 struct compound_hdr hdr;
1453 int status, i;
1454
1455 status = decode_compound_hdr(xdr, &hdr);
1456 if (status)
1457 goto out;
1458 status = decode_sequence(xdr, &res->seq_res, rqstp);
1459 if (status)
1460 goto out;
1461 status = decode_putfh(xdr);
1462
1463 for (i = 0; i < res->num_errors && status == 0; i++)
1464 status = decode_layouterror(xdr);
1465 out:
1466 res->rpc_status = status;
1467 return status;
1468 }
1469
1470 #ifdef CONFIG_NFS_V4_2
1471 static void nfs4_xdr_enc_setxattr(struct rpc_rqst *req, struct xdr_stream *xdr,
1472 const void *data)
1473 {
1474 const struct nfs42_setxattrargs *args = data;
1475 struct compound_hdr hdr = {
1476 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
1477 };
1478
1479 encode_compound_hdr(xdr, req, &hdr);
1480 encode_sequence(xdr, &args->seq_args, &hdr);
1481 encode_putfh(xdr, args->fh, &hdr);
1482 encode_setxattr(xdr, args, &hdr);
1483 encode_nops(&hdr);
1484 }
1485
1486 static int nfs4_xdr_dec_setxattr(struct rpc_rqst *req, struct xdr_stream *xdr,
1487 void *data)
1488 {
1489 struct nfs42_setxattrres *res = data;
1490 struct compound_hdr hdr;
1491 int status;
1492
1493 status = decode_compound_hdr(xdr, &hdr);
1494 if (status)
1495 goto out;
1496 status = decode_sequence(xdr, &res->seq_res, req);
1497 if (status)
1498 goto out;
1499 status = decode_putfh(xdr);
1500 if (status)
1501 goto out;
1502
1503 status = decode_setxattr(xdr, &res->cinfo);
1504 out:
1505 return status;
1506 }
1507
1508 static void nfs4_xdr_enc_getxattr(struct rpc_rqst *req, struct xdr_stream *xdr,
1509 const void *data)
1510 {
1511 const struct nfs42_getxattrargs *args = data;
1512 struct compound_hdr hdr = {
1513 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
1514 };
1515 uint32_t replen;
1516
1517 encode_compound_hdr(xdr, req, &hdr);
1518 encode_sequence(xdr, &args->seq_args, &hdr);
1519 encode_putfh(xdr, args->fh, &hdr);
1520 replen = hdr.replen + op_decode_hdr_maxsz + 1;
1521 encode_getxattr(xdr, args->xattr_name, &hdr);
1522
1523 rpc_prepare_reply_pages(req, args->xattr_pages, 0, args->xattr_len,
1524 replen);
1525
1526 encode_nops(&hdr);
1527 }
1528
1529 static int nfs4_xdr_dec_getxattr(struct rpc_rqst *rqstp,
1530 struct xdr_stream *xdr, void *data)
1531 {
1532 struct nfs42_getxattrres *res = data;
1533 struct compound_hdr hdr;
1534 int status;
1535
1536 status = decode_compound_hdr(xdr, &hdr);
1537 if (status)
1538 goto out;
1539 status = decode_sequence(xdr, &res->seq_res, rqstp);
1540 if (status)
1541 goto out;
1542 status = decode_putfh(xdr);
1543 if (status)
1544 goto out;
1545 status = decode_getxattr(xdr, res, rqstp);
1546 out:
1547 return status;
1548 }
1549
1550 static void nfs4_xdr_enc_listxattrs(struct rpc_rqst *req,
1551 struct xdr_stream *xdr, const void *data)
1552 {
1553 const struct nfs42_listxattrsargs *args = data;
1554 struct compound_hdr hdr = {
1555 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
1556 };
1557 uint32_t replen;
1558
1559 encode_compound_hdr(xdr, req, &hdr);
1560 encode_sequence(xdr, &args->seq_args, &hdr);
1561 encode_putfh(xdr, args->fh, &hdr);
1562 replen = hdr.replen + op_decode_hdr_maxsz + 2 + 1;
1563 encode_listxattrs(xdr, args, &hdr);
1564
1565 rpc_prepare_reply_pages(req, args->xattr_pages, 0, args->count, replen);
1566
1567 encode_nops(&hdr);
1568 }
1569
1570 static int nfs4_xdr_dec_listxattrs(struct rpc_rqst *rqstp,
1571 struct xdr_stream *xdr, void *data)
1572 {
1573 struct nfs42_listxattrsres *res = data;
1574 struct compound_hdr hdr;
1575 int status;
1576
1577 xdr_set_scratch_page(xdr, res->scratch);
1578
1579 status = decode_compound_hdr(xdr, &hdr);
1580 if (status)
1581 goto out;
1582 status = decode_sequence(xdr, &res->seq_res, rqstp);
1583 if (status)
1584 goto out;
1585 status = decode_putfh(xdr);
1586 if (status)
1587 goto out;
1588 status = decode_listxattrs(xdr, res);
1589 out:
1590 return status;
1591 }
1592
1593 static void nfs4_xdr_enc_removexattr(struct rpc_rqst *req,
1594 struct xdr_stream *xdr, const void *data)
1595 {
1596 const struct nfs42_removexattrargs *args = data;
1597 struct compound_hdr hdr = {
1598 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
1599 };
1600
1601 encode_compound_hdr(xdr, req, &hdr);
1602 encode_sequence(xdr, &args->seq_args, &hdr);
1603 encode_putfh(xdr, args->fh, &hdr);
1604 encode_removexattr(xdr, args->xattr_name, &hdr);
1605 encode_nops(&hdr);
1606 }
1607
1608 static int nfs4_xdr_dec_removexattr(struct rpc_rqst *req,
1609 struct xdr_stream *xdr, void *data)
1610 {
1611 struct nfs42_removexattrres *res = data;
1612 struct compound_hdr hdr;
1613 int status;
1614
1615 status = decode_compound_hdr(xdr, &hdr);
1616 if (status)
1617 goto out;
1618 status = decode_sequence(xdr, &res->seq_res, req);
1619 if (status)
1620 goto out;
1621 status = decode_putfh(xdr);
1622 if (status)
1623 goto out;
1624
1625 status = decode_removexattr(xdr, &res->cinfo);
1626 out:
1627 return status;
1628 }
1629 #endif
1630 #endif /* __LINUX_FS_NFS_NFS4_2XDR_H */
Ubuntu Jammy Linux kernel mirror