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