2 * Copyright (c) 2014 Anna Schumaker <Anna.Schumaker@Netapp.com>
4 #ifndef __LINUX_FS_NFS_NFS4_2XDR_H
5 #define __LINUX_FS_NFS_NFS4_2XDR_H
9 #define encode_fallocate_maxsz (encode_stateid_maxsz + \
12 #define NFS42_WRITE_RES_SIZE (1 /* wr_callback_id size */ +\
13 XDR_QUADLEN(NFS4_STATEID_SIZE) + \
15 1 /* wr_committed */ + \
16 XDR_QUADLEN(NFS4_VERIFIER_SIZE))
17 #define encode_allocate_maxsz (op_encode_hdr_maxsz + \
18 encode_fallocate_maxsz)
19 #define decode_allocate_maxsz (op_decode_hdr_maxsz)
20 #define encode_copy_maxsz (op_encode_hdr_maxsz + \
21 XDR_QUADLEN(NFS4_STATEID_SIZE) + \
22 XDR_QUADLEN(NFS4_STATEID_SIZE) + \
23 2 + 2 + 2 + 1 + 1 + 1)
24 #define decode_copy_maxsz (op_decode_hdr_maxsz + \
25 NFS42_WRITE_RES_SIZE + \
26 1 /* cr_consecutive */ + \
27 1 /* cr_synchronous */)
28 #define encode_deallocate_maxsz (op_encode_hdr_maxsz + \
29 encode_fallocate_maxsz)
30 #define decode_deallocate_maxsz (op_decode_hdr_maxsz)
31 #define encode_seek_maxsz (op_encode_hdr_maxsz + \
32 encode_stateid_maxsz + \
35 #define decode_seek_maxsz (op_decode_hdr_maxsz + \
40 #define encode_io_info_maxsz 4
41 #define encode_layoutstats_maxsz (op_decode_hdr_maxsz + \
44 encode_stateid_maxsz + \
45 encode_io_info_maxsz + \
46 encode_io_info_maxsz + \
47 1 /* opaque devaddr4 length */ + \
48 XDR_QUADLEN(PNFS_LAYOUTSTATS_MAXSIZE))
49 #define decode_layoutstats_maxsz (op_decode_hdr_maxsz)
50 #define encode_clone_maxsz (encode_stateid_maxsz + \
51 encode_stateid_maxsz + \
52 2 /* src offset */ + \
53 2 /* dst offset */ + \
55 #define decode_clone_maxsz (op_decode_hdr_maxsz)
57 #define NFS4_enc_allocate_sz (compound_encode_hdr_maxsz + \
58 encode_putfh_maxsz + \
59 encode_allocate_maxsz + \
61 #define NFS4_dec_allocate_sz (compound_decode_hdr_maxsz + \
62 decode_putfh_maxsz + \
63 decode_allocate_maxsz + \
65 #define NFS4_enc_copy_sz (compound_encode_hdr_maxsz + \
66 encode_putfh_maxsz + \
67 encode_savefh_maxsz + \
68 encode_putfh_maxsz + \
70 #define NFS4_dec_copy_sz (compound_decode_hdr_maxsz + \
71 decode_putfh_maxsz + \
72 decode_savefh_maxsz + \
73 decode_putfh_maxsz + \
75 #define NFS4_enc_deallocate_sz (compound_encode_hdr_maxsz + \
76 encode_putfh_maxsz + \
77 encode_deallocate_maxsz + \
79 #define NFS4_dec_deallocate_sz (compound_decode_hdr_maxsz + \
80 decode_putfh_maxsz + \
81 decode_deallocate_maxsz + \
83 #define NFS4_enc_seek_sz (compound_encode_hdr_maxsz + \
84 encode_putfh_maxsz + \
86 #define NFS4_dec_seek_sz (compound_decode_hdr_maxsz + \
87 decode_putfh_maxsz + \
89 #define NFS4_enc_layoutstats_sz (compound_encode_hdr_maxsz + \
90 encode_sequence_maxsz + \
91 encode_putfh_maxsz + \
92 PNFS_LAYOUTSTATS_MAXDEV * encode_layoutstats_maxsz)
93 #define NFS4_dec_layoutstats_sz (compound_decode_hdr_maxsz + \
94 decode_sequence_maxsz + \
95 decode_putfh_maxsz + \
96 PNFS_LAYOUTSTATS_MAXDEV * decode_layoutstats_maxsz)
97 #define NFS4_enc_clone_sz (compound_encode_hdr_maxsz + \
98 encode_sequence_maxsz + \
99 encode_putfh_maxsz + \
100 encode_savefh_maxsz + \
101 encode_putfh_maxsz + \
102 encode_clone_maxsz + \
103 encode_getattr_maxsz)
104 #define NFS4_dec_clone_sz (compound_decode_hdr_maxsz + \
105 decode_sequence_maxsz + \
106 decode_putfh_maxsz + \
107 decode_savefh_maxsz + \
108 decode_putfh_maxsz + \
109 decode_clone_maxsz + \
110 decode_getattr_maxsz)
112 static void encode_fallocate(struct xdr_stream *xdr,
113 struct nfs42_falloc_args *args)
115 encode_nfs4_stateid(xdr, &args->falloc_stateid);
116 encode_uint64(xdr, args->falloc_offset);
117 encode_uint64(xdr, args->falloc_length);
120 static void encode_allocate(struct xdr_stream *xdr,
121 struct nfs42_falloc_args *args,
122 struct compound_hdr *hdr)
124 encode_op_hdr(xdr, OP_ALLOCATE, decode_allocate_maxsz, hdr);
125 encode_fallocate(xdr, args);
128 static void encode_copy(struct xdr_stream *xdr,
129 struct nfs42_copy_args *args,
130 struct compound_hdr *hdr)
132 encode_op_hdr(xdr, OP_COPY, decode_copy_maxsz, hdr);
133 encode_nfs4_stateid(xdr, &args->src_stateid);
134 encode_nfs4_stateid(xdr, &args->dst_stateid);
136 encode_uint64(xdr, args->src_pos);
137 encode_uint64(xdr, args->dst_pos);
138 encode_uint64(xdr, args->count);
140 encode_uint32(xdr, 1); /* consecutive = true */
141 encode_uint32(xdr, 1); /* synchronous = true */
142 encode_uint32(xdr, 0); /* src server list */
145 static void encode_deallocate(struct xdr_stream *xdr,
146 struct nfs42_falloc_args *args,
147 struct compound_hdr *hdr)
149 encode_op_hdr(xdr, OP_DEALLOCATE, decode_deallocate_maxsz, hdr);
150 encode_fallocate(xdr, args);
153 static void encode_seek(struct xdr_stream *xdr,
154 struct nfs42_seek_args *args,
155 struct compound_hdr *hdr)
157 encode_op_hdr(xdr, OP_SEEK, decode_seek_maxsz, hdr);
158 encode_nfs4_stateid(xdr, &args->sa_stateid);
159 encode_uint64(xdr, args->sa_offset);
160 encode_uint32(xdr, args->sa_what);
163 static void encode_layoutstats(struct xdr_stream *xdr,
164 struct nfs42_layoutstat_args *args,
165 struct nfs42_layoutstat_devinfo *devinfo,
166 struct compound_hdr *hdr)
170 encode_op_hdr(xdr, OP_LAYOUTSTATS, decode_layoutstats_maxsz, hdr);
171 p = reserve_space(xdr, 8 + 8);
172 p = xdr_encode_hyper(p, devinfo->offset);
173 p = xdr_encode_hyper(p, devinfo->length);
174 encode_nfs4_stateid(xdr, &args->stateid);
175 p = reserve_space(xdr, 4*8 + NFS4_DEVICEID4_SIZE + 4);
176 p = xdr_encode_hyper(p, devinfo->read_count);
177 p = xdr_encode_hyper(p, devinfo->read_bytes);
178 p = xdr_encode_hyper(p, devinfo->write_count);
179 p = xdr_encode_hyper(p, devinfo->write_bytes);
180 p = xdr_encode_opaque_fixed(p, devinfo->dev_id.data,
181 NFS4_DEVICEID4_SIZE);
182 /* Encode layoutupdate4 */
183 *p++ = cpu_to_be32(devinfo->layout_type);
184 if (devinfo->layoutstats_encode != NULL)
185 devinfo->layoutstats_encode(xdr, args, devinfo);
187 encode_uint32(xdr, 0);
190 static void encode_clone(struct xdr_stream *xdr,
191 struct nfs42_clone_args *args,
192 struct compound_hdr *hdr)
196 encode_op_hdr(xdr, OP_CLONE, decode_clone_maxsz, hdr);
197 encode_nfs4_stateid(xdr, &args->src_stateid);
198 encode_nfs4_stateid(xdr, &args->dst_stateid);
199 p = reserve_space(xdr, 3*8);
200 p = xdr_encode_hyper(p, args->src_offset);
201 p = xdr_encode_hyper(p, args->dst_offset);
202 xdr_encode_hyper(p, args->count);
206 * Encode ALLOCATE request
208 static void nfs4_xdr_enc_allocate(struct rpc_rqst *req,
209 struct xdr_stream *xdr,
210 struct nfs42_falloc_args *args)
212 struct compound_hdr hdr = {
213 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
216 encode_compound_hdr(xdr, req, &hdr);
217 encode_sequence(xdr, &args->seq_args, &hdr);
218 encode_putfh(xdr, args->falloc_fh, &hdr);
219 encode_allocate(xdr, args, &hdr);
220 encode_getfattr(xdr, args->falloc_bitmask, &hdr);
225 * Encode COPY request
227 static void nfs4_xdr_enc_copy(struct rpc_rqst *req,
228 struct xdr_stream *xdr,
229 struct nfs42_copy_args *args)
231 struct compound_hdr hdr = {
232 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
235 encode_compound_hdr(xdr, req, &hdr);
236 encode_sequence(xdr, &args->seq_args, &hdr);
237 encode_putfh(xdr, args->src_fh, &hdr);
238 encode_savefh(xdr, &hdr);
239 encode_putfh(xdr, args->dst_fh, &hdr);
240 encode_copy(xdr, args, &hdr);
245 * Encode DEALLOCATE request
247 static void nfs4_xdr_enc_deallocate(struct rpc_rqst *req,
248 struct xdr_stream *xdr,
249 struct nfs42_falloc_args *args)
251 struct compound_hdr hdr = {
252 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
255 encode_compound_hdr(xdr, req, &hdr);
256 encode_sequence(xdr, &args->seq_args, &hdr);
257 encode_putfh(xdr, args->falloc_fh, &hdr);
258 encode_deallocate(xdr, args, &hdr);
259 encode_getfattr(xdr, args->falloc_bitmask, &hdr);
264 * Encode SEEK request
266 static void nfs4_xdr_enc_seek(struct rpc_rqst *req,
267 struct xdr_stream *xdr,
268 struct nfs42_seek_args *args)
270 struct compound_hdr hdr = {
271 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
274 encode_compound_hdr(xdr, req, &hdr);
275 encode_sequence(xdr, &args->seq_args, &hdr);
276 encode_putfh(xdr, args->sa_fh, &hdr);
277 encode_seek(xdr, args, &hdr);
282 * Encode LAYOUTSTATS request
284 static void nfs4_xdr_enc_layoutstats(struct rpc_rqst *req,
285 struct xdr_stream *xdr,
286 struct nfs42_layoutstat_args *args)
290 struct compound_hdr hdr = {
291 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
294 encode_compound_hdr(xdr, req, &hdr);
295 encode_sequence(xdr, &args->seq_args, &hdr);
296 encode_putfh(xdr, args->fh, &hdr);
297 WARN_ON(args->num_dev > PNFS_LAYOUTSTATS_MAXDEV);
298 for (i = 0; i < args->num_dev; i++)
299 encode_layoutstats(xdr, args, &args->devinfo[i], &hdr);
304 * Encode CLONE request
306 static void nfs4_xdr_enc_clone(struct rpc_rqst *req,
307 struct xdr_stream *xdr,
308 struct nfs42_clone_args *args)
310 struct compound_hdr hdr = {
311 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
314 encode_compound_hdr(xdr, req, &hdr);
315 encode_sequence(xdr, &args->seq_args, &hdr);
316 encode_putfh(xdr, args->src_fh, &hdr);
317 encode_savefh(xdr, &hdr);
318 encode_putfh(xdr, args->dst_fh, &hdr);
319 encode_clone(xdr, args, &hdr);
320 encode_getfattr(xdr, args->dst_bitmask, &hdr);
324 static int decode_allocate(struct xdr_stream *xdr, struct nfs42_falloc_res *res)
326 return decode_op_hdr(xdr, OP_ALLOCATE);
329 static int decode_write_response(struct xdr_stream *xdr,
330 struct nfs42_write_res *res)
335 p = xdr_inline_decode(xdr, 4 + 8 + 4);
339 stateids = be32_to_cpup(p++);
340 p = xdr_decode_hyper(p, &res->count);
341 res->verifier.committed = be32_to_cpup(p);
342 return decode_verifier(xdr, &res->verifier.verifier);
345 print_overflow_msg(__func__, xdr);
349 static int decode_copy_requirements(struct xdr_stream *xdr,
350 struct nfs42_copy_res *res) {
353 p = xdr_inline_decode(xdr, 4 + 4);
357 res->consecutive = be32_to_cpup(p++);
358 res->synchronous = be32_to_cpup(p++);
361 print_overflow_msg(__func__, xdr);
365 static int decode_copy(struct xdr_stream *xdr, struct nfs42_copy_res *res)
369 status = decode_op_hdr(xdr, OP_COPY);
370 if (status == NFS4ERR_OFFLOAD_NO_REQS) {
371 status = decode_copy_requirements(xdr, res);
374 return NFS4ERR_OFFLOAD_NO_REQS;
378 status = decode_write_response(xdr, &res->write_res);
382 return decode_copy_requirements(xdr, res);
385 static int decode_deallocate(struct xdr_stream *xdr, struct nfs42_falloc_res *res)
387 return decode_op_hdr(xdr, OP_DEALLOCATE);
390 static int decode_seek(struct xdr_stream *xdr, struct nfs42_seek_res *res)
395 status = decode_op_hdr(xdr, OP_SEEK);
399 p = xdr_inline_decode(xdr, 4 + 8);
403 res->sr_eof = be32_to_cpup(p++);
404 p = xdr_decode_hyper(p, &res->sr_offset);
408 print_overflow_msg(__func__, xdr);
412 static int decode_layoutstats(struct xdr_stream *xdr)
414 return decode_op_hdr(xdr, OP_LAYOUTSTATS);
417 static int decode_clone(struct xdr_stream *xdr)
419 return decode_op_hdr(xdr, OP_CLONE);
423 * Decode ALLOCATE request
425 static int nfs4_xdr_dec_allocate(struct rpc_rqst *rqstp,
426 struct xdr_stream *xdr,
427 struct nfs42_falloc_res *res)
429 struct compound_hdr hdr;
432 status = decode_compound_hdr(xdr, &hdr);
435 status = decode_sequence(xdr, &res->seq_res, rqstp);
438 status = decode_putfh(xdr);
441 status = decode_allocate(xdr, res);
444 decode_getfattr(xdr, res->falloc_fattr, res->falloc_server);
450 * Decode COPY response
452 static int nfs4_xdr_dec_copy(struct rpc_rqst *rqstp,
453 struct xdr_stream *xdr,
454 struct nfs42_copy_res *res)
456 struct compound_hdr hdr;
459 status = decode_compound_hdr(xdr, &hdr);
462 status = decode_sequence(xdr, &res->seq_res, rqstp);
465 status = decode_putfh(xdr);
468 status = decode_savefh(xdr);
471 status = decode_putfh(xdr);
474 status = decode_copy(xdr, res);
480 * Decode DEALLOCATE request
482 static int nfs4_xdr_dec_deallocate(struct rpc_rqst *rqstp,
483 struct xdr_stream *xdr,
484 struct nfs42_falloc_res *res)
486 struct compound_hdr hdr;
489 status = decode_compound_hdr(xdr, &hdr);
492 status = decode_sequence(xdr, &res->seq_res, rqstp);
495 status = decode_putfh(xdr);
498 status = decode_deallocate(xdr, res);
501 decode_getfattr(xdr, res->falloc_fattr, res->falloc_server);
507 * Decode SEEK request
509 static int nfs4_xdr_dec_seek(struct rpc_rqst *rqstp,
510 struct xdr_stream *xdr,
511 struct nfs42_seek_res *res)
513 struct compound_hdr hdr;
516 status = decode_compound_hdr(xdr, &hdr);
519 status = decode_sequence(xdr, &res->seq_res, rqstp);
522 status = decode_putfh(xdr);
525 status = decode_seek(xdr, res);
531 * Decode LAYOUTSTATS request
533 static int nfs4_xdr_dec_layoutstats(struct rpc_rqst *rqstp,
534 struct xdr_stream *xdr,
535 struct nfs42_layoutstat_res *res)
537 struct compound_hdr hdr;
540 status = decode_compound_hdr(xdr, &hdr);
543 status = decode_sequence(xdr, &res->seq_res, rqstp);
546 status = decode_putfh(xdr);
549 WARN_ON(res->num_dev > PNFS_LAYOUTSTATS_MAXDEV);
550 for (i = 0; i < res->num_dev; i++) {
551 status = decode_layoutstats(xdr);
556 res->rpc_status = status;
561 * Decode CLONE request
563 static int nfs4_xdr_dec_clone(struct rpc_rqst *rqstp,
564 struct xdr_stream *xdr,
565 struct nfs42_clone_res *res)
567 struct compound_hdr hdr;
570 status = decode_compound_hdr(xdr, &hdr);
573 status = decode_sequence(xdr, &res->seq_res, rqstp);
576 status = decode_putfh(xdr);
579 status = decode_savefh(xdr);
582 status = decode_putfh(xdr);
585 status = decode_clone(xdr);
588 status = decode_getfattr(xdr, res->dst_fattr, res->server);
591 res->rpc_status = status;
595 #endif /* __LINUX_FS_NFS_NFS4_2XDR_H */