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.
36 #include <linux/fs_struct.h>
37 #include <linux/file.h>
38 #include <linux/slab.h>
39 #include <linux/namei.h>
40 #include <linux/statfs.h>
41 #include <linux/utsname.h>
42 #include <linux/pagemap.h>
43 #include <linux/sunrpc/svcauth_gss.h>
54 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
55 #include <linux/security.h>
59 #define NFSDDBG_FACILITY NFSDDBG_XDR
61 const u32 nfsd_suppattrs
[3][3] = {
62 {NFSD4_SUPPORTED_ATTRS_WORD0
,
63 NFSD4_SUPPORTED_ATTRS_WORD1
,
64 NFSD4_SUPPORTED_ATTRS_WORD2
},
66 {NFSD4_1_SUPPORTED_ATTRS_WORD0
,
67 NFSD4_1_SUPPORTED_ATTRS_WORD1
,
68 NFSD4_1_SUPPORTED_ATTRS_WORD2
},
70 {NFSD4_1_SUPPORTED_ATTRS_WORD0
,
71 NFSD4_1_SUPPORTED_ATTRS_WORD1
,
72 NFSD4_2_SUPPORTED_ATTRS_WORD2
},
76 * As per referral draft, the fsid for a referral MUST be different from the fsid of the containing
77 * directory in order to indicate to the client that a filesystem boundary is present
78 * We use a fixed fsid for a referral
80 #define NFS4_REFERRAL_FSID_MAJOR 0x8000000ULL
81 #define NFS4_REFERRAL_FSID_MINOR 0x8000000ULL
84 check_filename(char *str
, int len
)
90 if (isdotent(str
, len
))
91 return nfserr_badname
;
92 for (i
= 0; i
< len
; i
++)
94 return nfserr_badname
;
101 #define DECODE_TAIL \
106 dprintk("NFSD: xdr error (%s:%d)\n", \
107 __FILE__, __LINE__); \
108 status = nfserr_bad_xdr; \
111 #define READMEM(x,nbytes) do { \
113 p += XDR_QUADLEN(nbytes); \
115 #define SAVEMEM(x,nbytes) do { \
116 if (!(x = (p==argp->tmp || p == argp->tmpp) ? \
117 savemem(argp, p, nbytes) : \
119 dprintk("NFSD: xdr error (%s:%d)\n", \
120 __FILE__, __LINE__); \
123 p += XDR_QUADLEN(nbytes); \
125 #define COPYMEM(x,nbytes) do { \
126 memcpy((x), p, nbytes); \
127 p += XDR_QUADLEN(nbytes); \
130 /* READ_BUF, read_buf(): nbytes must be <= PAGE_SIZE */
131 #define READ_BUF(nbytes) do { \
132 if (nbytes <= (u32)((char *)argp->end - (char *)argp->p)) { \
134 argp->p += XDR_QUADLEN(nbytes); \
135 } else if (!(p = read_buf(argp, nbytes))) { \
136 dprintk("NFSD: xdr error (%s:%d)\n", \
137 __FILE__, __LINE__); \
142 static void next_decode_page(struct nfsd4_compoundargs
*argp
)
144 argp
->p
= page_address(argp
->pagelist
[0]);
146 if (argp
->pagelen
< PAGE_SIZE
) {
147 argp
->end
= argp
->p
+ XDR_QUADLEN(argp
->pagelen
);
150 argp
->end
= argp
->p
+ (PAGE_SIZE
>>2);
151 argp
->pagelen
-= PAGE_SIZE
;
155 static __be32
*read_buf(struct nfsd4_compoundargs
*argp
, u32 nbytes
)
157 /* We want more bytes than seem to be available.
158 * Maybe we need a new page, maybe we have just run out
160 unsigned int avail
= (char *)argp
->end
- (char *)argp
->p
;
163 if (argp
->pagelen
== 0) {
164 struct kvec
*vec
= &argp
->rqstp
->rq_arg
.tail
[0];
168 avail
= vec
->iov_len
;
169 argp
->p
= vec
->iov_base
;
170 argp
->end
= vec
->iov_base
+ avail
;
177 argp
->p
+= XDR_QUADLEN(nbytes
);
181 if (avail
+ argp
->pagelen
< nbytes
)
183 if (avail
+ PAGE_SIZE
< nbytes
) /* need more than a page !! */
185 /* ok, we can do it with the current plus the next page */
186 if (nbytes
<= sizeof(argp
->tmp
))
190 p
= argp
->tmpp
= kmalloc(nbytes
, GFP_KERNEL
);
196 * The following memcpy is safe because read_buf is always
197 * called with nbytes > avail, and the two cases above both
198 * guarantee p points to at least nbytes bytes.
200 memcpy(p
, argp
->p
, avail
);
201 next_decode_page(argp
);
202 memcpy(((char*)p
)+avail
, argp
->p
, (nbytes
- avail
));
203 argp
->p
+= XDR_QUADLEN(nbytes
- avail
);
207 static int zero_clientid(clientid_t
*clid
)
209 return (clid
->cl_boot
== 0) && (clid
->cl_id
== 0);
213 * svcxdr_tmpalloc - allocate memory to be freed after compound processing
214 * @argp: NFSv4 compound argument structure
215 * @p: pointer to be freed (with kfree())
217 * Marks @p to be freed when processing the compound operation
218 * described in @argp finishes.
221 svcxdr_tmpalloc(struct nfsd4_compoundargs
*argp
, u32 len
)
223 struct svcxdr_tmpbuf
*tb
;
225 tb
= kmalloc(sizeof(*tb
) + len
, GFP_KERNEL
);
228 tb
->next
= argp
->to_free
;
234 * For xdr strings that need to be passed to other kernel api's
235 * as null-terminated strings.
237 * Note null-terminating in place usually isn't safe since the
238 * buffer might end on a page boundary.
241 svcxdr_dupstr(struct nfsd4_compoundargs
*argp
, void *buf
, u32 len
)
243 char *p
= svcxdr_tmpalloc(argp
, len
+ 1);
253 * savemem - duplicate a chunk of memory for later processing
254 * @argp: NFSv4 compound argument structure to be freed with
255 * @p: pointer to be duplicated
256 * @nbytes: length to be duplicated
258 * Returns a pointer to a copy of @nbytes bytes of memory at @p
259 * that are preserved until processing of the NFSv4 compound
260 * operation described by @argp finishes.
262 static char *savemem(struct nfsd4_compoundargs
*argp
, __be32
*p
, int nbytes
)
266 ret
= svcxdr_tmpalloc(argp
, nbytes
);
269 memcpy(ret
, p
, nbytes
);
274 * We require the high 32 bits of 'seconds' to be 0, and
275 * we ignore all 32 bits of 'nseconds'.
278 nfsd4_decode_time(struct nfsd4_compoundargs
*argp
, struct timespec
*tv
)
284 p
= xdr_decode_hyper(p
, &sec
);
286 tv
->tv_nsec
= be32_to_cpup(p
++);
287 if (tv
->tv_nsec
>= (u32
)1000000000)
294 nfsd4_decode_bitmap(struct nfsd4_compoundargs
*argp
, u32
*bmval
)
304 bmlen
= be32_to_cpup(p
++);
308 READ_BUF(bmlen
<< 2);
310 bmval
[0] = be32_to_cpup(p
++);
312 bmval
[1] = be32_to_cpup(p
++);
314 bmval
[2] = be32_to_cpup(p
++);
320 nfsd4_decode_fattr(struct nfsd4_compoundargs
*argp
, u32
*bmval
,
321 struct iattr
*iattr
, struct nfs4_acl
**acl
,
322 struct xdr_netobj
*label
, int *umask
)
324 int expected_len
, len
= 0;
330 if ((status
= nfsd4_decode_bitmap(argp
, bmval
)))
333 if (bmval
[0] & ~NFSD_WRITEABLE_ATTRS_WORD0
334 || bmval
[1] & ~NFSD_WRITEABLE_ATTRS_WORD1
335 || bmval
[2] & ~NFSD_WRITEABLE_ATTRS_WORD2
) {
336 if (nfsd_attrs_supported(argp
->minorversion
, bmval
))
338 return nfserr_attrnotsupp
;
342 expected_len
= be32_to_cpup(p
++);
344 if (bmval
[0] & FATTR4_WORD0_SIZE
) {
347 p
= xdr_decode_hyper(p
, &iattr
->ia_size
);
348 iattr
->ia_valid
|= ATTR_SIZE
;
350 if (bmval
[0] & FATTR4_WORD0_ACL
) {
352 struct nfs4_ace
*ace
;
354 READ_BUF(4); len
+= 4;
355 nace
= be32_to_cpup(p
++);
357 if (nace
> NFS4_ACL_MAX
)
360 *acl
= svcxdr_tmpalloc(argp
, nfs4_acl_bytes(nace
));
362 return nfserr_jukebox
;
364 (*acl
)->naces
= nace
;
365 for (ace
= (*acl
)->aces
; ace
< (*acl
)->aces
+ nace
; ace
++) {
366 READ_BUF(16); len
+= 16;
367 ace
->type
= be32_to_cpup(p
++);
368 ace
->flag
= be32_to_cpup(p
++);
369 ace
->access_mask
= be32_to_cpup(p
++);
370 dummy32
= be32_to_cpup(p
++);
372 len
+= XDR_QUADLEN(dummy32
) << 2;
373 READMEM(buf
, dummy32
);
374 ace
->whotype
= nfs4_acl_get_whotype(buf
, dummy32
);
376 if (ace
->whotype
!= NFS4_ACL_WHO_NAMED
)
378 else if (ace
->flag
& NFS4_ACE_IDENTIFIER_GROUP
)
379 status
= nfsd_map_name_to_gid(argp
->rqstp
,
380 buf
, dummy32
, &ace
->who_gid
);
382 status
= nfsd_map_name_to_uid(argp
->rqstp
,
383 buf
, dummy32
, &ace
->who_uid
);
389 if (bmval
[1] & FATTR4_WORD1_MODE
) {
392 iattr
->ia_mode
= be32_to_cpup(p
++);
393 iattr
->ia_mode
&= (S_IFMT
| S_IALLUGO
);
394 iattr
->ia_valid
|= ATTR_MODE
;
396 if (bmval
[1] & FATTR4_WORD1_OWNER
) {
399 dummy32
= be32_to_cpup(p
++);
401 len
+= (XDR_QUADLEN(dummy32
) << 2);
402 READMEM(buf
, dummy32
);
403 if ((status
= nfsd_map_name_to_uid(argp
->rqstp
, buf
, dummy32
, &iattr
->ia_uid
)))
405 iattr
->ia_valid
|= ATTR_UID
;
407 if (bmval
[1] & FATTR4_WORD1_OWNER_GROUP
) {
410 dummy32
= be32_to_cpup(p
++);
412 len
+= (XDR_QUADLEN(dummy32
) << 2);
413 READMEM(buf
, dummy32
);
414 if ((status
= nfsd_map_name_to_gid(argp
->rqstp
, buf
, dummy32
, &iattr
->ia_gid
)))
416 iattr
->ia_valid
|= ATTR_GID
;
418 if (bmval
[1] & FATTR4_WORD1_TIME_ACCESS_SET
) {
421 dummy32
= be32_to_cpup(p
++);
423 case NFS4_SET_TO_CLIENT_TIME
:
425 status
= nfsd4_decode_time(argp
, &iattr
->ia_atime
);
428 iattr
->ia_valid
|= (ATTR_ATIME
| ATTR_ATIME_SET
);
430 case NFS4_SET_TO_SERVER_TIME
:
431 iattr
->ia_valid
|= ATTR_ATIME
;
437 if (bmval
[1] & FATTR4_WORD1_TIME_MODIFY_SET
) {
440 dummy32
= be32_to_cpup(p
++);
442 case NFS4_SET_TO_CLIENT_TIME
:
444 status
= nfsd4_decode_time(argp
, &iattr
->ia_mtime
);
447 iattr
->ia_valid
|= (ATTR_MTIME
| ATTR_MTIME_SET
);
449 case NFS4_SET_TO_SERVER_TIME
:
450 iattr
->ia_valid
|= ATTR_MTIME
;
458 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
459 if (bmval
[2] & FATTR4_WORD2_SECURITY_LABEL
) {
462 dummy32
= be32_to_cpup(p
++); /* lfs: we don't use it */
465 dummy32
= be32_to_cpup(p
++); /* pi: we don't use it either */
468 dummy32
= be32_to_cpup(p
++);
470 if (dummy32
> NFS4_MAXLABELLEN
)
471 return nfserr_badlabel
;
472 len
+= (XDR_QUADLEN(dummy32
) << 2);
473 READMEM(buf
, dummy32
);
474 label
->len
= dummy32
;
475 label
->data
= svcxdr_dupstr(argp
, buf
, dummy32
);
477 return nfserr_jukebox
;
480 if (bmval
[2] & FATTR4_WORD2_MODE_UMASK
) {
485 dummy32
= be32_to_cpup(p
++);
486 iattr
->ia_mode
= dummy32
& (S_IFMT
| S_IALLUGO
);
487 dummy32
= be32_to_cpup(p
++);
488 *umask
= dummy32
& S_IRWXUGO
;
489 iattr
->ia_valid
|= ATTR_MODE
;
491 if (len
!= expected_len
)
498 nfsd4_decode_stateid(struct nfsd4_compoundargs
*argp
, stateid_t
*sid
)
502 READ_BUF(sizeof(stateid_t
));
503 sid
->si_generation
= be32_to_cpup(p
++);
504 COPYMEM(&sid
->si_opaque
, sizeof(stateid_opaque_t
));
510 nfsd4_decode_access(struct nfsd4_compoundargs
*argp
, struct nfsd4_access
*access
)
515 access
->ac_req_access
= be32_to_cpup(p
++);
520 static __be32
nfsd4_decode_cb_sec(struct nfsd4_compoundargs
*argp
, struct nfsd4_cb_sec
*cbs
)
528 /* callback_sec_params4 */
530 nr_secflavs
= be32_to_cpup(p
++);
532 cbs
->flavor
= (u32
)(-1);
534 /* Is this legal? Be generous, take it to mean AUTH_NONE: */
536 for (i
= 0; i
< nr_secflavs
; ++i
) {
538 dummy
= be32_to_cpup(p
++);
541 /* Nothing to read */
542 if (cbs
->flavor
== (u32
)(-1))
543 cbs
->flavor
= RPC_AUTH_NULL
;
548 dummy
= be32_to_cpup(p
++);
551 dummy
= be32_to_cpup(p
++);
553 SAVEMEM(machine_name
, dummy
);
557 uid
= be32_to_cpup(p
++);
558 gid
= be32_to_cpup(p
++);
562 dummy
= be32_to_cpup(p
++);
564 if (cbs
->flavor
== (u32
)(-1)) {
565 kuid_t kuid
= make_kuid(&init_user_ns
, uid
);
566 kgid_t kgid
= make_kgid(&init_user_ns
, gid
);
567 if (uid_valid(kuid
) && gid_valid(kgid
)) {
570 cbs
->flavor
= RPC_AUTH_UNIX
;
572 dprintk("RPC_AUTH_UNIX with invalid"
573 "uid or gid ignoring!\n");
578 dprintk("RPC_AUTH_GSS callback secflavor "
582 dummy
= be32_to_cpup(p
++);
583 /* gcbp_handle_from_server */
584 dummy
= be32_to_cpup(p
++);
586 p
+= XDR_QUADLEN(dummy
);
587 /* gcbp_handle_from_client */
589 dummy
= be32_to_cpup(p
++);
593 dprintk("Illegal callback secflavor\n");
600 static __be32
nfsd4_decode_backchannel_ctl(struct nfsd4_compoundargs
*argp
, struct nfsd4_backchannel_ctl
*bc
)
605 bc
->bc_cb_program
= be32_to_cpup(p
++);
606 nfsd4_decode_cb_sec(argp
, &bc
->bc_cb_sec
);
611 static __be32
nfsd4_decode_bind_conn_to_session(struct nfsd4_compoundargs
*argp
, struct nfsd4_bind_conn_to_session
*bcts
)
615 READ_BUF(NFS4_MAX_SESSIONID_LEN
+ 8);
616 COPYMEM(bcts
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
617 bcts
->dir
= be32_to_cpup(p
++);
618 /* XXX: skipping ctsa_use_conn_in_rdma_mode. Perhaps Tom Tucker
619 * could help us figure out we should be using it. */
624 nfsd4_decode_close(struct nfsd4_compoundargs
*argp
, struct nfsd4_close
*close
)
629 close
->cl_seqid
= be32_to_cpup(p
++);
630 return nfsd4_decode_stateid(argp
, &close
->cl_stateid
);
637 nfsd4_decode_commit(struct nfsd4_compoundargs
*argp
, struct nfsd4_commit
*commit
)
642 p
= xdr_decode_hyper(p
, &commit
->co_offset
);
643 commit
->co_count
= be32_to_cpup(p
++);
649 nfsd4_decode_create(struct nfsd4_compoundargs
*argp
, struct nfsd4_create
*create
)
654 create
->cr_type
= be32_to_cpup(p
++);
655 switch (create
->cr_type
) {
658 create
->cr_datalen
= be32_to_cpup(p
++);
659 READ_BUF(create
->cr_datalen
);
660 create
->cr_data
= svcxdr_dupstr(argp
, p
, create
->cr_datalen
);
661 if (!create
->cr_data
)
662 return nfserr_jukebox
;
667 create
->cr_specdata1
= be32_to_cpup(p
++);
668 create
->cr_specdata2
= be32_to_cpup(p
++);
678 create
->cr_namelen
= be32_to_cpup(p
++);
679 READ_BUF(create
->cr_namelen
);
680 SAVEMEM(create
->cr_name
, create
->cr_namelen
);
681 if ((status
= check_filename(create
->cr_name
, create
->cr_namelen
)))
684 status
= nfsd4_decode_fattr(argp
, create
->cr_bmval
, &create
->cr_iattr
,
685 &create
->cr_acl
, &create
->cr_label
,
686 ¤t
->fs
->umask
);
694 nfsd4_decode_delegreturn(struct nfsd4_compoundargs
*argp
, struct nfsd4_delegreturn
*dr
)
696 return nfsd4_decode_stateid(argp
, &dr
->dr_stateid
);
700 nfsd4_decode_getattr(struct nfsd4_compoundargs
*argp
, struct nfsd4_getattr
*getattr
)
702 return nfsd4_decode_bitmap(argp
, getattr
->ga_bmval
);
706 nfsd4_decode_link(struct nfsd4_compoundargs
*argp
, struct nfsd4_link
*link
)
711 link
->li_namelen
= be32_to_cpup(p
++);
712 READ_BUF(link
->li_namelen
);
713 SAVEMEM(link
->li_name
, link
->li_namelen
);
714 if ((status
= check_filename(link
->li_name
, link
->li_namelen
)))
721 nfsd4_decode_lock(struct nfsd4_compoundargs
*argp
, struct nfsd4_lock
*lock
)
726 * type, reclaim(boolean), offset, length, new_lock_owner(boolean)
729 lock
->lk_type
= be32_to_cpup(p
++);
730 if ((lock
->lk_type
< NFS4_READ_LT
) || (lock
->lk_type
> NFS4_WRITEW_LT
))
732 lock
->lk_reclaim
= be32_to_cpup(p
++);
733 p
= xdr_decode_hyper(p
, &lock
->lk_offset
);
734 p
= xdr_decode_hyper(p
, &lock
->lk_length
);
735 lock
->lk_is_new
= be32_to_cpup(p
++);
737 if (lock
->lk_is_new
) {
739 lock
->lk_new_open_seqid
= be32_to_cpup(p
++);
740 status
= nfsd4_decode_stateid(argp
, &lock
->lk_new_open_stateid
);
743 READ_BUF(8 + sizeof(clientid_t
));
744 lock
->lk_new_lock_seqid
= be32_to_cpup(p
++);
745 COPYMEM(&lock
->lk_new_clientid
, sizeof(clientid_t
));
746 lock
->lk_new_owner
.len
= be32_to_cpup(p
++);
747 READ_BUF(lock
->lk_new_owner
.len
);
748 READMEM(lock
->lk_new_owner
.data
, lock
->lk_new_owner
.len
);
750 status
= nfsd4_decode_stateid(argp
, &lock
->lk_old_lock_stateid
);
754 lock
->lk_old_lock_seqid
= be32_to_cpup(p
++);
761 nfsd4_decode_lockt(struct nfsd4_compoundargs
*argp
, struct nfsd4_lockt
*lockt
)
766 lockt
->lt_type
= be32_to_cpup(p
++);
767 if((lockt
->lt_type
< NFS4_READ_LT
) || (lockt
->lt_type
> NFS4_WRITEW_LT
))
769 p
= xdr_decode_hyper(p
, &lockt
->lt_offset
);
770 p
= xdr_decode_hyper(p
, &lockt
->lt_length
);
771 COPYMEM(&lockt
->lt_clientid
, 8);
772 lockt
->lt_owner
.len
= be32_to_cpup(p
++);
773 READ_BUF(lockt
->lt_owner
.len
);
774 READMEM(lockt
->lt_owner
.data
, lockt
->lt_owner
.len
);
780 nfsd4_decode_locku(struct nfsd4_compoundargs
*argp
, struct nfsd4_locku
*locku
)
785 locku
->lu_type
= be32_to_cpup(p
++);
786 if ((locku
->lu_type
< NFS4_READ_LT
) || (locku
->lu_type
> NFS4_WRITEW_LT
))
788 locku
->lu_seqid
= be32_to_cpup(p
++);
789 status
= nfsd4_decode_stateid(argp
, &locku
->lu_stateid
);
793 p
= xdr_decode_hyper(p
, &locku
->lu_offset
);
794 p
= xdr_decode_hyper(p
, &locku
->lu_length
);
800 nfsd4_decode_lookup(struct nfsd4_compoundargs
*argp
, struct nfsd4_lookup
*lookup
)
805 lookup
->lo_len
= be32_to_cpup(p
++);
806 READ_BUF(lookup
->lo_len
);
807 SAVEMEM(lookup
->lo_name
, lookup
->lo_len
);
808 if ((status
= check_filename(lookup
->lo_name
, lookup
->lo_len
)))
814 static __be32
nfsd4_decode_share_access(struct nfsd4_compoundargs
*argp
, u32
*share_access
, u32
*deleg_want
, u32
*deleg_when
)
820 w
= be32_to_cpup(p
++);
821 *share_access
= w
& NFS4_SHARE_ACCESS_MASK
;
822 *deleg_want
= w
& NFS4_SHARE_WANT_MASK
;
824 *deleg_when
= w
& NFS4_SHARE_WHEN_MASK
;
826 switch (w
& NFS4_SHARE_ACCESS_MASK
) {
827 case NFS4_SHARE_ACCESS_READ
:
828 case NFS4_SHARE_ACCESS_WRITE
:
829 case NFS4_SHARE_ACCESS_BOTH
:
832 return nfserr_bad_xdr
;
834 w
&= ~NFS4_SHARE_ACCESS_MASK
;
837 if (!argp
->minorversion
)
838 return nfserr_bad_xdr
;
839 switch (w
& NFS4_SHARE_WANT_MASK
) {
840 case NFS4_SHARE_WANT_NO_PREFERENCE
:
841 case NFS4_SHARE_WANT_READ_DELEG
:
842 case NFS4_SHARE_WANT_WRITE_DELEG
:
843 case NFS4_SHARE_WANT_ANY_DELEG
:
844 case NFS4_SHARE_WANT_NO_DELEG
:
845 case NFS4_SHARE_WANT_CANCEL
:
848 return nfserr_bad_xdr
;
850 w
&= ~NFS4_SHARE_WANT_MASK
;
854 if (!deleg_when
) /* open_downgrade */
857 case NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL
:
858 case NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED
:
859 case (NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL
|
860 NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED
):
864 return nfserr_bad_xdr
;
867 static __be32
nfsd4_decode_share_deny(struct nfsd4_compoundargs
*argp
, u32
*x
)
872 *x
= be32_to_cpup(p
++);
873 /* Note: unlinke access bits, deny bits may be zero. */
874 if (*x
& ~NFS4_SHARE_DENY_BOTH
)
875 return nfserr_bad_xdr
;
878 return nfserr_bad_xdr
;
881 static __be32
nfsd4_decode_opaque(struct nfsd4_compoundargs
*argp
, struct xdr_netobj
*o
)
886 o
->len
= be32_to_cpup(p
++);
888 if (o
->len
== 0 || o
->len
> NFS4_OPAQUE_LIMIT
)
889 return nfserr_bad_xdr
;
892 SAVEMEM(o
->data
, o
->len
);
895 return nfserr_bad_xdr
;
899 nfsd4_decode_open(struct nfsd4_compoundargs
*argp
, struct nfsd4_open
*open
)
904 memset(open
->op_bmval
, 0, sizeof(open
->op_bmval
));
905 open
->op_iattr
.ia_valid
= 0;
906 open
->op_openowner
= NULL
;
908 open
->op_xdr_error
= 0;
909 /* seqid, share_access, share_deny, clientid, ownerlen */
911 open
->op_seqid
= be32_to_cpup(p
++);
912 /* decode, yet ignore deleg_when until supported */
913 status
= nfsd4_decode_share_access(argp
, &open
->op_share_access
,
914 &open
->op_deleg_want
, &dummy
);
917 status
= nfsd4_decode_share_deny(argp
, &open
->op_share_deny
);
920 READ_BUF(sizeof(clientid_t
));
921 COPYMEM(&open
->op_clientid
, sizeof(clientid_t
));
922 status
= nfsd4_decode_opaque(argp
, &open
->op_owner
);
926 open
->op_create
= be32_to_cpup(p
++);
927 switch (open
->op_create
) {
928 case NFS4_OPEN_NOCREATE
:
930 case NFS4_OPEN_CREATE
:
931 current
->fs
->umask
= 0;
933 open
->op_createmode
= be32_to_cpup(p
++);
934 switch (open
->op_createmode
) {
935 case NFS4_CREATE_UNCHECKED
:
936 case NFS4_CREATE_GUARDED
:
937 status
= nfsd4_decode_fattr(argp
, open
->op_bmval
,
938 &open
->op_iattr
, &open
->op_acl
, &open
->op_label
,
939 ¤t
->fs
->umask
);
943 case NFS4_CREATE_EXCLUSIVE
:
944 READ_BUF(NFS4_VERIFIER_SIZE
);
945 COPYMEM(open
->op_verf
.data
, NFS4_VERIFIER_SIZE
);
947 case NFS4_CREATE_EXCLUSIVE4_1
:
948 if (argp
->minorversion
< 1)
950 READ_BUF(NFS4_VERIFIER_SIZE
);
951 COPYMEM(open
->op_verf
.data
, NFS4_VERIFIER_SIZE
);
952 status
= nfsd4_decode_fattr(argp
, open
->op_bmval
,
953 &open
->op_iattr
, &open
->op_acl
, &open
->op_label
,
954 ¤t
->fs
->umask
);
968 open
->op_claim_type
= be32_to_cpup(p
++);
969 switch (open
->op_claim_type
) {
970 case NFS4_OPEN_CLAIM_NULL
:
971 case NFS4_OPEN_CLAIM_DELEGATE_PREV
:
973 open
->op_fname
.len
= be32_to_cpup(p
++);
974 READ_BUF(open
->op_fname
.len
);
975 SAVEMEM(open
->op_fname
.data
, open
->op_fname
.len
);
976 if ((status
= check_filename(open
->op_fname
.data
, open
->op_fname
.len
)))
979 case NFS4_OPEN_CLAIM_PREVIOUS
:
981 open
->op_delegate_type
= be32_to_cpup(p
++);
983 case NFS4_OPEN_CLAIM_DELEGATE_CUR
:
984 status
= nfsd4_decode_stateid(argp
, &open
->op_delegate_stateid
);
988 open
->op_fname
.len
= be32_to_cpup(p
++);
989 READ_BUF(open
->op_fname
.len
);
990 SAVEMEM(open
->op_fname
.data
, open
->op_fname
.len
);
991 if ((status
= check_filename(open
->op_fname
.data
, open
->op_fname
.len
)))
994 case NFS4_OPEN_CLAIM_FH
:
995 case NFS4_OPEN_CLAIM_DELEG_PREV_FH
:
996 if (argp
->minorversion
< 1)
1000 case NFS4_OPEN_CLAIM_DELEG_CUR_FH
:
1001 if (argp
->minorversion
< 1)
1003 status
= nfsd4_decode_stateid(argp
, &open
->op_delegate_stateid
);
1015 nfsd4_decode_open_confirm(struct nfsd4_compoundargs
*argp
, struct nfsd4_open_confirm
*open_conf
)
1019 if (argp
->minorversion
>= 1)
1020 return nfserr_notsupp
;
1022 status
= nfsd4_decode_stateid(argp
, &open_conf
->oc_req_stateid
);
1026 open_conf
->oc_seqid
= be32_to_cpup(p
++);
1032 nfsd4_decode_open_downgrade(struct nfsd4_compoundargs
*argp
, struct nfsd4_open_downgrade
*open_down
)
1036 status
= nfsd4_decode_stateid(argp
, &open_down
->od_stateid
);
1040 open_down
->od_seqid
= be32_to_cpup(p
++);
1041 status
= nfsd4_decode_share_access(argp
, &open_down
->od_share_access
,
1042 &open_down
->od_deleg_want
, NULL
);
1045 status
= nfsd4_decode_share_deny(argp
, &open_down
->od_share_deny
);
1052 nfsd4_decode_putfh(struct nfsd4_compoundargs
*argp
, struct nfsd4_putfh
*putfh
)
1057 putfh
->pf_fhlen
= be32_to_cpup(p
++);
1058 if (putfh
->pf_fhlen
> NFS4_FHSIZE
)
1060 READ_BUF(putfh
->pf_fhlen
);
1061 SAVEMEM(putfh
->pf_fhval
, putfh
->pf_fhlen
);
1067 nfsd4_decode_putpubfh(struct nfsd4_compoundargs
*argp
, void *p
)
1069 if (argp
->minorversion
== 0)
1071 return nfserr_notsupp
;
1075 nfsd4_decode_read(struct nfsd4_compoundargs
*argp
, struct nfsd4_read
*read
)
1079 status
= nfsd4_decode_stateid(argp
, &read
->rd_stateid
);
1083 p
= xdr_decode_hyper(p
, &read
->rd_offset
);
1084 read
->rd_length
= be32_to_cpup(p
++);
1090 nfsd4_decode_readdir(struct nfsd4_compoundargs
*argp
, struct nfsd4_readdir
*readdir
)
1095 p
= xdr_decode_hyper(p
, &readdir
->rd_cookie
);
1096 COPYMEM(readdir
->rd_verf
.data
, sizeof(readdir
->rd_verf
.data
));
1097 readdir
->rd_dircount
= be32_to_cpup(p
++);
1098 readdir
->rd_maxcount
= be32_to_cpup(p
++);
1099 if ((status
= nfsd4_decode_bitmap(argp
, readdir
->rd_bmval
)))
1106 nfsd4_decode_remove(struct nfsd4_compoundargs
*argp
, struct nfsd4_remove
*remove
)
1111 remove
->rm_namelen
= be32_to_cpup(p
++);
1112 READ_BUF(remove
->rm_namelen
);
1113 SAVEMEM(remove
->rm_name
, remove
->rm_namelen
);
1114 if ((status
= check_filename(remove
->rm_name
, remove
->rm_namelen
)))
1121 nfsd4_decode_rename(struct nfsd4_compoundargs
*argp
, struct nfsd4_rename
*rename
)
1126 rename
->rn_snamelen
= be32_to_cpup(p
++);
1127 READ_BUF(rename
->rn_snamelen
);
1128 SAVEMEM(rename
->rn_sname
, rename
->rn_snamelen
);
1130 rename
->rn_tnamelen
= be32_to_cpup(p
++);
1131 READ_BUF(rename
->rn_tnamelen
);
1132 SAVEMEM(rename
->rn_tname
, rename
->rn_tnamelen
);
1133 if ((status
= check_filename(rename
->rn_sname
, rename
->rn_snamelen
)))
1135 if ((status
= check_filename(rename
->rn_tname
, rename
->rn_tnamelen
)))
1142 nfsd4_decode_renew(struct nfsd4_compoundargs
*argp
, clientid_t
*clientid
)
1146 if (argp
->minorversion
>= 1)
1147 return nfserr_notsupp
;
1149 READ_BUF(sizeof(clientid_t
));
1150 COPYMEM(clientid
, sizeof(clientid_t
));
1156 nfsd4_decode_secinfo(struct nfsd4_compoundargs
*argp
,
1157 struct nfsd4_secinfo
*secinfo
)
1162 secinfo
->si_namelen
= be32_to_cpup(p
++);
1163 READ_BUF(secinfo
->si_namelen
);
1164 SAVEMEM(secinfo
->si_name
, secinfo
->si_namelen
);
1165 status
= check_filename(secinfo
->si_name
, secinfo
->si_namelen
);
1172 nfsd4_decode_secinfo_no_name(struct nfsd4_compoundargs
*argp
,
1173 struct nfsd4_secinfo_no_name
*sin
)
1178 sin
->sin_style
= be32_to_cpup(p
++);
1183 nfsd4_decode_setattr(struct nfsd4_compoundargs
*argp
, struct nfsd4_setattr
*setattr
)
1187 status
= nfsd4_decode_stateid(argp
, &setattr
->sa_stateid
);
1190 return nfsd4_decode_fattr(argp
, setattr
->sa_bmval
, &setattr
->sa_iattr
,
1191 &setattr
->sa_acl
, &setattr
->sa_label
, NULL
);
1195 nfsd4_decode_setclientid(struct nfsd4_compoundargs
*argp
, struct nfsd4_setclientid
*setclientid
)
1199 if (argp
->minorversion
>= 1)
1200 return nfserr_notsupp
;
1202 READ_BUF(NFS4_VERIFIER_SIZE
);
1203 COPYMEM(setclientid
->se_verf
.data
, NFS4_VERIFIER_SIZE
);
1205 status
= nfsd4_decode_opaque(argp
, &setclientid
->se_name
);
1207 return nfserr_bad_xdr
;
1209 setclientid
->se_callback_prog
= be32_to_cpup(p
++);
1210 setclientid
->se_callback_netid_len
= be32_to_cpup(p
++);
1211 READ_BUF(setclientid
->se_callback_netid_len
);
1212 SAVEMEM(setclientid
->se_callback_netid_val
, setclientid
->se_callback_netid_len
);
1214 setclientid
->se_callback_addr_len
= be32_to_cpup(p
++);
1216 READ_BUF(setclientid
->se_callback_addr_len
);
1217 SAVEMEM(setclientid
->se_callback_addr_val
, setclientid
->se_callback_addr_len
);
1219 setclientid
->se_callback_ident
= be32_to_cpup(p
++);
1225 nfsd4_decode_setclientid_confirm(struct nfsd4_compoundargs
*argp
, struct nfsd4_setclientid_confirm
*scd_c
)
1229 if (argp
->minorversion
>= 1)
1230 return nfserr_notsupp
;
1232 READ_BUF(8 + NFS4_VERIFIER_SIZE
);
1233 COPYMEM(&scd_c
->sc_clientid
, 8);
1234 COPYMEM(&scd_c
->sc_confirm
, NFS4_VERIFIER_SIZE
);
1239 /* Also used for NVERIFY */
1241 nfsd4_decode_verify(struct nfsd4_compoundargs
*argp
, struct nfsd4_verify
*verify
)
1245 if ((status
= nfsd4_decode_bitmap(argp
, verify
->ve_bmval
)))
1248 /* For convenience's sake, we compare raw xdr'd attributes in
1249 * nfsd4_proc_verify */
1252 verify
->ve_attrlen
= be32_to_cpup(p
++);
1253 READ_BUF(verify
->ve_attrlen
);
1254 SAVEMEM(verify
->ve_attrval
, verify
->ve_attrlen
);
1260 nfsd4_decode_write(struct nfsd4_compoundargs
*argp
, struct nfsd4_write
*write
)
1266 status
= nfsd4_decode_stateid(argp
, &write
->wr_stateid
);
1270 p
= xdr_decode_hyper(p
, &write
->wr_offset
);
1271 write
->wr_stable_how
= be32_to_cpup(p
++);
1272 if (write
->wr_stable_how
> NFS_FILE_SYNC
)
1274 write
->wr_buflen
= be32_to_cpup(p
++);
1276 /* Sorry .. no magic macros for this.. *
1277 * READ_BUF(write->wr_buflen);
1278 * SAVEMEM(write->wr_buf, write->wr_buflen);
1280 avail
= (char*)argp
->end
- (char*)argp
->p
;
1281 if (avail
+ argp
->pagelen
< write
->wr_buflen
) {
1282 dprintk("NFSD: xdr error (%s:%d)\n",
1283 __FILE__
, __LINE__
);
1286 write
->wr_head
.iov_base
= p
;
1287 write
->wr_head
.iov_len
= avail
;
1288 write
->wr_pagelist
= argp
->pagelist
;
1290 len
= XDR_QUADLEN(write
->wr_buflen
) << 2;
1296 pages
= len
>> PAGE_SHIFT
;
1297 argp
->pagelist
+= pages
;
1298 argp
->pagelen
-= pages
* PAGE_SIZE
;
1299 len
-= pages
* PAGE_SIZE
;
1301 next_decode_page(argp
);
1303 argp
->p
+= XDR_QUADLEN(len
);
1309 nfsd4_decode_release_lockowner(struct nfsd4_compoundargs
*argp
, struct nfsd4_release_lockowner
*rlockowner
)
1313 if (argp
->minorversion
>= 1)
1314 return nfserr_notsupp
;
1317 COPYMEM(&rlockowner
->rl_clientid
, sizeof(clientid_t
));
1318 rlockowner
->rl_owner
.len
= be32_to_cpup(p
++);
1319 READ_BUF(rlockowner
->rl_owner
.len
);
1320 READMEM(rlockowner
->rl_owner
.data
, rlockowner
->rl_owner
.len
);
1322 if (argp
->minorversion
&& !zero_clientid(&rlockowner
->rl_clientid
))
1323 return nfserr_inval
;
1328 nfsd4_decode_exchange_id(struct nfsd4_compoundargs
*argp
,
1329 struct nfsd4_exchange_id
*exid
)
1334 READ_BUF(NFS4_VERIFIER_SIZE
);
1335 COPYMEM(exid
->verifier
.data
, NFS4_VERIFIER_SIZE
);
1337 status
= nfsd4_decode_opaque(argp
, &exid
->clname
);
1339 return nfserr_bad_xdr
;
1342 exid
->flags
= be32_to_cpup(p
++);
1344 /* Ignore state_protect4_a */
1346 exid
->spa_how
= be32_to_cpup(p
++);
1347 switch (exid
->spa_how
) {
1351 /* spo_must_enforce */
1352 status
= nfsd4_decode_bitmap(argp
,
1353 exid
->spo_must_enforce
);
1356 /* spo_must_allow */
1357 status
= nfsd4_decode_bitmap(argp
, exid
->spo_must_allow
);
1364 dummy
= be32_to_cpup(p
++);
1365 READ_BUF(dummy
* 4);
1369 dummy
= be32_to_cpup(p
++);
1370 READ_BUF(dummy
* 4);
1373 /* ssp_hash_algs<> */
1375 tmp
= be32_to_cpup(p
++);
1378 dummy
= be32_to_cpup(p
++);
1380 p
+= XDR_QUADLEN(dummy
);
1383 /* ssp_encr_algs<> */
1385 tmp
= be32_to_cpup(p
++);
1388 dummy
= be32_to_cpup(p
++);
1390 p
+= XDR_QUADLEN(dummy
);
1393 /* ssp_window and ssp_num_gss_handles */
1395 dummy
= be32_to_cpup(p
++);
1396 dummy
= be32_to_cpup(p
++);
1402 /* Ignore Implementation ID */
1403 READ_BUF(4); /* nfs_impl_id4 array length */
1404 dummy
= be32_to_cpup(p
++);
1412 dummy
= be32_to_cpup(p
++);
1414 p
+= XDR_QUADLEN(dummy
);
1418 dummy
= be32_to_cpup(p
++);
1420 p
+= XDR_QUADLEN(dummy
);
1430 nfsd4_decode_create_session(struct nfsd4_compoundargs
*argp
,
1431 struct nfsd4_create_session
*sess
)
1437 COPYMEM(&sess
->clientid
, 8);
1438 sess
->seqid
= be32_to_cpup(p
++);
1439 sess
->flags
= be32_to_cpup(p
++);
1441 /* Fore channel attrs */
1443 dummy
= be32_to_cpup(p
++); /* headerpadsz is always 0 */
1444 sess
->fore_channel
.maxreq_sz
= be32_to_cpup(p
++);
1445 sess
->fore_channel
.maxresp_sz
= be32_to_cpup(p
++);
1446 sess
->fore_channel
.maxresp_cached
= be32_to_cpup(p
++);
1447 sess
->fore_channel
.maxops
= be32_to_cpup(p
++);
1448 sess
->fore_channel
.maxreqs
= be32_to_cpup(p
++);
1449 sess
->fore_channel
.nr_rdma_attrs
= be32_to_cpup(p
++);
1450 if (sess
->fore_channel
.nr_rdma_attrs
== 1) {
1452 sess
->fore_channel
.rdma_attrs
= be32_to_cpup(p
++);
1453 } else if (sess
->fore_channel
.nr_rdma_attrs
> 1) {
1454 dprintk("Too many fore channel attr bitmaps!\n");
1458 /* Back channel attrs */
1460 dummy
= be32_to_cpup(p
++); /* headerpadsz is always 0 */
1461 sess
->back_channel
.maxreq_sz
= be32_to_cpup(p
++);
1462 sess
->back_channel
.maxresp_sz
= be32_to_cpup(p
++);
1463 sess
->back_channel
.maxresp_cached
= be32_to_cpup(p
++);
1464 sess
->back_channel
.maxops
= be32_to_cpup(p
++);
1465 sess
->back_channel
.maxreqs
= be32_to_cpup(p
++);
1466 sess
->back_channel
.nr_rdma_attrs
= be32_to_cpup(p
++);
1467 if (sess
->back_channel
.nr_rdma_attrs
== 1) {
1469 sess
->back_channel
.rdma_attrs
= be32_to_cpup(p
++);
1470 } else if (sess
->back_channel
.nr_rdma_attrs
> 1) {
1471 dprintk("Too many back channel attr bitmaps!\n");
1476 sess
->callback_prog
= be32_to_cpup(p
++);
1477 nfsd4_decode_cb_sec(argp
, &sess
->cb_sec
);
1482 nfsd4_decode_destroy_session(struct nfsd4_compoundargs
*argp
,
1483 struct nfsd4_destroy_session
*destroy_session
)
1486 READ_BUF(NFS4_MAX_SESSIONID_LEN
);
1487 COPYMEM(destroy_session
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
1493 nfsd4_decode_free_stateid(struct nfsd4_compoundargs
*argp
,
1494 struct nfsd4_free_stateid
*free_stateid
)
1498 READ_BUF(sizeof(stateid_t
));
1499 free_stateid
->fr_stateid
.si_generation
= be32_to_cpup(p
++);
1500 COPYMEM(&free_stateid
->fr_stateid
.si_opaque
, sizeof(stateid_opaque_t
));
1506 nfsd4_decode_sequence(struct nfsd4_compoundargs
*argp
,
1507 struct nfsd4_sequence
*seq
)
1511 READ_BUF(NFS4_MAX_SESSIONID_LEN
+ 16);
1512 COPYMEM(seq
->sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
1513 seq
->seqid
= be32_to_cpup(p
++);
1514 seq
->slotid
= be32_to_cpup(p
++);
1515 seq
->maxslots
= be32_to_cpup(p
++);
1516 seq
->cachethis
= be32_to_cpup(p
++);
1522 nfsd4_decode_test_stateid(struct nfsd4_compoundargs
*argp
, struct nfsd4_test_stateid
*test_stateid
)
1526 struct nfsd4_test_stateid_id
*stateid
;
1529 test_stateid
->ts_num_ids
= ntohl(*p
++);
1531 INIT_LIST_HEAD(&test_stateid
->ts_stateid_list
);
1533 for (i
= 0; i
< test_stateid
->ts_num_ids
; i
++) {
1534 stateid
= svcxdr_tmpalloc(argp
, sizeof(*stateid
));
1536 status
= nfserrno(-ENOMEM
);
1540 INIT_LIST_HEAD(&stateid
->ts_id_list
);
1541 list_add_tail(&stateid
->ts_id_list
, &test_stateid
->ts_stateid_list
);
1543 status
= nfsd4_decode_stateid(argp
, &stateid
->ts_id_stateid
);
1552 dprintk("NFSD: xdr error (%s:%d)\n", __FILE__
, __LINE__
);
1553 status
= nfserr_bad_xdr
;
1557 static __be32
nfsd4_decode_destroy_clientid(struct nfsd4_compoundargs
*argp
, struct nfsd4_destroy_clientid
*dc
)
1562 COPYMEM(&dc
->clientid
, 8);
1567 static __be32
nfsd4_decode_reclaim_complete(struct nfsd4_compoundargs
*argp
, struct nfsd4_reclaim_complete
*rc
)
1572 rc
->rca_one_fs
= be32_to_cpup(p
++);
1577 #ifdef CONFIG_NFSD_PNFS
1579 nfsd4_decode_getdeviceinfo(struct nfsd4_compoundargs
*argp
,
1580 struct nfsd4_getdeviceinfo
*gdev
)
1585 READ_BUF(sizeof(struct nfsd4_deviceid
) + 3 * 4);
1586 COPYMEM(&gdev
->gd_devid
, sizeof(struct nfsd4_deviceid
));
1587 gdev
->gd_layout_type
= be32_to_cpup(p
++);
1588 gdev
->gd_maxcount
= be32_to_cpup(p
++);
1589 num
= be32_to_cpup(p
++);
1592 gdev
->gd_notify_types
= be32_to_cpup(p
++);
1593 for (i
= 1; i
< num
; i
++) {
1594 if (be32_to_cpup(p
++)) {
1595 status
= nfserr_inval
;
1604 nfsd4_decode_layoutget(struct nfsd4_compoundargs
*argp
,
1605 struct nfsd4_layoutget
*lgp
)
1610 lgp
->lg_signal
= be32_to_cpup(p
++);
1611 lgp
->lg_layout_type
= be32_to_cpup(p
++);
1612 lgp
->lg_seg
.iomode
= be32_to_cpup(p
++);
1613 p
= xdr_decode_hyper(p
, &lgp
->lg_seg
.offset
);
1614 p
= xdr_decode_hyper(p
, &lgp
->lg_seg
.length
);
1615 p
= xdr_decode_hyper(p
, &lgp
->lg_minlength
);
1617 status
= nfsd4_decode_stateid(argp
, &lgp
->lg_sid
);
1622 lgp
->lg_maxcount
= be32_to_cpup(p
++);
1628 nfsd4_decode_layoutcommit(struct nfsd4_compoundargs
*argp
,
1629 struct nfsd4_layoutcommit
*lcp
)
1635 p
= xdr_decode_hyper(p
, &lcp
->lc_seg
.offset
);
1636 p
= xdr_decode_hyper(p
, &lcp
->lc_seg
.length
);
1637 lcp
->lc_reclaim
= be32_to_cpup(p
++);
1639 status
= nfsd4_decode_stateid(argp
, &lcp
->lc_sid
);
1644 lcp
->lc_newoffset
= be32_to_cpup(p
++);
1645 if (lcp
->lc_newoffset
) {
1647 p
= xdr_decode_hyper(p
, &lcp
->lc_last_wr
);
1649 lcp
->lc_last_wr
= 0;
1651 timechange
= be32_to_cpup(p
++);
1653 status
= nfsd4_decode_time(argp
, &lcp
->lc_mtime
);
1657 lcp
->lc_mtime
.tv_nsec
= UTIME_NOW
;
1660 lcp
->lc_layout_type
= be32_to_cpup(p
++);
1663 * Save the layout update in XDR format and let the layout driver deal
1666 lcp
->lc_up_len
= be32_to_cpup(p
++);
1667 if (lcp
->lc_up_len
> 0) {
1668 READ_BUF(lcp
->lc_up_len
);
1669 READMEM(lcp
->lc_up_layout
, lcp
->lc_up_len
);
1676 nfsd4_decode_layoutreturn(struct nfsd4_compoundargs
*argp
,
1677 struct nfsd4_layoutreturn
*lrp
)
1682 lrp
->lr_reclaim
= be32_to_cpup(p
++);
1683 lrp
->lr_layout_type
= be32_to_cpup(p
++);
1684 lrp
->lr_seg
.iomode
= be32_to_cpup(p
++);
1685 lrp
->lr_return_type
= be32_to_cpup(p
++);
1686 if (lrp
->lr_return_type
== RETURN_FILE
) {
1688 p
= xdr_decode_hyper(p
, &lrp
->lr_seg
.offset
);
1689 p
= xdr_decode_hyper(p
, &lrp
->lr_seg
.length
);
1691 status
= nfsd4_decode_stateid(argp
, &lrp
->lr_sid
);
1696 lrp
->lrf_body_len
= be32_to_cpup(p
++);
1697 if (lrp
->lrf_body_len
> 0) {
1698 READ_BUF(lrp
->lrf_body_len
);
1699 READMEM(lrp
->lrf_body
, lrp
->lrf_body_len
);
1702 lrp
->lr_seg
.offset
= 0;
1703 lrp
->lr_seg
.length
= NFS4_MAX_UINT64
;
1708 #endif /* CONFIG_NFSD_PNFS */
1711 nfsd4_decode_fallocate(struct nfsd4_compoundargs
*argp
,
1712 struct nfsd4_fallocate
*fallocate
)
1716 status
= nfsd4_decode_stateid(argp
, &fallocate
->falloc_stateid
);
1721 p
= xdr_decode_hyper(p
, &fallocate
->falloc_offset
);
1722 xdr_decode_hyper(p
, &fallocate
->falloc_length
);
1728 nfsd4_decode_clone(struct nfsd4_compoundargs
*argp
, struct nfsd4_clone
*clone
)
1732 status
= nfsd4_decode_stateid(argp
, &clone
->cl_src_stateid
);
1735 status
= nfsd4_decode_stateid(argp
, &clone
->cl_dst_stateid
);
1739 READ_BUF(8 + 8 + 8);
1740 p
= xdr_decode_hyper(p
, &clone
->cl_src_pos
);
1741 p
= xdr_decode_hyper(p
, &clone
->cl_dst_pos
);
1742 p
= xdr_decode_hyper(p
, &clone
->cl_count
);
1747 nfsd4_decode_copy(struct nfsd4_compoundargs
*argp
, struct nfsd4_copy
*copy
)
1752 status
= nfsd4_decode_stateid(argp
, ©
->cp_src_stateid
);
1755 status
= nfsd4_decode_stateid(argp
, ©
->cp_dst_stateid
);
1759 READ_BUF(8 + 8 + 8 + 4 + 4 + 4);
1760 p
= xdr_decode_hyper(p
, ©
->cp_src_pos
);
1761 p
= xdr_decode_hyper(p
, ©
->cp_dst_pos
);
1762 p
= xdr_decode_hyper(p
, ©
->cp_count
);
1763 copy
->cp_consecutive
= be32_to_cpup(p
++);
1764 copy
->cp_synchronous
= be32_to_cpup(p
++);
1765 tmp
= be32_to_cpup(p
); /* Source server list not supported */
1771 nfsd4_decode_seek(struct nfsd4_compoundargs
*argp
, struct nfsd4_seek
*seek
)
1775 status
= nfsd4_decode_stateid(argp
, &seek
->seek_stateid
);
1780 p
= xdr_decode_hyper(p
, &seek
->seek_offset
);
1781 seek
->seek_whence
= be32_to_cpup(p
);
1787 nfsd4_decode_noop(struct nfsd4_compoundargs
*argp
, void *p
)
1793 nfsd4_decode_notsupp(struct nfsd4_compoundargs
*argp
, void *p
)
1795 return nfserr_notsupp
;
1798 typedef __be32(*nfsd4_dec
)(struct nfsd4_compoundargs
*argp
, void *);
1800 static const nfsd4_dec nfsd4_dec_ops
[] = {
1801 [OP_ACCESS
] = (nfsd4_dec
)nfsd4_decode_access
,
1802 [OP_CLOSE
] = (nfsd4_dec
)nfsd4_decode_close
,
1803 [OP_COMMIT
] = (nfsd4_dec
)nfsd4_decode_commit
,
1804 [OP_CREATE
] = (nfsd4_dec
)nfsd4_decode_create
,
1805 [OP_DELEGPURGE
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1806 [OP_DELEGRETURN
] = (nfsd4_dec
)nfsd4_decode_delegreturn
,
1807 [OP_GETATTR
] = (nfsd4_dec
)nfsd4_decode_getattr
,
1808 [OP_GETFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1809 [OP_LINK
] = (nfsd4_dec
)nfsd4_decode_link
,
1810 [OP_LOCK
] = (nfsd4_dec
)nfsd4_decode_lock
,
1811 [OP_LOCKT
] = (nfsd4_dec
)nfsd4_decode_lockt
,
1812 [OP_LOCKU
] = (nfsd4_dec
)nfsd4_decode_locku
,
1813 [OP_LOOKUP
] = (nfsd4_dec
)nfsd4_decode_lookup
,
1814 [OP_LOOKUPP
] = (nfsd4_dec
)nfsd4_decode_noop
,
1815 [OP_NVERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
1816 [OP_OPEN
] = (nfsd4_dec
)nfsd4_decode_open
,
1817 [OP_OPENATTR
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1818 [OP_OPEN_CONFIRM
] = (nfsd4_dec
)nfsd4_decode_open_confirm
,
1819 [OP_OPEN_DOWNGRADE
] = (nfsd4_dec
)nfsd4_decode_open_downgrade
,
1820 [OP_PUTFH
] = (nfsd4_dec
)nfsd4_decode_putfh
,
1821 [OP_PUTPUBFH
] = (nfsd4_dec
)nfsd4_decode_putpubfh
,
1822 [OP_PUTROOTFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1823 [OP_READ
] = (nfsd4_dec
)nfsd4_decode_read
,
1824 [OP_READDIR
] = (nfsd4_dec
)nfsd4_decode_readdir
,
1825 [OP_READLINK
] = (nfsd4_dec
)nfsd4_decode_noop
,
1826 [OP_REMOVE
] = (nfsd4_dec
)nfsd4_decode_remove
,
1827 [OP_RENAME
] = (nfsd4_dec
)nfsd4_decode_rename
,
1828 [OP_RENEW
] = (nfsd4_dec
)nfsd4_decode_renew
,
1829 [OP_RESTOREFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1830 [OP_SAVEFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
1831 [OP_SECINFO
] = (nfsd4_dec
)nfsd4_decode_secinfo
,
1832 [OP_SETATTR
] = (nfsd4_dec
)nfsd4_decode_setattr
,
1833 [OP_SETCLIENTID
] = (nfsd4_dec
)nfsd4_decode_setclientid
,
1834 [OP_SETCLIENTID_CONFIRM
] = (nfsd4_dec
)nfsd4_decode_setclientid_confirm
,
1835 [OP_VERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
1836 [OP_WRITE
] = (nfsd4_dec
)nfsd4_decode_write
,
1837 [OP_RELEASE_LOCKOWNER
] = (nfsd4_dec
)nfsd4_decode_release_lockowner
,
1839 /* new operations for NFSv4.1 */
1840 [OP_BACKCHANNEL_CTL
] = (nfsd4_dec
)nfsd4_decode_backchannel_ctl
,
1841 [OP_BIND_CONN_TO_SESSION
]= (nfsd4_dec
)nfsd4_decode_bind_conn_to_session
,
1842 [OP_EXCHANGE_ID
] = (nfsd4_dec
)nfsd4_decode_exchange_id
,
1843 [OP_CREATE_SESSION
] = (nfsd4_dec
)nfsd4_decode_create_session
,
1844 [OP_DESTROY_SESSION
] = (nfsd4_dec
)nfsd4_decode_destroy_session
,
1845 [OP_FREE_STATEID
] = (nfsd4_dec
)nfsd4_decode_free_stateid
,
1846 [OP_GET_DIR_DELEGATION
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1847 #ifdef CONFIG_NFSD_PNFS
1848 [OP_GETDEVICEINFO
] = (nfsd4_dec
)nfsd4_decode_getdeviceinfo
,
1849 [OP_GETDEVICELIST
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1850 [OP_LAYOUTCOMMIT
] = (nfsd4_dec
)nfsd4_decode_layoutcommit
,
1851 [OP_LAYOUTGET
] = (nfsd4_dec
)nfsd4_decode_layoutget
,
1852 [OP_LAYOUTRETURN
] = (nfsd4_dec
)nfsd4_decode_layoutreturn
,
1854 [OP_GETDEVICEINFO
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1855 [OP_GETDEVICELIST
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1856 [OP_LAYOUTCOMMIT
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1857 [OP_LAYOUTGET
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1858 [OP_LAYOUTRETURN
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1860 [OP_SECINFO_NO_NAME
] = (nfsd4_dec
)nfsd4_decode_secinfo_no_name
,
1861 [OP_SEQUENCE
] = (nfsd4_dec
)nfsd4_decode_sequence
,
1862 [OP_SET_SSV
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1863 [OP_TEST_STATEID
] = (nfsd4_dec
)nfsd4_decode_test_stateid
,
1864 [OP_WANT_DELEGATION
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1865 [OP_DESTROY_CLIENTID
] = (nfsd4_dec
)nfsd4_decode_destroy_clientid
,
1866 [OP_RECLAIM_COMPLETE
] = (nfsd4_dec
)nfsd4_decode_reclaim_complete
,
1868 /* new operations for NFSv4.2 */
1869 [OP_ALLOCATE
] = (nfsd4_dec
)nfsd4_decode_fallocate
,
1870 [OP_COPY
] = (nfsd4_dec
)nfsd4_decode_copy
,
1871 [OP_COPY_NOTIFY
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1872 [OP_DEALLOCATE
] = (nfsd4_dec
)nfsd4_decode_fallocate
,
1873 [OP_IO_ADVISE
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1874 [OP_LAYOUTERROR
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1875 [OP_LAYOUTSTATS
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1876 [OP_OFFLOAD_CANCEL
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1877 [OP_OFFLOAD_STATUS
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1878 [OP_READ_PLUS
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1879 [OP_SEEK
] = (nfsd4_dec
)nfsd4_decode_seek
,
1880 [OP_WRITE_SAME
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
1881 [OP_CLONE
] = (nfsd4_dec
)nfsd4_decode_clone
,
1885 nfsd4_opnum_in_range(struct nfsd4_compoundargs
*argp
, struct nfsd4_op
*op
)
1887 if (op
->opnum
< FIRST_NFS4_OP
)
1889 else if (argp
->minorversion
== 0 && op
->opnum
> LAST_NFS40_OP
)
1891 else if (argp
->minorversion
== 1 && op
->opnum
> LAST_NFS41_OP
)
1893 else if (argp
->minorversion
== 2 && op
->opnum
> LAST_NFS42_OP
)
1899 nfsd4_decode_compound(struct nfsd4_compoundargs
*argp
)
1902 struct nfsd4_op
*op
;
1903 bool cachethis
= false;
1904 int auth_slack
= argp
->rqstp
->rq_auth_slack
;
1905 int max_reply
= auth_slack
+ 8; /* opcnt, status */
1911 argp
->taglen
= be32_to_cpup(p
++);
1912 READ_BUF(argp
->taglen
);
1913 SAVEMEM(argp
->tag
, argp
->taglen
);
1915 argp
->minorversion
= be32_to_cpup(p
++);
1916 argp
->opcnt
= be32_to_cpup(p
++);
1917 max_reply
+= 4 + (XDR_QUADLEN(argp
->taglen
) << 2);
1919 if (argp
->taglen
> NFSD4_MAX_TAGLEN
)
1921 if (argp
->opcnt
> 100)
1924 if (argp
->opcnt
> ARRAY_SIZE(argp
->iops
)) {
1925 argp
->ops
= kzalloc(argp
->opcnt
* sizeof(*argp
->ops
), GFP_KERNEL
);
1927 argp
->ops
= argp
->iops
;
1928 dprintk("nfsd: couldn't allocate room for COMPOUND\n");
1933 if (argp
->minorversion
> NFSD_SUPPORTED_MINOR_VERSION
)
1936 for (i
= 0; i
< argp
->opcnt
; i
++) {
1941 op
->opnum
= be32_to_cpup(p
++);
1943 if (nfsd4_opnum_in_range(argp
, op
))
1944 op
->status
= nfsd4_dec_ops
[op
->opnum
](argp
, &op
->u
);
1946 op
->opnum
= OP_ILLEGAL
;
1947 op
->status
= nfserr_op_illegal
;
1949 op
->opdesc
= OPDESC(op
);
1951 * We'll try to cache the result in the DRC if any one
1952 * op in the compound wants to be cached:
1954 cachethis
|= nfsd4_cache_this_op(op
);
1956 if (op
->opnum
== OP_READ
) {
1958 readbytes
+= nfsd4_max_reply(argp
->rqstp
, op
);
1960 max_reply
+= nfsd4_max_reply(argp
->rqstp
, op
);
1962 * OP_LOCK and OP_LOCKT may return a conflicting lock.
1963 * (Special case because it will just skip encoding this
1964 * if it runs out of xdr buffer space, and it is the only
1965 * operation that behaves this way.)
1967 if (op
->opnum
== OP_LOCK
|| op
->opnum
== OP_LOCKT
)
1968 max_reply
+= NFS4_OPAQUE_LIMIT
;
1975 /* Sessions make the DRC unnecessary: */
1976 if (argp
->minorversion
)
1978 svc_reserve(argp
->rqstp
, max_reply
+ readbytes
);
1979 argp
->rqstp
->rq_cachetype
= cachethis
? RC_REPLBUFF
: RC_NOCACHE
;
1981 if (readcount
> 1 || max_reply
> PAGE_SIZE
- auth_slack
)
1982 clear_bit(RQ_SPLICE_OK
, &argp
->rqstp
->rq_flags
);
1987 static __be32
*encode_change(__be32
*p
, struct kstat
*stat
, struct inode
*inode
,
1988 struct svc_export
*exp
)
1990 if (exp
->ex_flags
& NFSEXP_V4ROOT
) {
1991 *p
++ = cpu_to_be32(convert_to_wallclock(exp
->cd
->flush_time
));
1993 } else if (IS_I_VERSION(inode
)) {
1994 p
= xdr_encode_hyper(p
, nfsd4_change_attribute(inode
));
1996 *p
++ = cpu_to_be32(stat
->ctime
.tv_sec
);
1997 *p
++ = cpu_to_be32(stat
->ctime
.tv_nsec
);
2002 static __be32
*encode_cinfo(__be32
*p
, struct nfsd4_change_info
*c
)
2004 *p
++ = cpu_to_be32(c
->atomic
);
2005 if (c
->change_supported
) {
2006 p
= xdr_encode_hyper(p
, c
->before_change
);
2007 p
= xdr_encode_hyper(p
, c
->after_change
);
2009 *p
++ = cpu_to_be32(c
->before_ctime_sec
);
2010 *p
++ = cpu_to_be32(c
->before_ctime_nsec
);
2011 *p
++ = cpu_to_be32(c
->after_ctime_sec
);
2012 *p
++ = cpu_to_be32(c
->after_ctime_nsec
);
2017 /* Encode as an array of strings the string given with components
2018 * separated @sep, escaped with esc_enter and esc_exit.
2020 static __be32
nfsd4_encode_components_esc(struct xdr_stream
*xdr
, char sep
,
2021 char *components
, char esc_enter
,
2027 int strlen
, count
=0;
2028 char *str
, *end
, *next
;
2030 dprintk("nfsd4_encode_components(%s)\n", components
);
2032 pathlen_offset
= xdr
->buf
->len
;
2033 p
= xdr_reserve_space(xdr
, 4);
2035 return nfserr_resource
;
2036 p
++; /* We will fill this in with @count later */
2038 end
= str
= components
;
2040 bool found_esc
= false;
2042 /* try to parse as esc_start, ..., esc_end, sep */
2043 if (*str
== esc_enter
) {
2044 for (; *end
&& (*end
!= esc_exit
); end
++)
2045 /* find esc_exit or end of string */;
2047 if (*end
&& (!*next
|| *next
== sep
)) {
2054 for (; *end
&& (*end
!= sep
); end
++)
2055 /* find sep or end of string */;
2059 p
= xdr_reserve_space(xdr
, strlen
+ 4);
2061 return nfserr_resource
;
2062 p
= xdr_encode_opaque(p
, str
, strlen
);
2072 pathlen
= htonl(count
);
2073 write_bytes_to_xdr_buf(xdr
->buf
, pathlen_offset
, &pathlen
, 4);
2077 /* Encode as an array of strings the string given with components
2080 static __be32
nfsd4_encode_components(struct xdr_stream
*xdr
, char sep
,
2083 return nfsd4_encode_components_esc(xdr
, sep
, components
, 0, 0);
2087 * encode a location element of a fs_locations structure
2089 static __be32
nfsd4_encode_fs_location4(struct xdr_stream
*xdr
,
2090 struct nfsd4_fs_location
*location
)
2094 status
= nfsd4_encode_components_esc(xdr
, ':', location
->hosts
,
2098 status
= nfsd4_encode_components(xdr
, '/', location
->path
);
2105 * Encode a path in RFC3530 'pathname4' format
2107 static __be32
nfsd4_encode_path(struct xdr_stream
*xdr
,
2108 const struct path
*root
,
2109 const struct path
*path
)
2111 struct path cur
= *path
;
2113 struct dentry
**components
= NULL
;
2114 unsigned int ncomponents
= 0;
2115 __be32 err
= nfserr_jukebox
;
2117 dprintk("nfsd4_encode_components(");
2120 /* First walk the path up to the nfsd root, and store the
2121 * dentries/path components in an array.
2124 if (path_equal(&cur
, root
))
2126 if (cur
.dentry
== cur
.mnt
->mnt_root
) {
2127 if (follow_up(&cur
))
2131 if ((ncomponents
& 15) == 0) {
2132 struct dentry
**new;
2133 new = krealloc(components
,
2134 sizeof(*new) * (ncomponents
+ 16),
2140 components
[ncomponents
++] = cur
.dentry
;
2141 cur
.dentry
= dget_parent(cur
.dentry
);
2143 err
= nfserr_resource
;
2144 p
= xdr_reserve_space(xdr
, 4);
2147 *p
++ = cpu_to_be32(ncomponents
);
2149 while (ncomponents
) {
2150 struct dentry
*dentry
= components
[ncomponents
- 1];
2153 spin_lock(&dentry
->d_lock
);
2154 len
= dentry
->d_name
.len
;
2155 p
= xdr_reserve_space(xdr
, len
+ 4);
2157 spin_unlock(&dentry
->d_lock
);
2160 p
= xdr_encode_opaque(p
, dentry
->d_name
.name
, len
);
2161 dprintk("/%pd", dentry
);
2162 spin_unlock(&dentry
->d_lock
);
2171 dput(components
[--ncomponents
]);
2177 static __be32
nfsd4_encode_fsloc_fsroot(struct xdr_stream
*xdr
,
2178 struct svc_rqst
*rqstp
, const struct path
*path
)
2180 struct svc_export
*exp_ps
;
2183 exp_ps
= rqst_find_fsidzero_export(rqstp
);
2185 return nfserrno(PTR_ERR(exp_ps
));
2186 res
= nfsd4_encode_path(xdr
, &exp_ps
->ex_path
, path
);
2192 * encode a fs_locations structure
2194 static __be32
nfsd4_encode_fs_locations(struct xdr_stream
*xdr
,
2195 struct svc_rqst
*rqstp
, struct svc_export
*exp
)
2200 struct nfsd4_fs_locations
*fslocs
= &exp
->ex_fslocs
;
2202 status
= nfsd4_encode_fsloc_fsroot(xdr
, rqstp
, &exp
->ex_path
);
2205 p
= xdr_reserve_space(xdr
, 4);
2207 return nfserr_resource
;
2208 *p
++ = cpu_to_be32(fslocs
->locations_count
);
2209 for (i
=0; i
<fslocs
->locations_count
; i
++) {
2210 status
= nfsd4_encode_fs_location4(xdr
, &fslocs
->locations
[i
]);
2217 static u32
nfs4_file_type(umode_t mode
)
2219 switch (mode
& S_IFMT
) {
2220 case S_IFIFO
: return NF4FIFO
;
2221 case S_IFCHR
: return NF4CHR
;
2222 case S_IFDIR
: return NF4DIR
;
2223 case S_IFBLK
: return NF4BLK
;
2224 case S_IFLNK
: return NF4LNK
;
2225 case S_IFREG
: return NF4REG
;
2226 case S_IFSOCK
: return NF4SOCK
;
2227 default: return NF4BAD
;
2231 static inline __be32
2232 nfsd4_encode_aclname(struct xdr_stream
*xdr
, struct svc_rqst
*rqstp
,
2233 struct nfs4_ace
*ace
)
2235 if (ace
->whotype
!= NFS4_ACL_WHO_NAMED
)
2236 return nfs4_acl_write_who(xdr
, ace
->whotype
);
2237 else if (ace
->flag
& NFS4_ACE_IDENTIFIER_GROUP
)
2238 return nfsd4_encode_group(xdr
, rqstp
, ace
->who_gid
);
2240 return nfsd4_encode_user(xdr
, rqstp
, ace
->who_uid
);
2243 static inline __be32
2244 nfsd4_encode_layout_types(struct xdr_stream
*xdr
, u32 layout_types
)
2247 unsigned long i
= hweight_long(layout_types
);
2249 p
= xdr_reserve_space(xdr
, 4 + 4 * i
);
2251 return nfserr_resource
;
2253 *p
++ = cpu_to_be32(i
);
2255 for (i
= LAYOUT_NFSV4_1_FILES
; i
< LAYOUT_TYPE_MAX
; ++i
)
2256 if (layout_types
& (1 << i
))
2257 *p
++ = cpu_to_be32(i
);
2262 #define WORD0_ABSENT_FS_ATTRS (FATTR4_WORD0_FS_LOCATIONS | FATTR4_WORD0_FSID | \
2263 FATTR4_WORD0_RDATTR_ERROR)
2264 #define WORD1_ABSENT_FS_ATTRS FATTR4_WORD1_MOUNTED_ON_FILEID
2265 #define WORD2_ABSENT_FS_ATTRS 0
2267 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
2268 static inline __be32
2269 nfsd4_encode_security_label(struct xdr_stream
*xdr
, struct svc_rqst
*rqstp
,
2270 void *context
, int len
)
2274 p
= xdr_reserve_space(xdr
, len
+ 4 + 4 + 4);
2276 return nfserr_resource
;
2279 * For now we use a 0 here to indicate the null translation; in
2280 * the future we may place a call to translation code here.
2282 *p
++ = cpu_to_be32(0); /* lfs */
2283 *p
++ = cpu_to_be32(0); /* pi */
2284 p
= xdr_encode_opaque(p
, context
, len
);
2288 static inline __be32
2289 nfsd4_encode_security_label(struct xdr_stream
*xdr
, struct svc_rqst
*rqstp
,
2290 void *context
, int len
)
2294 static __be32
fattr_handle_absent_fs(u32
*bmval0
, u32
*bmval1
, u32
*bmval2
, u32
*rdattr_err
)
2296 /* As per referral draft: */
2297 if (*bmval0
& ~WORD0_ABSENT_FS_ATTRS
||
2298 *bmval1
& ~WORD1_ABSENT_FS_ATTRS
) {
2299 if (*bmval0
& FATTR4_WORD0_RDATTR_ERROR
||
2300 *bmval0
& FATTR4_WORD0_FS_LOCATIONS
)
2301 *rdattr_err
= NFSERR_MOVED
;
2303 return nfserr_moved
;
2305 *bmval0
&= WORD0_ABSENT_FS_ATTRS
;
2306 *bmval1
&= WORD1_ABSENT_FS_ATTRS
;
2307 *bmval2
&= WORD2_ABSENT_FS_ATTRS
;
2312 static int get_parent_attributes(struct svc_export
*exp
, struct kstat
*stat
)
2314 struct path path
= exp
->ex_path
;
2318 while (follow_up(&path
)) {
2319 if (path
.dentry
!= path
.mnt
->mnt_root
)
2322 err
= vfs_getattr(&path
, stat
, STATX_BASIC_STATS
, AT_STATX_SYNC_AS_STAT
);
2328 nfsd4_encode_bitmap(struct xdr_stream
*xdr
, u32 bmval0
, u32 bmval1
, u32 bmval2
)
2333 p
= xdr_reserve_space(xdr
, 16);
2336 *p
++ = cpu_to_be32(3);
2337 *p
++ = cpu_to_be32(bmval0
);
2338 *p
++ = cpu_to_be32(bmval1
);
2339 *p
++ = cpu_to_be32(bmval2
);
2340 } else if (bmval1
) {
2341 p
= xdr_reserve_space(xdr
, 12);
2344 *p
++ = cpu_to_be32(2);
2345 *p
++ = cpu_to_be32(bmval0
);
2346 *p
++ = cpu_to_be32(bmval1
);
2348 p
= xdr_reserve_space(xdr
, 8);
2351 *p
++ = cpu_to_be32(1);
2352 *p
++ = cpu_to_be32(bmval0
);
2357 return nfserr_resource
;
2361 * Note: @fhp can be NULL; in this case, we might have to compose the filehandle
2365 nfsd4_encode_fattr(struct xdr_stream
*xdr
, struct svc_fh
*fhp
,
2366 struct svc_export
*exp
,
2367 struct dentry
*dentry
, u32
*bmval
,
2368 struct svc_rqst
*rqstp
, int ignore_crossmnt
)
2370 u32 bmval0
= bmval
[0];
2371 u32 bmval1
= bmval
[1];
2372 u32 bmval2
= bmval
[2];
2374 struct svc_fh
*tempfh
= NULL
;
2375 struct kstatfs statfs
;
2377 int starting_len
= xdr
->buf
->len
;
2385 struct nfs4_acl
*acl
= NULL
;
2386 void *context
= NULL
;
2388 bool contextsupport
= false;
2389 struct nfsd4_compoundres
*resp
= rqstp
->rq_resp
;
2390 u32 minorversion
= resp
->cstate
.minorversion
;
2391 struct path path
= {
2392 .mnt
= exp
->ex_path
.mnt
,
2395 struct nfsd_net
*nn
= net_generic(SVC_NET(rqstp
), nfsd_net_id
);
2397 BUG_ON(bmval1
& NFSD_WRITEONLY_ATTRS_WORD1
);
2398 BUG_ON(!nfsd_attrs_supported(minorversion
, bmval
));
2400 if (exp
->ex_fslocs
.migrated
) {
2401 status
= fattr_handle_absent_fs(&bmval0
, &bmval1
, &bmval2
, &rdattr_err
);
2406 err
= vfs_getattr(&path
, &stat
, STATX_BASIC_STATS
, AT_STATX_SYNC_AS_STAT
);
2409 if ((bmval0
& (FATTR4_WORD0_FILES_AVAIL
| FATTR4_WORD0_FILES_FREE
|
2410 FATTR4_WORD0_FILES_TOTAL
| FATTR4_WORD0_MAXNAME
)) ||
2411 (bmval1
& (FATTR4_WORD1_SPACE_AVAIL
| FATTR4_WORD1_SPACE_FREE
|
2412 FATTR4_WORD1_SPACE_TOTAL
))) {
2413 err
= vfs_statfs(&path
, &statfs
);
2417 if ((bmval0
& (FATTR4_WORD0_FILEHANDLE
| FATTR4_WORD0_FSID
)) && !fhp
) {
2418 tempfh
= kmalloc(sizeof(struct svc_fh
), GFP_KERNEL
);
2419 status
= nfserr_jukebox
;
2422 fh_init(tempfh
, NFS4_FHSIZE
);
2423 status
= fh_compose(tempfh
, exp
, dentry
, NULL
);
2428 if (bmval0
& FATTR4_WORD0_ACL
) {
2429 err
= nfsd4_get_nfs4_acl(rqstp
, dentry
, &acl
);
2430 if (err
== -EOPNOTSUPP
)
2431 bmval0
&= ~FATTR4_WORD0_ACL
;
2432 else if (err
== -EINVAL
) {
2433 status
= nfserr_attrnotsupp
;
2435 } else if (err
!= 0)
2439 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
2440 if ((bmval2
& FATTR4_WORD2_SECURITY_LABEL
) ||
2441 bmval0
& FATTR4_WORD0_SUPPORTED_ATTRS
) {
2442 if (exp
->ex_flags
& NFSEXP_SECURITY_LABEL
)
2443 err
= security_inode_getsecctx(d_inode(dentry
),
2444 &context
, &contextlen
);
2447 contextsupport
= (err
== 0);
2448 if (bmval2
& FATTR4_WORD2_SECURITY_LABEL
) {
2449 if (err
== -EOPNOTSUPP
)
2450 bmval2
&= ~FATTR4_WORD2_SECURITY_LABEL
;
2455 #endif /* CONFIG_NFSD_V4_SECURITY_LABEL */
2457 status
= nfsd4_encode_bitmap(xdr
, bmval0
, bmval1
, bmval2
);
2461 attrlen_offset
= xdr
->buf
->len
;
2462 p
= xdr_reserve_space(xdr
, 4);
2465 p
++; /* to be backfilled later */
2467 if (bmval0
& FATTR4_WORD0_SUPPORTED_ATTRS
) {
2470 memcpy(supp
, nfsd_suppattrs
[minorversion
], sizeof(supp
));
2472 if (!IS_POSIXACL(dentry
->d_inode
))
2473 supp
[0] &= ~FATTR4_WORD0_ACL
;
2474 if (!contextsupport
)
2475 supp
[2] &= ~FATTR4_WORD2_SECURITY_LABEL
;
2477 p
= xdr_reserve_space(xdr
, 12);
2480 *p
++ = cpu_to_be32(2);
2481 *p
++ = cpu_to_be32(supp
[0]);
2482 *p
++ = cpu_to_be32(supp
[1]);
2484 p
= xdr_reserve_space(xdr
, 16);
2487 *p
++ = cpu_to_be32(3);
2488 *p
++ = cpu_to_be32(supp
[0]);
2489 *p
++ = cpu_to_be32(supp
[1]);
2490 *p
++ = cpu_to_be32(supp
[2]);
2493 if (bmval0
& FATTR4_WORD0_TYPE
) {
2494 p
= xdr_reserve_space(xdr
, 4);
2497 dummy
= nfs4_file_type(stat
.mode
);
2498 if (dummy
== NF4BAD
) {
2499 status
= nfserr_serverfault
;
2502 *p
++ = cpu_to_be32(dummy
);
2504 if (bmval0
& FATTR4_WORD0_FH_EXPIRE_TYPE
) {
2505 p
= xdr_reserve_space(xdr
, 4);
2508 if (exp
->ex_flags
& NFSEXP_NOSUBTREECHECK
)
2509 *p
++ = cpu_to_be32(NFS4_FH_PERSISTENT
);
2511 *p
++ = cpu_to_be32(NFS4_FH_PERSISTENT
|
2512 NFS4_FH_VOL_RENAME
);
2514 if (bmval0
& FATTR4_WORD0_CHANGE
) {
2515 p
= xdr_reserve_space(xdr
, 8);
2518 p
= encode_change(p
, &stat
, d_inode(dentry
), exp
);
2520 if (bmval0
& FATTR4_WORD0_SIZE
) {
2521 p
= xdr_reserve_space(xdr
, 8);
2524 p
= xdr_encode_hyper(p
, stat
.size
);
2526 if (bmval0
& FATTR4_WORD0_LINK_SUPPORT
) {
2527 p
= xdr_reserve_space(xdr
, 4);
2530 *p
++ = cpu_to_be32(1);
2532 if (bmval0
& FATTR4_WORD0_SYMLINK_SUPPORT
) {
2533 p
= xdr_reserve_space(xdr
, 4);
2536 *p
++ = cpu_to_be32(1);
2538 if (bmval0
& FATTR4_WORD0_NAMED_ATTR
) {
2539 p
= xdr_reserve_space(xdr
, 4);
2542 *p
++ = cpu_to_be32(0);
2544 if (bmval0
& FATTR4_WORD0_FSID
) {
2545 p
= xdr_reserve_space(xdr
, 16);
2548 if (exp
->ex_fslocs
.migrated
) {
2549 p
= xdr_encode_hyper(p
, NFS4_REFERRAL_FSID_MAJOR
);
2550 p
= xdr_encode_hyper(p
, NFS4_REFERRAL_FSID_MINOR
);
2551 } else switch(fsid_source(fhp
)) {
2552 case FSIDSOURCE_FSID
:
2553 p
= xdr_encode_hyper(p
, (u64
)exp
->ex_fsid
);
2554 p
= xdr_encode_hyper(p
, (u64
)0);
2556 case FSIDSOURCE_DEV
:
2557 *p
++ = cpu_to_be32(0);
2558 *p
++ = cpu_to_be32(MAJOR(stat
.dev
));
2559 *p
++ = cpu_to_be32(0);
2560 *p
++ = cpu_to_be32(MINOR(stat
.dev
));
2562 case FSIDSOURCE_UUID
:
2563 p
= xdr_encode_opaque_fixed(p
, exp
->ex_uuid
,
2568 if (bmval0
& FATTR4_WORD0_UNIQUE_HANDLES
) {
2569 p
= xdr_reserve_space(xdr
, 4);
2572 *p
++ = cpu_to_be32(0);
2574 if (bmval0
& FATTR4_WORD0_LEASE_TIME
) {
2575 p
= xdr_reserve_space(xdr
, 4);
2578 *p
++ = cpu_to_be32(nn
->nfsd4_lease
);
2580 if (bmval0
& FATTR4_WORD0_RDATTR_ERROR
) {
2581 p
= xdr_reserve_space(xdr
, 4);
2584 *p
++ = cpu_to_be32(rdattr_err
);
2586 if (bmval0
& FATTR4_WORD0_ACL
) {
2587 struct nfs4_ace
*ace
;
2590 p
= xdr_reserve_space(xdr
, 4);
2594 *p
++ = cpu_to_be32(0);
2597 p
= xdr_reserve_space(xdr
, 4);
2600 *p
++ = cpu_to_be32(acl
->naces
);
2602 for (ace
= acl
->aces
; ace
< acl
->aces
+ acl
->naces
; ace
++) {
2603 p
= xdr_reserve_space(xdr
, 4*3);
2606 *p
++ = cpu_to_be32(ace
->type
);
2607 *p
++ = cpu_to_be32(ace
->flag
);
2608 *p
++ = cpu_to_be32(ace
->access_mask
&
2610 status
= nfsd4_encode_aclname(xdr
, rqstp
, ace
);
2616 if (bmval0
& FATTR4_WORD0_ACLSUPPORT
) {
2617 p
= xdr_reserve_space(xdr
, 4);
2620 *p
++ = cpu_to_be32(IS_POSIXACL(dentry
->d_inode
) ?
2621 ACL4_SUPPORT_ALLOW_ACL
|ACL4_SUPPORT_DENY_ACL
: 0);
2623 if (bmval0
& FATTR4_WORD0_CANSETTIME
) {
2624 p
= xdr_reserve_space(xdr
, 4);
2627 *p
++ = cpu_to_be32(1);
2629 if (bmval0
& FATTR4_WORD0_CASE_INSENSITIVE
) {
2630 p
= xdr_reserve_space(xdr
, 4);
2633 *p
++ = cpu_to_be32(0);
2635 if (bmval0
& FATTR4_WORD0_CASE_PRESERVING
) {
2636 p
= xdr_reserve_space(xdr
, 4);
2639 *p
++ = cpu_to_be32(1);
2641 if (bmval0
& FATTR4_WORD0_CHOWN_RESTRICTED
) {
2642 p
= xdr_reserve_space(xdr
, 4);
2645 *p
++ = cpu_to_be32(1);
2647 if (bmval0
& FATTR4_WORD0_FILEHANDLE
) {
2648 p
= xdr_reserve_space(xdr
, fhp
->fh_handle
.fh_size
+ 4);
2651 p
= xdr_encode_opaque(p
, &fhp
->fh_handle
.fh_base
,
2652 fhp
->fh_handle
.fh_size
);
2654 if (bmval0
& FATTR4_WORD0_FILEID
) {
2655 p
= xdr_reserve_space(xdr
, 8);
2658 p
= xdr_encode_hyper(p
, stat
.ino
);
2660 if (bmval0
& FATTR4_WORD0_FILES_AVAIL
) {
2661 p
= xdr_reserve_space(xdr
, 8);
2664 p
= xdr_encode_hyper(p
, (u64
) statfs
.f_ffree
);
2666 if (bmval0
& FATTR4_WORD0_FILES_FREE
) {
2667 p
= xdr_reserve_space(xdr
, 8);
2670 p
= xdr_encode_hyper(p
, (u64
) statfs
.f_ffree
);
2672 if (bmval0
& FATTR4_WORD0_FILES_TOTAL
) {
2673 p
= xdr_reserve_space(xdr
, 8);
2676 p
= xdr_encode_hyper(p
, (u64
) statfs
.f_files
);
2678 if (bmval0
& FATTR4_WORD0_FS_LOCATIONS
) {
2679 status
= nfsd4_encode_fs_locations(xdr
, rqstp
, exp
);
2683 if (bmval0
& FATTR4_WORD0_HOMOGENEOUS
) {
2684 p
= xdr_reserve_space(xdr
, 4);
2687 *p
++ = cpu_to_be32(1);
2689 if (bmval0
& FATTR4_WORD0_MAXFILESIZE
) {
2690 p
= xdr_reserve_space(xdr
, 8);
2693 p
= xdr_encode_hyper(p
, exp
->ex_path
.mnt
->mnt_sb
->s_maxbytes
);
2695 if (bmval0
& FATTR4_WORD0_MAXLINK
) {
2696 p
= xdr_reserve_space(xdr
, 4);
2699 *p
++ = cpu_to_be32(255);
2701 if (bmval0
& FATTR4_WORD0_MAXNAME
) {
2702 p
= xdr_reserve_space(xdr
, 4);
2705 *p
++ = cpu_to_be32(statfs
.f_namelen
);
2707 if (bmval0
& FATTR4_WORD0_MAXREAD
) {
2708 p
= xdr_reserve_space(xdr
, 8);
2711 p
= xdr_encode_hyper(p
, (u64
) svc_max_payload(rqstp
));
2713 if (bmval0
& FATTR4_WORD0_MAXWRITE
) {
2714 p
= xdr_reserve_space(xdr
, 8);
2717 p
= xdr_encode_hyper(p
, (u64
) svc_max_payload(rqstp
));
2719 if (bmval1
& FATTR4_WORD1_MODE
) {
2720 p
= xdr_reserve_space(xdr
, 4);
2723 *p
++ = cpu_to_be32(stat
.mode
& S_IALLUGO
);
2725 if (bmval1
& FATTR4_WORD1_NO_TRUNC
) {
2726 p
= xdr_reserve_space(xdr
, 4);
2729 *p
++ = cpu_to_be32(1);
2731 if (bmval1
& FATTR4_WORD1_NUMLINKS
) {
2732 p
= xdr_reserve_space(xdr
, 4);
2735 *p
++ = cpu_to_be32(stat
.nlink
);
2737 if (bmval1
& FATTR4_WORD1_OWNER
) {
2738 status
= nfsd4_encode_user(xdr
, rqstp
, stat
.uid
);
2742 if (bmval1
& FATTR4_WORD1_OWNER_GROUP
) {
2743 status
= nfsd4_encode_group(xdr
, rqstp
, stat
.gid
);
2747 if (bmval1
& FATTR4_WORD1_RAWDEV
) {
2748 p
= xdr_reserve_space(xdr
, 8);
2751 *p
++ = cpu_to_be32((u32
) MAJOR(stat
.rdev
));
2752 *p
++ = cpu_to_be32((u32
) MINOR(stat
.rdev
));
2754 if (bmval1
& FATTR4_WORD1_SPACE_AVAIL
) {
2755 p
= xdr_reserve_space(xdr
, 8);
2758 dummy64
= (u64
)statfs
.f_bavail
* (u64
)statfs
.f_bsize
;
2759 p
= xdr_encode_hyper(p
, dummy64
);
2761 if (bmval1
& FATTR4_WORD1_SPACE_FREE
) {
2762 p
= xdr_reserve_space(xdr
, 8);
2765 dummy64
= (u64
)statfs
.f_bfree
* (u64
)statfs
.f_bsize
;
2766 p
= xdr_encode_hyper(p
, dummy64
);
2768 if (bmval1
& FATTR4_WORD1_SPACE_TOTAL
) {
2769 p
= xdr_reserve_space(xdr
, 8);
2772 dummy64
= (u64
)statfs
.f_blocks
* (u64
)statfs
.f_bsize
;
2773 p
= xdr_encode_hyper(p
, dummy64
);
2775 if (bmval1
& FATTR4_WORD1_SPACE_USED
) {
2776 p
= xdr_reserve_space(xdr
, 8);
2779 dummy64
= (u64
)stat
.blocks
<< 9;
2780 p
= xdr_encode_hyper(p
, dummy64
);
2782 if (bmval1
& FATTR4_WORD1_TIME_ACCESS
) {
2783 p
= xdr_reserve_space(xdr
, 12);
2786 p
= xdr_encode_hyper(p
, (s64
)stat
.atime
.tv_sec
);
2787 *p
++ = cpu_to_be32(stat
.atime
.tv_nsec
);
2789 if (bmval1
& FATTR4_WORD1_TIME_DELTA
) {
2790 p
= xdr_reserve_space(xdr
, 12);
2793 *p
++ = cpu_to_be32(0);
2794 *p
++ = cpu_to_be32(1);
2795 *p
++ = cpu_to_be32(0);
2797 if (bmval1
& FATTR4_WORD1_TIME_METADATA
) {
2798 p
= xdr_reserve_space(xdr
, 12);
2801 p
= xdr_encode_hyper(p
, (s64
)stat
.ctime
.tv_sec
);
2802 *p
++ = cpu_to_be32(stat
.ctime
.tv_nsec
);
2804 if (bmval1
& FATTR4_WORD1_TIME_MODIFY
) {
2805 p
= xdr_reserve_space(xdr
, 12);
2808 p
= xdr_encode_hyper(p
, (s64
)stat
.mtime
.tv_sec
);
2809 *p
++ = cpu_to_be32(stat
.mtime
.tv_nsec
);
2811 if (bmval1
& FATTR4_WORD1_MOUNTED_ON_FILEID
) {
2812 struct kstat parent_stat
;
2815 p
= xdr_reserve_space(xdr
, 8);
2819 * Get parent's attributes if not ignoring crossmount
2820 * and this is the root of a cross-mounted filesystem.
2822 if (ignore_crossmnt
== 0 &&
2823 dentry
== exp
->ex_path
.mnt
->mnt_root
) {
2824 err
= get_parent_attributes(exp
, &parent_stat
);
2827 ino
= parent_stat
.ino
;
2829 p
= xdr_encode_hyper(p
, ino
);
2831 #ifdef CONFIG_NFSD_PNFS
2832 if (bmval1
& FATTR4_WORD1_FS_LAYOUT_TYPES
) {
2833 status
= nfsd4_encode_layout_types(xdr
, exp
->ex_layout_types
);
2838 if (bmval2
& FATTR4_WORD2_LAYOUT_TYPES
) {
2839 status
= nfsd4_encode_layout_types(xdr
, exp
->ex_layout_types
);
2844 if (bmval2
& FATTR4_WORD2_LAYOUT_BLKSIZE
) {
2845 p
= xdr_reserve_space(xdr
, 4);
2848 *p
++ = cpu_to_be32(stat
.blksize
);
2850 #endif /* CONFIG_NFSD_PNFS */
2851 if (bmval2
& FATTR4_WORD2_SUPPATTR_EXCLCREAT
) {
2854 memcpy(supp
, nfsd_suppattrs
[minorversion
], sizeof(supp
));
2855 supp
[0] &= NFSD_SUPPATTR_EXCLCREAT_WORD0
;
2856 supp
[1] &= NFSD_SUPPATTR_EXCLCREAT_WORD1
;
2857 supp
[2] &= NFSD_SUPPATTR_EXCLCREAT_WORD2
;
2859 status
= nfsd4_encode_bitmap(xdr
, supp
[0], supp
[1], supp
[2]);
2864 if (bmval2
& FATTR4_WORD2_SECURITY_LABEL
) {
2865 status
= nfsd4_encode_security_label(xdr
, rqstp
, context
,
2871 attrlen
= htonl(xdr
->buf
->len
- attrlen_offset
- 4);
2872 write_bytes_to_xdr_buf(xdr
->buf
, attrlen_offset
, &attrlen
, 4);
2876 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
2878 security_release_secctx(context
, contextlen
);
2879 #endif /* CONFIG_NFSD_V4_SECURITY_LABEL */
2886 xdr_truncate_encode(xdr
, starting_len
);
2889 status
= nfserrno(err
);
2892 status
= nfserr_resource
;
2896 static void svcxdr_init_encode_from_buffer(struct xdr_stream
*xdr
,
2897 struct xdr_buf
*buf
, __be32
*p
, int bytes
)
2899 xdr
->scratch
.iov_len
= 0;
2900 memset(buf
, 0, sizeof(struct xdr_buf
));
2901 buf
->head
[0].iov_base
= p
;
2902 buf
->head
[0].iov_len
= 0;
2905 xdr
->iov
= buf
->head
;
2907 xdr
->end
= (void *)p
+ bytes
;
2908 buf
->buflen
= bytes
;
2911 __be32
nfsd4_encode_fattr_to_buf(__be32
**p
, int words
,
2912 struct svc_fh
*fhp
, struct svc_export
*exp
,
2913 struct dentry
*dentry
, u32
*bmval
,
2914 struct svc_rqst
*rqstp
, int ignore_crossmnt
)
2916 struct xdr_buf dummy
;
2917 struct xdr_stream xdr
;
2920 svcxdr_init_encode_from_buffer(&xdr
, &dummy
, *p
, words
<< 2);
2921 ret
= nfsd4_encode_fattr(&xdr
, fhp
, exp
, dentry
, bmval
, rqstp
,
2927 static inline int attributes_need_mount(u32
*bmval
)
2929 if (bmval
[0] & ~(FATTR4_WORD0_RDATTR_ERROR
| FATTR4_WORD0_LEASE_TIME
))
2931 if (bmval
[1] & ~FATTR4_WORD1_MOUNTED_ON_FILEID
)
2937 nfsd4_encode_dirent_fattr(struct xdr_stream
*xdr
, struct nfsd4_readdir
*cd
,
2938 const char *name
, int namlen
)
2940 struct svc_export
*exp
= cd
->rd_fhp
->fh_export
;
2941 struct dentry
*dentry
;
2943 int ignore_crossmnt
= 0;
2945 dentry
= lookup_one_len_unlocked(name
, cd
->rd_fhp
->fh_dentry
, namlen
);
2947 return nfserrno(PTR_ERR(dentry
));
2948 if (d_really_is_negative(dentry
)) {
2950 * we're not holding the i_mutex here, so there's
2951 * a window where this directory entry could have gone
2955 return nfserr_noent
;
2960 * In the case of a mountpoint, the client may be asking for
2961 * attributes that are only properties of the underlying filesystem
2962 * as opposed to the cross-mounted file system. In such a case,
2963 * we will not follow the cross mount and will fill the attribtutes
2964 * directly from the mountpoint dentry.
2966 if (nfsd_mountpoint(dentry
, exp
)) {
2969 if (!(exp
->ex_flags
& NFSEXP_V4ROOT
)
2970 && !attributes_need_mount(cd
->rd_bmval
)) {
2971 ignore_crossmnt
= 1;
2975 * Why the heck aren't we just using nfsd_lookup??
2976 * Different "."/".." handling? Something else?
2977 * At least, add a comment here to explain....
2979 err
= nfsd_cross_mnt(cd
->rd_rqstp
, &dentry
, &exp
);
2981 nfserr
= nfserrno(err
);
2984 nfserr
= check_nfsd_access(exp
, cd
->rd_rqstp
);
2990 nfserr
= nfsd4_encode_fattr(xdr
, NULL
, exp
, dentry
, cd
->rd_bmval
,
2991 cd
->rd_rqstp
, ignore_crossmnt
);
2999 nfsd4_encode_rdattr_error(struct xdr_stream
*xdr
, __be32 nfserr
)
3003 p
= xdr_reserve_space(xdr
, 20);
3007 *p
++ = htonl(FATTR4_WORD0_RDATTR_ERROR
); /* bmval0 */
3008 *p
++ = htonl(0); /* bmval1 */
3010 *p
++ = htonl(4); /* attribute length */
3011 *p
++ = nfserr
; /* no htonl */
3016 nfsd4_encode_dirent(void *ccdv
, const char *name
, int namlen
,
3017 loff_t offset
, u64 ino
, unsigned int d_type
)
3019 struct readdir_cd
*ccd
= ccdv
;
3020 struct nfsd4_readdir
*cd
= container_of(ccd
, struct nfsd4_readdir
, common
);
3021 struct xdr_stream
*xdr
= cd
->xdr
;
3022 int start_offset
= xdr
->buf
->len
;
3024 u32 name_and_cookie
;
3026 __be32 nfserr
= nfserr_toosmall
;
3030 /* In nfsv4, "." and ".." never make it onto the wire.. */
3031 if (name
&& isdotent(name
, namlen
)) {
3032 cd
->common
.err
= nfs_ok
;
3036 if (cd
->cookie_offset
) {
3037 wire_offset
= cpu_to_be64(offset
);
3038 write_bytes_to_xdr_buf(xdr
->buf
, cd
->cookie_offset
,
3042 p
= xdr_reserve_space(xdr
, 4);
3045 *p
++ = xdr_one
; /* mark entry present */
3046 cookie_offset
= xdr
->buf
->len
;
3047 p
= xdr_reserve_space(xdr
, 3*4 + namlen
);
3050 p
= xdr_encode_hyper(p
, NFS_OFFSET_MAX
); /* offset of next entry */
3051 p
= xdr_encode_array(p
, name
, namlen
); /* name length & name */
3053 nfserr
= nfsd4_encode_dirent_fattr(xdr
, cd
, name
, namlen
);
3057 case nfserr_resource
:
3058 nfserr
= nfserr_toosmall
;
3061 xdr_truncate_encode(xdr
, start_offset
);
3065 * If the client requested the RDATTR_ERROR attribute,
3066 * we stuff the error code into this attribute
3067 * and continue. If this attribute was not requested,
3068 * then in accordance with the spec, we fail the
3069 * entire READDIR operation(!)
3071 if (!(cd
->rd_bmval
[0] & FATTR4_WORD0_RDATTR_ERROR
))
3073 p
= nfsd4_encode_rdattr_error(xdr
, nfserr
);
3075 nfserr
= nfserr_toosmall
;
3079 nfserr
= nfserr_toosmall
;
3080 entry_bytes
= xdr
->buf
->len
- start_offset
;
3081 if (entry_bytes
> cd
->rd_maxcount
)
3083 cd
->rd_maxcount
-= entry_bytes
;
3085 * RFC 3530 14.2.24 describes rd_dircount as only a "hint", so
3086 * let's always let through the first entry, at least:
3088 if (!cd
->rd_dircount
)
3090 name_and_cookie
= 4 + 4 * XDR_QUADLEN(namlen
) + 8;
3091 if (name_and_cookie
> cd
->rd_dircount
&& cd
->cookie_offset
)
3093 cd
->rd_dircount
-= min(cd
->rd_dircount
, name_and_cookie
);
3095 cd
->cookie_offset
= cookie_offset
;
3097 cd
->common
.err
= nfs_ok
;
3100 xdr_truncate_encode(xdr
, start_offset
);
3101 cd
->common
.err
= nfserr
;
3106 nfsd4_encode_stateid(struct xdr_stream
*xdr
, stateid_t
*sid
)
3110 p
= xdr_reserve_space(xdr
, sizeof(stateid_t
));
3112 return nfserr_resource
;
3113 *p
++ = cpu_to_be32(sid
->si_generation
);
3114 p
= xdr_encode_opaque_fixed(p
, &sid
->si_opaque
,
3115 sizeof(stateid_opaque_t
));
3120 nfsd4_encode_access(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_access
*access
)
3122 struct xdr_stream
*xdr
= &resp
->xdr
;
3125 p
= xdr_reserve_space(xdr
, 8);
3127 return nfserr_resource
;
3128 *p
++ = cpu_to_be32(access
->ac_supported
);
3129 *p
++ = cpu_to_be32(access
->ac_resp_access
);
3133 static __be32
nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_bind_conn_to_session
*bcts
)
3135 struct xdr_stream
*xdr
= &resp
->xdr
;
3138 p
= xdr_reserve_space(xdr
, NFS4_MAX_SESSIONID_LEN
+ 8);
3140 return nfserr_resource
;
3141 p
= xdr_encode_opaque_fixed(p
, bcts
->sessionid
.data
,
3142 NFS4_MAX_SESSIONID_LEN
);
3143 *p
++ = cpu_to_be32(bcts
->dir
);
3144 /* Upshifting from TCP to RDMA is not supported */
3145 *p
++ = cpu_to_be32(0);
3150 nfsd4_encode_close(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_close
*close
)
3152 struct xdr_stream
*xdr
= &resp
->xdr
;
3154 return nfsd4_encode_stateid(xdr
, &close
->cl_stateid
);
3159 nfsd4_encode_commit(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_commit
*commit
)
3161 struct xdr_stream
*xdr
= &resp
->xdr
;
3164 p
= xdr_reserve_space(xdr
, NFS4_VERIFIER_SIZE
);
3166 return nfserr_resource
;
3167 p
= xdr_encode_opaque_fixed(p
, commit
->co_verf
.data
,
3168 NFS4_VERIFIER_SIZE
);
3173 nfsd4_encode_create(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_create
*create
)
3175 struct xdr_stream
*xdr
= &resp
->xdr
;
3178 p
= xdr_reserve_space(xdr
, 20);
3180 return nfserr_resource
;
3181 encode_cinfo(p
, &create
->cr_cinfo
);
3182 nfserr
= nfsd4_encode_bitmap(xdr
, create
->cr_bmval
[0],
3183 create
->cr_bmval
[1], create
->cr_bmval
[2]);
3188 nfsd4_encode_getattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_getattr
*getattr
)
3190 struct svc_fh
*fhp
= getattr
->ga_fhp
;
3191 struct xdr_stream
*xdr
= &resp
->xdr
;
3193 return nfsd4_encode_fattr(xdr
, fhp
, fhp
->fh_export
, fhp
->fh_dentry
,
3194 getattr
->ga_bmval
, resp
->rqstp
, 0);
3198 nfsd4_encode_getfh(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct svc_fh
**fhpp
)
3200 struct xdr_stream
*xdr
= &resp
->xdr
;
3201 struct svc_fh
*fhp
= *fhpp
;
3205 len
= fhp
->fh_handle
.fh_size
;
3206 p
= xdr_reserve_space(xdr
, len
+ 4);
3208 return nfserr_resource
;
3209 p
= xdr_encode_opaque(p
, &fhp
->fh_handle
.fh_base
, len
);
3214 * Including all fields other than the name, a LOCK4denied structure requires
3215 * 8(clientid) + 4(namelen) + 8(offset) + 8(length) + 4(type) = 32 bytes.
3218 nfsd4_encode_lock_denied(struct xdr_stream
*xdr
, struct nfsd4_lock_denied
*ld
)
3220 struct xdr_netobj
*conf
= &ld
->ld_owner
;
3224 p
= xdr_reserve_space(xdr
, 32 + XDR_LEN(conf
->len
));
3227 * Don't fail to return the result just because we can't
3228 * return the conflicting open:
3236 return nfserr_resource
;
3238 p
= xdr_encode_hyper(p
, ld
->ld_start
);
3239 p
= xdr_encode_hyper(p
, ld
->ld_length
);
3240 *p
++ = cpu_to_be32(ld
->ld_type
);
3242 p
= xdr_encode_opaque_fixed(p
, &ld
->ld_clientid
, 8);
3243 p
= xdr_encode_opaque(p
, conf
->data
, conf
->len
);
3245 } else { /* non - nfsv4 lock in conflict, no clientid nor owner */
3246 p
= xdr_encode_hyper(p
, (u64
)0); /* clientid */
3247 *p
++ = cpu_to_be32(0); /* length of owner name */
3249 return nfserr_denied
;
3253 nfsd4_encode_lock(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_lock
*lock
)
3255 struct xdr_stream
*xdr
= &resp
->xdr
;
3258 nfserr
= nfsd4_encode_stateid(xdr
, &lock
->lk_resp_stateid
);
3259 else if (nfserr
== nfserr_denied
)
3260 nfserr
= nfsd4_encode_lock_denied(xdr
, &lock
->lk_denied
);
3266 nfsd4_encode_lockt(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_lockt
*lockt
)
3268 struct xdr_stream
*xdr
= &resp
->xdr
;
3270 if (nfserr
== nfserr_denied
)
3271 nfsd4_encode_lock_denied(xdr
, &lockt
->lt_denied
);
3276 nfsd4_encode_locku(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_locku
*locku
)
3278 struct xdr_stream
*xdr
= &resp
->xdr
;
3280 return nfsd4_encode_stateid(xdr
, &locku
->lu_stateid
);
3285 nfsd4_encode_link(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_link
*link
)
3287 struct xdr_stream
*xdr
= &resp
->xdr
;
3290 p
= xdr_reserve_space(xdr
, 20);
3292 return nfserr_resource
;
3293 p
= encode_cinfo(p
, &link
->li_cinfo
);
3299 nfsd4_encode_open(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open
*open
)
3301 struct xdr_stream
*xdr
= &resp
->xdr
;
3304 nfserr
= nfsd4_encode_stateid(xdr
, &open
->op_stateid
);
3307 p
= xdr_reserve_space(xdr
, 24);
3309 return nfserr_resource
;
3310 p
= encode_cinfo(p
, &open
->op_cinfo
);
3311 *p
++ = cpu_to_be32(open
->op_rflags
);
3313 nfserr
= nfsd4_encode_bitmap(xdr
, open
->op_bmval
[0], open
->op_bmval
[1],
3318 p
= xdr_reserve_space(xdr
, 4);
3320 return nfserr_resource
;
3322 *p
++ = cpu_to_be32(open
->op_delegate_type
);
3323 switch (open
->op_delegate_type
) {
3324 case NFS4_OPEN_DELEGATE_NONE
:
3326 case NFS4_OPEN_DELEGATE_READ
:
3327 nfserr
= nfsd4_encode_stateid(xdr
, &open
->op_delegate_stateid
);
3330 p
= xdr_reserve_space(xdr
, 20);
3332 return nfserr_resource
;
3333 *p
++ = cpu_to_be32(open
->op_recall
);
3336 * TODO: ACE's in delegations
3338 *p
++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE
);
3339 *p
++ = cpu_to_be32(0);
3340 *p
++ = cpu_to_be32(0);
3341 *p
++ = cpu_to_be32(0); /* XXX: is NULL principal ok? */
3343 case NFS4_OPEN_DELEGATE_WRITE
:
3344 nfserr
= nfsd4_encode_stateid(xdr
, &open
->op_delegate_stateid
);
3347 p
= xdr_reserve_space(xdr
, 32);
3349 return nfserr_resource
;
3350 *p
++ = cpu_to_be32(0);
3353 * TODO: space_limit's in delegations
3355 *p
++ = cpu_to_be32(NFS4_LIMIT_SIZE
);
3356 *p
++ = cpu_to_be32(~(u32
)0);
3357 *p
++ = cpu_to_be32(~(u32
)0);
3360 * TODO: ACE's in delegations
3362 *p
++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE
);
3363 *p
++ = cpu_to_be32(0);
3364 *p
++ = cpu_to_be32(0);
3365 *p
++ = cpu_to_be32(0); /* XXX: is NULL principal ok? */
3367 case NFS4_OPEN_DELEGATE_NONE_EXT
: /* 4.1 */
3368 switch (open
->op_why_no_deleg
) {
3369 case WND4_CONTENTION
:
3371 p
= xdr_reserve_space(xdr
, 8);
3373 return nfserr_resource
;
3374 *p
++ = cpu_to_be32(open
->op_why_no_deleg
);
3375 /* deleg signaling not supported yet: */
3376 *p
++ = cpu_to_be32(0);
3379 p
= xdr_reserve_space(xdr
, 4);
3381 return nfserr_resource
;
3382 *p
++ = cpu_to_be32(open
->op_why_no_deleg
);
3388 /* XXX save filehandle here */
3393 nfsd4_encode_open_confirm(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open_confirm
*oc
)
3395 struct xdr_stream
*xdr
= &resp
->xdr
;
3397 return nfsd4_encode_stateid(xdr
, &oc
->oc_resp_stateid
);
3401 nfsd4_encode_open_downgrade(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open_downgrade
*od
)
3403 struct xdr_stream
*xdr
= &resp
->xdr
;
3405 return nfsd4_encode_stateid(xdr
, &od
->od_stateid
);
3408 static __be32
nfsd4_encode_splice_read(
3409 struct nfsd4_compoundres
*resp
,
3410 struct nfsd4_read
*read
,
3411 struct file
*file
, unsigned long maxcount
)
3413 struct xdr_stream
*xdr
= &resp
->xdr
;
3414 struct xdr_buf
*buf
= xdr
->buf
;
3419 __be32
*p
= xdr
->p
- 2;
3421 /* Make sure there will be room for padding if needed */
3422 if (xdr
->end
- xdr
->p
< 1)
3423 return nfserr_resource
;
3426 nfserr
= nfsd_splice_read(read
->rd_rqstp
, file
,
3427 read
->rd_offset
, &maxcount
);
3430 * nfsd_splice_actor may have already messed with the
3431 * page length; reset it so as not to confuse
3432 * xdr_truncate_encode:
3438 eof
= nfsd_eof_on_read(len
, maxcount
, read
->rd_offset
,
3439 d_inode(read
->rd_fhp
->fh_dentry
)->i_size
);
3441 *(p
++) = htonl(eof
);
3442 *(p
++) = htonl(maxcount
);
3444 buf
->page_len
= maxcount
;
3445 buf
->len
+= maxcount
;
3446 xdr
->page_ptr
+= (buf
->page_base
+ maxcount
+ PAGE_SIZE
- 1)
3449 /* Use rest of head for padding and remaining ops: */
3450 buf
->tail
[0].iov_base
= xdr
->p
;
3451 buf
->tail
[0].iov_len
= 0;
3452 xdr
->iov
= buf
->tail
;
3454 int pad
= 4 - (maxcount
&3);
3458 buf
->tail
[0].iov_base
+= maxcount
&3;
3459 buf
->tail
[0].iov_len
= pad
;
3463 space_left
= min_t(int, (void *)xdr
->end
- (void *)xdr
->p
,
3464 buf
->buflen
- buf
->len
);
3465 buf
->buflen
= buf
->len
+ space_left
;
3466 xdr
->end
= (__be32
*)((void *)xdr
->end
+ space_left
);
3471 static __be32
nfsd4_encode_readv(struct nfsd4_compoundres
*resp
,
3472 struct nfsd4_read
*read
,
3473 struct file
*file
, unsigned long maxcount
)
3475 struct xdr_stream
*xdr
= &resp
->xdr
;
3478 int starting_len
= xdr
->buf
->len
- 8;
3490 thislen
= min_t(long, len
, ((void *)xdr
->end
- (void *)xdr
->p
));
3491 p
= xdr_reserve_space(xdr
, (thislen
+3)&~3);
3493 resp
->rqstp
->rq_vec
[v
].iov_base
= p
;
3494 resp
->rqstp
->rq_vec
[v
].iov_len
= thislen
;
3499 thislen
= min_t(long, len
, PAGE_SIZE
);
3500 p
= xdr_reserve_space(xdr
, (thislen
+3)&~3);
3502 resp
->rqstp
->rq_vec
[v
].iov_base
= p
;
3503 resp
->rqstp
->rq_vec
[v
].iov_len
= thislen
;
3510 nfserr
= nfsd_readv(file
, read
->rd_offset
, resp
->rqstp
->rq_vec
,
3511 read
->rd_vlen
, &maxcount
);
3514 xdr_truncate_encode(xdr
, starting_len
+ 8 + ((maxcount
+3)&~3));
3516 eof
= nfsd_eof_on_read(len
, maxcount
, read
->rd_offset
,
3517 d_inode(read
->rd_fhp
->fh_dentry
)->i_size
);
3520 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
, &tmp
, 4);
3521 tmp
= htonl(maxcount
);
3522 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
+ 4, &tmp
, 4);
3524 pad
= (maxcount
&3) ? 4 - (maxcount
&3) : 0;
3525 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
+ 8 + maxcount
,
3532 nfsd4_encode_read(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
3533 struct nfsd4_read
*read
)
3535 unsigned long maxcount
;
3536 struct xdr_stream
*xdr
= &resp
->xdr
;
3537 struct file
*file
= read
->rd_filp
;
3538 int starting_len
= xdr
->buf
->len
;
3539 struct raparms
*ra
= NULL
;
3542 p
= xdr_reserve_space(xdr
, 8); /* eof flag and byte count */
3544 WARN_ON_ONCE(test_bit(RQ_SPLICE_OK
, &resp
->rqstp
->rq_flags
));
3545 return nfserr_resource
;
3547 if (resp
->xdr
.buf
->page_len
&&
3548 test_bit(RQ_SPLICE_OK
, &resp
->rqstp
->rq_flags
)) {
3550 return nfserr_resource
;
3552 xdr_commit_encode(xdr
);
3554 maxcount
= svc_max_payload(resp
->rqstp
);
3555 maxcount
= min_t(unsigned long, maxcount
,
3556 (xdr
->buf
->buflen
- xdr
->buf
->len
));
3557 maxcount
= min_t(unsigned long, maxcount
, read
->rd_length
);
3559 if (read
->rd_tmp_file
)
3560 ra
= nfsd_init_raparms(file
);
3562 if (file
->f_op
->splice_read
&&
3563 test_bit(RQ_SPLICE_OK
, &resp
->rqstp
->rq_flags
))
3564 nfserr
= nfsd4_encode_splice_read(resp
, read
, file
, maxcount
);
3566 nfserr
= nfsd4_encode_readv(resp
, read
, file
, maxcount
);
3569 nfsd_put_raparams(file
, ra
);
3572 xdr_truncate_encode(xdr
, starting_len
);
3578 nfsd4_encode_readlink(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_readlink
*readlink
)
3583 struct xdr_stream
*xdr
= &resp
->xdr
;
3584 int length_offset
= xdr
->buf
->len
;
3587 p
= xdr_reserve_space(xdr
, 4);
3589 return nfserr_resource
;
3590 maxcount
= PAGE_SIZE
;
3592 p
= xdr_reserve_space(xdr
, maxcount
);
3594 return nfserr_resource
;
3596 * XXX: By default, vfs_readlink() will truncate symlinks if they
3597 * would overflow the buffer. Is this kosher in NFSv4? If not, one
3598 * easy fix is: if vfs_readlink() precisely fills the buffer, assume
3599 * that truncation occurred, and return NFS4ERR_RESOURCE.
3601 nfserr
= nfsd_readlink(readlink
->rl_rqstp
, readlink
->rl_fhp
,
3602 (char *)p
, &maxcount
);
3603 if (nfserr
== nfserr_isdir
)
3604 nfserr
= nfserr_inval
;
3606 xdr_truncate_encode(xdr
, length_offset
);
3610 wire_count
= htonl(maxcount
);
3611 write_bytes_to_xdr_buf(xdr
->buf
, length_offset
, &wire_count
, 4);
3612 xdr_truncate_encode(xdr
, length_offset
+ 4 + ALIGN(maxcount
, 4));
3614 write_bytes_to_xdr_buf(xdr
->buf
, length_offset
+ 4 + maxcount
,
3615 &zero
, 4 - (maxcount
&3));
3620 nfsd4_encode_readdir(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_readdir
*readdir
)
3626 struct xdr_stream
*xdr
= &resp
->xdr
;
3627 int starting_len
= xdr
->buf
->len
;
3630 p
= xdr_reserve_space(xdr
, NFS4_VERIFIER_SIZE
);
3632 return nfserr_resource
;
3634 /* XXX: Following NFSv3, we ignore the READDIR verifier for now. */
3635 *p
++ = cpu_to_be32(0);
3636 *p
++ = cpu_to_be32(0);
3637 resp
->xdr
.buf
->head
[0].iov_len
= ((char *)resp
->xdr
.p
)
3638 - (char *)resp
->xdr
.buf
->head
[0].iov_base
;
3641 * Number of bytes left for directory entries allowing for the
3642 * final 8 bytes of the readdir and a following failed op:
3644 bytes_left
= xdr
->buf
->buflen
- xdr
->buf
->len
3645 - COMPOUND_ERR_SLACK_SPACE
- 8;
3646 if (bytes_left
< 0) {
3647 nfserr
= nfserr_resource
;
3650 maxcount
= min_t(u32
, readdir
->rd_maxcount
, INT_MAX
);
3652 * Note the rfc defines rd_maxcount as the size of the
3653 * READDIR4resok structure, which includes the verifier above
3654 * and the 8 bytes encoded at the end of this function:
3656 if (maxcount
< 16) {
3657 nfserr
= nfserr_toosmall
;
3660 maxcount
= min_t(int, maxcount
-16, bytes_left
);
3662 /* RFC 3530 14.2.24 allows us to ignore dircount when it's 0: */
3663 if (!readdir
->rd_dircount
)
3664 readdir
->rd_dircount
= INT_MAX
;
3667 readdir
->rd_maxcount
= maxcount
;
3668 readdir
->common
.err
= 0;
3669 readdir
->cookie_offset
= 0;
3671 offset
= readdir
->rd_cookie
;
3672 nfserr
= nfsd_readdir(readdir
->rd_rqstp
, readdir
->rd_fhp
,
3674 &readdir
->common
, nfsd4_encode_dirent
);
3675 if (nfserr
== nfs_ok
&&
3676 readdir
->common
.err
== nfserr_toosmall
&&
3677 xdr
->buf
->len
== starting_len
+ 8) {
3678 /* nothing encoded; which limit did we hit?: */
3679 if (maxcount
- 16 < bytes_left
)
3680 /* It was the fault of rd_maxcount: */
3681 nfserr
= nfserr_toosmall
;
3683 /* We ran out of buffer space: */
3684 nfserr
= nfserr_resource
;
3689 if (readdir
->cookie_offset
) {
3690 wire_offset
= cpu_to_be64(offset
);
3691 write_bytes_to_xdr_buf(xdr
->buf
, readdir
->cookie_offset
,
3695 p
= xdr_reserve_space(xdr
, 8);
3700 *p
++ = 0; /* no more entries */
3701 *p
++ = htonl(readdir
->common
.err
== nfserr_eof
);
3705 xdr_truncate_encode(xdr
, starting_len
);
3710 nfsd4_encode_remove(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_remove
*remove
)
3712 struct xdr_stream
*xdr
= &resp
->xdr
;
3715 p
= xdr_reserve_space(xdr
, 20);
3717 return nfserr_resource
;
3718 p
= encode_cinfo(p
, &remove
->rm_cinfo
);
3723 nfsd4_encode_rename(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_rename
*rename
)
3725 struct xdr_stream
*xdr
= &resp
->xdr
;
3728 p
= xdr_reserve_space(xdr
, 40);
3730 return nfserr_resource
;
3731 p
= encode_cinfo(p
, &rename
->rn_sinfo
);
3732 p
= encode_cinfo(p
, &rename
->rn_tinfo
);
3737 nfsd4_do_encode_secinfo(struct xdr_stream
*xdr
, struct svc_export
*exp
)
3739 u32 i
, nflavs
, supported
;
3740 struct exp_flavor_info
*flavs
;
3741 struct exp_flavor_info def_flavs
[2];
3742 __be32
*p
, *flavorsp
;
3743 static bool report
= true;
3745 if (exp
->ex_nflavors
) {
3746 flavs
= exp
->ex_flavors
;
3747 nflavs
= exp
->ex_nflavors
;
3748 } else { /* Handling of some defaults in absence of real secinfo: */
3750 if (exp
->ex_client
->flavour
->flavour
== RPC_AUTH_UNIX
) {
3752 flavs
[0].pseudoflavor
= RPC_AUTH_UNIX
;
3753 flavs
[1].pseudoflavor
= RPC_AUTH_NULL
;
3754 } else if (exp
->ex_client
->flavour
->flavour
== RPC_AUTH_GSS
) {
3756 flavs
[0].pseudoflavor
3757 = svcauth_gss_flavor(exp
->ex_client
);
3760 flavs
[0].pseudoflavor
3761 = exp
->ex_client
->flavour
->flavour
;
3766 p
= xdr_reserve_space(xdr
, 4);
3768 return nfserr_resource
;
3769 flavorsp
= p
++; /* to be backfilled later */
3771 for (i
= 0; i
< nflavs
; i
++) {
3772 rpc_authflavor_t pf
= flavs
[i
].pseudoflavor
;
3773 struct rpcsec_gss_info info
;
3775 if (rpcauth_get_gssinfo(pf
, &info
) == 0) {
3777 p
= xdr_reserve_space(xdr
, 4 + 4 +
3778 XDR_LEN(info
.oid
.len
) + 4 + 4);
3780 return nfserr_resource
;
3781 *p
++ = cpu_to_be32(RPC_AUTH_GSS
);
3782 p
= xdr_encode_opaque(p
, info
.oid
.data
, info
.oid
.len
);
3783 *p
++ = cpu_to_be32(info
.qop
);
3784 *p
++ = cpu_to_be32(info
.service
);
3785 } else if (pf
< RPC_AUTH_MAXFLAVOR
) {
3787 p
= xdr_reserve_space(xdr
, 4);
3789 return nfserr_resource
;
3790 *p
++ = cpu_to_be32(pf
);
3793 pr_warn("NFS: SECINFO: security flavor %u "
3794 "is not supported\n", pf
);
3798 if (nflavs
!= supported
)
3800 *flavorsp
= htonl(supported
);
3805 nfsd4_encode_secinfo(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
3806 struct nfsd4_secinfo
*secinfo
)
3808 struct xdr_stream
*xdr
= &resp
->xdr
;
3810 return nfsd4_do_encode_secinfo(xdr
, secinfo
->si_exp
);
3814 nfsd4_encode_secinfo_no_name(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
3815 struct nfsd4_secinfo_no_name
*secinfo
)
3817 struct xdr_stream
*xdr
= &resp
->xdr
;
3819 return nfsd4_do_encode_secinfo(xdr
, secinfo
->sin_exp
);
3823 * The SETATTR encode routine is special -- it always encodes a bitmap,
3824 * regardless of the error status.
3827 nfsd4_encode_setattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_setattr
*setattr
)
3829 struct xdr_stream
*xdr
= &resp
->xdr
;
3832 p
= xdr_reserve_space(xdr
, 16);
3834 return nfserr_resource
;
3836 *p
++ = cpu_to_be32(3);
3837 *p
++ = cpu_to_be32(0);
3838 *p
++ = cpu_to_be32(0);
3839 *p
++ = cpu_to_be32(0);
3842 *p
++ = cpu_to_be32(3);
3843 *p
++ = cpu_to_be32(setattr
->sa_bmval
[0]);
3844 *p
++ = cpu_to_be32(setattr
->sa_bmval
[1]);
3845 *p
++ = cpu_to_be32(setattr
->sa_bmval
[2]);
3851 nfsd4_encode_setclientid(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_setclientid
*scd
)
3853 struct xdr_stream
*xdr
= &resp
->xdr
;
3857 p
= xdr_reserve_space(xdr
, 8 + NFS4_VERIFIER_SIZE
);
3859 return nfserr_resource
;
3860 p
= xdr_encode_opaque_fixed(p
, &scd
->se_clientid
, 8);
3861 p
= xdr_encode_opaque_fixed(p
, &scd
->se_confirm
,
3862 NFS4_VERIFIER_SIZE
);
3864 else if (nfserr
== nfserr_clid_inuse
) {
3865 p
= xdr_reserve_space(xdr
, 8);
3867 return nfserr_resource
;
3868 *p
++ = cpu_to_be32(0);
3869 *p
++ = cpu_to_be32(0);
3875 nfsd4_encode_write(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_write
*write
)
3877 struct xdr_stream
*xdr
= &resp
->xdr
;
3880 p
= xdr_reserve_space(xdr
, 16);
3882 return nfserr_resource
;
3883 *p
++ = cpu_to_be32(write
->wr_bytes_written
);
3884 *p
++ = cpu_to_be32(write
->wr_how_written
);
3885 p
= xdr_encode_opaque_fixed(p
, write
->wr_verifier
.data
,
3886 NFS4_VERIFIER_SIZE
);
3891 nfsd4_encode_exchange_id(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
3892 struct nfsd4_exchange_id
*exid
)
3894 struct xdr_stream
*xdr
= &resp
->xdr
;
3899 int server_scope_sz
;
3900 uint64_t minor_id
= 0;
3902 major_id
= utsname()->nodename
;
3903 major_id_sz
= strlen(major_id
);
3904 server_scope
= utsname()->nodename
;
3905 server_scope_sz
= strlen(server_scope
);
3907 p
= xdr_reserve_space(xdr
,
3908 8 /* eir_clientid */ +
3909 4 /* eir_sequenceid */ +
3913 return nfserr_resource
;
3915 p
= xdr_encode_opaque_fixed(p
, &exid
->clientid
, 8);
3916 *p
++ = cpu_to_be32(exid
->seqid
);
3917 *p
++ = cpu_to_be32(exid
->flags
);
3919 *p
++ = cpu_to_be32(exid
->spa_how
);
3921 switch (exid
->spa_how
) {
3925 /* spo_must_enforce bitmap: */
3926 nfserr
= nfsd4_encode_bitmap(xdr
,
3927 exid
->spo_must_enforce
[0],
3928 exid
->spo_must_enforce
[1],
3929 exid
->spo_must_enforce
[2]);
3932 /* spo_must_allow bitmap: */
3933 nfserr
= nfsd4_encode_bitmap(xdr
,
3934 exid
->spo_must_allow
[0],
3935 exid
->spo_must_allow
[1],
3936 exid
->spo_must_allow
[2]);
3944 p
= xdr_reserve_space(xdr
,
3945 8 /* so_minor_id */ +
3946 4 /* so_major_id.len */ +
3947 (XDR_QUADLEN(major_id_sz
) * 4) +
3948 4 /* eir_server_scope.len */ +
3949 (XDR_QUADLEN(server_scope_sz
) * 4) +
3950 4 /* eir_server_impl_id.count (0) */);
3952 return nfserr_resource
;
3954 /* The server_owner struct */
3955 p
= xdr_encode_hyper(p
, minor_id
); /* Minor id */
3957 p
= xdr_encode_opaque(p
, major_id
, major_id_sz
);
3960 p
= xdr_encode_opaque(p
, server_scope
, server_scope_sz
);
3962 /* Implementation id */
3963 *p
++ = cpu_to_be32(0); /* zero length nfs_impl_id4 array */
3968 nfsd4_encode_create_session(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
3969 struct nfsd4_create_session
*sess
)
3971 struct xdr_stream
*xdr
= &resp
->xdr
;
3974 p
= xdr_reserve_space(xdr
, 24);
3976 return nfserr_resource
;
3977 p
= xdr_encode_opaque_fixed(p
, sess
->sessionid
.data
,
3978 NFS4_MAX_SESSIONID_LEN
);
3979 *p
++ = cpu_to_be32(sess
->seqid
);
3980 *p
++ = cpu_to_be32(sess
->flags
);
3982 p
= xdr_reserve_space(xdr
, 28);
3984 return nfserr_resource
;
3985 *p
++ = cpu_to_be32(0); /* headerpadsz */
3986 *p
++ = cpu_to_be32(sess
->fore_channel
.maxreq_sz
);
3987 *p
++ = cpu_to_be32(sess
->fore_channel
.maxresp_sz
);
3988 *p
++ = cpu_to_be32(sess
->fore_channel
.maxresp_cached
);
3989 *p
++ = cpu_to_be32(sess
->fore_channel
.maxops
);
3990 *p
++ = cpu_to_be32(sess
->fore_channel
.maxreqs
);
3991 *p
++ = cpu_to_be32(sess
->fore_channel
.nr_rdma_attrs
);
3993 if (sess
->fore_channel
.nr_rdma_attrs
) {
3994 p
= xdr_reserve_space(xdr
, 4);
3996 return nfserr_resource
;
3997 *p
++ = cpu_to_be32(sess
->fore_channel
.rdma_attrs
);
4000 p
= xdr_reserve_space(xdr
, 28);
4002 return nfserr_resource
;
4003 *p
++ = cpu_to_be32(0); /* headerpadsz */
4004 *p
++ = cpu_to_be32(sess
->back_channel
.maxreq_sz
);
4005 *p
++ = cpu_to_be32(sess
->back_channel
.maxresp_sz
);
4006 *p
++ = cpu_to_be32(sess
->back_channel
.maxresp_cached
);
4007 *p
++ = cpu_to_be32(sess
->back_channel
.maxops
);
4008 *p
++ = cpu_to_be32(sess
->back_channel
.maxreqs
);
4009 *p
++ = cpu_to_be32(sess
->back_channel
.nr_rdma_attrs
);
4011 if (sess
->back_channel
.nr_rdma_attrs
) {
4012 p
= xdr_reserve_space(xdr
, 4);
4014 return nfserr_resource
;
4015 *p
++ = cpu_to_be32(sess
->back_channel
.rdma_attrs
);
4021 nfsd4_encode_sequence(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4022 struct nfsd4_sequence
*seq
)
4024 struct xdr_stream
*xdr
= &resp
->xdr
;
4027 p
= xdr_reserve_space(xdr
, NFS4_MAX_SESSIONID_LEN
+ 20);
4029 return nfserr_resource
;
4030 p
= xdr_encode_opaque_fixed(p
, seq
->sessionid
.data
,
4031 NFS4_MAX_SESSIONID_LEN
);
4032 *p
++ = cpu_to_be32(seq
->seqid
);
4033 *p
++ = cpu_to_be32(seq
->slotid
);
4034 /* Note slotid's are numbered from zero: */
4035 *p
++ = cpu_to_be32(seq
->maxslots
- 1); /* sr_highest_slotid */
4036 *p
++ = cpu_to_be32(seq
->maxslots
- 1); /* sr_target_highest_slotid */
4037 *p
++ = cpu_to_be32(seq
->status_flags
);
4039 resp
->cstate
.data_offset
= xdr
->buf
->len
; /* DRC cache data pointer */
4044 nfsd4_encode_test_stateid(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4045 struct nfsd4_test_stateid
*test_stateid
)
4047 struct xdr_stream
*xdr
= &resp
->xdr
;
4048 struct nfsd4_test_stateid_id
*stateid
, *next
;
4051 p
= xdr_reserve_space(xdr
, 4 + (4 * test_stateid
->ts_num_ids
));
4053 return nfserr_resource
;
4054 *p
++ = htonl(test_stateid
->ts_num_ids
);
4056 list_for_each_entry_safe(stateid
, next
, &test_stateid
->ts_stateid_list
, ts_id_list
) {
4057 *p
++ = stateid
->ts_id_status
;
4063 #ifdef CONFIG_NFSD_PNFS
4065 nfsd4_encode_getdeviceinfo(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4066 struct nfsd4_getdeviceinfo
*gdev
)
4068 struct xdr_stream
*xdr
= &resp
->xdr
;
4069 const struct nfsd4_layout_ops
*ops
;
4070 u32 starting_len
= xdr
->buf
->len
, needed_len
;
4073 p
= xdr_reserve_space(xdr
, 4);
4075 return nfserr_resource
;
4077 *p
++ = cpu_to_be32(gdev
->gd_layout_type
);
4079 /* If maxcount is 0 then just update notifications */
4080 if (gdev
->gd_maxcount
!= 0) {
4081 ops
= nfsd4_layout_ops
[gdev
->gd_layout_type
];
4082 nfserr
= ops
->encode_getdeviceinfo(xdr
, gdev
);
4085 * We don't bother to burden the layout drivers with
4086 * enforcing gd_maxcount, just tell the client to
4087 * come back with a bigger buffer if it's not enough.
4089 if (xdr
->buf
->len
+ 4 > gdev
->gd_maxcount
)
4095 if (gdev
->gd_notify_types
) {
4096 p
= xdr_reserve_space(xdr
, 4 + 4);
4098 return nfserr_resource
;
4099 *p
++ = cpu_to_be32(1); /* bitmap length */
4100 *p
++ = cpu_to_be32(gdev
->gd_notify_types
);
4102 p
= xdr_reserve_space(xdr
, 4);
4104 return nfserr_resource
;
4110 dprintk("%s: maxcount too small\n", __func__
);
4111 needed_len
= xdr
->buf
->len
+ 4 /* notifications */;
4112 xdr_truncate_encode(xdr
, starting_len
);
4113 p
= xdr_reserve_space(xdr
, 4);
4115 return nfserr_resource
;
4116 *p
++ = cpu_to_be32(needed_len
);
4117 return nfserr_toosmall
;
4121 nfsd4_encode_layoutget(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4122 struct nfsd4_layoutget
*lgp
)
4124 struct xdr_stream
*xdr
= &resp
->xdr
;
4125 const struct nfsd4_layout_ops
*ops
;
4128 p
= xdr_reserve_space(xdr
, 36 + sizeof(stateid_opaque_t
));
4130 return nfserr_resource
;
4132 *p
++ = cpu_to_be32(1); /* we always set return-on-close */
4133 *p
++ = cpu_to_be32(lgp
->lg_sid
.si_generation
);
4134 p
= xdr_encode_opaque_fixed(p
, &lgp
->lg_sid
.si_opaque
,
4135 sizeof(stateid_opaque_t
));
4137 *p
++ = cpu_to_be32(1); /* we always return a single layout */
4138 p
= xdr_encode_hyper(p
, lgp
->lg_seg
.offset
);
4139 p
= xdr_encode_hyper(p
, lgp
->lg_seg
.length
);
4140 *p
++ = cpu_to_be32(lgp
->lg_seg
.iomode
);
4141 *p
++ = cpu_to_be32(lgp
->lg_layout_type
);
4143 ops
= nfsd4_layout_ops
[lgp
->lg_layout_type
];
4144 return ops
->encode_layoutget(xdr
, lgp
);
4148 nfsd4_encode_layoutcommit(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4149 struct nfsd4_layoutcommit
*lcp
)
4151 struct xdr_stream
*xdr
= &resp
->xdr
;
4154 p
= xdr_reserve_space(xdr
, 4);
4156 return nfserr_resource
;
4157 *p
++ = cpu_to_be32(lcp
->lc_size_chg
);
4158 if (lcp
->lc_size_chg
) {
4159 p
= xdr_reserve_space(xdr
, 8);
4161 return nfserr_resource
;
4162 p
= xdr_encode_hyper(p
, lcp
->lc_newsize
);
4169 nfsd4_encode_layoutreturn(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4170 struct nfsd4_layoutreturn
*lrp
)
4172 struct xdr_stream
*xdr
= &resp
->xdr
;
4175 p
= xdr_reserve_space(xdr
, 4);
4177 return nfserr_resource
;
4178 *p
++ = cpu_to_be32(lrp
->lrs_present
);
4179 if (lrp
->lrs_present
)
4180 return nfsd4_encode_stateid(xdr
, &lrp
->lr_sid
);
4183 #endif /* CONFIG_NFSD_PNFS */
4186 nfsd42_encode_write_res(struct nfsd4_compoundres
*resp
, struct nfsd42_write_res
*write
)
4190 p
= xdr_reserve_space(&resp
->xdr
, 4 + 8 + 4 + NFS4_VERIFIER_SIZE
);
4192 return nfserr_resource
;
4194 *p
++ = cpu_to_be32(0);
4195 p
= xdr_encode_hyper(p
, write
->wr_bytes_written
);
4196 *p
++ = cpu_to_be32(write
->wr_stable_how
);
4197 p
= xdr_encode_opaque_fixed(p
, write
->wr_verifier
.data
,
4198 NFS4_VERIFIER_SIZE
);
4203 nfsd4_encode_copy(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4204 struct nfsd4_copy
*copy
)
4208 nfserr
= nfsd42_encode_write_res(resp
, ©
->cp_res
);
4212 p
= xdr_reserve_space(&resp
->xdr
, 4 + 4);
4213 *p
++ = cpu_to_be32(copy
->cp_consecutive
);
4214 *p
++ = cpu_to_be32(copy
->cp_synchronous
);
4219 nfsd4_encode_seek(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4220 struct nfsd4_seek
*seek
)
4224 p
= xdr_reserve_space(&resp
->xdr
, 4 + 8);
4225 *p
++ = cpu_to_be32(seek
->seek_eof
);
4226 p
= xdr_encode_hyper(p
, seek
->seek_pos
);
4232 nfsd4_encode_noop(struct nfsd4_compoundres
*resp
, __be32 nfserr
, void *p
)
4237 typedef __be32(* nfsd4_enc
)(struct nfsd4_compoundres
*, __be32
, void *);
4240 * Note: nfsd4_enc_ops vector is shared for v4.0 and v4.1
4241 * since we don't need to filter out obsolete ops as this is
4242 * done in the decoding phase.
4244 static const nfsd4_enc nfsd4_enc_ops
[] = {
4245 [OP_ACCESS
] = (nfsd4_enc
)nfsd4_encode_access
,
4246 [OP_CLOSE
] = (nfsd4_enc
)nfsd4_encode_close
,
4247 [OP_COMMIT
] = (nfsd4_enc
)nfsd4_encode_commit
,
4248 [OP_CREATE
] = (nfsd4_enc
)nfsd4_encode_create
,
4249 [OP_DELEGPURGE
] = (nfsd4_enc
)nfsd4_encode_noop
,
4250 [OP_DELEGRETURN
] = (nfsd4_enc
)nfsd4_encode_noop
,
4251 [OP_GETATTR
] = (nfsd4_enc
)nfsd4_encode_getattr
,
4252 [OP_GETFH
] = (nfsd4_enc
)nfsd4_encode_getfh
,
4253 [OP_LINK
] = (nfsd4_enc
)nfsd4_encode_link
,
4254 [OP_LOCK
] = (nfsd4_enc
)nfsd4_encode_lock
,
4255 [OP_LOCKT
] = (nfsd4_enc
)nfsd4_encode_lockt
,
4256 [OP_LOCKU
] = (nfsd4_enc
)nfsd4_encode_locku
,
4257 [OP_LOOKUP
] = (nfsd4_enc
)nfsd4_encode_noop
,
4258 [OP_LOOKUPP
] = (nfsd4_enc
)nfsd4_encode_noop
,
4259 [OP_NVERIFY
] = (nfsd4_enc
)nfsd4_encode_noop
,
4260 [OP_OPEN
] = (nfsd4_enc
)nfsd4_encode_open
,
4261 [OP_OPENATTR
] = (nfsd4_enc
)nfsd4_encode_noop
,
4262 [OP_OPEN_CONFIRM
] = (nfsd4_enc
)nfsd4_encode_open_confirm
,
4263 [OP_OPEN_DOWNGRADE
] = (nfsd4_enc
)nfsd4_encode_open_downgrade
,
4264 [OP_PUTFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
4265 [OP_PUTPUBFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
4266 [OP_PUTROOTFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
4267 [OP_READ
] = (nfsd4_enc
)nfsd4_encode_read
,
4268 [OP_READDIR
] = (nfsd4_enc
)nfsd4_encode_readdir
,
4269 [OP_READLINK
] = (nfsd4_enc
)nfsd4_encode_readlink
,
4270 [OP_REMOVE
] = (nfsd4_enc
)nfsd4_encode_remove
,
4271 [OP_RENAME
] = (nfsd4_enc
)nfsd4_encode_rename
,
4272 [OP_RENEW
] = (nfsd4_enc
)nfsd4_encode_noop
,
4273 [OP_RESTOREFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
4274 [OP_SAVEFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
4275 [OP_SECINFO
] = (nfsd4_enc
)nfsd4_encode_secinfo
,
4276 [OP_SETATTR
] = (nfsd4_enc
)nfsd4_encode_setattr
,
4277 [OP_SETCLIENTID
] = (nfsd4_enc
)nfsd4_encode_setclientid
,
4278 [OP_SETCLIENTID_CONFIRM
] = (nfsd4_enc
)nfsd4_encode_noop
,
4279 [OP_VERIFY
] = (nfsd4_enc
)nfsd4_encode_noop
,
4280 [OP_WRITE
] = (nfsd4_enc
)nfsd4_encode_write
,
4281 [OP_RELEASE_LOCKOWNER
] = (nfsd4_enc
)nfsd4_encode_noop
,
4283 /* NFSv4.1 operations */
4284 [OP_BACKCHANNEL_CTL
] = (nfsd4_enc
)nfsd4_encode_noop
,
4285 [OP_BIND_CONN_TO_SESSION
] = (nfsd4_enc
)nfsd4_encode_bind_conn_to_session
,
4286 [OP_EXCHANGE_ID
] = (nfsd4_enc
)nfsd4_encode_exchange_id
,
4287 [OP_CREATE_SESSION
] = (nfsd4_enc
)nfsd4_encode_create_session
,
4288 [OP_DESTROY_SESSION
] = (nfsd4_enc
)nfsd4_encode_noop
,
4289 [OP_FREE_STATEID
] = (nfsd4_enc
)nfsd4_encode_noop
,
4290 [OP_GET_DIR_DELEGATION
] = (nfsd4_enc
)nfsd4_encode_noop
,
4291 #ifdef CONFIG_NFSD_PNFS
4292 [OP_GETDEVICEINFO
] = (nfsd4_enc
)nfsd4_encode_getdeviceinfo
,
4293 [OP_GETDEVICELIST
] = (nfsd4_enc
)nfsd4_encode_noop
,
4294 [OP_LAYOUTCOMMIT
] = (nfsd4_enc
)nfsd4_encode_layoutcommit
,
4295 [OP_LAYOUTGET
] = (nfsd4_enc
)nfsd4_encode_layoutget
,
4296 [OP_LAYOUTRETURN
] = (nfsd4_enc
)nfsd4_encode_layoutreturn
,
4298 [OP_GETDEVICEINFO
] = (nfsd4_enc
)nfsd4_encode_noop
,
4299 [OP_GETDEVICELIST
] = (nfsd4_enc
)nfsd4_encode_noop
,
4300 [OP_LAYOUTCOMMIT
] = (nfsd4_enc
)nfsd4_encode_noop
,
4301 [OP_LAYOUTGET
] = (nfsd4_enc
)nfsd4_encode_noop
,
4302 [OP_LAYOUTRETURN
] = (nfsd4_enc
)nfsd4_encode_noop
,
4304 [OP_SECINFO_NO_NAME
] = (nfsd4_enc
)nfsd4_encode_secinfo_no_name
,
4305 [OP_SEQUENCE
] = (nfsd4_enc
)nfsd4_encode_sequence
,
4306 [OP_SET_SSV
] = (nfsd4_enc
)nfsd4_encode_noop
,
4307 [OP_TEST_STATEID
] = (nfsd4_enc
)nfsd4_encode_test_stateid
,
4308 [OP_WANT_DELEGATION
] = (nfsd4_enc
)nfsd4_encode_noop
,
4309 [OP_DESTROY_CLIENTID
] = (nfsd4_enc
)nfsd4_encode_noop
,
4310 [OP_RECLAIM_COMPLETE
] = (nfsd4_enc
)nfsd4_encode_noop
,
4312 /* NFSv4.2 operations */
4313 [OP_ALLOCATE
] = (nfsd4_enc
)nfsd4_encode_noop
,
4314 [OP_COPY
] = (nfsd4_enc
)nfsd4_encode_copy
,
4315 [OP_COPY_NOTIFY
] = (nfsd4_enc
)nfsd4_encode_noop
,
4316 [OP_DEALLOCATE
] = (nfsd4_enc
)nfsd4_encode_noop
,
4317 [OP_IO_ADVISE
] = (nfsd4_enc
)nfsd4_encode_noop
,
4318 [OP_LAYOUTERROR
] = (nfsd4_enc
)nfsd4_encode_noop
,
4319 [OP_LAYOUTSTATS
] = (nfsd4_enc
)nfsd4_encode_noop
,
4320 [OP_OFFLOAD_CANCEL
] = (nfsd4_enc
)nfsd4_encode_noop
,
4321 [OP_OFFLOAD_STATUS
] = (nfsd4_enc
)nfsd4_encode_noop
,
4322 [OP_READ_PLUS
] = (nfsd4_enc
)nfsd4_encode_noop
,
4323 [OP_SEEK
] = (nfsd4_enc
)nfsd4_encode_seek
,
4324 [OP_WRITE_SAME
] = (nfsd4_enc
)nfsd4_encode_noop
,
4325 [OP_CLONE
] = (nfsd4_enc
)nfsd4_encode_noop
,
4329 * Calculate whether we still have space to encode repsize bytes.
4330 * There are two considerations:
4331 * - For NFS versions >=4.1, the size of the reply must stay within
4333 * - For all NFS versions, we must stay within limited preallocated
4336 * This is called before the operation is processed, so can only provide
4337 * an upper estimate. For some nonidempotent operations (such as
4338 * getattr), it's not necessarily a problem if that estimate is wrong,
4339 * as we can fail it after processing without significant side effects.
4341 __be32
nfsd4_check_resp_size(struct nfsd4_compoundres
*resp
, u32 respsize
)
4343 struct xdr_buf
*buf
= &resp
->rqstp
->rq_res
;
4344 struct nfsd4_slot
*slot
= resp
->cstate
.slot
;
4346 if (buf
->len
+ respsize
<= buf
->buflen
)
4348 if (!nfsd4_has_session(&resp
->cstate
))
4349 return nfserr_resource
;
4350 if (slot
->sl_flags
& NFSD4_SLOT_CACHETHIS
) {
4352 return nfserr_rep_too_big_to_cache
;
4354 return nfserr_rep_too_big
;
4358 nfsd4_encode_operation(struct nfsd4_compoundres
*resp
, struct nfsd4_op
*op
)
4360 struct xdr_stream
*xdr
= &resp
->xdr
;
4361 struct nfs4_stateowner
*so
= resp
->cstate
.replay_owner
;
4362 struct svc_rqst
*rqstp
= resp
->rqstp
;
4363 const struct nfsd4_operation
*opdesc
= op
->opdesc
;
4364 int post_err_offset
;
4368 p
= xdr_reserve_space(xdr
, 8);
4373 *p
++ = cpu_to_be32(op
->opnum
);
4374 post_err_offset
= xdr
->buf
->len
;
4376 if (op
->opnum
== OP_ILLEGAL
)
4378 if (op
->status
&& opdesc
&&
4379 !(opdesc
->op_flags
& OP_NONTRIVIAL_ERROR_ENCODE
))
4381 BUG_ON(op
->opnum
< 0 || op
->opnum
>= ARRAY_SIZE(nfsd4_enc_ops
) ||
4382 !nfsd4_enc_ops
[op
->opnum
]);
4383 encoder
= nfsd4_enc_ops
[op
->opnum
];
4384 op
->status
= encoder(resp
, op
->status
, &op
->u
);
4385 if (opdesc
&& opdesc
->op_release
)
4386 opdesc
->op_release(&op
->u
);
4387 xdr_commit_encode(xdr
);
4389 /* nfsd4_check_resp_size guarantees enough room for error status */
4391 int space_needed
= 0;
4392 if (!nfsd4_last_compound_op(rqstp
))
4393 space_needed
= COMPOUND_ERR_SLACK_SPACE
;
4394 op
->status
= nfsd4_check_resp_size(resp
, space_needed
);
4396 if (op
->status
== nfserr_resource
&& nfsd4_has_session(&resp
->cstate
)) {
4397 struct nfsd4_slot
*slot
= resp
->cstate
.slot
;
4399 if (slot
->sl_flags
& NFSD4_SLOT_CACHETHIS
)
4400 op
->status
= nfserr_rep_too_big_to_cache
;
4402 op
->status
= nfserr_rep_too_big
;
4404 if (op
->status
== nfserr_resource
||
4405 op
->status
== nfserr_rep_too_big
||
4406 op
->status
== nfserr_rep_too_big_to_cache
) {
4408 * The operation may have already been encoded or
4409 * partially encoded. No op returns anything additional
4410 * in the case of one of these three errors, so we can
4411 * just truncate back to after the status. But it's a
4412 * bug if we had to do this on a non-idempotent op:
4414 warn_on_nonidempotent_op(op
);
4415 xdr_truncate_encode(xdr
, post_err_offset
);
4418 int len
= xdr
->buf
->len
- post_err_offset
;
4420 so
->so_replay
.rp_status
= op
->status
;
4421 so
->so_replay
.rp_buflen
= len
;
4422 read_bytes_from_xdr_buf(xdr
->buf
, post_err_offset
,
4423 so
->so_replay
.rp_buf
, len
);
4426 /* Note that op->status is already in network byte order: */
4427 write_bytes_to_xdr_buf(xdr
->buf
, post_err_offset
- 4, &op
->status
, 4);
4431 * Encode the reply stored in the stateowner reply cache
4433 * XDR note: do not encode rp->rp_buflen: the buffer contains the
4434 * previously sent already encoded operation.
4437 nfsd4_encode_replay(struct xdr_stream
*xdr
, struct nfsd4_op
*op
)
4440 struct nfs4_replay
*rp
= op
->replay
;
4444 p
= xdr_reserve_space(xdr
, 8 + rp
->rp_buflen
);
4449 *p
++ = cpu_to_be32(op
->opnum
);
4450 *p
++ = rp
->rp_status
; /* already xdr'ed */
4452 p
= xdr_encode_opaque_fixed(p
, rp
->rp_buf
, rp
->rp_buflen
);
4456 nfs4svc_encode_voidres(struct svc_rqst
*rqstp
, __be32
*p
)
4458 return xdr_ressize_check(rqstp
, p
);
4461 void nfsd4_release_compoundargs(struct svc_rqst
*rqstp
)
4463 struct nfsd4_compoundargs
*args
= rqstp
->rq_argp
;
4465 if (args
->ops
!= args
->iops
) {
4467 args
->ops
= args
->iops
;
4471 while (args
->to_free
) {
4472 struct svcxdr_tmpbuf
*tb
= args
->to_free
;
4473 args
->to_free
= tb
->next
;
4479 nfs4svc_decode_compoundargs(struct svc_rqst
*rqstp
, __be32
*p
)
4481 struct nfsd4_compoundargs
*args
= rqstp
->rq_argp
;
4483 if (rqstp
->rq_arg
.head
[0].iov_len
% 4) {
4484 /* client is nuts */
4485 dprintk("%s: compound not properly padded! (peeraddr=%pISc xid=0x%x)",
4486 __func__
, svc_addr(rqstp
), be32_to_cpu(rqstp
->rq_xid
));
4490 args
->end
= rqstp
->rq_arg
.head
[0].iov_base
+ rqstp
->rq_arg
.head
[0].iov_len
;
4491 args
->pagelist
= rqstp
->rq_arg
.pages
;
4492 args
->pagelen
= rqstp
->rq_arg
.page_len
;
4495 args
->to_free
= NULL
;
4496 args
->ops
= args
->iops
;
4497 args
->rqstp
= rqstp
;
4499 return !nfsd4_decode_compound(args
);
4503 nfs4svc_encode_compoundres(struct svc_rqst
*rqstp
, __be32
*p
)
4506 * All that remains is to write the tag and operation count...
4508 struct nfsd4_compoundres
*resp
= rqstp
->rq_resp
;
4509 struct xdr_buf
*buf
= resp
->xdr
.buf
;
4511 WARN_ON_ONCE(buf
->len
!= buf
->head
[0].iov_len
+ buf
->page_len
+
4512 buf
->tail
[0].iov_len
);
4514 rqstp
->rq_next_page
= resp
->xdr
.page_ptr
+ 1;
4517 *p
++ = htonl(resp
->taglen
);
4518 memcpy(p
, resp
->tag
, resp
->taglen
);
4519 p
+= XDR_QUADLEN(resp
->taglen
);
4520 *p
++ = htonl(resp
->opcnt
);
4522 nfsd4_sequence_done(resp
);