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
);
193 defer_free(struct nfsd4_compoundargs
*argp
,
194 void (*release
)(const void *), void *p
)
198 tb
= kmalloc(sizeof(*tb
), GFP_KERNEL
);
202 tb
->release
= release
;
203 tb
->next
= argp
->to_free
;
208 static char *savemem(struct nfsd4_compoundargs
*argp
, __be32
*p
, int nbytes
)
210 if (p
== argp
->tmp
) {
211 p
= kmalloc(nbytes
, GFP_KERNEL
);
214 memcpy(p
, argp
->tmp
, nbytes
);
216 BUG_ON(p
!= argp
->tmpp
);
219 if (defer_free(argp
, kfree
, p
)) {
227 nfsd4_decode_bitmap(struct nfsd4_compoundargs
*argp
, u32
*bmval
)
240 READ_BUF(bmlen
<< 2);
250 nfsd4_decode_fattr(struct nfsd4_compoundargs
*argp
, u32
*bmval
, struct iattr
*iattr
,
251 struct nfs4_acl
**acl
)
253 int expected_len
, len
= 0;
260 if ((status
= nfsd4_decode_bitmap(argp
, bmval
)))
264 * According to spec, unsupported attributes return ERR_ATTRNOTSUPP;
265 * read-only attributes return ERR_INVAL.
267 if ((bmval
[0] & ~NFSD_SUPPORTED_ATTRS_WORD0
) || (bmval
[1] & ~NFSD_SUPPORTED_ATTRS_WORD1
))
268 return nfserr_attrnotsupp
;
269 if ((bmval
[0] & ~NFSD_WRITEABLE_ATTRS_WORD0
) || (bmval
[1] & ~NFSD_WRITEABLE_ATTRS_WORD1
))
273 READ32(expected_len
);
275 if (bmval
[0] & FATTR4_WORD0_SIZE
) {
278 READ64(iattr
->ia_size
);
279 iattr
->ia_valid
|= ATTR_SIZE
;
281 if (bmval
[0] & FATTR4_WORD0_ACL
) {
283 struct nfs4_ace
*ace
;
285 READ_BUF(4); len
+= 4;
288 if (nace
> NFS4_ACL_MAX
)
289 return nfserr_resource
;
291 *acl
= nfs4_acl_new(nace
);
296 defer_free(argp
, kfree
, *acl
);
298 (*acl
)->naces
= nace
;
299 for (ace
= (*acl
)->aces
; ace
< (*acl
)->aces
+ nace
; ace
++) {
300 READ_BUF(16); len
+= 16;
303 READ32(ace
->access_mask
);
306 len
+= XDR_QUADLEN(dummy32
) << 2;
307 READMEM(buf
, dummy32
);
308 ace
->whotype
= nfs4_acl_get_whotype(buf
, dummy32
);
310 if (ace
->whotype
!= NFS4_ACL_WHO_NAMED
)
312 else if (ace
->flag
& NFS4_ACE_IDENTIFIER_GROUP
)
313 host_err
= nfsd_map_name_to_gid(argp
->rqstp
,
314 buf
, dummy32
, &ace
->who
);
316 host_err
= nfsd_map_name_to_uid(argp
->rqstp
,
317 buf
, dummy32
, &ace
->who
);
323 if (bmval
[1] & FATTR4_WORD1_MODE
) {
326 READ32(iattr
->ia_mode
);
327 iattr
->ia_mode
&= (S_IFMT
| S_IALLUGO
);
328 iattr
->ia_valid
|= ATTR_MODE
;
330 if (bmval
[1] & FATTR4_WORD1_OWNER
) {
335 len
+= (XDR_QUADLEN(dummy32
) << 2);
336 READMEM(buf
, dummy32
);
337 if ((host_err
= nfsd_map_name_to_uid(argp
->rqstp
, buf
, dummy32
, &iattr
->ia_uid
)))
339 iattr
->ia_valid
|= ATTR_UID
;
341 if (bmval
[1] & FATTR4_WORD1_OWNER_GROUP
) {
346 len
+= (XDR_QUADLEN(dummy32
) << 2);
347 READMEM(buf
, dummy32
);
348 if ((host_err
= nfsd_map_name_to_gid(argp
->rqstp
, buf
, dummy32
, &iattr
->ia_gid
)))
350 iattr
->ia_valid
|= ATTR_GID
;
352 if (bmval
[1] & FATTR4_WORD1_TIME_ACCESS_SET
) {
357 case NFS4_SET_TO_CLIENT_TIME
:
358 /* We require the high 32 bits of 'seconds' to be 0, and we ignore
359 all 32 bits of 'nseconds'. */
365 READ32(iattr
->ia_atime
.tv_sec
);
366 READ32(iattr
->ia_atime
.tv_nsec
);
367 if (iattr
->ia_atime
.tv_nsec
>= (u32
)1000000000)
369 iattr
->ia_valid
|= (ATTR_ATIME
| ATTR_ATIME_SET
);
371 case NFS4_SET_TO_SERVER_TIME
:
372 iattr
->ia_valid
|= ATTR_ATIME
;
378 if (bmval
[1] & FATTR4_WORD1_TIME_MODIFY_SET
) {
383 case NFS4_SET_TO_CLIENT_TIME
:
384 /* We require the high 32 bits of 'seconds' to be 0, and we ignore
385 all 32 bits of 'nseconds'. */
391 READ32(iattr
->ia_mtime
.tv_sec
);
392 READ32(iattr
->ia_mtime
.tv_nsec
);
393 if (iattr
->ia_mtime
.tv_nsec
>= (u32
)1000000000)
395 iattr
->ia_valid
|= (ATTR_MTIME
| ATTR_MTIME_SET
);
397 case NFS4_SET_TO_SERVER_TIME
:
398 iattr
->ia_valid
|= ATTR_MTIME
;
404 if (len
!= expected_len
)
410 status
= nfserrno(host_err
);
415 nfsd4_decode_stateid(struct nfsd4_compoundargs
*argp
, stateid_t
*sid
)
419 READ_BUF(sizeof(stateid_t
));
420 READ32(sid
->si_generation
);
421 COPYMEM(&sid
->si_opaque
, sizeof(stateid_opaque_t
));
427 nfsd4_decode_access(struct nfsd4_compoundargs
*argp
, struct nfsd4_access
*access
)
432 READ32(access
->ac_req_access
);
438 nfsd4_decode_close(struct nfsd4_compoundargs
*argp
, struct nfsd4_close
*close
)
442 close
->cl_stateowner
= NULL
;
444 READ32(close
->cl_seqid
);
445 return nfsd4_decode_stateid(argp
, &close
->cl_stateid
);
452 nfsd4_decode_commit(struct nfsd4_compoundargs
*argp
, struct nfsd4_commit
*commit
)
457 READ64(commit
->co_offset
);
458 READ32(commit
->co_count
);
464 nfsd4_decode_create(struct nfsd4_compoundargs
*argp
, struct nfsd4_create
*create
)
469 READ32(create
->cr_type
);
470 switch (create
->cr_type
) {
473 READ32(create
->cr_linklen
);
474 READ_BUF(create
->cr_linklen
);
475 SAVEMEM(create
->cr_linkname
, create
->cr_linklen
);
480 READ32(create
->cr_specdata1
);
481 READ32(create
->cr_specdata2
);
491 READ32(create
->cr_namelen
);
492 READ_BUF(create
->cr_namelen
);
493 SAVEMEM(create
->cr_name
, create
->cr_namelen
);
494 if ((status
= check_filename(create
->cr_name
, create
->cr_namelen
, nfserr_inval
)))
497 if ((status
= nfsd4_decode_fattr(argp
, create
->cr_bmval
, &create
->cr_iattr
, &create
->cr_acl
)))
504 nfsd4_decode_delegreturn(struct nfsd4_compoundargs
*argp
, struct nfsd4_delegreturn
*dr
)
506 return nfsd4_decode_stateid(argp
, &dr
->dr_stateid
);
510 nfsd4_decode_getattr(struct nfsd4_compoundargs
*argp
, struct nfsd4_getattr
*getattr
)
512 return nfsd4_decode_bitmap(argp
, getattr
->ga_bmval
);
516 nfsd4_decode_link(struct nfsd4_compoundargs
*argp
, struct nfsd4_link
*link
)
521 READ32(link
->li_namelen
);
522 READ_BUF(link
->li_namelen
);
523 SAVEMEM(link
->li_name
, link
->li_namelen
);
524 if ((status
= check_filename(link
->li_name
, link
->li_namelen
, nfserr_inval
)))
531 nfsd4_decode_lock(struct nfsd4_compoundargs
*argp
, struct nfsd4_lock
*lock
)
535 lock
->lk_replay_owner
= NULL
;
537 * type, reclaim(boolean), offset, length, new_lock_owner(boolean)
540 READ32(lock
->lk_type
);
541 if ((lock
->lk_type
< NFS4_READ_LT
) || (lock
->lk_type
> NFS4_WRITEW_LT
))
543 READ32(lock
->lk_reclaim
);
544 READ64(lock
->lk_offset
);
545 READ64(lock
->lk_length
);
546 READ32(lock
->lk_is_new
);
548 if (lock
->lk_is_new
) {
550 READ32(lock
->lk_new_open_seqid
);
551 status
= nfsd4_decode_stateid(argp
, &lock
->lk_new_open_stateid
);
554 READ_BUF(8 + sizeof(clientid_t
));
555 READ32(lock
->lk_new_lock_seqid
);
556 COPYMEM(&lock
->lk_new_clientid
, sizeof(clientid_t
));
557 READ32(lock
->lk_new_owner
.len
);
558 READ_BUF(lock
->lk_new_owner
.len
);
559 READMEM(lock
->lk_new_owner
.data
, lock
->lk_new_owner
.len
);
561 status
= nfsd4_decode_stateid(argp
, &lock
->lk_old_lock_stateid
);
565 READ32(lock
->lk_old_lock_seqid
);
572 nfsd4_decode_lockt(struct nfsd4_compoundargs
*argp
, struct nfsd4_lockt
*lockt
)
577 READ32(lockt
->lt_type
);
578 if((lockt
->lt_type
< NFS4_READ_LT
) || (lockt
->lt_type
> NFS4_WRITEW_LT
))
580 READ64(lockt
->lt_offset
);
581 READ64(lockt
->lt_length
);
582 COPYMEM(&lockt
->lt_clientid
, 8);
583 READ32(lockt
->lt_owner
.len
);
584 READ_BUF(lockt
->lt_owner
.len
);
585 READMEM(lockt
->lt_owner
.data
, lockt
->lt_owner
.len
);
591 nfsd4_decode_locku(struct nfsd4_compoundargs
*argp
, struct nfsd4_locku
*locku
)
595 locku
->lu_stateowner
= NULL
;
597 READ32(locku
->lu_type
);
598 if ((locku
->lu_type
< NFS4_READ_LT
) || (locku
->lu_type
> NFS4_WRITEW_LT
))
600 READ32(locku
->lu_seqid
);
601 status
= nfsd4_decode_stateid(argp
, &locku
->lu_stateid
);
605 READ64(locku
->lu_offset
);
606 READ64(locku
->lu_length
);
612 nfsd4_decode_lookup(struct nfsd4_compoundargs
*argp
, struct nfsd4_lookup
*lookup
)
617 READ32(lookup
->lo_len
);
618 READ_BUF(lookup
->lo_len
);
619 SAVEMEM(lookup
->lo_name
, lookup
->lo_len
);
620 if ((status
= check_filename(lookup
->lo_name
, lookup
->lo_len
, nfserr_noent
)))
627 nfsd4_decode_open(struct nfsd4_compoundargs
*argp
, struct nfsd4_open
*open
)
631 memset(open
->op_bmval
, 0, sizeof(open
->op_bmval
));
632 open
->op_iattr
.ia_valid
= 0;
633 open
->op_stateowner
= NULL
;
635 /* seqid, share_access, share_deny, clientid, ownerlen */
636 READ_BUF(16 + sizeof(clientid_t
));
637 READ32(open
->op_seqid
);
638 READ32(open
->op_share_access
);
639 READ32(open
->op_share_deny
);
640 COPYMEM(&open
->op_clientid
, sizeof(clientid_t
));
641 READ32(open
->op_owner
.len
);
643 /* owner, open_flag */
644 READ_BUF(open
->op_owner
.len
+ 4);
645 SAVEMEM(open
->op_owner
.data
, open
->op_owner
.len
);
646 READ32(open
->op_create
);
647 switch (open
->op_create
) {
648 case NFS4_OPEN_NOCREATE
:
650 case NFS4_OPEN_CREATE
:
652 READ32(open
->op_createmode
);
653 switch (open
->op_createmode
) {
654 case NFS4_CREATE_UNCHECKED
:
655 case NFS4_CREATE_GUARDED
:
656 if ((status
= nfsd4_decode_fattr(argp
, open
->op_bmval
, &open
->op_iattr
, &open
->op_acl
)))
659 case NFS4_CREATE_EXCLUSIVE
:
661 COPYMEM(open
->op_verf
.data
, 8);
673 READ32(open
->op_claim_type
);
674 switch (open
->op_claim_type
) {
675 case NFS4_OPEN_CLAIM_NULL
:
676 case NFS4_OPEN_CLAIM_DELEGATE_PREV
:
678 READ32(open
->op_fname
.len
);
679 READ_BUF(open
->op_fname
.len
);
680 SAVEMEM(open
->op_fname
.data
, open
->op_fname
.len
);
681 if ((status
= check_filename(open
->op_fname
.data
, open
->op_fname
.len
, nfserr_inval
)))
684 case NFS4_OPEN_CLAIM_PREVIOUS
:
686 READ32(open
->op_delegate_type
);
688 case NFS4_OPEN_CLAIM_DELEGATE_CUR
:
689 status
= nfsd4_decode_stateid(argp
, &open
->op_delegate_stateid
);
693 READ32(open
->op_fname
.len
);
694 READ_BUF(open
->op_fname
.len
);
695 SAVEMEM(open
->op_fname
.data
, open
->op_fname
.len
);
696 if ((status
= check_filename(open
->op_fname
.data
, open
->op_fname
.len
, nfserr_inval
)))
707 nfsd4_decode_open_confirm(struct nfsd4_compoundargs
*argp
, struct nfsd4_open_confirm
*open_conf
)
711 open_conf
->oc_stateowner
= NULL
;
712 status
= nfsd4_decode_stateid(argp
, &open_conf
->oc_req_stateid
);
716 READ32(open_conf
->oc_seqid
);
722 nfsd4_decode_open_downgrade(struct nfsd4_compoundargs
*argp
, struct nfsd4_open_downgrade
*open_down
)
726 open_down
->od_stateowner
= NULL
;
727 status
= nfsd4_decode_stateid(argp
, &open_down
->od_stateid
);
731 READ32(open_down
->od_seqid
);
732 READ32(open_down
->od_share_access
);
733 READ32(open_down
->od_share_deny
);
739 nfsd4_decode_putfh(struct nfsd4_compoundargs
*argp
, struct nfsd4_putfh
*putfh
)
744 READ32(putfh
->pf_fhlen
);
745 if (putfh
->pf_fhlen
> NFS4_FHSIZE
)
747 READ_BUF(putfh
->pf_fhlen
);
748 SAVEMEM(putfh
->pf_fhval
, putfh
->pf_fhlen
);
754 nfsd4_decode_read(struct nfsd4_compoundargs
*argp
, struct nfsd4_read
*read
)
758 status
= nfsd4_decode_stateid(argp
, &read
->rd_stateid
);
762 READ64(read
->rd_offset
);
763 READ32(read
->rd_length
);
769 nfsd4_decode_readdir(struct nfsd4_compoundargs
*argp
, struct nfsd4_readdir
*readdir
)
774 READ64(readdir
->rd_cookie
);
775 COPYMEM(readdir
->rd_verf
.data
, sizeof(readdir
->rd_verf
.data
));
776 READ32(readdir
->rd_dircount
); /* just in case you needed a useless field... */
777 READ32(readdir
->rd_maxcount
);
778 if ((status
= nfsd4_decode_bitmap(argp
, readdir
->rd_bmval
)))
785 nfsd4_decode_remove(struct nfsd4_compoundargs
*argp
, struct nfsd4_remove
*remove
)
790 READ32(remove
->rm_namelen
);
791 READ_BUF(remove
->rm_namelen
);
792 SAVEMEM(remove
->rm_name
, remove
->rm_namelen
);
793 if ((status
= check_filename(remove
->rm_name
, remove
->rm_namelen
, nfserr_noent
)))
800 nfsd4_decode_rename(struct nfsd4_compoundargs
*argp
, struct nfsd4_rename
*rename
)
805 READ32(rename
->rn_snamelen
);
806 READ_BUF(rename
->rn_snamelen
+ 4);
807 SAVEMEM(rename
->rn_sname
, rename
->rn_snamelen
);
808 READ32(rename
->rn_tnamelen
);
809 READ_BUF(rename
->rn_tnamelen
);
810 SAVEMEM(rename
->rn_tname
, rename
->rn_tnamelen
);
811 if ((status
= check_filename(rename
->rn_sname
, rename
->rn_snamelen
, nfserr_noent
)))
813 if ((status
= check_filename(rename
->rn_tname
, rename
->rn_tnamelen
, nfserr_inval
)))
820 nfsd4_decode_renew(struct nfsd4_compoundargs
*argp
, clientid_t
*clientid
)
824 READ_BUF(sizeof(clientid_t
));
825 COPYMEM(clientid
, sizeof(clientid_t
));
831 nfsd4_decode_secinfo(struct nfsd4_compoundargs
*argp
,
832 struct nfsd4_secinfo
*secinfo
)
837 READ32(secinfo
->si_namelen
);
838 READ_BUF(secinfo
->si_namelen
);
839 SAVEMEM(secinfo
->si_name
, secinfo
->si_namelen
);
840 status
= check_filename(secinfo
->si_name
, secinfo
->si_namelen
,
848 nfsd4_decode_setattr(struct nfsd4_compoundargs
*argp
, struct nfsd4_setattr
*setattr
)
852 status
= nfsd4_decode_stateid(argp
, &setattr
->sa_stateid
);
855 return nfsd4_decode_fattr(argp
, setattr
->sa_bmval
,
856 &setattr
->sa_iattr
, &setattr
->sa_acl
);
860 nfsd4_decode_setclientid(struct nfsd4_compoundargs
*argp
, struct nfsd4_setclientid
*setclientid
)
865 COPYMEM(setclientid
->se_verf
.data
, 8);
866 READ32(setclientid
->se_namelen
);
868 READ_BUF(setclientid
->se_namelen
+ 8);
869 SAVEMEM(setclientid
->se_name
, setclientid
->se_namelen
);
870 READ32(setclientid
->se_callback_prog
);
871 READ32(setclientid
->se_callback_netid_len
);
873 READ_BUF(setclientid
->se_callback_netid_len
+ 4);
874 SAVEMEM(setclientid
->se_callback_netid_val
, setclientid
->se_callback_netid_len
);
875 READ32(setclientid
->se_callback_addr_len
);
877 READ_BUF(setclientid
->se_callback_addr_len
+ 4);
878 SAVEMEM(setclientid
->se_callback_addr_val
, setclientid
->se_callback_addr_len
);
879 READ32(setclientid
->se_callback_ident
);
885 nfsd4_decode_setclientid_confirm(struct nfsd4_compoundargs
*argp
, struct nfsd4_setclientid_confirm
*scd_c
)
889 READ_BUF(8 + sizeof(nfs4_verifier
));
890 COPYMEM(&scd_c
->sc_clientid
, 8);
891 COPYMEM(&scd_c
->sc_confirm
, sizeof(nfs4_verifier
));
896 /* Also used for NVERIFY */
898 nfsd4_decode_verify(struct nfsd4_compoundargs
*argp
, struct nfsd4_verify
*verify
)
901 struct nfsd4_compoundargs save
= {
904 .rqstp
= argp
->rqstp
,
907 struct iattr ve_iattr
; /* request */
908 struct nfs4_acl
*ve_acl
; /* request */
912 if ((status
= nfsd4_decode_bitmap(argp
, verify
->ve_bmval
)))
915 /* For convenience's sake, we compare raw xdr'd attributes in
916 * nfsd4_proc_verify; however we still decode here just to return
917 * correct error in case of bad xdr. */
919 status
= nfsd4_decode_fattr(ve_bmval
, &ve_iattr
, &ve_acl
);
920 if (status
== nfserr_inval
) {
921 status
= nfserrno(status
);
926 READ32(verify
->ve_attrlen
);
927 READ_BUF(verify
->ve_attrlen
);
928 SAVEMEM(verify
->ve_attrval
, verify
->ve_attrlen
);
934 nfsd4_decode_write(struct nfsd4_compoundargs
*argp
, struct nfsd4_write
*write
)
941 status
= nfsd4_decode_stateid(argp
, &write
->wr_stateid
);
945 READ64(write
->wr_offset
);
946 READ32(write
->wr_stable_how
);
947 if (write
->wr_stable_how
> 2)
949 READ32(write
->wr_buflen
);
951 /* Sorry .. no magic macros for this.. *
952 * READ_BUF(write->wr_buflen);
953 * SAVEMEM(write->wr_buf, write->wr_buflen);
955 avail
= (char*)argp
->end
- (char*)argp
->p
;
956 if (avail
+ argp
->pagelen
< write
->wr_buflen
) {
957 dprintk("NFSD: xdr error (%s:%d)\n",
961 argp
->rqstp
->rq_vec
[0].iov_base
= p
;
962 argp
->rqstp
->rq_vec
[0].iov_len
= avail
;
964 len
= write
->wr_buflen
;
965 while (len
> argp
->rqstp
->rq_vec
[v
].iov_len
) {
966 len
-= argp
->rqstp
->rq_vec
[v
].iov_len
;
968 argp
->rqstp
->rq_vec
[v
].iov_base
= page_address(argp
->pagelist
[0]);
970 if (argp
->pagelen
>= PAGE_SIZE
) {
971 argp
->rqstp
->rq_vec
[v
].iov_len
= PAGE_SIZE
;
972 argp
->pagelen
-= PAGE_SIZE
;
974 argp
->rqstp
->rq_vec
[v
].iov_len
= argp
->pagelen
;
975 argp
->pagelen
-= len
;
978 argp
->end
= (__be32
*) (argp
->rqstp
->rq_vec
[v
].iov_base
+ argp
->rqstp
->rq_vec
[v
].iov_len
);
979 argp
->p
= (__be32
*) (argp
->rqstp
->rq_vec
[v
].iov_base
+ (XDR_QUADLEN(len
) << 2));
980 argp
->rqstp
->rq_vec
[v
].iov_len
= len
;
981 write
->wr_vlen
= v
+1;
987 nfsd4_decode_release_lockowner(struct nfsd4_compoundargs
*argp
, struct nfsd4_release_lockowner
*rlockowner
)
992 COPYMEM(&rlockowner
->rl_clientid
, sizeof(clientid_t
));
993 READ32(rlockowner
->rl_owner
.len
);
994 READ_BUF(rlockowner
->rl_owner
.len
);
995 READMEM(rlockowner
->rl_owner
.data
, rlockowner
->rl_owner
.len
);
1001 nfsd4_decode_exchange_id(struct nfsd4_compoundargs
*argp
,
1002 struct nfsd4_exchange_id
*exid
)
1007 READ_BUF(NFS4_VERIFIER_SIZE
);
1008 COPYMEM(exid
->verifier
.data
, NFS4_VERIFIER_SIZE
);
1011 READ32(exid
->clname
.len
);
1013 READ_BUF(exid
->clname
.len
);
1014 SAVEMEM(exid
->clname
.data
, exid
->clname
.len
);
1017 READ32(exid
->flags
);
1019 /* Ignore state_protect4_a */
1021 READ32(exid
->spa_how
);
1022 switch (exid
->spa_how
) {
1026 /* spo_must_enforce */
1029 READ_BUF(dummy
* 4);
1032 /* spo_must_allow */
1035 READ_BUF(dummy
* 4);
1042 READ_BUF(dummy
* 4);
1047 READ_BUF(dummy
* 4);
1050 /* ssp_hash_algs<> */
1054 p
+= XDR_QUADLEN(dummy
);
1056 /* ssp_encr_algs<> */
1060 p
+= XDR_QUADLEN(dummy
);
1062 /* ssp_window and ssp_num_gss_handles */
1071 /* Ignore Implementation ID */
1072 READ_BUF(4); /* nfs_impl_id4 array length */
1083 p
+= XDR_QUADLEN(dummy
);
1089 p
+= XDR_QUADLEN(dummy
);
1099 nfsd4_decode_create_session(struct nfsd4_compoundargs
*argp
,
1100 struct nfsd4_create_session
*sess
)
1110 COPYMEM(&sess
->clientid
, 8);
1111 READ32(sess
->seqid
);
1112 READ32(sess
->flags
);
1114 /* Fore channel attrs */
1116 READ32(dummy
); /* headerpadsz is always 0 */
1117 READ32(sess
->fore_channel
.maxreq_sz
);
1118 READ32(sess
->fore_channel
.maxresp_sz
);
1119 READ32(sess
->fore_channel
.maxresp_cached
);
1120 READ32(sess
->fore_channel
.maxops
);
1121 READ32(sess
->fore_channel
.maxreqs
);
1122 READ32(sess
->fore_channel
.nr_rdma_attrs
);
1123 if (sess
->fore_channel
.nr_rdma_attrs
== 1) {
1125 READ32(sess
->fore_channel
.rdma_attrs
);
1126 } else if (sess
->fore_channel
.nr_rdma_attrs
> 1) {
1127 dprintk("Too many fore channel attr bitmaps!\n");
1131 /* Back channel attrs */
1133 READ32(dummy
); /* headerpadsz is always 0 */
1134 READ32(sess
->back_channel
.maxreq_sz
);
1135 READ32(sess
->back_channel
.maxresp_sz
);
1136 READ32(sess
->back_channel
.maxresp_cached
);
1137 READ32(sess
->back_channel
.maxops
);
1138 READ32(sess
->back_channel
.maxreqs
);
1139 READ32(sess
->back_channel
.nr_rdma_attrs
);
1140 if (sess
->back_channel
.nr_rdma_attrs
== 1) {
1142 READ32(sess
->back_channel
.rdma_attrs
);
1143 } else if (sess
->back_channel
.nr_rdma_attrs
> 1) {
1144 dprintk("Too many back channel attr bitmaps!\n");
1149 READ32(sess
->callback_prog
);
1151 /* callback_sec_params4 */
1152 READ32(nr_secflavs
);
1153 for (i
= 0; i
< nr_secflavs
; ++i
) {
1158 /* Nothing to read */
1168 SAVEMEM(machine_name
, dummy
);
1178 READ_BUF(dummy
* 4);
1179 for (i
= 0; i
< dummy
; ++i
)
1183 dprintk("RPC_AUTH_GSS callback secflavor "
1184 "not supported!\n");
1188 /* gcbp_handle_from_server */
1191 p
+= XDR_QUADLEN(dummy
);
1192 /* gcbp_handle_from_client */
1196 p
+= XDR_QUADLEN(dummy
);
1199 dprintk("Illegal callback secflavor\n");
1200 return nfserr_inval
;
1207 nfsd4_decode_destroy_session(struct nfsd4_compoundargs
*argp
,
1208 struct nfsd4_destroy_session
*destroy_session
)
1211 READ_BUF(NFS4_MAX_SESSIONID_LEN
);
1212 COPYMEM(destroy_session
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
1218 nfsd4_decode_sequence(struct nfsd4_compoundargs
*argp
,
1219 struct nfsd4_sequence
*seq
)
1223 READ_BUF(NFS4_MAX_SESSIONID_LEN
+ 16);
1224 COPYMEM(seq
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
1226 READ32(seq
->slotid
);
1227 READ32(seq
->maxslots
);
1228 READ32(seq
->cachethis
);
1234 nfsd4_decode_noop(struct nfsd4_compoundargs
*argp
, void *p
)
1240 nfsd4_decode_notsupp(struct nfsd4_compoundargs
*argp
, void *p
)
1242 return nfserr_notsupp
;
1245 typedef __be32(*nfsd4_dec
)(struct nfsd4_compoundargs
*argp
, void *);
1247 static nfsd4_dec nfsd4_dec_ops
[] = {
1248 [OP_ACCESS
] = (nfsd4_dec
)nfsd4_decode_access
,
1249 [OP_CLOSE
] = (nfsd4_dec
)nfsd4_decode_close
,
1250 [OP_COMMIT
] = (nfsd4_dec
)nfsd4_decode_commit
,
1251 [OP_CREATE
] = (nfsd4_dec
)nfsd4_decode_create
,
1252 [OP_DELEGPURGE
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1253 [OP_DELEGRETURN
] = (nfsd4_dec
)nfsd4_decode_delegreturn
,
1254 [OP_GETATTR
] = (nfsd4_dec
)nfsd4_decode_getattr
,
1255 [OP_GETFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1256 [OP_LINK
] = (nfsd4_dec
)nfsd4_decode_link
,
1257 [OP_LOCK
] = (nfsd4_dec
)nfsd4_decode_lock
,
1258 [OP_LOCKT
] = (nfsd4_dec
)nfsd4_decode_lockt
,
1259 [OP_LOCKU
] = (nfsd4_dec
)nfsd4_decode_locku
,
1260 [OP_LOOKUP
] = (nfsd4_dec
)nfsd4_decode_lookup
,
1261 [OP_LOOKUPP
] = (nfsd4_dec
)nfsd4_decode_noop
,
1262 [OP_NVERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
1263 [OP_OPEN
] = (nfsd4_dec
)nfsd4_decode_open
,
1264 [OP_OPENATTR
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1265 [OP_OPEN_CONFIRM
] = (nfsd4_dec
)nfsd4_decode_open_confirm
,
1266 [OP_OPEN_DOWNGRADE
] = (nfsd4_dec
)nfsd4_decode_open_downgrade
,
1267 [OP_PUTFH
] = (nfsd4_dec
)nfsd4_decode_putfh
,
1268 [OP_PUTPUBFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1269 [OP_PUTROOTFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1270 [OP_READ
] = (nfsd4_dec
)nfsd4_decode_read
,
1271 [OP_READDIR
] = (nfsd4_dec
)nfsd4_decode_readdir
,
1272 [OP_READLINK
] = (nfsd4_dec
)nfsd4_decode_noop
,
1273 [OP_REMOVE
] = (nfsd4_dec
)nfsd4_decode_remove
,
1274 [OP_RENAME
] = (nfsd4_dec
)nfsd4_decode_rename
,
1275 [OP_RENEW
] = (nfsd4_dec
)nfsd4_decode_renew
,
1276 [OP_RESTOREFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1277 [OP_SAVEFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1278 [OP_SECINFO
] = (nfsd4_dec
)nfsd4_decode_secinfo
,
1279 [OP_SETATTR
] = (nfsd4_dec
)nfsd4_decode_setattr
,
1280 [OP_SETCLIENTID
] = (nfsd4_dec
)nfsd4_decode_setclientid
,
1281 [OP_SETCLIENTID_CONFIRM
] = (nfsd4_dec
)nfsd4_decode_setclientid_confirm
,
1282 [OP_VERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
1283 [OP_WRITE
] = (nfsd4_dec
)nfsd4_decode_write
,
1284 [OP_RELEASE_LOCKOWNER
] = (nfsd4_dec
)nfsd4_decode_release_lockowner
,
1287 static nfsd4_dec nfsd41_dec_ops
[] = {
1288 [OP_ACCESS
] (nfsd4_dec
)nfsd4_decode_access
,
1289 [OP_CLOSE
] (nfsd4_dec
)nfsd4_decode_close
,
1290 [OP_COMMIT
] (nfsd4_dec
)nfsd4_decode_commit
,
1291 [OP_CREATE
] (nfsd4_dec
)nfsd4_decode_create
,
1292 [OP_DELEGPURGE
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1293 [OP_DELEGRETURN
] (nfsd4_dec
)nfsd4_decode_delegreturn
,
1294 [OP_GETATTR
] (nfsd4_dec
)nfsd4_decode_getattr
,
1295 [OP_GETFH
] (nfsd4_dec
)nfsd4_decode_noop
,
1296 [OP_LINK
] (nfsd4_dec
)nfsd4_decode_link
,
1297 [OP_LOCK
] (nfsd4_dec
)nfsd4_decode_lock
,
1298 [OP_LOCKT
] (nfsd4_dec
)nfsd4_decode_lockt
,
1299 [OP_LOCKU
] (nfsd4_dec
)nfsd4_decode_locku
,
1300 [OP_LOOKUP
] (nfsd4_dec
)nfsd4_decode_lookup
,
1301 [OP_LOOKUPP
] (nfsd4_dec
)nfsd4_decode_noop
,
1302 [OP_NVERIFY
] (nfsd4_dec
)nfsd4_decode_verify
,
1303 [OP_OPEN
] (nfsd4_dec
)nfsd4_decode_open
,
1304 [OP_OPENATTR
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1305 [OP_OPEN_CONFIRM
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1306 [OP_OPEN_DOWNGRADE
] (nfsd4_dec
)nfsd4_decode_open_downgrade
,
1307 [OP_PUTFH
] (nfsd4_dec
)nfsd4_decode_putfh
,
1308 [OP_PUTPUBFH
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1309 [OP_PUTROOTFH
] (nfsd4_dec
)nfsd4_decode_noop
,
1310 [OP_READ
] (nfsd4_dec
)nfsd4_decode_read
,
1311 [OP_READDIR
] (nfsd4_dec
)nfsd4_decode_readdir
,
1312 [OP_READLINK
] (nfsd4_dec
)nfsd4_decode_noop
,
1313 [OP_REMOVE
] (nfsd4_dec
)nfsd4_decode_remove
,
1314 [OP_RENAME
] (nfsd4_dec
)nfsd4_decode_rename
,
1315 [OP_RENEW
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1316 [OP_RESTOREFH
] (nfsd4_dec
)nfsd4_decode_noop
,
1317 [OP_SAVEFH
] (nfsd4_dec
)nfsd4_decode_noop
,
1318 [OP_SECINFO
] (nfsd4_dec
)nfsd4_decode_secinfo
,
1319 [OP_SETATTR
] (nfsd4_dec
)nfsd4_decode_setattr
,
1320 [OP_SETCLIENTID
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1321 [OP_SETCLIENTID_CONFIRM
](nfsd4_dec
)nfsd4_decode_notsupp
,
1322 [OP_VERIFY
] (nfsd4_dec
)nfsd4_decode_verify
,
1323 [OP_WRITE
] (nfsd4_dec
)nfsd4_decode_write
,
1324 [OP_RELEASE_LOCKOWNER
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1326 /* new operations for NFSv4.1 */
1327 [OP_BACKCHANNEL_CTL
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1328 [OP_BIND_CONN_TO_SESSION
](nfsd4_dec
)nfsd4_decode_notsupp
,
1329 [OP_EXCHANGE_ID
] (nfsd4_dec
)nfsd4_decode_exchange_id
,
1330 [OP_CREATE_SESSION
] (nfsd4_dec
)nfsd4_decode_create_session
,
1331 [OP_DESTROY_SESSION
] (nfsd4_dec
)nfsd4_decode_destroy_session
,
1332 [OP_FREE_STATEID
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1333 [OP_GET_DIR_DELEGATION
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1334 [OP_GETDEVICEINFO
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1335 [OP_GETDEVICELIST
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1336 [OP_LAYOUTCOMMIT
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1337 [OP_LAYOUTGET
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1338 [OP_LAYOUTRETURN
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1339 [OP_SECINFO_NO_NAME
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1340 [OP_SEQUENCE
] (nfsd4_dec
)nfsd4_decode_sequence
,
1341 [OP_SET_SSV
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1342 [OP_TEST_STATEID
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1343 [OP_WANT_DELEGATION
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1344 [OP_DESTROY_CLIENTID
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1345 [OP_RECLAIM_COMPLETE
] (nfsd4_dec
)nfsd4_decode_notsupp
,
1348 struct nfsd4_minorversion_ops
{
1349 nfsd4_dec
*decoders
;
1353 static struct nfsd4_minorversion_ops nfsd4_minorversion
[] = {
1354 [0] = { nfsd4_dec_ops
, ARRAY_SIZE(nfsd4_dec_ops
) },
1355 [1] = { nfsd41_dec_ops
, ARRAY_SIZE(nfsd41_dec_ops
) },
1359 nfsd4_decode_compound(struct nfsd4_compoundargs
*argp
)
1362 struct nfsd4_op
*op
;
1363 struct nfsd4_minorversion_ops
*ops
;
1367 * XXX: According to spec, we should check the tag
1368 * for UTF-8 compliance. I'm postponing this for
1369 * now because it seems that some clients do use
1373 READ32(argp
->taglen
);
1374 READ_BUF(argp
->taglen
+ 8);
1375 SAVEMEM(argp
->tag
, argp
->taglen
);
1376 READ32(argp
->minorversion
);
1377 READ32(argp
->opcnt
);
1379 if (argp
->taglen
> NFSD4_MAX_TAGLEN
)
1381 if (argp
->opcnt
> 100)
1384 if (argp
->opcnt
> ARRAY_SIZE(argp
->iops
)) {
1385 argp
->ops
= kmalloc(argp
->opcnt
* sizeof(*argp
->ops
), GFP_KERNEL
);
1387 argp
->ops
= argp
->iops
;
1388 dprintk("nfsd: couldn't allocate room for COMPOUND\n");
1393 if (argp
->minorversion
>= ARRAY_SIZE(nfsd4_minorversion
))
1396 ops
= &nfsd4_minorversion
[argp
->minorversion
];
1397 for (i
= 0; i
< argp
->opcnt
; i
++) {
1402 * We can't use READ_BUF() here because we need to handle
1403 * a missing opcode as an OP_WRITE + 1. So we need to check
1404 * to see if we're truly at the end of our buffer or if there
1405 * is another page we need to flip to.
1408 if (argp
->p
== argp
->end
) {
1409 if (argp
->pagelen
< 4) {
1410 /* There isn't an opcode still on the wire */
1411 op
->opnum
= OP_WRITE
+ 1;
1412 op
->status
= nfserr_bad_xdr
;
1418 * False alarm. We just hit a page boundary, but there
1419 * is still data available. Move pointer across page
1420 * boundary. *snip from READ_BUF*
1422 argp
->p
= page_address(argp
->pagelist
[0]);
1424 if (argp
->pagelen
< PAGE_SIZE
) {
1425 argp
->end
= p
+ (argp
->pagelen
>>2);
1428 argp
->end
= p
+ (PAGE_SIZE
>>2);
1429 argp
->pagelen
-= PAGE_SIZE
;
1432 op
->opnum
= ntohl(*argp
->p
++);
1434 if (op
->opnum
>= OP_ACCESS
&& op
->opnum
< ops
->nops
)
1435 op
->status
= ops
->decoders
[op
->opnum
](argp
, &op
->u
);
1437 op
->opnum
= OP_ILLEGAL
;
1438 op
->status
= nfserr_op_illegal
;
1450 * END OF "GENERIC" DECODE ROUTINES.
1454 * START OF "GENERIC" ENCODE ROUTINES.
1455 * These may look a little ugly since they are imported from a "generic"
1456 * set of XDR encode/decode routines which are intended to be shared by
1457 * all of our NFSv4 implementations (OpenBSD, MacOS X...).
1459 * If the pain of reading these is too great, it should be a straightforward
1460 * task to translate them into Linux-specific versions which are more
1461 * consistent with the style used in NFSv2/v3...
1463 #define ENCODE_HEAD __be32 *p
1465 #define WRITE32(n) *p++ = htonl(n)
1466 #define WRITE64(n) do { \
1467 *p++ = htonl((u32)((n) >> 32)); \
1468 *p++ = htonl((u32)(n)); \
1470 #define WRITEMEM(ptr,nbytes) do { if (nbytes > 0) { \
1471 *(p + XDR_QUADLEN(nbytes) -1) = 0; \
1472 memcpy(p, ptr, nbytes); \
1473 p += XDR_QUADLEN(nbytes); \
1475 #define WRITECINFO(c) do { \
1476 *p++ = htonl(c.atomic); \
1477 *p++ = htonl(c.before_ctime_sec); \
1478 *p++ = htonl(c.before_ctime_nsec); \
1479 *p++ = htonl(c.after_ctime_sec); \
1480 *p++ = htonl(c.after_ctime_nsec); \
1483 #define RESERVE_SPACE(nbytes) do { \
1485 BUG_ON(p + XDR_QUADLEN(nbytes) > resp->end); \
1487 #define ADJUST_ARGS() resp->p = p
1490 * Header routine to setup seqid operation replay cache
1492 #define ENCODE_SEQID_OP_HEAD \
1498 * Routine for encoding the result of a "seqid-mutating" NFSv4 operation. This
1499 * is where sequence id's are incremented, and the replay cache is filled.
1500 * Note that we increment sequence id's here, at the last moment, so we're sure
1501 * we know whether the error to be returned is a sequence id mutating error.
1504 #define ENCODE_SEQID_OP_TAIL(stateowner) do { \
1505 if (seqid_mutating_err(nfserr) && stateowner) { \
1506 stateowner->so_seqid++; \
1507 stateowner->so_replay.rp_status = nfserr; \
1508 stateowner->so_replay.rp_buflen = \
1509 (((char *)(resp)->p - (char *)save)); \
1510 memcpy(stateowner->so_replay.rp_buf, save, \
1511 stateowner->so_replay.rp_buflen); \
1514 /* Encode as an array of strings the string given with components
1517 static __be32
nfsd4_encode_components(char sep
, char *components
,
1518 __be32
**pp
, int *buflen
)
1522 int strlen
, count
=0;
1525 dprintk("nfsd4_encode_components(%s)\n", components
);
1526 if ((*buflen
-= 4) < 0)
1527 return nfserr_resource
;
1528 WRITE32(0); /* We will fill this in with @count later */
1529 end
= str
= components
;
1531 for (; *end
&& (*end
!= sep
); end
++)
1532 ; /* Point to end of component */
1535 if ((*buflen
-= ((XDR_QUADLEN(strlen
) << 2) + 4)) < 0)
1536 return nfserr_resource
;
1538 WRITEMEM(str
, strlen
);
1552 * encode a location element of a fs_locations structure
1554 static __be32
nfsd4_encode_fs_location4(struct nfsd4_fs_location
*location
,
1555 __be32
**pp
, int *buflen
)
1560 status
= nfsd4_encode_components(':', location
->hosts
, &p
, buflen
);
1563 status
= nfsd4_encode_components('/', location
->path
, &p
, buflen
);
1571 * Return the path to an export point in the pseudo filesystem namespace
1572 * Returned string is safe to use as long as the caller holds a reference
1575 static char *nfsd4_path(struct svc_rqst
*rqstp
, struct svc_export
*exp
, __be32
*stat
)
1577 struct svc_fh tmp_fh
;
1578 char *path
, *rootpath
;
1580 fh_init(&tmp_fh
, NFS4_FHSIZE
);
1581 *stat
= exp_pseudoroot(rqstp
, &tmp_fh
);
1584 rootpath
= tmp_fh
.fh_export
->ex_pathname
;
1586 path
= exp
->ex_pathname
;
1588 if (strncmp(path
, rootpath
, strlen(rootpath
))) {
1589 dprintk("nfsd: fs_locations failed;"
1590 "%s is not contained in %s\n", path
, rootpath
);
1591 *stat
= nfserr_notsupp
;
1595 return path
+ strlen(rootpath
);
1599 * encode a fs_locations structure
1601 static __be32
nfsd4_encode_fs_locations(struct svc_rqst
*rqstp
,
1602 struct svc_export
*exp
,
1603 __be32
**pp
, int *buflen
)
1608 struct nfsd4_fs_locations
*fslocs
= &exp
->ex_fslocs
;
1609 char *root
= nfsd4_path(rqstp
, exp
, &status
);
1613 status
= nfsd4_encode_components('/', root
, &p
, buflen
);
1616 if ((*buflen
-= 4) < 0)
1617 return nfserr_resource
;
1618 WRITE32(fslocs
->locations_count
);
1619 for (i
=0; i
<fslocs
->locations_count
; i
++) {
1620 status
= nfsd4_encode_fs_location4(&fslocs
->locations
[i
],
1629 static u32 nfs4_ftypes
[16] = {
1630 NF4BAD
, NF4FIFO
, NF4CHR
, NF4BAD
,
1631 NF4DIR
, NF4BAD
, NF4BLK
, NF4BAD
,
1632 NF4REG
, NF4BAD
, NF4LNK
, NF4BAD
,
1633 NF4SOCK
, NF4BAD
, NF4LNK
, NF4BAD
,
1637 nfsd4_encode_name(struct svc_rqst
*rqstp
, int whotype
, uid_t id
, int group
,
1638 __be32
**p
, int *buflen
)
1642 if (*buflen
< (XDR_QUADLEN(IDMAP_NAMESZ
) << 2) + 4)
1643 return nfserr_resource
;
1644 if (whotype
!= NFS4_ACL_WHO_NAMED
)
1645 status
= nfs4_acl_write_who(whotype
, (u8
*)(*p
+ 1));
1647 status
= nfsd_map_gid_to_name(rqstp
, id
, (u8
*)(*p
+ 1));
1649 status
= nfsd_map_uid_to_name(rqstp
, id
, (u8
*)(*p
+ 1));
1651 return nfserrno(status
);
1652 *p
= xdr_encode_opaque(*p
, NULL
, status
);
1653 *buflen
-= (XDR_QUADLEN(status
) << 2) + 4;
1654 BUG_ON(*buflen
< 0);
1658 static inline __be32
1659 nfsd4_encode_user(struct svc_rqst
*rqstp
, uid_t uid
, __be32
**p
, int *buflen
)
1661 return nfsd4_encode_name(rqstp
, NFS4_ACL_WHO_NAMED
, uid
, 0, p
, buflen
);
1664 static inline __be32
1665 nfsd4_encode_group(struct svc_rqst
*rqstp
, uid_t gid
, __be32
**p
, int *buflen
)
1667 return nfsd4_encode_name(rqstp
, NFS4_ACL_WHO_NAMED
, gid
, 1, p
, buflen
);
1670 static inline __be32
1671 nfsd4_encode_aclname(struct svc_rqst
*rqstp
, int whotype
, uid_t id
, int group
,
1672 __be32
**p
, int *buflen
)
1674 return nfsd4_encode_name(rqstp
, whotype
, id
, group
, p
, buflen
);
1677 #define WORD0_ABSENT_FS_ATTRS (FATTR4_WORD0_FS_LOCATIONS | FATTR4_WORD0_FSID | \
1678 FATTR4_WORD0_RDATTR_ERROR)
1679 #define WORD1_ABSENT_FS_ATTRS FATTR4_WORD1_MOUNTED_ON_FILEID
1681 static __be32
fattr_handle_absent_fs(u32
*bmval0
, u32
*bmval1
, u32
*rdattr_err
)
1683 /* As per referral draft: */
1684 if (*bmval0
& ~WORD0_ABSENT_FS_ATTRS
||
1685 *bmval1
& ~WORD1_ABSENT_FS_ATTRS
) {
1686 if (*bmval0
& FATTR4_WORD0_RDATTR_ERROR
||
1687 *bmval0
& FATTR4_WORD0_FS_LOCATIONS
)
1688 *rdattr_err
= NFSERR_MOVED
;
1690 return nfserr_moved
;
1692 *bmval0
&= WORD0_ABSENT_FS_ATTRS
;
1693 *bmval1
&= WORD1_ABSENT_FS_ATTRS
;
1698 * Note: @fhp can be NULL; in this case, we might have to compose the filehandle
1701 * @countp is the buffer size in _words_; upon successful return this becomes
1702 * replaced with the number of words written.
1705 nfsd4_encode_fattr(struct svc_fh
*fhp
, struct svc_export
*exp
,
1706 struct dentry
*dentry
, __be32
*buffer
, int *countp
, u32
*bmval
,
1707 struct svc_rqst
*rqstp
, int ignore_crossmnt
)
1709 u32 bmval0
= bmval
[0];
1710 u32 bmval1
= bmval
[1];
1712 struct svc_fh tempfh
;
1713 struct kstatfs statfs
;
1714 int buflen
= *countp
<< 2;
1723 struct nfs4_acl
*acl
= NULL
;
1725 BUG_ON(bmval1
& NFSD_WRITEONLY_ATTRS_WORD1
);
1726 BUG_ON(bmval0
& ~NFSD_SUPPORTED_ATTRS_WORD0
);
1727 BUG_ON(bmval1
& ~NFSD_SUPPORTED_ATTRS_WORD1
);
1729 if (exp
->ex_fslocs
.migrated
) {
1730 status
= fattr_handle_absent_fs(&bmval0
, &bmval1
, &rdattr_err
);
1735 err
= vfs_getattr(exp
->ex_path
.mnt
, dentry
, &stat
);
1738 if ((bmval0
& (FATTR4_WORD0_FILES_FREE
| FATTR4_WORD0_FILES_TOTAL
|
1739 FATTR4_WORD0_MAXNAME
)) ||
1740 (bmval1
& (FATTR4_WORD1_SPACE_AVAIL
| FATTR4_WORD1_SPACE_FREE
|
1741 FATTR4_WORD1_SPACE_TOTAL
))) {
1742 err
= vfs_statfs(dentry
, &statfs
);
1746 if ((bmval0
& (FATTR4_WORD0_FILEHANDLE
| FATTR4_WORD0_FSID
)) && !fhp
) {
1747 fh_init(&tempfh
, NFS4_FHSIZE
);
1748 status
= fh_compose(&tempfh
, exp
, dentry
, NULL
);
1753 if (bmval0
& (FATTR4_WORD0_ACL
| FATTR4_WORD0_ACLSUPPORT
1754 | FATTR4_WORD0_SUPPORTED_ATTRS
)) {
1755 err
= nfsd4_get_nfs4_acl(rqstp
, dentry
, &acl
);
1756 aclsupport
= (err
== 0);
1757 if (bmval0
& FATTR4_WORD0_ACL
) {
1758 if (err
== -EOPNOTSUPP
)
1759 bmval0
&= ~FATTR4_WORD0_ACL
;
1760 else if (err
== -EINVAL
) {
1761 status
= nfserr_attrnotsupp
;
1763 } else if (err
!= 0)
1767 if (bmval0
& FATTR4_WORD0_FS_LOCATIONS
) {
1768 if (exp
->ex_fslocs
.locations
== NULL
) {
1769 bmval0
&= ~FATTR4_WORD0_FS_LOCATIONS
;
1772 if ((buflen
-= 16) < 0)
1778 attrlenp
= p
++; /* to be backfilled later */
1780 if (bmval0
& FATTR4_WORD0_SUPPORTED_ATTRS
) {
1781 u32 word0
= NFSD_SUPPORTED_ATTRS_WORD0
;
1782 if ((buflen
-= 12) < 0)
1785 word0
&= ~FATTR4_WORD0_ACL
;
1786 if (!exp
->ex_fslocs
.locations
)
1787 word0
&= ~FATTR4_WORD0_FS_LOCATIONS
;
1790 WRITE32(NFSD_SUPPORTED_ATTRS_WORD1
);
1792 if (bmval0
& FATTR4_WORD0_TYPE
) {
1793 if ((buflen
-= 4) < 0)
1795 dummy
= nfs4_ftypes
[(stat
.mode
& S_IFMT
) >> 12];
1796 if (dummy
== NF4BAD
)
1797 goto out_serverfault
;
1800 if (bmval0
& FATTR4_WORD0_FH_EXPIRE_TYPE
) {
1801 if ((buflen
-= 4) < 0)
1803 if (exp
->ex_flags
& NFSEXP_NOSUBTREECHECK
)
1804 WRITE32(NFS4_FH_PERSISTENT
);
1806 WRITE32(NFS4_FH_PERSISTENT
|NFS4_FH_VOL_RENAME
);
1808 if (bmval0
& FATTR4_WORD0_CHANGE
) {
1810 * Note: This _must_ be consistent with the scheme for writing
1811 * change_info, so any changes made here must be reflected there
1812 * as well. (See xdr4.h:set_change_info() and the WRITECINFO()
1815 if ((buflen
-= 8) < 0)
1817 WRITE32(stat
.ctime
.tv_sec
);
1818 WRITE32(stat
.ctime
.tv_nsec
);
1820 if (bmval0
& FATTR4_WORD0_SIZE
) {
1821 if ((buflen
-= 8) < 0)
1825 if (bmval0
& FATTR4_WORD0_LINK_SUPPORT
) {
1826 if ((buflen
-= 4) < 0)
1830 if (bmval0
& FATTR4_WORD0_SYMLINK_SUPPORT
) {
1831 if ((buflen
-= 4) < 0)
1835 if (bmval0
& FATTR4_WORD0_NAMED_ATTR
) {
1836 if ((buflen
-= 4) < 0)
1840 if (bmval0
& FATTR4_WORD0_FSID
) {
1841 if ((buflen
-= 16) < 0)
1843 if (exp
->ex_fslocs
.migrated
) {
1844 WRITE64(NFS4_REFERRAL_FSID_MAJOR
);
1845 WRITE64(NFS4_REFERRAL_FSID_MINOR
);
1846 } else switch(fsid_source(fhp
)) {
1847 case FSIDSOURCE_FSID
:
1848 WRITE64((u64
)exp
->ex_fsid
);
1851 case FSIDSOURCE_DEV
:
1853 WRITE32(MAJOR(stat
.dev
));
1855 WRITE32(MINOR(stat
.dev
));
1857 case FSIDSOURCE_UUID
:
1858 WRITEMEM(exp
->ex_uuid
, 16);
1862 if (bmval0
& FATTR4_WORD0_UNIQUE_HANDLES
) {
1863 if ((buflen
-= 4) < 0)
1867 if (bmval0
& FATTR4_WORD0_LEASE_TIME
) {
1868 if ((buflen
-= 4) < 0)
1870 WRITE32(NFSD_LEASE_TIME
);
1872 if (bmval0
& FATTR4_WORD0_RDATTR_ERROR
) {
1873 if ((buflen
-= 4) < 0)
1875 WRITE32(rdattr_err
);
1877 if (bmval0
& FATTR4_WORD0_ACL
) {
1878 struct nfs4_ace
*ace
;
1881 if ((buflen
-= 4) < 0)
1887 if ((buflen
-= 4) < 0)
1889 WRITE32(acl
->naces
);
1891 for (ace
= acl
->aces
; ace
< acl
->aces
+ acl
->naces
; ace
++) {
1892 if ((buflen
-= 4*3) < 0)
1896 WRITE32(ace
->access_mask
& NFS4_ACE_MASK_ALL
);
1897 status
= nfsd4_encode_aclname(rqstp
, ace
->whotype
,
1898 ace
->who
, ace
->flag
& NFS4_ACE_IDENTIFIER_GROUP
,
1900 if (status
== nfserr_resource
)
1907 if (bmval0
& FATTR4_WORD0_ACLSUPPORT
) {
1908 if ((buflen
-= 4) < 0)
1910 WRITE32(aclsupport
?
1911 ACL4_SUPPORT_ALLOW_ACL
|ACL4_SUPPORT_DENY_ACL
: 0);
1913 if (bmval0
& FATTR4_WORD0_CANSETTIME
) {
1914 if ((buflen
-= 4) < 0)
1918 if (bmval0
& FATTR4_WORD0_CASE_INSENSITIVE
) {
1919 if ((buflen
-= 4) < 0)
1923 if (bmval0
& FATTR4_WORD0_CASE_PRESERVING
) {
1924 if ((buflen
-= 4) < 0)
1928 if (bmval0
& FATTR4_WORD0_CHOWN_RESTRICTED
) {
1929 if ((buflen
-= 4) < 0)
1933 if (bmval0
& FATTR4_WORD0_FILEHANDLE
) {
1934 buflen
-= (XDR_QUADLEN(fhp
->fh_handle
.fh_size
) << 2) + 4;
1937 WRITE32(fhp
->fh_handle
.fh_size
);
1938 WRITEMEM(&fhp
->fh_handle
.fh_base
, fhp
->fh_handle
.fh_size
);
1940 if (bmval0
& FATTR4_WORD0_FILEID
) {
1941 if ((buflen
-= 8) < 0)
1945 if (bmval0
& FATTR4_WORD0_FILES_AVAIL
) {
1946 if ((buflen
-= 8) < 0)
1948 WRITE64((u64
) statfs
.f_ffree
);
1950 if (bmval0
& FATTR4_WORD0_FILES_FREE
) {
1951 if ((buflen
-= 8) < 0)
1953 WRITE64((u64
) statfs
.f_ffree
);
1955 if (bmval0
& FATTR4_WORD0_FILES_TOTAL
) {
1956 if ((buflen
-= 8) < 0)
1958 WRITE64((u64
) statfs
.f_files
);
1960 if (bmval0
& FATTR4_WORD0_FS_LOCATIONS
) {
1961 status
= nfsd4_encode_fs_locations(rqstp
, exp
, &p
, &buflen
);
1962 if (status
== nfserr_resource
)
1967 if (bmval0
& FATTR4_WORD0_HOMOGENEOUS
) {
1968 if ((buflen
-= 4) < 0)
1972 if (bmval0
& FATTR4_WORD0_MAXFILESIZE
) {
1973 if ((buflen
-= 8) < 0)
1977 if (bmval0
& FATTR4_WORD0_MAXLINK
) {
1978 if ((buflen
-= 4) < 0)
1982 if (bmval0
& FATTR4_WORD0_MAXNAME
) {
1983 if ((buflen
-= 4) < 0)
1985 WRITE32(statfs
.f_namelen
);
1987 if (bmval0
& FATTR4_WORD0_MAXREAD
) {
1988 if ((buflen
-= 8) < 0)
1990 WRITE64((u64
) svc_max_payload(rqstp
));
1992 if (bmval0
& FATTR4_WORD0_MAXWRITE
) {
1993 if ((buflen
-= 8) < 0)
1995 WRITE64((u64
) svc_max_payload(rqstp
));
1997 if (bmval1
& FATTR4_WORD1_MODE
) {
1998 if ((buflen
-= 4) < 0)
2000 WRITE32(stat
.mode
& S_IALLUGO
);
2002 if (bmval1
& FATTR4_WORD1_NO_TRUNC
) {
2003 if ((buflen
-= 4) < 0)
2007 if (bmval1
& FATTR4_WORD1_NUMLINKS
) {
2008 if ((buflen
-= 4) < 0)
2010 WRITE32(stat
.nlink
);
2012 if (bmval1
& FATTR4_WORD1_OWNER
) {
2013 status
= nfsd4_encode_user(rqstp
, stat
.uid
, &p
, &buflen
);
2014 if (status
== nfserr_resource
)
2019 if (bmval1
& FATTR4_WORD1_OWNER_GROUP
) {
2020 status
= nfsd4_encode_group(rqstp
, stat
.gid
, &p
, &buflen
);
2021 if (status
== nfserr_resource
)
2026 if (bmval1
& FATTR4_WORD1_RAWDEV
) {
2027 if ((buflen
-= 8) < 0)
2029 WRITE32((u32
) MAJOR(stat
.rdev
));
2030 WRITE32((u32
) MINOR(stat
.rdev
));
2032 if (bmval1
& FATTR4_WORD1_SPACE_AVAIL
) {
2033 if ((buflen
-= 8) < 0)
2035 dummy64
= (u64
)statfs
.f_bavail
* (u64
)statfs
.f_bsize
;
2038 if (bmval1
& FATTR4_WORD1_SPACE_FREE
) {
2039 if ((buflen
-= 8) < 0)
2041 dummy64
= (u64
)statfs
.f_bfree
* (u64
)statfs
.f_bsize
;
2044 if (bmval1
& FATTR4_WORD1_SPACE_TOTAL
) {
2045 if ((buflen
-= 8) < 0)
2047 dummy64
= (u64
)statfs
.f_blocks
* (u64
)statfs
.f_bsize
;
2050 if (bmval1
& FATTR4_WORD1_SPACE_USED
) {
2051 if ((buflen
-= 8) < 0)
2053 dummy64
= (u64
)stat
.blocks
<< 9;
2056 if (bmval1
& FATTR4_WORD1_TIME_ACCESS
) {
2057 if ((buflen
-= 12) < 0)
2060 WRITE32(stat
.atime
.tv_sec
);
2061 WRITE32(stat
.atime
.tv_nsec
);
2063 if (bmval1
& FATTR4_WORD1_TIME_DELTA
) {
2064 if ((buflen
-= 12) < 0)
2070 if (bmval1
& FATTR4_WORD1_TIME_METADATA
) {
2071 if ((buflen
-= 12) < 0)
2074 WRITE32(stat
.ctime
.tv_sec
);
2075 WRITE32(stat
.ctime
.tv_nsec
);
2077 if (bmval1
& FATTR4_WORD1_TIME_MODIFY
) {
2078 if ((buflen
-= 12) < 0)
2081 WRITE32(stat
.mtime
.tv_sec
);
2082 WRITE32(stat
.mtime
.tv_nsec
);
2084 if (bmval1
& FATTR4_WORD1_MOUNTED_ON_FILEID
) {
2085 if ((buflen
-= 8) < 0)
2088 * Get parent's attributes if not ignoring crossmount
2089 * and this is the root of a cross-mounted filesystem.
2091 if (ignore_crossmnt
== 0 &&
2092 exp
->ex_path
.mnt
->mnt_root
->d_inode
== dentry
->d_inode
) {
2093 err
= vfs_getattr(exp
->ex_path
.mnt
->mnt_parent
,
2094 exp
->ex_path
.mnt
->mnt_mountpoint
, &stat
);
2100 *attrlenp
= htonl((char *)p
- (char *)attrlenp
- 4);
2101 *countp
= p
- buffer
;
2110 status
= nfserrno(err
);
2114 status
= nfserr_resource
;
2117 status
= nfserr_serverfault
;
2121 static inline int attributes_need_mount(u32
*bmval
)
2123 if (bmval
[0] & ~(FATTR4_WORD0_RDATTR_ERROR
| FATTR4_WORD0_LEASE_TIME
))
2125 if (bmval
[1] & ~FATTR4_WORD1_MOUNTED_ON_FILEID
)
2131 nfsd4_encode_dirent_fattr(struct nfsd4_readdir
*cd
,
2132 const char *name
, int namlen
, __be32
*p
, int *buflen
)
2134 struct svc_export
*exp
= cd
->rd_fhp
->fh_export
;
2135 struct dentry
*dentry
;
2137 int ignore_crossmnt
= 0;
2139 dentry
= lookup_one_len(name
, cd
->rd_fhp
->fh_dentry
, namlen
);
2141 return nfserrno(PTR_ERR(dentry
));
2145 * In the case of a mountpoint, the client may be asking for
2146 * attributes that are only properties of the underlying filesystem
2147 * as opposed to the cross-mounted file system. In such a case,
2148 * we will not follow the cross mount and will fill the attribtutes
2149 * directly from the mountpoint dentry.
2151 if (d_mountpoint(dentry
) && !attributes_need_mount(cd
->rd_bmval
))
2152 ignore_crossmnt
= 1;
2153 else if (d_mountpoint(dentry
)) {
2157 * Why the heck aren't we just using nfsd_lookup??
2158 * Different "."/".." handling? Something else?
2159 * At least, add a comment here to explain....
2161 err
= nfsd_cross_mnt(cd
->rd_rqstp
, &dentry
, &exp
);
2163 nfserr
= nfserrno(err
);
2166 nfserr
= check_nfsd_access(exp
, cd
->rd_rqstp
);
2171 nfserr
= nfsd4_encode_fattr(NULL
, exp
, dentry
, p
, buflen
, cd
->rd_bmval
,
2172 cd
->rd_rqstp
, ignore_crossmnt
);
2180 nfsd4_encode_rdattr_error(__be32
*p
, int buflen
, __be32 nfserr
)
2187 *p
++ = htonl(FATTR4_WORD0_RDATTR_ERROR
); /* bmval0 */
2188 *p
++ = htonl(0); /* bmval1 */
2191 *p
++ = nfserr
; /* no htonl */
2192 *attrlenp
= htonl((char *)p
- (char *)attrlenp
- 4);
2197 nfsd4_encode_dirent(void *ccdv
, const char *name
, int namlen
,
2198 loff_t offset
, u64 ino
, unsigned int d_type
)
2200 struct readdir_cd
*ccd
= ccdv
;
2201 struct nfsd4_readdir
*cd
= container_of(ccd
, struct nfsd4_readdir
, common
);
2203 __be32
*p
= cd
->buffer
;
2204 __be32 nfserr
= nfserr_toosmall
;
2206 /* In nfsv4, "." and ".." never make it onto the wire.. */
2207 if (name
&& isdotent(name
, namlen
)) {
2208 cd
->common
.err
= nfs_ok
;
2213 xdr_encode_hyper(cd
->offset
, (u64
) offset
);
2215 buflen
= cd
->buflen
- 4 - XDR_QUADLEN(namlen
);
2219 *p
++ = xdr_one
; /* mark entry present */
2220 cd
->offset
= p
; /* remember pointer */
2221 p
= xdr_encode_hyper(p
, NFS_OFFSET_MAX
); /* offset of next entry */
2222 p
= xdr_encode_array(p
, name
, namlen
); /* name length & name */
2224 nfserr
= nfsd4_encode_dirent_fattr(cd
, name
, namlen
, p
, &buflen
);
2229 case nfserr_resource
:
2230 nfserr
= nfserr_toosmall
;
2236 * If the client requested the RDATTR_ERROR attribute,
2237 * we stuff the error code into this attribute
2238 * and continue. If this attribute was not requested,
2239 * then in accordance with the spec, we fail the
2240 * entire READDIR operation(!)
2242 if (!(cd
->rd_bmval
[0] & FATTR4_WORD0_RDATTR_ERROR
))
2244 p
= nfsd4_encode_rdattr_error(p
, buflen
, nfserr
);
2246 nfserr
= nfserr_toosmall
;
2250 cd
->buflen
-= (p
- cd
->buffer
);
2252 cd
->common
.err
= nfs_ok
;
2255 cd
->common
.err
= nfserr
;
2260 nfsd4_encode_stateid(struct nfsd4_compoundres
*resp
, stateid_t
*sid
)
2264 RESERVE_SPACE(sizeof(stateid_t
));
2265 WRITE32(sid
->si_generation
);
2266 WRITEMEM(&sid
->si_opaque
, sizeof(stateid_opaque_t
));
2271 nfsd4_encode_access(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_access
*access
)
2277 WRITE32(access
->ac_supported
);
2278 WRITE32(access
->ac_resp_access
);
2285 nfsd4_encode_close(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_close
*close
)
2287 ENCODE_SEQID_OP_HEAD
;
2290 nfsd4_encode_stateid(resp
, &close
->cl_stateid
);
2292 ENCODE_SEQID_OP_TAIL(close
->cl_stateowner
);
2298 nfsd4_encode_commit(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_commit
*commit
)
2304 WRITEMEM(commit
->co_verf
.data
, 8);
2311 nfsd4_encode_create(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_create
*create
)
2317 WRITECINFO(create
->cr_cinfo
);
2319 WRITE32(create
->cr_bmval
[0]);
2320 WRITE32(create
->cr_bmval
[1]);
2327 nfsd4_encode_getattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_getattr
*getattr
)
2329 struct svc_fh
*fhp
= getattr
->ga_fhp
;
2335 buflen
= resp
->end
- resp
->p
- (COMPOUND_ERR_SLACK_SPACE
>> 2);
2336 nfserr
= nfsd4_encode_fattr(fhp
, fhp
->fh_export
, fhp
->fh_dentry
,
2337 resp
->p
, &buflen
, getattr
->ga_bmval
,
2345 nfsd4_encode_getfh(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct svc_fh
**fhpp
)
2347 struct svc_fh
*fhp
= *fhpp
;
2352 len
= fhp
->fh_handle
.fh_size
;
2353 RESERVE_SPACE(len
+ 4);
2355 WRITEMEM(&fhp
->fh_handle
.fh_base
, len
);
2362 * Including all fields other than the name, a LOCK4denied structure requires
2363 * 8(clientid) + 4(namelen) + 8(offset) + 8(length) + 4(type) = 32 bytes.
2366 nfsd4_encode_lock_denied(struct nfsd4_compoundres
*resp
, struct nfsd4_lock_denied
*ld
)
2370 RESERVE_SPACE(32 + XDR_LEN(ld
->ld_sop
? ld
->ld_sop
->so_owner
.len
: 0));
2371 WRITE64(ld
->ld_start
);
2372 WRITE64(ld
->ld_length
);
2373 WRITE32(ld
->ld_type
);
2375 WRITEMEM(&ld
->ld_clientid
, 8);
2376 WRITE32(ld
->ld_sop
->so_owner
.len
);
2377 WRITEMEM(ld
->ld_sop
->so_owner
.data
, ld
->ld_sop
->so_owner
.len
);
2378 kref_put(&ld
->ld_sop
->so_ref
, nfs4_free_stateowner
);
2379 } else { /* non - nfsv4 lock in conflict, no clientid nor owner */
2380 WRITE64((u64
)0); /* clientid */
2381 WRITE32(0); /* length of owner name */
2387 nfsd4_encode_lock(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_lock
*lock
)
2389 ENCODE_SEQID_OP_HEAD
;
2392 nfsd4_encode_stateid(resp
, &lock
->lk_resp_stateid
);
2393 else if (nfserr
== nfserr_denied
)
2394 nfsd4_encode_lock_denied(resp
, &lock
->lk_denied
);
2396 ENCODE_SEQID_OP_TAIL(lock
->lk_replay_owner
);
2401 nfsd4_encode_lockt(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_lockt
*lockt
)
2403 if (nfserr
== nfserr_denied
)
2404 nfsd4_encode_lock_denied(resp
, &lockt
->lt_denied
);
2409 nfsd4_encode_locku(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_locku
*locku
)
2411 ENCODE_SEQID_OP_HEAD
;
2414 nfsd4_encode_stateid(resp
, &locku
->lu_stateid
);
2416 ENCODE_SEQID_OP_TAIL(locku
->lu_stateowner
);
2422 nfsd4_encode_link(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_link
*link
)
2428 WRITECINFO(link
->li_cinfo
);
2436 nfsd4_encode_open(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open
*open
)
2439 ENCODE_SEQID_OP_HEAD
;
2444 nfsd4_encode_stateid(resp
, &open
->op_stateid
);
2446 WRITECINFO(open
->op_cinfo
);
2447 WRITE32(open
->op_rflags
);
2449 WRITE32(open
->op_bmval
[0]);
2450 WRITE32(open
->op_bmval
[1]);
2451 WRITE32(open
->op_delegate_type
);
2454 switch (open
->op_delegate_type
) {
2455 case NFS4_OPEN_DELEGATE_NONE
:
2457 case NFS4_OPEN_DELEGATE_READ
:
2458 nfsd4_encode_stateid(resp
, &open
->op_delegate_stateid
);
2460 WRITE32(open
->op_recall
);
2463 * TODO: ACE's in delegations
2465 WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE
);
2468 WRITE32(0); /* XXX: is NULL principal ok? */
2471 case NFS4_OPEN_DELEGATE_WRITE
:
2472 nfsd4_encode_stateid(resp
, &open
->op_delegate_stateid
);
2477 * TODO: space_limit's in delegations
2479 WRITE32(NFS4_LIMIT_SIZE
);
2484 * TODO: ACE's in delegations
2486 WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE
);
2489 WRITE32(0); /* XXX: is NULL principal ok? */
2495 /* XXX save filehandle here */
2497 ENCODE_SEQID_OP_TAIL(open
->op_stateowner
);
2502 nfsd4_encode_open_confirm(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open_confirm
*oc
)
2504 ENCODE_SEQID_OP_HEAD
;
2507 nfsd4_encode_stateid(resp
, &oc
->oc_resp_stateid
);
2509 ENCODE_SEQID_OP_TAIL(oc
->oc_stateowner
);
2514 nfsd4_encode_open_downgrade(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open_downgrade
*od
)
2516 ENCODE_SEQID_OP_HEAD
;
2519 nfsd4_encode_stateid(resp
, &od
->od_stateid
);
2521 ENCODE_SEQID_OP_TAIL(od
->od_stateowner
);
2526 nfsd4_encode_read(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
2527 struct nfsd4_read
*read
)
2531 unsigned long maxcount
;
2537 if (resp
->xbuf
->page_len
)
2538 return nfserr_resource
;
2540 RESERVE_SPACE(8); /* eof flag and byte count */
2542 maxcount
= svc_max_payload(resp
->rqstp
);
2543 if (maxcount
> read
->rd_length
)
2544 maxcount
= read
->rd_length
;
2549 pn
= resp
->rqstp
->rq_resused
++;
2550 resp
->rqstp
->rq_vec
[v
].iov_base
=
2551 page_address(resp
->rqstp
->rq_respages
[pn
]);
2552 resp
->rqstp
->rq_vec
[v
].iov_len
=
2553 len
< PAGE_SIZE
? len
: PAGE_SIZE
;
2559 nfserr
= nfsd_read(read
->rd_rqstp
, read
->rd_fhp
, read
->rd_filp
,
2560 read
->rd_offset
, resp
->rqstp
->rq_vec
, read
->rd_vlen
,
2563 if (nfserr
== nfserr_symlink
)
2564 nfserr
= nfserr_inval
;
2567 eof
= (read
->rd_offset
+ maxcount
>=
2568 read
->rd_fhp
->fh_dentry
->d_inode
->i_size
);
2573 resp
->xbuf
->head
[0].iov_len
= (char*)p
2574 - (char*)resp
->xbuf
->head
[0].iov_base
;
2575 resp
->xbuf
->page_len
= maxcount
;
2577 /* Use rest of head for padding and remaining ops: */
2578 resp
->xbuf
->tail
[0].iov_base
= p
;
2579 resp
->xbuf
->tail
[0].iov_len
= 0;
2583 resp
->xbuf
->tail
[0].iov_base
+= maxcount
&3;
2584 resp
->xbuf
->tail
[0].iov_len
= 4 - (maxcount
&3);
2591 nfsd4_encode_readlink(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_readlink
*readlink
)
2599 if (resp
->xbuf
->page_len
)
2600 return nfserr_resource
;
2602 page
= page_address(resp
->rqstp
->rq_respages
[resp
->rqstp
->rq_resused
++]);
2604 maxcount
= PAGE_SIZE
;
2608 * XXX: By default, the ->readlink() VFS op will truncate symlinks
2609 * if they would overflow the buffer. Is this kosher in NFSv4? If
2610 * not, one easy fix is: if ->readlink() precisely fills the buffer,
2611 * assume that truncation occurred, and return NFS4ERR_RESOURCE.
2613 nfserr
= nfsd_readlink(readlink
->rl_rqstp
, readlink
->rl_fhp
, page
, &maxcount
);
2614 if (nfserr
== nfserr_isdir
)
2615 return nfserr_inval
;
2621 resp
->xbuf
->head
[0].iov_len
= (char*)p
2622 - (char*)resp
->xbuf
->head
[0].iov_base
;
2623 resp
->xbuf
->page_len
= maxcount
;
2625 /* Use rest of head for padding and remaining ops: */
2626 resp
->xbuf
->tail
[0].iov_base
= p
;
2627 resp
->xbuf
->tail
[0].iov_len
= 0;
2631 resp
->xbuf
->tail
[0].iov_base
+= maxcount
&3;
2632 resp
->xbuf
->tail
[0].iov_len
= 4 - (maxcount
&3);
2639 nfsd4_encode_readdir(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_readdir
*readdir
)
2643 __be32
*page
, *savep
, *tailbase
;
2648 if (resp
->xbuf
->page_len
)
2649 return nfserr_resource
;
2651 RESERVE_SPACE(8); /* verifier */
2654 /* XXX: Following NFSv3, we ignore the READDIR verifier for now. */
2658 resp
->xbuf
->head
[0].iov_len
= ((char*)resp
->p
) - (char*)resp
->xbuf
->head
[0].iov_base
;
2661 maxcount
= PAGE_SIZE
;
2662 if (maxcount
> readdir
->rd_maxcount
)
2663 maxcount
= readdir
->rd_maxcount
;
2666 * Convert from bytes to words, account for the two words already
2667 * written, make sure to leave two words at the end for the next
2668 * pointer and eof field.
2670 maxcount
= (maxcount
>> 2) - 4;
2672 nfserr
= nfserr_toosmall
;
2676 page
= page_address(resp
->rqstp
->rq_respages
[resp
->rqstp
->rq_resused
++]);
2677 readdir
->common
.err
= 0;
2678 readdir
->buflen
= maxcount
;
2679 readdir
->buffer
= page
;
2680 readdir
->offset
= NULL
;
2682 offset
= readdir
->rd_cookie
;
2683 nfserr
= nfsd_readdir(readdir
->rd_rqstp
, readdir
->rd_fhp
,
2685 &readdir
->common
, nfsd4_encode_dirent
);
2686 if (nfserr
== nfs_ok
&&
2687 readdir
->common
.err
== nfserr_toosmall
&&
2688 readdir
->buffer
== page
)
2689 nfserr
= nfserr_toosmall
;
2690 if (nfserr
== nfserr_symlink
)
2691 nfserr
= nfserr_notdir
;
2695 if (readdir
->offset
)
2696 xdr_encode_hyper(readdir
->offset
, offset
);
2698 p
= readdir
->buffer
;
2699 *p
++ = 0; /* no more entries */
2700 *p
++ = htonl(readdir
->common
.err
== nfserr_eof
);
2701 resp
->xbuf
->page_len
= ((char*)p
) - (char*)page_address(
2702 resp
->rqstp
->rq_respages
[resp
->rqstp
->rq_resused
-1]);
2704 /* Use rest of head for padding and remaining ops: */
2705 resp
->xbuf
->tail
[0].iov_base
= tailbase
;
2706 resp
->xbuf
->tail
[0].iov_len
= 0;
2707 resp
->p
= resp
->xbuf
->tail
[0].iov_base
;
2708 resp
->end
= resp
->p
+ (PAGE_SIZE
- resp
->xbuf
->head
[0].iov_len
)/4;
2718 nfsd4_encode_remove(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_remove
*remove
)
2724 WRITECINFO(remove
->rm_cinfo
);
2731 nfsd4_encode_rename(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_rename
*rename
)
2737 WRITECINFO(rename
->rn_sinfo
);
2738 WRITECINFO(rename
->rn_tinfo
);
2745 nfsd4_encode_secinfo(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
2746 struct nfsd4_secinfo
*secinfo
)
2749 struct svc_export
*exp
= secinfo
->si_exp
;
2751 struct exp_flavor_info
*flavs
;
2752 struct exp_flavor_info def_flavs
[2];
2757 if (exp
->ex_nflavors
) {
2758 flavs
= exp
->ex_flavors
;
2759 nflavs
= exp
->ex_nflavors
;
2760 } else { /* Handling of some defaults in absence of real secinfo: */
2762 if (exp
->ex_client
->flavour
->flavour
== RPC_AUTH_UNIX
) {
2764 flavs
[0].pseudoflavor
= RPC_AUTH_UNIX
;
2765 flavs
[1].pseudoflavor
= RPC_AUTH_NULL
;
2766 } else if (exp
->ex_client
->flavour
->flavour
== RPC_AUTH_GSS
) {
2768 flavs
[0].pseudoflavor
2769 = svcauth_gss_flavor(exp
->ex_client
);
2772 flavs
[0].pseudoflavor
2773 = exp
->ex_client
->flavour
->flavour
;
2780 for (i
= 0; i
< nflavs
; i
++) {
2781 u32 flav
= flavs
[i
].pseudoflavor
;
2782 struct gss_api_mech
*gm
= gss_mech_get_by_pseudoflavor(flav
);
2786 WRITE32(RPC_AUTH_GSS
);
2788 RESERVE_SPACE(4 + gm
->gm_oid
.len
);
2789 WRITE32(gm
->gm_oid
.len
);
2790 WRITEMEM(gm
->gm_oid
.data
, gm
->gm_oid
.len
);
2793 WRITE32(0); /* qop */
2796 WRITE32(gss_pseudoflavor_to_service(gm
, flav
));
2812 * The SETATTR encode routine is special -- it always encodes a bitmap,
2813 * regardless of the error status.
2816 nfsd4_encode_setattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_setattr
*setattr
)
2828 WRITE32(setattr
->sa_bmval
[0]);
2829 WRITE32(setattr
->sa_bmval
[1]);
2836 nfsd4_encode_setclientid(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_setclientid
*scd
)
2841 RESERVE_SPACE(8 + sizeof(nfs4_verifier
));
2842 WRITEMEM(&scd
->se_clientid
, 8);
2843 WRITEMEM(&scd
->se_confirm
, sizeof(nfs4_verifier
));
2846 else if (nfserr
== nfserr_clid_inuse
) {
2856 nfsd4_encode_write(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_write
*write
)
2862 WRITE32(write
->wr_bytes_written
);
2863 WRITE32(write
->wr_how_written
);
2864 WRITEMEM(write
->wr_verifier
.data
, 8);
2871 nfsd4_encode_exchange_id(struct nfsd4_compoundres
*resp
, int nfserr
,
2872 struct nfsd4_exchange_id
*exid
)
2878 int server_scope_sz
;
2879 uint64_t minor_id
= 0;
2884 major_id
= utsname()->nodename
;
2885 major_id_sz
= strlen(major_id
);
2886 server_scope
= utsname()->nodename
;
2887 server_scope_sz
= strlen(server_scope
);
2890 8 /* eir_clientid */ +
2891 4 /* eir_sequenceid */ +
2893 4 /* spr_how (SP4_NONE) */ +
2894 8 /* so_minor_id */ +
2895 4 /* so_major_id.len */ +
2896 (XDR_QUADLEN(major_id_sz
) * 4) +
2897 4 /* eir_server_scope.len */ +
2898 (XDR_QUADLEN(server_scope_sz
) * 4) +
2899 4 /* eir_server_impl_id.count (0) */);
2901 WRITEMEM(&exid
->clientid
, 8);
2902 WRITE32(exid
->seqid
);
2903 WRITE32(exid
->flags
);
2905 /* state_protect4_r. Currently only support SP4_NONE */
2906 BUG_ON(exid
->spa_how
!= SP4_NONE
);
2907 WRITE32(exid
->spa_how
);
2909 /* The server_owner struct */
2910 WRITE64(minor_id
); /* Minor id */
2912 WRITE32(major_id_sz
);
2913 WRITEMEM(major_id
, major_id_sz
);
2916 WRITE32(server_scope_sz
);
2917 WRITEMEM(server_scope
, server_scope_sz
);
2919 /* Implementation id */
2920 WRITE32(0); /* zero length nfs_impl_id4 array */
2926 nfsd4_encode_create_session(struct nfsd4_compoundres
*resp
, int nfserr
,
2927 struct nfsd4_create_session
*sess
)
2935 WRITEMEM(sess
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
2936 WRITE32(sess
->seqid
);
2937 WRITE32(sess
->flags
);
2941 WRITE32(0); /* headerpadsz */
2942 WRITE32(sess
->fore_channel
.maxreq_sz
);
2943 WRITE32(sess
->fore_channel
.maxresp_sz
);
2944 WRITE32(sess
->fore_channel
.maxresp_cached
);
2945 WRITE32(sess
->fore_channel
.maxops
);
2946 WRITE32(sess
->fore_channel
.maxreqs
);
2947 WRITE32(sess
->fore_channel
.nr_rdma_attrs
);
2950 if (sess
->fore_channel
.nr_rdma_attrs
) {
2952 WRITE32(sess
->fore_channel
.rdma_attrs
);
2957 WRITE32(0); /* headerpadsz */
2958 WRITE32(sess
->back_channel
.maxreq_sz
);
2959 WRITE32(sess
->back_channel
.maxresp_sz
);
2960 WRITE32(sess
->back_channel
.maxresp_cached
);
2961 WRITE32(sess
->back_channel
.maxops
);
2962 WRITE32(sess
->back_channel
.maxreqs
);
2963 WRITE32(sess
->back_channel
.nr_rdma_attrs
);
2966 if (sess
->back_channel
.nr_rdma_attrs
) {
2968 WRITE32(sess
->back_channel
.rdma_attrs
);
2975 nfsd4_encode_destroy_session(struct nfsd4_compoundres
*resp
, int nfserr
,
2976 struct nfsd4_destroy_session
*destroy_session
)
2982 nfsd4_encode_sequence(struct nfsd4_compoundres
*resp
, int nfserr
,
2983 struct nfsd4_sequence
*seq
)
2990 RESERVE_SPACE(NFS4_MAX_SESSIONID_LEN
+ 20);
2991 WRITEMEM(seq
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
2992 WRITE32(seq
->seqid
);
2993 WRITE32(seq
->slotid
);
2994 WRITE32(seq
->maxslots
);
2997 * target_maxslots = maxslots
3000 WRITE32(seq
->maxslots
);
3008 nfsd4_encode_noop(struct nfsd4_compoundres
*resp
, __be32 nfserr
, void *p
)
3013 typedef __be32(* nfsd4_enc
)(struct nfsd4_compoundres
*, __be32
, void *);
3016 * Note: nfsd4_enc_ops vector is shared for v4.0 and v4.1
3017 * since we don't need to filter out obsolete ops as this is
3018 * done in the decoding phase.
3020 static nfsd4_enc nfsd4_enc_ops
[] = {
3021 [OP_ACCESS
] = (nfsd4_enc
)nfsd4_encode_access
,
3022 [OP_CLOSE
] = (nfsd4_enc
)nfsd4_encode_close
,
3023 [OP_COMMIT
] = (nfsd4_enc
)nfsd4_encode_commit
,
3024 [OP_CREATE
] = (nfsd4_enc
)nfsd4_encode_create
,
3025 [OP_DELEGPURGE
] = (nfsd4_enc
)nfsd4_encode_noop
,
3026 [OP_DELEGRETURN
] = (nfsd4_enc
)nfsd4_encode_noop
,
3027 [OP_GETATTR
] = (nfsd4_enc
)nfsd4_encode_getattr
,
3028 [OP_GETFH
] = (nfsd4_enc
)nfsd4_encode_getfh
,
3029 [OP_LINK
] = (nfsd4_enc
)nfsd4_encode_link
,
3030 [OP_LOCK
] = (nfsd4_enc
)nfsd4_encode_lock
,
3031 [OP_LOCKT
] = (nfsd4_enc
)nfsd4_encode_lockt
,
3032 [OP_LOCKU
] = (nfsd4_enc
)nfsd4_encode_locku
,
3033 [OP_LOOKUP
] = (nfsd4_enc
)nfsd4_encode_noop
,
3034 [OP_LOOKUPP
] = (nfsd4_enc
)nfsd4_encode_noop
,
3035 [OP_NVERIFY
] = (nfsd4_enc
)nfsd4_encode_noop
,
3036 [OP_OPEN
] = (nfsd4_enc
)nfsd4_encode_open
,
3037 [OP_OPENATTR
] = (nfsd4_enc
)nfsd4_encode_noop
,
3038 [OP_OPEN_CONFIRM
] = (nfsd4_enc
)nfsd4_encode_open_confirm
,
3039 [OP_OPEN_DOWNGRADE
] = (nfsd4_enc
)nfsd4_encode_open_downgrade
,
3040 [OP_PUTFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3041 [OP_PUTPUBFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3042 [OP_PUTROOTFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3043 [OP_READ
] = (nfsd4_enc
)nfsd4_encode_read
,
3044 [OP_READDIR
] = (nfsd4_enc
)nfsd4_encode_readdir
,
3045 [OP_READLINK
] = (nfsd4_enc
)nfsd4_encode_readlink
,
3046 [OP_REMOVE
] = (nfsd4_enc
)nfsd4_encode_remove
,
3047 [OP_RENAME
] = (nfsd4_enc
)nfsd4_encode_rename
,
3048 [OP_RENEW
] = (nfsd4_enc
)nfsd4_encode_noop
,
3049 [OP_RESTOREFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3050 [OP_SAVEFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3051 [OP_SECINFO
] = (nfsd4_enc
)nfsd4_encode_secinfo
,
3052 [OP_SETATTR
] = (nfsd4_enc
)nfsd4_encode_setattr
,
3053 [OP_SETCLIENTID
] = (nfsd4_enc
)nfsd4_encode_setclientid
,
3054 [OP_SETCLIENTID_CONFIRM
] = (nfsd4_enc
)nfsd4_encode_noop
,
3055 [OP_VERIFY
] = (nfsd4_enc
)nfsd4_encode_noop
,
3056 [OP_WRITE
] = (nfsd4_enc
)nfsd4_encode_write
,
3057 [OP_RELEASE_LOCKOWNER
] = (nfsd4_enc
)nfsd4_encode_noop
,
3059 /* NFSv4.1 operations */
3060 [OP_BACKCHANNEL_CTL
] = (nfsd4_enc
)nfsd4_encode_noop
,
3061 [OP_BIND_CONN_TO_SESSION
] = (nfsd4_enc
)nfsd4_encode_noop
,
3062 [OP_EXCHANGE_ID
] = (nfsd4_enc
)nfsd4_encode_exchange_id
,
3063 [OP_CREATE_SESSION
] = (nfsd4_enc
)nfsd4_encode_create_session
,
3064 [OP_DESTROY_SESSION
] = (nfsd4_enc
)nfsd4_encode_destroy_session
,
3065 [OP_FREE_STATEID
] = (nfsd4_enc
)nfsd4_encode_noop
,
3066 [OP_GET_DIR_DELEGATION
] = (nfsd4_enc
)nfsd4_encode_noop
,
3067 [OP_GETDEVICEINFO
] = (nfsd4_enc
)nfsd4_encode_noop
,
3068 [OP_GETDEVICELIST
] = (nfsd4_enc
)nfsd4_encode_noop
,
3069 [OP_LAYOUTCOMMIT
] = (nfsd4_enc
)nfsd4_encode_noop
,
3070 [OP_LAYOUTGET
] = (nfsd4_enc
)nfsd4_encode_noop
,
3071 [OP_LAYOUTRETURN
] = (nfsd4_enc
)nfsd4_encode_noop
,
3072 [OP_SECINFO_NO_NAME
] = (nfsd4_enc
)nfsd4_encode_noop
,
3073 [OP_SEQUENCE
] = (nfsd4_enc
)nfsd4_encode_sequence
,
3074 [OP_SET_SSV
] = (nfsd4_enc
)nfsd4_encode_noop
,
3075 [OP_TEST_STATEID
] = (nfsd4_enc
)nfsd4_encode_noop
,
3076 [OP_WANT_DELEGATION
] = (nfsd4_enc
)nfsd4_encode_noop
,
3077 [OP_DESTROY_CLIENTID
] = (nfsd4_enc
)nfsd4_encode_noop
,
3078 [OP_RECLAIM_COMPLETE
] = (nfsd4_enc
)nfsd4_encode_noop
,
3082 nfsd4_encode_operation(struct nfsd4_compoundres
*resp
, struct nfsd4_op
*op
)
3089 statp
= p
++; /* to be backfilled at the end */
3092 if (op
->opnum
== OP_ILLEGAL
)
3094 BUG_ON(op
->opnum
< 0 || op
->opnum
>= ARRAY_SIZE(nfsd4_enc_ops
) ||
3095 !nfsd4_enc_ops
[op
->opnum
]);
3096 op
->status
= nfsd4_enc_ops
[op
->opnum
](resp
, op
->status
, &op
->u
);
3099 * Note: We write the status directly, instead of using WRITE32(),
3100 * since it is already in network byte order.
3102 *statp
= op
->status
;
3106 * Encode the reply stored in the stateowner reply cache
3108 * XDR note: do not encode rp->rp_buflen: the buffer contains the
3109 * previously sent already encoded operation.
3111 * called with nfs4_lock_state() held
3114 nfsd4_encode_replay(struct nfsd4_compoundres
*resp
, struct nfsd4_op
*op
)
3117 struct nfs4_replay
*rp
= op
->replay
;
3123 *p
++ = rp
->rp_status
; /* already xdr'ed */
3126 RESERVE_SPACE(rp
->rp_buflen
);
3127 WRITEMEM(rp
->rp_buf
, rp
->rp_buflen
);
3132 * END OF "GENERIC" ENCODE ROUTINES.
3136 nfs4svc_encode_voidres(struct svc_rqst
*rqstp
, __be32
*p
, void *dummy
)
3138 return xdr_ressize_check(rqstp
, p
);
3141 void nfsd4_release_compoundargs(struct nfsd4_compoundargs
*args
)
3143 if (args
->ops
!= args
->iops
) {
3145 args
->ops
= args
->iops
;
3149 while (args
->to_free
) {
3150 struct tmpbuf
*tb
= args
->to_free
;
3151 args
->to_free
= tb
->next
;
3152 tb
->release(tb
->buf
);
3158 nfs4svc_decode_compoundargs(struct svc_rqst
*rqstp
, __be32
*p
, struct nfsd4_compoundargs
*args
)
3163 args
->end
= rqstp
->rq_arg
.head
[0].iov_base
+ rqstp
->rq_arg
.head
[0].iov_len
;
3164 args
->pagelist
= rqstp
->rq_arg
.pages
;
3165 args
->pagelen
= rqstp
->rq_arg
.page_len
;
3167 args
->to_free
= NULL
;
3168 args
->ops
= args
->iops
;
3169 args
->rqstp
= rqstp
;
3171 status
= nfsd4_decode_compound(args
);
3173 nfsd4_release_compoundargs(args
);
3179 nfs4svc_encode_compoundres(struct svc_rqst
*rqstp
, __be32
*p
, struct nfsd4_compoundres
*resp
)
3182 * All that remains is to write the tag and operation count...
3186 *p
++ = htonl(resp
->taglen
);
3187 memcpy(p
, resp
->tag
, resp
->taglen
);
3188 p
+= XDR_QUADLEN(resp
->taglen
);
3189 *p
++ = htonl(resp
->opcnt
);
3191 if (rqstp
->rq_res
.page_len
)
3192 iov
= &rqstp
->rq_res
.tail
[0];
3194 iov
= &rqstp
->rq_res
.head
[0];
3195 iov
->iov_len
= ((char*)resp
->p
) - (char*)iov
->iov_base
;
3196 BUG_ON(iov
->iov_len
> PAGE_SIZE
);
3197 if (resp
->cstate
.slot
!= NULL
) {
3198 if (resp
->cstate
.status
== nfserr_replay_cache
&&
3199 !nfsd4_not_cached(resp
)) {
3200 iov
->iov_len
= resp
->cstate
.iovlen
;
3202 nfsd4_store_cache_entry(resp
);
3203 dprintk("%s: SET SLOT STATE TO AVAILABLE\n", __func__
);
3204 resp
->cstate
.slot
->sl_inuse
= 0;
3206 if (resp
->cstate
.session
)
3207 nfsd4_put_session(resp
->cstate
.session
);