Linux 4.19.133
[linux/fpc-iii.git] / fs / nfsd / nfs4proc.c
blobf35aa9f88b5ec19731488527f0364429cd1c2aa0
1 /*
2 * Server-side procedures for NFSv4.
4 * Copyright (c) 2002 The Regents of the University of Michigan.
5 * All rights reserved.
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
12 * are met:
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>
40 #include "idmap.h"
41 #include "cache.h"
42 #include "xdr4.h"
43 #include "vfs.h"
44 #include "current_stateid.h"
45 #include "netns.h"
46 #include "acl.h"
47 #include "pnfs.h"
48 #include "trace.h"
50 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
51 #include <linux/security.h>
53 static inline void
54 nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct xdr_netobj *label, u32 *bmval)
56 struct inode *inode = d_inode(resfh->fh_dentry);
57 int status;
59 inode_lock(inode);
60 status = security_inode_setsecctx(resfh->fh_dentry,
61 label->data, label->len);
62 inode_unlock(inode);
64 if (status)
66 * XXX: We should really fail the whole open, but we may
67 * already have created a new file, so it may be too
68 * late. For now this seems the least of evils:
70 bmval[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
72 return;
74 #else
75 static inline void
76 nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct xdr_netobj *label, u32 *bmval)
77 { }
78 #endif
80 #define NFSDDBG_FACILITY NFSDDBG_PROC
82 static u32 nfsd_attrmask[] = {
83 NFSD_WRITEABLE_ATTRS_WORD0,
84 NFSD_WRITEABLE_ATTRS_WORD1,
85 NFSD_WRITEABLE_ATTRS_WORD2
88 static u32 nfsd41_ex_attrmask[] = {
89 NFSD_SUPPATTR_EXCLCREAT_WORD0,
90 NFSD_SUPPATTR_EXCLCREAT_WORD1,
91 NFSD_SUPPATTR_EXCLCREAT_WORD2
94 static __be32
95 check_attr_support(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
96 u32 *bmval, u32 *writable)
98 struct dentry *dentry = cstate->current_fh.fh_dentry;
99 struct svc_export *exp = cstate->current_fh.fh_export;
101 if (!nfsd_attrs_supported(cstate->minorversion, bmval))
102 return nfserr_attrnotsupp;
103 if ((bmval[0] & FATTR4_WORD0_ACL) && !IS_POSIXACL(d_inode(dentry)))
104 return nfserr_attrnotsupp;
105 if ((bmval[2] & FATTR4_WORD2_SECURITY_LABEL) &&
106 !(exp->ex_flags & NFSEXP_SECURITY_LABEL))
107 return nfserr_attrnotsupp;
108 if (writable && !bmval_is_subset(bmval, writable))
109 return nfserr_inval;
110 if (writable && (bmval[2] & FATTR4_WORD2_MODE_UMASK) &&
111 (bmval[1] & FATTR4_WORD1_MODE))
112 return nfserr_inval;
113 return nfs_ok;
116 static __be32
117 nfsd4_check_open_attributes(struct svc_rqst *rqstp,
118 struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
120 __be32 status = nfs_ok;
122 if (open->op_create == NFS4_OPEN_CREATE) {
123 if (open->op_createmode == NFS4_CREATE_UNCHECKED
124 || open->op_createmode == NFS4_CREATE_GUARDED)
125 status = check_attr_support(rqstp, cstate,
126 open->op_bmval, nfsd_attrmask);
127 else if (open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1)
128 status = check_attr_support(rqstp, cstate,
129 open->op_bmval, nfsd41_ex_attrmask);
132 return status;
135 static int
136 is_create_with_attrs(struct nfsd4_open *open)
138 return open->op_create == NFS4_OPEN_CREATE
139 && (open->op_createmode == NFS4_CREATE_UNCHECKED
140 || open->op_createmode == NFS4_CREATE_GUARDED
141 || open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1);
145 * if error occurs when setting the acl, just clear the acl bit
146 * in the returned attr bitmap.
148 static void
149 do_set_nfs4_acl(struct svc_rqst *rqstp, struct svc_fh *fhp,
150 struct nfs4_acl *acl, u32 *bmval)
152 __be32 status;
154 status = nfsd4_set_nfs4_acl(rqstp, fhp, acl);
155 if (status)
157 * We should probably fail the whole open at this point,
158 * but we've already created the file, so it's too late;
159 * So this seems the least of evils:
161 bmval[0] &= ~FATTR4_WORD0_ACL;
164 static inline void
165 fh_dup2(struct svc_fh *dst, struct svc_fh *src)
167 fh_put(dst);
168 dget(src->fh_dentry);
169 if (src->fh_export)
170 exp_get(src->fh_export);
171 *dst = *src;
174 static __be32
175 do_open_permission(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open, int accmode)
177 __be32 status;
179 if (open->op_truncate &&
180 !(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
181 return nfserr_inval;
183 accmode |= NFSD_MAY_READ_IF_EXEC;
185 if (open->op_share_access & NFS4_SHARE_ACCESS_READ)
186 accmode |= NFSD_MAY_READ;
187 if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
188 accmode |= (NFSD_MAY_WRITE | NFSD_MAY_TRUNC);
189 if (open->op_share_deny & NFS4_SHARE_DENY_READ)
190 accmode |= NFSD_MAY_WRITE;
192 status = fh_verify(rqstp, current_fh, S_IFREG, accmode);
194 return status;
197 static __be32 nfsd_check_obj_isreg(struct svc_fh *fh)
199 umode_t mode = d_inode(fh->fh_dentry)->i_mode;
201 if (S_ISREG(mode))
202 return nfs_ok;
203 if (S_ISDIR(mode))
204 return nfserr_isdir;
206 * Using err_symlink as our catch-all case may look odd; but
207 * there's no other obvious error for this case in 4.0, and we
208 * happen to know that it will cause the linux v4 client to do
209 * the right thing on attempts to open something other than a
210 * regular file.
212 return nfserr_symlink;
215 static void nfsd4_set_open_owner_reply_cache(struct nfsd4_compound_state *cstate, struct nfsd4_open *open, struct svc_fh *resfh)
217 if (nfsd4_has_session(cstate))
218 return;
219 fh_copy_shallow(&open->op_openowner->oo_owner.so_replay.rp_openfh,
220 &resfh->fh_handle);
223 static __be32
224 do_open_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_open *open, struct svc_fh **resfh)
226 struct svc_fh *current_fh = &cstate->current_fh;
227 int accmode;
228 __be32 status;
230 *resfh = kmalloc(sizeof(struct svc_fh), GFP_KERNEL);
231 if (!*resfh)
232 return nfserr_jukebox;
233 fh_init(*resfh, NFS4_FHSIZE);
234 open->op_truncate = 0;
236 if (open->op_create) {
237 /* FIXME: check session persistence and pnfs flags.
238 * The nfsv4.1 spec requires the following semantics:
240 * Persistent | pNFS | Server REQUIRED | Client Allowed
241 * Reply Cache | server | |
242 * -------------+--------+-----------------+--------------------
243 * no | no | EXCLUSIVE4_1 | EXCLUSIVE4_1
244 * | | | (SHOULD)
245 * | | and EXCLUSIVE4 | or EXCLUSIVE4
246 * | | | (SHOULD NOT)
247 * no | yes | EXCLUSIVE4_1 | EXCLUSIVE4_1
248 * yes | no | GUARDED4 | GUARDED4
249 * yes | yes | GUARDED4 | GUARDED4
253 * Note: create modes (UNCHECKED,GUARDED...) are the same
254 * in NFSv4 as in v3 except EXCLUSIVE4_1.
256 current->fs->umask = open->op_umask;
257 status = do_nfsd_create(rqstp, current_fh, open->op_fname.data,
258 open->op_fname.len, &open->op_iattr,
259 *resfh, open->op_createmode,
260 (u32 *)open->op_verf.data,
261 &open->op_truncate, &open->op_created);
262 current->fs->umask = 0;
264 if (!status && open->op_label.len)
265 nfsd4_security_inode_setsecctx(*resfh, &open->op_label, open->op_bmval);
268 * Following rfc 3530 14.2.16, and rfc 5661 18.16.4
269 * use the returned bitmask to indicate which attributes
270 * we used to store the verifier:
272 if (nfsd_create_is_exclusive(open->op_createmode) && status == 0)
273 open->op_bmval[1] |= (FATTR4_WORD1_TIME_ACCESS |
274 FATTR4_WORD1_TIME_MODIFY);
275 } else
277 * Note this may exit with the parent still locked.
278 * We will hold the lock until nfsd4_open's final
279 * lookup, to prevent renames or unlinks until we've had
280 * a chance to an acquire a delegation if appropriate.
282 status = nfsd_lookup(rqstp, current_fh,
283 open->op_fname.data, open->op_fname.len, *resfh);
284 if (status)
285 goto out;
286 status = nfsd_check_obj_isreg(*resfh);
287 if (status)
288 goto out;
290 if (is_create_with_attrs(open) && open->op_acl != NULL)
291 do_set_nfs4_acl(rqstp, *resfh, open->op_acl, open->op_bmval);
293 nfsd4_set_open_owner_reply_cache(cstate, open, *resfh);
294 accmode = NFSD_MAY_NOP;
295 if (open->op_created ||
296 open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR)
297 accmode |= NFSD_MAY_OWNER_OVERRIDE;
298 status = do_open_permission(rqstp, *resfh, open, accmode);
299 set_change_info(&open->op_cinfo, current_fh);
300 out:
301 return status;
304 static __be32
305 do_open_fhandle(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
307 struct svc_fh *current_fh = &cstate->current_fh;
308 __be32 status;
309 int accmode = 0;
311 /* We don't know the target directory, and therefore can not
312 * set the change info
315 memset(&open->op_cinfo, 0, sizeof(struct nfsd4_change_info));
317 nfsd4_set_open_owner_reply_cache(cstate, open, current_fh);
319 open->op_truncate = (open->op_iattr.ia_valid & ATTR_SIZE) &&
320 (open->op_iattr.ia_size == 0);
322 * In the delegation case, the client is telling us about an
323 * open that it *already* performed locally, some time ago. We
324 * should let it succeed now if possible.
326 * In the case of a CLAIM_FH open, on the other hand, the client
327 * may be counting on us to enforce permissions (the Linux 4.1
328 * client uses this for normal opens, for example).
330 if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH)
331 accmode = NFSD_MAY_OWNER_OVERRIDE;
333 status = do_open_permission(rqstp, current_fh, open, accmode);
335 return status;
338 static void
339 copy_clientid(clientid_t *clid, struct nfsd4_session *session)
341 struct nfsd4_sessionid *sid =
342 (struct nfsd4_sessionid *)session->se_sessionid.data;
344 clid->cl_boot = sid->clientid.cl_boot;
345 clid->cl_id = sid->clientid.cl_id;
348 static __be32
349 nfsd4_open(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
350 union nfsd4_op_u *u)
352 struct nfsd4_open *open = &u->open;
353 __be32 status;
354 struct svc_fh *resfh = NULL;
355 struct net *net = SVC_NET(rqstp);
356 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
357 bool reclaim = false;
359 dprintk("NFSD: nfsd4_open filename %.*s op_openowner %p\n",
360 (int)open->op_fname.len, open->op_fname.data,
361 open->op_openowner);
363 /* This check required by spec. */
364 if (open->op_create && open->op_claim_type != NFS4_OPEN_CLAIM_NULL)
365 return nfserr_inval;
367 open->op_created = 0;
369 * RFC5661 18.51.3
370 * Before RECLAIM_COMPLETE done, server should deny new lock
372 if (nfsd4_has_session(cstate) &&
373 !test_bit(NFSD4_CLIENT_RECLAIM_COMPLETE,
374 &cstate->session->se_client->cl_flags) &&
375 open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS)
376 return nfserr_grace;
378 if (nfsd4_has_session(cstate))
379 copy_clientid(&open->op_clientid, cstate->session);
381 /* check seqid for replay. set nfs4_owner */
382 status = nfsd4_process_open1(cstate, open, nn);
383 if (status == nfserr_replay_me) {
384 struct nfs4_replay *rp = &open->op_openowner->oo_owner.so_replay;
385 fh_put(&cstate->current_fh);
386 fh_copy_shallow(&cstate->current_fh.fh_handle,
387 &rp->rp_openfh);
388 status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
389 if (status)
390 dprintk("nfsd4_open: replay failed"
391 " restoring previous filehandle\n");
392 else
393 status = nfserr_replay_me;
395 if (status)
396 goto out;
397 if (open->op_xdr_error) {
398 status = open->op_xdr_error;
399 goto out;
402 status = nfsd4_check_open_attributes(rqstp, cstate, open);
403 if (status)
404 goto out;
406 /* Openowner is now set, so sequence id will get bumped. Now we need
407 * these checks before we do any creates: */
408 status = nfserr_grace;
409 if (opens_in_grace(net) && open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS)
410 goto out;
411 status = nfserr_no_grace;
412 if (!opens_in_grace(net) && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
413 goto out;
415 switch (open->op_claim_type) {
416 case NFS4_OPEN_CLAIM_DELEGATE_CUR:
417 case NFS4_OPEN_CLAIM_NULL:
418 status = do_open_lookup(rqstp, cstate, open, &resfh);
419 if (status)
420 goto out;
421 break;
422 case NFS4_OPEN_CLAIM_PREVIOUS:
423 status = nfs4_check_open_reclaim(&open->op_clientid,
424 cstate, nn);
425 if (status)
426 goto out;
427 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
428 reclaim = true;
429 case NFS4_OPEN_CLAIM_FH:
430 case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
431 status = do_open_fhandle(rqstp, cstate, open);
432 if (status)
433 goto out;
434 resfh = &cstate->current_fh;
435 break;
436 case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
437 case NFS4_OPEN_CLAIM_DELEGATE_PREV:
438 dprintk("NFSD: unsupported OPEN claim type %d\n",
439 open->op_claim_type);
440 status = nfserr_notsupp;
441 goto out;
442 default:
443 dprintk("NFSD: Invalid OPEN claim type %d\n",
444 open->op_claim_type);
445 status = nfserr_inval;
446 goto out;
449 * nfsd4_process_open2() does the actual opening of the file. If
450 * successful, it (1) truncates the file if open->op_truncate was
451 * set, (2) sets open->op_stateid, (3) sets open->op_delegation.
453 status = nfsd4_process_open2(rqstp, resfh, open);
454 WARN(status && open->op_created,
455 "nfsd4_process_open2 failed to open newly-created file! status=%u\n",
456 be32_to_cpu(status));
457 if (reclaim && !status)
458 nn->somebody_reclaimed = true;
459 out:
460 if (resfh && resfh != &cstate->current_fh) {
461 fh_dup2(&cstate->current_fh, resfh);
462 fh_put(resfh);
463 kfree(resfh);
465 nfsd4_cleanup_open_state(cstate, open);
466 nfsd4_bump_seqid(cstate, status);
467 return status;
471 * OPEN is the only seqid-mutating operation whose decoding can fail
472 * with a seqid-mutating error (specifically, decoding of user names in
473 * the attributes). Therefore we have to do some processing to look up
474 * the stateowner so that we can bump the seqid.
476 static __be32 nfsd4_open_omfg(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_op *op)
478 struct nfsd4_open *open = &op->u.open;
480 if (!seqid_mutating_err(ntohl(op->status)))
481 return op->status;
482 if (nfsd4_has_session(cstate))
483 return op->status;
484 open->op_xdr_error = op->status;
485 return nfsd4_open(rqstp, cstate, &op->u);
489 * filehandle-manipulating ops.
491 static __be32
492 nfsd4_getfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
493 union nfsd4_op_u *u)
495 u->getfh = &cstate->current_fh;
496 return nfs_ok;
499 static __be32
500 nfsd4_putfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
501 union nfsd4_op_u *u)
503 struct nfsd4_putfh *putfh = &u->putfh;
505 fh_put(&cstate->current_fh);
506 cstate->current_fh.fh_handle.fh_size = putfh->pf_fhlen;
507 memcpy(&cstate->current_fh.fh_handle.fh_base, putfh->pf_fhval,
508 putfh->pf_fhlen);
509 return fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_BYPASS_GSS);
512 static __be32
513 nfsd4_putrootfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
514 union nfsd4_op_u *u)
516 __be32 status;
518 fh_put(&cstate->current_fh);
519 status = exp_pseudoroot(rqstp, &cstate->current_fh);
520 return status;
523 static __be32
524 nfsd4_restorefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
525 union nfsd4_op_u *u)
527 if (!cstate->save_fh.fh_dentry)
528 return nfserr_restorefh;
530 fh_dup2(&cstate->current_fh, &cstate->save_fh);
531 if (HAS_STATE_ID(cstate, SAVED_STATE_ID_FLAG)) {
532 memcpy(&cstate->current_stateid, &cstate->save_stateid, sizeof(stateid_t));
533 SET_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
535 return nfs_ok;
538 static __be32
539 nfsd4_savefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
540 union nfsd4_op_u *u)
542 fh_dup2(&cstate->save_fh, &cstate->current_fh);
543 if (HAS_STATE_ID(cstate, CURRENT_STATE_ID_FLAG)) {
544 memcpy(&cstate->save_stateid, &cstate->current_stateid, sizeof(stateid_t));
545 SET_STATE_ID(cstate, SAVED_STATE_ID_FLAG);
547 return nfs_ok;
551 * misc nfsv4 ops
553 static __be32
554 nfsd4_access(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
555 union nfsd4_op_u *u)
557 struct nfsd4_access *access = &u->access;
559 if (access->ac_req_access & ~NFS3_ACCESS_FULL)
560 return nfserr_inval;
562 access->ac_resp_access = access->ac_req_access;
563 return nfsd_access(rqstp, &cstate->current_fh, &access->ac_resp_access,
564 &access->ac_supported);
567 static void gen_boot_verifier(nfs4_verifier *verifier, struct net *net)
569 __be32 verf[2];
570 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
573 * This is opaque to client, so no need to byte-swap. Use
574 * __force to keep sparse happy. y2038 time_t overflow is
575 * irrelevant in this usage.
577 verf[0] = (__force __be32)nn->nfssvc_boot.tv_sec;
578 verf[1] = (__force __be32)nn->nfssvc_boot.tv_nsec;
579 memcpy(verifier->data, verf, sizeof(verifier->data));
582 static __be32
583 nfsd4_commit(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
584 union nfsd4_op_u *u)
586 struct nfsd4_commit *commit = &u->commit;
588 gen_boot_verifier(&commit->co_verf, SVC_NET(rqstp));
589 return nfsd_commit(rqstp, &cstate->current_fh, commit->co_offset,
590 commit->co_count);
593 static __be32
594 nfsd4_create(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
595 union nfsd4_op_u *u)
597 struct nfsd4_create *create = &u->create;
598 struct svc_fh resfh;
599 __be32 status;
600 dev_t rdev;
602 fh_init(&resfh, NFS4_FHSIZE);
604 status = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_NOP);
605 if (status)
606 return status;
608 status = check_attr_support(rqstp, cstate, create->cr_bmval,
609 nfsd_attrmask);
610 if (status)
611 return status;
613 current->fs->umask = create->cr_umask;
614 switch (create->cr_type) {
615 case NF4LNK:
616 status = nfsd_symlink(rqstp, &cstate->current_fh,
617 create->cr_name, create->cr_namelen,
618 create->cr_data, &resfh);
619 break;
621 case NF4BLK:
622 status = nfserr_inval;
623 rdev = MKDEV(create->cr_specdata1, create->cr_specdata2);
624 if (MAJOR(rdev) != create->cr_specdata1 ||
625 MINOR(rdev) != create->cr_specdata2)
626 goto out_umask;
627 status = nfsd_create(rqstp, &cstate->current_fh,
628 create->cr_name, create->cr_namelen,
629 &create->cr_iattr, S_IFBLK, rdev, &resfh);
630 break;
632 case NF4CHR:
633 status = nfserr_inval;
634 rdev = MKDEV(create->cr_specdata1, create->cr_specdata2);
635 if (MAJOR(rdev) != create->cr_specdata1 ||
636 MINOR(rdev) != create->cr_specdata2)
637 goto out_umask;
638 status = nfsd_create(rqstp, &cstate->current_fh,
639 create->cr_name, create->cr_namelen,
640 &create->cr_iattr,S_IFCHR, rdev, &resfh);
641 break;
643 case NF4SOCK:
644 status = nfsd_create(rqstp, &cstate->current_fh,
645 create->cr_name, create->cr_namelen,
646 &create->cr_iattr, S_IFSOCK, 0, &resfh);
647 break;
649 case NF4FIFO:
650 status = nfsd_create(rqstp, &cstate->current_fh,
651 create->cr_name, create->cr_namelen,
652 &create->cr_iattr, S_IFIFO, 0, &resfh);
653 break;
655 case NF4DIR:
656 create->cr_iattr.ia_valid &= ~ATTR_SIZE;
657 status = nfsd_create(rqstp, &cstate->current_fh,
658 create->cr_name, create->cr_namelen,
659 &create->cr_iattr, S_IFDIR, 0, &resfh);
660 break;
662 default:
663 status = nfserr_badtype;
666 if (status)
667 goto out;
669 if (create->cr_label.len)
670 nfsd4_security_inode_setsecctx(&resfh, &create->cr_label, create->cr_bmval);
672 if (create->cr_acl != NULL)
673 do_set_nfs4_acl(rqstp, &resfh, create->cr_acl,
674 create->cr_bmval);
676 fh_unlock(&cstate->current_fh);
677 set_change_info(&create->cr_cinfo, &cstate->current_fh);
678 fh_dup2(&cstate->current_fh, &resfh);
679 out:
680 fh_put(&resfh);
681 out_umask:
682 current->fs->umask = 0;
683 return status;
686 static __be32
687 nfsd4_getattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
688 union nfsd4_op_u *u)
690 struct nfsd4_getattr *getattr = &u->getattr;
691 __be32 status;
693 status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
694 if (status)
695 return status;
697 if (getattr->ga_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)
698 return nfserr_inval;
700 getattr->ga_bmval[0] &= nfsd_suppattrs[cstate->minorversion][0];
701 getattr->ga_bmval[1] &= nfsd_suppattrs[cstate->minorversion][1];
702 getattr->ga_bmval[2] &= nfsd_suppattrs[cstate->minorversion][2];
704 getattr->ga_fhp = &cstate->current_fh;
705 return nfs_ok;
708 static __be32
709 nfsd4_link(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
710 union nfsd4_op_u *u)
712 struct nfsd4_link *link = &u->link;
713 __be32 status;
715 status = nfsd_link(rqstp, &cstate->current_fh,
716 link->li_name, link->li_namelen, &cstate->save_fh);
717 if (!status)
718 set_change_info(&link->li_cinfo, &cstate->current_fh);
719 return status;
722 static __be32 nfsd4_do_lookupp(struct svc_rqst *rqstp, struct svc_fh *fh)
724 struct svc_fh tmp_fh;
725 __be32 ret;
727 fh_init(&tmp_fh, NFS4_FHSIZE);
728 ret = exp_pseudoroot(rqstp, &tmp_fh);
729 if (ret)
730 return ret;
731 if (tmp_fh.fh_dentry == fh->fh_dentry) {
732 fh_put(&tmp_fh);
733 return nfserr_noent;
735 fh_put(&tmp_fh);
736 return nfsd_lookup(rqstp, fh, "..", 2, fh);
739 static __be32
740 nfsd4_lookupp(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
741 union nfsd4_op_u *u)
743 return nfsd4_do_lookupp(rqstp, &cstate->current_fh);
746 static __be32
747 nfsd4_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
748 union nfsd4_op_u *u)
750 return nfsd_lookup(rqstp, &cstate->current_fh,
751 u->lookup.lo_name, u->lookup.lo_len,
752 &cstate->current_fh);
755 static __be32
756 nfsd4_read(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
757 union nfsd4_op_u *u)
759 struct nfsd4_read *read = &u->read;
760 __be32 status;
762 read->rd_filp = NULL;
763 if (read->rd_offset >= OFFSET_MAX)
764 return nfserr_inval;
766 trace_nfsd_read_start(rqstp, &cstate->current_fh,
767 read->rd_offset, read->rd_length);
770 * If we do a zero copy read, then a client will see read data
771 * that reflects the state of the file *after* performing the
772 * following compound.
774 * To ensure proper ordering, we therefore turn off zero copy if
775 * the client wants us to do more in this compound:
777 if (!nfsd4_last_compound_op(rqstp))
778 clear_bit(RQ_SPLICE_OK, &rqstp->rq_flags);
780 /* check stateid */
781 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
782 &read->rd_stateid, RD_STATE,
783 &read->rd_filp, &read->rd_tmp_file);
784 if (status) {
785 dprintk("NFSD: nfsd4_read: couldn't process stateid!\n");
786 goto out;
788 status = nfs_ok;
789 out:
790 read->rd_rqstp = rqstp;
791 read->rd_fhp = &cstate->current_fh;
792 return status;
796 static void
797 nfsd4_read_release(union nfsd4_op_u *u)
799 if (u->read.rd_filp)
800 fput(u->read.rd_filp);
801 trace_nfsd_read_done(u->read.rd_rqstp, u->read.rd_fhp,
802 u->read.rd_offset, u->read.rd_length);
805 static __be32
806 nfsd4_readdir(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
807 union nfsd4_op_u *u)
809 struct nfsd4_readdir *readdir = &u->readdir;
810 u64 cookie = readdir->rd_cookie;
811 static const nfs4_verifier zeroverf;
813 /* no need to check permission - this will be done in nfsd_readdir() */
815 if (readdir->rd_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)
816 return nfserr_inval;
818 readdir->rd_bmval[0] &= nfsd_suppattrs[cstate->minorversion][0];
819 readdir->rd_bmval[1] &= nfsd_suppattrs[cstate->minorversion][1];
820 readdir->rd_bmval[2] &= nfsd_suppattrs[cstate->minorversion][2];
822 if ((cookie == 1) || (cookie == 2) ||
823 (cookie == 0 && memcmp(readdir->rd_verf.data, zeroverf.data, NFS4_VERIFIER_SIZE)))
824 return nfserr_bad_cookie;
826 readdir->rd_rqstp = rqstp;
827 readdir->rd_fhp = &cstate->current_fh;
828 return nfs_ok;
831 static __be32
832 nfsd4_readlink(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
833 union nfsd4_op_u *u)
835 u->readlink.rl_rqstp = rqstp;
836 u->readlink.rl_fhp = &cstate->current_fh;
837 return nfs_ok;
840 static __be32
841 nfsd4_remove(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
842 union nfsd4_op_u *u)
844 struct nfsd4_remove *remove = &u->remove;
845 __be32 status;
847 if (opens_in_grace(SVC_NET(rqstp)))
848 return nfserr_grace;
849 status = nfsd_unlink(rqstp, &cstate->current_fh, 0,
850 remove->rm_name, remove->rm_namelen);
851 if (!status) {
852 fh_unlock(&cstate->current_fh);
853 set_change_info(&remove->rm_cinfo, &cstate->current_fh);
855 return status;
858 static __be32
859 nfsd4_rename(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
860 union nfsd4_op_u *u)
862 struct nfsd4_rename *rename = &u->rename;
863 __be32 status;
865 if (opens_in_grace(SVC_NET(rqstp)) &&
866 !(cstate->save_fh.fh_export->ex_flags & NFSEXP_NOSUBTREECHECK))
867 return nfserr_grace;
868 status = nfsd_rename(rqstp, &cstate->save_fh, rename->rn_sname,
869 rename->rn_snamelen, &cstate->current_fh,
870 rename->rn_tname, rename->rn_tnamelen);
871 if (status)
872 return status;
873 set_change_info(&rename->rn_sinfo, &cstate->current_fh);
874 set_change_info(&rename->rn_tinfo, &cstate->save_fh);
875 return nfs_ok;
878 static __be32
879 nfsd4_secinfo(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
880 union nfsd4_op_u *u)
882 struct nfsd4_secinfo *secinfo = &u->secinfo;
883 struct svc_export *exp;
884 struct dentry *dentry;
885 __be32 err;
887 err = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_EXEC);
888 if (err)
889 return err;
890 err = nfsd_lookup_dentry(rqstp, &cstate->current_fh,
891 secinfo->si_name, secinfo->si_namelen,
892 &exp, &dentry);
893 if (err)
894 return err;
895 fh_unlock(&cstate->current_fh);
896 if (d_really_is_negative(dentry)) {
897 exp_put(exp);
898 err = nfserr_noent;
899 } else
900 secinfo->si_exp = exp;
901 dput(dentry);
902 if (cstate->minorversion)
903 /* See rfc 5661 section 2.6.3.1.1.8 */
904 fh_put(&cstate->current_fh);
905 return err;
908 static __be32
909 nfsd4_secinfo_no_name(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
910 union nfsd4_op_u *u)
912 __be32 err;
914 switch (u->secinfo_no_name.sin_style) {
915 case NFS4_SECINFO_STYLE4_CURRENT_FH:
916 break;
917 case NFS4_SECINFO_STYLE4_PARENT:
918 err = nfsd4_do_lookupp(rqstp, &cstate->current_fh);
919 if (err)
920 return err;
921 break;
922 default:
923 return nfserr_inval;
926 u->secinfo_no_name.sin_exp = exp_get(cstate->current_fh.fh_export);
927 fh_put(&cstate->current_fh);
928 return nfs_ok;
931 static void
932 nfsd4_secinfo_release(union nfsd4_op_u *u)
934 if (u->secinfo.si_exp)
935 exp_put(u->secinfo.si_exp);
938 static void
939 nfsd4_secinfo_no_name_release(union nfsd4_op_u *u)
941 if (u->secinfo_no_name.sin_exp)
942 exp_put(u->secinfo_no_name.sin_exp);
945 static __be32
946 nfsd4_setattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
947 union nfsd4_op_u *u)
949 struct nfsd4_setattr *setattr = &u->setattr;
950 __be32 status = nfs_ok;
951 int err;
953 if (setattr->sa_iattr.ia_valid & ATTR_SIZE) {
954 status = nfs4_preprocess_stateid_op(rqstp, cstate,
955 &cstate->current_fh, &setattr->sa_stateid,
956 WR_STATE, NULL, NULL);
957 if (status) {
958 dprintk("NFSD: nfsd4_setattr: couldn't process stateid!\n");
959 return status;
962 err = fh_want_write(&cstate->current_fh);
963 if (err)
964 return nfserrno(err);
965 status = nfs_ok;
967 status = check_attr_support(rqstp, cstate, setattr->sa_bmval,
968 nfsd_attrmask);
969 if (status)
970 goto out;
972 if (setattr->sa_acl != NULL)
973 status = nfsd4_set_nfs4_acl(rqstp, &cstate->current_fh,
974 setattr->sa_acl);
975 if (status)
976 goto out;
977 if (setattr->sa_label.len)
978 status = nfsd4_set_nfs4_label(rqstp, &cstate->current_fh,
979 &setattr->sa_label);
980 if (status)
981 goto out;
982 status = nfsd_setattr(rqstp, &cstate->current_fh, &setattr->sa_iattr,
983 0, (time_t)0);
984 out:
985 fh_drop_write(&cstate->current_fh);
986 return status;
989 static __be32
990 nfsd4_write(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
991 union nfsd4_op_u *u)
993 struct nfsd4_write *write = &u->write;
994 stateid_t *stateid = &write->wr_stateid;
995 struct file *filp = NULL;
996 __be32 status = nfs_ok;
997 unsigned long cnt;
998 int nvecs;
1000 if (write->wr_offset >= OFFSET_MAX)
1001 return nfserr_inval;
1003 cnt = write->wr_buflen;
1004 trace_nfsd_write_start(rqstp, &cstate->current_fh,
1005 write->wr_offset, cnt);
1006 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
1007 stateid, WR_STATE, &filp, NULL);
1008 if (status) {
1009 dprintk("NFSD: nfsd4_write: couldn't process stateid!\n");
1010 return status;
1013 write->wr_how_written = write->wr_stable_how;
1014 gen_boot_verifier(&write->wr_verifier, SVC_NET(rqstp));
1016 nvecs = svc_fill_write_vector(rqstp, write->wr_pagelist,
1017 &write->wr_head, write->wr_buflen);
1018 WARN_ON_ONCE(nvecs > ARRAY_SIZE(rqstp->rq_vec));
1020 status = nfsd_vfs_write(rqstp, &cstate->current_fh, filp,
1021 write->wr_offset, rqstp->rq_vec, nvecs, &cnt,
1022 write->wr_how_written);
1023 fput(filp);
1025 write->wr_bytes_written = cnt;
1026 trace_nfsd_write_done(rqstp, &cstate->current_fh,
1027 write->wr_offset, cnt);
1028 return status;
1031 static __be32
1032 nfsd4_verify_copy(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1033 stateid_t *src_stateid, struct file **src,
1034 stateid_t *dst_stateid, struct file **dst)
1036 __be32 status;
1038 if (!cstate->save_fh.fh_dentry)
1039 return nfserr_nofilehandle;
1041 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->save_fh,
1042 src_stateid, RD_STATE, src, NULL);
1043 if (status) {
1044 dprintk("NFSD: %s: couldn't process src stateid!\n", __func__);
1045 goto out;
1048 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
1049 dst_stateid, WR_STATE, dst, NULL);
1050 if (status) {
1051 dprintk("NFSD: %s: couldn't process dst stateid!\n", __func__);
1052 goto out_put_src;
1055 /* fix up for NFS-specific error code */
1056 if (!S_ISREG(file_inode(*src)->i_mode) ||
1057 !S_ISREG(file_inode(*dst)->i_mode)) {
1058 status = nfserr_wrong_type;
1059 goto out_put_dst;
1062 out:
1063 return status;
1064 out_put_dst:
1065 fput(*dst);
1066 out_put_src:
1067 fput(*src);
1068 goto out;
1071 static __be32
1072 nfsd4_clone(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1073 union nfsd4_op_u *u)
1075 struct nfsd4_clone *clone = &u->clone;
1076 struct file *src, *dst;
1077 __be32 status;
1079 status = nfsd4_verify_copy(rqstp, cstate, &clone->cl_src_stateid, &src,
1080 &clone->cl_dst_stateid, &dst);
1081 if (status)
1082 goto out;
1084 status = nfsd4_clone_file_range(src, clone->cl_src_pos,
1085 dst, clone->cl_dst_pos, clone->cl_count);
1087 fput(dst);
1088 fput(src);
1089 out:
1090 return status;
1093 static __be32
1094 nfsd4_copy(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1095 union nfsd4_op_u *u)
1097 struct nfsd4_copy *copy = &u->copy;
1098 struct file *src, *dst;
1099 __be32 status;
1100 ssize_t bytes;
1102 status = nfsd4_verify_copy(rqstp, cstate, &copy->cp_src_stateid, &src,
1103 &copy->cp_dst_stateid, &dst);
1104 if (status)
1105 goto out;
1107 bytes = nfsd_copy_file_range(src, copy->cp_src_pos,
1108 dst, copy->cp_dst_pos, copy->cp_count);
1110 if (bytes < 0)
1111 status = nfserrno(bytes);
1112 else {
1113 copy->cp_res.wr_bytes_written = bytes;
1114 copy->cp_res.wr_stable_how = NFS_UNSTABLE;
1115 copy->cp_synchronous = 1;
1116 gen_boot_verifier(&copy->cp_res.wr_verifier, SVC_NET(rqstp));
1117 status = nfs_ok;
1120 fput(src);
1121 fput(dst);
1122 out:
1123 return status;
1126 static __be32
1127 nfsd4_fallocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1128 struct nfsd4_fallocate *fallocate, int flags)
1130 __be32 status = nfserr_notsupp;
1131 struct file *file;
1133 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
1134 &fallocate->falloc_stateid,
1135 WR_STATE, &file, NULL);
1136 if (status != nfs_ok) {
1137 dprintk("NFSD: nfsd4_fallocate: couldn't process stateid!\n");
1138 return status;
1141 status = nfsd4_vfs_fallocate(rqstp, &cstate->current_fh, file,
1142 fallocate->falloc_offset,
1143 fallocate->falloc_length,
1144 flags);
1145 fput(file);
1146 return status;
1149 static __be32
1150 nfsd4_allocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1151 union nfsd4_op_u *u)
1153 return nfsd4_fallocate(rqstp, cstate, &u->allocate, 0);
1156 static __be32
1157 nfsd4_deallocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1158 union nfsd4_op_u *u)
1160 return nfsd4_fallocate(rqstp, cstate, &u->deallocate,
1161 FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE);
1164 static __be32
1165 nfsd4_seek(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1166 union nfsd4_op_u *u)
1168 struct nfsd4_seek *seek = &u->seek;
1169 int whence;
1170 __be32 status;
1171 struct file *file;
1173 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
1174 &seek->seek_stateid,
1175 RD_STATE, &file, NULL);
1176 if (status) {
1177 dprintk("NFSD: nfsd4_seek: couldn't process stateid!\n");
1178 return status;
1181 switch (seek->seek_whence) {
1182 case NFS4_CONTENT_DATA:
1183 whence = SEEK_DATA;
1184 break;
1185 case NFS4_CONTENT_HOLE:
1186 whence = SEEK_HOLE;
1187 break;
1188 default:
1189 status = nfserr_union_notsupp;
1190 goto out;
1194 * Note: This call does change file->f_pos, but nothing in NFSD
1195 * should ever file->f_pos.
1197 seek->seek_pos = vfs_llseek(file, seek->seek_offset, whence);
1198 if (seek->seek_pos < 0)
1199 status = nfserrno(seek->seek_pos);
1200 else if (seek->seek_pos >= i_size_read(file_inode(file)))
1201 seek->seek_eof = true;
1203 out:
1204 fput(file);
1205 return status;
1208 /* This routine never returns NFS_OK! If there are no other errors, it
1209 * will return NFSERR_SAME or NFSERR_NOT_SAME depending on whether the
1210 * attributes matched. VERIFY is implemented by mapping NFSERR_SAME
1211 * to NFS_OK after the call; NVERIFY by mapping NFSERR_NOT_SAME to NFS_OK.
1213 static __be32
1214 _nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1215 struct nfsd4_verify *verify)
1217 __be32 *buf, *p;
1218 int count;
1219 __be32 status;
1221 status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
1222 if (status)
1223 return status;
1225 status = check_attr_support(rqstp, cstate, verify->ve_bmval, NULL);
1226 if (status)
1227 return status;
1229 if ((verify->ve_bmval[0] & FATTR4_WORD0_RDATTR_ERROR)
1230 || (verify->ve_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1))
1231 return nfserr_inval;
1232 if (verify->ve_attrlen & 3)
1233 return nfserr_inval;
1235 /* count in words:
1236 * bitmap_len(1) + bitmap(2) + attr_len(1) = 4
1238 count = 4 + (verify->ve_attrlen >> 2);
1239 buf = kmalloc(count << 2, GFP_KERNEL);
1240 if (!buf)
1241 return nfserr_jukebox;
1243 p = buf;
1244 status = nfsd4_encode_fattr_to_buf(&p, count, &cstate->current_fh,
1245 cstate->current_fh.fh_export,
1246 cstate->current_fh.fh_dentry,
1247 verify->ve_bmval,
1248 rqstp, 0);
1250 * If nfsd4_encode_fattr() ran out of space, assume that's because
1251 * the attributes are longer (hence different) than those given:
1253 if (status == nfserr_resource)
1254 status = nfserr_not_same;
1255 if (status)
1256 goto out_kfree;
1258 /* skip bitmap */
1259 p = buf + 1 + ntohl(buf[0]);
1260 status = nfserr_not_same;
1261 if (ntohl(*p++) != verify->ve_attrlen)
1262 goto out_kfree;
1263 if (!memcmp(p, verify->ve_attrval, verify->ve_attrlen))
1264 status = nfserr_same;
1266 out_kfree:
1267 kfree(buf);
1268 return status;
1271 static __be32
1272 nfsd4_nverify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1273 union nfsd4_op_u *u)
1275 __be32 status;
1277 status = _nfsd4_verify(rqstp, cstate, &u->verify);
1278 return status == nfserr_not_same ? nfs_ok : status;
1281 static __be32
1282 nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1283 union nfsd4_op_u *u)
1285 __be32 status;
1287 status = _nfsd4_verify(rqstp, cstate, &u->nverify);
1288 return status == nfserr_same ? nfs_ok : status;
1291 #ifdef CONFIG_NFSD_PNFS
1292 static const struct nfsd4_layout_ops *
1293 nfsd4_layout_verify(struct svc_export *exp, unsigned int layout_type)
1295 if (!exp->ex_layout_types) {
1296 dprintk("%s: export does not support pNFS\n", __func__);
1297 return NULL;
1300 if (layout_type >= LAYOUT_TYPE_MAX ||
1301 !(exp->ex_layout_types & (1 << layout_type))) {
1302 dprintk("%s: layout type %d not supported\n",
1303 __func__, layout_type);
1304 return NULL;
1307 return nfsd4_layout_ops[layout_type];
1310 static __be32
1311 nfsd4_getdeviceinfo(struct svc_rqst *rqstp,
1312 struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
1314 struct nfsd4_getdeviceinfo *gdp = &u->getdeviceinfo;
1315 const struct nfsd4_layout_ops *ops;
1316 struct nfsd4_deviceid_map *map;
1317 struct svc_export *exp;
1318 __be32 nfserr;
1320 dprintk("%s: layout_type %u dev_id [0x%llx:0x%x] maxcnt %u\n",
1321 __func__,
1322 gdp->gd_layout_type,
1323 gdp->gd_devid.fsid_idx, gdp->gd_devid.generation,
1324 gdp->gd_maxcount);
1326 map = nfsd4_find_devid_map(gdp->gd_devid.fsid_idx);
1327 if (!map) {
1328 dprintk("%s: couldn't find device ID to export mapping!\n",
1329 __func__);
1330 return nfserr_noent;
1333 exp = rqst_exp_find(rqstp, map->fsid_type, map->fsid);
1334 if (IS_ERR(exp)) {
1335 dprintk("%s: could not find device id\n", __func__);
1336 return nfserr_noent;
1339 nfserr = nfserr_layoutunavailable;
1340 ops = nfsd4_layout_verify(exp, gdp->gd_layout_type);
1341 if (!ops)
1342 goto out;
1344 nfserr = nfs_ok;
1345 if (gdp->gd_maxcount != 0) {
1346 nfserr = ops->proc_getdeviceinfo(exp->ex_path.mnt->mnt_sb,
1347 rqstp, cstate->session->se_client, gdp);
1350 gdp->gd_notify_types &= ops->notify_types;
1351 out:
1352 exp_put(exp);
1353 return nfserr;
1356 static void
1357 nfsd4_getdeviceinfo_release(union nfsd4_op_u *u)
1359 kfree(u->getdeviceinfo.gd_device);
1362 static __be32
1363 nfsd4_layoutget(struct svc_rqst *rqstp,
1364 struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
1366 struct nfsd4_layoutget *lgp = &u->layoutget;
1367 struct svc_fh *current_fh = &cstate->current_fh;
1368 const struct nfsd4_layout_ops *ops;
1369 struct nfs4_layout_stateid *ls;
1370 __be32 nfserr;
1371 int accmode = NFSD_MAY_READ_IF_EXEC;
1373 switch (lgp->lg_seg.iomode) {
1374 case IOMODE_READ:
1375 accmode |= NFSD_MAY_READ;
1376 break;
1377 case IOMODE_RW:
1378 accmode |= NFSD_MAY_READ | NFSD_MAY_WRITE;
1379 break;
1380 default:
1381 dprintk("%s: invalid iomode %d\n",
1382 __func__, lgp->lg_seg.iomode);
1383 nfserr = nfserr_badiomode;
1384 goto out;
1387 nfserr = fh_verify(rqstp, current_fh, 0, accmode);
1388 if (nfserr)
1389 goto out;
1391 nfserr = nfserr_layoutunavailable;
1392 ops = nfsd4_layout_verify(current_fh->fh_export, lgp->lg_layout_type);
1393 if (!ops)
1394 goto out;
1397 * Verify minlength and range as per RFC5661:
1398 * o If loga_length is less than loga_minlength,
1399 * the metadata server MUST return NFS4ERR_INVAL.
1400 * o If the sum of loga_offset and loga_minlength exceeds
1401 * NFS4_UINT64_MAX, and loga_minlength is not
1402 * NFS4_UINT64_MAX, the error NFS4ERR_INVAL MUST result.
1403 * o If the sum of loga_offset and loga_length exceeds
1404 * NFS4_UINT64_MAX, and loga_length is not NFS4_UINT64_MAX,
1405 * the error NFS4ERR_INVAL MUST result.
1407 nfserr = nfserr_inval;
1408 if (lgp->lg_seg.length < lgp->lg_minlength ||
1409 (lgp->lg_minlength != NFS4_MAX_UINT64 &&
1410 lgp->lg_minlength > NFS4_MAX_UINT64 - lgp->lg_seg.offset) ||
1411 (lgp->lg_seg.length != NFS4_MAX_UINT64 &&
1412 lgp->lg_seg.length > NFS4_MAX_UINT64 - lgp->lg_seg.offset))
1413 goto out;
1414 if (lgp->lg_seg.length == 0)
1415 goto out;
1417 nfserr = nfsd4_preprocess_layout_stateid(rqstp, cstate, &lgp->lg_sid,
1418 true, lgp->lg_layout_type, &ls);
1419 if (nfserr) {
1420 trace_nfsd_layout_get_lookup_fail(&lgp->lg_sid);
1421 goto out;
1424 nfserr = nfserr_recallconflict;
1425 if (atomic_read(&ls->ls_stid.sc_file->fi_lo_recalls))
1426 goto out_put_stid;
1428 nfserr = ops->proc_layoutget(d_inode(current_fh->fh_dentry),
1429 current_fh, lgp);
1430 if (nfserr)
1431 goto out_put_stid;
1433 nfserr = nfsd4_insert_layout(lgp, ls);
1435 out_put_stid:
1436 mutex_unlock(&ls->ls_mutex);
1437 nfs4_put_stid(&ls->ls_stid);
1438 out:
1439 return nfserr;
1442 static void
1443 nfsd4_layoutget_release(union nfsd4_op_u *u)
1445 kfree(u->layoutget.lg_content);
1448 static __be32
1449 nfsd4_layoutcommit(struct svc_rqst *rqstp,
1450 struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
1452 struct nfsd4_layoutcommit *lcp = &u->layoutcommit;
1453 const struct nfsd4_layout_seg *seg = &lcp->lc_seg;
1454 struct svc_fh *current_fh = &cstate->current_fh;
1455 const struct nfsd4_layout_ops *ops;
1456 loff_t new_size = lcp->lc_last_wr + 1;
1457 struct inode *inode;
1458 struct nfs4_layout_stateid *ls;
1459 __be32 nfserr;
1461 nfserr = fh_verify(rqstp, current_fh, 0, NFSD_MAY_WRITE);
1462 if (nfserr)
1463 goto out;
1465 nfserr = nfserr_layoutunavailable;
1466 ops = nfsd4_layout_verify(current_fh->fh_export, lcp->lc_layout_type);
1467 if (!ops)
1468 goto out;
1469 inode = d_inode(current_fh->fh_dentry);
1471 nfserr = nfserr_inval;
1472 if (new_size <= seg->offset) {
1473 dprintk("pnfsd: last write before layout segment\n");
1474 goto out;
1476 if (new_size > seg->offset + seg->length) {
1477 dprintk("pnfsd: last write beyond layout segment\n");
1478 goto out;
1480 if (!lcp->lc_newoffset && new_size > i_size_read(inode)) {
1481 dprintk("pnfsd: layoutcommit beyond EOF\n");
1482 goto out;
1485 nfserr = nfsd4_preprocess_layout_stateid(rqstp, cstate, &lcp->lc_sid,
1486 false, lcp->lc_layout_type,
1487 &ls);
1488 if (nfserr) {
1489 trace_nfsd_layout_commit_lookup_fail(&lcp->lc_sid);
1490 /* fixup error code as per RFC5661 */
1491 if (nfserr == nfserr_bad_stateid)
1492 nfserr = nfserr_badlayout;
1493 goto out;
1496 /* LAYOUTCOMMIT does not require any serialization */
1497 mutex_unlock(&ls->ls_mutex);
1499 if (new_size > i_size_read(inode)) {
1500 lcp->lc_size_chg = 1;
1501 lcp->lc_newsize = new_size;
1502 } else {
1503 lcp->lc_size_chg = 0;
1506 nfserr = ops->proc_layoutcommit(inode, lcp);
1507 nfs4_put_stid(&ls->ls_stid);
1508 out:
1509 return nfserr;
1512 static __be32
1513 nfsd4_layoutreturn(struct svc_rqst *rqstp,
1514 struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
1516 struct nfsd4_layoutreturn *lrp = &u->layoutreturn;
1517 struct svc_fh *current_fh = &cstate->current_fh;
1518 __be32 nfserr;
1520 nfserr = fh_verify(rqstp, current_fh, 0, NFSD_MAY_NOP);
1521 if (nfserr)
1522 goto out;
1524 nfserr = nfserr_layoutunavailable;
1525 if (!nfsd4_layout_verify(current_fh->fh_export, lrp->lr_layout_type))
1526 goto out;
1528 switch (lrp->lr_seg.iomode) {
1529 case IOMODE_READ:
1530 case IOMODE_RW:
1531 case IOMODE_ANY:
1532 break;
1533 default:
1534 dprintk("%s: invalid iomode %d\n", __func__,
1535 lrp->lr_seg.iomode);
1536 nfserr = nfserr_inval;
1537 goto out;
1540 switch (lrp->lr_return_type) {
1541 case RETURN_FILE:
1542 nfserr = nfsd4_return_file_layouts(rqstp, cstate, lrp);
1543 break;
1544 case RETURN_FSID:
1545 case RETURN_ALL:
1546 nfserr = nfsd4_return_client_layouts(rqstp, cstate, lrp);
1547 break;
1548 default:
1549 dprintk("%s: invalid return_type %d\n", __func__,
1550 lrp->lr_return_type);
1551 nfserr = nfserr_inval;
1552 break;
1554 out:
1555 return nfserr;
1557 #endif /* CONFIG_NFSD_PNFS */
1560 * NULL call.
1562 static __be32
1563 nfsd4_proc_null(struct svc_rqst *rqstp)
1565 return nfs_ok;
1568 static inline void nfsd4_increment_op_stats(u32 opnum)
1570 if (opnum >= FIRST_NFS4_OP && opnum <= LAST_NFS4_OP)
1571 nfsdstats.nfs4_opcount[opnum]++;
1574 static const struct nfsd4_operation nfsd4_ops[];
1576 static const char *nfsd4_op_name(unsigned opnum);
1579 * Enforce NFSv4.1 COMPOUND ordering rules:
1581 * Also note, enforced elsewhere:
1582 * - SEQUENCE other than as first op results in
1583 * NFS4ERR_SEQUENCE_POS. (Enforced in nfsd4_sequence().)
1584 * - BIND_CONN_TO_SESSION must be the only op in its compound.
1585 * (Enforced in nfsd4_bind_conn_to_session().)
1586 * - DESTROY_SESSION must be the final operation in a compound, if
1587 * sessionid's in SEQUENCE and DESTROY_SESSION are the same.
1588 * (Enforced in nfsd4_destroy_session().)
1590 static __be32 nfs41_check_op_ordering(struct nfsd4_compoundargs *args)
1592 struct nfsd4_op *first_op = &args->ops[0];
1594 /* These ordering requirements don't apply to NFSv4.0: */
1595 if (args->minorversion == 0)
1596 return nfs_ok;
1597 /* This is weird, but OK, not our problem: */
1598 if (args->opcnt == 0)
1599 return nfs_ok;
1600 if (first_op->status == nfserr_op_illegal)
1601 return nfs_ok;
1602 if (!(nfsd4_ops[first_op->opnum].op_flags & ALLOWED_AS_FIRST_OP))
1603 return nfserr_op_not_in_session;
1604 if (first_op->opnum == OP_SEQUENCE)
1605 return nfs_ok;
1607 * So first_op is something allowed outside a session, like
1608 * EXCHANGE_ID; but then it has to be the only op in the
1609 * compound:
1611 if (args->opcnt != 1)
1612 return nfserr_not_only_op;
1613 return nfs_ok;
1616 const struct nfsd4_operation *OPDESC(struct nfsd4_op *op)
1618 return &nfsd4_ops[op->opnum];
1621 bool nfsd4_cache_this_op(struct nfsd4_op *op)
1623 if (op->opnum == OP_ILLEGAL)
1624 return false;
1625 return OPDESC(op)->op_flags & OP_CACHEME;
1628 static bool need_wrongsec_check(struct svc_rqst *rqstp)
1630 struct nfsd4_compoundres *resp = rqstp->rq_resp;
1631 struct nfsd4_compoundargs *argp = rqstp->rq_argp;
1632 struct nfsd4_op *this = &argp->ops[resp->opcnt - 1];
1633 struct nfsd4_op *next = &argp->ops[resp->opcnt];
1634 const struct nfsd4_operation *thisd = OPDESC(this);
1635 const struct nfsd4_operation *nextd;
1638 * Most ops check wronsec on our own; only the putfh-like ops
1639 * have special rules.
1641 if (!(thisd->op_flags & OP_IS_PUTFH_LIKE))
1642 return false;
1644 * rfc 5661 2.6.3.1.1.6: don't bother erroring out a
1645 * put-filehandle operation if we're not going to use the
1646 * result:
1648 if (argp->opcnt == resp->opcnt)
1649 return false;
1650 if (next->opnum == OP_ILLEGAL)
1651 return false;
1652 nextd = OPDESC(next);
1654 * Rest of 2.6.3.1.1: certain operations will return WRONGSEC
1655 * errors themselves as necessary; others should check for them
1656 * now:
1658 return !(nextd->op_flags & OP_HANDLES_WRONGSEC);
1661 static void svcxdr_init_encode(struct svc_rqst *rqstp,
1662 struct nfsd4_compoundres *resp)
1664 struct xdr_stream *xdr = &resp->xdr;
1665 struct xdr_buf *buf = &rqstp->rq_res;
1666 struct kvec *head = buf->head;
1668 xdr->buf = buf;
1669 xdr->iov = head;
1670 xdr->p = head->iov_base + head->iov_len;
1671 xdr->end = head->iov_base + PAGE_SIZE - rqstp->rq_auth_slack;
1672 /* Tail and page_len should be zero at this point: */
1673 buf->len = buf->head[0].iov_len;
1674 xdr->scratch.iov_len = 0;
1675 xdr->page_ptr = buf->pages - 1;
1676 buf->buflen = PAGE_SIZE * (1 + rqstp->rq_page_end - buf->pages)
1677 - rqstp->rq_auth_slack;
1681 * COMPOUND call.
1683 static __be32
1684 nfsd4_proc_compound(struct svc_rqst *rqstp)
1686 struct nfsd4_compoundargs *args = rqstp->rq_argp;
1687 struct nfsd4_compoundres *resp = rqstp->rq_resp;
1688 struct nfsd4_op *op;
1689 struct nfsd4_compound_state *cstate = &resp->cstate;
1690 struct svc_fh *current_fh = &cstate->current_fh;
1691 struct svc_fh *save_fh = &cstate->save_fh;
1692 __be32 status;
1694 svcxdr_init_encode(rqstp, resp);
1695 resp->tagp = resp->xdr.p;
1696 /* reserve space for: taglen, tag, and opcnt */
1697 xdr_reserve_space(&resp->xdr, 8 + args->taglen);
1698 resp->taglen = args->taglen;
1699 resp->tag = args->tag;
1700 resp->rqstp = rqstp;
1701 cstate->minorversion = args->minorversion;
1702 fh_init(current_fh, NFS4_FHSIZE);
1703 fh_init(save_fh, NFS4_FHSIZE);
1705 * Don't use the deferral mechanism for NFSv4; compounds make it
1706 * too hard to avoid non-idempotency problems.
1708 clear_bit(RQ_USEDEFERRAL, &rqstp->rq_flags);
1711 * According to RFC3010, this takes precedence over all other errors.
1713 status = nfserr_minor_vers_mismatch;
1714 if (nfsd_minorversion(args->minorversion, NFSD_TEST) <= 0)
1715 goto out;
1716 status = nfserr_resource;
1717 if (args->opcnt > NFSD_MAX_OPS_PER_COMPOUND)
1718 goto out;
1720 status = nfs41_check_op_ordering(args);
1721 if (status) {
1722 op = &args->ops[0];
1723 op->status = status;
1724 resp->opcnt = 1;
1725 goto encode_op;
1728 trace_nfsd_compound(rqstp, args->opcnt);
1729 while (!status && resp->opcnt < args->opcnt) {
1730 op = &args->ops[resp->opcnt++];
1733 * The XDR decode routines may have pre-set op->status;
1734 * for example, if there is a miscellaneous XDR error
1735 * it will be set to nfserr_bad_xdr.
1737 if (op->status) {
1738 if (op->opnum == OP_OPEN)
1739 op->status = nfsd4_open_omfg(rqstp, cstate, op);
1740 goto encode_op;
1743 if (!current_fh->fh_dentry) {
1744 if (!(op->opdesc->op_flags & ALLOWED_WITHOUT_FH)) {
1745 op->status = nfserr_nofilehandle;
1746 goto encode_op;
1748 } else if (current_fh->fh_export->ex_fslocs.migrated &&
1749 !(op->opdesc->op_flags & ALLOWED_ON_ABSENT_FS)) {
1750 op->status = nfserr_moved;
1751 goto encode_op;
1754 fh_clear_wcc(current_fh);
1756 /* If op is non-idempotent */
1757 if (op->opdesc->op_flags & OP_MODIFIES_SOMETHING) {
1759 * Don't execute this op if we couldn't encode a
1760 * succesful reply:
1762 u32 plen = op->opdesc->op_rsize_bop(rqstp, op);
1764 * Plus if there's another operation, make sure
1765 * we'll have space to at least encode an error:
1767 if (resp->opcnt < args->opcnt)
1768 plen += COMPOUND_ERR_SLACK_SPACE;
1769 op->status = nfsd4_check_resp_size(resp, plen);
1772 if (op->status)
1773 goto encode_op;
1775 if (op->opdesc->op_get_currentstateid)
1776 op->opdesc->op_get_currentstateid(cstate, &op->u);
1777 op->status = op->opdesc->op_func(rqstp, cstate, &op->u);
1779 /* Only from SEQUENCE */
1780 if (cstate->status == nfserr_replay_cache) {
1781 dprintk("%s NFS4.1 replay from cache\n", __func__);
1782 status = op->status;
1783 goto out;
1785 if (!op->status) {
1786 if (op->opdesc->op_set_currentstateid)
1787 op->opdesc->op_set_currentstateid(cstate, &op->u);
1789 if (op->opdesc->op_flags & OP_CLEAR_STATEID)
1790 clear_current_stateid(cstate);
1792 if (need_wrongsec_check(rqstp))
1793 op->status = check_nfsd_access(current_fh->fh_export, rqstp);
1795 encode_op:
1796 if (op->status == nfserr_replay_me) {
1797 op->replay = &cstate->replay_owner->so_replay;
1798 nfsd4_encode_replay(&resp->xdr, op);
1799 status = op->status = op->replay->rp_status;
1800 } else {
1801 nfsd4_encode_operation(resp, op);
1802 status = op->status;
1805 trace_nfsd_compound_status(args->opcnt, resp->opcnt, status,
1806 nfsd4_op_name(op->opnum));
1808 nfsd4_cstate_clear_replay(cstate);
1809 nfsd4_increment_op_stats(op->opnum);
1812 cstate->status = status;
1813 fh_put(current_fh);
1814 fh_put(save_fh);
1815 BUG_ON(cstate->replay_owner);
1816 out:
1817 /* Reset deferral mechanism for RPC deferrals */
1818 set_bit(RQ_USEDEFERRAL, &rqstp->rq_flags);
1819 dprintk("nfsv4 compound returned %d\n", ntohl(status));
1820 return status;
1823 #define op_encode_hdr_size (2)
1824 #define op_encode_stateid_maxsz (XDR_QUADLEN(NFS4_STATEID_SIZE))
1825 #define op_encode_verifier_maxsz (XDR_QUADLEN(NFS4_VERIFIER_SIZE))
1826 #define op_encode_change_info_maxsz (5)
1827 #define nfs4_fattr_bitmap_maxsz (4)
1829 /* We'll fall back on returning no lockowner if run out of space: */
1830 #define op_encode_lockowner_maxsz (0)
1831 #define op_encode_lock_denied_maxsz (8 + op_encode_lockowner_maxsz)
1833 #define nfs4_owner_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
1835 #define op_encode_ace_maxsz (3 + nfs4_owner_maxsz)
1836 #define op_encode_delegation_maxsz (1 + op_encode_stateid_maxsz + 1 + \
1837 op_encode_ace_maxsz)
1839 #define op_encode_channel_attrs_maxsz (6 + 1 + 1)
1841 static inline u32 nfsd4_only_status_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1843 return (op_encode_hdr_size) * sizeof(__be32);
1846 static inline u32 nfsd4_status_stateid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1848 return (op_encode_hdr_size + op_encode_stateid_maxsz)* sizeof(__be32);
1851 static inline u32 nfsd4_access_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1853 /* ac_supported, ac_resp_access */
1854 return (op_encode_hdr_size + 2)* sizeof(__be32);
1857 static inline u32 nfsd4_commit_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1859 return (op_encode_hdr_size + op_encode_verifier_maxsz) * sizeof(__be32);
1862 static inline u32 nfsd4_create_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1864 return (op_encode_hdr_size + op_encode_change_info_maxsz
1865 + nfs4_fattr_bitmap_maxsz) * sizeof(__be32);
1869 * Note since this is an idempotent operation we won't insist on failing
1870 * the op prematurely if the estimate is too large. We may turn off splice
1871 * reads unnecessarily.
1873 static inline u32 nfsd4_getattr_rsize(struct svc_rqst *rqstp,
1874 struct nfsd4_op *op)
1876 u32 *bmap = op->u.getattr.ga_bmval;
1877 u32 bmap0 = bmap[0], bmap1 = bmap[1], bmap2 = bmap[2];
1878 u32 ret = 0;
1880 if (bmap0 & FATTR4_WORD0_ACL)
1881 return svc_max_payload(rqstp);
1882 if (bmap0 & FATTR4_WORD0_FS_LOCATIONS)
1883 return svc_max_payload(rqstp);
1885 if (bmap1 & FATTR4_WORD1_OWNER) {
1886 ret += IDMAP_NAMESZ + 4;
1887 bmap1 &= ~FATTR4_WORD1_OWNER;
1889 if (bmap1 & FATTR4_WORD1_OWNER_GROUP) {
1890 ret += IDMAP_NAMESZ + 4;
1891 bmap1 &= ~FATTR4_WORD1_OWNER_GROUP;
1893 if (bmap0 & FATTR4_WORD0_FILEHANDLE) {
1894 ret += NFS4_FHSIZE + 4;
1895 bmap0 &= ~FATTR4_WORD0_FILEHANDLE;
1897 if (bmap2 & FATTR4_WORD2_SECURITY_LABEL) {
1898 ret += NFS4_MAXLABELLEN + 12;
1899 bmap2 &= ~FATTR4_WORD2_SECURITY_LABEL;
1902 * Largest of remaining attributes are 16 bytes (e.g.,
1903 * supported_attributes)
1905 ret += 16 * (hweight32(bmap0) + hweight32(bmap1) + hweight32(bmap2));
1906 /* bitmask, length */
1907 ret += 20;
1908 return ret;
1911 static inline u32 nfsd4_getfh_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1913 return (op_encode_hdr_size + 1) * sizeof(__be32) + NFS4_FHSIZE;
1916 static inline u32 nfsd4_link_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1918 return (op_encode_hdr_size + op_encode_change_info_maxsz)
1919 * sizeof(__be32);
1922 static inline u32 nfsd4_lock_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1924 return (op_encode_hdr_size + op_encode_lock_denied_maxsz)
1925 * sizeof(__be32);
1928 static inline u32 nfsd4_open_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1930 return (op_encode_hdr_size + op_encode_stateid_maxsz
1931 + op_encode_change_info_maxsz + 1
1932 + nfs4_fattr_bitmap_maxsz
1933 + op_encode_delegation_maxsz) * sizeof(__be32);
1936 static inline u32 nfsd4_read_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1938 u32 maxcount = 0, rlen = 0;
1940 maxcount = svc_max_payload(rqstp);
1941 rlen = min(op->u.read.rd_length, maxcount);
1943 return (op_encode_hdr_size + 2 + XDR_QUADLEN(rlen)) * sizeof(__be32);
1946 static inline u32 nfsd4_readdir_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1948 u32 maxcount = 0, rlen = 0;
1950 maxcount = svc_max_payload(rqstp);
1951 rlen = min(op->u.readdir.rd_maxcount, maxcount);
1953 return (op_encode_hdr_size + op_encode_verifier_maxsz +
1954 XDR_QUADLEN(rlen)) * sizeof(__be32);
1957 static inline u32 nfsd4_readlink_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1959 return (op_encode_hdr_size + 1) * sizeof(__be32) + PAGE_SIZE;
1962 static inline u32 nfsd4_remove_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1964 return (op_encode_hdr_size + op_encode_change_info_maxsz)
1965 * sizeof(__be32);
1968 static inline u32 nfsd4_rename_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1970 return (op_encode_hdr_size + op_encode_change_info_maxsz
1971 + op_encode_change_info_maxsz) * sizeof(__be32);
1974 static inline u32 nfsd4_sequence_rsize(struct svc_rqst *rqstp,
1975 struct nfsd4_op *op)
1977 return (op_encode_hdr_size
1978 + XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + 5) * sizeof(__be32);
1981 static inline u32 nfsd4_test_stateid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1983 return (op_encode_hdr_size + 1 + op->u.test_stateid.ts_num_ids)
1984 * sizeof(__be32);
1987 static inline u32 nfsd4_setattr_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1989 return (op_encode_hdr_size + nfs4_fattr_bitmap_maxsz) * sizeof(__be32);
1992 static inline u32 nfsd4_secinfo_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
1994 return (op_encode_hdr_size + RPC_AUTH_MAXFLAVOR *
1995 (4 + XDR_QUADLEN(GSS_OID_MAX_LEN))) * sizeof(__be32);
1998 static inline u32 nfsd4_setclientid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2000 return (op_encode_hdr_size + 2 + XDR_QUADLEN(NFS4_VERIFIER_SIZE)) *
2001 sizeof(__be32);
2004 static inline u32 nfsd4_write_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2006 return (op_encode_hdr_size + 2 + op_encode_verifier_maxsz) * sizeof(__be32);
2009 static inline u32 nfsd4_exchange_id_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2011 return (op_encode_hdr_size + 2 + 1 + /* eir_clientid, eir_sequenceid */\
2012 1 + 1 + /* eir_flags, spr_how */\
2013 4 + /* spo_must_enforce & _allow with bitmap */\
2014 2 + /*eir_server_owner.so_minor_id */\
2015 /* eir_server_owner.so_major_id<> */\
2016 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\
2017 /* eir_server_scope<> */\
2018 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\
2019 1 + /* eir_server_impl_id array length */\
2020 0 /* ignored eir_server_impl_id contents */) * sizeof(__be32);
2023 static inline u32 nfsd4_bind_conn_to_session_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2025 return (op_encode_hdr_size + \
2026 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* bctsr_sessid */\
2027 2 /* bctsr_dir, use_conn_in_rdma_mode */) * sizeof(__be32);
2030 static inline u32 nfsd4_create_session_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2032 return (op_encode_hdr_size + \
2033 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* sessionid */\
2034 2 + /* csr_sequence, csr_flags */\
2035 op_encode_channel_attrs_maxsz + \
2036 op_encode_channel_attrs_maxsz) * sizeof(__be32);
2039 static inline u32 nfsd4_copy_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2041 return (op_encode_hdr_size +
2042 1 /* wr_callback */ +
2043 op_encode_stateid_maxsz /* wr_callback */ +
2044 2 /* wr_count */ +
2045 1 /* wr_committed */ +
2046 op_encode_verifier_maxsz +
2047 1 /* cr_consecutive */ +
2048 1 /* cr_synchronous */) * sizeof(__be32);
2051 #ifdef CONFIG_NFSD_PNFS
2052 static inline u32 nfsd4_getdeviceinfo_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2054 u32 maxcount = 0, rlen = 0;
2056 maxcount = svc_max_payload(rqstp);
2057 rlen = min(op->u.getdeviceinfo.gd_maxcount, maxcount);
2059 return (op_encode_hdr_size +
2060 1 /* gd_layout_type*/ +
2061 XDR_QUADLEN(rlen) +
2062 2 /* gd_notify_types */) * sizeof(__be32);
2066 * At this stage we don't really know what layout driver will handle the request,
2067 * so we need to define an arbitrary upper bound here.
2069 #define MAX_LAYOUT_SIZE 128
2070 static inline u32 nfsd4_layoutget_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2072 return (op_encode_hdr_size +
2073 1 /* logr_return_on_close */ +
2074 op_encode_stateid_maxsz +
2075 1 /* nr of layouts */ +
2076 MAX_LAYOUT_SIZE) * sizeof(__be32);
2079 static inline u32 nfsd4_layoutcommit_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2081 return (op_encode_hdr_size +
2082 1 /* locr_newsize */ +
2083 2 /* ns_size */) * sizeof(__be32);
2086 static inline u32 nfsd4_layoutreturn_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2088 return (op_encode_hdr_size +
2089 1 /* lrs_stateid */ +
2090 op_encode_stateid_maxsz) * sizeof(__be32);
2092 #endif /* CONFIG_NFSD_PNFS */
2095 static inline u32 nfsd4_seek_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2097 return (op_encode_hdr_size + 3) * sizeof(__be32);
2100 static const struct nfsd4_operation nfsd4_ops[] = {
2101 [OP_ACCESS] = {
2102 .op_func = nfsd4_access,
2103 .op_name = "OP_ACCESS",
2104 .op_rsize_bop = nfsd4_access_rsize,
2106 [OP_CLOSE] = {
2107 .op_func = nfsd4_close,
2108 .op_flags = OP_MODIFIES_SOMETHING,
2109 .op_name = "OP_CLOSE",
2110 .op_rsize_bop = nfsd4_status_stateid_rsize,
2111 .op_get_currentstateid = nfsd4_get_closestateid,
2112 .op_set_currentstateid = nfsd4_set_closestateid,
2114 [OP_COMMIT] = {
2115 .op_func = nfsd4_commit,
2116 .op_flags = OP_MODIFIES_SOMETHING,
2117 .op_name = "OP_COMMIT",
2118 .op_rsize_bop = nfsd4_commit_rsize,
2120 [OP_CREATE] = {
2121 .op_func = nfsd4_create,
2122 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME | OP_CLEAR_STATEID,
2123 .op_name = "OP_CREATE",
2124 .op_rsize_bop = nfsd4_create_rsize,
2126 [OP_DELEGRETURN] = {
2127 .op_func = nfsd4_delegreturn,
2128 .op_flags = OP_MODIFIES_SOMETHING,
2129 .op_name = "OP_DELEGRETURN",
2130 .op_rsize_bop = nfsd4_only_status_rsize,
2131 .op_get_currentstateid = nfsd4_get_delegreturnstateid,
2133 [OP_GETATTR] = {
2134 .op_func = nfsd4_getattr,
2135 .op_flags = ALLOWED_ON_ABSENT_FS,
2136 .op_rsize_bop = nfsd4_getattr_rsize,
2137 .op_name = "OP_GETATTR",
2139 [OP_GETFH] = {
2140 .op_func = nfsd4_getfh,
2141 .op_name = "OP_GETFH",
2142 .op_rsize_bop = nfsd4_getfh_rsize,
2144 [OP_LINK] = {
2145 .op_func = nfsd4_link,
2146 .op_flags = ALLOWED_ON_ABSENT_FS | OP_MODIFIES_SOMETHING
2147 | OP_CACHEME,
2148 .op_name = "OP_LINK",
2149 .op_rsize_bop = nfsd4_link_rsize,
2151 [OP_LOCK] = {
2152 .op_func = nfsd4_lock,
2153 .op_flags = OP_MODIFIES_SOMETHING |
2154 OP_NONTRIVIAL_ERROR_ENCODE,
2155 .op_name = "OP_LOCK",
2156 .op_rsize_bop = nfsd4_lock_rsize,
2157 .op_set_currentstateid = nfsd4_set_lockstateid,
2159 [OP_LOCKT] = {
2160 .op_func = nfsd4_lockt,
2161 .op_flags = OP_NONTRIVIAL_ERROR_ENCODE,
2162 .op_name = "OP_LOCKT",
2163 .op_rsize_bop = nfsd4_lock_rsize,
2165 [OP_LOCKU] = {
2166 .op_func = nfsd4_locku,
2167 .op_flags = OP_MODIFIES_SOMETHING,
2168 .op_name = "OP_LOCKU",
2169 .op_rsize_bop = nfsd4_status_stateid_rsize,
2170 .op_get_currentstateid = nfsd4_get_lockustateid,
2172 [OP_LOOKUP] = {
2173 .op_func = nfsd4_lookup,
2174 .op_flags = OP_HANDLES_WRONGSEC | OP_CLEAR_STATEID,
2175 .op_name = "OP_LOOKUP",
2176 .op_rsize_bop = nfsd4_only_status_rsize,
2178 [OP_LOOKUPP] = {
2179 .op_func = nfsd4_lookupp,
2180 .op_flags = OP_HANDLES_WRONGSEC | OP_CLEAR_STATEID,
2181 .op_name = "OP_LOOKUPP",
2182 .op_rsize_bop = nfsd4_only_status_rsize,
2184 [OP_NVERIFY] = {
2185 .op_func = nfsd4_nverify,
2186 .op_name = "OP_NVERIFY",
2187 .op_rsize_bop = nfsd4_only_status_rsize,
2189 [OP_OPEN] = {
2190 .op_func = nfsd4_open,
2191 .op_flags = OP_HANDLES_WRONGSEC | OP_MODIFIES_SOMETHING,
2192 .op_name = "OP_OPEN",
2193 .op_rsize_bop = nfsd4_open_rsize,
2194 .op_set_currentstateid = nfsd4_set_openstateid,
2196 [OP_OPEN_CONFIRM] = {
2197 .op_func = nfsd4_open_confirm,
2198 .op_flags = OP_MODIFIES_SOMETHING,
2199 .op_name = "OP_OPEN_CONFIRM",
2200 .op_rsize_bop = nfsd4_status_stateid_rsize,
2202 [OP_OPEN_DOWNGRADE] = {
2203 .op_func = nfsd4_open_downgrade,
2204 .op_flags = OP_MODIFIES_SOMETHING,
2205 .op_name = "OP_OPEN_DOWNGRADE",
2206 .op_rsize_bop = nfsd4_status_stateid_rsize,
2207 .op_get_currentstateid = nfsd4_get_opendowngradestateid,
2208 .op_set_currentstateid = nfsd4_set_opendowngradestateid,
2210 [OP_PUTFH] = {
2211 .op_func = nfsd4_putfh,
2212 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2213 | OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID,
2214 .op_name = "OP_PUTFH",
2215 .op_rsize_bop = nfsd4_only_status_rsize,
2217 [OP_PUTPUBFH] = {
2218 .op_func = nfsd4_putrootfh,
2219 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2220 | OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID,
2221 .op_name = "OP_PUTPUBFH",
2222 .op_rsize_bop = nfsd4_only_status_rsize,
2224 [OP_PUTROOTFH] = {
2225 .op_func = nfsd4_putrootfh,
2226 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2227 | OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID,
2228 .op_name = "OP_PUTROOTFH",
2229 .op_rsize_bop = nfsd4_only_status_rsize,
2231 [OP_READ] = {
2232 .op_func = nfsd4_read,
2233 .op_release = nfsd4_read_release,
2234 .op_name = "OP_READ",
2235 .op_rsize_bop = nfsd4_read_rsize,
2236 .op_get_currentstateid = nfsd4_get_readstateid,
2238 [OP_READDIR] = {
2239 .op_func = nfsd4_readdir,
2240 .op_name = "OP_READDIR",
2241 .op_rsize_bop = nfsd4_readdir_rsize,
2243 [OP_READLINK] = {
2244 .op_func = nfsd4_readlink,
2245 .op_name = "OP_READLINK",
2246 .op_rsize_bop = nfsd4_readlink_rsize,
2248 [OP_REMOVE] = {
2249 .op_func = nfsd4_remove,
2250 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
2251 .op_name = "OP_REMOVE",
2252 .op_rsize_bop = nfsd4_remove_rsize,
2254 [OP_RENAME] = {
2255 .op_func = nfsd4_rename,
2256 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
2257 .op_name = "OP_RENAME",
2258 .op_rsize_bop = nfsd4_rename_rsize,
2260 [OP_RENEW] = {
2261 .op_func = nfsd4_renew,
2262 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2263 | OP_MODIFIES_SOMETHING,
2264 .op_name = "OP_RENEW",
2265 .op_rsize_bop = nfsd4_only_status_rsize,
2268 [OP_RESTOREFH] = {
2269 .op_func = nfsd4_restorefh,
2270 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2271 | OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING,
2272 .op_name = "OP_RESTOREFH",
2273 .op_rsize_bop = nfsd4_only_status_rsize,
2275 [OP_SAVEFH] = {
2276 .op_func = nfsd4_savefh,
2277 .op_flags = OP_HANDLES_WRONGSEC | OP_MODIFIES_SOMETHING,
2278 .op_name = "OP_SAVEFH",
2279 .op_rsize_bop = nfsd4_only_status_rsize,
2281 [OP_SECINFO] = {
2282 .op_func = nfsd4_secinfo,
2283 .op_release = nfsd4_secinfo_release,
2284 .op_flags = OP_HANDLES_WRONGSEC,
2285 .op_name = "OP_SECINFO",
2286 .op_rsize_bop = nfsd4_secinfo_rsize,
2288 [OP_SETATTR] = {
2289 .op_func = nfsd4_setattr,
2290 .op_name = "OP_SETATTR",
2291 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME
2292 | OP_NONTRIVIAL_ERROR_ENCODE,
2293 .op_rsize_bop = nfsd4_setattr_rsize,
2294 .op_get_currentstateid = nfsd4_get_setattrstateid,
2296 [OP_SETCLIENTID] = {
2297 .op_func = nfsd4_setclientid,
2298 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2299 | OP_MODIFIES_SOMETHING | OP_CACHEME
2300 | OP_NONTRIVIAL_ERROR_ENCODE,
2301 .op_name = "OP_SETCLIENTID",
2302 .op_rsize_bop = nfsd4_setclientid_rsize,
2304 [OP_SETCLIENTID_CONFIRM] = {
2305 .op_func = nfsd4_setclientid_confirm,
2306 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2307 | OP_MODIFIES_SOMETHING | OP_CACHEME,
2308 .op_name = "OP_SETCLIENTID_CONFIRM",
2309 .op_rsize_bop = nfsd4_only_status_rsize,
2311 [OP_VERIFY] = {
2312 .op_func = nfsd4_verify,
2313 .op_name = "OP_VERIFY",
2314 .op_rsize_bop = nfsd4_only_status_rsize,
2316 [OP_WRITE] = {
2317 .op_func = nfsd4_write,
2318 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
2319 .op_name = "OP_WRITE",
2320 .op_rsize_bop = nfsd4_write_rsize,
2321 .op_get_currentstateid = nfsd4_get_writestateid,
2323 [OP_RELEASE_LOCKOWNER] = {
2324 .op_func = nfsd4_release_lockowner,
2325 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2326 | OP_MODIFIES_SOMETHING,
2327 .op_name = "OP_RELEASE_LOCKOWNER",
2328 .op_rsize_bop = nfsd4_only_status_rsize,
2331 /* NFSv4.1 operations */
2332 [OP_EXCHANGE_ID] = {
2333 .op_func = nfsd4_exchange_id,
2334 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
2335 | OP_MODIFIES_SOMETHING,
2336 .op_name = "OP_EXCHANGE_ID",
2337 .op_rsize_bop = nfsd4_exchange_id_rsize,
2339 [OP_BACKCHANNEL_CTL] = {
2340 .op_func = nfsd4_backchannel_ctl,
2341 .op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING,
2342 .op_name = "OP_BACKCHANNEL_CTL",
2343 .op_rsize_bop = nfsd4_only_status_rsize,
2345 [OP_BIND_CONN_TO_SESSION] = {
2346 .op_func = nfsd4_bind_conn_to_session,
2347 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
2348 | OP_MODIFIES_SOMETHING,
2349 .op_name = "OP_BIND_CONN_TO_SESSION",
2350 .op_rsize_bop = nfsd4_bind_conn_to_session_rsize,
2352 [OP_CREATE_SESSION] = {
2353 .op_func = nfsd4_create_session,
2354 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
2355 | OP_MODIFIES_SOMETHING,
2356 .op_name = "OP_CREATE_SESSION",
2357 .op_rsize_bop = nfsd4_create_session_rsize,
2359 [OP_DESTROY_SESSION] = {
2360 .op_func = nfsd4_destroy_session,
2361 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
2362 | OP_MODIFIES_SOMETHING,
2363 .op_name = "OP_DESTROY_SESSION",
2364 .op_rsize_bop = nfsd4_only_status_rsize,
2366 [OP_SEQUENCE] = {
2367 .op_func = nfsd4_sequence,
2368 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP,
2369 .op_name = "OP_SEQUENCE",
2370 .op_rsize_bop = nfsd4_sequence_rsize,
2372 [OP_DESTROY_CLIENTID] = {
2373 .op_func = nfsd4_destroy_clientid,
2374 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
2375 | OP_MODIFIES_SOMETHING,
2376 .op_name = "OP_DESTROY_CLIENTID",
2377 .op_rsize_bop = nfsd4_only_status_rsize,
2379 [OP_RECLAIM_COMPLETE] = {
2380 .op_func = nfsd4_reclaim_complete,
2381 .op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING,
2382 .op_name = "OP_RECLAIM_COMPLETE",
2383 .op_rsize_bop = nfsd4_only_status_rsize,
2385 [OP_SECINFO_NO_NAME] = {
2386 .op_func = nfsd4_secinfo_no_name,
2387 .op_release = nfsd4_secinfo_no_name_release,
2388 .op_flags = OP_HANDLES_WRONGSEC,
2389 .op_name = "OP_SECINFO_NO_NAME",
2390 .op_rsize_bop = nfsd4_secinfo_rsize,
2392 [OP_TEST_STATEID] = {
2393 .op_func = nfsd4_test_stateid,
2394 .op_flags = ALLOWED_WITHOUT_FH,
2395 .op_name = "OP_TEST_STATEID",
2396 .op_rsize_bop = nfsd4_test_stateid_rsize,
2398 [OP_FREE_STATEID] = {
2399 .op_func = nfsd4_free_stateid,
2400 .op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING,
2401 .op_name = "OP_FREE_STATEID",
2402 .op_get_currentstateid = nfsd4_get_freestateid,
2403 .op_rsize_bop = nfsd4_only_status_rsize,
2405 #ifdef CONFIG_NFSD_PNFS
2406 [OP_GETDEVICEINFO] = {
2407 .op_func = nfsd4_getdeviceinfo,
2408 .op_release = nfsd4_getdeviceinfo_release,
2409 .op_flags = ALLOWED_WITHOUT_FH,
2410 .op_name = "OP_GETDEVICEINFO",
2411 .op_rsize_bop = nfsd4_getdeviceinfo_rsize,
2413 [OP_LAYOUTGET] = {
2414 .op_func = nfsd4_layoutget,
2415 .op_release = nfsd4_layoutget_release,
2416 .op_flags = OP_MODIFIES_SOMETHING,
2417 .op_name = "OP_LAYOUTGET",
2418 .op_rsize_bop = nfsd4_layoutget_rsize,
2420 [OP_LAYOUTCOMMIT] = {
2421 .op_func = nfsd4_layoutcommit,
2422 .op_flags = OP_MODIFIES_SOMETHING,
2423 .op_name = "OP_LAYOUTCOMMIT",
2424 .op_rsize_bop = nfsd4_layoutcommit_rsize,
2426 [OP_LAYOUTRETURN] = {
2427 .op_func = nfsd4_layoutreturn,
2428 .op_flags = OP_MODIFIES_SOMETHING,
2429 .op_name = "OP_LAYOUTRETURN",
2430 .op_rsize_bop = nfsd4_layoutreturn_rsize,
2432 #endif /* CONFIG_NFSD_PNFS */
2434 /* NFSv4.2 operations */
2435 [OP_ALLOCATE] = {
2436 .op_func = nfsd4_allocate,
2437 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
2438 .op_name = "OP_ALLOCATE",
2439 .op_rsize_bop = nfsd4_only_status_rsize,
2441 [OP_DEALLOCATE] = {
2442 .op_func = nfsd4_deallocate,
2443 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
2444 .op_name = "OP_DEALLOCATE",
2445 .op_rsize_bop = nfsd4_only_status_rsize,
2447 [OP_CLONE] = {
2448 .op_func = nfsd4_clone,
2449 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
2450 .op_name = "OP_CLONE",
2451 .op_rsize_bop = nfsd4_only_status_rsize,
2453 [OP_COPY] = {
2454 .op_func = nfsd4_copy,
2455 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
2456 .op_name = "OP_COPY",
2457 .op_rsize_bop = nfsd4_copy_rsize,
2459 [OP_SEEK] = {
2460 .op_func = nfsd4_seek,
2461 .op_name = "OP_SEEK",
2462 .op_rsize_bop = nfsd4_seek_rsize,
2467 * nfsd4_spo_must_allow - Determine if the compound op contains an
2468 * operation that is allowed to be sent with machine credentials
2470 * @rqstp: a pointer to the struct svc_rqst
2472 * Checks to see if the compound contains a spo_must_allow op
2473 * and confirms that it was sent with the proper machine creds.
2476 bool nfsd4_spo_must_allow(struct svc_rqst *rqstp)
2478 struct nfsd4_compoundres *resp = rqstp->rq_resp;
2479 struct nfsd4_compoundargs *argp = rqstp->rq_argp;
2480 struct nfsd4_op *this = &argp->ops[resp->opcnt - 1];
2481 struct nfsd4_compound_state *cstate = &resp->cstate;
2482 struct nfs4_op_map *allow = &cstate->clp->cl_spo_must_allow;
2483 u32 opiter;
2485 if (!cstate->minorversion)
2486 return false;
2488 if (cstate->spo_must_allowed == true)
2489 return true;
2491 opiter = resp->opcnt;
2492 while (opiter < argp->opcnt) {
2493 this = &argp->ops[opiter++];
2494 if (test_bit(this->opnum, allow->u.longs) &&
2495 cstate->clp->cl_mach_cred &&
2496 nfsd4_mach_creds_match(cstate->clp, rqstp)) {
2497 cstate->spo_must_allowed = true;
2498 return true;
2501 cstate->spo_must_allowed = false;
2502 return false;
2505 int nfsd4_max_reply(struct svc_rqst *rqstp, struct nfsd4_op *op)
2507 if (op->opnum == OP_ILLEGAL || op->status == nfserr_notsupp)
2508 return op_encode_hdr_size * sizeof(__be32);
2510 BUG_ON(OPDESC(op)->op_rsize_bop == NULL);
2511 return OPDESC(op)->op_rsize_bop(rqstp, op);
2514 void warn_on_nonidempotent_op(struct nfsd4_op *op)
2516 if (OPDESC(op)->op_flags & OP_MODIFIES_SOMETHING) {
2517 pr_err("unable to encode reply to nonidempotent op %d (%s)\n",
2518 op->opnum, nfsd4_op_name(op->opnum));
2519 WARN_ON_ONCE(1);
2523 static const char *nfsd4_op_name(unsigned opnum)
2525 if (opnum < ARRAY_SIZE(nfsd4_ops))
2526 return nfsd4_ops[opnum].op_name;
2527 return "unknown_operation";
2530 #define nfsd4_voidres nfsd4_voidargs
2531 struct nfsd4_voidargs { int dummy; };
2533 static const struct svc_procedure nfsd_procedures4[2] = {
2534 [NFSPROC4_NULL] = {
2535 .pc_func = nfsd4_proc_null,
2536 .pc_encode = nfs4svc_encode_voidres,
2537 .pc_argsize = sizeof(struct nfsd4_voidargs),
2538 .pc_ressize = sizeof(struct nfsd4_voidres),
2539 .pc_cachetype = RC_NOCACHE,
2540 .pc_xdrressize = 1,
2542 [NFSPROC4_COMPOUND] = {
2543 .pc_func = nfsd4_proc_compound,
2544 .pc_decode = nfs4svc_decode_compoundargs,
2545 .pc_encode = nfs4svc_encode_compoundres,
2546 .pc_argsize = sizeof(struct nfsd4_compoundargs),
2547 .pc_ressize = sizeof(struct nfsd4_compoundres),
2548 .pc_release = nfsd4_release_compoundargs,
2549 .pc_cachetype = RC_NOCACHE,
2550 .pc_xdrressize = NFSD_BUFSIZE/4,
2554 static unsigned int nfsd_count3[ARRAY_SIZE(nfsd_procedures4)];
2555 const struct svc_version nfsd_version4 = {
2556 .vs_vers = 4,
2557 .vs_nproc = 2,
2558 .vs_proc = nfsd_procedures4,
2559 .vs_count = nfsd_count3,
2560 .vs_dispatch = nfsd_dispatch,
2561 .vs_xdrsize = NFS4_SVC_XDRSIZE,
2562 .vs_rpcb_optnl = true,
2563 .vs_need_cong_ctrl = true,
2567 * Local variables:
2568 * c-basic-offset: 8
2569 * End: