]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - fs/nfs/nfs4xdr.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
nfs: remove incorrect usage of nfs4 compound response hdr.status
[mirror_ubuntu-bionic-kernel.git] / fs / nfs / nfs4xdr.c
1 /*
2 * fs/nfs/nfs4xdr.c
3 *
4 * Client-side XDR for NFSv4.
5 *
6 * Copyright (c) 2002 The Regents of the University of Michigan.
7 * All rights reserved.
8 *
9 * Kendrick Smith <kmsmith@umich.edu>
10 * Andy Adamson <andros@umich.edu>
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 *
16 * 1. Redistributions of source code must retain the above copyright
17 * notice, this list of conditions and the following disclaimer.
18 * 2. Redistributions in binary form must reproduce the above copyright
19 * notice, this list of conditions and the following disclaimer in the
20 * documentation and/or other materials provided with the distribution.
21 * 3. Neither the name of the University nor the names of its
22 * contributors may be used to endorse or promote products derived
23 * from this software without specific prior written permission.
24 *
25 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
26 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
27 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
28 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
32 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 */
37
38 #include <linux/param.h>
39 #include <linux/time.h>
40 #include <linux/mm.h>
41 #include <linux/slab.h>
42 #include <linux/utsname.h>
43 #include <linux/errno.h>
44 #include <linux/string.h>
45 #include <linux/in.h>
46 #include <linux/pagemap.h>
47 #include <linux/proc_fs.h>
48 #include <linux/kdev_t.h>
49 #include <linux/sunrpc/clnt.h>
50 #include <linux/nfs.h>
51 #include <linux/nfs4.h>
52 #include <linux/nfs_fs.h>
53 #include <linux/nfs_idmap.h>
54 #include "nfs4_fs.h"
55
56 #define NFSDBG_FACILITY NFSDBG_XDR
57
58 /* Mapping from NFS error code to "errno" error code. */
59 #define errno_NFSERR_IO EIO
60
61 static int nfs4_stat_to_errno(int);
62
63 /* NFSv4 COMPOUND tags are only wanted for debugging purposes */
64 #ifdef DEBUG
65 #define NFS4_MAXTAGLEN 20
66 #else
67 #define NFS4_MAXTAGLEN 0
68 #endif
69
70 /* lock,open owner id:
71 * we currently use size 2 (u64) out of (NFS4_OPAQUE_LIMIT >> 2)
72 */
73 #define open_owner_id_maxsz (1 + 4)
74 #define lock_owner_id_maxsz (1 + 4)
75 #define decode_lockowner_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
76 #define compound_encode_hdr_maxsz (3 + (NFS4_MAXTAGLEN >> 2))
77 #define compound_decode_hdr_maxsz (3 + (NFS4_MAXTAGLEN >> 2))
78 #define op_encode_hdr_maxsz (1)
79 #define op_decode_hdr_maxsz (2)
80 #define encode_stateid_maxsz (XDR_QUADLEN(NFS4_STATEID_SIZE))
81 #define decode_stateid_maxsz (XDR_QUADLEN(NFS4_STATEID_SIZE))
82 #define encode_verifier_maxsz (XDR_QUADLEN(NFS4_VERIFIER_SIZE))
83 #define decode_verifier_maxsz (XDR_QUADLEN(NFS4_VERIFIER_SIZE))
84 #define encode_putfh_maxsz (op_encode_hdr_maxsz + 1 + \
85 (NFS4_FHSIZE >> 2))
86 #define decode_putfh_maxsz (op_decode_hdr_maxsz)
87 #define encode_putrootfh_maxsz (op_encode_hdr_maxsz)
88 #define decode_putrootfh_maxsz (op_decode_hdr_maxsz)
89 #define encode_getfh_maxsz (op_encode_hdr_maxsz)
90 #define decode_getfh_maxsz (op_decode_hdr_maxsz + 1 + \
91 ((3+NFS4_FHSIZE) >> 2))
92 #define nfs4_fattr_bitmap_maxsz 3
93 #define encode_getattr_maxsz (op_encode_hdr_maxsz + nfs4_fattr_bitmap_maxsz)
94 #define nfs4_name_maxsz (1 + ((3 + NFS4_MAXNAMLEN) >> 2))
95 #define nfs4_path_maxsz (1 + ((3 + NFS4_MAXPATHLEN) >> 2))
96 #define nfs4_owner_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
97 #define nfs4_group_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
98 /* This is based on getfattr, which uses the most attributes: */
99 #define nfs4_fattr_value_maxsz (1 + (1 + 2 + 2 + 4 + 2 + 1 + 1 + 2 + 2 + \
100 3 + 3 + 3 + nfs4_owner_maxsz + nfs4_group_maxsz))
101 #define nfs4_fattr_maxsz (nfs4_fattr_bitmap_maxsz + \
102 nfs4_fattr_value_maxsz)
103 #define decode_getattr_maxsz (op_decode_hdr_maxsz + nfs4_fattr_maxsz)
104 #define encode_attrs_maxsz (nfs4_fattr_bitmap_maxsz + \
105 1 + 2 + 1 + \
106 nfs4_owner_maxsz + \
107 nfs4_group_maxsz + \
108 4 + 4)
109 #define encode_savefh_maxsz (op_encode_hdr_maxsz)
110 #define decode_savefh_maxsz (op_decode_hdr_maxsz)
111 #define encode_restorefh_maxsz (op_encode_hdr_maxsz)
112 #define decode_restorefh_maxsz (op_decode_hdr_maxsz)
113 #define encode_fsinfo_maxsz (encode_getattr_maxsz)
114 #define decode_fsinfo_maxsz (op_decode_hdr_maxsz + 11)
115 #define encode_renew_maxsz (op_encode_hdr_maxsz + 3)
116 #define decode_renew_maxsz (op_decode_hdr_maxsz)
117 #define encode_setclientid_maxsz \
118 (op_encode_hdr_maxsz + \
119 XDR_QUADLEN(NFS4_VERIFIER_SIZE) + \
120 XDR_QUADLEN(NFS4_SETCLIENTID_NAMELEN) + \
121 1 /* sc_prog */ + \
122 XDR_QUADLEN(RPCBIND_MAXNETIDLEN) + \
123 XDR_QUADLEN(RPCBIND_MAXUADDRLEN) + \
124 1) /* sc_cb_ident */
125 #define decode_setclientid_maxsz \
126 (op_decode_hdr_maxsz + \
127 2 + \
128 1024) /* large value for CLID_INUSE */
129 #define encode_setclientid_confirm_maxsz \
130 (op_encode_hdr_maxsz + \
131 3 + (NFS4_VERIFIER_SIZE >> 2))
132 #define decode_setclientid_confirm_maxsz \
133 (op_decode_hdr_maxsz)
134 #define encode_lookup_maxsz (op_encode_hdr_maxsz + nfs4_name_maxsz)
135 #define decode_lookup_maxsz (op_decode_hdr_maxsz)
136 #define encode_share_access_maxsz \
137 (2)
138 #define encode_createmode_maxsz (1 + encode_attrs_maxsz)
139 #define encode_opentype_maxsz (1 + encode_createmode_maxsz)
140 #define encode_claim_null_maxsz (1 + nfs4_name_maxsz)
141 #define encode_open_maxsz (op_encode_hdr_maxsz + \
142 2 + encode_share_access_maxsz + 2 + \
143 open_owner_id_maxsz + \
144 encode_opentype_maxsz + \
145 encode_claim_null_maxsz)
146 #define decode_ace_maxsz (3 + nfs4_owner_maxsz)
147 #define decode_delegation_maxsz (1 + decode_stateid_maxsz + 1 + \
148 decode_ace_maxsz)
149 #define decode_change_info_maxsz (5)
150 #define decode_open_maxsz (op_decode_hdr_maxsz + \
151 decode_stateid_maxsz + \
152 decode_change_info_maxsz + 1 + \
153 nfs4_fattr_bitmap_maxsz + \
154 decode_delegation_maxsz)
155 #define encode_open_confirm_maxsz \
156 (op_encode_hdr_maxsz + \
157 encode_stateid_maxsz + 1)
158 #define decode_open_confirm_maxsz \
159 (op_decode_hdr_maxsz + \
160 decode_stateid_maxsz)
161 #define encode_open_downgrade_maxsz \
162 (op_encode_hdr_maxsz + \
163 encode_stateid_maxsz + 1 + \
164 encode_share_access_maxsz)
165 #define decode_open_downgrade_maxsz \
166 (op_decode_hdr_maxsz + \
167 decode_stateid_maxsz)
168 #define encode_close_maxsz (op_encode_hdr_maxsz + \
169 1 + encode_stateid_maxsz)
170 #define decode_close_maxsz (op_decode_hdr_maxsz + \
171 decode_stateid_maxsz)
172 #define encode_setattr_maxsz (op_encode_hdr_maxsz + \
173 encode_stateid_maxsz + \
174 encode_attrs_maxsz)
175 #define decode_setattr_maxsz (op_decode_hdr_maxsz + \
176 nfs4_fattr_bitmap_maxsz)
177 #define encode_read_maxsz (op_encode_hdr_maxsz + \
178 encode_stateid_maxsz + 3)
179 #define decode_read_maxsz (op_decode_hdr_maxsz + 2)
180 #define encode_readdir_maxsz (op_encode_hdr_maxsz + \
181 2 + encode_verifier_maxsz + 5)
182 #define decode_readdir_maxsz (op_decode_hdr_maxsz + \
183 decode_verifier_maxsz)
184 #define encode_readlink_maxsz (op_encode_hdr_maxsz)
185 #define decode_readlink_maxsz (op_decode_hdr_maxsz + 1)
186 #define encode_write_maxsz (op_encode_hdr_maxsz + \
187 encode_stateid_maxsz + 4)
188 #define decode_write_maxsz (op_decode_hdr_maxsz + \
189 2 + decode_verifier_maxsz)
190 #define encode_commit_maxsz (op_encode_hdr_maxsz + 3)
191 #define decode_commit_maxsz (op_decode_hdr_maxsz + \
192 decode_verifier_maxsz)
193 #define encode_remove_maxsz (op_encode_hdr_maxsz + \
194 nfs4_name_maxsz)
195 #define encode_rename_maxsz (op_encode_hdr_maxsz + \
196 2 * nfs4_name_maxsz)
197 #define decode_rename_maxsz (op_decode_hdr_maxsz + 5 + 5)
198 #define encode_link_maxsz (op_encode_hdr_maxsz + \
199 nfs4_name_maxsz)
200 #define decode_link_maxsz (op_decode_hdr_maxsz + 5)
201 #define encode_lock_maxsz (op_encode_hdr_maxsz + \
202 7 + \
203 1 + encode_stateid_maxsz + 8)
204 #define decode_lock_denied_maxsz \
205 (8 + decode_lockowner_maxsz)
206 #define decode_lock_maxsz (op_decode_hdr_maxsz + \
207 decode_lock_denied_maxsz)
208 #define encode_lockt_maxsz (op_encode_hdr_maxsz + 12)
209 #define decode_lockt_maxsz (op_decode_hdr_maxsz + \
210 decode_lock_denied_maxsz)
211 #define encode_locku_maxsz (op_encode_hdr_maxsz + 3 + \
212 encode_stateid_maxsz + \
213 4)
214 #define decode_locku_maxsz (op_decode_hdr_maxsz + \
215 decode_stateid_maxsz)
216 #define encode_access_maxsz (op_encode_hdr_maxsz + 1)
217 #define decode_access_maxsz (op_decode_hdr_maxsz + 2)
218 #define encode_symlink_maxsz (op_encode_hdr_maxsz + \
219 1 + nfs4_name_maxsz + \
220 1 + \
221 nfs4_fattr_maxsz)
222 #define decode_symlink_maxsz (op_decode_hdr_maxsz + 8)
223 #define encode_create_maxsz (op_encode_hdr_maxsz + \
224 1 + 2 + nfs4_name_maxsz + \
225 encode_attrs_maxsz)
226 #define decode_create_maxsz (op_decode_hdr_maxsz + \
227 decode_change_info_maxsz + \
228 nfs4_fattr_bitmap_maxsz)
229 #define encode_statfs_maxsz (encode_getattr_maxsz)
230 #define decode_statfs_maxsz (decode_getattr_maxsz)
231 #define encode_delegreturn_maxsz (op_encode_hdr_maxsz + 4)
232 #define decode_delegreturn_maxsz (op_decode_hdr_maxsz)
233 #define encode_getacl_maxsz (encode_getattr_maxsz)
234 #define decode_getacl_maxsz (op_decode_hdr_maxsz + \
235 nfs4_fattr_bitmap_maxsz + 1)
236 #define encode_setacl_maxsz (op_encode_hdr_maxsz + \
237 encode_stateid_maxsz + 3)
238 #define decode_setacl_maxsz (decode_setattr_maxsz)
239 #define encode_fs_locations_maxsz \
240 (encode_getattr_maxsz)
241 #define decode_fs_locations_maxsz \
242 (0)
243 #define NFS4_enc_compound_sz (1024) /* XXX: large enough? */
244 #define NFS4_dec_compound_sz (1024) /* XXX: large enough? */
245 #define NFS4_enc_read_sz (compound_encode_hdr_maxsz + \
246 encode_putfh_maxsz + \
247 encode_read_maxsz)
248 #define NFS4_dec_read_sz (compound_decode_hdr_maxsz + \
249 decode_putfh_maxsz + \
250 decode_read_maxsz)
251 #define NFS4_enc_readlink_sz (compound_encode_hdr_maxsz + \
252 encode_putfh_maxsz + \
253 encode_readlink_maxsz)
254 #define NFS4_dec_readlink_sz (compound_decode_hdr_maxsz + \
255 decode_putfh_maxsz + \
256 decode_readlink_maxsz)
257 #define NFS4_enc_readdir_sz (compound_encode_hdr_maxsz + \
258 encode_putfh_maxsz + \
259 encode_readdir_maxsz)
260 #define NFS4_dec_readdir_sz (compound_decode_hdr_maxsz + \
261 decode_putfh_maxsz + \
262 decode_readdir_maxsz)
263 #define NFS4_enc_write_sz (compound_encode_hdr_maxsz + \
264 encode_putfh_maxsz + \
265 encode_write_maxsz + \
266 encode_getattr_maxsz)
267 #define NFS4_dec_write_sz (compound_decode_hdr_maxsz + \
268 decode_putfh_maxsz + \
269 decode_write_maxsz + \
270 decode_getattr_maxsz)
271 #define NFS4_enc_commit_sz (compound_encode_hdr_maxsz + \
272 encode_putfh_maxsz + \
273 encode_commit_maxsz + \
274 encode_getattr_maxsz)
275 #define NFS4_dec_commit_sz (compound_decode_hdr_maxsz + \
276 decode_putfh_maxsz + \
277 decode_commit_maxsz + \
278 decode_getattr_maxsz)
279 #define NFS4_enc_open_sz (compound_encode_hdr_maxsz + \
280 encode_putfh_maxsz + \
281 encode_savefh_maxsz + \
282 encode_open_maxsz + \
283 encode_getfh_maxsz + \
284 encode_getattr_maxsz + \
285 encode_restorefh_maxsz + \
286 encode_getattr_maxsz)
287 #define NFS4_dec_open_sz (compound_decode_hdr_maxsz + \
288 decode_putfh_maxsz + \
289 decode_savefh_maxsz + \
290 decode_open_maxsz + \
291 decode_getfh_maxsz + \
292 decode_getattr_maxsz + \
293 decode_restorefh_maxsz + \
294 decode_getattr_maxsz)
295 #define NFS4_enc_open_confirm_sz \
296 (compound_encode_hdr_maxsz + \
297 encode_putfh_maxsz + \
298 encode_open_confirm_maxsz)
299 #define NFS4_dec_open_confirm_sz \
300 (compound_decode_hdr_maxsz + \
301 decode_putfh_maxsz + \
302 decode_open_confirm_maxsz)
303 #define NFS4_enc_open_noattr_sz (compound_encode_hdr_maxsz + \
304 encode_putfh_maxsz + \
305 encode_open_maxsz + \
306 encode_getattr_maxsz)
307 #define NFS4_dec_open_noattr_sz (compound_decode_hdr_maxsz + \
308 decode_putfh_maxsz + \
309 decode_open_maxsz + \
310 decode_getattr_maxsz)
311 #define NFS4_enc_open_downgrade_sz \
312 (compound_encode_hdr_maxsz + \
313 encode_putfh_maxsz + \
314 encode_open_downgrade_maxsz + \
315 encode_getattr_maxsz)
316 #define NFS4_dec_open_downgrade_sz \
317 (compound_decode_hdr_maxsz + \
318 decode_putfh_maxsz + \
319 decode_open_downgrade_maxsz + \
320 decode_getattr_maxsz)
321 #define NFS4_enc_close_sz (compound_encode_hdr_maxsz + \
322 encode_putfh_maxsz + \
323 encode_close_maxsz + \
324 encode_getattr_maxsz)
325 #define NFS4_dec_close_sz (compound_decode_hdr_maxsz + \
326 decode_putfh_maxsz + \
327 decode_close_maxsz + \
328 decode_getattr_maxsz)
329 #define NFS4_enc_setattr_sz (compound_encode_hdr_maxsz + \
330 encode_putfh_maxsz + \
331 encode_setattr_maxsz + \
332 encode_getattr_maxsz)
333 #define NFS4_dec_setattr_sz (compound_decode_hdr_maxsz + \
334 decode_putfh_maxsz + \
335 decode_setattr_maxsz + \
336 decode_getattr_maxsz)
337 #define NFS4_enc_fsinfo_sz (compound_encode_hdr_maxsz + \
338 encode_putfh_maxsz + \
339 encode_fsinfo_maxsz)
340 #define NFS4_dec_fsinfo_sz (compound_decode_hdr_maxsz + \
341 decode_putfh_maxsz + \
342 decode_fsinfo_maxsz)
343 #define NFS4_enc_renew_sz (compound_encode_hdr_maxsz + \
344 encode_renew_maxsz)
345 #define NFS4_dec_renew_sz (compound_decode_hdr_maxsz + \
346 decode_renew_maxsz)
347 #define NFS4_enc_setclientid_sz (compound_encode_hdr_maxsz + \
348 encode_setclientid_maxsz)
349 #define NFS4_dec_setclientid_sz (compound_decode_hdr_maxsz + \
350 decode_setclientid_maxsz)
351 #define NFS4_enc_setclientid_confirm_sz \
352 (compound_encode_hdr_maxsz + \
353 encode_setclientid_confirm_maxsz + \
354 encode_putrootfh_maxsz + \
355 encode_fsinfo_maxsz)
356 #define NFS4_dec_setclientid_confirm_sz \
357 (compound_decode_hdr_maxsz + \
358 decode_setclientid_confirm_maxsz + \
359 decode_putrootfh_maxsz + \
360 decode_fsinfo_maxsz)
361 #define NFS4_enc_lock_sz (compound_encode_hdr_maxsz + \
362 encode_putfh_maxsz + \
363 encode_lock_maxsz)
364 #define NFS4_dec_lock_sz (compound_decode_hdr_maxsz + \
365 decode_putfh_maxsz + \
366 decode_lock_maxsz)
367 #define NFS4_enc_lockt_sz (compound_encode_hdr_maxsz + \
368 encode_putfh_maxsz + \
369 encode_lockt_maxsz)
370 #define NFS4_dec_lockt_sz (compound_decode_hdr_maxsz + \
371 decode_putfh_maxsz + \
372 decode_lockt_maxsz)
373 #define NFS4_enc_locku_sz (compound_encode_hdr_maxsz + \
374 encode_putfh_maxsz + \
375 encode_locku_maxsz)
376 #define NFS4_dec_locku_sz (compound_decode_hdr_maxsz + \
377 decode_putfh_maxsz + \
378 decode_locku_maxsz)
379 #define NFS4_enc_access_sz (compound_encode_hdr_maxsz + \
380 encode_putfh_maxsz + \
381 encode_access_maxsz + \
382 encode_getattr_maxsz)
383 #define NFS4_dec_access_sz (compound_decode_hdr_maxsz + \
384 decode_putfh_maxsz + \
385 decode_access_maxsz + \
386 decode_getattr_maxsz)
387 #define NFS4_enc_getattr_sz (compound_encode_hdr_maxsz + \
388 encode_putfh_maxsz + \
389 encode_getattr_maxsz)
390 #define NFS4_dec_getattr_sz (compound_decode_hdr_maxsz + \
391 decode_putfh_maxsz + \
392 decode_getattr_maxsz)
393 #define NFS4_enc_lookup_sz (compound_encode_hdr_maxsz + \
394 encode_putfh_maxsz + \
395 encode_lookup_maxsz + \
396 encode_getattr_maxsz + \
397 encode_getfh_maxsz)
398 #define NFS4_dec_lookup_sz (compound_decode_hdr_maxsz + \
399 decode_putfh_maxsz + \
400 decode_lookup_maxsz + \
401 decode_getattr_maxsz + \
402 decode_getfh_maxsz)
403 #define NFS4_enc_lookup_root_sz (compound_encode_hdr_maxsz + \
404 encode_putrootfh_maxsz + \
405 encode_getattr_maxsz + \
406 encode_getfh_maxsz)
407 #define NFS4_dec_lookup_root_sz (compound_decode_hdr_maxsz + \
408 decode_putrootfh_maxsz + \
409 decode_getattr_maxsz + \
410 decode_getfh_maxsz)
411 #define NFS4_enc_remove_sz (compound_encode_hdr_maxsz + \
412 encode_putfh_maxsz + \
413 encode_remove_maxsz + \
414 encode_getattr_maxsz)
415 #define NFS4_dec_remove_sz (compound_decode_hdr_maxsz + \
416 decode_putfh_maxsz + \
417 op_decode_hdr_maxsz + 5 + \
418 decode_getattr_maxsz)
419 #define NFS4_enc_rename_sz (compound_encode_hdr_maxsz + \
420 encode_putfh_maxsz + \
421 encode_savefh_maxsz + \
422 encode_putfh_maxsz + \
423 encode_rename_maxsz + \
424 encode_getattr_maxsz + \
425 encode_restorefh_maxsz + \
426 encode_getattr_maxsz)
427 #define NFS4_dec_rename_sz (compound_decode_hdr_maxsz + \
428 decode_putfh_maxsz + \
429 decode_savefh_maxsz + \
430 decode_putfh_maxsz + \
431 decode_rename_maxsz + \
432 decode_getattr_maxsz + \
433 decode_restorefh_maxsz + \
434 decode_getattr_maxsz)
435 #define NFS4_enc_link_sz (compound_encode_hdr_maxsz + \
436 encode_putfh_maxsz + \
437 encode_savefh_maxsz + \
438 encode_putfh_maxsz + \
439 encode_link_maxsz + \
440 decode_getattr_maxsz + \
441 encode_restorefh_maxsz + \
442 decode_getattr_maxsz)
443 #define NFS4_dec_link_sz (compound_decode_hdr_maxsz + \
444 decode_putfh_maxsz + \
445 decode_savefh_maxsz + \
446 decode_putfh_maxsz + \
447 decode_link_maxsz + \
448 decode_getattr_maxsz + \
449 decode_restorefh_maxsz + \
450 decode_getattr_maxsz)
451 #define NFS4_enc_symlink_sz (compound_encode_hdr_maxsz + \
452 encode_putfh_maxsz + \
453 encode_symlink_maxsz + \
454 encode_getattr_maxsz + \
455 encode_getfh_maxsz)
456 #define NFS4_dec_symlink_sz (compound_decode_hdr_maxsz + \
457 decode_putfh_maxsz + \
458 decode_symlink_maxsz + \
459 decode_getattr_maxsz + \
460 decode_getfh_maxsz)
461 #define NFS4_enc_create_sz (compound_encode_hdr_maxsz + \
462 encode_putfh_maxsz + \
463 encode_savefh_maxsz + \
464 encode_create_maxsz + \
465 encode_getfh_maxsz + \
466 encode_getattr_maxsz + \
467 encode_restorefh_maxsz + \
468 encode_getattr_maxsz)
469 #define NFS4_dec_create_sz (compound_decode_hdr_maxsz + \
470 decode_putfh_maxsz + \
471 decode_savefh_maxsz + \
472 decode_create_maxsz + \
473 decode_getfh_maxsz + \
474 decode_getattr_maxsz + \
475 decode_restorefh_maxsz + \
476 decode_getattr_maxsz)
477 #define NFS4_enc_pathconf_sz (compound_encode_hdr_maxsz + \
478 encode_putfh_maxsz + \
479 encode_getattr_maxsz)
480 #define NFS4_dec_pathconf_sz (compound_decode_hdr_maxsz + \
481 decode_putfh_maxsz + \
482 decode_getattr_maxsz)
483 #define NFS4_enc_statfs_sz (compound_encode_hdr_maxsz + \
484 encode_putfh_maxsz + \
485 encode_statfs_maxsz)
486 #define NFS4_dec_statfs_sz (compound_decode_hdr_maxsz + \
487 decode_putfh_maxsz + \
488 decode_statfs_maxsz)
489 #define NFS4_enc_server_caps_sz (compound_encode_hdr_maxsz + \
490 encode_putfh_maxsz + \
491 encode_getattr_maxsz)
492 #define NFS4_dec_server_caps_sz (compound_decode_hdr_maxsz + \
493 decode_putfh_maxsz + \
494 decode_getattr_maxsz)
495 #define NFS4_enc_delegreturn_sz (compound_encode_hdr_maxsz + \
496 encode_putfh_maxsz + \
497 encode_delegreturn_maxsz + \
498 encode_getattr_maxsz)
499 #define NFS4_dec_delegreturn_sz (compound_decode_hdr_maxsz + \
500 decode_delegreturn_maxsz + \
501 decode_getattr_maxsz)
502 #define NFS4_enc_getacl_sz (compound_encode_hdr_maxsz + \
503 encode_putfh_maxsz + \
504 encode_getacl_maxsz)
505 #define NFS4_dec_getacl_sz (compound_decode_hdr_maxsz + \
506 decode_putfh_maxsz + \
507 decode_getacl_maxsz)
508 #define NFS4_enc_setacl_sz (compound_encode_hdr_maxsz + \
509 encode_putfh_maxsz + \
510 encode_setacl_maxsz)
511 #define NFS4_dec_setacl_sz (compound_decode_hdr_maxsz + \
512 decode_putfh_maxsz + \
513 decode_setacl_maxsz)
514 #define NFS4_enc_fs_locations_sz \
515 (compound_encode_hdr_maxsz + \
516 encode_putfh_maxsz + \
517 encode_lookup_maxsz + \
518 encode_fs_locations_maxsz)
519 #define NFS4_dec_fs_locations_sz \
520 (compound_decode_hdr_maxsz + \
521 decode_putfh_maxsz + \
522 decode_lookup_maxsz + \
523 decode_fs_locations_maxsz)
524
525 static struct {
526 unsigned int mode;
527 unsigned int nfs2type;
528 } nfs_type2fmt[] = {
529 { 0, NFNON },
530 { S_IFREG, NFREG },
531 { S_IFDIR, NFDIR },
532 { S_IFBLK, NFBLK },
533 { S_IFCHR, NFCHR },
534 { S_IFLNK, NFLNK },
535 { S_IFSOCK, NFSOCK },
536 { S_IFIFO, NFFIFO },
537 { 0, NFNON },
538 { 0, NFNON },
539 };
540
541 struct compound_hdr {
542 int32_t status;
543 uint32_t nops;
544 uint32_t taglen;
545 char * tag;
546 };
547
548 /*
549 * START OF "GENERIC" ENCODE ROUTINES.
550 * These may look a little ugly since they are imported from a "generic"
551 * set of XDR encode/decode routines which are intended to be shared by
552 * all of our NFSv4 implementations (OpenBSD, MacOS X...).
553 *
554 * If the pain of reading these is too great, it should be a straightforward
555 * task to translate them into Linux-specific versions which are more
556 * consistent with the style used in NFSv2/v3...
557 */
558 #define WRITE32(n) *p++ = htonl(n)
559 #define WRITE64(n) do { \
560 *p++ = htonl((uint32_t)((n) >> 32)); \
561 *p++ = htonl((uint32_t)(n)); \
562 } while (0)
563 #define WRITEMEM(ptr,nbytes) do { \
564 p = xdr_encode_opaque_fixed(p, ptr, nbytes); \
565 } while (0)
566
567 #define RESERVE_SPACE(nbytes) do { \
568 p = xdr_reserve_space(xdr, nbytes); \
569 BUG_ON(!p); \
570 } while (0)
571
572 static void encode_string(struct xdr_stream *xdr, unsigned int len, const char *str)
573 {
574 __be32 *p;
575
576 p = xdr_reserve_space(xdr, 4 + len);
577 BUG_ON(p == NULL);
578 xdr_encode_opaque(p, str, len);
579 }
580
581 static int encode_compound_hdr(struct xdr_stream *xdr, struct compound_hdr *hdr)
582 {
583 __be32 *p;
584
585 dprintk("encode_compound: tag=%.*s\n", (int)hdr->taglen, hdr->tag);
586 BUG_ON(hdr->taglen > NFS4_MAXTAGLEN);
587 RESERVE_SPACE(12+(XDR_QUADLEN(hdr->taglen)<<2));
588 WRITE32(hdr->taglen);
589 WRITEMEM(hdr->tag, hdr->taglen);
590 WRITE32(NFS4_MINOR_VERSION);
591 WRITE32(hdr->nops);
592 return 0;
593 }
594
595 static void encode_nfs4_verifier(struct xdr_stream *xdr, const nfs4_verifier *verf)
596 {
597 __be32 *p;
598
599 p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE);
600 BUG_ON(p == NULL);
601 xdr_encode_opaque_fixed(p, verf->data, NFS4_VERIFIER_SIZE);
602 }
603
604 static int encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const struct nfs_server *server)
605 {
606 char owner_name[IDMAP_NAMESZ];
607 char owner_group[IDMAP_NAMESZ];
608 int owner_namelen = 0;
609 int owner_grouplen = 0;
610 __be32 *p;
611 __be32 *q;
612 int len;
613 uint32_t bmval0 = 0;
614 uint32_t bmval1 = 0;
615 int status;
616
617 /*
618 * We reserve enough space to write the entire attribute buffer at once.
619 * In the worst-case, this would be
620 * 12(bitmap) + 4(attrlen) + 8(size) + 4(mode) + 4(atime) + 4(mtime)
621 * = 36 bytes, plus any contribution from variable-length fields
622 * such as owner/group.
623 */
624 len = 16;
625
626 /* Sigh */
627 if (iap->ia_valid & ATTR_SIZE)
628 len += 8;
629 if (iap->ia_valid & ATTR_MODE)
630 len += 4;
631 if (iap->ia_valid & ATTR_UID) {
632 owner_namelen = nfs_map_uid_to_name(server->nfs_client, iap->ia_uid, owner_name);
633 if (owner_namelen < 0) {
634 dprintk("nfs: couldn't resolve uid %d to string\n",
635 iap->ia_uid);
636 /* XXX */
637 strcpy(owner_name, "nobody");
638 owner_namelen = sizeof("nobody") - 1;
639 /* goto out; */
640 }
641 len += 4 + (XDR_QUADLEN(owner_namelen) << 2);
642 }
643 if (iap->ia_valid & ATTR_GID) {
644 owner_grouplen = nfs_map_gid_to_group(server->nfs_client, iap->ia_gid, owner_group);
645 if (owner_grouplen < 0) {
646 dprintk("nfs: couldn't resolve gid %d to string\n",
647 iap->ia_gid);
648 strcpy(owner_group, "nobody");
649 owner_grouplen = sizeof("nobody") - 1;
650 /* goto out; */
651 }
652 len += 4 + (XDR_QUADLEN(owner_grouplen) << 2);
653 }
654 if (iap->ia_valid & ATTR_ATIME_SET)
655 len += 16;
656 else if (iap->ia_valid & ATTR_ATIME)
657 len += 4;
658 if (iap->ia_valid & ATTR_MTIME_SET)
659 len += 16;
660 else if (iap->ia_valid & ATTR_MTIME)
661 len += 4;
662 RESERVE_SPACE(len);
663
664 /*
665 * We write the bitmap length now, but leave the bitmap and the attribute
666 * buffer length to be backfilled at the end of this routine.
667 */
668 WRITE32(2);
669 q = p;
670 p += 3;
671
672 if (iap->ia_valid & ATTR_SIZE) {
673 bmval0 |= FATTR4_WORD0_SIZE;
674 WRITE64(iap->ia_size);
675 }
676 if (iap->ia_valid & ATTR_MODE) {
677 bmval1 |= FATTR4_WORD1_MODE;
678 WRITE32(iap->ia_mode & S_IALLUGO);
679 }
680 if (iap->ia_valid & ATTR_UID) {
681 bmval1 |= FATTR4_WORD1_OWNER;
682 WRITE32(owner_namelen);
683 WRITEMEM(owner_name, owner_namelen);
684 }
685 if (iap->ia_valid & ATTR_GID) {
686 bmval1 |= FATTR4_WORD1_OWNER_GROUP;
687 WRITE32(owner_grouplen);
688 WRITEMEM(owner_group, owner_grouplen);
689 }
690 if (iap->ia_valid & ATTR_ATIME_SET) {
691 bmval1 |= FATTR4_WORD1_TIME_ACCESS_SET;
692 WRITE32(NFS4_SET_TO_CLIENT_TIME);
693 WRITE32(0);
694 WRITE32(iap->ia_mtime.tv_sec);
695 WRITE32(iap->ia_mtime.tv_nsec);
696 }
697 else if (iap->ia_valid & ATTR_ATIME) {
698 bmval1 |= FATTR4_WORD1_TIME_ACCESS_SET;
699 WRITE32(NFS4_SET_TO_SERVER_TIME);
700 }
701 if (iap->ia_valid & ATTR_MTIME_SET) {
702 bmval1 |= FATTR4_WORD1_TIME_MODIFY_SET;
703 WRITE32(NFS4_SET_TO_CLIENT_TIME);
704 WRITE32(0);
705 WRITE32(iap->ia_mtime.tv_sec);
706 WRITE32(iap->ia_mtime.tv_nsec);
707 }
708 else if (iap->ia_valid & ATTR_MTIME) {
709 bmval1 |= FATTR4_WORD1_TIME_MODIFY_SET;
710 WRITE32(NFS4_SET_TO_SERVER_TIME);
711 }
712
713 /*
714 * Now we backfill the bitmap and the attribute buffer length.
715 */
716 if (len != ((char *)p - (char *)q) + 4) {
717 printk(KERN_ERR "nfs: Attr length error, %u != %Zu\n",
718 len, ((char *)p - (char *)q) + 4);
719 BUG();
720 }
721 len = (char *)p - (char *)q - 12;
722 *q++ = htonl(bmval0);
723 *q++ = htonl(bmval1);
724 *q++ = htonl(len);
725
726 status = 0;
727 /* out: */
728 return status;
729 }
730
731 static int encode_access(struct xdr_stream *xdr, u32 access)
732 {
733 __be32 *p;
734
735 RESERVE_SPACE(8);
736 WRITE32(OP_ACCESS);
737 WRITE32(access);
738
739 return 0;
740 }
741
742 static int encode_close(struct xdr_stream *xdr, const struct nfs_closeargs *arg)
743 {
744 __be32 *p;
745
746 RESERVE_SPACE(8+NFS4_STATEID_SIZE);
747 WRITE32(OP_CLOSE);
748 WRITE32(arg->seqid->sequence->counter);
749 WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE);
750
751 return 0;
752 }
753
754 static int encode_commit(struct xdr_stream *xdr, const struct nfs_writeargs *args)
755 {
756 __be32 *p;
757
758 RESERVE_SPACE(16);
759 WRITE32(OP_COMMIT);
760 WRITE64(args->offset);
761 WRITE32(args->count);
762
763 return 0;
764 }
765
766 static int encode_create(struct xdr_stream *xdr, const struct nfs4_create_arg *create)
767 {
768 __be32 *p;
769
770 RESERVE_SPACE(8);
771 WRITE32(OP_CREATE);
772 WRITE32(create->ftype);
773
774 switch (create->ftype) {
775 case NF4LNK:
776 RESERVE_SPACE(4);
777 WRITE32(create->u.symlink.len);
778 xdr_write_pages(xdr, create->u.symlink.pages, 0, create->u.symlink.len);
779 break;
780
781 case NF4BLK: case NF4CHR:
782 RESERVE_SPACE(8);
783 WRITE32(create->u.device.specdata1);
784 WRITE32(create->u.device.specdata2);
785 break;
786
787 default:
788 break;
789 }
790
791 RESERVE_SPACE(4 + create->name->len);
792 WRITE32(create->name->len);
793 WRITEMEM(create->name->name, create->name->len);
794
795 return encode_attrs(xdr, create->attrs, create->server);
796 }
797
798 static int encode_getattr_one(struct xdr_stream *xdr, uint32_t bitmap)
799 {
800 __be32 *p;
801
802 RESERVE_SPACE(12);
803 WRITE32(OP_GETATTR);
804 WRITE32(1);
805 WRITE32(bitmap);
806 return 0;
807 }
808
809 static int encode_getattr_two(struct xdr_stream *xdr, uint32_t bm0, uint32_t bm1)
810 {
811 __be32 *p;
812
813 RESERVE_SPACE(16);
814 WRITE32(OP_GETATTR);
815 WRITE32(2);
816 WRITE32(bm0);
817 WRITE32(bm1);
818 return 0;
819 }
820
821 static int encode_getfattr(struct xdr_stream *xdr, const u32* bitmask)
822 {
823 return encode_getattr_two(xdr,
824 bitmask[0] & nfs4_fattr_bitmap[0],
825 bitmask[1] & nfs4_fattr_bitmap[1]);
826 }
827
828 static int encode_fsinfo(struct xdr_stream *xdr, const u32* bitmask)
829 {
830 return encode_getattr_two(xdr, bitmask[0] & nfs4_fsinfo_bitmap[0],
831 bitmask[1] & nfs4_fsinfo_bitmap[1]);
832 }
833
834 static int encode_fs_locations(struct xdr_stream *xdr, const u32* bitmask)
835 {
836 return encode_getattr_two(xdr,
837 bitmask[0] & nfs4_fs_locations_bitmap[0],
838 bitmask[1] & nfs4_fs_locations_bitmap[1]);
839 }
840
841 static int encode_getfh(struct xdr_stream *xdr)
842 {
843 __be32 *p;
844
845 RESERVE_SPACE(4);
846 WRITE32(OP_GETFH);
847
848 return 0;
849 }
850
851 static int encode_link(struct xdr_stream *xdr, const struct qstr *name)
852 {
853 __be32 *p;
854
855 RESERVE_SPACE(8 + name->len);
856 WRITE32(OP_LINK);
857 WRITE32(name->len);
858 WRITEMEM(name->name, name->len);
859
860 return 0;
861 }
862
863 static inline int nfs4_lock_type(struct file_lock *fl, int block)
864 {
865 if ((fl->fl_type & (F_RDLCK|F_WRLCK|F_UNLCK)) == F_RDLCK)
866 return block ? NFS4_READW_LT : NFS4_READ_LT;
867 return block ? NFS4_WRITEW_LT : NFS4_WRITE_LT;
868 }
869
870 static inline uint64_t nfs4_lock_length(struct file_lock *fl)
871 {
872 if (fl->fl_end == OFFSET_MAX)
873 return ~(uint64_t)0;
874 return fl->fl_end - fl->fl_start + 1;
875 }
876
877 /*
878 * opcode,type,reclaim,offset,length,new_lock_owner = 32
879 * open_seqid,open_stateid,lock_seqid,lock_owner.clientid, lock_owner.id = 40
880 */
881 static int encode_lock(struct xdr_stream *xdr, const struct nfs_lock_args *args)
882 {
883 __be32 *p;
884
885 RESERVE_SPACE(32);
886 WRITE32(OP_LOCK);
887 WRITE32(nfs4_lock_type(args->fl, args->block));
888 WRITE32(args->reclaim);
889 WRITE64(args->fl->fl_start);
890 WRITE64(nfs4_lock_length(args->fl));
891 WRITE32(args->new_lock_owner);
892 if (args->new_lock_owner){
893 RESERVE_SPACE(4+NFS4_STATEID_SIZE+32);
894 WRITE32(args->open_seqid->sequence->counter);
895 WRITEMEM(args->open_stateid->data, NFS4_STATEID_SIZE);
896 WRITE32(args->lock_seqid->sequence->counter);
897 WRITE64(args->lock_owner.clientid);
898 WRITE32(16);
899 WRITEMEM("lock id:", 8);
900 WRITE64(args->lock_owner.id);
901 }
902 else {
903 RESERVE_SPACE(NFS4_STATEID_SIZE+4);
904 WRITEMEM(args->lock_stateid->data, NFS4_STATEID_SIZE);
905 WRITE32(args->lock_seqid->sequence->counter);
906 }
907
908 return 0;
909 }
910
911 static int encode_lockt(struct xdr_stream *xdr, const struct nfs_lockt_args *args)
912 {
913 __be32 *p;
914
915 RESERVE_SPACE(52);
916 WRITE32(OP_LOCKT);
917 WRITE32(nfs4_lock_type(args->fl, 0));
918 WRITE64(args->fl->fl_start);
919 WRITE64(nfs4_lock_length(args->fl));
920 WRITE64(args->lock_owner.clientid);
921 WRITE32(16);
922 WRITEMEM("lock id:", 8);
923 WRITE64(args->lock_owner.id);
924
925 return 0;
926 }
927
928 static int encode_locku(struct xdr_stream *xdr, const struct nfs_locku_args *args)
929 {
930 __be32 *p;
931
932 RESERVE_SPACE(12+NFS4_STATEID_SIZE+16);
933 WRITE32(OP_LOCKU);
934 WRITE32(nfs4_lock_type(args->fl, 0));
935 WRITE32(args->seqid->sequence->counter);
936 WRITEMEM(args->stateid->data, NFS4_STATEID_SIZE);
937 WRITE64(args->fl->fl_start);
938 WRITE64(nfs4_lock_length(args->fl));
939
940 return 0;
941 }
942
943 static int encode_lookup(struct xdr_stream *xdr, const struct qstr *name)
944 {
945 int len = name->len;
946 __be32 *p;
947
948 RESERVE_SPACE(8 + len);
949 WRITE32(OP_LOOKUP);
950 WRITE32(len);
951 WRITEMEM(name->name, len);
952
953 return 0;
954 }
955
956 static void encode_share_access(struct xdr_stream *xdr, fmode_t fmode)
957 {
958 __be32 *p;
959
960 RESERVE_SPACE(8);
961 switch (fmode & (FMODE_READ|FMODE_WRITE)) {
962 case FMODE_READ:
963 WRITE32(NFS4_SHARE_ACCESS_READ);
964 break;
965 case FMODE_WRITE:
966 WRITE32(NFS4_SHARE_ACCESS_WRITE);
967 break;
968 case FMODE_READ|FMODE_WRITE:
969 WRITE32(NFS4_SHARE_ACCESS_BOTH);
970 break;
971 default:
972 WRITE32(0);
973 }
974 WRITE32(0); /* for linux, share_deny = 0 always */
975 }
976
977 static inline void encode_openhdr(struct xdr_stream *xdr, const struct nfs_openargs *arg)
978 {
979 __be32 *p;
980 /*
981 * opcode 4, seqid 4, share_access 4, share_deny 4, clientid 8, ownerlen 4,
982 * owner 4 = 32
983 */
984 RESERVE_SPACE(8);
985 WRITE32(OP_OPEN);
986 WRITE32(arg->seqid->sequence->counter);
987 encode_share_access(xdr, arg->fmode);
988 RESERVE_SPACE(28);
989 WRITE64(arg->clientid);
990 WRITE32(16);
991 WRITEMEM("open id:", 8);
992 WRITE64(arg->id);
993 }
994
995 static inline void encode_createmode(struct xdr_stream *xdr, const struct nfs_openargs *arg)
996 {
997 __be32 *p;
998
999 RESERVE_SPACE(4);
1000 switch(arg->open_flags & O_EXCL) {
1001 case 0:
1002 WRITE32(NFS4_CREATE_UNCHECKED);
1003 encode_attrs(xdr, arg->u.attrs, arg->server);
1004 break;
1005 default:
1006 WRITE32(NFS4_CREATE_EXCLUSIVE);
1007 encode_nfs4_verifier(xdr, &arg->u.verifier);
1008 }
1009 }
1010
1011 static void encode_opentype(struct xdr_stream *xdr, const struct nfs_openargs *arg)
1012 {
1013 __be32 *p;
1014
1015 RESERVE_SPACE(4);
1016 switch (arg->open_flags & O_CREAT) {
1017 case 0:
1018 WRITE32(NFS4_OPEN_NOCREATE);
1019 break;
1020 default:
1021 BUG_ON(arg->claim != NFS4_OPEN_CLAIM_NULL);
1022 WRITE32(NFS4_OPEN_CREATE);
1023 encode_createmode(xdr, arg);
1024 }
1025 }
1026
1027 static inline void encode_delegation_type(struct xdr_stream *xdr, fmode_t delegation_type)
1028 {
1029 __be32 *p;
1030
1031 RESERVE_SPACE(4);
1032 switch (delegation_type) {
1033 case 0:
1034 WRITE32(NFS4_OPEN_DELEGATE_NONE);
1035 break;
1036 case FMODE_READ:
1037 WRITE32(NFS4_OPEN_DELEGATE_READ);
1038 break;
1039 case FMODE_WRITE|FMODE_READ:
1040 WRITE32(NFS4_OPEN_DELEGATE_WRITE);
1041 break;
1042 default:
1043 BUG();
1044 }
1045 }
1046
1047 static inline void encode_claim_null(struct xdr_stream *xdr, const struct qstr *name)
1048 {
1049 __be32 *p;
1050
1051 RESERVE_SPACE(4);
1052 WRITE32(NFS4_OPEN_CLAIM_NULL);
1053 encode_string(xdr, name->len, name->name);
1054 }
1055
1056 static inline void encode_claim_previous(struct xdr_stream *xdr, fmode_t type)
1057 {
1058 __be32 *p;
1059
1060 RESERVE_SPACE(4);
1061 WRITE32(NFS4_OPEN_CLAIM_PREVIOUS);
1062 encode_delegation_type(xdr, type);
1063 }
1064
1065 static inline void encode_claim_delegate_cur(struct xdr_stream *xdr, const struct qstr *name, const nfs4_stateid *stateid)
1066 {
1067 __be32 *p;
1068
1069 RESERVE_SPACE(4+NFS4_STATEID_SIZE);
1070 WRITE32(NFS4_OPEN_CLAIM_DELEGATE_CUR);
1071 WRITEMEM(stateid->data, NFS4_STATEID_SIZE);
1072 encode_string(xdr, name->len, name->name);
1073 }
1074
1075 static int encode_open(struct xdr_stream *xdr, const struct nfs_openargs *arg)
1076 {
1077 encode_openhdr(xdr, arg);
1078 encode_opentype(xdr, arg);
1079 switch (arg->claim) {
1080 case NFS4_OPEN_CLAIM_NULL:
1081 encode_claim_null(xdr, arg->name);
1082 break;
1083 case NFS4_OPEN_CLAIM_PREVIOUS:
1084 encode_claim_previous(xdr, arg->u.delegation_type);
1085 break;
1086 case NFS4_OPEN_CLAIM_DELEGATE_CUR:
1087 encode_claim_delegate_cur(xdr, arg->name, &arg->u.delegation);
1088 break;
1089 default:
1090 BUG();
1091 }
1092 return 0;
1093 }
1094
1095 static int encode_open_confirm(struct xdr_stream *xdr, const struct nfs_open_confirmargs *arg)
1096 {
1097 __be32 *p;
1098
1099 RESERVE_SPACE(4+NFS4_STATEID_SIZE+4);
1100 WRITE32(OP_OPEN_CONFIRM);
1101 WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE);
1102 WRITE32(arg->seqid->sequence->counter);
1103
1104 return 0;
1105 }
1106
1107 static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closeargs *arg)
1108 {
1109 __be32 *p;
1110
1111 RESERVE_SPACE(4+NFS4_STATEID_SIZE+4);
1112 WRITE32(OP_OPEN_DOWNGRADE);
1113 WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE);
1114 WRITE32(arg->seqid->sequence->counter);
1115 encode_share_access(xdr, arg->fmode);
1116 return 0;
1117 }
1118
1119 static int
1120 encode_putfh(struct xdr_stream *xdr, const struct nfs_fh *fh)
1121 {
1122 int len = fh->size;
1123 __be32 *p;
1124
1125 RESERVE_SPACE(8 + len);
1126 WRITE32(OP_PUTFH);
1127 WRITE32(len);
1128 WRITEMEM(fh->data, len);
1129
1130 return 0;
1131 }
1132
1133 static int encode_putrootfh(struct xdr_stream *xdr)
1134 {
1135 __be32 *p;
1136
1137 RESERVE_SPACE(4);
1138 WRITE32(OP_PUTROOTFH);
1139
1140 return 0;
1141 }
1142
1143 static void encode_stateid(struct xdr_stream *xdr, const struct nfs_open_context *ctx)
1144 {
1145 nfs4_stateid stateid;
1146 __be32 *p;
1147
1148 RESERVE_SPACE(NFS4_STATEID_SIZE);
1149 if (ctx->state != NULL) {
1150 nfs4_copy_stateid(&stateid, ctx->state, ctx->lockowner);
1151 WRITEMEM(stateid.data, NFS4_STATEID_SIZE);
1152 } else
1153 WRITEMEM(zero_stateid.data, NFS4_STATEID_SIZE);
1154 }
1155
1156 static int encode_read(struct xdr_stream *xdr, const struct nfs_readargs *args)
1157 {
1158 __be32 *p;
1159
1160 RESERVE_SPACE(4);
1161 WRITE32(OP_READ);
1162
1163 encode_stateid(xdr, args->context);
1164
1165 RESERVE_SPACE(12);
1166 WRITE64(args->offset);
1167 WRITE32(args->count);
1168
1169 return 0;
1170 }
1171
1172 static int encode_readdir(struct xdr_stream *xdr, const struct nfs4_readdir_arg *readdir, struct rpc_rqst *req)
1173 {
1174 uint32_t attrs[2] = {
1175 FATTR4_WORD0_RDATTR_ERROR|FATTR4_WORD0_FILEID,
1176 FATTR4_WORD1_MOUNTED_ON_FILEID,
1177 };
1178 __be32 *p;
1179
1180 RESERVE_SPACE(12+NFS4_VERIFIER_SIZE+20);
1181 WRITE32(OP_READDIR);
1182 WRITE64(readdir->cookie);
1183 WRITEMEM(readdir->verifier.data, NFS4_VERIFIER_SIZE);
1184 WRITE32(readdir->count >> 1); /* We're not doing readdirplus */
1185 WRITE32(readdir->count);
1186 WRITE32(2);
1187 /* Switch to mounted_on_fileid if the server supports it */
1188 if (readdir->bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)
1189 attrs[0] &= ~FATTR4_WORD0_FILEID;
1190 else
1191 attrs[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID;
1192 WRITE32(attrs[0] & readdir->bitmask[0]);
1193 WRITE32(attrs[1] & readdir->bitmask[1]);
1194 dprintk("%s: cookie = %Lu, verifier = %08x:%08x, bitmap = %08x:%08x\n",
1195 __func__,
1196 (unsigned long long)readdir->cookie,
1197 ((u32 *)readdir->verifier.data)[0],
1198 ((u32 *)readdir->verifier.data)[1],
1199 attrs[0] & readdir->bitmask[0],
1200 attrs[1] & readdir->bitmask[1]);
1201
1202 return 0;
1203 }
1204
1205 static int encode_readlink(struct xdr_stream *xdr, const struct nfs4_readlink *readlink, struct rpc_rqst *req)
1206 {
1207 __be32 *p;
1208
1209 RESERVE_SPACE(4);
1210 WRITE32(OP_READLINK);
1211
1212 return 0;
1213 }
1214
1215 static int encode_remove(struct xdr_stream *xdr, const struct qstr *name)
1216 {
1217 __be32 *p;
1218
1219 RESERVE_SPACE(8 + name->len);
1220 WRITE32(OP_REMOVE);
1221 WRITE32(name->len);
1222 WRITEMEM(name->name, name->len);
1223
1224 return 0;
1225 }
1226
1227 static int encode_rename(struct xdr_stream *xdr, const struct qstr *oldname, const struct qstr *newname)
1228 {
1229 __be32 *p;
1230
1231 RESERVE_SPACE(8 + oldname->len);
1232 WRITE32(OP_RENAME);
1233 WRITE32(oldname->len);
1234 WRITEMEM(oldname->name, oldname->len);
1235
1236 RESERVE_SPACE(4 + newname->len);
1237 WRITE32(newname->len);
1238 WRITEMEM(newname->name, newname->len);
1239
1240 return 0;
1241 }
1242
1243 static int encode_renew(struct xdr_stream *xdr, const struct nfs_client *client_stateid)
1244 {
1245 __be32 *p;
1246
1247 RESERVE_SPACE(12);
1248 WRITE32(OP_RENEW);
1249 WRITE64(client_stateid->cl_clientid);
1250
1251 return 0;
1252 }
1253
1254 static int
1255 encode_restorefh(struct xdr_stream *xdr)
1256 {
1257 __be32 *p;
1258
1259 RESERVE_SPACE(4);
1260 WRITE32(OP_RESTOREFH);
1261
1262 return 0;
1263 }
1264
1265 static int
1266 encode_setacl(struct xdr_stream *xdr, struct nfs_setaclargs *arg)
1267 {
1268 __be32 *p;
1269
1270 RESERVE_SPACE(4+NFS4_STATEID_SIZE);
1271 WRITE32(OP_SETATTR);
1272 WRITEMEM(zero_stateid.data, NFS4_STATEID_SIZE);
1273 RESERVE_SPACE(2*4);
1274 WRITE32(1);
1275 WRITE32(FATTR4_WORD0_ACL);
1276 if (arg->acl_len % 4)
1277 return -EINVAL;
1278 RESERVE_SPACE(4);
1279 WRITE32(arg->acl_len);
1280 xdr_write_pages(xdr, arg->acl_pages, arg->acl_pgbase, arg->acl_len);
1281 return 0;
1282 }
1283
1284 static int
1285 encode_savefh(struct xdr_stream *xdr)
1286 {
1287 __be32 *p;
1288
1289 RESERVE_SPACE(4);
1290 WRITE32(OP_SAVEFH);
1291
1292 return 0;
1293 }
1294
1295 static int encode_setattr(struct xdr_stream *xdr, const struct nfs_setattrargs *arg, const struct nfs_server *server)
1296 {
1297 int status;
1298 __be32 *p;
1299
1300 RESERVE_SPACE(4+NFS4_STATEID_SIZE);
1301 WRITE32(OP_SETATTR);
1302 WRITEMEM(arg->stateid.data, NFS4_STATEID_SIZE);
1303
1304 if ((status = encode_attrs(xdr, arg->iap, server)))
1305 return status;
1306
1307 return 0;
1308 }
1309
1310 static int encode_setclientid(struct xdr_stream *xdr, const struct nfs4_setclientid *setclientid)
1311 {
1312 __be32 *p;
1313
1314 RESERVE_SPACE(4 + NFS4_VERIFIER_SIZE);
1315 WRITE32(OP_SETCLIENTID);
1316 WRITEMEM(setclientid->sc_verifier->data, NFS4_VERIFIER_SIZE);
1317
1318 encode_string(xdr, setclientid->sc_name_len, setclientid->sc_name);
1319 RESERVE_SPACE(4);
1320 WRITE32(setclientid->sc_prog);
1321 encode_string(xdr, setclientid->sc_netid_len, setclientid->sc_netid);
1322 encode_string(xdr, setclientid->sc_uaddr_len, setclientid->sc_uaddr);
1323 RESERVE_SPACE(4);
1324 WRITE32(setclientid->sc_cb_ident);
1325
1326 return 0;
1327 }
1328
1329 static int encode_setclientid_confirm(struct xdr_stream *xdr, const struct nfs_client *client_state)
1330 {
1331 __be32 *p;
1332
1333 RESERVE_SPACE(12 + NFS4_VERIFIER_SIZE);
1334 WRITE32(OP_SETCLIENTID_CONFIRM);
1335 WRITE64(client_state->cl_clientid);
1336 WRITEMEM(client_state->cl_confirm.data, NFS4_VERIFIER_SIZE);
1337
1338 return 0;
1339 }
1340
1341 static int encode_write(struct xdr_stream *xdr, const struct nfs_writeargs *args)
1342 {
1343 __be32 *p;
1344
1345 RESERVE_SPACE(4);
1346 WRITE32(OP_WRITE);
1347
1348 encode_stateid(xdr, args->context);
1349
1350 RESERVE_SPACE(16);
1351 WRITE64(args->offset);
1352 WRITE32(args->stable);
1353 WRITE32(args->count);
1354
1355 xdr_write_pages(xdr, args->pages, args->pgbase, args->count);
1356
1357 return 0;
1358 }
1359
1360 static int encode_delegreturn(struct xdr_stream *xdr, const nfs4_stateid *stateid)
1361 {
1362 __be32 *p;
1363
1364 RESERVE_SPACE(4+NFS4_STATEID_SIZE);
1365
1366 WRITE32(OP_DELEGRETURN);
1367 WRITEMEM(stateid->data, NFS4_STATEID_SIZE);
1368 return 0;
1369
1370 }
1371 /*
1372 * END OF "GENERIC" ENCODE ROUTINES.
1373 */
1374
1375 /*
1376 * Encode an ACCESS request
1377 */
1378 static int nfs4_xdr_enc_access(struct rpc_rqst *req, __be32 *p, const struct nfs4_accessargs *args)
1379 {
1380 struct xdr_stream xdr;
1381 struct compound_hdr hdr = {
1382 .nops = 3,
1383 };
1384 int status;
1385
1386 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1387 encode_compound_hdr(&xdr, &hdr);
1388 status = encode_putfh(&xdr, args->fh);
1389 if (status != 0)
1390 goto out;
1391 status = encode_access(&xdr, args->access);
1392 if (status != 0)
1393 goto out;
1394 status = encode_getfattr(&xdr, args->bitmask);
1395 out:
1396 return status;
1397 }
1398
1399 /*
1400 * Encode LOOKUP request
1401 */
1402 static int nfs4_xdr_enc_lookup(struct rpc_rqst *req, __be32 *p, const struct nfs4_lookup_arg *args)
1403 {
1404 struct xdr_stream xdr;
1405 struct compound_hdr hdr = {
1406 .nops = 4,
1407 };
1408 int status;
1409
1410 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1411 encode_compound_hdr(&xdr, &hdr);
1412 if ((status = encode_putfh(&xdr, args->dir_fh)) != 0)
1413 goto out;
1414 if ((status = encode_lookup(&xdr, args->name)) != 0)
1415 goto out;
1416 if ((status = encode_getfh(&xdr)) != 0)
1417 goto out;
1418 status = encode_getfattr(&xdr, args->bitmask);
1419 out:
1420 return status;
1421 }
1422
1423 /*
1424 * Encode LOOKUP_ROOT request
1425 */
1426 static int nfs4_xdr_enc_lookup_root(struct rpc_rqst *req, __be32 *p, const struct nfs4_lookup_root_arg *args)
1427 {
1428 struct xdr_stream xdr;
1429 struct compound_hdr hdr = {
1430 .nops = 3,
1431 };
1432 int status;
1433
1434 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1435 encode_compound_hdr(&xdr, &hdr);
1436 if ((status = encode_putrootfh(&xdr)) != 0)
1437 goto out;
1438 if ((status = encode_getfh(&xdr)) == 0)
1439 status = encode_getfattr(&xdr, args->bitmask);
1440 out:
1441 return status;
1442 }
1443
1444 /*
1445 * Encode REMOVE request
1446 */
1447 static int nfs4_xdr_enc_remove(struct rpc_rqst *req, __be32 *p, const struct nfs_removeargs *args)
1448 {
1449 struct xdr_stream xdr;
1450 struct compound_hdr hdr = {
1451 .nops = 3,
1452 };
1453 int status;
1454
1455 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1456 encode_compound_hdr(&xdr, &hdr);
1457 if ((status = encode_putfh(&xdr, args->fh)) != 0)
1458 goto out;
1459 if ((status = encode_remove(&xdr, &args->name)) != 0)
1460 goto out;
1461 status = encode_getfattr(&xdr, args->bitmask);
1462 out:
1463 return status;
1464 }
1465
1466 /*
1467 * Encode RENAME request
1468 */
1469 static int nfs4_xdr_enc_rename(struct rpc_rqst *req, __be32 *p, const struct nfs4_rename_arg *args)
1470 {
1471 struct xdr_stream xdr;
1472 struct compound_hdr hdr = {
1473 .nops = 7,
1474 };
1475 int status;
1476
1477 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1478 encode_compound_hdr(&xdr, &hdr);
1479 if ((status = encode_putfh(&xdr, args->old_dir)) != 0)
1480 goto out;
1481 if ((status = encode_savefh(&xdr)) != 0)
1482 goto out;
1483 if ((status = encode_putfh(&xdr, args->new_dir)) != 0)
1484 goto out;
1485 if ((status = encode_rename(&xdr, args->old_name, args->new_name)) != 0)
1486 goto out;
1487 if ((status = encode_getfattr(&xdr, args->bitmask)) != 0)
1488 goto out;
1489 if ((status = encode_restorefh(&xdr)) != 0)
1490 goto out;
1491 status = encode_getfattr(&xdr, args->bitmask);
1492 out:
1493 return status;
1494 }
1495
1496 /*
1497 * Encode LINK request
1498 */
1499 static int nfs4_xdr_enc_link(struct rpc_rqst *req, __be32 *p, const struct nfs4_link_arg *args)
1500 {
1501 struct xdr_stream xdr;
1502 struct compound_hdr hdr = {
1503 .nops = 7,
1504 };
1505 int status;
1506
1507 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1508 encode_compound_hdr(&xdr, &hdr);
1509 if ((status = encode_putfh(&xdr, args->fh)) != 0)
1510 goto out;
1511 if ((status = encode_savefh(&xdr)) != 0)
1512 goto out;
1513 if ((status = encode_putfh(&xdr, args->dir_fh)) != 0)
1514 goto out;
1515 if ((status = encode_link(&xdr, args->name)) != 0)
1516 goto out;
1517 if ((status = encode_getfattr(&xdr, args->bitmask)) != 0)
1518 goto out;
1519 if ((status = encode_restorefh(&xdr)) != 0)
1520 goto out;
1521 status = encode_getfattr(&xdr, args->bitmask);
1522 out:
1523 return status;
1524 }
1525
1526 /*
1527 * Encode CREATE request
1528 */
1529 static int nfs4_xdr_enc_create(struct rpc_rqst *req, __be32 *p, const struct nfs4_create_arg *args)
1530 {
1531 struct xdr_stream xdr;
1532 struct compound_hdr hdr = {
1533 .nops = 7,
1534 };
1535 int status;
1536
1537 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1538 encode_compound_hdr(&xdr, &hdr);
1539 if ((status = encode_putfh(&xdr, args->dir_fh)) != 0)
1540 goto out;
1541 if ((status = encode_savefh(&xdr)) != 0)
1542 goto out;
1543 if ((status = encode_create(&xdr, args)) != 0)
1544 goto out;
1545 if ((status = encode_getfh(&xdr)) != 0)
1546 goto out;
1547 if ((status = encode_getfattr(&xdr, args->bitmask)) != 0)
1548 goto out;
1549 if ((status = encode_restorefh(&xdr)) != 0)
1550 goto out;
1551 status = encode_getfattr(&xdr, args->bitmask);
1552 out:
1553 return status;
1554 }
1555
1556 /*
1557 * Encode SYMLINK request
1558 */
1559 static int nfs4_xdr_enc_symlink(struct rpc_rqst *req, __be32 *p, const struct nfs4_create_arg *args)
1560 {
1561 return nfs4_xdr_enc_create(req, p, args);
1562 }
1563
1564 /*
1565 * Encode GETATTR request
1566 */
1567 static int nfs4_xdr_enc_getattr(struct rpc_rqst *req, __be32 *p, const struct nfs4_getattr_arg *args)
1568 {
1569 struct xdr_stream xdr;
1570 struct compound_hdr hdr = {
1571 .nops = 2,
1572 };
1573 int status;
1574
1575 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1576 encode_compound_hdr(&xdr, &hdr);
1577 if ((status = encode_putfh(&xdr, args->fh)) == 0)
1578 status = encode_getfattr(&xdr, args->bitmask);
1579 return status;
1580 }
1581
1582 /*
1583 * Encode a CLOSE request
1584 */
1585 static int nfs4_xdr_enc_close(struct rpc_rqst *req, __be32 *p, struct nfs_closeargs *args)
1586 {
1587 struct xdr_stream xdr;
1588 struct compound_hdr hdr = {
1589 .nops = 3,
1590 };
1591 int status;
1592
1593 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1594 encode_compound_hdr(&xdr, &hdr);
1595 status = encode_putfh(&xdr, args->fh);
1596 if(status)
1597 goto out;
1598 status = encode_close(&xdr, args);
1599 if (status != 0)
1600 goto out;
1601 status = encode_getfattr(&xdr, args->bitmask);
1602 out:
1603 return status;
1604 }
1605
1606 /*
1607 * Encode an OPEN request
1608 */
1609 static int nfs4_xdr_enc_open(struct rpc_rqst *req, __be32 *p, struct nfs_openargs *args)
1610 {
1611 struct xdr_stream xdr;
1612 struct compound_hdr hdr = {
1613 .nops = 7,
1614 };
1615 int status;
1616
1617 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1618 encode_compound_hdr(&xdr, &hdr);
1619 status = encode_putfh(&xdr, args->fh);
1620 if (status)
1621 goto out;
1622 status = encode_savefh(&xdr);
1623 if (status)
1624 goto out;
1625 status = encode_open(&xdr, args);
1626 if (status)
1627 goto out;
1628 status = encode_getfh(&xdr);
1629 if (status)
1630 goto out;
1631 status = encode_getfattr(&xdr, args->bitmask);
1632 if (status)
1633 goto out;
1634 status = encode_restorefh(&xdr);
1635 if (status)
1636 goto out;
1637 status = encode_getfattr(&xdr, args->bitmask);
1638 out:
1639 return status;
1640 }
1641
1642 /*
1643 * Encode an OPEN_CONFIRM request
1644 */
1645 static int nfs4_xdr_enc_open_confirm(struct rpc_rqst *req, __be32 *p, struct nfs_open_confirmargs *args)
1646 {
1647 struct xdr_stream xdr;
1648 struct compound_hdr hdr = {
1649 .nops = 2,
1650 };
1651 int status;
1652
1653 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1654 encode_compound_hdr(&xdr, &hdr);
1655 status = encode_putfh(&xdr, args->fh);
1656 if(status)
1657 goto out;
1658 status = encode_open_confirm(&xdr, args);
1659 out:
1660 return status;
1661 }
1662
1663 /*
1664 * Encode an OPEN request with no attributes.
1665 */
1666 static int nfs4_xdr_enc_open_noattr(struct rpc_rqst *req, __be32 *p, struct nfs_openargs *args)
1667 {
1668 struct xdr_stream xdr;
1669 struct compound_hdr hdr = {
1670 .nops = 3,
1671 };
1672 int status;
1673
1674 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1675 encode_compound_hdr(&xdr, &hdr);
1676 status = encode_putfh(&xdr, args->fh);
1677 if (status)
1678 goto out;
1679 status = encode_open(&xdr, args);
1680 if (status)
1681 goto out;
1682 status = encode_getfattr(&xdr, args->bitmask);
1683 out:
1684 return status;
1685 }
1686
1687 /*
1688 * Encode an OPEN_DOWNGRADE request
1689 */
1690 static int nfs4_xdr_enc_open_downgrade(struct rpc_rqst *req, __be32 *p, struct nfs_closeargs *args)
1691 {
1692 struct xdr_stream xdr;
1693 struct compound_hdr hdr = {
1694 .nops = 3,
1695 };
1696 int status;
1697
1698 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1699 encode_compound_hdr(&xdr, &hdr);
1700 status = encode_putfh(&xdr, args->fh);
1701 if (status)
1702 goto out;
1703 status = encode_open_downgrade(&xdr, args);
1704 if (status != 0)
1705 goto out;
1706 status = encode_getfattr(&xdr, args->bitmask);
1707 out:
1708 return status;
1709 }
1710
1711 /*
1712 * Encode a LOCK request
1713 */
1714 static int nfs4_xdr_enc_lock(struct rpc_rqst *req, __be32 *p, struct nfs_lock_args *args)
1715 {
1716 struct xdr_stream xdr;
1717 struct compound_hdr hdr = {
1718 .nops = 2,
1719 };
1720 int status;
1721
1722 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1723 encode_compound_hdr(&xdr, &hdr);
1724 status = encode_putfh(&xdr, args->fh);
1725 if(status)
1726 goto out;
1727 status = encode_lock(&xdr, args);
1728 out:
1729 return status;
1730 }
1731
1732 /*
1733 * Encode a LOCKT request
1734 */
1735 static int nfs4_xdr_enc_lockt(struct rpc_rqst *req, __be32 *p, struct nfs_lockt_args *args)
1736 {
1737 struct xdr_stream xdr;
1738 struct compound_hdr hdr = {
1739 .nops = 2,
1740 };
1741 int status;
1742
1743 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1744 encode_compound_hdr(&xdr, &hdr);
1745 status = encode_putfh(&xdr, args->fh);
1746 if(status)
1747 goto out;
1748 status = encode_lockt(&xdr, args);
1749 out:
1750 return status;
1751 }
1752
1753 /*
1754 * Encode a LOCKU request
1755 */
1756 static int nfs4_xdr_enc_locku(struct rpc_rqst *req, __be32 *p, struct nfs_locku_args *args)
1757 {
1758 struct xdr_stream xdr;
1759 struct compound_hdr hdr = {
1760 .nops = 2,
1761 };
1762 int status;
1763
1764 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1765 encode_compound_hdr(&xdr, &hdr);
1766 status = encode_putfh(&xdr, args->fh);
1767 if(status)
1768 goto out;
1769 status = encode_locku(&xdr, args);
1770 out:
1771 return status;
1772 }
1773
1774 /*
1775 * Encode a READLINK request
1776 */
1777 static int nfs4_xdr_enc_readlink(struct rpc_rqst *req, __be32 *p, const struct nfs4_readlink *args)
1778 {
1779 struct xdr_stream xdr;
1780 struct compound_hdr hdr = {
1781 .nops = 2,
1782 };
1783 struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
1784 unsigned int replen;
1785 int status;
1786
1787 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1788 encode_compound_hdr(&xdr, &hdr);
1789 status = encode_putfh(&xdr, args->fh);
1790 if(status)
1791 goto out;
1792 status = encode_readlink(&xdr, args, req);
1793
1794 /* set up reply kvec
1795 * toplevel_status + taglen + rescount + OP_PUTFH + status
1796 * + OP_READLINK + status + string length = 8
1797 */
1798 replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS4_dec_readlink_sz) << 2;
1799 xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages,
1800 args->pgbase, args->pglen);
1801
1802 out:
1803 return status;
1804 }
1805
1806 /*
1807 * Encode a READDIR request
1808 */
1809 static int nfs4_xdr_enc_readdir(struct rpc_rqst *req, __be32 *p, const struct nfs4_readdir_arg *args)
1810 {
1811 struct xdr_stream xdr;
1812 struct compound_hdr hdr = {
1813 .nops = 2,
1814 };
1815 struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
1816 int replen;
1817 int status;
1818
1819 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1820 encode_compound_hdr(&xdr, &hdr);
1821 status = encode_putfh(&xdr, args->fh);
1822 if(status)
1823 goto out;
1824 status = encode_readdir(&xdr, args, req);
1825
1826 /* set up reply kvec
1827 * toplevel_status + taglen + rescount + OP_PUTFH + status
1828 * + OP_READDIR + status + verifer(2) = 9
1829 */
1830 replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS4_dec_readdir_sz) << 2;
1831 xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages,
1832 args->pgbase, args->count);
1833 dprintk("%s: inlined page args = (%u, %p, %u, %u)\n",
1834 __func__, replen, args->pages,
1835 args->pgbase, args->count);
1836
1837 out:
1838 return status;
1839 }
1840
1841 /*
1842 * Encode a READ request
1843 */
1844 static int nfs4_xdr_enc_read(struct rpc_rqst *req, __be32 *p, struct nfs_readargs *args)
1845 {
1846 struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
1847 struct xdr_stream xdr;
1848 struct compound_hdr hdr = {
1849 .nops = 2,
1850 };
1851 int replen, status;
1852
1853 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1854 encode_compound_hdr(&xdr, &hdr);
1855 status = encode_putfh(&xdr, args->fh);
1856 if (status)
1857 goto out;
1858 status = encode_read(&xdr, args);
1859 if (status)
1860 goto out;
1861
1862 /* set up reply kvec
1863 * toplevel status + taglen=0 + rescount + OP_PUTFH + status
1864 * + OP_READ + status + eof + datalen = 9
1865 */
1866 replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS4_dec_read_sz) << 2;
1867 xdr_inline_pages(&req->rq_rcv_buf, replen,
1868 args->pages, args->pgbase, args->count);
1869 req->rq_rcv_buf.flags |= XDRBUF_READ;
1870 out:
1871 return status;
1872 }
1873
1874 /*
1875 * Encode an SETATTR request
1876 */
1877 static int nfs4_xdr_enc_setattr(struct rpc_rqst *req, __be32 *p, struct nfs_setattrargs *args)
1878
1879 {
1880 struct xdr_stream xdr;
1881 struct compound_hdr hdr = {
1882 .nops = 3,
1883 };
1884 int status;
1885
1886 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1887 encode_compound_hdr(&xdr, &hdr);
1888 status = encode_putfh(&xdr, args->fh);
1889 if(status)
1890 goto out;
1891 status = encode_setattr(&xdr, args, args->server);
1892 if(status)
1893 goto out;
1894 status = encode_getfattr(&xdr, args->bitmask);
1895 out:
1896 return status;
1897 }
1898
1899 /*
1900 * Encode a GETACL request
1901 */
1902 static int
1903 nfs4_xdr_enc_getacl(struct rpc_rqst *req, __be32 *p,
1904 struct nfs_getaclargs *args)
1905 {
1906 struct xdr_stream xdr;
1907 struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
1908 struct compound_hdr hdr = {
1909 .nops = 2,
1910 };
1911 int replen, status;
1912
1913 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1914 encode_compound_hdr(&xdr, &hdr);
1915 status = encode_putfh(&xdr, args->fh);
1916 if (status)
1917 goto out;
1918 status = encode_getattr_two(&xdr, FATTR4_WORD0_ACL, 0);
1919 /* set up reply buffer: */
1920 replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS4_dec_getacl_sz) << 2;
1921 xdr_inline_pages(&req->rq_rcv_buf, replen,
1922 args->acl_pages, args->acl_pgbase, args->acl_len);
1923 out:
1924 return status;
1925 }
1926
1927 /*
1928 * Encode a WRITE request
1929 */
1930 static int nfs4_xdr_enc_write(struct rpc_rqst *req, __be32 *p, struct nfs_writeargs *args)
1931 {
1932 struct xdr_stream xdr;
1933 struct compound_hdr hdr = {
1934 .nops = 3,
1935 };
1936 int status;
1937
1938 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1939 encode_compound_hdr(&xdr, &hdr);
1940 status = encode_putfh(&xdr, args->fh);
1941 if (status)
1942 goto out;
1943 status = encode_write(&xdr, args);
1944 if (status)
1945 goto out;
1946 req->rq_snd_buf.flags |= XDRBUF_WRITE;
1947 status = encode_getfattr(&xdr, args->bitmask);
1948 out:
1949 return status;
1950 }
1951
1952 /*
1953 * a COMMIT request
1954 */
1955 static int nfs4_xdr_enc_commit(struct rpc_rqst *req, __be32 *p, struct nfs_writeargs *args)
1956 {
1957 struct xdr_stream xdr;
1958 struct compound_hdr hdr = {
1959 .nops = 3,
1960 };
1961 int status;
1962
1963 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1964 encode_compound_hdr(&xdr, &hdr);
1965 status = encode_putfh(&xdr, args->fh);
1966 if (status)
1967 goto out;
1968 status = encode_commit(&xdr, args);
1969 if (status)
1970 goto out;
1971 status = encode_getfattr(&xdr, args->bitmask);
1972 out:
1973 return status;
1974 }
1975
1976 /*
1977 * FSINFO request
1978 */
1979 static int nfs4_xdr_enc_fsinfo(struct rpc_rqst *req, __be32 *p, struct nfs4_fsinfo_arg *args)
1980 {
1981 struct xdr_stream xdr;
1982 struct compound_hdr hdr = {
1983 .nops = 2,
1984 };
1985 int status;
1986
1987 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1988 encode_compound_hdr(&xdr, &hdr);
1989 status = encode_putfh(&xdr, args->fh);
1990 if (!status)
1991 status = encode_fsinfo(&xdr, args->bitmask);
1992 return status;
1993 }
1994
1995 /*
1996 * a PATHCONF request
1997 */
1998 static int nfs4_xdr_enc_pathconf(struct rpc_rqst *req, __be32 *p, const struct nfs4_pathconf_arg *args)
1999 {
2000 struct xdr_stream xdr;
2001 struct compound_hdr hdr = {
2002 .nops = 2,
2003 };
2004 int status;
2005
2006 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2007 encode_compound_hdr(&xdr, &hdr);
2008 status = encode_putfh(&xdr, args->fh);
2009 if (!status)
2010 status = encode_getattr_one(&xdr,
2011 args->bitmask[0] & nfs4_pathconf_bitmap[0]);
2012 return status;
2013 }
2014
2015 /*
2016 * a STATFS request
2017 */
2018 static int nfs4_xdr_enc_statfs(struct rpc_rqst *req, __be32 *p, const struct nfs4_statfs_arg *args)
2019 {
2020 struct xdr_stream xdr;
2021 struct compound_hdr hdr = {
2022 .nops = 2,
2023 };
2024 int status;
2025
2026 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2027 encode_compound_hdr(&xdr, &hdr);
2028 status = encode_putfh(&xdr, args->fh);
2029 if (status == 0)
2030 status = encode_getattr_two(&xdr,
2031 args->bitmask[0] & nfs4_statfs_bitmap[0],
2032 args->bitmask[1] & nfs4_statfs_bitmap[1]);
2033 return status;
2034 }
2035
2036 /*
2037 * GETATTR_BITMAP request
2038 */
2039 static int nfs4_xdr_enc_server_caps(struct rpc_rqst *req, __be32 *p, const struct nfs_fh *fhandle)
2040 {
2041 struct xdr_stream xdr;
2042 struct compound_hdr hdr = {
2043 .nops = 2,
2044 };
2045 int status;
2046
2047 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2048 encode_compound_hdr(&xdr, &hdr);
2049 status = encode_putfh(&xdr, fhandle);
2050 if (status == 0)
2051 status = encode_getattr_one(&xdr, FATTR4_WORD0_SUPPORTED_ATTRS|
2052 FATTR4_WORD0_LINK_SUPPORT|
2053 FATTR4_WORD0_SYMLINK_SUPPORT|
2054 FATTR4_WORD0_ACLSUPPORT);
2055 return status;
2056 }
2057
2058 /*
2059 * a RENEW request
2060 */
2061 static int nfs4_xdr_enc_renew(struct rpc_rqst *req, __be32 *p, struct nfs_client *clp)
2062 {
2063 struct xdr_stream xdr;
2064 struct compound_hdr hdr = {
2065 .nops = 1,
2066 };
2067
2068 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2069 encode_compound_hdr(&xdr, &hdr);
2070 return encode_renew(&xdr, clp);
2071 }
2072
2073 /*
2074 * a SETCLIENTID request
2075 */
2076 static int nfs4_xdr_enc_setclientid(struct rpc_rqst *req, __be32 *p, struct nfs4_setclientid *sc)
2077 {
2078 struct xdr_stream xdr;
2079 struct compound_hdr hdr = {
2080 .nops = 1,
2081 };
2082
2083 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2084 encode_compound_hdr(&xdr, &hdr);
2085 return encode_setclientid(&xdr, sc);
2086 }
2087
2088 /*
2089 * a SETCLIENTID_CONFIRM request
2090 */
2091 static int nfs4_xdr_enc_setclientid_confirm(struct rpc_rqst *req, __be32 *p, struct nfs_client *clp)
2092 {
2093 struct xdr_stream xdr;
2094 struct compound_hdr hdr = {
2095 .nops = 3,
2096 };
2097 const u32 lease_bitmap[2] = { FATTR4_WORD0_LEASE_TIME, 0 };
2098 int status;
2099
2100 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2101 encode_compound_hdr(&xdr, &hdr);
2102 status = encode_setclientid_confirm(&xdr, clp);
2103 if (!status)
2104 status = encode_putrootfh(&xdr);
2105 if (!status)
2106 status = encode_fsinfo(&xdr, lease_bitmap);
2107 return status;
2108 }
2109
2110 /*
2111 * DELEGRETURN request
2112 */
2113 static int nfs4_xdr_enc_delegreturn(struct rpc_rqst *req, __be32 *p, const struct nfs4_delegreturnargs *args)
2114 {
2115 struct xdr_stream xdr;
2116 struct compound_hdr hdr = {
2117 .nops = 3,
2118 };
2119 int status;
2120
2121 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2122 encode_compound_hdr(&xdr, &hdr);
2123 status = encode_putfh(&xdr, args->fhandle);
2124 if (status != 0)
2125 goto out;
2126 status = encode_delegreturn(&xdr, args->stateid);
2127 if (status != 0)
2128 goto out;
2129 status = encode_getfattr(&xdr, args->bitmask);
2130 out:
2131 return status;
2132 }
2133
2134 /*
2135 * Encode FS_LOCATIONS request
2136 */
2137 static int nfs4_xdr_enc_fs_locations(struct rpc_rqst *req, __be32 *p, struct nfs4_fs_locations_arg *args)
2138 {
2139 struct xdr_stream xdr;
2140 struct compound_hdr hdr = {
2141 .nops = 3,
2142 };
2143 struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
2144 int replen;
2145 int status;
2146
2147 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
2148 encode_compound_hdr(&xdr, &hdr);
2149 if ((status = encode_putfh(&xdr, args->dir_fh)) != 0)
2150 goto out;
2151 if ((status = encode_lookup(&xdr, args->name)) != 0)
2152 goto out;
2153 if ((status = encode_fs_locations(&xdr, args->bitmask)) != 0)
2154 goto out;
2155 /* set up reply
2156 * toplevel_status + OP_PUTFH + status
2157 * + OP_LOOKUP + status + OP_GETATTR + status = 7
2158 */
2159 replen = (RPC_REPHDRSIZE + auth->au_rslack + 7) << 2;
2160 xdr_inline_pages(&req->rq_rcv_buf, replen, &args->page,
2161 0, PAGE_SIZE);
2162 out:
2163 return status;
2164 }
2165
2166 /*
2167 * START OF "GENERIC" DECODE ROUTINES.
2168 * These may look a little ugly since they are imported from a "generic"
2169 * set of XDR encode/decode routines which are intended to be shared by
2170 * all of our NFSv4 implementations (OpenBSD, MacOS X...).
2171 *
2172 * If the pain of reading these is too great, it should be a straightforward
2173 * task to translate them into Linux-specific versions which are more
2174 * consistent with the style used in NFSv2/v3...
2175 */
2176 #define READ32(x) (x) = ntohl(*p++)
2177 #define READ64(x) do { \
2178 (x) = (u64)ntohl(*p++) << 32; \
2179 (x) |= ntohl(*p++); \
2180 } while (0)
2181 #define READTIME(x) do { \
2182 p++; \
2183 (x.tv_sec) = ntohl(*p++); \
2184 (x.tv_nsec) = ntohl(*p++); \
2185 } while (0)
2186 #define COPYMEM(x,nbytes) do { \
2187 memcpy((x), p, nbytes); \
2188 p += XDR_QUADLEN(nbytes); \
2189 } while (0)
2190
2191 #define READ_BUF(nbytes) do { \
2192 p = xdr_inline_decode(xdr, nbytes); \
2193 if (unlikely(!p)) { \
2194 dprintk("nfs: %s: prematurely hit end of receive" \
2195 " buffer\n", __func__); \
2196 dprintk("nfs: %s: xdr->p=%p, bytes=%u, xdr->end=%p\n", \
2197 __func__, xdr->p, nbytes, xdr->end); \
2198 return -EIO; \
2199 } \
2200 } while (0)
2201
2202 static int decode_opaque_inline(struct xdr_stream *xdr, unsigned int *len, char **string)
2203 {
2204 __be32 *p;
2205
2206 READ_BUF(4);
2207 READ32(*len);
2208 READ_BUF(*len);
2209 *string = (char *)p;
2210 return 0;
2211 }
2212
2213 static int decode_compound_hdr(struct xdr_stream *xdr, struct compound_hdr *hdr)
2214 {
2215 __be32 *p;
2216
2217 READ_BUF(8);
2218 READ32(hdr->status);
2219 READ32(hdr->taglen);
2220
2221 READ_BUF(hdr->taglen + 4);
2222 hdr->tag = (char *)p;
2223 p += XDR_QUADLEN(hdr->taglen);
2224 READ32(hdr->nops);
2225 if (unlikely(hdr->nops < 1))
2226 return nfs4_stat_to_errno(hdr->status);
2227 return 0;
2228 }
2229
2230 static int decode_op_hdr(struct xdr_stream *xdr, enum nfs_opnum4 expected)
2231 {
2232 __be32 *p;
2233 uint32_t opnum;
2234 int32_t nfserr;
2235
2236 READ_BUF(8);
2237 READ32(opnum);
2238 if (opnum != expected) {
2239 dprintk("nfs: Server returned operation"
2240 " %d but we issued a request for %d\n",
2241 opnum, expected);
2242 return -EIO;
2243 }
2244 READ32(nfserr);
2245 if (nfserr != NFS_OK)
2246 return nfs4_stat_to_errno(nfserr);
2247 return 0;
2248 }
2249
2250 /* Dummy routine */
2251 static int decode_ace(struct xdr_stream *xdr, void *ace, struct nfs_client *clp)
2252 {
2253 __be32 *p;
2254 unsigned int strlen;
2255 char *str;
2256
2257 READ_BUF(12);
2258 return decode_opaque_inline(xdr, &strlen, &str);
2259 }
2260
2261 static int decode_attr_bitmap(struct xdr_stream *xdr, uint32_t *bitmap)
2262 {
2263 uint32_t bmlen;
2264 __be32 *p;
2265
2266 READ_BUF(4);
2267 READ32(bmlen);
2268
2269 bitmap[0] = bitmap[1] = 0;
2270 READ_BUF((bmlen << 2));
2271 if (bmlen > 0) {
2272 READ32(bitmap[0]);
2273 if (bmlen > 1)
2274 READ32(bitmap[1]);
2275 }
2276 return 0;
2277 }
2278
2279 static inline int decode_attr_length(struct xdr_stream *xdr, uint32_t *attrlen, __be32 **savep)
2280 {
2281 __be32 *p;
2282
2283 READ_BUF(4);
2284 READ32(*attrlen);
2285 *savep = xdr->p;
2286 return 0;
2287 }
2288
2289 static int decode_attr_supported(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *bitmask)
2290 {
2291 if (likely(bitmap[0] & FATTR4_WORD0_SUPPORTED_ATTRS)) {
2292 decode_attr_bitmap(xdr, bitmask);
2293 bitmap[0] &= ~FATTR4_WORD0_SUPPORTED_ATTRS;
2294 } else
2295 bitmask[0] = bitmask[1] = 0;
2296 dprintk("%s: bitmask=%08x:%08x\n", __func__, bitmask[0], bitmask[1]);
2297 return 0;
2298 }
2299
2300 static int decode_attr_type(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *type)
2301 {
2302 __be32 *p;
2303
2304 *type = 0;
2305 if (unlikely(bitmap[0] & (FATTR4_WORD0_TYPE - 1U)))
2306 return -EIO;
2307 if (likely(bitmap[0] & FATTR4_WORD0_TYPE)) {
2308 READ_BUF(4);
2309 READ32(*type);
2310 if (*type < NF4REG || *type > NF4NAMEDATTR) {
2311 dprintk("%s: bad type %d\n", __func__, *type);
2312 return -EIO;
2313 }
2314 bitmap[0] &= ~FATTR4_WORD0_TYPE;
2315 }
2316 dprintk("%s: type=0%o\n", __func__, nfs_type2fmt[*type].nfs2type);
2317 return 0;
2318 }
2319
2320 static int decode_attr_change(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *change)
2321 {
2322 __be32 *p;
2323
2324 *change = 0;
2325 if (unlikely(bitmap[0] & (FATTR4_WORD0_CHANGE - 1U)))
2326 return -EIO;
2327 if (likely(bitmap[0] & FATTR4_WORD0_CHANGE)) {
2328 READ_BUF(8);
2329 READ64(*change);
2330 bitmap[0] &= ~FATTR4_WORD0_CHANGE;
2331 }
2332 dprintk("%s: change attribute=%Lu\n", __func__,
2333 (unsigned long long)*change);
2334 return 0;
2335 }
2336
2337 static int decode_attr_size(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *size)
2338 {
2339 __be32 *p;
2340
2341 *size = 0;
2342 if (unlikely(bitmap[0] & (FATTR4_WORD0_SIZE - 1U)))
2343 return -EIO;
2344 if (likely(bitmap[0] & FATTR4_WORD0_SIZE)) {
2345 READ_BUF(8);
2346 READ64(*size);
2347 bitmap[0] &= ~FATTR4_WORD0_SIZE;
2348 }
2349 dprintk("%s: file size=%Lu\n", __func__, (unsigned long long)*size);
2350 return 0;
2351 }
2352
2353 static int decode_attr_link_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
2354 {
2355 __be32 *p;
2356
2357 *res = 0;
2358 if (unlikely(bitmap[0] & (FATTR4_WORD0_LINK_SUPPORT - 1U)))
2359 return -EIO;
2360 if (likely(bitmap[0] & FATTR4_WORD0_LINK_SUPPORT)) {
2361 READ_BUF(4);
2362 READ32(*res);
2363 bitmap[0] &= ~FATTR4_WORD0_LINK_SUPPORT;
2364 }
2365 dprintk("%s: link support=%s\n", __func__, *res == 0 ? "false" : "true");
2366 return 0;
2367 }
2368
2369 static int decode_attr_symlink_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
2370 {
2371 __be32 *p;
2372
2373 *res = 0;
2374 if (unlikely(bitmap[0] & (FATTR4_WORD0_SYMLINK_SUPPORT - 1U)))
2375 return -EIO;
2376 if (likely(bitmap[0] & FATTR4_WORD0_SYMLINK_SUPPORT)) {
2377 READ_BUF(4);
2378 READ32(*res);
2379 bitmap[0] &= ~FATTR4_WORD0_SYMLINK_SUPPORT;
2380 }
2381 dprintk("%s: symlink support=%s\n", __func__, *res == 0 ? "false" : "true");
2382 return 0;
2383 }
2384
2385 static int decode_attr_fsid(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_fsid *fsid)
2386 {
2387 __be32 *p;
2388
2389 fsid->major = 0;
2390 fsid->minor = 0;
2391 if (unlikely(bitmap[0] & (FATTR4_WORD0_FSID - 1U)))
2392 return -EIO;
2393 if (likely(bitmap[0] & FATTR4_WORD0_FSID)) {
2394 READ_BUF(16);
2395 READ64(fsid->major);
2396 READ64(fsid->minor);
2397 bitmap[0] &= ~FATTR4_WORD0_FSID;
2398 }
2399 dprintk("%s: fsid=(0x%Lx/0x%Lx)\n", __func__,
2400 (unsigned long long)fsid->major,
2401 (unsigned long long)fsid->minor);
2402 return 0;
2403 }
2404
2405 static int decode_attr_lease_time(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
2406 {
2407 __be32 *p;
2408
2409 *res = 60;
2410 if (unlikely(bitmap[0] & (FATTR4_WORD0_LEASE_TIME - 1U)))
2411 return -EIO;
2412 if (likely(bitmap[0] & FATTR4_WORD0_LEASE_TIME)) {
2413 READ_BUF(4);
2414 READ32(*res);
2415 bitmap[0] &= ~FATTR4_WORD0_LEASE_TIME;
2416 }
2417 dprintk("%s: file size=%u\n", __func__, (unsigned int)*res);
2418 return 0;
2419 }
2420
2421 static int decode_attr_aclsupport(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
2422 {
2423 __be32 *p;
2424
2425 *res = ACL4_SUPPORT_ALLOW_ACL|ACL4_SUPPORT_DENY_ACL;
2426 if (unlikely(bitmap[0] & (FATTR4_WORD0_ACLSUPPORT - 1U)))
2427 return -EIO;
2428 if (likely(bitmap[0] & FATTR4_WORD0_ACLSUPPORT)) {
2429 READ_BUF(4);
2430 READ32(*res);
2431 bitmap[0] &= ~FATTR4_WORD0_ACLSUPPORT;
2432 }
2433 dprintk("%s: ACLs supported=%u\n", __func__, (unsigned int)*res);
2434 return 0;
2435 }
2436
2437 static int decode_attr_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *fileid)
2438 {
2439 __be32 *p;
2440
2441 *fileid = 0;
2442 if (unlikely(bitmap[0] & (FATTR4_WORD0_FILEID - 1U)))
2443 return -EIO;
2444 if (likely(bitmap[0] & FATTR4_WORD0_FILEID)) {
2445 READ_BUF(8);
2446 READ64(*fileid);
2447 bitmap[0] &= ~FATTR4_WORD0_FILEID;
2448 }
2449 dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid);
2450 return 0;
2451 }
2452
2453 static int decode_attr_mounted_on_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *fileid)
2454 {
2455 __be32 *p;
2456
2457 *fileid = 0;
2458 if (unlikely(bitmap[1] & (FATTR4_WORD1_MOUNTED_ON_FILEID - 1U)))
2459 return -EIO;
2460 if (likely(bitmap[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)) {
2461 READ_BUF(8);
2462 READ64(*fileid);
2463 bitmap[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID;
2464 }
2465 dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid);
2466 return 0;
2467 }
2468
2469 static int decode_attr_files_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
2470 {
2471 __be32 *p;
2472 int status = 0;
2473
2474 *res = 0;
2475 if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_AVAIL - 1U)))
2476 return -EIO;
2477 if (likely(bitmap[0] & FATTR4_WORD0_FILES_AVAIL)) {
2478 READ_BUF(8);
2479 READ64(*res);
2480 bitmap[0] &= ~FATTR4_WORD0_FILES_AVAIL;
2481 }
2482 dprintk("%s: files avail=%Lu\n", __func__, (unsigned long long)*res);
2483 return status;
2484 }
2485
2486 static int decode_attr_files_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
2487 {
2488 __be32 *p;
2489 int status = 0;
2490
2491 *res = 0;
2492 if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_FREE - 1U)))
2493 return -EIO;
2494 if (likely(bitmap[0] & FATTR4_WORD0_FILES_FREE)) {
2495 READ_BUF(8);
2496 READ64(*res);
2497 bitmap[0] &= ~FATTR4_WORD0_FILES_FREE;
2498 }
2499 dprintk("%s: files free=%Lu\n", __func__, (unsigned long long)*res);
2500 return status;
2501 }
2502
2503 static int decode_attr_files_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
2504 {
2505 __be32 *p;
2506 int status = 0;
2507
2508 *res = 0;
2509 if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_TOTAL - 1U)))
2510 return -EIO;
2511 if (likely(bitmap[0] & FATTR4_WORD0_FILES_TOTAL)) {
2512 READ_BUF(8);
2513 READ64(*res);
2514 bitmap[0] &= ~FATTR4_WORD0_FILES_TOTAL;
2515 }
2516 dprintk("%s: files total=%Lu\n", __func__, (unsigned long long)*res);
2517 return status;
2518 }
2519
2520 static int decode_pathname(struct xdr_stream *xdr, struct nfs4_pathname *path)
2521 {
2522 u32 n;
2523 __be32 *p;
2524 int status = 0;
2525
2526 READ_BUF(4);
2527 READ32(n);
2528 if (n == 0)
2529 goto root_path;
2530 dprintk("path ");
2531 path->ncomponents = 0;
2532 while (path->ncomponents < n) {
2533 struct nfs4_string *component = &path->components[path->ncomponents];
2534 status = decode_opaque_inline(xdr, &component->len, &component->data);
2535 if (unlikely(status != 0))
2536 goto out_eio;
2537 if (path->ncomponents != n)
2538 dprintk("/");
2539 dprintk("%s", component->data);
2540 if (path->ncomponents < NFS4_PATHNAME_MAXCOMPONENTS)
2541 path->ncomponents++;
2542 else {
2543 dprintk("cannot parse %d components in path\n", n);
2544 goto out_eio;
2545 }
2546 }
2547 out:
2548 dprintk("\n");
2549 return status;
2550 root_path:
2551 /* a root pathname is sent as a zero component4 */
2552 path->ncomponents = 1;
2553 path->components[0].len=0;
2554 path->components[0].data=NULL;
2555 dprintk("path /\n");
2556 goto out;
2557 out_eio:
2558 dprintk(" status %d", status);
2559 status = -EIO;
2560 goto out;
2561 }
2562
2563 static int decode_attr_fs_locations(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs4_fs_locations *res)
2564 {
2565 int n;
2566 __be32 *p;
2567 int status = -EIO;
2568
2569 if (unlikely(bitmap[0] & (FATTR4_WORD0_FS_LOCATIONS -1U)))
2570 goto out;
2571 status = 0;
2572 if (unlikely(!(bitmap[0] & FATTR4_WORD0_FS_LOCATIONS)))
2573 goto out;
2574 dprintk("%s: fsroot ", __func__);
2575 status = decode_pathname(xdr, &res->fs_path);
2576 if (unlikely(status != 0))
2577 goto out;
2578 READ_BUF(4);
2579 READ32(n);
2580 if (n <= 0)
2581 goto out_eio;
2582 res->nlocations = 0;
2583 while (res->nlocations < n) {
2584 u32 m;
2585 struct nfs4_fs_location *loc = &res->locations[res->nlocations];
2586
2587 READ_BUF(4);
2588 READ32(m);
2589
2590 loc->nservers = 0;
2591 dprintk("%s: servers ", __func__);
2592 while (loc->nservers < m) {
2593 struct nfs4_string *server = &loc->servers[loc->nservers];
2594 status = decode_opaque_inline(xdr, &server->len, &server->data);
2595 if (unlikely(status != 0))
2596 goto out_eio;
2597 dprintk("%s ", server->data);
2598 if (loc->nservers < NFS4_FS_LOCATION_MAXSERVERS)
2599 loc->nservers++;
2600 else {
2601 unsigned int i;
2602 dprintk("%s: using first %u of %u servers "
2603 "returned for location %u\n",
2604 __func__,
2605 NFS4_FS_LOCATION_MAXSERVERS,
2606 m, res->nlocations);
2607 for (i = loc->nservers; i < m; i++) {
2608 unsigned int len;
2609 char *data;
2610 status = decode_opaque_inline(xdr, &len, &data);
2611 if (unlikely(status != 0))
2612 goto out_eio;
2613 }
2614 }
2615 }
2616 status = decode_pathname(xdr, &loc->rootpath);
2617 if (unlikely(status != 0))
2618 goto out_eio;
2619 if (res->nlocations < NFS4_FS_LOCATIONS_MAXENTRIES)
2620 res->nlocations++;
2621 }
2622 out:
2623 dprintk("%s: fs_locations done, error = %d\n", __func__, status);
2624 return status;
2625 out_eio:
2626 status = -EIO;
2627 goto out;
2628 }
2629
2630 static int decode_attr_maxfilesize(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
2631 {
2632 __be32 *p;
2633 int status = 0;
2634
2635 *res = 0;
2636 if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXFILESIZE - 1U)))
2637 return -EIO;
2638 if (likely(bitmap[0] & FATTR4_WORD0_MAXFILESIZE)) {
2639 READ_BUF(8);
2640 READ64(*res);
2641 bitmap[0] &= ~FATTR4_WORD0_MAXFILESIZE;
2642 }
2643 dprintk("%s: maxfilesize=%Lu\n", __func__, (unsigned long long)*res);
2644 return status;
2645 }
2646
2647 static int decode_attr_maxlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *maxlink)
2648 {
2649 __be32 *p;
2650 int status = 0;
2651
2652 *maxlink = 1;
2653 if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXLINK - 1U)))
2654 return -EIO;
2655 if (likely(bitmap[0] & FATTR4_WORD0_MAXLINK)) {
2656 READ_BUF(4);
2657 READ32(*maxlink);
2658 bitmap[0] &= ~FATTR4_WORD0_MAXLINK;
2659 }
2660 dprintk("%s: maxlink=%u\n", __func__, *maxlink);
2661 return status;
2662 }
2663
2664 static int decode_attr_maxname(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *maxname)
2665 {
2666 __be32 *p;
2667 int status = 0;
2668
2669 *maxname = 1024;
2670 if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXNAME - 1U)))
2671 return -EIO;
2672 if (likely(bitmap[0] & FATTR4_WORD0_MAXNAME)) {
2673 READ_BUF(4);
2674 READ32(*maxname);
2675 bitmap[0] &= ~FATTR4_WORD0_MAXNAME;
2676 }
2677 dprintk("%s: maxname=%u\n", __func__, *maxname);
2678 return status;
2679 }
2680
2681 static int decode_attr_maxread(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
2682 {
2683 __be32 *p;
2684 int status = 0;
2685
2686 *res = 1024;
2687 if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXREAD - 1U)))
2688 return -EIO;
2689 if (likely(bitmap[0] & FATTR4_WORD0_MAXREAD)) {
2690 uint64_t maxread;
2691 READ_BUF(8);
2692 READ64(maxread);
2693 if (maxread > 0x7FFFFFFF)
2694 maxread = 0x7FFFFFFF;
2695 *res = (uint32_t)maxread;
2696 bitmap[0] &= ~FATTR4_WORD0_MAXREAD;
2697 }
2698 dprintk("%s: maxread=%lu\n", __func__, (unsigned long)*res);
2699 return status;
2700 }
2701
2702 static int decode_attr_maxwrite(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
2703 {
2704 __be32 *p;
2705 int status = 0;
2706
2707 *res = 1024;
2708 if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXWRITE - 1U)))
2709 return -EIO;
2710 if (likely(bitmap[0] & FATTR4_WORD0_MAXWRITE)) {
2711 uint64_t maxwrite;
2712 READ_BUF(8);
2713 READ64(maxwrite);
2714 if (maxwrite > 0x7FFFFFFF)
2715 maxwrite = 0x7FFFFFFF;
2716 *res = (uint32_t)maxwrite;
2717 bitmap[0] &= ~FATTR4_WORD0_MAXWRITE;
2718 }
2719 dprintk("%s: maxwrite=%lu\n", __func__, (unsigned long)*res);
2720 return status;
2721 }
2722
2723 static int decode_attr_mode(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *mode)
2724 {
2725 __be32 *p;
2726
2727 *mode = 0;
2728 if (unlikely(bitmap[1] & (FATTR4_WORD1_MODE - 1U)))
2729 return -EIO;
2730 if (likely(bitmap[1] & FATTR4_WORD1_MODE)) {
2731 READ_BUF(4);
2732 READ32(*mode);
2733 *mode &= ~S_IFMT;
2734 bitmap[1] &= ~FATTR4_WORD1_MODE;
2735 }
2736 dprintk("%s: file mode=0%o\n", __func__, (unsigned int)*mode);
2737 return 0;
2738 }
2739
2740 static int decode_attr_nlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *nlink)
2741 {
2742 __be32 *p;
2743
2744 *nlink = 1;
2745 if (unlikely(bitmap[1] & (FATTR4_WORD1_NUMLINKS - 1U)))
2746 return -EIO;
2747 if (likely(bitmap[1] & FATTR4_WORD1_NUMLINKS)) {
2748 READ_BUF(4);
2749 READ32(*nlink);
2750 bitmap[1] &= ~FATTR4_WORD1_NUMLINKS;
2751 }
2752 dprintk("%s: nlink=%u\n", __func__, (unsigned int)*nlink);
2753 return 0;
2754 }
2755
2756 static int decode_attr_owner(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_client *clp, uint32_t *uid)
2757 {
2758 uint32_t len;
2759 __be32 *p;
2760
2761 *uid = -2;
2762 if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER - 1U)))
2763 return -EIO;
2764 if (likely(bitmap[1] & FATTR4_WORD1_OWNER)) {
2765 READ_BUF(4);
2766 READ32(len);
2767 READ_BUF(len);
2768 if (len < XDR_MAX_NETOBJ) {
2769 if (nfs_map_name_to_uid(clp, (char *)p, len, uid) != 0)
2770 dprintk("%s: nfs_map_name_to_uid failed!\n",
2771 __func__);
2772 } else
2773 dprintk("%s: name too long (%u)!\n",
2774 __func__, len);
2775 bitmap[1] &= ~FATTR4_WORD1_OWNER;
2776 }
2777 dprintk("%s: uid=%d\n", __func__, (int)*uid);
2778 return 0;
2779 }
2780
2781 static int decode_attr_group(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_client *clp, uint32_t *gid)
2782 {
2783 uint32_t len;
2784 __be32 *p;
2785
2786 *gid = -2;
2787 if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER_GROUP - 1U)))
2788 return -EIO;
2789 if (likely(bitmap[1] & FATTR4_WORD1_OWNER_GROUP)) {
2790 READ_BUF(4);
2791 READ32(len);
2792 READ_BUF(len);
2793 if (len < XDR_MAX_NETOBJ) {
2794 if (nfs_map_group_to_gid(clp, (char *)p, len, gid) != 0)
2795 dprintk("%s: nfs_map_group_to_gid failed!\n",
2796 __func__);
2797 } else
2798 dprintk("%s: name too long (%u)!\n",
2799 __func__, len);
2800 bitmap[1] &= ~FATTR4_WORD1_OWNER_GROUP;
2801 }
2802 dprintk("%s: gid=%d\n", __func__, (int)*gid);
2803 return 0;
2804 }
2805
2806 static int decode_attr_rdev(struct xdr_stream *xdr, uint32_t *bitmap, dev_t *rdev)
2807 {
2808 uint32_t major = 0, minor = 0;
2809 __be32 *p;
2810
2811 *rdev = MKDEV(0,0);
2812 if (unlikely(bitmap[1] & (FATTR4_WORD1_RAWDEV - 1U)))
2813 return -EIO;
2814 if (likely(bitmap[1] & FATTR4_WORD1_RAWDEV)) {
2815 dev_t tmp;
2816
2817 READ_BUF(8);
2818 READ32(major);
2819 READ32(minor);
2820 tmp = MKDEV(major, minor);
2821 if (MAJOR(tmp) == major && MINOR(tmp) == minor)
2822 *rdev = tmp;
2823 bitmap[1] &= ~ FATTR4_WORD1_RAWDEV;
2824 }
2825 dprintk("%s: rdev=(0x%x:0x%x)\n", __func__, major, minor);
2826 return 0;
2827 }
2828
2829 static int decode_attr_space_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
2830 {
2831 __be32 *p;
2832 int status = 0;
2833
2834 *res = 0;
2835 if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_AVAIL - 1U)))
2836 return -EIO;
2837 if (likely(bitmap[1] & FATTR4_WORD1_SPACE_AVAIL)) {
2838 READ_BUF(8);
2839 READ64(*res);
2840 bitmap[1] &= ~FATTR4_WORD1_SPACE_AVAIL;
2841 }
2842 dprintk("%s: space avail=%Lu\n", __func__, (unsigned long long)*res);
2843 return status;
2844 }
2845
2846 static int decode_attr_space_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
2847 {
2848 __be32 *p;
2849 int status = 0;
2850
2851 *res = 0;
2852 if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_FREE - 1U)))
2853 return -EIO;
2854 if (likely(bitmap[1] & FATTR4_WORD1_SPACE_FREE)) {
2855 READ_BUF(8);
2856 READ64(*res);
2857 bitmap[1] &= ~FATTR4_WORD1_SPACE_FREE;
2858 }
2859 dprintk("%s: space free=%Lu\n", __func__, (unsigned long long)*res);
2860 return status;
2861 }
2862
2863 static int decode_attr_space_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
2864 {
2865 __be32 *p;
2866 int status = 0;
2867
2868 *res = 0;
2869 if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_TOTAL - 1U)))
2870 return -EIO;
2871 if (likely(bitmap[1] & FATTR4_WORD1_SPACE_TOTAL)) {
2872 READ_BUF(8);
2873 READ64(*res);
2874 bitmap[1] &= ~FATTR4_WORD1_SPACE_TOTAL;
2875 }
2876 dprintk("%s: space total=%Lu\n", __func__, (unsigned long long)*res);
2877 return status;
2878 }
2879
2880 static int decode_attr_space_used(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *used)
2881 {
2882 __be32 *p;
2883
2884 *used = 0;
2885 if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_USED - 1U)))
2886 return -EIO;
2887 if (likely(bitmap[1] & FATTR4_WORD1_SPACE_USED)) {
2888 READ_BUF(8);
2889 READ64(*used);
2890 bitmap[1] &= ~FATTR4_WORD1_SPACE_USED;
2891 }
2892 dprintk("%s: space used=%Lu\n", __func__,
2893 (unsigned long long)*used);
2894 return 0;
2895 }
2896
2897 static int decode_attr_time(struct xdr_stream *xdr, struct timespec *time)
2898 {
2899 __be32 *p;
2900 uint64_t sec;
2901 uint32_t nsec;
2902
2903 READ_BUF(12);
2904 READ64(sec);
2905 READ32(nsec);
2906 time->tv_sec = (time_t)sec;
2907 time->tv_nsec = (long)nsec;
2908 return 0;
2909 }
2910
2911 static int decode_attr_time_access(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
2912 {
2913 int status = 0;
2914
2915 time->tv_sec = 0;
2916 time->tv_nsec = 0;
2917 if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_ACCESS - 1U)))
2918 return -EIO;
2919 if (likely(bitmap[1] & FATTR4_WORD1_TIME_ACCESS)) {
2920 status = decode_attr_time(xdr, time);
2921 bitmap[1] &= ~FATTR4_WORD1_TIME_ACCESS;
2922 }
2923 dprintk("%s: atime=%ld\n", __func__, (long)time->tv_sec);
2924 return status;
2925 }
2926
2927 static int decode_attr_time_metadata(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
2928 {
2929 int status = 0;
2930
2931 time->tv_sec = 0;
2932 time->tv_nsec = 0;
2933 if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_METADATA - 1U)))
2934 return -EIO;
2935 if (likely(bitmap[1] & FATTR4_WORD1_TIME_METADATA)) {
2936 status = decode_attr_time(xdr, time);
2937 bitmap[1] &= ~FATTR4_WORD1_TIME_METADATA;
2938 }
2939 dprintk("%s: ctime=%ld\n", __func__, (long)time->tv_sec);
2940 return status;
2941 }
2942
2943 static int decode_attr_time_modify(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
2944 {
2945 int status = 0;
2946
2947 time->tv_sec = 0;
2948 time->tv_nsec = 0;
2949 if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_MODIFY - 1U)))
2950 return -EIO;
2951 if (likely(bitmap[1] & FATTR4_WORD1_TIME_MODIFY)) {
2952 status = decode_attr_time(xdr, time);
2953 bitmap[1] &= ~FATTR4_WORD1_TIME_MODIFY;
2954 }
2955 dprintk("%s: mtime=%ld\n", __func__, (long)time->tv_sec);
2956 return status;
2957 }
2958
2959 static int verify_attr_len(struct xdr_stream *xdr, __be32 *savep, uint32_t attrlen)
2960 {
2961 unsigned int attrwords = XDR_QUADLEN(attrlen);
2962 unsigned int nwords = xdr->p - savep;
2963
2964 if (unlikely(attrwords != nwords)) {
2965 dprintk("%s: server returned incorrect attribute length: "
2966 "%u %c %u\n",
2967 __func__,
2968 attrwords << 2,
2969 (attrwords < nwords) ? '<' : '>',
2970 nwords << 2);
2971 return -EIO;
2972 }
2973 return 0;
2974 }
2975
2976 static int decode_change_info(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
2977 {
2978 __be32 *p;
2979
2980 READ_BUF(20);
2981 READ32(cinfo->atomic);
2982 READ64(cinfo->before);
2983 READ64(cinfo->after);
2984 return 0;
2985 }
2986
2987 static int decode_access(struct xdr_stream *xdr, struct nfs4_accessres *access)
2988 {
2989 __be32 *p;
2990 uint32_t supp, acc;
2991 int status;
2992
2993 status = decode_op_hdr(xdr, OP_ACCESS);
2994 if (status)
2995 return status;
2996 READ_BUF(8);
2997 READ32(supp);
2998 READ32(acc);
2999 access->supported = supp;
3000 access->access = acc;
3001 return 0;
3002 }
3003
3004 static int decode_close(struct xdr_stream *xdr, struct nfs_closeres *res)
3005 {
3006 __be32 *p;
3007 int status;
3008
3009 status = decode_op_hdr(xdr, OP_CLOSE);
3010 if (status != -EIO)
3011 nfs_increment_open_seqid(status, res->seqid);
3012 if (status)
3013 return status;
3014 READ_BUF(NFS4_STATEID_SIZE);
3015 COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
3016 return 0;
3017 }
3018
3019 static int decode_commit(struct xdr_stream *xdr, struct nfs_writeres *res)
3020 {
3021 __be32 *p;
3022 int status;
3023
3024 status = decode_op_hdr(xdr, OP_COMMIT);
3025 if (status)
3026 return status;
3027 READ_BUF(8);
3028 COPYMEM(res->verf->verifier, 8);
3029 return 0;
3030 }
3031
3032 static int decode_create(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
3033 {
3034 __be32 *p;
3035 uint32_t bmlen;
3036 int status;
3037
3038 status = decode_op_hdr(xdr, OP_CREATE);
3039 if (status)
3040 return status;
3041 if ((status = decode_change_info(xdr, cinfo)))
3042 return status;
3043 READ_BUF(4);
3044 READ32(bmlen);
3045 READ_BUF(bmlen << 2);
3046 return 0;
3047 }
3048
3049 static int decode_server_caps(struct xdr_stream *xdr, struct nfs4_server_caps_res *res)
3050 {
3051 __be32 *savep;
3052 uint32_t attrlen,
3053 bitmap[2] = {0};
3054 int status;
3055
3056 if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
3057 goto xdr_error;
3058 if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
3059 goto xdr_error;
3060 if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
3061 goto xdr_error;
3062 if ((status = decode_attr_supported(xdr, bitmap, res->attr_bitmask)) != 0)
3063 goto xdr_error;
3064 if ((status = decode_attr_link_support(xdr, bitmap, &res->has_links)) != 0)
3065 goto xdr_error;
3066 if ((status = decode_attr_symlink_support(xdr, bitmap, &res->has_symlinks)) != 0)
3067 goto xdr_error;
3068 if ((status = decode_attr_aclsupport(xdr, bitmap, &res->acl_bitmask)) != 0)
3069 goto xdr_error;
3070 status = verify_attr_len(xdr, savep, attrlen);
3071 xdr_error:
3072 dprintk("%s: xdr returned %d!\n", __func__, -status);
3073 return status;
3074 }
3075
3076 static int decode_statfs(struct xdr_stream *xdr, struct nfs_fsstat *fsstat)
3077 {
3078 __be32 *savep;
3079 uint32_t attrlen,
3080 bitmap[2] = {0};
3081 int status;
3082
3083 if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
3084 goto xdr_error;
3085 if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
3086 goto xdr_error;
3087 if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
3088 goto xdr_error;
3089
3090 if ((status = decode_attr_files_avail(xdr, bitmap, &fsstat->afiles)) != 0)
3091 goto xdr_error;
3092 if ((status = decode_attr_files_free(xdr, bitmap, &fsstat->ffiles)) != 0)
3093 goto xdr_error;
3094 if ((status = decode_attr_files_total(xdr, bitmap, &fsstat->tfiles)) != 0)
3095 goto xdr_error;
3096 if ((status = decode_attr_space_avail(xdr, bitmap, &fsstat->abytes)) != 0)
3097 goto xdr_error;
3098 if ((status = decode_attr_space_free(xdr, bitmap, &fsstat->fbytes)) != 0)
3099 goto xdr_error;
3100 if ((status = decode_attr_space_total(xdr, bitmap, &fsstat->tbytes)) != 0)
3101 goto xdr_error;
3102
3103 status = verify_attr_len(xdr, savep, attrlen);
3104 xdr_error:
3105 dprintk("%s: xdr returned %d!\n", __func__, -status);
3106 return status;
3107 }
3108
3109 static int decode_pathconf(struct xdr_stream *xdr, struct nfs_pathconf *pathconf)
3110 {
3111 __be32 *savep;
3112 uint32_t attrlen,
3113 bitmap[2] = {0};
3114 int status;
3115
3116 if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
3117 goto xdr_error;
3118 if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
3119 goto xdr_error;
3120 if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
3121 goto xdr_error;
3122
3123 if ((status = decode_attr_maxlink(xdr, bitmap, &pathconf->max_link)) != 0)
3124 goto xdr_error;
3125 if ((status = decode_attr_maxname(xdr, bitmap, &pathconf->max_namelen)) != 0)
3126 goto xdr_error;
3127
3128 status = verify_attr_len(xdr, savep, attrlen);
3129 xdr_error:
3130 dprintk("%s: xdr returned %d!\n", __func__, -status);
3131 return status;
3132 }
3133
3134 static int decode_getfattr(struct xdr_stream *xdr, struct nfs_fattr *fattr, const struct nfs_server *server)
3135 {
3136 __be32 *savep;
3137 uint32_t attrlen,
3138 bitmap[2] = {0},
3139 type;
3140 int status, fmode = 0;
3141 uint64_t fileid;
3142
3143 if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
3144 goto xdr_error;
3145 if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
3146 goto xdr_error;
3147
3148 fattr->bitmap[0] = bitmap[0];
3149 fattr->bitmap[1] = bitmap[1];
3150
3151 if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
3152 goto xdr_error;
3153
3154
3155 if ((status = decode_attr_type(xdr, bitmap, &type)) != 0)
3156 goto xdr_error;
3157 fattr->type = nfs_type2fmt[type].nfs2type;
3158 fmode = nfs_type2fmt[type].mode;
3159
3160 if ((status = decode_attr_change(xdr, bitmap, &fattr->change_attr)) != 0)
3161 goto xdr_error;
3162 if ((status = decode_attr_size(xdr, bitmap, &fattr->size)) != 0)
3163 goto xdr_error;
3164 if ((status = decode_attr_fsid(xdr, bitmap, &fattr->fsid)) != 0)
3165 goto xdr_error;
3166 if ((status = decode_attr_fileid(xdr, bitmap, &fattr->fileid)) != 0)
3167 goto xdr_error;
3168 if ((status = decode_attr_fs_locations(xdr, bitmap, container_of(fattr,
3169 struct nfs4_fs_locations,
3170 fattr))) != 0)
3171 goto xdr_error;
3172 if ((status = decode_attr_mode(xdr, bitmap, &fattr->mode)) != 0)
3173 goto xdr_error;
3174 fattr->mode |= fmode;
3175 if ((status = decode_attr_nlink(xdr, bitmap, &fattr->nlink)) != 0)
3176 goto xdr_error;
3177 if ((status = decode_attr_owner(xdr, bitmap, server->nfs_client, &fattr->uid)) != 0)
3178 goto xdr_error;
3179 if ((status = decode_attr_group(xdr, bitmap, server->nfs_client, &fattr->gid)) != 0)
3180 goto xdr_error;
3181 if ((status = decode_attr_rdev(xdr, bitmap, &fattr->rdev)) != 0)
3182 goto xdr_error;
3183 if ((status = decode_attr_space_used(xdr, bitmap, &fattr->du.nfs3.used)) != 0)
3184 goto xdr_error;
3185 if ((status = decode_attr_time_access(xdr, bitmap, &fattr->atime)) != 0)
3186 goto xdr_error;
3187 if ((status = decode_attr_time_metadata(xdr, bitmap, &fattr->ctime)) != 0)
3188 goto xdr_error;
3189 if ((status = decode_attr_time_modify(xdr, bitmap, &fattr->mtime)) != 0)
3190 goto xdr_error;
3191 if ((status = decode_attr_mounted_on_fileid(xdr, bitmap, &fileid)) != 0)
3192 goto xdr_error;
3193 if (fattr->fileid == 0 && fileid != 0)
3194 fattr->fileid = fileid;
3195 if ((status = verify_attr_len(xdr, savep, attrlen)) == 0)
3196 fattr->valid = NFS_ATTR_FATTR | NFS_ATTR_FATTR_V3 | NFS_ATTR_FATTR_V4;
3197 xdr_error:
3198 dprintk("%s: xdr returned %d\n", __func__, -status);
3199 return status;
3200 }
3201
3202
3203 static int decode_fsinfo(struct xdr_stream *xdr, struct nfs_fsinfo *fsinfo)
3204 {
3205 __be32 *savep;
3206 uint32_t attrlen, bitmap[2];
3207 int status;
3208
3209 if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
3210 goto xdr_error;
3211 if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
3212 goto xdr_error;
3213 if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
3214 goto xdr_error;
3215
3216 fsinfo->rtmult = fsinfo->wtmult = 512; /* ??? */
3217
3218 if ((status = decode_attr_lease_time(xdr, bitmap, &fsinfo->lease_time)) != 0)
3219 goto xdr_error;
3220 if ((status = decode_attr_maxfilesize(xdr, bitmap, &fsinfo->maxfilesize)) != 0)
3221 goto xdr_error;
3222 if ((status = decode_attr_maxread(xdr, bitmap, &fsinfo->rtmax)) != 0)
3223 goto xdr_error;
3224 fsinfo->rtpref = fsinfo->dtpref = fsinfo->rtmax;
3225 if ((status = decode_attr_maxwrite(xdr, bitmap, &fsinfo->wtmax)) != 0)
3226 goto xdr_error;
3227 fsinfo->wtpref = fsinfo->wtmax;
3228
3229 status = verify_attr_len(xdr, savep, attrlen);
3230 xdr_error:
3231 dprintk("%s: xdr returned %d!\n", __func__, -status);
3232 return status;
3233 }
3234
3235 static int decode_getfh(struct xdr_stream *xdr, struct nfs_fh *fh)
3236 {
3237 __be32 *p;
3238 uint32_t len;
3239 int status;
3240
3241 /* Zero handle first to allow comparisons */
3242 memset(fh, 0, sizeof(*fh));
3243
3244 status = decode_op_hdr(xdr, OP_GETFH);
3245 if (status)
3246 return status;
3247
3248 READ_BUF(4);
3249 READ32(len);
3250 if (len > NFS4_FHSIZE)
3251 return -EIO;
3252 fh->size = len;
3253 READ_BUF(len);
3254 COPYMEM(fh->data, len);
3255 return 0;
3256 }
3257
3258 static int decode_link(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
3259 {
3260 int status;
3261
3262 status = decode_op_hdr(xdr, OP_LINK);
3263 if (status)
3264 return status;
3265 return decode_change_info(xdr, cinfo);
3266 }
3267
3268 /*
3269 * We create the owner, so we know a proper owner.id length is 4.
3270 */
3271 static int decode_lock_denied (struct xdr_stream *xdr, struct file_lock *fl)
3272 {
3273 uint64_t offset, length, clientid;
3274 __be32 *p;
3275 uint32_t namelen, type;
3276
3277 READ_BUF(32);
3278 READ64(offset);
3279 READ64(length);
3280 READ32(type);
3281 if (fl != NULL) {
3282 fl->fl_start = (loff_t)offset;
3283 fl->fl_end = fl->fl_start + (loff_t)length - 1;
3284 if (length == ~(uint64_t)0)
3285 fl->fl_end = OFFSET_MAX;
3286 fl->fl_type = F_WRLCK;
3287 if (type & 1)
3288 fl->fl_type = F_RDLCK;
3289 fl->fl_pid = 0;
3290 }
3291 READ64(clientid);
3292 READ32(namelen);
3293 READ_BUF(namelen);
3294 return -NFS4ERR_DENIED;
3295 }
3296
3297 static int decode_lock(struct xdr_stream *xdr, struct nfs_lock_res *res)
3298 {
3299 __be32 *p;
3300 int status;
3301
3302 status = decode_op_hdr(xdr, OP_LOCK);
3303 if (status == -EIO)
3304 goto out;
3305 if (status == 0) {
3306 READ_BUF(NFS4_STATEID_SIZE);
3307 COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
3308 } else if (status == -NFS4ERR_DENIED)
3309 status = decode_lock_denied(xdr, NULL);
3310 if (res->open_seqid != NULL)
3311 nfs_increment_open_seqid(status, res->open_seqid);
3312 nfs_increment_lock_seqid(status, res->lock_seqid);
3313 out:
3314 return status;
3315 }
3316
3317 static int decode_lockt(struct xdr_stream *xdr, struct nfs_lockt_res *res)
3318 {
3319 int status;
3320 status = decode_op_hdr(xdr, OP_LOCKT);
3321 if (status == -NFS4ERR_DENIED)
3322 return decode_lock_denied(xdr, res->denied);
3323 return status;
3324 }
3325
3326 static int decode_locku(struct xdr_stream *xdr, struct nfs_locku_res *res)
3327 {
3328 __be32 *p;
3329 int status;
3330
3331 status = decode_op_hdr(xdr, OP_LOCKU);
3332 if (status != -EIO)
3333 nfs_increment_lock_seqid(status, res->seqid);
3334 if (status == 0) {
3335 READ_BUF(NFS4_STATEID_SIZE);
3336 COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
3337 }
3338 return status;
3339 }
3340
3341 static int decode_lookup(struct xdr_stream *xdr)
3342 {
3343 return decode_op_hdr(xdr, OP_LOOKUP);
3344 }
3345
3346 /* This is too sick! */
3347 static int decode_space_limit(struct xdr_stream *xdr, u64 *maxsize)
3348 {
3349 __be32 *p;
3350 uint32_t limit_type, nblocks, blocksize;
3351
3352 READ_BUF(12);
3353 READ32(limit_type);
3354 switch (limit_type) {
3355 case 1:
3356 READ64(*maxsize);
3357 break;
3358 case 2:
3359 READ32(nblocks);
3360 READ32(blocksize);
3361 *maxsize = (uint64_t)nblocks * (uint64_t)blocksize;
3362 }
3363 return 0;
3364 }
3365
3366 static int decode_delegation(struct xdr_stream *xdr, struct nfs_openres *res)
3367 {
3368 __be32 *p;
3369 uint32_t delegation_type;
3370
3371 READ_BUF(4);
3372 READ32(delegation_type);
3373 if (delegation_type == NFS4_OPEN_DELEGATE_NONE) {
3374 res->delegation_type = 0;
3375 return 0;
3376 }
3377 READ_BUF(NFS4_STATEID_SIZE+4);
3378 COPYMEM(res->delegation.data, NFS4_STATEID_SIZE);
3379 READ32(res->do_recall);
3380 switch (delegation_type) {
3381 case NFS4_OPEN_DELEGATE_READ:
3382 res->delegation_type = FMODE_READ;
3383 break;
3384 case NFS4_OPEN_DELEGATE_WRITE:
3385 res->delegation_type = FMODE_WRITE|FMODE_READ;
3386 if (decode_space_limit(xdr, &res->maxsize) < 0)
3387 return -EIO;
3388 }
3389 return decode_ace(xdr, NULL, res->server->nfs_client);
3390 }
3391
3392 static int decode_open(struct xdr_stream *xdr, struct nfs_openres *res)
3393 {
3394 __be32 *p;
3395 uint32_t savewords, bmlen, i;
3396 int status;
3397
3398 status = decode_op_hdr(xdr, OP_OPEN);
3399 if (status != -EIO)
3400 nfs_increment_open_seqid(status, res->seqid);
3401 if (status)
3402 return status;
3403 READ_BUF(NFS4_STATEID_SIZE);
3404 COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
3405
3406 decode_change_info(xdr, &res->cinfo);
3407
3408 READ_BUF(8);
3409 READ32(res->rflags);
3410 READ32(bmlen);
3411 if (bmlen > 10)
3412 goto xdr_error;
3413
3414 READ_BUF(bmlen << 2);
3415 savewords = min_t(uint32_t, bmlen, NFS4_BITMAP_SIZE);
3416 for (i = 0; i < savewords; ++i)
3417 READ32(res->attrset[i]);
3418 for (; i < NFS4_BITMAP_SIZE; i++)
3419 res->attrset[i] = 0;
3420
3421 return decode_delegation(xdr, res);
3422 xdr_error:
3423 dprintk("%s: Bitmap too large! Length = %u\n", __func__, bmlen);
3424 return -EIO;
3425 }
3426
3427 static int decode_open_confirm(struct xdr_stream *xdr, struct nfs_open_confirmres *res)
3428 {
3429 __be32 *p;
3430 int status;
3431
3432 status = decode_op_hdr(xdr, OP_OPEN_CONFIRM);
3433 if (status != -EIO)
3434 nfs_increment_open_seqid(status, res->seqid);
3435 if (status)
3436 return status;
3437 READ_BUF(NFS4_STATEID_SIZE);
3438 COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
3439 return 0;
3440 }
3441
3442 static int decode_open_downgrade(struct xdr_stream *xdr, struct nfs_closeres *res)
3443 {
3444 __be32 *p;
3445 int status;
3446
3447 status = decode_op_hdr(xdr, OP_OPEN_DOWNGRADE);
3448 if (status != -EIO)
3449 nfs_increment_open_seqid(status, res->seqid);
3450 if (status)
3451 return status;
3452 READ_BUF(NFS4_STATEID_SIZE);
3453 COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
3454 return 0;
3455 }
3456
3457 static int decode_putfh(struct xdr_stream *xdr)
3458 {
3459 return decode_op_hdr(xdr, OP_PUTFH);
3460 }
3461
3462 static int decode_putrootfh(struct xdr_stream *xdr)
3463 {
3464 return decode_op_hdr(xdr, OP_PUTROOTFH);
3465 }
3466
3467 static int decode_read(struct xdr_stream *xdr, struct rpc_rqst *req, struct nfs_readres *res)
3468 {
3469 struct kvec *iov = req->rq_rcv_buf.head;
3470 __be32 *p;
3471 uint32_t count, eof, recvd, hdrlen;
3472 int status;
3473
3474 status = decode_op_hdr(xdr, OP_READ);
3475 if (status)
3476 return status;
3477 READ_BUF(8);
3478 READ32(eof);
3479 READ32(count);
3480 hdrlen = (u8 *) p - (u8 *) iov->iov_base;
3481 recvd = req->rq_rcv_buf.len - hdrlen;
3482 if (count > recvd) {
3483 dprintk("NFS: server cheating in read reply: "
3484 "count %u > recvd %u\n", count, recvd);
3485 count = recvd;
3486 eof = 0;
3487 }
3488 xdr_read_pages(xdr, count);
3489 res->eof = eof;
3490 res->count = count;
3491 return 0;
3492 }
3493
3494 static int decode_readdir(struct xdr_stream *xdr, struct rpc_rqst *req, struct nfs4_readdir_res *readdir)
3495 {
3496 struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
3497 struct page *page = *rcvbuf->pages;
3498 struct kvec *iov = rcvbuf->head;
3499 size_t hdrlen;
3500 u32 recvd, pglen = rcvbuf->page_len;
3501 __be32 *end, *entry, *p, *kaddr;
3502 unsigned int nr = 0;
3503 int status;
3504
3505 status = decode_op_hdr(xdr, OP_READDIR);
3506 if (status)
3507 return status;
3508 READ_BUF(8);
3509 COPYMEM(readdir->verifier.data, 8);
3510 dprintk("%s: verifier = %08x:%08x\n",
3511 __func__,
3512 ((u32 *)readdir->verifier.data)[0],
3513 ((u32 *)readdir->verifier.data)[1]);
3514
3515
3516 hdrlen = (char *) p - (char *) iov->iov_base;
3517 recvd = rcvbuf->len - hdrlen;
3518 if (pglen > recvd)
3519 pglen = recvd;
3520 xdr_read_pages(xdr, pglen);
3521
3522 BUG_ON(pglen + readdir->pgbase > PAGE_CACHE_SIZE);
3523 kaddr = p = kmap_atomic(page, KM_USER0);
3524 end = p + ((pglen + readdir->pgbase) >> 2);
3525 entry = p;
3526
3527 /* Make sure the packet actually has a value_follows and EOF entry */
3528 if ((entry + 1) > end)
3529 goto short_pkt;
3530
3531 for (; *p++; nr++) {
3532 u32 len, attrlen, xlen;
3533 if (end - p < 3)
3534 goto short_pkt;
3535 dprintk("cookie = %Lu, ", *((unsigned long long *)p));
3536 p += 2; /* cookie */
3537 len = ntohl(*p++); /* filename length */
3538 if (len > NFS4_MAXNAMLEN) {
3539 dprintk("NFS: giant filename in readdir (len 0x%x)\n",
3540 len);
3541 goto err_unmap;
3542 }
3543 xlen = XDR_QUADLEN(len);
3544 if (end - p < xlen + 1)
3545 goto short_pkt;
3546 dprintk("filename = %*s\n", len, (char *)p);
3547 p += xlen;
3548 len = ntohl(*p++); /* bitmap length */
3549 if (end - p < len + 1)
3550 goto short_pkt;
3551 p += len;
3552 attrlen = XDR_QUADLEN(ntohl(*p++));
3553 if (end - p < attrlen + 2)
3554 goto short_pkt;
3555 p += attrlen; /* attributes */
3556 entry = p;
3557 }
3558 /*
3559 * Apparently some server sends responses that are a valid size, but
3560 * contain no entries, and have value_follows==0 and EOF==0. For
3561 * those, just set the EOF marker.
3562 */
3563 if (!nr && entry[1] == 0) {
3564 dprintk("NFS: readdir reply truncated!\n");
3565 entry[1] = 1;
3566 }
3567 out:
3568 kunmap_atomic(kaddr, KM_USER0);
3569 return 0;
3570 short_pkt:
3571 /*
3572 * When we get a short packet there are 2 possibilities. We can
3573 * return an error, or fix up the response to look like a valid
3574 * response and return what we have so far. If there are no
3575 * entries and the packet was short, then return -EIO. If there
3576 * are valid entries in the response, return them and pretend that
3577 * the call was successful, but incomplete. The caller can retry the
3578 * readdir starting at the last cookie.
3579 */
3580 dprintk("%s: short packet at entry %d\n", __func__, nr);
3581 entry[0] = entry[1] = 0;
3582 if (nr)
3583 goto out;
3584 err_unmap:
3585 kunmap_atomic(kaddr, KM_USER0);
3586 return -errno_NFSERR_IO;
3587 }
3588
3589 static int decode_readlink(struct xdr_stream *xdr, struct rpc_rqst *req)
3590 {
3591 struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
3592 struct kvec *iov = rcvbuf->head;
3593 size_t hdrlen;
3594 u32 len, recvd;
3595 __be32 *p;
3596 char *kaddr;
3597 int status;
3598
3599 status = decode_op_hdr(xdr, OP_READLINK);
3600 if (status)
3601 return status;
3602
3603 /* Convert length of symlink */
3604 READ_BUF(4);
3605 READ32(len);
3606 if (len >= rcvbuf->page_len || len <= 0) {
3607 dprintk("nfs: server returned giant symlink!\n");
3608 return -ENAMETOOLONG;
3609 }
3610 hdrlen = (char *) xdr->p - (char *) iov->iov_base;
3611 recvd = req->rq_rcv_buf.len - hdrlen;
3612 if (recvd < len) {
3613 dprintk("NFS: server cheating in readlink reply: "
3614 "count %u > recvd %u\n", len, recvd);
3615 return -EIO;
3616 }
3617 xdr_read_pages(xdr, len);
3618 /*
3619 * The XDR encode routine has set things up so that
3620 * the link text will be copied directly into the
3621 * buffer. We just have to do overflow-checking,
3622 * and and null-terminate the text (the VFS expects
3623 * null-termination).
3624 */
3625 kaddr = (char *)kmap_atomic(rcvbuf->pages[0], KM_USER0);
3626 kaddr[len+rcvbuf->page_base] = '\0';
3627 kunmap_atomic(kaddr, KM_USER0);
3628 return 0;
3629 }
3630
3631 static int decode_remove(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
3632 {
3633 int status;
3634
3635 status = decode_op_hdr(xdr, OP_REMOVE);
3636 if (status)
3637 goto out;
3638 status = decode_change_info(xdr, cinfo);
3639 out:
3640 return status;
3641 }
3642
3643 static int decode_rename(struct xdr_stream *xdr, struct nfs4_change_info *old_cinfo,
3644 struct nfs4_change_info *new_cinfo)
3645 {
3646 int status;
3647
3648 status = decode_op_hdr(xdr, OP_RENAME);
3649 if (status)
3650 goto out;
3651 if ((status = decode_change_info(xdr, old_cinfo)))
3652 goto out;
3653 status = decode_change_info(xdr, new_cinfo);
3654 out:
3655 return status;
3656 }
3657
3658 static int decode_renew(struct xdr_stream *xdr)
3659 {
3660 return decode_op_hdr(xdr, OP_RENEW);
3661 }
3662
3663 static int
3664 decode_restorefh(struct xdr_stream *xdr)
3665 {
3666 return decode_op_hdr(xdr, OP_RESTOREFH);
3667 }
3668
3669 static int decode_getacl(struct xdr_stream *xdr, struct rpc_rqst *req,
3670 size_t *acl_len)
3671 {
3672 __be32 *savep;
3673 uint32_t attrlen,
3674 bitmap[2] = {0};
3675 struct kvec *iov = req->rq_rcv_buf.head;
3676 int status;
3677
3678 *acl_len = 0;
3679 if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
3680 goto out;
3681 if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
3682 goto out;
3683 if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
3684 goto out;
3685
3686 if (unlikely(bitmap[0] & (FATTR4_WORD0_ACL - 1U)))
3687 return -EIO;
3688 if (likely(bitmap[0] & FATTR4_WORD0_ACL)) {
3689 size_t hdrlen;
3690 u32 recvd;
3691
3692 /* We ignore &savep and don't do consistency checks on
3693 * the attr length. Let userspace figure it out.... */
3694 hdrlen = (u8 *)xdr->p - (u8 *)iov->iov_base;
3695 recvd = req->rq_rcv_buf.len - hdrlen;
3696 if (attrlen > recvd) {
3697 dprintk("NFS: server cheating in getattr"
3698 " acl reply: attrlen %u > recvd %u\n",
3699 attrlen, recvd);
3700 return -EINVAL;
3701 }
3702 xdr_read_pages(xdr, attrlen);
3703 *acl_len = attrlen;
3704 } else
3705 status = -EOPNOTSUPP;
3706
3707 out:
3708 return status;
3709 }
3710
3711 static int
3712 decode_savefh(struct xdr_stream *xdr)
3713 {
3714 return decode_op_hdr(xdr, OP_SAVEFH);
3715 }
3716
3717 static int decode_setattr(struct xdr_stream *xdr, struct nfs_setattrres *res)
3718 {
3719 __be32 *p;
3720 uint32_t bmlen;
3721 int status;
3722
3723
3724 status = decode_op_hdr(xdr, OP_SETATTR);
3725 if (status)
3726 return status;
3727 READ_BUF(4);
3728 READ32(bmlen);
3729 READ_BUF(bmlen << 2);
3730 return 0;
3731 }
3732
3733 static int decode_setclientid(struct xdr_stream *xdr, struct nfs_client *clp)
3734 {
3735 __be32 *p;
3736 uint32_t opnum;
3737 int32_t nfserr;
3738
3739 READ_BUF(8);
3740 READ32(opnum);
3741 if (opnum != OP_SETCLIENTID) {
3742 dprintk("nfs: decode_setclientid: Server returned operation"
3743 " %d\n", opnum);
3744 return -EIO;
3745 }
3746 READ32(nfserr);
3747 if (nfserr == NFS_OK) {
3748 READ_BUF(8 + NFS4_VERIFIER_SIZE);
3749 READ64(clp->cl_clientid);
3750 COPYMEM(clp->cl_confirm.data, NFS4_VERIFIER_SIZE);
3751 } else if (nfserr == NFSERR_CLID_INUSE) {
3752 uint32_t len;
3753
3754 /* skip netid string */
3755 READ_BUF(4);
3756 READ32(len);
3757 READ_BUF(len);
3758
3759 /* skip uaddr string */
3760 READ_BUF(4);
3761 READ32(len);
3762 READ_BUF(len);
3763 return -NFSERR_CLID_INUSE;
3764 } else
3765 return nfs4_stat_to_errno(nfserr);
3766
3767 return 0;
3768 }
3769
3770 static int decode_setclientid_confirm(struct xdr_stream *xdr)
3771 {
3772 return decode_op_hdr(xdr, OP_SETCLIENTID_CONFIRM);
3773 }
3774
3775 static int decode_write(struct xdr_stream *xdr, struct nfs_writeres *res)
3776 {
3777 __be32 *p;
3778 int status;
3779
3780 status = decode_op_hdr(xdr, OP_WRITE);
3781 if (status)
3782 return status;
3783
3784 READ_BUF(16);
3785 READ32(res->count);
3786 READ32(res->verf->committed);
3787 COPYMEM(res->verf->verifier, 8);
3788 return 0;
3789 }
3790
3791 static int decode_delegreturn(struct xdr_stream *xdr)
3792 {
3793 return decode_op_hdr(xdr, OP_DELEGRETURN);
3794 }
3795
3796 /*
3797 * Decode OPEN_DOWNGRADE response
3798 */
3799 static int nfs4_xdr_dec_open_downgrade(struct rpc_rqst *rqstp, __be32 *p, struct nfs_closeres *res)
3800 {
3801 struct xdr_stream xdr;
3802 struct compound_hdr hdr;
3803 int status;
3804
3805 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
3806 status = decode_compound_hdr(&xdr, &hdr);
3807 if (status)
3808 goto out;
3809 status = decode_putfh(&xdr);
3810 if (status)
3811 goto out;
3812 status = decode_open_downgrade(&xdr, res);
3813 if (status != 0)
3814 goto out;
3815 decode_getfattr(&xdr, res->fattr, res->server);
3816 out:
3817 return status;
3818 }
3819
3820 /*
3821 * END OF "GENERIC" DECODE ROUTINES.
3822 */
3823
3824 /*
3825 * Decode ACCESS response
3826 */
3827 static int nfs4_xdr_dec_access(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_accessres *res)
3828 {
3829 struct xdr_stream xdr;
3830 struct compound_hdr hdr;
3831 int status;
3832
3833 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
3834 if ((status = decode_compound_hdr(&xdr, &hdr)) != 0)
3835 goto out;
3836 status = decode_putfh(&xdr);
3837 if (status != 0)
3838 goto out;
3839 status = decode_access(&xdr, res);
3840 if (status != 0)
3841 goto out;
3842 decode_getfattr(&xdr, res->fattr, res->server);
3843 out:
3844 return status;
3845 }
3846
3847 /*
3848 * Decode LOOKUP response
3849 */
3850 static int nfs4_xdr_dec_lookup(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_lookup_res *res)
3851 {
3852 struct xdr_stream xdr;
3853 struct compound_hdr hdr;
3854 int status;
3855
3856 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
3857 if ((status = decode_compound_hdr(&xdr, &hdr)) != 0)
3858 goto out;
3859 if ((status = decode_putfh(&xdr)) != 0)
3860 goto out;
3861 if ((status = decode_lookup(&xdr)) != 0)
3862 goto out;
3863 if ((status = decode_getfh(&xdr, res->fh)) != 0)
3864 goto out;
3865 status = decode_getfattr(&xdr, res->fattr, res->server);
3866 out:
3867 return status;
3868 }
3869
3870 /*
3871 * Decode LOOKUP_ROOT response
3872 */
3873 static int nfs4_xdr_dec_lookup_root(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_lookup_res *res)
3874 {
3875 struct xdr_stream xdr;
3876 struct compound_hdr hdr;
3877 int status;
3878
3879 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
3880 if ((status = decode_compound_hdr(&xdr, &hdr)) != 0)
3881 goto out;
3882 if ((status = decode_putrootfh(&xdr)) != 0)
3883 goto out;
3884 if ((status = decode_getfh(&xdr, res->fh)) == 0)
3885 status = decode_getfattr(&xdr, res->fattr, res->server);
3886 out:
3887 return status;
3888 }
3889
3890 /*
3891 * Decode REMOVE response
3892 */
3893 static int nfs4_xdr_dec_remove(struct rpc_rqst *rqstp, __be32 *p, struct nfs_removeres *res)
3894 {
3895 struct xdr_stream xdr;
3896 struct compound_hdr hdr;
3897 int status;
3898
3899 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
3900 if ((status = decode_compound_hdr(&xdr, &hdr)) != 0)
3901 goto out;
3902 if ((status = decode_putfh(&xdr)) != 0)
3903 goto out;
3904 if ((status = decode_remove(&xdr, &res->cinfo)) != 0)
3905 goto out;
3906 decode_getfattr(&xdr, &res->dir_attr, res->server);
3907 out:
3908 return status;
3909 }
3910
3911 /*
3912 * Decode RENAME response
3913 */
3914 static int nfs4_xdr_dec_rename(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_rename_res *res)
3915 {
3916 struct xdr_stream xdr;
3917 struct compound_hdr hdr;
3918 int status;
3919
3920 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
3921 if ((status = decode_compound_hdr(&xdr, &hdr)) != 0)
3922 goto out;
3923 if ((status = decode_putfh(&xdr)) != 0)
3924 goto out;
3925 if ((status = decode_savefh(&xdr)) != 0)
3926 goto out;
3927 if ((status = decode_putfh(&xdr)) != 0)
3928 goto out;
3929 if ((status = decode_rename(&xdr, &res->old_cinfo, &res->new_cinfo)) != 0)
3930 goto out;
3931 /* Current FH is target directory */
3932 if (decode_getfattr(&xdr, res->new_fattr, res->server) != 0)
3933 goto out;
3934 if ((status = decode_restorefh(&xdr)) != 0)
3935 goto out;
3936 decode_getfattr(&xdr, res->old_fattr, res->server);
3937 out:
3938 return status;
3939 }
3940
3941 /*
3942 * Decode LINK response
3943 */
3944 static int nfs4_xdr_dec_link(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_link_res *res)
3945 {
3946 struct xdr_stream xdr;
3947 struct compound_hdr hdr;
3948 int status;
3949
3950 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
3951 if ((status = decode_compound_hdr(&xdr, &hdr)) != 0)
3952 goto out;
3953 if ((status = decode_putfh(&xdr)) != 0)
3954 goto out;
3955 if ((status = decode_savefh(&xdr)) != 0)
3956 goto out;
3957 if ((status = decode_putfh(&xdr)) != 0)
3958 goto out;
3959 if ((status = decode_link(&xdr, &res->cinfo)) != 0)
3960 goto out;
3961 /*
3962 * Note order: OP_LINK leaves the directory as the current
3963 * filehandle.
3964 */
3965 if (decode_getfattr(&xdr, res->dir_attr, res->server) != 0)
3966 goto out;
3967 if ((status = decode_restorefh(&xdr)) != 0)
3968 goto out;
3969 decode_getfattr(&xdr, res->fattr, res->server);
3970 out:
3971 return status;
3972 }
3973
3974 /*
3975 * Decode CREATE response
3976 */
3977 static int nfs4_xdr_dec_create(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_create_res *res)
3978 {
3979 struct xdr_stream xdr;
3980 struct compound_hdr hdr;
3981 int status;
3982
3983 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
3984 if ((status = decode_compound_hdr(&xdr, &hdr)) != 0)
3985 goto out;
3986 if ((status = decode_putfh(&xdr)) != 0)
3987 goto out;
3988 if ((status = decode_savefh(&xdr)) != 0)
3989 goto out;
3990 if ((status = decode_create(&xdr,&res->dir_cinfo)) != 0)
3991 goto out;
3992 if ((status = decode_getfh(&xdr, res->fh)) != 0)
3993 goto out;
3994 if (decode_getfattr(&xdr, res->fattr, res->server) != 0)
3995 goto out;
3996 if ((status = decode_restorefh(&xdr)) != 0)
3997 goto out;
3998 decode_getfattr(&xdr, res->dir_fattr, res->server);
3999 out:
4000 return status;
4001 }
4002
4003 /*
4004 * Decode SYMLINK response
4005 */
4006 static int nfs4_xdr_dec_symlink(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_create_res *res)
4007 {
4008 return nfs4_xdr_dec_create(rqstp, p, res);
4009 }
4010
4011 /*
4012 * Decode GETATTR response
4013 */
4014 static int nfs4_xdr_dec_getattr(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_getattr_res *res)
4015 {
4016 struct xdr_stream xdr;
4017 struct compound_hdr hdr;
4018 int status;
4019
4020 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4021 status = decode_compound_hdr(&xdr, &hdr);
4022 if (status)
4023 goto out;
4024 status = decode_putfh(&xdr);
4025 if (status)
4026 goto out;
4027 status = decode_getfattr(&xdr, res->fattr, res->server);
4028 out:
4029 return status;
4030
4031 }
4032
4033 /*
4034 * Encode an SETACL request
4035 */
4036 static int
4037 nfs4_xdr_enc_setacl(struct rpc_rqst *req, __be32 *p, struct nfs_setaclargs *args)
4038 {
4039 struct xdr_stream xdr;
4040 struct compound_hdr hdr = {
4041 .nops = 2,
4042 };
4043 int status;
4044
4045 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
4046 encode_compound_hdr(&xdr, &hdr);
4047 status = encode_putfh(&xdr, args->fh);
4048 if (status)
4049 goto out;
4050 status = encode_setacl(&xdr, args);
4051 out:
4052 return status;
4053 }
4054 /*
4055 * Decode SETACL response
4056 */
4057 static int
4058 nfs4_xdr_dec_setacl(struct rpc_rqst *rqstp, __be32 *p, void *res)
4059 {
4060 struct xdr_stream xdr;
4061 struct compound_hdr hdr;
4062 int status;
4063
4064 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4065 status = decode_compound_hdr(&xdr, &hdr);
4066 if (status)
4067 goto out;
4068 status = decode_putfh(&xdr);
4069 if (status)
4070 goto out;
4071 status = decode_setattr(&xdr, res);
4072 out:
4073 return status;
4074 }
4075
4076 /*
4077 * Decode GETACL response
4078 */
4079 static int
4080 nfs4_xdr_dec_getacl(struct rpc_rqst *rqstp, __be32 *p, size_t *acl_len)
4081 {
4082 struct xdr_stream xdr;
4083 struct compound_hdr hdr;
4084 int status;
4085
4086 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4087 status = decode_compound_hdr(&xdr, &hdr);
4088 if (status)
4089 goto out;
4090 status = decode_putfh(&xdr);
4091 if (status)
4092 goto out;
4093 status = decode_getacl(&xdr, rqstp, acl_len);
4094
4095 out:
4096 return status;
4097 }
4098
4099 /*
4100 * Decode CLOSE response
4101 */
4102 static int nfs4_xdr_dec_close(struct rpc_rqst *rqstp, __be32 *p, struct nfs_closeres *res)
4103 {
4104 struct xdr_stream xdr;
4105 struct compound_hdr hdr;
4106 int status;
4107
4108 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4109 status = decode_compound_hdr(&xdr, &hdr);
4110 if (status)
4111 goto out;
4112 status = decode_putfh(&xdr);
4113 if (status)
4114 goto out;
4115 status = decode_close(&xdr, res);
4116 if (status != 0)
4117 goto out;
4118 /*
4119 * Note: Server may do delete on close for this file
4120 * in which case the getattr call will fail with
4121 * an ESTALE error. Shouldn't be a problem,
4122 * though, since fattr->valid will remain unset.
4123 */
4124 decode_getfattr(&xdr, res->fattr, res->server);
4125 out:
4126 return status;
4127 }
4128
4129 /*
4130 * Decode OPEN response
4131 */
4132 static int nfs4_xdr_dec_open(struct rpc_rqst *rqstp, __be32 *p, struct nfs_openres *res)
4133 {
4134 struct xdr_stream xdr;
4135 struct compound_hdr hdr;
4136 int status;
4137
4138 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4139 status = decode_compound_hdr(&xdr, &hdr);
4140 if (status)
4141 goto out;
4142 status = decode_putfh(&xdr);
4143 if (status)
4144 goto out;
4145 status = decode_savefh(&xdr);
4146 if (status)
4147 goto out;
4148 status = decode_open(&xdr, res);
4149 if (status)
4150 goto out;
4151 if (decode_getfh(&xdr, &res->fh) != 0)
4152 goto out;
4153 if (decode_getfattr(&xdr, res->f_attr, res->server) != 0)
4154 goto out;
4155 if (decode_restorefh(&xdr) != 0)
4156 goto out;
4157 decode_getfattr(&xdr, res->dir_attr, res->server);
4158 out:
4159 return status;
4160 }
4161
4162 /*
4163 * Decode OPEN_CONFIRM response
4164 */
4165 static int nfs4_xdr_dec_open_confirm(struct rpc_rqst *rqstp, __be32 *p, struct nfs_open_confirmres *res)
4166 {
4167 struct xdr_stream xdr;
4168 struct compound_hdr hdr;
4169 int status;
4170
4171 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4172 status = decode_compound_hdr(&xdr, &hdr);
4173 if (status)
4174 goto out;
4175 status = decode_putfh(&xdr);
4176 if (status)
4177 goto out;
4178 status = decode_open_confirm(&xdr, res);
4179 out:
4180 return status;
4181 }
4182
4183 /*
4184 * Decode OPEN response
4185 */
4186 static int nfs4_xdr_dec_open_noattr(struct rpc_rqst *rqstp, __be32 *p, struct nfs_openres *res)
4187 {
4188 struct xdr_stream xdr;
4189 struct compound_hdr hdr;
4190 int status;
4191
4192 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4193 status = decode_compound_hdr(&xdr, &hdr);
4194 if (status)
4195 goto out;
4196 status = decode_putfh(&xdr);
4197 if (status)
4198 goto out;
4199 status = decode_open(&xdr, res);
4200 if (status)
4201 goto out;
4202 decode_getfattr(&xdr, res->f_attr, res->server);
4203 out:
4204 return status;
4205 }
4206
4207 /*
4208 * Decode SETATTR response
4209 */
4210 static int nfs4_xdr_dec_setattr(struct rpc_rqst *rqstp, __be32 *p, struct nfs_setattrres *res)
4211 {
4212 struct xdr_stream xdr;
4213 struct compound_hdr hdr;
4214 int status;
4215
4216 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4217 status = decode_compound_hdr(&xdr, &hdr);
4218 if (status)
4219 goto out;
4220 status = decode_putfh(&xdr);
4221 if (status)
4222 goto out;
4223 status = decode_setattr(&xdr, res);
4224 if (status)
4225 goto out;
4226 status = decode_getfattr(&xdr, res->fattr, res->server);
4227 if (status == NFS4ERR_DELAY)
4228 status = 0;
4229 out:
4230 return status;
4231 }
4232
4233 /*
4234 * Decode LOCK response
4235 */
4236 static int nfs4_xdr_dec_lock(struct rpc_rqst *rqstp, __be32 *p, struct nfs_lock_res *res)
4237 {
4238 struct xdr_stream xdr;
4239 struct compound_hdr hdr;
4240 int status;
4241
4242 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4243 status = decode_compound_hdr(&xdr, &hdr);
4244 if (status)
4245 goto out;
4246 status = decode_putfh(&xdr);
4247 if (status)
4248 goto out;
4249 status = decode_lock(&xdr, res);
4250 out:
4251 return status;
4252 }
4253
4254 /*
4255 * Decode LOCKT response
4256 */
4257 static int nfs4_xdr_dec_lockt(struct rpc_rqst *rqstp, __be32 *p, struct nfs_lockt_res *res)
4258 {
4259 struct xdr_stream xdr;
4260 struct compound_hdr hdr;
4261 int status;
4262
4263 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4264 status = decode_compound_hdr(&xdr, &hdr);
4265 if (status)
4266 goto out;
4267 status = decode_putfh(&xdr);
4268 if (status)
4269 goto out;
4270 status = decode_lockt(&xdr, res);
4271 out:
4272 return status;
4273 }
4274
4275 /*
4276 * Decode LOCKU response
4277 */
4278 static int nfs4_xdr_dec_locku(struct rpc_rqst *rqstp, __be32 *p, struct nfs_locku_res *res)
4279 {
4280 struct xdr_stream xdr;
4281 struct compound_hdr hdr;
4282 int status;
4283
4284 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4285 status = decode_compound_hdr(&xdr, &hdr);
4286 if (status)
4287 goto out;
4288 status = decode_putfh(&xdr);
4289 if (status)
4290 goto out;
4291 status = decode_locku(&xdr, res);
4292 out:
4293 return status;
4294 }
4295
4296 /*
4297 * Decode READLINK response
4298 */
4299 static int nfs4_xdr_dec_readlink(struct rpc_rqst *rqstp, __be32 *p, void *res)
4300 {
4301 struct xdr_stream xdr;
4302 struct compound_hdr hdr;
4303 int status;
4304
4305 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4306 status = decode_compound_hdr(&xdr, &hdr);
4307 if (status)
4308 goto out;
4309 status = decode_putfh(&xdr);
4310 if (status)
4311 goto out;
4312 status = decode_readlink(&xdr, rqstp);
4313 out:
4314 return status;
4315 }
4316
4317 /*
4318 * Decode READDIR response
4319 */
4320 static int nfs4_xdr_dec_readdir(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_readdir_res *res)
4321 {
4322 struct xdr_stream xdr;
4323 struct compound_hdr hdr;
4324 int status;
4325
4326 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4327 status = decode_compound_hdr(&xdr, &hdr);
4328 if (status)
4329 goto out;
4330 status = decode_putfh(&xdr);
4331 if (status)
4332 goto out;
4333 status = decode_readdir(&xdr, rqstp, res);
4334 out:
4335 return status;
4336 }
4337
4338 /*
4339 * Decode Read response
4340 */
4341 static int nfs4_xdr_dec_read(struct rpc_rqst *rqstp, __be32 *p, struct nfs_readres *res)
4342 {
4343 struct xdr_stream xdr;
4344 struct compound_hdr hdr;
4345 int status;
4346
4347 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4348 status = decode_compound_hdr(&xdr, &hdr);
4349 if (status)
4350 goto out;
4351 status = decode_putfh(&xdr);
4352 if (status)
4353 goto out;
4354 status = decode_read(&xdr, rqstp, res);
4355 if (!status)
4356 status = res->count;
4357 out:
4358 return status;
4359 }
4360
4361 /*
4362 * Decode WRITE response
4363 */
4364 static int nfs4_xdr_dec_write(struct rpc_rqst *rqstp, __be32 *p, struct nfs_writeres *res)
4365 {
4366 struct xdr_stream xdr;
4367 struct compound_hdr hdr;
4368 int status;
4369
4370 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4371 status = decode_compound_hdr(&xdr, &hdr);
4372 if (status)
4373 goto out;
4374 status = decode_putfh(&xdr);
4375 if (status)
4376 goto out;
4377 status = decode_write(&xdr, res);
4378 if (status)
4379 goto out;
4380 decode_getfattr(&xdr, res->fattr, res->server);
4381 if (!status)
4382 status = res->count;
4383 out:
4384 return status;
4385 }
4386
4387 /*
4388 * Decode COMMIT response
4389 */
4390 static int nfs4_xdr_dec_commit(struct rpc_rqst *rqstp, __be32 *p, struct nfs_writeres *res)
4391 {
4392 struct xdr_stream xdr;
4393 struct compound_hdr hdr;
4394 int status;
4395
4396 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4397 status = decode_compound_hdr(&xdr, &hdr);
4398 if (status)
4399 goto out;
4400 status = decode_putfh(&xdr);
4401 if (status)
4402 goto out;
4403 status = decode_commit(&xdr, res);
4404 if (status)
4405 goto out;
4406 decode_getfattr(&xdr, res->fattr, res->server);
4407 out:
4408 return status;
4409 }
4410
4411 /*
4412 * FSINFO request
4413 */
4414 static int nfs4_xdr_dec_fsinfo(struct rpc_rqst *req, __be32 *p, struct nfs_fsinfo *fsinfo)
4415 {
4416 struct xdr_stream xdr;
4417 struct compound_hdr hdr;
4418 int status;
4419
4420 xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
4421 status = decode_compound_hdr(&xdr, &hdr);
4422 if (!status)
4423 status = decode_putfh(&xdr);
4424 if (!status)
4425 status = decode_fsinfo(&xdr, fsinfo);
4426 return status;
4427 }
4428
4429 /*
4430 * PATHCONF request
4431 */
4432 static int nfs4_xdr_dec_pathconf(struct rpc_rqst *req, __be32 *p, struct nfs_pathconf *pathconf)
4433 {
4434 struct xdr_stream xdr;
4435 struct compound_hdr hdr;
4436 int status;
4437
4438 xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
4439 status = decode_compound_hdr(&xdr, &hdr);
4440 if (!status)
4441 status = decode_putfh(&xdr);
4442 if (!status)
4443 status = decode_pathconf(&xdr, pathconf);
4444 return status;
4445 }
4446
4447 /*
4448 * STATFS request
4449 */
4450 static int nfs4_xdr_dec_statfs(struct rpc_rqst *req, __be32 *p, struct nfs_fsstat *fsstat)
4451 {
4452 struct xdr_stream xdr;
4453 struct compound_hdr hdr;
4454 int status;
4455
4456 xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
4457 status = decode_compound_hdr(&xdr, &hdr);
4458 if (!status)
4459 status = decode_putfh(&xdr);
4460 if (!status)
4461 status = decode_statfs(&xdr, fsstat);
4462 return status;
4463 }
4464
4465 /*
4466 * GETATTR_BITMAP request
4467 */
4468 static int nfs4_xdr_dec_server_caps(struct rpc_rqst *req, __be32 *p, struct nfs4_server_caps_res *res)
4469 {
4470 struct xdr_stream xdr;
4471 struct compound_hdr hdr;
4472 int status;
4473
4474 xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
4475 if ((status = decode_compound_hdr(&xdr, &hdr)) != 0)
4476 goto out;
4477 if ((status = decode_putfh(&xdr)) != 0)
4478 goto out;
4479 status = decode_server_caps(&xdr, res);
4480 out:
4481 return status;
4482 }
4483
4484 /*
4485 * Decode RENEW response
4486 */
4487 static int nfs4_xdr_dec_renew(struct rpc_rqst *rqstp, __be32 *p, void *dummy)
4488 {
4489 struct xdr_stream xdr;
4490 struct compound_hdr hdr;
4491 int status;
4492
4493 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4494 status = decode_compound_hdr(&xdr, &hdr);
4495 if (!status)
4496 status = decode_renew(&xdr);
4497 return status;
4498 }
4499
4500 /*
4501 * a SETCLIENTID request
4502 */
4503 static int nfs4_xdr_dec_setclientid(struct rpc_rqst *req, __be32 *p,
4504 struct nfs_client *clp)
4505 {
4506 struct xdr_stream xdr;
4507 struct compound_hdr hdr;
4508 int status;
4509
4510 xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
4511 status = decode_compound_hdr(&xdr, &hdr);
4512 if (!status)
4513 status = decode_setclientid(&xdr, clp);
4514 return status;
4515 }
4516
4517 /*
4518 * a SETCLIENTID_CONFIRM request
4519 */
4520 static int nfs4_xdr_dec_setclientid_confirm(struct rpc_rqst *req, __be32 *p, struct nfs_fsinfo *fsinfo)
4521 {
4522 struct xdr_stream xdr;
4523 struct compound_hdr hdr;
4524 int status;
4525
4526 xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
4527 status = decode_compound_hdr(&xdr, &hdr);
4528 if (!status)
4529 status = decode_setclientid_confirm(&xdr);
4530 if (!status)
4531 status = decode_putrootfh(&xdr);
4532 if (!status)
4533 status = decode_fsinfo(&xdr, fsinfo);
4534 return status;
4535 }
4536
4537 /*
4538 * DELEGRETURN request
4539 */
4540 static int nfs4_xdr_dec_delegreturn(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_delegreturnres *res)
4541 {
4542 struct xdr_stream xdr;
4543 struct compound_hdr hdr;
4544 int status;
4545
4546 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
4547 status = decode_compound_hdr(&xdr, &hdr);
4548 if (status != 0)
4549 goto out;
4550 status = decode_putfh(&xdr);
4551 if (status != 0)
4552 goto out;
4553 status = decode_delegreturn(&xdr);
4554 decode_getfattr(&xdr, res->fattr, res->server);
4555 out:
4556 return status;
4557 }
4558
4559 /*
4560 * FS_LOCATIONS request
4561 */
4562 static int nfs4_xdr_dec_fs_locations(struct rpc_rqst *req, __be32 *p, struct nfs4_fs_locations *res)
4563 {
4564 struct xdr_stream xdr;
4565 struct compound_hdr hdr;
4566 int status;
4567
4568 xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
4569 status = decode_compound_hdr(&xdr, &hdr);
4570 if (status != 0)
4571 goto out;
4572 if ((status = decode_putfh(&xdr)) != 0)
4573 goto out;
4574 if ((status = decode_lookup(&xdr)) != 0)
4575 goto out;
4576 xdr_enter_page(&xdr, PAGE_SIZE);
4577 status = decode_getfattr(&xdr, &res->fattr, res->server);
4578 out:
4579 return status;
4580 }
4581
4582 __be32 *nfs4_decode_dirent(__be32 *p, struct nfs_entry *entry, int plus)
4583 {
4584 uint32_t bitmap[2] = {0};
4585 uint32_t len;
4586
4587 if (!*p++) {
4588 if (!*p)
4589 return ERR_PTR(-EAGAIN);
4590 entry->eof = 1;
4591 return ERR_PTR(-EBADCOOKIE);
4592 }
4593
4594 entry->prev_cookie = entry->cookie;
4595 p = xdr_decode_hyper(p, &entry->cookie);
4596 entry->len = ntohl(*p++);
4597 entry->name = (const char *) p;
4598 p += XDR_QUADLEN(entry->len);
4599
4600 /*
4601 * In case the server doesn't return an inode number,
4602 * we fake one here. (We don't use inode number 0,
4603 * since glibc seems to choke on it...)
4604 */
4605 entry->ino = 1;
4606
4607 len = ntohl(*p++); /* bitmap length */
4608 if (len-- > 0) {
4609 bitmap[0] = ntohl(*p++);
4610 if (len-- > 0) {
4611 bitmap[1] = ntohl(*p++);
4612 p += len;
4613 }
4614 }
4615 len = XDR_QUADLEN(ntohl(*p++)); /* attribute buffer length */
4616 if (len > 0) {
4617 if (bitmap[0] & FATTR4_WORD0_RDATTR_ERROR) {
4618 bitmap[0] &= ~FATTR4_WORD0_RDATTR_ERROR;
4619 /* Ignore the return value of rdattr_error for now */
4620 p++;
4621 len--;
4622 }
4623 if (bitmap[0] == 0 && bitmap[1] == FATTR4_WORD1_MOUNTED_ON_FILEID)
4624 xdr_decode_hyper(p, &entry->ino);
4625 else if (bitmap[0] == FATTR4_WORD0_FILEID)
4626 xdr_decode_hyper(p, &entry->ino);
4627 p += len;
4628 }
4629
4630 entry->eof = !p[0] && p[1];
4631 return p;
4632 }
4633
4634 /*
4635 * We need to translate between nfs status return values and
4636 * the local errno values which may not be the same.
4637 */
4638 static struct {
4639 int stat;
4640 int errno;
4641 } nfs_errtbl[] = {
4642 { NFS4_OK, 0 },
4643 { NFS4ERR_PERM, -EPERM },
4644 { NFS4ERR_NOENT, -ENOENT },
4645 { NFS4ERR_IO, -errno_NFSERR_IO},
4646 { NFS4ERR_NXIO, -ENXIO },
4647 { NFS4ERR_ACCESS, -EACCES },
4648 { NFS4ERR_EXIST, -EEXIST },
4649 { NFS4ERR_XDEV, -EXDEV },
4650 { NFS4ERR_NOTDIR, -ENOTDIR },
4651 { NFS4ERR_ISDIR, -EISDIR },
4652 { NFS4ERR_INVAL, -EINVAL },
4653 { NFS4ERR_FBIG, -EFBIG },
4654 { NFS4ERR_NOSPC, -ENOSPC },
4655 { NFS4ERR_ROFS, -EROFS },
4656 { NFS4ERR_MLINK, -EMLINK },
4657 { NFS4ERR_NAMETOOLONG, -ENAMETOOLONG },
4658 { NFS4ERR_NOTEMPTY, -ENOTEMPTY },
4659 { NFS4ERR_DQUOT, -EDQUOT },
4660 { NFS4ERR_STALE, -ESTALE },
4661 { NFS4ERR_BADHANDLE, -EBADHANDLE },
4662 { NFS4ERR_BADOWNER, -EINVAL },
4663 { NFS4ERR_BADNAME, -EINVAL },
4664 { NFS4ERR_BAD_COOKIE, -EBADCOOKIE },
4665 { NFS4ERR_NOTSUPP, -ENOTSUPP },
4666 { NFS4ERR_TOOSMALL, -ETOOSMALL },
4667 { NFS4ERR_SERVERFAULT, -ESERVERFAULT },
4668 { NFS4ERR_BADTYPE, -EBADTYPE },
4669 { NFS4ERR_LOCKED, -EAGAIN },
4670 { NFS4ERR_RESOURCE, -EREMOTEIO },
4671 { NFS4ERR_SYMLINK, -ELOOP },
4672 { NFS4ERR_OP_ILLEGAL, -EOPNOTSUPP },
4673 { NFS4ERR_DEADLOCK, -EDEADLK },
4674 { NFS4ERR_WRONGSEC, -EPERM }, /* FIXME: this needs
4675 * to be handled by a
4676 * middle-layer.
4677 */
4678 { -1, -EIO }
4679 };
4680
4681 /*
4682 * Convert an NFS error code to a local one.
4683 * This one is used jointly by NFSv2 and NFSv3.
4684 */
4685 static int
4686 nfs4_stat_to_errno(int stat)
4687 {
4688 int i;
4689 for (i = 0; nfs_errtbl[i].stat != -1; i++) {
4690 if (nfs_errtbl[i].stat == stat)
4691 return nfs_errtbl[i].errno;
4692 }
4693 if (stat <= 10000 || stat > 10100) {
4694 /* The server is looney tunes. */
4695 return -ESERVERFAULT;
4696 }
4697 /* If we cannot translate the error, the recovery routines should
4698 * handle it.
4699 * Note: remaining NFSv4 error codes have values > 10000, so should
4700 * not conflict with native Linux error codes.
4701 */
4702 return -stat;
4703 }
4704
4705 #define PROC(proc, argtype, restype) \
4706 [NFSPROC4_CLNT_##proc] = { \
4707 .p_proc = NFSPROC4_COMPOUND, \
4708 .p_encode = (kxdrproc_t) nfs4_xdr_##argtype, \
4709 .p_decode = (kxdrproc_t) nfs4_xdr_##restype, \
4710 .p_arglen = NFS4_##argtype##_sz, \
4711 .p_replen = NFS4_##restype##_sz, \
4712 .p_statidx = NFSPROC4_CLNT_##proc, \
4713 .p_name = #proc, \
4714 }
4715
4716 struct rpc_procinfo nfs4_procedures[] = {
4717 PROC(READ, enc_read, dec_read),
4718 PROC(WRITE, enc_write, dec_write),
4719 PROC(COMMIT, enc_commit, dec_commit),
4720 PROC(OPEN, enc_open, dec_open),
4721 PROC(OPEN_CONFIRM, enc_open_confirm, dec_open_confirm),
4722 PROC(OPEN_NOATTR, enc_open_noattr, dec_open_noattr),
4723 PROC(OPEN_DOWNGRADE, enc_open_downgrade, dec_open_downgrade),
4724 PROC(CLOSE, enc_close, dec_close),
4725 PROC(SETATTR, enc_setattr, dec_setattr),
4726 PROC(FSINFO, enc_fsinfo, dec_fsinfo),
4727 PROC(RENEW, enc_renew, dec_renew),
4728 PROC(SETCLIENTID, enc_setclientid, dec_setclientid),
4729 PROC(SETCLIENTID_CONFIRM, enc_setclientid_confirm, dec_setclientid_confirm),
4730 PROC(LOCK, enc_lock, dec_lock),
4731 PROC(LOCKT, enc_lockt, dec_lockt),
4732 PROC(LOCKU, enc_locku, dec_locku),
4733 PROC(ACCESS, enc_access, dec_access),
4734 PROC(GETATTR, enc_getattr, dec_getattr),
4735 PROC(LOOKUP, enc_lookup, dec_lookup),
4736 PROC(LOOKUP_ROOT, enc_lookup_root, dec_lookup_root),
4737 PROC(REMOVE, enc_remove, dec_remove),
4738 PROC(RENAME, enc_rename, dec_rename),
4739 PROC(LINK, enc_link, dec_link),
4740 PROC(SYMLINK, enc_symlink, dec_symlink),
4741 PROC(CREATE, enc_create, dec_create),
4742 PROC(PATHCONF, enc_pathconf, dec_pathconf),
4743 PROC(STATFS, enc_statfs, dec_statfs),
4744 PROC(READLINK, enc_readlink, dec_readlink),
4745 PROC(READDIR, enc_readdir, dec_readdir),
4746 PROC(SERVER_CAPS, enc_server_caps, dec_server_caps),
4747 PROC(DELEGRETURN, enc_delegreturn, dec_delegreturn),
4748 PROC(GETACL, enc_getacl, dec_getacl),
4749 PROC(SETACL, enc_setacl, dec_setacl),
4750 PROC(FS_LOCATIONS, enc_fs_locations, dec_fs_locations),
4751 };
4752
4753 struct rpc_version nfs_version4 = {
4754 .number = 4,
4755 .nrprocs = ARRAY_SIZE(nfs4_procedures),
4756 .procs = nfs4_procedures
4757 };
4758
4759 /*
4760 * Local variables:
4761 * c-basic-offset: 8
4762 * End:
4763 */
ubuntu-bionic-kernel mirror