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