]> git.ipfire.org Git - people/ms/linux.git/blame - fs/nfsd/nfs4proc.c
projects / people / ms / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
nfsd: simplify nfsd4_check_open_reclaim
[people/ms/linux.git] / fs / nfsd / nfs4proc.c
CommitLineData
1da177e4 1/*
1da177e4
LT		 2 * Server-side procedures for NFSv4.
3 *
4 * Copyright (c) 2002 The Regents of the University of Michigan.
5 * All rights reserved.
6 *
7 * Kendrick Smith <kmsmith@umich.edu>
8 * Andy Adamson <andros@umich.edu>
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 *
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.
22 *
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.
1da177e4 34 */
880a3a53 35#include <linux/fs_struct.h>
7e06b7f9 36#include <linux/file.h>
b0cb9085 37#include <linux/falloc.h>
5a0e3ad6 38#include <linux/slab.h>
e0639dc5 39#include <linux/kthread.h>
624322f1 40#include <linux/sunrpc/addr.h>
0cfcd405 41#include <linux/nfs_ssc.h>
1da177e4 42
58e7b33a 43#include "idmap.h"
9a74af21
BH		 44#include "cache.h"
45#include "xdr4.h"
0a3adade 46#include "vfs.h"
8b70484c 47#include "current_stateid.h"
3320fef1 48#include "netns.h"
4ac7249e 49#include "acl.h"
9cf514cc 50#include "pnfs.h"
31ef83dc 51#include "trace.h"
1da177e4 52
d6c9e436
CL		 53static bool inter_copy_offload_enable;
54module_param(inter_copy_offload_enable, bool, 0644);
55MODULE_PARM_DESC(inter_copy_offload_enable,
56 "Enable inter server to server copy offload. Default: false");
57
18032ca0
DQ		 58#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
59#include <linux/security.h>
60
61static inline void
62nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct xdr_netobj *label, u32 *bmval)
63{
2b0143b5 64 struct inode *inode = d_inode(resfh->fh_dentry);
18032ca0
DQ		 65 int status;
66
5955102c 67 inode_lock(inode);
18032ca0
DQ		 68 status = security_inode_setsecctx(resfh->fh_dentry,
69 label->data, label->len);
5955102c 70 inode_unlock(inode);
18032ca0
DQ		 71
72 if (status)
73 /*
74 * XXX: We should really fail the whole open, but we may
75 * already have created a new file, so it may be too
76 * late. For now this seems the least of evils:
77 */
78 bmval[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
79
80 return;
81}
82#else
83static inline void
84nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct xdr_netobj *label, u32 *bmval)
85{ }
86#endif
87
1da177e4
LT		 88#define NFSDDBG_FACILITY NFSDDBG_PROC
89
3c8e0316
YZ		 90static u32 nfsd_attrmask[] = {
91 NFSD_WRITEABLE_ATTRS_WORD0,
92 NFSD_WRITEABLE_ATTRS_WORD1,
93 NFSD_WRITEABLE_ATTRS_WORD2
94};
95
96static u32 nfsd41_ex_attrmask[] = {
97 NFSD_SUPPATTR_EXCLCREAT_WORD0,
98 NFSD_SUPPATTR_EXCLCREAT_WORD1,
99 NFSD_SUPPATTR_EXCLCREAT_WORD2
100};
101
102static __be32
103check_attr_support(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
104 u32 *bmval, u32 *writable)
105{
106 struct dentry *dentry = cstate->current_fh.fh_dentry;
32ddd944 107 struct svc_export *exp = cstate->current_fh.fh_export;
3c8e0316 108
916d2d84 109 if (!nfsd_attrs_supported(cstate->minorversion, bmval))
3c8e0316 110 return nfserr_attrnotsupp;
916d2d84
BF		 111 if ((bmval[0] & FATTR4_WORD0_ACL) && !IS_POSIXACL(d_inode(dentry)))
112 return nfserr_attrnotsupp;
32ddd944
BF		 113 if ((bmval[2] & FATTR4_WORD2_SECURITY_LABEL) &&
114 !(exp->ex_flags & NFSEXP_SECURITY_LABEL))
115 return nfserr_attrnotsupp;
916d2d84
BF		 116 if (writable && !bmval_is_subset(bmval, writable))
117 return nfserr_inval;
47057abd
AG		 118 if (writable && (bmval[2] & FATTR4_WORD2_MODE_UMASK) &&
119 (bmval[1] & FATTR4_WORD1_MODE))
120 return nfserr_inval;
3c8e0316
YZ		 121 return nfs_ok;
122}
123
124static __be32
125nfsd4_check_open_attributes(struct svc_rqst *rqstp,
126 struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
127{
128 __be32 status = nfs_ok;
129
130 if (open->op_create == NFS4_OPEN_CREATE) {
131 if (open->op_createmode == NFS4_CREATE_UNCHECKED
132 || open->op_createmode == NFS4_CREATE_GUARDED)
133 status = check_attr_support(rqstp, cstate,
134 open->op_bmval, nfsd_attrmask);
135 else if (open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1)
136 status = check_attr_support(rqstp, cstate,
137 open->op_bmval, nfsd41_ex_attrmask);
138 }
139
140 return status;
141}
142
9208faf2
YZ		 143static int
144is_create_with_attrs(struct nfsd4_open *open)
145{
146 return open->op_create == NFS4_OPEN_CREATE
147 && (open->op_createmode == NFS4_CREATE_UNCHECKED
148 || open->op_createmode == NFS4_CREATE_GUARDED
149 || open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1);
150}
151
152/*
153 * if error occurs when setting the acl, just clear the acl bit
154 * in the returned attr bitmap.
155 */
156static void
157do_set_nfs4_acl(struct svc_rqst *rqstp, struct svc_fh *fhp,
158 struct nfs4_acl *acl, u32 *bmval)
159{
160 __be32 status;
161
162 status = nfsd4_set_nfs4_acl(rqstp, fhp, acl);
163 if (status)
164 /*
165 * We should probably fail the whole open at this point,
166 * but we've already created the file, so it's too late;
167 * So this seems the least of evils:
168 */
169 bmval[0] &= ~FATTR4_WORD0_ACL;
170}
171
1da177e4
LT		 172static inline void
173fh_dup2(struct svc_fh *dst, struct svc_fh *src)
174{
175 fh_put(dst);
176 dget(src->fh_dentry);
177 if (src->fh_export)
bf18f163 178 exp_get(src->fh_export);
1da177e4
LT		 179 *dst = *src;
180}
181
b37ad28b 182static __be32
dc730e17 183do_open_permission(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open, int accmode)
1da177e4 184{
b37ad28b 185 __be32 status;
1da177e4
LT		 186
187 if (open->op_truncate &&
188 !(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
189 return nfserr_inval;
190
a043226b
BF		 191 accmode |= NFSD_MAY_READ_IF_EXEC;
192
1da177e4 193 if (open->op_share_access & NFS4_SHARE_ACCESS_READ)
8837abca 194 accmode |= NFSD_MAY_READ;
9801d8a3 195 if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
8837abca 196 accmode |= (NFSD_MAY_WRITE | NFSD_MAY_TRUNC);
57ecb34f 197 if (open->op_share_deny & NFS4_SHARE_DENY_READ)
8837abca 198 accmode |= NFSD_MAY_WRITE;
1da177e4
LT		 199
200 status = fh_verify(rqstp, current_fh, S_IFREG, accmode);
201
202 return status;
203}
204
aadab6c6
BF		 205static __be32 nfsd_check_obj_isreg(struct svc_fh *fh)
206{
2b0143b5 207 umode_t mode = d_inode(fh->fh_dentry)->i_mode;
aadab6c6
BF		 208
209 if (S_ISREG(mode))
210 return nfs_ok;
211 if (S_ISDIR(mode))
212 return nfserr_isdir;
213 /*
214 * Using err_symlink as our catch-all case may look odd; but
215 * there's no other obvious error for this case in 4.0, and we
216 * happen to know that it will cause the linux v4 client to do
217 * the right thing on attempts to open something other than a
218 * regular file.
219 */
220 return nfserr_symlink;
221}
222
bbc9c36c
BF		 223static void nfsd4_set_open_owner_reply_cache(struct nfsd4_compound_state *cstate, struct nfsd4_open *open, struct svc_fh *resfh)
224{
225 if (nfsd4_has_session(cstate))
226 return;
227 fh_copy_shallow(&open->op_openowner->oo_owner.so_replay.rp_openfh,
228 &resfh->fh_handle);
229}
230
b37ad28b 231static __be32
c0e6bee4 232do_open_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_open *open, struct svc_fh **resfh)
1da177e4 233{
bbc9c36c 234 struct svc_fh *current_fh = &cstate->current_fh;
7007c90f 235 int accmode;
b37ad28b 236 __be32 status;
1da177e4 237
c0e6bee4
BF		 238 *resfh = kmalloc(sizeof(struct svc_fh), GFP_KERNEL);
239 if (!*resfh)
59deeb9e 240 return nfserr_jukebox;
c0e6bee4 241 fh_init(*resfh, NFS4_FHSIZE);
500c2481 242 open->op_truncate = false;
1da177e4
LT		 243
244 if (open->op_create) {
79fb54ab
BH		 245 /* FIXME: check session persistence and pnfs flags.
246 * The nfsv4.1 spec requires the following semantics:
247 *
248 * Persistent | pNFS | Server REQUIRED | Client Allowed
249 * Reply Cache | server | |
250 * -------------+--------+-----------------+--------------------
251 * no | no | EXCLUSIVE4_1 | EXCLUSIVE4_1
252 * | | | (SHOULD)
253 * | | and EXCLUSIVE4 | or EXCLUSIVE4
254 * | | | (SHOULD NOT)
255 * no | yes | EXCLUSIVE4_1 | EXCLUSIVE4_1
256 * yes | no | GUARDED4 | GUARDED4
257 * yes | yes | GUARDED4 | GUARDED4
258 */
259
1da177e4
LT		 260 /*
261 * Note: create modes (UNCHECKED,GUARDED...) are the same
ac6721a1 262 * in NFSv4 as in v3 except EXCLUSIVE4_1.
1da177e4 263 */
880a3a53 264 current->fs->umask = open->op_umask;
1708e50b
CL		 265 status = do_nfsd_create(rqstp, current_fh, open->op_fname,
266 open->op_fnamelen, &open->op_iattr,
c0e6bee4 267 *resfh, open->op_createmode,
749997e5 268 (u32 *)open->op_verf.data,
856121b2 269 &open->op_truncate, &open->op_created);
880a3a53 270 current->fs->umask = 0;
749997e5 271
18032ca0 272 if (!status && open->op_label.len)
c0e6bee4 273 nfsd4_security_inode_setsecctx(*resfh, &open->op_label, open->op_bmval);
18032ca0 274
99f88726 275 /*
ead8fb8c
KM		 276 * Following rfc 3530 14.2.16, and rfc 5661 18.16.4
277 * use the returned bitmask to indicate which attributes
278 * we used to store the verifier:
749997e5 279 */
ead8fb8c
KM		 280 if (nfsd_create_is_exclusive(open->op_createmode) && status == 0)
281 open->op_bmval[1] |= (FATTR4_WORD1_TIME_ACCESS |
282 FATTR4_WORD1_TIME_MODIFY);
4335723e
BF		 283 } else
284 /*
285 * Note this may exit with the parent still locked.
286 * We will hold the lock until nfsd4_open's final
287 * lookup, to prevent renames or unlinks until we've had
288 * a chance to an acquire a delegation if appropriate.
289 */
1da177e4 290 status = nfsd_lookup(rqstp, current_fh,
1708e50b 291 open->op_fname, open->op_fnamelen, *resfh);
9dc4e6c4
BF		 292 if (status)
293 goto out;
c0e6bee4 294 status = nfsd_check_obj_isreg(*resfh);
af85852d
BF		 295 if (status)
296 goto out;
1da177e4 297
9208faf2 298 if (is_create_with_attrs(open) && open->op_acl != NULL)
c0e6bee4 299 do_set_nfs4_acl(rqstp, *resfh, open->op_acl, open->op_bmval);
9208faf2 300
c0e6bee4 301 nfsd4_set_open_owner_reply_cache(cstate, open, *resfh);
7007c90f 302 accmode = NFSD_MAY_NOP;
89f6c336
BF		 303 if (open->op_created ||
304 open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR)
7007c90f 305 accmode |= NFSD_MAY_OWNER_OVERRIDE;
c0e6bee4 306 status = do_open_permission(rqstp, *resfh, open, accmode);
41fd1e42 307 set_change_info(&open->op_cinfo, current_fh);
af85852d 308out:
1da177e4
LT		 309 return status;
310}
311
b37ad28b 312static __be32
bbc9c36c 313do_open_fhandle(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
1da177e4 314{
bbc9c36c 315 struct svc_fh *current_fh = &cstate->current_fh;
b37ad28b 316 __be32 status;
9f415eb2 317 int accmode = 0;
1da177e4 318
1da177e4
LT		 319 /* We don't know the target directory, and therefore can not
320 * set the change info
321 */
322
323 memset(&open->op_cinfo, 0, sizeof(struct nfsd4_change_info));
324
bbc9c36c 325 nfsd4_set_open_owner_reply_cache(cstate, open, current_fh);
1da177e4
LT		 326
327 open->op_truncate = (open->op_iattr.ia_valid & ATTR_SIZE) &&
328 (open->op_iattr.ia_size == 0);
9f415eb2
BF		 329 /*
330 * In the delegation case, the client is telling us about an
331 * open that it *already* performed locally, some time ago. We
332 * should let it succeed now if possible.
333 *
334 * In the case of a CLAIM_FH open, on the other hand, the client
335 * may be counting on us to enforce permissions (the Linux 4.1
336 * client uses this for normal opens, for example).
337 */
338 if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH)
339 accmode = NFSD_MAY_OWNER_OVERRIDE;
1da177e4 340
9f415eb2 341 status = do_open_permission(rqstp, current_fh, open, accmode);
1da177e4
LT		 342
343 return status;
344}
345
60adfc50
AA		 346static void
347copy_clientid(clientid_t *clid, struct nfsd4_session *session)
348{
349 struct nfsd4_sessionid *sid =
350 (struct nfsd4_sessionid *)session->se_sessionid.data;
351
352 clid->cl_boot = sid->clientid.cl_boot;
353 clid->cl_id = sid->clientid.cl_id;
354}
1da177e4 355
7191155b 356static __be32
ca364317 357nfsd4_open(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 358 union nfsd4_op_u *u)
1da177e4 359{
eb69853d 360 struct nfsd4_open *open = &u->open;
b37ad28b 361 __be32 status;
c0e6bee4 362 struct svc_fh *resfh = NULL;
3320fef1
SK		 363 struct net *net = SVC_NET(rqstp);
364 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
03f318ca 365 bool reclaim = false;
6668958f 366
fe0750e5 367 dprintk("NFSD: nfsd4_open filename %.*s op_openowner %p\n",
1708e50b 368 (int)open->op_fnamelen, open->op_fname,
fe0750e5 369 open->op_openowner);
1da177e4 370
1da177e4
LT		 371 /* This check required by spec. */
372 if (open->op_create && open->op_claim_type != NFS4_OPEN_CLAIM_NULL)
373 return nfserr_inval;
374
500c2481 375 open->op_created = false;
ab1350b2
MJ		 376 /*
377 * RFC5661 18.51.3
378 * Before RECLAIM_COMPLETE done, server should deny new lock
379 */
380 if (nfsd4_has_session(cstate) &&
a52d726b
JL		 381 !test_bit(NFSD4_CLIENT_RECLAIM_COMPLETE,
382 &cstate->session->se_client->cl_flags) &&
ab1350b2
MJ		 383 open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS)
384 return nfserr_grace;
385
60adfc50
AA		 386 if (nfsd4_has_session(cstate))
387 copy_clientid(&open->op_clientid, cstate->session);
388
1da177e4 389 /* check seqid for replay. set nfs4_owner */
6cd22668 390 status = nfsd4_process_open1(cstate, open, nn);
a90b061c 391 if (status == nfserr_replay_me) {
fe0750e5 392 struct nfs4_replay *rp = &open->op_openowner->oo_owner.so_replay;
ca364317 393 fh_put(&cstate->current_fh);
a4773c08
BF		 394 fh_copy_shallow(&cstate->current_fh.fh_handle,
395 &rp->rp_openfh);
8837abca 396 status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
1da177e4
LT		 397 if (status)
398 dprintk("nfsd4_open: replay failed"
399 " restoring previous filehandle\n");
400 else
a90b061c 401 status = nfserr_replay_me;
1da177e4
LT		 402 }
403 if (status)
404 goto out;
9d313b17
BF		 405 if (open->op_xdr_error) {
406 status = open->op_xdr_error;
407 goto out;
408 }
fb553c0f 409
3c8e0316
YZ		 410 status = nfsd4_check_open_attributes(rqstp, cstate, open);
411 if (status)
412 goto out;
413
fb553c0f
BF		 414 /* Openowner is now set, so sequence id will get bumped. Now we need
415 * these checks before we do any creates: */
cbd0d51a 416 status = nfserr_grace;
c87fb4a3 417 if (opens_in_grace(net) && open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS)
cbd0d51a
BF		 418 goto out;
419 status = nfserr_no_grace;
c87fb4a3 420 if (!opens_in_grace(net) && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
cbd0d51a 421 goto out;
fb553c0f 422
1da177e4 423 switch (open->op_claim_type) {
0dd3c192 424 case NFS4_OPEN_CLAIM_DELEGATE_CUR:
1da177e4 425 case NFS4_OPEN_CLAIM_NULL:
c0e6bee4 426 status = do_open_lookup(rqstp, cstate, open, &resfh);
1da177e4
LT		 427 if (status)
428 goto out;
429 break;
430 case NFS4_OPEN_CLAIM_PREVIOUS:
1722b046 431 status = nfs4_check_open_reclaim(cstate->clp);
0cf99b91
MJ		 432 if (status)
433 goto out;
ba5378b6 434 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
03f318ca 435 reclaim = true;
df561f66 436 fallthrough;
8b289b2c
BF		 437 case NFS4_OPEN_CLAIM_FH:
438 case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
bbc9c36c 439 status = do_open_fhandle(rqstp, cstate, open);
1da177e4
LT		 440 if (status)
441 goto out;
c0e6bee4 442 resfh = &cstate->current_fh;
1da177e4 443 break;
8b289b2c 444 case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
1da177e4 445 case NFS4_OPEN_CLAIM_DELEGATE_PREV:
2fdada03 446 dprintk("NFSD: unsupported OPEN claim type %d\n",
1da177e4
LT		 447 open->op_claim_type);
448 status = nfserr_notsupp;
449 goto out;
450 default:
2fdada03 451 dprintk("NFSD: Invalid OPEN claim type %d\n",
1da177e4
LT		 452 open->op_claim_type);
453 status = nfserr_inval;
454 goto out;
455 }
456 /*
457 * nfsd4_process_open2() does the actual opening of the file. If
458 * successful, it (1) truncates the file if open->op_truncate was
459 * set, (2) sets open->op_stateid, (3) sets open->op_delegation.
460 */
c0e6bee4 461 status = nfsd4_process_open2(rqstp, resfh, open);
b3fbfe0e
JL		 462 WARN(status && open->op_created,
463 "nfsd4_process_open2 failed to open newly-created file! status=%u\n",
464 be32_to_cpu(status));
03f318ca
BF		 465 if (reclaim && !status)
466 nn->somebody_reclaimed = true;
1da177e4 467out:
c0e6bee4
BF		 468 if (resfh && resfh != &cstate->current_fh) {
469 fh_dup2(&cstate->current_fh, resfh);
470 fh_put(resfh);
471 kfree(resfh);
472 }
42297899 473 nfsd4_cleanup_open_state(cstate, open);
9411b1d4 474 nfsd4_bump_seqid(cstate, status);
1da177e4
LT		 475 return status;
476}
477
9d313b17
BF		 478/*
479 * OPEN is the only seqid-mutating operation whose decoding can fail
480 * with a seqid-mutating error (specifically, decoding of user names in
481 * the attributes). Therefore we have to do some processing to look up
482 * the stateowner so that we can bump the seqid.
483 */
484static __be32 nfsd4_open_omfg(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_op *op)
485{
eb69853d 486 struct nfsd4_open *open = &op->u.open;
9d313b17
BF		 487
488 if (!seqid_mutating_err(ntohl(op->status)))
489 return op->status;
490 if (nfsd4_has_session(cstate))
491 return op->status;
492 open->op_xdr_error = op->status;
eb69853d 493 return nfsd4_open(rqstp, cstate, &op->u);
9d313b17
BF		 494}
495
1da177e4
LT		 496/*
497 * filehandle-manipulating ops.
498 */
7191155b 499static __be32
b591480b 500nfsd4_getfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 501 union nfsd4_op_u *u)
1da177e4 502{
eb69853d 503 u->getfh = &cstate->current_fh;
1da177e4
LT		 504 return nfs_ok;
505}
506
7191155b 507static __be32
ca364317 508nfsd4_putfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 509 union nfsd4_op_u *u)
1da177e4 510{
eb69853d 511 struct nfsd4_putfh *putfh = &u->putfh;
b9e8638e 512 __be32 ret;
eb69853d 513
ca364317
BF		 514 fh_put(&cstate->current_fh);
515 cstate->current_fh.fh_handle.fh_size = putfh->pf_fhlen;
516 memcpy(&cstate->current_fh.fh_handle.fh_base, putfh->pf_fhval,
517 putfh->pf_fhlen);
b9e8638e
OK		 518 ret = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_BYPASS_GSS);
519#ifdef CONFIG_NFSD_V4_2_INTER_SSC
520 if (ret == nfserr_stale && putfh->no_verify) {
521 SET_FH_FLAG(&cstate->current_fh, NFSD4_FH_FOREIGN);
522 ret = 0;
523 }
524#endif
525 return ret;
1da177e4
LT		 526}
527
7191155b 528static __be32
b591480b 529nfsd4_putrootfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 530 union nfsd4_op_u *u)
1da177e4 531{
b37ad28b 532 __be32 status;
1da177e4 533
ca364317 534 fh_put(&cstate->current_fh);
df547efb 535 status = exp_pseudoroot(rqstp, &cstate->current_fh);
1da177e4
LT		 536 return status;
537}
538
7191155b 539static __be32
b591480b 540nfsd4_restorefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 541 union nfsd4_op_u *u)
1da177e4 542{
ca364317 543 if (!cstate->save_fh.fh_dentry)
1da177e4
LT		 544 return nfserr_restorefh;
545
ca364317 546 fh_dup2(&cstate->current_fh, &cstate->save_fh);
51100d2b 547 if (HAS_CSTATE_FLAG(cstate, SAVED_STATE_ID_FLAG)) {
37c593c5 548 memcpy(&cstate->current_stateid, &cstate->save_stateid, sizeof(stateid_t));
51100d2b 549 SET_CSTATE_FLAG(cstate, CURRENT_STATE_ID_FLAG);
37c593c5 550 }
1da177e4
LT		 551 return nfs_ok;
552}
553
7191155b 554static __be32
b591480b 555nfsd4_savefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 556 union nfsd4_op_u *u)
1da177e4 557{
ca364317 558 fh_dup2(&cstate->save_fh, &cstate->current_fh);
51100d2b 559 if (HAS_CSTATE_FLAG(cstate, CURRENT_STATE_ID_FLAG)) {
37c593c5 560 memcpy(&cstate->save_stateid, &cstate->current_stateid, sizeof(stateid_t));
51100d2b 561 SET_CSTATE_FLAG(cstate, SAVED_STATE_ID_FLAG);
37c593c5 562 }
1da177e4
LT		 563 return nfs_ok;
564}
565
566/*
567 * misc nfsv4 ops
568 */
7191155b 569static __be32
ca364317 570nfsd4_access(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 571 union nfsd4_op_u *u)
1da177e4 572{
eb69853d 573 struct nfsd4_access *access = &u->access;
c11d7fd1 574 u32 access_full;
eb69853d 575
c11d7fd1
FL		 576 access_full = NFS3_ACCESS_FULL;
577 if (cstate->minorversion >= 2)
578 access_full |= NFS4_ACCESS_XALIST | NFS4_ACCESS_XAREAD |
579 NFS4_ACCESS_XAWRITE;
580
581 if (access->ac_req_access & ~access_full)
1da177e4
LT		 582 return nfserr_inval;
583
584 access->ac_resp_access = access->ac_req_access;
ca364317
BF		 585 return nfsd_access(rqstp, &cstate->current_fh, &access->ac_resp_access,
586 &access->ac_supported);
1da177e4
LT		 587}
588
b9c0ef85 589static void gen_boot_verifier(nfs4_verifier *verifier, struct net *net)
ab4684d1 590{
27c438f5 591 __be32 *verf = (__be32 *)verifier->data;
ab4684d1 592
27c438f5
TM		 593 BUILD_BUG_ON(2*sizeof(*verf) != sizeof(verifier->data));
594
595 nfsd_copy_boot_verifier(verf, net_generic(net, nfsd_net_id));
ab4684d1
CL		 596}
597
7191155b 598static __be32
ca364317 599nfsd4_commit(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 600 union nfsd4_op_u *u)
1da177e4 601{
eb69853d
CH		 602 struct nfsd4_commit *commit = &u->commit;
603
75c096f7 604 return nfsd_commit(rqstp, &cstate->current_fh, commit->co_offset,
524ff1af
TM		 605 commit->co_count,
606 (__be32 *)commit->co_verf.data);
1da177e4
LT		 607}
608
b37ad28b 609static __be32
ca364317 610nfsd4_create(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 611 union nfsd4_op_u *u)
1da177e4 612{
eb69853d 613 struct nfsd4_create *create = &u->create;
1da177e4 614 struct svc_fh resfh;
b37ad28b 615 __be32 status;
1da177e4
LT		 616 dev_t rdev;
617
618 fh_init(&resfh, NFS4_FHSIZE);
619
fa08139d 620 status = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_NOP);
1da177e4
LT		 621 if (status)
622 return status;
623
3c8e0316
YZ		 624 status = check_attr_support(rqstp, cstate, create->cr_bmval,
625 nfsd_attrmask);
626 if (status)
627 return status;
628
880a3a53 629 current->fs->umask = create->cr_umask;
1da177e4
LT		 630 switch (create->cr_type) {
631 case NF4LNK:
ca364317
BF		 632 status = nfsd_symlink(rqstp, &cstate->current_fh,
633 create->cr_name, create->cr_namelen,
1e444f5b 634 create->cr_data, &resfh);
1da177e4
LT		 635 break;
636
637 case NF4BLK:
880a3a53 638 status = nfserr_inval;
1da177e4
LT		 639 rdev = MKDEV(create->cr_specdata1, create->cr_specdata2);
640 if (MAJOR(rdev) != create->cr_specdata1 ||
641 MINOR(rdev) != create->cr_specdata2)
880a3a53 642 goto out_umask;
ca364317
BF		 643 status = nfsd_create(rqstp, &cstate->current_fh,
644 create->cr_name, create->cr_namelen,
645 &create->cr_iattr, S_IFBLK, rdev, &resfh);
1da177e4
LT		 646 break;
647
648 case NF4CHR:
880a3a53 649 status = nfserr_inval;
1da177e4
LT		 650 rdev = MKDEV(create->cr_specdata1, create->cr_specdata2);
651 if (MAJOR(rdev) != create->cr_specdata1 ||
652 MINOR(rdev) != create->cr_specdata2)
880a3a53 653 goto out_umask;
ca364317
BF		 654 status = nfsd_create(rqstp, &cstate->current_fh,
655 create->cr_name, create->cr_namelen,
656 &create->cr_iattr,S_IFCHR, rdev, &resfh);
1da177e4
LT		 657 break;
658
659 case NF4SOCK:
ca364317
BF		 660 status = nfsd_create(rqstp, &cstate->current_fh,
661 create->cr_name, create->cr_namelen,
662 &create->cr_iattr, S_IFSOCK, 0, &resfh);
1da177e4
LT		 663 break;
664
665 case NF4FIFO:
ca364317
BF		 666 status = nfsd_create(rqstp, &cstate->current_fh,
667 create->cr_name, create->cr_namelen,
668 &create->cr_iattr, S_IFIFO, 0, &resfh);
1da177e4
LT		 669 break;
670
671 case NF4DIR:
672 create->cr_iattr.ia_valid &= ~ATTR_SIZE;
ca364317
BF		 673 status = nfsd_create(rqstp, &cstate->current_fh,
674 create->cr_name, create->cr_namelen,
675 &create->cr_iattr, S_IFDIR, 0, &resfh);
1da177e4
LT		 676 break;
677
678 default:
679 status = nfserr_badtype;
680 }
681
9208faf2
YZ		 682 if (status)
683 goto out;
1da177e4 684
18032ca0
DQ		 685 if (create->cr_label.len)
686 nfsd4_security_inode_setsecctx(&resfh, &create->cr_label, create->cr_bmval);
687
9208faf2
YZ		 688 if (create->cr_acl != NULL)
689 do_set_nfs4_acl(rqstp, &resfh, create->cr_acl,
690 create->cr_bmval);
691
692 fh_unlock(&cstate->current_fh);
693 set_change_info(&create->cr_cinfo, &cstate->current_fh);
694 fh_dup2(&cstate->current_fh, &resfh);
695out:
1da177e4 696 fh_put(&resfh);
880a3a53
BF		 697out_umask:
698 current->fs->umask = 0;
1da177e4
LT		 699 return status;
700}
701
7191155b 702static __be32
ca364317 703nfsd4_getattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 704 union nfsd4_op_u *u)
1da177e4 705{
eb69853d 706 struct nfsd4_getattr *getattr = &u->getattr;
b37ad28b 707 __be32 status;
1da177e4 708
8837abca 709 status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
1da177e4
LT		 710 if (status)
711 return status;
712
713 if (getattr->ga_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)
714 return nfserr_inval;
715
916d2d84
BF		 716 getattr->ga_bmval[0] &= nfsd_suppattrs[cstate->minorversion][0];
717 getattr->ga_bmval[1] &= nfsd_suppattrs[cstate->minorversion][1];
718 getattr->ga_bmval[2] &= nfsd_suppattrs[cstate->minorversion][2];
1da177e4 719
ca364317 720 getattr->ga_fhp = &cstate->current_fh;
1da177e4
LT		 721 return nfs_ok;
722}
723
7191155b 724static __be32
ca364317 725nfsd4_link(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 726 union nfsd4_op_u *u)
1da177e4 727{
eb69853d 728 struct nfsd4_link *link = &u->link;
95424460 729 __be32 status;
1da177e4 730
ca364317
BF		 731 status = nfsd_link(rqstp, &cstate->current_fh,
732 link->li_name, link->li_namelen, &cstate->save_fh);
1da177e4 733 if (!status)
ca364317 734 set_change_info(&link->li_cinfo, &cstate->current_fh);
1da177e4
LT		 735 return status;
736}
737
0ff7ab46 738static __be32 nfsd4_do_lookupp(struct svc_rqst *rqstp, struct svc_fh *fh)
1da177e4
LT		 739{
740 struct svc_fh tmp_fh;
b37ad28b 741 __be32 ret;
1da177e4
LT		 742
743 fh_init(&tmp_fh, NFS4_FHSIZE);
df547efb
BF		 744 ret = exp_pseudoroot(rqstp, &tmp_fh);
745 if (ret)
1da177e4 746 return ret;
0ff7ab46 747 if (tmp_fh.fh_dentry == fh->fh_dentry) {
1da177e4
LT		 748 fh_put(&tmp_fh);
749 return nfserr_noent;
750 }
751 fh_put(&tmp_fh);
0ff7ab46
BF		 752 return nfsd_lookup(rqstp, fh, "..", 2, fh);
753}
754
755static __be32
756nfsd4_lookupp(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 757 union nfsd4_op_u *u)
0ff7ab46
BF		 758{
759 return nfsd4_do_lookupp(rqstp, &cstate->current_fh);
1da177e4
LT		 760}
761
7191155b 762static __be32
ca364317 763nfsd4_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 764 union nfsd4_op_u *u)
1da177e4 765{
ca364317 766 return nfsd_lookup(rqstp, &cstate->current_fh,
eb69853d 767 u->lookup.lo_name, u->lookup.lo_len,
ca364317 768 &cstate->current_fh);
1da177e4
LT		 769}
770
7191155b 771static __be32
ca364317 772nfsd4_read(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 773 union nfsd4_op_u *u)
1da177e4 774{
eb69853d 775 struct nfsd4_read *read = &u->read;
b37ad28b 776 __be32 status;
1da177e4 777
5c4583b2 778 read->rd_nf = NULL;
1da177e4
LT		 779 if (read->rd_offset >= OFFSET_MAX)
780 return nfserr_inval;
781
87c5942e
CL		 782 trace_nfsd_read_start(rqstp, &cstate->current_fh,
783 read->rd_offset, read->rd_length);
784
9b3234b9
BF		 785 /*
786 * If we do a zero copy read, then a client will see read data
787 * that reflects the state of the file *after* performing the
788 * following compound.
789 *
790 * To ensure proper ordering, we therefore turn off zero copy if
791 * the client wants us to do more in this compound:
792 */
793 if (!nfsd4_last_compound_op(rqstp))
779fb0f3 794 clear_bit(RQ_SPLICE_OK, &rqstp->rq_flags);
9b3234b9 795
1da177e4 796 /* check stateid */
aa0d6aed
AS		 797 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
798 &read->rd_stateid, RD_STATE,
624322f1 799 &read->rd_nf, NULL);
af90f707 800 if (status) {
1da177e4
LT		 801 dprintk("NFSD: nfsd4_read: couldn't process stateid!\n");
802 goto out;
803 }
804 status = nfs_ok;
805out:
1da177e4 806 read->rd_rqstp = rqstp;
ca364317 807 read->rd_fhp = &cstate->current_fh;
1da177e4
LT		 808 return status;
809}
810
34b1744c
BF		 811
812static void
813nfsd4_read_release(union nfsd4_op_u *u)
814{
5c4583b2
JL		 815 if (u->read.rd_nf)
816 nfsd_file_put(u->read.rd_nf);
87c5942e
CL		 817 trace_nfsd_read_done(u->read.rd_rqstp, u->read.rd_fhp,
818 u->read.rd_offset, u->read.rd_length);
34b1744c
BF		 819}
820
7191155b 821static __be32
ca364317 822nfsd4_readdir(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 823 union nfsd4_op_u *u)
1da177e4 824{
eb69853d 825 struct nfsd4_readdir *readdir = &u->readdir;
1da177e4
LT		 826 u64 cookie = readdir->rd_cookie;
827 static const nfs4_verifier zeroverf;
828
829 /* no need to check permission - this will be done in nfsd_readdir() */
830
831 if (readdir->rd_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)
832 return nfserr_inval;
833
916d2d84
BF		 834 readdir->rd_bmval[0] &= nfsd_suppattrs[cstate->minorversion][0];
835 readdir->rd_bmval[1] &= nfsd_suppattrs[cstate->minorversion][1];
836 readdir->rd_bmval[2] &= nfsd_suppattrs[cstate->minorversion][2];
1da177e4 837
832023bf 838 if ((cookie == 1) || (cookie == 2) ||
1da177e4
LT		 839 (cookie == 0 && memcmp(readdir->rd_verf.data, zeroverf.data, NFS4_VERIFIER_SIZE)))
840 return nfserr_bad_cookie;
841
842 readdir->rd_rqstp = rqstp;
ca364317 843 readdir->rd_fhp = &cstate->current_fh;
1da177e4
LT		 844 return nfs_ok;
845}
846
7191155b 847static __be32
ca364317 848nfsd4_readlink(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 849 union nfsd4_op_u *u)
1da177e4 850{
eb69853d
CH		 851 u->readlink.rl_rqstp = rqstp;
852 u->readlink.rl_fhp = &cstate->current_fh;
1da177e4
LT		 853 return nfs_ok;
854}
855
7191155b 856static __be32
ca364317 857nfsd4_remove(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 858 union nfsd4_op_u *u)
1da177e4 859{
eb69853d 860 struct nfsd4_remove *remove = &u->remove;
b37ad28b 861 __be32 status;
1da177e4 862
c87fb4a3 863 if (opens_in_grace(SVC_NET(rqstp)))
c815afc7 864 return nfserr_grace;
ca364317
BF		 865 status = nfsd_unlink(rqstp, &cstate->current_fh, 0,
866 remove->rm_name, remove->rm_namelen);
1da177e4 867 if (!status) {
ca364317
BF		 868 fh_unlock(&cstate->current_fh);
869 set_change_info(&remove->rm_cinfo, &cstate->current_fh);
1da177e4
LT		 870 }
871 return status;
872}
873
7191155b 874static __be32
ca364317 875nfsd4_rename(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 876 union nfsd4_op_u *u)
1da177e4 877{
eb69853d 878 struct nfsd4_rename *rename = &u->rename;
95424460 879 __be32 status;
1da177e4 880
f8f71d00 881 if (opens_in_grace(SVC_NET(rqstp)))
c815afc7 882 return nfserr_grace;
ca364317
BF		 883 status = nfsd_rename(rqstp, &cstate->save_fh, rename->rn_sname,
884 rename->rn_snamelen, &cstate->current_fh,
1da177e4 885 rename->rn_tname, rename->rn_tnamelen);
2a6cf944
BF		 886 if (status)
887 return status;
888 set_change_info(&rename->rn_sinfo, &cstate->current_fh);
889 set_change_info(&rename->rn_tinfo, &cstate->save_fh);
890 return nfs_ok;
1da177e4
LT		 891}
892
dcb488a3
AA		 893static __be32
894nfsd4_secinfo(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 895 union nfsd4_op_u *u)
dcb488a3 896{
eb69853d 897 struct nfsd4_secinfo *secinfo = &u->secinfo;
dcb488a3
AA		 898 struct svc_export *exp;
899 struct dentry *dentry;
900 __be32 err;
901
29a78a3e
BF		 902 err = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_EXEC);
903 if (err)
904 return err;
dcb488a3
AA		 905 err = nfsd_lookup_dentry(rqstp, &cstate->current_fh,
906 secinfo->si_name, secinfo->si_namelen,
907 &exp, &dentry);
908 if (err)
909 return err;
2f6fc056 910 fh_unlock(&cstate->current_fh);
2b0143b5 911 if (d_really_is_negative(dentry)) {
dcb488a3
AA		 912 exp_put(exp);
913 err = nfserr_noent;
914 } else
915 secinfo->si_exp = exp;
916 dput(dentry);
56560b9a
BF		 917 if (cstate->minorversion)
918 /* See rfc 5661 section 2.6.3.1.1.8 */
919 fh_put(&cstate->current_fh);
dcb488a3
AA		 920 return err;
921}
922
04f4ad16
BF		 923static __be32
924nfsd4_secinfo_no_name(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 925 union nfsd4_op_u *u)
04f4ad16
BF		 926{
927 __be32 err;
928
eb69853d 929 switch (u->secinfo_no_name.sin_style) {
04f4ad16
BF		 930 case NFS4_SECINFO_STYLE4_CURRENT_FH:
931 break;
932 case NFS4_SECINFO_STYLE4_PARENT:
933 err = nfsd4_do_lookupp(rqstp, &cstate->current_fh);
934 if (err)
935 return err;
936 break;
937 default:
938 return nfserr_inval;
939 }
bf18f163 940
eb69853d 941 u->secinfo_no_name.sin_exp = exp_get(cstate->current_fh.fh_export);
04f4ad16
BF		 942 fh_put(&cstate->current_fh);
943 return nfs_ok;
944}
945
34b1744c
BF		 946static void
947nfsd4_secinfo_release(union nfsd4_op_u *u)
948{
949 if (u->secinfo.si_exp)
950 exp_put(u->secinfo.si_exp);
951}
952
ec572b9e
EG		 953static void
954nfsd4_secinfo_no_name_release(union nfsd4_op_u *u)
955{
956 if (u->secinfo_no_name.sin_exp)
957 exp_put(u->secinfo_no_name.sin_exp);
958}
959
7191155b 960static __be32
ca364317 961nfsd4_setattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 962 union nfsd4_op_u *u)
1da177e4 963{
eb69853d 964 struct nfsd4_setattr *setattr = &u->setattr;
b37ad28b 965 __be32 status = nfs_ok;
96f6f985 966 int err;
1da177e4 967
1da177e4 968 if (setattr->sa_iattr.ia_valid & ATTR_SIZE) {
af90f707 969 status = nfs4_preprocess_stateid_op(rqstp, cstate,
aa0d6aed 970 &cstate->current_fh, &setattr->sa_stateid,
624322f1 971 WR_STATE, NULL, NULL);
375c5547 972 if (status) {
3e3b4800 973 dprintk("NFSD: nfsd4_setattr: couldn't process stateid!\n");
375c5547
BF		 974 return status;
975 }
1da177e4 976 }
96f6f985
AV		 977 err = fh_want_write(&cstate->current_fh);
978 if (err)
979 return nfserrno(err);
1da177e4 980 status = nfs_ok;
3c8e0316
YZ		 981
982 status = check_attr_support(rqstp, cstate, setattr->sa_bmval,
983 nfsd_attrmask);
984 if (status)
985 goto out;
986
1da177e4 987 if (setattr->sa_acl != NULL)
ca364317
BF		 988 status = nfsd4_set_nfs4_acl(rqstp, &cstate->current_fh,
989 setattr->sa_acl);
1da177e4 990 if (status)
18f335af 991 goto out;
18032ca0
DQ		 992 if (setattr->sa_label.len)
993 status = nfsd4_set_nfs4_label(rqstp, &cstate->current_fh,
994 &setattr->sa_label);
995 if (status)
996 goto out;
ca364317 997 status = nfsd_setattr(rqstp, &cstate->current_fh, &setattr->sa_iattr,
2a1aa489 998 0, (time64_t)0);
18f335af 999out:
bad0dcff 1000 fh_drop_write(&cstate->current_fh);
1da177e4
LT		 1001 return status;
1002}
1003
7191155b 1004static __be32
ca364317 1005nfsd4_write(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 1006 union nfsd4_op_u *u)
1da177e4 1007{
eb69853d 1008 struct nfsd4_write *write = &u->write;
1da177e4 1009 stateid_t *stateid = &write->wr_stateid;
5c4583b2 1010 struct nfsd_file *nf = NULL;
b37ad28b 1011 __be32 status = nfs_ok;
31dec253 1012 unsigned long cnt;
ffe1137b 1013 int nvecs;
1da177e4 1014
1da177e4
LT		 1015 if (write->wr_offset >= OFFSET_MAX)
1016 return nfserr_inval;
1017
d890be15
CL		 1018 cnt = write->wr_buflen;
1019 trace_nfsd_write_start(rqstp, &cstate->current_fh,
1020 write->wr_offset, cnt);
aa0d6aed 1021 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
624322f1 1022 stateid, WR_STATE, &nf, NULL);
375c5547
BF		 1023 if (status) {
1024 dprintk("NFSD: nfsd4_write: couldn't process stateid!\n");
1025 return status;
1026 }
1027
1da177e4 1028 write->wr_how_written = write->wr_stable_how;
1da177e4 1029
c1346a12
CL		 1030 nvecs = svc_fill_write_vector(rqstp, write->wr_payload.pages,
1031 write->wr_payload.head, write->wr_buflen);
ffe1137b
BF		 1032 WARN_ON_ONCE(nvecs > ARRAY_SIZE(rqstp->rq_vec));
1033
16f8f894 1034 status = nfsd_vfs_write(rqstp, &cstate->current_fh, nf,
af90f707 1035 write->wr_offset, rqstp->rq_vec, nvecs, &cnt,
19e0663f
TM		 1036 write->wr_how_written,
1037 (__be32 *)write->wr_verifier.data);
5c4583b2 1038 nfsd_file_put(nf);
1da177e4 1039
31dec253 1040 write->wr_bytes_written = cnt;
d890be15
CL		 1041 trace_nfsd_write_done(rqstp, &cstate->current_fh,
1042 write->wr_offset, cnt);
1da177e4 1043 return status;
1da177e4
LT		 1044}
1045
ffa0160a 1046static __be32
29ae7f9d 1047nfsd4_verify_copy(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
5c4583b2
JL		 1048 stateid_t *src_stateid, struct nfsd_file **src,
1049 stateid_t *dst_stateid, struct nfsd_file **dst)
ffa0160a 1050{
ffa0160a
CH		 1051 __be32 status;
1052
01310bb7
SM		 1053 if (!cstate->save_fh.fh_dentry)
1054 return nfserr_nofilehandle;
1055
ffa0160a 1056 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->save_fh,
624322f1 1057 src_stateid, RD_STATE, src, NULL);
ffa0160a
CH		 1058 if (status) {
1059 dprintk("NFSD: %s: couldn't process src stateid!\n", __func__);
1060 goto out;
1061 }
1062
1063 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
624322f1 1064 dst_stateid, WR_STATE, dst, NULL);
ffa0160a
CH		 1065 if (status) {
1066 dprintk("NFSD: %s: couldn't process dst stateid!\n", __func__);
1067 goto out_put_src;
1068 }
1069
1070 /* fix up for NFS-specific error code */
5c4583b2
JL		 1071 if (!S_ISREG(file_inode((*src)->nf_file)->i_mode) ||
1072 !S_ISREG(file_inode((*dst)->nf_file)->i_mode)) {
ffa0160a
CH		 1073 status = nfserr_wrong_type;
1074 goto out_put_dst;
1075 }
1076
29ae7f9d
AS		 1077out:
1078 return status;
1079out_put_dst:
5c4583b2 1080 nfsd_file_put(*dst);
29ae7f9d 1081out_put_src:
5c4583b2 1082 nfsd_file_put(*src);
29ae7f9d
AS		 1083 goto out;
1084}
1085
1086static __be32
1087nfsd4_clone(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 1088 union nfsd4_op_u *u)
29ae7f9d 1089{
eb69853d 1090 struct nfsd4_clone *clone = &u->clone;
5c4583b2 1091 struct nfsd_file *src, *dst;
29ae7f9d
AS		 1092 __be32 status;
1093
1094 status = nfsd4_verify_copy(rqstp, cstate, &clone->cl_src_stateid, &src,
1095 &clone->cl_dst_stateid, &dst);
1096 if (status)
1097 goto out;
1098
b66ae6dd
TM		 1099 status = nfsd4_clone_file_range(src, clone->cl_src_pos,
1100 dst, clone->cl_dst_pos, clone->cl_count,
a25e3726 1101 EX_ISSYNC(cstate->current_fh.fh_export));
ffa0160a 1102
5c4583b2
JL		 1103 nfsd_file_put(dst);
1104 nfsd_file_put(src);
ffa0160a
CH		 1105out:
1106 return status;
1107}
1108
e0639dc5
OK		 1109void nfs4_put_copy(struct nfsd4_copy *copy)
1110{
1111 if (!refcount_dec_and_test(&copy->refcount))
1112 return;
1113 kfree(copy);
1114}
1115
1116static bool
1117check_and_set_stop_copy(struct nfsd4_copy *copy)
1118{
1119 bool value;
1120
1121 spin_lock(&copy->cp_clp->async_lock);
1122 value = copy->stopped;
1123 if (!copy->stopped)
1124 copy->stopped = true;
1125 spin_unlock(&copy->cp_clp->async_lock);
1126 return value;
1127}
1128
1129static void nfsd4_stop_copy(struct nfsd4_copy *copy)
1130{
1131 /* only 1 thread should stop the copy */
1132 if (!check_and_set_stop_copy(copy))
1133 kthread_stop(copy->copy_task);
1134 nfs4_put_copy(copy);
1135}
1136
1137static struct nfsd4_copy *nfsd4_get_copy(struct nfs4_client *clp)
1138{
1139 struct nfsd4_copy *copy = NULL;
1140
1141 spin_lock(&clp->async_lock);
1142 if (!list_empty(&clp->async_copies)) {
1143 copy = list_first_entry(&clp->async_copies, struct nfsd4_copy,
1144 copies);
1145 refcount_inc(&copy->refcount);
1146 }
1147 spin_unlock(&clp->async_lock);
1148 return copy;
1149}
1150
1151void nfsd4_shutdown_copy(struct nfs4_client *clp)
1152{
1153 struct nfsd4_copy *copy;
1154
1155 while ((copy = nfsd4_get_copy(clp)) != NULL)
1156 nfsd4_stop_copy(copy);
1157}
ce0887ac
OK		 1158#ifdef CONFIG_NFSD_V4_2_INTER_SSC
1159
1160extern struct file *nfs42_ssc_open(struct vfsmount *ss_mnt,
1161 struct nfs_fh *src_fh,
1162 nfs4_stateid *stateid);
1163extern void nfs42_ssc_close(struct file *filep);
1164
1165extern void nfs_sb_deactive(struct super_block *sb);
1166
1167#define NFSD42_INTERSSC_MOUNTOPS "vers=4.2,addr=%s,sec=sys"
1168
f2453978 1169/*
ce0887ac
OK		 1170 * Support one copy source server for now.
1171 */
1172static __be32
1173nfsd4_interssc_connect(struct nl4_server *nss, struct svc_rqst *rqstp,
1174 struct vfsmount **mount)
1175{
1176 struct file_system_type *type;
1177 struct vfsmount *ss_mnt;
1178 struct nfs42_netaddr *naddr;
1179 struct sockaddr_storage tmp_addr;
1180 size_t tmp_addrlen, match_netid_len = 3;
1181 char *startsep = "", *endsep = "", *match_netid = "tcp";
1182 char *ipaddr, *dev_name, *raw_data;
b8290ca2
OK		 1183 int len, raw_len;
1184 __be32 status = nfserr_inval;
ce0887ac
OK		 1185
1186 naddr = &nss->u.nl4_addr;
1187 tmp_addrlen = rpc_uaddr2sockaddr(SVC_NET(rqstp), naddr->addr,
1188 naddr->addr_len,
1189 (struct sockaddr *)&tmp_addr,
1190 sizeof(tmp_addr));
1191 if (tmp_addrlen == 0)
1192 goto out_err;
1193
1194 if (tmp_addr.ss_family == AF_INET6) {
1195 startsep = "[";
1196 endsep = "]";
1197 match_netid = "tcp6";
1198 match_netid_len = 4;
1199 }
1200
1201 if (naddr->netid_len != match_netid_len ||
1202 strncmp(naddr->netid, match_netid, naddr->netid_len))
1203 goto out_err;
1204
1205 /* Construct the raw data for the vfs_kern_mount call */
1206 len = RPC_MAX_ADDRBUFLEN + 1;
1207 ipaddr = kzalloc(len, GFP_KERNEL);
1208 if (!ipaddr)
1209 goto out_err;
1210
1211 rpc_ntop((struct sockaddr *)&tmp_addr, ipaddr, len);
1212
1213 /* 2 for ipv6 endsep and startsep. 3 for ":/" and trailing '/0'*/
1214
1215 raw_len = strlen(NFSD42_INTERSSC_MOUNTOPS) + strlen(ipaddr);
1216 raw_data = kzalloc(raw_len, GFP_KERNEL);
1217 if (!raw_data)
1218 goto out_free_ipaddr;
1219
1220 snprintf(raw_data, raw_len, NFSD42_INTERSSC_MOUNTOPS, ipaddr);
1221
b8290ca2 1222 status = nfserr_nodev;
ce0887ac
OK		 1223 type = get_fs_type("nfs");
1224 if (!type)
1225 goto out_free_rawdata;
1226
1227 /* Set the server:<export> for the vfs_kern_mount call */
1228 dev_name = kzalloc(len + 5, GFP_KERNEL);
1229 if (!dev_name)
1230 goto out_free_rawdata;
1231 snprintf(dev_name, len + 5, "%s%s%s:/", startsep, ipaddr, endsep);
1232
1233 /* Use an 'internal' mount: SB_KERNMOUNT -> MNT_INTERNAL */
1234 ss_mnt = vfs_kern_mount(type, SB_KERNMOUNT, dev_name, raw_data);
1235 module_put(type->owner);
1236 if (IS_ERR(ss_mnt))
1237 goto out_free_devname;
1238
1239 status = 0;
1240 *mount = ss_mnt;
1241
1242out_free_devname:
1243 kfree(dev_name);
1244out_free_rawdata:
1245 kfree(raw_data);
1246out_free_ipaddr:
1247 kfree(ipaddr);
1248out_err:
1249 return status;
1250}
1251
1252static void
1253nfsd4_interssc_disconnect(struct vfsmount *ss_mnt)
1254{
0cfcd405 1255 nfs_do_sb_deactive(ss_mnt->mnt_sb);
ce0887ac
OK		 1256 mntput(ss_mnt);
1257}
1258
f2453978 1259/*
ce0887ac 1260 * Verify COPY destination stateid.
f2453978 1261 *
ce0887ac
OK		 1262 * Connect to the source server with NFSv4.1.
1263 * Create the source struct file for nfsd_copy_range.
1264 * Called with COPY cstate:
1265 * SAVED_FH: source filehandle
1266 * CURRENT_FH: destination filehandle
ce0887ac
OK		 1267 */
1268static __be32
1269nfsd4_setup_inter_ssc(struct svc_rqst *rqstp,
1270 struct nfsd4_compound_state *cstate,
1271 struct nfsd4_copy *copy, struct vfsmount **mount)
1272{
1273 struct svc_fh *s_fh = NULL;
1274 stateid_t *s_stid = &copy->cp_src_stateid;
b8290ca2 1275 __be32 status = nfserr_inval;
ce0887ac
OK		 1276
1277 /* Verify the destination stateid and set dst struct file*/
1278 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
1279 &copy->cp_dst_stateid,
1280 WR_STATE, &copy->nf_dst, NULL);
1281 if (status)
1282 goto out;
1283
1284 status = nfsd4_interssc_connect(&copy->cp_src, rqstp, mount);
1285 if (status)
1286 goto out;
1287
1288 s_fh = &cstate->save_fh;
1289
1290 copy->c_fh.size = s_fh->fh_handle.fh_size;
1291 memcpy(copy->c_fh.data, &s_fh->fh_handle.fh_base, copy->c_fh.size);
3f9544ca 1292 copy->stateid.seqid = cpu_to_be32(s_stid->si_generation);
ce0887ac
OK		 1293 memcpy(copy->stateid.other, (void *)&s_stid->si_opaque,
1294 sizeof(stateid_opaque_t));
1295
1296 status = 0;
1297out:
1298 return status;
1299}
1300
1301static void
1302nfsd4_cleanup_inter_ssc(struct vfsmount *ss_mnt, struct nfsd_file *src,
1303 struct nfsd_file *dst)
1304{
1305 nfs42_ssc_close(src->nf_file);
36e1e5ba 1306 /* 'src' is freed by nfsd4_do_async_copy */
ce0887ac
OK		 1307 nfsd_file_put(dst);
1308 mntput(ss_mnt);
1309}
1310
1311#else /* CONFIG_NFSD_V4_2_INTER_SSC */
1312
1313static __be32
1314nfsd4_setup_inter_ssc(struct svc_rqst *rqstp,
1315 struct nfsd4_compound_state *cstate,
1316 struct nfsd4_copy *copy,
1317 struct vfsmount **mount)
1318{
1319 *mount = NULL;
b8290ca2 1320 return nfserr_inval;
ce0887ac
OK		 1321}
1322
1323static void
1324nfsd4_cleanup_inter_ssc(struct vfsmount *ss_mnt, struct nfsd_file *src,
1325 struct nfsd_file *dst)
1326{
1327}
1328
1329static void
1330nfsd4_interssc_disconnect(struct vfsmount *ss_mnt)
1331{
1332}
1333
1334static struct file *nfs42_ssc_open(struct vfsmount *ss_mnt,
1335 struct nfs_fh *src_fh,
1336 nfs4_stateid *stateid)
1337{
1338 return NULL;
1339}
1340#endif /* CONFIG_NFSD_V4_2_INTER_SSC */
1341
1342static __be32
1343nfsd4_setup_intra_ssc(struct svc_rqst *rqstp,
1344 struct nfsd4_compound_state *cstate,
1345 struct nfsd4_copy *copy)
1346{
1347 return nfsd4_verify_copy(rqstp, cstate, &copy->cp_src_stateid,
1348 &copy->nf_src, &copy->cp_dst_stateid,
1349 &copy->nf_dst);
1350}
1351
1352static void
1353nfsd4_cleanup_intra_ssc(struct nfsd_file *src, struct nfsd_file *dst)
1354{
1355 nfsd_file_put(src);
1356 nfsd_file_put(dst);
1357}
e0639dc5
OK		 1358
1359static void nfsd4_cb_offload_release(struct nfsd4_callback *cb)
1360{
1361 struct nfsd4_copy *copy = container_of(cb, struct nfsd4_copy, cp_cb);
1362
1363 nfs4_put_copy(copy);
1364}
1365
1366static int nfsd4_cb_offload_done(struct nfsd4_callback *cb,
1367 struct rpc_task *task)
1368{
1369 return 1;
1370}
1371
1372static const struct nfsd4_callback_ops nfsd4_cb_offload_ops = {
1373 .release = nfsd4_cb_offload_release,
1374 .done = nfsd4_cb_offload_done
1375};
1376
1377static void nfsd4_init_copy_res(struct nfsd4_copy *copy, bool sync)
1378{
1379 copy->cp_res.wr_stable_how = NFS_UNSTABLE;
1380 copy->cp_synchronous = sync;
1381 gen_boot_verifier(&copy->cp_res.wr_verifier, copy->cp_clp->net);
1382}
1383
1384static ssize_t _nfsd_copy_file_range(struct nfsd4_copy *copy)
1385{
1386 ssize_t bytes_copied = 0;
1387 size_t bytes_total = copy->cp_count;
1388 u64 src_pos = copy->cp_src_pos;
1389 u64 dst_pos = copy->cp_dst_pos;
1390
1391 do {
1392 if (kthread_should_stop())
1393 break;
5c4583b2
JL		 1394 bytes_copied = nfsd_copy_file_range(copy->nf_src->nf_file,
1395 src_pos, copy->nf_dst->nf_file, dst_pos,
1396 bytes_total);
e0639dc5
OK		 1397 if (bytes_copied <= 0)
1398 break;
1399 bytes_total -= bytes_copied;
1400 copy->cp_res.wr_bytes_written += bytes_copied;
1401 src_pos += bytes_copied;
1402 dst_pos += bytes_copied;
1403 } while (bytes_total > 0 && !copy->cp_synchronous);
1404 return bytes_copied;
1405}
1406
1407static __be32 nfsd4_do_copy(struct nfsd4_copy *copy, bool sync)
1408{
1409 __be32 status;
1410 ssize_t bytes;
1411
1412 bytes = _nfsd_copy_file_range(copy);
1413 /* for async copy, we ignore the error, client can always retry
1414 * to get the error
1415 */
1416 if (bytes < 0 && !copy->cp_res.wr_bytes_written)
1417 status = nfserrno(bytes);
1418 else {
1419 nfsd4_init_copy_res(copy, sync);
1420 status = nfs_ok;
1421 }
1422
ce0887ac
OK		 1423 if (!copy->cp_intra) /* Inter server SSC */
1424 nfsd4_cleanup_inter_ssc(copy->ss_mnt, copy->nf_src,
1425 copy->nf_dst);
1426 else
1427 nfsd4_cleanup_intra_ssc(copy->nf_src, copy->nf_dst);
1428
e0639dc5
OK		 1429 return status;
1430}
1431
eb162e17 1432static void dup_copy_fields(struct nfsd4_copy *src, struct nfsd4_copy *dst)
e0639dc5
OK		 1433{
1434 dst->cp_src_pos = src->cp_src_pos;
1435 dst->cp_dst_pos = src->cp_dst_pos;
1436 dst->cp_count = src->cp_count;
1437 dst->cp_synchronous = src->cp_synchronous;
1438 memcpy(&dst->cp_res, &src->cp_res, sizeof(src->cp_res));
1439 memcpy(&dst->fh, &src->fh, sizeof(src->fh));
1440 dst->cp_clp = src->cp_clp;
5c4583b2 1441 dst->nf_dst = nfsd_file_get(src->nf_dst);
ce0887ac
OK		 1442 dst->cp_intra = src->cp_intra;
1443 if (src->cp_intra) /* for inter, file_src doesn't exist yet */
1444 dst->nf_src = nfsd_file_get(src->nf_src);
1445
e0639dc5 1446 memcpy(&dst->cp_stateid, &src->cp_stateid, sizeof(src->cp_stateid));
ce0887ac
OK		 1447 memcpy(&dst->cp_src, &src->cp_src, sizeof(struct nl4_server));
1448 memcpy(&dst->stateid, &src->stateid, sizeof(src->stateid));
1449 memcpy(&dst->c_fh, &src->c_fh, sizeof(src->c_fh));
1450 dst->ss_mnt = src->ss_mnt;
e0639dc5
OK		 1451}
1452
1453static void cleanup_async_copy(struct nfsd4_copy *copy)
1454{
624322f1 1455 nfs4_free_copy_state(copy);
5c4583b2 1456 nfsd_file_put(copy->nf_dst);
2e577f0f
OK		 1457 if (copy->cp_intra)
1458 nfsd_file_put(copy->nf_src);
e0639dc5
OK		 1459 spin_lock(&copy->cp_clp->async_lock);
1460 list_del(&copy->copies);
1461 spin_unlock(&copy->cp_clp->async_lock);
1462 nfs4_put_copy(copy);
1463}
1464
1465static int nfsd4_do_async_copy(void *data)
1466{
1467 struct nfsd4_copy *copy = (struct nfsd4_copy *)data;
1468 struct nfsd4_copy *cb_copy;
1469
ce0887ac
OK		 1470 if (!copy->cp_intra) { /* Inter server SSC */
1471 copy->nf_src = kzalloc(sizeof(struct nfsd_file), GFP_KERNEL);
1472 if (!copy->nf_src) {
1473 copy->nfserr = nfserr_serverfault;
1474 nfsd4_interssc_disconnect(copy->ss_mnt);
1475 goto do_callback;
1476 }
1477 copy->nf_src->nf_file = nfs42_ssc_open(copy->ss_mnt, &copy->c_fh,
1478 &copy->stateid);
1479 if (IS_ERR(copy->nf_src->nf_file)) {
ce0887ac
OK		 1480 copy->nfserr = nfserr_offload_denied;
1481 nfsd4_interssc_disconnect(copy->ss_mnt);
1482 goto do_callback;
1483 }
1484 }
1485
e0639dc5 1486 copy->nfserr = nfsd4_do_copy(copy, 0);
ce0887ac 1487do_callback:
e0639dc5
OK		 1488 cb_copy = kzalloc(sizeof(struct nfsd4_copy), GFP_KERNEL);
1489 if (!cb_copy)
1490 goto out;
49a36132 1491 refcount_set(&cb_copy->refcount, 1);
e0639dc5
OK		 1492 memcpy(&cb_copy->cp_res, &copy->cp_res, sizeof(copy->cp_res));
1493 cb_copy->cp_clp = copy->cp_clp;
1494 cb_copy->nfserr = copy->nfserr;
1495 memcpy(&cb_copy->fh, &copy->fh, sizeof(copy->fh));
1496 nfsd4_init_cb(&cb_copy->cp_cb, cb_copy->cp_clp,
1497 &nfsd4_cb_offload_ops, NFSPROC4_CLNT_CB_OFFLOAD);
1498 nfsd4_run_cb(&cb_copy->cp_cb);
1499out:
ce0887ac
OK		 1500 if (!copy->cp_intra)
1501 kfree(copy->nf_src);
e0639dc5
OK		 1502 cleanup_async_copy(copy);
1503 return 0;
1504}
1505
29ae7f9d
AS		 1506static __be32
1507nfsd4_copy(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 1508 union nfsd4_op_u *u)
29ae7f9d 1509{
eb69853d 1510 struct nfsd4_copy *copy = &u->copy;
29ae7f9d 1511 __be32 status;
e0639dc5 1512 struct nfsd4_copy *async_copy = NULL;
29ae7f9d 1513
ce0887ac
OK		 1514 if (!copy->cp_intra) { /* Inter server SSC */
1515 if (!inter_copy_offload_enable || copy->cp_synchronous) {
1516 status = nfserr_notsupp;
1517 goto out;
1518 }
1519 status = nfsd4_setup_inter_ssc(rqstp, cstate, copy,
1520 &copy->ss_mnt);
1521 if (status)
1522 return nfserr_offload_denied;
1523 } else {
1524 status = nfsd4_setup_intra_ssc(rqstp, cstate, copy);
1525 if (status)
1526 return status;
1527 }
29ae7f9d 1528
e0639dc5
OK		 1529 copy->cp_clp = cstate->clp;
1530 memcpy(&copy->fh, &cstate->current_fh.fh_handle,
1531 sizeof(struct knfsd_fh));
1532 if (!copy->cp_synchronous) {
1533 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
29ae7f9d 1534
e0639dc5
OK		 1535 status = nfserrno(-ENOMEM);
1536 async_copy = kzalloc(sizeof(struct nfsd4_copy), GFP_KERNEL);
1537 if (!async_copy)
ce0887ac
OK		 1538 goto out_err;
1539 if (!nfs4_init_copy_state(nn, copy))
1540 goto out_err;
e0639dc5
OK		 1541 refcount_set(&async_copy->refcount, 1);
1542 memcpy(&copy->cp_res.cb_stateid, &copy->cp_stateid,
1543 sizeof(copy->cp_stateid));
eb162e17 1544 dup_copy_fields(copy, async_copy);
e0639dc5
OK		 1545 async_copy->copy_task = kthread_create(nfsd4_do_async_copy,
1546 async_copy, "%s", "copy thread");
1547 if (IS_ERR(async_copy->copy_task))
1548 goto out_err;
1549 spin_lock(&async_copy->cp_clp->async_lock);
1550 list_add(&async_copy->copies,
1551 &async_copy->cp_clp->async_copies);
1552 spin_unlock(&async_copy->cp_clp->async_lock);
1553 wake_up_process(async_copy->copy_task);
29ae7f9d 1554 status = nfs_ok;
ce0887ac 1555 } else {
e0639dc5 1556 status = nfsd4_do_copy(copy, 1);
ce0887ac 1557 }
29ae7f9d
AS		 1558out:
1559 return status;
e0639dc5 1560out_err:
18f428d4
OK		 1561 if (async_copy)
1562 cleanup_async_copy(async_copy);
ce0887ac
OK		 1563 status = nfserrno(-ENOMEM);
1564 if (!copy->cp_intra)
1565 nfsd4_interssc_disconnect(copy->ss_mnt);
e0639dc5
OK		 1566 goto out;
1567}
1568
1569struct nfsd4_copy *
1570find_async_copy(struct nfs4_client *clp, stateid_t *stateid)
1571{
1572 struct nfsd4_copy *copy;
1573
1574 spin_lock(&clp->async_lock);
1575 list_for_each_entry(copy, &clp->async_copies, copies) {
ce0887ac 1576 if (memcmp(&copy->cp_stateid.stid, stateid, NFS4_STATEID_SIZE))
e0639dc5
OK		 1577 continue;
1578 refcount_inc(&copy->refcount);
1579 spin_unlock(&clp->async_lock);
1580 return copy;
1581 }
1582 spin_unlock(&clp->async_lock);
1583 return NULL;
29ae7f9d
AS		 1584}
1585
885e2bf3
OK		 1586static __be32
1587nfsd4_offload_cancel(struct svc_rqst *rqstp,
1588 struct nfsd4_compound_state *cstate,
1589 union nfsd4_op_u *u)
1590{
e0639dc5 1591 struct nfsd4_offload_status *os = &u->offload_status;
e0639dc5
OK		 1592 struct nfsd4_copy *copy;
1593 struct nfs4_client *clp = cstate->clp;
1594
1595 copy = find_async_copy(clp, &os->stateid);
ce0887ac
OK		 1596 if (!copy) {
1597 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
1598
1599 return manage_cpntf_state(nn, &os->stateid, clp, NULL);
1600 } else
e0639dc5 1601 nfsd4_stop_copy(copy);
e0639dc5 1602
ce0887ac 1603 return nfs_ok;
885e2bf3
OK		 1604}
1605
51911868
OK		 1606static __be32
1607nfsd4_copy_notify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1608 union nfsd4_op_u *u)
1609{
624322f1
OK		 1610 struct nfsd4_copy_notify *cn = &u->copy_notify;
1611 __be32 status;
1612 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
1613 struct nfs4_stid *stid;
1614 struct nfs4_cpntf_state *cps;
1615 struct nfs4_client *clp = cstate->clp;
1616
1617 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
1618 &cn->cpn_src_stateid, RD_STATE, NULL,
1619 &stid);
1620 if (status)
1621 return status;
1622
1623 cn->cpn_sec = nn->nfsd4_lease;
1624 cn->cpn_nsec = 0;
1625
1626 status = nfserrno(-ENOMEM);
1627 cps = nfs4_alloc_init_cpntf_state(nn, stid);
1628 if (!cps)
1629 goto out;
1630 memcpy(&cn->cpn_cnr_stateid, &cps->cp_stateid.stid, sizeof(stateid_t));
1631 memcpy(&cps->cp_p_stateid, &stid->sc_stateid, sizeof(stateid_t));
1632 memcpy(&cps->cp_p_clid, &clp->cl_clientid, sizeof(clientid_t));
1633
1634 /* For now, only return one server address in cpn_src, the
1635 * address used by the client to connect to this server.
1636 */
1637 cn->cpn_src.nl4_type = NL4_NETADDR;
1638 status = nfsd4_set_netaddr((struct sockaddr *)&rqstp->rq_daddr,
1639 &cn->cpn_src.u.nl4_addr);
1640 WARN_ON_ONCE(status);
1641 if (status) {
1642 nfs4_put_cpntf_state(nn, cps);
1643 goto out;
1644 }
1645out:
1646 nfs4_put_stid(stid);
1647 return status;
51911868
OK		 1648}
1649
95d871f0
AS		 1650static __be32
1651nfsd4_fallocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1652 struct nfsd4_fallocate *fallocate, int flags)
1653{
0d4d6720 1654 __be32 status;
5c4583b2 1655 struct nfsd_file *nf;
95d871f0 1656
aa0d6aed 1657 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
95d871f0 1658 &fallocate->falloc_stateid,
624322f1 1659 WR_STATE, &nf, NULL);
95d871f0
AS		 1660 if (status != nfs_ok) {
1661 dprintk("NFSD: nfsd4_fallocate: couldn't process stateid!\n");
1662 return status;
1663 }
1664
5c4583b2 1665 status = nfsd4_vfs_fallocate(rqstp, &cstate->current_fh, nf->nf_file,
95d871f0
AS		 1666 fallocate->falloc_offset,
1667 fallocate->falloc_length,
1668 flags);
5c4583b2 1669 nfsd_file_put(nf);
95d871f0
AS		 1670 return status;
1671}
6308bc98
OK		 1672static __be32
1673nfsd4_offload_status(struct svc_rqst *rqstp,
1674 struct nfsd4_compound_state *cstate,
1675 union nfsd4_op_u *u)
1676{
e0639dc5
OK		 1677 struct nfsd4_offload_status *os = &u->offload_status;
1678 __be32 status = 0;
1679 struct nfsd4_copy *copy;
1680 struct nfs4_client *clp = cstate->clp;
1681
1682 copy = find_async_copy(clp, &os->stateid);
1683 if (copy) {
1684 os->count = copy->cp_res.wr_bytes_written;
1685 nfs4_put_copy(copy);
1686 } else
1687 status = nfserr_bad_stateid;
1688
1689 return status;
6308bc98 1690}
95d871f0
AS		 1691
1692static __be32
1693nfsd4_allocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 1694 union nfsd4_op_u *u)
95d871f0 1695{
eb69853d 1696 return nfsd4_fallocate(rqstp, cstate, &u->allocate, 0);
95d871f0
AS		 1697}
1698
b0cb9085
AS		 1699static __be32
1700nfsd4_deallocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 1701 union nfsd4_op_u *u)
b0cb9085 1702{
eb69853d 1703 return nfsd4_fallocate(rqstp, cstate, &u->deallocate,
b0cb9085
AS		 1704 FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE);
1705}
1706
24bab491
AS		 1707static __be32
1708nfsd4_seek(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 1709 union nfsd4_op_u *u)
24bab491 1710{
eb69853d 1711 struct nfsd4_seek *seek = &u->seek;
24bab491
AS		 1712 int whence;
1713 __be32 status;
5c4583b2 1714 struct nfsd_file *nf;
24bab491 1715
aa0d6aed 1716 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
24bab491 1717 &seek->seek_stateid,
624322f1 1718 RD_STATE, &nf, NULL);
24bab491
AS		 1719 if (status) {
1720 dprintk("NFSD: nfsd4_seek: couldn't process stateid!\n");
1721 return status;
1722 }
1723
1724 switch (seek->seek_whence) {
1725 case NFS4_CONTENT_DATA:
1726 whence = SEEK_DATA;
1727 break;
1728 case NFS4_CONTENT_HOLE:
1729 whence = SEEK_HOLE;
1730 break;
1731 default:
1732 status = nfserr_union_notsupp;
1733 goto out;
1734 }
1735
1736 /*
1737 * Note: This call does change file->f_pos, but nothing in NFSD
1738 * should ever file->f_pos.
1739 */
5c4583b2 1740 seek->seek_pos = vfs_llseek(nf->nf_file, seek->seek_offset, whence);
24bab491
AS		 1741 if (seek->seek_pos < 0)
1742 status = nfserrno(seek->seek_pos);
5c4583b2 1743 else if (seek->seek_pos >= i_size_read(file_inode(nf->nf_file)))
24bab491
AS		 1744 seek->seek_eof = true;
1745
1746out:
5c4583b2 1747 nfsd_file_put(nf);
24bab491
AS		 1748 return status;
1749}
1750
1da177e4
LT		 1751/* This routine never returns NFS_OK! If there are no other errors, it
1752 * will return NFSERR_SAME or NFSERR_NOT_SAME depending on whether the
1753 * attributes matched. VERIFY is implemented by mapping NFSERR_SAME
1754 * to NFS_OK after the call; NVERIFY by mapping NFSERR_NOT_SAME to NFS_OK.
1755 */
b37ad28b 1756static __be32
c954e2a5 1757_nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
ca364317 1758 struct nfsd4_verify *verify)
1da177e4 1759{
2ebbc012 1760 __be32 *buf, *p;
1da177e4 1761 int count;
b37ad28b 1762 __be32 status;
1da177e4 1763
8837abca 1764 status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
1da177e4
LT		 1765 if (status)
1766 return status;
1767
3c8e0316
YZ		 1768 status = check_attr_support(rqstp, cstate, verify->ve_bmval, NULL);
1769 if (status)
1770 return status;
1771
1da177e4
LT		 1772 if ((verify->ve_bmval[0] & FATTR4_WORD0_RDATTR_ERROR)
1773 || (verify->ve_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1))
1774 return nfserr_inval;
1775 if (verify->ve_attrlen & 3)
1776 return nfserr_inval;
1777
1778 /* count in words:
1779 * bitmap_len(1) + bitmap(2) + attr_len(1) = 4
1780 */
1781 count = 4 + (verify->ve_attrlen >> 2);
1782 buf = kmalloc(count << 2, GFP_KERNEL);
1783 if (!buf)
3e772463 1784 return nfserr_jukebox;
1da177e4 1785
84822d0b 1786 p = buf;
d5184658 1787 status = nfsd4_encode_fattr_to_buf(&p, count, &cstate->current_fh,
ca364317 1788 cstate->current_fh.fh_export,
d5184658
BF		 1789 cstate->current_fh.fh_dentry,
1790 verify->ve_bmval,
406a7ea9 1791 rqstp, 0);
41ae6e71
BF		 1792 /*
1793 * If nfsd4_encode_fattr() ran out of space, assume that's because
1794 * the attributes are longer (hence different) than those given:
1795 */
84822d0b 1796 if (status == nfserr_resource)
1da177e4
LT		 1797 status = nfserr_not_same;
1798 if (status)
1799 goto out_kfree;
1800
95ec28cd
BH		 1801 /* skip bitmap */
1802 p = buf + 1 + ntohl(buf[0]);
1da177e4
LT		 1803 status = nfserr_not_same;
1804 if (ntohl(*p++) != verify->ve_attrlen)
1805 goto out_kfree;
1806 if (!memcmp(p, verify->ve_attrval, verify->ve_attrlen))
1807 status = nfserr_same;
1808
1809out_kfree:
1810 kfree(buf);
1811 return status;
1812}
1813
c954e2a5
BF		 1814static __be32
1815nfsd4_nverify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 1816 union nfsd4_op_u *u)
c954e2a5
BF		 1817{
1818 __be32 status;
1819
eb69853d 1820 status = _nfsd4_verify(rqstp, cstate, &u->verify);
c954e2a5
BF		 1821 return status == nfserr_not_same ? nfs_ok : status;
1822}
1823
1824static __be32
1825nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 1826 union nfsd4_op_u *u)
c954e2a5
BF		 1827{
1828 __be32 status;
1829
eb69853d 1830 status = _nfsd4_verify(rqstp, cstate, &u->nverify);
c954e2a5
BF		 1831 return status == nfserr_same ? nfs_ok : status;
1832}
1833
9cf514cc
CH		 1834#ifdef CONFIG_NFSD_PNFS
1835static const struct nfsd4_layout_ops *
1836nfsd4_layout_verify(struct svc_export *exp, unsigned int layout_type)
1837{
8a4c3926 1838 if (!exp->ex_layout_types) {
9cf514cc
CH		 1839 dprintk("%s: export does not support pNFS\n", __func__);
1840 return NULL;
1841 }
1842
b550a32e
AK		 1843 if (layout_type >= LAYOUT_TYPE_MAX ||
1844 !(exp->ex_layout_types & (1 << layout_type))) {
9cf514cc
CH		 1845 dprintk("%s: layout type %d not supported\n",
1846 __func__, layout_type);
1847 return NULL;
1848 }
1849
1850 return nfsd4_layout_ops[layout_type];
1851}
1852
1853static __be32
1854nfsd4_getdeviceinfo(struct svc_rqst *rqstp,
eb69853d 1855 struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
9cf514cc 1856{
eb69853d 1857 struct nfsd4_getdeviceinfo *gdp = &u->getdeviceinfo;
9cf514cc
CH		 1858 const struct nfsd4_layout_ops *ops;
1859 struct nfsd4_deviceid_map *map;
1860 struct svc_export *exp;
1861 __be32 nfserr;
1862
1863 dprintk("%s: layout_type %u dev_id [0x%llx:0x%x] maxcnt %u\n",
1864 __func__,
1865 gdp->gd_layout_type,
1866 gdp->gd_devid.fsid_idx, gdp->gd_devid.generation,
1867 gdp->gd_maxcount);
1868
1869 map = nfsd4_find_devid_map(gdp->gd_devid.fsid_idx);
1870 if (!map) {
1871 dprintk("%s: couldn't find device ID to export mapping!\n",
1872 __func__);
1873 return nfserr_noent;
1874 }
1875
1876 exp = rqst_exp_find(rqstp, map->fsid_type, map->fsid);
1877 if (IS_ERR(exp)) {
1878 dprintk("%s: could not find device id\n", __func__);
1879 return nfserr_noent;
1880 }
1881
1882 nfserr = nfserr_layoutunavailable;
1883 ops = nfsd4_layout_verify(exp, gdp->gd_layout_type);
1884 if (!ops)
1885 goto out;
1886
1887 nfserr = nfs_ok;
f99d4fbd
CH		 1888 if (gdp->gd_maxcount != 0) {
1889 nfserr = ops->proc_getdeviceinfo(exp->ex_path.mnt->mnt_sb,
d7c920d1 1890 rqstp, cstate->session->se_client, gdp);
f99d4fbd 1891 }
9cf514cc
CH		 1892
1893 gdp->gd_notify_types &= ops->notify_types;
9cf514cc 1894out:
a1420384 1895 exp_put(exp);
9cf514cc
CH		 1896 return nfserr;
1897}
1898
34b1744c
BF		 1899static void
1900nfsd4_getdeviceinfo_release(union nfsd4_op_u *u)
1901{
1902 kfree(u->getdeviceinfo.gd_device);
1903}
1904
9cf514cc
CH		 1905static __be32
1906nfsd4_layoutget(struct svc_rqst *rqstp,
eb69853d 1907 struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
9cf514cc 1908{
eb69853d 1909 struct nfsd4_layoutget *lgp = &u->layoutget;
9cf514cc
CH		 1910 struct svc_fh *current_fh = &cstate->current_fh;
1911 const struct nfsd4_layout_ops *ops;
1912 struct nfs4_layout_stateid *ls;
1913 __be32 nfserr;
66282ec1 1914 int accmode = NFSD_MAY_READ_IF_EXEC;
9cf514cc
CH		 1915
1916 switch (lgp->lg_seg.iomode) {
1917 case IOMODE_READ:
66282ec1 1918 accmode |= NFSD_MAY_READ;
9cf514cc
CH		 1919 break;
1920 case IOMODE_RW:
66282ec1 1921 accmode |= NFSD_MAY_READ | NFSD_MAY_WRITE;
9cf514cc
CH		 1922 break;
1923 default:
1924 dprintk("%s: invalid iomode %d\n",
1925 __func__, lgp->lg_seg.iomode);
1926 nfserr = nfserr_badiomode;
1927 goto out;
1928 }
1929
1930 nfserr = fh_verify(rqstp, current_fh, 0, accmode);
1931 if (nfserr)
1932 goto out;
1933
1934 nfserr = nfserr_layoutunavailable;
1935 ops = nfsd4_layout_verify(current_fh->fh_export, lgp->lg_layout_type);
1936 if (!ops)
1937 goto out;
1938
1939 /*
1940 * Verify minlength and range as per RFC5661:
1941 * o If loga_length is less than loga_minlength,
1942 * the metadata server MUST return NFS4ERR_INVAL.
1943 * o If the sum of loga_offset and loga_minlength exceeds
1944 * NFS4_UINT64_MAX, and loga_minlength is not
1945 * NFS4_UINT64_MAX, the error NFS4ERR_INVAL MUST result.
1946 * o If the sum of loga_offset and loga_length exceeds
1947 * NFS4_UINT64_MAX, and loga_length is not NFS4_UINT64_MAX,
1948 * the error NFS4ERR_INVAL MUST result.
1949 */
1950 nfserr = nfserr_inval;
1951 if (lgp->lg_seg.length < lgp->lg_minlength ||
1952 (lgp->lg_minlength != NFS4_MAX_UINT64 &&
1953 lgp->lg_minlength > NFS4_MAX_UINT64 - lgp->lg_seg.offset) ||
1954 (lgp->lg_seg.length != NFS4_MAX_UINT64 &&
1955 lgp->lg_seg.length > NFS4_MAX_UINT64 - lgp->lg_seg.offset))
1956 goto out;
1957 if (lgp->lg_seg.length == 0)
1958 goto out;
1959
1960 nfserr = nfsd4_preprocess_layout_stateid(rqstp, cstate, &lgp->lg_sid,
1961 true, lgp->lg_layout_type, &ls);
31ef83dc 1962 if (nfserr) {
f394b62b 1963 trace_nfsd_layout_get_lookup_fail(&lgp->lg_sid);
9cf514cc 1964 goto out;
31ef83dc 1965 }
9cf514cc 1966
c5c707f9
CH		 1967 nfserr = nfserr_recallconflict;
1968 if (atomic_read(&ls->ls_stid.sc_file->fi_lo_recalls))
1969 goto out_put_stid;
1970
2b0143b5 1971 nfserr = ops->proc_layoutget(d_inode(current_fh->fh_dentry),
9cf514cc
CH		 1972 current_fh, lgp);
1973 if (nfserr)
1974 goto out_put_stid;
1975
1976 nfserr = nfsd4_insert_layout(lgp, ls);
1977
1978out_put_stid:
cc8a5532 1979 mutex_unlock(&ls->ls_mutex);
9cf514cc
CH		 1980 nfs4_put_stid(&ls->ls_stid);
1981out:
1982 return nfserr;
1983}
1984
34b1744c
BF		 1985static void
1986nfsd4_layoutget_release(union nfsd4_op_u *u)
1987{
1988 kfree(u->layoutget.lg_content);
1989}
1990
9cf514cc
CH		 1991static __be32
1992nfsd4_layoutcommit(struct svc_rqst *rqstp,
eb69853d 1993 struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
9cf514cc 1994{
eb69853d 1995 struct nfsd4_layoutcommit *lcp = &u->layoutcommit;
9cf514cc
CH		 1996 const struct nfsd4_layout_seg *seg = &lcp->lc_seg;
1997 struct svc_fh *current_fh = &cstate->current_fh;
1998 const struct nfsd4_layout_ops *ops;
1999 loff_t new_size = lcp->lc_last_wr + 1;
2000 struct inode *inode;
2001 struct nfs4_layout_stateid *ls;
2002 __be32 nfserr;
2003
2004 nfserr = fh_verify(rqstp, current_fh, 0, NFSD_MAY_WRITE);
2005 if (nfserr)
2006 goto out;
2007
2008 nfserr = nfserr_layoutunavailable;
2009 ops = nfsd4_layout_verify(current_fh->fh_export, lcp->lc_layout_type);
2010 if (!ops)
2011 goto out;
2b0143b5 2012 inode = d_inode(current_fh->fh_dentry);
9cf514cc
CH		 2013
2014 nfserr = nfserr_inval;
2015 if (new_size <= seg->offset) {
2016 dprintk("pnfsd: last write before layout segment\n");
2017 goto out;
2018 }
2019 if (new_size > seg->offset + seg->length) {
2020 dprintk("pnfsd: last write beyond layout segment\n");
2021 goto out;
2022 }
2023 if (!lcp->lc_newoffset && new_size > i_size_read(inode)) {
2024 dprintk("pnfsd: layoutcommit beyond EOF\n");
2025 goto out;
2026 }
2027
2028 nfserr = nfsd4_preprocess_layout_stateid(rqstp, cstate, &lcp->lc_sid,
2029 false, lcp->lc_layout_type,
2030 &ls);
2031 if (nfserr) {
f394b62b 2032 trace_nfsd_layout_commit_lookup_fail(&lcp->lc_sid);
9cf514cc
CH		 2033 /* fixup error code as per RFC5661 */
2034 if (nfserr == nfserr_bad_stateid)
2035 nfserr = nfserr_badlayout;
2036 goto out;
2037 }
2038
cc8a5532
JL		 2039 /* LAYOUTCOMMIT does not require any serialization */
2040 mutex_unlock(&ls->ls_mutex);
2041
9cf514cc
CH		 2042 if (new_size > i_size_read(inode)) {
2043 lcp->lc_size_chg = 1;
2044 lcp->lc_newsize = new_size;
2045 } else {
2046 lcp->lc_size_chg = 0;
2047 }
2048
d8398fc1 2049 nfserr = ops->proc_layoutcommit(inode, lcp);
9cf514cc
CH		 2050 nfs4_put_stid(&ls->ls_stid);
2051out:
2052 return nfserr;
2053}
2054
2055static __be32
2056nfsd4_layoutreturn(struct svc_rqst *rqstp,
eb69853d 2057 struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
9cf514cc 2058{
eb69853d 2059 struct nfsd4_layoutreturn *lrp = &u->layoutreturn;
9cf514cc
CH		 2060 struct svc_fh *current_fh = &cstate->current_fh;
2061 __be32 nfserr;
2062
2063 nfserr = fh_verify(rqstp, current_fh, 0, NFSD_MAY_NOP);
2064 if (nfserr)
2065 goto out;
2066
2067 nfserr = nfserr_layoutunavailable;
2068 if (!nfsd4_layout_verify(current_fh->fh_export, lrp->lr_layout_type))
2069 goto out;
2070
2071 switch (lrp->lr_seg.iomode) {
2072 case IOMODE_READ:
2073 case IOMODE_RW:
2074 case IOMODE_ANY:
2075 break;
2076 default:
2077 dprintk("%s: invalid iomode %d\n", __func__,
2078 lrp->lr_seg.iomode);
2079 nfserr = nfserr_inval;
2080 goto out;
2081 }
2082
2083 switch (lrp->lr_return_type) {
2084 case RETURN_FILE:
2085 nfserr = nfsd4_return_file_layouts(rqstp, cstate, lrp);
2086 break;
2087 case RETURN_FSID:
2088 case RETURN_ALL:
2089 nfserr = nfsd4_return_client_layouts(rqstp, cstate, lrp);
2090 break;
2091 default:
2092 dprintk("%s: invalid return_type %d\n", __func__,
2093 lrp->lr_return_type);
2094 nfserr = nfserr_inval;
2095 break;
2096 }
2097out:
2098 return nfserr;
2099}
2100#endif /* CONFIG_NFSD_PNFS */
2101
23e50fe3
FL		 2102static __be32
2103nfsd4_getxattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
2104 union nfsd4_op_u *u)
2105{
2106 struct nfsd4_getxattr *getxattr = &u->getxattr;
2107
2108 return nfsd_getxattr(rqstp, &cstate->current_fh,
2109 getxattr->getxa_name, &getxattr->getxa_buf,
2110 &getxattr->getxa_len);
2111}
2112
2113static __be32
2114nfsd4_setxattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
2115 union nfsd4_op_u *u)
2116{
2117 struct nfsd4_setxattr *setxattr = &u->setxattr;
2118 __be32 ret;
2119
2120 if (opens_in_grace(SVC_NET(rqstp)))
2121 return nfserr_grace;
2122
2123 ret = nfsd_setxattr(rqstp, &cstate->current_fh, setxattr->setxa_name,
2124 setxattr->setxa_buf, setxattr->setxa_len,
2125 setxattr->setxa_flags);
2126
2127 if (!ret)
2128 set_change_info(&setxattr->setxa_cinfo, &cstate->current_fh);
2129
2130 return ret;
2131}
2132
2133static __be32
2134nfsd4_listxattrs(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
2135 union nfsd4_op_u *u)
2136{
2137 /*
2138 * Get the entire list, then copy out only the user attributes
2139 * in the encode function.
2140 */
2141 return nfsd_listxattr(rqstp, &cstate->current_fh,
2142 &u->listxattrs.lsxa_buf, &u->listxattrs.lsxa_len);
2143}
2144
2145static __be32
2146nfsd4_removexattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
2147 union nfsd4_op_u *u)
2148{
2149 struct nfsd4_removexattr *removexattr = &u->removexattr;
2150 __be32 ret;
2151
2152 if (opens_in_grace(SVC_NET(rqstp)))
2153 return nfserr_grace;
2154
2155 ret = nfsd_removexattr(rqstp, &cstate->current_fh,
2156 removexattr->rmxa_name);
2157
2158 if (!ret)
2159 set_change_info(&removexattr->rmxa_cinfo, &cstate->current_fh);
2160
2161 return ret;
2162}
2163
1da177e4
LT		 2164/*
2165 * NULL call.
2166 */
7111c66e 2167static __be32
a6beb732 2168nfsd4_proc_null(struct svc_rqst *rqstp)
1da177e4 2169{
cc028a10 2170 return rpc_success;
1da177e4
LT		 2171}
2172
e2b20950
SA		 2173static inline void nfsd4_increment_op_stats(u32 opnum)
2174{
2175 if (opnum >= FIRST_NFS4_OP && opnum <= LAST_NFS4_OP)
e567b98c 2176 percpu_counter_inc(&nfsdstats.counter[NFSD_STATS_NFS4_OP(opnum)]);
e2b20950
SA		 2177}
2178
bb2a8b0c 2179static const struct nfsd4_operation nfsd4_ops[];
b591480b 2180
f1c7f79b 2181static const char *nfsd4_op_name(unsigned opnum);
b001a1b6 2182
f9bb94c4 2183/*
57716355 2184 * Enforce NFSv4.1 COMPOUND ordering rules:
f9bb94c4 2185 *
57716355
BF		 2186 * Also note, enforced elsewhere:
2187 * - SEQUENCE other than as first op results in
2188 * NFS4ERR_SEQUENCE_POS. (Enforced in nfsd4_sequence().)
1d1bc8f2
BF		 2189 * - BIND_CONN_TO_SESSION must be the only op in its compound.
2190 * (Enforced in nfsd4_bind_conn_to_session().)
57716355
BF		 2191 * - DESTROY_SESSION must be the final operation in a compound, if
2192 * sessionid's in SEQUENCE and DESTROY_SESSION are the same.
2193 * (Enforced in nfsd4_destroy_session().)
f9bb94c4 2194 */
57716355 2195static __be32 nfs41_check_op_ordering(struct nfsd4_compoundargs *args)
f9bb94c4 2196{
7a04cfda 2197 struct nfsd4_op *first_op = &args->ops[0];
57716355
BF		 2198
2199 /* These ordering requirements don't apply to NFSv4.0: */
2200 if (args->minorversion == 0)
2201 return nfs_ok;
2202 /* This is weird, but OK, not our problem: */
2203 if (args->opcnt == 0)
2204 return nfs_ok;
7a04cfda 2205 if (first_op->status == nfserr_op_illegal)
57716355 2206 return nfs_ok;
7a04cfda 2207 if (!(nfsd4_ops[first_op->opnum].op_flags & ALLOWED_AS_FIRST_OP))
57716355 2208 return nfserr_op_not_in_session;
7a04cfda 2209 if (first_op->opnum == OP_SEQUENCE)
57716355 2210 return nfs_ok;
7a04cfda
BF		 2211 /*
2212 * So first_op is something allowed outside a session, like
2213 * EXCHANGE_ID; but then it has to be the only op in the
2214 * compound:
2215 */
57716355
BF		 2216 if (args->opcnt != 1)
2217 return nfserr_not_only_op;
2218 return nfs_ok;
f9bb94c4
AA		 2219}
2220
f4f9ef4a 2221const struct nfsd4_operation *OPDESC(struct nfsd4_op *op)
22b03214
BF		 2222{
2223 return &nfsd4_ops[op->opnum];
2224}
2225
1091006c
BF		 2226bool nfsd4_cache_this_op(struct nfsd4_op *op)
2227{
e372ba60
BF		 2228 if (op->opnum == OP_ILLEGAL)
2229 return false;
c856694e 2230 return OPDESC(op)->op_flags & OP_CACHEME;
1091006c
BF		 2231}
2232
68d93184
BF		 2233static bool need_wrongsec_check(struct svc_rqst *rqstp)
2234{
2235 struct nfsd4_compoundres *resp = rqstp->rq_resp;
2236 struct nfsd4_compoundargs *argp = rqstp->rq_argp;
2237 struct nfsd4_op *this = &argp->ops[resp->opcnt - 1];
2238 struct nfsd4_op *next = &argp->ops[resp->opcnt];
bb2a8b0c
CH		 2239 const struct nfsd4_operation *thisd = OPDESC(this);
2240 const struct nfsd4_operation *nextd;
68d93184 2241
68d93184
BF		 2242 /*
2243 * Most ops check wronsec on our own; only the putfh-like ops
2244 * have special rules.
2245 */
2246 if (!(thisd->op_flags & OP_IS_PUTFH_LIKE))
2247 return false;
2248 /*
2249 * rfc 5661 2.6.3.1.1.6: don't bother erroring out a
2250 * put-filehandle operation if we're not going to use the
2251 * result:
2252 */
2253 if (argp->opcnt == resp->opcnt)
2254 return false;
51904b08
BF		 2255 if (next->opnum == OP_ILLEGAL)
2256 return false;
68d93184
BF		 2257 nextd = OPDESC(next);
2258 /*
2259 * Rest of 2.6.3.1.1: certain operations will return WRONGSEC
2260 * errors themselves as necessary; others should check for them
2261 * now:
2262 */
2263 return !(nextd->op_flags & OP_HANDLES_WRONGSEC);
2264}
2265
2d124dfa
BF		 2266static void svcxdr_init_encode(struct svc_rqst *rqstp,
2267 struct nfsd4_compoundres *resp)
2268{
2269 struct xdr_stream *xdr = &resp->xdr;
2270 struct xdr_buf *buf = &rqstp->rq_res;
2271 struct kvec *head = buf->head;
2272
2273 xdr->buf = buf;
ddd1ea56 2274 xdr->iov = head;
2d124dfa 2275 xdr->p = head->iov_base + head->iov_len;
a5cddc88 2276 xdr->end = head->iov_base + PAGE_SIZE - rqstp->rq_auth_slack;
6ac90391
BF		 2277 /* Tail and page_len should be zero at this point: */
2278 buf->len = buf->head[0].iov_len;
0ae4c3e8 2279 xdr_reset_scratch_buffer(xdr);
05638dc7 2280 xdr->page_ptr = buf->pages - 1;
2825a7f9 2281 buf->buflen = PAGE_SIZE * (1 + rqstp->rq_page_end - buf->pages)
a5cddc88 2282 - rqstp->rq_auth_slack;
2d124dfa
BF		 2283}
2284
b9e8638e
OK		 2285#ifdef CONFIG_NFSD_V4_2_INTER_SSC
2286static void
2287check_if_stalefh_allowed(struct nfsd4_compoundargs *args)
2288{
2289 struct nfsd4_op *op, *current_op = NULL, *saved_op = NULL;
2290 struct nfsd4_copy *copy;
2291 struct nfsd4_putfh *putfh;
2292 int i;
2293
2294 /* traverse all operation and if it's a COPY compound, mark the
2295 * source filehandle to skip verification
2296 */
2297 for (i = 0; i < args->opcnt; i++) {
2298 op = &args->ops[i];
2299 if (op->opnum == OP_PUTFH)
2300 current_op = op;
2301 else if (op->opnum == OP_SAVEFH)
2302 saved_op = current_op;
2303 else if (op->opnum == OP_RESTOREFH)
2304 current_op = saved_op;
2305 else if (op->opnum == OP_COPY) {
2306 copy = (struct nfsd4_copy *)&op->u;
2307 if (!saved_op) {
2308 op->status = nfserr_nofilehandle;
2309 return;
2310 }
2311 putfh = (struct nfsd4_putfh *)&saved_op->u;
2312 if (!copy->cp_intra)
2313 putfh->no_verify = true;
2314 }
2315 }
2316}
2317#else
2318static void
2319check_if_stalefh_allowed(struct nfsd4_compoundargs *args)
2320{
2321}
2322#endif
2323
1da177e4
LT		 2324/*
2325 * COMPOUND call.
2326 */
7111c66e 2327static __be32
a6beb732 2328nfsd4_proc_compound(struct svc_rqst *rqstp)
1da177e4 2329{
a6beb732
CH		 2330 struct nfsd4_compoundargs *args = rqstp->rq_argp;
2331 struct nfsd4_compoundres *resp = rqstp->rq_resp;
1da177e4 2332 struct nfsd4_op *op;
e354d571 2333 struct nfsd4_compound_state *cstate = &resp->cstate;
4daeed25
KM		 2334 struct svc_fh *current_fh = &cstate->current_fh;
2335 struct svc_fh *save_fh = &cstate->save_fh;
e333f3bb 2336 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
b37ad28b 2337 __be32 status;
1da177e4 2338
2d124dfa 2339 svcxdr_init_encode(rqstp, resp);
4aea24b2 2340 resp->tagp = resp->xdr.p;
1da177e4 2341 /* reserve space for: taglen, tag, and opcnt */
d3f627c8 2342 xdr_reserve_space(&resp->xdr, 8 + args->taglen);
1da177e4
LT		 2343 resp->taglen = args->taglen;
2344 resp->tag = args->tag;
1da177e4 2345 resp->rqstp = rqstp;
4daeed25 2346 cstate->minorversion = args->minorversion;
4daeed25
KM		 2347 fh_init(current_fh, NFS4_FHSIZE);
2348 fh_init(save_fh, NFS4_FHSIZE);
8ff30fa4
N		 2349 /*
2350 * Don't use the deferral mechanism for NFSv4; compounds make it
2351 * too hard to avoid non-idempotency problems.
2352 */
30660e04 2353 clear_bit(RQ_USEDEFERRAL, &rqstp->rq_flags);
1da177e4
LT		 2354
2355 /*
2356 * According to RFC3010, this takes precedence over all other errors.
2357 */
2358 status = nfserr_minor_vers_mismatch;
e333f3bb 2359 if (nfsd_minorversion(nn, args->minorversion, NFSD_TEST) <= 0)
1da177e4 2360 goto out;
0078117c
BF		 2361 status = nfserr_resource;
2362 if (args->opcnt > NFSD_MAX_OPS_PER_COMPOUND)
2363 goto out;
1da177e4 2364
57716355
BF		 2365 status = nfs41_check_op_ordering(args);
2366 if (status) {
f9bb94c4 2367 op = &args->ops[0];
57716355 2368 op->status = status;
5b7b15ae 2369 resp->opcnt = 1;
f9bb94c4
AA		 2370 goto encode_op;
2371 }
b9e8638e 2372 check_if_stalefh_allowed(args);
f9bb94c4 2373
28df3d15
BF		 2374 rqstp->rq_lease_breaker = (void **)&cstate->clp;
2375
fff4080b 2376 trace_nfsd_compound(rqstp, args->opcnt);
1da177e4
LT		 2377 while (!status && resp->opcnt < args->opcnt) {
2378 op = &args->ops[resp->opcnt++];
2379
2380 /*
2381 * The XDR decode routines may have pre-set op->status;
2382 * for example, if there is a miscellaneous XDR error
2383 * it will be set to nfserr_bad_xdr.
2384 */
9d313b17
BF		 2385 if (op->status) {
2386 if (op->opnum == OP_OPEN)
2387 op->status = nfsd4_open_omfg(rqstp, cstate, op);
1da177e4 2388 goto encode_op;
9d313b17 2389 }
b9e8638e
OK		 2390 if (!current_fh->fh_dentry &&
2391 !HAS_FH_FLAG(current_fh, NFSD4_FH_FOREIGN)) {
f4f9ef4a 2392 if (!(op->opdesc->op_flags & ALLOWED_WITHOUT_FH)) {
42ca0993
BF		 2393 op->status = nfserr_nofilehandle;
2394 goto encode_op;
2395 }
b9e8638e
OK		 2396 } else if (current_fh->fh_export &&
2397 current_fh->fh_export->ex_fslocs.migrated &&
f4f9ef4a 2398 !(op->opdesc->op_flags & ALLOWED_ON_ABSENT_FS)) {
42ca0993 2399 op->status = nfserr_moved;
1da177e4
LT		 2400 goto encode_op;
2401 }
b591480b 2402
2336745e
KM		 2403 fh_clear_wcc(current_fh);
2404
58e7b33a 2405 /* If op is non-idempotent */
f4f9ef4a 2406 if (op->opdesc->op_flags & OP_MODIFIES_SOMETHING) {
4c69d585 2407 /*
a8095f7e
BF		 2408 * Don't execute this op if we couldn't encode a
2409 * succesful reply:
2410 */
f4f9ef4a 2411 u32 plen = op->opdesc->op_rsize_bop(rqstp, op);
a8095f7e
BF		 2412 /*
2413 * Plus if there's another operation, make sure
4c69d585
BF		 2414 * we'll have space to at least encode an error:
2415 */
2416 if (resp->opcnt < args->opcnt)
2417 plen += COMPOUND_ERR_SLACK_SPACE;
58e7b33a
MJ		 2418 op->status = nfsd4_check_resp_size(resp, plen);
2419 }
2420
2421 if (op->status)
2422 goto encode_op;
2423
f4f9ef4a
BF		 2424 if (op->opdesc->op_get_currentstateid)
2425 op->opdesc->op_get_currentstateid(cstate, &op->u);
2426 op->status = op->opdesc->op_func(rqstp, cstate, &op->u);
1da177e4 2427
9a307403
BF		 2428 /* Only from SEQUENCE */
2429 if (cstate->status == nfserr_replay_cache) {
2430 dprintk("%s NFS4.1 replay from cache\n", __func__);
2431 status = op->status;
2432 goto out;
2433 }
8b70484c 2434 if (!op->status) {
f4f9ef4a
BF		 2435 if (op->opdesc->op_set_currentstateid)
2436 op->opdesc->op_set_currentstateid(cstate, &op->u);
8b70484c 2437
f4f9ef4a 2438 if (op->opdesc->op_flags & OP_CLEAR_STATEID)
37c593c5 2439 clear_current_stateid(cstate);
8b70484c 2440
d781e3df
BF		 2441 if (current_fh->fh_export &&
2442 need_wrongsec_check(rqstp))
4daeed25 2443 op->status = check_nfsd_access(current_fh->fh_export, rqstp);
8b70484c 2444 }
1da177e4 2445encode_op:
a90b061c 2446 if (op->status == nfserr_replay_me) {
a4f1706a 2447 op->replay = &cstate->replay_owner->so_replay;
d0a381dd 2448 nfsd4_encode_replay(&resp->xdr, op);
1da177e4
LT		 2449 status = op->status = op->replay->rp_status;
2450 } else {
2451 nfsd4_encode_operation(resp, op);
2452 status = op->status;
2453 }
0407717d 2454
fff4080b
CL		 2455 trace_nfsd_compound_status(args->opcnt, resp->opcnt, status,
2456 nfsd4_op_name(op->opnum));
0407717d 2457
58fb12e6 2458 nfsd4_cstate_clear_replay(cstate);
e2b20950 2459 nfsd4_increment_op_stats(op->opnum);
1da177e4
LT		 2460 }
2461
4daeed25
KM		 2462 fh_put(current_fh);
2463 fh_put(save_fh);
2464 BUG_ON(cstate->replay_owner);
1da177e4 2465out:
cc028a10 2466 cstate->status = status;
2f425878 2467 /* Reset deferral mechanism for RPC deferrals */
30660e04 2468 set_bit(RQ_USEDEFERRAL, &rqstp->rq_flags);
cc028a10 2469 return rpc_success;
1da177e4
LT		 2470}
2471
58e7b33a
MJ		 2472#define op_encode_hdr_size (2)
2473#define op_encode_stateid_maxsz (XDR_QUADLEN(NFS4_STATEID_SIZE))
2474#define op_encode_verifier_maxsz (XDR_QUADLEN(NFS4_VERIFIER_SIZE))
2475#define op_encode_change_info_maxsz (5)
2476#define nfs4_fattr_bitmap_maxsz (4)
2477
8c7424cf
BF		 2478/* We'll fall back on returning no lockowner if run out of space: */
2479#define op_encode_lockowner_maxsz (0)
58e7b33a
MJ		 2480#define op_encode_lock_denied_maxsz (8 + op_encode_lockowner_maxsz)
2481
2482#define nfs4_owner_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
2483
2484#define op_encode_ace_maxsz (3 + nfs4_owner_maxsz)
2485#define op_encode_delegation_maxsz (1 + op_encode_stateid_maxsz + 1 + \
2486 op_encode_ace_maxsz)
2487
2488#define op_encode_channel_attrs_maxsz (6 + 1 + 1)
2489
2490static inline u32 nfsd4_only_status_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2491{
2492 return (op_encode_hdr_size) * sizeof(__be32);
2493}
2494
2495static inline u32 nfsd4_status_stateid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2496{
2497 return (op_encode_hdr_size + op_encode_stateid_maxsz)* sizeof(__be32);
2498}
2499
2282cd2c
KM		 2500static inline u32 nfsd4_access_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2501{
2502 /* ac_supported, ac_resp_access */
2503 return (op_encode_hdr_size + 2)* sizeof(__be32);
2504}
2505
58e7b33a
MJ		 2506static inline u32 nfsd4_commit_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2507{
2508 return (op_encode_hdr_size + op_encode_verifier_maxsz) * sizeof(__be32);
2509}
2510
2511static inline u32 nfsd4_create_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2512{
2513 return (op_encode_hdr_size + op_encode_change_info_maxsz
2514 + nfs4_fattr_bitmap_maxsz) * sizeof(__be32);
2515}
2516
b86cef60
BF		 2517/*
2518 * Note since this is an idempotent operation we won't insist on failing
2519 * the op prematurely if the estimate is too large. We may turn off splice
2520 * reads unnecessarily.
2521 */
2522static inline u32 nfsd4_getattr_rsize(struct svc_rqst *rqstp,
2523 struct nfsd4_op *op)
2524{
2525 u32 *bmap = op->u.getattr.ga_bmval;
2526 u32 bmap0 = bmap[0], bmap1 = bmap[1], bmap2 = bmap[2];
2527 u32 ret = 0;
2528
2529 if (bmap0 & FATTR4_WORD0_ACL)
2530 return svc_max_payload(rqstp);
2531 if (bmap0 & FATTR4_WORD0_FS_LOCATIONS)
2532 return svc_max_payload(rqstp);
2533
2534 if (bmap1 & FATTR4_WORD1_OWNER) {
2535 ret += IDMAP_NAMESZ + 4;
2536 bmap1 &= ~FATTR4_WORD1_OWNER;
2537 }
2538 if (bmap1 & FATTR4_WORD1_OWNER_GROUP) {
2539 ret += IDMAP_NAMESZ + 4;
2540 bmap1 &= ~FATTR4_WORD1_OWNER_GROUP;
2541 }
2542 if (bmap0 & FATTR4_WORD0_FILEHANDLE) {
2543 ret += NFS4_FHSIZE + 4;
2544 bmap0 &= ~FATTR4_WORD0_FILEHANDLE;
2545 }
2546 if (bmap2 & FATTR4_WORD2_SECURITY_LABEL) {
1ec8c0c4 2547 ret += NFS4_MAXLABELLEN + 12;
b86cef60
BF		 2548 bmap2 &= ~FATTR4_WORD2_SECURITY_LABEL;
2549 }
2550 /*
2551 * Largest of remaining attributes are 16 bytes (e.g.,
2552 * supported_attributes)
2553 */
2554 ret += 16 * (hweight32(bmap0) + hweight32(bmap1) + hweight32(bmap2));
2555 /* bitmask, length */
2556 ret += 20;
2557 return ret;
2558}
2559
2282cd2c
KM		 2560static inline u32 nfsd4_getfh_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2561{
2562 return (op_encode_hdr_size + 1) * sizeof(__be32) + NFS4_FHSIZE;
2563}
2564
58e7b33a
MJ		 2565static inline u32 nfsd4_link_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2566{
2567 return (op_encode_hdr_size + op_encode_change_info_maxsz)
2568 * sizeof(__be32);
2569}
2570
2571static inline u32 nfsd4_lock_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2572{
2573 return (op_encode_hdr_size + op_encode_lock_denied_maxsz)
2574 * sizeof(__be32);
2575}
2576
2577static inline u32 nfsd4_open_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2578{
2579 return (op_encode_hdr_size + op_encode_stateid_maxsz
2580 + op_encode_change_info_maxsz + 1
2581 + nfs4_fattr_bitmap_maxsz
2582 + op_encode_delegation_maxsz) * sizeof(__be32);
2583}
2584
2585static inline u32 nfsd4_read_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2586{
2587 u32 maxcount = 0, rlen = 0;
2588
2589 maxcount = svc_max_payload(rqstp);
3c7aa15d 2590 rlen = min(op->u.read.rd_length, maxcount);
58e7b33a 2591
622f560e 2592 return (op_encode_hdr_size + 2 + XDR_QUADLEN(rlen)) * sizeof(__be32);
58e7b33a
MJ		 2593}
2594
528b8493
AS		 2595static inline u32 nfsd4_read_plus_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2596{
2597 u32 maxcount = svc_max_payload(rqstp);
2598 u32 rlen = min(op->u.read.rd_length, maxcount);
2599 /*
2600 * If we detect that the file changed during hole encoding, then we
2601 * recover by encoding the remaining reply as data. This means we need
2602 * to set aside enough room to encode two data segments.
2603 */
2604 u32 seg_len = 2 * (1 + 2 + 1);
2605
2606 return (op_encode_hdr_size + 2 + seg_len + XDR_QUADLEN(rlen)) * sizeof(__be32);
2607}
2608
58e7b33a
MJ		 2609static inline u32 nfsd4_readdir_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2610{
3c7aa15d 2611 u32 maxcount = 0, rlen = 0;
58e7b33a 2612
3c7aa15d
KM		 2613 maxcount = svc_max_payload(rqstp);
2614 rlen = min(op->u.readdir.rd_maxcount, maxcount);
58e7b33a 2615
561f0ed4
BF		 2616 return (op_encode_hdr_size + op_encode_verifier_maxsz +
2617 XDR_QUADLEN(rlen)) * sizeof(__be32);
58e7b33a
MJ		 2618}
2619
2282cd2c
KM		 2620static inline u32 nfsd4_readlink_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2621{
2622 return (op_encode_hdr_size + 1) * sizeof(__be32) + PAGE_SIZE;
2623}
2624
58e7b33a
MJ		 2625static inline u32 nfsd4_remove_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2626{
2627 return (op_encode_hdr_size + op_encode_change_info_maxsz)
2628 * sizeof(__be32);
2629}
2630
2631static inline u32 nfsd4_rename_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2632{
2633 return (op_encode_hdr_size + op_encode_change_info_maxsz
2634 + op_encode_change_info_maxsz) * sizeof(__be32);
2635}
2636
ccae70a9
BF		 2637static inline u32 nfsd4_sequence_rsize(struct svc_rqst *rqstp,
2638 struct nfsd4_op *op)
2639{
d1d84c96
BF		 2640 return (op_encode_hdr_size
2641 + XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + 5) * sizeof(__be32);
ccae70a9
BF		 2642}
2643
2282cd2c
KM		 2644static inline u32 nfsd4_test_stateid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2645{
2646 return (op_encode_hdr_size + 1 + op->u.test_stateid.ts_num_ids)
2647 * sizeof(__be32);
2648}
2649
58e7b33a
MJ		 2650static inline u32 nfsd4_setattr_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2651{
2652 return (op_encode_hdr_size + nfs4_fattr_bitmap_maxsz) * sizeof(__be32);
2653}
2654
2282cd2c
KM		 2655static inline u32 nfsd4_secinfo_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2656{
2657 return (op_encode_hdr_size + RPC_AUTH_MAXFLAVOR *
2658 (4 + XDR_QUADLEN(GSS_OID_MAX_LEN))) * sizeof(__be32);
2659}
2660
58e7b33a
MJ		 2661static inline u32 nfsd4_setclientid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2662{
480efaee
BF		 2663 return (op_encode_hdr_size + 2 + XDR_QUADLEN(NFS4_VERIFIER_SIZE)) *
2664 sizeof(__be32);
58e7b33a
MJ		 2665}
2666
2667static inline u32 nfsd4_write_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2668{
f34e432b 2669 return (op_encode_hdr_size + 2 + op_encode_verifier_maxsz) * sizeof(__be32);
58e7b33a
MJ		 2670}
2671
2672static inline u32 nfsd4_exchange_id_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2673{
2674 return (op_encode_hdr_size + 2 + 1 + /* eir_clientid, eir_sequenceid */\
a8bb84bc
KM		 2675 1 + 1 + /* eir_flags, spr_how */\
2676 4 + /* spo_must_enforce & _allow with bitmap */\
58e7b33a
MJ		 2677 2 + /*eir_server_owner.so_minor_id */\
2678 /* eir_server_owner.so_major_id<> */\
2679 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\
2680 /* eir_server_scope<> */\
2681 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\
2682 1 + /* eir_server_impl_id array length */\
2683 0 /* ignored eir_server_impl_id contents */) * sizeof(__be32);
2684}
2685
2686static inline u32 nfsd4_bind_conn_to_session_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2687{
2688 return (op_encode_hdr_size + \
2689 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* bctsr_sessid */\
2690 2 /* bctsr_dir, use_conn_in_rdma_mode */) * sizeof(__be32);
2691}
2692
2693static inline u32 nfsd4_create_session_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2694{
2695 return (op_encode_hdr_size + \
2696 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* sessionid */\
2697 2 + /* csr_sequence, csr_flags */\
2698 op_encode_channel_attrs_maxsz + \
2699 op_encode_channel_attrs_maxsz) * sizeof(__be32);
2700}
2701
29ae7f9d
AS		 2702static inline u32 nfsd4_copy_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2703{
2704 return (op_encode_hdr_size +
2705 1 /* wr_callback */ +
2706 op_encode_stateid_maxsz /* wr_callback */ +
2707 2 /* wr_count */ +
2708 1 /* wr_committed */ +
2709 op_encode_verifier_maxsz +
2710 1 /* cr_consecutive */ +
2711 1 /* cr_synchronous */) * sizeof(__be32);
2712}
2713
6308bc98
OK		 2714static inline u32 nfsd4_offload_status_rsize(struct svc_rqst *rqstp,
2715 struct nfsd4_op *op)
2716{
2717 return (op_encode_hdr_size +
2718 2 /* osr_count */ +
2719 1 /* osr_complete<1> optional 0 for now */) * sizeof(__be32);
2720}
2721
51911868
OK		 2722static inline u32 nfsd4_copy_notify_rsize(struct svc_rqst *rqstp,
2723 struct nfsd4_op *op)
2724{
2725 return (op_encode_hdr_size +
2726 3 /* cnr_lease_time */ +
2727 1 /* We support one cnr_source_server */ +
2728 1 /* cnr_stateid seq */ +
2729 op_encode_stateid_maxsz /* cnr_stateid */ +
2730 1 /* num cnr_source_server*/ +
2731 1 /* nl4_type */ +
2732 1 /* nl4 size */ +
2733 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) /*nl4_loc + nl4_loc_sz */)
2734 * sizeof(__be32);
2735}
2736
9cf514cc 2737#ifdef CONFIG_NFSD_PNFS
2282cd2c
KM		 2738static inline u32 nfsd4_getdeviceinfo_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2739{
2740 u32 maxcount = 0, rlen = 0;
2741
2742 maxcount = svc_max_payload(rqstp);
2743 rlen = min(op->u.getdeviceinfo.gd_maxcount, maxcount);
2744
2745 return (op_encode_hdr_size +
2746 1 /* gd_layout_type*/ +
2747 XDR_QUADLEN(rlen) +
2748 2 /* gd_notify_types */) * sizeof(__be32);
2749}
2750
9cf514cc
CH		 2751/*
2752 * At this stage we don't really know what layout driver will handle the request,
2753 * so we need to define an arbitrary upper bound here.
2754 */
2755#define MAX_LAYOUT_SIZE 128
2756static inline u32 nfsd4_layoutget_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2757{
2758 return (op_encode_hdr_size +
2759 1 /* logr_return_on_close */ +
2760 op_encode_stateid_maxsz +
2761 1 /* nr of layouts */ +
2762 MAX_LAYOUT_SIZE) * sizeof(__be32);
2763}
2764
2765static inline u32 nfsd4_layoutcommit_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2766{
2767 return (op_encode_hdr_size +
2768 1 /* locr_newsize */ +
2769 2 /* ns_size */) * sizeof(__be32);
2770}
2771
2772static inline u32 nfsd4_layoutreturn_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2773{
2774 return (op_encode_hdr_size +
2775 1 /* lrs_stateid */ +
2776 op_encode_stateid_maxsz) * sizeof(__be32);
2777}
2778#endif /* CONFIG_NFSD_PNFS */
2779
2282cd2c
KM		 2780
2781static inline u32 nfsd4_seek_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2782{
2783 return (op_encode_hdr_size + 3) * sizeof(__be32);
2784}
2785
23e50fe3
FL		 2786static inline u32 nfsd4_getxattr_rsize(struct svc_rqst *rqstp,
2787 struct nfsd4_op *op)
2788{
2789 u32 maxcount, rlen;
2790
2791 maxcount = svc_max_payload(rqstp);
2792 rlen = min_t(u32, XATTR_SIZE_MAX, maxcount);
2793
2794 return (op_encode_hdr_size + 1 + XDR_QUADLEN(rlen)) * sizeof(__be32);
2795}
2796
2797static inline u32 nfsd4_setxattr_rsize(struct svc_rqst *rqstp,
2798 struct nfsd4_op *op)
2799{
2800 return (op_encode_hdr_size + op_encode_change_info_maxsz)
2801 * sizeof(__be32);
2802}
2803static inline u32 nfsd4_listxattrs_rsize(struct svc_rqst *rqstp,
2804 struct nfsd4_op *op)
2805{
2806 u32 maxcount, rlen;
2807
2808 maxcount = svc_max_payload(rqstp);
2809 rlen = min(op->u.listxattrs.lsxa_maxcount, maxcount);
2810
2811 return (op_encode_hdr_size + 4 + XDR_QUADLEN(rlen)) * sizeof(__be32);
2812}
2813
2814static inline u32 nfsd4_removexattr_rsize(struct svc_rqst *rqstp,
2815 struct nfsd4_op *op)
2816{
2817 return (op_encode_hdr_size + op_encode_change_info_maxsz)
2818 * sizeof(__be32);
2819}
2820
2821
bb2a8b0c 2822static const struct nfsd4_operation nfsd4_ops[] = {
b591480b 2823 [OP_ACCESS] = {
eb69853d 2824 .op_func = nfsd4_access,
b001a1b6 2825 .op_name = "OP_ACCESS",
1c122638 2826 .op_rsize_bop = nfsd4_access_rsize,
b591480b
BF		 2827 },
2828 [OP_CLOSE] = {
eb69853d 2829 .op_func = nfsd4_close,
58e7b33a 2830 .op_flags = OP_MODIFIES_SOMETHING,
b001a1b6 2831 .op_name = "OP_CLOSE",
1c122638 2832 .op_rsize_bop = nfsd4_status_stateid_rsize,
57832e7b 2833 .op_get_currentstateid = nfsd4_get_closestateid,
b60e9859 2834 .op_set_currentstateid = nfsd4_set_closestateid,
b591480b
BF		 2835 },
2836 [OP_COMMIT] = {
eb69853d 2837 .op_func = nfsd4_commit,
58e7b33a 2838 .op_flags = OP_MODIFIES_SOMETHING,
b001a1b6 2839 .op_name = "OP_COMMIT",
1c122638 2840 .op_rsize_bop = nfsd4_commit_rsize,
b591480b
BF		 2841 },
2842 [OP_CREATE] = {
eb69853d 2843 .op_func = nfsd4_create,
d1471053 2844 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME | OP_CLEAR_STATEID,
b001a1b6 2845 .op_name = "OP_CREATE",
1c122638 2846 .op_rsize_bop = nfsd4_create_rsize,
b591480b
BF		 2847 },
2848 [OP_DELEGRETURN] = {
eb69853d 2849 .op_func = nfsd4_delegreturn,
58e7b33a 2850 .op_flags = OP_MODIFIES_SOMETHING,
b001a1b6 2851 .op_name = "OP_DELEGRETURN",
58e7b33a 2852 .op_rsize_bop = nfsd4_only_status_rsize,
57832e7b 2853 .op_get_currentstateid = nfsd4_get_delegreturnstateid,
b591480b
BF		 2854 },
2855 [OP_GETATTR] = {
eb69853d 2856 .op_func = nfsd4_getattr,
eeac294e 2857 .op_flags = ALLOWED_ON_ABSENT_FS,
b86cef60 2858 .op_rsize_bop = nfsd4_getattr_rsize,
b001a1b6 2859 .op_name = "OP_GETATTR",
b591480b
BF		 2860 },
2861 [OP_GETFH] = {
eb69853d 2862 .op_func = nfsd4_getfh,
b001a1b6 2863 .op_name = "OP_GETFH",
1c122638 2864 .op_rsize_bop = nfsd4_getfh_rsize,
b591480b
BF		 2865 },
2866 [OP_LINK] = {
eb69853d 2867 .op_func = nfsd4_link,
c856694e
BF		 2868 .op_flags = ALLOWED_ON_ABSENT_FS | OP_MODIFIES_SOMETHING
2869 | OP_CACHEME,
b001a1b6 2870 .op_name = "OP_LINK",
1c122638 2871 .op_rsize_bop = nfsd4_link_rsize,
b591480b
BF		 2872 },
2873 [OP_LOCK] = {
eb69853d 2874 .op_func = nfsd4_lock,
b7571e4c
BF		 2875 .op_flags = OP_MODIFIES_SOMETHING |
2876 OP_NONTRIVIAL_ERROR_ENCODE,
b001a1b6 2877 .op_name = "OP_LOCK",
1c122638 2878 .op_rsize_bop = nfsd4_lock_rsize,
b60e9859 2879 .op_set_currentstateid = nfsd4_set_lockstateid,
b591480b
BF		 2880 },
2881 [OP_LOCKT] = {
eb69853d 2882 .op_func = nfsd4_lockt,
b7571e4c 2883 .op_flags = OP_NONTRIVIAL_ERROR_ENCODE,
b001a1b6 2884 .op_name = "OP_LOCKT",
1c122638 2885 .op_rsize_bop = nfsd4_lock_rsize,
b591480b
BF		 2886 },
2887 [OP_LOCKU] = {
eb69853d 2888 .op_func = nfsd4_locku,
58e7b33a 2889 .op_flags = OP_MODIFIES_SOMETHING,
b001a1b6 2890 .op_name = "OP_LOCKU",
1c122638 2891 .op_rsize_bop = nfsd4_status_stateid_rsize,
57832e7b 2892 .op_get_currentstateid = nfsd4_get_lockustateid,
b591480b
BF		 2893 },
2894 [OP_LOOKUP] = {
eb69853d 2895 .op_func = nfsd4_lookup,
d1471053 2896 .op_flags = OP_HANDLES_WRONGSEC | OP_CLEAR_STATEID,
b001a1b6 2897 .op_name = "OP_LOOKUP",
1c122638 2898 .op_rsize_bop = nfsd4_only_status_rsize,
b591480b
BF		 2899 },
2900 [OP_LOOKUPP] = {
eb69853d 2901 .op_func = nfsd4_lookupp,
d1471053 2902 .op_flags = OP_HANDLES_WRONGSEC | OP_CLEAR_STATEID,
b001a1b6 2903 .op_name = "OP_LOOKUPP",
1c122638 2904 .op_rsize_bop = nfsd4_only_status_rsize,
b591480b
BF		 2905 },
2906 [OP_NVERIFY] = {
eb69853d 2907 .op_func = nfsd4_nverify,
b001a1b6 2908 .op_name = "OP_NVERIFY",
1c122638 2909 .op_rsize_bop = nfsd4_only_status_rsize,
b591480b
BF		 2910 },
2911 [OP_OPEN] = {
eb69853d 2912 .op_func = nfsd4_open,
58e7b33a 2913 .op_flags = OP_HANDLES_WRONGSEC | OP_MODIFIES_SOMETHING,
b001a1b6 2914 .op_name = "OP_OPEN",
1c122638 2915 .op_rsize_bop = nfsd4_open_rsize,
b60e9859 2916 .op_set_currentstateid = nfsd4_set_openstateid,
b591480b
BF		 2917 },
2918 [OP_OPEN_CONFIRM] = {
eb69853d 2919 .op_func = nfsd4_open_confirm,
58e7b33a 2920 .op_flags = OP_MODIFIES_SOMETHING,
b001a1b6 2921 .op_name = "OP_OPEN_CONFIRM",
1c122638 2922 .op_rsize_bop = nfsd4_status_stateid_rsize,
b591480b
BF		 2923 },
2924 [OP_OPEN_DOWNGRADE] = {
eb69853d 2925 .op_func = nfsd4_open_downgrade,
58e7b33a 2926 .op_flags = OP_MODIFIES_SOMETHING,
b001a1b6 2927 .op_name = "OP_OPEN_DOWNGRADE",
1c122638 2928 .op_rsize_bop = nfsd4_status_stateid_rsize,
57832e7b 2929 .op_get_currentstateid = nfsd4_get_opendowngradestateid,
b60e9859 2930 .op_set_currentstateid = nfsd4_set_opendowngradestateid,
b591480b
BF		 2931 },
2932 [OP_PUTFH] = {
eb69853d 2933 .op_func = nfsd4_putfh,
68d93184 2934 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
5b648699 2935 | OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID,
b001a1b6 2936 .op_name = "OP_PUTFH",
1c122638 2937 .op_rsize_bop = nfsd4_only_status_rsize,
b591480b 2938 },
eeac294e 2939 [OP_PUTPUBFH] = {
eb69853d 2940 .op_func = nfsd4_putrootfh,
68d93184 2941 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
5b648699 2942 | OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID,
b001a1b6 2943 .op_name = "OP_PUTPUBFH",
1c122638 2944 .op_rsize_bop = nfsd4_only_status_rsize,
eeac294e 2945 },
b591480b 2946 [OP_PUTROOTFH] = {
eb69853d 2947 .op_func = nfsd4_putrootfh,
68d93184 2948 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
5b648699 2949 | OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID,
b001a1b6 2950 .op_name = "OP_PUTROOTFH",
1c122638 2951 .op_rsize_bop = nfsd4_only_status_rsize,
b591480b
BF		 2952 },
2953 [OP_READ] = {
eb69853d 2954 .op_func = nfsd4_read,
34b1744c 2955 .op_release = nfsd4_read_release,
b001a1b6 2956 .op_name = "OP_READ",
1c122638 2957 .op_rsize_bop = nfsd4_read_rsize,
57832e7b 2958 .op_get_currentstateid = nfsd4_get_readstateid,
b591480b
BF		 2959 },
2960 [OP_READDIR] = {
eb69853d 2961 .op_func = nfsd4_readdir,
b001a1b6 2962 .op_name = "OP_READDIR",
1c122638 2963 .op_rsize_bop = nfsd4_readdir_rsize,
b591480b
BF		 2964 },
2965 [OP_READLINK] = {
eb69853d 2966 .op_func = nfsd4_readlink,
b001a1b6 2967 .op_name = "OP_READLINK",
1c122638 2968 .op_rsize_bop = nfsd4_readlink_rsize,
b591480b
BF		 2969 },
2970 [OP_REMOVE] = {
eb69853d 2971 .op_func = nfsd4_remove,
c856694e 2972 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
b001a1b6 2973 .op_name = "OP_REMOVE",
1c122638 2974 .op_rsize_bop = nfsd4_remove_rsize,
b591480b
BF		 2975 },
2976 [OP_RENAME] = {
eb69853d 2977 .op_func = nfsd4_rename,
c856694e 2978 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
58e7b33a 2979 .op_name = "OP_RENAME",
1c122638 2980 .op_rsize_bop = nfsd4_rename_rsize,
b591480b
BF		 2981 },
2982 [OP_RENEW] = {
eb69853d 2983 .op_func = nfsd4_renew,
58e7b33a
MJ		 2984 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2985 | OP_MODIFIES_SOMETHING,
b001a1b6 2986 .op_name = "OP_RENEW",
1c122638 2987 .op_rsize_bop = nfsd4_only_status_rsize,
58e7b33a 2988
b591480b
BF		 2989 },
2990 [OP_RESTOREFH] = {
eb69853d 2991 .op_func = nfsd4_restorefh,
68d93184 2992 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
58e7b33a 2993 | OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING,
b001a1b6 2994 .op_name = "OP_RESTOREFH",
1c122638 2995 .op_rsize_bop = nfsd4_only_status_rsize,
b591480b
BF		 2996 },
2997 [OP_SAVEFH] = {
eb69853d 2998 .op_func = nfsd4_savefh,
58e7b33a 2999 .op_flags = OP_HANDLES_WRONGSEC | OP_MODIFIES_SOMETHING,
b001a1b6 3000 .op_name = "OP_SAVEFH",
1c122638 3001 .op_rsize_bop = nfsd4_only_status_rsize,
b591480b 3002 },
dcb488a3 3003 [OP_SECINFO] = {
eb69853d 3004 .op_func = nfsd4_secinfo,
34b1744c 3005 .op_release = nfsd4_secinfo_release,
68d93184 3006 .op_flags = OP_HANDLES_WRONGSEC,
b001a1b6 3007 .op_name = "OP_SECINFO",
1c122638 3008 .op_rsize_bop = nfsd4_secinfo_rsize,
dcb488a3 3009 },
b591480b 3010 [OP_SETATTR] = {
eb69853d 3011 .op_func = nfsd4_setattr,
b001a1b6 3012 .op_name = "OP_SETATTR",
b7571e4c
BF		 3013 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME
3014 | OP_NONTRIVIAL_ERROR_ENCODE,
1c122638 3015 .op_rsize_bop = nfsd4_setattr_rsize,
57832e7b 3016 .op_get_currentstateid = nfsd4_get_setattrstateid,
b591480b
BF		 3017 },
3018 [OP_SETCLIENTID] = {
eb69853d 3019 .op_func = nfsd4_setclientid,
58e7b33a 3020 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
b7571e4c
BF		 3021 | OP_MODIFIES_SOMETHING | OP_CACHEME
3022 | OP_NONTRIVIAL_ERROR_ENCODE,
b001a1b6 3023 .op_name = "OP_SETCLIENTID",
1c122638 3024 .op_rsize_bop = nfsd4_setclientid_rsize,
b591480b
BF		 3025 },
3026 [OP_SETCLIENTID_CONFIRM] = {
eb69853d 3027 .op_func = nfsd4_setclientid_confirm,
58e7b33a 3028 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
c856694e 3029 | OP_MODIFIES_SOMETHING | OP_CACHEME,
b001a1b6 3030 .op_name = "OP_SETCLIENTID_CONFIRM",
1c122638 3031 .op_rsize_bop = nfsd4_only_status_rsize,
b591480b
BF		 3032 },
3033 [OP_VERIFY] = {
eb69853d 3034 .op_func = nfsd4_verify,
b001a1b6 3035 .op_name = "OP_VERIFY",
1c122638 3036 .op_rsize_bop = nfsd4_only_status_rsize,
b591480b
BF		 3037 },
3038 [OP_WRITE] = {
eb69853d 3039 .op_func = nfsd4_write,
c856694e 3040 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
b001a1b6 3041 .op_name = "OP_WRITE",
1c122638 3042 .op_rsize_bop = nfsd4_write_rsize,
57832e7b 3043 .op_get_currentstateid = nfsd4_get_writestateid,
b591480b
BF		 3044 },
3045 [OP_RELEASE_LOCKOWNER] = {
eb69853d 3046 .op_func = nfsd4_release_lockowner,
58e7b33a
MJ		 3047 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
3048 | OP_MODIFIES_SOMETHING,
b001a1b6 3049 .op_name = "OP_RELEASE_LOCKOWNER",
1c122638 3050 .op_rsize_bop = nfsd4_only_status_rsize,
b591480b 3051 },
069b6ad4
AA		 3052
3053 /* NFSv4.1 operations */
3054 [OP_EXCHANGE_ID] = {
eb69853d 3055 .op_func = nfsd4_exchange_id,
58e7b33a
MJ		 3056 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
3057 | OP_MODIFIES_SOMETHING,
069b6ad4 3058 .op_name = "OP_EXCHANGE_ID",
1c122638 3059 .op_rsize_bop = nfsd4_exchange_id_rsize,
069b6ad4 3060 },
cb73a9f4 3061 [OP_BACKCHANNEL_CTL] = {
eb69853d 3062 .op_func = nfsd4_backchannel_ctl,
cb73a9f4
BF		 3063 .op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING,
3064 .op_name = "OP_BACKCHANNEL_CTL",
1c122638 3065 .op_rsize_bop = nfsd4_only_status_rsize,
cb73a9f4 3066 },
1d1bc8f2 3067 [OP_BIND_CONN_TO_SESSION] = {
eb69853d 3068 .op_func = nfsd4_bind_conn_to_session,
58e7b33a
MJ		 3069 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
3070 | OP_MODIFIES_SOMETHING,
1d1bc8f2 3071 .op_name = "OP_BIND_CONN_TO_SESSION",
1c122638 3072 .op_rsize_bop = nfsd4_bind_conn_to_session_rsize,
1d1bc8f2 3073 },
069b6ad4 3074 [OP_CREATE_SESSION] = {
eb69853d 3075 .op_func = nfsd4_create_session,
58e7b33a
MJ		 3076 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
3077 | OP_MODIFIES_SOMETHING,
069b6ad4 3078 .op_name = "OP_CREATE_SESSION",
1c122638 3079 .op_rsize_bop = nfsd4_create_session_rsize,
069b6ad4
AA		 3080 },
3081 [OP_DESTROY_SESSION] = {
eb69853d 3082 .op_func = nfsd4_destroy_session,
58e7b33a
MJ		 3083 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
3084 | OP_MODIFIES_SOMETHING,
069b6ad4 3085 .op_name = "OP_DESTROY_SESSION",
1c122638 3086 .op_rsize_bop = nfsd4_only_status_rsize,
069b6ad4
AA		 3087 },
3088 [OP_SEQUENCE] = {
eb69853d 3089 .op_func = nfsd4_sequence,
f9bb94c4 3090 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP,
069b6ad4 3091 .op_name = "OP_SEQUENCE",
1c122638 3092 .op_rsize_bop = nfsd4_sequence_rsize,
069b6ad4 3093 },
094b5d74 3094 [OP_DESTROY_CLIENTID] = {
eb69853d 3095 .op_func = nfsd4_destroy_clientid,
58e7b33a
MJ		 3096 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
3097 | OP_MODIFIES_SOMETHING,
094b5d74 3098 .op_name = "OP_DESTROY_CLIENTID",
1c122638 3099 .op_rsize_bop = nfsd4_only_status_rsize,
094b5d74 3100 },
4dc6ec00 3101 [OP_RECLAIM_COMPLETE] = {
eb69853d 3102 .op_func = nfsd4_reclaim_complete,
58e7b33a 3103 .op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING,
4dc6ec00 3104 .op_name = "OP_RECLAIM_COMPLETE",
1c122638 3105 .op_rsize_bop = nfsd4_only_status_rsize,
4dc6ec00 3106 },
04f4ad16 3107 [OP_SECINFO_NO_NAME] = {
eb69853d 3108 .op_func = nfsd4_secinfo_no_name,
ec572b9e 3109 .op_release = nfsd4_secinfo_no_name_release,
68d93184 3110 .op_flags = OP_HANDLES_WRONGSEC,
04f4ad16 3111 .op_name = "OP_SECINFO_NO_NAME",
1c122638 3112 .op_rsize_bop = nfsd4_secinfo_rsize,
04f4ad16 3113 },
17456804 3114 [OP_TEST_STATEID] = {
eb69853d 3115 .op_func = nfsd4_test_stateid,
17456804
BS		 3116 .op_flags = ALLOWED_WITHOUT_FH,
3117 .op_name = "OP_TEST_STATEID",
1c122638 3118 .op_rsize_bop = nfsd4_test_stateid_rsize,
17456804 3119 },
e1ca12df 3120 [OP_FREE_STATEID] = {
eb69853d 3121 .op_func = nfsd4_free_stateid,
58e7b33a 3122 .op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING,
e1ca12df 3123 .op_name = "OP_FREE_STATEID",
57832e7b 3124 .op_get_currentstateid = nfsd4_get_freestateid,
1c122638 3125 .op_rsize_bop = nfsd4_only_status_rsize,
e1ca12df 3126 },
9cf514cc
CH		 3127#ifdef CONFIG_NFSD_PNFS
3128 [OP_GETDEVICEINFO] = {
eb69853d 3129 .op_func = nfsd4_getdeviceinfo,
34b1744c 3130 .op_release = nfsd4_getdeviceinfo_release,
9cf514cc
CH		 3131 .op_flags = ALLOWED_WITHOUT_FH,
3132 .op_name = "OP_GETDEVICEINFO",
1c122638 3133 .op_rsize_bop = nfsd4_getdeviceinfo_rsize,
9cf514cc
CH		 3134 },
3135 [OP_LAYOUTGET] = {
eb69853d 3136 .op_func = nfsd4_layoutget,
34b1744c 3137 .op_release = nfsd4_layoutget_release,
9cf514cc
CH		 3138 .op_flags = OP_MODIFIES_SOMETHING,
3139 .op_name = "OP_LAYOUTGET",
1c122638 3140 .op_rsize_bop = nfsd4_layoutget_rsize,
9cf514cc
CH		 3141 },
3142 [OP_LAYOUTCOMMIT] = {
eb69853d 3143 .op_func = nfsd4_layoutcommit,
9cf514cc
CH		 3144 .op_flags = OP_MODIFIES_SOMETHING,
3145 .op_name = "OP_LAYOUTCOMMIT",
1c122638 3146 .op_rsize_bop = nfsd4_layoutcommit_rsize,
9cf514cc
CH		 3147 },
3148 [OP_LAYOUTRETURN] = {
eb69853d 3149 .op_func = nfsd4_layoutreturn,
9cf514cc
CH		 3150 .op_flags = OP_MODIFIES_SOMETHING,
3151 .op_name = "OP_LAYOUTRETURN",
1c122638 3152 .op_rsize_bop = nfsd4_layoutreturn_rsize,
9cf514cc
CH		 3153 },
3154#endif /* CONFIG_NFSD_PNFS */
24bab491
AS		 3155
3156 /* NFSv4.2 operations */
95d871f0 3157 [OP_ALLOCATE] = {
eb69853d 3158 .op_func = nfsd4_allocate,
03b31f48 3159 .op_flags = OP_MODIFIES_SOMETHING,
95d871f0 3160 .op_name = "OP_ALLOCATE",
1c122638 3161 .op_rsize_bop = nfsd4_only_status_rsize,
95d871f0 3162 },
b0cb9085 3163 [OP_DEALLOCATE] = {
eb69853d 3164 .op_func = nfsd4_deallocate,
03b31f48 3165 .op_flags = OP_MODIFIES_SOMETHING,
b0cb9085 3166 .op_name = "OP_DEALLOCATE",
1c122638 3167 .op_rsize_bop = nfsd4_only_status_rsize,
b0cb9085 3168 },
ffa0160a 3169 [OP_CLONE] = {
eb69853d 3170 .op_func = nfsd4_clone,
03b31f48 3171 .op_flags = OP_MODIFIES_SOMETHING,
ffa0160a 3172 .op_name = "OP_CLONE",
1c122638 3173 .op_rsize_bop = nfsd4_only_status_rsize,
ffa0160a 3174 },
29ae7f9d 3175 [OP_COPY] = {
eb69853d 3176 .op_func = nfsd4_copy,
03b31f48 3177 .op_flags = OP_MODIFIES_SOMETHING,
29ae7f9d 3178 .op_name = "OP_COPY",
1c122638 3179 .op_rsize_bop = nfsd4_copy_rsize,
29ae7f9d 3180 },
528b8493
AS		 3181 [OP_READ_PLUS] = {
3182 .op_func = nfsd4_read,
3183 .op_release = nfsd4_read_release,
3184 .op_name = "OP_READ_PLUS",
3185 .op_rsize_bop = nfsd4_read_plus_rsize,
3186 .op_get_currentstateid = nfsd4_get_readstateid,
3187 },
24bab491 3188 [OP_SEEK] = {
eb69853d 3189 .op_func = nfsd4_seek,
24bab491 3190 .op_name = "OP_SEEK",
1c122638 3191 .op_rsize_bop = nfsd4_seek_rsize,
24bab491 3192 },
6308bc98
OK		 3193 [OP_OFFLOAD_STATUS] = {
3194 .op_func = nfsd4_offload_status,
3195 .op_name = "OP_OFFLOAD_STATUS",
3196 .op_rsize_bop = nfsd4_offload_status_rsize,
3197 },
885e2bf3
OK		 3198 [OP_OFFLOAD_CANCEL] = {
3199 .op_func = nfsd4_offload_cancel,
3200 .op_flags = OP_MODIFIES_SOMETHING,
3201 .op_name = "OP_OFFLOAD_CANCEL",
3202 .op_rsize_bop = nfsd4_only_status_rsize,
3203 },
51911868
OK		 3204 [OP_COPY_NOTIFY] = {
3205 .op_func = nfsd4_copy_notify,
3206 .op_flags = OP_MODIFIES_SOMETHING,
3207 .op_name = "OP_COPY_NOTIFY",
3208 .op_rsize_bop = nfsd4_copy_notify_rsize,
3209 },
23e50fe3
FL		 3210 [OP_GETXATTR] = {
3211 .op_func = nfsd4_getxattr,
3212 .op_name = "OP_GETXATTR",
3213 .op_rsize_bop = nfsd4_getxattr_rsize,
3214 },
3215 [OP_SETXATTR] = {
3216 .op_func = nfsd4_setxattr,
3217 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
3218 .op_name = "OP_SETXATTR",
3219 .op_rsize_bop = nfsd4_setxattr_rsize,
3220 },
3221 [OP_LISTXATTRS] = {
3222 .op_func = nfsd4_listxattrs,
3223 .op_name = "OP_LISTXATTRS",
3224 .op_rsize_bop = nfsd4_listxattrs_rsize,
3225 },
3226 [OP_REMOVEXATTR] = {
3227 .op_func = nfsd4_removexattr,
3228 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
3229 .op_name = "OP_REMOVEXATTR",
3230 .op_rsize_bop = nfsd4_removexattr_rsize,
3231 },
b591480b
BF		 3232};
3233
ed941643
AE		 3234/**
3235 * nfsd4_spo_must_allow - Determine if the compound op contains an
3236 * operation that is allowed to be sent with machine credentials
3237 *
3238 * @rqstp: a pointer to the struct svc_rqst
3239 *
3240 * Checks to see if the compound contains a spo_must_allow op
3241 * and confirms that it was sent with the proper machine creds.
3242 */
3243
3244bool nfsd4_spo_must_allow(struct svc_rqst *rqstp)
3245{
3246 struct nfsd4_compoundres *resp = rqstp->rq_resp;
3247 struct nfsd4_compoundargs *argp = rqstp->rq_argp;
3248 struct nfsd4_op *this = &argp->ops[resp->opcnt - 1];
3249 struct nfsd4_compound_state *cstate = &resp->cstate;
3250 struct nfs4_op_map *allow = &cstate->clp->cl_spo_must_allow;
3251 u32 opiter;
3252
3253 if (!cstate->minorversion)
3254 return false;
3255
44b49aa6 3256 if (cstate->spo_must_allowed)
ed941643
AE		 3257 return true;
3258
3259 opiter = resp->opcnt;
3260 while (opiter < argp->opcnt) {
3261 this = &argp->ops[opiter++];
3262 if (test_bit(this->opnum, allow->u.longs) &&
3263 cstate->clp->cl_mach_cred &&
3264 nfsd4_mach_creds_match(cstate->clp, rqstp)) {
3265 cstate->spo_must_allowed = true;
3266 return true;
3267 }
3268 }
3269 cstate->spo_must_allowed = false;
3270 return false;
3271}
3272
4f0cefbf
BF		 3273int nfsd4_max_reply(struct svc_rqst *rqstp, struct nfsd4_op *op)
3274{
05b7278d 3275 if (op->opnum == OP_ILLEGAL || op->status == nfserr_notsupp)
4f0cefbf 3276 return op_encode_hdr_size * sizeof(__be32);
2282cd2c
KM		 3277
3278 BUG_ON(OPDESC(op)->op_rsize_bop == NULL);
3279 return OPDESC(op)->op_rsize_bop(rqstp, op);
4f0cefbf
BF		 3280}
3281
07d1f802
BF		 3282void warn_on_nonidempotent_op(struct nfsd4_op *op)
3283{
3284 if (OPDESC(op)->op_flags & OP_MODIFIES_SOMETHING) {
3a237b4a 3285 pr_err("unable to encode reply to nonidempotent op %u (%s)\n",
07d1f802
BF		 3286 op->opnum, nfsd4_op_name(op->opnum));
3287 WARN_ON_ONCE(1);
3288 }
3289}
3290
f1c7f79b 3291static const char *nfsd4_op_name(unsigned opnum)
b001a1b6
BH		 3292{
3293 if (opnum < ARRAY_SIZE(nfsd4_ops))
3294 return nfsd4_ops[opnum].op_name;
3295 return "unknown_operation";
3296}
3297
860bda29 3298static const struct svc_procedure nfsd_procedures4[2] = {
0a93a47f 3299 [NFSPROC4_NULL] = {
f7235b6b 3300 .pc_func = nfsd4_proc_null,
788f7183
CL		 3301 .pc_decode = nfssvc_decode_voidarg,
3302 .pc_encode = nfssvc_encode_voidres,
3303 .pc_argsize = sizeof(struct nfsd_voidargs),
3304 .pc_ressize = sizeof(struct nfsd_voidres),
0a93a47f
YZ		 3305 .pc_cachetype = RC_NOCACHE,
3306 .pc_xdrressize = 1,
2289e87b 3307 .pc_name = "NULL",
0a93a47f
YZ		 3308 },
3309 [NFSPROC4_COMPOUND] = {
f7235b6b 3310 .pc_func = nfsd4_proc_compound,
026fec7e 3311 .pc_decode = nfs4svc_decode_compoundargs,
63f8de37 3312 .pc_encode = nfs4svc_encode_compoundres,
0a93a47f
YZ		 3313 .pc_argsize = sizeof(struct nfsd4_compoundargs),
3314 .pc_ressize = sizeof(struct nfsd4_compoundres),
3e98abff 3315 .pc_release = nfsd4_release_compoundargs,
0a93a47f
YZ		 3316 .pc_cachetype = RC_NOCACHE,
3317 .pc_xdrressize = NFSD_BUFSIZE/4,
2289e87b 3318 .pc_name = "COMPOUND",
0a93a47f 3319 },
1da177e4
LT		 3320};
3321
7fd38af9 3322static unsigned int nfsd_count3[ARRAY_SIZE(nfsd_procedures4)];
e9679189 3323const struct svc_version nfsd_version4 = {
5283b03e
JL		 3324 .vs_vers = 4,
3325 .vs_nproc = 2,
3326 .vs_proc = nfsd_procedures4,
7fd38af9 3327 .vs_count = nfsd_count3,
5283b03e
JL		 3328 .vs_dispatch = nfsd_dispatch,
3329 .vs_xdrsize = NFS4_SVC_XDRSIZE,
3330 .vs_rpcb_optnl = true,
3331 .vs_need_cong_ctrl = true,
1da177e4
LT		 3332};
3333
3334/*
3335 * Local variables:
3336 * c-basic-offset: 8
3337 * End:
3338 */
Michael's Linux tree.