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/slab.h>
44 #include <linux/namei.h>
45 #include <linux/statfs.h>
46 #include <linux/utsname.h>
47 #include <linux/sunrpc/svcauth_gss.h>
55 #define NFSDDBG_FACILITY NFSDDBG_XDR
58 * As per referral draft, the fsid for a referral MUST be different from the fsid of the containing
59 * directory in order to indicate to the client that a filesystem boundary is present
60 * We use a fixed fsid for a referral
62 #define NFS4_REFERRAL_FSID_MAJOR 0x8000000ULL
63 #define NFS4_REFERRAL_FSID_MINOR 0x8000000ULL
66 check_filename(char *str
, int len
, __be32 err
)
72 if (isdotent(str
, len
))
74 for (i
= 0; i
< len
; i
++)
88 dprintk("NFSD: xdr error (%s:%d)\n", \
89 __FILE__, __LINE__); \
90 status = nfserr_bad_xdr; \
93 #define READ32(x) (x) = ntohl(*p++)
94 #define READ64(x) do { \
95 (x) = (u64)ntohl(*p++) << 32; \
98 #define READTIME(x) do { \
103 #define READMEM(x,nbytes) do { \
105 p += XDR_QUADLEN(nbytes); \
107 #define SAVEMEM(x,nbytes) do { \
108 if (!(x = (p==argp->tmp || p == argp->tmpp) ? \
109 savemem(argp, p, nbytes) : \
111 dprintk("NFSD: xdr error (%s:%d)\n", \
112 __FILE__, __LINE__); \
115 p += XDR_QUADLEN(nbytes); \
117 #define COPYMEM(x,nbytes) do { \
118 memcpy((x), p, nbytes); \
119 p += XDR_QUADLEN(nbytes); \
122 /* READ_BUF, read_buf(): nbytes must be <= PAGE_SIZE */
123 #define READ_BUF(nbytes) do { \
124 if (nbytes <= (u32)((char *)argp->end - (char *)argp->p)) { \
126 argp->p += XDR_QUADLEN(nbytes); \
127 } else if (!(p = read_buf(argp, nbytes))) { \
128 dprintk("NFSD: xdr error (%s:%d)\n", \
129 __FILE__, __LINE__); \
134 static __be32
*read_buf(struct nfsd4_compoundargs
*argp
, u32 nbytes
)
136 /* We want more bytes than seem to be available.
137 * Maybe we need a new page, maybe we have just run out
139 unsigned int avail
= (char *)argp
->end
- (char *)argp
->p
;
141 if (avail
+ argp
->pagelen
< nbytes
)
143 if (avail
+ PAGE_SIZE
< nbytes
) /* need more than a page !! */
145 /* ok, we can do it with the current plus the next page */
146 if (nbytes
<= sizeof(argp
->tmp
))
150 p
= argp
->tmpp
= kmalloc(nbytes
, GFP_KERNEL
);
156 * The following memcpy is safe because read_buf is always
157 * called with nbytes > avail, and the two cases above both
158 * guarantee p points to at least nbytes bytes.
160 memcpy(p
, argp
->p
, avail
);
161 /* step to next page */
162 argp
->p
= page_address(argp
->pagelist
[0]);
164 if (argp
->pagelen
< PAGE_SIZE
) {
165 argp
->end
= argp
->p
+ (argp
->pagelen
>>2);
168 argp
->end
= argp
->p
+ (PAGE_SIZE
>>2);
169 argp
->pagelen
-= PAGE_SIZE
;
171 memcpy(((char*)p
)+avail
, argp
->p
, (nbytes
- avail
));
172 argp
->p
+= XDR_QUADLEN(nbytes
- avail
);
176 static int zero_clientid(clientid_t
*clid
)
178 return (clid
->cl_boot
== 0) && (clid
->cl_id
== 0);
182 defer_free(struct nfsd4_compoundargs
*argp
,
183 void (*release
)(const void *), void *p
)
187 tb
= kmalloc(sizeof(*tb
), GFP_KERNEL
);
191 tb
->release
= release
;
192 tb
->next
= argp
->to_free
;
197 static char *savemem(struct nfsd4_compoundargs
*argp
, __be32
*p
, int nbytes
)
199 if (p
== argp
->tmp
) {
200 p
= kmalloc(nbytes
, GFP_KERNEL
);
203 memcpy(p
, argp
->tmp
, nbytes
);
205 BUG_ON(p
!= argp
->tmpp
);
208 if (defer_free(argp
, kfree
, p
)) {
216 nfsd4_decode_bitmap(struct nfsd4_compoundargs
*argp
, u32
*bmval
)
230 READ_BUF(bmlen
<< 2);
242 nfsd4_decode_fattr(struct nfsd4_compoundargs
*argp
, u32
*bmval
,
243 struct iattr
*iattr
, struct nfs4_acl
**acl
)
245 int expected_len
, len
= 0;
252 if ((status
= nfsd4_decode_bitmap(argp
, bmval
)))
256 READ32(expected_len
);
258 if (bmval
[0] & FATTR4_WORD0_SIZE
) {
261 READ64(iattr
->ia_size
);
262 iattr
->ia_valid
|= ATTR_SIZE
;
264 if (bmval
[0] & FATTR4_WORD0_ACL
) {
266 struct nfs4_ace
*ace
;
268 READ_BUF(4); len
+= 4;
271 if (nace
> NFS4_ACL_MAX
)
272 return nfserr_resource
;
274 *acl
= nfs4_acl_new(nace
);
279 defer_free(argp
, kfree
, *acl
);
281 (*acl
)->naces
= nace
;
282 for (ace
= (*acl
)->aces
; ace
< (*acl
)->aces
+ nace
; ace
++) {
283 READ_BUF(16); len
+= 16;
286 READ32(ace
->access_mask
);
289 len
+= XDR_QUADLEN(dummy32
) << 2;
290 READMEM(buf
, dummy32
);
291 ace
->whotype
= nfs4_acl_get_whotype(buf
, dummy32
);
293 if (ace
->whotype
!= NFS4_ACL_WHO_NAMED
)
295 else if (ace
->flag
& NFS4_ACE_IDENTIFIER_GROUP
)
296 host_err
= nfsd_map_name_to_gid(argp
->rqstp
,
297 buf
, dummy32
, &ace
->who
);
299 host_err
= nfsd_map_name_to_uid(argp
->rqstp
,
300 buf
, dummy32
, &ace
->who
);
306 if (bmval
[1] & FATTR4_WORD1_MODE
) {
309 READ32(iattr
->ia_mode
);
310 iattr
->ia_mode
&= (S_IFMT
| S_IALLUGO
);
311 iattr
->ia_valid
|= ATTR_MODE
;
313 if (bmval
[1] & FATTR4_WORD1_OWNER
) {
318 len
+= (XDR_QUADLEN(dummy32
) << 2);
319 READMEM(buf
, dummy32
);
320 if ((host_err
= nfsd_map_name_to_uid(argp
->rqstp
, buf
, dummy32
, &iattr
->ia_uid
)))
322 iattr
->ia_valid
|= ATTR_UID
;
324 if (bmval
[1] & FATTR4_WORD1_OWNER_GROUP
) {
329 len
+= (XDR_QUADLEN(dummy32
) << 2);
330 READMEM(buf
, dummy32
);
331 if ((host_err
= nfsd_map_name_to_gid(argp
->rqstp
, buf
, dummy32
, &iattr
->ia_gid
)))
333 iattr
->ia_valid
|= ATTR_GID
;
335 if (bmval
[1] & FATTR4_WORD1_TIME_ACCESS_SET
) {
340 case NFS4_SET_TO_CLIENT_TIME
:
341 /* We require the high 32 bits of 'seconds' to be 0, and we ignore
342 all 32 bits of 'nseconds'. */
348 READ32(iattr
->ia_atime
.tv_sec
);
349 READ32(iattr
->ia_atime
.tv_nsec
);
350 if (iattr
->ia_atime
.tv_nsec
>= (u32
)1000000000)
352 iattr
->ia_valid
|= (ATTR_ATIME
| ATTR_ATIME_SET
);
354 case NFS4_SET_TO_SERVER_TIME
:
355 iattr
->ia_valid
|= ATTR_ATIME
;
361 if (bmval
[1] & FATTR4_WORD1_TIME_MODIFY_SET
) {
366 case NFS4_SET_TO_CLIENT_TIME
:
367 /* We require the high 32 bits of 'seconds' to be 0, and we ignore
368 all 32 bits of 'nseconds'. */
374 READ32(iattr
->ia_mtime
.tv_sec
);
375 READ32(iattr
->ia_mtime
.tv_nsec
);
376 if (iattr
->ia_mtime
.tv_nsec
>= (u32
)1000000000)
378 iattr
->ia_valid
|= (ATTR_MTIME
| ATTR_MTIME_SET
);
380 case NFS4_SET_TO_SERVER_TIME
:
381 iattr
->ia_valid
|= ATTR_MTIME
;
387 if (bmval
[0] & ~NFSD_WRITEABLE_ATTRS_WORD0
388 || bmval
[1] & ~NFSD_WRITEABLE_ATTRS_WORD1
389 || bmval
[2] & ~NFSD_WRITEABLE_ATTRS_WORD2
)
390 READ_BUF(expected_len
- len
);
391 else if (len
!= expected_len
)
397 status
= nfserrno(host_err
);
402 nfsd4_decode_stateid(struct nfsd4_compoundargs
*argp
, stateid_t
*sid
)
406 READ_BUF(sizeof(stateid_t
));
407 READ32(sid
->si_generation
);
408 COPYMEM(&sid
->si_opaque
, sizeof(stateid_opaque_t
));
414 nfsd4_decode_access(struct nfsd4_compoundargs
*argp
, struct nfsd4_access
*access
)
419 READ32(access
->ac_req_access
);
425 nfsd4_decode_close(struct nfsd4_compoundargs
*argp
, struct nfsd4_close
*close
)
429 close
->cl_stateowner
= NULL
;
431 READ32(close
->cl_seqid
);
432 return nfsd4_decode_stateid(argp
, &close
->cl_stateid
);
439 nfsd4_decode_commit(struct nfsd4_compoundargs
*argp
, struct nfsd4_commit
*commit
)
444 READ64(commit
->co_offset
);
445 READ32(commit
->co_count
);
451 nfsd4_decode_create(struct nfsd4_compoundargs
*argp
, struct nfsd4_create
*create
)
456 READ32(create
->cr_type
);
457 switch (create
->cr_type
) {
460 READ32(create
->cr_linklen
);
461 READ_BUF(create
->cr_linklen
);
462 SAVEMEM(create
->cr_linkname
, create
->cr_linklen
);
467 READ32(create
->cr_specdata1
);
468 READ32(create
->cr_specdata2
);
478 READ32(create
->cr_namelen
);
479 READ_BUF(create
->cr_namelen
);
480 SAVEMEM(create
->cr_name
, create
->cr_namelen
);
481 if ((status
= check_filename(create
->cr_name
, create
->cr_namelen
, nfserr_inval
)))
484 status
= nfsd4_decode_fattr(argp
, create
->cr_bmval
, &create
->cr_iattr
,
493 nfsd4_decode_delegreturn(struct nfsd4_compoundargs
*argp
, struct nfsd4_delegreturn
*dr
)
495 return nfsd4_decode_stateid(argp
, &dr
->dr_stateid
);
499 nfsd4_decode_getattr(struct nfsd4_compoundargs
*argp
, struct nfsd4_getattr
*getattr
)
501 return nfsd4_decode_bitmap(argp
, getattr
->ga_bmval
);
505 nfsd4_decode_link(struct nfsd4_compoundargs
*argp
, struct nfsd4_link
*link
)
510 READ32(link
->li_namelen
);
511 READ_BUF(link
->li_namelen
);
512 SAVEMEM(link
->li_name
, link
->li_namelen
);
513 if ((status
= check_filename(link
->li_name
, link
->li_namelen
, nfserr_inval
)))
520 nfsd4_decode_lock(struct nfsd4_compoundargs
*argp
, struct nfsd4_lock
*lock
)
524 lock
->lk_replay_owner
= NULL
;
526 * type, reclaim(boolean), offset, length, new_lock_owner(boolean)
529 READ32(lock
->lk_type
);
530 if ((lock
->lk_type
< NFS4_READ_LT
) || (lock
->lk_type
> NFS4_WRITEW_LT
))
532 READ32(lock
->lk_reclaim
);
533 READ64(lock
->lk_offset
);
534 READ64(lock
->lk_length
);
535 READ32(lock
->lk_is_new
);
537 if (lock
->lk_is_new
) {
539 READ32(lock
->lk_new_open_seqid
);
540 status
= nfsd4_decode_stateid(argp
, &lock
->lk_new_open_stateid
);
543 READ_BUF(8 + sizeof(clientid_t
));
544 READ32(lock
->lk_new_lock_seqid
);
545 COPYMEM(&lock
->lk_new_clientid
, sizeof(clientid_t
));
546 READ32(lock
->lk_new_owner
.len
);
547 READ_BUF(lock
->lk_new_owner
.len
);
548 READMEM(lock
->lk_new_owner
.data
, lock
->lk_new_owner
.len
);
550 status
= nfsd4_decode_stateid(argp
, &lock
->lk_old_lock_stateid
);
554 READ32(lock
->lk_old_lock_seqid
);
561 nfsd4_decode_lockt(struct nfsd4_compoundargs
*argp
, struct nfsd4_lockt
*lockt
)
566 READ32(lockt
->lt_type
);
567 if((lockt
->lt_type
< NFS4_READ_LT
) || (lockt
->lt_type
> NFS4_WRITEW_LT
))
569 READ64(lockt
->lt_offset
);
570 READ64(lockt
->lt_length
);
571 COPYMEM(&lockt
->lt_clientid
, 8);
572 READ32(lockt
->lt_owner
.len
);
573 READ_BUF(lockt
->lt_owner
.len
);
574 READMEM(lockt
->lt_owner
.data
, lockt
->lt_owner
.len
);
576 if (argp
->minorversion
&& !zero_clientid(&lockt
->lt_clientid
))
582 nfsd4_decode_locku(struct nfsd4_compoundargs
*argp
, struct nfsd4_locku
*locku
)
586 locku
->lu_stateowner
= NULL
;
588 READ32(locku
->lu_type
);
589 if ((locku
->lu_type
< NFS4_READ_LT
) || (locku
->lu_type
> NFS4_WRITEW_LT
))
591 READ32(locku
->lu_seqid
);
592 status
= nfsd4_decode_stateid(argp
, &locku
->lu_stateid
);
596 READ64(locku
->lu_offset
);
597 READ64(locku
->lu_length
);
603 nfsd4_decode_lookup(struct nfsd4_compoundargs
*argp
, struct nfsd4_lookup
*lookup
)
608 READ32(lookup
->lo_len
);
609 READ_BUF(lookup
->lo_len
);
610 SAVEMEM(lookup
->lo_name
, lookup
->lo_len
);
611 if ((status
= check_filename(lookup
->lo_name
, lookup
->lo_len
, nfserr_noent
)))
618 nfsd4_decode_open(struct nfsd4_compoundargs
*argp
, struct nfsd4_open
*open
)
622 memset(open
->op_bmval
, 0, sizeof(open
->op_bmval
));
623 open
->op_iattr
.ia_valid
= 0;
624 open
->op_stateowner
= NULL
;
626 /* seqid, share_access, share_deny, clientid, ownerlen */
627 READ_BUF(16 + sizeof(clientid_t
));
628 READ32(open
->op_seqid
);
629 READ32(open
->op_share_access
);
630 READ32(open
->op_share_deny
);
631 COPYMEM(&open
->op_clientid
, sizeof(clientid_t
));
632 READ32(open
->op_owner
.len
);
634 /* owner, open_flag */
635 READ_BUF(open
->op_owner
.len
+ 4);
636 SAVEMEM(open
->op_owner
.data
, open
->op_owner
.len
);
637 READ32(open
->op_create
);
638 switch (open
->op_create
) {
639 case NFS4_OPEN_NOCREATE
:
641 case NFS4_OPEN_CREATE
:
643 READ32(open
->op_createmode
);
644 switch (open
->op_createmode
) {
645 case NFS4_CREATE_UNCHECKED
:
646 case NFS4_CREATE_GUARDED
:
647 status
= nfsd4_decode_fattr(argp
, open
->op_bmval
,
648 &open
->op_iattr
, &open
->op_acl
);
652 case NFS4_CREATE_EXCLUSIVE
:
654 COPYMEM(open
->op_verf
.data
, 8);
656 case NFS4_CREATE_EXCLUSIVE4_1
:
657 if (argp
->minorversion
< 1)
660 COPYMEM(open
->op_verf
.data
, 8);
661 status
= nfsd4_decode_fattr(argp
, open
->op_bmval
,
662 &open
->op_iattr
, &open
->op_acl
);
676 READ32(open
->op_claim_type
);
677 switch (open
->op_claim_type
) {
678 case NFS4_OPEN_CLAIM_NULL
:
679 case NFS4_OPEN_CLAIM_DELEGATE_PREV
:
681 READ32(open
->op_fname
.len
);
682 READ_BUF(open
->op_fname
.len
);
683 SAVEMEM(open
->op_fname
.data
, open
->op_fname
.len
);
684 if ((status
= check_filename(open
->op_fname
.data
, open
->op_fname
.len
, nfserr_inval
)))
687 case NFS4_OPEN_CLAIM_PREVIOUS
:
689 READ32(open
->op_delegate_type
);
691 case NFS4_OPEN_CLAIM_DELEGATE_CUR
:
692 status
= nfsd4_decode_stateid(argp
, &open
->op_delegate_stateid
);
696 READ32(open
->op_fname
.len
);
697 READ_BUF(open
->op_fname
.len
);
698 SAVEMEM(open
->op_fname
.data
, open
->op_fname
.len
);
699 if ((status
= check_filename(open
->op_fname
.data
, open
->op_fname
.len
, nfserr_inval
)))
710 nfsd4_decode_open_confirm(struct nfsd4_compoundargs
*argp
, struct nfsd4_open_confirm
*open_conf
)
714 open_conf
->oc_stateowner
= NULL
;
715 status
= nfsd4_decode_stateid(argp
, &open_conf
->oc_req_stateid
);
719 READ32(open_conf
->oc_seqid
);
725 nfsd4_decode_open_downgrade(struct nfsd4_compoundargs
*argp
, struct nfsd4_open_downgrade
*open_down
)
729 open_down
->od_stateowner
= NULL
;
730 status
= nfsd4_decode_stateid(argp
, &open_down
->od_stateid
);
734 READ32(open_down
->od_seqid
);
735 READ32(open_down
->od_share_access
);
736 READ32(open_down
->od_share_deny
);
742 nfsd4_decode_putfh(struct nfsd4_compoundargs
*argp
, struct nfsd4_putfh
*putfh
)
747 READ32(putfh
->pf_fhlen
);
748 if (putfh
->pf_fhlen
> NFS4_FHSIZE
)
750 READ_BUF(putfh
->pf_fhlen
);
751 SAVEMEM(putfh
->pf_fhval
, putfh
->pf_fhlen
);
757 nfsd4_decode_read(struct nfsd4_compoundargs
*argp
, struct nfsd4_read
*read
)
761 status
= nfsd4_decode_stateid(argp
, &read
->rd_stateid
);
765 READ64(read
->rd_offset
);
766 READ32(read
->rd_length
);
772 nfsd4_decode_readdir(struct nfsd4_compoundargs
*argp
, struct nfsd4_readdir
*readdir
)
777 READ64(readdir
->rd_cookie
);
778 COPYMEM(readdir
->rd_verf
.data
, sizeof(readdir
->rd_verf
.data
));
779 READ32(readdir
->rd_dircount
); /* just in case you needed a useless field... */
780 READ32(readdir
->rd_maxcount
);
781 if ((status
= nfsd4_decode_bitmap(argp
, readdir
->rd_bmval
)))
788 nfsd4_decode_remove(struct nfsd4_compoundargs
*argp
, struct nfsd4_remove
*remove
)
793 READ32(remove
->rm_namelen
);
794 READ_BUF(remove
->rm_namelen
);
795 SAVEMEM(remove
->rm_name
, remove
->rm_namelen
);
796 if ((status
= check_filename(remove
->rm_name
, remove
->rm_namelen
, nfserr_noent
)))
803 nfsd4_decode_rename(struct nfsd4_compoundargs
*argp
, struct nfsd4_rename
*rename
)
808 READ32(rename
->rn_snamelen
);
809 READ_BUF(rename
->rn_snamelen
+ 4);
810 SAVEMEM(rename
->rn_sname
, rename
->rn_snamelen
);
811 READ32(rename
->rn_tnamelen
);
812 READ_BUF(rename
->rn_tnamelen
);
813 SAVEMEM(rename
->rn_tname
, rename
->rn_tnamelen
);
814 if ((status
= check_filename(rename
->rn_sname
, rename
->rn_snamelen
, nfserr_noent
)))
816 if ((status
= check_filename(rename
->rn_tname
, rename
->rn_tnamelen
, nfserr_inval
)))
823 nfsd4_decode_renew(struct nfsd4_compoundargs
*argp
, clientid_t
*clientid
)
827 READ_BUF(sizeof(clientid_t
));
828 COPYMEM(clientid
, sizeof(clientid_t
));
834 nfsd4_decode_secinfo(struct nfsd4_compoundargs
*argp
,
835 struct nfsd4_secinfo
*secinfo
)
840 READ32(secinfo
->si_namelen
);
841 READ_BUF(secinfo
->si_namelen
);
842 SAVEMEM(secinfo
->si_name
, secinfo
->si_namelen
);
843 status
= check_filename(secinfo
->si_name
, secinfo
->si_namelen
,
851 nfsd4_decode_secinfo_no_name(struct nfsd4_compoundargs
*argp
,
852 struct nfsd4_secinfo_no_name
*sin
)
857 READ32(sin
->sin_style
);
862 nfsd4_decode_setattr(struct nfsd4_compoundargs
*argp
, struct nfsd4_setattr
*setattr
)
866 status
= nfsd4_decode_stateid(argp
, &setattr
->sa_stateid
);
869 return nfsd4_decode_fattr(argp
, setattr
->sa_bmval
, &setattr
->sa_iattr
,
874 nfsd4_decode_setclientid(struct nfsd4_compoundargs
*argp
, struct nfsd4_setclientid
*setclientid
)
879 COPYMEM(setclientid
->se_verf
.data
, 8);
880 READ32(setclientid
->se_namelen
);
882 READ_BUF(setclientid
->se_namelen
+ 8);
883 SAVEMEM(setclientid
->se_name
, setclientid
->se_namelen
);
884 READ32(setclientid
->se_callback_prog
);
885 READ32(setclientid
->se_callback_netid_len
);
887 READ_BUF(setclientid
->se_callback_netid_len
+ 4);
888 SAVEMEM(setclientid
->se_callback_netid_val
, setclientid
->se_callback_netid_len
);
889 READ32(setclientid
->se_callback_addr_len
);
891 READ_BUF(setclientid
->se_callback_addr_len
+ 4);
892 SAVEMEM(setclientid
->se_callback_addr_val
, setclientid
->se_callback_addr_len
);
893 READ32(setclientid
->se_callback_ident
);
899 nfsd4_decode_setclientid_confirm(struct nfsd4_compoundargs
*argp
, struct nfsd4_setclientid_confirm
*scd_c
)
903 READ_BUF(8 + sizeof(nfs4_verifier
));
904 COPYMEM(&scd_c
->sc_clientid
, 8);
905 COPYMEM(&scd_c
->sc_confirm
, sizeof(nfs4_verifier
));
910 /* Also used for NVERIFY */
912 nfsd4_decode_verify(struct nfsd4_compoundargs
*argp
, struct nfsd4_verify
*verify
)
915 struct nfsd4_compoundargs save
= {
918 .rqstp
= argp
->rqstp
,
921 struct iattr ve_iattr
; /* request */
922 struct nfs4_acl
*ve_acl
; /* request */
926 if ((status
= nfsd4_decode_bitmap(argp
, verify
->ve_bmval
)))
929 /* For convenience's sake, we compare raw xdr'd attributes in
930 * nfsd4_proc_verify; however we still decode here just to return
931 * correct error in case of bad xdr. */
933 status
= nfsd4_decode_fattr(ve_bmval
, &ve_iattr
, &ve_acl
);
934 if (status
== nfserr_inval
) {
935 status
= nfserrno(status
);
940 READ32(verify
->ve_attrlen
);
941 READ_BUF(verify
->ve_attrlen
);
942 SAVEMEM(verify
->ve_attrval
, verify
->ve_attrlen
);
948 nfsd4_decode_write(struct nfsd4_compoundargs
*argp
, struct nfsd4_write
*write
)
955 status
= nfsd4_decode_stateid(argp
, &write
->wr_stateid
);
959 READ64(write
->wr_offset
);
960 READ32(write
->wr_stable_how
);
961 if (write
->wr_stable_how
> 2)
963 READ32(write
->wr_buflen
);
965 /* Sorry .. no magic macros for this.. *
966 * READ_BUF(write->wr_buflen);
967 * SAVEMEM(write->wr_buf, write->wr_buflen);
969 avail
= (char*)argp
->end
- (char*)argp
->p
;
970 if (avail
+ argp
->pagelen
< write
->wr_buflen
) {
971 dprintk("NFSD: xdr error (%s:%d)\n",
975 argp
->rqstp
->rq_vec
[0].iov_base
= p
;
976 argp
->rqstp
->rq_vec
[0].iov_len
= avail
;
978 len
= write
->wr_buflen
;
979 while (len
> argp
->rqstp
->rq_vec
[v
].iov_len
) {
980 len
-= argp
->rqstp
->rq_vec
[v
].iov_len
;
982 argp
->rqstp
->rq_vec
[v
].iov_base
= page_address(argp
->pagelist
[0]);
984 if (argp
->pagelen
>= PAGE_SIZE
) {
985 argp
->rqstp
->rq_vec
[v
].iov_len
= PAGE_SIZE
;
986 argp
->pagelen
-= PAGE_SIZE
;
988 argp
->rqstp
->rq_vec
[v
].iov_len
= argp
->pagelen
;
989 argp
->pagelen
-= len
;
992 argp
->end
= (__be32
*) (argp
->rqstp
->rq_vec
[v
].iov_base
+ argp
->rqstp
->rq_vec
[v
].iov_len
);
993 argp
->p
= (__be32
*) (argp
->rqstp
->rq_vec
[v
].iov_base
+ (XDR_QUADLEN(len
) << 2));
994 argp
->rqstp
->rq_vec
[v
].iov_len
= len
;
995 write
->wr_vlen
= v
+1;
1001 nfsd4_decode_release_lockowner(struct nfsd4_compoundargs
*argp
, struct nfsd4_release_lockowner
*rlockowner
)
1006 COPYMEM(&rlockowner
->rl_clientid
, sizeof(clientid_t
));
1007 READ32(rlockowner
->rl_owner
.len
);
1008 READ_BUF(rlockowner
->rl_owner
.len
);
1009 READMEM(rlockowner
->rl_owner
.data
, rlockowner
->rl_owner
.len
);
1011 if (argp
->minorversion
&& !zero_clientid(&rlockowner
->rl_clientid
))
1012 return nfserr_inval
;
1017 nfsd4_decode_exchange_id(struct nfsd4_compoundargs
*argp
,
1018 struct nfsd4_exchange_id
*exid
)
1023 READ_BUF(NFS4_VERIFIER_SIZE
);
1024 COPYMEM(exid
->verifier
.data
, NFS4_VERIFIER_SIZE
);
1027 READ32(exid
->clname
.len
);
1029 READ_BUF(exid
->clname
.len
);
1030 SAVEMEM(exid
->clname
.data
, exid
->clname
.len
);
1033 READ32(exid
->flags
);
1035 /* Ignore state_protect4_a */
1037 READ32(exid
->spa_how
);
1038 switch (exid
->spa_how
) {
1042 /* spo_must_enforce */
1045 READ_BUF(dummy
* 4);
1048 /* spo_must_allow */
1051 READ_BUF(dummy
* 4);
1058 READ_BUF(dummy
* 4);
1063 READ_BUF(dummy
* 4);
1066 /* ssp_hash_algs<> */
1073 p
+= XDR_QUADLEN(dummy
);
1076 /* ssp_encr_algs<> */
1083 p
+= XDR_QUADLEN(dummy
);
1086 /* ssp_window and ssp_num_gss_handles */
1095 /* Ignore Implementation ID */
1096 READ_BUF(4); /* nfs_impl_id4 array length */
1107 p
+= XDR_QUADLEN(dummy
);
1113 p
+= XDR_QUADLEN(dummy
);
1123 nfsd4_decode_create_session(struct nfsd4_compoundargs
*argp
,
1124 struct nfsd4_create_session
*sess
)
1134 COPYMEM(&sess
->clientid
, 8);
1135 READ32(sess
->seqid
);
1136 READ32(sess
->flags
);
1138 /* Fore channel attrs */
1140 READ32(dummy
); /* headerpadsz is always 0 */
1141 READ32(sess
->fore_channel
.maxreq_sz
);
1142 READ32(sess
->fore_channel
.maxresp_sz
);
1143 READ32(sess
->fore_channel
.maxresp_cached
);
1144 READ32(sess
->fore_channel
.maxops
);
1145 READ32(sess
->fore_channel
.maxreqs
);
1146 READ32(sess
->fore_channel
.nr_rdma_attrs
);
1147 if (sess
->fore_channel
.nr_rdma_attrs
== 1) {
1149 READ32(sess
->fore_channel
.rdma_attrs
);
1150 } else if (sess
->fore_channel
.nr_rdma_attrs
> 1) {
1151 dprintk("Too many fore channel attr bitmaps!\n");
1155 /* Back channel attrs */
1157 READ32(dummy
); /* headerpadsz is always 0 */
1158 READ32(sess
->back_channel
.maxreq_sz
);
1159 READ32(sess
->back_channel
.maxresp_sz
);
1160 READ32(sess
->back_channel
.maxresp_cached
);
1161 READ32(sess
->back_channel
.maxops
);
1162 READ32(sess
->back_channel
.maxreqs
);
1163 READ32(sess
->back_channel
.nr_rdma_attrs
);
1164 if (sess
->back_channel
.nr_rdma_attrs
== 1) {
1166 READ32(sess
->back_channel
.rdma_attrs
);
1167 } else if (sess
->back_channel
.nr_rdma_attrs
> 1) {
1168 dprintk("Too many back channel attr bitmaps!\n");
1173 READ32(sess
->callback_prog
);
1175 /* callback_sec_params4 */
1176 READ32(nr_secflavs
);
1177 for (i
= 0; i
< nr_secflavs
; ++i
) {
1182 /* Nothing to read */
1192 SAVEMEM(machine_name
, dummy
);
1202 READ_BUF(dummy
* 4);
1203 for (i
= 0; i
< dummy
; ++i
)
1207 dprintk("RPC_AUTH_GSS callback secflavor "
1208 "not supported!\n");
1212 /* gcbp_handle_from_server */
1215 p
+= XDR_QUADLEN(dummy
);
1216 /* gcbp_handle_from_client */
1220 p
+= XDR_QUADLEN(dummy
);
1223 dprintk("Illegal callback secflavor\n");
1224 return nfserr_inval
;
1231 nfsd4_decode_destroy_session(struct nfsd4_compoundargs
*argp
,
1232 struct nfsd4_destroy_session
*destroy_session
)
1235 READ_BUF(NFS4_MAX_SESSIONID_LEN
);
1236 COPYMEM(destroy_session
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
1242 nfsd4_decode_sequence(struct nfsd4_compoundargs
*argp
,
1243 struct nfsd4_sequence
*seq
)
1247 READ_BUF(NFS4_MAX_SESSIONID_LEN
+ 16);
1248 COPYMEM(seq
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
1250 READ32(seq
->slotid
);
1251 READ32(seq
->maxslots
);
1252 READ32(seq
->cachethis
);
1257 static __be32
nfsd4_decode_reclaim_complete(struct nfsd4_compoundargs
*argp
, struct nfsd4_reclaim_complete
*rc
)
1262 READ32(rc
->rca_one_fs
);
1268 nfsd4_decode_noop(struct nfsd4_compoundargs
*argp
, void *p
)
1274 nfsd4_decode_notsupp(struct nfsd4_compoundargs
*argp
, void *p
)
1276 return nfserr_notsupp
;
1279 typedef __be32(*nfsd4_dec
)(struct nfsd4_compoundargs
*argp
, void *);
1281 static nfsd4_dec nfsd4_dec_ops
[] = {
1282 [OP_ACCESS
] = (nfsd4_dec
)nfsd4_decode_access
,
1283 [OP_CLOSE
] = (nfsd4_dec
)nfsd4_decode_close
,
1284 [OP_COMMIT
] = (nfsd4_dec
)nfsd4_decode_commit
,
1285 [OP_CREATE
] = (nfsd4_dec
)nfsd4_decode_create
,
1286 [OP_DELEGPURGE
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1287 [OP_DELEGRETURN
] = (nfsd4_dec
)nfsd4_decode_delegreturn
,
1288 [OP_GETATTR
] = (nfsd4_dec
)nfsd4_decode_getattr
,
1289 [OP_GETFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1290 [OP_LINK
] = (nfsd4_dec
)nfsd4_decode_link
,
1291 [OP_LOCK
] = (nfsd4_dec
)nfsd4_decode_lock
,
1292 [OP_LOCKT
] = (nfsd4_dec
)nfsd4_decode_lockt
,
1293 [OP_LOCKU
] = (nfsd4_dec
)nfsd4_decode_locku
,
1294 [OP_LOOKUP
] = (nfsd4_dec
)nfsd4_decode_lookup
,
1295 [OP_LOOKUPP
] = (nfsd4_dec
)nfsd4_decode_noop
,
1296 [OP_NVERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
1297 [OP_OPEN
] = (nfsd4_dec
)nfsd4_decode_open
,
1298 [OP_OPENATTR
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1299 [OP_OPEN_CONFIRM
] = (nfsd4_dec
)nfsd4_decode_open_confirm
,
1300 [OP_OPEN_DOWNGRADE
] = (nfsd4_dec
)nfsd4_decode_open_downgrade
,
1301 [OP_PUTFH
] = (nfsd4_dec
)nfsd4_decode_putfh
,
1302 [OP_PUTPUBFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1303 [OP_PUTROOTFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1304 [OP_READ
] = (nfsd4_dec
)nfsd4_decode_read
,
1305 [OP_READDIR
] = (nfsd4_dec
)nfsd4_decode_readdir
,
1306 [OP_READLINK
] = (nfsd4_dec
)nfsd4_decode_noop
,
1307 [OP_REMOVE
] = (nfsd4_dec
)nfsd4_decode_remove
,
1308 [OP_RENAME
] = (nfsd4_dec
)nfsd4_decode_rename
,
1309 [OP_RENEW
] = (nfsd4_dec
)nfsd4_decode_renew
,
1310 [OP_RESTOREFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1311 [OP_SAVEFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1312 [OP_SECINFO
] = (nfsd4_dec
)nfsd4_decode_secinfo
,
1313 [OP_SETATTR
] = (nfsd4_dec
)nfsd4_decode_setattr
,
1314 [OP_SETCLIENTID
] = (nfsd4_dec
)nfsd4_decode_setclientid
,
1315 [OP_SETCLIENTID_CONFIRM
] = (nfsd4_dec
)nfsd4_decode_setclientid_confirm
,
1316 [OP_VERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
1317 [OP_WRITE
] = (nfsd4_dec
)nfsd4_decode_write
,
1318 [OP_RELEASE_LOCKOWNER
] = (nfsd4_dec
)nfsd4_decode_release_lockowner
,
1321 static nfsd4_dec nfsd41_dec_ops
[] = {
1322 [OP_ACCESS
] = (nfsd4_dec
)nfsd4_decode_access
,
1323 [OP_CLOSE
] = (nfsd4_dec
)nfsd4_decode_close
,
1324 [OP_COMMIT
] = (nfsd4_dec
)nfsd4_decode_commit
,
1325 [OP_CREATE
] = (nfsd4_dec
)nfsd4_decode_create
,
1326 [OP_DELEGPURGE
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1327 [OP_DELEGRETURN
] = (nfsd4_dec
)nfsd4_decode_delegreturn
,
1328 [OP_GETATTR
] = (nfsd4_dec
)nfsd4_decode_getattr
,
1329 [OP_GETFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1330 [OP_LINK
] = (nfsd4_dec
)nfsd4_decode_link
,
1331 [OP_LOCK
] = (nfsd4_dec
)nfsd4_decode_lock
,
1332 [OP_LOCKT
] = (nfsd4_dec
)nfsd4_decode_lockt
,
1333 [OP_LOCKU
] = (nfsd4_dec
)nfsd4_decode_locku
,
1334 [OP_LOOKUP
] = (nfsd4_dec
)nfsd4_decode_lookup
,
1335 [OP_LOOKUPP
] = (nfsd4_dec
)nfsd4_decode_noop
,
1336 [OP_NVERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
1337 [OP_OPEN
] = (nfsd4_dec
)nfsd4_decode_open
,
1338 [OP_OPENATTR
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1339 [OP_OPEN_CONFIRM
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1340 [OP_OPEN_DOWNGRADE
] = (nfsd4_dec
)nfsd4_decode_open_downgrade
,
1341 [OP_PUTFH
] = (nfsd4_dec
)nfsd4_decode_putfh
,
1342 [OP_PUTPUBFH
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1343 [OP_PUTROOTFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1344 [OP_READ
] = (nfsd4_dec
)nfsd4_decode_read
,
1345 [OP_READDIR
] = (nfsd4_dec
)nfsd4_decode_readdir
,
1346 [OP_READLINK
] = (nfsd4_dec
)nfsd4_decode_noop
,
1347 [OP_REMOVE
] = (nfsd4_dec
)nfsd4_decode_remove
,
1348 [OP_RENAME
] = (nfsd4_dec
)nfsd4_decode_rename
,
1349 [OP_RENEW
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1350 [OP_RESTOREFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1351 [OP_SAVEFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1352 [OP_SECINFO
] = (nfsd4_dec
)nfsd4_decode_secinfo
,
1353 [OP_SETATTR
] = (nfsd4_dec
)nfsd4_decode_setattr
,
1354 [OP_SETCLIENTID
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1355 [OP_SETCLIENTID_CONFIRM
]= (nfsd4_dec
)nfsd4_decode_notsupp
,
1356 [OP_VERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
1357 [OP_WRITE
] = (nfsd4_dec
)nfsd4_decode_write
,
1358 [OP_RELEASE_LOCKOWNER
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1360 /* new operations for NFSv4.1 */
1361 [OP_BACKCHANNEL_CTL
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1362 [OP_BIND_CONN_TO_SESSION
]= (nfsd4_dec
)nfsd4_decode_notsupp
,
1363 [OP_EXCHANGE_ID
] = (nfsd4_dec
)nfsd4_decode_exchange_id
,
1364 [OP_CREATE_SESSION
] = (nfsd4_dec
)nfsd4_decode_create_session
,
1365 [OP_DESTROY_SESSION
] = (nfsd4_dec
)nfsd4_decode_destroy_session
,
1366 [OP_FREE_STATEID
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1367 [OP_GET_DIR_DELEGATION
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1368 [OP_GETDEVICEINFO
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1369 [OP_GETDEVICELIST
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1370 [OP_LAYOUTCOMMIT
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1371 [OP_LAYOUTGET
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1372 [OP_LAYOUTRETURN
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1373 [OP_SECINFO_NO_NAME
] = (nfsd4_dec
)nfsd4_decode_secinfo_no_name
,
1374 [OP_SEQUENCE
] = (nfsd4_dec
)nfsd4_decode_sequence
,
1375 [OP_SET_SSV
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1376 [OP_TEST_STATEID
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1377 [OP_WANT_DELEGATION
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1378 [OP_DESTROY_CLIENTID
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1379 [OP_RECLAIM_COMPLETE
] = (nfsd4_dec
)nfsd4_decode_reclaim_complete
,
1382 struct nfsd4_minorversion_ops
{
1383 nfsd4_dec
*decoders
;
1387 static struct nfsd4_minorversion_ops nfsd4_minorversion
[] = {
1388 [0] = { nfsd4_dec_ops
, ARRAY_SIZE(nfsd4_dec_ops
) },
1389 [1] = { nfsd41_dec_ops
, ARRAY_SIZE(nfsd41_dec_ops
) },
1393 nfsd4_decode_compound(struct nfsd4_compoundargs
*argp
)
1396 struct nfsd4_op
*op
;
1397 struct nfsd4_minorversion_ops
*ops
;
1401 * XXX: According to spec, we should check the tag
1402 * for UTF-8 compliance. I'm postponing this for
1403 * now because it seems that some clients do use
1407 READ32(argp
->taglen
);
1408 READ_BUF(argp
->taglen
+ 8);
1409 SAVEMEM(argp
->tag
, argp
->taglen
);
1410 READ32(argp
->minorversion
);
1411 READ32(argp
->opcnt
);
1413 if (argp
->taglen
> NFSD4_MAX_TAGLEN
)
1415 if (argp
->opcnt
> 100)
1418 if (argp
->opcnt
> ARRAY_SIZE(argp
->iops
)) {
1419 argp
->ops
= kmalloc(argp
->opcnt
* sizeof(*argp
->ops
), GFP_KERNEL
);
1421 argp
->ops
= argp
->iops
;
1422 dprintk("nfsd: couldn't allocate room for COMPOUND\n");
1427 if (argp
->minorversion
>= ARRAY_SIZE(nfsd4_minorversion
))
1430 ops
= &nfsd4_minorversion
[argp
->minorversion
];
1431 for (i
= 0; i
< argp
->opcnt
; i
++) {
1436 * We can't use READ_BUF() here because we need to handle
1437 * a missing opcode as an OP_WRITE + 1. So we need to check
1438 * to see if we're truly at the end of our buffer or if there
1439 * is another page we need to flip to.
1442 if (argp
->p
== argp
->end
) {
1443 if (argp
->pagelen
< 4) {
1444 /* There isn't an opcode still on the wire */
1445 op
->opnum
= OP_WRITE
+ 1;
1446 op
->status
= nfserr_bad_xdr
;
1452 * False alarm. We just hit a page boundary, but there
1453 * is still data available. Move pointer across page
1454 * boundary. *snip from READ_BUF*
1456 argp
->p
= page_address(argp
->pagelist
[0]);
1458 if (argp
->pagelen
< PAGE_SIZE
) {
1459 argp
->end
= argp
->p
+ (argp
->pagelen
>>2);
1462 argp
->end
= argp
->p
+ (PAGE_SIZE
>>2);
1463 argp
->pagelen
-= PAGE_SIZE
;
1466 op
->opnum
= ntohl(*argp
->p
++);
1468 if (op
->opnum
>= FIRST_NFS4_OP
&& op
->opnum
<= LAST_NFS4_OP
)
1469 op
->status
= ops
->decoders
[op
->opnum
](argp
, &op
->u
);
1471 op
->opnum
= OP_ILLEGAL
;
1472 op
->status
= nfserr_op_illegal
;
1484 #define WRITE32(n) *p++ = htonl(n)
1485 #define WRITE64(n) do { \
1486 *p++ = htonl((u32)((n) >> 32)); \
1487 *p++ = htonl((u32)(n)); \
1489 #define WRITEMEM(ptr,nbytes) do { if (nbytes > 0) { \
1490 *(p + XDR_QUADLEN(nbytes) -1) = 0; \
1491 memcpy(p, ptr, nbytes); \
1492 p += XDR_QUADLEN(nbytes); \
1495 static void write32(__be32
**p
, u32 n
)
1500 static void write64(__be32
**p
, u64 n
)
1502 write32(p
, (u32
)(n
>> 32));
1506 static void write_change(__be32
**p
, struct kstat
*stat
, struct inode
*inode
)
1508 if (IS_I_VERSION(inode
)) {
1509 write64(p
, inode
->i_version
);
1511 write32(p
, stat
->ctime
.tv_sec
);
1512 write32(p
, stat
->ctime
.tv_nsec
);
1516 static void write_cinfo(__be32
**p
, struct nfsd4_change_info
*c
)
1518 write32(p
, c
->atomic
);
1519 if (c
->change_supported
) {
1520 write64(p
, c
->before_change
);
1521 write64(p
, c
->after_change
);
1523 write32(p
, c
->before_ctime_sec
);
1524 write32(p
, c
->before_ctime_nsec
);
1525 write32(p
, c
->after_ctime_sec
);
1526 write32(p
, c
->after_ctime_nsec
);
1530 #define RESERVE_SPACE(nbytes) do { \
1532 BUG_ON(p + XDR_QUADLEN(nbytes) > resp->end); \
1534 #define ADJUST_ARGS() resp->p = p
1537 * Header routine to setup seqid operation replay cache
1539 #define ENCODE_SEQID_OP_HEAD \
1545 * Routine for encoding the result of a "seqid-mutating" NFSv4 operation. This
1546 * is where sequence id's are incremented, and the replay cache is filled.
1547 * Note that we increment sequence id's here, at the last moment, so we're sure
1548 * we know whether the error to be returned is a sequence id mutating error.
1551 #define ENCODE_SEQID_OP_TAIL(stateowner) do { \
1552 if (seqid_mutating_err(nfserr) && stateowner) { \
1553 stateowner->so_seqid++; \
1554 stateowner->so_replay.rp_status = nfserr; \
1555 stateowner->so_replay.rp_buflen = \
1556 (((char *)(resp)->p - (char *)save)); \
1557 memcpy(stateowner->so_replay.rp_buf, save, \
1558 stateowner->so_replay.rp_buflen); \
1561 /* Encode as an array of strings the string given with components
1564 static __be32
nfsd4_encode_components(char sep
, char *components
,
1565 __be32
**pp
, int *buflen
)
1569 int strlen
, count
=0;
1572 dprintk("nfsd4_encode_components(%s)\n", components
);
1573 if ((*buflen
-= 4) < 0)
1574 return nfserr_resource
;
1575 WRITE32(0); /* We will fill this in with @count later */
1576 end
= str
= components
;
1578 for (; *end
&& (*end
!= sep
); end
++)
1579 ; /* Point to end of component */
1582 if ((*buflen
-= ((XDR_QUADLEN(strlen
) << 2) + 4)) < 0)
1583 return nfserr_resource
;
1585 WRITEMEM(str
, strlen
);
1599 * encode a location element of a fs_locations structure
1601 static __be32
nfsd4_encode_fs_location4(struct nfsd4_fs_location
*location
,
1602 __be32
**pp
, int *buflen
)
1607 status
= nfsd4_encode_components(':', location
->hosts
, &p
, buflen
);
1610 status
= nfsd4_encode_components('/', location
->path
, &p
, buflen
);
1618 * Return the path to an export point in the pseudo filesystem namespace
1619 * Returned string is safe to use as long as the caller holds a reference
1622 static char *nfsd4_path(struct svc_rqst
*rqstp
, struct svc_export
*exp
, __be32
*stat
)
1624 struct svc_fh tmp_fh
;
1625 char *path
= NULL
, *rootpath
;
1628 fh_init(&tmp_fh
, NFS4_FHSIZE
);
1629 *stat
= exp_pseudoroot(rqstp
, &tmp_fh
);
1632 rootpath
= tmp_fh
.fh_export
->ex_pathname
;
1634 path
= exp
->ex_pathname
;
1636 rootlen
= strlen(rootpath
);
1637 if (strncmp(path
, rootpath
, rootlen
)) {
1638 dprintk("nfsd: fs_locations failed;"
1639 "%s is not contained in %s\n", path
, rootpath
);
1640 *stat
= nfserr_notsupp
;
1651 * encode a fs_locations structure
1653 static __be32
nfsd4_encode_fs_locations(struct svc_rqst
*rqstp
,
1654 struct svc_export
*exp
,
1655 __be32
**pp
, int *buflen
)
1660 struct nfsd4_fs_locations
*fslocs
= &exp
->ex_fslocs
;
1661 char *root
= nfsd4_path(rqstp
, exp
, &status
);
1665 status
= nfsd4_encode_components('/', root
, &p
, buflen
);
1668 if ((*buflen
-= 4) < 0)
1669 return nfserr_resource
;
1670 WRITE32(fslocs
->locations_count
);
1671 for (i
=0; i
<fslocs
->locations_count
; i
++) {
1672 status
= nfsd4_encode_fs_location4(&fslocs
->locations
[i
],
1681 static u32 nfs4_ftypes
[16] = {
1682 NF4BAD
, NF4FIFO
, NF4CHR
, NF4BAD
,
1683 NF4DIR
, NF4BAD
, NF4BLK
, NF4BAD
,
1684 NF4REG
, NF4BAD
, NF4LNK
, NF4BAD
,
1685 NF4SOCK
, NF4BAD
, NF4LNK
, NF4BAD
,
1689 nfsd4_encode_name(struct svc_rqst
*rqstp
, int whotype
, uid_t id
, int group
,
1690 __be32
**p
, int *buflen
)
1694 if (*buflen
< (XDR_QUADLEN(IDMAP_NAMESZ
) << 2) + 4)
1695 return nfserr_resource
;
1696 if (whotype
!= NFS4_ACL_WHO_NAMED
)
1697 status
= nfs4_acl_write_who(whotype
, (u8
*)(*p
+ 1));
1699 status
= nfsd_map_gid_to_name(rqstp
, id
, (u8
*)(*p
+ 1));
1701 status
= nfsd_map_uid_to_name(rqstp
, id
, (u8
*)(*p
+ 1));
1703 return nfserrno(status
);
1704 *p
= xdr_encode_opaque(*p
, NULL
, status
);
1705 *buflen
-= (XDR_QUADLEN(status
) << 2) + 4;
1706 BUG_ON(*buflen
< 0);
1710 static inline __be32
1711 nfsd4_encode_user(struct svc_rqst
*rqstp
, uid_t uid
, __be32
**p
, int *buflen
)
1713 return nfsd4_encode_name(rqstp
, NFS4_ACL_WHO_NAMED
, uid
, 0, p
, buflen
);
1716 static inline __be32
1717 nfsd4_encode_group(struct svc_rqst
*rqstp
, uid_t gid
, __be32
**p
, int *buflen
)
1719 return nfsd4_encode_name(rqstp
, NFS4_ACL_WHO_NAMED
, gid
, 1, p
, buflen
);
1722 static inline __be32
1723 nfsd4_encode_aclname(struct svc_rqst
*rqstp
, int whotype
, uid_t id
, int group
,
1724 __be32
**p
, int *buflen
)
1726 return nfsd4_encode_name(rqstp
, whotype
, id
, group
, p
, buflen
);
1729 #define WORD0_ABSENT_FS_ATTRS (FATTR4_WORD0_FS_LOCATIONS | FATTR4_WORD0_FSID | \
1730 FATTR4_WORD0_RDATTR_ERROR)
1731 #define WORD1_ABSENT_FS_ATTRS FATTR4_WORD1_MOUNTED_ON_FILEID
1733 static __be32
fattr_handle_absent_fs(u32
*bmval0
, u32
*bmval1
, u32
*rdattr_err
)
1735 /* As per referral draft: */
1736 if (*bmval0
& ~WORD0_ABSENT_FS_ATTRS
||
1737 *bmval1
& ~WORD1_ABSENT_FS_ATTRS
) {
1738 if (*bmval0
& FATTR4_WORD0_RDATTR_ERROR
||
1739 *bmval0
& FATTR4_WORD0_FS_LOCATIONS
)
1740 *rdattr_err
= NFSERR_MOVED
;
1742 return nfserr_moved
;
1744 *bmval0
&= WORD0_ABSENT_FS_ATTRS
;
1745 *bmval1
&= WORD1_ABSENT_FS_ATTRS
;
1750 * Note: @fhp can be NULL; in this case, we might have to compose the filehandle
1753 * @countp is the buffer size in _words_; upon successful return this becomes
1754 * replaced with the number of words written.
1757 nfsd4_encode_fattr(struct svc_fh
*fhp
, struct svc_export
*exp
,
1758 struct dentry
*dentry
, __be32
*buffer
, int *countp
, u32
*bmval
,
1759 struct svc_rqst
*rqstp
, int ignore_crossmnt
)
1761 u32 bmval0
= bmval
[0];
1762 u32 bmval1
= bmval
[1];
1763 u32 bmval2
= bmval
[2];
1765 struct svc_fh tempfh
;
1766 struct kstatfs statfs
;
1767 int buflen
= *countp
<< 2;
1776 struct nfs4_acl
*acl
= NULL
;
1777 struct nfsd4_compoundres
*resp
= rqstp
->rq_resp
;
1778 u32 minorversion
= resp
->cstate
.minorversion
;
1779 struct path path
= {
1780 .mnt
= exp
->ex_path
.mnt
,
1784 BUG_ON(bmval1
& NFSD_WRITEONLY_ATTRS_WORD1
);
1785 BUG_ON(bmval0
& ~nfsd_suppattrs0(minorversion
));
1786 BUG_ON(bmval1
& ~nfsd_suppattrs1(minorversion
));
1787 BUG_ON(bmval2
& ~nfsd_suppattrs2(minorversion
));
1789 if (exp
->ex_fslocs
.migrated
) {
1791 status
= fattr_handle_absent_fs(&bmval0
, &bmval1
, &rdattr_err
);
1796 err
= vfs_getattr(exp
->ex_path
.mnt
, dentry
, &stat
);
1799 if ((bmval0
& (FATTR4_WORD0_FILES_FREE
| FATTR4_WORD0_FILES_TOTAL
|
1800 FATTR4_WORD0_MAXNAME
)) ||
1801 (bmval1
& (FATTR4_WORD1_SPACE_AVAIL
| FATTR4_WORD1_SPACE_FREE
|
1802 FATTR4_WORD1_SPACE_TOTAL
))) {
1803 err
= vfs_statfs(&path
, &statfs
);
1807 if ((bmval0
& (FATTR4_WORD0_FILEHANDLE
| FATTR4_WORD0_FSID
)) && !fhp
) {
1808 fh_init(&tempfh
, NFS4_FHSIZE
);
1809 status
= fh_compose(&tempfh
, exp
, dentry
, NULL
);
1814 if (bmval0
& (FATTR4_WORD0_ACL
| FATTR4_WORD0_ACLSUPPORT
1815 | FATTR4_WORD0_SUPPORTED_ATTRS
)) {
1816 err
= nfsd4_get_nfs4_acl(rqstp
, dentry
, &acl
);
1817 aclsupport
= (err
== 0);
1818 if (bmval0
& FATTR4_WORD0_ACL
) {
1819 if (err
== -EOPNOTSUPP
)
1820 bmval0
&= ~FATTR4_WORD0_ACL
;
1821 else if (err
== -EINVAL
) {
1822 status
= nfserr_attrnotsupp
;
1824 } else if (err
!= 0)
1830 if ((buflen
-= 16) < 0)
1836 } else if (bmval1
) {
1837 if ((buflen
-= 12) < 0)
1843 if ((buflen
-= 8) < 0)
1848 attrlenp
= p
++; /* to be backfilled later */
1850 if (bmval0
& FATTR4_WORD0_SUPPORTED_ATTRS
) {
1851 u32 word0
= nfsd_suppattrs0(minorversion
);
1852 u32 word1
= nfsd_suppattrs1(minorversion
);
1853 u32 word2
= nfsd_suppattrs2(minorversion
);
1856 word0
&= ~FATTR4_WORD0_ACL
;
1858 if ((buflen
-= 12) < 0)
1864 if ((buflen
-= 16) < 0)
1872 if (bmval0
& FATTR4_WORD0_TYPE
) {
1873 if ((buflen
-= 4) < 0)
1875 dummy
= nfs4_ftypes
[(stat
.mode
& S_IFMT
) >> 12];
1876 if (dummy
== NF4BAD
)
1877 goto out_serverfault
;
1880 if (bmval0
& FATTR4_WORD0_FH_EXPIRE_TYPE
) {
1881 if ((buflen
-= 4) < 0)
1883 if (exp
->ex_flags
& NFSEXP_NOSUBTREECHECK
)
1884 WRITE32(NFS4_FH_PERSISTENT
);
1886 WRITE32(NFS4_FH_PERSISTENT
|NFS4_FH_VOL_RENAME
);
1888 if (bmval0
& FATTR4_WORD0_CHANGE
) {
1889 if ((buflen
-= 8) < 0)
1891 write_change(&p
, &stat
, dentry
->d_inode
);
1893 if (bmval0
& FATTR4_WORD0_SIZE
) {
1894 if ((buflen
-= 8) < 0)
1898 if (bmval0
& FATTR4_WORD0_LINK_SUPPORT
) {
1899 if ((buflen
-= 4) < 0)
1903 if (bmval0
& FATTR4_WORD0_SYMLINK_SUPPORT
) {
1904 if ((buflen
-= 4) < 0)
1908 if (bmval0
& FATTR4_WORD0_NAMED_ATTR
) {
1909 if ((buflen
-= 4) < 0)
1913 if (bmval0
& FATTR4_WORD0_FSID
) {
1914 if ((buflen
-= 16) < 0)
1916 if (exp
->ex_fslocs
.migrated
) {
1917 WRITE64(NFS4_REFERRAL_FSID_MAJOR
);
1918 WRITE64(NFS4_REFERRAL_FSID_MINOR
);
1919 } else switch(fsid_source(fhp
)) {
1920 case FSIDSOURCE_FSID
:
1921 WRITE64((u64
)exp
->ex_fsid
);
1924 case FSIDSOURCE_DEV
:
1926 WRITE32(MAJOR(stat
.dev
));
1928 WRITE32(MINOR(stat
.dev
));
1930 case FSIDSOURCE_UUID
:
1931 WRITEMEM(exp
->ex_uuid
, 16);
1935 if (bmval0
& FATTR4_WORD0_UNIQUE_HANDLES
) {
1936 if ((buflen
-= 4) < 0)
1940 if (bmval0
& FATTR4_WORD0_LEASE_TIME
) {
1941 if ((buflen
-= 4) < 0)
1943 WRITE32(nfsd4_lease
);
1945 if (bmval0
& FATTR4_WORD0_RDATTR_ERROR
) {
1946 if ((buflen
-= 4) < 0)
1948 WRITE32(rdattr_err
);
1950 if (bmval0
& FATTR4_WORD0_ACL
) {
1951 struct nfs4_ace
*ace
;
1954 if ((buflen
-= 4) < 0)
1960 if ((buflen
-= 4) < 0)
1962 WRITE32(acl
->naces
);
1964 for (ace
= acl
->aces
; ace
< acl
->aces
+ acl
->naces
; ace
++) {
1965 if ((buflen
-= 4*3) < 0)
1969 WRITE32(ace
->access_mask
& NFS4_ACE_MASK_ALL
);
1970 status
= nfsd4_encode_aclname(rqstp
, ace
->whotype
,
1971 ace
->who
, ace
->flag
& NFS4_ACE_IDENTIFIER_GROUP
,
1973 if (status
== nfserr_resource
)
1980 if (bmval0
& FATTR4_WORD0_ACLSUPPORT
) {
1981 if ((buflen
-= 4) < 0)
1983 WRITE32(aclsupport
?
1984 ACL4_SUPPORT_ALLOW_ACL
|ACL4_SUPPORT_DENY_ACL
: 0);
1986 if (bmval0
& FATTR4_WORD0_CANSETTIME
) {
1987 if ((buflen
-= 4) < 0)
1991 if (bmval0
& FATTR4_WORD0_CASE_INSENSITIVE
) {
1992 if ((buflen
-= 4) < 0)
1996 if (bmval0
& FATTR4_WORD0_CASE_PRESERVING
) {
1997 if ((buflen
-= 4) < 0)
2001 if (bmval0
& FATTR4_WORD0_CHOWN_RESTRICTED
) {
2002 if ((buflen
-= 4) < 0)
2006 if (bmval0
& FATTR4_WORD0_FILEHANDLE
) {
2007 buflen
-= (XDR_QUADLEN(fhp
->fh_handle
.fh_size
) << 2) + 4;
2010 WRITE32(fhp
->fh_handle
.fh_size
);
2011 WRITEMEM(&fhp
->fh_handle
.fh_base
, fhp
->fh_handle
.fh_size
);
2013 if (bmval0
& FATTR4_WORD0_FILEID
) {
2014 if ((buflen
-= 8) < 0)
2018 if (bmval0
& FATTR4_WORD0_FILES_AVAIL
) {
2019 if ((buflen
-= 8) < 0)
2021 WRITE64((u64
) statfs
.f_ffree
);
2023 if (bmval0
& FATTR4_WORD0_FILES_FREE
) {
2024 if ((buflen
-= 8) < 0)
2026 WRITE64((u64
) statfs
.f_ffree
);
2028 if (bmval0
& FATTR4_WORD0_FILES_TOTAL
) {
2029 if ((buflen
-= 8) < 0)
2031 WRITE64((u64
) statfs
.f_files
);
2033 if (bmval0
& FATTR4_WORD0_FS_LOCATIONS
) {
2034 status
= nfsd4_encode_fs_locations(rqstp
, exp
, &p
, &buflen
);
2035 if (status
== nfserr_resource
)
2040 if (bmval0
& FATTR4_WORD0_HOMOGENEOUS
) {
2041 if ((buflen
-= 4) < 0)
2045 if (bmval0
& FATTR4_WORD0_MAXFILESIZE
) {
2046 if ((buflen
-= 8) < 0)
2050 if (bmval0
& FATTR4_WORD0_MAXLINK
) {
2051 if ((buflen
-= 4) < 0)
2055 if (bmval0
& FATTR4_WORD0_MAXNAME
) {
2056 if ((buflen
-= 4) < 0)
2058 WRITE32(statfs
.f_namelen
);
2060 if (bmval0
& FATTR4_WORD0_MAXREAD
) {
2061 if ((buflen
-= 8) < 0)
2063 WRITE64((u64
) svc_max_payload(rqstp
));
2065 if (bmval0
& FATTR4_WORD0_MAXWRITE
) {
2066 if ((buflen
-= 8) < 0)
2068 WRITE64((u64
) svc_max_payload(rqstp
));
2070 if (bmval1
& FATTR4_WORD1_MODE
) {
2071 if ((buflen
-= 4) < 0)
2073 WRITE32(stat
.mode
& S_IALLUGO
);
2075 if (bmval1
& FATTR4_WORD1_NO_TRUNC
) {
2076 if ((buflen
-= 4) < 0)
2080 if (bmval1
& FATTR4_WORD1_NUMLINKS
) {
2081 if ((buflen
-= 4) < 0)
2083 WRITE32(stat
.nlink
);
2085 if (bmval1
& FATTR4_WORD1_OWNER
) {
2086 status
= nfsd4_encode_user(rqstp
, stat
.uid
, &p
, &buflen
);
2087 if (status
== nfserr_resource
)
2092 if (bmval1
& FATTR4_WORD1_OWNER_GROUP
) {
2093 status
= nfsd4_encode_group(rqstp
, stat
.gid
, &p
, &buflen
);
2094 if (status
== nfserr_resource
)
2099 if (bmval1
& FATTR4_WORD1_RAWDEV
) {
2100 if ((buflen
-= 8) < 0)
2102 WRITE32((u32
) MAJOR(stat
.rdev
));
2103 WRITE32((u32
) MINOR(stat
.rdev
));
2105 if (bmval1
& FATTR4_WORD1_SPACE_AVAIL
) {
2106 if ((buflen
-= 8) < 0)
2108 dummy64
= (u64
)statfs
.f_bavail
* (u64
)statfs
.f_bsize
;
2111 if (bmval1
& FATTR4_WORD1_SPACE_FREE
) {
2112 if ((buflen
-= 8) < 0)
2114 dummy64
= (u64
)statfs
.f_bfree
* (u64
)statfs
.f_bsize
;
2117 if (bmval1
& FATTR4_WORD1_SPACE_TOTAL
) {
2118 if ((buflen
-= 8) < 0)
2120 dummy64
= (u64
)statfs
.f_blocks
* (u64
)statfs
.f_bsize
;
2123 if (bmval1
& FATTR4_WORD1_SPACE_USED
) {
2124 if ((buflen
-= 8) < 0)
2126 dummy64
= (u64
)stat
.blocks
<< 9;
2129 if (bmval1
& FATTR4_WORD1_TIME_ACCESS
) {
2130 if ((buflen
-= 12) < 0)
2133 WRITE32(stat
.atime
.tv_sec
);
2134 WRITE32(stat
.atime
.tv_nsec
);
2136 if (bmval1
& FATTR4_WORD1_TIME_DELTA
) {
2137 if ((buflen
-= 12) < 0)
2143 if (bmval1
& FATTR4_WORD1_TIME_METADATA
) {
2144 if ((buflen
-= 12) < 0)
2147 WRITE32(stat
.ctime
.tv_sec
);
2148 WRITE32(stat
.ctime
.tv_nsec
);
2150 if (bmval1
& FATTR4_WORD1_TIME_MODIFY
) {
2151 if ((buflen
-= 12) < 0)
2154 WRITE32(stat
.mtime
.tv_sec
);
2155 WRITE32(stat
.mtime
.tv_nsec
);
2157 if (bmval1
& FATTR4_WORD1_MOUNTED_ON_FILEID
) {
2158 if ((buflen
-= 8) < 0)
2161 * Get parent's attributes if not ignoring crossmount
2162 * and this is the root of a cross-mounted filesystem.
2164 if (ignore_crossmnt
== 0 &&
2165 dentry
== exp
->ex_path
.mnt
->mnt_root
) {
2166 struct path path
= exp
->ex_path
;
2168 while (follow_up(&path
)) {
2169 if (path
.dentry
!= path
.mnt
->mnt_root
)
2172 err
= vfs_getattr(path
.mnt
, path
.dentry
, &stat
);
2179 if (bmval2
& FATTR4_WORD2_SUPPATTR_EXCLCREAT
) {
2181 WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD0
);
2182 WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD1
);
2183 WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD2
);
2186 *attrlenp
= htonl((char *)p
- (char *)attrlenp
- 4);
2187 *countp
= p
- buffer
;
2196 status
= nfserrno(err
);
2200 status
= nfserr_resource
;
2203 status
= nfserr_serverfault
;
2207 static inline int attributes_need_mount(u32
*bmval
)
2209 if (bmval
[0] & ~(FATTR4_WORD0_RDATTR_ERROR
| FATTR4_WORD0_LEASE_TIME
))
2211 if (bmval
[1] & ~FATTR4_WORD1_MOUNTED_ON_FILEID
)
2217 nfsd4_encode_dirent_fattr(struct nfsd4_readdir
*cd
,
2218 const char *name
, int namlen
, __be32
*p
, int *buflen
)
2220 struct svc_export
*exp
= cd
->rd_fhp
->fh_export
;
2221 struct dentry
*dentry
;
2223 int ignore_crossmnt
= 0;
2225 dentry
= lookup_one_len(name
, cd
->rd_fhp
->fh_dentry
, namlen
);
2227 return nfserrno(PTR_ERR(dentry
));
2228 if (!dentry
->d_inode
) {
2230 * nfsd_buffered_readdir drops the i_mutex between
2231 * readdir and calling this callback, leaving a window
2232 * where this directory entry could have gone away.
2235 return nfserr_noent
;
2240 * In the case of a mountpoint, the client may be asking for
2241 * attributes that are only properties of the underlying filesystem
2242 * as opposed to the cross-mounted file system. In such a case,
2243 * we will not follow the cross mount and will fill the attribtutes
2244 * directly from the mountpoint dentry.
2246 if (nfsd_mountpoint(dentry
, exp
)) {
2249 if (!(exp
->ex_flags
& NFSEXP_V4ROOT
)
2250 && !attributes_need_mount(cd
->rd_bmval
)) {
2251 ignore_crossmnt
= 1;
2255 * Why the heck aren't we just using nfsd_lookup??
2256 * Different "."/".." handling? Something else?
2257 * At least, add a comment here to explain....
2259 err
= nfsd_cross_mnt(cd
->rd_rqstp
, &dentry
, &exp
);
2261 nfserr
= nfserrno(err
);
2264 nfserr
= check_nfsd_access(exp
, cd
->rd_rqstp
);
2270 nfserr
= nfsd4_encode_fattr(NULL
, exp
, dentry
, p
, buflen
, cd
->rd_bmval
,
2271 cd
->rd_rqstp
, ignore_crossmnt
);
2279 nfsd4_encode_rdattr_error(__be32
*p
, int buflen
, __be32 nfserr
)
2286 *p
++ = htonl(FATTR4_WORD0_RDATTR_ERROR
); /* bmval0 */
2287 *p
++ = htonl(0); /* bmval1 */
2290 *p
++ = nfserr
; /* no htonl */
2291 *attrlenp
= htonl((char *)p
- (char *)attrlenp
- 4);
2296 nfsd4_encode_dirent(void *ccdv
, const char *name
, int namlen
,
2297 loff_t offset
, u64 ino
, unsigned int d_type
)
2299 struct readdir_cd
*ccd
= ccdv
;
2300 struct nfsd4_readdir
*cd
= container_of(ccd
, struct nfsd4_readdir
, common
);
2302 __be32
*p
= cd
->buffer
;
2304 __be32 nfserr
= nfserr_toosmall
;
2306 /* In nfsv4, "." and ".." never make it onto the wire.. */
2307 if (name
&& isdotent(name
, namlen
)) {
2308 cd
->common
.err
= nfs_ok
;
2313 xdr_encode_hyper(cd
->offset
, (u64
) offset
);
2315 buflen
= cd
->buflen
- 4 - XDR_QUADLEN(namlen
);
2319 *p
++ = xdr_one
; /* mark entry present */
2321 p
= xdr_encode_hyper(p
, NFS_OFFSET_MAX
); /* offset of next entry */
2322 p
= xdr_encode_array(p
, name
, namlen
); /* name length & name */
2324 nfserr
= nfsd4_encode_dirent_fattr(cd
, name
, namlen
, p
, &buflen
);
2329 case nfserr_resource
:
2330 nfserr
= nfserr_toosmall
;
2336 * If the client requested the RDATTR_ERROR attribute,
2337 * we stuff the error code into this attribute
2338 * and continue. If this attribute was not requested,
2339 * then in accordance with the spec, we fail the
2340 * entire READDIR operation(!)
2342 if (!(cd
->rd_bmval
[0] & FATTR4_WORD0_RDATTR_ERROR
))
2344 p
= nfsd4_encode_rdattr_error(p
, buflen
, nfserr
);
2346 nfserr
= nfserr_toosmall
;
2350 cd
->buflen
-= (p
- cd
->buffer
);
2352 cd
->offset
= cookiep
;
2354 cd
->common
.err
= nfs_ok
;
2357 cd
->common
.err
= nfserr
;
2362 nfsd4_encode_stateid(struct nfsd4_compoundres
*resp
, stateid_t
*sid
)
2366 RESERVE_SPACE(sizeof(stateid_t
));
2367 WRITE32(sid
->si_generation
);
2368 WRITEMEM(&sid
->si_opaque
, sizeof(stateid_opaque_t
));
2373 nfsd4_encode_access(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_access
*access
)
2379 WRITE32(access
->ac_supported
);
2380 WRITE32(access
->ac_resp_access
);
2387 nfsd4_encode_close(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_close
*close
)
2389 ENCODE_SEQID_OP_HEAD
;
2392 nfsd4_encode_stateid(resp
, &close
->cl_stateid
);
2394 ENCODE_SEQID_OP_TAIL(close
->cl_stateowner
);
2400 nfsd4_encode_commit(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_commit
*commit
)
2406 WRITEMEM(commit
->co_verf
.data
, 8);
2413 nfsd4_encode_create(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_create
*create
)
2419 write_cinfo(&p
, &create
->cr_cinfo
);
2421 WRITE32(create
->cr_bmval
[0]);
2422 WRITE32(create
->cr_bmval
[1]);
2429 nfsd4_encode_getattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_getattr
*getattr
)
2431 struct svc_fh
*fhp
= getattr
->ga_fhp
;
2437 buflen
= resp
->end
- resp
->p
- (COMPOUND_ERR_SLACK_SPACE
>> 2);
2438 nfserr
= nfsd4_encode_fattr(fhp
, fhp
->fh_export
, fhp
->fh_dentry
,
2439 resp
->p
, &buflen
, getattr
->ga_bmval
,
2447 nfsd4_encode_getfh(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct svc_fh
**fhpp
)
2449 struct svc_fh
*fhp
= *fhpp
;
2454 len
= fhp
->fh_handle
.fh_size
;
2455 RESERVE_SPACE(len
+ 4);
2457 WRITEMEM(&fhp
->fh_handle
.fh_base
, len
);
2464 * Including all fields other than the name, a LOCK4denied structure requires
2465 * 8(clientid) + 4(namelen) + 8(offset) + 8(length) + 4(type) = 32 bytes.
2468 nfsd4_encode_lock_denied(struct nfsd4_compoundres
*resp
, struct nfsd4_lock_denied
*ld
)
2472 RESERVE_SPACE(32 + XDR_LEN(ld
->ld_sop
? ld
->ld_sop
->so_owner
.len
: 0));
2473 WRITE64(ld
->ld_start
);
2474 WRITE64(ld
->ld_length
);
2475 WRITE32(ld
->ld_type
);
2477 WRITEMEM(&ld
->ld_clientid
, 8);
2478 WRITE32(ld
->ld_sop
->so_owner
.len
);
2479 WRITEMEM(ld
->ld_sop
->so_owner
.data
, ld
->ld_sop
->so_owner
.len
);
2480 kref_put(&ld
->ld_sop
->so_ref
, nfs4_free_stateowner
);
2481 } else { /* non - nfsv4 lock in conflict, no clientid nor owner */
2482 WRITE64((u64
)0); /* clientid */
2483 WRITE32(0); /* length of owner name */
2489 nfsd4_encode_lock(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_lock
*lock
)
2491 ENCODE_SEQID_OP_HEAD
;
2494 nfsd4_encode_stateid(resp
, &lock
->lk_resp_stateid
);
2495 else if (nfserr
== nfserr_denied
)
2496 nfsd4_encode_lock_denied(resp
, &lock
->lk_denied
);
2498 ENCODE_SEQID_OP_TAIL(lock
->lk_replay_owner
);
2503 nfsd4_encode_lockt(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_lockt
*lockt
)
2505 if (nfserr
== nfserr_denied
)
2506 nfsd4_encode_lock_denied(resp
, &lockt
->lt_denied
);
2511 nfsd4_encode_locku(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_locku
*locku
)
2513 ENCODE_SEQID_OP_HEAD
;
2516 nfsd4_encode_stateid(resp
, &locku
->lu_stateid
);
2518 ENCODE_SEQID_OP_TAIL(locku
->lu_stateowner
);
2524 nfsd4_encode_link(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_link
*link
)
2530 write_cinfo(&p
, &link
->li_cinfo
);
2538 nfsd4_encode_open(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open
*open
)
2541 ENCODE_SEQID_OP_HEAD
;
2546 nfsd4_encode_stateid(resp
, &open
->op_stateid
);
2548 write_cinfo(&p
, &open
->op_cinfo
);
2549 WRITE32(open
->op_rflags
);
2551 WRITE32(open
->op_bmval
[0]);
2552 WRITE32(open
->op_bmval
[1]);
2553 WRITE32(open
->op_delegate_type
);
2556 switch (open
->op_delegate_type
) {
2557 case NFS4_OPEN_DELEGATE_NONE
:
2559 case NFS4_OPEN_DELEGATE_READ
:
2560 nfsd4_encode_stateid(resp
, &open
->op_delegate_stateid
);
2562 WRITE32(open
->op_recall
);
2565 * TODO: ACE's in delegations
2567 WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE
);
2570 WRITE32(0); /* XXX: is NULL principal ok? */
2573 case NFS4_OPEN_DELEGATE_WRITE
:
2574 nfsd4_encode_stateid(resp
, &open
->op_delegate_stateid
);
2579 * TODO: space_limit's in delegations
2581 WRITE32(NFS4_LIMIT_SIZE
);
2586 * TODO: ACE's in delegations
2588 WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE
);
2591 WRITE32(0); /* XXX: is NULL principal ok? */
2597 /* XXX save filehandle here */
2599 ENCODE_SEQID_OP_TAIL(open
->op_stateowner
);
2604 nfsd4_encode_open_confirm(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open_confirm
*oc
)
2606 ENCODE_SEQID_OP_HEAD
;
2609 nfsd4_encode_stateid(resp
, &oc
->oc_resp_stateid
);
2611 ENCODE_SEQID_OP_TAIL(oc
->oc_stateowner
);
2616 nfsd4_encode_open_downgrade(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open_downgrade
*od
)
2618 ENCODE_SEQID_OP_HEAD
;
2621 nfsd4_encode_stateid(resp
, &od
->od_stateid
);
2623 ENCODE_SEQID_OP_TAIL(od
->od_stateowner
);
2628 nfsd4_encode_read(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
2629 struct nfsd4_read
*read
)
2633 unsigned long maxcount
;
2639 if (resp
->xbuf
->page_len
)
2640 return nfserr_resource
;
2642 RESERVE_SPACE(8); /* eof flag and byte count */
2644 maxcount
= svc_max_payload(resp
->rqstp
);
2645 if (maxcount
> read
->rd_length
)
2646 maxcount
= read
->rd_length
;
2651 pn
= resp
->rqstp
->rq_resused
++;
2652 resp
->rqstp
->rq_vec
[v
].iov_base
=
2653 page_address(resp
->rqstp
->rq_respages
[pn
]);
2654 resp
->rqstp
->rq_vec
[v
].iov_len
=
2655 len
< PAGE_SIZE
? len
: PAGE_SIZE
;
2661 nfserr
= nfsd_read_file(read
->rd_rqstp
, read
->rd_fhp
, read
->rd_filp
,
2662 read
->rd_offset
, resp
->rqstp
->rq_vec
, read
->rd_vlen
,
2665 if (nfserr
== nfserr_symlink
)
2666 nfserr
= nfserr_inval
;
2669 eof
= (read
->rd_offset
+ maxcount
>=
2670 read
->rd_fhp
->fh_dentry
->d_inode
->i_size
);
2675 resp
->xbuf
->head
[0].iov_len
= (char*)p
2676 - (char*)resp
->xbuf
->head
[0].iov_base
;
2677 resp
->xbuf
->page_len
= maxcount
;
2679 /* Use rest of head for padding and remaining ops: */
2680 resp
->xbuf
->tail
[0].iov_base
= p
;
2681 resp
->xbuf
->tail
[0].iov_len
= 0;
2685 resp
->xbuf
->tail
[0].iov_base
+= maxcount
&3;
2686 resp
->xbuf
->tail
[0].iov_len
= 4 - (maxcount
&3);
2693 nfsd4_encode_readlink(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_readlink
*readlink
)
2701 if (resp
->xbuf
->page_len
)
2702 return nfserr_resource
;
2704 page
= page_address(resp
->rqstp
->rq_respages
[resp
->rqstp
->rq_resused
++]);
2706 maxcount
= PAGE_SIZE
;
2710 * XXX: By default, the ->readlink() VFS op will truncate symlinks
2711 * if they would overflow the buffer. Is this kosher in NFSv4? If
2712 * not, one easy fix is: if ->readlink() precisely fills the buffer,
2713 * assume that truncation occurred, and return NFS4ERR_RESOURCE.
2715 nfserr
= nfsd_readlink(readlink
->rl_rqstp
, readlink
->rl_fhp
, page
, &maxcount
);
2716 if (nfserr
== nfserr_isdir
)
2717 return nfserr_inval
;
2723 resp
->xbuf
->head
[0].iov_len
= (char*)p
2724 - (char*)resp
->xbuf
->head
[0].iov_base
;
2725 resp
->xbuf
->page_len
= maxcount
;
2727 /* Use rest of head for padding and remaining ops: */
2728 resp
->xbuf
->tail
[0].iov_base
= p
;
2729 resp
->xbuf
->tail
[0].iov_len
= 0;
2733 resp
->xbuf
->tail
[0].iov_base
+= maxcount
&3;
2734 resp
->xbuf
->tail
[0].iov_len
= 4 - (maxcount
&3);
2741 nfsd4_encode_readdir(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_readdir
*readdir
)
2745 __be32
*page
, *savep
, *tailbase
;
2750 if (resp
->xbuf
->page_len
)
2751 return nfserr_resource
;
2753 RESERVE_SPACE(8); /* verifier */
2756 /* XXX: Following NFSv3, we ignore the READDIR verifier for now. */
2760 resp
->xbuf
->head
[0].iov_len
= ((char*)resp
->p
) - (char*)resp
->xbuf
->head
[0].iov_base
;
2763 maxcount
= PAGE_SIZE
;
2764 if (maxcount
> readdir
->rd_maxcount
)
2765 maxcount
= readdir
->rd_maxcount
;
2768 * Convert from bytes to words, account for the two words already
2769 * written, make sure to leave two words at the end for the next
2770 * pointer and eof field.
2772 maxcount
= (maxcount
>> 2) - 4;
2774 nfserr
= nfserr_toosmall
;
2778 page
= page_address(resp
->rqstp
->rq_respages
[resp
->rqstp
->rq_resused
++]);
2779 readdir
->common
.err
= 0;
2780 readdir
->buflen
= maxcount
;
2781 readdir
->buffer
= page
;
2782 readdir
->offset
= NULL
;
2784 offset
= readdir
->rd_cookie
;
2785 nfserr
= nfsd_readdir(readdir
->rd_rqstp
, readdir
->rd_fhp
,
2787 &readdir
->common
, nfsd4_encode_dirent
);
2788 if (nfserr
== nfs_ok
&&
2789 readdir
->common
.err
== nfserr_toosmall
&&
2790 readdir
->buffer
== page
)
2791 nfserr
= nfserr_toosmall
;
2792 if (nfserr
== nfserr_symlink
)
2793 nfserr
= nfserr_notdir
;
2797 if (readdir
->offset
)
2798 xdr_encode_hyper(readdir
->offset
, offset
);
2800 p
= readdir
->buffer
;
2801 *p
++ = 0; /* no more entries */
2802 *p
++ = htonl(readdir
->common
.err
== nfserr_eof
);
2803 resp
->xbuf
->page_len
= ((char*)p
) - (char*)page_address(
2804 resp
->rqstp
->rq_respages
[resp
->rqstp
->rq_resused
-1]);
2806 /* Use rest of head for padding and remaining ops: */
2807 resp
->xbuf
->tail
[0].iov_base
= tailbase
;
2808 resp
->xbuf
->tail
[0].iov_len
= 0;
2809 resp
->p
= resp
->xbuf
->tail
[0].iov_base
;
2810 resp
->end
= resp
->p
+ (PAGE_SIZE
- resp
->xbuf
->head
[0].iov_len
)/4;
2820 nfsd4_encode_remove(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_remove
*remove
)
2826 write_cinfo(&p
, &remove
->rm_cinfo
);
2833 nfsd4_encode_rename(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_rename
*rename
)
2839 write_cinfo(&p
, &rename
->rn_sinfo
);
2840 write_cinfo(&p
, &rename
->rn_tinfo
);
2847 nfsd4_do_encode_secinfo(struct nfsd4_compoundres
*resp
,
2848 __be32 nfserr
,struct svc_export
*exp
)
2852 struct exp_flavor_info
*flavs
;
2853 struct exp_flavor_info def_flavs
[2];
2858 if (exp
->ex_nflavors
) {
2859 flavs
= exp
->ex_flavors
;
2860 nflavs
= exp
->ex_nflavors
;
2861 } else { /* Handling of some defaults in absence of real secinfo: */
2863 if (exp
->ex_client
->flavour
->flavour
== RPC_AUTH_UNIX
) {
2865 flavs
[0].pseudoflavor
= RPC_AUTH_UNIX
;
2866 flavs
[1].pseudoflavor
= RPC_AUTH_NULL
;
2867 } else if (exp
->ex_client
->flavour
->flavour
== RPC_AUTH_GSS
) {
2869 flavs
[0].pseudoflavor
2870 = svcauth_gss_flavor(exp
->ex_client
);
2873 flavs
[0].pseudoflavor
2874 = exp
->ex_client
->flavour
->flavour
;
2881 for (i
= 0; i
< nflavs
; i
++) {
2882 u32 flav
= flavs
[i
].pseudoflavor
;
2883 struct gss_api_mech
*gm
= gss_mech_get_by_pseudoflavor(flav
);
2887 WRITE32(RPC_AUTH_GSS
);
2889 RESERVE_SPACE(4 + gm
->gm_oid
.len
);
2890 WRITE32(gm
->gm_oid
.len
);
2891 WRITEMEM(gm
->gm_oid
.data
, gm
->gm_oid
.len
);
2894 WRITE32(0); /* qop */
2897 WRITE32(gss_pseudoflavor_to_service(gm
, flav
));
2913 nfsd4_encode_secinfo(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
2914 struct nfsd4_secinfo
*secinfo
)
2916 return nfsd4_do_encode_secinfo(resp
, nfserr
, secinfo
->si_exp
);
2920 nfsd4_encode_secinfo_no_name(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
2921 struct nfsd4_secinfo_no_name
*secinfo
)
2923 return nfsd4_do_encode_secinfo(resp
, nfserr
, secinfo
->sin_exp
);
2927 * The SETATTR encode routine is special -- it always encodes a bitmap,
2928 * regardless of the error status.
2931 nfsd4_encode_setattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_setattr
*setattr
)
2943 WRITE32(setattr
->sa_bmval
[0]);
2944 WRITE32(setattr
->sa_bmval
[1]);
2951 nfsd4_encode_setclientid(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_setclientid
*scd
)
2956 RESERVE_SPACE(8 + sizeof(nfs4_verifier
));
2957 WRITEMEM(&scd
->se_clientid
, 8);
2958 WRITEMEM(&scd
->se_confirm
, sizeof(nfs4_verifier
));
2961 else if (nfserr
== nfserr_clid_inuse
) {
2971 nfsd4_encode_write(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_write
*write
)
2977 WRITE32(write
->wr_bytes_written
);
2978 WRITE32(write
->wr_how_written
);
2979 WRITEMEM(write
->wr_verifier
.data
, 8);
2986 nfsd4_encode_exchange_id(struct nfsd4_compoundres
*resp
, int nfserr
,
2987 struct nfsd4_exchange_id
*exid
)
2993 int server_scope_sz
;
2994 uint64_t minor_id
= 0;
2999 major_id
= utsname()->nodename
;
3000 major_id_sz
= strlen(major_id
);
3001 server_scope
= utsname()->nodename
;
3002 server_scope_sz
= strlen(server_scope
);
3005 8 /* eir_clientid */ +
3006 4 /* eir_sequenceid */ +
3008 4 /* spr_how (SP4_NONE) */ +
3009 8 /* so_minor_id */ +
3010 4 /* so_major_id.len */ +
3011 (XDR_QUADLEN(major_id_sz
) * 4) +
3012 4 /* eir_server_scope.len */ +
3013 (XDR_QUADLEN(server_scope_sz
) * 4) +
3014 4 /* eir_server_impl_id.count (0) */);
3016 WRITEMEM(&exid
->clientid
, 8);
3017 WRITE32(exid
->seqid
);
3018 WRITE32(exid
->flags
);
3020 /* state_protect4_r. Currently only support SP4_NONE */
3021 BUG_ON(exid
->spa_how
!= SP4_NONE
);
3022 WRITE32(exid
->spa_how
);
3024 /* The server_owner struct */
3025 WRITE64(minor_id
); /* Minor id */
3027 WRITE32(major_id_sz
);
3028 WRITEMEM(major_id
, major_id_sz
);
3031 WRITE32(server_scope_sz
);
3032 WRITEMEM(server_scope
, server_scope_sz
);
3034 /* Implementation id */
3035 WRITE32(0); /* zero length nfs_impl_id4 array */
3041 nfsd4_encode_create_session(struct nfsd4_compoundres
*resp
, int nfserr
,
3042 struct nfsd4_create_session
*sess
)
3050 WRITEMEM(sess
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
3051 WRITE32(sess
->seqid
);
3052 WRITE32(sess
->flags
);
3056 WRITE32(0); /* headerpadsz */
3057 WRITE32(sess
->fore_channel
.maxreq_sz
);
3058 WRITE32(sess
->fore_channel
.maxresp_sz
);
3059 WRITE32(sess
->fore_channel
.maxresp_cached
);
3060 WRITE32(sess
->fore_channel
.maxops
);
3061 WRITE32(sess
->fore_channel
.maxreqs
);
3062 WRITE32(sess
->fore_channel
.nr_rdma_attrs
);
3065 if (sess
->fore_channel
.nr_rdma_attrs
) {
3067 WRITE32(sess
->fore_channel
.rdma_attrs
);
3072 WRITE32(0); /* headerpadsz */
3073 WRITE32(sess
->back_channel
.maxreq_sz
);
3074 WRITE32(sess
->back_channel
.maxresp_sz
);
3075 WRITE32(sess
->back_channel
.maxresp_cached
);
3076 WRITE32(sess
->back_channel
.maxops
);
3077 WRITE32(sess
->back_channel
.maxreqs
);
3078 WRITE32(sess
->back_channel
.nr_rdma_attrs
);
3081 if (sess
->back_channel
.nr_rdma_attrs
) {
3083 WRITE32(sess
->back_channel
.rdma_attrs
);
3090 nfsd4_encode_destroy_session(struct nfsd4_compoundres
*resp
, int nfserr
,
3091 struct nfsd4_destroy_session
*destroy_session
)
3097 nfsd4_encode_sequence(struct nfsd4_compoundres
*resp
, int nfserr
,
3098 struct nfsd4_sequence
*seq
)
3105 RESERVE_SPACE(NFS4_MAX_SESSIONID_LEN
+ 20);
3106 WRITEMEM(seq
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
3107 WRITE32(seq
->seqid
);
3108 WRITE32(seq
->slotid
);
3109 WRITE32(seq
->maxslots
);
3112 * target_maxslots = maxslots
3115 WRITE32(seq
->maxslots
);
3119 resp
->cstate
.datap
= p
; /* DRC cache data pointer */
3124 nfsd4_encode_noop(struct nfsd4_compoundres
*resp
, __be32 nfserr
, void *p
)
3129 typedef __be32(* nfsd4_enc
)(struct nfsd4_compoundres
*, __be32
, void *);
3132 * Note: nfsd4_enc_ops vector is shared for v4.0 and v4.1
3133 * since we don't need to filter out obsolete ops as this is
3134 * done in the decoding phase.
3136 static nfsd4_enc nfsd4_enc_ops
[] = {
3137 [OP_ACCESS
] = (nfsd4_enc
)nfsd4_encode_access
,
3138 [OP_CLOSE
] = (nfsd4_enc
)nfsd4_encode_close
,
3139 [OP_COMMIT
] = (nfsd4_enc
)nfsd4_encode_commit
,
3140 [OP_CREATE
] = (nfsd4_enc
)nfsd4_encode_create
,
3141 [OP_DELEGPURGE
] = (nfsd4_enc
)nfsd4_encode_noop
,
3142 [OP_DELEGRETURN
] = (nfsd4_enc
)nfsd4_encode_noop
,
3143 [OP_GETATTR
] = (nfsd4_enc
)nfsd4_encode_getattr
,
3144 [OP_GETFH
] = (nfsd4_enc
)nfsd4_encode_getfh
,
3145 [OP_LINK
] = (nfsd4_enc
)nfsd4_encode_link
,
3146 [OP_LOCK
] = (nfsd4_enc
)nfsd4_encode_lock
,
3147 [OP_LOCKT
] = (nfsd4_enc
)nfsd4_encode_lockt
,
3148 [OP_LOCKU
] = (nfsd4_enc
)nfsd4_encode_locku
,
3149 [OP_LOOKUP
] = (nfsd4_enc
)nfsd4_encode_noop
,
3150 [OP_LOOKUPP
] = (nfsd4_enc
)nfsd4_encode_noop
,
3151 [OP_NVERIFY
] = (nfsd4_enc
)nfsd4_encode_noop
,
3152 [OP_OPEN
] = (nfsd4_enc
)nfsd4_encode_open
,
3153 [OP_OPENATTR
] = (nfsd4_enc
)nfsd4_encode_noop
,
3154 [OP_OPEN_CONFIRM
] = (nfsd4_enc
)nfsd4_encode_open_confirm
,
3155 [OP_OPEN_DOWNGRADE
] = (nfsd4_enc
)nfsd4_encode_open_downgrade
,
3156 [OP_PUTFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3157 [OP_PUTPUBFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3158 [OP_PUTROOTFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3159 [OP_READ
] = (nfsd4_enc
)nfsd4_encode_read
,
3160 [OP_READDIR
] = (nfsd4_enc
)nfsd4_encode_readdir
,
3161 [OP_READLINK
] = (nfsd4_enc
)nfsd4_encode_readlink
,
3162 [OP_REMOVE
] = (nfsd4_enc
)nfsd4_encode_remove
,
3163 [OP_RENAME
] = (nfsd4_enc
)nfsd4_encode_rename
,
3164 [OP_RENEW
] = (nfsd4_enc
)nfsd4_encode_noop
,
3165 [OP_RESTOREFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3166 [OP_SAVEFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3167 [OP_SECINFO
] = (nfsd4_enc
)nfsd4_encode_secinfo
,
3168 [OP_SETATTR
] = (nfsd4_enc
)nfsd4_encode_setattr
,
3169 [OP_SETCLIENTID
] = (nfsd4_enc
)nfsd4_encode_setclientid
,
3170 [OP_SETCLIENTID_CONFIRM
] = (nfsd4_enc
)nfsd4_encode_noop
,
3171 [OP_VERIFY
] = (nfsd4_enc
)nfsd4_encode_noop
,
3172 [OP_WRITE
] = (nfsd4_enc
)nfsd4_encode_write
,
3173 [OP_RELEASE_LOCKOWNER
] = (nfsd4_enc
)nfsd4_encode_noop
,
3175 /* NFSv4.1 operations */
3176 [OP_BACKCHANNEL_CTL
] = (nfsd4_enc
)nfsd4_encode_noop
,
3177 [OP_BIND_CONN_TO_SESSION
] = (nfsd4_enc
)nfsd4_encode_noop
,
3178 [OP_EXCHANGE_ID
] = (nfsd4_enc
)nfsd4_encode_exchange_id
,
3179 [OP_CREATE_SESSION
] = (nfsd4_enc
)nfsd4_encode_create_session
,
3180 [OP_DESTROY_SESSION
] = (nfsd4_enc
)nfsd4_encode_destroy_session
,
3181 [OP_FREE_STATEID
] = (nfsd4_enc
)nfsd4_encode_noop
,
3182 [OP_GET_DIR_DELEGATION
] = (nfsd4_enc
)nfsd4_encode_noop
,
3183 [OP_GETDEVICEINFO
] = (nfsd4_enc
)nfsd4_encode_noop
,
3184 [OP_GETDEVICELIST
] = (nfsd4_enc
)nfsd4_encode_noop
,
3185 [OP_LAYOUTCOMMIT
] = (nfsd4_enc
)nfsd4_encode_noop
,
3186 [OP_LAYOUTGET
] = (nfsd4_enc
)nfsd4_encode_noop
,
3187 [OP_LAYOUTRETURN
] = (nfsd4_enc
)nfsd4_encode_noop
,
3188 [OP_SECINFO_NO_NAME
] = (nfsd4_enc
)nfsd4_encode_secinfo_no_name
,
3189 [OP_SEQUENCE
] = (nfsd4_enc
)nfsd4_encode_sequence
,
3190 [OP_SET_SSV
] = (nfsd4_enc
)nfsd4_encode_noop
,
3191 [OP_TEST_STATEID
] = (nfsd4_enc
)nfsd4_encode_noop
,
3192 [OP_WANT_DELEGATION
] = (nfsd4_enc
)nfsd4_encode_noop
,
3193 [OP_DESTROY_CLIENTID
] = (nfsd4_enc
)nfsd4_encode_noop
,
3194 [OP_RECLAIM_COMPLETE
] = (nfsd4_enc
)nfsd4_encode_noop
,
3198 * Calculate the total amount of memory that the compound response has taken
3199 * after encoding the current operation.
3201 * pad: add on 8 bytes for the next operation's op_code and status so that
3202 * there is room to cache a failure on the next operation.
3204 * Compare this length to the session se_fmaxresp_cached.
3206 * Our se_fmaxresp_cached will always be a multiple of PAGE_SIZE, and so
3207 * will be at least a page and will therefore hold the xdr_buf head.
3209 static int nfsd4_check_drc_limit(struct nfsd4_compoundres
*resp
)
3212 struct xdr_buf
*xb
= &resp
->rqstp
->rq_res
;
3213 struct nfsd4_compoundargs
*args
= resp
->rqstp
->rq_argp
;
3214 struct nfsd4_session
*session
= NULL
;
3215 struct nfsd4_slot
*slot
= resp
->cstate
.slot
;
3216 u32 length
, tlen
= 0, pad
= 8;
3218 if (!nfsd4_has_session(&resp
->cstate
))
3221 session
= resp
->cstate
.session
;
3222 if (session
== NULL
|| slot
->sl_cachethis
== 0)
3225 if (resp
->opcnt
>= args
->opcnt
)
3226 pad
= 0; /* this is the last operation */
3228 if (xb
->page_len
== 0) {
3229 length
= (char *)resp
->p
- (char *)xb
->head
[0].iov_base
+ pad
;
3231 if (xb
->tail
[0].iov_base
&& xb
->tail
[0].iov_len
> 0)
3232 tlen
= (char *)resp
->p
- (char *)xb
->tail
[0].iov_base
;
3234 length
= xb
->head
[0].iov_len
+ xb
->page_len
+ tlen
+ pad
;
3236 dprintk("%s length %u, xb->page_len %u tlen %u pad %u\n", __func__
,
3237 length
, xb
->page_len
, tlen
, pad
);
3239 if (length
<= session
->se_fchannel
.maxresp_cached
)
3242 return nfserr_rep_too_big_to_cache
;
3246 nfsd4_encode_operation(struct nfsd4_compoundres
*resp
, struct nfsd4_op
*op
)
3253 statp
= p
++; /* to be backfilled at the end */
3256 if (op
->opnum
== OP_ILLEGAL
)
3258 BUG_ON(op
->opnum
< 0 || op
->opnum
>= ARRAY_SIZE(nfsd4_enc_ops
) ||
3259 !nfsd4_enc_ops
[op
->opnum
]);
3260 op
->status
= nfsd4_enc_ops
[op
->opnum
](resp
, op
->status
, &op
->u
);
3261 /* nfsd4_check_drc_limit guarantees enough room for error status */
3262 if (!op
->status
&& nfsd4_check_drc_limit(resp
))
3263 op
->status
= nfserr_rep_too_big_to_cache
;
3266 * Note: We write the status directly, instead of using WRITE32(),
3267 * since it is already in network byte order.
3269 *statp
= op
->status
;
3273 * Encode the reply stored in the stateowner reply cache
3275 * XDR note: do not encode rp->rp_buflen: the buffer contains the
3276 * previously sent already encoded operation.
3278 * called with nfs4_lock_state() held
3281 nfsd4_encode_replay(struct nfsd4_compoundres
*resp
, struct nfsd4_op
*op
)
3284 struct nfs4_replay
*rp
= op
->replay
;
3290 *p
++ = rp
->rp_status
; /* already xdr'ed */
3293 RESERVE_SPACE(rp
->rp_buflen
);
3294 WRITEMEM(rp
->rp_buf
, rp
->rp_buflen
);
3299 nfs4svc_encode_voidres(struct svc_rqst
*rqstp
, __be32
*p
, void *dummy
)
3301 return xdr_ressize_check(rqstp
, p
);
3304 void nfsd4_release_compoundargs(struct nfsd4_compoundargs
*args
)
3306 if (args
->ops
!= args
->iops
) {
3308 args
->ops
= args
->iops
;
3312 while (args
->to_free
) {
3313 struct tmpbuf
*tb
= args
->to_free
;
3314 args
->to_free
= tb
->next
;
3315 tb
->release(tb
->buf
);
3321 nfs4svc_decode_compoundargs(struct svc_rqst
*rqstp
, __be32
*p
, struct nfsd4_compoundargs
*args
)
3326 args
->end
= rqstp
->rq_arg
.head
[0].iov_base
+ rqstp
->rq_arg
.head
[0].iov_len
;
3327 args
->pagelist
= rqstp
->rq_arg
.pages
;
3328 args
->pagelen
= rqstp
->rq_arg
.page_len
;
3330 args
->to_free
= NULL
;
3331 args
->ops
= args
->iops
;
3332 args
->rqstp
= rqstp
;
3334 status
= nfsd4_decode_compound(args
);
3336 nfsd4_release_compoundargs(args
);
3342 nfs4svc_encode_compoundres(struct svc_rqst
*rqstp
, __be32
*p
, struct nfsd4_compoundres
*resp
)
3345 * All that remains is to write the tag and operation count...
3347 struct nfsd4_compound_state
*cs
= &resp
->cstate
;
3350 *p
++ = htonl(resp
->taglen
);
3351 memcpy(p
, resp
->tag
, resp
->taglen
);
3352 p
+= XDR_QUADLEN(resp
->taglen
);
3353 *p
++ = htonl(resp
->opcnt
);
3355 if (rqstp
->rq_res
.page_len
)
3356 iov
= &rqstp
->rq_res
.tail
[0];
3358 iov
= &rqstp
->rq_res
.head
[0];
3359 iov
->iov_len
= ((char*)resp
->p
) - (char*)iov
->iov_base
;
3360 BUG_ON(iov
->iov_len
> PAGE_SIZE
);
3361 if (nfsd4_has_session(cs
)) {
3362 if (cs
->status
!= nfserr_replay_cache
) {
3363 nfsd4_store_cache_entry(resp
);
3364 dprintk("%s: SET SLOT STATE TO AVAILABLE\n", __func__
);
3365 cs
->slot
->sl_inuse
= false;
3367 /* Renew the clientid on success and on replay */
3368 release_session_client(cs
->session
);
3369 nfsd4_put_session(cs
->session
);