2 * Server-side XDR for NFSv4
4 * Copyright (c) 2002 The Regents of the University of Michigan.
7 * Kendrick Smith <kmsmith@umich.edu>
8 * Andy Adamson <andros@umich.edu>
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. Neither the name of the University nor the names of its
20 * contributors may be used to endorse or promote products derived
21 * from this software without specific prior written permission.
23 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
24 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
25 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
28 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
29 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
30 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
31 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
32 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
33 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 * TODO: Neil Brown made the following observation: We currently
36 * initially reserve NFSD_BUFSIZE space on the transmit queue and
37 * never release any of that until the request is complete.
38 * It would be good to calculate a new maximum response size while
39 * decoding the COMPOUND, and call svc_reserve with this number
40 * at the end of nfs4svc_decode_compoundargs.
43 #include <linux/param.h>
44 #include <linux/smp.h>
46 #include <linux/namei.h>
47 #include <linux/vfs.h>
48 #include <linux/utsname.h>
49 #include <linux/sunrpc/xdr.h>
50 #include <linux/sunrpc/svc.h>
51 #include <linux/sunrpc/clnt.h>
52 #include <linux/nfsd/nfsd.h>
53 #include <linux/nfsd/state.h>
54 #include <linux/nfsd/xdr4.h>
55 #include <linux/nfsd_idmap.h>
56 #include <linux/nfs4.h>
57 #include <linux/nfs4_acl.h>
58 #include <linux/sunrpc/gss_api.h>
59 #include <linux/sunrpc/svcauth_gss.h>
61 #define NFSDDBG_FACILITY NFSDDBG_XDR
64 * As per referral draft, the fsid for a referral MUST be different from the fsid of the containing
65 * directory in order to indicate to the client that a filesystem boundary is present
66 * We use a fixed fsid for a referral
68 #define NFS4_REFERRAL_FSID_MAJOR 0x8000000ULL
69 #define NFS4_REFERRAL_FSID_MINOR 0x8000000ULL
72 check_filename(char *str
, int len
, __be32 err
)
78 if (isdotent(str
, len
))
80 for (i
= 0; i
< len
; i
++)
87 * START OF "GENERIC" DECODE ROUTINES.
88 * These may look a little ugly since they are imported from a "generic"
89 * set of XDR encode/decode routines which are intended to be shared by
90 * all of our NFSv4 implementations (OpenBSD, MacOS X...).
92 * If the pain of reading these is too great, it should be a straightforward
93 * task to translate them into Linux-specific versions which are more
94 * consistent with the style used in NFSv2/v3...
104 dprintk("NFSD: xdr error (%s:%d)\n", \
105 __FILE__, __LINE__); \
106 status = nfserr_bad_xdr; \
109 #define READ32(x) (x) = ntohl(*p++)
110 #define READ64(x) do { \
111 (x) = (u64)ntohl(*p++) << 32; \
112 (x) |= ntohl(*p++); \
114 #define READTIME(x) do { \
119 #define READMEM(x,nbytes) do { \
121 p += XDR_QUADLEN(nbytes); \
123 #define SAVEMEM(x,nbytes) do { \
124 if (!(x = (p==argp->tmp || p == argp->tmpp) ? \
125 savemem(argp, p, nbytes) : \
127 dprintk("NFSD: xdr error (%s:%d)\n", \
128 __FILE__, __LINE__); \
131 p += XDR_QUADLEN(nbytes); \
133 #define COPYMEM(x,nbytes) do { \
134 memcpy((x), p, nbytes); \
135 p += XDR_QUADLEN(nbytes); \
138 /* READ_BUF, read_buf(): nbytes must be <= PAGE_SIZE */
139 #define READ_BUF(nbytes) do { \
140 if (nbytes <= (u32)((char *)argp->end - (char *)argp->p)) { \
142 argp->p += XDR_QUADLEN(nbytes); \
143 } else if (!(p = read_buf(argp, nbytes))) { \
144 dprintk("NFSD: xdr error (%s:%d)\n", \
145 __FILE__, __LINE__); \
150 static __be32
*read_buf(struct nfsd4_compoundargs
*argp
, u32 nbytes
)
152 /* We want more bytes than seem to be available.
153 * Maybe we need a new page, maybe we have just run out
155 unsigned int avail
= (char *)argp
->end
- (char *)argp
->p
;
157 if (avail
+ argp
->pagelen
< nbytes
)
159 if (avail
+ PAGE_SIZE
< nbytes
) /* need more than a page !! */
161 /* ok, we can do it with the current plus the next page */
162 if (nbytes
<= sizeof(argp
->tmp
))
166 p
= argp
->tmpp
= kmalloc(nbytes
, GFP_KERNEL
);
172 * The following memcpy is safe because read_buf is always
173 * called with nbytes > avail, and the two cases above both
174 * guarantee p points to at least nbytes bytes.
176 memcpy(p
, argp
->p
, avail
);
177 /* step to next page */
178 argp
->p
= page_address(argp
->pagelist
[0]);
180 if (argp
->pagelen
< PAGE_SIZE
) {
181 argp
->end
= p
+ (argp
->pagelen
>>2);
184 argp
->end
= p
+ (PAGE_SIZE
>>2);
185 argp
->pagelen
-= PAGE_SIZE
;
187 memcpy(((char*)p
)+avail
, argp
->p
, (nbytes
- avail
));
188 argp
->p
+= XDR_QUADLEN(nbytes
- avail
);
192 static int zero_clientid(clientid_t
*clid
)
194 return (clid
->cl_boot
== 0) && (clid
->cl_id
== 0);
198 defer_free(struct nfsd4_compoundargs
*argp
,
199 void (*release
)(const void *), void *p
)
203 tb
= kmalloc(sizeof(*tb
), GFP_KERNEL
);
207 tb
->release
= release
;
208 tb
->next
= argp
->to_free
;
213 static char *savemem(struct nfsd4_compoundargs
*argp
, __be32
*p
, int nbytes
)
215 if (p
== argp
->tmp
) {
216 p
= kmalloc(nbytes
, GFP_KERNEL
);
219 memcpy(p
, argp
->tmp
, nbytes
);
221 BUG_ON(p
!= argp
->tmpp
);
224 if (defer_free(argp
, kfree
, p
)) {
232 nfsd4_decode_bitmap(struct nfsd4_compoundargs
*argp
, u32
*bmval
)
245 READ_BUF(bmlen
<< 2);
254 static u32 nfsd_attrmask
[] = {
255 NFSD_WRITEABLE_ATTRS_WORD0
,
256 NFSD_WRITEABLE_ATTRS_WORD1
260 nfsd4_decode_fattr(struct nfsd4_compoundargs
*argp
, u32
*bmval
, u32
*writable
,
261 struct iattr
*iattr
, struct nfs4_acl
**acl
)
263 int expected_len
, len
= 0;
270 if ((status
= nfsd4_decode_bitmap(argp
, bmval
)))
274 * According to spec, unsupported attributes return ERR_ATTRNOTSUPP;
275 * read-only attributes return ERR_INVAL.
277 if ((bmval
[0] & ~NFSD_SUPPORTED_ATTRS_WORD0
) || (bmval
[1] & ~NFSD_SUPPORTED_ATTRS_WORD1
))
278 return nfserr_attrnotsupp
;
279 if ((bmval
[0] & ~writable
[0]) || (bmval
[1] & ~writable
[1]))
283 READ32(expected_len
);
285 if (bmval
[0] & FATTR4_WORD0_SIZE
) {
288 READ64(iattr
->ia_size
);
289 iattr
->ia_valid
|= ATTR_SIZE
;
291 if (bmval
[0] & FATTR4_WORD0_ACL
) {
293 struct nfs4_ace
*ace
;
295 READ_BUF(4); len
+= 4;
298 if (nace
> NFS4_ACL_MAX
)
299 return nfserr_resource
;
301 *acl
= nfs4_acl_new(nace
);
306 defer_free(argp
, kfree
, *acl
);
308 (*acl
)->naces
= nace
;
309 for (ace
= (*acl
)->aces
; ace
< (*acl
)->aces
+ nace
; ace
++) {
310 READ_BUF(16); len
+= 16;
313 READ32(ace
->access_mask
);
316 len
+= XDR_QUADLEN(dummy32
) << 2;
317 READMEM(buf
, dummy32
);
318 ace
->whotype
= nfs4_acl_get_whotype(buf
, dummy32
);
320 if (ace
->whotype
!= NFS4_ACL_WHO_NAMED
)
322 else if (ace
->flag
& NFS4_ACE_IDENTIFIER_GROUP
)
323 host_err
= nfsd_map_name_to_gid(argp
->rqstp
,
324 buf
, dummy32
, &ace
->who
);
326 host_err
= nfsd_map_name_to_uid(argp
->rqstp
,
327 buf
, dummy32
, &ace
->who
);
333 if (bmval
[1] & FATTR4_WORD1_MODE
) {
336 READ32(iattr
->ia_mode
);
337 iattr
->ia_mode
&= (S_IFMT
| S_IALLUGO
);
338 iattr
->ia_valid
|= ATTR_MODE
;
340 if (bmval
[1] & FATTR4_WORD1_OWNER
) {
345 len
+= (XDR_QUADLEN(dummy32
) << 2);
346 READMEM(buf
, dummy32
);
347 if ((host_err
= nfsd_map_name_to_uid(argp
->rqstp
, buf
, dummy32
, &iattr
->ia_uid
)))
349 iattr
->ia_valid
|= ATTR_UID
;
351 if (bmval
[1] & FATTR4_WORD1_OWNER_GROUP
) {
356 len
+= (XDR_QUADLEN(dummy32
) << 2);
357 READMEM(buf
, dummy32
);
358 if ((host_err
= nfsd_map_name_to_gid(argp
->rqstp
, buf
, dummy32
, &iattr
->ia_gid
)))
360 iattr
->ia_valid
|= ATTR_GID
;
362 if (bmval
[1] & FATTR4_WORD1_TIME_ACCESS_SET
) {
367 case NFS4_SET_TO_CLIENT_TIME
:
368 /* We require the high 32 bits of 'seconds' to be 0, and we ignore
369 all 32 bits of 'nseconds'. */
375 READ32(iattr
->ia_atime
.tv_sec
);
376 READ32(iattr
->ia_atime
.tv_nsec
);
377 if (iattr
->ia_atime
.tv_nsec
>= (u32
)1000000000)
379 iattr
->ia_valid
|= (ATTR_ATIME
| ATTR_ATIME_SET
);
381 case NFS4_SET_TO_SERVER_TIME
:
382 iattr
->ia_valid
|= ATTR_ATIME
;
388 if (bmval
[1] & FATTR4_WORD1_TIME_MODIFY_SET
) {
393 case NFS4_SET_TO_CLIENT_TIME
:
394 /* We require the high 32 bits of 'seconds' to be 0, and we ignore
395 all 32 bits of 'nseconds'. */
401 READ32(iattr
->ia_mtime
.tv_sec
);
402 READ32(iattr
->ia_mtime
.tv_nsec
);
403 if (iattr
->ia_mtime
.tv_nsec
>= (u32
)1000000000)
405 iattr
->ia_valid
|= (ATTR_MTIME
| ATTR_MTIME_SET
);
407 case NFS4_SET_TO_SERVER_TIME
:
408 iattr
->ia_valid
|= ATTR_MTIME
;
414 if (len
!= expected_len
)
420 status
= nfserrno(host_err
);
425 nfsd4_decode_stateid(struct nfsd4_compoundargs
*argp
, stateid_t
*sid
)
429 READ_BUF(sizeof(stateid_t
));
430 READ32(sid
->si_generation
);
431 COPYMEM(&sid
->si_opaque
, sizeof(stateid_opaque_t
));
437 nfsd4_decode_access(struct nfsd4_compoundargs
*argp
, struct nfsd4_access
*access
)
442 READ32(access
->ac_req_access
);
448 nfsd4_decode_close(struct nfsd4_compoundargs
*argp
, struct nfsd4_close
*close
)
452 close
->cl_stateowner
= NULL
;
454 READ32(close
->cl_seqid
);
455 return nfsd4_decode_stateid(argp
, &close
->cl_stateid
);
462 nfsd4_decode_commit(struct nfsd4_compoundargs
*argp
, struct nfsd4_commit
*commit
)
467 READ64(commit
->co_offset
);
468 READ32(commit
->co_count
);
474 nfsd4_decode_create(struct nfsd4_compoundargs
*argp
, struct nfsd4_create
*create
)
479 READ32(create
->cr_type
);
480 switch (create
->cr_type
) {
483 READ32(create
->cr_linklen
);
484 READ_BUF(create
->cr_linklen
);
485 SAVEMEM(create
->cr_linkname
, create
->cr_linklen
);
490 READ32(create
->cr_specdata1
);
491 READ32(create
->cr_specdata2
);
501 READ32(create
->cr_namelen
);
502 READ_BUF(create
->cr_namelen
);
503 SAVEMEM(create
->cr_name
, create
->cr_namelen
);
504 if ((status
= check_filename(create
->cr_name
, create
->cr_namelen
, nfserr_inval
)))
507 status
= nfsd4_decode_fattr(argp
, create
->cr_bmval
, nfsd_attrmask
,
508 &create
->cr_iattr
, &create
->cr_acl
);
516 nfsd4_decode_delegreturn(struct nfsd4_compoundargs
*argp
, struct nfsd4_delegreturn
*dr
)
518 return nfsd4_decode_stateid(argp
, &dr
->dr_stateid
);
522 nfsd4_decode_getattr(struct nfsd4_compoundargs
*argp
, struct nfsd4_getattr
*getattr
)
524 return nfsd4_decode_bitmap(argp
, getattr
->ga_bmval
);
528 nfsd4_decode_link(struct nfsd4_compoundargs
*argp
, struct nfsd4_link
*link
)
533 READ32(link
->li_namelen
);
534 READ_BUF(link
->li_namelen
);
535 SAVEMEM(link
->li_name
, link
->li_namelen
);
536 if ((status
= check_filename(link
->li_name
, link
->li_namelen
, nfserr_inval
)))
543 nfsd4_decode_lock(struct nfsd4_compoundargs
*argp
, struct nfsd4_lock
*lock
)
547 lock
->lk_replay_owner
= NULL
;
549 * type, reclaim(boolean), offset, length, new_lock_owner(boolean)
552 READ32(lock
->lk_type
);
553 if ((lock
->lk_type
< NFS4_READ_LT
) || (lock
->lk_type
> NFS4_WRITEW_LT
))
555 READ32(lock
->lk_reclaim
);
556 READ64(lock
->lk_offset
);
557 READ64(lock
->lk_length
);
558 READ32(lock
->lk_is_new
);
560 if (lock
->lk_is_new
) {
562 READ32(lock
->lk_new_open_seqid
);
563 status
= nfsd4_decode_stateid(argp
, &lock
->lk_new_open_stateid
);
566 READ_BUF(8 + sizeof(clientid_t
));
567 READ32(lock
->lk_new_lock_seqid
);
568 COPYMEM(&lock
->lk_new_clientid
, sizeof(clientid_t
));
569 READ32(lock
->lk_new_owner
.len
);
570 READ_BUF(lock
->lk_new_owner
.len
);
571 READMEM(lock
->lk_new_owner
.data
, lock
->lk_new_owner
.len
);
573 status
= nfsd4_decode_stateid(argp
, &lock
->lk_old_lock_stateid
);
577 READ32(lock
->lk_old_lock_seqid
);
584 nfsd4_decode_lockt(struct nfsd4_compoundargs
*argp
, struct nfsd4_lockt
*lockt
)
589 READ32(lockt
->lt_type
);
590 if((lockt
->lt_type
< NFS4_READ_LT
) || (lockt
->lt_type
> NFS4_WRITEW_LT
))
592 READ64(lockt
->lt_offset
);
593 READ64(lockt
->lt_length
);
594 COPYMEM(&lockt
->lt_clientid
, 8);
595 READ32(lockt
->lt_owner
.len
);
596 READ_BUF(lockt
->lt_owner
.len
);
597 READMEM(lockt
->lt_owner
.data
, lockt
->lt_owner
.len
);
599 if (argp
->minorversion
&& !zero_clientid(&lockt
->lt_clientid
))
605 nfsd4_decode_locku(struct nfsd4_compoundargs
*argp
, struct nfsd4_locku
*locku
)
609 locku
->lu_stateowner
= NULL
;
611 READ32(locku
->lu_type
);
612 if ((locku
->lu_type
< NFS4_READ_LT
) || (locku
->lu_type
> NFS4_WRITEW_LT
))
614 READ32(locku
->lu_seqid
);
615 status
= nfsd4_decode_stateid(argp
, &locku
->lu_stateid
);
619 READ64(locku
->lu_offset
);
620 READ64(locku
->lu_length
);
626 nfsd4_decode_lookup(struct nfsd4_compoundargs
*argp
, struct nfsd4_lookup
*lookup
)
631 READ32(lookup
->lo_len
);
632 READ_BUF(lookup
->lo_len
);
633 SAVEMEM(lookup
->lo_name
, lookup
->lo_len
);
634 if ((status
= check_filename(lookup
->lo_name
, lookup
->lo_len
, nfserr_noent
)))
641 nfsd4_decode_open(struct nfsd4_compoundargs
*argp
, struct nfsd4_open
*open
)
645 memset(open
->op_bmval
, 0, sizeof(open
->op_bmval
));
646 open
->op_iattr
.ia_valid
= 0;
647 open
->op_stateowner
= NULL
;
649 /* seqid, share_access, share_deny, clientid, ownerlen */
650 READ_BUF(16 + sizeof(clientid_t
));
651 READ32(open
->op_seqid
);
652 READ32(open
->op_share_access
);
653 READ32(open
->op_share_deny
);
654 COPYMEM(&open
->op_clientid
, sizeof(clientid_t
));
655 READ32(open
->op_owner
.len
);
657 /* owner, open_flag */
658 READ_BUF(open
->op_owner
.len
+ 4);
659 SAVEMEM(open
->op_owner
.data
, open
->op_owner
.len
);
660 READ32(open
->op_create
);
661 switch (open
->op_create
) {
662 case NFS4_OPEN_NOCREATE
:
664 case NFS4_OPEN_CREATE
:
666 READ32(open
->op_createmode
);
667 switch (open
->op_createmode
) {
668 case NFS4_CREATE_UNCHECKED
:
669 case NFS4_CREATE_GUARDED
:
670 status
= nfsd4_decode_fattr(argp
, open
->op_bmval
,
671 nfsd_attrmask
, &open
->op_iattr
, &open
->op_acl
);
675 case NFS4_CREATE_EXCLUSIVE
:
677 COPYMEM(open
->op_verf
.data
, 8);
689 READ32(open
->op_claim_type
);
690 switch (open
->op_claim_type
) {
691 case NFS4_OPEN_CLAIM_NULL
:
692 case NFS4_OPEN_CLAIM_DELEGATE_PREV
:
694 READ32(open
->op_fname
.len
);
695 READ_BUF(open
->op_fname
.len
);
696 SAVEMEM(open
->op_fname
.data
, open
->op_fname
.len
);
697 if ((status
= check_filename(open
->op_fname
.data
, open
->op_fname
.len
, nfserr_inval
)))
700 case NFS4_OPEN_CLAIM_PREVIOUS
:
702 READ32(open
->op_delegate_type
);
704 case NFS4_OPEN_CLAIM_DELEGATE_CUR
:
705 status
= nfsd4_decode_stateid(argp
, &open
->op_delegate_stateid
);
709 READ32(open
->op_fname
.len
);
710 READ_BUF(open
->op_fname
.len
);
711 SAVEMEM(open
->op_fname
.data
, open
->op_fname
.len
);
712 if ((status
= check_filename(open
->op_fname
.data
, open
->op_fname
.len
, nfserr_inval
)))
723 nfsd4_decode_open_confirm(struct nfsd4_compoundargs
*argp
, struct nfsd4_open_confirm
*open_conf
)
727 open_conf
->oc_stateowner
= NULL
;
728 status
= nfsd4_decode_stateid(argp
, &open_conf
->oc_req_stateid
);
732 READ32(open_conf
->oc_seqid
);
738 nfsd4_decode_open_downgrade(struct nfsd4_compoundargs
*argp
, struct nfsd4_open_downgrade
*open_down
)
742 open_down
->od_stateowner
= NULL
;
743 status
= nfsd4_decode_stateid(argp
, &open_down
->od_stateid
);
747 READ32(open_down
->od_seqid
);
748 READ32(open_down
->od_share_access
);
749 READ32(open_down
->od_share_deny
);
755 nfsd4_decode_putfh(struct nfsd4_compoundargs
*argp
, struct nfsd4_putfh
*putfh
)
760 READ32(putfh
->pf_fhlen
);
761 if (putfh
->pf_fhlen
> NFS4_FHSIZE
)
763 READ_BUF(putfh
->pf_fhlen
);
764 SAVEMEM(putfh
->pf_fhval
, putfh
->pf_fhlen
);
770 nfsd4_decode_read(struct nfsd4_compoundargs
*argp
, struct nfsd4_read
*read
)
774 status
= nfsd4_decode_stateid(argp
, &read
->rd_stateid
);
778 READ64(read
->rd_offset
);
779 READ32(read
->rd_length
);
785 nfsd4_decode_readdir(struct nfsd4_compoundargs
*argp
, struct nfsd4_readdir
*readdir
)
790 READ64(readdir
->rd_cookie
);
791 COPYMEM(readdir
->rd_verf
.data
, sizeof(readdir
->rd_verf
.data
));
792 READ32(readdir
->rd_dircount
); /* just in case you needed a useless field... */
793 READ32(readdir
->rd_maxcount
);
794 if ((status
= nfsd4_decode_bitmap(argp
, readdir
->rd_bmval
)))
801 nfsd4_decode_remove(struct nfsd4_compoundargs
*argp
, struct nfsd4_remove
*remove
)
806 READ32(remove
->rm_namelen
);
807 READ_BUF(remove
->rm_namelen
);
808 SAVEMEM(remove
->rm_name
, remove
->rm_namelen
);
809 if ((status
= check_filename(remove
->rm_name
, remove
->rm_namelen
, nfserr_noent
)))
816 nfsd4_decode_rename(struct nfsd4_compoundargs
*argp
, struct nfsd4_rename
*rename
)
821 READ32(rename
->rn_snamelen
);
822 READ_BUF(rename
->rn_snamelen
+ 4);
823 SAVEMEM(rename
->rn_sname
, rename
->rn_snamelen
);
824 READ32(rename
->rn_tnamelen
);
825 READ_BUF(rename
->rn_tnamelen
);
826 SAVEMEM(rename
->rn_tname
, rename
->rn_tnamelen
);
827 if ((status
= check_filename(rename
->rn_sname
, rename
->rn_snamelen
, nfserr_noent
)))
829 if ((status
= check_filename(rename
->rn_tname
, rename
->rn_tnamelen
, nfserr_inval
)))
836 nfsd4_decode_renew(struct nfsd4_compoundargs
*argp
, clientid_t
*clientid
)
840 READ_BUF(sizeof(clientid_t
));
841 COPYMEM(clientid
, sizeof(clientid_t
));
847 nfsd4_decode_secinfo(struct nfsd4_compoundargs
*argp
,
848 struct nfsd4_secinfo
*secinfo
)
853 READ32(secinfo
->si_namelen
);
854 READ_BUF(secinfo
->si_namelen
);
855 SAVEMEM(secinfo
->si_name
, secinfo
->si_namelen
);
856 status
= check_filename(secinfo
->si_name
, secinfo
->si_namelen
,
864 nfsd4_decode_setattr(struct nfsd4_compoundargs
*argp
, struct nfsd4_setattr
*setattr
)
868 status
= nfsd4_decode_stateid(argp
, &setattr
->sa_stateid
);
871 return nfsd4_decode_fattr(argp
, setattr
->sa_bmval
, nfsd_attrmask
,
872 &setattr
->sa_iattr
, &setattr
->sa_acl
);
876 nfsd4_decode_setclientid(struct nfsd4_compoundargs
*argp
, struct nfsd4_setclientid
*setclientid
)
881 COPYMEM(setclientid
->se_verf
.data
, 8);
882 READ32(setclientid
->se_namelen
);
884 READ_BUF(setclientid
->se_namelen
+ 8);
885 SAVEMEM(setclientid
->se_name
, setclientid
->se_namelen
);
886 READ32(setclientid
->se_callback_prog
);
887 READ32(setclientid
->se_callback_netid_len
);
889 READ_BUF(setclientid
->se_callback_netid_len
+ 4);
890 SAVEMEM(setclientid
->se_callback_netid_val
, setclientid
->se_callback_netid_len
);
891 READ32(setclientid
->se_callback_addr_len
);
893 READ_BUF(setclientid
->se_callback_addr_len
+ 4);
894 SAVEMEM(setclientid
->se_callback_addr_val
, setclientid
->se_callback_addr_len
);
895 READ32(setclientid
->se_callback_ident
);
901 nfsd4_decode_setclientid_confirm(struct nfsd4_compoundargs
*argp
, struct nfsd4_setclientid_confirm
*scd_c
)
905 READ_BUF(8 + sizeof(nfs4_verifier
));
906 COPYMEM(&scd_c
->sc_clientid
, 8);
907 COPYMEM(&scd_c
->sc_confirm
, sizeof(nfs4_verifier
));
912 /* Also used for NVERIFY */
914 nfsd4_decode_verify(struct nfsd4_compoundargs
*argp
, struct nfsd4_verify
*verify
)
917 struct nfsd4_compoundargs save
= {
920 .rqstp
= argp
->rqstp
,
923 struct iattr ve_iattr
; /* request */
924 struct nfs4_acl
*ve_acl
; /* request */
928 if ((status
= nfsd4_decode_bitmap(argp
, verify
->ve_bmval
)))
931 /* For convenience's sake, we compare raw xdr'd attributes in
932 * nfsd4_proc_verify; however we still decode here just to return
933 * correct error in case of bad xdr. */
935 status
= nfsd4_decode_fattr(ve_bmval
, &ve_iattr
, &ve_acl
);
936 if (status
== nfserr_inval
) {
937 status
= nfserrno(status
);
942 READ32(verify
->ve_attrlen
);
943 READ_BUF(verify
->ve_attrlen
);
944 SAVEMEM(verify
->ve_attrval
, verify
->ve_attrlen
);
950 nfsd4_decode_write(struct nfsd4_compoundargs
*argp
, struct nfsd4_write
*write
)
957 status
= nfsd4_decode_stateid(argp
, &write
->wr_stateid
);
961 READ64(write
->wr_offset
);
962 READ32(write
->wr_stable_how
);
963 if (write
->wr_stable_how
> 2)
965 READ32(write
->wr_buflen
);
967 /* Sorry .. no magic macros for this.. *
968 * READ_BUF(write->wr_buflen);
969 * SAVEMEM(write->wr_buf, write->wr_buflen);
971 avail
= (char*)argp
->end
- (char*)argp
->p
;
972 if (avail
+ argp
->pagelen
< write
->wr_buflen
) {
973 dprintk("NFSD: xdr error (%s:%d)\n",
977 argp
->rqstp
->rq_vec
[0].iov_base
= p
;
978 argp
->rqstp
->rq_vec
[0].iov_len
= avail
;
980 len
= write
->wr_buflen
;
981 while (len
> argp
->rqstp
->rq_vec
[v
].iov_len
) {
982 len
-= argp
->rqstp
->rq_vec
[v
].iov_len
;
984 argp
->rqstp
->rq_vec
[v
].iov_base
= page_address(argp
->pagelist
[0]);
986 if (argp
->pagelen
>= PAGE_SIZE
) {
987 argp
->rqstp
->rq_vec
[v
].iov_len
= PAGE_SIZE
;
988 argp
->pagelen
-= PAGE_SIZE
;
990 argp
->rqstp
->rq_vec
[v
].iov_len
= argp
->pagelen
;
991 argp
->pagelen
-= len
;
994 argp
->end
= (__be32
*) (argp
->rqstp
->rq_vec
[v
].iov_base
+ argp
->rqstp
->rq_vec
[v
].iov_len
);
995 argp
->p
= (__be32
*) (argp
->rqstp
->rq_vec
[v
].iov_base
+ (XDR_QUADLEN(len
) << 2));
996 argp
->rqstp
->rq_vec
[v
].iov_len
= len
;
997 write
->wr_vlen
= v
+1;
1003 nfsd4_decode_release_lockowner(struct nfsd4_compoundargs
*argp
, struct nfsd4_release_lockowner
*rlockowner
)
1008 COPYMEM(&rlockowner
->rl_clientid
, sizeof(clientid_t
));
1009 READ32(rlockowner
->rl_owner
.len
);
1010 READ_BUF(rlockowner
->rl_owner
.len
);
1011 READMEM(rlockowner
->rl_owner
.data
, rlockowner
->rl_owner
.len
);
1013 if (argp
->minorversion
&& !zero_clientid(&rlockowner
->rl_clientid
))
1014 return nfserr_inval
;
1019 nfsd4_decode_exchange_id(struct nfsd4_compoundargs
*argp
,
1020 struct nfsd4_exchange_id
*exid
)
1025 READ_BUF(NFS4_VERIFIER_SIZE
);
1026 COPYMEM(exid
->verifier
.data
, NFS4_VERIFIER_SIZE
);
1029 READ32(exid
->clname
.len
);
1031 READ_BUF(exid
->clname
.len
);
1032 SAVEMEM(exid
->clname
.data
, exid
->clname
.len
);
1035 READ32(exid
->flags
);
1037 /* Ignore state_protect4_a */
1039 READ32(exid
->spa_how
);
1040 switch (exid
->spa_how
) {
1044 /* spo_must_enforce */
1047 READ_BUF(dummy
* 4);
1050 /* spo_must_allow */
1053 READ_BUF(dummy
* 4);
1060 READ_BUF(dummy
* 4);
1065 READ_BUF(dummy
* 4);
1068 /* ssp_hash_algs<> */
1072 p
+= XDR_QUADLEN(dummy
);
1074 /* ssp_encr_algs<> */
1078 p
+= XDR_QUADLEN(dummy
);
1080 /* ssp_window and ssp_num_gss_handles */
1089 /* Ignore Implementation ID */
1090 READ_BUF(4); /* nfs_impl_id4 array length */
1101 p
+= XDR_QUADLEN(dummy
);
1107 p
+= XDR_QUADLEN(dummy
);
1117 nfsd4_decode_create_session(struct nfsd4_compoundargs
*argp
,
1118 struct nfsd4_create_session
*sess
)
1128 COPYMEM(&sess
->clientid
, 8);
1129 READ32(sess
->seqid
);
1130 READ32(sess
->flags
);
1132 /* Fore channel attrs */
1134 READ32(dummy
); /* headerpadsz is always 0 */
1135 READ32(sess
->fore_channel
.maxreq_sz
);
1136 READ32(sess
->fore_channel
.maxresp_sz
);
1137 READ32(sess
->fore_channel
.maxresp_cached
);
1138 READ32(sess
->fore_channel
.maxops
);
1139 READ32(sess
->fore_channel
.maxreqs
);
1140 READ32(sess
->fore_channel
.nr_rdma_attrs
);
1141 if (sess
->fore_channel
.nr_rdma_attrs
== 1) {
1143 READ32(sess
->fore_channel
.rdma_attrs
);
1144 } else if (sess
->fore_channel
.nr_rdma_attrs
> 1) {
1145 dprintk("Too many fore channel attr bitmaps!\n");
1149 /* Back channel attrs */
1151 READ32(dummy
); /* headerpadsz is always 0 */
1152 READ32(sess
->back_channel
.maxreq_sz
);
1153 READ32(sess
->back_channel
.maxresp_sz
);
1154 READ32(sess
->back_channel
.maxresp_cached
);
1155 READ32(sess
->back_channel
.maxops
);
1156 READ32(sess
->back_channel
.maxreqs
);
1157 READ32(sess
->back_channel
.nr_rdma_attrs
);
1158 if (sess
->back_channel
.nr_rdma_attrs
== 1) {
1160 READ32(sess
->back_channel
.rdma_attrs
);
1161 } else if (sess
->back_channel
.nr_rdma_attrs
> 1) {
1162 dprintk("Too many back channel attr bitmaps!\n");
1167 READ32(sess
->callback_prog
);
1169 /* callback_sec_params4 */
1170 READ32(nr_secflavs
);
1171 for (i
= 0; i
< nr_secflavs
; ++i
) {
1176 /* Nothing to read */
1186 SAVEMEM(machine_name
, dummy
);
1196 READ_BUF(dummy
* 4);
1197 for (i
= 0; i
< dummy
; ++i
)
1201 dprintk("RPC_AUTH_GSS callback secflavor "
1202 "not supported!\n");
1206 /* gcbp_handle_from_server */
1209 p
+= XDR_QUADLEN(dummy
);
1210 /* gcbp_handle_from_client */
1214 p
+= XDR_QUADLEN(dummy
);
1217 dprintk("Illegal callback secflavor\n");
1218 return nfserr_inval
;
1225 nfsd4_decode_destroy_session(struct nfsd4_compoundargs
*argp
,
1226 struct nfsd4_destroy_session
*destroy_session
)
1229 READ_BUF(NFS4_MAX_SESSIONID_LEN
);
1230 COPYMEM(destroy_session
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
1236 nfsd4_decode_sequence(struct nfsd4_compoundargs
*argp
,
1237 struct nfsd4_sequence
*seq
)
1241 READ_BUF(NFS4_MAX_SESSIONID_LEN
+ 16);
1242 COPYMEM(seq
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
1244 READ32(seq
->slotid
);
1245 READ32(seq
->maxslots
);
1246 READ32(seq
->cachethis
);
1252 nfsd4_decode_noop(struct nfsd4_compoundargs
*argp
, void *p
)
1258 nfsd4_decode_notsupp(struct nfsd4_compoundargs
*argp
, void *p
)
1260 return nfserr_notsupp
;
1263 typedef __be32(*nfsd4_dec
)(struct nfsd4_compoundargs
*argp
, void *);
1265 static nfsd4_dec nfsd4_dec_ops
[] = {
1266 [OP_ACCESS
] = (nfsd4_dec
)nfsd4_decode_access
,
1267 [OP_CLOSE
] = (nfsd4_dec
)nfsd4_decode_close
,
1268 [OP_COMMIT
] = (nfsd4_dec
)nfsd4_decode_commit
,
1269 [OP_CREATE
] = (nfsd4_dec
)nfsd4_decode_create
,
1270 [OP_DELEGPURGE
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1271 [OP_DELEGRETURN
] = (nfsd4_dec
)nfsd4_decode_delegreturn
,
1272 [OP_GETATTR
] = (nfsd4_dec
)nfsd4_decode_getattr
,
1273 [OP_GETFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1274 [OP_LINK
] = (nfsd4_dec
)nfsd4_decode_link
,
1275 [OP_LOCK
] = (nfsd4_dec
)nfsd4_decode_lock
,
1276 [OP_LOCKT
] = (nfsd4_dec
)nfsd4_decode_lockt
,
1277 [OP_LOCKU
] = (nfsd4_dec
)nfsd4_decode_locku
,
1278 [OP_LOOKUP
] = (nfsd4_dec
)nfsd4_decode_lookup
,
1279 [OP_LOOKUPP
] = (nfsd4_dec
)nfsd4_decode_noop
,
1280 [OP_NVERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
1281 [OP_OPEN
] = (nfsd4_dec
)nfsd4_decode_open
,
1282 [OP_OPENATTR
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1283 [OP_OPEN_CONFIRM
] = (nfsd4_dec
)nfsd4_decode_open_confirm
,
1284 [OP_OPEN_DOWNGRADE
] = (nfsd4_dec
)nfsd4_decode_open_downgrade
,
1285 [OP_PUTFH
] = (nfsd4_dec
)nfsd4_decode_putfh
,
1286 [OP_PUTPUBFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1287 [OP_PUTROOTFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1288 [OP_READ
] = (nfsd4_dec
)nfsd4_decode_read
,
1289 [OP_READDIR
] = (nfsd4_dec
)nfsd4_decode_readdir
,
1290 [OP_READLINK
] = (nfsd4_dec
)nfsd4_decode_noop
,
1291 [OP_REMOVE
] = (nfsd4_dec
)nfsd4_decode_remove
,
1292 [OP_RENAME
] = (nfsd4_dec
)nfsd4_decode_rename
,
1293 [OP_RENEW
] = (nfsd4_dec
)nfsd4_decode_renew
,
1294 [OP_RESTOREFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1295 [OP_SAVEFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1296 [OP_SECINFO
] = (nfsd4_dec
)nfsd4_decode_secinfo
,
1297 [OP_SETATTR
] = (nfsd4_dec
)nfsd4_decode_setattr
,
1298 [OP_SETCLIENTID
] = (nfsd4_dec
)nfsd4_decode_setclientid
,
1299 [OP_SETCLIENTID_CONFIRM
] = (nfsd4_dec
)nfsd4_decode_setclientid_confirm
,
1300 [OP_VERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
1301 [OP_WRITE
] = (nfsd4_dec
)nfsd4_decode_write
,
1302 [OP_RELEASE_LOCKOWNER
] = (nfsd4_dec
)nfsd4_decode_release_lockowner
,
1305 static nfsd4_dec nfsd41_dec_ops
[] = {
1306 [OP_ACCESS
] (nfsd4_dec
)nfsd4_decode_access
,
1307 [OP_CLOSE
] (nfsd4_dec
)nfsd4_decode_close
,
1308 [OP_COMMIT
] (nfsd4_dec
)nfsd4_decode_commit
,
1309 [OP_CREATE
] (nfsd4_dec
)nfsd4_decode_create
,
1310 [OP_DELEGPURGE
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1311 [OP_DELEGRETURN
] (nfsd4_dec
)nfsd4_decode_delegreturn
,
1312 [OP_GETATTR
] (nfsd4_dec
)nfsd4_decode_getattr
,
1313 [OP_GETFH
] (nfsd4_dec
)nfsd4_decode_noop
,
1314 [OP_LINK
] (nfsd4_dec
)nfsd4_decode_link
,
1315 [OP_LOCK
] (nfsd4_dec
)nfsd4_decode_lock
,
1316 [OP_LOCKT
] (nfsd4_dec
)nfsd4_decode_lockt
,
1317 [OP_LOCKU
] (nfsd4_dec
)nfsd4_decode_locku
,
1318 [OP_LOOKUP
] (nfsd4_dec
)nfsd4_decode_lookup
,
1319 [OP_LOOKUPP
] (nfsd4_dec
)nfsd4_decode_noop
,
1320 [OP_NVERIFY
] (nfsd4_dec
)nfsd4_decode_verify
,
1321 [OP_OPEN
] (nfsd4_dec
)nfsd4_decode_open
,
1322 [OP_OPENATTR
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1323 [OP_OPEN_CONFIRM
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1324 [OP_OPEN_DOWNGRADE
] (nfsd4_dec
)nfsd4_decode_open_downgrade
,
1325 [OP_PUTFH
] (nfsd4_dec
)nfsd4_decode_putfh
,
1326 [OP_PUTPUBFH
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1327 [OP_PUTROOTFH
] (nfsd4_dec
)nfsd4_decode_noop
,
1328 [OP_READ
] (nfsd4_dec
)nfsd4_decode_read
,
1329 [OP_READDIR
] (nfsd4_dec
)nfsd4_decode_readdir
,
1330 [OP_READLINK
] (nfsd4_dec
)nfsd4_decode_noop
,
1331 [OP_REMOVE
] (nfsd4_dec
)nfsd4_decode_remove
,
1332 [OP_RENAME
] (nfsd4_dec
)nfsd4_decode_rename
,
1333 [OP_RENEW
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1334 [OP_RESTOREFH
] (nfsd4_dec
)nfsd4_decode_noop
,
1335 [OP_SAVEFH
] (nfsd4_dec
)nfsd4_decode_noop
,
1336 [OP_SECINFO
] (nfsd4_dec
)nfsd4_decode_secinfo
,
1337 [OP_SETATTR
] (nfsd4_dec
)nfsd4_decode_setattr
,
1338 [OP_SETCLIENTID
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1339 [OP_SETCLIENTID_CONFIRM
](nfsd4_dec
)nfsd4_decode_notsupp
,
1340 [OP_VERIFY
] (nfsd4_dec
)nfsd4_decode_verify
,
1341 [OP_WRITE
] (nfsd4_dec
)nfsd4_decode_write
,
1342 [OP_RELEASE_LOCKOWNER
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1344 /* new operations for NFSv4.1 */
1345 [OP_BACKCHANNEL_CTL
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1346 [OP_BIND_CONN_TO_SESSION
](nfsd4_dec
)nfsd4_decode_notsupp
,
1347 [OP_EXCHANGE_ID
] (nfsd4_dec
)nfsd4_decode_exchange_id
,
1348 [OP_CREATE_SESSION
] (nfsd4_dec
)nfsd4_decode_create_session
,
1349 [OP_DESTROY_SESSION
] (nfsd4_dec
)nfsd4_decode_destroy_session
,
1350 [OP_FREE_STATEID
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1351 [OP_GET_DIR_DELEGATION
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1352 [OP_GETDEVICEINFO
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1353 [OP_GETDEVICELIST
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1354 [OP_LAYOUTCOMMIT
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1355 [OP_LAYOUTGET
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1356 [OP_LAYOUTRETURN
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1357 [OP_SECINFO_NO_NAME
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1358 [OP_SEQUENCE
] (nfsd4_dec
)nfsd4_decode_sequence
,
1359 [OP_SET_SSV
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1360 [OP_TEST_STATEID
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1361 [OP_WANT_DELEGATION
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1362 [OP_DESTROY_CLIENTID
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1363 [OP_RECLAIM_COMPLETE
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1366 struct nfsd4_minorversion_ops
{
1367 nfsd4_dec
*decoders
;
1371 static struct nfsd4_minorversion_ops nfsd4_minorversion
[] = {
1372 [0] = { nfsd4_dec_ops
, ARRAY_SIZE(nfsd4_dec_ops
) },
1373 [1] = { nfsd41_dec_ops
, ARRAY_SIZE(nfsd41_dec_ops
) },
1377 nfsd4_decode_compound(struct nfsd4_compoundargs
*argp
)
1380 struct nfsd4_op
*op
;
1381 struct nfsd4_minorversion_ops
*ops
;
1385 * XXX: According to spec, we should check the tag
1386 * for UTF-8 compliance. I'm postponing this for
1387 * now because it seems that some clients do use
1391 READ32(argp
->taglen
);
1392 READ_BUF(argp
->taglen
+ 8);
1393 SAVEMEM(argp
->tag
, argp
->taglen
);
1394 READ32(argp
->minorversion
);
1395 READ32(argp
->opcnt
);
1397 if (argp
->taglen
> NFSD4_MAX_TAGLEN
)
1399 if (argp
->opcnt
> 100)
1402 if (argp
->opcnt
> ARRAY_SIZE(argp
->iops
)) {
1403 argp
->ops
= kmalloc(argp
->opcnt
* sizeof(*argp
->ops
), GFP_KERNEL
);
1405 argp
->ops
= argp
->iops
;
1406 dprintk("nfsd: couldn't allocate room for COMPOUND\n");
1411 if (argp
->minorversion
>= ARRAY_SIZE(nfsd4_minorversion
))
1414 ops
= &nfsd4_minorversion
[argp
->minorversion
];
1415 for (i
= 0; i
< argp
->opcnt
; i
++) {
1420 * We can't use READ_BUF() here because we need to handle
1421 * a missing opcode as an OP_WRITE + 1. So we need to check
1422 * to see if we're truly at the end of our buffer or if there
1423 * is another page we need to flip to.
1426 if (argp
->p
== argp
->end
) {
1427 if (argp
->pagelen
< 4) {
1428 /* There isn't an opcode still on the wire */
1429 op
->opnum
= OP_WRITE
+ 1;
1430 op
->status
= nfserr_bad_xdr
;
1436 * False alarm. We just hit a page boundary, but there
1437 * is still data available. Move pointer across page
1438 * boundary. *snip from READ_BUF*
1440 argp
->p
= page_address(argp
->pagelist
[0]);
1442 if (argp
->pagelen
< PAGE_SIZE
) {
1443 argp
->end
= p
+ (argp
->pagelen
>>2);
1446 argp
->end
= p
+ (PAGE_SIZE
>>2);
1447 argp
->pagelen
-= PAGE_SIZE
;
1450 op
->opnum
= ntohl(*argp
->p
++);
1452 if (op
->opnum
>= OP_ACCESS
&& op
->opnum
< ops
->nops
)
1453 op
->status
= ops
->decoders
[op
->opnum
](argp
, &op
->u
);
1455 op
->opnum
= OP_ILLEGAL
;
1456 op
->status
= nfserr_op_illegal
;
1468 * END OF "GENERIC" DECODE ROUTINES.
1472 * START OF "GENERIC" ENCODE ROUTINES.
1473 * These may look a little ugly since they are imported from a "generic"
1474 * set of XDR encode/decode routines which are intended to be shared by
1475 * all of our NFSv4 implementations (OpenBSD, MacOS X...).
1477 * If the pain of reading these is too great, it should be a straightforward
1478 * task to translate them into Linux-specific versions which are more
1479 * consistent with the style used in NFSv2/v3...
1481 #define ENCODE_HEAD __be32 *p
1483 #define WRITE32(n) *p++ = htonl(n)
1484 #define WRITE64(n) do { \
1485 *p++ = htonl((u32)((n) >> 32)); \
1486 *p++ = htonl((u32)(n)); \
1488 #define WRITEMEM(ptr,nbytes) do { if (nbytes > 0) { \
1489 *(p + XDR_QUADLEN(nbytes) -1) = 0; \
1490 memcpy(p, ptr, nbytes); \
1491 p += XDR_QUADLEN(nbytes); \
1493 #define WRITECINFO(c) do { \
1494 *p++ = htonl(c.atomic); \
1495 *p++ = htonl(c.before_ctime_sec); \
1496 *p++ = htonl(c.before_ctime_nsec); \
1497 *p++ = htonl(c.after_ctime_sec); \
1498 *p++ = htonl(c.after_ctime_nsec); \
1501 #define RESERVE_SPACE(nbytes) do { \
1503 BUG_ON(p + XDR_QUADLEN(nbytes) > resp->end); \
1505 #define ADJUST_ARGS() resp->p = p
1508 * Header routine to setup seqid operation replay cache
1510 #define ENCODE_SEQID_OP_HEAD \
1516 * Routine for encoding the result of a "seqid-mutating" NFSv4 operation. This
1517 * is where sequence id's are incremented, and the replay cache is filled.
1518 * Note that we increment sequence id's here, at the last moment, so we're sure
1519 * we know whether the error to be returned is a sequence id mutating error.
1522 #define ENCODE_SEQID_OP_TAIL(stateowner) do { \
1523 if (seqid_mutating_err(nfserr) && stateowner) { \
1524 stateowner->so_seqid++; \
1525 stateowner->so_replay.rp_status = nfserr; \
1526 stateowner->so_replay.rp_buflen = \
1527 (((char *)(resp)->p - (char *)save)); \
1528 memcpy(stateowner->so_replay.rp_buf, save, \
1529 stateowner->so_replay.rp_buflen); \
1532 /* Encode as an array of strings the string given with components
1535 static __be32
nfsd4_encode_components(char sep
, char *components
,
1536 __be32
**pp
, int *buflen
)
1540 int strlen
, count
=0;
1543 dprintk("nfsd4_encode_components(%s)\n", components
);
1544 if ((*buflen
-= 4) < 0)
1545 return nfserr_resource
;
1546 WRITE32(0); /* We will fill this in with @count later */
1547 end
= str
= components
;
1549 for (; *end
&& (*end
!= sep
); end
++)
1550 ; /* Point to end of component */
1553 if ((*buflen
-= ((XDR_QUADLEN(strlen
) << 2) + 4)) < 0)
1554 return nfserr_resource
;
1556 WRITEMEM(str
, strlen
);
1570 * encode a location element of a fs_locations structure
1572 static __be32
nfsd4_encode_fs_location4(struct nfsd4_fs_location
*location
,
1573 __be32
**pp
, int *buflen
)
1578 status
= nfsd4_encode_components(':', location
->hosts
, &p
, buflen
);
1581 status
= nfsd4_encode_components('/', location
->path
, &p
, buflen
);
1589 * Return the path to an export point in the pseudo filesystem namespace
1590 * Returned string is safe to use as long as the caller holds a reference
1593 static char *nfsd4_path(struct svc_rqst
*rqstp
, struct svc_export
*exp
, __be32
*stat
)
1595 struct svc_fh tmp_fh
;
1596 char *path
, *rootpath
;
1598 fh_init(&tmp_fh
, NFS4_FHSIZE
);
1599 *stat
= exp_pseudoroot(rqstp
, &tmp_fh
);
1602 rootpath
= tmp_fh
.fh_export
->ex_pathname
;
1604 path
= exp
->ex_pathname
;
1606 if (strncmp(path
, rootpath
, strlen(rootpath
))) {
1607 dprintk("nfsd: fs_locations failed;"
1608 "%s is not contained in %s\n", path
, rootpath
);
1609 *stat
= nfserr_notsupp
;
1613 return path
+ strlen(rootpath
);
1617 * encode a fs_locations structure
1619 static __be32
nfsd4_encode_fs_locations(struct svc_rqst
*rqstp
,
1620 struct svc_export
*exp
,
1621 __be32
**pp
, int *buflen
)
1626 struct nfsd4_fs_locations
*fslocs
= &exp
->ex_fslocs
;
1627 char *root
= nfsd4_path(rqstp
, exp
, &status
);
1631 status
= nfsd4_encode_components('/', root
, &p
, buflen
);
1634 if ((*buflen
-= 4) < 0)
1635 return nfserr_resource
;
1636 WRITE32(fslocs
->locations_count
);
1637 for (i
=0; i
<fslocs
->locations_count
; i
++) {
1638 status
= nfsd4_encode_fs_location4(&fslocs
->locations
[i
],
1647 static u32 nfs4_ftypes
[16] = {
1648 NF4BAD
, NF4FIFO
, NF4CHR
, NF4BAD
,
1649 NF4DIR
, NF4BAD
, NF4BLK
, NF4BAD
,
1650 NF4REG
, NF4BAD
, NF4LNK
, NF4BAD
,
1651 NF4SOCK
, NF4BAD
, NF4LNK
, NF4BAD
,
1655 nfsd4_encode_name(struct svc_rqst
*rqstp
, int whotype
, uid_t id
, int group
,
1656 __be32
**p
, int *buflen
)
1660 if (*buflen
< (XDR_QUADLEN(IDMAP_NAMESZ
) << 2) + 4)
1661 return nfserr_resource
;
1662 if (whotype
!= NFS4_ACL_WHO_NAMED
)
1663 status
= nfs4_acl_write_who(whotype
, (u8
*)(*p
+ 1));
1665 status
= nfsd_map_gid_to_name(rqstp
, id
, (u8
*)(*p
+ 1));
1667 status
= nfsd_map_uid_to_name(rqstp
, id
, (u8
*)(*p
+ 1));
1669 return nfserrno(status
);
1670 *p
= xdr_encode_opaque(*p
, NULL
, status
);
1671 *buflen
-= (XDR_QUADLEN(status
) << 2) + 4;
1672 BUG_ON(*buflen
< 0);
1676 static inline __be32
1677 nfsd4_encode_user(struct svc_rqst
*rqstp
, uid_t uid
, __be32
**p
, int *buflen
)
1679 return nfsd4_encode_name(rqstp
, NFS4_ACL_WHO_NAMED
, uid
, 0, p
, buflen
);
1682 static inline __be32
1683 nfsd4_encode_group(struct svc_rqst
*rqstp
, uid_t gid
, __be32
**p
, int *buflen
)
1685 return nfsd4_encode_name(rqstp
, NFS4_ACL_WHO_NAMED
, gid
, 1, p
, buflen
);
1688 static inline __be32
1689 nfsd4_encode_aclname(struct svc_rqst
*rqstp
, int whotype
, uid_t id
, int group
,
1690 __be32
**p
, int *buflen
)
1692 return nfsd4_encode_name(rqstp
, whotype
, id
, group
, p
, buflen
);
1695 #define WORD0_ABSENT_FS_ATTRS (FATTR4_WORD0_FS_LOCATIONS | FATTR4_WORD0_FSID | \
1696 FATTR4_WORD0_RDATTR_ERROR)
1697 #define WORD1_ABSENT_FS_ATTRS FATTR4_WORD1_MOUNTED_ON_FILEID
1699 static __be32
fattr_handle_absent_fs(u32
*bmval0
, u32
*bmval1
, u32
*rdattr_err
)
1701 /* As per referral draft: */
1702 if (*bmval0
& ~WORD0_ABSENT_FS_ATTRS
||
1703 *bmval1
& ~WORD1_ABSENT_FS_ATTRS
) {
1704 if (*bmval0
& FATTR4_WORD0_RDATTR_ERROR
||
1705 *bmval0
& FATTR4_WORD0_FS_LOCATIONS
)
1706 *rdattr_err
= NFSERR_MOVED
;
1708 return nfserr_moved
;
1710 *bmval0
&= WORD0_ABSENT_FS_ATTRS
;
1711 *bmval1
&= WORD1_ABSENT_FS_ATTRS
;
1716 * Note: @fhp can be NULL; in this case, we might have to compose the filehandle
1719 * @countp is the buffer size in _words_; upon successful return this becomes
1720 * replaced with the number of words written.
1723 nfsd4_encode_fattr(struct svc_fh
*fhp
, struct svc_export
*exp
,
1724 struct dentry
*dentry
, __be32
*buffer
, int *countp
, u32
*bmval
,
1725 struct svc_rqst
*rqstp
, int ignore_crossmnt
)
1727 u32 bmval0
= bmval
[0];
1728 u32 bmval1
= bmval
[1];
1730 struct svc_fh tempfh
;
1731 struct kstatfs statfs
;
1732 int buflen
= *countp
<< 2;
1741 struct nfs4_acl
*acl
= NULL
;
1743 BUG_ON(bmval1
& NFSD_WRITEONLY_ATTRS_WORD1
);
1744 BUG_ON(bmval0
& ~NFSD_SUPPORTED_ATTRS_WORD0
);
1745 BUG_ON(bmval1
& ~NFSD_SUPPORTED_ATTRS_WORD1
);
1747 if (exp
->ex_fslocs
.migrated
) {
1748 status
= fattr_handle_absent_fs(&bmval0
, &bmval1
, &rdattr_err
);
1753 err
= vfs_getattr(exp
->ex_path
.mnt
, dentry
, &stat
);
1756 if ((bmval0
& (FATTR4_WORD0_FILES_FREE
| FATTR4_WORD0_FILES_TOTAL
|
1757 FATTR4_WORD0_MAXNAME
)) ||
1758 (bmval1
& (FATTR4_WORD1_SPACE_AVAIL
| FATTR4_WORD1_SPACE_FREE
|
1759 FATTR4_WORD1_SPACE_TOTAL
))) {
1760 err
= vfs_statfs(dentry
, &statfs
);
1764 if ((bmval0
& (FATTR4_WORD0_FILEHANDLE
| FATTR4_WORD0_FSID
)) && !fhp
) {
1765 fh_init(&tempfh
, NFS4_FHSIZE
);
1766 status
= fh_compose(&tempfh
, exp
, dentry
, NULL
);
1771 if (bmval0
& (FATTR4_WORD0_ACL
| FATTR4_WORD0_ACLSUPPORT
1772 | FATTR4_WORD0_SUPPORTED_ATTRS
)) {
1773 err
= nfsd4_get_nfs4_acl(rqstp
, dentry
, &acl
);
1774 aclsupport
= (err
== 0);
1775 if (bmval0
& FATTR4_WORD0_ACL
) {
1776 if (err
== -EOPNOTSUPP
)
1777 bmval0
&= ~FATTR4_WORD0_ACL
;
1778 else if (err
== -EINVAL
) {
1779 status
= nfserr_attrnotsupp
;
1781 } else if (err
!= 0)
1785 if (bmval0
& FATTR4_WORD0_FS_LOCATIONS
) {
1786 if (exp
->ex_fslocs
.locations
== NULL
) {
1787 bmval0
&= ~FATTR4_WORD0_FS_LOCATIONS
;
1790 if ((buflen
-= 16) < 0)
1796 attrlenp
= p
++; /* to be backfilled later */
1798 if (bmval0
& FATTR4_WORD0_SUPPORTED_ATTRS
) {
1799 u32 word0
= NFSD_SUPPORTED_ATTRS_WORD0
;
1800 if ((buflen
-= 12) < 0)
1803 word0
&= ~FATTR4_WORD0_ACL
;
1804 if (!exp
->ex_fslocs
.locations
)
1805 word0
&= ~FATTR4_WORD0_FS_LOCATIONS
;
1808 WRITE32(NFSD_SUPPORTED_ATTRS_WORD1
);
1810 if (bmval0
& FATTR4_WORD0_TYPE
) {
1811 if ((buflen
-= 4) < 0)
1813 dummy
= nfs4_ftypes
[(stat
.mode
& S_IFMT
) >> 12];
1814 if (dummy
== NF4BAD
)
1815 goto out_serverfault
;
1818 if (bmval0
& FATTR4_WORD0_FH_EXPIRE_TYPE
) {
1819 if ((buflen
-= 4) < 0)
1821 if (exp
->ex_flags
& NFSEXP_NOSUBTREECHECK
)
1822 WRITE32(NFS4_FH_PERSISTENT
);
1824 WRITE32(NFS4_FH_PERSISTENT
|NFS4_FH_VOL_RENAME
);
1826 if (bmval0
& FATTR4_WORD0_CHANGE
) {
1828 * Note: This _must_ be consistent with the scheme for writing
1829 * change_info, so any changes made here must be reflected there
1830 * as well. (See xdr4.h:set_change_info() and the WRITECINFO()
1833 if ((buflen
-= 8) < 0)
1835 WRITE32(stat
.ctime
.tv_sec
);
1836 WRITE32(stat
.ctime
.tv_nsec
);
1838 if (bmval0
& FATTR4_WORD0_SIZE
) {
1839 if ((buflen
-= 8) < 0)
1843 if (bmval0
& FATTR4_WORD0_LINK_SUPPORT
) {
1844 if ((buflen
-= 4) < 0)
1848 if (bmval0
& FATTR4_WORD0_SYMLINK_SUPPORT
) {
1849 if ((buflen
-= 4) < 0)
1853 if (bmval0
& FATTR4_WORD0_NAMED_ATTR
) {
1854 if ((buflen
-= 4) < 0)
1858 if (bmval0
& FATTR4_WORD0_FSID
) {
1859 if ((buflen
-= 16) < 0)
1861 if (exp
->ex_fslocs
.migrated
) {
1862 WRITE64(NFS4_REFERRAL_FSID_MAJOR
);
1863 WRITE64(NFS4_REFERRAL_FSID_MINOR
);
1864 } else switch(fsid_source(fhp
)) {
1865 case FSIDSOURCE_FSID
:
1866 WRITE64((u64
)exp
->ex_fsid
);
1869 case FSIDSOURCE_DEV
:
1871 WRITE32(MAJOR(stat
.dev
));
1873 WRITE32(MINOR(stat
.dev
));
1875 case FSIDSOURCE_UUID
:
1876 WRITEMEM(exp
->ex_uuid
, 16);
1880 if (bmval0
& FATTR4_WORD0_UNIQUE_HANDLES
) {
1881 if ((buflen
-= 4) < 0)
1885 if (bmval0
& FATTR4_WORD0_LEASE_TIME
) {
1886 if ((buflen
-= 4) < 0)
1888 WRITE32(NFSD_LEASE_TIME
);
1890 if (bmval0
& FATTR4_WORD0_RDATTR_ERROR
) {
1891 if ((buflen
-= 4) < 0)
1893 WRITE32(rdattr_err
);
1895 if (bmval0
& FATTR4_WORD0_ACL
) {
1896 struct nfs4_ace
*ace
;
1899 if ((buflen
-= 4) < 0)
1905 if ((buflen
-= 4) < 0)
1907 WRITE32(acl
->naces
);
1909 for (ace
= acl
->aces
; ace
< acl
->aces
+ acl
->naces
; ace
++) {
1910 if ((buflen
-= 4*3) < 0)
1914 WRITE32(ace
->access_mask
& NFS4_ACE_MASK_ALL
);
1915 status
= nfsd4_encode_aclname(rqstp
, ace
->whotype
,
1916 ace
->who
, ace
->flag
& NFS4_ACE_IDENTIFIER_GROUP
,
1918 if (status
== nfserr_resource
)
1925 if (bmval0
& FATTR4_WORD0_ACLSUPPORT
) {
1926 if ((buflen
-= 4) < 0)
1928 WRITE32(aclsupport
?
1929 ACL4_SUPPORT_ALLOW_ACL
|ACL4_SUPPORT_DENY_ACL
: 0);
1931 if (bmval0
& FATTR4_WORD0_CANSETTIME
) {
1932 if ((buflen
-= 4) < 0)
1936 if (bmval0
& FATTR4_WORD0_CASE_INSENSITIVE
) {
1937 if ((buflen
-= 4) < 0)
1941 if (bmval0
& FATTR4_WORD0_CASE_PRESERVING
) {
1942 if ((buflen
-= 4) < 0)
1946 if (bmval0
& FATTR4_WORD0_CHOWN_RESTRICTED
) {
1947 if ((buflen
-= 4) < 0)
1951 if (bmval0
& FATTR4_WORD0_FILEHANDLE
) {
1952 buflen
-= (XDR_QUADLEN(fhp
->fh_handle
.fh_size
) << 2) + 4;
1955 WRITE32(fhp
->fh_handle
.fh_size
);
1956 WRITEMEM(&fhp
->fh_handle
.fh_base
, fhp
->fh_handle
.fh_size
);
1958 if (bmval0
& FATTR4_WORD0_FILEID
) {
1959 if ((buflen
-= 8) < 0)
1963 if (bmval0
& FATTR4_WORD0_FILES_AVAIL
) {
1964 if ((buflen
-= 8) < 0)
1966 WRITE64((u64
) statfs
.f_ffree
);
1968 if (bmval0
& FATTR4_WORD0_FILES_FREE
) {
1969 if ((buflen
-= 8) < 0)
1971 WRITE64((u64
) statfs
.f_ffree
);
1973 if (bmval0
& FATTR4_WORD0_FILES_TOTAL
) {
1974 if ((buflen
-= 8) < 0)
1976 WRITE64((u64
) statfs
.f_files
);
1978 if (bmval0
& FATTR4_WORD0_FS_LOCATIONS
) {
1979 status
= nfsd4_encode_fs_locations(rqstp
, exp
, &p
, &buflen
);
1980 if (status
== nfserr_resource
)
1985 if (bmval0
& FATTR4_WORD0_HOMOGENEOUS
) {
1986 if ((buflen
-= 4) < 0)
1990 if (bmval0
& FATTR4_WORD0_MAXFILESIZE
) {
1991 if ((buflen
-= 8) < 0)
1995 if (bmval0
& FATTR4_WORD0_MAXLINK
) {
1996 if ((buflen
-= 4) < 0)
2000 if (bmval0
& FATTR4_WORD0_MAXNAME
) {
2001 if ((buflen
-= 4) < 0)
2003 WRITE32(statfs
.f_namelen
);
2005 if (bmval0
& FATTR4_WORD0_MAXREAD
) {
2006 if ((buflen
-= 8) < 0)
2008 WRITE64((u64
) svc_max_payload(rqstp
));
2010 if (bmval0
& FATTR4_WORD0_MAXWRITE
) {
2011 if ((buflen
-= 8) < 0)
2013 WRITE64((u64
) svc_max_payload(rqstp
));
2015 if (bmval1
& FATTR4_WORD1_MODE
) {
2016 if ((buflen
-= 4) < 0)
2018 WRITE32(stat
.mode
& S_IALLUGO
);
2020 if (bmval1
& FATTR4_WORD1_NO_TRUNC
) {
2021 if ((buflen
-= 4) < 0)
2025 if (bmval1
& FATTR4_WORD1_NUMLINKS
) {
2026 if ((buflen
-= 4) < 0)
2028 WRITE32(stat
.nlink
);
2030 if (bmval1
& FATTR4_WORD1_OWNER
) {
2031 status
= nfsd4_encode_user(rqstp
, stat
.uid
, &p
, &buflen
);
2032 if (status
== nfserr_resource
)
2037 if (bmval1
& FATTR4_WORD1_OWNER_GROUP
) {
2038 status
= nfsd4_encode_group(rqstp
, stat
.gid
, &p
, &buflen
);
2039 if (status
== nfserr_resource
)
2044 if (bmval1
& FATTR4_WORD1_RAWDEV
) {
2045 if ((buflen
-= 8) < 0)
2047 WRITE32((u32
) MAJOR(stat
.rdev
));
2048 WRITE32((u32
) MINOR(stat
.rdev
));
2050 if (bmval1
& FATTR4_WORD1_SPACE_AVAIL
) {
2051 if ((buflen
-= 8) < 0)
2053 dummy64
= (u64
)statfs
.f_bavail
* (u64
)statfs
.f_bsize
;
2056 if (bmval1
& FATTR4_WORD1_SPACE_FREE
) {
2057 if ((buflen
-= 8) < 0)
2059 dummy64
= (u64
)statfs
.f_bfree
* (u64
)statfs
.f_bsize
;
2062 if (bmval1
& FATTR4_WORD1_SPACE_TOTAL
) {
2063 if ((buflen
-= 8) < 0)
2065 dummy64
= (u64
)statfs
.f_blocks
* (u64
)statfs
.f_bsize
;
2068 if (bmval1
& FATTR4_WORD1_SPACE_USED
) {
2069 if ((buflen
-= 8) < 0)
2071 dummy64
= (u64
)stat
.blocks
<< 9;
2074 if (bmval1
& FATTR4_WORD1_TIME_ACCESS
) {
2075 if ((buflen
-= 12) < 0)
2078 WRITE32(stat
.atime
.tv_sec
);
2079 WRITE32(stat
.atime
.tv_nsec
);
2081 if (bmval1
& FATTR4_WORD1_TIME_DELTA
) {
2082 if ((buflen
-= 12) < 0)
2088 if (bmval1
& FATTR4_WORD1_TIME_METADATA
) {
2089 if ((buflen
-= 12) < 0)
2092 WRITE32(stat
.ctime
.tv_sec
);
2093 WRITE32(stat
.ctime
.tv_nsec
);
2095 if (bmval1
& FATTR4_WORD1_TIME_MODIFY
) {
2096 if ((buflen
-= 12) < 0)
2099 WRITE32(stat
.mtime
.tv_sec
);
2100 WRITE32(stat
.mtime
.tv_nsec
);
2102 if (bmval1
& FATTR4_WORD1_MOUNTED_ON_FILEID
) {
2103 if ((buflen
-= 8) < 0)
2106 * Get parent's attributes if not ignoring crossmount
2107 * and this is the root of a cross-mounted filesystem.
2109 if (ignore_crossmnt
== 0 &&
2110 exp
->ex_path
.mnt
->mnt_root
->d_inode
== dentry
->d_inode
) {
2111 err
= vfs_getattr(exp
->ex_path
.mnt
->mnt_parent
,
2112 exp
->ex_path
.mnt
->mnt_mountpoint
, &stat
);
2118 *attrlenp
= htonl((char *)p
- (char *)attrlenp
- 4);
2119 *countp
= p
- buffer
;
2128 status
= nfserrno(err
);
2132 status
= nfserr_resource
;
2135 status
= nfserr_serverfault
;
2139 static inline int attributes_need_mount(u32
*bmval
)
2141 if (bmval
[0] & ~(FATTR4_WORD0_RDATTR_ERROR
| FATTR4_WORD0_LEASE_TIME
))
2143 if (bmval
[1] & ~FATTR4_WORD1_MOUNTED_ON_FILEID
)
2149 nfsd4_encode_dirent_fattr(struct nfsd4_readdir
*cd
,
2150 const char *name
, int namlen
, __be32
*p
, int *buflen
)
2152 struct svc_export
*exp
= cd
->rd_fhp
->fh_export
;
2153 struct dentry
*dentry
;
2155 int ignore_crossmnt
= 0;
2157 dentry
= lookup_one_len(name
, cd
->rd_fhp
->fh_dentry
, namlen
);
2159 return nfserrno(PTR_ERR(dentry
));
2163 * In the case of a mountpoint, the client may be asking for
2164 * attributes that are only properties of the underlying filesystem
2165 * as opposed to the cross-mounted file system. In such a case,
2166 * we will not follow the cross mount and will fill the attribtutes
2167 * directly from the mountpoint dentry.
2169 if (d_mountpoint(dentry
) && !attributes_need_mount(cd
->rd_bmval
))
2170 ignore_crossmnt
= 1;
2171 else if (d_mountpoint(dentry
)) {
2175 * Why the heck aren't we just using nfsd_lookup??
2176 * Different "."/".." handling? Something else?
2177 * At least, add a comment here to explain....
2179 err
= nfsd_cross_mnt(cd
->rd_rqstp
, &dentry
, &exp
);
2181 nfserr
= nfserrno(err
);
2184 nfserr
= check_nfsd_access(exp
, cd
->rd_rqstp
);
2189 nfserr
= nfsd4_encode_fattr(NULL
, exp
, dentry
, p
, buflen
, cd
->rd_bmval
,
2190 cd
->rd_rqstp
, ignore_crossmnt
);
2198 nfsd4_encode_rdattr_error(__be32
*p
, int buflen
, __be32 nfserr
)
2205 *p
++ = htonl(FATTR4_WORD0_RDATTR_ERROR
); /* bmval0 */
2206 *p
++ = htonl(0); /* bmval1 */
2209 *p
++ = nfserr
; /* no htonl */
2210 *attrlenp
= htonl((char *)p
- (char *)attrlenp
- 4);
2215 nfsd4_encode_dirent(void *ccdv
, const char *name
, int namlen
,
2216 loff_t offset
, u64 ino
, unsigned int d_type
)
2218 struct readdir_cd
*ccd
= ccdv
;
2219 struct nfsd4_readdir
*cd
= container_of(ccd
, struct nfsd4_readdir
, common
);
2221 __be32
*p
= cd
->buffer
;
2222 __be32 nfserr
= nfserr_toosmall
;
2224 /* In nfsv4, "." and ".." never make it onto the wire.. */
2225 if (name
&& isdotent(name
, namlen
)) {
2226 cd
->common
.err
= nfs_ok
;
2231 xdr_encode_hyper(cd
->offset
, (u64
) offset
);
2233 buflen
= cd
->buflen
- 4 - XDR_QUADLEN(namlen
);
2237 *p
++ = xdr_one
; /* mark entry present */
2238 cd
->offset
= p
; /* remember pointer */
2239 p
= xdr_encode_hyper(p
, NFS_OFFSET_MAX
); /* offset of next entry */
2240 p
= xdr_encode_array(p
, name
, namlen
); /* name length & name */
2242 nfserr
= nfsd4_encode_dirent_fattr(cd
, name
, namlen
, p
, &buflen
);
2247 case nfserr_resource
:
2248 nfserr
= nfserr_toosmall
;
2254 * If the client requested the RDATTR_ERROR attribute,
2255 * we stuff the error code into this attribute
2256 * and continue. If this attribute was not requested,
2257 * then in accordance with the spec, we fail the
2258 * entire READDIR operation(!)
2260 if (!(cd
->rd_bmval
[0] & FATTR4_WORD0_RDATTR_ERROR
))
2262 p
= nfsd4_encode_rdattr_error(p
, buflen
, nfserr
);
2264 nfserr
= nfserr_toosmall
;
2268 cd
->buflen
-= (p
- cd
->buffer
);
2270 cd
->common
.err
= nfs_ok
;
2273 cd
->common
.err
= nfserr
;
2278 nfsd4_encode_stateid(struct nfsd4_compoundres
*resp
, stateid_t
*sid
)
2282 RESERVE_SPACE(sizeof(stateid_t
));
2283 WRITE32(sid
->si_generation
);
2284 WRITEMEM(&sid
->si_opaque
, sizeof(stateid_opaque_t
));
2289 nfsd4_encode_access(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_access
*access
)
2295 WRITE32(access
->ac_supported
);
2296 WRITE32(access
->ac_resp_access
);
2303 nfsd4_encode_close(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_close
*close
)
2305 ENCODE_SEQID_OP_HEAD
;
2308 nfsd4_encode_stateid(resp
, &close
->cl_stateid
);
2310 ENCODE_SEQID_OP_TAIL(close
->cl_stateowner
);
2316 nfsd4_encode_commit(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_commit
*commit
)
2322 WRITEMEM(commit
->co_verf
.data
, 8);
2329 nfsd4_encode_create(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_create
*create
)
2335 WRITECINFO(create
->cr_cinfo
);
2337 WRITE32(create
->cr_bmval
[0]);
2338 WRITE32(create
->cr_bmval
[1]);
2345 nfsd4_encode_getattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_getattr
*getattr
)
2347 struct svc_fh
*fhp
= getattr
->ga_fhp
;
2353 buflen
= resp
->end
- resp
->p
- (COMPOUND_ERR_SLACK_SPACE
>> 2);
2354 nfserr
= nfsd4_encode_fattr(fhp
, fhp
->fh_export
, fhp
->fh_dentry
,
2355 resp
->p
, &buflen
, getattr
->ga_bmval
,
2363 nfsd4_encode_getfh(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct svc_fh
**fhpp
)
2365 struct svc_fh
*fhp
= *fhpp
;
2370 len
= fhp
->fh_handle
.fh_size
;
2371 RESERVE_SPACE(len
+ 4);
2373 WRITEMEM(&fhp
->fh_handle
.fh_base
, len
);
2380 * Including all fields other than the name, a LOCK4denied structure requires
2381 * 8(clientid) + 4(namelen) + 8(offset) + 8(length) + 4(type) = 32 bytes.
2384 nfsd4_encode_lock_denied(struct nfsd4_compoundres
*resp
, struct nfsd4_lock_denied
*ld
)
2388 RESERVE_SPACE(32 + XDR_LEN(ld
->ld_sop
? ld
->ld_sop
->so_owner
.len
: 0));
2389 WRITE64(ld
->ld_start
);
2390 WRITE64(ld
->ld_length
);
2391 WRITE32(ld
->ld_type
);
2393 WRITEMEM(&ld
->ld_clientid
, 8);
2394 WRITE32(ld
->ld_sop
->so_owner
.len
);
2395 WRITEMEM(ld
->ld_sop
->so_owner
.data
, ld
->ld_sop
->so_owner
.len
);
2396 kref_put(&ld
->ld_sop
->so_ref
, nfs4_free_stateowner
);
2397 } else { /* non - nfsv4 lock in conflict, no clientid nor owner */
2398 WRITE64((u64
)0); /* clientid */
2399 WRITE32(0); /* length of owner name */
2405 nfsd4_encode_lock(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_lock
*lock
)
2407 ENCODE_SEQID_OP_HEAD
;
2410 nfsd4_encode_stateid(resp
, &lock
->lk_resp_stateid
);
2411 else if (nfserr
== nfserr_denied
)
2412 nfsd4_encode_lock_denied(resp
, &lock
->lk_denied
);
2414 ENCODE_SEQID_OP_TAIL(lock
->lk_replay_owner
);
2419 nfsd4_encode_lockt(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_lockt
*lockt
)
2421 if (nfserr
== nfserr_denied
)
2422 nfsd4_encode_lock_denied(resp
, &lockt
->lt_denied
);
2427 nfsd4_encode_locku(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_locku
*locku
)
2429 ENCODE_SEQID_OP_HEAD
;
2432 nfsd4_encode_stateid(resp
, &locku
->lu_stateid
);
2434 ENCODE_SEQID_OP_TAIL(locku
->lu_stateowner
);
2440 nfsd4_encode_link(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_link
*link
)
2446 WRITECINFO(link
->li_cinfo
);
2454 nfsd4_encode_open(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open
*open
)
2457 ENCODE_SEQID_OP_HEAD
;
2462 nfsd4_encode_stateid(resp
, &open
->op_stateid
);
2464 WRITECINFO(open
->op_cinfo
);
2465 WRITE32(open
->op_rflags
);
2467 WRITE32(open
->op_bmval
[0]);
2468 WRITE32(open
->op_bmval
[1]);
2469 WRITE32(open
->op_delegate_type
);
2472 switch (open
->op_delegate_type
) {
2473 case NFS4_OPEN_DELEGATE_NONE
:
2475 case NFS4_OPEN_DELEGATE_READ
:
2476 nfsd4_encode_stateid(resp
, &open
->op_delegate_stateid
);
2478 WRITE32(open
->op_recall
);
2481 * TODO: ACE's in delegations
2483 WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE
);
2486 WRITE32(0); /* XXX: is NULL principal ok? */
2489 case NFS4_OPEN_DELEGATE_WRITE
:
2490 nfsd4_encode_stateid(resp
, &open
->op_delegate_stateid
);
2495 * TODO: space_limit's in delegations
2497 WRITE32(NFS4_LIMIT_SIZE
);
2502 * TODO: ACE's in delegations
2504 WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE
);
2507 WRITE32(0); /* XXX: is NULL principal ok? */
2513 /* XXX save filehandle here */
2515 ENCODE_SEQID_OP_TAIL(open
->op_stateowner
);
2520 nfsd4_encode_open_confirm(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open_confirm
*oc
)
2522 ENCODE_SEQID_OP_HEAD
;
2525 nfsd4_encode_stateid(resp
, &oc
->oc_resp_stateid
);
2527 ENCODE_SEQID_OP_TAIL(oc
->oc_stateowner
);
2532 nfsd4_encode_open_downgrade(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open_downgrade
*od
)
2534 ENCODE_SEQID_OP_HEAD
;
2537 nfsd4_encode_stateid(resp
, &od
->od_stateid
);
2539 ENCODE_SEQID_OP_TAIL(od
->od_stateowner
);
2544 nfsd4_encode_read(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
2545 struct nfsd4_read
*read
)
2549 unsigned long maxcount
;
2555 if (resp
->xbuf
->page_len
)
2556 return nfserr_resource
;
2558 RESERVE_SPACE(8); /* eof flag and byte count */
2560 maxcount
= svc_max_payload(resp
->rqstp
);
2561 if (maxcount
> read
->rd_length
)
2562 maxcount
= read
->rd_length
;
2567 pn
= resp
->rqstp
->rq_resused
++;
2568 resp
->rqstp
->rq_vec
[v
].iov_base
=
2569 page_address(resp
->rqstp
->rq_respages
[pn
]);
2570 resp
->rqstp
->rq_vec
[v
].iov_len
=
2571 len
< PAGE_SIZE
? len
: PAGE_SIZE
;
2577 nfserr
= nfsd_read(read
->rd_rqstp
, read
->rd_fhp
, read
->rd_filp
,
2578 read
->rd_offset
, resp
->rqstp
->rq_vec
, read
->rd_vlen
,
2581 if (nfserr
== nfserr_symlink
)
2582 nfserr
= nfserr_inval
;
2585 eof
= (read
->rd_offset
+ maxcount
>=
2586 read
->rd_fhp
->fh_dentry
->d_inode
->i_size
);
2591 resp
->xbuf
->head
[0].iov_len
= (char*)p
2592 - (char*)resp
->xbuf
->head
[0].iov_base
;
2593 resp
->xbuf
->page_len
= maxcount
;
2595 /* Use rest of head for padding and remaining ops: */
2596 resp
->xbuf
->tail
[0].iov_base
= p
;
2597 resp
->xbuf
->tail
[0].iov_len
= 0;
2601 resp
->xbuf
->tail
[0].iov_base
+= maxcount
&3;
2602 resp
->xbuf
->tail
[0].iov_len
= 4 - (maxcount
&3);
2609 nfsd4_encode_readlink(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_readlink
*readlink
)
2617 if (resp
->xbuf
->page_len
)
2618 return nfserr_resource
;
2620 page
= page_address(resp
->rqstp
->rq_respages
[resp
->rqstp
->rq_resused
++]);
2622 maxcount
= PAGE_SIZE
;
2626 * XXX: By default, the ->readlink() VFS op will truncate symlinks
2627 * if they would overflow the buffer. Is this kosher in NFSv4? If
2628 * not, one easy fix is: if ->readlink() precisely fills the buffer,
2629 * assume that truncation occurred, and return NFS4ERR_RESOURCE.
2631 nfserr
= nfsd_readlink(readlink
->rl_rqstp
, readlink
->rl_fhp
, page
, &maxcount
);
2632 if (nfserr
== nfserr_isdir
)
2633 return nfserr_inval
;
2639 resp
->xbuf
->head
[0].iov_len
= (char*)p
2640 - (char*)resp
->xbuf
->head
[0].iov_base
;
2641 resp
->xbuf
->page_len
= maxcount
;
2643 /* Use rest of head for padding and remaining ops: */
2644 resp
->xbuf
->tail
[0].iov_base
= p
;
2645 resp
->xbuf
->tail
[0].iov_len
= 0;
2649 resp
->xbuf
->tail
[0].iov_base
+= maxcount
&3;
2650 resp
->xbuf
->tail
[0].iov_len
= 4 - (maxcount
&3);
2657 nfsd4_encode_readdir(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_readdir
*readdir
)
2661 __be32
*page
, *savep
, *tailbase
;
2666 if (resp
->xbuf
->page_len
)
2667 return nfserr_resource
;
2669 RESERVE_SPACE(8); /* verifier */
2672 /* XXX: Following NFSv3, we ignore the READDIR verifier for now. */
2676 resp
->xbuf
->head
[0].iov_len
= ((char*)resp
->p
) - (char*)resp
->xbuf
->head
[0].iov_base
;
2679 maxcount
= PAGE_SIZE
;
2680 if (maxcount
> readdir
->rd_maxcount
)
2681 maxcount
= readdir
->rd_maxcount
;
2684 * Convert from bytes to words, account for the two words already
2685 * written, make sure to leave two words at the end for the next
2686 * pointer and eof field.
2688 maxcount
= (maxcount
>> 2) - 4;
2690 nfserr
= nfserr_toosmall
;
2694 page
= page_address(resp
->rqstp
->rq_respages
[resp
->rqstp
->rq_resused
++]);
2695 readdir
->common
.err
= 0;
2696 readdir
->buflen
= maxcount
;
2697 readdir
->buffer
= page
;
2698 readdir
->offset
= NULL
;
2700 offset
= readdir
->rd_cookie
;
2701 nfserr
= nfsd_readdir(readdir
->rd_rqstp
, readdir
->rd_fhp
,
2703 &readdir
->common
, nfsd4_encode_dirent
);
2704 if (nfserr
== nfs_ok
&&
2705 readdir
->common
.err
== nfserr_toosmall
&&
2706 readdir
->buffer
== page
)
2707 nfserr
= nfserr_toosmall
;
2708 if (nfserr
== nfserr_symlink
)
2709 nfserr
= nfserr_notdir
;
2713 if (readdir
->offset
)
2714 xdr_encode_hyper(readdir
->offset
, offset
);
2716 p
= readdir
->buffer
;
2717 *p
++ = 0; /* no more entries */
2718 *p
++ = htonl(readdir
->common
.err
== nfserr_eof
);
2719 resp
->xbuf
->page_len
= ((char*)p
) - (char*)page_address(
2720 resp
->rqstp
->rq_respages
[resp
->rqstp
->rq_resused
-1]);
2722 /* Use rest of head for padding and remaining ops: */
2723 resp
->xbuf
->tail
[0].iov_base
= tailbase
;
2724 resp
->xbuf
->tail
[0].iov_len
= 0;
2725 resp
->p
= resp
->xbuf
->tail
[0].iov_base
;
2726 resp
->end
= resp
->p
+ (PAGE_SIZE
- resp
->xbuf
->head
[0].iov_len
)/4;
2736 nfsd4_encode_remove(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_remove
*remove
)
2742 WRITECINFO(remove
->rm_cinfo
);
2749 nfsd4_encode_rename(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_rename
*rename
)
2755 WRITECINFO(rename
->rn_sinfo
);
2756 WRITECINFO(rename
->rn_tinfo
);
2763 nfsd4_encode_secinfo(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
2764 struct nfsd4_secinfo
*secinfo
)
2767 struct svc_export
*exp
= secinfo
->si_exp
;
2769 struct exp_flavor_info
*flavs
;
2770 struct exp_flavor_info def_flavs
[2];
2775 if (exp
->ex_nflavors
) {
2776 flavs
= exp
->ex_flavors
;
2777 nflavs
= exp
->ex_nflavors
;
2778 } else { /* Handling of some defaults in absence of real secinfo: */
2780 if (exp
->ex_client
->flavour
->flavour
== RPC_AUTH_UNIX
) {
2782 flavs
[0].pseudoflavor
= RPC_AUTH_UNIX
;
2783 flavs
[1].pseudoflavor
= RPC_AUTH_NULL
;
2784 } else if (exp
->ex_client
->flavour
->flavour
== RPC_AUTH_GSS
) {
2786 flavs
[0].pseudoflavor
2787 = svcauth_gss_flavor(exp
->ex_client
);
2790 flavs
[0].pseudoflavor
2791 = exp
->ex_client
->flavour
->flavour
;
2798 for (i
= 0; i
< nflavs
; i
++) {
2799 u32 flav
= flavs
[i
].pseudoflavor
;
2800 struct gss_api_mech
*gm
= gss_mech_get_by_pseudoflavor(flav
);
2804 WRITE32(RPC_AUTH_GSS
);
2806 RESERVE_SPACE(4 + gm
->gm_oid
.len
);
2807 WRITE32(gm
->gm_oid
.len
);
2808 WRITEMEM(gm
->gm_oid
.data
, gm
->gm_oid
.len
);
2811 WRITE32(0); /* qop */
2814 WRITE32(gss_pseudoflavor_to_service(gm
, flav
));
2830 * The SETATTR encode routine is special -- it always encodes a bitmap,
2831 * regardless of the error status.
2834 nfsd4_encode_setattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_setattr
*setattr
)
2846 WRITE32(setattr
->sa_bmval
[0]);
2847 WRITE32(setattr
->sa_bmval
[1]);
2854 nfsd4_encode_setclientid(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_setclientid
*scd
)
2859 RESERVE_SPACE(8 + sizeof(nfs4_verifier
));
2860 WRITEMEM(&scd
->se_clientid
, 8);
2861 WRITEMEM(&scd
->se_confirm
, sizeof(nfs4_verifier
));
2864 else if (nfserr
== nfserr_clid_inuse
) {
2874 nfsd4_encode_write(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_write
*write
)
2880 WRITE32(write
->wr_bytes_written
);
2881 WRITE32(write
->wr_how_written
);
2882 WRITEMEM(write
->wr_verifier
.data
, 8);
2889 nfsd4_encode_exchange_id(struct nfsd4_compoundres
*resp
, int nfserr
,
2890 struct nfsd4_exchange_id
*exid
)
2896 int server_scope_sz
;
2897 uint64_t minor_id
= 0;
2902 major_id
= utsname()->nodename
;
2903 major_id_sz
= strlen(major_id
);
2904 server_scope
= utsname()->nodename
;
2905 server_scope_sz
= strlen(server_scope
);
2908 8 /* eir_clientid */ +
2909 4 /* eir_sequenceid */ +
2911 4 /* spr_how (SP4_NONE) */ +
2912 8 /* so_minor_id */ +
2913 4 /* so_major_id.len */ +
2914 (XDR_QUADLEN(major_id_sz
) * 4) +
2915 4 /* eir_server_scope.len */ +
2916 (XDR_QUADLEN(server_scope_sz
) * 4) +
2917 4 /* eir_server_impl_id.count (0) */);
2919 WRITEMEM(&exid
->clientid
, 8);
2920 WRITE32(exid
->seqid
);
2921 WRITE32(exid
->flags
);
2923 /* state_protect4_r. Currently only support SP4_NONE */
2924 BUG_ON(exid
->spa_how
!= SP4_NONE
);
2925 WRITE32(exid
->spa_how
);
2927 /* The server_owner struct */
2928 WRITE64(minor_id
); /* Minor id */
2930 WRITE32(major_id_sz
);
2931 WRITEMEM(major_id
, major_id_sz
);
2934 WRITE32(server_scope_sz
);
2935 WRITEMEM(server_scope
, server_scope_sz
);
2937 /* Implementation id */
2938 WRITE32(0); /* zero length nfs_impl_id4 array */
2944 nfsd4_encode_create_session(struct nfsd4_compoundres
*resp
, int nfserr
,
2945 struct nfsd4_create_session
*sess
)
2953 WRITEMEM(sess
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
2954 WRITE32(sess
->seqid
);
2955 WRITE32(sess
->flags
);
2959 WRITE32(0); /* headerpadsz */
2960 WRITE32(sess
->fore_channel
.maxreq_sz
);
2961 WRITE32(sess
->fore_channel
.maxresp_sz
);
2962 WRITE32(sess
->fore_channel
.maxresp_cached
);
2963 WRITE32(sess
->fore_channel
.maxops
);
2964 WRITE32(sess
->fore_channel
.maxreqs
);
2965 WRITE32(sess
->fore_channel
.nr_rdma_attrs
);
2968 if (sess
->fore_channel
.nr_rdma_attrs
) {
2970 WRITE32(sess
->fore_channel
.rdma_attrs
);
2975 WRITE32(0); /* headerpadsz */
2976 WRITE32(sess
->back_channel
.maxreq_sz
);
2977 WRITE32(sess
->back_channel
.maxresp_sz
);
2978 WRITE32(sess
->back_channel
.maxresp_cached
);
2979 WRITE32(sess
->back_channel
.maxops
);
2980 WRITE32(sess
->back_channel
.maxreqs
);
2981 WRITE32(sess
->back_channel
.nr_rdma_attrs
);
2984 if (sess
->back_channel
.nr_rdma_attrs
) {
2986 WRITE32(sess
->back_channel
.rdma_attrs
);
2993 nfsd4_encode_destroy_session(struct nfsd4_compoundres
*resp
, int nfserr
,
2994 struct nfsd4_destroy_session
*destroy_session
)
3000 nfsd4_encode_sequence(struct nfsd4_compoundres
*resp
, int nfserr
,
3001 struct nfsd4_sequence
*seq
)
3008 RESERVE_SPACE(NFS4_MAX_SESSIONID_LEN
+ 20);
3009 WRITEMEM(seq
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
3010 WRITE32(seq
->seqid
);
3011 WRITE32(seq
->slotid
);
3012 WRITE32(seq
->maxslots
);
3015 * target_maxslots = maxslots
3018 WRITE32(seq
->maxslots
);
3026 nfsd4_encode_noop(struct nfsd4_compoundres
*resp
, __be32 nfserr
, void *p
)
3031 typedef __be32(* nfsd4_enc
)(struct nfsd4_compoundres
*, __be32
, void *);
3034 * Note: nfsd4_enc_ops vector is shared for v4.0 and v4.1
3035 * since we don't need to filter out obsolete ops as this is
3036 * done in the decoding phase.
3038 static nfsd4_enc nfsd4_enc_ops
[] = {
3039 [OP_ACCESS
] = (nfsd4_enc
)nfsd4_encode_access
,
3040 [OP_CLOSE
] = (nfsd4_enc
)nfsd4_encode_close
,
3041 [OP_COMMIT
] = (nfsd4_enc
)nfsd4_encode_commit
,
3042 [OP_CREATE
] = (nfsd4_enc
)nfsd4_encode_create
,
3043 [OP_DELEGPURGE
] = (nfsd4_enc
)nfsd4_encode_noop
,
3044 [OP_DELEGRETURN
] = (nfsd4_enc
)nfsd4_encode_noop
,
3045 [OP_GETATTR
] = (nfsd4_enc
)nfsd4_encode_getattr
,
3046 [OP_GETFH
] = (nfsd4_enc
)nfsd4_encode_getfh
,
3047 [OP_LINK
] = (nfsd4_enc
)nfsd4_encode_link
,
3048 [OP_LOCK
] = (nfsd4_enc
)nfsd4_encode_lock
,
3049 [OP_LOCKT
] = (nfsd4_enc
)nfsd4_encode_lockt
,
3050 [OP_LOCKU
] = (nfsd4_enc
)nfsd4_encode_locku
,
3051 [OP_LOOKUP
] = (nfsd4_enc
)nfsd4_encode_noop
,
3052 [OP_LOOKUPP
] = (nfsd4_enc
)nfsd4_encode_noop
,
3053 [OP_NVERIFY
] = (nfsd4_enc
)nfsd4_encode_noop
,
3054 [OP_OPEN
] = (nfsd4_enc
)nfsd4_encode_open
,
3055 [OP_OPENATTR
] = (nfsd4_enc
)nfsd4_encode_noop
,
3056 [OP_OPEN_CONFIRM
] = (nfsd4_enc
)nfsd4_encode_open_confirm
,
3057 [OP_OPEN_DOWNGRADE
] = (nfsd4_enc
)nfsd4_encode_open_downgrade
,
3058 [OP_PUTFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3059 [OP_PUTPUBFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3060 [OP_PUTROOTFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3061 [OP_READ
] = (nfsd4_enc
)nfsd4_encode_read
,
3062 [OP_READDIR
] = (nfsd4_enc
)nfsd4_encode_readdir
,
3063 [OP_READLINK
] = (nfsd4_enc
)nfsd4_encode_readlink
,
3064 [OP_REMOVE
] = (nfsd4_enc
)nfsd4_encode_remove
,
3065 [OP_RENAME
] = (nfsd4_enc
)nfsd4_encode_rename
,
3066 [OP_RENEW
] = (nfsd4_enc
)nfsd4_encode_noop
,
3067 [OP_RESTOREFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3068 [OP_SAVEFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3069 [OP_SECINFO
] = (nfsd4_enc
)nfsd4_encode_secinfo
,
3070 [OP_SETATTR
] = (nfsd4_enc
)nfsd4_encode_setattr
,
3071 [OP_SETCLIENTID
] = (nfsd4_enc
)nfsd4_encode_setclientid
,
3072 [OP_SETCLIENTID_CONFIRM
] = (nfsd4_enc
)nfsd4_encode_noop
,
3073 [OP_VERIFY
] = (nfsd4_enc
)nfsd4_encode_noop
,
3074 [OP_WRITE
] = (nfsd4_enc
)nfsd4_encode_write
,
3075 [OP_RELEASE_LOCKOWNER
] = (nfsd4_enc
)nfsd4_encode_noop
,
3077 /* NFSv4.1 operations */
3078 [OP_BACKCHANNEL_CTL
] = (nfsd4_enc
)nfsd4_encode_noop
,
3079 [OP_BIND_CONN_TO_SESSION
] = (nfsd4_enc
)nfsd4_encode_noop
,
3080 [OP_EXCHANGE_ID
] = (nfsd4_enc
)nfsd4_encode_exchange_id
,
3081 [OP_CREATE_SESSION
] = (nfsd4_enc
)nfsd4_encode_create_session
,
3082 [OP_DESTROY_SESSION
] = (nfsd4_enc
)nfsd4_encode_destroy_session
,
3083 [OP_FREE_STATEID
] = (nfsd4_enc
)nfsd4_encode_noop
,
3084 [OP_GET_DIR_DELEGATION
] = (nfsd4_enc
)nfsd4_encode_noop
,
3085 [OP_GETDEVICEINFO
] = (nfsd4_enc
)nfsd4_encode_noop
,
3086 [OP_GETDEVICELIST
] = (nfsd4_enc
)nfsd4_encode_noop
,
3087 [OP_LAYOUTCOMMIT
] = (nfsd4_enc
)nfsd4_encode_noop
,
3088 [OP_LAYOUTGET
] = (nfsd4_enc
)nfsd4_encode_noop
,
3089 [OP_LAYOUTRETURN
] = (nfsd4_enc
)nfsd4_encode_noop
,
3090 [OP_SECINFO_NO_NAME
] = (nfsd4_enc
)nfsd4_encode_noop
,
3091 [OP_SEQUENCE
] = (nfsd4_enc
)nfsd4_encode_sequence
,
3092 [OP_SET_SSV
] = (nfsd4_enc
)nfsd4_encode_noop
,
3093 [OP_TEST_STATEID
] = (nfsd4_enc
)nfsd4_encode_noop
,
3094 [OP_WANT_DELEGATION
] = (nfsd4_enc
)nfsd4_encode_noop
,
3095 [OP_DESTROY_CLIENTID
] = (nfsd4_enc
)nfsd4_encode_noop
,
3096 [OP_RECLAIM_COMPLETE
] = (nfsd4_enc
)nfsd4_encode_noop
,
3100 * Calculate the total amount of memory that the compound response has taken
3101 * after encoding the current operation.
3103 * pad: add on 8 bytes for the next operation's op_code and status so that
3104 * there is room to cache a failure on the next operation.
3106 * Compare this length to the session se_fmaxresp_cached.
3108 * Our se_fmaxresp_cached will always be a multiple of PAGE_SIZE, and so
3109 * will be at least a page and will therefore hold the xdr_buf head.
3111 static int nfsd4_check_drc_limit(struct nfsd4_compoundres
*resp
)
3114 struct xdr_buf
*xb
= &resp
->rqstp
->rq_res
;
3115 struct nfsd4_compoundargs
*args
= resp
->rqstp
->rq_argp
;
3116 struct nfsd4_session
*session
= NULL
;
3117 struct nfsd4_slot
*slot
= resp
->cstate
.slot
;
3118 u32 length
, tlen
= 0, pad
= 8;
3120 if (!nfsd4_has_session(&resp
->cstate
))
3123 session
= resp
->cstate
.session
;
3124 if (session
== NULL
|| slot
->sl_cache_entry
.ce_cachethis
== 0)
3127 if (resp
->opcnt
>= args
->opcnt
)
3128 pad
= 0; /* this is the last operation */
3130 if (xb
->page_len
== 0) {
3131 length
= (char *)resp
->p
- (char *)xb
->head
[0].iov_base
+ pad
;
3133 if (xb
->tail
[0].iov_base
&& xb
->tail
[0].iov_len
> 0)
3134 tlen
= (char *)resp
->p
- (char *)xb
->tail
[0].iov_base
;
3136 length
= xb
->head
[0].iov_len
+ xb
->page_len
+ tlen
+ pad
;
3138 dprintk("%s length %u, xb->page_len %u tlen %u pad %u\n", __func__
,
3139 length
, xb
->page_len
, tlen
, pad
);
3141 if (length
<= session
->se_fmaxresp_cached
)
3144 return nfserr_rep_too_big_to_cache
;
3148 nfsd4_encode_operation(struct nfsd4_compoundres
*resp
, struct nfsd4_op
*op
)
3155 statp
= p
++; /* to be backfilled at the end */
3158 if (op
->opnum
== OP_ILLEGAL
)
3160 BUG_ON(op
->opnum
< 0 || op
->opnum
>= ARRAY_SIZE(nfsd4_enc_ops
) ||
3161 !nfsd4_enc_ops
[op
->opnum
]);
3162 op
->status
= nfsd4_enc_ops
[op
->opnum
](resp
, op
->status
, &op
->u
);
3163 /* nfsd4_check_drc_limit guarantees enough room for error status */
3164 if (!op
->status
&& nfsd4_check_drc_limit(resp
))
3165 op
->status
= nfserr_rep_too_big_to_cache
;
3168 * Note: We write the status directly, instead of using WRITE32(),
3169 * since it is already in network byte order.
3171 *statp
= op
->status
;
3175 * Encode the reply stored in the stateowner reply cache
3177 * XDR note: do not encode rp->rp_buflen: the buffer contains the
3178 * previously sent already encoded operation.
3180 * called with nfs4_lock_state() held
3183 nfsd4_encode_replay(struct nfsd4_compoundres
*resp
, struct nfsd4_op
*op
)
3186 struct nfs4_replay
*rp
= op
->replay
;
3192 *p
++ = rp
->rp_status
; /* already xdr'ed */
3195 RESERVE_SPACE(rp
->rp_buflen
);
3196 WRITEMEM(rp
->rp_buf
, rp
->rp_buflen
);
3201 * END OF "GENERIC" ENCODE ROUTINES.
3205 nfs4svc_encode_voidres(struct svc_rqst
*rqstp
, __be32
*p
, void *dummy
)
3207 return xdr_ressize_check(rqstp
, p
);
3210 void nfsd4_release_compoundargs(struct nfsd4_compoundargs
*args
)
3212 if (args
->ops
!= args
->iops
) {
3214 args
->ops
= args
->iops
;
3218 while (args
->to_free
) {
3219 struct tmpbuf
*tb
= args
->to_free
;
3220 args
->to_free
= tb
->next
;
3221 tb
->release(tb
->buf
);
3227 nfs4svc_decode_compoundargs(struct svc_rqst
*rqstp
, __be32
*p
, struct nfsd4_compoundargs
*args
)
3232 args
->end
= rqstp
->rq_arg
.head
[0].iov_base
+ rqstp
->rq_arg
.head
[0].iov_len
;
3233 args
->pagelist
= rqstp
->rq_arg
.pages
;
3234 args
->pagelen
= rqstp
->rq_arg
.page_len
;
3236 args
->to_free
= NULL
;
3237 args
->ops
= args
->iops
;
3238 args
->rqstp
= rqstp
;
3240 status
= nfsd4_decode_compound(args
);
3242 nfsd4_release_compoundargs(args
);
3248 nfs4svc_encode_compoundres(struct svc_rqst
*rqstp
, __be32
*p
, struct nfsd4_compoundres
*resp
)
3251 * All that remains is to write the tag and operation count...
3255 *p
++ = htonl(resp
->taglen
);
3256 memcpy(p
, resp
->tag
, resp
->taglen
);
3257 p
+= XDR_QUADLEN(resp
->taglen
);
3258 *p
++ = htonl(resp
->opcnt
);
3260 if (rqstp
->rq_res
.page_len
)
3261 iov
= &rqstp
->rq_res
.tail
[0];
3263 iov
= &rqstp
->rq_res
.head
[0];
3264 iov
->iov_len
= ((char*)resp
->p
) - (char*)iov
->iov_base
;
3265 BUG_ON(iov
->iov_len
> PAGE_SIZE
);
3266 if (nfsd4_has_session(&resp
->cstate
)) {
3267 if (resp
->cstate
.status
== nfserr_replay_cache
&&
3268 !nfsd4_not_cached(resp
)) {
3269 iov
->iov_len
= resp
->cstate
.iovlen
;
3271 nfsd4_store_cache_entry(resp
);
3272 dprintk("%s: SET SLOT STATE TO AVAILABLE\n", __func__
);
3273 resp
->cstate
.slot
->sl_inuse
= 0;
3275 if (resp
->cstate
.session
)
3276 nfsd4_put_session(resp
->cstate
.session
);