Commit | Line | Data |
---|---|---|
1c6dcbe5 AS |
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 | ||
be3a5d23 TM |
7 | #include "nfs42.h" |
8 | ||
f4ac1674 AS |
9 | #define encode_fallocate_maxsz (encode_stateid_maxsz + \ |
10 | 2 /* offset */ + \ | |
11 | 2 /* length */) | |
2e72448b AS |
12 | #define NFS42_WRITE_RES_SIZE (1 /* wr_callback_id size */ +\ |
13 | XDR_QUADLEN(NFS4_STATEID_SIZE) + \ | |
14 | 2 /* wr_count */ + \ | |
15 | 1 /* wr_committed */ + \ | |
16 | XDR_QUADLEN(NFS4_VERIFIER_SIZE)) | |
f4ac1674 AS |
17 | #define encode_allocate_maxsz (op_encode_hdr_maxsz + \ |
18 | encode_fallocate_maxsz) | |
19 | #define decode_allocate_maxsz (op_decode_hdr_maxsz) | |
2e72448b AS |
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 */) | |
624bd5b7 AS |
28 | #define encode_deallocate_maxsz (op_encode_hdr_maxsz + \ |
29 | encode_fallocate_maxsz) | |
30 | #define decode_deallocate_maxsz (op_decode_hdr_maxsz) | |
1c6dcbe5 AS |
31 | #define encode_seek_maxsz (op_encode_hdr_maxsz + \ |
32 | encode_stateid_maxsz + \ | |
33 | 2 /* offset */ + \ | |
34 | 1 /* whence */) | |
35 | #define decode_seek_maxsz (op_decode_hdr_maxsz + \ | |
36 | 1 /* eof */ + \ | |
37 | 1 /* whence */ + \ | |
38 | 2 /* offset */ + \ | |
39 | 2 /* length */) | |
be3a5d23 TM |
40 | #define encode_io_info_maxsz 4 |
41 | #define encode_layoutstats_maxsz (op_decode_hdr_maxsz + \ | |
42 | 2 /* offset */ + \ | |
43 | 2 /* length */ + \ | |
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) | |
36022770 PT |
50 | #define encode_clone_maxsz (encode_stateid_maxsz + \ |
51 | encode_stateid_maxsz + \ | |
52 | 2 /* src offset */ + \ | |
53 | 2 /* dst offset */ + \ | |
54 | 2 /* count */) | |
55 | #define decode_clone_maxsz (op_decode_hdr_maxsz) | |
1c6dcbe5 | 56 | |
f4ac1674 AS |
57 | #define NFS4_enc_allocate_sz (compound_encode_hdr_maxsz + \ |
58 | encode_putfh_maxsz + \ | |
9a51940b AS |
59 | encode_allocate_maxsz + \ |
60 | encode_getattr_maxsz) | |
f4ac1674 AS |
61 | #define NFS4_dec_allocate_sz (compound_decode_hdr_maxsz + \ |
62 | decode_putfh_maxsz + \ | |
9a51940b AS |
63 | decode_allocate_maxsz + \ |
64 | decode_getattr_maxsz) | |
2e72448b AS |
65 | #define NFS4_enc_copy_sz (compound_encode_hdr_maxsz + \ |
66 | encode_putfh_maxsz + \ | |
67 | encode_savefh_maxsz + \ | |
68 | encode_putfh_maxsz + \ | |
69 | encode_copy_maxsz) | |
70 | #define NFS4_dec_copy_sz (compound_decode_hdr_maxsz + \ | |
71 | decode_putfh_maxsz + \ | |
72 | decode_savefh_maxsz + \ | |
73 | decode_putfh_maxsz + \ | |
74 | decode_copy_maxsz) | |
624bd5b7 AS |
75 | #define NFS4_enc_deallocate_sz (compound_encode_hdr_maxsz + \ |
76 | encode_putfh_maxsz + \ | |
9a51940b AS |
77 | encode_deallocate_maxsz + \ |
78 | encode_getattr_maxsz) | |
624bd5b7 AS |
79 | #define NFS4_dec_deallocate_sz (compound_decode_hdr_maxsz + \ |
80 | decode_putfh_maxsz + \ | |
9a51940b AS |
81 | decode_deallocate_maxsz + \ |
82 | decode_getattr_maxsz) | |
1c6dcbe5 AS |
83 | #define NFS4_enc_seek_sz (compound_encode_hdr_maxsz + \ |
84 | encode_putfh_maxsz + \ | |
85 | encode_seek_maxsz) | |
86 | #define NFS4_dec_seek_sz (compound_decode_hdr_maxsz + \ | |
87 | decode_putfh_maxsz + \ | |
88 | decode_seek_maxsz) | |
be3a5d23 TM |
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) | |
36022770 PT |
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) | |
1c6dcbe5 | 111 | |
f4ac1674 AS |
112 | static void encode_fallocate(struct xdr_stream *xdr, |
113 | struct nfs42_falloc_args *args) | |
114 | { | |
115 | encode_nfs4_stateid(xdr, &args->falloc_stateid); | |
116 | encode_uint64(xdr, args->falloc_offset); | |
117 | encode_uint64(xdr, args->falloc_length); | |
118 | } | |
119 | ||
120 | static void encode_allocate(struct xdr_stream *xdr, | |
121 | struct nfs42_falloc_args *args, | |
122 | struct compound_hdr *hdr) | |
123 | { | |
124 | encode_op_hdr(xdr, OP_ALLOCATE, decode_allocate_maxsz, hdr); | |
125 | encode_fallocate(xdr, args); | |
126 | } | |
127 | ||
2e72448b AS |
128 | static void encode_copy(struct xdr_stream *xdr, |
129 | struct nfs42_copy_args *args, | |
130 | struct compound_hdr *hdr) | |
131 | { | |
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); | |
135 | ||
136 | encode_uint64(xdr, args->src_pos); | |
137 | encode_uint64(xdr, args->dst_pos); | |
138 | encode_uint64(xdr, args->count); | |
139 | ||
140 | encode_uint32(xdr, 1); /* consecutive = true */ | |
141 | encode_uint32(xdr, 1); /* synchronous = true */ | |
142 | encode_uint32(xdr, 0); /* src server list */ | |
143 | } | |
144 | ||
624bd5b7 AS |
145 | static void encode_deallocate(struct xdr_stream *xdr, |
146 | struct nfs42_falloc_args *args, | |
147 | struct compound_hdr *hdr) | |
148 | { | |
149 | encode_op_hdr(xdr, OP_DEALLOCATE, decode_deallocate_maxsz, hdr); | |
150 | encode_fallocate(xdr, args); | |
151 | } | |
152 | ||
1c6dcbe5 AS |
153 | static void encode_seek(struct xdr_stream *xdr, |
154 | struct nfs42_seek_args *args, | |
155 | struct compound_hdr *hdr) | |
156 | { | |
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); | |
161 | } | |
162 | ||
be3a5d23 TM |
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) | |
167 | { | |
168 | __be32 *p; | |
169 | ||
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); | |
186 | else | |
187 | encode_uint32(xdr, 0); | |
188 | } | |
189 | ||
36022770 PT |
190 | static void encode_clone(struct xdr_stream *xdr, |
191 | struct nfs42_clone_args *args, | |
192 | struct compound_hdr *hdr) | |
193 | { | |
194 | __be32 *p; | |
195 | ||
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); | |
203 | } | |
204 | ||
f4ac1674 AS |
205 | /* |
206 | * Encode ALLOCATE request | |
207 | */ | |
208 | static void nfs4_xdr_enc_allocate(struct rpc_rqst *req, | |
209 | struct xdr_stream *xdr, | |
210 | struct nfs42_falloc_args *args) | |
211 | { | |
212 | struct compound_hdr hdr = { | |
213 | .minorversion = nfs4_xdr_minorversion(&args->seq_args), | |
214 | }; | |
215 | ||
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); | |
9a51940b | 220 | encode_getfattr(xdr, args->falloc_bitmask, &hdr); |
f4ac1674 AS |
221 | encode_nops(&hdr); |
222 | } | |
223 | ||
2e72448b AS |
224 | /* |
225 | * Encode COPY request | |
226 | */ | |
227 | static void nfs4_xdr_enc_copy(struct rpc_rqst *req, | |
228 | struct xdr_stream *xdr, | |
229 | struct nfs42_copy_args *args) | |
230 | { | |
231 | struct compound_hdr hdr = { | |
232 | .minorversion = nfs4_xdr_minorversion(&args->seq_args), | |
233 | }; | |
234 | ||
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); | |
241 | encode_nops(&hdr); | |
242 | } | |
243 | ||
624bd5b7 AS |
244 | /* |
245 | * Encode DEALLOCATE request | |
246 | */ | |
247 | static void nfs4_xdr_enc_deallocate(struct rpc_rqst *req, | |
248 | struct xdr_stream *xdr, | |
249 | struct nfs42_falloc_args *args) | |
250 | { | |
251 | struct compound_hdr hdr = { | |
252 | .minorversion = nfs4_xdr_minorversion(&args->seq_args), | |
253 | }; | |
254 | ||
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); | |
9a51940b | 259 | encode_getfattr(xdr, args->falloc_bitmask, &hdr); |
624bd5b7 AS |
260 | encode_nops(&hdr); |
261 | } | |
262 | ||
1c6dcbe5 AS |
263 | /* |
264 | * Encode SEEK request | |
265 | */ | |
266 | static void nfs4_xdr_enc_seek(struct rpc_rqst *req, | |
267 | struct xdr_stream *xdr, | |
268 | struct nfs42_seek_args *args) | |
269 | { | |
270 | struct compound_hdr hdr = { | |
271 | .minorversion = nfs4_xdr_minorversion(&args->seq_args), | |
272 | }; | |
273 | ||
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); | |
278 | encode_nops(&hdr); | |
279 | } | |
280 | ||
be3a5d23 TM |
281 | /* |
282 | * Encode LAYOUTSTATS request | |
283 | */ | |
284 | static void nfs4_xdr_enc_layoutstats(struct rpc_rqst *req, | |
285 | struct xdr_stream *xdr, | |
286 | struct nfs42_layoutstat_args *args) | |
287 | { | |
288 | int i; | |
289 | ||
290 | struct compound_hdr hdr = { | |
291 | .minorversion = nfs4_xdr_minorversion(&args->seq_args), | |
292 | }; | |
293 | ||
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); | |
300 | encode_nops(&hdr); | |
301 | } | |
302 | ||
36022770 PT |
303 | /* |
304 | * Encode CLONE request | |
305 | */ | |
306 | static void nfs4_xdr_enc_clone(struct rpc_rqst *req, | |
307 | struct xdr_stream *xdr, | |
308 | struct nfs42_clone_args *args) | |
309 | { | |
310 | struct compound_hdr hdr = { | |
311 | .minorversion = nfs4_xdr_minorversion(&args->seq_args), | |
312 | }; | |
313 | ||
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); | |
321 | encode_nops(&hdr); | |
322 | } | |
323 | ||
f4ac1674 AS |
324 | static int decode_allocate(struct xdr_stream *xdr, struct nfs42_falloc_res *res) |
325 | { | |
326 | return decode_op_hdr(xdr, OP_ALLOCATE); | |
327 | } | |
328 | ||
2e72448b AS |
329 | static int decode_write_response(struct xdr_stream *xdr, |
330 | struct nfs42_write_res *res) | |
331 | { | |
332 | __be32 *p; | |
333 | int stateids; | |
334 | ||
335 | p = xdr_inline_decode(xdr, 4 + 8 + 4); | |
336 | if (unlikely(!p)) | |
337 | goto out_overflow; | |
338 | ||
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); | |
343 | ||
344 | out_overflow: | |
345 | print_overflow_msg(__func__, xdr); | |
346 | return -EIO; | |
347 | } | |
348 | ||
349 | static int decode_copy_requirements(struct xdr_stream *xdr, | |
350 | struct nfs42_copy_res *res) { | |
351 | __be32 *p; | |
352 | ||
353 | p = xdr_inline_decode(xdr, 4 + 4); | |
354 | if (unlikely(!p)) | |
355 | goto out_overflow; | |
356 | ||
357 | res->consecutive = be32_to_cpup(p++); | |
358 | res->synchronous = be32_to_cpup(p++); | |
359 | return 0; | |
360 | out_overflow: | |
361 | print_overflow_msg(__func__, xdr); | |
362 | return -EIO; | |
363 | } | |
364 | ||
365 | static int decode_copy(struct xdr_stream *xdr, struct nfs42_copy_res *res) | |
366 | { | |
367 | int status; | |
368 | ||
369 | status = decode_op_hdr(xdr, OP_COPY); | |
370 | if (status == NFS4ERR_OFFLOAD_NO_REQS) { | |
371 | status = decode_copy_requirements(xdr, res); | |
372 | if (status) | |
373 | return status; | |
374 | return NFS4ERR_OFFLOAD_NO_REQS; | |
375 | } else if (status) | |
376 | return status; | |
377 | ||
378 | status = decode_write_response(xdr, &res->write_res); | |
379 | if (status) | |
380 | return status; | |
381 | ||
382 | return decode_copy_requirements(xdr, res); | |
383 | } | |
384 | ||
624bd5b7 AS |
385 | static int decode_deallocate(struct xdr_stream *xdr, struct nfs42_falloc_res *res) |
386 | { | |
387 | return decode_op_hdr(xdr, OP_DEALLOCATE); | |
388 | } | |
389 | ||
1c6dcbe5 AS |
390 | static int decode_seek(struct xdr_stream *xdr, struct nfs42_seek_res *res) |
391 | { | |
392 | int status; | |
393 | __be32 *p; | |
394 | ||
395 | status = decode_op_hdr(xdr, OP_SEEK); | |
396 | if (status) | |
397 | return status; | |
398 | ||
399 | p = xdr_inline_decode(xdr, 4 + 8); | |
400 | if (unlikely(!p)) | |
401 | goto out_overflow; | |
402 | ||
403 | res->sr_eof = be32_to_cpup(p++); | |
404 | p = xdr_decode_hyper(p, &res->sr_offset); | |
405 | return 0; | |
406 | ||
407 | out_overflow: | |
408 | print_overflow_msg(__func__, xdr); | |
409 | return -EIO; | |
410 | } | |
411 | ||
19cf6335 | 412 | static int decode_layoutstats(struct xdr_stream *xdr) |
be3a5d23 | 413 | { |
da2e8127 | 414 | return decode_op_hdr(xdr, OP_LAYOUTSTATS); |
be3a5d23 TM |
415 | } |
416 | ||
36022770 PT |
417 | static int decode_clone(struct xdr_stream *xdr) |
418 | { | |
419 | return decode_op_hdr(xdr, OP_CLONE); | |
420 | } | |
421 | ||
f4ac1674 AS |
422 | /* |
423 | * Decode ALLOCATE request | |
424 | */ | |
425 | static int nfs4_xdr_dec_allocate(struct rpc_rqst *rqstp, | |
426 | struct xdr_stream *xdr, | |
427 | struct nfs42_falloc_res *res) | |
428 | { | |
429 | struct compound_hdr hdr; | |
430 | int status; | |
431 | ||
432 | status = decode_compound_hdr(xdr, &hdr); | |
433 | if (status) | |
434 | goto out; | |
435 | status = decode_sequence(xdr, &res->seq_res, rqstp); | |
436 | if (status) | |
437 | goto out; | |
438 | status = decode_putfh(xdr); | |
439 | if (status) | |
440 | goto out; | |
441 | status = decode_allocate(xdr, res); | |
9a51940b AS |
442 | if (status) |
443 | goto out; | |
444 | decode_getfattr(xdr, res->falloc_fattr, res->falloc_server); | |
f4ac1674 AS |
445 | out: |
446 | return status; | |
447 | } | |
448 | ||
2e72448b AS |
449 | /* |
450 | * Decode COPY response | |
451 | */ | |
452 | static int nfs4_xdr_dec_copy(struct rpc_rqst *rqstp, | |
453 | struct xdr_stream *xdr, | |
454 | struct nfs42_copy_res *res) | |
455 | { | |
456 | struct compound_hdr hdr; | |
457 | int status; | |
458 | ||
459 | status = decode_compound_hdr(xdr, &hdr); | |
460 | if (status) | |
461 | goto out; | |
462 | status = decode_sequence(xdr, &res->seq_res, rqstp); | |
463 | if (status) | |
464 | goto out; | |
465 | status = decode_putfh(xdr); | |
466 | if (status) | |
467 | goto out; | |
468 | status = decode_savefh(xdr); | |
469 | if (status) | |
470 | goto out; | |
471 | status = decode_putfh(xdr); | |
472 | if (status) | |
473 | goto out; | |
474 | status = decode_copy(xdr, res); | |
475 | out: | |
476 | return status; | |
477 | } | |
478 | ||
624bd5b7 AS |
479 | /* |
480 | * Decode DEALLOCATE request | |
481 | */ | |
482 | static int nfs4_xdr_dec_deallocate(struct rpc_rqst *rqstp, | |
483 | struct xdr_stream *xdr, | |
484 | struct nfs42_falloc_res *res) | |
485 | { | |
486 | struct compound_hdr hdr; | |
487 | int status; | |
488 | ||
489 | status = decode_compound_hdr(xdr, &hdr); | |
490 | if (status) | |
491 | goto out; | |
492 | status = decode_sequence(xdr, &res->seq_res, rqstp); | |
493 | if (status) | |
494 | goto out; | |
495 | status = decode_putfh(xdr); | |
496 | if (status) | |
497 | goto out; | |
498 | status = decode_deallocate(xdr, res); | |
9a51940b AS |
499 | if (status) |
500 | goto out; | |
501 | decode_getfattr(xdr, res->falloc_fattr, res->falloc_server); | |
624bd5b7 AS |
502 | out: |
503 | return status; | |
504 | } | |
505 | ||
1c6dcbe5 AS |
506 | /* |
507 | * Decode SEEK request | |
508 | */ | |
509 | static int nfs4_xdr_dec_seek(struct rpc_rqst *rqstp, | |
510 | struct xdr_stream *xdr, | |
511 | struct nfs42_seek_res *res) | |
512 | { | |
513 | struct compound_hdr hdr; | |
514 | int status; | |
515 | ||
516 | status = decode_compound_hdr(xdr, &hdr); | |
517 | if (status) | |
518 | goto out; | |
519 | status = decode_sequence(xdr, &res->seq_res, rqstp); | |
520 | if (status) | |
521 | goto out; | |
522 | status = decode_putfh(xdr); | |
523 | if (status) | |
524 | goto out; | |
525 | status = decode_seek(xdr, res); | |
526 | out: | |
527 | return status; | |
528 | } | |
be3a5d23 TM |
529 | |
530 | /* | |
531 | * Decode LAYOUTSTATS request | |
532 | */ | |
533 | static int nfs4_xdr_dec_layoutstats(struct rpc_rqst *rqstp, | |
534 | struct xdr_stream *xdr, | |
535 | struct nfs42_layoutstat_res *res) | |
536 | { | |
537 | struct compound_hdr hdr; | |
538 | int status, i; | |
539 | ||
540 | status = decode_compound_hdr(xdr, &hdr); | |
541 | if (status) | |
542 | goto out; | |
543 | status = decode_sequence(xdr, &res->seq_res, rqstp); | |
544 | if (status) | |
545 | goto out; | |
546 | status = decode_putfh(xdr); | |
547 | if (status) | |
548 | goto out; | |
549 | WARN_ON(res->num_dev > PNFS_LAYOUTSTATS_MAXDEV); | |
550 | for (i = 0; i < res->num_dev; i++) { | |
19cf6335 | 551 | status = decode_layoutstats(xdr); |
be3a5d23 TM |
552 | if (status) |
553 | goto out; | |
554 | } | |
555 | out: | |
556 | res->rpc_status = status; | |
557 | return status; | |
558 | } | |
559 | ||
36022770 PT |
560 | /* |
561 | * Decode CLONE request | |
562 | */ | |
563 | static int nfs4_xdr_dec_clone(struct rpc_rqst *rqstp, | |
564 | struct xdr_stream *xdr, | |
565 | struct nfs42_clone_res *res) | |
566 | { | |
567 | struct compound_hdr hdr; | |
568 | int status; | |
569 | ||
570 | status = decode_compound_hdr(xdr, &hdr); | |
571 | if (status) | |
572 | goto out; | |
573 | status = decode_sequence(xdr, &res->seq_res, rqstp); | |
574 | if (status) | |
575 | goto out; | |
576 | status = decode_putfh(xdr); | |
577 | if (status) | |
578 | goto out; | |
579 | status = decode_savefh(xdr); | |
580 | if (status) | |
581 | goto out; | |
582 | status = decode_putfh(xdr); | |
583 | if (status) | |
584 | goto out; | |
585 | status = decode_clone(xdr); | |
586 | if (status) | |
587 | goto out; | |
588 | status = decode_getfattr(xdr, res->dst_fattr, res->server); | |
589 | ||
590 | out: | |
591 | res->rpc_status = status; | |
592 | return status; | |
593 | } | |
594 | ||
1c6dcbe5 | 595 | #endif /* __LINUX_FS_NFS_NFS4_2XDR_H */ |