Loading...
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_deallocate_maxsz (op_encode_hdr_maxsz + \
30 encode_fallocate_maxsz)
31#define decode_deallocate_maxsz (op_decode_hdr_maxsz)
32#define encode_seek_maxsz (op_encode_hdr_maxsz + \
33 encode_stateid_maxsz + \
34 2 /* offset */ + \
35 1 /* whence */)
36#define decode_seek_maxsz (op_decode_hdr_maxsz + \
37 1 /* eof */ + \
38 1 /* whence */ + \
39 2 /* offset */ + \
40 2 /* length */)
41#define encode_io_info_maxsz 4
42#define encode_layoutstats_maxsz (op_decode_hdr_maxsz + \
43 2 /* offset */ + \
44 2 /* length */ + \
45 encode_stateid_maxsz + \
46 encode_io_info_maxsz + \
47 encode_io_info_maxsz + \
48 1 /* opaque devaddr4 length */ + \
49 XDR_QUADLEN(PNFS_LAYOUTSTATS_MAXSIZE))
50#define decode_layoutstats_maxsz (op_decode_hdr_maxsz)
51#define encode_clone_maxsz (encode_stateid_maxsz + \
52 encode_stateid_maxsz + \
53 2 /* src offset */ + \
54 2 /* dst offset */ + \
55 2 /* count */)
56#define decode_clone_maxsz (op_decode_hdr_maxsz)
57
58#define NFS4_enc_allocate_sz (compound_encode_hdr_maxsz + \
59 encode_putfh_maxsz + \
60 encode_allocate_maxsz + \
61 encode_getattr_maxsz)
62#define NFS4_dec_allocate_sz (compound_decode_hdr_maxsz + \
63 decode_putfh_maxsz + \
64 decode_allocate_maxsz + \
65 decode_getattr_maxsz)
66#define NFS4_enc_copy_sz (compound_encode_hdr_maxsz + \
67 encode_putfh_maxsz + \
68 encode_savefh_maxsz + \
69 encode_putfh_maxsz + \
70 encode_copy_maxsz + \
71 encode_commit_maxsz)
72#define NFS4_dec_copy_sz (compound_decode_hdr_maxsz + \
73 decode_putfh_maxsz + \
74 decode_savefh_maxsz + \
75 decode_putfh_maxsz + \
76 decode_copy_maxsz + \
77 decode_commit_maxsz)
78#define NFS4_enc_deallocate_sz (compound_encode_hdr_maxsz + \
79 encode_putfh_maxsz + \
80 encode_deallocate_maxsz + \
81 encode_getattr_maxsz)
82#define NFS4_dec_deallocate_sz (compound_decode_hdr_maxsz + \
83 decode_putfh_maxsz + \
84 decode_deallocate_maxsz + \
85 decode_getattr_maxsz)
86#define NFS4_enc_seek_sz (compound_encode_hdr_maxsz + \
87 encode_putfh_maxsz + \
88 encode_seek_maxsz)
89#define NFS4_dec_seek_sz (compound_decode_hdr_maxsz + \
90 decode_putfh_maxsz + \
91 decode_seek_maxsz)
92#define NFS4_enc_layoutstats_sz (compound_encode_hdr_maxsz + \
93 encode_sequence_maxsz + \
94 encode_putfh_maxsz + \
95 PNFS_LAYOUTSTATS_MAXDEV * encode_layoutstats_maxsz)
96#define NFS4_dec_layoutstats_sz (compound_decode_hdr_maxsz + \
97 decode_sequence_maxsz + \
98 decode_putfh_maxsz + \
99 PNFS_LAYOUTSTATS_MAXDEV * decode_layoutstats_maxsz)
100#define NFS4_enc_clone_sz (compound_encode_hdr_maxsz + \
101 encode_sequence_maxsz + \
102 encode_putfh_maxsz + \
103 encode_savefh_maxsz + \
104 encode_putfh_maxsz + \
105 encode_clone_maxsz + \
106 encode_getattr_maxsz)
107#define NFS4_dec_clone_sz (compound_decode_hdr_maxsz + \
108 decode_sequence_maxsz + \
109 decode_putfh_maxsz + \
110 decode_savefh_maxsz + \
111 decode_putfh_maxsz + \
112 decode_clone_maxsz + \
113 decode_getattr_maxsz)
114
115static void encode_fallocate(struct xdr_stream *xdr,
116 const struct nfs42_falloc_args *args)
117{
118 encode_nfs4_stateid(xdr, &args->falloc_stateid);
119 encode_uint64(xdr, args->falloc_offset);
120 encode_uint64(xdr, args->falloc_length);
121}
122
123static void encode_allocate(struct xdr_stream *xdr,
124 const struct nfs42_falloc_args *args,
125 struct compound_hdr *hdr)
126{
127 encode_op_hdr(xdr, OP_ALLOCATE, decode_allocate_maxsz, hdr);
128 encode_fallocate(xdr, args);
129}
130
131static void encode_copy(struct xdr_stream *xdr,
132 const struct nfs42_copy_args *args,
133 struct compound_hdr *hdr)
134{
135 encode_op_hdr(xdr, OP_COPY, decode_copy_maxsz, hdr);
136 encode_nfs4_stateid(xdr, &args->src_stateid);
137 encode_nfs4_stateid(xdr, &args->dst_stateid);
138
139 encode_uint64(xdr, args->src_pos);
140 encode_uint64(xdr, args->dst_pos);
141 encode_uint64(xdr, args->count);
142
143 encode_uint32(xdr, 1); /* consecutive = true */
144 encode_uint32(xdr, 1); /* synchronous = true */
145 encode_uint32(xdr, 0); /* src server list */
146}
147
148static void encode_deallocate(struct xdr_stream *xdr,
149 const struct nfs42_falloc_args *args,
150 struct compound_hdr *hdr)
151{
152 encode_op_hdr(xdr, OP_DEALLOCATE, decode_deallocate_maxsz, hdr);
153 encode_fallocate(xdr, args);
154}
155
156static void encode_seek(struct xdr_stream *xdr,
157 const struct nfs42_seek_args *args,
158 struct compound_hdr *hdr)
159{
160 encode_op_hdr(xdr, OP_SEEK, decode_seek_maxsz, hdr);
161 encode_nfs4_stateid(xdr, &args->sa_stateid);
162 encode_uint64(xdr, args->sa_offset);
163 encode_uint32(xdr, args->sa_what);
164}
165
166static void encode_layoutstats(struct xdr_stream *xdr,
167 const struct nfs42_layoutstat_args *args,
168 struct nfs42_layoutstat_devinfo *devinfo,
169 struct compound_hdr *hdr)
170{
171 __be32 *p;
172
173 encode_op_hdr(xdr, OP_LAYOUTSTATS, decode_layoutstats_maxsz, hdr);
174 p = reserve_space(xdr, 8 + 8);
175 p = xdr_encode_hyper(p, devinfo->offset);
176 p = xdr_encode_hyper(p, devinfo->length);
177 encode_nfs4_stateid(xdr, &args->stateid);
178 p = reserve_space(xdr, 4*8 + NFS4_DEVICEID4_SIZE + 4);
179 p = xdr_encode_hyper(p, devinfo->read_count);
180 p = xdr_encode_hyper(p, devinfo->read_bytes);
181 p = xdr_encode_hyper(p, devinfo->write_count);
182 p = xdr_encode_hyper(p, devinfo->write_bytes);
183 p = xdr_encode_opaque_fixed(p, devinfo->dev_id.data,
184 NFS4_DEVICEID4_SIZE);
185 /* Encode layoutupdate4 */
186 *p++ = cpu_to_be32(devinfo->layout_type);
187 if (devinfo->ld_private.ops)
188 devinfo->ld_private.ops->encode(xdr, args,
189 &devinfo->ld_private);
190 else
191 encode_uint32(xdr, 0);
192}
193
194static void encode_clone(struct xdr_stream *xdr,
195 const struct nfs42_clone_args *args,
196 struct compound_hdr *hdr)
197{
198 __be32 *p;
199
200 encode_op_hdr(xdr, OP_CLONE, decode_clone_maxsz, hdr);
201 encode_nfs4_stateid(xdr, &args->src_stateid);
202 encode_nfs4_stateid(xdr, &args->dst_stateid);
203 p = reserve_space(xdr, 3*8);
204 p = xdr_encode_hyper(p, args->src_offset);
205 p = xdr_encode_hyper(p, args->dst_offset);
206 xdr_encode_hyper(p, args->count);
207}
208
209/*
210 * Encode ALLOCATE request
211 */
212static void nfs4_xdr_enc_allocate(struct rpc_rqst *req,
213 struct xdr_stream *xdr,
214 const void *data)
215{
216 const struct nfs42_falloc_args *args = data;
217 struct compound_hdr hdr = {
218 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
219 };
220
221 encode_compound_hdr(xdr, req, &hdr);
222 encode_sequence(xdr, &args->seq_args, &hdr);
223 encode_putfh(xdr, args->falloc_fh, &hdr);
224 encode_allocate(xdr, args, &hdr);
225 encode_getfattr(xdr, args->falloc_bitmask, &hdr);
226 encode_nops(&hdr);
227}
228
229static void encode_copy_commit(struct xdr_stream *xdr,
230 const struct nfs42_copy_args *args,
231 struct compound_hdr *hdr)
232{
233 __be32 *p;
234
235 encode_op_hdr(xdr, OP_COMMIT, decode_commit_maxsz, hdr);
236 p = reserve_space(xdr, 12);
237 p = xdr_encode_hyper(p, args->dst_pos);
238 *p = cpu_to_be32(args->count);
239}
240
241/*
242 * Encode COPY request
243 */
244static void nfs4_xdr_enc_copy(struct rpc_rqst *req,
245 struct xdr_stream *xdr,
246 const void *data)
247{
248 const struct nfs42_copy_args *args = data;
249 struct compound_hdr hdr = {
250 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
251 };
252
253 encode_compound_hdr(xdr, req, &hdr);
254 encode_sequence(xdr, &args->seq_args, &hdr);
255 encode_putfh(xdr, args->src_fh, &hdr);
256 encode_savefh(xdr, &hdr);
257 encode_putfh(xdr, args->dst_fh, &hdr);
258 encode_copy(xdr, args, &hdr);
259 encode_copy_commit(xdr, args, &hdr);
260 encode_nops(&hdr);
261}
262
263/*
264 * Encode DEALLOCATE request
265 */
266static void nfs4_xdr_enc_deallocate(struct rpc_rqst *req,
267 struct xdr_stream *xdr,
268 const void *data)
269{
270 const struct nfs42_falloc_args *args = data;
271 struct compound_hdr hdr = {
272 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
273 };
274
275 encode_compound_hdr(xdr, req, &hdr);
276 encode_sequence(xdr, &args->seq_args, &hdr);
277 encode_putfh(xdr, args->falloc_fh, &hdr);
278 encode_deallocate(xdr, args, &hdr);
279 encode_getfattr(xdr, args->falloc_bitmask, &hdr);
280 encode_nops(&hdr);
281}
282
283/*
284 * Encode SEEK request
285 */
286static void nfs4_xdr_enc_seek(struct rpc_rqst *req,
287 struct xdr_stream *xdr,
288 const void *data)
289{
290 const struct nfs42_seek_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->sa_fh, &hdr);
298 encode_seek(xdr, args, &hdr);
299 encode_nops(&hdr);
300}
301
302/*
303 * Encode LAYOUTSTATS request
304 */
305static void nfs4_xdr_enc_layoutstats(struct rpc_rqst *req,
306 struct xdr_stream *xdr,
307 const void *data)
308{
309 const struct nfs42_layoutstat_args *args = data;
310 int i;
311
312 struct compound_hdr hdr = {
313 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
314 };
315
316 encode_compound_hdr(xdr, req, &hdr);
317 encode_sequence(xdr, &args->seq_args, &hdr);
318 encode_putfh(xdr, args->fh, &hdr);
319 WARN_ON(args->num_dev > PNFS_LAYOUTSTATS_MAXDEV);
320 for (i = 0; i < args->num_dev; i++)
321 encode_layoutstats(xdr, args, &args->devinfo[i], &hdr);
322 encode_nops(&hdr);
323}
324
325/*
326 * Encode CLONE request
327 */
328static void nfs4_xdr_enc_clone(struct rpc_rqst *req,
329 struct xdr_stream *xdr,
330 const void *data)
331{
332 const struct nfs42_clone_args *args = data;
333 struct compound_hdr hdr = {
334 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
335 };
336
337 encode_compound_hdr(xdr, req, &hdr);
338 encode_sequence(xdr, &args->seq_args, &hdr);
339 encode_putfh(xdr, args->src_fh, &hdr);
340 encode_savefh(xdr, &hdr);
341 encode_putfh(xdr, args->dst_fh, &hdr);
342 encode_clone(xdr, args, &hdr);
343 encode_getfattr(xdr, args->dst_bitmask, &hdr);
344 encode_nops(&hdr);
345}
346
347static int decode_allocate(struct xdr_stream *xdr, struct nfs42_falloc_res *res)
348{
349 return decode_op_hdr(xdr, OP_ALLOCATE);
350}
351
352static int decode_write_response(struct xdr_stream *xdr,
353 struct nfs42_write_res *res)
354{
355 __be32 *p;
356
357 p = xdr_inline_decode(xdr, 4 + 8 + 4);
358 if (unlikely(!p))
359 goto out_overflow;
360
361 /*
362 * We never use asynchronous mode, so warn if a server returns
363 * a stateid.
364 */
365 if (unlikely(*p != 0)) {
366 pr_err_once("%s: server has set unrequested "
367 "asynchronous mode\n", __func__);
368 return -EREMOTEIO;
369 }
370 p++;
371 p = xdr_decode_hyper(p, &res->count);
372 res->verifier.committed = be32_to_cpup(p);
373 return decode_verifier(xdr, &res->verifier.verifier);
374
375out_overflow:
376 print_overflow_msg(__func__, xdr);
377 return -EIO;
378}
379
380static int decode_copy_requirements(struct xdr_stream *xdr,
381 struct nfs42_copy_res *res) {
382 __be32 *p;
383
384 p = xdr_inline_decode(xdr, 4 + 4);
385 if (unlikely(!p))
386 goto out_overflow;
387
388 res->consecutive = be32_to_cpup(p++);
389 res->synchronous = be32_to_cpup(p++);
390 return 0;
391out_overflow:
392 print_overflow_msg(__func__, xdr);
393 return -EIO;
394}
395
396static int decode_copy(struct xdr_stream *xdr, struct nfs42_copy_res *res)
397{
398 int status;
399
400 status = decode_op_hdr(xdr, OP_COPY);
401 if (status == NFS4ERR_OFFLOAD_NO_REQS) {
402 status = decode_copy_requirements(xdr, res);
403 if (status)
404 return status;
405 return NFS4ERR_OFFLOAD_NO_REQS;
406 } else if (status)
407 return status;
408
409 status = decode_write_response(xdr, &res->write_res);
410 if (status)
411 return status;
412
413 return decode_copy_requirements(xdr, res);
414}
415
416static int decode_deallocate(struct xdr_stream *xdr, struct nfs42_falloc_res *res)
417{
418 return decode_op_hdr(xdr, OP_DEALLOCATE);
419}
420
421static int decode_seek(struct xdr_stream *xdr, struct nfs42_seek_res *res)
422{
423 int status;
424 __be32 *p;
425
426 status = decode_op_hdr(xdr, OP_SEEK);
427 if (status)
428 return status;
429
430 p = xdr_inline_decode(xdr, 4 + 8);
431 if (unlikely(!p))
432 goto out_overflow;
433
434 res->sr_eof = be32_to_cpup(p++);
435 p = xdr_decode_hyper(p, &res->sr_offset);
436 return 0;
437
438out_overflow:
439 print_overflow_msg(__func__, xdr);
440 return -EIO;
441}
442
443static int decode_layoutstats(struct xdr_stream *xdr)
444{
445 return decode_op_hdr(xdr, OP_LAYOUTSTATS);
446}
447
448static int decode_clone(struct xdr_stream *xdr)
449{
450 return decode_op_hdr(xdr, OP_CLONE);
451}
452
453/*
454 * Decode ALLOCATE request
455 */
456static int nfs4_xdr_dec_allocate(struct rpc_rqst *rqstp,
457 struct xdr_stream *xdr,
458 void *data)
459{
460 struct nfs42_falloc_res *res = data;
461 struct compound_hdr hdr;
462 int status;
463
464 status = decode_compound_hdr(xdr, &hdr);
465 if (status)
466 goto out;
467 status = decode_sequence(xdr, &res->seq_res, rqstp);
468 if (status)
469 goto out;
470 status = decode_putfh(xdr);
471 if (status)
472 goto out;
473 status = decode_allocate(xdr, res);
474 if (status)
475 goto out;
476 decode_getfattr(xdr, res->falloc_fattr, res->falloc_server);
477out:
478 return status;
479}
480
481/*
482 * Decode COPY response
483 */
484static int nfs4_xdr_dec_copy(struct rpc_rqst *rqstp,
485 struct xdr_stream *xdr,
486 void *data)
487{
488 struct nfs42_copy_res *res = data;
489 struct compound_hdr hdr;
490 int status;
491
492 status = decode_compound_hdr(xdr, &hdr);
493 if (status)
494 goto out;
495 status = decode_sequence(xdr, &res->seq_res, rqstp);
496 if (status)
497 goto out;
498 status = decode_putfh(xdr);
499 if (status)
500 goto out;
501 status = decode_savefh(xdr);
502 if (status)
503 goto out;
504 status = decode_putfh(xdr);
505 if (status)
506 goto out;
507 status = decode_copy(xdr, res);
508 if (status)
509 goto out;
510 status = decode_commit(xdr, &res->commit_res);
511out:
512 return status;
513}
514
515/*
516 * Decode DEALLOCATE request
517 */
518static int nfs4_xdr_dec_deallocate(struct rpc_rqst *rqstp,
519 struct xdr_stream *xdr,
520 void *data)
521{
522 struct nfs42_falloc_res *res = data;
523 struct compound_hdr hdr;
524 int status;
525
526 status = decode_compound_hdr(xdr, &hdr);
527 if (status)
528 goto out;
529 status = decode_sequence(xdr, &res->seq_res, rqstp);
530 if (status)
531 goto out;
532 status = decode_putfh(xdr);
533 if (status)
534 goto out;
535 status = decode_deallocate(xdr, res);
536 if (status)
537 goto out;
538 decode_getfattr(xdr, res->falloc_fattr, res->falloc_server);
539out:
540 return status;
541}
542
543/*
544 * Decode SEEK request
545 */
546static int nfs4_xdr_dec_seek(struct rpc_rqst *rqstp,
547 struct xdr_stream *xdr,
548 void *data)
549{
550 struct nfs42_seek_res *res = data;
551 struct compound_hdr hdr;
552 int status;
553
554 status = decode_compound_hdr(xdr, &hdr);
555 if (status)
556 goto out;
557 status = decode_sequence(xdr, &res->seq_res, rqstp);
558 if (status)
559 goto out;
560 status = decode_putfh(xdr);
561 if (status)
562 goto out;
563 status = decode_seek(xdr, res);
564out:
565 return status;
566}
567
568/*
569 * Decode LAYOUTSTATS request
570 */
571static int nfs4_xdr_dec_layoutstats(struct rpc_rqst *rqstp,
572 struct xdr_stream *xdr,
573 void *data)
574{
575 struct nfs42_layoutstat_res *res = data;
576 struct compound_hdr hdr;
577 int status, i;
578
579 status = decode_compound_hdr(xdr, &hdr);
580 if (status)
581 goto out;
582 status = decode_sequence(xdr, &res->seq_res, rqstp);
583 if (status)
584 goto out;
585 status = decode_putfh(xdr);
586 if (status)
587 goto out;
588 WARN_ON(res->num_dev > PNFS_LAYOUTSTATS_MAXDEV);
589 for (i = 0; i < res->num_dev; i++) {
590 status = decode_layoutstats(xdr);
591 if (status)
592 goto out;
593 }
594out:
595 res->rpc_status = status;
596 return status;
597}
598
599/*
600 * Decode CLONE request
601 */
602static int nfs4_xdr_dec_clone(struct rpc_rqst *rqstp,
603 struct xdr_stream *xdr,
604 void *data)
605{
606 struct nfs42_clone_res *res = data;
607 struct compound_hdr hdr;
608 int status;
609
610 status = decode_compound_hdr(xdr, &hdr);
611 if (status)
612 goto out;
613 status = decode_sequence(xdr, &res->seq_res, rqstp);
614 if (status)
615 goto out;
616 status = decode_putfh(xdr);
617 if (status)
618 goto out;
619 status = decode_savefh(xdr);
620 if (status)
621 goto out;
622 status = decode_putfh(xdr);
623 if (status)
624 goto out;
625 status = decode_clone(xdr);
626 if (status)
627 goto out;
628 status = decode_getfattr(xdr, res->dst_fattr, res->server);
629
630out:
631 res->rpc_status = status;
632 return status;
633}
634
635#endif /* __LINUX_FS_NFS_NFS4_2XDR_H */
1/*
2 * Copyright (c) 2014 Anna Schumaker <Anna.Schumaker@Netapp.com>
3 */
4#ifndef __LINUX_FS_NFS_NFS4_2XDR_H
5#define __LINUX_FS_NFS_NFS4_2XDR_H
6
7#include "nfs42.h"
8
9#define encode_fallocate_maxsz (encode_stateid_maxsz + \
10 2 /* offset */ + \
11 2 /* length */)
12#define encode_allocate_maxsz (op_encode_hdr_maxsz + \
13 encode_fallocate_maxsz)
14#define decode_allocate_maxsz (op_decode_hdr_maxsz)
15#define encode_deallocate_maxsz (op_encode_hdr_maxsz + \
16 encode_fallocate_maxsz)
17#define decode_deallocate_maxsz (op_decode_hdr_maxsz)
18#define encode_seek_maxsz (op_encode_hdr_maxsz + \
19 encode_stateid_maxsz + \
20 2 /* offset */ + \
21 1 /* whence */)
22#define decode_seek_maxsz (op_decode_hdr_maxsz + \
23 1 /* eof */ + \
24 1 /* whence */ + \
25 2 /* offset */ + \
26 2 /* length */)
27#define encode_io_info_maxsz 4
28#define encode_layoutstats_maxsz (op_decode_hdr_maxsz + \
29 2 /* offset */ + \
30 2 /* length */ + \
31 encode_stateid_maxsz + \
32 encode_io_info_maxsz + \
33 encode_io_info_maxsz + \
34 1 /* opaque devaddr4 length */ + \
35 XDR_QUADLEN(PNFS_LAYOUTSTATS_MAXSIZE))
36#define decode_layoutstats_maxsz (op_decode_hdr_maxsz)
37#define encode_clone_maxsz (encode_stateid_maxsz + \
38 encode_stateid_maxsz + \
39 2 /* src offset */ + \
40 2 /* dst offset */ + \
41 2 /* count */)
42#define decode_clone_maxsz (op_decode_hdr_maxsz)
43
44#define NFS4_enc_allocate_sz (compound_encode_hdr_maxsz + \
45 encode_putfh_maxsz + \
46 encode_allocate_maxsz + \
47 encode_getattr_maxsz)
48#define NFS4_dec_allocate_sz (compound_decode_hdr_maxsz + \
49 decode_putfh_maxsz + \
50 decode_allocate_maxsz + \
51 decode_getattr_maxsz)
52#define NFS4_enc_deallocate_sz (compound_encode_hdr_maxsz + \
53 encode_putfh_maxsz + \
54 encode_deallocate_maxsz + \
55 encode_getattr_maxsz)
56#define NFS4_dec_deallocate_sz (compound_decode_hdr_maxsz + \
57 decode_putfh_maxsz + \
58 decode_deallocate_maxsz + \
59 decode_getattr_maxsz)
60#define NFS4_enc_seek_sz (compound_encode_hdr_maxsz + \
61 encode_putfh_maxsz + \
62 encode_seek_maxsz)
63#define NFS4_dec_seek_sz (compound_decode_hdr_maxsz + \
64 decode_putfh_maxsz + \
65 decode_seek_maxsz)
66#define NFS4_enc_layoutstats_sz (compound_encode_hdr_maxsz + \
67 encode_sequence_maxsz + \
68 encode_putfh_maxsz + \
69 PNFS_LAYOUTSTATS_MAXDEV * encode_layoutstats_maxsz)
70#define NFS4_dec_layoutstats_sz (compound_decode_hdr_maxsz + \
71 decode_sequence_maxsz + \
72 decode_putfh_maxsz + \
73 PNFS_LAYOUTSTATS_MAXDEV * decode_layoutstats_maxsz)
74#define NFS4_enc_clone_sz (compound_encode_hdr_maxsz + \
75 encode_sequence_maxsz + \
76 encode_putfh_maxsz + \
77 encode_savefh_maxsz + \
78 encode_putfh_maxsz + \
79 encode_clone_maxsz + \
80 encode_getattr_maxsz)
81#define NFS4_dec_clone_sz (compound_decode_hdr_maxsz + \
82 decode_sequence_maxsz + \
83 decode_putfh_maxsz + \
84 decode_savefh_maxsz + \
85 decode_putfh_maxsz + \
86 decode_clone_maxsz + \
87 decode_getattr_maxsz)
88
89static void encode_fallocate(struct xdr_stream *xdr,
90 struct nfs42_falloc_args *args)
91{
92 encode_nfs4_stateid(xdr, &args->falloc_stateid);
93 encode_uint64(xdr, args->falloc_offset);
94 encode_uint64(xdr, args->falloc_length);
95}
96
97static void encode_allocate(struct xdr_stream *xdr,
98 struct nfs42_falloc_args *args,
99 struct compound_hdr *hdr)
100{
101 encode_op_hdr(xdr, OP_ALLOCATE, decode_allocate_maxsz, hdr);
102 encode_fallocate(xdr, args);
103}
104
105static void encode_deallocate(struct xdr_stream *xdr,
106 struct nfs42_falloc_args *args,
107 struct compound_hdr *hdr)
108{
109 encode_op_hdr(xdr, OP_DEALLOCATE, decode_deallocate_maxsz, hdr);
110 encode_fallocate(xdr, args);
111}
112
113static void encode_seek(struct xdr_stream *xdr,
114 struct nfs42_seek_args *args,
115 struct compound_hdr *hdr)
116{
117 encode_op_hdr(xdr, OP_SEEK, decode_seek_maxsz, hdr);
118 encode_nfs4_stateid(xdr, &args->sa_stateid);
119 encode_uint64(xdr, args->sa_offset);
120 encode_uint32(xdr, args->sa_what);
121}
122
123static void encode_layoutstats(struct xdr_stream *xdr,
124 struct nfs42_layoutstat_args *args,
125 struct nfs42_layoutstat_devinfo *devinfo,
126 struct compound_hdr *hdr)
127{
128 __be32 *p;
129
130 encode_op_hdr(xdr, OP_LAYOUTSTATS, decode_layoutstats_maxsz, hdr);
131 p = reserve_space(xdr, 8 + 8);
132 p = xdr_encode_hyper(p, devinfo->offset);
133 p = xdr_encode_hyper(p, devinfo->length);
134 encode_nfs4_stateid(xdr, &args->stateid);
135 p = reserve_space(xdr, 4*8 + NFS4_DEVICEID4_SIZE + 4);
136 p = xdr_encode_hyper(p, devinfo->read_count);
137 p = xdr_encode_hyper(p, devinfo->read_bytes);
138 p = xdr_encode_hyper(p, devinfo->write_count);
139 p = xdr_encode_hyper(p, devinfo->write_bytes);
140 p = xdr_encode_opaque_fixed(p, devinfo->dev_id.data,
141 NFS4_DEVICEID4_SIZE);
142 /* Encode layoutupdate4 */
143 *p++ = cpu_to_be32(devinfo->layout_type);
144 if (devinfo->layoutstats_encode != NULL)
145 devinfo->layoutstats_encode(xdr, args, devinfo);
146 else
147 encode_uint32(xdr, 0);
148}
149
150static void encode_clone(struct xdr_stream *xdr,
151 struct nfs42_clone_args *args,
152 struct compound_hdr *hdr)
153{
154 __be32 *p;
155
156 encode_op_hdr(xdr, OP_CLONE, decode_clone_maxsz, hdr);
157 encode_nfs4_stateid(xdr, &args->src_stateid);
158 encode_nfs4_stateid(xdr, &args->dst_stateid);
159 p = reserve_space(xdr, 3*8);
160 p = xdr_encode_hyper(p, args->src_offset);
161 p = xdr_encode_hyper(p, args->dst_offset);
162 xdr_encode_hyper(p, args->count);
163}
164
165/*
166 * Encode ALLOCATE request
167 */
168static void nfs4_xdr_enc_allocate(struct rpc_rqst *req,
169 struct xdr_stream *xdr,
170 struct nfs42_falloc_args *args)
171{
172 struct compound_hdr hdr = {
173 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
174 };
175
176 encode_compound_hdr(xdr, req, &hdr);
177 encode_sequence(xdr, &args->seq_args, &hdr);
178 encode_putfh(xdr, args->falloc_fh, &hdr);
179 encode_allocate(xdr, args, &hdr);
180 encode_getfattr(xdr, args->falloc_bitmask, &hdr);
181 encode_nops(&hdr);
182}
183
184/*
185 * Encode DEALLOCATE request
186 */
187static void nfs4_xdr_enc_deallocate(struct rpc_rqst *req,
188 struct xdr_stream *xdr,
189 struct nfs42_falloc_args *args)
190{
191 struct compound_hdr hdr = {
192 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
193 };
194
195 encode_compound_hdr(xdr, req, &hdr);
196 encode_sequence(xdr, &args->seq_args, &hdr);
197 encode_putfh(xdr, args->falloc_fh, &hdr);
198 encode_deallocate(xdr, args, &hdr);
199 encode_getfattr(xdr, args->falloc_bitmask, &hdr);
200 encode_nops(&hdr);
201}
202
203/*
204 * Encode SEEK request
205 */
206static void nfs4_xdr_enc_seek(struct rpc_rqst *req,
207 struct xdr_stream *xdr,
208 struct nfs42_seek_args *args)
209{
210 struct compound_hdr hdr = {
211 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
212 };
213
214 encode_compound_hdr(xdr, req, &hdr);
215 encode_sequence(xdr, &args->seq_args, &hdr);
216 encode_putfh(xdr, args->sa_fh, &hdr);
217 encode_seek(xdr, args, &hdr);
218 encode_nops(&hdr);
219}
220
221/*
222 * Encode LAYOUTSTATS request
223 */
224static void nfs4_xdr_enc_layoutstats(struct rpc_rqst *req,
225 struct xdr_stream *xdr,
226 struct nfs42_layoutstat_args *args)
227{
228 int i;
229
230 struct compound_hdr hdr = {
231 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
232 };
233
234 encode_compound_hdr(xdr, req, &hdr);
235 encode_sequence(xdr, &args->seq_args, &hdr);
236 encode_putfh(xdr, args->fh, &hdr);
237 WARN_ON(args->num_dev > PNFS_LAYOUTSTATS_MAXDEV);
238 for (i = 0; i < args->num_dev; i++)
239 encode_layoutstats(xdr, args, &args->devinfo[i], &hdr);
240 encode_nops(&hdr);
241}
242
243/*
244 * Encode CLONE request
245 */
246static void nfs4_xdr_enc_clone(struct rpc_rqst *req,
247 struct xdr_stream *xdr,
248 struct nfs42_clone_args *args)
249{
250 struct compound_hdr hdr = {
251 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
252 };
253
254 encode_compound_hdr(xdr, req, &hdr);
255 encode_sequence(xdr, &args->seq_args, &hdr);
256 encode_putfh(xdr, args->src_fh, &hdr);
257 encode_savefh(xdr, &hdr);
258 encode_putfh(xdr, args->dst_fh, &hdr);
259 encode_clone(xdr, args, &hdr);
260 encode_getfattr(xdr, args->dst_bitmask, &hdr);
261 encode_nops(&hdr);
262}
263
264static int decode_allocate(struct xdr_stream *xdr, struct nfs42_falloc_res *res)
265{
266 return decode_op_hdr(xdr, OP_ALLOCATE);
267}
268
269static int decode_deallocate(struct xdr_stream *xdr, struct nfs42_falloc_res *res)
270{
271 return decode_op_hdr(xdr, OP_DEALLOCATE);
272}
273
274static int decode_seek(struct xdr_stream *xdr, struct nfs42_seek_res *res)
275{
276 int status;
277 __be32 *p;
278
279 status = decode_op_hdr(xdr, OP_SEEK);
280 if (status)
281 return status;
282
283 p = xdr_inline_decode(xdr, 4 + 8);
284 if (unlikely(!p))
285 goto out_overflow;
286
287 res->sr_eof = be32_to_cpup(p++);
288 p = xdr_decode_hyper(p, &res->sr_offset);
289 return 0;
290
291out_overflow:
292 print_overflow_msg(__func__, xdr);
293 return -EIO;
294}
295
296static int decode_layoutstats(struct xdr_stream *xdr)
297{
298 return decode_op_hdr(xdr, OP_LAYOUTSTATS);
299}
300
301static int decode_clone(struct xdr_stream *xdr)
302{
303 return decode_op_hdr(xdr, OP_CLONE);
304}
305
306/*
307 * Decode ALLOCATE request
308 */
309static int nfs4_xdr_dec_allocate(struct rpc_rqst *rqstp,
310 struct xdr_stream *xdr,
311 struct nfs42_falloc_res *res)
312{
313 struct compound_hdr hdr;
314 int status;
315
316 status = decode_compound_hdr(xdr, &hdr);
317 if (status)
318 goto out;
319 status = decode_sequence(xdr, &res->seq_res, rqstp);
320 if (status)
321 goto out;
322 status = decode_putfh(xdr);
323 if (status)
324 goto out;
325 status = decode_allocate(xdr, res);
326 if (status)
327 goto out;
328 decode_getfattr(xdr, res->falloc_fattr, res->falloc_server);
329out:
330 return status;
331}
332
333/*
334 * Decode DEALLOCATE request
335 */
336static int nfs4_xdr_dec_deallocate(struct rpc_rqst *rqstp,
337 struct xdr_stream *xdr,
338 struct nfs42_falloc_res *res)
339{
340 struct compound_hdr hdr;
341 int status;
342
343 status = decode_compound_hdr(xdr, &hdr);
344 if (status)
345 goto out;
346 status = decode_sequence(xdr, &res->seq_res, rqstp);
347 if (status)
348 goto out;
349 status = decode_putfh(xdr);
350 if (status)
351 goto out;
352 status = decode_deallocate(xdr, res);
353 if (status)
354 goto out;
355 decode_getfattr(xdr, res->falloc_fattr, res->falloc_server);
356out:
357 return status;
358}
359
360/*
361 * Decode SEEK request
362 */
363static int nfs4_xdr_dec_seek(struct rpc_rqst *rqstp,
364 struct xdr_stream *xdr,
365 struct nfs42_seek_res *res)
366{
367 struct compound_hdr hdr;
368 int status;
369
370 status = decode_compound_hdr(xdr, &hdr);
371 if (status)
372 goto out;
373 status = decode_sequence(xdr, &res->seq_res, rqstp);
374 if (status)
375 goto out;
376 status = decode_putfh(xdr);
377 if (status)
378 goto out;
379 status = decode_seek(xdr, res);
380out:
381 return status;
382}
383
384/*
385 * Decode LAYOUTSTATS request
386 */
387static int nfs4_xdr_dec_layoutstats(struct rpc_rqst *rqstp,
388 struct xdr_stream *xdr,
389 struct nfs42_layoutstat_res *res)
390{
391 struct compound_hdr hdr;
392 int status, i;
393
394 status = decode_compound_hdr(xdr, &hdr);
395 if (status)
396 goto out;
397 status = decode_sequence(xdr, &res->seq_res, rqstp);
398 if (status)
399 goto out;
400 status = decode_putfh(xdr);
401 if (status)
402 goto out;
403 WARN_ON(res->num_dev > PNFS_LAYOUTSTATS_MAXDEV);
404 for (i = 0; i < res->num_dev; i++) {
405 status = decode_layoutstats(xdr);
406 if (status)
407 goto out;
408 }
409out:
410 res->rpc_status = status;
411 return status;
412}
413
414/*
415 * Decode CLONE request
416 */
417static int nfs4_xdr_dec_clone(struct rpc_rqst *rqstp,
418 struct xdr_stream *xdr,
419 struct nfs42_clone_res *res)
420{
421 struct compound_hdr hdr;
422 int status;
423
424 status = decode_compound_hdr(xdr, &hdr);
425 if (status)
426 goto out;
427 status = decode_sequence(xdr, &res->seq_res, rqstp);
428 if (status)
429 goto out;
430 status = decode_putfh(xdr);
431 if (status)
432 goto out;
433 status = decode_savefh(xdr);
434 if (status)
435 goto out;
436 status = decode_putfh(xdr);
437 if (status)
438 goto out;
439 status = decode_clone(xdr);
440 if (status)
441 goto out;
442 status = decode_getfattr(xdr, res->dst_fattr, res->server);
443
444out:
445 res->rpc_status = status;
446 return status;
447}
448
449#endif /* __LINUX_FS_NFS_NFS4_2XDR_H */