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/pagemap.h>
48 #include <linux/sunrpc/svcauth_gss.h>
57 #define NFSDDBG_FACILITY NFSDDBG_XDR
60 * As per referral draft, the fsid for a referral MUST be different from the fsid of the containing
61 * directory in order to indicate to the client that a filesystem boundary is present
62 * We use a fixed fsid for a referral
64 #define NFS4_REFERRAL_FSID_MAJOR 0x8000000ULL
65 #define NFS4_REFERRAL_FSID_MINOR 0x8000000ULL
68 check_filename(char *str
, int len
, __be32 err
)
74 if (isdotent(str
, len
))
76 for (i
= 0; i
< len
; i
++)
90 dprintk("NFSD: xdr error (%s:%d)\n", \
91 __FILE__, __LINE__); \
92 status = nfserr_bad_xdr; \
95 #define READ32(x) (x) = ntohl(*p++)
96 #define READ64(x) do { \
97 (x) = (u64)ntohl(*p++) << 32; \
100 #define READTIME(x) do { \
105 #define READMEM(x,nbytes) do { \
107 p += XDR_QUADLEN(nbytes); \
109 #define SAVEMEM(x,nbytes) do { \
110 if (!(x = (p==argp->tmp || p == argp->tmpp) ? \
111 savemem(argp, p, nbytes) : \
113 dprintk("NFSD: xdr error (%s:%d)\n", \
114 __FILE__, __LINE__); \
117 p += XDR_QUADLEN(nbytes); \
119 #define COPYMEM(x,nbytes) do { \
120 memcpy((x), p, nbytes); \
121 p += XDR_QUADLEN(nbytes); \
124 /* READ_BUF, read_buf(): nbytes must be <= PAGE_SIZE */
125 #define READ_BUF(nbytes) do { \
126 if (nbytes <= (u32)((char *)argp->end - (char *)argp->p)) { \
128 argp->p += XDR_QUADLEN(nbytes); \
129 } else if (!(p = read_buf(argp, nbytes))) { \
130 dprintk("NFSD: xdr error (%s:%d)\n", \
131 __FILE__, __LINE__); \
136 static void save_buf(struct nfsd4_compoundargs
*argp
, struct nfsd4_saved_compoundargs
*savep
)
139 savep
->end
= argp
->end
;
140 savep
->pagelen
= argp
->pagelen
;
141 savep
->pagelist
= argp
->pagelist
;
144 static void restore_buf(struct nfsd4_compoundargs
*argp
, struct nfsd4_saved_compoundargs
*savep
)
147 argp
->end
= savep
->end
;
148 argp
->pagelen
= savep
->pagelen
;
149 argp
->pagelist
= savep
->pagelist
;
152 static __be32
*read_buf(struct nfsd4_compoundargs
*argp
, u32 nbytes
)
154 /* We want more bytes than seem to be available.
155 * Maybe we need a new page, maybe we have just run out
157 unsigned int avail
= (char *)argp
->end
- (char *)argp
->p
;
159 if (avail
+ argp
->pagelen
< nbytes
)
161 if (avail
+ PAGE_SIZE
< nbytes
) /* need more than a page !! */
163 /* ok, we can do it with the current plus the next page */
164 if (nbytes
<= sizeof(argp
->tmp
))
168 p
= argp
->tmpp
= kmalloc(nbytes
, GFP_KERNEL
);
174 * The following memcpy is safe because read_buf is always
175 * called with nbytes > avail, and the two cases above both
176 * guarantee p points to at least nbytes bytes.
178 memcpy(p
, argp
->p
, avail
);
179 /* step to next page */
180 argp
->p
= page_address(argp
->pagelist
[0]);
182 if (argp
->pagelen
< PAGE_SIZE
) {
183 argp
->end
= argp
->p
+ (argp
->pagelen
>>2);
186 argp
->end
= argp
->p
+ (PAGE_SIZE
>>2);
187 argp
->pagelen
-= PAGE_SIZE
;
189 memcpy(((char*)p
)+avail
, argp
->p
, (nbytes
- avail
));
190 argp
->p
+= XDR_QUADLEN(nbytes
- avail
);
194 static int zero_clientid(clientid_t
*clid
)
196 return (clid
->cl_boot
== 0) && (clid
->cl_id
== 0);
200 defer_free(struct nfsd4_compoundargs
*argp
,
201 void (*release
)(const void *), void *p
)
205 tb
= kmalloc(sizeof(*tb
), GFP_KERNEL
);
209 tb
->release
= release
;
210 tb
->next
= argp
->to_free
;
215 static char *savemem(struct nfsd4_compoundargs
*argp
, __be32
*p
, int nbytes
)
217 if (p
== argp
->tmp
) {
218 p
= kmalloc(nbytes
, GFP_KERNEL
);
221 memcpy(p
, argp
->tmp
, nbytes
);
223 BUG_ON(p
!= argp
->tmpp
);
226 if (defer_free(argp
, kfree
, p
)) {
234 nfsd4_decode_bitmap(struct nfsd4_compoundargs
*argp
, u32
*bmval
)
248 READ_BUF(bmlen
<< 2);
260 nfsd4_decode_fattr(struct nfsd4_compoundargs
*argp
, u32
*bmval
,
261 struct iattr
*iattr
, struct nfs4_acl
**acl
)
263 int expected_len
, len
= 0;
270 if ((status
= nfsd4_decode_bitmap(argp
, bmval
)))
274 READ32(expected_len
);
276 if (bmval
[0] & FATTR4_WORD0_SIZE
) {
279 READ64(iattr
->ia_size
);
280 iattr
->ia_valid
|= ATTR_SIZE
;
282 if (bmval
[0] & FATTR4_WORD0_ACL
) {
284 struct nfs4_ace
*ace
;
286 READ_BUF(4); len
+= 4;
289 if (nace
> NFS4_ACL_MAX
)
290 return nfserr_resource
;
292 *acl
= nfs4_acl_new(nace
);
297 defer_free(argp
, kfree
, *acl
);
299 (*acl
)->naces
= nace
;
300 for (ace
= (*acl
)->aces
; ace
< (*acl
)->aces
+ nace
; ace
++) {
301 READ_BUF(16); len
+= 16;
304 READ32(ace
->access_mask
);
307 len
+= XDR_QUADLEN(dummy32
) << 2;
308 READMEM(buf
, dummy32
);
309 ace
->whotype
= nfs4_acl_get_whotype(buf
, dummy32
);
311 if (ace
->whotype
!= NFS4_ACL_WHO_NAMED
)
313 else if (ace
->flag
& NFS4_ACE_IDENTIFIER_GROUP
)
314 status
= nfsd_map_name_to_gid(argp
->rqstp
,
315 buf
, dummy32
, &ace
->who
);
317 status
= nfsd_map_name_to_uid(argp
->rqstp
,
318 buf
, dummy32
, &ace
->who
);
324 if (bmval
[1] & FATTR4_WORD1_MODE
) {
327 READ32(iattr
->ia_mode
);
328 iattr
->ia_mode
&= (S_IFMT
| S_IALLUGO
);
329 iattr
->ia_valid
|= ATTR_MODE
;
331 if (bmval
[1] & FATTR4_WORD1_OWNER
) {
336 len
+= (XDR_QUADLEN(dummy32
) << 2);
337 READMEM(buf
, dummy32
);
338 if ((status
= nfsd_map_name_to_uid(argp
->rqstp
, buf
, dummy32
, &iattr
->ia_uid
)))
340 iattr
->ia_valid
|= ATTR_UID
;
342 if (bmval
[1] & FATTR4_WORD1_OWNER_GROUP
) {
347 len
+= (XDR_QUADLEN(dummy32
) << 2);
348 READMEM(buf
, dummy32
);
349 if ((status
= nfsd_map_name_to_gid(argp
->rqstp
, buf
, dummy32
, &iattr
->ia_gid
)))
351 iattr
->ia_valid
|= ATTR_GID
;
353 if (bmval
[1] & FATTR4_WORD1_TIME_ACCESS_SET
) {
358 case NFS4_SET_TO_CLIENT_TIME
:
359 /* We require the high 32 bits of 'seconds' to be 0, and we ignore
360 all 32 bits of 'nseconds'. */
366 READ32(iattr
->ia_atime
.tv_sec
);
367 READ32(iattr
->ia_atime
.tv_nsec
);
368 if (iattr
->ia_atime
.tv_nsec
>= (u32
)1000000000)
370 iattr
->ia_valid
|= (ATTR_ATIME
| ATTR_ATIME_SET
);
372 case NFS4_SET_TO_SERVER_TIME
:
373 iattr
->ia_valid
|= ATTR_ATIME
;
379 if (bmval
[1] & FATTR4_WORD1_TIME_MODIFY_SET
) {
384 case NFS4_SET_TO_CLIENT_TIME
:
385 /* We require the high 32 bits of 'seconds' to be 0, and we ignore
386 all 32 bits of 'nseconds'. */
392 READ32(iattr
->ia_mtime
.tv_sec
);
393 READ32(iattr
->ia_mtime
.tv_nsec
);
394 if (iattr
->ia_mtime
.tv_nsec
>= (u32
)1000000000)
396 iattr
->ia_valid
|= (ATTR_MTIME
| ATTR_MTIME_SET
);
398 case NFS4_SET_TO_SERVER_TIME
:
399 iattr
->ia_valid
|= ATTR_MTIME
;
405 if (bmval
[0] & ~NFSD_WRITEABLE_ATTRS_WORD0
406 || bmval
[1] & ~NFSD_WRITEABLE_ATTRS_WORD1
407 || bmval
[2] & ~NFSD_WRITEABLE_ATTRS_WORD2
)
408 READ_BUF(expected_len
- len
);
409 else if (len
!= expected_len
)
415 status
= nfserrno(host_err
);
420 nfsd4_decode_stateid(struct nfsd4_compoundargs
*argp
, stateid_t
*sid
)
424 READ_BUF(sizeof(stateid_t
));
425 READ32(sid
->si_generation
);
426 COPYMEM(&sid
->si_opaque
, sizeof(stateid_opaque_t
));
432 nfsd4_decode_access(struct nfsd4_compoundargs
*argp
, struct nfsd4_access
*access
)
437 READ32(access
->ac_req_access
);
442 static __be32
nfsd4_decode_bind_conn_to_session(struct nfsd4_compoundargs
*argp
, struct nfsd4_bind_conn_to_session
*bcts
)
446 READ_BUF(NFS4_MAX_SESSIONID_LEN
+ 8);
447 COPYMEM(bcts
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
449 /* XXX: skipping ctsa_use_conn_in_rdma_mode. Perhaps Tom Tucker
450 * could help us figure out we should be using it. */
455 nfsd4_decode_close(struct nfsd4_compoundargs
*argp
, struct nfsd4_close
*close
)
459 close
->cl_stateowner
= NULL
;
461 READ32(close
->cl_seqid
);
462 return nfsd4_decode_stateid(argp
, &close
->cl_stateid
);
469 nfsd4_decode_commit(struct nfsd4_compoundargs
*argp
, struct nfsd4_commit
*commit
)
474 READ64(commit
->co_offset
);
475 READ32(commit
->co_count
);
481 nfsd4_decode_create(struct nfsd4_compoundargs
*argp
, struct nfsd4_create
*create
)
486 READ32(create
->cr_type
);
487 switch (create
->cr_type
) {
490 READ32(create
->cr_linklen
);
491 READ_BUF(create
->cr_linklen
);
492 SAVEMEM(create
->cr_linkname
, create
->cr_linklen
);
497 READ32(create
->cr_specdata1
);
498 READ32(create
->cr_specdata2
);
508 READ32(create
->cr_namelen
);
509 READ_BUF(create
->cr_namelen
);
510 SAVEMEM(create
->cr_name
, create
->cr_namelen
);
511 if ((status
= check_filename(create
->cr_name
, create
->cr_namelen
, nfserr_inval
)))
514 status
= nfsd4_decode_fattr(argp
, create
->cr_bmval
, &create
->cr_iattr
,
523 nfsd4_decode_delegreturn(struct nfsd4_compoundargs
*argp
, struct nfsd4_delegreturn
*dr
)
525 return nfsd4_decode_stateid(argp
, &dr
->dr_stateid
);
529 nfsd4_decode_getattr(struct nfsd4_compoundargs
*argp
, struct nfsd4_getattr
*getattr
)
531 return nfsd4_decode_bitmap(argp
, getattr
->ga_bmval
);
535 nfsd4_decode_link(struct nfsd4_compoundargs
*argp
, struct nfsd4_link
*link
)
540 READ32(link
->li_namelen
);
541 READ_BUF(link
->li_namelen
);
542 SAVEMEM(link
->li_name
, link
->li_namelen
);
543 if ((status
= check_filename(link
->li_name
, link
->li_namelen
, nfserr_inval
)))
550 nfsd4_decode_lock(struct nfsd4_compoundargs
*argp
, struct nfsd4_lock
*lock
)
554 lock
->lk_replay_owner
= NULL
;
556 * type, reclaim(boolean), offset, length, new_lock_owner(boolean)
559 READ32(lock
->lk_type
);
560 if ((lock
->lk_type
< NFS4_READ_LT
) || (lock
->lk_type
> NFS4_WRITEW_LT
))
562 READ32(lock
->lk_reclaim
);
563 READ64(lock
->lk_offset
);
564 READ64(lock
->lk_length
);
565 READ32(lock
->lk_is_new
);
567 if (lock
->lk_is_new
) {
569 READ32(lock
->lk_new_open_seqid
);
570 status
= nfsd4_decode_stateid(argp
, &lock
->lk_new_open_stateid
);
573 READ_BUF(8 + sizeof(clientid_t
));
574 READ32(lock
->lk_new_lock_seqid
);
575 COPYMEM(&lock
->lk_new_clientid
, sizeof(clientid_t
));
576 READ32(lock
->lk_new_owner
.len
);
577 READ_BUF(lock
->lk_new_owner
.len
);
578 READMEM(lock
->lk_new_owner
.data
, lock
->lk_new_owner
.len
);
580 status
= nfsd4_decode_stateid(argp
, &lock
->lk_old_lock_stateid
);
584 READ32(lock
->lk_old_lock_seqid
);
591 nfsd4_decode_lockt(struct nfsd4_compoundargs
*argp
, struct nfsd4_lockt
*lockt
)
596 READ32(lockt
->lt_type
);
597 if((lockt
->lt_type
< NFS4_READ_LT
) || (lockt
->lt_type
> NFS4_WRITEW_LT
))
599 READ64(lockt
->lt_offset
);
600 READ64(lockt
->lt_length
);
601 COPYMEM(&lockt
->lt_clientid
, 8);
602 READ32(lockt
->lt_owner
.len
);
603 READ_BUF(lockt
->lt_owner
.len
);
604 READMEM(lockt
->lt_owner
.data
, lockt
->lt_owner
.len
);
610 nfsd4_decode_locku(struct nfsd4_compoundargs
*argp
, struct nfsd4_locku
*locku
)
614 locku
->lu_stateowner
= NULL
;
616 READ32(locku
->lu_type
);
617 if ((locku
->lu_type
< NFS4_READ_LT
) || (locku
->lu_type
> NFS4_WRITEW_LT
))
619 READ32(locku
->lu_seqid
);
620 status
= nfsd4_decode_stateid(argp
, &locku
->lu_stateid
);
624 READ64(locku
->lu_offset
);
625 READ64(locku
->lu_length
);
631 nfsd4_decode_lookup(struct nfsd4_compoundargs
*argp
, struct nfsd4_lookup
*lookup
)
636 READ32(lookup
->lo_len
);
637 READ_BUF(lookup
->lo_len
);
638 SAVEMEM(lookup
->lo_name
, lookup
->lo_len
);
639 if ((status
= check_filename(lookup
->lo_name
, lookup
->lo_len
, nfserr_noent
)))
646 nfsd4_decode_open(struct nfsd4_compoundargs
*argp
, struct nfsd4_open
*open
)
650 memset(open
->op_bmval
, 0, sizeof(open
->op_bmval
));
651 open
->op_iattr
.ia_valid
= 0;
652 open
->op_stateowner
= NULL
;
654 /* seqid, share_access, share_deny, clientid, ownerlen */
655 READ_BUF(16 + sizeof(clientid_t
));
656 READ32(open
->op_seqid
);
657 READ32(open
->op_share_access
);
658 READ32(open
->op_share_deny
);
659 COPYMEM(&open
->op_clientid
, sizeof(clientid_t
));
660 READ32(open
->op_owner
.len
);
662 /* owner, open_flag */
663 READ_BUF(open
->op_owner
.len
+ 4);
664 SAVEMEM(open
->op_owner
.data
, open
->op_owner
.len
);
665 READ32(open
->op_create
);
666 switch (open
->op_create
) {
667 case NFS4_OPEN_NOCREATE
:
669 case NFS4_OPEN_CREATE
:
671 READ32(open
->op_createmode
);
672 switch (open
->op_createmode
) {
673 case NFS4_CREATE_UNCHECKED
:
674 case NFS4_CREATE_GUARDED
:
675 status
= nfsd4_decode_fattr(argp
, open
->op_bmval
,
676 &open
->op_iattr
, &open
->op_acl
);
680 case NFS4_CREATE_EXCLUSIVE
:
682 COPYMEM(open
->op_verf
.data
, 8);
684 case NFS4_CREATE_EXCLUSIVE4_1
:
685 if (argp
->minorversion
< 1)
688 COPYMEM(open
->op_verf
.data
, 8);
689 status
= nfsd4_decode_fattr(argp
, open
->op_bmval
,
690 &open
->op_iattr
, &open
->op_acl
);
704 READ32(open
->op_claim_type
);
705 switch (open
->op_claim_type
) {
706 case NFS4_OPEN_CLAIM_NULL
:
707 case NFS4_OPEN_CLAIM_DELEGATE_PREV
:
709 READ32(open
->op_fname
.len
);
710 READ_BUF(open
->op_fname
.len
);
711 SAVEMEM(open
->op_fname
.data
, open
->op_fname
.len
);
712 if ((status
= check_filename(open
->op_fname
.data
, open
->op_fname
.len
, nfserr_inval
)))
715 case NFS4_OPEN_CLAIM_PREVIOUS
:
717 READ32(open
->op_delegate_type
);
719 case NFS4_OPEN_CLAIM_DELEGATE_CUR
:
720 status
= nfsd4_decode_stateid(argp
, &open
->op_delegate_stateid
);
724 READ32(open
->op_fname
.len
);
725 READ_BUF(open
->op_fname
.len
);
726 SAVEMEM(open
->op_fname
.data
, open
->op_fname
.len
);
727 if ((status
= check_filename(open
->op_fname
.data
, open
->op_fname
.len
, nfserr_inval
)))
738 nfsd4_decode_open_confirm(struct nfsd4_compoundargs
*argp
, struct nfsd4_open_confirm
*open_conf
)
742 open_conf
->oc_stateowner
= NULL
;
743 status
= nfsd4_decode_stateid(argp
, &open_conf
->oc_req_stateid
);
747 READ32(open_conf
->oc_seqid
);
753 nfsd4_decode_open_downgrade(struct nfsd4_compoundargs
*argp
, struct nfsd4_open_downgrade
*open_down
)
757 open_down
->od_stateowner
= NULL
;
758 status
= nfsd4_decode_stateid(argp
, &open_down
->od_stateid
);
762 READ32(open_down
->od_seqid
);
763 READ32(open_down
->od_share_access
);
764 READ32(open_down
->od_share_deny
);
770 nfsd4_decode_putfh(struct nfsd4_compoundargs
*argp
, struct nfsd4_putfh
*putfh
)
775 READ32(putfh
->pf_fhlen
);
776 if (putfh
->pf_fhlen
> NFS4_FHSIZE
)
778 READ_BUF(putfh
->pf_fhlen
);
779 SAVEMEM(putfh
->pf_fhval
, putfh
->pf_fhlen
);
785 nfsd4_decode_read(struct nfsd4_compoundargs
*argp
, struct nfsd4_read
*read
)
789 status
= nfsd4_decode_stateid(argp
, &read
->rd_stateid
);
793 READ64(read
->rd_offset
);
794 READ32(read
->rd_length
);
800 nfsd4_decode_readdir(struct nfsd4_compoundargs
*argp
, struct nfsd4_readdir
*readdir
)
805 READ64(readdir
->rd_cookie
);
806 COPYMEM(readdir
->rd_verf
.data
, sizeof(readdir
->rd_verf
.data
));
807 READ32(readdir
->rd_dircount
); /* just in case you needed a useless field... */
808 READ32(readdir
->rd_maxcount
);
809 if ((status
= nfsd4_decode_bitmap(argp
, readdir
->rd_bmval
)))
816 nfsd4_decode_remove(struct nfsd4_compoundargs
*argp
, struct nfsd4_remove
*remove
)
821 READ32(remove
->rm_namelen
);
822 READ_BUF(remove
->rm_namelen
);
823 SAVEMEM(remove
->rm_name
, remove
->rm_namelen
);
824 if ((status
= check_filename(remove
->rm_name
, remove
->rm_namelen
, nfserr_noent
)))
831 nfsd4_decode_rename(struct nfsd4_compoundargs
*argp
, struct nfsd4_rename
*rename
)
836 READ32(rename
->rn_snamelen
);
837 READ_BUF(rename
->rn_snamelen
+ 4);
838 SAVEMEM(rename
->rn_sname
, rename
->rn_snamelen
);
839 READ32(rename
->rn_tnamelen
);
840 READ_BUF(rename
->rn_tnamelen
);
841 SAVEMEM(rename
->rn_tname
, rename
->rn_tnamelen
);
842 if ((status
= check_filename(rename
->rn_sname
, rename
->rn_snamelen
, nfserr_noent
)))
844 if ((status
= check_filename(rename
->rn_tname
, rename
->rn_tnamelen
, nfserr_inval
)))
851 nfsd4_decode_renew(struct nfsd4_compoundargs
*argp
, clientid_t
*clientid
)
855 READ_BUF(sizeof(clientid_t
));
856 COPYMEM(clientid
, sizeof(clientid_t
));
862 nfsd4_decode_secinfo(struct nfsd4_compoundargs
*argp
,
863 struct nfsd4_secinfo
*secinfo
)
868 READ32(secinfo
->si_namelen
);
869 READ_BUF(secinfo
->si_namelen
);
870 SAVEMEM(secinfo
->si_name
, secinfo
->si_namelen
);
871 status
= check_filename(secinfo
->si_name
, secinfo
->si_namelen
,
879 nfsd4_decode_secinfo_no_name(struct nfsd4_compoundargs
*argp
,
880 struct nfsd4_secinfo_no_name
*sin
)
885 READ32(sin
->sin_style
);
890 nfsd4_decode_setattr(struct nfsd4_compoundargs
*argp
, struct nfsd4_setattr
*setattr
)
894 status
= nfsd4_decode_stateid(argp
, &setattr
->sa_stateid
);
897 return nfsd4_decode_fattr(argp
, setattr
->sa_bmval
, &setattr
->sa_iattr
,
902 nfsd4_decode_setclientid(struct nfsd4_compoundargs
*argp
, struct nfsd4_setclientid
*setclientid
)
907 COPYMEM(setclientid
->se_verf
.data
, 8);
908 READ32(setclientid
->se_namelen
);
910 READ_BUF(setclientid
->se_namelen
+ 8);
911 SAVEMEM(setclientid
->se_name
, setclientid
->se_namelen
);
912 READ32(setclientid
->se_callback_prog
);
913 READ32(setclientid
->se_callback_netid_len
);
915 READ_BUF(setclientid
->se_callback_netid_len
+ 4);
916 SAVEMEM(setclientid
->se_callback_netid_val
, setclientid
->se_callback_netid_len
);
917 READ32(setclientid
->se_callback_addr_len
);
919 READ_BUF(setclientid
->se_callback_addr_len
+ 4);
920 SAVEMEM(setclientid
->se_callback_addr_val
, setclientid
->se_callback_addr_len
);
921 READ32(setclientid
->se_callback_ident
);
927 nfsd4_decode_setclientid_confirm(struct nfsd4_compoundargs
*argp
, struct nfsd4_setclientid_confirm
*scd_c
)
931 READ_BUF(8 + sizeof(nfs4_verifier
));
932 COPYMEM(&scd_c
->sc_clientid
, 8);
933 COPYMEM(&scd_c
->sc_confirm
, sizeof(nfs4_verifier
));
938 /* Also used for NVERIFY */
940 nfsd4_decode_verify(struct nfsd4_compoundargs
*argp
, struct nfsd4_verify
*verify
)
943 struct nfsd4_compoundargs save
= {
946 .rqstp
= argp
->rqstp
,
949 struct iattr ve_iattr
; /* request */
950 struct nfs4_acl
*ve_acl
; /* request */
954 if ((status
= nfsd4_decode_bitmap(argp
, verify
->ve_bmval
)))
957 /* For convenience's sake, we compare raw xdr'd attributes in
958 * nfsd4_proc_verify; however we still decode here just to return
959 * correct error in case of bad xdr. */
961 status
= nfsd4_decode_fattr(ve_bmval
, &ve_iattr
, &ve_acl
);
962 if (status
== nfserr_inval
) {
963 status
= nfserrno(status
);
968 READ32(verify
->ve_attrlen
);
969 READ_BUF(verify
->ve_attrlen
);
970 SAVEMEM(verify
->ve_attrval
, verify
->ve_attrlen
);
976 nfsd4_decode_write(struct nfsd4_compoundargs
*argp
, struct nfsd4_write
*write
)
983 status
= nfsd4_decode_stateid(argp
, &write
->wr_stateid
);
987 READ64(write
->wr_offset
);
988 READ32(write
->wr_stable_how
);
989 if (write
->wr_stable_how
> 2)
991 READ32(write
->wr_buflen
);
993 /* Sorry .. no magic macros for this.. *
994 * READ_BUF(write->wr_buflen);
995 * SAVEMEM(write->wr_buf, write->wr_buflen);
997 avail
= (char*)argp
->end
- (char*)argp
->p
;
998 if (avail
+ argp
->pagelen
< write
->wr_buflen
) {
999 dprintk("NFSD: xdr error (%s:%d)\n",
1000 __FILE__
, __LINE__
);
1003 argp
->rqstp
->rq_vec
[0].iov_base
= p
;
1004 argp
->rqstp
->rq_vec
[0].iov_len
= avail
;
1006 len
= write
->wr_buflen
;
1007 while (len
> argp
->rqstp
->rq_vec
[v
].iov_len
) {
1008 len
-= argp
->rqstp
->rq_vec
[v
].iov_len
;
1010 argp
->rqstp
->rq_vec
[v
].iov_base
= page_address(argp
->pagelist
[0]);
1012 if (argp
->pagelen
>= PAGE_SIZE
) {
1013 argp
->rqstp
->rq_vec
[v
].iov_len
= PAGE_SIZE
;
1014 argp
->pagelen
-= PAGE_SIZE
;
1016 argp
->rqstp
->rq_vec
[v
].iov_len
= argp
->pagelen
;
1017 argp
->pagelen
-= len
;
1020 argp
->end
= (__be32
*) (argp
->rqstp
->rq_vec
[v
].iov_base
+ argp
->rqstp
->rq_vec
[v
].iov_len
);
1021 argp
->p
= (__be32
*) (argp
->rqstp
->rq_vec
[v
].iov_base
+ (XDR_QUADLEN(len
) << 2));
1022 argp
->rqstp
->rq_vec
[v
].iov_len
= len
;
1023 write
->wr_vlen
= v
+1;
1029 nfsd4_decode_release_lockowner(struct nfsd4_compoundargs
*argp
, struct nfsd4_release_lockowner
*rlockowner
)
1034 COPYMEM(&rlockowner
->rl_clientid
, sizeof(clientid_t
));
1035 READ32(rlockowner
->rl_owner
.len
);
1036 READ_BUF(rlockowner
->rl_owner
.len
);
1037 READMEM(rlockowner
->rl_owner
.data
, rlockowner
->rl_owner
.len
);
1039 if (argp
->minorversion
&& !zero_clientid(&rlockowner
->rl_clientid
))
1040 return nfserr_inval
;
1045 nfsd4_decode_exchange_id(struct nfsd4_compoundargs
*argp
,
1046 struct nfsd4_exchange_id
*exid
)
1051 READ_BUF(NFS4_VERIFIER_SIZE
);
1052 COPYMEM(exid
->verifier
.data
, NFS4_VERIFIER_SIZE
);
1055 READ32(exid
->clname
.len
);
1057 READ_BUF(exid
->clname
.len
);
1058 SAVEMEM(exid
->clname
.data
, exid
->clname
.len
);
1061 READ32(exid
->flags
);
1063 /* Ignore state_protect4_a */
1065 READ32(exid
->spa_how
);
1066 switch (exid
->spa_how
) {
1070 /* spo_must_enforce */
1073 READ_BUF(dummy
* 4);
1076 /* spo_must_allow */
1079 READ_BUF(dummy
* 4);
1086 READ_BUF(dummy
* 4);
1091 READ_BUF(dummy
* 4);
1094 /* ssp_hash_algs<> */
1101 p
+= XDR_QUADLEN(dummy
);
1104 /* ssp_encr_algs<> */
1111 p
+= XDR_QUADLEN(dummy
);
1114 /* ssp_window and ssp_num_gss_handles */
1123 /* Ignore Implementation ID */
1124 READ_BUF(4); /* nfs_impl_id4 array length */
1135 p
+= XDR_QUADLEN(dummy
);
1141 p
+= XDR_QUADLEN(dummy
);
1151 nfsd4_decode_create_session(struct nfsd4_compoundargs
*argp
,
1152 struct nfsd4_create_session
*sess
)
1162 COPYMEM(&sess
->clientid
, 8);
1163 READ32(sess
->seqid
);
1164 READ32(sess
->flags
);
1166 /* Fore channel attrs */
1168 READ32(dummy
); /* headerpadsz is always 0 */
1169 READ32(sess
->fore_channel
.maxreq_sz
);
1170 READ32(sess
->fore_channel
.maxresp_sz
);
1171 READ32(sess
->fore_channel
.maxresp_cached
);
1172 READ32(sess
->fore_channel
.maxops
);
1173 READ32(sess
->fore_channel
.maxreqs
);
1174 READ32(sess
->fore_channel
.nr_rdma_attrs
);
1175 if (sess
->fore_channel
.nr_rdma_attrs
== 1) {
1177 READ32(sess
->fore_channel
.rdma_attrs
);
1178 } else if (sess
->fore_channel
.nr_rdma_attrs
> 1) {
1179 dprintk("Too many fore channel attr bitmaps!\n");
1183 /* Back channel attrs */
1185 READ32(dummy
); /* headerpadsz is always 0 */
1186 READ32(sess
->back_channel
.maxreq_sz
);
1187 READ32(sess
->back_channel
.maxresp_sz
);
1188 READ32(sess
->back_channel
.maxresp_cached
);
1189 READ32(sess
->back_channel
.maxops
);
1190 READ32(sess
->back_channel
.maxreqs
);
1191 READ32(sess
->back_channel
.nr_rdma_attrs
);
1192 if (sess
->back_channel
.nr_rdma_attrs
== 1) {
1194 READ32(sess
->back_channel
.rdma_attrs
);
1195 } else if (sess
->back_channel
.nr_rdma_attrs
> 1) {
1196 dprintk("Too many back channel attr bitmaps!\n");
1201 READ32(sess
->callback_prog
);
1203 /* callback_sec_params4 */
1204 READ32(nr_secflavs
);
1205 for (i
= 0; i
< nr_secflavs
; ++i
) {
1210 /* Nothing to read */
1220 SAVEMEM(machine_name
, dummy
);
1230 READ_BUF(dummy
* 4);
1233 dprintk("RPC_AUTH_GSS callback secflavor "
1234 "not supported!\n");
1238 /* gcbp_handle_from_server */
1241 p
+= XDR_QUADLEN(dummy
);
1242 /* gcbp_handle_from_client */
1248 dprintk("Illegal callback secflavor\n");
1249 return nfserr_inval
;
1256 nfsd4_decode_destroy_session(struct nfsd4_compoundargs
*argp
,
1257 struct nfsd4_destroy_session
*destroy_session
)
1260 READ_BUF(NFS4_MAX_SESSIONID_LEN
);
1261 COPYMEM(destroy_session
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
1267 nfsd4_decode_free_stateid(struct nfsd4_compoundargs
*argp
,
1268 struct nfsd4_free_stateid
*free_stateid
)
1272 READ_BUF(sizeof(stateid_t
));
1273 READ32(free_stateid
->fr_stateid
.si_generation
);
1274 COPYMEM(&free_stateid
->fr_stateid
.si_opaque
, sizeof(stateid_opaque_t
));
1280 nfsd4_decode_sequence(struct nfsd4_compoundargs
*argp
,
1281 struct nfsd4_sequence
*seq
)
1285 READ_BUF(NFS4_MAX_SESSIONID_LEN
+ 16);
1286 COPYMEM(seq
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
1288 READ32(seq
->slotid
);
1289 READ32(seq
->maxslots
);
1290 READ32(seq
->cachethis
);
1296 nfsd4_decode_test_stateid(struct nfsd4_compoundargs
*argp
, struct nfsd4_test_stateid
*test_stateid
)
1298 unsigned int nbytes
;
1305 test_stateid
->ts_num_ids
= ntohl(*p
++);
1307 nbytes
= test_stateid
->ts_num_ids
* sizeof(stateid_t
);
1308 if (nbytes
> (u32
)((char *)argp
->end
- (char *)argp
->p
))
1311 test_stateid
->ts_saved_args
= argp
;
1312 save_buf(argp
, &test_stateid
->ts_savedp
);
1314 for (i
= 0; i
< test_stateid
->ts_num_ids
; i
++) {
1315 status
= nfsd4_decode_stateid(argp
, &si
);
1324 dprintk("NFSD: xdr error (%s:%d)\n", __FILE__
, __LINE__
);
1325 status
= nfserr_bad_xdr
;
1329 static __be32
nfsd4_decode_reclaim_complete(struct nfsd4_compoundargs
*argp
, struct nfsd4_reclaim_complete
*rc
)
1334 READ32(rc
->rca_one_fs
);
1340 nfsd4_decode_noop(struct nfsd4_compoundargs
*argp
, void *p
)
1346 nfsd4_decode_notsupp(struct nfsd4_compoundargs
*argp
, void *p
)
1348 return nfserr_notsupp
;
1351 typedef __be32(*nfsd4_dec
)(struct nfsd4_compoundargs
*argp
, void *);
1353 static nfsd4_dec nfsd4_dec_ops
[] = {
1354 [OP_ACCESS
] = (nfsd4_dec
)nfsd4_decode_access
,
1355 [OP_CLOSE
] = (nfsd4_dec
)nfsd4_decode_close
,
1356 [OP_COMMIT
] = (nfsd4_dec
)nfsd4_decode_commit
,
1357 [OP_CREATE
] = (nfsd4_dec
)nfsd4_decode_create
,
1358 [OP_DELEGPURGE
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1359 [OP_DELEGRETURN
] = (nfsd4_dec
)nfsd4_decode_delegreturn
,
1360 [OP_GETATTR
] = (nfsd4_dec
)nfsd4_decode_getattr
,
1361 [OP_GETFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1362 [OP_LINK
] = (nfsd4_dec
)nfsd4_decode_link
,
1363 [OP_LOCK
] = (nfsd4_dec
)nfsd4_decode_lock
,
1364 [OP_LOCKT
] = (nfsd4_dec
)nfsd4_decode_lockt
,
1365 [OP_LOCKU
] = (nfsd4_dec
)nfsd4_decode_locku
,
1366 [OP_LOOKUP
] = (nfsd4_dec
)nfsd4_decode_lookup
,
1367 [OP_LOOKUPP
] = (nfsd4_dec
)nfsd4_decode_noop
,
1368 [OP_NVERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
1369 [OP_OPEN
] = (nfsd4_dec
)nfsd4_decode_open
,
1370 [OP_OPENATTR
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1371 [OP_OPEN_CONFIRM
] = (nfsd4_dec
)nfsd4_decode_open_confirm
,
1372 [OP_OPEN_DOWNGRADE
] = (nfsd4_dec
)nfsd4_decode_open_downgrade
,
1373 [OP_PUTFH
] = (nfsd4_dec
)nfsd4_decode_putfh
,
1374 [OP_PUTPUBFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1375 [OP_PUTROOTFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1376 [OP_READ
] = (nfsd4_dec
)nfsd4_decode_read
,
1377 [OP_READDIR
] = (nfsd4_dec
)nfsd4_decode_readdir
,
1378 [OP_READLINK
] = (nfsd4_dec
)nfsd4_decode_noop
,
1379 [OP_REMOVE
] = (nfsd4_dec
)nfsd4_decode_remove
,
1380 [OP_RENAME
] = (nfsd4_dec
)nfsd4_decode_rename
,
1381 [OP_RENEW
] = (nfsd4_dec
)nfsd4_decode_renew
,
1382 [OP_RESTOREFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1383 [OP_SAVEFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1384 [OP_SECINFO
] = (nfsd4_dec
)nfsd4_decode_secinfo
,
1385 [OP_SETATTR
] = (nfsd4_dec
)nfsd4_decode_setattr
,
1386 [OP_SETCLIENTID
] = (nfsd4_dec
)nfsd4_decode_setclientid
,
1387 [OP_SETCLIENTID_CONFIRM
] = (nfsd4_dec
)nfsd4_decode_setclientid_confirm
,
1388 [OP_VERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
1389 [OP_WRITE
] = (nfsd4_dec
)nfsd4_decode_write
,
1390 [OP_RELEASE_LOCKOWNER
] = (nfsd4_dec
)nfsd4_decode_release_lockowner
,
1393 static nfsd4_dec nfsd41_dec_ops
[] = {
1394 [OP_ACCESS
] = (nfsd4_dec
)nfsd4_decode_access
,
1395 [OP_CLOSE
] = (nfsd4_dec
)nfsd4_decode_close
,
1396 [OP_COMMIT
] = (nfsd4_dec
)nfsd4_decode_commit
,
1397 [OP_CREATE
] = (nfsd4_dec
)nfsd4_decode_create
,
1398 [OP_DELEGPURGE
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1399 [OP_DELEGRETURN
] = (nfsd4_dec
)nfsd4_decode_delegreturn
,
1400 [OP_GETATTR
] = (nfsd4_dec
)nfsd4_decode_getattr
,
1401 [OP_GETFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1402 [OP_LINK
] = (nfsd4_dec
)nfsd4_decode_link
,
1403 [OP_LOCK
] = (nfsd4_dec
)nfsd4_decode_lock
,
1404 [OP_LOCKT
] = (nfsd4_dec
)nfsd4_decode_lockt
,
1405 [OP_LOCKU
] = (nfsd4_dec
)nfsd4_decode_locku
,
1406 [OP_LOOKUP
] = (nfsd4_dec
)nfsd4_decode_lookup
,
1407 [OP_LOOKUPP
] = (nfsd4_dec
)nfsd4_decode_noop
,
1408 [OP_NVERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
1409 [OP_OPEN
] = (nfsd4_dec
)nfsd4_decode_open
,
1410 [OP_OPENATTR
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1411 [OP_OPEN_CONFIRM
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1412 [OP_OPEN_DOWNGRADE
] = (nfsd4_dec
)nfsd4_decode_open_downgrade
,
1413 [OP_PUTFH
] = (nfsd4_dec
)nfsd4_decode_putfh
,
1414 [OP_PUTPUBFH
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1415 [OP_PUTROOTFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1416 [OP_READ
] = (nfsd4_dec
)nfsd4_decode_read
,
1417 [OP_READDIR
] = (nfsd4_dec
)nfsd4_decode_readdir
,
1418 [OP_READLINK
] = (nfsd4_dec
)nfsd4_decode_noop
,
1419 [OP_REMOVE
] = (nfsd4_dec
)nfsd4_decode_remove
,
1420 [OP_RENAME
] = (nfsd4_dec
)nfsd4_decode_rename
,
1421 [OP_RENEW
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1422 [OP_RESTOREFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1423 [OP_SAVEFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1424 [OP_SECINFO
] = (nfsd4_dec
)nfsd4_decode_secinfo
,
1425 [OP_SETATTR
] = (nfsd4_dec
)nfsd4_decode_setattr
,
1426 [OP_SETCLIENTID
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1427 [OP_SETCLIENTID_CONFIRM
]= (nfsd4_dec
)nfsd4_decode_notsupp
,
1428 [OP_VERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
1429 [OP_WRITE
] = (nfsd4_dec
)nfsd4_decode_write
,
1430 [OP_RELEASE_LOCKOWNER
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1432 /* new operations for NFSv4.1 */
1433 [OP_BACKCHANNEL_CTL
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1434 [OP_BIND_CONN_TO_SESSION
]= (nfsd4_dec
)nfsd4_decode_bind_conn_to_session
,
1435 [OP_EXCHANGE_ID
] = (nfsd4_dec
)nfsd4_decode_exchange_id
,
1436 [OP_CREATE_SESSION
] = (nfsd4_dec
)nfsd4_decode_create_session
,
1437 [OP_DESTROY_SESSION
] = (nfsd4_dec
)nfsd4_decode_destroy_session
,
1438 [OP_FREE_STATEID
] = (nfsd4_dec
)nfsd4_decode_free_stateid
,
1439 [OP_GET_DIR_DELEGATION
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1440 [OP_GETDEVICEINFO
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1441 [OP_GETDEVICELIST
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1442 [OP_LAYOUTCOMMIT
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1443 [OP_LAYOUTGET
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1444 [OP_LAYOUTRETURN
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1445 [OP_SECINFO_NO_NAME
] = (nfsd4_dec
)nfsd4_decode_secinfo_no_name
,
1446 [OP_SEQUENCE
] = (nfsd4_dec
)nfsd4_decode_sequence
,
1447 [OP_SET_SSV
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1448 [OP_TEST_STATEID
] = (nfsd4_dec
)nfsd4_decode_test_stateid
,
1449 [OP_WANT_DELEGATION
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1450 [OP_DESTROY_CLIENTID
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1451 [OP_RECLAIM_COMPLETE
] = (nfsd4_dec
)nfsd4_decode_reclaim_complete
,
1454 struct nfsd4_minorversion_ops
{
1455 nfsd4_dec
*decoders
;
1459 static struct nfsd4_minorversion_ops nfsd4_minorversion
[] = {
1460 [0] = { nfsd4_dec_ops
, ARRAY_SIZE(nfsd4_dec_ops
) },
1461 [1] = { nfsd41_dec_ops
, ARRAY_SIZE(nfsd41_dec_ops
) },
1465 nfsd4_decode_compound(struct nfsd4_compoundargs
*argp
)
1468 struct nfsd4_op
*op
;
1469 struct nfsd4_minorversion_ops
*ops
;
1470 bool cachethis
= false;
1474 * XXX: According to spec, we should check the tag
1475 * for UTF-8 compliance. I'm postponing this for
1476 * now because it seems that some clients do use
1480 READ32(argp
->taglen
);
1481 READ_BUF(argp
->taglen
+ 8);
1482 SAVEMEM(argp
->tag
, argp
->taglen
);
1483 READ32(argp
->minorversion
);
1484 READ32(argp
->opcnt
);
1486 if (argp
->taglen
> NFSD4_MAX_TAGLEN
)
1488 if (argp
->opcnt
> 100)
1491 if (argp
->opcnt
> ARRAY_SIZE(argp
->iops
)) {
1492 argp
->ops
= kmalloc(argp
->opcnt
* sizeof(*argp
->ops
), GFP_KERNEL
);
1494 argp
->ops
= argp
->iops
;
1495 dprintk("nfsd: couldn't allocate room for COMPOUND\n");
1500 if (argp
->minorversion
>= ARRAY_SIZE(nfsd4_minorversion
))
1503 ops
= &nfsd4_minorversion
[argp
->minorversion
];
1504 for (i
= 0; i
< argp
->opcnt
; i
++) {
1509 * We can't use READ_BUF() here because we need to handle
1510 * a missing opcode as an OP_WRITE + 1. So we need to check
1511 * to see if we're truly at the end of our buffer or if there
1512 * is another page we need to flip to.
1515 if (argp
->p
== argp
->end
) {
1516 if (argp
->pagelen
< 4) {
1517 /* There isn't an opcode still on the wire */
1518 op
->opnum
= OP_WRITE
+ 1;
1519 op
->status
= nfserr_bad_xdr
;
1525 * False alarm. We just hit a page boundary, but there
1526 * is still data available. Move pointer across page
1527 * boundary. *snip from READ_BUF*
1529 argp
->p
= page_address(argp
->pagelist
[0]);
1531 if (argp
->pagelen
< PAGE_SIZE
) {
1532 argp
->end
= argp
->p
+ (argp
->pagelen
>>2);
1535 argp
->end
= argp
->p
+ (PAGE_SIZE
>>2);
1536 argp
->pagelen
-= PAGE_SIZE
;
1539 op
->opnum
= ntohl(*argp
->p
++);
1541 if (op
->opnum
>= FIRST_NFS4_OP
&& op
->opnum
<= LAST_NFS4_OP
)
1542 op
->status
= ops
->decoders
[op
->opnum
](argp
, &op
->u
);
1544 op
->opnum
= OP_ILLEGAL
;
1545 op
->status
= nfserr_op_illegal
;
1553 * We'll try to cache the result in the DRC if any one
1554 * op in the compound wants to be cached:
1556 cachethis
|= nfsd4_cache_this_op(op
);
1558 /* Sessions make the DRC unnecessary: */
1559 if (argp
->minorversion
)
1561 argp
->rqstp
->rq_cachetype
= cachethis
? RC_REPLBUFF
: RC_NOCACHE
;
1566 #define WRITE32(n) *p++ = htonl(n)
1567 #define WRITE64(n) do { \
1568 *p++ = htonl((u32)((n) >> 32)); \
1569 *p++ = htonl((u32)(n)); \
1571 #define WRITEMEM(ptr,nbytes) do { if (nbytes > 0) { \
1572 *(p + XDR_QUADLEN(nbytes) -1) = 0; \
1573 memcpy(p, ptr, nbytes); \
1574 p += XDR_QUADLEN(nbytes); \
1577 static void write32(__be32
**p
, u32 n
)
1582 static void write64(__be32
**p
, u64 n
)
1584 write32(p
, (u32
)(n
>> 32));
1588 static void write_change(__be32
**p
, struct kstat
*stat
, struct inode
*inode
)
1590 if (IS_I_VERSION(inode
)) {
1591 write64(p
, inode
->i_version
);
1593 write32(p
, stat
->ctime
.tv_sec
);
1594 write32(p
, stat
->ctime
.tv_nsec
);
1598 static void write_cinfo(__be32
**p
, struct nfsd4_change_info
*c
)
1600 write32(p
, c
->atomic
);
1601 if (c
->change_supported
) {
1602 write64(p
, c
->before_change
);
1603 write64(p
, c
->after_change
);
1605 write32(p
, c
->before_ctime_sec
);
1606 write32(p
, c
->before_ctime_nsec
);
1607 write32(p
, c
->after_ctime_sec
);
1608 write32(p
, c
->after_ctime_nsec
);
1612 #define RESERVE_SPACE(nbytes) do { \
1614 BUG_ON(p + XDR_QUADLEN(nbytes) > resp->end); \
1616 #define ADJUST_ARGS() resp->p = p
1619 * Header routine to setup seqid operation replay cache
1621 #define ENCODE_SEQID_OP_HEAD \
1626 static bool seqid_mutating_err(__be32 err
)
1628 /* rfc 3530 section 8.1.5: */
1629 return err
!= nfserr_stale_clientid
&&
1630 err
!= nfserr_stale_stateid
&&
1631 err
!= nfserr_bad_stateid
&&
1632 err
!= nfserr_bad_seqid
&&
1633 err
!= nfserr_bad_xdr
&&
1634 err
!= nfserr_resource
&&
1635 err
!= nfserr_nofilehandle
;
1639 * Routine for encoding the result of a "seqid-mutating" NFSv4 operation. This
1640 * is where sequence id's are incremented, and the replay cache is filled.
1641 * Note that we increment sequence id's here, at the last moment, so we're sure
1642 * we know whether the error to be returned is a sequence id mutating error.
1645 #define ENCODE_SEQID_OP_TAIL(stateowner) do { \
1646 if (seqid_mutating_err(nfserr) && stateowner) { \
1647 stateowner->so_seqid++; \
1648 stateowner->so_replay.rp_status = nfserr; \
1649 stateowner->so_replay.rp_buflen = \
1650 (((char *)(resp)->p - (char *)save)); \
1651 memcpy(stateowner->so_replay.rp_buf, save, \
1652 stateowner->so_replay.rp_buflen); \
1655 /* Encode as an array of strings the string given with components
1658 static __be32
nfsd4_encode_components(char sep
, char *components
,
1659 __be32
**pp
, int *buflen
)
1663 int strlen
, count
=0;
1666 dprintk("nfsd4_encode_components(%s)\n", components
);
1667 if ((*buflen
-= 4) < 0)
1668 return nfserr_resource
;
1669 WRITE32(0); /* We will fill this in with @count later */
1670 end
= str
= components
;
1672 for (; *end
&& (*end
!= sep
); end
++)
1673 ; /* Point to end of component */
1676 if ((*buflen
-= ((XDR_QUADLEN(strlen
) << 2) + 4)) < 0)
1677 return nfserr_resource
;
1679 WRITEMEM(str
, strlen
);
1693 * encode a location element of a fs_locations structure
1695 static __be32
nfsd4_encode_fs_location4(struct nfsd4_fs_location
*location
,
1696 __be32
**pp
, int *buflen
)
1701 status
= nfsd4_encode_components(':', location
->hosts
, &p
, buflen
);
1704 status
= nfsd4_encode_components('/', location
->path
, &p
, buflen
);
1712 * Return the path to an export point in the pseudo filesystem namespace
1713 * Returned string is safe to use as long as the caller holds a reference
1716 static char *nfsd4_path(struct svc_rqst
*rqstp
, struct svc_export
*exp
, __be32
*stat
)
1718 struct svc_fh tmp_fh
;
1719 char *path
= NULL
, *rootpath
;
1722 fh_init(&tmp_fh
, NFS4_FHSIZE
);
1723 *stat
= exp_pseudoroot(rqstp
, &tmp_fh
);
1726 rootpath
= tmp_fh
.fh_export
->ex_pathname
;
1728 path
= exp
->ex_pathname
;
1730 rootlen
= strlen(rootpath
);
1731 if (strncmp(path
, rootpath
, rootlen
)) {
1732 dprintk("nfsd: fs_locations failed;"
1733 "%s is not contained in %s\n", path
, rootpath
);
1734 *stat
= nfserr_notsupp
;
1745 * encode a fs_locations structure
1747 static __be32
nfsd4_encode_fs_locations(struct svc_rqst
*rqstp
,
1748 struct svc_export
*exp
,
1749 __be32
**pp
, int *buflen
)
1754 struct nfsd4_fs_locations
*fslocs
= &exp
->ex_fslocs
;
1755 char *root
= nfsd4_path(rqstp
, exp
, &status
);
1759 status
= nfsd4_encode_components('/', root
, &p
, buflen
);
1762 if ((*buflen
-= 4) < 0)
1763 return nfserr_resource
;
1764 WRITE32(fslocs
->locations_count
);
1765 for (i
=0; i
<fslocs
->locations_count
; i
++) {
1766 status
= nfsd4_encode_fs_location4(&fslocs
->locations
[i
],
1775 static u32
nfs4_file_type(umode_t mode
)
1777 switch (mode
& S_IFMT
) {
1778 case S_IFIFO
: return NF4FIFO
;
1779 case S_IFCHR
: return NF4CHR
;
1780 case S_IFDIR
: return NF4DIR
;
1781 case S_IFBLK
: return NF4BLK
;
1782 case S_IFLNK
: return NF4LNK
;
1783 case S_IFREG
: return NF4REG
;
1784 case S_IFSOCK
: return NF4SOCK
;
1785 default: return NF4BAD
;
1790 nfsd4_encode_name(struct svc_rqst
*rqstp
, int whotype
, uid_t id
, int group
,
1791 __be32
**p
, int *buflen
)
1795 if (*buflen
< (XDR_QUADLEN(IDMAP_NAMESZ
) << 2) + 4)
1796 return nfserr_resource
;
1797 if (whotype
!= NFS4_ACL_WHO_NAMED
)
1798 status
= nfs4_acl_write_who(whotype
, (u8
*)(*p
+ 1));
1800 status
= nfsd_map_gid_to_name(rqstp
, id
, (u8
*)(*p
+ 1));
1802 status
= nfsd_map_uid_to_name(rqstp
, id
, (u8
*)(*p
+ 1));
1804 return nfserrno(status
);
1805 *p
= xdr_encode_opaque(*p
, NULL
, status
);
1806 *buflen
-= (XDR_QUADLEN(status
) << 2) + 4;
1807 BUG_ON(*buflen
< 0);
1811 static inline __be32
1812 nfsd4_encode_user(struct svc_rqst
*rqstp
, uid_t uid
, __be32
**p
, int *buflen
)
1814 return nfsd4_encode_name(rqstp
, NFS4_ACL_WHO_NAMED
, uid
, 0, p
, buflen
);
1817 static inline __be32
1818 nfsd4_encode_group(struct svc_rqst
*rqstp
, uid_t gid
, __be32
**p
, int *buflen
)
1820 return nfsd4_encode_name(rqstp
, NFS4_ACL_WHO_NAMED
, gid
, 1, p
, buflen
);
1823 static inline __be32
1824 nfsd4_encode_aclname(struct svc_rqst
*rqstp
, int whotype
, uid_t id
, int group
,
1825 __be32
**p
, int *buflen
)
1827 return nfsd4_encode_name(rqstp
, whotype
, id
, group
, p
, buflen
);
1830 #define WORD0_ABSENT_FS_ATTRS (FATTR4_WORD0_FS_LOCATIONS | FATTR4_WORD0_FSID | \
1831 FATTR4_WORD0_RDATTR_ERROR)
1832 #define WORD1_ABSENT_FS_ATTRS FATTR4_WORD1_MOUNTED_ON_FILEID
1834 static __be32
fattr_handle_absent_fs(u32
*bmval0
, u32
*bmval1
, u32
*rdattr_err
)
1836 /* As per referral draft: */
1837 if (*bmval0
& ~WORD0_ABSENT_FS_ATTRS
||
1838 *bmval1
& ~WORD1_ABSENT_FS_ATTRS
) {
1839 if (*bmval0
& FATTR4_WORD0_RDATTR_ERROR
||
1840 *bmval0
& FATTR4_WORD0_FS_LOCATIONS
)
1841 *rdattr_err
= NFSERR_MOVED
;
1843 return nfserr_moved
;
1845 *bmval0
&= WORD0_ABSENT_FS_ATTRS
;
1846 *bmval1
&= WORD1_ABSENT_FS_ATTRS
;
1851 * Note: @fhp can be NULL; in this case, we might have to compose the filehandle
1854 * @countp is the buffer size in _words_; upon successful return this becomes
1855 * replaced with the number of words written.
1858 nfsd4_encode_fattr(struct svc_fh
*fhp
, struct svc_export
*exp
,
1859 struct dentry
*dentry
, __be32
*buffer
, int *countp
, u32
*bmval
,
1860 struct svc_rqst
*rqstp
, int ignore_crossmnt
)
1862 u32 bmval0
= bmval
[0];
1863 u32 bmval1
= bmval
[1];
1864 u32 bmval2
= bmval
[2];
1866 struct svc_fh tempfh
;
1867 struct kstatfs statfs
;
1868 int buflen
= *countp
<< 2;
1877 struct nfs4_acl
*acl
= NULL
;
1878 struct nfsd4_compoundres
*resp
= rqstp
->rq_resp
;
1879 u32 minorversion
= resp
->cstate
.minorversion
;
1880 struct path path
= {
1881 .mnt
= exp
->ex_path
.mnt
,
1885 BUG_ON(bmval1
& NFSD_WRITEONLY_ATTRS_WORD1
);
1886 BUG_ON(bmval0
& ~nfsd_suppattrs0(minorversion
));
1887 BUG_ON(bmval1
& ~nfsd_suppattrs1(minorversion
));
1888 BUG_ON(bmval2
& ~nfsd_suppattrs2(minorversion
));
1890 if (exp
->ex_fslocs
.migrated
) {
1892 status
= fattr_handle_absent_fs(&bmval0
, &bmval1
, &rdattr_err
);
1897 err
= vfs_getattr(exp
->ex_path
.mnt
, dentry
, &stat
);
1900 if ((bmval0
& (FATTR4_WORD0_FILES_FREE
| FATTR4_WORD0_FILES_TOTAL
|
1901 FATTR4_WORD0_MAXNAME
)) ||
1902 (bmval1
& (FATTR4_WORD1_SPACE_AVAIL
| FATTR4_WORD1_SPACE_FREE
|
1903 FATTR4_WORD1_SPACE_TOTAL
))) {
1904 err
= vfs_statfs(&path
, &statfs
);
1908 if ((bmval0
& (FATTR4_WORD0_FILEHANDLE
| FATTR4_WORD0_FSID
)) && !fhp
) {
1909 fh_init(&tempfh
, NFS4_FHSIZE
);
1910 status
= fh_compose(&tempfh
, exp
, dentry
, NULL
);
1915 if (bmval0
& (FATTR4_WORD0_ACL
| FATTR4_WORD0_ACLSUPPORT
1916 | FATTR4_WORD0_SUPPORTED_ATTRS
)) {
1917 err
= nfsd4_get_nfs4_acl(rqstp
, dentry
, &acl
);
1918 aclsupport
= (err
== 0);
1919 if (bmval0
& FATTR4_WORD0_ACL
) {
1920 if (err
== -EOPNOTSUPP
)
1921 bmval0
&= ~FATTR4_WORD0_ACL
;
1922 else if (err
== -EINVAL
) {
1923 status
= nfserr_attrnotsupp
;
1925 } else if (err
!= 0)
1931 if ((buflen
-= 16) < 0)
1937 } else if (bmval1
) {
1938 if ((buflen
-= 12) < 0)
1944 if ((buflen
-= 8) < 0)
1949 attrlenp
= p
++; /* to be backfilled later */
1951 if (bmval0
& FATTR4_WORD0_SUPPORTED_ATTRS
) {
1952 u32 word0
= nfsd_suppattrs0(minorversion
);
1953 u32 word1
= nfsd_suppattrs1(minorversion
);
1954 u32 word2
= nfsd_suppattrs2(minorversion
);
1957 word0
&= ~FATTR4_WORD0_ACL
;
1959 if ((buflen
-= 12) < 0)
1965 if ((buflen
-= 16) < 0)
1973 if (bmval0
& FATTR4_WORD0_TYPE
) {
1974 if ((buflen
-= 4) < 0)
1976 dummy
= nfs4_file_type(stat
.mode
);
1977 if (dummy
== NF4BAD
)
1978 goto out_serverfault
;
1981 if (bmval0
& FATTR4_WORD0_FH_EXPIRE_TYPE
) {
1982 if ((buflen
-= 4) < 0)
1984 if (exp
->ex_flags
& NFSEXP_NOSUBTREECHECK
)
1985 WRITE32(NFS4_FH_PERSISTENT
);
1987 WRITE32(NFS4_FH_PERSISTENT
|NFS4_FH_VOL_RENAME
);
1989 if (bmval0
& FATTR4_WORD0_CHANGE
) {
1990 if ((buflen
-= 8) < 0)
1992 write_change(&p
, &stat
, dentry
->d_inode
);
1994 if (bmval0
& FATTR4_WORD0_SIZE
) {
1995 if ((buflen
-= 8) < 0)
1999 if (bmval0
& FATTR4_WORD0_LINK_SUPPORT
) {
2000 if ((buflen
-= 4) < 0)
2004 if (bmval0
& FATTR4_WORD0_SYMLINK_SUPPORT
) {
2005 if ((buflen
-= 4) < 0)
2009 if (bmval0
& FATTR4_WORD0_NAMED_ATTR
) {
2010 if ((buflen
-= 4) < 0)
2014 if (bmval0
& FATTR4_WORD0_FSID
) {
2015 if ((buflen
-= 16) < 0)
2017 if (exp
->ex_fslocs
.migrated
) {
2018 WRITE64(NFS4_REFERRAL_FSID_MAJOR
);
2019 WRITE64(NFS4_REFERRAL_FSID_MINOR
);
2020 } else switch(fsid_source(fhp
)) {
2021 case FSIDSOURCE_FSID
:
2022 WRITE64((u64
)exp
->ex_fsid
);
2025 case FSIDSOURCE_DEV
:
2027 WRITE32(MAJOR(stat
.dev
));
2029 WRITE32(MINOR(stat
.dev
));
2031 case FSIDSOURCE_UUID
:
2032 WRITEMEM(exp
->ex_uuid
, 16);
2036 if (bmval0
& FATTR4_WORD0_UNIQUE_HANDLES
) {
2037 if ((buflen
-= 4) < 0)
2041 if (bmval0
& FATTR4_WORD0_LEASE_TIME
) {
2042 if ((buflen
-= 4) < 0)
2044 WRITE32(nfsd4_lease
);
2046 if (bmval0
& FATTR4_WORD0_RDATTR_ERROR
) {
2047 if ((buflen
-= 4) < 0)
2049 WRITE32(rdattr_err
);
2051 if (bmval0
& FATTR4_WORD0_ACL
) {
2052 struct nfs4_ace
*ace
;
2055 if ((buflen
-= 4) < 0)
2061 if ((buflen
-= 4) < 0)
2063 WRITE32(acl
->naces
);
2065 for (ace
= acl
->aces
; ace
< acl
->aces
+ acl
->naces
; ace
++) {
2066 if ((buflen
-= 4*3) < 0)
2070 WRITE32(ace
->access_mask
& NFS4_ACE_MASK_ALL
);
2071 status
= nfsd4_encode_aclname(rqstp
, ace
->whotype
,
2072 ace
->who
, ace
->flag
& NFS4_ACE_IDENTIFIER_GROUP
,
2074 if (status
== nfserr_resource
)
2081 if (bmval0
& FATTR4_WORD0_ACLSUPPORT
) {
2082 if ((buflen
-= 4) < 0)
2084 WRITE32(aclsupport
?
2085 ACL4_SUPPORT_ALLOW_ACL
|ACL4_SUPPORT_DENY_ACL
: 0);
2087 if (bmval0
& FATTR4_WORD0_CANSETTIME
) {
2088 if ((buflen
-= 4) < 0)
2092 if (bmval0
& FATTR4_WORD0_CASE_INSENSITIVE
) {
2093 if ((buflen
-= 4) < 0)
2097 if (bmval0
& FATTR4_WORD0_CASE_PRESERVING
) {
2098 if ((buflen
-= 4) < 0)
2102 if (bmval0
& FATTR4_WORD0_CHOWN_RESTRICTED
) {
2103 if ((buflen
-= 4) < 0)
2107 if (bmval0
& FATTR4_WORD0_FILEHANDLE
) {
2108 buflen
-= (XDR_QUADLEN(fhp
->fh_handle
.fh_size
) << 2) + 4;
2111 WRITE32(fhp
->fh_handle
.fh_size
);
2112 WRITEMEM(&fhp
->fh_handle
.fh_base
, fhp
->fh_handle
.fh_size
);
2114 if (bmval0
& FATTR4_WORD0_FILEID
) {
2115 if ((buflen
-= 8) < 0)
2119 if (bmval0
& FATTR4_WORD0_FILES_AVAIL
) {
2120 if ((buflen
-= 8) < 0)
2122 WRITE64((u64
) statfs
.f_ffree
);
2124 if (bmval0
& FATTR4_WORD0_FILES_FREE
) {
2125 if ((buflen
-= 8) < 0)
2127 WRITE64((u64
) statfs
.f_ffree
);
2129 if (bmval0
& FATTR4_WORD0_FILES_TOTAL
) {
2130 if ((buflen
-= 8) < 0)
2132 WRITE64((u64
) statfs
.f_files
);
2134 if (bmval0
& FATTR4_WORD0_FS_LOCATIONS
) {
2135 status
= nfsd4_encode_fs_locations(rqstp
, exp
, &p
, &buflen
);
2136 if (status
== nfserr_resource
)
2141 if (bmval0
& FATTR4_WORD0_HOMOGENEOUS
) {
2142 if ((buflen
-= 4) < 0)
2146 if (bmval0
& FATTR4_WORD0_MAXFILESIZE
) {
2147 if ((buflen
-= 8) < 0)
2151 if (bmval0
& FATTR4_WORD0_MAXLINK
) {
2152 if ((buflen
-= 4) < 0)
2156 if (bmval0
& FATTR4_WORD0_MAXNAME
) {
2157 if ((buflen
-= 4) < 0)
2159 WRITE32(statfs
.f_namelen
);
2161 if (bmval0
& FATTR4_WORD0_MAXREAD
) {
2162 if ((buflen
-= 8) < 0)
2164 WRITE64((u64
) svc_max_payload(rqstp
));
2166 if (bmval0
& FATTR4_WORD0_MAXWRITE
) {
2167 if ((buflen
-= 8) < 0)
2169 WRITE64((u64
) svc_max_payload(rqstp
));
2171 if (bmval1
& FATTR4_WORD1_MODE
) {
2172 if ((buflen
-= 4) < 0)
2174 WRITE32(stat
.mode
& S_IALLUGO
);
2176 if (bmval1
& FATTR4_WORD1_NO_TRUNC
) {
2177 if ((buflen
-= 4) < 0)
2181 if (bmval1
& FATTR4_WORD1_NUMLINKS
) {
2182 if ((buflen
-= 4) < 0)
2184 WRITE32(stat
.nlink
);
2186 if (bmval1
& FATTR4_WORD1_OWNER
) {
2187 status
= nfsd4_encode_user(rqstp
, stat
.uid
, &p
, &buflen
);
2188 if (status
== nfserr_resource
)
2193 if (bmval1
& FATTR4_WORD1_OWNER_GROUP
) {
2194 status
= nfsd4_encode_group(rqstp
, stat
.gid
, &p
, &buflen
);
2195 if (status
== nfserr_resource
)
2200 if (bmval1
& FATTR4_WORD1_RAWDEV
) {
2201 if ((buflen
-= 8) < 0)
2203 WRITE32((u32
) MAJOR(stat
.rdev
));
2204 WRITE32((u32
) MINOR(stat
.rdev
));
2206 if (bmval1
& FATTR4_WORD1_SPACE_AVAIL
) {
2207 if ((buflen
-= 8) < 0)
2209 dummy64
= (u64
)statfs
.f_bavail
* (u64
)statfs
.f_bsize
;
2212 if (bmval1
& FATTR4_WORD1_SPACE_FREE
) {
2213 if ((buflen
-= 8) < 0)
2215 dummy64
= (u64
)statfs
.f_bfree
* (u64
)statfs
.f_bsize
;
2218 if (bmval1
& FATTR4_WORD1_SPACE_TOTAL
) {
2219 if ((buflen
-= 8) < 0)
2221 dummy64
= (u64
)statfs
.f_blocks
* (u64
)statfs
.f_bsize
;
2224 if (bmval1
& FATTR4_WORD1_SPACE_USED
) {
2225 if ((buflen
-= 8) < 0)
2227 dummy64
= (u64
)stat
.blocks
<< 9;
2230 if (bmval1
& FATTR4_WORD1_TIME_ACCESS
) {
2231 if ((buflen
-= 12) < 0)
2234 WRITE32(stat
.atime
.tv_sec
);
2235 WRITE32(stat
.atime
.tv_nsec
);
2237 if (bmval1
& FATTR4_WORD1_TIME_DELTA
) {
2238 if ((buflen
-= 12) < 0)
2244 if (bmval1
& FATTR4_WORD1_TIME_METADATA
) {
2245 if ((buflen
-= 12) < 0)
2248 WRITE32(stat
.ctime
.tv_sec
);
2249 WRITE32(stat
.ctime
.tv_nsec
);
2251 if (bmval1
& FATTR4_WORD1_TIME_MODIFY
) {
2252 if ((buflen
-= 12) < 0)
2255 WRITE32(stat
.mtime
.tv_sec
);
2256 WRITE32(stat
.mtime
.tv_nsec
);
2258 if (bmval1
& FATTR4_WORD1_MOUNTED_ON_FILEID
) {
2259 if ((buflen
-= 8) < 0)
2262 * Get parent's attributes if not ignoring crossmount
2263 * and this is the root of a cross-mounted filesystem.
2265 if (ignore_crossmnt
== 0 &&
2266 dentry
== exp
->ex_path
.mnt
->mnt_root
) {
2267 struct path path
= exp
->ex_path
;
2269 while (follow_up(&path
)) {
2270 if (path
.dentry
!= path
.mnt
->mnt_root
)
2273 err
= vfs_getattr(path
.mnt
, path
.dentry
, &stat
);
2280 if (bmval2
& FATTR4_WORD2_SUPPATTR_EXCLCREAT
) {
2282 WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD0
);
2283 WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD1
);
2284 WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD2
);
2287 *attrlenp
= htonl((char *)p
- (char *)attrlenp
- 4);
2288 *countp
= p
- buffer
;
2297 status
= nfserrno(err
);
2301 status
= nfserr_resource
;
2304 status
= nfserr_serverfault
;
2308 static inline int attributes_need_mount(u32
*bmval
)
2310 if (bmval
[0] & ~(FATTR4_WORD0_RDATTR_ERROR
| FATTR4_WORD0_LEASE_TIME
))
2312 if (bmval
[1] & ~FATTR4_WORD1_MOUNTED_ON_FILEID
)
2318 nfsd4_encode_dirent_fattr(struct nfsd4_readdir
*cd
,
2319 const char *name
, int namlen
, __be32
*p
, int *buflen
)
2321 struct svc_export
*exp
= cd
->rd_fhp
->fh_export
;
2322 struct dentry
*dentry
;
2324 int ignore_crossmnt
= 0;
2326 dentry
= lookup_one_len(name
, cd
->rd_fhp
->fh_dentry
, namlen
);
2328 return nfserrno(PTR_ERR(dentry
));
2329 if (!dentry
->d_inode
) {
2331 * nfsd_buffered_readdir drops the i_mutex between
2332 * readdir and calling this callback, leaving a window
2333 * where this directory entry could have gone away.
2336 return nfserr_noent
;
2341 * In the case of a mountpoint, the client may be asking for
2342 * attributes that are only properties of the underlying filesystem
2343 * as opposed to the cross-mounted file system. In such a case,
2344 * we will not follow the cross mount and will fill the attribtutes
2345 * directly from the mountpoint dentry.
2347 if (nfsd_mountpoint(dentry
, exp
)) {
2350 if (!(exp
->ex_flags
& NFSEXP_V4ROOT
)
2351 && !attributes_need_mount(cd
->rd_bmval
)) {
2352 ignore_crossmnt
= 1;
2356 * Why the heck aren't we just using nfsd_lookup??
2357 * Different "."/".." handling? Something else?
2358 * At least, add a comment here to explain....
2360 err
= nfsd_cross_mnt(cd
->rd_rqstp
, &dentry
, &exp
);
2362 nfserr
= nfserrno(err
);
2365 nfserr
= check_nfsd_access(exp
, cd
->rd_rqstp
);
2371 nfserr
= nfsd4_encode_fattr(NULL
, exp
, dentry
, p
, buflen
, cd
->rd_bmval
,
2372 cd
->rd_rqstp
, ignore_crossmnt
);
2380 nfsd4_encode_rdattr_error(__be32
*p
, int buflen
, __be32 nfserr
)
2387 *p
++ = htonl(FATTR4_WORD0_RDATTR_ERROR
); /* bmval0 */
2388 *p
++ = htonl(0); /* bmval1 */
2391 *p
++ = nfserr
; /* no htonl */
2392 *attrlenp
= htonl((char *)p
- (char *)attrlenp
- 4);
2397 nfsd4_encode_dirent(void *ccdv
, const char *name
, int namlen
,
2398 loff_t offset
, u64 ino
, unsigned int d_type
)
2400 struct readdir_cd
*ccd
= ccdv
;
2401 struct nfsd4_readdir
*cd
= container_of(ccd
, struct nfsd4_readdir
, common
);
2403 __be32
*p
= cd
->buffer
;
2405 __be32 nfserr
= nfserr_toosmall
;
2407 /* In nfsv4, "." and ".." never make it onto the wire.. */
2408 if (name
&& isdotent(name
, namlen
)) {
2409 cd
->common
.err
= nfs_ok
;
2414 xdr_encode_hyper(cd
->offset
, (u64
) offset
);
2416 buflen
= cd
->buflen
- 4 - XDR_QUADLEN(namlen
);
2420 *p
++ = xdr_one
; /* mark entry present */
2422 p
= xdr_encode_hyper(p
, NFS_OFFSET_MAX
); /* offset of next entry */
2423 p
= xdr_encode_array(p
, name
, namlen
); /* name length & name */
2425 nfserr
= nfsd4_encode_dirent_fattr(cd
, name
, namlen
, p
, &buflen
);
2430 case nfserr_resource
:
2431 nfserr
= nfserr_toosmall
;
2437 * If the client requested the RDATTR_ERROR attribute,
2438 * we stuff the error code into this attribute
2439 * and continue. If this attribute was not requested,
2440 * then in accordance with the spec, we fail the
2441 * entire READDIR operation(!)
2443 if (!(cd
->rd_bmval
[0] & FATTR4_WORD0_RDATTR_ERROR
))
2445 p
= nfsd4_encode_rdattr_error(p
, buflen
, nfserr
);
2447 nfserr
= nfserr_toosmall
;
2451 cd
->buflen
-= (p
- cd
->buffer
);
2453 cd
->offset
= cookiep
;
2455 cd
->common
.err
= nfs_ok
;
2458 cd
->common
.err
= nfserr
;
2463 nfsd4_encode_stateid(struct nfsd4_compoundres
*resp
, stateid_t
*sid
)
2467 RESERVE_SPACE(sizeof(stateid_t
));
2468 WRITE32(sid
->si_generation
);
2469 WRITEMEM(&sid
->si_opaque
, sizeof(stateid_opaque_t
));
2474 nfsd4_encode_access(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_access
*access
)
2480 WRITE32(access
->ac_supported
);
2481 WRITE32(access
->ac_resp_access
);
2487 static __be32
nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_bind_conn_to_session
*bcts
)
2492 RESERVE_SPACE(NFS4_MAX_SESSIONID_LEN
+ 8);
2493 WRITEMEM(bcts
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
2503 nfsd4_encode_close(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_close
*close
)
2505 ENCODE_SEQID_OP_HEAD
;
2508 nfsd4_encode_stateid(resp
, &close
->cl_stateid
);
2510 ENCODE_SEQID_OP_TAIL(close
->cl_stateowner
);
2516 nfsd4_encode_commit(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_commit
*commit
)
2522 WRITEMEM(commit
->co_verf
.data
, 8);
2529 nfsd4_encode_create(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_create
*create
)
2535 write_cinfo(&p
, &create
->cr_cinfo
);
2537 WRITE32(create
->cr_bmval
[0]);
2538 WRITE32(create
->cr_bmval
[1]);
2545 nfsd4_encode_getattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_getattr
*getattr
)
2547 struct svc_fh
*fhp
= getattr
->ga_fhp
;
2553 buflen
= resp
->end
- resp
->p
- (COMPOUND_ERR_SLACK_SPACE
>> 2);
2554 nfserr
= nfsd4_encode_fattr(fhp
, fhp
->fh_export
, fhp
->fh_dentry
,
2555 resp
->p
, &buflen
, getattr
->ga_bmval
,
2563 nfsd4_encode_getfh(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct svc_fh
**fhpp
)
2565 struct svc_fh
*fhp
= *fhpp
;
2570 len
= fhp
->fh_handle
.fh_size
;
2571 RESERVE_SPACE(len
+ 4);
2573 WRITEMEM(&fhp
->fh_handle
.fh_base
, len
);
2580 * Including all fields other than the name, a LOCK4denied structure requires
2581 * 8(clientid) + 4(namelen) + 8(offset) + 8(length) + 4(type) = 32 bytes.
2584 nfsd4_encode_lock_denied(struct nfsd4_compoundres
*resp
, struct nfsd4_lock_denied
*ld
)
2588 RESERVE_SPACE(32 + XDR_LEN(ld
->ld_sop
? ld
->ld_sop
->so_owner
.len
: 0));
2589 WRITE64(ld
->ld_start
);
2590 WRITE64(ld
->ld_length
);
2591 WRITE32(ld
->ld_type
);
2593 WRITEMEM(&ld
->ld_clientid
, 8);
2594 WRITE32(ld
->ld_sop
->so_owner
.len
);
2595 WRITEMEM(ld
->ld_sop
->so_owner
.data
, ld
->ld_sop
->so_owner
.len
);
2596 kref_put(&ld
->ld_sop
->so_ref
, nfs4_free_stateowner
);
2597 } else { /* non - nfsv4 lock in conflict, no clientid nor owner */
2598 WRITE64((u64
)0); /* clientid */
2599 WRITE32(0); /* length of owner name */
2605 nfsd4_encode_lock(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_lock
*lock
)
2607 ENCODE_SEQID_OP_HEAD
;
2610 nfsd4_encode_stateid(resp
, &lock
->lk_resp_stateid
);
2611 else if (nfserr
== nfserr_denied
)
2612 nfsd4_encode_lock_denied(resp
, &lock
->lk_denied
);
2614 ENCODE_SEQID_OP_TAIL(lock
->lk_replay_owner
);
2619 nfsd4_encode_lockt(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_lockt
*lockt
)
2621 if (nfserr
== nfserr_denied
)
2622 nfsd4_encode_lock_denied(resp
, &lockt
->lt_denied
);
2627 nfsd4_encode_locku(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_locku
*locku
)
2629 ENCODE_SEQID_OP_HEAD
;
2632 nfsd4_encode_stateid(resp
, &locku
->lu_stateid
);
2634 ENCODE_SEQID_OP_TAIL(locku
->lu_stateowner
);
2640 nfsd4_encode_link(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_link
*link
)
2646 write_cinfo(&p
, &link
->li_cinfo
);
2654 nfsd4_encode_open(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open
*open
)
2657 ENCODE_SEQID_OP_HEAD
;
2662 nfsd4_encode_stateid(resp
, &open
->op_stateid
);
2664 write_cinfo(&p
, &open
->op_cinfo
);
2665 WRITE32(open
->op_rflags
);
2667 WRITE32(open
->op_bmval
[0]);
2668 WRITE32(open
->op_bmval
[1]);
2669 WRITE32(open
->op_delegate_type
);
2672 switch (open
->op_delegate_type
) {
2673 case NFS4_OPEN_DELEGATE_NONE
:
2675 case NFS4_OPEN_DELEGATE_READ
:
2676 nfsd4_encode_stateid(resp
, &open
->op_delegate_stateid
);
2678 WRITE32(open
->op_recall
);
2681 * TODO: ACE's in delegations
2683 WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE
);
2686 WRITE32(0); /* XXX: is NULL principal ok? */
2689 case NFS4_OPEN_DELEGATE_WRITE
:
2690 nfsd4_encode_stateid(resp
, &open
->op_delegate_stateid
);
2695 * TODO: space_limit's in delegations
2697 WRITE32(NFS4_LIMIT_SIZE
);
2702 * TODO: ACE's in delegations
2704 WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE
);
2707 WRITE32(0); /* XXX: is NULL principal ok? */
2713 /* XXX save filehandle here */
2715 ENCODE_SEQID_OP_TAIL(open
->op_stateowner
);
2720 nfsd4_encode_open_confirm(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open_confirm
*oc
)
2722 ENCODE_SEQID_OP_HEAD
;
2725 nfsd4_encode_stateid(resp
, &oc
->oc_resp_stateid
);
2727 ENCODE_SEQID_OP_TAIL(oc
->oc_stateowner
);
2732 nfsd4_encode_open_downgrade(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open_downgrade
*od
)
2734 ENCODE_SEQID_OP_HEAD
;
2737 nfsd4_encode_stateid(resp
, &od
->od_stateid
);
2739 ENCODE_SEQID_OP_TAIL(od
->od_stateowner
);
2744 nfsd4_encode_read(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
2745 struct nfsd4_read
*read
)
2749 unsigned long maxcount
;
2755 if (resp
->xbuf
->page_len
)
2756 return nfserr_resource
;
2758 RESERVE_SPACE(8); /* eof flag and byte count */
2760 maxcount
= svc_max_payload(resp
->rqstp
);
2761 if (maxcount
> read
->rd_length
)
2762 maxcount
= read
->rd_length
;
2767 pn
= resp
->rqstp
->rq_resused
++;
2768 resp
->rqstp
->rq_vec
[v
].iov_base
=
2769 page_address(resp
->rqstp
->rq_respages
[pn
]);
2770 resp
->rqstp
->rq_vec
[v
].iov_len
=
2771 len
< PAGE_SIZE
? len
: PAGE_SIZE
;
2777 nfserr
= nfsd_read_file(read
->rd_rqstp
, read
->rd_fhp
, read
->rd_filp
,
2778 read
->rd_offset
, resp
->rqstp
->rq_vec
, read
->rd_vlen
,
2781 if (nfserr
== nfserr_symlink
)
2782 nfserr
= nfserr_inval
;
2785 eof
= (read
->rd_offset
+ maxcount
>=
2786 read
->rd_fhp
->fh_dentry
->d_inode
->i_size
);
2791 resp
->xbuf
->head
[0].iov_len
= (char*)p
2792 - (char*)resp
->xbuf
->head
[0].iov_base
;
2793 resp
->xbuf
->page_len
= maxcount
;
2795 /* Use rest of head for padding and remaining ops: */
2796 resp
->xbuf
->tail
[0].iov_base
= p
;
2797 resp
->xbuf
->tail
[0].iov_len
= 0;
2801 resp
->xbuf
->tail
[0].iov_base
+= maxcount
&3;
2802 resp
->xbuf
->tail
[0].iov_len
= 4 - (maxcount
&3);
2809 nfsd4_encode_readlink(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_readlink
*readlink
)
2817 if (resp
->xbuf
->page_len
)
2818 return nfserr_resource
;
2820 page
= page_address(resp
->rqstp
->rq_respages
[resp
->rqstp
->rq_resused
++]);
2822 maxcount
= PAGE_SIZE
;
2826 * XXX: By default, the ->readlink() VFS op will truncate symlinks
2827 * if they would overflow the buffer. Is this kosher in NFSv4? If
2828 * not, one easy fix is: if ->readlink() precisely fills the buffer,
2829 * assume that truncation occurred, and return NFS4ERR_RESOURCE.
2831 nfserr
= nfsd_readlink(readlink
->rl_rqstp
, readlink
->rl_fhp
, page
, &maxcount
);
2832 if (nfserr
== nfserr_isdir
)
2833 return nfserr_inval
;
2839 resp
->xbuf
->head
[0].iov_len
= (char*)p
2840 - (char*)resp
->xbuf
->head
[0].iov_base
;
2841 resp
->xbuf
->page_len
= maxcount
;
2843 /* Use rest of head for padding and remaining ops: */
2844 resp
->xbuf
->tail
[0].iov_base
= p
;
2845 resp
->xbuf
->tail
[0].iov_len
= 0;
2849 resp
->xbuf
->tail
[0].iov_base
+= maxcount
&3;
2850 resp
->xbuf
->tail
[0].iov_len
= 4 - (maxcount
&3);
2857 nfsd4_encode_readdir(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_readdir
*readdir
)
2861 __be32
*page
, *savep
, *tailbase
;
2866 if (resp
->xbuf
->page_len
)
2867 return nfserr_resource
;
2869 RESERVE_SPACE(8); /* verifier */
2872 /* XXX: Following NFSv3, we ignore the READDIR verifier for now. */
2876 resp
->xbuf
->head
[0].iov_len
= ((char*)resp
->p
) - (char*)resp
->xbuf
->head
[0].iov_base
;
2879 maxcount
= PAGE_SIZE
;
2880 if (maxcount
> readdir
->rd_maxcount
)
2881 maxcount
= readdir
->rd_maxcount
;
2884 * Convert from bytes to words, account for the two words already
2885 * written, make sure to leave two words at the end for the next
2886 * pointer and eof field.
2888 maxcount
= (maxcount
>> 2) - 4;
2890 nfserr
= nfserr_toosmall
;
2894 page
= page_address(resp
->rqstp
->rq_respages
[resp
->rqstp
->rq_resused
++]);
2895 readdir
->common
.err
= 0;
2896 readdir
->buflen
= maxcount
;
2897 readdir
->buffer
= page
;
2898 readdir
->offset
= NULL
;
2900 offset
= readdir
->rd_cookie
;
2901 nfserr
= nfsd_readdir(readdir
->rd_rqstp
, readdir
->rd_fhp
,
2903 &readdir
->common
, nfsd4_encode_dirent
);
2904 if (nfserr
== nfs_ok
&&
2905 readdir
->common
.err
== nfserr_toosmall
&&
2906 readdir
->buffer
== page
)
2907 nfserr
= nfserr_toosmall
;
2908 if (nfserr
== nfserr_symlink
)
2909 nfserr
= nfserr_notdir
;
2913 if (readdir
->offset
)
2914 xdr_encode_hyper(readdir
->offset
, offset
);
2916 p
= readdir
->buffer
;
2917 *p
++ = 0; /* no more entries */
2918 *p
++ = htonl(readdir
->common
.err
== nfserr_eof
);
2919 resp
->xbuf
->page_len
= ((char*)p
) - (char*)page_address(
2920 resp
->rqstp
->rq_respages
[resp
->rqstp
->rq_resused
-1]);
2922 /* Use rest of head for padding and remaining ops: */
2923 resp
->xbuf
->tail
[0].iov_base
= tailbase
;
2924 resp
->xbuf
->tail
[0].iov_len
= 0;
2925 resp
->p
= resp
->xbuf
->tail
[0].iov_base
;
2926 resp
->end
= resp
->p
+ (PAGE_SIZE
- resp
->xbuf
->head
[0].iov_len
)/4;
2936 nfsd4_encode_remove(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_remove
*remove
)
2942 write_cinfo(&p
, &remove
->rm_cinfo
);
2949 nfsd4_encode_rename(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_rename
*rename
)
2955 write_cinfo(&p
, &rename
->rn_sinfo
);
2956 write_cinfo(&p
, &rename
->rn_tinfo
);
2963 nfsd4_do_encode_secinfo(struct nfsd4_compoundres
*resp
,
2964 __be32 nfserr
,struct svc_export
*exp
)
2968 struct exp_flavor_info
*flavs
;
2969 struct exp_flavor_info def_flavs
[2];
2974 if (exp
->ex_nflavors
) {
2975 flavs
= exp
->ex_flavors
;
2976 nflavs
= exp
->ex_nflavors
;
2977 } else { /* Handling of some defaults in absence of real secinfo: */
2979 if (exp
->ex_client
->flavour
->flavour
== RPC_AUTH_UNIX
) {
2981 flavs
[0].pseudoflavor
= RPC_AUTH_UNIX
;
2982 flavs
[1].pseudoflavor
= RPC_AUTH_NULL
;
2983 } else if (exp
->ex_client
->flavour
->flavour
== RPC_AUTH_GSS
) {
2985 flavs
[0].pseudoflavor
2986 = svcauth_gss_flavor(exp
->ex_client
);
2989 flavs
[0].pseudoflavor
2990 = exp
->ex_client
->flavour
->flavour
;
2997 for (i
= 0; i
< nflavs
; i
++) {
2998 u32 flav
= flavs
[i
].pseudoflavor
;
2999 struct gss_api_mech
*gm
= gss_mech_get_by_pseudoflavor(flav
);
3003 WRITE32(RPC_AUTH_GSS
);
3005 RESERVE_SPACE(4 + gm
->gm_oid
.len
);
3006 WRITE32(gm
->gm_oid
.len
);
3007 WRITEMEM(gm
->gm_oid
.data
, gm
->gm_oid
.len
);
3010 WRITE32(0); /* qop */
3013 WRITE32(gss_pseudoflavor_to_service(gm
, flav
));
3029 nfsd4_encode_secinfo(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
3030 struct nfsd4_secinfo
*secinfo
)
3032 return nfsd4_do_encode_secinfo(resp
, nfserr
, secinfo
->si_exp
);
3036 nfsd4_encode_secinfo_no_name(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
3037 struct nfsd4_secinfo_no_name
*secinfo
)
3039 return nfsd4_do_encode_secinfo(resp
, nfserr
, secinfo
->sin_exp
);
3043 * The SETATTR encode routine is special -- it always encodes a bitmap,
3044 * regardless of the error status.
3047 nfsd4_encode_setattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_setattr
*setattr
)
3059 WRITE32(setattr
->sa_bmval
[0]);
3060 WRITE32(setattr
->sa_bmval
[1]);
3067 nfsd4_encode_setclientid(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_setclientid
*scd
)
3072 RESERVE_SPACE(8 + sizeof(nfs4_verifier
));
3073 WRITEMEM(&scd
->se_clientid
, 8);
3074 WRITEMEM(&scd
->se_confirm
, sizeof(nfs4_verifier
));
3077 else if (nfserr
== nfserr_clid_inuse
) {
3087 nfsd4_encode_write(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_write
*write
)
3093 WRITE32(write
->wr_bytes_written
);
3094 WRITE32(write
->wr_how_written
);
3095 WRITEMEM(write
->wr_verifier
.data
, 8);
3102 nfsd4_encode_exchange_id(struct nfsd4_compoundres
*resp
, int nfserr
,
3103 struct nfsd4_exchange_id
*exid
)
3109 int server_scope_sz
;
3110 uint64_t minor_id
= 0;
3115 major_id
= utsname()->nodename
;
3116 major_id_sz
= strlen(major_id
);
3117 server_scope
= utsname()->nodename
;
3118 server_scope_sz
= strlen(server_scope
);
3121 8 /* eir_clientid */ +
3122 4 /* eir_sequenceid */ +
3124 4 /* spr_how (SP4_NONE) */ +
3125 8 /* so_minor_id */ +
3126 4 /* so_major_id.len */ +
3127 (XDR_QUADLEN(major_id_sz
) * 4) +
3128 4 /* eir_server_scope.len */ +
3129 (XDR_QUADLEN(server_scope_sz
) * 4) +
3130 4 /* eir_server_impl_id.count (0) */);
3132 WRITEMEM(&exid
->clientid
, 8);
3133 WRITE32(exid
->seqid
);
3134 WRITE32(exid
->flags
);
3136 /* state_protect4_r. Currently only support SP4_NONE */
3137 BUG_ON(exid
->spa_how
!= SP4_NONE
);
3138 WRITE32(exid
->spa_how
);
3140 /* The server_owner struct */
3141 WRITE64(minor_id
); /* Minor id */
3143 WRITE32(major_id_sz
);
3144 WRITEMEM(major_id
, major_id_sz
);
3147 WRITE32(server_scope_sz
);
3148 WRITEMEM(server_scope
, server_scope_sz
);
3150 /* Implementation id */
3151 WRITE32(0); /* zero length nfs_impl_id4 array */
3157 nfsd4_encode_create_session(struct nfsd4_compoundres
*resp
, int nfserr
,
3158 struct nfsd4_create_session
*sess
)
3166 WRITEMEM(sess
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
3167 WRITE32(sess
->seqid
);
3168 WRITE32(sess
->flags
);
3172 WRITE32(0); /* headerpadsz */
3173 WRITE32(sess
->fore_channel
.maxreq_sz
);
3174 WRITE32(sess
->fore_channel
.maxresp_sz
);
3175 WRITE32(sess
->fore_channel
.maxresp_cached
);
3176 WRITE32(sess
->fore_channel
.maxops
);
3177 WRITE32(sess
->fore_channel
.maxreqs
);
3178 WRITE32(sess
->fore_channel
.nr_rdma_attrs
);
3181 if (sess
->fore_channel
.nr_rdma_attrs
) {
3183 WRITE32(sess
->fore_channel
.rdma_attrs
);
3188 WRITE32(0); /* headerpadsz */
3189 WRITE32(sess
->back_channel
.maxreq_sz
);
3190 WRITE32(sess
->back_channel
.maxresp_sz
);
3191 WRITE32(sess
->back_channel
.maxresp_cached
);
3192 WRITE32(sess
->back_channel
.maxops
);
3193 WRITE32(sess
->back_channel
.maxreqs
);
3194 WRITE32(sess
->back_channel
.nr_rdma_attrs
);
3197 if (sess
->back_channel
.nr_rdma_attrs
) {
3199 WRITE32(sess
->back_channel
.rdma_attrs
);
3206 nfsd4_encode_destroy_session(struct nfsd4_compoundres
*resp
, int nfserr
,
3207 struct nfsd4_destroy_session
*destroy_session
)
3213 nfsd4_encode_free_stateid(struct nfsd4_compoundres
*resp
, int nfserr
,
3214 struct nfsd4_free_stateid
*free_stateid
)
3228 nfsd4_encode_sequence(struct nfsd4_compoundres
*resp
, int nfserr
,
3229 struct nfsd4_sequence
*seq
)
3236 RESERVE_SPACE(NFS4_MAX_SESSIONID_LEN
+ 20);
3237 WRITEMEM(seq
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
3238 WRITE32(seq
->seqid
);
3239 WRITE32(seq
->slotid
);
3240 WRITE32(seq
->maxslots
);
3241 /* For now: target_maxslots = maxslots */
3242 WRITE32(seq
->maxslots
);
3243 WRITE32(seq
->status_flags
);
3246 resp
->cstate
.datap
= p
; /* DRC cache data pointer */
3251 nfsd4_encode_test_stateid(struct nfsd4_compoundres
*resp
, int nfserr
,
3252 struct nfsd4_test_stateid
*test_stateid
)
3254 struct nfsd4_compoundargs
*argp
;
3260 restore_buf(test_stateid
->ts_saved_args
, &test_stateid
->ts_savedp
);
3261 argp
= test_stateid
->ts_saved_args
;
3264 *p
++ = htonl(test_stateid
->ts_num_ids
);
3268 for (i
= 0; i
< test_stateid
->ts_num_ids
; i
++) {
3269 nfsd4_decode_stateid(argp
, &si
);
3270 valid
= nfs4_validate_stateid(&si
, test_stateid
->ts_has_session
);
3272 *p
++ = htonl(valid
);
3275 nfs4_unlock_state();
3281 nfsd4_encode_noop(struct nfsd4_compoundres
*resp
, __be32 nfserr
, void *p
)
3286 typedef __be32(* nfsd4_enc
)(struct nfsd4_compoundres
*, __be32
, void *);
3289 * Note: nfsd4_enc_ops vector is shared for v4.0 and v4.1
3290 * since we don't need to filter out obsolete ops as this is
3291 * done in the decoding phase.
3293 static nfsd4_enc nfsd4_enc_ops
[] = {
3294 [OP_ACCESS
] = (nfsd4_enc
)nfsd4_encode_access
,
3295 [OP_CLOSE
] = (nfsd4_enc
)nfsd4_encode_close
,
3296 [OP_COMMIT
] = (nfsd4_enc
)nfsd4_encode_commit
,
3297 [OP_CREATE
] = (nfsd4_enc
)nfsd4_encode_create
,
3298 [OP_DELEGPURGE
] = (nfsd4_enc
)nfsd4_encode_noop
,
3299 [OP_DELEGRETURN
] = (nfsd4_enc
)nfsd4_encode_noop
,
3300 [OP_GETATTR
] = (nfsd4_enc
)nfsd4_encode_getattr
,
3301 [OP_GETFH
] = (nfsd4_enc
)nfsd4_encode_getfh
,
3302 [OP_LINK
] = (nfsd4_enc
)nfsd4_encode_link
,
3303 [OP_LOCK
] = (nfsd4_enc
)nfsd4_encode_lock
,
3304 [OP_LOCKT
] = (nfsd4_enc
)nfsd4_encode_lockt
,
3305 [OP_LOCKU
] = (nfsd4_enc
)nfsd4_encode_locku
,
3306 [OP_LOOKUP
] = (nfsd4_enc
)nfsd4_encode_noop
,
3307 [OP_LOOKUPP
] = (nfsd4_enc
)nfsd4_encode_noop
,
3308 [OP_NVERIFY
] = (nfsd4_enc
)nfsd4_encode_noop
,
3309 [OP_OPEN
] = (nfsd4_enc
)nfsd4_encode_open
,
3310 [OP_OPENATTR
] = (nfsd4_enc
)nfsd4_encode_noop
,
3311 [OP_OPEN_CONFIRM
] = (nfsd4_enc
)nfsd4_encode_open_confirm
,
3312 [OP_OPEN_DOWNGRADE
] = (nfsd4_enc
)nfsd4_encode_open_downgrade
,
3313 [OP_PUTFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3314 [OP_PUTPUBFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3315 [OP_PUTROOTFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3316 [OP_READ
] = (nfsd4_enc
)nfsd4_encode_read
,
3317 [OP_READDIR
] = (nfsd4_enc
)nfsd4_encode_readdir
,
3318 [OP_READLINK
] = (nfsd4_enc
)nfsd4_encode_readlink
,
3319 [OP_REMOVE
] = (nfsd4_enc
)nfsd4_encode_remove
,
3320 [OP_RENAME
] = (nfsd4_enc
)nfsd4_encode_rename
,
3321 [OP_RENEW
] = (nfsd4_enc
)nfsd4_encode_noop
,
3322 [OP_RESTOREFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3323 [OP_SAVEFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3324 [OP_SECINFO
] = (nfsd4_enc
)nfsd4_encode_secinfo
,
3325 [OP_SETATTR
] = (nfsd4_enc
)nfsd4_encode_setattr
,
3326 [OP_SETCLIENTID
] = (nfsd4_enc
)nfsd4_encode_setclientid
,
3327 [OP_SETCLIENTID_CONFIRM
] = (nfsd4_enc
)nfsd4_encode_noop
,
3328 [OP_VERIFY
] = (nfsd4_enc
)nfsd4_encode_noop
,
3329 [OP_WRITE
] = (nfsd4_enc
)nfsd4_encode_write
,
3330 [OP_RELEASE_LOCKOWNER
] = (nfsd4_enc
)nfsd4_encode_noop
,
3332 /* NFSv4.1 operations */
3333 [OP_BACKCHANNEL_CTL
] = (nfsd4_enc
)nfsd4_encode_noop
,
3334 [OP_BIND_CONN_TO_SESSION
] = (nfsd4_enc
)nfsd4_encode_bind_conn_to_session
,
3335 [OP_EXCHANGE_ID
] = (nfsd4_enc
)nfsd4_encode_exchange_id
,
3336 [OP_CREATE_SESSION
] = (nfsd4_enc
)nfsd4_encode_create_session
,
3337 [OP_DESTROY_SESSION
] = (nfsd4_enc
)nfsd4_encode_destroy_session
,
3338 [OP_FREE_STATEID
] = (nfsd4_enc
)nfsd4_encode_free_stateid
,
3339 [OP_GET_DIR_DELEGATION
] = (nfsd4_enc
)nfsd4_encode_noop
,
3340 [OP_GETDEVICEINFO
] = (nfsd4_enc
)nfsd4_encode_noop
,
3341 [OP_GETDEVICELIST
] = (nfsd4_enc
)nfsd4_encode_noop
,
3342 [OP_LAYOUTCOMMIT
] = (nfsd4_enc
)nfsd4_encode_noop
,
3343 [OP_LAYOUTGET
] = (nfsd4_enc
)nfsd4_encode_noop
,
3344 [OP_LAYOUTRETURN
] = (nfsd4_enc
)nfsd4_encode_noop
,
3345 [OP_SECINFO_NO_NAME
] = (nfsd4_enc
)nfsd4_encode_secinfo_no_name
,
3346 [OP_SEQUENCE
] = (nfsd4_enc
)nfsd4_encode_sequence
,
3347 [OP_SET_SSV
] = (nfsd4_enc
)nfsd4_encode_noop
,
3348 [OP_TEST_STATEID
] = (nfsd4_enc
)nfsd4_encode_test_stateid
,
3349 [OP_WANT_DELEGATION
] = (nfsd4_enc
)nfsd4_encode_noop
,
3350 [OP_DESTROY_CLIENTID
] = (nfsd4_enc
)nfsd4_encode_noop
,
3351 [OP_RECLAIM_COMPLETE
] = (nfsd4_enc
)nfsd4_encode_noop
,
3355 * Calculate the total amount of memory that the compound response has taken
3356 * after encoding the current operation.
3358 * pad: add on 8 bytes for the next operation's op_code and status so that
3359 * there is room to cache a failure on the next operation.
3361 * Compare this length to the session se_fmaxresp_cached.
3363 * Our se_fmaxresp_cached will always be a multiple of PAGE_SIZE, and so
3364 * will be at least a page and will therefore hold the xdr_buf head.
3366 static int nfsd4_check_drc_limit(struct nfsd4_compoundres
*resp
)
3369 struct xdr_buf
*xb
= &resp
->rqstp
->rq_res
;
3370 struct nfsd4_compoundargs
*args
= resp
->rqstp
->rq_argp
;
3371 struct nfsd4_session
*session
= NULL
;
3372 struct nfsd4_slot
*slot
= resp
->cstate
.slot
;
3373 u32 length
, tlen
= 0, pad
= 8;
3375 if (!nfsd4_has_session(&resp
->cstate
))
3378 session
= resp
->cstate
.session
;
3379 if (session
== NULL
|| slot
->sl_cachethis
== 0)
3382 if (resp
->opcnt
>= args
->opcnt
)
3383 pad
= 0; /* this is the last operation */
3385 if (xb
->page_len
== 0) {
3386 length
= (char *)resp
->p
- (char *)xb
->head
[0].iov_base
+ pad
;
3388 if (xb
->tail
[0].iov_base
&& xb
->tail
[0].iov_len
> 0)
3389 tlen
= (char *)resp
->p
- (char *)xb
->tail
[0].iov_base
;
3391 length
= xb
->head
[0].iov_len
+ xb
->page_len
+ tlen
+ pad
;
3393 dprintk("%s length %u, xb->page_len %u tlen %u pad %u\n", __func__
,
3394 length
, xb
->page_len
, tlen
, pad
);
3396 if (length
<= session
->se_fchannel
.maxresp_cached
)
3399 return nfserr_rep_too_big_to_cache
;
3403 nfsd4_encode_operation(struct nfsd4_compoundres
*resp
, struct nfsd4_op
*op
)
3410 statp
= p
++; /* to be backfilled at the end */
3413 if (op
->opnum
== OP_ILLEGAL
)
3415 BUG_ON(op
->opnum
< 0 || op
->opnum
>= ARRAY_SIZE(nfsd4_enc_ops
) ||
3416 !nfsd4_enc_ops
[op
->opnum
]);
3417 op
->status
= nfsd4_enc_ops
[op
->opnum
](resp
, op
->status
, &op
->u
);
3418 /* nfsd4_check_drc_limit guarantees enough room for error status */
3419 if (!op
->status
&& nfsd4_check_drc_limit(resp
))
3420 op
->status
= nfserr_rep_too_big_to_cache
;
3423 * Note: We write the status directly, instead of using WRITE32(),
3424 * since it is already in network byte order.
3426 *statp
= op
->status
;
3430 * Encode the reply stored in the stateowner reply cache
3432 * XDR note: do not encode rp->rp_buflen: the buffer contains the
3433 * previously sent already encoded operation.
3435 * called with nfs4_lock_state() held
3438 nfsd4_encode_replay(struct nfsd4_compoundres
*resp
, struct nfsd4_op
*op
)
3441 struct nfs4_replay
*rp
= op
->replay
;
3447 *p
++ = rp
->rp_status
; /* already xdr'ed */
3450 RESERVE_SPACE(rp
->rp_buflen
);
3451 WRITEMEM(rp
->rp_buf
, rp
->rp_buflen
);
3456 nfs4svc_encode_voidres(struct svc_rqst
*rqstp
, __be32
*p
, void *dummy
)
3458 return xdr_ressize_check(rqstp
, p
);
3461 int nfsd4_release_compoundargs(void *rq
, __be32
*p
, void *resp
)
3463 struct svc_rqst
*rqstp
= rq
;
3464 struct nfsd4_compoundargs
*args
= rqstp
->rq_argp
;
3466 if (args
->ops
!= args
->iops
) {
3468 args
->ops
= args
->iops
;
3472 while (args
->to_free
) {
3473 struct tmpbuf
*tb
= args
->to_free
;
3474 args
->to_free
= tb
->next
;
3475 tb
->release(tb
->buf
);
3482 nfs4svc_decode_compoundargs(struct svc_rqst
*rqstp
, __be32
*p
, struct nfsd4_compoundargs
*args
)
3485 args
->end
= rqstp
->rq_arg
.head
[0].iov_base
+ rqstp
->rq_arg
.head
[0].iov_len
;
3486 args
->pagelist
= rqstp
->rq_arg
.pages
;
3487 args
->pagelen
= rqstp
->rq_arg
.page_len
;
3489 args
->to_free
= NULL
;
3490 args
->ops
= args
->iops
;
3491 args
->rqstp
= rqstp
;
3493 return !nfsd4_decode_compound(args
);
3497 nfs4svc_encode_compoundres(struct svc_rqst
*rqstp
, __be32
*p
, struct nfsd4_compoundres
*resp
)
3500 * All that remains is to write the tag and operation count...
3502 struct nfsd4_compound_state
*cs
= &resp
->cstate
;
3505 *p
++ = htonl(resp
->taglen
);
3506 memcpy(p
, resp
->tag
, resp
->taglen
);
3507 p
+= XDR_QUADLEN(resp
->taglen
);
3508 *p
++ = htonl(resp
->opcnt
);
3510 if (rqstp
->rq_res
.page_len
)
3511 iov
= &rqstp
->rq_res
.tail
[0];
3513 iov
= &rqstp
->rq_res
.head
[0];
3514 iov
->iov_len
= ((char*)resp
->p
) - (char*)iov
->iov_base
;
3515 BUG_ON(iov
->iov_len
> PAGE_SIZE
);
3516 if (nfsd4_has_session(cs
)) {
3517 if (cs
->status
!= nfserr_replay_cache
) {
3518 nfsd4_store_cache_entry(resp
);
3519 dprintk("%s: SET SLOT STATE TO AVAILABLE\n", __func__
);
3520 cs
->slot
->sl_inuse
= false;
3522 /* Renew the clientid on success and on replay */
3523 release_session_client(cs
->session
);
3524 nfsd4_put_session(cs
->session
);