4 * Server-side procedures for NFSv4.
6 * Copyright (c) 2002 The Regents of the University of Michigan.
9 * Kendrick Smith <kmsmith@umich.edu>
10 * Andy Adamson <andros@umich.edu>
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
16 * 1. Redistributions of source code must retain the above copyright
17 * notice, this list of conditions and the following disclaimer.
18 * 2. Redistributions in binary form must reproduce the above copyright
19 * notice, this list of conditions and the following disclaimer in the
20 * documentation and/or other materials provided with the distribution.
21 * 3. Neither the name of the University nor the names of its
22 * contributors may be used to endorse or promote products derived
23 * from this software without specific prior written permission.
25 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
26 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
27 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
28 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
32 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38 #include <linux/param.h>
39 #include <linux/major.h>
40 #include <linux/slab.h>
41 #include <linux/file.h>
43 #include <linux/sunrpc/svc.h>
44 #include <linux/nfsd/nfsd.h>
45 #include <linux/nfsd/cache.h>
46 #include <linux/nfs4.h>
47 #include <linux/nfsd/state.h>
48 #include <linux/nfsd/xdr4.h>
49 #include <linux/nfs4_acl.h>
50 #include <linux/sunrpc/gss_api.h>
53 #define NFSDDBG_FACILITY NFSDDBG_PROC
55 static u32 nfsd_attrmask
[] = {
56 NFSD_WRITEABLE_ATTRS_WORD0
,
57 NFSD_WRITEABLE_ATTRS_WORD1
,
58 NFSD_WRITEABLE_ATTRS_WORD2
61 static u32 nfsd41_ex_attrmask
[] = {
62 NFSD_SUPPATTR_EXCLCREAT_WORD0
,
63 NFSD_SUPPATTR_EXCLCREAT_WORD1
,
64 NFSD_SUPPATTR_EXCLCREAT_WORD2
68 check_attr_support(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
69 u32
*bmval
, u32
*writable
)
71 struct dentry
*dentry
= cstate
->current_fh
.fh_dentry
;
74 * Check about attributes are supported by the NFSv4 server or not.
75 * According to spec, unsupported attributes return ERR_ATTRNOTSUPP.
77 if ((bmval
[0] & ~nfsd_suppattrs0(cstate
->minorversion
)) ||
78 (bmval
[1] & ~nfsd_suppattrs1(cstate
->minorversion
)) ||
79 (bmval
[2] & ~nfsd_suppattrs2(cstate
->minorversion
)))
80 return nfserr_attrnotsupp
;
83 * Check FATTR4_WORD0_ACL can be supported
84 * in current environment or not.
86 if (bmval
[0] & FATTR4_WORD0_ACL
) {
87 if (!IS_POSIXACL(dentry
->d_inode
))
88 return nfserr_attrnotsupp
;
92 * According to spec, read-only attributes return ERR_INVAL.
95 if ((bmval
[0] & ~writable
[0]) || (bmval
[1] & ~writable
[1]) ||
96 (bmval
[2] & ~writable
[2]))
104 nfsd4_check_open_attributes(struct svc_rqst
*rqstp
,
105 struct nfsd4_compound_state
*cstate
, struct nfsd4_open
*open
)
107 __be32 status
= nfs_ok
;
109 if (open
->op_create
== NFS4_OPEN_CREATE
) {
110 if (open
->op_createmode
== NFS4_CREATE_UNCHECKED
111 || open
->op_createmode
== NFS4_CREATE_GUARDED
)
112 status
= check_attr_support(rqstp
, cstate
,
113 open
->op_bmval
, nfsd_attrmask
);
114 else if (open
->op_createmode
== NFS4_CREATE_EXCLUSIVE4_1
)
115 status
= check_attr_support(rqstp
, cstate
,
116 open
->op_bmval
, nfsd41_ex_attrmask
);
123 is_create_with_attrs(struct nfsd4_open
*open
)
125 return open
->op_create
== NFS4_OPEN_CREATE
126 && (open
->op_createmode
== NFS4_CREATE_UNCHECKED
127 || open
->op_createmode
== NFS4_CREATE_GUARDED
128 || open
->op_createmode
== NFS4_CREATE_EXCLUSIVE4_1
);
132 * if error occurs when setting the acl, just clear the acl bit
133 * in the returned attr bitmap.
136 do_set_nfs4_acl(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
,
137 struct nfs4_acl
*acl
, u32
*bmval
)
141 status
= nfsd4_set_nfs4_acl(rqstp
, fhp
, acl
);
144 * We should probably fail the whole open at this point,
145 * but we've already created the file, so it's too late;
146 * So this seems the least of evils:
148 bmval
[0] &= ~FATTR4_WORD0_ACL
;
152 fh_dup2(struct svc_fh
*dst
, struct svc_fh
*src
)
155 dget(src
->fh_dentry
);
157 cache_get(&src
->fh_export
->h
);
162 do_open_permission(struct svc_rqst
*rqstp
, struct svc_fh
*current_fh
, struct nfsd4_open
*open
, int accmode
)
166 if (open
->op_truncate
&&
167 !(open
->op_share_access
& NFS4_SHARE_ACCESS_WRITE
))
170 if (open
->op_share_access
& NFS4_SHARE_ACCESS_READ
)
171 accmode
|= NFSD_MAY_READ
;
172 if (open
->op_share_access
& NFS4_SHARE_ACCESS_WRITE
)
173 accmode
|= (NFSD_MAY_WRITE
| NFSD_MAY_TRUNC
);
174 if (open
->op_share_deny
& NFS4_SHARE_DENY_WRITE
)
175 accmode
|= NFSD_MAY_WRITE
;
177 status
= fh_verify(rqstp
, current_fh
, S_IFREG
, accmode
);
183 do_open_lookup(struct svc_rqst
*rqstp
, struct svc_fh
*current_fh
, struct nfsd4_open
*open
)
189 fh_init(&resfh
, NFS4_FHSIZE
);
190 open
->op_truncate
= 0;
192 if (open
->op_create
) {
193 /* FIXME: check session persistence and pnfs flags.
194 * The nfsv4.1 spec requires the following semantics:
196 * Persistent | pNFS | Server REQUIRED | Client Allowed
197 * Reply Cache | server | |
198 * -------------+--------+-----------------+--------------------
199 * no | no | EXCLUSIVE4_1 | EXCLUSIVE4_1
201 * | | and EXCLUSIVE4 | or EXCLUSIVE4
203 * no | yes | EXCLUSIVE4_1 | EXCLUSIVE4_1
204 * yes | no | GUARDED4 | GUARDED4
205 * yes | yes | GUARDED4 | GUARDED4
209 * Note: create modes (UNCHECKED,GUARDED...) are the same
212 status
= nfsd_create_v3(rqstp
, current_fh
, open
->op_fname
.data
,
213 open
->op_fname
.len
, &open
->op_iattr
,
214 &resfh
, open
->op_createmode
,
215 (u32
*)open
->op_verf
.data
,
216 &open
->op_truncate
, &created
);
219 * Following rfc 3530 14.2.16, use the returned bitmask
220 * to indicate which attributes we used to store the
223 if (open
->op_createmode
== NFS4_CREATE_EXCLUSIVE
&& status
== 0)
224 open
->op_bmval
[1] = (FATTR4_WORD1_TIME_ACCESS
|
225 FATTR4_WORD1_TIME_MODIFY
);
227 status
= nfsd_lookup(rqstp
, current_fh
,
228 open
->op_fname
.data
, open
->op_fname
.len
, &resfh
);
229 fh_unlock(current_fh
);
234 if (is_create_with_attrs(open
) && open
->op_acl
!= NULL
)
235 do_set_nfs4_acl(rqstp
, &resfh
, open
->op_acl
, open
->op_bmval
);
237 set_change_info(&open
->op_cinfo
, current_fh
);
238 fh_dup2(current_fh
, &resfh
);
240 /* set reply cache */
241 fh_copy_shallow(&open
->op_stateowner
->so_replay
.rp_openfh
,
244 status
= do_open_permission(rqstp
, current_fh
, open
,
253 do_open_fhandle(struct svc_rqst
*rqstp
, struct svc_fh
*current_fh
, struct nfsd4_open
*open
)
257 /* Only reclaims from previously confirmed clients are valid */
258 if ((status
= nfs4_check_open_reclaim(&open
->op_clientid
)))
261 /* We don't know the target directory, and therefore can not
262 * set the change info
265 memset(&open
->op_cinfo
, 0, sizeof(struct nfsd4_change_info
));
267 /* set replay cache */
268 fh_copy_shallow(&open
->op_stateowner
->so_replay
.rp_openfh
,
269 ¤t_fh
->fh_handle
);
271 open
->op_truncate
= (open
->op_iattr
.ia_valid
& ATTR_SIZE
) &&
272 (open
->op_iattr
.ia_size
== 0);
274 status
= do_open_permission(rqstp
, current_fh
, open
,
275 NFSD_MAY_OWNER_OVERRIDE
);
281 copy_clientid(clientid_t
*clid
, struct nfsd4_session
*session
)
283 struct nfsd4_sessionid
*sid
=
284 (struct nfsd4_sessionid
*)session
->se_sessionid
.data
;
286 clid
->cl_boot
= sid
->clientid
.cl_boot
;
287 clid
->cl_id
= sid
->clientid
.cl_id
;
291 nfsd4_open(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
292 struct nfsd4_open
*open
)
295 struct nfsd4_compoundres
*resp
;
297 dprintk("NFSD: nfsd4_open filename %.*s op_stateowner %p\n",
298 (int)open
->op_fname
.len
, open
->op_fname
.data
,
299 open
->op_stateowner
);
301 /* This check required by spec. */
302 if (open
->op_create
&& open
->op_claim_type
!= NFS4_OPEN_CLAIM_NULL
)
305 if (nfsd4_has_session(cstate
))
306 copy_clientid(&open
->op_clientid
, cstate
->session
);
310 /* check seqid for replay. set nfs4_owner */
311 resp
= rqstp
->rq_resp
;
312 status
= nfsd4_process_open1(&resp
->cstate
, open
);
313 if (status
== nfserr_replay_me
) {
314 struct nfs4_replay
*rp
= &open
->op_stateowner
->so_replay
;
315 fh_put(&cstate
->current_fh
);
316 fh_copy_shallow(&cstate
->current_fh
.fh_handle
,
318 status
= fh_verify(rqstp
, &cstate
->current_fh
, 0, NFSD_MAY_NOP
);
320 dprintk("nfsd4_open: replay failed"
321 " restoring previous filehandle\n");
323 status
= nfserr_replay_me
;
328 status
= nfsd4_check_open_attributes(rqstp
, cstate
, open
);
332 /* Openowner is now set, so sequence id will get bumped. Now we need
333 * these checks before we do any creates: */
334 status
= nfserr_grace
;
335 if (locks_in_grace() && open
->op_claim_type
!= NFS4_OPEN_CLAIM_PREVIOUS
)
337 status
= nfserr_no_grace
;
338 if (!locks_in_grace() && open
->op_claim_type
== NFS4_OPEN_CLAIM_PREVIOUS
)
341 switch (open
->op_claim_type
) {
342 case NFS4_OPEN_CLAIM_DELEGATE_CUR
:
343 case NFS4_OPEN_CLAIM_NULL
:
345 * (1) set CURRENT_FH to the file being opened,
346 * creating it if necessary, (2) set open->op_cinfo,
347 * (3) set open->op_truncate if the file is to be
348 * truncated after opening, (4) do permission checking.
350 status
= do_open_lookup(rqstp
, &cstate
->current_fh
,
355 case NFS4_OPEN_CLAIM_PREVIOUS
:
356 open
->op_stateowner
->so_confirmed
= 1;
358 * The CURRENT_FH is already set to the file being
359 * opened. (1) set open->op_cinfo, (2) set
360 * open->op_truncate if the file is to be truncated
361 * after opening, (3) do permission checking.
363 status
= do_open_fhandle(rqstp
, &cstate
->current_fh
,
368 case NFS4_OPEN_CLAIM_DELEGATE_PREV
:
369 open
->op_stateowner
->so_confirmed
= 1;
370 dprintk("NFSD: unsupported OPEN claim type %d\n",
371 open
->op_claim_type
);
372 status
= nfserr_notsupp
;
375 dprintk("NFSD: Invalid OPEN claim type %d\n",
376 open
->op_claim_type
);
377 status
= nfserr_inval
;
381 * nfsd4_process_open2() does the actual opening of the file. If
382 * successful, it (1) truncates the file if open->op_truncate was
383 * set, (2) sets open->op_stateid, (3) sets open->op_delegation.
385 status
= nfsd4_process_open2(rqstp
, &cstate
->current_fh
, open
);
387 if (open
->op_stateowner
) {
388 nfs4_get_stateowner(open
->op_stateowner
);
389 cstate
->replay_owner
= open
->op_stateowner
;
396 * filehandle-manipulating ops.
399 nfsd4_getfh(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
400 struct svc_fh
**getfh
)
402 if (!cstate
->current_fh
.fh_dentry
)
403 return nfserr_nofilehandle
;
405 *getfh
= &cstate
->current_fh
;
410 nfsd4_putfh(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
411 struct nfsd4_putfh
*putfh
)
413 fh_put(&cstate
->current_fh
);
414 cstate
->current_fh
.fh_handle
.fh_size
= putfh
->pf_fhlen
;
415 memcpy(&cstate
->current_fh
.fh_handle
.fh_base
, putfh
->pf_fhval
,
417 return fh_verify(rqstp
, &cstate
->current_fh
, 0, NFSD_MAY_NOP
);
421 nfsd4_putrootfh(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
426 fh_put(&cstate
->current_fh
);
427 status
= exp_pseudoroot(rqstp
, &cstate
->current_fh
);
432 nfsd4_restorefh(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
435 if (!cstate
->save_fh
.fh_dentry
)
436 return nfserr_restorefh
;
438 fh_dup2(&cstate
->current_fh
, &cstate
->save_fh
);
443 nfsd4_savefh(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
446 if (!cstate
->current_fh
.fh_dentry
)
447 return nfserr_nofilehandle
;
449 fh_dup2(&cstate
->save_fh
, &cstate
->current_fh
);
457 nfsd4_access(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
458 struct nfsd4_access
*access
)
460 if (access
->ac_req_access
& ~NFS3_ACCESS_FULL
)
463 access
->ac_resp_access
= access
->ac_req_access
;
464 return nfsd_access(rqstp
, &cstate
->current_fh
, &access
->ac_resp_access
,
465 &access
->ac_supported
);
469 nfsd4_commit(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
470 struct nfsd4_commit
*commit
)
474 u32
*p
= (u32
*)commit
->co_verf
.data
;
475 *p
++ = nfssvc_boot
.tv_sec
;
476 *p
++ = nfssvc_boot
.tv_usec
;
478 status
= nfsd_commit(rqstp
, &cstate
->current_fh
, commit
->co_offset
,
480 if (status
== nfserr_symlink
)
481 status
= nfserr_inval
;
486 nfsd4_create(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
487 struct nfsd4_create
*create
)
493 fh_init(&resfh
, NFS4_FHSIZE
);
495 status
= fh_verify(rqstp
, &cstate
->current_fh
, S_IFDIR
,
497 if (status
== nfserr_symlink
)
498 status
= nfserr_notdir
;
502 status
= check_attr_support(rqstp
, cstate
, create
->cr_bmval
,
507 switch (create
->cr_type
) {
509 /* ugh! we have to null-terminate the linktext, or
510 * vfs_symlink() will choke. it is always safe to
511 * null-terminate by brute force, since at worst we
512 * will overwrite the first byte of the create namelen
513 * in the XDR buffer, which has already been extracted
516 create
->cr_linkname
[create
->cr_linklen
] = 0;
518 status
= nfsd_symlink(rqstp
, &cstate
->current_fh
,
519 create
->cr_name
, create
->cr_namelen
,
520 create
->cr_linkname
, create
->cr_linklen
,
521 &resfh
, &create
->cr_iattr
);
525 rdev
= MKDEV(create
->cr_specdata1
, create
->cr_specdata2
);
526 if (MAJOR(rdev
) != create
->cr_specdata1
||
527 MINOR(rdev
) != create
->cr_specdata2
)
529 status
= nfsd_create(rqstp
, &cstate
->current_fh
,
530 create
->cr_name
, create
->cr_namelen
,
531 &create
->cr_iattr
, S_IFBLK
, rdev
, &resfh
);
535 rdev
= MKDEV(create
->cr_specdata1
, create
->cr_specdata2
);
536 if (MAJOR(rdev
) != create
->cr_specdata1
||
537 MINOR(rdev
) != create
->cr_specdata2
)
539 status
= nfsd_create(rqstp
, &cstate
->current_fh
,
540 create
->cr_name
, create
->cr_namelen
,
541 &create
->cr_iattr
,S_IFCHR
, rdev
, &resfh
);
545 status
= nfsd_create(rqstp
, &cstate
->current_fh
,
546 create
->cr_name
, create
->cr_namelen
,
547 &create
->cr_iattr
, S_IFSOCK
, 0, &resfh
);
551 status
= nfsd_create(rqstp
, &cstate
->current_fh
,
552 create
->cr_name
, create
->cr_namelen
,
553 &create
->cr_iattr
, S_IFIFO
, 0, &resfh
);
557 create
->cr_iattr
.ia_valid
&= ~ATTR_SIZE
;
558 status
= nfsd_create(rqstp
, &cstate
->current_fh
,
559 create
->cr_name
, create
->cr_namelen
,
560 &create
->cr_iattr
, S_IFDIR
, 0, &resfh
);
564 status
= nfserr_badtype
;
570 if (create
->cr_acl
!= NULL
)
571 do_set_nfs4_acl(rqstp
, &resfh
, create
->cr_acl
,
574 fh_unlock(&cstate
->current_fh
);
575 set_change_info(&create
->cr_cinfo
, &cstate
->current_fh
);
576 fh_dup2(&cstate
->current_fh
, &resfh
);
583 nfsd4_getattr(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
584 struct nfsd4_getattr
*getattr
)
588 status
= fh_verify(rqstp
, &cstate
->current_fh
, 0, NFSD_MAY_NOP
);
592 if (getattr
->ga_bmval
[1] & NFSD_WRITEONLY_ATTRS_WORD1
)
595 getattr
->ga_bmval
[0] &= nfsd_suppattrs0(cstate
->minorversion
);
596 getattr
->ga_bmval
[1] &= nfsd_suppattrs1(cstate
->minorversion
);
597 getattr
->ga_bmval
[2] &= nfsd_suppattrs2(cstate
->minorversion
);
599 getattr
->ga_fhp
= &cstate
->current_fh
;
604 nfsd4_link(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
605 struct nfsd4_link
*link
)
607 __be32 status
= nfserr_nofilehandle
;
609 if (!cstate
->save_fh
.fh_dentry
)
611 status
= nfsd_link(rqstp
, &cstate
->current_fh
,
612 link
->li_name
, link
->li_namelen
, &cstate
->save_fh
);
614 set_change_info(&link
->li_cinfo
, &cstate
->current_fh
);
619 nfsd4_lookupp(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
622 struct svc_fh tmp_fh
;
625 fh_init(&tmp_fh
, NFS4_FHSIZE
);
626 ret
= exp_pseudoroot(rqstp
, &tmp_fh
);
629 if (tmp_fh
.fh_dentry
== cstate
->current_fh
.fh_dentry
) {
634 return nfsd_lookup(rqstp
, &cstate
->current_fh
,
635 "..", 2, &cstate
->current_fh
);
639 nfsd4_lookup(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
640 struct nfsd4_lookup
*lookup
)
642 return nfsd_lookup(rqstp
, &cstate
->current_fh
,
643 lookup
->lo_name
, lookup
->lo_len
,
644 &cstate
->current_fh
);
648 nfsd4_read(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
649 struct nfsd4_read
*read
)
653 /* no need to check permission - this will be done in nfsd_read() */
655 read
->rd_filp
= NULL
;
656 if (read
->rd_offset
>= OFFSET_MAX
)
661 if ((status
= nfs4_preprocess_stateid_op(cstate
, &read
->rd_stateid
,
662 RD_STATE
, &read
->rd_filp
))) {
663 dprintk("NFSD: nfsd4_read: couldn't process stateid!\n");
667 get_file(read
->rd_filp
);
671 read
->rd_rqstp
= rqstp
;
672 read
->rd_fhp
= &cstate
->current_fh
;
677 nfsd4_readdir(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
678 struct nfsd4_readdir
*readdir
)
680 u64 cookie
= readdir
->rd_cookie
;
681 static const nfs4_verifier zeroverf
;
683 /* no need to check permission - this will be done in nfsd_readdir() */
685 if (readdir
->rd_bmval
[1] & NFSD_WRITEONLY_ATTRS_WORD1
)
688 readdir
->rd_bmval
[0] &= nfsd_suppattrs0(cstate
->minorversion
);
689 readdir
->rd_bmval
[1] &= nfsd_suppattrs1(cstate
->minorversion
);
690 readdir
->rd_bmval
[2] &= nfsd_suppattrs2(cstate
->minorversion
);
692 if ((cookie
> ~(u32
)0) || (cookie
== 1) || (cookie
== 2) ||
693 (cookie
== 0 && memcmp(readdir
->rd_verf
.data
, zeroverf
.data
, NFS4_VERIFIER_SIZE
)))
694 return nfserr_bad_cookie
;
696 readdir
->rd_rqstp
= rqstp
;
697 readdir
->rd_fhp
= &cstate
->current_fh
;
702 nfsd4_readlink(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
703 struct nfsd4_readlink
*readlink
)
705 readlink
->rl_rqstp
= rqstp
;
706 readlink
->rl_fhp
= &cstate
->current_fh
;
711 nfsd4_remove(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
712 struct nfsd4_remove
*remove
)
716 if (locks_in_grace())
718 status
= nfsd_unlink(rqstp
, &cstate
->current_fh
, 0,
719 remove
->rm_name
, remove
->rm_namelen
);
720 if (status
== nfserr_symlink
)
721 return nfserr_notdir
;
723 fh_unlock(&cstate
->current_fh
);
724 set_change_info(&remove
->rm_cinfo
, &cstate
->current_fh
);
730 nfsd4_rename(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
731 struct nfsd4_rename
*rename
)
733 __be32 status
= nfserr_nofilehandle
;
735 if (!cstate
->save_fh
.fh_dentry
)
737 if (locks_in_grace() && !(cstate
->save_fh
.fh_export
->ex_flags
738 & NFSEXP_NOSUBTREECHECK
))
740 status
= nfsd_rename(rqstp
, &cstate
->save_fh
, rename
->rn_sname
,
741 rename
->rn_snamelen
, &cstate
->current_fh
,
742 rename
->rn_tname
, rename
->rn_tnamelen
);
744 /* the underlying filesystem returns different error's than required
745 * by NFSv4. both save_fh and current_fh have been verified.. */
746 if (status
== nfserr_isdir
)
747 status
= nfserr_exist
;
748 else if ((status
== nfserr_notdir
) &&
749 (S_ISDIR(cstate
->save_fh
.fh_dentry
->d_inode
->i_mode
) &&
750 S_ISDIR(cstate
->current_fh
.fh_dentry
->d_inode
->i_mode
)))
751 status
= nfserr_exist
;
752 else if (status
== nfserr_symlink
)
753 status
= nfserr_notdir
;
756 set_change_info(&rename
->rn_sinfo
, &cstate
->current_fh
);
757 set_change_info(&rename
->rn_tinfo
, &cstate
->save_fh
);
763 nfsd4_secinfo(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
764 struct nfsd4_secinfo
*secinfo
)
767 struct svc_export
*exp
;
768 struct dentry
*dentry
;
771 fh_init(&resfh
, NFS4_FHSIZE
);
772 err
= nfsd_lookup_dentry(rqstp
, &cstate
->current_fh
,
773 secinfo
->si_name
, secinfo
->si_namelen
,
777 if (dentry
->d_inode
== NULL
) {
781 secinfo
->si_exp
= exp
;
787 nfsd4_setattr(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
788 struct nfsd4_setattr
*setattr
)
790 __be32 status
= nfs_ok
;
792 if (setattr
->sa_iattr
.ia_valid
& ATTR_SIZE
) {
794 status
= nfs4_preprocess_stateid_op(cstate
,
795 &setattr
->sa_stateid
, WR_STATE
, NULL
);
798 dprintk("NFSD: nfsd4_setattr: couldn't process stateid!\n");
802 status
= mnt_want_write(cstate
->current_fh
.fh_export
->ex_path
.mnt
);
807 status
= check_attr_support(rqstp
, cstate
, setattr
->sa_bmval
,
812 if (setattr
->sa_acl
!= NULL
)
813 status
= nfsd4_set_nfs4_acl(rqstp
, &cstate
->current_fh
,
817 status
= nfsd_setattr(rqstp
, &cstate
->current_fh
, &setattr
->sa_iattr
,
820 mnt_drop_write(cstate
->current_fh
.fh_export
->ex_path
.mnt
);
825 nfsd4_write(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
826 struct nfsd4_write
*write
)
828 stateid_t
*stateid
= &write
->wr_stateid
;
829 struct file
*filp
= NULL
;
831 __be32 status
= nfs_ok
;
834 /* no need to check permission - this will be done in nfsd_write() */
836 if (write
->wr_offset
>= OFFSET_MAX
)
840 status
= nfs4_preprocess_stateid_op(cstate
, stateid
, WR_STATE
, &filp
);
846 dprintk("NFSD: nfsd4_write: couldn't process stateid!\n");
850 cnt
= write
->wr_buflen
;
851 write
->wr_how_written
= write
->wr_stable_how
;
852 p
= (u32
*)write
->wr_verifier
.data
;
853 *p
++ = nfssvc_boot
.tv_sec
;
854 *p
++ = nfssvc_boot
.tv_usec
;
856 status
= nfsd_write(rqstp
, &cstate
->current_fh
, filp
,
857 write
->wr_offset
, rqstp
->rq_vec
, write
->wr_vlen
,
858 &cnt
, &write
->wr_how_written
);
862 write
->wr_bytes_written
= cnt
;
864 if (status
== nfserr_symlink
)
865 status
= nfserr_inval
;
869 /* This routine never returns NFS_OK! If there are no other errors, it
870 * will return NFSERR_SAME or NFSERR_NOT_SAME depending on whether the
871 * attributes matched. VERIFY is implemented by mapping NFSERR_SAME
872 * to NFS_OK after the call; NVERIFY by mapping NFSERR_NOT_SAME to NFS_OK.
875 _nfsd4_verify(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
876 struct nfsd4_verify
*verify
)
882 status
= fh_verify(rqstp
, &cstate
->current_fh
, 0, NFSD_MAY_NOP
);
886 status
= check_attr_support(rqstp
, cstate
, verify
->ve_bmval
, NULL
);
890 if ((verify
->ve_bmval
[0] & FATTR4_WORD0_RDATTR_ERROR
)
891 || (verify
->ve_bmval
[1] & NFSD_WRITEONLY_ATTRS_WORD1
))
893 if (verify
->ve_attrlen
& 3)
897 * bitmap_len(1) + bitmap(2) + attr_len(1) = 4
899 count
= 4 + (verify
->ve_attrlen
>> 2);
900 buf
= kmalloc(count
<< 2, GFP_KERNEL
);
902 return nfserr_resource
;
904 status
= nfsd4_encode_fattr(&cstate
->current_fh
,
905 cstate
->current_fh
.fh_export
,
906 cstate
->current_fh
.fh_dentry
, buf
,
907 &count
, verify
->ve_bmval
,
910 /* this means that nfsd4_encode_fattr() ran out of space */
911 if (status
== nfserr_resource
&& count
== 0)
912 status
= nfserr_not_same
;
917 p
= buf
+ 1 + ntohl(buf
[0]);
918 status
= nfserr_not_same
;
919 if (ntohl(*p
++) != verify
->ve_attrlen
)
921 if (!memcmp(p
, verify
->ve_attrval
, verify
->ve_attrlen
))
922 status
= nfserr_same
;
930 nfsd4_nverify(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
931 struct nfsd4_verify
*verify
)
935 status
= _nfsd4_verify(rqstp
, cstate
, verify
);
936 return status
== nfserr_not_same
? nfs_ok
: status
;
940 nfsd4_verify(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
941 struct nfsd4_verify
*verify
)
945 status
= _nfsd4_verify(rqstp
, cstate
, verify
);
946 return status
== nfserr_same
? nfs_ok
: status
;
953 nfsd4_proc_null(struct svc_rqst
*rqstp
, void *argp
, void *resp
)
958 static inline void nfsd4_increment_op_stats(u32 opnum
)
960 if (opnum
>= FIRST_NFS4_OP
&& opnum
<= LAST_NFS4_OP
)
961 nfsdstats
.nfs4_opcount
[opnum
]++;
964 typedef __be32(*nfsd4op_func
)(struct svc_rqst
*, struct nfsd4_compound_state
*,
966 enum nfsd4_op_flags
{
967 ALLOWED_WITHOUT_FH
= 1 << 0, /* No current filehandle required */
968 ALLOWED_ON_ABSENT_FS
= 2 << 0, /* ops processed on absent fs */
969 ALLOWED_AS_FIRST_OP
= 3 << 0, /* ops reqired first in compound */
972 struct nfsd4_operation
{
973 nfsd4op_func op_func
;
978 static struct nfsd4_operation nfsd4_ops
[];
980 static const char *nfsd4_op_name(unsigned opnum
);
983 * Enforce NFSv4.1 COMPOUND ordering rules.
986 * - enforce NFS4ERR_NOT_ONLY_OP,
987 * - DESTROY_SESSION MUST be the final operation in the COMPOUND request.
989 static bool nfs41_op_ordering_ok(struct nfsd4_compoundargs
*args
)
991 if (args
->minorversion
&& args
->opcnt
> 0) {
992 struct nfsd4_op
*op
= &args
->ops
[0];
993 return (op
->status
== nfserr_op_illegal
) ||
994 (nfsd4_ops
[op
->opnum
].op_flags
& ALLOWED_AS_FIRST_OP
);
1003 nfsd4_proc_compound(struct svc_rqst
*rqstp
,
1004 struct nfsd4_compoundargs
*args
,
1005 struct nfsd4_compoundres
*resp
)
1007 struct nfsd4_op
*op
;
1008 struct nfsd4_operation
*opdesc
;
1009 struct nfsd4_compound_state
*cstate
= &resp
->cstate
;
1013 resp
->xbuf
= &rqstp
->rq_res
;
1014 resp
->p
= rqstp
->rq_res
.head
[0].iov_base
+
1015 rqstp
->rq_res
.head
[0].iov_len
;
1016 resp
->tagp
= resp
->p
;
1017 /* reserve space for: taglen, tag, and opcnt */
1018 resp
->p
+= 2 + XDR_QUADLEN(args
->taglen
);
1019 resp
->end
= rqstp
->rq_res
.head
[0].iov_base
+ PAGE_SIZE
;
1020 resp
->taglen
= args
->taglen
;
1021 resp
->tag
= args
->tag
;
1023 resp
->rqstp
= rqstp
;
1024 resp
->cstate
.minorversion
= args
->minorversion
;
1025 resp
->cstate
.replay_owner
= NULL
;
1026 fh_init(&resp
->cstate
.current_fh
, NFS4_FHSIZE
);
1027 fh_init(&resp
->cstate
.save_fh
, NFS4_FHSIZE
);
1028 /* Use the deferral mechanism only for NFSv4.0 compounds */
1029 rqstp
->rq_usedeferral
= (args
->minorversion
== 0);
1032 * According to RFC3010, this takes precedence over all other errors.
1034 status
= nfserr_minor_vers_mismatch
;
1035 if (args
->minorversion
> nfsd_supported_minorversion
)
1038 if (!nfs41_op_ordering_ok(args
)) {
1040 op
->status
= nfserr_sequence_pos
;
1045 while (!status
&& resp
->opcnt
< args
->opcnt
) {
1046 op
= &args
->ops
[resp
->opcnt
++];
1048 dprintk("nfsv4 compound op #%d/%d: %d (%s)\n",
1049 resp
->opcnt
, args
->opcnt
, op
->opnum
,
1050 nfsd4_op_name(op
->opnum
));
1052 * The XDR decode routines may have pre-set op->status;
1053 * for example, if there is a miscellaneous XDR error
1054 * it will be set to nfserr_bad_xdr.
1059 /* We must be able to encode a successful response to
1060 * this operation, with enough room left over to encode a
1061 * failed response to the next operation. If we don't
1062 * have enough room, fail with ERR_RESOURCE.
1064 slack_bytes
= (char *)resp
->end
- (char *)resp
->p
;
1065 if (slack_bytes
< COMPOUND_SLACK_SPACE
1066 + COMPOUND_ERR_SLACK_SPACE
) {
1067 BUG_ON(slack_bytes
< COMPOUND_ERR_SLACK_SPACE
);
1068 op
->status
= nfserr_resource
;
1072 opdesc
= &nfsd4_ops
[op
->opnum
];
1074 if (!cstate
->current_fh
.fh_dentry
) {
1075 if (!(opdesc
->op_flags
& ALLOWED_WITHOUT_FH
)) {
1076 op
->status
= nfserr_nofilehandle
;
1079 } else if (cstate
->current_fh
.fh_export
->ex_fslocs
.migrated
&&
1080 !(opdesc
->op_flags
& ALLOWED_ON_ABSENT_FS
)) {
1081 op
->status
= nfserr_moved
;
1085 if (opdesc
->op_func
)
1086 op
->status
= opdesc
->op_func(rqstp
, cstate
, &op
->u
);
1088 BUG_ON(op
->status
== nfs_ok
);
1091 /* Only from SEQUENCE */
1092 if (resp
->cstate
.status
== nfserr_replay_cache
) {
1093 dprintk("%s NFS4.1 replay from cache\n", __func__
);
1094 status
= op
->status
;
1097 if (op
->status
== nfserr_replay_me
) {
1098 op
->replay
= &cstate
->replay_owner
->so_replay
;
1099 nfsd4_encode_replay(resp
, op
);
1100 status
= op
->status
= op
->replay
->rp_status
;
1102 nfsd4_encode_operation(resp
, op
);
1103 status
= op
->status
;
1106 dprintk("nfsv4 compound op %p opcnt %d #%d: %d: status %d\n",
1107 args
->ops
, args
->opcnt
, resp
->opcnt
, op
->opnum
,
1108 be32_to_cpu(status
));
1110 if (cstate
->replay_owner
) {
1111 nfs4_put_stateowner(cstate
->replay_owner
);
1112 cstate
->replay_owner
= NULL
;
1114 /* XXX Ugh, we need to get rid of this kind of special case: */
1115 if (op
->opnum
== OP_READ
&& op
->u
.read
.rd_filp
)
1116 fput(op
->u
.read
.rd_filp
);
1118 nfsd4_increment_op_stats(op
->opnum
);
1120 if (!rqstp
->rq_usedeferral
&& status
== nfserr_dropit
) {
1121 dprintk("%s Dropit - send NFS4ERR_DELAY\n", __func__
);
1122 status
= nfserr_jukebox
;
1125 resp
->cstate
.status
= status
;
1126 fh_put(&resp
->cstate
.current_fh
);
1127 fh_put(&resp
->cstate
.save_fh
);
1128 BUG_ON(resp
->cstate
.replay_owner
);
1130 nfsd4_release_compoundargs(args
);
1131 /* Reset deferral mechanism for RPC deferrals */
1132 rqstp
->rq_usedeferral
= 1;
1133 dprintk("nfsv4 compound returned %d\n", ntohl(status
));
1137 static struct nfsd4_operation nfsd4_ops
[] = {
1139 .op_func
= (nfsd4op_func
)nfsd4_access
,
1140 .op_name
= "OP_ACCESS",
1143 .op_func
= (nfsd4op_func
)nfsd4_close
,
1144 .op_name
= "OP_CLOSE",
1147 .op_func
= (nfsd4op_func
)nfsd4_commit
,
1148 .op_name
= "OP_COMMIT",
1151 .op_func
= (nfsd4op_func
)nfsd4_create
,
1152 .op_name
= "OP_CREATE",
1154 [OP_DELEGRETURN
] = {
1155 .op_func
= (nfsd4op_func
)nfsd4_delegreturn
,
1156 .op_name
= "OP_DELEGRETURN",
1159 .op_func
= (nfsd4op_func
)nfsd4_getattr
,
1160 .op_flags
= ALLOWED_ON_ABSENT_FS
,
1161 .op_name
= "OP_GETATTR",
1164 .op_func
= (nfsd4op_func
)nfsd4_getfh
,
1165 .op_name
= "OP_GETFH",
1168 .op_func
= (nfsd4op_func
)nfsd4_link
,
1169 .op_name
= "OP_LINK",
1172 .op_func
= (nfsd4op_func
)nfsd4_lock
,
1173 .op_name
= "OP_LOCK",
1176 .op_func
= (nfsd4op_func
)nfsd4_lockt
,
1177 .op_name
= "OP_LOCKT",
1180 .op_func
= (nfsd4op_func
)nfsd4_locku
,
1181 .op_name
= "OP_LOCKU",
1184 .op_func
= (nfsd4op_func
)nfsd4_lookup
,
1185 .op_name
= "OP_LOOKUP",
1188 .op_func
= (nfsd4op_func
)nfsd4_lookupp
,
1189 .op_name
= "OP_LOOKUPP",
1192 .op_func
= (nfsd4op_func
)nfsd4_nverify
,
1193 .op_name
= "OP_NVERIFY",
1196 .op_func
= (nfsd4op_func
)nfsd4_open
,
1197 .op_name
= "OP_OPEN",
1199 [OP_OPEN_CONFIRM
] = {
1200 .op_func
= (nfsd4op_func
)nfsd4_open_confirm
,
1201 .op_name
= "OP_OPEN_CONFIRM",
1203 [OP_OPEN_DOWNGRADE
] = {
1204 .op_func
= (nfsd4op_func
)nfsd4_open_downgrade
,
1205 .op_name
= "OP_OPEN_DOWNGRADE",
1208 .op_func
= (nfsd4op_func
)nfsd4_putfh
,
1209 .op_flags
= ALLOWED_WITHOUT_FH
| ALLOWED_ON_ABSENT_FS
,
1210 .op_name
= "OP_PUTFH",
1213 .op_func
= (nfsd4op_func
)nfsd4_putrootfh
,
1214 .op_flags
= ALLOWED_WITHOUT_FH
| ALLOWED_ON_ABSENT_FS
,
1215 .op_name
= "OP_PUTPUBFH",
1218 .op_func
= (nfsd4op_func
)nfsd4_putrootfh
,
1219 .op_flags
= ALLOWED_WITHOUT_FH
| ALLOWED_ON_ABSENT_FS
,
1220 .op_name
= "OP_PUTROOTFH",
1223 .op_func
= (nfsd4op_func
)nfsd4_read
,
1224 .op_name
= "OP_READ",
1227 .op_func
= (nfsd4op_func
)nfsd4_readdir
,
1228 .op_name
= "OP_READDIR",
1231 .op_func
= (nfsd4op_func
)nfsd4_readlink
,
1232 .op_name
= "OP_READLINK",
1235 .op_func
= (nfsd4op_func
)nfsd4_remove
,
1236 .op_name
= "OP_REMOVE",
1239 .op_name
= "OP_RENAME",
1240 .op_func
= (nfsd4op_func
)nfsd4_rename
,
1243 .op_func
= (nfsd4op_func
)nfsd4_renew
,
1244 .op_flags
= ALLOWED_WITHOUT_FH
| ALLOWED_ON_ABSENT_FS
,
1245 .op_name
= "OP_RENEW",
1248 .op_func
= (nfsd4op_func
)nfsd4_restorefh
,
1249 .op_flags
= ALLOWED_WITHOUT_FH
| ALLOWED_ON_ABSENT_FS
,
1250 .op_name
= "OP_RESTOREFH",
1253 .op_func
= (nfsd4op_func
)nfsd4_savefh
,
1254 .op_name
= "OP_SAVEFH",
1257 .op_func
= (nfsd4op_func
)nfsd4_secinfo
,
1258 .op_name
= "OP_SECINFO",
1261 .op_func
= (nfsd4op_func
)nfsd4_setattr
,
1262 .op_name
= "OP_SETATTR",
1264 [OP_SETCLIENTID
] = {
1265 .op_func
= (nfsd4op_func
)nfsd4_setclientid
,
1266 .op_flags
= ALLOWED_WITHOUT_FH
| ALLOWED_ON_ABSENT_FS
,
1267 .op_name
= "OP_SETCLIENTID",
1269 [OP_SETCLIENTID_CONFIRM
] = {
1270 .op_func
= (nfsd4op_func
)nfsd4_setclientid_confirm
,
1271 .op_flags
= ALLOWED_WITHOUT_FH
| ALLOWED_ON_ABSENT_FS
,
1272 .op_name
= "OP_SETCLIENTID_CONFIRM",
1275 .op_func
= (nfsd4op_func
)nfsd4_verify
,
1276 .op_name
= "OP_VERIFY",
1279 .op_func
= (nfsd4op_func
)nfsd4_write
,
1280 .op_name
= "OP_WRITE",
1282 [OP_RELEASE_LOCKOWNER
] = {
1283 .op_func
= (nfsd4op_func
)nfsd4_release_lockowner
,
1284 .op_flags
= ALLOWED_WITHOUT_FH
| ALLOWED_ON_ABSENT_FS
,
1285 .op_name
= "OP_RELEASE_LOCKOWNER",
1288 /* NFSv4.1 operations */
1289 [OP_EXCHANGE_ID
] = {
1290 .op_func
= (nfsd4op_func
)nfsd4_exchange_id
,
1291 .op_flags
= ALLOWED_WITHOUT_FH
| ALLOWED_AS_FIRST_OP
,
1292 .op_name
= "OP_EXCHANGE_ID",
1294 [OP_CREATE_SESSION
] = {
1295 .op_func
= (nfsd4op_func
)nfsd4_create_session
,
1296 .op_flags
= ALLOWED_WITHOUT_FH
| ALLOWED_AS_FIRST_OP
,
1297 .op_name
= "OP_CREATE_SESSION",
1299 [OP_DESTROY_SESSION
] = {
1300 .op_func
= (nfsd4op_func
)nfsd4_destroy_session
,
1301 .op_flags
= ALLOWED_WITHOUT_FH
| ALLOWED_AS_FIRST_OP
,
1302 .op_name
= "OP_DESTROY_SESSION",
1305 .op_func
= (nfsd4op_func
)nfsd4_sequence
,
1306 .op_flags
= ALLOWED_WITHOUT_FH
| ALLOWED_AS_FIRST_OP
,
1307 .op_name
= "OP_SEQUENCE",
1311 static const char *nfsd4_op_name(unsigned opnum
)
1313 if (opnum
< ARRAY_SIZE(nfsd4_ops
))
1314 return nfsd4_ops
[opnum
].op_name
;
1315 return "unknown_operation";
1318 #define nfsd4_voidres nfsd4_voidargs
1319 struct nfsd4_voidargs
{ int dummy
; };
1322 * TODO: At the present time, the NFSv4 server does not do XID caching
1323 * of requests. Implementing XID caching would not be a serious problem,
1324 * although it would require a mild change in interfaces since one
1325 * doesn't know whether an NFSv4 request is idempotent until after the
1326 * XDR decode. However, XID caching totally confuses pynfs (Peter
1327 * Astrand's regression testsuite for NFSv4 servers), which reuses
1328 * XID's liberally, so I've left it unimplemented until pynfs generates
1331 static struct svc_procedure nfsd_procedures4
[2] = {
1333 .pc_func
= (svc_procfunc
) nfsd4_proc_null
,
1334 .pc_encode
= (kxdrproc_t
) nfs4svc_encode_voidres
,
1335 .pc_argsize
= sizeof(struct nfsd4_voidargs
),
1336 .pc_ressize
= sizeof(struct nfsd4_voidres
),
1337 .pc_cachetype
= RC_NOCACHE
,
1340 [NFSPROC4_COMPOUND
] = {
1341 .pc_func
= (svc_procfunc
) nfsd4_proc_compound
,
1342 .pc_decode
= (kxdrproc_t
) nfs4svc_decode_compoundargs
,
1343 .pc_encode
= (kxdrproc_t
) nfs4svc_encode_compoundres
,
1344 .pc_argsize
= sizeof(struct nfsd4_compoundargs
),
1345 .pc_ressize
= sizeof(struct nfsd4_compoundres
),
1346 .pc_cachetype
= RC_NOCACHE
,
1347 .pc_xdrressize
= NFSD_BUFSIZE
/4,
1351 struct svc_version nfsd_version4
= {
1354 .vs_proc
= nfsd_procedures4
,
1355 .vs_dispatch
= nfsd_dispatch
,
1356 .vs_xdrsize
= NFS4_SVC_XDRSIZE
,