Loading...
Note: File does not exist in v3.1.
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#define decode_copy_maxsz (op_decode_hdr_maxsz + \
26 NFS42_WRITE_RES_SIZE + \
27 1 /* cr_consecutive */ + \
28 1 /* cr_synchronous */)
29#define encode_offload_cancel_maxsz (op_encode_hdr_maxsz + \
30 XDR_QUADLEN(NFS4_STATEID_SIZE))
31#define decode_offload_cancel_maxsz (op_decode_hdr_maxsz)
32#define encode_deallocate_maxsz (op_encode_hdr_maxsz + \
33 encode_fallocate_maxsz)
34#define decode_deallocate_maxsz (op_decode_hdr_maxsz)
35#define encode_seek_maxsz (op_encode_hdr_maxsz + \
36 encode_stateid_maxsz + \
37 2 /* offset */ + \
38 1 /* whence */)
39#define decode_seek_maxsz (op_decode_hdr_maxsz + \
40 1 /* eof */ + \
41 1 /* whence */ + \
42 2 /* offset */ + \
43 2 /* length */)
44#define encode_io_info_maxsz 4
45#define encode_layoutstats_maxsz (op_decode_hdr_maxsz + \
46 2 /* offset */ + \
47 2 /* length */ + \
48 encode_stateid_maxsz + \
49 encode_io_info_maxsz + \
50 encode_io_info_maxsz + \
51 1 /* opaque devaddr4 length */ + \
52 XDR_QUADLEN(PNFS_LAYOUTSTATS_MAXSIZE))
53#define decode_layoutstats_maxsz (op_decode_hdr_maxsz)
54#define encode_device_error_maxsz (XDR_QUADLEN(NFS4_DEVICEID4_SIZE) + \
55 1 /* status */ + 1 /* opnum */)
56#define encode_layouterror_maxsz (op_decode_hdr_maxsz + \
57 2 /* offset */ + \
58 2 /* length */ + \
59 encode_stateid_maxsz + \
60 1 /* Array size */ + \
61 encode_device_error_maxsz)
62#define decode_layouterror_maxsz (op_decode_hdr_maxsz)
63#define encode_clone_maxsz (encode_stateid_maxsz + \
64 encode_stateid_maxsz + \
65 2 /* src offset */ + \
66 2 /* dst offset */ + \
67 2 /* count */)
68#define decode_clone_maxsz (op_decode_hdr_maxsz)
69
70#define NFS4_enc_allocate_sz (compound_encode_hdr_maxsz + \
71 encode_sequence_maxsz + \
72 encode_putfh_maxsz + \
73 encode_allocate_maxsz + \
74 encode_getattr_maxsz)
75#define NFS4_dec_allocate_sz (compound_decode_hdr_maxsz + \
76 decode_sequence_maxsz + \
77 decode_putfh_maxsz + \
78 decode_allocate_maxsz + \
79 decode_getattr_maxsz)
80#define NFS4_enc_copy_sz (compound_encode_hdr_maxsz + \
81 encode_sequence_maxsz + \
82 encode_putfh_maxsz + \
83 encode_savefh_maxsz + \
84 encode_putfh_maxsz + \
85 encode_copy_maxsz + \
86 encode_commit_maxsz)
87#define NFS4_dec_copy_sz (compound_decode_hdr_maxsz + \
88 decode_sequence_maxsz + \
89 decode_putfh_maxsz + \
90 decode_savefh_maxsz + \
91 decode_putfh_maxsz + \
92 decode_copy_maxsz + \
93 decode_commit_maxsz)
94#define NFS4_enc_offload_cancel_sz (compound_encode_hdr_maxsz + \
95 encode_sequence_maxsz + \
96 encode_putfh_maxsz + \
97 encode_offload_cancel_maxsz)
98#define NFS4_dec_offload_cancel_sz (compound_decode_hdr_maxsz + \
99 decode_sequence_maxsz + \
100 decode_putfh_maxsz + \
101 decode_offload_cancel_maxsz)
102#define NFS4_enc_deallocate_sz (compound_encode_hdr_maxsz + \
103 encode_sequence_maxsz + \
104 encode_putfh_maxsz + \
105 encode_deallocate_maxsz + \
106 encode_getattr_maxsz)
107#define NFS4_dec_deallocate_sz (compound_decode_hdr_maxsz + \
108 decode_sequence_maxsz + \
109 decode_putfh_maxsz + \
110 decode_deallocate_maxsz + \
111 decode_getattr_maxsz)
112#define NFS4_enc_seek_sz (compound_encode_hdr_maxsz + \
113 encode_sequence_maxsz + \
114 encode_putfh_maxsz + \
115 encode_seek_maxsz)
116#define NFS4_dec_seek_sz (compound_decode_hdr_maxsz + \
117 decode_sequence_maxsz + \
118 decode_putfh_maxsz + \
119 decode_seek_maxsz)
120#define NFS4_enc_layoutstats_sz (compound_encode_hdr_maxsz + \
121 encode_sequence_maxsz + \
122 encode_putfh_maxsz + \
123 PNFS_LAYOUTSTATS_MAXDEV * encode_layoutstats_maxsz)
124#define NFS4_dec_layoutstats_sz (compound_decode_hdr_maxsz + \
125 decode_sequence_maxsz + \
126 decode_putfh_maxsz + \
127 PNFS_LAYOUTSTATS_MAXDEV * decode_layoutstats_maxsz)
128#define NFS4_enc_layouterror_sz (compound_encode_hdr_maxsz + \
129 encode_sequence_maxsz + \
130 encode_putfh_maxsz + \
131 NFS42_LAYOUTERROR_MAX * \
132 encode_layouterror_maxsz)
133#define NFS4_dec_layouterror_sz (compound_decode_hdr_maxsz + \
134 decode_sequence_maxsz + \
135 decode_putfh_maxsz + \
136 NFS42_LAYOUTERROR_MAX * \
137 decode_layouterror_maxsz)
138#define NFS4_enc_clone_sz (compound_encode_hdr_maxsz + \
139 encode_sequence_maxsz + \
140 encode_putfh_maxsz + \
141 encode_savefh_maxsz + \
142 encode_putfh_maxsz + \
143 encode_clone_maxsz + \
144 encode_getattr_maxsz)
145#define NFS4_dec_clone_sz (compound_decode_hdr_maxsz + \
146 decode_sequence_maxsz + \
147 decode_putfh_maxsz + \
148 decode_savefh_maxsz + \
149 decode_putfh_maxsz + \
150 decode_clone_maxsz + \
151 decode_getattr_maxsz)
152
153static void encode_fallocate(struct xdr_stream *xdr,
154 const struct nfs42_falloc_args *args)
155{
156 encode_nfs4_stateid(xdr, &args->falloc_stateid);
157 encode_uint64(xdr, args->falloc_offset);
158 encode_uint64(xdr, args->falloc_length);
159}
160
161static void encode_allocate(struct xdr_stream *xdr,
162 const struct nfs42_falloc_args *args,
163 struct compound_hdr *hdr)
164{
165 encode_op_hdr(xdr, OP_ALLOCATE, decode_allocate_maxsz, hdr);
166 encode_fallocate(xdr, args);
167}
168
169static void encode_copy(struct xdr_stream *xdr,
170 const struct nfs42_copy_args *args,
171 struct compound_hdr *hdr)
172{
173 encode_op_hdr(xdr, OP_COPY, decode_copy_maxsz, hdr);
174 encode_nfs4_stateid(xdr, &args->src_stateid);
175 encode_nfs4_stateid(xdr, &args->dst_stateid);
176
177 encode_uint64(xdr, args->src_pos);
178 encode_uint64(xdr, args->dst_pos);
179 encode_uint64(xdr, args->count);
180
181 encode_uint32(xdr, 1); /* consecutive = true */
182 encode_uint32(xdr, args->sync);
183 encode_uint32(xdr, 0); /* src server list */
184}
185
186static void encode_offload_cancel(struct xdr_stream *xdr,
187 const struct nfs42_offload_status_args *args,
188 struct compound_hdr *hdr)
189{
190 encode_op_hdr(xdr, OP_OFFLOAD_CANCEL, decode_offload_cancel_maxsz, hdr);
191 encode_nfs4_stateid(xdr, &args->osa_stateid);
192}
193
194static void encode_deallocate(struct xdr_stream *xdr,
195 const struct nfs42_falloc_args *args,
196 struct compound_hdr *hdr)
197{
198 encode_op_hdr(xdr, OP_DEALLOCATE, decode_deallocate_maxsz, hdr);
199 encode_fallocate(xdr, args);
200}
201
202static void encode_seek(struct xdr_stream *xdr,
203 const struct nfs42_seek_args *args,
204 struct compound_hdr *hdr)
205{
206 encode_op_hdr(xdr, OP_SEEK, decode_seek_maxsz, hdr);
207 encode_nfs4_stateid(xdr, &args->sa_stateid);
208 encode_uint64(xdr, args->sa_offset);
209 encode_uint32(xdr, args->sa_what);
210}
211
212static void encode_layoutstats(struct xdr_stream *xdr,
213 const struct nfs42_layoutstat_args *args,
214 struct nfs42_layoutstat_devinfo *devinfo,
215 struct compound_hdr *hdr)
216{
217 __be32 *p;
218
219 encode_op_hdr(xdr, OP_LAYOUTSTATS, decode_layoutstats_maxsz, hdr);
220 p = reserve_space(xdr, 8 + 8);
221 p = xdr_encode_hyper(p, devinfo->offset);
222 p = xdr_encode_hyper(p, devinfo->length);
223 encode_nfs4_stateid(xdr, &args->stateid);
224 p = reserve_space(xdr, 4*8 + NFS4_DEVICEID4_SIZE + 4);
225 p = xdr_encode_hyper(p, devinfo->read_count);
226 p = xdr_encode_hyper(p, devinfo->read_bytes);
227 p = xdr_encode_hyper(p, devinfo->write_count);
228 p = xdr_encode_hyper(p, devinfo->write_bytes);
229 p = xdr_encode_opaque_fixed(p, devinfo->dev_id.data,
230 NFS4_DEVICEID4_SIZE);
231 /* Encode layoutupdate4 */
232 *p++ = cpu_to_be32(devinfo->layout_type);
233 if (devinfo->ld_private.ops)
234 devinfo->ld_private.ops->encode(xdr, args,
235 &devinfo->ld_private);
236 else
237 encode_uint32(xdr, 0);
238}
239
240static void encode_clone(struct xdr_stream *xdr,
241 const struct nfs42_clone_args *args,
242 struct compound_hdr *hdr)
243{
244 __be32 *p;
245
246 encode_op_hdr(xdr, OP_CLONE, decode_clone_maxsz, hdr);
247 encode_nfs4_stateid(xdr, &args->src_stateid);
248 encode_nfs4_stateid(xdr, &args->dst_stateid);
249 p = reserve_space(xdr, 3*8);
250 p = xdr_encode_hyper(p, args->src_offset);
251 p = xdr_encode_hyper(p, args->dst_offset);
252 xdr_encode_hyper(p, args->count);
253}
254
255static void encode_device_error(struct xdr_stream *xdr,
256 const struct nfs42_device_error *error)
257{
258 __be32 *p;
259
260 p = reserve_space(xdr, NFS4_DEVICEID4_SIZE + 2*4);
261 p = xdr_encode_opaque_fixed(p, error->dev_id.data,
262 NFS4_DEVICEID4_SIZE);
263 *p++ = cpu_to_be32(error->status);
264 *p = cpu_to_be32(error->opnum);
265}
266
267static void encode_layouterror(struct xdr_stream *xdr,
268 const struct nfs42_layout_error *args,
269 struct compound_hdr *hdr)
270{
271 __be32 *p;
272
273 encode_op_hdr(xdr, OP_LAYOUTERROR, decode_layouterror_maxsz, hdr);
274 p = reserve_space(xdr, 8 + 8);
275 p = xdr_encode_hyper(p, args->offset);
276 p = xdr_encode_hyper(p, args->length);
277 encode_nfs4_stateid(xdr, &args->stateid);
278 p = reserve_space(xdr, 4);
279 *p = cpu_to_be32(1);
280 encode_device_error(xdr, &args->errors[0]);
281}
282
283/*
284 * Encode ALLOCATE request
285 */
286static void nfs4_xdr_enc_allocate(struct rpc_rqst *req,
287 struct xdr_stream *xdr,
288 const void *data)
289{
290 const struct nfs42_falloc_args *args = data;
291 struct compound_hdr hdr = {
292 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
293 };
294
295 encode_compound_hdr(xdr, req, &hdr);
296 encode_sequence(xdr, &args->seq_args, &hdr);
297 encode_putfh(xdr, args->falloc_fh, &hdr);
298 encode_allocate(xdr, args, &hdr);
299 encode_getfattr(xdr, args->falloc_bitmask, &hdr);
300 encode_nops(&hdr);
301}
302
303static void encode_copy_commit(struct xdr_stream *xdr,
304 const struct nfs42_copy_args *args,
305 struct compound_hdr *hdr)
306{
307 __be32 *p;
308
309 encode_op_hdr(xdr, OP_COMMIT, decode_commit_maxsz, hdr);
310 p = reserve_space(xdr, 12);
311 p = xdr_encode_hyper(p, args->dst_pos);
312 *p = cpu_to_be32(args->count);
313}
314
315/*
316 * Encode COPY request
317 */
318static void nfs4_xdr_enc_copy(struct rpc_rqst *req,
319 struct xdr_stream *xdr,
320 const void *data)
321{
322 const struct nfs42_copy_args *args = data;
323 struct compound_hdr hdr = {
324 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
325 };
326
327 encode_compound_hdr(xdr, req, &hdr);
328 encode_sequence(xdr, &args->seq_args, &hdr);
329 encode_putfh(xdr, args->src_fh, &hdr);
330 encode_savefh(xdr, &hdr);
331 encode_putfh(xdr, args->dst_fh, &hdr);
332 encode_copy(xdr, args, &hdr);
333 if (args->sync)
334 encode_copy_commit(xdr, args, &hdr);
335 encode_nops(&hdr);
336}
337
338/*
339 * Encode OFFLOAD_CANEL request
340 */
341static void nfs4_xdr_enc_offload_cancel(struct rpc_rqst *req,
342 struct xdr_stream *xdr,
343 const void *data)
344{
345 const struct nfs42_offload_status_args *args = data;
346 struct compound_hdr hdr = {
347 .minorversion = nfs4_xdr_minorversion(&args->osa_seq_args),
348 };
349
350 encode_compound_hdr(xdr, req, &hdr);
351 encode_sequence(xdr, &args->osa_seq_args, &hdr);
352 encode_putfh(xdr, args->osa_src_fh, &hdr);
353 encode_offload_cancel(xdr, args, &hdr);
354 encode_nops(&hdr);
355}
356
357/*
358 * Encode DEALLOCATE request
359 */
360static void nfs4_xdr_enc_deallocate(struct rpc_rqst *req,
361 struct xdr_stream *xdr,
362 const void *data)
363{
364 const struct nfs42_falloc_args *args = data;
365 struct compound_hdr hdr = {
366 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
367 };
368
369 encode_compound_hdr(xdr, req, &hdr);
370 encode_sequence(xdr, &args->seq_args, &hdr);
371 encode_putfh(xdr, args->falloc_fh, &hdr);
372 encode_deallocate(xdr, args, &hdr);
373 encode_getfattr(xdr, args->falloc_bitmask, &hdr);
374 encode_nops(&hdr);
375}
376
377/*
378 * Encode SEEK request
379 */
380static void nfs4_xdr_enc_seek(struct rpc_rqst *req,
381 struct xdr_stream *xdr,
382 const void *data)
383{
384 const struct nfs42_seek_args *args = data;
385 struct compound_hdr hdr = {
386 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
387 };
388
389 encode_compound_hdr(xdr, req, &hdr);
390 encode_sequence(xdr, &args->seq_args, &hdr);
391 encode_putfh(xdr, args->sa_fh, &hdr);
392 encode_seek(xdr, args, &hdr);
393 encode_nops(&hdr);
394}
395
396/*
397 * Encode LAYOUTSTATS request
398 */
399static void nfs4_xdr_enc_layoutstats(struct rpc_rqst *req,
400 struct xdr_stream *xdr,
401 const void *data)
402{
403 const struct nfs42_layoutstat_args *args = data;
404 int i;
405
406 struct compound_hdr hdr = {
407 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
408 };
409
410 encode_compound_hdr(xdr, req, &hdr);
411 encode_sequence(xdr, &args->seq_args, &hdr);
412 encode_putfh(xdr, args->fh, &hdr);
413 WARN_ON(args->num_dev > PNFS_LAYOUTSTATS_MAXDEV);
414 for (i = 0; i < args->num_dev; i++)
415 encode_layoutstats(xdr, args, &args->devinfo[i], &hdr);
416 encode_nops(&hdr);
417}
418
419/*
420 * Encode CLONE request
421 */
422static void nfs4_xdr_enc_clone(struct rpc_rqst *req,
423 struct xdr_stream *xdr,
424 const void *data)
425{
426 const struct nfs42_clone_args *args = data;
427 struct compound_hdr hdr = {
428 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
429 };
430
431 encode_compound_hdr(xdr, req, &hdr);
432 encode_sequence(xdr, &args->seq_args, &hdr);
433 encode_putfh(xdr, args->src_fh, &hdr);
434 encode_savefh(xdr, &hdr);
435 encode_putfh(xdr, args->dst_fh, &hdr);
436 encode_clone(xdr, args, &hdr);
437 encode_getfattr(xdr, args->dst_bitmask, &hdr);
438 encode_nops(&hdr);
439}
440
441/*
442 * Encode LAYOUTERROR request
443 */
444static void nfs4_xdr_enc_layouterror(struct rpc_rqst *req,
445 struct xdr_stream *xdr,
446 const void *data)
447{
448 const struct nfs42_layouterror_args *args = data;
449 struct compound_hdr hdr = {
450 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
451 };
452 int i;
453
454 encode_compound_hdr(xdr, req, &hdr);
455 encode_sequence(xdr, &args->seq_args, &hdr);
456 encode_putfh(xdr, NFS_FH(args->inode), &hdr);
457 for (i = 0; i < args->num_errors; i++)
458 encode_layouterror(xdr, &args->errors[i], &hdr);
459 encode_nops(&hdr);
460}
461
462static int decode_allocate(struct xdr_stream *xdr, struct nfs42_falloc_res *res)
463{
464 return decode_op_hdr(xdr, OP_ALLOCATE);
465}
466
467static int decode_write_response(struct xdr_stream *xdr,
468 struct nfs42_write_res *res)
469{
470 __be32 *p;
471 int status, count;
472
473 p = xdr_inline_decode(xdr, 4);
474 if (unlikely(!p))
475 return -EIO;
476 count = be32_to_cpup(p);
477 if (count > 1)
478 return -EREMOTEIO;
479 else if (count == 1) {
480 status = decode_opaque_fixed(xdr, &res->stateid,
481 NFS4_STATEID_SIZE);
482 if (unlikely(status))
483 return -EIO;
484 }
485 p = xdr_inline_decode(xdr, 8 + 4);
486 if (unlikely(!p))
487 return -EIO;
488 p = xdr_decode_hyper(p, &res->count);
489 res->verifier.committed = be32_to_cpup(p);
490 return decode_verifier(xdr, &res->verifier.verifier);
491}
492
493static int decode_copy_requirements(struct xdr_stream *xdr,
494 struct nfs42_copy_res *res) {
495 __be32 *p;
496
497 p = xdr_inline_decode(xdr, 4 + 4);
498 if (unlikely(!p))
499 return -EIO;
500
501 res->consecutive = be32_to_cpup(p++);
502 res->synchronous = be32_to_cpup(p++);
503 return 0;
504}
505
506static int decode_copy(struct xdr_stream *xdr, struct nfs42_copy_res *res)
507{
508 int status;
509
510 status = decode_op_hdr(xdr, OP_COPY);
511 if (status == NFS4ERR_OFFLOAD_NO_REQS) {
512 status = decode_copy_requirements(xdr, res);
513 if (status)
514 return status;
515 return NFS4ERR_OFFLOAD_NO_REQS;
516 } else if (status)
517 return status;
518
519 status = decode_write_response(xdr, &res->write_res);
520 if (status)
521 return status;
522
523 return decode_copy_requirements(xdr, res);
524}
525
526static int decode_offload_cancel(struct xdr_stream *xdr,
527 struct nfs42_offload_status_res *res)
528{
529 return decode_op_hdr(xdr, OP_OFFLOAD_CANCEL);
530}
531
532static int decode_deallocate(struct xdr_stream *xdr, struct nfs42_falloc_res *res)
533{
534 return decode_op_hdr(xdr, OP_DEALLOCATE);
535}
536
537static int decode_seek(struct xdr_stream *xdr, struct nfs42_seek_res *res)
538{
539 int status;
540 __be32 *p;
541
542 status = decode_op_hdr(xdr, OP_SEEK);
543 if (status)
544 return status;
545
546 p = xdr_inline_decode(xdr, 4 + 8);
547 if (unlikely(!p))
548 return -EIO;
549
550 res->sr_eof = be32_to_cpup(p++);
551 p = xdr_decode_hyper(p, &res->sr_offset);
552 return 0;
553}
554
555static int decode_layoutstats(struct xdr_stream *xdr)
556{
557 return decode_op_hdr(xdr, OP_LAYOUTSTATS);
558}
559
560static int decode_clone(struct xdr_stream *xdr)
561{
562 return decode_op_hdr(xdr, OP_CLONE);
563}
564
565static int decode_layouterror(struct xdr_stream *xdr)
566{
567 return decode_op_hdr(xdr, OP_LAYOUTERROR);
568}
569
570/*
571 * Decode ALLOCATE request
572 */
573static int nfs4_xdr_dec_allocate(struct rpc_rqst *rqstp,
574 struct xdr_stream *xdr,
575 void *data)
576{
577 struct nfs42_falloc_res *res = data;
578 struct compound_hdr hdr;
579 int status;
580
581 status = decode_compound_hdr(xdr, &hdr);
582 if (status)
583 goto out;
584 status = decode_sequence(xdr, &res->seq_res, rqstp);
585 if (status)
586 goto out;
587 status = decode_putfh(xdr);
588 if (status)
589 goto out;
590 status = decode_allocate(xdr, res);
591 if (status)
592 goto out;
593 decode_getfattr(xdr, res->falloc_fattr, res->falloc_server);
594out:
595 return status;
596}
597
598/*
599 * Decode COPY response
600 */
601static int nfs4_xdr_dec_copy(struct rpc_rqst *rqstp,
602 struct xdr_stream *xdr,
603 void *data)
604{
605 struct nfs42_copy_res *res = data;
606 struct compound_hdr hdr;
607 int status;
608
609 status = decode_compound_hdr(xdr, &hdr);
610 if (status)
611 goto out;
612 status = decode_sequence(xdr, &res->seq_res, rqstp);
613 if (status)
614 goto out;
615 status = decode_putfh(xdr);
616 if (status)
617 goto out;
618 status = decode_savefh(xdr);
619 if (status)
620 goto out;
621 status = decode_putfh(xdr);
622 if (status)
623 goto out;
624 status = decode_copy(xdr, res);
625 if (status)
626 goto out;
627 if (res->commit_res.verf)
628 status = decode_commit(xdr, &res->commit_res);
629out:
630 return status;
631}
632
633/*
634 * Decode OFFLOAD_CANCEL response
635 */
636static int nfs4_xdr_dec_offload_cancel(struct rpc_rqst *rqstp,
637 struct xdr_stream *xdr,
638 void *data)
639{
640 struct nfs42_offload_status_res *res = data;
641 struct compound_hdr hdr;
642 int status;
643
644 status = decode_compound_hdr(xdr, &hdr);
645 if (status)
646 goto out;
647 status = decode_sequence(xdr, &res->osr_seq_res, rqstp);
648 if (status)
649 goto out;
650 status = decode_putfh(xdr);
651 if (status)
652 goto out;
653 status = decode_offload_cancel(xdr, res);
654
655out:
656 return status;
657}
658
659/*
660 * Decode DEALLOCATE request
661 */
662static int nfs4_xdr_dec_deallocate(struct rpc_rqst *rqstp,
663 struct xdr_stream *xdr,
664 void *data)
665{
666 struct nfs42_falloc_res *res = data;
667 struct compound_hdr hdr;
668 int status;
669
670 status = decode_compound_hdr(xdr, &hdr);
671 if (status)
672 goto out;
673 status = decode_sequence(xdr, &res->seq_res, rqstp);
674 if (status)
675 goto out;
676 status = decode_putfh(xdr);
677 if (status)
678 goto out;
679 status = decode_deallocate(xdr, res);
680 if (status)
681 goto out;
682 decode_getfattr(xdr, res->falloc_fattr, res->falloc_server);
683out:
684 return status;
685}
686
687/*
688 * Decode SEEK request
689 */
690static int nfs4_xdr_dec_seek(struct rpc_rqst *rqstp,
691 struct xdr_stream *xdr,
692 void *data)
693{
694 struct nfs42_seek_res *res = data;
695 struct compound_hdr hdr;
696 int status;
697
698 status = decode_compound_hdr(xdr, &hdr);
699 if (status)
700 goto out;
701 status = decode_sequence(xdr, &res->seq_res, rqstp);
702 if (status)
703 goto out;
704 status = decode_putfh(xdr);
705 if (status)
706 goto out;
707 status = decode_seek(xdr, res);
708out:
709 return status;
710}
711
712/*
713 * Decode LAYOUTSTATS request
714 */
715static int nfs4_xdr_dec_layoutstats(struct rpc_rqst *rqstp,
716 struct xdr_stream *xdr,
717 void *data)
718{
719 struct nfs42_layoutstat_res *res = data;
720 struct compound_hdr hdr;
721 int status, i;
722
723 status = decode_compound_hdr(xdr, &hdr);
724 if (status)
725 goto out;
726 status = decode_sequence(xdr, &res->seq_res, rqstp);
727 if (status)
728 goto out;
729 status = decode_putfh(xdr);
730 if (status)
731 goto out;
732 WARN_ON(res->num_dev > PNFS_LAYOUTSTATS_MAXDEV);
733 for (i = 0; i < res->num_dev; i++) {
734 status = decode_layoutstats(xdr);
735 if (status)
736 goto out;
737 }
738out:
739 res->rpc_status = status;
740 return status;
741}
742
743/*
744 * Decode CLONE request
745 */
746static int nfs4_xdr_dec_clone(struct rpc_rqst *rqstp,
747 struct xdr_stream *xdr,
748 void *data)
749{
750 struct nfs42_clone_res *res = data;
751 struct compound_hdr hdr;
752 int status;
753
754 status = decode_compound_hdr(xdr, &hdr);
755 if (status)
756 goto out;
757 status = decode_sequence(xdr, &res->seq_res, rqstp);
758 if (status)
759 goto out;
760 status = decode_putfh(xdr);
761 if (status)
762 goto out;
763 status = decode_savefh(xdr);
764 if (status)
765 goto out;
766 status = decode_putfh(xdr);
767 if (status)
768 goto out;
769 status = decode_clone(xdr);
770 if (status)
771 goto out;
772 status = decode_getfattr(xdr, res->dst_fattr, res->server);
773
774out:
775 res->rpc_status = status;
776 return status;
777}
778
779/*
780 * Decode LAYOUTERROR request
781 */
782static int nfs4_xdr_dec_layouterror(struct rpc_rqst *rqstp,
783 struct xdr_stream *xdr,
784 void *data)
785{
786 struct nfs42_layouterror_res *res = data;
787 struct compound_hdr hdr;
788 int status, i;
789
790 status = decode_compound_hdr(xdr, &hdr);
791 if (status)
792 goto out;
793 status = decode_sequence(xdr, &res->seq_res, rqstp);
794 if (status)
795 goto out;
796 status = decode_putfh(xdr);
797
798 for (i = 0; i < res->num_errors && status == 0; i++)
799 status = decode_layouterror(xdr);
800out:
801 res->rpc_status = status;
802 return status;
803}
804
805#endif /* __LINUX_FS_NFS_NFS4_2XDR_H */