4 * Client-side XDR for NFSv4.
6 * Copyright (c) 2002 The Regents of the University of Michigan.
9 * Kendrick Smith <kmsmith@umich.edu>
10 * Andy Adamson <andros@umich.edu>
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
16 * 1. Redistributions of source code must retain the above copyright
17 * notice, this list of conditions and the following disclaimer.
18 * 2. Redistributions in binary form must reproduce the above copyright
19 * notice, this list of conditions and the following disclaimer in the
20 * documentation and/or other materials provided with the distribution.
21 * 3. Neither the name of the University nor the names of its
22 * contributors may be used to endorse or promote products derived
23 * from this software without specific prior written permission.
25 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
26 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
27 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
28 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
32 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38 #include <linux/param.h>
39 #include <linux/time.h>
41 #include <linux/errno.h>
42 #include <linux/string.h>
44 #include <linux/pagemap.h>
45 #include <linux/proc_fs.h>
46 #include <linux/kdev_t.h>
47 #include <linux/module.h>
48 #include <linux/utsname.h>
49 #include <linux/sunrpc/clnt.h>
50 #include <linux/sunrpc/msg_prot.h>
51 #include <linux/sunrpc/gss_api.h>
52 #include <linux/nfs.h>
53 #include <linux/nfs4.h>
54 #include <linux/nfs_fs.h>
55 #include <linux/nfs_idmap.h>
59 #include "nfs4session.h"
63 #define NFSDBG_FACILITY NFSDBG_XDR
65 /* Mapping from NFS error code to "errno" error code. */
66 #define errno_NFSERR_IO EIO
68 static int nfs4_stat_to_errno(int);
70 /* NFSv4 COMPOUND tags are only wanted for debugging purposes */
72 #define NFS4_MAXTAGLEN 20
74 #define NFS4_MAXTAGLEN 0
77 /* lock,open owner id:
78 * we currently use size 2 (u64) out of (NFS4_OPAQUE_LIMIT >> 2)
80 #define open_owner_id_maxsz (1 + 2 + 1 + 1 + 2)
81 #define lock_owner_id_maxsz (1 + 1 + 4)
82 #define decode_lockowner_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
83 #define compound_encode_hdr_maxsz (3 + (NFS4_MAXTAGLEN >> 2))
84 #define compound_decode_hdr_maxsz (3 + (NFS4_MAXTAGLEN >> 2))
85 #define op_encode_hdr_maxsz (1)
86 #define op_decode_hdr_maxsz (2)
87 #define encode_stateid_maxsz (XDR_QUADLEN(NFS4_STATEID_SIZE))
88 #define decode_stateid_maxsz (XDR_QUADLEN(NFS4_STATEID_SIZE))
89 #define encode_verifier_maxsz (XDR_QUADLEN(NFS4_VERIFIER_SIZE))
90 #define decode_verifier_maxsz (XDR_QUADLEN(NFS4_VERIFIER_SIZE))
91 #define encode_putfh_maxsz (op_encode_hdr_maxsz + 1 + \
93 #define decode_putfh_maxsz (op_decode_hdr_maxsz)
94 #define encode_putrootfh_maxsz (op_encode_hdr_maxsz)
95 #define decode_putrootfh_maxsz (op_decode_hdr_maxsz)
96 #define encode_getfh_maxsz (op_encode_hdr_maxsz)
97 #define decode_getfh_maxsz (op_decode_hdr_maxsz + 1 + \
98 ((3+NFS4_FHSIZE) >> 2))
99 #define nfs4_fattr_bitmap_maxsz 4
100 #define encode_getattr_maxsz (op_encode_hdr_maxsz + nfs4_fattr_bitmap_maxsz)
101 #define nfs4_name_maxsz (1 + ((3 + NFS4_MAXNAMLEN) >> 2))
102 #define nfs4_path_maxsz (1 + ((3 + NFS4_MAXPATHLEN) >> 2))
103 #define nfs4_owner_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
104 #define nfs4_group_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
105 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
106 /* PI(4 bytes) + LFS(4 bytes) + 1(for null terminator?) + MAXLABELLEN */
107 #define nfs4_label_maxsz (4 + 4 + 1 + XDR_QUADLEN(NFS4_MAXLABELLEN))
108 #define encode_readdir_space 24
109 #define encode_readdir_bitmask_sz 3
111 #define nfs4_label_maxsz 0
112 #define encode_readdir_space 20
113 #define encode_readdir_bitmask_sz 2
115 /* We support only one layout type per file system */
116 #define decode_mdsthreshold_maxsz (1 + 1 + nfs4_fattr_bitmap_maxsz + 1 + 8)
117 /* This is based on getfattr, which uses the most attributes: */
118 #define nfs4_fattr_value_maxsz (1 + (1 + 2 + 2 + 4 + 2 + 1 + 1 + 2 + 2 + \
119 3 + 3 + 3 + nfs4_owner_maxsz + \
120 nfs4_group_maxsz + nfs4_label_maxsz + \
121 decode_mdsthreshold_maxsz))
122 #define nfs4_fattr_maxsz (nfs4_fattr_bitmap_maxsz + \
123 nfs4_fattr_value_maxsz)
124 #define decode_getattr_maxsz (op_decode_hdr_maxsz + nfs4_fattr_maxsz)
125 #define encode_attrs_maxsz (nfs4_fattr_bitmap_maxsz + \
131 #define encode_savefh_maxsz (op_encode_hdr_maxsz)
132 #define decode_savefh_maxsz (op_decode_hdr_maxsz)
133 #define encode_restorefh_maxsz (op_encode_hdr_maxsz)
134 #define decode_restorefh_maxsz (op_decode_hdr_maxsz)
135 #define encode_fsinfo_maxsz (encode_getattr_maxsz)
136 /* The 5 accounts for the PNFS attributes, and assumes that at most three
137 * layout types will be returned.
139 #define decode_fsinfo_maxsz (op_decode_hdr_maxsz + \
140 nfs4_fattr_bitmap_maxsz + 4 + 8 + 5)
141 #define encode_renew_maxsz (op_encode_hdr_maxsz + 3)
142 #define decode_renew_maxsz (op_decode_hdr_maxsz)
143 #define encode_setclientid_maxsz \
144 (op_encode_hdr_maxsz + \
145 XDR_QUADLEN(NFS4_VERIFIER_SIZE) + \
146 XDR_QUADLEN(NFS4_SETCLIENTID_NAMELEN) + \
148 XDR_QUADLEN(RPCBIND_MAXNETIDLEN) + \
149 XDR_QUADLEN(RPCBIND_MAXUADDRLEN) + \
151 #define decode_setclientid_maxsz \
152 (op_decode_hdr_maxsz + \
154 1024) /* large value for CLID_INUSE */
155 #define encode_setclientid_confirm_maxsz \
156 (op_encode_hdr_maxsz + \
157 3 + (NFS4_VERIFIER_SIZE >> 2))
158 #define decode_setclientid_confirm_maxsz \
159 (op_decode_hdr_maxsz)
160 #define encode_lookup_maxsz (op_encode_hdr_maxsz + nfs4_name_maxsz)
161 #define decode_lookup_maxsz (op_decode_hdr_maxsz)
162 #define encode_share_access_maxsz \
164 #define encode_createmode_maxsz (1 + encode_attrs_maxsz + encode_verifier_maxsz)
165 #define encode_opentype_maxsz (1 + encode_createmode_maxsz)
166 #define encode_claim_null_maxsz (1 + nfs4_name_maxsz)
167 #define encode_open_maxsz (op_encode_hdr_maxsz + \
168 2 + encode_share_access_maxsz + 2 + \
169 open_owner_id_maxsz + \
170 encode_opentype_maxsz + \
171 encode_claim_null_maxsz)
172 #define decode_ace_maxsz (3 + nfs4_owner_maxsz)
173 #define decode_delegation_maxsz (1 + decode_stateid_maxsz + 1 + \
175 #define decode_change_info_maxsz (5)
176 #define decode_open_maxsz (op_decode_hdr_maxsz + \
177 decode_stateid_maxsz + \
178 decode_change_info_maxsz + 1 + \
179 nfs4_fattr_bitmap_maxsz + \
180 decode_delegation_maxsz)
181 #define encode_open_confirm_maxsz \
182 (op_encode_hdr_maxsz + \
183 encode_stateid_maxsz + 1)
184 #define decode_open_confirm_maxsz \
185 (op_decode_hdr_maxsz + \
186 decode_stateid_maxsz)
187 #define encode_open_downgrade_maxsz \
188 (op_encode_hdr_maxsz + \
189 encode_stateid_maxsz + 1 + \
190 encode_share_access_maxsz)
191 #define decode_open_downgrade_maxsz \
192 (op_decode_hdr_maxsz + \
193 decode_stateid_maxsz)
194 #define encode_close_maxsz (op_encode_hdr_maxsz + \
195 1 + encode_stateid_maxsz)
196 #define decode_close_maxsz (op_decode_hdr_maxsz + \
197 decode_stateid_maxsz)
198 #define encode_setattr_maxsz (op_encode_hdr_maxsz + \
199 encode_stateid_maxsz + \
201 #define decode_setattr_maxsz (op_decode_hdr_maxsz + \
202 nfs4_fattr_bitmap_maxsz)
203 #define encode_read_maxsz (op_encode_hdr_maxsz + \
204 encode_stateid_maxsz + 3)
205 #define decode_read_maxsz (op_decode_hdr_maxsz + 2)
206 #define encode_readdir_maxsz (op_encode_hdr_maxsz + \
207 2 + encode_verifier_maxsz + 5 + \
209 #define decode_readdir_maxsz (op_decode_hdr_maxsz + \
210 decode_verifier_maxsz + \
211 nfs4_label_maxsz + nfs4_fattr_maxsz)
212 #define encode_readlink_maxsz (op_encode_hdr_maxsz)
213 #define decode_readlink_maxsz (op_decode_hdr_maxsz + 1)
214 #define encode_write_maxsz (op_encode_hdr_maxsz + \
215 encode_stateid_maxsz + 4)
216 #define decode_write_maxsz (op_decode_hdr_maxsz + \
217 2 + decode_verifier_maxsz)
218 #define encode_commit_maxsz (op_encode_hdr_maxsz + 3)
219 #define decode_commit_maxsz (op_decode_hdr_maxsz + \
220 decode_verifier_maxsz)
221 #define encode_remove_maxsz (op_encode_hdr_maxsz + \
223 #define decode_remove_maxsz (op_decode_hdr_maxsz + \
224 decode_change_info_maxsz)
225 #define encode_rename_maxsz (op_encode_hdr_maxsz + \
227 #define decode_rename_maxsz (op_decode_hdr_maxsz + \
228 decode_change_info_maxsz + \
229 decode_change_info_maxsz)
230 #define encode_link_maxsz (op_encode_hdr_maxsz + \
232 #define decode_link_maxsz (op_decode_hdr_maxsz + decode_change_info_maxsz)
233 #define encode_lockowner_maxsz (7)
234 #define encode_lock_maxsz (op_encode_hdr_maxsz + \
236 1 + encode_stateid_maxsz + 1 + \
237 encode_lockowner_maxsz)
238 #define decode_lock_denied_maxsz \
239 (8 + decode_lockowner_maxsz)
240 #define decode_lock_maxsz (op_decode_hdr_maxsz + \
241 decode_lock_denied_maxsz)
242 #define encode_lockt_maxsz (op_encode_hdr_maxsz + 5 + \
243 encode_lockowner_maxsz)
244 #define decode_lockt_maxsz (op_decode_hdr_maxsz + \
245 decode_lock_denied_maxsz)
246 #define encode_locku_maxsz (op_encode_hdr_maxsz + 3 + \
247 encode_stateid_maxsz + \
249 #define decode_locku_maxsz (op_decode_hdr_maxsz + \
250 decode_stateid_maxsz)
251 #define encode_release_lockowner_maxsz \
252 (op_encode_hdr_maxsz + \
253 encode_lockowner_maxsz)
254 #define decode_release_lockowner_maxsz \
255 (op_decode_hdr_maxsz)
256 #define encode_access_maxsz (op_encode_hdr_maxsz + 1)
257 #define decode_access_maxsz (op_decode_hdr_maxsz + 2)
258 #define encode_symlink_maxsz (op_encode_hdr_maxsz + \
259 1 + nfs4_name_maxsz + \
262 #define decode_symlink_maxsz (op_decode_hdr_maxsz + 8)
263 #define encode_create_maxsz (op_encode_hdr_maxsz + \
264 1 + 2 + nfs4_name_maxsz + \
266 #define decode_create_maxsz (op_decode_hdr_maxsz + \
267 decode_change_info_maxsz + \
268 nfs4_fattr_bitmap_maxsz)
269 #define encode_statfs_maxsz (encode_getattr_maxsz)
270 #define decode_statfs_maxsz (decode_getattr_maxsz)
271 #define encode_delegreturn_maxsz (op_encode_hdr_maxsz + 4)
272 #define decode_delegreturn_maxsz (op_decode_hdr_maxsz)
273 #define encode_getacl_maxsz (encode_getattr_maxsz)
274 #define decode_getacl_maxsz (op_decode_hdr_maxsz + \
275 nfs4_fattr_bitmap_maxsz + 1)
276 #define encode_setacl_maxsz (op_encode_hdr_maxsz + \
277 encode_stateid_maxsz + 3)
278 #define decode_setacl_maxsz (decode_setattr_maxsz)
279 #define encode_fs_locations_maxsz \
280 (encode_getattr_maxsz)
281 #define decode_fs_locations_maxsz \
283 #define encode_secinfo_maxsz (op_encode_hdr_maxsz + nfs4_name_maxsz)
284 #define decode_secinfo_maxsz (op_decode_hdr_maxsz + 1 + ((NFS_MAX_SECFLAVORS * (16 + GSS_OID_MAX_LEN)) / 4))
286 #if defined(CONFIG_NFS_V4_1)
287 #define NFS4_MAX_MACHINE_NAME_LEN (64)
288 #define IMPL_NAME_LIMIT (sizeof(utsname()->sysname) + sizeof(utsname()->release) + \
289 sizeof(utsname()->version) + sizeof(utsname()->machine) + 8)
291 #define encode_exchange_id_maxsz (op_encode_hdr_maxsz + \
292 encode_verifier_maxsz + \
293 1 /* co_ownerid.len */ + \
294 XDR_QUADLEN(NFS4_EXCHANGE_ID_LEN) + \
297 /* max is SP4_MACH_CRED (for now) */ + \
298 1 + NFS4_OP_MAP_NUM_WORDS + \
299 1 + NFS4_OP_MAP_NUM_WORDS + \
300 1 /* implementation id array of size 1 */ + \
301 1 /* nii_domain */ + \
302 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + \
304 XDR_QUADLEN(IMPL_NAME_LIMIT) + \
306 #define decode_exchange_id_maxsz (op_decode_hdr_maxsz + \
307 2 /* eir_clientid */ + \
308 1 /* eir_sequenceid */ + \
309 1 /* eir_flags */ + \
311 /* max is SP4_MACH_CRED (for now) */ + \
312 1 + NFS4_OP_MAP_NUM_WORDS + \
313 1 + NFS4_OP_MAP_NUM_WORDS + \
314 2 /* eir_server_owner.so_minor_id */ + \
315 /* eir_server_owner.so_major_id<> */ \
316 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 + \
317 /* eir_server_scope<> */ \
318 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 + \
319 1 /* eir_server_impl_id array length */ + \
320 1 /* nii_domain */ + \
321 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + \
323 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + \
325 #define encode_channel_attrs_maxsz (6 + 1 /* ca_rdma_ird.len (0) */)
326 #define decode_channel_attrs_maxsz (6 + \
327 1 /* ca_rdma_ird.len */ + \
329 #define encode_create_session_maxsz (op_encode_hdr_maxsz + \
330 2 /* csa_clientid */ + \
331 1 /* csa_sequence */ + \
332 1 /* csa_flags */ + \
333 encode_channel_attrs_maxsz + \
334 encode_channel_attrs_maxsz + \
335 1 /* csa_cb_program */ + \
336 1 /* csa_sec_parms.len (1) */ + \
337 1 /* cb_secflavor (AUTH_SYS) */ + \
339 1 /* machinename.len */ + \
340 XDR_QUADLEN(NFS4_MAX_MACHINE_NAME_LEN) + \
343 1 /* gids.len (0) */)
344 #define decode_create_session_maxsz (op_decode_hdr_maxsz + \
345 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
346 1 /* csr_sequence */ + \
347 1 /* csr_flags */ + \
348 decode_channel_attrs_maxsz + \
349 decode_channel_attrs_maxsz)
350 #define encode_bind_conn_to_session_maxsz (op_encode_hdr_maxsz + \
352 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
353 1 /* bctsa_dir */ + \
354 1 /* bctsa_use_conn_in_rdma_mode */)
355 #define decode_bind_conn_to_session_maxsz (op_decode_hdr_maxsz + \
357 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
358 1 /* bctsr_dir */ + \
359 1 /* bctsr_use_conn_in_rdma_mode */)
360 #define encode_destroy_session_maxsz (op_encode_hdr_maxsz + 4)
361 #define decode_destroy_session_maxsz (op_decode_hdr_maxsz)
362 #define encode_destroy_clientid_maxsz (op_encode_hdr_maxsz + 2)
363 #define decode_destroy_clientid_maxsz (op_decode_hdr_maxsz)
364 #define encode_sequence_maxsz (op_encode_hdr_maxsz + \
365 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + 4)
366 #define decode_sequence_maxsz (op_decode_hdr_maxsz + \
367 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + 5)
368 #define encode_reclaim_complete_maxsz (op_encode_hdr_maxsz + 4)
369 #define decode_reclaim_complete_maxsz (op_decode_hdr_maxsz + 4)
370 #define encode_getdevicelist_maxsz (op_encode_hdr_maxsz + 4 + \
371 encode_verifier_maxsz)
372 #define decode_getdevicelist_maxsz (op_decode_hdr_maxsz + \
373 2 /* nfs_cookie4 gdlr_cookie */ + \
374 decode_verifier_maxsz \
375 /* verifier4 gdlr_verifier */ + \
376 1 /* gdlr_deviceid_list count */ + \
377 XDR_QUADLEN(NFS4_PNFS_GETDEVLIST_MAXNUM * \
378 NFS4_DEVICEID4_SIZE) \
379 /* gdlr_deviceid_list */ + \
380 1 /* bool gdlr_eof */)
381 #define encode_getdeviceinfo_maxsz (op_encode_hdr_maxsz + 4 + \
382 XDR_QUADLEN(NFS4_DEVICEID4_SIZE))
383 #define decode_getdeviceinfo_maxsz (op_decode_hdr_maxsz + \
384 1 /* layout type */ + \
385 1 /* opaque devaddr4 length */ + \
386 /* devaddr4 payload is read into page */ \
387 1 /* notification bitmap length */ + \
388 1 /* notification bitmap */)
389 #define encode_layoutget_maxsz (op_encode_hdr_maxsz + 10 + \
390 encode_stateid_maxsz)
391 #define decode_layoutget_maxsz (op_decode_hdr_maxsz + 8 + \
392 decode_stateid_maxsz + \
393 XDR_QUADLEN(PNFS_LAYOUT_MAXSIZE))
394 #define encode_layoutcommit_maxsz (op_encode_hdr_maxsz + \
398 encode_stateid_maxsz + \
399 1 /* new offset (true) */ + \
400 2 /* last byte written */ + \
401 1 /* nt_timechanged (false) */ + \
402 1 /* layoutupdate4 layout type */ + \
403 1 /* NULL filelayout layoutupdate4 payload */)
404 #define decode_layoutcommit_maxsz (op_decode_hdr_maxsz + 3)
405 #define encode_layoutreturn_maxsz (8 + op_encode_hdr_maxsz + \
406 encode_stateid_maxsz + \
407 1 /* FIXME: opaque lrf_body always empty at the moment */)
408 #define decode_layoutreturn_maxsz (op_decode_hdr_maxsz + \
409 1 + decode_stateid_maxsz)
410 #define encode_secinfo_no_name_maxsz (op_encode_hdr_maxsz + 1)
411 #define decode_secinfo_no_name_maxsz decode_secinfo_maxsz
412 #define encode_test_stateid_maxsz (op_encode_hdr_maxsz + 2 + \
413 XDR_QUADLEN(NFS4_STATEID_SIZE))
414 #define decode_test_stateid_maxsz (op_decode_hdr_maxsz + 2 + 1)
415 #define encode_free_stateid_maxsz (op_encode_hdr_maxsz + 1 + \
416 XDR_QUADLEN(NFS4_STATEID_SIZE))
417 #define decode_free_stateid_maxsz (op_decode_hdr_maxsz)
418 #else /* CONFIG_NFS_V4_1 */
419 #define encode_sequence_maxsz 0
420 #define decode_sequence_maxsz 0
421 #endif /* CONFIG_NFS_V4_1 */
423 #define NFS4_enc_compound_sz (1024) /* XXX: large enough? */
424 #define NFS4_dec_compound_sz (1024) /* XXX: large enough? */
425 #define NFS4_enc_read_sz (compound_encode_hdr_maxsz + \
426 encode_sequence_maxsz + \
427 encode_putfh_maxsz + \
429 #define NFS4_dec_read_sz (compound_decode_hdr_maxsz + \
430 decode_sequence_maxsz + \
431 decode_putfh_maxsz + \
433 #define NFS4_enc_readlink_sz (compound_encode_hdr_maxsz + \
434 encode_sequence_maxsz + \
435 encode_putfh_maxsz + \
436 encode_readlink_maxsz)
437 #define NFS4_dec_readlink_sz (compound_decode_hdr_maxsz + \
438 decode_sequence_maxsz + \
439 decode_putfh_maxsz + \
440 decode_readlink_maxsz)
441 #define NFS4_enc_readdir_sz (compound_encode_hdr_maxsz + \
442 encode_sequence_maxsz + \
443 encode_putfh_maxsz + \
444 encode_readdir_maxsz)
445 #define NFS4_dec_readdir_sz (compound_decode_hdr_maxsz + \
446 decode_sequence_maxsz + \
447 decode_putfh_maxsz + \
448 decode_readdir_maxsz)
449 #define NFS4_enc_write_sz (compound_encode_hdr_maxsz + \
450 encode_sequence_maxsz + \
451 encode_putfh_maxsz + \
452 encode_write_maxsz + \
453 encode_getattr_maxsz)
454 #define NFS4_dec_write_sz (compound_decode_hdr_maxsz + \
455 decode_sequence_maxsz + \
456 decode_putfh_maxsz + \
457 decode_write_maxsz + \
458 decode_getattr_maxsz)
459 #define NFS4_enc_commit_sz (compound_encode_hdr_maxsz + \
460 encode_sequence_maxsz + \
461 encode_putfh_maxsz + \
463 #define NFS4_dec_commit_sz (compound_decode_hdr_maxsz + \
464 decode_sequence_maxsz + \
465 decode_putfh_maxsz + \
467 #define NFS4_enc_open_sz (compound_encode_hdr_maxsz + \
468 encode_sequence_maxsz + \
469 encode_putfh_maxsz + \
470 encode_open_maxsz + \
471 encode_access_maxsz + \
472 encode_getfh_maxsz + \
473 encode_getattr_maxsz)
474 #define NFS4_dec_open_sz (compound_decode_hdr_maxsz + \
475 decode_sequence_maxsz + \
476 decode_putfh_maxsz + \
477 decode_open_maxsz + \
478 decode_access_maxsz + \
479 decode_getfh_maxsz + \
480 decode_getattr_maxsz)
481 #define NFS4_enc_open_confirm_sz \
482 (compound_encode_hdr_maxsz + \
483 encode_putfh_maxsz + \
484 encode_open_confirm_maxsz)
485 #define NFS4_dec_open_confirm_sz \
486 (compound_decode_hdr_maxsz + \
487 decode_putfh_maxsz + \
488 decode_open_confirm_maxsz)
489 #define NFS4_enc_open_noattr_sz (compound_encode_hdr_maxsz + \
490 encode_sequence_maxsz + \
491 encode_putfh_maxsz + \
492 encode_open_maxsz + \
493 encode_access_maxsz + \
494 encode_getattr_maxsz)
495 #define NFS4_dec_open_noattr_sz (compound_decode_hdr_maxsz + \
496 decode_sequence_maxsz + \
497 decode_putfh_maxsz + \
498 decode_open_maxsz + \
499 decode_access_maxsz + \
500 decode_getattr_maxsz)
501 #define NFS4_enc_open_downgrade_sz \
502 (compound_encode_hdr_maxsz + \
503 encode_sequence_maxsz + \
504 encode_putfh_maxsz + \
505 encode_open_downgrade_maxsz + \
506 encode_getattr_maxsz)
507 #define NFS4_dec_open_downgrade_sz \
508 (compound_decode_hdr_maxsz + \
509 decode_sequence_maxsz + \
510 decode_putfh_maxsz + \
511 decode_open_downgrade_maxsz + \
512 decode_getattr_maxsz)
513 #define NFS4_enc_close_sz (compound_encode_hdr_maxsz + \
514 encode_sequence_maxsz + \
515 encode_putfh_maxsz + \
516 encode_close_maxsz + \
517 encode_getattr_maxsz)
518 #define NFS4_dec_close_sz (compound_decode_hdr_maxsz + \
519 decode_sequence_maxsz + \
520 decode_putfh_maxsz + \
521 decode_close_maxsz + \
522 decode_getattr_maxsz)
523 #define NFS4_enc_setattr_sz (compound_encode_hdr_maxsz + \
524 encode_sequence_maxsz + \
525 encode_putfh_maxsz + \
526 encode_setattr_maxsz + \
527 encode_getattr_maxsz)
528 #define NFS4_dec_setattr_sz (compound_decode_hdr_maxsz + \
529 decode_sequence_maxsz + \
530 decode_putfh_maxsz + \
531 decode_setattr_maxsz + \
532 decode_getattr_maxsz)
533 #define NFS4_enc_fsinfo_sz (compound_encode_hdr_maxsz + \
534 encode_sequence_maxsz + \
535 encode_putfh_maxsz + \
537 #define NFS4_dec_fsinfo_sz (compound_decode_hdr_maxsz + \
538 decode_sequence_maxsz + \
539 decode_putfh_maxsz + \
541 #define NFS4_enc_renew_sz (compound_encode_hdr_maxsz + \
543 #define NFS4_dec_renew_sz (compound_decode_hdr_maxsz + \
545 #define NFS4_enc_setclientid_sz (compound_encode_hdr_maxsz + \
546 encode_setclientid_maxsz)
547 #define NFS4_dec_setclientid_sz (compound_decode_hdr_maxsz + \
548 decode_setclientid_maxsz)
549 #define NFS4_enc_setclientid_confirm_sz \
550 (compound_encode_hdr_maxsz + \
551 encode_setclientid_confirm_maxsz)
552 #define NFS4_dec_setclientid_confirm_sz \
553 (compound_decode_hdr_maxsz + \
554 decode_setclientid_confirm_maxsz)
555 #define NFS4_enc_lock_sz (compound_encode_hdr_maxsz + \
556 encode_sequence_maxsz + \
557 encode_putfh_maxsz + \
559 #define NFS4_dec_lock_sz (compound_decode_hdr_maxsz + \
560 decode_sequence_maxsz + \
561 decode_putfh_maxsz + \
563 #define NFS4_enc_lockt_sz (compound_encode_hdr_maxsz + \
564 encode_sequence_maxsz + \
565 encode_putfh_maxsz + \
567 #define NFS4_dec_lockt_sz (compound_decode_hdr_maxsz + \
568 decode_sequence_maxsz + \
569 decode_putfh_maxsz + \
571 #define NFS4_enc_locku_sz (compound_encode_hdr_maxsz + \
572 encode_sequence_maxsz + \
573 encode_putfh_maxsz + \
575 #define NFS4_dec_locku_sz (compound_decode_hdr_maxsz + \
576 decode_sequence_maxsz + \
577 decode_putfh_maxsz + \
579 #define NFS4_enc_release_lockowner_sz \
580 (compound_encode_hdr_maxsz + \
581 encode_lockowner_maxsz)
582 #define NFS4_dec_release_lockowner_sz \
583 (compound_decode_hdr_maxsz + \
584 decode_lockowner_maxsz)
585 #define NFS4_enc_access_sz (compound_encode_hdr_maxsz + \
586 encode_sequence_maxsz + \
587 encode_putfh_maxsz + \
588 encode_access_maxsz + \
589 encode_getattr_maxsz)
590 #define NFS4_dec_access_sz (compound_decode_hdr_maxsz + \
591 decode_sequence_maxsz + \
592 decode_putfh_maxsz + \
593 decode_access_maxsz + \
594 decode_getattr_maxsz)
595 #define NFS4_enc_getattr_sz (compound_encode_hdr_maxsz + \
596 encode_sequence_maxsz + \
597 encode_putfh_maxsz + \
598 encode_getattr_maxsz)
599 #define NFS4_dec_getattr_sz (compound_decode_hdr_maxsz + \
600 decode_sequence_maxsz + \
601 decode_putfh_maxsz + \
602 decode_getattr_maxsz)
603 #define NFS4_enc_lookup_sz (compound_encode_hdr_maxsz + \
604 encode_sequence_maxsz + \
605 encode_putfh_maxsz + \
606 encode_lookup_maxsz + \
607 encode_getattr_maxsz + \
609 #define NFS4_dec_lookup_sz (compound_decode_hdr_maxsz + \
610 decode_sequence_maxsz + \
611 decode_putfh_maxsz + \
612 decode_lookup_maxsz + \
613 decode_getattr_maxsz + \
615 #define NFS4_enc_lookup_root_sz (compound_encode_hdr_maxsz + \
616 encode_sequence_maxsz + \
617 encode_putrootfh_maxsz + \
618 encode_getattr_maxsz + \
620 #define NFS4_dec_lookup_root_sz (compound_decode_hdr_maxsz + \
621 decode_sequence_maxsz + \
622 decode_putrootfh_maxsz + \
623 decode_getattr_maxsz + \
625 #define NFS4_enc_remove_sz (compound_encode_hdr_maxsz + \
626 encode_sequence_maxsz + \
627 encode_putfh_maxsz + \
629 #define NFS4_dec_remove_sz (compound_decode_hdr_maxsz + \
630 decode_sequence_maxsz + \
631 decode_putfh_maxsz + \
633 #define NFS4_enc_rename_sz (compound_encode_hdr_maxsz + \
634 encode_sequence_maxsz + \
635 encode_putfh_maxsz + \
636 encode_savefh_maxsz + \
637 encode_putfh_maxsz + \
639 #define NFS4_dec_rename_sz (compound_decode_hdr_maxsz + \
640 decode_sequence_maxsz + \
641 decode_putfh_maxsz + \
642 decode_savefh_maxsz + \
643 decode_putfh_maxsz + \
645 #define NFS4_enc_link_sz (compound_encode_hdr_maxsz + \
646 encode_sequence_maxsz + \
647 encode_putfh_maxsz + \
648 encode_savefh_maxsz + \
649 encode_putfh_maxsz + \
650 encode_link_maxsz + \
651 encode_restorefh_maxsz + \
652 encode_getattr_maxsz)
653 #define NFS4_dec_link_sz (compound_decode_hdr_maxsz + \
654 decode_sequence_maxsz + \
655 decode_putfh_maxsz + \
656 decode_savefh_maxsz + \
657 decode_putfh_maxsz + \
658 decode_link_maxsz + \
659 decode_restorefh_maxsz + \
660 decode_getattr_maxsz)
661 #define NFS4_enc_symlink_sz (compound_encode_hdr_maxsz + \
662 encode_sequence_maxsz + \
663 encode_putfh_maxsz + \
664 encode_symlink_maxsz + \
665 encode_getattr_maxsz + \
667 #define NFS4_dec_symlink_sz (compound_decode_hdr_maxsz + \
668 decode_sequence_maxsz + \
669 decode_putfh_maxsz + \
670 decode_symlink_maxsz + \
671 decode_getattr_maxsz + \
673 #define NFS4_enc_create_sz (compound_encode_hdr_maxsz + \
674 encode_sequence_maxsz + \
675 encode_putfh_maxsz + \
676 encode_create_maxsz + \
677 encode_getfh_maxsz + \
678 encode_getattr_maxsz)
679 #define NFS4_dec_create_sz (compound_decode_hdr_maxsz + \
680 decode_sequence_maxsz + \
681 decode_putfh_maxsz + \
682 decode_create_maxsz + \
683 decode_getfh_maxsz + \
684 decode_getattr_maxsz)
685 #define NFS4_enc_pathconf_sz (compound_encode_hdr_maxsz + \
686 encode_sequence_maxsz + \
687 encode_putfh_maxsz + \
688 encode_getattr_maxsz)
689 #define NFS4_dec_pathconf_sz (compound_decode_hdr_maxsz + \
690 decode_sequence_maxsz + \
691 decode_putfh_maxsz + \
692 decode_getattr_maxsz)
693 #define NFS4_enc_statfs_sz (compound_encode_hdr_maxsz + \
694 encode_sequence_maxsz + \
695 encode_putfh_maxsz + \
697 #define NFS4_dec_statfs_sz (compound_decode_hdr_maxsz + \
698 decode_sequence_maxsz + \
699 decode_putfh_maxsz + \
701 #define NFS4_enc_server_caps_sz (compound_encode_hdr_maxsz + \
702 encode_sequence_maxsz + \
703 encode_putfh_maxsz + \
704 encode_getattr_maxsz)
705 #define NFS4_dec_server_caps_sz (compound_decode_hdr_maxsz + \
706 decode_sequence_maxsz + \
707 decode_putfh_maxsz + \
708 decode_getattr_maxsz)
709 #define NFS4_enc_delegreturn_sz (compound_encode_hdr_maxsz + \
710 encode_sequence_maxsz + \
711 encode_putfh_maxsz + \
712 encode_delegreturn_maxsz + \
713 encode_getattr_maxsz)
714 #define NFS4_dec_delegreturn_sz (compound_decode_hdr_maxsz + \
715 decode_sequence_maxsz + \
716 decode_delegreturn_maxsz + \
717 decode_getattr_maxsz)
718 #define NFS4_enc_getacl_sz (compound_encode_hdr_maxsz + \
719 encode_sequence_maxsz + \
720 encode_putfh_maxsz + \
722 #define NFS4_dec_getacl_sz (compound_decode_hdr_maxsz + \
723 decode_sequence_maxsz + \
724 decode_putfh_maxsz + \
726 #define NFS4_enc_setacl_sz (compound_encode_hdr_maxsz + \
727 encode_sequence_maxsz + \
728 encode_putfh_maxsz + \
730 #define NFS4_dec_setacl_sz (compound_decode_hdr_maxsz + \
731 decode_sequence_maxsz + \
732 decode_putfh_maxsz + \
734 #define NFS4_enc_fs_locations_sz \
735 (compound_encode_hdr_maxsz + \
736 encode_sequence_maxsz + \
737 encode_putfh_maxsz + \
738 encode_lookup_maxsz + \
739 encode_fs_locations_maxsz)
740 #define NFS4_dec_fs_locations_sz \
741 (compound_decode_hdr_maxsz + \
742 decode_sequence_maxsz + \
743 decode_putfh_maxsz + \
744 decode_lookup_maxsz + \
745 decode_fs_locations_maxsz)
746 #define NFS4_enc_secinfo_sz (compound_encode_hdr_maxsz + \
747 encode_sequence_maxsz + \
748 encode_putfh_maxsz + \
749 encode_secinfo_maxsz)
750 #define NFS4_dec_secinfo_sz (compound_decode_hdr_maxsz + \
751 decode_sequence_maxsz + \
752 decode_putfh_maxsz + \
753 decode_secinfo_maxsz)
754 #if defined(CONFIG_NFS_V4_1)
755 #define NFS4_enc_bind_conn_to_session_sz \
756 (compound_encode_hdr_maxsz + \
757 encode_bind_conn_to_session_maxsz)
758 #define NFS4_dec_bind_conn_to_session_sz \
759 (compound_decode_hdr_maxsz + \
760 decode_bind_conn_to_session_maxsz)
761 #define NFS4_enc_exchange_id_sz \
762 (compound_encode_hdr_maxsz + \
763 encode_exchange_id_maxsz)
764 #define NFS4_dec_exchange_id_sz \
765 (compound_decode_hdr_maxsz + \
766 decode_exchange_id_maxsz)
767 #define NFS4_enc_create_session_sz \
768 (compound_encode_hdr_maxsz + \
769 encode_create_session_maxsz)
770 #define NFS4_dec_create_session_sz \
771 (compound_decode_hdr_maxsz + \
772 decode_create_session_maxsz)
773 #define NFS4_enc_destroy_session_sz (compound_encode_hdr_maxsz + \
774 encode_destroy_session_maxsz)
775 #define NFS4_dec_destroy_session_sz (compound_decode_hdr_maxsz + \
776 decode_destroy_session_maxsz)
777 #define NFS4_enc_destroy_clientid_sz (compound_encode_hdr_maxsz + \
778 encode_destroy_clientid_maxsz)
779 #define NFS4_dec_destroy_clientid_sz (compound_decode_hdr_maxsz + \
780 decode_destroy_clientid_maxsz)
781 #define NFS4_enc_sequence_sz \
782 (compound_decode_hdr_maxsz + \
783 encode_sequence_maxsz)
784 #define NFS4_dec_sequence_sz \
785 (compound_decode_hdr_maxsz + \
786 decode_sequence_maxsz)
787 #define NFS4_enc_get_lease_time_sz (compound_encode_hdr_maxsz + \
788 encode_sequence_maxsz + \
789 encode_putrootfh_maxsz + \
791 #define NFS4_dec_get_lease_time_sz (compound_decode_hdr_maxsz + \
792 decode_sequence_maxsz + \
793 decode_putrootfh_maxsz + \
795 #define NFS4_enc_reclaim_complete_sz (compound_encode_hdr_maxsz + \
796 encode_sequence_maxsz + \
797 encode_reclaim_complete_maxsz)
798 #define NFS4_dec_reclaim_complete_sz (compound_decode_hdr_maxsz + \
799 decode_sequence_maxsz + \
800 decode_reclaim_complete_maxsz)
801 #define NFS4_enc_getdevicelist_sz (compound_encode_hdr_maxsz + \
802 encode_sequence_maxsz + \
803 encode_putfh_maxsz + \
804 encode_getdevicelist_maxsz)
805 #define NFS4_dec_getdevicelist_sz (compound_decode_hdr_maxsz + \
806 decode_sequence_maxsz + \
807 decode_putfh_maxsz + \
808 decode_getdevicelist_maxsz)
809 #define NFS4_enc_getdeviceinfo_sz (compound_encode_hdr_maxsz + \
810 encode_sequence_maxsz +\
811 encode_getdeviceinfo_maxsz)
812 #define NFS4_dec_getdeviceinfo_sz (compound_decode_hdr_maxsz + \
813 decode_sequence_maxsz + \
814 decode_getdeviceinfo_maxsz)
815 #define NFS4_enc_layoutget_sz (compound_encode_hdr_maxsz + \
816 encode_sequence_maxsz + \
817 encode_putfh_maxsz + \
818 encode_layoutget_maxsz)
819 #define NFS4_dec_layoutget_sz (compound_decode_hdr_maxsz + \
820 decode_sequence_maxsz + \
821 decode_putfh_maxsz + \
822 decode_layoutget_maxsz)
823 #define NFS4_enc_layoutcommit_sz (compound_encode_hdr_maxsz + \
824 encode_sequence_maxsz +\
825 encode_putfh_maxsz + \
826 encode_layoutcommit_maxsz + \
827 encode_getattr_maxsz)
828 #define NFS4_dec_layoutcommit_sz (compound_decode_hdr_maxsz + \
829 decode_sequence_maxsz + \
830 decode_putfh_maxsz + \
831 decode_layoutcommit_maxsz + \
832 decode_getattr_maxsz)
833 #define NFS4_enc_layoutreturn_sz (compound_encode_hdr_maxsz + \
834 encode_sequence_maxsz + \
835 encode_putfh_maxsz + \
836 encode_layoutreturn_maxsz)
837 #define NFS4_dec_layoutreturn_sz (compound_decode_hdr_maxsz + \
838 decode_sequence_maxsz + \
839 decode_putfh_maxsz + \
840 decode_layoutreturn_maxsz)
841 #define NFS4_enc_secinfo_no_name_sz (compound_encode_hdr_maxsz + \
842 encode_sequence_maxsz + \
843 encode_putrootfh_maxsz +\
844 encode_secinfo_no_name_maxsz)
845 #define NFS4_dec_secinfo_no_name_sz (compound_decode_hdr_maxsz + \
846 decode_sequence_maxsz + \
847 decode_putrootfh_maxsz + \
848 decode_secinfo_no_name_maxsz)
849 #define NFS4_enc_test_stateid_sz (compound_encode_hdr_maxsz + \
850 encode_sequence_maxsz + \
851 encode_test_stateid_maxsz)
852 #define NFS4_dec_test_stateid_sz (compound_decode_hdr_maxsz + \
853 decode_sequence_maxsz + \
854 decode_test_stateid_maxsz)
855 #define NFS4_enc_free_stateid_sz (compound_encode_hdr_maxsz + \
856 encode_sequence_maxsz + \
857 encode_free_stateid_maxsz)
858 #define NFS4_dec_free_stateid_sz (compound_decode_hdr_maxsz + \
859 decode_sequence_maxsz + \
860 decode_free_stateid_maxsz)
862 const u32 nfs41_maxwrite_overhead
= ((RPC_MAX_HEADER_WITH_AUTH
+
863 compound_encode_hdr_maxsz
+
864 encode_sequence_maxsz
+
866 encode_getattr_maxsz
) *
869 const u32 nfs41_maxread_overhead
= ((RPC_MAX_HEADER_WITH_AUTH
+
870 compound_decode_hdr_maxsz
+
871 decode_sequence_maxsz
+
872 decode_putfh_maxsz
) *
875 const u32 nfs41_maxgetdevinfo_overhead
= ((RPC_MAX_REPHEADER_WITH_AUTH
+
876 compound_decode_hdr_maxsz
+
877 decode_sequence_maxsz
) *
879 EXPORT_SYMBOL_GPL(nfs41_maxgetdevinfo_overhead
);
880 #endif /* CONFIG_NFS_V4_1 */
882 static const umode_t nfs_type2fmt
[] = {
889 [NF4SOCK
] = S_IFSOCK
,
895 struct compound_hdr
{
901 uint32_t replen
; /* expected reply words */
905 static __be32
*reserve_space(struct xdr_stream
*xdr
, size_t nbytes
)
907 __be32
*p
= xdr_reserve_space(xdr
, nbytes
);
912 static void encode_opaque_fixed(struct xdr_stream
*xdr
, const void *buf
, size_t len
)
916 p
= xdr_reserve_space(xdr
, len
);
917 xdr_encode_opaque_fixed(p
, buf
, len
);
920 static void encode_string(struct xdr_stream
*xdr
, unsigned int len
, const char *str
)
924 p
= reserve_space(xdr
, 4 + len
);
925 xdr_encode_opaque(p
, str
, len
);
928 static void encode_uint32(struct xdr_stream
*xdr
, u32 n
)
932 p
= reserve_space(xdr
, 4);
936 static void encode_uint64(struct xdr_stream
*xdr
, u64 n
)
940 p
= reserve_space(xdr
, 8);
941 xdr_encode_hyper(p
, n
);
944 static void encode_nfs4_seqid(struct xdr_stream
*xdr
,
945 const struct nfs_seqid
*seqid
)
947 encode_uint32(xdr
, seqid
->sequence
->counter
);
950 static void encode_compound_hdr(struct xdr_stream
*xdr
,
951 struct rpc_rqst
*req
,
952 struct compound_hdr
*hdr
)
955 struct rpc_auth
*auth
= req
->rq_cred
->cr_auth
;
957 /* initialize running count of expected bytes in reply.
958 * NOTE: the replied tag SHOULD be the same is the one sent,
959 * but this is not required as a MUST for the server to do so. */
960 hdr
->replen
= RPC_REPHDRSIZE
+ auth
->au_rslack
+ 3 + hdr
->taglen
;
962 WARN_ON_ONCE(hdr
->taglen
> NFS4_MAXTAGLEN
);
963 encode_string(xdr
, hdr
->taglen
, hdr
->tag
);
964 p
= reserve_space(xdr
, 8);
965 *p
++ = cpu_to_be32(hdr
->minorversion
);
967 *p
= cpu_to_be32(hdr
->nops
);
970 static void encode_op_hdr(struct xdr_stream
*xdr
, enum nfs_opnum4 op
,
972 struct compound_hdr
*hdr
)
974 encode_uint32(xdr
, op
);
976 hdr
->replen
+= replen
;
979 static void encode_nops(struct compound_hdr
*hdr
)
981 WARN_ON_ONCE(hdr
->nops
> NFS4_MAX_OPS
);
982 *hdr
->nops_p
= htonl(hdr
->nops
);
985 static void encode_nfs4_stateid(struct xdr_stream
*xdr
, const nfs4_stateid
*stateid
)
987 encode_opaque_fixed(xdr
, stateid
, NFS4_STATEID_SIZE
);
990 static void encode_nfs4_verifier(struct xdr_stream
*xdr
, const nfs4_verifier
*verf
)
992 encode_opaque_fixed(xdr
, verf
->data
, NFS4_VERIFIER_SIZE
);
995 static void encode_attrs(struct xdr_stream
*xdr
, const struct iattr
*iap
,
996 const struct nfs4_label
*label
,
997 const struct nfs_server
*server
)
999 char owner_name
[IDMAP_NAMESZ
];
1000 char owner_group
[IDMAP_NAMESZ
];
1001 int owner_namelen
= 0;
1002 int owner_grouplen
= 0;
1007 uint32_t bmval
[3] = { 0 };
1010 * We reserve enough space to write the entire attribute buffer at once.
1011 * In the worst-case, this would be
1012 * 16(bitmap) + 4(attrlen) + 8(size) + 4(mode) + 4(atime) + 4(mtime)
1013 * = 40 bytes, plus any contribution from variable-length fields
1014 * such as owner/group.
1016 if (iap
->ia_valid
& ATTR_SIZE
) {
1017 bmval
[0] |= FATTR4_WORD0_SIZE
;
1020 if (iap
->ia_valid
& ATTR_MODE
) {
1021 bmval
[1] |= FATTR4_WORD1_MODE
;
1024 if (iap
->ia_valid
& ATTR_UID
) {
1025 owner_namelen
= nfs_map_uid_to_name(server
, iap
->ia_uid
, owner_name
, IDMAP_NAMESZ
);
1026 if (owner_namelen
< 0) {
1027 dprintk("nfs: couldn't resolve uid %d to string\n",
1028 from_kuid(&init_user_ns
, iap
->ia_uid
));
1030 strcpy(owner_name
, "nobody");
1031 owner_namelen
= sizeof("nobody") - 1;
1034 bmval
[1] |= FATTR4_WORD1_OWNER
;
1035 len
+= 4 + (XDR_QUADLEN(owner_namelen
) << 2);
1037 if (iap
->ia_valid
& ATTR_GID
) {
1038 owner_grouplen
= nfs_map_gid_to_group(server
, iap
->ia_gid
, owner_group
, IDMAP_NAMESZ
);
1039 if (owner_grouplen
< 0) {
1040 dprintk("nfs: couldn't resolve gid %d to string\n",
1041 from_kgid(&init_user_ns
, iap
->ia_gid
));
1042 strcpy(owner_group
, "nobody");
1043 owner_grouplen
= sizeof("nobody") - 1;
1046 bmval
[1] |= FATTR4_WORD1_OWNER_GROUP
;
1047 len
+= 4 + (XDR_QUADLEN(owner_grouplen
) << 2);
1049 if (iap
->ia_valid
& ATTR_ATIME_SET
) {
1050 bmval
[1] |= FATTR4_WORD1_TIME_ACCESS_SET
;
1052 } else if (iap
->ia_valid
& ATTR_ATIME
) {
1053 bmval
[1] |= FATTR4_WORD1_TIME_ACCESS_SET
;
1056 if (iap
->ia_valid
& ATTR_MTIME_SET
) {
1057 bmval
[1] |= FATTR4_WORD1_TIME_MODIFY_SET
;
1059 } else if (iap
->ia_valid
& ATTR_MTIME
) {
1060 bmval
[1] |= FATTR4_WORD1_TIME_MODIFY_SET
;
1064 len
+= 4 + 4 + 4 + (XDR_QUADLEN(label
->len
) << 2);
1065 bmval
[2] |= FATTR4_WORD2_SECURITY_LABEL
;
1070 else if (bmval
[1] != 0)
1075 p
= reserve_space(xdr
, 4 + (bmval_len
<< 2) + 4 + len
);
1077 *p
++ = cpu_to_be32(bmval_len
);
1078 for (i
= 0; i
< bmval_len
; i
++)
1079 *p
++ = cpu_to_be32(bmval
[i
]);
1080 *p
++ = cpu_to_be32(len
);
1082 if (bmval
[0] & FATTR4_WORD0_SIZE
)
1083 p
= xdr_encode_hyper(p
, iap
->ia_size
);
1084 if (bmval
[1] & FATTR4_WORD1_MODE
)
1085 *p
++ = cpu_to_be32(iap
->ia_mode
& S_IALLUGO
);
1086 if (bmval
[1] & FATTR4_WORD1_OWNER
)
1087 p
= xdr_encode_opaque(p
, owner_name
, owner_namelen
);
1088 if (bmval
[1] & FATTR4_WORD1_OWNER_GROUP
)
1089 p
= xdr_encode_opaque(p
, owner_group
, owner_grouplen
);
1090 if (bmval
[1] & FATTR4_WORD1_TIME_ACCESS_SET
) {
1091 if (iap
->ia_valid
& ATTR_ATIME_SET
) {
1092 *p
++ = cpu_to_be32(NFS4_SET_TO_CLIENT_TIME
);
1093 p
= xdr_encode_hyper(p
, (s64
)iap
->ia_atime
.tv_sec
);
1094 *p
++ = cpu_to_be32(iap
->ia_atime
.tv_nsec
);
1096 *p
++ = cpu_to_be32(NFS4_SET_TO_SERVER_TIME
);
1098 if (bmval
[1] & FATTR4_WORD1_TIME_MODIFY_SET
) {
1099 if (iap
->ia_valid
& ATTR_MTIME_SET
) {
1100 *p
++ = cpu_to_be32(NFS4_SET_TO_CLIENT_TIME
);
1101 p
= xdr_encode_hyper(p
, (s64
)iap
->ia_mtime
.tv_sec
);
1102 *p
++ = cpu_to_be32(iap
->ia_mtime
.tv_nsec
);
1104 *p
++ = cpu_to_be32(NFS4_SET_TO_SERVER_TIME
);
1106 if (bmval
[2] & FATTR4_WORD2_SECURITY_LABEL
) {
1107 *p
++ = cpu_to_be32(label
->lfs
);
1108 *p
++ = cpu_to_be32(label
->pi
);
1109 *p
++ = cpu_to_be32(label
->len
);
1110 p
= xdr_encode_opaque_fixed(p
, label
->label
, label
->len
);
1116 static void encode_access(struct xdr_stream
*xdr
, u32 access
, struct compound_hdr
*hdr
)
1118 encode_op_hdr(xdr
, OP_ACCESS
, decode_access_maxsz
, hdr
);
1119 encode_uint32(xdr
, access
);
1122 static void encode_close(struct xdr_stream
*xdr
, const struct nfs_closeargs
*arg
, struct compound_hdr
*hdr
)
1124 encode_op_hdr(xdr
, OP_CLOSE
, decode_close_maxsz
, hdr
);
1125 encode_nfs4_seqid(xdr
, arg
->seqid
);
1126 encode_nfs4_stateid(xdr
, arg
->stateid
);
1129 static void encode_commit(struct xdr_stream
*xdr
, const struct nfs_commitargs
*args
, struct compound_hdr
*hdr
)
1133 encode_op_hdr(xdr
, OP_COMMIT
, decode_commit_maxsz
, hdr
);
1134 p
= reserve_space(xdr
, 12);
1135 p
= xdr_encode_hyper(p
, args
->offset
);
1136 *p
= cpu_to_be32(args
->count
);
1139 static void encode_create(struct xdr_stream
*xdr
, const struct nfs4_create_arg
*create
, struct compound_hdr
*hdr
)
1143 encode_op_hdr(xdr
, OP_CREATE
, decode_create_maxsz
, hdr
);
1144 encode_uint32(xdr
, create
->ftype
);
1146 switch (create
->ftype
) {
1148 p
= reserve_space(xdr
, 4);
1149 *p
= cpu_to_be32(create
->u
.symlink
.len
);
1150 xdr_write_pages(xdr
, create
->u
.symlink
.pages
, 0, create
->u
.symlink
.len
);
1153 case NF4BLK
: case NF4CHR
:
1154 p
= reserve_space(xdr
, 8);
1155 *p
++ = cpu_to_be32(create
->u
.device
.specdata1
);
1156 *p
= cpu_to_be32(create
->u
.device
.specdata2
);
1163 encode_string(xdr
, create
->name
->len
, create
->name
->name
);
1164 encode_attrs(xdr
, create
->attrs
, create
->label
, create
->server
);
1167 static void encode_getattr_one(struct xdr_stream
*xdr
, uint32_t bitmap
, struct compound_hdr
*hdr
)
1171 encode_op_hdr(xdr
, OP_GETATTR
, decode_getattr_maxsz
, hdr
);
1172 p
= reserve_space(xdr
, 8);
1173 *p
++ = cpu_to_be32(1);
1174 *p
= cpu_to_be32(bitmap
);
1177 static void encode_getattr_two(struct xdr_stream
*xdr
, uint32_t bm0
, uint32_t bm1
, struct compound_hdr
*hdr
)
1181 encode_op_hdr(xdr
, OP_GETATTR
, decode_getattr_maxsz
, hdr
);
1182 p
= reserve_space(xdr
, 12);
1183 *p
++ = cpu_to_be32(2);
1184 *p
++ = cpu_to_be32(bm0
);
1185 *p
= cpu_to_be32(bm1
);
1189 encode_getattr_three(struct xdr_stream
*xdr
,
1190 uint32_t bm0
, uint32_t bm1
, uint32_t bm2
,
1191 struct compound_hdr
*hdr
)
1195 encode_op_hdr(xdr
, OP_GETATTR
, decode_getattr_maxsz
, hdr
);
1197 p
= reserve_space(xdr
, 16);
1198 *p
++ = cpu_to_be32(3);
1199 *p
++ = cpu_to_be32(bm0
);
1200 *p
++ = cpu_to_be32(bm1
);
1201 *p
= cpu_to_be32(bm2
);
1203 p
= reserve_space(xdr
, 12);
1204 *p
++ = cpu_to_be32(2);
1205 *p
++ = cpu_to_be32(bm0
);
1206 *p
= cpu_to_be32(bm1
);
1208 p
= reserve_space(xdr
, 8);
1209 *p
++ = cpu_to_be32(1);
1210 *p
= cpu_to_be32(bm0
);
1214 static void encode_getfattr(struct xdr_stream
*xdr
, const u32
* bitmask
, struct compound_hdr
*hdr
)
1216 encode_getattr_three(xdr
, bitmask
[0] & nfs4_fattr_bitmap
[0],
1217 bitmask
[1] & nfs4_fattr_bitmap
[1],
1218 bitmask
[2] & nfs4_fattr_bitmap
[2],
1222 static void encode_getfattr_open(struct xdr_stream
*xdr
, const u32
*bitmask
,
1223 const u32
*open_bitmap
,
1224 struct compound_hdr
*hdr
)
1226 encode_getattr_three(xdr
,
1227 bitmask
[0] & open_bitmap
[0],
1228 bitmask
[1] & open_bitmap
[1],
1229 bitmask
[2] & open_bitmap
[2],
1233 static void encode_fsinfo(struct xdr_stream
*xdr
, const u32
* bitmask
, struct compound_hdr
*hdr
)
1235 encode_getattr_three(xdr
,
1236 bitmask
[0] & nfs4_fsinfo_bitmap
[0],
1237 bitmask
[1] & nfs4_fsinfo_bitmap
[1],
1238 bitmask
[2] & nfs4_fsinfo_bitmap
[2],
1242 static void encode_fs_locations(struct xdr_stream
*xdr
, const u32
* bitmask
, struct compound_hdr
*hdr
)
1244 encode_getattr_two(xdr
, bitmask
[0] & nfs4_fs_locations_bitmap
[0],
1245 bitmask
[1] & nfs4_fs_locations_bitmap
[1], hdr
);
1248 static void encode_getfh(struct xdr_stream
*xdr
, struct compound_hdr
*hdr
)
1250 encode_op_hdr(xdr
, OP_GETFH
, decode_getfh_maxsz
, hdr
);
1253 static void encode_link(struct xdr_stream
*xdr
, const struct qstr
*name
, struct compound_hdr
*hdr
)
1255 encode_op_hdr(xdr
, OP_LINK
, decode_link_maxsz
, hdr
);
1256 encode_string(xdr
, name
->len
, name
->name
);
1259 static inline int nfs4_lock_type(struct file_lock
*fl
, int block
)
1261 if (fl
->fl_type
== F_RDLCK
)
1262 return block
? NFS4_READW_LT
: NFS4_READ_LT
;
1263 return block
? NFS4_WRITEW_LT
: NFS4_WRITE_LT
;
1266 static inline uint64_t nfs4_lock_length(struct file_lock
*fl
)
1268 if (fl
->fl_end
== OFFSET_MAX
)
1269 return ~(uint64_t)0;
1270 return fl
->fl_end
- fl
->fl_start
+ 1;
1273 static void encode_lockowner(struct xdr_stream
*xdr
, const struct nfs_lowner
*lowner
)
1277 p
= reserve_space(xdr
, 32);
1278 p
= xdr_encode_hyper(p
, lowner
->clientid
);
1279 *p
++ = cpu_to_be32(20);
1280 p
= xdr_encode_opaque_fixed(p
, "lock id:", 8);
1281 *p
++ = cpu_to_be32(lowner
->s_dev
);
1282 xdr_encode_hyper(p
, lowner
->id
);
1286 * opcode,type,reclaim,offset,length,new_lock_owner = 32
1287 * open_seqid,open_stateid,lock_seqid,lock_owner.clientid, lock_owner.id = 40
1289 static void encode_lock(struct xdr_stream
*xdr
, const struct nfs_lock_args
*args
, struct compound_hdr
*hdr
)
1293 encode_op_hdr(xdr
, OP_LOCK
, decode_lock_maxsz
, hdr
);
1294 p
= reserve_space(xdr
, 28);
1295 *p
++ = cpu_to_be32(nfs4_lock_type(args
->fl
, args
->block
));
1296 *p
++ = cpu_to_be32(args
->reclaim
);
1297 p
= xdr_encode_hyper(p
, args
->fl
->fl_start
);
1298 p
= xdr_encode_hyper(p
, nfs4_lock_length(args
->fl
));
1299 *p
= cpu_to_be32(args
->new_lock_owner
);
1300 if (args
->new_lock_owner
){
1301 encode_nfs4_seqid(xdr
, args
->open_seqid
);
1302 encode_nfs4_stateid(xdr
, args
->open_stateid
);
1303 encode_nfs4_seqid(xdr
, args
->lock_seqid
);
1304 encode_lockowner(xdr
, &args
->lock_owner
);
1307 encode_nfs4_stateid(xdr
, args
->lock_stateid
);
1308 encode_nfs4_seqid(xdr
, args
->lock_seqid
);
1312 static void encode_lockt(struct xdr_stream
*xdr
, const struct nfs_lockt_args
*args
, struct compound_hdr
*hdr
)
1316 encode_op_hdr(xdr
, OP_LOCKT
, decode_lockt_maxsz
, hdr
);
1317 p
= reserve_space(xdr
, 20);
1318 *p
++ = cpu_to_be32(nfs4_lock_type(args
->fl
, 0));
1319 p
= xdr_encode_hyper(p
, args
->fl
->fl_start
);
1320 p
= xdr_encode_hyper(p
, nfs4_lock_length(args
->fl
));
1321 encode_lockowner(xdr
, &args
->lock_owner
);
1324 static void encode_locku(struct xdr_stream
*xdr
, const struct nfs_locku_args
*args
, struct compound_hdr
*hdr
)
1328 encode_op_hdr(xdr
, OP_LOCKU
, decode_locku_maxsz
, hdr
);
1329 encode_uint32(xdr
, nfs4_lock_type(args
->fl
, 0));
1330 encode_nfs4_seqid(xdr
, args
->seqid
);
1331 encode_nfs4_stateid(xdr
, args
->stateid
);
1332 p
= reserve_space(xdr
, 16);
1333 p
= xdr_encode_hyper(p
, args
->fl
->fl_start
);
1334 xdr_encode_hyper(p
, nfs4_lock_length(args
->fl
));
1337 static void encode_release_lockowner(struct xdr_stream
*xdr
, const struct nfs_lowner
*lowner
, struct compound_hdr
*hdr
)
1339 encode_op_hdr(xdr
, OP_RELEASE_LOCKOWNER
, decode_release_lockowner_maxsz
, hdr
);
1340 encode_lockowner(xdr
, lowner
);
1343 static void encode_lookup(struct xdr_stream
*xdr
, const struct qstr
*name
, struct compound_hdr
*hdr
)
1345 encode_op_hdr(xdr
, OP_LOOKUP
, decode_lookup_maxsz
, hdr
);
1346 encode_string(xdr
, name
->len
, name
->name
);
1349 static void encode_share_access(struct xdr_stream
*xdr
, fmode_t fmode
)
1353 p
= reserve_space(xdr
, 8);
1354 switch (fmode
& (FMODE_READ
|FMODE_WRITE
)) {
1356 *p
++ = cpu_to_be32(NFS4_SHARE_ACCESS_READ
);
1359 *p
++ = cpu_to_be32(NFS4_SHARE_ACCESS_WRITE
);
1361 case FMODE_READ
|FMODE_WRITE
:
1362 *p
++ = cpu_to_be32(NFS4_SHARE_ACCESS_BOTH
);
1365 *p
++ = cpu_to_be32(0);
1367 *p
= cpu_to_be32(0); /* for linux, share_deny = 0 always */
1370 static inline void encode_openhdr(struct xdr_stream
*xdr
, const struct nfs_openargs
*arg
)
1374 * opcode 4, seqid 4, share_access 4, share_deny 4, clientid 8, ownerlen 4,
1377 encode_nfs4_seqid(xdr
, arg
->seqid
);
1378 encode_share_access(xdr
, arg
->fmode
);
1379 p
= reserve_space(xdr
, 36);
1380 p
= xdr_encode_hyper(p
, arg
->clientid
);
1381 *p
++ = cpu_to_be32(24);
1382 p
= xdr_encode_opaque_fixed(p
, "open id:", 8);
1383 *p
++ = cpu_to_be32(arg
->server
->s_dev
);
1384 *p
++ = cpu_to_be32(arg
->id
.uniquifier
);
1385 xdr_encode_hyper(p
, arg
->id
.create_time
);
1388 static inline void encode_createmode(struct xdr_stream
*xdr
, const struct nfs_openargs
*arg
)
1393 p
= reserve_space(xdr
, 4);
1394 switch(arg
->createmode
) {
1395 case NFS4_CREATE_UNCHECKED
:
1396 *p
= cpu_to_be32(NFS4_CREATE_UNCHECKED
);
1397 encode_attrs(xdr
, arg
->u
.attrs
, arg
->label
, arg
->server
);
1399 case NFS4_CREATE_GUARDED
:
1400 *p
= cpu_to_be32(NFS4_CREATE_GUARDED
);
1401 encode_attrs(xdr
, arg
->u
.attrs
, arg
->label
, arg
->server
);
1403 case NFS4_CREATE_EXCLUSIVE
:
1404 *p
= cpu_to_be32(NFS4_CREATE_EXCLUSIVE
);
1405 encode_nfs4_verifier(xdr
, &arg
->u
.verifier
);
1407 case NFS4_CREATE_EXCLUSIVE4_1
:
1408 *p
= cpu_to_be32(NFS4_CREATE_EXCLUSIVE4_1
);
1409 encode_nfs4_verifier(xdr
, &arg
->u
.verifier
);
1411 encode_attrs(xdr
, &dummy
, arg
->label
, arg
->server
);
1415 static void encode_opentype(struct xdr_stream
*xdr
, const struct nfs_openargs
*arg
)
1419 p
= reserve_space(xdr
, 4);
1420 switch (arg
->open_flags
& O_CREAT
) {
1422 *p
= cpu_to_be32(NFS4_OPEN_NOCREATE
);
1425 *p
= cpu_to_be32(NFS4_OPEN_CREATE
);
1426 encode_createmode(xdr
, arg
);
1430 static inline void encode_delegation_type(struct xdr_stream
*xdr
, fmode_t delegation_type
)
1434 p
= reserve_space(xdr
, 4);
1435 switch (delegation_type
) {
1437 *p
= cpu_to_be32(NFS4_OPEN_DELEGATE_NONE
);
1440 *p
= cpu_to_be32(NFS4_OPEN_DELEGATE_READ
);
1442 case FMODE_WRITE
|FMODE_READ
:
1443 *p
= cpu_to_be32(NFS4_OPEN_DELEGATE_WRITE
);
1450 static inline void encode_claim_null(struct xdr_stream
*xdr
, const struct qstr
*name
)
1454 p
= reserve_space(xdr
, 4);
1455 *p
= cpu_to_be32(NFS4_OPEN_CLAIM_NULL
);
1456 encode_string(xdr
, name
->len
, name
->name
);
1459 static inline void encode_claim_previous(struct xdr_stream
*xdr
, fmode_t type
)
1463 p
= reserve_space(xdr
, 4);
1464 *p
= cpu_to_be32(NFS4_OPEN_CLAIM_PREVIOUS
);
1465 encode_delegation_type(xdr
, type
);
1468 static inline void encode_claim_delegate_cur(struct xdr_stream
*xdr
, const struct qstr
*name
, const nfs4_stateid
*stateid
)
1472 p
= reserve_space(xdr
, 4);
1473 *p
= cpu_to_be32(NFS4_OPEN_CLAIM_DELEGATE_CUR
);
1474 encode_nfs4_stateid(xdr
, stateid
);
1475 encode_string(xdr
, name
->len
, name
->name
);
1478 static inline void encode_claim_fh(struct xdr_stream
*xdr
)
1482 p
= reserve_space(xdr
, 4);
1483 *p
= cpu_to_be32(NFS4_OPEN_CLAIM_FH
);
1486 static inline void encode_claim_delegate_cur_fh(struct xdr_stream
*xdr
, const nfs4_stateid
*stateid
)
1490 p
= reserve_space(xdr
, 4);
1491 *p
= cpu_to_be32(NFS4_OPEN_CLAIM_DELEG_CUR_FH
);
1492 encode_nfs4_stateid(xdr
, stateid
);
1495 static void encode_open(struct xdr_stream
*xdr
, const struct nfs_openargs
*arg
, struct compound_hdr
*hdr
)
1497 encode_op_hdr(xdr
, OP_OPEN
, decode_open_maxsz
, hdr
);
1498 encode_openhdr(xdr
, arg
);
1499 encode_opentype(xdr
, arg
);
1500 switch (arg
->claim
) {
1501 case NFS4_OPEN_CLAIM_NULL
:
1502 encode_claim_null(xdr
, arg
->name
);
1504 case NFS4_OPEN_CLAIM_PREVIOUS
:
1505 encode_claim_previous(xdr
, arg
->u
.delegation_type
);
1507 case NFS4_OPEN_CLAIM_DELEGATE_CUR
:
1508 encode_claim_delegate_cur(xdr
, arg
->name
, &arg
->u
.delegation
);
1510 case NFS4_OPEN_CLAIM_FH
:
1511 encode_claim_fh(xdr
);
1513 case NFS4_OPEN_CLAIM_DELEG_CUR_FH
:
1514 encode_claim_delegate_cur_fh(xdr
, &arg
->u
.delegation
);
1521 static void encode_open_confirm(struct xdr_stream
*xdr
, const struct nfs_open_confirmargs
*arg
, struct compound_hdr
*hdr
)
1523 encode_op_hdr(xdr
, OP_OPEN_CONFIRM
, decode_open_confirm_maxsz
, hdr
);
1524 encode_nfs4_stateid(xdr
, arg
->stateid
);
1525 encode_nfs4_seqid(xdr
, arg
->seqid
);
1528 static void encode_open_downgrade(struct xdr_stream
*xdr
, const struct nfs_closeargs
*arg
, struct compound_hdr
*hdr
)
1530 encode_op_hdr(xdr
, OP_OPEN_DOWNGRADE
, decode_open_downgrade_maxsz
, hdr
);
1531 encode_nfs4_stateid(xdr
, arg
->stateid
);
1532 encode_nfs4_seqid(xdr
, arg
->seqid
);
1533 encode_share_access(xdr
, arg
->fmode
);
1537 encode_putfh(struct xdr_stream
*xdr
, const struct nfs_fh
*fh
, struct compound_hdr
*hdr
)
1539 encode_op_hdr(xdr
, OP_PUTFH
, decode_putfh_maxsz
, hdr
);
1540 encode_string(xdr
, fh
->size
, fh
->data
);
1543 static void encode_putrootfh(struct xdr_stream
*xdr
, struct compound_hdr
*hdr
)
1545 encode_op_hdr(xdr
, OP_PUTROOTFH
, decode_putrootfh_maxsz
, hdr
);
1548 static void encode_read(struct xdr_stream
*xdr
, const struct nfs_readargs
*args
, struct compound_hdr
*hdr
)
1552 encode_op_hdr(xdr
, OP_READ
, decode_read_maxsz
, hdr
);
1553 encode_nfs4_stateid(xdr
, &args
->stateid
);
1555 p
= reserve_space(xdr
, 12);
1556 p
= xdr_encode_hyper(p
, args
->offset
);
1557 *p
= cpu_to_be32(args
->count
);
1560 static void encode_readdir(struct xdr_stream
*xdr
, const struct nfs4_readdir_arg
*readdir
, struct rpc_rqst
*req
, struct compound_hdr
*hdr
)
1562 uint32_t attrs
[3] = {
1563 FATTR4_WORD0_RDATTR_ERROR
,
1564 FATTR4_WORD1_MOUNTED_ON_FILEID
,
1566 uint32_t dircount
= readdir
->count
>> 1;
1569 if (readdir
->plus
) {
1570 attrs
[0] |= FATTR4_WORD0_TYPE
|FATTR4_WORD0_CHANGE
|FATTR4_WORD0_SIZE
|
1571 FATTR4_WORD0_FSID
|FATTR4_WORD0_FILEHANDLE
|FATTR4_WORD0_FILEID
;
1572 attrs
[1] |= FATTR4_WORD1_MODE
|FATTR4_WORD1_NUMLINKS
|FATTR4_WORD1_OWNER
|
1573 FATTR4_WORD1_OWNER_GROUP
|FATTR4_WORD1_RAWDEV
|
1574 FATTR4_WORD1_SPACE_USED
|FATTR4_WORD1_TIME_ACCESS
|
1575 FATTR4_WORD1_TIME_METADATA
|FATTR4_WORD1_TIME_MODIFY
;
1578 /* Use mounted_on_fileid only if the server supports it */
1579 if (!(readdir
->bitmask
[1] & FATTR4_WORD1_MOUNTED_ON_FILEID
))
1580 attrs
[0] |= FATTR4_WORD0_FILEID
;
1582 encode_op_hdr(xdr
, OP_READDIR
, decode_readdir_maxsz
, hdr
);
1583 encode_uint64(xdr
, readdir
->cookie
);
1584 encode_nfs4_verifier(xdr
, &readdir
->verifier
);
1585 p
= reserve_space(xdr
, encode_readdir_space
);
1586 *p
++ = cpu_to_be32(dircount
);
1587 *p
++ = cpu_to_be32(readdir
->count
);
1588 *p
++ = cpu_to_be32(encode_readdir_bitmask_sz
);
1589 *p
++ = cpu_to_be32(attrs
[0] & readdir
->bitmask
[0]);
1590 *p
= cpu_to_be32(attrs
[1] & readdir
->bitmask
[1]);
1591 if (encode_readdir_bitmask_sz
> 2) {
1592 if (hdr
->minorversion
> 1)
1593 attrs
[2] |= FATTR4_WORD2_SECURITY_LABEL
;
1594 p
++, *p
++ = cpu_to_be32(attrs
[2] & readdir
->bitmask
[2]);
1596 memcpy(verf
, readdir
->verifier
.data
, sizeof(verf
));
1598 dprintk("%s: cookie = %llu, verifier = %08x:%08x, bitmap = %08x:%08x:%08x\n",
1600 (unsigned long long)readdir
->cookie
,
1602 attrs
[0] & readdir
->bitmask
[0],
1603 attrs
[1] & readdir
->bitmask
[1],
1604 attrs
[2] & readdir
->bitmask
[2]);
1607 static void encode_readlink(struct xdr_stream
*xdr
, const struct nfs4_readlink
*readlink
, struct rpc_rqst
*req
, struct compound_hdr
*hdr
)
1609 encode_op_hdr(xdr
, OP_READLINK
, decode_readlink_maxsz
, hdr
);
1612 static void encode_remove(struct xdr_stream
*xdr
, const struct qstr
*name
, struct compound_hdr
*hdr
)
1614 encode_op_hdr(xdr
, OP_REMOVE
, decode_remove_maxsz
, hdr
);
1615 encode_string(xdr
, name
->len
, name
->name
);
1618 static void encode_rename(struct xdr_stream
*xdr
, const struct qstr
*oldname
, const struct qstr
*newname
, struct compound_hdr
*hdr
)
1620 encode_op_hdr(xdr
, OP_RENAME
, decode_rename_maxsz
, hdr
);
1621 encode_string(xdr
, oldname
->len
, oldname
->name
);
1622 encode_string(xdr
, newname
->len
, newname
->name
);
1625 static void encode_renew(struct xdr_stream
*xdr
, clientid4 clid
,
1626 struct compound_hdr
*hdr
)
1628 encode_op_hdr(xdr
, OP_RENEW
, decode_renew_maxsz
, hdr
);
1629 encode_uint64(xdr
, clid
);
1633 encode_restorefh(struct xdr_stream
*xdr
, struct compound_hdr
*hdr
)
1635 encode_op_hdr(xdr
, OP_RESTOREFH
, decode_restorefh_maxsz
, hdr
);
1639 encode_setacl(struct xdr_stream
*xdr
, struct nfs_setaclargs
*arg
, struct compound_hdr
*hdr
)
1643 encode_op_hdr(xdr
, OP_SETATTR
, decode_setacl_maxsz
, hdr
);
1644 encode_nfs4_stateid(xdr
, &zero_stateid
);
1645 p
= reserve_space(xdr
, 2*4);
1646 *p
++ = cpu_to_be32(1);
1647 *p
= cpu_to_be32(FATTR4_WORD0_ACL
);
1648 p
= reserve_space(xdr
, 4);
1649 *p
= cpu_to_be32(arg
->acl_len
);
1650 xdr_write_pages(xdr
, arg
->acl_pages
, arg
->acl_pgbase
, arg
->acl_len
);
1654 encode_savefh(struct xdr_stream
*xdr
, struct compound_hdr
*hdr
)
1656 encode_op_hdr(xdr
, OP_SAVEFH
, decode_savefh_maxsz
, hdr
);
1659 static void encode_setattr(struct xdr_stream
*xdr
, const struct nfs_setattrargs
*arg
, const struct nfs_server
*server
, struct compound_hdr
*hdr
)
1661 encode_op_hdr(xdr
, OP_SETATTR
, decode_setattr_maxsz
, hdr
);
1662 encode_nfs4_stateid(xdr
, &arg
->stateid
);
1663 encode_attrs(xdr
, arg
->iap
, arg
->label
, server
);
1666 static void encode_setclientid(struct xdr_stream
*xdr
, const struct nfs4_setclientid
*setclientid
, struct compound_hdr
*hdr
)
1670 encode_op_hdr(xdr
, OP_SETCLIENTID
, decode_setclientid_maxsz
, hdr
);
1671 encode_nfs4_verifier(xdr
, setclientid
->sc_verifier
);
1673 encode_string(xdr
, setclientid
->sc_name_len
, setclientid
->sc_name
);
1674 p
= reserve_space(xdr
, 4);
1675 *p
= cpu_to_be32(setclientid
->sc_prog
);
1676 encode_string(xdr
, setclientid
->sc_netid_len
, setclientid
->sc_netid
);
1677 encode_string(xdr
, setclientid
->sc_uaddr_len
, setclientid
->sc_uaddr
);
1678 p
= reserve_space(xdr
, 4);
1679 *p
= cpu_to_be32(setclientid
->sc_cb_ident
);
1682 static void encode_setclientid_confirm(struct xdr_stream
*xdr
, const struct nfs4_setclientid_res
*arg
, struct compound_hdr
*hdr
)
1684 encode_op_hdr(xdr
, OP_SETCLIENTID_CONFIRM
,
1685 decode_setclientid_confirm_maxsz
, hdr
);
1686 encode_uint64(xdr
, arg
->clientid
);
1687 encode_nfs4_verifier(xdr
, &arg
->confirm
);
1690 static void encode_write(struct xdr_stream
*xdr
, const struct nfs_writeargs
*args
, struct compound_hdr
*hdr
)
1694 encode_op_hdr(xdr
, OP_WRITE
, decode_write_maxsz
, hdr
);
1695 encode_nfs4_stateid(xdr
, &args
->stateid
);
1697 p
= reserve_space(xdr
, 16);
1698 p
= xdr_encode_hyper(p
, args
->offset
);
1699 *p
++ = cpu_to_be32(args
->stable
);
1700 *p
= cpu_to_be32(args
->count
);
1702 xdr_write_pages(xdr
, args
->pages
, args
->pgbase
, args
->count
);
1705 static void encode_delegreturn(struct xdr_stream
*xdr
, const nfs4_stateid
*stateid
, struct compound_hdr
*hdr
)
1707 encode_op_hdr(xdr
, OP_DELEGRETURN
, decode_delegreturn_maxsz
, hdr
);
1708 encode_nfs4_stateid(xdr
, stateid
);
1711 static void encode_secinfo(struct xdr_stream
*xdr
, const struct qstr
*name
, struct compound_hdr
*hdr
)
1713 encode_op_hdr(xdr
, OP_SECINFO
, decode_secinfo_maxsz
, hdr
);
1714 encode_string(xdr
, name
->len
, name
->name
);
1717 #if defined(CONFIG_NFS_V4_1)
1718 /* NFSv4.1 operations */
1719 static void encode_bind_conn_to_session(struct xdr_stream
*xdr
,
1720 struct nfs4_session
*session
,
1721 struct compound_hdr
*hdr
)
1725 encode_op_hdr(xdr
, OP_BIND_CONN_TO_SESSION
,
1726 decode_bind_conn_to_session_maxsz
, hdr
);
1727 encode_opaque_fixed(xdr
, session
->sess_id
.data
, NFS4_MAX_SESSIONID_LEN
);
1728 p
= xdr_reserve_space(xdr
, 8);
1729 *p
++ = cpu_to_be32(NFS4_CDFC4_BACK_OR_BOTH
);
1730 *p
= 0; /* use_conn_in_rdma_mode = False */
1733 static void encode_op_map(struct xdr_stream
*xdr
, struct nfs4_op_map
*op_map
)
1736 encode_uint32(xdr
, NFS4_OP_MAP_NUM_WORDS
);
1737 for (i
= 0; i
< NFS4_OP_MAP_NUM_WORDS
; i
++)
1738 encode_uint32(xdr
, op_map
->u
.words
[i
]);
1741 static void encode_exchange_id(struct xdr_stream
*xdr
,
1742 struct nfs41_exchange_id_args
*args
,
1743 struct compound_hdr
*hdr
)
1746 char impl_name
[IMPL_NAME_LIMIT
];
1749 encode_op_hdr(xdr
, OP_EXCHANGE_ID
, decode_exchange_id_maxsz
, hdr
);
1750 encode_nfs4_verifier(xdr
, args
->verifier
);
1752 encode_string(xdr
, args
->id_len
, args
->id
);
1754 encode_uint32(xdr
, args
->flags
);
1755 encode_uint32(xdr
, args
->state_protect
.how
);
1757 switch (args
->state_protect
.how
) {
1761 encode_op_map(xdr
, &args
->state_protect
.enforce
);
1762 encode_op_map(xdr
, &args
->state_protect
.allow
);
1769 if (send_implementation_id
&&
1770 sizeof(CONFIG_NFS_V4_1_IMPLEMENTATION_ID_DOMAIN
) > 1 &&
1771 sizeof(CONFIG_NFS_V4_1_IMPLEMENTATION_ID_DOMAIN
)
1772 <= sizeof(impl_name
) + 1)
1773 len
= snprintf(impl_name
, sizeof(impl_name
), "%s %s %s %s",
1774 utsname()->sysname
, utsname()->release
,
1775 utsname()->version
, utsname()->machine
);
1778 encode_uint32(xdr
, 1); /* implementation id array length=1 */
1781 sizeof(CONFIG_NFS_V4_1_IMPLEMENTATION_ID_DOMAIN
) - 1,
1782 CONFIG_NFS_V4_1_IMPLEMENTATION_ID_DOMAIN
);
1783 encode_string(xdr
, len
, impl_name
);
1784 /* just send zeros for nii_date - the date is in nii_name */
1785 p
= reserve_space(xdr
, 12);
1786 p
= xdr_encode_hyper(p
, 0);
1787 *p
= cpu_to_be32(0);
1789 encode_uint32(xdr
, 0); /* implementation id array length=0 */
1792 static void encode_create_session(struct xdr_stream
*xdr
,
1793 struct nfs41_create_session_args
*args
,
1794 struct compound_hdr
*hdr
)
1797 char machine_name
[NFS4_MAX_MACHINE_NAME_LEN
];
1799 struct nfs_client
*clp
= args
->client
;
1800 struct nfs_net
*nn
= net_generic(clp
->cl_net
, nfs_net_id
);
1801 u32 max_resp_sz_cached
;
1804 * Assumes OPEN is the biggest non-idempotent compound.
1805 * 2 is the verifier.
1807 max_resp_sz_cached
= (NFS4_dec_open_sz
+ RPC_REPHDRSIZE
+
1808 RPC_MAX_AUTH_SIZE
+ 2) * XDR_UNIT
;
1810 len
= scnprintf(machine_name
, sizeof(machine_name
), "%s",
1813 encode_op_hdr(xdr
, OP_CREATE_SESSION
, decode_create_session_maxsz
, hdr
);
1814 p
= reserve_space(xdr
, 16 + 2*28 + 20 + len
+ 12);
1815 p
= xdr_encode_hyper(p
, clp
->cl_clientid
);
1816 *p
++ = cpu_to_be32(clp
->cl_seqid
); /*Sequence id */
1817 *p
++ = cpu_to_be32(args
->flags
); /*flags */
1820 *p
++ = cpu_to_be32(0); /* header padding size */
1821 *p
++ = cpu_to_be32(args
->fc_attrs
.max_rqst_sz
); /* max req size */
1822 *p
++ = cpu_to_be32(args
->fc_attrs
.max_resp_sz
); /* max resp size */
1823 *p
++ = cpu_to_be32(max_resp_sz_cached
); /* Max resp sz cached */
1824 *p
++ = cpu_to_be32(args
->fc_attrs
.max_ops
); /* max operations */
1825 *p
++ = cpu_to_be32(args
->fc_attrs
.max_reqs
); /* max requests */
1826 *p
++ = cpu_to_be32(0); /* rdmachannel_attrs */
1829 *p
++ = cpu_to_be32(0); /* header padding size */
1830 *p
++ = cpu_to_be32(args
->bc_attrs
.max_rqst_sz
); /* max req size */
1831 *p
++ = cpu_to_be32(args
->bc_attrs
.max_resp_sz
); /* max resp size */
1832 *p
++ = cpu_to_be32(args
->bc_attrs
.max_resp_sz_cached
); /* Max resp sz cached */
1833 *p
++ = cpu_to_be32(args
->bc_attrs
.max_ops
); /* max operations */
1834 *p
++ = cpu_to_be32(args
->bc_attrs
.max_reqs
); /* max requests */
1835 *p
++ = cpu_to_be32(0); /* rdmachannel_attrs */
1837 *p
++ = cpu_to_be32(args
->cb_program
); /* cb_program */
1838 *p
++ = cpu_to_be32(1);
1839 *p
++ = cpu_to_be32(RPC_AUTH_UNIX
); /* auth_sys */
1841 /* authsys_parms rfc1831 */
1842 *p
++ = cpu_to_be32(nn
->boot_time
.tv_nsec
); /* stamp */
1843 p
= xdr_encode_opaque(p
, machine_name
, len
);
1844 *p
++ = cpu_to_be32(0); /* UID */
1845 *p
++ = cpu_to_be32(0); /* GID */
1846 *p
= cpu_to_be32(0); /* No more gids */
1849 static void encode_destroy_session(struct xdr_stream
*xdr
,
1850 struct nfs4_session
*session
,
1851 struct compound_hdr
*hdr
)
1853 encode_op_hdr(xdr
, OP_DESTROY_SESSION
, decode_destroy_session_maxsz
, hdr
);
1854 encode_opaque_fixed(xdr
, session
->sess_id
.data
, NFS4_MAX_SESSIONID_LEN
);
1857 static void encode_destroy_clientid(struct xdr_stream
*xdr
,
1859 struct compound_hdr
*hdr
)
1861 encode_op_hdr(xdr
, OP_DESTROY_CLIENTID
, decode_destroy_clientid_maxsz
, hdr
);
1862 encode_uint64(xdr
, clientid
);
1865 static void encode_reclaim_complete(struct xdr_stream
*xdr
,
1866 struct nfs41_reclaim_complete_args
*args
,
1867 struct compound_hdr
*hdr
)
1869 encode_op_hdr(xdr
, OP_RECLAIM_COMPLETE
, decode_reclaim_complete_maxsz
, hdr
);
1870 encode_uint32(xdr
, args
->one_fs
);
1872 #endif /* CONFIG_NFS_V4_1 */
1874 static void encode_sequence(struct xdr_stream
*xdr
,
1875 const struct nfs4_sequence_args
*args
,
1876 struct compound_hdr
*hdr
)
1878 #if defined(CONFIG_NFS_V4_1)
1879 struct nfs4_session
*session
;
1880 struct nfs4_slot_table
*tp
;
1881 struct nfs4_slot
*slot
= args
->sa_slot
;
1885 session
= tp
->session
;
1889 encode_op_hdr(xdr
, OP_SEQUENCE
, decode_sequence_maxsz
, hdr
);
1892 * Sessionid + seqid + slotid + max slotid + cache_this
1894 dprintk("%s: sessionid=%u:%u:%u:%u seqid=%d slotid=%d "
1895 "max_slotid=%d cache_this=%d\n",
1897 ((u32
*)session
->sess_id
.data
)[0],
1898 ((u32
*)session
->sess_id
.data
)[1],
1899 ((u32
*)session
->sess_id
.data
)[2],
1900 ((u32
*)session
->sess_id
.data
)[3],
1901 slot
->seq_nr
, slot
->slot_nr
,
1902 tp
->highest_used_slotid
, args
->sa_cache_this
);
1903 p
= reserve_space(xdr
, NFS4_MAX_SESSIONID_LEN
+ 16);
1904 p
= xdr_encode_opaque_fixed(p
, session
->sess_id
.data
, NFS4_MAX_SESSIONID_LEN
);
1905 *p
++ = cpu_to_be32(slot
->seq_nr
);
1906 *p
++ = cpu_to_be32(slot
->slot_nr
);
1907 *p
++ = cpu_to_be32(tp
->highest_used_slotid
);
1908 *p
= cpu_to_be32(args
->sa_cache_this
);
1909 #endif /* CONFIG_NFS_V4_1 */
1912 #ifdef CONFIG_NFS_V4_1
1914 encode_getdevicelist(struct xdr_stream
*xdr
,
1915 const struct nfs4_getdevicelist_args
*args
,
1916 struct compound_hdr
*hdr
)
1919 nfs4_verifier dummy
= {
1923 encode_op_hdr(xdr
, OP_GETDEVICELIST
, decode_getdevicelist_maxsz
, hdr
);
1924 p
= reserve_space(xdr
, 16);
1925 *p
++ = cpu_to_be32(args
->layoutclass
);
1926 *p
++ = cpu_to_be32(NFS4_PNFS_GETDEVLIST_MAXNUM
);
1927 xdr_encode_hyper(p
, 0ULL); /* cookie */
1928 encode_nfs4_verifier(xdr
, &dummy
);
1932 encode_getdeviceinfo(struct xdr_stream
*xdr
,
1933 const struct nfs4_getdeviceinfo_args
*args
,
1934 struct compound_hdr
*hdr
)
1938 encode_op_hdr(xdr
, OP_GETDEVICEINFO
, decode_getdeviceinfo_maxsz
, hdr
);
1939 p
= reserve_space(xdr
, 12 + NFS4_DEVICEID4_SIZE
);
1940 p
= xdr_encode_opaque_fixed(p
, args
->pdev
->dev_id
.data
,
1941 NFS4_DEVICEID4_SIZE
);
1942 *p
++ = cpu_to_be32(args
->pdev
->layout_type
);
1943 *p
++ = cpu_to_be32(args
->pdev
->maxcount
); /* gdia_maxcount */
1944 *p
++ = cpu_to_be32(0); /* bitmap length 0 */
1948 encode_layoutget(struct xdr_stream
*xdr
,
1949 const struct nfs4_layoutget_args
*args
,
1950 struct compound_hdr
*hdr
)
1954 encode_op_hdr(xdr
, OP_LAYOUTGET
, decode_layoutget_maxsz
, hdr
);
1955 p
= reserve_space(xdr
, 36);
1956 *p
++ = cpu_to_be32(0); /* Signal layout available */
1957 *p
++ = cpu_to_be32(args
->type
);
1958 *p
++ = cpu_to_be32(args
->range
.iomode
);
1959 p
= xdr_encode_hyper(p
, args
->range
.offset
);
1960 p
= xdr_encode_hyper(p
, args
->range
.length
);
1961 p
= xdr_encode_hyper(p
, args
->minlength
);
1962 encode_nfs4_stateid(xdr
, &args
->stateid
);
1963 encode_uint32(xdr
, args
->maxcount
);
1965 dprintk("%s: 1st type:0x%x iomode:%d off:%lu len:%lu mc:%d\n",
1969 (unsigned long)args
->range
.offset
,
1970 (unsigned long)args
->range
.length
,
1975 encode_layoutcommit(struct xdr_stream
*xdr
,
1976 struct inode
*inode
,
1977 const struct nfs4_layoutcommit_args
*args
,
1978 struct compound_hdr
*hdr
)
1982 dprintk("%s: lbw: %llu type: %d\n", __func__
, args
->lastbytewritten
,
1983 NFS_SERVER(args
->inode
)->pnfs_curr_ld
->id
);
1985 encode_op_hdr(xdr
, OP_LAYOUTCOMMIT
, decode_layoutcommit_maxsz
, hdr
);
1986 p
= reserve_space(xdr
, 20);
1987 /* Only whole file layouts */
1988 p
= xdr_encode_hyper(p
, 0); /* offset */
1989 p
= xdr_encode_hyper(p
, args
->lastbytewritten
+ 1); /* length */
1990 *p
= cpu_to_be32(0); /* reclaim */
1991 encode_nfs4_stateid(xdr
, &args
->stateid
);
1992 p
= reserve_space(xdr
, 20);
1993 *p
++ = cpu_to_be32(1); /* newoffset = TRUE */
1994 p
= xdr_encode_hyper(p
, args
->lastbytewritten
);
1995 *p
++ = cpu_to_be32(0); /* Never send time_modify_changed */
1996 *p
++ = cpu_to_be32(NFS_SERVER(args
->inode
)->pnfs_curr_ld
->id
);/* type */
1998 if (NFS_SERVER(inode
)->pnfs_curr_ld
->encode_layoutcommit
)
1999 NFS_SERVER(inode
)->pnfs_curr_ld
->encode_layoutcommit(
2000 NFS_I(inode
)->layout
, xdr
, args
);
2002 encode_uint32(xdr
, 0); /* no layout-type payload */
2008 encode_layoutreturn(struct xdr_stream
*xdr
,
2009 const struct nfs4_layoutreturn_args
*args
,
2010 struct compound_hdr
*hdr
)
2014 encode_op_hdr(xdr
, OP_LAYOUTRETURN
, decode_layoutreturn_maxsz
, hdr
);
2015 p
= reserve_space(xdr
, 16);
2016 *p
++ = cpu_to_be32(0); /* reclaim. always 0 for now */
2017 *p
++ = cpu_to_be32(args
->layout_type
);
2018 *p
++ = cpu_to_be32(IOMODE_ANY
);
2019 *p
= cpu_to_be32(RETURN_FILE
);
2020 p
= reserve_space(xdr
, 16);
2021 p
= xdr_encode_hyper(p
, 0);
2022 p
= xdr_encode_hyper(p
, NFS4_MAX_UINT64
);
2023 spin_lock(&args
->inode
->i_lock
);
2024 encode_nfs4_stateid(xdr
, &args
->stateid
);
2025 spin_unlock(&args
->inode
->i_lock
);
2026 if (NFS_SERVER(args
->inode
)->pnfs_curr_ld
->encode_layoutreturn
) {
2027 NFS_SERVER(args
->inode
)->pnfs_curr_ld
->encode_layoutreturn(
2028 NFS_I(args
->inode
)->layout
, xdr
, args
);
2030 encode_uint32(xdr
, 0);
2034 encode_secinfo_no_name(struct xdr_stream
*xdr
,
2035 const struct nfs41_secinfo_no_name_args
*args
,
2036 struct compound_hdr
*hdr
)
2038 encode_op_hdr(xdr
, OP_SECINFO_NO_NAME
, decode_secinfo_no_name_maxsz
, hdr
);
2039 encode_uint32(xdr
, args
->style
);
2043 static void encode_test_stateid(struct xdr_stream
*xdr
,
2044 struct nfs41_test_stateid_args
*args
,
2045 struct compound_hdr
*hdr
)
2047 encode_op_hdr(xdr
, OP_TEST_STATEID
, decode_test_stateid_maxsz
, hdr
);
2048 encode_uint32(xdr
, 1);
2049 encode_nfs4_stateid(xdr
, args
->stateid
);
2052 static void encode_free_stateid(struct xdr_stream
*xdr
,
2053 struct nfs41_free_stateid_args
*args
,
2054 struct compound_hdr
*hdr
)
2056 encode_op_hdr(xdr
, OP_FREE_STATEID
, decode_free_stateid_maxsz
, hdr
);
2057 encode_nfs4_stateid(xdr
, &args
->stateid
);
2059 #endif /* CONFIG_NFS_V4_1 */
2062 * END OF "GENERIC" ENCODE ROUTINES.
2065 static u32
nfs4_xdr_minorversion(const struct nfs4_sequence_args
*args
)
2067 #if defined(CONFIG_NFS_V4_1)
2068 struct nfs4_session
*session
= args
->sa_slot
->table
->session
;
2070 return session
->clp
->cl_mvops
->minor_version
;
2071 #endif /* CONFIG_NFS_V4_1 */
2076 * Encode an ACCESS request
2078 static void nfs4_xdr_enc_access(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
2079 const struct nfs4_accessargs
*args
)
2081 struct compound_hdr hdr
= {
2082 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2085 encode_compound_hdr(xdr
, req
, &hdr
);
2086 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2087 encode_putfh(xdr
, args
->fh
, &hdr
);
2088 encode_access(xdr
, args
->access
, &hdr
);
2089 encode_getfattr(xdr
, args
->bitmask
, &hdr
);
2094 * Encode LOOKUP request
2096 static void nfs4_xdr_enc_lookup(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
2097 const struct nfs4_lookup_arg
*args
)
2099 struct compound_hdr hdr
= {
2100 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2103 encode_compound_hdr(xdr
, req
, &hdr
);
2104 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2105 encode_putfh(xdr
, args
->dir_fh
, &hdr
);
2106 encode_lookup(xdr
, args
->name
, &hdr
);
2107 encode_getfh(xdr
, &hdr
);
2108 encode_getfattr(xdr
, args
->bitmask
, &hdr
);
2113 * Encode LOOKUP_ROOT request
2115 static void nfs4_xdr_enc_lookup_root(struct rpc_rqst
*req
,
2116 struct xdr_stream
*xdr
,
2117 const struct nfs4_lookup_root_arg
*args
)
2119 struct compound_hdr hdr
= {
2120 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2123 encode_compound_hdr(xdr
, req
, &hdr
);
2124 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2125 encode_putrootfh(xdr
, &hdr
);
2126 encode_getfh(xdr
, &hdr
);
2127 encode_getfattr(xdr
, args
->bitmask
, &hdr
);
2132 * Encode REMOVE request
2134 static void nfs4_xdr_enc_remove(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
2135 const struct nfs_removeargs
*args
)
2137 struct compound_hdr hdr
= {
2138 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2141 encode_compound_hdr(xdr
, req
, &hdr
);
2142 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2143 encode_putfh(xdr
, args
->fh
, &hdr
);
2144 encode_remove(xdr
, &args
->name
, &hdr
);
2149 * Encode RENAME request
2151 static void nfs4_xdr_enc_rename(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
2152 const struct nfs_renameargs
*args
)
2154 struct compound_hdr hdr
= {
2155 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2158 encode_compound_hdr(xdr
, req
, &hdr
);
2159 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2160 encode_putfh(xdr
, args
->old_dir
, &hdr
);
2161 encode_savefh(xdr
, &hdr
);
2162 encode_putfh(xdr
, args
->new_dir
, &hdr
);
2163 encode_rename(xdr
, args
->old_name
, args
->new_name
, &hdr
);
2168 * Encode LINK request
2170 static void nfs4_xdr_enc_link(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
2171 const struct nfs4_link_arg
*args
)
2173 struct compound_hdr hdr
= {
2174 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2177 encode_compound_hdr(xdr
, req
, &hdr
);
2178 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2179 encode_putfh(xdr
, args
->fh
, &hdr
);
2180 encode_savefh(xdr
, &hdr
);
2181 encode_putfh(xdr
, args
->dir_fh
, &hdr
);
2182 encode_link(xdr
, args
->name
, &hdr
);
2183 encode_restorefh(xdr
, &hdr
);
2184 encode_getfattr(xdr
, args
->bitmask
, &hdr
);
2189 * Encode CREATE request
2191 static void nfs4_xdr_enc_create(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
2192 const struct nfs4_create_arg
*args
)
2194 struct compound_hdr hdr
= {
2195 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2198 encode_compound_hdr(xdr
, req
, &hdr
);
2199 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2200 encode_putfh(xdr
, args
->dir_fh
, &hdr
);
2201 encode_create(xdr
, args
, &hdr
);
2202 encode_getfh(xdr
, &hdr
);
2203 encode_getfattr(xdr
, args
->bitmask
, &hdr
);
2208 * Encode SYMLINK request
2210 static void nfs4_xdr_enc_symlink(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
2211 const struct nfs4_create_arg
*args
)
2213 nfs4_xdr_enc_create(req
, xdr
, args
);
2217 * Encode GETATTR request
2219 static void nfs4_xdr_enc_getattr(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
2220 const struct nfs4_getattr_arg
*args
)
2222 struct compound_hdr hdr
= {
2223 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2226 encode_compound_hdr(xdr
, req
, &hdr
);
2227 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2228 encode_putfh(xdr
, args
->fh
, &hdr
);
2229 encode_getfattr(xdr
, args
->bitmask
, &hdr
);
2234 * Encode a CLOSE request
2236 static void nfs4_xdr_enc_close(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
2237 struct nfs_closeargs
*args
)
2239 struct compound_hdr hdr
= {
2240 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2243 encode_compound_hdr(xdr
, req
, &hdr
);
2244 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2245 encode_putfh(xdr
, args
->fh
, &hdr
);
2246 encode_close(xdr
, args
, &hdr
);
2247 encode_getfattr(xdr
, args
->bitmask
, &hdr
);
2252 * Encode an OPEN request
2254 static void nfs4_xdr_enc_open(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
2255 struct nfs_openargs
*args
)
2257 struct compound_hdr hdr
= {
2258 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
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
);
2265 encode_getfh(xdr
, &hdr
);
2267 encode_access(xdr
, args
->access
, &hdr
);
2268 encode_getfattr_open(xdr
, args
->bitmask
, args
->open_bitmap
, &hdr
);
2273 * Encode an OPEN_CONFIRM request
2275 static void nfs4_xdr_enc_open_confirm(struct rpc_rqst
*req
,
2276 struct xdr_stream
*xdr
,
2277 struct nfs_open_confirmargs
*args
)
2279 struct compound_hdr hdr
= {
2283 encode_compound_hdr(xdr
, req
, &hdr
);
2284 encode_putfh(xdr
, args
->fh
, &hdr
);
2285 encode_open_confirm(xdr
, args
, &hdr
);
2290 * Encode an OPEN request with no attributes.
2292 static void nfs4_xdr_enc_open_noattr(struct rpc_rqst
*req
,
2293 struct xdr_stream
*xdr
,
2294 struct nfs_openargs
*args
)
2296 struct compound_hdr hdr
= {
2297 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2300 encode_compound_hdr(xdr
, req
, &hdr
);
2301 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2302 encode_putfh(xdr
, args
->fh
, &hdr
);
2303 encode_open(xdr
, args
, &hdr
);
2305 encode_access(xdr
, args
->access
, &hdr
);
2306 encode_getfattr_open(xdr
, args
->bitmask
, args
->open_bitmap
, &hdr
);
2311 * Encode an OPEN_DOWNGRADE request
2313 static void nfs4_xdr_enc_open_downgrade(struct rpc_rqst
*req
,
2314 struct xdr_stream
*xdr
,
2315 struct nfs_closeargs
*args
)
2317 struct compound_hdr hdr
= {
2318 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2321 encode_compound_hdr(xdr
, req
, &hdr
);
2322 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2323 encode_putfh(xdr
, args
->fh
, &hdr
);
2324 encode_open_downgrade(xdr
, args
, &hdr
);
2325 encode_getfattr(xdr
, args
->bitmask
, &hdr
);
2330 * Encode a LOCK request
2332 static void nfs4_xdr_enc_lock(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
2333 struct nfs_lock_args
*args
)
2335 struct compound_hdr hdr
= {
2336 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2339 encode_compound_hdr(xdr
, req
, &hdr
);
2340 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2341 encode_putfh(xdr
, args
->fh
, &hdr
);
2342 encode_lock(xdr
, args
, &hdr
);
2347 * Encode a LOCKT request
2349 static void nfs4_xdr_enc_lockt(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
2350 struct nfs_lockt_args
*args
)
2352 struct compound_hdr hdr
= {
2353 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2356 encode_compound_hdr(xdr
, req
, &hdr
);
2357 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2358 encode_putfh(xdr
, args
->fh
, &hdr
);
2359 encode_lockt(xdr
, args
, &hdr
);
2364 * Encode a LOCKU request
2366 static void nfs4_xdr_enc_locku(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
2367 struct nfs_locku_args
*args
)
2369 struct compound_hdr hdr
= {
2370 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2373 encode_compound_hdr(xdr
, req
, &hdr
);
2374 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2375 encode_putfh(xdr
, args
->fh
, &hdr
);
2376 encode_locku(xdr
, args
, &hdr
);
2380 static void nfs4_xdr_enc_release_lockowner(struct rpc_rqst
*req
,
2381 struct xdr_stream
*xdr
,
2382 struct nfs_release_lockowner_args
*args
)
2384 struct compound_hdr hdr
= {
2388 encode_compound_hdr(xdr
, req
, &hdr
);
2389 encode_release_lockowner(xdr
, &args
->lock_owner
, &hdr
);
2394 * Encode a READLINK request
2396 static void nfs4_xdr_enc_readlink(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
2397 const struct nfs4_readlink
*args
)
2399 struct compound_hdr hdr
= {
2400 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2403 encode_compound_hdr(xdr
, req
, &hdr
);
2404 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2405 encode_putfh(xdr
, args
->fh
, &hdr
);
2406 encode_readlink(xdr
, args
, req
, &hdr
);
2408 xdr_inline_pages(&req
->rq_rcv_buf
, hdr
.replen
<< 2, args
->pages
,
2409 args
->pgbase
, args
->pglen
);
2414 * Encode a READDIR request
2416 static void nfs4_xdr_enc_readdir(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
2417 const struct nfs4_readdir_arg
*args
)
2419 struct compound_hdr hdr
= {
2420 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2423 encode_compound_hdr(xdr
, req
, &hdr
);
2424 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2425 encode_putfh(xdr
, args
->fh
, &hdr
);
2426 encode_readdir(xdr
, args
, req
, &hdr
);
2428 xdr_inline_pages(&req
->rq_rcv_buf
, hdr
.replen
<< 2, args
->pages
,
2429 args
->pgbase
, args
->count
);
2430 dprintk("%s: inlined page args = (%u, %p, %u, %u)\n",
2431 __func__
, hdr
.replen
<< 2, args
->pages
,
2432 args
->pgbase
, args
->count
);
2437 * Encode a READ request
2439 static void nfs4_xdr_enc_read(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
2440 struct nfs_readargs
*args
)
2442 struct compound_hdr hdr
= {
2443 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2446 encode_compound_hdr(xdr
, req
, &hdr
);
2447 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2448 encode_putfh(xdr
, args
->fh
, &hdr
);
2449 encode_read(xdr
, args
, &hdr
);
2451 xdr_inline_pages(&req
->rq_rcv_buf
, hdr
.replen
<< 2,
2452 args
->pages
, args
->pgbase
, args
->count
);
2453 req
->rq_rcv_buf
.flags
|= XDRBUF_READ
;
2458 * Encode an SETATTR request
2460 static void nfs4_xdr_enc_setattr(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
2461 struct nfs_setattrargs
*args
)
2463 struct compound_hdr hdr
= {
2464 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2467 encode_compound_hdr(xdr
, req
, &hdr
);
2468 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2469 encode_putfh(xdr
, args
->fh
, &hdr
);
2470 encode_setattr(xdr
, args
, args
->server
, &hdr
);
2471 encode_getfattr(xdr
, args
->bitmask
, &hdr
);
2476 * Encode a GETACL request
2478 static void nfs4_xdr_enc_getacl(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
2479 struct nfs_getaclargs
*args
)
2481 struct compound_hdr hdr
= {
2482 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2486 encode_compound_hdr(xdr
, req
, &hdr
);
2487 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2488 encode_putfh(xdr
, args
->fh
, &hdr
);
2489 replen
= hdr
.replen
+ op_decode_hdr_maxsz
+ 1;
2490 encode_getattr_two(xdr
, FATTR4_WORD0_ACL
, 0, &hdr
);
2492 xdr_inline_pages(&req
->rq_rcv_buf
, replen
<< 2,
2493 args
->acl_pages
, args
->acl_pgbase
, args
->acl_len
);
2499 * Encode a WRITE request
2501 static void nfs4_xdr_enc_write(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
2502 struct nfs_writeargs
*args
)
2504 struct compound_hdr hdr
= {
2505 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2508 encode_compound_hdr(xdr
, req
, &hdr
);
2509 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2510 encode_putfh(xdr
, args
->fh
, &hdr
);
2511 encode_write(xdr
, args
, &hdr
);
2512 req
->rq_snd_buf
.flags
|= XDRBUF_WRITE
;
2514 encode_getfattr(xdr
, args
->bitmask
, &hdr
);
2521 static void nfs4_xdr_enc_commit(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
2522 struct nfs_commitargs
*args
)
2524 struct compound_hdr hdr
= {
2525 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2528 encode_compound_hdr(xdr
, req
, &hdr
);
2529 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2530 encode_putfh(xdr
, args
->fh
, &hdr
);
2531 encode_commit(xdr
, args
, &hdr
);
2538 static void nfs4_xdr_enc_fsinfo(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
2539 struct nfs4_fsinfo_arg
*args
)
2541 struct compound_hdr hdr
= {
2542 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2545 encode_compound_hdr(xdr
, req
, &hdr
);
2546 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2547 encode_putfh(xdr
, args
->fh
, &hdr
);
2548 encode_fsinfo(xdr
, args
->bitmask
, &hdr
);
2553 * a PATHCONF request
2555 static void nfs4_xdr_enc_pathconf(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
2556 const struct nfs4_pathconf_arg
*args
)
2558 struct compound_hdr hdr
= {
2559 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2562 encode_compound_hdr(xdr
, req
, &hdr
);
2563 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2564 encode_putfh(xdr
, args
->fh
, &hdr
);
2565 encode_getattr_one(xdr
, args
->bitmask
[0] & nfs4_pathconf_bitmap
[0],
2573 static void nfs4_xdr_enc_statfs(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
2574 const struct nfs4_statfs_arg
*args
)
2576 struct compound_hdr hdr
= {
2577 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2580 encode_compound_hdr(xdr
, req
, &hdr
);
2581 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2582 encode_putfh(xdr
, args
->fh
, &hdr
);
2583 encode_getattr_two(xdr
, args
->bitmask
[0] & nfs4_statfs_bitmap
[0],
2584 args
->bitmask
[1] & nfs4_statfs_bitmap
[1], &hdr
);
2589 * GETATTR_BITMAP request
2591 static void nfs4_xdr_enc_server_caps(struct rpc_rqst
*req
,
2592 struct xdr_stream
*xdr
,
2593 struct nfs4_server_caps_arg
*args
)
2595 struct compound_hdr hdr
= {
2596 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2599 encode_compound_hdr(xdr
, req
, &hdr
);
2600 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2601 encode_putfh(xdr
, args
->fhandle
, &hdr
);
2602 encode_getattr_one(xdr
, FATTR4_WORD0_SUPPORTED_ATTRS
|
2603 FATTR4_WORD0_FH_EXPIRE_TYPE
|
2604 FATTR4_WORD0_LINK_SUPPORT
|
2605 FATTR4_WORD0_SYMLINK_SUPPORT
|
2606 FATTR4_WORD0_ACLSUPPORT
, &hdr
);
2613 static void nfs4_xdr_enc_renew(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
2614 struct nfs_client
*clp
)
2616 struct compound_hdr hdr
= {
2620 encode_compound_hdr(xdr
, req
, &hdr
);
2621 encode_renew(xdr
, clp
->cl_clientid
, &hdr
);
2626 * a SETCLIENTID request
2628 static void nfs4_xdr_enc_setclientid(struct rpc_rqst
*req
,
2629 struct xdr_stream
*xdr
,
2630 struct nfs4_setclientid
*sc
)
2632 struct compound_hdr hdr
= {
2636 encode_compound_hdr(xdr
, req
, &hdr
);
2637 encode_setclientid(xdr
, sc
, &hdr
);
2642 * a SETCLIENTID_CONFIRM request
2644 static void nfs4_xdr_enc_setclientid_confirm(struct rpc_rqst
*req
,
2645 struct xdr_stream
*xdr
,
2646 struct nfs4_setclientid_res
*arg
)
2648 struct compound_hdr hdr
= {
2652 encode_compound_hdr(xdr
, req
, &hdr
);
2653 encode_setclientid_confirm(xdr
, arg
, &hdr
);
2658 * DELEGRETURN request
2660 static void nfs4_xdr_enc_delegreturn(struct rpc_rqst
*req
,
2661 struct xdr_stream
*xdr
,
2662 const struct nfs4_delegreturnargs
*args
)
2664 struct compound_hdr hdr
= {
2665 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2668 encode_compound_hdr(xdr
, req
, &hdr
);
2669 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2670 encode_putfh(xdr
, args
->fhandle
, &hdr
);
2671 encode_getfattr(xdr
, args
->bitmask
, &hdr
);
2672 encode_delegreturn(xdr
, args
->stateid
, &hdr
);
2677 * Encode FS_LOCATIONS request
2679 static void nfs4_xdr_enc_fs_locations(struct rpc_rqst
*req
,
2680 struct xdr_stream
*xdr
,
2681 struct nfs4_fs_locations_arg
*args
)
2683 struct compound_hdr hdr
= {
2684 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2688 encode_compound_hdr(xdr
, req
, &hdr
);
2689 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2690 encode_putfh(xdr
, args
->dir_fh
, &hdr
);
2691 encode_lookup(xdr
, args
->name
, &hdr
);
2692 replen
= hdr
.replen
; /* get the attribute into args->page */
2693 encode_fs_locations(xdr
, args
->bitmask
, &hdr
);
2695 xdr_inline_pages(&req
->rq_rcv_buf
, replen
<< 2, &args
->page
,
2701 * Encode SECINFO request
2703 static void nfs4_xdr_enc_secinfo(struct rpc_rqst
*req
,
2704 struct xdr_stream
*xdr
,
2705 struct nfs4_secinfo_arg
*args
)
2707 struct compound_hdr hdr
= {
2708 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2711 encode_compound_hdr(xdr
, req
, &hdr
);
2712 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2713 encode_putfh(xdr
, args
->dir_fh
, &hdr
);
2714 encode_secinfo(xdr
, args
->name
, &hdr
);
2718 #if defined(CONFIG_NFS_V4_1)
2720 * BIND_CONN_TO_SESSION request
2722 static void nfs4_xdr_enc_bind_conn_to_session(struct rpc_rqst
*req
,
2723 struct xdr_stream
*xdr
,
2724 struct nfs_client
*clp
)
2726 struct compound_hdr hdr
= {
2727 .minorversion
= clp
->cl_mvops
->minor_version
,
2730 encode_compound_hdr(xdr
, req
, &hdr
);
2731 encode_bind_conn_to_session(xdr
, clp
->cl_session
, &hdr
);
2736 * EXCHANGE_ID request
2738 static void nfs4_xdr_enc_exchange_id(struct rpc_rqst
*req
,
2739 struct xdr_stream
*xdr
,
2740 struct nfs41_exchange_id_args
*args
)
2742 struct compound_hdr hdr
= {
2743 .minorversion
= args
->client
->cl_mvops
->minor_version
,
2746 encode_compound_hdr(xdr
, req
, &hdr
);
2747 encode_exchange_id(xdr
, args
, &hdr
);
2752 * a CREATE_SESSION request
2754 static void nfs4_xdr_enc_create_session(struct rpc_rqst
*req
,
2755 struct xdr_stream
*xdr
,
2756 struct nfs41_create_session_args
*args
)
2758 struct compound_hdr hdr
= {
2759 .minorversion
= args
->client
->cl_mvops
->minor_version
,
2762 encode_compound_hdr(xdr
, req
, &hdr
);
2763 encode_create_session(xdr
, args
, &hdr
);
2768 * a DESTROY_SESSION request
2770 static void nfs4_xdr_enc_destroy_session(struct rpc_rqst
*req
,
2771 struct xdr_stream
*xdr
,
2772 struct nfs4_session
*session
)
2774 struct compound_hdr hdr
= {
2775 .minorversion
= session
->clp
->cl_mvops
->minor_version
,
2778 encode_compound_hdr(xdr
, req
, &hdr
);
2779 encode_destroy_session(xdr
, session
, &hdr
);
2784 * a DESTROY_CLIENTID request
2786 static void nfs4_xdr_enc_destroy_clientid(struct rpc_rqst
*req
,
2787 struct xdr_stream
*xdr
,
2788 struct nfs_client
*clp
)
2790 struct compound_hdr hdr
= {
2791 .minorversion
= clp
->cl_mvops
->minor_version
,
2794 encode_compound_hdr(xdr
, req
, &hdr
);
2795 encode_destroy_clientid(xdr
, clp
->cl_clientid
, &hdr
);
2800 * a SEQUENCE request
2802 static void nfs4_xdr_enc_sequence(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
2803 struct nfs4_sequence_args
*args
)
2805 struct compound_hdr hdr
= {
2806 .minorversion
= nfs4_xdr_minorversion(args
),
2809 encode_compound_hdr(xdr
, req
, &hdr
);
2810 encode_sequence(xdr
, args
, &hdr
);
2815 * a GET_LEASE_TIME request
2817 static void nfs4_xdr_enc_get_lease_time(struct rpc_rqst
*req
,
2818 struct xdr_stream
*xdr
,
2819 struct nfs4_get_lease_time_args
*args
)
2821 struct compound_hdr hdr
= {
2822 .minorversion
= nfs4_xdr_minorversion(&args
->la_seq_args
),
2824 const u32 lease_bitmap
[3] = { FATTR4_WORD0_LEASE_TIME
};
2826 encode_compound_hdr(xdr
, req
, &hdr
);
2827 encode_sequence(xdr
, &args
->la_seq_args
, &hdr
);
2828 encode_putrootfh(xdr
, &hdr
);
2829 encode_fsinfo(xdr
, lease_bitmap
, &hdr
);
2834 * a RECLAIM_COMPLETE request
2836 static void nfs4_xdr_enc_reclaim_complete(struct rpc_rqst
*req
,
2837 struct xdr_stream
*xdr
,
2838 struct nfs41_reclaim_complete_args
*args
)
2840 struct compound_hdr hdr
= {
2841 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
)
2844 encode_compound_hdr(xdr
, req
, &hdr
);
2845 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2846 encode_reclaim_complete(xdr
, args
, &hdr
);
2851 * Encode GETDEVICELIST request
2853 static void nfs4_xdr_enc_getdevicelist(struct rpc_rqst
*req
,
2854 struct xdr_stream
*xdr
,
2855 struct nfs4_getdevicelist_args
*args
)
2857 struct compound_hdr hdr
= {
2858 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2861 encode_compound_hdr(xdr
, req
, &hdr
);
2862 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2863 encode_putfh(xdr
, args
->fh
, &hdr
);
2864 encode_getdevicelist(xdr
, args
, &hdr
);
2869 * Encode GETDEVICEINFO request
2871 static void nfs4_xdr_enc_getdeviceinfo(struct rpc_rqst
*req
,
2872 struct xdr_stream
*xdr
,
2873 struct nfs4_getdeviceinfo_args
*args
)
2875 struct compound_hdr hdr
= {
2876 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2879 encode_compound_hdr(xdr
, req
, &hdr
);
2880 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2881 encode_getdeviceinfo(xdr
, args
, &hdr
);
2883 /* set up reply kvec. Subtract notification bitmap max size (2)
2884 * so that notification bitmap is put in xdr_buf tail */
2885 xdr_inline_pages(&req
->rq_rcv_buf
, (hdr
.replen
- 2) << 2,
2886 args
->pdev
->pages
, args
->pdev
->pgbase
,
2893 * Encode LAYOUTGET request
2895 static void nfs4_xdr_enc_layoutget(struct rpc_rqst
*req
,
2896 struct xdr_stream
*xdr
,
2897 struct nfs4_layoutget_args
*args
)
2899 struct compound_hdr hdr
= {
2900 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2903 encode_compound_hdr(xdr
, req
, &hdr
);
2904 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2905 encode_putfh(xdr
, NFS_FH(args
->inode
), &hdr
);
2906 encode_layoutget(xdr
, args
, &hdr
);
2908 xdr_inline_pages(&req
->rq_rcv_buf
, hdr
.replen
<< 2,
2909 args
->layout
.pages
, 0, args
->layout
.pglen
);
2915 * Encode LAYOUTCOMMIT request
2917 static void nfs4_xdr_enc_layoutcommit(struct rpc_rqst
*req
,
2918 struct xdr_stream
*xdr
,
2919 struct nfs4_layoutcommit_args
*args
)
2921 struct nfs4_layoutcommit_data
*data
=
2922 container_of(args
, struct nfs4_layoutcommit_data
, args
);
2923 struct compound_hdr hdr
= {
2924 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2927 encode_compound_hdr(xdr
, req
, &hdr
);
2928 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2929 encode_putfh(xdr
, NFS_FH(args
->inode
), &hdr
);
2930 encode_layoutcommit(xdr
, data
->args
.inode
, args
, &hdr
);
2931 encode_getfattr(xdr
, args
->bitmask
, &hdr
);
2936 * Encode LAYOUTRETURN request
2938 static void nfs4_xdr_enc_layoutreturn(struct rpc_rqst
*req
,
2939 struct xdr_stream
*xdr
,
2940 struct nfs4_layoutreturn_args
*args
)
2942 struct compound_hdr hdr
= {
2943 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2946 encode_compound_hdr(xdr
, req
, &hdr
);
2947 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2948 encode_putfh(xdr
, NFS_FH(args
->inode
), &hdr
);
2949 encode_layoutreturn(xdr
, args
, &hdr
);
2954 * Encode SECINFO_NO_NAME request
2956 static int nfs4_xdr_enc_secinfo_no_name(struct rpc_rqst
*req
,
2957 struct xdr_stream
*xdr
,
2958 struct nfs41_secinfo_no_name_args
*args
)
2960 struct compound_hdr hdr
= {
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_putrootfh(xdr
, &hdr
);
2967 encode_secinfo_no_name(xdr
, args
, &hdr
);
2973 * Encode TEST_STATEID request
2975 static void nfs4_xdr_enc_test_stateid(struct rpc_rqst
*req
,
2976 struct xdr_stream
*xdr
,
2977 struct nfs41_test_stateid_args
*args
)
2979 struct compound_hdr hdr
= {
2980 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
2983 encode_compound_hdr(xdr
, req
, &hdr
);
2984 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
2985 encode_test_stateid(xdr
, args
, &hdr
);
2990 * Encode FREE_STATEID request
2992 static void nfs4_xdr_enc_free_stateid(struct rpc_rqst
*req
,
2993 struct xdr_stream
*xdr
,
2994 struct nfs41_free_stateid_args
*args
)
2996 struct compound_hdr hdr
= {
2997 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
3000 encode_compound_hdr(xdr
, req
, &hdr
);
3001 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
3002 encode_free_stateid(xdr
, args
, &hdr
);
3005 #endif /* CONFIG_NFS_V4_1 */
3007 static void print_overflow_msg(const char *func
, const struct xdr_stream
*xdr
)
3009 dprintk("nfs: %s: prematurely hit end of receive buffer. "
3010 "Remaining buffer length is %tu words.\n",
3011 func
, xdr
->end
- xdr
->p
);
3014 static int decode_opaque_inline(struct xdr_stream
*xdr
, unsigned int *len
, char **string
)
3018 p
= xdr_inline_decode(xdr
, 4);
3021 *len
= be32_to_cpup(p
);
3022 p
= xdr_inline_decode(xdr
, *len
);
3025 *string
= (char *)p
;
3028 print_overflow_msg(__func__
, xdr
);
3032 static int decode_compound_hdr(struct xdr_stream
*xdr
, struct compound_hdr
*hdr
)
3036 p
= xdr_inline_decode(xdr
, 8);
3039 hdr
->status
= be32_to_cpup(p
++);
3040 hdr
->taglen
= be32_to_cpup(p
);
3042 p
= xdr_inline_decode(xdr
, hdr
->taglen
+ 4);
3045 hdr
->tag
= (char *)p
;
3046 p
+= XDR_QUADLEN(hdr
->taglen
);
3047 hdr
->nops
= be32_to_cpup(p
);
3048 if (unlikely(hdr
->nops
< 1))
3049 return nfs4_stat_to_errno(hdr
->status
);
3052 print_overflow_msg(__func__
, xdr
);
3056 static int decode_op_hdr(struct xdr_stream
*xdr
, enum nfs_opnum4 expected
)
3062 p
= xdr_inline_decode(xdr
, 8);
3065 opnum
= be32_to_cpup(p
++);
3066 if (opnum
!= expected
) {
3067 dprintk("nfs: Server returned operation"
3068 " %d but we issued a request for %d\n",
3072 nfserr
= be32_to_cpup(p
);
3073 if (nfserr
!= NFS_OK
)
3074 return nfs4_stat_to_errno(nfserr
);
3077 print_overflow_msg(__func__
, xdr
);
3082 static int decode_ace(struct xdr_stream
*xdr
, void *ace
, struct nfs_client
*clp
)
3085 unsigned int strlen
;
3088 p
= xdr_inline_decode(xdr
, 12);
3090 return decode_opaque_inline(xdr
, &strlen
, &str
);
3091 print_overflow_msg(__func__
, xdr
);
3095 static int decode_attr_bitmap(struct xdr_stream
*xdr
, uint32_t *bitmap
)
3100 p
= xdr_inline_decode(xdr
, 4);
3103 bmlen
= be32_to_cpup(p
);
3105 bitmap
[0] = bitmap
[1] = bitmap
[2] = 0;
3106 p
= xdr_inline_decode(xdr
, (bmlen
<< 2));
3110 bitmap
[0] = be32_to_cpup(p
++);
3112 bitmap
[1] = be32_to_cpup(p
++);
3114 bitmap
[2] = be32_to_cpup(p
);
3119 print_overflow_msg(__func__
, xdr
);
3123 static int decode_attr_length(struct xdr_stream
*xdr
, uint32_t *attrlen
, unsigned int *savep
)
3127 p
= xdr_inline_decode(xdr
, 4);
3130 *attrlen
= be32_to_cpup(p
);
3131 *savep
= xdr_stream_pos(xdr
);
3134 print_overflow_msg(__func__
, xdr
);
3138 static int decode_attr_supported(struct xdr_stream
*xdr
, uint32_t *bitmap
, uint32_t *bitmask
)
3140 if (likely(bitmap
[0] & FATTR4_WORD0_SUPPORTED_ATTRS
)) {
3142 ret
= decode_attr_bitmap(xdr
, bitmask
);
3143 if (unlikely(ret
< 0))
3145 bitmap
[0] &= ~FATTR4_WORD0_SUPPORTED_ATTRS
;
3147 bitmask
[0] = bitmask
[1] = bitmask
[2] = 0;
3148 dprintk("%s: bitmask=%08x:%08x:%08x\n", __func__
,
3149 bitmask
[0], bitmask
[1], bitmask
[2]);
3153 static int decode_attr_type(struct xdr_stream
*xdr
, uint32_t *bitmap
, uint32_t *type
)
3159 if (unlikely(bitmap
[0] & (FATTR4_WORD0_TYPE
- 1U)))
3161 if (likely(bitmap
[0] & FATTR4_WORD0_TYPE
)) {
3162 p
= xdr_inline_decode(xdr
, 4);
3165 *type
= be32_to_cpup(p
);
3166 if (*type
< NF4REG
|| *type
> NF4NAMEDATTR
) {
3167 dprintk("%s: bad type %d\n", __func__
, *type
);
3170 bitmap
[0] &= ~FATTR4_WORD0_TYPE
;
3171 ret
= NFS_ATTR_FATTR_TYPE
;
3173 dprintk("%s: type=0%o\n", __func__
, nfs_type2fmt
[*type
]);
3176 print_overflow_msg(__func__
, xdr
);
3180 static int decode_attr_fh_expire_type(struct xdr_stream
*xdr
,
3181 uint32_t *bitmap
, uint32_t *type
)
3186 if (unlikely(bitmap
[0] & (FATTR4_WORD0_FH_EXPIRE_TYPE
- 1U)))
3188 if (likely(bitmap
[0] & FATTR4_WORD0_FH_EXPIRE_TYPE
)) {
3189 p
= xdr_inline_decode(xdr
, 4);
3192 *type
= be32_to_cpup(p
);
3193 bitmap
[0] &= ~FATTR4_WORD0_FH_EXPIRE_TYPE
;
3195 dprintk("%s: expire type=0x%x\n", __func__
, *type
);
3198 print_overflow_msg(__func__
, xdr
);
3202 static int decode_attr_change(struct xdr_stream
*xdr
, uint32_t *bitmap
, uint64_t *change
)
3208 if (unlikely(bitmap
[0] & (FATTR4_WORD0_CHANGE
- 1U)))
3210 if (likely(bitmap
[0] & FATTR4_WORD0_CHANGE
)) {
3211 p
= xdr_inline_decode(xdr
, 8);
3214 xdr_decode_hyper(p
, change
);
3215 bitmap
[0] &= ~FATTR4_WORD0_CHANGE
;
3216 ret
= NFS_ATTR_FATTR_CHANGE
;
3218 dprintk("%s: change attribute=%Lu\n", __func__
,
3219 (unsigned long long)*change
);
3222 print_overflow_msg(__func__
, xdr
);
3226 static int decode_attr_size(struct xdr_stream
*xdr
, uint32_t *bitmap
, uint64_t *size
)
3232 if (unlikely(bitmap
[0] & (FATTR4_WORD0_SIZE
- 1U)))
3234 if (likely(bitmap
[0] & FATTR4_WORD0_SIZE
)) {
3235 p
= xdr_inline_decode(xdr
, 8);
3238 xdr_decode_hyper(p
, size
);
3239 bitmap
[0] &= ~FATTR4_WORD0_SIZE
;
3240 ret
= NFS_ATTR_FATTR_SIZE
;
3242 dprintk("%s: file size=%Lu\n", __func__
, (unsigned long long)*size
);
3245 print_overflow_msg(__func__
, xdr
);
3249 static int decode_attr_link_support(struct xdr_stream
*xdr
, uint32_t *bitmap
, uint32_t *res
)
3254 if (unlikely(bitmap
[0] & (FATTR4_WORD0_LINK_SUPPORT
- 1U)))
3256 if (likely(bitmap
[0] & FATTR4_WORD0_LINK_SUPPORT
)) {
3257 p
= xdr_inline_decode(xdr
, 4);
3260 *res
= be32_to_cpup(p
);
3261 bitmap
[0] &= ~FATTR4_WORD0_LINK_SUPPORT
;
3263 dprintk("%s: link support=%s\n", __func__
, *res
== 0 ? "false" : "true");
3266 print_overflow_msg(__func__
, xdr
);
3270 static int decode_attr_symlink_support(struct xdr_stream
*xdr
, uint32_t *bitmap
, uint32_t *res
)
3275 if (unlikely(bitmap
[0] & (FATTR4_WORD0_SYMLINK_SUPPORT
- 1U)))
3277 if (likely(bitmap
[0] & FATTR4_WORD0_SYMLINK_SUPPORT
)) {
3278 p
= xdr_inline_decode(xdr
, 4);
3281 *res
= be32_to_cpup(p
);
3282 bitmap
[0] &= ~FATTR4_WORD0_SYMLINK_SUPPORT
;
3284 dprintk("%s: symlink support=%s\n", __func__
, *res
== 0 ? "false" : "true");
3287 print_overflow_msg(__func__
, xdr
);
3291 static int decode_attr_fsid(struct xdr_stream
*xdr
, uint32_t *bitmap
, struct nfs_fsid
*fsid
)
3298 if (unlikely(bitmap
[0] & (FATTR4_WORD0_FSID
- 1U)))
3300 if (likely(bitmap
[0] & FATTR4_WORD0_FSID
)) {
3301 p
= xdr_inline_decode(xdr
, 16);
3304 p
= xdr_decode_hyper(p
, &fsid
->major
);
3305 xdr_decode_hyper(p
, &fsid
->minor
);
3306 bitmap
[0] &= ~FATTR4_WORD0_FSID
;
3307 ret
= NFS_ATTR_FATTR_FSID
;
3309 dprintk("%s: fsid=(0x%Lx/0x%Lx)\n", __func__
,
3310 (unsigned long long)fsid
->major
,
3311 (unsigned long long)fsid
->minor
);
3314 print_overflow_msg(__func__
, xdr
);
3318 static int decode_attr_lease_time(struct xdr_stream
*xdr
, uint32_t *bitmap
, uint32_t *res
)
3323 if (unlikely(bitmap
[0] & (FATTR4_WORD0_LEASE_TIME
- 1U)))
3325 if (likely(bitmap
[0] & FATTR4_WORD0_LEASE_TIME
)) {
3326 p
= xdr_inline_decode(xdr
, 4);
3329 *res
= be32_to_cpup(p
);
3330 bitmap
[0] &= ~FATTR4_WORD0_LEASE_TIME
;
3332 dprintk("%s: file size=%u\n", __func__
, (unsigned int)*res
);
3335 print_overflow_msg(__func__
, xdr
);
3339 static int decode_attr_error(struct xdr_stream
*xdr
, uint32_t *bitmap
, int32_t *res
)
3343 if (unlikely(bitmap
[0] & (FATTR4_WORD0_RDATTR_ERROR
- 1U)))
3345 if (likely(bitmap
[0] & FATTR4_WORD0_RDATTR_ERROR
)) {
3346 p
= xdr_inline_decode(xdr
, 4);
3349 bitmap
[0] &= ~FATTR4_WORD0_RDATTR_ERROR
;
3350 *res
= -be32_to_cpup(p
);
3354 print_overflow_msg(__func__
, xdr
);
3358 static int decode_attr_filehandle(struct xdr_stream
*xdr
, uint32_t *bitmap
, struct nfs_fh
*fh
)
3364 memset(fh
, 0, sizeof(*fh
));
3366 if (unlikely(bitmap
[0] & (FATTR4_WORD0_FILEHANDLE
- 1U)))
3368 if (likely(bitmap
[0] & FATTR4_WORD0_FILEHANDLE
)) {
3369 p
= xdr_inline_decode(xdr
, 4);
3372 len
= be32_to_cpup(p
);
3373 if (len
> NFS4_FHSIZE
)
3375 p
= xdr_inline_decode(xdr
, len
);
3379 memcpy(fh
->data
, p
, len
);
3382 bitmap
[0] &= ~FATTR4_WORD0_FILEHANDLE
;
3386 print_overflow_msg(__func__
, xdr
);
3390 static int decode_attr_aclsupport(struct xdr_stream
*xdr
, uint32_t *bitmap
, uint32_t *res
)
3394 *res
= ACL4_SUPPORT_ALLOW_ACL
|ACL4_SUPPORT_DENY_ACL
;
3395 if (unlikely(bitmap
[0] & (FATTR4_WORD0_ACLSUPPORT
- 1U)))
3397 if (likely(bitmap
[0] & FATTR4_WORD0_ACLSUPPORT
)) {
3398 p
= xdr_inline_decode(xdr
, 4);
3401 *res
= be32_to_cpup(p
);
3402 bitmap
[0] &= ~FATTR4_WORD0_ACLSUPPORT
;
3404 dprintk("%s: ACLs supported=%u\n", __func__
, (unsigned int)*res
);
3407 print_overflow_msg(__func__
, xdr
);
3411 static int decode_attr_fileid(struct xdr_stream
*xdr
, uint32_t *bitmap
, uint64_t *fileid
)
3417 if (unlikely(bitmap
[0] & (FATTR4_WORD0_FILEID
- 1U)))
3419 if (likely(bitmap
[0] & FATTR4_WORD0_FILEID
)) {
3420 p
= xdr_inline_decode(xdr
, 8);
3423 xdr_decode_hyper(p
, fileid
);
3424 bitmap
[0] &= ~FATTR4_WORD0_FILEID
;
3425 ret
= NFS_ATTR_FATTR_FILEID
;
3427 dprintk("%s: fileid=%Lu\n", __func__
, (unsigned long long)*fileid
);
3430 print_overflow_msg(__func__
, xdr
);
3434 static int decode_attr_mounted_on_fileid(struct xdr_stream
*xdr
, uint32_t *bitmap
, uint64_t *fileid
)
3440 if (unlikely(bitmap
[1] & (FATTR4_WORD1_MOUNTED_ON_FILEID
- 1U)))
3442 if (likely(bitmap
[1] & FATTR4_WORD1_MOUNTED_ON_FILEID
)) {
3443 p
= xdr_inline_decode(xdr
, 8);
3446 xdr_decode_hyper(p
, fileid
);
3447 bitmap
[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID
;
3448 ret
= NFS_ATTR_FATTR_MOUNTED_ON_FILEID
;
3450 dprintk("%s: fileid=%Lu\n", __func__
, (unsigned long long)*fileid
);
3453 print_overflow_msg(__func__
, xdr
);
3457 static int decode_attr_files_avail(struct xdr_stream
*xdr
, uint32_t *bitmap
, uint64_t *res
)
3463 if (unlikely(bitmap
[0] & (FATTR4_WORD0_FILES_AVAIL
- 1U)))
3465 if (likely(bitmap
[0] & FATTR4_WORD0_FILES_AVAIL
)) {
3466 p
= xdr_inline_decode(xdr
, 8);
3469 xdr_decode_hyper(p
, res
);
3470 bitmap
[0] &= ~FATTR4_WORD0_FILES_AVAIL
;
3472 dprintk("%s: files avail=%Lu\n", __func__
, (unsigned long long)*res
);
3475 print_overflow_msg(__func__
, xdr
);
3479 static int decode_attr_files_free(struct xdr_stream
*xdr
, uint32_t *bitmap
, uint64_t *res
)
3485 if (unlikely(bitmap
[0] & (FATTR4_WORD0_FILES_FREE
- 1U)))
3487 if (likely(bitmap
[0] & FATTR4_WORD0_FILES_FREE
)) {
3488 p
= xdr_inline_decode(xdr
, 8);
3491 xdr_decode_hyper(p
, res
);
3492 bitmap
[0] &= ~FATTR4_WORD0_FILES_FREE
;
3494 dprintk("%s: files free=%Lu\n", __func__
, (unsigned long long)*res
);
3497 print_overflow_msg(__func__
, xdr
);
3501 static int decode_attr_files_total(struct xdr_stream
*xdr
, uint32_t *bitmap
, uint64_t *res
)
3507 if (unlikely(bitmap
[0] & (FATTR4_WORD0_FILES_TOTAL
- 1U)))
3509 if (likely(bitmap
[0] & FATTR4_WORD0_FILES_TOTAL
)) {
3510 p
= xdr_inline_decode(xdr
, 8);
3513 xdr_decode_hyper(p
, res
);
3514 bitmap
[0] &= ~FATTR4_WORD0_FILES_TOTAL
;
3516 dprintk("%s: files total=%Lu\n", __func__
, (unsigned long long)*res
);
3519 print_overflow_msg(__func__
, xdr
);
3523 static int decode_pathname(struct xdr_stream
*xdr
, struct nfs4_pathname
*path
)
3529 p
= xdr_inline_decode(xdr
, 4);
3532 n
= be32_to_cpup(p
);
3535 dprintk("pathname4: ");
3536 if (n
> NFS4_PATHNAME_MAXCOMPONENTS
) {
3537 dprintk("cannot parse %d components in path\n", n
);
3540 for (path
->ncomponents
= 0; path
->ncomponents
< n
; path
->ncomponents
++) {
3541 struct nfs4_string
*component
= &path
->components
[path
->ncomponents
];
3542 status
= decode_opaque_inline(xdr
, &component
->len
, &component
->data
);
3543 if (unlikely(status
!= 0))
3547 (path
->ncomponents
!= n
? "/ " : ""),
3548 component
->len
, component
->data
);
3553 /* a root pathname is sent as a zero component4 */
3554 path
->ncomponents
= 1;
3555 path
->components
[0].len
=0;
3556 path
->components
[0].data
=NULL
;
3557 dprintk("pathname4: /\n");
3560 dprintk(" status %d", status
);
3564 print_overflow_msg(__func__
, xdr
);
3568 static int decode_attr_fs_locations(struct xdr_stream
*xdr
, uint32_t *bitmap
, struct nfs4_fs_locations
*res
)
3574 if (unlikely(bitmap
[0] & (FATTR4_WORD0_FS_LOCATIONS
-1U)))
3577 if (unlikely(!(bitmap
[0] & FATTR4_WORD0_FS_LOCATIONS
)))
3580 /* Ignore borken servers that return unrequested attrs */
3581 if (unlikely(res
== NULL
))
3583 dprintk("%s: fsroot:\n", __func__
);
3584 status
= decode_pathname(xdr
, &res
->fs_path
);
3585 if (unlikely(status
!= 0))
3587 p
= xdr_inline_decode(xdr
, 4);
3590 n
= be32_to_cpup(p
);
3593 for (res
->nlocations
= 0; res
->nlocations
< n
; res
->nlocations
++) {
3595 struct nfs4_fs_location
*loc
;
3597 if (res
->nlocations
== NFS4_FS_LOCATIONS_MAXENTRIES
)
3599 loc
= &res
->locations
[res
->nlocations
];
3600 p
= xdr_inline_decode(xdr
, 4);
3603 m
= be32_to_cpup(p
);
3605 dprintk("%s: servers:\n", __func__
);
3606 for (loc
->nservers
= 0; loc
->nservers
< m
; loc
->nservers
++) {
3607 struct nfs4_string
*server
;
3609 if (loc
->nservers
== NFS4_FS_LOCATION_MAXSERVERS
) {
3611 dprintk("%s: using first %u of %u servers "
3612 "returned for location %u\n",
3614 NFS4_FS_LOCATION_MAXSERVERS
,
3615 m
, res
->nlocations
);
3616 for (i
= loc
->nservers
; i
< m
; i
++) {
3619 status
= decode_opaque_inline(xdr
, &len
, &data
);
3620 if (unlikely(status
!= 0))
3625 server
= &loc
->servers
[loc
->nservers
];
3626 status
= decode_opaque_inline(xdr
, &server
->len
, &server
->data
);
3627 if (unlikely(status
!= 0))
3629 dprintk("%s ", server
->data
);
3631 status
= decode_pathname(xdr
, &loc
->rootpath
);
3632 if (unlikely(status
!= 0))
3635 if (res
->nlocations
!= 0)
3636 status
= NFS_ATTR_FATTR_V4_LOCATIONS
;
3638 dprintk("%s: fs_locations done, error = %d\n", __func__
, status
);
3641 print_overflow_msg(__func__
, xdr
);
3647 static int decode_attr_maxfilesize(struct xdr_stream
*xdr
, uint32_t *bitmap
, uint64_t *res
)
3653 if (unlikely(bitmap
[0] & (FATTR4_WORD0_MAXFILESIZE
- 1U)))
3655 if (likely(bitmap
[0] & FATTR4_WORD0_MAXFILESIZE
)) {
3656 p
= xdr_inline_decode(xdr
, 8);
3659 xdr_decode_hyper(p
, res
);
3660 bitmap
[0] &= ~FATTR4_WORD0_MAXFILESIZE
;
3662 dprintk("%s: maxfilesize=%Lu\n", __func__
, (unsigned long long)*res
);
3665 print_overflow_msg(__func__
, xdr
);
3669 static int decode_attr_maxlink(struct xdr_stream
*xdr
, uint32_t *bitmap
, uint32_t *maxlink
)
3675 if (unlikely(bitmap
[0] & (FATTR4_WORD0_MAXLINK
- 1U)))
3677 if (likely(bitmap
[0] & FATTR4_WORD0_MAXLINK
)) {
3678 p
= xdr_inline_decode(xdr
, 4);
3681 *maxlink
= be32_to_cpup(p
);
3682 bitmap
[0] &= ~FATTR4_WORD0_MAXLINK
;
3684 dprintk("%s: maxlink=%u\n", __func__
, *maxlink
);
3687 print_overflow_msg(__func__
, xdr
);
3691 static int decode_attr_maxname(struct xdr_stream
*xdr
, uint32_t *bitmap
, uint32_t *maxname
)
3697 if (unlikely(bitmap
[0] & (FATTR4_WORD0_MAXNAME
- 1U)))
3699 if (likely(bitmap
[0] & FATTR4_WORD0_MAXNAME
)) {
3700 p
= xdr_inline_decode(xdr
, 4);
3703 *maxname
= be32_to_cpup(p
);
3704 bitmap
[0] &= ~FATTR4_WORD0_MAXNAME
;
3706 dprintk("%s: maxname=%u\n", __func__
, *maxname
);
3709 print_overflow_msg(__func__
, xdr
);
3713 static int decode_attr_maxread(struct xdr_stream
*xdr
, uint32_t *bitmap
, uint32_t *res
)
3719 if (unlikely(bitmap
[0] & (FATTR4_WORD0_MAXREAD
- 1U)))
3721 if (likely(bitmap
[0] & FATTR4_WORD0_MAXREAD
)) {
3723 p
= xdr_inline_decode(xdr
, 8);
3726 xdr_decode_hyper(p
, &maxread
);
3727 if (maxread
> 0x7FFFFFFF)
3728 maxread
= 0x7FFFFFFF;
3729 *res
= (uint32_t)maxread
;
3730 bitmap
[0] &= ~FATTR4_WORD0_MAXREAD
;
3732 dprintk("%s: maxread=%lu\n", __func__
, (unsigned long)*res
);
3735 print_overflow_msg(__func__
, xdr
);
3739 static int decode_attr_maxwrite(struct xdr_stream
*xdr
, uint32_t *bitmap
, uint32_t *res
)
3745 if (unlikely(bitmap
[0] & (FATTR4_WORD0_MAXWRITE
- 1U)))
3747 if (likely(bitmap
[0] & FATTR4_WORD0_MAXWRITE
)) {
3749 p
= xdr_inline_decode(xdr
, 8);
3752 xdr_decode_hyper(p
, &maxwrite
);
3753 if (maxwrite
> 0x7FFFFFFF)
3754 maxwrite
= 0x7FFFFFFF;
3755 *res
= (uint32_t)maxwrite
;
3756 bitmap
[0] &= ~FATTR4_WORD0_MAXWRITE
;
3758 dprintk("%s: maxwrite=%lu\n", __func__
, (unsigned long)*res
);
3761 print_overflow_msg(__func__
, xdr
);
3765 static int decode_attr_mode(struct xdr_stream
*xdr
, uint32_t *bitmap
, umode_t
*mode
)
3772 if (unlikely(bitmap
[1] & (FATTR4_WORD1_MODE
- 1U)))
3774 if (likely(bitmap
[1] & FATTR4_WORD1_MODE
)) {
3775 p
= xdr_inline_decode(xdr
, 4);
3778 tmp
= be32_to_cpup(p
);
3779 *mode
= tmp
& ~S_IFMT
;
3780 bitmap
[1] &= ~FATTR4_WORD1_MODE
;
3781 ret
= NFS_ATTR_FATTR_MODE
;
3783 dprintk("%s: file mode=0%o\n", __func__
, (unsigned int)*mode
);
3786 print_overflow_msg(__func__
, xdr
);
3790 static int decode_attr_nlink(struct xdr_stream
*xdr
, uint32_t *bitmap
, uint32_t *nlink
)
3796 if (unlikely(bitmap
[1] & (FATTR4_WORD1_NUMLINKS
- 1U)))
3798 if (likely(bitmap
[1] & FATTR4_WORD1_NUMLINKS
)) {
3799 p
= xdr_inline_decode(xdr
, 4);
3802 *nlink
= be32_to_cpup(p
);
3803 bitmap
[1] &= ~FATTR4_WORD1_NUMLINKS
;
3804 ret
= NFS_ATTR_FATTR_NLINK
;
3806 dprintk("%s: nlink=%u\n", __func__
, (unsigned int)*nlink
);
3809 print_overflow_msg(__func__
, xdr
);
3813 static int decode_attr_owner(struct xdr_stream
*xdr
, uint32_t *bitmap
,
3814 const struct nfs_server
*server
, kuid_t
*uid
,
3815 struct nfs4_string
*owner_name
)
3821 *uid
= make_kuid(&init_user_ns
, -2);
3822 if (unlikely(bitmap
[1] & (FATTR4_WORD1_OWNER
- 1U)))
3824 if (likely(bitmap
[1] & FATTR4_WORD1_OWNER
)) {
3825 p
= xdr_inline_decode(xdr
, 4);
3828 len
= be32_to_cpup(p
);
3829 p
= xdr_inline_decode(xdr
, len
);
3832 if (owner_name
!= NULL
) {
3833 owner_name
->data
= kmemdup(p
, len
, GFP_NOWAIT
);
3834 if (owner_name
->data
!= NULL
) {
3835 owner_name
->len
= len
;
3836 ret
= NFS_ATTR_FATTR_OWNER_NAME
;
3838 } else if (len
< XDR_MAX_NETOBJ
) {
3839 if (nfs_map_name_to_uid(server
, (char *)p
, len
, uid
) == 0)
3840 ret
= NFS_ATTR_FATTR_OWNER
;
3842 dprintk("%s: nfs_map_name_to_uid failed!\n",
3845 dprintk("%s: name too long (%u)!\n",
3847 bitmap
[1] &= ~FATTR4_WORD1_OWNER
;
3849 dprintk("%s: uid=%d\n", __func__
, (int)from_kuid(&init_user_ns
, *uid
));
3852 print_overflow_msg(__func__
, xdr
);
3856 static int decode_attr_group(struct xdr_stream
*xdr
, uint32_t *bitmap
,
3857 const struct nfs_server
*server
, kgid_t
*gid
,
3858 struct nfs4_string
*group_name
)
3864 *gid
= make_kgid(&init_user_ns
, -2);
3865 if (unlikely(bitmap
[1] & (FATTR4_WORD1_OWNER_GROUP
- 1U)))
3867 if (likely(bitmap
[1] & FATTR4_WORD1_OWNER_GROUP
)) {
3868 p
= xdr_inline_decode(xdr
, 4);
3871 len
= be32_to_cpup(p
);
3872 p
= xdr_inline_decode(xdr
, len
);
3875 if (group_name
!= NULL
) {
3876 group_name
->data
= kmemdup(p
, len
, GFP_NOWAIT
);
3877 if (group_name
->data
!= NULL
) {
3878 group_name
->len
= len
;
3879 ret
= NFS_ATTR_FATTR_GROUP_NAME
;
3881 } else if (len
< XDR_MAX_NETOBJ
) {
3882 if (nfs_map_group_to_gid(server
, (char *)p
, len
, gid
) == 0)
3883 ret
= NFS_ATTR_FATTR_GROUP
;
3885 dprintk("%s: nfs_map_group_to_gid failed!\n",
3888 dprintk("%s: name too long (%u)!\n",
3890 bitmap
[1] &= ~FATTR4_WORD1_OWNER_GROUP
;
3892 dprintk("%s: gid=%d\n", __func__
, (int)from_kgid(&init_user_ns
, *gid
));
3895 print_overflow_msg(__func__
, xdr
);
3899 static int decode_attr_rdev(struct xdr_stream
*xdr
, uint32_t *bitmap
, dev_t
*rdev
)
3901 uint32_t major
= 0, minor
= 0;
3906 if (unlikely(bitmap
[1] & (FATTR4_WORD1_RAWDEV
- 1U)))
3908 if (likely(bitmap
[1] & FATTR4_WORD1_RAWDEV
)) {
3911 p
= xdr_inline_decode(xdr
, 8);
3914 major
= be32_to_cpup(p
++);
3915 minor
= be32_to_cpup(p
);
3916 tmp
= MKDEV(major
, minor
);
3917 if (MAJOR(tmp
) == major
&& MINOR(tmp
) == minor
)
3919 bitmap
[1] &= ~ FATTR4_WORD1_RAWDEV
;
3920 ret
= NFS_ATTR_FATTR_RDEV
;
3922 dprintk("%s: rdev=(0x%x:0x%x)\n", __func__
, major
, minor
);
3925 print_overflow_msg(__func__
, xdr
);
3929 static int decode_attr_space_avail(struct xdr_stream
*xdr
, uint32_t *bitmap
, uint64_t *res
)
3935 if (unlikely(bitmap
[1] & (FATTR4_WORD1_SPACE_AVAIL
- 1U)))
3937 if (likely(bitmap
[1] & FATTR4_WORD1_SPACE_AVAIL
)) {
3938 p
= xdr_inline_decode(xdr
, 8);
3941 xdr_decode_hyper(p
, res
);
3942 bitmap
[1] &= ~FATTR4_WORD1_SPACE_AVAIL
;
3944 dprintk("%s: space avail=%Lu\n", __func__
, (unsigned long long)*res
);
3947 print_overflow_msg(__func__
, xdr
);
3951 static int decode_attr_space_free(struct xdr_stream
*xdr
, uint32_t *bitmap
, uint64_t *res
)
3957 if (unlikely(bitmap
[1] & (FATTR4_WORD1_SPACE_FREE
- 1U)))
3959 if (likely(bitmap
[1] & FATTR4_WORD1_SPACE_FREE
)) {
3960 p
= xdr_inline_decode(xdr
, 8);
3963 xdr_decode_hyper(p
, res
);
3964 bitmap
[1] &= ~FATTR4_WORD1_SPACE_FREE
;
3966 dprintk("%s: space free=%Lu\n", __func__
, (unsigned long long)*res
);
3969 print_overflow_msg(__func__
, xdr
);
3973 static int decode_attr_space_total(struct xdr_stream
*xdr
, uint32_t *bitmap
, uint64_t *res
)
3979 if (unlikely(bitmap
[1] & (FATTR4_WORD1_SPACE_TOTAL
- 1U)))
3981 if (likely(bitmap
[1] & FATTR4_WORD1_SPACE_TOTAL
)) {
3982 p
= xdr_inline_decode(xdr
, 8);
3985 xdr_decode_hyper(p
, res
);
3986 bitmap
[1] &= ~FATTR4_WORD1_SPACE_TOTAL
;
3988 dprintk("%s: space total=%Lu\n", __func__
, (unsigned long long)*res
);
3991 print_overflow_msg(__func__
, xdr
);
3995 static int decode_attr_space_used(struct xdr_stream
*xdr
, uint32_t *bitmap
, uint64_t *used
)
4001 if (unlikely(bitmap
[1] & (FATTR4_WORD1_SPACE_USED
- 1U)))
4003 if (likely(bitmap
[1] & FATTR4_WORD1_SPACE_USED
)) {
4004 p
= xdr_inline_decode(xdr
, 8);
4007 xdr_decode_hyper(p
, used
);
4008 bitmap
[1] &= ~FATTR4_WORD1_SPACE_USED
;
4009 ret
= NFS_ATTR_FATTR_SPACE_USED
;
4011 dprintk("%s: space used=%Lu\n", __func__
,
4012 (unsigned long long)*used
);
4015 print_overflow_msg(__func__
, xdr
);
4019 static int decode_attr_time(struct xdr_stream
*xdr
, struct timespec
*time
)
4025 p
= xdr_inline_decode(xdr
, 12);
4028 p
= xdr_decode_hyper(p
, &sec
);
4029 nsec
= be32_to_cpup(p
);
4030 time
->tv_sec
= (time_t)sec
;
4031 time
->tv_nsec
= (long)nsec
;
4034 print_overflow_msg(__func__
, xdr
);
4038 static int decode_attr_time_access(struct xdr_stream
*xdr
, uint32_t *bitmap
, struct timespec
*time
)
4044 if (unlikely(bitmap
[1] & (FATTR4_WORD1_TIME_ACCESS
- 1U)))
4046 if (likely(bitmap
[1] & FATTR4_WORD1_TIME_ACCESS
)) {
4047 status
= decode_attr_time(xdr
, time
);
4049 status
= NFS_ATTR_FATTR_ATIME
;
4050 bitmap
[1] &= ~FATTR4_WORD1_TIME_ACCESS
;
4052 dprintk("%s: atime=%ld\n", __func__
, (long)time
->tv_sec
);
4056 static int decode_attr_time_metadata(struct xdr_stream
*xdr
, uint32_t *bitmap
, struct timespec
*time
)
4062 if (unlikely(bitmap
[1] & (FATTR4_WORD1_TIME_METADATA
- 1U)))
4064 if (likely(bitmap
[1] & FATTR4_WORD1_TIME_METADATA
)) {
4065 status
= decode_attr_time(xdr
, time
);
4067 status
= NFS_ATTR_FATTR_CTIME
;
4068 bitmap
[1] &= ~FATTR4_WORD1_TIME_METADATA
;
4070 dprintk("%s: ctime=%ld\n", __func__
, (long)time
->tv_sec
);
4074 static int decode_attr_time_delta(struct xdr_stream
*xdr
, uint32_t *bitmap
,
4075 struct timespec
*time
)
4081 if (unlikely(bitmap
[1] & (FATTR4_WORD1_TIME_DELTA
- 1U)))
4083 if (likely(bitmap
[1] & FATTR4_WORD1_TIME_DELTA
)) {
4084 status
= decode_attr_time(xdr
, time
);
4085 bitmap
[1] &= ~FATTR4_WORD1_TIME_DELTA
;
4087 dprintk("%s: time_delta=%ld %ld\n", __func__
, (long)time
->tv_sec
,
4088 (long)time
->tv_nsec
);
4092 static int decode_attr_security_label(struct xdr_stream
*xdr
, uint32_t *bitmap
,
4093 struct nfs4_label
*label
)
4101 if (unlikely(bitmap
[2] & (FATTR4_WORD2_SECURITY_LABEL
- 1U)))
4103 if (likely(bitmap
[2] & FATTR4_WORD2_SECURITY_LABEL
)) {
4104 p
= xdr_inline_decode(xdr
, 4);
4107 lfs
= be32_to_cpup(p
++);
4108 p
= xdr_inline_decode(xdr
, 4);
4111 pi
= be32_to_cpup(p
++);
4112 p
= xdr_inline_decode(xdr
, 4);
4115 len
= be32_to_cpup(p
++);
4116 p
= xdr_inline_decode(xdr
, len
);
4119 if (len
< NFS4_MAXLABELLEN
) {
4121 memcpy(label
->label
, p
, len
);
4125 status
= NFS_ATTR_FATTR_V4_SECURITY_LABEL
;
4127 bitmap
[2] &= ~FATTR4_WORD2_SECURITY_LABEL
;
4129 printk(KERN_WARNING
"%s: label too long (%u)!\n",
4132 if (label
&& label
->label
)
4133 dprintk("%s: label=%s, len=%d, PI=%d, LFS=%d\n", __func__
,
4134 (char *)label
->label
, label
->len
, label
->pi
, label
->lfs
);
4138 print_overflow_msg(__func__
, xdr
);
4142 static int decode_attr_time_modify(struct xdr_stream
*xdr
, uint32_t *bitmap
, struct timespec
*time
)
4148 if (unlikely(bitmap
[1] & (FATTR4_WORD1_TIME_MODIFY
- 1U)))
4150 if (likely(bitmap
[1] & FATTR4_WORD1_TIME_MODIFY
)) {
4151 status
= decode_attr_time(xdr
, time
);
4153 status
= NFS_ATTR_FATTR_MTIME
;
4154 bitmap
[1] &= ~FATTR4_WORD1_TIME_MODIFY
;
4156 dprintk("%s: mtime=%ld\n", __func__
, (long)time
->tv_sec
);
4160 static int verify_attr_len(struct xdr_stream
*xdr
, unsigned int savep
, uint32_t attrlen
)
4162 unsigned int attrwords
= XDR_QUADLEN(attrlen
);
4163 unsigned int nwords
= (xdr_stream_pos(xdr
) - savep
) >> 2;
4165 if (unlikely(attrwords
!= nwords
)) {
4166 dprintk("%s: server returned incorrect attribute length: "
4170 (attrwords
< nwords
) ? '<' : '>',
4177 static int decode_change_info(struct xdr_stream
*xdr
, struct nfs4_change_info
*cinfo
)
4181 p
= xdr_inline_decode(xdr
, 20);
4184 cinfo
->atomic
= be32_to_cpup(p
++);
4185 p
= xdr_decode_hyper(p
, &cinfo
->before
);
4186 xdr_decode_hyper(p
, &cinfo
->after
);
4189 print_overflow_msg(__func__
, xdr
);
4193 static int decode_access(struct xdr_stream
*xdr
, u32
*supported
, u32
*access
)
4199 status
= decode_op_hdr(xdr
, OP_ACCESS
);
4202 p
= xdr_inline_decode(xdr
, 8);
4205 supp
= be32_to_cpup(p
++);
4206 acc
= be32_to_cpup(p
);
4211 print_overflow_msg(__func__
, xdr
);
4215 static int decode_opaque_fixed(struct xdr_stream
*xdr
, void *buf
, size_t len
)
4219 p
= xdr_inline_decode(xdr
, len
);
4221 memcpy(buf
, p
, len
);
4224 print_overflow_msg(__func__
, xdr
);
4228 static int decode_stateid(struct xdr_stream
*xdr
, nfs4_stateid
*stateid
)
4230 return decode_opaque_fixed(xdr
, stateid
, NFS4_STATEID_SIZE
);
4233 static int decode_close(struct xdr_stream
*xdr
, struct nfs_closeres
*res
)
4237 status
= decode_op_hdr(xdr
, OP_CLOSE
);
4239 nfs_increment_open_seqid(status
, res
->seqid
);
4241 status
= decode_stateid(xdr
, &res
->stateid
);
4245 static int decode_verifier(struct xdr_stream
*xdr
, void *verifier
)
4247 return decode_opaque_fixed(xdr
, verifier
, NFS4_VERIFIER_SIZE
);
4250 static int decode_write_verifier(struct xdr_stream
*xdr
, struct nfs_write_verifier
*verifier
)
4252 return decode_opaque_fixed(xdr
, verifier
->data
, NFS4_VERIFIER_SIZE
);
4255 static int decode_commit(struct xdr_stream
*xdr
, struct nfs_commitres
*res
)
4259 status
= decode_op_hdr(xdr
, OP_COMMIT
);
4261 status
= decode_write_verifier(xdr
, &res
->verf
->verifier
);
4265 static int decode_create(struct xdr_stream
*xdr
, struct nfs4_change_info
*cinfo
)
4271 status
= decode_op_hdr(xdr
, OP_CREATE
);
4274 if ((status
= decode_change_info(xdr
, cinfo
)))
4276 p
= xdr_inline_decode(xdr
, 4);
4279 bmlen
= be32_to_cpup(p
);
4280 p
= xdr_inline_decode(xdr
, bmlen
<< 2);
4284 print_overflow_msg(__func__
, xdr
);
4288 static int decode_server_caps(struct xdr_stream
*xdr
, struct nfs4_server_caps_res
*res
)
4291 uint32_t attrlen
, bitmap
[3] = {0};
4294 if ((status
= decode_op_hdr(xdr
, OP_GETATTR
)) != 0)
4296 if ((status
= decode_attr_bitmap(xdr
, bitmap
)) != 0)
4298 if ((status
= decode_attr_length(xdr
, &attrlen
, &savep
)) != 0)
4300 if ((status
= decode_attr_supported(xdr
, bitmap
, res
->attr_bitmask
)) != 0)
4302 if ((status
= decode_attr_fh_expire_type(xdr
, bitmap
,
4303 &res
->fh_expire_type
)) != 0)
4305 if ((status
= decode_attr_link_support(xdr
, bitmap
, &res
->has_links
)) != 0)
4307 if ((status
= decode_attr_symlink_support(xdr
, bitmap
, &res
->has_symlinks
)) != 0)
4309 if ((status
= decode_attr_aclsupport(xdr
, bitmap
, &res
->acl_bitmask
)) != 0)
4311 status
= verify_attr_len(xdr
, savep
, attrlen
);
4313 dprintk("%s: xdr returned %d!\n", __func__
, -status
);
4317 static int decode_statfs(struct xdr_stream
*xdr
, struct nfs_fsstat
*fsstat
)
4320 uint32_t attrlen
, bitmap
[3] = {0};
4323 if ((status
= decode_op_hdr(xdr
, OP_GETATTR
)) != 0)
4325 if ((status
= decode_attr_bitmap(xdr
, bitmap
)) != 0)
4327 if ((status
= decode_attr_length(xdr
, &attrlen
, &savep
)) != 0)
4330 if ((status
= decode_attr_files_avail(xdr
, bitmap
, &fsstat
->afiles
)) != 0)
4332 if ((status
= decode_attr_files_free(xdr
, bitmap
, &fsstat
->ffiles
)) != 0)
4334 if ((status
= decode_attr_files_total(xdr
, bitmap
, &fsstat
->tfiles
)) != 0)
4336 if ((status
= decode_attr_space_avail(xdr
, bitmap
, &fsstat
->abytes
)) != 0)
4338 if ((status
= decode_attr_space_free(xdr
, bitmap
, &fsstat
->fbytes
)) != 0)
4340 if ((status
= decode_attr_space_total(xdr
, bitmap
, &fsstat
->tbytes
)) != 0)
4343 status
= verify_attr_len(xdr
, savep
, attrlen
);
4345 dprintk("%s: xdr returned %d!\n", __func__
, -status
);
4349 static int decode_pathconf(struct xdr_stream
*xdr
, struct nfs_pathconf
*pathconf
)
4352 uint32_t attrlen
, bitmap
[3] = {0};
4355 if ((status
= decode_op_hdr(xdr
, OP_GETATTR
)) != 0)
4357 if ((status
= decode_attr_bitmap(xdr
, bitmap
)) != 0)
4359 if ((status
= decode_attr_length(xdr
, &attrlen
, &savep
)) != 0)
4362 if ((status
= decode_attr_maxlink(xdr
, bitmap
, &pathconf
->max_link
)) != 0)
4364 if ((status
= decode_attr_maxname(xdr
, bitmap
, &pathconf
->max_namelen
)) != 0)
4367 status
= verify_attr_len(xdr
, savep
, attrlen
);
4369 dprintk("%s: xdr returned %d!\n", __func__
, -status
);
4373 static int decode_threshold_hint(struct xdr_stream
*xdr
,
4381 if (likely(bitmap
[0] & hint_bit
)) {
4382 p
= xdr_inline_decode(xdr
, 8);
4385 xdr_decode_hyper(p
, res
);
4389 print_overflow_msg(__func__
, xdr
);
4393 static int decode_first_threshold_item4(struct xdr_stream
*xdr
,
4394 struct nfs4_threshold
*res
)
4398 uint32_t bitmap
[3] = {0,}, attrlen
;
4402 p
= xdr_inline_decode(xdr
, 4);
4404 print_overflow_msg(__func__
, xdr
);
4407 res
->l_type
= be32_to_cpup(p
);
4409 /* thi_hintset bitmap */
4410 status
= decode_attr_bitmap(xdr
, bitmap
);
4414 /* thi_hintlist length */
4415 status
= decode_attr_length(xdr
, &attrlen
, &savep
);
4419 status
= decode_threshold_hint(xdr
, bitmap
, &res
->rd_sz
, THRESHOLD_RD
);
4422 status
= decode_threshold_hint(xdr
, bitmap
, &res
->wr_sz
, THRESHOLD_WR
);
4425 status
= decode_threshold_hint(xdr
, bitmap
, &res
->rd_io_sz
,
4429 status
= decode_threshold_hint(xdr
, bitmap
, &res
->wr_io_sz
,
4434 status
= verify_attr_len(xdr
, savep
, attrlen
);
4435 res
->bm
= bitmap
[0];
4437 dprintk("%s bm=0x%x rd_sz=%llu wr_sz=%llu rd_io=%llu wr_io=%llu\n",
4438 __func__
, res
->bm
, res
->rd_sz
, res
->wr_sz
, res
->rd_io_sz
,
4441 dprintk("%s ret=%d!\n", __func__
, status
);
4446 * Thresholds on pNFS direct I/O vrs MDS I/O
4448 static int decode_attr_mdsthreshold(struct xdr_stream
*xdr
,
4450 struct nfs4_threshold
*res
)
4456 if (unlikely(bitmap
[2] & (FATTR4_WORD2_MDSTHRESHOLD
- 1U)))
4458 if (bitmap
[2] & FATTR4_WORD2_MDSTHRESHOLD
) {
4459 /* Did the server return an unrequested attribute? */
4460 if (unlikely(res
== NULL
))
4462 p
= xdr_inline_decode(xdr
, 4);
4465 num
= be32_to_cpup(p
);
4469 printk(KERN_INFO
"%s: Warning: Multiple pNFS layout "
4470 "drivers per filesystem not supported\n",
4473 status
= decode_first_threshold_item4(xdr
, res
);
4474 bitmap
[2] &= ~FATTR4_WORD2_MDSTHRESHOLD
;
4478 print_overflow_msg(__func__
, xdr
);
4482 static int decode_getfattr_attrs(struct xdr_stream
*xdr
, uint32_t *bitmap
,
4483 struct nfs_fattr
*fattr
, struct nfs_fh
*fh
,
4484 struct nfs4_fs_locations
*fs_loc
, struct nfs4_label
*label
,
4485 const struct nfs_server
*server
)
4492 status
= decode_attr_type(xdr
, bitmap
, &type
);
4497 fattr
->mode
|= nfs_type2fmt
[type
];
4498 fattr
->valid
|= status
;
4501 status
= decode_attr_change(xdr
, bitmap
, &fattr
->change_attr
);
4504 fattr
->valid
|= status
;
4506 status
= decode_attr_size(xdr
, bitmap
, &fattr
->size
);
4509 fattr
->valid
|= status
;
4511 status
= decode_attr_fsid(xdr
, bitmap
, &fattr
->fsid
);
4514 fattr
->valid
|= status
;
4517 status
= decode_attr_error(xdr
, bitmap
, &err
);
4521 status
= decode_attr_filehandle(xdr
, bitmap
, fh
);
4525 status
= decode_attr_fileid(xdr
, bitmap
, &fattr
->fileid
);
4528 fattr
->valid
|= status
;
4530 status
= decode_attr_fs_locations(xdr
, bitmap
, fs_loc
);
4533 fattr
->valid
|= status
;
4535 status
= decode_attr_mode(xdr
, bitmap
, &fmode
);
4539 fattr
->mode
|= fmode
;
4540 fattr
->valid
|= status
;
4543 status
= decode_attr_nlink(xdr
, bitmap
, &fattr
->nlink
);
4546 fattr
->valid
|= status
;
4548 status
= decode_attr_owner(xdr
, bitmap
, server
, &fattr
->uid
, fattr
->owner_name
);
4551 fattr
->valid
|= status
;
4553 status
= decode_attr_group(xdr
, bitmap
, server
, &fattr
->gid
, fattr
->group_name
);
4556 fattr
->valid
|= status
;
4558 status
= decode_attr_rdev(xdr
, bitmap
, &fattr
->rdev
);
4561 fattr
->valid
|= status
;
4563 status
= decode_attr_space_used(xdr
, bitmap
, &fattr
->du
.nfs3
.used
);
4566 fattr
->valid
|= status
;
4568 status
= decode_attr_time_access(xdr
, bitmap
, &fattr
->atime
);
4571 fattr
->valid
|= status
;
4573 status
= decode_attr_time_metadata(xdr
, bitmap
, &fattr
->ctime
);
4576 fattr
->valid
|= status
;
4578 status
= decode_attr_time_modify(xdr
, bitmap
, &fattr
->mtime
);
4581 fattr
->valid
|= status
;
4583 status
= decode_attr_mounted_on_fileid(xdr
, bitmap
, &fattr
->mounted_on_fileid
);
4586 fattr
->valid
|= status
;
4588 status
= decode_attr_mdsthreshold(xdr
, bitmap
, fattr
->mdsthreshold
);
4593 status
= decode_attr_security_label(xdr
, bitmap
, label
);
4596 fattr
->valid
|= status
;
4600 dprintk("%s: xdr returned %d\n", __func__
, -status
);
4604 static int decode_getfattr_generic(struct xdr_stream
*xdr
, struct nfs_fattr
*fattr
,
4605 struct nfs_fh
*fh
, struct nfs4_fs_locations
*fs_loc
,
4606 struct nfs4_label
*label
, const struct nfs_server
*server
)
4613 status
= decode_op_hdr(xdr
, OP_GETATTR
);
4617 status
= decode_attr_bitmap(xdr
, bitmap
);
4621 status
= decode_attr_length(xdr
, &attrlen
, &savep
);
4625 status
= decode_getfattr_attrs(xdr
, bitmap
, fattr
, fh
, fs_loc
,
4630 status
= verify_attr_len(xdr
, savep
, attrlen
);
4632 dprintk("%s: xdr returned %d\n", __func__
, -status
);
4636 static int decode_getfattr_label(struct xdr_stream
*xdr
, struct nfs_fattr
*fattr
,
4637 struct nfs4_label
*label
, const struct nfs_server
*server
)
4639 return decode_getfattr_generic(xdr
, fattr
, NULL
, NULL
, label
, server
);
4642 static int decode_getfattr(struct xdr_stream
*xdr
, struct nfs_fattr
*fattr
,
4643 const struct nfs_server
*server
)
4645 return decode_getfattr_generic(xdr
, fattr
, NULL
, NULL
, NULL
, server
);
4649 * Decode potentially multiple layout types. Currently we only support
4650 * one layout driver per file system.
4652 static int decode_first_pnfs_layout_type(struct xdr_stream
*xdr
,
4653 uint32_t *layouttype
)
4658 p
= xdr_inline_decode(xdr
, 4);
4661 num
= be32_to_cpup(p
);
4663 /* pNFS is not supported by the underlying file system */
4669 printk(KERN_INFO
"NFS: %s: Warning: Multiple pNFS layout "
4670 "drivers per filesystem not supported\n", __func__
);
4672 /* Decode and set first layout type, move xdr->p past unused types */
4673 p
= xdr_inline_decode(xdr
, num
* 4);
4676 *layouttype
= be32_to_cpup(p
);
4679 print_overflow_msg(__func__
, xdr
);
4684 * The type of file system exported.
4685 * Note we must ensure that layouttype is set in any non-error case.
4687 static int decode_attr_pnfstype(struct xdr_stream
*xdr
, uint32_t *bitmap
,
4688 uint32_t *layouttype
)
4692 dprintk("%s: bitmap is %x\n", __func__
, bitmap
[1]);
4693 if (unlikely(bitmap
[1] & (FATTR4_WORD1_FS_LAYOUT_TYPES
- 1U)))
4695 if (bitmap
[1] & FATTR4_WORD1_FS_LAYOUT_TYPES
) {
4696 status
= decode_first_pnfs_layout_type(xdr
, layouttype
);
4697 bitmap
[1] &= ~FATTR4_WORD1_FS_LAYOUT_TYPES
;
4704 * The prefered block size for layout directed io
4706 static int decode_attr_layout_blksize(struct xdr_stream
*xdr
, uint32_t *bitmap
,
4711 dprintk("%s: bitmap is %x\n", __func__
, bitmap
[2]);
4713 if (bitmap
[2] & FATTR4_WORD2_LAYOUT_BLKSIZE
) {
4714 p
= xdr_inline_decode(xdr
, 4);
4716 print_overflow_msg(__func__
, xdr
);
4719 *res
= be32_to_cpup(p
);
4720 bitmap
[2] &= ~FATTR4_WORD2_LAYOUT_BLKSIZE
;
4725 static int decode_fsinfo(struct xdr_stream
*xdr
, struct nfs_fsinfo
*fsinfo
)
4728 uint32_t attrlen
, bitmap
[3];
4731 if ((status
= decode_op_hdr(xdr
, OP_GETATTR
)) != 0)
4733 if ((status
= decode_attr_bitmap(xdr
, bitmap
)) != 0)
4735 if ((status
= decode_attr_length(xdr
, &attrlen
, &savep
)) != 0)
4738 fsinfo
->rtmult
= fsinfo
->wtmult
= 512; /* ??? */
4740 if ((status
= decode_attr_lease_time(xdr
, bitmap
, &fsinfo
->lease_time
)) != 0)
4742 if ((status
= decode_attr_maxfilesize(xdr
, bitmap
, &fsinfo
->maxfilesize
)) != 0)
4744 if ((status
= decode_attr_maxread(xdr
, bitmap
, &fsinfo
->rtmax
)) != 0)
4746 fsinfo
->rtpref
= fsinfo
->dtpref
= fsinfo
->rtmax
;
4747 if ((status
= decode_attr_maxwrite(xdr
, bitmap
, &fsinfo
->wtmax
)) != 0)
4749 fsinfo
->wtpref
= fsinfo
->wtmax
;
4750 status
= decode_attr_time_delta(xdr
, bitmap
, &fsinfo
->time_delta
);
4753 status
= decode_attr_pnfstype(xdr
, bitmap
, &fsinfo
->layouttype
);
4756 status
= decode_attr_layout_blksize(xdr
, bitmap
, &fsinfo
->blksize
);
4760 status
= verify_attr_len(xdr
, savep
, attrlen
);
4762 dprintk("%s: xdr returned %d!\n", __func__
, -status
);
4766 static int decode_getfh(struct xdr_stream
*xdr
, struct nfs_fh
*fh
)
4772 /* Zero handle first to allow comparisons */
4773 memset(fh
, 0, sizeof(*fh
));
4775 status
= decode_op_hdr(xdr
, OP_GETFH
);
4779 p
= xdr_inline_decode(xdr
, 4);
4782 len
= be32_to_cpup(p
);
4783 if (len
> NFS4_FHSIZE
)
4786 p
= xdr_inline_decode(xdr
, len
);
4789 memcpy(fh
->data
, p
, len
);
4792 print_overflow_msg(__func__
, xdr
);
4796 static int decode_link(struct xdr_stream
*xdr
, struct nfs4_change_info
*cinfo
)
4800 status
= decode_op_hdr(xdr
, OP_LINK
);
4803 return decode_change_info(xdr
, cinfo
);
4807 * We create the owner, so we know a proper owner.id length is 4.
4809 static int decode_lock_denied (struct xdr_stream
*xdr
, struct file_lock
*fl
)
4811 uint64_t offset
, length
, clientid
;
4813 uint32_t namelen
, type
;
4815 p
= xdr_inline_decode(xdr
, 32); /* read 32 bytes */
4818 p
= xdr_decode_hyper(p
, &offset
); /* read 2 8-byte long words */
4819 p
= xdr_decode_hyper(p
, &length
);
4820 type
= be32_to_cpup(p
++); /* 4 byte read */
4821 if (fl
!= NULL
) { /* manipulate file lock */
4822 fl
->fl_start
= (loff_t
)offset
;
4823 fl
->fl_end
= fl
->fl_start
+ (loff_t
)length
- 1;
4824 if (length
== ~(uint64_t)0)
4825 fl
->fl_end
= OFFSET_MAX
;
4826 fl
->fl_type
= F_WRLCK
;
4828 fl
->fl_type
= F_RDLCK
;
4831 p
= xdr_decode_hyper(p
, &clientid
); /* read 8 bytes */
4832 namelen
= be32_to_cpup(p
); /* read 4 bytes */ /* have read all 32 bytes now */
4833 p
= xdr_inline_decode(xdr
, namelen
); /* variable size field */
4835 return -NFS4ERR_DENIED
;
4837 print_overflow_msg(__func__
, xdr
);
4841 static int decode_lock(struct xdr_stream
*xdr
, struct nfs_lock_res
*res
)
4845 status
= decode_op_hdr(xdr
, OP_LOCK
);
4849 status
= decode_stateid(xdr
, &res
->stateid
);
4850 if (unlikely(status
))
4852 } else if (status
== -NFS4ERR_DENIED
)
4853 status
= decode_lock_denied(xdr
, NULL
);
4854 if (res
->open_seqid
!= NULL
)
4855 nfs_increment_open_seqid(status
, res
->open_seqid
);
4856 nfs_increment_lock_seqid(status
, res
->lock_seqid
);
4861 static int decode_lockt(struct xdr_stream
*xdr
, struct nfs_lockt_res
*res
)
4864 status
= decode_op_hdr(xdr
, OP_LOCKT
);
4865 if (status
== -NFS4ERR_DENIED
)
4866 return decode_lock_denied(xdr
, res
->denied
);
4870 static int decode_locku(struct xdr_stream
*xdr
, struct nfs_locku_res
*res
)
4874 status
= decode_op_hdr(xdr
, OP_LOCKU
);
4876 nfs_increment_lock_seqid(status
, res
->seqid
);
4878 status
= decode_stateid(xdr
, &res
->stateid
);
4882 static int decode_release_lockowner(struct xdr_stream
*xdr
)
4884 return decode_op_hdr(xdr
, OP_RELEASE_LOCKOWNER
);
4887 static int decode_lookup(struct xdr_stream
*xdr
)
4889 return decode_op_hdr(xdr
, OP_LOOKUP
);
4892 /* This is too sick! */
4893 static int decode_space_limit(struct xdr_stream
*xdr
, u64
*maxsize
)
4896 uint32_t limit_type
, nblocks
, blocksize
;
4898 p
= xdr_inline_decode(xdr
, 12);
4901 limit_type
= be32_to_cpup(p
++);
4902 switch (limit_type
) {
4904 xdr_decode_hyper(p
, maxsize
);
4907 nblocks
= be32_to_cpup(p
++);
4908 blocksize
= be32_to_cpup(p
);
4909 *maxsize
= (uint64_t)nblocks
* (uint64_t)blocksize
;
4913 print_overflow_msg(__func__
, xdr
);
4917 static int decode_delegation(struct xdr_stream
*xdr
, struct nfs_openres
*res
)
4920 uint32_t delegation_type
;
4923 p
= xdr_inline_decode(xdr
, 4);
4926 delegation_type
= be32_to_cpup(p
);
4927 if (delegation_type
== NFS4_OPEN_DELEGATE_NONE
) {
4928 res
->delegation_type
= 0;
4931 status
= decode_stateid(xdr
, &res
->delegation
);
4932 if (unlikely(status
))
4934 p
= xdr_inline_decode(xdr
, 4);
4937 res
->do_recall
= be32_to_cpup(p
);
4939 switch (delegation_type
) {
4940 case NFS4_OPEN_DELEGATE_READ
:
4941 res
->delegation_type
= FMODE_READ
;
4943 case NFS4_OPEN_DELEGATE_WRITE
:
4944 res
->delegation_type
= FMODE_WRITE
|FMODE_READ
;
4945 if (decode_space_limit(xdr
, &res
->maxsize
) < 0)
4948 return decode_ace(xdr
, NULL
, res
->server
->nfs_client
);
4950 print_overflow_msg(__func__
, xdr
);
4954 static int decode_open(struct xdr_stream
*xdr
, struct nfs_openres
*res
)
4957 uint32_t savewords
, bmlen
, i
;
4960 status
= decode_op_hdr(xdr
, OP_OPEN
);
4962 nfs_increment_open_seqid(status
, res
->seqid
);
4964 status
= decode_stateid(xdr
, &res
->stateid
);
4965 if (unlikely(status
))
4968 decode_change_info(xdr
, &res
->cinfo
);
4970 p
= xdr_inline_decode(xdr
, 8);
4973 res
->rflags
= be32_to_cpup(p
++);
4974 bmlen
= be32_to_cpup(p
);
4978 p
= xdr_inline_decode(xdr
, bmlen
<< 2);
4981 savewords
= min_t(uint32_t, bmlen
, NFS4_BITMAP_SIZE
);
4982 for (i
= 0; i
< savewords
; ++i
)
4983 res
->attrset
[i
] = be32_to_cpup(p
++);
4984 for (; i
< NFS4_BITMAP_SIZE
; i
++)
4985 res
->attrset
[i
] = 0;
4987 return decode_delegation(xdr
, res
);
4989 dprintk("%s: Bitmap too large! Length = %u\n", __func__
, bmlen
);
4992 print_overflow_msg(__func__
, xdr
);
4996 static int decode_open_confirm(struct xdr_stream
*xdr
, struct nfs_open_confirmres
*res
)
5000 status
= decode_op_hdr(xdr
, OP_OPEN_CONFIRM
);
5002 nfs_increment_open_seqid(status
, res
->seqid
);
5004 status
= decode_stateid(xdr
, &res
->stateid
);
5008 static int decode_open_downgrade(struct xdr_stream
*xdr
, struct nfs_closeres
*res
)
5012 status
= decode_op_hdr(xdr
, OP_OPEN_DOWNGRADE
);
5014 nfs_increment_open_seqid(status
, res
->seqid
);
5016 status
= decode_stateid(xdr
, &res
->stateid
);
5020 static int decode_putfh(struct xdr_stream
*xdr
)
5022 return decode_op_hdr(xdr
, OP_PUTFH
);
5025 static int decode_putrootfh(struct xdr_stream
*xdr
)
5027 return decode_op_hdr(xdr
, OP_PUTROOTFH
);
5030 static int decode_read(struct xdr_stream
*xdr
, struct rpc_rqst
*req
, struct nfs_readres
*res
)
5033 uint32_t count
, eof
, recvd
;
5036 status
= decode_op_hdr(xdr
, OP_READ
);
5039 p
= xdr_inline_decode(xdr
, 8);
5042 eof
= be32_to_cpup(p
++);
5043 count
= be32_to_cpup(p
);
5044 recvd
= xdr_read_pages(xdr
, count
);
5045 if (count
> recvd
) {
5046 dprintk("NFS: server cheating in read reply: "
5047 "count %u > recvd %u\n", count
, recvd
);
5055 print_overflow_msg(__func__
, xdr
);
5059 static int decode_readdir(struct xdr_stream
*xdr
, struct rpc_rqst
*req
, struct nfs4_readdir_res
*readdir
)
5064 status
= decode_op_hdr(xdr
, OP_READDIR
);
5066 status
= decode_verifier(xdr
, readdir
->verifier
.data
);
5067 if (unlikely(status
))
5069 memcpy(verf
, readdir
->verifier
.data
, sizeof(verf
));
5070 dprintk("%s: verifier = %08x:%08x\n",
5071 __func__
, verf
[0], verf
[1]);
5072 return xdr_read_pages(xdr
, xdr
->buf
->page_len
);
5075 static int decode_readlink(struct xdr_stream
*xdr
, struct rpc_rqst
*req
)
5077 struct xdr_buf
*rcvbuf
= &req
->rq_rcv_buf
;
5082 status
= decode_op_hdr(xdr
, OP_READLINK
);
5086 /* Convert length of symlink */
5087 p
= xdr_inline_decode(xdr
, 4);
5090 len
= be32_to_cpup(p
);
5091 if (len
>= rcvbuf
->page_len
|| len
<= 0) {
5092 dprintk("nfs: server returned giant symlink!\n");
5093 return -ENAMETOOLONG
;
5095 recvd
= xdr_read_pages(xdr
, len
);
5097 dprintk("NFS: server cheating in readlink reply: "
5098 "count %u > recvd %u\n", len
, recvd
);
5102 * The XDR encode routine has set things up so that
5103 * the link text will be copied directly into the
5104 * buffer. We just have to do overflow-checking,
5105 * and and null-terminate the text (the VFS expects
5106 * null-termination).
5108 xdr_terminate_string(rcvbuf
, len
);
5111 print_overflow_msg(__func__
, xdr
);
5115 static int decode_remove(struct xdr_stream
*xdr
, struct nfs4_change_info
*cinfo
)
5119 status
= decode_op_hdr(xdr
, OP_REMOVE
);
5122 status
= decode_change_info(xdr
, cinfo
);
5127 static int decode_rename(struct xdr_stream
*xdr
, struct nfs4_change_info
*old_cinfo
,
5128 struct nfs4_change_info
*new_cinfo
)
5132 status
= decode_op_hdr(xdr
, OP_RENAME
);
5135 if ((status
= decode_change_info(xdr
, old_cinfo
)))
5137 status
= decode_change_info(xdr
, new_cinfo
);
5142 static int decode_renew(struct xdr_stream
*xdr
)
5144 return decode_op_hdr(xdr
, OP_RENEW
);
5148 decode_restorefh(struct xdr_stream
*xdr
)
5150 return decode_op_hdr(xdr
, OP_RESTOREFH
);
5153 static int decode_getacl(struct xdr_stream
*xdr
, struct rpc_rqst
*req
,
5154 struct nfs_getaclres
*res
)
5160 unsigned int pg_offset
;
5163 if ((status
= decode_op_hdr(xdr
, OP_GETATTR
)) != 0)
5166 xdr_enter_page(xdr
, xdr
->buf
->page_len
);
5168 /* Calculate the offset of the page data */
5169 pg_offset
= xdr
->buf
->head
[0].iov_len
;
5171 if ((status
= decode_attr_bitmap(xdr
, bitmap
)) != 0)
5173 if ((status
= decode_attr_length(xdr
, &attrlen
, &savep
)) != 0)
5176 if (unlikely(bitmap
[0] & (FATTR4_WORD0_ACL
- 1U)))
5178 if (likely(bitmap
[0] & FATTR4_WORD0_ACL
)) {
5180 /* The bitmap (xdr len + bitmaps) and the attr xdr len words
5181 * are stored with the acl data to handle the problem of
5182 * variable length bitmaps.*/
5183 res
->acl_data_offset
= xdr_stream_pos(xdr
) - pg_offset
;
5184 res
->acl_len
= attrlen
;
5186 /* Check for receive buffer overflow */
5187 if (res
->acl_len
> (xdr
->nwords
<< 2) ||
5188 res
->acl_len
+ res
->acl_data_offset
> xdr
->buf
->page_len
) {
5189 res
->acl_flags
|= NFS4_ACL_TRUNC
;
5190 dprintk("NFS: acl reply: attrlen %u > page_len %u\n",
5191 attrlen
, xdr
->nwords
<< 2);
5194 status
= -EOPNOTSUPP
;
5201 decode_savefh(struct xdr_stream
*xdr
)
5203 return decode_op_hdr(xdr
, OP_SAVEFH
);
5206 static int decode_setattr(struct xdr_stream
*xdr
)
5212 status
= decode_op_hdr(xdr
, OP_SETATTR
);
5215 p
= xdr_inline_decode(xdr
, 4);
5218 bmlen
= be32_to_cpup(p
);
5219 p
= xdr_inline_decode(xdr
, bmlen
<< 2);
5223 print_overflow_msg(__func__
, xdr
);
5227 static int decode_setclientid(struct xdr_stream
*xdr
, struct nfs4_setclientid_res
*res
)
5233 p
= xdr_inline_decode(xdr
, 8);
5236 opnum
= be32_to_cpup(p
++);
5237 if (opnum
!= OP_SETCLIENTID
) {
5238 dprintk("nfs: decode_setclientid: Server returned operation"
5242 nfserr
= be32_to_cpup(p
);
5243 if (nfserr
== NFS_OK
) {
5244 p
= xdr_inline_decode(xdr
, 8 + NFS4_VERIFIER_SIZE
);
5247 p
= xdr_decode_hyper(p
, &res
->clientid
);
5248 memcpy(res
->confirm
.data
, p
, NFS4_VERIFIER_SIZE
);
5249 } else if (nfserr
== NFSERR_CLID_INUSE
) {
5252 /* skip netid string */
5253 p
= xdr_inline_decode(xdr
, 4);
5256 len
= be32_to_cpup(p
);
5257 p
= xdr_inline_decode(xdr
, len
);
5261 /* skip uaddr string */
5262 p
= xdr_inline_decode(xdr
, 4);
5265 len
= be32_to_cpup(p
);
5266 p
= xdr_inline_decode(xdr
, len
);
5269 return -NFSERR_CLID_INUSE
;
5271 return nfs4_stat_to_errno(nfserr
);
5275 print_overflow_msg(__func__
, xdr
);
5279 static int decode_setclientid_confirm(struct xdr_stream
*xdr
)
5281 return decode_op_hdr(xdr
, OP_SETCLIENTID_CONFIRM
);
5284 static int decode_write(struct xdr_stream
*xdr
, struct nfs_writeres
*res
)
5289 status
= decode_op_hdr(xdr
, OP_WRITE
);
5293 p
= xdr_inline_decode(xdr
, 8);
5296 res
->count
= be32_to_cpup(p
++);
5297 res
->verf
->committed
= be32_to_cpup(p
++);
5298 return decode_write_verifier(xdr
, &res
->verf
->verifier
);
5300 print_overflow_msg(__func__
, xdr
);
5304 static int decode_delegreturn(struct xdr_stream
*xdr
)
5306 return decode_op_hdr(xdr
, OP_DELEGRETURN
);
5309 static int decode_secinfo_gss(struct xdr_stream
*xdr
,
5310 struct nfs4_secinfo4
*flavor
)
5315 p
= xdr_inline_decode(xdr
, 4);
5318 oid_len
= be32_to_cpup(p
);
5319 if (oid_len
> GSS_OID_MAX_LEN
)
5322 p
= xdr_inline_decode(xdr
, oid_len
);
5325 memcpy(flavor
->flavor_info
.oid
.data
, p
, oid_len
);
5326 flavor
->flavor_info
.oid
.len
= oid_len
;
5328 p
= xdr_inline_decode(xdr
, 8);
5331 flavor
->flavor_info
.qop
= be32_to_cpup(p
++);
5332 flavor
->flavor_info
.service
= be32_to_cpup(p
);
5337 print_overflow_msg(__func__
, xdr
);
5343 static int decode_secinfo_common(struct xdr_stream
*xdr
, struct nfs4_secinfo_res
*res
)
5345 struct nfs4_secinfo4
*sec_flavor
;
5346 unsigned int i
, num_flavors
;
5350 p
= xdr_inline_decode(xdr
, 4);
5354 res
->flavors
->num_flavors
= 0;
5355 num_flavors
= be32_to_cpup(p
);
5357 for (i
= 0; i
< num_flavors
; i
++) {
5358 sec_flavor
= &res
->flavors
->flavors
[i
];
5359 if ((char *)&sec_flavor
[1] - (char *)res
->flavors
> PAGE_SIZE
)
5362 p
= xdr_inline_decode(xdr
, 4);
5365 sec_flavor
->flavor
= be32_to_cpup(p
);
5367 if (sec_flavor
->flavor
== RPC_AUTH_GSS
) {
5368 status
= decode_secinfo_gss(xdr
, sec_flavor
);
5372 res
->flavors
->num_flavors
++;
5379 print_overflow_msg(__func__
, xdr
);
5383 static int decode_secinfo(struct xdr_stream
*xdr
, struct nfs4_secinfo_res
*res
)
5385 int status
= decode_op_hdr(xdr
, OP_SECINFO
);
5388 return decode_secinfo_common(xdr
, res
);
5391 #if defined(CONFIG_NFS_V4_1)
5392 static int decode_secinfo_no_name(struct xdr_stream
*xdr
, struct nfs4_secinfo_res
*res
)
5394 int status
= decode_op_hdr(xdr
, OP_SECINFO_NO_NAME
);
5397 return decode_secinfo_common(xdr
, res
);
5400 static int decode_op_map(struct xdr_stream
*xdr
, struct nfs4_op_map
*op_map
)
5403 uint32_t bitmap_words
;
5406 p
= xdr_inline_decode(xdr
, 4);
5407 bitmap_words
= be32_to_cpup(p
++);
5408 if (bitmap_words
> NFS4_OP_MAP_NUM_WORDS
)
5410 p
= xdr_inline_decode(xdr
, 4 * bitmap_words
);
5411 for (i
= 0; i
< bitmap_words
; i
++)
5412 op_map
->u
.words
[i
] = be32_to_cpup(p
++);
5417 static int decode_exchange_id(struct xdr_stream
*xdr
,
5418 struct nfs41_exchange_id_res
*res
)
5424 uint32_t impl_id_count
;
5426 status
= decode_op_hdr(xdr
, OP_EXCHANGE_ID
);
5430 p
= xdr_inline_decode(xdr
, 8);
5433 xdr_decode_hyper(p
, &res
->clientid
);
5434 p
= xdr_inline_decode(xdr
, 12);
5437 res
->seqid
= be32_to_cpup(p
++);
5438 res
->flags
= be32_to_cpup(p
++);
5440 res
->state_protect
.how
= be32_to_cpup(p
);
5441 switch (res
->state_protect
.how
) {
5445 status
= decode_op_map(xdr
, &res
->state_protect
.enforce
);
5448 status
= decode_op_map(xdr
, &res
->state_protect
.allow
);
5457 /* server_owner4.so_minor_id */
5458 p
= xdr_inline_decode(xdr
, 8);
5461 p
= xdr_decode_hyper(p
, &res
->server_owner
->minor_id
);
5463 /* server_owner4.so_major_id */
5464 status
= decode_opaque_inline(xdr
, &dummy
, &dummy_str
);
5465 if (unlikely(status
))
5467 if (unlikely(dummy
> NFS4_OPAQUE_LIMIT
))
5469 memcpy(res
->server_owner
->major_id
, dummy_str
, dummy
);
5470 res
->server_owner
->major_id_sz
= dummy
;
5473 status
= decode_opaque_inline(xdr
, &dummy
, &dummy_str
);
5474 if (unlikely(status
))
5476 if (unlikely(dummy
> NFS4_OPAQUE_LIMIT
))
5478 memcpy(res
->server_scope
->server_scope
, dummy_str
, dummy
);
5479 res
->server_scope
->server_scope_sz
= dummy
;
5481 /* Implementation Id */
5482 p
= xdr_inline_decode(xdr
, 4);
5485 impl_id_count
= be32_to_cpup(p
++);
5487 if (impl_id_count
) {
5489 status
= decode_opaque_inline(xdr
, &dummy
, &dummy_str
);
5490 if (unlikely(status
))
5492 if (unlikely(dummy
> NFS4_OPAQUE_LIMIT
))
5494 memcpy(res
->impl_id
->domain
, dummy_str
, dummy
);
5497 status
= decode_opaque_inline(xdr
, &dummy
, &dummy_str
);
5498 if (unlikely(status
))
5500 if (unlikely(dummy
> NFS4_OPAQUE_LIMIT
))
5502 memcpy(res
->impl_id
->name
, dummy_str
, dummy
);
5505 p
= xdr_inline_decode(xdr
, 12);
5508 p
= xdr_decode_hyper(p
, &res
->impl_id
->date
.seconds
);
5509 res
->impl_id
->date
.nseconds
= be32_to_cpup(p
);
5511 /* if there's more than one entry, ignore the rest */
5515 print_overflow_msg(__func__
, xdr
);
5519 static int decode_chan_attrs(struct xdr_stream
*xdr
,
5520 struct nfs4_channel_attrs
*attrs
)
5525 p
= xdr_inline_decode(xdr
, 28);
5528 val
= be32_to_cpup(p
++); /* headerpadsz */
5530 return -EINVAL
; /* no support for header padding yet */
5531 attrs
->max_rqst_sz
= be32_to_cpup(p
++);
5532 attrs
->max_resp_sz
= be32_to_cpup(p
++);
5533 attrs
->max_resp_sz_cached
= be32_to_cpup(p
++);
5534 attrs
->max_ops
= be32_to_cpup(p
++);
5535 attrs
->max_reqs
= be32_to_cpup(p
++);
5536 nr_attrs
= be32_to_cpup(p
);
5537 if (unlikely(nr_attrs
> 1)) {
5538 printk(KERN_WARNING
"NFS: %s: Invalid rdma channel attrs "
5539 "count %u\n", __func__
, nr_attrs
);
5542 if (nr_attrs
== 1) {
5543 p
= xdr_inline_decode(xdr
, 4); /* skip rdma_attrs */
5549 print_overflow_msg(__func__
, xdr
);
5553 static int decode_sessionid(struct xdr_stream
*xdr
, struct nfs4_sessionid
*sid
)
5555 return decode_opaque_fixed(xdr
, sid
->data
, NFS4_MAX_SESSIONID_LEN
);
5558 static int decode_bind_conn_to_session(struct xdr_stream
*xdr
,
5559 struct nfs41_bind_conn_to_session_res
*res
)
5564 status
= decode_op_hdr(xdr
, OP_BIND_CONN_TO_SESSION
);
5566 status
= decode_sessionid(xdr
, &res
->session
->sess_id
);
5567 if (unlikely(status
))
5570 /* dir flags, rdma mode bool */
5571 p
= xdr_inline_decode(xdr
, 8);
5575 res
->dir
= be32_to_cpup(p
++);
5576 if (res
->dir
== 0 || res
->dir
> NFS4_CDFS4_BOTH
)
5578 if (be32_to_cpup(p
) == 0)
5579 res
->use_conn_in_rdma_mode
= false;
5581 res
->use_conn_in_rdma_mode
= true;
5585 print_overflow_msg(__func__
, xdr
);
5589 static int decode_create_session(struct xdr_stream
*xdr
,
5590 struct nfs41_create_session_res
*res
)
5594 struct nfs_client
*clp
= res
->client
;
5595 struct nfs4_session
*session
= clp
->cl_session
;
5597 status
= decode_op_hdr(xdr
, OP_CREATE_SESSION
);
5599 status
= decode_sessionid(xdr
, &session
->sess_id
);
5600 if (unlikely(status
))
5604 p
= xdr_inline_decode(xdr
, 8);
5607 clp
->cl_seqid
= be32_to_cpup(p
++);
5608 session
->flags
= be32_to_cpup(p
);
5610 /* Channel attributes */
5611 status
= decode_chan_attrs(xdr
, &session
->fc_attrs
);
5613 status
= decode_chan_attrs(xdr
, &session
->bc_attrs
);
5616 print_overflow_msg(__func__
, xdr
);
5620 static int decode_destroy_session(struct xdr_stream
*xdr
, void *dummy
)
5622 return decode_op_hdr(xdr
, OP_DESTROY_SESSION
);
5625 static int decode_destroy_clientid(struct xdr_stream
*xdr
, void *dummy
)
5627 return decode_op_hdr(xdr
, OP_DESTROY_CLIENTID
);
5630 static int decode_reclaim_complete(struct xdr_stream
*xdr
, void *dummy
)
5632 return decode_op_hdr(xdr
, OP_RECLAIM_COMPLETE
);
5634 #endif /* CONFIG_NFS_V4_1 */
5636 static int decode_sequence(struct xdr_stream
*xdr
,
5637 struct nfs4_sequence_res
*res
,
5638 struct rpc_rqst
*rqstp
)
5640 #if defined(CONFIG_NFS_V4_1)
5641 struct nfs4_session
*session
;
5642 struct nfs4_sessionid id
;
5647 if (res
->sr_slot
== NULL
)
5649 if (!res
->sr_slot
->table
->session
)
5652 status
= decode_op_hdr(xdr
, OP_SEQUENCE
);
5654 status
= decode_sessionid(xdr
, &id
);
5655 if (unlikely(status
))
5659 * If the server returns different values for sessionID, slotID or
5660 * sequence number, the server is looney tunes.
5662 status
= -EREMOTEIO
;
5663 session
= res
->sr_slot
->table
->session
;
5665 if (memcmp(id
.data
, session
->sess_id
.data
,
5666 NFS4_MAX_SESSIONID_LEN
)) {
5667 dprintk("%s Invalid session id\n", __func__
);
5671 p
= xdr_inline_decode(xdr
, 20);
5676 dummy
= be32_to_cpup(p
++);
5677 if (dummy
!= res
->sr_slot
->seq_nr
) {
5678 dprintk("%s Invalid sequence number\n", __func__
);
5682 dummy
= be32_to_cpup(p
++);
5683 if (dummy
!= res
->sr_slot
->slot_nr
) {
5684 dprintk("%s Invalid slot id\n", __func__
);
5687 /* highest slot id */
5688 res
->sr_highest_slotid
= be32_to_cpup(p
++);
5689 /* target highest slot id */
5690 res
->sr_target_highest_slotid
= be32_to_cpup(p
++);
5692 res
->sr_status_flags
= be32_to_cpup(p
);
5695 res
->sr_status
= status
;
5698 print_overflow_msg(__func__
, xdr
);
5701 #else /* CONFIG_NFS_V4_1 */
5703 #endif /* CONFIG_NFS_V4_1 */
5706 #if defined(CONFIG_NFS_V4_1)
5708 * TODO: Need to handle case when EOF != true;
5710 static int decode_getdevicelist(struct xdr_stream
*xdr
,
5711 struct pnfs_devicelist
*res
)
5715 nfs4_verifier verftemp
;
5717 status
= decode_op_hdr(xdr
, OP_GETDEVICELIST
);
5721 p
= xdr_inline_decode(xdr
, 8 + 8 + 4);
5725 /* TODO: Skip cookie for now */
5729 p
= xdr_decode_opaque_fixed(p
, verftemp
.data
, NFS4_VERIFIER_SIZE
);
5731 res
->num_devs
= be32_to_cpup(p
);
5733 dprintk("%s: num_dev %d\n", __func__
, res
->num_devs
);
5735 if (res
->num_devs
> NFS4_PNFS_GETDEVLIST_MAXNUM
) {
5736 printk(KERN_ERR
"NFS: %s too many result dev_num %u\n",
5737 __func__
, res
->num_devs
);
5741 p
= xdr_inline_decode(xdr
,
5742 res
->num_devs
* NFS4_DEVICEID4_SIZE
+ 4);
5745 for (i
= 0; i
< res
->num_devs
; i
++)
5746 p
= xdr_decode_opaque_fixed(p
, res
->dev_id
[i
].data
,
5747 NFS4_DEVICEID4_SIZE
);
5748 res
->eof
= be32_to_cpup(p
);
5751 print_overflow_msg(__func__
, xdr
);
5755 static int decode_getdeviceinfo(struct xdr_stream
*xdr
,
5756 struct pnfs_device
*pdev
)
5762 status
= decode_op_hdr(xdr
, OP_GETDEVICEINFO
);
5764 if (status
== -ETOOSMALL
) {
5765 p
= xdr_inline_decode(xdr
, 4);
5768 pdev
->mincount
= be32_to_cpup(p
);
5769 dprintk("%s: Min count too small. mincnt = %u\n",
5770 __func__
, pdev
->mincount
);
5775 p
= xdr_inline_decode(xdr
, 8);
5778 type
= be32_to_cpup(p
++);
5779 if (type
!= pdev
->layout_type
) {
5780 dprintk("%s: layout mismatch req: %u pdev: %u\n",
5781 __func__
, pdev
->layout_type
, type
);
5785 * Get the length of the opaque device_addr4. xdr_read_pages places
5786 * the opaque device_addr4 in the xdr_buf->pages (pnfs_device->pages)
5787 * and places the remaining xdr data in xdr_buf->tail
5789 pdev
->mincount
= be32_to_cpup(p
);
5790 if (xdr_read_pages(xdr
, pdev
->mincount
) != pdev
->mincount
)
5793 /* Parse notification bitmap, verifying that it is zero. */
5794 p
= xdr_inline_decode(xdr
, 4);
5797 len
= be32_to_cpup(p
);
5801 p
= xdr_inline_decode(xdr
, 4 * len
);
5804 for (i
= 0; i
< len
; i
++, p
++) {
5805 if (be32_to_cpup(p
)) {
5806 dprintk("%s: notifications not supported\n",
5814 print_overflow_msg(__func__
, xdr
);
5818 static int decode_layoutget(struct xdr_stream
*xdr
, struct rpc_rqst
*req
,
5819 struct nfs4_layoutget_res
*res
)
5826 status
= decode_op_hdr(xdr
, OP_LAYOUTGET
);
5829 p
= xdr_inline_decode(xdr
, 4);
5832 res
->return_on_close
= be32_to_cpup(p
);
5833 decode_stateid(xdr
, &res
->stateid
);
5834 p
= xdr_inline_decode(xdr
, 4);
5837 layout_count
= be32_to_cpup(p
);
5838 if (!layout_count
) {
5839 dprintk("%s: server responded with empty layout array\n",
5844 p
= xdr_inline_decode(xdr
, 28);
5847 p
= xdr_decode_hyper(p
, &res
->range
.offset
);
5848 p
= xdr_decode_hyper(p
, &res
->range
.length
);
5849 res
->range
.iomode
= be32_to_cpup(p
++);
5850 res
->type
= be32_to_cpup(p
++);
5851 res
->layoutp
->len
= be32_to_cpup(p
);
5853 dprintk("%s roff:%lu rlen:%lu riomode:%d, lo_type:0x%x, lo.len:%d\n",
5855 (unsigned long)res
->range
.offset
,
5856 (unsigned long)res
->range
.length
,
5861 recvd
= xdr_read_pages(xdr
, res
->layoutp
->len
);
5862 if (res
->layoutp
->len
> recvd
) {
5863 dprintk("NFS: server cheating in layoutget reply: "
5864 "layout len %u > recvd %u\n",
5865 res
->layoutp
->len
, recvd
);
5869 if (layout_count
> 1) {
5870 /* We only handle a length one array at the moment. Any
5871 * further entries are just ignored. Note that this means
5872 * the client may see a response that is less than the
5873 * minimum it requested.
5875 dprintk("%s: server responded with %d layouts, dropping tail\n",
5876 __func__
, layout_count
);
5881 print_overflow_msg(__func__
, xdr
);
5885 static int decode_layoutreturn(struct xdr_stream
*xdr
,
5886 struct nfs4_layoutreturn_res
*res
)
5891 status
= decode_op_hdr(xdr
, OP_LAYOUTRETURN
);
5894 p
= xdr_inline_decode(xdr
, 4);
5897 res
->lrs_present
= be32_to_cpup(p
);
5898 if (res
->lrs_present
)
5899 status
= decode_stateid(xdr
, &res
->stateid
);
5902 print_overflow_msg(__func__
, xdr
);
5906 static int decode_layoutcommit(struct xdr_stream
*xdr
,
5907 struct rpc_rqst
*req
,
5908 struct nfs4_layoutcommit_res
*res
)
5914 status
= decode_op_hdr(xdr
, OP_LAYOUTCOMMIT
);
5915 res
->status
= status
;
5919 p
= xdr_inline_decode(xdr
, 4);
5922 sizechanged
= be32_to_cpup(p
);
5925 /* throw away new size */
5926 p
= xdr_inline_decode(xdr
, 8);
5932 print_overflow_msg(__func__
, xdr
);
5936 static int decode_test_stateid(struct xdr_stream
*xdr
,
5937 struct nfs41_test_stateid_res
*res
)
5943 status
= decode_op_hdr(xdr
, OP_TEST_STATEID
);
5947 p
= xdr_inline_decode(xdr
, 4);
5950 num_res
= be32_to_cpup(p
++);
5954 p
= xdr_inline_decode(xdr
, 4);
5957 res
->status
= be32_to_cpup(p
++);
5961 print_overflow_msg(__func__
, xdr
);
5966 static int decode_free_stateid(struct xdr_stream
*xdr
,
5967 struct nfs41_free_stateid_res
*res
)
5969 res
->status
= decode_op_hdr(xdr
, OP_FREE_STATEID
);
5972 #endif /* CONFIG_NFS_V4_1 */
5975 * END OF "GENERIC" DECODE ROUTINES.
5979 * Decode OPEN_DOWNGRADE response
5981 static int nfs4_xdr_dec_open_downgrade(struct rpc_rqst
*rqstp
,
5982 struct xdr_stream
*xdr
,
5983 struct nfs_closeres
*res
)
5985 struct compound_hdr hdr
;
5988 status
= decode_compound_hdr(xdr
, &hdr
);
5991 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
5994 status
= decode_putfh(xdr
);
5997 status
= decode_open_downgrade(xdr
, res
);
6000 decode_getfattr(xdr
, res
->fattr
, res
->server
);
6006 * Decode ACCESS response
6008 static int nfs4_xdr_dec_access(struct rpc_rqst
*rqstp
, struct xdr_stream
*xdr
,
6009 struct nfs4_accessres
*res
)
6011 struct compound_hdr hdr
;
6014 status
= decode_compound_hdr(xdr
, &hdr
);
6017 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
6020 status
= decode_putfh(xdr
);
6023 status
= decode_access(xdr
, &res
->supported
, &res
->access
);
6026 decode_getfattr(xdr
, res
->fattr
, res
->server
);
6032 * Decode LOOKUP response
6034 static int nfs4_xdr_dec_lookup(struct rpc_rqst
*rqstp
, struct xdr_stream
*xdr
,
6035 struct nfs4_lookup_res
*res
)
6037 struct compound_hdr hdr
;
6040 status
= decode_compound_hdr(xdr
, &hdr
);
6043 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
6046 status
= decode_putfh(xdr
);
6049 status
= decode_lookup(xdr
);
6052 status
= decode_getfh(xdr
, res
->fh
);
6055 status
= decode_getfattr_label(xdr
, res
->fattr
, res
->label
, res
->server
);
6061 * Decode LOOKUP_ROOT response
6063 static int nfs4_xdr_dec_lookup_root(struct rpc_rqst
*rqstp
,
6064 struct xdr_stream
*xdr
,
6065 struct nfs4_lookup_res
*res
)
6067 struct compound_hdr hdr
;
6070 status
= decode_compound_hdr(xdr
, &hdr
);
6073 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
6076 status
= decode_putrootfh(xdr
);
6079 status
= decode_getfh(xdr
, res
->fh
);
6081 status
= decode_getfattr_label(xdr
, res
->fattr
,
6082 res
->label
, res
->server
);
6088 * Decode REMOVE response
6090 static int nfs4_xdr_dec_remove(struct rpc_rqst
*rqstp
, struct xdr_stream
*xdr
,
6091 struct nfs_removeres
*res
)
6093 struct compound_hdr hdr
;
6096 status
= decode_compound_hdr(xdr
, &hdr
);
6099 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
6102 status
= decode_putfh(xdr
);
6105 status
= decode_remove(xdr
, &res
->cinfo
);
6111 * Decode RENAME response
6113 static int nfs4_xdr_dec_rename(struct rpc_rqst
*rqstp
, struct xdr_stream
*xdr
,
6114 struct nfs_renameres
*res
)
6116 struct compound_hdr hdr
;
6119 status
= decode_compound_hdr(xdr
, &hdr
);
6122 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
6125 status
= decode_putfh(xdr
);
6128 status
= decode_savefh(xdr
);
6131 status
= decode_putfh(xdr
);
6134 status
= decode_rename(xdr
, &res
->old_cinfo
, &res
->new_cinfo
);
6140 * Decode LINK response
6142 static int nfs4_xdr_dec_link(struct rpc_rqst
*rqstp
, struct xdr_stream
*xdr
,
6143 struct nfs4_link_res
*res
)
6145 struct compound_hdr hdr
;
6148 status
= decode_compound_hdr(xdr
, &hdr
);
6151 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
6154 status
= decode_putfh(xdr
);
6157 status
= decode_savefh(xdr
);
6160 status
= decode_putfh(xdr
);
6163 status
= decode_link(xdr
, &res
->cinfo
);
6167 * Note order: OP_LINK leaves the directory as the current
6170 status
= decode_restorefh(xdr
);
6173 decode_getfattr_label(xdr
, res
->fattr
, res
->label
, res
->server
);
6179 * Decode CREATE response
6181 static int nfs4_xdr_dec_create(struct rpc_rqst
*rqstp
, struct xdr_stream
*xdr
,
6182 struct nfs4_create_res
*res
)
6184 struct compound_hdr hdr
;
6187 status
= decode_compound_hdr(xdr
, &hdr
);
6190 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
6193 status
= decode_putfh(xdr
);
6196 status
= decode_create(xdr
, &res
->dir_cinfo
);
6199 status
= decode_getfh(xdr
, res
->fh
);
6202 decode_getfattr_label(xdr
, res
->fattr
, res
->label
, res
->server
);
6208 * Decode SYMLINK response
6210 static int nfs4_xdr_dec_symlink(struct rpc_rqst
*rqstp
, struct xdr_stream
*xdr
,
6211 struct nfs4_create_res
*res
)
6213 return nfs4_xdr_dec_create(rqstp
, xdr
, res
);
6217 * Decode GETATTR response
6219 static int nfs4_xdr_dec_getattr(struct rpc_rqst
*rqstp
, struct xdr_stream
*xdr
,
6220 struct nfs4_getattr_res
*res
)
6222 struct compound_hdr hdr
;
6225 status
= decode_compound_hdr(xdr
, &hdr
);
6228 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
6231 status
= decode_putfh(xdr
);
6234 status
= decode_getfattr_label(xdr
, res
->fattr
, res
->label
, res
->server
);
6240 * Encode an SETACL request
6242 static void nfs4_xdr_enc_setacl(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
6243 struct nfs_setaclargs
*args
)
6245 struct compound_hdr hdr
= {
6246 .minorversion
= nfs4_xdr_minorversion(&args
->seq_args
),
6249 encode_compound_hdr(xdr
, req
, &hdr
);
6250 encode_sequence(xdr
, &args
->seq_args
, &hdr
);
6251 encode_putfh(xdr
, args
->fh
, &hdr
);
6252 encode_setacl(xdr
, args
, &hdr
);
6257 * Decode SETACL response
6260 nfs4_xdr_dec_setacl(struct rpc_rqst
*rqstp
, struct xdr_stream
*xdr
,
6261 struct nfs_setaclres
*res
)
6263 struct compound_hdr hdr
;
6266 status
= decode_compound_hdr(xdr
, &hdr
);
6269 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
6272 status
= decode_putfh(xdr
);
6275 status
= decode_setattr(xdr
);
6281 * Decode GETACL response
6284 nfs4_xdr_dec_getacl(struct rpc_rqst
*rqstp
, struct xdr_stream
*xdr
,
6285 struct nfs_getaclres
*res
)
6287 struct compound_hdr hdr
;
6290 if (res
->acl_scratch
!= NULL
) {
6291 void *p
= page_address(res
->acl_scratch
);
6292 xdr_set_scratch_buffer(xdr
, p
, PAGE_SIZE
);
6294 status
= decode_compound_hdr(xdr
, &hdr
);
6297 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
6300 status
= decode_putfh(xdr
);
6303 status
= decode_getacl(xdr
, rqstp
, res
);
6310 * Decode CLOSE response
6312 static int nfs4_xdr_dec_close(struct rpc_rqst
*rqstp
, struct xdr_stream
*xdr
,
6313 struct nfs_closeres
*res
)
6315 struct compound_hdr hdr
;
6318 status
= decode_compound_hdr(xdr
, &hdr
);
6321 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
6324 status
= decode_putfh(xdr
);
6327 status
= decode_close(xdr
, res
);
6331 * Note: Server may do delete on close for this file
6332 * in which case the getattr call will fail with
6333 * an ESTALE error. Shouldn't be a problem,
6334 * though, since fattr->valid will remain unset.
6336 decode_getfattr(xdr
, res
->fattr
, res
->server
);
6342 * Decode OPEN response
6344 static int nfs4_xdr_dec_open(struct rpc_rqst
*rqstp
, struct xdr_stream
*xdr
,
6345 struct nfs_openres
*res
)
6347 struct compound_hdr hdr
;
6350 status
= decode_compound_hdr(xdr
, &hdr
);
6353 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
6356 status
= decode_putfh(xdr
);
6359 status
= decode_open(xdr
, res
);
6362 status
= decode_getfh(xdr
, &res
->fh
);
6365 if (res
->access_request
)
6366 decode_access(xdr
, &res
->access_supported
, &res
->access_result
);
6367 decode_getfattr_label(xdr
, res
->f_attr
, res
->f_label
, res
->server
);
6373 * Decode OPEN_CONFIRM response
6375 static int nfs4_xdr_dec_open_confirm(struct rpc_rqst
*rqstp
,
6376 struct xdr_stream
*xdr
,
6377 struct nfs_open_confirmres
*res
)
6379 struct compound_hdr hdr
;
6382 status
= decode_compound_hdr(xdr
, &hdr
);
6385 status
= decode_putfh(xdr
);
6388 status
= decode_open_confirm(xdr
, res
);
6394 * Decode OPEN response
6396 static int nfs4_xdr_dec_open_noattr(struct rpc_rqst
*rqstp
,
6397 struct xdr_stream
*xdr
,
6398 struct nfs_openres
*res
)
6400 struct compound_hdr hdr
;
6403 status
= decode_compound_hdr(xdr
, &hdr
);
6406 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
6409 status
= decode_putfh(xdr
);
6412 status
= decode_open(xdr
, res
);
6415 if (res
->access_request
)
6416 decode_access(xdr
, &res
->access_supported
, &res
->access_result
);
6417 decode_getfattr(xdr
, res
->f_attr
, res
->server
);
6423 * Decode SETATTR response
6425 static int nfs4_xdr_dec_setattr(struct rpc_rqst
*rqstp
,
6426 struct xdr_stream
*xdr
,
6427 struct nfs_setattrres
*res
)
6429 struct compound_hdr hdr
;
6432 status
= decode_compound_hdr(xdr
, &hdr
);
6435 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
6438 status
= decode_putfh(xdr
);
6441 status
= decode_setattr(xdr
);
6444 decode_getfattr_label(xdr
, res
->fattr
, res
->label
, res
->server
);
6450 * Decode LOCK response
6452 static int nfs4_xdr_dec_lock(struct rpc_rqst
*rqstp
, struct xdr_stream
*xdr
,
6453 struct nfs_lock_res
*res
)
6455 struct compound_hdr hdr
;
6458 status
= decode_compound_hdr(xdr
, &hdr
);
6461 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
6464 status
= decode_putfh(xdr
);
6467 status
= decode_lock(xdr
, res
);
6473 * Decode LOCKT response
6475 static int nfs4_xdr_dec_lockt(struct rpc_rqst
*rqstp
, struct xdr_stream
*xdr
,
6476 struct nfs_lockt_res
*res
)
6478 struct compound_hdr hdr
;
6481 status
= decode_compound_hdr(xdr
, &hdr
);
6484 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
6487 status
= decode_putfh(xdr
);
6490 status
= decode_lockt(xdr
, res
);
6496 * Decode LOCKU response
6498 static int nfs4_xdr_dec_locku(struct rpc_rqst
*rqstp
, struct xdr_stream
*xdr
,
6499 struct nfs_locku_res
*res
)
6501 struct compound_hdr hdr
;
6504 status
= decode_compound_hdr(xdr
, &hdr
);
6507 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
6510 status
= decode_putfh(xdr
);
6513 status
= decode_locku(xdr
, res
);
6518 static int nfs4_xdr_dec_release_lockowner(struct rpc_rqst
*rqstp
,
6519 struct xdr_stream
*xdr
, void *dummy
)
6521 struct compound_hdr hdr
;
6524 status
= decode_compound_hdr(xdr
, &hdr
);
6526 status
= decode_release_lockowner(xdr
);
6531 * Decode READLINK response
6533 static int nfs4_xdr_dec_readlink(struct rpc_rqst
*rqstp
,
6534 struct xdr_stream
*xdr
,
6535 struct nfs4_readlink_res
*res
)
6537 struct compound_hdr hdr
;
6540 status
= decode_compound_hdr(xdr
, &hdr
);
6543 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
6546 status
= decode_putfh(xdr
);
6549 status
= decode_readlink(xdr
, rqstp
);
6555 * Decode READDIR response
6557 static int nfs4_xdr_dec_readdir(struct rpc_rqst
*rqstp
, struct xdr_stream
*xdr
,
6558 struct nfs4_readdir_res
*res
)
6560 struct compound_hdr hdr
;
6563 status
= decode_compound_hdr(xdr
, &hdr
);
6566 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
6569 status
= decode_putfh(xdr
);
6572 status
= decode_readdir(xdr
, rqstp
, res
);
6578 * Decode Read response
6580 static int nfs4_xdr_dec_read(struct rpc_rqst
*rqstp
, struct xdr_stream
*xdr
,
6581 struct nfs_readres
*res
)
6583 struct compound_hdr hdr
;
6586 status
= decode_compound_hdr(xdr
, &hdr
);
6589 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
6592 status
= decode_putfh(xdr
);
6595 status
= decode_read(xdr
, rqstp
, res
);
6597 status
= res
->count
;
6603 * Decode WRITE response
6605 static int nfs4_xdr_dec_write(struct rpc_rqst
*rqstp
, struct xdr_stream
*xdr
,
6606 struct nfs_writeres
*res
)
6608 struct compound_hdr hdr
;
6611 status
= decode_compound_hdr(xdr
, &hdr
);
6614 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
6617 status
= decode_putfh(xdr
);
6620 status
= decode_write(xdr
, res
);
6624 decode_getfattr(xdr
, res
->fattr
, res
->server
);
6626 status
= res
->count
;
6632 * Decode COMMIT response
6634 static int nfs4_xdr_dec_commit(struct rpc_rqst
*rqstp
, struct xdr_stream
*xdr
,
6635 struct nfs_commitres
*res
)
6637 struct compound_hdr hdr
;
6640 status
= decode_compound_hdr(xdr
, &hdr
);
6643 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
6646 status
= decode_putfh(xdr
);
6649 status
= decode_commit(xdr
, res
);
6655 * Decode FSINFO response
6657 static int nfs4_xdr_dec_fsinfo(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
6658 struct nfs4_fsinfo_res
*res
)
6660 struct compound_hdr hdr
;
6663 status
= decode_compound_hdr(xdr
, &hdr
);
6665 status
= decode_sequence(xdr
, &res
->seq_res
, req
);
6667 status
= decode_putfh(xdr
);
6669 status
= decode_fsinfo(xdr
, res
->fsinfo
);
6674 * Decode PATHCONF response
6676 static int nfs4_xdr_dec_pathconf(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
6677 struct nfs4_pathconf_res
*res
)
6679 struct compound_hdr hdr
;
6682 status
= decode_compound_hdr(xdr
, &hdr
);
6684 status
= decode_sequence(xdr
, &res
->seq_res
, req
);
6686 status
= decode_putfh(xdr
);
6688 status
= decode_pathconf(xdr
, res
->pathconf
);
6693 * Decode STATFS response
6695 static int nfs4_xdr_dec_statfs(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
6696 struct nfs4_statfs_res
*res
)
6698 struct compound_hdr hdr
;
6701 status
= decode_compound_hdr(xdr
, &hdr
);
6703 status
= decode_sequence(xdr
, &res
->seq_res
, req
);
6705 status
= decode_putfh(xdr
);
6707 status
= decode_statfs(xdr
, res
->fsstat
);
6712 * Decode GETATTR_BITMAP response
6714 static int nfs4_xdr_dec_server_caps(struct rpc_rqst
*req
,
6715 struct xdr_stream
*xdr
,
6716 struct nfs4_server_caps_res
*res
)
6718 struct compound_hdr hdr
;
6721 status
= decode_compound_hdr(xdr
, &hdr
);
6724 status
= decode_sequence(xdr
, &res
->seq_res
, req
);
6727 status
= decode_putfh(xdr
);
6730 status
= decode_server_caps(xdr
, res
);
6736 * Decode RENEW response
6738 static int nfs4_xdr_dec_renew(struct rpc_rqst
*rqstp
, struct xdr_stream
*xdr
,
6741 struct compound_hdr hdr
;
6744 status
= decode_compound_hdr(xdr
, &hdr
);
6746 status
= decode_renew(xdr
);
6751 * Decode SETCLIENTID response
6753 static int nfs4_xdr_dec_setclientid(struct rpc_rqst
*req
,
6754 struct xdr_stream
*xdr
,
6755 struct nfs4_setclientid_res
*res
)
6757 struct compound_hdr hdr
;
6760 status
= decode_compound_hdr(xdr
, &hdr
);
6762 status
= decode_setclientid(xdr
, res
);
6767 * Decode SETCLIENTID_CONFIRM response
6769 static int nfs4_xdr_dec_setclientid_confirm(struct rpc_rqst
*req
,
6770 struct xdr_stream
*xdr
)
6772 struct compound_hdr hdr
;
6775 status
= decode_compound_hdr(xdr
, &hdr
);
6777 status
= decode_setclientid_confirm(xdr
);
6782 * Decode DELEGRETURN response
6784 static int nfs4_xdr_dec_delegreturn(struct rpc_rqst
*rqstp
,
6785 struct xdr_stream
*xdr
,
6786 struct nfs4_delegreturnres
*res
)
6788 struct compound_hdr hdr
;
6791 status
= decode_compound_hdr(xdr
, &hdr
);
6794 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
6797 status
= decode_putfh(xdr
);
6800 status
= decode_getfattr(xdr
, res
->fattr
, res
->server
);
6803 status
= decode_delegreturn(xdr
);
6809 * Decode FS_LOCATIONS response
6811 static int nfs4_xdr_dec_fs_locations(struct rpc_rqst
*req
,
6812 struct xdr_stream
*xdr
,
6813 struct nfs4_fs_locations_res
*res
)
6815 struct compound_hdr hdr
;
6818 status
= decode_compound_hdr(xdr
, &hdr
);
6821 status
= decode_sequence(xdr
, &res
->seq_res
, req
);
6824 status
= decode_putfh(xdr
);
6827 status
= decode_lookup(xdr
);
6830 xdr_enter_page(xdr
, PAGE_SIZE
);
6831 status
= decode_getfattr_generic(xdr
, &res
->fs_locations
->fattr
,
6832 NULL
, res
->fs_locations
,
6833 NULL
, res
->fs_locations
->server
);
6839 * Decode SECINFO response
6841 static int nfs4_xdr_dec_secinfo(struct rpc_rqst
*rqstp
,
6842 struct xdr_stream
*xdr
,
6843 struct nfs4_secinfo_res
*res
)
6845 struct compound_hdr hdr
;
6848 status
= decode_compound_hdr(xdr
, &hdr
);
6851 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
6854 status
= decode_putfh(xdr
);
6857 status
= decode_secinfo(xdr
, res
);
6862 #if defined(CONFIG_NFS_V4_1)
6864 * Decode BIND_CONN_TO_SESSION response
6866 static int nfs4_xdr_dec_bind_conn_to_session(struct rpc_rqst
*rqstp
,
6867 struct xdr_stream
*xdr
,
6870 struct compound_hdr hdr
;
6873 status
= decode_compound_hdr(xdr
, &hdr
);
6875 status
= decode_bind_conn_to_session(xdr
, res
);
6880 * Decode EXCHANGE_ID response
6882 static int nfs4_xdr_dec_exchange_id(struct rpc_rqst
*rqstp
,
6883 struct xdr_stream
*xdr
,
6886 struct compound_hdr hdr
;
6889 status
= decode_compound_hdr(xdr
, &hdr
);
6891 status
= decode_exchange_id(xdr
, res
);
6896 * Decode CREATE_SESSION response
6898 static int nfs4_xdr_dec_create_session(struct rpc_rqst
*rqstp
,
6899 struct xdr_stream
*xdr
,
6900 struct nfs41_create_session_res
*res
)
6902 struct compound_hdr hdr
;
6905 status
= decode_compound_hdr(xdr
, &hdr
);
6907 status
= decode_create_session(xdr
, res
);
6912 * Decode DESTROY_SESSION response
6914 static int nfs4_xdr_dec_destroy_session(struct rpc_rqst
*rqstp
,
6915 struct xdr_stream
*xdr
,
6918 struct compound_hdr hdr
;
6921 status
= decode_compound_hdr(xdr
, &hdr
);
6923 status
= decode_destroy_session(xdr
, res
);
6928 * Decode DESTROY_CLIENTID response
6930 static int nfs4_xdr_dec_destroy_clientid(struct rpc_rqst
*rqstp
,
6931 struct xdr_stream
*xdr
,
6934 struct compound_hdr hdr
;
6937 status
= decode_compound_hdr(xdr
, &hdr
);
6939 status
= decode_destroy_clientid(xdr
, res
);
6944 * Decode SEQUENCE response
6946 static int nfs4_xdr_dec_sequence(struct rpc_rqst
*rqstp
,
6947 struct xdr_stream
*xdr
,
6948 struct nfs4_sequence_res
*res
)
6950 struct compound_hdr hdr
;
6953 status
= decode_compound_hdr(xdr
, &hdr
);
6955 status
= decode_sequence(xdr
, res
, rqstp
);
6960 * Decode GET_LEASE_TIME response
6962 static int nfs4_xdr_dec_get_lease_time(struct rpc_rqst
*rqstp
,
6963 struct xdr_stream
*xdr
,
6964 struct nfs4_get_lease_time_res
*res
)
6966 struct compound_hdr hdr
;
6969 status
= decode_compound_hdr(xdr
, &hdr
);
6971 status
= decode_sequence(xdr
, &res
->lr_seq_res
, rqstp
);
6973 status
= decode_putrootfh(xdr
);
6975 status
= decode_fsinfo(xdr
, res
->lr_fsinfo
);
6980 * Decode RECLAIM_COMPLETE response
6982 static int nfs4_xdr_dec_reclaim_complete(struct rpc_rqst
*rqstp
,
6983 struct xdr_stream
*xdr
,
6984 struct nfs41_reclaim_complete_res
*res
)
6986 struct compound_hdr hdr
;
6989 status
= decode_compound_hdr(xdr
, &hdr
);
6991 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
6993 status
= decode_reclaim_complete(xdr
, (void *)NULL
);
6998 * Decode GETDEVICELIST response
7000 static int nfs4_xdr_dec_getdevicelist(struct rpc_rqst
*rqstp
,
7001 struct xdr_stream
*xdr
,
7002 struct nfs4_getdevicelist_res
*res
)
7004 struct compound_hdr hdr
;
7007 dprintk("encoding getdevicelist!\n");
7009 status
= decode_compound_hdr(xdr
, &hdr
);
7012 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
7015 status
= decode_putfh(xdr
);
7018 status
= decode_getdevicelist(xdr
, res
->devlist
);
7024 * Decode GETDEVINFO response
7026 static int nfs4_xdr_dec_getdeviceinfo(struct rpc_rqst
*rqstp
,
7027 struct xdr_stream
*xdr
,
7028 struct nfs4_getdeviceinfo_res
*res
)
7030 struct compound_hdr hdr
;
7033 status
= decode_compound_hdr(xdr
, &hdr
);
7036 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
7039 status
= decode_getdeviceinfo(xdr
, res
->pdev
);
7045 * Decode LAYOUTGET response
7047 static int nfs4_xdr_dec_layoutget(struct rpc_rqst
*rqstp
,
7048 struct xdr_stream
*xdr
,
7049 struct nfs4_layoutget_res
*res
)
7051 struct compound_hdr hdr
;
7054 status
= decode_compound_hdr(xdr
, &hdr
);
7057 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
7060 status
= decode_putfh(xdr
);
7063 status
= decode_layoutget(xdr
, rqstp
, res
);
7069 * Decode LAYOUTRETURN response
7071 static int nfs4_xdr_dec_layoutreturn(struct rpc_rqst
*rqstp
,
7072 struct xdr_stream
*xdr
,
7073 struct nfs4_layoutreturn_res
*res
)
7075 struct compound_hdr hdr
;
7078 status
= decode_compound_hdr(xdr
, &hdr
);
7081 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
7084 status
= decode_putfh(xdr
);
7087 status
= decode_layoutreturn(xdr
, res
);
7093 * Decode LAYOUTCOMMIT response
7095 static int nfs4_xdr_dec_layoutcommit(struct rpc_rqst
*rqstp
,
7096 struct xdr_stream
*xdr
,
7097 struct nfs4_layoutcommit_res
*res
)
7099 struct compound_hdr hdr
;
7102 status
= decode_compound_hdr(xdr
, &hdr
);
7105 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
7108 status
= decode_putfh(xdr
);
7111 status
= decode_layoutcommit(xdr
, rqstp
, res
);
7114 decode_getfattr(xdr
, res
->fattr
, res
->server
);
7120 * Decode SECINFO_NO_NAME response
7122 static int nfs4_xdr_dec_secinfo_no_name(struct rpc_rqst
*rqstp
,
7123 struct xdr_stream
*xdr
,
7124 struct nfs4_secinfo_res
*res
)
7126 struct compound_hdr hdr
;
7129 status
= decode_compound_hdr(xdr
, &hdr
);
7132 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
7135 status
= decode_putrootfh(xdr
);
7138 status
= decode_secinfo_no_name(xdr
, res
);
7144 * Decode TEST_STATEID response
7146 static int nfs4_xdr_dec_test_stateid(struct rpc_rqst
*rqstp
,
7147 struct xdr_stream
*xdr
,
7148 struct nfs41_test_stateid_res
*res
)
7150 struct compound_hdr hdr
;
7153 status
= decode_compound_hdr(xdr
, &hdr
);
7156 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
7159 status
= decode_test_stateid(xdr
, res
);
7165 * Decode FREE_STATEID response
7167 static int nfs4_xdr_dec_free_stateid(struct rpc_rqst
*rqstp
,
7168 struct xdr_stream
*xdr
,
7169 struct nfs41_free_stateid_res
*res
)
7171 struct compound_hdr hdr
;
7174 status
= decode_compound_hdr(xdr
, &hdr
);
7177 status
= decode_sequence(xdr
, &res
->seq_res
, rqstp
);
7180 status
= decode_free_stateid(xdr
, res
);
7184 #endif /* CONFIG_NFS_V4_1 */
7187 * nfs4_decode_dirent - Decode a single NFSv4 directory entry stored in
7188 * the local page cache.
7189 * @xdr: XDR stream where entry resides
7190 * @entry: buffer to fill in with entry data
7191 * @plus: boolean indicating whether this should be a readdirplus entry
7193 * Returns zero if successful, otherwise a negative errno value is
7196 * This function is not invoked during READDIR reply decoding, but
7197 * rather whenever an application invokes the getdents(2) system call
7198 * on a directory already in our cache.
7200 int nfs4_decode_dirent(struct xdr_stream
*xdr
, struct nfs_entry
*entry
,
7204 uint32_t bitmap
[3] = {0};
7206 __be32
*p
= xdr_inline_decode(xdr
, 4);
7209 if (*p
== xdr_zero
) {
7210 p
= xdr_inline_decode(xdr
, 4);
7219 p
= xdr_inline_decode(xdr
, 12);
7222 entry
->prev_cookie
= entry
->cookie
;
7223 p
= xdr_decode_hyper(p
, &entry
->cookie
);
7224 entry
->len
= be32_to_cpup(p
);
7226 p
= xdr_inline_decode(xdr
, entry
->len
);
7229 entry
->name
= (const char *) p
;
7232 * In case the server doesn't return an inode number,
7233 * we fake one here. (We don't use inode number 0,
7234 * since glibc seems to choke on it...)
7237 entry
->fattr
->valid
= 0;
7239 if (decode_attr_bitmap(xdr
, bitmap
) < 0)
7242 if (decode_attr_length(xdr
, &len
, &savep
) < 0)
7245 if (decode_getfattr_attrs(xdr
, bitmap
, entry
->fattr
, entry
->fh
,
7246 NULL
, entry
->label
, entry
->server
) < 0)
7248 if (entry
->fattr
->valid
& NFS_ATTR_FATTR_MOUNTED_ON_FILEID
)
7249 entry
->ino
= entry
->fattr
->mounted_on_fileid
;
7250 else if (entry
->fattr
->valid
& NFS_ATTR_FATTR_FILEID
)
7251 entry
->ino
= entry
->fattr
->fileid
;
7253 entry
->d_type
= DT_UNKNOWN
;
7254 if (entry
->fattr
->valid
& NFS_ATTR_FATTR_TYPE
)
7255 entry
->d_type
= nfs_umode_to_dtype(entry
->fattr
->mode
);
7260 print_overflow_msg(__func__
, xdr
);
7265 * We need to translate between nfs status return values and
7266 * the local errno values which may not be the same.
7273 { NFS4ERR_PERM
, -EPERM
},
7274 { NFS4ERR_NOENT
, -ENOENT
},
7275 { NFS4ERR_IO
, -errno_NFSERR_IO
},
7276 { NFS4ERR_NXIO
, -ENXIO
},
7277 { NFS4ERR_ACCESS
, -EACCES
},
7278 { NFS4ERR_EXIST
, -EEXIST
},
7279 { NFS4ERR_XDEV
, -EXDEV
},
7280 { NFS4ERR_NOTDIR
, -ENOTDIR
},
7281 { NFS4ERR_ISDIR
, -EISDIR
},
7282 { NFS4ERR_INVAL
, -EINVAL
},
7283 { NFS4ERR_FBIG
, -EFBIG
},
7284 { NFS4ERR_NOSPC
, -ENOSPC
},
7285 { NFS4ERR_ROFS
, -EROFS
},
7286 { NFS4ERR_MLINK
, -EMLINK
},
7287 { NFS4ERR_NAMETOOLONG
, -ENAMETOOLONG
},
7288 { NFS4ERR_NOTEMPTY
, -ENOTEMPTY
},
7289 { NFS4ERR_DQUOT
, -EDQUOT
},
7290 { NFS4ERR_STALE
, -ESTALE
},
7291 { NFS4ERR_BADHANDLE
, -EBADHANDLE
},
7292 { NFS4ERR_BAD_COOKIE
, -EBADCOOKIE
},
7293 { NFS4ERR_NOTSUPP
, -ENOTSUPP
},
7294 { NFS4ERR_TOOSMALL
, -ETOOSMALL
},
7295 { NFS4ERR_SERVERFAULT
, -EREMOTEIO
},
7296 { NFS4ERR_BADTYPE
, -EBADTYPE
},
7297 { NFS4ERR_LOCKED
, -EAGAIN
},
7298 { NFS4ERR_SYMLINK
, -ELOOP
},
7299 { NFS4ERR_OP_ILLEGAL
, -EOPNOTSUPP
},
7300 { NFS4ERR_DEADLOCK
, -EDEADLK
},
7305 * Convert an NFS error code to a local one.
7306 * This one is used jointly by NFSv2 and NFSv3.
7309 nfs4_stat_to_errno(int stat
)
7312 for (i
= 0; nfs_errtbl
[i
].stat
!= -1; i
++) {
7313 if (nfs_errtbl
[i
].stat
== stat
)
7314 return nfs_errtbl
[i
].errno
;
7316 if (stat
<= 10000 || stat
> 10100) {
7317 /* The server is looney tunes. */
7320 /* If we cannot translate the error, the recovery routines should
7322 * Note: remaining NFSv4 error codes have values > 10000, so should
7323 * not conflict with native Linux error codes.
7328 #define PROC(proc, argtype, restype) \
7329 [NFSPROC4_CLNT_##proc] = { \
7330 .p_proc = NFSPROC4_COMPOUND, \
7331 .p_encode = (kxdreproc_t)nfs4_xdr_##argtype, \
7332 .p_decode = (kxdrdproc_t)nfs4_xdr_##restype, \
7333 .p_arglen = NFS4_##argtype##_sz, \
7334 .p_replen = NFS4_##restype##_sz, \
7335 .p_statidx = NFSPROC4_CLNT_##proc, \
7339 struct rpc_procinfo nfs4_procedures
[] = {
7340 PROC(READ
, enc_read
, dec_read
),
7341 PROC(WRITE
, enc_write
, dec_write
),
7342 PROC(COMMIT
, enc_commit
, dec_commit
),
7343 PROC(OPEN
, enc_open
, dec_open
),
7344 PROC(OPEN_CONFIRM
, enc_open_confirm
, dec_open_confirm
),
7345 PROC(OPEN_NOATTR
, enc_open_noattr
, dec_open_noattr
),
7346 PROC(OPEN_DOWNGRADE
, enc_open_downgrade
, dec_open_downgrade
),
7347 PROC(CLOSE
, enc_close
, dec_close
),
7348 PROC(SETATTR
, enc_setattr
, dec_setattr
),
7349 PROC(FSINFO
, enc_fsinfo
, dec_fsinfo
),
7350 PROC(RENEW
, enc_renew
, dec_renew
),
7351 PROC(SETCLIENTID
, enc_setclientid
, dec_setclientid
),
7352 PROC(SETCLIENTID_CONFIRM
, enc_setclientid_confirm
, dec_setclientid_confirm
),
7353 PROC(LOCK
, enc_lock
, dec_lock
),
7354 PROC(LOCKT
, enc_lockt
, dec_lockt
),
7355 PROC(LOCKU
, enc_locku
, dec_locku
),
7356 PROC(ACCESS
, enc_access
, dec_access
),
7357 PROC(GETATTR
, enc_getattr
, dec_getattr
),
7358 PROC(LOOKUP
, enc_lookup
, dec_lookup
),
7359 PROC(LOOKUP_ROOT
, enc_lookup_root
, dec_lookup_root
),
7360 PROC(REMOVE
, enc_remove
, dec_remove
),
7361 PROC(RENAME
, enc_rename
, dec_rename
),
7362 PROC(LINK
, enc_link
, dec_link
),
7363 PROC(SYMLINK
, enc_symlink
, dec_symlink
),
7364 PROC(CREATE
, enc_create
, dec_create
),
7365 PROC(PATHCONF
, enc_pathconf
, dec_pathconf
),
7366 PROC(STATFS
, enc_statfs
, dec_statfs
),
7367 PROC(READLINK
, enc_readlink
, dec_readlink
),
7368 PROC(READDIR
, enc_readdir
, dec_readdir
),
7369 PROC(SERVER_CAPS
, enc_server_caps
, dec_server_caps
),
7370 PROC(DELEGRETURN
, enc_delegreturn
, dec_delegreturn
),
7371 PROC(GETACL
, enc_getacl
, dec_getacl
),
7372 PROC(SETACL
, enc_setacl
, dec_setacl
),
7373 PROC(FS_LOCATIONS
, enc_fs_locations
, dec_fs_locations
),
7374 PROC(RELEASE_LOCKOWNER
, enc_release_lockowner
, dec_release_lockowner
),
7375 PROC(SECINFO
, enc_secinfo
, dec_secinfo
),
7376 #if defined(CONFIG_NFS_V4_1)
7377 PROC(EXCHANGE_ID
, enc_exchange_id
, dec_exchange_id
),
7378 PROC(CREATE_SESSION
, enc_create_session
, dec_create_session
),
7379 PROC(DESTROY_SESSION
, enc_destroy_session
, dec_destroy_session
),
7380 PROC(SEQUENCE
, enc_sequence
, dec_sequence
),
7381 PROC(GET_LEASE_TIME
, enc_get_lease_time
, dec_get_lease_time
),
7382 PROC(RECLAIM_COMPLETE
, enc_reclaim_complete
, dec_reclaim_complete
),
7383 PROC(GETDEVICEINFO
, enc_getdeviceinfo
, dec_getdeviceinfo
),
7384 PROC(LAYOUTGET
, enc_layoutget
, dec_layoutget
),
7385 PROC(LAYOUTCOMMIT
, enc_layoutcommit
, dec_layoutcommit
),
7386 PROC(LAYOUTRETURN
, enc_layoutreturn
, dec_layoutreturn
),
7387 PROC(SECINFO_NO_NAME
, enc_secinfo_no_name
, dec_secinfo_no_name
),
7388 PROC(TEST_STATEID
, enc_test_stateid
, dec_test_stateid
),
7389 PROC(FREE_STATEID
, enc_free_stateid
, dec_free_stateid
),
7390 PROC(GETDEVICELIST
, enc_getdevicelist
, dec_getdevicelist
),
7391 PROC(BIND_CONN_TO_SESSION
,
7392 enc_bind_conn_to_session
, dec_bind_conn_to_session
),
7393 PROC(DESTROY_CLIENTID
, enc_destroy_clientid
, dec_destroy_clientid
),
7394 #endif /* CONFIG_NFS_V4_1 */
7397 const struct rpc_version nfs_version4
= {
7399 .nrprocs
= ARRAY_SIZE(nfs4_procedures
),
7400 .procs
= nfs4_procedures