vfs: trivial __d_lookup_rcu() cleanups
[linux-2.6.git] / fs / nfs / nfs2xdr.c
1 /*
2  * linux/fs/nfs/nfs2xdr.c
3  *
4  * XDR functions to encode/decode NFS RPC arguments and results.
5  *
6  * Copyright (C) 1992, 1993, 1994  Rick Sladkey
7  * Copyright (C) 1996 Olaf Kirch
8  * 04 Aug 1998  Ion Badulescu <ionut@cs.columbia.edu>
9  *              FIFO's need special handling in NFSv2
10  */
11
12 #include <linux/param.h>
13 #include <linux/time.h>
14 #include <linux/mm.h>
15 #include <linux/errno.h>
16 #include <linux/string.h>
17 #include <linux/in.h>
18 #include <linux/pagemap.h>
19 #include <linux/proc_fs.h>
20 #include <linux/sunrpc/clnt.h>
21 #include <linux/nfs.h>
22 #include <linux/nfs2.h>
23 #include <linux/nfs_fs.h>
24 #include "internal.h"
25
26 #define NFSDBG_FACILITY         NFSDBG_XDR
27
28 /* Mapping from NFS error code to "errno" error code. */
29 #define errno_NFSERR_IO         EIO
30
31 /*
32  * Declare the space requirements for NFS arguments and replies as
33  * number of 32bit-words
34  */
35 #define NFS_fhandle_sz          (8)
36 #define NFS_sattr_sz            (8)
37 #define NFS_filename_sz         (1+(NFS2_MAXNAMLEN>>2))
38 #define NFS_path_sz             (1+(NFS2_MAXPATHLEN>>2))
39 #define NFS_fattr_sz            (17)
40 #define NFS_info_sz             (5)
41 #define NFS_entry_sz            (NFS_filename_sz+3)
42
43 #define NFS_diropargs_sz        (NFS_fhandle_sz+NFS_filename_sz)
44 #define NFS_removeargs_sz       (NFS_fhandle_sz+NFS_filename_sz)
45 #define NFS_sattrargs_sz        (NFS_fhandle_sz+NFS_sattr_sz)
46 #define NFS_readlinkargs_sz     (NFS_fhandle_sz)
47 #define NFS_readargs_sz         (NFS_fhandle_sz+3)
48 #define NFS_writeargs_sz        (NFS_fhandle_sz+4)
49 #define NFS_createargs_sz       (NFS_diropargs_sz+NFS_sattr_sz)
50 #define NFS_renameargs_sz       (NFS_diropargs_sz+NFS_diropargs_sz)
51 #define NFS_linkargs_sz         (NFS_fhandle_sz+NFS_diropargs_sz)
52 #define NFS_symlinkargs_sz      (NFS_diropargs_sz+1+NFS_sattr_sz)
53 #define NFS_readdirargs_sz      (NFS_fhandle_sz+2)
54
55 #define NFS_attrstat_sz         (1+NFS_fattr_sz)
56 #define NFS_diropres_sz         (1+NFS_fhandle_sz+NFS_fattr_sz)
57 #define NFS_readlinkres_sz      (2)
58 #define NFS_readres_sz          (1+NFS_fattr_sz+1)
59 #define NFS_writeres_sz         (NFS_attrstat_sz)
60 #define NFS_stat_sz             (1)
61 #define NFS_readdirres_sz       (1)
62 #define NFS_statfsres_sz        (1+NFS_info_sz)
63
64
65 /*
66  * While encoding arguments, set up the reply buffer in advance to
67  * receive reply data directly into the page cache.
68  */
69 static void prepare_reply_buffer(struct rpc_rqst *req, struct page **pages,
70                                  unsigned int base, unsigned int len,
71                                  unsigned int bufsize)
72 {
73         struct rpc_auth *auth = req->rq_cred->cr_auth;
74         unsigned int replen;
75
76         replen = RPC_REPHDRSIZE + auth->au_rslack + bufsize;
77         xdr_inline_pages(&req->rq_rcv_buf, replen << 2, pages, base, len);
78 }
79
80 /*
81  * Handle decode buffer overflows out-of-line.
82  */
83 static void print_overflow_msg(const char *func, const struct xdr_stream *xdr)
84 {
85         dprintk("NFS: %s prematurely hit the end of our receive buffer. "
86                 "Remaining buffer length is %tu words.\n",
87                 func, xdr->end - xdr->p);
88 }
89
90
91 /*
92  * Encode/decode NFSv2 basic data types
93  *
94  * Basic NFSv2 data types are defined in section 2.3 of RFC 1094:
95  * "NFS: Network File System Protocol Specification".
96  *
97  * Not all basic data types have their own encoding and decoding
98  * functions.  For run-time efficiency, some data types are encoded
99  * or decoded inline.
100  */
101
102 /*
103  *      typedef opaque  nfsdata<>;
104  */
105 static int decode_nfsdata(struct xdr_stream *xdr, struct nfs_readres *result)
106 {
107         u32 recvd, count;
108         size_t hdrlen;
109         __be32 *p;
110
111         p = xdr_inline_decode(xdr, 4);
112         if (unlikely(p == NULL))
113                 goto out_overflow;
114         count = be32_to_cpup(p);
115         hdrlen = (u8 *)xdr->p - (u8 *)xdr->iov->iov_base;
116         recvd = xdr->buf->len - hdrlen;
117         if (unlikely(count > recvd))
118                 goto out_cheating;
119 out:
120         xdr_read_pages(xdr, count);
121         result->eof = 0;        /* NFSv2 does not pass EOF flag on the wire. */
122         result->count = count;
123         return count;
124 out_cheating:
125         dprintk("NFS: server cheating in read result: "
126                 "count %u > recvd %u\n", count, recvd);
127         count = recvd;
128         goto out;
129 out_overflow:
130         print_overflow_msg(__func__, xdr);
131         return -EIO;
132 }
133
134 /*
135  *      enum stat {
136  *              NFS_OK = 0,
137  *              NFSERR_PERM = 1,
138  *              NFSERR_NOENT = 2,
139  *              NFSERR_IO = 5,
140  *              NFSERR_NXIO = 6,
141  *              NFSERR_ACCES = 13,
142  *              NFSERR_EXIST = 17,
143  *              NFSERR_NODEV = 19,
144  *              NFSERR_NOTDIR = 20,
145  *              NFSERR_ISDIR = 21,
146  *              NFSERR_FBIG = 27,
147  *              NFSERR_NOSPC = 28,
148  *              NFSERR_ROFS = 30,
149  *              NFSERR_NAMETOOLONG = 63,
150  *              NFSERR_NOTEMPTY = 66,
151  *              NFSERR_DQUOT = 69,
152  *              NFSERR_STALE = 70,
153  *              NFSERR_WFLUSH = 99
154  *      };
155  */
156 static int decode_stat(struct xdr_stream *xdr, enum nfs_stat *status)
157 {
158         __be32 *p;
159
160         p = xdr_inline_decode(xdr, 4);
161         if (unlikely(p == NULL))
162                 goto out_overflow;
163         *status = be32_to_cpup(p);
164         return 0;
165 out_overflow:
166         print_overflow_msg(__func__, xdr);
167         return -EIO;
168 }
169
170 /*
171  * 2.3.2.  ftype
172  *
173  *      enum ftype {
174  *              NFNON = 0,
175  *              NFREG = 1,
176  *              NFDIR = 2,
177  *              NFBLK = 3,
178  *              NFCHR = 4,
179  *              NFLNK = 5
180  *      };
181  *
182  */
183 static __be32 *xdr_decode_ftype(__be32 *p, u32 *type)
184 {
185         *type = be32_to_cpup(p++);
186         if (unlikely(*type > NF2FIFO))
187                 *type = NFBAD;
188         return p;
189 }
190
191 /*
192  * 2.3.3.  fhandle
193  *
194  *      typedef opaque fhandle[FHSIZE];
195  */
196 static void encode_fhandle(struct xdr_stream *xdr, const struct nfs_fh *fh)
197 {
198         __be32 *p;
199
200         BUG_ON(fh->size != NFS2_FHSIZE);
201         p = xdr_reserve_space(xdr, NFS2_FHSIZE);
202         memcpy(p, fh->data, NFS2_FHSIZE);
203 }
204
205 static int decode_fhandle(struct xdr_stream *xdr, struct nfs_fh *fh)
206 {
207         __be32 *p;
208
209         p = xdr_inline_decode(xdr, NFS2_FHSIZE);
210         if (unlikely(p == NULL))
211                 goto out_overflow;
212         fh->size = NFS2_FHSIZE;
213         memcpy(fh->data, p, NFS2_FHSIZE);
214         return 0;
215 out_overflow:
216         print_overflow_msg(__func__, xdr);
217         return -EIO;
218 }
219
220 /*
221  * 2.3.4.  timeval
222  *
223  *      struct timeval {
224  *              unsigned int seconds;
225  *              unsigned int useconds;
226  *      };
227  */
228 static __be32 *xdr_encode_time(__be32 *p, const struct timespec *timep)
229 {
230         *p++ = cpu_to_be32(timep->tv_sec);
231         if (timep->tv_nsec != 0)
232                 *p++ = cpu_to_be32(timep->tv_nsec / NSEC_PER_USEC);
233         else
234                 *p++ = cpu_to_be32(0);
235         return p;
236 }
237
238 /*
239  * Passing the invalid value useconds=1000000 is a Sun convention for
240  * "set to current server time".  It's needed to make permissions checks
241  * for the "touch" program across v2 mounts to Solaris and Irix servers
242  * work correctly.  See description of sattr in section 6.1 of "NFS
243  * Illustrated" by Brent Callaghan, Addison-Wesley, ISBN 0-201-32750-5.
244  */
245 static __be32 *xdr_encode_current_server_time(__be32 *p,
246                                               const struct timespec *timep)
247 {
248         *p++ = cpu_to_be32(timep->tv_sec);
249         *p++ = cpu_to_be32(1000000);
250         return p;
251 }
252
253 static __be32 *xdr_decode_time(__be32 *p, struct timespec *timep)
254 {
255         timep->tv_sec = be32_to_cpup(p++);
256         timep->tv_nsec = be32_to_cpup(p++) * NSEC_PER_USEC;
257         return p;
258 }
259
260 /*
261  * 2.3.5.  fattr
262  *
263  *      struct fattr {
264  *              ftype           type;
265  *              unsigned int    mode;
266  *              unsigned int    nlink;
267  *              unsigned int    uid;
268  *              unsigned int    gid;
269  *              unsigned int    size;
270  *              unsigned int    blocksize;
271  *              unsigned int    rdev;
272  *              unsigned int    blocks;
273  *              unsigned int    fsid;
274  *              unsigned int    fileid;
275  *              timeval         atime;
276  *              timeval         mtime;
277  *              timeval         ctime;
278  *      };
279  *
280  */
281 static int decode_fattr(struct xdr_stream *xdr, struct nfs_fattr *fattr)
282 {
283         u32 rdev, type;
284         __be32 *p;
285
286         p = xdr_inline_decode(xdr, NFS_fattr_sz << 2);
287         if (unlikely(p == NULL))
288                 goto out_overflow;
289
290         fattr->valid |= NFS_ATTR_FATTR_V2;
291
292         p = xdr_decode_ftype(p, &type);
293
294         fattr->mode = be32_to_cpup(p++);
295         fattr->nlink = be32_to_cpup(p++);
296         fattr->uid = be32_to_cpup(p++);
297         fattr->gid = be32_to_cpup(p++);
298         fattr->size = be32_to_cpup(p++);
299         fattr->du.nfs2.blocksize = be32_to_cpup(p++);
300
301         rdev = be32_to_cpup(p++);
302         fattr->rdev = new_decode_dev(rdev);
303         if (type == (u32)NFCHR && rdev == (u32)NFS2_FIFO_DEV) {
304                 fattr->mode = (fattr->mode & ~S_IFMT) | S_IFIFO;
305                 fattr->rdev = 0;
306         }
307
308         fattr->du.nfs2.blocks = be32_to_cpup(p++);
309         fattr->fsid.major = be32_to_cpup(p++);
310         fattr->fsid.minor = 0;
311         fattr->fileid = be32_to_cpup(p++);
312
313         p = xdr_decode_time(p, &fattr->atime);
314         p = xdr_decode_time(p, &fattr->mtime);
315         xdr_decode_time(p, &fattr->ctime);
316         return 0;
317 out_overflow:
318         print_overflow_msg(__func__, xdr);
319         return -EIO;
320 }
321
322 /*
323  * 2.3.6.  sattr
324  *
325  *      struct sattr {
326  *              unsigned int    mode;
327  *              unsigned int    uid;
328  *              unsigned int    gid;
329  *              unsigned int    size;
330  *              timeval         atime;
331  *              timeval         mtime;
332  *      };
333  */
334
335 #define NFS2_SATTR_NOT_SET      (0xffffffff)
336
337 static __be32 *xdr_time_not_set(__be32 *p)
338 {
339         *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
340         *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
341         return p;
342 }
343
344 static void encode_sattr(struct xdr_stream *xdr, const struct iattr *attr)
345 {
346         __be32 *p;
347
348         p = xdr_reserve_space(xdr, NFS_sattr_sz << 2);
349
350         if (attr->ia_valid & ATTR_MODE)
351                 *p++ = cpu_to_be32(attr->ia_mode);
352         else
353                 *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
354         if (attr->ia_valid & ATTR_UID)
355                 *p++ = cpu_to_be32(attr->ia_uid);
356         else
357                 *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
358         if (attr->ia_valid & ATTR_GID)
359                 *p++ = cpu_to_be32(attr->ia_gid);
360         else
361                 *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
362         if (attr->ia_valid & ATTR_SIZE)
363                 *p++ = cpu_to_be32((u32)attr->ia_size);
364         else
365                 *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
366
367         if (attr->ia_valid & ATTR_ATIME_SET)
368                 p = xdr_encode_time(p, &attr->ia_atime);
369         else if (attr->ia_valid & ATTR_ATIME)
370                 p = xdr_encode_current_server_time(p, &attr->ia_atime);
371         else
372                 p = xdr_time_not_set(p);
373         if (attr->ia_valid & ATTR_MTIME_SET)
374                 xdr_encode_time(p, &attr->ia_mtime);
375         else if (attr->ia_valid & ATTR_MTIME)
376                 xdr_encode_current_server_time(p, &attr->ia_mtime);
377         else
378                 xdr_time_not_set(p);
379 }
380
381 /*
382  * 2.3.7.  filename
383  *
384  *      typedef string filename<MAXNAMLEN>;
385  */
386 static void encode_filename(struct xdr_stream *xdr,
387                             const char *name, u32 length)
388 {
389         __be32 *p;
390
391         BUG_ON(length > NFS2_MAXNAMLEN);
392         p = xdr_reserve_space(xdr, 4 + length);
393         xdr_encode_opaque(p, name, length);
394 }
395
396 static int decode_filename_inline(struct xdr_stream *xdr,
397                                   const char **name, u32 *length)
398 {
399         __be32 *p;
400         u32 count;
401
402         p = xdr_inline_decode(xdr, 4);
403         if (unlikely(p == NULL))
404                 goto out_overflow;
405         count = be32_to_cpup(p);
406         if (count > NFS3_MAXNAMLEN)
407                 goto out_nametoolong;
408         p = xdr_inline_decode(xdr, count);
409         if (unlikely(p == NULL))
410                 goto out_overflow;
411         *name = (const char *)p;
412         *length = count;
413         return 0;
414 out_nametoolong:
415         dprintk("NFS: returned filename too long: %u\n", count);
416         return -ENAMETOOLONG;
417 out_overflow:
418         print_overflow_msg(__func__, xdr);
419         return -EIO;
420 }
421
422 /*
423  * 2.3.8.  path
424  *
425  *      typedef string path<MAXPATHLEN>;
426  */
427 static void encode_path(struct xdr_stream *xdr, struct page **pages, u32 length)
428 {
429         __be32 *p;
430
431         BUG_ON(length > NFS2_MAXPATHLEN);
432         p = xdr_reserve_space(xdr, 4);
433         *p = cpu_to_be32(length);
434         xdr_write_pages(xdr, pages, 0, length);
435 }
436
437 static int decode_path(struct xdr_stream *xdr)
438 {
439         u32 length, recvd;
440         size_t hdrlen;
441         __be32 *p;
442
443         p = xdr_inline_decode(xdr, 4);
444         if (unlikely(p == NULL))
445                 goto out_overflow;
446         length = be32_to_cpup(p);
447         if (unlikely(length >= xdr->buf->page_len || length > NFS_MAXPATHLEN))
448                 goto out_size;
449         hdrlen = (u8 *)xdr->p - (u8 *)xdr->iov->iov_base;
450         recvd = xdr->buf->len - hdrlen;
451         if (unlikely(length > recvd))
452                 goto out_cheating;
453
454         xdr_read_pages(xdr, length);
455         xdr_terminate_string(xdr->buf, length);
456         return 0;
457 out_size:
458         dprintk("NFS: returned pathname too long: %u\n", length);
459         return -ENAMETOOLONG;
460 out_cheating:
461         dprintk("NFS: server cheating in pathname result: "
462                 "length %u > received %u\n", length, recvd);
463         return -EIO;
464 out_overflow:
465         print_overflow_msg(__func__, xdr);
466         return -EIO;
467 }
468
469 /*
470  * 2.3.9.  attrstat
471  *
472  *      union attrstat switch (stat status) {
473  *      case NFS_OK:
474  *              fattr attributes;
475  *      default:
476  *              void;
477  *      };
478  */
479 static int decode_attrstat(struct xdr_stream *xdr, struct nfs_fattr *result)
480 {
481         enum nfs_stat status;
482         int error;
483
484         error = decode_stat(xdr, &status);
485         if (unlikely(error))
486                 goto out;
487         if (status != NFS_OK)
488                 goto out_default;
489         error = decode_fattr(xdr, result);
490 out:
491         return error;
492 out_default:
493         return nfs_stat_to_errno(status);
494 }
495
496 /*
497  * 2.3.10.  diropargs
498  *
499  *      struct diropargs {
500  *              fhandle  dir;
501  *              filename name;
502  *      };
503  */
504 static void encode_diropargs(struct xdr_stream *xdr, const struct nfs_fh *fh,
505                              const char *name, u32 length)
506 {
507         encode_fhandle(xdr, fh);
508         encode_filename(xdr, name, length);
509 }
510
511 /*
512  * 2.3.11.  diropres
513  *
514  *      union diropres switch (stat status) {
515  *      case NFS_OK:
516  *              struct {
517  *                      fhandle file;
518  *                      fattr   attributes;
519  *              } diropok;
520  *      default:
521  *              void;
522  *      };
523  */
524 static int decode_diropok(struct xdr_stream *xdr, struct nfs_diropok *result)
525 {
526         int error;
527
528         error = decode_fhandle(xdr, result->fh);
529         if (unlikely(error))
530                 goto out;
531         error = decode_fattr(xdr, result->fattr);
532 out:
533         return error;
534 }
535
536 static int decode_diropres(struct xdr_stream *xdr, struct nfs_diropok *result)
537 {
538         enum nfs_stat status;
539         int error;
540
541         error = decode_stat(xdr, &status);
542         if (unlikely(error))
543                 goto out;
544         if (status != NFS_OK)
545                 goto out_default;
546         error = decode_diropok(xdr, result);
547 out:
548         return error;
549 out_default:
550         return nfs_stat_to_errno(status);
551 }
552
553
554 /*
555  * NFSv2 XDR encode functions
556  *
557  * NFSv2 argument types are defined in section 2.2 of RFC 1094:
558  * "NFS: Network File System Protocol Specification".
559  */
560
561 static void nfs2_xdr_enc_fhandle(struct rpc_rqst *req,
562                                  struct xdr_stream *xdr,
563                                  const struct nfs_fh *fh)
564 {
565         encode_fhandle(xdr, fh);
566 }
567
568 /*
569  * 2.2.3.  sattrargs
570  *
571  *      struct sattrargs {
572  *              fhandle file;
573  *              sattr attributes;
574  *      };
575  */
576 static void nfs2_xdr_enc_sattrargs(struct rpc_rqst *req,
577                                    struct xdr_stream *xdr,
578                                    const struct nfs_sattrargs *args)
579 {
580         encode_fhandle(xdr, args->fh);
581         encode_sattr(xdr, args->sattr);
582 }
583
584 static void nfs2_xdr_enc_diropargs(struct rpc_rqst *req,
585                                    struct xdr_stream *xdr,
586                                    const struct nfs_diropargs *args)
587 {
588         encode_diropargs(xdr, args->fh, args->name, args->len);
589 }
590
591 static void nfs2_xdr_enc_readlinkargs(struct rpc_rqst *req,
592                                       struct xdr_stream *xdr,
593                                       const struct nfs_readlinkargs *args)
594 {
595         encode_fhandle(xdr, args->fh);
596         prepare_reply_buffer(req, args->pages, args->pgbase,
597                                         args->pglen, NFS_readlinkres_sz);
598 }
599
600 /*
601  * 2.2.7.  readargs
602  *
603  *      struct readargs {
604  *              fhandle file;
605  *              unsigned offset;
606  *              unsigned count;
607  *              unsigned totalcount;
608  *      };
609  */
610 static void encode_readargs(struct xdr_stream *xdr,
611                             const struct nfs_readargs *args)
612 {
613         u32 offset = args->offset;
614         u32 count = args->count;
615         __be32 *p;
616
617         encode_fhandle(xdr, args->fh);
618
619         p = xdr_reserve_space(xdr, 4 + 4 + 4);
620         *p++ = cpu_to_be32(offset);
621         *p++ = cpu_to_be32(count);
622         *p = cpu_to_be32(count);
623 }
624
625 static void nfs2_xdr_enc_readargs(struct rpc_rqst *req,
626                                   struct xdr_stream *xdr,
627                                   const struct nfs_readargs *args)
628 {
629         encode_readargs(xdr, args);
630         prepare_reply_buffer(req, args->pages, args->pgbase,
631                                         args->count, NFS_readres_sz);
632         req->rq_rcv_buf.flags |= XDRBUF_READ;
633 }
634
635 /*
636  * 2.2.9.  writeargs
637  *
638  *      struct writeargs {
639  *              fhandle file;
640  *              unsigned beginoffset;
641  *              unsigned offset;
642  *              unsigned totalcount;
643  *              nfsdata data;
644  *      };
645  */
646 static void encode_writeargs(struct xdr_stream *xdr,
647                              const struct nfs_writeargs *args)
648 {
649         u32 offset = args->offset;
650         u32 count = args->count;
651         __be32 *p;
652
653         encode_fhandle(xdr, args->fh);
654
655         p = xdr_reserve_space(xdr, 4 + 4 + 4 + 4);
656         *p++ = cpu_to_be32(offset);
657         *p++ = cpu_to_be32(offset);
658         *p++ = cpu_to_be32(count);
659
660         /* nfsdata */
661         *p = cpu_to_be32(count);
662         xdr_write_pages(xdr, args->pages, args->pgbase, count);
663 }
664
665 static void nfs2_xdr_enc_writeargs(struct rpc_rqst *req,
666                                    struct xdr_stream *xdr,
667                                    const struct nfs_writeargs *args)
668 {
669         encode_writeargs(xdr, args);
670         xdr->buf->flags |= XDRBUF_WRITE;
671 }
672
673 /*
674  * 2.2.10.  createargs
675  *
676  *      struct createargs {
677  *              diropargs where;
678  *              sattr attributes;
679  *      };
680  */
681 static void nfs2_xdr_enc_createargs(struct rpc_rqst *req,
682                                     struct xdr_stream *xdr,
683                                     const struct nfs_createargs *args)
684 {
685         encode_diropargs(xdr, args->fh, args->name, args->len);
686         encode_sattr(xdr, args->sattr);
687 }
688
689 static void nfs2_xdr_enc_removeargs(struct rpc_rqst *req,
690                                     struct xdr_stream *xdr,
691                                     const struct nfs_removeargs *args)
692 {
693         encode_diropargs(xdr, args->fh, args->name.name, args->name.len);
694 }
695
696 /*
697  * 2.2.12.  renameargs
698  *
699  *      struct renameargs {
700  *              diropargs from;
701  *              diropargs to;
702  *      };
703  */
704 static void nfs2_xdr_enc_renameargs(struct rpc_rqst *req,
705                                     struct xdr_stream *xdr,
706                                     const struct nfs_renameargs *args)
707 {
708         const struct qstr *old = args->old_name;
709         const struct qstr *new = args->new_name;
710
711         encode_diropargs(xdr, args->old_dir, old->name, old->len);
712         encode_diropargs(xdr, args->new_dir, new->name, new->len);
713 }
714
715 /*
716  * 2.2.13.  linkargs
717  *
718  *      struct linkargs {
719  *              fhandle from;
720  *              diropargs to;
721  *      };
722  */
723 static void nfs2_xdr_enc_linkargs(struct rpc_rqst *req,
724                                   struct xdr_stream *xdr,
725                                   const struct nfs_linkargs *args)
726 {
727         encode_fhandle(xdr, args->fromfh);
728         encode_diropargs(xdr, args->tofh, args->toname, args->tolen);
729 }
730
731 /*
732  * 2.2.14.  symlinkargs
733  *
734  *      struct symlinkargs {
735  *              diropargs from;
736  *              path to;
737  *              sattr attributes;
738  *      };
739  */
740 static void nfs2_xdr_enc_symlinkargs(struct rpc_rqst *req,
741                                      struct xdr_stream *xdr,
742                                      const struct nfs_symlinkargs *args)
743 {
744         encode_diropargs(xdr, args->fromfh, args->fromname, args->fromlen);
745         encode_path(xdr, args->pages, args->pathlen);
746         encode_sattr(xdr, args->sattr);
747 }
748
749 /*
750  * 2.2.17.  readdirargs
751  *
752  *      struct readdirargs {
753  *              fhandle dir;
754  *              nfscookie cookie;
755  *              unsigned count;
756  *      };
757  */
758 static void encode_readdirargs(struct xdr_stream *xdr,
759                                const struct nfs_readdirargs *args)
760 {
761         __be32 *p;
762
763         encode_fhandle(xdr, args->fh);
764
765         p = xdr_reserve_space(xdr, 4 + 4);
766         *p++ = cpu_to_be32(args->cookie);
767         *p = cpu_to_be32(args->count);
768 }
769
770 static void nfs2_xdr_enc_readdirargs(struct rpc_rqst *req,
771                                      struct xdr_stream *xdr,
772                                      const struct nfs_readdirargs *args)
773 {
774         encode_readdirargs(xdr, args);
775         prepare_reply_buffer(req, args->pages, 0,
776                                         args->count, NFS_readdirres_sz);
777 }
778
779 /*
780  * NFSv2 XDR decode functions
781  *
782  * NFSv2 result types are defined in section 2.2 of RFC 1094:
783  * "NFS: Network File System Protocol Specification".
784  */
785
786 static int nfs2_xdr_dec_stat(struct rpc_rqst *req, struct xdr_stream *xdr,
787                              void *__unused)
788 {
789         enum nfs_stat status;
790         int error;
791
792         error = decode_stat(xdr, &status);
793         if (unlikely(error))
794                 goto out;
795         if (status != NFS_OK)
796                 goto out_default;
797 out:
798         return error;
799 out_default:
800         return nfs_stat_to_errno(status);
801 }
802
803 static int nfs2_xdr_dec_attrstat(struct rpc_rqst *req, struct xdr_stream *xdr,
804                                  struct nfs_fattr *result)
805 {
806         return decode_attrstat(xdr, result);
807 }
808
809 static int nfs2_xdr_dec_diropres(struct rpc_rqst *req, struct xdr_stream *xdr,
810                                  struct nfs_diropok *result)
811 {
812         return decode_diropres(xdr, result);
813 }
814
815 /*
816  * 2.2.6.  readlinkres
817  *
818  *      union readlinkres switch (stat status) {
819  *      case NFS_OK:
820  *              path data;
821  *      default:
822  *              void;
823  *      };
824  */
825 static int nfs2_xdr_dec_readlinkres(struct rpc_rqst *req,
826                                     struct xdr_stream *xdr, void *__unused)
827 {
828         enum nfs_stat status;
829         int error;
830
831         error = decode_stat(xdr, &status);
832         if (unlikely(error))
833                 goto out;
834         if (status != NFS_OK)
835                 goto out_default;
836         error = decode_path(xdr);
837 out:
838         return error;
839 out_default:
840         return nfs_stat_to_errno(status);
841 }
842
843 /*
844  * 2.2.7.  readres
845  *
846  *      union readres switch (stat status) {
847  *      case NFS_OK:
848  *              fattr attributes;
849  *              nfsdata data;
850  *      default:
851  *              void;
852  *      };
853  */
854 static int nfs2_xdr_dec_readres(struct rpc_rqst *req, struct xdr_stream *xdr,
855                                 struct nfs_readres *result)
856 {
857         enum nfs_stat status;
858         int error;
859
860         error = decode_stat(xdr, &status);
861         if (unlikely(error))
862                 goto out;
863         if (status != NFS_OK)
864                 goto out_default;
865         error = decode_fattr(xdr, result->fattr);
866         if (unlikely(error))
867                 goto out;
868         error = decode_nfsdata(xdr, result);
869 out:
870         return error;
871 out_default:
872         return nfs_stat_to_errno(status);
873 }
874
875 static int nfs2_xdr_dec_writeres(struct rpc_rqst *req, struct xdr_stream *xdr,
876                                  struct nfs_writeres *result)
877 {
878         /* All NFSv2 writes are "file sync" writes */
879         result->verf->committed = NFS_FILE_SYNC;
880         return decode_attrstat(xdr, result->fattr);
881 }
882
883 /**
884  * nfs2_decode_dirent - Decode a single NFSv2 directory entry stored in
885  *                      the local page cache.
886  * @xdr: XDR stream where entry resides
887  * @entry: buffer to fill in with entry data
888  * @plus: boolean indicating whether this should be a readdirplus entry
889  *
890  * Returns zero if successful, otherwise a negative errno value is
891  * returned.
892  *
893  * This function is not invoked during READDIR reply decoding, but
894  * rather whenever an application invokes the getdents(2) system call
895  * on a directory already in our cache.
896  *
897  * 2.2.17.  entry
898  *
899  *      struct entry {
900  *              unsigned        fileid;
901  *              filename        name;
902  *              nfscookie       cookie;
903  *              entry           *nextentry;
904  *      };
905  */
906 int nfs2_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry,
907                        int plus)
908 {
909         __be32 *p;
910         int error;
911
912         p = xdr_inline_decode(xdr, 4);
913         if (unlikely(p == NULL))
914                 goto out_overflow;
915         if (*p++ == xdr_zero) {
916                 p = xdr_inline_decode(xdr, 4);
917                 if (unlikely(p == NULL))
918                         goto out_overflow;
919                 if (*p++ == xdr_zero)
920                         return -EAGAIN;
921                 entry->eof = 1;
922                 return -EBADCOOKIE;
923         }
924
925         p = xdr_inline_decode(xdr, 4);
926         if (unlikely(p == NULL))
927                 goto out_overflow;
928         entry->ino = be32_to_cpup(p);
929
930         error = decode_filename_inline(xdr, &entry->name, &entry->len);
931         if (unlikely(error))
932                 return error;
933
934         /*
935          * The type (size and byte order) of nfscookie isn't defined in
936          * RFC 1094.  This implementation assumes that it's an XDR uint32.
937          */
938         entry->prev_cookie = entry->cookie;
939         p = xdr_inline_decode(xdr, 4);
940         if (unlikely(p == NULL))
941                 goto out_overflow;
942         entry->cookie = be32_to_cpup(p);
943
944         entry->d_type = DT_UNKNOWN;
945
946         return 0;
947
948 out_overflow:
949         print_overflow_msg(__func__, xdr);
950         return -EAGAIN;
951 }
952
953 /*
954  * 2.2.17.  readdirres
955  *
956  *      union readdirres switch (stat status) {
957  *      case NFS_OK:
958  *              struct {
959  *                      entry *entries;
960  *                      bool eof;
961  *              } readdirok;
962  *      default:
963  *              void;
964  *      };
965  *
966  * Read the directory contents into the page cache, but don't
967  * touch them.  The actual decoding is done by nfs2_decode_dirent()
968  * during subsequent nfs_readdir() calls.
969  */
970 static int decode_readdirok(struct xdr_stream *xdr)
971 {
972         u32 recvd, pglen;
973         size_t hdrlen;
974
975         pglen = xdr->buf->page_len;
976         hdrlen = (u8 *)xdr->p - (u8 *)xdr->iov->iov_base;
977         recvd = xdr->buf->len - hdrlen;
978         if (unlikely(pglen > recvd))
979                 goto out_cheating;
980 out:
981         xdr_read_pages(xdr, pglen);
982         return pglen;
983 out_cheating:
984         dprintk("NFS: server cheating in readdir result: "
985                 "pglen %u > recvd %u\n", pglen, recvd);
986         pglen = recvd;
987         goto out;
988 }
989
990 static int nfs2_xdr_dec_readdirres(struct rpc_rqst *req,
991                                    struct xdr_stream *xdr, void *__unused)
992 {
993         enum nfs_stat status;
994         int error;
995
996         error = decode_stat(xdr, &status);
997         if (unlikely(error))
998                 goto out;
999         if (status != NFS_OK)
1000                 goto out_default;
1001         error = decode_readdirok(xdr);
1002 out:
1003         return error;
1004 out_default:
1005         return nfs_stat_to_errno(status);
1006 }
1007
1008 /*
1009  * 2.2.18.  statfsres
1010  *
1011  *      union statfsres (stat status) {
1012  *      case NFS_OK:
1013  *              struct {
1014  *                      unsigned tsize;
1015  *                      unsigned bsize;
1016  *                      unsigned blocks;
1017  *                      unsigned bfree;
1018  *                      unsigned bavail;
1019  *              } info;
1020  *      default:
1021  *              void;
1022  *      };
1023  */
1024 static int decode_info(struct xdr_stream *xdr, struct nfs2_fsstat *result)
1025 {
1026         __be32 *p;
1027
1028         p = xdr_inline_decode(xdr, NFS_info_sz << 2);
1029         if (unlikely(p == NULL))
1030                 goto out_overflow;
1031         result->tsize  = be32_to_cpup(p++);
1032         result->bsize  = be32_to_cpup(p++);
1033         result->blocks = be32_to_cpup(p++);
1034         result->bfree  = be32_to_cpup(p++);
1035         result->bavail = be32_to_cpup(p);
1036         return 0;
1037 out_overflow:
1038         print_overflow_msg(__func__, xdr);
1039         return -EIO;
1040 }
1041
1042 static int nfs2_xdr_dec_statfsres(struct rpc_rqst *req, struct xdr_stream *xdr,
1043                                   struct nfs2_fsstat *result)
1044 {
1045         enum nfs_stat status;
1046         int error;
1047
1048         error = decode_stat(xdr, &status);
1049         if (unlikely(error))
1050                 goto out;
1051         if (status != NFS_OK)
1052                 goto out_default;
1053         error = decode_info(xdr, result);
1054 out:
1055         return error;
1056 out_default:
1057         return nfs_stat_to_errno(status);
1058 }
1059
1060
1061 /*
1062  * We need to translate between nfs status return values and
1063  * the local errno values which may not be the same.
1064  */
1065 static const struct {
1066         int stat;
1067         int errno;
1068 } nfs_errtbl[] = {
1069         { NFS_OK,               0               },
1070         { NFSERR_PERM,          -EPERM          },
1071         { NFSERR_NOENT,         -ENOENT         },
1072         { NFSERR_IO,            -errno_NFSERR_IO},
1073         { NFSERR_NXIO,          -ENXIO          },
1074 /*      { NFSERR_EAGAIN,        -EAGAIN         }, */
1075         { NFSERR_ACCES,         -EACCES         },
1076         { NFSERR_EXIST,         -EEXIST         },
1077         { NFSERR_XDEV,          -EXDEV          },
1078         { NFSERR_NODEV,         -ENODEV         },
1079         { NFSERR_NOTDIR,        -ENOTDIR        },
1080         { NFSERR_ISDIR,         -EISDIR         },
1081         { NFSERR_INVAL,         -EINVAL         },
1082         { NFSERR_FBIG,          -EFBIG          },
1083         { NFSERR_NOSPC,         -ENOSPC         },
1084         { NFSERR_ROFS,          -EROFS          },
1085         { NFSERR_MLINK,         -EMLINK         },
1086         { NFSERR_NAMETOOLONG,   -ENAMETOOLONG   },
1087         { NFSERR_NOTEMPTY,      -ENOTEMPTY      },
1088         { NFSERR_DQUOT,         -EDQUOT         },
1089         { NFSERR_STALE,         -ESTALE         },
1090         { NFSERR_REMOTE,        -EREMOTE        },
1091 #ifdef EWFLUSH
1092         { NFSERR_WFLUSH,        -EWFLUSH        },
1093 #endif
1094         { NFSERR_BADHANDLE,     -EBADHANDLE     },
1095         { NFSERR_NOT_SYNC,      -ENOTSYNC       },
1096         { NFSERR_BAD_COOKIE,    -EBADCOOKIE     },
1097         { NFSERR_NOTSUPP,       -ENOTSUPP       },
1098         { NFSERR_TOOSMALL,      -ETOOSMALL      },
1099         { NFSERR_SERVERFAULT,   -EREMOTEIO      },
1100         { NFSERR_BADTYPE,       -EBADTYPE       },
1101         { NFSERR_JUKEBOX,       -EJUKEBOX       },
1102         { -1,                   -EIO            }
1103 };
1104
1105 /**
1106  * nfs_stat_to_errno - convert an NFS status code to a local errno
1107  * @status: NFS status code to convert
1108  *
1109  * Returns a local errno value, or -EIO if the NFS status code is
1110  * not recognized.  This function is used jointly by NFSv2 and NFSv3.
1111  */
1112 int nfs_stat_to_errno(enum nfs_stat status)
1113 {
1114         int i;
1115
1116         for (i = 0; nfs_errtbl[i].stat != -1; i++) {
1117                 if (nfs_errtbl[i].stat == (int)status)
1118                         return nfs_errtbl[i].errno;
1119         }
1120         dprintk("NFS: Unrecognized nfs status value: %u\n", status);
1121         return nfs_errtbl[i].errno;
1122 }
1123
1124 #define PROC(proc, argtype, restype, timer)                             \
1125 [NFSPROC_##proc] = {                                                    \
1126         .p_proc     =  NFSPROC_##proc,                                  \
1127         .p_encode   =  (kxdreproc_t)nfs2_xdr_enc_##argtype,             \
1128         .p_decode   =  (kxdrdproc_t)nfs2_xdr_dec_##restype,             \
1129         .p_arglen   =  NFS_##argtype##_sz,                              \
1130         .p_replen   =  NFS_##restype##_sz,                              \
1131         .p_timer    =  timer,                                           \
1132         .p_statidx  =  NFSPROC_##proc,                                  \
1133         .p_name     =  #proc,                                           \
1134         }
1135 struct rpc_procinfo     nfs_procedures[] = {
1136         PROC(GETATTR,   fhandle,        attrstat,       1),
1137         PROC(SETATTR,   sattrargs,      attrstat,       0),
1138         PROC(LOOKUP,    diropargs,      diropres,       2),
1139         PROC(READLINK,  readlinkargs,   readlinkres,    3),
1140         PROC(READ,      readargs,       readres,        3),
1141         PROC(WRITE,     writeargs,      writeres,       4),
1142         PROC(CREATE,    createargs,     diropres,       0),
1143         PROC(REMOVE,    removeargs,     stat,           0),
1144         PROC(RENAME,    renameargs,     stat,           0),
1145         PROC(LINK,      linkargs,       stat,           0),
1146         PROC(SYMLINK,   symlinkargs,    stat,           0),
1147         PROC(MKDIR,     createargs,     diropres,       0),
1148         PROC(RMDIR,     diropargs,      stat,           0),
1149         PROC(READDIR,   readdirargs,    readdirres,     3),
1150         PROC(STATFS,    fhandle,        statfsres,      0),
1151 };
1152
1153 struct rpc_version              nfs_version2 = {
1154         .number                 = 2,
1155         .nrprocs                = ARRAY_SIZE(nfs_procedures),
1156         .procs                  = nfs_procedures
1157 };