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