xref: /openbmc/linux/fs/nfs/nfs4xdr.c (revision 9d56dd3b083a3bec56e9da35ce07baca81030b03)
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/slab.h>
42 #include <linux/errno.h>
43 #include <linux/string.h>
44 #include <linux/in.h>
45 #include <linux/pagemap.h>
46 #include <linux/proc_fs.h>
47 #include <linux/kdev_t.h>
48 #include <linux/sunrpc/clnt.h>
49 #include <linux/sunrpc/msg_prot.h>
50 #include <linux/nfs.h>
51 #include <linux/nfs4.h>
52 #include <linux/nfs_fs.h>
53 #include <linux/nfs_idmap.h>
54 #include "nfs4_fs.h"
55 #include "internal.h"
56 
57 #define NFSDBG_FACILITY		NFSDBG_XDR
58 
59 /* Mapping from NFS error code to "errno" error code. */
60 #define errno_NFSERR_IO		EIO
61 
62 static int nfs4_stat_to_errno(int);
63 
64 /* NFSv4 COMPOUND tags are only wanted for debugging purposes */
65 #ifdef DEBUG
66 #define NFS4_MAXTAGLEN		20
67 #else
68 #define NFS4_MAXTAGLEN		0
69 #endif
70 
71 /* lock,open owner id:
72  * we currently use size 2 (u64) out of (NFS4_OPAQUE_LIMIT  >> 2)
73  */
74 #define open_owner_id_maxsz	(1 + 4)
75 #define lock_owner_id_maxsz	(1 + 4)
76 #define decode_lockowner_maxsz	(1 + XDR_QUADLEN(IDMAP_NAMESZ))
77 #define compound_encode_hdr_maxsz	(3 + (NFS4_MAXTAGLEN >> 2))
78 #define compound_decode_hdr_maxsz	(3 + (NFS4_MAXTAGLEN >> 2))
79 #define op_encode_hdr_maxsz	(1)
80 #define op_decode_hdr_maxsz	(2)
81 #define encode_stateid_maxsz	(XDR_QUADLEN(NFS4_STATEID_SIZE))
82 #define decode_stateid_maxsz	(XDR_QUADLEN(NFS4_STATEID_SIZE))
83 #define encode_verifier_maxsz	(XDR_QUADLEN(NFS4_VERIFIER_SIZE))
84 #define decode_verifier_maxsz	(XDR_QUADLEN(NFS4_VERIFIER_SIZE))
85 #define encode_putfh_maxsz	(op_encode_hdr_maxsz + 1 + \
86 				(NFS4_FHSIZE >> 2))
87 #define decode_putfh_maxsz	(op_decode_hdr_maxsz)
88 #define encode_putrootfh_maxsz	(op_encode_hdr_maxsz)
89 #define decode_putrootfh_maxsz	(op_decode_hdr_maxsz)
90 #define encode_getfh_maxsz      (op_encode_hdr_maxsz)
91 #define decode_getfh_maxsz      (op_decode_hdr_maxsz + 1 + \
92 				((3+NFS4_FHSIZE) >> 2))
93 #define nfs4_fattr_bitmap_maxsz 3
94 #define encode_getattr_maxsz    (op_encode_hdr_maxsz + nfs4_fattr_bitmap_maxsz)
95 #define nfs4_name_maxsz		(1 + ((3 + NFS4_MAXNAMLEN) >> 2))
96 #define nfs4_path_maxsz		(1 + ((3 + NFS4_MAXPATHLEN) >> 2))
97 #define nfs4_owner_maxsz	(1 + XDR_QUADLEN(IDMAP_NAMESZ))
98 #define nfs4_group_maxsz	(1 + XDR_QUADLEN(IDMAP_NAMESZ))
99 /* This is based on getfattr, which uses the most attributes: */
100 #define nfs4_fattr_value_maxsz	(1 + (1 + 2 + 2 + 4 + 2 + 1 + 1 + 2 + 2 + \
101 				3 + 3 + 3 + nfs4_owner_maxsz + nfs4_group_maxsz))
102 #define nfs4_fattr_maxsz	(nfs4_fattr_bitmap_maxsz + \
103 				nfs4_fattr_value_maxsz)
104 #define decode_getattr_maxsz    (op_decode_hdr_maxsz + nfs4_fattr_maxsz)
105 #define encode_attrs_maxsz	(nfs4_fattr_bitmap_maxsz + \
106 				 1 + 2 + 1 + \
107 				nfs4_owner_maxsz + \
108 				nfs4_group_maxsz + \
109 				4 + 4)
110 #define encode_savefh_maxsz     (op_encode_hdr_maxsz)
111 #define decode_savefh_maxsz     (op_decode_hdr_maxsz)
112 #define encode_restorefh_maxsz  (op_encode_hdr_maxsz)
113 #define decode_restorefh_maxsz  (op_decode_hdr_maxsz)
114 #define encode_fsinfo_maxsz	(encode_getattr_maxsz)
115 #define decode_fsinfo_maxsz	(op_decode_hdr_maxsz + 11)
116 #define encode_renew_maxsz	(op_encode_hdr_maxsz + 3)
117 #define decode_renew_maxsz	(op_decode_hdr_maxsz)
118 #define encode_setclientid_maxsz \
119 				(op_encode_hdr_maxsz + \
120 				XDR_QUADLEN(NFS4_VERIFIER_SIZE) + \
121 				XDR_QUADLEN(NFS4_SETCLIENTID_NAMELEN) + \
122 				1 /* sc_prog */ + \
123 				XDR_QUADLEN(RPCBIND_MAXNETIDLEN) + \
124 				XDR_QUADLEN(RPCBIND_MAXUADDRLEN) + \
125 				1) /* sc_cb_ident */
126 #define decode_setclientid_maxsz \
127 				(op_decode_hdr_maxsz + \
128 				2 + \
129 				1024) /* large value for CLID_INUSE */
130 #define encode_setclientid_confirm_maxsz \
131 				(op_encode_hdr_maxsz + \
132 				3 + (NFS4_VERIFIER_SIZE >> 2))
133 #define decode_setclientid_confirm_maxsz \
134 				(op_decode_hdr_maxsz)
135 #define encode_lookup_maxsz	(op_encode_hdr_maxsz + nfs4_name_maxsz)
136 #define decode_lookup_maxsz	(op_decode_hdr_maxsz)
137 #define encode_share_access_maxsz \
138 				(2)
139 #define encode_createmode_maxsz	(1 + encode_attrs_maxsz + encode_verifier_maxsz)
140 #define encode_opentype_maxsz	(1 + encode_createmode_maxsz)
141 #define encode_claim_null_maxsz	(1 + nfs4_name_maxsz)
142 #define encode_open_maxsz	(op_encode_hdr_maxsz + \
143 				2 + encode_share_access_maxsz + 2 + \
144 				open_owner_id_maxsz + \
145 				encode_opentype_maxsz + \
146 				encode_claim_null_maxsz)
147 #define decode_ace_maxsz	(3 + nfs4_owner_maxsz)
148 #define decode_delegation_maxsz	(1 + decode_stateid_maxsz + 1 + \
149 				decode_ace_maxsz)
150 #define decode_change_info_maxsz	(5)
151 #define decode_open_maxsz	(op_decode_hdr_maxsz + \
152 				decode_stateid_maxsz + \
153 				decode_change_info_maxsz + 1 + \
154 				nfs4_fattr_bitmap_maxsz + \
155 				decode_delegation_maxsz)
156 #define encode_open_confirm_maxsz \
157 				(op_encode_hdr_maxsz + \
158 				 encode_stateid_maxsz + 1)
159 #define decode_open_confirm_maxsz \
160 				(op_decode_hdr_maxsz + \
161 				 decode_stateid_maxsz)
162 #define encode_open_downgrade_maxsz \
163 				(op_encode_hdr_maxsz + \
164 				 encode_stateid_maxsz + 1 + \
165 				 encode_share_access_maxsz)
166 #define decode_open_downgrade_maxsz \
167 				(op_decode_hdr_maxsz + \
168 				 decode_stateid_maxsz)
169 #define encode_close_maxsz	(op_encode_hdr_maxsz + \
170 				 1 + encode_stateid_maxsz)
171 #define decode_close_maxsz	(op_decode_hdr_maxsz + \
172 				 decode_stateid_maxsz)
173 #define encode_setattr_maxsz	(op_encode_hdr_maxsz + \
174 				 encode_stateid_maxsz + \
175 				 encode_attrs_maxsz)
176 #define decode_setattr_maxsz	(op_decode_hdr_maxsz + \
177 				 nfs4_fattr_bitmap_maxsz)
178 #define encode_read_maxsz	(op_encode_hdr_maxsz + \
179 				 encode_stateid_maxsz + 3)
180 #define decode_read_maxsz	(op_decode_hdr_maxsz + 2)
181 #define encode_readdir_maxsz	(op_encode_hdr_maxsz + \
182 				 2 + encode_verifier_maxsz + 5)
183 #define decode_readdir_maxsz	(op_decode_hdr_maxsz + \
184 				 decode_verifier_maxsz)
185 #define encode_readlink_maxsz	(op_encode_hdr_maxsz)
186 #define decode_readlink_maxsz	(op_decode_hdr_maxsz + 1)
187 #define encode_write_maxsz	(op_encode_hdr_maxsz + \
188 				 encode_stateid_maxsz + 4)
189 #define decode_write_maxsz	(op_decode_hdr_maxsz + \
190 				 2 + decode_verifier_maxsz)
191 #define encode_commit_maxsz	(op_encode_hdr_maxsz + 3)
192 #define decode_commit_maxsz	(op_decode_hdr_maxsz + \
193 				 decode_verifier_maxsz)
194 #define encode_remove_maxsz	(op_encode_hdr_maxsz + \
195 				nfs4_name_maxsz)
196 #define decode_remove_maxsz	(op_decode_hdr_maxsz + \
197 				 decode_change_info_maxsz)
198 #define encode_rename_maxsz	(op_encode_hdr_maxsz + \
199 				2 * nfs4_name_maxsz)
200 #define decode_rename_maxsz	(op_decode_hdr_maxsz + \
201 				 decode_change_info_maxsz + \
202 				 decode_change_info_maxsz)
203 #define encode_link_maxsz	(op_encode_hdr_maxsz + \
204 				nfs4_name_maxsz)
205 #define decode_link_maxsz	(op_decode_hdr_maxsz + decode_change_info_maxsz)
206 #define encode_lock_maxsz	(op_encode_hdr_maxsz + \
207 				 7 + \
208 				 1 + encode_stateid_maxsz + 8)
209 #define decode_lock_denied_maxsz \
210 				(8 + decode_lockowner_maxsz)
211 #define decode_lock_maxsz	(op_decode_hdr_maxsz + \
212 				 decode_lock_denied_maxsz)
213 #define encode_lockt_maxsz	(op_encode_hdr_maxsz + 12)
214 #define decode_lockt_maxsz	(op_decode_hdr_maxsz + \
215 				 decode_lock_denied_maxsz)
216 #define encode_locku_maxsz	(op_encode_hdr_maxsz + 3 + \
217 				 encode_stateid_maxsz + \
218 				 4)
219 #define decode_locku_maxsz	(op_decode_hdr_maxsz + \
220 				 decode_stateid_maxsz)
221 #define encode_access_maxsz	(op_encode_hdr_maxsz + 1)
222 #define decode_access_maxsz	(op_decode_hdr_maxsz + 2)
223 #define encode_symlink_maxsz	(op_encode_hdr_maxsz + \
224 				1 + nfs4_name_maxsz + \
225 				1 + \
226 				nfs4_fattr_maxsz)
227 #define decode_symlink_maxsz	(op_decode_hdr_maxsz + 8)
228 #define encode_create_maxsz	(op_encode_hdr_maxsz + \
229 				1 + 2 + nfs4_name_maxsz + \
230 				encode_attrs_maxsz)
231 #define decode_create_maxsz	(op_decode_hdr_maxsz + \
232 				decode_change_info_maxsz + \
233 				nfs4_fattr_bitmap_maxsz)
234 #define encode_statfs_maxsz	(encode_getattr_maxsz)
235 #define decode_statfs_maxsz	(decode_getattr_maxsz)
236 #define encode_delegreturn_maxsz (op_encode_hdr_maxsz + 4)
237 #define decode_delegreturn_maxsz (op_decode_hdr_maxsz)
238 #define encode_getacl_maxsz	(encode_getattr_maxsz)
239 #define decode_getacl_maxsz	(op_decode_hdr_maxsz + \
240 				 nfs4_fattr_bitmap_maxsz + 1)
241 #define encode_setacl_maxsz	(op_encode_hdr_maxsz + \
242 				 encode_stateid_maxsz + 3)
243 #define decode_setacl_maxsz	(decode_setattr_maxsz)
244 #define encode_fs_locations_maxsz \
245 				(encode_getattr_maxsz)
246 #define decode_fs_locations_maxsz \
247 				(0)
248 
249 #if defined(CONFIG_NFS_V4_1)
250 #define NFS4_MAX_MACHINE_NAME_LEN (64)
251 
252 #define encode_exchange_id_maxsz (op_encode_hdr_maxsz + \
253 				encode_verifier_maxsz + \
254 				1 /* co_ownerid.len */ + \
255 				XDR_QUADLEN(NFS4_EXCHANGE_ID_LEN) + \
256 				1 /* flags */ + \
257 				1 /* spa_how */ + \
258 				0 /* SP4_NONE (for now) */ + \
259 				1 /* zero implemetation id array */)
260 #define decode_exchange_id_maxsz (op_decode_hdr_maxsz + \
261 				2 /* eir_clientid */ + \
262 				1 /* eir_sequenceid */ + \
263 				1 /* eir_flags */ + \
264 				1 /* spr_how */ + \
265 				0 /* SP4_NONE (for now) */ + \
266 				2 /* eir_server_owner.so_minor_id */ + \
267 				/* eir_server_owner.so_major_id<> */ \
268 				XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 + \
269 				/* eir_server_scope<> */ \
270 				XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 + \
271 				1 /* eir_server_impl_id array length */ + \
272 				0 /* ignored eir_server_impl_id contents */)
273 #define encode_channel_attrs_maxsz  (6 + 1 /* ca_rdma_ird.len (0) */)
274 #define decode_channel_attrs_maxsz  (6 + \
275 				     1 /* ca_rdma_ird.len */ + \
276 				     1 /* ca_rdma_ird */)
277 #define encode_create_session_maxsz  (op_encode_hdr_maxsz + \
278 				     2 /* csa_clientid */ + \
279 				     1 /* csa_sequence */ + \
280 				     1 /* csa_flags */ + \
281 				     encode_channel_attrs_maxsz + \
282 				     encode_channel_attrs_maxsz + \
283 				     1 /* csa_cb_program */ + \
284 				     1 /* csa_sec_parms.len (1) */ + \
285 				     1 /* cb_secflavor (AUTH_SYS) */ + \
286 				     1 /* stamp */ + \
287 				     1 /* machinename.len */ + \
288 				     XDR_QUADLEN(NFS4_MAX_MACHINE_NAME_LEN) + \
289 				     1 /* uid */ + \
290 				     1 /* gid */ + \
291 				     1 /* gids.len (0) */)
292 #define decode_create_session_maxsz  (op_decode_hdr_maxsz +	\
293 				     XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
294 				     1 /* csr_sequence */ + \
295 				     1 /* csr_flags */ + \
296 				     decode_channel_attrs_maxsz + \
297 				     decode_channel_attrs_maxsz)
298 #define encode_destroy_session_maxsz    (op_encode_hdr_maxsz + 4)
299 #define decode_destroy_session_maxsz    (op_decode_hdr_maxsz)
300 #define encode_sequence_maxsz	(op_encode_hdr_maxsz + \
301 				XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + 4)
302 #define decode_sequence_maxsz	(op_decode_hdr_maxsz + \
303 				XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + 5)
304 #define encode_reclaim_complete_maxsz	(op_encode_hdr_maxsz + 4)
305 #define decode_reclaim_complete_maxsz	(op_decode_hdr_maxsz + 4)
306 #else /* CONFIG_NFS_V4_1 */
307 #define encode_sequence_maxsz	0
308 #define decode_sequence_maxsz	0
309 #endif /* CONFIG_NFS_V4_1 */
310 
311 #define NFS4_enc_compound_sz	(1024)  /* XXX: large enough? */
312 #define NFS4_dec_compound_sz	(1024)  /* XXX: large enough? */
313 #define NFS4_enc_read_sz	(compound_encode_hdr_maxsz + \
314 				encode_sequence_maxsz + \
315 				encode_putfh_maxsz + \
316 				encode_read_maxsz)
317 #define NFS4_dec_read_sz	(compound_decode_hdr_maxsz + \
318 				decode_sequence_maxsz + \
319 				decode_putfh_maxsz + \
320 				decode_read_maxsz)
321 #define NFS4_enc_readlink_sz	(compound_encode_hdr_maxsz + \
322 				encode_sequence_maxsz + \
323 				encode_putfh_maxsz + \
324 				encode_readlink_maxsz)
325 #define NFS4_dec_readlink_sz	(compound_decode_hdr_maxsz + \
326 				decode_sequence_maxsz + \
327 				decode_putfh_maxsz + \
328 				decode_readlink_maxsz)
329 #define NFS4_enc_readdir_sz	(compound_encode_hdr_maxsz + \
330 				encode_sequence_maxsz + \
331 				encode_putfh_maxsz + \
332 				encode_readdir_maxsz)
333 #define NFS4_dec_readdir_sz	(compound_decode_hdr_maxsz + \
334 				decode_sequence_maxsz + \
335 				decode_putfh_maxsz + \
336 				decode_readdir_maxsz)
337 #define NFS4_enc_write_sz	(compound_encode_hdr_maxsz + \
338 				encode_sequence_maxsz + \
339 				encode_putfh_maxsz + \
340 				encode_write_maxsz + \
341 				encode_getattr_maxsz)
342 #define NFS4_dec_write_sz	(compound_decode_hdr_maxsz + \
343 				decode_sequence_maxsz + \
344 				decode_putfh_maxsz + \
345 				decode_write_maxsz + \
346 				decode_getattr_maxsz)
347 #define NFS4_enc_commit_sz	(compound_encode_hdr_maxsz + \
348 				encode_sequence_maxsz + \
349 				encode_putfh_maxsz + \
350 				encode_commit_maxsz + \
351 				encode_getattr_maxsz)
352 #define NFS4_dec_commit_sz	(compound_decode_hdr_maxsz + \
353 				decode_sequence_maxsz + \
354 				decode_putfh_maxsz + \
355 				decode_commit_maxsz + \
356 				decode_getattr_maxsz)
357 #define NFS4_enc_open_sz        (compound_encode_hdr_maxsz + \
358 				encode_sequence_maxsz + \
359 				encode_putfh_maxsz + \
360 				encode_savefh_maxsz + \
361 				encode_open_maxsz + \
362 				encode_getfh_maxsz + \
363 				encode_getattr_maxsz + \
364 				encode_restorefh_maxsz + \
365 				encode_getattr_maxsz)
366 #define NFS4_dec_open_sz        (compound_decode_hdr_maxsz + \
367 				decode_sequence_maxsz + \
368 				decode_putfh_maxsz + \
369 				decode_savefh_maxsz + \
370 				decode_open_maxsz + \
371 				decode_getfh_maxsz + \
372 				decode_getattr_maxsz + \
373 				decode_restorefh_maxsz + \
374 				decode_getattr_maxsz)
375 #define NFS4_enc_open_confirm_sz \
376 				(compound_encode_hdr_maxsz + \
377 				 encode_putfh_maxsz + \
378 				 encode_open_confirm_maxsz)
379 #define NFS4_dec_open_confirm_sz \
380 				(compound_decode_hdr_maxsz + \
381 				 decode_putfh_maxsz + \
382 				 decode_open_confirm_maxsz)
383 #define NFS4_enc_open_noattr_sz	(compound_encode_hdr_maxsz + \
384 					encode_sequence_maxsz + \
385 					encode_putfh_maxsz + \
386 					encode_open_maxsz + \
387 					encode_getattr_maxsz)
388 #define NFS4_dec_open_noattr_sz	(compound_decode_hdr_maxsz + \
389 					decode_sequence_maxsz + \
390 					decode_putfh_maxsz + \
391 					decode_open_maxsz + \
392 					decode_getattr_maxsz)
393 #define NFS4_enc_open_downgrade_sz \
394 				(compound_encode_hdr_maxsz + \
395 				 encode_sequence_maxsz + \
396 				 encode_putfh_maxsz + \
397 				 encode_open_downgrade_maxsz + \
398 				 encode_getattr_maxsz)
399 #define NFS4_dec_open_downgrade_sz \
400 				(compound_decode_hdr_maxsz + \
401 				 decode_sequence_maxsz + \
402 				 decode_putfh_maxsz + \
403 				 decode_open_downgrade_maxsz + \
404 				 decode_getattr_maxsz)
405 #define NFS4_enc_close_sz	(compound_encode_hdr_maxsz + \
406 				 encode_sequence_maxsz + \
407 				 encode_putfh_maxsz + \
408 				 encode_close_maxsz + \
409 				 encode_getattr_maxsz)
410 #define NFS4_dec_close_sz	(compound_decode_hdr_maxsz + \
411 				 decode_sequence_maxsz + \
412 				 decode_putfh_maxsz + \
413 				 decode_close_maxsz + \
414 				 decode_getattr_maxsz)
415 #define NFS4_enc_setattr_sz	(compound_encode_hdr_maxsz + \
416 				 encode_sequence_maxsz + \
417 				 encode_putfh_maxsz + \
418 				 encode_setattr_maxsz + \
419 				 encode_getattr_maxsz)
420 #define NFS4_dec_setattr_sz	(compound_decode_hdr_maxsz + \
421 				 decode_sequence_maxsz + \
422 				 decode_putfh_maxsz + \
423 				 decode_setattr_maxsz + \
424 				 decode_getattr_maxsz)
425 #define NFS4_enc_fsinfo_sz	(compound_encode_hdr_maxsz + \
426 				encode_sequence_maxsz + \
427 				encode_putfh_maxsz + \
428 				encode_fsinfo_maxsz)
429 #define NFS4_dec_fsinfo_sz	(compound_decode_hdr_maxsz + \
430 				decode_sequence_maxsz + \
431 				decode_putfh_maxsz + \
432 				decode_fsinfo_maxsz)
433 #define NFS4_enc_renew_sz	(compound_encode_hdr_maxsz + \
434 				encode_renew_maxsz)
435 #define NFS4_dec_renew_sz	(compound_decode_hdr_maxsz + \
436 				decode_renew_maxsz)
437 #define NFS4_enc_setclientid_sz	(compound_encode_hdr_maxsz + \
438 				encode_setclientid_maxsz)
439 #define NFS4_dec_setclientid_sz	(compound_decode_hdr_maxsz + \
440 				decode_setclientid_maxsz)
441 #define NFS4_enc_setclientid_confirm_sz \
442 				(compound_encode_hdr_maxsz + \
443 				encode_setclientid_confirm_maxsz + \
444 				encode_putrootfh_maxsz + \
445 				encode_fsinfo_maxsz)
446 #define NFS4_dec_setclientid_confirm_sz \
447 				(compound_decode_hdr_maxsz + \
448 				decode_setclientid_confirm_maxsz + \
449 				decode_putrootfh_maxsz + \
450 				decode_fsinfo_maxsz)
451 #define NFS4_enc_lock_sz        (compound_encode_hdr_maxsz + \
452 				encode_sequence_maxsz + \
453 				encode_putfh_maxsz + \
454 				encode_lock_maxsz)
455 #define NFS4_dec_lock_sz        (compound_decode_hdr_maxsz + \
456 				decode_sequence_maxsz + \
457 				decode_putfh_maxsz + \
458 				decode_lock_maxsz)
459 #define NFS4_enc_lockt_sz       (compound_encode_hdr_maxsz + \
460 				encode_sequence_maxsz + \
461 				encode_putfh_maxsz + \
462 				encode_lockt_maxsz)
463 #define NFS4_dec_lockt_sz       (compound_decode_hdr_maxsz + \
464 				 decode_sequence_maxsz + \
465 				 decode_putfh_maxsz + \
466 				 decode_lockt_maxsz)
467 #define NFS4_enc_locku_sz       (compound_encode_hdr_maxsz + \
468 				encode_sequence_maxsz + \
469 				encode_putfh_maxsz + \
470 				encode_locku_maxsz)
471 #define NFS4_dec_locku_sz       (compound_decode_hdr_maxsz + \
472 				decode_sequence_maxsz + \
473 				decode_putfh_maxsz + \
474 				decode_locku_maxsz)
475 #define NFS4_enc_access_sz	(compound_encode_hdr_maxsz + \
476 				encode_sequence_maxsz + \
477 				encode_putfh_maxsz + \
478 				encode_access_maxsz + \
479 				encode_getattr_maxsz)
480 #define NFS4_dec_access_sz	(compound_decode_hdr_maxsz + \
481 				decode_sequence_maxsz + \
482 				decode_putfh_maxsz + \
483 				decode_access_maxsz + \
484 				decode_getattr_maxsz)
485 #define NFS4_enc_getattr_sz	(compound_encode_hdr_maxsz + \
486 				encode_sequence_maxsz + \
487 				encode_putfh_maxsz + \
488 				encode_getattr_maxsz)
489 #define NFS4_dec_getattr_sz	(compound_decode_hdr_maxsz + \
490 				decode_sequence_maxsz + \
491 				decode_putfh_maxsz + \
492 				decode_getattr_maxsz)
493 #define NFS4_enc_lookup_sz	(compound_encode_hdr_maxsz + \
494 				encode_sequence_maxsz + \
495 				encode_putfh_maxsz + \
496 				encode_lookup_maxsz + \
497 				encode_getattr_maxsz + \
498 				encode_getfh_maxsz)
499 #define NFS4_dec_lookup_sz	(compound_decode_hdr_maxsz + \
500 				decode_sequence_maxsz + \
501 				decode_putfh_maxsz + \
502 				decode_lookup_maxsz + \
503 				decode_getattr_maxsz + \
504 				decode_getfh_maxsz)
505 #define NFS4_enc_lookup_root_sz (compound_encode_hdr_maxsz + \
506 				encode_sequence_maxsz + \
507 				encode_putrootfh_maxsz + \
508 				encode_getattr_maxsz + \
509 				encode_getfh_maxsz)
510 #define NFS4_dec_lookup_root_sz (compound_decode_hdr_maxsz + \
511 				decode_sequence_maxsz + \
512 				decode_putrootfh_maxsz + \
513 				decode_getattr_maxsz + \
514 				decode_getfh_maxsz)
515 #define NFS4_enc_remove_sz	(compound_encode_hdr_maxsz + \
516 				encode_sequence_maxsz + \
517 				encode_putfh_maxsz + \
518 				encode_remove_maxsz + \
519 				encode_getattr_maxsz)
520 #define NFS4_dec_remove_sz	(compound_decode_hdr_maxsz + \
521 				decode_sequence_maxsz + \
522 				decode_putfh_maxsz + \
523 				decode_remove_maxsz + \
524 				decode_getattr_maxsz)
525 #define NFS4_enc_rename_sz	(compound_encode_hdr_maxsz + \
526 				encode_sequence_maxsz + \
527 				encode_putfh_maxsz + \
528 				encode_savefh_maxsz + \
529 				encode_putfh_maxsz + \
530 				encode_rename_maxsz + \
531 				encode_getattr_maxsz + \
532 				encode_restorefh_maxsz + \
533 				encode_getattr_maxsz)
534 #define NFS4_dec_rename_sz	(compound_decode_hdr_maxsz + \
535 				decode_sequence_maxsz + \
536 				decode_putfh_maxsz + \
537 				decode_savefh_maxsz + \
538 				decode_putfh_maxsz + \
539 				decode_rename_maxsz + \
540 				decode_getattr_maxsz + \
541 				decode_restorefh_maxsz + \
542 				decode_getattr_maxsz)
543 #define NFS4_enc_link_sz	(compound_encode_hdr_maxsz + \
544 				encode_sequence_maxsz + \
545 				encode_putfh_maxsz + \
546 				encode_savefh_maxsz + \
547 				encode_putfh_maxsz + \
548 				encode_link_maxsz + \
549 				decode_getattr_maxsz + \
550 				encode_restorefh_maxsz + \
551 				decode_getattr_maxsz)
552 #define NFS4_dec_link_sz	(compound_decode_hdr_maxsz + \
553 				decode_sequence_maxsz + \
554 				decode_putfh_maxsz + \
555 				decode_savefh_maxsz + \
556 				decode_putfh_maxsz + \
557 				decode_link_maxsz + \
558 				decode_getattr_maxsz + \
559 				decode_restorefh_maxsz + \
560 				decode_getattr_maxsz)
561 #define NFS4_enc_symlink_sz	(compound_encode_hdr_maxsz + \
562 				encode_sequence_maxsz + \
563 				encode_putfh_maxsz + \
564 				encode_symlink_maxsz + \
565 				encode_getattr_maxsz + \
566 				encode_getfh_maxsz)
567 #define NFS4_dec_symlink_sz	(compound_decode_hdr_maxsz + \
568 				decode_sequence_maxsz + \
569 				decode_putfh_maxsz + \
570 				decode_symlink_maxsz + \
571 				decode_getattr_maxsz + \
572 				decode_getfh_maxsz)
573 #define NFS4_enc_create_sz	(compound_encode_hdr_maxsz + \
574 				encode_sequence_maxsz + \
575 				encode_putfh_maxsz + \
576 				encode_savefh_maxsz + \
577 				encode_create_maxsz + \
578 				encode_getfh_maxsz + \
579 				encode_getattr_maxsz + \
580 				encode_restorefh_maxsz + \
581 				encode_getattr_maxsz)
582 #define NFS4_dec_create_sz	(compound_decode_hdr_maxsz + \
583 				decode_sequence_maxsz + \
584 				decode_putfh_maxsz + \
585 				decode_savefh_maxsz + \
586 				decode_create_maxsz + \
587 				decode_getfh_maxsz + \
588 				decode_getattr_maxsz + \
589 				decode_restorefh_maxsz + \
590 				decode_getattr_maxsz)
591 #define NFS4_enc_pathconf_sz	(compound_encode_hdr_maxsz + \
592 				encode_sequence_maxsz + \
593 				encode_putfh_maxsz + \
594 				encode_getattr_maxsz)
595 #define NFS4_dec_pathconf_sz	(compound_decode_hdr_maxsz + \
596 				decode_sequence_maxsz + \
597 				decode_putfh_maxsz + \
598 				decode_getattr_maxsz)
599 #define NFS4_enc_statfs_sz	(compound_encode_hdr_maxsz + \
600 				encode_sequence_maxsz + \
601 				encode_putfh_maxsz + \
602 				encode_statfs_maxsz)
603 #define NFS4_dec_statfs_sz	(compound_decode_hdr_maxsz + \
604 				decode_sequence_maxsz + \
605 				decode_putfh_maxsz + \
606 				decode_statfs_maxsz)
607 #define NFS4_enc_server_caps_sz (compound_encode_hdr_maxsz + \
608 				encode_sequence_maxsz + \
609 				encode_putfh_maxsz + \
610 				encode_getattr_maxsz)
611 #define NFS4_dec_server_caps_sz (compound_decode_hdr_maxsz + \
612 				decode_sequence_maxsz + \
613 				decode_putfh_maxsz + \
614 				decode_getattr_maxsz)
615 #define NFS4_enc_delegreturn_sz	(compound_encode_hdr_maxsz + \
616 				encode_sequence_maxsz + \
617 				encode_putfh_maxsz + \
618 				encode_delegreturn_maxsz + \
619 				encode_getattr_maxsz)
620 #define NFS4_dec_delegreturn_sz (compound_decode_hdr_maxsz + \
621 				decode_sequence_maxsz + \
622 				decode_delegreturn_maxsz + \
623 				decode_getattr_maxsz)
624 #define NFS4_enc_getacl_sz	(compound_encode_hdr_maxsz + \
625 				encode_sequence_maxsz + \
626 				encode_putfh_maxsz + \
627 				encode_getacl_maxsz)
628 #define NFS4_dec_getacl_sz	(compound_decode_hdr_maxsz + \
629 				decode_sequence_maxsz + \
630 				decode_putfh_maxsz + \
631 				decode_getacl_maxsz)
632 #define NFS4_enc_setacl_sz	(compound_encode_hdr_maxsz + \
633 				encode_sequence_maxsz + \
634 				encode_putfh_maxsz + \
635 				encode_setacl_maxsz)
636 #define NFS4_dec_setacl_sz	(compound_decode_hdr_maxsz + \
637 				decode_sequence_maxsz + \
638 				decode_putfh_maxsz + \
639 				decode_setacl_maxsz)
640 #define NFS4_enc_fs_locations_sz \
641 				(compound_encode_hdr_maxsz + \
642 				 encode_sequence_maxsz + \
643 				 encode_putfh_maxsz + \
644 				 encode_lookup_maxsz + \
645 				 encode_fs_locations_maxsz)
646 #define NFS4_dec_fs_locations_sz \
647 				(compound_decode_hdr_maxsz + \
648 				 decode_sequence_maxsz + \
649 				 decode_putfh_maxsz + \
650 				 decode_lookup_maxsz + \
651 				 decode_fs_locations_maxsz)
652 #if defined(CONFIG_NFS_V4_1)
653 #define NFS4_enc_exchange_id_sz \
654 				(compound_encode_hdr_maxsz + \
655 				 encode_exchange_id_maxsz)
656 #define NFS4_dec_exchange_id_sz \
657 				(compound_decode_hdr_maxsz + \
658 				 decode_exchange_id_maxsz)
659 #define NFS4_enc_create_session_sz \
660 				(compound_encode_hdr_maxsz + \
661 				 encode_create_session_maxsz)
662 #define NFS4_dec_create_session_sz \
663 				(compound_decode_hdr_maxsz + \
664 				 decode_create_session_maxsz)
665 #define NFS4_enc_destroy_session_sz	(compound_encode_hdr_maxsz + \
666 					 encode_destroy_session_maxsz)
667 #define NFS4_dec_destroy_session_sz	(compound_decode_hdr_maxsz + \
668 					 decode_destroy_session_maxsz)
669 #define NFS4_enc_sequence_sz \
670 				(compound_decode_hdr_maxsz + \
671 				 encode_sequence_maxsz)
672 #define NFS4_dec_sequence_sz \
673 				(compound_decode_hdr_maxsz + \
674 				 decode_sequence_maxsz)
675 #define NFS4_enc_get_lease_time_sz	(compound_encode_hdr_maxsz + \
676 					 encode_sequence_maxsz + \
677 					 encode_putrootfh_maxsz + \
678 					 encode_fsinfo_maxsz)
679 #define NFS4_dec_get_lease_time_sz	(compound_decode_hdr_maxsz + \
680 					 decode_sequence_maxsz + \
681 					 decode_putrootfh_maxsz + \
682 					 decode_fsinfo_maxsz)
683 #define NFS4_enc_reclaim_complete_sz	(compound_encode_hdr_maxsz + \
684 					 encode_sequence_maxsz + \
685 					 encode_reclaim_complete_maxsz)
686 #define NFS4_dec_reclaim_complete_sz	(compound_decode_hdr_maxsz + \
687 					 decode_sequence_maxsz + \
688 					 decode_reclaim_complete_maxsz)
689 
690 const u32 nfs41_maxwrite_overhead = ((RPC_MAX_HEADER_WITH_AUTH +
691 				      compound_encode_hdr_maxsz +
692 				      encode_sequence_maxsz +
693 				      encode_putfh_maxsz +
694 				      encode_getattr_maxsz) *
695 				     XDR_UNIT);
696 
697 const u32 nfs41_maxread_overhead = ((RPC_MAX_HEADER_WITH_AUTH +
698 				     compound_decode_hdr_maxsz +
699 				     decode_sequence_maxsz +
700 				     decode_putfh_maxsz) *
701 				    XDR_UNIT);
702 #endif /* CONFIG_NFS_V4_1 */
703 
704 static const umode_t nfs_type2fmt[] = {
705 	[NF4BAD] = 0,
706 	[NF4REG] = S_IFREG,
707 	[NF4DIR] = S_IFDIR,
708 	[NF4BLK] = S_IFBLK,
709 	[NF4CHR] = S_IFCHR,
710 	[NF4LNK] = S_IFLNK,
711 	[NF4SOCK] = S_IFSOCK,
712 	[NF4FIFO] = S_IFIFO,
713 	[NF4ATTRDIR] = 0,
714 	[NF4NAMEDATTR] = 0,
715 };
716 
717 struct compound_hdr {
718 	int32_t		status;
719 	uint32_t	nops;
720 	__be32 *	nops_p;
721 	uint32_t	taglen;
722 	char *		tag;
723 	uint32_t	replen;		/* expected reply words */
724 	u32		minorversion;
725 };
726 
727 static __be32 *reserve_space(struct xdr_stream *xdr, size_t nbytes)
728 {
729 	__be32 *p = xdr_reserve_space(xdr, nbytes);
730 	BUG_ON(!p);
731 	return p;
732 }
733 
734 static void encode_string(struct xdr_stream *xdr, unsigned int len, const char *str)
735 {
736 	__be32 *p;
737 
738 	p = xdr_reserve_space(xdr, 4 + len);
739 	BUG_ON(p == NULL);
740 	xdr_encode_opaque(p, str, len);
741 }
742 
743 static void encode_compound_hdr(struct xdr_stream *xdr,
744 				struct rpc_rqst *req,
745 				struct compound_hdr *hdr)
746 {
747 	__be32 *p;
748 	struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
749 
750 	/* initialize running count of expected bytes in reply.
751 	 * NOTE: the replied tag SHOULD be the same is the one sent,
752 	 * but this is not required as a MUST for the server to do so. */
753 	hdr->replen = RPC_REPHDRSIZE + auth->au_rslack + 3 + hdr->taglen;
754 
755 	dprintk("encode_compound: tag=%.*s\n", (int)hdr->taglen, hdr->tag);
756 	BUG_ON(hdr->taglen > NFS4_MAXTAGLEN);
757 	p = reserve_space(xdr, 4 + hdr->taglen + 8);
758 	p = xdr_encode_opaque(p, hdr->tag, hdr->taglen);
759 	*p++ = cpu_to_be32(hdr->minorversion);
760 	hdr->nops_p = p;
761 	*p = cpu_to_be32(hdr->nops);
762 }
763 
764 static void encode_nops(struct compound_hdr *hdr)
765 {
766 	BUG_ON(hdr->nops > NFS4_MAX_OPS);
767 	*hdr->nops_p = htonl(hdr->nops);
768 }
769 
770 static void encode_nfs4_verifier(struct xdr_stream *xdr, const nfs4_verifier *verf)
771 {
772 	__be32 *p;
773 
774 	p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE);
775 	BUG_ON(p == NULL);
776 	xdr_encode_opaque_fixed(p, verf->data, NFS4_VERIFIER_SIZE);
777 }
778 
779 static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const struct nfs_server *server)
780 {
781 	char owner_name[IDMAP_NAMESZ];
782 	char owner_group[IDMAP_NAMESZ];
783 	int owner_namelen = 0;
784 	int owner_grouplen = 0;
785 	__be32 *p;
786 	__be32 *q;
787 	int len;
788 	uint32_t bmval0 = 0;
789 	uint32_t bmval1 = 0;
790 
791 	/*
792 	 * We reserve enough space to write the entire attribute buffer at once.
793 	 * In the worst-case, this would be
794 	 *   12(bitmap) + 4(attrlen) + 8(size) + 4(mode) + 4(atime) + 4(mtime)
795 	 *          = 36 bytes, plus any contribution from variable-length fields
796 	 *            such as owner/group.
797 	 */
798 	len = 16;
799 
800 	/* Sigh */
801 	if (iap->ia_valid & ATTR_SIZE)
802 		len += 8;
803 	if (iap->ia_valid & ATTR_MODE)
804 		len += 4;
805 	if (iap->ia_valid & ATTR_UID) {
806 		owner_namelen = nfs_map_uid_to_name(server->nfs_client, iap->ia_uid, owner_name);
807 		if (owner_namelen < 0) {
808 			dprintk("nfs: couldn't resolve uid %d to string\n",
809 					iap->ia_uid);
810 			/* XXX */
811 			strcpy(owner_name, "nobody");
812 			owner_namelen = sizeof("nobody") - 1;
813 			/* goto out; */
814 		}
815 		len += 4 + (XDR_QUADLEN(owner_namelen) << 2);
816 	}
817 	if (iap->ia_valid & ATTR_GID) {
818 		owner_grouplen = nfs_map_gid_to_group(server->nfs_client, iap->ia_gid, owner_group);
819 		if (owner_grouplen < 0) {
820 			dprintk("nfs: couldn't resolve gid %d to string\n",
821 					iap->ia_gid);
822 			strcpy(owner_group, "nobody");
823 			owner_grouplen = sizeof("nobody") - 1;
824 			/* goto out; */
825 		}
826 		len += 4 + (XDR_QUADLEN(owner_grouplen) << 2);
827 	}
828 	if (iap->ia_valid & ATTR_ATIME_SET)
829 		len += 16;
830 	else if (iap->ia_valid & ATTR_ATIME)
831 		len += 4;
832 	if (iap->ia_valid & ATTR_MTIME_SET)
833 		len += 16;
834 	else if (iap->ia_valid & ATTR_MTIME)
835 		len += 4;
836 	p = reserve_space(xdr, len);
837 
838 	/*
839 	 * We write the bitmap length now, but leave the bitmap and the attribute
840 	 * buffer length to be backfilled at the end of this routine.
841 	 */
842 	*p++ = cpu_to_be32(2);
843 	q = p;
844 	p += 3;
845 
846 	if (iap->ia_valid & ATTR_SIZE) {
847 		bmval0 |= FATTR4_WORD0_SIZE;
848 		p = xdr_encode_hyper(p, iap->ia_size);
849 	}
850 	if (iap->ia_valid & ATTR_MODE) {
851 		bmval1 |= FATTR4_WORD1_MODE;
852 		*p++ = cpu_to_be32(iap->ia_mode & S_IALLUGO);
853 	}
854 	if (iap->ia_valid & ATTR_UID) {
855 		bmval1 |= FATTR4_WORD1_OWNER;
856 		p = xdr_encode_opaque(p, owner_name, owner_namelen);
857 	}
858 	if (iap->ia_valid & ATTR_GID) {
859 		bmval1 |= FATTR4_WORD1_OWNER_GROUP;
860 		p = xdr_encode_opaque(p, owner_group, owner_grouplen);
861 	}
862 	if (iap->ia_valid & ATTR_ATIME_SET) {
863 		bmval1 |= FATTR4_WORD1_TIME_ACCESS_SET;
864 		*p++ = cpu_to_be32(NFS4_SET_TO_CLIENT_TIME);
865 		*p++ = cpu_to_be32(0);
866 		*p++ = cpu_to_be32(iap->ia_mtime.tv_sec);
867 		*p++ = cpu_to_be32(iap->ia_mtime.tv_nsec);
868 	}
869 	else if (iap->ia_valid & ATTR_ATIME) {
870 		bmval1 |= FATTR4_WORD1_TIME_ACCESS_SET;
871 		*p++ = cpu_to_be32(NFS4_SET_TO_SERVER_TIME);
872 	}
873 	if (iap->ia_valid & ATTR_MTIME_SET) {
874 		bmval1 |= FATTR4_WORD1_TIME_MODIFY_SET;
875 		*p++ = cpu_to_be32(NFS4_SET_TO_CLIENT_TIME);
876 		*p++ = cpu_to_be32(0);
877 		*p++ = cpu_to_be32(iap->ia_mtime.tv_sec);
878 		*p++ = cpu_to_be32(iap->ia_mtime.tv_nsec);
879 	}
880 	else if (iap->ia_valid & ATTR_MTIME) {
881 		bmval1 |= FATTR4_WORD1_TIME_MODIFY_SET;
882 		*p++ = cpu_to_be32(NFS4_SET_TO_SERVER_TIME);
883 	}
884 
885 	/*
886 	 * Now we backfill the bitmap and the attribute buffer length.
887 	 */
888 	if (len != ((char *)p - (char *)q) + 4) {
889 		printk(KERN_ERR "nfs: Attr length error, %u != %Zu\n",
890 				len, ((char *)p - (char *)q) + 4);
891 		BUG();
892 	}
893 	len = (char *)p - (char *)q - 12;
894 	*q++ = htonl(bmval0);
895 	*q++ = htonl(bmval1);
896 	*q = htonl(len);
897 
898 /* out: */
899 }
900 
901 static void encode_access(struct xdr_stream *xdr, u32 access, struct compound_hdr *hdr)
902 {
903 	__be32 *p;
904 
905 	p = reserve_space(xdr, 8);
906 	*p++ = cpu_to_be32(OP_ACCESS);
907 	*p = cpu_to_be32(access);
908 	hdr->nops++;
909 	hdr->replen += decode_access_maxsz;
910 }
911 
912 static void encode_close(struct xdr_stream *xdr, const struct nfs_closeargs *arg, struct compound_hdr *hdr)
913 {
914 	__be32 *p;
915 
916 	p = reserve_space(xdr, 8+NFS4_STATEID_SIZE);
917 	*p++ = cpu_to_be32(OP_CLOSE);
918 	*p++ = cpu_to_be32(arg->seqid->sequence->counter);
919 	xdr_encode_opaque_fixed(p, arg->stateid->data, NFS4_STATEID_SIZE);
920 	hdr->nops++;
921 	hdr->replen += decode_close_maxsz;
922 }
923 
924 static void encode_commit(struct xdr_stream *xdr, const struct nfs_writeargs *args, struct compound_hdr *hdr)
925 {
926 	__be32 *p;
927 
928 	p = reserve_space(xdr, 16);
929 	*p++ = cpu_to_be32(OP_COMMIT);
930 	p = xdr_encode_hyper(p, args->offset);
931 	*p = cpu_to_be32(args->count);
932 	hdr->nops++;
933 	hdr->replen += decode_commit_maxsz;
934 }
935 
936 static void encode_create(struct xdr_stream *xdr, const struct nfs4_create_arg *create, struct compound_hdr *hdr)
937 {
938 	__be32 *p;
939 
940 	p = reserve_space(xdr, 8);
941 	*p++ = cpu_to_be32(OP_CREATE);
942 	*p = cpu_to_be32(create->ftype);
943 
944 	switch (create->ftype) {
945 	case NF4LNK:
946 		p = reserve_space(xdr, 4);
947 		*p = cpu_to_be32(create->u.symlink.len);
948 		xdr_write_pages(xdr, create->u.symlink.pages, 0, create->u.symlink.len);
949 		break;
950 
951 	case NF4BLK: case NF4CHR:
952 		p = reserve_space(xdr, 8);
953 		*p++ = cpu_to_be32(create->u.device.specdata1);
954 		*p = cpu_to_be32(create->u.device.specdata2);
955 		break;
956 
957 	default:
958 		break;
959 	}
960 
961 	encode_string(xdr, create->name->len, create->name->name);
962 	hdr->nops++;
963 	hdr->replen += decode_create_maxsz;
964 
965 	encode_attrs(xdr, create->attrs, create->server);
966 }
967 
968 static void encode_getattr_one(struct xdr_stream *xdr, uint32_t bitmap, struct compound_hdr *hdr)
969 {
970 	__be32 *p;
971 
972 	p = reserve_space(xdr, 12);
973 	*p++ = cpu_to_be32(OP_GETATTR);
974 	*p++ = cpu_to_be32(1);
975 	*p = cpu_to_be32(bitmap);
976 	hdr->nops++;
977 	hdr->replen += decode_getattr_maxsz;
978 }
979 
980 static void encode_getattr_two(struct xdr_stream *xdr, uint32_t bm0, uint32_t bm1, struct compound_hdr *hdr)
981 {
982 	__be32 *p;
983 
984 	p = reserve_space(xdr, 16);
985 	*p++ = cpu_to_be32(OP_GETATTR);
986 	*p++ = cpu_to_be32(2);
987 	*p++ = cpu_to_be32(bm0);
988 	*p = cpu_to_be32(bm1);
989 	hdr->nops++;
990 	hdr->replen += decode_getattr_maxsz;
991 }
992 
993 static void encode_getfattr(struct xdr_stream *xdr, const u32* bitmask, struct compound_hdr *hdr)
994 {
995 	encode_getattr_two(xdr, bitmask[0] & nfs4_fattr_bitmap[0],
996 			   bitmask[1] & nfs4_fattr_bitmap[1], hdr);
997 }
998 
999 static void encode_fsinfo(struct xdr_stream *xdr, const u32* bitmask, struct compound_hdr *hdr)
1000 {
1001 	encode_getattr_two(xdr, bitmask[0] & nfs4_fsinfo_bitmap[0],
1002 			   bitmask[1] & nfs4_fsinfo_bitmap[1], hdr);
1003 }
1004 
1005 static void encode_fs_locations(struct xdr_stream *xdr, const u32* bitmask, struct compound_hdr *hdr)
1006 {
1007 	encode_getattr_two(xdr, bitmask[0] & nfs4_fs_locations_bitmap[0],
1008 			   bitmask[1] & nfs4_fs_locations_bitmap[1], hdr);
1009 }
1010 
1011 static void encode_getfh(struct xdr_stream *xdr, struct compound_hdr *hdr)
1012 {
1013 	__be32 *p;
1014 
1015 	p = reserve_space(xdr, 4);
1016 	*p = cpu_to_be32(OP_GETFH);
1017 	hdr->nops++;
1018 	hdr->replen += decode_getfh_maxsz;
1019 }
1020 
1021 static void encode_link(struct xdr_stream *xdr, const struct qstr *name, struct compound_hdr *hdr)
1022 {
1023 	__be32 *p;
1024 
1025 	p = reserve_space(xdr, 8 + name->len);
1026 	*p++ = cpu_to_be32(OP_LINK);
1027 	xdr_encode_opaque(p, name->name, name->len);
1028 	hdr->nops++;
1029 	hdr->replen += decode_link_maxsz;
1030 }
1031 
1032 static inline int nfs4_lock_type(struct file_lock *fl, int block)
1033 {
1034 	if ((fl->fl_type & (F_RDLCK|F_WRLCK|F_UNLCK)) == F_RDLCK)
1035 		return block ? NFS4_READW_LT : NFS4_READ_LT;
1036 	return block ? NFS4_WRITEW_LT : NFS4_WRITE_LT;
1037 }
1038 
1039 static inline uint64_t nfs4_lock_length(struct file_lock *fl)
1040 {
1041 	if (fl->fl_end == OFFSET_MAX)
1042 		return ~(uint64_t)0;
1043 	return fl->fl_end - fl->fl_start + 1;
1044 }
1045 
1046 /*
1047  * opcode,type,reclaim,offset,length,new_lock_owner = 32
1048  * open_seqid,open_stateid,lock_seqid,lock_owner.clientid, lock_owner.id = 40
1049  */
1050 static void encode_lock(struct xdr_stream *xdr, const struct nfs_lock_args *args, struct compound_hdr *hdr)
1051 {
1052 	__be32 *p;
1053 
1054 	p = reserve_space(xdr, 32);
1055 	*p++ = cpu_to_be32(OP_LOCK);
1056 	*p++ = cpu_to_be32(nfs4_lock_type(args->fl, args->block));
1057 	*p++ = cpu_to_be32(args->reclaim);
1058 	p = xdr_encode_hyper(p, args->fl->fl_start);
1059 	p = xdr_encode_hyper(p, nfs4_lock_length(args->fl));
1060 	*p = cpu_to_be32(args->new_lock_owner);
1061 	if (args->new_lock_owner){
1062 		p = reserve_space(xdr, 4+NFS4_STATEID_SIZE+32);
1063 		*p++ = cpu_to_be32(args->open_seqid->sequence->counter);
1064 		p = xdr_encode_opaque_fixed(p, args->open_stateid->data, NFS4_STATEID_SIZE);
1065 		*p++ = cpu_to_be32(args->lock_seqid->sequence->counter);
1066 		p = xdr_encode_hyper(p, args->lock_owner.clientid);
1067 		*p++ = cpu_to_be32(16);
1068 		p = xdr_encode_opaque_fixed(p, "lock id:", 8);
1069 		xdr_encode_hyper(p, args->lock_owner.id);
1070 	}
1071 	else {
1072 		p = reserve_space(xdr, NFS4_STATEID_SIZE+4);
1073 		p = xdr_encode_opaque_fixed(p, args->lock_stateid->data, NFS4_STATEID_SIZE);
1074 		*p = cpu_to_be32(args->lock_seqid->sequence->counter);
1075 	}
1076 	hdr->nops++;
1077 	hdr->replen += decode_lock_maxsz;
1078 }
1079 
1080 static void encode_lockt(struct xdr_stream *xdr, const struct nfs_lockt_args *args, struct compound_hdr *hdr)
1081 {
1082 	__be32 *p;
1083 
1084 	p = reserve_space(xdr, 52);
1085 	*p++ = cpu_to_be32(OP_LOCKT);
1086 	*p++ = cpu_to_be32(nfs4_lock_type(args->fl, 0));
1087 	p = xdr_encode_hyper(p, args->fl->fl_start);
1088 	p = xdr_encode_hyper(p, nfs4_lock_length(args->fl));
1089 	p = xdr_encode_hyper(p, args->lock_owner.clientid);
1090 	*p++ = cpu_to_be32(16);
1091 	p = xdr_encode_opaque_fixed(p, "lock id:", 8);
1092 	xdr_encode_hyper(p, args->lock_owner.id);
1093 	hdr->nops++;
1094 	hdr->replen += decode_lockt_maxsz;
1095 }
1096 
1097 static void encode_locku(struct xdr_stream *xdr, const struct nfs_locku_args *args, struct compound_hdr *hdr)
1098 {
1099 	__be32 *p;
1100 
1101 	p = reserve_space(xdr, 12+NFS4_STATEID_SIZE+16);
1102 	*p++ = cpu_to_be32(OP_LOCKU);
1103 	*p++ = cpu_to_be32(nfs4_lock_type(args->fl, 0));
1104 	*p++ = cpu_to_be32(args->seqid->sequence->counter);
1105 	p = xdr_encode_opaque_fixed(p, args->stateid->data, NFS4_STATEID_SIZE);
1106 	p = xdr_encode_hyper(p, args->fl->fl_start);
1107 	xdr_encode_hyper(p, nfs4_lock_length(args->fl));
1108 	hdr->nops++;
1109 	hdr->replen += decode_locku_maxsz;
1110 }
1111 
1112 static void encode_lookup(struct xdr_stream *xdr, const struct qstr *name, struct compound_hdr *hdr)
1113 {
1114 	int len = name->len;
1115 	__be32 *p;
1116 
1117 	p = reserve_space(xdr, 8 + len);
1118 	*p++ = cpu_to_be32(OP_LOOKUP);
1119 	xdr_encode_opaque(p, name->name, len);
1120 	hdr->nops++;
1121 	hdr->replen += decode_lookup_maxsz;
1122 }
1123 
1124 static void encode_share_access(struct xdr_stream *xdr, fmode_t fmode)
1125 {
1126 	__be32 *p;
1127 
1128 	p = reserve_space(xdr, 8);
1129 	switch (fmode & (FMODE_READ|FMODE_WRITE)) {
1130 	case FMODE_READ:
1131 		*p++ = cpu_to_be32(NFS4_SHARE_ACCESS_READ);
1132 		break;
1133 	case FMODE_WRITE:
1134 		*p++ = cpu_to_be32(NFS4_SHARE_ACCESS_WRITE);
1135 		break;
1136 	case FMODE_READ|FMODE_WRITE:
1137 		*p++ = cpu_to_be32(NFS4_SHARE_ACCESS_BOTH);
1138 		break;
1139 	default:
1140 		*p++ = cpu_to_be32(0);
1141 	}
1142 	*p = cpu_to_be32(0);		/* for linux, share_deny = 0 always */
1143 }
1144 
1145 static inline void encode_openhdr(struct xdr_stream *xdr, const struct nfs_openargs *arg)
1146 {
1147 	__be32 *p;
1148  /*
1149  * opcode 4, seqid 4, share_access 4, share_deny 4, clientid 8, ownerlen 4,
1150  * owner 4 = 32
1151  */
1152 	p = reserve_space(xdr, 8);
1153 	*p++ = cpu_to_be32(OP_OPEN);
1154 	*p = cpu_to_be32(arg->seqid->sequence->counter);
1155 	encode_share_access(xdr, arg->fmode);
1156 	p = reserve_space(xdr, 28);
1157 	p = xdr_encode_hyper(p, arg->clientid);
1158 	*p++ = cpu_to_be32(16);
1159 	p = xdr_encode_opaque_fixed(p, "open id:", 8);
1160 	xdr_encode_hyper(p, arg->id);
1161 }
1162 
1163 static inline void encode_createmode(struct xdr_stream *xdr, const struct nfs_openargs *arg)
1164 {
1165 	__be32 *p;
1166 	struct nfs_client *clp;
1167 
1168 	p = reserve_space(xdr, 4);
1169 	switch(arg->open_flags & O_EXCL) {
1170 	case 0:
1171 		*p = cpu_to_be32(NFS4_CREATE_UNCHECKED);
1172 		encode_attrs(xdr, arg->u.attrs, arg->server);
1173 		break;
1174 	default:
1175 		clp = arg->server->nfs_client;
1176 		if (clp->cl_minorversion > 0) {
1177 			if (nfs4_has_persistent_session(clp)) {
1178 				*p = cpu_to_be32(NFS4_CREATE_GUARDED);
1179 				encode_attrs(xdr, arg->u.attrs, arg->server);
1180 			} else {
1181 				struct iattr dummy;
1182 
1183 				*p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE4_1);
1184 				encode_nfs4_verifier(xdr, &arg->u.verifier);
1185 				dummy.ia_valid = 0;
1186 				encode_attrs(xdr, &dummy, arg->server);
1187 			}
1188 		} else {
1189 			*p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE);
1190 			encode_nfs4_verifier(xdr, &arg->u.verifier);
1191 		}
1192 	}
1193 }
1194 
1195 static void encode_opentype(struct xdr_stream *xdr, const struct nfs_openargs *arg)
1196 {
1197 	__be32 *p;
1198 
1199 	p = reserve_space(xdr, 4);
1200 	switch (arg->open_flags & O_CREAT) {
1201 	case 0:
1202 		*p = cpu_to_be32(NFS4_OPEN_NOCREATE);
1203 		break;
1204 	default:
1205 		BUG_ON(arg->claim != NFS4_OPEN_CLAIM_NULL);
1206 		*p = cpu_to_be32(NFS4_OPEN_CREATE);
1207 		encode_createmode(xdr, arg);
1208 	}
1209 }
1210 
1211 static inline void encode_delegation_type(struct xdr_stream *xdr, fmode_t delegation_type)
1212 {
1213 	__be32 *p;
1214 
1215 	p = reserve_space(xdr, 4);
1216 	switch (delegation_type) {
1217 	case 0:
1218 		*p = cpu_to_be32(NFS4_OPEN_DELEGATE_NONE);
1219 		break;
1220 	case FMODE_READ:
1221 		*p = cpu_to_be32(NFS4_OPEN_DELEGATE_READ);
1222 		break;
1223 	case FMODE_WRITE|FMODE_READ:
1224 		*p = cpu_to_be32(NFS4_OPEN_DELEGATE_WRITE);
1225 		break;
1226 	default:
1227 		BUG();
1228 	}
1229 }
1230 
1231 static inline void encode_claim_null(struct xdr_stream *xdr, const struct qstr *name)
1232 {
1233 	__be32 *p;
1234 
1235 	p = reserve_space(xdr, 4);
1236 	*p = cpu_to_be32(NFS4_OPEN_CLAIM_NULL);
1237 	encode_string(xdr, name->len, name->name);
1238 }
1239 
1240 static inline void encode_claim_previous(struct xdr_stream *xdr, fmode_t type)
1241 {
1242 	__be32 *p;
1243 
1244 	p = reserve_space(xdr, 4);
1245 	*p = cpu_to_be32(NFS4_OPEN_CLAIM_PREVIOUS);
1246 	encode_delegation_type(xdr, type);
1247 }
1248 
1249 static inline void encode_claim_delegate_cur(struct xdr_stream *xdr, const struct qstr *name, const nfs4_stateid *stateid)
1250 {
1251 	__be32 *p;
1252 
1253 	p = reserve_space(xdr, 4+NFS4_STATEID_SIZE);
1254 	*p++ = cpu_to_be32(NFS4_OPEN_CLAIM_DELEGATE_CUR);
1255 	xdr_encode_opaque_fixed(p, stateid->data, NFS4_STATEID_SIZE);
1256 	encode_string(xdr, name->len, name->name);
1257 }
1258 
1259 static void encode_open(struct xdr_stream *xdr, const struct nfs_openargs *arg, struct compound_hdr *hdr)
1260 {
1261 	encode_openhdr(xdr, arg);
1262 	encode_opentype(xdr, arg);
1263 	switch (arg->claim) {
1264 	case NFS4_OPEN_CLAIM_NULL:
1265 		encode_claim_null(xdr, arg->name);
1266 		break;
1267 	case NFS4_OPEN_CLAIM_PREVIOUS:
1268 		encode_claim_previous(xdr, arg->u.delegation_type);
1269 		break;
1270 	case NFS4_OPEN_CLAIM_DELEGATE_CUR:
1271 		encode_claim_delegate_cur(xdr, arg->name, &arg->u.delegation);
1272 		break;
1273 	default:
1274 		BUG();
1275 	}
1276 	hdr->nops++;
1277 	hdr->replen += decode_open_maxsz;
1278 }
1279 
1280 static void encode_open_confirm(struct xdr_stream *xdr, const struct nfs_open_confirmargs *arg, struct compound_hdr *hdr)
1281 {
1282 	__be32 *p;
1283 
1284 	p = reserve_space(xdr, 4+NFS4_STATEID_SIZE+4);
1285 	*p++ = cpu_to_be32(OP_OPEN_CONFIRM);
1286 	p = xdr_encode_opaque_fixed(p, arg->stateid->data, NFS4_STATEID_SIZE);
1287 	*p = cpu_to_be32(arg->seqid->sequence->counter);
1288 	hdr->nops++;
1289 	hdr->replen += decode_open_confirm_maxsz;
1290 }
1291 
1292 static void encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closeargs *arg, struct compound_hdr *hdr)
1293 {
1294 	__be32 *p;
1295 
1296 	p = reserve_space(xdr, 4+NFS4_STATEID_SIZE+4);
1297 	*p++ = cpu_to_be32(OP_OPEN_DOWNGRADE);
1298 	p = xdr_encode_opaque_fixed(p, arg->stateid->data, NFS4_STATEID_SIZE);
1299 	*p = cpu_to_be32(arg->seqid->sequence->counter);
1300 	encode_share_access(xdr, arg->fmode);
1301 	hdr->nops++;
1302 	hdr->replen += decode_open_downgrade_maxsz;
1303 }
1304 
1305 static void
1306 encode_putfh(struct xdr_stream *xdr, const struct nfs_fh *fh, struct compound_hdr *hdr)
1307 {
1308 	int len = fh->size;
1309 	__be32 *p;
1310 
1311 	p = reserve_space(xdr, 8 + len);
1312 	*p++ = cpu_to_be32(OP_PUTFH);
1313 	xdr_encode_opaque(p, fh->data, len);
1314 	hdr->nops++;
1315 	hdr->replen += decode_putfh_maxsz;
1316 }
1317 
1318 static void encode_putrootfh(struct xdr_stream *xdr, struct compound_hdr *hdr)
1319 {
1320 	__be32 *p;
1321 
1322 	p = reserve_space(xdr, 4);
1323 	*p = cpu_to_be32(OP_PUTROOTFH);
1324 	hdr->nops++;
1325 	hdr->replen += decode_putrootfh_maxsz;
1326 }
1327 
1328 static void encode_stateid(struct xdr_stream *xdr, const struct nfs_open_context *ctx)
1329 {
1330 	nfs4_stateid stateid;
1331 	__be32 *p;
1332 
1333 	p = reserve_space(xdr, NFS4_STATEID_SIZE);
1334 	if (ctx->state != NULL) {
1335 		nfs4_copy_stateid(&stateid, ctx->state, ctx->lockowner);
1336 		xdr_encode_opaque_fixed(p, stateid.data, NFS4_STATEID_SIZE);
1337 	} else
1338 		xdr_encode_opaque_fixed(p, zero_stateid.data, NFS4_STATEID_SIZE);
1339 }
1340 
1341 static void encode_read(struct xdr_stream *xdr, const struct nfs_readargs *args, struct compound_hdr *hdr)
1342 {
1343 	__be32 *p;
1344 
1345 	p = reserve_space(xdr, 4);
1346 	*p = cpu_to_be32(OP_READ);
1347 
1348 	encode_stateid(xdr, args->context);
1349 
1350 	p = reserve_space(xdr, 12);
1351 	p = xdr_encode_hyper(p, args->offset);
1352 	*p = cpu_to_be32(args->count);
1353 	hdr->nops++;
1354 	hdr->replen += decode_read_maxsz;
1355 }
1356 
1357 static void encode_readdir(struct xdr_stream *xdr, const struct nfs4_readdir_arg *readdir, struct rpc_rqst *req, struct compound_hdr *hdr)
1358 {
1359 	uint32_t attrs[2] = {
1360 		FATTR4_WORD0_RDATTR_ERROR|FATTR4_WORD0_FILEID,
1361 		FATTR4_WORD1_MOUNTED_ON_FILEID,
1362 	};
1363 	__be32 *p;
1364 
1365 	p = reserve_space(xdr, 12+NFS4_VERIFIER_SIZE+20);
1366 	*p++ = cpu_to_be32(OP_READDIR);
1367 	p = xdr_encode_hyper(p, readdir->cookie);
1368 	p = xdr_encode_opaque_fixed(p, readdir->verifier.data, NFS4_VERIFIER_SIZE);
1369 	*p++ = cpu_to_be32(readdir->count >> 1);  /* We're not doing readdirplus */
1370 	*p++ = cpu_to_be32(readdir->count);
1371 	*p++ = cpu_to_be32(2);
1372 	/* Switch to mounted_on_fileid if the server supports it */
1373 	if (readdir->bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)
1374 		attrs[0] &= ~FATTR4_WORD0_FILEID;
1375 	else
1376 		attrs[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID;
1377 	*p++ = cpu_to_be32(attrs[0] & readdir->bitmask[0]);
1378 	*p = cpu_to_be32(attrs[1] & readdir->bitmask[1]);
1379 	hdr->nops++;
1380 	hdr->replen += decode_readdir_maxsz;
1381 	dprintk("%s: cookie = %Lu, verifier = %08x:%08x, bitmap = %08x:%08x\n",
1382 			__func__,
1383 			(unsigned long long)readdir->cookie,
1384 			((u32 *)readdir->verifier.data)[0],
1385 			((u32 *)readdir->verifier.data)[1],
1386 			attrs[0] & readdir->bitmask[0],
1387 			attrs[1] & readdir->bitmask[1]);
1388 }
1389 
1390 static void encode_readlink(struct xdr_stream *xdr, const struct nfs4_readlink *readlink, struct rpc_rqst *req, struct compound_hdr *hdr)
1391 {
1392 	__be32 *p;
1393 
1394 	p = reserve_space(xdr, 4);
1395 	*p = cpu_to_be32(OP_READLINK);
1396 	hdr->nops++;
1397 	hdr->replen += decode_readlink_maxsz;
1398 }
1399 
1400 static void encode_remove(struct xdr_stream *xdr, const struct qstr *name, struct compound_hdr *hdr)
1401 {
1402 	__be32 *p;
1403 
1404 	p = reserve_space(xdr, 8 + name->len);
1405 	*p++ = cpu_to_be32(OP_REMOVE);
1406 	xdr_encode_opaque(p, name->name, name->len);
1407 	hdr->nops++;
1408 	hdr->replen += decode_remove_maxsz;
1409 }
1410 
1411 static void encode_rename(struct xdr_stream *xdr, const struct qstr *oldname, const struct qstr *newname, struct compound_hdr *hdr)
1412 {
1413 	__be32 *p;
1414 
1415 	p = reserve_space(xdr, 4);
1416 	*p = cpu_to_be32(OP_RENAME);
1417 	encode_string(xdr, oldname->len, oldname->name);
1418 	encode_string(xdr, newname->len, newname->name);
1419 	hdr->nops++;
1420 	hdr->replen += decode_rename_maxsz;
1421 }
1422 
1423 static void encode_renew(struct xdr_stream *xdr, const struct nfs_client *client_stateid, struct compound_hdr *hdr)
1424 {
1425 	__be32 *p;
1426 
1427 	p = reserve_space(xdr, 12);
1428 	*p++ = cpu_to_be32(OP_RENEW);
1429 	xdr_encode_hyper(p, client_stateid->cl_clientid);
1430 	hdr->nops++;
1431 	hdr->replen += decode_renew_maxsz;
1432 }
1433 
1434 static void
1435 encode_restorefh(struct xdr_stream *xdr, struct compound_hdr *hdr)
1436 {
1437 	__be32 *p;
1438 
1439 	p = reserve_space(xdr, 4);
1440 	*p = cpu_to_be32(OP_RESTOREFH);
1441 	hdr->nops++;
1442 	hdr->replen += decode_restorefh_maxsz;
1443 }
1444 
1445 static int
1446 encode_setacl(struct xdr_stream *xdr, struct nfs_setaclargs *arg, struct compound_hdr *hdr)
1447 {
1448 	__be32 *p;
1449 
1450 	p = reserve_space(xdr, 4+NFS4_STATEID_SIZE);
1451 	*p++ = cpu_to_be32(OP_SETATTR);
1452 	xdr_encode_opaque_fixed(p, zero_stateid.data, NFS4_STATEID_SIZE);
1453 	p = reserve_space(xdr, 2*4);
1454 	*p++ = cpu_to_be32(1);
1455 	*p = cpu_to_be32(FATTR4_WORD0_ACL);
1456 	if (arg->acl_len % 4)
1457 		return -EINVAL;
1458 	p = reserve_space(xdr, 4);
1459 	*p = cpu_to_be32(arg->acl_len);
1460 	xdr_write_pages(xdr, arg->acl_pages, arg->acl_pgbase, arg->acl_len);
1461 	hdr->nops++;
1462 	hdr->replen += decode_setacl_maxsz;
1463 	return 0;
1464 }
1465 
1466 static void
1467 encode_savefh(struct xdr_stream *xdr, struct compound_hdr *hdr)
1468 {
1469 	__be32 *p;
1470 
1471 	p = reserve_space(xdr, 4);
1472 	*p = cpu_to_be32(OP_SAVEFH);
1473 	hdr->nops++;
1474 	hdr->replen += decode_savefh_maxsz;
1475 }
1476 
1477 static void encode_setattr(struct xdr_stream *xdr, const struct nfs_setattrargs *arg, const struct nfs_server *server, struct compound_hdr *hdr)
1478 {
1479 	__be32 *p;
1480 
1481 	p = reserve_space(xdr, 4+NFS4_STATEID_SIZE);
1482 	*p++ = cpu_to_be32(OP_SETATTR);
1483 	xdr_encode_opaque_fixed(p, arg->stateid.data, NFS4_STATEID_SIZE);
1484 	hdr->nops++;
1485 	hdr->replen += decode_setattr_maxsz;
1486 	encode_attrs(xdr, arg->iap, server);
1487 }
1488 
1489 static void encode_setclientid(struct xdr_stream *xdr, const struct nfs4_setclientid *setclientid, struct compound_hdr *hdr)
1490 {
1491 	__be32 *p;
1492 
1493 	p = reserve_space(xdr, 4 + NFS4_VERIFIER_SIZE);
1494 	*p++ = cpu_to_be32(OP_SETCLIENTID);
1495 	xdr_encode_opaque_fixed(p, setclientid->sc_verifier->data, NFS4_VERIFIER_SIZE);
1496 
1497 	encode_string(xdr, setclientid->sc_name_len, setclientid->sc_name);
1498 	p = reserve_space(xdr, 4);
1499 	*p = cpu_to_be32(setclientid->sc_prog);
1500 	encode_string(xdr, setclientid->sc_netid_len, setclientid->sc_netid);
1501 	encode_string(xdr, setclientid->sc_uaddr_len, setclientid->sc_uaddr);
1502 	p = reserve_space(xdr, 4);
1503 	*p = cpu_to_be32(setclientid->sc_cb_ident);
1504 	hdr->nops++;
1505 	hdr->replen += decode_setclientid_maxsz;
1506 }
1507 
1508 static void encode_setclientid_confirm(struct xdr_stream *xdr, const struct nfs_client *client_state, struct compound_hdr *hdr)
1509 {
1510 	__be32 *p;
1511 
1512 	p = reserve_space(xdr, 12 + NFS4_VERIFIER_SIZE);
1513 	*p++ = cpu_to_be32(OP_SETCLIENTID_CONFIRM);
1514 	p = xdr_encode_hyper(p, client_state->cl_clientid);
1515 	xdr_encode_opaque_fixed(p, client_state->cl_confirm.data, NFS4_VERIFIER_SIZE);
1516 	hdr->nops++;
1517 	hdr->replen += decode_setclientid_confirm_maxsz;
1518 }
1519 
1520 static void encode_write(struct xdr_stream *xdr, const struct nfs_writeargs *args, struct compound_hdr *hdr)
1521 {
1522 	__be32 *p;
1523 
1524 	p = reserve_space(xdr, 4);
1525 	*p = cpu_to_be32(OP_WRITE);
1526 
1527 	encode_stateid(xdr, args->context);
1528 
1529 	p = reserve_space(xdr, 16);
1530 	p = xdr_encode_hyper(p, args->offset);
1531 	*p++ = cpu_to_be32(args->stable);
1532 	*p = cpu_to_be32(args->count);
1533 
1534 	xdr_write_pages(xdr, args->pages, args->pgbase, args->count);
1535 	hdr->nops++;
1536 	hdr->replen += decode_write_maxsz;
1537 }
1538 
1539 static void encode_delegreturn(struct xdr_stream *xdr, const nfs4_stateid *stateid, struct compound_hdr *hdr)
1540 {
1541 	__be32 *p;
1542 
1543 	p = reserve_space(xdr, 4+NFS4_STATEID_SIZE);
1544 
1545 	*p++ = cpu_to_be32(OP_DELEGRETURN);
1546 	xdr_encode_opaque_fixed(p, stateid->data, NFS4_STATEID_SIZE);
1547 	hdr->nops++;
1548 	hdr->replen += decode_delegreturn_maxsz;
1549 }
1550 
1551 #if defined(CONFIG_NFS_V4_1)
1552 /* NFSv4.1 operations */
1553 static void encode_exchange_id(struct xdr_stream *xdr,
1554 			       struct nfs41_exchange_id_args *args,
1555 			       struct compound_hdr *hdr)
1556 {
1557 	__be32 *p;
1558 
1559 	p = reserve_space(xdr, 4 + sizeof(args->verifier->data));
1560 	*p++ = cpu_to_be32(OP_EXCHANGE_ID);
1561 	xdr_encode_opaque_fixed(p, args->verifier->data, sizeof(args->verifier->data));
1562 
1563 	encode_string(xdr, args->id_len, args->id);
1564 
1565 	p = reserve_space(xdr, 12);
1566 	*p++ = cpu_to_be32(args->flags);
1567 	*p++ = cpu_to_be32(0);	/* zero length state_protect4_a */
1568 	*p = cpu_to_be32(0);	/* zero length implementation id array */
1569 	hdr->nops++;
1570 	hdr->replen += decode_exchange_id_maxsz;
1571 }
1572 
1573 static void encode_create_session(struct xdr_stream *xdr,
1574 				  struct nfs41_create_session_args *args,
1575 				  struct compound_hdr *hdr)
1576 {
1577 	__be32 *p;
1578 	char machine_name[NFS4_MAX_MACHINE_NAME_LEN];
1579 	uint32_t len;
1580 	struct nfs_client *clp = args->client;
1581 
1582 	len = scnprintf(machine_name, sizeof(machine_name), "%s",
1583 			clp->cl_ipaddr);
1584 
1585 	p = reserve_space(xdr, 20 + 2*28 + 20 + len + 12);
1586 	*p++ = cpu_to_be32(OP_CREATE_SESSION);
1587 	p = xdr_encode_hyper(p, clp->cl_ex_clid);
1588 	*p++ = cpu_to_be32(clp->cl_seqid);			/*Sequence id */
1589 	*p++ = cpu_to_be32(args->flags);			/*flags */
1590 
1591 	/* Fore Channel */
1592 	*p++ = cpu_to_be32(args->fc_attrs.headerpadsz);	/* header padding size */
1593 	*p++ = cpu_to_be32(args->fc_attrs.max_rqst_sz);	/* max req size */
1594 	*p++ = cpu_to_be32(args->fc_attrs.max_resp_sz);	/* max resp size */
1595 	*p++ = cpu_to_be32(args->fc_attrs.max_resp_sz_cached);	/* Max resp sz cached */
1596 	*p++ = cpu_to_be32(args->fc_attrs.max_ops);	/* max operations */
1597 	*p++ = cpu_to_be32(args->fc_attrs.max_reqs);	/* max requests */
1598 	*p++ = cpu_to_be32(0);				/* rdmachannel_attrs */
1599 
1600 	/* Back Channel */
1601 	*p++ = cpu_to_be32(args->fc_attrs.headerpadsz);	/* header padding size */
1602 	*p++ = cpu_to_be32(args->bc_attrs.max_rqst_sz);	/* max req size */
1603 	*p++ = cpu_to_be32(args->bc_attrs.max_resp_sz);	/* max resp size */
1604 	*p++ = cpu_to_be32(args->bc_attrs.max_resp_sz_cached);	/* Max resp sz cached */
1605 	*p++ = cpu_to_be32(args->bc_attrs.max_ops);	/* max operations */
1606 	*p++ = cpu_to_be32(args->bc_attrs.max_reqs);	/* max requests */
1607 	*p++ = cpu_to_be32(0);				/* rdmachannel_attrs */
1608 
1609 	*p++ = cpu_to_be32(args->cb_program);		/* cb_program */
1610 	*p++ = cpu_to_be32(1);
1611 	*p++ = cpu_to_be32(RPC_AUTH_UNIX);			/* auth_sys */
1612 
1613 	/* authsys_parms rfc1831 */
1614 	*p++ = cpu_to_be32((u32)clp->cl_boot_time.tv_nsec);	/* stamp */
1615 	p = xdr_encode_opaque(p, machine_name, len);
1616 	*p++ = cpu_to_be32(0);				/* UID */
1617 	*p++ = cpu_to_be32(0);				/* GID */
1618 	*p = cpu_to_be32(0);				/* No more gids */
1619 	hdr->nops++;
1620 	hdr->replen += decode_create_session_maxsz;
1621 }
1622 
1623 static void encode_destroy_session(struct xdr_stream *xdr,
1624 				   struct nfs4_session *session,
1625 				   struct compound_hdr *hdr)
1626 {
1627 	__be32 *p;
1628 	p = reserve_space(xdr, 4 + NFS4_MAX_SESSIONID_LEN);
1629 	*p++ = cpu_to_be32(OP_DESTROY_SESSION);
1630 	xdr_encode_opaque_fixed(p, session->sess_id.data, NFS4_MAX_SESSIONID_LEN);
1631 	hdr->nops++;
1632 	hdr->replen += decode_destroy_session_maxsz;
1633 }
1634 
1635 static void encode_reclaim_complete(struct xdr_stream *xdr,
1636 				    struct nfs41_reclaim_complete_args *args,
1637 				    struct compound_hdr *hdr)
1638 {
1639 	__be32 *p;
1640 
1641 	p = reserve_space(xdr, 8);
1642 	*p++ = cpu_to_be32(OP_RECLAIM_COMPLETE);
1643 	*p++ = cpu_to_be32(args->one_fs);
1644 	hdr->nops++;
1645 	hdr->replen += decode_reclaim_complete_maxsz;
1646 }
1647 #endif /* CONFIG_NFS_V4_1 */
1648 
1649 static void encode_sequence(struct xdr_stream *xdr,
1650 			    const struct nfs4_sequence_args *args,
1651 			    struct compound_hdr *hdr)
1652 {
1653 #if defined(CONFIG_NFS_V4_1)
1654 	struct nfs4_session *session = args->sa_session;
1655 	struct nfs4_slot_table *tp;
1656 	struct nfs4_slot *slot;
1657 	__be32 *p;
1658 
1659 	if (!session)
1660 		return;
1661 
1662 	tp = &session->fc_slot_table;
1663 
1664 	WARN_ON(args->sa_slotid == NFS4_MAX_SLOT_TABLE);
1665 	slot = tp->slots + args->sa_slotid;
1666 
1667 	p = reserve_space(xdr, 4 + NFS4_MAX_SESSIONID_LEN + 16);
1668 	*p++ = cpu_to_be32(OP_SEQUENCE);
1669 
1670 	/*
1671 	 * Sessionid + seqid + slotid + max slotid + cache_this
1672 	 */
1673 	dprintk("%s: sessionid=%u:%u:%u:%u seqid=%d slotid=%d "
1674 		"max_slotid=%d cache_this=%d\n",
1675 		__func__,
1676 		((u32 *)session->sess_id.data)[0],
1677 		((u32 *)session->sess_id.data)[1],
1678 		((u32 *)session->sess_id.data)[2],
1679 		((u32 *)session->sess_id.data)[3],
1680 		slot->seq_nr, args->sa_slotid,
1681 		tp->highest_used_slotid, args->sa_cache_this);
1682 	p = xdr_encode_opaque_fixed(p, session->sess_id.data, NFS4_MAX_SESSIONID_LEN);
1683 	*p++ = cpu_to_be32(slot->seq_nr);
1684 	*p++ = cpu_to_be32(args->sa_slotid);
1685 	*p++ = cpu_to_be32(tp->highest_used_slotid);
1686 	*p = cpu_to_be32(args->sa_cache_this);
1687 	hdr->nops++;
1688 	hdr->replen += decode_sequence_maxsz;
1689 #endif /* CONFIG_NFS_V4_1 */
1690 }
1691 
1692 /*
1693  * END OF "GENERIC" ENCODE ROUTINES.
1694  */
1695 
1696 static u32 nfs4_xdr_minorversion(const struct nfs4_sequence_args *args)
1697 {
1698 #if defined(CONFIG_NFS_V4_1)
1699 	if (args->sa_session)
1700 		return args->sa_session->clp->cl_minorversion;
1701 #endif /* CONFIG_NFS_V4_1 */
1702 	return 0;
1703 }
1704 
1705 /*
1706  * Encode an ACCESS request
1707  */
1708 static int nfs4_xdr_enc_access(struct rpc_rqst *req, __be32 *p, const struct nfs4_accessargs *args)
1709 {
1710 	struct xdr_stream xdr;
1711 	struct compound_hdr hdr = {
1712 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
1713 	};
1714 
1715 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1716 	encode_compound_hdr(&xdr, req, &hdr);
1717 	encode_sequence(&xdr, &args->seq_args, &hdr);
1718 	encode_putfh(&xdr, args->fh, &hdr);
1719 	encode_access(&xdr, args->access, &hdr);
1720 	encode_getfattr(&xdr, args->bitmask, &hdr);
1721 	encode_nops(&hdr);
1722 	return 0;
1723 }
1724 
1725 /*
1726  * Encode LOOKUP request
1727  */
1728 static int nfs4_xdr_enc_lookup(struct rpc_rqst *req, __be32 *p, const struct nfs4_lookup_arg *args)
1729 {
1730 	struct xdr_stream xdr;
1731 	struct compound_hdr hdr = {
1732 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
1733 	};
1734 
1735 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1736 	encode_compound_hdr(&xdr, req, &hdr);
1737 	encode_sequence(&xdr, &args->seq_args, &hdr);
1738 	encode_putfh(&xdr, args->dir_fh, &hdr);
1739 	encode_lookup(&xdr, args->name, &hdr);
1740 	encode_getfh(&xdr, &hdr);
1741 	encode_getfattr(&xdr, args->bitmask, &hdr);
1742 	encode_nops(&hdr);
1743 	return 0;
1744 }
1745 
1746 /*
1747  * Encode LOOKUP_ROOT request
1748  */
1749 static int nfs4_xdr_enc_lookup_root(struct rpc_rqst *req, __be32 *p, const struct nfs4_lookup_root_arg *args)
1750 {
1751 	struct xdr_stream xdr;
1752 	struct compound_hdr hdr = {
1753 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
1754 	};
1755 
1756 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1757 	encode_compound_hdr(&xdr, req, &hdr);
1758 	encode_sequence(&xdr, &args->seq_args, &hdr);
1759 	encode_putrootfh(&xdr, &hdr);
1760 	encode_getfh(&xdr, &hdr);
1761 	encode_getfattr(&xdr, args->bitmask, &hdr);
1762 	encode_nops(&hdr);
1763 	return 0;
1764 }
1765 
1766 /*
1767  * Encode REMOVE request
1768  */
1769 static int nfs4_xdr_enc_remove(struct rpc_rqst *req, __be32 *p, const struct nfs_removeargs *args)
1770 {
1771 	struct xdr_stream xdr;
1772 	struct compound_hdr hdr = {
1773 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
1774 	};
1775 
1776 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1777 	encode_compound_hdr(&xdr, req, &hdr);
1778 	encode_sequence(&xdr, &args->seq_args, &hdr);
1779 	encode_putfh(&xdr, args->fh, &hdr);
1780 	encode_remove(&xdr, &args->name, &hdr);
1781 	encode_getfattr(&xdr, args->bitmask, &hdr);
1782 	encode_nops(&hdr);
1783 	return 0;
1784 }
1785 
1786 /*
1787  * Encode RENAME request
1788  */
1789 static int nfs4_xdr_enc_rename(struct rpc_rqst *req, __be32 *p, const struct nfs4_rename_arg *args)
1790 {
1791 	struct xdr_stream xdr;
1792 	struct compound_hdr hdr = {
1793 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
1794 	};
1795 
1796 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1797 	encode_compound_hdr(&xdr, req, &hdr);
1798 	encode_sequence(&xdr, &args->seq_args, &hdr);
1799 	encode_putfh(&xdr, args->old_dir, &hdr);
1800 	encode_savefh(&xdr, &hdr);
1801 	encode_putfh(&xdr, args->new_dir, &hdr);
1802 	encode_rename(&xdr, args->old_name, args->new_name, &hdr);
1803 	encode_getfattr(&xdr, args->bitmask, &hdr);
1804 	encode_restorefh(&xdr, &hdr);
1805 	encode_getfattr(&xdr, args->bitmask, &hdr);
1806 	encode_nops(&hdr);
1807 	return 0;
1808 }
1809 
1810 /*
1811  * Encode LINK request
1812  */
1813 static int nfs4_xdr_enc_link(struct rpc_rqst *req, __be32 *p, const struct nfs4_link_arg *args)
1814 {
1815 	struct xdr_stream xdr;
1816 	struct compound_hdr hdr = {
1817 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
1818 	};
1819 
1820 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1821 	encode_compound_hdr(&xdr, req, &hdr);
1822 	encode_sequence(&xdr, &args->seq_args, &hdr);
1823 	encode_putfh(&xdr, args->fh, &hdr);
1824 	encode_savefh(&xdr, &hdr);
1825 	encode_putfh(&xdr, args->dir_fh, &hdr);
1826 	encode_link(&xdr, args->name, &hdr);
1827 	encode_getfattr(&xdr, args->bitmask, &hdr);
1828 	encode_restorefh(&xdr, &hdr);
1829 	encode_getfattr(&xdr, args->bitmask, &hdr);
1830 	encode_nops(&hdr);
1831 	return 0;
1832 }
1833 
1834 /*
1835  * Encode CREATE request
1836  */
1837 static int nfs4_xdr_enc_create(struct rpc_rqst *req, __be32 *p, const struct nfs4_create_arg *args)
1838 {
1839 	struct xdr_stream xdr;
1840 	struct compound_hdr hdr = {
1841 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
1842 	};
1843 
1844 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1845 	encode_compound_hdr(&xdr, req, &hdr);
1846 	encode_sequence(&xdr, &args->seq_args, &hdr);
1847 	encode_putfh(&xdr, args->dir_fh, &hdr);
1848 	encode_savefh(&xdr, &hdr);
1849 	encode_create(&xdr, args, &hdr);
1850 	encode_getfh(&xdr, &hdr);
1851 	encode_getfattr(&xdr, args->bitmask, &hdr);
1852 	encode_restorefh(&xdr, &hdr);
1853 	encode_getfattr(&xdr, args->bitmask, &hdr);
1854 	encode_nops(&hdr);
1855 	return 0;
1856 }
1857 
1858 /*
1859  * Encode SYMLINK request
1860  */
1861 static int nfs4_xdr_enc_symlink(struct rpc_rqst *req, __be32 *p, const struct nfs4_create_arg *args)
1862 {
1863 	return nfs4_xdr_enc_create(req, p, args);
1864 }
1865 
1866 /*
1867  * Encode GETATTR request
1868  */
1869 static int nfs4_xdr_enc_getattr(struct rpc_rqst *req, __be32 *p, const struct nfs4_getattr_arg *args)
1870 {
1871 	struct xdr_stream xdr;
1872 	struct compound_hdr hdr = {
1873 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
1874 	};
1875 
1876 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1877 	encode_compound_hdr(&xdr, req, &hdr);
1878 	encode_sequence(&xdr, &args->seq_args, &hdr);
1879 	encode_putfh(&xdr, args->fh, &hdr);
1880 	encode_getfattr(&xdr, args->bitmask, &hdr);
1881 	encode_nops(&hdr);
1882 	return 0;
1883 }
1884 
1885 /*
1886  * Encode a CLOSE request
1887  */
1888 static int nfs4_xdr_enc_close(struct rpc_rqst *req, __be32 *p, struct nfs_closeargs *args)
1889 {
1890 	struct xdr_stream xdr;
1891 	struct compound_hdr hdr = {
1892 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
1893 	};
1894 
1895 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1896 	encode_compound_hdr(&xdr, req, &hdr);
1897 	encode_sequence(&xdr, &args->seq_args, &hdr);
1898 	encode_putfh(&xdr, args->fh, &hdr);
1899 	encode_close(&xdr, args, &hdr);
1900 	encode_getfattr(&xdr, args->bitmask, &hdr);
1901 	encode_nops(&hdr);
1902 	return 0;
1903 }
1904 
1905 /*
1906  * Encode an OPEN request
1907  */
1908 static int nfs4_xdr_enc_open(struct rpc_rqst *req, __be32 *p, struct nfs_openargs *args)
1909 {
1910 	struct xdr_stream xdr;
1911 	struct compound_hdr hdr = {
1912 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
1913 	};
1914 
1915 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1916 	encode_compound_hdr(&xdr, req, &hdr);
1917 	encode_sequence(&xdr, &args->seq_args, &hdr);
1918 	encode_putfh(&xdr, args->fh, &hdr);
1919 	encode_savefh(&xdr, &hdr);
1920 	encode_open(&xdr, args, &hdr);
1921 	encode_getfh(&xdr, &hdr);
1922 	encode_getfattr(&xdr, args->bitmask, &hdr);
1923 	encode_restorefh(&xdr, &hdr);
1924 	encode_getfattr(&xdr, args->bitmask, &hdr);
1925 	encode_nops(&hdr);
1926 	return 0;
1927 }
1928 
1929 /*
1930  * Encode an OPEN_CONFIRM request
1931  */
1932 static int nfs4_xdr_enc_open_confirm(struct rpc_rqst *req, __be32 *p, struct nfs_open_confirmargs *args)
1933 {
1934 	struct xdr_stream xdr;
1935 	struct compound_hdr hdr = {
1936 		.nops   = 0,
1937 	};
1938 
1939 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1940 	encode_compound_hdr(&xdr, req, &hdr);
1941 	encode_putfh(&xdr, args->fh, &hdr);
1942 	encode_open_confirm(&xdr, args, &hdr);
1943 	encode_nops(&hdr);
1944 	return 0;
1945 }
1946 
1947 /*
1948  * Encode an OPEN request with no attributes.
1949  */
1950 static int nfs4_xdr_enc_open_noattr(struct rpc_rqst *req, __be32 *p, struct nfs_openargs *args)
1951 {
1952 	struct xdr_stream xdr;
1953 	struct compound_hdr hdr = {
1954 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
1955 	};
1956 
1957 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1958 	encode_compound_hdr(&xdr, req, &hdr);
1959 	encode_sequence(&xdr, &args->seq_args, &hdr);
1960 	encode_putfh(&xdr, args->fh, &hdr);
1961 	encode_open(&xdr, args, &hdr);
1962 	encode_getfattr(&xdr, args->bitmask, &hdr);
1963 	encode_nops(&hdr);
1964 	return 0;
1965 }
1966 
1967 /*
1968  * Encode an OPEN_DOWNGRADE request
1969  */
1970 static int nfs4_xdr_enc_open_downgrade(struct rpc_rqst *req, __be32 *p, struct nfs_closeargs *args)
1971 {
1972 	struct xdr_stream xdr;
1973 	struct compound_hdr hdr = {
1974 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
1975 	};
1976 
1977 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1978 	encode_compound_hdr(&xdr, req, &hdr);
1979 	encode_sequence(&xdr, &args->seq_args, &hdr);
1980 	encode_putfh(&xdr, args->fh, &hdr);
1981 	encode_open_downgrade(&xdr, args, &hdr);
1982 	encode_getfattr(&xdr, args->bitmask, &hdr);
1983 	encode_nops(&hdr);
1984 	return 0;
1985 }
1986 
1987 /*
1988  * Encode a LOCK request
1989  */
1990 static int nfs4_xdr_enc_lock(struct rpc_rqst *req, __be32 *p, struct nfs_lock_args *args)
1991 {
1992 	struct xdr_stream xdr;
1993 	struct compound_hdr hdr = {
1994 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
1995 	};
1996 
1997 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1998 	encode_compound_hdr(&xdr, req, &hdr);
1999 	encode_sequence(&xdr, &args->seq_args, &hdr);
2000 	encode_putfh(&xdr, args->fh, &hdr);
2001 	encode_lock(&xdr, args, &hdr);
2002 	encode_nops(&hdr);
2003 	return 0;
2004 }
2005 
2006 /*
2007  * Encode a LOCKT request
2008  */
2009 static int nfs4_xdr_enc_lockt(struct rpc_rqst *req, __be32 *p, struct nfs_lockt_args *args)
2010 {
2011 	struct xdr_stream xdr;
2012 	struct compound_hdr hdr = {
2013 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2014 	};
2015 
2016 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2017 	encode_compound_hdr(&xdr, req, &hdr);
2018 	encode_sequence(&xdr, &args->seq_args, &hdr);
2019 	encode_putfh(&xdr, args->fh, &hdr);
2020 	encode_lockt(&xdr, args, &hdr);
2021 	encode_nops(&hdr);
2022 	return 0;
2023 }
2024 
2025 /*
2026  * Encode a LOCKU request
2027  */
2028 static int nfs4_xdr_enc_locku(struct rpc_rqst *req, __be32 *p, struct nfs_locku_args *args)
2029 {
2030 	struct xdr_stream xdr;
2031 	struct compound_hdr hdr = {
2032 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2033 	};
2034 
2035 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2036 	encode_compound_hdr(&xdr, req, &hdr);
2037 	encode_sequence(&xdr, &args->seq_args, &hdr);
2038 	encode_putfh(&xdr, args->fh, &hdr);
2039 	encode_locku(&xdr, args, &hdr);
2040 	encode_nops(&hdr);
2041 	return 0;
2042 }
2043 
2044 /*
2045  * Encode a READLINK request
2046  */
2047 static int nfs4_xdr_enc_readlink(struct rpc_rqst *req, __be32 *p, const struct nfs4_readlink *args)
2048 {
2049 	struct xdr_stream xdr;
2050 	struct compound_hdr hdr = {
2051 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2052 	};
2053 
2054 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2055 	encode_compound_hdr(&xdr, req, &hdr);
2056 	encode_sequence(&xdr, &args->seq_args, &hdr);
2057 	encode_putfh(&xdr, args->fh, &hdr);
2058 	encode_readlink(&xdr, args, req, &hdr);
2059 
2060 	xdr_inline_pages(&req->rq_rcv_buf, hdr.replen << 2, args->pages,
2061 			args->pgbase, args->pglen);
2062 	encode_nops(&hdr);
2063 	return 0;
2064 }
2065 
2066 /*
2067  * Encode a READDIR request
2068  */
2069 static int nfs4_xdr_enc_readdir(struct rpc_rqst *req, __be32 *p, const struct nfs4_readdir_arg *args)
2070 {
2071 	struct xdr_stream xdr;
2072 	struct compound_hdr hdr = {
2073 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2074 	};
2075 
2076 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2077 	encode_compound_hdr(&xdr, req, &hdr);
2078 	encode_sequence(&xdr, &args->seq_args, &hdr);
2079 	encode_putfh(&xdr, args->fh, &hdr);
2080 	encode_readdir(&xdr, args, req, &hdr);
2081 
2082 	xdr_inline_pages(&req->rq_rcv_buf, hdr.replen << 2, args->pages,
2083 			 args->pgbase, args->count);
2084 	dprintk("%s: inlined page args = (%u, %p, %u, %u)\n",
2085 			__func__, hdr.replen << 2, args->pages,
2086 			args->pgbase, args->count);
2087 	encode_nops(&hdr);
2088 	return 0;
2089 }
2090 
2091 /*
2092  * Encode a READ request
2093  */
2094 static int nfs4_xdr_enc_read(struct rpc_rqst *req, __be32 *p, struct nfs_readargs *args)
2095 {
2096 	struct xdr_stream xdr;
2097 	struct compound_hdr hdr = {
2098 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2099 	};
2100 
2101 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2102 	encode_compound_hdr(&xdr, req, &hdr);
2103 	encode_sequence(&xdr, &args->seq_args, &hdr);
2104 	encode_putfh(&xdr, args->fh, &hdr);
2105 	encode_read(&xdr, args, &hdr);
2106 
2107 	xdr_inline_pages(&req->rq_rcv_buf, hdr.replen << 2,
2108 			 args->pages, args->pgbase, args->count);
2109 	req->rq_rcv_buf.flags |= XDRBUF_READ;
2110 	encode_nops(&hdr);
2111 	return 0;
2112 }
2113 
2114 /*
2115  * Encode an SETATTR request
2116  */
2117 static int nfs4_xdr_enc_setattr(struct rpc_rqst *req, __be32 *p, struct nfs_setattrargs *args)
2118 {
2119 	struct xdr_stream xdr;
2120 	struct compound_hdr hdr = {
2121 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2122 	};
2123 
2124 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2125 	encode_compound_hdr(&xdr, req, &hdr);
2126 	encode_sequence(&xdr, &args->seq_args, &hdr);
2127 	encode_putfh(&xdr, args->fh, &hdr);
2128 	encode_setattr(&xdr, args, args->server, &hdr);
2129 	encode_getfattr(&xdr, args->bitmask, &hdr);
2130 	encode_nops(&hdr);
2131 	return 0;
2132 }
2133 
2134 /*
2135  * Encode a GETACL request
2136  */
2137 static int
2138 nfs4_xdr_enc_getacl(struct rpc_rqst *req, __be32 *p,
2139 		struct nfs_getaclargs *args)
2140 {
2141 	struct xdr_stream xdr;
2142 	struct compound_hdr hdr = {
2143 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2144 	};
2145 	uint32_t replen;
2146 
2147 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2148 	encode_compound_hdr(&xdr, req, &hdr);
2149 	encode_sequence(&xdr, &args->seq_args, &hdr);
2150 	encode_putfh(&xdr, args->fh, &hdr);
2151 	replen = hdr.replen + op_decode_hdr_maxsz + nfs4_fattr_bitmap_maxsz + 1;
2152 	encode_getattr_two(&xdr, FATTR4_WORD0_ACL, 0, &hdr);
2153 
2154 	xdr_inline_pages(&req->rq_rcv_buf, replen << 2,
2155 		args->acl_pages, args->acl_pgbase, args->acl_len);
2156 	encode_nops(&hdr);
2157 	return 0;
2158 }
2159 
2160 /*
2161  * Encode a WRITE request
2162  */
2163 static int nfs4_xdr_enc_write(struct rpc_rqst *req, __be32 *p, struct nfs_writeargs *args)
2164 {
2165 	struct xdr_stream xdr;
2166 	struct compound_hdr hdr = {
2167 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2168 	};
2169 
2170 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2171 	encode_compound_hdr(&xdr, req, &hdr);
2172 	encode_sequence(&xdr, &args->seq_args, &hdr);
2173 	encode_putfh(&xdr, args->fh, &hdr);
2174 	encode_write(&xdr, args, &hdr);
2175 	req->rq_snd_buf.flags |= XDRBUF_WRITE;
2176 	encode_getfattr(&xdr, args->bitmask, &hdr);
2177 	encode_nops(&hdr);
2178 	return 0;
2179 }
2180 
2181 /*
2182  *  a COMMIT request
2183  */
2184 static int nfs4_xdr_enc_commit(struct rpc_rqst *req, __be32 *p, struct nfs_writeargs *args)
2185 {
2186 	struct xdr_stream xdr;
2187 	struct compound_hdr hdr = {
2188 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2189 	};
2190 
2191 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2192 	encode_compound_hdr(&xdr, req, &hdr);
2193 	encode_sequence(&xdr, &args->seq_args, &hdr);
2194 	encode_putfh(&xdr, args->fh, &hdr);
2195 	encode_commit(&xdr, args, &hdr);
2196 	encode_getfattr(&xdr, args->bitmask, &hdr);
2197 	encode_nops(&hdr);
2198 	return 0;
2199 }
2200 
2201 /*
2202  * FSINFO request
2203  */
2204 static int nfs4_xdr_enc_fsinfo(struct rpc_rqst *req, __be32 *p, struct nfs4_fsinfo_arg *args)
2205 {
2206 	struct xdr_stream xdr;
2207 	struct compound_hdr hdr = {
2208 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2209 	};
2210 
2211 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2212 	encode_compound_hdr(&xdr, req, &hdr);
2213 	encode_sequence(&xdr, &args->seq_args, &hdr);
2214 	encode_putfh(&xdr, args->fh, &hdr);
2215 	encode_fsinfo(&xdr, args->bitmask, &hdr);
2216 	encode_nops(&hdr);
2217 	return 0;
2218 }
2219 
2220 /*
2221  * a PATHCONF request
2222  */
2223 static int nfs4_xdr_enc_pathconf(struct rpc_rqst *req, __be32 *p, const struct nfs4_pathconf_arg *args)
2224 {
2225 	struct xdr_stream xdr;
2226 	struct compound_hdr hdr = {
2227 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2228 	};
2229 
2230 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2231 	encode_compound_hdr(&xdr, req, &hdr);
2232 	encode_sequence(&xdr, &args->seq_args, &hdr);
2233 	encode_putfh(&xdr, args->fh, &hdr);
2234 	encode_getattr_one(&xdr, args->bitmask[0] & nfs4_pathconf_bitmap[0],
2235 			   &hdr);
2236 	encode_nops(&hdr);
2237 	return 0;
2238 }
2239 
2240 /*
2241  * a STATFS request
2242  */
2243 static int nfs4_xdr_enc_statfs(struct rpc_rqst *req, __be32 *p, const struct nfs4_statfs_arg *args)
2244 {
2245 	struct xdr_stream xdr;
2246 	struct compound_hdr hdr = {
2247 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2248 	};
2249 
2250 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2251 	encode_compound_hdr(&xdr, req, &hdr);
2252 	encode_sequence(&xdr, &args->seq_args, &hdr);
2253 	encode_putfh(&xdr, args->fh, &hdr);
2254 	encode_getattr_two(&xdr, args->bitmask[0] & nfs4_statfs_bitmap[0],
2255 			   args->bitmask[1] & nfs4_statfs_bitmap[1], &hdr);
2256 	encode_nops(&hdr);
2257 	return 0;
2258 }
2259 
2260 /*
2261  * GETATTR_BITMAP request
2262  */
2263 static int nfs4_xdr_enc_server_caps(struct rpc_rqst *req, __be32 *p,
2264 				    struct nfs4_server_caps_arg *args)
2265 {
2266 	struct xdr_stream xdr;
2267 	struct compound_hdr hdr = {
2268 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2269 	};
2270 
2271 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2272 	encode_compound_hdr(&xdr, req, &hdr);
2273 	encode_sequence(&xdr, &args->seq_args, &hdr);
2274 	encode_putfh(&xdr, args->fhandle, &hdr);
2275 	encode_getattr_one(&xdr, FATTR4_WORD0_SUPPORTED_ATTRS|
2276 			   FATTR4_WORD0_LINK_SUPPORT|
2277 			   FATTR4_WORD0_SYMLINK_SUPPORT|
2278 			   FATTR4_WORD0_ACLSUPPORT, &hdr);
2279 	encode_nops(&hdr);
2280 	return 0;
2281 }
2282 
2283 /*
2284  * a RENEW request
2285  */
2286 static int nfs4_xdr_enc_renew(struct rpc_rqst *req, __be32 *p, struct nfs_client *clp)
2287 {
2288 	struct xdr_stream xdr;
2289 	struct compound_hdr hdr = {
2290 		.nops	= 0,
2291 	};
2292 
2293 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2294 	encode_compound_hdr(&xdr, req, &hdr);
2295 	encode_renew(&xdr, clp, &hdr);
2296 	encode_nops(&hdr);
2297 	return 0;
2298 }
2299 
2300 /*
2301  * a SETCLIENTID request
2302  */
2303 static int nfs4_xdr_enc_setclientid(struct rpc_rqst *req, __be32 *p, struct nfs4_setclientid *sc)
2304 {
2305 	struct xdr_stream xdr;
2306 	struct compound_hdr hdr = {
2307 		.nops	= 0,
2308 	};
2309 
2310 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2311 	encode_compound_hdr(&xdr, req, &hdr);
2312 	encode_setclientid(&xdr, sc, &hdr);
2313 	encode_nops(&hdr);
2314 	return 0;
2315 }
2316 
2317 /*
2318  * a SETCLIENTID_CONFIRM request
2319  */
2320 static int nfs4_xdr_enc_setclientid_confirm(struct rpc_rqst *req, __be32 *p, struct nfs_client *clp)
2321 {
2322 	struct xdr_stream xdr;
2323 	struct compound_hdr hdr = {
2324 		.nops	= 0,
2325 	};
2326 	const u32 lease_bitmap[2] = { FATTR4_WORD0_LEASE_TIME, 0 };
2327 
2328 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2329 	encode_compound_hdr(&xdr, req, &hdr);
2330 	encode_setclientid_confirm(&xdr, clp, &hdr);
2331 	encode_putrootfh(&xdr, &hdr);
2332 	encode_fsinfo(&xdr, lease_bitmap, &hdr);
2333 	encode_nops(&hdr);
2334 	return 0;
2335 }
2336 
2337 /*
2338  * DELEGRETURN request
2339  */
2340 static int nfs4_xdr_enc_delegreturn(struct rpc_rqst *req, __be32 *p, const struct nfs4_delegreturnargs *args)
2341 {
2342 	struct xdr_stream xdr;
2343 	struct compound_hdr hdr = {
2344 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2345 	};
2346 
2347 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2348 	encode_compound_hdr(&xdr, req, &hdr);
2349 	encode_sequence(&xdr, &args->seq_args, &hdr);
2350 	encode_putfh(&xdr, args->fhandle, &hdr);
2351 	encode_delegreturn(&xdr, args->stateid, &hdr);
2352 	encode_getfattr(&xdr, args->bitmask, &hdr);
2353 	encode_nops(&hdr);
2354 	return 0;
2355 }
2356 
2357 /*
2358  * Encode FS_LOCATIONS request
2359  */
2360 static int nfs4_xdr_enc_fs_locations(struct rpc_rqst *req, __be32 *p, struct nfs4_fs_locations_arg *args)
2361 {
2362 	struct xdr_stream xdr;
2363 	struct compound_hdr hdr = {
2364 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
2365 	};
2366 	uint32_t replen;
2367 
2368 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2369 	encode_compound_hdr(&xdr, req, &hdr);
2370 	encode_sequence(&xdr, &args->seq_args, &hdr);
2371 	encode_putfh(&xdr, args->dir_fh, &hdr);
2372 	encode_lookup(&xdr, args->name, &hdr);
2373 	replen = hdr.replen;	/* get the attribute into args->page */
2374 	encode_fs_locations(&xdr, args->bitmask, &hdr);
2375 
2376 	xdr_inline_pages(&req->rq_rcv_buf, replen << 2, &args->page,
2377 			0, PAGE_SIZE);
2378 	encode_nops(&hdr);
2379 	return 0;
2380 }
2381 
2382 #if defined(CONFIG_NFS_V4_1)
2383 /*
2384  * EXCHANGE_ID request
2385  */
2386 static int nfs4_xdr_enc_exchange_id(struct rpc_rqst *req, uint32_t *p,
2387 				    struct nfs41_exchange_id_args *args)
2388 {
2389 	struct xdr_stream xdr;
2390 	struct compound_hdr hdr = {
2391 		.minorversion = args->client->cl_minorversion,
2392 	};
2393 
2394 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2395 	encode_compound_hdr(&xdr, req, &hdr);
2396 	encode_exchange_id(&xdr, args, &hdr);
2397 	encode_nops(&hdr);
2398 	return 0;
2399 }
2400 
2401 /*
2402  * a CREATE_SESSION request
2403  */
2404 static int nfs4_xdr_enc_create_session(struct rpc_rqst *req, uint32_t *p,
2405 				       struct nfs41_create_session_args *args)
2406 {
2407 	struct xdr_stream xdr;
2408 	struct compound_hdr hdr = {
2409 		.minorversion = args->client->cl_minorversion,
2410 	};
2411 
2412 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2413 	encode_compound_hdr(&xdr, req, &hdr);
2414 	encode_create_session(&xdr, args, &hdr);
2415 	encode_nops(&hdr);
2416 	return 0;
2417 }
2418 
2419 /*
2420  * a DESTROY_SESSION request
2421  */
2422 static int nfs4_xdr_enc_destroy_session(struct rpc_rqst *req, uint32_t *p,
2423 					struct nfs4_session *session)
2424 {
2425 	struct xdr_stream xdr;
2426 	struct compound_hdr hdr = {
2427 		.minorversion = session->clp->cl_minorversion,
2428 	};
2429 
2430 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2431 	encode_compound_hdr(&xdr, req, &hdr);
2432 	encode_destroy_session(&xdr, session, &hdr);
2433 	encode_nops(&hdr);
2434 	return 0;
2435 }
2436 
2437 /*
2438  * a SEQUENCE request
2439  */
2440 static int nfs4_xdr_enc_sequence(struct rpc_rqst *req, uint32_t *p,
2441 				 struct nfs4_sequence_args *args)
2442 {
2443 	struct xdr_stream xdr;
2444 	struct compound_hdr hdr = {
2445 		.minorversion = nfs4_xdr_minorversion(args),
2446 	};
2447 
2448 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2449 	encode_compound_hdr(&xdr, req, &hdr);
2450 	encode_sequence(&xdr, args, &hdr);
2451 	encode_nops(&hdr);
2452 	return 0;
2453 }
2454 
2455 /*
2456  * a GET_LEASE_TIME request
2457  */
2458 static int nfs4_xdr_enc_get_lease_time(struct rpc_rqst *req, uint32_t *p,
2459 				       struct nfs4_get_lease_time_args *args)
2460 {
2461 	struct xdr_stream xdr;
2462 	struct compound_hdr hdr = {
2463 		.minorversion = nfs4_xdr_minorversion(&args->la_seq_args),
2464 	};
2465 	const u32 lease_bitmap[2] = { FATTR4_WORD0_LEASE_TIME, 0 };
2466 
2467 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2468 	encode_compound_hdr(&xdr, req, &hdr);
2469 	encode_sequence(&xdr, &args->la_seq_args, &hdr);
2470 	encode_putrootfh(&xdr, &hdr);
2471 	encode_fsinfo(&xdr, lease_bitmap, &hdr);
2472 	encode_nops(&hdr);
2473 	return 0;
2474 }
2475 
2476 /*
2477  * a RECLAIM_COMPLETE request
2478  */
2479 static int nfs4_xdr_enc_reclaim_complete(struct rpc_rqst *req, uint32_t *p,
2480 				     struct nfs41_reclaim_complete_args *args)
2481 {
2482 	struct xdr_stream xdr;
2483 	struct compound_hdr hdr = {
2484 		.minorversion = nfs4_xdr_minorversion(&args->seq_args)
2485 	};
2486 
2487 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2488 	encode_compound_hdr(&xdr, req, &hdr);
2489 	encode_sequence(&xdr, &args->seq_args, &hdr);
2490 	encode_reclaim_complete(&xdr, args, &hdr);
2491 	encode_nops(&hdr);
2492 	return 0;
2493 }
2494 
2495 #endif /* CONFIG_NFS_V4_1 */
2496 
2497 static void print_overflow_msg(const char *func, const struct xdr_stream *xdr)
2498 {
2499 	dprintk("nfs: %s: prematurely hit end of receive buffer. "
2500 		"Remaining buffer length is %tu words.\n",
2501 		func, xdr->end - xdr->p);
2502 }
2503 
2504 static int decode_opaque_inline(struct xdr_stream *xdr, unsigned int *len, char **string)
2505 {
2506 	__be32 *p;
2507 
2508 	p = xdr_inline_decode(xdr, 4);
2509 	if (unlikely(!p))
2510 		goto out_overflow;
2511 	*len = be32_to_cpup(p);
2512 	p = xdr_inline_decode(xdr, *len);
2513 	if (unlikely(!p))
2514 		goto out_overflow;
2515 	*string = (char *)p;
2516 	return 0;
2517 out_overflow:
2518 	print_overflow_msg(__func__, xdr);
2519 	return -EIO;
2520 }
2521 
2522 static int decode_compound_hdr(struct xdr_stream *xdr, struct compound_hdr *hdr)
2523 {
2524 	__be32 *p;
2525 
2526 	p = xdr_inline_decode(xdr, 8);
2527 	if (unlikely(!p))
2528 		goto out_overflow;
2529 	hdr->status = be32_to_cpup(p++);
2530 	hdr->taglen = be32_to_cpup(p);
2531 
2532 	p = xdr_inline_decode(xdr, hdr->taglen + 4);
2533 	if (unlikely(!p))
2534 		goto out_overflow;
2535 	hdr->tag = (char *)p;
2536 	p += XDR_QUADLEN(hdr->taglen);
2537 	hdr->nops = be32_to_cpup(p);
2538 	if (unlikely(hdr->nops < 1))
2539 		return nfs4_stat_to_errno(hdr->status);
2540 	return 0;
2541 out_overflow:
2542 	print_overflow_msg(__func__, xdr);
2543 	return -EIO;
2544 }
2545 
2546 static int decode_op_hdr(struct xdr_stream *xdr, enum nfs_opnum4 expected)
2547 {
2548 	__be32 *p;
2549 	uint32_t opnum;
2550 	int32_t nfserr;
2551 
2552 	p = xdr_inline_decode(xdr, 8);
2553 	if (unlikely(!p))
2554 		goto out_overflow;
2555 	opnum = be32_to_cpup(p++);
2556 	if (opnum != expected) {
2557 		dprintk("nfs: Server returned operation"
2558 			" %d but we issued a request for %d\n",
2559 				opnum, expected);
2560 		return -EIO;
2561 	}
2562 	nfserr = be32_to_cpup(p);
2563 	if (nfserr != NFS_OK)
2564 		return nfs4_stat_to_errno(nfserr);
2565 	return 0;
2566 out_overflow:
2567 	print_overflow_msg(__func__, xdr);
2568 	return -EIO;
2569 }
2570 
2571 /* Dummy routine */
2572 static int decode_ace(struct xdr_stream *xdr, void *ace, struct nfs_client *clp)
2573 {
2574 	__be32 *p;
2575 	unsigned int strlen;
2576 	char *str;
2577 
2578 	p = xdr_inline_decode(xdr, 12);
2579 	if (likely(p))
2580 		return decode_opaque_inline(xdr, &strlen, &str);
2581 	print_overflow_msg(__func__, xdr);
2582 	return -EIO;
2583 }
2584 
2585 static int decode_attr_bitmap(struct xdr_stream *xdr, uint32_t *bitmap)
2586 {
2587 	uint32_t bmlen;
2588 	__be32 *p;
2589 
2590 	p = xdr_inline_decode(xdr, 4);
2591 	if (unlikely(!p))
2592 		goto out_overflow;
2593 	bmlen = be32_to_cpup(p);
2594 
2595 	bitmap[0] = bitmap[1] = 0;
2596 	p = xdr_inline_decode(xdr, (bmlen << 2));
2597 	if (unlikely(!p))
2598 		goto out_overflow;
2599 	if (bmlen > 0) {
2600 		bitmap[0] = be32_to_cpup(p++);
2601 		if (bmlen > 1)
2602 			bitmap[1] = be32_to_cpup(p);
2603 	}
2604 	return 0;
2605 out_overflow:
2606 	print_overflow_msg(__func__, xdr);
2607 	return -EIO;
2608 }
2609 
2610 static inline int decode_attr_length(struct xdr_stream *xdr, uint32_t *attrlen, __be32 **savep)
2611 {
2612 	__be32 *p;
2613 
2614 	p = xdr_inline_decode(xdr, 4);
2615 	if (unlikely(!p))
2616 		goto out_overflow;
2617 	*attrlen = be32_to_cpup(p);
2618 	*savep = xdr->p;
2619 	return 0;
2620 out_overflow:
2621 	print_overflow_msg(__func__, xdr);
2622 	return -EIO;
2623 }
2624 
2625 static int decode_attr_supported(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *bitmask)
2626 {
2627 	if (likely(bitmap[0] & FATTR4_WORD0_SUPPORTED_ATTRS)) {
2628 		decode_attr_bitmap(xdr, bitmask);
2629 		bitmap[0] &= ~FATTR4_WORD0_SUPPORTED_ATTRS;
2630 	} else
2631 		bitmask[0] = bitmask[1] = 0;
2632 	dprintk("%s: bitmask=%08x:%08x\n", __func__, bitmask[0], bitmask[1]);
2633 	return 0;
2634 }
2635 
2636 static int decode_attr_type(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *type)
2637 {
2638 	__be32 *p;
2639 	int ret = 0;
2640 
2641 	*type = 0;
2642 	if (unlikely(bitmap[0] & (FATTR4_WORD0_TYPE - 1U)))
2643 		return -EIO;
2644 	if (likely(bitmap[0] & FATTR4_WORD0_TYPE)) {
2645 		p = xdr_inline_decode(xdr, 4);
2646 		if (unlikely(!p))
2647 			goto out_overflow;
2648 		*type = be32_to_cpup(p);
2649 		if (*type < NF4REG || *type > NF4NAMEDATTR) {
2650 			dprintk("%s: bad type %d\n", __func__, *type);
2651 			return -EIO;
2652 		}
2653 		bitmap[0] &= ~FATTR4_WORD0_TYPE;
2654 		ret = NFS_ATTR_FATTR_TYPE;
2655 	}
2656 	dprintk("%s: type=0%o\n", __func__, nfs_type2fmt[*type]);
2657 	return ret;
2658 out_overflow:
2659 	print_overflow_msg(__func__, xdr);
2660 	return -EIO;
2661 }
2662 
2663 static int decode_attr_change(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *change)
2664 {
2665 	__be32 *p;
2666 	int ret = 0;
2667 
2668 	*change = 0;
2669 	if (unlikely(bitmap[0] & (FATTR4_WORD0_CHANGE - 1U)))
2670 		return -EIO;
2671 	if (likely(bitmap[0] & FATTR4_WORD0_CHANGE)) {
2672 		p = xdr_inline_decode(xdr, 8);
2673 		if (unlikely(!p))
2674 			goto out_overflow;
2675 		xdr_decode_hyper(p, change);
2676 		bitmap[0] &= ~FATTR4_WORD0_CHANGE;
2677 		ret = NFS_ATTR_FATTR_CHANGE;
2678 	}
2679 	dprintk("%s: change attribute=%Lu\n", __func__,
2680 			(unsigned long long)*change);
2681 	return ret;
2682 out_overflow:
2683 	print_overflow_msg(__func__, xdr);
2684 	return -EIO;
2685 }
2686 
2687 static int decode_attr_size(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *size)
2688 {
2689 	__be32 *p;
2690 	int ret = 0;
2691 
2692 	*size = 0;
2693 	if (unlikely(bitmap[0] & (FATTR4_WORD0_SIZE - 1U)))
2694 		return -EIO;
2695 	if (likely(bitmap[0] & FATTR4_WORD0_SIZE)) {
2696 		p = xdr_inline_decode(xdr, 8);
2697 		if (unlikely(!p))
2698 			goto out_overflow;
2699 		xdr_decode_hyper(p, size);
2700 		bitmap[0] &= ~FATTR4_WORD0_SIZE;
2701 		ret = NFS_ATTR_FATTR_SIZE;
2702 	}
2703 	dprintk("%s: file size=%Lu\n", __func__, (unsigned long long)*size);
2704 	return ret;
2705 out_overflow:
2706 	print_overflow_msg(__func__, xdr);
2707 	return -EIO;
2708 }
2709 
2710 static int decode_attr_link_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
2711 {
2712 	__be32 *p;
2713 
2714 	*res = 0;
2715 	if (unlikely(bitmap[0] & (FATTR4_WORD0_LINK_SUPPORT - 1U)))
2716 		return -EIO;
2717 	if (likely(bitmap[0] & FATTR4_WORD0_LINK_SUPPORT)) {
2718 		p = xdr_inline_decode(xdr, 4);
2719 		if (unlikely(!p))
2720 			goto out_overflow;
2721 		*res = be32_to_cpup(p);
2722 		bitmap[0] &= ~FATTR4_WORD0_LINK_SUPPORT;
2723 	}
2724 	dprintk("%s: link support=%s\n", __func__, *res == 0 ? "false" : "true");
2725 	return 0;
2726 out_overflow:
2727 	print_overflow_msg(__func__, xdr);
2728 	return -EIO;
2729 }
2730 
2731 static int decode_attr_symlink_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
2732 {
2733 	__be32 *p;
2734 
2735 	*res = 0;
2736 	if (unlikely(bitmap[0] & (FATTR4_WORD0_SYMLINK_SUPPORT - 1U)))
2737 		return -EIO;
2738 	if (likely(bitmap[0] & FATTR4_WORD0_SYMLINK_SUPPORT)) {
2739 		p = xdr_inline_decode(xdr, 4);
2740 		if (unlikely(!p))
2741 			goto out_overflow;
2742 		*res = be32_to_cpup(p);
2743 		bitmap[0] &= ~FATTR4_WORD0_SYMLINK_SUPPORT;
2744 	}
2745 	dprintk("%s: symlink support=%s\n", __func__, *res == 0 ? "false" : "true");
2746 	return 0;
2747 out_overflow:
2748 	print_overflow_msg(__func__, xdr);
2749 	return -EIO;
2750 }
2751 
2752 static int decode_attr_fsid(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_fsid *fsid)
2753 {
2754 	__be32 *p;
2755 	int ret = 0;
2756 
2757 	fsid->major = 0;
2758 	fsid->minor = 0;
2759 	if (unlikely(bitmap[0] & (FATTR4_WORD0_FSID - 1U)))
2760 		return -EIO;
2761 	if (likely(bitmap[0] & FATTR4_WORD0_FSID)) {
2762 		p = xdr_inline_decode(xdr, 16);
2763 		if (unlikely(!p))
2764 			goto out_overflow;
2765 		p = xdr_decode_hyper(p, &fsid->major);
2766 		xdr_decode_hyper(p, &fsid->minor);
2767 		bitmap[0] &= ~FATTR4_WORD0_FSID;
2768 		ret = NFS_ATTR_FATTR_FSID;
2769 	}
2770 	dprintk("%s: fsid=(0x%Lx/0x%Lx)\n", __func__,
2771 			(unsigned long long)fsid->major,
2772 			(unsigned long long)fsid->minor);
2773 	return ret;
2774 out_overflow:
2775 	print_overflow_msg(__func__, xdr);
2776 	return -EIO;
2777 }
2778 
2779 static int decode_attr_lease_time(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
2780 {
2781 	__be32 *p;
2782 
2783 	*res = 60;
2784 	if (unlikely(bitmap[0] & (FATTR4_WORD0_LEASE_TIME - 1U)))
2785 		return -EIO;
2786 	if (likely(bitmap[0] & FATTR4_WORD0_LEASE_TIME)) {
2787 		p = xdr_inline_decode(xdr, 4);
2788 		if (unlikely(!p))
2789 			goto out_overflow;
2790 		*res = be32_to_cpup(p);
2791 		bitmap[0] &= ~FATTR4_WORD0_LEASE_TIME;
2792 	}
2793 	dprintk("%s: file size=%u\n", __func__, (unsigned int)*res);
2794 	return 0;
2795 out_overflow:
2796 	print_overflow_msg(__func__, xdr);
2797 	return -EIO;
2798 }
2799 
2800 static int decode_attr_aclsupport(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
2801 {
2802 	__be32 *p;
2803 
2804 	*res = ACL4_SUPPORT_ALLOW_ACL|ACL4_SUPPORT_DENY_ACL;
2805 	if (unlikely(bitmap[0] & (FATTR4_WORD0_ACLSUPPORT - 1U)))
2806 		return -EIO;
2807 	if (likely(bitmap[0] & FATTR4_WORD0_ACLSUPPORT)) {
2808 		p = xdr_inline_decode(xdr, 4);
2809 		if (unlikely(!p))
2810 			goto out_overflow;
2811 		*res = be32_to_cpup(p);
2812 		bitmap[0] &= ~FATTR4_WORD0_ACLSUPPORT;
2813 	}
2814 	dprintk("%s: ACLs supported=%u\n", __func__, (unsigned int)*res);
2815 	return 0;
2816 out_overflow:
2817 	print_overflow_msg(__func__, xdr);
2818 	return -EIO;
2819 }
2820 
2821 static int decode_attr_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *fileid)
2822 {
2823 	__be32 *p;
2824 	int ret = 0;
2825 
2826 	*fileid = 0;
2827 	if (unlikely(bitmap[0] & (FATTR4_WORD0_FILEID - 1U)))
2828 		return -EIO;
2829 	if (likely(bitmap[0] & FATTR4_WORD0_FILEID)) {
2830 		p = xdr_inline_decode(xdr, 8);
2831 		if (unlikely(!p))
2832 			goto out_overflow;
2833 		xdr_decode_hyper(p, fileid);
2834 		bitmap[0] &= ~FATTR4_WORD0_FILEID;
2835 		ret = NFS_ATTR_FATTR_FILEID;
2836 	}
2837 	dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid);
2838 	return ret;
2839 out_overflow:
2840 	print_overflow_msg(__func__, xdr);
2841 	return -EIO;
2842 }
2843 
2844 static int decode_attr_mounted_on_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *fileid)
2845 {
2846 	__be32 *p;
2847 	int ret = 0;
2848 
2849 	*fileid = 0;
2850 	if (unlikely(bitmap[1] & (FATTR4_WORD1_MOUNTED_ON_FILEID - 1U)))
2851 		return -EIO;
2852 	if (likely(bitmap[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)) {
2853 		p = xdr_inline_decode(xdr, 8);
2854 		if (unlikely(!p))
2855 			goto out_overflow;
2856 		xdr_decode_hyper(p, fileid);
2857 		bitmap[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID;
2858 		ret = NFS_ATTR_FATTR_FILEID;
2859 	}
2860 	dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid);
2861 	return ret;
2862 out_overflow:
2863 	print_overflow_msg(__func__, xdr);
2864 	return -EIO;
2865 }
2866 
2867 static int decode_attr_files_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
2868 {
2869 	__be32 *p;
2870 	int status = 0;
2871 
2872 	*res = 0;
2873 	if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_AVAIL - 1U)))
2874 		return -EIO;
2875 	if (likely(bitmap[0] & FATTR4_WORD0_FILES_AVAIL)) {
2876 		p = xdr_inline_decode(xdr, 8);
2877 		if (unlikely(!p))
2878 			goto out_overflow;
2879 		xdr_decode_hyper(p, res);
2880 		bitmap[0] &= ~FATTR4_WORD0_FILES_AVAIL;
2881 	}
2882 	dprintk("%s: files avail=%Lu\n", __func__, (unsigned long long)*res);
2883 	return status;
2884 out_overflow:
2885 	print_overflow_msg(__func__, xdr);
2886 	return -EIO;
2887 }
2888 
2889 static int decode_attr_files_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
2890 {
2891 	__be32 *p;
2892 	int status = 0;
2893 
2894 	*res = 0;
2895 	if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_FREE - 1U)))
2896 		return -EIO;
2897 	if (likely(bitmap[0] & FATTR4_WORD0_FILES_FREE)) {
2898 		p = xdr_inline_decode(xdr, 8);
2899 		if (unlikely(!p))
2900 			goto out_overflow;
2901 		xdr_decode_hyper(p, res);
2902 		bitmap[0] &= ~FATTR4_WORD0_FILES_FREE;
2903 	}
2904 	dprintk("%s: files free=%Lu\n", __func__, (unsigned long long)*res);
2905 	return status;
2906 out_overflow:
2907 	print_overflow_msg(__func__, xdr);
2908 	return -EIO;
2909 }
2910 
2911 static int decode_attr_files_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
2912 {
2913 	__be32 *p;
2914 	int status = 0;
2915 
2916 	*res = 0;
2917 	if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_TOTAL - 1U)))
2918 		return -EIO;
2919 	if (likely(bitmap[0] & FATTR4_WORD0_FILES_TOTAL)) {
2920 		p = xdr_inline_decode(xdr, 8);
2921 		if (unlikely(!p))
2922 			goto out_overflow;
2923 		xdr_decode_hyper(p, res);
2924 		bitmap[0] &= ~FATTR4_WORD0_FILES_TOTAL;
2925 	}
2926 	dprintk("%s: files total=%Lu\n", __func__, (unsigned long long)*res);
2927 	return status;
2928 out_overflow:
2929 	print_overflow_msg(__func__, xdr);
2930 	return -EIO;
2931 }
2932 
2933 static int decode_pathname(struct xdr_stream *xdr, struct nfs4_pathname *path)
2934 {
2935 	u32 n;
2936 	__be32 *p;
2937 	int status = 0;
2938 
2939 	p = xdr_inline_decode(xdr, 4);
2940 	if (unlikely(!p))
2941 		goto out_overflow;
2942 	n = be32_to_cpup(p);
2943 	if (n == 0)
2944 		goto root_path;
2945 	dprintk("path ");
2946 	path->ncomponents = 0;
2947 	while (path->ncomponents < n) {
2948 		struct nfs4_string *component = &path->components[path->ncomponents];
2949 		status = decode_opaque_inline(xdr, &component->len, &component->data);
2950 		if (unlikely(status != 0))
2951 			goto out_eio;
2952 		if (path->ncomponents != n)
2953 			dprintk("/");
2954 		dprintk("%s", component->data);
2955 		if (path->ncomponents < NFS4_PATHNAME_MAXCOMPONENTS)
2956 			path->ncomponents++;
2957 		else {
2958 			dprintk("cannot parse %d components in path\n", n);
2959 			goto out_eio;
2960 		}
2961 	}
2962 out:
2963 	dprintk("\n");
2964 	return status;
2965 root_path:
2966 /* a root pathname is sent as a zero component4 */
2967 	path->ncomponents = 1;
2968 	path->components[0].len=0;
2969 	path->components[0].data=NULL;
2970 	dprintk("path /\n");
2971 	goto out;
2972 out_eio:
2973 	dprintk(" status %d", status);
2974 	status = -EIO;
2975 	goto out;
2976 out_overflow:
2977 	print_overflow_msg(__func__, xdr);
2978 	return -EIO;
2979 }
2980 
2981 static int decode_attr_fs_locations(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs4_fs_locations *res)
2982 {
2983 	int n;
2984 	__be32 *p;
2985 	int status = -EIO;
2986 
2987 	if (unlikely(bitmap[0] & (FATTR4_WORD0_FS_LOCATIONS -1U)))
2988 		goto out;
2989 	status = 0;
2990 	if (unlikely(!(bitmap[0] & FATTR4_WORD0_FS_LOCATIONS)))
2991 		goto out;
2992 	dprintk("%s: fsroot ", __func__);
2993 	status = decode_pathname(xdr, &res->fs_path);
2994 	if (unlikely(status != 0))
2995 		goto out;
2996 	p = xdr_inline_decode(xdr, 4);
2997 	if (unlikely(!p))
2998 		goto out_overflow;
2999 	n = be32_to_cpup(p);
3000 	if (n <= 0)
3001 		goto out_eio;
3002 	res->nlocations = 0;
3003 	while (res->nlocations < n) {
3004 		u32 m;
3005 		struct nfs4_fs_location *loc = &res->locations[res->nlocations];
3006 
3007 		p = xdr_inline_decode(xdr, 4);
3008 		if (unlikely(!p))
3009 			goto out_overflow;
3010 		m = be32_to_cpup(p);
3011 
3012 		loc->nservers = 0;
3013 		dprintk("%s: servers ", __func__);
3014 		while (loc->nservers < m) {
3015 			struct nfs4_string *server = &loc->servers[loc->nservers];
3016 			status = decode_opaque_inline(xdr, &server->len, &server->data);
3017 			if (unlikely(status != 0))
3018 				goto out_eio;
3019 			dprintk("%s ", server->data);
3020 			if (loc->nservers < NFS4_FS_LOCATION_MAXSERVERS)
3021 				loc->nservers++;
3022 			else {
3023 				unsigned int i;
3024 				dprintk("%s: using first %u of %u servers "
3025 					"returned for location %u\n",
3026 						__func__,
3027 						NFS4_FS_LOCATION_MAXSERVERS,
3028 						m, res->nlocations);
3029 				for (i = loc->nservers; i < m; i++) {
3030 					unsigned int len;
3031 					char *data;
3032 					status = decode_opaque_inline(xdr, &len, &data);
3033 					if (unlikely(status != 0))
3034 						goto out_eio;
3035 				}
3036 			}
3037 		}
3038 		status = decode_pathname(xdr, &loc->rootpath);
3039 		if (unlikely(status != 0))
3040 			goto out_eio;
3041 		if (res->nlocations < NFS4_FS_LOCATIONS_MAXENTRIES)
3042 			res->nlocations++;
3043 	}
3044 	if (res->nlocations != 0)
3045 		status = NFS_ATTR_FATTR_V4_REFERRAL;
3046 out:
3047 	dprintk("%s: fs_locations done, error = %d\n", __func__, status);
3048 	return status;
3049 out_overflow:
3050 	print_overflow_msg(__func__, xdr);
3051 out_eio:
3052 	status = -EIO;
3053 	goto out;
3054 }
3055 
3056 static int decode_attr_maxfilesize(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
3057 {
3058 	__be32 *p;
3059 	int status = 0;
3060 
3061 	*res = 0;
3062 	if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXFILESIZE - 1U)))
3063 		return -EIO;
3064 	if (likely(bitmap[0] & FATTR4_WORD0_MAXFILESIZE)) {
3065 		p = xdr_inline_decode(xdr, 8);
3066 		if (unlikely(!p))
3067 			goto out_overflow;
3068 		xdr_decode_hyper(p, res);
3069 		bitmap[0] &= ~FATTR4_WORD0_MAXFILESIZE;
3070 	}
3071 	dprintk("%s: maxfilesize=%Lu\n", __func__, (unsigned long long)*res);
3072 	return status;
3073 out_overflow:
3074 	print_overflow_msg(__func__, xdr);
3075 	return -EIO;
3076 }
3077 
3078 static int decode_attr_maxlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *maxlink)
3079 {
3080 	__be32 *p;
3081 	int status = 0;
3082 
3083 	*maxlink = 1;
3084 	if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXLINK - 1U)))
3085 		return -EIO;
3086 	if (likely(bitmap[0] & FATTR4_WORD0_MAXLINK)) {
3087 		p = xdr_inline_decode(xdr, 4);
3088 		if (unlikely(!p))
3089 			goto out_overflow;
3090 		*maxlink = be32_to_cpup(p);
3091 		bitmap[0] &= ~FATTR4_WORD0_MAXLINK;
3092 	}
3093 	dprintk("%s: maxlink=%u\n", __func__, *maxlink);
3094 	return status;
3095 out_overflow:
3096 	print_overflow_msg(__func__, xdr);
3097 	return -EIO;
3098 }
3099 
3100 static int decode_attr_maxname(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *maxname)
3101 {
3102 	__be32 *p;
3103 	int status = 0;
3104 
3105 	*maxname = 1024;
3106 	if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXNAME - 1U)))
3107 		return -EIO;
3108 	if (likely(bitmap[0] & FATTR4_WORD0_MAXNAME)) {
3109 		p = xdr_inline_decode(xdr, 4);
3110 		if (unlikely(!p))
3111 			goto out_overflow;
3112 		*maxname = be32_to_cpup(p);
3113 		bitmap[0] &= ~FATTR4_WORD0_MAXNAME;
3114 	}
3115 	dprintk("%s: maxname=%u\n", __func__, *maxname);
3116 	return status;
3117 out_overflow:
3118 	print_overflow_msg(__func__, xdr);
3119 	return -EIO;
3120 }
3121 
3122 static int decode_attr_maxread(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
3123 {
3124 	__be32 *p;
3125 	int status = 0;
3126 
3127 	*res = 1024;
3128 	if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXREAD - 1U)))
3129 		return -EIO;
3130 	if (likely(bitmap[0] & FATTR4_WORD0_MAXREAD)) {
3131 		uint64_t maxread;
3132 		p = xdr_inline_decode(xdr, 8);
3133 		if (unlikely(!p))
3134 			goto out_overflow;
3135 		xdr_decode_hyper(p, &maxread);
3136 		if (maxread > 0x7FFFFFFF)
3137 			maxread = 0x7FFFFFFF;
3138 		*res = (uint32_t)maxread;
3139 		bitmap[0] &= ~FATTR4_WORD0_MAXREAD;
3140 	}
3141 	dprintk("%s: maxread=%lu\n", __func__, (unsigned long)*res);
3142 	return status;
3143 out_overflow:
3144 	print_overflow_msg(__func__, xdr);
3145 	return -EIO;
3146 }
3147 
3148 static int decode_attr_maxwrite(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
3149 {
3150 	__be32 *p;
3151 	int status = 0;
3152 
3153 	*res = 1024;
3154 	if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXWRITE - 1U)))
3155 		return -EIO;
3156 	if (likely(bitmap[0] & FATTR4_WORD0_MAXWRITE)) {
3157 		uint64_t maxwrite;
3158 		p = xdr_inline_decode(xdr, 8);
3159 		if (unlikely(!p))
3160 			goto out_overflow;
3161 		xdr_decode_hyper(p, &maxwrite);
3162 		if (maxwrite > 0x7FFFFFFF)
3163 			maxwrite = 0x7FFFFFFF;
3164 		*res = (uint32_t)maxwrite;
3165 		bitmap[0] &= ~FATTR4_WORD0_MAXWRITE;
3166 	}
3167 	dprintk("%s: maxwrite=%lu\n", __func__, (unsigned long)*res);
3168 	return status;
3169 out_overflow:
3170 	print_overflow_msg(__func__, xdr);
3171 	return -EIO;
3172 }
3173 
3174 static int decode_attr_mode(struct xdr_stream *xdr, uint32_t *bitmap, umode_t *mode)
3175 {
3176 	uint32_t tmp;
3177 	__be32 *p;
3178 	int ret = 0;
3179 
3180 	*mode = 0;
3181 	if (unlikely(bitmap[1] & (FATTR4_WORD1_MODE - 1U)))
3182 		return -EIO;
3183 	if (likely(bitmap[1] & FATTR4_WORD1_MODE)) {
3184 		p = xdr_inline_decode(xdr, 4);
3185 		if (unlikely(!p))
3186 			goto out_overflow;
3187 		tmp = be32_to_cpup(p);
3188 		*mode = tmp & ~S_IFMT;
3189 		bitmap[1] &= ~FATTR4_WORD1_MODE;
3190 		ret = NFS_ATTR_FATTR_MODE;
3191 	}
3192 	dprintk("%s: file mode=0%o\n", __func__, (unsigned int)*mode);
3193 	return ret;
3194 out_overflow:
3195 	print_overflow_msg(__func__, xdr);
3196 	return -EIO;
3197 }
3198 
3199 static int decode_attr_nlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *nlink)
3200 {
3201 	__be32 *p;
3202 	int ret = 0;
3203 
3204 	*nlink = 1;
3205 	if (unlikely(bitmap[1] & (FATTR4_WORD1_NUMLINKS - 1U)))
3206 		return -EIO;
3207 	if (likely(bitmap[1] & FATTR4_WORD1_NUMLINKS)) {
3208 		p = xdr_inline_decode(xdr, 4);
3209 		if (unlikely(!p))
3210 			goto out_overflow;
3211 		*nlink = be32_to_cpup(p);
3212 		bitmap[1] &= ~FATTR4_WORD1_NUMLINKS;
3213 		ret = NFS_ATTR_FATTR_NLINK;
3214 	}
3215 	dprintk("%s: nlink=%u\n", __func__, (unsigned int)*nlink);
3216 	return ret;
3217 out_overflow:
3218 	print_overflow_msg(__func__, xdr);
3219 	return -EIO;
3220 }
3221 
3222 static int decode_attr_owner(struct xdr_stream *xdr, uint32_t *bitmap,
3223 		struct nfs_client *clp, uint32_t *uid, int may_sleep)
3224 {
3225 	uint32_t len;
3226 	__be32 *p;
3227 	int ret = 0;
3228 
3229 	*uid = -2;
3230 	if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER - 1U)))
3231 		return -EIO;
3232 	if (likely(bitmap[1] & FATTR4_WORD1_OWNER)) {
3233 		p = xdr_inline_decode(xdr, 4);
3234 		if (unlikely(!p))
3235 			goto out_overflow;
3236 		len = be32_to_cpup(p);
3237 		p = xdr_inline_decode(xdr, len);
3238 		if (unlikely(!p))
3239 			goto out_overflow;
3240 		if (!may_sleep) {
3241 			/* do nothing */
3242 		} else if (len < XDR_MAX_NETOBJ) {
3243 			if (nfs_map_name_to_uid(clp, (char *)p, len, uid) == 0)
3244 				ret = NFS_ATTR_FATTR_OWNER;
3245 			else
3246 				dprintk("%s: nfs_map_name_to_uid failed!\n",
3247 						__func__);
3248 		} else
3249 			dprintk("%s: name too long (%u)!\n",
3250 					__func__, len);
3251 		bitmap[1] &= ~FATTR4_WORD1_OWNER;
3252 	}
3253 	dprintk("%s: uid=%d\n", __func__, (int)*uid);
3254 	return ret;
3255 out_overflow:
3256 	print_overflow_msg(__func__, xdr);
3257 	return -EIO;
3258 }
3259 
3260 static int decode_attr_group(struct xdr_stream *xdr, uint32_t *bitmap,
3261 		struct nfs_client *clp, uint32_t *gid, int may_sleep)
3262 {
3263 	uint32_t len;
3264 	__be32 *p;
3265 	int ret = 0;
3266 
3267 	*gid = -2;
3268 	if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER_GROUP - 1U)))
3269 		return -EIO;
3270 	if (likely(bitmap[1] & FATTR4_WORD1_OWNER_GROUP)) {
3271 		p = xdr_inline_decode(xdr, 4);
3272 		if (unlikely(!p))
3273 			goto out_overflow;
3274 		len = be32_to_cpup(p);
3275 		p = xdr_inline_decode(xdr, len);
3276 		if (unlikely(!p))
3277 			goto out_overflow;
3278 		if (!may_sleep) {
3279 			/* do nothing */
3280 		} else if (len < XDR_MAX_NETOBJ) {
3281 			if (nfs_map_group_to_gid(clp, (char *)p, len, gid) == 0)
3282 				ret = NFS_ATTR_FATTR_GROUP;
3283 			else
3284 				dprintk("%s: nfs_map_group_to_gid failed!\n",
3285 						__func__);
3286 		} else
3287 			dprintk("%s: name too long (%u)!\n",
3288 					__func__, len);
3289 		bitmap[1] &= ~FATTR4_WORD1_OWNER_GROUP;
3290 	}
3291 	dprintk("%s: gid=%d\n", __func__, (int)*gid);
3292 	return ret;
3293 out_overflow:
3294 	print_overflow_msg(__func__, xdr);
3295 	return -EIO;
3296 }
3297 
3298 static int decode_attr_rdev(struct xdr_stream *xdr, uint32_t *bitmap, dev_t *rdev)
3299 {
3300 	uint32_t major = 0, minor = 0;
3301 	__be32 *p;
3302 	int ret = 0;
3303 
3304 	*rdev = MKDEV(0,0);
3305 	if (unlikely(bitmap[1] & (FATTR4_WORD1_RAWDEV - 1U)))
3306 		return -EIO;
3307 	if (likely(bitmap[1] & FATTR4_WORD1_RAWDEV)) {
3308 		dev_t tmp;
3309 
3310 		p = xdr_inline_decode(xdr, 8);
3311 		if (unlikely(!p))
3312 			goto out_overflow;
3313 		major = be32_to_cpup(p++);
3314 		minor = be32_to_cpup(p);
3315 		tmp = MKDEV(major, minor);
3316 		if (MAJOR(tmp) == major && MINOR(tmp) == minor)
3317 			*rdev = tmp;
3318 		bitmap[1] &= ~ FATTR4_WORD1_RAWDEV;
3319 		ret = NFS_ATTR_FATTR_RDEV;
3320 	}
3321 	dprintk("%s: rdev=(0x%x:0x%x)\n", __func__, major, minor);
3322 	return ret;
3323 out_overflow:
3324 	print_overflow_msg(__func__, xdr);
3325 	return -EIO;
3326 }
3327 
3328 static int decode_attr_space_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
3329 {
3330 	__be32 *p;
3331 	int status = 0;
3332 
3333 	*res = 0;
3334 	if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_AVAIL - 1U)))
3335 		return -EIO;
3336 	if (likely(bitmap[1] & FATTR4_WORD1_SPACE_AVAIL)) {
3337 		p = xdr_inline_decode(xdr, 8);
3338 		if (unlikely(!p))
3339 			goto out_overflow;
3340 		xdr_decode_hyper(p, res);
3341 		bitmap[1] &= ~FATTR4_WORD1_SPACE_AVAIL;
3342 	}
3343 	dprintk("%s: space avail=%Lu\n", __func__, (unsigned long long)*res);
3344 	return status;
3345 out_overflow:
3346 	print_overflow_msg(__func__, xdr);
3347 	return -EIO;
3348 }
3349 
3350 static int decode_attr_space_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
3351 {
3352 	__be32 *p;
3353 	int status = 0;
3354 
3355 	*res = 0;
3356 	if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_FREE - 1U)))
3357 		return -EIO;
3358 	if (likely(bitmap[1] & FATTR4_WORD1_SPACE_FREE)) {
3359 		p = xdr_inline_decode(xdr, 8);
3360 		if (unlikely(!p))
3361 			goto out_overflow;
3362 		xdr_decode_hyper(p, res);
3363 		bitmap[1] &= ~FATTR4_WORD1_SPACE_FREE;
3364 	}
3365 	dprintk("%s: space free=%Lu\n", __func__, (unsigned long long)*res);
3366 	return status;
3367 out_overflow:
3368 	print_overflow_msg(__func__, xdr);
3369 	return -EIO;
3370 }
3371 
3372 static int decode_attr_space_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
3373 {
3374 	__be32 *p;
3375 	int status = 0;
3376 
3377 	*res = 0;
3378 	if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_TOTAL - 1U)))
3379 		return -EIO;
3380 	if (likely(bitmap[1] & FATTR4_WORD1_SPACE_TOTAL)) {
3381 		p = xdr_inline_decode(xdr, 8);
3382 		if (unlikely(!p))
3383 			goto out_overflow;
3384 		xdr_decode_hyper(p, res);
3385 		bitmap[1] &= ~FATTR4_WORD1_SPACE_TOTAL;
3386 	}
3387 	dprintk("%s: space total=%Lu\n", __func__, (unsigned long long)*res);
3388 	return status;
3389 out_overflow:
3390 	print_overflow_msg(__func__, xdr);
3391 	return -EIO;
3392 }
3393 
3394 static int decode_attr_space_used(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *used)
3395 {
3396 	__be32 *p;
3397 	int ret = 0;
3398 
3399 	*used = 0;
3400 	if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_USED - 1U)))
3401 		return -EIO;
3402 	if (likely(bitmap[1] & FATTR4_WORD1_SPACE_USED)) {
3403 		p = xdr_inline_decode(xdr, 8);
3404 		if (unlikely(!p))
3405 			goto out_overflow;
3406 		xdr_decode_hyper(p, used);
3407 		bitmap[1] &= ~FATTR4_WORD1_SPACE_USED;
3408 		ret = NFS_ATTR_FATTR_SPACE_USED;
3409 	}
3410 	dprintk("%s: space used=%Lu\n", __func__,
3411 			(unsigned long long)*used);
3412 	return ret;
3413 out_overflow:
3414 	print_overflow_msg(__func__, xdr);
3415 	return -EIO;
3416 }
3417 
3418 static int decode_attr_time(struct xdr_stream *xdr, struct timespec *time)
3419 {
3420 	__be32 *p;
3421 	uint64_t sec;
3422 	uint32_t nsec;
3423 
3424 	p = xdr_inline_decode(xdr, 12);
3425 	if (unlikely(!p))
3426 		goto out_overflow;
3427 	p = xdr_decode_hyper(p, &sec);
3428 	nsec = be32_to_cpup(p);
3429 	time->tv_sec = (time_t)sec;
3430 	time->tv_nsec = (long)nsec;
3431 	return 0;
3432 out_overflow:
3433 	print_overflow_msg(__func__, xdr);
3434 	return -EIO;
3435 }
3436 
3437 static int decode_attr_time_access(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
3438 {
3439 	int status = 0;
3440 
3441 	time->tv_sec = 0;
3442 	time->tv_nsec = 0;
3443 	if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_ACCESS - 1U)))
3444 		return -EIO;
3445 	if (likely(bitmap[1] & FATTR4_WORD1_TIME_ACCESS)) {
3446 		status = decode_attr_time(xdr, time);
3447 		if (status == 0)
3448 			status = NFS_ATTR_FATTR_ATIME;
3449 		bitmap[1] &= ~FATTR4_WORD1_TIME_ACCESS;
3450 	}
3451 	dprintk("%s: atime=%ld\n", __func__, (long)time->tv_sec);
3452 	return status;
3453 }
3454 
3455 static int decode_attr_time_metadata(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
3456 {
3457 	int status = 0;
3458 
3459 	time->tv_sec = 0;
3460 	time->tv_nsec = 0;
3461 	if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_METADATA - 1U)))
3462 		return -EIO;
3463 	if (likely(bitmap[1] & FATTR4_WORD1_TIME_METADATA)) {
3464 		status = decode_attr_time(xdr, time);
3465 		if (status == 0)
3466 			status = NFS_ATTR_FATTR_CTIME;
3467 		bitmap[1] &= ~FATTR4_WORD1_TIME_METADATA;
3468 	}
3469 	dprintk("%s: ctime=%ld\n", __func__, (long)time->tv_sec);
3470 	return status;
3471 }
3472 
3473 static int decode_attr_time_modify(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
3474 {
3475 	int status = 0;
3476 
3477 	time->tv_sec = 0;
3478 	time->tv_nsec = 0;
3479 	if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_MODIFY - 1U)))
3480 		return -EIO;
3481 	if (likely(bitmap[1] & FATTR4_WORD1_TIME_MODIFY)) {
3482 		status = decode_attr_time(xdr, time);
3483 		if (status == 0)
3484 			status = NFS_ATTR_FATTR_MTIME;
3485 		bitmap[1] &= ~FATTR4_WORD1_TIME_MODIFY;
3486 	}
3487 	dprintk("%s: mtime=%ld\n", __func__, (long)time->tv_sec);
3488 	return status;
3489 }
3490 
3491 static int verify_attr_len(struct xdr_stream *xdr, __be32 *savep, uint32_t attrlen)
3492 {
3493 	unsigned int attrwords = XDR_QUADLEN(attrlen);
3494 	unsigned int nwords = xdr->p - savep;
3495 
3496 	if (unlikely(attrwords != nwords)) {
3497 		dprintk("%s: server returned incorrect attribute length: "
3498 			"%u %c %u\n",
3499 				__func__,
3500 				attrwords << 2,
3501 				(attrwords < nwords) ? '<' : '>',
3502 				nwords << 2);
3503 		return -EIO;
3504 	}
3505 	return 0;
3506 }
3507 
3508 static int decode_change_info(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
3509 {
3510 	__be32 *p;
3511 
3512 	p = xdr_inline_decode(xdr, 20);
3513 	if (unlikely(!p))
3514 		goto out_overflow;
3515 	cinfo->atomic = be32_to_cpup(p++);
3516 	p = xdr_decode_hyper(p, &cinfo->before);
3517 	xdr_decode_hyper(p, &cinfo->after);
3518 	return 0;
3519 out_overflow:
3520 	print_overflow_msg(__func__, xdr);
3521 	return -EIO;
3522 }
3523 
3524 static int decode_access(struct xdr_stream *xdr, struct nfs4_accessres *access)
3525 {
3526 	__be32 *p;
3527 	uint32_t supp, acc;
3528 	int status;
3529 
3530 	status = decode_op_hdr(xdr, OP_ACCESS);
3531 	if (status)
3532 		return status;
3533 	p = xdr_inline_decode(xdr, 8);
3534 	if (unlikely(!p))
3535 		goto out_overflow;
3536 	supp = be32_to_cpup(p++);
3537 	acc = be32_to_cpup(p);
3538 	access->supported = supp;
3539 	access->access = acc;
3540 	return 0;
3541 out_overflow:
3542 	print_overflow_msg(__func__, xdr);
3543 	return -EIO;
3544 }
3545 
3546 static int decode_opaque_fixed(struct xdr_stream *xdr, void *buf, size_t len)
3547 {
3548 	__be32 *p;
3549 
3550 	p = xdr_inline_decode(xdr, len);
3551 	if (likely(p)) {
3552 		memcpy(buf, p, len);
3553 		return 0;
3554 	}
3555 	print_overflow_msg(__func__, xdr);
3556 	return -EIO;
3557 }
3558 
3559 static int decode_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
3560 {
3561 	return decode_opaque_fixed(xdr, stateid->data, NFS4_STATEID_SIZE);
3562 }
3563 
3564 static int decode_close(struct xdr_stream *xdr, struct nfs_closeres *res)
3565 {
3566 	int status;
3567 
3568 	status = decode_op_hdr(xdr, OP_CLOSE);
3569 	if (status != -EIO)
3570 		nfs_increment_open_seqid(status, res->seqid);
3571 	if (!status)
3572 		status = decode_stateid(xdr, &res->stateid);
3573 	return status;
3574 }
3575 
3576 static int decode_verifier(struct xdr_stream *xdr, void *verifier)
3577 {
3578 	return decode_opaque_fixed(xdr, verifier, 8);
3579 }
3580 
3581 static int decode_commit(struct xdr_stream *xdr, struct nfs_writeres *res)
3582 {
3583 	int status;
3584 
3585 	status = decode_op_hdr(xdr, OP_COMMIT);
3586 	if (!status)
3587 		status = decode_verifier(xdr, res->verf->verifier);
3588 	return status;
3589 }
3590 
3591 static int decode_create(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
3592 {
3593 	__be32 *p;
3594 	uint32_t bmlen;
3595 	int status;
3596 
3597 	status = decode_op_hdr(xdr, OP_CREATE);
3598 	if (status)
3599 		return status;
3600 	if ((status = decode_change_info(xdr, cinfo)))
3601 		return status;
3602 	p = xdr_inline_decode(xdr, 4);
3603 	if (unlikely(!p))
3604 		goto out_overflow;
3605 	bmlen = be32_to_cpup(p);
3606 	p = xdr_inline_decode(xdr, bmlen << 2);
3607 	if (likely(p))
3608 		return 0;
3609 out_overflow:
3610 	print_overflow_msg(__func__, xdr);
3611 	return -EIO;
3612 }
3613 
3614 static int decode_server_caps(struct xdr_stream *xdr, struct nfs4_server_caps_res *res)
3615 {
3616 	__be32 *savep;
3617 	uint32_t attrlen, bitmap[2] = {0};
3618 	int status;
3619 
3620 	if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
3621 		goto xdr_error;
3622 	if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
3623 		goto xdr_error;
3624 	if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
3625 		goto xdr_error;
3626 	if ((status = decode_attr_supported(xdr, bitmap, res->attr_bitmask)) != 0)
3627 		goto xdr_error;
3628 	if ((status = decode_attr_link_support(xdr, bitmap, &res->has_links)) != 0)
3629 		goto xdr_error;
3630 	if ((status = decode_attr_symlink_support(xdr, bitmap, &res->has_symlinks)) != 0)
3631 		goto xdr_error;
3632 	if ((status = decode_attr_aclsupport(xdr, bitmap, &res->acl_bitmask)) != 0)
3633 		goto xdr_error;
3634 	status = verify_attr_len(xdr, savep, attrlen);
3635 xdr_error:
3636 	dprintk("%s: xdr returned %d!\n", __func__, -status);
3637 	return status;
3638 }
3639 
3640 static int decode_statfs(struct xdr_stream *xdr, struct nfs_fsstat *fsstat)
3641 {
3642 	__be32 *savep;
3643 	uint32_t attrlen, bitmap[2] = {0};
3644 	int status;
3645 
3646 	if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
3647 		goto xdr_error;
3648 	if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
3649 		goto xdr_error;
3650 	if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
3651 		goto xdr_error;
3652 
3653 	if ((status = decode_attr_files_avail(xdr, bitmap, &fsstat->afiles)) != 0)
3654 		goto xdr_error;
3655 	if ((status = decode_attr_files_free(xdr, bitmap, &fsstat->ffiles)) != 0)
3656 		goto xdr_error;
3657 	if ((status = decode_attr_files_total(xdr, bitmap, &fsstat->tfiles)) != 0)
3658 		goto xdr_error;
3659 	if ((status = decode_attr_space_avail(xdr, bitmap, &fsstat->abytes)) != 0)
3660 		goto xdr_error;
3661 	if ((status = decode_attr_space_free(xdr, bitmap, &fsstat->fbytes)) != 0)
3662 		goto xdr_error;
3663 	if ((status = decode_attr_space_total(xdr, bitmap, &fsstat->tbytes)) != 0)
3664 		goto xdr_error;
3665 
3666 	status = verify_attr_len(xdr, savep, attrlen);
3667 xdr_error:
3668 	dprintk("%s: xdr returned %d!\n", __func__, -status);
3669 	return status;
3670 }
3671 
3672 static int decode_pathconf(struct xdr_stream *xdr, struct nfs_pathconf *pathconf)
3673 {
3674 	__be32 *savep;
3675 	uint32_t attrlen, bitmap[2] = {0};
3676 	int status;
3677 
3678 	if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
3679 		goto xdr_error;
3680 	if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
3681 		goto xdr_error;
3682 	if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
3683 		goto xdr_error;
3684 
3685 	if ((status = decode_attr_maxlink(xdr, bitmap, &pathconf->max_link)) != 0)
3686 		goto xdr_error;
3687 	if ((status = decode_attr_maxname(xdr, bitmap, &pathconf->max_namelen)) != 0)
3688 		goto xdr_error;
3689 
3690 	status = verify_attr_len(xdr, savep, attrlen);
3691 xdr_error:
3692 	dprintk("%s: xdr returned %d!\n", __func__, -status);
3693 	return status;
3694 }
3695 
3696 static int decode_getfattr(struct xdr_stream *xdr, struct nfs_fattr *fattr,
3697 		const struct nfs_server *server, int may_sleep)
3698 {
3699 	__be32 *savep;
3700 	uint32_t attrlen,
3701 		 bitmap[2] = {0},
3702 		 type;
3703 	int status;
3704 	umode_t fmode = 0;
3705 	uint64_t fileid;
3706 
3707 	status = decode_op_hdr(xdr, OP_GETATTR);
3708 	if (status < 0)
3709 		goto xdr_error;
3710 
3711 	status = decode_attr_bitmap(xdr, bitmap);
3712 	if (status < 0)
3713 		goto xdr_error;
3714 
3715 	status = decode_attr_length(xdr, &attrlen, &savep);
3716 	if (status < 0)
3717 		goto xdr_error;
3718 
3719 
3720 	status = decode_attr_type(xdr, bitmap, &type);
3721 	if (status < 0)
3722 		goto xdr_error;
3723 	fattr->mode = 0;
3724 	if (status != 0) {
3725 		fattr->mode |= nfs_type2fmt[type];
3726 		fattr->valid |= status;
3727 	}
3728 
3729 	status = decode_attr_change(xdr, bitmap, &fattr->change_attr);
3730 	if (status < 0)
3731 		goto xdr_error;
3732 	fattr->valid |= status;
3733 
3734 	status = decode_attr_size(xdr, bitmap, &fattr->size);
3735 	if (status < 0)
3736 		goto xdr_error;
3737 	fattr->valid |= status;
3738 
3739 	status = decode_attr_fsid(xdr, bitmap, &fattr->fsid);
3740 	if (status < 0)
3741 		goto xdr_error;
3742 	fattr->valid |= status;
3743 
3744 	status = decode_attr_fileid(xdr, bitmap, &fattr->fileid);
3745 	if (status < 0)
3746 		goto xdr_error;
3747 	fattr->valid |= status;
3748 
3749 	status = decode_attr_fs_locations(xdr, bitmap, container_of(fattr,
3750 						struct nfs4_fs_locations,
3751 						fattr));
3752 	if (status < 0)
3753 		goto xdr_error;
3754 	fattr->valid |= status;
3755 
3756 	status = decode_attr_mode(xdr, bitmap, &fmode);
3757 	if (status < 0)
3758 		goto xdr_error;
3759 	if (status != 0) {
3760 		fattr->mode |= fmode;
3761 		fattr->valid |= status;
3762 	}
3763 
3764 	status = decode_attr_nlink(xdr, bitmap, &fattr->nlink);
3765 	if (status < 0)
3766 		goto xdr_error;
3767 	fattr->valid |= status;
3768 
3769 	status = decode_attr_owner(xdr, bitmap, server->nfs_client,
3770 			&fattr->uid, may_sleep);
3771 	if (status < 0)
3772 		goto xdr_error;
3773 	fattr->valid |= status;
3774 
3775 	status = decode_attr_group(xdr, bitmap, server->nfs_client,
3776 			&fattr->gid, may_sleep);
3777 	if (status < 0)
3778 		goto xdr_error;
3779 	fattr->valid |= status;
3780 
3781 	status = decode_attr_rdev(xdr, bitmap, &fattr->rdev);
3782 	if (status < 0)
3783 		goto xdr_error;
3784 	fattr->valid |= status;
3785 
3786 	status = decode_attr_space_used(xdr, bitmap, &fattr->du.nfs3.used);
3787 	if (status < 0)
3788 		goto xdr_error;
3789 	fattr->valid |= status;
3790 
3791 	status = decode_attr_time_access(xdr, bitmap, &fattr->atime);
3792 	if (status < 0)
3793 		goto xdr_error;
3794 	fattr->valid |= status;
3795 
3796 	status = decode_attr_time_metadata(xdr, bitmap, &fattr->ctime);
3797 	if (status < 0)
3798 		goto xdr_error;
3799 	fattr->valid |= status;
3800 
3801 	status = decode_attr_time_modify(xdr, bitmap, &fattr->mtime);
3802 	if (status < 0)
3803 		goto xdr_error;
3804 	fattr->valid |= status;
3805 
3806 	status = decode_attr_mounted_on_fileid(xdr, bitmap, &fileid);
3807 	if (status < 0)
3808 		goto xdr_error;
3809 	if (status != 0 && !(fattr->valid & status)) {
3810 		fattr->fileid = fileid;
3811 		fattr->valid |= status;
3812 	}
3813 
3814 	status = verify_attr_len(xdr, savep, attrlen);
3815 xdr_error:
3816 	dprintk("%s: xdr returned %d\n", __func__, -status);
3817 	return status;
3818 }
3819 
3820 
3821 static int decode_fsinfo(struct xdr_stream *xdr, struct nfs_fsinfo *fsinfo)
3822 {
3823 	__be32 *savep;
3824 	uint32_t attrlen, bitmap[2];
3825 	int status;
3826 
3827 	if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
3828 		goto xdr_error;
3829 	if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
3830 		goto xdr_error;
3831 	if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
3832 		goto xdr_error;
3833 
3834 	fsinfo->rtmult = fsinfo->wtmult = 512;	/* ??? */
3835 
3836 	if ((status = decode_attr_lease_time(xdr, bitmap, &fsinfo->lease_time)) != 0)
3837 		goto xdr_error;
3838 	if ((status = decode_attr_maxfilesize(xdr, bitmap, &fsinfo->maxfilesize)) != 0)
3839 		goto xdr_error;
3840 	if ((status = decode_attr_maxread(xdr, bitmap, &fsinfo->rtmax)) != 0)
3841 		goto xdr_error;
3842 	fsinfo->rtpref = fsinfo->dtpref = fsinfo->rtmax;
3843 	if ((status = decode_attr_maxwrite(xdr, bitmap, &fsinfo->wtmax)) != 0)
3844 		goto xdr_error;
3845 	fsinfo->wtpref = fsinfo->wtmax;
3846 
3847 	status = verify_attr_len(xdr, savep, attrlen);
3848 xdr_error:
3849 	dprintk("%s: xdr returned %d!\n", __func__, -status);
3850 	return status;
3851 }
3852 
3853 static int decode_getfh(struct xdr_stream *xdr, struct nfs_fh *fh)
3854 {
3855 	__be32 *p;
3856 	uint32_t len;
3857 	int status;
3858 
3859 	/* Zero handle first to allow comparisons */
3860 	memset(fh, 0, sizeof(*fh));
3861 
3862 	status = decode_op_hdr(xdr, OP_GETFH);
3863 	if (status)
3864 		return status;
3865 
3866 	p = xdr_inline_decode(xdr, 4);
3867 	if (unlikely(!p))
3868 		goto out_overflow;
3869 	len = be32_to_cpup(p);
3870 	if (len > NFS4_FHSIZE)
3871 		return -EIO;
3872 	fh->size = len;
3873 	p = xdr_inline_decode(xdr, len);
3874 	if (unlikely(!p))
3875 		goto out_overflow;
3876 	memcpy(fh->data, p, len);
3877 	return 0;
3878 out_overflow:
3879 	print_overflow_msg(__func__, xdr);
3880 	return -EIO;
3881 }
3882 
3883 static int decode_link(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
3884 {
3885 	int status;
3886 
3887 	status = decode_op_hdr(xdr, OP_LINK);
3888 	if (status)
3889 		return status;
3890 	return decode_change_info(xdr, cinfo);
3891 }
3892 
3893 /*
3894  * We create the owner, so we know a proper owner.id length is 4.
3895  */
3896 static int decode_lock_denied (struct xdr_stream *xdr, struct file_lock *fl)
3897 {
3898 	uint64_t offset, length, clientid;
3899 	__be32 *p;
3900 	uint32_t namelen, type;
3901 
3902 	p = xdr_inline_decode(xdr, 32);
3903 	if (unlikely(!p))
3904 		goto out_overflow;
3905 	p = xdr_decode_hyper(p, &offset);
3906 	p = xdr_decode_hyper(p, &length);
3907 	type = be32_to_cpup(p++);
3908 	if (fl != NULL) {
3909 		fl->fl_start = (loff_t)offset;
3910 		fl->fl_end = fl->fl_start + (loff_t)length - 1;
3911 		if (length == ~(uint64_t)0)
3912 			fl->fl_end = OFFSET_MAX;
3913 		fl->fl_type = F_WRLCK;
3914 		if (type & 1)
3915 			fl->fl_type = F_RDLCK;
3916 		fl->fl_pid = 0;
3917 	}
3918 	p = xdr_decode_hyper(p, &clientid);
3919 	namelen = be32_to_cpup(p);
3920 	p = xdr_inline_decode(xdr, namelen);
3921 	if (likely(p))
3922 		return -NFS4ERR_DENIED;
3923 out_overflow:
3924 	print_overflow_msg(__func__, xdr);
3925 	return -EIO;
3926 }
3927 
3928 static int decode_lock(struct xdr_stream *xdr, struct nfs_lock_res *res)
3929 {
3930 	int status;
3931 
3932 	status = decode_op_hdr(xdr, OP_LOCK);
3933 	if (status == -EIO)
3934 		goto out;
3935 	if (status == 0) {
3936 		status = decode_stateid(xdr, &res->stateid);
3937 		if (unlikely(status))
3938 			goto out;
3939 	} else if (status == -NFS4ERR_DENIED)
3940 		status = decode_lock_denied(xdr, NULL);
3941 	if (res->open_seqid != NULL)
3942 		nfs_increment_open_seqid(status, res->open_seqid);
3943 	nfs_increment_lock_seqid(status, res->lock_seqid);
3944 out:
3945 	return status;
3946 }
3947 
3948 static int decode_lockt(struct xdr_stream *xdr, struct nfs_lockt_res *res)
3949 {
3950 	int status;
3951 	status = decode_op_hdr(xdr, OP_LOCKT);
3952 	if (status == -NFS4ERR_DENIED)
3953 		return decode_lock_denied(xdr, res->denied);
3954 	return status;
3955 }
3956 
3957 static int decode_locku(struct xdr_stream *xdr, struct nfs_locku_res *res)
3958 {
3959 	int status;
3960 
3961 	status = decode_op_hdr(xdr, OP_LOCKU);
3962 	if (status != -EIO)
3963 		nfs_increment_lock_seqid(status, res->seqid);
3964 	if (status == 0)
3965 		status = decode_stateid(xdr, &res->stateid);
3966 	return status;
3967 }
3968 
3969 static int decode_lookup(struct xdr_stream *xdr)
3970 {
3971 	return decode_op_hdr(xdr, OP_LOOKUP);
3972 }
3973 
3974 /* This is too sick! */
3975 static int decode_space_limit(struct xdr_stream *xdr, u64 *maxsize)
3976 {
3977 	__be32 *p;
3978 	uint32_t limit_type, nblocks, blocksize;
3979 
3980 	p = xdr_inline_decode(xdr, 12);
3981 	if (unlikely(!p))
3982 		goto out_overflow;
3983 	limit_type = be32_to_cpup(p++);
3984 	switch (limit_type) {
3985 	case 1:
3986 		xdr_decode_hyper(p, maxsize);
3987 		break;
3988 	case 2:
3989 		nblocks = be32_to_cpup(p++);
3990 		blocksize = be32_to_cpup(p);
3991 		*maxsize = (uint64_t)nblocks * (uint64_t)blocksize;
3992 	}
3993 	return 0;
3994 out_overflow:
3995 	print_overflow_msg(__func__, xdr);
3996 	return -EIO;
3997 }
3998 
3999 static int decode_delegation(struct xdr_stream *xdr, struct nfs_openres *res)
4000 {
4001 	__be32 *p;
4002 	uint32_t delegation_type;
4003 	int status;
4004 
4005 	p = xdr_inline_decode(xdr, 4);
4006 	if (unlikely(!p))
4007 		goto out_overflow;
4008 	delegation_type = be32_to_cpup(p);
4009 	if (delegation_type == NFS4_OPEN_DELEGATE_NONE) {
4010 		res->delegation_type = 0;
4011 		return 0;
4012 	}
4013 	status = decode_stateid(xdr, &res->delegation);
4014 	if (unlikely(status))
4015 		return status;
4016 	p = xdr_inline_decode(xdr, 4);
4017 	if (unlikely(!p))
4018 		goto out_overflow;
4019 	res->do_recall = be32_to_cpup(p);
4020 
4021 	switch (delegation_type) {
4022 	case NFS4_OPEN_DELEGATE_READ:
4023 		res->delegation_type = FMODE_READ;
4024 		break;
4025 	case NFS4_OPEN_DELEGATE_WRITE:
4026 		res->delegation_type = FMODE_WRITE|FMODE_READ;
4027 		if (decode_space_limit(xdr, &res->maxsize) < 0)
4028 				return -EIO;
4029 	}
4030 	return decode_ace(xdr, NULL, res->server->nfs_client);
4031 out_overflow:
4032 	print_overflow_msg(__func__, xdr);
4033 	return -EIO;
4034 }
4035 
4036 static int decode_open(struct xdr_stream *xdr, struct nfs_openres *res)
4037 {
4038 	__be32 *p;
4039 	uint32_t savewords, bmlen, i;
4040 	int status;
4041 
4042 	status = decode_op_hdr(xdr, OP_OPEN);
4043 	if (status != -EIO)
4044 		nfs_increment_open_seqid(status, res->seqid);
4045 	if (!status)
4046 		status = decode_stateid(xdr, &res->stateid);
4047 	if (unlikely(status))
4048 		return status;
4049 
4050 	decode_change_info(xdr, &res->cinfo);
4051 
4052 	p = xdr_inline_decode(xdr, 8);
4053 	if (unlikely(!p))
4054 		goto out_overflow;
4055 	res->rflags = be32_to_cpup(p++);
4056 	bmlen = be32_to_cpup(p);
4057 	if (bmlen > 10)
4058 		goto xdr_error;
4059 
4060 	p = xdr_inline_decode(xdr, bmlen << 2);
4061 	if (unlikely(!p))
4062 		goto out_overflow;
4063 	savewords = min_t(uint32_t, bmlen, NFS4_BITMAP_SIZE);
4064 	for (i = 0; i < savewords; ++i)
4065 		res->attrset[i] = be32_to_cpup(p++);
4066 	for (; i < NFS4_BITMAP_SIZE; i++)
4067 		res->attrset[i] = 0;
4068 
4069 	return decode_delegation(xdr, res);
4070 xdr_error:
4071 	dprintk("%s: Bitmap too large! Length = %u\n", __func__, bmlen);
4072 	return -EIO;
4073 out_overflow:
4074 	print_overflow_msg(__func__, xdr);
4075 	return -EIO;
4076 }
4077 
4078 static int decode_open_confirm(struct xdr_stream *xdr, struct nfs_open_confirmres *res)
4079 {
4080 	int status;
4081 
4082 	status = decode_op_hdr(xdr, OP_OPEN_CONFIRM);
4083 	if (status != -EIO)
4084 		nfs_increment_open_seqid(status, res->seqid);
4085 	if (!status)
4086 		status = decode_stateid(xdr, &res->stateid);
4087 	return status;
4088 }
4089 
4090 static int decode_open_downgrade(struct xdr_stream *xdr, struct nfs_closeres *res)
4091 {
4092 	int status;
4093 
4094 	status = decode_op_hdr(xdr, OP_OPEN_DOWNGRADE);
4095 	if (status != -EIO)
4096 		nfs_increment_open_seqid(status, res->seqid);
4097 	if (!status)
4098 		status = decode_stateid(xdr, &res->stateid);
4099 	return status;
4100 }
4101 
4102 static int decode_putfh(struct xdr_stream *xdr)
4103 {
4104 	return decode_op_hdr(xdr, OP_PUTFH);
4105 }
4106 
4107 static int decode_putrootfh(struct xdr_stream *xdr)
4108 {
4109 	return decode_op_hdr(xdr, OP_PUTROOTFH);
4110 }
4111 
4112 static int decode_read(struct xdr_stream *xdr, struct rpc_rqst *req, struct nfs_readres *res)
4113 {
4114 	struct kvec *iov = req->rq_rcv_buf.head;
4115 	__be32 *p;
4116 	uint32_t count, eof, recvd, hdrlen;
4117 	int status;
4118 
4119 	status = decode_op_hdr(xdr, OP_READ);
4120 	if (status)
4121 		return status;
4122 	p = xdr_inline_decode(xdr, 8);
4123 	if (unlikely(!p))
4124 		goto out_overflow;
4125 	eof = be32_to_cpup(p++);
4126 	count = be32_to_cpup(p);
4127 	hdrlen = (u8 *) p - (u8 *) iov->iov_base;
4128 	recvd = req->rq_rcv_buf.len - hdrlen;
4129 	if (count > recvd) {
4130 		dprintk("NFS: server cheating in read reply: "
4131 				"count %u > recvd %u\n", count, recvd);
4132 		count = recvd;
4133 		eof = 0;
4134 	}
4135 	xdr_read_pages(xdr, count);
4136 	res->eof = eof;
4137 	res->count = count;
4138 	return 0;
4139 out_overflow:
4140 	print_overflow_msg(__func__, xdr);
4141 	return -EIO;
4142 }
4143 
4144 static int decode_readdir(struct xdr_stream *xdr, struct rpc_rqst *req, struct nfs4_readdir_res *readdir)
4145 {
4146 	struct xdr_buf	*rcvbuf = &req->rq_rcv_buf;
4147 	struct page	*page = *rcvbuf->pages;
4148 	struct kvec	*iov = rcvbuf->head;
4149 	size_t		hdrlen;
4150 	u32		recvd, pglen = rcvbuf->page_len;
4151 	__be32		*end, *entry, *p, *kaddr;
4152 	unsigned int	nr = 0;
4153 	int		status;
4154 
4155 	status = decode_op_hdr(xdr, OP_READDIR);
4156 	if (!status)
4157 		status = decode_verifier(xdr, readdir->verifier.data);
4158 	if (unlikely(status))
4159 		return status;
4160 	dprintk("%s: verifier = %08x:%08x\n",
4161 			__func__,
4162 			((u32 *)readdir->verifier.data)[0],
4163 			((u32 *)readdir->verifier.data)[1]);
4164 
4165 
4166 	hdrlen = (char *) xdr->p - (char *) iov->iov_base;
4167 	recvd = rcvbuf->len - hdrlen;
4168 	if (pglen > recvd)
4169 		pglen = recvd;
4170 	xdr_read_pages(xdr, pglen);
4171 
4172 	BUG_ON(pglen + readdir->pgbase > PAGE_CACHE_SIZE);
4173 	kaddr = p = kmap_atomic(page, KM_USER0);
4174 	end = p + ((pglen + readdir->pgbase) >> 2);
4175 	entry = p;
4176 
4177 	/* Make sure the packet actually has a value_follows and EOF entry */
4178 	if ((entry + 1) > end)
4179 		goto short_pkt;
4180 
4181 	for (; *p++; nr++) {
4182 		u32 len, attrlen, xlen;
4183 		if (end - p < 3)
4184 			goto short_pkt;
4185 		dprintk("cookie = %Lu, ", *((unsigned long long *)p));
4186 		p += 2;			/* cookie */
4187 		len = ntohl(*p++);	/* filename length */
4188 		if (len > NFS4_MAXNAMLEN) {
4189 			dprintk("NFS: giant filename in readdir (len 0x%x)\n",
4190 					len);
4191 			goto err_unmap;
4192 		}
4193 		xlen = XDR_QUADLEN(len);
4194 		if (end - p < xlen + 1)
4195 			goto short_pkt;
4196 		dprintk("filename = %*s\n", len, (char *)p);
4197 		p += xlen;
4198 		len = ntohl(*p++);	/* bitmap length */
4199 		if (end - p < len + 1)
4200 			goto short_pkt;
4201 		p += len;
4202 		attrlen = XDR_QUADLEN(ntohl(*p++));
4203 		if (end - p < attrlen + 2)
4204 			goto short_pkt;
4205 		p += attrlen;		/* attributes */
4206 		entry = p;
4207 	}
4208 	/*
4209 	 * Apparently some server sends responses that are a valid size, but
4210 	 * contain no entries, and have value_follows==0 and EOF==0. For
4211 	 * those, just set the EOF marker.
4212 	 */
4213 	if (!nr && entry[1] == 0) {
4214 		dprintk("NFS: readdir reply truncated!\n");
4215 		entry[1] = 1;
4216 	}
4217 out:
4218 	kunmap_atomic(kaddr, KM_USER0);
4219 	return 0;
4220 short_pkt:
4221 	/*
4222 	 * When we get a short packet there are 2 possibilities. We can
4223 	 * return an error, or fix up the response to look like a valid
4224 	 * response and return what we have so far. If there are no
4225 	 * entries and the packet was short, then return -EIO. If there
4226 	 * are valid entries in the response, return them and pretend that
4227 	 * the call was successful, but incomplete. The caller can retry the
4228 	 * readdir starting at the last cookie.
4229 	 */
4230 	dprintk("%s: short packet at entry %d\n", __func__, nr);
4231 	entry[0] = entry[1] = 0;
4232 	if (nr)
4233 		goto out;
4234 err_unmap:
4235 	kunmap_atomic(kaddr, KM_USER0);
4236 	return -errno_NFSERR_IO;
4237 }
4238 
4239 static int decode_readlink(struct xdr_stream *xdr, struct rpc_rqst *req)
4240 {
4241 	struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
4242 	struct kvec *iov = rcvbuf->head;
4243 	size_t hdrlen;
4244 	u32 len, recvd;
4245 	__be32 *p;
4246 	char *kaddr;
4247 	int status;
4248 
4249 	status = decode_op_hdr(xdr, OP_READLINK);
4250 	if (status)
4251 		return status;
4252 
4253 	/* Convert length of symlink */
4254 	p = xdr_inline_decode(xdr, 4);
4255 	if (unlikely(!p))
4256 		goto out_overflow;
4257 	len = be32_to_cpup(p);
4258 	if (len >= rcvbuf->page_len || len <= 0) {
4259 		dprintk("nfs: server returned giant symlink!\n");
4260 		return -ENAMETOOLONG;
4261 	}
4262 	hdrlen = (char *) xdr->p - (char *) iov->iov_base;
4263 	recvd = req->rq_rcv_buf.len - hdrlen;
4264 	if (recvd < len) {
4265 		dprintk("NFS: server cheating in readlink reply: "
4266 				"count %u > recvd %u\n", len, recvd);
4267 		return -EIO;
4268 	}
4269 	xdr_read_pages(xdr, len);
4270 	/*
4271 	 * The XDR encode routine has set things up so that
4272 	 * the link text will be copied directly into the
4273 	 * buffer.  We just have to do overflow-checking,
4274 	 * and and null-terminate the text (the VFS expects
4275 	 * null-termination).
4276 	 */
4277 	kaddr = (char *)kmap_atomic(rcvbuf->pages[0], KM_USER0);
4278 	kaddr[len+rcvbuf->page_base] = '\0';
4279 	kunmap_atomic(kaddr, KM_USER0);
4280 	return 0;
4281 out_overflow:
4282 	print_overflow_msg(__func__, xdr);
4283 	return -EIO;
4284 }
4285 
4286 static int decode_remove(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
4287 {
4288 	int status;
4289 
4290 	status = decode_op_hdr(xdr, OP_REMOVE);
4291 	if (status)
4292 		goto out;
4293 	status = decode_change_info(xdr, cinfo);
4294 out:
4295 	return status;
4296 }
4297 
4298 static int decode_rename(struct xdr_stream *xdr, struct nfs4_change_info *old_cinfo,
4299 	      struct nfs4_change_info *new_cinfo)
4300 {
4301 	int status;
4302 
4303 	status = decode_op_hdr(xdr, OP_RENAME);
4304 	if (status)
4305 		goto out;
4306 	if ((status = decode_change_info(xdr, old_cinfo)))
4307 		goto out;
4308 	status = decode_change_info(xdr, new_cinfo);
4309 out:
4310 	return status;
4311 }
4312 
4313 static int decode_renew(struct xdr_stream *xdr)
4314 {
4315 	return decode_op_hdr(xdr, OP_RENEW);
4316 }
4317 
4318 static int
4319 decode_restorefh(struct xdr_stream *xdr)
4320 {
4321 	return decode_op_hdr(xdr, OP_RESTOREFH);
4322 }
4323 
4324 static int decode_getacl(struct xdr_stream *xdr, struct rpc_rqst *req,
4325 		size_t *acl_len)
4326 {
4327 	__be32 *savep;
4328 	uint32_t attrlen,
4329 		 bitmap[2] = {0};
4330 	struct kvec *iov = req->rq_rcv_buf.head;
4331 	int status;
4332 
4333 	*acl_len = 0;
4334 	if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
4335 		goto out;
4336 	if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
4337 		goto out;
4338 	if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
4339 		goto out;
4340 
4341 	if (unlikely(bitmap[0] & (FATTR4_WORD0_ACL - 1U)))
4342 		return -EIO;
4343 	if (likely(bitmap[0] & FATTR4_WORD0_ACL)) {
4344 		size_t hdrlen;
4345 		u32 recvd;
4346 
4347 		/* We ignore &savep and don't do consistency checks on
4348 		 * the attr length.  Let userspace figure it out.... */
4349 		hdrlen = (u8 *)xdr->p - (u8 *)iov->iov_base;
4350 		recvd = req->rq_rcv_buf.len - hdrlen;
4351 		if (attrlen > recvd) {
4352 			dprintk("NFS: server cheating in getattr"
4353 					" acl reply: attrlen %u > recvd %u\n",
4354 					attrlen, recvd);
4355 			return -EINVAL;
4356 		}
4357 		xdr_read_pages(xdr, attrlen);
4358 		*acl_len = attrlen;
4359 	} else
4360 		status = -EOPNOTSUPP;
4361 
4362 out:
4363 	return status;
4364 }
4365 
4366 static int
4367 decode_savefh(struct xdr_stream *xdr)
4368 {
4369 	return decode_op_hdr(xdr, OP_SAVEFH);
4370 }
4371 
4372 static int decode_setattr(struct xdr_stream *xdr)
4373 {
4374 	__be32 *p;
4375 	uint32_t bmlen;
4376 	int status;
4377 
4378 	status = decode_op_hdr(xdr, OP_SETATTR);
4379 	if (status)
4380 		return status;
4381 	p = xdr_inline_decode(xdr, 4);
4382 	if (unlikely(!p))
4383 		goto out_overflow;
4384 	bmlen = be32_to_cpup(p);
4385 	p = xdr_inline_decode(xdr, bmlen << 2);
4386 	if (likely(p))
4387 		return 0;
4388 out_overflow:
4389 	print_overflow_msg(__func__, xdr);
4390 	return -EIO;
4391 }
4392 
4393 static int decode_setclientid(struct xdr_stream *xdr, struct nfs_client *clp)
4394 {
4395 	__be32 *p;
4396 	uint32_t opnum;
4397 	int32_t nfserr;
4398 
4399 	p = xdr_inline_decode(xdr, 8);
4400 	if (unlikely(!p))
4401 		goto out_overflow;
4402 	opnum = be32_to_cpup(p++);
4403 	if (opnum != OP_SETCLIENTID) {
4404 		dprintk("nfs: decode_setclientid: Server returned operation"
4405 			" %d\n", opnum);
4406 		return -EIO;
4407 	}
4408 	nfserr = be32_to_cpup(p);
4409 	if (nfserr == NFS_OK) {
4410 		p = xdr_inline_decode(xdr, 8 + NFS4_VERIFIER_SIZE);
4411 		if (unlikely(!p))
4412 			goto out_overflow;
4413 		p = xdr_decode_hyper(p, &clp->cl_clientid);
4414 		memcpy(clp->cl_confirm.data, p, NFS4_VERIFIER_SIZE);
4415 	} else if (nfserr == NFSERR_CLID_INUSE) {
4416 		uint32_t len;
4417 
4418 		/* skip netid string */
4419 		p = xdr_inline_decode(xdr, 4);
4420 		if (unlikely(!p))
4421 			goto out_overflow;
4422 		len = be32_to_cpup(p);
4423 		p = xdr_inline_decode(xdr, len);
4424 		if (unlikely(!p))
4425 			goto out_overflow;
4426 
4427 		/* skip uaddr string */
4428 		p = xdr_inline_decode(xdr, 4);
4429 		if (unlikely(!p))
4430 			goto out_overflow;
4431 		len = be32_to_cpup(p);
4432 		p = xdr_inline_decode(xdr, len);
4433 		if (unlikely(!p))
4434 			goto out_overflow;
4435 		return -NFSERR_CLID_INUSE;
4436 	} else
4437 		return nfs4_stat_to_errno(nfserr);
4438 
4439 	return 0;
4440 out_overflow:
4441 	print_overflow_msg(__func__, xdr);
4442 	return -EIO;
4443 }
4444 
4445 static int decode_setclientid_confirm(struct xdr_stream *xdr)
4446 {
4447 	return decode_op_hdr(xdr, OP_SETCLIENTID_CONFIRM);
4448 }
4449 
4450 static int decode_write(struct xdr_stream *xdr, struct nfs_writeres *res)
4451 {
4452 	__be32 *p;
4453 	int status;
4454 
4455 	status = decode_op_hdr(xdr, OP_WRITE);
4456 	if (status)
4457 		return status;
4458 
4459 	p = xdr_inline_decode(xdr, 16);
4460 	if (unlikely(!p))
4461 		goto out_overflow;
4462 	res->count = be32_to_cpup(p++);
4463 	res->verf->committed = be32_to_cpup(p++);
4464 	memcpy(res->verf->verifier, p, 8);
4465 	return 0;
4466 out_overflow:
4467 	print_overflow_msg(__func__, xdr);
4468 	return -EIO;
4469 }
4470 
4471 static int decode_delegreturn(struct xdr_stream *xdr)
4472 {
4473 	return decode_op_hdr(xdr, OP_DELEGRETURN);
4474 }
4475 
4476 #if defined(CONFIG_NFS_V4_1)
4477 static int decode_exchange_id(struct xdr_stream *xdr,
4478 			      struct nfs41_exchange_id_res *res)
4479 {
4480 	__be32 *p;
4481 	uint32_t dummy;
4482 	char *dummy_str;
4483 	int status;
4484 	struct nfs_client *clp = res->client;
4485 
4486 	status = decode_op_hdr(xdr, OP_EXCHANGE_ID);
4487 	if (status)
4488 		return status;
4489 
4490 	p = xdr_inline_decode(xdr, 8);
4491 	if (unlikely(!p))
4492 		goto out_overflow;
4493 	xdr_decode_hyper(p, &clp->cl_ex_clid);
4494 	p = xdr_inline_decode(xdr, 12);
4495 	if (unlikely(!p))
4496 		goto out_overflow;
4497 	clp->cl_seqid = be32_to_cpup(p++);
4498 	clp->cl_exchange_flags = be32_to_cpup(p++);
4499 
4500 	/* We ask for SP4_NONE */
4501 	dummy = be32_to_cpup(p);
4502 	if (dummy != SP4_NONE)
4503 		return -EIO;
4504 
4505 	/* Throw away minor_id */
4506 	p = xdr_inline_decode(xdr, 8);
4507 	if (unlikely(!p))
4508 		goto out_overflow;
4509 
4510 	/* Throw away Major id */
4511 	status = decode_opaque_inline(xdr, &dummy, &dummy_str);
4512 	if (unlikely(status))
4513 		return status;
4514 
4515 	/* Throw away server_scope */
4516 	status = decode_opaque_inline(xdr, &dummy, &dummy_str);
4517 	if (unlikely(status))
4518 		return status;
4519 
4520 	/* Throw away Implementation id array */
4521 	status = decode_opaque_inline(xdr, &dummy, &dummy_str);
4522 	if (unlikely(status))
4523 		return status;
4524 
4525 	return 0;
4526 out_overflow:
4527 	print_overflow_msg(__func__, xdr);
4528 	return -EIO;
4529 }
4530 
4531 static int decode_chan_attrs(struct xdr_stream *xdr,
4532 			     struct nfs4_channel_attrs *attrs)
4533 {
4534 	__be32 *p;
4535 	u32 nr_attrs;
4536 
4537 	p = xdr_inline_decode(xdr, 28);
4538 	if (unlikely(!p))
4539 		goto out_overflow;
4540 	attrs->headerpadsz = be32_to_cpup(p++);
4541 	attrs->max_rqst_sz = be32_to_cpup(p++);
4542 	attrs->max_resp_sz = be32_to_cpup(p++);
4543 	attrs->max_resp_sz_cached = be32_to_cpup(p++);
4544 	attrs->max_ops = be32_to_cpup(p++);
4545 	attrs->max_reqs = be32_to_cpup(p++);
4546 	nr_attrs = be32_to_cpup(p);
4547 	if (unlikely(nr_attrs > 1)) {
4548 		printk(KERN_WARNING "%s: Invalid rdma channel attrs count %u\n",
4549 			__func__, nr_attrs);
4550 		return -EINVAL;
4551 	}
4552 	if (nr_attrs == 1) {
4553 		p = xdr_inline_decode(xdr, 4); /* skip rdma_attrs */
4554 		if (unlikely(!p))
4555 			goto out_overflow;
4556 	}
4557 	return 0;
4558 out_overflow:
4559 	print_overflow_msg(__func__, xdr);
4560 	return -EIO;
4561 }
4562 
4563 static int decode_sessionid(struct xdr_stream *xdr, struct nfs4_sessionid *sid)
4564 {
4565 	return decode_opaque_fixed(xdr, sid->data, NFS4_MAX_SESSIONID_LEN);
4566 }
4567 
4568 static int decode_create_session(struct xdr_stream *xdr,
4569 				 struct nfs41_create_session_res *res)
4570 {
4571 	__be32 *p;
4572 	int status;
4573 	struct nfs_client *clp = res->client;
4574 	struct nfs4_session *session = clp->cl_session;
4575 
4576 	status = decode_op_hdr(xdr, OP_CREATE_SESSION);
4577 	if (!status)
4578 		status = decode_sessionid(xdr, &session->sess_id);
4579 	if (unlikely(status))
4580 		return status;
4581 
4582 	/* seqid, flags */
4583 	p = xdr_inline_decode(xdr, 8);
4584 	if (unlikely(!p))
4585 		goto out_overflow;
4586 	clp->cl_seqid = be32_to_cpup(p++);
4587 	session->flags = be32_to_cpup(p);
4588 
4589 	/* Channel attributes */
4590 	status = decode_chan_attrs(xdr, &session->fc_attrs);
4591 	if (!status)
4592 		status = decode_chan_attrs(xdr, &session->bc_attrs);
4593 	return status;
4594 out_overflow:
4595 	print_overflow_msg(__func__, xdr);
4596 	return -EIO;
4597 }
4598 
4599 static int decode_destroy_session(struct xdr_stream *xdr, void *dummy)
4600 {
4601 	return decode_op_hdr(xdr, OP_DESTROY_SESSION);
4602 }
4603 
4604 static int decode_reclaim_complete(struct xdr_stream *xdr, void *dummy)
4605 {
4606 	return decode_op_hdr(xdr, OP_RECLAIM_COMPLETE);
4607 }
4608 #endif /* CONFIG_NFS_V4_1 */
4609 
4610 static int decode_sequence(struct xdr_stream *xdr,
4611 			   struct nfs4_sequence_res *res,
4612 			   struct rpc_rqst *rqstp)
4613 {
4614 #if defined(CONFIG_NFS_V4_1)
4615 	struct nfs4_slot *slot;
4616 	struct nfs4_sessionid id;
4617 	u32 dummy;
4618 	int status;
4619 	__be32 *p;
4620 
4621 	if (!res->sr_session)
4622 		return 0;
4623 
4624 	status = decode_op_hdr(xdr, OP_SEQUENCE);
4625 	if (!status)
4626 		status = decode_sessionid(xdr, &id);
4627 	if (unlikely(status))
4628 		goto out_err;
4629 
4630 	/*
4631 	 * If the server returns different values for sessionID, slotID or
4632 	 * sequence number, the server is looney tunes.
4633 	 */
4634 	status = -ESERVERFAULT;
4635 
4636 	if (memcmp(id.data, res->sr_session->sess_id.data,
4637 		   NFS4_MAX_SESSIONID_LEN)) {
4638 		dprintk("%s Invalid session id\n", __func__);
4639 		goto out_err;
4640 	}
4641 
4642 	p = xdr_inline_decode(xdr, 20);
4643 	if (unlikely(!p))
4644 		goto out_overflow;
4645 
4646 	/* seqid */
4647 	slot = &res->sr_session->fc_slot_table.slots[res->sr_slotid];
4648 	dummy = be32_to_cpup(p++);
4649 	if (dummy != slot->seq_nr) {
4650 		dprintk("%s Invalid sequence number\n", __func__);
4651 		goto out_err;
4652 	}
4653 	/* slot id */
4654 	dummy = be32_to_cpup(p++);
4655 	if (dummy != res->sr_slotid) {
4656 		dprintk("%s Invalid slot id\n", __func__);
4657 		goto out_err;
4658 	}
4659 	/* highest slot id - currently not processed */
4660 	dummy = be32_to_cpup(p++);
4661 	/* target highest slot id - currently not processed */
4662 	dummy = be32_to_cpup(p++);
4663 	/* result flags */
4664 	res->sr_status_flags = be32_to_cpup(p);
4665 	status = 0;
4666 out_err:
4667 	res->sr_status = status;
4668 	return status;
4669 out_overflow:
4670 	print_overflow_msg(__func__, xdr);
4671 	status = -EIO;
4672 	goto out_err;
4673 #else  /* CONFIG_NFS_V4_1 */
4674 	return 0;
4675 #endif /* CONFIG_NFS_V4_1 */
4676 }
4677 
4678 /*
4679  * END OF "GENERIC" DECODE ROUTINES.
4680  */
4681 
4682 /*
4683  * Decode OPEN_DOWNGRADE response
4684  */
4685 static int nfs4_xdr_dec_open_downgrade(struct rpc_rqst *rqstp, __be32 *p, struct nfs_closeres *res)
4686 {
4687 	struct xdr_stream xdr;
4688 	struct compound_hdr hdr;
4689 	int status;
4690 
4691 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4692 	status = decode_compound_hdr(&xdr, &hdr);
4693 	if (status)
4694 		goto out;
4695 	status = decode_sequence(&xdr, &res->seq_res, rqstp);
4696 	if (status)
4697 		goto out;
4698 	status = decode_putfh(&xdr);
4699 	if (status)
4700 		goto out;
4701 	status = decode_open_downgrade(&xdr, res);
4702 	if (status != 0)
4703 		goto out;
4704 	decode_getfattr(&xdr, res->fattr, res->server,
4705 			!RPC_IS_ASYNC(rqstp->rq_task));
4706 out:
4707 	return status;
4708 }
4709 
4710 /*
4711  * Decode ACCESS response
4712  */
4713 static int nfs4_xdr_dec_access(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_accessres *res)
4714 {
4715 	struct xdr_stream xdr;
4716 	struct compound_hdr hdr;
4717 	int status;
4718 
4719 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4720 	status = decode_compound_hdr(&xdr, &hdr);
4721 	if (status)
4722 		goto out;
4723 	status = decode_sequence(&xdr, &res->seq_res, rqstp);
4724 	if (status)
4725 		goto out;
4726 	status = decode_putfh(&xdr);
4727 	if (status != 0)
4728 		goto out;
4729 	status = decode_access(&xdr, res);
4730 	if (status != 0)
4731 		goto out;
4732 	decode_getfattr(&xdr, res->fattr, res->server,
4733 			!RPC_IS_ASYNC(rqstp->rq_task));
4734 out:
4735 	return status;
4736 }
4737 
4738 /*
4739  * Decode LOOKUP response
4740  */
4741 static int nfs4_xdr_dec_lookup(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_lookup_res *res)
4742 {
4743 	struct xdr_stream xdr;
4744 	struct compound_hdr hdr;
4745 	int status;
4746 
4747 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4748 	status = decode_compound_hdr(&xdr, &hdr);
4749 	if (status)
4750 		goto out;
4751 	status = decode_sequence(&xdr, &res->seq_res, rqstp);
4752 	if (status)
4753 		goto out;
4754 	if ((status = decode_putfh(&xdr)) != 0)
4755 		goto out;
4756 	if ((status = decode_lookup(&xdr)) != 0)
4757 		goto out;
4758 	if ((status = decode_getfh(&xdr, res->fh)) != 0)
4759 		goto out;
4760 	status = decode_getfattr(&xdr, res->fattr, res->server
4761 			,!RPC_IS_ASYNC(rqstp->rq_task));
4762 out:
4763 	return status;
4764 }
4765 
4766 /*
4767  * Decode LOOKUP_ROOT response
4768  */
4769 static int nfs4_xdr_dec_lookup_root(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_lookup_res *res)
4770 {
4771 	struct xdr_stream xdr;
4772 	struct compound_hdr hdr;
4773 	int status;
4774 
4775 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4776 	status = decode_compound_hdr(&xdr, &hdr);
4777 	if (status)
4778 		goto out;
4779 	status = decode_sequence(&xdr, &res->seq_res, rqstp);
4780 	if (status)
4781 		goto out;
4782 	if ((status = decode_putrootfh(&xdr)) != 0)
4783 		goto out;
4784 	if ((status = decode_getfh(&xdr, res->fh)) == 0)
4785 		status = decode_getfattr(&xdr, res->fattr, res->server,
4786 				!RPC_IS_ASYNC(rqstp->rq_task));
4787 out:
4788 	return status;
4789 }
4790 
4791 /*
4792  * Decode REMOVE response
4793  */
4794 static int nfs4_xdr_dec_remove(struct rpc_rqst *rqstp, __be32 *p, struct nfs_removeres *res)
4795 {
4796 	struct xdr_stream xdr;
4797 	struct compound_hdr hdr;
4798 	int status;
4799 
4800 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4801 	status = decode_compound_hdr(&xdr, &hdr);
4802 	if (status)
4803 		goto out;
4804 	status = decode_sequence(&xdr, &res->seq_res, rqstp);
4805 	if (status)
4806 		goto out;
4807 	if ((status = decode_putfh(&xdr)) != 0)
4808 		goto out;
4809 	if ((status = decode_remove(&xdr, &res->cinfo)) != 0)
4810 		goto out;
4811 	decode_getfattr(&xdr, &res->dir_attr, res->server,
4812 			!RPC_IS_ASYNC(rqstp->rq_task));
4813 out:
4814 	return status;
4815 }
4816 
4817 /*
4818  * Decode RENAME response
4819  */
4820 static int nfs4_xdr_dec_rename(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_rename_res *res)
4821 {
4822 	struct xdr_stream xdr;
4823 	struct compound_hdr hdr;
4824 	int status;
4825 
4826 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4827 	status = decode_compound_hdr(&xdr, &hdr);
4828 	if (status)
4829 		goto out;
4830 	status = decode_sequence(&xdr, &res->seq_res, rqstp);
4831 	if (status)
4832 		goto out;
4833 	if ((status = decode_putfh(&xdr)) != 0)
4834 		goto out;
4835 	if ((status = decode_savefh(&xdr)) != 0)
4836 		goto out;
4837 	if ((status = decode_putfh(&xdr)) != 0)
4838 		goto out;
4839 	if ((status = decode_rename(&xdr, &res->old_cinfo, &res->new_cinfo)) != 0)
4840 		goto out;
4841 	/* Current FH is target directory */
4842 	if (decode_getfattr(&xdr, res->new_fattr, res->server,
4843 				!RPC_IS_ASYNC(rqstp->rq_task)) != 0)
4844 		goto out;
4845 	if ((status = decode_restorefh(&xdr)) != 0)
4846 		goto out;
4847 	decode_getfattr(&xdr, res->old_fattr, res->server,
4848 			!RPC_IS_ASYNC(rqstp->rq_task));
4849 out:
4850 	return status;
4851 }
4852 
4853 /*
4854  * Decode LINK response
4855  */
4856 static int nfs4_xdr_dec_link(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_link_res *res)
4857 {
4858 	struct xdr_stream xdr;
4859 	struct compound_hdr hdr;
4860 	int status;
4861 
4862 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4863 	status = decode_compound_hdr(&xdr, &hdr);
4864 	if (status)
4865 		goto out;
4866 	status = decode_sequence(&xdr, &res->seq_res, rqstp);
4867 	if (status)
4868 		goto out;
4869 	if ((status = decode_putfh(&xdr)) != 0)
4870 		goto out;
4871 	if ((status = decode_savefh(&xdr)) != 0)
4872 		goto out;
4873 	if ((status = decode_putfh(&xdr)) != 0)
4874 		goto out;
4875 	if ((status = decode_link(&xdr, &res->cinfo)) != 0)
4876 		goto out;
4877 	/*
4878 	 * Note order: OP_LINK leaves the directory as the current
4879 	 *             filehandle.
4880 	 */
4881 	if (decode_getfattr(&xdr, res->dir_attr, res->server,
4882 				!RPC_IS_ASYNC(rqstp->rq_task)) != 0)
4883 		goto out;
4884 	if ((status = decode_restorefh(&xdr)) != 0)
4885 		goto out;
4886 	decode_getfattr(&xdr, res->fattr, res->server,
4887 			!RPC_IS_ASYNC(rqstp->rq_task));
4888 out:
4889 	return status;
4890 }
4891 
4892 /*
4893  * Decode CREATE response
4894  */
4895 static int nfs4_xdr_dec_create(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_create_res *res)
4896 {
4897 	struct xdr_stream xdr;
4898 	struct compound_hdr hdr;
4899 	int status;
4900 
4901 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4902 	status = decode_compound_hdr(&xdr, &hdr);
4903 	if (status)
4904 		goto out;
4905 	status = decode_sequence(&xdr, &res->seq_res, rqstp);
4906 	if (status)
4907 		goto out;
4908 	if ((status = decode_putfh(&xdr)) != 0)
4909 		goto out;
4910 	if ((status = decode_savefh(&xdr)) != 0)
4911 		goto out;
4912 	if ((status = decode_create(&xdr,&res->dir_cinfo)) != 0)
4913 		goto out;
4914 	if ((status = decode_getfh(&xdr, res->fh)) != 0)
4915 		goto out;
4916 	if (decode_getfattr(&xdr, res->fattr, res->server,
4917 				!RPC_IS_ASYNC(rqstp->rq_task)) != 0)
4918 		goto out;
4919 	if ((status = decode_restorefh(&xdr)) != 0)
4920 		goto out;
4921 	decode_getfattr(&xdr, res->dir_fattr, res->server,
4922 			!RPC_IS_ASYNC(rqstp->rq_task));
4923 out:
4924 	return status;
4925 }
4926 
4927 /*
4928  * Decode SYMLINK response
4929  */
4930 static int nfs4_xdr_dec_symlink(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_create_res *res)
4931 {
4932 	return nfs4_xdr_dec_create(rqstp, p, res);
4933 }
4934 
4935 /*
4936  * Decode GETATTR response
4937  */
4938 static int nfs4_xdr_dec_getattr(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_getattr_res *res)
4939 {
4940 	struct xdr_stream xdr;
4941 	struct compound_hdr hdr;
4942 	int status;
4943 
4944 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4945 	status = decode_compound_hdr(&xdr, &hdr);
4946 	if (status)
4947 		goto out;
4948 	status = decode_sequence(&xdr, &res->seq_res, rqstp);
4949 	if (status)
4950 		goto out;
4951 	status = decode_putfh(&xdr);
4952 	if (status)
4953 		goto out;
4954 	status = decode_getfattr(&xdr, res->fattr, res->server,
4955 			!RPC_IS_ASYNC(rqstp->rq_task));
4956 out:
4957 	return status;
4958 }
4959 
4960 /*
4961  * Encode an SETACL request
4962  */
4963 static int
4964 nfs4_xdr_enc_setacl(struct rpc_rqst *req, __be32 *p, struct nfs_setaclargs *args)
4965 {
4966 	struct xdr_stream xdr;
4967 	struct compound_hdr hdr = {
4968 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
4969 	};
4970 	int status;
4971 
4972 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
4973 	encode_compound_hdr(&xdr, req, &hdr);
4974 	encode_sequence(&xdr, &args->seq_args, &hdr);
4975 	encode_putfh(&xdr, args->fh, &hdr);
4976 	status = encode_setacl(&xdr, args, &hdr);
4977 	encode_nops(&hdr);
4978 	return status;
4979 }
4980 
4981 /*
4982  * Decode SETACL response
4983  */
4984 static int
4985 nfs4_xdr_dec_setacl(struct rpc_rqst *rqstp, __be32 *p,
4986 		    struct nfs_setaclres *res)
4987 {
4988 	struct xdr_stream xdr;
4989 	struct compound_hdr hdr;
4990 	int status;
4991 
4992 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4993 	status = decode_compound_hdr(&xdr, &hdr);
4994 	if (status)
4995 		goto out;
4996 	status = decode_sequence(&xdr, &res->seq_res, rqstp);
4997 	if (status)
4998 		goto out;
4999 	status = decode_putfh(&xdr);
5000 	if (status)
5001 		goto out;
5002 	status = decode_setattr(&xdr);
5003 out:
5004 	return status;
5005 }
5006 
5007 /*
5008  * Decode GETACL response
5009  */
5010 static int
5011 nfs4_xdr_dec_getacl(struct rpc_rqst *rqstp, __be32 *p,
5012 		    struct nfs_getaclres *res)
5013 {
5014 	struct xdr_stream xdr;
5015 	struct compound_hdr hdr;
5016 	int status;
5017 
5018 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
5019 	status = decode_compound_hdr(&xdr, &hdr);
5020 	if (status)
5021 		goto out;
5022 	status = decode_sequence(&xdr, &res->seq_res, rqstp);
5023 	if (status)
5024 		goto out;
5025 	status = decode_putfh(&xdr);
5026 	if (status)
5027 		goto out;
5028 	status = decode_getacl(&xdr, rqstp, &res->acl_len);
5029 
5030 out:
5031 	return status;
5032 }
5033 
5034 /*
5035  * Decode CLOSE response
5036  */
5037 static int nfs4_xdr_dec_close(struct rpc_rqst *rqstp, __be32 *p, struct nfs_closeres *res)
5038 {
5039 	struct xdr_stream xdr;
5040 	struct compound_hdr hdr;
5041 	int status;
5042 
5043 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
5044 	status = decode_compound_hdr(&xdr, &hdr);
5045 	if (status)
5046 		goto out;
5047 	status = decode_sequence(&xdr, &res->seq_res, rqstp);
5048 	if (status)
5049 		goto out;
5050 	status = decode_putfh(&xdr);
5051 	if (status)
5052 		goto out;
5053 	status = decode_close(&xdr, res);
5054 	if (status != 0)
5055 		goto out;
5056 	/*
5057 	 * Note: Server may do delete on close for this file
5058 	 * 	in which case the getattr call will fail with
5059 	 * 	an ESTALE error. Shouldn't be a problem,
5060 	 * 	though, since fattr->valid will remain unset.
5061 	 */
5062 	decode_getfattr(&xdr, res->fattr, res->server,
5063 			!RPC_IS_ASYNC(rqstp->rq_task));
5064 out:
5065 	return status;
5066 }
5067 
5068 /*
5069  * Decode OPEN response
5070  */
5071 static int nfs4_xdr_dec_open(struct rpc_rqst *rqstp, __be32 *p, struct nfs_openres *res)
5072 {
5073 	struct xdr_stream xdr;
5074 	struct compound_hdr hdr;
5075 	int status;
5076 
5077 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
5078 	status = decode_compound_hdr(&xdr, &hdr);
5079 	if (status)
5080 		goto out;
5081 	status = decode_sequence(&xdr, &res->seq_res, rqstp);
5082 	if (status)
5083 		goto out;
5084 	status = decode_putfh(&xdr);
5085 	if (status)
5086 		goto out;
5087 	status = decode_savefh(&xdr);
5088 	if (status)
5089 		goto out;
5090 	status = decode_open(&xdr, res);
5091 	if (status)
5092 		goto out;
5093 	if (decode_getfh(&xdr, &res->fh) != 0)
5094 		goto out;
5095 	if (decode_getfattr(&xdr, res->f_attr, res->server,
5096 				!RPC_IS_ASYNC(rqstp->rq_task)) != 0)
5097 		goto out;
5098 	if (decode_restorefh(&xdr) != 0)
5099 		goto out;
5100 	decode_getfattr(&xdr, res->dir_attr, res->server,
5101 			!RPC_IS_ASYNC(rqstp->rq_task));
5102 out:
5103 	return status;
5104 }
5105 
5106 /*
5107  * Decode OPEN_CONFIRM response
5108  */
5109 static int nfs4_xdr_dec_open_confirm(struct rpc_rqst *rqstp, __be32 *p, struct nfs_open_confirmres *res)
5110 {
5111 	struct xdr_stream xdr;
5112 	struct compound_hdr hdr;
5113 	int status;
5114 
5115 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
5116 	status = decode_compound_hdr(&xdr, &hdr);
5117 	if (status)
5118 		goto out;
5119 	status = decode_putfh(&xdr);
5120 	if (status)
5121 		goto out;
5122 	status = decode_open_confirm(&xdr, res);
5123 out:
5124 	return status;
5125 }
5126 
5127 /*
5128  * Decode OPEN response
5129  */
5130 static int nfs4_xdr_dec_open_noattr(struct rpc_rqst *rqstp, __be32 *p, struct nfs_openres *res)
5131 {
5132 	struct xdr_stream xdr;
5133 	struct compound_hdr hdr;
5134 	int status;
5135 
5136 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
5137 	status = decode_compound_hdr(&xdr, &hdr);
5138 	if (status)
5139 		goto out;
5140 	status = decode_sequence(&xdr, &res->seq_res, rqstp);
5141 	if (status)
5142 		goto out;
5143 	status = decode_putfh(&xdr);
5144 	if (status)
5145 		goto out;
5146 	status = decode_open(&xdr, res);
5147 	if (status)
5148 		goto out;
5149 	decode_getfattr(&xdr, res->f_attr, res->server,
5150 			!RPC_IS_ASYNC(rqstp->rq_task));
5151 out:
5152 	return status;
5153 }
5154 
5155 /*
5156  * Decode SETATTR response
5157  */
5158 static int nfs4_xdr_dec_setattr(struct rpc_rqst *rqstp, __be32 *p, struct nfs_setattrres *res)
5159 {
5160 	struct xdr_stream xdr;
5161 	struct compound_hdr hdr;
5162 	int status;
5163 
5164 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
5165 	status = decode_compound_hdr(&xdr, &hdr);
5166 	if (status)
5167 		goto out;
5168 	status = decode_sequence(&xdr, &res->seq_res, rqstp);
5169 	if (status)
5170 		goto out;
5171 	status = decode_putfh(&xdr);
5172 	if (status)
5173 		goto out;
5174 	status = decode_setattr(&xdr);
5175 	if (status)
5176 		goto out;
5177 	decode_getfattr(&xdr, res->fattr, res->server,
5178 			!RPC_IS_ASYNC(rqstp->rq_task));
5179 out:
5180 	return status;
5181 }
5182 
5183 /*
5184  * Decode LOCK response
5185  */
5186 static int nfs4_xdr_dec_lock(struct rpc_rqst *rqstp, __be32 *p, struct nfs_lock_res *res)
5187 {
5188 	struct xdr_stream xdr;
5189 	struct compound_hdr hdr;
5190 	int status;
5191 
5192 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
5193 	status = decode_compound_hdr(&xdr, &hdr);
5194 	if (status)
5195 		goto out;
5196 	status = decode_sequence(&xdr, &res->seq_res, rqstp);
5197 	if (status)
5198 		goto out;
5199 	status = decode_putfh(&xdr);
5200 	if (status)
5201 		goto out;
5202 	status = decode_lock(&xdr, res);
5203 out:
5204 	return status;
5205 }
5206 
5207 /*
5208  * Decode LOCKT response
5209  */
5210 static int nfs4_xdr_dec_lockt(struct rpc_rqst *rqstp, __be32 *p, struct nfs_lockt_res *res)
5211 {
5212 	struct xdr_stream xdr;
5213 	struct compound_hdr hdr;
5214 	int status;
5215 
5216 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
5217 	status = decode_compound_hdr(&xdr, &hdr);
5218 	if (status)
5219 		goto out;
5220 	status = decode_sequence(&xdr, &res->seq_res, rqstp);
5221 	if (status)
5222 		goto out;
5223 	status = decode_putfh(&xdr);
5224 	if (status)
5225 		goto out;
5226 	status = decode_lockt(&xdr, res);
5227 out:
5228 	return status;
5229 }
5230 
5231 /*
5232  * Decode LOCKU response
5233  */
5234 static int nfs4_xdr_dec_locku(struct rpc_rqst *rqstp, __be32 *p, struct nfs_locku_res *res)
5235 {
5236 	struct xdr_stream xdr;
5237 	struct compound_hdr hdr;
5238 	int status;
5239 
5240 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
5241 	status = decode_compound_hdr(&xdr, &hdr);
5242 	if (status)
5243 		goto out;
5244 	status = decode_sequence(&xdr, &res->seq_res, rqstp);
5245 	if (status)
5246 		goto out;
5247 	status = decode_putfh(&xdr);
5248 	if (status)
5249 		goto out;
5250 	status = decode_locku(&xdr, res);
5251 out:
5252 	return status;
5253 }
5254 
5255 /*
5256  * Decode READLINK response
5257  */
5258 static int nfs4_xdr_dec_readlink(struct rpc_rqst *rqstp, __be32 *p,
5259 				 struct nfs4_readlink_res *res)
5260 {
5261 	struct xdr_stream xdr;
5262 	struct compound_hdr hdr;
5263 	int status;
5264 
5265 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
5266 	status = decode_compound_hdr(&xdr, &hdr);
5267 	if (status)
5268 		goto out;
5269 	status = decode_sequence(&xdr, &res->seq_res, rqstp);
5270 	if (status)
5271 		goto out;
5272 	status = decode_putfh(&xdr);
5273 	if (status)
5274 		goto out;
5275 	status = decode_readlink(&xdr, rqstp);
5276 out:
5277 	return status;
5278 }
5279 
5280 /*
5281  * Decode READDIR response
5282  */
5283 static int nfs4_xdr_dec_readdir(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_readdir_res *res)
5284 {
5285 	struct xdr_stream xdr;
5286 	struct compound_hdr hdr;
5287 	int status;
5288 
5289 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
5290 	status = decode_compound_hdr(&xdr, &hdr);
5291 	if (status)
5292 		goto out;
5293 	status = decode_sequence(&xdr, &res->seq_res, rqstp);
5294 	if (status)
5295 		goto out;
5296 	status = decode_putfh(&xdr);
5297 	if (status)
5298 		goto out;
5299 	status = decode_readdir(&xdr, rqstp, res);
5300 out:
5301 	return status;
5302 }
5303 
5304 /*
5305  * Decode Read response
5306  */
5307 static int nfs4_xdr_dec_read(struct rpc_rqst *rqstp, __be32 *p, struct nfs_readres *res)
5308 {
5309 	struct xdr_stream xdr;
5310 	struct compound_hdr hdr;
5311 	int status;
5312 
5313 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
5314 	status = decode_compound_hdr(&xdr, &hdr);
5315 	if (status)
5316 		goto out;
5317 	status = decode_sequence(&xdr, &res->seq_res, rqstp);
5318 	if (status)
5319 		goto out;
5320 	status = decode_putfh(&xdr);
5321 	if (status)
5322 		goto out;
5323 	status = decode_read(&xdr, rqstp, res);
5324 	if (!status)
5325 		status = res->count;
5326 out:
5327 	return status;
5328 }
5329 
5330 /*
5331  * Decode WRITE response
5332  */
5333 static int nfs4_xdr_dec_write(struct rpc_rqst *rqstp, __be32 *p, struct nfs_writeres *res)
5334 {
5335 	struct xdr_stream xdr;
5336 	struct compound_hdr hdr;
5337 	int status;
5338 
5339 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
5340 	status = decode_compound_hdr(&xdr, &hdr);
5341 	if (status)
5342 		goto out;
5343 	status = decode_sequence(&xdr, &res->seq_res, rqstp);
5344 	if (status)
5345 		goto out;
5346 	status = decode_putfh(&xdr);
5347 	if (status)
5348 		goto out;
5349 	status = decode_write(&xdr, res);
5350 	if (status)
5351 		goto out;
5352 	decode_getfattr(&xdr, res->fattr, res->server,
5353 			!RPC_IS_ASYNC(rqstp->rq_task));
5354 	if (!status)
5355 		status = res->count;
5356 out:
5357 	return status;
5358 }
5359 
5360 /*
5361  * Decode COMMIT response
5362  */
5363 static int nfs4_xdr_dec_commit(struct rpc_rqst *rqstp, __be32 *p, struct nfs_writeres *res)
5364 {
5365 	struct xdr_stream xdr;
5366 	struct compound_hdr hdr;
5367 	int status;
5368 
5369 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
5370 	status = decode_compound_hdr(&xdr, &hdr);
5371 	if (status)
5372 		goto out;
5373 	status = decode_sequence(&xdr, &res->seq_res, rqstp);
5374 	if (status)
5375 		goto out;
5376 	status = decode_putfh(&xdr);
5377 	if (status)
5378 		goto out;
5379 	status = decode_commit(&xdr, res);
5380 	if (status)
5381 		goto out;
5382 	decode_getfattr(&xdr, res->fattr, res->server,
5383 			!RPC_IS_ASYNC(rqstp->rq_task));
5384 out:
5385 	return status;
5386 }
5387 
5388 /*
5389  * Decode FSINFO response
5390  */
5391 static int nfs4_xdr_dec_fsinfo(struct rpc_rqst *req, __be32 *p,
5392 			       struct nfs4_fsinfo_res *res)
5393 {
5394 	struct xdr_stream xdr;
5395 	struct compound_hdr hdr;
5396 	int status;
5397 
5398 	xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
5399 	status = decode_compound_hdr(&xdr, &hdr);
5400 	if (!status)
5401 		status = decode_sequence(&xdr, &res->seq_res, req);
5402 	if (!status)
5403 		status = decode_putfh(&xdr);
5404 	if (!status)
5405 		status = decode_fsinfo(&xdr, res->fsinfo);
5406 	return status;
5407 }
5408 
5409 /*
5410  * Decode PATHCONF response
5411  */
5412 static int nfs4_xdr_dec_pathconf(struct rpc_rqst *req, __be32 *p,
5413 				 struct nfs4_pathconf_res *res)
5414 {
5415 	struct xdr_stream xdr;
5416 	struct compound_hdr hdr;
5417 	int status;
5418 
5419 	xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
5420 	status = decode_compound_hdr(&xdr, &hdr);
5421 	if (!status)
5422 		status = decode_sequence(&xdr, &res->seq_res, req);
5423 	if (!status)
5424 		status = decode_putfh(&xdr);
5425 	if (!status)
5426 		status = decode_pathconf(&xdr, res->pathconf);
5427 	return status;
5428 }
5429 
5430 /*
5431  * Decode STATFS response
5432  */
5433 static int nfs4_xdr_dec_statfs(struct rpc_rqst *req, __be32 *p,
5434 			       struct nfs4_statfs_res *res)
5435 {
5436 	struct xdr_stream xdr;
5437 	struct compound_hdr hdr;
5438 	int status;
5439 
5440 	xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
5441 	status = decode_compound_hdr(&xdr, &hdr);
5442 	if (!status)
5443 		status = decode_sequence(&xdr, &res->seq_res, req);
5444 	if (!status)
5445 		status = decode_putfh(&xdr);
5446 	if (!status)
5447 		status = decode_statfs(&xdr, res->fsstat);
5448 	return status;
5449 }
5450 
5451 /*
5452  * Decode GETATTR_BITMAP response
5453  */
5454 static int nfs4_xdr_dec_server_caps(struct rpc_rqst *req, __be32 *p, struct nfs4_server_caps_res *res)
5455 {
5456 	struct xdr_stream xdr;
5457 	struct compound_hdr hdr;
5458 	int status;
5459 
5460 	xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
5461 	status = decode_compound_hdr(&xdr, &hdr);
5462 	if (status)
5463 		goto out;
5464 	status = decode_sequence(&xdr, &res->seq_res, req);
5465 	if (status)
5466 		goto out;
5467 	if ((status = decode_putfh(&xdr)) != 0)
5468 		goto out;
5469 	status = decode_server_caps(&xdr, res);
5470 out:
5471 	return status;
5472 }
5473 
5474 /*
5475  * Decode RENEW response
5476  */
5477 static int nfs4_xdr_dec_renew(struct rpc_rqst *rqstp, __be32 *p, void *dummy)
5478 {
5479 	struct xdr_stream xdr;
5480 	struct compound_hdr hdr;
5481 	int status;
5482 
5483 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
5484 	status = decode_compound_hdr(&xdr, &hdr);
5485 	if (!status)
5486 		status = decode_renew(&xdr);
5487 	return status;
5488 }
5489 
5490 /*
5491  * Decode SETCLIENTID response
5492  */
5493 static int nfs4_xdr_dec_setclientid(struct rpc_rqst *req, __be32 *p,
5494 		struct nfs_client *clp)
5495 {
5496 	struct xdr_stream xdr;
5497 	struct compound_hdr hdr;
5498 	int status;
5499 
5500 	xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
5501 	status = decode_compound_hdr(&xdr, &hdr);
5502 	if (!status)
5503 		status = decode_setclientid(&xdr, clp);
5504 	return status;
5505 }
5506 
5507 /*
5508  * Decode SETCLIENTID_CONFIRM response
5509  */
5510 static int nfs4_xdr_dec_setclientid_confirm(struct rpc_rqst *req, __be32 *p, struct nfs_fsinfo *fsinfo)
5511 {
5512 	struct xdr_stream xdr;
5513 	struct compound_hdr hdr;
5514 	int status;
5515 
5516 	xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
5517 	status = decode_compound_hdr(&xdr, &hdr);
5518 	if (!status)
5519 		status = decode_setclientid_confirm(&xdr);
5520 	if (!status)
5521 		status = decode_putrootfh(&xdr);
5522 	if (!status)
5523 		status = decode_fsinfo(&xdr, fsinfo);
5524 	return status;
5525 }
5526 
5527 /*
5528  * Decode DELEGRETURN response
5529  */
5530 static int nfs4_xdr_dec_delegreturn(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_delegreturnres *res)
5531 {
5532 	struct xdr_stream xdr;
5533 	struct compound_hdr hdr;
5534 	int status;
5535 
5536 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
5537 	status = decode_compound_hdr(&xdr, &hdr);
5538 	if (status)
5539 		goto out;
5540 	status = decode_sequence(&xdr, &res->seq_res, rqstp);
5541 	if (status)
5542 		goto out;
5543 	status = decode_putfh(&xdr);
5544 	if (status != 0)
5545 		goto out;
5546 	status = decode_delegreturn(&xdr);
5547 	decode_getfattr(&xdr, res->fattr, res->server,
5548 			!RPC_IS_ASYNC(rqstp->rq_task));
5549 out:
5550 	return status;
5551 }
5552 
5553 /*
5554  * Decode FS_LOCATIONS response
5555  */
5556 static int nfs4_xdr_dec_fs_locations(struct rpc_rqst *req, __be32 *p,
5557 				     struct nfs4_fs_locations_res *res)
5558 {
5559 	struct xdr_stream xdr;
5560 	struct compound_hdr hdr;
5561 	int status;
5562 
5563 	xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
5564 	status = decode_compound_hdr(&xdr, &hdr);
5565 	if (status)
5566 		goto out;
5567 	status = decode_sequence(&xdr, &res->seq_res, req);
5568 	if (status)
5569 		goto out;
5570 	if ((status = decode_putfh(&xdr)) != 0)
5571 		goto out;
5572 	if ((status = decode_lookup(&xdr)) != 0)
5573 		goto out;
5574 	xdr_enter_page(&xdr, PAGE_SIZE);
5575 	status = decode_getfattr(&xdr, &res->fs_locations->fattr,
5576 				 res->fs_locations->server,
5577 				 !RPC_IS_ASYNC(req->rq_task));
5578 out:
5579 	return status;
5580 }
5581 
5582 #if defined(CONFIG_NFS_V4_1)
5583 /*
5584  * Decode EXCHANGE_ID response
5585  */
5586 static int nfs4_xdr_dec_exchange_id(struct rpc_rqst *rqstp, uint32_t *p,
5587 				    void *res)
5588 {
5589 	struct xdr_stream xdr;
5590 	struct compound_hdr hdr;
5591 	int status;
5592 
5593 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
5594 	status = decode_compound_hdr(&xdr, &hdr);
5595 	if (!status)
5596 		status = decode_exchange_id(&xdr, res);
5597 	return status;
5598 }
5599 
5600 /*
5601  * Decode CREATE_SESSION response
5602  */
5603 static int nfs4_xdr_dec_create_session(struct rpc_rqst *rqstp, uint32_t *p,
5604 				       struct nfs41_create_session_res *res)
5605 {
5606 	struct xdr_stream xdr;
5607 	struct compound_hdr hdr;
5608 	int status;
5609 
5610 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
5611 	status = decode_compound_hdr(&xdr, &hdr);
5612 	if (!status)
5613 		status = decode_create_session(&xdr, res);
5614 	return status;
5615 }
5616 
5617 /*
5618  * Decode DESTROY_SESSION response
5619  */
5620 static int nfs4_xdr_dec_destroy_session(struct rpc_rqst *rqstp, uint32_t *p,
5621 					void *dummy)
5622 {
5623 	struct xdr_stream xdr;
5624 	struct compound_hdr hdr;
5625 	int status;
5626 
5627 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
5628 	status = decode_compound_hdr(&xdr, &hdr);
5629 	if (!status)
5630 		status = decode_destroy_session(&xdr, dummy);
5631 	return status;
5632 }
5633 
5634 /*
5635  * Decode SEQUENCE response
5636  */
5637 static int nfs4_xdr_dec_sequence(struct rpc_rqst *rqstp, uint32_t *p,
5638 				 struct nfs4_sequence_res *res)
5639 {
5640 	struct xdr_stream xdr;
5641 	struct compound_hdr hdr;
5642 	int status;
5643 
5644 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
5645 	status = decode_compound_hdr(&xdr, &hdr);
5646 	if (!status)
5647 		status = decode_sequence(&xdr, res, rqstp);
5648 	return status;
5649 }
5650 
5651 /*
5652  * Decode GET_LEASE_TIME response
5653  */
5654 static int nfs4_xdr_dec_get_lease_time(struct rpc_rqst *rqstp, uint32_t *p,
5655 				       struct nfs4_get_lease_time_res *res)
5656 {
5657 	struct xdr_stream xdr;
5658 	struct compound_hdr hdr;
5659 	int status;
5660 
5661 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
5662 	status = decode_compound_hdr(&xdr, &hdr);
5663 	if (!status)
5664 		status = decode_sequence(&xdr, &res->lr_seq_res, rqstp);
5665 	if (!status)
5666 		status = decode_putrootfh(&xdr);
5667 	if (!status)
5668 		status = decode_fsinfo(&xdr, res->lr_fsinfo);
5669 	return status;
5670 }
5671 
5672 /*
5673  * Decode RECLAIM_COMPLETE response
5674  */
5675 static int nfs4_xdr_dec_reclaim_complete(struct rpc_rqst *rqstp, uint32_t *p,
5676 					 struct nfs41_reclaim_complete_res *res)
5677 {
5678 	struct xdr_stream xdr;
5679 	struct compound_hdr hdr;
5680 	int status;
5681 
5682 	xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
5683 	status = decode_compound_hdr(&xdr, &hdr);
5684 	if (!status)
5685 		status = decode_sequence(&xdr, &res->seq_res, rqstp);
5686 	if (!status)
5687 		status = decode_reclaim_complete(&xdr, (void *)NULL);
5688 	return status;
5689 }
5690 #endif /* CONFIG_NFS_V4_1 */
5691 
5692 __be32 *nfs4_decode_dirent(__be32 *p, struct nfs_entry *entry, int plus)
5693 {
5694 	uint32_t bitmap[2] = {0};
5695 	uint32_t len;
5696 
5697 	if (!*p++) {
5698 		if (!*p)
5699 			return ERR_PTR(-EAGAIN);
5700 		entry->eof = 1;
5701 		return ERR_PTR(-EBADCOOKIE);
5702 	}
5703 
5704 	entry->prev_cookie = entry->cookie;
5705 	p = xdr_decode_hyper(p, &entry->cookie);
5706 	entry->len = ntohl(*p++);
5707 	entry->name = (const char *) p;
5708 	p += XDR_QUADLEN(entry->len);
5709 
5710 	/*
5711 	 * In case the server doesn't return an inode number,
5712 	 * we fake one here.  (We don't use inode number 0,
5713 	 * since glibc seems to choke on it...)
5714 	 */
5715 	entry->ino = 1;
5716 
5717 	len = ntohl(*p++);		/* bitmap length */
5718 	if (len-- > 0) {
5719 		bitmap[0] = ntohl(*p++);
5720 		if (len-- > 0) {
5721 			bitmap[1] = ntohl(*p++);
5722 			p += len;
5723 		}
5724 	}
5725 	len = XDR_QUADLEN(ntohl(*p++));	/* attribute buffer length */
5726 	if (len > 0) {
5727 		if (bitmap[0] & FATTR4_WORD0_RDATTR_ERROR) {
5728 			bitmap[0] &= ~FATTR4_WORD0_RDATTR_ERROR;
5729 			/* Ignore the return value of rdattr_error for now */
5730 			p++;
5731 			len--;
5732 		}
5733 		if (bitmap[0] == 0 && bitmap[1] == FATTR4_WORD1_MOUNTED_ON_FILEID)
5734 			xdr_decode_hyper(p, &entry->ino);
5735 		else if (bitmap[0] == FATTR4_WORD0_FILEID)
5736 			xdr_decode_hyper(p, &entry->ino);
5737 		p += len;
5738 	}
5739 
5740 	entry->eof = !p[0] && p[1];
5741 	return p;
5742 }
5743 
5744 /*
5745  * We need to translate between nfs status return values and
5746  * the local errno values which may not be the same.
5747  */
5748 static struct {
5749 	int stat;
5750 	int errno;
5751 } nfs_errtbl[] = {
5752 	{ NFS4_OK,		0		},
5753 	{ NFS4ERR_PERM,		-EPERM		},
5754 	{ NFS4ERR_NOENT,	-ENOENT		},
5755 	{ NFS4ERR_IO,		-errno_NFSERR_IO},
5756 	{ NFS4ERR_NXIO,		-ENXIO		},
5757 	{ NFS4ERR_ACCESS,	-EACCES		},
5758 	{ NFS4ERR_EXIST,	-EEXIST		},
5759 	{ NFS4ERR_XDEV,		-EXDEV		},
5760 	{ NFS4ERR_NOTDIR,	-ENOTDIR	},
5761 	{ NFS4ERR_ISDIR,	-EISDIR		},
5762 	{ NFS4ERR_INVAL,	-EINVAL		},
5763 	{ NFS4ERR_FBIG,		-EFBIG		},
5764 	{ NFS4ERR_NOSPC,	-ENOSPC		},
5765 	{ NFS4ERR_ROFS,		-EROFS		},
5766 	{ NFS4ERR_MLINK,	-EMLINK		},
5767 	{ NFS4ERR_NAMETOOLONG,	-ENAMETOOLONG	},
5768 	{ NFS4ERR_NOTEMPTY,	-ENOTEMPTY	},
5769 	{ NFS4ERR_DQUOT,	-EDQUOT		},
5770 	{ NFS4ERR_STALE,	-ESTALE		},
5771 	{ NFS4ERR_BADHANDLE,	-EBADHANDLE	},
5772 	{ NFS4ERR_BADOWNER,	-EINVAL		},
5773 	{ NFS4ERR_BADNAME,	-EINVAL		},
5774 	{ NFS4ERR_BAD_COOKIE,	-EBADCOOKIE	},
5775 	{ NFS4ERR_NOTSUPP,	-ENOTSUPP	},
5776 	{ NFS4ERR_TOOSMALL,	-ETOOSMALL	},
5777 	{ NFS4ERR_SERVERFAULT,	-ESERVERFAULT	},
5778 	{ NFS4ERR_BADTYPE,	-EBADTYPE	},
5779 	{ NFS4ERR_LOCKED,	-EAGAIN		},
5780 	{ NFS4ERR_SYMLINK,	-ELOOP		},
5781 	{ NFS4ERR_OP_ILLEGAL,	-EOPNOTSUPP	},
5782 	{ NFS4ERR_DEADLOCK,	-EDEADLK	},
5783 	{ NFS4ERR_WRONGSEC,	-EPERM		}, /* FIXME: this needs
5784 						    * to be handled by a
5785 						    * middle-layer.
5786 						    */
5787 	{ -1,			-EIO		}
5788 };
5789 
5790 /*
5791  * Convert an NFS error code to a local one.
5792  * This one is used jointly by NFSv2 and NFSv3.
5793  */
5794 static int
5795 nfs4_stat_to_errno(int stat)
5796 {
5797 	int i;
5798 	for (i = 0; nfs_errtbl[i].stat != -1; i++) {
5799 		if (nfs_errtbl[i].stat == stat)
5800 			return nfs_errtbl[i].errno;
5801 	}
5802 	if (stat <= 10000 || stat > 10100) {
5803 		/* The server is looney tunes. */
5804 		return -ESERVERFAULT;
5805 	}
5806 	/* If we cannot translate the error, the recovery routines should
5807 	 * handle it.
5808 	 * Note: remaining NFSv4 error codes have values > 10000, so should
5809 	 * not conflict with native Linux error codes.
5810 	 */
5811 	return -stat;
5812 }
5813 
5814 #define PROC(proc, argtype, restype)				\
5815 [NFSPROC4_CLNT_##proc] = {					\
5816 	.p_proc   = NFSPROC4_COMPOUND,				\
5817 	.p_encode = (kxdrproc_t) nfs4_xdr_##argtype,		\
5818 	.p_decode = (kxdrproc_t) nfs4_xdr_##restype,		\
5819 	.p_arglen = NFS4_##argtype##_sz,			\
5820 	.p_replen = NFS4_##restype##_sz,			\
5821 	.p_statidx = NFSPROC4_CLNT_##proc,			\
5822 	.p_name   = #proc,					\
5823 }
5824 
5825 struct rpc_procinfo	nfs4_procedures[] = {
5826   PROC(READ,		enc_read,	dec_read),
5827   PROC(WRITE,		enc_write,	dec_write),
5828   PROC(COMMIT,		enc_commit,	dec_commit),
5829   PROC(OPEN,		enc_open,	dec_open),
5830   PROC(OPEN_CONFIRM,	enc_open_confirm,	dec_open_confirm),
5831   PROC(OPEN_NOATTR,	enc_open_noattr,	dec_open_noattr),
5832   PROC(OPEN_DOWNGRADE,	enc_open_downgrade,	dec_open_downgrade),
5833   PROC(CLOSE,		enc_close,	dec_close),
5834   PROC(SETATTR,		enc_setattr,	dec_setattr),
5835   PROC(FSINFO,		enc_fsinfo,	dec_fsinfo),
5836   PROC(RENEW,		enc_renew,	dec_renew),
5837   PROC(SETCLIENTID,	enc_setclientid,	dec_setclientid),
5838   PROC(SETCLIENTID_CONFIRM,	enc_setclientid_confirm,	dec_setclientid_confirm),
5839   PROC(LOCK,            enc_lock,       dec_lock),
5840   PROC(LOCKT,           enc_lockt,      dec_lockt),
5841   PROC(LOCKU,           enc_locku,      dec_locku),
5842   PROC(ACCESS,		enc_access,	dec_access),
5843   PROC(GETATTR,		enc_getattr,	dec_getattr),
5844   PROC(LOOKUP,		enc_lookup,	dec_lookup),
5845   PROC(LOOKUP_ROOT,	enc_lookup_root,	dec_lookup_root),
5846   PROC(REMOVE,		enc_remove,	dec_remove),
5847   PROC(RENAME,		enc_rename,	dec_rename),
5848   PROC(LINK,		enc_link,	dec_link),
5849   PROC(SYMLINK,		enc_symlink,	dec_symlink),
5850   PROC(CREATE,		enc_create,	dec_create),
5851   PROC(PATHCONF,	enc_pathconf,	dec_pathconf),
5852   PROC(STATFS,		enc_statfs,	dec_statfs),
5853   PROC(READLINK,	enc_readlink,	dec_readlink),
5854   PROC(READDIR,		enc_readdir,	dec_readdir),
5855   PROC(SERVER_CAPS,	enc_server_caps, dec_server_caps),
5856   PROC(DELEGRETURN,	enc_delegreturn, dec_delegreturn),
5857   PROC(GETACL,		enc_getacl,	dec_getacl),
5858   PROC(SETACL,		enc_setacl,	dec_setacl),
5859   PROC(FS_LOCATIONS,	enc_fs_locations, dec_fs_locations),
5860 #if defined(CONFIG_NFS_V4_1)
5861   PROC(EXCHANGE_ID,	enc_exchange_id,	dec_exchange_id),
5862   PROC(CREATE_SESSION,	enc_create_session,	dec_create_session),
5863   PROC(DESTROY_SESSION,	enc_destroy_session,	dec_destroy_session),
5864   PROC(SEQUENCE,	enc_sequence,	dec_sequence),
5865   PROC(GET_LEASE_TIME,	enc_get_lease_time,	dec_get_lease_time),
5866   PROC(RECLAIM_COMPLETE, enc_reclaim_complete,  dec_reclaim_complete),
5867 #endif /* CONFIG_NFS_V4_1 */
5868 };
5869 
5870 struct rpc_version		nfs_version4 = {
5871 	.number			= 4,
5872 	.nrprocs		= ARRAY_SIZE(nfs4_procedures),
5873 	.procs			= nfs4_procedures
5874 };
5875 
5876 /*
5877  * Local variables:
5878  *  c-basic-offset: 8
5879  * End:
5880  */
5881