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

Archive Download this file



interactive