1884a3fbb584726b41ca515247510539590a1ff1
[linux-3.10.git] / fs / nfsd / nfs3xdr.c
1 /*
2  * XDR support for nfsd/protocol version 3.
3  *
4  * Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de>
5  *
6  * 2003-08-09 Jamie Lokier: Use htonl() for nanoseconds, not htons()!
7  */
8
9 #include <linux/namei.h>
10 #include <linux/sunrpc/svc_xprt.h>
11 #include "xdr3.h"
12 #include "auth.h"
13 #include "netns.h"
14
15 #define NFSDDBG_FACILITY                NFSDDBG_XDR
16
17
18 /*
19  * Mapping of S_IF* types to NFS file types
20  */
21 static u32      nfs3_ftypes[] = {
22         NF3NON,  NF3FIFO, NF3CHR, NF3BAD,
23         NF3DIR,  NF3BAD,  NF3BLK, NF3BAD,
24         NF3REG,  NF3BAD,  NF3LNK, NF3BAD,
25         NF3SOCK, NF3BAD,  NF3LNK, NF3BAD,
26 };
27
28 /*
29  * XDR functions for basic NFS types
30  */
31 static __be32 *
32 encode_time3(__be32 *p, struct timespec *time)
33 {
34         *p++ = htonl((u32) time->tv_sec); *p++ = htonl(time->tv_nsec);
35         return p;
36 }
37
38 static __be32 *
39 decode_time3(__be32 *p, struct timespec *time)
40 {
41         time->tv_sec = ntohl(*p++);
42         time->tv_nsec = ntohl(*p++);
43         return p;
44 }
45
46 static __be32 *
47 decode_fh(__be32 *p, struct svc_fh *fhp)
48 {
49         unsigned int size;
50         fh_init(fhp, NFS3_FHSIZE);
51         size = ntohl(*p++);
52         if (size > NFS3_FHSIZE)
53                 return NULL;
54
55         memcpy(&fhp->fh_handle.fh_base, p, size);
56         fhp->fh_handle.fh_size = size;
57         return p + XDR_QUADLEN(size);
58 }
59
60 /* Helper function for NFSv3 ACL code */
61 __be32 *nfs3svc_decode_fh(__be32 *p, struct svc_fh *fhp)
62 {
63         return decode_fh(p, fhp);
64 }
65
66 static __be32 *
67 encode_fh(__be32 *p, struct svc_fh *fhp)
68 {
69         unsigned int size = fhp->fh_handle.fh_size;
70         *p++ = htonl(size);
71         if (size) p[XDR_QUADLEN(size)-1]=0;
72         memcpy(p, &fhp->fh_handle.fh_base, size);
73         return p + XDR_QUADLEN(size);
74 }
75
76 /*
77  * Decode a file name and make sure that the path contains
78  * no slashes or null bytes.
79  */
80 static __be32 *
81 decode_filename(__be32 *p, char **namp, unsigned int *lenp)
82 {
83         char            *name;
84         unsigned int    i;
85
86         if ((p = xdr_decode_string_inplace(p, namp, lenp, NFS3_MAXNAMLEN)) != NULL) {
87                 for (i = 0, name = *namp; i < *lenp; i++, name++) {
88                         if (*name == '\0' || *name == '/')
89                                 return NULL;
90                 }
91         }
92
93         return p;
94 }
95
96 static __be32 *
97 decode_sattr3(__be32 *p, struct iattr *iap)
98 {
99         u32     tmp;
100
101         iap->ia_valid = 0;
102
103         if (*p++) {
104                 iap->ia_valid |= ATTR_MODE;
105                 iap->ia_mode = ntohl(*p++);
106         }
107         if (*p++) {
108                 iap->ia_valid |= ATTR_UID;
109                 iap->ia_uid = ntohl(*p++);
110         }
111         if (*p++) {
112                 iap->ia_valid |= ATTR_GID;
113                 iap->ia_gid = ntohl(*p++);
114         }
115         if (*p++) {
116                 u64     newsize;
117
118                 iap->ia_valid |= ATTR_SIZE;
119                 p = xdr_decode_hyper(p, &newsize);
120                 if (newsize <= NFS_OFFSET_MAX)
121                         iap->ia_size = newsize;
122                 else
123                         iap->ia_size = NFS_OFFSET_MAX;
124         }
125         if ((tmp = ntohl(*p++)) == 1) { /* set to server time */
126                 iap->ia_valid |= ATTR_ATIME;
127         } else if (tmp == 2) {          /* set to client time */
128                 iap->ia_valid |= ATTR_ATIME | ATTR_ATIME_SET;
129                 iap->ia_atime.tv_sec = ntohl(*p++);
130                 iap->ia_atime.tv_nsec = ntohl(*p++);
131         }
132         if ((tmp = ntohl(*p++)) == 1) { /* set to server time */
133                 iap->ia_valid |= ATTR_MTIME;
134         } else if (tmp == 2) {          /* set to client time */
135                 iap->ia_valid |= ATTR_MTIME | ATTR_MTIME_SET;
136                 iap->ia_mtime.tv_sec = ntohl(*p++);
137                 iap->ia_mtime.tv_nsec = ntohl(*p++);
138         }
139         return p;
140 }
141
142 static __be32 *encode_fsid(__be32 *p, struct svc_fh *fhp)
143 {
144         u64 f;
145         switch(fsid_source(fhp)) {
146         default:
147         case FSIDSOURCE_DEV:
148                 p = xdr_encode_hyper(p, (u64)huge_encode_dev
149                                      (fhp->fh_dentry->d_inode->i_sb->s_dev));
150                 break;
151         case FSIDSOURCE_FSID:
152                 p = xdr_encode_hyper(p, (u64) fhp->fh_export->ex_fsid);
153                 break;
154         case FSIDSOURCE_UUID:
155                 f = ((u64*)fhp->fh_export->ex_uuid)[0];
156                 f ^= ((u64*)fhp->fh_export->ex_uuid)[1];
157                 p = xdr_encode_hyper(p, f);
158                 break;
159         }
160         return p;
161 }
162
163 static __be32 *
164 encode_fattr3(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp,
165               struct kstat *stat)
166 {
167         *p++ = htonl(nfs3_ftypes[(stat->mode & S_IFMT) >> 12]);
168         *p++ = htonl((u32) stat->mode);
169         *p++ = htonl((u32) stat->nlink);
170         *p++ = htonl((u32) stat->uid);
171         *p++ = htonl((u32) stat->gid);
172         if (S_ISLNK(stat->mode) && stat->size > NFS3_MAXPATHLEN) {
173                 p = xdr_encode_hyper(p, (u64) NFS3_MAXPATHLEN);
174         } else {
175                 p = xdr_encode_hyper(p, (u64) stat->size);
176         }
177         p = xdr_encode_hyper(p, ((u64)stat->blocks) << 9);
178         *p++ = htonl((u32) MAJOR(stat->rdev));
179         *p++ = htonl((u32) MINOR(stat->rdev));
180         p = encode_fsid(p, fhp);
181         p = xdr_encode_hyper(p, stat->ino);
182         p = encode_time3(p, &stat->atime);
183         p = encode_time3(p, &stat->mtime);
184         p = encode_time3(p, &stat->ctime);
185
186         return p;
187 }
188
189 static __be32 *
190 encode_saved_post_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
191 {
192         /* Attributes to follow */
193         *p++ = xdr_one;
194         return encode_fattr3(rqstp, p, fhp, &fhp->fh_post_attr);
195 }
196
197 /*
198  * Encode post-operation attributes.
199  * The inode may be NULL if the call failed because of a stale file
200  * handle. In this case, no attributes are returned.
201  */
202 static __be32 *
203 encode_post_op_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
204 {
205         struct dentry *dentry = fhp->fh_dentry;
206         if (dentry && dentry->d_inode) {
207                 int err;
208                 struct kstat stat;
209
210                 err = vfs_getattr(fhp->fh_export->ex_path.mnt, dentry, &stat);
211                 if (!err) {
212                         *p++ = xdr_one;         /* attributes follow */
213                         lease_get_mtime(dentry->d_inode, &stat.mtime);
214                         return encode_fattr3(rqstp, p, fhp, &stat);
215                 }
216         }
217         *p++ = xdr_zero;
218         return p;
219 }
220
221 /* Helper for NFSv3 ACLs */
222 __be32 *
223 nfs3svc_encode_post_op_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
224 {
225         return encode_post_op_attr(rqstp, p, fhp);
226 }
227
228 /*
229  * Enocde weak cache consistency data
230  */
231 static __be32 *
232 encode_wcc_data(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
233 {
234         struct dentry   *dentry = fhp->fh_dentry;
235
236         if (dentry && dentry->d_inode && fhp->fh_post_saved) {
237                 if (fhp->fh_pre_saved) {
238                         *p++ = xdr_one;
239                         p = xdr_encode_hyper(p, (u64) fhp->fh_pre_size);
240                         p = encode_time3(p, &fhp->fh_pre_mtime);
241                         p = encode_time3(p, &fhp->fh_pre_ctime);
242                 } else {
243                         *p++ = xdr_zero;
244                 }
245                 return encode_saved_post_attr(rqstp, p, fhp);
246         }
247         /* no pre- or post-attrs */
248         *p++ = xdr_zero;
249         return encode_post_op_attr(rqstp, p, fhp);
250 }
251
252 /*
253  * Fill in the post_op attr for the wcc data
254  */
255 void fill_post_wcc(struct svc_fh *fhp)
256 {
257         int err;
258
259         if (fhp->fh_post_saved)
260                 printk("nfsd: inode locked twice during operation.\n");
261
262         err = vfs_getattr(fhp->fh_export->ex_path.mnt, fhp->fh_dentry,
263                         &fhp->fh_post_attr);
264         fhp->fh_post_change = fhp->fh_dentry->d_inode->i_version;
265         if (err) {
266                 fhp->fh_post_saved = 0;
267                 /* Grab the ctime anyway - set_change_info might use it */
268                 fhp->fh_post_attr.ctime = fhp->fh_dentry->d_inode->i_ctime;
269         } else
270                 fhp->fh_post_saved = 1;
271 }
272
273 /*
274  * XDR decode functions
275  */
276 int
277 nfs3svc_decode_fhandle(struct svc_rqst *rqstp, __be32 *p, struct nfsd_fhandle *args)
278 {
279         if (!(p = decode_fh(p, &args->fh)))
280                 return 0;
281         return xdr_argsize_check(rqstp, p);
282 }
283
284 int
285 nfs3svc_decode_sattrargs(struct svc_rqst *rqstp, __be32 *p,
286                                         struct nfsd3_sattrargs *args)
287 {
288         if (!(p = decode_fh(p, &args->fh)))
289                 return 0;
290         p = decode_sattr3(p, &args->attrs);
291
292         if ((args->check_guard = ntohl(*p++)) != 0) { 
293                 struct timespec time; 
294                 p = decode_time3(p, &time);
295                 args->guardtime = time.tv_sec;
296         }
297
298         return xdr_argsize_check(rqstp, p);
299 }
300
301 int
302 nfs3svc_decode_diropargs(struct svc_rqst *rqstp, __be32 *p,
303                                         struct nfsd3_diropargs *args)
304 {
305         if (!(p = decode_fh(p, &args->fh))
306          || !(p = decode_filename(p, &args->name, &args->len)))
307                 return 0;
308
309         return xdr_argsize_check(rqstp, p);
310 }
311
312 int
313 nfs3svc_decode_accessargs(struct svc_rqst *rqstp, __be32 *p,
314                                         struct nfsd3_accessargs *args)
315 {
316         if (!(p = decode_fh(p, &args->fh)))
317                 return 0;
318         args->access = ntohl(*p++);
319
320         return xdr_argsize_check(rqstp, p);
321 }
322
323 int
324 nfs3svc_decode_readargs(struct svc_rqst *rqstp, __be32 *p,
325                                         struct nfsd3_readargs *args)
326 {
327         unsigned int len;
328         int v;
329         u32 max_blocksize = svc_max_payload(rqstp);
330
331         if (!(p = decode_fh(p, &args->fh)))
332                 return 0;
333         p = xdr_decode_hyper(p, &args->offset);
334
335         len = args->count = ntohl(*p++);
336
337         if (len > max_blocksize)
338                 len = max_blocksize;
339
340         /* set up the kvec */
341         v=0;
342         while (len > 0) {
343                 struct page *p = *(rqstp->rq_next_page++);
344
345                 rqstp->rq_vec[v].iov_base = page_address(p);
346                 rqstp->rq_vec[v].iov_len = len < PAGE_SIZE? len : PAGE_SIZE;
347                 len -= rqstp->rq_vec[v].iov_len;
348                 v++;
349         }
350         args->vlen = v;
351         return xdr_argsize_check(rqstp, p);
352 }
353
354 int
355 nfs3svc_decode_writeargs(struct svc_rqst *rqstp, __be32 *p,
356                                         struct nfsd3_writeargs *args)
357 {
358         unsigned int len, v, hdr, dlen;
359         u32 max_blocksize = svc_max_payload(rqstp);
360
361         if (!(p = decode_fh(p, &args->fh)))
362                 return 0;
363         p = xdr_decode_hyper(p, &args->offset);
364
365         args->count = ntohl(*p++);
366         args->stable = ntohl(*p++);
367         len = args->len = ntohl(*p++);
368         /*
369          * The count must equal the amount of data passed.
370          */
371         if (args->count != args->len)
372                 return 0;
373
374         /*
375          * Check to make sure that we got the right number of
376          * bytes.
377          */
378         hdr = (void*)p - rqstp->rq_arg.head[0].iov_base;
379         dlen = rqstp->rq_arg.head[0].iov_len + rqstp->rq_arg.page_len
380                 - hdr;
381         /*
382          * Round the length of the data which was specified up to
383          * the next multiple of XDR units and then compare that
384          * against the length which was actually received.
385          * Note that when RPCSEC/GSS (for example) is used, the
386          * data buffer can be padded so dlen might be larger
387          * than required.  It must never be smaller.
388          */
389         if (dlen < XDR_QUADLEN(len)*4)
390                 return 0;
391
392         if (args->count > max_blocksize) {
393                 args->count = max_blocksize;
394                 len = args->len = max_blocksize;
395         }
396         rqstp->rq_vec[0].iov_base = (void*)p;
397         rqstp->rq_vec[0].iov_len = rqstp->rq_arg.head[0].iov_len - hdr;
398         v = 0;
399         while (len > rqstp->rq_vec[v].iov_len) {
400                 len -= rqstp->rq_vec[v].iov_len;
401                 v++;
402                 rqstp->rq_vec[v].iov_base = page_address(rqstp->rq_pages[v]);
403                 rqstp->rq_vec[v].iov_len = PAGE_SIZE;
404         }
405         rqstp->rq_vec[v].iov_len = len;
406         args->vlen = v + 1;
407         return 1;
408 }
409
410 int
411 nfs3svc_decode_createargs(struct svc_rqst *rqstp, __be32 *p,
412                                         struct nfsd3_createargs *args)
413 {
414         if (!(p = decode_fh(p, &args->fh))
415          || !(p = decode_filename(p, &args->name, &args->len)))
416                 return 0;
417
418         switch (args->createmode = ntohl(*p++)) {
419         case NFS3_CREATE_UNCHECKED:
420         case NFS3_CREATE_GUARDED:
421                 p = decode_sattr3(p, &args->attrs);
422                 break;
423         case NFS3_CREATE_EXCLUSIVE:
424                 args->verf = p;
425                 p += 2;
426                 break;
427         default:
428                 return 0;
429         }
430
431         return xdr_argsize_check(rqstp, p);
432 }
433 int
434 nfs3svc_decode_mkdirargs(struct svc_rqst *rqstp, __be32 *p,
435                                         struct nfsd3_createargs *args)
436 {
437         if (!(p = decode_fh(p, &args->fh)) ||
438             !(p = decode_filename(p, &args->name, &args->len)))
439                 return 0;
440         p = decode_sattr3(p, &args->attrs);
441
442         return xdr_argsize_check(rqstp, p);
443 }
444
445 int
446 nfs3svc_decode_symlinkargs(struct svc_rqst *rqstp, __be32 *p,
447                                         struct nfsd3_symlinkargs *args)
448 {
449         unsigned int len, avail;
450         char *old, *new;
451         struct kvec *vec;
452
453         if (!(p = decode_fh(p, &args->ffh)) ||
454             !(p = decode_filename(p, &args->fname, &args->flen))
455                 )
456                 return 0;
457         p = decode_sattr3(p, &args->attrs);
458
459         /* now decode the pathname, which might be larger than the first page.
460          * As we have to check for nul's anyway, we copy it into a new page
461          * This page appears in the rq_res.pages list, but as pages_len is always
462          * 0, it won't get in the way
463          */
464         len = ntohl(*p++);
465         if (len == 0 || len > NFS3_MAXPATHLEN || len >= PAGE_SIZE)
466                 return 0;
467         args->tname = new = page_address(*(rqstp->rq_next_page++));
468         args->tlen = len;
469         /* first copy and check from the first page */
470         old = (char*)p;
471         vec = &rqstp->rq_arg.head[0];
472         avail = vec->iov_len - (old - (char*)vec->iov_base);
473         while (len && avail && *old) {
474                 *new++ = *old++;
475                 len--;
476                 avail--;
477         }
478         /* now copy next page if there is one */
479         if (len && !avail && rqstp->rq_arg.page_len) {
480                 avail = rqstp->rq_arg.page_len;
481                 if (avail > PAGE_SIZE)
482                         avail = PAGE_SIZE;
483                 old = page_address(rqstp->rq_arg.pages[0]);
484         }
485         while (len && avail && *old) {
486                 *new++ = *old++;
487                 len--;
488                 avail--;
489         }
490         *new = '\0';
491         if (len)
492                 return 0;
493
494         return 1;
495 }
496
497 int
498 nfs3svc_decode_mknodargs(struct svc_rqst *rqstp, __be32 *p,
499                                         struct nfsd3_mknodargs *args)
500 {
501         if (!(p = decode_fh(p, &args->fh))
502          || !(p = decode_filename(p, &args->name, &args->len)))
503                 return 0;
504
505         args->ftype = ntohl(*p++);
506
507         if (args->ftype == NF3BLK  || args->ftype == NF3CHR
508          || args->ftype == NF3SOCK || args->ftype == NF3FIFO)
509                 p = decode_sattr3(p, &args->attrs);
510
511         if (args->ftype == NF3BLK || args->ftype == NF3CHR) {
512                 args->major = ntohl(*p++);
513                 args->minor = ntohl(*p++);
514         }
515
516         return xdr_argsize_check(rqstp, p);
517 }
518
519 int
520 nfs3svc_decode_renameargs(struct svc_rqst *rqstp, __be32 *p,
521                                         struct nfsd3_renameargs *args)
522 {
523         if (!(p = decode_fh(p, &args->ffh))
524          || !(p = decode_filename(p, &args->fname, &args->flen))
525          || !(p = decode_fh(p, &args->tfh))
526          || !(p = decode_filename(p, &args->tname, &args->tlen)))
527                 return 0;
528
529         return xdr_argsize_check(rqstp, p);
530 }
531
532 int
533 nfs3svc_decode_readlinkargs(struct svc_rqst *rqstp, __be32 *p,
534                                         struct nfsd3_readlinkargs *args)
535 {
536         if (!(p = decode_fh(p, &args->fh)))
537                 return 0;
538         args->buffer = page_address(*(rqstp->rq_next_page++));
539
540         return xdr_argsize_check(rqstp, p);
541 }
542
543 int
544 nfs3svc_decode_linkargs(struct svc_rqst *rqstp, __be32 *p,
545                                         struct nfsd3_linkargs *args)
546 {
547         if (!(p = decode_fh(p, &args->ffh))
548          || !(p = decode_fh(p, &args->tfh))
549          || !(p = decode_filename(p, &args->tname, &args->tlen)))
550                 return 0;
551
552         return xdr_argsize_check(rqstp, p);
553 }
554
555 int
556 nfs3svc_decode_readdirargs(struct svc_rqst *rqstp, __be32 *p,
557                                         struct nfsd3_readdirargs *args)
558 {
559         if (!(p = decode_fh(p, &args->fh)))
560                 return 0;
561         p = xdr_decode_hyper(p, &args->cookie);
562         args->verf   = p; p += 2;
563         args->dircount = ~0;
564         args->count  = ntohl(*p++);
565
566         if (args->count > PAGE_SIZE)
567                 args->count = PAGE_SIZE;
568
569         args->buffer = page_address(*(rqstp->rq_next_page++));
570
571         return xdr_argsize_check(rqstp, p);
572 }
573
574 int
575 nfs3svc_decode_readdirplusargs(struct svc_rqst *rqstp, __be32 *p,
576                                         struct nfsd3_readdirargs *args)
577 {
578         int len;
579         u32 max_blocksize = svc_max_payload(rqstp);
580
581         if (!(p = decode_fh(p, &args->fh)))
582                 return 0;
583         p = xdr_decode_hyper(p, &args->cookie);
584         args->verf     = p; p += 2;
585         args->dircount = ntohl(*p++);
586         args->count    = ntohl(*p++);
587
588         len = (args->count > max_blocksize) ? max_blocksize :
589                                                   args->count;
590         args->count = len;
591
592         while (len > 0) {
593                 struct page *p = *(rqstp->rq_next_page++);
594                 if (!args->buffer)
595                         args->buffer = page_address(p);
596                 len -= PAGE_SIZE;
597         }
598
599         return xdr_argsize_check(rqstp, p);
600 }
601
602 int
603 nfs3svc_decode_commitargs(struct svc_rqst *rqstp, __be32 *p,
604                                         struct nfsd3_commitargs *args)
605 {
606         if (!(p = decode_fh(p, &args->fh)))
607                 return 0;
608         p = xdr_decode_hyper(p, &args->offset);
609         args->count = ntohl(*p++);
610
611         return xdr_argsize_check(rqstp, p);
612 }
613
614 /*
615  * XDR encode functions
616  */
617 /*
618  * There must be an encoding function for void results so svc_process
619  * will work properly.
620  */
621 int
622 nfs3svc_encode_voidres(struct svc_rqst *rqstp, __be32 *p, void *dummy)
623 {
624         return xdr_ressize_check(rqstp, p);
625 }
626
627 /* GETATTR */
628 int
629 nfs3svc_encode_attrstat(struct svc_rqst *rqstp, __be32 *p,
630                                         struct nfsd3_attrstat *resp)
631 {
632         if (resp->status == 0) {
633                 lease_get_mtime(resp->fh.fh_dentry->d_inode,
634                                 &resp->stat.mtime);
635                 p = encode_fattr3(rqstp, p, &resp->fh, &resp->stat);
636         }
637         return xdr_ressize_check(rqstp, p);
638 }
639
640 /* SETATTR, REMOVE, RMDIR */
641 int
642 nfs3svc_encode_wccstat(struct svc_rqst *rqstp, __be32 *p,
643                                         struct nfsd3_attrstat *resp)
644 {
645         p = encode_wcc_data(rqstp, p, &resp->fh);
646         return xdr_ressize_check(rqstp, p);
647 }
648
649 /* LOOKUP */
650 int
651 nfs3svc_encode_diropres(struct svc_rqst *rqstp, __be32 *p,
652                                         struct nfsd3_diropres *resp)
653 {
654         if (resp->status == 0) {
655                 p = encode_fh(p, &resp->fh);
656                 p = encode_post_op_attr(rqstp, p, &resp->fh);
657         }
658         p = encode_post_op_attr(rqstp, p, &resp->dirfh);
659         return xdr_ressize_check(rqstp, p);
660 }
661
662 /* ACCESS */
663 int
664 nfs3svc_encode_accessres(struct svc_rqst *rqstp, __be32 *p,
665                                         struct nfsd3_accessres *resp)
666 {
667         p = encode_post_op_attr(rqstp, p, &resp->fh);
668         if (resp->status == 0)
669                 *p++ = htonl(resp->access);
670         return xdr_ressize_check(rqstp, p);
671 }
672
673 /* READLINK */
674 int
675 nfs3svc_encode_readlinkres(struct svc_rqst *rqstp, __be32 *p,
676                                         struct nfsd3_readlinkres *resp)
677 {
678         p = encode_post_op_attr(rqstp, p, &resp->fh);
679         if (resp->status == 0) {
680                 *p++ = htonl(resp->len);
681                 xdr_ressize_check(rqstp, p);
682                 rqstp->rq_res.page_len = resp->len;
683                 if (resp->len & 3) {
684                         /* need to pad the tail */
685                         rqstp->rq_res.tail[0].iov_base = p;
686                         *p = 0;
687                         rqstp->rq_res.tail[0].iov_len = 4 - (resp->len&3);
688                 }
689                 return 1;
690         } else
691                 return xdr_ressize_check(rqstp, p);
692 }
693
694 /* READ */
695 int
696 nfs3svc_encode_readres(struct svc_rqst *rqstp, __be32 *p,
697                                         struct nfsd3_readres *resp)
698 {
699         p = encode_post_op_attr(rqstp, p, &resp->fh);
700         if (resp->status == 0) {
701                 *p++ = htonl(resp->count);
702                 *p++ = htonl(resp->eof);
703                 *p++ = htonl(resp->count);      /* xdr opaque count */
704                 xdr_ressize_check(rqstp, p);
705                 /* now update rqstp->rq_res to reflect data as well */
706                 rqstp->rq_res.page_len = resp->count;
707                 if (resp->count & 3) {
708                         /* need to pad the tail */
709                         rqstp->rq_res.tail[0].iov_base = p;
710                         *p = 0;
711                         rqstp->rq_res.tail[0].iov_len = 4 - (resp->count & 3);
712                 }
713                 return 1;
714         } else
715                 return xdr_ressize_check(rqstp, p);
716 }
717
718 /* WRITE */
719 int
720 nfs3svc_encode_writeres(struct svc_rqst *rqstp, __be32 *p,
721                                         struct nfsd3_writeres *resp)
722 {
723         struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
724
725         p = encode_wcc_data(rqstp, p, &resp->fh);
726         if (resp->status == 0) {
727                 *p++ = htonl(resp->count);
728                 *p++ = htonl(resp->committed);
729                 *p++ = htonl(nn->nfssvc_boot.tv_sec);
730                 *p++ = htonl(nn->nfssvc_boot.tv_usec);
731         }
732         return xdr_ressize_check(rqstp, p);
733 }
734
735 /* CREATE, MKDIR, SYMLINK, MKNOD */
736 int
737 nfs3svc_encode_createres(struct svc_rqst *rqstp, __be32 *p,
738                                         struct nfsd3_diropres *resp)
739 {
740         if (resp->status == 0) {
741                 *p++ = xdr_one;
742                 p = encode_fh(p, &resp->fh);
743                 p = encode_post_op_attr(rqstp, p, &resp->fh);
744         }
745         p = encode_wcc_data(rqstp, p, &resp->dirfh);
746         return xdr_ressize_check(rqstp, p);
747 }
748
749 /* RENAME */
750 int
751 nfs3svc_encode_renameres(struct svc_rqst *rqstp, __be32 *p,
752                                         struct nfsd3_renameres *resp)
753 {
754         p = encode_wcc_data(rqstp, p, &resp->ffh);
755         p = encode_wcc_data(rqstp, p, &resp->tfh);
756         return xdr_ressize_check(rqstp, p);
757 }
758
759 /* LINK */
760 int
761 nfs3svc_encode_linkres(struct svc_rqst *rqstp, __be32 *p,
762                                         struct nfsd3_linkres *resp)
763 {
764         p = encode_post_op_attr(rqstp, p, &resp->fh);
765         p = encode_wcc_data(rqstp, p, &resp->tfh);
766         return xdr_ressize_check(rqstp, p);
767 }
768
769 /* READDIR */
770 int
771 nfs3svc_encode_readdirres(struct svc_rqst *rqstp, __be32 *p,
772                                         struct nfsd3_readdirres *resp)
773 {
774         p = encode_post_op_attr(rqstp, p, &resp->fh);
775
776         if (resp->status == 0) {
777                 /* stupid readdir cookie */
778                 memcpy(p, resp->verf, 8); p += 2;
779                 xdr_ressize_check(rqstp, p);
780                 if (rqstp->rq_res.head[0].iov_len + (2<<2) > PAGE_SIZE)
781                         return 1; /*No room for trailer */
782                 rqstp->rq_res.page_len = (resp->count) << 2;
783
784                 /* add the 'tail' to the end of the 'head' page - page 0. */
785                 rqstp->rq_res.tail[0].iov_base = p;
786                 *p++ = 0;               /* no more entries */
787                 *p++ = htonl(resp->common.err == nfserr_eof);
788                 rqstp->rq_res.tail[0].iov_len = 2<<2;
789                 return 1;
790         } else
791                 return xdr_ressize_check(rqstp, p);
792 }
793
794 static __be32 *
795 encode_entry_baggage(struct nfsd3_readdirres *cd, __be32 *p, const char *name,
796              int namlen, u64 ino)
797 {
798         *p++ = xdr_one;                          /* mark entry present */
799         p    = xdr_encode_hyper(p, ino);         /* file id */
800         p    = xdr_encode_array(p, name, namlen);/* name length & name */
801
802         cd->offset = p;                         /* remember pointer */
803         p = xdr_encode_hyper(p, NFS_OFFSET_MAX);/* offset of next entry */
804
805         return p;
806 }
807
808 static __be32
809 compose_entry_fh(struct nfsd3_readdirres *cd, struct svc_fh *fhp,
810                 const char *name, int namlen)
811 {
812         struct svc_export       *exp;
813         struct dentry           *dparent, *dchild;
814         __be32 rv = nfserr_noent;
815
816         dparent = cd->fh.fh_dentry;
817         exp  = cd->fh.fh_export;
818
819         if (isdotent(name, namlen)) {
820                 if (namlen == 2) {
821                         dchild = dget_parent(dparent);
822                         /* filesystem root - cannot return filehandle for ".." */
823                         if (dchild == dparent)
824                                 goto out;
825                 } else
826                         dchild = dget(dparent);
827         } else
828                 dchild = lookup_one_len(name, dparent, namlen);
829         if (IS_ERR(dchild))
830                 return rv;
831         if (d_mountpoint(dchild))
832                 goto out;
833         if (!dchild->d_inode)
834                 goto out;
835         rv = fh_compose(fhp, exp, dchild, &cd->fh);
836 out:
837         dput(dchild);
838         return rv;
839 }
840
841 static __be32 *encode_entryplus_baggage(struct nfsd3_readdirres *cd, __be32 *p, const char *name, int namlen)
842 {
843         struct svc_fh   fh;
844         __be32 err;
845
846         fh_init(&fh, NFS3_FHSIZE);
847         err = compose_entry_fh(cd, &fh, name, namlen);
848         if (err) {
849                 *p++ = 0;
850                 *p++ = 0;
851                 goto out;
852         }
853         p = encode_post_op_attr(cd->rqstp, p, &fh);
854         *p++ = xdr_one;                 /* yes, a file handle follows */
855         p = encode_fh(p, &fh);
856 out:
857         fh_put(&fh);
858         return p;
859 }
860
861 /*
862  * Encode a directory entry. This one works for both normal readdir
863  * and readdirplus.
864  * The normal readdir reply requires 2 (fileid) + 1 (stringlen)
865  * + string + 2 (cookie) + 1 (next) words, i.e. 6 + strlen.
866  * 
867  * The readdirplus baggage is 1+21 words for post_op_attr, plus the
868  * file handle.
869  */
870
871 #define NFS3_ENTRY_BAGGAGE      (2 + 1 + 2 + 1)
872 #define NFS3_ENTRYPLUS_BAGGAGE  (1 + 21 + 1 + (NFS3_FHSIZE >> 2))
873 static int
874 encode_entry(struct readdir_cd *ccd, const char *name, int namlen,
875              loff_t offset, u64 ino, unsigned int d_type, int plus)
876 {
877         struct nfsd3_readdirres *cd = container_of(ccd, struct nfsd3_readdirres,
878                                                         common);
879         __be32          *p = cd->buffer;
880         caddr_t         curr_page_addr = NULL;
881         struct page **  page;
882         int             slen;           /* string (name) length */
883         int             elen;           /* estimated entry length in words */
884         int             num_entry_words = 0;    /* actual number of words */
885
886         if (cd->offset) {
887                 u64 offset64 = offset;
888
889                 if (unlikely(cd->offset1)) {
890                         /* we ended up with offset on a page boundary */
891                         *cd->offset = htonl(offset64 >> 32);
892                         *cd->offset1 = htonl(offset64 & 0xffffffff);
893                         cd->offset1 = NULL;
894                 } else {
895                         xdr_encode_hyper(cd->offset, offset64);
896                 }
897         }
898
899         /*
900         dprintk("encode_entry(%.*s @%ld%s)\n",
901                 namlen, name, (long) offset, plus? " plus" : "");
902          */
903
904         /* truncate filename if too long */
905         if (namlen > NFS3_MAXNAMLEN)
906                 namlen = NFS3_MAXNAMLEN;
907
908         slen = XDR_QUADLEN(namlen);
909         elen = slen + NFS3_ENTRY_BAGGAGE
910                 + (plus? NFS3_ENTRYPLUS_BAGGAGE : 0);
911
912         if (cd->buflen < elen) {
913                 cd->common.err = nfserr_toosmall;
914                 return -EINVAL;
915         }
916
917         /* determine which page in rq_respages[] we are currently filling */
918         for (page = cd->rqstp->rq_respages + 1;
919                                 page < cd->rqstp->rq_next_page; page++) {
920                 curr_page_addr = page_address(*page);
921
922                 if (((caddr_t)cd->buffer >= curr_page_addr) &&
923                     ((caddr_t)cd->buffer <  curr_page_addr + PAGE_SIZE))
924                         break;
925         }
926
927         if ((caddr_t)(cd->buffer + elen) < (curr_page_addr + PAGE_SIZE)) {
928                 /* encode entry in current page */
929
930                 p = encode_entry_baggage(cd, p, name, namlen, ino);
931
932                 if (plus)
933                         p = encode_entryplus_baggage(cd, p, name, namlen);
934                 num_entry_words = p - cd->buffer;
935         } else if (*(page+1) != NULL) {
936                 /* temporarily encode entry into next page, then move back to
937                  * current and next page in rq_respages[] */
938                 __be32 *p1, *tmp;
939                 int len1, len2;
940
941                 /* grab next page for temporary storage of entry */
942                 p1 = tmp = page_address(*(page+1));
943
944                 p1 = encode_entry_baggage(cd, p1, name, namlen, ino);
945
946                 if (plus)
947                         p1 = encode_entryplus_baggage(cd, p1, name, namlen);
948
949                 /* determine entry word length and lengths to go in pages */
950                 num_entry_words = p1 - tmp;
951                 len1 = curr_page_addr + PAGE_SIZE - (caddr_t)cd->buffer;
952                 if ((num_entry_words << 2) < len1) {
953                         /* the actual number of words in the entry is less
954                          * than elen and can still fit in the current page
955                          */
956                         memmove(p, tmp, num_entry_words << 2);
957                         p += num_entry_words;
958
959                         /* update offset */
960                         cd->offset = cd->buffer + (cd->offset - tmp);
961                 } else {
962                         unsigned int offset_r = (cd->offset - tmp) << 2;
963
964                         /* update pointer to offset location.
965                          * This is a 64bit quantity, so we need to
966                          * deal with 3 cases:
967                          *  -   entirely in first page
968                          *  -   entirely in second page
969                          *  -   4 bytes in each page
970                          */
971                         if (offset_r + 8 <= len1) {
972                                 cd->offset = p + (cd->offset - tmp);
973                         } else if (offset_r >= len1) {
974                                 cd->offset -= len1 >> 2;
975                         } else {
976                                 /* sitting on the fence */
977                                 BUG_ON(offset_r != len1 - 4);
978                                 cd->offset = p + (cd->offset - tmp);
979                                 cd->offset1 = tmp;
980                         }
981
982                         len2 = (num_entry_words << 2) - len1;
983
984                         /* move from temp page to current and next pages */
985                         memmove(p, tmp, len1);
986                         memmove(tmp, (caddr_t)tmp+len1, len2);
987
988                         p = tmp + (len2 >> 2);
989                 }
990         }
991         else {
992                 cd->common.err = nfserr_toosmall;
993                 return -EINVAL;
994         }
995
996         cd->buflen -= num_entry_words;
997         cd->buffer = p;
998         cd->common.err = nfs_ok;
999         return 0;
1000
1001 }
1002
1003 int
1004 nfs3svc_encode_entry(void *cd, const char *name,
1005                      int namlen, loff_t offset, u64 ino, unsigned int d_type)
1006 {
1007         return encode_entry(cd, name, namlen, offset, ino, d_type, 0);
1008 }
1009
1010 int
1011 nfs3svc_encode_entry_plus(void *cd, const char *name,
1012                           int namlen, loff_t offset, u64 ino,
1013                           unsigned int d_type)
1014 {
1015         return encode_entry(cd, name, namlen, offset, ino, d_type, 1);
1016 }
1017
1018 /* FSSTAT */
1019 int
1020 nfs3svc_encode_fsstatres(struct svc_rqst *rqstp, __be32 *p,
1021                                         struct nfsd3_fsstatres *resp)
1022 {
1023         struct kstatfs  *s = &resp->stats;
1024         u64             bs = s->f_bsize;
1025
1026         *p++ = xdr_zero;        /* no post_op_attr */
1027
1028         if (resp->status == 0) {
1029                 p = xdr_encode_hyper(p, bs * s->f_blocks);      /* total bytes */
1030                 p = xdr_encode_hyper(p, bs * s->f_bfree);       /* free bytes */
1031                 p = xdr_encode_hyper(p, bs * s->f_bavail);      /* user available bytes */
1032                 p = xdr_encode_hyper(p, s->f_files);    /* total inodes */
1033                 p = xdr_encode_hyper(p, s->f_ffree);    /* free inodes */
1034                 p = xdr_encode_hyper(p, s->f_ffree);    /* user available inodes */
1035                 *p++ = htonl(resp->invarsec);   /* mean unchanged time */
1036         }
1037         return xdr_ressize_check(rqstp, p);
1038 }
1039
1040 /* FSINFO */
1041 int
1042 nfs3svc_encode_fsinfores(struct svc_rqst *rqstp, __be32 *p,
1043                                         struct nfsd3_fsinfores *resp)
1044 {
1045         *p++ = xdr_zero;        /* no post_op_attr */
1046
1047         if (resp->status == 0) {
1048                 *p++ = htonl(resp->f_rtmax);
1049                 *p++ = htonl(resp->f_rtpref);
1050                 *p++ = htonl(resp->f_rtmult);
1051                 *p++ = htonl(resp->f_wtmax);
1052                 *p++ = htonl(resp->f_wtpref);
1053                 *p++ = htonl(resp->f_wtmult);
1054                 *p++ = htonl(resp->f_dtpref);
1055                 p = xdr_encode_hyper(p, resp->f_maxfilesize);
1056                 *p++ = xdr_one;
1057                 *p++ = xdr_zero;
1058                 *p++ = htonl(resp->f_properties);
1059         }
1060
1061         return xdr_ressize_check(rqstp, p);
1062 }
1063
1064 /* PATHCONF */
1065 int
1066 nfs3svc_encode_pathconfres(struct svc_rqst *rqstp, __be32 *p,
1067                                         struct nfsd3_pathconfres *resp)
1068 {
1069         *p++ = xdr_zero;        /* no post_op_attr */
1070
1071         if (resp->status == 0) {
1072                 *p++ = htonl(resp->p_link_max);
1073                 *p++ = htonl(resp->p_name_max);
1074                 *p++ = htonl(resp->p_no_trunc);
1075                 *p++ = htonl(resp->p_chown_restricted);
1076                 *p++ = htonl(resp->p_case_insensitive);
1077                 *p++ = htonl(resp->p_case_preserving);
1078         }
1079
1080         return xdr_ressize_check(rqstp, p);
1081 }
1082
1083 /* COMMIT */
1084 int
1085 nfs3svc_encode_commitres(struct svc_rqst *rqstp, __be32 *p,
1086                                         struct nfsd3_commitres *resp)
1087 {
1088         struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
1089
1090         p = encode_wcc_data(rqstp, p, &resp->fh);
1091         /* Write verifier */
1092         if (resp->status == 0) {
1093                 *p++ = htonl(nn->nfssvc_boot.tv_sec);
1094                 *p++ = htonl(nn->nfssvc_boot.tv_usec);
1095         }
1096         return xdr_ressize_check(rqstp, p);
1097 }
1098
1099 /*
1100  * XDR release functions
1101  */
1102 int
1103 nfs3svc_release_fhandle(struct svc_rqst *rqstp, __be32 *p,
1104                                         struct nfsd3_attrstat *resp)
1105 {
1106         fh_put(&resp->fh);
1107         return 1;
1108 }
1109
1110 int
1111 nfs3svc_release_fhandle2(struct svc_rqst *rqstp, __be32 *p,
1112                                         struct nfsd3_fhandle_pair *resp)
1113 {
1114         fh_put(&resp->fh1);
1115         fh_put(&resp->fh2);
1116         return 1;
1117 }