2 * XDR support for nfsd/protocol version 3.
4 * Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de>
6 * 2003-08-09 Jamie Lokier: Use htonl() for nanoseconds, not htons()!
9 #include <linux/namei.h>
13 #define NFSDDBG_FACILITY NFSDDBG_XDR
17 * Mapping of S_IF* types to NFS file types
19 static u32 nfs3_ftypes[] = {
20 NF3NON, NF3FIFO, NF3CHR, NF3BAD,
21 NF3DIR, NF3BAD, NF3BLK, NF3BAD,
22 NF3REG, NF3BAD, NF3LNK, NF3BAD,
23 NF3SOCK, NF3BAD, NF3LNK, NF3BAD,
27 * XDR functions for basic NFS types
30 encode_time3(__be32 *p, struct timespec *time)
32 *p++ = htonl((u32) time->tv_sec); *p++ = htonl(time->tv_nsec);
37 decode_time3(__be32 *p, struct timespec *time)
39 time->tv_sec = ntohl(*p++);
40 time->tv_nsec = ntohl(*p++);
45 decode_fh(__be32 *p, struct svc_fh *fhp)
48 fh_init(fhp, NFS3_FHSIZE);
50 if (size > NFS3_FHSIZE)
53 memcpy(&fhp->fh_handle.fh_base, p, size);
54 fhp->fh_handle.fh_size = size;
55 return p + XDR_QUADLEN(size);
58 /* Helper function for NFSv3 ACL code */
59 __be32 *nfs3svc_decode_fh(__be32 *p, struct svc_fh *fhp)
61 return decode_fh(p, fhp);
65 encode_fh(__be32 *p, struct svc_fh *fhp)
67 unsigned int size = fhp->fh_handle.fh_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);
75 * Decode a file name and make sure that the path contains
76 * no slashes or null bytes.
79 decode_filename(__be32 *p, char **namp, unsigned int *lenp)
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 == '/')
95 decode_sattr3(__be32 *p, struct iattr *iap)
102 iap->ia_valid |= ATTR_MODE;
103 iap->ia_mode = ntohl(*p++);
106 iap->ia_valid |= ATTR_UID;
107 iap->ia_uid = ntohl(*p++);
110 iap->ia_valid |= ATTR_GID;
111 iap->ia_gid = ntohl(*p++);
116 iap->ia_valid |= ATTR_SIZE;
117 p = xdr_decode_hyper(p, &newsize);
118 if (newsize <= NFS_OFFSET_MAX)
119 iap->ia_size = newsize;
121 iap->ia_size = NFS_OFFSET_MAX;
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++);
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++);
140 static __be32 *encode_fsid(__be32 *p, struct svc_fh *fhp)
143 switch(fsid_source(fhp)) {
146 p = xdr_encode_hyper(p, (u64)huge_encode_dev
147 (fhp->fh_dentry->d_inode->i_sb->s_dev));
149 case FSIDSOURCE_FSID:
150 p = xdr_encode_hyper(p, (u64) fhp->fh_export->ex_fsid);
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);
162 encode_fattr3(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp,
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);
173 p = xdr_encode_hyper(p, (u64) stat->size);
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);
188 encode_saved_post_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
190 /* Attributes to follow */
192 return encode_fattr3(rqstp, p, fhp, &fhp->fh_post_attr);
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.
201 encode_post_op_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
203 struct dentry *dentry = fhp->fh_dentry;
204 if (dentry && dentry->d_inode) {
208 err = vfs_getattr(fhp->fh_export->ex_path.mnt, dentry, &stat);
210 *p++ = xdr_one; /* attributes follow */
211 lease_get_mtime(dentry->d_inode, &stat.mtime);
212 return encode_fattr3(rqstp, p, fhp, &stat);
219 /* Helper for NFSv3 ACLs */
221 nfs3svc_encode_post_op_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
223 return encode_post_op_attr(rqstp, p, fhp);
227 * Enocde weak cache consistency data
230 encode_wcc_data(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
232 struct dentry *dentry = fhp->fh_dentry;
234 if (dentry && dentry->d_inode && fhp->fh_post_saved) {
235 if (fhp->fh_pre_saved) {
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);
243 return encode_saved_post_attr(rqstp, p, fhp);
245 /* no pre- or post-attrs */
247 return encode_post_op_attr(rqstp, p, fhp);
251 * Fill in the post_op attr for the wcc data
253 void fill_post_wcc(struct svc_fh *fhp)
257 if (fhp->fh_post_saved)
258 printk("nfsd: inode locked twice during operation.\n");
260 err = vfs_getattr(fhp->fh_export->ex_path.mnt, fhp->fh_dentry,
262 fhp->fh_post_change = fhp->fh_dentry->d_inode->i_version;
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;
268 fhp->fh_post_saved = 1;
272 * XDR decode functions
275 nfs3svc_decode_fhandle(struct svc_rqst *rqstp, __be32 *p, struct nfsd_fhandle *args)
277 if (!(p = decode_fh(p, &args->fh)))
279 return xdr_argsize_check(rqstp, p);
283 nfs3svc_decode_sattrargs(struct svc_rqst *rqstp, __be32 *p,
284 struct nfsd3_sattrargs *args)
286 if (!(p = decode_fh(p, &args->fh)))
288 p = decode_sattr3(p, &args->attrs);
290 if ((args->check_guard = ntohl(*p++)) != 0) {
291 struct timespec time;
292 p = decode_time3(p, &time);
293 args->guardtime = time.tv_sec;
296 return xdr_argsize_check(rqstp, p);
300 nfs3svc_decode_diropargs(struct svc_rqst *rqstp, __be32 *p,
301 struct nfsd3_diropargs *args)
303 if (!(p = decode_fh(p, &args->fh))
304 || !(p = decode_filename(p, &args->name, &args->len)))
307 return xdr_argsize_check(rqstp, p);
311 nfs3svc_decode_accessargs(struct svc_rqst *rqstp, __be32 *p,
312 struct nfsd3_accessargs *args)
314 if (!(p = decode_fh(p, &args->fh)))
316 args->access = ntohl(*p++);
318 return xdr_argsize_check(rqstp, p);
322 nfs3svc_decode_readargs(struct svc_rqst *rqstp, __be32 *p,
323 struct nfsd3_readargs *args)
327 u32 max_blocksize = svc_max_payload(rqstp);
329 if (!(p = decode_fh(p, &args->fh)))
331 p = xdr_decode_hyper(p, &args->offset);
333 len = args->count = ntohl(*p++);
335 if (len > max_blocksize)
338 /* set up the kvec */
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;
348 return xdr_argsize_check(rqstp, p);
352 nfs3svc_decode_writeargs(struct svc_rqst *rqstp, __be32 *p,
353 struct nfsd3_writeargs *args)
355 unsigned int len, v, hdr, dlen;
356 u32 max_blocksize = svc_max_payload(rqstp);
357 struct kvec *head = rqstp->rq_arg.head;
359 if (!(p = decode_fh(p, &args->fh)))
361 p = xdr_decode_hyper(p, &args->offset);
363 args->count = ntohl(*p++);
364 args->stable = ntohl(*p++);
365 len = args->len = ntohl(*p++);
366 if ((void *)p > head->iov_base + head->iov_len)
369 * The count must equal the amount of data passed.
371 if (args->count != args->len)
375 * Check to make sure that we got the right number of
378 hdr = (void*)p - head->iov_base;
379 dlen = head->iov_len + rqstp->rq_arg.page_len - hdr;
381 * Round the length of the data which was specified up to
382 * the next multiple of XDR units and then compare that
383 * against the length which was actually received.
384 * Note that when RPCSEC/GSS (for example) is used, the
385 * data buffer can be padded so dlen might be larger
386 * than required. It must never be smaller.
388 if (dlen < XDR_QUADLEN(len)*4)
391 if (args->count > max_blocksize) {
392 args->count = max_blocksize;
393 len = args->len = max_blocksize;
395 rqstp->rq_vec[0].iov_base = (void*)p;
396 rqstp->rq_vec[0].iov_len = head->iov_len - hdr;
398 while (len > rqstp->rq_vec[v].iov_len) {
399 len -= rqstp->rq_vec[v].iov_len;
401 rqstp->rq_vec[v].iov_base = page_address(rqstp->rq_pages[v]);
402 rqstp->rq_vec[v].iov_len = PAGE_SIZE;
404 rqstp->rq_vec[v].iov_len = len;
410 nfs3svc_decode_createargs(struct svc_rqst *rqstp, __be32 *p,
411 struct nfsd3_createargs *args)
413 if (!(p = decode_fh(p, &args->fh))
414 || !(p = decode_filename(p, &args->name, &args->len)))
417 switch (args->createmode = ntohl(*p++)) {
418 case NFS3_CREATE_UNCHECKED:
419 case NFS3_CREATE_GUARDED:
420 p = decode_sattr3(p, &args->attrs);
422 case NFS3_CREATE_EXCLUSIVE:
430 return xdr_argsize_check(rqstp, p);
433 nfs3svc_decode_mkdirargs(struct svc_rqst *rqstp, __be32 *p,
434 struct nfsd3_createargs *args)
436 if (!(p = decode_fh(p, &args->fh)) ||
437 !(p = decode_filename(p, &args->name, &args->len)))
439 p = decode_sattr3(p, &args->attrs);
441 return xdr_argsize_check(rqstp, p);
445 nfs3svc_decode_symlinkargs(struct svc_rqst *rqstp, __be32 *p,
446 struct nfsd3_symlinkargs *args)
448 unsigned int len, avail;
452 if (!(p = decode_fh(p, &args->ffh)) ||
453 !(p = decode_filename(p, &args->fname, &args->flen))
456 p = decode_sattr3(p, &args->attrs);
458 /* now decode the pathname, which might be larger than the first page.
459 * As we have to check for nul's anyway, we copy it into a new page
460 * This page appears in the rq_res.pages list, but as pages_len is always
461 * 0, it won't get in the way
464 if (len == 0 || len > NFS3_MAXPATHLEN || len >= PAGE_SIZE)
467 page_address(rqstp->rq_respages[rqstp->rq_resused++]);
469 /* first copy and check from the first page */
471 vec = &rqstp->rq_arg.head[0];
472 if ((void *)old > vec->iov_base + vec->iov_len)
474 avail = vec->iov_len - (old - (char*)vec->iov_base);
475 while (len && avail && *old) {
480 /* now copy next page if there is one */
481 if (len && !avail && rqstp->rq_arg.page_len) {
482 avail = rqstp->rq_arg.page_len;
483 if (avail > PAGE_SIZE)
485 old = page_address(rqstp->rq_arg.pages[0]);
487 while (len && avail && *old) {
500 nfs3svc_decode_mknodargs(struct svc_rqst *rqstp, __be32 *p,
501 struct nfsd3_mknodargs *args)
503 if (!(p = decode_fh(p, &args->fh))
504 || !(p = decode_filename(p, &args->name, &args->len)))
507 args->ftype = ntohl(*p++);
509 if (args->ftype == NF3BLK || args->ftype == NF3CHR
510 || args->ftype == NF3SOCK || args->ftype == NF3FIFO)
511 p = decode_sattr3(p, &args->attrs);
513 if (args->ftype == NF3BLK || args->ftype == NF3CHR) {
514 args->major = ntohl(*p++);
515 args->minor = ntohl(*p++);
518 return xdr_argsize_check(rqstp, p);
522 nfs3svc_decode_renameargs(struct svc_rqst *rqstp, __be32 *p,
523 struct nfsd3_renameargs *args)
525 if (!(p = decode_fh(p, &args->ffh))
526 || !(p = decode_filename(p, &args->fname, &args->flen))
527 || !(p = decode_fh(p, &args->tfh))
528 || !(p = decode_filename(p, &args->tname, &args->tlen)))
531 return xdr_argsize_check(rqstp, p);
535 nfs3svc_decode_readlinkargs(struct svc_rqst *rqstp, __be32 *p,
536 struct nfsd3_readlinkargs *args)
538 if (!(p = decode_fh(p, &args->fh)))
541 page_address(rqstp->rq_respages[rqstp->rq_resused++]);
543 return xdr_argsize_check(rqstp, p);
547 nfs3svc_decode_linkargs(struct svc_rqst *rqstp, __be32 *p,
548 struct nfsd3_linkargs *args)
550 if (!(p = decode_fh(p, &args->ffh))
551 || !(p = decode_fh(p, &args->tfh))
552 || !(p = decode_filename(p, &args->tname, &args->tlen)))
555 return xdr_argsize_check(rqstp, p);
559 nfs3svc_decode_readdirargs(struct svc_rqst *rqstp, __be32 *p,
560 struct nfsd3_readdirargs *args)
562 if (!(p = decode_fh(p, &args->fh)))
564 p = xdr_decode_hyper(p, &args->cookie);
565 args->verf = p; p += 2;
567 args->count = ntohl(*p++);
569 if (args->count > PAGE_SIZE)
570 args->count = PAGE_SIZE;
573 page_address(rqstp->rq_respages[rqstp->rq_resused++]);
575 return xdr_argsize_check(rqstp, p);
579 nfs3svc_decode_readdirplusargs(struct svc_rqst *rqstp, __be32 *p,
580 struct nfsd3_readdirargs *args)
583 u32 max_blocksize = svc_max_payload(rqstp);
585 if (!(p = decode_fh(p, &args->fh)))
587 p = xdr_decode_hyper(p, &args->cookie);
588 args->verf = p; p += 2;
589 args->dircount = ntohl(*p++);
590 args->count = ntohl(*p++);
592 len = (args->count > max_blocksize) ? max_blocksize :
597 pn = rqstp->rq_resused++;
599 args->buffer = page_address(rqstp->rq_respages[pn]);
603 return xdr_argsize_check(rqstp, p);
607 nfs3svc_decode_commitargs(struct svc_rqst *rqstp, __be32 *p,
608 struct nfsd3_commitargs *args)
610 if (!(p = decode_fh(p, &args->fh)))
612 p = xdr_decode_hyper(p, &args->offset);
613 args->count = ntohl(*p++);
615 return xdr_argsize_check(rqstp, p);
619 * XDR encode functions
622 * There must be an encoding function for void results so svc_process
623 * will work properly.
626 nfs3svc_encode_voidres(struct svc_rqst *rqstp, __be32 *p, void *dummy)
628 return xdr_ressize_check(rqstp, p);
633 nfs3svc_encode_attrstat(struct svc_rqst *rqstp, __be32 *p,
634 struct nfsd3_attrstat *resp)
636 if (resp->status == 0) {
637 lease_get_mtime(resp->fh.fh_dentry->d_inode,
639 p = encode_fattr3(rqstp, p, &resp->fh, &resp->stat);
641 return xdr_ressize_check(rqstp, p);
644 /* SETATTR, REMOVE, RMDIR */
646 nfs3svc_encode_wccstat(struct svc_rqst *rqstp, __be32 *p,
647 struct nfsd3_attrstat *resp)
649 p = encode_wcc_data(rqstp, p, &resp->fh);
650 return xdr_ressize_check(rqstp, p);
655 nfs3svc_encode_diropres(struct svc_rqst *rqstp, __be32 *p,
656 struct nfsd3_diropres *resp)
658 if (resp->status == 0) {
659 p = encode_fh(p, &resp->fh);
660 p = encode_post_op_attr(rqstp, p, &resp->fh);
662 p = encode_post_op_attr(rqstp, p, &resp->dirfh);
663 return xdr_ressize_check(rqstp, p);
668 nfs3svc_encode_accessres(struct svc_rqst *rqstp, __be32 *p,
669 struct nfsd3_accessres *resp)
671 p = encode_post_op_attr(rqstp, p, &resp->fh);
672 if (resp->status == 0)
673 *p++ = htonl(resp->access);
674 return xdr_ressize_check(rqstp, p);
679 nfs3svc_encode_readlinkres(struct svc_rqst *rqstp, __be32 *p,
680 struct nfsd3_readlinkres *resp)
682 p = encode_post_op_attr(rqstp, p, &resp->fh);
683 if (resp->status == 0) {
684 *p++ = htonl(resp->len);
685 xdr_ressize_check(rqstp, p);
686 rqstp->rq_res.page_len = resp->len;
688 /* need to pad the tail */
689 rqstp->rq_res.tail[0].iov_base = p;
691 rqstp->rq_res.tail[0].iov_len = 4 - (resp->len&3);
695 return xdr_ressize_check(rqstp, p);
700 nfs3svc_encode_readres(struct svc_rqst *rqstp, __be32 *p,
701 struct nfsd3_readres *resp)
703 p = encode_post_op_attr(rqstp, p, &resp->fh);
704 if (resp->status == 0) {
705 *p++ = htonl(resp->count);
706 *p++ = htonl(resp->eof);
707 *p++ = htonl(resp->count); /* xdr opaque count */
708 xdr_ressize_check(rqstp, p);
709 /* now update rqstp->rq_res to reflect data as well */
710 rqstp->rq_res.page_len = resp->count;
711 if (resp->count & 3) {
712 /* need to pad the tail */
713 rqstp->rq_res.tail[0].iov_base = p;
715 rqstp->rq_res.tail[0].iov_len = 4 - (resp->count & 3);
719 return xdr_ressize_check(rqstp, p);
724 nfs3svc_encode_writeres(struct svc_rqst *rqstp, __be32 *p,
725 struct nfsd3_writeres *resp)
727 p = encode_wcc_data(rqstp, p, &resp->fh);
728 if (resp->status == 0) {
729 *p++ = htonl(resp->count);
730 *p++ = htonl(resp->committed);
731 *p++ = htonl(nfssvc_boot.tv_sec);
732 *p++ = htonl(nfssvc_boot.tv_usec);
734 return xdr_ressize_check(rqstp, p);
737 /* CREATE, MKDIR, SYMLINK, MKNOD */
739 nfs3svc_encode_createres(struct svc_rqst *rqstp, __be32 *p,
740 struct nfsd3_diropres *resp)
742 if (resp->status == 0) {
744 p = encode_fh(p, &resp->fh);
745 p = encode_post_op_attr(rqstp, p, &resp->fh);
747 p = encode_wcc_data(rqstp, p, &resp->dirfh);
748 return xdr_ressize_check(rqstp, p);
753 nfs3svc_encode_renameres(struct svc_rqst *rqstp, __be32 *p,
754 struct nfsd3_renameres *resp)
756 p = encode_wcc_data(rqstp, p, &resp->ffh);
757 p = encode_wcc_data(rqstp, p, &resp->tfh);
758 return xdr_ressize_check(rqstp, p);
763 nfs3svc_encode_linkres(struct svc_rqst *rqstp, __be32 *p,
764 struct nfsd3_linkres *resp)
766 p = encode_post_op_attr(rqstp, p, &resp->fh);
767 p = encode_wcc_data(rqstp, p, &resp->tfh);
768 return xdr_ressize_check(rqstp, p);
773 nfs3svc_encode_readdirres(struct svc_rqst *rqstp, __be32 *p,
774 struct nfsd3_readdirres *resp)
776 p = encode_post_op_attr(rqstp, p, &resp->fh);
778 if (resp->status == 0) {
779 /* stupid readdir cookie */
780 memcpy(p, resp->verf, 8); p += 2;
781 xdr_ressize_check(rqstp, p);
782 if (rqstp->rq_res.head[0].iov_len + (2<<2) > PAGE_SIZE)
783 return 1; /*No room for trailer */
784 rqstp->rq_res.page_len = (resp->count) << 2;
786 /* add the 'tail' to the end of the 'head' page - page 0. */
787 rqstp->rq_res.tail[0].iov_base = p;
788 *p++ = 0; /* no more entries */
789 *p++ = htonl(resp->common.err == nfserr_eof);
790 rqstp->rq_res.tail[0].iov_len = 2<<2;
793 return xdr_ressize_check(rqstp, p);
797 encode_entry_baggage(struct nfsd3_readdirres *cd, __be32 *p, const char *name,
800 *p++ = xdr_one; /* mark entry present */
801 p = xdr_encode_hyper(p, ino); /* file id */
802 p = xdr_encode_array(p, name, namlen);/* name length & name */
804 cd->offset = p; /* remember pointer */
805 p = xdr_encode_hyper(p, NFS_OFFSET_MAX);/* offset of next entry */
811 compose_entry_fh(struct nfsd3_readdirres *cd, struct svc_fh *fhp,
812 const char *name, int namlen)
814 struct svc_export *exp;
815 struct dentry *dparent, *dchild;
816 __be32 rv = nfserr_noent;
818 dparent = cd->fh.fh_dentry;
819 exp = cd->fh.fh_export;
821 if (isdotent(name, namlen)) {
823 dchild = dget_parent(dparent);
824 /* filesystem root - cannot return filehandle for ".." */
825 if (dchild == dparent)
828 dchild = dget(dparent);
830 dchild = lookup_one_len(name, dparent, namlen);
833 if (d_mountpoint(dchild))
835 if (!dchild->d_inode)
837 rv = fh_compose(fhp, exp, dchild, &cd->fh);
843 static __be32 *encode_entryplus_baggage(struct nfsd3_readdirres *cd, __be32 *p, const char *name, int namlen)
848 fh_init(&fh, NFS3_FHSIZE);
849 err = compose_entry_fh(cd, &fh, name, namlen);
855 p = encode_post_op_attr(cd->rqstp, p, &fh);
856 *p++ = xdr_one; /* yes, a file handle follows */
857 p = encode_fh(p, &fh);
864 * Encode a directory entry. This one works for both normal readdir
866 * The normal readdir reply requires 2 (fileid) + 1 (stringlen)
867 * + string + 2 (cookie) + 1 (next) words, i.e. 6 + strlen.
869 * The readdirplus baggage is 1+21 words for post_op_attr, plus the
873 #define NFS3_ENTRY_BAGGAGE (2 + 1 + 2 + 1)
874 #define NFS3_ENTRYPLUS_BAGGAGE (1 + 21 + 1 + (NFS3_FHSIZE >> 2))
876 encode_entry(struct readdir_cd *ccd, const char *name, int namlen,
877 loff_t offset, u64 ino, unsigned int d_type, int plus)
879 struct nfsd3_readdirres *cd = container_of(ccd, struct nfsd3_readdirres,
881 __be32 *p = cd->buffer;
882 caddr_t curr_page_addr = NULL;
883 int pn; /* current page number */
884 int slen; /* string (name) length */
885 int elen; /* estimated entry length in words */
886 int num_entry_words = 0; /* actual number of words */
889 u64 offset64 = offset;
891 if (unlikely(cd->offset1)) {
892 /* we ended up with offset on a page boundary */
893 *cd->offset = htonl(offset64 >> 32);
894 *cd->offset1 = htonl(offset64 & 0xffffffff);
897 xdr_encode_hyper(cd->offset, offset64);
902 dprintk("encode_entry(%.*s @%ld%s)\n",
903 namlen, name, (long) offset, plus? " plus" : "");
906 /* truncate filename if too long */
907 if (namlen > NFS3_MAXNAMLEN)
908 namlen = NFS3_MAXNAMLEN;
910 slen = XDR_QUADLEN(namlen);
911 elen = slen + NFS3_ENTRY_BAGGAGE
912 + (plus? NFS3_ENTRYPLUS_BAGGAGE : 0);
914 if (cd->buflen < elen) {
915 cd->common.err = nfserr_toosmall;
919 /* determine which page in rq_respages[] we are currently filling */
920 for (pn=1; pn < cd->rqstp->rq_resused; pn++) {
921 curr_page_addr = page_address(cd->rqstp->rq_respages[pn]);
923 if (((caddr_t)cd->buffer >= curr_page_addr) &&
924 ((caddr_t)cd->buffer < curr_page_addr + PAGE_SIZE))
928 if ((caddr_t)(cd->buffer + elen) < (curr_page_addr + PAGE_SIZE)) {
929 /* encode entry in current page */
931 p = encode_entry_baggage(cd, p, name, namlen, ino);
934 p = encode_entryplus_baggage(cd, p, name, namlen);
935 num_entry_words = p - cd->buffer;
936 } else if (cd->rqstp->rq_respages[pn+1] != NULL) {
937 /* temporarily encode entry into next page, then move back to
938 * current and next page in rq_respages[] */
942 /* grab next page for temporary storage of entry */
943 p1 = tmp = page_address(cd->rqstp->rq_respages[pn+1]);
945 p1 = encode_entry_baggage(cd, p1, name, namlen, ino);
948 p1 = encode_entryplus_baggage(cd, p1, name, namlen);
950 /* determine entry word length and lengths to go in pages */
951 num_entry_words = p1 - tmp;
952 len1 = curr_page_addr + PAGE_SIZE - (caddr_t)cd->buffer;
953 if ((num_entry_words << 2) < len1) {
954 /* the actual number of words in the entry is less
955 * than elen and can still fit in the current page
957 memmove(p, tmp, num_entry_words << 2);
958 p += num_entry_words;
961 cd->offset = cd->buffer + (cd->offset - tmp);
963 unsigned int offset_r = (cd->offset - tmp) << 2;
965 /* update pointer to offset location.
966 * This is a 64bit quantity, so we need to
968 * - entirely in first page
969 * - entirely in second page
970 * - 4 bytes in each page
972 if (offset_r + 8 <= len1) {
973 cd->offset = p + (cd->offset - tmp);
974 } else if (offset_r >= len1) {
975 cd->offset -= len1 >> 2;
977 /* sitting on the fence */
978 BUG_ON(offset_r != len1 - 4);
979 cd->offset = p + (cd->offset - tmp);
983 len2 = (num_entry_words << 2) - len1;
985 /* move from temp page to current and next pages */
986 memmove(p, tmp, len1);
987 memmove(tmp, (caddr_t)tmp+len1, len2);
989 p = tmp + (len2 >> 2);
993 cd->common.err = nfserr_toosmall;
997 cd->buflen -= num_entry_words;
999 cd->common.err = nfs_ok;
1005 nfs3svc_encode_entry(void *cd, const char *name,
1006 int namlen, loff_t offset, u64 ino, unsigned int d_type)
1008 return encode_entry(cd, name, namlen, offset, ino, d_type, 0);
1012 nfs3svc_encode_entry_plus(void *cd, const char *name,
1013 int namlen, loff_t offset, u64 ino,
1014 unsigned int d_type)
1016 return encode_entry(cd, name, namlen, offset, ino, d_type, 1);
1021 nfs3svc_encode_fsstatres(struct svc_rqst *rqstp, __be32 *p,
1022 struct nfsd3_fsstatres *resp)
1024 struct kstatfs *s = &resp->stats;
1025 u64 bs = s->f_bsize;
1027 *p++ = xdr_zero; /* no post_op_attr */
1029 if (resp->status == 0) {
1030 p = xdr_encode_hyper(p, bs * s->f_blocks); /* total bytes */
1031 p = xdr_encode_hyper(p, bs * s->f_bfree); /* free bytes */
1032 p = xdr_encode_hyper(p, bs * s->f_bavail); /* user available bytes */
1033 p = xdr_encode_hyper(p, s->f_files); /* total inodes */
1034 p = xdr_encode_hyper(p, s->f_ffree); /* free inodes */
1035 p = xdr_encode_hyper(p, s->f_ffree); /* user available inodes */
1036 *p++ = htonl(resp->invarsec); /* mean unchanged time */
1038 return xdr_ressize_check(rqstp, p);
1043 nfs3svc_encode_fsinfores(struct svc_rqst *rqstp, __be32 *p,
1044 struct nfsd3_fsinfores *resp)
1046 *p++ = xdr_zero; /* no post_op_attr */
1048 if (resp->status == 0) {
1049 *p++ = htonl(resp->f_rtmax);
1050 *p++ = htonl(resp->f_rtpref);
1051 *p++ = htonl(resp->f_rtmult);
1052 *p++ = htonl(resp->f_wtmax);
1053 *p++ = htonl(resp->f_wtpref);
1054 *p++ = htonl(resp->f_wtmult);
1055 *p++ = htonl(resp->f_dtpref);
1056 p = xdr_encode_hyper(p, resp->f_maxfilesize);
1059 *p++ = htonl(resp->f_properties);
1062 return xdr_ressize_check(rqstp, p);
1067 nfs3svc_encode_pathconfres(struct svc_rqst *rqstp, __be32 *p,
1068 struct nfsd3_pathconfres *resp)
1070 *p++ = xdr_zero; /* no post_op_attr */
1072 if (resp->status == 0) {
1073 *p++ = htonl(resp->p_link_max);
1074 *p++ = htonl(resp->p_name_max);
1075 *p++ = htonl(resp->p_no_trunc);
1076 *p++ = htonl(resp->p_chown_restricted);
1077 *p++ = htonl(resp->p_case_insensitive);
1078 *p++ = htonl(resp->p_case_preserving);
1081 return xdr_ressize_check(rqstp, p);
1086 nfs3svc_encode_commitres(struct svc_rqst *rqstp, __be32 *p,
1087 struct nfsd3_commitres *resp)
1089 p = encode_wcc_data(rqstp, p, &resp->fh);
1090 /* Write verifier */
1091 if (resp->status == 0) {
1092 *p++ = htonl(nfssvc_boot.tv_sec);
1093 *p++ = htonl(nfssvc_boot.tv_usec);
1095 return xdr_ressize_check(rqstp, p);
1099 * XDR release functions
1102 nfs3svc_release_fhandle(struct svc_rqst *rqstp, __be32 *p,
1103 struct nfsd3_attrstat *resp)
1110 nfs3svc_release_fhandle2(struct svc_rqst *rqstp, __be32 *p,
1111 struct nfsd3_fhandle_pair *resp)