[PATCH] NFSv4: fix fattr size calculations
[sfrench/cifs-2.6.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 nfs_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 1 (u32) out of (NFS4_OPAQUE_LIMIT  >> 2)
72  */
73 #define owner_id_maxsz          (1 + 1)
74 #define compound_encode_hdr_maxsz       (3 + (NFS4_MAXTAGLEN >> 2))
75 #define compound_decode_hdr_maxsz       (3 + (NFS4_MAXTAGLEN >> 2))
76 #define op_encode_hdr_maxsz     (1)
77 #define op_decode_hdr_maxsz     (2)
78 #define encode_putfh_maxsz      (op_encode_hdr_maxsz + 1 + \
79                                 (NFS4_FHSIZE >> 2))
80 #define decode_putfh_maxsz      (op_decode_hdr_maxsz)
81 #define encode_putrootfh_maxsz  (op_encode_hdr_maxsz)
82 #define decode_putrootfh_maxsz  (op_decode_hdr_maxsz)
83 #define encode_getfh_maxsz      (op_encode_hdr_maxsz)
84 #define decode_getfh_maxsz      (op_decode_hdr_maxsz + 1 + \
85                                 ((3+NFS4_FHSIZE) >> 2))
86 #define nfs4_fattr_bitmap_maxsz 3
87 #define encode_getattr_maxsz    (op_encode_hdr_maxsz + nfs4_fattr_bitmap_maxsz)
88 #define nfs4_name_maxsz         (1 + ((3 + NFS4_MAXNAMLEN) >> 2))
89 #define nfs4_path_maxsz         (1 + ((3 + NFS4_MAXPATHLEN) >> 2))
90 /* This is based on getfattr, which uses the most attributes: */
91 #define nfs4_fattr_value_maxsz  (1 + (1 + 2 + 2 + 4 + 2 + 1 + 1 + 2 + 2 + \
92                                 3 + 3 + 3 + 2 * nfs4_name_maxsz))
93 #define nfs4_fattr_maxsz        (nfs4_fattr_bitmap_maxsz + \
94                                 nfs4_fattr_value_maxsz)
95 #define decode_getattr_maxsz    (op_decode_hdr_maxsz + nfs4_fattr_maxsz)
96 #define encode_savefh_maxsz     (op_encode_hdr_maxsz)
97 #define decode_savefh_maxsz     (op_decode_hdr_maxsz)
98 #define encode_fsinfo_maxsz     (op_encode_hdr_maxsz + 2)
99 #define decode_fsinfo_maxsz     (op_decode_hdr_maxsz + 11)
100 #define encode_renew_maxsz      (op_encode_hdr_maxsz + 3)
101 #define decode_renew_maxsz      (op_decode_hdr_maxsz)
102 #define encode_setclientid_maxsz \
103                                 (op_encode_hdr_maxsz + \
104                                 4 /*server->ip_addr*/ + \
105                                 1 /*Netid*/ + \
106                                 6 /*uaddr*/ + \
107                                 6 + (NFS4_VERIFIER_SIZE >> 2))
108 #define decode_setclientid_maxsz \
109                                 (op_decode_hdr_maxsz + \
110                                 2 + \
111                                 1024) /* large value for CLID_INUSE */
112 #define encode_setclientid_confirm_maxsz \
113                                 (op_encode_hdr_maxsz + \
114                                 3 + (NFS4_VERIFIER_SIZE >> 2))
115 #define decode_setclientid_confirm_maxsz \
116                                 (op_decode_hdr_maxsz)
117 #define encode_lookup_maxsz     (op_encode_hdr_maxsz + \
118                                 1 + ((3 + NFS4_FHSIZE) >> 2))
119 #define encode_remove_maxsz     (op_encode_hdr_maxsz + \
120                                 nfs4_name_maxsz)
121 #define encode_rename_maxsz     (op_encode_hdr_maxsz + \
122                                 2 * nfs4_name_maxsz)
123 #define decode_rename_maxsz     (op_decode_hdr_maxsz + 5 + 5)
124 #define encode_link_maxsz       (op_encode_hdr_maxsz + \
125                                 nfs4_name_maxsz)
126 #define decode_link_maxsz       (op_decode_hdr_maxsz + 5)
127 #define encode_symlink_maxsz    (op_encode_hdr_maxsz + \
128                                 1 + nfs4_name_maxsz + \
129                                 nfs4_path_maxsz + \
130                                 nfs4_fattr_maxsz)
131 #define decode_symlink_maxsz    (op_decode_hdr_maxsz + 8)
132 #define encode_create_maxsz     (op_encode_hdr_maxsz + \
133                                 2 + nfs4_name_maxsz + \
134                                 nfs4_fattr_maxsz)
135 #define decode_create_maxsz     (op_decode_hdr_maxsz + 8)
136 #define encode_delegreturn_maxsz (op_encode_hdr_maxsz + 4)
137 #define decode_delegreturn_maxsz (op_decode_hdr_maxsz)
138 #define NFS4_enc_compound_sz    (1024)  /* XXX: large enough? */
139 #define NFS4_dec_compound_sz    (1024)  /* XXX: large enough? */
140 #define NFS4_enc_read_sz        (compound_encode_hdr_maxsz + \
141                                 encode_putfh_maxsz + \
142                                 op_encode_hdr_maxsz + 7)
143 #define NFS4_dec_read_sz        (compound_decode_hdr_maxsz + \
144                                 decode_putfh_maxsz + \
145                                 op_decode_hdr_maxsz + 2)
146 #define NFS4_enc_readlink_sz    (compound_encode_hdr_maxsz + \
147                                 encode_putfh_maxsz + \
148                                 op_encode_hdr_maxsz)
149 #define NFS4_dec_readlink_sz    (compound_decode_hdr_maxsz + \
150                                 decode_putfh_maxsz + \
151                                 op_decode_hdr_maxsz)
152 #define NFS4_enc_readdir_sz     (compound_encode_hdr_maxsz + \
153                                 encode_putfh_maxsz + \
154                                 op_encode_hdr_maxsz + 9)
155 #define NFS4_dec_readdir_sz     (compound_decode_hdr_maxsz + \
156                                 decode_putfh_maxsz + \
157                                 op_decode_hdr_maxsz + 2)
158 #define NFS4_enc_write_sz       (compound_encode_hdr_maxsz + \
159                                 encode_putfh_maxsz + \
160                                 op_encode_hdr_maxsz + 8)
161 #define NFS4_dec_write_sz       (compound_decode_hdr_maxsz + \
162                                 decode_putfh_maxsz + \
163                                 op_decode_hdr_maxsz + 4)
164 #define NFS4_enc_commit_sz      (compound_encode_hdr_maxsz + \
165                                 encode_putfh_maxsz + \
166                                 op_encode_hdr_maxsz + 3)
167 #define NFS4_dec_commit_sz      (compound_decode_hdr_maxsz + \
168                                 decode_putfh_maxsz + \
169                                 op_decode_hdr_maxsz + 2)
170 #define NFS4_enc_open_sz        (compound_encode_hdr_maxsz + \
171                                 encode_putfh_maxsz + \
172                                 op_encode_hdr_maxsz + \
173                                 13 + 3 + 2 + 64 + \
174                                 encode_getattr_maxsz + \
175                                 encode_getfh_maxsz)
176 #define NFS4_dec_open_sz        (compound_decode_hdr_maxsz + \
177                                 decode_putfh_maxsz + \
178                                 op_decode_hdr_maxsz + 4 + 5 + 2 + 3 + \
179                                 decode_getattr_maxsz + \
180                                 decode_getfh_maxsz)
181 #define NFS4_enc_open_confirm_sz      \
182                                 (compound_encode_hdr_maxsz + \
183                                 encode_putfh_maxsz + \
184                                 op_encode_hdr_maxsz + 5)
185 #define NFS4_dec_open_confirm_sz        (compound_decode_hdr_maxsz + \
186                                         decode_putfh_maxsz + \
187                                         op_decode_hdr_maxsz + 4)
188 #define NFS4_enc_open_noattr_sz (compound_encode_hdr_maxsz + \
189                                         encode_putfh_maxsz + \
190                                         op_encode_hdr_maxsz + \
191                                         11)
192 #define NFS4_dec_open_noattr_sz (compound_decode_hdr_maxsz + \
193                                         decode_putfh_maxsz + \
194                                         op_decode_hdr_maxsz + \
195                                         4 + 5 + 2 + 3)
196 #define NFS4_enc_open_downgrade_sz \
197                                 (compound_encode_hdr_maxsz + \
198                                 encode_putfh_maxsz + \
199                                 op_encode_hdr_maxsz + 7)
200 #define NFS4_dec_open_downgrade_sz \
201                                 (compound_decode_hdr_maxsz + \
202                                 decode_putfh_maxsz + \
203                                 op_decode_hdr_maxsz + 4)
204 #define NFS4_enc_close_sz       (compound_encode_hdr_maxsz + \
205                                 encode_putfh_maxsz + \
206                                 op_encode_hdr_maxsz + 5)
207 #define NFS4_dec_close_sz       (compound_decode_hdr_maxsz + \
208                                 decode_putfh_maxsz + \
209                                 op_decode_hdr_maxsz + 4)
210 #define NFS4_enc_setattr_sz     (compound_encode_hdr_maxsz + \
211                                 encode_putfh_maxsz + \
212                                 op_encode_hdr_maxsz + 4 + \
213                                 nfs4_fattr_maxsz + \
214                                 encode_getattr_maxsz)
215 #define NFS4_dec_setattr_sz     (compound_decode_hdr_maxsz + \
216                                 decode_putfh_maxsz + \
217                                 op_decode_hdr_maxsz + 3)
218 #define NFS4_enc_fsinfo_sz      (compound_encode_hdr_maxsz + \
219                                 encode_putfh_maxsz + \
220                                 encode_fsinfo_maxsz)
221 #define NFS4_dec_fsinfo_sz      (compound_decode_hdr_maxsz + \
222                                 decode_putfh_maxsz + \
223                                 decode_fsinfo_maxsz)
224 #define NFS4_enc_renew_sz       (compound_encode_hdr_maxsz + \
225                                 encode_renew_maxsz)
226 #define NFS4_dec_renew_sz       (compound_decode_hdr_maxsz + \
227                                 decode_renew_maxsz)
228 #define NFS4_enc_setclientid_sz (compound_encode_hdr_maxsz + \
229                                 encode_setclientid_maxsz)
230 #define NFS4_dec_setclientid_sz (compound_decode_hdr_maxsz + \
231                                 decode_setclientid_maxsz)
232 #define NFS4_enc_setclientid_confirm_sz \
233                                 (compound_encode_hdr_maxsz + \
234                                 encode_setclientid_confirm_maxsz + \
235                                 encode_putrootfh_maxsz + \
236                                 encode_fsinfo_maxsz)
237 #define NFS4_dec_setclientid_confirm_sz \
238                                 (compound_decode_hdr_maxsz + \
239                                 decode_setclientid_confirm_maxsz + \
240                                 decode_putrootfh_maxsz + \
241                                 decode_fsinfo_maxsz)
242 #define NFS4_enc_lock_sz        (compound_encode_hdr_maxsz + \
243                                 encode_putfh_maxsz + \
244                                 encode_getattr_maxsz + \
245                                 op_encode_hdr_maxsz + \
246                                 1 + 1 + 2 + 2 + \
247                                 1 + 4 + 1 + 2 + \
248                                 owner_id_maxsz)
249 #define NFS4_dec_lock_sz        (compound_decode_hdr_maxsz + \
250                                 decode_putfh_maxsz + \
251                                 decode_getattr_maxsz + \
252                                 op_decode_hdr_maxsz + \
253                                 2 + 2 + 1 + 2 + \
254                                 owner_id_maxsz)
255 #define NFS4_enc_lockt_sz       (compound_encode_hdr_maxsz + \
256                                 encode_putfh_maxsz + \
257                                 encode_getattr_maxsz + \
258                                 op_encode_hdr_maxsz + \
259                                 1 + 2 + 2 + 2 + \
260                                 owner_id_maxsz)
261 #define NFS4_dec_lockt_sz       (NFS4_dec_lock_sz)
262 #define NFS4_enc_locku_sz       (compound_encode_hdr_maxsz + \
263                                 encode_putfh_maxsz + \
264                                 encode_getattr_maxsz + \
265                                 op_encode_hdr_maxsz + \
266                                 1 + 1 + 4 + 2 + 2)
267 #define NFS4_dec_locku_sz       (compound_decode_hdr_maxsz + \
268                                 decode_putfh_maxsz + \
269                                 decode_getattr_maxsz + \
270                                 op_decode_hdr_maxsz + 4)
271 #define NFS4_enc_access_sz      (compound_encode_hdr_maxsz + \
272                                 encode_putfh_maxsz + \
273                                 op_encode_hdr_maxsz + 1)
274 #define NFS4_dec_access_sz      (compound_decode_hdr_maxsz + \
275                                 decode_putfh_maxsz + \
276                                 op_decode_hdr_maxsz + 2)
277 #define NFS4_enc_getattr_sz     (compound_encode_hdr_maxsz + \
278                                 encode_putfh_maxsz + \
279                                 encode_getattr_maxsz)
280 #define NFS4_dec_getattr_sz     (compound_decode_hdr_maxsz + \
281                                 decode_putfh_maxsz + \
282                                 decode_getattr_maxsz)
283 #define NFS4_enc_lookup_sz      (compound_encode_hdr_maxsz + \
284                                 encode_putfh_maxsz + \
285                                 encode_lookup_maxsz + \
286                                 encode_getattr_maxsz + \
287                                 encode_getfh_maxsz)
288 #define NFS4_dec_lookup_sz      (compound_decode_hdr_maxsz + \
289                                 decode_putfh_maxsz + \
290                                 op_decode_hdr_maxsz + \
291                                 decode_getattr_maxsz + \
292                                 decode_getfh_maxsz)
293 #define NFS4_enc_lookup_root_sz (compound_encode_hdr_maxsz + \
294                                 encode_putrootfh_maxsz + \
295                                 encode_getattr_maxsz + \
296                                 encode_getfh_maxsz)
297 #define NFS4_dec_lookup_root_sz (compound_decode_hdr_maxsz + \
298                                 decode_putrootfh_maxsz + \
299                                 decode_getattr_maxsz + \
300                                 decode_getfh_maxsz)
301 #define NFS4_enc_remove_sz      (compound_encode_hdr_maxsz + \
302                                 encode_putfh_maxsz + \
303                                 encode_remove_maxsz)
304 #define NFS4_dec_remove_sz      (compound_decode_hdr_maxsz + \
305                                 decode_putfh_maxsz + \
306                                 op_decode_hdr_maxsz + 5)
307 #define NFS4_enc_rename_sz      (compound_encode_hdr_maxsz + \
308                                 encode_putfh_maxsz + \
309                                 encode_savefh_maxsz + \
310                                 encode_putfh_maxsz + \
311                                 encode_rename_maxsz)
312 #define NFS4_dec_rename_sz      (compound_decode_hdr_maxsz + \
313                                 decode_putfh_maxsz + \
314                                 decode_savefh_maxsz + \
315                                 decode_putfh_maxsz + \
316                                 decode_rename_maxsz)
317 #define NFS4_enc_link_sz        (compound_encode_hdr_maxsz + \
318                                 encode_putfh_maxsz + \
319                                 encode_savefh_maxsz + \
320                                 encode_putfh_maxsz + \
321                                 encode_link_maxsz)
322 #define NFS4_dec_link_sz        (compound_decode_hdr_maxsz + \
323                                 decode_putfh_maxsz + \
324                                 decode_savefh_maxsz + \
325                                 decode_putfh_maxsz + \
326                                 decode_link_maxsz)
327 #define NFS4_enc_symlink_sz     (compound_encode_hdr_maxsz + \
328                                 encode_putfh_maxsz + \
329                                 encode_symlink_maxsz + \
330                                 encode_getattr_maxsz + \
331                                 encode_getfh_maxsz)
332 #define NFS4_dec_symlink_sz     (compound_decode_hdr_maxsz + \
333                                 decode_putfh_maxsz + \
334                                 decode_symlink_maxsz + \
335                                 decode_getattr_maxsz + \
336                                 decode_getfh_maxsz)
337 #define NFS4_enc_create_sz      (compound_encode_hdr_maxsz + \
338                                 encode_putfh_maxsz + \
339                                 encode_create_maxsz + \
340                                 encode_getattr_maxsz + \
341                                 encode_getfh_maxsz)
342 #define NFS4_dec_create_sz      (compound_decode_hdr_maxsz + \
343                                 decode_putfh_maxsz + \
344                                 decode_create_maxsz + \
345                                 decode_getattr_maxsz + \
346                                 decode_getfh_maxsz)
347 #define NFS4_enc_pathconf_sz    (compound_encode_hdr_maxsz + \
348                                 encode_putfh_maxsz + \
349                                 encode_getattr_maxsz)
350 #define NFS4_dec_pathconf_sz    (compound_decode_hdr_maxsz + \
351                                 decode_putfh_maxsz + \
352                                 decode_getattr_maxsz)
353 #define NFS4_enc_statfs_sz      (compound_encode_hdr_maxsz + \
354                                 encode_putfh_maxsz + \
355                                 encode_getattr_maxsz)
356 #define NFS4_dec_statfs_sz      (compound_decode_hdr_maxsz + \
357                                 decode_putfh_maxsz + \
358                                 op_decode_hdr_maxsz + 12)
359 #define NFS4_enc_server_caps_sz (compound_encode_hdr_maxsz + \
360                                 encode_getattr_maxsz)
361 #define NFS4_dec_server_caps_sz (compound_decode_hdr_maxsz + \
362                                 decode_getattr_maxsz)
363 #define NFS4_enc_delegreturn_sz (compound_encode_hdr_maxsz + \
364                                 encode_putfh_maxsz + \
365                                 encode_delegreturn_maxsz)
366 #define NFS4_dec_delegreturn_sz (compound_decode_hdr_maxsz + \
367                                 decode_delegreturn_maxsz)
368
369 static struct {
370         unsigned int    mode;
371         unsigned int    nfs2type;
372 } nfs_type2fmt[] = {
373         { 0,            NFNON        },
374         { S_IFREG,      NFREG        },
375         { S_IFDIR,      NFDIR        },
376         { S_IFBLK,      NFBLK        },
377         { S_IFCHR,      NFCHR        },
378         { S_IFLNK,      NFLNK        },
379         { S_IFSOCK,     NFSOCK       },
380         { S_IFIFO,      NFFIFO       },
381         { 0,            NFNON        },
382         { 0,            NFNON        },
383 };
384
385 struct compound_hdr {
386         int32_t         status;
387         uint32_t        nops;
388         uint32_t        taglen;
389         char *          tag;
390 };
391
392 /*
393  * START OF "GENERIC" ENCODE ROUTINES.
394  *   These may look a little ugly since they are imported from a "generic"
395  * set of XDR encode/decode routines which are intended to be shared by
396  * all of our NFSv4 implementations (OpenBSD, MacOS X...).
397  *
398  * If the pain of reading these is too great, it should be a straightforward
399  * task to translate them into Linux-specific versions which are more
400  * consistent with the style used in NFSv2/v3...
401  */
402 #define WRITE32(n)               *p++ = htonl(n)
403 #define WRITE64(n)               do {                           \
404         *p++ = htonl((uint32_t)((n) >> 32));                            \
405         *p++ = htonl((uint32_t)(n));                                    \
406 } while (0)
407 #define WRITEMEM(ptr,nbytes)     do {                           \
408         p = xdr_encode_opaque_fixed(p, ptr, nbytes);            \
409 } while (0)
410
411 #define RESERVE_SPACE(nbytes)   do {                            \
412         p = xdr_reserve_space(xdr, nbytes);                     \
413         if (!p) printk("RESERVE_SPACE(%d) failed in function %s\n", (int) (nbytes), __FUNCTION__); \
414         BUG_ON(!p);                                             \
415 } while (0)
416
417 static void encode_string(struct xdr_stream *xdr, unsigned int len, const char *str)
418 {
419         uint32_t *p;
420
421         p = xdr_reserve_space(xdr, 4 + len);
422         BUG_ON(p == NULL);
423         xdr_encode_opaque(p, str, len);
424 }
425
426 static int encode_compound_hdr(struct xdr_stream *xdr, struct compound_hdr *hdr)
427 {
428         uint32_t *p;
429
430         dprintk("encode_compound: tag=%.*s\n", (int)hdr->taglen, hdr->tag);
431         BUG_ON(hdr->taglen > NFS4_MAXTAGLEN);
432         RESERVE_SPACE(12+(XDR_QUADLEN(hdr->taglen)<<2));
433         WRITE32(hdr->taglen);
434         WRITEMEM(hdr->tag, hdr->taglen);
435         WRITE32(NFS4_MINOR_VERSION);
436         WRITE32(hdr->nops);
437         return 0;
438 }
439
440 static void encode_nfs4_verifier(struct xdr_stream *xdr, const nfs4_verifier *verf)
441 {
442         uint32_t *p;
443
444         p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE);
445         BUG_ON(p == NULL);
446         xdr_encode_opaque_fixed(p, verf->data, NFS4_VERIFIER_SIZE);
447 }
448
449 static int encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const struct nfs_server *server)
450 {
451         char owner_name[IDMAP_NAMESZ];
452         char owner_group[IDMAP_NAMESZ];
453         int owner_namelen = 0;
454         int owner_grouplen = 0;
455         uint32_t *p;
456         uint32_t *q;
457         int len;
458         uint32_t bmval0 = 0;
459         uint32_t bmval1 = 0;
460         int status;
461
462         /*
463          * We reserve enough space to write the entire attribute buffer at once.
464          * In the worst-case, this would be
465          *   12(bitmap) + 4(attrlen) + 8(size) + 4(mode) + 4(atime) + 4(mtime)
466          *          = 36 bytes, plus any contribution from variable-length fields
467          *            such as owner/group/acl's.
468          */
469         len = 16;
470
471         /* Sigh */
472         if (iap->ia_valid & ATTR_SIZE)
473                 len += 8;
474         if (iap->ia_valid & ATTR_MODE)
475                 len += 4;
476         if (iap->ia_valid & ATTR_UID) {
477                 owner_namelen = nfs_map_uid_to_name(server->nfs4_state, iap->ia_uid, owner_name);
478                 if (owner_namelen < 0) {
479                         printk(KERN_WARNING "nfs: couldn't resolve uid %d to string\n",
480                                iap->ia_uid);
481                         /* XXX */
482                         strcpy(owner_name, "nobody");
483                         owner_namelen = sizeof("nobody") - 1;
484                         /* goto out; */
485                 }
486                 len += 4 + (XDR_QUADLEN(owner_namelen) << 2);
487         }
488         if (iap->ia_valid & ATTR_GID) {
489                 owner_grouplen = nfs_map_gid_to_group(server->nfs4_state, iap->ia_gid, owner_group);
490                 if (owner_grouplen < 0) {
491                         printk(KERN_WARNING "nfs4: couldn't resolve gid %d to string\n",
492                                iap->ia_gid);
493                         strcpy(owner_group, "nobody");
494                         owner_grouplen = sizeof("nobody") - 1;
495                         /* goto out; */
496                 }
497                 len += 4 + (XDR_QUADLEN(owner_grouplen) << 2);
498         }
499         if (iap->ia_valid & ATTR_ATIME_SET)
500                 len += 16;
501         else if (iap->ia_valid & ATTR_ATIME)
502                 len += 4;
503         if (iap->ia_valid & ATTR_MTIME_SET)
504                 len += 16;
505         else if (iap->ia_valid & ATTR_MTIME)
506                 len += 4;
507         RESERVE_SPACE(len);
508
509         /*
510          * We write the bitmap length now, but leave the bitmap and the attribute
511          * buffer length to be backfilled at the end of this routine.
512          */
513         WRITE32(2);
514         q = p;
515         p += 3;
516
517         if (iap->ia_valid & ATTR_SIZE) {
518                 bmval0 |= FATTR4_WORD0_SIZE;
519                 WRITE64(iap->ia_size);
520         }
521         if (iap->ia_valid & ATTR_MODE) {
522                 bmval1 |= FATTR4_WORD1_MODE;
523                 WRITE32(iap->ia_mode);
524         }
525         if (iap->ia_valid & ATTR_UID) {
526                 bmval1 |= FATTR4_WORD1_OWNER;
527                 WRITE32(owner_namelen);
528                 WRITEMEM(owner_name, owner_namelen);
529         }
530         if (iap->ia_valid & ATTR_GID) {
531                 bmval1 |= FATTR4_WORD1_OWNER_GROUP;
532                 WRITE32(owner_grouplen);
533                 WRITEMEM(owner_group, owner_grouplen);
534         }
535         if (iap->ia_valid & ATTR_ATIME_SET) {
536                 bmval1 |= FATTR4_WORD1_TIME_ACCESS_SET;
537                 WRITE32(NFS4_SET_TO_CLIENT_TIME);
538                 WRITE32(0);
539                 WRITE32(iap->ia_mtime.tv_sec);
540                 WRITE32(iap->ia_mtime.tv_nsec);
541         }
542         else if (iap->ia_valid & ATTR_ATIME) {
543                 bmval1 |= FATTR4_WORD1_TIME_ACCESS_SET;
544                 WRITE32(NFS4_SET_TO_SERVER_TIME);
545         }
546         if (iap->ia_valid & ATTR_MTIME_SET) {
547                 bmval1 |= FATTR4_WORD1_TIME_MODIFY_SET;
548                 WRITE32(NFS4_SET_TO_CLIENT_TIME);
549                 WRITE32(0);
550                 WRITE32(iap->ia_mtime.tv_sec);
551                 WRITE32(iap->ia_mtime.tv_nsec);
552         }
553         else if (iap->ia_valid & ATTR_MTIME) {
554                 bmval1 |= FATTR4_WORD1_TIME_MODIFY_SET;
555                 WRITE32(NFS4_SET_TO_SERVER_TIME);
556         }
557         
558         /*
559          * Now we backfill the bitmap and the attribute buffer length.
560          */
561         if (len != ((char *)p - (char *)q) + 4) {
562                 printk ("encode_attr: Attr length calculation error! %u != %Zu\n",
563                                 len, ((char *)p - (char *)q) + 4);
564                 BUG();
565         }
566         len = (char *)p - (char *)q - 12;
567         *q++ = htonl(bmval0);
568         *q++ = htonl(bmval1);
569         *q++ = htonl(len);
570
571         status = 0;
572 /* out: */
573         return status;
574 }
575
576 static int encode_access(struct xdr_stream *xdr, u32 access)
577 {
578         uint32_t *p;
579
580         RESERVE_SPACE(8);
581         WRITE32(OP_ACCESS);
582         WRITE32(access);
583         
584         return 0;
585 }
586
587 static int encode_close(struct xdr_stream *xdr, const struct nfs_closeargs *arg)
588 {
589         uint32_t *p;
590
591         RESERVE_SPACE(8+sizeof(arg->stateid.data));
592         WRITE32(OP_CLOSE);
593         WRITE32(arg->seqid);
594         WRITEMEM(arg->stateid.data, sizeof(arg->stateid.data));
595         
596         return 0;
597 }
598
599 static int encode_commit(struct xdr_stream *xdr, const struct nfs_writeargs *args)
600 {
601         uint32_t *p;
602         
603         RESERVE_SPACE(16);
604         WRITE32(OP_COMMIT);
605         WRITE64(args->offset);
606         WRITE32(args->count);
607
608         return 0;
609 }
610
611 static int encode_create(struct xdr_stream *xdr, const struct nfs4_create_arg *create)
612 {
613         uint32_t *p;
614         
615         RESERVE_SPACE(8);
616         WRITE32(OP_CREATE);
617         WRITE32(create->ftype);
618
619         switch (create->ftype) {
620         case NF4LNK:
621                 RESERVE_SPACE(4 + create->u.symlink->len);
622                 WRITE32(create->u.symlink->len);
623                 WRITEMEM(create->u.symlink->name, create->u.symlink->len);
624                 break;
625
626         case NF4BLK: case NF4CHR:
627                 RESERVE_SPACE(8);
628                 WRITE32(create->u.device.specdata1);
629                 WRITE32(create->u.device.specdata2);
630                 break;
631
632         default:
633                 break;
634         }
635
636         RESERVE_SPACE(4 + create->name->len);
637         WRITE32(create->name->len);
638         WRITEMEM(create->name->name, create->name->len);
639
640         return encode_attrs(xdr, create->attrs, create->server);
641 }
642
643 static int encode_getattr_one(struct xdr_stream *xdr, uint32_t bitmap)
644 {
645         uint32_t *p;
646
647         RESERVE_SPACE(12);
648         WRITE32(OP_GETATTR);
649         WRITE32(1);
650         WRITE32(bitmap);
651         return 0;
652 }
653
654 static int encode_getattr_two(struct xdr_stream *xdr, uint32_t bm0, uint32_t bm1)
655 {
656         uint32_t *p;
657
658         RESERVE_SPACE(16);
659         WRITE32(OP_GETATTR);
660         WRITE32(2);
661         WRITE32(bm0);
662         WRITE32(bm1);
663         return 0;
664 }
665
666 static int encode_getfattr(struct xdr_stream *xdr, const u32* bitmask)
667 {
668         return encode_getattr_two(xdr,
669                         bitmask[0] & nfs4_fattr_bitmap[0],
670                         bitmask[1] & nfs4_fattr_bitmap[1]);
671 }
672
673 static int encode_fsinfo(struct xdr_stream *xdr, const u32* bitmask)
674 {
675         return encode_getattr_two(xdr, bitmask[0] & nfs4_fsinfo_bitmap[0],
676                         bitmask[1] & nfs4_fsinfo_bitmap[1]);
677 }
678
679 static int encode_getfh(struct xdr_stream *xdr)
680 {
681         uint32_t *p;
682
683         RESERVE_SPACE(4);
684         WRITE32(OP_GETFH);
685
686         return 0;
687 }
688
689 static int encode_link(struct xdr_stream *xdr, const struct qstr *name)
690 {
691         uint32_t *p;
692
693         RESERVE_SPACE(8 + name->len);
694         WRITE32(OP_LINK);
695         WRITE32(name->len);
696         WRITEMEM(name->name, name->len);
697         
698         return 0;
699 }
700
701 /*
702  * opcode,type,reclaim,offset,length,new_lock_owner = 32
703  * open_seqid,open_stateid,lock_seqid,lock_owner.clientid, lock_owner.id = 40
704  */
705 static int encode_lock(struct xdr_stream *xdr, const struct nfs_lockargs *arg)
706 {
707         uint32_t *p;
708         struct nfs_lock_opargs *opargs = arg->u.lock;
709
710         RESERVE_SPACE(32);
711         WRITE32(OP_LOCK);
712         WRITE32(arg->type); 
713         WRITE32(opargs->reclaim);
714         WRITE64(arg->offset);
715         WRITE64(arg->length);
716         WRITE32(opargs->new_lock_owner);
717         if (opargs->new_lock_owner){
718                 struct nfs_open_to_lock *ol = opargs->u.open_lock;
719
720                 RESERVE_SPACE(40);
721                 WRITE32(ol->open_seqid);
722                 WRITEMEM(&ol->open_stateid, sizeof(ol->open_stateid));
723                 WRITE32(ol->lock_seqid);
724                 WRITE64(ol->lock_owner.clientid);
725                 WRITE32(4);
726                 WRITE32(ol->lock_owner.id);
727         }
728         else {
729                 struct nfs_exist_lock *el = opargs->u.exist_lock;
730
731                 RESERVE_SPACE(20);
732                 WRITEMEM(&el->stateid, sizeof(el->stateid));
733                 WRITE32(el->seqid);
734         }
735
736         return 0;
737 }
738
739 static int encode_lockt(struct xdr_stream *xdr, const struct nfs_lockargs *arg)
740 {
741         uint32_t *p;
742         struct nfs_lowner *opargs = arg->u.lockt;
743
744         RESERVE_SPACE(40);
745         WRITE32(OP_LOCKT);
746         WRITE32(arg->type);
747         WRITE64(arg->offset);
748         WRITE64(arg->length);
749         WRITE64(opargs->clientid);
750         WRITE32(4);
751         WRITE32(opargs->id);
752
753         return 0;
754 }
755
756 static int encode_locku(struct xdr_stream *xdr, const struct nfs_lockargs *arg)
757 {
758         uint32_t *p;
759         struct nfs_locku_opargs *opargs = arg->u.locku;
760
761         RESERVE_SPACE(44);
762         WRITE32(OP_LOCKU);
763         WRITE32(arg->type);
764         WRITE32(opargs->seqid);
765         WRITEMEM(&opargs->stateid, sizeof(opargs->stateid));
766         WRITE64(arg->offset);
767         WRITE64(arg->length);
768
769         return 0;
770 }
771
772 static int encode_lookup(struct xdr_stream *xdr, const struct qstr *name)
773 {
774         int len = name->len;
775         uint32_t *p;
776
777         RESERVE_SPACE(8 + len);
778         WRITE32(OP_LOOKUP);
779         WRITE32(len);
780         WRITEMEM(name->name, len);
781
782         return 0;
783 }
784
785 static void encode_share_access(struct xdr_stream *xdr, int open_flags)
786 {
787         uint32_t *p;
788
789         RESERVE_SPACE(8);
790         switch (open_flags & (FMODE_READ|FMODE_WRITE)) {
791                 case FMODE_READ:
792                         WRITE32(NFS4_SHARE_ACCESS_READ);
793                         break;
794                 case FMODE_WRITE:
795                         WRITE32(NFS4_SHARE_ACCESS_WRITE);
796                         break;
797                 case FMODE_READ|FMODE_WRITE:
798                         WRITE32(NFS4_SHARE_ACCESS_BOTH);
799                         break;
800                 default:
801                         BUG();
802         }
803         WRITE32(0);             /* for linux, share_deny = 0 always */
804 }
805
806 static inline void encode_openhdr(struct xdr_stream *xdr, const struct nfs_openargs *arg)
807 {
808         uint32_t *p;
809  /*
810  * opcode 4, seqid 4, share_access 4, share_deny 4, clientid 8, ownerlen 4,
811  * owner 4 = 32
812  */
813         RESERVE_SPACE(8);
814         WRITE32(OP_OPEN);
815         WRITE32(arg->seqid);
816         encode_share_access(xdr, arg->open_flags);
817         RESERVE_SPACE(16);
818         WRITE64(arg->clientid);
819         WRITE32(4);
820         WRITE32(arg->id);
821 }
822
823 static inline void encode_createmode(struct xdr_stream *xdr, const struct nfs_openargs *arg)
824 {
825         uint32_t *p;
826
827         RESERVE_SPACE(4);
828         switch(arg->open_flags & O_EXCL) {
829                 case 0:
830                         WRITE32(NFS4_CREATE_UNCHECKED);
831                         encode_attrs(xdr, arg->u.attrs, arg->server);
832                         break;
833                 default:
834                         WRITE32(NFS4_CREATE_EXCLUSIVE);
835                         encode_nfs4_verifier(xdr, &arg->u.verifier);
836         }
837 }
838
839 static void encode_opentype(struct xdr_stream *xdr, const struct nfs_openargs *arg)
840 {
841         uint32_t *p;
842
843         RESERVE_SPACE(4);
844         switch (arg->open_flags & O_CREAT) {
845                 case 0:
846                         WRITE32(NFS4_OPEN_NOCREATE);
847                         break;
848                 default:
849                         BUG_ON(arg->claim != NFS4_OPEN_CLAIM_NULL);
850                         WRITE32(NFS4_OPEN_CREATE);
851                         encode_createmode(xdr, arg);
852         }
853 }
854
855 static inline void encode_delegation_type(struct xdr_stream *xdr, int delegation_type)
856 {
857         uint32_t *p;
858
859         RESERVE_SPACE(4);
860         switch (delegation_type) {
861                 case 0:
862                         WRITE32(NFS4_OPEN_DELEGATE_NONE);
863                         break;
864                 case FMODE_READ:
865                         WRITE32(NFS4_OPEN_DELEGATE_READ);
866                         break;
867                 case FMODE_WRITE|FMODE_READ:
868                         WRITE32(NFS4_OPEN_DELEGATE_WRITE);
869                         break;
870                 default:
871                         BUG();
872         }
873 }
874
875 static inline void encode_claim_null(struct xdr_stream *xdr, const struct qstr *name)
876 {
877         uint32_t *p;
878
879         RESERVE_SPACE(4);
880         WRITE32(NFS4_OPEN_CLAIM_NULL);
881         encode_string(xdr, name->len, name->name);
882 }
883
884 static inline void encode_claim_previous(struct xdr_stream *xdr, int type)
885 {
886         uint32_t *p;
887
888         RESERVE_SPACE(4);
889         WRITE32(NFS4_OPEN_CLAIM_PREVIOUS);
890         encode_delegation_type(xdr, type);
891 }
892
893 static inline void encode_claim_delegate_cur(struct xdr_stream *xdr, const struct qstr *name, const nfs4_stateid *stateid)
894 {
895         uint32_t *p;
896
897         RESERVE_SPACE(4+sizeof(stateid->data));
898         WRITE32(NFS4_OPEN_CLAIM_DELEGATE_CUR);
899         WRITEMEM(stateid->data, sizeof(stateid->data));
900         encode_string(xdr, name->len, name->name);
901 }
902
903 static int encode_open(struct xdr_stream *xdr, const struct nfs_openargs *arg)
904 {
905         encode_openhdr(xdr, arg);
906         encode_opentype(xdr, arg);
907         switch (arg->claim) {
908                 case NFS4_OPEN_CLAIM_NULL:
909                         encode_claim_null(xdr, arg->name);
910                         break;
911                 case NFS4_OPEN_CLAIM_PREVIOUS:
912                         encode_claim_previous(xdr, arg->u.delegation_type);
913                         break;
914                 case NFS4_OPEN_CLAIM_DELEGATE_CUR:
915                         encode_claim_delegate_cur(xdr, arg->name, &arg->u.delegation);
916                         break;
917                 default:
918                         BUG();
919         }
920         return 0;
921 }
922
923 static int encode_open_confirm(struct xdr_stream *xdr, const struct nfs_open_confirmargs *arg)
924 {
925         uint32_t *p;
926
927         RESERVE_SPACE(8+sizeof(arg->stateid.data));
928         WRITE32(OP_OPEN_CONFIRM);
929         WRITEMEM(arg->stateid.data, sizeof(arg->stateid.data));
930         WRITE32(arg->seqid);
931
932         return 0;
933 }
934
935 static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closeargs *arg)
936 {
937         uint32_t *p;
938
939         RESERVE_SPACE(8+sizeof(arg->stateid.data));
940         WRITE32(OP_OPEN_DOWNGRADE);
941         WRITEMEM(arg->stateid.data, sizeof(arg->stateid.data));
942         WRITE32(arg->seqid);
943         encode_share_access(xdr, arg->open_flags);
944         return 0;
945 }
946
947 static int
948 encode_putfh(struct xdr_stream *xdr, const struct nfs_fh *fh)
949 {
950         int len = fh->size;
951         uint32_t *p;
952
953         RESERVE_SPACE(8 + len);
954         WRITE32(OP_PUTFH);
955         WRITE32(len);
956         WRITEMEM(fh->data, len);
957
958         return 0;
959 }
960
961 static int encode_putrootfh(struct xdr_stream *xdr)
962 {
963         uint32_t *p;
964         
965         RESERVE_SPACE(4);
966         WRITE32(OP_PUTROOTFH);
967
968         return 0;
969 }
970
971 static void encode_stateid(struct xdr_stream *xdr, const struct nfs_open_context *ctx)
972 {
973         nfs4_stateid stateid;
974         uint32_t *p;
975
976         RESERVE_SPACE(16);
977         if (ctx->state != NULL) {
978                 nfs4_copy_stateid(&stateid, ctx->state, ctx->lockowner);
979                 WRITEMEM(stateid.data, sizeof(stateid.data));
980         } else
981                 WRITEMEM(zero_stateid.data, sizeof(zero_stateid.data));
982 }
983
984 static int encode_read(struct xdr_stream *xdr, const struct nfs_readargs *args)
985 {
986         uint32_t *p;
987
988         RESERVE_SPACE(4);
989         WRITE32(OP_READ);
990
991         encode_stateid(xdr, args->context);
992
993         RESERVE_SPACE(12);
994         WRITE64(args->offset);
995         WRITE32(args->count);
996
997         return 0;
998 }
999
1000 static int encode_readdir(struct xdr_stream *xdr, const struct nfs4_readdir_arg *readdir, struct rpc_rqst *req)
1001 {
1002         struct rpc_auth *auth = req->rq_task->tk_auth;
1003         int replen;
1004         uint32_t *p;
1005
1006         RESERVE_SPACE(32+sizeof(nfs4_verifier));
1007         WRITE32(OP_READDIR);
1008         WRITE64(readdir->cookie);
1009         WRITEMEM(readdir->verifier.data, sizeof(readdir->verifier.data));
1010         WRITE32(readdir->count >> 1);  /* We're not doing readdirplus */
1011         WRITE32(readdir->count);
1012         WRITE32(2);
1013         if (readdir->bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID) {
1014                 WRITE32(0);
1015                 WRITE32(FATTR4_WORD1_MOUNTED_ON_FILEID);
1016         } else {
1017                 WRITE32(FATTR4_WORD0_FILEID);
1018                 WRITE32(0);
1019         }
1020
1021         /* set up reply kvec
1022          *    toplevel_status + taglen + rescount + OP_PUTFH + status
1023          *      + OP_READDIR + status + verifer(2)  = 9
1024          */
1025         replen = (RPC_REPHDRSIZE + auth->au_rslack + 9) << 2;
1026         xdr_inline_pages(&req->rq_rcv_buf, replen, readdir->pages,
1027                          readdir->pgbase, readdir->count);
1028
1029         return 0;
1030 }
1031
1032 static int encode_readlink(struct xdr_stream *xdr, const struct nfs4_readlink *readlink, struct rpc_rqst *req)
1033 {
1034         struct rpc_auth *auth = req->rq_task->tk_auth;
1035         unsigned int replen;
1036         uint32_t *p;
1037
1038         RESERVE_SPACE(4);
1039         WRITE32(OP_READLINK);
1040
1041         /* set up reply kvec
1042          *    toplevel_status + taglen + rescount + OP_PUTFH + status
1043          *      + OP_READLINK + status + string length = 8
1044          */
1045         replen = (RPC_REPHDRSIZE + auth->au_rslack + 8) << 2;
1046         xdr_inline_pages(&req->rq_rcv_buf, replen, readlink->pages,
1047                         readlink->pgbase, readlink->pglen);
1048         
1049         return 0;
1050 }
1051
1052 static int encode_remove(struct xdr_stream *xdr, const struct qstr *name)
1053 {
1054         uint32_t *p;
1055
1056         RESERVE_SPACE(8 + name->len);
1057         WRITE32(OP_REMOVE);
1058         WRITE32(name->len);
1059         WRITEMEM(name->name, name->len);
1060
1061         return 0;
1062 }
1063
1064 static int encode_rename(struct xdr_stream *xdr, const struct qstr *oldname, const struct qstr *newname)
1065 {
1066         uint32_t *p;
1067
1068         RESERVE_SPACE(8 + oldname->len);
1069         WRITE32(OP_RENAME);
1070         WRITE32(oldname->len);
1071         WRITEMEM(oldname->name, oldname->len);
1072         
1073         RESERVE_SPACE(4 + newname->len);
1074         WRITE32(newname->len);
1075         WRITEMEM(newname->name, newname->len);
1076
1077         return 0;
1078 }
1079
1080 static int encode_renew(struct xdr_stream *xdr, const struct nfs4_client *client_stateid)
1081 {
1082         uint32_t *p;
1083
1084         RESERVE_SPACE(12);
1085         WRITE32(OP_RENEW);
1086         WRITE64(client_stateid->cl_clientid);
1087
1088         return 0;
1089 }
1090
1091 static int
1092 encode_savefh(struct xdr_stream *xdr)
1093 {
1094         uint32_t *p;
1095
1096         RESERVE_SPACE(4);
1097         WRITE32(OP_SAVEFH);
1098
1099         return 0;
1100 }
1101
1102 static int encode_setattr(struct xdr_stream *xdr, const struct nfs_setattrargs *arg, const struct nfs_server *server)
1103 {
1104         int status;
1105         uint32_t *p;
1106         
1107         RESERVE_SPACE(4+sizeof(arg->stateid.data));
1108         WRITE32(OP_SETATTR);
1109         WRITEMEM(arg->stateid.data, sizeof(arg->stateid.data));
1110
1111         if ((status = encode_attrs(xdr, arg->iap, server)))
1112                 return status;
1113
1114         return 0;
1115 }
1116
1117 static int encode_setclientid(struct xdr_stream *xdr, const struct nfs4_setclientid *setclientid)
1118 {
1119         uint32_t *p;
1120
1121         RESERVE_SPACE(4 + sizeof(setclientid->sc_verifier->data));
1122         WRITE32(OP_SETCLIENTID);
1123         WRITEMEM(setclientid->sc_verifier->data, sizeof(setclientid->sc_verifier->data));
1124
1125         encode_string(xdr, setclientid->sc_name_len, setclientid->sc_name);
1126         RESERVE_SPACE(4);
1127         WRITE32(setclientid->sc_prog);
1128         encode_string(xdr, setclientid->sc_netid_len, setclientid->sc_netid);
1129         encode_string(xdr, setclientid->sc_uaddr_len, setclientid->sc_uaddr);
1130         RESERVE_SPACE(4);
1131         WRITE32(setclientid->sc_cb_ident);
1132
1133         return 0;
1134 }
1135
1136 static int encode_setclientid_confirm(struct xdr_stream *xdr, const struct nfs4_client *client_state)
1137 {
1138         uint32_t *p;
1139
1140         RESERVE_SPACE(12 + sizeof(client_state->cl_confirm.data));
1141         WRITE32(OP_SETCLIENTID_CONFIRM);
1142         WRITE64(client_state->cl_clientid);
1143         WRITEMEM(client_state->cl_confirm.data, sizeof(client_state->cl_confirm.data));
1144
1145         return 0;
1146 }
1147
1148 static int encode_write(struct xdr_stream *xdr, const struct nfs_writeargs *args)
1149 {
1150         uint32_t *p;
1151
1152         RESERVE_SPACE(4);
1153         WRITE32(OP_WRITE);
1154
1155         encode_stateid(xdr, args->context);
1156
1157         RESERVE_SPACE(16);
1158         WRITE64(args->offset);
1159         WRITE32(args->stable);
1160         WRITE32(args->count);
1161
1162         xdr_write_pages(xdr, args->pages, args->pgbase, args->count);
1163
1164         return 0;
1165 }
1166
1167 static int encode_delegreturn(struct xdr_stream *xdr, const nfs4_stateid *stateid)
1168 {
1169         uint32_t *p;
1170
1171         RESERVE_SPACE(20);
1172
1173         WRITE32(OP_DELEGRETURN);
1174         WRITEMEM(stateid->data, sizeof(stateid->data));
1175         return 0;
1176
1177 }
1178 /*
1179  * END OF "GENERIC" ENCODE ROUTINES.
1180  */
1181
1182 /*
1183  * Encode an ACCESS request
1184  */
1185 static int nfs4_xdr_enc_access(struct rpc_rqst *req, uint32_t *p, const struct nfs4_accessargs *args)
1186 {
1187         struct xdr_stream xdr;
1188         struct compound_hdr hdr = {
1189                 .nops = 2,
1190         };
1191         int status;
1192
1193         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1194         encode_compound_hdr(&xdr, &hdr);
1195         if ((status = encode_putfh(&xdr, args->fh)) == 0)
1196                 status = encode_access(&xdr, args->access);
1197         return status;
1198 }
1199
1200 /*
1201  * Encode LOOKUP request
1202  */
1203 static int nfs4_xdr_enc_lookup(struct rpc_rqst *req, uint32_t *p, const struct nfs4_lookup_arg *args)
1204 {
1205         struct xdr_stream xdr;
1206         struct compound_hdr hdr = {
1207                 .nops = 4,
1208         };
1209         int status;
1210
1211         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1212         encode_compound_hdr(&xdr, &hdr);
1213         if ((status = encode_putfh(&xdr, args->dir_fh)) != 0)
1214                 goto out;
1215         if ((status = encode_lookup(&xdr, args->name)) != 0)
1216                 goto out;
1217         if ((status = encode_getfh(&xdr)) != 0)
1218                 goto out;
1219         status = encode_getfattr(&xdr, args->bitmask);
1220 out:
1221         return status;
1222 }
1223
1224 /*
1225  * Encode LOOKUP_ROOT request
1226  */
1227 static int nfs4_xdr_enc_lookup_root(struct rpc_rqst *req, uint32_t *p, const struct nfs4_lookup_root_arg *args)
1228 {
1229         struct xdr_stream xdr;
1230         struct compound_hdr hdr = {
1231                 .nops = 3,
1232         };
1233         int status;
1234
1235         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1236         encode_compound_hdr(&xdr, &hdr);
1237         if ((status = encode_putrootfh(&xdr)) != 0)
1238                 goto out;
1239         if ((status = encode_getfh(&xdr)) == 0)
1240                 status = encode_getfattr(&xdr, args->bitmask);
1241 out:
1242         return status;
1243 }
1244
1245 /*
1246  * Encode REMOVE request
1247  */
1248 static int nfs4_xdr_enc_remove(struct rpc_rqst *req, uint32_t *p, const struct nfs4_remove_arg *args)
1249 {
1250         struct xdr_stream xdr;
1251         struct compound_hdr hdr = {
1252                 .nops = 2,
1253         };
1254         int status;
1255
1256         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1257         encode_compound_hdr(&xdr, &hdr);
1258         if ((status = encode_putfh(&xdr, args->fh)) == 0)
1259                 status = encode_remove(&xdr, args->name);
1260         return status;
1261 }
1262
1263 /*
1264  * Encode RENAME request
1265  */
1266 static int nfs4_xdr_enc_rename(struct rpc_rqst *req, uint32_t *p, const struct nfs4_rename_arg *args)
1267 {
1268         struct xdr_stream xdr;
1269         struct compound_hdr hdr = {
1270                 .nops = 4,
1271         };
1272         int status;
1273
1274         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1275         encode_compound_hdr(&xdr, &hdr);
1276         if ((status = encode_putfh(&xdr, args->old_dir)) != 0)
1277                 goto out;
1278         if ((status = encode_savefh(&xdr)) != 0)
1279                 goto out;
1280         if ((status = encode_putfh(&xdr, args->new_dir)) != 0)
1281                 goto out;
1282         status = encode_rename(&xdr, args->old_name, args->new_name);
1283 out:
1284         return status;
1285 }
1286
1287 /*
1288  * Encode LINK request
1289  */
1290 static int nfs4_xdr_enc_link(struct rpc_rqst *req, uint32_t *p, const struct nfs4_link_arg *args)
1291 {
1292         struct xdr_stream xdr;
1293         struct compound_hdr hdr = {
1294                 .nops = 4,
1295         };
1296         int status;
1297
1298         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1299         encode_compound_hdr(&xdr, &hdr);
1300         if ((status = encode_putfh(&xdr, args->fh)) != 0)
1301                 goto out;
1302         if ((status = encode_savefh(&xdr)) != 0)
1303                 goto out;
1304         if ((status = encode_putfh(&xdr, args->dir_fh)) != 0)
1305                 goto out;
1306         status = encode_link(&xdr, args->name);
1307 out:
1308         return status;
1309 }
1310
1311 /*
1312  * Encode CREATE request
1313  */
1314 static int nfs4_xdr_enc_create(struct rpc_rqst *req, uint32_t *p, const struct nfs4_create_arg *args)
1315 {
1316         struct xdr_stream xdr;
1317         struct compound_hdr hdr = {
1318                 .nops = 4,
1319         };
1320         int status;
1321
1322         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1323         encode_compound_hdr(&xdr, &hdr);
1324         if ((status = encode_putfh(&xdr, args->dir_fh)) != 0)
1325                 goto out;
1326         if ((status = encode_create(&xdr, args)) != 0)
1327                 goto out;
1328         if ((status = encode_getfh(&xdr)) != 0)
1329                 goto out;
1330         status = encode_getfattr(&xdr, args->bitmask);
1331 out:
1332         return status;
1333 }
1334
1335 /*
1336  * Encode SYMLINK request
1337  */
1338 static int nfs4_xdr_enc_symlink(struct rpc_rqst *req, uint32_t *p, const struct nfs4_create_arg *args)
1339 {
1340         return nfs4_xdr_enc_create(req, p, args);
1341 }
1342
1343 /*
1344  * Encode GETATTR request
1345  */
1346 static int nfs4_xdr_enc_getattr(struct rpc_rqst *req, uint32_t *p, const struct nfs4_getattr_arg *args)
1347 {
1348         struct xdr_stream xdr;
1349         struct compound_hdr hdr = {
1350                 .nops = 2,
1351         };
1352         int status;
1353
1354         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1355         encode_compound_hdr(&xdr, &hdr);
1356         if ((status = encode_putfh(&xdr, args->fh)) == 0)
1357                 status = encode_getfattr(&xdr, args->bitmask);
1358         return status;
1359 }
1360
1361 /*
1362  * Encode a CLOSE request
1363  */
1364 static int nfs4_xdr_enc_close(struct rpc_rqst *req, uint32_t *p, struct nfs_closeargs *args)
1365 {
1366         struct xdr_stream xdr;
1367         struct compound_hdr hdr = {
1368                 .nops   = 2,
1369         };
1370         int status;
1371
1372         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1373         encode_compound_hdr(&xdr, &hdr);
1374         status = encode_putfh(&xdr, args->fh);
1375         if(status)
1376                 goto out;
1377         status = encode_close(&xdr, args);
1378 out:
1379         return status;
1380 }
1381
1382 /*
1383  * Encode an OPEN request
1384  */
1385 static int nfs4_xdr_enc_open(struct rpc_rqst *req, uint32_t *p, struct nfs_openargs *args)
1386 {
1387         struct xdr_stream xdr;
1388         struct compound_hdr hdr = {
1389                 .nops = 4,
1390         };
1391         int status;
1392
1393         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1394         encode_compound_hdr(&xdr, &hdr);
1395         status = encode_putfh(&xdr, args->fh);
1396         if (status)
1397                 goto out;
1398         status = encode_open(&xdr, args);
1399         if (status)
1400                 goto out;
1401         status = encode_getfh(&xdr);
1402         if (status)
1403                 goto out;
1404         status = encode_getfattr(&xdr, args->bitmask);
1405 out:
1406         return status;
1407 }
1408
1409 /*
1410  * Encode an OPEN_CONFIRM request
1411  */
1412 static int nfs4_xdr_enc_open_confirm(struct rpc_rqst *req, uint32_t *p, struct nfs_open_confirmargs *args)
1413 {
1414         struct xdr_stream xdr;
1415         struct compound_hdr hdr = {
1416                 .nops   = 2,
1417         };
1418         int status;
1419
1420         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1421         encode_compound_hdr(&xdr, &hdr);
1422         status = encode_putfh(&xdr, args->fh);
1423         if(status)
1424                 goto out;
1425         status = encode_open_confirm(&xdr, args);
1426 out:
1427         return status;
1428 }
1429
1430 /*
1431  * Encode an OPEN request with no attributes.
1432  */
1433 static int nfs4_xdr_enc_open_noattr(struct rpc_rqst *req, uint32_t *p, struct nfs_openargs *args)
1434 {
1435         struct xdr_stream xdr;
1436         struct compound_hdr hdr = {
1437                 .nops   = 2,
1438         };
1439         int status;
1440
1441         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1442         encode_compound_hdr(&xdr, &hdr);
1443         status = encode_putfh(&xdr, args->fh);
1444         if (status)
1445                 goto out;
1446         status = encode_open(&xdr, args);
1447 out:
1448         return status;
1449 }
1450
1451 /*
1452  * Encode an OPEN_DOWNGRADE request
1453  */
1454 static int nfs4_xdr_enc_open_downgrade(struct rpc_rqst *req, uint32_t *p, struct nfs_closeargs *args)
1455 {
1456         struct xdr_stream xdr;
1457         struct compound_hdr hdr = {
1458                 .nops   = 2,
1459         };
1460         int status;
1461
1462         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1463         encode_compound_hdr(&xdr, &hdr);
1464         status = encode_putfh(&xdr, args->fh);
1465         if (status)
1466                 goto out;
1467         status = encode_open_downgrade(&xdr, args);
1468 out:
1469         return status;
1470 }
1471
1472 /*
1473  * Encode a LOCK request
1474  */
1475 static int nfs4_xdr_enc_lock(struct rpc_rqst *req, uint32_t *p, struct nfs_lockargs *args)
1476 {
1477         struct xdr_stream xdr;
1478         struct compound_hdr hdr = {
1479                 .nops   = 2,
1480         };
1481         int status;
1482
1483         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1484         encode_compound_hdr(&xdr, &hdr);
1485         status = encode_putfh(&xdr, args->fh);
1486         if(status)
1487                 goto out;
1488         status = encode_lock(&xdr, args);
1489 out:
1490         return status;
1491 }
1492
1493 /*
1494  * Encode a LOCKT request
1495  */
1496 static int nfs4_xdr_enc_lockt(struct rpc_rqst *req, uint32_t *p, struct nfs_lockargs *args)
1497 {
1498         struct xdr_stream xdr;
1499         struct compound_hdr hdr = {
1500                 .nops   = 2,
1501         };
1502         int status;
1503
1504         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1505         encode_compound_hdr(&xdr, &hdr);
1506         status = encode_putfh(&xdr, args->fh);
1507         if(status)
1508                 goto out;
1509         status = encode_lockt(&xdr, args);
1510 out:
1511         return status;
1512 }
1513
1514 /*
1515  * Encode a LOCKU request
1516  */
1517 static int nfs4_xdr_enc_locku(struct rpc_rqst *req, uint32_t *p, struct nfs_lockargs *args)
1518 {
1519         struct xdr_stream xdr;
1520         struct compound_hdr hdr = {
1521                 .nops   = 2,
1522         };
1523         int status;
1524
1525         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1526         encode_compound_hdr(&xdr, &hdr);
1527         status = encode_putfh(&xdr, args->fh);
1528         if(status)
1529                 goto out;
1530         status = encode_locku(&xdr, args);
1531 out:
1532         return status;
1533 }
1534
1535 /*
1536  * Encode a READLINK request
1537  */
1538 static int nfs4_xdr_enc_readlink(struct rpc_rqst *req, uint32_t *p, const struct nfs4_readlink *args)
1539 {
1540         struct xdr_stream xdr;
1541         struct compound_hdr hdr = {
1542                 .nops = 2,
1543         };
1544         int status;
1545
1546         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1547         encode_compound_hdr(&xdr, &hdr);
1548         status = encode_putfh(&xdr, args->fh);
1549         if(status)
1550                 goto out;
1551         status = encode_readlink(&xdr, args, req);
1552 out:
1553         return status;
1554 }
1555
1556 /*
1557  * Encode a READDIR request
1558  */
1559 static int nfs4_xdr_enc_readdir(struct rpc_rqst *req, uint32_t *p, const struct nfs4_readdir_arg *args)
1560 {
1561         struct xdr_stream xdr;
1562         struct compound_hdr hdr = {
1563                 .nops = 2,
1564         };
1565         int status;
1566
1567         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1568         encode_compound_hdr(&xdr, &hdr);
1569         status = encode_putfh(&xdr, args->fh);
1570         if(status)
1571                 goto out;
1572         status = encode_readdir(&xdr, args, req);
1573 out:
1574         return status;
1575 }
1576
1577 /*
1578  * Encode a READ request
1579  */
1580 static int nfs4_xdr_enc_read(struct rpc_rqst *req, uint32_t *p, struct nfs_readargs *args)
1581 {
1582         struct rpc_auth *auth = req->rq_task->tk_auth;
1583         struct xdr_stream xdr;
1584         struct compound_hdr hdr = {
1585                 .nops = 2,
1586         };
1587         int replen, status;
1588
1589         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1590         encode_compound_hdr(&xdr, &hdr);
1591         status = encode_putfh(&xdr, args->fh);
1592         if (status)
1593                 goto out;
1594         status = encode_read(&xdr, args);
1595         if (status)
1596                 goto out;
1597
1598         /* set up reply kvec
1599          *    toplevel status + taglen=0 + rescount + OP_PUTFH + status
1600          *       + OP_READ + status + eof + datalen = 9
1601          */
1602         replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS4_dec_read_sz) << 2;
1603         xdr_inline_pages(&req->rq_rcv_buf, replen,
1604                          args->pages, args->pgbase, args->count);
1605 out:
1606         return status;
1607 }
1608
1609 /*
1610  * Encode an SETATTR request
1611  */
1612 static int nfs4_xdr_enc_setattr(struct rpc_rqst *req, uint32_t *p, struct nfs_setattrargs *args)
1613
1614 {
1615         struct xdr_stream xdr;
1616         struct compound_hdr hdr = {
1617                 .nops   = 3,
1618         };
1619         int status;
1620
1621         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1622         encode_compound_hdr(&xdr, &hdr);
1623         status = encode_putfh(&xdr, args->fh);
1624         if(status)
1625                 goto out;
1626         status = encode_setattr(&xdr, args, args->server);
1627         if(status)
1628                 goto out;
1629         status = encode_getfattr(&xdr, args->bitmask);
1630 out:
1631         return status;
1632 }
1633
1634 /*
1635  * Encode a WRITE request
1636  */
1637 static int nfs4_xdr_enc_write(struct rpc_rqst *req, uint32_t *p, struct nfs_writeargs *args)
1638 {
1639         struct xdr_stream xdr;
1640         struct compound_hdr hdr = {
1641                 .nops = 2,
1642         };
1643         int status;
1644
1645         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1646         encode_compound_hdr(&xdr, &hdr);
1647         status = encode_putfh(&xdr, args->fh);
1648         if (status)
1649                 goto out;
1650         status = encode_write(&xdr, args);
1651 out:
1652         return status;
1653 }
1654
1655 /*
1656  *  a COMMIT request
1657  */
1658 static int nfs4_xdr_enc_commit(struct rpc_rqst *req, uint32_t *p, struct nfs_writeargs *args)
1659 {
1660         struct xdr_stream xdr;
1661         struct compound_hdr hdr = {
1662                 .nops = 2,
1663         };
1664         int status;
1665
1666         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1667         encode_compound_hdr(&xdr, &hdr);
1668         status = encode_putfh(&xdr, args->fh);
1669         if (status)
1670                 goto out;
1671         status = encode_commit(&xdr, args);
1672 out:
1673         return status;
1674 }
1675
1676 /*
1677  * FSINFO request
1678  */
1679 static int nfs4_xdr_enc_fsinfo(struct rpc_rqst *req, uint32_t *p, struct nfs4_fsinfo_arg *args)
1680 {
1681         struct xdr_stream xdr;
1682         struct compound_hdr hdr = {
1683                 .nops   = 2,
1684         };
1685         int status;
1686
1687         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1688         encode_compound_hdr(&xdr, &hdr);
1689         status = encode_putfh(&xdr, args->fh);
1690         if (!status)
1691                 status = encode_fsinfo(&xdr, args->bitmask);
1692         return status;
1693 }
1694
1695 /*
1696  * a PATHCONF request
1697  */
1698 static int nfs4_xdr_enc_pathconf(struct rpc_rqst *req, uint32_t *p, const struct nfs4_pathconf_arg *args)
1699 {
1700         struct xdr_stream xdr;
1701         struct compound_hdr hdr = {
1702                 .nops = 2,
1703         };
1704         int status;
1705
1706         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1707         encode_compound_hdr(&xdr, &hdr);
1708         status = encode_putfh(&xdr, args->fh);
1709         if (!status)
1710                 status = encode_getattr_one(&xdr,
1711                                 args->bitmask[0] & nfs4_pathconf_bitmap[0]);
1712         return status;
1713 }
1714
1715 /*
1716  * a STATFS request
1717  */
1718 static int nfs4_xdr_enc_statfs(struct rpc_rqst *req, uint32_t *p, const struct nfs4_statfs_arg *args)
1719 {
1720         struct xdr_stream xdr;
1721         struct compound_hdr hdr = {
1722                 .nops = 2,
1723         };
1724         int status;
1725
1726         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1727         encode_compound_hdr(&xdr, &hdr);
1728         status = encode_putfh(&xdr, args->fh);
1729         if (status == 0)
1730                 status = encode_getattr_two(&xdr,
1731                                 args->bitmask[0] & nfs4_statfs_bitmap[0],
1732                                 args->bitmask[1] & nfs4_statfs_bitmap[1]);
1733         return status;
1734 }
1735
1736 /*
1737  * GETATTR_BITMAP request
1738  */
1739 static int nfs4_xdr_enc_server_caps(struct rpc_rqst *req, uint32_t *p, const struct nfs_fh *fhandle)
1740 {
1741         struct xdr_stream xdr;
1742         struct compound_hdr hdr = {
1743                 .nops = 2,
1744         };
1745         int status;
1746
1747         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1748         encode_compound_hdr(&xdr, &hdr);
1749         status = encode_putfh(&xdr, fhandle);
1750         if (status == 0)
1751                 status = encode_getattr_one(&xdr, FATTR4_WORD0_SUPPORTED_ATTRS|
1752                                 FATTR4_WORD0_LINK_SUPPORT|
1753                                 FATTR4_WORD0_SYMLINK_SUPPORT|
1754                                 FATTR4_WORD0_ACLSUPPORT);
1755         return status;
1756 }
1757
1758 /*
1759  * a RENEW request
1760  */
1761 static int nfs4_xdr_enc_renew(struct rpc_rqst *req, uint32_t *p, struct nfs4_client *clp)
1762 {
1763         struct xdr_stream xdr;
1764         struct compound_hdr hdr = {
1765                 .nops   = 1,
1766         };
1767
1768         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1769         encode_compound_hdr(&xdr, &hdr);
1770         return encode_renew(&xdr, clp);
1771 }
1772
1773 /*
1774  * a SETCLIENTID request
1775  */
1776 static int nfs4_xdr_enc_setclientid(struct rpc_rqst *req, uint32_t *p, struct nfs4_setclientid *sc)
1777 {
1778         struct xdr_stream xdr;
1779         struct compound_hdr hdr = {
1780                 .nops   = 1,
1781         };
1782
1783         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1784         encode_compound_hdr(&xdr, &hdr);
1785         return encode_setclientid(&xdr, sc);
1786 }
1787
1788 /*
1789  * a SETCLIENTID_CONFIRM request
1790  */
1791 static int nfs4_xdr_enc_setclientid_confirm(struct rpc_rqst *req, uint32_t *p, struct nfs4_client *clp)
1792 {
1793         struct xdr_stream xdr;
1794         struct compound_hdr hdr = {
1795                 .nops   = 3,
1796         };
1797         const u32 lease_bitmap[2] = { FATTR4_WORD0_LEASE_TIME, 0 };
1798         int status;
1799
1800         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1801         encode_compound_hdr(&xdr, &hdr);
1802         status = encode_setclientid_confirm(&xdr, clp);
1803         if (!status)
1804                 status = encode_putrootfh(&xdr);
1805         if (!status)
1806                 status = encode_fsinfo(&xdr, lease_bitmap);
1807         return status;
1808 }
1809
1810 /*
1811  * DELEGRETURN request
1812  */
1813 static int nfs4_xdr_enc_delegreturn(struct rpc_rqst *req, uint32_t *p, const struct nfs4_delegreturnargs *args)
1814 {
1815         struct xdr_stream xdr;
1816         struct compound_hdr hdr = {
1817                 .nops = 2,
1818         };
1819         int status;
1820
1821         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
1822         encode_compound_hdr(&xdr, &hdr);
1823         if ((status = encode_putfh(&xdr, args->fhandle)) == 0)
1824                 status = encode_delegreturn(&xdr, args->stateid);
1825         return status;
1826 }
1827
1828 /*
1829  * START OF "GENERIC" DECODE ROUTINES.
1830  *   These may look a little ugly since they are imported from a "generic"
1831  * set of XDR encode/decode routines which are intended to be shared by
1832  * all of our NFSv4 implementations (OpenBSD, MacOS X...).
1833  *
1834  * If the pain of reading these is too great, it should be a straightforward
1835  * task to translate them into Linux-specific versions which are more
1836  * consistent with the style used in NFSv2/v3...
1837  */
1838 #define READ32(x)         (x) = ntohl(*p++)
1839 #define READ64(x)         do {                  \
1840         (x) = (u64)ntohl(*p++) << 32;           \
1841         (x) |= ntohl(*p++);                     \
1842 } while (0)
1843 #define READTIME(x)       do {                  \
1844         p++;                                    \
1845         (x.tv_sec) = ntohl(*p++);               \
1846         (x.tv_nsec) = ntohl(*p++);              \
1847 } while (0)
1848 #define COPYMEM(x,nbytes) do {                  \
1849         memcpy((x), p, nbytes);                 \
1850         p += XDR_QUADLEN(nbytes);               \
1851 } while (0)
1852
1853 #define READ_BUF(nbytes)  do { \
1854         p = xdr_inline_decode(xdr, nbytes); \
1855         if (!p) { \
1856                 printk(KERN_WARNING "%s: reply buffer overflowed in line %d.", \
1857                                 __FUNCTION__, __LINE__); \
1858                 return -EIO; \
1859         } \
1860 } while (0)
1861
1862 static int decode_opaque_inline(struct xdr_stream *xdr, uint32_t *len, char **string)
1863 {
1864         uint32_t *p;
1865
1866         READ_BUF(4);
1867         READ32(*len);
1868         READ_BUF(*len);
1869         *string = (char *)p;
1870         return 0;
1871 }
1872
1873 static int decode_compound_hdr(struct xdr_stream *xdr, struct compound_hdr *hdr)
1874 {
1875         uint32_t *p;
1876
1877         READ_BUF(8);
1878         READ32(hdr->status);
1879         READ32(hdr->taglen);
1880         
1881         READ_BUF(hdr->taglen + 4);
1882         hdr->tag = (char *)p;
1883         p += XDR_QUADLEN(hdr->taglen);
1884         READ32(hdr->nops);
1885         return 0;
1886 }
1887
1888 static int decode_op_hdr(struct xdr_stream *xdr, enum nfs_opnum4 expected)
1889 {
1890         uint32_t *p;
1891         uint32_t opnum;
1892         int32_t nfserr;
1893
1894         READ_BUF(8);
1895         READ32(opnum);
1896         if (opnum != expected) {
1897                 printk(KERN_NOTICE
1898                                 "nfs4_decode_op_hdr: Server returned operation"
1899                                 " %d but we issued a request for %d\n",
1900                                 opnum, expected);
1901                 return -EIO;
1902         }
1903         READ32(nfserr);
1904         if (nfserr != NFS_OK)
1905                 return -nfs_stat_to_errno(nfserr);
1906         return 0;
1907 }
1908
1909 /* Dummy routine */
1910 static int decode_ace(struct xdr_stream *xdr, void *ace, struct nfs4_client *clp)
1911 {
1912         uint32_t *p;
1913         uint32_t strlen;
1914         char *str;
1915
1916         READ_BUF(12);
1917         return decode_opaque_inline(xdr, &strlen, &str);
1918 }
1919
1920 static int decode_attr_bitmap(struct xdr_stream *xdr, uint32_t *bitmap)
1921 {
1922         uint32_t bmlen, *p;
1923
1924         READ_BUF(4);
1925         READ32(bmlen);
1926
1927         bitmap[0] = bitmap[1] = 0;
1928         READ_BUF((bmlen << 2));
1929         if (bmlen > 0) {
1930                 READ32(bitmap[0]);
1931                 if (bmlen > 1)
1932                         READ32(bitmap[1]);
1933         }
1934         return 0;
1935 }
1936
1937 static inline int decode_attr_length(struct xdr_stream *xdr, uint32_t *attrlen, uint32_t **savep)
1938 {
1939         uint32_t *p;
1940
1941         READ_BUF(4);
1942         READ32(*attrlen);
1943         *savep = xdr->p;
1944         return 0;
1945 }
1946
1947 static int decode_attr_supported(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *bitmask)
1948 {
1949         if (likely(bitmap[0] & FATTR4_WORD0_SUPPORTED_ATTRS)) {
1950                 decode_attr_bitmap(xdr, bitmask);
1951                 bitmap[0] &= ~FATTR4_WORD0_SUPPORTED_ATTRS;
1952         } else
1953                 bitmask[0] = bitmask[1] = 0;
1954         dprintk("%s: bitmask=0x%x%x\n", __FUNCTION__, bitmask[0], bitmask[1]);
1955         return 0;
1956 }
1957
1958 static int decode_attr_type(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *type)
1959 {
1960         uint32_t *p;
1961
1962         *type = 0;
1963         if (unlikely(bitmap[0] & (FATTR4_WORD0_TYPE - 1U)))
1964                 return -EIO;
1965         if (likely(bitmap[0] & FATTR4_WORD0_TYPE)) {
1966                 READ_BUF(4);
1967                 READ32(*type);
1968                 if (*type < NF4REG || *type > NF4NAMEDATTR) {
1969                         dprintk("%s: bad type %d\n", __FUNCTION__, *type);
1970                         return -EIO;
1971                 }
1972                 bitmap[0] &= ~FATTR4_WORD0_TYPE;
1973         }
1974         dprintk("%s: type=0%o\n", __FUNCTION__, nfs_type2fmt[*type].nfs2type);
1975         return 0;
1976 }
1977
1978 static int decode_attr_change(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *change)
1979 {
1980         uint32_t *p;
1981
1982         *change = 0;
1983         if (unlikely(bitmap[0] & (FATTR4_WORD0_CHANGE - 1U)))
1984                 return -EIO;
1985         if (likely(bitmap[0] & FATTR4_WORD0_CHANGE)) {
1986                 READ_BUF(8);
1987                 READ64(*change);
1988                 bitmap[0] &= ~FATTR4_WORD0_CHANGE;
1989         }
1990         dprintk("%s: change attribute=%Lu\n", __FUNCTION__,
1991                         (unsigned long long)*change);
1992         return 0;
1993 }
1994
1995 static int decode_attr_size(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *size)
1996 {
1997         uint32_t *p;
1998
1999         *size = 0;
2000         if (unlikely(bitmap[0] & (FATTR4_WORD0_SIZE - 1U)))
2001                 return -EIO;
2002         if (likely(bitmap[0] & FATTR4_WORD0_SIZE)) {
2003                 READ_BUF(8);
2004                 READ64(*size);
2005                 bitmap[0] &= ~FATTR4_WORD0_SIZE;
2006         }
2007         dprintk("%s: file size=%Lu\n", __FUNCTION__, (unsigned long long)*size);
2008         return 0;
2009 }
2010
2011 static int decode_attr_link_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
2012 {
2013         uint32_t *p;
2014
2015         *res = 0;
2016         if (unlikely(bitmap[0] & (FATTR4_WORD0_LINK_SUPPORT - 1U)))
2017                 return -EIO;
2018         if (likely(bitmap[0] & FATTR4_WORD0_LINK_SUPPORT)) {
2019                 READ_BUF(4);
2020                 READ32(*res);
2021                 bitmap[0] &= ~FATTR4_WORD0_LINK_SUPPORT;
2022         }
2023         dprintk("%s: link support=%s\n", __FUNCTION__, *res == 0 ? "false" : "true");
2024         return 0;
2025 }
2026
2027 static int decode_attr_symlink_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
2028 {
2029         uint32_t *p;
2030
2031         *res = 0;
2032         if (unlikely(bitmap[0] & (FATTR4_WORD0_SYMLINK_SUPPORT - 1U)))
2033                 return -EIO;
2034         if (likely(bitmap[0] & FATTR4_WORD0_SYMLINK_SUPPORT)) {
2035                 READ_BUF(4);
2036                 READ32(*res);
2037                 bitmap[0] &= ~FATTR4_WORD0_SYMLINK_SUPPORT;
2038         }
2039         dprintk("%s: symlink support=%s\n", __FUNCTION__, *res == 0 ? "false" : "true");
2040         return 0;
2041 }
2042
2043 static int decode_attr_fsid(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs4_fsid *fsid)
2044 {
2045         uint32_t *p;
2046
2047         fsid->major = 0;
2048         fsid->minor = 0;
2049         if (unlikely(bitmap[0] & (FATTR4_WORD0_FSID - 1U)))
2050                 return -EIO;
2051         if (likely(bitmap[0] & FATTR4_WORD0_FSID)) {
2052                 READ_BUF(16);
2053                 READ64(fsid->major);
2054                 READ64(fsid->minor);
2055                 bitmap[0] &= ~FATTR4_WORD0_FSID;
2056         }
2057         dprintk("%s: fsid=(0x%Lx/0x%Lx)\n", __FUNCTION__,
2058                         (unsigned long long)fsid->major,
2059                         (unsigned long long)fsid->minor);
2060         return 0;
2061 }
2062
2063 static int decode_attr_lease_time(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
2064 {
2065         uint32_t *p;
2066
2067         *res = 60;
2068         if (unlikely(bitmap[0] & (FATTR4_WORD0_LEASE_TIME - 1U)))
2069                 return -EIO;
2070         if (likely(bitmap[0] & FATTR4_WORD0_LEASE_TIME)) {
2071                 READ_BUF(4);
2072                 READ32(*res);
2073                 bitmap[0] &= ~FATTR4_WORD0_LEASE_TIME;
2074         }
2075         dprintk("%s: file size=%u\n", __FUNCTION__, (unsigned int)*res);
2076         return 0;
2077 }
2078
2079 static int decode_attr_aclsupport(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
2080 {
2081         uint32_t *p;
2082
2083         *res = ACL4_SUPPORT_ALLOW_ACL|ACL4_SUPPORT_DENY_ACL;
2084         if (unlikely(bitmap[0] & (FATTR4_WORD0_ACLSUPPORT - 1U)))
2085                 return -EIO;
2086         if (likely(bitmap[0] & FATTR4_WORD0_ACLSUPPORT)) {
2087                 READ_BUF(4);
2088                 READ32(*res);
2089                 bitmap[0] &= ~FATTR4_WORD0_ACLSUPPORT;
2090         }
2091         dprintk("%s: ACLs supported=%u\n", __FUNCTION__, (unsigned int)*res);
2092         return 0;
2093 }
2094
2095 static int decode_attr_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *fileid)
2096 {
2097         uint32_t *p;
2098
2099         *fileid = 0;
2100         if (unlikely(bitmap[0] & (FATTR4_WORD0_FILEID - 1U)))
2101                 return -EIO;
2102         if (likely(bitmap[0] & FATTR4_WORD0_FILEID)) {
2103                 READ_BUF(8);
2104                 READ64(*fileid);
2105                 bitmap[0] &= ~FATTR4_WORD0_FILEID;
2106         }
2107         dprintk("%s: fileid=%Lu\n", __FUNCTION__, (unsigned long long)*fileid);
2108         return 0;
2109 }
2110
2111 static int decode_attr_files_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
2112 {
2113         uint32_t *p;
2114         int status = 0;
2115
2116         *res = 0;
2117         if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_AVAIL - 1U)))
2118                 return -EIO;
2119         if (likely(bitmap[0] & FATTR4_WORD0_FILES_AVAIL)) {
2120                 READ_BUF(8);
2121                 READ64(*res);
2122                 bitmap[0] &= ~FATTR4_WORD0_FILES_AVAIL;
2123         }
2124         dprintk("%s: files avail=%Lu\n", __FUNCTION__, (unsigned long long)*res);
2125         return status;
2126 }
2127
2128 static int decode_attr_files_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
2129 {
2130         uint32_t *p;
2131         int status = 0;
2132
2133         *res = 0;
2134         if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_FREE - 1U)))
2135                 return -EIO;
2136         if (likely(bitmap[0] & FATTR4_WORD0_FILES_FREE)) {
2137                 READ_BUF(8);
2138                 READ64(*res);
2139                 bitmap[0] &= ~FATTR4_WORD0_FILES_FREE;
2140         }
2141         dprintk("%s: files free=%Lu\n", __FUNCTION__, (unsigned long long)*res);
2142         return status;
2143 }
2144
2145 static int decode_attr_files_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
2146 {
2147         uint32_t *p;
2148         int status = 0;
2149
2150         *res = 0;
2151         if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_TOTAL - 1U)))
2152                 return -EIO;
2153         if (likely(bitmap[0] & FATTR4_WORD0_FILES_TOTAL)) {
2154                 READ_BUF(8);
2155                 READ64(*res);
2156                 bitmap[0] &= ~FATTR4_WORD0_FILES_TOTAL;
2157         }
2158         dprintk("%s: files total=%Lu\n", __FUNCTION__, (unsigned long long)*res);
2159         return status;
2160 }
2161
2162 static int decode_attr_maxfilesize(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
2163 {
2164         uint32_t *p;
2165         int status = 0;
2166
2167         *res = 0;
2168         if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXFILESIZE - 1U)))
2169                 return -EIO;
2170         if (likely(bitmap[0] & FATTR4_WORD0_MAXFILESIZE)) {
2171                 READ_BUF(8);
2172                 READ64(*res);
2173                 bitmap[0] &= ~FATTR4_WORD0_MAXFILESIZE;
2174         }
2175         dprintk("%s: maxfilesize=%Lu\n", __FUNCTION__, (unsigned long long)*res);
2176         return status;
2177 }
2178
2179 static int decode_attr_maxlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *maxlink)
2180 {
2181         uint32_t *p;
2182         int status = 0;
2183
2184         *maxlink = 1;
2185         if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXLINK - 1U)))
2186                 return -EIO;
2187         if (likely(bitmap[0] & FATTR4_WORD0_MAXLINK)) {
2188                 READ_BUF(4);
2189                 READ32(*maxlink);
2190                 bitmap[0] &= ~FATTR4_WORD0_MAXLINK;
2191         }
2192         dprintk("%s: maxlink=%u\n", __FUNCTION__, *maxlink);
2193         return status;
2194 }
2195
2196 static int decode_attr_maxname(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *maxname)
2197 {
2198         uint32_t *p;
2199         int status = 0;
2200
2201         *maxname = 1024;
2202         if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXNAME - 1U)))
2203                 return -EIO;
2204         if (likely(bitmap[0] & FATTR4_WORD0_MAXNAME)) {
2205                 READ_BUF(4);
2206                 READ32(*maxname);
2207                 bitmap[0] &= ~FATTR4_WORD0_MAXNAME;
2208         }
2209         dprintk("%s: maxname=%u\n", __FUNCTION__, *maxname);
2210         return status;
2211 }
2212
2213 static int decode_attr_maxread(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
2214 {
2215         uint32_t *p;
2216         int status = 0;
2217
2218         *res = 1024;
2219         if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXREAD - 1U)))
2220                 return -EIO;
2221         if (likely(bitmap[0] & FATTR4_WORD0_MAXREAD)) {
2222                 uint64_t maxread;
2223                 READ_BUF(8);
2224                 READ64(maxread);
2225                 if (maxread > 0x7FFFFFFF)
2226                         maxread = 0x7FFFFFFF;
2227                 *res = (uint32_t)maxread;
2228                 bitmap[0] &= ~FATTR4_WORD0_MAXREAD;
2229         }
2230         dprintk("%s: maxread=%lu\n", __FUNCTION__, (unsigned long)*res);
2231         return status;
2232 }
2233
2234 static int decode_attr_maxwrite(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
2235 {
2236         uint32_t *p;
2237         int status = 0;
2238
2239         *res = 1024;
2240         if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXWRITE - 1U)))
2241                 return -EIO;
2242         if (likely(bitmap[0] & FATTR4_WORD0_MAXWRITE)) {
2243                 uint64_t maxwrite;
2244                 READ_BUF(8);
2245                 READ64(maxwrite);
2246                 if (maxwrite > 0x7FFFFFFF)
2247                         maxwrite = 0x7FFFFFFF;
2248                 *res = (uint32_t)maxwrite;
2249                 bitmap[0] &= ~FATTR4_WORD0_MAXWRITE;
2250         }
2251         dprintk("%s: maxwrite=%lu\n", __FUNCTION__, (unsigned long)*res);
2252         return status;
2253 }
2254
2255 static int decode_attr_mode(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *mode)
2256 {
2257         uint32_t *p;
2258
2259         *mode = 0;
2260         if (unlikely(bitmap[1] & (FATTR4_WORD1_MODE - 1U)))
2261                 return -EIO;
2262         if (likely(bitmap[1] & FATTR4_WORD1_MODE)) {
2263                 READ_BUF(4);
2264                 READ32(*mode);
2265                 *mode &= ~S_IFMT;
2266                 bitmap[1] &= ~FATTR4_WORD1_MODE;
2267         }
2268         dprintk("%s: file mode=0%o\n", __FUNCTION__, (unsigned int)*mode);
2269         return 0;
2270 }
2271
2272 static int decode_attr_nlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *nlink)
2273 {
2274         uint32_t *p;
2275
2276         *nlink = 1;
2277         if (unlikely(bitmap[1] & (FATTR4_WORD1_NUMLINKS - 1U)))
2278                 return -EIO;
2279         if (likely(bitmap[1] & FATTR4_WORD1_NUMLINKS)) {
2280                 READ_BUF(4);
2281                 READ32(*nlink);
2282                 bitmap[1] &= ~FATTR4_WORD1_NUMLINKS;
2283         }
2284         dprintk("%s: nlink=%u\n", __FUNCTION__, (unsigned int)*nlink);
2285         return 0;
2286 }
2287
2288 static int decode_attr_owner(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs4_client *clp, int32_t *uid)
2289 {
2290         uint32_t len, *p;
2291
2292         *uid = -2;
2293         if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER - 1U)))
2294                 return -EIO;
2295         if (likely(bitmap[1] & FATTR4_WORD1_OWNER)) {
2296                 READ_BUF(4);
2297                 READ32(len);
2298                 READ_BUF(len);
2299                 if (len < XDR_MAX_NETOBJ) {
2300                         if (nfs_map_name_to_uid(clp, (char *)p, len, uid) != 0)
2301                                 dprintk("%s: nfs_map_name_to_uid failed!\n",
2302                                                 __FUNCTION__);
2303                 } else
2304                         printk(KERN_WARNING "%s: name too long (%u)!\n",
2305                                         __FUNCTION__, len);
2306                 bitmap[1] &= ~FATTR4_WORD1_OWNER;
2307         }
2308         dprintk("%s: uid=%d\n", __FUNCTION__, (int)*uid);
2309         return 0;
2310 }
2311
2312 static int decode_attr_group(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs4_client *clp, int32_t *gid)
2313 {
2314         uint32_t len, *p;
2315
2316         *gid = -2;
2317         if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER_GROUP - 1U)))
2318                 return -EIO;
2319         if (likely(bitmap[1] & FATTR4_WORD1_OWNER_GROUP)) {
2320                 READ_BUF(4);
2321                 READ32(len);
2322                 READ_BUF(len);
2323                 if (len < XDR_MAX_NETOBJ) {
2324                         if (nfs_map_group_to_gid(clp, (char *)p, len, gid) != 0)
2325                                 dprintk("%s: nfs_map_group_to_gid failed!\n",
2326                                                 __FUNCTION__);
2327                 } else
2328                         printk(KERN_WARNING "%s: name too long (%u)!\n",
2329                                         __FUNCTION__, len);
2330                 bitmap[1] &= ~FATTR4_WORD1_OWNER_GROUP;
2331         }
2332         dprintk("%s: gid=%d\n", __FUNCTION__, (int)*gid);
2333         return 0;
2334 }
2335
2336 static int decode_attr_rdev(struct xdr_stream *xdr, uint32_t *bitmap, dev_t *rdev)
2337 {
2338         uint32_t major = 0, minor = 0, *p;
2339
2340         *rdev = MKDEV(0,0);
2341         if (unlikely(bitmap[1] & (FATTR4_WORD1_RAWDEV - 1U)))
2342                 return -EIO;
2343         if (likely(bitmap[1] & FATTR4_WORD1_RAWDEV)) {
2344                 dev_t tmp;
2345
2346                 READ_BUF(8);
2347                 READ32(major);
2348                 READ32(minor);
2349                 tmp = MKDEV(major, minor);
2350                 if (MAJOR(tmp) == major && MINOR(tmp) == minor)
2351                         *rdev = tmp;
2352                 bitmap[1] &= ~ FATTR4_WORD1_RAWDEV;
2353         }
2354         dprintk("%s: rdev=(0x%x:0x%x)\n", __FUNCTION__, major, minor);
2355         return 0;
2356 }
2357
2358 static int decode_attr_space_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
2359 {
2360         uint32_t *p;
2361         int status = 0;
2362
2363         *res = 0;
2364         if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_AVAIL - 1U)))
2365                 return -EIO;
2366         if (likely(bitmap[1] & FATTR4_WORD1_SPACE_AVAIL)) {
2367                 READ_BUF(8);
2368                 READ64(*res);
2369                 bitmap[1] &= ~FATTR4_WORD1_SPACE_AVAIL;
2370         }
2371         dprintk("%s: space avail=%Lu\n", __FUNCTION__, (unsigned long long)*res);
2372         return status;
2373 }
2374
2375 static int decode_attr_space_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
2376 {
2377         uint32_t *p;
2378         int status = 0;
2379
2380         *res = 0;
2381         if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_FREE - 1U)))
2382                 return -EIO;
2383         if (likely(bitmap[1] & FATTR4_WORD1_SPACE_FREE)) {
2384                 READ_BUF(8);
2385                 READ64(*res);
2386                 bitmap[1] &= ~FATTR4_WORD1_SPACE_FREE;
2387         }
2388         dprintk("%s: space free=%Lu\n", __FUNCTION__, (unsigned long long)*res);
2389         return status;
2390 }
2391
2392 static int decode_attr_space_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
2393 {
2394         uint32_t *p;
2395         int status = 0;
2396
2397         *res = 0;
2398         if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_TOTAL - 1U)))
2399                 return -EIO;
2400         if (likely(bitmap[1] & FATTR4_WORD1_SPACE_TOTAL)) {
2401                 READ_BUF(8);
2402                 READ64(*res);
2403                 bitmap[1] &= ~FATTR4_WORD1_SPACE_TOTAL;
2404         }
2405         dprintk("%s: space total=%Lu\n", __FUNCTION__, (unsigned long long)*res);
2406         return status;
2407 }
2408
2409 static int decode_attr_space_used(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *used)
2410 {
2411         uint32_t *p;
2412
2413         *used = 0;
2414         if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_USED - 1U)))
2415                 return -EIO;
2416         if (likely(bitmap[1] & FATTR4_WORD1_SPACE_USED)) {
2417                 READ_BUF(8);
2418                 READ64(*used);
2419                 bitmap[1] &= ~FATTR4_WORD1_SPACE_USED;
2420         }
2421         dprintk("%s: space used=%Lu\n", __FUNCTION__,
2422                         (unsigned long long)*used);
2423         return 0;
2424 }
2425
2426 static int decode_attr_time(struct xdr_stream *xdr, struct timespec *time)
2427 {
2428         uint32_t *p;
2429         uint64_t sec;
2430         uint32_t nsec;
2431
2432         READ_BUF(12);
2433         READ64(sec);
2434         READ32(nsec);
2435         time->tv_sec = (time_t)sec;
2436         time->tv_nsec = (long)nsec;
2437         return 0;
2438 }
2439
2440 static int decode_attr_time_access(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
2441 {
2442         int status = 0;
2443
2444         time->tv_sec = 0;
2445         time->tv_nsec = 0;
2446         if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_ACCESS - 1U)))
2447                 return -EIO;
2448         if (likely(bitmap[1] & FATTR4_WORD1_TIME_ACCESS)) {
2449                 status = decode_attr_time(xdr, time);
2450                 bitmap[1] &= ~FATTR4_WORD1_TIME_ACCESS;
2451         }
2452         dprintk("%s: atime=%ld\n", __FUNCTION__, (long)time->tv_sec);
2453         return status;
2454 }
2455
2456 static int decode_attr_time_metadata(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
2457 {
2458         int status = 0;
2459
2460         time->tv_sec = 0;
2461         time->tv_nsec = 0;
2462         if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_METADATA - 1U)))
2463                 return -EIO;
2464         if (likely(bitmap[1] & FATTR4_WORD1_TIME_METADATA)) {
2465                 status = decode_attr_time(xdr, time);
2466                 bitmap[1] &= ~FATTR4_WORD1_TIME_METADATA;
2467         }
2468         dprintk("%s: ctime=%ld\n", __FUNCTION__, (long)time->tv_sec);
2469         return status;
2470 }
2471
2472 static int decode_attr_time_modify(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
2473 {
2474         int status = 0;
2475
2476         time->tv_sec = 0;
2477         time->tv_nsec = 0;
2478         if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_MODIFY - 1U)))
2479                 return -EIO;
2480         if (likely(bitmap[1] & FATTR4_WORD1_TIME_MODIFY)) {
2481                 status = decode_attr_time(xdr, time);
2482                 bitmap[1] &= ~FATTR4_WORD1_TIME_MODIFY;
2483         }
2484         dprintk("%s: mtime=%ld\n", __FUNCTION__, (long)time->tv_sec);
2485         return status;
2486 }
2487
2488 static int verify_attr_len(struct xdr_stream *xdr, uint32_t *savep, uint32_t attrlen)
2489 {
2490         unsigned int attrwords = XDR_QUADLEN(attrlen);
2491         unsigned int nwords = xdr->p - savep;
2492
2493         if (unlikely(attrwords != nwords)) {
2494                 printk(KERN_WARNING "%s: server returned incorrect attribute length: %u %c %u\n",
2495                                 __FUNCTION__,
2496                                 attrwords << 2,
2497                                 (attrwords < nwords) ? '<' : '>',
2498                                 nwords << 2);
2499                 return -EIO;
2500         }
2501         return 0;
2502 }
2503
2504 static int decode_change_info(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
2505 {
2506         uint32_t *p;
2507
2508         READ_BUF(20);
2509         READ32(cinfo->atomic);
2510         READ64(cinfo->before);
2511         READ64(cinfo->after);
2512         return 0;
2513 }
2514
2515 static int decode_access(struct xdr_stream *xdr, struct nfs4_accessres *access)
2516 {
2517         uint32_t *p;
2518         uint32_t supp, acc;
2519         int status;
2520
2521         status = decode_op_hdr(xdr, OP_ACCESS);
2522         if (status)
2523                 return status;
2524         READ_BUF(8);
2525         READ32(supp);
2526         READ32(acc);
2527         access->supported = supp;
2528         access->access = acc;
2529         return 0;
2530 }
2531
2532 static int decode_close(struct xdr_stream *xdr, struct nfs_closeres *res)
2533 {
2534         uint32_t *p;
2535         int status;
2536
2537         status = decode_op_hdr(xdr, OP_CLOSE);
2538         if (status)
2539                 return status;
2540         READ_BUF(sizeof(res->stateid.data));
2541         COPYMEM(res->stateid.data, sizeof(res->stateid.data));
2542         return 0;
2543 }
2544
2545 static int decode_commit(struct xdr_stream *xdr, struct nfs_writeres *res)
2546 {
2547         uint32_t *p;
2548         int status;
2549
2550         status = decode_op_hdr(xdr, OP_COMMIT);
2551         if (status)
2552                 return status;
2553         READ_BUF(8);
2554         COPYMEM(res->verf->verifier, 8);
2555         return 0;
2556 }
2557
2558 static int decode_create(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
2559 {
2560         uint32_t *p;
2561         uint32_t bmlen;
2562         int status;
2563
2564         status = decode_op_hdr(xdr, OP_CREATE);
2565         if (status)
2566                 return status;
2567         if ((status = decode_change_info(xdr, cinfo)))
2568                 return status;
2569         READ_BUF(4);
2570         READ32(bmlen);
2571         READ_BUF(bmlen << 2);
2572         return 0;
2573 }
2574
2575 static int decode_server_caps(struct xdr_stream *xdr, struct nfs4_server_caps_res *res)
2576 {
2577         uint32_t *savep;
2578         uint32_t attrlen, 
2579                  bitmap[2] = {0};
2580         int status;
2581
2582         if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
2583                 goto xdr_error;
2584         if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
2585                 goto xdr_error;
2586         if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
2587                 goto xdr_error;
2588         if ((status = decode_attr_supported(xdr, bitmap, res->attr_bitmask)) != 0)
2589                 goto xdr_error;
2590         if ((status = decode_attr_link_support(xdr, bitmap, &res->has_links)) != 0)
2591                 goto xdr_error;
2592         if ((status = decode_attr_symlink_support(xdr, bitmap, &res->has_symlinks)) != 0)
2593                 goto xdr_error;
2594         if ((status = decode_attr_aclsupport(xdr, bitmap, &res->acl_bitmask)) != 0)
2595                 goto xdr_error;
2596         status = verify_attr_len(xdr, savep, attrlen);
2597 xdr_error:
2598         if (status != 0)
2599                 printk(KERN_NOTICE "%s: xdr error %d!\n", __FUNCTION__, -status);
2600         return status;
2601 }
2602         
2603 static int decode_statfs(struct xdr_stream *xdr, struct nfs_fsstat *fsstat)
2604 {
2605         uint32_t *savep;
2606         uint32_t attrlen, 
2607                  bitmap[2] = {0};
2608         int status;
2609         
2610         if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
2611                 goto xdr_error;
2612         if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
2613                 goto xdr_error;
2614         if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
2615                 goto xdr_error;
2616
2617         if ((status = decode_attr_files_avail(xdr, bitmap, &fsstat->afiles)) != 0)
2618                 goto xdr_error;
2619         if ((status = decode_attr_files_free(xdr, bitmap, &fsstat->ffiles)) != 0)
2620                 goto xdr_error;
2621         if ((status = decode_attr_files_total(xdr, bitmap, &fsstat->tfiles)) != 0)
2622                 goto xdr_error;
2623         if ((status = decode_attr_space_avail(xdr, bitmap, &fsstat->abytes)) != 0)
2624                 goto xdr_error;
2625         if ((status = decode_attr_space_free(xdr, bitmap, &fsstat->fbytes)) != 0)
2626                 goto xdr_error;
2627         if ((status = decode_attr_space_total(xdr, bitmap, &fsstat->tbytes)) != 0)
2628                 goto xdr_error;
2629
2630         status = verify_attr_len(xdr, savep, attrlen);
2631 xdr_error:
2632         if (status != 0)
2633                 printk(KERN_NOTICE "%s: xdr error %d!\n", __FUNCTION__, -status);
2634         return status;
2635 }
2636
2637 static int decode_pathconf(struct xdr_stream *xdr, struct nfs_pathconf *pathconf)
2638 {
2639         uint32_t *savep;
2640         uint32_t attrlen, 
2641                  bitmap[2] = {0};
2642         int status;
2643         
2644         if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
2645                 goto xdr_error;
2646         if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
2647                 goto xdr_error;
2648         if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
2649                 goto xdr_error;
2650
2651         if ((status = decode_attr_maxlink(xdr, bitmap, &pathconf->max_link)) != 0)
2652                 goto xdr_error;
2653         if ((status = decode_attr_maxname(xdr, bitmap, &pathconf->max_namelen)) != 0)
2654                 goto xdr_error;
2655
2656         status = verify_attr_len(xdr, savep, attrlen);
2657 xdr_error:
2658         if (status != 0)
2659                 printk(KERN_NOTICE "%s: xdr error %d!\n", __FUNCTION__, -status);
2660         return status;
2661 }
2662
2663 static int decode_getfattr(struct xdr_stream *xdr, struct nfs_fattr *fattr, const struct nfs_server *server)
2664 {
2665         uint32_t *savep;
2666         uint32_t attrlen,
2667                  bitmap[2] = {0},
2668                  type;
2669         int status, fmode = 0;
2670
2671         if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
2672                 goto xdr_error;
2673         if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
2674                 goto xdr_error;
2675
2676         fattr->bitmap[0] = bitmap[0];
2677         fattr->bitmap[1] = bitmap[1];
2678
2679         if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
2680                 goto xdr_error;
2681
2682
2683         if ((status = decode_attr_type(xdr, bitmap, &type)) != 0)
2684                 goto xdr_error;
2685         fattr->type = nfs_type2fmt[type].nfs2type;
2686         fmode = nfs_type2fmt[type].mode;
2687
2688         if ((status = decode_attr_change(xdr, bitmap, &fattr->change_attr)) != 0)
2689                 goto xdr_error;
2690         if ((status = decode_attr_size(xdr, bitmap, &fattr->size)) != 0)
2691                 goto xdr_error;
2692         if ((status = decode_attr_fsid(xdr, bitmap, &fattr->fsid_u.nfs4)) != 0)
2693                 goto xdr_error;
2694         if ((status = decode_attr_fileid(xdr, bitmap, &fattr->fileid)) != 0)
2695                 goto xdr_error;
2696         if ((status = decode_attr_mode(xdr, bitmap, &fattr->mode)) != 0)
2697                 goto xdr_error;
2698         fattr->mode |= fmode;
2699         if ((status = decode_attr_nlink(xdr, bitmap, &fattr->nlink)) != 0)
2700                 goto xdr_error;
2701         if ((status = decode_attr_owner(xdr, bitmap, server->nfs4_state, &fattr->uid)) != 0)
2702                 goto xdr_error;
2703         if ((status = decode_attr_group(xdr, bitmap, server->nfs4_state, &fattr->gid)) != 0)
2704                 goto xdr_error;
2705         if ((status = decode_attr_rdev(xdr, bitmap, &fattr->rdev)) != 0)
2706                 goto xdr_error;
2707         if ((status = decode_attr_space_used(xdr, bitmap, &fattr->du.nfs3.used)) != 0)
2708                 goto xdr_error;
2709         if ((status = decode_attr_time_access(xdr, bitmap, &fattr->atime)) != 0)
2710                 goto xdr_error;
2711         if ((status = decode_attr_time_metadata(xdr, bitmap, &fattr->ctime)) != 0)
2712                 goto xdr_error;
2713         if ((status = decode_attr_time_modify(xdr, bitmap, &fattr->mtime)) != 0)
2714                 goto xdr_error;
2715         if ((status = verify_attr_len(xdr, savep, attrlen)) == 0) {
2716                 fattr->valid = NFS_ATTR_FATTR | NFS_ATTR_FATTR_V3 | NFS_ATTR_FATTR_V4;
2717                 fattr->timestamp = jiffies;
2718         }
2719 xdr_error:
2720         if (status != 0)
2721                 printk(KERN_NOTICE "%s: xdr error %d!\n", __FUNCTION__, -status);
2722         return status;
2723 }
2724
2725
2726 static int decode_fsinfo(struct xdr_stream *xdr, struct nfs_fsinfo *fsinfo)
2727 {
2728         uint32_t *savep;
2729         uint32_t attrlen, bitmap[2];
2730         int status;
2731
2732         if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
2733                 goto xdr_error;
2734         if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
2735                 goto xdr_error;
2736         if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
2737                 goto xdr_error;
2738
2739         fsinfo->rtmult = fsinfo->wtmult = 512;  /* ??? */
2740
2741         if ((status = decode_attr_lease_time(xdr, bitmap, &fsinfo->lease_time)) != 0)
2742                 goto xdr_error;
2743         if ((status = decode_attr_maxfilesize(xdr, bitmap, &fsinfo->maxfilesize)) != 0)
2744                 goto xdr_error;
2745         if ((status = decode_attr_maxread(xdr, bitmap, &fsinfo->rtmax)) != 0)
2746                 goto xdr_error;
2747         fsinfo->rtpref = fsinfo->dtpref = fsinfo->rtmax;
2748         if ((status = decode_attr_maxwrite(xdr, bitmap, &fsinfo->wtmax)) != 0)
2749                 goto xdr_error;
2750         fsinfo->wtpref = fsinfo->wtmax;
2751
2752         status = verify_attr_len(xdr, savep, attrlen);
2753 xdr_error:
2754         if (status != 0)
2755                 printk(KERN_NOTICE "%s: xdr error %d!\n", __FUNCTION__, -status);
2756         return status;
2757 }
2758
2759 static int decode_getfh(struct xdr_stream *xdr, struct nfs_fh *fh)
2760 {
2761         uint32_t *p;
2762         uint32_t len;
2763         int status;
2764
2765         status = decode_op_hdr(xdr, OP_GETFH);
2766         if (status)
2767                 return status;
2768         /* Zero handle first to allow comparisons */
2769         memset(fh, 0, sizeof(*fh));
2770
2771         READ_BUF(4);
2772         READ32(len);
2773         if (len > NFS4_FHSIZE)
2774                 return -EIO;
2775         fh->size = len;
2776         READ_BUF(len);
2777         COPYMEM(fh->data, len);
2778         return 0;
2779 }
2780
2781 static int decode_link(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
2782 {
2783         int status;
2784         
2785         status = decode_op_hdr(xdr, OP_LINK);
2786         if (status)
2787                 return status;
2788         return decode_change_info(xdr, cinfo);
2789 }
2790
2791 /*
2792  * We create the owner, so we know a proper owner.id length is 4.
2793  */
2794 static int decode_lock_denied (struct xdr_stream *xdr, struct nfs_lock_denied *denied)
2795 {
2796         uint32_t *p;
2797         uint32_t namelen;
2798
2799         READ_BUF(32);
2800         READ64(denied->offset);
2801         READ64(denied->length);
2802         READ32(denied->type);
2803         READ64(denied->owner.clientid);
2804         READ32(namelen);
2805         READ_BUF(namelen);
2806         if (namelen == 4)
2807                 READ32(denied->owner.id);
2808         return -NFS4ERR_DENIED;
2809 }
2810
2811 static int decode_lock(struct xdr_stream *xdr, struct nfs_lockres *res)
2812 {
2813         uint32_t *p;
2814         int status;
2815
2816         status = decode_op_hdr(xdr, OP_LOCK);
2817         if (status == 0) {
2818                 READ_BUF(sizeof(nfs4_stateid));
2819                 COPYMEM(&res->u.stateid, sizeof(res->u.stateid));
2820         } else if (status == -NFS4ERR_DENIED)
2821                 return decode_lock_denied(xdr, &res->u.denied);
2822         return status;
2823 }
2824
2825 static int decode_lockt(struct xdr_stream *xdr, struct nfs_lockres *res)
2826 {
2827         int status;
2828         status = decode_op_hdr(xdr, OP_LOCKT);
2829         if (status == -NFS4ERR_DENIED)
2830                 return decode_lock_denied(xdr, &res->u.denied);
2831         return status;
2832 }
2833
2834 static int decode_locku(struct xdr_stream *xdr, struct nfs_lockres *res)
2835 {
2836         uint32_t *p;
2837         int status;
2838
2839         status = decode_op_hdr(xdr, OP_LOCKU);
2840         if (status == 0) {
2841                 READ_BUF(sizeof(nfs4_stateid));
2842                 COPYMEM(&res->u.stateid, sizeof(res->u.stateid));
2843         }
2844         return status;
2845 }
2846
2847 static int decode_lookup(struct xdr_stream *xdr)
2848 {
2849         return decode_op_hdr(xdr, OP_LOOKUP);
2850 }
2851
2852 /* This is too sick! */
2853 static int decode_space_limit(struct xdr_stream *xdr, u64 *maxsize)
2854 {
2855         uint32_t *p;
2856         uint32_t limit_type, nblocks, blocksize;
2857
2858         READ_BUF(12);
2859         READ32(limit_type);
2860         switch (limit_type) {
2861                 case 1:
2862                         READ64(*maxsize);
2863                         break;
2864                 case 2:
2865                         READ32(nblocks);
2866                         READ32(blocksize);
2867                         *maxsize = (uint64_t)nblocks * (uint64_t)blocksize;
2868         }
2869         return 0;
2870 }
2871
2872 static int decode_delegation(struct xdr_stream *xdr, struct nfs_openres *res)
2873 {
2874         uint32_t *p;
2875         uint32_t delegation_type;
2876
2877         READ_BUF(4);
2878         READ32(delegation_type);
2879         if (delegation_type == NFS4_OPEN_DELEGATE_NONE) {
2880                 res->delegation_type = 0;
2881                 return 0;
2882         }
2883         READ_BUF(20);
2884         COPYMEM(res->delegation.data, sizeof(res->delegation.data));
2885         READ32(res->do_recall);
2886         switch (delegation_type) {
2887                 case NFS4_OPEN_DELEGATE_READ:
2888                         res->delegation_type = FMODE_READ;
2889                         break;
2890                 case NFS4_OPEN_DELEGATE_WRITE:
2891                         res->delegation_type = FMODE_WRITE|FMODE_READ;
2892                         if (decode_space_limit(xdr, &res->maxsize) < 0)
2893                                 return -EIO;
2894         }
2895         return decode_ace(xdr, NULL, res->server->nfs4_state);
2896 }
2897
2898 static int decode_open(struct xdr_stream *xdr, struct nfs_openres *res)
2899 {
2900         uint32_t *p;
2901         uint32_t bmlen;
2902         int status;
2903
2904         status = decode_op_hdr(xdr, OP_OPEN);
2905         if (status)
2906                 return status;
2907         READ_BUF(sizeof(res->stateid.data));
2908         COPYMEM(res->stateid.data, sizeof(res->stateid.data));
2909
2910         decode_change_info(xdr, &res->cinfo);
2911
2912         READ_BUF(8);
2913         READ32(res->rflags);
2914         READ32(bmlen);
2915         if (bmlen > 10)
2916                 goto xdr_error;
2917
2918         READ_BUF(bmlen << 2);
2919         p += bmlen;
2920         return decode_delegation(xdr, res);
2921 xdr_error:
2922         printk(KERN_NOTICE "%s: xdr error!\n", __FUNCTION__);
2923         return -EIO;
2924 }
2925
2926 static int decode_open_confirm(struct xdr_stream *xdr, struct nfs_open_confirmres *res)
2927 {
2928         uint32_t *p;
2929         int status;
2930
2931         status = decode_op_hdr(xdr, OP_OPEN_CONFIRM);
2932         if (status)
2933                 return status;
2934         READ_BUF(sizeof(res->stateid.data));
2935         COPYMEM(res->stateid.data, sizeof(res->stateid.data));
2936         return 0;
2937 }
2938
2939 static int decode_open_downgrade(struct xdr_stream *xdr, struct nfs_closeres *res)
2940 {
2941         uint32_t *p;
2942         int status;
2943
2944         status = decode_op_hdr(xdr, OP_OPEN_DOWNGRADE);
2945         if (status)
2946                 return status;
2947         READ_BUF(sizeof(res->stateid.data));
2948         COPYMEM(res->stateid.data, sizeof(res->stateid.data));
2949         return 0;
2950 }
2951
2952 static int decode_putfh(struct xdr_stream *xdr)
2953 {
2954         return decode_op_hdr(xdr, OP_PUTFH);
2955 }
2956
2957 static int decode_putrootfh(struct xdr_stream *xdr)
2958 {
2959         return decode_op_hdr(xdr, OP_PUTROOTFH);
2960 }
2961
2962 static int decode_read(struct xdr_stream *xdr, struct rpc_rqst *req, struct nfs_readres *res)
2963 {
2964         struct kvec *iov = req->rq_rcv_buf.head;
2965         uint32_t *p;
2966         uint32_t count, eof, recvd, hdrlen;
2967         int status;
2968
2969         status = decode_op_hdr(xdr, OP_READ);
2970         if (status)
2971                 return status;
2972         READ_BUF(8);
2973         READ32(eof);
2974         READ32(count);
2975         hdrlen = (u8 *) p - (u8 *) iov->iov_base;
2976         recvd = req->rq_rcv_buf.len - hdrlen;
2977         if (count > recvd) {
2978                 printk(KERN_WARNING "NFS: server cheating in read reply: "
2979                                 "count %u > recvd %u\n", count, recvd);
2980                 count = recvd;
2981                 eof = 0;
2982         }
2983         xdr_read_pages(xdr, count);
2984         res->eof = eof;
2985         res->count = count;
2986         return 0;
2987 }
2988
2989 static int decode_readdir(struct xdr_stream *xdr, struct rpc_rqst *req, struct nfs4_readdir_res *readdir)
2990 {
2991         struct xdr_buf  *rcvbuf = &req->rq_rcv_buf;
2992         struct page     *page = *rcvbuf->pages;
2993         struct kvec     *iov = rcvbuf->head;
2994         unsigned int    nr, pglen = rcvbuf->page_len;
2995         uint32_t        *end, *entry, *p, *kaddr;
2996         uint32_t        len, attrlen;
2997         int             hdrlen, recvd, status;
2998
2999         status = decode_op_hdr(xdr, OP_READDIR);
3000         if (status)
3001                 return status;
3002         READ_BUF(8);
3003         COPYMEM(readdir->verifier.data, 8);
3004
3005         hdrlen = (char *) p - (char *) iov->iov_base;
3006         recvd = rcvbuf->len - hdrlen;
3007         if (pglen > recvd)
3008                 pglen = recvd;
3009         xdr_read_pages(xdr, pglen);
3010
3011         BUG_ON(pglen + readdir->pgbase > PAGE_CACHE_SIZE);
3012         kaddr = p = (uint32_t *) kmap_atomic(page, KM_USER0);
3013         end = (uint32_t *) ((char *)p + pglen + readdir->pgbase);
3014         entry = p;
3015         for (nr = 0; *p++; nr++) {
3016                 if (p + 3 > end)
3017                         goto short_pkt;
3018                 p += 2;                 /* cookie */
3019                 len = ntohl(*p++);      /* filename length */
3020                 if (len > NFS4_MAXNAMLEN) {
3021                         printk(KERN_WARNING "NFS: giant filename in readdir (len 0x%x)\n", len);
3022                         goto err_unmap;
3023                 }
3024                 p += XDR_QUADLEN(len);
3025                 if (p + 1 > end)
3026                         goto short_pkt;
3027                 len = ntohl(*p++);      /* bitmap length */
3028                 p += len;
3029                 if (p + 1 > end)
3030                         goto short_pkt;
3031                 attrlen = XDR_QUADLEN(ntohl(*p++));
3032                 p += attrlen;           /* attributes */
3033                 if (p + 2 > end)
3034                         goto short_pkt;
3035                 entry = p;
3036         }
3037         if (!nr && (entry[0] != 0 || entry[1] == 0))
3038                 goto short_pkt;
3039 out:    
3040         kunmap_atomic(kaddr, KM_USER0);
3041         return 0;
3042 short_pkt:
3043         entry[0] = entry[1] = 0;
3044         /* truncate listing ? */
3045         if (!nr) {
3046                 printk(KERN_NOTICE "NFS: readdir reply truncated!\n");
3047                 entry[1] = 1;
3048         }
3049         goto out;
3050 err_unmap:
3051         kunmap_atomic(kaddr, KM_USER0);
3052         return -errno_NFSERR_IO;
3053 }
3054
3055 static int decode_readlink(struct xdr_stream *xdr, struct rpc_rqst *req)
3056 {
3057         struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
3058         struct kvec *iov = rcvbuf->head;
3059         int hdrlen, len, recvd;
3060         uint32_t *p;
3061         char *kaddr;
3062         int status;
3063
3064         status = decode_op_hdr(xdr, OP_READLINK);
3065         if (status)
3066                 return status;
3067
3068         /* Convert length of symlink */
3069         READ_BUF(4);
3070         READ32(len);
3071         if (len >= rcvbuf->page_len || len <= 0) {
3072                 dprintk(KERN_WARNING "nfs: server returned giant symlink!\n");
3073                 return -ENAMETOOLONG;
3074         }
3075         hdrlen = (char *) xdr->p - (char *) iov->iov_base;
3076         recvd = req->rq_rcv_buf.len - hdrlen;
3077         if (recvd < len) {
3078                 printk(KERN_WARNING "NFS: server cheating in readlink reply: "
3079                                 "count %u > recvd %u\n", len, recvd);
3080                 return -EIO;
3081         }
3082         xdr_read_pages(xdr, len);
3083         /*
3084          * The XDR encode routine has set things up so that
3085          * the link text will be copied directly into the
3086          * buffer.  We just have to do overflow-checking,
3087          * and and null-terminate the text (the VFS expects
3088          * null-termination).
3089          */
3090         kaddr = (char *)kmap_atomic(rcvbuf->pages[0], KM_USER0);
3091         kaddr[len+rcvbuf->page_base] = '\0';
3092         kunmap_atomic(kaddr, KM_USER0);
3093         return 0;
3094 }
3095
3096 static int decode_remove(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
3097 {
3098         int status;
3099
3100         status = decode_op_hdr(xdr, OP_REMOVE);
3101         if (status)
3102                 goto out;
3103         status = decode_change_info(xdr, cinfo);
3104 out:
3105         return status;
3106 }
3107
3108 static int decode_rename(struct xdr_stream *xdr, struct nfs4_change_info *old_cinfo,
3109               struct nfs4_change_info *new_cinfo)
3110 {
3111         int status;
3112
3113         status = decode_op_hdr(xdr, OP_RENAME);
3114         if (status)
3115                 goto out;
3116         if ((status = decode_change_info(xdr, old_cinfo)))
3117                 goto out;
3118         status = decode_change_info(xdr, new_cinfo);
3119 out:
3120         return status;
3121 }
3122
3123 static int decode_renew(struct xdr_stream *xdr)
3124 {
3125         return decode_op_hdr(xdr, OP_RENEW);
3126 }
3127
3128 static int
3129 decode_savefh(struct xdr_stream *xdr)
3130 {
3131         return decode_op_hdr(xdr, OP_SAVEFH);
3132 }
3133
3134 static int decode_setattr(struct xdr_stream *xdr, struct nfs_setattrres *res)
3135 {
3136         uint32_t *p;
3137         uint32_t bmlen;
3138         int status;
3139
3140         
3141         status = decode_op_hdr(xdr, OP_SETATTR);
3142         if (status)
3143                 return status;
3144         READ_BUF(4);
3145         READ32(bmlen);
3146         READ_BUF(bmlen << 2);
3147         return 0;
3148 }
3149
3150 static int decode_setclientid(struct xdr_stream *xdr, struct nfs4_client *clp)
3151 {
3152         uint32_t *p;
3153         uint32_t opnum;
3154         int32_t nfserr;
3155
3156         READ_BUF(8);
3157         READ32(opnum);
3158         if (opnum != OP_SETCLIENTID) {
3159                 printk(KERN_NOTICE
3160                                 "nfs4_decode_setclientid: Server returned operation"
3161                                 " %d\n", opnum);
3162                 return -EIO;
3163         }
3164         READ32(nfserr);
3165         if (nfserr == NFS_OK) {
3166                 READ_BUF(8 + sizeof(clp->cl_confirm.data));
3167                 READ64(clp->cl_clientid);
3168                 COPYMEM(clp->cl_confirm.data, sizeof(clp->cl_confirm.data));
3169         } else if (nfserr == NFSERR_CLID_INUSE) {
3170                 uint32_t len;
3171
3172                 /* skip netid string */
3173                 READ_BUF(4);
3174                 READ32(len);
3175                 READ_BUF(len);
3176
3177                 /* skip uaddr string */
3178                 READ_BUF(4);
3179                 READ32(len);
3180                 READ_BUF(len);
3181                 return -NFSERR_CLID_INUSE;
3182         } else
3183                 return -nfs_stat_to_errno(nfserr);
3184
3185         return 0;
3186 }
3187
3188 static int decode_setclientid_confirm(struct xdr_stream *xdr)
3189 {
3190         return decode_op_hdr(xdr, OP_SETCLIENTID_CONFIRM);
3191 }
3192
3193 static int decode_write(struct xdr_stream *xdr, struct nfs_writeres *res)
3194 {
3195         uint32_t *p;
3196         int status;
3197
3198         status = decode_op_hdr(xdr, OP_WRITE);
3199         if (status)
3200                 return status;
3201
3202         READ_BUF(16);
3203         READ32(res->count);
3204         READ32(res->verf->committed);
3205         COPYMEM(res->verf->verifier, 8);
3206         return 0;
3207 }
3208
3209 static int decode_delegreturn(struct xdr_stream *xdr)
3210 {
3211         return decode_op_hdr(xdr, OP_DELEGRETURN);
3212 }
3213
3214 /*
3215  * Decode OPEN_DOWNGRADE response
3216  */
3217 static int nfs4_xdr_dec_open_downgrade(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_closeres *res)
3218 {
3219         struct xdr_stream xdr;
3220         struct compound_hdr hdr;
3221         int status;
3222
3223         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
3224         status = decode_compound_hdr(&xdr, &hdr);
3225         if (status)
3226                 goto out;
3227         status = decode_putfh(&xdr);
3228         if (status)
3229                 goto out;
3230         status = decode_open_downgrade(&xdr, res);
3231 out:
3232         return status;
3233 }
3234
3235 /*
3236  * END OF "GENERIC" DECODE ROUTINES.
3237  */
3238
3239 /*
3240  * Decode ACCESS response
3241  */
3242 static int nfs4_xdr_dec_access(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_accessres *res)
3243 {
3244         struct xdr_stream xdr;
3245         struct compound_hdr hdr;
3246         int status;
3247         
3248         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
3249         if ((status = decode_compound_hdr(&xdr, &hdr)) != 0)
3250                 goto out;
3251         if ((status = decode_putfh(&xdr)) == 0)
3252                 status = decode_access(&xdr, res);
3253 out:
3254         return status;
3255 }
3256
3257 /*
3258  * Decode LOOKUP response
3259  */
3260 static int nfs4_xdr_dec_lookup(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_lookup_res *res)
3261 {
3262         struct xdr_stream xdr;
3263         struct compound_hdr hdr;
3264         int status;
3265         
3266         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
3267         if ((status = decode_compound_hdr(&xdr, &hdr)) != 0)
3268                 goto out;
3269         if ((status = decode_putfh(&xdr)) != 0)
3270                 goto out;
3271         if ((status = decode_lookup(&xdr)) != 0)
3272                 goto out;
3273         if ((status = decode_getfh(&xdr, res->fh)) != 0)
3274                 goto out;
3275         status = decode_getfattr(&xdr, res->fattr, res->server);
3276 out:
3277         return status;
3278 }
3279
3280 /*
3281  * Decode LOOKUP_ROOT response
3282  */
3283 static int nfs4_xdr_dec_lookup_root(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_lookup_res *res)
3284 {
3285         struct xdr_stream xdr;
3286         struct compound_hdr hdr;
3287         int status;
3288         
3289         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
3290         if ((status = decode_compound_hdr(&xdr, &hdr)) != 0)
3291                 goto out;
3292         if ((status = decode_putrootfh(&xdr)) != 0)
3293                 goto out;
3294         if ((status = decode_getfh(&xdr, res->fh)) == 0)
3295                 status = decode_getfattr(&xdr, res->fattr, res->server);
3296 out:
3297         return status;
3298 }
3299
3300 /*
3301  * Decode REMOVE response
3302  */
3303 static int nfs4_xdr_dec_remove(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_change_info *cinfo)
3304 {
3305         struct xdr_stream xdr;
3306         struct compound_hdr hdr;
3307         int status;
3308         
3309         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
3310         if ((status = decode_compound_hdr(&xdr, &hdr)) != 0)
3311                 goto out;
3312         if ((status = decode_putfh(&xdr)) == 0)
3313                 status = decode_remove(&xdr, cinfo);
3314 out:
3315         return status;
3316 }
3317
3318 /*
3319  * Decode RENAME response
3320  */
3321 static int nfs4_xdr_dec_rename(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_rename_res *res)
3322 {
3323         struct xdr_stream xdr;
3324         struct compound_hdr hdr;
3325         int status;
3326         
3327         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
3328         if ((status = decode_compound_hdr(&xdr, &hdr)) != 0)
3329                 goto out;
3330         if ((status = decode_putfh(&xdr)) != 0)
3331                 goto out;
3332         if ((status = decode_savefh(&xdr)) != 0)
3333                 goto out;
3334         if ((status = decode_putfh(&xdr)) != 0)
3335                 goto out;
3336         status = decode_rename(&xdr, &res->old_cinfo, &res->new_cinfo);
3337 out:
3338         return status;
3339 }
3340
3341 /*
3342  * Decode LINK response
3343  */
3344 static int nfs4_xdr_dec_link(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_change_info *cinfo)
3345 {
3346         struct xdr_stream xdr;
3347         struct compound_hdr hdr;
3348         int status;
3349         
3350         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
3351         if ((status = decode_compound_hdr(&xdr, &hdr)) != 0)
3352                 goto out;
3353         if ((status = decode_putfh(&xdr)) != 0)
3354                 goto out;
3355         if ((status = decode_savefh(&xdr)) != 0)
3356                 goto out;
3357         if ((status = decode_putfh(&xdr)) != 0)
3358                 goto out;
3359         status = decode_link(&xdr, cinfo);
3360 out:
3361         return status;
3362 }
3363
3364 /*
3365  * Decode CREATE response
3366  */
3367 static int nfs4_xdr_dec_create(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_create_res *res)
3368 {
3369         struct xdr_stream xdr;
3370         struct compound_hdr hdr;
3371         int status;
3372         
3373         xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
3374         if ((status = decode_compound_hdr(&xdr, &hdr)) != 0)
3375                 goto out;
3376         if ((status = decode_putfh(&xdr)) != 0)
3377                 goto out;
3378         if ((status = decode_create(&xdr,&res->dir_cinfo)) != 0)
3379                 goto out;
3380         if ((status = decode_getfh(&xdr, res->fh)) != 0)
3381                 goto out;
3382         status = decode_getfattr(&xdr, res->fattr, res->server);
3383         if (status == NFS4ERR_DELAY)
3384                 status = 0;
3385 out:
3386         return status;
3387 }
3388
3389 /*
3390  * Decode SYMLINK response
3391  */
3392 static int nfs4_xdr_dec_symlink(struct rpc_rqst *rqstp, uint32_t *p, struct nfs4_create_res *res)
3393 {
3394         return nfs4_xdr_dec_create(rqstp, p, res);
3395 }
3396
3397 /*