]>
git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - fs/nfs/nfs42xdr.c
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 + \
71 #define NFS4_dec_copy_sz (compound_decode_hdr_maxsz + \
72 decode_putfh_maxsz + \
73 decode_savefh_maxsz + \
74 decode_putfh_maxsz + \
77 #define NFS4_enc_deallocate_sz (compound_encode_hdr_maxsz + \
78 encode_putfh_maxsz + \
79 encode_deallocate_maxsz + \
81 #define NFS4_dec_deallocate_sz (compound_decode_hdr_maxsz + \
82 decode_putfh_maxsz + \
83 decode_deallocate_maxsz + \
85 #define NFS4_enc_seek_sz (compound_encode_hdr_maxsz + \
86 encode_putfh_maxsz + \
88 #define NFS4_dec_seek_sz (compound_decode_hdr_maxsz + \
89 decode_putfh_maxsz + \
91 #define NFS4_enc_layoutstats_sz (compound_encode_hdr_maxsz + \
92 encode_sequence_maxsz + \
93 encode_putfh_maxsz + \
94 PNFS_LAYOUTSTATS_MAXDEV * encode_layoutstats_maxsz)
95 #define NFS4_dec_layoutstats_sz (compound_decode_hdr_maxsz + \
96 decode_sequence_maxsz + \
97 decode_putfh_maxsz + \
98 PNFS_LAYOUTSTATS_MAXDEV * decode_layoutstats_maxsz)
99 #define NFS4_enc_clone_sz (compound_encode_hdr_maxsz + \
100 encode_sequence_maxsz + \
101 encode_putfh_maxsz + \
102 encode_savefh_maxsz + \
103 encode_putfh_maxsz + \
104 encode_clone_maxsz + \
105 encode_getattr_maxsz)
106 #define NFS4_dec_clone_sz (compound_decode_hdr_maxsz + \
107 decode_sequence_maxsz + \
108 decode_putfh_maxsz + \
109 decode_savefh_maxsz + \
110 decode_putfh_maxsz + \
111 decode_clone_maxsz + \
112 decode_getattr_maxsz)
114 static void encode_fallocate(struct xdr_stream
*xdr
,
115 const struct nfs42_falloc_args
*args
)
117 encode_nfs4_stateid(xdr
, &args
->falloc_stateid
);
118 encode_uint64(xdr
, args
->falloc_offset
);
119 encode_uint64(xdr
, args
->falloc_length
);
122 static void encode_allocate(struct xdr_stream
*xdr
,
123 const struct nfs42_falloc_args
*args
,
124 struct compound_hdr
*hdr
)
126 encode_op_hdr(xdr
, OP_ALLOCATE
, decode_allocate_maxsz
, hdr
);
127 encode_fallocate(xdr
, args
);
130 static void encode_copy(struct xdr_stream
*xdr
,
131 const struct nfs42_copy_args
*args
,
132 struct compound_hdr
*hdr
)
134 encode_op_hdr(xdr
, OP_COPY
, decode_copy_maxsz
, hdr
);
135 encode_nfs4_stateid(xdr
, &args
->src_stateid
);
136 encode_nfs4_stateid(xdr
, &args
->dst_stateid
);
138 encode_uint64(xdr
, args
->src_pos
);
139 encode_uint64(xdr
, args
->dst_pos
);
140 encode_uint64(xdr
, args
->count
);
142 encode_uint32(xdr
, 1); /* consecutive = true */
143 encode_uint32(xdr
, 1); /* synchronous = true */
144 encode_uint32(xdr
, 0); /* src server list */
147 static void encode_deallocate(struct xdr_stream
*xdr
,
148 const struct nfs42_falloc_args
*args
,
149 struct compound_hdr
*hdr
)
151 encode_op_hdr(xdr
, OP_DEALLOCATE
, decode_deallocate_maxsz
, hdr
);
152 encode_fallocate(xdr
, args
);
155 static void encode_seek(struct xdr_stream
*xdr
,
156 const struct nfs42_seek_args
*args
,
157 struct compound_hdr
*hdr
)
159 encode_op_hdr(xdr
, OP_SEEK
, decode_seek_maxsz
, hdr
);
160 encode_nfs4_stateid(xdr
, &args
->sa_stateid
);
161 encode_uint64(xdr
, args
->sa_offset
);
162 encode_uint32(xdr
, args
->sa_what
);
165 static void encode_layoutstats(struct xdr_stream
*xdr
,
166 const struct nfs42_layoutstat_args
*args
,
167 struct nfs42_layoutstat_devinfo
*devinfo
,
168 struct compound_hdr
*hdr
)
172 encode_op_hdr(xdr
, OP_LAYOUTSTATS
, decode_layoutstats_maxsz
, hdr
);
173 p
= reserve_space(xdr
, 8 + 8);
174 p
= xdr_encode_hyper(p
, devinfo
->offset
);
175 p
= xdr_encode_hyper(p
, devinfo
->length
);
176 encode_nfs4_stateid(xdr
, &args
->stateid
);
177 p
= reserve_space(xdr
, 4*8 + NFS4_DEVICEID4_SIZE
+ 4);
178 p
= xdr_encode_hyper(p
, devinfo
->read_count
);
179 p
= xdr_encode_hyper(p
, devinfo
->read_bytes
);
180 p
= xdr_encode_hyper(p
, devinfo
->write_count
);
181 p
= xdr_encode_hyper(p
, devinfo
->write_bytes
);
182 p
= xdr_encode_opaque_fixed(p
, devinfo
->dev_id
.data
,
183 NFS4_DEVICEID4_SIZE
);
184 /* Encode layoutupdate4 */
185 *p
++ = cpu_to_be32(devinfo
->layout_type
);
186 if (devinfo
->ld_private
.ops
)
187 devinfo
->ld_private
.ops
->encode(xdr
, args
,
188 &devinfo
->ld_private
);
190 encode_uint32(xdr
, 0);
193 static void encode_clone(struct xdr_stream
*xdr
,
194 const struct nfs42_clone_args
*args
,
195 struct compound_hdr
*hdr
)
199 encode_op_hdr(xdr
, OP_CLONE
, decode_clone_maxsz
, hdr
);
200 encode_nfs4_stateid(xdr
, &args
->src_stateid
);
201 encode_nfs4_stateid(xdr
, &args
->dst_stateid
);
202 p
= reserve_space(xdr
, 3*8);
203 p
= xdr_encode_hyper(p
, args
->src_offset
);
204 p
= xdr_encode_hyper(p
, args
->dst_offset
);
205 xdr_encode_hyper(p
, args
->count
);
209 * Encode ALLOCATE request
211 static void nfs4_xdr_enc_allocate(struct rpc_rqst
*req
,
212 struct xdr_stream
*xdr
,
215 const struct nfs42_falloc_args
*args
= data
;
216 struct compound_hdr hdr
= {
217 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
220 encode_compound_hdr(xdr
, req
, &hdr
);
221 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
222 encode_putfh(xdr
, args
->falloc_fh
, &hdr
);
223 encode_allocate(xdr
, args
, &hdr
);
224 encode_getfattr(xdr
, args
->falloc_bitmask
, &hdr
);
228 static void encode_copy_commit(struct xdr_stream
*xdr
,
229 const struct nfs42_copy_args
*args
,
230 struct compound_hdr
*hdr
)
234 encode_op_hdr(xdr
, OP_COMMIT
, decode_commit_maxsz
, hdr
);
235 p
= reserve_space(xdr
, 12);
236 p
= xdr_encode_hyper(p
, args
->dst_pos
);
237 *p
= cpu_to_be32(args
->count
);
241 * Encode COPY request
243 static void nfs4_xdr_enc_copy(struct rpc_rqst
*req
,
244 struct xdr_stream
*xdr
,
247 const struct nfs42_copy_args
*args
= data
;
248 struct compound_hdr hdr
= {
249 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
252 encode_compound_hdr(xdr
, req
, &hdr
);
253 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
254 encode_putfh(xdr
, args
->src_fh
, &hdr
);
255 encode_savefh(xdr
, &hdr
);
256 encode_putfh(xdr
, args
->dst_fh
, &hdr
);
257 encode_copy(xdr
, args
, &hdr
);
258 encode_copy_commit(xdr
, args
, &hdr
);
263 * Encode DEALLOCATE request
265 static void nfs4_xdr_enc_deallocate(struct rpc_rqst
*req
,
266 struct xdr_stream
*xdr
,
269 const struct nfs42_falloc_args
*args
= data
;
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
->falloc_fh
, &hdr
);
277 encode_deallocate(xdr
, args
, &hdr
);
278 encode_getfattr(xdr
, args
->falloc_bitmask
, &hdr
);
283 * Encode SEEK request
285 static void nfs4_xdr_enc_seek(struct rpc_rqst
*req
,
286 struct xdr_stream
*xdr
,
289 const struct nfs42_seek_args
*args
= data
;
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
->sa_fh
, &hdr
);
297 encode_seek(xdr
, args
, &hdr
);
302 * Encode LAYOUTSTATS request
304 static void nfs4_xdr_enc_layoutstats(struct rpc_rqst
*req
,
305 struct xdr_stream
*xdr
,
308 const struct nfs42_layoutstat_args
*args
= data
;
311 struct compound_hdr hdr
= {
312 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
315 encode_compound_hdr(xdr
, req
, &hdr
);
316 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
317 encode_putfh(xdr
, args
->fh
, &hdr
);
318 WARN_ON(args
->num_dev
> PNFS_LAYOUTSTATS_MAXDEV
);
319 for (i
= 0; i
< args
->num_dev
; i
++)
320 encode_layoutstats(xdr
, args
, &args
->devinfo
[i
], &hdr
);
325 * Encode CLONE request
327 static void nfs4_xdr_enc_clone(struct rpc_rqst
*req
,
328 struct xdr_stream
*xdr
,
331 const struct nfs42_clone_args
*args
= data
;
332 struct compound_hdr hdr
= {
333 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
336 encode_compound_hdr(xdr
, req
, &hdr
);
337 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
338 encode_putfh(xdr
, args
->src_fh
, &hdr
);
339 encode_savefh(xdr
, &hdr
);
340 encode_putfh(xdr
, args
->dst_fh
, &hdr
);
341 encode_clone(xdr
, args
, &hdr
);
342 encode_getfattr(xdr
, args
->dst_bitmask
, &hdr
);
346 static int decode_allocate(struct xdr_stream
*xdr
, struct nfs42_falloc_res
*res
)
348 return decode_op_hdr(xdr
, OP_ALLOCATE
);
351 static int decode_write_response(struct xdr_stream
*xdr
,
352 struct nfs42_write_res
*res
)
356 p
= xdr_inline_decode(xdr
, 4 + 8 + 4);
361 * We never use asynchronous mode, so warn if a server returns
364 if (unlikely(*p
!= 0)) {
365 pr_err_once("%s: server has set unrequested "
366 "asynchronous mode\n", __func__
);
370 p
= xdr_decode_hyper(p
, &res
->count
);
371 res
->verifier
.committed
= be32_to_cpup(p
);
372 return decode_verifier(xdr
, &res
->verifier
.verifier
);
375 print_overflow_msg(__func__
, xdr
);
379 static int decode_copy_requirements(struct xdr_stream
*xdr
,
380 struct nfs42_copy_res
*res
) {
383 p
= xdr_inline_decode(xdr
, 4 + 4);
387 res
->consecutive
= be32_to_cpup(p
++);
388 res
->synchronous
= be32_to_cpup(p
++);
391 print_overflow_msg(__func__
, xdr
);
395 static int decode_copy(struct xdr_stream
*xdr
, struct nfs42_copy_res
*res
)
399 status
= decode_op_hdr(xdr
, OP_COPY
);
400 if (status
== NFS4ERR_OFFLOAD_NO_REQS
) {
401 status
= decode_copy_requirements(xdr
, res
);
404 return NFS4ERR_OFFLOAD_NO_REQS
;
408 status
= decode_write_response(xdr
, &res
->write_res
);
412 return decode_copy_requirements(xdr
, res
);
415 static int decode_deallocate(struct xdr_stream
*xdr
, struct nfs42_falloc_res
*res
)
417 return decode_op_hdr(xdr
, OP_DEALLOCATE
);
420 static int decode_seek(struct xdr_stream
*xdr
, struct nfs42_seek_res
*res
)
425 status
= decode_op_hdr(xdr
, OP_SEEK
);
429 p
= xdr_inline_decode(xdr
, 4 + 8);
433 res
->sr_eof
= be32_to_cpup(p
++);
434 p
= xdr_decode_hyper(p
, &res
->sr_offset
);
438 print_overflow_msg(__func__
, xdr
);
442 static int decode_layoutstats(struct xdr_stream
*xdr
)
444 return decode_op_hdr(xdr
, OP_LAYOUTSTATS
);
447 static int decode_clone(struct xdr_stream
*xdr
)
449 return decode_op_hdr(xdr
, OP_CLONE
);
453 * Decode ALLOCATE request
455 static int nfs4_xdr_dec_allocate(struct rpc_rqst
*rqstp
,
456 struct xdr_stream
*xdr
,
459 struct nfs42_falloc_res
*res
= data
;
460 struct compound_hdr hdr
;
463 status
= decode_compound_hdr(xdr
, &hdr
);
466 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
469 status
= decode_putfh(xdr
);
472 status
= decode_allocate(xdr
, res
);
475 decode_getfattr(xdr
, res
->falloc_fattr
, res
->falloc_server
);
481 * Decode COPY response
483 static int nfs4_xdr_dec_copy(struct rpc_rqst
*rqstp
,
484 struct xdr_stream
*xdr
,
487 struct nfs42_copy_res
*res
= data
;
488 struct compound_hdr hdr
;
491 status
= decode_compound_hdr(xdr
, &hdr
);
494 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
497 status
= decode_putfh(xdr
);
500 status
= decode_savefh(xdr
);
503 status
= decode_putfh(xdr
);
506 status
= decode_copy(xdr
, res
);
509 status
= decode_commit(xdr
, &res
->commit_res
);
515 * Decode DEALLOCATE request
517 static int nfs4_xdr_dec_deallocate(struct rpc_rqst
*rqstp
,
518 struct xdr_stream
*xdr
,
521 struct nfs42_falloc_res
*res
= data
;
522 struct compound_hdr hdr
;
525 status
= decode_compound_hdr(xdr
, &hdr
);
528 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
531 status
= decode_putfh(xdr
);
534 status
= decode_deallocate(xdr
, res
);
537 decode_getfattr(xdr
, res
->falloc_fattr
, res
->falloc_server
);
543 * Decode SEEK request
545 static int nfs4_xdr_dec_seek(struct rpc_rqst
*rqstp
,
546 struct xdr_stream
*xdr
,
549 struct nfs42_seek_res
*res
= data
;
550 struct compound_hdr hdr
;
553 status
= decode_compound_hdr(xdr
, &hdr
);
556 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
559 status
= decode_putfh(xdr
);
562 status
= decode_seek(xdr
, res
);
568 * Decode LAYOUTSTATS request
570 static int nfs4_xdr_dec_layoutstats(struct rpc_rqst
*rqstp
,
571 struct xdr_stream
*xdr
,
574 struct nfs42_layoutstat_res
*res
= data
;
575 struct compound_hdr hdr
;
578 status
= decode_compound_hdr(xdr
, &hdr
);
581 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
584 status
= decode_putfh(xdr
);
587 WARN_ON(res
->num_dev
> PNFS_LAYOUTSTATS_MAXDEV
);
588 for (i
= 0; i
< res
->num_dev
; i
++) {
589 status
= decode_layoutstats(xdr
);
594 res
->rpc_status
= status
;
599 * Decode CLONE request
601 static int nfs4_xdr_dec_clone(struct rpc_rqst
*rqstp
,
602 struct xdr_stream
*xdr
,
605 struct nfs42_clone_res
*res
= data
;
606 struct compound_hdr hdr
;
609 status
= decode_compound_hdr(xdr
, &hdr
);
612 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
615 status
= decode_putfh(xdr
);
618 status
= decode_savefh(xdr
);
621 status
= decode_putfh(xdr
);
624 status
= decode_clone(xdr
);
627 status
= decode_getfattr(xdr
, res
->dst_fattr
, res
->server
);
630 res
->rpc_status
= status
;
634 #endif /* __LINUX_FS_NFS_NFS4_2XDR_H */