39 #include <linux/time.h>
41 #include <linux/errno.h>
42 #include <linux/string.h>
46 #include <linux/kdev_t.h>
47 #include <linux/module.h>
48 #include <linux/utsname.h>
52 #include <linux/nfs.h>
53 #include <linux/nfs4.h>
54 #include <linux/nfs_fs.h>
55 #include <linux/nfs_idmap.h>
62 #define NFSDBG_FACILITY NFSDBG_XDR
65 #define errno_NFSERR_IO EIO
67 static int nfs4_stat_to_errno(
int);
71 #define NFS4_MAXTAGLEN 20
73 #define NFS4_MAXTAGLEN 0
79 #define open_owner_id_maxsz (1 + 2 + 1 + 1 + 2)
80 #define lock_owner_id_maxsz (1 + 1 + 4)
81 #define decode_lockowner_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
82 #define compound_encode_hdr_maxsz (3 + (NFS4_MAXTAGLEN >> 2))
83 #define compound_decode_hdr_maxsz (3 + (NFS4_MAXTAGLEN >> 2))
84 #define op_encode_hdr_maxsz (1)
85 #define op_decode_hdr_maxsz (2)
86 #define encode_stateid_maxsz (XDR_QUADLEN(NFS4_STATEID_SIZE))
87 #define decode_stateid_maxsz (XDR_QUADLEN(NFS4_STATEID_SIZE))
88 #define encode_verifier_maxsz (XDR_QUADLEN(NFS4_VERIFIER_SIZE))
89 #define decode_verifier_maxsz (XDR_QUADLEN(NFS4_VERIFIER_SIZE))
90 #define encode_putfh_maxsz (op_encode_hdr_maxsz + 1 + \
92 #define decode_putfh_maxsz (op_decode_hdr_maxsz)
93 #define encode_putrootfh_maxsz (op_encode_hdr_maxsz)
94 #define decode_putrootfh_maxsz (op_decode_hdr_maxsz)
95 #define encode_getfh_maxsz (op_encode_hdr_maxsz)
96 #define decode_getfh_maxsz (op_decode_hdr_maxsz + 1 + \
97 ((3+NFS4_FHSIZE) >> 2))
98 #define nfs4_fattr_bitmap_maxsz 4
99 #define encode_getattr_maxsz (op_encode_hdr_maxsz + nfs4_fattr_bitmap_maxsz)
100 #define nfs4_name_maxsz (1 + ((3 + NFS4_MAXNAMLEN) >> 2))
101 #define nfs4_path_maxsz (1 + ((3 + NFS4_MAXPATHLEN) >> 2))
102 #define nfs4_owner_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
103 #define nfs4_group_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
105 #define decode_mdsthreshold_maxsz (1 + 1 + nfs4_fattr_bitmap_maxsz + 1 + 8)
107 #define nfs4_fattr_value_maxsz (1 + (1 + 2 + 2 + 4 + 2 + 1 + 1 + 2 + 2 + \
108 3 + 3 + 3 + nfs4_owner_maxsz + \
109 nfs4_group_maxsz + decode_mdsthreshold_maxsz))
110 #define nfs4_fattr_maxsz (nfs4_fattr_bitmap_maxsz + \
111 nfs4_fattr_value_maxsz)
112 #define decode_getattr_maxsz (op_decode_hdr_maxsz + nfs4_fattr_maxsz)
113 #define encode_attrs_maxsz (nfs4_fattr_bitmap_maxsz + \
118 #define encode_savefh_maxsz (op_encode_hdr_maxsz)
119 #define decode_savefh_maxsz (op_decode_hdr_maxsz)
120 #define encode_restorefh_maxsz (op_encode_hdr_maxsz)
121 #define decode_restorefh_maxsz (op_decode_hdr_maxsz)
122 #define encode_fsinfo_maxsz (encode_getattr_maxsz)
126 #define decode_fsinfo_maxsz (op_decode_hdr_maxsz + \
127 nfs4_fattr_bitmap_maxsz + 4 + 8 + 5)
128 #define encode_renew_maxsz (op_encode_hdr_maxsz + 3)
129 #define decode_renew_maxsz (op_decode_hdr_maxsz)
130 #define encode_setclientid_maxsz \
131 (op_encode_hdr_maxsz + \
132 XDR_QUADLEN(NFS4_VERIFIER_SIZE) + \
133 XDR_QUADLEN(NFS4_SETCLIENTID_NAMELEN) + \
135 XDR_QUADLEN(RPCBIND_MAXNETIDLEN) + \
136 XDR_QUADLEN(RPCBIND_MAXUADDRLEN) + \
138 #define decode_setclientid_maxsz \
139 (op_decode_hdr_maxsz + \
142 #define encode_setclientid_confirm_maxsz \
143 (op_encode_hdr_maxsz + \
144 3 + (NFS4_VERIFIER_SIZE >> 2))
145 #define decode_setclientid_confirm_maxsz \
146 (op_decode_hdr_maxsz)
147 #define encode_lookup_maxsz (op_encode_hdr_maxsz + nfs4_name_maxsz)
148 #define decode_lookup_maxsz (op_decode_hdr_maxsz)
149 #define encode_share_access_maxsz \
151 #define encode_createmode_maxsz (1 + encode_attrs_maxsz + encode_verifier_maxsz)
152 #define encode_opentype_maxsz (1 + encode_createmode_maxsz)
153 #define encode_claim_null_maxsz (1 + nfs4_name_maxsz)
154 #define encode_open_maxsz (op_encode_hdr_maxsz + \
155 2 + encode_share_access_maxsz + 2 + \
156 open_owner_id_maxsz + \
157 encode_opentype_maxsz + \
158 encode_claim_null_maxsz)
159 #define decode_ace_maxsz (3 + nfs4_owner_maxsz)
160 #define decode_delegation_maxsz (1 + decode_stateid_maxsz + 1 + \
162 #define decode_change_info_maxsz (5)
163 #define decode_open_maxsz (op_decode_hdr_maxsz + \
164 decode_stateid_maxsz + \
165 decode_change_info_maxsz + 1 + \
166 nfs4_fattr_bitmap_maxsz + \
167 decode_delegation_maxsz)
168 #define encode_open_confirm_maxsz \
169 (op_encode_hdr_maxsz + \
170 encode_stateid_maxsz + 1)
171 #define decode_open_confirm_maxsz \
172 (op_decode_hdr_maxsz + \
173 decode_stateid_maxsz)
174 #define encode_open_downgrade_maxsz \
175 (op_encode_hdr_maxsz + \
176 encode_stateid_maxsz + 1 + \
177 encode_share_access_maxsz)
178 #define decode_open_downgrade_maxsz \
179 (op_decode_hdr_maxsz + \
180 decode_stateid_maxsz)
181 #define encode_close_maxsz (op_encode_hdr_maxsz + \
182 1 + encode_stateid_maxsz)
183 #define decode_close_maxsz (op_decode_hdr_maxsz + \
184 decode_stateid_maxsz)
185 #define encode_setattr_maxsz (op_encode_hdr_maxsz + \
186 encode_stateid_maxsz + \
188 #define decode_setattr_maxsz (op_decode_hdr_maxsz + \
189 nfs4_fattr_bitmap_maxsz)
190 #define encode_read_maxsz (op_encode_hdr_maxsz + \
191 encode_stateid_maxsz + 3)
192 #define decode_read_maxsz (op_decode_hdr_maxsz + 2)
193 #define encode_readdir_maxsz (op_encode_hdr_maxsz + \
194 2 + encode_verifier_maxsz + 5)
195 #define decode_readdir_maxsz (op_decode_hdr_maxsz + \
196 decode_verifier_maxsz)
197 #define encode_readlink_maxsz (op_encode_hdr_maxsz)
198 #define decode_readlink_maxsz (op_decode_hdr_maxsz + 1)
199 #define encode_write_maxsz (op_encode_hdr_maxsz + \
200 encode_stateid_maxsz + 4)
201 #define decode_write_maxsz (op_decode_hdr_maxsz + \
202 2 + decode_verifier_maxsz)
203 #define encode_commit_maxsz (op_encode_hdr_maxsz + 3)
204 #define decode_commit_maxsz (op_decode_hdr_maxsz + \
205 decode_verifier_maxsz)
206 #define encode_remove_maxsz (op_encode_hdr_maxsz + \
208 #define decode_remove_maxsz (op_decode_hdr_maxsz + \
209 decode_change_info_maxsz)
210 #define encode_rename_maxsz (op_encode_hdr_maxsz + \
212 #define decode_rename_maxsz (op_decode_hdr_maxsz + \
213 decode_change_info_maxsz + \
214 decode_change_info_maxsz)
215 #define encode_link_maxsz (op_encode_hdr_maxsz + \
217 #define decode_link_maxsz (op_decode_hdr_maxsz + decode_change_info_maxsz)
218 #define encode_lockowner_maxsz (7)
219 #define encode_lock_maxsz (op_encode_hdr_maxsz + \
221 1 + encode_stateid_maxsz + 1 + \
222 encode_lockowner_maxsz)
223 #define decode_lock_denied_maxsz \
224 (8 + decode_lockowner_maxsz)
225 #define decode_lock_maxsz (op_decode_hdr_maxsz + \
226 decode_lock_denied_maxsz)
227 #define encode_lockt_maxsz (op_encode_hdr_maxsz + 5 + \
228 encode_lockowner_maxsz)
229 #define decode_lockt_maxsz (op_decode_hdr_maxsz + \
230 decode_lock_denied_maxsz)
231 #define encode_locku_maxsz (op_encode_hdr_maxsz + 3 + \
232 encode_stateid_maxsz + \
234 #define decode_locku_maxsz (op_decode_hdr_maxsz + \
235 decode_stateid_maxsz)
236 #define encode_release_lockowner_maxsz \
237 (op_encode_hdr_maxsz + \
238 encode_lockowner_maxsz)
239 #define decode_release_lockowner_maxsz \
240 (op_decode_hdr_maxsz)
241 #define encode_access_maxsz (op_encode_hdr_maxsz + 1)
242 #define decode_access_maxsz (op_decode_hdr_maxsz + 2)
243 #define encode_symlink_maxsz (op_encode_hdr_maxsz + \
244 1 + nfs4_name_maxsz + \
247 #define decode_symlink_maxsz (op_decode_hdr_maxsz + 8)
248 #define encode_create_maxsz (op_encode_hdr_maxsz + \
249 1 + 2 + nfs4_name_maxsz + \
251 #define decode_create_maxsz (op_decode_hdr_maxsz + \
252 decode_change_info_maxsz + \
253 nfs4_fattr_bitmap_maxsz)
254 #define encode_statfs_maxsz (encode_getattr_maxsz)
255 #define decode_statfs_maxsz (decode_getattr_maxsz)
256 #define encode_delegreturn_maxsz (op_encode_hdr_maxsz + 4)
257 #define decode_delegreturn_maxsz (op_decode_hdr_maxsz)
258 #define encode_getacl_maxsz (encode_getattr_maxsz)
259 #define decode_getacl_maxsz (op_decode_hdr_maxsz + \
260 nfs4_fattr_bitmap_maxsz + 1)
261 #define encode_setacl_maxsz (op_encode_hdr_maxsz + \
262 encode_stateid_maxsz + 3)
263 #define decode_setacl_maxsz (decode_setattr_maxsz)
264 #define encode_fs_locations_maxsz \
265 (encode_getattr_maxsz)
266 #define decode_fs_locations_maxsz \
268 #define encode_secinfo_maxsz (op_encode_hdr_maxsz + nfs4_name_maxsz)
269 #define decode_secinfo_maxsz (op_decode_hdr_maxsz + 1 + ((NFS_MAX_SECFLAVORS * (16 + GSS_OID_MAX_LEN)) / 4))
271 #if defined(CONFIG_NFS_V4_1)
272 #define NFS4_MAX_MACHINE_NAME_LEN (64)
274 #define encode_exchange_id_maxsz (op_encode_hdr_maxsz + \
275 encode_verifier_maxsz + \
277 XDR_QUADLEN(NFS4_EXCHANGE_ID_LEN) + \
283 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + \
285 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + \
287 #define decode_exchange_id_maxsz (op_decode_hdr_maxsz + \
295 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 + \
297 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 + \
300 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + \
302 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + \
304 #define encode_channel_attrs_maxsz (6 + 1 )
305 #define decode_channel_attrs_maxsz (6 + \
308 #define encode_create_session_maxsz (op_encode_hdr_maxsz + \
312 encode_channel_attrs_maxsz + \
313 encode_channel_attrs_maxsz + \
319 XDR_QUADLEN(NFS4_MAX_MACHINE_NAME_LEN) + \
323 #define decode_create_session_maxsz (op_decode_hdr_maxsz + \
324 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
327 decode_channel_attrs_maxsz + \
328 decode_channel_attrs_maxsz)
329 #define encode_bind_conn_to_session_maxsz (op_encode_hdr_maxsz + \
331 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
334 #define decode_bind_conn_to_session_maxsz (op_decode_hdr_maxsz + \
336 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
339 #define encode_destroy_session_maxsz (op_encode_hdr_maxsz + 4)
340 #define decode_destroy_session_maxsz (op_decode_hdr_maxsz)
341 #define encode_destroy_clientid_maxsz (op_encode_hdr_maxsz + 2)
342 #define decode_destroy_clientid_maxsz (op_decode_hdr_maxsz)
343 #define encode_sequence_maxsz (op_encode_hdr_maxsz + \
344 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + 4)
345 #define decode_sequence_maxsz (op_decode_hdr_maxsz + \
346 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + 5)
347 #define encode_reclaim_complete_maxsz (op_encode_hdr_maxsz + 4)
348 #define decode_reclaim_complete_maxsz (op_decode_hdr_maxsz + 4)
349 #define encode_getdevicelist_maxsz (op_encode_hdr_maxsz + 4 + \
350 encode_verifier_maxsz)
351 #define decode_getdevicelist_maxsz (op_decode_hdr_maxsz + \
353 decode_verifier_maxsz \
356 XDR_QUADLEN(NFS4_PNFS_GETDEVLIST_MAXNUM * \
357 NFS4_DEVICEID4_SIZE) \
360 #define encode_getdeviceinfo_maxsz (op_encode_hdr_maxsz + 4 + \
361 XDR_QUADLEN(NFS4_DEVICEID4_SIZE))
362 #define decode_getdeviceinfo_maxsz (op_decode_hdr_maxsz + \
368 #define encode_layoutget_maxsz (op_encode_hdr_maxsz + 10 + \
369 encode_stateid_maxsz)
370 #define decode_layoutget_maxsz (op_decode_hdr_maxsz + 8 + \
371 decode_stateid_maxsz + \
372 XDR_QUADLEN(PNFS_LAYOUT_MAXSIZE))
373 #define encode_layoutcommit_maxsz (op_encode_hdr_maxsz + \
377 encode_stateid_maxsz + \
383 #define decode_layoutcommit_maxsz (op_decode_hdr_maxsz + 3)
384 #define encode_layoutreturn_maxsz (8 + op_encode_hdr_maxsz + \
385 encode_stateid_maxsz + \
387 #define decode_layoutreturn_maxsz (op_decode_hdr_maxsz + \
388 1 + decode_stateid_maxsz)
389 #define encode_secinfo_no_name_maxsz (op_encode_hdr_maxsz + 1)
390 #define decode_secinfo_no_name_maxsz decode_secinfo_maxsz
391 #define encode_test_stateid_maxsz (op_encode_hdr_maxsz + 2 + \
392 XDR_QUADLEN(NFS4_STATEID_SIZE))
393 #define decode_test_stateid_maxsz (op_decode_hdr_maxsz + 2 + 1)
394 #define encode_free_stateid_maxsz (op_encode_hdr_maxsz + 1 + \
395 XDR_QUADLEN(NFS4_STATEID_SIZE))
396 #define decode_free_stateid_maxsz (op_decode_hdr_maxsz + 1)
398 #define encode_sequence_maxsz 0
399 #define decode_sequence_maxsz 0
402 #define NFS4_enc_compound_sz (1024)
403 #define NFS4_dec_compound_sz (1024)
404 #define NFS4_enc_read_sz (compound_encode_hdr_maxsz + \
405 encode_sequence_maxsz + \
406 encode_putfh_maxsz + \
408 #define NFS4_dec_read_sz (compound_decode_hdr_maxsz + \
409 decode_sequence_maxsz + \
410 decode_putfh_maxsz + \
412 #define NFS4_enc_readlink_sz (compound_encode_hdr_maxsz + \
413 encode_sequence_maxsz + \
414 encode_putfh_maxsz + \
415 encode_readlink_maxsz)
416 #define NFS4_dec_readlink_sz (compound_decode_hdr_maxsz + \
417 decode_sequence_maxsz + \
418 decode_putfh_maxsz + \
419 decode_readlink_maxsz)
420 #define NFS4_enc_readdir_sz (compound_encode_hdr_maxsz + \
421 encode_sequence_maxsz + \
422 encode_putfh_maxsz + \
423 encode_readdir_maxsz)
424 #define NFS4_dec_readdir_sz (compound_decode_hdr_maxsz + \
425 decode_sequence_maxsz + \
426 decode_putfh_maxsz + \
427 decode_readdir_maxsz)
428 #define NFS4_enc_write_sz (compound_encode_hdr_maxsz + \
429 encode_sequence_maxsz + \
430 encode_putfh_maxsz + \
431 encode_write_maxsz + \
432 encode_getattr_maxsz)
433 #define NFS4_dec_write_sz (compound_decode_hdr_maxsz + \
434 decode_sequence_maxsz + \
435 decode_putfh_maxsz + \
436 decode_write_maxsz + \
437 decode_getattr_maxsz)
438 #define NFS4_enc_commit_sz (compound_encode_hdr_maxsz + \
439 encode_sequence_maxsz + \
440 encode_putfh_maxsz + \
442 #define NFS4_dec_commit_sz (compound_decode_hdr_maxsz + \
443 decode_sequence_maxsz + \
444 decode_putfh_maxsz + \
446 #define NFS4_enc_open_sz (compound_encode_hdr_maxsz + \
447 encode_sequence_maxsz + \
448 encode_putfh_maxsz + \
449 encode_open_maxsz + \
450 encode_access_maxsz + \
451 encode_getfh_maxsz + \
452 encode_getattr_maxsz)
453 #define NFS4_dec_open_sz (compound_decode_hdr_maxsz + \
454 decode_sequence_maxsz + \
455 decode_putfh_maxsz + \
456 decode_open_maxsz + \
457 decode_access_maxsz + \
458 decode_getfh_maxsz + \
459 decode_getattr_maxsz)
460 #define NFS4_enc_open_confirm_sz \
461 (compound_encode_hdr_maxsz + \
462 encode_putfh_maxsz + \
463 encode_open_confirm_maxsz)
464 #define NFS4_dec_open_confirm_sz \
465 (compound_decode_hdr_maxsz + \
466 decode_putfh_maxsz + \
467 decode_open_confirm_maxsz)
468 #define NFS4_enc_open_noattr_sz (compound_encode_hdr_maxsz + \
469 encode_sequence_maxsz + \
470 encode_putfh_maxsz + \
471 encode_open_maxsz + \
472 encode_access_maxsz + \
473 encode_getattr_maxsz)
474 #define NFS4_dec_open_noattr_sz (compound_decode_hdr_maxsz + \
475 decode_sequence_maxsz + \
476 decode_putfh_maxsz + \
477 decode_open_maxsz + \
478 decode_access_maxsz + \
479 decode_getattr_maxsz)
480 #define NFS4_enc_open_downgrade_sz \
481 (compound_encode_hdr_maxsz + \
482 encode_sequence_maxsz + \
483 encode_putfh_maxsz + \
484 encode_open_downgrade_maxsz + \
485 encode_getattr_maxsz)
486 #define NFS4_dec_open_downgrade_sz \
487 (compound_decode_hdr_maxsz + \
488 decode_sequence_maxsz + \
489 decode_putfh_maxsz + \
490 decode_open_downgrade_maxsz + \
491 decode_getattr_maxsz)
492 #define NFS4_enc_close_sz (compound_encode_hdr_maxsz + \
493 encode_sequence_maxsz + \
494 encode_putfh_maxsz + \
495 encode_close_maxsz + \
496 encode_getattr_maxsz)
497 #define NFS4_dec_close_sz (compound_decode_hdr_maxsz + \
498 decode_sequence_maxsz + \
499 decode_putfh_maxsz + \
500 decode_close_maxsz + \
501 decode_getattr_maxsz)
502 #define NFS4_enc_setattr_sz (compound_encode_hdr_maxsz + \
503 encode_sequence_maxsz + \
504 encode_putfh_maxsz + \
505 encode_setattr_maxsz + \
506 encode_getattr_maxsz)
507 #define NFS4_dec_setattr_sz (compound_decode_hdr_maxsz + \
508 decode_sequence_maxsz + \
509 decode_putfh_maxsz + \
510 decode_setattr_maxsz + \
511 decode_getattr_maxsz)
512 #define NFS4_enc_fsinfo_sz (compound_encode_hdr_maxsz + \
513 encode_sequence_maxsz + \
514 encode_putfh_maxsz + \
516 #define NFS4_dec_fsinfo_sz (compound_decode_hdr_maxsz + \
517 decode_sequence_maxsz + \
518 decode_putfh_maxsz + \
520 #define NFS4_enc_renew_sz (compound_encode_hdr_maxsz + \
522 #define NFS4_dec_renew_sz (compound_decode_hdr_maxsz + \
524 #define NFS4_enc_setclientid_sz (compound_encode_hdr_maxsz + \
525 encode_setclientid_maxsz)
526 #define NFS4_dec_setclientid_sz (compound_decode_hdr_maxsz + \
527 decode_setclientid_maxsz)
528 #define NFS4_enc_setclientid_confirm_sz \
529 (compound_encode_hdr_maxsz + \
530 encode_setclientid_confirm_maxsz + \
531 encode_putrootfh_maxsz + \
533 #define NFS4_dec_setclientid_confirm_sz \
534 (compound_decode_hdr_maxsz + \
535 decode_setclientid_confirm_maxsz + \
536 decode_putrootfh_maxsz + \
538 #define NFS4_enc_lock_sz (compound_encode_hdr_maxsz + \
539 encode_sequence_maxsz + \
540 encode_putfh_maxsz + \
542 #define NFS4_dec_lock_sz (compound_decode_hdr_maxsz + \
543 decode_sequence_maxsz + \
544 decode_putfh_maxsz + \
546 #define NFS4_enc_lockt_sz (compound_encode_hdr_maxsz + \
547 encode_sequence_maxsz + \
548 encode_putfh_maxsz + \
550 #define NFS4_dec_lockt_sz (compound_decode_hdr_maxsz + \
551 decode_sequence_maxsz + \
552 decode_putfh_maxsz + \
554 #define NFS4_enc_locku_sz (compound_encode_hdr_maxsz + \
555 encode_sequence_maxsz + \
556 encode_putfh_maxsz + \
558 #define NFS4_dec_locku_sz (compound_decode_hdr_maxsz + \
559 decode_sequence_maxsz + \
560 decode_putfh_maxsz + \
562 #define NFS4_enc_release_lockowner_sz \
563 (compound_encode_hdr_maxsz + \
564 encode_lockowner_maxsz)
565 #define NFS4_dec_release_lockowner_sz \
566 (compound_decode_hdr_maxsz + \
567 decode_lockowner_maxsz)
568 #define NFS4_enc_access_sz (compound_encode_hdr_maxsz + \
569 encode_sequence_maxsz + \
570 encode_putfh_maxsz + \
571 encode_access_maxsz + \
572 encode_getattr_maxsz)
573 #define NFS4_dec_access_sz (compound_decode_hdr_maxsz + \
574 decode_sequence_maxsz + \
575 decode_putfh_maxsz + \
576 decode_access_maxsz + \
577 decode_getattr_maxsz)
578 #define NFS4_enc_getattr_sz (compound_encode_hdr_maxsz + \
579 encode_sequence_maxsz + \
580 encode_putfh_maxsz + \
581 encode_getattr_maxsz)
582 #define NFS4_dec_getattr_sz (compound_decode_hdr_maxsz + \
583 decode_sequence_maxsz + \
584 decode_putfh_maxsz + \
585 decode_getattr_maxsz)
586 #define NFS4_enc_lookup_sz (compound_encode_hdr_maxsz + \
587 encode_sequence_maxsz + \
588 encode_putfh_maxsz + \
589 encode_lookup_maxsz + \
590 encode_getattr_maxsz + \
592 #define NFS4_dec_lookup_sz (compound_decode_hdr_maxsz + \
593 decode_sequence_maxsz + \
594 decode_putfh_maxsz + \
595 decode_lookup_maxsz + \
596 decode_getattr_maxsz + \
598 #define NFS4_enc_lookup_root_sz (compound_encode_hdr_maxsz + \
599 encode_sequence_maxsz + \
600 encode_putrootfh_maxsz + \
601 encode_getattr_maxsz + \
603 #define NFS4_dec_lookup_root_sz (compound_decode_hdr_maxsz + \
604 decode_sequence_maxsz + \
605 decode_putrootfh_maxsz + \
606 decode_getattr_maxsz + \
608 #define NFS4_enc_remove_sz (compound_encode_hdr_maxsz + \
609 encode_sequence_maxsz + \
610 encode_putfh_maxsz + \
612 #define NFS4_dec_remove_sz (compound_decode_hdr_maxsz + \
613 decode_sequence_maxsz + \
614 decode_putfh_maxsz + \
616 #define NFS4_enc_rename_sz (compound_encode_hdr_maxsz + \
617 encode_sequence_maxsz + \
618 encode_putfh_maxsz + \
619 encode_savefh_maxsz + \
620 encode_putfh_maxsz + \
622 #define NFS4_dec_rename_sz (compound_decode_hdr_maxsz + \
623 decode_sequence_maxsz + \
624 decode_putfh_maxsz + \
625 decode_savefh_maxsz + \
626 decode_putfh_maxsz + \
628 #define NFS4_enc_link_sz (compound_encode_hdr_maxsz + \
629 encode_sequence_maxsz + \
630 encode_putfh_maxsz + \
631 encode_savefh_maxsz + \
632 encode_putfh_maxsz + \
633 encode_link_maxsz + \
634 encode_restorefh_maxsz + \
635 encode_getattr_maxsz)
636 #define NFS4_dec_link_sz (compound_decode_hdr_maxsz + \
637 decode_sequence_maxsz + \
638 decode_putfh_maxsz + \
639 decode_savefh_maxsz + \
640 decode_putfh_maxsz + \
641 decode_link_maxsz + \
642 decode_restorefh_maxsz + \
643 decode_getattr_maxsz)
644 #define NFS4_enc_symlink_sz (compound_encode_hdr_maxsz + \
645 encode_sequence_maxsz + \
646 encode_putfh_maxsz + \
647 encode_symlink_maxsz + \
648 encode_getattr_maxsz + \
650 #define NFS4_dec_symlink_sz (compound_decode_hdr_maxsz + \
651 decode_sequence_maxsz + \
652 decode_putfh_maxsz + \
653 decode_symlink_maxsz + \
654 decode_getattr_maxsz + \
656 #define NFS4_enc_create_sz (compound_encode_hdr_maxsz + \
657 encode_sequence_maxsz + \
658 encode_putfh_maxsz + \
659 encode_create_maxsz + \
660 encode_getfh_maxsz + \
661 encode_getattr_maxsz)
662 #define NFS4_dec_create_sz (compound_decode_hdr_maxsz + \
663 decode_sequence_maxsz + \
664 decode_putfh_maxsz + \
665 decode_create_maxsz + \
666 decode_getfh_maxsz + \
667 decode_getattr_maxsz)
668 #define NFS4_enc_pathconf_sz (compound_encode_hdr_maxsz + \
669 encode_sequence_maxsz + \
670 encode_putfh_maxsz + \
671 encode_getattr_maxsz)
672 #define NFS4_dec_pathconf_sz (compound_decode_hdr_maxsz + \
673 decode_sequence_maxsz + \
674 decode_putfh_maxsz + \
675 decode_getattr_maxsz)
676 #define NFS4_enc_statfs_sz (compound_encode_hdr_maxsz + \
677 encode_sequence_maxsz + \
678 encode_putfh_maxsz + \
680 #define NFS4_dec_statfs_sz (compound_decode_hdr_maxsz + \
681 decode_sequence_maxsz + \
682 decode_putfh_maxsz + \
684 #define NFS4_enc_server_caps_sz (compound_encode_hdr_maxsz + \
685 encode_sequence_maxsz + \
686 encode_putfh_maxsz + \
687 encode_getattr_maxsz)
688 #define NFS4_dec_server_caps_sz (compound_decode_hdr_maxsz + \
689 decode_sequence_maxsz + \
690 decode_putfh_maxsz + \
691 decode_getattr_maxsz)
692 #define NFS4_enc_delegreturn_sz (compound_encode_hdr_maxsz + \
693 encode_sequence_maxsz + \
694 encode_putfh_maxsz + \
695 encode_delegreturn_maxsz + \
696 encode_getattr_maxsz)
697 #define NFS4_dec_delegreturn_sz (compound_decode_hdr_maxsz + \
698 decode_sequence_maxsz + \
699 decode_delegreturn_maxsz + \
700 decode_getattr_maxsz)
701 #define NFS4_enc_getacl_sz (compound_encode_hdr_maxsz + \
702 encode_sequence_maxsz + \
703 encode_putfh_maxsz + \
705 #define NFS4_dec_getacl_sz (compound_decode_hdr_maxsz + \
706 decode_sequence_maxsz + \
707 decode_putfh_maxsz + \
709 #define NFS4_enc_setacl_sz (compound_encode_hdr_maxsz + \
710 encode_sequence_maxsz + \
711 encode_putfh_maxsz + \
713 #define NFS4_dec_setacl_sz (compound_decode_hdr_maxsz + \
714 decode_sequence_maxsz + \
715 decode_putfh_maxsz + \
717 #define NFS4_enc_fs_locations_sz \
718 (compound_encode_hdr_maxsz + \
719 encode_sequence_maxsz + \
720 encode_putfh_maxsz + \
721 encode_lookup_maxsz + \
722 encode_fs_locations_maxsz)
723 #define NFS4_dec_fs_locations_sz \
724 (compound_decode_hdr_maxsz + \
725 decode_sequence_maxsz + \
726 decode_putfh_maxsz + \
727 decode_lookup_maxsz + \
728 decode_fs_locations_maxsz)
729 #define NFS4_enc_secinfo_sz (compound_encode_hdr_maxsz + \
730 encode_sequence_maxsz + \
731 encode_putfh_maxsz + \
732 encode_secinfo_maxsz)
733 #define NFS4_dec_secinfo_sz (compound_decode_hdr_maxsz + \
734 decode_sequence_maxsz + \
735 decode_putfh_maxsz + \
736 decode_secinfo_maxsz)
737 #if defined(CONFIG_NFS_V4_1)
738 #define NFS4_enc_bind_conn_to_session_sz \
739 (compound_encode_hdr_maxsz + \
740 encode_bind_conn_to_session_maxsz)
741 #define NFS4_dec_bind_conn_to_session_sz \
742 (compound_decode_hdr_maxsz + \
743 decode_bind_conn_to_session_maxsz)
744 #define NFS4_enc_exchange_id_sz \
745 (compound_encode_hdr_maxsz + \
746 encode_exchange_id_maxsz)
747 #define NFS4_dec_exchange_id_sz \
748 (compound_decode_hdr_maxsz + \
749 decode_exchange_id_maxsz)
750 #define NFS4_enc_create_session_sz \
751 (compound_encode_hdr_maxsz + \
752 encode_create_session_maxsz)
753 #define NFS4_dec_create_session_sz \
754 (compound_decode_hdr_maxsz + \
755 decode_create_session_maxsz)
756 #define NFS4_enc_destroy_session_sz (compound_encode_hdr_maxsz + \
757 encode_destroy_session_maxsz)
758 #define NFS4_dec_destroy_session_sz (compound_decode_hdr_maxsz + \
759 decode_destroy_session_maxsz)
760 #define NFS4_enc_destroy_clientid_sz (compound_encode_hdr_maxsz + \
761 encode_destroy_clientid_maxsz)
762 #define NFS4_dec_destroy_clientid_sz (compound_decode_hdr_maxsz + \
763 decode_destroy_clientid_maxsz)
764 #define NFS4_enc_sequence_sz \
765 (compound_decode_hdr_maxsz + \
766 encode_sequence_maxsz)
767 #define NFS4_dec_sequence_sz \
768 (compound_decode_hdr_maxsz + \
769 decode_sequence_maxsz)
770 #define NFS4_enc_get_lease_time_sz (compound_encode_hdr_maxsz + \
771 encode_sequence_maxsz + \
772 encode_putrootfh_maxsz + \
774 #define NFS4_dec_get_lease_time_sz (compound_decode_hdr_maxsz + \
775 decode_sequence_maxsz + \
776 decode_putrootfh_maxsz + \
778 #define NFS4_enc_reclaim_complete_sz (compound_encode_hdr_maxsz + \
779 encode_sequence_maxsz + \
780 encode_reclaim_complete_maxsz)
781 #define NFS4_dec_reclaim_complete_sz (compound_decode_hdr_maxsz + \
782 decode_sequence_maxsz + \
783 decode_reclaim_complete_maxsz)
784 #define NFS4_enc_getdevicelist_sz (compound_encode_hdr_maxsz + \
785 encode_sequence_maxsz + \
786 encode_putfh_maxsz + \
787 encode_getdevicelist_maxsz)
788 #define NFS4_dec_getdevicelist_sz (compound_decode_hdr_maxsz + \
789 decode_sequence_maxsz + \
790 decode_putfh_maxsz + \
791 decode_getdevicelist_maxsz)
792 #define NFS4_enc_getdeviceinfo_sz (compound_encode_hdr_maxsz + \
793 encode_sequence_maxsz +\
794 encode_getdeviceinfo_maxsz)
795 #define NFS4_dec_getdeviceinfo_sz (compound_decode_hdr_maxsz + \
796 decode_sequence_maxsz + \
797 decode_getdeviceinfo_maxsz)
798 #define NFS4_enc_layoutget_sz (compound_encode_hdr_maxsz + \
799 encode_sequence_maxsz + \
800 encode_putfh_maxsz + \
801 encode_layoutget_maxsz)
802 #define NFS4_dec_layoutget_sz (compound_decode_hdr_maxsz + \
803 decode_sequence_maxsz + \
804 decode_putfh_maxsz + \
805 decode_layoutget_maxsz)
806 #define NFS4_enc_layoutcommit_sz (compound_encode_hdr_maxsz + \
807 encode_sequence_maxsz +\
808 encode_putfh_maxsz + \
809 encode_layoutcommit_maxsz + \
810 encode_getattr_maxsz)
811 #define NFS4_dec_layoutcommit_sz (compound_decode_hdr_maxsz + \
812 decode_sequence_maxsz + \
813 decode_putfh_maxsz + \
814 decode_layoutcommit_maxsz + \
815 decode_getattr_maxsz)
816 #define NFS4_enc_layoutreturn_sz (compound_encode_hdr_maxsz + \
817 encode_sequence_maxsz + \
818 encode_putfh_maxsz + \
819 encode_layoutreturn_maxsz)
820 #define NFS4_dec_layoutreturn_sz (compound_decode_hdr_maxsz + \
821 decode_sequence_maxsz + \
822 decode_putfh_maxsz + \
823 decode_layoutreturn_maxsz)
824 #define NFS4_enc_secinfo_no_name_sz (compound_encode_hdr_maxsz + \
825 encode_sequence_maxsz + \
826 encode_putrootfh_maxsz +\
827 encode_secinfo_no_name_maxsz)
828 #define NFS4_dec_secinfo_no_name_sz (compound_decode_hdr_maxsz + \
829 decode_sequence_maxsz + \
830 decode_putrootfh_maxsz + \
831 decode_secinfo_no_name_maxsz)
832 #define NFS4_enc_test_stateid_sz (compound_encode_hdr_maxsz + \
833 encode_sequence_maxsz + \
834 encode_test_stateid_maxsz)
835 #define NFS4_dec_test_stateid_sz (compound_decode_hdr_maxsz + \
836 decode_sequence_maxsz + \
837 decode_test_stateid_maxsz)
838 #define NFS4_enc_free_stateid_sz (compound_encode_hdr_maxsz + \
839 encode_sequence_maxsz + \
840 encode_free_stateid_maxsz)
841 #define NFS4_dec_free_stateid_sz (compound_decode_hdr_maxsz + \
842 decode_sequence_maxsz + \
843 decode_free_stateid_maxsz)
845 const u32 nfs41_maxwrite_overhead = ((RPC_MAX_HEADER_WITH_AUTH +
852 const u32 nfs41_maxread_overhead = ((RPC_MAX_HEADER_WITH_AUTH +
859 static const umode_t nfs_type2fmt[] = {
882 static __be32 *reserve_space(
struct xdr_stream *xdr,
size_t nbytes)
889 static void encode_opaque_fixed(
struct xdr_stream *xdr,
const void *
buf,
size_t len)
897 static void encode_string(
struct xdr_stream *xdr,
unsigned int len,
const char *
str)
901 p = reserve_space(xdr, 4 + len);
905 static void encode_uint32(
struct xdr_stream *xdr,
u32 n)
909 p = reserve_space(xdr, 4);
913 static void encode_uint64(
struct xdr_stream *xdr,
u64 n)
917 p = reserve_space(xdr, 8);
918 xdr_encode_hyper(p, n);
921 static void encode_nfs4_seqid(
struct xdr_stream *xdr,
922 const struct nfs_seqid *
seqid)
924 encode_uint32(xdr, seqid->sequence->counter);
927 static void encode_compound_hdr(
struct xdr_stream *xdr,
928 struct rpc_rqst *
req,
932 struct rpc_auth *
auth = req->rq_cred->cr_auth;
937 hdr->
replen = RPC_REPHDRSIZE + auth->au_rslack + 3 + hdr->
taglen;
940 encode_string(xdr, hdr->
taglen, hdr->
tag);
941 p = reserve_space(xdr, 8);
947 static void encode_op_hdr(
struct xdr_stream *xdr,
enum nfs_opnum4 op,
951 encode_uint32(xdr, op);
962 static void encode_nfs4_stateid(
struct xdr_stream *xdr,
const nfs4_stateid *stateid)
967 static void encode_nfs4_verifier(
struct xdr_stream *xdr,
const nfs4_verifier *verf)
972 static void encode_attrs(
struct xdr_stream *xdr,
const struct iattr *iap,
const struct nfs_server *server)
976 int owner_namelen = 0;
977 int owner_grouplen = 0;
1000 if (owner_namelen < 0) {
1001 dprintk(
"nfs: couldn't resolve uid %d to string\n",
1004 strcpy(owner_name,
"nobody");
1005 owner_namelen =
sizeof(
"nobody") - 1;
1008 len += 4 + (XDR_QUADLEN(owner_namelen) << 2);
1012 if (owner_grouplen < 0) {
1013 dprintk(
"nfs: couldn't resolve gid %d to string\n",
1015 strcpy(owner_group,
"nobody");
1016 owner_grouplen =
sizeof(
"nobody") - 1;
1019 len += 4 + (XDR_QUADLEN(owner_grouplen) << 2);
1029 p = reserve_space(xdr, len);
1041 p = xdr_encode_hyper(p, iap->
ia_size);
1081 if (len != ((
char *)p - (
char *)q) + 4) {
1083 len, ((
char *)p - (
char *)q) + 4);
1086 len = (
char *)p - (
char *)q - 12;
1087 *q++ =
htonl(bmval0);
1088 *q++ =
htonl(bmval1);
1097 encode_uint32(xdr, access);
1103 encode_nfs4_seqid(xdr, arg->
seqid);
1104 encode_nfs4_stateid(xdr, arg->
stateid);
1112 p = reserve_space(xdr, 12);
1113 p = xdr_encode_hyper(p, args->
offset);
1117 static void encode_create(
struct xdr_stream *xdr,
const struct nfs4_create_arg *
create,
struct compound_hdr *
hdr)
1122 encode_uint32(xdr, create->ftype);
1124 switch (create->ftype) {
1126 p = reserve_space(xdr, 4);
1128 xdr_write_pages(xdr, create->u.symlink.pages, 0, create->u.symlink.len);
1132 p = reserve_space(xdr, 8);
1141 encode_string(xdr, create->name->len, create->name->name);
1142 encode_attrs(xdr, create->attrs, create->server);
1150 p = reserve_space(xdr, 8);
1160 p = reserve_space(xdr, 12);
1167 encode_getattr_three(
struct xdr_stream *xdr,
1175 p = reserve_space(xdr, 16);
1181 p = reserve_space(xdr, 12);
1186 p = reserve_space(xdr, 8);
1195 bitmask[1] & nfs4_fattr_bitmap[1], hdr);
1198 static void encode_getfattr_open(
struct xdr_stream *xdr,
const u32 *
bitmask,
1199 const u32 *open_bitmap,
1202 encode_getattr_three(xdr,
1203 bitmask[0] & open_bitmap[0],
1204 bitmask[1] & open_bitmap[1],
1205 bitmask[2] & open_bitmap[2],
1211 encode_getattr_three(xdr,
1213 bitmask[1] & nfs4_fsinfo_bitmap[1],
1214 bitmask[2] & nfs4_fsinfo_bitmap[2],
1221 bitmask[1] & nfs4_fs_locations_bitmap[1], hdr);
1224 static void encode_getfh(
struct xdr_stream *xdr,
struct compound_hdr *hdr)
1229 static void encode_link(
struct xdr_stream *xdr,
const struct qstr *
name,
struct compound_hdr *hdr)
1232 encode_string(xdr, name->len, name->
name);
1249 static void encode_lockowner(
struct xdr_stream *xdr,
const struct nfs_lowner *lowner)
1253 p = reserve_space(xdr, 32);
1254 p = xdr_encode_hyper(p, lowner->
clientid);
1258 xdr_encode_hyper(p, lowner->
id);
1270 p = reserve_space(xdr, 28);
1273 p = xdr_encode_hyper(p, args->
fl->fl_start);
1274 p = xdr_encode_hyper(p, nfs4_lock_length(args->
fl));
1293 p = reserve_space(xdr, 20);
1295 p = xdr_encode_hyper(p, args->
fl->fl_start);
1296 p = xdr_encode_hyper(p, nfs4_lock_length(args->
fl));
1305 encode_uint32(xdr, nfs4_lock_type(args->
fl, 0));
1306 encode_nfs4_seqid(xdr, args->
seqid);
1307 encode_nfs4_stateid(xdr, args->
stateid);
1308 p = reserve_space(xdr, 16);
1309 p = xdr_encode_hyper(p, args->
fl->fl_start);
1310 xdr_encode_hyper(p, nfs4_lock_length(args->
fl));
1313 static void encode_release_lockowner(
struct xdr_stream *xdr,
const struct nfs_lowner *lowner,
struct compound_hdr *hdr)
1316 encode_lockowner(xdr, lowner);
1319 static void encode_lookup(
struct xdr_stream *xdr,
const struct qstr *
name,
struct compound_hdr *hdr)
1322 encode_string(xdr, name->len, name->
name);
1325 static void encode_share_access(
struct xdr_stream *xdr,
fmode_t fmode)
1329 p = reserve_space(xdr, 8);
1346 static inline void encode_openhdr(
struct xdr_stream *xdr,
const struct nfs_openargs *
arg)
1353 encode_nfs4_seqid(xdr, arg->
seqid);
1354 encode_share_access(xdr, arg->
fmode);
1355 p = reserve_space(xdr, 36);
1356 p = xdr_encode_hyper(p, arg->
clientid);
1361 xdr_encode_hyper(p, arg->
id.create_time);
1364 static inline void encode_createmode(
struct xdr_stream *xdr,
const struct nfs_openargs *
arg)
1369 p = reserve_space(xdr, 4);
1376 clp = arg->
server->nfs_client;
1377 if (clp->cl_mvops->minor_version > 0) {
1378 if (nfs4_has_persistent_session(clp)) {
1385 encode_nfs4_verifier(xdr, &arg->
u.
verifier);
1391 encode_nfs4_verifier(xdr, &arg->
u.
verifier);
1396 static void encode_opentype(
struct xdr_stream *xdr,
const struct nfs_openargs *arg)
1400 p = reserve_space(xdr, 4);
1408 encode_createmode(xdr, arg);
1412 static inline void encode_delegation_type(
struct xdr_stream *xdr,
fmode_t delegation_type)
1416 p = reserve_space(xdr, 4);
1417 switch (delegation_type) {
1432 static inline void encode_claim_null(
struct xdr_stream *xdr,
const struct qstr *
name)
1436 p = reserve_space(xdr, 4);
1438 encode_string(xdr, name->len, name->
name);
1441 static inline void encode_claim_previous(
struct xdr_stream *xdr,
fmode_t type)
1445 p = reserve_space(xdr, 4);
1447 encode_delegation_type(xdr, type);
1450 static inline void encode_claim_delegate_cur(
struct xdr_stream *xdr,
const struct qstr *
name,
const nfs4_stateid *stateid)
1454 p = reserve_space(xdr, 4);
1456 encode_nfs4_stateid(xdr, stateid);
1457 encode_string(xdr, name->len, name->
name);
1463 encode_openhdr(xdr, arg);
1464 encode_opentype(xdr, arg);
1465 switch (arg->
claim) {
1467 encode_claim_null(xdr, arg->
name);
1483 encode_nfs4_stateid(xdr, arg->
stateid);
1484 encode_nfs4_seqid(xdr, arg->
seqid);
1490 encode_nfs4_stateid(xdr, arg->
stateid);
1491 encode_nfs4_seqid(xdr, arg->
seqid);
1492 encode_share_access(xdr, arg->
fmode);
1496 encode_putfh(
struct xdr_stream *xdr,
const struct nfs_fh *fh,
struct compound_hdr *hdr)
1499 encode_string(xdr, fh->
size, fh->
data);
1502 static void encode_putrootfh(
struct xdr_stream *xdr,
struct compound_hdr *hdr)
1507 static void encode_open_stateid(
struct xdr_stream *xdr,
1524 encode_nfs4_stateid(xdr, &stateid);
1537 p = reserve_space(xdr, 12);
1538 p = xdr_encode_hyper(p, args->
offset);
1542 static void encode_readdir(
struct xdr_stream *xdr,
const struct nfs4_readdir_arg *readdir,
struct rpc_rqst *
req,
struct compound_hdr *hdr)
1548 uint32_t dircount = readdir->count >> 1;
1551 if (readdir->plus) {
1565 encode_uint64(xdr, readdir->cookie);
1566 encode_nfs4_verifier(xdr, &readdir->verifier);
1567 p = reserve_space(xdr, 20);
1572 *p++ =
cpu_to_be32(attrs[0] & readdir->bitmask[0]);
1574 memcpy(verf, readdir->verifier.data,
sizeof(verf));
1575 dprintk(
"%s: cookie = %Lu, verifier = %08x:%08x, bitmap = %08x:%08x\n",
1577 (
unsigned long long)readdir->cookie,
1579 attrs[0] & readdir->bitmask[0],
1580 attrs[1] & readdir->bitmask[1]);
1583 static void encode_readlink(
struct xdr_stream *xdr,
const struct nfs4_readlink *readlink,
struct rpc_rqst *req,
struct compound_hdr *hdr)
1588 static void encode_remove(
struct xdr_stream *xdr,
const struct qstr *
name,
struct compound_hdr *hdr)
1591 encode_string(xdr, name->len, name->
name);
1594 static void encode_rename(
struct xdr_stream *xdr,
const struct qstr *oldname,
const struct qstr *newname,
struct compound_hdr *hdr)
1597 encode_string(xdr, oldname->len, oldname->
name);
1598 encode_string(xdr, newname->len, newname->
name);
1601 static void encode_renew(
struct xdr_stream *xdr, clientid4
clid,
1605 encode_uint64(xdr, clid);
1609 encode_restorefh(
struct xdr_stream *xdr,
struct compound_hdr *hdr)
1621 p = reserve_space(xdr, 2*4);
1625 p = reserve_space(xdr, 4);
1631 encode_savefh(
struct xdr_stream *xdr,
struct compound_hdr *hdr)
1639 encode_nfs4_stateid(xdr, &arg->
stateid);
1640 encode_attrs(xdr, arg->
iap, server);
1643 static void encode_setclientid(
struct xdr_stream *xdr,
const struct nfs4_setclientid *setclientid,
struct compound_hdr *hdr)
1648 encode_nfs4_verifier(xdr, setclientid->sc_verifier);
1650 encode_string(xdr, setclientid->sc_name_len, setclientid->sc_name);
1651 p = reserve_space(xdr, 4);
1653 encode_string(xdr, setclientid->sc_netid_len, setclientid->sc_netid);
1654 encode_string(xdr, setclientid->sc_uaddr_len, setclientid->sc_uaddr);
1655 p = reserve_space(xdr, 4);
1659 static void encode_setclientid_confirm(
struct xdr_stream *xdr,
const struct nfs4_setclientid_res *arg,
struct compound_hdr *hdr)
1663 encode_uint64(xdr, arg->clientid);
1664 encode_nfs4_verifier(xdr, &arg->confirm);
1675 p = reserve_space(xdr, 16);
1676 p = xdr_encode_hyper(p, args->
offset);
1686 encode_nfs4_stateid(xdr, stateid);
1689 static void encode_secinfo(
struct xdr_stream *xdr,
const struct qstr *
name,
struct compound_hdr *hdr)
1692 encode_string(xdr, name->len, name->
name);
1695 #if defined(CONFIG_NFS_V4_1)
1697 static void encode_bind_conn_to_session(
struct xdr_stream *xdr,
1698 struct nfs4_session *session,
1704 decode_bind_conn_to_session_maxsz, hdr);
1711 static void encode_exchange_id(
struct xdr_stream *xdr,
1712 struct nfs41_exchange_id_args *args,
1719 encode_op_hdr(xdr,
OP_EXCHANGE_ID, decode_exchange_id_maxsz, hdr);
1720 encode_nfs4_verifier(xdr, args->verifier);
1722 encode_string(xdr, args->id_len, args->id);
1724 p = reserve_space(xdr, 12);
1728 if (send_implementation_id &&
1729 sizeof(CONFIG_NFS_V4_1_IMPLEMENTATION_ID_DOMAIN) > 1 &&
1730 sizeof(CONFIG_NFS_V4_1_IMPLEMENTATION_ID_DOMAIN)
1732 len =
snprintf(impl_name,
sizeof(impl_name),
"%s %s %s %s",
1733 utsname()->sysname, utsname()->
release,
1740 sizeof(CONFIG_NFS_V4_1_IMPLEMENTATION_ID_DOMAIN) - 1,
1741 CONFIG_NFS_V4_1_IMPLEMENTATION_ID_DOMAIN);
1742 encode_string(xdr, len, impl_name);
1744 p = reserve_space(xdr, 12);
1745 p = xdr_encode_hyper(p, 0);
1751 static void encode_create_session(
struct xdr_stream *xdr,
1752 struct nfs41_create_session_args *args,
1756 char machine_name[NFS4_MAX_MACHINE_NAME_LEN];
1760 u32 max_resp_sz_cached;
1767 RPC_MAX_AUTH_SIZE + 2) * XDR_UNIT;
1769 len =
scnprintf(machine_name,
sizeof(machine_name),
"%s",
1773 p = reserve_space(xdr, 16 + 2*28 + 20 + len + 12);
1774 p = xdr_encode_hyper(p, clp->cl_clientid);
1791 *p++ =
cpu_to_be32(args->bc_attrs.max_resp_sz_cached);
1808 static void encode_destroy_session(
struct xdr_stream *xdr,
1809 struct nfs4_session *session,
1816 static void encode_destroy_clientid(
struct xdr_stream *xdr,
1821 encode_uint64(xdr, clientid);
1824 static void encode_reclaim_complete(
struct xdr_stream *xdr,
1825 struct nfs41_reclaim_complete_args *args,
1829 encode_uint32(xdr, args->one_fs);
1833 static void encode_sequence(
struct xdr_stream *xdr,
1837 #if defined(CONFIG_NFS_V4_1)
1838 struct nfs4_session *session = args->
sa_session;
1839 struct nfs4_slot_table *tp;
1846 tp = &session->fc_slot_table;
1856 dprintk(
"%s: sessionid=%u:%u:%u:%u seqid=%d slotid=%d "
1857 "max_slotid=%d cache_this=%d\n",
1859 ((
u32 *)session->sess_id.data)[0],
1860 ((
u32 *)session->sess_id.data)[1],
1861 ((
u32 *)session->sess_id.data)[2],
1862 ((
u32 *)session->sess_id.data)[3],
1874 #ifdef CONFIG_NFS_V4_1
1876 encode_getdevicelist(
struct xdr_stream *xdr,
1886 p = reserve_space(xdr, 16);
1889 xdr_encode_hyper(p, 0ULL);
1890 encode_nfs4_verifier(xdr, &dummy);
1894 encode_getdeviceinfo(
struct xdr_stream *xdr,
1910 encode_layoutget(
struct xdr_stream *xdr,
1916 encode_op_hdr(xdr,
OP_LAYOUTGET, decode_layoutget_maxsz, hdr);
1917 p = reserve_space(xdr, 36);
1921 p = xdr_encode_hyper(p, args->
range.offset);
1922 p = xdr_encode_hyper(p, args->
range.length);
1923 p = xdr_encode_hyper(p, args->
minlength);
1924 encode_nfs4_stateid(xdr, &args->
stateid);
1925 encode_uint32(xdr, args->
maxcount);
1927 dprintk(
"%s: 1st type:0x%x iomode:%d off:%lu len:%lu mc:%d\n",
1931 (
unsigned long)args->
range.offset,
1932 (
unsigned long)args->
range.length,
1937 encode_layoutcommit(
struct xdr_stream *xdr,
1945 NFS_SERVER(args->
inode)->pnfs_curr_ld->id);
1948 p = reserve_space(xdr, 20);
1950 p = xdr_encode_hyper(p, 0);
1953 encode_nfs4_stateid(xdr, &args->
stateid);
1954 p = reserve_space(xdr, 20);
1960 if (NFS_SERVER(inode)->pnfs_curr_ld->encode_layoutcommit)
1961 NFS_SERVER(inode)->pnfs_curr_ld->encode_layoutcommit(
1962 NFS_I(inode)->
layout, xdr, args);
1964 encode_uint32(xdr, 0);
1970 encode_layoutreturn(
struct xdr_stream *xdr,
1977 p = reserve_space(xdr, 16);
1982 p = reserve_space(xdr, 16);
1983 p = xdr_encode_hyper(p, 0);
1985 spin_lock(&args->
inode->i_lock);
1986 encode_nfs4_stateid(xdr, &args->
stateid);
1987 spin_unlock(&args->
inode->i_lock);
1988 if (NFS_SERVER(args->
inode)->pnfs_curr_ld->encode_layoutreturn) {
1989 NFS_SERVER(args->
inode)->pnfs_curr_ld->encode_layoutreturn(
1990 NFS_I(args->
inode)->layout, xdr, args);
1992 encode_uint32(xdr, 0);
1996 encode_secinfo_no_name(
struct xdr_stream *xdr,
1997 const struct nfs41_secinfo_no_name_args *args,
2001 encode_uint32(xdr, args->style);
2005 static void encode_test_stateid(
struct xdr_stream *xdr,
2006 struct nfs41_test_stateid_args *args,
2010 encode_uint32(xdr, 1);
2011 encode_nfs4_stateid(xdr, args->stateid);
2014 static void encode_free_stateid(
struct xdr_stream *xdr,
2015 struct nfs41_free_stateid_args *args,
2019 encode_nfs4_stateid(xdr, args->stateid);
2029 #if defined(CONFIG_NFS_V4_1)
2031 return args->
sa_session->clp->cl_mvops->minor_version;
2039 static void nfs4_xdr_enc_access(
struct rpc_rqst *req,
struct xdr_stream *xdr,
2040 const struct nfs4_accessargs *args)
2043 .
minorversion = nfs4_xdr_minorversion(&args->seq_args),
2046 encode_compound_hdr(xdr, req, &hdr);
2047 encode_sequence(xdr, &args->seq_args, &hdr);
2048 encode_putfh(xdr, args->fh, &hdr);
2049 encode_access(xdr, args->access, &hdr);
2050 encode_getfattr(xdr, args->bitmask, &hdr);
2057 static void nfs4_xdr_enc_lookup(
struct rpc_rqst *req,
struct xdr_stream *xdr,
2058 const struct nfs4_lookup_arg *args)
2061 .
minorversion = nfs4_xdr_minorversion(&args->seq_args),
2064 encode_compound_hdr(xdr, req, &hdr);
2065 encode_sequence(xdr, &args->seq_args, &hdr);
2066 encode_putfh(xdr, args->dir_fh, &hdr);
2067 encode_lookup(xdr, args->name, &hdr);
2068 encode_getfh(xdr, &hdr);
2069 encode_getfattr(xdr, args->bitmask, &hdr);
2076 static void nfs4_xdr_enc_lookup_root(
struct rpc_rqst *req,
2077 struct xdr_stream *xdr,
2078 const struct nfs4_lookup_root_arg *args)
2081 .
minorversion = nfs4_xdr_minorversion(&args->seq_args),
2084 encode_compound_hdr(xdr, req, &hdr);
2085 encode_sequence(xdr, &args->seq_args, &hdr);
2086 encode_putrootfh(xdr, &hdr);
2087 encode_getfh(xdr, &hdr);
2088 encode_getfattr(xdr, args->bitmask, &hdr);
2095 static void nfs4_xdr_enc_remove(
struct rpc_rqst *req,
struct xdr_stream *xdr,
2102 encode_compound_hdr(xdr, req, &hdr);
2103 encode_sequence(xdr, &args->
seq_args, &hdr);
2104 encode_putfh(xdr, args->
fh, &hdr);
2105 encode_remove(xdr, &args->
name, &hdr);
2112 static void nfs4_xdr_enc_rename(
struct rpc_rqst *req,
struct xdr_stream *xdr,
2119 encode_compound_hdr(xdr, req, &hdr);
2120 encode_sequence(xdr, &args->
seq_args, &hdr);
2121 encode_putfh(xdr, args->
old_dir, &hdr);
2122 encode_savefh(xdr, &hdr);
2123 encode_putfh(xdr, args->
new_dir, &hdr);
2131 static void nfs4_xdr_enc_link(
struct rpc_rqst *req,
struct xdr_stream *xdr,
2132 const struct nfs4_link_arg *args)
2135 .
minorversion = nfs4_xdr_minorversion(&args->seq_args),
2138 encode_compound_hdr(xdr, req, &hdr);
2139 encode_sequence(xdr, &args->seq_args, &hdr);
2140 encode_putfh(xdr, args->fh, &hdr);
2141 encode_savefh(xdr, &hdr);
2142 encode_putfh(xdr, args->dir_fh, &hdr);
2143 encode_link(xdr, args->name, &hdr);
2144 encode_restorefh(xdr, &hdr);
2145 encode_getfattr(xdr, args->bitmask, &hdr);
2152 static void nfs4_xdr_enc_create(
struct rpc_rqst *req,
struct xdr_stream *xdr,
2153 const struct nfs4_create_arg *args)
2156 .
minorversion = nfs4_xdr_minorversion(&args->seq_args),
2159 encode_compound_hdr(xdr, req, &hdr);
2160 encode_sequence(xdr, &args->seq_args, &hdr);
2161 encode_putfh(xdr, args->dir_fh, &hdr);
2162 encode_create(xdr, args, &hdr);
2163 encode_getfh(xdr, &hdr);
2164 encode_getfattr(xdr, args->bitmask, &hdr);
2171 static void nfs4_xdr_enc_symlink(
struct rpc_rqst *req,
struct xdr_stream *xdr,
2172 const struct nfs4_create_arg *args)
2174 nfs4_xdr_enc_create(req, xdr, args);
2180 static void nfs4_xdr_enc_getattr(
struct rpc_rqst *req,
struct xdr_stream *xdr,
2181 const struct nfs4_getattr_arg *args)
2184 .
minorversion = nfs4_xdr_minorversion(&args->seq_args),
2187 encode_compound_hdr(xdr, req, &hdr);
2188 encode_sequence(xdr, &args->seq_args, &hdr);
2189 encode_putfh(xdr, args->fh, &hdr);
2190 encode_getfattr(xdr, args->bitmask, &hdr);
2197 static void nfs4_xdr_enc_close(
struct rpc_rqst *req,
struct xdr_stream *xdr,
2204 encode_compound_hdr(xdr, req, &hdr);
2205 encode_sequence(xdr, &args->
seq_args, &hdr);
2206 encode_putfh(xdr, args->
fh, &hdr);
2207 encode_close(xdr, args, &hdr);
2208 encode_getfattr(xdr, args->
bitmask, &hdr);
2215 static void nfs4_xdr_enc_open(
struct rpc_rqst *req,
struct xdr_stream *xdr,
2222 encode_compound_hdr(xdr, req, &hdr);
2223 encode_sequence(xdr, &args->
seq_args, &hdr);
2224 encode_putfh(xdr, args->
fh, &hdr);
2225 encode_open(xdr, args, &hdr);
2226 encode_getfh(xdr, &hdr);
2228 encode_access(xdr, args->
access, &hdr);
2236 static void nfs4_xdr_enc_open_confirm(
struct rpc_rqst *req,
2237 struct xdr_stream *xdr,
2244 encode_compound_hdr(xdr, req, &hdr);
2245 encode_putfh(xdr, args->
fh, &hdr);
2246 encode_open_confirm(xdr, args, &hdr);
2253 static void nfs4_xdr_enc_open_noattr(
struct rpc_rqst *req,
2254 struct xdr_stream *xdr,
2261 encode_compound_hdr(xdr, req, &hdr);
2262 encode_sequence(xdr, &args->
seq_args, &hdr);
2263 encode_putfh(xdr, args->
fh, &hdr);
2264 encode_open(xdr, args, &hdr);
2266 encode_access(xdr, args->
access, &hdr);
2274 static void nfs4_xdr_enc_open_downgrade(
struct rpc_rqst *req,
2275 struct xdr_stream *xdr,
2282 encode_compound_hdr(xdr, req, &hdr);
2283 encode_sequence(xdr, &args->
seq_args, &hdr);
2284 encode_putfh(xdr, args->
fh, &hdr);
2285 encode_open_downgrade(xdr, args, &hdr);
2286 encode_getfattr(xdr, args->
bitmask, &hdr);
2293 static void nfs4_xdr_enc_lock(
struct rpc_rqst *req,
struct xdr_stream *xdr,
2300 encode_compound_hdr(xdr, req, &hdr);
2301 encode_sequence(xdr, &args->
seq_args, &hdr);
2302 encode_putfh(xdr, args->
fh, &hdr);
2303 encode_lock(xdr, args, &hdr);
2310 static void nfs4_xdr_enc_lockt(
struct rpc_rqst *req,
struct xdr_stream *xdr,
2317 encode_compound_hdr(xdr, req, &hdr);
2318 encode_sequence(xdr, &args->
seq_args, &hdr);
2319 encode_putfh(xdr, args->
fh, &hdr);
2320 encode_lockt(xdr, args, &hdr);
2327 static void nfs4_xdr_enc_locku(
struct rpc_rqst *req,
struct xdr_stream *xdr,
2334 encode_compound_hdr(xdr, req, &hdr);
2335 encode_sequence(xdr, &args->
seq_args, &hdr);
2336 encode_putfh(xdr, args->
fh, &hdr);
2337 encode_locku(xdr, args, &hdr);
2341 static void nfs4_xdr_enc_release_lockowner(
struct rpc_rqst *req,
2342 struct xdr_stream *xdr,
2349 encode_compound_hdr(xdr, req, &hdr);
2350 encode_release_lockowner(xdr, &args->
lock_owner, &hdr);
2357 static void nfs4_xdr_enc_readlink(
struct rpc_rqst *req,
struct xdr_stream *xdr,
2358 const struct nfs4_readlink *args)
2361 .
minorversion = nfs4_xdr_minorversion(&args->seq_args),
2364 encode_compound_hdr(xdr, req, &hdr);
2365 encode_sequence(xdr, &args->seq_args, &hdr);
2366 encode_putfh(xdr, args->fh, &hdr);
2367 encode_readlink(xdr, args, req, &hdr);
2370 args->pgbase, args->pglen);
2377 static void nfs4_xdr_enc_readdir(
struct rpc_rqst *req,
struct xdr_stream *xdr,
2378 const struct nfs4_readdir_arg *args)
2381 .
minorversion = nfs4_xdr_minorversion(&args->seq_args),
2384 encode_compound_hdr(xdr, req, &hdr);
2385 encode_sequence(xdr, &args->seq_args, &hdr);
2386 encode_putfh(xdr, args->fh, &hdr);
2387 encode_readdir(xdr, args, req, &hdr);
2390 args->pgbase, args->count);
2391 dprintk(
"%s: inlined page args = (%u, %p, %u, %u)\n",
2392 __func__, hdr.
replen << 2, args->pages,
2393 args->pgbase, args->count);
2400 static void nfs4_xdr_enc_read(
struct rpc_rqst *req,
struct xdr_stream *xdr,
2407 encode_compound_hdr(xdr, req, &hdr);
2408 encode_sequence(xdr, &args->
seq_args, &hdr);
2409 encode_putfh(xdr, args->
fh, &hdr);
2410 encode_read(xdr, args, &hdr);
2414 req->rq_rcv_buf.flags |= XDRBUF_READ;
2421 static void nfs4_xdr_enc_setattr(
struct rpc_rqst *req,
struct xdr_stream *xdr,
2428 encode_compound_hdr(xdr, req, &hdr);
2429 encode_sequence(xdr, &args->
seq_args, &hdr);
2430 encode_putfh(xdr, args->
fh, &hdr);
2431 encode_setattr(xdr, args, args->
server, &hdr);
2432 encode_getfattr(xdr, args->
bitmask, &hdr);
2439 static void nfs4_xdr_enc_getacl(
struct rpc_rqst *req,
struct xdr_stream *xdr,
2447 encode_compound_hdr(xdr, req, &hdr);
2448 encode_sequence(xdr, &args->
seq_args, &hdr);
2449 encode_putfh(xdr, args->
fh, &hdr);
2462 static void nfs4_xdr_enc_write(
struct rpc_rqst *req,
struct xdr_stream *xdr,
2469 encode_compound_hdr(xdr, req, &hdr);
2470 encode_sequence(xdr, &args->
seq_args, &hdr);
2471 encode_putfh(xdr, args->
fh, &hdr);
2472 encode_write(xdr, args, &hdr);
2473 req->rq_snd_buf.flags |= XDRBUF_WRITE;
2475 encode_getfattr(xdr, args->
bitmask, &hdr);
2482 static void nfs4_xdr_enc_commit(
struct rpc_rqst *req,
struct xdr_stream *xdr,
2489 encode_compound_hdr(xdr, req, &hdr);
2490 encode_sequence(xdr, &args->
seq_args, &hdr);
2491 encode_putfh(xdr, args->
fh, &hdr);
2492 encode_commit(xdr, args, &hdr);
2499 static void nfs4_xdr_enc_fsinfo(
struct rpc_rqst *req,
struct xdr_stream *xdr,
2500 struct nfs4_fsinfo_arg *args)
2503 .
minorversion = nfs4_xdr_minorversion(&args->seq_args),
2506 encode_compound_hdr(xdr, req, &hdr);
2507 encode_sequence(xdr, &args->seq_args, &hdr);
2508 encode_putfh(xdr, args->fh, &hdr);
2509 encode_fsinfo(xdr, args->bitmask, &hdr);
2516 static void nfs4_xdr_enc_pathconf(
struct rpc_rqst *req,
struct xdr_stream *xdr,
2517 const struct nfs4_pathconf_arg *args)
2520 .
minorversion = nfs4_xdr_minorversion(&args->seq_args),
2523 encode_compound_hdr(xdr, req, &hdr);
2524 encode_sequence(xdr, &args->seq_args, &hdr);
2525 encode_putfh(xdr, args->fh, &hdr);
2534 static void nfs4_xdr_enc_statfs(
struct rpc_rqst *req,
struct xdr_stream *xdr,
2535 const struct nfs4_statfs_arg *args)
2538 .
minorversion = nfs4_xdr_minorversion(&args->seq_args),
2541 encode_compound_hdr(xdr, req, &hdr);
2542 encode_sequence(xdr, &args->seq_args, &hdr);
2543 encode_putfh(xdr, args->fh, &hdr);
2552 static void nfs4_xdr_enc_server_caps(
struct rpc_rqst *req,
2553 struct xdr_stream *xdr,
2554 struct nfs4_server_caps_arg *args)
2557 .
minorversion = nfs4_xdr_minorversion(&args->seq_args),
2560 encode_compound_hdr(xdr, req, &hdr);
2561 encode_sequence(xdr, &args->seq_args, &hdr);
2562 encode_putfh(xdr, args->fhandle, &hdr);
2574 static void nfs4_xdr_enc_renew(
struct rpc_rqst *req,
struct xdr_stream *xdr,
2581 encode_compound_hdr(xdr, req, &hdr);
2582 encode_renew(xdr, clp->cl_clientid, &hdr);
2589 static void nfs4_xdr_enc_setclientid(
struct rpc_rqst *req,
2590 struct xdr_stream *xdr,
2591 struct nfs4_setclientid *
sc)
2597 encode_compound_hdr(xdr, req, &hdr);
2598 encode_setclientid(xdr, sc, &hdr);
2605 static void nfs4_xdr_enc_setclientid_confirm(
struct rpc_rqst *req,
2606 struct xdr_stream *xdr,
2607 struct nfs4_setclientid_res *arg)
2614 encode_compound_hdr(xdr, req, &hdr);
2615 encode_setclientid_confirm(xdr, arg, &hdr);
2616 encode_putrootfh(xdr, &hdr);
2617 encode_fsinfo(xdr, lease_bitmap, &hdr);
2624 static void nfs4_xdr_enc_delegreturn(
struct rpc_rqst *req,
2625 struct xdr_stream *xdr,
2632 encode_compound_hdr(xdr, req, &hdr);
2633 encode_sequence(xdr, &args->
seq_args, &hdr);
2634 encode_putfh(xdr, args->
fhandle, &hdr);
2635 encode_getfattr(xdr, args->
bitmask, &hdr);
2636 encode_delegreturn(xdr, args->
stateid, &hdr);
2643 static void nfs4_xdr_enc_fs_locations(
struct rpc_rqst *req,
2644 struct xdr_stream *xdr,
2645 struct nfs4_fs_locations_arg *args)
2648 .
minorversion = nfs4_xdr_minorversion(&args->seq_args),
2652 encode_compound_hdr(xdr, req, &hdr);
2653 encode_sequence(xdr, &args->seq_args, &hdr);
2654 encode_putfh(xdr, args->dir_fh, &hdr);
2655 encode_lookup(xdr, args->name, &hdr);
2657 encode_fs_locations(xdr, args->bitmask, &hdr);
2667 static void nfs4_xdr_enc_secinfo(
struct rpc_rqst *req,
2668 struct xdr_stream *xdr,
2669 struct nfs4_secinfo_arg *args)
2672 .
minorversion = nfs4_xdr_minorversion(&args->seq_args),
2675 encode_compound_hdr(xdr, req, &hdr);
2676 encode_sequence(xdr, &args->seq_args, &hdr);
2677 encode_putfh(xdr, args->dir_fh, &hdr);
2678 encode_secinfo(xdr, args->name, &hdr);
2682 #if defined(CONFIG_NFS_V4_1)
2686 static void nfs4_xdr_enc_bind_conn_to_session(
struct rpc_rqst *req,
2687 struct xdr_stream *xdr,
2694 encode_compound_hdr(xdr, req, &hdr);
2695 encode_bind_conn_to_session(xdr, clp->cl_session, &hdr);
2702 static void nfs4_xdr_enc_exchange_id(
struct rpc_rqst *req,
2703 struct xdr_stream *xdr,
2704 struct nfs41_exchange_id_args *args)
2710 encode_compound_hdr(xdr, req, &hdr);
2711 encode_exchange_id(xdr, args, &hdr);
2718 static void nfs4_xdr_enc_create_session(
struct rpc_rqst *req,
2719 struct xdr_stream *xdr,
2720 struct nfs41_create_session_args *args)
2726 encode_compound_hdr(xdr, req, &hdr);
2727 encode_create_session(xdr, args, &hdr);
2734 static void nfs4_xdr_enc_destroy_session(
struct rpc_rqst *req,
2735 struct xdr_stream *xdr,
2736 struct nfs4_session *session)
2742 encode_compound_hdr(xdr, req, &hdr);
2743 encode_destroy_session(xdr, session, &hdr);
2750 static void nfs4_xdr_enc_destroy_clientid(
struct rpc_rqst *req,
2751 struct xdr_stream *xdr,
2758 encode_compound_hdr(xdr, req, &hdr);
2759 encode_destroy_clientid(xdr, clp->cl_clientid, &hdr);
2766 static void nfs4_xdr_enc_sequence(
struct rpc_rqst *req,
struct xdr_stream *xdr,
2773 encode_compound_hdr(xdr, req, &hdr);
2774 encode_sequence(xdr, args, &hdr);
2781 static void nfs4_xdr_enc_get_lease_time(
struct rpc_rqst *req,
2782 struct xdr_stream *xdr,
2790 encode_compound_hdr(xdr, req, &hdr);
2792 encode_putrootfh(xdr, &hdr);
2793 encode_fsinfo(xdr, lease_bitmap, &hdr);
2800 static void nfs4_xdr_enc_reclaim_complete(
struct rpc_rqst *req,
2801 struct xdr_stream *xdr,
2802 struct nfs41_reclaim_complete_args *args)
2808 encode_compound_hdr(xdr, req, &hdr);
2809 encode_sequence(xdr, &args->seq_args, &hdr);
2810 encode_reclaim_complete(xdr, args, &hdr);
2817 static void nfs4_xdr_enc_getdevicelist(
struct rpc_rqst *req,
2818 struct xdr_stream *xdr,
2825 encode_compound_hdr(xdr, req, &hdr);
2826 encode_sequence(xdr, &args->
seq_args, &hdr);
2827 encode_putfh(xdr, args->
fh, &hdr);
2828 encode_getdevicelist(xdr, args, &hdr);
2835 static void nfs4_xdr_enc_getdeviceinfo(
struct rpc_rqst *req,
2836 struct xdr_stream *xdr,
2843 encode_compound_hdr(xdr, req, &hdr);
2844 encode_sequence(xdr, &args->
seq_args, &hdr);
2845 encode_getdeviceinfo(xdr, args, &hdr);
2850 args->
pdev->pages, args->
pdev->pgbase,
2859 static void nfs4_xdr_enc_layoutget(
struct rpc_rqst *req,
2860 struct xdr_stream *xdr,
2867 encode_compound_hdr(xdr, req, &hdr);
2868 encode_sequence(xdr, &args->
seq_args, &hdr);
2869 encode_putfh(xdr, NFS_FH(args->
inode), &hdr);
2870 encode_layoutget(xdr, args, &hdr);
2881 static void nfs4_xdr_enc_layoutcommit(
struct rpc_rqst *req,
2882 struct xdr_stream *xdr,
2891 encode_compound_hdr(xdr, req, &hdr);
2892 encode_sequence(xdr, &args->
seq_args, &hdr);
2893 encode_putfh(xdr, NFS_FH(args->
inode), &hdr);
2894 encode_layoutcommit(xdr, data->
args.inode, args, &hdr);
2895 encode_getfattr(xdr, args->
bitmask, &hdr);
2902 static void nfs4_xdr_enc_layoutreturn(
struct rpc_rqst *req,
2903 struct xdr_stream *xdr,
2910 encode_compound_hdr(xdr, req, &hdr);
2911 encode_sequence(xdr, &args->
seq_args, &hdr);
2912 encode_putfh(xdr, NFS_FH(args->
inode), &hdr);
2913 encode_layoutreturn(xdr, args, &hdr);
2920 static int nfs4_xdr_enc_secinfo_no_name(
struct rpc_rqst *req,
2921 struct xdr_stream *xdr,
2922 struct nfs41_secinfo_no_name_args *args)
2925 .
minorversion = nfs4_xdr_minorversion(&args->seq_args),
2928 encode_compound_hdr(xdr, req, &hdr);
2929 encode_sequence(xdr, &args->seq_args, &hdr);
2930 encode_putrootfh(xdr, &hdr);
2931 encode_secinfo_no_name(xdr, args, &hdr);
2939 static void nfs4_xdr_enc_test_stateid(
struct rpc_rqst *req,
2940 struct xdr_stream *xdr,
2941 struct nfs41_test_stateid_args *args)
2944 .
minorversion = nfs4_xdr_minorversion(&args->seq_args),
2947 encode_compound_hdr(xdr, req, &hdr);
2948 encode_sequence(xdr, &args->seq_args, &hdr);
2949 encode_test_stateid(xdr, args, &hdr);
2956 static void nfs4_xdr_enc_free_stateid(
struct rpc_rqst *req,
2957 struct xdr_stream *xdr,
2958 struct nfs41_free_stateid_args *args)
2961 .
minorversion = nfs4_xdr_minorversion(&args->seq_args),
2964 encode_compound_hdr(xdr, req, &hdr);
2965 encode_sequence(xdr, &args->seq_args, &hdr);
2966 encode_free_stateid(xdr, args, &hdr);
2971 static void print_overflow_msg(
const char *
func,
const struct xdr_stream *xdr)
2973 dprintk(
"nfs: %s: prematurely hit end of receive buffer. "
2974 "Remaining buffer length is %tu words.\n",
2975 func, xdr->end - xdr->p);
2978 static int decode_opaque_inline(
struct xdr_stream *xdr,
unsigned int *len,
char **
string)
2989 *
string = (
char *)p;
2992 print_overflow_msg(__func__, xdr);
2996 static int decode_compound_hdr(
struct xdr_stream *xdr,
struct compound_hdr *hdr)
3009 hdr->
tag = (
char *)p;
3010 p += XDR_QUADLEN(hdr->
taglen);
3013 return nfs4_stat_to_errno(hdr->
status);
3016 print_overflow_msg(__func__, xdr);
3020 static int decode_op_hdr(
struct xdr_stream *xdr,
enum nfs_opnum4 expected)
3030 if (opnum != expected) {
3031 dprintk(
"nfs: Server returned operation"
3032 " %d but we issued a request for %d\n",
3038 return nfs4_stat_to_errno(nfserr);
3041 print_overflow_msg(__func__, xdr);
3046 static int decode_ace(
struct xdr_stream *xdr,
void *ace,
struct nfs_client *clp)
3054 return decode_opaque_inline(xdr, &strlen, &str);
3055 print_overflow_msg(__func__, xdr);
3059 static int decode_attr_bitmap(
struct xdr_stream *xdr,
uint32_t *
bitmap)
3069 bitmap[0] = bitmap[1] = bitmap[2] = 0;
3083 print_overflow_msg(__func__, xdr);
3087 static int decode_attr_length(
struct xdr_stream *xdr,
uint32_t *attrlen,
unsigned int *savep)
3098 print_overflow_msg(__func__, xdr);
3106 ret = decode_attr_bitmap(xdr, bitmask);
3109 bitmap[0] &= ~FATTR4_WORD0_SUPPORTED_ATTRS;
3111 bitmask[0] = bitmask[1] = bitmask[2] = 0;
3112 dprintk(
"%s: bitmask=%08x:%08x:%08x\n", __func__,
3113 bitmask[0], bitmask[1], bitmask[2]);
3131 dprintk(
"%s: bad type %d\n", __func__, *type);
3134 bitmap[0] &= ~FATTR4_WORD0_TYPE;
3137 dprintk(
"%s: type=0%o\n", __func__, nfs_type2fmt[*type]);
3140 print_overflow_msg(__func__, xdr);
3144 static int decode_attr_fh_expire_type(
struct xdr_stream *xdr,
3157 bitmap[0] &= ~FATTR4_WORD0_FH_EXPIRE_TYPE;
3159 dprintk(
"%s: expire type=0x%x\n", __func__, *type);
3162 print_overflow_msg(__func__, xdr);
3166 static int decode_attr_change(
struct xdr_stream *xdr,
uint32_t *bitmap,
uint64_t *change)
3178 xdr_decode_hyper(p, change);
3179 bitmap[0] &= ~FATTR4_WORD0_CHANGE;
3182 dprintk(
"%s: change attribute=%Lu\n", __func__,
3183 (
unsigned long long)*change);
3186 print_overflow_msg(__func__, xdr);
3202 xdr_decode_hyper(p, size);
3203 bitmap[0] &= ~FATTR4_WORD0_SIZE;
3206 dprintk(
"%s: file size=%Lu\n", __func__, (
unsigned long long)*size);
3209 print_overflow_msg(__func__, xdr);
3213 static int decode_attr_link_support(
struct xdr_stream *xdr,
uint32_t *bitmap,
uint32_t *
res)
3225 bitmap[0] &= ~FATTR4_WORD0_LINK_SUPPORT;
3227 dprintk(
"%s: link support=%s\n", __func__, *res == 0 ?
"false" :
"true");
3230 print_overflow_msg(__func__, xdr);
3234 static int decode_attr_symlink_support(
struct xdr_stream *xdr,
uint32_t *bitmap,
uint32_t *res)
3246 bitmap[0] &= ~FATTR4_WORD0_SYMLINK_SUPPORT;
3248 dprintk(
"%s: symlink support=%s\n", __func__, *res == 0 ?
"false" :
"true");
3251 print_overflow_msg(__func__, xdr);
3268 p = xdr_decode_hyper(p, &fsid->
major);
3269 xdr_decode_hyper(p, &fsid->
minor);
3270 bitmap[0] &= ~FATTR4_WORD0_FSID;
3273 dprintk(
"%s: fsid=(0x%Lx/0x%Lx)\n", __func__,
3274 (
unsigned long long)fsid->
major,
3275 (
unsigned long long)fsid->
minor);
3278 print_overflow_msg(__func__, xdr);
3282 static int decode_attr_lease_time(
struct xdr_stream *xdr,
uint32_t *bitmap,
uint32_t *res)
3294 bitmap[0] &= ~FATTR4_WORD0_LEASE_TIME;
3296 dprintk(
"%s: file size=%u\n", __func__, (
unsigned int)*res);
3299 print_overflow_msg(__func__, xdr);
3303 static int decode_attr_error(
struct xdr_stream *xdr,
uint32_t *bitmap,
int32_t *res)
3313 bitmap[0] &= ~FATTR4_WORD0_RDATTR_ERROR;
3318 print_overflow_msg(__func__, xdr);
3322 static int decode_attr_filehandle(
struct xdr_stream *xdr,
uint32_t *bitmap,
struct nfs_fh *fh)
3328 memset(fh, 0,
sizeof(*fh));
3346 bitmap[0] &= ~FATTR4_WORD0_FILEHANDLE;
3350 print_overflow_msg(__func__, xdr);
3354 static int decode_attr_aclsupport(
struct xdr_stream *xdr,
uint32_t *bitmap,
uint32_t *res)
3366 bitmap[0] &= ~FATTR4_WORD0_ACLSUPPORT;
3368 dprintk(
"%s: ACLs supported=%u\n", __func__, (
unsigned int)*res);
3371 print_overflow_msg(__func__, xdr);
3375 static int decode_attr_fileid(
struct xdr_stream *xdr,
uint32_t *bitmap,
uint64_t *fileid)
3387 xdr_decode_hyper(p, fileid);
3388 bitmap[0] &= ~FATTR4_WORD0_FILEID;
3391 dprintk(
"%s: fileid=%Lu\n", __func__, (
unsigned long long)*fileid);
3394 print_overflow_msg(__func__, xdr);
3398 static int decode_attr_mounted_on_fileid(
struct xdr_stream *xdr,
uint32_t *bitmap,
uint64_t *fileid)
3410 xdr_decode_hyper(p, fileid);
3411 bitmap[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID;
3414 dprintk(
"%s: fileid=%Lu\n", __func__, (
unsigned long long)*fileid);
3417 print_overflow_msg(__func__, xdr);
3421 static int decode_attr_files_avail(
struct xdr_stream *xdr,
uint32_t *bitmap,
uint64_t *res)
3433 xdr_decode_hyper(p, res);
3434 bitmap[0] &= ~FATTR4_WORD0_FILES_AVAIL;
3436 dprintk(
"%s: files avail=%Lu\n", __func__, (
unsigned long long)*res);
3439 print_overflow_msg(__func__, xdr);
3443 static int decode_attr_files_free(
struct xdr_stream *xdr,
uint32_t *bitmap,
uint64_t *res)
3455 xdr_decode_hyper(p, res);
3456 bitmap[0] &= ~FATTR4_WORD0_FILES_FREE;
3458 dprintk(
"%s: files free=%Lu\n", __func__, (
unsigned long long)*res);
3461 print_overflow_msg(__func__, xdr);
3465 static int decode_attr_files_total(
struct xdr_stream *xdr,
uint32_t *bitmap,
uint64_t *res)
3477 xdr_decode_hyper(p, res);
3478 bitmap[0] &= ~FATTR4_WORD0_FILES_TOTAL;
3480 dprintk(
"%s: files total=%Lu\n", __func__, (
unsigned long long)*res);
3483 print_overflow_msg(__func__, xdr);
3487 static int decode_pathname(
struct xdr_stream *xdr,
struct nfs4_pathname *
path)
3500 path->ncomponents = 0;
3501 while (path->ncomponents < n) {
3503 status = decode_opaque_inline(xdr, &component->
len, &component->
data);
3508 (path->ncomponents != n ? "/ " : ""),
3509 component->len, component->data);
3510 if (path->ncomponents < NFS4_PATHNAME_MAXCOMPONENTS)
3511 path->ncomponents++;
3513 dprintk(
"cannot parse %d components in path\n", n);
3521 path->ncomponents = 1;
3522 path->components[0].len=0;
3523 path->components[0].data=
NULL;
3527 dprintk(
" status %d", status);
3531 print_overflow_msg(__func__, xdr);
3535 static int decode_attr_fs_locations(
struct xdr_stream *xdr,
uint32_t *bitmap,
struct nfs4_fs_locations *res)
3550 dprintk(
"%s: fsroot:\n", __func__);
3551 status = decode_pathname(xdr, &res->fs_path);
3560 res->nlocations = 0;
3561 while (res->nlocations < n) {
3563 struct nfs4_fs_location *
loc = &res->locations[res->nlocations];
3571 dprintk(
"%s: servers:\n", __func__);
3572 while (loc->nservers < m) {
3573 struct nfs4_string *server = &loc->servers[loc->nservers];
3574 status = decode_opaque_inline(xdr, &server->
len, &server->
data);
3578 if (loc->nservers < NFS4_FS_LOCATION_MAXSERVERS)
3582 dprintk(
"%s: using first %u of %u servers "
3583 "returned for location %u\n",
3585 NFS4_FS_LOCATION_MAXSERVERS,
3586 m, res->nlocations);
3587 for (i = loc->nservers; i < m; i++) {
3590 status = decode_opaque_inline(xdr, &len, &data);
3596 status = decode_pathname(xdr, &loc->rootpath);
3599 if (res->nlocations < NFS4_FS_LOCATIONS_MAXENTRIES)
3602 if (res->nlocations != 0)
3605 dprintk(
"%s: fs_locations done, error = %d\n", __func__, status);
3608 print_overflow_msg(__func__, xdr);
3614 static int decode_attr_maxfilesize(
struct xdr_stream *xdr,
uint32_t *bitmap,
uint64_t *res)
3626 xdr_decode_hyper(p, res);
3627 bitmap[0] &= ~FATTR4_WORD0_MAXFILESIZE;
3629 dprintk(
"%s: maxfilesize=%Lu\n", __func__, (
unsigned long long)*res);
3632 print_overflow_msg(__func__, xdr);
3636 static int decode_attr_maxlink(
struct xdr_stream *xdr,
uint32_t *bitmap,
uint32_t *maxlink)
3649 bitmap[0] &= ~FATTR4_WORD0_MAXLINK;
3651 dprintk(
"%s: maxlink=%u\n", __func__, *maxlink);
3654 print_overflow_msg(__func__, xdr);
3658 static int decode_attr_maxname(
struct xdr_stream *xdr,
uint32_t *bitmap,
uint32_t *maxname)
3671 bitmap[0] &= ~FATTR4_WORD0_MAXNAME;
3673 dprintk(
"%s: maxname=%u\n", __func__, *maxname);
3676 print_overflow_msg(__func__, xdr);
3680 static int decode_attr_maxread(
struct xdr_stream *xdr,
uint32_t *bitmap,
uint32_t *res)
3693 xdr_decode_hyper(p, &maxread);
3694 if (maxread > 0x7FFFFFFF)
3695 maxread = 0x7FFFFFFF;
3697 bitmap[0] &= ~FATTR4_WORD0_MAXREAD;
3699 dprintk(
"%s: maxread=%lu\n", __func__, (
unsigned long)*res);
3702 print_overflow_msg(__func__, xdr);
3706 static int decode_attr_maxwrite(
struct xdr_stream *xdr,
uint32_t *bitmap,
uint32_t *res)
3719 xdr_decode_hyper(p, &maxwrite);
3720 if (maxwrite > 0x7FFFFFFF)
3721 maxwrite = 0x7FFFFFFF;
3723 bitmap[0] &= ~FATTR4_WORD0_MAXWRITE;
3725 dprintk(
"%s: maxwrite=%lu\n", __func__, (
unsigned long)*res);
3728 print_overflow_msg(__func__, xdr);
3747 bitmap[1] &= ~FATTR4_WORD1_MODE;
3750 dprintk(
"%s: file mode=0%o\n", __func__, (
unsigned int)*mode);
3753 print_overflow_msg(__func__, xdr);
3770 bitmap[1] &= ~FATTR4_WORD1_NUMLINKS;
3773 dprintk(
"%s: nlink=%u\n", __func__, (
unsigned int)*nlink);
3776 print_overflow_msg(__func__, xdr);
3780 static int decode_attr_owner(
struct xdr_stream *xdr,
uint32_t *bitmap,
3799 if (owner_name !=
NULL) {
3805 }
else if (len < XDR_MAX_NETOBJ) {
3809 dprintk(
"%s: nfs_map_name_to_uid failed!\n",
3812 dprintk(
"%s: name too long (%u)!\n",
3814 bitmap[1] &= ~FATTR4_WORD1_OWNER;
3816 dprintk(
"%s: uid=%d\n", __func__, (
int)*uid);
3819 print_overflow_msg(__func__, xdr);
3823 static int decode_attr_group(
struct xdr_stream *xdr,
uint32_t *bitmap,
3842 if (group_name !=
NULL) {
3848 }
else if (len < XDR_MAX_NETOBJ) {
3852 dprintk(
"%s: nfs_map_group_to_gid failed!\n",
3855 dprintk(
"%s: name too long (%u)!\n",
3857 bitmap[1] &= ~FATTR4_WORD1_OWNER_GROUP;
3859 dprintk(
"%s: gid=%d\n", __func__, (
int)*gid);
3862 print_overflow_msg(__func__, xdr);
3866 static int decode_attr_rdev(
struct xdr_stream *xdr,
uint32_t *bitmap,
dev_t *
rdev)
3883 tmp =
MKDEV(major, minor);
3884 if (
MAJOR(tmp) == major &&
MINOR(tmp) == minor)
3889 dprintk(
"%s: rdev=(0x%x:0x%x)\n", __func__, major, minor);
3892 print_overflow_msg(__func__, xdr);
3896 static int decode_attr_space_avail(
struct xdr_stream *xdr,
uint32_t *bitmap,
uint64_t *res)
3908 xdr_decode_hyper(p, res);
3909 bitmap[1] &= ~FATTR4_WORD1_SPACE_AVAIL;
3911 dprintk(
"%s: space avail=%Lu\n", __func__, (
unsigned long long)*res);
3914 print_overflow_msg(__func__, xdr);
3918 static int decode_attr_space_free(
struct xdr_stream *xdr,
uint32_t *bitmap,
uint64_t *res)
3930 xdr_decode_hyper(p, res);
3931 bitmap[1] &= ~FATTR4_WORD1_SPACE_FREE;
3933 dprintk(
"%s: space free=%Lu\n", __func__, (
unsigned long long)*res);
3936 print_overflow_msg(__func__, xdr);
3940 static int decode_attr_space_total(
struct xdr_stream *xdr,
uint32_t *bitmap,
uint64_t *res)
3952 xdr_decode_hyper(p, res);
3953 bitmap[1] &= ~FATTR4_WORD1_SPACE_TOTAL;
3955 dprintk(
"%s: space total=%Lu\n", __func__, (
unsigned long long)*res);
3958 print_overflow_msg(__func__, xdr);
3974 xdr_decode_hyper(p, used);
3975 bitmap[1] &= ~FATTR4_WORD1_SPACE_USED;
3978 dprintk(
"%s: space used=%Lu\n", __func__,
3979 (
unsigned long long)*used);
3982 print_overflow_msg(__func__, xdr);
3986 static int decode_attr_time(
struct xdr_stream *xdr,
struct timespec *
time)
3995 p = xdr_decode_hyper(p, &sec);
4001 print_overflow_msg(__func__, xdr);
4005 static int decode_attr_time_access(
struct xdr_stream *xdr,
uint32_t *bitmap,
struct timespec *time)
4014 status = decode_attr_time(xdr, time);
4017 bitmap[1] &= ~FATTR4_WORD1_TIME_ACCESS;
4023 static int decode_attr_time_metadata(
struct xdr_stream *xdr,
uint32_t *bitmap,
struct timespec *time)
4032 status = decode_attr_time(xdr, time);
4035 bitmap[1] &= ~FATTR4_WORD1_TIME_METADATA;
4041 static int decode_attr_time_delta(
struct xdr_stream *xdr,
uint32_t *bitmap,
4051 status = decode_attr_time(xdr, time);
4052 bitmap[1] &= ~FATTR4_WORD1_TIME_DELTA;
4054 dprintk(
"%s: time_delta=%ld %ld\n", __func__, (
long)time->
tv_sec,
4059 static int decode_attr_time_modify(
struct xdr_stream *xdr,
uint32_t *bitmap,
struct timespec *time)
4068 status = decode_attr_time(xdr, time);
4071 bitmap[1] &= ~FATTR4_WORD1_TIME_MODIFY;
4077 static int verify_attr_len(
struct xdr_stream *xdr,
unsigned int savep,
uint32_t attrlen)
4079 unsigned int attrwords = XDR_QUADLEN(attrlen);
4082 if (
unlikely(attrwords != nwords)) {
4083 dprintk(
"%s: server returned incorrect attribute length: "
4087 (attrwords < nwords) ?
'<' :
'>',
4094 static int decode_change_info(
struct xdr_stream *xdr,
struct nfs4_change_info *cinfo)
4102 p = xdr_decode_hyper(p, &cinfo->
before);
4103 xdr_decode_hyper(p, &cinfo->
after);
4106 print_overflow_msg(__func__, xdr);
4110 static int decode_access(
struct xdr_stream *xdr,
u32 *supported,
u32 *
access)
4128 print_overflow_msg(__func__, xdr);
4132 static int decode_opaque_fixed(
struct xdr_stream *xdr,
void *
buf,
size_t len)
4141 print_overflow_msg(__func__, xdr);
4145 static int decode_stateid(
struct xdr_stream *xdr,
nfs4_stateid *stateid)
4150 static int decode_close(
struct xdr_stream *xdr,
struct nfs_closeres *res)
4154 status = decode_op_hdr(xdr,
OP_CLOSE);
4158 status = decode_stateid(xdr, &res->
stateid);
4162 static int decode_verifier(
struct xdr_stream *xdr,
void *verifier)
4167 static int decode_write_verifier(
struct xdr_stream *xdr,
struct nfs_write_verifier *verifier)
4172 static int decode_commit(
struct xdr_stream *xdr,
struct nfs_commitres *res)
4178 status = decode_write_verifier(xdr, &res->
verf->verifier);
4182 static int decode_create(
struct xdr_stream *xdr,
struct nfs4_change_info *cinfo)
4191 if ((status = decode_change_info(xdr, cinfo)))
4201 print_overflow_msg(__func__, xdr);
4205 static int decode_server_caps(
struct xdr_stream *xdr,
struct nfs4_server_caps_res *res)
4211 if ((status = decode_op_hdr(xdr,
OP_GETATTR)) != 0)
4213 if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
4215 if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
4217 if ((status = decode_attr_supported(xdr, bitmap, res->attr_bitmask)) != 0)
4219 if ((status = decode_attr_fh_expire_type(xdr, bitmap,
4220 &res->fh_expire_type)) != 0)
4222 if ((status = decode_attr_link_support(xdr, bitmap, &res->has_links)) != 0)
4224 if ((status = decode_attr_symlink_support(xdr, bitmap, &res->has_symlinks)) != 0)
4226 if ((status = decode_attr_aclsupport(xdr, bitmap, &res->acl_bitmask)) != 0)
4228 status = verify_attr_len(xdr, savep, attrlen);
4230 dprintk(
"%s: xdr returned %d!\n", __func__, -status);
4234 static int decode_statfs(
struct xdr_stream *xdr,
struct nfs_fsstat *fsstat)
4240 if ((status = decode_op_hdr(xdr,
OP_GETATTR)) != 0)
4242 if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
4244 if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
4247 if ((status = decode_attr_files_avail(xdr, bitmap, &fsstat->
afiles)) != 0)
4249 if ((status = decode_attr_files_free(xdr, bitmap, &fsstat->
ffiles)) != 0)
4251 if ((status = decode_attr_files_total(xdr, bitmap, &fsstat->
tfiles)) != 0)
4253 if ((status = decode_attr_space_avail(xdr, bitmap, &fsstat->
abytes)) != 0)
4255 if ((status = decode_attr_space_free(xdr, bitmap, &fsstat->
fbytes)) != 0)
4257 if ((status = decode_attr_space_total(xdr, bitmap, &fsstat->
tbytes)) != 0)
4260 status = verify_attr_len(xdr, savep, attrlen);
4262 dprintk(
"%s: xdr returned %d!\n", __func__, -status);
4266 static int decode_pathconf(
struct xdr_stream *xdr,
struct nfs_pathconf *pathconf)
4272 if ((status = decode_op_hdr(xdr,
OP_GETATTR)) != 0)
4274 if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
4276 if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
4279 if ((status = decode_attr_maxlink(xdr, bitmap, &pathconf->
max_link)) != 0)
4281 if ((status = decode_attr_maxname(xdr, bitmap, &pathconf->
max_namelen)) != 0)
4284 status = verify_attr_len(xdr, savep, attrlen);
4286 dprintk(
"%s: xdr returned %d!\n", __func__, -status);
4290 static int decode_threshold_hint(
struct xdr_stream *xdr,
4298 if (
likely(bitmap[0] & hint_bit)) {
4302 xdr_decode_hyper(p, res);
4306 print_overflow_msg(__func__, xdr);
4310 static int decode_first_threshold_item4(
struct xdr_stream *xdr,
4315 uint32_t bitmap[3] = {0,}, attrlen;
4321 print_overflow_msg(__func__, xdr);
4327 status = decode_attr_bitmap(xdr, bitmap);
4332 status = decode_attr_length(xdr, &attrlen, &savep);
4342 status = decode_threshold_hint(xdr, bitmap, &res->
rd_io_sz,
4346 status = decode_threshold_hint(xdr, bitmap, &res->
wr_io_sz,
4351 status = verify_attr_len(xdr, savep, attrlen);
4352 res->
bm = bitmap[0];
4354 dprintk(
"%s bm=0x%x rd_sz=%llu wr_sz=%llu rd_io=%llu wr_io=%llu\n",
4358 dprintk(
"%s ret=%d!\n", __func__, status);
4365 static int decode_attr_mdsthreshold(
struct xdr_stream *xdr,
4387 "drivers per filesystem not supported\n",
4390 status = decode_first_threshold_item4(xdr, res);
4391 bitmap[2] &= ~FATTR4_WORD2_MDSTHRESHOLD;
4395 print_overflow_msg(__func__, xdr);
4399 static int decode_getfattr_attrs(
struct xdr_stream *xdr,
uint32_t *bitmap,
4401 struct nfs4_fs_locations *fs_loc,
4409 status = decode_attr_type(xdr, bitmap, &type);
4418 status = decode_attr_change(xdr, bitmap, &fattr->
change_attr);
4423 status = decode_attr_size(xdr, bitmap, &fattr->
size);
4428 status = decode_attr_fsid(xdr, bitmap, &fattr->
fsid);
4434 status = decode_attr_error(xdr, bitmap, &err);
4438 status = decode_attr_filehandle(xdr, bitmap, fh);
4442 status = decode_attr_fileid(xdr, bitmap, &fattr->
fileid);
4447 status = decode_attr_fs_locations(xdr, bitmap, fs_loc);
4452 status = decode_attr_mode(xdr, bitmap, &fmode);
4456 fattr->
mode |= fmode;
4460 status = decode_attr_nlink(xdr, bitmap, &fattr->
nlink);
4465 status = decode_attr_owner(xdr, bitmap, server, &fattr->
uid, fattr->
owner_name);
4470 status = decode_attr_group(xdr, bitmap, server, &fattr->
gid, fattr->
group_name);
4475 status = decode_attr_rdev(xdr, bitmap, &fattr->
rdev);
4480 status = decode_attr_space_used(xdr, bitmap, &fattr->
du.
nfs3.used);
4485 status = decode_attr_time_access(xdr, bitmap, &fattr->
atime);
4490 status = decode_attr_time_metadata(xdr, bitmap, &fattr->
ctime);
4495 status = decode_attr_time_modify(xdr, bitmap, &fattr->
mtime);
4505 status = decode_attr_mdsthreshold(xdr, bitmap, fattr->
mdsthreshold);
4510 dprintk(
"%s: xdr returned %d\n", __func__, -status);
4514 static int decode_getfattr_generic(
struct xdr_stream *xdr,
struct nfs_fattr *fattr,
4515 struct nfs_fh *fh,
struct nfs4_fs_locations *fs_loc,
4527 status = decode_attr_bitmap(xdr, bitmap);
4531 status = decode_attr_length(xdr, &attrlen, &savep);
4535 status = decode_getfattr_attrs(xdr, bitmap, fattr, fh, fs_loc, server);
4539 status = verify_attr_len(xdr, savep, attrlen);
4541 dprintk(
"%s: xdr returned %d\n", __func__, -status);
4545 static int decode_getfattr(
struct xdr_stream *xdr,
struct nfs_fattr *fattr,
4548 return decode_getfattr_generic(xdr, fattr,
NULL,
NULL, server);
4555 static int decode_first_pnfs_layout_type(
struct xdr_stream *xdr,
4573 "drivers per filesystem not supported\n", __func__);
4582 print_overflow_msg(__func__, xdr);
4590 static int decode_attr_pnfstype(
struct xdr_stream *xdr,
uint32_t *bitmap,
4595 dprintk(
"%s: bitmap is %x\n", __func__, bitmap[1]);
4599 status = decode_first_pnfs_layout_type(xdr, layouttype);
4600 bitmap[1] &= ~FATTR4_WORD1_FS_LAYOUT_TYPES;
4609 static int decode_attr_layout_blksize(
struct xdr_stream *xdr,
uint32_t *bitmap,
4614 dprintk(
"%s: bitmap is %x\n", __func__, bitmap[2]);
4619 print_overflow_msg(__func__, xdr);
4623 bitmap[2] &= ~FATTR4_WORD2_LAYOUT_BLKSIZE;
4628 static int decode_fsinfo(
struct xdr_stream *xdr,
struct nfs_fsinfo *fsinfo)
4634 if ((status = decode_op_hdr(xdr,
OP_GETATTR)) != 0)
4636 if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
4638 if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
4643 if ((status = decode_attr_lease_time(xdr, bitmap, &fsinfo->
lease_time)) != 0)
4645 if ((status = decode_attr_maxfilesize(xdr, bitmap, &fsinfo->
maxfilesize)) != 0)
4647 if ((status = decode_attr_maxread(xdr, bitmap, &fsinfo->
rtmax)) != 0)
4650 if ((status = decode_attr_maxwrite(xdr, bitmap, &fsinfo->
wtmax)) != 0)
4653 status = decode_attr_time_delta(xdr, bitmap, &fsinfo->
time_delta);
4656 status = decode_attr_pnfstype(xdr, bitmap, &fsinfo->
layouttype);
4659 status = decode_attr_layout_blksize(xdr, bitmap, &fsinfo->
blksize);
4663 status = verify_attr_len(xdr, savep, attrlen);
4665 dprintk(
"%s: xdr returned %d!\n", __func__, -status);
4669 static int decode_getfh(
struct xdr_stream *xdr,
struct nfs_fh *fh)
4676 memset(fh, 0,
sizeof(*fh));
4678 status = decode_op_hdr(xdr,
OP_GETFH);
4695 print_overflow_msg(__func__, xdr);
4699 static int decode_link(
struct xdr_stream *xdr,
struct nfs4_change_info *cinfo)
4703 status = decode_op_hdr(xdr,
OP_LINK);
4706 return decode_change_info(xdr, cinfo);
4712 static int decode_lock_denied (
struct xdr_stream *xdr,
struct file_lock *fl)
4721 p = xdr_decode_hyper(p, &offset);
4722 p = xdr_decode_hyper(p, &length);
4734 p = xdr_decode_hyper(p, &clientid);
4740 print_overflow_msg(__func__, xdr);
4744 static int decode_lock(
struct xdr_stream *xdr,
struct nfs_lock_res *res)
4748 status = decode_op_hdr(xdr,
OP_LOCK);
4752 status = decode_stateid(xdr, &res->
stateid);
4756 status = decode_lock_denied(xdr,
NULL);
4764 static int decode_lockt(
struct xdr_stream *xdr,
struct nfs_lockt_res *res)
4767 status = decode_op_hdr(xdr,
OP_LOCKT);
4769 return decode_lock_denied(xdr, res->
denied);
4773 static int decode_locku(
struct xdr_stream *xdr,
struct nfs_locku_res *res)
4777 status = decode_op_hdr(xdr,
OP_LOCKU);
4781 status = decode_stateid(xdr, &res->
stateid);
4785 static int decode_release_lockowner(
struct xdr_stream *xdr)
4790 static int decode_lookup(
struct xdr_stream *xdr)
4796 static int decode_space_limit(
struct xdr_stream *xdr,
u64 *maxsize)
4799 uint32_t limit_type, nblocks, blocksize;
4805 switch (limit_type) {
4807 xdr_decode_hyper(p, maxsize);
4816 print_overflow_msg(__func__, xdr);
4820 static int decode_delegation(
struct xdr_stream *xdr,
struct nfs_openres *res)
4834 status = decode_stateid(xdr, &res->
delegation);
4842 switch (delegation_type) {
4848 if (decode_space_limit(xdr, &res->
maxsize) < 0)
4851 return decode_ace(xdr,
NULL, res->
server->nfs_client);
4853 print_overflow_msg(__func__, xdr);
4857 static int decode_open(
struct xdr_stream *xdr,
struct nfs_openres *res)
4863 status = decode_op_hdr(xdr,
OP_OPEN);
4867 status = decode_stateid(xdr, &res->
stateid);
4871 decode_change_info(xdr, &res->
cinfo);
4885 for (i = 0; i < savewords; ++
i)
4890 return decode_delegation(xdr, res);
4892 dprintk(
"%s: Bitmap too large! Length = %u\n", __func__, bmlen);
4895 print_overflow_msg(__func__, xdr);
4907 status = decode_stateid(xdr, &res->
stateid);
4911 static int decode_open_downgrade(
struct xdr_stream *xdr,
struct nfs_closeres *res)
4919 status = decode_stateid(xdr, &res->
stateid);
4923 static int decode_putfh(
struct xdr_stream *xdr)
4925 return decode_op_hdr(xdr,
OP_PUTFH);
4928 static int decode_putrootfh(
struct xdr_stream *xdr)
4933 static int decode_read(
struct xdr_stream *xdr,
struct rpc_rqst *req,
struct nfs_readres *res)
4939 status = decode_op_hdr(xdr,
OP_READ);
4948 if (count > recvd) {
4949 dprintk(
"NFS: server cheating in read reply: "
4950 "count %u > recvd %u\n", count, recvd);
4958 print_overflow_msg(__func__, xdr);
4962 static int decode_readdir(
struct xdr_stream *xdr,
struct rpc_rqst *req,
struct nfs4_readdir_res *readdir)
4969 status = decode_verifier(xdr, readdir->verifier.data);
4972 memcpy(verf, readdir->verifier.data,
sizeof(verf));
4973 dprintk(
"%s: verifier = %08x:%08x\n",
4974 __func__, verf[0], verf[1]);
4978 static int decode_readlink(
struct xdr_stream *xdr,
struct rpc_rqst *req)
4980 struct xdr_buf *
rcvbuf = &req->rq_rcv_buf;
4994 if (len >= rcvbuf->page_len || len <= 0) {
4995 dprintk(
"nfs: server returned giant symlink!\n");
5000 dprintk(
"NFS: server cheating in readlink reply: "
5001 "count %u > recvd %u\n", len, recvd);
5014 print_overflow_msg(__func__, xdr);
5018 static int decode_remove(
struct xdr_stream *xdr,
struct nfs4_change_info *cinfo)
5025 status = decode_change_info(xdr, cinfo);
5030 static int decode_rename(
struct xdr_stream *xdr,
struct nfs4_change_info *old_cinfo,
5038 if ((status = decode_change_info(xdr, old_cinfo)))
5040 status = decode_change_info(xdr, new_cinfo);
5045 static int decode_renew(
struct xdr_stream *xdr)
5047 return decode_op_hdr(xdr,
OP_RENEW);
5051 decode_restorefh(
struct xdr_stream *xdr)
5056 static int decode_getacl(
struct xdr_stream *xdr,
struct rpc_rqst *req,
5063 unsigned int pg_offset;
5066 if ((status = decode_op_hdr(xdr,
OP_GETATTR)) != 0)
5072 pg_offset = xdr->buf->head[0].iov_len;
5074 if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
5076 if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
5090 if (res->
acl_len > (xdr->nwords << 2) ||
5093 dprintk(
"NFS: acl reply: attrlen %u > page_len %u\n",
5094 attrlen, xdr->nwords << 2);
5104 decode_savefh(
struct xdr_stream *xdr)
5109 static int decode_setattr(
struct xdr_stream *xdr)
5126 print_overflow_msg(__func__, xdr);
5130 static int decode_setclientid(
struct xdr_stream *xdr,
struct nfs4_setclientid_res *res)
5141 dprintk(
"nfs: decode_setclientid: Server returned operation"
5150 p = xdr_decode_hyper(p, &res->clientid);
5174 return nfs4_stat_to_errno(nfserr);
5178 print_overflow_msg(__func__, xdr);
5182 static int decode_setclientid_confirm(
struct xdr_stream *xdr)
5187 static int decode_write(
struct xdr_stream *xdr,
struct nfs_writeres *res)
5192 status = decode_op_hdr(xdr,
OP_WRITE);
5201 return decode_write_verifier(xdr, &res->
verf->verifier);
5203 print_overflow_msg(__func__, xdr);
5207 static int decode_delegreturn(
struct xdr_stream *xdr)
5212 static int decode_secinfo_gss(
struct xdr_stream *xdr,
struct nfs4_secinfo_flavor *flavor)
5220 if (flavor->gss.sec_oid4.len > GSS_OID_MAX_LEN)
5226 memcpy(flavor->gss.sec_oid4.data, p, flavor->gss.sec_oid4.len);
5237 print_overflow_msg(__func__, xdr);
5243 static int decode_secinfo_common(
struct xdr_stream *xdr,
struct nfs4_secinfo_res *res)
5245 struct nfs4_secinfo_flavor *sec_flavor;
5254 res->flavors->num_flavors = 0;
5257 for (i = 0; i < num_flavors; i++) {
5258 sec_flavor = &res->flavors->flavors[
i];
5259 if ((
char *)&sec_flavor[1] - (
char *)res->flavors >
PAGE_SIZE)
5267 if (sec_flavor->flavor == RPC_AUTH_GSS) {
5268 status = decode_secinfo_gss(xdr, sec_flavor);
5272 res->flavors->num_flavors++;
5279 print_overflow_msg(__func__, xdr);
5283 static int decode_secinfo(
struct xdr_stream *xdr,
struct nfs4_secinfo_res *res)
5288 return decode_secinfo_common(xdr, res);
5291 #if defined(CONFIG_NFS_V4_1)
5292 static int decode_secinfo_no_name(
struct xdr_stream *xdr,
struct nfs4_secinfo_res *res)
5297 return decode_secinfo_common(xdr, res);
5300 static int decode_exchange_id(
struct xdr_stream *xdr,
5301 struct nfs41_exchange_id_res *res)
5316 xdr_decode_hyper(p, &res->clientid);
5332 p = xdr_decode_hyper(p, &res->server_owner->minor_id);
5335 status = decode_opaque_inline(xdr, &dummy, &dummy_str);
5340 memcpy(res->server_owner->major_id, dummy_str, dummy);
5341 res->server_owner->major_id_sz =
dummy;
5344 status = decode_opaque_inline(xdr, &dummy, &dummy_str);
5349 memcpy(res->server_scope->server_scope, dummy_str, dummy);
5350 res->server_scope->server_scope_sz =
dummy;
5358 if (impl_id_count) {
5360 status = decode_opaque_inline(xdr, &dummy, &dummy_str);
5365 memcpy(res->impl_id->domain, dummy_str, dummy);
5368 status = decode_opaque_inline(xdr, &dummy, &dummy_str);
5373 memcpy(res->impl_id->name, dummy_str, dummy);
5379 p = xdr_decode_hyper(p, &res->impl_id->date.seconds);
5386 print_overflow_msg(__func__, xdr);
5390 static int decode_chan_attrs(
struct xdr_stream *xdr,
5410 "count %u\n", __func__, nr_attrs);
5413 if (nr_attrs == 1) {
5420 print_overflow_msg(__func__, xdr);
5429 static int decode_bind_conn_to_session(
struct xdr_stream *xdr,
5430 struct nfs41_bind_conn_to_session_res *res)
5437 status = decode_sessionid(xdr, &res->session->sess_id);
5450 res->use_conn_in_rdma_mode =
false;
5452 res->use_conn_in_rdma_mode =
true;
5456 print_overflow_msg(__func__, xdr);
5460 static int decode_create_session(
struct xdr_stream *xdr,
5461 struct nfs41_create_session_res *res)
5466 struct nfs4_session *session = clp->cl_session;
5470 status = decode_sessionid(xdr, &session->sess_id);
5482 status = decode_chan_attrs(xdr, &session->fc_attrs);
5484 status = decode_chan_attrs(xdr, &session->bc_attrs);
5487 print_overflow_msg(__func__, xdr);
5491 static int decode_destroy_session(
struct xdr_stream *xdr,
void *dummy)
5496 static int decode_destroy_clientid(
struct xdr_stream *xdr,
void *dummy)
5501 static int decode_reclaim_complete(
struct xdr_stream *xdr,
void *dummy)
5507 static int decode_sequence(
struct xdr_stream *xdr,
5509 struct rpc_rqst *rqstp)
5511 #if defined(CONFIG_NFS_V4_1)
5522 status = decode_sessionid(xdr, &
id);
5534 dprintk(
"%s Invalid session id\n", __func__);
5544 if (dummy != res->
sr_slot->seq_nr) {
5545 dprintk(
"%s Invalid sequence number\n", __func__);
5551 dprintk(
"%s Invalid slot id\n", __func__);
5565 print_overflow_msg(__func__, xdr);
5573 #if defined(CONFIG_NFS_V4_1)
5577 static int decode_getdevicelist(
struct xdr_stream *xdr,
5578 struct pnfs_devicelist *res)
5600 dprintk(
"%s: num_dev %d\n", __func__, res->num_devs);
5602 if (res->num_devs > NFS4_PNFS_GETDEVLIST_MAXNUM) {
5604 __func__, res->num_devs);
5612 for (i = 0; i < res->num_devs; i++)
5613 p = xdr_decode_opaque_fixed(p, res->dev_id[i].data,
5618 print_overflow_msg(__func__, xdr);
5622 static int decode_getdeviceinfo(
struct xdr_stream *xdr,
5623 struct pnfs_device *pdev)
5636 dprintk(
"%s: Min count too small. mincnt = %u\n",
5637 __func__, pdev->mincount);
5646 if (type != pdev->layout_type) {
5647 dprintk(
"%s: layout mismatch req: %u pdev: %u\n",
5648 __func__, pdev->layout_type, type);
5671 for (i = 0; i < len; i++, p++) {
5673 dprintk(
"%s: notifications not supported\n",
5681 print_overflow_msg(__func__, xdr);
5685 static int decode_layoutget(
struct xdr_stream *xdr,
struct rpc_rqst *req,
5700 decode_stateid(xdr, &res->
stateid);
5705 if (!layout_count) {
5706 dprintk(
"%s: server responded with empty layout array\n",
5714 p = xdr_decode_hyper(p, &res->
range.offset);
5715 p = xdr_decode_hyper(p, &res->
range.length);
5720 dprintk(
"%s roff:%lu rlen:%lu riomode:%d, lo_type:0x%x, lo.len:%d\n",
5722 (
unsigned long)res->
range.offset,
5723 (
unsigned long)res->
range.length,
5729 if (res->
layoutp->len > recvd) {
5730 dprintk(
"NFS: server cheating in layoutget reply: "
5731 "layout len %u > recvd %u\n",
5736 if (layout_count > 1) {
5742 dprintk(
"%s: server responded with %d layouts, dropping tail\n",
5743 __func__, layout_count);
5748 print_overflow_msg(__func__, xdr);
5752 static int decode_layoutreturn(
struct xdr_stream *xdr,
5766 status = decode_stateid(xdr, &res->
stateid);
5769 print_overflow_msg(__func__, xdr);
5773 static int decode_layoutcommit(
struct xdr_stream *xdr,
5774 struct rpc_rqst *req,
5799 print_overflow_msg(__func__, xdr);
5803 static int decode_test_stateid(
struct xdr_stream *xdr,
5804 struct nfs41_test_stateid_res *res)
5828 print_overflow_msg(__func__, xdr);
5833 static int decode_free_stateid(
struct xdr_stream *xdr,
5834 struct nfs41_free_stateid_res *res)
5849 print_overflow_msg(__func__, xdr);
5861 static int nfs4_xdr_dec_open_downgrade(
struct rpc_rqst *rqstp,
5862 struct xdr_stream *xdr,
5868 status = decode_compound_hdr(xdr, &hdr);
5871 status = decode_sequence(xdr, &res->
seq_res, rqstp);
5874 status = decode_putfh(xdr);
5877 status = decode_open_downgrade(xdr, res);
5888 static int nfs4_xdr_dec_access(
struct rpc_rqst *rqstp,
struct xdr_stream *xdr,
5889 struct nfs4_accessres *res)
5894 status = decode_compound_hdr(xdr, &hdr);
5897 status = decode_sequence(xdr, &res->seq_res, rqstp);
5900 status = decode_putfh(xdr);
5903 status = decode_access(xdr, &res->supported, &res->access);
5906 decode_getfattr(xdr, res->fattr, res->server);
5914 static int nfs4_xdr_dec_lookup(
struct rpc_rqst *rqstp,
struct xdr_stream *xdr,
5915 struct nfs4_lookup_res *res)
5920 status = decode_compound_hdr(xdr, &hdr);
5923 status = decode_sequence(xdr, &res->seq_res, rqstp);
5926 status = decode_putfh(xdr);
5929 status = decode_lookup(xdr);
5932 status = decode_getfh(xdr, res->fh);
5935 status = decode_getfattr(xdr, res->fattr, res->server);
5943 static int nfs4_xdr_dec_lookup_root(
struct rpc_rqst *rqstp,
5944 struct xdr_stream *xdr,
5945 struct nfs4_lookup_res *res)
5950 status = decode_compound_hdr(xdr, &hdr);
5953 status = decode_sequence(xdr, &res->seq_res, rqstp);
5956 status = decode_putrootfh(xdr);
5959 status = decode_getfh(xdr, res->fh);
5961 status = decode_getfattr(xdr, res->fattr, res->server);
5969 static int nfs4_xdr_dec_remove(
struct rpc_rqst *rqstp,
struct xdr_stream *xdr,
5975 status = decode_compound_hdr(xdr, &hdr);
5978 status = decode_sequence(xdr, &res->
seq_res, rqstp);
5981 status = decode_putfh(xdr);
5984 status = decode_remove(xdr, &res->
cinfo);
5992 static int nfs4_xdr_dec_rename(
struct rpc_rqst *rqstp,
struct xdr_stream *xdr,
5998 status = decode_compound_hdr(xdr, &hdr);
6001 status = decode_sequence(xdr, &res->
seq_res, rqstp);
6004 status = decode_putfh(xdr);
6007 status = decode_savefh(xdr);
6010 status = decode_putfh(xdr);
6021 static int nfs4_xdr_dec_link(
struct rpc_rqst *rqstp,
struct xdr_stream *xdr,
6022 struct nfs4_link_res *res)
6027 status = decode_compound_hdr(xdr, &hdr);
6030 status = decode_sequence(xdr, &res->seq_res, rqstp);
6033 status = decode_putfh(xdr);
6036 status = decode_savefh(xdr);
6039 status = decode_putfh(xdr);
6042 status = decode_link(xdr, &res->cinfo);
6049 status = decode_restorefh(xdr);
6052 decode_getfattr(xdr, res->fattr, res->server);
6060 static int nfs4_xdr_dec_create(
struct rpc_rqst *rqstp,
struct xdr_stream *xdr,
6061 struct nfs4_create_res *res)
6066 status = decode_compound_hdr(xdr, &hdr);
6069 status = decode_sequence(xdr, &res->seq_res, rqstp);
6072 status = decode_putfh(xdr);
6075 status = decode_create(xdr, &res->dir_cinfo);
6078 status = decode_getfh(xdr, res->fh);
6081 decode_getfattr(xdr, res->fattr, res->server);
6089 static int nfs4_xdr_dec_symlink(
struct rpc_rqst *rqstp,
struct xdr_stream *xdr,
6090 struct nfs4_create_res *res)
6092 return nfs4_xdr_dec_create(rqstp, xdr, res);
6098 static int nfs4_xdr_dec_getattr(
struct rpc_rqst *rqstp,
struct xdr_stream *xdr,
6099 struct nfs4_getattr_res *res)
6104 status = decode_compound_hdr(xdr, &hdr);
6107 status = decode_sequence(xdr, &res->seq_res, rqstp);
6110 status = decode_putfh(xdr);
6113 status = decode_getfattr(xdr, res->fattr, res->server);
6121 static void nfs4_xdr_enc_setacl(
struct rpc_rqst *req,
struct xdr_stream *xdr,
6128 encode_compound_hdr(xdr, req, &hdr);
6129 encode_sequence(xdr, &args->
seq_args, &hdr);
6130 encode_putfh(xdr, args->
fh, &hdr);
6131 encode_setacl(xdr, args, &hdr);
6139 nfs4_xdr_dec_setacl(
struct rpc_rqst *rqstp,
struct xdr_stream *xdr,
6145 status = decode_compound_hdr(xdr, &hdr);
6148 status = decode_sequence(xdr, &res->
seq_res, rqstp);
6151 status = decode_putfh(xdr);
6154 status = decode_setattr(xdr);
6163 nfs4_xdr_dec_getacl(
struct rpc_rqst *rqstp,
struct xdr_stream *xdr,
6173 status = decode_compound_hdr(xdr, &hdr);
6176 status = decode_sequence(xdr, &res->
seq_res, rqstp);
6179 status = decode_putfh(xdr);
6182 status = decode_getacl(xdr, rqstp, res);
6191 static int nfs4_xdr_dec_close(
struct rpc_rqst *rqstp,
struct xdr_stream *xdr,
6197 status = decode_compound_hdr(xdr, &hdr);
6200 status = decode_sequence(xdr, &res->
seq_res, rqstp);
6203 status = decode_putfh(xdr);
6206 status = decode_close(xdr, res);
6223 static int nfs4_xdr_dec_open(
struct rpc_rqst *rqstp,
struct xdr_stream *xdr,
6229 status = decode_compound_hdr(xdr, &hdr);
6232 status = decode_sequence(xdr, &res->
seq_res, rqstp);
6235 status = decode_putfh(xdr);
6238 status = decode_open(xdr, res);
6241 status = decode_getfh(xdr, &res->
fh);
6254 static int nfs4_xdr_dec_open_confirm(
struct rpc_rqst *rqstp,
6255 struct xdr_stream *xdr,
6261 status = decode_compound_hdr(xdr, &hdr);
6264 status = decode_putfh(xdr);
6267 status = decode_open_confirm(xdr, res);
6275 static int nfs4_xdr_dec_open_noattr(
struct rpc_rqst *rqstp,
6276 struct xdr_stream *xdr,
6282 status = decode_compound_hdr(xdr, &hdr);
6285 status = decode_sequence(xdr, &res->
seq_res, rqstp);
6288 status = decode_putfh(xdr);
6291 status = decode_open(xdr, res);
6304 static int nfs4_xdr_dec_setattr(
struct rpc_rqst *rqstp,
6305 struct xdr_stream *xdr,
6311 status = decode_compound_hdr(xdr, &hdr);
6314 status = decode_sequence(xdr, &res->
seq_res, rqstp);
6317 status = decode_putfh(xdr);
6320 status = decode_setattr(xdr);
6331 static int nfs4_xdr_dec_lock(
struct rpc_rqst *rqstp,
struct xdr_stream *xdr,
6337 status = decode_compound_hdr(xdr, &hdr);
6340 status = decode_sequence(xdr, &res->
seq_res, rqstp);
6343 status = decode_putfh(xdr);
6346 status = decode_lock(xdr, res);
6354 static int nfs4_xdr_dec_lockt(
struct rpc_rqst *rqstp,
struct xdr_stream *xdr,
6360 status = decode_compound_hdr(xdr, &hdr);
6363 status = decode_sequence(xdr, &res->
seq_res, rqstp);
6366 status = decode_putfh(xdr);
6369 status = decode_lockt(xdr, res);
6377 static int nfs4_xdr_dec_locku(
struct rpc_rqst *rqstp,
struct xdr_stream *xdr,
6383 status = decode_compound_hdr(xdr, &hdr);
6386 status = decode_sequence(xdr, &res->
seq_res, rqstp);
6389 status = decode_putfh(xdr);
6392 status = decode_locku(xdr, res);
6397 static int nfs4_xdr_dec_release_lockowner(
struct rpc_rqst *rqstp,
6398 struct xdr_stream *xdr,
void *dummy)
6403 status = decode_compound_hdr(xdr, &hdr);
6405 status = decode_release_lockowner(xdr);
6412 static int nfs4_xdr_dec_readlink(
struct rpc_rqst *rqstp,
6413 struct xdr_stream *xdr,
6414 struct nfs4_readlink_res *res)
6419 status = decode_compound_hdr(xdr, &hdr);
6422 status = decode_sequence(xdr, &res->seq_res, rqstp);
6425 status = decode_putfh(xdr);
6428 status = decode_readlink(xdr, rqstp);
6436 static int nfs4_xdr_dec_readdir(
struct rpc_rqst *rqstp,
struct xdr_stream *xdr,
6437 struct nfs4_readdir_res *res)
6442 status = decode_compound_hdr(xdr, &hdr);
6445 status = decode_sequence(xdr, &res->seq_res, rqstp);
6448 status = decode_putfh(xdr);
6451 status = decode_readdir(xdr, rqstp, res);
6459 static int nfs4_xdr_dec_read(
struct rpc_rqst *rqstp,
struct xdr_stream *xdr,
6465 status = decode_compound_hdr(xdr, &hdr);
6468 status = decode_sequence(xdr, &res->
seq_res, rqstp);
6471 status = decode_putfh(xdr);
6474 status = decode_read(xdr, rqstp, res);
6476 status = res->
count;
6484 static int nfs4_xdr_dec_write(
struct rpc_rqst *rqstp,
struct xdr_stream *xdr,
6490 status = decode_compound_hdr(xdr, &hdr);
6493 status = decode_sequence(xdr, &res->
seq_res, rqstp);
6496 status = decode_putfh(xdr);
6499 status = decode_write(xdr, res);
6505 status = res->
count;
6513 static int nfs4_xdr_dec_commit(
struct rpc_rqst *rqstp,
struct xdr_stream *xdr,
6519 status = decode_compound_hdr(xdr, &hdr);
6522 status = decode_sequence(xdr, &res->
seq_res, rqstp);
6525 status = decode_putfh(xdr);
6528 status = decode_commit(xdr, res);
6536 static int nfs4_xdr_dec_fsinfo(
struct rpc_rqst *req,
struct xdr_stream *xdr,
6537 struct nfs4_fsinfo_res *res)
6542 status = decode_compound_hdr(xdr, &hdr);
6544 status = decode_sequence(xdr, &res->seq_res, req);
6546 status = decode_putfh(xdr);
6548 status = decode_fsinfo(xdr, res->fsinfo);
6555 static int nfs4_xdr_dec_pathconf(
struct rpc_rqst *req,
struct xdr_stream *xdr,
6556 struct nfs4_pathconf_res *res)
6561 status = decode_compound_hdr(xdr, &hdr);
6563 status = decode_sequence(xdr, &res->seq_res, req);
6565 status = decode_putfh(xdr);
6567 status = decode_pathconf(xdr, res->pathconf);
6574 static int nfs4_xdr_dec_statfs(
struct rpc_rqst *req,
struct xdr_stream *xdr,
6575 struct nfs4_statfs_res *res)
6580 status = decode_compound_hdr(xdr, &hdr);
6582 status = decode_sequence(xdr, &res->seq_res, req);
6584 status = decode_putfh(xdr);
6586 status = decode_statfs(xdr, res->fsstat);
6593 static int nfs4_xdr_dec_server_caps(
struct rpc_rqst *req,
6594 struct xdr_stream *xdr,
6595 struct nfs4_server_caps_res *res)
6600 status = decode_compound_hdr(xdr, &hdr);
6603 status = decode_sequence(xdr, &res->seq_res, req);
6606 status = decode_putfh(xdr);
6609 status = decode_server_caps(xdr, res);
6617 static int nfs4_xdr_dec_renew(
struct rpc_rqst *rqstp,
struct xdr_stream *xdr,
6623 status = decode_compound_hdr(xdr, &hdr);
6625 status = decode_renew(xdr);
6632 static int nfs4_xdr_dec_setclientid(
struct rpc_rqst *req,
6633 struct xdr_stream *xdr,
6634 struct nfs4_setclientid_res *res)
6639 status = decode_compound_hdr(xdr, &hdr);
6641 status = decode_setclientid(xdr, res);
6648 static int nfs4_xdr_dec_setclientid_confirm(
struct rpc_rqst *req,
6649 struct xdr_stream *xdr,
6655 status = decode_compound_hdr(xdr, &hdr);
6657 status = decode_setclientid_confirm(xdr);
6659 status = decode_putrootfh(xdr);
6661 status = decode_fsinfo(xdr, fsinfo);
6668 static int nfs4_xdr_dec_delegreturn(
struct rpc_rqst *rqstp,
6669 struct xdr_stream *xdr,
6675 status = decode_compound_hdr(xdr, &hdr);
6678 status = decode_sequence(xdr, &res->
seq_res, rqstp);
6681 status = decode_putfh(xdr);
6684 status = decode_getfattr(xdr, res->
fattr, res->
server);
6687 status = decode_delegreturn(xdr);
6695 static int nfs4_xdr_dec_fs_locations(
struct rpc_rqst *req,
6696 struct xdr_stream *xdr,
6697 struct nfs4_fs_locations_res *res)
6702 status = decode_compound_hdr(xdr, &hdr);
6705 status = decode_sequence(xdr, &res->seq_res, req);
6708 status = decode_putfh(xdr);
6711 status = decode_lookup(xdr);
6715 status = decode_getfattr_generic(xdr, &res->fs_locations->fattr,
6716 NULL, res->fs_locations,
6717 res->fs_locations->server);
6725 static int nfs4_xdr_dec_secinfo(
struct rpc_rqst *rqstp,
6726 struct xdr_stream *xdr,
6727 struct nfs4_secinfo_res *res)
6732 status = decode_compound_hdr(xdr, &hdr);
6735 status = decode_sequence(xdr, &res->seq_res, rqstp);
6738 status = decode_putfh(xdr);
6741 status = decode_secinfo(xdr, res);
6746 #if defined(CONFIG_NFS_V4_1)
6750 static int nfs4_xdr_dec_bind_conn_to_session(
struct rpc_rqst *rqstp,
6751 struct xdr_stream *xdr,
6757 status = decode_compound_hdr(xdr, &hdr);
6759 status = decode_bind_conn_to_session(xdr, res);
6766 static int nfs4_xdr_dec_exchange_id(
struct rpc_rqst *rqstp,
6767 struct xdr_stream *xdr,
6773 status = decode_compound_hdr(xdr, &hdr);
6775 status = decode_exchange_id(xdr, res);
6782 static int nfs4_xdr_dec_create_session(
struct rpc_rqst *rqstp,
6783 struct xdr_stream *xdr,
6784 struct nfs41_create_session_res *res)
6789 status = decode_compound_hdr(xdr, &hdr);
6791 status = decode_create_session(xdr, res);
6798 static int nfs4_xdr_dec_destroy_session(
struct rpc_rqst *rqstp,
6799 struct xdr_stream *xdr,
6805 status = decode_compound_hdr(xdr, &hdr);
6807 status = decode_destroy_session(xdr, res);
6814 static int nfs4_xdr_dec_destroy_clientid(
struct rpc_rqst *rqstp,
6815 struct xdr_stream *xdr,
6821 status = decode_compound_hdr(xdr, &hdr);
6823 status = decode_destroy_clientid(xdr, res);
6830 static int nfs4_xdr_dec_sequence(
struct rpc_rqst *rqstp,
6831 struct xdr_stream *xdr,
6837 status = decode_compound_hdr(xdr, &hdr);
6839 status = decode_sequence(xdr, res, rqstp);
6846 static int nfs4_xdr_dec_get_lease_time(
struct rpc_rqst *rqstp,
6847 struct xdr_stream *xdr,
6853 status = decode_compound_hdr(xdr, &hdr);
6855 status = decode_sequence(xdr, &res->
lr_seq_res, rqstp);
6857 status = decode_putrootfh(xdr);
6859 status = decode_fsinfo(xdr, res->
lr_fsinfo);
6866 static int nfs4_xdr_dec_reclaim_complete(
struct rpc_rqst *rqstp,
6867 struct xdr_stream *xdr,
6868 struct nfs41_reclaim_complete_res *res)
6873 status = decode_compound_hdr(xdr, &hdr);
6875 status = decode_sequence(xdr, &res->seq_res, rqstp);
6877 status = decode_reclaim_complete(xdr, (
void *)
NULL);
6884 static int nfs4_xdr_dec_getdevicelist(
struct rpc_rqst *rqstp,
6885 struct xdr_stream *xdr,
6891 dprintk(
"encoding getdevicelist!\n");
6893 status = decode_compound_hdr(xdr, &hdr);
6896 status = decode_sequence(xdr, &res->
seq_res, rqstp);
6899 status = decode_putfh(xdr);
6902 status = decode_getdevicelist(xdr, res->
devlist);
6910 static int nfs4_xdr_dec_getdeviceinfo(
struct rpc_rqst *rqstp,
6911 struct xdr_stream *xdr,
6917 status = decode_compound_hdr(xdr, &hdr);
6920 status = decode_sequence(xdr, &res->
seq_res, rqstp);
6923 status = decode_getdeviceinfo(xdr, res->
pdev);
6931 static int nfs4_xdr_dec_layoutget(
struct rpc_rqst *rqstp,
6932 struct xdr_stream *xdr,
6938 status = decode_compound_hdr(xdr, &hdr);
6941 status = decode_sequence(xdr, &res->
seq_res, rqstp);
6944 status = decode_putfh(xdr);
6947 status = decode_layoutget(xdr, rqstp, res);
6955 static int nfs4_xdr_dec_layoutreturn(
struct rpc_rqst *rqstp,
6956 struct xdr_stream *xdr,
6962 status = decode_compound_hdr(xdr, &hdr);
6965 status = decode_sequence(xdr, &res->
seq_res, rqstp);
6968 status = decode_putfh(xdr);
6971 status = decode_layoutreturn(xdr, res);
6979 static int nfs4_xdr_dec_layoutcommit(
struct rpc_rqst *rqstp,
6980 struct xdr_stream *xdr,
6986 status = decode_compound_hdr(xdr, &hdr);
6989 status = decode_sequence(xdr, &res->
seq_res, rqstp);
6992 status = decode_putfh(xdr);
6995 status = decode_layoutcommit(xdr, rqstp, res);
7006 static int nfs4_xdr_dec_secinfo_no_name(
struct rpc_rqst *rqstp,
7007 struct xdr_stream *xdr,
7008 struct nfs4_secinfo_res *res)
7013 status = decode_compound_hdr(xdr, &hdr);
7016 status = decode_sequence(xdr, &res->seq_res, rqstp);
7019 status = decode_putrootfh(xdr);
7022 status = decode_secinfo_no_name(xdr, res);
7030 static int nfs4_xdr_dec_test_stateid(
struct rpc_rqst *rqstp,
7031 struct xdr_stream *xdr,
7032 struct nfs41_test_stateid_res *res)
7037 status = decode_compound_hdr(xdr, &hdr);
7040 status = decode_sequence(xdr, &res->seq_res, rqstp);
7043 status = decode_test_stateid(xdr, res);
7051 static int nfs4_xdr_dec_free_stateid(
struct rpc_rqst *rqstp,
7052 struct xdr_stream *xdr,
7053 struct nfs41_free_stateid_res *res)
7058 status = decode_compound_hdr(xdr, &hdr);
7061 status = decode_sequence(xdr, &res->seq_res, rqstp);
7064 status = decode_free_stateid(xdr, res);
7093 if (*p == xdr_zero) {
7107 p = xdr_decode_hyper(p, &entry->
cookie);
7113 entry->
name = (
const char *) p;
7121 entry->
fattr->valid = 0;
7123 if (decode_attr_bitmap(xdr, bitmap) < 0)
7126 if (decode_attr_length(xdr, &len, &savep) < 0)
7129 if (decode_getfattr_attrs(xdr, bitmap, entry->
fattr, entry->
fh,
7133 entry->
ino = entry->
fattr->mounted_on_fileid;
7139 entry->
d_type = nfs_umode_to_dtype(entry->
fattr->mode);
7144 print_overflow_msg(__func__, xdr);
7193 nfs4_stat_to_errno(
int stat)
7196 for (i = 0; nfs_errtbl[
i].stat != -1; i++) {
7197 if (nfs_errtbl[i].stat == stat)
7198 return nfs_errtbl[
i].errno;
7212 #define PROC(proc, argtype, restype) \
7213 [NFSPROC4_CLNT_##proc] = { \
7214 .p_proc = NFSPROC4_COMPOUND, \
7215 .p_encode = (kxdreproc_t)nfs4_xdr_##argtype, \
7216 .p_decode = (kxdrdproc_t)nfs4_xdr_##restype, \
7217 .p_arglen = NFS4_##argtype##_sz, \
7218 .p_replen = NFS4_##restype##_sz, \
7219 .p_statidx = NFSPROC4_CLNT_##proc, \
7226 PROC(COMMIT, enc_commit, dec_commit),
7228 PROC(OPEN_CONFIRM, enc_open_confirm, dec_open_confirm),
7229 PROC(OPEN_NOATTR, enc_open_noattr, dec_open_noattr),
7230 PROC(OPEN_DOWNGRADE, enc_open_downgrade, dec_open_downgrade),
7231 PROC(CLOSE, enc_close, dec_close),
7232 PROC(SETATTR, enc_setattr, dec_setattr),
7233 PROC(FSINFO, enc_fsinfo, dec_fsinfo),
7234 PROC(RENEW, enc_renew, dec_renew),
7235 PROC(SETCLIENTID, enc_setclientid, dec_setclientid),
7236 PROC(SETCLIENTID_CONFIRM, enc_setclientid_confirm, dec_setclientid_confirm),
7238 PROC(LOCKT, enc_lockt, dec_lockt),
7239 PROC(LOCKU, enc_locku, dec_locku),
7240 PROC(ACCESS, enc_access, dec_access),
7241 PROC(GETATTR, enc_getattr, dec_getattr),
7242 PROC(LOOKUP, enc_lookup, dec_lookup),
7245 PROC(RENAME, enc_rename, dec_rename),
7247 PROC(SYMLINK, enc_symlink, dec_symlink),
7249 PROC(PATHCONF, enc_pathconf, dec_pathconf),
7250 PROC(STATFS, enc_statfs, dec_statfs),
7251 PROC(READLINK, enc_readlink, dec_readlink),
7252 PROC(READDIR, enc_readdir, dec_readdir),
7253 PROC(SERVER_CAPS, enc_server_caps, dec_server_caps),
7254 PROC(DELEGRETURN, enc_delegreturn, dec_delegreturn),
7255 PROC(GETACL, enc_getacl, dec_getacl),
7256 PROC(SETACL, enc_setacl, dec_setacl),
7257 PROC(FS_LOCATIONS, enc_fs_locations, dec_fs_locations),
7258 PROC(RELEASE_LOCKOWNER, enc_release_lockowner, dec_release_lockowner),
7259 PROC(SECINFO, enc_secinfo, dec_secinfo),
7260 #if defined(CONFIG_NFS_V4_1)
7261 PROC(EXCHANGE_ID, enc_exchange_id, dec_exchange_id),
7262 PROC(CREATE_SESSION, enc_create_session, dec_create_session),
7263 PROC(DESTROY_SESSION, enc_destroy_session, dec_destroy_session),
7265 PROC(GET_LEASE_TIME, enc_get_lease_time, dec_get_lease_time),
7266 PROC(RECLAIM_COMPLETE, enc_reclaim_complete, dec_reclaim_complete),
7267 PROC(GETDEVICEINFO, enc_getdeviceinfo, dec_getdeviceinfo),
7268 PROC(LAYOUTGET, enc_layoutget, dec_layoutget),
7269 PROC(LAYOUTCOMMIT, enc_layoutcommit, dec_layoutcommit),
7270 PROC(LAYOUTRETURN, enc_layoutreturn, dec_layoutreturn),
7271 PROC(SECINFO_NO_NAME, enc_secinfo_no_name, dec_secinfo_no_name),
7272 PROC(TEST_STATEID, enc_test_stateid, dec_test_stateid),
7273 PROC(FREE_STATEID, enc_free_stateid, dec_free_stateid),
7274 PROC(GETDEVICELIST, enc_getdevicelist, dec_getdevicelist),
7275 PROC(BIND_CONN_TO_SESSION,
7276 enc_bind_conn_to_session, dec_bind_conn_to_session),
7277 PROC(DESTROY_CLIENTID, enc_destroy_clientid, dec_destroy_clientid),
7284 .procs = nfs4_procedures