]> 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: Replace READ* macros in nfsd4_decode_share_deny()
[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
18032ca0
DQ		 53#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
54#include <linux/security.h>
55
56static inline void
57nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct xdr_netobj *label, u32 *bmval)
58{
2b0143b5 59 struct inode *inode = d_inode(resfh->fh_dentry);
18032ca0
DQ		 60 int status;
61
5955102c 62 inode_lock(inode);
18032ca0
DQ		 63 status = security_inode_setsecctx(resfh->fh_dentry,
64 label->data, label->len);
5955102c 65 inode_unlock(inode);
18032ca0
DQ		 66
67 if (status)
68 /*
69 * XXX: We should really fail the whole open, but we may
70 * already have created a new file, so it may be too
71 * late. For now this seems the least of evils:
72 */
73 bmval[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
74
75 return;
76}
77#else
78static inline void
79nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct xdr_netobj *label, u32 *bmval)
80{ }
81#endif
82
1da177e4
LT		 83#define NFSDDBG_FACILITY NFSDDBG_PROC
84
3c8e0316
YZ		 85static u32 nfsd_attrmask[] = {
86 NFSD_WRITEABLE_ATTRS_WORD0,
87 NFSD_WRITEABLE_ATTRS_WORD1,
88 NFSD_WRITEABLE_ATTRS_WORD2
89};
90
91static u32 nfsd41_ex_attrmask[] = {
92 NFSD_SUPPATTR_EXCLCREAT_WORD0,
93 NFSD_SUPPATTR_EXCLCREAT_WORD1,
94 NFSD_SUPPATTR_EXCLCREAT_WORD2
95};
96
97static __be32
98check_attr_support(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
99 u32 *bmval, u32 *writable)
100{
101 struct dentry *dentry = cstate->current_fh.fh_dentry;
32ddd944 102 struct svc_export *exp = cstate->current_fh.fh_export;
3c8e0316 103
916d2d84 104 if (!nfsd_attrs_supported(cstate->minorversion, bmval))
3c8e0316 105 return nfserr_attrnotsupp;
916d2d84
BF		 106 if ((bmval[0] & FATTR4_WORD0_ACL) && !IS_POSIXACL(d_inode(dentry)))
107 return nfserr_attrnotsupp;
32ddd944
BF		 108 if ((bmval[2] & FATTR4_WORD2_SECURITY_LABEL) &&
109 !(exp->ex_flags & NFSEXP_SECURITY_LABEL))
110 return nfserr_attrnotsupp;
916d2d84
BF		 111 if (writable && !bmval_is_subset(bmval, writable))
112 return nfserr_inval;
47057abd
AG		 113 if (writable && (bmval[2] & FATTR4_WORD2_MODE_UMASK) &&
114 (bmval[1] & FATTR4_WORD1_MODE))
115 return nfserr_inval;
3c8e0316
YZ		 116 return nfs_ok;
117}
118
119static __be32
120nfsd4_check_open_attributes(struct svc_rqst *rqstp,
121 struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
122{
123 __be32 status = nfs_ok;
124
125 if (open->op_create == NFS4_OPEN_CREATE) {
126 if (open->op_createmode == NFS4_CREATE_UNCHECKED
127 || open->op_createmode == NFS4_CREATE_GUARDED)
128 status = check_attr_support(rqstp, cstate,
129 open->op_bmval, nfsd_attrmask);
130 else if (open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1)
131 status = check_attr_support(rqstp, cstate,
132 open->op_bmval, nfsd41_ex_attrmask);
133 }
134
135 return status;
136}
137
9208faf2
YZ		 138static int
139is_create_with_attrs(struct nfsd4_open *open)
140{
141 return open->op_create == NFS4_OPEN_CREATE
142 && (open->op_createmode == NFS4_CREATE_UNCHECKED
143 || open->op_createmode == NFS4_CREATE_GUARDED
144 || open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1);
145}
146
147/*
148 * if error occurs when setting the acl, just clear the acl bit
149 * in the returned attr bitmap.
150 */
151static void
152do_set_nfs4_acl(struct svc_rqst *rqstp, struct svc_fh *fhp,
153 struct nfs4_acl *acl, u32 *bmval)
154{
155 __be32 status;
156
157 status = nfsd4_set_nfs4_acl(rqstp, fhp, acl);
158 if (status)
159 /*
160 * We should probably fail the whole open at this point,
161 * but we've already created the file, so it's too late;
162 * So this seems the least of evils:
163 */
164 bmval[0] &= ~FATTR4_WORD0_ACL;
165}
166
1da177e4
LT		 167static inline void
168fh_dup2(struct svc_fh *dst, struct svc_fh *src)
169{
170 fh_put(dst);
171 dget(src->fh_dentry);
172 if (src->fh_export)
bf18f163 173 exp_get(src->fh_export);
1da177e4
LT		 174 *dst = *src;
175}
176
b37ad28b 177static __be32
dc730e17 178do_open_permission(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open, int accmode)
1da177e4 179{
b37ad28b 180 __be32 status;
1da177e4
LT		 181
182 if (open->op_truncate &&
183 !(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
184 return nfserr_inval;
185
a043226b
BF		 186 accmode |= NFSD_MAY_READ_IF_EXEC;
187
1da177e4 188 if (open->op_share_access & NFS4_SHARE_ACCESS_READ)
8837abca 189 accmode |= NFSD_MAY_READ;
9801d8a3 190 if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
8837abca 191 accmode |= (NFSD_MAY_WRITE | NFSD_MAY_TRUNC);
57ecb34f 192 if (open->op_share_deny & NFS4_SHARE_DENY_READ)
8837abca 193 accmode |= NFSD_MAY_WRITE;
1da177e4
LT		 194
195 status = fh_verify(rqstp, current_fh, S_IFREG, accmode);
196
197 return status;
198}
199
aadab6c6
BF		 200static __be32 nfsd_check_obj_isreg(struct svc_fh *fh)
201{
2b0143b5 202 umode_t mode = d_inode(fh->fh_dentry)->i_mode;
aadab6c6
BF		 203
204 if (S_ISREG(mode))
205 return nfs_ok;
206 if (S_ISDIR(mode))
207 return nfserr_isdir;
208 /*
209 * Using err_symlink as our catch-all case may look odd; but
210 * there's no other obvious error for this case in 4.0, and we
211 * happen to know that it will cause the linux v4 client to do
212 * the right thing on attempts to open something other than a
213 * regular file.
214 */
215 return nfserr_symlink;
216}
217
bbc9c36c
BF		 218static void nfsd4_set_open_owner_reply_cache(struct nfsd4_compound_state *cstate, struct nfsd4_open *open, struct svc_fh *resfh)
219{
220 if (nfsd4_has_session(cstate))
221 return;
222 fh_copy_shallow(&open->op_openowner->oo_owner.so_replay.rp_openfh,
223 &resfh->fh_handle);
224}
225
b37ad28b 226static __be32
c0e6bee4 227do_open_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_open *open, struct svc_fh **resfh)
1da177e4 228{
bbc9c36c 229 struct svc_fh *current_fh = &cstate->current_fh;
7007c90f 230 int accmode;
b37ad28b 231 __be32 status;
1da177e4 232
c0e6bee4
BF		 233 *resfh = kmalloc(sizeof(struct svc_fh), GFP_KERNEL);
234 if (!*resfh)
59deeb9e 235 return nfserr_jukebox;
c0e6bee4 236 fh_init(*resfh, NFS4_FHSIZE);
500c2481 237 open->op_truncate = false;
1da177e4
LT		 238
239 if (open->op_create) {
79fb54ab
BH		 240 /* FIXME: check session persistence and pnfs flags.
241 * The nfsv4.1 spec requires the following semantics:
242 *
243 * Persistent | pNFS | Server REQUIRED | Client Allowed
244 * Reply Cache | server | |
245 * -------------+--------+-----------------+--------------------
246 * no | no | EXCLUSIVE4_1 | EXCLUSIVE4_1
247 * | | | (SHOULD)
248 * | | and EXCLUSIVE4 | or EXCLUSIVE4
249 * | | | (SHOULD NOT)
250 * no | yes | EXCLUSIVE4_1 | EXCLUSIVE4_1
251 * yes | no | GUARDED4 | GUARDED4
252 * yes | yes | GUARDED4 | GUARDED4
253 */
254
1da177e4
LT		 255 /*
256 * Note: create modes (UNCHECKED,GUARDED...) are the same
ac6721a1 257 * in NFSv4 as in v3 except EXCLUSIVE4_1.
1da177e4 258 */
880a3a53 259 current->fs->umask = open->op_umask;
ac6721a1 260 status = do_nfsd_create(rqstp, current_fh, open->op_fname.data,
1da177e4 261 open->op_fname.len, &open->op_iattr,
c0e6bee4 262 *resfh, open->op_createmode,
749997e5 263 (u32 *)open->op_verf.data,
856121b2 264 &open->op_truncate, &open->op_created);
880a3a53 265 current->fs->umask = 0;
749997e5 266
18032ca0 267 if (!status && open->op_label.len)
c0e6bee4 268 nfsd4_security_inode_setsecctx(*resfh, &open->op_label, open->op_bmval);
18032ca0 269
99f88726 270 /*
ead8fb8c
KM		 271 * Following rfc 3530 14.2.16, and rfc 5661 18.16.4
272 * use the returned bitmask to indicate which attributes
273 * we used to store the verifier:
749997e5 274 */
ead8fb8c
KM		 275 if (nfsd_create_is_exclusive(open->op_createmode) && status == 0)
276 open->op_bmval[1] |= (FATTR4_WORD1_TIME_ACCESS |
277 FATTR4_WORD1_TIME_MODIFY);
4335723e
BF		 278 } else
279 /*
280 * Note this may exit with the parent still locked.
281 * We will hold the lock until nfsd4_open's final
282 * lookup, to prevent renames or unlinks until we've had
283 * a chance to an acquire a delegation if appropriate.
284 */
1da177e4 285 status = nfsd_lookup(rqstp, current_fh,
c0e6bee4 286 open->op_fname.data, open->op_fname.len, *resfh);
9dc4e6c4
BF		 287 if (status)
288 goto out;
c0e6bee4 289 status = nfsd_check_obj_isreg(*resfh);
af85852d
BF		 290 if (status)
291 goto out;
1da177e4 292
9208faf2 293 if (is_create_with_attrs(open) && open->op_acl != NULL)
c0e6bee4 294 do_set_nfs4_acl(rqstp, *resfh, open->op_acl, open->op_bmval);
9208faf2 295
c0e6bee4 296 nfsd4_set_open_owner_reply_cache(cstate, open, *resfh);
7007c90f 297 accmode = NFSD_MAY_NOP;
89f6c336
BF		 298 if (open->op_created ||
299 open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR)
7007c90f 300 accmode |= NFSD_MAY_OWNER_OVERRIDE;
c0e6bee4 301 status = do_open_permission(rqstp, *resfh, open, accmode);
41fd1e42 302 set_change_info(&open->op_cinfo, current_fh);
af85852d 303out:
1da177e4
LT		 304 return status;
305}
306
b37ad28b 307static __be32
bbc9c36c 308do_open_fhandle(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
1da177e4 309{
bbc9c36c 310 struct svc_fh *current_fh = &cstate->current_fh;
b37ad28b 311 __be32 status;
9f415eb2 312 int accmode = 0;
1da177e4 313
1da177e4
LT		 314 /* We don't know the target directory, and therefore can not
315 * set the change info
316 */
317
318 memset(&open->op_cinfo, 0, sizeof(struct nfsd4_change_info));
319
bbc9c36c 320 nfsd4_set_open_owner_reply_cache(cstate, open, current_fh);
1da177e4
LT		 321
322 open->op_truncate = (open->op_iattr.ia_valid & ATTR_SIZE) &&
323 (open->op_iattr.ia_size == 0);
9f415eb2
BF		 324 /*
325 * In the delegation case, the client is telling us about an
326 * open that it *already* performed locally, some time ago. We
327 * should let it succeed now if possible.
328 *
329 * In the case of a CLAIM_FH open, on the other hand, the client
330 * may be counting on us to enforce permissions (the Linux 4.1
331 * client uses this for normal opens, for example).
332 */
333 if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH)
334 accmode = NFSD_MAY_OWNER_OVERRIDE;
1da177e4 335
9f415eb2 336 status = do_open_permission(rqstp, current_fh, open, accmode);
1da177e4
LT		 337
338 return status;
339}
340
60adfc50
AA		 341static void
342copy_clientid(clientid_t *clid, struct nfsd4_session *session)
343{
344 struct nfsd4_sessionid *sid =
345 (struct nfsd4_sessionid *)session->se_sessionid.data;
346
347 clid->cl_boot = sid->clientid.cl_boot;
348 clid->cl_id = sid->clientid.cl_id;
349}
1da177e4 350
7191155b 351static __be32
ca364317 352nfsd4_open(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 353 union nfsd4_op_u *u)
1da177e4 354{
eb69853d 355 struct nfsd4_open *open = &u->open;
b37ad28b 356 __be32 status;
c0e6bee4 357 struct svc_fh *resfh = NULL;
3320fef1
SK		 358 struct net *net = SVC_NET(rqstp);
359 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
03f318ca 360 bool reclaim = false;
6668958f 361
fe0750e5 362 dprintk("NFSD: nfsd4_open filename %.*s op_openowner %p\n",
1da177e4 363 (int)open->op_fname.len, open->op_fname.data,
fe0750e5 364 open->op_openowner);
1da177e4 365
1da177e4
LT		 366 /* This check required by spec. */
367 if (open->op_create && open->op_claim_type != NFS4_OPEN_CLAIM_NULL)
368 return nfserr_inval;
369
500c2481 370 open->op_created = false;
ab1350b2
MJ		 371 /*
372 * RFC5661 18.51.3
373 * Before RECLAIM_COMPLETE done, server should deny new lock
374 */
375 if (nfsd4_has_session(cstate) &&
a52d726b
JL		 376 !test_bit(NFSD4_CLIENT_RECLAIM_COMPLETE,
377 &cstate->session->se_client->cl_flags) &&
ab1350b2
MJ		 378 open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS)
379 return nfserr_grace;
380
60adfc50
AA		 381 if (nfsd4_has_session(cstate))
382 copy_clientid(&open->op_clientid, cstate->session);
383
1da177e4 384 /* check seqid for replay. set nfs4_owner */
6cd22668 385 status = nfsd4_process_open1(cstate, open, nn);
a90b061c 386 if (status == nfserr_replay_me) {
fe0750e5 387 struct nfs4_replay *rp = &open->op_openowner->oo_owner.so_replay;
ca364317 388 fh_put(&cstate->current_fh);
a4773c08
BF		 389 fh_copy_shallow(&cstate->current_fh.fh_handle,
390 &rp->rp_openfh);
8837abca 391 status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
1da177e4
LT		 392 if (status)
393 dprintk("nfsd4_open: replay failed"
394 " restoring previous filehandle\n");
395 else
a90b061c 396 status = nfserr_replay_me;
1da177e4
LT		 397 }
398 if (status)
399 goto out;
9d313b17
BF		 400 if (open->op_xdr_error) {
401 status = open->op_xdr_error;
402 goto out;
403 }
fb553c0f 404
3c8e0316
YZ		 405 status = nfsd4_check_open_attributes(rqstp, cstate, open);
406 if (status)
407 goto out;
408
fb553c0f
BF		 409 /* Openowner is now set, so sequence id will get bumped. Now we need
410 * these checks before we do any creates: */
cbd0d51a 411 status = nfserr_grace;
c87fb4a3 412 if (opens_in_grace(net) && open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS)
cbd0d51a
BF		 413 goto out;
414 status = nfserr_no_grace;
c87fb4a3 415 if (!opens_in_grace(net) && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
cbd0d51a 416 goto out;
fb553c0f 417
1da177e4 418 switch (open->op_claim_type) {
0dd3c192 419 case NFS4_OPEN_CLAIM_DELEGATE_CUR:
1da177e4 420 case NFS4_OPEN_CLAIM_NULL:
c0e6bee4 421 status = do_open_lookup(rqstp, cstate, open, &resfh);
1da177e4
LT		 422 if (status)
423 goto out;
424 break;
425 case NFS4_OPEN_CLAIM_PREVIOUS:
3320fef1 426 status = nfs4_check_open_reclaim(&open->op_clientid,
0fe492db 427 cstate, nn);
0cf99b91
MJ		 428 if (status)
429 goto out;
ba5378b6 430 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
03f318ca 431 reclaim = true;
df561f66 432 fallthrough;
8b289b2c
BF		 433 case NFS4_OPEN_CLAIM_FH:
434 case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
bbc9c36c 435 status = do_open_fhandle(rqstp, cstate, open);
1da177e4
LT		 436 if (status)
437 goto out;
c0e6bee4 438 resfh = &cstate->current_fh;
1da177e4 439 break;
8b289b2c 440 case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
1da177e4 441 case NFS4_OPEN_CLAIM_DELEGATE_PREV:
2fdada03 442 dprintk("NFSD: unsupported OPEN claim type %d\n",
1da177e4
LT		 443 open->op_claim_type);
444 status = nfserr_notsupp;
445 goto out;
446 default:
2fdada03 447 dprintk("NFSD: Invalid OPEN claim type %d\n",
1da177e4
LT		 448 open->op_claim_type);
449 status = nfserr_inval;
450 goto out;
451 }
452 /*
453 * nfsd4_process_open2() does the actual opening of the file. If
454 * successful, it (1) truncates the file if open->op_truncate was
455 * set, (2) sets open->op_stateid, (3) sets open->op_delegation.
456 */
c0e6bee4 457 status = nfsd4_process_open2(rqstp, resfh, open);
b3fbfe0e
JL		 458 WARN(status && open->op_created,
459 "nfsd4_process_open2 failed to open newly-created file! status=%u\n",
460 be32_to_cpu(status));
03f318ca
BF		 461 if (reclaim && !status)
462 nn->somebody_reclaimed = true;
1da177e4 463out:
c0e6bee4
BF		 464 if (resfh && resfh != &cstate->current_fh) {
465 fh_dup2(&cstate->current_fh, resfh);
466 fh_put(resfh);
467 kfree(resfh);
468 }
42297899 469 nfsd4_cleanup_open_state(cstate, open);
9411b1d4 470 nfsd4_bump_seqid(cstate, status);
1da177e4
LT		 471 return status;
472}
473
9d313b17
BF		 474/*
475 * OPEN is the only seqid-mutating operation whose decoding can fail
476 * with a seqid-mutating error (specifically, decoding of user names in
477 * the attributes). Therefore we have to do some processing to look up
478 * the stateowner so that we can bump the seqid.
479 */
480static __be32 nfsd4_open_omfg(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_op *op)
481{
eb69853d 482 struct nfsd4_open *open = &op->u.open;
9d313b17
BF		 483
484 if (!seqid_mutating_err(ntohl(op->status)))
485 return op->status;
486 if (nfsd4_has_session(cstate))
487 return op->status;
488 open->op_xdr_error = op->status;
eb69853d 489 return nfsd4_open(rqstp, cstate, &op->u);
9d313b17
BF		 490}
491
1da177e4
LT		 492/*
493 * filehandle-manipulating ops.
494 */
7191155b 495static __be32
b591480b 496nfsd4_getfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 497 union nfsd4_op_u *u)
1da177e4 498{
eb69853d 499 u->getfh = &cstate->current_fh;
1da177e4
LT		 500 return nfs_ok;
501}
502
7191155b 503static __be32
ca364317 504nfsd4_putfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 505 union nfsd4_op_u *u)
1da177e4 506{
eb69853d 507 struct nfsd4_putfh *putfh = &u->putfh;
b9e8638e 508 __be32 ret;
eb69853d 509
ca364317
BF		 510 fh_put(&cstate->current_fh);
511 cstate->current_fh.fh_handle.fh_size = putfh->pf_fhlen;
512 memcpy(&cstate->current_fh.fh_handle.fh_base, putfh->pf_fhval,
513 putfh->pf_fhlen);
b9e8638e
OK		 514 ret = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_BYPASS_GSS);
515#ifdef CONFIG_NFSD_V4_2_INTER_SSC
516 if (ret == nfserr_stale && putfh->no_verify) {
517 SET_FH_FLAG(&cstate->current_fh, NFSD4_FH_FOREIGN);
518 ret = 0;
519 }
520#endif
521 return ret;
1da177e4
LT		 522}
523
7191155b 524static __be32
b591480b 525nfsd4_putrootfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 526 union nfsd4_op_u *u)
1da177e4 527{
b37ad28b 528 __be32 status;
1da177e4 529
ca364317 530 fh_put(&cstate->current_fh);
df547efb 531 status = exp_pseudoroot(rqstp, &cstate->current_fh);
1da177e4
LT		 532 return status;
533}
534
7191155b 535static __be32
b591480b 536nfsd4_restorefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 537 union nfsd4_op_u *u)
1da177e4 538{
ca364317 539 if (!cstate->save_fh.fh_dentry)
1da177e4
LT		 540 return nfserr_restorefh;
541
ca364317 542 fh_dup2(&cstate->current_fh, &cstate->save_fh);
51100d2b 543 if (HAS_CSTATE_FLAG(cstate, SAVED_STATE_ID_FLAG)) {
37c593c5 544 memcpy(&cstate->current_stateid, &cstate->save_stateid, sizeof(stateid_t));
51100d2b 545 SET_CSTATE_FLAG(cstate, CURRENT_STATE_ID_FLAG);
37c593c5 546 }
1da177e4
LT		 547 return nfs_ok;
548}
549
7191155b 550static __be32
b591480b 551nfsd4_savefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 552 union nfsd4_op_u *u)
1da177e4 553{
ca364317 554 fh_dup2(&cstate->save_fh, &cstate->current_fh);
51100d2b 555 if (HAS_CSTATE_FLAG(cstate, CURRENT_STATE_ID_FLAG)) {
37c593c5 556 memcpy(&cstate->save_stateid, &cstate->current_stateid, sizeof(stateid_t));
51100d2b 557 SET_CSTATE_FLAG(cstate, SAVED_STATE_ID_FLAG);
37c593c5 558 }
1da177e4
LT		 559 return nfs_ok;
560}
561
562/*
563 * misc nfsv4 ops
564 */
7191155b 565static __be32
ca364317 566nfsd4_access(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 567 union nfsd4_op_u *u)
1da177e4 568{
eb69853d 569 struct nfsd4_access *access = &u->access;
c11d7fd1 570 u32 access_full;
eb69853d 571
c11d7fd1
FL		 572 access_full = NFS3_ACCESS_FULL;
573 if (cstate->minorversion >= 2)
574 access_full |= NFS4_ACCESS_XALIST | NFS4_ACCESS_XAREAD |
575 NFS4_ACCESS_XAWRITE;
576
577 if (access->ac_req_access & ~access_full)
1da177e4
LT		 578 return nfserr_inval;
579
580 access->ac_resp_access = access->ac_req_access;
ca364317
BF		 581 return nfsd_access(rqstp, &cstate->current_fh, &access->ac_resp_access,
582 &access->ac_supported);
1da177e4
LT		 583}
584
b9c0ef85 585static void gen_boot_verifier(nfs4_verifier *verifier, struct net *net)
ab4684d1 586{
27c438f5 587 __be32 *verf = (__be32 *)verifier->data;
ab4684d1 588
27c438f5
TM		 589 BUILD_BUG_ON(2*sizeof(*verf) != sizeof(verifier->data));
590
591 nfsd_copy_boot_verifier(verf, net_generic(net, nfsd_net_id));
ab4684d1
CL		 592}
593
7191155b 594static __be32
ca364317 595nfsd4_commit(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 596 union nfsd4_op_u *u)
1da177e4 597{
eb69853d
CH		 598 struct nfsd4_commit *commit = &u->commit;
599
75c096f7 600 return nfsd_commit(rqstp, &cstate->current_fh, commit->co_offset,
524ff1af
TM		 601 commit->co_count,
602 (__be32 *)commit->co_verf.data);
1da177e4
LT		 603}
604
b37ad28b 605static __be32
ca364317 606nfsd4_create(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 607 union nfsd4_op_u *u)
1da177e4 608{
eb69853d 609 struct nfsd4_create *create = &u->create;
1da177e4 610 struct svc_fh resfh;
b37ad28b 611 __be32 status;
1da177e4
LT		 612 dev_t rdev;
613
614 fh_init(&resfh, NFS4_FHSIZE);
615
fa08139d 616 status = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_NOP);
1da177e4
LT		 617 if (status)
618 return status;
619
3c8e0316
YZ		 620 status = check_attr_support(rqstp, cstate, create->cr_bmval,
621 nfsd_attrmask);
622 if (status)
623 return status;
624
880a3a53 625 current->fs->umask = create->cr_umask;
1da177e4
LT		 626 switch (create->cr_type) {
627 case NF4LNK:
ca364317
BF		 628 status = nfsd_symlink(rqstp, &cstate->current_fh,
629 create->cr_name, create->cr_namelen,
1e444f5b 630 create->cr_data, &resfh);
1da177e4
LT		 631 break;
632
633 case NF4BLK:
880a3a53 634 status = nfserr_inval;
1da177e4
LT		 635 rdev = MKDEV(create->cr_specdata1, create->cr_specdata2);
636 if (MAJOR(rdev) != create->cr_specdata1 ||
637 MINOR(rdev) != create->cr_specdata2)
880a3a53 638 goto out_umask;
ca364317
BF		 639 status = nfsd_create(rqstp, &cstate->current_fh,
640 create->cr_name, create->cr_namelen,
641 &create->cr_iattr, S_IFBLK, rdev, &resfh);
1da177e4
LT		 642 break;
643
644 case NF4CHR:
880a3a53 645 status = nfserr_inval;
1da177e4
LT		 646 rdev = MKDEV(create->cr_specdata1, create->cr_specdata2);
647 if (MAJOR(rdev) != create->cr_specdata1 ||
648 MINOR(rdev) != create->cr_specdata2)
880a3a53 649 goto out_umask;
ca364317
BF		 650 status = nfsd_create(rqstp, &cstate->current_fh,
651 create->cr_name, create->cr_namelen,
652 &create->cr_iattr,S_IFCHR, rdev, &resfh);
1da177e4
LT		 653 break;
654
655 case NF4SOCK:
ca364317
BF		 656 status = nfsd_create(rqstp, &cstate->current_fh,
657 create->cr_name, create->cr_namelen,
658 &create->cr_iattr, S_IFSOCK, 0, &resfh);
1da177e4
LT		 659 break;
660
661 case NF4FIFO:
ca364317
BF		 662 status = nfsd_create(rqstp, &cstate->current_fh,
663 create->cr_name, create->cr_namelen,
664 &create->cr_iattr, S_IFIFO, 0, &resfh);
1da177e4
LT		 665 break;
666
667 case NF4DIR:
668 create->cr_iattr.ia_valid &= ~ATTR_SIZE;
ca364317
BF		 669 status = nfsd_create(rqstp, &cstate->current_fh,
670 create->cr_name, create->cr_namelen,
671 &create->cr_iattr, S_IFDIR, 0, &resfh);
1da177e4
LT		 672 break;
673
674 default:
675 status = nfserr_badtype;
676 }
677
9208faf2
YZ		 678 if (status)
679 goto out;
1da177e4 680
18032ca0
DQ		 681 if (create->cr_label.len)
682 nfsd4_security_inode_setsecctx(&resfh, &create->cr_label, create->cr_bmval);
683
9208faf2
YZ		 684 if (create->cr_acl != NULL)
685 do_set_nfs4_acl(rqstp, &resfh, create->cr_acl,
686 create->cr_bmval);
687
688 fh_unlock(&cstate->current_fh);
689 set_change_info(&create->cr_cinfo, &cstate->current_fh);
690 fh_dup2(&cstate->current_fh, &resfh);
691out:
1da177e4 692 fh_put(&resfh);
880a3a53
BF		 693out_umask:
694 current->fs->umask = 0;
1da177e4
LT		 695 return status;
696}
697
7191155b 698static __be32
ca364317 699nfsd4_getattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 700 union nfsd4_op_u *u)
1da177e4 701{
eb69853d 702 struct nfsd4_getattr *getattr = &u->getattr;
b37ad28b 703 __be32 status;
1da177e4 704
8837abca 705 status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
1da177e4
LT		 706 if (status)
707 return status;
708
709 if (getattr->ga_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)
710 return nfserr_inval;
711
916d2d84
BF		 712 getattr->ga_bmval[0] &= nfsd_suppattrs[cstate->minorversion][0];
713 getattr->ga_bmval[1] &= nfsd_suppattrs[cstate->minorversion][1];
714 getattr->ga_bmval[2] &= nfsd_suppattrs[cstate->minorversion][2];
1da177e4 715
ca364317 716 getattr->ga_fhp = &cstate->current_fh;
1da177e4
LT		 717 return nfs_ok;
718}
719
7191155b 720static __be32
ca364317 721nfsd4_link(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 722 union nfsd4_op_u *u)
1da177e4 723{
eb69853d 724 struct nfsd4_link *link = &u->link;
95424460 725 __be32 status;
1da177e4 726
ca364317
BF		 727 status = nfsd_link(rqstp, &cstate->current_fh,
728 link->li_name, link->li_namelen, &cstate->save_fh);
1da177e4 729 if (!status)
ca364317 730 set_change_info(&link->li_cinfo, &cstate->current_fh);
1da177e4
LT		 731 return status;
732}
733
0ff7ab46 734static __be32 nfsd4_do_lookupp(struct svc_rqst *rqstp, struct svc_fh *fh)
1da177e4
LT		 735{
736 struct svc_fh tmp_fh;
b37ad28b 737 __be32 ret;
1da177e4
LT		 738
739 fh_init(&tmp_fh, NFS4_FHSIZE);
df547efb
BF		 740 ret = exp_pseudoroot(rqstp, &tmp_fh);
741 if (ret)
1da177e4 742 return ret;
0ff7ab46 743 if (tmp_fh.fh_dentry == fh->fh_dentry) {
1da177e4
LT		 744 fh_put(&tmp_fh);
745 return nfserr_noent;
746 }
747 fh_put(&tmp_fh);
0ff7ab46
BF		 748 return nfsd_lookup(rqstp, fh, "..", 2, fh);
749}
750
751static __be32
752nfsd4_lookupp(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 753 union nfsd4_op_u *u)
0ff7ab46
BF		 754{
755 return nfsd4_do_lookupp(rqstp, &cstate->current_fh);
1da177e4
LT		 756}
757
7191155b 758static __be32
ca364317 759nfsd4_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 760 union nfsd4_op_u *u)
1da177e4 761{
ca364317 762 return nfsd_lookup(rqstp, &cstate->current_fh,
eb69853d 763 u->lookup.lo_name, u->lookup.lo_len,
ca364317 764 &cstate->current_fh);
1da177e4
LT		 765}
766
7191155b 767static __be32
ca364317 768nfsd4_read(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 769 union nfsd4_op_u *u)
1da177e4 770{
eb69853d 771 struct nfsd4_read *read = &u->read;
b37ad28b 772 __be32 status;
1da177e4 773
5c4583b2 774 read->rd_nf = NULL;
1da177e4
LT		 775 if (read->rd_offset >= OFFSET_MAX)
776 return nfserr_inval;
777
87c5942e
CL		 778 trace_nfsd_read_start(rqstp, &cstate->current_fh,
779 read->rd_offset, read->rd_length);
780
9b3234b9
BF		 781 /*
782 * If we do a zero copy read, then a client will see read data
783 * that reflects the state of the file *after* performing the
784 * following compound.
785 *
786 * To ensure proper ordering, we therefore turn off zero copy if
787 * the client wants us to do more in this compound:
788 */
789 if (!nfsd4_last_compound_op(rqstp))
779fb0f3 790 clear_bit(RQ_SPLICE_OK, &rqstp->rq_flags);
9b3234b9 791
1da177e4 792 /* check stateid */
aa0d6aed
AS		 793 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
794 &read->rd_stateid, RD_STATE,
624322f1 795 &read->rd_nf, NULL);
af90f707 796 if (status) {
1da177e4
LT		 797 dprintk("NFSD: nfsd4_read: couldn't process stateid!\n");
798 goto out;
799 }
800 status = nfs_ok;
801out:
1da177e4 802 read->rd_rqstp = rqstp;
ca364317 803 read->rd_fhp = &cstate->current_fh;
1da177e4
LT		 804 return status;
805}
806
34b1744c
BF		 807
808static void
809nfsd4_read_release(union nfsd4_op_u *u)
810{
5c4583b2
JL		 811 if (u->read.rd_nf)
812 nfsd_file_put(u->read.rd_nf);
87c5942e
CL		 813 trace_nfsd_read_done(u->read.rd_rqstp, u->read.rd_fhp,
814 u->read.rd_offset, u->read.rd_length);
34b1744c
BF		 815}
816
7191155b 817static __be32
ca364317 818nfsd4_readdir(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 819 union nfsd4_op_u *u)
1da177e4 820{
eb69853d 821 struct nfsd4_readdir *readdir = &u->readdir;
1da177e4
LT		 822 u64 cookie = readdir->rd_cookie;
823 static const nfs4_verifier zeroverf;
824
825 /* no need to check permission - this will be done in nfsd_readdir() */
826
827 if (readdir->rd_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)
828 return nfserr_inval;
829
916d2d84
BF		 830 readdir->rd_bmval[0] &= nfsd_suppattrs[cstate->minorversion][0];
831 readdir->rd_bmval[1] &= nfsd_suppattrs[cstate->minorversion][1];
832 readdir->rd_bmval[2] &= nfsd_suppattrs[cstate->minorversion][2];
1da177e4 833
832023bf 834 if ((cookie == 1) || (cookie == 2) ||
1da177e4
LT		 835 (cookie == 0 && memcmp(readdir->rd_verf.data, zeroverf.data, NFS4_VERIFIER_SIZE)))
836 return nfserr_bad_cookie;
837
838 readdir->rd_rqstp = rqstp;
ca364317 839 readdir->rd_fhp = &cstate->current_fh;
1da177e4
LT		 840 return nfs_ok;
841}
842
7191155b 843static __be32
ca364317 844nfsd4_readlink(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 845 union nfsd4_op_u *u)
1da177e4 846{
eb69853d
CH		 847 u->readlink.rl_rqstp = rqstp;
848 u->readlink.rl_fhp = &cstate->current_fh;
1da177e4
LT		 849 return nfs_ok;
850}
851
7191155b 852static __be32
ca364317 853nfsd4_remove(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 854 union nfsd4_op_u *u)
1da177e4 855{
eb69853d 856 struct nfsd4_remove *remove = &u->remove;
b37ad28b 857 __be32 status;
1da177e4 858
c87fb4a3 859 if (opens_in_grace(SVC_NET(rqstp)))
c815afc7 860 return nfserr_grace;
ca364317
BF		 861 status = nfsd_unlink(rqstp, &cstate->current_fh, 0,
862 remove->rm_name, remove->rm_namelen);
1da177e4 863 if (!status) {
ca364317
BF		 864 fh_unlock(&cstate->current_fh);
865 set_change_info(&remove->rm_cinfo, &cstate->current_fh);
1da177e4
LT		 866 }
867 return status;
868}
869
7191155b 870static __be32
ca364317 871nfsd4_rename(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 872 union nfsd4_op_u *u)
1da177e4 873{
eb69853d 874 struct nfsd4_rename *rename = &u->rename;
95424460 875 __be32 status;
1da177e4 876
f8f71d00 877 if (opens_in_grace(SVC_NET(rqstp)))
c815afc7 878 return nfserr_grace;
ca364317
BF		 879 status = nfsd_rename(rqstp, &cstate->save_fh, rename->rn_sname,
880 rename->rn_snamelen, &cstate->current_fh,
1da177e4 881 rename->rn_tname, rename->rn_tnamelen);
2a6cf944
BF		 882 if (status)
883 return status;
884 set_change_info(&rename->rn_sinfo, &cstate->current_fh);
885 set_change_info(&rename->rn_tinfo, &cstate->save_fh);
886 return nfs_ok;
1da177e4
LT		 887}
888
dcb488a3
AA		 889static __be32
890nfsd4_secinfo(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 891 union nfsd4_op_u *u)
dcb488a3 892{
eb69853d 893 struct nfsd4_secinfo *secinfo = &u->secinfo;
dcb488a3
AA		 894 struct svc_export *exp;
895 struct dentry *dentry;
896 __be32 err;
897
29a78a3e
BF		 898 err = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_EXEC);
899 if (err)
900 return err;
dcb488a3
AA		 901 err = nfsd_lookup_dentry(rqstp, &cstate->current_fh,
902 secinfo->si_name, secinfo->si_namelen,
903 &exp, &dentry);
904 if (err)
905 return err;
2f6fc056 906 fh_unlock(&cstate->current_fh);
2b0143b5 907 if (d_really_is_negative(dentry)) {
dcb488a3
AA		 908 exp_put(exp);
909 err = nfserr_noent;
910 } else
911 secinfo->si_exp = exp;
912 dput(dentry);
56560b9a
BF		 913 if (cstate->minorversion)
914 /* See rfc 5661 section 2.6.3.1.1.8 */
915 fh_put(&cstate->current_fh);
dcb488a3
AA		 916 return err;
917}
918
04f4ad16
BF		 919static __be32
920nfsd4_secinfo_no_name(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 921 union nfsd4_op_u *u)
04f4ad16
BF		 922{
923 __be32 err;
924
eb69853d 925 switch (u->secinfo_no_name.sin_style) {
04f4ad16
BF		 926 case NFS4_SECINFO_STYLE4_CURRENT_FH:
927 break;
928 case NFS4_SECINFO_STYLE4_PARENT:
929 err = nfsd4_do_lookupp(rqstp, &cstate->current_fh);
930 if (err)
931 return err;
932 break;
933 default:
934 return nfserr_inval;
935 }
bf18f163 936
eb69853d 937 u->secinfo_no_name.sin_exp = exp_get(cstate->current_fh.fh_export);
04f4ad16
BF		 938 fh_put(&cstate->current_fh);
939 return nfs_ok;
940}
941
34b1744c
BF		 942static void
943nfsd4_secinfo_release(union nfsd4_op_u *u)
944{
945 if (u->secinfo.si_exp)
946 exp_put(u->secinfo.si_exp);
947}
948
ec572b9e
EG		 949static void
950nfsd4_secinfo_no_name_release(union nfsd4_op_u *u)
951{
952 if (u->secinfo_no_name.sin_exp)
953 exp_put(u->secinfo_no_name.sin_exp);
954}
955
7191155b 956static __be32
ca364317 957nfsd4_setattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 958 union nfsd4_op_u *u)
1da177e4 959{
eb69853d 960 struct nfsd4_setattr *setattr = &u->setattr;
b37ad28b 961 __be32 status = nfs_ok;
96f6f985 962 int err;
1da177e4 963
1da177e4 964 if (setattr->sa_iattr.ia_valid & ATTR_SIZE) {
af90f707 965 status = nfs4_preprocess_stateid_op(rqstp, cstate,
aa0d6aed 966 &cstate->current_fh, &setattr->sa_stateid,
624322f1 967 WR_STATE, NULL, NULL);
375c5547 968 if (status) {
3e3b4800 969 dprintk("NFSD: nfsd4_setattr: couldn't process stateid!\n");
375c5547
BF		 970 return status;
971 }
1da177e4 972 }
96f6f985
AV		 973 err = fh_want_write(&cstate->current_fh);
974 if (err)
975 return nfserrno(err);
1da177e4 976 status = nfs_ok;
3c8e0316
YZ		 977
978 status = check_attr_support(rqstp, cstate, setattr->sa_bmval,
979 nfsd_attrmask);
980 if (status)
981 goto out;
982
1da177e4 983 if (setattr->sa_acl != NULL)
ca364317
BF		 984 status = nfsd4_set_nfs4_acl(rqstp, &cstate->current_fh,
985 setattr->sa_acl);
1da177e4 986 if (status)
18f335af 987 goto out;
18032ca0
DQ		 988 if (setattr->sa_label.len)
989 status = nfsd4_set_nfs4_label(rqstp, &cstate->current_fh,
990 &setattr->sa_label);
991 if (status)
992 goto out;
ca364317 993 status = nfsd_setattr(rqstp, &cstate->current_fh, &setattr->sa_iattr,
2a1aa489 994 0, (time64_t)0);
18f335af 995out:
bad0dcff 996 fh_drop_write(&cstate->current_fh);
1da177e4
LT		 997 return status;
998}
999
7191155b 1000static __be32
ca364317 1001nfsd4_write(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 1002 union nfsd4_op_u *u)
1da177e4 1003{
eb69853d 1004 struct nfsd4_write *write = &u->write;
1da177e4 1005 stateid_t *stateid = &write->wr_stateid;
5c4583b2 1006 struct nfsd_file *nf = NULL;
b37ad28b 1007 __be32 status = nfs_ok;
31dec253 1008 unsigned long cnt;
ffe1137b 1009 int nvecs;
1da177e4 1010
1da177e4
LT		 1011 if (write->wr_offset >= OFFSET_MAX)
1012 return nfserr_inval;
1013
d890be15
CL		 1014 cnt = write->wr_buflen;
1015 trace_nfsd_write_start(rqstp, &cstate->current_fh,
1016 write->wr_offset, cnt);
aa0d6aed 1017 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
624322f1 1018 stateid, WR_STATE, &nf, NULL);
375c5547
BF		 1019 if (status) {
1020 dprintk("NFSD: nfsd4_write: couldn't process stateid!\n");
1021 return status;
1022 }
1023
1da177e4 1024 write->wr_how_written = write->wr_stable_how;
1da177e4 1025
c1346a12
CL		 1026 nvecs = svc_fill_write_vector(rqstp, write->wr_payload.pages,
1027 write->wr_payload.head, write->wr_buflen);
ffe1137b
BF		 1028 WARN_ON_ONCE(nvecs > ARRAY_SIZE(rqstp->rq_vec));
1029
16f8f894 1030 status = nfsd_vfs_write(rqstp, &cstate->current_fh, nf,
af90f707 1031 write->wr_offset, rqstp->rq_vec, nvecs, &cnt,
19e0663f
TM		 1032 write->wr_how_written,
1033 (__be32 *)write->wr_verifier.data);
5c4583b2 1034 nfsd_file_put(nf);
1da177e4 1035
31dec253 1036 write->wr_bytes_written = cnt;
d890be15
CL		 1037 trace_nfsd_write_done(rqstp, &cstate->current_fh,
1038 write->wr_offset, cnt);
1da177e4 1039 return status;
1da177e4
LT		 1040}
1041
ffa0160a 1042static __be32
29ae7f9d 1043nfsd4_verify_copy(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
5c4583b2
JL		 1044 stateid_t *src_stateid, struct nfsd_file **src,
1045 stateid_t *dst_stateid, struct nfsd_file **dst)
ffa0160a 1046{
ffa0160a
CH		 1047 __be32 status;
1048
01310bb7
SM		 1049 if (!cstate->save_fh.fh_dentry)
1050 return nfserr_nofilehandle;
1051
ffa0160a 1052 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->save_fh,
624322f1 1053 src_stateid, RD_STATE, src, NULL);
ffa0160a
CH		 1054 if (status) {
1055 dprintk("NFSD: %s: couldn't process src stateid!\n", __func__);
1056 goto out;
1057 }
1058
1059 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
624322f1 1060 dst_stateid, WR_STATE, dst, NULL);
ffa0160a
CH		 1061 if (status) {
1062 dprintk("NFSD: %s: couldn't process dst stateid!\n", __func__);
1063 goto out_put_src;
1064 }
1065
1066 /* fix up for NFS-specific error code */
5c4583b2
JL		 1067 if (!S_ISREG(file_inode((*src)->nf_file)->i_mode) ||
1068 !S_ISREG(file_inode((*dst)->nf_file)->i_mode)) {
ffa0160a
CH		 1069 status = nfserr_wrong_type;
1070 goto out_put_dst;
1071 }
1072
29ae7f9d
AS		 1073out:
1074 return status;
1075out_put_dst:
5c4583b2 1076 nfsd_file_put(*dst);
29ae7f9d 1077out_put_src:
5c4583b2 1078 nfsd_file_put(*src);
29ae7f9d
AS		 1079 goto out;
1080}
1081
1082static __be32
1083nfsd4_clone(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 1084 union nfsd4_op_u *u)
29ae7f9d 1085{
eb69853d 1086 struct nfsd4_clone *clone = &u->clone;
5c4583b2 1087 struct nfsd_file *src, *dst;
29ae7f9d
AS		 1088 __be32 status;
1089
1090 status = nfsd4_verify_copy(rqstp, cstate, &clone->cl_src_stateid, &src,
1091 &clone->cl_dst_stateid, &dst);
1092 if (status)
1093 goto out;
1094
b66ae6dd
TM		 1095 status = nfsd4_clone_file_range(src, clone->cl_src_pos,
1096 dst, clone->cl_dst_pos, clone->cl_count,
a25e3726 1097 EX_ISSYNC(cstate->current_fh.fh_export));
ffa0160a 1098
5c4583b2
JL		 1099 nfsd_file_put(dst);
1100 nfsd_file_put(src);
ffa0160a
CH		 1101out:
1102 return status;
1103}
1104
e0639dc5
OK		 1105void nfs4_put_copy(struct nfsd4_copy *copy)
1106{
1107 if (!refcount_dec_and_test(&copy->refcount))
1108 return;
1109 kfree(copy);
1110}
1111
1112static bool
1113check_and_set_stop_copy(struct nfsd4_copy *copy)
1114{
1115 bool value;
1116
1117 spin_lock(&copy->cp_clp->async_lock);
1118 value = copy->stopped;
1119 if (!copy->stopped)
1120 copy->stopped = true;
1121 spin_unlock(&copy->cp_clp->async_lock);
1122 return value;
1123}
1124
1125static void nfsd4_stop_copy(struct nfsd4_copy *copy)
1126{
1127 /* only 1 thread should stop the copy */
1128 if (!check_and_set_stop_copy(copy))
1129 kthread_stop(copy->copy_task);
1130 nfs4_put_copy(copy);
1131}
1132
1133static struct nfsd4_copy *nfsd4_get_copy(struct nfs4_client *clp)
1134{
1135 struct nfsd4_copy *copy = NULL;
1136
1137 spin_lock(&clp->async_lock);
1138 if (!list_empty(&clp->async_copies)) {
1139 copy = list_first_entry(&clp->async_copies, struct nfsd4_copy,
1140 copies);
1141 refcount_inc(&copy->refcount);
1142 }
1143 spin_unlock(&clp->async_lock);
1144 return copy;
1145}
1146
1147void nfsd4_shutdown_copy(struct nfs4_client *clp)
1148{
1149 struct nfsd4_copy *copy;
1150
1151 while ((copy = nfsd4_get_copy(clp)) != NULL)
1152 nfsd4_stop_copy(copy);
1153}
ce0887ac
OK		 1154#ifdef CONFIG_NFSD_V4_2_INTER_SSC
1155
1156extern struct file *nfs42_ssc_open(struct vfsmount *ss_mnt,
1157 struct nfs_fh *src_fh,
1158 nfs4_stateid *stateid);
1159extern void nfs42_ssc_close(struct file *filep);
1160
1161extern void nfs_sb_deactive(struct super_block *sb);
1162
1163#define NFSD42_INTERSSC_MOUNTOPS "vers=4.2,addr=%s,sec=sys"
1164
f2453978 1165/*
ce0887ac
OK		 1166 * Support one copy source server for now.
1167 */
1168static __be32
1169nfsd4_interssc_connect(struct nl4_server *nss, struct svc_rqst *rqstp,
1170 struct vfsmount **mount)
1171{
1172 struct file_system_type *type;
1173 struct vfsmount *ss_mnt;
1174 struct nfs42_netaddr *naddr;
1175 struct sockaddr_storage tmp_addr;
1176 size_t tmp_addrlen, match_netid_len = 3;
1177 char *startsep = "", *endsep = "", *match_netid = "tcp";
1178 char *ipaddr, *dev_name, *raw_data;
b8290ca2
OK		 1179 int len, raw_len;
1180 __be32 status = nfserr_inval;
ce0887ac
OK		 1181
1182 naddr = &nss->u.nl4_addr;
1183 tmp_addrlen = rpc_uaddr2sockaddr(SVC_NET(rqstp), naddr->addr,
1184 naddr->addr_len,
1185 (struct sockaddr *)&tmp_addr,
1186 sizeof(tmp_addr));
1187 if (tmp_addrlen == 0)
1188 goto out_err;
1189
1190 if (tmp_addr.ss_family == AF_INET6) {
1191 startsep = "[";
1192 endsep = "]";
1193 match_netid = "tcp6";
1194 match_netid_len = 4;
1195 }
1196
1197 if (naddr->netid_len != match_netid_len ||
1198 strncmp(naddr->netid, match_netid, naddr->netid_len))
1199 goto out_err;
1200
1201 /* Construct the raw data for the vfs_kern_mount call */
1202 len = RPC_MAX_ADDRBUFLEN + 1;
1203 ipaddr = kzalloc(len, GFP_KERNEL);
1204 if (!ipaddr)
1205 goto out_err;
1206
1207 rpc_ntop((struct sockaddr *)&tmp_addr, ipaddr, len);
1208
1209 /* 2 for ipv6 endsep and startsep. 3 for ":/" and trailing '/0'*/
1210
1211 raw_len = strlen(NFSD42_INTERSSC_MOUNTOPS) + strlen(ipaddr);
1212 raw_data = kzalloc(raw_len, GFP_KERNEL);
1213 if (!raw_data)
1214 goto out_free_ipaddr;
1215
1216 snprintf(raw_data, raw_len, NFSD42_INTERSSC_MOUNTOPS, ipaddr);
1217
b8290ca2 1218 status = nfserr_nodev;
ce0887ac
OK		 1219 type = get_fs_type("nfs");
1220 if (!type)
1221 goto out_free_rawdata;
1222
1223 /* Set the server:<export> for the vfs_kern_mount call */
1224 dev_name = kzalloc(len + 5, GFP_KERNEL);
1225 if (!dev_name)
1226 goto out_free_rawdata;
1227 snprintf(dev_name, len + 5, "%s%s%s:/", startsep, ipaddr, endsep);
1228
1229 /* Use an 'internal' mount: SB_KERNMOUNT -> MNT_INTERNAL */
1230 ss_mnt = vfs_kern_mount(type, SB_KERNMOUNT, dev_name, raw_data);
1231 module_put(type->owner);
1232 if (IS_ERR(ss_mnt))
1233 goto out_free_devname;
1234
1235 status = 0;
1236 *mount = ss_mnt;
1237
1238out_free_devname:
1239 kfree(dev_name);
1240out_free_rawdata:
1241 kfree(raw_data);
1242out_free_ipaddr:
1243 kfree(ipaddr);
1244out_err:
1245 return status;
1246}
1247
1248static void
1249nfsd4_interssc_disconnect(struct vfsmount *ss_mnt)
1250{
0cfcd405 1251 nfs_do_sb_deactive(ss_mnt->mnt_sb);
ce0887ac
OK		 1252 mntput(ss_mnt);
1253}
1254
f2453978 1255/*
ce0887ac 1256 * Verify COPY destination stateid.
f2453978 1257 *
ce0887ac
OK		 1258 * Connect to the source server with NFSv4.1.
1259 * Create the source struct file for nfsd_copy_range.
1260 * Called with COPY cstate:
1261 * SAVED_FH: source filehandle
1262 * CURRENT_FH: destination filehandle
ce0887ac
OK		 1263 */
1264static __be32
1265nfsd4_setup_inter_ssc(struct svc_rqst *rqstp,
1266 struct nfsd4_compound_state *cstate,
1267 struct nfsd4_copy *copy, struct vfsmount **mount)
1268{
1269 struct svc_fh *s_fh = NULL;
1270 stateid_t *s_stid = &copy->cp_src_stateid;
b8290ca2 1271 __be32 status = nfserr_inval;
ce0887ac
OK		 1272
1273 /* Verify the destination stateid and set dst struct file*/
1274 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
1275 &copy->cp_dst_stateid,
1276 WR_STATE, &copy->nf_dst, NULL);
1277 if (status)
1278 goto out;
1279
1280 status = nfsd4_interssc_connect(&copy->cp_src, rqstp, mount);
1281 if (status)
1282 goto out;
1283
1284 s_fh = &cstate->save_fh;
1285
1286 copy->c_fh.size = s_fh->fh_handle.fh_size;
1287 memcpy(copy->c_fh.data, &s_fh->fh_handle.fh_base, copy->c_fh.size);
3f9544ca 1288 copy->stateid.seqid = cpu_to_be32(s_stid->si_generation);
ce0887ac
OK		 1289 memcpy(copy->stateid.other, (void *)&s_stid->si_opaque,
1290 sizeof(stateid_opaque_t));
1291
1292 status = 0;
1293out:
1294 return status;
1295}
1296
1297static void
1298nfsd4_cleanup_inter_ssc(struct vfsmount *ss_mnt, struct nfsd_file *src,
1299 struct nfsd_file *dst)
1300{
1301 nfs42_ssc_close(src->nf_file);
36e1e5ba 1302 /* 'src' is freed by nfsd4_do_async_copy */
ce0887ac
OK		 1303 nfsd_file_put(dst);
1304 mntput(ss_mnt);
1305}
1306
1307#else /* CONFIG_NFSD_V4_2_INTER_SSC */
1308
1309static __be32
1310nfsd4_setup_inter_ssc(struct svc_rqst *rqstp,
1311 struct nfsd4_compound_state *cstate,
1312 struct nfsd4_copy *copy,
1313 struct vfsmount **mount)
1314{
1315 *mount = NULL;
b8290ca2 1316 return nfserr_inval;
ce0887ac
OK		 1317}
1318
1319static void
1320nfsd4_cleanup_inter_ssc(struct vfsmount *ss_mnt, struct nfsd_file *src,
1321 struct nfsd_file *dst)
1322{
1323}
1324
1325static void
1326nfsd4_interssc_disconnect(struct vfsmount *ss_mnt)
1327{
1328}
1329
1330static struct file *nfs42_ssc_open(struct vfsmount *ss_mnt,
1331 struct nfs_fh *src_fh,
1332 nfs4_stateid *stateid)
1333{
1334 return NULL;
1335}
1336#endif /* CONFIG_NFSD_V4_2_INTER_SSC */
1337
1338static __be32
1339nfsd4_setup_intra_ssc(struct svc_rqst *rqstp,
1340 struct nfsd4_compound_state *cstate,
1341 struct nfsd4_copy *copy)
1342{
1343 return nfsd4_verify_copy(rqstp, cstate, &copy->cp_src_stateid,
1344 &copy->nf_src, &copy->cp_dst_stateid,
1345 &copy->nf_dst);
1346}
1347
1348static void
1349nfsd4_cleanup_intra_ssc(struct nfsd_file *src, struct nfsd_file *dst)
1350{
1351 nfsd_file_put(src);
1352 nfsd_file_put(dst);
1353}
e0639dc5
OK		 1354
1355static void nfsd4_cb_offload_release(struct nfsd4_callback *cb)
1356{
1357 struct nfsd4_copy *copy = container_of(cb, struct nfsd4_copy, cp_cb);
1358
1359 nfs4_put_copy(copy);
1360}
1361
1362static int nfsd4_cb_offload_done(struct nfsd4_callback *cb,
1363 struct rpc_task *task)
1364{
1365 return 1;
1366}
1367
1368static const struct nfsd4_callback_ops nfsd4_cb_offload_ops = {
1369 .release = nfsd4_cb_offload_release,
1370 .done = nfsd4_cb_offload_done
1371};
1372
1373static void nfsd4_init_copy_res(struct nfsd4_copy *copy, bool sync)
1374{
1375 copy->cp_res.wr_stable_how = NFS_UNSTABLE;
1376 copy->cp_synchronous = sync;
1377 gen_boot_verifier(&copy->cp_res.wr_verifier, copy->cp_clp->net);
1378}
1379
1380static ssize_t _nfsd_copy_file_range(struct nfsd4_copy *copy)
1381{
1382 ssize_t bytes_copied = 0;
1383 size_t bytes_total = copy->cp_count;
1384 u64 src_pos = copy->cp_src_pos;
1385 u64 dst_pos = copy->cp_dst_pos;
1386
1387 do {
1388 if (kthread_should_stop())
1389 break;
5c4583b2
JL		 1390 bytes_copied = nfsd_copy_file_range(copy->nf_src->nf_file,
1391 src_pos, copy->nf_dst->nf_file, dst_pos,
1392 bytes_total);
e0639dc5
OK		 1393 if (bytes_copied <= 0)
1394 break;
1395 bytes_total -= bytes_copied;
1396 copy->cp_res.wr_bytes_written += bytes_copied;
1397 src_pos += bytes_copied;
1398 dst_pos += bytes_copied;
1399 } while (bytes_total > 0 && !copy->cp_synchronous);
1400 return bytes_copied;
1401}
1402
1403static __be32 nfsd4_do_copy(struct nfsd4_copy *copy, bool sync)
1404{
1405 __be32 status;
1406 ssize_t bytes;
1407
1408 bytes = _nfsd_copy_file_range(copy);
1409 /* for async copy, we ignore the error, client can always retry
1410 * to get the error
1411 */
1412 if (bytes < 0 && !copy->cp_res.wr_bytes_written)
1413 status = nfserrno(bytes);
1414 else {
1415 nfsd4_init_copy_res(copy, sync);
1416 status = nfs_ok;
1417 }
1418
ce0887ac
OK		 1419 if (!copy->cp_intra) /* Inter server SSC */
1420 nfsd4_cleanup_inter_ssc(copy->ss_mnt, copy->nf_src,
1421 copy->nf_dst);
1422 else
1423 nfsd4_cleanup_intra_ssc(copy->nf_src, copy->nf_dst);
1424
e0639dc5
OK		 1425 return status;
1426}
1427
ce0887ac 1428static int dup_copy_fields(struct nfsd4_copy *src, struct nfsd4_copy *dst)
e0639dc5
OK		 1429{
1430 dst->cp_src_pos = src->cp_src_pos;
1431 dst->cp_dst_pos = src->cp_dst_pos;
1432 dst->cp_count = src->cp_count;
1433 dst->cp_synchronous = src->cp_synchronous;
1434 memcpy(&dst->cp_res, &src->cp_res, sizeof(src->cp_res));
1435 memcpy(&dst->fh, &src->fh, sizeof(src->fh));
1436 dst->cp_clp = src->cp_clp;
5c4583b2 1437 dst->nf_dst = nfsd_file_get(src->nf_dst);
ce0887ac
OK		 1438 dst->cp_intra = src->cp_intra;
1439 if (src->cp_intra) /* for inter, file_src doesn't exist yet */
1440 dst->nf_src = nfsd_file_get(src->nf_src);
1441
e0639dc5 1442 memcpy(&dst->cp_stateid, &src->cp_stateid, sizeof(src->cp_stateid));
ce0887ac
OK		 1443 memcpy(&dst->cp_src, &src->cp_src, sizeof(struct nl4_server));
1444 memcpy(&dst->stateid, &src->stateid, sizeof(src->stateid));
1445 memcpy(&dst->c_fh, &src->c_fh, sizeof(src->c_fh));
1446 dst->ss_mnt = src->ss_mnt;
1447
1448 return 0;
e0639dc5
OK		 1449}
1450
1451static void cleanup_async_copy(struct nfsd4_copy *copy)
1452{
624322f1 1453 nfs4_free_copy_state(copy);
5c4583b2 1454 nfsd_file_put(copy->nf_dst);
2e577f0f
OK		 1455 if (copy->cp_intra)
1456 nfsd_file_put(copy->nf_src);
e0639dc5
OK		 1457 spin_lock(&copy->cp_clp->async_lock);
1458 list_del(&copy->copies);
1459 spin_unlock(&copy->cp_clp->async_lock);
1460 nfs4_put_copy(copy);
1461}
1462
1463static int nfsd4_do_async_copy(void *data)
1464{
1465 struct nfsd4_copy *copy = (struct nfsd4_copy *)data;
1466 struct nfsd4_copy *cb_copy;
1467
ce0887ac
OK		 1468 if (!copy->cp_intra) { /* Inter server SSC */
1469 copy->nf_src = kzalloc(sizeof(struct nfsd_file), GFP_KERNEL);
1470 if (!copy->nf_src) {
1471 copy->nfserr = nfserr_serverfault;
1472 nfsd4_interssc_disconnect(copy->ss_mnt);
1473 goto do_callback;
1474 }
1475 copy->nf_src->nf_file = nfs42_ssc_open(copy->ss_mnt, &copy->c_fh,
1476 &copy->stateid);
1477 if (IS_ERR(copy->nf_src->nf_file)) {
ce0887ac
OK		 1478 copy->nfserr = nfserr_offload_denied;
1479 nfsd4_interssc_disconnect(copy->ss_mnt);
1480 goto do_callback;
1481 }
1482 }
1483
e0639dc5 1484 copy->nfserr = nfsd4_do_copy(copy, 0);
ce0887ac 1485do_callback:
e0639dc5
OK		 1486 cb_copy = kzalloc(sizeof(struct nfsd4_copy), GFP_KERNEL);
1487 if (!cb_copy)
1488 goto out;
49a36132 1489 refcount_set(&cb_copy->refcount, 1);
e0639dc5
OK		 1490 memcpy(&cb_copy->cp_res, &copy->cp_res, sizeof(copy->cp_res));
1491 cb_copy->cp_clp = copy->cp_clp;
1492 cb_copy->nfserr = copy->nfserr;
1493 memcpy(&cb_copy->fh, &copy->fh, sizeof(copy->fh));
1494 nfsd4_init_cb(&cb_copy->cp_cb, cb_copy->cp_clp,
1495 &nfsd4_cb_offload_ops, NFSPROC4_CLNT_CB_OFFLOAD);
1496 nfsd4_run_cb(&cb_copy->cp_cb);
1497out:
ce0887ac
OK		 1498 if (!copy->cp_intra)
1499 kfree(copy->nf_src);
e0639dc5
OK		 1500 cleanup_async_copy(copy);
1501 return 0;
1502}
1503
29ae7f9d
AS		 1504static __be32
1505nfsd4_copy(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
eb69853d 1506 union nfsd4_op_u *u)
29ae7f9d 1507{
eb69853d 1508 struct nfsd4_copy *copy = &u->copy;
29ae7f9d 1509 __be32 status;
e0639dc5 1510 struct nfsd4_copy *async_copy = NULL;
29ae7f9d 1511
ce0887ac
OK		 1512 if (!copy->cp_intra) { /* Inter server SSC */
1513 if (!inter_copy_offload_enable || copy->cp_synchronous) {
1514 status = nfserr_notsupp;
1515 goto out;
1516 }
1517 status = nfsd4_setup_inter_ssc(rqstp, cstate, copy,
1518 &copy->ss_mnt);
1519 if (status)
1520 return nfserr_offload_denied;
1521 } else {
1522 status = nfsd4_setup_intra_ssc(rqstp, cstate, copy);
1523 if (status)
1524 return status;
1525 }
29ae7f9d 1526
e0639dc5
OK		 1527 copy->cp_clp = cstate->clp;
1528 memcpy(&copy->fh, &cstate->current_fh.fh_handle,
1529 sizeof(struct knfsd_fh));
1530 if (!copy->cp_synchronous) {
1531 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
29ae7f9d 1532
e0639dc5
OK		 1533 status = nfserrno(-ENOMEM);
1534 async_copy = kzalloc(sizeof(struct nfsd4_copy), GFP_KERNEL);
1535 if (!async_copy)
ce0887ac
OK		 1536 goto out_err;
1537 if (!nfs4_init_copy_state(nn, copy))
1538 goto out_err;
e0639dc5
OK		 1539 refcount_set(&async_copy->refcount, 1);
1540 memcpy(&copy->cp_res.cb_stateid, &copy->cp_stateid,
1541 sizeof(copy->cp_stateid));
ce0887ac
OK		 1542 status = dup_copy_fields(copy, async_copy);
1543 if (status)
1544 goto out_err;
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)
2176 nfsdstats.nfs4_opcount[opnum]++;
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) {
3285 pr_err("unable to encode reply to nonidempotent op %d (%s)\n",
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,
3307 },
3308 [NFSPROC4_COMPOUND] = {
f7235b6b 3309 .pc_func = nfsd4_proc_compound,
026fec7e 3310 .pc_decode = nfs4svc_decode_compoundargs,
63f8de37 3311 .pc_encode = nfs4svc_encode_compoundres,
0a93a47f
YZ		 3312 .pc_argsize = sizeof(struct nfsd4_compoundargs),
3313 .pc_ressize = sizeof(struct nfsd4_compoundres),
3e98abff 3314 .pc_release = nfsd4_release_compoundargs,
0a93a47f
YZ		 3315 .pc_cachetype = RC_NOCACHE,
3316 .pc_xdrressize = NFSD_BUFSIZE/4,
3317 },
1da177e4
LT		 3318};
3319
7fd38af9 3320static unsigned int nfsd_count3[ARRAY_SIZE(nfsd_procedures4)];
e9679189 3321const struct svc_version nfsd_version4 = {
5283b03e
JL		 3322 .vs_vers = 4,
3323 .vs_nproc = 2,
3324 .vs_proc = nfsd_procedures4,
7fd38af9 3325 .vs_count = nfsd_count3,
5283b03e
JL		 3326 .vs_dispatch = nfsd_dispatch,
3327 .vs_xdrsize = NFS4_SVC_XDRSIZE,
3328 .vs_rpcb_optnl = true,
3329 .vs_need_cong_ctrl = true,
1da177e4
LT		 3330};
3331
3332/*
3333 * Local variables:
3334 * c-basic-offset: 8
3335 * End:
3336 */
Michael's Linux tree.