1
2
3
4
5
6
7
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
22
23static 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
32
33static __be32 *
34encode_time3(__be32 *p, struct timespec *time)
35{
36 *p++ = htonl((u32) time->tv_sec); *p++ = htonl(time->tv_nsec);
37 return p;
38}
39
40static __be32 *
41decode_time3(__be32 *p, struct timespec *time)
42{
43 time->tv_sec = ntohl(*p++);
44 time->tv_nsec = ntohl(*p++);
45 return p;
46}
47
48static __be32 *
49decode_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
63__be32 *nfs3svc_decode_fh(__be32 *p, struct svc_fh *fhp)
64{
65 return decode_fh(p, fhp);
66}
67
68static __be32 *
69encode_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
80
81
82static __be32 *
83decode_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
98static __be32 *
99decode_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) {
127 iap->ia_valid |= ATTR_ATIME;
128 } else if (tmp == 2) {
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) {
134 iap->ia_valid |= ATTR_MTIME;
135 } else if (tmp == 2) {
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
143static __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
164static __be32 *
165encode_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
190static __be32 *
191encode_saved_post_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
192{
193
194 *p++ = xdr_one;
195 return encode_fattr3(rqstp, p, fhp, &fhp->fh_post_attr);
196}
197
198
199
200
201
202
203static __be32 *
204encode_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;
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
223__be32 *
224nfs3svc_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
231
232static __be32 *
233encode_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
249 *p++ = xdr_zero;
250 return encode_post_op_attr(rqstp, p, fhp);
251}
252
253
254
255
256void 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
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
275
276int
277nfs3svc_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
287int
288nfs3svc_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
306int
307nfs3svc_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
318int
319nfs3svc_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
331int
332nfs3svc_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
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
361int
362nfs3svc_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
382
383 if (args->count != args->len)
384 return 0;
385
386
387
388
389
390 hdr = (void*)p - head->iov_base;
391 dlen = head->iov_len + rqstp->rq_arg.page_len + tail->iov_len - hdr;
392
393
394
395
396
397
398
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
421int
422nfs3svc_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
446int
447nfs3svc_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
459int
460nfs3svc_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
474
475
476
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
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
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
511int
512nfs3svc_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
534int
535nfs3svc_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
548int
549nfs3svc_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
561int
562nfs3svc_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
574int
575nfs3svc_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
591int
592nfs3svc_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
617int
618nfs3svc_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
632
633
634
635
636
637int
638nfs3svc_encode_voidres(struct svc_rqst *rqstp, __be32 *p)
639{
640 return xdr_ressize_check(rqstp, p);
641}
642
643
644int
645nfs3svc_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
658int
659nfs3svc_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
668int
669nfs3svc_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
682int
683nfs3svc_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
694int
695nfs3svc_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
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
716int
717nfs3svc_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);
726 xdr_ressize_check(rqstp, p);
727
728 rqstp->rq_res.page_len = resp->count;
729 if (resp->count & 3) {
730
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
741int
742nfs3svc_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
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
759int
760nfs3svc_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
774int
775nfs3svc_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
785int
786nfs3svc_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
796int
797nfs3svc_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
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;
809 rqstp->rq_res.page_len = (resp->count) << 2;
810
811
812 rqstp->rq_res.tail[0].iov_base = p;
813 *p++ = 0;
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
821static __be32 *
822encode_entry_baggage(struct nfsd3_readdirres *cd, __be32 *p, const char *name,
823 int namlen, u64 ino)
824{
825 *p++ = xdr_one;
826 p = xdr_encode_hyper(p, ino);
827 p = xdr_encode_array(p, name, namlen);
828
829 cd->offset = p;
830 p = xdr_encode_hyper(p, NFS_OFFSET_MAX);
831
832 return p;
833}
834
835static __be32
836compose_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
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);
865out:
866 dput(dchild);
867 return rv;
868}
869
870static __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;
884 p = encode_fh(p, fh);
885out:
886 fh_put(fh);
887 return p;
888}
889
890
891
892
893
894
895
896
897
898
899
900#define NFS3_ENTRY_BAGGAGE (2 + 1 + 2 + 1)
901#define NFS3_ENTRYPLUS_BAGGAGE (1 + 21 + 1 + (NFS3_FHSIZE >> 2))
902static int
903encode_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;
912 int elen;
913 int num_entry_words = 0;
914
915 if (cd->offset) {
916 u64 offset64 = offset;
917
918 if (unlikely(cd->offset1)) {
919
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
930
931
932
933
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
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
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
965
966 __be32 *p1, *tmp;
967 int len1, len2;
968
969
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
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
982
983
984 memmove(p, tmp, num_entry_words << 2);
985 p += num_entry_words;
986
987
988 cd->offset = cd->buffer + (cd->offset - tmp);
989 } else {
990 unsigned int offset_r = (cd->offset - tmp) << 2;
991
992
993
994
995
996
997
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
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
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
1031int
1032nfs3svc_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
1038int
1039nfs3svc_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
1047int
1048nfs3svc_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;
1055
1056 if (resp->status == 0) {
1057 p = xdr_encode_hyper(p, bs * s->f_blocks);
1058 p = xdr_encode_hyper(p, bs * s->f_bfree);
1059 p = xdr_encode_hyper(p, bs * s->f_bavail);
1060 p = xdr_encode_hyper(p, s->f_files);
1061 p = xdr_encode_hyper(p, s->f_ffree);
1062 p = xdr_encode_hyper(p, s->f_ffree);
1063 *p++ = htonl(resp->invarsec);
1064 }
1065 return xdr_ressize_check(rqstp, p);
1066}
1067
1068
1069int
1070nfs3svc_encode_fsinfores(struct svc_rqst *rqstp, __be32 *p)
1071{
1072 struct nfsd3_fsinfores *resp = rqstp->rq_resp;
1073
1074 *p++ = xdr_zero;
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
1094int
1095nfs3svc_encode_pathconfres(struct svc_rqst *rqstp, __be32 *p)
1096{
1097 struct nfsd3_pathconfres *resp = rqstp->rq_resp;
1098
1099 *p++ = xdr_zero;
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
1114int
1115nfs3svc_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
1122 if (resp->status == 0) {
1123
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
1132
1133void
1134nfs3svc_release_fhandle(struct svc_rqst *rqstp)
1135{
1136 struct nfsd3_attrstat *resp = rqstp->rq_resp;
1137
1138 fh_put(&resp->fh);
1139}
1140
1141void
1142nfs3svc_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}
1149