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/namei.h>
44 #include <linux/statfs.h>
45 #include <linux/utsname.h>
46 #include <linux/nfsd_idmap.h>
47 #include <linux/nfs4_acl.h>
48 #include <linux/sunrpc/svcauth_gss.h>
53 #define NFSDDBG_FACILITY NFSDDBG_XDR
56 * As per referral draft, the fsid for a referral MUST be different from the fsid of the containing
57 * directory in order to indicate to the client that a filesystem boundary is present
58 * We use a fixed fsid for a referral
60 #define NFS4_REFERRAL_FSID_MAJOR 0x8000000ULL
61 #define NFS4_REFERRAL_FSID_MINOR 0x8000000ULL
64 check_filename(char *str
, int len
, __be32 err
)
70 if (isdotent(str
, len
))
72 for (i
= 0; i
< len
; i
++)
86 dprintk("NFSD: xdr error (%s:%d)\n", \
87 __FILE__, __LINE__); \
88 status = nfserr_bad_xdr; \
91 #define READ32(x) (x) = ntohl(*p++)
92 #define READ64(x) do { \
93 (x) = (u64)ntohl(*p++) << 32; \
96 #define READTIME(x) do { \
101 #define READMEM(x,nbytes) do { \
103 p += XDR_QUADLEN(nbytes); \
105 #define SAVEMEM(x,nbytes) do { \
106 if (!(x = (p==argp->tmp || p == argp->tmpp) ? \
107 savemem(argp, p, nbytes) : \
109 dprintk("NFSD: xdr error (%s:%d)\n", \
110 __FILE__, __LINE__); \
113 p += XDR_QUADLEN(nbytes); \
115 #define COPYMEM(x,nbytes) do { \
116 memcpy((x), p, nbytes); \
117 p += XDR_QUADLEN(nbytes); \
120 /* READ_BUF, read_buf(): nbytes must be <= PAGE_SIZE */
121 #define READ_BUF(nbytes) do { \
122 if (nbytes <= (u32)((char *)argp->end - (char *)argp->p)) { \
124 argp->p += XDR_QUADLEN(nbytes); \
125 } else if (!(p = read_buf(argp, nbytes))) { \
126 dprintk("NFSD: xdr error (%s:%d)\n", \
127 __FILE__, __LINE__); \
132 static __be32
*read_buf(struct nfsd4_compoundargs
*argp
, u32 nbytes
)
134 /* We want more bytes than seem to be available.
135 * Maybe we need a new page, maybe we have just run out
137 unsigned int avail
= (char *)argp
->end
- (char *)argp
->p
;
139 if (avail
+ argp
->pagelen
< nbytes
)
141 if (avail
+ PAGE_SIZE
< nbytes
) /* need more than a page !! */
143 /* ok, we can do it with the current plus the next page */
144 if (nbytes
<= sizeof(argp
->tmp
))
148 p
= argp
->tmpp
= kmalloc(nbytes
, GFP_KERNEL
);
154 * The following memcpy is safe because read_buf is always
155 * called with nbytes > avail, and the two cases above both
156 * guarantee p points to at least nbytes bytes.
158 memcpy(p
, argp
->p
, avail
);
159 /* step to next page */
160 argp
->p
= page_address(argp
->pagelist
[0]);
162 if (argp
->pagelen
< PAGE_SIZE
) {
163 argp
->end
= argp
->p
+ (argp
->pagelen
>>2);
166 argp
->end
= argp
->p
+ (PAGE_SIZE
>>2);
167 argp
->pagelen
-= PAGE_SIZE
;
169 memcpy(((char*)p
)+avail
, argp
->p
, (nbytes
- avail
));
170 argp
->p
+= XDR_QUADLEN(nbytes
- avail
);
174 static int zero_clientid(clientid_t
*clid
)
176 return (clid
->cl_boot
== 0) && (clid
->cl_id
== 0);
180 defer_free(struct nfsd4_compoundargs
*argp
,
181 void (*release
)(const void *), void *p
)
185 tb
= kmalloc(sizeof(*tb
), GFP_KERNEL
);
189 tb
->release
= release
;
190 tb
->next
= argp
->to_free
;
195 static char *savemem(struct nfsd4_compoundargs
*argp
, __be32
*p
, int nbytes
)
197 if (p
== argp
->tmp
) {
198 p
= kmalloc(nbytes
, GFP_KERNEL
);
201 memcpy(p
, argp
->tmp
, nbytes
);
203 BUG_ON(p
!= argp
->tmpp
);
206 if (defer_free(argp
, kfree
, p
)) {
214 nfsd4_decode_bitmap(struct nfsd4_compoundargs
*argp
, u32
*bmval
)
228 READ_BUF(bmlen
<< 2);
240 nfsd4_decode_fattr(struct nfsd4_compoundargs
*argp
, u32
*bmval
,
241 struct iattr
*iattr
, struct nfs4_acl
**acl
)
243 int expected_len
, len
= 0;
250 if ((status
= nfsd4_decode_bitmap(argp
, bmval
)))
254 READ32(expected_len
);
256 if (bmval
[0] & FATTR4_WORD0_SIZE
) {
259 READ64(iattr
->ia_size
);
260 iattr
->ia_valid
|= ATTR_SIZE
;
262 if (bmval
[0] & FATTR4_WORD0_ACL
) {
264 struct nfs4_ace
*ace
;
266 READ_BUF(4); len
+= 4;
269 if (nace
> NFS4_ACL_MAX
)
270 return nfserr_resource
;
272 *acl
= nfs4_acl_new(nace
);
277 defer_free(argp
, kfree
, *acl
);
279 (*acl
)->naces
= nace
;
280 for (ace
= (*acl
)->aces
; ace
< (*acl
)->aces
+ nace
; ace
++) {
281 READ_BUF(16); len
+= 16;
284 READ32(ace
->access_mask
);
287 len
+= XDR_QUADLEN(dummy32
) << 2;
288 READMEM(buf
, dummy32
);
289 ace
->whotype
= nfs4_acl_get_whotype(buf
, dummy32
);
291 if (ace
->whotype
!= NFS4_ACL_WHO_NAMED
)
293 else if (ace
->flag
& NFS4_ACE_IDENTIFIER_GROUP
)
294 host_err
= nfsd_map_name_to_gid(argp
->rqstp
,
295 buf
, dummy32
, &ace
->who
);
297 host_err
= nfsd_map_name_to_uid(argp
->rqstp
,
298 buf
, dummy32
, &ace
->who
);
304 if (bmval
[1] & FATTR4_WORD1_MODE
) {
307 READ32(iattr
->ia_mode
);
308 iattr
->ia_mode
&= (S_IFMT
| S_IALLUGO
);
309 iattr
->ia_valid
|= ATTR_MODE
;
311 if (bmval
[1] & FATTR4_WORD1_OWNER
) {
316 len
+= (XDR_QUADLEN(dummy32
) << 2);
317 READMEM(buf
, dummy32
);
318 if ((status
= nfsd_map_name_to_uid(argp
->rqstp
, buf
, dummy32
, &iattr
->ia_uid
)))
320 iattr
->ia_valid
|= ATTR_UID
;
322 if (bmval
[1] & FATTR4_WORD1_OWNER_GROUP
) {
327 len
+= (XDR_QUADLEN(dummy32
) << 2);
328 READMEM(buf
, dummy32
);
329 if ((status
= nfsd_map_name_to_gid(argp
->rqstp
, buf
, dummy32
, &iattr
->ia_gid
)))
331 iattr
->ia_valid
|= ATTR_GID
;
333 if (bmval
[1] & FATTR4_WORD1_TIME_ACCESS_SET
) {
338 case NFS4_SET_TO_CLIENT_TIME
:
339 /* We require the high 32 bits of 'seconds' to be 0, and we ignore
340 all 32 bits of 'nseconds'. */
346 READ32(iattr
->ia_atime
.tv_sec
);
347 READ32(iattr
->ia_atime
.tv_nsec
);
348 if (iattr
->ia_atime
.tv_nsec
>= (u32
)1000000000)
350 iattr
->ia_valid
|= (ATTR_ATIME
| ATTR_ATIME_SET
);
352 case NFS4_SET_TO_SERVER_TIME
:
353 iattr
->ia_valid
|= ATTR_ATIME
;
359 if (bmval
[1] & FATTR4_WORD1_TIME_MODIFY_SET
) {
364 case NFS4_SET_TO_CLIENT_TIME
:
365 /* We require the high 32 bits of 'seconds' to be 0, and we ignore
366 all 32 bits of 'nseconds'. */
372 READ32(iattr
->ia_mtime
.tv_sec
);
373 READ32(iattr
->ia_mtime
.tv_nsec
);
374 if (iattr
->ia_mtime
.tv_nsec
>= (u32
)1000000000)
376 iattr
->ia_valid
|= (ATTR_MTIME
| ATTR_MTIME_SET
);
378 case NFS4_SET_TO_SERVER_TIME
:
379 iattr
->ia_valid
|= ATTR_MTIME
;
385 if (bmval
[0] & ~NFSD_WRITEABLE_ATTRS_WORD0
386 || bmval
[1] & ~NFSD_WRITEABLE_ATTRS_WORD1
387 || bmval
[2] & ~NFSD_WRITEABLE_ATTRS_WORD2
)
388 READ_BUF(expected_len
- len
);
389 else if (len
!= expected_len
)
395 status
= nfserrno(host_err
);
400 nfsd4_decode_stateid(struct nfsd4_compoundargs
*argp
, stateid_t
*sid
)
404 READ_BUF(sizeof(stateid_t
));
405 READ32(sid
->si_generation
);
406 COPYMEM(&sid
->si_opaque
, sizeof(stateid_opaque_t
));
412 nfsd4_decode_access(struct nfsd4_compoundargs
*argp
, struct nfsd4_access
*access
)
417 READ32(access
->ac_req_access
);
423 nfsd4_decode_close(struct nfsd4_compoundargs
*argp
, struct nfsd4_close
*close
)
427 close
->cl_stateowner
= NULL
;
429 READ32(close
->cl_seqid
);
430 return nfsd4_decode_stateid(argp
, &close
->cl_stateid
);
437 nfsd4_decode_commit(struct nfsd4_compoundargs
*argp
, struct nfsd4_commit
*commit
)
442 READ64(commit
->co_offset
);
443 READ32(commit
->co_count
);
449 nfsd4_decode_create(struct nfsd4_compoundargs
*argp
, struct nfsd4_create
*create
)
454 READ32(create
->cr_type
);
455 switch (create
->cr_type
) {
458 READ32(create
->cr_linklen
);
459 READ_BUF(create
->cr_linklen
);
460 SAVEMEM(create
->cr_linkname
, create
->cr_linklen
);
465 READ32(create
->cr_specdata1
);
466 READ32(create
->cr_specdata2
);
476 READ32(create
->cr_namelen
);
477 READ_BUF(create
->cr_namelen
);
478 SAVEMEM(create
->cr_name
, create
->cr_namelen
);
479 if ((status
= check_filename(create
->cr_name
, create
->cr_namelen
, nfserr_inval
)))
482 status
= nfsd4_decode_fattr(argp
, create
->cr_bmval
, &create
->cr_iattr
,
491 nfsd4_decode_delegreturn(struct nfsd4_compoundargs
*argp
, struct nfsd4_delegreturn
*dr
)
493 return nfsd4_decode_stateid(argp
, &dr
->dr_stateid
);
497 nfsd4_decode_getattr(struct nfsd4_compoundargs
*argp
, struct nfsd4_getattr
*getattr
)
499 return nfsd4_decode_bitmap(argp
, getattr
->ga_bmval
);
503 nfsd4_decode_link(struct nfsd4_compoundargs
*argp
, struct nfsd4_link
*link
)
508 READ32(link
->li_namelen
);
509 READ_BUF(link
->li_namelen
);
510 SAVEMEM(link
->li_name
, link
->li_namelen
);
511 if ((status
= check_filename(link
->li_name
, link
->li_namelen
, nfserr_inval
)))
518 nfsd4_decode_lock(struct nfsd4_compoundargs
*argp
, struct nfsd4_lock
*lock
)
522 lock
->lk_replay_owner
= NULL
;
524 * type, reclaim(boolean), offset, length, new_lock_owner(boolean)
527 READ32(lock
->lk_type
);
528 if ((lock
->lk_type
< NFS4_READ_LT
) || (lock
->lk_type
> NFS4_WRITEW_LT
))
530 READ32(lock
->lk_reclaim
);
531 READ64(lock
->lk_offset
);
532 READ64(lock
->lk_length
);
533 READ32(lock
->lk_is_new
);
535 if (lock
->lk_is_new
) {
537 READ32(lock
->lk_new_open_seqid
);
538 status
= nfsd4_decode_stateid(argp
, &lock
->lk_new_open_stateid
);
541 READ_BUF(8 + sizeof(clientid_t
));
542 READ32(lock
->lk_new_lock_seqid
);
543 COPYMEM(&lock
->lk_new_clientid
, sizeof(clientid_t
));
544 READ32(lock
->lk_new_owner
.len
);
545 READ_BUF(lock
->lk_new_owner
.len
);
546 READMEM(lock
->lk_new_owner
.data
, lock
->lk_new_owner
.len
);
548 status
= nfsd4_decode_stateid(argp
, &lock
->lk_old_lock_stateid
);
552 READ32(lock
->lk_old_lock_seqid
);
559 nfsd4_decode_lockt(struct nfsd4_compoundargs
*argp
, struct nfsd4_lockt
*lockt
)
564 READ32(lockt
->lt_type
);
565 if((lockt
->lt_type
< NFS4_READ_LT
) || (lockt
->lt_type
> NFS4_WRITEW_LT
))
567 READ64(lockt
->lt_offset
);
568 READ64(lockt
->lt_length
);
569 COPYMEM(&lockt
->lt_clientid
, 8);
570 READ32(lockt
->lt_owner
.len
);
571 READ_BUF(lockt
->lt_owner
.len
);
572 READMEM(lockt
->lt_owner
.data
, lockt
->lt_owner
.len
);
574 if (argp
->minorversion
&& !zero_clientid(&lockt
->lt_clientid
))
580 nfsd4_decode_locku(struct nfsd4_compoundargs
*argp
, struct nfsd4_locku
*locku
)
584 locku
->lu_stateowner
= NULL
;
586 READ32(locku
->lu_type
);
587 if ((locku
->lu_type
< NFS4_READ_LT
) || (locku
->lu_type
> NFS4_WRITEW_LT
))
589 READ32(locku
->lu_seqid
);
590 status
= nfsd4_decode_stateid(argp
, &locku
->lu_stateid
);
594 READ64(locku
->lu_offset
);
595 READ64(locku
->lu_length
);
601 nfsd4_decode_lookup(struct nfsd4_compoundargs
*argp
, struct nfsd4_lookup
*lookup
)
606 READ32(lookup
->lo_len
);
607 READ_BUF(lookup
->lo_len
);
608 SAVEMEM(lookup
->lo_name
, lookup
->lo_len
);
609 if ((status
= check_filename(lookup
->lo_name
, lookup
->lo_len
, nfserr_noent
)))
616 nfsd4_decode_open(struct nfsd4_compoundargs
*argp
, struct nfsd4_open
*open
)
620 memset(open
->op_bmval
, 0, sizeof(open
->op_bmval
));
621 open
->op_iattr
.ia_valid
= 0;
622 open
->op_stateowner
= NULL
;
624 /* seqid, share_access, share_deny, clientid, ownerlen */
625 READ_BUF(16 + sizeof(clientid_t
));
626 READ32(open
->op_seqid
);
627 READ32(open
->op_share_access
);
628 READ32(open
->op_share_deny
);
629 COPYMEM(&open
->op_clientid
, sizeof(clientid_t
));
630 READ32(open
->op_owner
.len
);
632 /* owner, open_flag */
633 READ_BUF(open
->op_owner
.len
+ 4);
634 SAVEMEM(open
->op_owner
.data
, open
->op_owner
.len
);
635 READ32(open
->op_create
);
636 switch (open
->op_create
) {
637 case NFS4_OPEN_NOCREATE
:
639 case NFS4_OPEN_CREATE
:
641 READ32(open
->op_createmode
);
642 switch (open
->op_createmode
) {
643 case NFS4_CREATE_UNCHECKED
:
644 case NFS4_CREATE_GUARDED
:
645 status
= nfsd4_decode_fattr(argp
, open
->op_bmval
,
646 &open
->op_iattr
, &open
->op_acl
);
650 case NFS4_CREATE_EXCLUSIVE
:
652 COPYMEM(open
->op_verf
.data
, 8);
654 case NFS4_CREATE_EXCLUSIVE4_1
:
655 if (argp
->minorversion
< 1)
658 COPYMEM(open
->op_verf
.data
, 8);
659 status
= nfsd4_decode_fattr(argp
, open
->op_bmval
,
660 &open
->op_iattr
, &open
->op_acl
);
674 READ32(open
->op_claim_type
);
675 switch (open
->op_claim_type
) {
676 case NFS4_OPEN_CLAIM_NULL
:
677 case NFS4_OPEN_CLAIM_DELEGATE_PREV
:
679 READ32(open
->op_fname
.len
);
680 READ_BUF(open
->op_fname
.len
);
681 SAVEMEM(open
->op_fname
.data
, open
->op_fname
.len
);
682 if ((status
= check_filename(open
->op_fname
.data
, open
->op_fname
.len
, nfserr_inval
)))
685 case NFS4_OPEN_CLAIM_PREVIOUS
:
687 READ32(open
->op_delegate_type
);
689 case NFS4_OPEN_CLAIM_DELEGATE_CUR
:
690 status
= nfsd4_decode_stateid(argp
, &open
->op_delegate_stateid
);
694 READ32(open
->op_fname
.len
);
695 READ_BUF(open
->op_fname
.len
);
696 SAVEMEM(open
->op_fname
.data
, open
->op_fname
.len
);
697 if ((status
= check_filename(open
->op_fname
.data
, open
->op_fname
.len
, nfserr_inval
)))
708 nfsd4_decode_open_confirm(struct nfsd4_compoundargs
*argp
, struct nfsd4_open_confirm
*open_conf
)
712 open_conf
->oc_stateowner
= NULL
;
713 status
= nfsd4_decode_stateid(argp
, &open_conf
->oc_req_stateid
);
717 READ32(open_conf
->oc_seqid
);
723 nfsd4_decode_open_downgrade(struct nfsd4_compoundargs
*argp
, struct nfsd4_open_downgrade
*open_down
)
727 open_down
->od_stateowner
= NULL
;
728 status
= nfsd4_decode_stateid(argp
, &open_down
->od_stateid
);
732 READ32(open_down
->od_seqid
);
733 READ32(open_down
->od_share_access
);
734 READ32(open_down
->od_share_deny
);
740 nfsd4_decode_putfh(struct nfsd4_compoundargs
*argp
, struct nfsd4_putfh
*putfh
)
745 READ32(putfh
->pf_fhlen
);
746 if (putfh
->pf_fhlen
> NFS4_FHSIZE
)
748 READ_BUF(putfh
->pf_fhlen
);
749 SAVEMEM(putfh
->pf_fhval
, putfh
->pf_fhlen
);
755 nfsd4_decode_read(struct nfsd4_compoundargs
*argp
, struct nfsd4_read
*read
)
759 status
= nfsd4_decode_stateid(argp
, &read
->rd_stateid
);
763 READ64(read
->rd_offset
);
764 READ32(read
->rd_length
);
770 nfsd4_decode_readdir(struct nfsd4_compoundargs
*argp
, struct nfsd4_readdir
*readdir
)
775 READ64(readdir
->rd_cookie
);
776 COPYMEM(readdir
->rd_verf
.data
, sizeof(readdir
->rd_verf
.data
));
777 READ32(readdir
->rd_dircount
); /* just in case you needed a useless field... */
778 READ32(readdir
->rd_maxcount
);
779 if ((status
= nfsd4_decode_bitmap(argp
, readdir
->rd_bmval
)))
786 nfsd4_decode_remove(struct nfsd4_compoundargs
*argp
, struct nfsd4_remove
*remove
)
791 READ32(remove
->rm_namelen
);
792 READ_BUF(remove
->rm_namelen
);
793 SAVEMEM(remove
->rm_name
, remove
->rm_namelen
);
794 if ((status
= check_filename(remove
->rm_name
, remove
->rm_namelen
, nfserr_noent
)))
801 nfsd4_decode_rename(struct nfsd4_compoundargs
*argp
, struct nfsd4_rename
*rename
)
806 READ32(rename
->rn_snamelen
);
807 READ_BUF(rename
->rn_snamelen
+ 4);
808 SAVEMEM(rename
->rn_sname
, rename
->rn_snamelen
);
809 READ32(rename
->rn_tnamelen
);
810 READ_BUF(rename
->rn_tnamelen
);
811 SAVEMEM(rename
->rn_tname
, rename
->rn_tnamelen
);
812 if ((status
= check_filename(rename
->rn_sname
, rename
->rn_snamelen
, nfserr_noent
)))
814 if ((status
= check_filename(rename
->rn_tname
, rename
->rn_tnamelen
, nfserr_inval
)))
821 nfsd4_decode_renew(struct nfsd4_compoundargs
*argp
, clientid_t
*clientid
)
825 READ_BUF(sizeof(clientid_t
));
826 COPYMEM(clientid
, sizeof(clientid_t
));
832 nfsd4_decode_secinfo(struct nfsd4_compoundargs
*argp
,
833 struct nfsd4_secinfo
*secinfo
)
838 READ32(secinfo
->si_namelen
);
839 READ_BUF(secinfo
->si_namelen
);
840 SAVEMEM(secinfo
->si_name
, secinfo
->si_namelen
);
841 status
= check_filename(secinfo
->si_name
, secinfo
->si_namelen
,
849 nfsd4_decode_setattr(struct nfsd4_compoundargs
*argp
, struct nfsd4_setattr
*setattr
)
853 status
= nfsd4_decode_stateid(argp
, &setattr
->sa_stateid
);
856 return nfsd4_decode_fattr(argp
, setattr
->sa_bmval
, &setattr
->sa_iattr
,
861 nfsd4_decode_setclientid(struct nfsd4_compoundargs
*argp
, struct nfsd4_setclientid
*setclientid
)
866 COPYMEM(setclientid
->se_verf
.data
, 8);
867 READ32(setclientid
->se_namelen
);
869 READ_BUF(setclientid
->se_namelen
+ 8);
870 SAVEMEM(setclientid
->se_name
, setclientid
->se_namelen
);
871 READ32(setclientid
->se_callback_prog
);
872 READ32(setclientid
->se_callback_netid_len
);
874 READ_BUF(setclientid
->se_callback_netid_len
+ 4);
875 SAVEMEM(setclientid
->se_callback_netid_val
, setclientid
->se_callback_netid_len
);
876 READ32(setclientid
->se_callback_addr_len
);
878 READ_BUF(setclientid
->se_callback_addr_len
+ 4);
879 SAVEMEM(setclientid
->se_callback_addr_val
, setclientid
->se_callback_addr_len
);
880 READ32(setclientid
->se_callback_ident
);
886 nfsd4_decode_setclientid_confirm(struct nfsd4_compoundargs
*argp
, struct nfsd4_setclientid_confirm
*scd_c
)
890 READ_BUF(8 + sizeof(nfs4_verifier
));
891 COPYMEM(&scd_c
->sc_clientid
, 8);
892 COPYMEM(&scd_c
->sc_confirm
, sizeof(nfs4_verifier
));
897 /* Also used for NVERIFY */
899 nfsd4_decode_verify(struct nfsd4_compoundargs
*argp
, struct nfsd4_verify
*verify
)
902 struct nfsd4_compoundargs save
= {
905 .rqstp
= argp
->rqstp
,
908 struct iattr ve_iattr
; /* request */
909 struct nfs4_acl
*ve_acl
; /* request */
913 if ((status
= nfsd4_decode_bitmap(argp
, verify
->ve_bmval
)))
916 /* For convenience's sake, we compare raw xdr'd attributes in
917 * nfsd4_proc_verify; however we still decode here just to return
918 * correct error in case of bad xdr. */
920 status
= nfsd4_decode_fattr(ve_bmval
, &ve_iattr
, &ve_acl
);
921 if (status
== nfserr_inval
) {
922 status
= nfserrno(status
);
927 READ32(verify
->ve_attrlen
);
928 READ_BUF(verify
->ve_attrlen
);
929 SAVEMEM(verify
->ve_attrval
, verify
->ve_attrlen
);
935 nfsd4_decode_write(struct nfsd4_compoundargs
*argp
, struct nfsd4_write
*write
)
942 status
= nfsd4_decode_stateid(argp
, &write
->wr_stateid
);
946 READ64(write
->wr_offset
);
947 READ32(write
->wr_stable_how
);
948 if (write
->wr_stable_how
> 2)
950 READ32(write
->wr_buflen
);
952 /* Sorry .. no magic macros for this.. *
953 * READ_BUF(write->wr_buflen);
954 * SAVEMEM(write->wr_buf, write->wr_buflen);
956 avail
= (char*)argp
->end
- (char*)argp
->p
;
957 if (avail
+ argp
->pagelen
< write
->wr_buflen
) {
958 dprintk("NFSD: xdr error (%s:%d)\n",
962 argp
->rqstp
->rq_vec
[0].iov_base
= p
;
963 argp
->rqstp
->rq_vec
[0].iov_len
= avail
;
965 len
= write
->wr_buflen
;
966 while (len
> argp
->rqstp
->rq_vec
[v
].iov_len
) {
967 len
-= argp
->rqstp
->rq_vec
[v
].iov_len
;
969 argp
->rqstp
->rq_vec
[v
].iov_base
= page_address(argp
->pagelist
[0]);
971 if (argp
->pagelen
>= PAGE_SIZE
) {
972 argp
->rqstp
->rq_vec
[v
].iov_len
= PAGE_SIZE
;
973 argp
->pagelen
-= PAGE_SIZE
;
975 argp
->rqstp
->rq_vec
[v
].iov_len
= argp
->pagelen
;
976 argp
->pagelen
-= len
;
979 argp
->end
= (__be32
*) (argp
->rqstp
->rq_vec
[v
].iov_base
+ argp
->rqstp
->rq_vec
[v
].iov_len
);
980 argp
->p
= (__be32
*) (argp
->rqstp
->rq_vec
[v
].iov_base
+ (XDR_QUADLEN(len
) << 2));
981 argp
->rqstp
->rq_vec
[v
].iov_len
= len
;
982 write
->wr_vlen
= v
+1;
988 nfsd4_decode_release_lockowner(struct nfsd4_compoundargs
*argp
, struct nfsd4_release_lockowner
*rlockowner
)
993 COPYMEM(&rlockowner
->rl_clientid
, sizeof(clientid_t
));
994 READ32(rlockowner
->rl_owner
.len
);
995 READ_BUF(rlockowner
->rl_owner
.len
);
996 READMEM(rlockowner
->rl_owner
.data
, rlockowner
->rl_owner
.len
);
998 if (argp
->minorversion
&& !zero_clientid(&rlockowner
->rl_clientid
))
1004 nfsd4_decode_exchange_id(struct nfsd4_compoundargs
*argp
,
1005 struct nfsd4_exchange_id
*exid
)
1010 READ_BUF(NFS4_VERIFIER_SIZE
);
1011 COPYMEM(exid
->verifier
.data
, NFS4_VERIFIER_SIZE
);
1014 READ32(exid
->clname
.len
);
1016 READ_BUF(exid
->clname
.len
);
1017 SAVEMEM(exid
->clname
.data
, exid
->clname
.len
);
1020 READ32(exid
->flags
);
1022 /* Ignore state_protect4_a */
1024 READ32(exid
->spa_how
);
1025 switch (exid
->spa_how
) {
1029 /* spo_must_enforce */
1032 READ_BUF(dummy
* 4);
1035 /* spo_must_allow */
1038 READ_BUF(dummy
* 4);
1045 READ_BUF(dummy
* 4);
1050 READ_BUF(dummy
* 4);
1053 /* ssp_hash_algs<> */
1057 p
+= XDR_QUADLEN(dummy
);
1059 /* ssp_encr_algs<> */
1063 p
+= XDR_QUADLEN(dummy
);
1065 /* ssp_window and ssp_num_gss_handles */
1074 /* Ignore Implementation ID */
1075 READ_BUF(4); /* nfs_impl_id4 array length */
1086 p
+= XDR_QUADLEN(dummy
);
1092 p
+= XDR_QUADLEN(dummy
);
1102 nfsd4_decode_create_session(struct nfsd4_compoundargs
*argp
,
1103 struct nfsd4_create_session
*sess
)
1113 COPYMEM(&sess
->clientid
, 8);
1114 READ32(sess
->seqid
);
1115 READ32(sess
->flags
);
1117 /* Fore channel attrs */
1119 READ32(dummy
); /* headerpadsz is always 0 */
1120 READ32(sess
->fore_channel
.maxreq_sz
);
1121 READ32(sess
->fore_channel
.maxresp_sz
);
1122 READ32(sess
->fore_channel
.maxresp_cached
);
1123 READ32(sess
->fore_channel
.maxops
);
1124 READ32(sess
->fore_channel
.maxreqs
);
1125 READ32(sess
->fore_channel
.nr_rdma_attrs
);
1126 if (sess
->fore_channel
.nr_rdma_attrs
== 1) {
1128 READ32(sess
->fore_channel
.rdma_attrs
);
1129 } else if (sess
->fore_channel
.nr_rdma_attrs
> 1) {
1130 dprintk("Too many fore channel attr bitmaps!\n");
1134 /* Back channel attrs */
1136 READ32(dummy
); /* headerpadsz is always 0 */
1137 READ32(sess
->back_channel
.maxreq_sz
);
1138 READ32(sess
->back_channel
.maxresp_sz
);
1139 READ32(sess
->back_channel
.maxresp_cached
);
1140 READ32(sess
->back_channel
.maxops
);
1141 READ32(sess
->back_channel
.maxreqs
);
1142 READ32(sess
->back_channel
.nr_rdma_attrs
);
1143 if (sess
->back_channel
.nr_rdma_attrs
== 1) {
1145 READ32(sess
->back_channel
.rdma_attrs
);
1146 } else if (sess
->back_channel
.nr_rdma_attrs
> 1) {
1147 dprintk("Too many back channel attr bitmaps!\n");
1152 READ32(sess
->callback_prog
);
1154 /* callback_sec_params4 */
1155 READ32(nr_secflavs
);
1156 for (i
= 0; i
< nr_secflavs
; ++i
) {
1161 /* Nothing to read */
1171 SAVEMEM(machine_name
, dummy
);
1181 READ_BUF(dummy
* 4);
1184 dprintk("RPC_AUTH_GSS callback secflavor "
1185 "not supported!\n");
1189 /* gcbp_handle_from_server */
1192 p
+= XDR_QUADLEN(dummy
);
1193 /* gcbp_handle_from_client */
1199 dprintk("Illegal callback secflavor\n");
1200 return nfserr_inval
;
1207 nfsd4_decode_destroy_session(struct nfsd4_compoundargs
*argp
,
1208 struct nfsd4_destroy_session
*destroy_session
)
1211 READ_BUF(NFS4_MAX_SESSIONID_LEN
);
1212 COPYMEM(destroy_session
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
1218 nfsd4_decode_sequence(struct nfsd4_compoundargs
*argp
,
1219 struct nfsd4_sequence
*seq
)
1223 READ_BUF(NFS4_MAX_SESSIONID_LEN
+ 16);
1224 COPYMEM(seq
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
1226 READ32(seq
->slotid
);
1227 READ32(seq
->maxslots
);
1228 READ32(seq
->cachethis
);
1234 nfsd4_decode_noop(struct nfsd4_compoundargs
*argp
, void *p
)
1240 nfsd4_decode_notsupp(struct nfsd4_compoundargs
*argp
, void *p
)
1242 return nfserr_notsupp
;
1245 typedef __be32(*nfsd4_dec
)(struct nfsd4_compoundargs
*argp
, void *);
1247 static nfsd4_dec nfsd4_dec_ops
[] = {
1248 [OP_ACCESS
] = (nfsd4_dec
)nfsd4_decode_access
,
1249 [OP_CLOSE
] = (nfsd4_dec
)nfsd4_decode_close
,
1250 [OP_COMMIT
] = (nfsd4_dec
)nfsd4_decode_commit
,
1251 [OP_CREATE
] = (nfsd4_dec
)nfsd4_decode_create
,
1252 [OP_DELEGPURGE
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1253 [OP_DELEGRETURN
] = (nfsd4_dec
)nfsd4_decode_delegreturn
,
1254 [OP_GETATTR
] = (nfsd4_dec
)nfsd4_decode_getattr
,
1255 [OP_GETFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1256 [OP_LINK
] = (nfsd4_dec
)nfsd4_decode_link
,
1257 [OP_LOCK
] = (nfsd4_dec
)nfsd4_decode_lock
,
1258 [OP_LOCKT
] = (nfsd4_dec
)nfsd4_decode_lockt
,
1259 [OP_LOCKU
] = (nfsd4_dec
)nfsd4_decode_locku
,
1260 [OP_LOOKUP
] = (nfsd4_dec
)nfsd4_decode_lookup
,
1261 [OP_LOOKUPP
] = (nfsd4_dec
)nfsd4_decode_noop
,
1262 [OP_NVERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
1263 [OP_OPEN
] = (nfsd4_dec
)nfsd4_decode_open
,
1264 [OP_OPENATTR
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1265 [OP_OPEN_CONFIRM
] = (nfsd4_dec
)nfsd4_decode_open_confirm
,
1266 [OP_OPEN_DOWNGRADE
] = (nfsd4_dec
)nfsd4_decode_open_downgrade
,
1267 [OP_PUTFH
] = (nfsd4_dec
)nfsd4_decode_putfh
,
1268 [OP_PUTPUBFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1269 [OP_PUTROOTFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1270 [OP_READ
] = (nfsd4_dec
)nfsd4_decode_read
,
1271 [OP_READDIR
] = (nfsd4_dec
)nfsd4_decode_readdir
,
1272 [OP_READLINK
] = (nfsd4_dec
)nfsd4_decode_noop
,
1273 [OP_REMOVE
] = (nfsd4_dec
)nfsd4_decode_remove
,
1274 [OP_RENAME
] = (nfsd4_dec
)nfsd4_decode_rename
,
1275 [OP_RENEW
] = (nfsd4_dec
)nfsd4_decode_renew
,
1276 [OP_RESTOREFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1277 [OP_SAVEFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1278 [OP_SECINFO
] = (nfsd4_dec
)nfsd4_decode_secinfo
,
1279 [OP_SETATTR
] = (nfsd4_dec
)nfsd4_decode_setattr
,
1280 [OP_SETCLIENTID
] = (nfsd4_dec
)nfsd4_decode_setclientid
,
1281 [OP_SETCLIENTID_CONFIRM
] = (nfsd4_dec
)nfsd4_decode_setclientid_confirm
,
1282 [OP_VERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
1283 [OP_WRITE
] = (nfsd4_dec
)nfsd4_decode_write
,
1284 [OP_RELEASE_LOCKOWNER
] = (nfsd4_dec
)nfsd4_decode_release_lockowner
,
1287 static nfsd4_dec nfsd41_dec_ops
[] = {
1288 [OP_ACCESS
] = (nfsd4_dec
)nfsd4_decode_access
,
1289 [OP_CLOSE
] = (nfsd4_dec
)nfsd4_decode_close
,
1290 [OP_COMMIT
] = (nfsd4_dec
)nfsd4_decode_commit
,
1291 [OP_CREATE
] = (nfsd4_dec
)nfsd4_decode_create
,
1292 [OP_DELEGPURGE
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1293 [OP_DELEGRETURN
] = (nfsd4_dec
)nfsd4_decode_delegreturn
,
1294 [OP_GETATTR
] = (nfsd4_dec
)nfsd4_decode_getattr
,
1295 [OP_GETFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1296 [OP_LINK
] = (nfsd4_dec
)nfsd4_decode_link
,
1297 [OP_LOCK
] = (nfsd4_dec
)nfsd4_decode_lock
,
1298 [OP_LOCKT
] = (nfsd4_dec
)nfsd4_decode_lockt
,
1299 [OP_LOCKU
] = (nfsd4_dec
)nfsd4_decode_locku
,
1300 [OP_LOOKUP
] = (nfsd4_dec
)nfsd4_decode_lookup
,
1301 [OP_LOOKUPP
] = (nfsd4_dec
)nfsd4_decode_noop
,
1302 [OP_NVERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
1303 [OP_OPEN
] = (nfsd4_dec
)nfsd4_decode_open
,
1304 [OP_OPENATTR
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1305 [OP_OPEN_CONFIRM
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1306 [OP_OPEN_DOWNGRADE
] = (nfsd4_dec
)nfsd4_decode_open_downgrade
,
1307 [OP_PUTFH
] = (nfsd4_dec
)nfsd4_decode_putfh
,
1308 [OP_PUTPUBFH
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1309 [OP_PUTROOTFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1310 [OP_READ
] = (nfsd4_dec
)nfsd4_decode_read
,
1311 [OP_READDIR
] = (nfsd4_dec
)nfsd4_decode_readdir
,
1312 [OP_READLINK
] = (nfsd4_dec
)nfsd4_decode_noop
,
1313 [OP_REMOVE
] = (nfsd4_dec
)nfsd4_decode_remove
,
1314 [OP_RENAME
] = (nfsd4_dec
)nfsd4_decode_rename
,
1315 [OP_RENEW
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1316 [OP_RESTOREFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1317 [OP_SAVEFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1318 [OP_SECINFO
] = (nfsd4_dec
)nfsd4_decode_secinfo
,
1319 [OP_SETATTR
] = (nfsd4_dec
)nfsd4_decode_setattr
,
1320 [OP_SETCLIENTID
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1321 [OP_SETCLIENTID_CONFIRM
]= (nfsd4_dec
)nfsd4_decode_notsupp
,
1322 [OP_VERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
1323 [OP_WRITE
] = (nfsd4_dec
)nfsd4_decode_write
,
1324 [OP_RELEASE_LOCKOWNER
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1326 /* new operations for NFSv4.1 */
1327 [OP_BACKCHANNEL_CTL
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1328 [OP_BIND_CONN_TO_SESSION
]= (nfsd4_dec
)nfsd4_decode_notsupp
,
1329 [OP_EXCHANGE_ID
] = (nfsd4_dec
)nfsd4_decode_exchange_id
,
1330 [OP_CREATE_SESSION
] = (nfsd4_dec
)nfsd4_decode_create_session
,
1331 [OP_DESTROY_SESSION
] = (nfsd4_dec
)nfsd4_decode_destroy_session
,
1332 [OP_FREE_STATEID
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1333 [OP_GET_DIR_DELEGATION
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1334 [OP_GETDEVICEINFO
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1335 [OP_GETDEVICELIST
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1336 [OP_LAYOUTCOMMIT
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1337 [OP_LAYOUTGET
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1338 [OP_LAYOUTRETURN
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1339 [OP_SECINFO_NO_NAME
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1340 [OP_SEQUENCE
] = (nfsd4_dec
)nfsd4_decode_sequence
,
1341 [OP_SET_SSV
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1342 [OP_TEST_STATEID
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1343 [OP_WANT_DELEGATION
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1344 [OP_DESTROY_CLIENTID
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1345 [OP_RECLAIM_COMPLETE
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1348 struct nfsd4_minorversion_ops
{
1349 nfsd4_dec
*decoders
;
1353 static struct nfsd4_minorversion_ops nfsd4_minorversion
[] = {
1354 [0] = { nfsd4_dec_ops
, ARRAY_SIZE(nfsd4_dec_ops
) },
1355 [1] = { nfsd41_dec_ops
, ARRAY_SIZE(nfsd41_dec_ops
) },
1359 nfsd4_decode_compound(struct nfsd4_compoundargs
*argp
)
1362 struct nfsd4_op
*op
;
1363 struct nfsd4_minorversion_ops
*ops
;
1367 * XXX: According to spec, we should check the tag
1368 * for UTF-8 compliance. I'm postponing this for
1369 * now because it seems that some clients do use
1373 READ32(argp
->taglen
);
1374 READ_BUF(argp
->taglen
+ 8);
1375 SAVEMEM(argp
->tag
, argp
->taglen
);
1376 READ32(argp
->minorversion
);
1377 READ32(argp
->opcnt
);
1379 if (argp
->taglen
> NFSD4_MAX_TAGLEN
)
1381 if (argp
->opcnt
> 100)
1384 if (argp
->opcnt
> ARRAY_SIZE(argp
->iops
)) {
1385 argp
->ops
= kmalloc(argp
->opcnt
* sizeof(*argp
->ops
), GFP_KERNEL
);
1387 argp
->ops
= argp
->iops
;
1388 dprintk("nfsd: couldn't allocate room for COMPOUND\n");
1393 if (argp
->minorversion
>= ARRAY_SIZE(nfsd4_minorversion
))
1396 ops
= &nfsd4_minorversion
[argp
->minorversion
];
1397 for (i
= 0; i
< argp
->opcnt
; i
++) {
1402 * We can't use READ_BUF() here because we need to handle
1403 * a missing opcode as an OP_WRITE + 1. So we need to check
1404 * to see if we're truly at the end of our buffer or if there
1405 * is another page we need to flip to.
1408 if (argp
->p
== argp
->end
) {
1409 if (argp
->pagelen
< 4) {
1410 /* There isn't an opcode still on the wire */
1411 op
->opnum
= OP_WRITE
+ 1;
1412 op
->status
= nfserr_bad_xdr
;
1418 * False alarm. We just hit a page boundary, but there
1419 * is still data available. Move pointer across page
1420 * boundary. *snip from READ_BUF*
1422 argp
->p
= page_address(argp
->pagelist
[0]);
1424 if (argp
->pagelen
< PAGE_SIZE
) {
1425 argp
->end
= argp
->p
+ (argp
->pagelen
>>2);
1428 argp
->end
= argp
->p
+ (PAGE_SIZE
>>2);
1429 argp
->pagelen
-= PAGE_SIZE
;
1432 op
->opnum
= ntohl(*argp
->p
++);
1434 if (op
->opnum
>= OP_ACCESS
&& op
->opnum
< ops
->nops
)
1435 op
->status
= ops
->decoders
[op
->opnum
](argp
, &op
->u
);
1437 op
->opnum
= OP_ILLEGAL
;
1438 op
->status
= nfserr_op_illegal
;
1450 #define WRITE32(n) *p++ = htonl(n)
1451 #define WRITE64(n) do { \
1452 *p++ = htonl((u32)((n) >> 32)); \
1453 *p++ = htonl((u32)(n)); \
1455 #define WRITEMEM(ptr,nbytes) do { if (nbytes > 0) { \
1456 *(p + XDR_QUADLEN(nbytes) -1) = 0; \
1457 memcpy(p, ptr, nbytes); \
1458 p += XDR_QUADLEN(nbytes); \
1461 static void write32(__be32
**p
, u32 n
)
1466 static void write64(__be32
**p
, u64 n
)
1468 write32(p
, (u32
)(n
>> 32));
1472 static void write_change(__be32
**p
, struct kstat
*stat
, struct inode
*inode
)
1474 if (IS_I_VERSION(inode
)) {
1475 write64(p
, inode
->i_version
);
1477 write32(p
, stat
->ctime
.tv_sec
);
1478 write32(p
, stat
->ctime
.tv_nsec
);
1482 static void write_cinfo(__be32
**p
, struct nfsd4_change_info
*c
)
1484 write32(p
, c
->atomic
);
1485 if (c
->change_supported
) {
1486 write64(p
, c
->before_change
);
1487 write64(p
, c
->after_change
);
1489 write32(p
, c
->before_ctime_sec
);
1490 write32(p
, c
->before_ctime_nsec
);
1491 write32(p
, c
->after_ctime_sec
);
1492 write32(p
, c
->after_ctime_nsec
);
1496 #define RESERVE_SPACE(nbytes) do { \
1498 BUG_ON(p + XDR_QUADLEN(nbytes) > resp->end); \
1500 #define ADJUST_ARGS() resp->p = p
1503 * Header routine to setup seqid operation replay cache
1505 #define ENCODE_SEQID_OP_HEAD \
1511 * Routine for encoding the result of a "seqid-mutating" NFSv4 operation. This
1512 * is where sequence id's are incremented, and the replay cache is filled.
1513 * Note that we increment sequence id's here, at the last moment, so we're sure
1514 * we know whether the error to be returned is a sequence id mutating error.
1517 #define ENCODE_SEQID_OP_TAIL(stateowner) do { \
1518 if (seqid_mutating_err(nfserr) && stateowner) { \
1519 stateowner->so_seqid++; \
1520 stateowner->so_replay.rp_status = nfserr; \
1521 stateowner->so_replay.rp_buflen = \
1522 (((char *)(resp)->p - (char *)save)); \
1523 memcpy(stateowner->so_replay.rp_buf, save, \
1524 stateowner->so_replay.rp_buflen); \
1527 /* Encode as an array of strings the string given with components
1530 static __be32
nfsd4_encode_components(char sep
, char *components
,
1531 __be32
**pp
, int *buflen
)
1535 int strlen
, count
=0;
1538 dprintk("nfsd4_encode_components(%s)\n", components
);
1539 if ((*buflen
-= 4) < 0)
1540 return nfserr_resource
;
1541 WRITE32(0); /* We will fill this in with @count later */
1542 end
= str
= components
;
1544 for (; *end
&& (*end
!= sep
); end
++)
1545 ; /* Point to end of component */
1548 if ((*buflen
-= ((XDR_QUADLEN(strlen
) << 2) + 4)) < 0)
1549 return nfserr_resource
;
1551 WRITEMEM(str
, strlen
);
1565 * encode a location element of a fs_locations structure
1567 static __be32
nfsd4_encode_fs_location4(struct nfsd4_fs_location
*location
,
1568 __be32
**pp
, int *buflen
)
1573 status
= nfsd4_encode_components(':', location
->hosts
, &p
, buflen
);
1576 status
= nfsd4_encode_components('/', location
->path
, &p
, buflen
);
1584 * Return the path to an export point in the pseudo filesystem namespace
1585 * Returned string is safe to use as long as the caller holds a reference
1588 static char *nfsd4_path(struct svc_rqst
*rqstp
, struct svc_export
*exp
, __be32
*stat
)
1590 struct svc_fh tmp_fh
;
1591 char *path
= NULL
, *rootpath
;
1594 fh_init(&tmp_fh
, NFS4_FHSIZE
);
1595 *stat
= exp_pseudoroot(rqstp
, &tmp_fh
);
1598 rootpath
= tmp_fh
.fh_export
->ex_pathname
;
1600 path
= exp
->ex_pathname
;
1602 rootlen
= strlen(rootpath
);
1603 if (strncmp(path
, rootpath
, rootlen
)) {
1604 dprintk("nfsd: fs_locations failed;"
1605 "%s is not contained in %s\n", path
, rootpath
);
1606 *stat
= nfserr_notsupp
;
1617 * encode a fs_locations structure
1619 static __be32
nfsd4_encode_fs_locations(struct svc_rqst
*rqstp
,
1620 struct svc_export
*exp
,
1621 __be32
**pp
, int *buflen
)
1626 struct nfsd4_fs_locations
*fslocs
= &exp
->ex_fslocs
;
1627 char *root
= nfsd4_path(rqstp
, exp
, &status
);
1631 status
= nfsd4_encode_components('/', root
, &p
, buflen
);
1634 if ((*buflen
-= 4) < 0)
1635 return nfserr_resource
;
1636 WRITE32(fslocs
->locations_count
);
1637 for (i
=0; i
<fslocs
->locations_count
; i
++) {
1638 status
= nfsd4_encode_fs_location4(&fslocs
->locations
[i
],
1647 static u32 nfs4_ftypes
[16] = {
1648 NF4BAD
, NF4FIFO
, NF4CHR
, NF4BAD
,
1649 NF4DIR
, NF4BAD
, NF4BLK
, NF4BAD
,
1650 NF4REG
, NF4BAD
, NF4LNK
, NF4BAD
,
1651 NF4SOCK
, NF4BAD
, NF4LNK
, NF4BAD
,
1655 nfsd4_encode_name(struct svc_rqst
*rqstp
, int whotype
, uid_t id
, int group
,
1656 __be32
**p
, int *buflen
)
1660 if (*buflen
< (XDR_QUADLEN(IDMAP_NAMESZ
) << 2) + 4)
1661 return nfserr_resource
;
1662 if (whotype
!= NFS4_ACL_WHO_NAMED
)
1663 status
= nfs4_acl_write_who(whotype
, (u8
*)(*p
+ 1));
1665 status
= nfsd_map_gid_to_name(rqstp
, id
, (u8
*)(*p
+ 1));
1667 status
= nfsd_map_uid_to_name(rqstp
, id
, (u8
*)(*p
+ 1));
1669 return nfserrno(status
);
1670 *p
= xdr_encode_opaque(*p
, NULL
, status
);
1671 *buflen
-= (XDR_QUADLEN(status
) << 2) + 4;
1672 BUG_ON(*buflen
< 0);
1676 static inline __be32
1677 nfsd4_encode_user(struct svc_rqst
*rqstp
, uid_t uid
, __be32
**p
, int *buflen
)
1679 return nfsd4_encode_name(rqstp
, NFS4_ACL_WHO_NAMED
, uid
, 0, p
, buflen
);
1682 static inline __be32
1683 nfsd4_encode_group(struct svc_rqst
*rqstp
, uid_t gid
, __be32
**p
, int *buflen
)
1685 return nfsd4_encode_name(rqstp
, NFS4_ACL_WHO_NAMED
, gid
, 1, p
, buflen
);
1688 static inline __be32
1689 nfsd4_encode_aclname(struct svc_rqst
*rqstp
, int whotype
, uid_t id
, int group
,
1690 __be32
**p
, int *buflen
)
1692 return nfsd4_encode_name(rqstp
, whotype
, id
, group
, p
, buflen
);
1695 #define WORD0_ABSENT_FS_ATTRS (FATTR4_WORD0_FS_LOCATIONS | FATTR4_WORD0_FSID | \
1696 FATTR4_WORD0_RDATTR_ERROR)
1697 #define WORD1_ABSENT_FS_ATTRS FATTR4_WORD1_MOUNTED_ON_FILEID
1699 static __be32
fattr_handle_absent_fs(u32
*bmval0
, u32
*bmval1
, u32
*rdattr_err
)
1701 /* As per referral draft: */
1702 if (*bmval0
& ~WORD0_ABSENT_FS_ATTRS
||
1703 *bmval1
& ~WORD1_ABSENT_FS_ATTRS
) {
1704 if (*bmval0
& FATTR4_WORD0_RDATTR_ERROR
||
1705 *bmval0
& FATTR4_WORD0_FS_LOCATIONS
)
1706 *rdattr_err
= NFSERR_MOVED
;
1708 return nfserr_moved
;
1710 *bmval0
&= WORD0_ABSENT_FS_ATTRS
;
1711 *bmval1
&= WORD1_ABSENT_FS_ATTRS
;
1716 * Note: @fhp can be NULL; in this case, we might have to compose the filehandle
1719 * @countp is the buffer size in _words_; upon successful return this becomes
1720 * replaced with the number of words written.
1723 nfsd4_encode_fattr(struct svc_fh
*fhp
, struct svc_export
*exp
,
1724 struct dentry
*dentry
, __be32
*buffer
, int *countp
, u32
*bmval
,
1725 struct svc_rqst
*rqstp
, int ignore_crossmnt
)
1727 u32 bmval0
= bmval
[0];
1728 u32 bmval1
= bmval
[1];
1729 u32 bmval2
= bmval
[2];
1731 struct svc_fh tempfh
;
1732 struct kstatfs statfs
;
1733 int buflen
= *countp
<< 2;
1742 struct nfs4_acl
*acl
= NULL
;
1743 struct nfsd4_compoundres
*resp
= rqstp
->rq_resp
;
1744 u32 minorversion
= resp
->cstate
.minorversion
;
1746 BUG_ON(bmval1
& NFSD_WRITEONLY_ATTRS_WORD1
);
1747 BUG_ON(bmval0
& ~nfsd_suppattrs0(minorversion
));
1748 BUG_ON(bmval1
& ~nfsd_suppattrs1(minorversion
));
1749 BUG_ON(bmval2
& ~nfsd_suppattrs2(minorversion
));
1751 if (exp
->ex_fslocs
.migrated
) {
1753 status
= fattr_handle_absent_fs(&bmval0
, &bmval1
, &rdattr_err
);
1758 err
= vfs_getattr(exp
->ex_path
.mnt
, dentry
, &stat
);
1761 if ((bmval0
& (FATTR4_WORD0_FILES_FREE
| FATTR4_WORD0_FILES_TOTAL
|
1762 FATTR4_WORD0_MAXNAME
)) ||
1763 (bmval1
& (FATTR4_WORD1_SPACE_AVAIL
| FATTR4_WORD1_SPACE_FREE
|
1764 FATTR4_WORD1_SPACE_TOTAL
))) {
1765 err
= vfs_statfs(dentry
, &statfs
);
1769 if ((bmval0
& (FATTR4_WORD0_FILEHANDLE
| FATTR4_WORD0_FSID
)) && !fhp
) {
1770 fh_init(&tempfh
, NFS4_FHSIZE
);
1771 status
= fh_compose(&tempfh
, exp
, dentry
, NULL
);
1776 if (bmval0
& (FATTR4_WORD0_ACL
| FATTR4_WORD0_ACLSUPPORT
1777 | FATTR4_WORD0_SUPPORTED_ATTRS
)) {
1778 err
= nfsd4_get_nfs4_acl(rqstp
, dentry
, &acl
);
1779 aclsupport
= (err
== 0);
1780 if (bmval0
& FATTR4_WORD0_ACL
) {
1781 if (err
== -EOPNOTSUPP
)
1782 bmval0
&= ~FATTR4_WORD0_ACL
;
1783 else if (err
== -EINVAL
) {
1784 status
= nfserr_attrnotsupp
;
1786 } else if (err
!= 0)
1790 if ((buflen
-= 16) < 0)
1793 if (unlikely(bmval2
)) {
1798 } else if (likely(bmval1
)) {
1806 attrlenp
= p
++; /* to be backfilled later */
1808 if (bmval0
& FATTR4_WORD0_SUPPORTED_ATTRS
) {
1809 u32 word0
= nfsd_suppattrs0(minorversion
);
1810 u32 word1
= nfsd_suppattrs1(minorversion
);
1811 u32 word2
= nfsd_suppattrs2(minorversion
);
1813 if ((buflen
-= 12) < 0)
1816 word0
&= ~FATTR4_WORD0_ACL
;
1828 if (bmval0
& FATTR4_WORD0_TYPE
) {
1829 if ((buflen
-= 4) < 0)
1831 dummy
= nfs4_ftypes
[(stat
.mode
& S_IFMT
) >> 12];
1832 if (dummy
== NF4BAD
)
1833 goto out_serverfault
;
1836 if (bmval0
& FATTR4_WORD0_FH_EXPIRE_TYPE
) {
1837 if ((buflen
-= 4) < 0)
1839 if (exp
->ex_flags
& NFSEXP_NOSUBTREECHECK
)
1840 WRITE32(NFS4_FH_PERSISTENT
);
1842 WRITE32(NFS4_FH_PERSISTENT
|NFS4_FH_VOL_RENAME
);
1844 if (bmval0
& FATTR4_WORD0_CHANGE
) {
1845 if ((buflen
-= 8) < 0)
1847 write_change(&p
, &stat
, dentry
->d_inode
);
1849 if (bmval0
& FATTR4_WORD0_SIZE
) {
1850 if ((buflen
-= 8) < 0)
1854 if (bmval0
& FATTR4_WORD0_LINK_SUPPORT
) {
1855 if ((buflen
-= 4) < 0)
1859 if (bmval0
& FATTR4_WORD0_SYMLINK_SUPPORT
) {
1860 if ((buflen
-= 4) < 0)
1864 if (bmval0
& FATTR4_WORD0_NAMED_ATTR
) {
1865 if ((buflen
-= 4) < 0)
1869 if (bmval0
& FATTR4_WORD0_FSID
) {
1870 if ((buflen
-= 16) < 0)
1872 if (exp
->ex_fslocs
.migrated
) {
1873 WRITE64(NFS4_REFERRAL_FSID_MAJOR
);
1874 WRITE64(NFS4_REFERRAL_FSID_MINOR
);
1875 } else switch(fsid_source(fhp
)) {
1876 case FSIDSOURCE_FSID
:
1877 WRITE64((u64
)exp
->ex_fsid
);
1880 case FSIDSOURCE_DEV
:
1882 WRITE32(MAJOR(stat
.dev
));
1884 WRITE32(MINOR(stat
.dev
));
1886 case FSIDSOURCE_UUID
:
1887 WRITEMEM(exp
->ex_uuid
, 16);
1891 if (bmval0
& FATTR4_WORD0_UNIQUE_HANDLES
) {
1892 if ((buflen
-= 4) < 0)
1896 if (bmval0
& FATTR4_WORD0_LEASE_TIME
) {
1897 if ((buflen
-= 4) < 0)
1899 WRITE32(NFSD_LEASE_TIME
);
1901 if (bmval0
& FATTR4_WORD0_RDATTR_ERROR
) {
1902 if ((buflen
-= 4) < 0)
1904 WRITE32(rdattr_err
);
1906 if (bmval0
& FATTR4_WORD0_ACL
) {
1907 struct nfs4_ace
*ace
;
1910 if ((buflen
-= 4) < 0)
1916 if ((buflen
-= 4) < 0)
1918 WRITE32(acl
->naces
);
1920 for (ace
= acl
->aces
; ace
< acl
->aces
+ acl
->naces
; ace
++) {
1921 if ((buflen
-= 4*3) < 0)
1925 WRITE32(ace
->access_mask
& NFS4_ACE_MASK_ALL
);
1926 status
= nfsd4_encode_aclname(rqstp
, ace
->whotype
,
1927 ace
->who
, ace
->flag
& NFS4_ACE_IDENTIFIER_GROUP
,
1929 if (status
== nfserr_resource
)
1936 if (bmval0
& FATTR4_WORD0_ACLSUPPORT
) {
1937 if ((buflen
-= 4) < 0)
1939 WRITE32(aclsupport
?
1940 ACL4_SUPPORT_ALLOW_ACL
|ACL4_SUPPORT_DENY_ACL
: 0);
1942 if (bmval0
& FATTR4_WORD0_CANSETTIME
) {
1943 if ((buflen
-= 4) < 0)
1947 if (bmval0
& FATTR4_WORD0_CASE_INSENSITIVE
) {
1948 if ((buflen
-= 4) < 0)
1952 if (bmval0
& FATTR4_WORD0_CASE_PRESERVING
) {
1953 if ((buflen
-= 4) < 0)
1957 if (bmval0
& FATTR4_WORD0_CHOWN_RESTRICTED
) {
1958 if ((buflen
-= 4) < 0)
1962 if (bmval0
& FATTR4_WORD0_FILEHANDLE
) {
1963 buflen
-= (XDR_QUADLEN(fhp
->fh_handle
.fh_size
) << 2) + 4;
1966 WRITE32(fhp
->fh_handle
.fh_size
);
1967 WRITEMEM(&fhp
->fh_handle
.fh_base
, fhp
->fh_handle
.fh_size
);
1969 if (bmval0
& FATTR4_WORD0_FILEID
) {
1970 if ((buflen
-= 8) < 0)
1974 if (bmval0
& FATTR4_WORD0_FILES_AVAIL
) {
1975 if ((buflen
-= 8) < 0)
1977 WRITE64((u64
) statfs
.f_ffree
);
1979 if (bmval0
& FATTR4_WORD0_FILES_FREE
) {
1980 if ((buflen
-= 8) < 0)
1982 WRITE64((u64
) statfs
.f_ffree
);
1984 if (bmval0
& FATTR4_WORD0_FILES_TOTAL
) {
1985 if ((buflen
-= 8) < 0)
1987 WRITE64((u64
) statfs
.f_files
);
1989 if (bmval0
& FATTR4_WORD0_FS_LOCATIONS
) {
1990 status
= nfsd4_encode_fs_locations(rqstp
, exp
, &p
, &buflen
);
1991 if (status
== nfserr_resource
)
1996 if (bmval0
& FATTR4_WORD0_HOMOGENEOUS
) {
1997 if ((buflen
-= 4) < 0)
2001 if (bmval0
& FATTR4_WORD0_MAXFILESIZE
) {
2002 if ((buflen
-= 8) < 0)
2006 if (bmval0
& FATTR4_WORD0_MAXLINK
) {
2007 if ((buflen
-= 4) < 0)
2011 if (bmval0
& FATTR4_WORD0_MAXNAME
) {
2012 if ((buflen
-= 4) < 0)
2014 WRITE32(statfs
.f_namelen
);
2016 if (bmval0
& FATTR4_WORD0_MAXREAD
) {
2017 if ((buflen
-= 8) < 0)
2019 WRITE64((u64
) svc_max_payload(rqstp
));
2021 if (bmval0
& FATTR4_WORD0_MAXWRITE
) {
2022 if ((buflen
-= 8) < 0)
2024 WRITE64((u64
) svc_max_payload(rqstp
));
2026 if (bmval1
& FATTR4_WORD1_MODE
) {
2027 if ((buflen
-= 4) < 0)
2029 WRITE32(stat
.mode
& S_IALLUGO
);
2031 if (bmval1
& FATTR4_WORD1_NO_TRUNC
) {
2032 if ((buflen
-= 4) < 0)
2036 if (bmval1
& FATTR4_WORD1_NUMLINKS
) {
2037 if ((buflen
-= 4) < 0)
2039 WRITE32(stat
.nlink
);
2041 if (bmval1
& FATTR4_WORD1_OWNER
) {
2042 status
= nfsd4_encode_user(rqstp
, stat
.uid
, &p
, &buflen
);
2043 if (status
== nfserr_resource
)
2048 if (bmval1
& FATTR4_WORD1_OWNER_GROUP
) {
2049 status
= nfsd4_encode_group(rqstp
, stat
.gid
, &p
, &buflen
);
2050 if (status
== nfserr_resource
)
2055 if (bmval1
& FATTR4_WORD1_RAWDEV
) {
2056 if ((buflen
-= 8) < 0)
2058 WRITE32((u32
) MAJOR(stat
.rdev
));
2059 WRITE32((u32
) MINOR(stat
.rdev
));
2061 if (bmval1
& FATTR4_WORD1_SPACE_AVAIL
) {
2062 if ((buflen
-= 8) < 0)
2064 dummy64
= (u64
)statfs
.f_bavail
* (u64
)statfs
.f_bsize
;
2067 if (bmval1
& FATTR4_WORD1_SPACE_FREE
) {
2068 if ((buflen
-= 8) < 0)
2070 dummy64
= (u64
)statfs
.f_bfree
* (u64
)statfs
.f_bsize
;
2073 if (bmval1
& FATTR4_WORD1_SPACE_TOTAL
) {
2074 if ((buflen
-= 8) < 0)
2076 dummy64
= (u64
)statfs
.f_blocks
* (u64
)statfs
.f_bsize
;
2079 if (bmval1
& FATTR4_WORD1_SPACE_USED
) {
2080 if ((buflen
-= 8) < 0)
2082 dummy64
= (u64
)stat
.blocks
<< 9;
2085 if (bmval1
& FATTR4_WORD1_TIME_ACCESS
) {
2086 if ((buflen
-= 12) < 0)
2089 WRITE32(stat
.atime
.tv_sec
);
2090 WRITE32(stat
.atime
.tv_nsec
);
2092 if (bmval1
& FATTR4_WORD1_TIME_DELTA
) {
2093 if ((buflen
-= 12) < 0)
2099 if (bmval1
& FATTR4_WORD1_TIME_METADATA
) {
2100 if ((buflen
-= 12) < 0)
2103 WRITE32(stat
.ctime
.tv_sec
);
2104 WRITE32(stat
.ctime
.tv_nsec
);
2106 if (bmval1
& FATTR4_WORD1_TIME_MODIFY
) {
2107 if ((buflen
-= 12) < 0)
2110 WRITE32(stat
.mtime
.tv_sec
);
2111 WRITE32(stat
.mtime
.tv_nsec
);
2113 if (bmval1
& FATTR4_WORD1_MOUNTED_ON_FILEID
) {
2114 if ((buflen
-= 8) < 0)
2117 * Get parent's attributes if not ignoring crossmount
2118 * and this is the root of a cross-mounted filesystem.
2120 if (ignore_crossmnt
== 0 &&
2121 dentry
== exp
->ex_path
.mnt
->mnt_root
) {
2122 struct path path
= exp
->ex_path
;
2124 while (follow_up(&path
)) {
2125 if (path
.dentry
!= path
.mnt
->mnt_root
)
2128 err
= vfs_getattr(path
.mnt
, path
.dentry
, &stat
);
2135 if (bmval2
& FATTR4_WORD2_SUPPATTR_EXCLCREAT
) {
2137 WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD0
);
2138 WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD1
);
2139 WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD2
);
2142 *attrlenp
= htonl((char *)p
- (char *)attrlenp
- 4);
2143 *countp
= p
- buffer
;
2152 status
= nfserrno(err
);
2156 status
= nfserr_resource
;
2159 status
= nfserr_serverfault
;
2163 static inline int attributes_need_mount(u32
*bmval
)
2165 if (bmval
[0] & ~(FATTR4_WORD0_RDATTR_ERROR
| FATTR4_WORD0_LEASE_TIME
))
2167 if (bmval
[1] & ~FATTR4_WORD1_MOUNTED_ON_FILEID
)
2173 nfsd4_encode_dirent_fattr(struct nfsd4_readdir
*cd
,
2174 const char *name
, int namlen
, __be32
*p
, int *buflen
)
2176 struct svc_export
*exp
= cd
->rd_fhp
->fh_export
;
2177 struct dentry
*dentry
;
2179 int ignore_crossmnt
= 0;
2181 dentry
= lookup_one_len(name
, cd
->rd_fhp
->fh_dentry
, namlen
);
2183 return nfserrno(PTR_ERR(dentry
));
2184 if (!dentry
->d_inode
) {
2186 * nfsd_buffered_readdir drops the i_mutex between
2187 * readdir and calling this callback, leaving a window
2188 * where this directory entry could have gone away.
2191 return nfserr_noent
;
2196 * In the case of a mountpoint, the client may be asking for
2197 * attributes that are only properties of the underlying filesystem
2198 * as opposed to the cross-mounted file system. In such a case,
2199 * we will not follow the cross mount and will fill the attribtutes
2200 * directly from the mountpoint dentry.
2202 if (nfsd_mountpoint(dentry
, exp
)) {
2205 if (!(exp
->ex_flags
& NFSEXP_V4ROOT
)
2206 && !attributes_need_mount(cd
->rd_bmval
)) {
2207 ignore_crossmnt
= 1;
2211 * Why the heck aren't we just using nfsd_lookup??
2212 * Different "."/".." handling? Something else?
2213 * At least, add a comment here to explain....
2215 err
= nfsd_cross_mnt(cd
->rd_rqstp
, &dentry
, &exp
);
2217 nfserr
= nfserrno(err
);
2220 nfserr
= check_nfsd_access(exp
, cd
->rd_rqstp
);
2226 nfserr
= nfsd4_encode_fattr(NULL
, exp
, dentry
, p
, buflen
, cd
->rd_bmval
,
2227 cd
->rd_rqstp
, ignore_crossmnt
);
2235 nfsd4_encode_rdattr_error(__be32
*p
, int buflen
, __be32 nfserr
)
2242 *p
++ = htonl(FATTR4_WORD0_RDATTR_ERROR
); /* bmval0 */
2243 *p
++ = htonl(0); /* bmval1 */
2246 *p
++ = nfserr
; /* no htonl */
2247 *attrlenp
= htonl((char *)p
- (char *)attrlenp
- 4);
2252 nfsd4_encode_dirent(void *ccdv
, const char *name
, int namlen
,
2253 loff_t offset
, u64 ino
, unsigned int d_type
)
2255 struct readdir_cd
*ccd
= ccdv
;
2256 struct nfsd4_readdir
*cd
= container_of(ccd
, struct nfsd4_readdir
, common
);
2258 __be32
*p
= cd
->buffer
;
2260 __be32 nfserr
= nfserr_toosmall
;
2262 /* In nfsv4, "." and ".." never make it onto the wire.. */
2263 if (name
&& isdotent(name
, namlen
)) {
2264 cd
->common
.err
= nfs_ok
;
2269 xdr_encode_hyper(cd
->offset
, (u64
) offset
);
2271 buflen
= cd
->buflen
- 4 - XDR_QUADLEN(namlen
);
2275 *p
++ = xdr_one
; /* mark entry present */
2277 p
= xdr_encode_hyper(p
, NFS_OFFSET_MAX
); /* offset of next entry */
2278 p
= xdr_encode_array(p
, name
, namlen
); /* name length & name */
2280 nfserr
= nfsd4_encode_dirent_fattr(cd
, name
, namlen
, p
, &buflen
);
2285 case nfserr_resource
:
2286 nfserr
= nfserr_toosmall
;
2294 * If the client requested the RDATTR_ERROR attribute,
2295 * we stuff the error code into this attribute
2296 * and continue. If this attribute was not requested,
2297 * then in accordance with the spec, we fail the
2298 * entire READDIR operation(!)
2300 if (!(cd
->rd_bmval
[0] & FATTR4_WORD0_RDATTR_ERROR
))
2302 p
= nfsd4_encode_rdattr_error(p
, buflen
, nfserr
);
2304 nfserr
= nfserr_toosmall
;
2308 cd
->buflen
-= (p
- cd
->buffer
);
2310 cd
->offset
= cookiep
;
2312 cd
->common
.err
= nfs_ok
;
2315 cd
->common
.err
= nfserr
;
2320 nfsd4_encode_stateid(struct nfsd4_compoundres
*resp
, stateid_t
*sid
)
2324 RESERVE_SPACE(sizeof(stateid_t
));
2325 WRITE32(sid
->si_generation
);
2326 WRITEMEM(&sid
->si_opaque
, sizeof(stateid_opaque_t
));
2331 nfsd4_encode_access(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_access
*access
)
2337 WRITE32(access
->ac_supported
);
2338 WRITE32(access
->ac_resp_access
);
2345 nfsd4_encode_close(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_close
*close
)
2347 ENCODE_SEQID_OP_HEAD
;
2350 nfsd4_encode_stateid(resp
, &close
->cl_stateid
);
2352 ENCODE_SEQID_OP_TAIL(close
->cl_stateowner
);
2358 nfsd4_encode_commit(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_commit
*commit
)
2364 WRITEMEM(commit
->co_verf
.data
, 8);
2371 nfsd4_encode_create(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_create
*create
)
2377 write_cinfo(&p
, &create
->cr_cinfo
);
2379 WRITE32(create
->cr_bmval
[0]);
2380 WRITE32(create
->cr_bmval
[1]);
2387 nfsd4_encode_getattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_getattr
*getattr
)
2389 struct svc_fh
*fhp
= getattr
->ga_fhp
;
2395 buflen
= resp
->end
- resp
->p
- (COMPOUND_ERR_SLACK_SPACE
>> 2);
2396 nfserr
= nfsd4_encode_fattr(fhp
, fhp
->fh_export
, fhp
->fh_dentry
,
2397 resp
->p
, &buflen
, getattr
->ga_bmval
,
2405 nfsd4_encode_getfh(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct svc_fh
**fhpp
)
2407 struct svc_fh
*fhp
= *fhpp
;
2412 len
= fhp
->fh_handle
.fh_size
;
2413 RESERVE_SPACE(len
+ 4);
2415 WRITEMEM(&fhp
->fh_handle
.fh_base
, len
);
2422 * Including all fields other than the name, a LOCK4denied structure requires
2423 * 8(clientid) + 4(namelen) + 8(offset) + 8(length) + 4(type) = 32 bytes.
2426 nfsd4_encode_lock_denied(struct nfsd4_compoundres
*resp
, struct nfsd4_lock_denied
*ld
)
2430 RESERVE_SPACE(32 + XDR_LEN(ld
->ld_sop
? ld
->ld_sop
->so_owner
.len
: 0));
2431 WRITE64(ld
->ld_start
);
2432 WRITE64(ld
->ld_length
);
2433 WRITE32(ld
->ld_type
);
2435 WRITEMEM(&ld
->ld_clientid
, 8);
2436 WRITE32(ld
->ld_sop
->so_owner
.len
);
2437 WRITEMEM(ld
->ld_sop
->so_owner
.data
, ld
->ld_sop
->so_owner
.len
);
2438 kref_put(&ld
->ld_sop
->so_ref
, nfs4_free_stateowner
);
2439 } else { /* non - nfsv4 lock in conflict, no clientid nor owner */
2440 WRITE64((u64
)0); /* clientid */
2441 WRITE32(0); /* length of owner name */
2447 nfsd4_encode_lock(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_lock
*lock
)
2449 ENCODE_SEQID_OP_HEAD
;
2452 nfsd4_encode_stateid(resp
, &lock
->lk_resp_stateid
);
2453 else if (nfserr
== nfserr_denied
)
2454 nfsd4_encode_lock_denied(resp
, &lock
->lk_denied
);
2456 ENCODE_SEQID_OP_TAIL(lock
->lk_replay_owner
);
2461 nfsd4_encode_lockt(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_lockt
*lockt
)
2463 if (nfserr
== nfserr_denied
)
2464 nfsd4_encode_lock_denied(resp
, &lockt
->lt_denied
);
2469 nfsd4_encode_locku(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_locku
*locku
)
2471 ENCODE_SEQID_OP_HEAD
;
2474 nfsd4_encode_stateid(resp
, &locku
->lu_stateid
);
2476 ENCODE_SEQID_OP_TAIL(locku
->lu_stateowner
);
2482 nfsd4_encode_link(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_link
*link
)
2488 write_cinfo(&p
, &link
->li_cinfo
);
2496 nfsd4_encode_open(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open
*open
)
2499 ENCODE_SEQID_OP_HEAD
;
2504 nfsd4_encode_stateid(resp
, &open
->op_stateid
);
2506 write_cinfo(&p
, &open
->op_cinfo
);
2507 WRITE32(open
->op_rflags
);
2509 WRITE32(open
->op_bmval
[0]);
2510 WRITE32(open
->op_bmval
[1]);
2511 WRITE32(open
->op_delegate_type
);
2514 switch (open
->op_delegate_type
) {
2515 case NFS4_OPEN_DELEGATE_NONE
:
2517 case NFS4_OPEN_DELEGATE_READ
:
2518 nfsd4_encode_stateid(resp
, &open
->op_delegate_stateid
);
2520 WRITE32(open
->op_recall
);
2523 * TODO: ACE's in delegations
2525 WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE
);
2528 WRITE32(0); /* XXX: is NULL principal ok? */
2531 case NFS4_OPEN_DELEGATE_WRITE
:
2532 nfsd4_encode_stateid(resp
, &open
->op_delegate_stateid
);
2537 * TODO: space_limit's in delegations
2539 WRITE32(NFS4_LIMIT_SIZE
);
2544 * TODO: ACE's in delegations
2546 WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE
);
2549 WRITE32(0); /* XXX: is NULL principal ok? */
2555 /* XXX save filehandle here */
2557 ENCODE_SEQID_OP_TAIL(open
->op_stateowner
);
2562 nfsd4_encode_open_confirm(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open_confirm
*oc
)
2564 ENCODE_SEQID_OP_HEAD
;
2567 nfsd4_encode_stateid(resp
, &oc
->oc_resp_stateid
);
2569 ENCODE_SEQID_OP_TAIL(oc
->oc_stateowner
);
2574 nfsd4_encode_open_downgrade(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open_downgrade
*od
)
2576 ENCODE_SEQID_OP_HEAD
;
2579 nfsd4_encode_stateid(resp
, &od
->od_stateid
);
2581 ENCODE_SEQID_OP_TAIL(od
->od_stateowner
);
2586 nfsd4_encode_read(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
2587 struct nfsd4_read
*read
)
2591 unsigned long maxcount
;
2597 if (resp
->xbuf
->page_len
)
2598 return nfserr_resource
;
2600 RESERVE_SPACE(8); /* eof flag and byte count */
2602 maxcount
= svc_max_payload(resp
->rqstp
);
2603 if (maxcount
> read
->rd_length
)
2604 maxcount
= read
->rd_length
;
2609 pn
= resp
->rqstp
->rq_resused
++;
2610 resp
->rqstp
->rq_vec
[v
].iov_base
=
2611 page_address(resp
->rqstp
->rq_respages
[pn
]);
2612 resp
->rqstp
->rq_vec
[v
].iov_len
=
2613 len
< PAGE_SIZE
? len
: PAGE_SIZE
;
2619 nfserr
= nfsd_read(read
->rd_rqstp
, read
->rd_fhp
, read
->rd_filp
,
2620 read
->rd_offset
, resp
->rqstp
->rq_vec
, read
->rd_vlen
,
2623 if (nfserr
== nfserr_symlink
)
2624 nfserr
= nfserr_inval
;
2627 eof
= (read
->rd_offset
+ maxcount
>=
2628 read
->rd_fhp
->fh_dentry
->d_inode
->i_size
);
2633 resp
->xbuf
->head
[0].iov_len
= (char*)p
2634 - (char*)resp
->xbuf
->head
[0].iov_base
;
2635 resp
->xbuf
->page_len
= maxcount
;
2637 /* Use rest of head for padding and remaining ops: */
2638 resp
->xbuf
->tail
[0].iov_base
= p
;
2639 resp
->xbuf
->tail
[0].iov_len
= 0;
2643 resp
->xbuf
->tail
[0].iov_base
+= maxcount
&3;
2644 resp
->xbuf
->tail
[0].iov_len
= 4 - (maxcount
&3);
2651 nfsd4_encode_readlink(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_readlink
*readlink
)
2659 if (resp
->xbuf
->page_len
)
2660 return nfserr_resource
;
2662 page
= page_address(resp
->rqstp
->rq_respages
[resp
->rqstp
->rq_resused
++]);
2664 maxcount
= PAGE_SIZE
;
2668 * XXX: By default, the ->readlink() VFS op will truncate symlinks
2669 * if they would overflow the buffer. Is this kosher in NFSv4? If
2670 * not, one easy fix is: if ->readlink() precisely fills the buffer,
2671 * assume that truncation occurred, and return NFS4ERR_RESOURCE.
2673 nfserr
= nfsd_readlink(readlink
->rl_rqstp
, readlink
->rl_fhp
, page
, &maxcount
);
2674 if (nfserr
== nfserr_isdir
)
2675 return nfserr_inval
;
2681 resp
->xbuf
->head
[0].iov_len
= (char*)p
2682 - (char*)resp
->xbuf
->head
[0].iov_base
;
2683 resp
->xbuf
->page_len
= maxcount
;
2685 /* Use rest of head for padding and remaining ops: */
2686 resp
->xbuf
->tail
[0].iov_base
= p
;
2687 resp
->xbuf
->tail
[0].iov_len
= 0;
2691 resp
->xbuf
->tail
[0].iov_base
+= maxcount
&3;
2692 resp
->xbuf
->tail
[0].iov_len
= 4 - (maxcount
&3);
2699 nfsd4_encode_readdir(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_readdir
*readdir
)
2703 __be32
*page
, *savep
, *tailbase
;
2708 if (resp
->xbuf
->page_len
)
2709 return nfserr_resource
;
2711 RESERVE_SPACE(8); /* verifier */
2714 /* XXX: Following NFSv3, we ignore the READDIR verifier for now. */
2718 resp
->xbuf
->head
[0].iov_len
= ((char*)resp
->p
) - (char*)resp
->xbuf
->head
[0].iov_base
;
2721 maxcount
= PAGE_SIZE
;
2722 if (maxcount
> readdir
->rd_maxcount
)
2723 maxcount
= readdir
->rd_maxcount
;
2726 * Convert from bytes to words, account for the two words already
2727 * written, make sure to leave two words at the end for the next
2728 * pointer and eof field.
2730 maxcount
= (maxcount
>> 2) - 4;
2732 nfserr
= nfserr_toosmall
;
2736 page
= page_address(resp
->rqstp
->rq_respages
[resp
->rqstp
->rq_resused
++]);
2737 readdir
->common
.err
= 0;
2738 readdir
->buflen
= maxcount
;
2739 readdir
->buffer
= page
;
2740 readdir
->offset
= NULL
;
2742 offset
= readdir
->rd_cookie
;
2743 nfserr
= nfsd_readdir(readdir
->rd_rqstp
, readdir
->rd_fhp
,
2745 &readdir
->common
, nfsd4_encode_dirent
);
2746 if (nfserr
== nfs_ok
&&
2747 readdir
->common
.err
== nfserr_toosmall
&&
2748 readdir
->buffer
== page
)
2749 nfserr
= nfserr_toosmall
;
2750 if (nfserr
== nfserr_symlink
)
2751 nfserr
= nfserr_notdir
;
2755 if (readdir
->offset
)
2756 xdr_encode_hyper(readdir
->offset
, offset
);
2758 p
= readdir
->buffer
;
2759 *p
++ = 0; /* no more entries */
2760 *p
++ = htonl(readdir
->common
.err
== nfserr_eof
);
2761 resp
->xbuf
->page_len
= ((char*)p
) - (char*)page_address(
2762 resp
->rqstp
->rq_respages
[resp
->rqstp
->rq_resused
-1]);
2764 /* Use rest of head for padding and remaining ops: */
2765 resp
->xbuf
->tail
[0].iov_base
= tailbase
;
2766 resp
->xbuf
->tail
[0].iov_len
= 0;
2767 resp
->p
= resp
->xbuf
->tail
[0].iov_base
;
2768 resp
->end
= resp
->p
+ (PAGE_SIZE
- resp
->xbuf
->head
[0].iov_len
)/4;
2778 nfsd4_encode_remove(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_remove
*remove
)
2784 write_cinfo(&p
, &remove
->rm_cinfo
);
2791 nfsd4_encode_rename(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_rename
*rename
)
2797 write_cinfo(&p
, &rename
->rn_sinfo
);
2798 write_cinfo(&p
, &rename
->rn_tinfo
);
2805 nfsd4_encode_secinfo(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
2806 struct nfsd4_secinfo
*secinfo
)
2809 struct svc_export
*exp
= secinfo
->si_exp
;
2811 struct exp_flavor_info
*flavs
;
2812 struct exp_flavor_info def_flavs
[2];
2817 if (exp
->ex_nflavors
) {
2818 flavs
= exp
->ex_flavors
;
2819 nflavs
= exp
->ex_nflavors
;
2820 } else { /* Handling of some defaults in absence of real secinfo: */
2822 if (exp
->ex_client
->flavour
->flavour
== RPC_AUTH_UNIX
) {
2824 flavs
[0].pseudoflavor
= RPC_AUTH_UNIX
;
2825 flavs
[1].pseudoflavor
= RPC_AUTH_NULL
;
2826 } else if (exp
->ex_client
->flavour
->flavour
== RPC_AUTH_GSS
) {
2828 flavs
[0].pseudoflavor
2829 = svcauth_gss_flavor(exp
->ex_client
);
2832 flavs
[0].pseudoflavor
2833 = exp
->ex_client
->flavour
->flavour
;
2840 for (i
= 0; i
< nflavs
; i
++) {
2841 u32 flav
= flavs
[i
].pseudoflavor
;
2842 struct gss_api_mech
*gm
= gss_mech_get_by_pseudoflavor(flav
);
2846 WRITE32(RPC_AUTH_GSS
);
2848 RESERVE_SPACE(4 + gm
->gm_oid
.len
);
2849 WRITE32(gm
->gm_oid
.len
);
2850 WRITEMEM(gm
->gm_oid
.data
, gm
->gm_oid
.len
);
2853 WRITE32(0); /* qop */
2856 WRITE32(gss_pseudoflavor_to_service(gm
, flav
));
2872 * The SETATTR encode routine is special -- it always encodes a bitmap,
2873 * regardless of the error status.
2876 nfsd4_encode_setattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_setattr
*setattr
)
2888 WRITE32(setattr
->sa_bmval
[0]);
2889 WRITE32(setattr
->sa_bmval
[1]);
2896 nfsd4_encode_setclientid(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_setclientid
*scd
)
2901 RESERVE_SPACE(8 + sizeof(nfs4_verifier
));
2902 WRITEMEM(&scd
->se_clientid
, 8);
2903 WRITEMEM(&scd
->se_confirm
, sizeof(nfs4_verifier
));
2906 else if (nfserr
== nfserr_clid_inuse
) {
2916 nfsd4_encode_write(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_write
*write
)
2922 WRITE32(write
->wr_bytes_written
);
2923 WRITE32(write
->wr_how_written
);
2924 WRITEMEM(write
->wr_verifier
.data
, 8);
2931 nfsd4_encode_exchange_id(struct nfsd4_compoundres
*resp
, int nfserr
,
2932 struct nfsd4_exchange_id
*exid
)
2938 int server_scope_sz
;
2939 uint64_t minor_id
= 0;
2944 major_id
= utsname()->nodename
;
2945 major_id_sz
= strlen(major_id
);
2946 server_scope
= utsname()->nodename
;
2947 server_scope_sz
= strlen(server_scope
);
2950 8 /* eir_clientid */ +
2951 4 /* eir_sequenceid */ +
2953 4 /* spr_how (SP4_NONE) */ +
2954 8 /* so_minor_id */ +
2955 4 /* so_major_id.len */ +
2956 (XDR_QUADLEN(major_id_sz
) * 4) +
2957 4 /* eir_server_scope.len */ +
2958 (XDR_QUADLEN(server_scope_sz
) * 4) +
2959 4 /* eir_server_impl_id.count (0) */);
2961 WRITEMEM(&exid
->clientid
, 8);
2962 WRITE32(exid
->seqid
);
2963 WRITE32(exid
->flags
);
2965 /* state_protect4_r. Currently only support SP4_NONE */
2966 BUG_ON(exid
->spa_how
!= SP4_NONE
);
2967 WRITE32(exid
->spa_how
);
2969 /* The server_owner struct */
2970 WRITE64(minor_id
); /* Minor id */
2972 WRITE32(major_id_sz
);
2973 WRITEMEM(major_id
, major_id_sz
);
2976 WRITE32(server_scope_sz
);
2977 WRITEMEM(server_scope
, server_scope_sz
);
2979 /* Implementation id */
2980 WRITE32(0); /* zero length nfs_impl_id4 array */
2986 nfsd4_encode_create_session(struct nfsd4_compoundres
*resp
, int nfserr
,
2987 struct nfsd4_create_session
*sess
)
2995 WRITEMEM(sess
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
2996 WRITE32(sess
->seqid
);
2997 WRITE32(sess
->flags
);
3001 WRITE32(0); /* headerpadsz */
3002 WRITE32(sess
->fore_channel
.maxreq_sz
);
3003 WRITE32(sess
->fore_channel
.maxresp_sz
);
3004 WRITE32(sess
->fore_channel
.maxresp_cached
);
3005 WRITE32(sess
->fore_channel
.maxops
);
3006 WRITE32(sess
->fore_channel
.maxreqs
);
3007 WRITE32(sess
->fore_channel
.nr_rdma_attrs
);
3010 if (sess
->fore_channel
.nr_rdma_attrs
) {
3012 WRITE32(sess
->fore_channel
.rdma_attrs
);
3017 WRITE32(0); /* headerpadsz */
3018 WRITE32(sess
->back_channel
.maxreq_sz
);
3019 WRITE32(sess
->back_channel
.maxresp_sz
);
3020 WRITE32(sess
->back_channel
.maxresp_cached
);
3021 WRITE32(sess
->back_channel
.maxops
);
3022 WRITE32(sess
->back_channel
.maxreqs
);
3023 WRITE32(sess
->back_channel
.nr_rdma_attrs
);
3026 if (sess
->back_channel
.nr_rdma_attrs
) {
3028 WRITE32(sess
->back_channel
.rdma_attrs
);
3035 nfsd4_encode_destroy_session(struct nfsd4_compoundres
*resp
, int nfserr
,
3036 struct nfsd4_destroy_session
*destroy_session
)
3042 nfsd4_encode_sequence(struct nfsd4_compoundres
*resp
, int nfserr
,
3043 struct nfsd4_sequence
*seq
)
3050 RESERVE_SPACE(NFS4_MAX_SESSIONID_LEN
+ 20);
3051 WRITEMEM(seq
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
3052 WRITE32(seq
->seqid
);
3053 WRITE32(seq
->slotid
);
3054 WRITE32(seq
->maxslots
);
3057 * target_maxslots = maxslots
3060 WRITE32(seq
->maxslots
);
3064 resp
->cstate
.datap
= p
; /* DRC cache data pointer */
3069 nfsd4_encode_noop(struct nfsd4_compoundres
*resp
, __be32 nfserr
, void *p
)
3074 typedef __be32(* nfsd4_enc
)(struct nfsd4_compoundres
*, __be32
, void *);
3077 * Note: nfsd4_enc_ops vector is shared for v4.0 and v4.1
3078 * since we don't need to filter out obsolete ops as this is
3079 * done in the decoding phase.
3081 static nfsd4_enc nfsd4_enc_ops
[] = {
3082 [OP_ACCESS
] = (nfsd4_enc
)nfsd4_encode_access
,
3083 [OP_CLOSE
] = (nfsd4_enc
)nfsd4_encode_close
,
3084 [OP_COMMIT
] = (nfsd4_enc
)nfsd4_encode_commit
,
3085 [OP_CREATE
] = (nfsd4_enc
)nfsd4_encode_create
,
3086 [OP_DELEGPURGE
] = (nfsd4_enc
)nfsd4_encode_noop
,
3087 [OP_DELEGRETURN
] = (nfsd4_enc
)nfsd4_encode_noop
,
3088 [OP_GETATTR
] = (nfsd4_enc
)nfsd4_encode_getattr
,
3089 [OP_GETFH
] = (nfsd4_enc
)nfsd4_encode_getfh
,
3090 [OP_LINK
] = (nfsd4_enc
)nfsd4_encode_link
,
3091 [OP_LOCK
] = (nfsd4_enc
)nfsd4_encode_lock
,
3092 [OP_LOCKT
] = (nfsd4_enc
)nfsd4_encode_lockt
,
3093 [OP_LOCKU
] = (nfsd4_enc
)nfsd4_encode_locku
,
3094 [OP_LOOKUP
] = (nfsd4_enc
)nfsd4_encode_noop
,
3095 [OP_LOOKUPP
] = (nfsd4_enc
)nfsd4_encode_noop
,
3096 [OP_NVERIFY
] = (nfsd4_enc
)nfsd4_encode_noop
,
3097 [OP_OPEN
] = (nfsd4_enc
)nfsd4_encode_open
,
3098 [OP_OPENATTR
] = (nfsd4_enc
)nfsd4_encode_noop
,
3099 [OP_OPEN_CONFIRM
] = (nfsd4_enc
)nfsd4_encode_open_confirm
,
3100 [OP_OPEN_DOWNGRADE
] = (nfsd4_enc
)nfsd4_encode_open_downgrade
,
3101 [OP_PUTFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3102 [OP_PUTPUBFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3103 [OP_PUTROOTFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3104 [OP_READ
] = (nfsd4_enc
)nfsd4_encode_read
,
3105 [OP_READDIR
] = (nfsd4_enc
)nfsd4_encode_readdir
,
3106 [OP_READLINK
] = (nfsd4_enc
)nfsd4_encode_readlink
,
3107 [OP_REMOVE
] = (nfsd4_enc
)nfsd4_encode_remove
,
3108 [OP_RENAME
] = (nfsd4_enc
)nfsd4_encode_rename
,
3109 [OP_RENEW
] = (nfsd4_enc
)nfsd4_encode_noop
,
3110 [OP_RESTOREFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3111 [OP_SAVEFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3112 [OP_SECINFO
] = (nfsd4_enc
)nfsd4_encode_secinfo
,
3113 [OP_SETATTR
] = (nfsd4_enc
)nfsd4_encode_setattr
,
3114 [OP_SETCLIENTID
] = (nfsd4_enc
)nfsd4_encode_setclientid
,
3115 [OP_SETCLIENTID_CONFIRM
] = (nfsd4_enc
)nfsd4_encode_noop
,
3116 [OP_VERIFY
] = (nfsd4_enc
)nfsd4_encode_noop
,
3117 [OP_WRITE
] = (nfsd4_enc
)nfsd4_encode_write
,
3118 [OP_RELEASE_LOCKOWNER
] = (nfsd4_enc
)nfsd4_encode_noop
,
3120 /* NFSv4.1 operations */
3121 [OP_BACKCHANNEL_CTL
] = (nfsd4_enc
)nfsd4_encode_noop
,
3122 [OP_BIND_CONN_TO_SESSION
] = (nfsd4_enc
)nfsd4_encode_noop
,
3123 [OP_EXCHANGE_ID
] = (nfsd4_enc
)nfsd4_encode_exchange_id
,
3124 [OP_CREATE_SESSION
] = (nfsd4_enc
)nfsd4_encode_create_session
,
3125 [OP_DESTROY_SESSION
] = (nfsd4_enc
)nfsd4_encode_destroy_session
,
3126 [OP_FREE_STATEID
] = (nfsd4_enc
)nfsd4_encode_noop
,
3127 [OP_GET_DIR_DELEGATION
] = (nfsd4_enc
)nfsd4_encode_noop
,
3128 [OP_GETDEVICEINFO
] = (nfsd4_enc
)nfsd4_encode_noop
,
3129 [OP_GETDEVICELIST
] = (nfsd4_enc
)nfsd4_encode_noop
,
3130 [OP_LAYOUTCOMMIT
] = (nfsd4_enc
)nfsd4_encode_noop
,
3131 [OP_LAYOUTGET
] = (nfsd4_enc
)nfsd4_encode_noop
,
3132 [OP_LAYOUTRETURN
] = (nfsd4_enc
)nfsd4_encode_noop
,
3133 [OP_SECINFO_NO_NAME
] = (nfsd4_enc
)nfsd4_encode_noop
,
3134 [OP_SEQUENCE
] = (nfsd4_enc
)nfsd4_encode_sequence
,
3135 [OP_SET_SSV
] = (nfsd4_enc
)nfsd4_encode_noop
,
3136 [OP_TEST_STATEID
] = (nfsd4_enc
)nfsd4_encode_noop
,
3137 [OP_WANT_DELEGATION
] = (nfsd4_enc
)nfsd4_encode_noop
,
3138 [OP_DESTROY_CLIENTID
] = (nfsd4_enc
)nfsd4_encode_noop
,
3139 [OP_RECLAIM_COMPLETE
] = (nfsd4_enc
)nfsd4_encode_noop
,
3143 * Calculate the total amount of memory that the compound response has taken
3144 * after encoding the current operation.
3146 * pad: add on 8 bytes for the next operation's op_code and status so that
3147 * there is room to cache a failure on the next operation.
3149 * Compare this length to the session se_fmaxresp_cached.
3151 * Our se_fmaxresp_cached will always be a multiple of PAGE_SIZE, and so
3152 * will be at least a page and will therefore hold the xdr_buf head.
3154 static int nfsd4_check_drc_limit(struct nfsd4_compoundres
*resp
)
3157 struct xdr_buf
*xb
= &resp
->rqstp
->rq_res
;
3158 struct nfsd4_compoundargs
*args
= resp
->rqstp
->rq_argp
;
3159 struct nfsd4_session
*session
= NULL
;
3160 struct nfsd4_slot
*slot
= resp
->cstate
.slot
;
3161 u32 length
, tlen
= 0, pad
= 8;
3163 if (!nfsd4_has_session(&resp
->cstate
))
3166 session
= resp
->cstate
.session
;
3167 if (session
== NULL
|| slot
->sl_cachethis
== 0)
3170 if (resp
->opcnt
>= args
->opcnt
)
3171 pad
= 0; /* this is the last operation */
3173 if (xb
->page_len
== 0) {
3174 length
= (char *)resp
->p
- (char *)xb
->head
[0].iov_base
+ pad
;
3176 if (xb
->tail
[0].iov_base
&& xb
->tail
[0].iov_len
> 0)
3177 tlen
= (char *)resp
->p
- (char *)xb
->tail
[0].iov_base
;
3179 length
= xb
->head
[0].iov_len
+ xb
->page_len
+ tlen
+ pad
;
3181 dprintk("%s length %u, xb->page_len %u tlen %u pad %u\n", __func__
,
3182 length
, xb
->page_len
, tlen
, pad
);
3184 if (length
<= session
->se_fchannel
.maxresp_cached
)
3187 return nfserr_rep_too_big_to_cache
;
3191 nfsd4_encode_operation(struct nfsd4_compoundres
*resp
, struct nfsd4_op
*op
)
3198 statp
= p
++; /* to be backfilled at the end */
3201 if (op
->opnum
== OP_ILLEGAL
)
3203 BUG_ON(op
->opnum
< 0 || op
->opnum
>= ARRAY_SIZE(nfsd4_enc_ops
) ||
3204 !nfsd4_enc_ops
[op
->opnum
]);
3205 op
->status
= nfsd4_enc_ops
[op
->opnum
](resp
, op
->status
, &op
->u
);
3206 /* nfsd4_check_drc_limit guarantees enough room for error status */
3207 if (!op
->status
&& nfsd4_check_drc_limit(resp
))
3208 op
->status
= nfserr_rep_too_big_to_cache
;
3211 * Note: We write the status directly, instead of using WRITE32(),
3212 * since it is already in network byte order.
3214 *statp
= op
->status
;
3218 * Encode the reply stored in the stateowner reply cache
3220 * XDR note: do not encode rp->rp_buflen: the buffer contains the
3221 * previously sent already encoded operation.
3223 * called with nfs4_lock_state() held
3226 nfsd4_encode_replay(struct nfsd4_compoundres
*resp
, struct nfsd4_op
*op
)
3229 struct nfs4_replay
*rp
= op
->replay
;
3235 *p
++ = rp
->rp_status
; /* already xdr'ed */
3238 RESERVE_SPACE(rp
->rp_buflen
);
3239 WRITEMEM(rp
->rp_buf
, rp
->rp_buflen
);
3244 nfs4svc_encode_voidres(struct svc_rqst
*rqstp
, __be32
*p
, void *dummy
)
3246 return xdr_ressize_check(rqstp
, p
);
3249 void nfsd4_release_compoundargs(struct nfsd4_compoundargs
*args
)
3251 if (args
->ops
!= args
->iops
) {
3253 args
->ops
= args
->iops
;
3257 while (args
->to_free
) {
3258 struct tmpbuf
*tb
= args
->to_free
;
3259 args
->to_free
= tb
->next
;
3260 tb
->release(tb
->buf
);
3266 nfs4svc_decode_compoundargs(struct svc_rqst
*rqstp
, __be32
*p
, struct nfsd4_compoundargs
*args
)
3271 args
->end
= rqstp
->rq_arg
.head
[0].iov_base
+ rqstp
->rq_arg
.head
[0].iov_len
;
3272 args
->pagelist
= rqstp
->rq_arg
.pages
;
3273 args
->pagelen
= rqstp
->rq_arg
.page_len
;
3275 args
->to_free
= NULL
;
3276 args
->ops
= args
->iops
;
3277 args
->rqstp
= rqstp
;
3279 status
= nfsd4_decode_compound(args
);
3281 nfsd4_release_compoundargs(args
);
3287 nfs4svc_encode_compoundres(struct svc_rqst
*rqstp
, __be32
*p
, struct nfsd4_compoundres
*resp
)
3290 * All that remains is to write the tag and operation count...
3292 struct nfsd4_compound_state
*cs
= &resp
->cstate
;
3295 *p
++ = htonl(resp
->taglen
);
3296 memcpy(p
, resp
->tag
, resp
->taglen
);
3297 p
+= XDR_QUADLEN(resp
->taglen
);
3298 *p
++ = htonl(resp
->opcnt
);
3300 if (rqstp
->rq_res
.page_len
)
3301 iov
= &rqstp
->rq_res
.tail
[0];
3303 iov
= &rqstp
->rq_res
.head
[0];
3304 iov
->iov_len
= ((char*)resp
->p
) - (char*)iov
->iov_base
;
3305 BUG_ON(iov
->iov_len
> PAGE_SIZE
);
3306 if (nfsd4_has_session(cs
) && cs
->status
!= nfserr_replay_cache
) {
3307 nfsd4_store_cache_entry(resp
);
3308 dprintk("%s: SET SLOT STATE TO AVAILABLE\n", __func__
);
3309 resp
->cstate
.slot
->sl_inuse
= false;
3310 nfsd4_put_session(resp
->cstate
.session
);