2 * Server-side procedures for NFSv4.
4 * Copyright (c) 2002 The Regents of the University of Michigan.
7 * Kendrick Smith <kmsmith@umich.edu>
8 * Andy Adamson <andros@umich.edu>
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. Neither the name of the University nor the names of its
20 * contributors may be used to endorse or promote products derived
21 * from this software without specific prior written permission.
23 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
24 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
25 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
28 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
29 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
30 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
31 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
32 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
33 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 #include <linux/fs_struct.h>
36 #include <linux/file.h>
37 #include <linux/falloc.h>
38 #include <linux/slab.h>
39 #include <linux/kthread.h>
40 #include <linux/sunrpc/addr.h>
41 #include <linux/nfs_ssc.h>
47 #include "current_stateid.h"
53 static bool inter_copy_offload_enable
;
54 module_param(inter_copy_offload_enable
, bool, 0644);
55 MODULE_PARM_DESC(inter_copy_offload_enable
,
56 "Enable inter server to server copy offload. Default: false");
58 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
59 #include <linux/security.h>
62 nfsd4_security_inode_setsecctx(struct svc_fh
*resfh
, struct xdr_netobj
*label
, u32
*bmval
)
64 struct inode
*inode
= d_inode(resfh
->fh_dentry
);
68 status
= security_inode_setsecctx(resfh
->fh_dentry
,
69 label
->data
, label
->len
);
74 * XXX: We should really fail the whole open, but we may
75 * already have created a new file, so it may be too
76 * late. For now this seems the least of evils:
78 bmval
[2] &= ~FATTR4_WORD2_SECURITY_LABEL
;
84 nfsd4_security_inode_setsecctx(struct svc_fh
*resfh
, struct xdr_netobj
*label
, u32
*bmval
)
88 #define NFSDDBG_FACILITY NFSDDBG_PROC
90 static u32 nfsd_attrmask
[] = {
91 NFSD_WRITEABLE_ATTRS_WORD0
,
92 NFSD_WRITEABLE_ATTRS_WORD1
,
93 NFSD_WRITEABLE_ATTRS_WORD2
96 static u32 nfsd41_ex_attrmask
[] = {
97 NFSD_SUPPATTR_EXCLCREAT_WORD0
,
98 NFSD_SUPPATTR_EXCLCREAT_WORD1
,
99 NFSD_SUPPATTR_EXCLCREAT_WORD2
103 check_attr_support(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
104 u32
*bmval
, u32
*writable
)
106 struct dentry
*dentry
= cstate
->current_fh
.fh_dentry
;
107 struct svc_export
*exp
= cstate
->current_fh
.fh_export
;
109 if (!nfsd_attrs_supported(cstate
->minorversion
, bmval
))
110 return nfserr_attrnotsupp
;
111 if ((bmval
[0] & FATTR4_WORD0_ACL
) && !IS_POSIXACL(d_inode(dentry
)))
112 return nfserr_attrnotsupp
;
113 if ((bmval
[2] & FATTR4_WORD2_SECURITY_LABEL
) &&
114 !(exp
->ex_flags
& NFSEXP_SECURITY_LABEL
))
115 return nfserr_attrnotsupp
;
116 if (writable
&& !bmval_is_subset(bmval
, writable
))
118 if (writable
&& (bmval
[2] & FATTR4_WORD2_MODE_UMASK
) &&
119 (bmval
[1] & FATTR4_WORD1_MODE
))
125 nfsd4_check_open_attributes(struct svc_rqst
*rqstp
,
126 struct nfsd4_compound_state
*cstate
, struct nfsd4_open
*open
)
128 __be32 status
= nfs_ok
;
130 if (open
->op_create
== NFS4_OPEN_CREATE
) {
131 if (open
->op_createmode
== NFS4_CREATE_UNCHECKED
132 || open
->op_createmode
== NFS4_CREATE_GUARDED
)
133 status
= check_attr_support(rqstp
, cstate
,
134 open
->op_bmval
, nfsd_attrmask
);
135 else if (open
->op_createmode
== NFS4_CREATE_EXCLUSIVE4_1
)
136 status
= check_attr_support(rqstp
, cstate
,
137 open
->op_bmval
, nfsd41_ex_attrmask
);
144 is_create_with_attrs(struct nfsd4_open
*open
)
146 return open
->op_create
== NFS4_OPEN_CREATE
147 && (open
->op_createmode
== NFS4_CREATE_UNCHECKED
148 || open
->op_createmode
== NFS4_CREATE_GUARDED
149 || open
->op_createmode
== NFS4_CREATE_EXCLUSIVE4_1
);
153 * if error occurs when setting the acl, just clear the acl bit
154 * in the returned attr bitmap.
157 do_set_nfs4_acl(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
,
158 struct nfs4_acl
*acl
, u32
*bmval
)
162 status
= nfsd4_set_nfs4_acl(rqstp
, fhp
, acl
);
165 * We should probably fail the whole open at this point,
166 * but we've already created the file, so it's too late;
167 * So this seems the least of evils:
169 bmval
[0] &= ~FATTR4_WORD0_ACL
;
173 fh_dup2(struct svc_fh
*dst
, struct svc_fh
*src
)
176 dget(src
->fh_dentry
);
178 exp_get(src
->fh_export
);
183 do_open_permission(struct svc_rqst
*rqstp
, struct svc_fh
*current_fh
, struct nfsd4_open
*open
, int accmode
)
187 if (open
->op_truncate
&&
188 !(open
->op_share_access
& NFS4_SHARE_ACCESS_WRITE
))
191 accmode
|= NFSD_MAY_READ_IF_EXEC
;
193 if (open
->op_share_access
& NFS4_SHARE_ACCESS_READ
)
194 accmode
|= NFSD_MAY_READ
;
195 if (open
->op_share_access
& NFS4_SHARE_ACCESS_WRITE
)
196 accmode
|= (NFSD_MAY_WRITE
| NFSD_MAY_TRUNC
);
197 if (open
->op_share_deny
& NFS4_SHARE_DENY_READ
)
198 accmode
|= NFSD_MAY_WRITE
;
200 status
= fh_verify(rqstp
, current_fh
, S_IFREG
, accmode
);
205 static __be32
nfsd_check_obj_isreg(struct svc_fh
*fh
)
207 umode_t mode
= d_inode(fh
->fh_dentry
)->i_mode
;
214 * Using err_symlink as our catch-all case may look odd; but
215 * there's no other obvious error for this case in 4.0, and we
216 * happen to know that it will cause the linux v4 client to do
217 * the right thing on attempts to open something other than a
220 return nfserr_symlink
;
223 static void nfsd4_set_open_owner_reply_cache(struct nfsd4_compound_state
*cstate
, struct nfsd4_open
*open
, struct svc_fh
*resfh
)
225 if (nfsd4_has_session(cstate
))
227 fh_copy_shallow(&open
->op_openowner
->oo_owner
.so_replay
.rp_openfh
,
232 do_open_lookup(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
, struct nfsd4_open
*open
, struct svc_fh
**resfh
)
234 struct svc_fh
*current_fh
= &cstate
->current_fh
;
238 *resfh
= kmalloc(sizeof(struct svc_fh
), GFP_KERNEL
);
240 return nfserr_jukebox
;
241 fh_init(*resfh
, NFS4_FHSIZE
);
242 open
->op_truncate
= false;
244 if (open
->op_create
) {
245 /* FIXME: check session persistence and pnfs flags.
246 * The nfsv4.1 spec requires the following semantics:
248 * Persistent | pNFS | Server REQUIRED | Client Allowed
249 * Reply Cache | server | |
250 * -------------+--------+-----------------+--------------------
251 * no | no | EXCLUSIVE4_1 | EXCLUSIVE4_1
253 * | | and EXCLUSIVE4 | or EXCLUSIVE4
255 * no | yes | EXCLUSIVE4_1 | EXCLUSIVE4_1
256 * yes | no | GUARDED4 | GUARDED4
257 * yes | yes | GUARDED4 | GUARDED4
261 * Note: create modes (UNCHECKED,GUARDED...) are the same
262 * in NFSv4 as in v3 except EXCLUSIVE4_1.
264 current
->fs
->umask
= open
->op_umask
;
265 status
= do_nfsd_create(rqstp
, current_fh
, open
->op_fname
,
266 open
->op_fnamelen
, &open
->op_iattr
,
267 *resfh
, open
->op_createmode
,
268 (u32
*)open
->op_verf
.data
,
269 &open
->op_truncate
, &open
->op_created
);
270 current
->fs
->umask
= 0;
272 if (!status
&& open
->op_label
.len
)
273 nfsd4_security_inode_setsecctx(*resfh
, &open
->op_label
, open
->op_bmval
);
276 * Following rfc 3530 14.2.16, and rfc 5661 18.16.4
277 * use the returned bitmask to indicate which attributes
278 * we used to store the verifier:
280 if (nfsd_create_is_exclusive(open
->op_createmode
) && status
== 0)
281 open
->op_bmval
[1] |= (FATTR4_WORD1_TIME_ACCESS
|
282 FATTR4_WORD1_TIME_MODIFY
);
285 * Note this may exit with the parent still locked.
286 * We will hold the lock until nfsd4_open's final
287 * lookup, to prevent renames or unlinks until we've had
288 * a chance to an acquire a delegation if appropriate.
290 status
= nfsd_lookup(rqstp
, current_fh
,
291 open
->op_fname
, open
->op_fnamelen
, *resfh
);
294 status
= nfsd_check_obj_isreg(*resfh
);
298 if (is_create_with_attrs(open
) && open
->op_acl
!= NULL
)
299 do_set_nfs4_acl(rqstp
, *resfh
, open
->op_acl
, open
->op_bmval
);
301 nfsd4_set_open_owner_reply_cache(cstate
, open
, *resfh
);
302 accmode
= NFSD_MAY_NOP
;
303 if (open
->op_created
||
304 open
->op_claim_type
== NFS4_OPEN_CLAIM_DELEGATE_CUR
)
305 accmode
|= NFSD_MAY_OWNER_OVERRIDE
;
306 status
= do_open_permission(rqstp
, *resfh
, open
, accmode
);
307 set_change_info(&open
->op_cinfo
, current_fh
);
313 do_open_fhandle(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
, struct nfsd4_open
*open
)
315 struct svc_fh
*current_fh
= &cstate
->current_fh
;
319 /* We don't know the target directory, and therefore can not
320 * set the change info
323 memset(&open
->op_cinfo
, 0, sizeof(struct nfsd4_change_info
));
325 nfsd4_set_open_owner_reply_cache(cstate
, open
, current_fh
);
327 open
->op_truncate
= (open
->op_iattr
.ia_valid
& ATTR_SIZE
) &&
328 (open
->op_iattr
.ia_size
== 0);
330 * In the delegation case, the client is telling us about an
331 * open that it *already* performed locally, some time ago. We
332 * should let it succeed now if possible.
334 * In the case of a CLAIM_FH open, on the other hand, the client
335 * may be counting on us to enforce permissions (the Linux 4.1
336 * client uses this for normal opens, for example).
338 if (open
->op_claim_type
== NFS4_OPEN_CLAIM_DELEG_CUR_FH
)
339 accmode
= NFSD_MAY_OWNER_OVERRIDE
;
341 status
= do_open_permission(rqstp
, current_fh
, open
, accmode
);
347 copy_clientid(clientid_t
*clid
, struct nfsd4_session
*session
)
349 struct nfsd4_sessionid
*sid
=
350 (struct nfsd4_sessionid
*)session
->se_sessionid
.data
;
352 clid
->cl_boot
= sid
->clientid
.cl_boot
;
353 clid
->cl_id
= sid
->clientid
.cl_id
;
357 nfsd4_open(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
360 struct nfsd4_open
*open
= &u
->open
;
362 struct svc_fh
*resfh
= NULL
;
363 struct net
*net
= SVC_NET(rqstp
);
364 struct nfsd_net
*nn
= net_generic(net
, nfsd_net_id
);
365 bool reclaim
= false;
367 dprintk("NFSD: nfsd4_open filename %.*s op_openowner %p\n",
368 (int)open
->op_fnamelen
, open
->op_fname
,
371 /* This check required by spec. */
372 if (open
->op_create
&& open
->op_claim_type
!= NFS4_OPEN_CLAIM_NULL
)
375 open
->op_created
= false;
378 * Before RECLAIM_COMPLETE done, server should deny new lock
380 if (nfsd4_has_session(cstate
) &&
381 !test_bit(NFSD4_CLIENT_RECLAIM_COMPLETE
, &cstate
->clp
->cl_flags
) &&
382 open
->op_claim_type
!= NFS4_OPEN_CLAIM_PREVIOUS
)
385 if (nfsd4_has_session(cstate
))
386 copy_clientid(&open
->op_clientid
, cstate
->session
);
388 /* check seqid for replay. set nfs4_owner */
389 status
= nfsd4_process_open1(cstate
, open
, nn
);
390 if (status
== nfserr_replay_me
) {
391 struct nfs4_replay
*rp
= &open
->op_openowner
->oo_owner
.so_replay
;
392 fh_put(&cstate
->current_fh
);
393 fh_copy_shallow(&cstate
->current_fh
.fh_handle
,
395 status
= fh_verify(rqstp
, &cstate
->current_fh
, 0, NFSD_MAY_NOP
);
397 dprintk("nfsd4_open: replay failed"
398 " restoring previous filehandle\n");
400 status
= nfserr_replay_me
;
404 if (open
->op_xdr_error
) {
405 status
= open
->op_xdr_error
;
409 status
= nfsd4_check_open_attributes(rqstp
, cstate
, open
);
413 /* Openowner is now set, so sequence id will get bumped. Now we need
414 * these checks before we do any creates: */
415 status
= nfserr_grace
;
416 if (opens_in_grace(net
) && open
->op_claim_type
!= NFS4_OPEN_CLAIM_PREVIOUS
)
418 status
= nfserr_no_grace
;
419 if (!opens_in_grace(net
) && open
->op_claim_type
== NFS4_OPEN_CLAIM_PREVIOUS
)
422 switch (open
->op_claim_type
) {
423 case NFS4_OPEN_CLAIM_DELEGATE_CUR
:
424 case NFS4_OPEN_CLAIM_NULL
:
425 status
= do_open_lookup(rqstp
, cstate
, open
, &resfh
);
429 case NFS4_OPEN_CLAIM_PREVIOUS
:
430 status
= nfs4_check_open_reclaim(cstate
->clp
);
433 open
->op_openowner
->oo_flags
|= NFS4_OO_CONFIRMED
;
436 case NFS4_OPEN_CLAIM_FH
:
437 case NFS4_OPEN_CLAIM_DELEG_CUR_FH
:
438 status
= do_open_fhandle(rqstp
, cstate
, open
);
441 resfh
= &cstate
->current_fh
;
443 case NFS4_OPEN_CLAIM_DELEG_PREV_FH
:
444 case NFS4_OPEN_CLAIM_DELEGATE_PREV
:
445 dprintk("NFSD: unsupported OPEN claim type %d\n",
446 open
->op_claim_type
);
447 status
= nfserr_notsupp
;
450 dprintk("NFSD: Invalid OPEN claim type %d\n",
451 open
->op_claim_type
);
452 status
= nfserr_inval
;
456 * nfsd4_process_open2() does the actual opening of the file. If
457 * successful, it (1) truncates the file if open->op_truncate was
458 * set, (2) sets open->op_stateid, (3) sets open->op_delegation.
460 status
= nfsd4_process_open2(rqstp
, resfh
, open
);
461 WARN(status
&& open
->op_created
,
462 "nfsd4_process_open2 failed to open newly-created file! status=%u\n",
463 be32_to_cpu(status
));
464 if (reclaim
&& !status
)
465 nn
->somebody_reclaimed
= true;
467 if (resfh
&& resfh
!= &cstate
->current_fh
) {
468 fh_dup2(&cstate
->current_fh
, resfh
);
472 nfsd4_cleanup_open_state(cstate
, open
);
473 nfsd4_bump_seqid(cstate
, status
);
478 * OPEN is the only seqid-mutating operation whose decoding can fail
479 * with a seqid-mutating error (specifically, decoding of user names in
480 * the attributes). Therefore we have to do some processing to look up
481 * the stateowner so that we can bump the seqid.
483 static __be32
nfsd4_open_omfg(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
, struct nfsd4_op
*op
)
485 struct nfsd4_open
*open
= &op
->u
.open
;
487 if (!seqid_mutating_err(ntohl(op
->status
)))
489 if (nfsd4_has_session(cstate
))
491 open
->op_xdr_error
= op
->status
;
492 return nfsd4_open(rqstp
, cstate
, &op
->u
);
496 * filehandle-manipulating ops.
499 nfsd4_getfh(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
502 u
->getfh
= &cstate
->current_fh
;
507 nfsd4_putfh(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
510 struct nfsd4_putfh
*putfh
= &u
->putfh
;
513 fh_put(&cstate
->current_fh
);
514 cstate
->current_fh
.fh_handle
.fh_size
= putfh
->pf_fhlen
;
515 memcpy(&cstate
->current_fh
.fh_handle
.fh_base
, putfh
->pf_fhval
,
517 ret
= fh_verify(rqstp
, &cstate
->current_fh
, 0, NFSD_MAY_BYPASS_GSS
);
518 #ifdef CONFIG_NFSD_V4_2_INTER_SSC
519 if (ret
== nfserr_stale
&& putfh
->no_verify
) {
520 SET_FH_FLAG(&cstate
->current_fh
, NFSD4_FH_FOREIGN
);
528 nfsd4_putrootfh(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
533 fh_put(&cstate
->current_fh
);
534 status
= exp_pseudoroot(rqstp
, &cstate
->current_fh
);
539 nfsd4_restorefh(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
542 if (!cstate
->save_fh
.fh_dentry
)
543 return nfserr_restorefh
;
545 fh_dup2(&cstate
->current_fh
, &cstate
->save_fh
);
546 if (HAS_CSTATE_FLAG(cstate
, SAVED_STATE_ID_FLAG
)) {
547 memcpy(&cstate
->current_stateid
, &cstate
->save_stateid
, sizeof(stateid_t
));
548 SET_CSTATE_FLAG(cstate
, CURRENT_STATE_ID_FLAG
);
554 nfsd4_savefh(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
557 fh_dup2(&cstate
->save_fh
, &cstate
->current_fh
);
558 if (HAS_CSTATE_FLAG(cstate
, CURRENT_STATE_ID_FLAG
)) {
559 memcpy(&cstate
->save_stateid
, &cstate
->current_stateid
, sizeof(stateid_t
));
560 SET_CSTATE_FLAG(cstate
, SAVED_STATE_ID_FLAG
);
569 nfsd4_access(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
572 struct nfsd4_access
*access
= &u
->access
;
575 access_full
= NFS3_ACCESS_FULL
;
576 if (cstate
->minorversion
>= 2)
577 access_full
|= NFS4_ACCESS_XALIST
| NFS4_ACCESS_XAREAD
|
580 if (access
->ac_req_access
& ~access_full
)
583 access
->ac_resp_access
= access
->ac_req_access
;
584 return nfsd_access(rqstp
, &cstate
->current_fh
, &access
->ac_resp_access
,
585 &access
->ac_supported
);
588 static void gen_boot_verifier(nfs4_verifier
*verifier
, struct net
*net
)
590 __be32
*verf
= (__be32
*)verifier
->data
;
592 BUILD_BUG_ON(2*sizeof(*verf
) != sizeof(verifier
->data
));
594 nfsd_copy_boot_verifier(verf
, net_generic(net
, nfsd_net_id
));
598 nfsd4_commit(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
601 struct nfsd4_commit
*commit
= &u
->commit
;
603 return nfsd_commit(rqstp
, &cstate
->current_fh
, commit
->co_offset
,
605 (__be32
*)commit
->co_verf
.data
);
609 nfsd4_create(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
612 struct nfsd4_create
*create
= &u
->create
;
617 fh_init(&resfh
, NFS4_FHSIZE
);
619 status
= fh_verify(rqstp
, &cstate
->current_fh
, S_IFDIR
, NFSD_MAY_NOP
);
623 status
= check_attr_support(rqstp
, cstate
, create
->cr_bmval
,
628 current
->fs
->umask
= create
->cr_umask
;
629 switch (create
->cr_type
) {
631 status
= nfsd_symlink(rqstp
, &cstate
->current_fh
,
632 create
->cr_name
, create
->cr_namelen
,
633 create
->cr_data
, &resfh
);
637 status
= nfserr_inval
;
638 rdev
= MKDEV(create
->cr_specdata1
, create
->cr_specdata2
);
639 if (MAJOR(rdev
) != create
->cr_specdata1
||
640 MINOR(rdev
) != create
->cr_specdata2
)
642 status
= nfsd_create(rqstp
, &cstate
->current_fh
,
643 create
->cr_name
, create
->cr_namelen
,
644 &create
->cr_iattr
, S_IFBLK
, rdev
, &resfh
);
648 status
= nfserr_inval
;
649 rdev
= MKDEV(create
->cr_specdata1
, create
->cr_specdata2
);
650 if (MAJOR(rdev
) != create
->cr_specdata1
||
651 MINOR(rdev
) != create
->cr_specdata2
)
653 status
= nfsd_create(rqstp
, &cstate
->current_fh
,
654 create
->cr_name
, create
->cr_namelen
,
655 &create
->cr_iattr
,S_IFCHR
, rdev
, &resfh
);
659 status
= nfsd_create(rqstp
, &cstate
->current_fh
,
660 create
->cr_name
, create
->cr_namelen
,
661 &create
->cr_iattr
, S_IFSOCK
, 0, &resfh
);
665 status
= nfsd_create(rqstp
, &cstate
->current_fh
,
666 create
->cr_name
, create
->cr_namelen
,
667 &create
->cr_iattr
, S_IFIFO
, 0, &resfh
);
671 create
->cr_iattr
.ia_valid
&= ~ATTR_SIZE
;
672 status
= nfsd_create(rqstp
, &cstate
->current_fh
,
673 create
->cr_name
, create
->cr_namelen
,
674 &create
->cr_iattr
, S_IFDIR
, 0, &resfh
);
678 status
= nfserr_badtype
;
684 if (create
->cr_label
.len
)
685 nfsd4_security_inode_setsecctx(&resfh
, &create
->cr_label
, create
->cr_bmval
);
687 if (create
->cr_acl
!= NULL
)
688 do_set_nfs4_acl(rqstp
, &resfh
, create
->cr_acl
,
691 fh_unlock(&cstate
->current_fh
);
692 set_change_info(&create
->cr_cinfo
, &cstate
->current_fh
);
693 fh_dup2(&cstate
->current_fh
, &resfh
);
697 current
->fs
->umask
= 0;
702 nfsd4_getattr(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
705 struct nfsd4_getattr
*getattr
= &u
->getattr
;
708 status
= fh_verify(rqstp
, &cstate
->current_fh
, 0, NFSD_MAY_NOP
);
712 if (getattr
->ga_bmval
[1] & NFSD_WRITEONLY_ATTRS_WORD1
)
715 getattr
->ga_bmval
[0] &= nfsd_suppattrs
[cstate
->minorversion
][0];
716 getattr
->ga_bmval
[1] &= nfsd_suppattrs
[cstate
->minorversion
][1];
717 getattr
->ga_bmval
[2] &= nfsd_suppattrs
[cstate
->minorversion
][2];
719 getattr
->ga_fhp
= &cstate
->current_fh
;
724 nfsd4_link(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
727 struct nfsd4_link
*link
= &u
->link
;
730 status
= nfsd_link(rqstp
, &cstate
->current_fh
,
731 link
->li_name
, link
->li_namelen
, &cstate
->save_fh
);
733 set_change_info(&link
->li_cinfo
, &cstate
->current_fh
);
737 static __be32
nfsd4_do_lookupp(struct svc_rqst
*rqstp
, struct svc_fh
*fh
)
739 struct svc_fh tmp_fh
;
742 fh_init(&tmp_fh
, NFS4_FHSIZE
);
743 ret
= exp_pseudoroot(rqstp
, &tmp_fh
);
746 if (tmp_fh
.fh_dentry
== fh
->fh_dentry
) {
751 return nfsd_lookup(rqstp
, fh
, "..", 2, fh
);
755 nfsd4_lookupp(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
758 return nfsd4_do_lookupp(rqstp
, &cstate
->current_fh
);
762 nfsd4_lookup(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
765 return nfsd_lookup(rqstp
, &cstate
->current_fh
,
766 u
->lookup
.lo_name
, u
->lookup
.lo_len
,
767 &cstate
->current_fh
);
771 nfsd4_read(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
774 struct nfsd4_read
*read
= &u
->read
;
778 if (read
->rd_offset
>= OFFSET_MAX
)
781 trace_nfsd_read_start(rqstp
, &cstate
->current_fh
,
782 read
->rd_offset
, read
->rd_length
);
785 * If we do a zero copy read, then a client will see read data
786 * that reflects the state of the file *after* performing the
787 * following compound.
789 * To ensure proper ordering, we therefore turn off zero copy if
790 * the client wants us to do more in this compound:
792 if (!nfsd4_last_compound_op(rqstp
))
793 clear_bit(RQ_SPLICE_OK
, &rqstp
->rq_flags
);
796 status
= nfs4_preprocess_stateid_op(rqstp
, cstate
, &cstate
->current_fh
,
797 &read
->rd_stateid
, RD_STATE
,
800 dprintk("NFSD: nfsd4_read: couldn't process stateid!\n");
805 read
->rd_rqstp
= rqstp
;
806 read
->rd_fhp
= &cstate
->current_fh
;
812 nfsd4_read_release(union nfsd4_op_u
*u
)
815 nfsd_file_put(u
->read
.rd_nf
);
816 trace_nfsd_read_done(u
->read
.rd_rqstp
, u
->read
.rd_fhp
,
817 u
->read
.rd_offset
, u
->read
.rd_length
);
821 nfsd4_readdir(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
824 struct nfsd4_readdir
*readdir
= &u
->readdir
;
825 u64 cookie
= readdir
->rd_cookie
;
826 static const nfs4_verifier zeroverf
;
828 /* no need to check permission - this will be done in nfsd_readdir() */
830 if (readdir
->rd_bmval
[1] & NFSD_WRITEONLY_ATTRS_WORD1
)
833 readdir
->rd_bmval
[0] &= nfsd_suppattrs
[cstate
->minorversion
][0];
834 readdir
->rd_bmval
[1] &= nfsd_suppattrs
[cstate
->minorversion
][1];
835 readdir
->rd_bmval
[2] &= nfsd_suppattrs
[cstate
->minorversion
][2];
837 if ((cookie
== 1) || (cookie
== 2) ||
838 (cookie
== 0 && memcmp(readdir
->rd_verf
.data
, zeroverf
.data
, NFS4_VERIFIER_SIZE
)))
839 return nfserr_bad_cookie
;
841 readdir
->rd_rqstp
= rqstp
;
842 readdir
->rd_fhp
= &cstate
->current_fh
;
847 nfsd4_readlink(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
850 u
->readlink
.rl_rqstp
= rqstp
;
851 u
->readlink
.rl_fhp
= &cstate
->current_fh
;
856 nfsd4_remove(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
859 struct nfsd4_remove
*remove
= &u
->remove
;
862 if (opens_in_grace(SVC_NET(rqstp
)))
864 status
= nfsd_unlink(rqstp
, &cstate
->current_fh
, 0,
865 remove
->rm_name
, remove
->rm_namelen
);
867 fh_unlock(&cstate
->current_fh
);
868 set_change_info(&remove
->rm_cinfo
, &cstate
->current_fh
);
874 nfsd4_rename(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
877 struct nfsd4_rename
*rename
= &u
->rename
;
880 if (opens_in_grace(SVC_NET(rqstp
)))
882 status
= nfsd_rename(rqstp
, &cstate
->save_fh
, rename
->rn_sname
,
883 rename
->rn_snamelen
, &cstate
->current_fh
,
884 rename
->rn_tname
, rename
->rn_tnamelen
);
887 set_change_info(&rename
->rn_sinfo
, &cstate
->current_fh
);
888 set_change_info(&rename
->rn_tinfo
, &cstate
->save_fh
);
893 nfsd4_secinfo(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
896 struct nfsd4_secinfo
*secinfo
= &u
->secinfo
;
897 struct svc_export
*exp
;
898 struct dentry
*dentry
;
901 err
= fh_verify(rqstp
, &cstate
->current_fh
, S_IFDIR
, NFSD_MAY_EXEC
);
904 err
= nfsd_lookup_dentry(rqstp
, &cstate
->current_fh
,
905 secinfo
->si_name
, secinfo
->si_namelen
,
909 fh_unlock(&cstate
->current_fh
);
910 if (d_really_is_negative(dentry
)) {
914 secinfo
->si_exp
= exp
;
916 if (cstate
->minorversion
)
917 /* See rfc 5661 section 2.6.3.1.1.8 */
918 fh_put(&cstate
->current_fh
);
923 nfsd4_secinfo_no_name(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
928 switch (u
->secinfo_no_name
.sin_style
) {
929 case NFS4_SECINFO_STYLE4_CURRENT_FH
:
931 case NFS4_SECINFO_STYLE4_PARENT
:
932 err
= nfsd4_do_lookupp(rqstp
, &cstate
->current_fh
);
940 u
->secinfo_no_name
.sin_exp
= exp_get(cstate
->current_fh
.fh_export
);
941 fh_put(&cstate
->current_fh
);
946 nfsd4_secinfo_release(union nfsd4_op_u
*u
)
948 if (u
->secinfo
.si_exp
)
949 exp_put(u
->secinfo
.si_exp
);
953 nfsd4_secinfo_no_name_release(union nfsd4_op_u
*u
)
955 if (u
->secinfo_no_name
.sin_exp
)
956 exp_put(u
->secinfo_no_name
.sin_exp
);
960 nfsd4_setattr(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
963 struct nfsd4_setattr
*setattr
= &u
->setattr
;
964 __be32 status
= nfs_ok
;
967 if (setattr
->sa_iattr
.ia_valid
& ATTR_SIZE
) {
968 status
= nfs4_preprocess_stateid_op(rqstp
, cstate
,
969 &cstate
->current_fh
, &setattr
->sa_stateid
,
970 WR_STATE
, NULL
, NULL
);
972 dprintk("NFSD: nfsd4_setattr: couldn't process stateid!\n");
976 err
= fh_want_write(&cstate
->current_fh
);
978 return nfserrno(err
);
981 status
= check_attr_support(rqstp
, cstate
, setattr
->sa_bmval
,
986 if (setattr
->sa_acl
!= NULL
)
987 status
= nfsd4_set_nfs4_acl(rqstp
, &cstate
->current_fh
,
991 if (setattr
->sa_label
.len
)
992 status
= nfsd4_set_nfs4_label(rqstp
, &cstate
->current_fh
,
996 status
= nfsd_setattr(rqstp
, &cstate
->current_fh
, &setattr
->sa_iattr
,
999 fh_drop_write(&cstate
->current_fh
);
1004 nfsd4_write(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
1005 union nfsd4_op_u
*u
)
1007 struct nfsd4_write
*write
= &u
->write
;
1008 stateid_t
*stateid
= &write
->wr_stateid
;
1009 struct nfsd_file
*nf
= NULL
;
1010 __be32 status
= nfs_ok
;
1014 if (write
->wr_offset
>= OFFSET_MAX
)
1015 return nfserr_inval
;
1017 cnt
= write
->wr_buflen
;
1018 trace_nfsd_write_start(rqstp
, &cstate
->current_fh
,
1019 write
->wr_offset
, cnt
);
1020 status
= nfs4_preprocess_stateid_op(rqstp
, cstate
, &cstate
->current_fh
,
1021 stateid
, WR_STATE
, &nf
, NULL
);
1023 dprintk("NFSD: nfsd4_write: couldn't process stateid!\n");
1027 write
->wr_how_written
= write
->wr_stable_how
;
1029 nvecs
= svc_fill_write_vector(rqstp
, write
->wr_payload
.pages
,
1030 write
->wr_payload
.head
, write
->wr_buflen
);
1031 WARN_ON_ONCE(nvecs
> ARRAY_SIZE(rqstp
->rq_vec
));
1033 status
= nfsd_vfs_write(rqstp
, &cstate
->current_fh
, nf
,
1034 write
->wr_offset
, rqstp
->rq_vec
, nvecs
, &cnt
,
1035 write
->wr_how_written
,
1036 (__be32
*)write
->wr_verifier
.data
);
1039 write
->wr_bytes_written
= cnt
;
1040 trace_nfsd_write_done(rqstp
, &cstate
->current_fh
,
1041 write
->wr_offset
, cnt
);
1046 nfsd4_verify_copy(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
1047 stateid_t
*src_stateid
, struct nfsd_file
**src
,
1048 stateid_t
*dst_stateid
, struct nfsd_file
**dst
)
1052 if (!cstate
->save_fh
.fh_dentry
)
1053 return nfserr_nofilehandle
;
1055 status
= nfs4_preprocess_stateid_op(rqstp
, cstate
, &cstate
->save_fh
,
1056 src_stateid
, RD_STATE
, src
, NULL
);
1058 dprintk("NFSD: %s: couldn't process src stateid!\n", __func__
);
1062 status
= nfs4_preprocess_stateid_op(rqstp
, cstate
, &cstate
->current_fh
,
1063 dst_stateid
, WR_STATE
, dst
, NULL
);
1065 dprintk("NFSD: %s: couldn't process dst stateid!\n", __func__
);
1069 /* fix up for NFS-specific error code */
1070 if (!S_ISREG(file_inode((*src
)->nf_file
)->i_mode
) ||
1071 !S_ISREG(file_inode((*dst
)->nf_file
)->i_mode
)) {
1072 status
= nfserr_wrong_type
;
1079 nfsd_file_put(*dst
);
1081 nfsd_file_put(*src
);
1086 nfsd4_clone(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
1087 union nfsd4_op_u
*u
)
1089 struct nfsd4_clone
*clone
= &u
->clone
;
1090 struct nfsd_file
*src
, *dst
;
1093 status
= nfsd4_verify_copy(rqstp
, cstate
, &clone
->cl_src_stateid
, &src
,
1094 &clone
->cl_dst_stateid
, &dst
);
1098 status
= nfsd4_clone_file_range(src
, clone
->cl_src_pos
,
1099 dst
, clone
->cl_dst_pos
, clone
->cl_count
,
1100 EX_ISSYNC(cstate
->current_fh
.fh_export
));
1108 void nfs4_put_copy(struct nfsd4_copy
*copy
)
1110 if (!refcount_dec_and_test(©
->refcount
))
1116 check_and_set_stop_copy(struct nfsd4_copy
*copy
)
1120 spin_lock(©
->cp_clp
->async_lock
);
1121 value
= copy
->stopped
;
1123 copy
->stopped
= true;
1124 spin_unlock(©
->cp_clp
->async_lock
);
1128 static void nfsd4_stop_copy(struct nfsd4_copy
*copy
)
1130 /* only 1 thread should stop the copy */
1131 if (!check_and_set_stop_copy(copy
))
1132 kthread_stop(copy
->copy_task
);
1133 nfs4_put_copy(copy
);
1136 static struct nfsd4_copy
*nfsd4_get_copy(struct nfs4_client
*clp
)
1138 struct nfsd4_copy
*copy
= NULL
;
1140 spin_lock(&clp
->async_lock
);
1141 if (!list_empty(&clp
->async_copies
)) {
1142 copy
= list_first_entry(&clp
->async_copies
, struct nfsd4_copy
,
1144 refcount_inc(©
->refcount
);
1146 spin_unlock(&clp
->async_lock
);
1150 void nfsd4_shutdown_copy(struct nfs4_client
*clp
)
1152 struct nfsd4_copy
*copy
;
1154 while ((copy
= nfsd4_get_copy(clp
)) != NULL
)
1155 nfsd4_stop_copy(copy
);
1157 #ifdef CONFIG_NFSD_V4_2_INTER_SSC
1159 extern struct file
*nfs42_ssc_open(struct vfsmount
*ss_mnt
,
1160 struct nfs_fh
*src_fh
,
1161 nfs4_stateid
*stateid
);
1162 extern void nfs42_ssc_close(struct file
*filep
);
1164 extern void nfs_sb_deactive(struct super_block
*sb
);
1166 #define NFSD42_INTERSSC_MOUNTOPS "vers=4.2,addr=%s,sec=sys"
1169 * Support one copy source server for now.
1172 nfsd4_interssc_connect(struct nl4_server
*nss
, struct svc_rqst
*rqstp
,
1173 struct vfsmount
**mount
)
1175 struct file_system_type
*type
;
1176 struct vfsmount
*ss_mnt
;
1177 struct nfs42_netaddr
*naddr
;
1178 struct sockaddr_storage tmp_addr
;
1179 size_t tmp_addrlen
, match_netid_len
= 3;
1180 char *startsep
= "", *endsep
= "", *match_netid
= "tcp";
1181 char *ipaddr
, *dev_name
, *raw_data
;
1183 __be32 status
= nfserr_inval
;
1185 naddr
= &nss
->u
.nl4_addr
;
1186 tmp_addrlen
= rpc_uaddr2sockaddr(SVC_NET(rqstp
), naddr
->addr
,
1188 (struct sockaddr
*)&tmp_addr
,
1190 if (tmp_addrlen
== 0)
1193 if (tmp_addr
.ss_family
== AF_INET6
) {
1196 match_netid
= "tcp6";
1197 match_netid_len
= 4;
1200 if (naddr
->netid_len
!= match_netid_len
||
1201 strncmp(naddr
->netid
, match_netid
, naddr
->netid_len
))
1204 /* Construct the raw data for the vfs_kern_mount call */
1205 len
= RPC_MAX_ADDRBUFLEN
+ 1;
1206 ipaddr
= kzalloc(len
, GFP_KERNEL
);
1210 rpc_ntop((struct sockaddr
*)&tmp_addr
, ipaddr
, len
);
1212 /* 2 for ipv6 endsep and startsep. 3 for ":/" and trailing '/0'*/
1214 raw_len
= strlen(NFSD42_INTERSSC_MOUNTOPS
) + strlen(ipaddr
);
1215 raw_data
= kzalloc(raw_len
, GFP_KERNEL
);
1217 goto out_free_ipaddr
;
1219 snprintf(raw_data
, raw_len
, NFSD42_INTERSSC_MOUNTOPS
, ipaddr
);
1221 status
= nfserr_nodev
;
1222 type
= get_fs_type("nfs");
1224 goto out_free_rawdata
;
1226 /* Set the server:<export> for the vfs_kern_mount call */
1227 dev_name
= kzalloc(len
+ 5, GFP_KERNEL
);
1229 goto out_free_rawdata
;
1230 snprintf(dev_name
, len
+ 5, "%s%s%s:/", startsep
, ipaddr
, endsep
);
1232 /* Use an 'internal' mount: SB_KERNMOUNT -> MNT_INTERNAL */
1233 ss_mnt
= vfs_kern_mount(type
, SB_KERNMOUNT
, dev_name
, raw_data
);
1234 module_put(type
->owner
);
1236 goto out_free_devname
;
1252 nfsd4_interssc_disconnect(struct vfsmount
*ss_mnt
)
1254 nfs_do_sb_deactive(ss_mnt
->mnt_sb
);
1259 * Verify COPY destination stateid.
1261 * Connect to the source server with NFSv4.1.
1262 * Create the source struct file for nfsd_copy_range.
1263 * Called with COPY cstate:
1264 * SAVED_FH: source filehandle
1265 * CURRENT_FH: destination filehandle
1268 nfsd4_setup_inter_ssc(struct svc_rqst
*rqstp
,
1269 struct nfsd4_compound_state
*cstate
,
1270 struct nfsd4_copy
*copy
, struct vfsmount
**mount
)
1272 struct svc_fh
*s_fh
= NULL
;
1273 stateid_t
*s_stid
= ©
->cp_src_stateid
;
1274 __be32 status
= nfserr_inval
;
1276 /* Verify the destination stateid and set dst struct file*/
1277 status
= nfs4_preprocess_stateid_op(rqstp
, cstate
, &cstate
->current_fh
,
1278 ©
->cp_dst_stateid
,
1279 WR_STATE
, ©
->nf_dst
, NULL
);
1283 status
= nfsd4_interssc_connect(©
->cp_src
, rqstp
, mount
);
1287 s_fh
= &cstate
->save_fh
;
1289 copy
->c_fh
.size
= s_fh
->fh_handle
.fh_size
;
1290 memcpy(copy
->c_fh
.data
, &s_fh
->fh_handle
.fh_base
, copy
->c_fh
.size
);
1291 copy
->stateid
.seqid
= cpu_to_be32(s_stid
->si_generation
);
1292 memcpy(copy
->stateid
.other
, (void *)&s_stid
->si_opaque
,
1293 sizeof(stateid_opaque_t
));
1301 nfsd4_cleanup_inter_ssc(struct vfsmount
*ss_mnt
, struct nfsd_file
*src
,
1302 struct nfsd_file
*dst
)
1304 nfs42_ssc_close(src
->nf_file
);
1310 #else /* CONFIG_NFSD_V4_2_INTER_SSC */
1313 nfsd4_setup_inter_ssc(struct svc_rqst
*rqstp
,
1314 struct nfsd4_compound_state
*cstate
,
1315 struct nfsd4_copy
*copy
,
1316 struct vfsmount
**mount
)
1319 return nfserr_inval
;
1323 nfsd4_cleanup_inter_ssc(struct vfsmount
*ss_mnt
, struct nfsd_file
*src
,
1324 struct nfsd_file
*dst
)
1329 nfsd4_interssc_disconnect(struct vfsmount
*ss_mnt
)
1333 static struct file
*nfs42_ssc_open(struct vfsmount
*ss_mnt
,
1334 struct nfs_fh
*src_fh
,
1335 nfs4_stateid
*stateid
)
1339 #endif /* CONFIG_NFSD_V4_2_INTER_SSC */
1342 nfsd4_setup_intra_ssc(struct svc_rqst
*rqstp
,
1343 struct nfsd4_compound_state
*cstate
,
1344 struct nfsd4_copy
*copy
)
1346 return nfsd4_verify_copy(rqstp
, cstate
, ©
->cp_src_stateid
,
1347 ©
->nf_src
, ©
->cp_dst_stateid
,
1352 nfsd4_cleanup_intra_ssc(struct nfsd_file
*src
, struct nfsd_file
*dst
)
1358 static void nfsd4_cb_offload_release(struct nfsd4_callback
*cb
)
1360 struct nfsd4_copy
*copy
= container_of(cb
, struct nfsd4_copy
, cp_cb
);
1362 nfs4_put_copy(copy
);
1365 static int nfsd4_cb_offload_done(struct nfsd4_callback
*cb
,
1366 struct rpc_task
*task
)
1371 static const struct nfsd4_callback_ops nfsd4_cb_offload_ops
= {
1372 .release
= nfsd4_cb_offload_release
,
1373 .done
= nfsd4_cb_offload_done
1376 static void nfsd4_init_copy_res(struct nfsd4_copy
*copy
, bool sync
)
1378 copy
->cp_res
.wr_stable_how
= NFS_UNSTABLE
;
1379 copy
->cp_synchronous
= sync
;
1380 gen_boot_verifier(©
->cp_res
.wr_verifier
, copy
->cp_clp
->net
);
1383 static ssize_t
_nfsd_copy_file_range(struct nfsd4_copy
*copy
)
1385 ssize_t bytes_copied
= 0;
1386 u64 bytes_total
= copy
->cp_count
;
1387 u64 src_pos
= copy
->cp_src_pos
;
1388 u64 dst_pos
= copy
->cp_dst_pos
;
1390 /* See RFC 7862 p.67: */
1391 if (bytes_total
== 0)
1392 bytes_total
= ULLONG_MAX
;
1394 if (kthread_should_stop())
1396 bytes_copied
= nfsd_copy_file_range(copy
->nf_src
->nf_file
,
1397 src_pos
, copy
->nf_dst
->nf_file
, dst_pos
,
1399 if (bytes_copied
<= 0)
1401 bytes_total
-= bytes_copied
;
1402 copy
->cp_res
.wr_bytes_written
+= bytes_copied
;
1403 src_pos
+= bytes_copied
;
1404 dst_pos
+= bytes_copied
;
1405 } while (bytes_total
> 0 && !copy
->cp_synchronous
);
1406 return bytes_copied
;
1409 static __be32
nfsd4_do_copy(struct nfsd4_copy
*copy
, bool sync
)
1414 bytes
= _nfsd_copy_file_range(copy
);
1415 /* for async copy, we ignore the error, client can always retry
1418 if (bytes
< 0 && !copy
->cp_res
.wr_bytes_written
)
1419 status
= nfserrno(bytes
);
1421 nfsd4_init_copy_res(copy
, sync
);
1425 if (!copy
->cp_intra
) /* Inter server SSC */
1426 nfsd4_cleanup_inter_ssc(copy
->ss_mnt
, copy
->nf_src
,
1429 nfsd4_cleanup_intra_ssc(copy
->nf_src
, copy
->nf_dst
);
1434 static void dup_copy_fields(struct nfsd4_copy
*src
, struct nfsd4_copy
*dst
)
1436 dst
->cp_src_pos
= src
->cp_src_pos
;
1437 dst
->cp_dst_pos
= src
->cp_dst_pos
;
1438 dst
->cp_count
= src
->cp_count
;
1439 dst
->cp_synchronous
= src
->cp_synchronous
;
1440 memcpy(&dst
->cp_res
, &src
->cp_res
, sizeof(src
->cp_res
));
1441 memcpy(&dst
->fh
, &src
->fh
, sizeof(src
->fh
));
1442 dst
->cp_clp
= src
->cp_clp
;
1443 dst
->nf_dst
= nfsd_file_get(src
->nf_dst
);
1444 dst
->cp_intra
= src
->cp_intra
;
1445 if (src
->cp_intra
) /* for inter, file_src doesn't exist yet */
1446 dst
->nf_src
= nfsd_file_get(src
->nf_src
);
1448 memcpy(&dst
->cp_stateid
, &src
->cp_stateid
, sizeof(src
->cp_stateid
));
1449 memcpy(&dst
->cp_src
, &src
->cp_src
, sizeof(struct nl4_server
));
1450 memcpy(&dst
->stateid
, &src
->stateid
, sizeof(src
->stateid
));
1451 memcpy(&dst
->c_fh
, &src
->c_fh
, sizeof(src
->c_fh
));
1452 dst
->ss_mnt
= src
->ss_mnt
;
1455 static void cleanup_async_copy(struct nfsd4_copy
*copy
)
1457 nfs4_free_copy_state(copy
);
1458 nfsd_file_put(copy
->nf_dst
);
1460 nfsd_file_put(copy
->nf_src
);
1461 spin_lock(©
->cp_clp
->async_lock
);
1462 list_del(©
->copies
);
1463 spin_unlock(©
->cp_clp
->async_lock
);
1464 nfs4_put_copy(copy
);
1467 static int nfsd4_do_async_copy(void *data
)
1469 struct nfsd4_copy
*copy
= (struct nfsd4_copy
*)data
;
1470 struct nfsd4_copy
*cb_copy
;
1472 if (!copy
->cp_intra
) { /* Inter server SSC */
1473 copy
->nf_src
= kzalloc(sizeof(struct nfsd_file
), GFP_KERNEL
);
1474 if (!copy
->nf_src
) {
1475 copy
->nfserr
= nfserr_serverfault
;
1476 nfsd4_interssc_disconnect(copy
->ss_mnt
);
1479 copy
->nf_src
->nf_file
= nfs42_ssc_open(copy
->ss_mnt
, ©
->c_fh
,
1481 if (IS_ERR(copy
->nf_src
->nf_file
)) {
1482 copy
->nfserr
= nfserr_offload_denied
;
1483 nfsd4_interssc_disconnect(copy
->ss_mnt
);
1488 copy
->nfserr
= nfsd4_do_copy(copy
, 0);
1490 cb_copy
= kzalloc(sizeof(struct nfsd4_copy
), GFP_KERNEL
);
1493 refcount_set(&cb_copy
->refcount
, 1);
1494 memcpy(&cb_copy
->cp_res
, ©
->cp_res
, sizeof(copy
->cp_res
));
1495 cb_copy
->cp_clp
= copy
->cp_clp
;
1496 cb_copy
->nfserr
= copy
->nfserr
;
1497 memcpy(&cb_copy
->fh
, ©
->fh
, sizeof(copy
->fh
));
1498 nfsd4_init_cb(&cb_copy
->cp_cb
, cb_copy
->cp_clp
,
1499 &nfsd4_cb_offload_ops
, NFSPROC4_CLNT_CB_OFFLOAD
);
1500 nfsd4_run_cb(&cb_copy
->cp_cb
);
1502 if (!copy
->cp_intra
)
1503 kfree(copy
->nf_src
);
1504 cleanup_async_copy(copy
);
1509 nfsd4_copy(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
1510 union nfsd4_op_u
*u
)
1512 struct nfsd4_copy
*copy
= &u
->copy
;
1514 struct nfsd4_copy
*async_copy
= NULL
;
1516 if (!copy
->cp_intra
) { /* Inter server SSC */
1517 if (!inter_copy_offload_enable
|| copy
->cp_synchronous
) {
1518 status
= nfserr_notsupp
;
1521 status
= nfsd4_setup_inter_ssc(rqstp
, cstate
, copy
,
1524 return nfserr_offload_denied
;
1526 status
= nfsd4_setup_intra_ssc(rqstp
, cstate
, copy
);
1531 copy
->cp_clp
= cstate
->clp
;
1532 memcpy(©
->fh
, &cstate
->current_fh
.fh_handle
,
1533 sizeof(struct knfsd_fh
));
1534 if (!copy
->cp_synchronous
) {
1535 struct nfsd_net
*nn
= net_generic(SVC_NET(rqstp
), nfsd_net_id
);
1537 status
= nfserrno(-ENOMEM
);
1538 async_copy
= kzalloc(sizeof(struct nfsd4_copy
), GFP_KERNEL
);
1541 if (!nfs4_init_copy_state(nn
, copy
))
1543 refcount_set(&async_copy
->refcount
, 1);
1544 memcpy(©
->cp_res
.cb_stateid
, ©
->cp_stateid
.stid
,
1545 sizeof(copy
->cp_res
.cb_stateid
));
1546 dup_copy_fields(copy
, async_copy
);
1547 async_copy
->copy_task
= kthread_create(nfsd4_do_async_copy
,
1548 async_copy
, "%s", "copy thread");
1549 if (IS_ERR(async_copy
->copy_task
))
1551 spin_lock(&async_copy
->cp_clp
->async_lock
);
1552 list_add(&async_copy
->copies
,
1553 &async_copy
->cp_clp
->async_copies
);
1554 spin_unlock(&async_copy
->cp_clp
->async_lock
);
1555 wake_up_process(async_copy
->copy_task
);
1558 status
= nfsd4_do_copy(copy
, 1);
1564 cleanup_async_copy(async_copy
);
1565 status
= nfserrno(-ENOMEM
);
1566 if (!copy
->cp_intra
)
1567 nfsd4_interssc_disconnect(copy
->ss_mnt
);
1572 find_async_copy(struct nfs4_client
*clp
, stateid_t
*stateid
)
1574 struct nfsd4_copy
*copy
;
1576 spin_lock(&clp
->async_lock
);
1577 list_for_each_entry(copy
, &clp
->async_copies
, copies
) {
1578 if (memcmp(©
->cp_stateid
.stid
, stateid
, NFS4_STATEID_SIZE
))
1580 refcount_inc(©
->refcount
);
1581 spin_unlock(&clp
->async_lock
);
1584 spin_unlock(&clp
->async_lock
);
1589 nfsd4_offload_cancel(struct svc_rqst
*rqstp
,
1590 struct nfsd4_compound_state
*cstate
,
1591 union nfsd4_op_u
*u
)
1593 struct nfsd4_offload_status
*os
= &u
->offload_status
;
1594 struct nfsd4_copy
*copy
;
1595 struct nfs4_client
*clp
= cstate
->clp
;
1597 copy
= find_async_copy(clp
, &os
->stateid
);
1599 struct nfsd_net
*nn
= net_generic(SVC_NET(rqstp
), nfsd_net_id
);
1601 return manage_cpntf_state(nn
, &os
->stateid
, clp
, NULL
);
1603 nfsd4_stop_copy(copy
);
1609 nfsd4_copy_notify(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
1610 union nfsd4_op_u
*u
)
1612 struct nfsd4_copy_notify
*cn
= &u
->copy_notify
;
1614 struct nfsd_net
*nn
= net_generic(SVC_NET(rqstp
), nfsd_net_id
);
1615 struct nfs4_stid
*stid
;
1616 struct nfs4_cpntf_state
*cps
;
1617 struct nfs4_client
*clp
= cstate
->clp
;
1619 status
= nfs4_preprocess_stateid_op(rqstp
, cstate
, &cstate
->current_fh
,
1620 &cn
->cpn_src_stateid
, RD_STATE
, NULL
,
1625 cn
->cpn_sec
= nn
->nfsd4_lease
;
1628 status
= nfserrno(-ENOMEM
);
1629 cps
= nfs4_alloc_init_cpntf_state(nn
, stid
);
1632 memcpy(&cn
->cpn_cnr_stateid
, &cps
->cp_stateid
.stid
, sizeof(stateid_t
));
1633 memcpy(&cps
->cp_p_stateid
, &stid
->sc_stateid
, sizeof(stateid_t
));
1634 memcpy(&cps
->cp_p_clid
, &clp
->cl_clientid
, sizeof(clientid_t
));
1636 /* For now, only return one server address in cpn_src, the
1637 * address used by the client to connect to this server.
1639 cn
->cpn_src
.nl4_type
= NL4_NETADDR
;
1640 status
= nfsd4_set_netaddr((struct sockaddr
*)&rqstp
->rq_daddr
,
1641 &cn
->cpn_src
.u
.nl4_addr
);
1642 WARN_ON_ONCE(status
);
1644 nfs4_put_cpntf_state(nn
, cps
);
1648 nfs4_put_stid(stid
);
1653 nfsd4_fallocate(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
1654 struct nfsd4_fallocate
*fallocate
, int flags
)
1657 struct nfsd_file
*nf
;
1659 status
= nfs4_preprocess_stateid_op(rqstp
, cstate
, &cstate
->current_fh
,
1660 &fallocate
->falloc_stateid
,
1661 WR_STATE
, &nf
, NULL
);
1662 if (status
!= nfs_ok
) {
1663 dprintk("NFSD: nfsd4_fallocate: couldn't process stateid!\n");
1667 status
= nfsd4_vfs_fallocate(rqstp
, &cstate
->current_fh
, nf
->nf_file
,
1668 fallocate
->falloc_offset
,
1669 fallocate
->falloc_length
,
1675 nfsd4_offload_status(struct svc_rqst
*rqstp
,
1676 struct nfsd4_compound_state
*cstate
,
1677 union nfsd4_op_u
*u
)
1679 struct nfsd4_offload_status
*os
= &u
->offload_status
;
1681 struct nfsd4_copy
*copy
;
1682 struct nfs4_client
*clp
= cstate
->clp
;
1684 copy
= find_async_copy(clp
, &os
->stateid
);
1686 os
->count
= copy
->cp_res
.wr_bytes_written
;
1687 nfs4_put_copy(copy
);
1689 status
= nfserr_bad_stateid
;
1695 nfsd4_allocate(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
1696 union nfsd4_op_u
*u
)
1698 return nfsd4_fallocate(rqstp
, cstate
, &u
->allocate
, 0);
1702 nfsd4_deallocate(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
1703 union nfsd4_op_u
*u
)
1705 return nfsd4_fallocate(rqstp
, cstate
, &u
->deallocate
,
1706 FALLOC_FL_PUNCH_HOLE
| FALLOC_FL_KEEP_SIZE
);
1710 nfsd4_seek(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
1711 union nfsd4_op_u
*u
)
1713 struct nfsd4_seek
*seek
= &u
->seek
;
1716 struct nfsd_file
*nf
;
1718 status
= nfs4_preprocess_stateid_op(rqstp
, cstate
, &cstate
->current_fh
,
1719 &seek
->seek_stateid
,
1720 RD_STATE
, &nf
, NULL
);
1722 dprintk("NFSD: nfsd4_seek: couldn't process stateid!\n");
1726 switch (seek
->seek_whence
) {
1727 case NFS4_CONTENT_DATA
:
1730 case NFS4_CONTENT_HOLE
:
1734 status
= nfserr_union_notsupp
;
1739 * Note: This call does change file->f_pos, but nothing in NFSD
1740 * should ever file->f_pos.
1742 seek
->seek_pos
= vfs_llseek(nf
->nf_file
, seek
->seek_offset
, whence
);
1743 if (seek
->seek_pos
< 0)
1744 status
= nfserrno(seek
->seek_pos
);
1745 else if (seek
->seek_pos
>= i_size_read(file_inode(nf
->nf_file
)))
1746 seek
->seek_eof
= true;
1753 /* This routine never returns NFS_OK! If there are no other errors, it
1754 * will return NFSERR_SAME or NFSERR_NOT_SAME depending on whether the
1755 * attributes matched. VERIFY is implemented by mapping NFSERR_SAME
1756 * to NFS_OK after the call; NVERIFY by mapping NFSERR_NOT_SAME to NFS_OK.
1759 _nfsd4_verify(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
1760 struct nfsd4_verify
*verify
)
1766 status
= fh_verify(rqstp
, &cstate
->current_fh
, 0, NFSD_MAY_NOP
);
1770 status
= check_attr_support(rqstp
, cstate
, verify
->ve_bmval
, NULL
);
1774 if ((verify
->ve_bmval
[0] & FATTR4_WORD0_RDATTR_ERROR
)
1775 || (verify
->ve_bmval
[1] & NFSD_WRITEONLY_ATTRS_WORD1
))
1776 return nfserr_inval
;
1777 if (verify
->ve_attrlen
& 3)
1778 return nfserr_inval
;
1781 * bitmap_len(1) + bitmap(2) + attr_len(1) = 4
1783 count
= 4 + (verify
->ve_attrlen
>> 2);
1784 buf
= kmalloc(count
<< 2, GFP_KERNEL
);
1786 return nfserr_jukebox
;
1789 status
= nfsd4_encode_fattr_to_buf(&p
, count
, &cstate
->current_fh
,
1790 cstate
->current_fh
.fh_export
,
1791 cstate
->current_fh
.fh_dentry
,
1795 * If nfsd4_encode_fattr() ran out of space, assume that's because
1796 * the attributes are longer (hence different) than those given:
1798 if (status
== nfserr_resource
)
1799 status
= nfserr_not_same
;
1804 p
= buf
+ 1 + ntohl(buf
[0]);
1805 status
= nfserr_not_same
;
1806 if (ntohl(*p
++) != verify
->ve_attrlen
)
1808 if (!memcmp(p
, verify
->ve_attrval
, verify
->ve_attrlen
))
1809 status
= nfserr_same
;
1817 nfsd4_nverify(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
1818 union nfsd4_op_u
*u
)
1822 status
= _nfsd4_verify(rqstp
, cstate
, &u
->verify
);
1823 return status
== nfserr_not_same
? nfs_ok
: status
;
1827 nfsd4_verify(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
1828 union nfsd4_op_u
*u
)
1832 status
= _nfsd4_verify(rqstp
, cstate
, &u
->nverify
);
1833 return status
== nfserr_same
? nfs_ok
: status
;
1836 #ifdef CONFIG_NFSD_PNFS
1837 static const struct nfsd4_layout_ops
*
1838 nfsd4_layout_verify(struct svc_export
*exp
, unsigned int layout_type
)
1840 if (!exp
->ex_layout_types
) {
1841 dprintk("%s: export does not support pNFS\n", __func__
);
1845 if (layout_type
>= LAYOUT_TYPE_MAX
||
1846 !(exp
->ex_layout_types
& (1 << layout_type
))) {
1847 dprintk("%s: layout type %d not supported\n",
1848 __func__
, layout_type
);
1852 return nfsd4_layout_ops
[layout_type
];
1856 nfsd4_getdeviceinfo(struct svc_rqst
*rqstp
,
1857 struct nfsd4_compound_state
*cstate
, union nfsd4_op_u
*u
)
1859 struct nfsd4_getdeviceinfo
*gdp
= &u
->getdeviceinfo
;
1860 const struct nfsd4_layout_ops
*ops
;
1861 struct nfsd4_deviceid_map
*map
;
1862 struct svc_export
*exp
;
1865 dprintk("%s: layout_type %u dev_id [0x%llx:0x%x] maxcnt %u\n",
1867 gdp
->gd_layout_type
,
1868 gdp
->gd_devid
.fsid_idx
, gdp
->gd_devid
.generation
,
1871 map
= nfsd4_find_devid_map(gdp
->gd_devid
.fsid_idx
);
1873 dprintk("%s: couldn't find device ID to export mapping!\n",
1875 return nfserr_noent
;
1878 exp
= rqst_exp_find(rqstp
, map
->fsid_type
, map
->fsid
);
1880 dprintk("%s: could not find device id\n", __func__
);
1881 return nfserr_noent
;
1884 nfserr
= nfserr_layoutunavailable
;
1885 ops
= nfsd4_layout_verify(exp
, gdp
->gd_layout_type
);
1890 if (gdp
->gd_maxcount
!= 0) {
1891 nfserr
= ops
->proc_getdeviceinfo(exp
->ex_path
.mnt
->mnt_sb
,
1892 rqstp
, cstate
->clp
, gdp
);
1895 gdp
->gd_notify_types
&= ops
->notify_types
;
1902 nfsd4_getdeviceinfo_release(union nfsd4_op_u
*u
)
1904 kfree(u
->getdeviceinfo
.gd_device
);
1908 nfsd4_layoutget(struct svc_rqst
*rqstp
,
1909 struct nfsd4_compound_state
*cstate
, union nfsd4_op_u
*u
)
1911 struct nfsd4_layoutget
*lgp
= &u
->layoutget
;
1912 struct svc_fh
*current_fh
= &cstate
->current_fh
;
1913 const struct nfsd4_layout_ops
*ops
;
1914 struct nfs4_layout_stateid
*ls
;
1916 int accmode
= NFSD_MAY_READ_IF_EXEC
;
1918 switch (lgp
->lg_seg
.iomode
) {
1920 accmode
|= NFSD_MAY_READ
;
1923 accmode
|= NFSD_MAY_READ
| NFSD_MAY_WRITE
;
1926 dprintk("%s: invalid iomode %d\n",
1927 __func__
, lgp
->lg_seg
.iomode
);
1928 nfserr
= nfserr_badiomode
;
1932 nfserr
= fh_verify(rqstp
, current_fh
, 0, accmode
);
1936 nfserr
= nfserr_layoutunavailable
;
1937 ops
= nfsd4_layout_verify(current_fh
->fh_export
, lgp
->lg_layout_type
);
1942 * Verify minlength and range as per RFC5661:
1943 * o If loga_length is less than loga_minlength,
1944 * the metadata server MUST return NFS4ERR_INVAL.
1945 * o If the sum of loga_offset and loga_minlength exceeds
1946 * NFS4_UINT64_MAX, and loga_minlength is not
1947 * NFS4_UINT64_MAX, the error NFS4ERR_INVAL MUST result.
1948 * o If the sum of loga_offset and loga_length exceeds
1949 * NFS4_UINT64_MAX, and loga_length is not NFS4_UINT64_MAX,
1950 * the error NFS4ERR_INVAL MUST result.
1952 nfserr
= nfserr_inval
;
1953 if (lgp
->lg_seg
.length
< lgp
->lg_minlength
||
1954 (lgp
->lg_minlength
!= NFS4_MAX_UINT64
&&
1955 lgp
->lg_minlength
> NFS4_MAX_UINT64
- lgp
->lg_seg
.offset
) ||
1956 (lgp
->lg_seg
.length
!= NFS4_MAX_UINT64
&&
1957 lgp
->lg_seg
.length
> NFS4_MAX_UINT64
- lgp
->lg_seg
.offset
))
1959 if (lgp
->lg_seg
.length
== 0)
1962 nfserr
= nfsd4_preprocess_layout_stateid(rqstp
, cstate
, &lgp
->lg_sid
,
1963 true, lgp
->lg_layout_type
, &ls
);
1965 trace_nfsd_layout_get_lookup_fail(&lgp
->lg_sid
);
1969 nfserr
= nfserr_recallconflict
;
1970 if (atomic_read(&ls
->ls_stid
.sc_file
->fi_lo_recalls
))
1973 nfserr
= ops
->proc_layoutget(d_inode(current_fh
->fh_dentry
),
1978 nfserr
= nfsd4_insert_layout(lgp
, ls
);
1981 mutex_unlock(&ls
->ls_mutex
);
1982 nfs4_put_stid(&ls
->ls_stid
);
1988 nfsd4_layoutget_release(union nfsd4_op_u
*u
)
1990 kfree(u
->layoutget
.lg_content
);
1994 nfsd4_layoutcommit(struct svc_rqst
*rqstp
,
1995 struct nfsd4_compound_state
*cstate
, union nfsd4_op_u
*u
)
1997 struct nfsd4_layoutcommit
*lcp
= &u
->layoutcommit
;
1998 const struct nfsd4_layout_seg
*seg
= &lcp
->lc_seg
;
1999 struct svc_fh
*current_fh
= &cstate
->current_fh
;
2000 const struct nfsd4_layout_ops
*ops
;
2001 loff_t new_size
= lcp
->lc_last_wr
+ 1;
2002 struct inode
*inode
;
2003 struct nfs4_layout_stateid
*ls
;
2006 nfserr
= fh_verify(rqstp
, current_fh
, 0, NFSD_MAY_WRITE
);
2010 nfserr
= nfserr_layoutunavailable
;
2011 ops
= nfsd4_layout_verify(current_fh
->fh_export
, lcp
->lc_layout_type
);
2014 inode
= d_inode(current_fh
->fh_dentry
);
2016 nfserr
= nfserr_inval
;
2017 if (new_size
<= seg
->offset
) {
2018 dprintk("pnfsd: last write before layout segment\n");
2021 if (new_size
> seg
->offset
+ seg
->length
) {
2022 dprintk("pnfsd: last write beyond layout segment\n");
2025 if (!lcp
->lc_newoffset
&& new_size
> i_size_read(inode
)) {
2026 dprintk("pnfsd: layoutcommit beyond EOF\n");
2030 nfserr
= nfsd4_preprocess_layout_stateid(rqstp
, cstate
, &lcp
->lc_sid
,
2031 false, lcp
->lc_layout_type
,
2034 trace_nfsd_layout_commit_lookup_fail(&lcp
->lc_sid
);
2035 /* fixup error code as per RFC5661 */
2036 if (nfserr
== nfserr_bad_stateid
)
2037 nfserr
= nfserr_badlayout
;
2041 /* LAYOUTCOMMIT does not require any serialization */
2042 mutex_unlock(&ls
->ls_mutex
);
2044 if (new_size
> i_size_read(inode
)) {
2045 lcp
->lc_size_chg
= 1;
2046 lcp
->lc_newsize
= new_size
;
2048 lcp
->lc_size_chg
= 0;
2051 nfserr
= ops
->proc_layoutcommit(inode
, lcp
);
2052 nfs4_put_stid(&ls
->ls_stid
);
2058 nfsd4_layoutreturn(struct svc_rqst
*rqstp
,
2059 struct nfsd4_compound_state
*cstate
, union nfsd4_op_u
*u
)
2061 struct nfsd4_layoutreturn
*lrp
= &u
->layoutreturn
;
2062 struct svc_fh
*current_fh
= &cstate
->current_fh
;
2065 nfserr
= fh_verify(rqstp
, current_fh
, 0, NFSD_MAY_NOP
);
2069 nfserr
= nfserr_layoutunavailable
;
2070 if (!nfsd4_layout_verify(current_fh
->fh_export
, lrp
->lr_layout_type
))
2073 switch (lrp
->lr_seg
.iomode
) {
2079 dprintk("%s: invalid iomode %d\n", __func__
,
2080 lrp
->lr_seg
.iomode
);
2081 nfserr
= nfserr_inval
;
2085 switch (lrp
->lr_return_type
) {
2087 nfserr
= nfsd4_return_file_layouts(rqstp
, cstate
, lrp
);
2091 nfserr
= nfsd4_return_client_layouts(rqstp
, cstate
, lrp
);
2094 dprintk("%s: invalid return_type %d\n", __func__
,
2095 lrp
->lr_return_type
);
2096 nfserr
= nfserr_inval
;
2102 #endif /* CONFIG_NFSD_PNFS */
2105 nfsd4_getxattr(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
2106 union nfsd4_op_u
*u
)
2108 struct nfsd4_getxattr
*getxattr
= &u
->getxattr
;
2110 return nfsd_getxattr(rqstp
, &cstate
->current_fh
,
2111 getxattr
->getxa_name
, &getxattr
->getxa_buf
,
2112 &getxattr
->getxa_len
);
2116 nfsd4_setxattr(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
2117 union nfsd4_op_u
*u
)
2119 struct nfsd4_setxattr
*setxattr
= &u
->setxattr
;
2122 if (opens_in_grace(SVC_NET(rqstp
)))
2123 return nfserr_grace
;
2125 ret
= nfsd_setxattr(rqstp
, &cstate
->current_fh
, setxattr
->setxa_name
,
2126 setxattr
->setxa_buf
, setxattr
->setxa_len
,
2127 setxattr
->setxa_flags
);
2130 set_change_info(&setxattr
->setxa_cinfo
, &cstate
->current_fh
);
2136 nfsd4_listxattrs(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
2137 union nfsd4_op_u
*u
)
2140 * Get the entire list, then copy out only the user attributes
2141 * in the encode function.
2143 return nfsd_listxattr(rqstp
, &cstate
->current_fh
,
2144 &u
->listxattrs
.lsxa_buf
, &u
->listxattrs
.lsxa_len
);
2148 nfsd4_removexattr(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
2149 union nfsd4_op_u
*u
)
2151 struct nfsd4_removexattr
*removexattr
= &u
->removexattr
;
2154 if (opens_in_grace(SVC_NET(rqstp
)))
2155 return nfserr_grace
;
2157 ret
= nfsd_removexattr(rqstp
, &cstate
->current_fh
,
2158 removexattr
->rmxa_name
);
2161 set_change_info(&removexattr
->rmxa_cinfo
, &cstate
->current_fh
);
2170 nfsd4_proc_null(struct svc_rqst
*rqstp
)
2175 static inline void nfsd4_increment_op_stats(u32 opnum
)
2177 if (opnum
>= FIRST_NFS4_OP
&& opnum
<= LAST_NFS4_OP
)
2178 percpu_counter_inc(&nfsdstats
.counter
[NFSD_STATS_NFS4_OP(opnum
)]);
2181 static const struct nfsd4_operation nfsd4_ops
[];
2183 static const char *nfsd4_op_name(unsigned opnum
);
2186 * Enforce NFSv4.1 COMPOUND ordering rules:
2188 * Also note, enforced elsewhere:
2189 * - SEQUENCE other than as first op results in
2190 * NFS4ERR_SEQUENCE_POS. (Enforced in nfsd4_sequence().)
2191 * - BIND_CONN_TO_SESSION must be the only op in its compound.
2192 * (Enforced in nfsd4_bind_conn_to_session().)
2193 * - DESTROY_SESSION must be the final operation in a compound, if
2194 * sessionid's in SEQUENCE and DESTROY_SESSION are the same.
2195 * (Enforced in nfsd4_destroy_session().)
2197 static __be32
nfs41_check_op_ordering(struct nfsd4_compoundargs
*args
)
2199 struct nfsd4_op
*first_op
= &args
->ops
[0];
2201 /* These ordering requirements don't apply to NFSv4.0: */
2202 if (args
->minorversion
== 0)
2204 /* This is weird, but OK, not our problem: */
2205 if (args
->opcnt
== 0)
2207 if (first_op
->status
== nfserr_op_illegal
)
2209 if (!(nfsd4_ops
[first_op
->opnum
].op_flags
& ALLOWED_AS_FIRST_OP
))
2210 return nfserr_op_not_in_session
;
2211 if (first_op
->opnum
== OP_SEQUENCE
)
2214 * So first_op is something allowed outside a session, like
2215 * EXCHANGE_ID; but then it has to be the only op in the
2218 if (args
->opcnt
!= 1)
2219 return nfserr_not_only_op
;
2223 const struct nfsd4_operation
*OPDESC(struct nfsd4_op
*op
)
2225 return &nfsd4_ops
[op
->opnum
];
2228 bool nfsd4_cache_this_op(struct nfsd4_op
*op
)
2230 if (op
->opnum
== OP_ILLEGAL
)
2232 return OPDESC(op
)->op_flags
& OP_CACHEME
;
2235 static bool need_wrongsec_check(struct svc_rqst
*rqstp
)
2237 struct nfsd4_compoundres
*resp
= rqstp
->rq_resp
;
2238 struct nfsd4_compoundargs
*argp
= rqstp
->rq_argp
;
2239 struct nfsd4_op
*this = &argp
->ops
[resp
->opcnt
- 1];
2240 struct nfsd4_op
*next
= &argp
->ops
[resp
->opcnt
];
2241 const struct nfsd4_operation
*thisd
= OPDESC(this);
2242 const struct nfsd4_operation
*nextd
;
2245 * Most ops check wronsec on our own; only the putfh-like ops
2246 * have special rules.
2248 if (!(thisd
->op_flags
& OP_IS_PUTFH_LIKE
))
2251 * rfc 5661 2.6.3.1.1.6: don't bother erroring out a
2252 * put-filehandle operation if we're not going to use the
2255 if (argp
->opcnt
== resp
->opcnt
)
2257 if (next
->opnum
== OP_ILLEGAL
)
2259 nextd
= OPDESC(next
);
2261 * Rest of 2.6.3.1.1: certain operations will return WRONGSEC
2262 * errors themselves as necessary; others should check for them
2265 return !(nextd
->op_flags
& OP_HANDLES_WRONGSEC
);
2268 #ifdef CONFIG_NFSD_V4_2_INTER_SSC
2270 check_if_stalefh_allowed(struct nfsd4_compoundargs
*args
)
2272 struct nfsd4_op
*op
, *current_op
= NULL
, *saved_op
= NULL
;
2273 struct nfsd4_copy
*copy
;
2274 struct nfsd4_putfh
*putfh
;
2277 /* traverse all operation and if it's a COPY compound, mark the
2278 * source filehandle to skip verification
2280 for (i
= 0; i
< args
->opcnt
; i
++) {
2282 if (op
->opnum
== OP_PUTFH
)
2284 else if (op
->opnum
== OP_SAVEFH
)
2285 saved_op
= current_op
;
2286 else if (op
->opnum
== OP_RESTOREFH
)
2287 current_op
= saved_op
;
2288 else if (op
->opnum
== OP_COPY
) {
2289 copy
= (struct nfsd4_copy
*)&op
->u
;
2291 op
->status
= nfserr_nofilehandle
;
2294 putfh
= (struct nfsd4_putfh
*)&saved_op
->u
;
2295 if (!copy
->cp_intra
)
2296 putfh
->no_verify
= true;
2302 check_if_stalefh_allowed(struct nfsd4_compoundargs
*args
)
2311 nfsd4_proc_compound(struct svc_rqst
*rqstp
)
2313 struct nfsd4_compoundargs
*args
= rqstp
->rq_argp
;
2314 struct nfsd4_compoundres
*resp
= rqstp
->rq_resp
;
2315 struct nfsd4_op
*op
;
2316 struct nfsd4_compound_state
*cstate
= &resp
->cstate
;
2317 struct svc_fh
*current_fh
= &cstate
->current_fh
;
2318 struct svc_fh
*save_fh
= &cstate
->save_fh
;
2319 struct nfsd_net
*nn
= net_generic(SVC_NET(rqstp
), nfsd_net_id
);
2322 resp
->xdr
= &rqstp
->rq_res_stream
;
2324 /* reserve space for: NFS status code */
2325 xdr_reserve_space(resp
->xdr
, XDR_UNIT
);
2327 resp
->tagp
= resp
->xdr
->p
;
2328 /* reserve space for: taglen, tag, and opcnt */
2329 xdr_reserve_space(resp
->xdr
, XDR_UNIT
* 2 + args
->taglen
);
2330 resp
->taglen
= args
->taglen
;
2331 resp
->tag
= args
->tag
;
2332 resp
->rqstp
= rqstp
;
2333 cstate
->minorversion
= args
->minorversion
;
2334 fh_init(current_fh
, NFS4_FHSIZE
);
2335 fh_init(save_fh
, NFS4_FHSIZE
);
2337 * Don't use the deferral mechanism for NFSv4; compounds make it
2338 * too hard to avoid non-idempotency problems.
2340 clear_bit(RQ_USEDEFERRAL
, &rqstp
->rq_flags
);
2343 * According to RFC3010, this takes precedence over all other errors.
2345 status
= nfserr_minor_vers_mismatch
;
2346 if (nfsd_minorversion(nn
, args
->minorversion
, NFSD_TEST
) <= 0)
2348 status
= nfserr_resource
;
2349 if (args
->opcnt
> NFSD_MAX_OPS_PER_COMPOUND
)
2352 status
= nfs41_check_op_ordering(args
);
2355 op
->status
= status
;
2359 check_if_stalefh_allowed(args
);
2361 rqstp
->rq_lease_breaker
= (void **)&cstate
->clp
;
2363 trace_nfsd_compound(rqstp
, args
->opcnt
);
2364 while (!status
&& resp
->opcnt
< args
->opcnt
) {
2365 op
= &args
->ops
[resp
->opcnt
++];
2368 * The XDR decode routines may have pre-set op->status;
2369 * for example, if there is a miscellaneous XDR error
2370 * it will be set to nfserr_bad_xdr.
2373 if (op
->opnum
== OP_OPEN
)
2374 op
->status
= nfsd4_open_omfg(rqstp
, cstate
, op
);
2377 if (!current_fh
->fh_dentry
&&
2378 !HAS_FH_FLAG(current_fh
, NFSD4_FH_FOREIGN
)) {
2379 if (!(op
->opdesc
->op_flags
& ALLOWED_WITHOUT_FH
)) {
2380 op
->status
= nfserr_nofilehandle
;
2383 } else if (current_fh
->fh_export
&&
2384 current_fh
->fh_export
->ex_fslocs
.migrated
&&
2385 !(op
->opdesc
->op_flags
& ALLOWED_ON_ABSENT_FS
)) {
2386 op
->status
= nfserr_moved
;
2390 fh_clear_wcc(current_fh
);
2392 /* If op is non-idempotent */
2393 if (op
->opdesc
->op_flags
& OP_MODIFIES_SOMETHING
) {
2395 * Don't execute this op if we couldn't encode a
2398 u32 plen
= op
->opdesc
->op_rsize_bop(rqstp
, op
);
2400 * Plus if there's another operation, make sure
2401 * we'll have space to at least encode an error:
2403 if (resp
->opcnt
< args
->opcnt
)
2404 plen
+= COMPOUND_ERR_SLACK_SPACE
;
2405 op
->status
= nfsd4_check_resp_size(resp
, plen
);
2411 if (op
->opdesc
->op_get_currentstateid
)
2412 op
->opdesc
->op_get_currentstateid(cstate
, &op
->u
);
2413 op
->status
= op
->opdesc
->op_func(rqstp
, cstate
, &op
->u
);
2415 /* Only from SEQUENCE */
2416 if (cstate
->status
== nfserr_replay_cache
) {
2417 dprintk("%s NFS4.1 replay from cache\n", __func__
);
2418 status
= op
->status
;
2422 if (op
->opdesc
->op_set_currentstateid
)
2423 op
->opdesc
->op_set_currentstateid(cstate
, &op
->u
);
2425 if (op
->opdesc
->op_flags
& OP_CLEAR_STATEID
)
2426 clear_current_stateid(cstate
);
2428 if (current_fh
->fh_export
&&
2429 need_wrongsec_check(rqstp
))
2430 op
->status
= check_nfsd_access(current_fh
->fh_export
, rqstp
);
2433 if (op
->status
== nfserr_replay_me
) {
2434 op
->replay
= &cstate
->replay_owner
->so_replay
;
2435 nfsd4_encode_replay(resp
->xdr
, op
);
2436 status
= op
->status
= op
->replay
->rp_status
;
2438 nfsd4_encode_operation(resp
, op
);
2439 status
= op
->status
;
2442 trace_nfsd_compound_status(args
->opcnt
, resp
->opcnt
, status
,
2443 nfsd4_op_name(op
->opnum
));
2445 nfsd4_cstate_clear_replay(cstate
);
2446 nfsd4_increment_op_stats(op
->opnum
);
2451 BUG_ON(cstate
->replay_owner
);
2453 cstate
->status
= status
;
2454 /* Reset deferral mechanism for RPC deferrals */
2455 set_bit(RQ_USEDEFERRAL
, &rqstp
->rq_flags
);
2459 #define op_encode_hdr_size (2)
2460 #define op_encode_stateid_maxsz (XDR_QUADLEN(NFS4_STATEID_SIZE))
2461 #define op_encode_verifier_maxsz (XDR_QUADLEN(NFS4_VERIFIER_SIZE))
2462 #define op_encode_change_info_maxsz (5)
2463 #define nfs4_fattr_bitmap_maxsz (4)
2465 /* We'll fall back on returning no lockowner if run out of space: */
2466 #define op_encode_lockowner_maxsz (0)
2467 #define op_encode_lock_denied_maxsz (8 + op_encode_lockowner_maxsz)
2469 #define nfs4_owner_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
2471 #define op_encode_ace_maxsz (3 + nfs4_owner_maxsz)
2472 #define op_encode_delegation_maxsz (1 + op_encode_stateid_maxsz + 1 + \
2473 op_encode_ace_maxsz)
2475 #define op_encode_channel_attrs_maxsz (6 + 1 + 1)
2477 static inline u32
nfsd4_only_status_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2479 return (op_encode_hdr_size
) * sizeof(__be32
);
2482 static inline u32
nfsd4_status_stateid_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2484 return (op_encode_hdr_size
+ op_encode_stateid_maxsz
)* sizeof(__be32
);
2487 static inline u32
nfsd4_access_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2489 /* ac_supported, ac_resp_access */
2490 return (op_encode_hdr_size
+ 2)* sizeof(__be32
);
2493 static inline u32
nfsd4_commit_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2495 return (op_encode_hdr_size
+ op_encode_verifier_maxsz
) * sizeof(__be32
);
2498 static inline u32
nfsd4_create_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2500 return (op_encode_hdr_size
+ op_encode_change_info_maxsz
2501 + nfs4_fattr_bitmap_maxsz
) * sizeof(__be32
);
2505 * Note since this is an idempotent operation we won't insist on failing
2506 * the op prematurely if the estimate is too large. We may turn off splice
2507 * reads unnecessarily.
2509 static inline u32
nfsd4_getattr_rsize(struct svc_rqst
*rqstp
,
2510 struct nfsd4_op
*op
)
2512 u32
*bmap
= op
->u
.getattr
.ga_bmval
;
2513 u32 bmap0
= bmap
[0], bmap1
= bmap
[1], bmap2
= bmap
[2];
2516 if (bmap0
& FATTR4_WORD0_ACL
)
2517 return svc_max_payload(rqstp
);
2518 if (bmap0
& FATTR4_WORD0_FS_LOCATIONS
)
2519 return svc_max_payload(rqstp
);
2521 if (bmap1
& FATTR4_WORD1_OWNER
) {
2522 ret
+= IDMAP_NAMESZ
+ 4;
2523 bmap1
&= ~FATTR4_WORD1_OWNER
;
2525 if (bmap1
& FATTR4_WORD1_OWNER_GROUP
) {
2526 ret
+= IDMAP_NAMESZ
+ 4;
2527 bmap1
&= ~FATTR4_WORD1_OWNER_GROUP
;
2529 if (bmap0
& FATTR4_WORD0_FILEHANDLE
) {
2530 ret
+= NFS4_FHSIZE
+ 4;
2531 bmap0
&= ~FATTR4_WORD0_FILEHANDLE
;
2533 if (bmap2
& FATTR4_WORD2_SECURITY_LABEL
) {
2534 ret
+= NFS4_MAXLABELLEN
+ 12;
2535 bmap2
&= ~FATTR4_WORD2_SECURITY_LABEL
;
2538 * Largest of remaining attributes are 16 bytes (e.g.,
2539 * supported_attributes)
2541 ret
+= 16 * (hweight32(bmap0
) + hweight32(bmap1
) + hweight32(bmap2
));
2542 /* bitmask, length */
2547 static inline u32
nfsd4_getfh_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2549 return (op_encode_hdr_size
+ 1) * sizeof(__be32
) + NFS4_FHSIZE
;
2552 static inline u32
nfsd4_link_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2554 return (op_encode_hdr_size
+ op_encode_change_info_maxsz
)
2558 static inline u32
nfsd4_lock_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2560 return (op_encode_hdr_size
+ op_encode_lock_denied_maxsz
)
2564 static inline u32
nfsd4_open_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2566 return (op_encode_hdr_size
+ op_encode_stateid_maxsz
2567 + op_encode_change_info_maxsz
+ 1
2568 + nfs4_fattr_bitmap_maxsz
2569 + op_encode_delegation_maxsz
) * sizeof(__be32
);
2572 static inline u32
nfsd4_read_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2574 u32 maxcount
= 0, rlen
= 0;
2576 maxcount
= svc_max_payload(rqstp
);
2577 rlen
= min(op
->u
.read
.rd_length
, maxcount
);
2579 return (op_encode_hdr_size
+ 2 + XDR_QUADLEN(rlen
)) * sizeof(__be32
);
2582 static inline u32
nfsd4_read_plus_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2584 u32 maxcount
= svc_max_payload(rqstp
);
2585 u32 rlen
= min(op
->u
.read
.rd_length
, maxcount
);
2587 * If we detect that the file changed during hole encoding, then we
2588 * recover by encoding the remaining reply as data. This means we need
2589 * to set aside enough room to encode two data segments.
2591 u32 seg_len
= 2 * (1 + 2 + 1);
2593 return (op_encode_hdr_size
+ 2 + seg_len
+ XDR_QUADLEN(rlen
)) * sizeof(__be32
);
2596 static inline u32
nfsd4_readdir_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2598 u32 maxcount
= 0, rlen
= 0;
2600 maxcount
= svc_max_payload(rqstp
);
2601 rlen
= min(op
->u
.readdir
.rd_maxcount
, maxcount
);
2603 return (op_encode_hdr_size
+ op_encode_verifier_maxsz
+
2604 XDR_QUADLEN(rlen
)) * sizeof(__be32
);
2607 static inline u32
nfsd4_readlink_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2609 return (op_encode_hdr_size
+ 1) * sizeof(__be32
) + PAGE_SIZE
;
2612 static inline u32
nfsd4_remove_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2614 return (op_encode_hdr_size
+ op_encode_change_info_maxsz
)
2618 static inline u32
nfsd4_rename_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2620 return (op_encode_hdr_size
+ op_encode_change_info_maxsz
2621 + op_encode_change_info_maxsz
) * sizeof(__be32
);
2624 static inline u32
nfsd4_sequence_rsize(struct svc_rqst
*rqstp
,
2625 struct nfsd4_op
*op
)
2627 return (op_encode_hdr_size
2628 + XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN
) + 5) * sizeof(__be32
);
2631 static inline u32
nfsd4_test_stateid_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2633 return (op_encode_hdr_size
+ 1 + op
->u
.test_stateid
.ts_num_ids
)
2637 static inline u32
nfsd4_setattr_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2639 return (op_encode_hdr_size
+ nfs4_fattr_bitmap_maxsz
) * sizeof(__be32
);
2642 static inline u32
nfsd4_secinfo_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2644 return (op_encode_hdr_size
+ RPC_AUTH_MAXFLAVOR
*
2645 (4 + XDR_QUADLEN(GSS_OID_MAX_LEN
))) * sizeof(__be32
);
2648 static inline u32
nfsd4_setclientid_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2650 return (op_encode_hdr_size
+ 2 + XDR_QUADLEN(NFS4_VERIFIER_SIZE
)) *
2654 static inline u32
nfsd4_write_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2656 return (op_encode_hdr_size
+ 2 + op_encode_verifier_maxsz
) * sizeof(__be32
);
2659 static inline u32
nfsd4_exchange_id_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2661 return (op_encode_hdr_size
+ 2 + 1 + /* eir_clientid, eir_sequenceid */\
2662 1 + 1 + /* eir_flags, spr_how */\
2663 4 + /* spo_must_enforce & _allow with bitmap */\
2664 2 + /*eir_server_owner.so_minor_id */\
2665 /* eir_server_owner.so_major_id<> */\
2666 XDR_QUADLEN(NFS4_OPAQUE_LIMIT
) + 1 +\
2667 /* eir_server_scope<> */\
2668 XDR_QUADLEN(NFS4_OPAQUE_LIMIT
) + 1 +\
2669 1 + /* eir_server_impl_id array length */\
2670 0 /* ignored eir_server_impl_id contents */) * sizeof(__be32
);
2673 static inline u32
nfsd4_bind_conn_to_session_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2675 return (op_encode_hdr_size
+ \
2676 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN
) + /* bctsr_sessid */\
2677 2 /* bctsr_dir, use_conn_in_rdma_mode */) * sizeof(__be32
);
2680 static inline u32
nfsd4_create_session_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2682 return (op_encode_hdr_size
+ \
2683 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN
) + /* sessionid */\
2684 2 + /* csr_sequence, csr_flags */\
2685 op_encode_channel_attrs_maxsz
+ \
2686 op_encode_channel_attrs_maxsz
) * sizeof(__be32
);
2689 static inline u32
nfsd4_copy_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2691 return (op_encode_hdr_size
+
2692 1 /* wr_callback */ +
2693 op_encode_stateid_maxsz
/* wr_callback */ +
2695 1 /* wr_committed */ +
2696 op_encode_verifier_maxsz
+
2697 1 /* cr_consecutive */ +
2698 1 /* cr_synchronous */) * sizeof(__be32
);
2701 static inline u32
nfsd4_offload_status_rsize(struct svc_rqst
*rqstp
,
2702 struct nfsd4_op
*op
)
2704 return (op_encode_hdr_size
+
2706 1 /* osr_complete<1> optional 0 for now */) * sizeof(__be32
);
2709 static inline u32
nfsd4_copy_notify_rsize(struct svc_rqst
*rqstp
,
2710 struct nfsd4_op
*op
)
2712 return (op_encode_hdr_size
+
2713 3 /* cnr_lease_time */ +
2714 1 /* We support one cnr_source_server */ +
2715 1 /* cnr_stateid seq */ +
2716 op_encode_stateid_maxsz
/* cnr_stateid */ +
2717 1 /* num cnr_source_server*/ +
2720 XDR_QUADLEN(NFS4_OPAQUE_LIMIT
) /*nl4_loc + nl4_loc_sz */)
2724 #ifdef CONFIG_NFSD_PNFS
2725 static inline u32
nfsd4_getdeviceinfo_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2727 u32 maxcount
= 0, rlen
= 0;
2729 maxcount
= svc_max_payload(rqstp
);
2730 rlen
= min(op
->u
.getdeviceinfo
.gd_maxcount
, maxcount
);
2732 return (op_encode_hdr_size
+
2733 1 /* gd_layout_type*/ +
2735 2 /* gd_notify_types */) * sizeof(__be32
);
2739 * At this stage we don't really know what layout driver will handle the request,
2740 * so we need to define an arbitrary upper bound here.
2742 #define MAX_LAYOUT_SIZE 128
2743 static inline u32
nfsd4_layoutget_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2745 return (op_encode_hdr_size
+
2746 1 /* logr_return_on_close */ +
2747 op_encode_stateid_maxsz
+
2748 1 /* nr of layouts */ +
2749 MAX_LAYOUT_SIZE
) * sizeof(__be32
);
2752 static inline u32
nfsd4_layoutcommit_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2754 return (op_encode_hdr_size
+
2755 1 /* locr_newsize */ +
2756 2 /* ns_size */) * sizeof(__be32
);
2759 static inline u32
nfsd4_layoutreturn_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2761 return (op_encode_hdr_size
+
2762 1 /* lrs_stateid */ +
2763 op_encode_stateid_maxsz
) * sizeof(__be32
);
2765 #endif /* CONFIG_NFSD_PNFS */
2768 static inline u32
nfsd4_seek_rsize(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
2770 return (op_encode_hdr_size
+ 3) * sizeof(__be32
);
2773 static inline u32
nfsd4_getxattr_rsize(struct svc_rqst
*rqstp
,
2774 struct nfsd4_op
*op
)
2778 maxcount
= svc_max_payload(rqstp
);
2779 rlen
= min_t(u32
, XATTR_SIZE_MAX
, maxcount
);
2781 return (op_encode_hdr_size
+ 1 + XDR_QUADLEN(rlen
)) * sizeof(__be32
);
2784 static inline u32
nfsd4_setxattr_rsize(struct svc_rqst
*rqstp
,
2785 struct nfsd4_op
*op
)
2787 return (op_encode_hdr_size
+ op_encode_change_info_maxsz
)
2790 static inline u32
nfsd4_listxattrs_rsize(struct svc_rqst
*rqstp
,
2791 struct nfsd4_op
*op
)
2795 maxcount
= svc_max_payload(rqstp
);
2796 rlen
= min(op
->u
.listxattrs
.lsxa_maxcount
, maxcount
);
2798 return (op_encode_hdr_size
+ 4 + XDR_QUADLEN(rlen
)) * sizeof(__be32
);
2801 static inline u32
nfsd4_removexattr_rsize(struct svc_rqst
*rqstp
,
2802 struct nfsd4_op
*op
)
2804 return (op_encode_hdr_size
+ op_encode_change_info_maxsz
)
2809 static const struct nfsd4_operation nfsd4_ops
[] = {
2811 .op_func
= nfsd4_access
,
2812 .op_name
= "OP_ACCESS",
2813 .op_rsize_bop
= nfsd4_access_rsize
,
2816 .op_func
= nfsd4_close
,
2817 .op_flags
= OP_MODIFIES_SOMETHING
,
2818 .op_name
= "OP_CLOSE",
2819 .op_rsize_bop
= nfsd4_status_stateid_rsize
,
2820 .op_get_currentstateid
= nfsd4_get_closestateid
,
2821 .op_set_currentstateid
= nfsd4_set_closestateid
,
2824 .op_func
= nfsd4_commit
,
2825 .op_flags
= OP_MODIFIES_SOMETHING
,
2826 .op_name
= "OP_COMMIT",
2827 .op_rsize_bop
= nfsd4_commit_rsize
,
2830 .op_func
= nfsd4_create
,
2831 .op_flags
= OP_MODIFIES_SOMETHING
| OP_CACHEME
| OP_CLEAR_STATEID
,
2832 .op_name
= "OP_CREATE",
2833 .op_rsize_bop
= nfsd4_create_rsize
,
2835 [OP_DELEGRETURN
] = {
2836 .op_func
= nfsd4_delegreturn
,
2837 .op_flags
= OP_MODIFIES_SOMETHING
,
2838 .op_name
= "OP_DELEGRETURN",
2839 .op_rsize_bop
= nfsd4_only_status_rsize
,
2840 .op_get_currentstateid
= nfsd4_get_delegreturnstateid
,
2843 .op_func
= nfsd4_getattr
,
2844 .op_flags
= ALLOWED_ON_ABSENT_FS
,
2845 .op_rsize_bop
= nfsd4_getattr_rsize
,
2846 .op_name
= "OP_GETATTR",
2849 .op_func
= nfsd4_getfh
,
2850 .op_name
= "OP_GETFH",
2851 .op_rsize_bop
= nfsd4_getfh_rsize
,
2854 .op_func
= nfsd4_link
,
2855 .op_flags
= ALLOWED_ON_ABSENT_FS
| OP_MODIFIES_SOMETHING
2857 .op_name
= "OP_LINK",
2858 .op_rsize_bop
= nfsd4_link_rsize
,
2861 .op_func
= nfsd4_lock
,
2862 .op_flags
= OP_MODIFIES_SOMETHING
|
2863 OP_NONTRIVIAL_ERROR_ENCODE
,
2864 .op_name
= "OP_LOCK",
2865 .op_rsize_bop
= nfsd4_lock_rsize
,
2866 .op_set_currentstateid
= nfsd4_set_lockstateid
,
2869 .op_func
= nfsd4_lockt
,
2870 .op_flags
= OP_NONTRIVIAL_ERROR_ENCODE
,
2871 .op_name
= "OP_LOCKT",
2872 .op_rsize_bop
= nfsd4_lock_rsize
,
2875 .op_func
= nfsd4_locku
,
2876 .op_flags
= OP_MODIFIES_SOMETHING
,
2877 .op_name
= "OP_LOCKU",
2878 .op_rsize_bop
= nfsd4_status_stateid_rsize
,
2879 .op_get_currentstateid
= nfsd4_get_lockustateid
,
2882 .op_func
= nfsd4_lookup
,
2883 .op_flags
= OP_HANDLES_WRONGSEC
| OP_CLEAR_STATEID
,
2884 .op_name
= "OP_LOOKUP",
2885 .op_rsize_bop
= nfsd4_only_status_rsize
,
2888 .op_func
= nfsd4_lookupp
,
2889 .op_flags
= OP_HANDLES_WRONGSEC
| OP_CLEAR_STATEID
,
2890 .op_name
= "OP_LOOKUPP",
2891 .op_rsize_bop
= nfsd4_only_status_rsize
,
2894 .op_func
= nfsd4_nverify
,
2895 .op_name
= "OP_NVERIFY",
2896 .op_rsize_bop
= nfsd4_only_status_rsize
,
2899 .op_func
= nfsd4_open
,
2900 .op_flags
= OP_HANDLES_WRONGSEC
| OP_MODIFIES_SOMETHING
,
2901 .op_name
= "OP_OPEN",
2902 .op_rsize_bop
= nfsd4_open_rsize
,
2903 .op_set_currentstateid
= nfsd4_set_openstateid
,
2905 [OP_OPEN_CONFIRM
] = {
2906 .op_func
= nfsd4_open_confirm
,
2907 .op_flags
= OP_MODIFIES_SOMETHING
,
2908 .op_name
= "OP_OPEN_CONFIRM",
2909 .op_rsize_bop
= nfsd4_status_stateid_rsize
,
2911 [OP_OPEN_DOWNGRADE
] = {
2912 .op_func
= nfsd4_open_downgrade
,
2913 .op_flags
= OP_MODIFIES_SOMETHING
,
2914 .op_name
= "OP_OPEN_DOWNGRADE",
2915 .op_rsize_bop
= nfsd4_status_stateid_rsize
,
2916 .op_get_currentstateid
= nfsd4_get_opendowngradestateid
,
2917 .op_set_currentstateid
= nfsd4_set_opendowngradestateid
,
2920 .op_func
= nfsd4_putfh
,
2921 .op_flags
= ALLOWED_WITHOUT_FH
| ALLOWED_ON_ABSENT_FS
2922 | OP_IS_PUTFH_LIKE
| OP_CLEAR_STATEID
,
2923 .op_name
= "OP_PUTFH",
2924 .op_rsize_bop
= nfsd4_only_status_rsize
,
2927 .op_func
= nfsd4_putrootfh
,
2928 .op_flags
= ALLOWED_WITHOUT_FH
| ALLOWED_ON_ABSENT_FS
2929 | OP_IS_PUTFH_LIKE
| OP_CLEAR_STATEID
,
2930 .op_name
= "OP_PUTPUBFH",
2931 .op_rsize_bop
= nfsd4_only_status_rsize
,
2934 .op_func
= nfsd4_putrootfh
,
2935 .op_flags
= ALLOWED_WITHOUT_FH
| ALLOWED_ON_ABSENT_FS
2936 | OP_IS_PUTFH_LIKE
| OP_CLEAR_STATEID
,
2937 .op_name
= "OP_PUTROOTFH",
2938 .op_rsize_bop
= nfsd4_only_status_rsize
,
2941 .op_func
= nfsd4_read
,
2942 .op_release
= nfsd4_read_release
,
2943 .op_name
= "OP_READ",
2944 .op_rsize_bop
= nfsd4_read_rsize
,
2945 .op_get_currentstateid
= nfsd4_get_readstateid
,
2948 .op_func
= nfsd4_readdir
,
2949 .op_name
= "OP_READDIR",
2950 .op_rsize_bop
= nfsd4_readdir_rsize
,
2953 .op_func
= nfsd4_readlink
,
2954 .op_name
= "OP_READLINK",
2955 .op_rsize_bop
= nfsd4_readlink_rsize
,
2958 .op_func
= nfsd4_remove
,
2959 .op_flags
= OP_MODIFIES_SOMETHING
| OP_CACHEME
,
2960 .op_name
= "OP_REMOVE",
2961 .op_rsize_bop
= nfsd4_remove_rsize
,
2964 .op_func
= nfsd4_rename
,
2965 .op_flags
= OP_MODIFIES_SOMETHING
| OP_CACHEME
,
2966 .op_name
= "OP_RENAME",
2967 .op_rsize_bop
= nfsd4_rename_rsize
,
2970 .op_func
= nfsd4_renew
,
2971 .op_flags
= ALLOWED_WITHOUT_FH
| ALLOWED_ON_ABSENT_FS
2972 | OP_MODIFIES_SOMETHING
,
2973 .op_name
= "OP_RENEW",
2974 .op_rsize_bop
= nfsd4_only_status_rsize
,
2978 .op_func
= nfsd4_restorefh
,
2979 .op_flags
= ALLOWED_WITHOUT_FH
| ALLOWED_ON_ABSENT_FS
2980 | OP_IS_PUTFH_LIKE
| OP_MODIFIES_SOMETHING
,
2981 .op_name
= "OP_RESTOREFH",
2982 .op_rsize_bop
= nfsd4_only_status_rsize
,
2985 .op_func
= nfsd4_savefh
,
2986 .op_flags
= OP_HANDLES_WRONGSEC
| OP_MODIFIES_SOMETHING
,
2987 .op_name
= "OP_SAVEFH",
2988 .op_rsize_bop
= nfsd4_only_status_rsize
,
2991 .op_func
= nfsd4_secinfo
,
2992 .op_release
= nfsd4_secinfo_release
,
2993 .op_flags
= OP_HANDLES_WRONGSEC
,
2994 .op_name
= "OP_SECINFO",
2995 .op_rsize_bop
= nfsd4_secinfo_rsize
,
2998 .op_func
= nfsd4_setattr
,
2999 .op_name
= "OP_SETATTR",
3000 .op_flags
= OP_MODIFIES_SOMETHING
| OP_CACHEME
3001 | OP_NONTRIVIAL_ERROR_ENCODE
,
3002 .op_rsize_bop
= nfsd4_setattr_rsize
,
3003 .op_get_currentstateid
= nfsd4_get_setattrstateid
,
3005 [OP_SETCLIENTID
] = {
3006 .op_func
= nfsd4_setclientid
,
3007 .op_flags
= ALLOWED_WITHOUT_FH
| ALLOWED_ON_ABSENT_FS
3008 | OP_MODIFIES_SOMETHING
| OP_CACHEME
3009 | OP_NONTRIVIAL_ERROR_ENCODE
,
3010 .op_name
= "OP_SETCLIENTID",
3011 .op_rsize_bop
= nfsd4_setclientid_rsize
,
3013 [OP_SETCLIENTID_CONFIRM
] = {
3014 .op_func
= nfsd4_setclientid_confirm
,
3015 .op_flags
= ALLOWED_WITHOUT_FH
| ALLOWED_ON_ABSENT_FS
3016 | OP_MODIFIES_SOMETHING
| OP_CACHEME
,
3017 .op_name
= "OP_SETCLIENTID_CONFIRM",
3018 .op_rsize_bop
= nfsd4_only_status_rsize
,
3021 .op_func
= nfsd4_verify
,
3022 .op_name
= "OP_VERIFY",
3023 .op_rsize_bop
= nfsd4_only_status_rsize
,
3026 .op_func
= nfsd4_write
,
3027 .op_flags
= OP_MODIFIES_SOMETHING
| OP_CACHEME
,
3028 .op_name
= "OP_WRITE",
3029 .op_rsize_bop
= nfsd4_write_rsize
,
3030 .op_get_currentstateid
= nfsd4_get_writestateid
,
3032 [OP_RELEASE_LOCKOWNER
] = {
3033 .op_func
= nfsd4_release_lockowner
,
3034 .op_flags
= ALLOWED_WITHOUT_FH
| ALLOWED_ON_ABSENT_FS
3035 | OP_MODIFIES_SOMETHING
,
3036 .op_name
= "OP_RELEASE_LOCKOWNER",
3037 .op_rsize_bop
= nfsd4_only_status_rsize
,
3040 /* NFSv4.1 operations */
3041 [OP_EXCHANGE_ID
] = {
3042 .op_func
= nfsd4_exchange_id
,
3043 .op_flags
= ALLOWED_WITHOUT_FH
| ALLOWED_AS_FIRST_OP
3044 | OP_MODIFIES_SOMETHING
,
3045 .op_name
= "OP_EXCHANGE_ID",
3046 .op_rsize_bop
= nfsd4_exchange_id_rsize
,
3048 [OP_BACKCHANNEL_CTL
] = {
3049 .op_func
= nfsd4_backchannel_ctl
,
3050 .op_flags
= ALLOWED_WITHOUT_FH
| OP_MODIFIES_SOMETHING
,
3051 .op_name
= "OP_BACKCHANNEL_CTL",
3052 .op_rsize_bop
= nfsd4_only_status_rsize
,
3054 [OP_BIND_CONN_TO_SESSION
] = {
3055 .op_func
= nfsd4_bind_conn_to_session
,
3056 .op_flags
= ALLOWED_WITHOUT_FH
| ALLOWED_AS_FIRST_OP
3057 | OP_MODIFIES_SOMETHING
,
3058 .op_name
= "OP_BIND_CONN_TO_SESSION",
3059 .op_rsize_bop
= nfsd4_bind_conn_to_session_rsize
,
3061 [OP_CREATE_SESSION
] = {
3062 .op_func
= nfsd4_create_session
,
3063 .op_flags
= ALLOWED_WITHOUT_FH
| ALLOWED_AS_FIRST_OP
3064 | OP_MODIFIES_SOMETHING
,
3065 .op_name
= "OP_CREATE_SESSION",
3066 .op_rsize_bop
= nfsd4_create_session_rsize
,
3068 [OP_DESTROY_SESSION
] = {
3069 .op_func
= nfsd4_destroy_session
,
3070 .op_flags
= ALLOWED_WITHOUT_FH
| ALLOWED_AS_FIRST_OP
3071 | OP_MODIFIES_SOMETHING
,
3072 .op_name
= "OP_DESTROY_SESSION",
3073 .op_rsize_bop
= nfsd4_only_status_rsize
,
3076 .op_func
= nfsd4_sequence
,
3077 .op_flags
= ALLOWED_WITHOUT_FH
| ALLOWED_AS_FIRST_OP
,
3078 .op_name
= "OP_SEQUENCE",
3079 .op_rsize_bop
= nfsd4_sequence_rsize
,
3081 [OP_DESTROY_CLIENTID
] = {
3082 .op_func
= nfsd4_destroy_clientid
,
3083 .op_flags
= ALLOWED_WITHOUT_FH
| ALLOWED_AS_FIRST_OP
3084 | OP_MODIFIES_SOMETHING
,
3085 .op_name
= "OP_DESTROY_CLIENTID",
3086 .op_rsize_bop
= nfsd4_only_status_rsize
,
3088 [OP_RECLAIM_COMPLETE
] = {
3089 .op_func
= nfsd4_reclaim_complete
,
3090 .op_flags
= ALLOWED_WITHOUT_FH
| OP_MODIFIES_SOMETHING
,
3091 .op_name
= "OP_RECLAIM_COMPLETE",
3092 .op_rsize_bop
= nfsd4_only_status_rsize
,
3094 [OP_SECINFO_NO_NAME
] = {
3095 .op_func
= nfsd4_secinfo_no_name
,
3096 .op_release
= nfsd4_secinfo_no_name_release
,
3097 .op_flags
= OP_HANDLES_WRONGSEC
,
3098 .op_name
= "OP_SECINFO_NO_NAME",
3099 .op_rsize_bop
= nfsd4_secinfo_rsize
,
3101 [OP_TEST_STATEID
] = {
3102 .op_func
= nfsd4_test_stateid
,
3103 .op_flags
= ALLOWED_WITHOUT_FH
,
3104 .op_name
= "OP_TEST_STATEID",
3105 .op_rsize_bop
= nfsd4_test_stateid_rsize
,
3107 [OP_FREE_STATEID
] = {
3108 .op_func
= nfsd4_free_stateid
,
3109 .op_flags
= ALLOWED_WITHOUT_FH
| OP_MODIFIES_SOMETHING
,
3110 .op_name
= "OP_FREE_STATEID",
3111 .op_get_currentstateid
= nfsd4_get_freestateid
,
3112 .op_rsize_bop
= nfsd4_only_status_rsize
,
3114 #ifdef CONFIG_NFSD_PNFS
3115 [OP_GETDEVICEINFO
] = {
3116 .op_func
= nfsd4_getdeviceinfo
,
3117 .op_release
= nfsd4_getdeviceinfo_release
,
3118 .op_flags
= ALLOWED_WITHOUT_FH
,
3119 .op_name
= "OP_GETDEVICEINFO",
3120 .op_rsize_bop
= nfsd4_getdeviceinfo_rsize
,
3123 .op_func
= nfsd4_layoutget
,
3124 .op_release
= nfsd4_layoutget_release
,
3125 .op_flags
= OP_MODIFIES_SOMETHING
,
3126 .op_name
= "OP_LAYOUTGET",
3127 .op_rsize_bop
= nfsd4_layoutget_rsize
,
3129 [OP_LAYOUTCOMMIT
] = {
3130 .op_func
= nfsd4_layoutcommit
,
3131 .op_flags
= OP_MODIFIES_SOMETHING
,
3132 .op_name
= "OP_LAYOUTCOMMIT",
3133 .op_rsize_bop
= nfsd4_layoutcommit_rsize
,
3135 [OP_LAYOUTRETURN
] = {
3136 .op_func
= nfsd4_layoutreturn
,
3137 .op_flags
= OP_MODIFIES_SOMETHING
,
3138 .op_name
= "OP_LAYOUTRETURN",
3139 .op_rsize_bop
= nfsd4_layoutreturn_rsize
,
3141 #endif /* CONFIG_NFSD_PNFS */
3143 /* NFSv4.2 operations */
3145 .op_func
= nfsd4_allocate
,
3146 .op_flags
= OP_MODIFIES_SOMETHING
,
3147 .op_name
= "OP_ALLOCATE",
3148 .op_rsize_bop
= nfsd4_only_status_rsize
,
3151 .op_func
= nfsd4_deallocate
,
3152 .op_flags
= OP_MODIFIES_SOMETHING
,
3153 .op_name
= "OP_DEALLOCATE",
3154 .op_rsize_bop
= nfsd4_only_status_rsize
,
3157 .op_func
= nfsd4_clone
,
3158 .op_flags
= OP_MODIFIES_SOMETHING
,
3159 .op_name
= "OP_CLONE",
3160 .op_rsize_bop
= nfsd4_only_status_rsize
,
3163 .op_func
= nfsd4_copy
,
3164 .op_flags
= OP_MODIFIES_SOMETHING
,
3165 .op_name
= "OP_COPY",
3166 .op_rsize_bop
= nfsd4_copy_rsize
,
3169 .op_func
= nfsd4_read
,
3170 .op_release
= nfsd4_read_release
,
3171 .op_name
= "OP_READ_PLUS",
3172 .op_rsize_bop
= nfsd4_read_plus_rsize
,
3173 .op_get_currentstateid
= nfsd4_get_readstateid
,
3176 .op_func
= nfsd4_seek
,
3177 .op_name
= "OP_SEEK",
3178 .op_rsize_bop
= nfsd4_seek_rsize
,
3180 [OP_OFFLOAD_STATUS
] = {
3181 .op_func
= nfsd4_offload_status
,
3182 .op_name
= "OP_OFFLOAD_STATUS",
3183 .op_rsize_bop
= nfsd4_offload_status_rsize
,
3185 [OP_OFFLOAD_CANCEL
] = {
3186 .op_func
= nfsd4_offload_cancel
,
3187 .op_flags
= OP_MODIFIES_SOMETHING
,
3188 .op_name
= "OP_OFFLOAD_CANCEL",
3189 .op_rsize_bop
= nfsd4_only_status_rsize
,
3191 [OP_COPY_NOTIFY
] = {
3192 .op_func
= nfsd4_copy_notify
,
3193 .op_flags
= OP_MODIFIES_SOMETHING
,
3194 .op_name
= "OP_COPY_NOTIFY",
3195 .op_rsize_bop
= nfsd4_copy_notify_rsize
,
3198 .op_func
= nfsd4_getxattr
,
3199 .op_name
= "OP_GETXATTR",
3200 .op_rsize_bop
= nfsd4_getxattr_rsize
,
3203 .op_func
= nfsd4_setxattr
,
3204 .op_flags
= OP_MODIFIES_SOMETHING
| OP_CACHEME
,
3205 .op_name
= "OP_SETXATTR",
3206 .op_rsize_bop
= nfsd4_setxattr_rsize
,
3209 .op_func
= nfsd4_listxattrs
,
3210 .op_name
= "OP_LISTXATTRS",
3211 .op_rsize_bop
= nfsd4_listxattrs_rsize
,
3213 [OP_REMOVEXATTR
] = {
3214 .op_func
= nfsd4_removexattr
,
3215 .op_flags
= OP_MODIFIES_SOMETHING
| OP_CACHEME
,
3216 .op_name
= "OP_REMOVEXATTR",
3217 .op_rsize_bop
= nfsd4_removexattr_rsize
,
3222 * nfsd4_spo_must_allow - Determine if the compound op contains an
3223 * operation that is allowed to be sent with machine credentials
3225 * @rqstp: a pointer to the struct svc_rqst
3227 * Checks to see if the compound contains a spo_must_allow op
3228 * and confirms that it was sent with the proper machine creds.
3231 bool nfsd4_spo_must_allow(struct svc_rqst
*rqstp
)
3233 struct nfsd4_compoundres
*resp
= rqstp
->rq_resp
;
3234 struct nfsd4_compoundargs
*argp
= rqstp
->rq_argp
;
3235 struct nfsd4_op
*this = &argp
->ops
[resp
->opcnt
- 1];
3236 struct nfsd4_compound_state
*cstate
= &resp
->cstate
;
3237 struct nfs4_op_map
*allow
= &cstate
->clp
->cl_spo_must_allow
;
3240 if (!cstate
->minorversion
)
3243 if (cstate
->spo_must_allowed
)
3246 opiter
= resp
->opcnt
;
3247 while (opiter
< argp
->opcnt
) {
3248 this = &argp
->ops
[opiter
++];
3249 if (test_bit(this->opnum
, allow
->u
.longs
) &&
3250 cstate
->clp
->cl_mach_cred
&&
3251 nfsd4_mach_creds_match(cstate
->clp
, rqstp
)) {
3252 cstate
->spo_must_allowed
= true;
3256 cstate
->spo_must_allowed
= false;
3260 int nfsd4_max_reply(struct svc_rqst
*rqstp
, struct nfsd4_op
*op
)
3262 if (op
->opnum
== OP_ILLEGAL
|| op
->status
== nfserr_notsupp
)
3263 return op_encode_hdr_size
* sizeof(__be32
);
3265 BUG_ON(OPDESC(op
)->op_rsize_bop
== NULL
);
3266 return OPDESC(op
)->op_rsize_bop(rqstp
, op
);
3269 void warn_on_nonidempotent_op(struct nfsd4_op
*op
)
3271 if (OPDESC(op
)->op_flags
& OP_MODIFIES_SOMETHING
) {
3272 pr_err("unable to encode reply to nonidempotent op %u (%s)\n",
3273 op
->opnum
, nfsd4_op_name(op
->opnum
));
3278 static const char *nfsd4_op_name(unsigned opnum
)
3280 if (opnum
< ARRAY_SIZE(nfsd4_ops
))
3281 return nfsd4_ops
[opnum
].op_name
;
3282 return "unknown_operation";
3285 static const struct svc_procedure nfsd_procedures4
[2] = {
3287 .pc_func
= nfsd4_proc_null
,
3288 .pc_decode
= nfssvc_decode_voidarg
,
3289 .pc_encode
= nfssvc_encode_voidres
,
3290 .pc_argsize
= sizeof(struct nfsd_voidargs
),
3291 .pc_ressize
= sizeof(struct nfsd_voidres
),
3292 .pc_cachetype
= RC_NOCACHE
,
3296 [NFSPROC4_COMPOUND
] = {
3297 .pc_func
= nfsd4_proc_compound
,
3298 .pc_decode
= nfs4svc_decode_compoundargs
,
3299 .pc_encode
= nfs4svc_encode_compoundres
,
3300 .pc_argsize
= sizeof(struct nfsd4_compoundargs
),
3301 .pc_ressize
= sizeof(struct nfsd4_compoundres
),
3302 .pc_release
= nfsd4_release_compoundargs
,
3303 .pc_cachetype
= RC_NOCACHE
,
3304 .pc_xdrressize
= NFSD_BUFSIZE
/4,
3305 .pc_name
= "COMPOUND",
3309 static unsigned int nfsd_count3
[ARRAY_SIZE(nfsd_procedures4
)];
3310 const struct svc_version nfsd_version4
= {
3313 .vs_proc
= nfsd_procedures4
,
3314 .vs_count
= nfsd_count3
,
3315 .vs_dispatch
= nfsd_dispatch
,
3316 .vs_xdrsize
= NFS4_SVC_XDRSIZE
,
3317 .vs_rpcb_optnl
= true,
3318 .vs_need_cong_ctrl
= true,