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