2 * Server-side XDR for NFSv4
4 * Copyright (c) 2002 The Regents of the University of Michigan.
7 * Kendrick Smith <kmsmith@umich.edu>
8 * Andy Adamson <andros@umich.edu>
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. Neither the name of the University nor the names of its
20 * contributors may be used to endorse or promote products derived
21 * from this software without specific prior written permission.
23 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
24 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
25 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
28 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
29 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
30 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
31 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
32 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
33 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 * TODO: Neil Brown made the following observation: We currently
36 * initially reserve NFSD_BUFSIZE space on the transmit queue and
37 * never release any of that until the request is complete.
38 * It would be good to calculate a new maximum response size while
39 * decoding the COMPOUND, and call svc_reserve with this number
40 * at the end of nfs4svc_decode_compoundargs.
43 #include <linux/slab.h>
44 #include <linux/namei.h>
45 #include <linux/statfs.h>
46 #include <linux/utsname.h>
47 #include <linux/pagemap.h>
48 #include <linux/sunrpc/svcauth_gss.h>
58 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
59 #include <linux/security.h>
63 #define NFSDDBG_FACILITY NFSDDBG_XDR
66 * As per referral draft, the fsid for a referral MUST be different from the fsid of the containing
67 * directory in order to indicate to the client that a filesystem boundary is present
68 * We use a fixed fsid for a referral
70 #define NFS4_REFERRAL_FSID_MAJOR 0x8000000ULL
71 #define NFS4_REFERRAL_FSID_MINOR 0x8000000ULL
74 check_filename(char *str
, int len
)
80 if (isdotent(str
, len
))
81 return nfserr_badname
;
82 for (i
= 0; i
< len
; i
++)
84 return nfserr_badname
;
96 dprintk("NFSD: xdr error (%s:%d)\n", \
97 __FILE__, __LINE__); \
98 status = nfserr_bad_xdr; \
101 #define READ32(x) (x) = ntohl(*p++)
102 #define READ64(x) do { \
103 (x) = (u64)ntohl(*p++) << 32; \
104 (x) |= ntohl(*p++); \
106 #define READMEM(x,nbytes) do { \
108 p += XDR_QUADLEN(nbytes); \
110 #define SAVEMEM(x,nbytes) do { \
111 if (!(x = (p==argp->tmp || p == argp->tmpp) ? \
112 savemem(argp, p, nbytes) : \
114 dprintk("NFSD: xdr error (%s:%d)\n", \
115 __FILE__, __LINE__); \
118 p += XDR_QUADLEN(nbytes); \
120 #define COPYMEM(x,nbytes) do { \
121 memcpy((x), p, nbytes); \
122 p += XDR_QUADLEN(nbytes); \
125 /* READ_BUF, read_buf(): nbytes must be <= PAGE_SIZE */
126 #define READ_BUF(nbytes) do { \
127 if (nbytes <= (u32)((char *)argp->end - (char *)argp->p)) { \
129 argp->p += XDR_QUADLEN(nbytes); \
130 } else if (!(p = read_buf(argp, nbytes))) { \
131 dprintk("NFSD: xdr error (%s:%d)\n", \
132 __FILE__, __LINE__); \
137 static void next_decode_page(struct nfsd4_compoundargs
*argp
)
139 argp
->p
= page_address(argp
->pagelist
[0]);
141 if (argp
->pagelen
< PAGE_SIZE
) {
142 argp
->end
= argp
->p
+ (argp
->pagelen
>>2);
145 argp
->end
= argp
->p
+ (PAGE_SIZE
>>2);
146 argp
->pagelen
-= PAGE_SIZE
;
150 static __be32
*read_buf(struct nfsd4_compoundargs
*argp
, u32 nbytes
)
152 /* We want more bytes than seem to be available.
153 * Maybe we need a new page, maybe we have just run out
155 unsigned int avail
= (char *)argp
->end
- (char *)argp
->p
;
157 if (avail
+ argp
->pagelen
< nbytes
)
159 if (avail
+ PAGE_SIZE
< nbytes
) /* need more than a page !! */
161 /* ok, we can do it with the current plus the next page */
162 if (nbytes
<= sizeof(argp
->tmp
))
166 p
= argp
->tmpp
= kmalloc(nbytes
, GFP_KERNEL
);
172 * The following memcpy is safe because read_buf is always
173 * called with nbytes > avail, and the two cases above both
174 * guarantee p points to at least nbytes bytes.
176 memcpy(p
, argp
->p
, avail
);
177 next_decode_page(argp
);
178 memcpy(((char*)p
)+avail
, argp
->p
, (nbytes
- avail
));
179 argp
->p
+= XDR_QUADLEN(nbytes
- avail
);
183 static int zero_clientid(clientid_t
*clid
)
185 return (clid
->cl_boot
== 0) && (clid
->cl_id
== 0);
189 * defer_free - mark an allocation as deferred freed
190 * @argp: NFSv4 compound argument structure to be freed with
191 * @release: release callback to free @p, typically kfree()
192 * @p: pointer to be freed
194 * Marks @p to be freed when processing the compound operation
195 * described in @argp finishes.
198 defer_free(struct nfsd4_compoundargs
*argp
,
199 void (*release
)(const void *), void *p
)
203 tb
= kmalloc(sizeof(*tb
), GFP_KERNEL
);
207 tb
->release
= release
;
208 tb
->next
= argp
->to_free
;
214 * savemem - duplicate a chunk of memory for later processing
215 * @argp: NFSv4 compound argument structure to be freed with
216 * @p: pointer to be duplicated
217 * @nbytes: length to be duplicated
219 * Returns a pointer to a copy of @nbytes bytes of memory at @p
220 * that are preserved until processing of the NFSv4 compound
221 * operation described by @argp finishes.
223 static char *savemem(struct nfsd4_compoundargs
*argp
, __be32
*p
, int nbytes
)
225 if (p
== argp
->tmp
) {
226 p
= kmemdup(argp
->tmp
, nbytes
, GFP_KERNEL
);
230 BUG_ON(p
!= argp
->tmpp
);
233 if (defer_free(argp
, kfree
, p
)) {
241 nfsd4_decode_bitmap(struct nfsd4_compoundargs
*argp
, u32
*bmval
)
255 READ_BUF(bmlen
<< 2);
267 nfsd4_decode_fattr(struct nfsd4_compoundargs
*argp
, u32
*bmval
,
268 struct iattr
*iattr
, struct nfs4_acl
**acl
,
269 struct xdr_netobj
*label
)
271 int expected_len
, len
= 0;
277 if ((status
= nfsd4_decode_bitmap(argp
, bmval
)))
281 READ32(expected_len
);
283 if (bmval
[0] & FATTR4_WORD0_SIZE
) {
286 READ64(iattr
->ia_size
);
287 iattr
->ia_valid
|= ATTR_SIZE
;
289 if (bmval
[0] & FATTR4_WORD0_ACL
) {
291 struct nfs4_ace
*ace
;
293 READ_BUF(4); len
+= 4;
296 if (nace
> NFS4_ACL_MAX
)
299 *acl
= nfs4_acl_new(nace
);
301 return nfserr_jukebox
;
303 defer_free(argp
, kfree
, *acl
);
305 (*acl
)->naces
= nace
;
306 for (ace
= (*acl
)->aces
; ace
< (*acl
)->aces
+ nace
; ace
++) {
307 READ_BUF(16); len
+= 16;
310 READ32(ace
->access_mask
);
313 len
+= XDR_QUADLEN(dummy32
) << 2;
314 READMEM(buf
, dummy32
);
315 ace
->whotype
= nfs4_acl_get_whotype(buf
, dummy32
);
317 if (ace
->whotype
!= NFS4_ACL_WHO_NAMED
)
319 else if (ace
->flag
& NFS4_ACE_IDENTIFIER_GROUP
)
320 status
= nfsd_map_name_to_gid(argp
->rqstp
,
321 buf
, dummy32
, &ace
->who_gid
);
323 status
= nfsd_map_name_to_uid(argp
->rqstp
,
324 buf
, dummy32
, &ace
->who_uid
);
330 if (bmval
[1] & FATTR4_WORD1_MODE
) {
333 READ32(iattr
->ia_mode
);
334 iattr
->ia_mode
&= (S_IFMT
| S_IALLUGO
);
335 iattr
->ia_valid
|= ATTR_MODE
;
337 if (bmval
[1] & FATTR4_WORD1_OWNER
) {
342 len
+= (XDR_QUADLEN(dummy32
) << 2);
343 READMEM(buf
, dummy32
);
344 if ((status
= nfsd_map_name_to_uid(argp
->rqstp
, buf
, dummy32
, &iattr
->ia_uid
)))
346 iattr
->ia_valid
|= ATTR_UID
;
348 if (bmval
[1] & FATTR4_WORD1_OWNER_GROUP
) {
353 len
+= (XDR_QUADLEN(dummy32
) << 2);
354 READMEM(buf
, dummy32
);
355 if ((status
= nfsd_map_name_to_gid(argp
->rqstp
, buf
, dummy32
, &iattr
->ia_gid
)))
357 iattr
->ia_valid
|= ATTR_GID
;
359 if (bmval
[1] & FATTR4_WORD1_TIME_ACCESS_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'. */
369 READ64(iattr
->ia_atime
.tv_sec
);
370 READ32(iattr
->ia_atime
.tv_nsec
);
371 if (iattr
->ia_atime
.tv_nsec
>= (u32
)1000000000)
373 iattr
->ia_valid
|= (ATTR_ATIME
| ATTR_ATIME_SET
);
375 case NFS4_SET_TO_SERVER_TIME
:
376 iattr
->ia_valid
|= ATTR_ATIME
;
382 if (bmval
[1] & FATTR4_WORD1_TIME_MODIFY_SET
) {
387 case NFS4_SET_TO_CLIENT_TIME
:
388 /* We require the high 32 bits of 'seconds' to be 0, and we ignore
389 all 32 bits of 'nseconds'. */
392 READ64(iattr
->ia_mtime
.tv_sec
);
393 READ32(iattr
->ia_mtime
.tv_nsec
);
394 if (iattr
->ia_mtime
.tv_nsec
>= (u32
)1000000000)
396 iattr
->ia_valid
|= (ATTR_MTIME
| ATTR_MTIME_SET
);
398 case NFS4_SET_TO_SERVER_TIME
:
399 iattr
->ia_valid
|= ATTR_MTIME
;
407 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
408 if (bmval
[2] & FATTR4_WORD2_SECURITY_LABEL
) {
411 READ32(dummy32
); /* lfs: we don't use it */
414 READ32(dummy32
); /* pi: we don't use it either */
419 if (dummy32
> NFSD4_MAX_SEC_LABEL_LEN
)
420 return nfserr_badlabel
;
421 len
+= (XDR_QUADLEN(dummy32
) << 2);
422 READMEM(buf
, dummy32
);
423 label
->data
= kzalloc(dummy32
+ 1, GFP_KERNEL
);
425 return nfserr_jukebox
;
426 label
->len
= dummy32
;
427 defer_free(argp
, kfree
, label
->data
);
428 memcpy(label
->data
, buf
, dummy32
);
432 if (bmval
[0] & ~NFSD_WRITEABLE_ATTRS_WORD0
433 || bmval
[1] & ~NFSD_WRITEABLE_ATTRS_WORD1
434 || bmval
[2] & ~NFSD_WRITEABLE_ATTRS_WORD2
)
435 READ_BUF(expected_len
- len
);
436 else if (len
!= expected_len
)
443 nfsd4_decode_stateid(struct nfsd4_compoundargs
*argp
, stateid_t
*sid
)
447 READ_BUF(sizeof(stateid_t
));
448 READ32(sid
->si_generation
);
449 COPYMEM(&sid
->si_opaque
, sizeof(stateid_opaque_t
));
455 nfsd4_decode_access(struct nfsd4_compoundargs
*argp
, struct nfsd4_access
*access
)
460 READ32(access
->ac_req_access
);
465 static __be32
nfsd4_decode_cb_sec(struct nfsd4_compoundargs
*argp
, struct nfsd4_cb_sec
*cbs
)
473 /* callback_sec_params4 */
477 cbs
->flavor
= (u32
)(-1);
479 /* Is this legal? Be generous, take it to mean AUTH_NONE: */
481 for (i
= 0; i
< nr_secflavs
; ++i
) {
486 /* Nothing to read */
487 if (cbs
->flavor
== (u32
)(-1))
488 cbs
->flavor
= RPC_AUTH_NULL
;
498 SAVEMEM(machine_name
, dummy
);
509 if (cbs
->flavor
== (u32
)(-1)) {
510 kuid_t kuid
= make_kuid(&init_user_ns
, uid
);
511 kgid_t kgid
= make_kgid(&init_user_ns
, gid
);
512 if (uid_valid(kuid
) && gid_valid(kgid
)) {
515 cbs
->flavor
= RPC_AUTH_UNIX
;
517 dprintk("RPC_AUTH_UNIX with invalid"
518 "uid or gid ignoring!\n");
523 dprintk("RPC_AUTH_GSS callback secflavor "
528 /* gcbp_handle_from_server */
531 p
+= XDR_QUADLEN(dummy
);
532 /* gcbp_handle_from_client */
538 dprintk("Illegal callback secflavor\n");
545 static __be32
nfsd4_decode_backchannel_ctl(struct nfsd4_compoundargs
*argp
, struct nfsd4_backchannel_ctl
*bc
)
550 READ32(bc
->bc_cb_program
);
551 nfsd4_decode_cb_sec(argp
, &bc
->bc_cb_sec
);
556 static __be32
nfsd4_decode_bind_conn_to_session(struct nfsd4_compoundargs
*argp
, struct nfsd4_bind_conn_to_session
*bcts
)
560 READ_BUF(NFS4_MAX_SESSIONID_LEN
+ 8);
561 COPYMEM(bcts
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
563 /* XXX: skipping ctsa_use_conn_in_rdma_mode. Perhaps Tom Tucker
564 * could help us figure out we should be using it. */
569 nfsd4_decode_close(struct nfsd4_compoundargs
*argp
, struct nfsd4_close
*close
)
574 READ32(close
->cl_seqid
);
575 return nfsd4_decode_stateid(argp
, &close
->cl_stateid
);
582 nfsd4_decode_commit(struct nfsd4_compoundargs
*argp
, struct nfsd4_commit
*commit
)
587 READ64(commit
->co_offset
);
588 READ32(commit
->co_count
);
594 nfsd4_decode_create(struct nfsd4_compoundargs
*argp
, struct nfsd4_create
*create
)
599 READ32(create
->cr_type
);
600 switch (create
->cr_type
) {
603 READ32(create
->cr_linklen
);
604 READ_BUF(create
->cr_linklen
);
605 SAVEMEM(create
->cr_linkname
, create
->cr_linklen
);
610 READ32(create
->cr_specdata1
);
611 READ32(create
->cr_specdata2
);
621 READ32(create
->cr_namelen
);
622 READ_BUF(create
->cr_namelen
);
623 SAVEMEM(create
->cr_name
, create
->cr_namelen
);
624 if ((status
= check_filename(create
->cr_name
, create
->cr_namelen
)))
627 status
= nfsd4_decode_fattr(argp
, create
->cr_bmval
, &create
->cr_iattr
,
628 &create
->cr_acl
, &create
->cr_label
);
636 nfsd4_decode_delegreturn(struct nfsd4_compoundargs
*argp
, struct nfsd4_delegreturn
*dr
)
638 return nfsd4_decode_stateid(argp
, &dr
->dr_stateid
);
642 nfsd4_decode_getattr(struct nfsd4_compoundargs
*argp
, struct nfsd4_getattr
*getattr
)
644 return nfsd4_decode_bitmap(argp
, getattr
->ga_bmval
);
648 nfsd4_decode_link(struct nfsd4_compoundargs
*argp
, struct nfsd4_link
*link
)
653 READ32(link
->li_namelen
);
654 READ_BUF(link
->li_namelen
);
655 SAVEMEM(link
->li_name
, link
->li_namelen
);
656 if ((status
= check_filename(link
->li_name
, link
->li_namelen
)))
663 nfsd4_decode_lock(struct nfsd4_compoundargs
*argp
, struct nfsd4_lock
*lock
)
668 * type, reclaim(boolean), offset, length, new_lock_owner(boolean)
671 READ32(lock
->lk_type
);
672 if ((lock
->lk_type
< NFS4_READ_LT
) || (lock
->lk_type
> NFS4_WRITEW_LT
))
674 READ32(lock
->lk_reclaim
);
675 READ64(lock
->lk_offset
);
676 READ64(lock
->lk_length
);
677 READ32(lock
->lk_is_new
);
679 if (lock
->lk_is_new
) {
681 READ32(lock
->lk_new_open_seqid
);
682 status
= nfsd4_decode_stateid(argp
, &lock
->lk_new_open_stateid
);
685 READ_BUF(8 + sizeof(clientid_t
));
686 READ32(lock
->lk_new_lock_seqid
);
687 COPYMEM(&lock
->lk_new_clientid
, sizeof(clientid_t
));
688 READ32(lock
->lk_new_owner
.len
);
689 READ_BUF(lock
->lk_new_owner
.len
);
690 READMEM(lock
->lk_new_owner
.data
, lock
->lk_new_owner
.len
);
692 status
= nfsd4_decode_stateid(argp
, &lock
->lk_old_lock_stateid
);
696 READ32(lock
->lk_old_lock_seqid
);
703 nfsd4_decode_lockt(struct nfsd4_compoundargs
*argp
, struct nfsd4_lockt
*lockt
)
708 READ32(lockt
->lt_type
);
709 if((lockt
->lt_type
< NFS4_READ_LT
) || (lockt
->lt_type
> NFS4_WRITEW_LT
))
711 READ64(lockt
->lt_offset
);
712 READ64(lockt
->lt_length
);
713 COPYMEM(&lockt
->lt_clientid
, 8);
714 READ32(lockt
->lt_owner
.len
);
715 READ_BUF(lockt
->lt_owner
.len
);
716 READMEM(lockt
->lt_owner
.data
, lockt
->lt_owner
.len
);
722 nfsd4_decode_locku(struct nfsd4_compoundargs
*argp
, struct nfsd4_locku
*locku
)
727 READ32(locku
->lu_type
);
728 if ((locku
->lu_type
< NFS4_READ_LT
) || (locku
->lu_type
> NFS4_WRITEW_LT
))
730 READ32(locku
->lu_seqid
);
731 status
= nfsd4_decode_stateid(argp
, &locku
->lu_stateid
);
735 READ64(locku
->lu_offset
);
736 READ64(locku
->lu_length
);
742 nfsd4_decode_lookup(struct nfsd4_compoundargs
*argp
, struct nfsd4_lookup
*lookup
)
747 READ32(lookup
->lo_len
);
748 READ_BUF(lookup
->lo_len
);
749 SAVEMEM(lookup
->lo_name
, lookup
->lo_len
);
750 if ((status
= check_filename(lookup
->lo_name
, lookup
->lo_len
)))
756 static __be32
nfsd4_decode_share_access(struct nfsd4_compoundargs
*argp
, u32
*share_access
, u32
*deleg_want
, u32
*deleg_when
)
763 *share_access
= w
& NFS4_SHARE_ACCESS_MASK
;
764 *deleg_want
= w
& NFS4_SHARE_WANT_MASK
;
766 *deleg_when
= w
& NFS4_SHARE_WHEN_MASK
;
768 switch (w
& NFS4_SHARE_ACCESS_MASK
) {
769 case NFS4_SHARE_ACCESS_READ
:
770 case NFS4_SHARE_ACCESS_WRITE
:
771 case NFS4_SHARE_ACCESS_BOTH
:
774 return nfserr_bad_xdr
;
776 w
&= ~NFS4_SHARE_ACCESS_MASK
;
779 if (!argp
->minorversion
)
780 return nfserr_bad_xdr
;
781 switch (w
& NFS4_SHARE_WANT_MASK
) {
782 case NFS4_SHARE_WANT_NO_PREFERENCE
:
783 case NFS4_SHARE_WANT_READ_DELEG
:
784 case NFS4_SHARE_WANT_WRITE_DELEG
:
785 case NFS4_SHARE_WANT_ANY_DELEG
:
786 case NFS4_SHARE_WANT_NO_DELEG
:
787 case NFS4_SHARE_WANT_CANCEL
:
790 return nfserr_bad_xdr
;
792 w
&= ~NFS4_SHARE_WANT_MASK
;
796 if (!deleg_when
) /* open_downgrade */
799 case NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL
:
800 case NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED
:
801 case (NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL
|
802 NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED
):
806 return nfserr_bad_xdr
;
809 static __be32
nfsd4_decode_share_deny(struct nfsd4_compoundargs
*argp
, u32
*x
)
815 /* Note: unlinke access bits, deny bits may be zero. */
816 if (*x
& ~NFS4_SHARE_DENY_BOTH
)
817 return nfserr_bad_xdr
;
820 return nfserr_bad_xdr
;
823 static __be32
nfsd4_decode_opaque(struct nfsd4_compoundargs
*argp
, struct xdr_netobj
*o
)
830 if (o
->len
== 0 || o
->len
> NFS4_OPAQUE_LIMIT
)
831 return nfserr_bad_xdr
;
834 SAVEMEM(o
->data
, o
->len
);
837 return nfserr_bad_xdr
;
841 nfsd4_decode_open(struct nfsd4_compoundargs
*argp
, struct nfsd4_open
*open
)
846 memset(open
->op_bmval
, 0, sizeof(open
->op_bmval
));
847 open
->op_iattr
.ia_valid
= 0;
848 open
->op_openowner
= NULL
;
850 open
->op_xdr_error
= 0;
851 /* seqid, share_access, share_deny, clientid, ownerlen */
853 READ32(open
->op_seqid
);
854 /* decode, yet ignore deleg_when until supported */
855 status
= nfsd4_decode_share_access(argp
, &open
->op_share_access
,
856 &open
->op_deleg_want
, &dummy
);
859 status
= nfsd4_decode_share_deny(argp
, &open
->op_share_deny
);
862 READ_BUF(sizeof(clientid_t
));
863 COPYMEM(&open
->op_clientid
, sizeof(clientid_t
));
864 status
= nfsd4_decode_opaque(argp
, &open
->op_owner
);
868 READ32(open
->op_create
);
869 switch (open
->op_create
) {
870 case NFS4_OPEN_NOCREATE
:
872 case NFS4_OPEN_CREATE
:
874 READ32(open
->op_createmode
);
875 switch (open
->op_createmode
) {
876 case NFS4_CREATE_UNCHECKED
:
877 case NFS4_CREATE_GUARDED
:
878 status
= nfsd4_decode_fattr(argp
, open
->op_bmval
,
879 &open
->op_iattr
, &open
->op_acl
, &open
->op_label
);
883 case NFS4_CREATE_EXCLUSIVE
:
884 READ_BUF(NFS4_VERIFIER_SIZE
);
885 COPYMEM(open
->op_verf
.data
, NFS4_VERIFIER_SIZE
);
887 case NFS4_CREATE_EXCLUSIVE4_1
:
888 if (argp
->minorversion
< 1)
890 READ_BUF(NFS4_VERIFIER_SIZE
);
891 COPYMEM(open
->op_verf
.data
, NFS4_VERIFIER_SIZE
);
892 status
= nfsd4_decode_fattr(argp
, open
->op_bmval
,
893 &open
->op_iattr
, &open
->op_acl
, &open
->op_label
);
907 READ32(open
->op_claim_type
);
908 switch (open
->op_claim_type
) {
909 case NFS4_OPEN_CLAIM_NULL
:
910 case NFS4_OPEN_CLAIM_DELEGATE_PREV
:
912 READ32(open
->op_fname
.len
);
913 READ_BUF(open
->op_fname
.len
);
914 SAVEMEM(open
->op_fname
.data
, open
->op_fname
.len
);
915 if ((status
= check_filename(open
->op_fname
.data
, open
->op_fname
.len
)))
918 case NFS4_OPEN_CLAIM_PREVIOUS
:
920 READ32(open
->op_delegate_type
);
922 case NFS4_OPEN_CLAIM_DELEGATE_CUR
:
923 status
= nfsd4_decode_stateid(argp
, &open
->op_delegate_stateid
);
927 READ32(open
->op_fname
.len
);
928 READ_BUF(open
->op_fname
.len
);
929 SAVEMEM(open
->op_fname
.data
, open
->op_fname
.len
);
930 if ((status
= check_filename(open
->op_fname
.data
, open
->op_fname
.len
)))
933 case NFS4_OPEN_CLAIM_FH
:
934 case NFS4_OPEN_CLAIM_DELEG_PREV_FH
:
935 if (argp
->minorversion
< 1)
939 case NFS4_OPEN_CLAIM_DELEG_CUR_FH
:
940 if (argp
->minorversion
< 1)
942 status
= nfsd4_decode_stateid(argp
, &open
->op_delegate_stateid
);
954 nfsd4_decode_open_confirm(struct nfsd4_compoundargs
*argp
, struct nfsd4_open_confirm
*open_conf
)
958 if (argp
->minorversion
>= 1)
959 return nfserr_notsupp
;
961 status
= nfsd4_decode_stateid(argp
, &open_conf
->oc_req_stateid
);
965 READ32(open_conf
->oc_seqid
);
971 nfsd4_decode_open_downgrade(struct nfsd4_compoundargs
*argp
, struct nfsd4_open_downgrade
*open_down
)
975 status
= nfsd4_decode_stateid(argp
, &open_down
->od_stateid
);
979 READ32(open_down
->od_seqid
);
980 status
= nfsd4_decode_share_access(argp
, &open_down
->od_share_access
,
981 &open_down
->od_deleg_want
, NULL
);
984 status
= nfsd4_decode_share_deny(argp
, &open_down
->od_share_deny
);
991 nfsd4_decode_putfh(struct nfsd4_compoundargs
*argp
, struct nfsd4_putfh
*putfh
)
996 READ32(putfh
->pf_fhlen
);
997 if (putfh
->pf_fhlen
> NFS4_FHSIZE
)
999 READ_BUF(putfh
->pf_fhlen
);
1000 SAVEMEM(putfh
->pf_fhval
, putfh
->pf_fhlen
);
1006 nfsd4_decode_putpubfh(struct nfsd4_compoundargs
*argp
, void *p
)
1008 if (argp
->minorversion
== 0)
1010 return nfserr_notsupp
;
1014 nfsd4_decode_read(struct nfsd4_compoundargs
*argp
, struct nfsd4_read
*read
)
1018 status
= nfsd4_decode_stateid(argp
, &read
->rd_stateid
);
1022 READ64(read
->rd_offset
);
1023 READ32(read
->rd_length
);
1029 nfsd4_decode_readdir(struct nfsd4_compoundargs
*argp
, struct nfsd4_readdir
*readdir
)
1034 READ64(readdir
->rd_cookie
);
1035 COPYMEM(readdir
->rd_verf
.data
, sizeof(readdir
->rd_verf
.data
));
1036 READ32(readdir
->rd_dircount
); /* just in case you needed a useless field... */
1037 READ32(readdir
->rd_maxcount
);
1038 if ((status
= nfsd4_decode_bitmap(argp
, readdir
->rd_bmval
)))
1045 nfsd4_decode_remove(struct nfsd4_compoundargs
*argp
, struct nfsd4_remove
*remove
)
1050 READ32(remove
->rm_namelen
);
1051 READ_BUF(remove
->rm_namelen
);
1052 SAVEMEM(remove
->rm_name
, remove
->rm_namelen
);
1053 if ((status
= check_filename(remove
->rm_name
, remove
->rm_namelen
)))
1060 nfsd4_decode_rename(struct nfsd4_compoundargs
*argp
, struct nfsd4_rename
*rename
)
1065 READ32(rename
->rn_snamelen
);
1066 READ_BUF(rename
->rn_snamelen
+ 4);
1067 SAVEMEM(rename
->rn_sname
, rename
->rn_snamelen
);
1068 READ32(rename
->rn_tnamelen
);
1069 READ_BUF(rename
->rn_tnamelen
);
1070 SAVEMEM(rename
->rn_tname
, rename
->rn_tnamelen
);
1071 if ((status
= check_filename(rename
->rn_sname
, rename
->rn_snamelen
)))
1073 if ((status
= check_filename(rename
->rn_tname
, rename
->rn_tnamelen
)))
1080 nfsd4_decode_renew(struct nfsd4_compoundargs
*argp
, clientid_t
*clientid
)
1084 if (argp
->minorversion
>= 1)
1085 return nfserr_notsupp
;
1087 READ_BUF(sizeof(clientid_t
));
1088 COPYMEM(clientid
, sizeof(clientid_t
));
1094 nfsd4_decode_secinfo(struct nfsd4_compoundargs
*argp
,
1095 struct nfsd4_secinfo
*secinfo
)
1100 READ32(secinfo
->si_namelen
);
1101 READ_BUF(secinfo
->si_namelen
);
1102 SAVEMEM(secinfo
->si_name
, secinfo
->si_namelen
);
1103 status
= check_filename(secinfo
->si_name
, secinfo
->si_namelen
);
1110 nfsd4_decode_secinfo_no_name(struct nfsd4_compoundargs
*argp
,
1111 struct nfsd4_secinfo_no_name
*sin
)
1116 READ32(sin
->sin_style
);
1121 nfsd4_decode_setattr(struct nfsd4_compoundargs
*argp
, struct nfsd4_setattr
*setattr
)
1125 status
= nfsd4_decode_stateid(argp
, &setattr
->sa_stateid
);
1128 return nfsd4_decode_fattr(argp
, setattr
->sa_bmval
, &setattr
->sa_iattr
,
1129 &setattr
->sa_acl
, &setattr
->sa_label
);
1133 nfsd4_decode_setclientid(struct nfsd4_compoundargs
*argp
, struct nfsd4_setclientid
*setclientid
)
1137 if (argp
->minorversion
>= 1)
1138 return nfserr_notsupp
;
1140 READ_BUF(NFS4_VERIFIER_SIZE
);
1141 COPYMEM(setclientid
->se_verf
.data
, NFS4_VERIFIER_SIZE
);
1143 status
= nfsd4_decode_opaque(argp
, &setclientid
->se_name
);
1145 return nfserr_bad_xdr
;
1147 READ32(setclientid
->se_callback_prog
);
1148 READ32(setclientid
->se_callback_netid_len
);
1150 READ_BUF(setclientid
->se_callback_netid_len
+ 4);
1151 SAVEMEM(setclientid
->se_callback_netid_val
, setclientid
->se_callback_netid_len
);
1152 READ32(setclientid
->se_callback_addr_len
);
1154 READ_BUF(setclientid
->se_callback_addr_len
+ 4);
1155 SAVEMEM(setclientid
->se_callback_addr_val
, setclientid
->se_callback_addr_len
);
1156 READ32(setclientid
->se_callback_ident
);
1162 nfsd4_decode_setclientid_confirm(struct nfsd4_compoundargs
*argp
, struct nfsd4_setclientid_confirm
*scd_c
)
1166 if (argp
->minorversion
>= 1)
1167 return nfserr_notsupp
;
1169 READ_BUF(8 + NFS4_VERIFIER_SIZE
);
1170 COPYMEM(&scd_c
->sc_clientid
, 8);
1171 COPYMEM(&scd_c
->sc_confirm
, NFS4_VERIFIER_SIZE
);
1176 /* Also used for NVERIFY */
1178 nfsd4_decode_verify(struct nfsd4_compoundargs
*argp
, struct nfsd4_verify
*verify
)
1182 if ((status
= nfsd4_decode_bitmap(argp
, verify
->ve_bmval
)))
1185 /* For convenience's sake, we compare raw xdr'd attributes in
1186 * nfsd4_proc_verify */
1189 READ32(verify
->ve_attrlen
);
1190 READ_BUF(verify
->ve_attrlen
);
1191 SAVEMEM(verify
->ve_attrval
, verify
->ve_attrlen
);
1197 nfsd4_decode_write(struct nfsd4_compoundargs
*argp
, struct nfsd4_write
*write
)
1203 status
= nfsd4_decode_stateid(argp
, &write
->wr_stateid
);
1207 READ64(write
->wr_offset
);
1208 READ32(write
->wr_stable_how
);
1209 if (write
->wr_stable_how
> 2)
1211 READ32(write
->wr_buflen
);
1213 /* Sorry .. no magic macros for this.. *
1214 * READ_BUF(write->wr_buflen);
1215 * SAVEMEM(write->wr_buf, write->wr_buflen);
1217 avail
= (char*)argp
->end
- (char*)argp
->p
;
1218 if (avail
+ argp
->pagelen
< write
->wr_buflen
) {
1219 dprintk("NFSD: xdr error (%s:%d)\n",
1220 __FILE__
, __LINE__
);
1223 write
->wr_head
.iov_base
= p
;
1224 write
->wr_head
.iov_len
= avail
;
1225 write
->wr_pagelist
= argp
->pagelist
;
1227 len
= XDR_QUADLEN(write
->wr_buflen
) << 2;
1233 pages
= len
>> PAGE_SHIFT
;
1234 argp
->pagelist
+= pages
;
1235 argp
->pagelen
-= pages
* PAGE_SIZE
;
1236 len
-= pages
* PAGE_SIZE
;
1238 argp
->p
= (__be32
*)page_address(argp
->pagelist
[0]);
1240 argp
->end
= argp
->p
+ XDR_QUADLEN(PAGE_SIZE
);
1242 argp
->p
+= XDR_QUADLEN(len
);
1248 nfsd4_decode_release_lockowner(struct nfsd4_compoundargs
*argp
, struct nfsd4_release_lockowner
*rlockowner
)
1252 if (argp
->minorversion
>= 1)
1253 return nfserr_notsupp
;
1256 COPYMEM(&rlockowner
->rl_clientid
, sizeof(clientid_t
));
1257 READ32(rlockowner
->rl_owner
.len
);
1258 READ_BUF(rlockowner
->rl_owner
.len
);
1259 READMEM(rlockowner
->rl_owner
.data
, rlockowner
->rl_owner
.len
);
1261 if (argp
->minorversion
&& !zero_clientid(&rlockowner
->rl_clientid
))
1262 return nfserr_inval
;
1267 nfsd4_decode_exchange_id(struct nfsd4_compoundargs
*argp
,
1268 struct nfsd4_exchange_id
*exid
)
1273 READ_BUF(NFS4_VERIFIER_SIZE
);
1274 COPYMEM(exid
->verifier
.data
, NFS4_VERIFIER_SIZE
);
1276 status
= nfsd4_decode_opaque(argp
, &exid
->clname
);
1278 return nfserr_bad_xdr
;
1281 READ32(exid
->flags
);
1283 /* Ignore state_protect4_a */
1285 READ32(exid
->spa_how
);
1286 switch (exid
->spa_how
) {
1290 /* spo_must_enforce */
1293 READ_BUF(dummy
* 4);
1296 /* spo_must_allow */
1299 READ_BUF(dummy
* 4);
1306 READ_BUF(dummy
* 4);
1311 READ_BUF(dummy
* 4);
1314 /* ssp_hash_algs<> */
1321 p
+= XDR_QUADLEN(dummy
);
1324 /* ssp_encr_algs<> */
1331 p
+= XDR_QUADLEN(dummy
);
1334 /* ssp_window and ssp_num_gss_handles */
1343 /* Ignore Implementation ID */
1344 READ_BUF(4); /* nfs_impl_id4 array length */
1355 p
+= XDR_QUADLEN(dummy
);
1361 p
+= XDR_QUADLEN(dummy
);
1371 nfsd4_decode_create_session(struct nfsd4_compoundargs
*argp
,
1372 struct nfsd4_create_session
*sess
)
1378 COPYMEM(&sess
->clientid
, 8);
1379 READ32(sess
->seqid
);
1380 READ32(sess
->flags
);
1382 /* Fore channel attrs */
1384 READ32(dummy
); /* headerpadsz is always 0 */
1385 READ32(sess
->fore_channel
.maxreq_sz
);
1386 READ32(sess
->fore_channel
.maxresp_sz
);
1387 READ32(sess
->fore_channel
.maxresp_cached
);
1388 READ32(sess
->fore_channel
.maxops
);
1389 READ32(sess
->fore_channel
.maxreqs
);
1390 READ32(sess
->fore_channel
.nr_rdma_attrs
);
1391 if (sess
->fore_channel
.nr_rdma_attrs
== 1) {
1393 READ32(sess
->fore_channel
.rdma_attrs
);
1394 } else if (sess
->fore_channel
.nr_rdma_attrs
> 1) {
1395 dprintk("Too many fore channel attr bitmaps!\n");
1399 /* Back channel attrs */
1401 READ32(dummy
); /* headerpadsz is always 0 */
1402 READ32(sess
->back_channel
.maxreq_sz
);
1403 READ32(sess
->back_channel
.maxresp_sz
);
1404 READ32(sess
->back_channel
.maxresp_cached
);
1405 READ32(sess
->back_channel
.maxops
);
1406 READ32(sess
->back_channel
.maxreqs
);
1407 READ32(sess
->back_channel
.nr_rdma_attrs
);
1408 if (sess
->back_channel
.nr_rdma_attrs
== 1) {
1410 READ32(sess
->back_channel
.rdma_attrs
);
1411 } else if (sess
->back_channel
.nr_rdma_attrs
> 1) {
1412 dprintk("Too many back channel attr bitmaps!\n");
1417 READ32(sess
->callback_prog
);
1418 nfsd4_decode_cb_sec(argp
, &sess
->cb_sec
);
1423 nfsd4_decode_destroy_session(struct nfsd4_compoundargs
*argp
,
1424 struct nfsd4_destroy_session
*destroy_session
)
1427 READ_BUF(NFS4_MAX_SESSIONID_LEN
);
1428 COPYMEM(destroy_session
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
1434 nfsd4_decode_free_stateid(struct nfsd4_compoundargs
*argp
,
1435 struct nfsd4_free_stateid
*free_stateid
)
1439 READ_BUF(sizeof(stateid_t
));
1440 READ32(free_stateid
->fr_stateid
.si_generation
);
1441 COPYMEM(&free_stateid
->fr_stateid
.si_opaque
, sizeof(stateid_opaque_t
));
1447 nfsd4_decode_sequence(struct nfsd4_compoundargs
*argp
,
1448 struct nfsd4_sequence
*seq
)
1452 READ_BUF(NFS4_MAX_SESSIONID_LEN
+ 16);
1453 COPYMEM(seq
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
1455 READ32(seq
->slotid
);
1456 READ32(seq
->maxslots
);
1457 READ32(seq
->cachethis
);
1463 nfsd4_decode_test_stateid(struct nfsd4_compoundargs
*argp
, struct nfsd4_test_stateid
*test_stateid
)
1467 struct nfsd4_test_stateid_id
*stateid
;
1470 test_stateid
->ts_num_ids
= ntohl(*p
++);
1472 INIT_LIST_HEAD(&test_stateid
->ts_stateid_list
);
1474 for (i
= 0; i
< test_stateid
->ts_num_ids
; i
++) {
1475 stateid
= kmalloc(sizeof(struct nfsd4_test_stateid_id
), GFP_KERNEL
);
1477 status
= nfserrno(-ENOMEM
);
1481 defer_free(argp
, kfree
, stateid
);
1482 INIT_LIST_HEAD(&stateid
->ts_id_list
);
1483 list_add_tail(&stateid
->ts_id_list
, &test_stateid
->ts_stateid_list
);
1485 status
= nfsd4_decode_stateid(argp
, &stateid
->ts_id_stateid
);
1494 dprintk("NFSD: xdr error (%s:%d)\n", __FILE__
, __LINE__
);
1495 status
= nfserr_bad_xdr
;
1499 static __be32
nfsd4_decode_destroy_clientid(struct nfsd4_compoundargs
*argp
, struct nfsd4_destroy_clientid
*dc
)
1504 COPYMEM(&dc
->clientid
, 8);
1509 static __be32
nfsd4_decode_reclaim_complete(struct nfsd4_compoundargs
*argp
, struct nfsd4_reclaim_complete
*rc
)
1514 READ32(rc
->rca_one_fs
);
1520 nfsd4_decode_noop(struct nfsd4_compoundargs
*argp
, void *p
)
1526 nfsd4_decode_notsupp(struct nfsd4_compoundargs
*argp
, void *p
)
1528 return nfserr_notsupp
;
1531 typedef __be32(*nfsd4_dec
)(struct nfsd4_compoundargs
*argp
, void *);
1533 static nfsd4_dec nfsd4_dec_ops
[] = {
1534 [OP_ACCESS
] = (nfsd4_dec
)nfsd4_decode_access
,
1535 [OP_CLOSE
] = (nfsd4_dec
)nfsd4_decode_close
,
1536 [OP_COMMIT
] = (nfsd4_dec
)nfsd4_decode_commit
,
1537 [OP_CREATE
] = (nfsd4_dec
)nfsd4_decode_create
,
1538 [OP_DELEGPURGE
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1539 [OP_DELEGRETURN
] = (nfsd4_dec
)nfsd4_decode_delegreturn
,
1540 [OP_GETATTR
] = (nfsd4_dec
)nfsd4_decode_getattr
,
1541 [OP_GETFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1542 [OP_LINK
] = (nfsd4_dec
)nfsd4_decode_link
,
1543 [OP_LOCK
] = (nfsd4_dec
)nfsd4_decode_lock
,
1544 [OP_LOCKT
] = (nfsd4_dec
)nfsd4_decode_lockt
,
1545 [OP_LOCKU
] = (nfsd4_dec
)nfsd4_decode_locku
,
1546 [OP_LOOKUP
] = (nfsd4_dec
)nfsd4_decode_lookup
,
1547 [OP_LOOKUPP
] = (nfsd4_dec
)nfsd4_decode_noop
,
1548 [OP_NVERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
1549 [OP_OPEN
] = (nfsd4_dec
)nfsd4_decode_open
,
1550 [OP_OPENATTR
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1551 [OP_OPEN_CONFIRM
] = (nfsd4_dec
)nfsd4_decode_open_confirm
,
1552 [OP_OPEN_DOWNGRADE
] = (nfsd4_dec
)nfsd4_decode_open_downgrade
,
1553 [OP_PUTFH
] = (nfsd4_dec
)nfsd4_decode_putfh
,
1554 [OP_PUTPUBFH
] = (nfsd4_dec
)nfsd4_decode_putpubfh
,
1555 [OP_PUTROOTFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1556 [OP_READ
] = (nfsd4_dec
)nfsd4_decode_read
,
1557 [OP_READDIR
] = (nfsd4_dec
)nfsd4_decode_readdir
,
1558 [OP_READLINK
] = (nfsd4_dec
)nfsd4_decode_noop
,
1559 [OP_REMOVE
] = (nfsd4_dec
)nfsd4_decode_remove
,
1560 [OP_RENAME
] = (nfsd4_dec
)nfsd4_decode_rename
,
1561 [OP_RENEW
] = (nfsd4_dec
)nfsd4_decode_renew
,
1562 [OP_RESTOREFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1563 [OP_SAVEFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1564 [OP_SECINFO
] = (nfsd4_dec
)nfsd4_decode_secinfo
,
1565 [OP_SETATTR
] = (nfsd4_dec
)nfsd4_decode_setattr
,
1566 [OP_SETCLIENTID
] = (nfsd4_dec
)nfsd4_decode_setclientid
,
1567 [OP_SETCLIENTID_CONFIRM
] = (nfsd4_dec
)nfsd4_decode_setclientid_confirm
,
1568 [OP_VERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
1569 [OP_WRITE
] = (nfsd4_dec
)nfsd4_decode_write
,
1570 [OP_RELEASE_LOCKOWNER
] = (nfsd4_dec
)nfsd4_decode_release_lockowner
,
1572 /* new operations for NFSv4.1 */
1573 [OP_BACKCHANNEL_CTL
] = (nfsd4_dec
)nfsd4_decode_backchannel_ctl
,
1574 [OP_BIND_CONN_TO_SESSION
]= (nfsd4_dec
)nfsd4_decode_bind_conn_to_session
,
1575 [OP_EXCHANGE_ID
] = (nfsd4_dec
)nfsd4_decode_exchange_id
,
1576 [OP_CREATE_SESSION
] = (nfsd4_dec
)nfsd4_decode_create_session
,
1577 [OP_DESTROY_SESSION
] = (nfsd4_dec
)nfsd4_decode_destroy_session
,
1578 [OP_FREE_STATEID
] = (nfsd4_dec
)nfsd4_decode_free_stateid
,
1579 [OP_GET_DIR_DELEGATION
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1580 [OP_GETDEVICEINFO
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1581 [OP_GETDEVICELIST
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1582 [OP_LAYOUTCOMMIT
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1583 [OP_LAYOUTGET
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1584 [OP_LAYOUTRETURN
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1585 [OP_SECINFO_NO_NAME
] = (nfsd4_dec
)nfsd4_decode_secinfo_no_name
,
1586 [OP_SEQUENCE
] = (nfsd4_dec
)nfsd4_decode_sequence
,
1587 [OP_SET_SSV
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1588 [OP_TEST_STATEID
] = (nfsd4_dec
)nfsd4_decode_test_stateid
,
1589 [OP_WANT_DELEGATION
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1590 [OP_DESTROY_CLIENTID
] = (nfsd4_dec
)nfsd4_decode_destroy_clientid
,
1591 [OP_RECLAIM_COMPLETE
] = (nfsd4_dec
)nfsd4_decode_reclaim_complete
,
1595 nfsd4_opnum_in_range(struct nfsd4_compoundargs
*argp
, struct nfsd4_op
*op
)
1597 if (op
->opnum
< FIRST_NFS4_OP
)
1599 else if (argp
->minorversion
== 0 && op
->opnum
> LAST_NFS40_OP
)
1601 else if (argp
->minorversion
== 1 && op
->opnum
> LAST_NFS41_OP
)
1603 else if (argp
->minorversion
== 2 && op
->opnum
> LAST_NFS42_OP
)
1609 * Return a rough estimate of the maximum possible reply size. Note the
1610 * estimate includes rpc headers so is meant to be passed to
1611 * svc_reserve, not svc_reserve_auth.
1613 * Also note the current compound encoding permits only one operation to
1614 * use pages beyond the first one, so the maximum possible length is the
1615 * maximum over these values, not the sum.
1617 static int nfsd4_max_reply(u32 opnum
)
1623 * Both of these ops take a single page for data and put
1624 * the head and tail in another page:
1626 return 2 * PAGE_SIZE
;
1635 nfsd4_decode_compound(struct nfsd4_compoundargs
*argp
)
1638 struct nfsd4_op
*op
;
1639 bool cachethis
= false;
1640 int max_reply
= PAGE_SIZE
;
1644 READ32(argp
->taglen
);
1645 READ_BUF(argp
->taglen
+ 8);
1646 SAVEMEM(argp
->tag
, argp
->taglen
);
1647 READ32(argp
->minorversion
);
1648 READ32(argp
->opcnt
);
1650 if (argp
->taglen
> NFSD4_MAX_TAGLEN
)
1652 if (argp
->opcnt
> 100)
1655 if (argp
->opcnt
> ARRAY_SIZE(argp
->iops
)) {
1656 argp
->ops
= kmalloc(argp
->opcnt
* sizeof(*argp
->ops
), GFP_KERNEL
);
1658 argp
->ops
= argp
->iops
;
1659 dprintk("nfsd: couldn't allocate room for COMPOUND\n");
1664 if (argp
->minorversion
> NFSD_SUPPORTED_MINOR_VERSION
)
1667 for (i
= 0; i
< argp
->opcnt
; i
++) {
1674 if (nfsd4_opnum_in_range(argp
, op
))
1675 op
->status
= nfsd4_dec_ops
[op
->opnum
](argp
, &op
->u
);
1677 op
->opnum
= OP_ILLEGAL
;
1678 op
->status
= nfserr_op_illegal
;
1681 * We'll try to cache the result in the DRC if any one
1682 * op in the compound wants to be cached:
1684 cachethis
|= nfsd4_cache_this_op(op
);
1686 max_reply
= max(max_reply
, nfsd4_max_reply(op
->opnum
));
1693 /* Sessions make the DRC unnecessary: */
1694 if (argp
->minorversion
)
1696 if (max_reply
!= INT_MAX
)
1697 svc_reserve(argp
->rqstp
, max_reply
);
1698 argp
->rqstp
->rq_cachetype
= cachethis
? RC_REPLBUFF
: RC_NOCACHE
;
1703 #define WRITE32(n) *p++ = htonl(n)
1704 #define WRITE64(n) do { \
1705 *p++ = htonl((u32)((n) >> 32)); \
1706 *p++ = htonl((u32)(n)); \
1708 #define WRITEMEM(ptr,nbytes) do { if (nbytes > 0) { \
1709 *(p + XDR_QUADLEN(nbytes) -1) = 0; \
1710 memcpy(p, ptr, nbytes); \
1711 p += XDR_QUADLEN(nbytes); \
1714 static void write32(__be32
**p
, u32 n
)
1719 static void write64(__be32
**p
, u64 n
)
1721 write32(p
, (n
>> 32));
1725 static void write_change(__be32
**p
, struct kstat
*stat
, struct inode
*inode
)
1727 if (IS_I_VERSION(inode
)) {
1728 write64(p
, inode
->i_version
);
1730 write32(p
, stat
->ctime
.tv_sec
);
1731 write32(p
, stat
->ctime
.tv_nsec
);
1735 static void write_cinfo(__be32
**p
, struct nfsd4_change_info
*c
)
1737 write32(p
, c
->atomic
);
1738 if (c
->change_supported
) {
1739 write64(p
, c
->before_change
);
1740 write64(p
, c
->after_change
);
1742 write32(p
, c
->before_ctime_sec
);
1743 write32(p
, c
->before_ctime_nsec
);
1744 write32(p
, c
->after_ctime_sec
);
1745 write32(p
, c
->after_ctime_nsec
);
1749 /* Encode as an array of strings the string given with components
1750 * separated @sep, escaped with esc_enter and esc_exit.
1752 static __be32
nfsd4_encode_components_esc(struct xdr_stream
*xdr
, char sep
,
1753 char *components
, char esc_enter
,
1759 int strlen
, count
=0;
1760 char *str
, *end
, *next
;
1762 dprintk("nfsd4_encode_components(%s)\n", components
);
1764 pathlen_offset
= xdr
->buf
->len
;
1765 p
= xdr_reserve_space(xdr
, 4);
1767 return nfserr_resource
;
1768 p
++; /* We will fill this in with @count later */
1770 end
= str
= components
;
1772 bool found_esc
= false;
1774 /* try to parse as esc_start, ..., esc_end, sep */
1775 if (*str
== esc_enter
) {
1776 for (; *end
&& (*end
!= esc_exit
); end
++)
1777 /* find esc_exit or end of string */;
1779 if (*end
&& (!*next
|| *next
== sep
)) {
1786 for (; *end
&& (*end
!= sep
); end
++)
1787 /* find sep or end of string */;
1791 p
= xdr_reserve_space(xdr
, strlen
+ 4);
1793 return nfserr_resource
;
1795 WRITEMEM(str
, strlen
);
1802 pathlen
= htonl(xdr
->buf
->len
- pathlen_offset
);
1803 write_bytes_to_xdr_buf(xdr
->buf
, pathlen_offset
, &pathlen
, 4);
1807 /* Encode as an array of strings the string given with components
1810 static __be32
nfsd4_encode_components(struct xdr_stream
*xdr
, char sep
,
1813 return nfsd4_encode_components_esc(xdr
, sep
, components
, 0, 0);
1817 * encode a location element of a fs_locations structure
1819 static __be32
nfsd4_encode_fs_location4(struct xdr_stream
*xdr
,
1820 struct nfsd4_fs_location
*location
)
1824 status
= nfsd4_encode_components_esc(xdr
, ':', location
->hosts
,
1828 status
= nfsd4_encode_components(xdr
, '/', location
->path
);
1835 * Encode a path in RFC3530 'pathname4' format
1837 static __be32
nfsd4_encode_path(struct xdr_stream
*xdr
,
1838 const struct path
*root
,
1839 const struct path
*path
)
1841 struct path cur
= *path
;
1843 struct dentry
**components
= NULL
;
1844 unsigned int ncomponents
= 0;
1845 __be32 err
= nfserr_jukebox
;
1847 dprintk("nfsd4_encode_components(");
1850 /* First walk the path up to the nfsd root, and store the
1851 * dentries/path components in an array.
1854 if (cur
.dentry
== root
->dentry
&& cur
.mnt
== root
->mnt
)
1856 if (cur
.dentry
== cur
.mnt
->mnt_root
) {
1857 if (follow_up(&cur
))
1861 if ((ncomponents
& 15) == 0) {
1862 struct dentry
**new;
1863 new = krealloc(components
,
1864 sizeof(*new) * (ncomponents
+ 16),
1870 components
[ncomponents
++] = cur
.dentry
;
1871 cur
.dentry
= dget_parent(cur
.dentry
);
1873 err
= nfserr_resource
;
1874 p
= xdr_reserve_space(xdr
, 4);
1877 WRITE32(ncomponents
);
1879 while (ncomponents
) {
1880 struct dentry
*dentry
= components
[ncomponents
- 1];
1883 spin_lock(&dentry
->d_lock
);
1884 len
= dentry
->d_name
.len
;
1885 p
= xdr_reserve_space(xdr
, len
+ 4);
1887 spin_unlock(&dentry
->d_lock
);
1891 WRITEMEM(dentry
->d_name
.name
, len
);
1892 dprintk("/%s", dentry
->d_name
.name
);
1893 spin_unlock(&dentry
->d_lock
);
1902 dput(components
[--ncomponents
]);
1908 static __be32
nfsd4_encode_fsloc_fsroot(struct xdr_stream
*xdr
,
1909 struct svc_rqst
*rqstp
, const struct path
*path
)
1911 struct svc_export
*exp_ps
;
1914 exp_ps
= rqst_find_fsidzero_export(rqstp
);
1916 return nfserrno(PTR_ERR(exp_ps
));
1917 res
= nfsd4_encode_path(xdr
, &exp_ps
->ex_path
, path
);
1923 * encode a fs_locations structure
1925 static __be32
nfsd4_encode_fs_locations(struct xdr_stream
*xdr
,
1926 struct svc_rqst
*rqstp
, struct svc_export
*exp
)
1931 struct nfsd4_fs_locations
*fslocs
= &exp
->ex_fslocs
;
1933 status
= nfsd4_encode_fsloc_fsroot(xdr
, rqstp
, &exp
->ex_path
);
1936 p
= xdr_reserve_space(xdr
, 4);
1938 return nfserr_resource
;
1939 WRITE32(fslocs
->locations_count
);
1940 for (i
=0; i
<fslocs
->locations_count
; i
++) {
1941 status
= nfsd4_encode_fs_location4(xdr
, &fslocs
->locations
[i
]);
1948 static u32
nfs4_file_type(umode_t mode
)
1950 switch (mode
& S_IFMT
) {
1951 case S_IFIFO
: return NF4FIFO
;
1952 case S_IFCHR
: return NF4CHR
;
1953 case S_IFDIR
: return NF4DIR
;
1954 case S_IFBLK
: return NF4BLK
;
1955 case S_IFLNK
: return NF4LNK
;
1956 case S_IFREG
: return NF4REG
;
1957 case S_IFSOCK
: return NF4SOCK
;
1958 default: return NF4BAD
;
1962 static inline __be32
1963 nfsd4_encode_aclname(struct xdr_stream
*xdr
, struct svc_rqst
*rqstp
,
1964 struct nfs4_ace
*ace
)
1966 if (ace
->whotype
!= NFS4_ACL_WHO_NAMED
)
1967 return nfs4_acl_write_who(xdr
, ace
->whotype
);
1968 else if (ace
->flag
& NFS4_ACE_IDENTIFIER_GROUP
)
1969 return nfsd4_encode_group(xdr
, rqstp
, ace
->who_gid
);
1971 return nfsd4_encode_user(xdr
, rqstp
, ace
->who_uid
);
1974 #define WORD0_ABSENT_FS_ATTRS (FATTR4_WORD0_FS_LOCATIONS | FATTR4_WORD0_FSID | \
1975 FATTR4_WORD0_RDATTR_ERROR)
1976 #define WORD1_ABSENT_FS_ATTRS FATTR4_WORD1_MOUNTED_ON_FILEID
1978 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
1979 static inline __be32
1980 nfsd4_encode_security_label(struct xdr_stream
*xdr
, struct svc_rqst
*rqstp
,
1981 void *context
, int len
)
1985 p
= xdr_reserve_space(xdr
, len
+ 4 + 4 + 4);
1987 return nfserr_resource
;
1990 * For now we use a 0 here to indicate the null translation; in
1991 * the future we may place a call to translation code here.
1993 WRITE32(0); /* lfs */
1994 WRITE32(0); /* pi */
1995 p
= xdr_encode_opaque(p
, context
, len
);
1999 static inline __be32
2000 nfsd4_encode_security_label(struct xdr_stream
*xdr
, struct svc_rqst
*rqstp
,
2001 void *context
, int len
)
2005 static __be32
fattr_handle_absent_fs(u32
*bmval0
, u32
*bmval1
, u32
*rdattr_err
)
2007 /* As per referral draft: */
2008 if (*bmval0
& ~WORD0_ABSENT_FS_ATTRS
||
2009 *bmval1
& ~WORD1_ABSENT_FS_ATTRS
) {
2010 if (*bmval0
& FATTR4_WORD0_RDATTR_ERROR
||
2011 *bmval0
& FATTR4_WORD0_FS_LOCATIONS
)
2012 *rdattr_err
= NFSERR_MOVED
;
2014 return nfserr_moved
;
2016 *bmval0
&= WORD0_ABSENT_FS_ATTRS
;
2017 *bmval1
&= WORD1_ABSENT_FS_ATTRS
;
2022 static int get_parent_attributes(struct svc_export
*exp
, struct kstat
*stat
)
2024 struct path path
= exp
->ex_path
;
2028 while (follow_up(&path
)) {
2029 if (path
.dentry
!= path
.mnt
->mnt_root
)
2032 err
= vfs_getattr(&path
, stat
);
2038 * Note: @fhp can be NULL; in this case, we might have to compose the filehandle
2042 nfsd4_encode_fattr(struct xdr_stream
*xdr
, struct svc_fh
*fhp
,
2043 struct svc_export
*exp
,
2044 struct dentry
*dentry
, u32
*bmval
,
2045 struct svc_rqst
*rqstp
, int ignore_crossmnt
)
2047 u32 bmval0
= bmval
[0];
2048 u32 bmval1
= bmval
[1];
2049 u32 bmval2
= bmval
[2];
2051 struct svc_fh
*tempfh
= NULL
;
2052 struct kstatfs statfs
;
2054 int starting_len
= xdr
->buf
->len
;
2063 struct nfs4_acl
*acl
= NULL
;
2064 void *context
= NULL
;
2066 bool contextsupport
= false;
2067 struct nfsd4_compoundres
*resp
= rqstp
->rq_resp
;
2068 u32 minorversion
= resp
->cstate
.minorversion
;
2069 struct path path
= {
2070 .mnt
= exp
->ex_path
.mnt
,
2073 struct nfsd_net
*nn
= net_generic(SVC_NET(rqstp
), nfsd_net_id
);
2075 BUG_ON(bmval1
& NFSD_WRITEONLY_ATTRS_WORD1
);
2076 BUG_ON(bmval0
& ~nfsd_suppattrs0(minorversion
));
2077 BUG_ON(bmval1
& ~nfsd_suppattrs1(minorversion
));
2078 BUG_ON(bmval2
& ~nfsd_suppattrs2(minorversion
));
2080 if (exp
->ex_fslocs
.migrated
) {
2082 status
= fattr_handle_absent_fs(&bmval0
, &bmval1
, &rdattr_err
);
2087 err
= vfs_getattr(&path
, &stat
);
2090 if ((bmval0
& (FATTR4_WORD0_FILES_FREE
| FATTR4_WORD0_FILES_TOTAL
|
2091 FATTR4_WORD0_MAXNAME
)) ||
2092 (bmval1
& (FATTR4_WORD1_SPACE_AVAIL
| FATTR4_WORD1_SPACE_FREE
|
2093 FATTR4_WORD1_SPACE_TOTAL
))) {
2094 err
= vfs_statfs(&path
, &statfs
);
2098 if ((bmval0
& (FATTR4_WORD0_FILEHANDLE
| FATTR4_WORD0_FSID
)) && !fhp
) {
2099 tempfh
= kmalloc(sizeof(struct svc_fh
), GFP_KERNEL
);
2100 status
= nfserr_jukebox
;
2103 fh_init(tempfh
, NFS4_FHSIZE
);
2104 status
= fh_compose(tempfh
, exp
, dentry
, NULL
);
2109 if (bmval0
& (FATTR4_WORD0_ACL
| FATTR4_WORD0_ACLSUPPORT
2110 | FATTR4_WORD0_SUPPORTED_ATTRS
)) {
2111 err
= nfsd4_get_nfs4_acl(rqstp
, dentry
, &acl
);
2112 aclsupport
= (err
== 0);
2113 if (bmval0
& FATTR4_WORD0_ACL
) {
2114 if (err
== -EOPNOTSUPP
)
2115 bmval0
&= ~FATTR4_WORD0_ACL
;
2116 else if (err
== -EINVAL
) {
2117 status
= nfserr_attrnotsupp
;
2119 } else if (err
!= 0)
2124 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
2125 if ((bmval
[2] & FATTR4_WORD2_SECURITY_LABEL
) ||
2126 bmval
[0] & FATTR4_WORD0_SUPPORTED_ATTRS
) {
2127 err
= security_inode_getsecctx(dentry
->d_inode
,
2128 &context
, &contextlen
);
2129 contextsupport
= (err
== 0);
2130 if (bmval2
& FATTR4_WORD2_SECURITY_LABEL
) {
2131 if (err
== -EOPNOTSUPP
)
2132 bmval2
&= ~FATTR4_WORD2_SECURITY_LABEL
;
2137 #endif /* CONFIG_NFSD_V4_SECURITY_LABEL */
2140 p
= xdr_reserve_space(xdr
, 16);
2147 } else if (bmval1
) {
2148 p
= xdr_reserve_space(xdr
, 12);
2155 p
= xdr_reserve_space(xdr
, 8);
2162 attrlen_offset
= xdr
->buf
->len
;
2163 p
= xdr_reserve_space(xdr
, 4);
2166 p
++; /* to be backfilled later */
2168 if (bmval0
& FATTR4_WORD0_SUPPORTED_ATTRS
) {
2169 u32 word0
= nfsd_suppattrs0(minorversion
);
2170 u32 word1
= nfsd_suppattrs1(minorversion
);
2171 u32 word2
= nfsd_suppattrs2(minorversion
);
2174 word0
&= ~FATTR4_WORD0_ACL
;
2175 if (!contextsupport
)
2176 word2
&= ~FATTR4_WORD2_SECURITY_LABEL
;
2178 p
= xdr_reserve_space(xdr
, 12);
2185 p
= xdr_reserve_space(xdr
, 16);
2194 if (bmval0
& FATTR4_WORD0_TYPE
) {
2195 p
= xdr_reserve_space(xdr
, 4);
2198 dummy
= nfs4_file_type(stat
.mode
);
2199 if (dummy
== NF4BAD
) {
2200 status
= nfserr_serverfault
;
2205 if (bmval0
& FATTR4_WORD0_FH_EXPIRE_TYPE
) {
2206 p
= xdr_reserve_space(xdr
, 4);
2209 if (exp
->ex_flags
& NFSEXP_NOSUBTREECHECK
)
2210 WRITE32(NFS4_FH_PERSISTENT
);
2212 WRITE32(NFS4_FH_PERSISTENT
|NFS4_FH_VOL_RENAME
);
2214 if (bmval0
& FATTR4_WORD0_CHANGE
) {
2215 p
= xdr_reserve_space(xdr
, 8);
2218 write_change(&p
, &stat
, dentry
->d_inode
);
2220 if (bmval0
& FATTR4_WORD0_SIZE
) {
2221 p
= xdr_reserve_space(xdr
, 8);
2226 if (bmval0
& FATTR4_WORD0_LINK_SUPPORT
) {
2227 p
= xdr_reserve_space(xdr
, 4);
2232 if (bmval0
& FATTR4_WORD0_SYMLINK_SUPPORT
) {
2233 p
= xdr_reserve_space(xdr
, 4);
2238 if (bmval0
& FATTR4_WORD0_NAMED_ATTR
) {
2239 p
= xdr_reserve_space(xdr
, 4);
2244 if (bmval0
& FATTR4_WORD0_FSID
) {
2245 p
= xdr_reserve_space(xdr
, 16);
2248 if (exp
->ex_fslocs
.migrated
) {
2249 WRITE64(NFS4_REFERRAL_FSID_MAJOR
);
2250 WRITE64(NFS4_REFERRAL_FSID_MINOR
);
2251 } else switch(fsid_source(fhp
)) {
2252 case FSIDSOURCE_FSID
:
2253 WRITE64((u64
)exp
->ex_fsid
);
2256 case FSIDSOURCE_DEV
:
2258 WRITE32(MAJOR(stat
.dev
));
2260 WRITE32(MINOR(stat
.dev
));
2262 case FSIDSOURCE_UUID
:
2263 WRITEMEM(exp
->ex_uuid
, 16);
2267 if (bmval0
& FATTR4_WORD0_UNIQUE_HANDLES
) {
2268 p
= xdr_reserve_space(xdr
, 4);
2273 if (bmval0
& FATTR4_WORD0_LEASE_TIME
) {
2274 p
= xdr_reserve_space(xdr
, 4);
2277 WRITE32(nn
->nfsd4_lease
);
2279 if (bmval0
& FATTR4_WORD0_RDATTR_ERROR
) {
2280 p
= xdr_reserve_space(xdr
, 4);
2283 WRITE32(rdattr_err
);
2285 if (bmval0
& FATTR4_WORD0_ACL
) {
2286 struct nfs4_ace
*ace
;
2289 p
= xdr_reserve_space(xdr
, 4);
2296 p
= xdr_reserve_space(xdr
, 4);
2299 WRITE32(acl
->naces
);
2301 for (ace
= acl
->aces
; ace
< acl
->aces
+ acl
->naces
; ace
++) {
2302 p
= xdr_reserve_space(xdr
, 4*3);
2307 WRITE32(ace
->access_mask
& NFS4_ACE_MASK_ALL
);
2308 status
= nfsd4_encode_aclname(xdr
, rqstp
, ace
);
2314 if (bmval0
& FATTR4_WORD0_ACLSUPPORT
) {
2315 p
= xdr_reserve_space(xdr
, 4);
2318 WRITE32(aclsupport
?
2319 ACL4_SUPPORT_ALLOW_ACL
|ACL4_SUPPORT_DENY_ACL
: 0);
2321 if (bmval0
& FATTR4_WORD0_CANSETTIME
) {
2322 p
= xdr_reserve_space(xdr
, 4);
2327 if (bmval0
& FATTR4_WORD0_CASE_INSENSITIVE
) {
2328 p
= xdr_reserve_space(xdr
, 4);
2333 if (bmval0
& FATTR4_WORD0_CASE_PRESERVING
) {
2334 p
= xdr_reserve_space(xdr
, 4);
2339 if (bmval0
& FATTR4_WORD0_CHOWN_RESTRICTED
) {
2340 p
= xdr_reserve_space(xdr
, 4);
2345 if (bmval0
& FATTR4_WORD0_FILEHANDLE
) {
2346 p
= xdr_reserve_space(xdr
, fhp
->fh_handle
.fh_size
+ 4);
2349 WRITE32(fhp
->fh_handle
.fh_size
);
2350 WRITEMEM(&fhp
->fh_handle
.fh_base
, fhp
->fh_handle
.fh_size
);
2352 if (bmval0
& FATTR4_WORD0_FILEID
) {
2353 p
= xdr_reserve_space(xdr
, 8);
2358 if (bmval0
& FATTR4_WORD0_FILES_AVAIL
) {
2359 p
= xdr_reserve_space(xdr
, 8);
2362 WRITE64((u64
) statfs
.f_ffree
);
2364 if (bmval0
& FATTR4_WORD0_FILES_FREE
) {
2365 p
= xdr_reserve_space(xdr
, 8);
2368 WRITE64((u64
) statfs
.f_ffree
);
2370 if (bmval0
& FATTR4_WORD0_FILES_TOTAL
) {
2371 p
= xdr_reserve_space(xdr
, 8);
2374 WRITE64((u64
) statfs
.f_files
);
2376 if (bmval0
& FATTR4_WORD0_FS_LOCATIONS
) {
2377 status
= nfsd4_encode_fs_locations(xdr
, rqstp
, exp
);
2381 if (bmval0
& FATTR4_WORD0_HOMOGENEOUS
) {
2382 p
= xdr_reserve_space(xdr
, 4);
2387 if (bmval0
& FATTR4_WORD0_MAXFILESIZE
) {
2388 p
= xdr_reserve_space(xdr
, 8);
2391 WRITE64(exp
->ex_path
.mnt
->mnt_sb
->s_maxbytes
);
2393 if (bmval0
& FATTR4_WORD0_MAXLINK
) {
2394 p
= xdr_reserve_space(xdr
, 4);
2399 if (bmval0
& FATTR4_WORD0_MAXNAME
) {
2400 p
= xdr_reserve_space(xdr
, 4);
2403 WRITE32(statfs
.f_namelen
);
2405 if (bmval0
& FATTR4_WORD0_MAXREAD
) {
2406 p
= xdr_reserve_space(xdr
, 8);
2409 WRITE64((u64
) svc_max_payload(rqstp
));
2411 if (bmval0
& FATTR4_WORD0_MAXWRITE
) {
2412 p
= xdr_reserve_space(xdr
, 8);
2415 WRITE64((u64
) svc_max_payload(rqstp
));
2417 if (bmval1
& FATTR4_WORD1_MODE
) {
2418 p
= xdr_reserve_space(xdr
, 4);
2421 WRITE32(stat
.mode
& S_IALLUGO
);
2423 if (bmval1
& FATTR4_WORD1_NO_TRUNC
) {
2424 p
= xdr_reserve_space(xdr
, 4);
2429 if (bmval1
& FATTR4_WORD1_NUMLINKS
) {
2430 p
= xdr_reserve_space(xdr
, 4);
2433 WRITE32(stat
.nlink
);
2435 if (bmval1
& FATTR4_WORD1_OWNER
) {
2436 status
= nfsd4_encode_user(xdr
, rqstp
, stat
.uid
);
2440 if (bmval1
& FATTR4_WORD1_OWNER_GROUP
) {
2441 status
= nfsd4_encode_group(xdr
, rqstp
, stat
.gid
);
2445 if (bmval1
& FATTR4_WORD1_RAWDEV
) {
2446 p
= xdr_reserve_space(xdr
, 8);
2449 WRITE32((u32
) MAJOR(stat
.rdev
));
2450 WRITE32((u32
) MINOR(stat
.rdev
));
2452 if (bmval1
& FATTR4_WORD1_SPACE_AVAIL
) {
2453 p
= xdr_reserve_space(xdr
, 8);
2456 dummy64
= (u64
)statfs
.f_bavail
* (u64
)statfs
.f_bsize
;
2459 if (bmval1
& FATTR4_WORD1_SPACE_FREE
) {
2460 p
= xdr_reserve_space(xdr
, 8);
2463 dummy64
= (u64
)statfs
.f_bfree
* (u64
)statfs
.f_bsize
;
2466 if (bmval1
& FATTR4_WORD1_SPACE_TOTAL
) {
2467 p
= xdr_reserve_space(xdr
, 8);
2470 dummy64
= (u64
)statfs
.f_blocks
* (u64
)statfs
.f_bsize
;
2473 if (bmval1
& FATTR4_WORD1_SPACE_USED
) {
2474 p
= xdr_reserve_space(xdr
, 8);
2477 dummy64
= (u64
)stat
.blocks
<< 9;
2480 if (bmval1
& FATTR4_WORD1_TIME_ACCESS
) {
2481 p
= xdr_reserve_space(xdr
, 12);
2484 WRITE64((s64
)stat
.atime
.tv_sec
);
2485 WRITE32(stat
.atime
.tv_nsec
);
2487 if (bmval1
& FATTR4_WORD1_TIME_DELTA
) {
2488 p
= xdr_reserve_space(xdr
, 12);
2495 if (bmval1
& FATTR4_WORD1_TIME_METADATA
) {
2496 p
= xdr_reserve_space(xdr
, 12);
2499 WRITE64((s64
)stat
.ctime
.tv_sec
);
2500 WRITE32(stat
.ctime
.tv_nsec
);
2502 if (bmval1
& FATTR4_WORD1_TIME_MODIFY
) {
2503 p
= xdr_reserve_space(xdr
, 12);
2506 WRITE64((s64
)stat
.mtime
.tv_sec
);
2507 WRITE32(stat
.mtime
.tv_nsec
);
2509 if (bmval1
& FATTR4_WORD1_MOUNTED_ON_FILEID
) {
2510 p
= xdr_reserve_space(xdr
, 8);
2514 * Get parent's attributes if not ignoring crossmount
2515 * and this is the root of a cross-mounted filesystem.
2517 if (ignore_crossmnt
== 0 &&
2518 dentry
== exp
->ex_path
.mnt
->mnt_root
)
2519 get_parent_attributes(exp
, &stat
);
2522 if (bmval2
& FATTR4_WORD2_SECURITY_LABEL
) {
2523 status
= nfsd4_encode_security_label(xdr
, rqstp
, context
,
2528 if (bmval2
& FATTR4_WORD2_SUPPATTR_EXCLCREAT
) {
2529 p
= xdr_reserve_space(xdr
, 16);
2533 WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD0
);
2534 WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD1
);
2535 WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD2
);
2538 attrlen
= htonl(xdr
->buf
->len
- attrlen_offset
- 4);
2539 write_bytes_to_xdr_buf(xdr
->buf
, attrlen_offset
, &attrlen
, 4);
2543 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
2545 security_release_secctx(context
, contextlen
);
2546 #endif /* CONFIG_NFSD_V4_SECURITY_LABEL */
2553 xdr_truncate_encode(xdr
, starting_len
);
2556 status
= nfserrno(err
);
2559 status
= nfserr_resource
;
2563 __be32
nfsd4_encode_fattr_to_buf(__be32
**p
, int words
,
2564 struct svc_fh
*fhp
, struct svc_export
*exp
,
2565 struct dentry
*dentry
, u32
*bmval
,
2566 struct svc_rqst
*rqstp
, int ignore_crossmnt
)
2568 struct xdr_buf dummy
= {
2572 .buflen
= words
<< 2,
2574 struct xdr_stream xdr
;
2577 xdr_init_encode(&xdr
, &dummy
, NULL
);
2578 ret
= nfsd4_encode_fattr(&xdr
, fhp
, exp
, dentry
, bmval
, rqstp
,
2584 static inline int attributes_need_mount(u32
*bmval
)
2586 if (bmval
[0] & ~(FATTR4_WORD0_RDATTR_ERROR
| FATTR4_WORD0_LEASE_TIME
))
2588 if (bmval
[1] & ~FATTR4_WORD1_MOUNTED_ON_FILEID
)
2594 nfsd4_encode_dirent_fattr(struct nfsd4_readdir
*cd
,
2595 const char *name
, int namlen
, __be32
**p
, int buflen
)
2597 struct svc_export
*exp
= cd
->rd_fhp
->fh_export
;
2598 struct dentry
*dentry
;
2600 int ignore_crossmnt
= 0;
2602 dentry
= lookup_one_len(name
, cd
->rd_fhp
->fh_dentry
, namlen
);
2604 return nfserrno(PTR_ERR(dentry
));
2605 if (!dentry
->d_inode
) {
2607 * nfsd_buffered_readdir drops the i_mutex between
2608 * readdir and calling this callback, leaving a window
2609 * where this directory entry could have gone away.
2612 return nfserr_noent
;
2617 * In the case of a mountpoint, the client may be asking for
2618 * attributes that are only properties of the underlying filesystem
2619 * as opposed to the cross-mounted file system. In such a case,
2620 * we will not follow the cross mount and will fill the attribtutes
2621 * directly from the mountpoint dentry.
2623 if (nfsd_mountpoint(dentry
, exp
)) {
2626 if (!(exp
->ex_flags
& NFSEXP_V4ROOT
)
2627 && !attributes_need_mount(cd
->rd_bmval
)) {
2628 ignore_crossmnt
= 1;
2632 * Why the heck aren't we just using nfsd_lookup??
2633 * Different "."/".." handling? Something else?
2634 * At least, add a comment here to explain....
2636 err
= nfsd_cross_mnt(cd
->rd_rqstp
, &dentry
, &exp
);
2638 nfserr
= nfserrno(err
);
2641 nfserr
= check_nfsd_access(exp
, cd
->rd_rqstp
);
2647 nfserr
= nfsd4_encode_fattr_to_buf(p
, buflen
, NULL
, exp
, dentry
,
2649 cd
->rd_rqstp
, ignore_crossmnt
);
2657 nfsd4_encode_rdattr_error(__be32
*p
, int buflen
, __be32 nfserr
)
2662 *p
++ = htonl(FATTR4_WORD0_RDATTR_ERROR
); /* bmval0 */
2663 *p
++ = htonl(0); /* bmval1 */
2665 *p
++ = htonl(4); /* attribute length */
2666 *p
++ = nfserr
; /* no htonl */
2671 nfsd4_encode_dirent(void *ccdv
, const char *name
, int namlen
,
2672 loff_t offset
, u64 ino
, unsigned int d_type
)
2674 struct readdir_cd
*ccd
= ccdv
;
2675 struct nfsd4_readdir
*cd
= container_of(ccd
, struct nfsd4_readdir
, common
);
2677 __be32
*p
= cd
->buffer
;
2679 __be32 nfserr
= nfserr_toosmall
;
2681 /* In nfsv4, "." and ".." never make it onto the wire.. */
2682 if (name
&& isdotent(name
, namlen
)) {
2683 cd
->common
.err
= nfs_ok
;
2688 xdr_encode_hyper(cd
->offset
, (u64
) offset
);
2690 buflen
= cd
->buflen
- 4 - XDR_QUADLEN(namlen
);
2694 *p
++ = xdr_one
; /* mark entry present */
2696 p
= xdr_encode_hyper(p
, NFS_OFFSET_MAX
); /* offset of next entry */
2697 p
= xdr_encode_array(p
, name
, namlen
); /* name length & name */
2699 nfserr
= nfsd4_encode_dirent_fattr(cd
, name
, namlen
, &p
, buflen
);
2703 case nfserr_resource
:
2704 nfserr
= nfserr_toosmall
;
2710 * If the client requested the RDATTR_ERROR attribute,
2711 * we stuff the error code into this attribute
2712 * and continue. If this attribute was not requested,
2713 * then in accordance with the spec, we fail the
2714 * entire READDIR operation(!)
2716 if (!(cd
->rd_bmval
[0] & FATTR4_WORD0_RDATTR_ERROR
))
2718 p
= nfsd4_encode_rdattr_error(p
, buflen
, nfserr
);
2720 nfserr
= nfserr_toosmall
;
2724 cd
->buflen
-= (p
- cd
->buffer
);
2726 cd
->offset
= cookiep
;
2728 cd
->common
.err
= nfs_ok
;
2731 cd
->common
.err
= nfserr
;
2736 nfsd4_encode_stateid(struct xdr_stream
*xdr
, stateid_t
*sid
)
2740 p
= xdr_reserve_space(xdr
, sizeof(stateid_t
));
2742 return nfserr_resource
;
2743 WRITE32(sid
->si_generation
);
2744 WRITEMEM(&sid
->si_opaque
, sizeof(stateid_opaque_t
));
2749 nfsd4_encode_access(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_access
*access
)
2751 struct xdr_stream
*xdr
= &resp
->xdr
;
2755 p
= xdr_reserve_space(xdr
, 8);
2757 return nfserr_resource
;
2758 WRITE32(access
->ac_supported
);
2759 WRITE32(access
->ac_resp_access
);
2764 static __be32
nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_bind_conn_to_session
*bcts
)
2766 struct xdr_stream
*xdr
= &resp
->xdr
;
2770 p
= xdr_reserve_space(xdr
, NFS4_MAX_SESSIONID_LEN
+ 8);
2772 return nfserr_resource
;
2773 WRITEMEM(bcts
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
2775 /* Sorry, we do not yet support RDMA over 4.1: */
2782 nfsd4_encode_close(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_close
*close
)
2784 struct xdr_stream
*xdr
= &resp
->xdr
;
2787 nfserr
= nfsd4_encode_stateid(xdr
, &close
->cl_stateid
);
2794 nfsd4_encode_commit(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_commit
*commit
)
2796 struct xdr_stream
*xdr
= &resp
->xdr
;
2800 p
= xdr_reserve_space(xdr
, NFS4_VERIFIER_SIZE
);
2802 return nfserr_resource
;
2803 WRITEMEM(commit
->co_verf
.data
, NFS4_VERIFIER_SIZE
);
2809 nfsd4_encode_create(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_create
*create
)
2811 struct xdr_stream
*xdr
= &resp
->xdr
;
2815 p
= xdr_reserve_space(xdr
, 32);
2817 return nfserr_resource
;
2818 write_cinfo(&p
, &create
->cr_cinfo
);
2820 WRITE32(create
->cr_bmval
[0]);
2821 WRITE32(create
->cr_bmval
[1]);
2827 nfsd4_encode_getattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_getattr
*getattr
)
2829 struct svc_fh
*fhp
= getattr
->ga_fhp
;
2830 struct xdr_stream
*xdr
= &resp
->xdr
;
2835 nfserr
= nfsd4_encode_fattr(xdr
, fhp
, fhp
->fh_export
, fhp
->fh_dentry
,
2842 nfsd4_encode_getfh(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct svc_fh
**fhpp
)
2844 struct xdr_stream
*xdr
= &resp
->xdr
;
2845 struct svc_fh
*fhp
= *fhpp
;
2850 len
= fhp
->fh_handle
.fh_size
;
2851 p
= xdr_reserve_space(xdr
, len
+ 4);
2853 return nfserr_resource
;
2855 WRITEMEM(&fhp
->fh_handle
.fh_base
, len
);
2861 * Including all fields other than the name, a LOCK4denied structure requires
2862 * 8(clientid) + 4(namelen) + 8(offset) + 8(length) + 4(type) = 32 bytes.
2865 nfsd4_encode_lock_denied(struct xdr_stream
*xdr
, struct nfsd4_lock_denied
*ld
)
2867 struct xdr_netobj
*conf
= &ld
->ld_owner
;
2870 p
= xdr_reserve_space(xdr
, 32 + XDR_LEN(conf
->len
));
2872 return nfserr_resource
;
2873 WRITE64(ld
->ld_start
);
2874 WRITE64(ld
->ld_length
);
2875 WRITE32(ld
->ld_type
);
2877 WRITEMEM(&ld
->ld_clientid
, 8);
2879 WRITEMEM(conf
->data
, conf
->len
);
2881 } else { /* non - nfsv4 lock in conflict, no clientid nor owner */
2882 WRITE64((u64
)0); /* clientid */
2883 WRITE32(0); /* length of owner name */
2885 return nfserr_denied
;
2889 nfsd4_encode_lock(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_lock
*lock
)
2891 struct xdr_stream
*xdr
= &resp
->xdr
;
2894 nfserr
= nfsd4_encode_stateid(xdr
, &lock
->lk_resp_stateid
);
2895 else if (nfserr
== nfserr_denied
)
2896 nfserr
= nfsd4_encode_lock_denied(xdr
, &lock
->lk_denied
);
2902 nfsd4_encode_lockt(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_lockt
*lockt
)
2904 struct xdr_stream
*xdr
= &resp
->xdr
;
2906 if (nfserr
== nfserr_denied
)
2907 nfsd4_encode_lock_denied(xdr
, &lockt
->lt_denied
);
2912 nfsd4_encode_locku(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_locku
*locku
)
2914 struct xdr_stream
*xdr
= &resp
->xdr
;
2917 nfserr
= nfsd4_encode_stateid(xdr
, &locku
->lu_stateid
);
2924 nfsd4_encode_link(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_link
*link
)
2926 struct xdr_stream
*xdr
= &resp
->xdr
;
2930 p
= xdr_reserve_space(xdr
, 20);
2932 return nfserr_resource
;
2933 write_cinfo(&p
, &link
->li_cinfo
);
2940 nfsd4_encode_open(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open
*open
)
2942 struct xdr_stream
*xdr
= &resp
->xdr
;
2948 nfserr
= nfsd4_encode_stateid(xdr
, &open
->op_stateid
);
2951 p
= xdr_reserve_space(xdr
, 40);
2953 return nfserr_resource
;
2954 write_cinfo(&p
, &open
->op_cinfo
);
2955 WRITE32(open
->op_rflags
);
2957 WRITE32(open
->op_bmval
[0]);
2958 WRITE32(open
->op_bmval
[1]);
2959 WRITE32(open
->op_delegate_type
);
2961 switch (open
->op_delegate_type
) {
2962 case NFS4_OPEN_DELEGATE_NONE
:
2964 case NFS4_OPEN_DELEGATE_READ
:
2965 nfserr
= nfsd4_encode_stateid(xdr
, &open
->op_delegate_stateid
);
2968 p
= xdr_reserve_space(xdr
, 20);
2970 return nfserr_resource
;
2971 WRITE32(open
->op_recall
);
2974 * TODO: ACE's in delegations
2976 WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE
);
2979 WRITE32(0); /* XXX: is NULL principal ok? */
2981 case NFS4_OPEN_DELEGATE_WRITE
:
2982 nfserr
= nfsd4_encode_stateid(xdr
, &open
->op_delegate_stateid
);
2985 p
= xdr_reserve_space(xdr
, 32);
2987 return nfserr_resource
;
2991 * TODO: space_limit's in delegations
2993 WRITE32(NFS4_LIMIT_SIZE
);
2998 * TODO: ACE's in delegations
3000 WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE
);
3003 WRITE32(0); /* XXX: is NULL principal ok? */
3005 case NFS4_OPEN_DELEGATE_NONE_EXT
: /* 4.1 */
3006 switch (open
->op_why_no_deleg
) {
3007 case WND4_CONTENTION
:
3009 p
= xdr_reserve_space(xdr
, 8);
3011 return nfserr_resource
;
3012 WRITE32(open
->op_why_no_deleg
);
3013 WRITE32(0); /* deleg signaling not supported yet */
3016 p
= xdr_reserve_space(xdr
, 4);
3018 return nfserr_resource
;
3019 WRITE32(open
->op_why_no_deleg
);
3025 /* XXX save filehandle here */
3031 nfsd4_encode_open_confirm(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open_confirm
*oc
)
3033 struct xdr_stream
*xdr
= &resp
->xdr
;
3036 nfserr
= nfsd4_encode_stateid(xdr
, &oc
->oc_resp_stateid
);
3042 nfsd4_encode_open_downgrade(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open_downgrade
*od
)
3044 struct xdr_stream
*xdr
= &resp
->xdr
;
3047 nfserr
= nfsd4_encode_stateid(xdr
, &od
->od_stateid
);
3053 nfsd4_encode_read(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
3054 struct nfsd4_read
*read
)
3059 unsigned long maxcount
;
3060 struct xdr_stream
*xdr
= &resp
->xdr
;
3061 int starting_len
= xdr
->buf
->len
;
3067 if (resp
->xdr
.buf
->page_len
)
3068 return nfserr_resource
;
3070 p
= xdr_reserve_space(xdr
, 8); /* eof flag and byte count */
3072 return nfserr_resource
;
3074 maxcount
= svc_max_payload(resp
->rqstp
);
3075 if (maxcount
> read
->rd_length
)
3076 maxcount
= read
->rd_length
;
3081 page
= *(resp
->rqstp
->rq_next_page
);
3082 if (!page
) { /* ran out of pages */
3086 resp
->rqstp
->rq_vec
[v
].iov_base
= page_address(page
);
3087 resp
->rqstp
->rq_vec
[v
].iov_len
=
3088 len
< PAGE_SIZE
? len
: PAGE_SIZE
;
3089 resp
->rqstp
->rq_next_page
++;
3095 nfserr
= nfsd_read_file(read
->rd_rqstp
, read
->rd_fhp
, read
->rd_filp
,
3096 read
->rd_offset
, resp
->rqstp
->rq_vec
, read
->rd_vlen
,
3101 * nfsd_splice_actor may have already messed with the
3102 * page length; reset it so as not to confuse
3103 * xdr_truncate_encode:
3105 xdr
->buf
->page_len
= 0;
3106 xdr_truncate_encode(xdr
, starting_len
);
3109 eof
= (read
->rd_offset
+ maxcount
>=
3110 read
->rd_fhp
->fh_dentry
->d_inode
->i_size
);
3114 WARN_ON_ONCE(resp
->xdr
.buf
->head
[0].iov_len
!= (char *)p
3115 - (char *)resp
->xdr
.buf
->head
[0].iov_base
);
3116 resp
->xdr
.buf
->page_len
= maxcount
;
3117 xdr
->buf
->len
+= maxcount
;
3118 xdr
->iov
= xdr
->buf
->tail
;
3120 /* Use rest of head for padding and remaining ops: */
3121 resp
->xdr
.buf
->tail
[0].iov_base
= p
;
3122 resp
->xdr
.buf
->tail
[0].iov_len
= 0;
3124 p
= xdr_reserve_space(xdr
, 4);
3126 return nfserr_resource
;
3128 resp
->xdr
.buf
->tail
[0].iov_base
+= maxcount
&3;
3129 resp
->xdr
.buf
->tail
[0].iov_len
= 4 - (maxcount
&3);
3130 xdr
->buf
->len
-= (maxcount
&3);
3136 nfsd4_encode_readlink(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_readlink
*readlink
)
3139 struct xdr_stream
*xdr
= &resp
->xdr
;
3141 int length_offset
= xdr
->buf
->len
;
3146 if (resp
->xdr
.buf
->page_len
)
3147 return nfserr_resource
;
3148 if (!*resp
->rqstp
->rq_next_page
)
3149 return nfserr_resource
;
3151 page
= page_address(*(resp
->rqstp
->rq_next_page
++));
3153 maxcount
= PAGE_SIZE
;
3155 p
= xdr_reserve_space(xdr
, 4);
3157 return nfserr_resource
;
3160 * XXX: By default, the ->readlink() VFS op will truncate symlinks
3161 * if they would overflow the buffer. Is this kosher in NFSv4? If
3162 * not, one easy fix is: if ->readlink() precisely fills the buffer,
3163 * assume that truncation occurred, and return NFS4ERR_RESOURCE.
3165 nfserr
= nfsd_readlink(readlink
->rl_rqstp
, readlink
->rl_fhp
, page
, &maxcount
);
3166 if (nfserr
== nfserr_isdir
)
3167 nfserr
= nfserr_inval
;
3169 xdr_truncate_encode(xdr
, length_offset
);
3174 resp
->xdr
.buf
->head
[0].iov_len
= (char *)p
3175 - (char *)resp
->xdr
.buf
->head
[0].iov_base
;
3176 resp
->xdr
.buf
->page_len
= maxcount
;
3177 xdr
->buf
->len
+= maxcount
;
3178 xdr
->iov
= xdr
->buf
->tail
;
3180 /* Use rest of head for padding and remaining ops: */
3181 resp
->xdr
.buf
->tail
[0].iov_base
= p
;
3182 resp
->xdr
.buf
->tail
[0].iov_len
= 0;
3184 p
= xdr_reserve_space(xdr
, 4);
3186 return nfserr_resource
;
3188 resp
->xdr
.buf
->tail
[0].iov_base
+= maxcount
&3;
3189 resp
->xdr
.buf
->tail
[0].iov_len
= 4 - (maxcount
&3);
3195 nfsd4_encode_readdir(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_readdir
*readdir
)
3199 struct xdr_stream
*xdr
= &resp
->xdr
;
3200 int starting_len
= xdr
->buf
->len
;
3201 __be32
*page
, *tailbase
;
3206 if (resp
->xdr
.buf
->page_len
)
3207 return nfserr_resource
;
3208 if (!*resp
->rqstp
->rq_next_page
)
3209 return nfserr_resource
;
3211 p
= xdr_reserve_space(xdr
, NFS4_VERIFIER_SIZE
);
3213 return nfserr_resource
;
3215 /* XXX: Following NFSv3, we ignore the READDIR verifier for now. */
3218 resp
->xdr
.buf
->head
[0].iov_len
= ((char *)resp
->xdr
.p
)
3219 - (char *)resp
->xdr
.buf
->head
[0].iov_base
;
3222 maxcount
= PAGE_SIZE
;
3223 if (maxcount
> readdir
->rd_maxcount
)
3224 maxcount
= readdir
->rd_maxcount
;
3227 * Convert from bytes to words, account for the two words already
3228 * written, make sure to leave two words at the end for the next
3229 * pointer and eof field.
3231 maxcount
= (maxcount
>> 2) - 4;
3233 nfserr
= nfserr_toosmall
;
3237 page
= page_address(*(resp
->rqstp
->rq_next_page
++));
3238 readdir
->common
.err
= 0;
3239 readdir
->buflen
= maxcount
;
3240 readdir
->buffer
= page
;
3241 readdir
->offset
= NULL
;
3243 offset
= readdir
->rd_cookie
;
3244 nfserr
= nfsd_readdir(readdir
->rd_rqstp
, readdir
->rd_fhp
,
3246 &readdir
->common
, nfsd4_encode_dirent
);
3247 if (nfserr
== nfs_ok
&&
3248 readdir
->common
.err
== nfserr_toosmall
&&
3249 readdir
->buffer
== page
)
3250 nfserr
= nfserr_toosmall
;
3254 if (readdir
->offset
)
3255 xdr_encode_hyper(readdir
->offset
, offset
);
3257 p
= readdir
->buffer
;
3258 *p
++ = 0; /* no more entries */
3259 *p
++ = htonl(readdir
->common
.err
== nfserr_eof
);
3260 resp
->xdr
.buf
->page_len
= ((char *)p
) -
3261 (char*)page_address(*(resp
->rqstp
->rq_next_page
-1));
3262 xdr
->buf
->len
+= xdr
->buf
->page_len
;
3264 xdr
->iov
= xdr
->buf
->tail
;
3266 /* Use rest of head for padding and remaining ops: */
3267 resp
->xdr
.buf
->tail
[0].iov_base
= tailbase
;
3268 resp
->xdr
.buf
->tail
[0].iov_len
= 0;
3269 resp
->xdr
.p
= resp
->xdr
.buf
->tail
[0].iov_base
;
3270 resp
->xdr
.end
= resp
->xdr
.p
+
3271 (PAGE_SIZE
- resp
->xdr
.buf
->head
[0].iov_len
)/4;
3275 xdr_truncate_encode(xdr
, starting_len
);
3280 nfsd4_encode_remove(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_remove
*remove
)
3282 struct xdr_stream
*xdr
= &resp
->xdr
;
3286 p
= xdr_reserve_space(xdr
, 20);
3288 return nfserr_resource
;
3289 write_cinfo(&p
, &remove
->rm_cinfo
);
3295 nfsd4_encode_rename(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_rename
*rename
)
3297 struct xdr_stream
*xdr
= &resp
->xdr
;
3301 p
= xdr_reserve_space(xdr
, 40);
3303 return nfserr_resource
;
3304 write_cinfo(&p
, &rename
->rn_sinfo
);
3305 write_cinfo(&p
, &rename
->rn_tinfo
);
3311 nfsd4_do_encode_secinfo(struct xdr_stream
*xdr
,
3312 __be32 nfserr
, struct svc_export
*exp
)
3314 u32 i
, nflavs
, supported
;
3315 struct exp_flavor_info
*flavs
;
3316 struct exp_flavor_info def_flavs
[2];
3317 __be32
*p
, *flavorsp
;
3318 static bool report
= true;
3322 nfserr
= nfserr_resource
;
3323 if (exp
->ex_nflavors
) {
3324 flavs
= exp
->ex_flavors
;
3325 nflavs
= exp
->ex_nflavors
;
3326 } else { /* Handling of some defaults in absence of real secinfo: */
3328 if (exp
->ex_client
->flavour
->flavour
== RPC_AUTH_UNIX
) {
3330 flavs
[0].pseudoflavor
= RPC_AUTH_UNIX
;
3331 flavs
[1].pseudoflavor
= RPC_AUTH_NULL
;
3332 } else if (exp
->ex_client
->flavour
->flavour
== RPC_AUTH_GSS
) {
3334 flavs
[0].pseudoflavor
3335 = svcauth_gss_flavor(exp
->ex_client
);
3338 flavs
[0].pseudoflavor
3339 = exp
->ex_client
->flavour
->flavour
;
3344 p
= xdr_reserve_space(xdr
, 4);
3347 flavorsp
= p
++; /* to be backfilled later */
3349 for (i
= 0; i
< nflavs
; i
++) {
3350 rpc_authflavor_t pf
= flavs
[i
].pseudoflavor
;
3351 struct rpcsec_gss_info info
;
3353 if (rpcauth_get_gssinfo(pf
, &info
) == 0) {
3355 p
= xdr_reserve_space(xdr
, 4 + 4 +
3356 XDR_LEN(info
.oid
.len
) + 4 + 4);
3359 WRITE32(RPC_AUTH_GSS
);
3360 WRITE32(info
.oid
.len
);
3361 WRITEMEM(info
.oid
.data
, info
.oid
.len
);
3363 WRITE32(info
.service
);
3364 } else if (pf
< RPC_AUTH_MAXFLAVOR
) {
3366 p
= xdr_reserve_space(xdr
, 4);
3372 pr_warn("NFS: SECINFO: security flavor %u "
3373 "is not supported\n", pf
);
3377 if (nflavs
!= supported
)
3379 *flavorsp
= htonl(supported
);
3388 nfsd4_encode_secinfo(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
3389 struct nfsd4_secinfo
*secinfo
)
3391 struct xdr_stream
*xdr
= &resp
->xdr
;
3393 return nfsd4_do_encode_secinfo(xdr
, nfserr
, secinfo
->si_exp
);
3397 nfsd4_encode_secinfo_no_name(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
3398 struct nfsd4_secinfo_no_name
*secinfo
)
3400 struct xdr_stream
*xdr
= &resp
->xdr
;
3402 return nfsd4_do_encode_secinfo(xdr
, nfserr
, secinfo
->sin_exp
);
3406 * The SETATTR encode routine is special -- it always encodes a bitmap,
3407 * regardless of the error status.
3410 nfsd4_encode_setattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_setattr
*setattr
)
3412 struct xdr_stream
*xdr
= &resp
->xdr
;
3415 p
= xdr_reserve_space(xdr
, 16);
3417 return nfserr_resource
;
3426 WRITE32(setattr
->sa_bmval
[0]);
3427 WRITE32(setattr
->sa_bmval
[1]);
3428 WRITE32(setattr
->sa_bmval
[2]);
3434 nfsd4_encode_setclientid(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_setclientid
*scd
)
3436 struct xdr_stream
*xdr
= &resp
->xdr
;
3440 p
= xdr_reserve_space(xdr
, 8 + NFS4_VERIFIER_SIZE
);
3442 return nfserr_resource
;
3443 WRITEMEM(&scd
->se_clientid
, 8);
3444 WRITEMEM(&scd
->se_confirm
, NFS4_VERIFIER_SIZE
);
3446 else if (nfserr
== nfserr_clid_inuse
) {
3447 p
= xdr_reserve_space(xdr
, 8);
3449 return nfserr_resource
;
3457 nfsd4_encode_write(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_write
*write
)
3459 struct xdr_stream
*xdr
= &resp
->xdr
;
3463 p
= xdr_reserve_space(xdr
, 16);
3465 return nfserr_resource
;
3466 WRITE32(write
->wr_bytes_written
);
3467 WRITE32(write
->wr_how_written
);
3468 WRITEMEM(write
->wr_verifier
.data
, NFS4_VERIFIER_SIZE
);
3473 static const u32 nfs4_minimal_spo_must_enforce
[2] = {
3474 [1] = 1 << (OP_BIND_CONN_TO_SESSION
- 32) |
3475 1 << (OP_EXCHANGE_ID
- 32) |
3476 1 << (OP_CREATE_SESSION
- 32) |
3477 1 << (OP_DESTROY_SESSION
- 32) |
3478 1 << (OP_DESTROY_CLIENTID
- 32)
3482 nfsd4_encode_exchange_id(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
3483 struct nfsd4_exchange_id
*exid
)
3485 struct xdr_stream
*xdr
= &resp
->xdr
;
3490 int server_scope_sz
;
3491 uint64_t minor_id
= 0;
3496 major_id
= utsname()->nodename
;
3497 major_id_sz
= strlen(major_id
);
3498 server_scope
= utsname()->nodename
;
3499 server_scope_sz
= strlen(server_scope
);
3501 p
= xdr_reserve_space(xdr
,
3502 8 /* eir_clientid */ +
3503 4 /* eir_sequenceid */ +
3507 return nfserr_resource
;
3509 WRITEMEM(&exid
->clientid
, 8);
3510 WRITE32(exid
->seqid
);
3511 WRITE32(exid
->flags
);
3513 WRITE32(exid
->spa_how
);
3515 switch (exid
->spa_how
) {
3519 /* spo_must_enforce, spo_must_allow */
3520 p
= xdr_reserve_space(xdr
, 16);
3522 return nfserr_resource
;
3524 /* spo_must_enforce bitmap: */
3526 WRITE32(nfs4_minimal_spo_must_enforce
[0]);
3527 WRITE32(nfs4_minimal_spo_must_enforce
[1]);
3528 /* empty spo_must_allow bitmap: */
3536 p
= xdr_reserve_space(xdr
,
3537 8 /* so_minor_id */ +
3538 4 /* so_major_id.len */ +
3539 (XDR_QUADLEN(major_id_sz
) * 4) +
3540 4 /* eir_server_scope.len */ +
3541 (XDR_QUADLEN(server_scope_sz
) * 4) +
3542 4 /* eir_server_impl_id.count (0) */);
3544 return nfserr_resource
;
3546 /* The server_owner struct */
3547 WRITE64(minor_id
); /* Minor id */
3549 WRITE32(major_id_sz
);
3550 WRITEMEM(major_id
, major_id_sz
);
3553 WRITE32(server_scope_sz
);
3554 WRITEMEM(server_scope
, server_scope_sz
);
3556 /* Implementation id */
3557 WRITE32(0); /* zero length nfs_impl_id4 array */
3562 nfsd4_encode_create_session(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
3563 struct nfsd4_create_session
*sess
)
3565 struct xdr_stream
*xdr
= &resp
->xdr
;
3571 p
= xdr_reserve_space(xdr
, 24);
3573 return nfserr_resource
;
3574 WRITEMEM(sess
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
3575 WRITE32(sess
->seqid
);
3576 WRITE32(sess
->flags
);
3578 p
= xdr_reserve_space(xdr
, 28);
3580 return nfserr_resource
;
3581 WRITE32(0); /* headerpadsz */
3582 WRITE32(sess
->fore_channel
.maxreq_sz
);
3583 WRITE32(sess
->fore_channel
.maxresp_sz
);
3584 WRITE32(sess
->fore_channel
.maxresp_cached
);
3585 WRITE32(sess
->fore_channel
.maxops
);
3586 WRITE32(sess
->fore_channel
.maxreqs
);
3587 WRITE32(sess
->fore_channel
.nr_rdma_attrs
);
3589 if (sess
->fore_channel
.nr_rdma_attrs
) {
3590 p
= xdr_reserve_space(xdr
, 4);
3592 return nfserr_resource
;
3593 WRITE32(sess
->fore_channel
.rdma_attrs
);
3596 p
= xdr_reserve_space(xdr
, 28);
3598 return nfserr_resource
;
3599 WRITE32(0); /* headerpadsz */
3600 WRITE32(sess
->back_channel
.maxreq_sz
);
3601 WRITE32(sess
->back_channel
.maxresp_sz
);
3602 WRITE32(sess
->back_channel
.maxresp_cached
);
3603 WRITE32(sess
->back_channel
.maxops
);
3604 WRITE32(sess
->back_channel
.maxreqs
);
3605 WRITE32(sess
->back_channel
.nr_rdma_attrs
);
3607 if (sess
->back_channel
.nr_rdma_attrs
) {
3608 p
= xdr_reserve_space(xdr
, 4);
3610 return nfserr_resource
;
3611 WRITE32(sess
->back_channel
.rdma_attrs
);
3617 nfsd4_encode_sequence(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
3618 struct nfsd4_sequence
*seq
)
3620 struct xdr_stream
*xdr
= &resp
->xdr
;
3626 p
= xdr_reserve_space(xdr
, NFS4_MAX_SESSIONID_LEN
+ 20);
3628 return nfserr_resource
;
3629 WRITEMEM(seq
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
3630 WRITE32(seq
->seqid
);
3631 WRITE32(seq
->slotid
);
3632 /* Note slotid's are numbered from zero: */
3633 WRITE32(seq
->maxslots
- 1); /* sr_highest_slotid */
3634 WRITE32(seq
->maxslots
- 1); /* sr_target_highest_slotid */
3635 WRITE32(seq
->status_flags
);
3637 resp
->cstate
.datap
= p
; /* DRC cache data pointer */
3642 nfsd4_encode_test_stateid(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
3643 struct nfsd4_test_stateid
*test_stateid
)
3645 struct xdr_stream
*xdr
= &resp
->xdr
;
3646 struct nfsd4_test_stateid_id
*stateid
, *next
;
3652 p
= xdr_reserve_space(xdr
, 4 + (4 * test_stateid
->ts_num_ids
));
3654 return nfserr_resource
;
3655 *p
++ = htonl(test_stateid
->ts_num_ids
);
3657 list_for_each_entry_safe(stateid
, next
, &test_stateid
->ts_stateid_list
, ts_id_list
) {
3658 *p
++ = stateid
->ts_id_status
;
3665 nfsd4_encode_noop(struct nfsd4_compoundres
*resp
, __be32 nfserr
, void *p
)
3670 typedef __be32(* nfsd4_enc
)(struct nfsd4_compoundres
*, __be32
, void *);
3673 * Note: nfsd4_enc_ops vector is shared for v4.0 and v4.1
3674 * since we don't need to filter out obsolete ops as this is
3675 * done in the decoding phase.
3677 static nfsd4_enc nfsd4_enc_ops
[] = {
3678 [OP_ACCESS
] = (nfsd4_enc
)nfsd4_encode_access
,
3679 [OP_CLOSE
] = (nfsd4_enc
)nfsd4_encode_close
,
3680 [OP_COMMIT
] = (nfsd4_enc
)nfsd4_encode_commit
,
3681 [OP_CREATE
] = (nfsd4_enc
)nfsd4_encode_create
,
3682 [OP_DELEGPURGE
] = (nfsd4_enc
)nfsd4_encode_noop
,
3683 [OP_DELEGRETURN
] = (nfsd4_enc
)nfsd4_encode_noop
,
3684 [OP_GETATTR
] = (nfsd4_enc
)nfsd4_encode_getattr
,
3685 [OP_GETFH
] = (nfsd4_enc
)nfsd4_encode_getfh
,
3686 [OP_LINK
] = (nfsd4_enc
)nfsd4_encode_link
,
3687 [OP_LOCK
] = (nfsd4_enc
)nfsd4_encode_lock
,
3688 [OP_LOCKT
] = (nfsd4_enc
)nfsd4_encode_lockt
,
3689 [OP_LOCKU
] = (nfsd4_enc
)nfsd4_encode_locku
,
3690 [OP_LOOKUP
] = (nfsd4_enc
)nfsd4_encode_noop
,
3691 [OP_LOOKUPP
] = (nfsd4_enc
)nfsd4_encode_noop
,
3692 [OP_NVERIFY
] = (nfsd4_enc
)nfsd4_encode_noop
,
3693 [OP_OPEN
] = (nfsd4_enc
)nfsd4_encode_open
,
3694 [OP_OPENATTR
] = (nfsd4_enc
)nfsd4_encode_noop
,
3695 [OP_OPEN_CONFIRM
] = (nfsd4_enc
)nfsd4_encode_open_confirm
,
3696 [OP_OPEN_DOWNGRADE
] = (nfsd4_enc
)nfsd4_encode_open_downgrade
,
3697 [OP_PUTFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3698 [OP_PUTPUBFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3699 [OP_PUTROOTFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3700 [OP_READ
] = (nfsd4_enc
)nfsd4_encode_read
,
3701 [OP_READDIR
] = (nfsd4_enc
)nfsd4_encode_readdir
,
3702 [OP_READLINK
] = (nfsd4_enc
)nfsd4_encode_readlink
,
3703 [OP_REMOVE
] = (nfsd4_enc
)nfsd4_encode_remove
,
3704 [OP_RENAME
] = (nfsd4_enc
)nfsd4_encode_rename
,
3705 [OP_RENEW
] = (nfsd4_enc
)nfsd4_encode_noop
,
3706 [OP_RESTOREFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3707 [OP_SAVEFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
3708 [OP_SECINFO
] = (nfsd4_enc
)nfsd4_encode_secinfo
,
3709 [OP_SETATTR
] = (nfsd4_enc
)nfsd4_encode_setattr
,
3710 [OP_SETCLIENTID
] = (nfsd4_enc
)nfsd4_encode_setclientid
,
3711 [OP_SETCLIENTID_CONFIRM
] = (nfsd4_enc
)nfsd4_encode_noop
,
3712 [OP_VERIFY
] = (nfsd4_enc
)nfsd4_encode_noop
,
3713 [OP_WRITE
] = (nfsd4_enc
)nfsd4_encode_write
,
3714 [OP_RELEASE_LOCKOWNER
] = (nfsd4_enc
)nfsd4_encode_noop
,
3716 /* NFSv4.1 operations */
3717 [OP_BACKCHANNEL_CTL
] = (nfsd4_enc
)nfsd4_encode_noop
,
3718 [OP_BIND_CONN_TO_SESSION
] = (nfsd4_enc
)nfsd4_encode_bind_conn_to_session
,
3719 [OP_EXCHANGE_ID
] = (nfsd4_enc
)nfsd4_encode_exchange_id
,
3720 [OP_CREATE_SESSION
] = (nfsd4_enc
)nfsd4_encode_create_session
,
3721 [OP_DESTROY_SESSION
] = (nfsd4_enc
)nfsd4_encode_noop
,
3722 [OP_FREE_STATEID
] = (nfsd4_enc
)nfsd4_encode_noop
,
3723 [OP_GET_DIR_DELEGATION
] = (nfsd4_enc
)nfsd4_encode_noop
,
3724 [OP_GETDEVICEINFO
] = (nfsd4_enc
)nfsd4_encode_noop
,
3725 [OP_GETDEVICELIST
] = (nfsd4_enc
)nfsd4_encode_noop
,
3726 [OP_LAYOUTCOMMIT
] = (nfsd4_enc
)nfsd4_encode_noop
,
3727 [OP_LAYOUTGET
] = (nfsd4_enc
)nfsd4_encode_noop
,
3728 [OP_LAYOUTRETURN
] = (nfsd4_enc
)nfsd4_encode_noop
,
3729 [OP_SECINFO_NO_NAME
] = (nfsd4_enc
)nfsd4_encode_secinfo_no_name
,
3730 [OP_SEQUENCE
] = (nfsd4_enc
)nfsd4_encode_sequence
,
3731 [OP_SET_SSV
] = (nfsd4_enc
)nfsd4_encode_noop
,
3732 [OP_TEST_STATEID
] = (nfsd4_enc
)nfsd4_encode_test_stateid
,
3733 [OP_WANT_DELEGATION
] = (nfsd4_enc
)nfsd4_encode_noop
,
3734 [OP_DESTROY_CLIENTID
] = (nfsd4_enc
)nfsd4_encode_noop
,
3735 [OP_RECLAIM_COMPLETE
] = (nfsd4_enc
)nfsd4_encode_noop
,
3739 * Calculate the total amount of memory that the compound response has taken
3740 * after encoding the current operation with pad.
3742 * pad: if operation is non-idempotent, pad was calculate by op_rsize_bop()
3743 * which was specified at nfsd4_operation, else pad is zero.
3745 * Compare this length to the session se_fmaxresp_sz and se_fmaxresp_cached.
3747 * Our se_fmaxresp_cached will always be a multiple of PAGE_SIZE, and so
3748 * will be at least a page and will therefore hold the xdr_buf head.
3750 __be32
nfsd4_check_resp_size(struct nfsd4_compoundres
*resp
, u32 pad
)
3752 struct xdr_buf
*xb
= &resp
->rqstp
->rq_res
;
3753 struct nfsd4_session
*session
= NULL
;
3754 struct nfsd4_slot
*slot
= resp
->cstate
.slot
;
3755 u32 length
, tlen
= 0;
3757 if (!nfsd4_has_session(&resp
->cstate
))
3760 session
= resp
->cstate
.session
;
3762 if (xb
->page_len
== 0) {
3763 length
= (char *)resp
->xdr
.p
- (char *)xb
->head
[0].iov_base
+ pad
;
3765 if (xb
->tail
[0].iov_base
&& xb
->tail
[0].iov_len
> 0)
3766 tlen
= (char *)resp
->xdr
.p
- (char *)xb
->tail
[0].iov_base
;
3768 length
= xb
->head
[0].iov_len
+ xb
->page_len
+ tlen
+ pad
;
3770 dprintk("%s length %u, xb->page_len %u tlen %u pad %u\n", __func__
,
3771 length
, xb
->page_len
, tlen
, pad
);
3773 if (length
> session
->se_fchannel
.maxresp_sz
)
3774 return nfserr_rep_too_big
;
3776 if ((slot
->sl_flags
& NFSD4_SLOT_CACHETHIS
) &&
3777 length
> session
->se_fchannel
.maxresp_cached
)
3778 return nfserr_rep_too_big_to_cache
;
3784 nfsd4_encode_operation(struct nfsd4_compoundres
*resp
, struct nfsd4_op
*op
)
3786 struct xdr_stream
*xdr
= &resp
->xdr
;
3787 struct nfs4_stateowner
*so
= resp
->cstate
.replay_owner
;
3788 struct svc_rqst
*rqstp
= resp
->rqstp
;
3789 int post_err_offset
;
3793 p
= xdr_reserve_space(xdr
, 8);
3799 post_err_offset
= xdr
->buf
->len
;
3801 if (op
->opnum
== OP_ILLEGAL
)
3803 BUG_ON(op
->opnum
< 0 || op
->opnum
>= ARRAY_SIZE(nfsd4_enc_ops
) ||
3804 !nfsd4_enc_ops
[op
->opnum
]);
3805 encoder
= nfsd4_enc_ops
[op
->opnum
];
3806 op
->status
= encoder(resp
, op
->status
, &op
->u
);
3807 /* nfsd4_check_resp_size guarantees enough room for error status */
3809 int space_needed
= 0;
3810 if (!nfsd4_last_compound_op(rqstp
))
3811 space_needed
= COMPOUND_ERR_SLACK_SPACE
;
3812 op
->status
= nfsd4_check_resp_size(resp
, space_needed
);
3814 if (op
->status
== nfserr_resource
||
3815 op
->status
== nfserr_rep_too_big
||
3816 op
->status
== nfserr_rep_too_big_to_cache
) {
3818 * The operation may have already been encoded or
3819 * partially encoded. No op returns anything additional
3820 * in the case of one of these three errors, so we can
3821 * just truncate back to after the status. But it's a
3822 * bug if we had to do this on a non-idempotent op:
3824 warn_on_nonidempotent_op(op
);
3825 xdr_truncate_encode(xdr
, post_err_offset
);
3828 int len
= xdr
->buf
->len
- post_err_offset
;
3830 so
->so_replay
.rp_status
= op
->status
;
3831 so
->so_replay
.rp_buflen
= len
;
3832 read_bytes_from_xdr_buf(xdr
->buf
, post_err_offset
,
3833 so
->so_replay
.rp_buf
, len
);
3836 /* Note that op->status is already in network byte order: */
3837 write_bytes_to_xdr_buf(xdr
->buf
, post_err_offset
- 4, &op
->status
, 4);
3841 * Encode the reply stored in the stateowner reply cache
3843 * XDR note: do not encode rp->rp_buflen: the buffer contains the
3844 * previously sent already encoded operation.
3846 * called with nfs4_lock_state() held
3849 nfsd4_encode_replay(struct xdr_stream
*xdr
, struct nfsd4_op
*op
)
3852 struct nfs4_replay
*rp
= op
->replay
;
3856 p
= xdr_reserve_space(xdr
, 8 + rp
->rp_buflen
);
3862 *p
++ = rp
->rp_status
; /* already xdr'ed */
3864 WRITEMEM(rp
->rp_buf
, rp
->rp_buflen
);
3868 nfs4svc_encode_voidres(struct svc_rqst
*rqstp
, __be32
*p
, void *dummy
)
3870 return xdr_ressize_check(rqstp
, p
);
3873 int nfsd4_release_compoundargs(void *rq
, __be32
*p
, void *resp
)
3875 struct svc_rqst
*rqstp
= rq
;
3876 struct nfsd4_compoundargs
*args
= rqstp
->rq_argp
;
3878 if (args
->ops
!= args
->iops
) {
3880 args
->ops
= args
->iops
;
3884 while (args
->to_free
) {
3885 struct tmpbuf
*tb
= args
->to_free
;
3886 args
->to_free
= tb
->next
;
3887 tb
->release(tb
->buf
);
3894 nfs4svc_decode_compoundargs(struct svc_rqst
*rqstp
, __be32
*p
, struct nfsd4_compoundargs
*args
)
3896 if (rqstp
->rq_arg
.head
[0].iov_len
% 4) {
3897 /* client is nuts */
3898 dprintk("%s: compound not properly padded! (peeraddr=%pISc xid=0x%x)",
3899 __func__
, svc_addr(rqstp
), be32_to_cpu(rqstp
->rq_xid
));
3903 args
->end
= rqstp
->rq_arg
.head
[0].iov_base
+ rqstp
->rq_arg
.head
[0].iov_len
;
3904 args
->pagelist
= rqstp
->rq_arg
.pages
;
3905 args
->pagelen
= rqstp
->rq_arg
.page_len
;
3907 args
->to_free
= NULL
;
3908 args
->ops
= args
->iops
;
3909 args
->rqstp
= rqstp
;
3911 return !nfsd4_decode_compound(args
);
3915 nfs4svc_encode_compoundres(struct svc_rqst
*rqstp
, __be32
*p
, struct nfsd4_compoundres
*resp
)
3918 * All that remains is to write the tag and operation count...
3920 struct nfsd4_compound_state
*cs
= &resp
->cstate
;
3921 struct xdr_buf
*buf
= resp
->xdr
.buf
;
3923 WARN_ON_ONCE(buf
->len
!= buf
->head
[0].iov_len
+ buf
->page_len
+
3924 buf
->tail
[0].iov_len
);
3927 *p
++ = htonl(resp
->taglen
);
3928 memcpy(p
, resp
->tag
, resp
->taglen
);
3929 p
+= XDR_QUADLEN(resp
->taglen
);
3930 *p
++ = htonl(resp
->opcnt
);
3932 if (nfsd4_has_session(cs
)) {
3933 struct nfsd_net
*nn
= net_generic(SVC_NET(rqstp
), nfsd_net_id
);
3934 struct nfs4_client
*clp
= cs
->session
->se_client
;
3935 if (cs
->status
!= nfserr_replay_cache
) {
3936 nfsd4_store_cache_entry(resp
);
3937 cs
->slot
->sl_flags
&= ~NFSD4_SLOT_INUSE
;
3939 /* Renew the clientid on success and on replay */
3940 spin_lock(&nn
->client_lock
);
3941 nfsd4_put_session(cs
->session
);
3942 spin_unlock(&nn
->client_lock
);
3943 put_client_renew(clp
);