Branch data Line data Source code
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 : :
153 : 0 : static void encode_fallocate(struct xdr_stream *xdr,
154 : : const struct nfs42_falloc_args *args)
155 : : {
156 : 0 : encode_nfs4_stateid(xdr, &args->falloc_stateid);
157 : 0 : encode_uint64(xdr, args->falloc_offset);
158 : 0 : encode_uint64(xdr, args->falloc_length);
159 : 0 : }
160 : :
161 : 0 : static 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 : 0 : encode_fallocate(xdr, args);
167 : 0 : }
168 : :
169 : 0 : static 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 : 0 : encode_nfs4_stateid(xdr, &args->src_stateid);
175 : 0 : encode_nfs4_stateid(xdr, &args->dst_stateid);
176 : :
177 : 0 : encode_uint64(xdr, args->src_pos);
178 : 0 : encode_uint64(xdr, args->dst_pos);
179 : 0 : encode_uint64(xdr, args->count);
180 : :
181 : 0 : encode_uint32(xdr, 1); /* consecutive = true */
182 : 0 : encode_uint32(xdr, args->sync);
183 : 0 : encode_uint32(xdr, 0); /* src server list */
184 : 0 : }
185 : :
186 : 0 : static 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 : 0 : encode_nfs4_stateid(xdr, &args->osa_stateid);
192 : 0 : }
193 : :
194 : 0 : static 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 : 0 : encode_fallocate(xdr, args);
200 : 0 : }
201 : :
202 : 0 : static 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 : 0 : encode_nfs4_stateid(xdr, &args->sa_stateid);
208 : 0 : encode_uint64(xdr, args->sa_offset);
209 : 0 : encode_uint32(xdr, args->sa_what);
210 : 0 : }
211 : :
212 : 0 : static 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 : 0 : p = reserve_space(xdr, 8 + 8);
221 : 0 : p = xdr_encode_hyper(p, devinfo->offset);
222 : 0 : p = xdr_encode_hyper(p, devinfo->length);
223 : 0 : encode_nfs4_stateid(xdr, &args->stateid);
224 : 0 : p = reserve_space(xdr, 4*8 + NFS4_DEVICEID4_SIZE + 4);
225 : 0 : p = xdr_encode_hyper(p, devinfo->read_count);
226 : 0 : p = xdr_encode_hyper(p, devinfo->read_bytes);
227 : 0 : p = xdr_encode_hyper(p, devinfo->write_count);
228 : 0 : p = xdr_encode_hyper(p, devinfo->write_bytes);
229 : 0 : p = xdr_encode_opaque_fixed(p, devinfo->dev_id.data,
230 : : NFS4_DEVICEID4_SIZE);
231 : : /* Encode layoutupdate4 */
232 : 0 : *p++ = cpu_to_be32(devinfo->layout_type);
233 : 0 : if (devinfo->ld_private.ops)
234 : 0 : devinfo->ld_private.ops->encode(xdr, args,
235 : 0 : &devinfo->ld_private);
236 : : else
237 : 0 : encode_uint32(xdr, 0);
238 : 0 : }
239 : :
240 : 0 : static 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 : 0 : encode_nfs4_stateid(xdr, &args->src_stateid);
248 : 0 : encode_nfs4_stateid(xdr, &args->dst_stateid);
249 : 0 : p = reserve_space(xdr, 3*8);
250 : 0 : p = xdr_encode_hyper(p, args->src_offset);
251 : 0 : p = xdr_encode_hyper(p, args->dst_offset);
252 : 0 : xdr_encode_hyper(p, args->count);
253 : 0 : }
254 : :
255 : 0 : static void encode_device_error(struct xdr_stream *xdr,
256 : : const struct nfs42_device_error *error)
257 : : {
258 : : __be32 *p;
259 : :
260 : 0 : p = reserve_space(xdr, NFS4_DEVICEID4_SIZE + 2*4);
261 : 0 : p = xdr_encode_opaque_fixed(p, error->dev_id.data,
262 : : NFS4_DEVICEID4_SIZE);
263 : 0 : *p++ = cpu_to_be32(error->status);
264 : 0 : *p = cpu_to_be32(error->opnum);
265 : 0 : }
266 : :
267 : 0 : static 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 : 0 : p = reserve_space(xdr, 8 + 8);
275 : 0 : p = xdr_encode_hyper(p, args->offset);
276 : 0 : p = xdr_encode_hyper(p, args->length);
277 : 0 : encode_nfs4_stateid(xdr, &args->stateid);
278 : 0 : p = reserve_space(xdr, 4);
279 : 0 : *p = cpu_to_be32(1);
280 : 0 : encode_device_error(xdr, &args->errors[0]);
281 : 0 : }
282 : :
283 : : /*
284 : : * Encode ALLOCATE request
285 : : */
286 : 0 : static 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 : 0 : struct compound_hdr hdr = {
292 : : .minorversion = nfs4_xdr_minorversion(&args->seq_args),
293 : : };
294 : :
295 : 0 : encode_compound_hdr(xdr, req, &hdr);
296 : 0 : encode_sequence(xdr, &args->seq_args, &hdr);
297 : 0 : encode_putfh(xdr, args->falloc_fh, &hdr);
298 : 0 : encode_allocate(xdr, args, &hdr);
299 : 0 : encode_getfattr(xdr, args->falloc_bitmask, &hdr);
300 : 0 : encode_nops(&hdr);
301 : 0 : }
302 : :
303 : 0 : static 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 : 0 : p = reserve_space(xdr, 12);
311 : 0 : p = xdr_encode_hyper(p, args->dst_pos);
312 : 0 : *p = cpu_to_be32(args->count);
313 : 0 : }
314 : :
315 : : /*
316 : : * Encode COPY request
317 : : */
318 : 0 : static 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 : 0 : struct compound_hdr hdr = {
324 : : .minorversion = nfs4_xdr_minorversion(&args->seq_args),
325 : : };
326 : :
327 : 0 : encode_compound_hdr(xdr, req, &hdr);
328 : 0 : encode_sequence(xdr, &args->seq_args, &hdr);
329 : 0 : encode_putfh(xdr, args->src_fh, &hdr);
330 : : encode_savefh(xdr, &hdr);
331 : 0 : encode_putfh(xdr, args->dst_fh, &hdr);
332 : 0 : encode_copy(xdr, args, &hdr);
333 : 0 : if (args->sync)
334 : 0 : encode_copy_commit(xdr, args, &hdr);
335 : 0 : encode_nops(&hdr);
336 : 0 : }
337 : :
338 : : /*
339 : : * Encode OFFLOAD_CANEL request
340 : : */
341 : 0 : static 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 : 0 : struct compound_hdr hdr = {
347 : : .minorversion = nfs4_xdr_minorversion(&args->osa_seq_args),
348 : : };
349 : :
350 : 0 : encode_compound_hdr(xdr, req, &hdr);
351 : 0 : encode_sequence(xdr, &args->osa_seq_args, &hdr);
352 : 0 : encode_putfh(xdr, args->osa_src_fh, &hdr);
353 : 0 : encode_offload_cancel(xdr, args, &hdr);
354 : 0 : encode_nops(&hdr);
355 : 0 : }
356 : :
357 : : /*
358 : : * Encode DEALLOCATE request
359 : : */
360 : 0 : static 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 : 0 : struct compound_hdr hdr = {
366 : : .minorversion = nfs4_xdr_minorversion(&args->seq_args),
367 : : };
368 : :
369 : 0 : encode_compound_hdr(xdr, req, &hdr);
370 : 0 : encode_sequence(xdr, &args->seq_args, &hdr);
371 : 0 : encode_putfh(xdr, args->falloc_fh, &hdr);
372 : 0 : encode_deallocate(xdr, args, &hdr);
373 : 0 : encode_getfattr(xdr, args->falloc_bitmask, &hdr);
374 : 0 : encode_nops(&hdr);
375 : 0 : }
376 : :
377 : : /*
378 : : * Encode SEEK request
379 : : */
380 : 0 : static 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 : 0 : struct compound_hdr hdr = {
386 : : .minorversion = nfs4_xdr_minorversion(&args->seq_args),
387 : : };
388 : :
389 : 0 : encode_compound_hdr(xdr, req, &hdr);
390 : 0 : encode_sequence(xdr, &args->seq_args, &hdr);
391 : 0 : encode_putfh(xdr, args->sa_fh, &hdr);
392 : 0 : encode_seek(xdr, args, &hdr);
393 : 0 : encode_nops(&hdr);
394 : 0 : }
395 : :
396 : : /*
397 : : * Encode LAYOUTSTATS request
398 : : */
399 : 0 : static 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 : 0 : struct compound_hdr hdr = {
407 : : .minorversion = nfs4_xdr_minorversion(&args->seq_args),
408 : : };
409 : :
410 : 0 : encode_compound_hdr(xdr, req, &hdr);
411 : 0 : encode_sequence(xdr, &args->seq_args, &hdr);
412 : 0 : encode_putfh(xdr, args->fh, &hdr);
413 : 0 : WARN_ON(args->num_dev > PNFS_LAYOUTSTATS_MAXDEV);
414 : 0 : for (i = 0; i < args->num_dev; i++)
415 : 0 : encode_layoutstats(xdr, args, &args->devinfo[i], &hdr);
416 : 0 : encode_nops(&hdr);
417 : 0 : }
418 : :
419 : : /*
420 : : * Encode CLONE request
421 : : */
422 : 0 : static 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 : 0 : struct compound_hdr hdr = {
428 : : .minorversion = nfs4_xdr_minorversion(&args->seq_args),
429 : : };
430 : :
431 : 0 : encode_compound_hdr(xdr, req, &hdr);
432 : 0 : encode_sequence(xdr, &args->seq_args, &hdr);
433 : 0 : encode_putfh(xdr, args->src_fh, &hdr);
434 : : encode_savefh(xdr, &hdr);
435 : 0 : encode_putfh(xdr, args->dst_fh, &hdr);
436 : 0 : encode_clone(xdr, args, &hdr);
437 : 0 : encode_getfattr(xdr, args->dst_bitmask, &hdr);
438 : 0 : encode_nops(&hdr);
439 : 0 : }
440 : :
441 : : /*
442 : : * Encode LAYOUTERROR request
443 : : */
444 : 0 : static 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 : 0 : struct compound_hdr hdr = {
450 : : .minorversion = nfs4_xdr_minorversion(&args->seq_args),
451 : : };
452 : : int i;
453 : :
454 : 0 : encode_compound_hdr(xdr, req, &hdr);
455 : 0 : encode_sequence(xdr, &args->seq_args, &hdr);
456 : 0 : encode_putfh(xdr, NFS_FH(args->inode), &hdr);
457 : 0 : for (i = 0; i < args->num_errors; i++)
458 : 0 : encode_layouterror(xdr, &args->errors[i], &hdr);
459 : 0 : encode_nops(&hdr);
460 : 0 : }
461 : :
462 : : static int decode_allocate(struct xdr_stream *xdr, struct nfs42_falloc_res *res)
463 : : {
464 : : return decode_op_hdr(xdr, OP_ALLOCATE);
465 : : }
466 : :
467 : 0 : static int decode_write_response(struct xdr_stream *xdr,
468 : : struct nfs42_write_res *res)
469 : : {
470 : : __be32 *p;
471 : : int status, count;
472 : :
473 : 0 : p = xdr_inline_decode(xdr, 4);
474 : 0 : if (unlikely(!p))
475 : : return -EIO;
476 : 0 : count = be32_to_cpup(p);
477 : 0 : if (count > 1)
478 : : return -EREMOTEIO;
479 : 0 : else if (count == 1) {
480 : 0 : status = decode_opaque_fixed(xdr, &res->stateid,
481 : : NFS4_STATEID_SIZE);
482 : 0 : if (unlikely(status))
483 : : return -EIO;
484 : : }
485 : 0 : p = xdr_inline_decode(xdr, 8 + 4);
486 : 0 : if (unlikely(!p))
487 : : return -EIO;
488 : : p = xdr_decode_hyper(p, &res->count);
489 : 0 : res->verifier.committed = be32_to_cpup(p);
490 : 0 : return decode_verifier(xdr, &res->verifier.verifier);
491 : : }
492 : :
493 : 0 : static int decode_copy_requirements(struct xdr_stream *xdr,
494 : : struct nfs42_copy_res *res) {
495 : : __be32 *p;
496 : :
497 : 0 : p = xdr_inline_decode(xdr, 4 + 4);
498 : 0 : if (unlikely(!p))
499 : : return -EIO;
500 : :
501 : 0 : res->consecutive = be32_to_cpup(p++);
502 : 0 : res->synchronous = be32_to_cpup(p++);
503 : 0 : return 0;
504 : : }
505 : :
506 : 0 : static 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 : 0 : if (status == NFS4ERR_OFFLOAD_NO_REQS) {
512 : 0 : status = decode_copy_requirements(xdr, res);
513 : 0 : if (status)
514 : 0 : return status;
515 : : return NFS4ERR_OFFLOAD_NO_REQS;
516 : 0 : } else if (status)
517 : : return status;
518 : :
519 : 0 : status = decode_write_response(xdr, &res->write_res);
520 : 0 : if (status)
521 : : return status;
522 : :
523 : 0 : return decode_copy_requirements(xdr, res);
524 : : }
525 : :
526 : : static 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 : :
532 : : static int decode_deallocate(struct xdr_stream *xdr, struct nfs42_falloc_res *res)
533 : : {
534 : : return decode_op_hdr(xdr, OP_DEALLOCATE);
535 : : }
536 : :
537 : 0 : static 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 : 0 : if (status)
544 : : return status;
545 : :
546 : 0 : p = xdr_inline_decode(xdr, 4 + 8);
547 : 0 : if (unlikely(!p))
548 : : return -EIO;
549 : :
550 : 0 : res->sr_eof = be32_to_cpup(p++);
551 : : p = xdr_decode_hyper(p, &res->sr_offset);
552 : 0 : return 0;
553 : : }
554 : :
555 : : static int decode_layoutstats(struct xdr_stream *xdr)
556 : : {
557 : : return decode_op_hdr(xdr, OP_LAYOUTSTATS);
558 : : }
559 : :
560 : : static int decode_clone(struct xdr_stream *xdr)
561 : : {
562 : : return decode_op_hdr(xdr, OP_CLONE);
563 : : }
564 : :
565 : : static int decode_layouterror(struct xdr_stream *xdr)
566 : : {
567 : : return decode_op_hdr(xdr, OP_LAYOUTERROR);
568 : : }
569 : :
570 : : /*
571 : : * Decode ALLOCATE request
572 : : */
573 : 0 : static 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 : 0 : status = decode_compound_hdr(xdr, &hdr);
582 : 0 : if (status)
583 : : goto out;
584 : 0 : status = decode_sequence(xdr, &res->seq_res, rqstp);
585 : 0 : if (status)
586 : : goto out;
587 : : status = decode_putfh(xdr);
588 : 0 : if (status)
589 : : goto out;
590 : : status = decode_allocate(xdr, res);
591 : 0 : if (status)
592 : : goto out;
593 : 0 : decode_getfattr(xdr, res->falloc_fattr, res->falloc_server);
594 : : out:
595 : 0 : return status;
596 : : }
597 : :
598 : : /*
599 : : * Decode COPY response
600 : : */
601 : 0 : static 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 : 0 : status = decode_compound_hdr(xdr, &hdr);
610 : 0 : if (status)
611 : : goto out;
612 : 0 : status = decode_sequence(xdr, &res->seq_res, rqstp);
613 : 0 : if (status)
614 : : goto out;
615 : : status = decode_putfh(xdr);
616 : 0 : if (status)
617 : : goto out;
618 : : status = decode_savefh(xdr);
619 : 0 : if (status)
620 : : goto out;
621 : : status = decode_putfh(xdr);
622 : 0 : if (status)
623 : : goto out;
624 : 0 : status = decode_copy(xdr, res);
625 : 0 : if (status)
626 : : goto out;
627 : 0 : if (res->commit_res.verf)
628 : 0 : status = decode_commit(xdr, &res->commit_res);
629 : : out:
630 : 0 : return status;
631 : : }
632 : :
633 : : /*
634 : : * Decode OFFLOAD_CANCEL response
635 : : */
636 : 0 : static 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 : 0 : status = decode_compound_hdr(xdr, &hdr);
645 : 0 : if (status)
646 : : goto out;
647 : 0 : status = decode_sequence(xdr, &res->osr_seq_res, rqstp);
648 : 0 : if (status)
649 : : goto out;
650 : : status = decode_putfh(xdr);
651 : 0 : if (status)
652 : : goto out;
653 : : status = decode_offload_cancel(xdr, res);
654 : :
655 : : out:
656 : 0 : return status;
657 : : }
658 : :
659 : : /*
660 : : * Decode DEALLOCATE request
661 : : */
662 : 0 : static 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 : 0 : status = decode_compound_hdr(xdr, &hdr);
671 : 0 : if (status)
672 : : goto out;
673 : 0 : status = decode_sequence(xdr, &res->seq_res, rqstp);
674 : 0 : if (status)
675 : : goto out;
676 : : status = decode_putfh(xdr);
677 : 0 : if (status)
678 : : goto out;
679 : : status = decode_deallocate(xdr, res);
680 : 0 : if (status)
681 : : goto out;
682 : 0 : decode_getfattr(xdr, res->falloc_fattr, res->falloc_server);
683 : : out:
684 : 0 : return status;
685 : : }
686 : :
687 : : /*
688 : : * Decode SEEK request
689 : : */
690 : 0 : static 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 : 0 : status = decode_compound_hdr(xdr, &hdr);
699 : 0 : if (status)
700 : : goto out;
701 : 0 : status = decode_sequence(xdr, &res->seq_res, rqstp);
702 : 0 : if (status)
703 : : goto out;
704 : : status = decode_putfh(xdr);
705 : 0 : if (status)
706 : : goto out;
707 : 0 : status = decode_seek(xdr, res);
708 : : out:
709 : 0 : return status;
710 : : }
711 : :
712 : : /*
713 : : * Decode LAYOUTSTATS request
714 : : */
715 : 0 : static 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 : 0 : status = decode_compound_hdr(xdr, &hdr);
724 : 0 : if (status)
725 : : goto out;
726 : 0 : status = decode_sequence(xdr, &res->seq_res, rqstp);
727 : 0 : if (status)
728 : : goto out;
729 : : status = decode_putfh(xdr);
730 : 0 : if (status)
731 : : goto out;
732 : 0 : WARN_ON(res->num_dev > PNFS_LAYOUTSTATS_MAXDEV);
733 : 0 : for (i = 0; i < res->num_dev; i++) {
734 : : status = decode_layoutstats(xdr);
735 : 0 : if (status)
736 : : goto out;
737 : : }
738 : : out:
739 : 0 : res->rpc_status = status;
740 : 0 : return status;
741 : : }
742 : :
743 : : /*
744 : : * Decode CLONE request
745 : : */
746 : 0 : static 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 : 0 : status = decode_compound_hdr(xdr, &hdr);
755 : 0 : if (status)
756 : : goto out;
757 : 0 : status = decode_sequence(xdr, &res->seq_res, rqstp);
758 : 0 : if (status)
759 : : goto out;
760 : : status = decode_putfh(xdr);
761 : 0 : if (status)
762 : : goto out;
763 : : status = decode_savefh(xdr);
764 : 0 : if (status)
765 : : goto out;
766 : : status = decode_putfh(xdr);
767 : 0 : if (status)
768 : : goto out;
769 : : status = decode_clone(xdr);
770 : 0 : if (status)
771 : : goto out;
772 : 0 : status = decode_getfattr(xdr, res->dst_fattr, res->server);
773 : :
774 : : out:
775 : 0 : res->rpc_status = status;
776 : 0 : return status;
777 : : }
778 : :
779 : : /*
780 : : * Decode LAYOUTERROR request
781 : : */
782 : 0 : static 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 : 0 : status = decode_compound_hdr(xdr, &hdr);
791 : 0 : if (status)
792 : : goto out;
793 : 0 : status = decode_sequence(xdr, &res->seq_res, rqstp);
794 : 0 : if (status)
795 : : goto out;
796 : : status = decode_putfh(xdr);
797 : :
798 : 0 : for (i = 0; i < res->num_errors && status == 0; i++)
799 : : status = decode_layouterror(xdr);
800 : : out:
801 : 0 : res->rpc_status = status;
802 : 0 : return status;
803 : : }
804 : :
805 : : #endif /* __LINUX_FS_NFS_NFS4_2XDR_H */
|
