2 * Server-side XDR for NFSv4
4 * Copyright (c) 2002 The Regents of the University of Michigan.
7 * Kendrick Smith <kmsmith@umich.edu>
8 * Andy Adamson <andros@umich.edu>
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. Neither the name of the University nor the names of its
20 * contributors may be used to endorse or promote products derived
21 * from this software without specific prior written permission.
23 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
24 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
25 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
28 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
29 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
30 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
31 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
32 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
33 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 * TODO: Neil Brown made the following observation: We currently
36 * initially reserve NFSD_BUFSIZE space on the transmit queue and
37 * never release any of that until the request is complete.
38 * It would be good to calculate a new maximum response size while
39 * decoding the COMPOUND, and call svc_reserve with this number
40 * at the end of nfs4svc_decode_compoundargs.
43 #include <linux/param.h>
44 #include <linux/smp.h>
46 #include <linux/namei.h>
47 #include <linux/vfs.h>
48 #include <linux/utsname.h>
49 #include <linux/sunrpc/xdr.h>
50 #include <linux/sunrpc/svc.h>
51 #include <linux/sunrpc/clnt.h>
52 #include <linux/nfsd/nfsd.h>
53 #include <linux/nfsd/state.h>
54 #include <linux/nfsd/xdr4.h>
55 #include <linux/nfsd_idmap.h>
56 #include <linux/nfs4.h>
57 #include <linux/nfs4_acl.h>
58 #include <linux/sunrpc/gss_api.h>
59 #include <linux/sunrpc/svcauth_gss.h>
61 #define NFSDDBG_FACILITY NFSDDBG_XDR
64 * As per referral draft, the fsid for a referral MUST be different from the fsid of the containing
65 * directory in order to indicate to the client that a filesystem boundary is present
66 * We use a fixed fsid for a referral
68 #define NFS4_REFERRAL_FSID_MAJOR 0x8000000ULL
69 #define NFS4_REFERRAL_FSID_MINOR 0x8000000ULL
72 check_filename(char *str
, int len
, __be32 err
)
78 if (isdotent(str
, len
))
80 for (i
= 0; i
< len
; i
++)
94 dprintk("NFSD: xdr error (%s:%d)\n", \
95 __FILE__, __LINE__); \
96 status = nfserr_bad_xdr; \
99 #define READ32(x) (x) = ntohl(*p++)
100 #define READ64(x) do { \
101 (x) = (u64)ntohl(*p++) << 32; \
102 (x) |= ntohl(*p++); \
104 #define READTIME(x) do { \
109 #define READMEM(x,nbytes) do { \
111 p += XDR_QUADLEN(nbytes); \
113 #define SAVEMEM(x,nbytes) do { \
114 if (!(x = (p==argp->tmp || p == argp->tmpp) ? \
115 savemem(argp, p, nbytes) : \
117 dprintk("NFSD: xdr error (%s:%d)\n", \
118 __FILE__, __LINE__); \
121 p += XDR_QUADLEN(nbytes); \
123 #define COPYMEM(x,nbytes) do { \
124 memcpy((x), p, nbytes); \
125 p += XDR_QUADLEN(nbytes); \
128 /* READ_BUF, read_buf(): nbytes must be <= PAGE_SIZE */
129 #define READ_BUF(nbytes) do { \
130 if (nbytes <= (u32)((char *)argp->end - (char *)argp->p)) { \
132 argp->p += XDR_QUADLEN(nbytes); \
133 } else if (!(p = read_buf(argp, nbytes))) { \
134 dprintk("NFSD: xdr error (%s:%d)\n", \
135 __FILE__, __LINE__); \
140 static __be32
*read_buf(struct nfsd4_compoundargs
*argp
, u32 nbytes
)
142 /* We want more bytes than seem to be available.
143 * Maybe we need a new page, maybe we have just run out
145 unsigned int avail
= (char *)argp
->end
- (char *)argp
->p
;
147 if (avail
+ argp
->pagelen
< nbytes
)
149 if (avail
+ PAGE_SIZE
< nbytes
) /* need more than a page !! */
151 /* ok, we can do it with the current plus the next page */
152 if (nbytes
<= sizeof(argp
->tmp
))
156 p
= argp
->tmpp
= kmalloc(nbytes
, GFP_KERNEL
);
162 * The following memcpy is safe because read_buf is always
163 * called with nbytes > avail, and the two cases above both
164 * guarantee p points to at least nbytes bytes.
166 memcpy(p
, argp
->p
, avail
);
167 /* step to next page */
168 argp
->p
= page_address(argp
->pagelist
[0]);
170 if (argp
->pagelen
< PAGE_SIZE
) {
171 argp
->end
= argp
->p
+ (argp
->pagelen
>>2);
174 argp
->end
= argp
->p
+ (PAGE_SIZE
>>2);
175 argp
->pagelen
-= PAGE_SIZE
;
177 memcpy(((char*)p
)+avail
, argp
->p
, (nbytes
- avail
));
178 argp
->p
+= XDR_QUADLEN(nbytes
- avail
);
182 static int zero_clientid(clientid_t
*clid
)
184 return (clid
->cl_boot
== 0) && (clid
->cl_id
== 0);
188 defer_free(struct nfsd4_compoundargs
*argp
,
189 void (*release
)(const void *), void *p
)
193 tb
= kmalloc(sizeof(*tb
), GFP_KERNEL
);
197 tb
->release
= release
;
198 tb
->next
= argp
->to_free
;
203 static char *savemem(struct nfsd4_compoundargs
*argp
, __be32
*p
, int nbytes
)
205 if (p
== argp
->tmp
) {
206 p
= kmalloc(nbytes
, GFP_KERNEL
);
209 memcpy(p
, argp
->tmp
, nbytes
);
211 BUG_ON(p
!= argp
->tmpp
);
214 if (defer_free(argp
, kfree
, p
)) {
222 nfsd4_decode_bitmap(struct nfsd4_compoundargs
*argp
, u32
*bmval
)
236 READ_BUF(bmlen
<< 2);
248 nfsd4_decode_fattr(struct nfsd4_compoundargs
*argp
, u32
*bmval
,
249 struct iattr
*iattr
, struct nfs4_acl
**acl
)
251 int expected_len
, len
= 0;
258 if ((status
= nfsd4_decode_bitmap(argp
, bmval
)))
262 READ32(expected_len
);
264 if (bmval
[0] & FATTR4_WORD0_SIZE
) {
267 READ64(iattr
->ia_size
);
268 iattr
->ia_valid
|= ATTR_SIZE
;
270 if (bmval
[0] & FATTR4_WORD0_ACL
) {
272 struct nfs4_ace
*ace
;
274 READ_BUF(4); len
+= 4;
277 if (nace
> NFS4_ACL_MAX
)
278 return nfserr_resource
;
280 *acl
= nfs4_acl_new(nace
);
285 defer_free(argp
, kfree
, *acl
);
287 (*acl
)->naces
= nace
;
288 for (ace
= (*acl
)->aces
; ace
< (*acl
)->aces
+ nace
; ace
++) {
289 READ_BUF(16); len
+= 16;
292 READ32(ace
->access_mask
);
295 len
+= XDR_QUADLEN(dummy32
) << 2;
296 READMEM(buf
, dummy32
);
297 ace
->whotype
= nfs4_acl_get_whotype(buf
, dummy32
);
299 if (ace
->whotype
!= NFS4_ACL_WHO_NAMED
)
301 else if (ace
->flag
& NFS4_ACE_IDENTIFIER_GROUP
)
302 host_err
= nfsd_map_name_to_gid(argp
->rqstp
,
303 buf
, dummy32
, &ace
->who
);
305 host_err
= nfsd_map_name_to_uid(argp
->rqstp
,
306 buf
, dummy32
, &ace
->who
);
312 if (bmval
[1] & FATTR4_WORD1_MODE
) {
315 READ32(iattr
->ia_mode
);
316 iattr
->ia_mode
&= (S_IFMT
| S_IALLUGO
);
317 iattr
->ia_valid
|= ATTR_MODE
;
319 if (bmval
[1] & FATTR4_WORD1_OWNER
) {
324 len
+= (XDR_QUADLEN(dummy32
) << 2);
325 READMEM(buf
, dummy32
);
326 if ((status
= nfsd_map_name_to_uid(argp
->rqstp
, buf
, dummy32
, &iattr
->ia_uid
)))
328 iattr
->ia_valid
|= ATTR_UID
;
330 if (bmval
[1] & FATTR4_WORD1_OWNER_GROUP
) {
335 len
+= (XDR_QUADLEN(dummy32
) << 2);
336 READMEM(buf
, dummy32
);
337 if ((status
= nfsd_map_name_to_gid(argp
->rqstp
, buf
, dummy32
, &iattr
->ia_gid
)))
339 iattr
->ia_valid
|= ATTR_GID
;
341 if (bmval
[1] & FATTR4_WORD1_TIME_ACCESS_SET
) {
346 case NFS4_SET_TO_CLIENT_TIME
:
347 /* We require the high 32 bits of 'seconds' to be 0, and we ignore
348 all 32 bits of 'nseconds'. */
354 READ32(iattr
->ia_atime
.tv_sec
);
355 READ32(iattr
->ia_atime
.tv_nsec
);
356 if (iattr
->ia_atime
.tv_nsec
>= (u32
)1000000000)
358 iattr
->ia_valid
|= (ATTR_ATIME
| ATTR_ATIME_SET
);
360 case NFS4_SET_TO_SERVER_TIME
:
361 iattr
->ia_valid
|= ATTR_ATIME
;
367 if (bmval
[1] & FATTR4_WORD1_TIME_MODIFY_SET
) {
372 case NFS4_SET_TO_CLIENT_TIME
:
373 /* We require the high 32 bits of 'seconds' to be 0, and we ignore
374 all 32 bits of 'nseconds'. */
380 READ32(iattr
->ia_mtime
.tv_sec
);
381 READ32(iattr
->ia_mtime
.tv_nsec
);
382 if (iattr
->ia_mtime
.tv_nsec
>= (u32
)1000000000)
384 iattr
->ia_valid
|= (ATTR_MTIME
| ATTR_MTIME_SET
);
386 case NFS4_SET_TO_SERVER_TIME
:
387 iattr
->ia_valid
|= ATTR_MTIME
;
393 if (bmval
[0] & ~NFSD_WRITEABLE_ATTRS_WORD0
394 || bmval
[1] & ~NFSD_WRITEABLE_ATTRS_WORD1
395 || bmval
[2] & ~NFSD_WRITEABLE_ATTRS_WORD2
)
396 READ_BUF(expected_len
- len
);
397 else if (len
!= expected_len
)
403 status
= nfserrno(host_err
);
408 nfsd4_decode_stateid(struct nfsd4_compoundargs
*argp
, stateid_t
*sid
)
412 READ_BUF(sizeof(stateid_t
));
413 READ32(sid
->si_generation
);
414 COPYMEM(&sid
->si_opaque
, sizeof(stateid_opaque_t
));
420 nfsd4_decode_access(struct nfsd4_compoundargs
*argp
, struct nfsd4_access
*access
)
425 READ32(access
->ac_req_access
);
431 nfsd4_decode_close(struct nfsd4_compoundargs
*argp
, struct nfsd4_close
*close
)
435 close
->cl_stateowner
= NULL
;
437 READ32(close
->cl_seqid
);
438 return nfsd4_decode_stateid(argp
, &close
->cl_stateid
);
445 nfsd4_decode_commit(struct nfsd4_compoundargs
*argp
, struct nfsd4_commit
*commit
)
450 READ64(commit
->co_offset
);
451 READ32(commit
->co_count
);
457 nfsd4_decode_create(struct nfsd4_compoundargs
*argp
, struct nfsd4_create
*create
)
462 READ32(create
->cr_type
);
463 switch (create
->cr_type
) {
466 READ32(create
->cr_linklen
);
467 READ_BUF(create
->cr_linklen
);
468 SAVEMEM(create
->cr_linkname
, create
->cr_linklen
);
473 READ32(create
->cr_specdata1
);
474 READ32(create
->cr_specdata2
);
484 READ32(create
->cr_namelen
);
485 READ_BUF(create
->cr_namelen
);
486 SAVEMEM(create
->cr_name
, create
->cr_namelen
);
487 if ((status
= check_filename(create
->cr_name
, create
->cr_namelen
, nfserr_inval
)))
490 status
= nfsd4_decode_fattr(argp
, create
->cr_bmval
, &create
->cr_iattr
,
499 nfsd4_decode_delegreturn(struct nfsd4_compoundargs
*argp
, struct nfsd4_delegreturn
*dr
)
501 return nfsd4_decode_stateid(argp
, &dr
->dr_stateid
);
505 nfsd4_decode_getattr(struct nfsd4_compoundargs
*argp
, struct nfsd4_getattr
*getattr
)
507 return nfsd4_decode_bitmap(argp
, getattr
->ga_bmval
);
511 nfsd4_decode_link(struct nfsd4_compoundargs
*argp
, struct nfsd4_link
*link
)
516 READ32(link
->li_namelen
);
517 READ_BUF(link
->li_namelen
);
518 SAVEMEM(link
->li_name
, link
->li_namelen
);
519 if ((status
= check_filename(link
->li_name
, link
->li_namelen
, nfserr_inval
)))
526 nfsd4_decode_lock(struct nfsd4_compoundargs
*argp
, struct nfsd4_lock
*lock
)
530 lock
->lk_replay_owner
= NULL
;
532 * type, reclaim(boolean), offset, length, new_lock_owner(boolean)
535 READ32(lock
->lk_type
);
536 if ((lock
->lk_type
< NFS4_READ_LT
) || (lock
->lk_type
> NFS4_WRITEW_LT
))
538 READ32(lock
->lk_reclaim
);
539 READ64(lock
->lk_offset
);
540 READ64(lock
->lk_length
);
541 READ32(lock
->lk_is_new
);
543 if (lock
->lk_is_new
) {
545 READ32(lock
->lk_new_open_seqid
);
546 status
= nfsd4_decode_stateid(argp
, &lock
->lk_new_open_stateid
);
549 READ_BUF(8 + sizeof(clientid_t
));
550 READ32(lock
->lk_new_lock_seqid
);
551 COPYMEM(&lock
->lk_new_clientid
, sizeof(clientid_t
));
552 READ32(lock
->lk_new_owner
.len
);
553 READ_BUF(lock
->lk_new_owner
.len
);
554 READMEM(lock
->lk_new_owner
.data
, lock
->lk_new_owner
.len
);
556 status
= nfsd4_decode_stateid(argp
, &lock
->lk_old_lock_stateid
);
560 READ32(lock
->lk_old_lock_seqid
);
567 nfsd4_decode_lockt(struct nfsd4_compoundargs
*argp
, struct nfsd4_lockt
*lockt
)
572 READ32(lockt
->lt_type
);
573 if((lockt
->lt_type
< NFS4_READ_LT
) || (lockt
->lt_type
> NFS4_WRITEW_LT
))
575 READ64(lockt
->lt_offset
);
576 READ64(lockt
->lt_length
);
577 COPYMEM(&lockt
->lt_clientid
, 8);
578 READ32(lockt
->lt_owner
.len
);
579 READ_BUF(lockt
->lt_owner
.len
);
580 READMEM(lockt
->lt_owner
.data
, lockt
->lt_owner
.len
);
582 if (argp
->minorversion
&& !zero_clientid(&lockt
->lt_clientid
))
588 nfsd4_decode_locku(struct nfsd4_compoundargs
*argp
, struct nfsd4_locku
*locku
)
592 locku
->lu_stateowner
= NULL
;
594 READ32(locku
->lu_type
);
595 if ((locku
->lu_type
< NFS4_READ_LT
) || (locku
->lu_type
> NFS4_WRITEW_LT
))
597 READ32(locku
->lu_seqid
);
598 status
= nfsd4_decode_stateid(argp
, &locku
->lu_stateid
);
602 READ64(locku
->lu_offset
);
603 READ64(locku
->lu_length
);
609 nfsd4_decode_lookup(struct nfsd4_compoundargs
*argp
, struct nfsd4_lookup
*lookup
)
614 READ32(lookup
->lo_len
);
615 READ_BUF(lookup
->lo_len
);
616 SAVEMEM(lookup
->lo_name
, lookup
->lo_len
);
617 if ((status
= check_filename(lookup
->lo_name
, lookup
->lo_len
, nfserr_noent
)))
624 nfsd4_decode_open(struct nfsd4_compoundargs
*argp
, struct nfsd4_open
*open
)
628 memset(open
->op_bmval
, 0, sizeof(open
->op_bmval
));
629 open
->op_iattr
.ia_valid
= 0;
630 open
->op_stateowner
= NULL
;
632 /* seqid, share_access, share_deny, clientid, ownerlen */
633 READ_BUF(16 + sizeof(clientid_t
));
634 READ32(open
->op_seqid
);
635 READ32(open
->op_share_access
);
636 READ32(open
->op_share_deny
);
637 COPYMEM(&open
->op_clientid
, sizeof(clientid_t
));
638 READ32(open
->op_owner
.len
);
640 /* owner, open_flag */
641 READ_BUF(open
->op_owner
.len
+ 4);
642 SAVEMEM(open
->op_owner
.data
, open
->op_owner
.len
);
643 READ32(open
->op_create
);
644 switch (open
->op_create
) {
645 case NFS4_OPEN_NOCREATE
:
647 case NFS4_OPEN_CREATE
:
649 READ32(open
->op_createmode
);
650 switch (open
->op_createmode
) {
651 case NFS4_CREATE_UNCHECKED
:
652 case NFS4_CREATE_GUARDED
:
653 status
= nfsd4_decode_fattr(argp
, open
->op_bmval
,
654 &open
->op_iattr
, &open
->op_acl
);
658 case NFS4_CREATE_EXCLUSIVE
:
660 COPYMEM(open
->op_verf
.data
, 8);
662 case NFS4_CREATE_EXCLUSIVE4_1
:
663 if (argp
->minorversion
< 1)
666 COPYMEM(open
->op_verf
.data
, 8);
667 status
= nfsd4_decode_fattr(argp
, open
->op_bmval
,
668 &open
->op_iattr
, &open
->op_acl
);
682 READ32(open
->op_claim_type
);
683 switch (open
->op_claim_type
) {
684 case NFS4_OPEN_CLAIM_NULL
:
685 case NFS4_OPEN_CLAIM_DELEGATE_PREV
:
687 READ32(open
->op_fname
.len
);
688 READ_BUF(open
->op_fname
.len
);
689 SAVEMEM(open
->op_fname
.data
, open
->op_fname
.len
);
690 if ((status
= check_filename(open
->op_fname
.data
, open
->op_fname
.len
, nfserr_inval
)))
693 case NFS4_OPEN_CLAIM_PREVIOUS
:
695 READ32(open
->op_delegate_type
);
697 case NFS4_OPEN_CLAIM_DELEGATE_CUR
:
698 status
= nfsd4_decode_stateid(argp
, &open
->op_delegate_stateid
);
702 READ32(open
->op_fname
.len
);
703 READ_BUF(open
->op_fname
.len
);
704 SAVEMEM(open
->op_fname
.data
, open
->op_fname
.len
);
705 if ((status
= check_filename(open
->op_fname
.data
, open
->op_fname
.len
, nfserr_inval
)))
716 nfsd4_decode_open_confirm(struct nfsd4_compoundargs
*argp
, struct nfsd4_open_confirm
*open_conf
)
720 open_conf
->oc_stateowner
= NULL
;
721 status
= nfsd4_decode_stateid(argp
, &open_conf
->oc_req_stateid
);
725 READ32(open_conf
->oc_seqid
);
731 nfsd4_decode_open_downgrade(struct nfsd4_compoundargs
*argp
, struct nfsd4_open_downgrade
*open_down
)
735 open_down
->od_stateowner
= NULL
;
736 status
= nfsd4_decode_stateid(argp
, &open_down
->od_stateid
);
740 READ32(open_down
->od_seqid
);
741 READ32(open_down
->od_share_access
);
742 READ32(open_down
->od_share_deny
);
748 nfsd4_decode_putfh(struct nfsd4_compoundargs
*argp
, struct nfsd4_putfh
*putfh
)
753 READ32(putfh
->pf_fhlen
);
754 if (putfh
->pf_fhlen
> NFS4_FHSIZE
)
756 READ_BUF(putfh
->pf_fhlen
);
757 SAVEMEM(putfh
->pf_fhval
, putfh
->pf_fhlen
);
763 nfsd4_decode_read(struct nfsd4_compoundargs
*argp
, struct nfsd4_read
*read
)
767 status
= nfsd4_decode_stateid(argp
, &read
->rd_stateid
);
771 READ64(read
->rd_offset
);
772 READ32(read
->rd_length
);
778 nfsd4_decode_readdir(struct nfsd4_compoundargs
*argp
, struct nfsd4_readdir
*readdir
)
783 READ64(readdir
->rd_cookie
);
784 COPYMEM(readdir
->rd_verf
.data
, sizeof(readdir
->rd_verf
.data
));
785 READ32(readdir
->rd_dircount
); /* just in case you needed a useless field... */
786 READ32(readdir
->rd_maxcount
);
787 if ((status
= nfsd4_decode_bitmap(argp
, readdir
->rd_bmval
)))
794 nfsd4_decode_remove(struct nfsd4_compoundargs
*argp
, struct nfsd4_remove
*remove
)
799 READ32(remove
->rm_namelen
);
800 READ_BUF(remove
->rm_namelen
);
801 SAVEMEM(remove
->rm_name
, remove
->rm_namelen
);
802 if ((status
= check_filename(remove
->rm_name
, remove
->rm_namelen
, nfserr_noent
)))
809 nfsd4_decode_rename(struct nfsd4_compoundargs
*argp
, struct nfsd4_rename
*rename
)
814 READ32(rename
->rn_snamelen
);
815 READ_BUF(rename
->rn_snamelen
+ 4);
816 SAVEMEM(rename
->rn_sname
, rename
->rn_snamelen
);
817 READ32(rename
->rn_tnamelen
);
818 READ_BUF(rename
->rn_tnamelen
);
819 SAVEMEM(rename
->rn_tname
, rename
->rn_tnamelen
);
820 if ((status
= check_filename(rename
->rn_sname
, rename
->rn_snamelen
, nfserr_noent
)))
822 if ((status
= check_filename(rename
->rn_tname
, rename
->rn_tnamelen
, nfserr_inval
)))
829 nfsd4_decode_renew(struct nfsd4_compoundargs
*argp
, clientid_t
*clientid
)
833 READ_BUF(sizeof(clientid_t
));
834 COPYMEM(clientid
, sizeof(clientid_t
));
840 nfsd4_decode_secinfo(struct nfsd4_compoundargs
*argp
,
841 struct nfsd4_secinfo
*secinfo
)
846 READ32(secinfo
->si_namelen
);
847 READ_BUF(secinfo
->si_namelen
);
848 SAVEMEM(secinfo
->si_name
, secinfo
->si_namelen
);
849 status
= check_filename(secinfo
->si_name
, secinfo
->si_namelen
,
857 nfsd4_decode_setattr(struct nfsd4_compoundargs
*argp
, struct nfsd4_setattr
*setattr
)
861 status
= nfsd4_decode_stateid(argp
, &setattr
->sa_stateid
);
864 return nfsd4_decode_fattr(argp
, setattr
->sa_bmval
, &setattr
->sa_iattr
,
869 nfsd4_decode_setclientid(struct nfsd4_compoundargs
*argp
, struct nfsd4_setclientid
*setclientid
)
874 COPYMEM(setclientid
->se_verf
.data
, 8);
875 READ32(setclientid
->se_namelen
);
877 READ_BUF(setclientid
->se_namelen
+ 8);
878 SAVEMEM(setclientid
->se_name
, setclientid
->se_namelen
);
879 READ32(setclientid
->se_callback_prog
);
880 READ32(setclientid
->se_callback_netid_len
);
882 READ_BUF(setclientid
->se_callback_netid_len
+ 4);
883 SAVEMEM(setclientid
->se_callback_netid_val
, setclientid
->se_callback_netid_len
);
884 READ32(setclientid
->se_callback_addr_len
);
886 READ_BUF(setclientid
->se_callback_addr_len
+ 4);
887 SAVEMEM(setclientid
->se_callback_addr_val
, setclientid
->se_callback_addr_len
);
888 READ32(setclientid
->se_callback_ident
);
894 nfsd4_decode_setclientid_confirm(struct nfsd4_compoundargs
*argp
, struct nfsd4_setclientid_confirm
*scd_c
)
898 READ_BUF(8 + sizeof(nfs4_verifier
));
899 COPYMEM(&scd_c
->sc_clientid
, 8);
900 COPYMEM(&scd_c
->sc_confirm
, sizeof(nfs4_verifier
));
905 /* Also used for NVERIFY */
907 nfsd4_decode_verify(struct nfsd4_compoundargs
*argp
, struct nfsd4_verify
*verify
)
910 struct nfsd4_compoundargs save
= {
913 .rqstp
= argp
->rqstp
,
916 struct iattr ve_iattr
; /* request */
917 struct nfs4_acl
*ve_acl
; /* request */
921 if ((status
= nfsd4_decode_bitmap(argp
, verify
->ve_bmval
)))
924 /* For convenience's sake, we compare raw xdr'd attributes in
925 * nfsd4_proc_verify; however we still decode here just to return
926 * correct error in case of bad xdr. */
928 status
= nfsd4_decode_fattr(ve_bmval
, &ve_iattr
, &ve_acl
);
929 if (status
== nfserr_inval
) {
930 status
= nfserrno(status
);
935 READ32(verify
->ve_attrlen
);
936 READ_BUF(verify
->ve_attrlen
);
937 SAVEMEM(verify
->ve_attrval
, verify
->ve_attrlen
);
943 nfsd4_decode_write(struct nfsd4_compoundargs
*argp
, struct nfsd4_write
*write
)
950 status
= nfsd4_decode_stateid(argp
, &write
->wr_stateid
);
954 READ64(write
->wr_offset
);
955 READ32(write
->wr_stable_how
);
956 if (write
->wr_stable_how
> 2)
958 READ32(write
->wr_buflen
);
960 /* Sorry .. no magic macros for this.. *
961 * READ_BUF(write->wr_buflen);
962 * SAVEMEM(write->wr_buf, write->wr_buflen);
964 avail
= (char*)argp
->end
- (char*)argp
->p
;
965 if (avail
+ argp
->pagelen
< write
->wr_buflen
) {
966 dprintk("NFSD: xdr error (%s:%d)\n",
970 argp
->rqstp
->rq_vec
[0].iov_base
= p
;
971 argp
->rqstp
->rq_vec
[0].iov_len
= avail
;
973 len
= write
->wr_buflen
;
974 while (len
> argp
->rqstp
->rq_vec
[v
].iov_len
) {
975 len
-= argp
->rqstp
->rq_vec
[v
].iov_len
;
977 argp
->rqstp
->rq_vec
[v
].iov_base
= page_address(argp
->pagelist
[0]);
979 if (argp
->pagelen
>= PAGE_SIZE
) {
980 argp
->rqstp
->rq_vec
[v
].iov_len
= PAGE_SIZE
;
981 argp
->pagelen
-= PAGE_SIZE
;
983 argp
->rqstp
->rq_vec
[v
].iov_len
= argp
->pagelen
;
984 argp
->pagelen
-= len
;
987 argp
->end
= (__be32
*) (argp
->rqstp
->rq_vec
[v
].iov_base
+ argp
->rqstp
->rq_vec
[v
].iov_len
);
988 argp
->p
= (__be32
*) (argp
->rqstp
->rq_vec
[v
].iov_base
+ (XDR_QUADLEN(len
) << 2));
989 argp
->rqstp
->rq_vec
[v
].iov_len
= len
;
990 write
->wr_vlen
= v
+1;
996 nfsd4_decode_release_lockowner(struct nfsd4_compoundargs
*argp
, struct nfsd4_release_lockowner
*rlockowner
)
1001 COPYMEM(&rlockowner
->rl_clientid
, sizeof(clientid_t
));
1002 READ32(rlockowner
->rl_owner
.len
);
1003 READ_BUF(rlockowner
->rl_owner
.len
);
1004 READMEM(rlockowner
->rl_owner
.data
, rlockowner
->rl_owner
.len
);
1006 if (argp
->minorversion
&& !zero_clientid(&rlockowner
->rl_clientid
))
1007 return nfserr_inval
;
1012 nfsd4_decode_exchange_id(struct nfsd4_compoundargs
*argp
,
1013 struct nfsd4_exchange_id
*exid
)
1018 READ_BUF(NFS4_VERIFIER_SIZE
);
1019 COPYMEM(exid
->verifier
.data
, NFS4_VERIFIER_SIZE
);
1022 READ32(exid
->clname
.len
);
1024 READ_BUF(exid
->clname
.len
);
1025 SAVEMEM(exid
->clname
.data
, exid
->clname
.len
);
1028 READ32(exid
->flags
);
1030 /* Ignore state_protect4_a */
1032 READ32(exid
->spa_how
);
1033 switch (exid
->spa_how
) {
1037 /* spo_must_enforce */
1040 READ_BUF(dummy
* 4);
1043 /* spo_must_allow */
1046 READ_BUF(dummy
* 4);
1053 READ_BUF(dummy
* 4);
1058 READ_BUF(dummy
* 4);
1061 /* ssp_hash_algs<> */
1065 p
+= XDR_QUADLEN(dummy
);
1067 /* ssp_encr_algs<> */
1071 p
+= XDR_QUADLEN(dummy
);
1073 /* ssp_window and ssp_num_gss_handles */
1082 /* Ignore Implementation ID */
1083 READ_BUF(4); /* nfs_impl_id4 array length */
1094 p
+= XDR_QUADLEN(dummy
);
1100 p
+= XDR_QUADLEN(dummy
);
1110 nfsd4_decode_create_session(struct nfsd4_compoundargs
*argp
,
1111 struct nfsd4_create_session
*sess
)
1121 COPYMEM(&sess
->clientid
, 8);
1122 READ32(sess
->seqid
);
1123 READ32(sess
->flags
);
1125 /* Fore channel attrs */
1127 READ32(dummy
); /* headerpadsz is always 0 */
1128 READ32(sess
->fore_channel
.maxreq_sz
);
1129 READ32(sess
->fore_channel
.maxresp_sz
);
1130 READ32(sess
->fore_channel
.maxresp_cached
);
1131 READ32(sess
->fore_channel
.maxops
);
1132 READ32(sess
->fore_channel
.maxreqs
);
1133 READ32(sess
->fore_channel
.nr_rdma_attrs
);
1134 if (sess
->fore_channel
.nr_rdma_attrs
== 1) {
1136 READ32(sess
->fore_channel
.rdma_attrs
);
1137 } else if (sess
->fore_channel
.nr_rdma_attrs
> 1) {
1138 dprintk("Too many fore channel attr bitmaps!\n");
1142 /* Back channel attrs */
1144 READ32(dummy
); /* headerpadsz is always 0 */
1145 READ32(sess
->back_channel
.maxreq_sz
);
1146 READ32(sess
->back_channel
.maxresp_sz
);
1147 READ32(sess
->back_channel
.maxresp_cached
);
1148 READ32(sess
->back_channel
.maxops
);
1149 READ32(sess
->back_channel
.maxreqs
);
1150 READ32(sess
->back_channel
.nr_rdma_attrs
);
1151 if (sess
->back_channel
.nr_rdma_attrs
== 1) {
1153 READ32(sess
->back_channel
.rdma_attrs
);
1154 } else if (sess
->back_channel
.nr_rdma_attrs
> 1) {
1155 dprintk("Too many back channel attr bitmaps!\n");
1160 READ32(sess
->callback_prog
);
1162 /* callback_sec_params4 */
1163 READ32(nr_secflavs
);
1164 for (i
= 0; i
< nr_secflavs
; ++i
) {
1169 /* Nothing to read */
1179 SAVEMEM(machine_name
, dummy
);
1189 READ_BUF(dummy
* 4);
1192 dprintk("RPC_AUTH_GSS callback secflavor "
1193 "not supported!\n");
1197 /* gcbp_handle_from_server */
1200 p
+= XDR_QUADLEN(dummy
);
1201 /* gcbp_handle_from_client */
1207 dprintk("Illegal callback secflavor\n");
1208 return nfserr_inval
;
1215 nfsd4_decode_destroy_session(struct nfsd4_compoundargs
*argp
,
1216 struct nfsd4_destroy_session
*destroy_session
)
1219 READ_BUF(NFS4_MAX_SESSIONID_LEN
);
1220 COPYMEM(destroy_session
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
1226 nfsd4_decode_sequence(struct nfsd4_compoundargs
*argp
,
1227 struct nfsd4_sequence
*seq
)
1231 READ_BUF(NFS4_MAX_SESSIONID_LEN
+ 16);
1232 COPYMEM(seq
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
1234 READ32(seq
->slotid
);
1235 READ32(seq
->maxslots
);
1236 READ32(seq
->cachethis
);
1242 nfsd4_decode_noop(struct nfsd4_compoundargs
*argp
, void *p
)
1248 nfsd4_decode_notsupp(struct nfsd4_compoundargs
*argp
, void *p
)
1250 return nfserr_notsupp
;
1253 typedef __be32(*nfsd4_dec
)(struct nfsd4_compoundargs
*argp
, void *);
1255 static nfsd4_dec nfsd4_dec_ops
[] = {
1256 [OP_ACCESS
] = (nfsd4_dec
)nfsd4_decode_access
,
1257 [OP_CLOSE
] = (nfsd4_dec
)nfsd4_decode_close
,
1258 [OP_COMMIT
] = (nfsd4_dec
)nfsd4_decode_commit
,
1259 [OP_CREATE
] = (nfsd4_dec
)nfsd4_decode_create
,
1260 [OP_DELEGPURGE
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1261 [OP_DELEGRETURN
] = (nfsd4_dec
)nfsd4_decode_delegreturn
,
1262 [OP_GETATTR
] = (nfsd4_dec
)nfsd4_decode_getattr
,
1263 [OP_GETFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1264 [OP_LINK
] = (nfsd4_dec
)nfsd4_decode_link
,
1265 [OP_LOCK
] = (nfsd4_dec
)nfsd4_decode_lock
,
1266 [OP_LOCKT
] = (nfsd4_dec
)nfsd4_decode_lockt
,
1267 [OP_LOCKU
] = (nfsd4_dec
)nfsd4_decode_locku
,
1268 [OP_LOOKUP
] = (nfsd4_dec
)nfsd4_decode_lookup
,
1269 [OP_LOOKUPP
] = (nfsd4_dec
)nfsd4_decode_noop
,
1270 [OP_NVERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
1271 [OP_OPEN
] = (nfsd4_dec
)nfsd4_decode_open
,
1272 [OP_OPENATTR
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1273 [OP_OPEN_CONFIRM
] = (nfsd4_dec
)nfsd4_decode_open_confirm
,
1274 [OP_OPEN_DOWNGRADE
] = (nfsd4_dec
)nfsd4_decode_open_downgrade
,
1275 [OP_PUTFH
] = (nfsd4_dec
)nfsd4_decode_putfh
,
1276 [OP_PUTPUBFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1277 [OP_PUTROOTFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1278 [OP_READ
] = (nfsd4_dec
)nfsd4_decode_read
,
1279 [OP_READDIR
] = (nfsd4_dec
)nfsd4_decode_readdir
,
1280 [OP_READLINK
] = (nfsd4_dec
)nfsd4_decode_noop
,
1281 [OP_REMOVE
] = (nfsd4_dec
)nfsd4_decode_remove
,
1282 [OP_RENAME
] = (nfsd4_dec
)nfsd4_decode_rename
,
1283 [OP_RENEW
] = (nfsd4_dec
)nfsd4_decode_renew
,
1284 [OP_RESTOREFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1285 [OP_SAVEFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1286 [OP_SECINFO
] = (nfsd4_dec
)nfsd4_decode_secinfo
,
1287 [OP_SETATTR
] = (nfsd4_dec
)nfsd4_decode_setattr
,
1288 [OP_SETCLIENTID
] = (nfsd4_dec
)nfsd4_decode_setclientid
,
1289 [OP_SETCLIENTID_CONFIRM
] = (nfsd4_dec
)nfsd4_decode_setclientid_confirm
,
1290 [OP_VERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
1291 [OP_WRITE
] = (nfsd4_dec
)nfsd4_decode_write
,
1292 [OP_RELEASE_LOCKOWNER
] = (nfsd4_dec
)nfsd4_decode_release_lockowner
,
1295 static nfsd4_dec nfsd41_dec_ops
[] = {
1296 [OP_ACCESS
] = (nfsd4_dec
)nfsd4_decode_access
,
1297 [OP_CLOSE
] = (nfsd4_dec
)nfsd4_decode_close
,
1298 [OP_COMMIT
] = (nfsd4_dec
)nfsd4_decode_commit
,
1299 [OP_CREATE
] = (nfsd4_dec
)nfsd4_decode_create
,
1300 [OP_DELEGPURGE
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1301 [OP_DELEGRETURN
] = (nfsd4_dec
)nfsd4_decode_delegreturn
,
1302 [OP_GETATTR
] = (nfsd4_dec
)nfsd4_decode_getattr
,
1303 [OP_GETFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1304 [OP_LINK
] = (nfsd4_dec
)nfsd4_decode_link
,
1305 [OP_LOCK
] = (nfsd4_dec
)nfsd4_decode_lock
,
1306 [OP_LOCKT
] = (nfsd4_dec
)nfsd4_decode_lockt
,
1307 [OP_LOCKU
] = (nfsd4_dec
)nfsd4_decode_locku
,
1308 [OP_LOOKUP
] = (nfsd4_dec
)nfsd4_decode_lookup
,
1309 [OP_LOOKUPP
] = (nfsd4_dec
)nfsd4_decode_noop
,
1310 [OP_NVERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
1311 [OP_OPEN
] = (nfsd4_dec
)nfsd4_decode_open
,
1312 [OP_OPENATTR
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1313 [OP_OPEN_CONFIRM
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1314 [OP_OPEN_DOWNGRADE
] = (nfsd4_dec
)nfsd4_decode_open_downgrade
,
1315 [OP_PUTFH
] = (nfsd4_dec
)nfsd4_decode_putfh
,
1316 [OP_PUTPUBFH
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1317 [OP_PUTROOTFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1318 [OP_READ
] = (nfsd4_dec
)nfsd4_decode_read
,
1319 [OP_READDIR
] = (nfsd4_dec
)nfsd4_decode_readdir
,
1320 [OP_READLINK
] = (nfsd4_dec
)nfsd4_decode_noop
,
1321 [OP_REMOVE
] = (nfsd4_dec
)nfsd4_decode_remove
,
1322 [OP_RENAME
] = (nfsd4_dec
)nfsd4_decode_rename
,
1323 [OP_RENEW
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1324 [OP_RESTOREFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1325 [OP_SAVEFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1326 [OP_SECINFO
] = (nfsd4_dec
)nfsd4_decode_secinfo
,
1327 [OP_SETATTR
] = (nfsd4_dec
)nfsd4_decode_setattr
,
1328 [OP_SETCLIENTID
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1329 [OP_SETCLIENTID_CONFIRM
]= (nfsd4_dec
)nfsd4_decode_notsupp
,
1330 [OP_VERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
1331 [OP_WRITE
] = (nfsd4_dec
)nfsd4_decode_write
,
1332 [OP_RELEASE_LOCKOWNER
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1334 /* new operations for NFSv4.1 */
1335 [OP_BACKCHANNEL_CTL
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1336 [OP_BIND_CONN_TO_SESSION
]= (nfsd4_dec
)nfsd4_decode_notsupp
,
1337 [OP_EXCHANGE_ID
] = (nfsd4_dec
)nfsd4_decode_exchange_id
,
1338 [OP_CREATE_SESSION
] = (nfsd4_dec
)nfsd4_decode_create_session
,
1339 [OP_DESTROY_SESSION
] = (nfsd4_dec
)nfsd4_decode_destroy_session
,
1340 [OP_FREE_STATEID
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1341 [OP_GET_DIR_DELEGATION
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1342 [OP_GETDEVICEINFO
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1343 [OP_GETDEVICELIST
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1344 [OP_LAYOUTCOMMIT
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1345 [OP_LAYOUTGET
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1346 [OP_LAYOUTRETURN
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1347 [OP_SECINFO_NO_NAME
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1348 [OP_SEQUENCE
] = (nfsd4_dec
)nfsd4_decode_sequence
,
1349 [OP_SET_SSV
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1350 [OP_TEST_STATEID
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1351 [OP_WANT_DELEGATION
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1352 [OP_DESTROY_CLIENTID
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1353 [OP_RECLAIM_COMPLETE
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1356 struct nfsd4_minorversion_ops
{
1357 nfsd4_dec
*decoders
;
1361 static struct nfsd4_minorversion_ops nfsd4_minorversion
[] = {
1362 [0] = { nfsd4_dec_ops
, ARRAY_SIZE(nfsd4_dec_ops
) },
1363 [1] = { nfsd41_dec_ops
, ARRAY_SIZE(nfsd41_dec_ops
) },
1367 nfsd4_decode_compound(struct nfsd4_compoundargs
*argp
)
1370 struct nfsd4_op
*op
;
1371 struct nfsd4_minorversion_ops
*ops
;
1375 * XXX: According to spec, we should check the tag
1376 * for UTF-8 compliance. I'm postponing this for
1377 * now because it seems that some clients do use
1381 READ32(argp
->taglen
);
1382 READ_BUF(argp
->taglen
+ 8);
1383 SAVEMEM(argp
->tag
, argp
->taglen
);
1384 READ32(argp
->minorversion
);
1385 READ32(argp
->opcnt
);
1387 if (argp
->taglen
> NFSD4_MAX_TAGLEN
)
1389 if (argp
->opcnt
> 100)
1392 if (argp
->opcnt
> ARRAY_SIZE(argp
->iops
)) {
1393 argp
->ops
= kmalloc(argp
->opcnt
* sizeof(*argp
->ops
), GFP_KERNEL
);
1395 argp
->ops
= argp
->iops
;
1396 dprintk("nfsd: couldn't allocate room for COMPOUND\n");
1401 if (argp
->minorversion
>= ARRAY_SIZE(nfsd4_minorversion
))
1404 ops
= &nfsd4_minorversion
[argp
->minorversion
];
1405 for (i
= 0; i
< argp
->opcnt
; i
++) {
1410 * We can't use READ_BUF() here because we need to handle
1411 * a missing opcode as an OP_WRITE + 1. So we need to check
1412 * to see if we're truly at the end of our buffer or if there
1413 * is another page we need to flip to.
1416 if (argp
->p
== argp
->end
) {
1417 if (argp
->pagelen
< 4) {
1418 /* There isn't an opcode still on the wire */
1419 op
->opnum
= OP_WRITE
+ 1;
1420 op
->status
= nfserr_bad_xdr
;
1426 * False alarm. We just hit a page boundary, but there
1427 * is still data available. Move pointer across page
1428 * boundary. *snip from READ_BUF*
1430 argp
->p
= page_address(argp
->pagelist
[0]);
1432 if (argp
->pagelen
< PAGE_SIZE
) {
1433 argp
->end
= argp
->p
+ (argp
->pagelen
>>2);
1436 argp
->end
= argp
->p
+ (PAGE_SIZE
>>2);
1437 argp
->pagelen
-= PAGE_SIZE
;
1440 op
->opnum
= ntohl(*argp
->p
++);
1442 if (op
->opnum
>= OP_ACCESS
&& op
->opnum
< ops
->nops
)
1443 op
->status
= ops
->decoders
[op
->opnum
](argp
, &op
->u
);
1445 op
->opnum
= OP_ILLEGAL
;
1446 op
->status
= nfserr_op_illegal
;
1458 #define WRITE32(n) *p++ = htonl(n)
1459 #define WRITE64(n) do { \
1460 *p++ = htonl((u32)((n) >> 32)); \
1461 *p++ = htonl((u32)(n)); \
1463 #define WRITEMEM(ptr,nbytes) do { if (nbytes > 0) { \
1464 *(p + XDR_QUADLEN(nbytes) -1) = 0; \
1465 memcpy(p, ptr, nbytes); \
1466 p += XDR_QUADLEN(nbytes); \
1469 static void write32(__be32
**p
, u32 n
)
1474 static void write64(__be32
**p
, u64 n
)
1476 write32(p
, (u32
)(n
>> 32));
1480 static void write_change(__be32
**p
, struct kstat
*stat
, struct inode
*inode
)
1482 if (IS_I_VERSION(inode
)) {
1483 write64(p
, inode
->i_version
);
1485 write32(p
, stat
->ctime
.tv_sec
);
1486 write32(p
, stat
->ctime
.tv_nsec
);
1490 static void write_cinfo(__be32
**p
, struct nfsd4_change_info
*c
)
1492 write32(p
, c
->atomic
);
1493 if (c
->change_supported
) {
1494 write64(p
, c
->before_change
);
1495 write64(p
, c
->after_change
);
1497 write32(p
, c
->before_ctime_sec
);
1498 write32(p
, c
->before_ctime_nsec
);
1499 write32(p
, c
->after_ctime_sec
);
1500 write32(p
, c
->after_ctime_nsec
);
1504 #define RESERVE_SPACE(nbytes) do { \
1506 BUG_ON(p + XDR_QUADLEN(nbytes) > resp->end); \
1508 #define ADJUST_ARGS() resp->p = p
1511 * Header routine to setup seqid operation replay cache
1513 #define ENCODE_SEQID_OP_HEAD \
1519 * Routine for encoding the result of a "seqid-mutating" NFSv4 operation. This
1520 * is where sequence id's are incremented, and the replay cache is filled.
1521 * Note that we increment sequence id's here, at the last moment, so we're sure
1522 * we know whether the error to be returned is a sequence id mutating error.
1525 #define ENCODE_SEQID_OP_TAIL(stateowner) do { \
1526 if (seqid_mutating_err(nfserr) && stateowner) { \
1527 stateowner->so_seqid++; \
1528 stateowner->so_replay.rp_status = nfserr; \
1529 stateowner->so_replay.rp_buflen = \
1530 (((char *)(resp)->p - (char *)save)); \
1531 memcpy(stateowner->so_replay.rp_buf, save, \
1532 stateowner->so_replay.rp_buflen); \
1535 /* Encode as an array of strings the string given with components
1538 static __be32
nfsd4_encode_components(char sep
, char *components
,
1539 __be32
**pp
, int *buflen
)
1543 int strlen
, count
=0;
1546 dprintk("nfsd4_encode_components(%s)\n", components
);
1547 if ((*buflen
-= 4) < 0)
1548 return nfserr_resource
;
1549 WRITE32(0); /* We will fill this in with @count later */
1550 end
= str
= components
;
1552 for (; *end
&& (*end
!= sep
); end
++)
1553 ; /* Point to end of component */
1556 if ((*buflen
-= ((XDR_QUADLEN(strlen
) << 2) + 4)) < 0)
1557 return nfserr_resource
;
1559 WRITEMEM(str
, strlen
);
1573 * encode a location element of a fs_locations structure
1575 static __be32
nfsd4_encode_fs_location4(struct nfsd4_fs_location
*location
,
1576 __be32
**pp
, int *buflen
)
1581 status
= nfsd4_encode_components(':', location
->hosts
, &p
, buflen
);
1584 status
= nfsd4_encode_components('/', location
->path
, &p
, buflen
);
1592 * Return the path to an export point in the pseudo filesystem namespace
1593 * Returned string is safe to use as long as the caller holds a reference
1596 static char *nfsd4_path(struct svc_rqst
*rqstp
, struct svc_export
*exp
, __be32
*stat
)
1598 struct svc_fh tmp_fh
;
1599 char *path
= NULL
, *rootpath
;
1602 fh_init(&tmp_fh
, NFS4_FHSIZE
);
1603 *stat
= exp_pseudoroot(rqstp
, &tmp_fh
);
1606 rootpath
= tmp_fh
.fh_export
->ex_pathname
;
1608 path
= exp
->ex_pathname
;
1610 rootlen
= strlen(rootpath
);
1611 if (strncmp(path
, rootpath
, rootlen
)) {
1612 dprintk("nfsd: fs_locations failed;"
1613 "%s is not contained in %s\n", path
, rootpath
);
1614 *stat
= nfserr_notsupp
;
1625 * encode a fs_locations structure
1627 static __be32
nfsd4_encode_fs_locations(struct svc_rqst
*rqstp
,
1628 struct svc_export
*exp
,
1629 __be32
**pp
, int *buflen
)
1634 struct nfsd4_fs_locations
*fslocs
= &exp
->ex_fslocs
;
1635 char *root
= nfsd4_path(rqstp
, exp
, &status
);
1639 status
= nfsd4_encode_components('/', root
, &p
, buflen
);
1642 if ((*buflen
-= 4) < 0)
1643 return nfserr_resource
;
1644 WRITE32(fslocs
->locations_count
);
1645 for (i
=0; i
<fslocs
->locations_count
; i
++) {
1646 status
= nfsd4_encode_fs_location4(&fslocs
->locations
[i
],
1655 static u32 nfs4_ftypes
[16] = {
1656 NF4BAD
, NF4FIFO
, NF4CHR
, NF4BAD
,
1657 NF4DIR
, NF4BAD
, NF4BLK
, NF4BAD
,
1658 NF4REG
, NF4BAD
, NF4LNK
, NF4BAD
,
1659 NF4SOCK
, NF4BAD
, NF4LNK
, NF4BAD
,
1663 nfsd4_encode_name(struct svc_rqst
*rqstp
, int whotype
, uid_t id
, int group
,
1664 __be32
**p
, int *buflen
)
1668 if (*buflen
< (XDR_QUADLEN(IDMAP_NAMESZ
) << 2) + 4)
1669 return nfserr_resource
;
1670 if (whotype
!= NFS4_ACL_WHO_NAMED
)
1671 status
= nfs4_acl_write_who(whotype
, (u8
*)(*p
+ 1));
1673 status
= nfsd_map_gid_to_name(rqstp
, id
, (u8
*)(*p
+ 1));
1675 status
= nfsd_map_uid_to_name(rqstp
, id
, (u8
*)(*p
+ 1));
1677 return nfserrno(status
);
1678 *p
= xdr_encode_opaque(*p
, NULL
, status
);
1679 *buflen
-= (XDR_QUADLEN(status
) << 2) + 4;
1680 BUG_ON(*buflen
< 0);
1684 static inline __be32
1685 nfsd4_encode_user(struct svc_rqst
*rqstp
, uid_t uid
, __be32
**p
, int *buflen
)
1687 return nfsd4_encode_name(rqstp
, NFS4_ACL_WHO_NAMED
, uid
, 0, p
, buflen
);
1690 static inline __be32
1691 nfsd4_encode_group(struct svc_rqst
*rqstp
, uid_t gid
, __be32
**p
, int *buflen
)
1693 return nfsd4_encode_name(rqstp
, NFS4_ACL_WHO_NAMED
, gid
, 1, p
, buflen
);
1696 static inline __be32
1697 nfsd4_encode_aclname(struct svc_rqst
*rqstp
, int whotype
, uid_t id
, int group
,
1698 __be32
**p
, int *buflen
)
1700 return nfsd4_encode_name(rqstp
, whotype
, id
, group
, p
, buflen
);
1703 #define WORD0_ABSENT_FS_ATTRS (FATTR4_WORD0_FS_LOCATIONS | FATTR4_WORD0_FSID | \
1704 FATTR4_WORD0_RDATTR_ERROR)
1705 #define WORD1_ABSENT_FS_ATTRS FATTR4_WORD1_MOUNTED_ON_FILEID
1707 static __be32
fattr_handle_absent_fs(u32
*bmval0
, u32
*bmval1
, u32
*rdattr_err
)
1709 /* As per referral draft: */
1710 if (*bmval0
& ~WORD0_ABSENT_FS_ATTRS
||
1711 *bmval1
& ~WORD1_ABSENT_FS_ATTRS
) {
1712 if (*bmval0
& FATTR4_WORD0_RDATTR_ERROR
||
1713 *bmval0
& FATTR4_WORD0_FS_LOCATIONS
)
1714 *rdattr_err
= NFSERR_MOVED
;
1716 return nfserr_moved
;
1718 *bmval0
&= WORD0_ABSENT_FS_ATTRS
;
1719 *bmval1
&= WORD1_ABSENT_FS_ATTRS
;
1724 * Note: @fhp can be NULL; in this case, we might have to compose the filehandle
1727 * @countp is the buffer size in _words_; upon successful return this becomes
1728 * replaced with the number of words written.
1731 nfsd4_encode_fattr(struct svc_fh
*fhp
, struct svc_export
*exp
,
1732 struct dentry
*dentry
, __be32
*buffer
, int *countp
, u32
*bmval
,
1733 struct svc_rqst
*rqstp
, int ignore_crossmnt
)
1735 u32 bmval0
= bmval
[0];
1736 u32 bmval1
= bmval
[1];
1737 u32 bmval2
= bmval
[2];
1739 struct svc_fh tempfh
;
1740 struct kstatfs statfs
;
1741 int buflen
= *countp
<< 2;
1750 struct nfs4_acl
*acl
= NULL
;
1751 struct nfsd4_compoundres
*resp
= rqstp
->rq_resp
;
1752 u32 minorversion
= resp
->cstate
.minorversion
;
1754 BUG_ON(bmval1
& NFSD_WRITEONLY_ATTRS_WORD1
);
1755 BUG_ON(bmval0
& ~nfsd_suppattrs0(minorversion
));
1756 BUG_ON(bmval1
& ~nfsd_suppattrs1(minorversion
));
1757 BUG_ON(bmval2
& ~nfsd_suppattrs2(minorversion
));
1759 if (exp
->ex_fslocs
.migrated
) {
1761 status
= fattr_handle_absent_fs(&bmval0
, &bmval1
, &rdattr_err
);
1766 err
= vfs_getattr(exp
->ex_path
.mnt
, dentry
, &stat
);
1769 if ((bmval0
& (FATTR4_WORD0_FILES_FREE
| FATTR4_WORD0_FILES_TOTAL
|
1770 FATTR4_WORD0_MAXNAME
)) ||
1771 (bmval1
& (FATTR4_WORD1_SPACE_AVAIL
| FATTR4_WORD1_SPACE_FREE
|
1772 FATTR4_WORD1_SPACE_TOTAL
))) {
1773 err
= vfs_statfs(dentry
, &statfs
);
1777 if ((bmval0
& (FATTR4_WORD0_FILEHANDLE
| FATTR4_WORD0_FSID
)) && !fhp
) {
1778 fh_init(&tempfh
, NFS4_FHSIZE
);
1779 status
= fh_compose(&tempfh
, exp
, dentry
, NULL
);
1784 if (bmval0
& (FATTR4_WORD0_ACL
| FATTR4_WORD0_ACLSUPPORT
1785 | FATTR4_WORD0_SUPPORTED_ATTRS
)) {
1786 err
= nfsd4_get_nfs4_acl(rqstp
, dentry
, &acl
);
1787 aclsupport
= (err
== 0);
1788 if (bmval0
& FATTR4_WORD0_ACL
) {
1789 if (err
== -EOPNOTSUPP
)
1790 bmval0
&= ~FATTR4_WORD0_ACL
;
1791 else if (err
== -EINVAL
) {
1792 status
= nfserr_attrnotsupp
;
1794 } else if (err
!= 0)
1798 if ((buflen
-= 16) < 0)
1801 if (unlikely(bmval2
)) {
1806 } else if (likely(bmval1
)) {
1814 attrlenp
= p
++; /* to be backfilled later */
1816 if (bmval0
& FATTR4_WORD0_SUPPORTED_ATTRS
) {
1817 u32 word0
= nfsd_suppattrs0(minorversion
);
1818 u32 word1
= nfsd_suppattrs1(minorversion
);
1819 u32 word2
= nfsd_suppattrs2(minorversion
);
1821 if ((buflen
-= 12) < 0)
1824 word0
&= ~FATTR4_WORD0_ACL
;
1836 if (bmval0
& FATTR4_WORD0_TYPE
) {
1837 if ((buflen
-= 4) < 0)
1839 dummy
= nfs4_ftypes
[(stat
.mode
& S_IFMT
) >> 12];
1840 if (dummy
== NF4BAD
)
1841 goto out_serverfault
;
1844 if (bmval0
& FATTR4_WORD0_FH_EXPIRE_TYPE
) {
1845 if ((buflen
-= 4) < 0)
1847 if (exp
->ex_flags
& NFSEXP_NOSUBTREECHECK
)
1848 WRITE32(NFS4_FH_PERSISTENT
);
1850 WRITE32(NFS4_FH_PERSISTENT
|NFS4_FH_VOL_RENAME
);
1852 if (bmval0
& FATTR4_WORD0_CHANGE
) {
1853 if ((buflen
-= 8) < 0)
1855 write_change(&p
, &stat
, dentry
->d_inode
);
1857 if (bmval0
& FATTR4_WORD0_SIZE
) {
1858 if ((buflen
-= 8) < 0)
1862 if (bmval0
& FATTR4_WORD0_LINK_SUPPORT
) {
1863 if ((buflen
-= 4) < 0)
1867 if (bmval0
& FATTR4_WORD0_SYMLINK_SUPPORT
) {
1868 if ((buflen
-= 4) < 0)
1872 if (bmval0
& FATTR4_WORD0_NAMED_ATTR
) {
1873 if ((buflen
-= 4) < 0)
1877 if (bmval0
& FATTR4_WORD0_FSID
) {
1878 if ((buflen
-= 16) < 0)
1880 if (exp
->ex_fslocs
.migrated
) {
1881 WRITE64(NFS4_REFERRAL_FSID_MAJOR
);
1882 WRITE64(NFS4_REFERRAL_FSID_MINOR
);
1883 } else switch(fsid_source(fhp
)) {
1884 case FSIDSOURCE_FSID
:
1885 WRITE64((u64
)exp
->ex_fsid
);
1888 case FSIDSOURCE_DEV
:
1890 WRITE32(MAJOR(stat
.dev
));
1892 WRITE32(MINOR(stat
.dev
));
1894 case FSIDSOURCE_UUID
:
1895 WRITEMEM(exp
->ex_uuid
, 16);
1899 if (bmval0
& FATTR4_WORD0_UNIQUE_HANDLES
) {
1900 if ((buflen
-= 4) < 0)
1904 if (bmval0
& FATTR4_WORD0_LEASE_TIME
) {
1905 if ((buflen
-= 4) < 0)
1907 WRITE32(NFSD_LEASE_TIME
);
1909 if (bmval0
& FATTR4_WORD0_RDATTR_ERROR
) {
1910 if ((buflen
-= 4) < 0)
1912 WRITE32(rdattr_err
);
1914 if (bmval0
& FATTR4_WORD0_ACL
) {
1915 struct nfs4_ace
*ace
;
1918 if ((buflen
-= 4) < 0)
1924 if ((buflen
-= 4) < 0)
1926 WRITE32(acl
->naces
);
1928 for (ace
= acl
->aces
; ace
< acl
->aces
+ acl
->naces
; ace
++) {
1929 if ((buflen
-= 4*3) < 0)
1933 WRITE32(ace
->access_mask
& NFS4_ACE_MASK_ALL
);
1934 status
= nfsd4_encode_aclname(rqstp
, ace
->whotype
,
1935 ace
->who
, ace
->flag
& NFS4_ACE_IDENTIFIER_GROUP
,
1937 if (status
== nfserr_resource
)
1944 if (bmval0
& FATTR4_WORD0_ACLSUPPORT
) {
1945 if ((buflen
-= 4) < 0)
1947 WRITE32(aclsupport
?
1948 ACL4_SUPPORT_ALLOW_ACL
|ACL4_SUPPORT_DENY_ACL
: 0);
1950 if (bmval0
& FATTR4_WORD0_CANSETTIME
) {
1951 if ((buflen
-= 4) < 0)
1955 if (bmval0
& FATTR4_WORD0_CASE_INSENSITIVE
) {
1956 if ((buflen
-= 4) < 0)
1960 if (bmval0
& FATTR4_WORD0_CASE_PRESERVING
) {
1961 if ((buflen
-= 4) < 0)
1965 if (bmval0
& FATTR4_WORD0_CHOWN_RESTRICTED
) {
1966 if ((buflen
-= 4) < 0)
1970 if (bmval0
& FATTR4_WORD0_FILEHANDLE
) {
1971 buflen
-= (XDR_QUADLEN(fhp
->fh_handle
.fh_size
) << 2) + 4;
1974 WRITE32(fhp
->fh_handle
.fh_size
);
1975 WRITEMEM(&fhp
->fh_handle
.fh_base
, fhp
->fh_handle
.fh_size
);
1977 if (bmval0
& FATTR4_WORD0_FILEID
) {
1978 if ((buflen
-= 8) < 0)
1982 if (bmval0
& FATTR4_WORD0_FILES_AVAIL
) {
1983 if ((buflen
-= 8) < 0)
1985 WRITE64((u64
) statfs
.f_ffree
);
1987 if (bmval0
& FATTR4_WORD0_FILES_FREE
) {
1988 if ((buflen
-= 8) < 0)
1990 WRITE64((u64
) statfs
.f_ffree
);
1992 if (bmval0
& FATTR4_WORD0_FILES_TOTAL
) {
1993 if ((buflen
-= 8) < 0)
1995 WRITE64((u64
) statfs
.f_files
);
1997 if (bmval0
& FATTR4_WORD0_FS_LOCATIONS
) {
1998 status
= nfsd4_encode_fs_locations(rqstp
, exp
, &p
, &buflen
);
1999 if (status
== nfserr_resource
)
2004 if (bmval0
& FATTR4_WORD0_HOMOGENEOUS
) {
2005 if ((buflen
-= 4) < 0)
2009 if (bmval0
& FATTR4_WORD0_MAXFILESIZE
) {
2010 if ((buflen
-= 8) < 0)
2014 if (bmval0
& FATTR4_WORD0_MAXLINK
) {
2015 if ((buflen
-= 4) < 0)
2019 if (bmval0
& FATTR4_WORD0_MAXNAME
) {
2020 if ((buflen
-= 4) < 0)
2022 WRITE32(statfs
.f_namelen
);
2024 if (bmval0
& FATTR4_WORD0_MAXREAD
) {
2025 if ((buflen
-= 8) < 0)
2027 WRITE64((u64
) svc_max_payload(rqstp
));
2029 if (bmval0
& FATTR4_WORD0_MAXWRITE
) {
2030 if ((buflen
-= 8) < 0)
2032 WRITE64((u64
) svc_max_payload(rqstp
));
2034 if (bmval1
& FATTR4_WORD1_MODE
) {
2035 if ((buflen
-= 4) < 0)
2037 WRITE32(stat
.mode
& S_IALLUGO
);
2039 if (bmval1
& FATTR4_WORD1_NO_TRUNC
) {
2040 if ((buflen
-= 4) < 0)
2044 if (bmval1
& FATTR4_WORD1_NUMLINKS
) {
2045 if ((buflen
-= 4) < 0)
2047 WRITE32(stat
.nlink
);
2049 if (bmval1
& FATTR4_WORD1_OWNER
) {
2050 status
= nfsd4_encode_user(rqstp
, stat
.uid
, &p
, &buflen
);
2051 if (status
== nfserr_resource
)
2056 if (bmval1
& FATTR4_WORD1_OWNER_GROUP
) {
2057 status
= nfsd4_encode_group(rqstp
, stat
.gid
, &p
, &buflen
);
2058 if (status
== nfserr_resource
)
2063 if (bmval1
& FATTR4_WORD1_RAWDEV
) {
2064 if ((buflen
-= 8) < 0)
2066 WRITE32((u32
) MAJOR(stat
.rdev
));
2067 WRITE32((u32
) MINOR(stat
.rdev
));
2069 if (bmval1
& FATTR4_WORD1_SPACE_AVAIL
) {
2070 if ((buflen
-= 8) < 0)
2072 dummy64
= (u64
)statfs
.f_bavail
* (u64
)statfs
.f_bsize
;
2075 if (bmval1
& FATTR4_WORD1_SPACE_FREE
) {
2076 if ((buflen
-= 8) < 0)
2078 dummy64
= (u64
)statfs
.f_bfree
* (u64
)statfs
.f_bsize
;
2081 if (bmval1
& FATTR4_WORD1_SPACE_TOTAL
) {
2082 if ((buflen
-= 8) < 0)
2084 dummy64
= (u64
)statfs
.f_blocks
* (u64
)statfs
.f_bsize
;
2087 if (bmval1
& FATTR4_WORD1_SPACE_USED
) {
2088 if ((buflen
-= 8) < 0)
2090 dummy64
= (u64
)stat
.blocks
<< 9;
2093 if (bmval1
& FATTR4_WORD1_TIME_ACCESS
) {
2094 if ((buflen
-= 12) < 0)
2097 WRITE32(stat
.atime
.tv_sec
);
2098 WRITE32(stat
.atime
.tv_nsec
);
2100 if (bmval1
& FATTR4_WORD1_TIME_DELTA
) {
2101 if ((buflen
-= 12) < 0)
2107 if (bmval1
& FATTR4_WORD1_TIME_METADATA
) {
2108 if ((buflen
-= 12) < 0)
2111 WRITE32(stat
.ctime
.tv_sec
);
2112 WRITE32(stat
.ctime
.tv_nsec
);
2114 if (bmval1
& FATTR4_WORD1_TIME_MODIFY
) {
2115 if ((buflen
-= 12) < 0)
2118 WRITE32(stat
.mtime
.tv_sec
);
2119 WRITE32(stat
.mtime
.tv_nsec
);
2121 if (bmval1
& FATTR4_WORD1_MOUNTED_ON_FILEID
) {
2122 if ((buflen
-= 8) < 0)
2125 * Get parent's attributes if not ignoring crossmount
2126 * and this is the root of a cross-mounted filesystem.
2128 if (ignore_crossmnt
== 0 &&
2129 dentry
== exp
->ex_path
.mnt
->mnt_root
) {
2130 struct path path
= exp
->ex_path
;
2132 while (follow_up(&path
)) {
2133 if (path
.dentry
!= path
.mnt
->mnt_root
)
2136 err
= vfs_getattr(path
.mnt
, path
.dentry
, &stat
);
2143 if (bmval2
& FATTR4_WORD2_SUPPATTR_EXCLCREAT
) {
2145 WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD0
);
2146 WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD1
);
2147 WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD2
);
2150 *attrlenp
= htonl((char *)p
- (char *)attrlenp
- 4);
2151 *countp
= p
- buffer
;
2160 status
= nfserrno(err
);
2164 status
= nfserr_resource
;
2167 status
= nfserr_serverfault
;
2171 static inline int attributes_need_mount(u32
*bmval
)
2173 if (bmval
[0] & ~(FATTR4_WORD0_RDATTR_ERROR
| FATTR4_WORD0_LEASE_TIME
))
2175 if (bmval
[1] & ~FATTR4_WORD1_MOUNTED_ON_FILEID
)
2181 nfsd4_encode_dirent_fattr(struct nfsd4_readdir
*cd
,
2182 const char *name
, int namlen
, __be32
*p
, int *buflen
)
2184 struct svc_export
*exp
= cd
->rd_fhp
->fh_export
;
2185 struct dentry
*dentry
;
2187 int ignore_crossmnt
= 0;
2189 dentry
= lookup_one_len(name
, cd
->rd_fhp
->fh_dentry
, namlen
);
2191 return nfserrno(PTR_ERR(dentry
));
2192 if (!dentry
->d_inode
) {
2194 * nfsd_buffered_readdir drops the i_mutex between
2195 * readdir and calling this callback, leaving a window
2196 * where this directory entry could have gone away.
2199 return nfserr_noent
;
2204 * In the case of a mountpoint, the client may be asking for
2205 * attributes that are only properties of the underlying filesystem
2206 * as opposed to the cross-mounted file system. In such a case,
2207 * we will not follow the cross mount and will fill the attribtutes
2208 * directly from the mountpoint dentry.
2210 if (d_mountpoint(dentry
) && !attributes_need_mount(cd
->rd_bmval
))
2211 ignore_crossmnt
= 1;
2212 else if (d_mountpoint(dentry
)) {
2216 * Why the heck aren't we just using nfsd_lookup??
2217 * Different "."/".." handling? Something else?
2218 * At least, add a comment here to explain....
2220 err
= nfsd_cross_mnt(cd
->rd_rqstp
, &dentry
, &exp
);
2222 nfserr
= nfserrno(err
);
2225 nfserr
= check_nfsd_access(exp
, cd
->rd_rqstp
);
2230 nfserr
= nfsd4_encode_fattr(NULL
, exp
, dentry
, p
, buflen
, cd
->rd_bmval
,
2231 cd
->rd_rqstp
, ignore_crossmnt
);
2239 nfsd4_encode_rdattr_error(__be32
*p
, int buflen
, __be32 nfserr
)
2246 *p
++ = htonl(FATTR4_WORD0_RDATTR_ERROR
); /* bmval0 */
2247 *p
++ = htonl(0); /* bmval1 */
2250 *p
++ = nfserr
; /* no htonl */
2251 *attrlenp
= htonl((char *)p
- (char *)attrlenp
- 4);
2256 nfsd4_encode_dirent(void *ccdv
, const char *name
, int namlen
,
2257 loff_t offset
, u64 ino
, unsigned int d_type
)
2259 struct readdir_cd
*ccd
= ccdv
;
2260 struct nfsd4_readdir
*cd
= container_of(ccd
, struct nfsd4_readdir
, common
);
2262 __be32
*p
= cd
->buffer
;
2264 __be32 nfserr
= nfserr_toosmall
;
2266 /* In nfsv4, "." and ".." never make it onto the wire.. */
2267 if (name
&& isdotent(name
, namlen
)) {
2268 cd
->common
.err
= nfs_ok
;
2273 xdr_encode_hyper(cd
->offset
, (u64
) offset
);
2275 buflen
= cd
->buflen
- 4 - XDR_QUADLEN(namlen
);
2279 *p
++ = xdr_one
; /* mark entry present */
2281 p
= xdr_encode_hyper(p
, NFS_OFFSET_MAX
); /* offset of next entry */
2282 p
= xdr_encode_array(p
, name
, namlen
); /* name length & name */
2284 nfserr
= nfsd4_encode_dirent_fattr(cd
, name
, namlen
, p
, &buflen
);
2289 case nfserr_resource
:
2290 nfserr
= nfserr_toosmall
;
2298 * If the client requested the RDATTR_ERROR attribute,
2299 * we stuff the error code into this attribute
2300 * and continue. If this attribute was not requested,
2301 * then in accordance with the spec, we fail the
2302 * entire READDIR operation(!)
2304 if (!(cd
->rd_bmval
[0] & FATTR4_WORD0_RDATTR_ERROR
))
2306 p
= nfsd4_encode_rdattr_error(p
, buflen
, nfserr
);
2308 nfserr
= nfserr_toosmall
;
2312 cd
->buflen
-= (p
- cd
->buffer
);
2314 cd
->offset
= cookiep
;
2316 cd
->common
.err
= nfs_ok
;
2319 cd
->common
.err
= nfserr
;
2324 nfsd4_encode_stateid(struct nfsd4_compoundres
*resp
, stateid_t
*sid
)
2328 RESERVE_SPACE(sizeof(stateid_t
));
2329 WRITE32(sid
->si_generation
);
2330 WRITEMEM(&sid
->si_opaque
, sizeof(stateid_opaque_t
));
2335 nfsd4_encode_access(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_access
*access
)
2341 WRITE32(access
->ac_supported
);
2342 WRITE32(access
->ac_resp_access
);
2349 nfsd4_encode_close(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_close
*close
)
2351 ENCODE_SEQID_OP_HEAD
;
2354 nfsd4_encode_stateid(resp
, &close
->cl_stateid
);
2356 ENCODE_SEQID_OP_TAIL(close
->cl_stateowner
);
2362 nfsd4_encode_commit(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_commit
*commit
)
2368 WRITEMEM(commit
->co_verf
.data
, 8);
2375 nfsd4_encode_create(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_create
*create
)
2381 write_cinfo(&p
, &create
->cr_cinfo
);
2383 WRITE32(create
->cr_bmval
[0]);
2384 WRITE32(create
->cr_bmval
[1]);
2391 nfsd4_encode_getattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_getattr
*getattr
)
2393 struct svc_fh
*fhp
= getattr
->ga_fhp
;
2399 buflen
= resp
->end
- resp
->p
- (COMPOUND_ERR_SLACK_SPACE
>> 2);
2400 nfserr
= nfsd4_encode_fattr(fhp
, fhp
->fh_export
, fhp
->fh_dentry
,
2401 resp
->p
, &buflen
, getattr
->ga_bmval
,
2409 nfsd4_encode_getfh(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct svc_fh
**fhpp
)
2411 struct svc_fh
*fhp
= *fhpp
;
2416 len
= fhp
->fh_handle
.fh_size
;
2417 RESERVE_SPACE(len
+ 4);
2419 WRITEMEM(&fhp
->fh_handle
.fh_base
, len
);
2426 * Including all fields other than the name, a LOCK4denied structure requires
2427 * 8(clientid) + 4(namelen) + 8(offset) + 8(length) + 4(type) = 32 bytes.
2430 nfsd4_encode_lock_denied(struct nfsd4_compoundres
*resp
, struct nfsd4_lock_denied
*ld
)
2434 RESERVE_SPACE(32 + XDR_LEN(ld
->ld_sop
? ld
->ld_sop
->so_owner
.len
: 0));
2435 WRITE64(ld
->ld_start
);
2436 WRITE64(ld
->ld_length
);
2437 WRITE32(ld
->ld_type
);
2439 WRITEMEM(&ld
->ld_clientid
, 8);
2440 WRITE32(ld
->ld_sop
->so_owner
.len
);
2441 WRITEMEM(ld
->ld_sop
->so_owner
.data
, ld
->ld_sop
->so_owner
.len
);
2442 kref_put(&ld
->ld_sop
->so_ref
, nfs4_free_stateowner
);
2443 } else { /* non - nfsv4 lock in conflict, no clientid nor owner */
2444 WRITE64((u64
)0); /* clientid */
2445 WRITE32(0); /* length of owner name */
2451 nfsd4_encode_lock(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_lock
*lock
)
2453 ENCODE_SEQID_OP_HEAD
;
2456 nfsd4_encode_stateid(resp
, &lock
->lk_resp_stateid
);
2457 else if (nfserr
== nfserr_denied
)
2458 nfsd4_encode_lock_denied(resp
, &lock
->lk_denied
);
2460 ENCODE_SEQID_OP_TAIL(lock
->lk_replay_owner
);
2465 nfsd4_encode_lockt(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_lockt
*lockt
)
2467 if (nfserr
== nfserr_denied
)
2468 nfsd4_encode_lock_denied(resp
, &lockt
->lt_denied
);
2473 nfsd4_encode_locku(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_locku
*locku
)
2475 ENCODE_SEQID_OP_HEAD
;
2478 nfsd4_encode_stateid(resp
, &locku
->lu_stateid
);
2480 ENCODE_SEQID_OP_TAIL(locku
->lu_stateowner
);
2486 nfsd4_encode_link(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_link
*link
)
2492 write_cinfo(&p
, &link
->li_cinfo
);
2500 nfsd4_encode_open(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open
*open
)
2503 ENCODE_SEQID_OP_HEAD
;
2508 nfsd4_encode_stateid(resp
, &open
->op_stateid
);
2510 write_cinfo(&p
, &open
->op_cinfo
);
2511 WRITE32(open
->op_rflags
);
2513 WRITE32(open
->op_bmval
[0]);
2514 WRITE32(open
->op_bmval
[1]);
2515 WRITE32(open
->op_delegate_type
);
2518 switch (open
->op_delegate_type
) {
2519 case NFS4_OPEN_DELEGATE_NONE
:
2521 case NFS4_OPEN_DELEGATE_READ
:
2522 nfsd4_encode_stateid(resp
, &open
->op_delegate_stateid
);
2524 WRITE32(open
->op_recall
);
2527 * TODO: ACE's in delegations
2529 WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE
);
2532 WRITE32(0); /* XXX: is NULL principal ok? */
2535 case NFS4_OPEN_DELEGATE_WRITE
:
2536 nfsd4_encode_stateid(resp
, &open
->op_delegate_stateid
);
2541 * TODO: space_limit's in delegations
2543 WRITE32(NFS4_LIMIT_SIZE
);
2548 * TODO: ACE's in delegations
2550 WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE
);
2553 WRITE32(0); /* XXX: is NULL principal ok? */
2559 /* XXX save filehandle here */
2561 ENCODE_SEQID_OP_TAIL(open
->op_stateowner
);
2566 nfsd4_encode_open_confirm(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open_confirm
*oc
)
2568 ENCODE_SEQID_OP_HEAD
;
2571 nfsd4_encode_stateid(resp
, &oc
->oc_resp_stateid
);
2573 ENCODE_SEQID_OP_TAIL(oc
->oc_stateowner
);
2578 nfsd4_encode_open_downgrade(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open_downgrade
*od
)
2580 ENCODE_SEQID_OP_HEAD
;
2583 nfsd4_encode_stateid(resp
, &od
->od_stateid
);
2585 ENCODE_SEQID_OP_TAIL(od
->od_stateowner
);
2590 nfsd4_encode_read(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
2591 struct nfsd4_read
*read
)
2595 unsigned long maxcount
;
2601 if (resp
->xbuf
->page_len
)
2602 return nfserr_resource
;
2604 RESERVE_SPACE(8); /* eof flag and byte count */
2606 maxcount
= svc_max_payload(resp
->rqstp
);
2607 if (maxcount
> read
->rd_length
)
2608 maxcount
= read
->rd_length
;
2613 pn
= resp
->rqstp
->rq_resused
++;
2614 resp
->rqstp
->rq_vec
[v
].iov_base
=
2615 page_address(resp
->rqstp
->rq_respages
[pn
]);
2616 resp
->rqstp
->rq_vec
[v
].iov_len
=
2617 len
< PAGE_SIZE
? len
: PAGE_SIZE
;
2623 nfserr
= nfsd_read(read
->rd_rqstp
, read
->rd_fhp
, read
->rd_filp
,
2624 read
->rd_offset
, resp
->rqstp
->rq_vec
, read
->rd_vlen
,
2627 if (nfserr
== nfserr_symlink
)
2628 nfserr
= nfserr_inval
;
2631 eof
= (read
->rd_offset
+ maxcount
>=
2632 read
->rd_fhp
->fh_dentry
->d_inode
->i_size
);
2637 resp
->xbuf
->head
[0].iov_len
= (char*)p
2638 - (char*)resp
->xbuf
->head
[0].iov_base
;
2639 resp
->xbuf
->page_len
= maxcount
;
2641 /* Use rest of head for padding and remaining ops: */
2642 resp
->xbuf
->tail
[0].iov_base
= p
;
2643 resp
->xbuf
->tail
[0].iov_len
= 0;
2647 resp
->xbuf
->tail
[0].iov_base
+= maxcount
&3;
2648 resp
->xbuf
->tail
[0].iov_len
= 4 - (maxcount
&3);
2655 nfsd4_encode_readlink(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_readlink
*readlink
)
2663 if (resp
->xbuf
->page_len
)
2664 return nfserr_resource
;
2666 page
= page_address(resp
->rqstp
->rq_respages
[resp
->rqstp
->rq_resused
++]);
2668 maxcount
= PAGE_SIZE
;
2672 * XXX: By default, the ->readlink() VFS op will truncate symlinks
2673 * if they would overflow the buffer. Is this kosher in NFSv4? If
2674 * not, one easy fix is: if ->readlink() precisely fills the buffer,
2675 * assume that truncation occurred, and return NFS4ERR_RESOURCE.
2677 nfserr
= nfsd_readlink(readlink
->rl_rqstp
, readlink
->rl_fhp
, page
, &maxcount
);
2678 if (nfserr
== nfserr_isdir
)
2679 return nfserr_inval
;
2685 resp
->xbuf
->head
[0].iov_len
= (char*)p
2686 - (char*)resp
->xbuf
->head
[0].iov_base
;
2687 resp
->xbuf
->page_len
= maxcount
;
2689 /* Use rest of head for padding and remaining ops: */
2690 resp
->xbuf
->tail
[0].iov_base
= p
;
2691 resp
->xbuf
->tail
[0].iov_len
= 0;
2695 resp
->xbuf
->tail
[0].iov_base
+= maxcount
&3;
2696 resp
->xbuf
->tail
[0].iov_len
= 4 - (maxcount
&3);
2703 nfsd4_encode_readdir(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_readdir
*readdir
)
2707 __be32
*page
, *savep
, *tailbase
;
2712 if (resp
->xbuf
->page_len
)
2713 return nfserr_resource
;
2715 RESERVE_SPACE(8); /* verifier */
2718 /* XXX: Following NFSv3, we ignore the READDIR verifier for now. */
2722 resp
->xbuf
->head
[0].iov_len
= ((char*)resp
->p
) - (char*)resp
->xbuf
->head
[0].iov_base
;
2725 maxcount
= PAGE_SIZE
;
2726 if (maxcount
> readdir
->rd_maxcount
)
2727 maxcount
= readdir
->rd_maxcount
;
2730 * Convert from bytes to words, account for the two words already
2731 * written, make sure to leave two words at the end for the next
2732 * pointer and eof field.
2734 maxcount
= (maxcount
>> 2) - 4;
2736 nfserr
= nfserr_toosmall
;
2740 page
= page_address(resp
->rqstp
->rq_respages
[resp
->rqstp
->rq_resused
++]);
2741 readdir
->common
.err
= 0;
2742 readdir
->buflen
= maxcount
;
2743 readdir
->buffer
= page
;
2744 readdir
->offset
= NULL
;
2746 offset
= readdir
->rd_cookie
;
2747 nfserr
= nfsd_readdir(readdir
->rd_rqstp
, readdir
->rd_fhp
,
2749 &readdir
->common
, nfsd4_encode_dirent
);
2750 if (nfserr
== nfs_ok
&&
2751 readdir
->common
.err
== nfserr_toosmall
&&
2752 readdir
->buffer
== page
)
2753 nfserr
= nfserr_toosmall
;
2754 if (nfserr
== nfserr_symlink
)
2755 nfserr
= nfserr_notdir
;
2759 if (readdir
->offset
)
2760 xdr_encode_hyper(readdir
->offset
, offset
);
2762 p
= readdir
->buffer
;
2763 *p
++ = 0; /* no more entries */
2764 *p
++ = htonl(readdir
->common
.err
== nfserr_eof
);
2765 resp
->xbuf
->page_len
= ((char*)p
) - (char*)page_address(
2766 resp
->rqstp
->rq_respages
[resp
->rqstp
->rq_resused
-1]);
2768 /* Use rest of head for padding and remaining ops: */
2769 resp
->xbuf
->tail
[0].iov_base
= tailbase
;
2770 resp
->xbuf
->tail
[0].iov_len
= 0;
2771 resp
->p
= resp
->xbuf
->tail
[0].iov_base
;
2772 resp
->end
= resp
->p
+ (PAGE_SIZE
- resp
->xbuf
->head
[0].iov_len
)/4;
2782 nfsd4_encode_remove(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_remove
*remove
)
2788 write_cinfo(&p
, &remove
->rm_cinfo
);
2795 nfsd4_encode_rename(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_rename
*rename
)
2801 write_cinfo(&p
, &rename
->rn_sinfo
);
2802 write_cinfo(&p
, &rename
->rn_tinfo
);
2809 nfsd4_encode_secinfo(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
2810 struct nfsd4_secinfo
*secinfo
)
2813 struct svc_export
*exp
= secinfo
->si_exp
;
2815 struct exp_flavor_info
*flavs
;
2816 struct exp_flavor_info def_flavs
[2];
2821 if (exp
->ex_nflavors
) {
2822 flavs
= exp
->ex_flavors
;
2823 nflavs
= exp
->ex_nflavors
;
2824 } else { /* Handling of some defaults in absence of real secinfo: */
2826 if (exp
->ex_client
->flavour
->flavour
== RPC_AUTH_UNIX
) {
2828 flavs
[0].pseudoflavor
= RPC_AUTH_UNIX
;
2829 flavs
[1].pseudoflavor
= RPC_AUTH_NULL
;
2830 } else if (exp
->ex_client
->flavour
->flavour
== RPC_AUTH_GSS
) {
2832 flavs
[0].pseudoflavor
2833 = svcauth_gss_flavor(exp
->ex_client
);
2836 flavs
[0].pseudoflavor
2837 = exp
->ex_client
->flavour
->flavour
;
2844 for (i
= 0; i
< nflavs
; i
++) {
2845 u32 flav
= flavs
[i
].pseudoflavor
;
2846 struct gss_api_mech
*gm
= gss_mech_get_by_pseudoflavor(flav
);
2850 WRITE32(RPC_AUTH_GSS
);
2852 RESERVE_SPACE(4 + gm
->gm_oid
.len
);
2853 WRITE32(gm
->gm_oid
.len
);
2854 WRITEMEM(gm
->gm_oid
.data
, gm
->gm_oid
.len
);
2857 WRITE32(0); /* qop */
2860 WRITE32(gss_pseudoflavor_to_service(gm
, flav
));
2876 * The SETATTR encode routine is special -- it always encodes a bitmap,
2877 * regardless of the error status.
2880 nfsd4_encode_setattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_setattr
*setattr
)
2892 WRITE32(setattr
->sa_bmval
[0]);
2893 WRITE32(setattr
->sa_bmval
[1]);
2900 nfsd4_encode_setclientid(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_setclientid
*scd
)
2905 RESERVE_SPACE(8 + sizeof(nfs4_verifier
));
2906 WRITEMEM(&scd
->se_clientid
, 8);
2907 WRITEMEM(&scd
->se_confirm
, sizeof(nfs4_verifier
));
2910 else if (nfserr
== nfserr_clid_inuse
) {
2920 nfsd4_encode_write(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_write
*write
)
2926 WRITE32(write
->wr_bytes_written
);
2927 WRITE32(write
->wr_how_written
);
2928 WRITEMEM(write
->wr_verifier
.data
, 8);
2935 nfsd4_encode_exchange_id(struct nfsd4_compoundres
*resp
, int nfserr
,
2936 struct nfsd4_exchange_id
*exid
)
2942 int server_scope_sz
;
2943 uint64_t minor_id
= 0;
2948 major_id
= utsname()->nodename
;
2949 major_id_sz
= strlen(major_id
);
2950 server_scope
= utsname()->nodename
;
2951 server_scope_sz
= strlen(server_scope
);
2954 8 /* eir_clientid */ +
2955 4 /* eir_sequenceid */ +
2957 4 /* spr_how (SP4_NONE) */ +
2958 8 /* so_minor_id */ +
2959 4 /* so_major_id.len */ +
2960 (XDR_QUADLEN(major_id_sz
) * 4) +
2961 4 /* eir_server_scope.len */ +
2962 (XDR_QUADLEN(server_scope_sz
) * 4) +
2963 4 /* eir_server_impl_id.count (0) */);
2965 WRITEMEM(&exid
->clientid
, 8);
2966 WRITE32(exid
->seqid
);
2967 WRITE32(exid
->flags
);
2969 /* state_protect4_r. Currently only support SP4_NONE */
2970 BUG_ON(exid
->spa_how
!= SP4_NONE
);
2971 WRITE32(exid
->spa_how
);
2973 /* The server_owner struct */
2974 WRITE64(minor_id
); /* Minor id */
2976 WRITE32(major_id_sz
);
2977 WRITEMEM(major_id
, major_id_sz
);
2980 WRITE32(server_scope_sz
);
2981 WRITEMEM(server_scope
, server_scope_sz
);
2983 /* Implementation id */
2984 WRITE32(0); /* zero length nfs_impl_id4 array */
2990 nfsd4_encode_create_session(struct nfsd4_compoundres
*resp
, int nfserr
,
2991 struct nfsd4_create_session
*sess
)
2999 WRITEMEM(sess
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
3000 WRITE32(sess
->seqid
);
3001 WRITE32(sess
->flags
);
3005 WRITE32(0); /* headerpadsz */
3006 WRITE32(sess
->fore_channel
.maxreq_sz
);
3007 WRITE32(sess
->fore_channel
.maxresp_sz
);
3008 WRITE32(sess
->fore_channel
.maxresp_cached
);
3009 WRITE32(sess
->fore_channel
.maxops
);
3010 WRITE32(sess
->fore_channel
.maxreqs
);
3011 WRITE32(sess
->fore_channel
.nr_rdma_attrs
);
3014 if (sess
->fore_channel
.nr_rdma_attrs
) {
3016 WRITE32(sess
->fore_channel
.rdma_attrs
);
3021 WRITE32(0); /* headerpadsz */
3022 WRITE32(sess
->back_channel
.maxreq_sz
);
3023 WRITE32(sess
->back_channel
.maxresp_sz
);
3024 WRITE32(sess
->back_channel
.maxresp_cached
);
3025 WRITE32(sess
->back_channel
.maxops
);
3026 WRITE32(sess
->back_channel
.maxreqs
);
3027 WRITE32(sess
->back_channel
.nr_rdma_attrs
);
3030 if (sess
->back_channel
.nr_rdma_attrs
) {
3032 WRITE32(sess
->back_channel
.rdma_attrs
);
3039 nfsd4_encode_destroy_session(struct nfsd4_compoundres
*resp
, int nfserr
,
3040 struct nfsd4_destroy_session
*destroy_session
)
3046 nfsd4_encode_sequence(struct nfsd4_compoundres
*resp
, int nfserr
,
3047 struct nfsd4_sequence
*seq
)
3054 RESERVE_SPACE(NFS4_MAX_SESSIONID_LEN
+ 20);
3055 WRITEMEM(seq
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
3056 WRITE32(seq
->seqid
);
3057 WRITE32(seq
->slotid
);
3058 WRITE32(seq
->maxslots
);
3061 * target_maxslots = maxslots
3064 WRITE32(seq
->maxslots
);
3068 resp
->cstate
.datap
= p
; /* DRC cache data pointer */
3073 nfsd4_encode_noop(struct nfsd4_compoundres
*resp
, __be32 nfserr
, void *p
)
3078 typedef __be32(* nfsd4_enc
)(struct nfsd4_compoundres
*, __be32
, void *);
3081 * Note: nfsd4_enc_ops vector is shared for v4.0 and v4.1
3082 * since we don't need to filter out obsolete ops as this is
3083 * done in the decoding phase.
3085 static nfsd4_enc nfsd4_enc_ops
[] = {
3086 [OP_ACCESS
] = (nfsd4_enc
)nfsd4_encode_access
,
3087 [OP_CLOSE
] = (nfsd4_enc
)nfsd4_encode_close
,
3088 [OP_COMMIT
] = (nfsd4_enc
)nfsd4_encode_commit
,
3089 [OP_CREATE
] = (nfsd4_enc
)nfsd4_encode_create
,
3090 [OP_DELEGPURGE
] = (nfsd4_enc
)nfsd4_encode_noop
,
3091 [OP_DELEGRETURN
] = (nfsd4_enc
)nfsd4_encode_noop
,
3092 [OP_GETATTR
] = (nfsd4_enc
)nfsd4_encode_getattr
,
3093 [OP_GETFH
] = (nfsd4_enc
)nfsd4_encode_getfh
,
3094 [OP_LINK
] = (nfsd4_enc
)nfsd4_encode_link
,
3095 [OP_LOCK
] = (nfsd4_enc
)nfsd4_encode_lock
,
3096 [OP_LOCKT
] = (nfsd4_enc
)nfsd4_encode_lockt
,
3097 [OP_LOCKU
] = (nfsd4_enc
)nfsd4_encode_locku
,
3098 [OP_LOOKUP
] = (nfsd4_enc
)nfsd4_encode_noop
,
3099 [OP_LOOKUPP
] = (nfsd4_enc
)nfsd4_encode_noop
,
3100 [OP_NVERIFY
] = (nfsd4_enc
)nfsd4_encode_noop
,
3101 [OP_OPEN
] = (nfsd4_enc
)nfsd4_encode_open
,
3102 [OP_OPENATTR
] = (nfsd4_enc
)nfsd4_encode_noop
,
3103 [OP_OPEN_CONFIRM
] = (nfsd4_enc
)nfsd4_encode_open_confirm
,
3104 [OP_OPEN_DOWNGRADE
] = (nfsd4_enc
)nfsd4_encode_open_downgrade
,
3105 [OP_PUTFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3106 [OP_PUTPUBFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3107 [OP_PUTROOTFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3108 [OP_READ
] = (nfsd4_enc
)nfsd4_encode_read
,
3109 [OP_READDIR
] = (nfsd4_enc
)nfsd4_encode_readdir
,
3110 [OP_READLINK
] = (nfsd4_enc
)nfsd4_encode_readlink
,
3111 [OP_REMOVE
] = (nfsd4_enc
)nfsd4_encode_remove
,
3112 [OP_RENAME
] = (nfsd4_enc
)nfsd4_encode_rename
,
3113 [OP_RENEW
] = (nfsd4_enc
)nfsd4_encode_noop
,
3114 [OP_RESTOREFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3115 [OP_SAVEFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3116 [OP_SECINFO
] = (nfsd4_enc
)nfsd4_encode_secinfo
,
3117 [OP_SETATTR
] = (nfsd4_enc
)nfsd4_encode_setattr
,
3118 [OP_SETCLIENTID
] = (nfsd4_enc
)nfsd4_encode_setclientid
,
3119 [OP_SETCLIENTID_CONFIRM
] = (nfsd4_enc
)nfsd4_encode_noop
,
3120 [OP_VERIFY
] = (nfsd4_enc
)nfsd4_encode_noop
,
3121 [OP_WRITE
] = (nfsd4_enc
)nfsd4_encode_write
,
3122 [OP_RELEASE_LOCKOWNER
] = (nfsd4_enc
)nfsd4_encode_noop
,
3124 /* NFSv4.1 operations */
3125 [OP_BACKCHANNEL_CTL
] = (nfsd4_enc
)nfsd4_encode_noop
,
3126 [OP_BIND_CONN_TO_SESSION
] = (nfsd4_enc
)nfsd4_encode_noop
,
3127 [OP_EXCHANGE_ID
] = (nfsd4_enc
)nfsd4_encode_exchange_id
,
3128 [OP_CREATE_SESSION
] = (nfsd4_enc
)nfsd4_encode_create_session
,
3129 [OP_DESTROY_SESSION
] = (nfsd4_enc
)nfsd4_encode_destroy_session
,
3130 [OP_FREE_STATEID
] = (nfsd4_enc
)nfsd4_encode_noop
,
3131 [OP_GET_DIR_DELEGATION
] = (nfsd4_enc
)nfsd4_encode_noop
,
3132 [OP_GETDEVICEINFO
] = (nfsd4_enc
)nfsd4_encode_noop
,
3133 [OP_GETDEVICELIST
] = (nfsd4_enc
)nfsd4_encode_noop
,
3134 [OP_LAYOUTCOMMIT
] = (nfsd4_enc
)nfsd4_encode_noop
,
3135 [OP_LAYOUTGET
] = (nfsd4_enc
)nfsd4_encode_noop
,
3136 [OP_LAYOUTRETURN
] = (nfsd4_enc
)nfsd4_encode_noop
,
3137 [OP_SECINFO_NO_NAME
] = (nfsd4_enc
)nfsd4_encode_noop
,
3138 [OP_SEQUENCE
] = (nfsd4_enc
)nfsd4_encode_sequence
,
3139 [OP_SET_SSV
] = (nfsd4_enc
)nfsd4_encode_noop
,
3140 [OP_TEST_STATEID
] = (nfsd4_enc
)nfsd4_encode_noop
,
3141 [OP_WANT_DELEGATION
] = (nfsd4_enc
)nfsd4_encode_noop
,
3142 [OP_DESTROY_CLIENTID
] = (nfsd4_enc
)nfsd4_encode_noop
,
3143 [OP_RECLAIM_COMPLETE
] = (nfsd4_enc
)nfsd4_encode_noop
,
3147 * Calculate the total amount of memory that the compound response has taken
3148 * after encoding the current operation.
3150 * pad: add on 8 bytes for the next operation's op_code and status so that
3151 * there is room to cache a failure on the next operation.
3153 * Compare this length to the session se_fmaxresp_cached.
3155 * Our se_fmaxresp_cached will always be a multiple of PAGE_SIZE, and so
3156 * will be at least a page and will therefore hold the xdr_buf head.
3158 static int nfsd4_check_drc_limit(struct nfsd4_compoundres
*resp
)
3161 struct xdr_buf
*xb
= &resp
->rqstp
->rq_res
;
3162 struct nfsd4_compoundargs
*args
= resp
->rqstp
->rq_argp
;
3163 struct nfsd4_session
*session
= NULL
;
3164 struct nfsd4_slot
*slot
= resp
->cstate
.slot
;
3165 u32 length
, tlen
= 0, pad
= 8;
3167 if (!nfsd4_has_session(&resp
->cstate
))
3170 session
= resp
->cstate
.session
;
3171 if (session
== NULL
|| slot
->sl_cachethis
== 0)
3174 if (resp
->opcnt
>= args
->opcnt
)
3175 pad
= 0; /* this is the last operation */
3177 if (xb
->page_len
== 0) {
3178 length
= (char *)resp
->p
- (char *)xb
->head
[0].iov_base
+ pad
;
3180 if (xb
->tail
[0].iov_base
&& xb
->tail
[0].iov_len
> 0)
3181 tlen
= (char *)resp
->p
- (char *)xb
->tail
[0].iov_base
;
3183 length
= xb
->head
[0].iov_len
+ xb
->page_len
+ tlen
+ pad
;
3185 dprintk("%s length %u, xb->page_len %u tlen %u pad %u\n", __func__
,
3186 length
, xb
->page_len
, tlen
, pad
);
3188 if (length
<= session
->se_fchannel
.maxresp_cached
)
3191 return nfserr_rep_too_big_to_cache
;
3195 nfsd4_encode_operation(struct nfsd4_compoundres
*resp
, struct nfsd4_op
*op
)
3202 statp
= p
++; /* to be backfilled at the end */
3205 if (op
->opnum
== OP_ILLEGAL
)
3207 BUG_ON(op
->opnum
< 0 || op
->opnum
>= ARRAY_SIZE(nfsd4_enc_ops
) ||
3208 !nfsd4_enc_ops
[op
->opnum
]);
3209 op
->status
= nfsd4_enc_ops
[op
->opnum
](resp
, op
->status
, &op
->u
);
3210 /* nfsd4_check_drc_limit guarantees enough room for error status */
3211 if (!op
->status
&& nfsd4_check_drc_limit(resp
))
3212 op
->status
= nfserr_rep_too_big_to_cache
;
3215 * Note: We write the status directly, instead of using WRITE32(),
3216 * since it is already in network byte order.
3218 *statp
= op
->status
;
3222 * Encode the reply stored in the stateowner reply cache
3224 * XDR note: do not encode rp->rp_buflen: the buffer contains the
3225 * previously sent already encoded operation.
3227 * called with nfs4_lock_state() held
3230 nfsd4_encode_replay(struct nfsd4_compoundres
*resp
, struct nfsd4_op
*op
)
3233 struct nfs4_replay
*rp
= op
->replay
;
3239 *p
++ = rp
->rp_status
; /* already xdr'ed */
3242 RESERVE_SPACE(rp
->rp_buflen
);
3243 WRITEMEM(rp
->rp_buf
, rp
->rp_buflen
);
3248 nfs4svc_encode_voidres(struct svc_rqst
*rqstp
, __be32
*p
, void *dummy
)
3250 return xdr_ressize_check(rqstp
, p
);
3253 void nfsd4_release_compoundargs(struct nfsd4_compoundargs
*args
)
3255 if (args
->ops
!= args
->iops
) {
3257 args
->ops
= args
->iops
;
3261 while (args
->to_free
) {
3262 struct tmpbuf
*tb
= args
->to_free
;
3263 args
->to_free
= tb
->next
;
3264 tb
->release(tb
->buf
);
3270 nfs4svc_decode_compoundargs(struct svc_rqst
*rqstp
, __be32
*p
, struct nfsd4_compoundargs
*args
)
3275 args
->end
= rqstp
->rq_arg
.head
[0].iov_base
+ rqstp
->rq_arg
.head
[0].iov_len
;
3276 args
->pagelist
= rqstp
->rq_arg
.pages
;
3277 args
->pagelen
= rqstp
->rq_arg
.page_len
;
3279 args
->to_free
= NULL
;
3280 args
->ops
= args
->iops
;
3281 args
->rqstp
= rqstp
;
3283 status
= nfsd4_decode_compound(args
);
3285 nfsd4_release_compoundargs(args
);
3291 nfs4svc_encode_compoundres(struct svc_rqst
*rqstp
, __be32
*p
, struct nfsd4_compoundres
*resp
)
3294 * All that remains is to write the tag and operation count...
3296 struct nfsd4_compound_state
*cs
= &resp
->cstate
;
3299 *p
++ = htonl(resp
->taglen
);
3300 memcpy(p
, resp
->tag
, resp
->taglen
);
3301 p
+= XDR_QUADLEN(resp
->taglen
);
3302 *p
++ = htonl(resp
->opcnt
);
3304 if (rqstp
->rq_res
.page_len
)
3305 iov
= &rqstp
->rq_res
.tail
[0];
3307 iov
= &rqstp
->rq_res
.head
[0];
3308 iov
->iov_len
= ((char*)resp
->p
) - (char*)iov
->iov_base
;
3309 BUG_ON(iov
->iov_len
> PAGE_SIZE
);
3310 if (nfsd4_has_session(cs
) && cs
->status
!= nfserr_replay_cache
) {
3311 nfsd4_store_cache_entry(resp
);
3312 dprintk("%s: SET SLOT STATE TO AVAILABLE\n", __func__
);
3313 resp
->cstate
.slot
->sl_inuse
= false;
3314 nfsd4_put_session(resp
->cstate
.session
);