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