1 // SPDX-License-Identifier: GPL-2.0
3 * XDR support for nfsd/protocol version 3.
5 * Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de>
7 * 2003-08-09 Jamie Lokier: Use htonl() for nanoseconds, not htons()!
10 #include <linux/namei.h>
11 #include <linux/sunrpc/svc_xprt.h>
17 #define NFSDDBG_FACILITY NFSDDBG_XDR
21 * Mapping of S_IF* types to NFS file types
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
,
31 * XDR functions for basic NFS types
34 encode_time3(__be32
*p
, struct timespec
*time
)
36 *p
++ = htonl((u32
) time
->tv_sec
); *p
++ = htonl(time
->tv_nsec
);
41 decode_time3(__be32
*p
, struct timespec
*time
)
43 time
->tv_sec
= ntohl(*p
++);
44 time
->tv_nsec
= ntohl(*p
++);
49 decode_fh(__be32
*p
, struct svc_fh
*fhp
)
52 fh_init(fhp
, NFS3_FHSIZE
);
54 if (size
> NFS3_FHSIZE
)
57 memcpy(&fhp
->fh_handle
.fh_base
, p
, size
);
58 fhp
->fh_handle
.fh_size
= size
;
59 return p
+ XDR_QUADLEN(size
);
62 /* Helper function for NFSv3 ACL code */
63 __be32
*nfs3svc_decode_fh(__be32
*p
, struct svc_fh
*fhp
)
65 return decode_fh(p
, fhp
);
69 encode_fh(__be32
*p
, struct svc_fh
*fhp
)
71 unsigned int size
= fhp
->fh_handle
.fh_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
);
79 * Decode a file name and make sure that the path contains
80 * no slashes or null bytes.
83 decode_filename(__be32
*p
, char **namp
, unsigned int *lenp
)
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
== '/')
99 decode_sattr3(__be32
*p
, struct iattr
*iap
)
106 iap
->ia_valid
|= ATTR_MODE
;
107 iap
->ia_mode
= ntohl(*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
;
115 iap
->ia_gid
= make_kgid(&init_user_ns
, ntohl(*p
++));
116 if (gid_valid(iap
->ia_gid
))
117 iap
->ia_valid
|= ATTR_GID
;
122 iap
->ia_valid
|= ATTR_SIZE
;
123 p
= xdr_decode_hyper(p
, &newsize
);
124 iap
->ia_size
= min_t(u64
, newsize
, NFS_OFFSET_MAX
);
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
++);
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
++);
143 static __be32
*encode_fsid(__be32
*p
, struct svc_fh
*fhp
)
146 switch(fsid_source(fhp
)) {
149 p
= xdr_encode_hyper(p
, (u64
)huge_encode_dev
150 (fhp
->fh_dentry
->d_sb
->s_dev
));
152 case FSIDSOURCE_FSID
:
153 p
= xdr_encode_hyper(p
, (u64
) fhp
->fh_export
->ex_fsid
);
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
);
165 encode_fattr3(struct svc_rqst
*rqstp
, __be32
*p
, struct svc_fh
*fhp
,
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
);
176 p
= xdr_encode_hyper(p
, (u64
) stat
->size
);
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
);
191 encode_saved_post_attr(struct svc_rqst
*rqstp
, __be32
*p
, struct svc_fh
*fhp
)
193 /* Attributes to follow */
195 return encode_fattr3(rqstp
, p
, fhp
, &fhp
->fh_post_attr
);
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.
204 encode_post_op_attr(struct svc_rqst
*rqstp
, __be32
*p
, struct svc_fh
*fhp
)
206 struct dentry
*dentry
= fhp
->fh_dentry
;
207 if (dentry
&& d_really_is_positive(dentry
)) {
211 err
= fh_getattr(fhp
, &stat
);
213 *p
++ = xdr_one
; /* attributes follow */
214 lease_get_mtime(d_inode(dentry
), &stat
.mtime
);
215 return encode_fattr3(rqstp
, p
, fhp
, &stat
);
222 /* Helper for NFSv3 ACLs */
224 nfs3svc_encode_post_op_attr(struct svc_rqst
*rqstp
, __be32
*p
, struct svc_fh
*fhp
)
226 return encode_post_op_attr(rqstp
, p
, fhp
);
230 * Enocde weak cache consistency data
233 encode_wcc_data(struct svc_rqst
*rqstp
, __be32
*p
, struct svc_fh
*fhp
)
235 struct dentry
*dentry
= fhp
->fh_dentry
;
237 if (dentry
&& d_really_is_positive(dentry
) && fhp
->fh_post_saved
) {
238 if (fhp
->fh_pre_saved
) {
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
);
246 return encode_saved_post_attr(rqstp
, p
, fhp
);
248 /* no pre- or post-attrs */
250 return encode_post_op_attr(rqstp
, p
, fhp
);
254 * Fill in the post_op attr for the wcc data
256 void fill_post_wcc(struct svc_fh
*fhp
)
260 if (fhp
->fh_post_saved
)
261 printk("nfsd: inode locked twice during operation.\n");
263 err
= fh_getattr(fhp
, &fhp
->fh_post_attr
);
264 fhp
->fh_post_change
= nfsd4_change_attribute(d_inode(fhp
->fh_dentry
));
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
;
270 fhp
->fh_post_saved
= true;
274 * XDR decode functions
277 nfs3svc_decode_fhandle(struct svc_rqst
*rqstp
, __be32
*p
)
279 struct nfsd_fhandle
*args
= rqstp
->rq_argp
;
281 p
= decode_fh(p
, &args
->fh
);
284 return xdr_argsize_check(rqstp
, p
);
288 nfs3svc_decode_sattrargs(struct svc_rqst
*rqstp
, __be32
*p
)
290 struct nfsd3_sattrargs
*args
= rqstp
->rq_argp
;
292 p
= decode_fh(p
, &args
->fh
);
295 p
= decode_sattr3(p
, &args
->attrs
);
297 if ((args
->check_guard
= ntohl(*p
++)) != 0) {
298 struct timespec time
;
299 p
= decode_time3(p
, &time
);
300 args
->guardtime
= time
.tv_sec
;
303 return xdr_argsize_check(rqstp
, p
);
307 nfs3svc_decode_diropargs(struct svc_rqst
*rqstp
, __be32
*p
)
309 struct nfsd3_diropargs
*args
= rqstp
->rq_argp
;
311 if (!(p
= decode_fh(p
, &args
->fh
))
312 || !(p
= decode_filename(p
, &args
->name
, &args
->len
)))
315 return xdr_argsize_check(rqstp
, p
);
319 nfs3svc_decode_accessargs(struct svc_rqst
*rqstp
, __be32
*p
)
321 struct nfsd3_accessargs
*args
= rqstp
->rq_argp
;
323 p
= decode_fh(p
, &args
->fh
);
326 args
->access
= ntohl(*p
++);
328 return xdr_argsize_check(rqstp
, p
);
332 nfs3svc_decode_readargs(struct svc_rqst
*rqstp
, __be32
*p
)
334 struct nfsd3_readargs
*args
= rqstp
->rq_argp
;
337 u32 max_blocksize
= svc_max_payload(rqstp
);
339 p
= decode_fh(p
, &args
->fh
);
342 p
= xdr_decode_hyper(p
, &args
->offset
);
344 args
->count
= ntohl(*p
++);
345 len
= min(args
->count
, max_blocksize
);
347 /* set up the kvec */
350 struct page
*p
= *(rqstp
->rq_next_page
++);
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
;
358 return xdr_argsize_check(rqstp
, p
);
362 nfs3svc_decode_writeargs(struct svc_rqst
*rqstp
, __be32
*p
)
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
;
370 p
= decode_fh(p
, &args
->fh
);
373 p
= xdr_decode_hyper(p
, &args
->offset
);
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
)
381 * The count must equal the amount of data passed.
383 if (args
->count
!= args
->len
)
387 * Check to make sure that we got the right number of
390 hdr
= (void*)p
- head
->iov_base
;
391 dlen
= head
->iov_len
+ rqstp
->rq_arg
.page_len
+ tail
->iov_len
- hdr
;
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.
400 if (dlen
< XDR_QUADLEN(len
)*4)
403 if (args
->count
> max_blocksize
) {
404 args
->count
= max_blocksize
;
405 len
= args
->len
= max_blocksize
;
407 rqstp
->rq_vec
[0].iov_base
= (void*)p
;
408 rqstp
->rq_vec
[0].iov_len
= head
->iov_len
- hdr
;
410 while (len
> rqstp
->rq_vec
[v
].iov_len
) {
411 len
-= rqstp
->rq_vec
[v
].iov_len
;
413 rqstp
->rq_vec
[v
].iov_base
= page_address(rqstp
->rq_pages
[v
]);
414 rqstp
->rq_vec
[v
].iov_len
= PAGE_SIZE
;
416 rqstp
->rq_vec
[v
].iov_len
= len
;
422 nfs3svc_decode_createargs(struct svc_rqst
*rqstp
, __be32
*p
)
424 struct nfsd3_createargs
*args
= rqstp
->rq_argp
;
426 if (!(p
= decode_fh(p
, &args
->fh
))
427 || !(p
= decode_filename(p
, &args
->name
, &args
->len
)))
430 switch (args
->createmode
= ntohl(*p
++)) {
431 case NFS3_CREATE_UNCHECKED
:
432 case NFS3_CREATE_GUARDED
:
433 p
= decode_sattr3(p
, &args
->attrs
);
435 case NFS3_CREATE_EXCLUSIVE
:
443 return xdr_argsize_check(rqstp
, p
);
447 nfs3svc_decode_mkdirargs(struct svc_rqst
*rqstp
, __be32
*p
)
449 struct nfsd3_createargs
*args
= rqstp
->rq_argp
;
451 if (!(p
= decode_fh(p
, &args
->fh
)) ||
452 !(p
= decode_filename(p
, &args
->name
, &args
->len
)))
454 p
= decode_sattr3(p
, &args
->attrs
);
456 return xdr_argsize_check(rqstp
, p
);
460 nfs3svc_decode_symlinkargs(struct svc_rqst
*rqstp
, __be32
*p
)
462 struct nfsd3_symlinkargs
*args
= rqstp
->rq_argp
;
463 unsigned int len
, avail
;
467 if (!(p
= decode_fh(p
, &args
->ffh
)) ||
468 !(p
= decode_filename(p
, &args
->fname
, &args
->flen
))
471 p
= decode_sattr3(p
, &args
->attrs
);
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
479 if (len
== 0 || len
> NFS3_MAXPATHLEN
|| len
>= PAGE_SIZE
)
481 args
->tname
= new = page_address(*(rqstp
->rq_next_page
++));
483 /* first copy and check from the first page */
485 vec
= &rqstp
->rq_arg
.head
[0];
486 if ((void *)old
> vec
->iov_base
+ vec
->iov_len
)
488 avail
= vec
->iov_len
- (old
- (char*)vec
->iov_base
);
489 while (len
&& avail
&& *old
) {
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]);
499 while (len
&& avail
&& *old
) {
512 nfs3svc_decode_mknodargs(struct svc_rqst
*rqstp
, __be32
*p
)
514 struct nfsd3_mknodargs
*args
= rqstp
->rq_argp
;
516 if (!(p
= decode_fh(p
, &args
->fh
))
517 || !(p
= decode_filename(p
, &args
->name
, &args
->len
)))
520 args
->ftype
= ntohl(*p
++);
522 if (args
->ftype
== NF3BLK
|| args
->ftype
== NF3CHR
523 || args
->ftype
== NF3SOCK
|| args
->ftype
== NF3FIFO
)
524 p
= decode_sattr3(p
, &args
->attrs
);
526 if (args
->ftype
== NF3BLK
|| args
->ftype
== NF3CHR
) {
527 args
->major
= ntohl(*p
++);
528 args
->minor
= ntohl(*p
++);
531 return xdr_argsize_check(rqstp
, p
);
535 nfs3svc_decode_renameargs(struct svc_rqst
*rqstp
, __be32
*p
)
537 struct nfsd3_renameargs
*args
= rqstp
->rq_argp
;
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
)))
545 return xdr_argsize_check(rqstp
, p
);
549 nfs3svc_decode_readlinkargs(struct svc_rqst
*rqstp
, __be32
*p
)
551 struct nfsd3_readlinkargs
*args
= rqstp
->rq_argp
;
553 p
= decode_fh(p
, &args
->fh
);
556 args
->buffer
= page_address(*(rqstp
->rq_next_page
++));
558 return xdr_argsize_check(rqstp
, p
);
562 nfs3svc_decode_linkargs(struct svc_rqst
*rqstp
, __be32
*p
)
564 struct nfsd3_linkargs
*args
= rqstp
->rq_argp
;
566 if (!(p
= decode_fh(p
, &args
->ffh
))
567 || !(p
= decode_fh(p
, &args
->tfh
))
568 || !(p
= decode_filename(p
, &args
->tname
, &args
->tlen
)))
571 return xdr_argsize_check(rqstp
, p
);
575 nfs3svc_decode_readdirargs(struct svc_rqst
*rqstp
, __be32
*p
)
577 struct nfsd3_readdirargs
*args
= rqstp
->rq_argp
;
578 p
= decode_fh(p
, &args
->fh
);
581 p
= xdr_decode_hyper(p
, &args
->cookie
);
582 args
->verf
= p
; p
+= 2;
584 args
->count
= ntohl(*p
++);
585 args
->count
= min_t(u32
, args
->count
, PAGE_SIZE
);
586 args
->buffer
= page_address(*(rqstp
->rq_next_page
++));
588 return xdr_argsize_check(rqstp
, p
);
592 nfs3svc_decode_readdirplusargs(struct svc_rqst
*rqstp
, __be32
*p
)
594 struct nfsd3_readdirargs
*args
= rqstp
->rq_argp
;
596 u32 max_blocksize
= svc_max_payload(rqstp
);
598 p
= decode_fh(p
, &args
->fh
);
601 p
= xdr_decode_hyper(p
, &args
->cookie
);
602 args
->verf
= p
; p
+= 2;
603 args
->dircount
= ntohl(*p
++);
604 args
->count
= ntohl(*p
++);
606 len
= args
->count
= min(args
->count
, max_blocksize
);
608 struct page
*p
= *(rqstp
->rq_next_page
++);
610 args
->buffer
= page_address(p
);
614 return xdr_argsize_check(rqstp
, p
);
618 nfs3svc_decode_commitargs(struct svc_rqst
*rqstp
, __be32
*p
)
620 struct nfsd3_commitargs
*args
= rqstp
->rq_argp
;
621 p
= decode_fh(p
, &args
->fh
);
624 p
= xdr_decode_hyper(p
, &args
->offset
);
625 args
->count
= ntohl(*p
++);
627 return xdr_argsize_check(rqstp
, p
);
631 * XDR encode functions
634 * There must be an encoding function for void results so svc_process
635 * will work properly.
638 nfs3svc_encode_voidres(struct svc_rqst
*rqstp
, __be32
*p
)
640 return xdr_ressize_check(rqstp
, p
);
645 nfs3svc_encode_attrstat(struct svc_rqst
*rqstp
, __be32
*p
)
647 struct nfsd3_attrstat
*resp
= rqstp
->rq_resp
;
649 if (resp
->status
== 0) {
650 lease_get_mtime(d_inode(resp
->fh
.fh_dentry
),
652 p
= encode_fattr3(rqstp
, p
, &resp
->fh
, &resp
->stat
);
654 return xdr_ressize_check(rqstp
, p
);
657 /* SETATTR, REMOVE, RMDIR */
659 nfs3svc_encode_wccstat(struct svc_rqst
*rqstp
, __be32
*p
)
661 struct nfsd3_attrstat
*resp
= rqstp
->rq_resp
;
663 p
= encode_wcc_data(rqstp
, p
, &resp
->fh
);
664 return xdr_ressize_check(rqstp
, p
);
669 nfs3svc_encode_diropres(struct svc_rqst
*rqstp
, __be32
*p
)
671 struct nfsd3_diropres
*resp
= rqstp
->rq_resp
;
673 if (resp
->status
== 0) {
674 p
= encode_fh(p
, &resp
->fh
);
675 p
= encode_post_op_attr(rqstp
, p
, &resp
->fh
);
677 p
= encode_post_op_attr(rqstp
, p
, &resp
->dirfh
);
678 return xdr_ressize_check(rqstp
, p
);
683 nfs3svc_encode_accessres(struct svc_rqst
*rqstp
, __be32
*p
)
685 struct nfsd3_accessres
*resp
= rqstp
->rq_resp
;
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
);
695 nfs3svc_encode_readlinkres(struct svc_rqst
*rqstp
, __be32
*p
)
697 struct nfsd3_readlinkres
*resp
= rqstp
->rq_resp
;
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
;
705 /* need to pad the tail */
706 rqstp
->rq_res
.tail
[0].iov_base
= p
;
708 rqstp
->rq_res
.tail
[0].iov_len
= 4 - (resp
->len
&3);
712 return xdr_ressize_check(rqstp
, p
);
717 nfs3svc_encode_readres(struct svc_rqst
*rqstp
, __be32
*p
)
719 struct nfsd3_readres
*resp
= rqstp
->rq_resp
;
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
;
733 rqstp
->rq_res
.tail
[0].iov_len
= 4 - (resp
->count
& 3);
737 return xdr_ressize_check(rqstp
, p
);
742 nfs3svc_encode_writeres(struct svc_rqst
*rqstp
, __be32
*p
)
744 struct nfsd3_writeres
*resp
= rqstp
->rq_resp
;
745 struct nfsd_net
*nn
= net_generic(SVC_NET(rqstp
), nfsd_net_id
);
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 *p
++ = htonl(nn
->nfssvc_boot
.tv_sec
);
752 *p
++ = htonl(nn
->nfssvc_boot
.tv_usec
);
754 return xdr_ressize_check(rqstp
, p
);
757 /* CREATE, MKDIR, SYMLINK, MKNOD */
759 nfs3svc_encode_createres(struct svc_rqst
*rqstp
, __be32
*p
)
761 struct nfsd3_diropres
*resp
= rqstp
->rq_resp
;
763 if (resp
->status
== 0) {
765 p
= encode_fh(p
, &resp
->fh
);
766 p
= encode_post_op_attr(rqstp
, p
, &resp
->fh
);
768 p
= encode_wcc_data(rqstp
, p
, &resp
->dirfh
);
769 return xdr_ressize_check(rqstp
, p
);
774 nfs3svc_encode_renameres(struct svc_rqst
*rqstp
, __be32
*p
)
776 struct nfsd3_renameres
*resp
= rqstp
->rq_resp
;
778 p
= encode_wcc_data(rqstp
, p
, &resp
->ffh
);
779 p
= encode_wcc_data(rqstp
, p
, &resp
->tfh
);
780 return xdr_ressize_check(rqstp
, p
);
785 nfs3svc_encode_linkres(struct svc_rqst
*rqstp
, __be32
*p
)
787 struct nfsd3_linkres
*resp
= rqstp
->rq_resp
;
789 p
= encode_post_op_attr(rqstp
, p
, &resp
->fh
);
790 p
= encode_wcc_data(rqstp
, p
, &resp
->tfh
);
791 return xdr_ressize_check(rqstp
, p
);
796 nfs3svc_encode_readdirres(struct svc_rqst
*rqstp
, __be32
*p
)
798 struct nfsd3_readdirres
*resp
= rqstp
->rq_resp
;
800 p
= encode_post_op_attr(rqstp
, p
, &resp
->fh
);
802 if (resp
->status
== 0) {
803 /* stupid readdir cookie */
804 memcpy(p
, resp
->verf
, 8); p
+= 2;
805 xdr_ressize_check(rqstp
, p
);
806 if (rqstp
->rq_res
.head
[0].iov_len
+ (2<<2) > PAGE_SIZE
)
807 return 1; /*No room for trailer */
808 rqstp
->rq_res
.page_len
= (resp
->count
) << 2;
810 /* add the 'tail' to the end of the 'head' page - page 0. */
811 rqstp
->rq_res
.tail
[0].iov_base
= p
;
812 *p
++ = 0; /* no more entries */
813 *p
++ = htonl(resp
->common
.err
== nfserr_eof
);
814 rqstp
->rq_res
.tail
[0].iov_len
= 2<<2;
817 return xdr_ressize_check(rqstp
, p
);
821 encode_entry_baggage(struct nfsd3_readdirres
*cd
, __be32
*p
, const char *name
,
824 *p
++ = xdr_one
; /* mark entry present */
825 p
= xdr_encode_hyper(p
, ino
); /* file id */
826 p
= xdr_encode_array(p
, name
, namlen
);/* name length & name */
828 cd
->offset
= p
; /* remember pointer */
829 p
= xdr_encode_hyper(p
, NFS_OFFSET_MAX
);/* offset of next entry */
835 compose_entry_fh(struct nfsd3_readdirres
*cd
, struct svc_fh
*fhp
,
836 const char *name
, int namlen
, u64 ino
)
838 struct svc_export
*exp
;
839 struct dentry
*dparent
, *dchild
;
840 __be32 rv
= nfserr_noent
;
842 dparent
= cd
->fh
.fh_dentry
;
843 exp
= cd
->fh
.fh_export
;
845 if (isdotent(name
, namlen
)) {
847 dchild
= dget_parent(dparent
);
848 /* filesystem root - cannot return filehandle for ".." */
849 if (dchild
== dparent
)
852 dchild
= dget(dparent
);
854 dchild
= lookup_one_len_unlocked(name
, dparent
, namlen
);
857 if (d_mountpoint(dchild
))
859 if (d_really_is_negative(dchild
))
861 if (dchild
->d_inode
->i_ino
!= ino
)
863 rv
= fh_compose(fhp
, exp
, dchild
, &cd
->fh
);
869 static __be32
*encode_entryplus_baggage(struct nfsd3_readdirres
*cd
, __be32
*p
, const char *name
, int namlen
, u64 ino
)
871 struct svc_fh
*fh
= &cd
->scratch
;
874 fh_init(fh
, NFS3_FHSIZE
);
875 err
= compose_entry_fh(cd
, fh
, name
, namlen
, ino
);
881 p
= encode_post_op_attr(cd
->rqstp
, p
, fh
);
882 *p
++ = xdr_one
; /* yes, a file handle follows */
883 p
= encode_fh(p
, fh
);
890 * Encode a directory entry. This one works for both normal readdir
892 * The normal readdir reply requires 2 (fileid) + 1 (stringlen)
893 * + string + 2 (cookie) + 1 (next) words, i.e. 6 + strlen.
895 * The readdirplus baggage is 1+21 words for post_op_attr, plus the
899 #define NFS3_ENTRY_BAGGAGE (2 + 1 + 2 + 1)
900 #define NFS3_ENTRYPLUS_BAGGAGE (1 + 21 + 1 + (NFS3_FHSIZE >> 2))
902 encode_entry(struct readdir_cd
*ccd
, const char *name
, int namlen
,
903 loff_t offset
, u64 ino
, unsigned int d_type
, int plus
)
905 struct nfsd3_readdirres
*cd
= container_of(ccd
, struct nfsd3_readdirres
,
907 __be32
*p
= cd
->buffer
;
908 caddr_t curr_page_addr
= NULL
;
910 int slen
; /* string (name) length */
911 int elen
; /* estimated entry length in words */
912 int num_entry_words
= 0; /* actual number of words */
915 u64 offset64
= offset
;
917 if (unlikely(cd
->offset1
)) {
918 /* we ended up with offset on a page boundary */
919 *cd
->offset
= htonl(offset64
>> 32);
920 *cd
->offset1
= htonl(offset64
& 0xffffffff);
923 xdr_encode_hyper(cd
->offset
, offset64
);
929 dprintk("encode_entry(%.*s @%ld%s)\n",
930 namlen, name, (long) offset, plus? " plus" : "");
933 /* truncate filename if too long */
934 namlen
= min(namlen
, NFS3_MAXNAMLEN
);
936 slen
= XDR_QUADLEN(namlen
);
937 elen
= slen
+ NFS3_ENTRY_BAGGAGE
938 + (plus
? NFS3_ENTRYPLUS_BAGGAGE
: 0);
940 if (cd
->buflen
< elen
) {
941 cd
->common
.err
= nfserr_toosmall
;
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
);
950 if (((caddr_t
)cd
->buffer
>= curr_page_addr
) &&
951 ((caddr_t
)cd
->buffer
< curr_page_addr
+ PAGE_SIZE
))
955 if ((caddr_t
)(cd
->buffer
+ elen
) < (curr_page_addr
+ PAGE_SIZE
)) {
956 /* encode entry in current page */
958 p
= encode_entry_baggage(cd
, p
, name
, namlen
, ino
);
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[] */
969 /* grab next page for temporary storage of entry */
970 p1
= tmp
= page_address(*(page
+1));
972 p1
= encode_entry_baggage(cd
, p1
, name
, namlen
, ino
);
975 p1
= encode_entryplus_baggage(cd
, p1
, name
, namlen
, ino
);
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
984 memmove(p
, tmp
, num_entry_words
<< 2);
985 p
+= num_entry_words
;
988 cd
->offset
= cd
->buffer
+ (cd
->offset
- tmp
);
990 unsigned int offset_r
= (cd
->offset
- tmp
) << 2;
992 /* update pointer to offset location.
993 * This is a 64bit quantity, so we need to
995 * - entirely in first page
996 * - entirely in second page
997 * - 4 bytes in each page
999 if (offset_r
+ 8 <= len1
) {
1000 cd
->offset
= p
+ (cd
->offset
- tmp
);
1001 } else if (offset_r
>= len1
) {
1002 cd
->offset
-= len1
>> 2;
1004 /* sitting on the fence */
1005 BUG_ON(offset_r
!= len1
- 4);
1006 cd
->offset
= p
+ (cd
->offset
- tmp
);
1010 len2
= (num_entry_words
<< 2) - len1
;
1012 /* move from temp page to current and next pages */
1013 memmove(p
, tmp
, len1
);
1014 memmove(tmp
, (caddr_t
)tmp
+len1
, len2
);
1016 p
= tmp
+ (len2
>> 2);
1020 cd
->common
.err
= nfserr_toosmall
;
1024 cd
->buflen
-= num_entry_words
;
1026 cd
->common
.err
= nfs_ok
;
1032 nfs3svc_encode_entry(void *cd
, const char *name
,
1033 int namlen
, loff_t offset
, u64 ino
, unsigned int d_type
)
1035 return encode_entry(cd
, name
, namlen
, offset
, ino
, d_type
, 0);
1039 nfs3svc_encode_entry_plus(void *cd
, const char *name
,
1040 int namlen
, loff_t offset
, u64 ino
,
1041 unsigned int d_type
)
1043 return encode_entry(cd
, name
, namlen
, offset
, ino
, d_type
, 1);
1048 nfs3svc_encode_fsstatres(struct svc_rqst
*rqstp
, __be32
*p
)
1050 struct nfsd3_fsstatres
*resp
= rqstp
->rq_resp
;
1051 struct kstatfs
*s
= &resp
->stats
;
1052 u64 bs
= s
->f_bsize
;
1054 *p
++ = xdr_zero
; /* no post_op_attr */
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 */
1065 return xdr_ressize_check(rqstp
, p
);
1070 nfs3svc_encode_fsinfores(struct svc_rqst
*rqstp
, __be32
*p
)
1072 struct nfsd3_fsinfores
*resp
= rqstp
->rq_resp
;
1074 *p
++ = xdr_zero
; /* no post_op_attr */
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
);
1087 *p
++ = htonl(resp
->f_properties
);
1090 return xdr_ressize_check(rqstp
, p
);
1095 nfs3svc_encode_pathconfres(struct svc_rqst
*rqstp
, __be32
*p
)
1097 struct nfsd3_pathconfres
*resp
= rqstp
->rq_resp
;
1099 *p
++ = xdr_zero
; /* no post_op_attr */
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
);
1110 return xdr_ressize_check(rqstp
, p
);
1115 nfs3svc_encode_commitres(struct svc_rqst
*rqstp
, __be32
*p
)
1117 struct nfsd3_commitres
*resp
= rqstp
->rq_resp
;
1118 struct nfsd_net
*nn
= net_generic(SVC_NET(rqstp
), nfsd_net_id
);
1120 p
= encode_wcc_data(rqstp
, p
, &resp
->fh
);
1121 /* Write verifier */
1122 if (resp
->status
== 0) {
1123 *p
++ = htonl(nn
->nfssvc_boot
.tv_sec
);
1124 *p
++ = htonl(nn
->nfssvc_boot
.tv_usec
);
1126 return xdr_ressize_check(rqstp
, p
);
1130 * XDR release functions
1133 nfs3svc_release_fhandle(struct svc_rqst
*rqstp
)
1135 struct nfsd3_attrstat
*resp
= rqstp
->rq_resp
;
1141 nfs3svc_release_fhandle2(struct svc_rqst
*rqstp
)
1143 struct nfsd3_fhandle_pair
*resp
= rqstp
->rq_resp
;