xref: /linux/fs/nfs/nfs4xdr.c (revision c4ee0af3fa0dc65f690fc908f02b8355f9576ea0) 
1 /*
2  *  fs/nfs/nfs4xdr.c
3  *
4  *  Client-side XDR for NFSv4.
5  *
6  *  Copyright (c) 2002 The Regents of the University of Michigan.
7  *  All rights reserved.
8  *
9  *  Kendrick Smith <kmsmith@umich.edu>
10  *  Andy Adamson   <andros@umich.edu>
11  *
12  *  Redistribution and use in source and binary forms, with or without
13  *  modification, are permitted provided that the following conditions
14  *  are met:
15  *
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.
24  *
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.
36  */
37 
38 #include <linux/param.h>
39 #include <linux/time.h>
40 #include <linux/mm.h>
41 #include <linux/errno.h>
42 #include <linux/string.h>
43 #include <linux/in.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>
56 
57 #include "nfs4_fs.h"
58 #include "internal.h"
59 #include "nfs4session.h"
60 #include "pnfs.h"
61 #include "netns.h"
62 
63 #define NFSDBG_FACILITY		NFSDBG_XDR
64 
65 /* Mapping from NFS error code to "errno" error code. */
66 #define errno_NFSERR_IO		EIO
67 
68 static int nfs4_stat_to_errno(int);
69 
70 /* NFSv4 COMPOUND tags are only wanted for debugging purposes */
71 #ifdef DEBUG
72 #define NFS4_MAXTAGLEN		20
73 #else
74 #define NFS4_MAXTAGLEN		0
75 #endif
76 
77 /* lock,open owner id:
78  * we currently use size 2 (u64) out of (NFS4_OPAQUE_LIMIT  >> 2)
79  */
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 + \
92 				(NFS4_FHSIZE >> 2))
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 #else
109 #define	nfs4_label_maxsz	0
110 #endif
111 /* We support only one layout type per file system */
112 #define decode_mdsthreshold_maxsz (1 + 1 + nfs4_fattr_bitmap_maxsz + 1 + 8)
113 /* This is based on getfattr, which uses the most attributes: */
114 #define nfs4_fattr_value_maxsz	(1 + (1 + 2 + 2 + 4 + 2 + 1 + 1 + 2 + 2 + \
115 				3 + 3 + 3 + nfs4_owner_maxsz + \
116 				nfs4_group_maxsz + nfs4_label_maxsz + \
117 				 decode_mdsthreshold_maxsz))
118 #define nfs4_fattr_maxsz	(nfs4_fattr_bitmap_maxsz + \
119 				nfs4_fattr_value_maxsz)
120 #define decode_getattr_maxsz    (op_decode_hdr_maxsz + nfs4_fattr_maxsz)
121 #define encode_attrs_maxsz	(nfs4_fattr_bitmap_maxsz + \
122 				 1 + 2 + 1 + \
123 				nfs4_owner_maxsz + \
124 				nfs4_group_maxsz + \
125 				nfs4_label_maxsz + \
126 				4 + 4)
127 #define encode_savefh_maxsz     (op_encode_hdr_maxsz)
128 #define decode_savefh_maxsz     (op_decode_hdr_maxsz)
129 #define encode_restorefh_maxsz  (op_encode_hdr_maxsz)
130 #define decode_restorefh_maxsz  (op_decode_hdr_maxsz)
131 #define encode_fsinfo_maxsz	(encode_getattr_maxsz)
132 /* The 5 accounts for the PNFS attributes, and assumes that at most three
133  * layout types will be returned.
134  */
135 #define decode_fsinfo_maxsz	(op_decode_hdr_maxsz + \
136 				 nfs4_fattr_bitmap_maxsz + 4 + 8 + 5)
137 #define encode_renew_maxsz	(op_encode_hdr_maxsz + 3)
138 #define decode_renew_maxsz	(op_decode_hdr_maxsz)
139 #define encode_setclientid_maxsz \
140 				(op_encode_hdr_maxsz + \
141 				XDR_QUADLEN(NFS4_VERIFIER_SIZE) + \
142 				XDR_QUADLEN(NFS4_SETCLIENTID_NAMELEN) + \
143 				1 /* sc_prog */ + \
144 				XDR_QUADLEN(RPCBIND_MAXNETIDLEN) + \
145 				XDR_QUADLEN(RPCBIND_MAXUADDRLEN) + \
146 				1) /* sc_cb_ident */
147 #define decode_setclientid_maxsz \
148 				(op_decode_hdr_maxsz + \
149 				2 + \
150 				1024) /* large value for CLID_INUSE */
151 #define encode_setclientid_confirm_maxsz \
152 				(op_encode_hdr_maxsz + \
153 				3 + (NFS4_VERIFIER_SIZE >> 2))
154 #define decode_setclientid_confirm_maxsz \
155 				(op_decode_hdr_maxsz)
156 #define encode_lookup_maxsz	(op_encode_hdr_maxsz + nfs4_name_maxsz)
157 #define decode_lookup_maxsz	(op_decode_hdr_maxsz)
158 #define encode_share_access_maxsz \
159 				(2)
160 #define encode_createmode_maxsz	(1 + encode_attrs_maxsz + encode_verifier_maxsz)
161 #define encode_opentype_maxsz	(1 + encode_createmode_maxsz)
162 #define encode_claim_null_maxsz	(1 + nfs4_name_maxsz)
163 #define encode_open_maxsz	(op_encode_hdr_maxsz + \
164 				2 + encode_share_access_maxsz + 2 + \
165 				open_owner_id_maxsz + \
166 				encode_opentype_maxsz + \
167 				encode_claim_null_maxsz)
168 #define decode_ace_maxsz	(3 + nfs4_owner_maxsz)
169 #define decode_delegation_maxsz	(1 + decode_stateid_maxsz + 1 + \
170 				decode_ace_maxsz)
171 #define decode_change_info_maxsz	(5)
172 #define decode_open_maxsz	(op_decode_hdr_maxsz + \
173 				decode_stateid_maxsz + \
174 				decode_change_info_maxsz + 1 + \
175 				nfs4_fattr_bitmap_maxsz + \
176 				decode_delegation_maxsz)
177 #define encode_open_confirm_maxsz \
178 				(op_encode_hdr_maxsz + \
179 				 encode_stateid_maxsz + 1)
180 #define decode_open_confirm_maxsz \
181 				(op_decode_hdr_maxsz + \
182 				 decode_stateid_maxsz)
183 #define encode_open_downgrade_maxsz \
184 				(op_encode_hdr_maxsz + \
185 				 encode_stateid_maxsz + 1 + \
186 				 encode_share_access_maxsz)
187 #define decode_open_downgrade_maxsz \
188 				(op_decode_hdr_maxsz + \
189 				 decode_stateid_maxsz)
190 #define encode_close_maxsz	(op_encode_hdr_maxsz + \
191 				 1 + encode_stateid_maxsz)
192 #define decode_close_maxsz	(op_decode_hdr_maxsz + \
193 				 decode_stateid_maxsz)
194 #define encode_setattr_maxsz	(op_encode_hdr_maxsz + \
195 				 encode_stateid_maxsz + \
196 				 encode_attrs_maxsz)
197 #define decode_setattr_maxsz	(op_decode_hdr_maxsz + \
198 				 nfs4_fattr_bitmap_maxsz)
199 #define encode_read_maxsz	(op_encode_hdr_maxsz + \
200 				 encode_stateid_maxsz + 3)
201 #define decode_read_maxsz	(op_decode_hdr_maxsz + 2)
202 #define encode_readdir_maxsz	(op_encode_hdr_maxsz + \
203 				 2 + encode_verifier_maxsz + 5 + \
204 				nfs4_label_maxsz)
205 #define decode_readdir_maxsz	(op_decode_hdr_maxsz + \
206 				 decode_verifier_maxsz + \
207 				nfs4_label_maxsz + nfs4_fattr_maxsz)
208 #define encode_readlink_maxsz	(op_encode_hdr_maxsz)
209 #define decode_readlink_maxsz	(op_decode_hdr_maxsz + 1)
210 #define encode_write_maxsz	(op_encode_hdr_maxsz + \
211 				 encode_stateid_maxsz + 4)
212 #define decode_write_maxsz	(op_decode_hdr_maxsz + \
213 				 2 + decode_verifier_maxsz)
214 #define encode_commit_maxsz	(op_encode_hdr_maxsz + 3)
215 #define decode_commit_maxsz	(op_decode_hdr_maxsz + \
216 				 decode_verifier_maxsz)
217 #define encode_remove_maxsz	(op_encode_hdr_maxsz + \
218 				nfs4_name_maxsz)
219 #define decode_remove_maxsz	(op_decode_hdr_maxsz + \
220 				 decode_change_info_maxsz)
221 #define encode_rename_maxsz	(op_encode_hdr_maxsz + \
222 				2 * nfs4_name_maxsz)
223 #define decode_rename_maxsz	(op_decode_hdr_maxsz + \
224 				 decode_change_info_maxsz + \
225 				 decode_change_info_maxsz)
226 #define encode_link_maxsz	(op_encode_hdr_maxsz + \
227 				nfs4_name_maxsz)
228 #define decode_link_maxsz	(op_decode_hdr_maxsz + decode_change_info_maxsz)
229 #define encode_lockowner_maxsz	(7)
230 #define encode_lock_maxsz	(op_encode_hdr_maxsz + \
231 				 7 + \
232 				 1 + encode_stateid_maxsz + 1 + \
233 				 encode_lockowner_maxsz)
234 #define decode_lock_denied_maxsz \
235 				(8 + decode_lockowner_maxsz)
236 #define decode_lock_maxsz	(op_decode_hdr_maxsz + \
237 				 decode_lock_denied_maxsz)
238 #define encode_lockt_maxsz	(op_encode_hdr_maxsz + 5 + \
239 				encode_lockowner_maxsz)
240 #define decode_lockt_maxsz	(op_decode_hdr_maxsz + \
241 				 decode_lock_denied_maxsz)
242 #define encode_locku_maxsz	(op_encode_hdr_maxsz + 3 + \
243 				 encode_stateid_maxsz + \
244 				 4)
245 #define decode_locku_maxsz	(op_decode_hdr_maxsz + \
246 				 decode_stateid_maxsz)
247 #define encode_release_lockowner_maxsz \
248 				(op_encode_hdr_maxsz + \
249 				 encode_lockowner_maxsz)
250 #define decode_release_lockowner_maxsz \
251 				(op_decode_hdr_maxsz)
252 #define encode_access_maxsz	(op_encode_hdr_maxsz + 1)
253 #define decode_access_maxsz	(op_decode_hdr_maxsz + 2)
254 #define encode_symlink_maxsz	(op_encode_hdr_maxsz + \
255 				1 + nfs4_name_maxsz + \
256 				1 + \
257 				nfs4_fattr_maxsz)
258 #define decode_symlink_maxsz	(op_decode_hdr_maxsz + 8)
259 #define encode_create_maxsz	(op_encode_hdr_maxsz + \
260 				1 + 2 + nfs4_name_maxsz + \
261 				encode_attrs_maxsz)
262 #define decode_create_maxsz	(op_decode_hdr_maxsz + \
263 				decode_change_info_maxsz + \
264 				nfs4_fattr_bitmap_maxsz)
265 #define encode_statfs_maxsz	(encode_getattr_maxsz)
266 #define decode_statfs_maxsz	(decode_getattr_maxsz)
267 #define encode_delegreturn_maxsz (op_encode_hdr_maxsz + 4)
268 #define decode_delegreturn_maxsz (op_decode_hdr_maxsz)
269 #define encode_getacl_maxsz	(encode_getattr_maxsz)
270 #define decode_getacl_maxsz	(op_decode_hdr_maxsz + \
271 				 nfs4_fattr_bitmap_maxsz + 1)
272 #define encode_setacl_maxsz	(op_encode_hdr_maxsz + \
273 				 encode_stateid_maxsz + 3)
274 #define decode_setacl_maxsz	(decode_setattr_maxsz)
275 #define encode_fs_locations_maxsz \
276 				(encode_getattr_maxsz)
277 #define decode_fs_locations_maxsz \
278 				(0)
279 #define encode_secinfo_maxsz	(op_encode_hdr_maxsz + nfs4_name_maxsz)
280 #define decode_secinfo_maxsz	(op_decode_hdr_maxsz + 1 + ((NFS_MAX_SECFLAVORS * (16 + GSS_OID_MAX_LEN)) / 4))
281 
282 #if defined(CONFIG_NFS_V4_1)
283 #define NFS4_MAX_MACHINE_NAME_LEN (64)
284 #define IMPL_NAME_LIMIT (sizeof(utsname()->sysname) + sizeof(utsname()->release) + \
285 			 sizeof(utsname()->version) + sizeof(utsname()->machine) + 8)
286 
287 #define encode_exchange_id_maxsz (op_encode_hdr_maxsz + \
288 				encode_verifier_maxsz + \
289 				1 /* co_ownerid.len */ + \
290 				XDR_QUADLEN(NFS4_EXCHANGE_ID_LEN) + \
291 				1 /* flags */ + \
292 				1 /* spa_how */ + \
293 				/* max is SP4_MACH_CRED (for now) */ + \
294 				1 + NFS4_OP_MAP_NUM_WORDS + \
295 				1 + NFS4_OP_MAP_NUM_WORDS + \
296 				1 /* implementation id array of size 1 */ + \
297 				1 /* nii_domain */ + \
298 				XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + \
299 				1 /* nii_name */ + \
300 				XDR_QUADLEN(IMPL_NAME_LIMIT) + \
301 				3 /* nii_date */)
302 #define decode_exchange_id_maxsz (op_decode_hdr_maxsz + \
303 				2 /* eir_clientid */ + \
304 				1 /* eir_sequenceid */ + \
305 				1 /* eir_flags */ + \
306 				1 /* spr_how */ + \
307 				  /* max is SP4_MACH_CRED (for now) */ + \
308 				1 + NFS4_OP_MAP_NUM_WORDS + \
309 				1 + NFS4_OP_MAP_NUM_WORDS + \
310 				2 /* eir_server_owner.so_minor_id */ + \
311 				/* eir_server_owner.so_major_id<> */ \
312 				XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 + \
313 				/* eir_server_scope<> */ \
314 				XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 + \
315 				1 /* eir_server_impl_id array length */ + \
316 				1 /* nii_domain */ + \
317 				XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + \
318 				1 /* nii_name */ + \
319 				XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + \
320 				3 /* nii_date */)
321 #define encode_channel_attrs_maxsz  (6 + 1 /* ca_rdma_ird.len (0) */)
322 #define decode_channel_attrs_maxsz  (6 + \
323 				     1 /* ca_rdma_ird.len */ + \
324 				     1 /* ca_rdma_ird */)
325 #define encode_create_session_maxsz  (op_encode_hdr_maxsz + \
326 				     2 /* csa_clientid */ + \
327 				     1 /* csa_sequence */ + \
328 				     1 /* csa_flags */ + \
329 				     encode_channel_attrs_maxsz + \
330 				     encode_channel_attrs_maxsz + \
331 				     1 /* csa_cb_program */ + \
332 				     1 /* csa_sec_parms.len (1) */ + \
333 				     1 /* cb_secflavor (AUTH_SYS) */ + \
334 				     1 /* stamp */ + \
335 				     1 /* machinename.len */ + \
336 				     XDR_QUADLEN(NFS4_MAX_MACHINE_NAME_LEN) + \
337 				     1 /* uid */ + \
338 				     1 /* gid */ + \
339 				     1 /* gids.len (0) */)
340 #define decode_create_session_maxsz  (op_decode_hdr_maxsz +	\
341 				     XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
342 				     1 /* csr_sequence */ + \
343 				     1 /* csr_flags */ + \
344 				     decode_channel_attrs_maxsz + \
345 				     decode_channel_attrs_maxsz)
346 #define encode_bind_conn_to_session_maxsz  (op_encode_hdr_maxsz + \
347 				     /* bctsa_sessid */ \
348 				     XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
349 				     1 /* bctsa_dir */ + \
350 				     1 /* bctsa_use_conn_in_rdma_mode */)
351 #define decode_bind_conn_to_session_maxsz  (op_decode_hdr_maxsz +	\
352 				     /* bctsr_sessid */ \
353 				     XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
354 				     1 /* bctsr_dir */ + \
355 				     1 /* bctsr_use_conn_in_rdma_mode */)
356 #define encode_destroy_session_maxsz    (op_encode_hdr_maxsz + 4)
357 #define decode_destroy_session_maxsz    (op_decode_hdr_maxsz)
358 #define encode_destroy_clientid_maxsz   (op_encode_hdr_maxsz + 2)
359 #define decode_destroy_clientid_maxsz   (op_decode_hdr_maxsz)
360 #define encode_sequence_maxsz	(op_encode_hdr_maxsz + \
361 				XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + 4)
362 #define decode_sequence_maxsz	(op_decode_hdr_maxsz + \
363 				XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + 5)
364 #define encode_reclaim_complete_maxsz	(op_encode_hdr_maxsz + 4)
365 #define decode_reclaim_complete_maxsz	(op_decode_hdr_maxsz + 4)
366 #define encode_getdevicelist_maxsz (op_encode_hdr_maxsz + 4 + \
367 				encode_verifier_maxsz)
368 #define decode_getdevicelist_maxsz (op_decode_hdr_maxsz + \
369 				2 /* nfs_cookie4 gdlr_cookie */ + \
370 				decode_verifier_maxsz \
371 				  /* verifier4 gdlr_verifier */ + \
372 				1 /* gdlr_deviceid_list count */ + \
373 				XDR_QUADLEN(NFS4_PNFS_GETDEVLIST_MAXNUM * \
374 					    NFS4_DEVICEID4_SIZE) \
375 				  /* gdlr_deviceid_list */ + \
376 				1 /* bool gdlr_eof */)
377 #define encode_getdeviceinfo_maxsz (op_encode_hdr_maxsz + 4 + \
378 				XDR_QUADLEN(NFS4_DEVICEID4_SIZE))
379 #define decode_getdeviceinfo_maxsz (op_decode_hdr_maxsz + \
380 				1 /* layout type */ + \
381 				1 /* opaque devaddr4 length */ + \
382 				  /* devaddr4 payload is read into page */ \
383 				1 /* notification bitmap length */ + \
384 				1 /* notification bitmap */)
385 #define encode_layoutget_maxsz	(op_encode_hdr_maxsz + 10 + \
386 				encode_stateid_maxsz)
387 #define decode_layoutget_maxsz	(op_decode_hdr_maxsz + 8 + \
388 				decode_stateid_maxsz + \
389 				XDR_QUADLEN(PNFS_LAYOUT_MAXSIZE))
390 #define encode_layoutcommit_maxsz (op_encode_hdr_maxsz +          \
391 				2 /* offset */ + \
392 				2 /* length */ + \
393 				1 /* reclaim */ + \
394 				encode_stateid_maxsz + \
395 				1 /* new offset (true) */ + \
396 				2 /* last byte written */ + \
397 				1 /* nt_timechanged (false) */ + \
398 				1 /* layoutupdate4 layout type */ + \
399 				1 /* NULL filelayout layoutupdate4 payload */)
400 #define decode_layoutcommit_maxsz (op_decode_hdr_maxsz + 3)
401 #define encode_layoutreturn_maxsz (8 + op_encode_hdr_maxsz + \
402 				encode_stateid_maxsz + \
403 				1 /* FIXME: opaque lrf_body always empty at the moment */)
404 #define decode_layoutreturn_maxsz (op_decode_hdr_maxsz + \
405 				1 + decode_stateid_maxsz)
406 #define encode_secinfo_no_name_maxsz (op_encode_hdr_maxsz + 1)
407 #define decode_secinfo_no_name_maxsz decode_secinfo_maxsz
408 #define encode_test_stateid_maxsz	(op_encode_hdr_maxsz + 2 + \
409 					 XDR_QUADLEN(NFS4_STATEID_SIZE))
410 #define decode_test_stateid_maxsz	(op_decode_hdr_maxsz + 2 + 1)
411 #define encode_free_stateid_maxsz	(op_encode_hdr_maxsz + 1 + \
412 					 XDR_QUADLEN(NFS4_STATEID_SIZE))
413 #define decode_free_stateid_maxsz	(op_decode_hdr_maxsz)
414 #else /* CONFIG_NFS_V4_1 */
415 #define encode_sequence_maxsz	0
416 #define decode_sequence_maxsz	0
417 #endif /* CONFIG_NFS_V4_1 */
418 
419 #define NFS4_enc_compound_sz	(1024)  /* XXX: large enough? */
420 #define NFS4_dec_compound_sz	(1024)  /* XXX: large enough? */
421 #define NFS4_enc_read_sz	(compound_encode_hdr_maxsz + \
422 				encode_sequence_maxsz + \
423 				encode_putfh_maxsz + \
424 				encode_read_maxsz)
425 #define NFS4_dec_read_sz	(compound_decode_hdr_maxsz + \
426 				decode_sequence_maxsz + \
427 				decode_putfh_maxsz + \
428 				decode_read_maxsz)
429 #define NFS4_enc_readlink_sz	(compound_encode_hdr_maxsz + \
430 				encode_sequence_maxsz + \
431 				encode_putfh_maxsz + \
432 				encode_readlink_maxsz)
433 #define NFS4_dec_readlink_sz	(compound_decode_hdr_maxsz + \
434 				decode_sequence_maxsz + \
435 				decode_putfh_maxsz + \
436 				decode_readlink_maxsz)
437 #define NFS4_enc_readdir_sz	(compound_encode_hdr_maxsz + \
438 				encode_sequence_maxsz + \
439 				encode_putfh_maxsz + \
440 				encode_readdir_maxsz)
441 #define NFS4_dec_readdir_sz	(compound_decode_hdr_maxsz + \
442 				decode_sequence_maxsz + \
443 				decode_putfh_maxsz + \
444 				decode_readdir_maxsz)
445 #define NFS4_enc_write_sz	(compound_encode_hdr_maxsz + \
446 				encode_sequence_maxsz + \
447 				encode_putfh_maxsz + \
448 				encode_write_maxsz + \
449 				encode_getattr_maxsz)
450 #define NFS4_dec_write_sz	(compound_decode_hdr_maxsz + \
451 				decode_sequence_maxsz + \
452 				decode_putfh_maxsz + \
453 				decode_write_maxsz + \
454 				decode_getattr_maxsz)
455 #define NFS4_enc_commit_sz	(compound_encode_hdr_maxsz + \
456 				encode_sequence_maxsz + \
457 				encode_putfh_maxsz + \
458 				encode_commit_maxsz)
459 #define NFS4_dec_commit_sz	(compound_decode_hdr_maxsz + \
460 				decode_sequence_maxsz + \
461 				decode_putfh_maxsz + \
462 				decode_commit_maxsz)
463 #define NFS4_enc_open_sz        (compound_encode_hdr_maxsz + \
464 				encode_sequence_maxsz + \
465 				encode_putfh_maxsz + \
466 				encode_open_maxsz + \
467 				encode_access_maxsz + \
468 				encode_getfh_maxsz + \
469 				encode_getattr_maxsz)
470 #define NFS4_dec_open_sz        (compound_decode_hdr_maxsz + \
471 				decode_sequence_maxsz + \
472 				decode_putfh_maxsz + \
473 				decode_open_maxsz + \
474 				decode_access_maxsz + \
475 				decode_getfh_maxsz + \
476 				decode_getattr_maxsz)
477 #define NFS4_enc_open_confirm_sz \
478 				(compound_encode_hdr_maxsz + \
479 				 encode_putfh_maxsz + \
480 				 encode_open_confirm_maxsz)
481 #define NFS4_dec_open_confirm_sz \
482 				(compound_decode_hdr_maxsz + \
483 				 decode_putfh_maxsz + \
484 				 decode_open_confirm_maxsz)
485 #define NFS4_enc_open_noattr_sz	(compound_encode_hdr_maxsz + \
486 					encode_sequence_maxsz + \
487 					encode_putfh_maxsz + \
488 					encode_open_maxsz + \
489 					encode_access_maxsz + \
490 					encode_getattr_maxsz)
491 #define NFS4_dec_open_noattr_sz	(compound_decode_hdr_maxsz + \
492 					decode_sequence_maxsz + \
493 					decode_putfh_maxsz + \
494 					decode_open_maxsz + \
495 					decode_access_maxsz + \
496 					decode_getattr_maxsz)
497 #define NFS4_enc_open_downgrade_sz \
498 				(compound_encode_hdr_maxsz + \
499 				 encode_sequence_maxsz + \
500 				 encode_putfh_maxsz + \
501 				 encode_open_downgrade_maxsz + \
502 				 encode_getattr_maxsz)
503 #define NFS4_dec_open_downgrade_sz \
504 				(compound_decode_hdr_maxsz + \
505 				 decode_sequence_maxsz + \
506 				 decode_putfh_maxsz + \
507 				 decode_open_downgrade_maxsz + \
508 				 decode_getattr_maxsz)
509 #define NFS4_enc_close_sz	(compound_encode_hdr_maxsz + \
510 				 encode_sequence_maxsz + \
511 				 encode_putfh_maxsz + \
512 				 encode_close_maxsz + \
513 				 encode_getattr_maxsz)
514 #define NFS4_dec_close_sz	(compound_decode_hdr_maxsz + \
515 				 decode_sequence_maxsz + \
516 				 decode_putfh_maxsz + \
517 				 decode_close_maxsz + \
518 				 decode_getattr_maxsz)
519 #define NFS4_enc_setattr_sz	(compound_encode_hdr_maxsz + \
520 				 encode_sequence_maxsz + \
521 				 encode_putfh_maxsz + \
522 				 encode_setattr_maxsz + \
523 				 encode_getattr_maxsz)
524 #define NFS4_dec_setattr_sz	(compound_decode_hdr_maxsz + \
525 				 decode_sequence_maxsz + \
526 				 decode_putfh_maxsz + \
527 				 decode_setattr_maxsz + \
528 				 decode_getattr_maxsz)
529 #define NFS4_enc_fsinfo_sz	(compound_encode_hdr_maxsz + \
530 				encode_sequence_maxsz + \
531 				encode_putfh_maxsz + \
532 				encode_fsinfo_maxsz)
533 #define NFS4_dec_fsinfo_sz	(compound_decode_hdr_maxsz + \
534 				decode_sequence_maxsz + \
535 				decode_putfh_maxsz + \
536 				decode_fsinfo_maxsz)
537 #define NFS4_enc_renew_sz	(compound_encode_hdr_maxsz + \
538 				encode_renew_maxsz)
539 #define NFS4_dec_renew_sz	(compound_decode_hdr_maxsz + \
540 				decode_renew_maxsz)
541 #define NFS4_enc_setclientid_sz	(compound_encode_hdr_maxsz + \
542 				encode_setclientid_maxsz)
543 #define NFS4_dec_setclientid_sz	(compound_decode_hdr_maxsz + \
544 				decode_setclientid_maxsz)
545 #define NFS4_enc_setclientid_confirm_sz \
546 				(compound_encode_hdr_maxsz + \
547 				encode_setclientid_confirm_maxsz)
548 #define NFS4_dec_setclientid_confirm_sz \
549 				(compound_decode_hdr_maxsz + \
550 				decode_setclientid_confirm_maxsz)
551 #define NFS4_enc_lock_sz        (compound_encode_hdr_maxsz + \
552 				encode_sequence_maxsz + \
553 				encode_putfh_maxsz + \
554 				encode_lock_maxsz)
555 #define NFS4_dec_lock_sz        (compound_decode_hdr_maxsz + \
556 				decode_sequence_maxsz + \
557 				decode_putfh_maxsz + \
558 				decode_lock_maxsz)
559 #define NFS4_enc_lockt_sz       (compound_encode_hdr_maxsz + \
560 				encode_sequence_maxsz + \
561 				encode_putfh_maxsz + \
562 				encode_lockt_maxsz)
563 #define NFS4_dec_lockt_sz       (compound_decode_hdr_maxsz + \
564 				 decode_sequence_maxsz + \
565 				 decode_putfh_maxsz + \
566 				 decode_lockt_maxsz)
567 #define NFS4_enc_locku_sz       (compound_encode_hdr_maxsz + \
568 				encode_sequence_maxsz + \
569 				encode_putfh_maxsz + \
570 				encode_locku_maxsz)
571 #define NFS4_dec_locku_sz       (compound_decode_hdr_maxsz + \
572 				decode_sequence_maxsz + \
573 				decode_putfh_maxsz + \
574 				decode_locku_maxsz)
575 #define NFS4_enc_release_lockowner_sz \
576 				(compound_encode_hdr_maxsz + \
577 				 encode_lockowner_maxsz)
578 #define NFS4_dec_release_lockowner_sz \
579 				(compound_decode_hdr_maxsz + \
580 				 decode_lockowner_maxsz)
581 #define NFS4_enc_access_sz	(compound_encode_hdr_maxsz + \
582 				encode_sequence_maxsz + \
583 				encode_putfh_maxsz + \
584 				encode_access_maxsz + \
585 				encode_getattr_maxsz)
586 #define NFS4_dec_access_sz	(compound_decode_hdr_maxsz + \
587 				decode_sequence_maxsz + \
588 				decode_putfh_maxsz + \
589 				decode_access_maxsz + \
590 				decode_getattr_maxsz)
591 #define NFS4_enc_getattr_sz	(compound_encode_hdr_maxsz + \
592 				encode_sequence_maxsz + \
593 				encode_putfh_maxsz + \
594 				encode_getattr_maxsz + \
595 				encode_renew_maxsz)
596 #define NFS4_dec_getattr_sz	(compound_decode_hdr_maxsz + \
597 				decode_sequence_maxsz + \
598 				decode_putfh_maxsz + \
599 				decode_getattr_maxsz + \
600 				decode_renew_maxsz)
601 #define NFS4_enc_lookup_sz	(compound_encode_hdr_maxsz + \
602 				encode_sequence_maxsz + \
603 				encode_putfh_maxsz + \
604 				encode_lookup_maxsz + \
605 				encode_getattr_maxsz + \
606 				encode_getfh_maxsz)
607 #define NFS4_dec_lookup_sz	(compound_decode_hdr_maxsz + \
608 				decode_sequence_maxsz + \
609 				decode_putfh_maxsz + \
610 				decode_lookup_maxsz + \
611 				decode_getattr_maxsz + \
612 				decode_getfh_maxsz)
613 #define NFS4_enc_lookup_root_sz (compound_encode_hdr_maxsz + \
614 				encode_sequence_maxsz + \
615 				encode_putrootfh_maxsz + \
616 				encode_getattr_maxsz + \
617 				encode_getfh_maxsz)
618 #define NFS4_dec_lookup_root_sz (compound_decode_hdr_maxsz + \
619 				decode_sequence_maxsz + \
620 				decode_putrootfh_maxsz + \
621 				decode_getattr_maxsz + \
622 				decode_getfh_maxsz)
623 #define NFS4_enc_remove_sz	(compound_encode_hdr_maxsz + \
624 				encode_sequence_maxsz + \
625 				encode_putfh_maxsz + \
626 				encode_remove_maxsz)
627 #define NFS4_dec_remove_sz	(compound_decode_hdr_maxsz + \
628 				decode_sequence_maxsz + \
629 				decode_putfh_maxsz + \
630 				decode_remove_maxsz)
631 #define NFS4_enc_rename_sz	(compound_encode_hdr_maxsz + \
632 				encode_sequence_maxsz + \
633 				encode_putfh_maxsz + \
634 				encode_savefh_maxsz + \
635 				encode_putfh_maxsz + \
636 				encode_rename_maxsz)
637 #define NFS4_dec_rename_sz	(compound_decode_hdr_maxsz + \
638 				decode_sequence_maxsz + \
639 				decode_putfh_maxsz + \
640 				decode_savefh_maxsz + \
641 				decode_putfh_maxsz + \
642 				decode_rename_maxsz)
643 #define NFS4_enc_link_sz	(compound_encode_hdr_maxsz + \
644 				encode_sequence_maxsz + \
645 				encode_putfh_maxsz + \
646 				encode_savefh_maxsz + \
647 				encode_putfh_maxsz + \
648 				encode_link_maxsz + \
649 				encode_restorefh_maxsz + \
650 				encode_getattr_maxsz)
651 #define NFS4_dec_link_sz	(compound_decode_hdr_maxsz + \
652 				decode_sequence_maxsz + \
653 				decode_putfh_maxsz + \
654 				decode_savefh_maxsz + \
655 				decode_putfh_maxsz + \
656 				decode_link_maxsz + \
657 				decode_restorefh_maxsz + \
658 				decode_getattr_maxsz)
659 #define NFS4_enc_symlink_sz	(compound_encode_hdr_maxsz + \
660 				encode_sequence_maxsz + \
661 				encode_putfh_maxsz + \
662 				encode_symlink_maxsz + \
663 				encode_getattr_maxsz + \
664 				encode_getfh_maxsz)
665 #define NFS4_dec_symlink_sz	(compound_decode_hdr_maxsz + \
666 				decode_sequence_maxsz + \
667 				decode_putfh_maxsz + \
668 				decode_symlink_maxsz + \
669 				decode_getattr_maxsz + \
670 				decode_getfh_maxsz)
671 #define NFS4_enc_create_sz	(compound_encode_hdr_maxsz + \
672 				encode_sequence_maxsz + \
673 				encode_putfh_maxsz + \
674 				encode_create_maxsz + \
675 				encode_getfh_maxsz + \
676 				encode_getattr_maxsz)
677 #define NFS4_dec_create_sz	(compound_decode_hdr_maxsz + \
678 				decode_sequence_maxsz + \
679 				decode_putfh_maxsz + \
680 				decode_create_maxsz + \
681 				decode_getfh_maxsz + \
682 				decode_getattr_maxsz)
683 #define NFS4_enc_pathconf_sz	(compound_encode_hdr_maxsz + \
684 				encode_sequence_maxsz + \
685 				encode_putfh_maxsz + \
686 				encode_getattr_maxsz)
687 #define NFS4_dec_pathconf_sz	(compound_decode_hdr_maxsz + \
688 				decode_sequence_maxsz + \
689 				decode_putfh_maxsz + \
690 				decode_getattr_maxsz)
691 #define NFS4_enc_statfs_sz	(compound_encode_hdr_maxsz + \
692 				encode_sequence_maxsz + \
693 				encode_putfh_maxsz + \
694 				encode_statfs_maxsz)
695 #define NFS4_dec_statfs_sz	(compound_decode_hdr_maxsz + \
696 				decode_sequence_maxsz + \
697 				decode_putfh_maxsz + \
698 				decode_statfs_maxsz)
699 #define NFS4_enc_server_caps_sz (compound_encode_hdr_maxsz + \
700 				encode_sequence_maxsz + \
701 				encode_putfh_maxsz + \
702 				encode_getattr_maxsz)
703 #define NFS4_dec_server_caps_sz (compound_decode_hdr_maxsz + \
704 				decode_sequence_maxsz + \
705 				decode_putfh_maxsz + \
706 				decode_getattr_maxsz)
707 #define NFS4_enc_delegreturn_sz	(compound_encode_hdr_maxsz + \
708 				encode_sequence_maxsz + \
709 				encode_putfh_maxsz + \
710 				encode_delegreturn_maxsz + \
711 				encode_getattr_maxsz)
712 #define NFS4_dec_delegreturn_sz (compound_decode_hdr_maxsz + \
713 				decode_sequence_maxsz + \
714 				decode_delegreturn_maxsz + \
715 				decode_getattr_maxsz)
716 #define NFS4_enc_getacl_sz	(compound_encode_hdr_maxsz + \
717 				encode_sequence_maxsz + \
718 				encode_putfh_maxsz + \
719 				encode_getacl_maxsz)
720 #define NFS4_dec_getacl_sz	(compound_decode_hdr_maxsz + \
721 				decode_sequence_maxsz + \
722 				decode_putfh_maxsz + \
723 				decode_getacl_maxsz)
724 #define NFS4_enc_setacl_sz	(compound_encode_hdr_maxsz + \
725 				encode_sequence_maxsz + \
726 				encode_putfh_maxsz + \
727 				encode_setacl_maxsz)
728 #define NFS4_dec_setacl_sz	(compound_decode_hdr_maxsz + \
729 				decode_sequence_maxsz + \
730 				decode_putfh_maxsz + \
731 				decode_setacl_maxsz)
732 #define NFS4_enc_fs_locations_sz \
733 				(compound_encode_hdr_maxsz + \
734 				 encode_sequence_maxsz + \
735 				 encode_putfh_maxsz + \
736 				 encode_lookup_maxsz + \
737 				 encode_fs_locations_maxsz + \
738 				 encode_renew_maxsz)
739 #define NFS4_dec_fs_locations_sz \
740 				(compound_decode_hdr_maxsz + \
741 				 decode_sequence_maxsz + \
742 				 decode_putfh_maxsz + \
743 				 decode_lookup_maxsz + \
744 				 decode_fs_locations_maxsz + \
745 				 decode_renew_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 #define NFS4_enc_fsid_present_sz \
755 				(compound_encode_hdr_maxsz + \
756 				 encode_sequence_maxsz + \
757 				 encode_putfh_maxsz + \
758 				 encode_getfh_maxsz + \
759 				 encode_renew_maxsz)
760 #define NFS4_dec_fsid_present_sz \
761 				(compound_decode_hdr_maxsz + \
762 				 decode_sequence_maxsz + \
763 				 decode_putfh_maxsz + \
764 				 decode_getfh_maxsz + \
765 				 decode_renew_maxsz)
766 #if defined(CONFIG_NFS_V4_1)
767 #define NFS4_enc_bind_conn_to_session_sz \
768 				(compound_encode_hdr_maxsz + \
769 				 encode_bind_conn_to_session_maxsz)
770 #define NFS4_dec_bind_conn_to_session_sz \
771 				(compound_decode_hdr_maxsz + \
772 				 decode_bind_conn_to_session_maxsz)
773 #define NFS4_enc_exchange_id_sz \
774 				(compound_encode_hdr_maxsz + \
775 				 encode_exchange_id_maxsz)
776 #define NFS4_dec_exchange_id_sz \
777 				(compound_decode_hdr_maxsz + \
778 				 decode_exchange_id_maxsz)
779 #define NFS4_enc_create_session_sz \
780 				(compound_encode_hdr_maxsz + \
781 				 encode_create_session_maxsz)
782 #define NFS4_dec_create_session_sz \
783 				(compound_decode_hdr_maxsz + \
784 				 decode_create_session_maxsz)
785 #define NFS4_enc_destroy_session_sz	(compound_encode_hdr_maxsz + \
786 					 encode_destroy_session_maxsz)
787 #define NFS4_dec_destroy_session_sz	(compound_decode_hdr_maxsz + \
788 					 decode_destroy_session_maxsz)
789 #define NFS4_enc_destroy_clientid_sz	(compound_encode_hdr_maxsz + \
790 					 encode_destroy_clientid_maxsz)
791 #define NFS4_dec_destroy_clientid_sz	(compound_decode_hdr_maxsz + \
792 					 decode_destroy_clientid_maxsz)
793 #define NFS4_enc_sequence_sz \
794 				(compound_decode_hdr_maxsz + \
795 				 encode_sequence_maxsz)
796 #define NFS4_dec_sequence_sz \
797 				(compound_decode_hdr_maxsz + \
798 				 decode_sequence_maxsz)
799 #define NFS4_enc_get_lease_time_sz	(compound_encode_hdr_maxsz + \
800 					 encode_sequence_maxsz + \
801 					 encode_putrootfh_maxsz + \
802 					 encode_fsinfo_maxsz)
803 #define NFS4_dec_get_lease_time_sz	(compound_decode_hdr_maxsz + \
804 					 decode_sequence_maxsz + \
805 					 decode_putrootfh_maxsz + \
806 					 decode_fsinfo_maxsz)
807 #define NFS4_enc_reclaim_complete_sz	(compound_encode_hdr_maxsz + \
808 					 encode_sequence_maxsz + \
809 					 encode_reclaim_complete_maxsz)
810 #define NFS4_dec_reclaim_complete_sz	(compound_decode_hdr_maxsz + \
811 					 decode_sequence_maxsz + \
812 					 decode_reclaim_complete_maxsz)
813 #define NFS4_enc_getdevicelist_sz (compound_encode_hdr_maxsz + \
814 				encode_sequence_maxsz + \
815 				encode_putfh_maxsz + \
816 				encode_getdevicelist_maxsz)
817 #define NFS4_dec_getdevicelist_sz (compound_decode_hdr_maxsz + \
818 				decode_sequence_maxsz + \
819 				decode_putfh_maxsz + \
820 				decode_getdevicelist_maxsz)
821 #define NFS4_enc_getdeviceinfo_sz (compound_encode_hdr_maxsz +    \
822 				encode_sequence_maxsz +\
823 				encode_getdeviceinfo_maxsz)
824 #define NFS4_dec_getdeviceinfo_sz (compound_decode_hdr_maxsz +    \
825 				decode_sequence_maxsz + \
826 				decode_getdeviceinfo_maxsz)
827 #define NFS4_enc_layoutget_sz	(compound_encode_hdr_maxsz + \
828 				encode_sequence_maxsz + \
829 				encode_putfh_maxsz +        \
830 				encode_layoutget_maxsz)
831 #define NFS4_dec_layoutget_sz	(compound_decode_hdr_maxsz + \
832 				decode_sequence_maxsz + \
833 				decode_putfh_maxsz +        \
834 				decode_layoutget_maxsz)
835 #define NFS4_enc_layoutcommit_sz (compound_encode_hdr_maxsz + \
836 				encode_sequence_maxsz +\
837 				encode_putfh_maxsz + \
838 				encode_layoutcommit_maxsz + \
839 				encode_getattr_maxsz)
840 #define NFS4_dec_layoutcommit_sz (compound_decode_hdr_maxsz + \
841 				decode_sequence_maxsz + \
842 				decode_putfh_maxsz + \
843 				decode_layoutcommit_maxsz + \
844 				decode_getattr_maxsz)
845 #define NFS4_enc_layoutreturn_sz (compound_encode_hdr_maxsz + \
846 				encode_sequence_maxsz + \
847 				encode_putfh_maxsz + \
848 				encode_layoutreturn_maxsz)
849 #define NFS4_dec_layoutreturn_sz (compound_decode_hdr_maxsz + \
850 				decode_sequence_maxsz + \
851 				decode_putfh_maxsz + \
852 				decode_layoutreturn_maxsz)
853 #define NFS4_enc_secinfo_no_name_sz	(compound_encode_hdr_maxsz + \
854 					encode_sequence_maxsz + \
855 					encode_putrootfh_maxsz +\
856 					encode_secinfo_no_name_maxsz)
857 #define NFS4_dec_secinfo_no_name_sz	(compound_decode_hdr_maxsz + \
858 					decode_sequence_maxsz + \
859 					decode_putrootfh_maxsz + \
860 					decode_secinfo_no_name_maxsz)
861 #define NFS4_enc_test_stateid_sz	(compound_encode_hdr_maxsz + \
862 					 encode_sequence_maxsz + \
863 					 encode_test_stateid_maxsz)
864 #define NFS4_dec_test_stateid_sz	(compound_decode_hdr_maxsz + \
865 					 decode_sequence_maxsz + \
866 					 decode_test_stateid_maxsz)
867 #define NFS4_enc_free_stateid_sz	(compound_encode_hdr_maxsz + \
868 					 encode_sequence_maxsz + \
869 					 encode_free_stateid_maxsz)
870 #define NFS4_dec_free_stateid_sz	(compound_decode_hdr_maxsz + \
871 					 decode_sequence_maxsz + \
872 					 decode_free_stateid_maxsz)
873 
874 const u32 nfs41_maxwrite_overhead = ((RPC_MAX_HEADER_WITH_AUTH +
875 				      compound_encode_hdr_maxsz +
876 				      encode_sequence_maxsz +
877 				      encode_putfh_maxsz +
878 				      encode_getattr_maxsz) *
879 				     XDR_UNIT);
880 
881 const u32 nfs41_maxread_overhead = ((RPC_MAX_HEADER_WITH_AUTH +
882 				     compound_decode_hdr_maxsz +
883 				     decode_sequence_maxsz +
884 				     decode_putfh_maxsz) *
885 				    XDR_UNIT);
886 
887 const u32 nfs41_maxgetdevinfo_overhead = ((RPC_MAX_REPHEADER_WITH_AUTH +
888 					   compound_decode_hdr_maxsz +
889 					   decode_sequence_maxsz) *
890 					  XDR_UNIT);
891 EXPORT_SYMBOL_GPL(nfs41_maxgetdevinfo_overhead);
892 #endif /* CONFIG_NFS_V4_1 */
893 
894 static const umode_t nfs_type2fmt[] = {
895 	[NF4BAD] = 0,
896 	[NF4REG] = S_IFREG,
897 	[NF4DIR] = S_IFDIR,
898 	[NF4BLK] = S_IFBLK,
899 	[NF4CHR] = S_IFCHR,
900 	[NF4LNK] = S_IFLNK,
901 	[NF4SOCK] = S_IFSOCK,
902 	[NF4FIFO] = S_IFIFO,
903 	[NF4ATTRDIR] = 0,
904 	[NF4NAMEDATTR] = 0,
905 };
906 
907 struct compound_hdr {
908 	int32_t		status;
909 	uint32_t	nops;
910 	__be32 *	nops_p;
911 	uint32_t	taglen;
912 	char *		tag;
913 	uint32_t	replen;		/* expected reply words */
914 	u32		minorversion;
915 };
916 
917 static __be32 *reserve_space(struct xdr_stream *xdr, size_t nbytes)
918 {
919 	__be32 *p = xdr_reserve_space(xdr, nbytes);
920 	BUG_ON(!p);
921 	return p;
922 }
923 
924 static void encode_opaque_fixed(struct xdr_stream *xdr, const void *buf, size_t len)
925 {
926 	__be32 *p;
927 
928 	p = xdr_reserve_space(xdr, len);
929 	xdr_encode_opaque_fixed(p, buf, len);
930 }
931 
932 static void encode_string(struct xdr_stream *xdr, unsigned int len, const char *str)
933 {
934 	__be32 *p;
935 
936 	p = reserve_space(xdr, 4 + len);
937 	xdr_encode_opaque(p, str, len);
938 }
939 
940 static void encode_uint32(struct xdr_stream *xdr, u32 n)
941 {
942 	__be32 *p;
943 
944 	p = reserve_space(xdr, 4);
945 	*p = cpu_to_be32(n);
946 }
947 
948 static void encode_uint64(struct xdr_stream *xdr, u64 n)
949 {
950 	__be32 *p;
951 
952 	p = reserve_space(xdr, 8);
953 	xdr_encode_hyper(p, n);
954 }
955 
956 static void encode_nfs4_seqid(struct xdr_stream *xdr,
957 		const struct nfs_seqid *seqid)
958 {
959 	encode_uint32(xdr, seqid->sequence->counter);
960 }
961 
962 static void encode_compound_hdr(struct xdr_stream *xdr,
963 				struct rpc_rqst *req,
964 				struct compound_hdr *hdr)
965 {
966 	__be32 *p;
967 	struct rpc_auth *auth = req->rq_cred->cr_auth;
968 
969 	/* initialize running count of expected bytes in reply.
970 	 * NOTE: the replied tag SHOULD be the same is the one sent,
971 	 * but this is not required as a MUST for the server to do so. */
972 	hdr->replen = RPC_REPHDRSIZE + auth->au_rslack + 3 + hdr->taglen;
973 
974 	WARN_ON_ONCE(hdr->taglen > NFS4_MAXTAGLEN);
975 	encode_string(xdr, hdr->taglen, hdr->tag);
976 	p = reserve_space(xdr, 8);
977 	*p++ = cpu_to_be32(hdr->minorversion);
978 	hdr->nops_p = p;
979 	*p = cpu_to_be32(hdr->nops);
980 }
981 
982 static void encode_op_hdr(struct xdr_stream *xdr, enum nfs_opnum4 op,
983 		uint32_t replen,
984 		struct compound_hdr *hdr)
985 {
986 	encode_uint32(xdr, op);
987 	hdr->nops++;
988 	hdr->replen += replen;
989 }
990 
991 static void encode_nops(struct compound_hdr *hdr)
992 {
993 	WARN_ON_ONCE(hdr->nops > NFS4_MAX_OPS);
994 	*hdr->nops_p = htonl(hdr->nops);
995 }
996 
997 static void encode_nfs4_stateid(struct xdr_stream *xdr, const nfs4_stateid *stateid)
998 {
999 	encode_opaque_fixed(xdr, stateid, NFS4_STATEID_SIZE);
1000 }
1001 
1002 static void encode_nfs4_verifier(struct xdr_stream *xdr, const nfs4_verifier *verf)
1003 {
1004 	encode_opaque_fixed(xdr, verf->data, NFS4_VERIFIER_SIZE);
1005 }
1006 
1007 static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap,
1008 				const struct nfs4_label *label,
1009 				const struct nfs_server *server)
1010 {
1011 	char owner_name[IDMAP_NAMESZ];
1012 	char owner_group[IDMAP_NAMESZ];
1013 	int owner_namelen = 0;
1014 	int owner_grouplen = 0;
1015 	__be32 *p;
1016 	unsigned i;
1017 	uint32_t len = 0;
1018 	uint32_t bmval_len;
1019 	uint32_t bmval[3] = { 0 };
1020 
1021 	/*
1022 	 * We reserve enough space to write the entire attribute buffer at once.
1023 	 * In the worst-case, this would be
1024 	 * 16(bitmap) + 4(attrlen) + 8(size) + 4(mode) + 4(atime) + 4(mtime)
1025 	 * = 40 bytes, plus any contribution from variable-length fields
1026 	 *            such as owner/group.
1027 	 */
1028 	if (iap->ia_valid & ATTR_SIZE) {
1029 		bmval[0] |= FATTR4_WORD0_SIZE;
1030 		len += 8;
1031 	}
1032 	if (iap->ia_valid & ATTR_MODE) {
1033 		bmval[1] |= FATTR4_WORD1_MODE;
1034 		len += 4;
1035 	}
1036 	if (iap->ia_valid & ATTR_UID) {
1037 		owner_namelen = nfs_map_uid_to_name(server, iap->ia_uid, owner_name, IDMAP_NAMESZ);
1038 		if (owner_namelen < 0) {
1039 			dprintk("nfs: couldn't resolve uid %d to string\n",
1040 					from_kuid(&init_user_ns, iap->ia_uid));
1041 			/* XXX */
1042 			strcpy(owner_name, "nobody");
1043 			owner_namelen = sizeof("nobody") - 1;
1044 			/* goto out; */
1045 		}
1046 		bmval[1] |= FATTR4_WORD1_OWNER;
1047 		len += 4 + (XDR_QUADLEN(owner_namelen) << 2);
1048 	}
1049 	if (iap->ia_valid & ATTR_GID) {
1050 		owner_grouplen = nfs_map_gid_to_group(server, iap->ia_gid, owner_group, IDMAP_NAMESZ);
1051 		if (owner_grouplen < 0) {
1052 			dprintk("nfs: couldn't resolve gid %d to string\n",
1053 					from_kgid(&init_user_ns, iap->ia_gid));
1054 			strcpy(owner_group, "nobody");
1055 			owner_grouplen = sizeof("nobody") - 1;
1056 			/* goto out; */
1057 		}
1058 		bmval[1] |= FATTR4_WORD1_OWNER_GROUP;
1059 		len += 4 + (XDR_QUADLEN(owner_grouplen) << 2);
1060 	}
1061 	if (iap->ia_valid & ATTR_ATIME_SET) {
1062 		bmval[1] |= FATTR4_WORD1_TIME_ACCESS_SET;
1063 		len += 16;
1064 	} else if (iap->ia_valid & ATTR_ATIME) {
1065 		bmval[1] |= FATTR4_WORD1_TIME_ACCESS_SET;
1066 		len += 4;
1067 	}
1068 	if (iap->ia_valid & ATTR_MTIME_SET) {
1069 		bmval[1] |= FATTR4_WORD1_TIME_MODIFY_SET;
1070 		len += 16;
1071 	} else if (iap->ia_valid & ATTR_MTIME) {
1072 		bmval[1] |= FATTR4_WORD1_TIME_MODIFY_SET;
1073 		len += 4;
1074 	}
1075 	if (label) {
1076 		len += 4 + 4 + 4 + (XDR_QUADLEN(label->len) << 2);
1077 		bmval[2] |= FATTR4_WORD2_SECURITY_LABEL;
1078 	}
1079 
1080 	if (bmval[2] != 0)
1081 		bmval_len = 3;
1082 	else if (bmval[1] != 0)
1083 		bmval_len = 2;
1084 	else
1085 		bmval_len = 1;
1086 
1087 	p = reserve_space(xdr, 4 + (bmval_len << 2) + 4 + len);
1088 
1089 	*p++ = cpu_to_be32(bmval_len);
1090 	for (i = 0; i < bmval_len; i++)
1091 		*p++ = cpu_to_be32(bmval[i]);
1092 	*p++ = cpu_to_be32(len);
1093 
1094 	if (bmval[0] & FATTR4_WORD0_SIZE)
1095 		p = xdr_encode_hyper(p, iap->ia_size);
1096 	if (bmval[1] & FATTR4_WORD1_MODE)
1097 		*p++ = cpu_to_be32(iap->ia_mode & S_IALLUGO);
1098 	if (bmval[1] & FATTR4_WORD1_OWNER)
1099 		p = xdr_encode_opaque(p, owner_name, owner_namelen);
1100 	if (bmval[1] & FATTR4_WORD1_OWNER_GROUP)
1101 		p = xdr_encode_opaque(p, owner_group, owner_grouplen);
1102 	if (bmval[1] & FATTR4_WORD1_TIME_ACCESS_SET) {
1103 		if (iap->ia_valid & ATTR_ATIME_SET) {
1104 			*p++ = cpu_to_be32(NFS4_SET_TO_CLIENT_TIME);
1105 			p = xdr_encode_hyper(p, (s64)iap->ia_atime.tv_sec);
1106 			*p++ = cpu_to_be32(iap->ia_atime.tv_nsec);
1107 		} else
1108 			*p++ = cpu_to_be32(NFS4_SET_TO_SERVER_TIME);
1109 	}
1110 	if (bmval[1] & FATTR4_WORD1_TIME_MODIFY_SET) {
1111 		if (iap->ia_valid & ATTR_MTIME_SET) {
1112 			*p++ = cpu_to_be32(NFS4_SET_TO_CLIENT_TIME);
1113 			p = xdr_encode_hyper(p, (s64)iap->ia_mtime.tv_sec);
1114 			*p++ = cpu_to_be32(iap->ia_mtime.tv_nsec);
1115 		} else
1116 			*p++ = cpu_to_be32(NFS4_SET_TO_SERVER_TIME);
1117 	}
1118 	if (bmval[2] & FATTR4_WORD2_SECURITY_LABEL) {
1119 		*p++ = cpu_to_be32(label->lfs);
1120 		*p++ = cpu_to_be32(label->pi);
1121 		*p++ = cpu_to_be32(label->len);
1122 		p = xdr_encode_opaque_fixed(p, label->label, label->len);
1123 	}
1124 
1125 /* out: */
1126 }
1127 
1128 static void encode_access(struct xdr_stream *xdr, u32 access, struct compound_hdr *hdr)
1129 {
1130 	encode_op_hdr(xdr, OP_ACCESS, decode_access_maxsz, hdr);
1131 	encode_uint32(xdr, access);
1132 }
1133 
1134 static void encode_close(struct xdr_stream *xdr, const struct nfs_closeargs *arg, struct compound_hdr *hdr)
1135 {
1136 	encode_op_hdr(xdr, OP_CLOSE, decode_close_maxsz, hdr);
1137 	encode_nfs4_seqid(xdr, arg->seqid);
1138 	encode_nfs4_stateid(xdr, arg->stateid);
1139 }
1140 
1141 static void encode_commit(struct xdr_stream *xdr, const struct nfs_commitargs *args, struct compound_hdr *hdr)
1142 {
1143 	__be32 *p;
1144 
1145 	encode_op_hdr(xdr, OP_COMMIT, decode_commit_maxsz, hdr);
1146 	p = reserve_space(xdr, 12);
1147 	p = xdr_encode_hyper(p, args->offset);
1148 	*p = cpu_to_be32(args->count);
1149 }
1150 
1151 static void encode_create(struct xdr_stream *xdr, const struct nfs4_create_arg *create, struct compound_hdr *hdr)
1152 {
1153 	__be32 *p;
1154 
1155 	encode_op_hdr(xdr, OP_CREATE, decode_create_maxsz, hdr);
1156 	encode_uint32(xdr, create->ftype);
1157 
1158 	switch (create->ftype) {
1159 	case NF4LNK:
1160 		p = reserve_space(xdr, 4);
1161 		*p = cpu_to_be32(create->u.symlink.len);
1162 		xdr_write_pages(xdr, create->u.symlink.pages, 0, create->u.symlink.len);
1163 		break;
1164 
1165 	case NF4BLK: case NF4CHR:
1166 		p = reserve_space(xdr, 8);
1167 		*p++ = cpu_to_be32(create->u.device.specdata1);
1168 		*p = cpu_to_be32(create->u.device.specdata2);
1169 		break;
1170 
1171 	default:
1172 		break;
1173 	}
1174 
1175 	encode_string(xdr, create->name->len, create->name->name);
1176 	encode_attrs(xdr, create->attrs, create->label, create->server);
1177 }
1178 
1179 static void encode_getattr_one(struct xdr_stream *xdr, uint32_t bitmap, struct compound_hdr *hdr)
1180 {
1181 	__be32 *p;
1182 
1183 	encode_op_hdr(xdr, OP_GETATTR, decode_getattr_maxsz, hdr);
1184 	p = reserve_space(xdr, 8);
1185 	*p++ = cpu_to_be32(1);
1186 	*p = cpu_to_be32(bitmap);
1187 }
1188 
1189 static void encode_getattr_two(struct xdr_stream *xdr, uint32_t bm0, uint32_t bm1, struct compound_hdr *hdr)
1190 {
1191 	__be32 *p;
1192 
1193 	encode_op_hdr(xdr, OP_GETATTR, decode_getattr_maxsz, hdr);
1194 	p = reserve_space(xdr, 12);
1195 	*p++ = cpu_to_be32(2);
1196 	*p++ = cpu_to_be32(bm0);
1197 	*p = cpu_to_be32(bm1);
1198 }
1199 
1200 static void
1201 encode_getattr_three(struct xdr_stream *xdr,
1202 		     uint32_t bm0, uint32_t bm1, uint32_t bm2,
1203 		     struct compound_hdr *hdr)
1204 {
1205 	__be32 *p;
1206 
1207 	encode_op_hdr(xdr, OP_GETATTR, decode_getattr_maxsz, hdr);
1208 	if (bm2) {
1209 		p = reserve_space(xdr, 16);
1210 		*p++ = cpu_to_be32(3);
1211 		*p++ = cpu_to_be32(bm0);
1212 		*p++ = cpu_to_be32(bm1);
1213 		*p = cpu_to_be32(bm2);
1214 	} else if (bm1) {
1215 		p = reserve_space(xdr, 12);
1216 		*p++ = cpu_to_be32(2);
1217 		*p++ = cpu_to_be32(bm0);
1218 		*p = cpu_to_be32(bm1);
1219 	} else {
1220 		p = reserve_space(xdr, 8);
1221 		*p++ = cpu_to_be32(1);
1222 		*p = cpu_to_be32(bm0);
1223 	}
1224 }
1225 
1226 static void encode_getfattr(struct xdr_stream *xdr, const u32* bitmask, struct compound_hdr *hdr)
1227 {
1228 	encode_getattr_three(xdr, bitmask[0] & nfs4_fattr_bitmap[0],
1229 			   bitmask[1] & nfs4_fattr_bitmap[1],
1230 			   bitmask[2] & nfs4_fattr_bitmap[2],
1231 			   hdr);
1232 }
1233 
1234 static void encode_getfattr_open(struct xdr_stream *xdr, const u32 *bitmask,
1235 				 const u32 *open_bitmap,
1236 				 struct compound_hdr *hdr)
1237 {
1238 	encode_getattr_three(xdr,
1239 			     bitmask[0] & open_bitmap[0],
1240 			     bitmask[1] & open_bitmap[1],
1241 			     bitmask[2] & open_bitmap[2],
1242 			     hdr);
1243 }
1244 
1245 static void encode_fsinfo(struct xdr_stream *xdr, const u32* bitmask, struct compound_hdr *hdr)
1246 {
1247 	encode_getattr_three(xdr,
1248 			     bitmask[0] & nfs4_fsinfo_bitmap[0],
1249 			     bitmask[1] & nfs4_fsinfo_bitmap[1],
1250 			     bitmask[2] & nfs4_fsinfo_bitmap[2],
1251 			     hdr);
1252 }
1253 
1254 static void encode_fs_locations(struct xdr_stream *xdr, const u32* bitmask, struct compound_hdr *hdr)
1255 {
1256 	encode_getattr_two(xdr, bitmask[0] & nfs4_fs_locations_bitmap[0],
1257 			   bitmask[1] & nfs4_fs_locations_bitmap[1], hdr);
1258 }
1259 
1260 static void encode_getfh(struct xdr_stream *xdr, struct compound_hdr *hdr)
1261 {
1262 	encode_op_hdr(xdr, OP_GETFH, decode_getfh_maxsz, hdr);
1263 }
1264 
1265 static void encode_link(struct xdr_stream *xdr, const struct qstr *name, struct compound_hdr *hdr)
1266 {
1267 	encode_op_hdr(xdr, OP_LINK, decode_link_maxsz, hdr);
1268 	encode_string(xdr, name->len, name->name);
1269 }
1270 
1271 static inline int nfs4_lock_type(struct file_lock *fl, int block)
1272 {
1273 	if (fl->fl_type == F_RDLCK)
1274 		return block ? NFS4_READW_LT : NFS4_READ_LT;
1275 	return block ? NFS4_WRITEW_LT : NFS4_WRITE_LT;
1276 }
1277 
1278 static inline uint64_t nfs4_lock_length(struct file_lock *fl)
1279 {
1280 	if (fl->fl_end == OFFSET_MAX)
1281 		return ~(uint64_t)0;
1282 	return fl->fl_end - fl->fl_start + 1;
1283 }
1284 
1285 static void encode_lockowner(struct xdr_stream *xdr, const struct nfs_lowner *lowner)
1286 {
1287 	__be32 *p;
1288 
1289 	p = reserve_space(xdr, 32);
1290 	p = xdr_encode_hyper(p, lowner->clientid);
1291 	*p++ = cpu_to_be32(20);
1292 	p = xdr_encode_opaque_fixed(p, "lock id:", 8);
1293 	*p++ = cpu_to_be32(lowner->s_dev);
1294 	xdr_encode_hyper(p, lowner->id);
1295 }
1296 
1297 /*
1298  * opcode,type,reclaim,offset,length,new_lock_owner = 32
1299  * open_seqid,open_stateid,lock_seqid,lock_owner.clientid, lock_owner.id = 40
1300  */
1301 static void encode_lock(struct xdr_stream *xdr, const struct nfs_lock_args *args, struct compound_hdr *hdr)
1302 {
1303 	__be32 *p;
1304 
1305 	encode_op_hdr(xdr, OP_LOCK, decode_lock_maxsz, hdr);
1306 	p = reserve_space(xdr, 28);
1307 	*p++ = cpu_to_be32(nfs4_lock_type(args->fl, args->block));
1308 	*p++ = cpu_to_be32(args->reclaim);
1309 	p = xdr_encode_hyper(p, args->fl->fl_start);
1310 	p = xdr_encode_hyper(p, nfs4_lock_length(args->fl));
1311 	*p = cpu_to_be32(args->new_lock_owner);
1312 	if (args->new_lock_owner){
1313 		encode_nfs4_seqid(xdr, args->open_seqid);
1314 		encode_nfs4_stateid(xdr, args->open_stateid);
1315 		encode_nfs4_seqid(xdr, args->lock_seqid);
1316 		encode_lockowner(xdr, &args->lock_owner);
1317 	}
1318 	else {
1319 		encode_nfs4_stateid(xdr, args->lock_stateid);
1320 		encode_nfs4_seqid(xdr, args->lock_seqid);
1321 	}
1322 }
1323 
1324 static void encode_lockt(struct xdr_stream *xdr, const struct nfs_lockt_args *args, struct compound_hdr *hdr)
1325 {
1326 	__be32 *p;
1327 
1328 	encode_op_hdr(xdr, OP_LOCKT, decode_lockt_maxsz, hdr);
1329 	p = reserve_space(xdr, 20);
1330 	*p++ = cpu_to_be32(nfs4_lock_type(args->fl, 0));
1331 	p = xdr_encode_hyper(p, args->fl->fl_start);
1332 	p = xdr_encode_hyper(p, nfs4_lock_length(args->fl));
1333 	encode_lockowner(xdr, &args->lock_owner);
1334 }
1335 
1336 static void encode_locku(struct xdr_stream *xdr, const struct nfs_locku_args *args, struct compound_hdr *hdr)
1337 {
1338 	__be32 *p;
1339 
1340 	encode_op_hdr(xdr, OP_LOCKU, decode_locku_maxsz, hdr);
1341 	encode_uint32(xdr, nfs4_lock_type(args->fl, 0));
1342 	encode_nfs4_seqid(xdr, args->seqid);
1343 	encode_nfs4_stateid(xdr, args->stateid);
1344 	p = reserve_space(xdr, 16);
1345 	p = xdr_encode_hyper(p, args->fl->fl_start);
1346 	xdr_encode_hyper(p, nfs4_lock_length(args->fl));
1347 }
1348 
1349 static void encode_release_lockowner(struct xdr_stream *xdr, const struct nfs_lowner *lowner, struct compound_hdr *hdr)
1350 {
1351 	encode_op_hdr(xdr, OP_RELEASE_LOCKOWNER, decode_release_lockowner_maxsz, hdr);
1352 	encode_lockowner(xdr, lowner);
1353 }
1354 
1355 static void encode_lookup(struct xdr_stream *xdr, const struct qstr *name, struct compound_hdr *hdr)
1356 {
1357 	encode_op_hdr(xdr, OP_LOOKUP, decode_lookup_maxsz, hdr);
1358 	encode_string(xdr, name->len, name->name);
1359 }
1360 
1361 static void encode_share_access(struct xdr_stream *xdr, fmode_t fmode)
1362 {
1363 	__be32 *p;
1364 
1365 	p = reserve_space(xdr, 8);
1366 	switch (fmode & (FMODE_READ|FMODE_WRITE)) {
1367 	case FMODE_READ:
1368 		*p++ = cpu_to_be32(NFS4_SHARE_ACCESS_READ);
1369 		break;
1370 	case FMODE_WRITE:
1371 		*p++ = cpu_to_be32(NFS4_SHARE_ACCESS_WRITE);
1372 		break;
1373 	case FMODE_READ|FMODE_WRITE:
1374 		*p++ = cpu_to_be32(NFS4_SHARE_ACCESS_BOTH);
1375 		break;
1376 	default:
1377 		*p++ = cpu_to_be32(0);
1378 	}
1379 	*p = cpu_to_be32(0);		/* for linux, share_deny = 0 always */
1380 }
1381 
1382 static inline void encode_openhdr(struct xdr_stream *xdr, const struct nfs_openargs *arg)
1383 {
1384 	__be32 *p;
1385  /*
1386  * opcode 4, seqid 4, share_access 4, share_deny 4, clientid 8, ownerlen 4,
1387  * owner 4 = 32
1388  */
1389 	encode_nfs4_seqid(xdr, arg->seqid);
1390 	encode_share_access(xdr, arg->fmode);
1391 	p = reserve_space(xdr, 36);
1392 	p = xdr_encode_hyper(p, arg->clientid);
1393 	*p++ = cpu_to_be32(24);
1394 	p = xdr_encode_opaque_fixed(p, "open id:", 8);
1395 	*p++ = cpu_to_be32(arg->server->s_dev);
1396 	*p++ = cpu_to_be32(arg->id.uniquifier);
1397 	xdr_encode_hyper(p, arg->id.create_time);
1398 }
1399 
1400 static inline void encode_createmode(struct xdr_stream *xdr, const struct nfs_openargs *arg)
1401 {
1402 	struct iattr dummy;
1403 	__be32 *p;
1404 
1405 	p = reserve_space(xdr, 4);
1406 	switch(arg->createmode) {
1407 	case NFS4_CREATE_UNCHECKED:
1408 		*p = cpu_to_be32(NFS4_CREATE_UNCHECKED);
1409 		encode_attrs(xdr, arg->u.attrs, arg->label, arg->server);
1410 		break;
1411 	case NFS4_CREATE_GUARDED:
1412 		*p = cpu_to_be32(NFS4_CREATE_GUARDED);
1413 		encode_attrs(xdr, arg->u.attrs, arg->label, arg->server);
1414 		break;
1415 	case NFS4_CREATE_EXCLUSIVE:
1416 		*p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE);
1417 		encode_nfs4_verifier(xdr, &arg->u.verifier);
1418 		break;
1419 	case NFS4_CREATE_EXCLUSIVE4_1:
1420 		*p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE4_1);
1421 		encode_nfs4_verifier(xdr, &arg->u.verifier);
1422 		dummy.ia_valid = 0;
1423 		encode_attrs(xdr, &dummy, arg->label, arg->server);
1424 	}
1425 }
1426 
1427 static void encode_opentype(struct xdr_stream *xdr, const struct nfs_openargs *arg)
1428 {
1429 	__be32 *p;
1430 
1431 	p = reserve_space(xdr, 4);
1432 	switch (arg->open_flags & O_CREAT) {
1433 	case 0:
1434 		*p = cpu_to_be32(NFS4_OPEN_NOCREATE);
1435 		break;
1436 	default:
1437 		*p = cpu_to_be32(NFS4_OPEN_CREATE);
1438 		encode_createmode(xdr, arg);
1439 	}
1440 }
1441 
1442 static inline void encode_delegation_type(struct xdr_stream *xdr, fmode_t delegation_type)
1443 {
1444 	__be32 *p;
1445 
1446 	p = reserve_space(xdr, 4);
1447 	switch (delegation_type) {
1448 	case 0:
1449 		*p = cpu_to_be32(NFS4_OPEN_DELEGATE_NONE);
1450 		break;
1451 	case FMODE_READ:
1452 		*p = cpu_to_be32(NFS4_OPEN_DELEGATE_READ);
1453 		break;
1454 	case FMODE_WRITE|FMODE_READ:
1455 		*p = cpu_to_be32(NFS4_OPEN_DELEGATE_WRITE);
1456 		break;
1457 	default:
1458 		BUG();
1459 	}
1460 }
1461 
1462 static inline void encode_claim_null(struct xdr_stream *xdr, const struct qstr *name)
1463 {
1464 	__be32 *p;
1465 
1466 	p = reserve_space(xdr, 4);
1467 	*p = cpu_to_be32(NFS4_OPEN_CLAIM_NULL);
1468 	encode_string(xdr, name->len, name->name);
1469 }
1470 
1471 static inline void encode_claim_previous(struct xdr_stream *xdr, fmode_t type)
1472 {
1473 	__be32 *p;
1474 
1475 	p = reserve_space(xdr, 4);
1476 	*p = cpu_to_be32(NFS4_OPEN_CLAIM_PREVIOUS);
1477 	encode_delegation_type(xdr, type);
1478 }
1479 
1480 static inline void encode_claim_delegate_cur(struct xdr_stream *xdr, const struct qstr *name, const nfs4_stateid *stateid)
1481 {
1482 	__be32 *p;
1483 
1484 	p = reserve_space(xdr, 4);
1485 	*p = cpu_to_be32(NFS4_OPEN_CLAIM_DELEGATE_CUR);
1486 	encode_nfs4_stateid(xdr, stateid);
1487 	encode_string(xdr, name->len, name->name);
1488 }
1489 
1490 static inline void encode_claim_fh(struct xdr_stream *xdr)
1491 {
1492 	__be32 *p;
1493 
1494 	p = reserve_space(xdr, 4);
1495 	*p = cpu_to_be32(NFS4_OPEN_CLAIM_FH);
1496 }
1497 
1498 static inline void encode_claim_delegate_cur_fh(struct xdr_stream *xdr, const nfs4_stateid *stateid)
1499 {
1500 	__be32 *p;
1501 
1502 	p = reserve_space(xdr, 4);
1503 	*p = cpu_to_be32(NFS4_OPEN_CLAIM_DELEG_CUR_FH);
1504 	encode_nfs4_stateid(xdr, stateid);
1505 }
1506 
1507 static void encode_open(struct xdr_stream *xdr, const struct nfs_openargs *arg, struct compound_hdr *hdr)
1508 {
1509 	encode_op_hdr(xdr, OP_OPEN, decode_open_maxsz, hdr);
1510 	encode_openhdr(xdr, arg);
1511 	encode_opentype(xdr, arg);
1512 	switch (arg->claim) {
1513 	case NFS4_OPEN_CLAIM_NULL:
1514 		encode_claim_null(xdr, arg->name);
1515 		break;
1516 	case NFS4_OPEN_CLAIM_PREVIOUS:
1517 		encode_claim_previous(xdr, arg->u.delegation_type);
1518 		break;
1519 	case NFS4_OPEN_CLAIM_DELEGATE_CUR:
1520 		encode_claim_delegate_cur(xdr, arg->name, &arg->u.delegation);
1521 		break;
1522 	case NFS4_OPEN_CLAIM_FH:
1523 		encode_claim_fh(xdr);
1524 		break;
1525 	case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
1526 		encode_claim_delegate_cur_fh(xdr, &arg->u.delegation);
1527 		break;
1528 	default:
1529 		BUG();
1530 	}
1531 }
1532 
1533 static void encode_open_confirm(struct xdr_stream *xdr, const struct nfs_open_confirmargs *arg, struct compound_hdr *hdr)
1534 {
1535 	encode_op_hdr(xdr, OP_OPEN_CONFIRM, decode_open_confirm_maxsz, hdr);
1536 	encode_nfs4_stateid(xdr, arg->stateid);
1537 	encode_nfs4_seqid(xdr, arg->seqid);
1538 }
1539 
1540 static void encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closeargs *arg, struct compound_hdr *hdr)
1541 {
1542 	encode_op_hdr(xdr, OP_OPEN_DOWNGRADE, decode_open_downgrade_maxsz, hdr);
1543 	encode_nfs4_stateid(xdr, arg->stateid);
1544 	encode_nfs4_seqid(xdr, arg->seqid);
1545 	encode_share_access(xdr, arg->fmode);
1546 }
1547 
1548 static void
1549 encode_putfh(struct xdr_stream *xdr, const struct nfs_fh *fh, struct compound_hdr *hdr)
1550 {
1551 	encode_op_hdr(xdr, OP_PUTFH, decode_putfh_maxsz, hdr);
1552 	encode_string(xdr, fh->size, fh->data);
1553 }
1554 
1555 static void encode_putrootfh(struct xdr_stream *xdr, struct compound_hdr *hdr)
1556 {
1557 	encode_op_hdr(xdr, OP_PUTROOTFH, decode_putrootfh_maxsz, hdr);
1558 }
1559 
1560 static void encode_read(struct xdr_stream *xdr, const struct nfs_readargs *args, struct compound_hdr *hdr)
1561 {
1562 	__be32 *p;
1563 
1564 	encode_op_hdr(xdr, OP_READ, decode_read_maxsz, hdr);
1565 	encode_nfs4_stateid(xdr, &args->stateid);
1566 
1567 	p = reserve_space(xdr, 12);
1568 	p = xdr_encode_hyper(p, args->offset);
1569 	*p = cpu_to_be32(args->count);
1570 }
1571 
1572 static void encode_readdir(struct xdr_stream *xdr, const struct nfs4_readdir_arg *readdir, struct rpc_rqst *req, struct compound_hdr *hdr)
1573 {
1574 	uint32_t attrs[3] = {
1575 		FATTR4_WORD0_RDATTR_ERROR,
1576 		FATTR4_WORD1_MOUNTED_ON_FILEID,
1577 	};
1578 	uint32_t dircount = readdir->count >> 1;
1579 	__be32 *p, verf[2];
1580 	uint32_t attrlen = 0;
1581 	unsigned int i;
1582 
1583 	if (readdir->plus) {
1584 		attrs[0] |= FATTR4_WORD0_TYPE|FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE|
1585 			FATTR4_WORD0_FSID|FATTR4_WORD0_FILEHANDLE|FATTR4_WORD0_FILEID;
1586 		attrs[1] |= FATTR4_WORD1_MODE|FATTR4_WORD1_NUMLINKS|FATTR4_WORD1_OWNER|
1587 			FATTR4_WORD1_OWNER_GROUP|FATTR4_WORD1_RAWDEV|
1588 			FATTR4_WORD1_SPACE_USED|FATTR4_WORD1_TIME_ACCESS|
1589 			FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY;
1590 		attrs[2] |= FATTR4_WORD2_SECURITY_LABEL;
1591 		dircount >>= 1;
1592 	}
1593 	/* Use mounted_on_fileid only if the server supports it */
1594 	if (!(readdir->bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID))
1595 		attrs[0] |= FATTR4_WORD0_FILEID;
1596 	for (i = 0; i < ARRAY_SIZE(attrs); i++) {
1597 		attrs[i] &= readdir->bitmask[i];
1598 		if (attrs[i] != 0)
1599 			attrlen = i+1;
1600 	}
1601 
1602 	encode_op_hdr(xdr, OP_READDIR, decode_readdir_maxsz, hdr);
1603 	encode_uint64(xdr, readdir->cookie);
1604 	encode_nfs4_verifier(xdr, &readdir->verifier);
1605 	p = reserve_space(xdr, 12 + (attrlen << 2));
1606 	*p++ = cpu_to_be32(dircount);
1607 	*p++ = cpu_to_be32(readdir->count);
1608 	*p++ = cpu_to_be32(attrlen);
1609 	for (i = 0; i < attrlen; i++)
1610 		*p++ = cpu_to_be32(attrs[i]);
1611 	memcpy(verf, readdir->verifier.data, sizeof(verf));
1612 
1613 	dprintk("%s: cookie = %llu, verifier = %08x:%08x, bitmap = %08x:%08x:%08x\n",
1614 			__func__,
1615 			(unsigned long long)readdir->cookie,
1616 			verf[0], verf[1],
1617 			attrs[0] & readdir->bitmask[0],
1618 			attrs[1] & readdir->bitmask[1],
1619 			attrs[2] & readdir->bitmask[2]);
1620 }
1621 
1622 static void encode_readlink(struct xdr_stream *xdr, const struct nfs4_readlink *readlink, struct rpc_rqst *req, struct compound_hdr *hdr)
1623 {
1624 	encode_op_hdr(xdr, OP_READLINK, decode_readlink_maxsz, hdr);
1625 }
1626 
1627 static void encode_remove(struct xdr_stream *xdr, const struct qstr *name, struct compound_hdr *hdr)
1628 {
1629 	encode_op_hdr(xdr, OP_REMOVE, decode_remove_maxsz, hdr);
1630 	encode_string(xdr, name->len, name->name);
1631 }
1632 
1633 static void encode_rename(struct xdr_stream *xdr, const struct qstr *oldname, const struct qstr *newname, struct compound_hdr *hdr)
1634 {
1635 	encode_op_hdr(xdr, OP_RENAME, decode_rename_maxsz, hdr);
1636 	encode_string(xdr, oldname->len, oldname->name);
1637 	encode_string(xdr, newname->len, newname->name);
1638 }
1639 
1640 static void encode_renew(struct xdr_stream *xdr, clientid4 clid,
1641 			 struct compound_hdr *hdr)
1642 {
1643 	encode_op_hdr(xdr, OP_RENEW, decode_renew_maxsz, hdr);
1644 	encode_uint64(xdr, clid);
1645 }
1646 
1647 static void
1648 encode_restorefh(struct xdr_stream *xdr, struct compound_hdr *hdr)
1649 {
1650 	encode_op_hdr(xdr, OP_RESTOREFH, decode_restorefh_maxsz, hdr);
1651 }
1652 
1653 static void
1654 encode_setacl(struct xdr_stream *xdr, struct nfs_setaclargs *arg, struct compound_hdr *hdr)
1655 {
1656 	__be32 *p;
1657 
1658 	encode_op_hdr(xdr, OP_SETATTR, decode_setacl_maxsz, hdr);
1659 	encode_nfs4_stateid(xdr, &zero_stateid);
1660 	p = reserve_space(xdr, 2*4);
1661 	*p++ = cpu_to_be32(1);
1662 	*p = cpu_to_be32(FATTR4_WORD0_ACL);
1663 	p = reserve_space(xdr, 4);
1664 	*p = cpu_to_be32(arg->acl_len);
1665 	xdr_write_pages(xdr, arg->acl_pages, arg->acl_pgbase, arg->acl_len);
1666 }
1667 
1668 static void
1669 encode_savefh(struct xdr_stream *xdr, struct compound_hdr *hdr)
1670 {
1671 	encode_op_hdr(xdr, OP_SAVEFH, decode_savefh_maxsz, hdr);
1672 }
1673 
1674 static void encode_setattr(struct xdr_stream *xdr, const struct nfs_setattrargs *arg, const struct nfs_server *server, struct compound_hdr *hdr)
1675 {
1676 	encode_op_hdr(xdr, OP_SETATTR, decode_setattr_maxsz, hdr);
1677 	encode_nfs4_stateid(xdr, &arg->stateid);
1678 	encode_attrs(xdr, arg->iap, arg->label, server);
1679 }
1680 
1681 static void encode_setclientid(struct xdr_stream *xdr, const struct nfs4_setclientid *setclientid, struct compound_hdr *hdr)
1682 {
1683 	__be32 *p;
1684 
1685 	encode_op_hdr(xdr, OP_SETCLIENTID, decode_setclientid_maxsz, hdr);
1686 	encode_nfs4_verifier(xdr, setclientid->sc_verifier);
1687 
1688 	encode_string(xdr, setclientid->sc_name_len, setclientid->sc_name);
1689 	p = reserve_space(xdr, 4);
1690 	*p = cpu_to_be32(setclientid->sc_prog);
1691 	encode_string(xdr, setclientid->sc_netid_len, setclientid->sc_netid);
1692 	encode_string(xdr, setclientid->sc_uaddr_len, setclientid->sc_uaddr);
1693 	p = reserve_space(xdr, 4);
1694 	*p = cpu_to_be32(setclientid->sc_cb_ident);
1695 }
1696 
1697 static void encode_setclientid_confirm(struct xdr_stream *xdr, const struct nfs4_setclientid_res *arg, struct compound_hdr *hdr)
1698 {
1699 	encode_op_hdr(xdr, OP_SETCLIENTID_CONFIRM,
1700 			decode_setclientid_confirm_maxsz, hdr);
1701 	encode_uint64(xdr, arg->clientid);
1702 	encode_nfs4_verifier(xdr, &arg->confirm);
1703 }
1704 
1705 static void encode_write(struct xdr_stream *xdr, const struct nfs_writeargs *args, struct compound_hdr *hdr)
1706 {
1707 	__be32 *p;
1708 
1709 	encode_op_hdr(xdr, OP_WRITE, decode_write_maxsz, hdr);
1710 	encode_nfs4_stateid(xdr, &args->stateid);
1711 
1712 	p = reserve_space(xdr, 16);
1713 	p = xdr_encode_hyper(p, args->offset);
1714 	*p++ = cpu_to_be32(args->stable);
1715 	*p = cpu_to_be32(args->count);
1716 
1717 	xdr_write_pages(xdr, args->pages, args->pgbase, args->count);
1718 }
1719 
1720 static void encode_delegreturn(struct xdr_stream *xdr, const nfs4_stateid *stateid, struct compound_hdr *hdr)
1721 {
1722 	encode_op_hdr(xdr, OP_DELEGRETURN, decode_delegreturn_maxsz, hdr);
1723 	encode_nfs4_stateid(xdr, stateid);
1724 }
1725 
1726 static void encode_secinfo(struct xdr_stream *xdr, const struct qstr *name, struct compound_hdr *hdr)
1727 {
1728 	encode_op_hdr(xdr, OP_SECINFO, decode_secinfo_maxsz, hdr);
1729 	encode_string(xdr, name->len, name->name);
1730 }
1731 
1732 #if defined(CONFIG_NFS_V4_1)
1733 /* NFSv4.1 operations */
1734 static void encode_bind_conn_to_session(struct xdr_stream *xdr,
1735 				   struct nfs4_session *session,
1736 				   struct compound_hdr *hdr)
1737 {
1738 	__be32 *p;
1739 
1740 	encode_op_hdr(xdr, OP_BIND_CONN_TO_SESSION,
1741 		decode_bind_conn_to_session_maxsz, hdr);
1742 	encode_opaque_fixed(xdr, session->sess_id.data, NFS4_MAX_SESSIONID_LEN);
1743 	p = xdr_reserve_space(xdr, 8);
1744 	*p++ = cpu_to_be32(NFS4_CDFC4_BACK_OR_BOTH);
1745 	*p = 0;	/* use_conn_in_rdma_mode = False */
1746 }
1747 
1748 static void encode_op_map(struct xdr_stream *xdr, struct nfs4_op_map *op_map)
1749 {
1750 	unsigned int i;
1751 	encode_uint32(xdr, NFS4_OP_MAP_NUM_WORDS);
1752 	for (i = 0; i < NFS4_OP_MAP_NUM_WORDS; i++)
1753 		encode_uint32(xdr, op_map->u.words[i]);
1754 }
1755 
1756 static void encode_exchange_id(struct xdr_stream *xdr,
1757 			       struct nfs41_exchange_id_args *args,
1758 			       struct compound_hdr *hdr)
1759 {
1760 	__be32 *p;
1761 	char impl_name[IMPL_NAME_LIMIT];
1762 	int len = 0;
1763 
1764 	encode_op_hdr(xdr, OP_EXCHANGE_ID, decode_exchange_id_maxsz, hdr);
1765 	encode_nfs4_verifier(xdr, args->verifier);
1766 
1767 	encode_string(xdr, args->id_len, args->id);
1768 
1769 	encode_uint32(xdr, args->flags);
1770 	encode_uint32(xdr, args->state_protect.how);
1771 
1772 	switch (args->state_protect.how) {
1773 	case SP4_NONE:
1774 		break;
1775 	case SP4_MACH_CRED:
1776 		encode_op_map(xdr, &args->state_protect.enforce);
1777 		encode_op_map(xdr, &args->state_protect.allow);
1778 		break;
1779 	default:
1780 		WARN_ON_ONCE(1);
1781 		break;
1782 	}
1783 
1784 	if (send_implementation_id &&
1785 	    sizeof(CONFIG_NFS_V4_1_IMPLEMENTATION_ID_DOMAIN) > 1 &&
1786 	    sizeof(CONFIG_NFS_V4_1_IMPLEMENTATION_ID_DOMAIN)
1787 		<= sizeof(impl_name) + 1)
1788 		len = snprintf(impl_name, sizeof(impl_name), "%s %s %s %s",
1789 			       utsname()->sysname, utsname()->release,
1790 			       utsname()->version, utsname()->machine);
1791 
1792 	if (len > 0) {
1793 		encode_uint32(xdr, 1);	/* implementation id array length=1 */
1794 
1795 		encode_string(xdr,
1796 			sizeof(CONFIG_NFS_V4_1_IMPLEMENTATION_ID_DOMAIN) - 1,
1797 			CONFIG_NFS_V4_1_IMPLEMENTATION_ID_DOMAIN);
1798 		encode_string(xdr, len, impl_name);
1799 		/* just send zeros for nii_date - the date is in nii_name */
1800 		p = reserve_space(xdr, 12);
1801 		p = xdr_encode_hyper(p, 0);
1802 		*p = cpu_to_be32(0);
1803 	} else
1804 		encode_uint32(xdr, 0);	/* implementation id array length=0 */
1805 }
1806 
1807 static void encode_create_session(struct xdr_stream *xdr,
1808 				  struct nfs41_create_session_args *args,
1809 				  struct compound_hdr *hdr)
1810 {
1811 	__be32 *p;
1812 	char machine_name[NFS4_MAX_MACHINE_NAME_LEN];
1813 	uint32_t len;
1814 	struct nfs_client *clp = args->client;
1815 	struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
1816 	u32 max_resp_sz_cached;
1817 
1818 	/*
1819 	 * Assumes OPEN is the biggest non-idempotent compound.
1820 	 * 2 is the verifier.
1821 	 */
1822 	max_resp_sz_cached = (NFS4_dec_open_sz + RPC_REPHDRSIZE +
1823 			      RPC_MAX_AUTH_SIZE + 2) * XDR_UNIT;
1824 
1825 	len = scnprintf(machine_name, sizeof(machine_name), "%s",
1826 			clp->cl_ipaddr);
1827 
1828 	encode_op_hdr(xdr, OP_CREATE_SESSION, decode_create_session_maxsz, hdr);
1829 	p = reserve_space(xdr, 16 + 2*28 + 20 + len + 12);
1830 	p = xdr_encode_hyper(p, clp->cl_clientid);
1831 	*p++ = cpu_to_be32(clp->cl_seqid);			/*Sequence id */
1832 	*p++ = cpu_to_be32(args->flags);			/*flags */
1833 
1834 	/* Fore Channel */
1835 	*p++ = cpu_to_be32(0);				/* header padding size */
1836 	*p++ = cpu_to_be32(args->fc_attrs.max_rqst_sz);	/* max req size */
1837 	*p++ = cpu_to_be32(args->fc_attrs.max_resp_sz);	/* max resp size */
1838 	*p++ = cpu_to_be32(max_resp_sz_cached);		/* Max resp sz cached */
1839 	*p++ = cpu_to_be32(args->fc_attrs.max_ops);	/* max operations */
1840 	*p++ = cpu_to_be32(args->fc_attrs.max_reqs);	/* max requests */
1841 	*p++ = cpu_to_be32(0);				/* rdmachannel_attrs */
1842 
1843 	/* Back Channel */
1844 	*p++ = cpu_to_be32(0);				/* header padding size */
1845 	*p++ = cpu_to_be32(args->bc_attrs.max_rqst_sz);	/* max req size */
1846 	*p++ = cpu_to_be32(args->bc_attrs.max_resp_sz);	/* max resp size */
1847 	*p++ = cpu_to_be32(args->bc_attrs.max_resp_sz_cached);	/* Max resp sz cached */
1848 	*p++ = cpu_to_be32(args->bc_attrs.max_ops);	/* max operations */
1849 	*p++ = cpu_to_be32(args->bc_attrs.max_reqs);	/* max requests */
1850 	*p++ = cpu_to_be32(0);				/* rdmachannel_attrs */
1851 
1852 	*p++ = cpu_to_be32(args->cb_program);		/* cb_program */
1853 	*p++ = cpu_to_be32(1);
1854 	*p++ = cpu_to_be32(RPC_AUTH_UNIX);			/* auth_sys */
1855 
1856 	/* authsys_parms rfc1831 */
1857 	*p++ = cpu_to_be32(nn->boot_time.tv_nsec);	/* stamp */
1858 	p = xdr_encode_opaque(p, machine_name, len);
1859 	*p++ = cpu_to_be32(0);				/* UID */
1860 	*p++ = cpu_to_be32(0);				/* GID */
1861 	*p = cpu_to_be32(0);				/* No more gids */
1862 }
1863 
1864 static void encode_destroy_session(struct xdr_stream *xdr,
1865 				   struct nfs4_session *session,
1866 				   struct compound_hdr *hdr)
1867 {
1868 	encode_op_hdr(xdr, OP_DESTROY_SESSION, decode_destroy_session_maxsz, hdr);
1869 	encode_opaque_fixed(xdr, session->sess_id.data, NFS4_MAX_SESSIONID_LEN);
1870 }
1871 
1872 static void encode_destroy_clientid(struct xdr_stream *xdr,
1873 				   uint64_t clientid,
1874 				   struct compound_hdr *hdr)
1875 {
1876 	encode_op_hdr(xdr, OP_DESTROY_CLIENTID, decode_destroy_clientid_maxsz, hdr);
1877 	encode_uint64(xdr, clientid);
1878 }
1879 
1880 static void encode_reclaim_complete(struct xdr_stream *xdr,
1881 				    struct nfs41_reclaim_complete_args *args,
1882 				    struct compound_hdr *hdr)
1883 {
1884 	encode_op_hdr(xdr, OP_RECLAIM_COMPLETE, decode_reclaim_complete_maxsz, hdr);
1885 	encode_uint32(xdr, args->one_fs);
1886 }
1887 #endif /* CONFIG_NFS_V4_1 */
1888 
1889 static void encode_sequence(struct xdr_stream *xdr,
1890 			    const struct nfs4_sequence_args *args,
1891 			    struct compound_hdr *hdr)
1892 {
1893 #if defined(CONFIG_NFS_V4_1)
1894 	struct nfs4_session *session;
1895 	struct nfs4_slot_table *tp;
1896 	struct nfs4_slot *slot = args->sa_slot;
1897 	__be32 *p;
1898 
1899 	tp = slot->table;
1900 	session = tp->session;
1901 	if (!session)
1902 		return;
1903 
1904 	encode_op_hdr(xdr, OP_SEQUENCE, decode_sequence_maxsz, hdr);
1905 
1906 	/*
1907 	 * Sessionid + seqid + slotid + max slotid + cache_this
1908 	 */
1909 	dprintk("%s: sessionid=%u:%u:%u:%u seqid=%d slotid=%d "
1910 		"max_slotid=%d cache_this=%d\n",
1911 		__func__,
1912 		((u32 *)session->sess_id.data)[0],
1913 		((u32 *)session->sess_id.data)[1],
1914 		((u32 *)session->sess_id.data)[2],
1915 		((u32 *)session->sess_id.data)[3],
1916 		slot->seq_nr, slot->slot_nr,
1917 		tp->highest_used_slotid, args->sa_cache_this);
1918 	p = reserve_space(xdr, NFS4_MAX_SESSIONID_LEN + 16);
1919 	p = xdr_encode_opaque_fixed(p, session->sess_id.data, NFS4_MAX_SESSIONID_LEN);
1920 	*p++ = cpu_to_be32(slot->seq_nr);
1921 	*p++ = cpu_to_be32(slot->slot_nr);
1922 	*p++ = cpu_to_be32(tp->highest_used_slotid);
1923 	*p = cpu_to_be32(args->sa_cache_this);
1924 #endif /* CONFIG_NFS_V4_1 */
1925 }
1926 
1927 #ifdef CONFIG_NFS_V4_1
1928 static void
1929 encode_getdevicelist(struct xdr_stream *xdr,
1930 		     const struct nfs4_getdevicelist_args *args,
1931 		     struct compound_hdr *hdr)
1932 {
1933 	__be32 *p;
1934 	nfs4_verifier dummy = {
1935 		.data = "dummmmmy",
1936 	};
1937 
1938 	encode_op_hdr(xdr, OP_GETDEVICELIST, decode_getdevicelist_maxsz, hdr);
1939 	p = reserve_space(xdr, 16);
1940 	*p++ = cpu_to_be32(args->layoutclass);
1941 	*p++ = cpu_to_be32(NFS4_PNFS_GETDEVLIST_MAXNUM);
1942 	xdr_encode_hyper(p, 0ULL);                          /* cookie */
1943 	encode_nfs4_verifier(xdr, &dummy);
1944 }
1945 
1946 static void
1947 encode_getdeviceinfo(struct xdr_stream *xdr,
1948 		     const struct nfs4_getdeviceinfo_args *args,
1949 		     struct compound_hdr *hdr)
1950 {
1951 	__be32 *p;
1952 
1953 	encode_op_hdr(xdr, OP_GETDEVICEINFO, decode_getdeviceinfo_maxsz, hdr);
1954 	p = reserve_space(xdr, 12 + NFS4_DEVICEID4_SIZE);
1955 	p = xdr_encode_opaque_fixed(p, args->pdev->dev_id.data,
1956 				    NFS4_DEVICEID4_SIZE);
1957 	*p++ = cpu_to_be32(args->pdev->layout_type);
1958 	*p++ = cpu_to_be32(args->pdev->maxcount);	/* gdia_maxcount */
1959 	*p++ = cpu_to_be32(0);				/* bitmap length 0 */
1960 }
1961 
1962 static void
1963 encode_layoutget(struct xdr_stream *xdr,
1964 		      const struct nfs4_layoutget_args *args,
1965 		      struct compound_hdr *hdr)
1966 {
1967 	__be32 *p;
1968 
1969 	encode_op_hdr(xdr, OP_LAYOUTGET, decode_layoutget_maxsz, hdr);
1970 	p = reserve_space(xdr, 36);
1971 	*p++ = cpu_to_be32(0);     /* Signal layout available */
1972 	*p++ = cpu_to_be32(args->type);
1973 	*p++ = cpu_to_be32(args->range.iomode);
1974 	p = xdr_encode_hyper(p, args->range.offset);
1975 	p = xdr_encode_hyper(p, args->range.length);
1976 	p = xdr_encode_hyper(p, args->minlength);
1977 	encode_nfs4_stateid(xdr, &args->stateid);
1978 	encode_uint32(xdr, args->maxcount);
1979 
1980 	dprintk("%s: 1st type:0x%x iomode:%d off:%lu len:%lu mc:%d\n",
1981 		__func__,
1982 		args->type,
1983 		args->range.iomode,
1984 		(unsigned long)args->range.offset,
1985 		(unsigned long)args->range.length,
1986 		args->maxcount);
1987 }
1988 
1989 static int
1990 encode_layoutcommit(struct xdr_stream *xdr,
1991 		    struct inode *inode,
1992 		    const struct nfs4_layoutcommit_args *args,
1993 		    struct compound_hdr *hdr)
1994 {
1995 	__be32 *p;
1996 
1997 	dprintk("%s: lbw: %llu type: %d\n", __func__, args->lastbytewritten,
1998 		NFS_SERVER(args->inode)->pnfs_curr_ld->id);
1999 
2000 	encode_op_hdr(xdr, OP_LAYOUTCOMMIT, decode_layoutcommit_maxsz, hdr);
2001 	p = reserve_space(xdr, 20);
2002 	/* Only whole file layouts */
2003 	p = xdr_encode_hyper(p, 0); /* offset */
2004 	p = xdr_encode_hyper(p, args->lastbytewritten + 1);	/* length */
2005 	*p = cpu_to_be32(0); /* reclaim */
2006 	encode_nfs4_stateid(xdr, &args->stateid);
2007 	p = reserve_space(xdr, 20);
2008 	*p++ = cpu_to_be32(1); /* newoffset = TRUE */
2009 	p = xdr_encode_hyper(p, args->lastbytewritten);
2010 	*p++ = cpu_to_be32(0); /* Never send time_modify_changed */
2011 	*p++ = cpu_to_be32(NFS_SERVER(args->inode)->pnfs_curr_ld->id);/* type */
2012 
2013 	if (NFS_SERVER(inode)->pnfs_curr_ld->encode_layoutcommit)
2014 		NFS_SERVER(inode)->pnfs_curr_ld->encode_layoutcommit(
2015 			NFS_I(inode)->layout, xdr, args);
2016 	else
2017 		encode_uint32(xdr, 0); /* no layout-type payload */
2018 
2019 	return 0;
2020 }
2021 
2022 static void
2023 encode_layoutreturn(struct xdr_stream *xdr,
2024 		    const struct nfs4_layoutreturn_args *args,
2025 		    struct compound_hdr *hdr)
2026 {
2027 	__be32 *p;
2028 
2029 	encode_op_hdr(xdr, OP_LAYOUTRETURN, decode_layoutreturn_maxsz, hdr);
2030 	p = reserve_space(xdr, 16);
2031 	*p++ = cpu_to_be32(0);		/* reclaim. always 0 for now */
2032 	*p++ = cpu_to_be32(args->layout_type);
2033 	*p++ = cpu_to_be32(IOMODE_ANY);
2034 	*p = cpu_to_be32(RETURN_FILE);
2035 	p = reserve_space(xdr, 16);
2036 	p = xdr_encode_hyper(p, 0);
2037 	p = xdr_encode_hyper(p, NFS4_MAX_UINT64);
2038 	spin_lock(&args->inode->i_lock);
2039 	encode_nfs4_stateid(xdr, &args->stateid);
2040 	spin_unlock(&args->inode->i_lock);
2041 	if (NFS_SERVER(args->inode)->pnfs_curr_ld->encode_layoutreturn) {
2042 		NFS_SERVER(args->inode)->pnfs_curr_ld->encode_layoutreturn(
2043 			NFS_I(args->inode)->layout, xdr, args);
2044 	} else
2045 		encode_uint32(xdr, 0);
2046 }
2047 
2048 static int
2049 encode_secinfo_no_name(struct xdr_stream *xdr,
2050 		       const struct nfs41_secinfo_no_name_args *args,
2051 		       struct compound_hdr *hdr)
2052 {
2053 	encode_op_hdr(xdr, OP_SECINFO_NO_NAME, decode_secinfo_no_name_maxsz, hdr);
2054 	encode_uint32(xdr, args->style);
2055 	return 0;
2056 }
2057 
2058 static void encode_test_stateid(struct xdr_stream *xdr,
2059 				struct nfs41_test_stateid_args *args,
2060 				struct compound_hdr *hdr)
2061 {
2062 	encode_op_hdr(xdr, OP_TEST_STATEID, decode_test_stateid_maxsz, hdr);
2063 	encode_uint32(xdr, 1);
2064 	encode_nfs4_stateid(xdr, args->stateid);
2065 }
2066 
2067 static void encode_free_stateid(struct xdr_stream *xdr,
2068 				struct nfs41_free_stateid_args *args,
2069 				struct compound_hdr *hdr)
2070 {
2071 	encode_op_hdr(xdr, OP_FREE_STATEID, decode_free_stateid_maxsz, hdr);
2072 	encode_nfs4_stateid(xdr, &args->stateid);
2073 }
2074 #endif /* CONFIG_NFS_V4_1 */
2075 
2076 /*
2077  * END OF "GENERIC" ENCODE ROUTINES.
2078  */
2079 
2080 static u32 nfs4_xdr_minorversion(const struct nfs4_sequence_args *args)
2081 {
2082 #if defined(CONFIG_NFS_V4_1)
2083 	struct nfs4_session *session = args->sa_slot->table->session;
2084 	if (session)
2085 		return session->clp->cl_mvops->minor_version;
2086 #endif /* CONFIG_NFS_V4_1 */
2087 	return 0;
2088 }
2089 
2090 /*
2091  * Encode an ACCESS request
2092  */
2093 static void nfs4_xdr_enc_access(struct rpc_rqst *req, struct xdr_stream *xdr,
2094 				const struct nfs4_accessargs *args)
2095 {
2096 	struct compound_hdr hdr = {
2097 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2098 	};
2099 
2100 	encode_compound_hdr(xdr, req, &hdr);
2101 	encode_sequence(xdr, &args->seq_args, &hdr);
2102 	encode_putfh(xdr, args->fh, &hdr);
2103 	encode_access(xdr, args->access, &hdr);
2104 	encode_getfattr(xdr, args->bitmask, &hdr);
2105 	encode_nops(&hdr);
2106 }
2107 
2108 /*
2109  * Encode LOOKUP request
2110  */
2111 static void nfs4_xdr_enc_lookup(struct rpc_rqst *req, struct xdr_stream *xdr,
2112 				const struct nfs4_lookup_arg *args)
2113 {
2114 	struct compound_hdr hdr = {
2115 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2116 	};
2117 
2118 	encode_compound_hdr(xdr, req, &hdr);
2119 	encode_sequence(xdr, &args->seq_args, &hdr);
2120 	encode_putfh(xdr, args->dir_fh, &hdr);
2121 	encode_lookup(xdr, args->name, &hdr);
2122 	encode_getfh(xdr, &hdr);
2123 	encode_getfattr(xdr, args->bitmask, &hdr);
2124 	encode_nops(&hdr);
2125 }
2126 
2127 /*
2128  * Encode LOOKUP_ROOT request
2129  */
2130 static void nfs4_xdr_enc_lookup_root(struct rpc_rqst *req,
2131 				     struct xdr_stream *xdr,
2132 				     const struct nfs4_lookup_root_arg *args)
2133 {
2134 	struct compound_hdr hdr = {
2135 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2136 	};
2137 
2138 	encode_compound_hdr(xdr, req, &hdr);
2139 	encode_sequence(xdr, &args->seq_args, &hdr);
2140 	encode_putrootfh(xdr, &hdr);
2141 	encode_getfh(xdr, &hdr);
2142 	encode_getfattr(xdr, args->bitmask, &hdr);
2143 	encode_nops(&hdr);
2144 }
2145 
2146 /*
2147  * Encode REMOVE request
2148  */
2149 static void nfs4_xdr_enc_remove(struct rpc_rqst *req, struct xdr_stream *xdr,
2150 				const struct nfs_removeargs *args)
2151 {
2152 	struct compound_hdr hdr = {
2153 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2154 	};
2155 
2156 	encode_compound_hdr(xdr, req, &hdr);
2157 	encode_sequence(xdr, &args->seq_args, &hdr);
2158 	encode_putfh(xdr, args->fh, &hdr);
2159 	encode_remove(xdr, &args->name, &hdr);
2160 	encode_nops(&hdr);
2161 }
2162 
2163 /*
2164  * Encode RENAME request
2165  */
2166 static void nfs4_xdr_enc_rename(struct rpc_rqst *req, struct xdr_stream *xdr,
2167 				const struct nfs_renameargs *args)
2168 {
2169 	struct compound_hdr hdr = {
2170 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2171 	};
2172 
2173 	encode_compound_hdr(xdr, req, &hdr);
2174 	encode_sequence(xdr, &args->seq_args, &hdr);
2175 	encode_putfh(xdr, args->old_dir, &hdr);
2176 	encode_savefh(xdr, &hdr);
2177 	encode_putfh(xdr, args->new_dir, &hdr);
2178 	encode_rename(xdr, args->old_name, args->new_name, &hdr);
2179 	encode_nops(&hdr);
2180 }
2181 
2182 /*
2183  * Encode LINK request
2184  */
2185 static void nfs4_xdr_enc_link(struct rpc_rqst *req, struct xdr_stream *xdr,
2186 			     const struct nfs4_link_arg *args)
2187 {
2188 	struct compound_hdr hdr = {
2189 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2190 	};
2191 
2192 	encode_compound_hdr(xdr, req, &hdr);
2193 	encode_sequence(xdr, &args->seq_args, &hdr);
2194 	encode_putfh(xdr, args->fh, &hdr);
2195 	encode_savefh(xdr, &hdr);
2196 	encode_putfh(xdr, args->dir_fh, &hdr);
2197 	encode_link(xdr, args->name, &hdr);
2198 	encode_restorefh(xdr, &hdr);
2199 	encode_getfattr(xdr, args->bitmask, &hdr);
2200 	encode_nops(&hdr);
2201 }
2202 
2203 /*
2204  * Encode CREATE request
2205  */
2206 static void nfs4_xdr_enc_create(struct rpc_rqst *req, struct xdr_stream *xdr,
2207 				const struct nfs4_create_arg *args)
2208 {
2209 	struct compound_hdr hdr = {
2210 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2211 	};
2212 
2213 	encode_compound_hdr(xdr, req, &hdr);
2214 	encode_sequence(xdr, &args->seq_args, &hdr);
2215 	encode_putfh(xdr, args->dir_fh, &hdr);
2216 	encode_create(xdr, args, &hdr);
2217 	encode_getfh(xdr, &hdr);
2218 	encode_getfattr(xdr, args->bitmask, &hdr);
2219 	encode_nops(&hdr);
2220 }
2221 
2222 /*
2223  * Encode SYMLINK request
2224  */
2225 static void nfs4_xdr_enc_symlink(struct rpc_rqst *req, struct xdr_stream *xdr,
2226 				 const struct nfs4_create_arg *args)
2227 {
2228 	nfs4_xdr_enc_create(req, xdr, args);
2229 }
2230 
2231 /*
2232  * Encode GETATTR request
2233  */
2234 static void nfs4_xdr_enc_getattr(struct rpc_rqst *req, struct xdr_stream *xdr,
2235 				 const struct nfs4_getattr_arg *args)
2236 {
2237 	struct compound_hdr hdr = {
2238 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2239 	};
2240 
2241 	encode_compound_hdr(xdr, req, &hdr);
2242 	encode_sequence(xdr, &args->seq_args, &hdr);
2243 	encode_putfh(xdr, args->fh, &hdr);
2244 	encode_getfattr(xdr, args->bitmask, &hdr);
2245 	encode_nops(&hdr);
2246 }
2247 
2248 /*
2249  * Encode a CLOSE request
2250  */
2251 static void nfs4_xdr_enc_close(struct rpc_rqst *req, struct xdr_stream *xdr,
2252 			       struct nfs_closeargs *args)
2253 {
2254 	struct compound_hdr hdr = {
2255 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2256 	};
2257 
2258 	encode_compound_hdr(xdr, req, &hdr);
2259 	encode_sequence(xdr, &args->seq_args, &hdr);
2260 	encode_putfh(xdr, args->fh, &hdr);
2261 	encode_close(xdr, args, &hdr);
2262 	encode_getfattr(xdr, args->bitmask, &hdr);
2263 	encode_nops(&hdr);
2264 }
2265 
2266 /*
2267  * Encode an OPEN request
2268  */
2269 static void nfs4_xdr_enc_open(struct rpc_rqst *req, struct xdr_stream *xdr,
2270 			      struct nfs_openargs *args)
2271 {
2272 	struct compound_hdr hdr = {
2273 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2274 	};
2275 
2276 	encode_compound_hdr(xdr, req, &hdr);
2277 	encode_sequence(xdr, &args->seq_args, &hdr);
2278 	encode_putfh(xdr, args->fh, &hdr);
2279 	encode_open(xdr, args, &hdr);
2280 	encode_getfh(xdr, &hdr);
2281 	if (args->access)
2282 		encode_access(xdr, args->access, &hdr);
2283 	encode_getfattr_open(xdr, args->bitmask, args->open_bitmap, &hdr);
2284 	encode_nops(&hdr);
2285 }
2286 
2287 /*
2288  * Encode an OPEN_CONFIRM request
2289  */
2290 static void nfs4_xdr_enc_open_confirm(struct rpc_rqst *req,
2291 				      struct xdr_stream *xdr,
2292 				      struct nfs_open_confirmargs *args)
2293 {
2294 	struct compound_hdr hdr = {
2295 		.nops   = 0,
2296 	};
2297 
2298 	encode_compound_hdr(xdr, req, &hdr);
2299 	encode_putfh(xdr, args->fh, &hdr);
2300 	encode_open_confirm(xdr, args, &hdr);
2301 	encode_nops(&hdr);
2302 }
2303 
2304 /*
2305  * Encode an OPEN request with no attributes.
2306  */
2307 static void nfs4_xdr_enc_open_noattr(struct rpc_rqst *req,
2308 				     struct xdr_stream *xdr,
2309 				     struct nfs_openargs *args)
2310 {
2311 	struct compound_hdr hdr = {
2312 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2313 	};
2314 
2315 	encode_compound_hdr(xdr, req, &hdr);
2316 	encode_sequence(xdr, &args->seq_args, &hdr);
2317 	encode_putfh(xdr, args->fh, &hdr);
2318 	encode_open(xdr, args, &hdr);
2319 	if (args->access)
2320 		encode_access(xdr, args->access, &hdr);
2321 	encode_getfattr_open(xdr, args->bitmask, args->open_bitmap, &hdr);
2322 	encode_nops(&hdr);
2323 }
2324 
2325 /*
2326  * Encode an OPEN_DOWNGRADE request
2327  */
2328 static void nfs4_xdr_enc_open_downgrade(struct rpc_rqst *req,
2329 					struct xdr_stream *xdr,
2330 					struct nfs_closeargs *args)
2331 {
2332 	struct compound_hdr hdr = {
2333 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2334 	};
2335 
2336 	encode_compound_hdr(xdr, req, &hdr);
2337 	encode_sequence(xdr, &args->seq_args, &hdr);
2338 	encode_putfh(xdr, args->fh, &hdr);
2339 	encode_open_downgrade(xdr, args, &hdr);
2340 	encode_getfattr(xdr, args->bitmask, &hdr);
2341 	encode_nops(&hdr);
2342 }
2343 
2344 /*
2345  * Encode a LOCK request
2346  */
2347 static void nfs4_xdr_enc_lock(struct rpc_rqst *req, struct xdr_stream *xdr,
2348 			      struct nfs_lock_args *args)
2349 {
2350 	struct compound_hdr hdr = {
2351 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2352 	};
2353 
2354 	encode_compound_hdr(xdr, req, &hdr);
2355 	encode_sequence(xdr, &args->seq_args, &hdr);
2356 	encode_putfh(xdr, args->fh, &hdr);
2357 	encode_lock(xdr, args, &hdr);
2358 	encode_nops(&hdr);
2359 }
2360 
2361 /*
2362  * Encode a LOCKT request
2363  */
2364 static void nfs4_xdr_enc_lockt(struct rpc_rqst *req, struct xdr_stream *xdr,
2365 			       struct nfs_lockt_args *args)
2366 {
2367 	struct compound_hdr hdr = {
2368 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2369 	};
2370 
2371 	encode_compound_hdr(xdr, req, &hdr);
2372 	encode_sequence(xdr, &args->seq_args, &hdr);
2373 	encode_putfh(xdr, args->fh, &hdr);
2374 	encode_lockt(xdr, args, &hdr);
2375 	encode_nops(&hdr);
2376 }
2377 
2378 /*
2379  * Encode a LOCKU request
2380  */
2381 static void nfs4_xdr_enc_locku(struct rpc_rqst *req, struct xdr_stream *xdr,
2382 			       struct nfs_locku_args *args)
2383 {
2384 	struct compound_hdr hdr = {
2385 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2386 	};
2387 
2388 	encode_compound_hdr(xdr, req, &hdr);
2389 	encode_sequence(xdr, &args->seq_args, &hdr);
2390 	encode_putfh(xdr, args->fh, &hdr);
2391 	encode_locku(xdr, args, &hdr);
2392 	encode_nops(&hdr);
2393 }
2394 
2395 static void nfs4_xdr_enc_release_lockowner(struct rpc_rqst *req,
2396 					   struct xdr_stream *xdr,
2397 					struct nfs_release_lockowner_args *args)
2398 {
2399 	struct compound_hdr hdr = {
2400 		.minorversion = 0,
2401 	};
2402 
2403 	encode_compound_hdr(xdr, req, &hdr);
2404 	encode_release_lockowner(xdr, &args->lock_owner, &hdr);
2405 	encode_nops(&hdr);
2406 }
2407 
2408 /*
2409  * Encode a READLINK request
2410  */
2411 static void nfs4_xdr_enc_readlink(struct rpc_rqst *req, struct xdr_stream *xdr,
2412 				  const struct nfs4_readlink *args)
2413 {
2414 	struct compound_hdr hdr = {
2415 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2416 	};
2417 
2418 	encode_compound_hdr(xdr, req, &hdr);
2419 	encode_sequence(xdr, &args->seq_args, &hdr);
2420 	encode_putfh(xdr, args->fh, &hdr);
2421 	encode_readlink(xdr, args, req, &hdr);
2422 
2423 	xdr_inline_pages(&req->rq_rcv_buf, hdr.replen << 2, args->pages,
2424 			args->pgbase, args->pglen);
2425 	encode_nops(&hdr);
2426 }
2427 
2428 /*
2429  * Encode a READDIR request
2430  */
2431 static void nfs4_xdr_enc_readdir(struct rpc_rqst *req, struct xdr_stream *xdr,
2432 				 const struct nfs4_readdir_arg *args)
2433 {
2434 	struct compound_hdr hdr = {
2435 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2436 	};
2437 
2438 	encode_compound_hdr(xdr, req, &hdr);
2439 	encode_sequence(xdr, &args->seq_args, &hdr);
2440 	encode_putfh(xdr, args->fh, &hdr);
2441 	encode_readdir(xdr, args, req, &hdr);
2442 
2443 	xdr_inline_pages(&req->rq_rcv_buf, hdr.replen << 2, args->pages,
2444 			 args->pgbase, args->count);
2445 	dprintk("%s: inlined page args = (%u, %p, %u, %u)\n",
2446 			__func__, hdr.replen << 2, args->pages,
2447 			args->pgbase, args->count);
2448 	encode_nops(&hdr);
2449 }
2450 
2451 /*
2452  * Encode a READ request
2453  */
2454 static void nfs4_xdr_enc_read(struct rpc_rqst *req, struct xdr_stream *xdr,
2455 			      struct nfs_readargs *args)
2456 {
2457 	struct compound_hdr hdr = {
2458 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2459 	};
2460 
2461 	encode_compound_hdr(xdr, req, &hdr);
2462 	encode_sequence(xdr, &args->seq_args, &hdr);
2463 	encode_putfh(xdr, args->fh, &hdr);
2464 	encode_read(xdr, args, &hdr);
2465 
2466 	xdr_inline_pages(&req->rq_rcv_buf, hdr.replen << 2,
2467 			 args->pages, args->pgbase, args->count);
2468 	req->rq_rcv_buf.flags |= XDRBUF_READ;
2469 	encode_nops(&hdr);
2470 }
2471 
2472 /*
2473  * Encode an SETATTR request
2474  */
2475 static void nfs4_xdr_enc_setattr(struct rpc_rqst *req, struct xdr_stream *xdr,
2476 				 struct nfs_setattrargs *args)
2477 {
2478 	struct compound_hdr hdr = {
2479 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2480 	};
2481 
2482 	encode_compound_hdr(xdr, req, &hdr);
2483 	encode_sequence(xdr, &args->seq_args, &hdr);
2484 	encode_putfh(xdr, args->fh, &hdr);
2485 	encode_setattr(xdr, args, args->server, &hdr);
2486 	encode_getfattr(xdr, args->bitmask, &hdr);
2487 	encode_nops(&hdr);
2488 }
2489 
2490 /*
2491  * Encode a GETACL request
2492  */
2493 static void nfs4_xdr_enc_getacl(struct rpc_rqst *req, struct xdr_stream *xdr,
2494 				struct nfs_getaclargs *args)
2495 {
2496 	struct compound_hdr hdr = {
2497 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2498 	};
2499 	uint32_t replen;
2500 
2501 	encode_compound_hdr(xdr, req, &hdr);
2502 	encode_sequence(xdr, &args->seq_args, &hdr);
2503 	encode_putfh(xdr, args->fh, &hdr);
2504 	replen = hdr.replen + op_decode_hdr_maxsz + 1;
2505 	encode_getattr_two(xdr, FATTR4_WORD0_ACL, 0, &hdr);
2506 
2507 	xdr_inline_pages(&req->rq_rcv_buf, replen << 2,
2508 		args->acl_pages, args->acl_pgbase, args->acl_len);
2509 
2510 	encode_nops(&hdr);
2511 }
2512 
2513 /*
2514  * Encode a WRITE request
2515  */
2516 static void nfs4_xdr_enc_write(struct rpc_rqst *req, struct xdr_stream *xdr,
2517 			       struct nfs_writeargs *args)
2518 {
2519 	struct compound_hdr hdr = {
2520 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2521 	};
2522 
2523 	encode_compound_hdr(xdr, req, &hdr);
2524 	encode_sequence(xdr, &args->seq_args, &hdr);
2525 	encode_putfh(xdr, args->fh, &hdr);
2526 	encode_write(xdr, args, &hdr);
2527 	req->rq_snd_buf.flags |= XDRBUF_WRITE;
2528 	if (args->bitmask)
2529 		encode_getfattr(xdr, args->bitmask, &hdr);
2530 	encode_nops(&hdr);
2531 }
2532 
2533 /*
2534  *  a COMMIT request
2535  */
2536 static void nfs4_xdr_enc_commit(struct rpc_rqst *req, struct xdr_stream *xdr,
2537 				struct nfs_commitargs *args)
2538 {
2539 	struct compound_hdr hdr = {
2540 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2541 	};
2542 
2543 	encode_compound_hdr(xdr, req, &hdr);
2544 	encode_sequence(xdr, &args->seq_args, &hdr);
2545 	encode_putfh(xdr, args->fh, &hdr);
2546 	encode_commit(xdr, args, &hdr);
2547 	encode_nops(&hdr);
2548 }
2549 
2550 /*
2551  * FSINFO request
2552  */
2553 static void nfs4_xdr_enc_fsinfo(struct rpc_rqst *req, struct xdr_stream *xdr,
2554 				struct nfs4_fsinfo_arg *args)
2555 {
2556 	struct compound_hdr hdr = {
2557 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2558 	};
2559 
2560 	encode_compound_hdr(xdr, req, &hdr);
2561 	encode_sequence(xdr, &args->seq_args, &hdr);
2562 	encode_putfh(xdr, args->fh, &hdr);
2563 	encode_fsinfo(xdr, args->bitmask, &hdr);
2564 	encode_nops(&hdr);
2565 }
2566 
2567 /*
2568  * a PATHCONF request
2569  */
2570 static void nfs4_xdr_enc_pathconf(struct rpc_rqst *req, struct xdr_stream *xdr,
2571 				  const struct nfs4_pathconf_arg *args)
2572 {
2573 	struct compound_hdr hdr = {
2574 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2575 	};
2576 
2577 	encode_compound_hdr(xdr, req, &hdr);
2578 	encode_sequence(xdr, &args->seq_args, &hdr);
2579 	encode_putfh(xdr, args->fh, &hdr);
2580 	encode_getattr_one(xdr, args->bitmask[0] & nfs4_pathconf_bitmap[0],
2581 			   &hdr);
2582 	encode_nops(&hdr);
2583 }
2584 
2585 /*
2586  * a STATFS request
2587  */
2588 static void nfs4_xdr_enc_statfs(struct rpc_rqst *req, struct xdr_stream *xdr,
2589 				const struct nfs4_statfs_arg *args)
2590 {
2591 	struct compound_hdr hdr = {
2592 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2593 	};
2594 
2595 	encode_compound_hdr(xdr, req, &hdr);
2596 	encode_sequence(xdr, &args->seq_args, &hdr);
2597 	encode_putfh(xdr, args->fh, &hdr);
2598 	encode_getattr_two(xdr, args->bitmask[0] & nfs4_statfs_bitmap[0],
2599 			   args->bitmask[1] & nfs4_statfs_bitmap[1], &hdr);
2600 	encode_nops(&hdr);
2601 }
2602 
2603 /*
2604  * GETATTR_BITMAP request
2605  */
2606 static void nfs4_xdr_enc_server_caps(struct rpc_rqst *req,
2607 				     struct xdr_stream *xdr,
2608 				     struct nfs4_server_caps_arg *args)
2609 {
2610 	struct compound_hdr hdr = {
2611 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2612 	};
2613 
2614 	encode_compound_hdr(xdr, req, &hdr);
2615 	encode_sequence(xdr, &args->seq_args, &hdr);
2616 	encode_putfh(xdr, args->fhandle, &hdr);
2617 	encode_getattr_one(xdr, FATTR4_WORD0_SUPPORTED_ATTRS|
2618 			   FATTR4_WORD0_FH_EXPIRE_TYPE|
2619 			   FATTR4_WORD0_LINK_SUPPORT|
2620 			   FATTR4_WORD0_SYMLINK_SUPPORT|
2621 			   FATTR4_WORD0_ACLSUPPORT, &hdr);
2622 	encode_nops(&hdr);
2623 }
2624 
2625 /*
2626  * a RENEW request
2627  */
2628 static void nfs4_xdr_enc_renew(struct rpc_rqst *req, struct xdr_stream *xdr,
2629 			       struct nfs_client *clp)
2630 {
2631 	struct compound_hdr hdr = {
2632 		.nops	= 0,
2633 	};
2634 
2635 	encode_compound_hdr(xdr, req, &hdr);
2636 	encode_renew(xdr, clp->cl_clientid, &hdr);
2637 	encode_nops(&hdr);
2638 }
2639 
2640 /*
2641  * a SETCLIENTID request
2642  */
2643 static void nfs4_xdr_enc_setclientid(struct rpc_rqst *req,
2644 				     struct xdr_stream *xdr,
2645 				     struct nfs4_setclientid *sc)
2646 {
2647 	struct compound_hdr hdr = {
2648 		.nops	= 0,
2649 	};
2650 
2651 	encode_compound_hdr(xdr, req, &hdr);
2652 	encode_setclientid(xdr, sc, &hdr);
2653 	encode_nops(&hdr);
2654 }
2655 
2656 /*
2657  * a SETCLIENTID_CONFIRM request
2658  */
2659 static void nfs4_xdr_enc_setclientid_confirm(struct rpc_rqst *req,
2660 					     struct xdr_stream *xdr,
2661 					     struct nfs4_setclientid_res *arg)
2662 {
2663 	struct compound_hdr hdr = {
2664 		.nops	= 0,
2665 	};
2666 
2667 	encode_compound_hdr(xdr, req, &hdr);
2668 	encode_setclientid_confirm(xdr, arg, &hdr);
2669 	encode_nops(&hdr);
2670 }
2671 
2672 /*
2673  * DELEGRETURN request
2674  */
2675 static void nfs4_xdr_enc_delegreturn(struct rpc_rqst *req,
2676 				     struct xdr_stream *xdr,
2677 				     const struct nfs4_delegreturnargs *args)
2678 {
2679 	struct compound_hdr hdr = {
2680 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2681 	};
2682 
2683 	encode_compound_hdr(xdr, req, &hdr);
2684 	encode_sequence(xdr, &args->seq_args, &hdr);
2685 	encode_putfh(xdr, args->fhandle, &hdr);
2686 	encode_getfattr(xdr, args->bitmask, &hdr);
2687 	encode_delegreturn(xdr, args->stateid, &hdr);
2688 	encode_nops(&hdr);
2689 }
2690 
2691 /*
2692  * Encode FS_LOCATIONS request
2693  */
2694 static void nfs4_xdr_enc_fs_locations(struct rpc_rqst *req,
2695 				      struct xdr_stream *xdr,
2696 				      struct nfs4_fs_locations_arg *args)
2697 {
2698 	struct compound_hdr hdr = {
2699 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2700 	};
2701 	uint32_t replen;
2702 
2703 	encode_compound_hdr(xdr, req, &hdr);
2704 	encode_sequence(xdr, &args->seq_args, &hdr);
2705 	if (args->migration) {
2706 		encode_putfh(xdr, args->fh, &hdr);
2707 		replen = hdr.replen;
2708 		encode_fs_locations(xdr, args->bitmask, &hdr);
2709 		if (args->renew)
2710 			encode_renew(xdr, args->clientid, &hdr);
2711 	} else {
2712 		encode_putfh(xdr, args->dir_fh, &hdr);
2713 		encode_lookup(xdr, args->name, &hdr);
2714 		replen = hdr.replen;
2715 		encode_fs_locations(xdr, args->bitmask, &hdr);
2716 	}
2717 
2718 	/* Set up reply kvec to capture returned fs_locations array. */
2719 	xdr_inline_pages(&req->rq_rcv_buf, replen << 2, &args->page,
2720 			0, PAGE_SIZE);
2721 	encode_nops(&hdr);
2722 }
2723 
2724 /*
2725  * Encode SECINFO request
2726  */
2727 static void nfs4_xdr_enc_secinfo(struct rpc_rqst *req,
2728 				struct xdr_stream *xdr,
2729 				struct nfs4_secinfo_arg *args)
2730 {
2731 	struct compound_hdr hdr = {
2732 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2733 	};
2734 
2735 	encode_compound_hdr(xdr, req, &hdr);
2736 	encode_sequence(xdr, &args->seq_args, &hdr);
2737 	encode_putfh(xdr, args->dir_fh, &hdr);
2738 	encode_secinfo(xdr, args->name, &hdr);
2739 	encode_nops(&hdr);
2740 }
2741 
2742 /*
2743  * Encode FSID_PRESENT request
2744  */
2745 static void nfs4_xdr_enc_fsid_present(struct rpc_rqst *req,
2746 				      struct xdr_stream *xdr,
2747 				      struct nfs4_fsid_present_arg *args)
2748 {
2749 	struct compound_hdr hdr = {
2750 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2751 	};
2752 
2753 	encode_compound_hdr(xdr, req, &hdr);
2754 	encode_sequence(xdr, &args->seq_args, &hdr);
2755 	encode_putfh(xdr, args->fh, &hdr);
2756 	encode_getfh(xdr, &hdr);
2757 	if (args->renew)
2758 		encode_renew(xdr, args->clientid, &hdr);
2759 	encode_nops(&hdr);
2760 }
2761 
2762 #if defined(CONFIG_NFS_V4_1)
2763 /*
2764  * BIND_CONN_TO_SESSION request
2765  */
2766 static void nfs4_xdr_enc_bind_conn_to_session(struct rpc_rqst *req,
2767 				struct xdr_stream *xdr,
2768 				struct nfs_client *clp)
2769 {
2770 	struct compound_hdr hdr = {
2771 		.minorversion = clp->cl_mvops->minor_version,
2772 	};
2773 
2774 	encode_compound_hdr(xdr, req, &hdr);
2775 	encode_bind_conn_to_session(xdr, clp->cl_session, &hdr);
2776 	encode_nops(&hdr);
2777 }
2778 
2779 /*
2780  * EXCHANGE_ID request
2781  */
2782 static void nfs4_xdr_enc_exchange_id(struct rpc_rqst *req,
2783 				     struct xdr_stream *xdr,
2784 				     struct nfs41_exchange_id_args *args)
2785 {
2786 	struct compound_hdr hdr = {
2787 		.minorversion = args->client->cl_mvops->minor_version,
2788 	};
2789 
2790 	encode_compound_hdr(xdr, req, &hdr);
2791 	encode_exchange_id(xdr, args, &hdr);
2792 	encode_nops(&hdr);
2793 }
2794 
2795 /*
2796  * a CREATE_SESSION request
2797  */
2798 static void nfs4_xdr_enc_create_session(struct rpc_rqst *req,
2799 					struct xdr_stream *xdr,
2800 					struct nfs41_create_session_args *args)
2801 {
2802 	struct compound_hdr hdr = {
2803 		.minorversion = args->client->cl_mvops->minor_version,
2804 	};
2805 
2806 	encode_compound_hdr(xdr, req, &hdr);
2807 	encode_create_session(xdr, args, &hdr);
2808 	encode_nops(&hdr);
2809 }
2810 
2811 /*
2812  * a DESTROY_SESSION request
2813  */
2814 static void nfs4_xdr_enc_destroy_session(struct rpc_rqst *req,
2815 					 struct xdr_stream *xdr,
2816 					 struct nfs4_session *session)
2817 {
2818 	struct compound_hdr hdr = {
2819 		.minorversion = session->clp->cl_mvops->minor_version,
2820 	};
2821 
2822 	encode_compound_hdr(xdr, req, &hdr);
2823 	encode_destroy_session(xdr, session, &hdr);
2824 	encode_nops(&hdr);
2825 }
2826 
2827 /*
2828  * a DESTROY_CLIENTID request
2829  */
2830 static void nfs4_xdr_enc_destroy_clientid(struct rpc_rqst *req,
2831 					 struct xdr_stream *xdr,
2832 					 struct nfs_client *clp)
2833 {
2834 	struct compound_hdr hdr = {
2835 		.minorversion = clp->cl_mvops->minor_version,
2836 	};
2837 
2838 	encode_compound_hdr(xdr, req, &hdr);
2839 	encode_destroy_clientid(xdr, clp->cl_clientid, &hdr);
2840 	encode_nops(&hdr);
2841 }
2842 
2843 /*
2844  * a SEQUENCE request
2845  */
2846 static void nfs4_xdr_enc_sequence(struct rpc_rqst *req, struct xdr_stream *xdr,
2847 				  struct nfs4_sequence_args *args)
2848 {
2849 	struct compound_hdr hdr = {
2850 		.minorversion = nfs4_xdr_minorversion(args),
2851 	};
2852 
2853 	encode_compound_hdr(xdr, req, &hdr);
2854 	encode_sequence(xdr, args, &hdr);
2855 	encode_nops(&hdr);
2856 }
2857 
2858 /*
2859  * a GET_LEASE_TIME request
2860  */
2861 static void nfs4_xdr_enc_get_lease_time(struct rpc_rqst *req,
2862 					struct xdr_stream *xdr,
2863 					struct nfs4_get_lease_time_args *args)
2864 {
2865 	struct compound_hdr hdr = {
2866 		.minorversion = nfs4_xdr_minorversion(&args->la_seq_args),
2867 	};
2868 	const u32 lease_bitmap[3] = { FATTR4_WORD0_LEASE_TIME };
2869 
2870 	encode_compound_hdr(xdr, req, &hdr);
2871 	encode_sequence(xdr, &args->la_seq_args, &hdr);
2872 	encode_putrootfh(xdr, &hdr);
2873 	encode_fsinfo(xdr, lease_bitmap, &hdr);
2874 	encode_nops(&hdr);
2875 }
2876 
2877 /*
2878  * a RECLAIM_COMPLETE request
2879  */
2880 static void nfs4_xdr_enc_reclaim_complete(struct rpc_rqst *req,
2881 					  struct xdr_stream *xdr,
2882 				struct nfs41_reclaim_complete_args *args)
2883 {
2884 	struct compound_hdr hdr = {
2885 		.minorversion = nfs4_xdr_minorversion(&args->seq_args)
2886 	};
2887 
2888 	encode_compound_hdr(xdr, req, &hdr);
2889 	encode_sequence(xdr, &args->seq_args, &hdr);
2890 	encode_reclaim_complete(xdr, args, &hdr);
2891 	encode_nops(&hdr);
2892 }
2893 
2894 /*
2895  * Encode GETDEVICELIST request
2896  */
2897 static void nfs4_xdr_enc_getdevicelist(struct rpc_rqst *req,
2898 				       struct xdr_stream *xdr,
2899 				       struct nfs4_getdevicelist_args *args)
2900 {
2901 	struct compound_hdr hdr = {
2902 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2903 	};
2904 
2905 	encode_compound_hdr(xdr, req, &hdr);
2906 	encode_sequence(xdr, &args->seq_args, &hdr);
2907 	encode_putfh(xdr, args->fh, &hdr);
2908 	encode_getdevicelist(xdr, args, &hdr);
2909 	encode_nops(&hdr);
2910 }
2911 
2912 /*
2913  * Encode GETDEVICEINFO request
2914  */
2915 static void nfs4_xdr_enc_getdeviceinfo(struct rpc_rqst *req,
2916 				       struct xdr_stream *xdr,
2917 				       struct nfs4_getdeviceinfo_args *args)
2918 {
2919 	struct compound_hdr hdr = {
2920 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2921 	};
2922 
2923 	encode_compound_hdr(xdr, req, &hdr);
2924 	encode_sequence(xdr, &args->seq_args, &hdr);
2925 	encode_getdeviceinfo(xdr, args, &hdr);
2926 
2927 	/* set up reply kvec. Subtract notification bitmap max size (2)
2928 	 * so that notification bitmap is put in xdr_buf tail */
2929 	xdr_inline_pages(&req->rq_rcv_buf, (hdr.replen - 2) << 2,
2930 			 args->pdev->pages, args->pdev->pgbase,
2931 			 args->pdev->pglen);
2932 
2933 	encode_nops(&hdr);
2934 }
2935 
2936 /*
2937  *  Encode LAYOUTGET request
2938  */
2939 static void nfs4_xdr_enc_layoutget(struct rpc_rqst *req,
2940 				   struct xdr_stream *xdr,
2941 				   struct nfs4_layoutget_args *args)
2942 {
2943 	struct compound_hdr hdr = {
2944 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2945 	};
2946 
2947 	encode_compound_hdr(xdr, req, &hdr);
2948 	encode_sequence(xdr, &args->seq_args, &hdr);
2949 	encode_putfh(xdr, NFS_FH(args->inode), &hdr);
2950 	encode_layoutget(xdr, args, &hdr);
2951 
2952 	xdr_inline_pages(&req->rq_rcv_buf, hdr.replen << 2,
2953 	    args->layout.pages, 0, args->layout.pglen);
2954 
2955 	encode_nops(&hdr);
2956 }
2957 
2958 /*
2959  *  Encode LAYOUTCOMMIT request
2960  */
2961 static void nfs4_xdr_enc_layoutcommit(struct rpc_rqst *req,
2962 				      struct xdr_stream *xdr,
2963 				      struct nfs4_layoutcommit_args *args)
2964 {
2965 	struct nfs4_layoutcommit_data *data =
2966 		container_of(args, struct nfs4_layoutcommit_data, args);
2967 	struct compound_hdr hdr = {
2968 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2969 	};
2970 
2971 	encode_compound_hdr(xdr, req, &hdr);
2972 	encode_sequence(xdr, &args->seq_args, &hdr);
2973 	encode_putfh(xdr, NFS_FH(args->inode), &hdr);
2974 	encode_layoutcommit(xdr, data->args.inode, args, &hdr);
2975 	encode_getfattr(xdr, args->bitmask, &hdr);
2976 	encode_nops(&hdr);
2977 }
2978 
2979 /*
2980  * Encode LAYOUTRETURN request
2981  */
2982 static void nfs4_xdr_enc_layoutreturn(struct rpc_rqst *req,
2983 				      struct xdr_stream *xdr,
2984 				      struct nfs4_layoutreturn_args *args)
2985 {
2986 	struct compound_hdr hdr = {
2987 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2988 	};
2989 
2990 	encode_compound_hdr(xdr, req, &hdr);
2991 	encode_sequence(xdr, &args->seq_args, &hdr);
2992 	encode_putfh(xdr, NFS_FH(args->inode), &hdr);
2993 	encode_layoutreturn(xdr, args, &hdr);
2994 	encode_nops(&hdr);
2995 }
2996 
2997 /*
2998  * Encode SECINFO_NO_NAME request
2999  */
3000 static int nfs4_xdr_enc_secinfo_no_name(struct rpc_rqst *req,
3001 					struct xdr_stream *xdr,
3002 					struct nfs41_secinfo_no_name_args *args)
3003 {
3004 	struct compound_hdr hdr = {
3005 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
3006 	};
3007 
3008 	encode_compound_hdr(xdr, req, &hdr);
3009 	encode_sequence(xdr, &args->seq_args, &hdr);
3010 	encode_putrootfh(xdr, &hdr);
3011 	encode_secinfo_no_name(xdr, args, &hdr);
3012 	encode_nops(&hdr);
3013 	return 0;
3014 }
3015 
3016 /*
3017  *  Encode TEST_STATEID request
3018  */
3019 static void nfs4_xdr_enc_test_stateid(struct rpc_rqst *req,
3020 				      struct xdr_stream *xdr,
3021 				      struct nfs41_test_stateid_args *args)
3022 {
3023 	struct compound_hdr hdr = {
3024 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
3025 	};
3026 
3027 	encode_compound_hdr(xdr, req, &hdr);
3028 	encode_sequence(xdr, &args->seq_args, &hdr);
3029 	encode_test_stateid(xdr, args, &hdr);
3030 	encode_nops(&hdr);
3031 }
3032 
3033 /*
3034  *  Encode FREE_STATEID request
3035  */
3036 static void nfs4_xdr_enc_free_stateid(struct rpc_rqst *req,
3037 				     struct xdr_stream *xdr,
3038 				     struct nfs41_free_stateid_args *args)
3039 {
3040 	struct compound_hdr hdr = {
3041 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
3042 	};
3043 
3044 	encode_compound_hdr(xdr, req, &hdr);
3045 	encode_sequence(xdr, &args->seq_args, &hdr);
3046 	encode_free_stateid(xdr, args, &hdr);
3047 	encode_nops(&hdr);
3048 }
3049 #endif /* CONFIG_NFS_V4_1 */
3050 
3051 static void print_overflow_msg(const char *func, const struct xdr_stream *xdr)
3052 {
3053 	dprintk("nfs: %s: prematurely hit end of receive buffer. "
3054 		"Remaining buffer length is %tu words.\n",
3055 		func, xdr->end - xdr->p);
3056 }
3057 
3058 static int decode_opaque_inline(struct xdr_stream *xdr, unsigned int *len, char **string)
3059 {
3060 	__be32 *p;
3061 
3062 	p = xdr_inline_decode(xdr, 4);
3063 	if (unlikely(!p))
3064 		goto out_overflow;
3065 	*len = be32_to_cpup(p);
3066 	p = xdr_inline_decode(xdr, *len);
3067 	if (unlikely(!p))
3068 		goto out_overflow;
3069 	*string = (char *)p;
3070 	return 0;
3071 out_overflow:
3072 	print_overflow_msg(__func__, xdr);
3073 	return -EIO;
3074 }
3075 
3076 static int decode_compound_hdr(struct xdr_stream *xdr, struct compound_hdr *hdr)
3077 {
3078 	__be32 *p;
3079 
3080 	p = xdr_inline_decode(xdr, 8);
3081 	if (unlikely(!p))
3082 		goto out_overflow;
3083 	hdr->status = be32_to_cpup(p++);
3084 	hdr->taglen = be32_to_cpup(p);
3085 
3086 	p = xdr_inline_decode(xdr, hdr->taglen + 4);
3087 	if (unlikely(!p))
3088 		goto out_overflow;
3089 	hdr->tag = (char *)p;
3090 	p += XDR_QUADLEN(hdr->taglen);
3091 	hdr->nops = be32_to_cpup(p);
3092 	if (unlikely(hdr->nops < 1))
3093 		return nfs4_stat_to_errno(hdr->status);
3094 	return 0;
3095 out_overflow:
3096 	print_overflow_msg(__func__, xdr);
3097 	return -EIO;
3098 }
3099 
3100 static int decode_op_hdr(struct xdr_stream *xdr, enum nfs_opnum4 expected)
3101 {
3102 	__be32 *p;
3103 	uint32_t opnum;
3104 	int32_t nfserr;
3105 
3106 	p = xdr_inline_decode(xdr, 8);
3107 	if (unlikely(!p))
3108 		goto out_overflow;
3109 	opnum = be32_to_cpup(p++);
3110 	if (opnum != expected) {
3111 		dprintk("nfs: Server returned operation"
3112 			" %d but we issued a request for %d\n",
3113 				opnum, expected);
3114 		return -EIO;
3115 	}
3116 	nfserr = be32_to_cpup(p);
3117 	if (nfserr != NFS_OK)
3118 		return nfs4_stat_to_errno(nfserr);
3119 	return 0;
3120 out_overflow:
3121 	print_overflow_msg(__func__, xdr);
3122 	return -EIO;
3123 }
3124 
3125 /* Dummy routine */
3126 static int decode_ace(struct xdr_stream *xdr, void *ace, struct nfs_client *clp)
3127 {
3128 	__be32 *p;
3129 	unsigned int strlen;
3130 	char *str;
3131 
3132 	p = xdr_inline_decode(xdr, 12);
3133 	if (likely(p))
3134 		return decode_opaque_inline(xdr, &strlen, &str);
3135 	print_overflow_msg(__func__, xdr);
3136 	return -EIO;
3137 }
3138 
3139 static int decode_attr_bitmap(struct xdr_stream *xdr, uint32_t *bitmap)
3140 {
3141 	uint32_t bmlen;
3142 	__be32 *p;
3143 
3144 	p = xdr_inline_decode(xdr, 4);
3145 	if (unlikely(!p))
3146 		goto out_overflow;
3147 	bmlen = be32_to_cpup(p);
3148 
3149 	bitmap[0] = bitmap[1] = bitmap[2] = 0;
3150 	p = xdr_inline_decode(xdr, (bmlen << 2));
3151 	if (unlikely(!p))
3152 		goto out_overflow;
3153 	if (bmlen > 0) {
3154 		bitmap[0] = be32_to_cpup(p++);
3155 		if (bmlen > 1) {
3156 			bitmap[1] = be32_to_cpup(p++);
3157 			if (bmlen > 2)
3158 				bitmap[2] = be32_to_cpup(p);
3159 		}
3160 	}
3161 	return 0;
3162 out_overflow:
3163 	print_overflow_msg(__func__, xdr);
3164 	return -EIO;
3165 }
3166 
3167 static int decode_attr_length(struct xdr_stream *xdr, uint32_t *attrlen, unsigned int *savep)
3168 {
3169 	__be32 *p;
3170 
3171 	p = xdr_inline_decode(xdr, 4);
3172 	if (unlikely(!p))
3173 		goto out_overflow;
3174 	*attrlen = be32_to_cpup(p);
3175 	*savep = xdr_stream_pos(xdr);
3176 	return 0;
3177 out_overflow:
3178 	print_overflow_msg(__func__, xdr);
3179 	return -EIO;
3180 }
3181 
3182 static int decode_attr_supported(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *bitmask)
3183 {
3184 	if (likely(bitmap[0] & FATTR4_WORD0_SUPPORTED_ATTRS)) {
3185 		int ret;
3186 		ret = decode_attr_bitmap(xdr, bitmask);
3187 		if (unlikely(ret < 0))
3188 			return ret;
3189 		bitmap[0] &= ~FATTR4_WORD0_SUPPORTED_ATTRS;
3190 	} else
3191 		bitmask[0] = bitmask[1] = bitmask[2] = 0;
3192 	dprintk("%s: bitmask=%08x:%08x:%08x\n", __func__,
3193 		bitmask[0], bitmask[1], bitmask[2]);
3194 	return 0;
3195 }
3196 
3197 static int decode_attr_type(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *type)
3198 {
3199 	__be32 *p;
3200 	int ret = 0;
3201 
3202 	*type = 0;
3203 	if (unlikely(bitmap[0] & (FATTR4_WORD0_TYPE - 1U)))
3204 		return -EIO;
3205 	if (likely(bitmap[0] & FATTR4_WORD0_TYPE)) {
3206 		p = xdr_inline_decode(xdr, 4);
3207 		if (unlikely(!p))
3208 			goto out_overflow;
3209 		*type = be32_to_cpup(p);
3210 		if (*type < NF4REG || *type > NF4NAMEDATTR) {
3211 			dprintk("%s: bad type %d\n", __func__, *type);
3212 			return -EIO;
3213 		}
3214 		bitmap[0] &= ~FATTR4_WORD0_TYPE;
3215 		ret = NFS_ATTR_FATTR_TYPE;
3216 	}
3217 	dprintk("%s: type=0%o\n", __func__, nfs_type2fmt[*type]);
3218 	return ret;
3219 out_overflow:
3220 	print_overflow_msg(__func__, xdr);
3221 	return -EIO;
3222 }
3223 
3224 static int decode_attr_fh_expire_type(struct xdr_stream *xdr,
3225 				      uint32_t *bitmap, uint32_t *type)
3226 {
3227 	__be32 *p;
3228 
3229 	*type = 0;
3230 	if (unlikely(bitmap[0] & (FATTR4_WORD0_FH_EXPIRE_TYPE - 1U)))
3231 		return -EIO;
3232 	if (likely(bitmap[0] & FATTR4_WORD0_FH_EXPIRE_TYPE)) {
3233 		p = xdr_inline_decode(xdr, 4);
3234 		if (unlikely(!p))
3235 			goto out_overflow;
3236 		*type = be32_to_cpup(p);
3237 		bitmap[0] &= ~FATTR4_WORD0_FH_EXPIRE_TYPE;
3238 	}
3239 	dprintk("%s: expire type=0x%x\n", __func__, *type);
3240 	return 0;
3241 out_overflow:
3242 	print_overflow_msg(__func__, xdr);
3243 	return -EIO;
3244 }
3245 
3246 static int decode_attr_change(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *change)
3247 {
3248 	__be32 *p;
3249 	int ret = 0;
3250 
3251 	*change = 0;
3252 	if (unlikely(bitmap[0] & (FATTR4_WORD0_CHANGE - 1U)))
3253 		return -EIO;
3254 	if (likely(bitmap[0] & FATTR4_WORD0_CHANGE)) {
3255 		p = xdr_inline_decode(xdr, 8);
3256 		if (unlikely(!p))
3257 			goto out_overflow;
3258 		xdr_decode_hyper(p, change);
3259 		bitmap[0] &= ~FATTR4_WORD0_CHANGE;
3260 		ret = NFS_ATTR_FATTR_CHANGE;
3261 	}
3262 	dprintk("%s: change attribute=%Lu\n", __func__,
3263 			(unsigned long long)*change);
3264 	return ret;
3265 out_overflow:
3266 	print_overflow_msg(__func__, xdr);
3267 	return -EIO;
3268 }
3269 
3270 static int decode_attr_size(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *size)
3271 {
3272 	__be32 *p;
3273 	int ret = 0;
3274 
3275 	*size = 0;
3276 	if (unlikely(bitmap[0] & (FATTR4_WORD0_SIZE - 1U)))
3277 		return -EIO;
3278 	if (likely(bitmap[0] & FATTR4_WORD0_SIZE)) {
3279 		p = xdr_inline_decode(xdr, 8);
3280 		if (unlikely(!p))
3281 			goto out_overflow;
3282 		xdr_decode_hyper(p, size);
3283 		bitmap[0] &= ~FATTR4_WORD0_SIZE;
3284 		ret = NFS_ATTR_FATTR_SIZE;
3285 	}
3286 	dprintk("%s: file size=%Lu\n", __func__, (unsigned long long)*size);
3287 	return ret;
3288 out_overflow:
3289 	print_overflow_msg(__func__, xdr);
3290 	return -EIO;
3291 }
3292 
3293 static int decode_attr_link_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
3294 {
3295 	__be32 *p;
3296 
3297 	*res = 0;
3298 	if (unlikely(bitmap[0] & (FATTR4_WORD0_LINK_SUPPORT - 1U)))
3299 		return -EIO;
3300 	if (likely(bitmap[0] & FATTR4_WORD0_LINK_SUPPORT)) {
3301 		p = xdr_inline_decode(xdr, 4);
3302 		if (unlikely(!p))
3303 			goto out_overflow;
3304 		*res = be32_to_cpup(p);
3305 		bitmap[0] &= ~FATTR4_WORD0_LINK_SUPPORT;
3306 	}
3307 	dprintk("%s: link support=%s\n", __func__, *res == 0 ? "false" : "true");
3308 	return 0;
3309 out_overflow:
3310 	print_overflow_msg(__func__, xdr);
3311 	return -EIO;
3312 }
3313 
3314 static int decode_attr_symlink_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
3315 {
3316 	__be32 *p;
3317 
3318 	*res = 0;
3319 	if (unlikely(bitmap[0] & (FATTR4_WORD0_SYMLINK_SUPPORT - 1U)))
3320 		return -EIO;
3321 	if (likely(bitmap[0] & FATTR4_WORD0_SYMLINK_SUPPORT)) {
3322 		p = xdr_inline_decode(xdr, 4);
3323 		if (unlikely(!p))
3324 			goto out_overflow;
3325 		*res = be32_to_cpup(p);
3326 		bitmap[0] &= ~FATTR4_WORD0_SYMLINK_SUPPORT;
3327 	}
3328 	dprintk("%s: symlink support=%s\n", __func__, *res == 0 ? "false" : "true");
3329 	return 0;
3330 out_overflow:
3331 	print_overflow_msg(__func__, xdr);
3332 	return -EIO;
3333 }
3334 
3335 static int decode_attr_fsid(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_fsid *fsid)
3336 {
3337 	__be32 *p;
3338 	int ret = 0;
3339 
3340 	fsid->major = 0;
3341 	fsid->minor = 0;
3342 	if (unlikely(bitmap[0] & (FATTR4_WORD0_FSID - 1U)))
3343 		return -EIO;
3344 	if (likely(bitmap[0] & FATTR4_WORD0_FSID)) {
3345 		p = xdr_inline_decode(xdr, 16);
3346 		if (unlikely(!p))
3347 			goto out_overflow;
3348 		p = xdr_decode_hyper(p, &fsid->major);
3349 		xdr_decode_hyper(p, &fsid->minor);
3350 		bitmap[0] &= ~FATTR4_WORD0_FSID;
3351 		ret = NFS_ATTR_FATTR_FSID;
3352 	}
3353 	dprintk("%s: fsid=(0x%Lx/0x%Lx)\n", __func__,
3354 			(unsigned long long)fsid->major,
3355 			(unsigned long long)fsid->minor);
3356 	return ret;
3357 out_overflow:
3358 	print_overflow_msg(__func__, xdr);
3359 	return -EIO;
3360 }
3361 
3362 static int decode_attr_lease_time(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
3363 {
3364 	__be32 *p;
3365 
3366 	*res = 60;
3367 	if (unlikely(bitmap[0] & (FATTR4_WORD0_LEASE_TIME - 1U)))
3368 		return -EIO;
3369 	if (likely(bitmap[0] & FATTR4_WORD0_LEASE_TIME)) {
3370 		p = xdr_inline_decode(xdr, 4);
3371 		if (unlikely(!p))
3372 			goto out_overflow;
3373 		*res = be32_to_cpup(p);
3374 		bitmap[0] &= ~FATTR4_WORD0_LEASE_TIME;
3375 	}
3376 	dprintk("%s: file size=%u\n", __func__, (unsigned int)*res);
3377 	return 0;
3378 out_overflow:
3379 	print_overflow_msg(__func__, xdr);
3380 	return -EIO;
3381 }
3382 
3383 static int decode_attr_error(struct xdr_stream *xdr, uint32_t *bitmap, int32_t *res)
3384 {
3385 	__be32 *p;
3386 
3387 	if (unlikely(bitmap[0] & (FATTR4_WORD0_RDATTR_ERROR - 1U)))
3388 		return -EIO;
3389 	if (likely(bitmap[0] & FATTR4_WORD0_RDATTR_ERROR)) {
3390 		p = xdr_inline_decode(xdr, 4);
3391 		if (unlikely(!p))
3392 			goto out_overflow;
3393 		bitmap[0] &= ~FATTR4_WORD0_RDATTR_ERROR;
3394 		*res = -be32_to_cpup(p);
3395 	}
3396 	return 0;
3397 out_overflow:
3398 	print_overflow_msg(__func__, xdr);
3399 	return -EIO;
3400 }
3401 
3402 static int decode_attr_filehandle(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_fh *fh)
3403 {
3404 	__be32 *p;
3405 	int len;
3406 
3407 	if (fh != NULL)
3408 		memset(fh, 0, sizeof(*fh));
3409 
3410 	if (unlikely(bitmap[0] & (FATTR4_WORD0_FILEHANDLE - 1U)))
3411 		return -EIO;
3412 	if (likely(bitmap[0] & FATTR4_WORD0_FILEHANDLE)) {
3413 		p = xdr_inline_decode(xdr, 4);
3414 		if (unlikely(!p))
3415 			goto out_overflow;
3416 		len = be32_to_cpup(p);
3417 		if (len > NFS4_FHSIZE)
3418 			return -EIO;
3419 		p = xdr_inline_decode(xdr, len);
3420 		if (unlikely(!p))
3421 			goto out_overflow;
3422 		if (fh != NULL) {
3423 			memcpy(fh->data, p, len);
3424 			fh->size = len;
3425 		}
3426 		bitmap[0] &= ~FATTR4_WORD0_FILEHANDLE;
3427 	}
3428 	return 0;
3429 out_overflow:
3430 	print_overflow_msg(__func__, xdr);
3431 	return -EIO;
3432 }
3433 
3434 static int decode_attr_aclsupport(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
3435 {
3436 	__be32 *p;
3437 
3438 	*res = ACL4_SUPPORT_ALLOW_ACL|ACL4_SUPPORT_DENY_ACL;
3439 	if (unlikely(bitmap[0] & (FATTR4_WORD0_ACLSUPPORT - 1U)))
3440 		return -EIO;
3441 	if (likely(bitmap[0] & FATTR4_WORD0_ACLSUPPORT)) {
3442 		p = xdr_inline_decode(xdr, 4);
3443 		if (unlikely(!p))
3444 			goto out_overflow;
3445 		*res = be32_to_cpup(p);
3446 		bitmap[0] &= ~FATTR4_WORD0_ACLSUPPORT;
3447 	}
3448 	dprintk("%s: ACLs supported=%u\n", __func__, (unsigned int)*res);
3449 	return 0;
3450 out_overflow:
3451 	print_overflow_msg(__func__, xdr);
3452 	return -EIO;
3453 }
3454 
3455 static int decode_attr_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *fileid)
3456 {
3457 	__be32 *p;
3458 	int ret = 0;
3459 
3460 	*fileid = 0;
3461 	if (unlikely(bitmap[0] & (FATTR4_WORD0_FILEID - 1U)))
3462 		return -EIO;
3463 	if (likely(bitmap[0] & FATTR4_WORD0_FILEID)) {
3464 		p = xdr_inline_decode(xdr, 8);
3465 		if (unlikely(!p))
3466 			goto out_overflow;
3467 		xdr_decode_hyper(p, fileid);
3468 		bitmap[0] &= ~FATTR4_WORD0_FILEID;
3469 		ret = NFS_ATTR_FATTR_FILEID;
3470 	}
3471 	dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid);
3472 	return ret;
3473 out_overflow:
3474 	print_overflow_msg(__func__, xdr);
3475 	return -EIO;
3476 }
3477 
3478 static int decode_attr_mounted_on_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *fileid)
3479 {
3480 	__be32 *p;
3481 	int ret = 0;
3482 
3483 	*fileid = 0;
3484 	if (unlikely(bitmap[1] & (FATTR4_WORD1_MOUNTED_ON_FILEID - 1U)))
3485 		return -EIO;
3486 	if (likely(bitmap[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)) {
3487 		p = xdr_inline_decode(xdr, 8);
3488 		if (unlikely(!p))
3489 			goto out_overflow;
3490 		xdr_decode_hyper(p, fileid);
3491 		bitmap[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID;
3492 		ret = NFS_ATTR_FATTR_MOUNTED_ON_FILEID;
3493 	}
3494 	dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid);
3495 	return ret;
3496 out_overflow:
3497 	print_overflow_msg(__func__, xdr);
3498 	return -EIO;
3499 }
3500 
3501 static int decode_attr_files_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
3502 {
3503 	__be32 *p;
3504 	int status = 0;
3505 
3506 	*res = 0;
3507 	if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_AVAIL - 1U)))
3508 		return -EIO;
3509 	if (likely(bitmap[0] & FATTR4_WORD0_FILES_AVAIL)) {
3510 		p = xdr_inline_decode(xdr, 8);
3511 		if (unlikely(!p))
3512 			goto out_overflow;
3513 		xdr_decode_hyper(p, res);
3514 		bitmap[0] &= ~FATTR4_WORD0_FILES_AVAIL;
3515 	}
3516 	dprintk("%s: files avail=%Lu\n", __func__, (unsigned long long)*res);
3517 	return status;
3518 out_overflow:
3519 	print_overflow_msg(__func__, xdr);
3520 	return -EIO;
3521 }
3522 
3523 static int decode_attr_files_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
3524 {
3525 	__be32 *p;
3526 	int status = 0;
3527 
3528 	*res = 0;
3529 	if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_FREE - 1U)))
3530 		return -EIO;
3531 	if (likely(bitmap[0] & FATTR4_WORD0_FILES_FREE)) {
3532 		p = xdr_inline_decode(xdr, 8);
3533 		if (unlikely(!p))
3534 			goto out_overflow;
3535 		xdr_decode_hyper(p, res);
3536 		bitmap[0] &= ~FATTR4_WORD0_FILES_FREE;
3537 	}
3538 	dprintk("%s: files free=%Lu\n", __func__, (unsigned long long)*res);
3539 	return status;
3540 out_overflow:
3541 	print_overflow_msg(__func__, xdr);
3542 	return -EIO;
3543 }
3544 
3545 static int decode_attr_files_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
3546 {
3547 	__be32 *p;
3548 	int status = 0;
3549 
3550 	*res = 0;
3551 	if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_TOTAL - 1U)))
3552 		return -EIO;
3553 	if (likely(bitmap[0] & FATTR4_WORD0_FILES_TOTAL)) {
3554 		p = xdr_inline_decode(xdr, 8);
3555 		if (unlikely(!p))
3556 			goto out_overflow;
3557 		xdr_decode_hyper(p, res);
3558 		bitmap[0] &= ~FATTR4_WORD0_FILES_TOTAL;
3559 	}
3560 	dprintk("%s: files total=%Lu\n", __func__, (unsigned long long)*res);
3561 	return status;
3562 out_overflow:
3563 	print_overflow_msg(__func__, xdr);
3564 	return -EIO;
3565 }
3566 
3567 static int decode_pathname(struct xdr_stream *xdr, struct nfs4_pathname *path)
3568 {
3569 	u32 n;
3570 	__be32 *p;
3571 	int status = 0;
3572 
3573 	p = xdr_inline_decode(xdr, 4);
3574 	if (unlikely(!p))
3575 		goto out_overflow;
3576 	n = be32_to_cpup(p);
3577 	if (n == 0)
3578 		goto root_path;
3579 	dprintk("pathname4: ");
3580 	if (n > NFS4_PATHNAME_MAXCOMPONENTS) {
3581 		dprintk("cannot parse %d components in path\n", n);
3582 		goto out_eio;
3583 	}
3584 	for (path->ncomponents = 0; path->ncomponents < n; path->ncomponents++) {
3585 		struct nfs4_string *component = &path->components[path->ncomponents];
3586 		status = decode_opaque_inline(xdr, &component->len, &component->data);
3587 		if (unlikely(status != 0))
3588 			goto out_eio;
3589 		ifdebug (XDR)
3590 			pr_cont("%s%.*s ",
3591 				(path->ncomponents != n ? "/ " : ""),
3592 				component->len, component->data);
3593 	}
3594 out:
3595 	return status;
3596 root_path:
3597 /* a root pathname is sent as a zero component4 */
3598 	path->ncomponents = 1;
3599 	path->components[0].len=0;
3600 	path->components[0].data=NULL;
3601 	dprintk("pathname4: /\n");
3602 	goto out;
3603 out_eio:
3604 	dprintk(" status %d", status);
3605 	status = -EIO;
3606 	goto out;
3607 out_overflow:
3608 	print_overflow_msg(__func__, xdr);
3609 	return -EIO;
3610 }
3611 
3612 static int decode_attr_fs_locations(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs4_fs_locations *res)
3613 {
3614 	int n;
3615 	__be32 *p;
3616 	int status = -EIO;
3617 
3618 	if (unlikely(bitmap[0] & (FATTR4_WORD0_FS_LOCATIONS -1U)))
3619 		goto out;
3620 	status = 0;
3621 	if (unlikely(!(bitmap[0] & FATTR4_WORD0_FS_LOCATIONS)))
3622 		goto out;
3623 	status = -EIO;
3624 	/* Ignore borken servers that return unrequested attrs */
3625 	if (unlikely(res == NULL))
3626 		goto out;
3627 	dprintk("%s: fsroot:\n", __func__);
3628 	status = decode_pathname(xdr, &res->fs_path);
3629 	if (unlikely(status != 0))
3630 		goto out;
3631 	p = xdr_inline_decode(xdr, 4);
3632 	if (unlikely(!p))
3633 		goto out_overflow;
3634 	n = be32_to_cpup(p);
3635 	if (n <= 0)
3636 		goto out_eio;
3637 	for (res->nlocations = 0; res->nlocations < n; res->nlocations++) {
3638 		u32 m;
3639 		struct nfs4_fs_location *loc;
3640 
3641 		if (res->nlocations == NFS4_FS_LOCATIONS_MAXENTRIES)
3642 			break;
3643 		loc = &res->locations[res->nlocations];
3644 		p = xdr_inline_decode(xdr, 4);
3645 		if (unlikely(!p))
3646 			goto out_overflow;
3647 		m = be32_to_cpup(p);
3648 
3649 		dprintk("%s: servers:\n", __func__);
3650 		for (loc->nservers = 0; loc->nservers < m; loc->nservers++) {
3651 			struct nfs4_string *server;
3652 
3653 			if (loc->nservers == NFS4_FS_LOCATION_MAXSERVERS) {
3654 				unsigned int i;
3655 				dprintk("%s: using first %u of %u servers "
3656 					"returned for location %u\n",
3657 						__func__,
3658 						NFS4_FS_LOCATION_MAXSERVERS,
3659 						m, res->nlocations);
3660 				for (i = loc->nservers; i < m; i++) {
3661 					unsigned int len;
3662 					char *data;
3663 					status = decode_opaque_inline(xdr, &len, &data);
3664 					if (unlikely(status != 0))
3665 						goto out_eio;
3666 				}
3667 				break;
3668 			}
3669 			server = &loc->servers[loc->nservers];
3670 			status = decode_opaque_inline(xdr, &server->len, &server->data);
3671 			if (unlikely(status != 0))
3672 				goto out_eio;
3673 			dprintk("%s ", server->data);
3674 		}
3675 		status = decode_pathname(xdr, &loc->rootpath);
3676 		if (unlikely(status != 0))
3677 			goto out_eio;
3678 	}
3679 	if (res->nlocations != 0)
3680 		status = NFS_ATTR_FATTR_V4_LOCATIONS;
3681 out:
3682 	dprintk("%s: fs_locations done, error = %d\n", __func__, status);
3683 	return status;
3684 out_overflow:
3685 	print_overflow_msg(__func__, xdr);
3686 out_eio:
3687 	status = -EIO;
3688 	goto out;
3689 }
3690 
3691 static int decode_attr_maxfilesize(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
3692 {
3693 	__be32 *p;
3694 	int status = 0;
3695 
3696 	*res = 0;
3697 	if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXFILESIZE - 1U)))
3698 		return -EIO;
3699 	if (likely(bitmap[0] & FATTR4_WORD0_MAXFILESIZE)) {
3700 		p = xdr_inline_decode(xdr, 8);
3701 		if (unlikely(!p))
3702 			goto out_overflow;
3703 		xdr_decode_hyper(p, res);
3704 		bitmap[0] &= ~FATTR4_WORD0_MAXFILESIZE;
3705 	}
3706 	dprintk("%s: maxfilesize=%Lu\n", __func__, (unsigned long long)*res);
3707 	return status;
3708 out_overflow:
3709 	print_overflow_msg(__func__, xdr);
3710 	return -EIO;
3711 }
3712 
3713 static int decode_attr_maxlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *maxlink)
3714 {
3715 	__be32 *p;
3716 	int status = 0;
3717 
3718 	*maxlink = 1;
3719 	if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXLINK - 1U)))
3720 		return -EIO;
3721 	if (likely(bitmap[0] & FATTR4_WORD0_MAXLINK)) {
3722 		p = xdr_inline_decode(xdr, 4);
3723 		if (unlikely(!p))
3724 			goto out_overflow;
3725 		*maxlink = be32_to_cpup(p);
3726 		bitmap[0] &= ~FATTR4_WORD0_MAXLINK;
3727 	}
3728 	dprintk("%s: maxlink=%u\n", __func__, *maxlink);
3729 	return status;
3730 out_overflow:
3731 	print_overflow_msg(__func__, xdr);
3732 	return -EIO;
3733 }
3734 
3735 static int decode_attr_maxname(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *maxname)
3736 {
3737 	__be32 *p;
3738 	int status = 0;
3739 
3740 	*maxname = 1024;
3741 	if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXNAME - 1U)))
3742 		return -EIO;
3743 	if (likely(bitmap[0] & FATTR4_WORD0_MAXNAME)) {
3744 		p = xdr_inline_decode(xdr, 4);
3745 		if (unlikely(!p))
3746 			goto out_overflow;
3747 		*maxname = be32_to_cpup(p);
3748 		bitmap[0] &= ~FATTR4_WORD0_MAXNAME;
3749 	}
3750 	dprintk("%s: maxname=%u\n", __func__, *maxname);
3751 	return status;
3752 out_overflow:
3753 	print_overflow_msg(__func__, xdr);
3754 	return -EIO;
3755 }
3756 
3757 static int decode_attr_maxread(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
3758 {
3759 	__be32 *p;
3760 	int status = 0;
3761 
3762 	*res = 1024;
3763 	if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXREAD - 1U)))
3764 		return -EIO;
3765 	if (likely(bitmap[0] & FATTR4_WORD0_MAXREAD)) {
3766 		uint64_t maxread;
3767 		p = xdr_inline_decode(xdr, 8);
3768 		if (unlikely(!p))
3769 			goto out_overflow;
3770 		xdr_decode_hyper(p, &maxread);
3771 		if (maxread > 0x7FFFFFFF)
3772 			maxread = 0x7FFFFFFF;
3773 		*res = (uint32_t)maxread;
3774 		bitmap[0] &= ~FATTR4_WORD0_MAXREAD;
3775 	}
3776 	dprintk("%s: maxread=%lu\n", __func__, (unsigned long)*res);
3777 	return status;
3778 out_overflow:
3779 	print_overflow_msg(__func__, xdr);
3780 	return -EIO;
3781 }
3782 
3783 static int decode_attr_maxwrite(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
3784 {
3785 	__be32 *p;
3786 	int status = 0;
3787 
3788 	*res = 1024;
3789 	if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXWRITE - 1U)))
3790 		return -EIO;
3791 	if (likely(bitmap[0] & FATTR4_WORD0_MAXWRITE)) {
3792 		uint64_t maxwrite;
3793 		p = xdr_inline_decode(xdr, 8);
3794 		if (unlikely(!p))
3795 			goto out_overflow;
3796 		xdr_decode_hyper(p, &maxwrite);
3797 		if (maxwrite > 0x7FFFFFFF)
3798 			maxwrite = 0x7FFFFFFF;
3799 		*res = (uint32_t)maxwrite;
3800 		bitmap[0] &= ~FATTR4_WORD0_MAXWRITE;
3801 	}
3802 	dprintk("%s: maxwrite=%lu\n", __func__, (unsigned long)*res);
3803 	return status;
3804 out_overflow:
3805 	print_overflow_msg(__func__, xdr);
3806 	return -EIO;
3807 }
3808 
3809 static int decode_attr_mode(struct xdr_stream *xdr, uint32_t *bitmap, umode_t *mode)
3810 {
3811 	uint32_t tmp;
3812 	__be32 *p;
3813 	int ret = 0;
3814 
3815 	*mode = 0;
3816 	if (unlikely(bitmap[1] & (FATTR4_WORD1_MODE - 1U)))
3817 		return -EIO;
3818 	if (likely(bitmap[1] & FATTR4_WORD1_MODE)) {
3819 		p = xdr_inline_decode(xdr, 4);
3820 		if (unlikely(!p))
3821 			goto out_overflow;
3822 		tmp = be32_to_cpup(p);
3823 		*mode = tmp & ~S_IFMT;
3824 		bitmap[1] &= ~FATTR4_WORD1_MODE;
3825 		ret = NFS_ATTR_FATTR_MODE;
3826 	}
3827 	dprintk("%s: file mode=0%o\n", __func__, (unsigned int)*mode);
3828 	return ret;
3829 out_overflow:
3830 	print_overflow_msg(__func__, xdr);
3831 	return -EIO;
3832 }
3833 
3834 static int decode_attr_nlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *nlink)
3835 {
3836 	__be32 *p;
3837 	int ret = 0;
3838 
3839 	*nlink = 1;
3840 	if (unlikely(bitmap[1] & (FATTR4_WORD1_NUMLINKS - 1U)))
3841 		return -EIO;
3842 	if (likely(bitmap[1] & FATTR4_WORD1_NUMLINKS)) {
3843 		p = xdr_inline_decode(xdr, 4);
3844 		if (unlikely(!p))
3845 			goto out_overflow;
3846 		*nlink = be32_to_cpup(p);
3847 		bitmap[1] &= ~FATTR4_WORD1_NUMLINKS;
3848 		ret = NFS_ATTR_FATTR_NLINK;
3849 	}
3850 	dprintk("%s: nlink=%u\n", __func__, (unsigned int)*nlink);
3851 	return ret;
3852 out_overflow:
3853 	print_overflow_msg(__func__, xdr);
3854 	return -EIO;
3855 }
3856 
3857 static int decode_attr_owner(struct xdr_stream *xdr, uint32_t *bitmap,
3858 		const struct nfs_server *server, kuid_t *uid,
3859 		struct nfs4_string *owner_name)
3860 {
3861 	uint32_t len;
3862 	__be32 *p;
3863 	int ret = 0;
3864 
3865 	*uid = make_kuid(&init_user_ns, -2);
3866 	if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER - 1U)))
3867 		return -EIO;
3868 	if (likely(bitmap[1] & FATTR4_WORD1_OWNER)) {
3869 		p = xdr_inline_decode(xdr, 4);
3870 		if (unlikely(!p))
3871 			goto out_overflow;
3872 		len = be32_to_cpup(p);
3873 		p = xdr_inline_decode(xdr, len);
3874 		if (unlikely(!p))
3875 			goto out_overflow;
3876 		if (owner_name != NULL) {
3877 			owner_name->data = kmemdup(p, len, GFP_NOWAIT);
3878 			if (owner_name->data != NULL) {
3879 				owner_name->len = len;
3880 				ret = NFS_ATTR_FATTR_OWNER_NAME;
3881 			}
3882 		} else if (len < XDR_MAX_NETOBJ) {
3883 			if (nfs_map_name_to_uid(server, (char *)p, len, uid) == 0)
3884 				ret = NFS_ATTR_FATTR_OWNER;
3885 			else
3886 				dprintk("%s: nfs_map_name_to_uid failed!\n",
3887 						__func__);
3888 		} else
3889 			dprintk("%s: name too long (%u)!\n",
3890 					__func__, len);
3891 		bitmap[1] &= ~FATTR4_WORD1_OWNER;
3892 	}
3893 	dprintk("%s: uid=%d\n", __func__, (int)from_kuid(&init_user_ns, *uid));
3894 	return ret;
3895 out_overflow:
3896 	print_overflow_msg(__func__, xdr);
3897 	return -EIO;
3898 }
3899 
3900 static int decode_attr_group(struct xdr_stream *xdr, uint32_t *bitmap,
3901 		const struct nfs_server *server, kgid_t *gid,
3902 		struct nfs4_string *group_name)
3903 {
3904 	uint32_t len;
3905 	__be32 *p;
3906 	int ret = 0;
3907 
3908 	*gid = make_kgid(&init_user_ns, -2);
3909 	if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER_GROUP - 1U)))
3910 		return -EIO;
3911 	if (likely(bitmap[1] & FATTR4_WORD1_OWNER_GROUP)) {
3912 		p = xdr_inline_decode(xdr, 4);
3913 		if (unlikely(!p))
3914 			goto out_overflow;
3915 		len = be32_to_cpup(p);
3916 		p = xdr_inline_decode(xdr, len);
3917 		if (unlikely(!p))
3918 			goto out_overflow;
3919 		if (group_name != NULL) {
3920 			group_name->data = kmemdup(p, len, GFP_NOWAIT);
3921 			if (group_name->data != NULL) {
3922 				group_name->len = len;
3923 				ret = NFS_ATTR_FATTR_GROUP_NAME;
3924 			}
3925 		} else if (len < XDR_MAX_NETOBJ) {
3926 			if (nfs_map_group_to_gid(server, (char *)p, len, gid) == 0)
3927 				ret = NFS_ATTR_FATTR_GROUP;
3928 			else
3929 				dprintk("%s: nfs_map_group_to_gid failed!\n",
3930 						__func__);
3931 		} else
3932 			dprintk("%s: name too long (%u)!\n",
3933 					__func__, len);
3934 		bitmap[1] &= ~FATTR4_WORD1_OWNER_GROUP;
3935 	}
3936 	dprintk("%s: gid=%d\n", __func__, (int)from_kgid(&init_user_ns, *gid));
3937 	return ret;
3938 out_overflow:
3939 	print_overflow_msg(__func__, xdr);
3940 	return -EIO;
3941 }
3942 
3943 static int decode_attr_rdev(struct xdr_stream *xdr, uint32_t *bitmap, dev_t *rdev)
3944 {
3945 	uint32_t major = 0, minor = 0;
3946 	__be32 *p;
3947 	int ret = 0;
3948 
3949 	*rdev = MKDEV(0,0);
3950 	if (unlikely(bitmap[1] & (FATTR4_WORD1_RAWDEV - 1U)))
3951 		return -EIO;
3952 	if (likely(bitmap[1] & FATTR4_WORD1_RAWDEV)) {
3953 		dev_t tmp;
3954 
3955 		p = xdr_inline_decode(xdr, 8);
3956 		if (unlikely(!p))
3957 			goto out_overflow;
3958 		major = be32_to_cpup(p++);
3959 		minor = be32_to_cpup(p);
3960 		tmp = MKDEV(major, minor);
3961 		if (MAJOR(tmp) == major && MINOR(tmp) == minor)
3962 			*rdev = tmp;
3963 		bitmap[1] &= ~ FATTR4_WORD1_RAWDEV;
3964 		ret = NFS_ATTR_FATTR_RDEV;
3965 	}
3966 	dprintk("%s: rdev=(0x%x:0x%x)\n", __func__, major, minor);
3967 	return ret;
3968 out_overflow:
3969 	print_overflow_msg(__func__, xdr);
3970 	return -EIO;
3971 }
3972 
3973 static int decode_attr_space_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
3974 {
3975 	__be32 *p;
3976 	int status = 0;
3977 
3978 	*res = 0;
3979 	if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_AVAIL - 1U)))
3980 		return -EIO;
3981 	if (likely(bitmap[1] & FATTR4_WORD1_SPACE_AVAIL)) {
3982 		p = xdr_inline_decode(xdr, 8);
3983 		if (unlikely(!p))
3984 			goto out_overflow;
3985 		xdr_decode_hyper(p, res);
3986 		bitmap[1] &= ~FATTR4_WORD1_SPACE_AVAIL;
3987 	}
3988 	dprintk("%s: space avail=%Lu\n", __func__, (unsigned long long)*res);
3989 	return status;
3990 out_overflow:
3991 	print_overflow_msg(__func__, xdr);
3992 	return -EIO;
3993 }
3994 
3995 static int decode_attr_space_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
3996 {
3997 	__be32 *p;
3998 	int status = 0;
3999 
4000 	*res = 0;
4001 	if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_FREE - 1U)))
4002 		return -EIO;
4003 	if (likely(bitmap[1] & FATTR4_WORD1_SPACE_FREE)) {
4004 		p = xdr_inline_decode(xdr, 8);
4005 		if (unlikely(!p))
4006 			goto out_overflow;
4007 		xdr_decode_hyper(p, res);
4008 		bitmap[1] &= ~FATTR4_WORD1_SPACE_FREE;
4009 	}
4010 	dprintk("%s: space free=%Lu\n", __func__, (unsigned long long)*res);
4011 	return status;
4012 out_overflow:
4013 	print_overflow_msg(__func__, xdr);
4014 	return -EIO;
4015 }
4016 
4017 static int decode_attr_space_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
4018 {
4019 	__be32 *p;
4020 	int status = 0;
4021 
4022 	*res = 0;
4023 	if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_TOTAL - 1U)))
4024 		return -EIO;
4025 	if (likely(bitmap[1] & FATTR4_WORD1_SPACE_TOTAL)) {
4026 		p = xdr_inline_decode(xdr, 8);
4027 		if (unlikely(!p))
4028 			goto out_overflow;
4029 		xdr_decode_hyper(p, res);
4030 		bitmap[1] &= ~FATTR4_WORD1_SPACE_TOTAL;
4031 	}
4032 	dprintk("%s: space total=%Lu\n", __func__, (unsigned long long)*res);
4033 	return status;
4034 out_overflow:
4035 	print_overflow_msg(__func__, xdr);
4036 	return -EIO;
4037 }
4038 
4039 static int decode_attr_space_used(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *used)
4040 {
4041 	__be32 *p;
4042 	int ret = 0;
4043 
4044 	*used = 0;
4045 	if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_USED - 1U)))
4046 		return -EIO;
4047 	if (likely(bitmap[1] & FATTR4_WORD1_SPACE_USED)) {
4048 		p = xdr_inline_decode(xdr, 8);
4049 		if (unlikely(!p))
4050 			goto out_overflow;
4051 		xdr_decode_hyper(p, used);
4052 		bitmap[1] &= ~FATTR4_WORD1_SPACE_USED;
4053 		ret = NFS_ATTR_FATTR_SPACE_USED;
4054 	}
4055 	dprintk("%s: space used=%Lu\n", __func__,
4056 			(unsigned long long)*used);
4057 	return ret;
4058 out_overflow:
4059 	print_overflow_msg(__func__, xdr);
4060 	return -EIO;
4061 }
4062 
4063 static int decode_attr_time(struct xdr_stream *xdr, struct timespec *time)
4064 {
4065 	__be32 *p;
4066 	uint64_t sec;
4067 	uint32_t nsec;
4068 
4069 	p = xdr_inline_decode(xdr, 12);
4070 	if (unlikely(!p))
4071 		goto out_overflow;
4072 	p = xdr_decode_hyper(p, &sec);
4073 	nsec = be32_to_cpup(p);
4074 	time->tv_sec = (time_t)sec;
4075 	time->tv_nsec = (long)nsec;
4076 	return 0;
4077 out_overflow:
4078 	print_overflow_msg(__func__, xdr);
4079 	return -EIO;
4080 }
4081 
4082 static int decode_attr_time_access(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
4083 {
4084 	int status = 0;
4085 
4086 	time->tv_sec = 0;
4087 	time->tv_nsec = 0;
4088 	if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_ACCESS - 1U)))
4089 		return -EIO;
4090 	if (likely(bitmap[1] & FATTR4_WORD1_TIME_ACCESS)) {
4091 		status = decode_attr_time(xdr, time);
4092 		if (status == 0)
4093 			status = NFS_ATTR_FATTR_ATIME;
4094 		bitmap[1] &= ~FATTR4_WORD1_TIME_ACCESS;
4095 	}
4096 	dprintk("%s: atime=%ld\n", __func__, (long)time->tv_sec);
4097 	return status;
4098 }
4099 
4100 static int decode_attr_time_metadata(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
4101 {
4102 	int status = 0;
4103 
4104 	time->tv_sec = 0;
4105 	time->tv_nsec = 0;
4106 	if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_METADATA - 1U)))
4107 		return -EIO;
4108 	if (likely(bitmap[1] & FATTR4_WORD1_TIME_METADATA)) {
4109 		status = decode_attr_time(xdr, time);
4110 		if (status == 0)
4111 			status = NFS_ATTR_FATTR_CTIME;
4112 		bitmap[1] &= ~FATTR4_WORD1_TIME_METADATA;
4113 	}
4114 	dprintk("%s: ctime=%ld\n", __func__, (long)time->tv_sec);
4115 	return status;
4116 }
4117 
4118 static int decode_attr_time_delta(struct xdr_stream *xdr, uint32_t *bitmap,
4119 				  struct timespec *time)
4120 {
4121 	int status = 0;
4122 
4123 	time->tv_sec = 0;
4124 	time->tv_nsec = 0;
4125 	if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_DELTA - 1U)))
4126 		return -EIO;
4127 	if (likely(bitmap[1] & FATTR4_WORD1_TIME_DELTA)) {
4128 		status = decode_attr_time(xdr, time);
4129 		bitmap[1] &= ~FATTR4_WORD1_TIME_DELTA;
4130 	}
4131 	dprintk("%s: time_delta=%ld %ld\n", __func__, (long)time->tv_sec,
4132 		(long)time->tv_nsec);
4133 	return status;
4134 }
4135 
4136 static int decode_attr_security_label(struct xdr_stream *xdr, uint32_t *bitmap,
4137 					struct nfs4_label *label)
4138 {
4139 	uint32_t pi = 0;
4140 	uint32_t lfs = 0;
4141 	__u32 len;
4142 	__be32 *p;
4143 	int status = 0;
4144 
4145 	if (unlikely(bitmap[2] & (FATTR4_WORD2_SECURITY_LABEL - 1U)))
4146 		return -EIO;
4147 	if (likely(bitmap[2] & FATTR4_WORD2_SECURITY_LABEL)) {
4148 		p = xdr_inline_decode(xdr, 4);
4149 		if (unlikely(!p))
4150 			goto out_overflow;
4151 		lfs = be32_to_cpup(p++);
4152 		p = xdr_inline_decode(xdr, 4);
4153 		if (unlikely(!p))
4154 			goto out_overflow;
4155 		pi = be32_to_cpup(p++);
4156 		p = xdr_inline_decode(xdr, 4);
4157 		if (unlikely(!p))
4158 			goto out_overflow;
4159 		len = be32_to_cpup(p++);
4160 		p = xdr_inline_decode(xdr, len);
4161 		if (unlikely(!p))
4162 			goto out_overflow;
4163 		if (len < NFS4_MAXLABELLEN) {
4164 			if (label) {
4165 				memcpy(label->label, p, len);
4166 				label->len = len;
4167 				label->pi = pi;
4168 				label->lfs = lfs;
4169 				status = NFS_ATTR_FATTR_V4_SECURITY_LABEL;
4170 			}
4171 			bitmap[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
4172 		} else
4173 			printk(KERN_WARNING "%s: label too long (%u)!\n",
4174 					__func__, len);
4175 	}
4176 	if (label && label->label)
4177 		dprintk("%s: label=%s, len=%d, PI=%d, LFS=%d\n", __func__,
4178 			(char *)label->label, label->len, label->pi, label->lfs);
4179 	return status;
4180 
4181 out_overflow:
4182 	print_overflow_msg(__func__, xdr);
4183 	return -EIO;
4184 }
4185 
4186 static int decode_attr_time_modify(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
4187 {
4188 	int status = 0;
4189 
4190 	time->tv_sec = 0;
4191 	time->tv_nsec = 0;
4192 	if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_MODIFY - 1U)))
4193 		return -EIO;
4194 	if (likely(bitmap[1] & FATTR4_WORD1_TIME_MODIFY)) {
4195 		status = decode_attr_time(xdr, time);
4196 		if (status == 0)
4197 			status = NFS_ATTR_FATTR_MTIME;
4198 		bitmap[1] &= ~FATTR4_WORD1_TIME_MODIFY;
4199 	}
4200 	dprintk("%s: mtime=%ld\n", __func__, (long)time->tv_sec);
4201 	return status;
4202 }
4203 
4204 static int verify_attr_len(struct xdr_stream *xdr, unsigned int savep, uint32_t attrlen)
4205 {
4206 	unsigned int attrwords = XDR_QUADLEN(attrlen);
4207 	unsigned int nwords = (xdr_stream_pos(xdr) - savep) >> 2;
4208 
4209 	if (unlikely(attrwords != nwords)) {
4210 		dprintk("%s: server returned incorrect attribute length: "
4211 			"%u %c %u\n",
4212 				__func__,
4213 				attrwords << 2,
4214 				(attrwords < nwords) ? '<' : '>',
4215 				nwords << 2);
4216 		return -EIO;
4217 	}
4218 	return 0;
4219 }
4220 
4221 static int decode_change_info(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
4222 {
4223 	__be32 *p;
4224 
4225 	p = xdr_inline_decode(xdr, 20);
4226 	if (unlikely(!p))
4227 		goto out_overflow;
4228 	cinfo->atomic = be32_to_cpup(p++);
4229 	p = xdr_decode_hyper(p, &cinfo->before);
4230 	xdr_decode_hyper(p, &cinfo->after);
4231 	return 0;
4232 out_overflow:
4233 	print_overflow_msg(__func__, xdr);
4234 	return -EIO;
4235 }
4236 
4237 static int decode_access(struct xdr_stream *xdr, u32 *supported, u32 *access)
4238 {
4239 	__be32 *p;
4240 	uint32_t supp, acc;
4241 	int status;
4242 
4243 	status = decode_op_hdr(xdr, OP_ACCESS);
4244 	if (status)
4245 		return status;
4246 	p = xdr_inline_decode(xdr, 8);
4247 	if (unlikely(!p))
4248 		goto out_overflow;
4249 	supp = be32_to_cpup(p++);
4250 	acc = be32_to_cpup(p);
4251 	*supported = supp;
4252 	*access = acc;
4253 	return 0;
4254 out_overflow:
4255 	print_overflow_msg(__func__, xdr);
4256 	return -EIO;
4257 }
4258 
4259 static int decode_opaque_fixed(struct xdr_stream *xdr, void *buf, size_t len)
4260 {
4261 	__be32 *p;
4262 
4263 	p = xdr_inline_decode(xdr, len);
4264 	if (likely(p)) {
4265 		memcpy(buf, p, len);
4266 		return 0;
4267 	}
4268 	print_overflow_msg(__func__, xdr);
4269 	return -EIO;
4270 }
4271 
4272 static int decode_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
4273 {
4274 	return decode_opaque_fixed(xdr, stateid, NFS4_STATEID_SIZE);
4275 }
4276 
4277 static int decode_close(struct xdr_stream *xdr, struct nfs_closeres *res)
4278 {
4279 	int status;
4280 
4281 	status = decode_op_hdr(xdr, OP_CLOSE);
4282 	if (status != -EIO)
4283 		nfs_increment_open_seqid(status, res->seqid);
4284 	if (!status)
4285 		status = decode_stateid(xdr, &res->stateid);
4286 	return status;
4287 }
4288 
4289 static int decode_verifier(struct xdr_stream *xdr, void *verifier)
4290 {
4291 	return decode_opaque_fixed(xdr, verifier, NFS4_VERIFIER_SIZE);
4292 }
4293 
4294 static int decode_write_verifier(struct xdr_stream *xdr, struct nfs_write_verifier *verifier)
4295 {
4296 	return decode_opaque_fixed(xdr, verifier->data, NFS4_VERIFIER_SIZE);
4297 }
4298 
4299 static int decode_commit(struct xdr_stream *xdr, struct nfs_commitres *res)
4300 {
4301 	int status;
4302 
4303 	status = decode_op_hdr(xdr, OP_COMMIT);
4304 	if (!status)
4305 		status = decode_write_verifier(xdr, &res->verf->verifier);
4306 	return status;
4307 }
4308 
4309 static int decode_create(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
4310 {
4311 	__be32 *p;
4312 	uint32_t bmlen;
4313 	int status;
4314 
4315 	status = decode_op_hdr(xdr, OP_CREATE);
4316 	if (status)
4317 		return status;
4318 	if ((status = decode_change_info(xdr, cinfo)))
4319 		return status;
4320 	p = xdr_inline_decode(xdr, 4);
4321 	if (unlikely(!p))
4322 		goto out_overflow;
4323 	bmlen = be32_to_cpup(p);
4324 	p = xdr_inline_decode(xdr, bmlen << 2);
4325 	if (likely(p))
4326 		return 0;
4327 out_overflow:
4328 	print_overflow_msg(__func__, xdr);
4329 	return -EIO;
4330 }
4331 
4332 static int decode_server_caps(struct xdr_stream *xdr, struct nfs4_server_caps_res *res)
4333 {
4334 	unsigned int savep;
4335 	uint32_t attrlen, bitmap[3] = {0};
4336 	int status;
4337 
4338 	if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
4339 		goto xdr_error;
4340 	if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
4341 		goto xdr_error;
4342 	if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
4343 		goto xdr_error;
4344 	if ((status = decode_attr_supported(xdr, bitmap, res->attr_bitmask)) != 0)
4345 		goto xdr_error;
4346 	if ((status = decode_attr_fh_expire_type(xdr, bitmap,
4347 						 &res->fh_expire_type)) != 0)
4348 		goto xdr_error;
4349 	if ((status = decode_attr_link_support(xdr, bitmap, &res->has_links)) != 0)
4350 		goto xdr_error;
4351 	if ((status = decode_attr_symlink_support(xdr, bitmap, &res->has_symlinks)) != 0)
4352 		goto xdr_error;
4353 	if ((status = decode_attr_aclsupport(xdr, bitmap, &res->acl_bitmask)) != 0)
4354 		goto xdr_error;
4355 	status = verify_attr_len(xdr, savep, attrlen);
4356 xdr_error:
4357 	dprintk("%s: xdr returned %d!\n", __func__, -status);
4358 	return status;
4359 }
4360 
4361 static int decode_statfs(struct xdr_stream *xdr, struct nfs_fsstat *fsstat)
4362 {
4363 	unsigned int savep;
4364 	uint32_t attrlen, bitmap[3] = {0};
4365 	int status;
4366 
4367 	if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
4368 		goto xdr_error;
4369 	if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
4370 		goto xdr_error;
4371 	if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
4372 		goto xdr_error;
4373 
4374 	if ((status = decode_attr_files_avail(xdr, bitmap, &fsstat->afiles)) != 0)
4375 		goto xdr_error;
4376 	if ((status = decode_attr_files_free(xdr, bitmap, &fsstat->ffiles)) != 0)
4377 		goto xdr_error;
4378 	if ((status = decode_attr_files_total(xdr, bitmap, &fsstat->tfiles)) != 0)
4379 		goto xdr_error;
4380 	if ((status = decode_attr_space_avail(xdr, bitmap, &fsstat->abytes)) != 0)
4381 		goto xdr_error;
4382 	if ((status = decode_attr_space_free(xdr, bitmap, &fsstat->fbytes)) != 0)
4383 		goto xdr_error;
4384 	if ((status = decode_attr_space_total(xdr, bitmap, &fsstat->tbytes)) != 0)
4385 		goto xdr_error;
4386 
4387 	status = verify_attr_len(xdr, savep, attrlen);
4388 xdr_error:
4389 	dprintk("%s: xdr returned %d!\n", __func__, -status);
4390 	return status;
4391 }
4392 
4393 static int decode_pathconf(struct xdr_stream *xdr, struct nfs_pathconf *pathconf)
4394 {
4395 	unsigned int savep;
4396 	uint32_t attrlen, bitmap[3] = {0};
4397 	int status;
4398 
4399 	if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
4400 		goto xdr_error;
4401 	if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
4402 		goto xdr_error;
4403 	if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
4404 		goto xdr_error;
4405 
4406 	if ((status = decode_attr_maxlink(xdr, bitmap, &pathconf->max_link)) != 0)
4407 		goto xdr_error;
4408 	if ((status = decode_attr_maxname(xdr, bitmap, &pathconf->max_namelen)) != 0)
4409 		goto xdr_error;
4410 
4411 	status = verify_attr_len(xdr, savep, attrlen);
4412 xdr_error:
4413 	dprintk("%s: xdr returned %d!\n", __func__, -status);
4414 	return status;
4415 }
4416 
4417 static int decode_threshold_hint(struct xdr_stream *xdr,
4418 				  uint32_t *bitmap,
4419 				  uint64_t *res,
4420 				  uint32_t hint_bit)
4421 {
4422 	__be32 *p;
4423 
4424 	*res = 0;
4425 	if (likely(bitmap[0] & hint_bit)) {
4426 		p = xdr_inline_decode(xdr, 8);
4427 		if (unlikely(!p))
4428 			goto out_overflow;
4429 		xdr_decode_hyper(p, res);
4430 	}
4431 	return 0;
4432 out_overflow:
4433 	print_overflow_msg(__func__, xdr);
4434 	return -EIO;
4435 }
4436 
4437 static int decode_first_threshold_item4(struct xdr_stream *xdr,
4438 					struct nfs4_threshold *res)
4439 {
4440 	__be32 *p;
4441 	unsigned int savep;
4442 	uint32_t bitmap[3] = {0,}, attrlen;
4443 	int status;
4444 
4445 	/* layout type */
4446 	p = xdr_inline_decode(xdr, 4);
4447 	if (unlikely(!p)) {
4448 		print_overflow_msg(__func__, xdr);
4449 		return -EIO;
4450 	}
4451 	res->l_type = be32_to_cpup(p);
4452 
4453 	/* thi_hintset bitmap */
4454 	status = decode_attr_bitmap(xdr, bitmap);
4455 	if (status < 0)
4456 		goto xdr_error;
4457 
4458 	/* thi_hintlist length */
4459 	status = decode_attr_length(xdr, &attrlen, &savep);
4460 	if (status < 0)
4461 		goto xdr_error;
4462 	/* thi_hintlist */
4463 	status = decode_threshold_hint(xdr, bitmap, &res->rd_sz, THRESHOLD_RD);
4464 	if (status < 0)
4465 		goto xdr_error;
4466 	status = decode_threshold_hint(xdr, bitmap, &res->wr_sz, THRESHOLD_WR);
4467 	if (status < 0)
4468 		goto xdr_error;
4469 	status = decode_threshold_hint(xdr, bitmap, &res->rd_io_sz,
4470 				       THRESHOLD_RD_IO);
4471 	if (status < 0)
4472 		goto xdr_error;
4473 	status = decode_threshold_hint(xdr, bitmap, &res->wr_io_sz,
4474 				       THRESHOLD_WR_IO);
4475 	if (status < 0)
4476 		goto xdr_error;
4477 
4478 	status = verify_attr_len(xdr, savep, attrlen);
4479 	res->bm = bitmap[0];
4480 
4481 	dprintk("%s bm=0x%x rd_sz=%llu wr_sz=%llu rd_io=%llu wr_io=%llu\n",
4482 		 __func__, res->bm, res->rd_sz, res->wr_sz, res->rd_io_sz,
4483 		res->wr_io_sz);
4484 xdr_error:
4485 	dprintk("%s ret=%d!\n", __func__, status);
4486 	return status;
4487 }
4488 
4489 /*
4490  * Thresholds on pNFS direct I/O vrs MDS I/O
4491  */
4492 static int decode_attr_mdsthreshold(struct xdr_stream *xdr,
4493 				    uint32_t *bitmap,
4494 				    struct nfs4_threshold *res)
4495 {
4496 	__be32 *p;
4497 	int status = 0;
4498 	uint32_t num;
4499 
4500 	if (unlikely(bitmap[2] & (FATTR4_WORD2_MDSTHRESHOLD - 1U)))
4501 		return -EIO;
4502 	if (bitmap[2] & FATTR4_WORD2_MDSTHRESHOLD) {
4503 		/* Did the server return an unrequested attribute? */
4504 		if (unlikely(res == NULL))
4505 			return -EREMOTEIO;
4506 		p = xdr_inline_decode(xdr, 4);
4507 		if (unlikely(!p))
4508 			goto out_overflow;
4509 		num = be32_to_cpup(p);
4510 		if (num == 0)
4511 			return 0;
4512 		if (num > 1)
4513 			printk(KERN_INFO "%s: Warning: Multiple pNFS layout "
4514 				"drivers per filesystem not supported\n",
4515 				__func__);
4516 
4517 		status = decode_first_threshold_item4(xdr, res);
4518 		bitmap[2] &= ~FATTR4_WORD2_MDSTHRESHOLD;
4519 	}
4520 	return status;
4521 out_overflow:
4522 	print_overflow_msg(__func__, xdr);
4523 	return -EIO;
4524 }
4525 
4526 static int decode_getfattr_attrs(struct xdr_stream *xdr, uint32_t *bitmap,
4527 		struct nfs_fattr *fattr, struct nfs_fh *fh,
4528 		struct nfs4_fs_locations *fs_loc, struct nfs4_label *label,
4529 		const struct nfs_server *server)
4530 {
4531 	int status;
4532 	umode_t fmode = 0;
4533 	uint32_t type;
4534 	int32_t err;
4535 
4536 	status = decode_attr_type(xdr, bitmap, &type);
4537 	if (status < 0)
4538 		goto xdr_error;
4539 	fattr->mode = 0;
4540 	if (status != 0) {
4541 		fattr->mode |= nfs_type2fmt[type];
4542 		fattr->valid |= status;
4543 	}
4544 
4545 	status = decode_attr_change(xdr, bitmap, &fattr->change_attr);
4546 	if (status < 0)
4547 		goto xdr_error;
4548 	fattr->valid |= status;
4549 
4550 	status = decode_attr_size(xdr, bitmap, &fattr->size);
4551 	if (status < 0)
4552 		goto xdr_error;
4553 	fattr->valid |= status;
4554 
4555 	status = decode_attr_fsid(xdr, bitmap, &fattr->fsid);
4556 	if (status < 0)
4557 		goto xdr_error;
4558 	fattr->valid |= status;
4559 
4560 	err = 0;
4561 	status = decode_attr_error(xdr, bitmap, &err);
4562 	if (status < 0)
4563 		goto xdr_error;
4564 
4565 	status = decode_attr_filehandle(xdr, bitmap, fh);
4566 	if (status < 0)
4567 		goto xdr_error;
4568 
4569 	status = decode_attr_fileid(xdr, bitmap, &fattr->fileid);
4570 	if (status < 0)
4571 		goto xdr_error;
4572 	fattr->valid |= status;
4573 
4574 	status = decode_attr_fs_locations(xdr, bitmap, fs_loc);
4575 	if (status < 0)
4576 		goto xdr_error;
4577 	fattr->valid |= status;
4578 
4579 	status = decode_attr_mode(xdr, bitmap, &fmode);
4580 	if (status < 0)
4581 		goto xdr_error;
4582 	if (status != 0) {
4583 		fattr->mode |= fmode;
4584 		fattr->valid |= status;
4585 	}
4586 
4587 	status = decode_attr_nlink(xdr, bitmap, &fattr->nlink);
4588 	if (status < 0)
4589 		goto xdr_error;
4590 	fattr->valid |= status;
4591 
4592 	status = decode_attr_owner(xdr, bitmap, server, &fattr->uid, fattr->owner_name);
4593 	if (status < 0)
4594 		goto xdr_error;
4595 	fattr->valid |= status;
4596 
4597 	status = decode_attr_group(xdr, bitmap, server, &fattr->gid, fattr->group_name);
4598 	if (status < 0)
4599 		goto xdr_error;
4600 	fattr->valid |= status;
4601 
4602 	status = decode_attr_rdev(xdr, bitmap, &fattr->rdev);
4603 	if (status < 0)
4604 		goto xdr_error;
4605 	fattr->valid |= status;
4606 
4607 	status = decode_attr_space_used(xdr, bitmap, &fattr->du.nfs3.used);
4608 	if (status < 0)
4609 		goto xdr_error;
4610 	fattr->valid |= status;
4611 
4612 	status = decode_attr_time_access(xdr, bitmap, &fattr->atime);
4613 	if (status < 0)
4614 		goto xdr_error;
4615 	fattr->valid |= status;
4616 
4617 	status = decode_attr_time_metadata(xdr, bitmap, &fattr->ctime);
4618 	if (status < 0)
4619 		goto xdr_error;
4620 	fattr->valid |= status;
4621 
4622 	status = decode_attr_time_modify(xdr, bitmap, &fattr->mtime);
4623 	if (status < 0)
4624 		goto xdr_error;
4625 	fattr->valid |= status;
4626 
4627 	status = decode_attr_mounted_on_fileid(xdr, bitmap, &fattr->mounted_on_fileid);
4628 	if (status < 0)
4629 		goto xdr_error;
4630 	fattr->valid |= status;
4631 
4632 	status = decode_attr_mdsthreshold(xdr, bitmap, fattr->mdsthreshold);
4633 	if (status < 0)
4634 		goto xdr_error;
4635 
4636 	if (label) {
4637 		status = decode_attr_security_label(xdr, bitmap, label);
4638 		if (status < 0)
4639 			goto xdr_error;
4640 		fattr->valid |= status;
4641 	}
4642 
4643 xdr_error:
4644 	dprintk("%s: xdr returned %d\n", __func__, -status);
4645 	return status;
4646 }
4647 
4648 static int decode_getfattr_generic(struct xdr_stream *xdr, struct nfs_fattr *fattr,
4649 		struct nfs_fh *fh, struct nfs4_fs_locations *fs_loc,
4650 		struct nfs4_label *label, const struct nfs_server *server)
4651 {
4652 	unsigned int savep;
4653 	uint32_t attrlen,
4654 		 bitmap[3] = {0};
4655 	int status;
4656 
4657 	status = decode_op_hdr(xdr, OP_GETATTR);
4658 	if (status < 0)
4659 		goto xdr_error;
4660 
4661 	status = decode_attr_bitmap(xdr, bitmap);
4662 	if (status < 0)
4663 		goto xdr_error;
4664 
4665 	status = decode_attr_length(xdr, &attrlen, &savep);
4666 	if (status < 0)
4667 		goto xdr_error;
4668 
4669 	status = decode_getfattr_attrs(xdr, bitmap, fattr, fh, fs_loc,
4670 					label, server);
4671 	if (status < 0)
4672 		goto xdr_error;
4673 
4674 	status = verify_attr_len(xdr, savep, attrlen);
4675 xdr_error:
4676 	dprintk("%s: xdr returned %d\n", __func__, -status);
4677 	return status;
4678 }
4679 
4680 static int decode_getfattr_label(struct xdr_stream *xdr, struct nfs_fattr *fattr,
4681 		struct nfs4_label *label, const struct nfs_server *server)
4682 {
4683 	return decode_getfattr_generic(xdr, fattr, NULL, NULL, label, server);
4684 }
4685 
4686 static int decode_getfattr(struct xdr_stream *xdr, struct nfs_fattr *fattr,
4687 		const struct nfs_server *server)
4688 {
4689 	return decode_getfattr_generic(xdr, fattr, NULL, NULL, NULL, server);
4690 }
4691 
4692 /*
4693  * Decode potentially multiple layout types. Currently we only support
4694  * one layout driver per file system.
4695  */
4696 static int decode_first_pnfs_layout_type(struct xdr_stream *xdr,
4697 					 uint32_t *layouttype)
4698 {
4699 	__be32 *p;
4700 	int num;
4701 
4702 	p = xdr_inline_decode(xdr, 4);
4703 	if (unlikely(!p))
4704 		goto out_overflow;
4705 	num = be32_to_cpup(p);
4706 
4707 	/* pNFS is not supported by the underlying file system */
4708 	if (num == 0) {
4709 		*layouttype = 0;
4710 		return 0;
4711 	}
4712 	if (num > 1)
4713 		printk(KERN_INFO "NFS: %s: Warning: Multiple pNFS layout "
4714 			"drivers per filesystem not supported\n", __func__);
4715 
4716 	/* Decode and set first layout type, move xdr->p past unused types */
4717 	p = xdr_inline_decode(xdr, num * 4);
4718 	if (unlikely(!p))
4719 		goto out_overflow;
4720 	*layouttype = be32_to_cpup(p);
4721 	return 0;
4722 out_overflow:
4723 	print_overflow_msg(__func__, xdr);
4724 	return -EIO;
4725 }
4726 
4727 /*
4728  * The type of file system exported.
4729  * Note we must ensure that layouttype is set in any non-error case.
4730  */
4731 static int decode_attr_pnfstype(struct xdr_stream *xdr, uint32_t *bitmap,
4732 				uint32_t *layouttype)
4733 {
4734 	int status = 0;
4735 
4736 	dprintk("%s: bitmap is %x\n", __func__, bitmap[1]);
4737 	if (unlikely(bitmap[1] & (FATTR4_WORD1_FS_LAYOUT_TYPES - 1U)))
4738 		return -EIO;
4739 	if (bitmap[1] & FATTR4_WORD1_FS_LAYOUT_TYPES) {
4740 		status = decode_first_pnfs_layout_type(xdr, layouttype);
4741 		bitmap[1] &= ~FATTR4_WORD1_FS_LAYOUT_TYPES;
4742 	} else
4743 		*layouttype = 0;
4744 	return status;
4745 }
4746 
4747 /*
4748  * The prefered block size for layout directed io
4749  */
4750 static int decode_attr_layout_blksize(struct xdr_stream *xdr, uint32_t *bitmap,
4751 				      uint32_t *res)
4752 {
4753 	__be32 *p;
4754 
4755 	dprintk("%s: bitmap is %x\n", __func__, bitmap[2]);
4756 	*res = 0;
4757 	if (bitmap[2] & FATTR4_WORD2_LAYOUT_BLKSIZE) {
4758 		p = xdr_inline_decode(xdr, 4);
4759 		if (unlikely(!p)) {
4760 			print_overflow_msg(__func__, xdr);
4761 			return -EIO;
4762 		}
4763 		*res = be32_to_cpup(p);
4764 		bitmap[2] &= ~FATTR4_WORD2_LAYOUT_BLKSIZE;
4765 	}
4766 	return 0;
4767 }
4768 
4769 static int decode_fsinfo(struct xdr_stream *xdr, struct nfs_fsinfo *fsinfo)
4770 {
4771 	unsigned int savep;
4772 	uint32_t attrlen, bitmap[3];
4773 	int status;
4774 
4775 	if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
4776 		goto xdr_error;
4777 	if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
4778 		goto xdr_error;
4779 	if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
4780 		goto xdr_error;
4781 
4782 	fsinfo->rtmult = fsinfo->wtmult = 512;	/* ??? */
4783 
4784 	if ((status = decode_attr_lease_time(xdr, bitmap, &fsinfo->lease_time)) != 0)
4785 		goto xdr_error;
4786 	if ((status = decode_attr_maxfilesize(xdr, bitmap, &fsinfo->maxfilesize)) != 0)
4787 		goto xdr_error;
4788 	if ((status = decode_attr_maxread(xdr, bitmap, &fsinfo->rtmax)) != 0)
4789 		goto xdr_error;
4790 	fsinfo->rtpref = fsinfo->dtpref = fsinfo->rtmax;
4791 	if ((status = decode_attr_maxwrite(xdr, bitmap, &fsinfo->wtmax)) != 0)
4792 		goto xdr_error;
4793 	fsinfo->wtpref = fsinfo->wtmax;
4794 	status = decode_attr_time_delta(xdr, bitmap, &fsinfo->time_delta);
4795 	if (status != 0)
4796 		goto xdr_error;
4797 	status = decode_attr_pnfstype(xdr, bitmap, &fsinfo->layouttype);
4798 	if (status != 0)
4799 		goto xdr_error;
4800 	status = decode_attr_layout_blksize(xdr, bitmap, &fsinfo->blksize);
4801 	if (status)
4802 		goto xdr_error;
4803 
4804 	status = verify_attr_len(xdr, savep, attrlen);
4805 xdr_error:
4806 	dprintk("%s: xdr returned %d!\n", __func__, -status);
4807 	return status;
4808 }
4809 
4810 static int decode_getfh(struct xdr_stream *xdr, struct nfs_fh *fh)
4811 {
4812 	__be32 *p;
4813 	uint32_t len;
4814 	int status;
4815 
4816 	/* Zero handle first to allow comparisons */
4817 	memset(fh, 0, sizeof(*fh));
4818 
4819 	status = decode_op_hdr(xdr, OP_GETFH);
4820 	if (status)
4821 		return status;
4822 
4823 	p = xdr_inline_decode(xdr, 4);
4824 	if (unlikely(!p))
4825 		goto out_overflow;
4826 	len = be32_to_cpup(p);
4827 	if (len > NFS4_FHSIZE)
4828 		return -EIO;
4829 	fh->size = len;
4830 	p = xdr_inline_decode(xdr, len);
4831 	if (unlikely(!p))
4832 		goto out_overflow;
4833 	memcpy(fh->data, p, len);
4834 	return 0;
4835 out_overflow:
4836 	print_overflow_msg(__func__, xdr);
4837 	return -EIO;
4838 }
4839 
4840 static int decode_link(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
4841 {
4842 	int status;
4843 
4844 	status = decode_op_hdr(xdr, OP_LINK);
4845 	if (status)
4846 		return status;
4847 	return decode_change_info(xdr, cinfo);
4848 }
4849 
4850 /*
4851  * We create the owner, so we know a proper owner.id length is 4.
4852  */
4853 static int decode_lock_denied (struct xdr_stream *xdr, struct file_lock *fl)
4854 {
4855 	uint64_t offset, length, clientid;
4856 	__be32 *p;
4857 	uint32_t namelen, type;
4858 
4859 	p = xdr_inline_decode(xdr, 32); /* read 32 bytes */
4860 	if (unlikely(!p))
4861 		goto out_overflow;
4862 	p = xdr_decode_hyper(p, &offset); /* read 2 8-byte long words */
4863 	p = xdr_decode_hyper(p, &length);
4864 	type = be32_to_cpup(p++); /* 4 byte read */
4865 	if (fl != NULL) { /* manipulate file lock */
4866 		fl->fl_start = (loff_t)offset;
4867 		fl->fl_end = fl->fl_start + (loff_t)length - 1;
4868 		if (length == ~(uint64_t)0)
4869 			fl->fl_end = OFFSET_MAX;
4870 		fl->fl_type = F_WRLCK;
4871 		if (type & 1)
4872 			fl->fl_type = F_RDLCK;
4873 		fl->fl_pid = 0;
4874 	}
4875 	p = xdr_decode_hyper(p, &clientid); /* read 8 bytes */
4876 	namelen = be32_to_cpup(p); /* read 4 bytes */  /* have read all 32 bytes now */
4877 	p = xdr_inline_decode(xdr, namelen); /* variable size field */
4878 	if (likely(p))
4879 		return -NFS4ERR_DENIED;
4880 out_overflow:
4881 	print_overflow_msg(__func__, xdr);
4882 	return -EIO;
4883 }
4884 
4885 static int decode_lock(struct xdr_stream *xdr, struct nfs_lock_res *res)
4886 {
4887 	int status;
4888 
4889 	status = decode_op_hdr(xdr, OP_LOCK);
4890 	if (status == -EIO)
4891 		goto out;
4892 	if (status == 0) {
4893 		status = decode_stateid(xdr, &res->stateid);
4894 		if (unlikely(status))
4895 			goto out;
4896 	} else if (status == -NFS4ERR_DENIED)
4897 		status = decode_lock_denied(xdr, NULL);
4898 	if (res->open_seqid != NULL)
4899 		nfs_increment_open_seqid(status, res->open_seqid);
4900 	nfs_increment_lock_seqid(status, res->lock_seqid);
4901 out:
4902 	return status;
4903 }
4904 
4905 static int decode_lockt(struct xdr_stream *xdr, struct nfs_lockt_res *res)
4906 {
4907 	int status;
4908 	status = decode_op_hdr(xdr, OP_LOCKT);
4909 	if (status == -NFS4ERR_DENIED)
4910 		return decode_lock_denied(xdr, res->denied);
4911 	return status;
4912 }
4913 
4914 static int decode_locku(struct xdr_stream *xdr, struct nfs_locku_res *res)
4915 {
4916 	int status;
4917 
4918 	status = decode_op_hdr(xdr, OP_LOCKU);
4919 	if (status != -EIO)
4920 		nfs_increment_lock_seqid(status, res->seqid);
4921 	if (status == 0)
4922 		status = decode_stateid(xdr, &res->stateid);
4923 	return status;
4924 }
4925 
4926 static int decode_release_lockowner(struct xdr_stream *xdr)
4927 {
4928 	return decode_op_hdr(xdr, OP_RELEASE_LOCKOWNER);
4929 }
4930 
4931 static int decode_lookup(struct xdr_stream *xdr)
4932 {
4933 	return decode_op_hdr(xdr, OP_LOOKUP);
4934 }
4935 
4936 /* This is too sick! */
4937 static int decode_space_limit(struct xdr_stream *xdr, u64 *maxsize)
4938 {
4939 	__be32 *p;
4940 	uint32_t limit_type, nblocks, blocksize;
4941 
4942 	p = xdr_inline_decode(xdr, 12);
4943 	if (unlikely(!p))
4944 		goto out_overflow;
4945 	limit_type = be32_to_cpup(p++);
4946 	switch (limit_type) {
4947 	case 1:
4948 		xdr_decode_hyper(p, maxsize);
4949 		break;
4950 	case 2:
4951 		nblocks = be32_to_cpup(p++);
4952 		blocksize = be32_to_cpup(p);
4953 		*maxsize = (uint64_t)nblocks * (uint64_t)blocksize;
4954 	}
4955 	return 0;
4956 out_overflow:
4957 	print_overflow_msg(__func__, xdr);
4958 	return -EIO;
4959 }
4960 
4961 static int decode_delegation(struct xdr_stream *xdr, struct nfs_openres *res)
4962 {
4963 	__be32 *p;
4964 	uint32_t delegation_type;
4965 	int status;
4966 
4967 	p = xdr_inline_decode(xdr, 4);
4968 	if (unlikely(!p))
4969 		goto out_overflow;
4970 	delegation_type = be32_to_cpup(p);
4971 	if (delegation_type == NFS4_OPEN_DELEGATE_NONE) {
4972 		res->delegation_type = 0;
4973 		return 0;
4974 	}
4975 	status = decode_stateid(xdr, &res->delegation);
4976 	if (unlikely(status))
4977 		return status;
4978 	p = xdr_inline_decode(xdr, 4);
4979 	if (unlikely(!p))
4980 		goto out_overflow;
4981 	res->do_recall = be32_to_cpup(p);
4982 
4983 	switch (delegation_type) {
4984 	case NFS4_OPEN_DELEGATE_READ:
4985 		res->delegation_type = FMODE_READ;
4986 		break;
4987 	case NFS4_OPEN_DELEGATE_WRITE:
4988 		res->delegation_type = FMODE_WRITE|FMODE_READ;
4989 		if (decode_space_limit(xdr, &res->maxsize) < 0)
4990 				return -EIO;
4991 	}
4992 	return decode_ace(xdr, NULL, res->server->nfs_client);
4993 out_overflow:
4994 	print_overflow_msg(__func__, xdr);
4995 	return -EIO;
4996 }
4997 
4998 static int decode_open(struct xdr_stream *xdr, struct nfs_openres *res)
4999 {
5000 	__be32 *p;
5001 	uint32_t savewords, bmlen, i;
5002 	int status;
5003 
5004 	status = decode_op_hdr(xdr, OP_OPEN);
5005 	if (status != -EIO)
5006 		nfs_increment_open_seqid(status, res->seqid);
5007 	if (!status)
5008 		status = decode_stateid(xdr, &res->stateid);
5009 	if (unlikely(status))
5010 		return status;
5011 
5012 	decode_change_info(xdr, &res->cinfo);
5013 
5014 	p = xdr_inline_decode(xdr, 8);
5015 	if (unlikely(!p))
5016 		goto out_overflow;
5017 	res->rflags = be32_to_cpup(p++);
5018 	bmlen = be32_to_cpup(p);
5019 	if (bmlen > 10)
5020 		goto xdr_error;
5021 
5022 	p = xdr_inline_decode(xdr, bmlen << 2);
5023 	if (unlikely(!p))
5024 		goto out_overflow;
5025 	savewords = min_t(uint32_t, bmlen, NFS4_BITMAP_SIZE);
5026 	for (i = 0; i < savewords; ++i)
5027 		res->attrset[i] = be32_to_cpup(p++);
5028 	for (; i < NFS4_BITMAP_SIZE; i++)
5029 		res->attrset[i] = 0;
5030 
5031 	return decode_delegation(xdr, res);
5032 xdr_error:
5033 	dprintk("%s: Bitmap too large! Length = %u\n", __func__, bmlen);
5034 	return -EIO;
5035 out_overflow:
5036 	print_overflow_msg(__func__, xdr);
5037 	return -EIO;
5038 }
5039 
5040 static int decode_open_confirm(struct xdr_stream *xdr, struct nfs_open_confirmres *res)
5041 {
5042 	int status;
5043 
5044 	status = decode_op_hdr(xdr, OP_OPEN_CONFIRM);
5045 	if (status != -EIO)
5046 		nfs_increment_open_seqid(status, res->seqid);
5047 	if (!status)
5048 		status = decode_stateid(xdr, &res->stateid);
5049 	return status;
5050 }
5051 
5052 static int decode_open_downgrade(struct xdr_stream *xdr, struct nfs_closeres *res)
5053 {
5054 	int status;
5055 
5056 	status = decode_op_hdr(xdr, OP_OPEN_DOWNGRADE);
5057 	if (status != -EIO)
5058 		nfs_increment_open_seqid(status, res->seqid);
5059 	if (!status)
5060 		status = decode_stateid(xdr, &res->stateid);
5061 	return status;
5062 }
5063 
5064 static int decode_putfh(struct xdr_stream *xdr)
5065 {
5066 	return decode_op_hdr(xdr, OP_PUTFH);
5067 }
5068 
5069 static int decode_putrootfh(struct xdr_stream *xdr)
5070 {
5071 	return decode_op_hdr(xdr, OP_PUTROOTFH);
5072 }
5073 
5074 static int decode_read(struct xdr_stream *xdr, struct rpc_rqst *req, struct nfs_readres *res)
5075 {
5076 	__be32 *p;
5077 	uint32_t count, eof, recvd;
5078 	int status;
5079 
5080 	status = decode_op_hdr(xdr, OP_READ);
5081 	if (status)
5082 		return status;
5083 	p = xdr_inline_decode(xdr, 8);
5084 	if (unlikely(!p))
5085 		goto out_overflow;
5086 	eof = be32_to_cpup(p++);
5087 	count = be32_to_cpup(p);
5088 	recvd = xdr_read_pages(xdr, count);
5089 	if (count > recvd) {
5090 		dprintk("NFS: server cheating in read reply: "
5091 				"count %u > recvd %u\n", count, recvd);
5092 		count = recvd;
5093 		eof = 0;
5094 	}
5095 	res->eof = eof;
5096 	res->count = count;
5097 	return 0;
5098 out_overflow:
5099 	print_overflow_msg(__func__, xdr);
5100 	return -EIO;
5101 }
5102 
5103 static int decode_readdir(struct xdr_stream *xdr, struct rpc_rqst *req, struct nfs4_readdir_res *readdir)
5104 {
5105 	int		status;
5106 	__be32		verf[2];
5107 
5108 	status = decode_op_hdr(xdr, OP_READDIR);
5109 	if (!status)
5110 		status = decode_verifier(xdr, readdir->verifier.data);
5111 	if (unlikely(status))
5112 		return status;
5113 	memcpy(verf, readdir->verifier.data, sizeof(verf));
5114 	dprintk("%s: verifier = %08x:%08x\n",
5115 			__func__, verf[0], verf[1]);
5116 	return xdr_read_pages(xdr, xdr->buf->page_len);
5117 }
5118 
5119 static int decode_readlink(struct xdr_stream *xdr, struct rpc_rqst *req)
5120 {
5121 	struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
5122 	u32 len, recvd;
5123 	__be32 *p;
5124 	int status;
5125 
5126 	status = decode_op_hdr(xdr, OP_READLINK);
5127 	if (status)
5128 		return status;
5129 
5130 	/* Convert length of symlink */
5131 	p = xdr_inline_decode(xdr, 4);
5132 	if (unlikely(!p))
5133 		goto out_overflow;
5134 	len = be32_to_cpup(p);
5135 	if (len >= rcvbuf->page_len || len <= 0) {
5136 		dprintk("nfs: server returned giant symlink!\n");
5137 		return -ENAMETOOLONG;
5138 	}
5139 	recvd = xdr_read_pages(xdr, len);
5140 	if (recvd < len) {
5141 		dprintk("NFS: server cheating in readlink reply: "
5142 				"count %u > recvd %u\n", len, recvd);
5143 		return -EIO;
5144 	}
5145 	/*
5146 	 * The XDR encode routine has set things up so that
5147 	 * the link text will be copied directly into the
5148 	 * buffer.  We just have to do overflow-checking,
5149 	 * and and null-terminate the text (the VFS expects
5150 	 * null-termination).
5151 	 */
5152 	xdr_terminate_string(rcvbuf, len);
5153 	return 0;
5154 out_overflow:
5155 	print_overflow_msg(__func__, xdr);
5156 	return -EIO;
5157 }
5158 
5159 static int decode_remove(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
5160 {
5161 	int status;
5162 
5163 	status = decode_op_hdr(xdr, OP_REMOVE);
5164 	if (status)
5165 		goto out;
5166 	status = decode_change_info(xdr, cinfo);
5167 out:
5168 	return status;
5169 }
5170 
5171 static int decode_rename(struct xdr_stream *xdr, struct nfs4_change_info *old_cinfo,
5172 	      struct nfs4_change_info *new_cinfo)
5173 {
5174 	int status;
5175 
5176 	status = decode_op_hdr(xdr, OP_RENAME);
5177 	if (status)
5178 		goto out;
5179 	if ((status = decode_change_info(xdr, old_cinfo)))
5180 		goto out;
5181 	status = decode_change_info(xdr, new_cinfo);
5182 out:
5183 	return status;
5184 }
5185 
5186 static int decode_renew(struct xdr_stream *xdr)
5187 {
5188 	return decode_op_hdr(xdr, OP_RENEW);
5189 }
5190 
5191 static int
5192 decode_restorefh(struct xdr_stream *xdr)
5193 {
5194 	return decode_op_hdr(xdr, OP_RESTOREFH);
5195 }
5196 
5197 static int decode_getacl(struct xdr_stream *xdr, struct rpc_rqst *req,
5198 			 struct nfs_getaclres *res)
5199 {
5200 	unsigned int savep;
5201 	uint32_t attrlen,
5202 		 bitmap[3] = {0};
5203 	int status;
5204 	unsigned int pg_offset;
5205 
5206 	res->acl_len = 0;
5207 	if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
5208 		goto out;
5209 
5210 	xdr_enter_page(xdr, xdr->buf->page_len);
5211 
5212 	/* Calculate the offset of the page data */
5213 	pg_offset = xdr->buf->head[0].iov_len;
5214 
5215 	if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
5216 		goto out;
5217 	if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
5218 		goto out;
5219 
5220 	if (unlikely(bitmap[0] & (FATTR4_WORD0_ACL - 1U)))
5221 		return -EIO;
5222 	if (likely(bitmap[0] & FATTR4_WORD0_ACL)) {
5223 
5224 		/* The bitmap (xdr len + bitmaps) and the attr xdr len words
5225 		 * are stored with the acl data to handle the problem of
5226 		 * variable length bitmaps.*/
5227 		res->acl_data_offset = xdr_stream_pos(xdr) - pg_offset;
5228 		res->acl_len = attrlen;
5229 
5230 		/* Check for receive buffer overflow */
5231 		if (res->acl_len > (xdr->nwords << 2) ||
5232 		    res->acl_len + res->acl_data_offset > xdr->buf->page_len) {
5233 			res->acl_flags |= NFS4_ACL_TRUNC;
5234 			dprintk("NFS: acl reply: attrlen %u > page_len %u\n",
5235 					attrlen, xdr->nwords << 2);
5236 		}
5237 	} else
5238 		status = -EOPNOTSUPP;
5239 
5240 out:
5241 	return status;
5242 }
5243 
5244 static int
5245 decode_savefh(struct xdr_stream *xdr)
5246 {
5247 	return decode_op_hdr(xdr, OP_SAVEFH);
5248 }
5249 
5250 static int decode_setattr(struct xdr_stream *xdr)
5251 {
5252 	__be32 *p;
5253 	uint32_t bmlen;
5254 	int status;
5255 
5256 	status = decode_op_hdr(xdr, OP_SETATTR);
5257 	if (status)
5258 		return status;
5259 	p = xdr_inline_decode(xdr, 4);
5260 	if (unlikely(!p))
5261 		goto out_overflow;
5262 	bmlen = be32_to_cpup(p);
5263 	p = xdr_inline_decode(xdr, bmlen << 2);
5264 	if (likely(p))
5265 		return 0;
5266 out_overflow:
5267 	print_overflow_msg(__func__, xdr);
5268 	return -EIO;
5269 }
5270 
5271 static int decode_setclientid(struct xdr_stream *xdr, struct nfs4_setclientid_res *res)
5272 {
5273 	__be32 *p;
5274 	uint32_t opnum;
5275 	int32_t nfserr;
5276 
5277 	p = xdr_inline_decode(xdr, 8);
5278 	if (unlikely(!p))
5279 		goto out_overflow;
5280 	opnum = be32_to_cpup(p++);
5281 	if (opnum != OP_SETCLIENTID) {
5282 		dprintk("nfs: decode_setclientid: Server returned operation"
5283 			" %d\n", opnum);
5284 		return -EIO;
5285 	}
5286 	nfserr = be32_to_cpup(p);
5287 	if (nfserr == NFS_OK) {
5288 		p = xdr_inline_decode(xdr, 8 + NFS4_VERIFIER_SIZE);
5289 		if (unlikely(!p))
5290 			goto out_overflow;
5291 		p = xdr_decode_hyper(p, &res->clientid);
5292 		memcpy(res->confirm.data, p, NFS4_VERIFIER_SIZE);
5293 	} else if (nfserr == NFSERR_CLID_INUSE) {
5294 		uint32_t len;
5295 
5296 		/* skip netid string */
5297 		p = xdr_inline_decode(xdr, 4);
5298 		if (unlikely(!p))
5299 			goto out_overflow;
5300 		len = be32_to_cpup(p);
5301 		p = xdr_inline_decode(xdr, len);
5302 		if (unlikely(!p))
5303 			goto out_overflow;
5304 
5305 		/* skip uaddr string */
5306 		p = xdr_inline_decode(xdr, 4);
5307 		if (unlikely(!p))
5308 			goto out_overflow;
5309 		len = be32_to_cpup(p);
5310 		p = xdr_inline_decode(xdr, len);
5311 		if (unlikely(!p))
5312 			goto out_overflow;
5313 		return -NFSERR_CLID_INUSE;
5314 	} else
5315 		return nfs4_stat_to_errno(nfserr);
5316 
5317 	return 0;
5318 out_overflow:
5319 	print_overflow_msg(__func__, xdr);
5320 	return -EIO;
5321 }
5322 
5323 static int decode_setclientid_confirm(struct xdr_stream *xdr)
5324 {
5325 	return decode_op_hdr(xdr, OP_SETCLIENTID_CONFIRM);
5326 }
5327 
5328 static int decode_write(struct xdr_stream *xdr, struct nfs_writeres *res)
5329 {
5330 	__be32 *p;
5331 	int status;
5332 
5333 	status = decode_op_hdr(xdr, OP_WRITE);
5334 	if (status)
5335 		return status;
5336 
5337 	p = xdr_inline_decode(xdr, 8);
5338 	if (unlikely(!p))
5339 		goto out_overflow;
5340 	res->count = be32_to_cpup(p++);
5341 	res->verf->committed = be32_to_cpup(p++);
5342 	return decode_write_verifier(xdr, &res->verf->verifier);
5343 out_overflow:
5344 	print_overflow_msg(__func__, xdr);
5345 	return -EIO;
5346 }
5347 
5348 static int decode_delegreturn(struct xdr_stream *xdr)
5349 {
5350 	return decode_op_hdr(xdr, OP_DELEGRETURN);
5351 }
5352 
5353 static int decode_secinfo_gss(struct xdr_stream *xdr,
5354 			      struct nfs4_secinfo4 *flavor)
5355 {
5356 	u32 oid_len;
5357 	__be32 *p;
5358 
5359 	p = xdr_inline_decode(xdr, 4);
5360 	if (unlikely(!p))
5361 		goto out_overflow;
5362 	oid_len = be32_to_cpup(p);
5363 	if (oid_len > GSS_OID_MAX_LEN)
5364 		goto out_err;
5365 
5366 	p = xdr_inline_decode(xdr, oid_len);
5367 	if (unlikely(!p))
5368 		goto out_overflow;
5369 	memcpy(flavor->flavor_info.oid.data, p, oid_len);
5370 	flavor->flavor_info.oid.len = oid_len;
5371 
5372 	p = xdr_inline_decode(xdr, 8);
5373 	if (unlikely(!p))
5374 		goto out_overflow;
5375 	flavor->flavor_info.qop = be32_to_cpup(p++);
5376 	flavor->flavor_info.service = be32_to_cpup(p);
5377 
5378 	return 0;
5379 
5380 out_overflow:
5381 	print_overflow_msg(__func__, xdr);
5382 	return -EIO;
5383 out_err:
5384 	return -EINVAL;
5385 }
5386 
5387 static int decode_secinfo_common(struct xdr_stream *xdr, struct nfs4_secinfo_res *res)
5388 {
5389 	struct nfs4_secinfo4 *sec_flavor;
5390 	unsigned int i, num_flavors;
5391 	int status;
5392 	__be32 *p;
5393 
5394 	p = xdr_inline_decode(xdr, 4);
5395 	if (unlikely(!p))
5396 		goto out_overflow;
5397 
5398 	res->flavors->num_flavors = 0;
5399 	num_flavors = be32_to_cpup(p);
5400 
5401 	for (i = 0; i < num_flavors; i++) {
5402 		sec_flavor = &res->flavors->flavors[i];
5403 		if ((char *)&sec_flavor[1] - (char *)res->flavors > PAGE_SIZE)
5404 			break;
5405 
5406 		p = xdr_inline_decode(xdr, 4);
5407 		if (unlikely(!p))
5408 			goto out_overflow;
5409 		sec_flavor->flavor = be32_to_cpup(p);
5410 
5411 		if (sec_flavor->flavor == RPC_AUTH_GSS) {
5412 			status = decode_secinfo_gss(xdr, sec_flavor);
5413 			if (status)
5414 				goto out;
5415 		}
5416 		res->flavors->num_flavors++;
5417 	}
5418 
5419 	status = 0;
5420 out:
5421 	return status;
5422 out_overflow:
5423 	print_overflow_msg(__func__, xdr);
5424 	return -EIO;
5425 }
5426 
5427 static int decode_secinfo(struct xdr_stream *xdr, struct nfs4_secinfo_res *res)
5428 {
5429 	int status = decode_op_hdr(xdr, OP_SECINFO);
5430 	if (status)
5431 		return status;
5432 	return decode_secinfo_common(xdr, res);
5433 }
5434 
5435 #if defined(CONFIG_NFS_V4_1)
5436 static int decode_secinfo_no_name(struct xdr_stream *xdr, struct nfs4_secinfo_res *res)
5437 {
5438 	int status = decode_op_hdr(xdr, OP_SECINFO_NO_NAME);
5439 	if (status)
5440 		return status;
5441 	return decode_secinfo_common(xdr, res);
5442 }
5443 
5444 static int decode_op_map(struct xdr_stream *xdr, struct nfs4_op_map *op_map)
5445 {
5446 	__be32 *p;
5447 	uint32_t bitmap_words;
5448 	unsigned int i;
5449 
5450 	p = xdr_inline_decode(xdr, 4);
5451 	bitmap_words = be32_to_cpup(p++);
5452 	if (bitmap_words > NFS4_OP_MAP_NUM_WORDS)
5453 		return -EIO;
5454 	p = xdr_inline_decode(xdr, 4 * bitmap_words);
5455 	for (i = 0; i < bitmap_words; i++)
5456 		op_map->u.words[i] = be32_to_cpup(p++);
5457 
5458 	return 0;
5459 }
5460 
5461 static int decode_exchange_id(struct xdr_stream *xdr,
5462 			      struct nfs41_exchange_id_res *res)
5463 {
5464 	__be32 *p;
5465 	uint32_t dummy;
5466 	char *dummy_str;
5467 	int status;
5468 	uint32_t impl_id_count;
5469 
5470 	status = decode_op_hdr(xdr, OP_EXCHANGE_ID);
5471 	if (status)
5472 		return status;
5473 
5474 	p = xdr_inline_decode(xdr, 8);
5475 	if (unlikely(!p))
5476 		goto out_overflow;
5477 	xdr_decode_hyper(p, &res->clientid);
5478 	p = xdr_inline_decode(xdr, 12);
5479 	if (unlikely(!p))
5480 		goto out_overflow;
5481 	res->seqid = be32_to_cpup(p++);
5482 	res->flags = be32_to_cpup(p++);
5483 
5484 	res->state_protect.how = be32_to_cpup(p);
5485 	switch (res->state_protect.how) {
5486 	case SP4_NONE:
5487 		break;
5488 	case SP4_MACH_CRED:
5489 		status = decode_op_map(xdr, &res->state_protect.enforce);
5490 		if (status)
5491 			return status;
5492 		status = decode_op_map(xdr, &res->state_protect.allow);
5493 		if (status)
5494 			return status;
5495 		break;
5496 	default:
5497 		WARN_ON_ONCE(1);
5498 		return -EIO;
5499 	}
5500 
5501 	/* server_owner4.so_minor_id */
5502 	p = xdr_inline_decode(xdr, 8);
5503 	if (unlikely(!p))
5504 		goto out_overflow;
5505 	p = xdr_decode_hyper(p, &res->server_owner->minor_id);
5506 
5507 	/* server_owner4.so_major_id */
5508 	status = decode_opaque_inline(xdr, &dummy, &dummy_str);
5509 	if (unlikely(status))
5510 		return status;
5511 	if (unlikely(dummy > NFS4_OPAQUE_LIMIT))
5512 		return -EIO;
5513 	memcpy(res->server_owner->major_id, dummy_str, dummy);
5514 	res->server_owner->major_id_sz = dummy;
5515 
5516 	/* server_scope4 */
5517 	status = decode_opaque_inline(xdr, &dummy, &dummy_str);
5518 	if (unlikely(status))
5519 		return status;
5520 	if (unlikely(dummy > NFS4_OPAQUE_LIMIT))
5521 		return -EIO;
5522 	memcpy(res->server_scope->server_scope, dummy_str, dummy);
5523 	res->server_scope->server_scope_sz = dummy;
5524 
5525 	/* Implementation Id */
5526 	p = xdr_inline_decode(xdr, 4);
5527 	if (unlikely(!p))
5528 		goto out_overflow;
5529 	impl_id_count = be32_to_cpup(p++);
5530 
5531 	if (impl_id_count) {
5532 		/* nii_domain */
5533 		status = decode_opaque_inline(xdr, &dummy, &dummy_str);
5534 		if (unlikely(status))
5535 			return status;
5536 		if (unlikely(dummy > NFS4_OPAQUE_LIMIT))
5537 			return -EIO;
5538 		memcpy(res->impl_id->domain, dummy_str, dummy);
5539 
5540 		/* nii_name */
5541 		status = decode_opaque_inline(xdr, &dummy, &dummy_str);
5542 		if (unlikely(status))
5543 			return status;
5544 		if (unlikely(dummy > NFS4_OPAQUE_LIMIT))
5545 			return -EIO;
5546 		memcpy(res->impl_id->name, dummy_str, dummy);
5547 
5548 		/* nii_date */
5549 		p = xdr_inline_decode(xdr, 12);
5550 		if (unlikely(!p))
5551 			goto out_overflow;
5552 		p = xdr_decode_hyper(p, &res->impl_id->date.seconds);
5553 		res->impl_id->date.nseconds = be32_to_cpup(p);
5554 
5555 		/* if there's more than one entry, ignore the rest */
5556 	}
5557 	return 0;
5558 out_overflow:
5559 	print_overflow_msg(__func__, xdr);
5560 	return -EIO;
5561 }
5562 
5563 static int decode_chan_attrs(struct xdr_stream *xdr,
5564 			     struct nfs4_channel_attrs *attrs)
5565 {
5566 	__be32 *p;
5567 	u32 nr_attrs, val;
5568 
5569 	p = xdr_inline_decode(xdr, 28);
5570 	if (unlikely(!p))
5571 		goto out_overflow;
5572 	val = be32_to_cpup(p++);	/* headerpadsz */
5573 	if (val)
5574 		return -EINVAL;		/* no support for header padding yet */
5575 	attrs->max_rqst_sz = be32_to_cpup(p++);
5576 	attrs->max_resp_sz = be32_to_cpup(p++);
5577 	attrs->max_resp_sz_cached = be32_to_cpup(p++);
5578 	attrs->max_ops = be32_to_cpup(p++);
5579 	attrs->max_reqs = be32_to_cpup(p++);
5580 	nr_attrs = be32_to_cpup(p);
5581 	if (unlikely(nr_attrs > 1)) {
5582 		printk(KERN_WARNING "NFS: %s: Invalid rdma channel attrs "
5583 			"count %u\n", __func__, nr_attrs);
5584 		return -EINVAL;
5585 	}
5586 	if (nr_attrs == 1) {
5587 		p = xdr_inline_decode(xdr, 4); /* skip rdma_attrs */
5588 		if (unlikely(!p))
5589 			goto out_overflow;
5590 	}
5591 	return 0;
5592 out_overflow:
5593 	print_overflow_msg(__func__, xdr);
5594 	return -EIO;
5595 }
5596 
5597 static int decode_sessionid(struct xdr_stream *xdr, struct nfs4_sessionid *sid)
5598 {
5599 	return decode_opaque_fixed(xdr, sid->data, NFS4_MAX_SESSIONID_LEN);
5600 }
5601 
5602 static int decode_bind_conn_to_session(struct xdr_stream *xdr,
5603 				struct nfs41_bind_conn_to_session_res *res)
5604 {
5605 	__be32 *p;
5606 	int status;
5607 
5608 	status = decode_op_hdr(xdr, OP_BIND_CONN_TO_SESSION);
5609 	if (!status)
5610 		status = decode_sessionid(xdr, &res->session->sess_id);
5611 	if (unlikely(status))
5612 		return status;
5613 
5614 	/* dir flags, rdma mode bool */
5615 	p = xdr_inline_decode(xdr, 8);
5616 	if (unlikely(!p))
5617 		goto out_overflow;
5618 
5619 	res->dir = be32_to_cpup(p++);
5620 	if (res->dir == 0 || res->dir > NFS4_CDFS4_BOTH)
5621 		return -EIO;
5622 	if (be32_to_cpup(p) == 0)
5623 		res->use_conn_in_rdma_mode = false;
5624 	else
5625 		res->use_conn_in_rdma_mode = true;
5626 
5627 	return 0;
5628 out_overflow:
5629 	print_overflow_msg(__func__, xdr);
5630 	return -EIO;
5631 }
5632 
5633 static int decode_create_session(struct xdr_stream *xdr,
5634 				 struct nfs41_create_session_res *res)
5635 {
5636 	__be32 *p;
5637 	int status;
5638 	struct nfs_client *clp = res->client;
5639 	struct nfs4_session *session = clp->cl_session;
5640 
5641 	status = decode_op_hdr(xdr, OP_CREATE_SESSION);
5642 	if (!status)
5643 		status = decode_sessionid(xdr, &session->sess_id);
5644 	if (unlikely(status))
5645 		return status;
5646 
5647 	/* seqid, flags */
5648 	p = xdr_inline_decode(xdr, 8);
5649 	if (unlikely(!p))
5650 		goto out_overflow;
5651 	clp->cl_seqid = be32_to_cpup(p++);
5652 	session->flags = be32_to_cpup(p);
5653 
5654 	/* Channel attributes */
5655 	status = decode_chan_attrs(xdr, &session->fc_attrs);
5656 	if (!status)
5657 		status = decode_chan_attrs(xdr, &session->bc_attrs);
5658 	return status;
5659 out_overflow:
5660 	print_overflow_msg(__func__, xdr);
5661 	return -EIO;
5662 }
5663 
5664 static int decode_destroy_session(struct xdr_stream *xdr, void *dummy)
5665 {
5666 	return decode_op_hdr(xdr, OP_DESTROY_SESSION);
5667 }
5668 
5669 static int decode_destroy_clientid(struct xdr_stream *xdr, void *dummy)
5670 {
5671 	return decode_op_hdr(xdr, OP_DESTROY_CLIENTID);
5672 }
5673 
5674 static int decode_reclaim_complete(struct xdr_stream *xdr, void *dummy)
5675 {
5676 	return decode_op_hdr(xdr, OP_RECLAIM_COMPLETE);
5677 }
5678 #endif /* CONFIG_NFS_V4_1 */
5679 
5680 static int decode_sequence(struct xdr_stream *xdr,
5681 			   struct nfs4_sequence_res *res,
5682 			   struct rpc_rqst *rqstp)
5683 {
5684 #if defined(CONFIG_NFS_V4_1)
5685 	struct nfs4_session *session;
5686 	struct nfs4_sessionid id;
5687 	u32 dummy;
5688 	int status;
5689 	__be32 *p;
5690 
5691 	if (res->sr_slot == NULL)
5692 		return 0;
5693 	if (!res->sr_slot->table->session)
5694 		return 0;
5695 
5696 	status = decode_op_hdr(xdr, OP_SEQUENCE);
5697 	if (!status)
5698 		status = decode_sessionid(xdr, &id);
5699 	if (unlikely(status))
5700 		goto out_err;
5701 
5702 	/*
5703 	 * If the server returns different values for sessionID, slotID or
5704 	 * sequence number, the server is looney tunes.
5705 	 */
5706 	status = -EREMOTEIO;
5707 	session = res->sr_slot->table->session;
5708 
5709 	if (memcmp(id.data, session->sess_id.data,
5710 		   NFS4_MAX_SESSIONID_LEN)) {
5711 		dprintk("%s Invalid session id\n", __func__);
5712 		goto out_err;
5713 	}
5714 
5715 	p = xdr_inline_decode(xdr, 20);
5716 	if (unlikely(!p))
5717 		goto out_overflow;
5718 
5719 	/* seqid */
5720 	dummy = be32_to_cpup(p++);
5721 	if (dummy != res->sr_slot->seq_nr) {
5722 		dprintk("%s Invalid sequence number\n", __func__);
5723 		goto out_err;
5724 	}
5725 	/* slot id */
5726 	dummy = be32_to_cpup(p++);
5727 	if (dummy != res->sr_slot->slot_nr) {
5728 		dprintk("%s Invalid slot id\n", __func__);
5729 		goto out_err;
5730 	}
5731 	/* highest slot id */
5732 	res->sr_highest_slotid = be32_to_cpup(p++);
5733 	/* target highest slot id */
5734 	res->sr_target_highest_slotid = be32_to_cpup(p++);
5735 	/* result flags */
5736 	res->sr_status_flags = be32_to_cpup(p);
5737 	status = 0;
5738 out_err:
5739 	res->sr_status = status;
5740 	return status;
5741 out_overflow:
5742 	print_overflow_msg(__func__, xdr);
5743 	status = -EIO;
5744 	goto out_err;
5745 #else  /* CONFIG_NFS_V4_1 */
5746 	return 0;
5747 #endif /* CONFIG_NFS_V4_1 */
5748 }
5749 
5750 #if defined(CONFIG_NFS_V4_1)
5751 /*
5752  * TODO: Need to handle case when EOF != true;
5753  */
5754 static int decode_getdevicelist(struct xdr_stream *xdr,
5755 				struct pnfs_devicelist *res)
5756 {
5757 	__be32 *p;
5758 	int status, i;
5759 	nfs4_verifier verftemp;
5760 
5761 	status = decode_op_hdr(xdr, OP_GETDEVICELIST);
5762 	if (status)
5763 		return status;
5764 
5765 	p = xdr_inline_decode(xdr, 8 + 8 + 4);
5766 	if (unlikely(!p))
5767 		goto out_overflow;
5768 
5769 	/* TODO: Skip cookie for now */
5770 	p += 2;
5771 
5772 	/* Read verifier */
5773 	p = xdr_decode_opaque_fixed(p, verftemp.data, NFS4_VERIFIER_SIZE);
5774 
5775 	res->num_devs = be32_to_cpup(p);
5776 
5777 	dprintk("%s: num_dev %d\n", __func__, res->num_devs);
5778 
5779 	if (res->num_devs > NFS4_PNFS_GETDEVLIST_MAXNUM) {
5780 		printk(KERN_ERR "NFS: %s too many result dev_num %u\n",
5781 				__func__, res->num_devs);
5782 		return -EIO;
5783 	}
5784 
5785 	p = xdr_inline_decode(xdr,
5786 			      res->num_devs * NFS4_DEVICEID4_SIZE + 4);
5787 	if (unlikely(!p))
5788 		goto out_overflow;
5789 	for (i = 0; i < res->num_devs; i++)
5790 		p = xdr_decode_opaque_fixed(p, res->dev_id[i].data,
5791 					    NFS4_DEVICEID4_SIZE);
5792 	res->eof = be32_to_cpup(p);
5793 	return 0;
5794 out_overflow:
5795 	print_overflow_msg(__func__, xdr);
5796 	return -EIO;
5797 }
5798 
5799 static int decode_getdeviceinfo(struct xdr_stream *xdr,
5800 				struct pnfs_device *pdev)
5801 {
5802 	__be32 *p;
5803 	uint32_t len, type;
5804 	int status;
5805 
5806 	status = decode_op_hdr(xdr, OP_GETDEVICEINFO);
5807 	if (status) {
5808 		if (status == -ETOOSMALL) {
5809 			p = xdr_inline_decode(xdr, 4);
5810 			if (unlikely(!p))
5811 				goto out_overflow;
5812 			pdev->mincount = be32_to_cpup(p);
5813 			dprintk("%s: Min count too small. mincnt = %u\n",
5814 				__func__, pdev->mincount);
5815 		}
5816 		return status;
5817 	}
5818 
5819 	p = xdr_inline_decode(xdr, 8);
5820 	if (unlikely(!p))
5821 		goto out_overflow;
5822 	type = be32_to_cpup(p++);
5823 	if (type != pdev->layout_type) {
5824 		dprintk("%s: layout mismatch req: %u pdev: %u\n",
5825 			__func__, pdev->layout_type, type);
5826 		return -EINVAL;
5827 	}
5828 	/*
5829 	 * Get the length of the opaque device_addr4. xdr_read_pages places
5830 	 * the opaque device_addr4 in the xdr_buf->pages (pnfs_device->pages)
5831 	 * and places the remaining xdr data in xdr_buf->tail
5832 	 */
5833 	pdev->mincount = be32_to_cpup(p);
5834 	if (xdr_read_pages(xdr, pdev->mincount) != pdev->mincount)
5835 		goto out_overflow;
5836 
5837 	/* Parse notification bitmap, verifying that it is zero. */
5838 	p = xdr_inline_decode(xdr, 4);
5839 	if (unlikely(!p))
5840 		goto out_overflow;
5841 	len = be32_to_cpup(p);
5842 	if (len) {
5843 		uint32_t i;
5844 
5845 		p = xdr_inline_decode(xdr, 4 * len);
5846 		if (unlikely(!p))
5847 			goto out_overflow;
5848 		for (i = 0; i < len; i++, p++) {
5849 			if (be32_to_cpup(p)) {
5850 				dprintk("%s: notifications not supported\n",
5851 					__func__);
5852 				return -EIO;
5853 			}
5854 		}
5855 	}
5856 	return 0;
5857 out_overflow:
5858 	print_overflow_msg(__func__, xdr);
5859 	return -EIO;
5860 }
5861 
5862 static int decode_layoutget(struct xdr_stream *xdr, struct rpc_rqst *req,
5863 			    struct nfs4_layoutget_res *res)
5864 {
5865 	__be32 *p;
5866 	int status;
5867 	u32 layout_count;
5868 	u32 recvd;
5869 
5870 	status = decode_op_hdr(xdr, OP_LAYOUTGET);
5871 	if (status)
5872 		return status;
5873 	p = xdr_inline_decode(xdr, 4);
5874 	if (unlikely(!p))
5875 		goto out_overflow;
5876 	res->return_on_close = be32_to_cpup(p);
5877 	decode_stateid(xdr, &res->stateid);
5878 	p = xdr_inline_decode(xdr, 4);
5879 	if (unlikely(!p))
5880 		goto out_overflow;
5881 	layout_count = be32_to_cpup(p);
5882 	if (!layout_count) {
5883 		dprintk("%s: server responded with empty layout array\n",
5884 			__func__);
5885 		return -EINVAL;
5886 	}
5887 
5888 	p = xdr_inline_decode(xdr, 28);
5889 	if (unlikely(!p))
5890 		goto out_overflow;
5891 	p = xdr_decode_hyper(p, &res->range.offset);
5892 	p = xdr_decode_hyper(p, &res->range.length);
5893 	res->range.iomode = be32_to_cpup(p++);
5894 	res->type = be32_to_cpup(p++);
5895 	res->layoutp->len = be32_to_cpup(p);
5896 
5897 	dprintk("%s roff:%lu rlen:%lu riomode:%d, lo_type:0x%x, lo.len:%d\n",
5898 		__func__,
5899 		(unsigned long)res->range.offset,
5900 		(unsigned long)res->range.length,
5901 		res->range.iomode,
5902 		res->type,
5903 		res->layoutp->len);
5904 
5905 	recvd = xdr_read_pages(xdr, res->layoutp->len);
5906 	if (res->layoutp->len > recvd) {
5907 		dprintk("NFS: server cheating in layoutget reply: "
5908 				"layout len %u > recvd %u\n",
5909 				res->layoutp->len, recvd);
5910 		return -EINVAL;
5911 	}
5912 
5913 	if (layout_count > 1) {
5914 		/* We only handle a length one array at the moment.  Any
5915 		 * further entries are just ignored.  Note that this means
5916 		 * the client may see a response that is less than the
5917 		 * minimum it requested.
5918 		 */
5919 		dprintk("%s: server responded with %d layouts, dropping tail\n",
5920 			__func__, layout_count);
5921 	}
5922 
5923 	return 0;
5924 out_overflow:
5925 	print_overflow_msg(__func__, xdr);
5926 	return -EIO;
5927 }
5928 
5929 static int decode_layoutreturn(struct xdr_stream *xdr,
5930 			       struct nfs4_layoutreturn_res *res)
5931 {
5932 	__be32 *p;
5933 	int status;
5934 
5935 	status = decode_op_hdr(xdr, OP_LAYOUTRETURN);
5936 	if (status)
5937 		return status;
5938 	p = xdr_inline_decode(xdr, 4);
5939 	if (unlikely(!p))
5940 		goto out_overflow;
5941 	res->lrs_present = be32_to_cpup(p);
5942 	if (res->lrs_present)
5943 		status = decode_stateid(xdr, &res->stateid);
5944 	return status;
5945 out_overflow:
5946 	print_overflow_msg(__func__, xdr);
5947 	return -EIO;
5948 }
5949 
5950 static int decode_layoutcommit(struct xdr_stream *xdr,
5951 			       struct rpc_rqst *req,
5952 			       struct nfs4_layoutcommit_res *res)
5953 {
5954 	__be32 *p;
5955 	__u32 sizechanged;
5956 	int status;
5957 
5958 	status = decode_op_hdr(xdr, OP_LAYOUTCOMMIT);
5959 	res->status = status;
5960 	if (status)
5961 		return status;
5962 
5963 	p = xdr_inline_decode(xdr, 4);
5964 	if (unlikely(!p))
5965 		goto out_overflow;
5966 	sizechanged = be32_to_cpup(p);
5967 
5968 	if (sizechanged) {
5969 		/* throw away new size */
5970 		p = xdr_inline_decode(xdr, 8);
5971 		if (unlikely(!p))
5972 			goto out_overflow;
5973 	}
5974 	return 0;
5975 out_overflow:
5976 	print_overflow_msg(__func__, xdr);
5977 	return -EIO;
5978 }
5979 
5980 static int decode_test_stateid(struct xdr_stream *xdr,
5981 			       struct nfs41_test_stateid_res *res)
5982 {
5983 	__be32 *p;
5984 	int status;
5985 	int num_res;
5986 
5987 	status = decode_op_hdr(xdr, OP_TEST_STATEID);
5988 	if (status)
5989 		return status;
5990 
5991 	p = xdr_inline_decode(xdr, 4);
5992 	if (unlikely(!p))
5993 		goto out_overflow;
5994 	num_res = be32_to_cpup(p++);
5995 	if (num_res != 1)
5996 		goto out;
5997 
5998 	p = xdr_inline_decode(xdr, 4);
5999 	if (unlikely(!p))
6000 		goto out_overflow;
6001 	res->status = be32_to_cpup(p++);
6002 
6003 	return status;
6004 out_overflow:
6005 	print_overflow_msg(__func__, xdr);
6006 out:
6007 	return -EIO;
6008 }
6009 
6010 static int decode_free_stateid(struct xdr_stream *xdr,
6011 			       struct nfs41_free_stateid_res *res)
6012 {
6013 	res->status = decode_op_hdr(xdr, OP_FREE_STATEID);
6014 	return res->status;
6015 }
6016 #endif /* CONFIG_NFS_V4_1 */
6017 
6018 /*
6019  * END OF "GENERIC" DECODE ROUTINES.
6020  */
6021 
6022 /*
6023  * Decode OPEN_DOWNGRADE response
6024  */
6025 static int nfs4_xdr_dec_open_downgrade(struct rpc_rqst *rqstp,
6026 				       struct xdr_stream *xdr,
6027 				       struct nfs_closeres *res)
6028 {
6029 	struct compound_hdr hdr;
6030 	int status;
6031 
6032 	status = decode_compound_hdr(xdr, &hdr);
6033 	if (status)
6034 		goto out;
6035 	status = decode_sequence(xdr, &res->seq_res, rqstp);
6036 	if (status)
6037 		goto out;
6038 	status = decode_putfh(xdr);
6039 	if (status)
6040 		goto out;
6041 	status = decode_open_downgrade(xdr, res);
6042 	if (status != 0)
6043 		goto out;
6044 	decode_getfattr(xdr, res->fattr, res->server);
6045 out:
6046 	return status;
6047 }
6048 
6049 /*
6050  * Decode ACCESS response
6051  */
6052 static int nfs4_xdr_dec_access(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6053 			       struct nfs4_accessres *res)
6054 {
6055 	struct compound_hdr hdr;
6056 	int status;
6057 
6058 	status = decode_compound_hdr(xdr, &hdr);
6059 	if (status)
6060 		goto out;
6061 	status = decode_sequence(xdr, &res->seq_res, rqstp);
6062 	if (status)
6063 		goto out;
6064 	status = decode_putfh(xdr);
6065 	if (status != 0)
6066 		goto out;
6067 	status = decode_access(xdr, &res->supported, &res->access);
6068 	if (status != 0)
6069 		goto out;
6070 	decode_getfattr(xdr, res->fattr, res->server);
6071 out:
6072 	return status;
6073 }
6074 
6075 /*
6076  * Decode LOOKUP response
6077  */
6078 static int nfs4_xdr_dec_lookup(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6079 			       struct nfs4_lookup_res *res)
6080 {
6081 	struct compound_hdr hdr;
6082 	int status;
6083 
6084 	status = decode_compound_hdr(xdr, &hdr);
6085 	if (status)
6086 		goto out;
6087 	status = decode_sequence(xdr, &res->seq_res, rqstp);
6088 	if (status)
6089 		goto out;
6090 	status = decode_putfh(xdr);
6091 	if (status)
6092 		goto out;
6093 	status = decode_lookup(xdr);
6094 	if (status)
6095 		goto out;
6096 	status = decode_getfh(xdr, res->fh);
6097 	if (status)
6098 		goto out;
6099 	status = decode_getfattr_label(xdr, res->fattr, res->label, res->server);
6100 out:
6101 	return status;
6102 }
6103 
6104 /*
6105  * Decode LOOKUP_ROOT response
6106  */
6107 static int nfs4_xdr_dec_lookup_root(struct rpc_rqst *rqstp,
6108 				    struct xdr_stream *xdr,
6109 				    struct nfs4_lookup_res *res)
6110 {
6111 	struct compound_hdr hdr;
6112 	int status;
6113 
6114 	status = decode_compound_hdr(xdr, &hdr);
6115 	if (status)
6116 		goto out;
6117 	status = decode_sequence(xdr, &res->seq_res, rqstp);
6118 	if (status)
6119 		goto out;
6120 	status = decode_putrootfh(xdr);
6121 	if (status)
6122 		goto out;
6123 	status = decode_getfh(xdr, res->fh);
6124 	if (status == 0)
6125 		status = decode_getfattr_label(xdr, res->fattr,
6126 						res->label, res->server);
6127 out:
6128 	return status;
6129 }
6130 
6131 /*
6132  * Decode REMOVE response
6133  */
6134 static int nfs4_xdr_dec_remove(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6135 			       struct nfs_removeres *res)
6136 {
6137 	struct compound_hdr hdr;
6138 	int status;
6139 
6140 	status = decode_compound_hdr(xdr, &hdr);
6141 	if (status)
6142 		goto out;
6143 	status = decode_sequence(xdr, &res->seq_res, rqstp);
6144 	if (status)
6145 		goto out;
6146 	status = decode_putfh(xdr);
6147 	if (status)
6148 		goto out;
6149 	status = decode_remove(xdr, &res->cinfo);
6150 out:
6151 	return status;
6152 }
6153 
6154 /*
6155  * Decode RENAME response
6156  */
6157 static int nfs4_xdr_dec_rename(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6158 			       struct nfs_renameres *res)
6159 {
6160 	struct compound_hdr hdr;
6161 	int status;
6162 
6163 	status = decode_compound_hdr(xdr, &hdr);
6164 	if (status)
6165 		goto out;
6166 	status = decode_sequence(xdr, &res->seq_res, rqstp);
6167 	if (status)
6168 		goto out;
6169 	status = decode_putfh(xdr);
6170 	if (status)
6171 		goto out;
6172 	status = decode_savefh(xdr);
6173 	if (status)
6174 		goto out;
6175 	status = decode_putfh(xdr);
6176 	if (status)
6177 		goto out;
6178 	status = decode_rename(xdr, &res->old_cinfo, &res->new_cinfo);
6179 out:
6180 	return status;
6181 }
6182 
6183 /*
6184  * Decode LINK response
6185  */
6186 static int nfs4_xdr_dec_link(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6187 			     struct nfs4_link_res *res)
6188 {
6189 	struct compound_hdr hdr;
6190 	int status;
6191 
6192 	status = decode_compound_hdr(xdr, &hdr);
6193 	if (status)
6194 		goto out;
6195 	status = decode_sequence(xdr, &res->seq_res, rqstp);
6196 	if (status)
6197 		goto out;
6198 	status = decode_putfh(xdr);
6199 	if (status)
6200 		goto out;
6201 	status = decode_savefh(xdr);
6202 	if (status)
6203 		goto out;
6204 	status = decode_putfh(xdr);
6205 	if (status)
6206 		goto out;
6207 	status = decode_link(xdr, &res->cinfo);
6208 	if (status)
6209 		goto out;
6210 	/*
6211 	 * Note order: OP_LINK leaves the directory as the current
6212 	 *             filehandle.
6213 	 */
6214 	status = decode_restorefh(xdr);
6215 	if (status)
6216 		goto out;
6217 	decode_getfattr_label(xdr, res->fattr, res->label, res->server);
6218 out:
6219 	return status;
6220 }
6221 
6222 /*
6223  * Decode CREATE response
6224  */
6225 static int nfs4_xdr_dec_create(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6226 			       struct nfs4_create_res *res)
6227 {
6228 	struct compound_hdr hdr;
6229 	int status;
6230 
6231 	status = decode_compound_hdr(xdr, &hdr);
6232 	if (status)
6233 		goto out;
6234 	status = decode_sequence(xdr, &res->seq_res, rqstp);
6235 	if (status)
6236 		goto out;
6237 	status = decode_putfh(xdr);
6238 	if (status)
6239 		goto out;
6240 	status = decode_create(xdr, &res->dir_cinfo);
6241 	if (status)
6242 		goto out;
6243 	status = decode_getfh(xdr, res->fh);
6244 	if (status)
6245 		goto out;
6246 	decode_getfattr_label(xdr, res->fattr, res->label, res->server);
6247 out:
6248 	return status;
6249 }
6250 
6251 /*
6252  * Decode SYMLINK response
6253  */
6254 static int nfs4_xdr_dec_symlink(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6255 				struct nfs4_create_res *res)
6256 {
6257 	return nfs4_xdr_dec_create(rqstp, xdr, res);
6258 }
6259 
6260 /*
6261  * Decode GETATTR response
6262  */
6263 static int nfs4_xdr_dec_getattr(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6264 				struct nfs4_getattr_res *res)
6265 {
6266 	struct compound_hdr hdr;
6267 	int status;
6268 
6269 	status = decode_compound_hdr(xdr, &hdr);
6270 	if (status)
6271 		goto out;
6272 	status = decode_sequence(xdr, &res->seq_res, rqstp);
6273 	if (status)
6274 		goto out;
6275 	status = decode_putfh(xdr);
6276 	if (status)
6277 		goto out;
6278 	status = decode_getfattr_label(xdr, res->fattr, res->label, res->server);
6279 out:
6280 	return status;
6281 }
6282 
6283 /*
6284  * Encode an SETACL request
6285  */
6286 static void nfs4_xdr_enc_setacl(struct rpc_rqst *req, struct xdr_stream *xdr,
6287 				struct nfs_setaclargs *args)
6288 {
6289 	struct compound_hdr hdr = {
6290 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
6291 	};
6292 
6293 	encode_compound_hdr(xdr, req, &hdr);
6294 	encode_sequence(xdr, &args->seq_args, &hdr);
6295 	encode_putfh(xdr, args->fh, &hdr);
6296 	encode_setacl(xdr, args, &hdr);
6297 	encode_nops(&hdr);
6298 }
6299 
6300 /*
6301  * Decode SETACL response
6302  */
6303 static int
6304 nfs4_xdr_dec_setacl(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6305 		    struct nfs_setaclres *res)
6306 {
6307 	struct compound_hdr hdr;
6308 	int status;
6309 
6310 	status = decode_compound_hdr(xdr, &hdr);
6311 	if (status)
6312 		goto out;
6313 	status = decode_sequence(xdr, &res->seq_res, rqstp);
6314 	if (status)
6315 		goto out;
6316 	status = decode_putfh(xdr);
6317 	if (status)
6318 		goto out;
6319 	status = decode_setattr(xdr);
6320 out:
6321 	return status;
6322 }
6323 
6324 /*
6325  * Decode GETACL response
6326  */
6327 static int
6328 nfs4_xdr_dec_getacl(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6329 		    struct nfs_getaclres *res)
6330 {
6331 	struct compound_hdr hdr;
6332 	int status;
6333 
6334 	if (res->acl_scratch != NULL) {
6335 		void *p = page_address(res->acl_scratch);
6336 		xdr_set_scratch_buffer(xdr, p, PAGE_SIZE);
6337 	}
6338 	status = decode_compound_hdr(xdr, &hdr);
6339 	if (status)
6340 		goto out;
6341 	status = decode_sequence(xdr, &res->seq_res, rqstp);
6342 	if (status)
6343 		goto out;
6344 	status = decode_putfh(xdr);
6345 	if (status)
6346 		goto out;
6347 	status = decode_getacl(xdr, rqstp, res);
6348 
6349 out:
6350 	return status;
6351 }
6352 
6353 /*
6354  * Decode CLOSE response
6355  */
6356 static int nfs4_xdr_dec_close(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6357 			      struct nfs_closeres *res)
6358 {
6359 	struct compound_hdr hdr;
6360 	int status;
6361 
6362 	status = decode_compound_hdr(xdr, &hdr);
6363 	if (status)
6364 		goto out;
6365 	status = decode_sequence(xdr, &res->seq_res, rqstp);
6366 	if (status)
6367 		goto out;
6368 	status = decode_putfh(xdr);
6369 	if (status)
6370 		goto out;
6371 	status = decode_close(xdr, res);
6372 	if (status != 0)
6373 		goto out;
6374 	/*
6375 	 * Note: Server may do delete on close for this file
6376 	 * 	in which case the getattr call will fail with
6377 	 * 	an ESTALE error. Shouldn't be a problem,
6378 	 * 	though, since fattr->valid will remain unset.
6379 	 */
6380 	decode_getfattr(xdr, res->fattr, res->server);
6381 out:
6382 	return status;
6383 }
6384 
6385 /*
6386  * Decode OPEN response
6387  */
6388 static int nfs4_xdr_dec_open(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6389 			     struct nfs_openres *res)
6390 {
6391 	struct compound_hdr hdr;
6392 	int status;
6393 
6394 	status = decode_compound_hdr(xdr, &hdr);
6395 	if (status)
6396 		goto out;
6397 	status = decode_sequence(xdr, &res->seq_res, rqstp);
6398 	if (status)
6399 		goto out;
6400 	status = decode_putfh(xdr);
6401 	if (status)
6402 		goto out;
6403 	status = decode_open(xdr, res);
6404 	if (status)
6405 		goto out;
6406 	status = decode_getfh(xdr, &res->fh);
6407 	if (status)
6408 		goto out;
6409 	if (res->access_request)
6410 		decode_access(xdr, &res->access_supported, &res->access_result);
6411 	decode_getfattr_label(xdr, res->f_attr, res->f_label, res->server);
6412 out:
6413 	return status;
6414 }
6415 
6416 /*
6417  * Decode OPEN_CONFIRM response
6418  */
6419 static int nfs4_xdr_dec_open_confirm(struct rpc_rqst *rqstp,
6420 				     struct xdr_stream *xdr,
6421 				     struct nfs_open_confirmres *res)
6422 {
6423 	struct compound_hdr hdr;
6424 	int status;
6425 
6426 	status = decode_compound_hdr(xdr, &hdr);
6427 	if (status)
6428 		goto out;
6429 	status = decode_putfh(xdr);
6430 	if (status)
6431 		goto out;
6432 	status = decode_open_confirm(xdr, res);
6433 out:
6434 	return status;
6435 }
6436 
6437 /*
6438  * Decode OPEN response
6439  */
6440 static int nfs4_xdr_dec_open_noattr(struct rpc_rqst *rqstp,
6441 				    struct xdr_stream *xdr,
6442 				    struct nfs_openres *res)
6443 {
6444 	struct compound_hdr hdr;
6445 	int status;
6446 
6447 	status = decode_compound_hdr(xdr, &hdr);
6448 	if (status)
6449 		goto out;
6450 	status = decode_sequence(xdr, &res->seq_res, rqstp);
6451 	if (status)
6452 		goto out;
6453 	status = decode_putfh(xdr);
6454 	if (status)
6455 		goto out;
6456 	status = decode_open(xdr, res);
6457 	if (status)
6458 		goto out;
6459 	if (res->access_request)
6460 		decode_access(xdr, &res->access_supported, &res->access_result);
6461 	decode_getfattr(xdr, res->f_attr, res->server);
6462 out:
6463 	return status;
6464 }
6465 
6466 /*
6467  * Decode SETATTR response
6468  */
6469 static int nfs4_xdr_dec_setattr(struct rpc_rqst *rqstp,
6470 				struct xdr_stream *xdr,
6471 				struct nfs_setattrres *res)
6472 {
6473 	struct compound_hdr hdr;
6474 	int status;
6475 
6476 	status = decode_compound_hdr(xdr, &hdr);
6477 	if (status)
6478 		goto out;
6479 	status = decode_sequence(xdr, &res->seq_res, rqstp);
6480 	if (status)
6481 		goto out;
6482 	status = decode_putfh(xdr);
6483 	if (status)
6484 		goto out;
6485 	status = decode_setattr(xdr);
6486 	if (status)
6487 		goto out;
6488 	decode_getfattr_label(xdr, res->fattr, res->label, res->server);
6489 out:
6490 	return status;
6491 }
6492 
6493 /*
6494  * Decode LOCK response
6495  */
6496 static int nfs4_xdr_dec_lock(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6497 			     struct nfs_lock_res *res)
6498 {
6499 	struct compound_hdr hdr;
6500 	int status;
6501 
6502 	status = decode_compound_hdr(xdr, &hdr);
6503 	if (status)
6504 		goto out;
6505 	status = decode_sequence(xdr, &res->seq_res, rqstp);
6506 	if (status)
6507 		goto out;
6508 	status = decode_putfh(xdr);
6509 	if (status)
6510 		goto out;
6511 	status = decode_lock(xdr, res);
6512 out:
6513 	return status;
6514 }
6515 
6516 /*
6517  * Decode LOCKT response
6518  */
6519 static int nfs4_xdr_dec_lockt(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6520 			      struct nfs_lockt_res *res)
6521 {
6522 	struct compound_hdr hdr;
6523 	int status;
6524 
6525 	status = decode_compound_hdr(xdr, &hdr);
6526 	if (status)
6527 		goto out;
6528 	status = decode_sequence(xdr, &res->seq_res, rqstp);
6529 	if (status)
6530 		goto out;
6531 	status = decode_putfh(xdr);
6532 	if (status)
6533 		goto out;
6534 	status = decode_lockt(xdr, res);
6535 out:
6536 	return status;
6537 }
6538 
6539 /*
6540  * Decode LOCKU response
6541  */
6542 static int nfs4_xdr_dec_locku(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6543 			      struct nfs_locku_res *res)
6544 {
6545 	struct compound_hdr hdr;
6546 	int status;
6547 
6548 	status = decode_compound_hdr(xdr, &hdr);
6549 	if (status)
6550 		goto out;
6551 	status = decode_sequence(xdr, &res->seq_res, rqstp);
6552 	if (status)
6553 		goto out;
6554 	status = decode_putfh(xdr);
6555 	if (status)
6556 		goto out;
6557 	status = decode_locku(xdr, res);
6558 out:
6559 	return status;
6560 }
6561 
6562 static int nfs4_xdr_dec_release_lockowner(struct rpc_rqst *rqstp,
6563 					  struct xdr_stream *xdr, void *dummy)
6564 {
6565 	struct compound_hdr hdr;
6566 	int status;
6567 
6568 	status = decode_compound_hdr(xdr, &hdr);
6569 	if (!status)
6570 		status = decode_release_lockowner(xdr);
6571 	return status;
6572 }
6573 
6574 /*
6575  * Decode READLINK response
6576  */
6577 static int nfs4_xdr_dec_readlink(struct rpc_rqst *rqstp,
6578 				 struct xdr_stream *xdr,
6579 				 struct nfs4_readlink_res *res)
6580 {
6581 	struct compound_hdr hdr;
6582 	int status;
6583 
6584 	status = decode_compound_hdr(xdr, &hdr);
6585 	if (status)
6586 		goto out;
6587 	status = decode_sequence(xdr, &res->seq_res, rqstp);
6588 	if (status)
6589 		goto out;
6590 	status = decode_putfh(xdr);
6591 	if (status)
6592 		goto out;
6593 	status = decode_readlink(xdr, rqstp);
6594 out:
6595 	return status;
6596 }
6597 
6598 /*
6599  * Decode READDIR response
6600  */
6601 static int nfs4_xdr_dec_readdir(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6602 				struct nfs4_readdir_res *res)
6603 {
6604 	struct compound_hdr hdr;
6605 	int status;
6606 
6607 	status = decode_compound_hdr(xdr, &hdr);
6608 	if (status)
6609 		goto out;
6610 	status = decode_sequence(xdr, &res->seq_res, rqstp);
6611 	if (status)
6612 		goto out;
6613 	status = decode_putfh(xdr);
6614 	if (status)
6615 		goto out;
6616 	status = decode_readdir(xdr, rqstp, res);
6617 out:
6618 	return status;
6619 }
6620 
6621 /*
6622  * Decode Read response
6623  */
6624 static int nfs4_xdr_dec_read(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6625 			     struct nfs_readres *res)
6626 {
6627 	struct compound_hdr hdr;
6628 	int status;
6629 
6630 	status = decode_compound_hdr(xdr, &hdr);
6631 	if (status)
6632 		goto out;
6633 	status = decode_sequence(xdr, &res->seq_res, rqstp);
6634 	if (status)
6635 		goto out;
6636 	status = decode_putfh(xdr);
6637 	if (status)
6638 		goto out;
6639 	status = decode_read(xdr, rqstp, res);
6640 	if (!status)
6641 		status = res->count;
6642 out:
6643 	return status;
6644 }
6645 
6646 /*
6647  * Decode WRITE response
6648  */
6649 static int nfs4_xdr_dec_write(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6650 			      struct nfs_writeres *res)
6651 {
6652 	struct compound_hdr hdr;
6653 	int status;
6654 
6655 	status = decode_compound_hdr(xdr, &hdr);
6656 	if (status)
6657 		goto out;
6658 	status = decode_sequence(xdr, &res->seq_res, rqstp);
6659 	if (status)
6660 		goto out;
6661 	status = decode_putfh(xdr);
6662 	if (status)
6663 		goto out;
6664 	status = decode_write(xdr, res);
6665 	if (status)
6666 		goto out;
6667 	if (res->fattr)
6668 		decode_getfattr(xdr, res->fattr, res->server);
6669 	if (!status)
6670 		status = res->count;
6671 out:
6672 	return status;
6673 }
6674 
6675 /*
6676  * Decode COMMIT response
6677  */
6678 static int nfs4_xdr_dec_commit(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6679 			       struct nfs_commitres *res)
6680 {
6681 	struct compound_hdr hdr;
6682 	int status;
6683 
6684 	status = decode_compound_hdr(xdr, &hdr);
6685 	if (status)
6686 		goto out;
6687 	status = decode_sequence(xdr, &res->seq_res, rqstp);
6688 	if (status)
6689 		goto out;
6690 	status = decode_putfh(xdr);
6691 	if (status)
6692 		goto out;
6693 	status = decode_commit(xdr, res);
6694 out:
6695 	return status;
6696 }
6697 
6698 /*
6699  * Decode FSINFO response
6700  */
6701 static int nfs4_xdr_dec_fsinfo(struct rpc_rqst *req, struct xdr_stream *xdr,
6702 			       struct nfs4_fsinfo_res *res)
6703 {
6704 	struct compound_hdr hdr;
6705 	int status;
6706 
6707 	status = decode_compound_hdr(xdr, &hdr);
6708 	if (!status)
6709 		status = decode_sequence(xdr, &res->seq_res, req);
6710 	if (!status)
6711 		status = decode_putfh(xdr);
6712 	if (!status)
6713 		status = decode_fsinfo(xdr, res->fsinfo);
6714 	return status;
6715 }
6716 
6717 /*
6718  * Decode PATHCONF response
6719  */
6720 static int nfs4_xdr_dec_pathconf(struct rpc_rqst *req, struct xdr_stream *xdr,
6721 				 struct nfs4_pathconf_res *res)
6722 {
6723 	struct compound_hdr hdr;
6724 	int status;
6725 
6726 	status = decode_compound_hdr(xdr, &hdr);
6727 	if (!status)
6728 		status = decode_sequence(xdr, &res->seq_res, req);
6729 	if (!status)
6730 		status = decode_putfh(xdr);
6731 	if (!status)
6732 		status = decode_pathconf(xdr, res->pathconf);
6733 	return status;
6734 }
6735 
6736 /*
6737  * Decode STATFS response
6738  */
6739 static int nfs4_xdr_dec_statfs(struct rpc_rqst *req, struct xdr_stream *xdr,
6740 			       struct nfs4_statfs_res *res)
6741 {
6742 	struct compound_hdr hdr;
6743 	int status;
6744 
6745 	status = decode_compound_hdr(xdr, &hdr);
6746 	if (!status)
6747 		status = decode_sequence(xdr, &res->seq_res, req);
6748 	if (!status)
6749 		status = decode_putfh(xdr);
6750 	if (!status)
6751 		status = decode_statfs(xdr, res->fsstat);
6752 	return status;
6753 }
6754 
6755 /*
6756  * Decode GETATTR_BITMAP response
6757  */
6758 static int nfs4_xdr_dec_server_caps(struct rpc_rqst *req,
6759 				    struct xdr_stream *xdr,
6760 				    struct nfs4_server_caps_res *res)
6761 {
6762 	struct compound_hdr hdr;
6763 	int status;
6764 
6765 	status = decode_compound_hdr(xdr, &hdr);
6766 	if (status)
6767 		goto out;
6768 	status = decode_sequence(xdr, &res->seq_res, req);
6769 	if (status)
6770 		goto out;
6771 	status = decode_putfh(xdr);
6772 	if (status)
6773 		goto out;
6774 	status = decode_server_caps(xdr, res);
6775 out:
6776 	return status;
6777 }
6778 
6779 /*
6780  * Decode RENEW response
6781  */
6782 static int nfs4_xdr_dec_renew(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
6783 			      void *__unused)
6784 {
6785 	struct compound_hdr hdr;
6786 	int status;
6787 
6788 	status = decode_compound_hdr(xdr, &hdr);
6789 	if (!status)
6790 		status = decode_renew(xdr);
6791 	return status;
6792 }
6793 
6794 /*
6795  * Decode SETCLIENTID response
6796  */
6797 static int nfs4_xdr_dec_setclientid(struct rpc_rqst *req,
6798 				    struct xdr_stream *xdr,
6799 				    struct nfs4_setclientid_res *res)
6800 {
6801 	struct compound_hdr hdr;
6802 	int status;
6803 
6804 	status = decode_compound_hdr(xdr, &hdr);
6805 	if (!status)
6806 		status = decode_setclientid(xdr, res);
6807 	return status;
6808 }
6809 
6810 /*
6811  * Decode SETCLIENTID_CONFIRM response
6812  */
6813 static int nfs4_xdr_dec_setclientid_confirm(struct rpc_rqst *req,
6814 					    struct xdr_stream *xdr)
6815 {
6816 	struct compound_hdr hdr;
6817 	int status;
6818 
6819 	status = decode_compound_hdr(xdr, &hdr);
6820 	if (!status)
6821 		status = decode_setclientid_confirm(xdr);
6822 	return status;
6823 }
6824 
6825 /*
6826  * Decode DELEGRETURN response
6827  */
6828 static int nfs4_xdr_dec_delegreturn(struct rpc_rqst *rqstp,
6829 				    struct xdr_stream *xdr,
6830 				    struct nfs4_delegreturnres *res)
6831 {
6832 	struct compound_hdr hdr;
6833 	int status;
6834 
6835 	status = decode_compound_hdr(xdr, &hdr);
6836 	if (status)
6837 		goto out;
6838 	status = decode_sequence(xdr, &res->seq_res, rqstp);
6839 	if (status)
6840 		goto out;
6841 	status = decode_putfh(xdr);
6842 	if (status != 0)
6843 		goto out;
6844 	status = decode_getfattr(xdr, res->fattr, res->server);
6845 	if (status != 0)
6846 		goto out;
6847 	status = decode_delegreturn(xdr);
6848 out:
6849 	return status;
6850 }
6851 
6852 /*
6853  * Decode FS_LOCATIONS response
6854  */
6855 static int nfs4_xdr_dec_fs_locations(struct rpc_rqst *req,
6856 				     struct xdr_stream *xdr,
6857 				     struct nfs4_fs_locations_res *res)
6858 {
6859 	struct compound_hdr hdr;
6860 	int status;
6861 
6862 	status = decode_compound_hdr(xdr, &hdr);
6863 	if (status)
6864 		goto out;
6865 	status = decode_sequence(xdr, &res->seq_res, req);
6866 	if (status)
6867 		goto out;
6868 	status = decode_putfh(xdr);
6869 	if (status)
6870 		goto out;
6871 	if (res->migration) {
6872 		xdr_enter_page(xdr, PAGE_SIZE);
6873 		status = decode_getfattr_generic(xdr,
6874 					&res->fs_locations->fattr,
6875 					 NULL, res->fs_locations,
6876 					 NULL, res->fs_locations->server);
6877 		if (status)
6878 			goto out;
6879 		if (res->renew)
6880 			status = decode_renew(xdr);
6881 	} else {
6882 		status = decode_lookup(xdr);
6883 		if (status)
6884 			goto out;
6885 		xdr_enter_page(xdr, PAGE_SIZE);
6886 		status = decode_getfattr_generic(xdr,
6887 					&res->fs_locations->fattr,
6888 					 NULL, res->fs_locations,
6889 					 NULL, res->fs_locations->server);
6890 	}
6891 out:
6892 	return status;
6893 }
6894 
6895 /*
6896  * Decode SECINFO response
6897  */
6898 static int nfs4_xdr_dec_secinfo(struct rpc_rqst *rqstp,
6899 				struct xdr_stream *xdr,
6900 				struct nfs4_secinfo_res *res)
6901 {
6902 	struct compound_hdr hdr;
6903 	int status;
6904 
6905 	status = decode_compound_hdr(xdr, &hdr);
6906 	if (status)
6907 		goto out;
6908 	status = decode_sequence(xdr, &res->seq_res, rqstp);
6909 	if (status)
6910 		goto out;
6911 	status = decode_putfh(xdr);
6912 	if (status)
6913 		goto out;
6914 	status = decode_secinfo(xdr, res);
6915 out:
6916 	return status;
6917 }
6918 
6919 /*
6920  * Decode FSID_PRESENT response
6921  */
6922 static int nfs4_xdr_dec_fsid_present(struct rpc_rqst *rqstp,
6923 				     struct xdr_stream *xdr,
6924 				     struct nfs4_fsid_present_res *res)
6925 {
6926 	struct compound_hdr hdr;
6927 	int status;
6928 
6929 	status = decode_compound_hdr(xdr, &hdr);
6930 	if (status)
6931 		goto out;
6932 	status = decode_sequence(xdr, &res->seq_res, rqstp);
6933 	if (status)
6934 		goto out;
6935 	status = decode_putfh(xdr);
6936 	if (status)
6937 		goto out;
6938 	status = decode_getfh(xdr, res->fh);
6939 	if (status)
6940 		goto out;
6941 	if (res->renew)
6942 		status = decode_renew(xdr);
6943 out:
6944 	return status;
6945 }
6946 
6947 #if defined(CONFIG_NFS_V4_1)
6948 /*
6949  * Decode BIND_CONN_TO_SESSION response
6950  */
6951 static int nfs4_xdr_dec_bind_conn_to_session(struct rpc_rqst *rqstp,
6952 					struct xdr_stream *xdr,
6953 					void *res)
6954 {
6955 	struct compound_hdr hdr;
6956 	int status;
6957 
6958 	status = decode_compound_hdr(xdr, &hdr);
6959 	if (!status)
6960 		status = decode_bind_conn_to_session(xdr, res);
6961 	return status;
6962 }
6963 
6964 /*
6965  * Decode EXCHANGE_ID response
6966  */
6967 static int nfs4_xdr_dec_exchange_id(struct rpc_rqst *rqstp,
6968 				    struct xdr_stream *xdr,
6969 				    void *res)
6970 {
6971 	struct compound_hdr hdr;
6972 	int status;
6973 
6974 	status = decode_compound_hdr(xdr, &hdr);
6975 	if (!status)
6976 		status = decode_exchange_id(xdr, res);
6977 	return status;
6978 }
6979 
6980 /*
6981  * Decode CREATE_SESSION response
6982  */
6983 static int nfs4_xdr_dec_create_session(struct rpc_rqst *rqstp,
6984 				       struct xdr_stream *xdr,
6985 				       struct nfs41_create_session_res *res)
6986 {
6987 	struct compound_hdr hdr;
6988 	int status;
6989 
6990 	status = decode_compound_hdr(xdr, &hdr);
6991 	if (!status)
6992 		status = decode_create_session(xdr, res);
6993 	return status;
6994 }
6995 
6996 /*
6997  * Decode DESTROY_SESSION response
6998  */
6999 static int nfs4_xdr_dec_destroy_session(struct rpc_rqst *rqstp,
7000 					struct xdr_stream *xdr,
7001 					void *res)
7002 {
7003 	struct compound_hdr hdr;
7004 	int status;
7005 
7006 	status = decode_compound_hdr(xdr, &hdr);
7007 	if (!status)
7008 		status = decode_destroy_session(xdr, res);
7009 	return status;
7010 }
7011 
7012 /*
7013  * Decode DESTROY_CLIENTID response
7014  */
7015 static int nfs4_xdr_dec_destroy_clientid(struct rpc_rqst *rqstp,
7016 					struct xdr_stream *xdr,
7017 					void *res)
7018 {
7019 	struct compound_hdr hdr;
7020 	int status;
7021 
7022 	status = decode_compound_hdr(xdr, &hdr);
7023 	if (!status)
7024 		status = decode_destroy_clientid(xdr, res);
7025 	return status;
7026 }
7027 
7028 /*
7029  * Decode SEQUENCE response
7030  */
7031 static int nfs4_xdr_dec_sequence(struct rpc_rqst *rqstp,
7032 				 struct xdr_stream *xdr,
7033 				 struct nfs4_sequence_res *res)
7034 {
7035 	struct compound_hdr hdr;
7036 	int status;
7037 
7038 	status = decode_compound_hdr(xdr, &hdr);
7039 	if (!status)
7040 		status = decode_sequence(xdr, res, rqstp);
7041 	return status;
7042 }
7043 
7044 /*
7045  * Decode GET_LEASE_TIME response
7046  */
7047 static int nfs4_xdr_dec_get_lease_time(struct rpc_rqst *rqstp,
7048 				       struct xdr_stream *xdr,
7049 				       struct nfs4_get_lease_time_res *res)
7050 {
7051 	struct compound_hdr hdr;
7052 	int status;
7053 
7054 	status = decode_compound_hdr(xdr, &hdr);
7055 	if (!status)
7056 		status = decode_sequence(xdr, &res->lr_seq_res, rqstp);
7057 	if (!status)
7058 		status = decode_putrootfh(xdr);
7059 	if (!status)
7060 		status = decode_fsinfo(xdr, res->lr_fsinfo);
7061 	return status;
7062 }
7063 
7064 /*
7065  * Decode RECLAIM_COMPLETE response
7066  */
7067 static int nfs4_xdr_dec_reclaim_complete(struct rpc_rqst *rqstp,
7068 					 struct xdr_stream *xdr,
7069 					 struct nfs41_reclaim_complete_res *res)
7070 {
7071 	struct compound_hdr hdr;
7072 	int status;
7073 
7074 	status = decode_compound_hdr(xdr, &hdr);
7075 	if (!status)
7076 		status = decode_sequence(xdr, &res->seq_res, rqstp);
7077 	if (!status)
7078 		status = decode_reclaim_complete(xdr, (void *)NULL);
7079 	return status;
7080 }
7081 
7082 /*
7083  * Decode GETDEVICELIST response
7084  */
7085 static int nfs4_xdr_dec_getdevicelist(struct rpc_rqst *rqstp,
7086 				      struct xdr_stream *xdr,
7087 				      struct nfs4_getdevicelist_res *res)
7088 {
7089 	struct compound_hdr hdr;
7090 	int status;
7091 
7092 	dprintk("encoding getdevicelist!\n");
7093 
7094 	status = decode_compound_hdr(xdr, &hdr);
7095 	if (status != 0)
7096 		goto out;
7097 	status = decode_sequence(xdr, &res->seq_res, rqstp);
7098 	if (status != 0)
7099 		goto out;
7100 	status = decode_putfh(xdr);
7101 	if (status != 0)
7102 		goto out;
7103 	status = decode_getdevicelist(xdr, res->devlist);
7104 out:
7105 	return status;
7106 }
7107 
7108 /*
7109  * Decode GETDEVINFO response
7110  */
7111 static int nfs4_xdr_dec_getdeviceinfo(struct rpc_rqst *rqstp,
7112 				      struct xdr_stream *xdr,
7113 				      struct nfs4_getdeviceinfo_res *res)
7114 {
7115 	struct compound_hdr hdr;
7116 	int status;
7117 
7118 	status = decode_compound_hdr(xdr, &hdr);
7119 	if (status != 0)
7120 		goto out;
7121 	status = decode_sequence(xdr, &res->seq_res, rqstp);
7122 	if (status != 0)
7123 		goto out;
7124 	status = decode_getdeviceinfo(xdr, res->pdev);
7125 out:
7126 	return status;
7127 }
7128 
7129 /*
7130  * Decode LAYOUTGET response
7131  */
7132 static int nfs4_xdr_dec_layoutget(struct rpc_rqst *rqstp,
7133 				  struct xdr_stream *xdr,
7134 				  struct nfs4_layoutget_res *res)
7135 {
7136 	struct compound_hdr hdr;
7137 	int status;
7138 
7139 	status = decode_compound_hdr(xdr, &hdr);
7140 	if (status)
7141 		goto out;
7142 	status = decode_sequence(xdr, &res->seq_res, rqstp);
7143 	if (status)
7144 		goto out;
7145 	status = decode_putfh(xdr);
7146 	if (status)
7147 		goto out;
7148 	status = decode_layoutget(xdr, rqstp, res);
7149 out:
7150 	return status;
7151 }
7152 
7153 /*
7154  * Decode LAYOUTRETURN response
7155  */
7156 static int nfs4_xdr_dec_layoutreturn(struct rpc_rqst *rqstp,
7157 				     struct xdr_stream *xdr,
7158 				     struct nfs4_layoutreturn_res *res)
7159 {
7160 	struct compound_hdr hdr;
7161 	int status;
7162 
7163 	status = decode_compound_hdr(xdr, &hdr);
7164 	if (status)
7165 		goto out;
7166 	status = decode_sequence(xdr, &res->seq_res, rqstp);
7167 	if (status)
7168 		goto out;
7169 	status = decode_putfh(xdr);
7170 	if (status)
7171 		goto out;
7172 	status = decode_layoutreturn(xdr, res);
7173 out:
7174 	return status;
7175 }
7176 
7177 /*
7178  * Decode LAYOUTCOMMIT response
7179  */
7180 static int nfs4_xdr_dec_layoutcommit(struct rpc_rqst *rqstp,
7181 				     struct xdr_stream *xdr,
7182 				     struct nfs4_layoutcommit_res *res)
7183 {
7184 	struct compound_hdr hdr;
7185 	int status;
7186 
7187 	status = decode_compound_hdr(xdr, &hdr);
7188 	if (status)
7189 		goto out;
7190 	status = decode_sequence(xdr, &res->seq_res, rqstp);
7191 	if (status)
7192 		goto out;
7193 	status = decode_putfh(xdr);
7194 	if (status)
7195 		goto out;
7196 	status = decode_layoutcommit(xdr, rqstp, res);
7197 	if (status)
7198 		goto out;
7199 	decode_getfattr(xdr, res->fattr, res->server);
7200 out:
7201 	return status;
7202 }
7203 
7204 /*
7205  * Decode SECINFO_NO_NAME response
7206  */
7207 static int nfs4_xdr_dec_secinfo_no_name(struct rpc_rqst *rqstp,
7208 					struct xdr_stream *xdr,
7209 					struct nfs4_secinfo_res *res)
7210 {
7211 	struct compound_hdr hdr;
7212 	int status;
7213 
7214 	status = decode_compound_hdr(xdr, &hdr);
7215 	if (status)
7216 		goto out;
7217 	status = decode_sequence(xdr, &res->seq_res, rqstp);
7218 	if (status)
7219 		goto out;
7220 	status = decode_putrootfh(xdr);
7221 	if (status)
7222 		goto out;
7223 	status = decode_secinfo_no_name(xdr, res);
7224 out:
7225 	return status;
7226 }
7227 
7228 /*
7229  * Decode TEST_STATEID response
7230  */
7231 static int nfs4_xdr_dec_test_stateid(struct rpc_rqst *rqstp,
7232 				     struct xdr_stream *xdr,
7233 				     struct nfs41_test_stateid_res *res)
7234 {
7235 	struct compound_hdr hdr;
7236 	int status;
7237 
7238 	status = decode_compound_hdr(xdr, &hdr);
7239 	if (status)
7240 		goto out;
7241 	status = decode_sequence(xdr, &res->seq_res, rqstp);
7242 	if (status)
7243 		goto out;
7244 	status = decode_test_stateid(xdr, res);
7245 out:
7246 	return status;
7247 }
7248 
7249 /*
7250  * Decode FREE_STATEID response
7251  */
7252 static int nfs4_xdr_dec_free_stateid(struct rpc_rqst *rqstp,
7253 				     struct xdr_stream *xdr,
7254 				     struct nfs41_free_stateid_res *res)
7255 {
7256 	struct compound_hdr hdr;
7257 	int status;
7258 
7259 	status = decode_compound_hdr(xdr, &hdr);
7260 	if (status)
7261 		goto out;
7262 	status = decode_sequence(xdr, &res->seq_res, rqstp);
7263 	if (status)
7264 		goto out;
7265 	status = decode_free_stateid(xdr, res);
7266 out:
7267 	return status;
7268 }
7269 #endif /* CONFIG_NFS_V4_1 */
7270 
7271 /**
7272  * nfs4_decode_dirent - Decode a single NFSv4 directory entry stored in
7273  *                      the local page cache.
7274  * @xdr: XDR stream where entry resides
7275  * @entry: buffer to fill in with entry data
7276  * @plus: boolean indicating whether this should be a readdirplus entry
7277  *
7278  * Returns zero if successful, otherwise a negative errno value is
7279  * returned.
7280  *
7281  * This function is not invoked during READDIR reply decoding, but
7282  * rather whenever an application invokes the getdents(2) system call
7283  * on a directory already in our cache.
7284  */
7285 int nfs4_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry,
7286 		       int plus)
7287 {
7288 	unsigned int savep;
7289 	uint32_t bitmap[3] = {0};
7290 	uint32_t len;
7291 	__be32 *p = xdr_inline_decode(xdr, 4);
7292 	if (unlikely(!p))
7293 		goto out_overflow;
7294 	if (*p == xdr_zero) {
7295 		p = xdr_inline_decode(xdr, 4);
7296 		if (unlikely(!p))
7297 			goto out_overflow;
7298 		if (*p == xdr_zero)
7299 			return -EAGAIN;
7300 		entry->eof = 1;
7301 		return -EBADCOOKIE;
7302 	}
7303 
7304 	p = xdr_inline_decode(xdr, 12);
7305 	if (unlikely(!p))
7306 		goto out_overflow;
7307 	entry->prev_cookie = entry->cookie;
7308 	p = xdr_decode_hyper(p, &entry->cookie);
7309 	entry->len = be32_to_cpup(p);
7310 
7311 	p = xdr_inline_decode(xdr, entry->len);
7312 	if (unlikely(!p))
7313 		goto out_overflow;
7314 	entry->name = (const char *) p;
7315 
7316 	/*
7317 	 * In case the server doesn't return an inode number,
7318 	 * we fake one here.  (We don't use inode number 0,
7319 	 * since glibc seems to choke on it...)
7320 	 */
7321 	entry->ino = 1;
7322 	entry->fattr->valid = 0;
7323 
7324 	if (decode_attr_bitmap(xdr, bitmap) < 0)
7325 		goto out_overflow;
7326 
7327 	if (decode_attr_length(xdr, &len, &savep) < 0)
7328 		goto out_overflow;
7329 
7330 	if (decode_getfattr_attrs(xdr, bitmap, entry->fattr, entry->fh,
7331 			NULL, entry->label, entry->server) < 0)
7332 		goto out_overflow;
7333 	if (entry->fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID)
7334 		entry->ino = entry->fattr->mounted_on_fileid;
7335 	else if (entry->fattr->valid & NFS_ATTR_FATTR_FILEID)
7336 		entry->ino = entry->fattr->fileid;
7337 
7338 	entry->d_type = DT_UNKNOWN;
7339 	if (entry->fattr->valid & NFS_ATTR_FATTR_TYPE)
7340 		entry->d_type = nfs_umode_to_dtype(entry->fattr->mode);
7341 
7342 	return 0;
7343 
7344 out_overflow:
7345 	print_overflow_msg(__func__, xdr);
7346 	return -EAGAIN;
7347 }
7348 
7349 /*
7350  * We need to translate between nfs status return values and
7351  * the local errno values which may not be the same.
7352  */
7353 static struct {
7354 	int stat;
7355 	int errno;
7356 } nfs_errtbl[] = {
7357 	{ NFS4_OK,		0		},
7358 	{ NFS4ERR_PERM,		-EPERM		},
7359 	{ NFS4ERR_NOENT,	-ENOENT		},
7360 	{ NFS4ERR_IO,		-errno_NFSERR_IO},
7361 	{ NFS4ERR_NXIO,		-ENXIO		},
7362 	{ NFS4ERR_ACCESS,	-EACCES		},
7363 	{ NFS4ERR_EXIST,	-EEXIST		},
7364 	{ NFS4ERR_XDEV,		-EXDEV		},
7365 	{ NFS4ERR_NOTDIR,	-ENOTDIR	},
7366 	{ NFS4ERR_ISDIR,	-EISDIR		},
7367 	{ NFS4ERR_INVAL,	-EINVAL		},
7368 	{ NFS4ERR_FBIG,		-EFBIG		},
7369 	{ NFS4ERR_NOSPC,	-ENOSPC		},
7370 	{ NFS4ERR_ROFS,		-EROFS		},
7371 	{ NFS4ERR_MLINK,	-EMLINK		},
7372 	{ NFS4ERR_NAMETOOLONG,	-ENAMETOOLONG	},
7373 	{ NFS4ERR_NOTEMPTY,	-ENOTEMPTY	},
7374 	{ NFS4ERR_DQUOT,	-EDQUOT		},
7375 	{ NFS4ERR_STALE,	-ESTALE		},
7376 	{ NFS4ERR_BADHANDLE,	-EBADHANDLE	},
7377 	{ NFS4ERR_BAD_COOKIE,	-EBADCOOKIE	},
7378 	{ NFS4ERR_NOTSUPP,	-ENOTSUPP	},
7379 	{ NFS4ERR_TOOSMALL,	-ETOOSMALL	},
7380 	{ NFS4ERR_SERVERFAULT,	-EREMOTEIO	},
7381 	{ NFS4ERR_BADTYPE,	-EBADTYPE	},
7382 	{ NFS4ERR_LOCKED,	-EAGAIN		},
7383 	{ NFS4ERR_SYMLINK,	-ELOOP		},
7384 	{ NFS4ERR_OP_ILLEGAL,	-EOPNOTSUPP	},
7385 	{ NFS4ERR_DEADLOCK,	-EDEADLK	},
7386 	{ -1,			-EIO		}
7387 };
7388 
7389 /*
7390  * Convert an NFS error code to a local one.
7391  * This one is used jointly by NFSv2 and NFSv3.
7392  */
7393 static int
7394 nfs4_stat_to_errno(int stat)
7395 {
7396 	int i;
7397 	for (i = 0; nfs_errtbl[i].stat != -1; i++) {
7398 		if (nfs_errtbl[i].stat == stat)
7399 			return nfs_errtbl[i].errno;
7400 	}
7401 	if (stat <= 10000 || stat > 10100) {
7402 		/* The server is looney tunes. */
7403 		return -EREMOTEIO;
7404 	}
7405 	/* If we cannot translate the error, the recovery routines should
7406 	 * handle it.
7407 	 * Note: remaining NFSv4 error codes have values > 10000, so should
7408 	 * not conflict with native Linux error codes.
7409 	 */
7410 	return -stat;
7411 }
7412 
7413 #define PROC(proc, argtype, restype)				\
7414 [NFSPROC4_CLNT_##proc] = {					\
7415 	.p_proc   = NFSPROC4_COMPOUND,				\
7416 	.p_encode = (kxdreproc_t)nfs4_xdr_##argtype,		\
7417 	.p_decode = (kxdrdproc_t)nfs4_xdr_##restype,		\
7418 	.p_arglen = NFS4_##argtype##_sz,			\
7419 	.p_replen = NFS4_##restype##_sz,			\
7420 	.p_statidx = NFSPROC4_CLNT_##proc,			\
7421 	.p_name   = #proc,					\
7422 }
7423 
7424 struct rpc_procinfo	nfs4_procedures[] = {
7425 	PROC(READ,		enc_read,		dec_read),
7426 	PROC(WRITE,		enc_write,		dec_write),
7427 	PROC(COMMIT,		enc_commit,		dec_commit),
7428 	PROC(OPEN,		enc_open,		dec_open),
7429 	PROC(OPEN_CONFIRM,	enc_open_confirm,	dec_open_confirm),
7430 	PROC(OPEN_NOATTR,	enc_open_noattr,	dec_open_noattr),
7431 	PROC(OPEN_DOWNGRADE,	enc_open_downgrade,	dec_open_downgrade),
7432 	PROC(CLOSE,		enc_close,		dec_close),
7433 	PROC(SETATTR,		enc_setattr,		dec_setattr),
7434 	PROC(FSINFO,		enc_fsinfo,		dec_fsinfo),
7435 	PROC(RENEW,		enc_renew,		dec_renew),
7436 	PROC(SETCLIENTID,	enc_setclientid,	dec_setclientid),
7437 	PROC(SETCLIENTID_CONFIRM, enc_setclientid_confirm, dec_setclientid_confirm),
7438 	PROC(LOCK,		enc_lock,		dec_lock),
7439 	PROC(LOCKT,		enc_lockt,		dec_lockt),
7440 	PROC(LOCKU,		enc_locku,		dec_locku),
7441 	PROC(ACCESS,		enc_access,		dec_access),
7442 	PROC(GETATTR,		enc_getattr,		dec_getattr),
7443 	PROC(LOOKUP,		enc_lookup,		dec_lookup),
7444 	PROC(LOOKUP_ROOT,	enc_lookup_root,	dec_lookup_root),
7445 	PROC(REMOVE,		enc_remove,		dec_remove),
7446 	PROC(RENAME,		enc_rename,		dec_rename),
7447 	PROC(LINK,		enc_link,		dec_link),
7448 	PROC(SYMLINK,		enc_symlink,		dec_symlink),
7449 	PROC(CREATE,		enc_create,		dec_create),
7450 	PROC(PATHCONF,		enc_pathconf,		dec_pathconf),
7451 	PROC(STATFS,		enc_statfs,		dec_statfs),
7452 	PROC(READLINK,		enc_readlink,		dec_readlink),
7453 	PROC(READDIR,		enc_readdir,		dec_readdir),
7454 	PROC(SERVER_CAPS,	enc_server_caps,	dec_server_caps),
7455 	PROC(DELEGRETURN,	enc_delegreturn,	dec_delegreturn),
7456 	PROC(GETACL,		enc_getacl,		dec_getacl),
7457 	PROC(SETACL,		enc_setacl,		dec_setacl),
7458 	PROC(FS_LOCATIONS,	enc_fs_locations,	dec_fs_locations),
7459 	PROC(RELEASE_LOCKOWNER,	enc_release_lockowner,	dec_release_lockowner),
7460 	PROC(SECINFO,		enc_secinfo,		dec_secinfo),
7461 	PROC(FSID_PRESENT,	enc_fsid_present,	dec_fsid_present),
7462 #if defined(CONFIG_NFS_V4_1)
7463 	PROC(EXCHANGE_ID,	enc_exchange_id,	dec_exchange_id),
7464 	PROC(CREATE_SESSION,	enc_create_session,	dec_create_session),
7465 	PROC(DESTROY_SESSION,	enc_destroy_session,	dec_destroy_session),
7466 	PROC(SEQUENCE,		enc_sequence,		dec_sequence),
7467 	PROC(GET_LEASE_TIME,	enc_get_lease_time,	dec_get_lease_time),
7468 	PROC(RECLAIM_COMPLETE,	enc_reclaim_complete,	dec_reclaim_complete),
7469 	PROC(GETDEVICEINFO,	enc_getdeviceinfo,	dec_getdeviceinfo),
7470 	PROC(LAYOUTGET,		enc_layoutget,		dec_layoutget),
7471 	PROC(LAYOUTCOMMIT,	enc_layoutcommit,	dec_layoutcommit),
7472 	PROC(LAYOUTRETURN,	enc_layoutreturn,	dec_layoutreturn),
7473 	PROC(SECINFO_NO_NAME,	enc_secinfo_no_name,	dec_secinfo_no_name),
7474 	PROC(TEST_STATEID,	enc_test_stateid,	dec_test_stateid),
7475 	PROC(FREE_STATEID,	enc_free_stateid,	dec_free_stateid),
7476 	PROC(GETDEVICELIST,	enc_getdevicelist,	dec_getdevicelist),
7477 	PROC(BIND_CONN_TO_SESSION,
7478 			enc_bind_conn_to_session, dec_bind_conn_to_session),
7479 	PROC(DESTROY_CLIENTID,	enc_destroy_clientid,	dec_destroy_clientid),
7480 #endif /* CONFIG_NFS_V4_1 */
7481 };
7482 
7483 const struct rpc_version nfs_version4 = {
7484 	.number			= 4,
7485 	.nrprocs		= ARRAY_SIZE(nfs4_procedures),
7486 	.procs			= nfs4_procedures
7487 };
7488 
7489 /*
7490  * Local variables:
7491  *  c-basic-offset: 8
7492  * End:
7493  */
7494