2 * linux/fs/nfsd/nfs3xdr.c
4 * XDR support for nfsd/protocol version 3.
6 * Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de>
8 * 2003-08-09 Jamie Lokier: Use htonl() for nanoseconds, not htons()!
11 #include <linux/types.h>
12 #include <linux/time.h>
13 #include <linux/nfs3.h>
14 #include <linux/list.h>
15 #include <linux/spinlock.h>
16 #include <linux/dcache.h>
17 #include <linux/namei.h>
19 #include <linux/vfs.h>
20 #include <linux/sunrpc/xdr.h>
21 #include <linux/sunrpc/svc.h>
22 #include <linux/nfsd/nfsd.h>
23 #include <linux/nfsd/xdr3.h>
26 #define NFSDDBG_FACILITY NFSDDBG_XDR
30 * Mapping of S_IF* types to NFS file types
32 static u32 nfs3_ftypes
[] = {
33 NF3NON
, NF3FIFO
, NF3CHR
, NF3BAD
,
34 NF3DIR
, NF3BAD
, NF3BLK
, NF3BAD
,
35 NF3REG
, NF3BAD
, NF3LNK
, NF3BAD
,
36 NF3SOCK
, NF3BAD
, NF3LNK
, NF3BAD
,
40 * XDR functions for basic NFS types
43 encode_time3(__be32
*p
, struct timespec
*time
)
45 *p
++ = htonl((u32
) time
->tv_sec
); *p
++ = htonl(time
->tv_nsec
);
50 decode_time3(__be32
*p
, struct timespec
*time
)
52 time
->tv_sec
= ntohl(*p
++);
53 time
->tv_nsec
= ntohl(*p
++);
58 decode_fh(__be32
*p
, struct svc_fh
*fhp
)
61 fh_init(fhp
, NFS3_FHSIZE
);
63 if (size
> NFS3_FHSIZE
)
66 memcpy(&fhp
->fh_handle
.fh_base
, p
, size
);
67 fhp
->fh_handle
.fh_size
= size
;
68 return p
+ XDR_QUADLEN(size
);
71 /* Helper function for NFSv3 ACL code */
72 __be32
*nfs3svc_decode_fh(__be32
*p
, struct svc_fh
*fhp
)
74 return decode_fh(p
, fhp
);
78 encode_fh(__be32
*p
, struct svc_fh
*fhp
)
80 unsigned int size
= fhp
->fh_handle
.fh_size
;
82 if (size
) p
[XDR_QUADLEN(size
)-1]=0;
83 memcpy(p
, &fhp
->fh_handle
.fh_base
, size
);
84 return p
+ XDR_QUADLEN(size
);
88 * Decode a file name and make sure that the path contains
89 * no slashes or null bytes.
92 decode_filename(__be32
*p
, char **namp
, unsigned int *lenp
)
97 if ((p
= xdr_decode_string_inplace(p
, namp
, lenp
, NFS3_MAXNAMLEN
)) != NULL
) {
98 for (i
= 0, name
= *namp
; i
< *lenp
; i
++, name
++) {
99 if (*name
== '\0' || *name
== '/')
108 decode_sattr3(__be32
*p
, struct iattr
*iap
)
115 iap
->ia_valid
|= ATTR_MODE
;
116 iap
->ia_mode
= ntohl(*p
++);
119 iap
->ia_valid
|= ATTR_UID
;
120 iap
->ia_uid
= ntohl(*p
++);
123 iap
->ia_valid
|= ATTR_GID
;
124 iap
->ia_gid
= ntohl(*p
++);
129 iap
->ia_valid
|= ATTR_SIZE
;
130 p
= xdr_decode_hyper(p
, &newsize
);
131 if (newsize
<= NFS_OFFSET_MAX
)
132 iap
->ia_size
= newsize
;
134 iap
->ia_size
= NFS_OFFSET_MAX
;
136 if ((tmp
= ntohl(*p
++)) == 1) { /* set to server time */
137 iap
->ia_valid
|= ATTR_ATIME
;
138 } else if (tmp
== 2) { /* set to client time */
139 iap
->ia_valid
|= ATTR_ATIME
| ATTR_ATIME_SET
;
140 iap
->ia_atime
.tv_sec
= ntohl(*p
++);
141 iap
->ia_atime
.tv_nsec
= ntohl(*p
++);
143 if ((tmp
= ntohl(*p
++)) == 1) { /* set to server time */
144 iap
->ia_valid
|= ATTR_MTIME
;
145 } else if (tmp
== 2) { /* set to client time */
146 iap
->ia_valid
|= ATTR_MTIME
| ATTR_MTIME_SET
;
147 iap
->ia_mtime
.tv_sec
= ntohl(*p
++);
148 iap
->ia_mtime
.tv_nsec
= ntohl(*p
++);
153 static __be32
*encode_fsid(__be32
*p
, struct svc_fh
*fhp
)
156 switch(fsid_source(fhp
)) {
159 p
= xdr_encode_hyper(p
, (u64
)huge_encode_dev
160 (fhp
->fh_dentry
->d_inode
->i_sb
->s_dev
));
162 case FSIDSOURCE_FSID
:
163 p
= xdr_encode_hyper(p
, (u64
) fhp
->fh_export
->ex_fsid
);
165 case FSIDSOURCE_UUID
:
166 f
= ((u64
*)fhp
->fh_export
->ex_uuid
)[0];
167 f
^= ((u64
*)fhp
->fh_export
->ex_uuid
)[1];
168 p
= xdr_encode_hyper(p
, f
);
175 encode_fattr3(struct svc_rqst
*rqstp
, __be32
*p
, struct svc_fh
*fhp
,
178 *p
++ = htonl(nfs3_ftypes
[(stat
->mode
& S_IFMT
) >> 12]);
179 *p
++ = htonl((u32
) stat
->mode
);
180 *p
++ = htonl((u32
) stat
->nlink
);
181 *p
++ = htonl((u32
) nfsd_ruid(rqstp
, stat
->uid
));
182 *p
++ = htonl((u32
) nfsd_rgid(rqstp
, stat
->gid
));
183 if (S_ISLNK(stat
->mode
) && stat
->size
> NFS3_MAXPATHLEN
) {
184 p
= xdr_encode_hyper(p
, (u64
) NFS3_MAXPATHLEN
);
186 p
= xdr_encode_hyper(p
, (u64
) stat
->size
);
188 p
= xdr_encode_hyper(p
, ((u64
)stat
->blocks
) << 9);
189 *p
++ = htonl((u32
) MAJOR(stat
->rdev
));
190 *p
++ = htonl((u32
) MINOR(stat
->rdev
));
191 p
= encode_fsid(p
, fhp
);
192 p
= xdr_encode_hyper(p
, stat
->ino
);
193 p
= encode_time3(p
, &stat
->atime
);
194 p
= encode_time3(p
, &stat
->mtime
);
195 p
= encode_time3(p
, &stat
->ctime
);
201 encode_saved_post_attr(struct svc_rqst
*rqstp
, __be32
*p
, struct svc_fh
*fhp
)
203 /* Attributes to follow */
205 return encode_fattr3(rqstp
, p
, fhp
, &fhp
->fh_post_attr
);
209 * Encode post-operation attributes.
210 * The inode may be NULL if the call failed because of a stale file
211 * handle. In this case, no attributes are returned.
214 encode_post_op_attr(struct svc_rqst
*rqstp
, __be32
*p
, struct svc_fh
*fhp
)
216 struct dentry
*dentry
= fhp
->fh_dentry
;
217 if (dentry
&& dentry
->d_inode
) {
221 err
= vfs_getattr(fhp
->fh_export
->ex_path
.mnt
, dentry
, &stat
);
223 *p
++ = xdr_one
; /* attributes follow */
224 lease_get_mtime(dentry
->d_inode
, &stat
.mtime
);
225 return encode_fattr3(rqstp
, p
, fhp
, &stat
);
232 /* Helper for NFSv3 ACLs */
234 nfs3svc_encode_post_op_attr(struct svc_rqst
*rqstp
, __be32
*p
, struct svc_fh
*fhp
)
236 return encode_post_op_attr(rqstp
, p
, fhp
);
240 * Enocde weak cache consistency data
243 encode_wcc_data(struct svc_rqst
*rqstp
, __be32
*p
, struct svc_fh
*fhp
)
245 struct dentry
*dentry
= fhp
->fh_dentry
;
247 if (dentry
&& dentry
->d_inode
&& fhp
->fh_post_saved
) {
248 if (fhp
->fh_pre_saved
) {
250 p
= xdr_encode_hyper(p
, (u64
) fhp
->fh_pre_size
);
251 p
= encode_time3(p
, &fhp
->fh_pre_mtime
);
252 p
= encode_time3(p
, &fhp
->fh_pre_ctime
);
256 return encode_saved_post_attr(rqstp
, p
, fhp
);
258 /* no pre- or post-attrs */
260 return encode_post_op_attr(rqstp
, p
, fhp
);
264 * Fill in the post_op attr for the wcc data
266 void fill_post_wcc(struct svc_fh
*fhp
)
270 if (fhp
->fh_post_saved
)
271 printk("nfsd: inode locked twice during operation.\n");
273 err
= vfs_getattr(fhp
->fh_export
->ex_path
.mnt
, fhp
->fh_dentry
,
275 fhp
->fh_post_change
= fhp
->fh_dentry
->d_inode
->i_version
;
277 fhp
->fh_post_saved
= 0;
279 fhp
->fh_post_saved
= 1;
283 * XDR decode functions
286 nfs3svc_decode_fhandle(struct svc_rqst
*rqstp
, __be32
*p
, struct nfsd_fhandle
*args
)
288 if (!(p
= decode_fh(p
, &args
->fh
)))
290 return xdr_argsize_check(rqstp
, p
);
294 nfs3svc_decode_sattrargs(struct svc_rqst
*rqstp
, __be32
*p
,
295 struct nfsd3_sattrargs
*args
)
297 if (!(p
= decode_fh(p
, &args
->fh
)))
299 p
= decode_sattr3(p
, &args
->attrs
);
301 if ((args
->check_guard
= ntohl(*p
++)) != 0) {
302 struct timespec time
;
303 p
= decode_time3(p
, &time
);
304 args
->guardtime
= time
.tv_sec
;
307 return xdr_argsize_check(rqstp
, p
);
311 nfs3svc_decode_diropargs(struct svc_rqst
*rqstp
, __be32
*p
,
312 struct nfsd3_diropargs
*args
)
314 if (!(p
= decode_fh(p
, &args
->fh
))
315 || !(p
= decode_filename(p
, &args
->name
, &args
->len
)))
318 return xdr_argsize_check(rqstp
, p
);
322 nfs3svc_decode_accessargs(struct svc_rqst
*rqstp
, __be32
*p
,
323 struct nfsd3_accessargs
*args
)
325 if (!(p
= decode_fh(p
, &args
->fh
)))
327 args
->access
= ntohl(*p
++);
329 return xdr_argsize_check(rqstp
, p
);
333 nfs3svc_decode_readargs(struct svc_rqst
*rqstp
, __be32
*p
,
334 struct nfsd3_readargs
*args
)
338 u32 max_blocksize
= svc_max_payload(rqstp
);
340 if (!(p
= decode_fh(p
, &args
->fh
)))
342 p
= xdr_decode_hyper(p
, &args
->offset
);
344 len
= args
->count
= ntohl(*p
++);
346 if (len
> max_blocksize
)
349 /* set up the kvec */
352 pn
= rqstp
->rq_resused
++;
353 rqstp
->rq_vec
[v
].iov_base
= page_address(rqstp
->rq_respages
[pn
]);
354 rqstp
->rq_vec
[v
].iov_len
= len
< PAGE_SIZE
? len
: PAGE_SIZE
;
355 len
-= rqstp
->rq_vec
[v
].iov_len
;
359 return xdr_argsize_check(rqstp
, p
);
363 nfs3svc_decode_writeargs(struct svc_rqst
*rqstp
, __be32
*p
,
364 struct nfsd3_writeargs
*args
)
366 unsigned int len
, v
, hdr
, dlen
;
367 u32 max_blocksize
= svc_max_payload(rqstp
);
369 if (!(p
= decode_fh(p
, &args
->fh
)))
371 p
= xdr_decode_hyper(p
, &args
->offset
);
373 args
->count
= ntohl(*p
++);
374 args
->stable
= ntohl(*p
++);
375 len
= args
->len
= ntohl(*p
++);
377 * The count must equal the amount of data passed.
379 if (args
->count
!= args
->len
)
383 * Check to make sure that we got the right number of
386 hdr
= (void*)p
- rqstp
->rq_arg
.head
[0].iov_base
;
387 dlen
= rqstp
->rq_arg
.head
[0].iov_len
+ rqstp
->rq_arg
.page_len
390 * Round the length of the data which was specified up to
391 * the next multiple of XDR units and then compare that
392 * against the length which was actually received.
393 * Note that when RPCSEC/GSS (for example) is used, the
394 * data buffer can be padded so dlen might be larger
395 * than required. It must never be smaller.
397 if (dlen
< XDR_QUADLEN(len
)*4)
400 if (args
->count
> max_blocksize
) {
401 args
->count
= max_blocksize
;
402 len
= args
->len
= max_blocksize
;
404 rqstp
->rq_vec
[0].iov_base
= (void*)p
;
405 rqstp
->rq_vec
[0].iov_len
= rqstp
->rq_arg
.head
[0].iov_len
- hdr
;
407 while (len
> rqstp
->rq_vec
[v
].iov_len
) {
408 len
-= rqstp
->rq_vec
[v
].iov_len
;
410 rqstp
->rq_vec
[v
].iov_base
= page_address(rqstp
->rq_pages
[v
]);
411 rqstp
->rq_vec
[v
].iov_len
= PAGE_SIZE
;
413 rqstp
->rq_vec
[v
].iov_len
= len
;
419 nfs3svc_decode_createargs(struct svc_rqst
*rqstp
, __be32
*p
,
420 struct nfsd3_createargs
*args
)
422 if (!(p
= decode_fh(p
, &args
->fh
))
423 || !(p
= decode_filename(p
, &args
->name
, &args
->len
)))
426 switch (args
->createmode
= ntohl(*p
++)) {
427 case NFS3_CREATE_UNCHECKED
:
428 case NFS3_CREATE_GUARDED
:
429 p
= decode_sattr3(p
, &args
->attrs
);
431 case NFS3_CREATE_EXCLUSIVE
:
439 return xdr_argsize_check(rqstp
, p
);
442 nfs3svc_decode_mkdirargs(struct svc_rqst
*rqstp
, __be32
*p
,
443 struct nfsd3_createargs
*args
)
445 if (!(p
= decode_fh(p
, &args
->fh
)) ||
446 !(p
= decode_filename(p
, &args
->name
, &args
->len
)))
448 p
= decode_sattr3(p
, &args
->attrs
);
450 return xdr_argsize_check(rqstp
, p
);
454 nfs3svc_decode_symlinkargs(struct svc_rqst
*rqstp
, __be32
*p
,
455 struct nfsd3_symlinkargs
*args
)
457 unsigned int len
, avail
;
461 if (!(p
= decode_fh(p
, &args
->ffh
)) ||
462 !(p
= decode_filename(p
, &args
->fname
, &args
->flen
))
465 p
= decode_sattr3(p
, &args
->attrs
);
467 /* now decode the pathname, which might be larger than the first page.
468 * As we have to check for nul's anyway, we copy it into a new page
469 * This page appears in the rq_res.pages list, but as pages_len is always
470 * 0, it won't get in the way
473 if (len
== 0 || len
> NFS3_MAXPATHLEN
|| len
>= PAGE_SIZE
)
476 page_address(rqstp
->rq_respages
[rqstp
->rq_resused
++]);
478 /* first copy and check from the first page */
480 vec
= &rqstp
->rq_arg
.head
[0];
481 avail
= vec
->iov_len
- (old
- (char*)vec
->iov_base
);
482 while (len
&& avail
&& *old
) {
487 /* now copy next page if there is one */
488 if (len
&& !avail
&& rqstp
->rq_arg
.page_len
) {
489 avail
= rqstp
->rq_arg
.page_len
;
490 if (avail
> PAGE_SIZE
)
492 old
= page_address(rqstp
->rq_arg
.pages
[0]);
494 while (len
&& avail
&& *old
) {
507 nfs3svc_decode_mknodargs(struct svc_rqst
*rqstp
, __be32
*p
,
508 struct nfsd3_mknodargs
*args
)
510 if (!(p
= decode_fh(p
, &args
->fh
))
511 || !(p
= decode_filename(p
, &args
->name
, &args
->len
)))
514 args
->ftype
= ntohl(*p
++);
516 if (args
->ftype
== NF3BLK
|| args
->ftype
== NF3CHR
517 || args
->ftype
== NF3SOCK
|| args
->ftype
== NF3FIFO
)
518 p
= decode_sattr3(p
, &args
->attrs
);
520 if (args
->ftype
== NF3BLK
|| args
->ftype
== NF3CHR
) {
521 args
->major
= ntohl(*p
++);
522 args
->minor
= ntohl(*p
++);
525 return xdr_argsize_check(rqstp
, p
);
529 nfs3svc_decode_renameargs(struct svc_rqst
*rqstp
, __be32
*p
,
530 struct nfsd3_renameargs
*args
)
532 if (!(p
= decode_fh(p
, &args
->ffh
))
533 || !(p
= decode_filename(p
, &args
->fname
, &args
->flen
))
534 || !(p
= decode_fh(p
, &args
->tfh
))
535 || !(p
= decode_filename(p
, &args
->tname
, &args
->tlen
)))
538 return xdr_argsize_check(rqstp
, p
);
542 nfs3svc_decode_readlinkargs(struct svc_rqst
*rqstp
, __be32
*p
,
543 struct nfsd3_readlinkargs
*args
)
545 if (!(p
= decode_fh(p
, &args
->fh
)))
548 page_address(rqstp
->rq_respages
[rqstp
->rq_resused
++]);
550 return xdr_argsize_check(rqstp
, p
);
554 nfs3svc_decode_linkargs(struct svc_rqst
*rqstp
, __be32
*p
,
555 struct nfsd3_linkargs
*args
)
557 if (!(p
= decode_fh(p
, &args
->ffh
))
558 || !(p
= decode_fh(p
, &args
->tfh
))
559 || !(p
= decode_filename(p
, &args
->tname
, &args
->tlen
)))
562 return xdr_argsize_check(rqstp
, p
);
566 nfs3svc_decode_readdirargs(struct svc_rqst
*rqstp
, __be32
*p
,
567 struct nfsd3_readdirargs
*args
)
569 if (!(p
= decode_fh(p
, &args
->fh
)))
571 p
= xdr_decode_hyper(p
, &args
->cookie
);
572 args
->verf
= p
; p
+= 2;
574 args
->count
= ntohl(*p
++);
576 if (args
->count
> PAGE_SIZE
)
577 args
->count
= PAGE_SIZE
;
580 page_address(rqstp
->rq_respages
[rqstp
->rq_resused
++]);
582 return xdr_argsize_check(rqstp
, p
);
586 nfs3svc_decode_readdirplusargs(struct svc_rqst
*rqstp
, __be32
*p
,
587 struct nfsd3_readdirargs
*args
)
590 u32 max_blocksize
= svc_max_payload(rqstp
);
592 if (!(p
= decode_fh(p
, &args
->fh
)))
594 p
= xdr_decode_hyper(p
, &args
->cookie
);
595 args
->verf
= p
; p
+= 2;
596 args
->dircount
= ntohl(*p
++);
597 args
->count
= ntohl(*p
++);
599 len
= (args
->count
> max_blocksize
) ? max_blocksize
:
604 pn
= rqstp
->rq_resused
++;
606 args
->buffer
= page_address(rqstp
->rq_respages
[pn
]);
610 return xdr_argsize_check(rqstp
, p
);
614 nfs3svc_decode_commitargs(struct svc_rqst
*rqstp
, __be32
*p
,
615 struct nfsd3_commitargs
*args
)
617 if (!(p
= decode_fh(p
, &args
->fh
)))
619 p
= xdr_decode_hyper(p
, &args
->offset
);
620 args
->count
= ntohl(*p
++);
622 return xdr_argsize_check(rqstp
, p
);
626 * XDR encode functions
629 * There must be an encoding function for void results so svc_process
630 * will work properly.
633 nfs3svc_encode_voidres(struct svc_rqst
*rqstp
, __be32
*p
, void *dummy
)
635 return xdr_ressize_check(rqstp
, p
);
640 nfs3svc_encode_attrstat(struct svc_rqst
*rqstp
, __be32
*p
,
641 struct nfsd3_attrstat
*resp
)
643 if (resp
->status
== 0) {
644 lease_get_mtime(resp
->fh
.fh_dentry
->d_inode
,
646 p
= encode_fattr3(rqstp
, p
, &resp
->fh
, &resp
->stat
);
648 return xdr_ressize_check(rqstp
, p
);
651 /* SETATTR, REMOVE, RMDIR */
653 nfs3svc_encode_wccstat(struct svc_rqst
*rqstp
, __be32
*p
,
654 struct nfsd3_attrstat
*resp
)
656 p
= encode_wcc_data(rqstp
, p
, &resp
->fh
);
657 return xdr_ressize_check(rqstp
, p
);
662 nfs3svc_encode_diropres(struct svc_rqst
*rqstp
, __be32
*p
,
663 struct nfsd3_diropres
*resp
)
665 if (resp
->status
== 0) {
666 p
= encode_fh(p
, &resp
->fh
);
667 p
= encode_post_op_attr(rqstp
, p
, &resp
->fh
);
669 p
= encode_post_op_attr(rqstp
, p
, &resp
->dirfh
);
670 return xdr_ressize_check(rqstp
, p
);
675 nfs3svc_encode_accessres(struct svc_rqst
*rqstp
, __be32
*p
,
676 struct nfsd3_accessres
*resp
)
678 p
= encode_post_op_attr(rqstp
, p
, &resp
->fh
);
679 if (resp
->status
== 0)
680 *p
++ = htonl(resp
->access
);
681 return xdr_ressize_check(rqstp
, p
);
686 nfs3svc_encode_readlinkres(struct svc_rqst
*rqstp
, __be32
*p
,
687 struct nfsd3_readlinkres
*resp
)
689 p
= encode_post_op_attr(rqstp
, p
, &resp
->fh
);
690 if (resp
->status
== 0) {
691 *p
++ = htonl(resp
->len
);
692 xdr_ressize_check(rqstp
, p
);
693 rqstp
->rq_res
.page_len
= resp
->len
;
695 /* need to pad the tail */
696 rqstp
->rq_res
.tail
[0].iov_base
= p
;
698 rqstp
->rq_res
.tail
[0].iov_len
= 4 - (resp
->len
&3);
702 return xdr_ressize_check(rqstp
, p
);
707 nfs3svc_encode_readres(struct svc_rqst
*rqstp
, __be32
*p
,
708 struct nfsd3_readres
*resp
)
710 p
= encode_post_op_attr(rqstp
, p
, &resp
->fh
);
711 if (resp
->status
== 0) {
712 *p
++ = htonl(resp
->count
);
713 *p
++ = htonl(resp
->eof
);
714 *p
++ = htonl(resp
->count
); /* xdr opaque count */
715 xdr_ressize_check(rqstp
, p
);
716 /* now update rqstp->rq_res to reflect data aswell */
717 rqstp
->rq_res
.page_len
= resp
->count
;
718 if (resp
->count
& 3) {
719 /* need to pad the tail */
720 rqstp
->rq_res
.tail
[0].iov_base
= p
;
722 rqstp
->rq_res
.tail
[0].iov_len
= 4 - (resp
->count
& 3);
726 return xdr_ressize_check(rqstp
, p
);
731 nfs3svc_encode_writeres(struct svc_rqst
*rqstp
, __be32
*p
,
732 struct nfsd3_writeres
*resp
)
734 p
= encode_wcc_data(rqstp
, p
, &resp
->fh
);
735 if (resp
->status
== 0) {
736 *p
++ = htonl(resp
->count
);
737 *p
++ = htonl(resp
->committed
);
738 *p
++ = htonl(nfssvc_boot
.tv_sec
);
739 *p
++ = htonl(nfssvc_boot
.tv_usec
);
741 return xdr_ressize_check(rqstp
, p
);
744 /* CREATE, MKDIR, SYMLINK, MKNOD */
746 nfs3svc_encode_createres(struct svc_rqst
*rqstp
, __be32
*p
,
747 struct nfsd3_diropres
*resp
)
749 if (resp
->status
== 0) {
751 p
= encode_fh(p
, &resp
->fh
);
752 p
= encode_post_op_attr(rqstp
, p
, &resp
->fh
);
754 p
= encode_wcc_data(rqstp
, p
, &resp
->dirfh
);
755 return xdr_ressize_check(rqstp
, p
);
760 nfs3svc_encode_renameres(struct svc_rqst
*rqstp
, __be32
*p
,
761 struct nfsd3_renameres
*resp
)
763 p
= encode_wcc_data(rqstp
, p
, &resp
->ffh
);
764 p
= encode_wcc_data(rqstp
, p
, &resp
->tfh
);
765 return xdr_ressize_check(rqstp
, p
);
770 nfs3svc_encode_linkres(struct svc_rqst
*rqstp
, __be32
*p
,
771 struct nfsd3_linkres
*resp
)
773 p
= encode_post_op_attr(rqstp
, p
, &resp
->fh
);
774 p
= encode_wcc_data(rqstp
, p
, &resp
->tfh
);
775 return xdr_ressize_check(rqstp
, p
);
780 nfs3svc_encode_readdirres(struct svc_rqst
*rqstp
, __be32
*p
,
781 struct nfsd3_readdirres
*resp
)
783 p
= encode_post_op_attr(rqstp
, p
, &resp
->fh
);
785 if (resp
->status
== 0) {
786 /* stupid readdir cookie */
787 memcpy(p
, resp
->verf
, 8); p
+= 2;
788 xdr_ressize_check(rqstp
, p
);
789 if (rqstp
->rq_res
.head
[0].iov_len
+ (2<<2) > PAGE_SIZE
)
790 return 1; /*No room for trailer */
791 rqstp
->rq_res
.page_len
= (resp
->count
) << 2;
793 /* add the 'tail' to the end of the 'head' page - page 0. */
794 rqstp
->rq_res
.tail
[0].iov_base
= p
;
795 *p
++ = 0; /* no more entries */
796 *p
++ = htonl(resp
->common
.err
== nfserr_eof
);
797 rqstp
->rq_res
.tail
[0].iov_len
= 2<<2;
800 return xdr_ressize_check(rqstp
, p
);
804 encode_entry_baggage(struct nfsd3_readdirres
*cd
, __be32
*p
, const char *name
,
807 *p
++ = xdr_one
; /* mark entry present */
808 p
= xdr_encode_hyper(p
, ino
); /* file id */
809 p
= xdr_encode_array(p
, name
, namlen
);/* name length & name */
811 cd
->offset
= p
; /* remember pointer */
812 p
= xdr_encode_hyper(p
, NFS_OFFSET_MAX
);/* offset of next entry */
818 encode_entryplus_baggage(struct nfsd3_readdirres
*cd
, __be32
*p
,
821 p
= encode_post_op_attr(cd
->rqstp
, p
, fhp
);
822 *p
++ = xdr_one
; /* yes, a file handle follows */
823 p
= encode_fh(p
, fhp
);
829 compose_entry_fh(struct nfsd3_readdirres
*cd
, struct svc_fh
*fhp
,
830 const char *name
, int namlen
)
832 struct svc_export
*exp
;
833 struct dentry
*dparent
, *dchild
;
836 dparent
= cd
->fh
.fh_dentry
;
837 exp
= cd
->fh
.fh_export
;
839 fh_init(fhp
, NFS3_FHSIZE
);
840 if (isdotent(name
, namlen
)) {
842 dchild
= dget_parent(dparent
);
843 if (dchild
== dparent
) {
844 /* filesystem root - cannot return filehandle for ".." */
849 dchild
= dget(dparent
);
851 dchild
= lookup_one_len(name
, dparent
, namlen
);
854 if (d_mountpoint(dchild
) ||
855 fh_compose(fhp
, exp
, dchild
, &cd
->fh
) != 0 ||
863 * Encode a directory entry. This one works for both normal readdir
865 * The normal readdir reply requires 2 (fileid) + 1 (stringlen)
866 * + string + 2 (cookie) + 1 (next) words, i.e. 6 + strlen.
868 * The readdirplus baggage is 1+21 words for post_op_attr, plus the
872 #define NFS3_ENTRY_BAGGAGE (2 + 1 + 2 + 1)
873 #define NFS3_ENTRYPLUS_BAGGAGE (1 + 21 + 1 + (NFS3_FHSIZE >> 2))
875 encode_entry(struct readdir_cd
*ccd
, const char *name
, int namlen
,
876 loff_t offset
, u64 ino
, unsigned int d_type
, int plus
)
878 struct nfsd3_readdirres
*cd
= container_of(ccd
, struct nfsd3_readdirres
,
880 __be32
*p
= cd
->buffer
;
881 caddr_t curr_page_addr
= NULL
;
882 int pn
; /* current page number */
883 int slen
; /* string (name) length */
884 int elen
; /* estimated entry length in words */
885 int num_entry_words
= 0; /* actual number of words */
888 u64 offset64
= offset
;
890 if (unlikely(cd
->offset1
)) {
891 /* we ended up with offset on a page boundary */
892 *cd
->offset
= htonl(offset64
>> 32);
893 *cd
->offset1
= htonl(offset64
& 0xffffffff);
896 xdr_encode_hyper(cd
->offset
, offset64
);
901 dprintk("encode_entry(%.*s @%ld%s)\n",
902 namlen, name, (long) offset, plus? " plus" : "");
905 /* truncate filename if too long */
906 if (namlen
> NFS3_MAXNAMLEN
)
907 namlen
= NFS3_MAXNAMLEN
;
909 slen
= XDR_QUADLEN(namlen
);
910 elen
= slen
+ NFS3_ENTRY_BAGGAGE
911 + (plus
? NFS3_ENTRYPLUS_BAGGAGE
: 0);
913 if (cd
->buflen
< elen
) {
914 cd
->common
.err
= nfserr_toosmall
;
918 /* determine which page in rq_respages[] we are currently filling */
919 for (pn
=1; pn
< cd
->rqstp
->rq_resused
; pn
++) {
920 curr_page_addr
= page_address(cd
->rqstp
->rq_respages
[pn
]);
922 if (((caddr_t
)cd
->buffer
>= curr_page_addr
) &&
923 ((caddr_t
)cd
->buffer
< curr_page_addr
+ PAGE_SIZE
))
927 if ((caddr_t
)(cd
->buffer
+ elen
) < (curr_page_addr
+ PAGE_SIZE
)) {
928 /* encode entry in current page */
930 p
= encode_entry_baggage(cd
, p
, name
, namlen
, ino
);
932 /* throw in readdirplus baggage */
936 if (compose_entry_fh(cd
, &fh
, name
, namlen
) > 0) {
940 p
= encode_entryplus_baggage(cd
, p
, &fh
);
942 num_entry_words
= p
- cd
->buffer
;
943 } else if (cd
->rqstp
->rq_respages
[pn
+1] != NULL
) {
944 /* temporarily encode entry into next page, then move back to
945 * current and next page in rq_respages[] */
949 /* grab next page for temporary storage of entry */
950 p1
= tmp
= page_address(cd
->rqstp
->rq_respages
[pn
+1]);
952 p1
= encode_entry_baggage(cd
, p1
, name
, namlen
, ino
);
954 /* throw in readdirplus baggage */
958 if (compose_entry_fh(cd
, &fh
, name
, namlen
) > 0) {
959 /* zero out the filehandle */
963 p1
= encode_entryplus_baggage(cd
, p1
, &fh
);
966 /* determine entry word length and lengths to go in pages */
967 num_entry_words
= p1
- tmp
;
968 len1
= curr_page_addr
+ PAGE_SIZE
- (caddr_t
)cd
->buffer
;
969 if ((num_entry_words
<< 2) < len1
) {
970 /* the actual number of words in the entry is less
971 * than elen and can still fit in the current page
973 memmove(p
, tmp
, num_entry_words
<< 2);
974 p
+= num_entry_words
;
977 cd
->offset
= cd
->buffer
+ (cd
->offset
- tmp
);
979 unsigned int offset_r
= (cd
->offset
- tmp
) << 2;
981 /* update pointer to offset location.
982 * This is a 64bit quantity, so we need to
984 * - entirely in first page
985 * - entirely in second page
986 * - 4 bytes in each page
988 if (offset_r
+ 8 <= len1
) {
989 cd
->offset
= p
+ (cd
->offset
- tmp
);
990 } else if (offset_r
>= len1
) {
991 cd
->offset
-= len1
>> 2;
993 /* sitting on the fence */
994 BUG_ON(offset_r
!= len1
- 4);
995 cd
->offset
= p
+ (cd
->offset
- tmp
);
999 len2
= (num_entry_words
<< 2) - len1
;
1001 /* move from temp page to current and next pages */
1002 memmove(p
, tmp
, len1
);
1003 memmove(tmp
, (caddr_t
)tmp
+len1
, len2
);
1005 p
= tmp
+ (len2
>> 2);
1009 cd
->common
.err
= nfserr_toosmall
;
1013 cd
->buflen
-= num_entry_words
;
1015 cd
->common
.err
= nfs_ok
;
1021 nfs3svc_encode_entry(void *cd
, const char *name
,
1022 int namlen
, loff_t offset
, u64 ino
, unsigned int d_type
)
1024 return encode_entry(cd
, name
, namlen
, offset
, ino
, d_type
, 0);
1028 nfs3svc_encode_entry_plus(void *cd
, const char *name
,
1029 int namlen
, loff_t offset
, u64 ino
,
1030 unsigned int d_type
)
1032 return encode_entry(cd
, name
, namlen
, offset
, ino
, d_type
, 1);
1037 nfs3svc_encode_fsstatres(struct svc_rqst
*rqstp
, __be32
*p
,
1038 struct nfsd3_fsstatres
*resp
)
1040 struct kstatfs
*s
= &resp
->stats
;
1041 u64 bs
= s
->f_bsize
;
1043 *p
++ = xdr_zero
; /* no post_op_attr */
1045 if (resp
->status
== 0) {
1046 p
= xdr_encode_hyper(p
, bs
* s
->f_blocks
); /* total bytes */
1047 p
= xdr_encode_hyper(p
, bs
* s
->f_bfree
); /* free bytes */
1048 p
= xdr_encode_hyper(p
, bs
* s
->f_bavail
); /* user available bytes */
1049 p
= xdr_encode_hyper(p
, s
->f_files
); /* total inodes */
1050 p
= xdr_encode_hyper(p
, s
->f_ffree
); /* free inodes */
1051 p
= xdr_encode_hyper(p
, s
->f_ffree
); /* user available inodes */
1052 *p
++ = htonl(resp
->invarsec
); /* mean unchanged time */
1054 return xdr_ressize_check(rqstp
, p
);
1059 nfs3svc_encode_fsinfores(struct svc_rqst
*rqstp
, __be32
*p
,
1060 struct nfsd3_fsinfores
*resp
)
1062 *p
++ = xdr_zero
; /* no post_op_attr */
1064 if (resp
->status
== 0) {
1065 *p
++ = htonl(resp
->f_rtmax
);
1066 *p
++ = htonl(resp
->f_rtpref
);
1067 *p
++ = htonl(resp
->f_rtmult
);
1068 *p
++ = htonl(resp
->f_wtmax
);
1069 *p
++ = htonl(resp
->f_wtpref
);
1070 *p
++ = htonl(resp
->f_wtmult
);
1071 *p
++ = htonl(resp
->f_dtpref
);
1072 p
= xdr_encode_hyper(p
, resp
->f_maxfilesize
);
1075 *p
++ = htonl(resp
->f_properties
);
1078 return xdr_ressize_check(rqstp
, p
);
1083 nfs3svc_encode_pathconfres(struct svc_rqst
*rqstp
, __be32
*p
,
1084 struct nfsd3_pathconfres
*resp
)
1086 *p
++ = xdr_zero
; /* no post_op_attr */
1088 if (resp
->status
== 0) {
1089 *p
++ = htonl(resp
->p_link_max
);
1090 *p
++ = htonl(resp
->p_name_max
);
1091 *p
++ = htonl(resp
->p_no_trunc
);
1092 *p
++ = htonl(resp
->p_chown_restricted
);
1093 *p
++ = htonl(resp
->p_case_insensitive
);
1094 *p
++ = htonl(resp
->p_case_preserving
);
1097 return xdr_ressize_check(rqstp
, p
);
1102 nfs3svc_encode_commitres(struct svc_rqst
*rqstp
, __be32
*p
,
1103 struct nfsd3_commitres
*resp
)
1105 p
= encode_wcc_data(rqstp
, p
, &resp
->fh
);
1106 /* Write verifier */
1107 if (resp
->status
== 0) {
1108 *p
++ = htonl(nfssvc_boot
.tv_sec
);
1109 *p
++ = htonl(nfssvc_boot
.tv_usec
);
1111 return xdr_ressize_check(rqstp
, p
);
1115 * XDR release functions
1118 nfs3svc_release_fhandle(struct svc_rqst
*rqstp
, __be32
*p
,
1119 struct nfsd3_attrstat
*resp
)
1126 nfs3svc_release_fhandle2(struct svc_rqst
*rqstp
, __be32
*p
,
1127 struct nfsd3_fhandle_pair
*resp
)
This page took 0.055168 seconds and 5 git commands to generate.