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