Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jbarnes...
[pandora-kernel.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  * Common NFS XDR functions as inlines
66  */
67 static inline __be32 *
68 xdr_encode_fhandle(__be32 *p, const struct nfs_fh *fhandle)
69 {
70         memcpy(p, fhandle->data, NFS2_FHSIZE);
71         return p + XDR_QUADLEN(NFS2_FHSIZE);
72 }
73
74 static inline __be32 *
75 xdr_decode_fhandle(__be32 *p, struct nfs_fh *fhandle)
76 {
77         /* NFSv2 handles have a fixed length */
78         fhandle->size = NFS2_FHSIZE;
79         memcpy(fhandle->data, p, NFS2_FHSIZE);
80         return p + XDR_QUADLEN(NFS2_FHSIZE);
81 }
82
83 static inline __be32*
84 xdr_encode_time(__be32 *p, struct timespec *timep)
85 {
86         *p++ = htonl(timep->tv_sec);
87         /* Convert nanoseconds into microseconds */
88         *p++ = htonl(timep->tv_nsec ? timep->tv_nsec / 1000 : 0);
89         return p;
90 }
91
92 static inline __be32*
93 xdr_encode_current_server_time(__be32 *p, struct timespec *timep)
94 {
95         /*
96          * Passing the invalid value useconds=1000000 is a
97          * Sun convention for "set to current server time".
98          * It's needed to make permissions checks for the
99          * "touch" program across v2 mounts to Solaris and
100          * Irix boxes work correctly. See description of
101          * sattr in section 6.1 of "NFS Illustrated" by
102          * Brent Callaghan, Addison-Wesley, ISBN 0-201-32750-5
103          */
104         *p++ = htonl(timep->tv_sec);
105         *p++ = htonl(1000000);
106         return p;
107 }
108
109 static inline __be32*
110 xdr_decode_time(__be32 *p, struct timespec *timep)
111 {
112         timep->tv_sec = ntohl(*p++);
113         /* Convert microseconds into nanoseconds */
114         timep->tv_nsec = ntohl(*p++) * 1000;
115         return p;
116 }
117
118 static __be32 *
119 xdr_decode_fattr(__be32 *p, struct nfs_fattr *fattr)
120 {
121         u32 rdev, type;
122         type = ntohl(*p++);
123         fattr->mode = ntohl(*p++);
124         fattr->nlink = ntohl(*p++);
125         fattr->uid = ntohl(*p++);
126         fattr->gid = ntohl(*p++);
127         fattr->size = ntohl(*p++);
128         fattr->du.nfs2.blocksize = ntohl(*p++);
129         rdev = ntohl(*p++);
130         fattr->du.nfs2.blocks = ntohl(*p++);
131         fattr->fsid.major = ntohl(*p++);
132         fattr->fsid.minor = 0;
133         fattr->fileid = ntohl(*p++);
134         p = xdr_decode_time(p, &fattr->atime);
135         p = xdr_decode_time(p, &fattr->mtime);
136         p = xdr_decode_time(p, &fattr->ctime);
137         fattr->valid |= NFS_ATTR_FATTR_V2;
138         fattr->rdev = new_decode_dev(rdev);
139         if (type == NFCHR && rdev == NFS2_FIFO_DEV) {
140                 fattr->mode = (fattr->mode & ~S_IFMT) | S_IFIFO;
141                 fattr->rdev = 0;
142         }
143         return p;
144 }
145
146 static inline __be32 *
147 xdr_encode_sattr(__be32 *p, struct iattr *attr)
148 {
149         const __be32 not_set = __constant_htonl(0xFFFFFFFF);
150
151         *p++ = (attr->ia_valid & ATTR_MODE) ? htonl(attr->ia_mode) : not_set;
152         *p++ = (attr->ia_valid & ATTR_UID) ? htonl(attr->ia_uid) : not_set;
153         *p++ = (attr->ia_valid & ATTR_GID) ? htonl(attr->ia_gid) : not_set;
154         *p++ = (attr->ia_valid & ATTR_SIZE) ? htonl(attr->ia_size) : not_set;
155
156         if (attr->ia_valid & ATTR_ATIME_SET) {
157                 p = xdr_encode_time(p, &attr->ia_atime);
158         } else if (attr->ia_valid & ATTR_ATIME) {
159                 p = xdr_encode_current_server_time(p, &attr->ia_atime);
160         } else {
161                 *p++ = not_set;
162                 *p++ = not_set;
163         }
164
165         if (attr->ia_valid & ATTR_MTIME_SET) {
166                 p = xdr_encode_time(p, &attr->ia_mtime);
167         } else if (attr->ia_valid & ATTR_MTIME) {
168                 p = xdr_encode_current_server_time(p, &attr->ia_mtime);
169         } else {
170                 *p++ = not_set; 
171                 *p++ = not_set;
172         }
173         return p;
174 }
175
176 /*
177  * NFS encode functions
178  */
179 /*
180  * Encode file handle argument
181  * GETATTR, READLINK, STATFS
182  */
183 static int
184 nfs_xdr_fhandle(struct rpc_rqst *req, __be32 *p, struct nfs_fh *fh)
185 {
186         p = xdr_encode_fhandle(p, fh);
187         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
188         return 0;
189 }
190
191 /*
192  * Encode SETATTR arguments
193  */
194 static int
195 nfs_xdr_sattrargs(struct rpc_rqst *req, __be32 *p, struct nfs_sattrargs *args)
196 {
197         p = xdr_encode_fhandle(p, args->fh);
198         p = xdr_encode_sattr(p, args->sattr);
199         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
200         return 0;
201 }
202
203 /*
204  * Encode directory ops argument
205  * LOOKUP, RMDIR
206  */
207 static int
208 nfs_xdr_diropargs(struct rpc_rqst *req, __be32 *p, struct nfs_diropargs *args)
209 {
210         p = xdr_encode_fhandle(p, args->fh);
211         p = xdr_encode_array(p, args->name, args->len);
212         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
213         return 0;
214 }
215
216 /*
217  * Encode REMOVE argument
218  */
219 static int
220 nfs_xdr_removeargs(struct rpc_rqst *req, __be32 *p, const struct nfs_removeargs *args)
221 {
222         p = xdr_encode_fhandle(p, args->fh);
223         p = xdr_encode_array(p, args->name.name, args->name.len);
224         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
225         return 0;
226 }
227
228 /*
229  * Arguments to a READ call. Since we read data directly into the page
230  * cache, we also set up the reply iovec here so that iov[1] points
231  * exactly to the page we want to fetch.
232  */
233 static int
234 nfs_xdr_readargs(struct rpc_rqst *req, __be32 *p, struct nfs_readargs *args)
235 {
236         struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
237         unsigned int replen;
238         u32 offset = (u32)args->offset;
239         u32 count = args->count;
240
241         p = xdr_encode_fhandle(p, args->fh);
242         *p++ = htonl(offset);
243         *p++ = htonl(count);
244         *p++ = htonl(count);
245         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
246
247         /* Inline the page array */
248         replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readres_sz) << 2;
249         xdr_inline_pages(&req->rq_rcv_buf, replen,
250                          args->pages, args->pgbase, count);
251         req->rq_rcv_buf.flags |= XDRBUF_READ;
252         return 0;
253 }
254
255 /*
256  * Decode READ reply
257  */
258 static int
259 nfs_xdr_readres(struct rpc_rqst *req, __be32 *p, struct nfs_readres *res)
260 {
261         struct kvec *iov = req->rq_rcv_buf.head;
262         size_t hdrlen;
263         u32 count, recvd;
264         int status;
265
266         if ((status = ntohl(*p++)))
267                 return nfs_stat_to_errno(status);
268         p = xdr_decode_fattr(p, res->fattr);
269
270         count = ntohl(*p++);
271         res->eof = 0;
272         hdrlen = (u8 *) p - (u8 *) iov->iov_base;
273         if (iov->iov_len < hdrlen) {
274                 dprintk("NFS: READ reply header overflowed:"
275                                 "length %Zu > %Zu\n", hdrlen, iov->iov_len);
276                 return -errno_NFSERR_IO;
277         } else if (iov->iov_len != hdrlen) {
278                 dprintk("NFS: READ header is short. iovec will be shifted.\n");
279                 xdr_shift_buf(&req->rq_rcv_buf, iov->iov_len - hdrlen);
280         }
281
282         recvd = req->rq_rcv_buf.len - hdrlen;
283         if (count > recvd) {
284                 dprintk("NFS: server cheating in read reply: "
285                         "count %u > recvd %u\n", count, recvd);
286                 count = recvd;
287         }
288
289         dprintk("RPC:      readres OK count %u\n", count);
290         if (count < res->count)
291                 res->count = count;
292
293         return count;
294 }
295
296
297 /*
298  * Write arguments. Splice the buffer to be written into the iovec.
299  */
300 static int
301 nfs_xdr_writeargs(struct rpc_rqst *req, __be32 *p, struct nfs_writeargs *args)
302 {
303         struct xdr_buf *sndbuf = &req->rq_snd_buf;
304         u32 offset = (u32)args->offset;
305         u32 count = args->count;
306
307         p = xdr_encode_fhandle(p, args->fh);
308         *p++ = htonl(offset);
309         *p++ = htonl(offset);
310         *p++ = htonl(count);
311         *p++ = htonl(count);
312         sndbuf->len = xdr_adjust_iovec(sndbuf->head, p);
313
314         /* Copy the page array */
315         xdr_encode_pages(sndbuf, args->pages, args->pgbase, count);
316         sndbuf->flags |= XDRBUF_WRITE;
317         return 0;
318 }
319
320 /*
321  * Encode create arguments
322  * CREATE, MKDIR
323  */
324 static int
325 nfs_xdr_createargs(struct rpc_rqst *req, __be32 *p, struct nfs_createargs *args)
326 {
327         p = xdr_encode_fhandle(p, args->fh);
328         p = xdr_encode_array(p, args->name, args->len);
329         p = xdr_encode_sattr(p, args->sattr);
330         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
331         return 0;
332 }
333
334 /*
335  * Encode RENAME arguments
336  */
337 static int
338 nfs_xdr_renameargs(struct rpc_rqst *req, __be32 *p, struct nfs_renameargs *args)
339 {
340         p = xdr_encode_fhandle(p, args->fromfh);
341         p = xdr_encode_array(p, args->fromname, args->fromlen);
342         p = xdr_encode_fhandle(p, args->tofh);
343         p = xdr_encode_array(p, args->toname, args->tolen);
344         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
345         return 0;
346 }
347
348 /*
349  * Encode LINK arguments
350  */
351 static int
352 nfs_xdr_linkargs(struct rpc_rqst *req, __be32 *p, struct nfs_linkargs *args)
353 {
354         p = xdr_encode_fhandle(p, args->fromfh);
355         p = xdr_encode_fhandle(p, args->tofh);
356         p = xdr_encode_array(p, args->toname, args->tolen);
357         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
358         return 0;
359 }
360
361 /*
362  * Encode SYMLINK arguments
363  */
364 static int
365 nfs_xdr_symlinkargs(struct rpc_rqst *req, __be32 *p, struct nfs_symlinkargs *args)
366 {
367         struct xdr_buf *sndbuf = &req->rq_snd_buf;
368         size_t pad;
369
370         p = xdr_encode_fhandle(p, args->fromfh);
371         p = xdr_encode_array(p, args->fromname, args->fromlen);
372         *p++ = htonl(args->pathlen);
373         sndbuf->len = xdr_adjust_iovec(sndbuf->head, p);
374
375         xdr_encode_pages(sndbuf, args->pages, 0, args->pathlen);
376
377         /*
378          * xdr_encode_pages may have added a few bytes to ensure the
379          * pathname ends on a 4-byte boundary.  Start encoding the
380          * attributes after the pad bytes.
381          */
382         pad = sndbuf->tail->iov_len;
383         if (pad > 0)
384                 p++;
385         p = xdr_encode_sattr(p, args->sattr);
386         sndbuf->len += xdr_adjust_iovec(sndbuf->tail, p) - pad;
387         return 0;
388 }
389
390 /*
391  * Encode arguments to readdir call
392  */
393 static int
394 nfs_xdr_readdirargs(struct rpc_rqst *req, __be32 *p, struct nfs_readdirargs *args)
395 {
396         struct rpc_task *task = req->rq_task;
397         struct rpc_auth *auth = task->tk_msg.rpc_cred->cr_auth;
398         unsigned int replen;
399         u32 count = args->count;
400
401         p = xdr_encode_fhandle(p, args->fh);
402         *p++ = htonl(args->cookie);
403         *p++ = htonl(count); /* see above */
404         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
405
406         /* Inline the page array */
407         replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readdirres_sz) << 2;
408         xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, 0, count);
409         return 0;
410 }
411
412 /*
413  * Decode the result of a readdir call.
414  * We're not really decoding anymore, we just leave the buffer untouched
415  * and only check that it is syntactically correct.
416  * The real decoding happens in nfs_decode_entry below, called directly
417  * from nfs_readdir for each entry.
418  */
419 static int
420 nfs_xdr_readdirres(struct rpc_rqst *req, __be32 *p, void *dummy)
421 {
422         struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
423         struct kvec *iov = rcvbuf->head;
424         struct page **page;
425         size_t hdrlen;
426         unsigned int pglen, recvd;
427         u32 len;
428         int status, nr = 0;
429         __be32 *end, *entry, *kaddr;
430
431         if ((status = ntohl(*p++)))
432                 return nfs_stat_to_errno(status);
433
434         hdrlen = (u8 *) p - (u8 *) iov->iov_base;
435         if (iov->iov_len < hdrlen) {
436                 dprintk("NFS: READDIR reply header overflowed:"
437                                 "length %Zu > %Zu\n", hdrlen, iov->iov_len);
438                 return -errno_NFSERR_IO;
439         } else if (iov->iov_len != hdrlen) {
440                 dprintk("NFS: READDIR header is short. iovec will be shifted.\n");
441                 xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen);
442         }
443
444         pglen = rcvbuf->page_len;
445         recvd = rcvbuf->len - hdrlen;
446         if (pglen > recvd)
447                 pglen = recvd;
448         page = rcvbuf->pages;
449         kaddr = p = kmap_atomic(*page, KM_USER0);
450         end = (__be32 *)((char *)p + pglen);
451         entry = p;
452
453         /* Make sure the packet actually has a value_follows and EOF entry */
454         if ((entry + 1) > end)
455                 goto short_pkt;
456
457         for (; *p++; nr++) {
458                 if (p + 2 > end)
459                         goto short_pkt;
460                 p++; /* fileid */
461                 len = ntohl(*p++);
462                 p += XDR_QUADLEN(len) + 1;      /* name plus cookie */
463                 if (len > NFS2_MAXNAMLEN) {
464                         dprintk("NFS: giant filename in readdir (len 0x%x)!\n",
465                                                 len);
466                         goto err_unmap;
467                 }
468                 if (p + 2 > end)
469                         goto short_pkt;
470                 entry = p;
471         }
472
473         /*
474          * Apparently some server sends responses that are a valid size, but
475          * contain no entries, and have value_follows==0 and EOF==0. For
476          * those, just set the EOF marker.
477          */
478         if (!nr && entry[1] == 0) {
479                 dprintk("NFS: readdir reply truncated!\n");
480                 entry[1] = 1;
481         }
482  out:
483         kunmap_atomic(kaddr, KM_USER0);
484         return nr;
485  short_pkt:
486         /*
487          * When we get a short packet there are 2 possibilities. We can
488          * return an error, or fix up the response to look like a valid
489          * response and return what we have so far. If there are no
490          * entries and the packet was short, then return -EIO. If there
491          * are valid entries in the response, return them and pretend that
492          * the call was successful, but incomplete. The caller can retry the
493          * readdir starting at the last cookie.
494          */
495         entry[0] = entry[1] = 0;
496         if (!nr)
497                 nr = -errno_NFSERR_IO;
498         goto out;
499 err_unmap:
500         nr = -errno_NFSERR_IO;
501         goto out;
502 }
503
504 __be32 *
505 nfs_decode_dirent(__be32 *p, struct nfs_entry *entry, int plus)
506 {
507         if (!*p++) {
508                 if (!*p)
509                         return ERR_PTR(-EAGAIN);
510                 entry->eof = 1;
511                 return ERR_PTR(-EBADCOOKIE);
512         }
513
514         entry->ino        = ntohl(*p++);
515         entry->len        = ntohl(*p++);
516         entry->name       = (const char *) p;
517         p                += XDR_QUADLEN(entry->len);
518         entry->prev_cookie        = entry->cookie;
519         entry->cookie     = ntohl(*p++);
520         entry->eof        = !p[0] && p[1];
521
522         return p;
523 }
524
525 /*
526  * NFS XDR decode functions
527  */
528 /*
529  * Decode simple status reply
530  */
531 static int
532 nfs_xdr_stat(struct rpc_rqst *req, __be32 *p, void *dummy)
533 {
534         int     status;
535
536         if ((status = ntohl(*p++)) != 0)
537                 status = nfs_stat_to_errno(status);
538         return status;
539 }
540
541 /*
542  * Decode attrstat reply
543  * GETATTR, SETATTR, WRITE
544  */
545 static int
546 nfs_xdr_attrstat(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr)
547 {
548         int     status;
549
550         if ((status = ntohl(*p++)))
551                 return nfs_stat_to_errno(status);
552         xdr_decode_fattr(p, fattr);
553         return 0;
554 }
555
556 /*
557  * Decode diropres reply
558  * LOOKUP, CREATE, MKDIR
559  */
560 static int
561 nfs_xdr_diropres(struct rpc_rqst *req, __be32 *p, struct nfs_diropok *res)
562 {
563         int     status;
564
565         if ((status = ntohl(*p++)))
566                 return nfs_stat_to_errno(status);
567         p = xdr_decode_fhandle(p, res->fh);
568         xdr_decode_fattr(p, res->fattr);
569         return 0;
570 }
571
572 /*
573  * Encode READLINK args
574  */
575 static int
576 nfs_xdr_readlinkargs(struct rpc_rqst *req, __be32 *p, struct nfs_readlinkargs *args)
577 {
578         struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
579         unsigned int replen;
580
581         p = xdr_encode_fhandle(p, args->fh);
582         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
583
584         /* Inline the page array */
585         replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readlinkres_sz) << 2;
586         xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, args->pgbase, args->pglen);
587         return 0;
588 }
589
590 /*
591  * Decode READLINK reply
592  */
593 static int
594 nfs_xdr_readlinkres(struct rpc_rqst *req, __be32 *p, void *dummy)
595 {
596         struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
597         struct kvec *iov = rcvbuf->head;
598         size_t hdrlen;
599         u32 len, recvd;
600         char    *kaddr;
601         int     status;
602
603         if ((status = ntohl(*p++)))
604                 return nfs_stat_to_errno(status);
605         /* Convert length of symlink */
606         len = ntohl(*p++);
607         if (len >= rcvbuf->page_len) {
608                 dprintk("nfs: server returned giant symlink!\n");
609                 return -ENAMETOOLONG;
610         }
611         hdrlen = (u8 *) p - (u8 *) iov->iov_base;
612         if (iov->iov_len < hdrlen) {
613                 dprintk("NFS: READLINK reply header overflowed:"
614                                 "length %Zu > %Zu\n", hdrlen, iov->iov_len);
615                 return -errno_NFSERR_IO;
616         } else if (iov->iov_len != hdrlen) {
617                 dprintk("NFS: READLINK header is short. iovec will be shifted.\n");
618                 xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen);
619         }
620         recvd = req->rq_rcv_buf.len - hdrlen;
621         if (recvd < len) {
622                 dprintk("NFS: server cheating in readlink reply: "
623                                 "count %u > recvd %u\n", len, recvd);
624                 return -EIO;
625         }
626
627         /* NULL terminate the string we got */
628         kaddr = (char *)kmap_atomic(rcvbuf->pages[0], KM_USER0);
629         kaddr[len+rcvbuf->page_base] = '\0';
630         kunmap_atomic(kaddr, KM_USER0);
631         return 0;
632 }
633
634 /*
635  * Decode WRITE reply
636  */
637 static int
638 nfs_xdr_writeres(struct rpc_rqst *req, __be32 *p, struct nfs_writeres *res)
639 {
640         res->verf->committed = NFS_FILE_SYNC;
641         return nfs_xdr_attrstat(req, p, res->fattr);
642 }
643
644 /*
645  * Decode STATFS reply
646  */
647 static int
648 nfs_xdr_statfsres(struct rpc_rqst *req, __be32 *p, struct nfs2_fsstat *res)
649 {
650         int     status;
651
652         if ((status = ntohl(*p++)))
653                 return nfs_stat_to_errno(status);
654
655         res->tsize  = ntohl(*p++);
656         res->bsize  = ntohl(*p++);
657         res->blocks = ntohl(*p++);
658         res->bfree  = ntohl(*p++);
659         res->bavail = ntohl(*p++);
660         return 0;
661 }
662
663 /*
664  * We need to translate between nfs status return values and
665  * the local errno values which may not be the same.
666  */
667 static struct {
668         int stat;
669         int errno;
670 } nfs_errtbl[] = {
671         { NFS_OK,               0               },
672         { NFSERR_PERM,          -EPERM          },
673         { NFSERR_NOENT,         -ENOENT         },
674         { NFSERR_IO,            -errno_NFSERR_IO},
675         { NFSERR_NXIO,          -ENXIO          },
676 /*      { NFSERR_EAGAIN,        -EAGAIN         }, */
677         { NFSERR_ACCES,         -EACCES         },
678         { NFSERR_EXIST,         -EEXIST         },
679         { NFSERR_XDEV,          -EXDEV          },
680         { NFSERR_NODEV,         -ENODEV         },
681         { NFSERR_NOTDIR,        -ENOTDIR        },
682         { NFSERR_ISDIR,         -EISDIR         },
683         { NFSERR_INVAL,         -EINVAL         },
684         { NFSERR_FBIG,          -EFBIG          },
685         { NFSERR_NOSPC,         -ENOSPC         },
686         { NFSERR_ROFS,          -EROFS          },
687         { NFSERR_MLINK,         -EMLINK         },
688         { NFSERR_NAMETOOLONG,   -ENAMETOOLONG   },
689         { NFSERR_NOTEMPTY,      -ENOTEMPTY      },
690         { NFSERR_DQUOT,         -EDQUOT         },
691         { NFSERR_STALE,         -ESTALE         },
692         { NFSERR_REMOTE,        -EREMOTE        },
693 #ifdef EWFLUSH
694         { NFSERR_WFLUSH,        -EWFLUSH        },
695 #endif
696         { NFSERR_BADHANDLE,     -EBADHANDLE     },
697         { NFSERR_NOT_SYNC,      -ENOTSYNC       },
698         { NFSERR_BAD_COOKIE,    -EBADCOOKIE     },
699         { NFSERR_NOTSUPP,       -ENOTSUPP       },
700         { NFSERR_TOOSMALL,      -ETOOSMALL      },
701         { NFSERR_SERVERFAULT,   -EREMOTEIO      },
702         { NFSERR_BADTYPE,       -EBADTYPE       },
703         { NFSERR_JUKEBOX,       -EJUKEBOX       },
704         { -1,                   -EIO            }
705 };
706
707 /*
708  * Convert an NFS error code to a local one.
709  * This one is used jointly by NFSv2 and NFSv3.
710  */
711 int
712 nfs_stat_to_errno(int stat)
713 {
714         int i;
715
716         for (i = 0; nfs_errtbl[i].stat != -1; i++) {
717                 if (nfs_errtbl[i].stat == stat)
718                         return nfs_errtbl[i].errno;
719         }
720         dprintk("nfs_stat_to_errno: bad nfs status return value: %d\n", stat);
721         return nfs_errtbl[i].errno;
722 }
723
724 #define PROC(proc, argtype, restype, timer)                             \
725 [NFSPROC_##proc] = {                                                    \
726         .p_proc     =  NFSPROC_##proc,                                  \
727         .p_encode   =  (kxdrproc_t) nfs_xdr_##argtype,                  \
728         .p_decode   =  (kxdrproc_t) nfs_xdr_##restype,                  \
729         .p_arglen   =  NFS_##argtype##_sz,                              \
730         .p_replen   =  NFS_##restype##_sz,                              \
731         .p_timer    =  timer,                                           \
732         .p_statidx  =  NFSPROC_##proc,                                  \
733         .p_name     =  #proc,                                           \
734         }
735 struct rpc_procinfo     nfs_procedures[] = {
736     PROC(GETATTR,       fhandle,        attrstat, 1),
737     PROC(SETATTR,       sattrargs,      attrstat, 0),
738     PROC(LOOKUP,        diropargs,      diropres, 2),
739     PROC(READLINK,      readlinkargs,   readlinkres, 3),
740     PROC(READ,          readargs,       readres, 3),
741     PROC(WRITE,         writeargs,      writeres, 4),
742     PROC(CREATE,        createargs,     diropres, 0),
743     PROC(REMOVE,        removeargs,     stat, 0),
744     PROC(RENAME,        renameargs,     stat, 0),
745     PROC(LINK,          linkargs,       stat, 0),
746     PROC(SYMLINK,       symlinkargs,    stat, 0),
747     PROC(MKDIR,         createargs,     diropres, 0),
748     PROC(RMDIR,         diropargs,      stat, 0),
749     PROC(READDIR,       readdirargs,    readdirres, 3),
750     PROC(STATFS,        fhandle,        statfsres, 0),
751 };
752
753 struct rpc_version              nfs_version2 = {
754         .number                 = 2,
755         .nrprocs                = ARRAY_SIZE(nfs_procedures),
756         .procs                  = nfs_procedures
757 };