nfs4proc.c 54.0 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
/*
 *  Server-side procedures for NFSv4.
 *
 *  Copyright (c) 2002 The Regents of the University of Michigan.
 *  All rights reserved.
 *
 *  Kendrick Smith <kmsmith@umich.edu>
 *  Andy Adamson   <andros@umich.edu>
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. Neither the name of the University nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
 *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
35
#include <linux/file.h>
36
#include <linux/slab.h>
L
Linus Torvalds 已提交
37

38
#include "idmap.h"
39 40
#include "cache.h"
#include "xdr4.h"
41
#include "vfs.h"
42
#include "current_stateid.h"
43
#include "netns.h"
L
Linus Torvalds 已提交
44

45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
#include <linux/security.h>

static inline void
nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct xdr_netobj *label, u32 *bmval)
{
	struct inode *inode = resfh->fh_dentry->d_inode;
	int status;

	mutex_lock(&inode->i_mutex);
	status = security_inode_setsecctx(resfh->fh_dentry,
		label->data, label->len);
	mutex_unlock(&inode->i_mutex);

	if (status)
		/*
		 * XXX: We should really fail the whole open, but we may
		 * already have created a new file, so it may be too
		 * late.  For now this seems the least of evils:
		 */
		bmval[2] &= ~FATTR4_WORD2_SECURITY_LABEL;

	return;
}
#else
static inline void
nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct xdr_netobj *label, u32 *bmval)
{ }
#endif

L
Linus Torvalds 已提交
75 76
#define NFSDDBG_FACILITY		NFSDDBG_PROC

77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104
static u32 nfsd_attrmask[] = {
	NFSD_WRITEABLE_ATTRS_WORD0,
	NFSD_WRITEABLE_ATTRS_WORD1,
	NFSD_WRITEABLE_ATTRS_WORD2
};

static u32 nfsd41_ex_attrmask[] = {
	NFSD_SUPPATTR_EXCLCREAT_WORD0,
	NFSD_SUPPATTR_EXCLCREAT_WORD1,
	NFSD_SUPPATTR_EXCLCREAT_WORD2
};

static __be32
check_attr_support(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
		   u32 *bmval, u32 *writable)
{
	struct dentry *dentry = cstate->current_fh.fh_dentry;

	/*
	 * Check about attributes are supported by the NFSv4 server or not.
	 * According to spec, unsupported attributes return ERR_ATTRNOTSUPP.
	 */
	if ((bmval[0] & ~nfsd_suppattrs0(cstate->minorversion)) ||
	    (bmval[1] & ~nfsd_suppattrs1(cstate->minorversion)) ||
	    (bmval[2] & ~nfsd_suppattrs2(cstate->minorversion)))
		return nfserr_attrnotsupp;

	/*
105
	 * Check FATTR4_WORD0_ACL can be supported
106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
	 * in current environment or not.
	 */
	if (bmval[0] & FATTR4_WORD0_ACL) {
		if (!IS_POSIXACL(dentry->d_inode))
			return nfserr_attrnotsupp;
	}

	/*
	 * According to spec, read-only attributes return ERR_INVAL.
	 */
	if (writable) {
		if ((bmval[0] & ~writable[0]) || (bmval[1] & ~writable[1]) ||
		    (bmval[2] & ~writable[2]))
			return nfserr_inval;
	}

	return nfs_ok;
}

static __be32
nfsd4_check_open_attributes(struct svc_rqst *rqstp,
	struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
{
	__be32 status = nfs_ok;

	if (open->op_create == NFS4_OPEN_CREATE) {
		if (open->op_createmode == NFS4_CREATE_UNCHECKED
		    || open->op_createmode == NFS4_CREATE_GUARDED)
			status = check_attr_support(rqstp, cstate,
					open->op_bmval, nfsd_attrmask);
		else if (open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1)
			status = check_attr_support(rqstp, cstate,
					open->op_bmval, nfsd41_ex_attrmask);
	}

	return status;
}

144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172
static int
is_create_with_attrs(struct nfsd4_open *open)
{
	return open->op_create == NFS4_OPEN_CREATE
		&& (open->op_createmode == NFS4_CREATE_UNCHECKED
		    || open->op_createmode == NFS4_CREATE_GUARDED
		    || open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1);
}

/*
 * if error occurs when setting the acl, just clear the acl bit
 * in the returned attr bitmap.
 */
static void
do_set_nfs4_acl(struct svc_rqst *rqstp, struct svc_fh *fhp,
		struct nfs4_acl *acl, u32 *bmval)
{
	__be32 status;

	status = nfsd4_set_nfs4_acl(rqstp, fhp, acl);
	if (status)
		/*
		 * We should probably fail the whole open at this point,
		 * but we've already created the file, so it's too late;
		 * So this seems the least of evils:
		 */
		bmval[0] &= ~FATTR4_WORD0_ACL;
}

L
Linus Torvalds 已提交
173 174 175 176 177 178 179 180 181 182
static inline void
fh_dup2(struct svc_fh *dst, struct svc_fh *src)
{
	fh_put(dst);
	dget(src->fh_dentry);
	if (src->fh_export)
		cache_get(&src->fh_export->h);
	*dst = *src;
}

183
static __be32
184
do_open_permission(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open, int accmode)
L
Linus Torvalds 已提交
185
{
186
	__be32 status;
L
Linus Torvalds 已提交
187 188 189 190 191

	if (open->op_truncate &&
		!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
		return nfserr_inval;

192 193
	accmode |= NFSD_MAY_READ_IF_EXEC;

L
Linus Torvalds 已提交
194
	if (open->op_share_access & NFS4_SHARE_ACCESS_READ)
M
Miklos Szeredi 已提交
195
		accmode |= NFSD_MAY_READ;
196
	if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
M
Miklos Szeredi 已提交
197
		accmode |= (NFSD_MAY_WRITE | NFSD_MAY_TRUNC);
198
	if (open->op_share_deny & NFS4_SHARE_DENY_READ)
M
Miklos Szeredi 已提交
199
		accmode |= NFSD_MAY_WRITE;
L
Linus Torvalds 已提交
200 201 202 203 204 205

	status = fh_verify(rqstp, current_fh, S_IFREG, accmode);

	return status;
}

206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223
static __be32 nfsd_check_obj_isreg(struct svc_fh *fh)
{
	umode_t mode = fh->fh_dentry->d_inode->i_mode;

	if (S_ISREG(mode))
		return nfs_ok;
	if (S_ISDIR(mode))
		return nfserr_isdir;
	/*
	 * Using err_symlink as our catch-all case may look odd; but
	 * there's no other obvious error for this case in 4.0, and we
	 * happen to know that it will cause the linux v4 client to do
	 * the right thing on attempts to open something other than a
	 * regular file.
	 */
	return nfserr_symlink;
}

224 225 226 227 228 229 230 231
static void nfsd4_set_open_owner_reply_cache(struct nfsd4_compound_state *cstate, struct nfsd4_open *open, struct svc_fh *resfh)
{
	if (nfsd4_has_session(cstate))
		return;
	fh_copy_shallow(&open->op_openowner->oo_owner.so_replay.rp_openfh,
			&resfh->fh_handle);
}

232
static __be32
233
do_open_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
L
Linus Torvalds 已提交
234
{
235
	struct svc_fh *current_fh = &cstate->current_fh;
236
	struct svc_fh *resfh;
237
	int accmode;
238
	__be32 status;
L
Linus Torvalds 已提交
239

240 241 242 243
	resfh = kmalloc(sizeof(struct svc_fh), GFP_KERNEL);
	if (!resfh)
		return nfserr_jukebox;
	fh_init(resfh, NFS4_FHSIZE);
L
Linus Torvalds 已提交
244 245 246
	open->op_truncate = 0;

	if (open->op_create) {
B
Benny Halevy 已提交
247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
		/* FIXME: check session persistence and pnfs flags.
		 * The nfsv4.1 spec requires the following semantics:
		 *
		 * Persistent   | pNFS   | Server REQUIRED | Client Allowed
		 * Reply Cache  | server |                 |
		 * -------------+--------+-----------------+--------------------
		 * no           | no     | EXCLUSIVE4_1    | EXCLUSIVE4_1
		 *              |        |                 | (SHOULD)
		 *              |        | and EXCLUSIVE4  | or EXCLUSIVE4
		 *              |        |                 | (SHOULD NOT)
		 * no           | yes    | EXCLUSIVE4_1    | EXCLUSIVE4_1
		 * yes          | no     | GUARDED4        | GUARDED4
		 * yes          | yes    | GUARDED4        | GUARDED4
		 */

L
Linus Torvalds 已提交
262 263
		/*
		 * Note: create modes (UNCHECKED,GUARDED...) are the same
264
		 * in NFSv4 as in v3 except EXCLUSIVE4_1.
L
Linus Torvalds 已提交
265
		 */
266
		status = do_nfsd_create(rqstp, current_fh, open->op_fname.data,
L
Linus Torvalds 已提交
267
					open->op_fname.len, &open->op_iattr,
268
					resfh, open->op_createmode,
269
					(u32 *)open->op_verf.data,
270
					&open->op_truncate, &open->op_created);
271

272 273 274
		if (!status && open->op_label.len)
			nfsd4_security_inode_setsecctx(resfh, &open->op_label, open->op_bmval);

275 276 277 278
		/*
		 * Following rfc 3530 14.2.16, use the returned bitmask
		 * to indicate which attributes we used to store the
		 * verifier:
279 280
		 */
		if (open->op_createmode == NFS4_CREATE_EXCLUSIVE && status == 0)
281
			open->op_bmval[1] = (FATTR4_WORD1_TIME_ACCESS |
282
							FATTR4_WORD1_TIME_MODIFY);
283
	} else {
L
Linus Torvalds 已提交
284
		status = nfsd_lookup(rqstp, current_fh,
285
				     open->op_fname.data, open->op_fname.len, resfh);
L
Linus Torvalds 已提交
286 287
		fh_unlock(current_fh);
	}
288 289 290
	if (status)
		goto out;
	status = nfsd_check_obj_isreg(resfh);
291 292
	if (status)
		goto out;
L
Linus Torvalds 已提交
293

294
	if (is_create_with_attrs(open) && open->op_acl != NULL)
295
		do_set_nfs4_acl(rqstp, resfh, open->op_acl, open->op_bmval);
296

297
	nfsd4_set_open_owner_reply_cache(cstate, open, resfh);
298
	accmode = NFSD_MAY_NOP;
299 300
	if (open->op_created ||
			open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR)
301 302
		accmode |= NFSD_MAY_OWNER_OVERRIDE;
	status = do_open_permission(rqstp, resfh, open, accmode);
303
	set_change_info(&open->op_cinfo, current_fh);
304
	fh_dup2(current_fh, resfh);
305
out:
306 307
	fh_put(resfh);
	kfree(resfh);
L
Linus Torvalds 已提交
308 309 310
	return status;
}

311
static __be32
312
do_open_fhandle(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
L
Linus Torvalds 已提交
313
{
314
	struct svc_fh *current_fh = &cstate->current_fh;
315
	__be32 status;
316
	int accmode = 0;
L
Linus Torvalds 已提交
317 318 319 320 321 322 323

	/* We don't know the target directory, and therefore can not
	* set the change info
	*/

	memset(&open->op_cinfo, 0, sizeof(struct nfsd4_change_info));

324
	nfsd4_set_open_owner_reply_cache(cstate, open, current_fh);
L
Linus Torvalds 已提交
325 326 327

	open->op_truncate = (open->op_iattr.ia_valid & ATTR_SIZE) &&
		(open->op_iattr.ia_size == 0);
328 329 330 331 332 333 334 335 336 337 338
	/*
	 * In the delegation case, the client is telling us about an
	 * open that it *already* performed locally, some time ago.  We
	 * should let it succeed now if possible.
	 *
	 * In the case of a CLAIM_FH open, on the other hand, the client
	 * may be counting on us to enforce permissions (the Linux 4.1
	 * client uses this for normal opens, for example).
	 */
	if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH)
		accmode = NFSD_MAY_OWNER_OVERRIDE;
L
Linus Torvalds 已提交
339

340
	status = do_open_permission(rqstp, current_fh, open, accmode);
L
Linus Torvalds 已提交
341 342 343 344

	return status;
}

A
Andy Adamson 已提交
345 346 347 348 349 350 351 352 353
static void
copy_clientid(clientid_t *clid, struct nfsd4_session *session)
{
	struct nfsd4_sessionid *sid =
			(struct nfsd4_sessionid *)session->se_sessionid.data;

	clid->cl_boot = sid->clientid.cl_boot;
	clid->cl_id = sid->clientid.cl_id;
}
L
Linus Torvalds 已提交
354

355
static __be32
356
nfsd4_open(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
357
	   struct nfsd4_open *open)
L
Linus Torvalds 已提交
358
{
359
	__be32 status;
A
Andy Adamson 已提交
360
	struct nfsd4_compoundres *resp;
361 362
	struct net *net = SVC_NET(rqstp);
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
A
Andy Adamson 已提交
363

364
	dprintk("NFSD: nfsd4_open filename %.*s op_openowner %p\n",
L
Linus Torvalds 已提交
365
		(int)open->op_fname.len, open->op_fname.data,
366
		open->op_openowner);
L
Linus Torvalds 已提交
367 368 369 370 371

	/* This check required by spec. */
	if (open->op_create && open->op_claim_type != NFS4_OPEN_CLAIM_NULL)
		return nfserr_inval;

372
	open->op_created = 0;
373 374 375 376 377
	/*
	 * RFC5661 18.51.3
	 * Before RECLAIM_COMPLETE done, server should deny new lock
	 */
	if (nfsd4_has_session(cstate) &&
378 379
	    !test_bit(NFSD4_CLIENT_RECLAIM_COMPLETE,
		      &cstate->session->se_client->cl_flags) &&
380 381 382
	    open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS)
		return nfserr_grace;

A
Andy Adamson 已提交
383 384 385
	if (nfsd4_has_session(cstate))
		copy_clientid(&open->op_clientid, cstate->session);

L
Linus Torvalds 已提交
386 387 388
	nfs4_lock_state();

	/* check seqid for replay. set nfs4_owner */
A
Andy Adamson 已提交
389
	resp = rqstp->rq_resp;
390
	status = nfsd4_process_open1(&resp->cstate, open, nn);
A
Al Viro 已提交
391
	if (status == nfserr_replay_me) {
392
		struct nfs4_replay *rp = &open->op_openowner->oo_owner.so_replay;
393
		fh_put(&cstate->current_fh);
394 395
		fh_copy_shallow(&cstate->current_fh.fh_handle,
				&rp->rp_openfh);
M
Miklos Szeredi 已提交
396
		status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
L
Linus Torvalds 已提交
397 398 399 400
		if (status)
			dprintk("nfsd4_open: replay failed"
				" restoring previous filehandle\n");
		else
A
Al Viro 已提交
401
			status = nfserr_replay_me;
L
Linus Torvalds 已提交
402 403 404
	}
	if (status)
		goto out;
405 406 407 408
	if (open->op_xdr_error) {
		status = open->op_xdr_error;
		goto out;
	}
409

410 411 412 413
	status = nfsd4_check_open_attributes(rqstp, cstate, open);
	if (status)
		goto out;

414 415
	/* Openowner is now set, so sequence id will get bumped.  Now we need
	 * these checks before we do any creates: */
416
	status = nfserr_grace;
417
	if (locks_in_grace(net) && open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS)
418 419
		goto out;
	status = nfserr_no_grace;
420
	if (!locks_in_grace(net) && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
421
		goto out;
422

L
Linus Torvalds 已提交
423
	switch (open->op_claim_type) {
424
		case NFS4_OPEN_CLAIM_DELEGATE_CUR:
L
Linus Torvalds 已提交
425
		case NFS4_OPEN_CLAIM_NULL:
426
			status = do_open_lookup(rqstp, cstate, open);
L
Linus Torvalds 已提交
427 428 429 430
			if (status)
				goto out;
			break;
		case NFS4_OPEN_CLAIM_PREVIOUS:
431
			open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
432 433 434
			status = nfs4_check_open_reclaim(&open->op_clientid,
							 cstate->minorversion,
							 nn);
435 436
			if (status)
				goto out;
437 438
		case NFS4_OPEN_CLAIM_FH:
		case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
439
			status = do_open_fhandle(rqstp, cstate, open);
L
Linus Torvalds 已提交
440 441 442
			if (status)
				goto out;
			break;
443
		case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
L
Linus Torvalds 已提交
444
             	case NFS4_OPEN_CLAIM_DELEGATE_PREV:
445
			open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
446
			dprintk("NFSD: unsupported OPEN claim type %d\n",
L
Linus Torvalds 已提交
447 448 449 450
				open->op_claim_type);
			status = nfserr_notsupp;
			goto out;
		default:
451
			dprintk("NFSD: Invalid OPEN claim type %d\n",
L
Linus Torvalds 已提交
452 453 454 455 456 457 458 459 460
				open->op_claim_type);
			status = nfserr_inval;
			goto out;
	}
	/*
	 * nfsd4_process_open2() does the actual opening of the file.  If
	 * successful, it (1) truncates the file if open->op_truncate was
	 * set, (2) sets open->op_stateid, (3) sets open->op_delegation.
	 */
461
	status = nfsd4_process_open2(rqstp, &cstate->current_fh, open);
462
	WARN_ON(status && open->op_created);
L
Linus Torvalds 已提交
463
out:
464
	nfsd4_cleanup_open_state(open, status);
465
	if (open->op_openowner && !nfsd4_has_session(cstate))
466
		cstate->replay_owner = &open->op_openowner->oo_owner;
467 468
	nfsd4_bump_seqid(cstate, status);
	if (!cstate->replay_owner)
469
		nfs4_unlock_state();
L
Linus Torvalds 已提交
470 471 472
	return status;
}

473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490
/*
 * OPEN is the only seqid-mutating operation whose decoding can fail
 * with a seqid-mutating error (specifically, decoding of user names in
 * the attributes).  Therefore we have to do some processing to look up
 * the stateowner so that we can bump the seqid.
 */
static __be32 nfsd4_open_omfg(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_op *op)
{
	struct nfsd4_open *open = (struct nfsd4_open *)&op->u;

	if (!seqid_mutating_err(ntohl(op->status)))
		return op->status;
	if (nfsd4_has_session(cstate))
		return op->status;
	open->op_xdr_error = op->status;
	return nfsd4_open(rqstp, cstate, open);
}

L
Linus Torvalds 已提交
491 492 493
/*
 * filehandle-manipulating ops.
 */
494
static __be32
495 496
nfsd4_getfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
	    struct svc_fh **getfh)
L
Linus Torvalds 已提交
497
{
498
	if (!cstate->current_fh.fh_dentry)
L
Linus Torvalds 已提交
499 500
		return nfserr_nofilehandle;

501
	*getfh = &cstate->current_fh;
L
Linus Torvalds 已提交
502 503 504
	return nfs_ok;
}

505
static __be32
506 507
nfsd4_putfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
	    struct nfsd4_putfh *putfh)
L
Linus Torvalds 已提交
508
{
509 510 511 512
	fh_put(&cstate->current_fh);
	cstate->current_fh.fh_handle.fh_size = putfh->pf_fhlen;
	memcpy(&cstate->current_fh.fh_handle.fh_base, putfh->pf_fhval,
	       putfh->pf_fhlen);
513
	return fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_BYPASS_GSS);
L
Linus Torvalds 已提交
514 515
}

516
static __be32
517 518
nfsd4_putrootfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
		void *arg)
L
Linus Torvalds 已提交
519
{
520
	__be32 status;
L
Linus Torvalds 已提交
521

522
	fh_put(&cstate->current_fh);
523
	status = exp_pseudoroot(rqstp, &cstate->current_fh);
L
Linus Torvalds 已提交
524 525 526
	return status;
}

527
static __be32
528 529
nfsd4_restorefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
		void *arg)
L
Linus Torvalds 已提交
530
{
531
	if (!cstate->save_fh.fh_dentry)
L
Linus Torvalds 已提交
532 533
		return nfserr_restorefh;

534
	fh_dup2(&cstate->current_fh, &cstate->save_fh);
535 536 537 538
	if (HAS_STATE_ID(cstate, SAVED_STATE_ID_FLAG)) {
		memcpy(&cstate->current_stateid, &cstate->save_stateid, sizeof(stateid_t));
		SET_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
	}
L
Linus Torvalds 已提交
539 540 541
	return nfs_ok;
}

542
static __be32
543 544
nfsd4_savefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
	     void *arg)
L
Linus Torvalds 已提交
545
{
546
	if (!cstate->current_fh.fh_dentry)
L
Linus Torvalds 已提交
547 548
		return nfserr_nofilehandle;

549
	fh_dup2(&cstate->save_fh, &cstate->current_fh);
550 551 552 553
	if (HAS_STATE_ID(cstate, CURRENT_STATE_ID_FLAG)) {
		memcpy(&cstate->save_stateid, &cstate->current_stateid, sizeof(stateid_t));
		SET_STATE_ID(cstate, SAVED_STATE_ID_FLAG);
	}
L
Linus Torvalds 已提交
554 555 556 557 558 559
	return nfs_ok;
}

/*
 * misc nfsv4 ops
 */
560
static __be32
561 562
nfsd4_access(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
	     struct nfsd4_access *access)
L
Linus Torvalds 已提交
563 564 565 566 567
{
	if (access->ac_req_access & ~NFS3_ACCESS_FULL)
		return nfserr_inval;

	access->ac_resp_access = access->ac_req_access;
568 569
	return nfsd_access(rqstp, &cstate->current_fh, &access->ac_resp_access,
			   &access->ac_supported);
L
Linus Torvalds 已提交
570 571
}

572
static void gen_boot_verifier(nfs4_verifier *verifier, struct net *net)
573 574
{
	__be32 verf[2];
575
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
576

577 578
	verf[0] = (__be32)nn->nfssvc_boot.tv_sec;
	verf[1] = (__be32)nn->nfssvc_boot.tv_usec;
579 580 581
	memcpy(verifier->data, verf, sizeof(verifier->data));
}

582
static __be32
583 584
nfsd4_commit(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
	     struct nfsd4_commit *commit)
L
Linus Torvalds 已提交
585
{
586
	gen_boot_verifier(&commit->co_verf, SVC_NET(rqstp));
587
	return nfsd_commit(rqstp, &cstate->current_fh, commit->co_offset,
588
			     commit->co_count);
L
Linus Torvalds 已提交
589 590
}

591
static __be32
592 593
nfsd4_create(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
	     struct nfsd4_create *create)
L
Linus Torvalds 已提交
594 595
{
	struct svc_fh resfh;
596
	__be32 status;
L
Linus Torvalds 已提交
597 598 599 600
	dev_t rdev;

	fh_init(&resfh, NFS4_FHSIZE);

M
Miklos Szeredi 已提交
601 602
	status = fh_verify(rqstp, &cstate->current_fh, S_IFDIR,
			   NFSD_MAY_CREATE);
L
Linus Torvalds 已提交
603 604 605
	if (status)
		return status;

606 607 608 609 610
	status = check_attr_support(rqstp, cstate, create->cr_bmval,
				    nfsd_attrmask);
	if (status)
		return status;

L
Linus Torvalds 已提交
611 612 613 614 615 616 617 618 619 620 621
	switch (create->cr_type) {
	case NF4LNK:
		/* ugh! we have to null-terminate the linktext, or
		 * vfs_symlink() will choke.  it is always safe to
		 * null-terminate by brute force, since at worst we
		 * will overwrite the first byte of the create namelen
		 * in the XDR buffer, which has already been extracted
		 * during XDR decode.
		 */
		create->cr_linkname[create->cr_linklen] = 0;

622 623 624 625
		status = nfsd_symlink(rqstp, &cstate->current_fh,
				      create->cr_name, create->cr_namelen,
				      create->cr_linkname, create->cr_linklen,
				      &resfh, &create->cr_iattr);
L
Linus Torvalds 已提交
626 627 628 629 630 631 632
		break;

	case NF4BLK:
		rdev = MKDEV(create->cr_specdata1, create->cr_specdata2);
		if (MAJOR(rdev) != create->cr_specdata1 ||
		    MINOR(rdev) != create->cr_specdata2)
			return nfserr_inval;
633 634 635
		status = nfsd_create(rqstp, &cstate->current_fh,
				     create->cr_name, create->cr_namelen,
				     &create->cr_iattr, S_IFBLK, rdev, &resfh);
L
Linus Torvalds 已提交
636 637 638 639 640 641 642
		break;

	case NF4CHR:
		rdev = MKDEV(create->cr_specdata1, create->cr_specdata2);
		if (MAJOR(rdev) != create->cr_specdata1 ||
		    MINOR(rdev) != create->cr_specdata2)
			return nfserr_inval;
643 644 645
		status = nfsd_create(rqstp, &cstate->current_fh,
				     create->cr_name, create->cr_namelen,
				     &create->cr_iattr,S_IFCHR, rdev, &resfh);
L
Linus Torvalds 已提交
646 647 648
		break;

	case NF4SOCK:
649 650 651
		status = nfsd_create(rqstp, &cstate->current_fh,
				     create->cr_name, create->cr_namelen,
				     &create->cr_iattr, S_IFSOCK, 0, &resfh);
L
Linus Torvalds 已提交
652 653 654
		break;

	case NF4FIFO:
655 656 657
		status = nfsd_create(rqstp, &cstate->current_fh,
				     create->cr_name, create->cr_namelen,
				     &create->cr_iattr, S_IFIFO, 0, &resfh);
L
Linus Torvalds 已提交
658 659 660 661
		break;

	case NF4DIR:
		create->cr_iattr.ia_valid &= ~ATTR_SIZE;
662 663 664
		status = nfsd_create(rqstp, &cstate->current_fh,
				     create->cr_name, create->cr_namelen,
				     &create->cr_iattr, S_IFDIR, 0, &resfh);
L
Linus Torvalds 已提交
665 666 667 668 669 670
		break;

	default:
		status = nfserr_badtype;
	}

671 672
	if (status)
		goto out;
L
Linus Torvalds 已提交
673

674 675 676
	if (create->cr_label.len)
		nfsd4_security_inode_setsecctx(&resfh, &create->cr_label, create->cr_bmval);

677 678 679 680 681 682 683 684
	if (create->cr_acl != NULL)
		do_set_nfs4_acl(rqstp, &resfh, create->cr_acl,
				create->cr_bmval);

	fh_unlock(&cstate->current_fh);
	set_change_info(&create->cr_cinfo, &cstate->current_fh);
	fh_dup2(&cstate->current_fh, &resfh);
out:
L
Linus Torvalds 已提交
685 686 687 688
	fh_put(&resfh);
	return status;
}

689
static __be32
690 691
nfsd4_getattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
	      struct nfsd4_getattr *getattr)
L
Linus Torvalds 已提交
692
{
693
	__be32 status;
L
Linus Torvalds 已提交
694

M
Miklos Szeredi 已提交
695
	status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
L
Linus Torvalds 已提交
696 697 698 699 700 701
	if (status)
		return status;

	if (getattr->ga_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)
		return nfserr_inval;

702 703 704
	getattr->ga_bmval[0] &= nfsd_suppattrs0(cstate->minorversion);
	getattr->ga_bmval[1] &= nfsd_suppattrs1(cstate->minorversion);
	getattr->ga_bmval[2] &= nfsd_suppattrs2(cstate->minorversion);
L
Linus Torvalds 已提交
705

706
	getattr->ga_fhp = &cstate->current_fh;
L
Linus Torvalds 已提交
707 708 709
	return nfs_ok;
}

710
static __be32
711 712
nfsd4_link(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
	   struct nfsd4_link *link)
L
Linus Torvalds 已提交
713
{
714
	__be32 status = nfserr_nofilehandle;
L
Linus Torvalds 已提交
715

716
	if (!cstate->save_fh.fh_dentry)
L
Linus Torvalds 已提交
717
		return status;
718 719
	status = nfsd_link(rqstp, &cstate->current_fh,
			   link->li_name, link->li_namelen, &cstate->save_fh);
L
Linus Torvalds 已提交
720
	if (!status)
721
		set_change_info(&link->li_cinfo, &cstate->current_fh);
L
Linus Torvalds 已提交
722 723 724
	return status;
}

725
static __be32 nfsd4_do_lookupp(struct svc_rqst *rqstp, struct svc_fh *fh)
L
Linus Torvalds 已提交
726 727
{
	struct svc_fh tmp_fh;
728
	__be32 ret;
L
Linus Torvalds 已提交
729 730

	fh_init(&tmp_fh, NFS4_FHSIZE);
731 732
	ret = exp_pseudoroot(rqstp, &tmp_fh);
	if (ret)
L
Linus Torvalds 已提交
733
		return ret;
734
	if (tmp_fh.fh_dentry == fh->fh_dentry) {
L
Linus Torvalds 已提交
735 736 737 738
		fh_put(&tmp_fh);
		return nfserr_noent;
	}
	fh_put(&tmp_fh);
739 740 741 742 743 744 745 746
	return nfsd_lookup(rqstp, fh, "..", 2, fh);
}

static __be32
nfsd4_lookupp(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
	      void *arg)
{
	return nfsd4_do_lookupp(rqstp, &cstate->current_fh);
L
Linus Torvalds 已提交
747 748
}

749
static __be32
750 751
nfsd4_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
	     struct nfsd4_lookup *lookup)
L
Linus Torvalds 已提交
752
{
753 754 755
	return nfsd_lookup(rqstp, &cstate->current_fh,
			   lookup->lo_name, lookup->lo_len,
			   &cstate->current_fh);
L
Linus Torvalds 已提交
756 757
}

758
static __be32
759 760
nfsd4_read(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
	   struct nfsd4_read *read)
L
Linus Torvalds 已提交
761
{
762
	__be32 status;
L
Linus Torvalds 已提交
763 764 765

	/* no need to check permission - this will be done in nfsd_read() */

766
	read->rd_filp = NULL;
L
Linus Torvalds 已提交
767 768 769
	if (read->rd_offset >= OFFSET_MAX)
		return nfserr_inval;

770 771 772 773 774 775 776 777 778 779 780
	/*
	 * If we do a zero copy read, then a client will see read data
	 * that reflects the state of the file *after* performing the
	 * following compound.
	 *
	 * To ensure proper ordering, we therefore turn off zero copy if
	 * the client wants us to do more in this compound:
	 */
	if (!nfsd4_last_compound_op(rqstp))
		rqstp->rq_splice_ok = false;

L
Linus Torvalds 已提交
781 782
	nfs4_lock_state();
	/* check stateid */
783 784
	if ((status = nfs4_preprocess_stateid_op(SVC_NET(rqstp),
						 cstate, &read->rd_stateid,
785
						 RD_STATE, &read->rd_filp))) {
L
Linus Torvalds 已提交
786 787 788
		dprintk("NFSD: nfsd4_read: couldn't process stateid!\n");
		goto out;
	}
789 790
	if (read->rd_filp)
		get_file(read->rd_filp);
L
Linus Torvalds 已提交
791 792 793 794
	status = nfs_ok;
out:
	nfs4_unlock_state();
	read->rd_rqstp = rqstp;
795
	read->rd_fhp = &cstate->current_fh;
L
Linus Torvalds 已提交
796 797 798
	return status;
}

799
static __be32
800 801
nfsd4_readdir(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
	      struct nfsd4_readdir *readdir)
L
Linus Torvalds 已提交
802 803 804 805 806 807 808 809 810
{
	u64 cookie = readdir->rd_cookie;
	static const nfs4_verifier zeroverf;

	/* no need to check permission - this will be done in nfsd_readdir() */

	if (readdir->rd_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)
		return nfserr_inval;

811 812 813
	readdir->rd_bmval[0] &= nfsd_suppattrs0(cstate->minorversion);
	readdir->rd_bmval[1] &= nfsd_suppattrs1(cstate->minorversion);
	readdir->rd_bmval[2] &= nfsd_suppattrs2(cstate->minorversion);
L
Linus Torvalds 已提交
814

815
	if ((cookie == 1) || (cookie == 2) ||
L
Linus Torvalds 已提交
816 817 818 819
	    (cookie == 0 && memcmp(readdir->rd_verf.data, zeroverf.data, NFS4_VERIFIER_SIZE)))
		return nfserr_bad_cookie;

	readdir->rd_rqstp = rqstp;
820
	readdir->rd_fhp = &cstate->current_fh;
L
Linus Torvalds 已提交
821 822 823
	return nfs_ok;
}

824
static __be32
825 826
nfsd4_readlink(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
	       struct nfsd4_readlink *readlink)
L
Linus Torvalds 已提交
827 828
{
	readlink->rl_rqstp = rqstp;
829
	readlink->rl_fhp = &cstate->current_fh;
L
Linus Torvalds 已提交
830 831 832
	return nfs_ok;
}

833
static __be32
834 835
nfsd4_remove(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
	     struct nfsd4_remove *remove)
L
Linus Torvalds 已提交
836
{
837
	__be32 status;
L
Linus Torvalds 已提交
838

839
	if (locks_in_grace(SVC_NET(rqstp)))
840
		return nfserr_grace;
841 842
	status = nfsd_unlink(rqstp, &cstate->current_fh, 0,
			     remove->rm_name, remove->rm_namelen);
L
Linus Torvalds 已提交
843
	if (!status) {
844 845
		fh_unlock(&cstate->current_fh);
		set_change_info(&remove->rm_cinfo, &cstate->current_fh);
L
Linus Torvalds 已提交
846 847 848 849
	}
	return status;
}

850
static __be32
851 852
nfsd4_rename(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
	     struct nfsd4_rename *rename)
L
Linus Torvalds 已提交
853
{
854
	__be32 status = nfserr_nofilehandle;
L
Linus Torvalds 已提交
855

856
	if (!cstate->save_fh.fh_dentry)
L
Linus Torvalds 已提交
857
		return status;
858 859
	if (locks_in_grace(SVC_NET(rqstp)) &&
		!(cstate->save_fh.fh_export->ex_flags & NFSEXP_NOSUBTREECHECK))
860
		return nfserr_grace;
861 862
	status = nfsd_rename(rqstp, &cstate->save_fh, rename->rn_sname,
			     rename->rn_snamelen, &cstate->current_fh,
L
Linus Torvalds 已提交
863
			     rename->rn_tname, rename->rn_tnamelen);
864 865 866 867 868
	if (status)
		return status;
	set_change_info(&rename->rn_sinfo, &cstate->current_fh);
	set_change_info(&rename->rn_tinfo, &cstate->save_fh);
	return nfs_ok;
L
Linus Torvalds 已提交
869 870
}

A
Andy Adamson 已提交
871 872 873 874 875 876 877 878 879 880
static __be32
nfsd4_secinfo(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
	      struct nfsd4_secinfo *secinfo)
{
	struct svc_fh resfh;
	struct svc_export *exp;
	struct dentry *dentry;
	__be32 err;

	fh_init(&resfh, NFS4_FHSIZE);
881 882 883
	err = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_EXEC);
	if (err)
		return err;
A
Andy Adamson 已提交
884 885 886 887 888 889 890 891 892 893 894
	err = nfsd_lookup_dentry(rqstp, &cstate->current_fh,
				    secinfo->si_name, secinfo->si_namelen,
				    &exp, &dentry);
	if (err)
		return err;
	if (dentry->d_inode == NULL) {
		exp_put(exp);
		err = nfserr_noent;
	} else
		secinfo->si_exp = exp;
	dput(dentry);
895 896 897
	if (cstate->minorversion)
		/* See rfc 5661 section 2.6.3.1.1.8 */
		fh_put(&cstate->current_fh);
A
Andy Adamson 已提交
898 899 900
	return err;
}

J
J. Bruce Fields 已提交
901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923
static __be32
nfsd4_secinfo_no_name(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
	      struct nfsd4_secinfo_no_name *sin)
{
	__be32 err;

	switch (sin->sin_style) {
	case NFS4_SECINFO_STYLE4_CURRENT_FH:
		break;
	case NFS4_SECINFO_STYLE4_PARENT:
		err = nfsd4_do_lookupp(rqstp, &cstate->current_fh);
		if (err)
			return err;
		break;
	default:
		return nfserr_inval;
	}
	exp_get(cstate->current_fh.fh_export);
	sin->sin_exp = cstate->current_fh.fh_export;
	fh_put(&cstate->current_fh);
	return nfs_ok;
}

924
static __be32
925 926
nfsd4_setattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
	      struct nfsd4_setattr *setattr)
L
Linus Torvalds 已提交
927
{
928
	__be32 status = nfs_ok;
929
	int err;
L
Linus Torvalds 已提交
930 931 932

	if (setattr->sa_iattr.ia_valid & ATTR_SIZE) {
		nfs4_lock_state();
933
		status = nfs4_preprocess_stateid_op(SVC_NET(rqstp), cstate,
934
			&setattr->sa_stateid, WR_STATE, NULL);
L
Linus Torvalds 已提交
935
		nfs4_unlock_state();
936
		if (status) {
937
			dprintk("NFSD: nfsd4_setattr: couldn't process stateid!\n");
938 939
			return status;
		}
L
Linus Torvalds 已提交
940
	}
941 942 943
	err = fh_want_write(&cstate->current_fh);
	if (err)
		return nfserrno(err);
L
Linus Torvalds 已提交
944
	status = nfs_ok;
945 946 947 948 949 950

	status = check_attr_support(rqstp, cstate, setattr->sa_bmval,
				    nfsd_attrmask);
	if (status)
		goto out;

L
Linus Torvalds 已提交
951
	if (setattr->sa_acl != NULL)
952 953
		status = nfsd4_set_nfs4_acl(rqstp, &cstate->current_fh,
					    setattr->sa_acl);
L
Linus Torvalds 已提交
954
	if (status)
955
		goto out;
956 957 958 959 960
	if (setattr->sa_label.len)
		status = nfsd4_set_nfs4_label(rqstp, &cstate->current_fh,
				&setattr->sa_label);
	if (status)
		goto out;
961
	status = nfsd_setattr(rqstp, &cstate->current_fh, &setattr->sa_iattr,
L
Linus Torvalds 已提交
962
				0, (time_t)0);
963
out:
A
Al Viro 已提交
964
	fh_drop_write(&cstate->current_fh);
L
Linus Torvalds 已提交
965 966 967
	return status;
}

968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985
static int fill_in_write_vector(struct kvec *vec, struct nfsd4_write *write)
{
        int i = 1;
        int buflen = write->wr_buflen;

        vec[0].iov_base = write->wr_head.iov_base;
        vec[0].iov_len = min_t(int, buflen, write->wr_head.iov_len);
        buflen -= vec[0].iov_len;

        while (buflen) {
                vec[i].iov_base = page_address(write->wr_pagelist[i - 1]);
                vec[i].iov_len = min_t(int, PAGE_SIZE, buflen);
                buflen -= vec[i].iov_len;
                i++;
        }
        return i;
}

986
static __be32
987 988
nfsd4_write(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
	    struct nfsd4_write *write)
L
Linus Torvalds 已提交
989 990 991
{
	stateid_t *stateid = &write->wr_stateid;
	struct file *filp = NULL;
992
	__be32 status = nfs_ok;
993
	unsigned long cnt;
994
	int nvecs;
L
Linus Torvalds 已提交
995 996 997 998 999 1000 1001

	/* no need to check permission - this will be done in nfsd_write() */

	if (write->wr_offset >= OFFSET_MAX)
		return nfserr_inval;

	nfs4_lock_state();
1002 1003
	status = nfs4_preprocess_stateid_op(SVC_NET(rqstp),
					cstate, stateid, WR_STATE, &filp);
1004
	if (status) {
1005
		nfs4_unlock_state();
1006 1007 1008
		dprintk("NFSD: nfsd4_write: couldn't process stateid!\n");
		return status;
	}
1009 1010 1011
	if (filp)
		get_file(filp);
	nfs4_unlock_state();
1012

1013
	cnt = write->wr_buflen;
L
Linus Torvalds 已提交
1014
	write->wr_how_written = write->wr_stable_how;
1015
	gen_boot_verifier(&write->wr_verifier, SVC_NET(rqstp));
L
Linus Torvalds 已提交
1016

1017 1018 1019
	nvecs = fill_in_write_vector(rqstp->rq_vec, write);
	WARN_ON_ONCE(nvecs > ARRAY_SIZE(rqstp->rq_vec));

1020
	status =  nfsd_write(rqstp, &cstate->current_fh, filp,
1021
			     write->wr_offset, rqstp->rq_vec, nvecs,
1022
			     &cnt, &write->wr_how_written);
1023 1024
	if (filp)
		fput(filp);
L
Linus Torvalds 已提交
1025

1026 1027
	write->wr_bytes_written = cnt;

L
Linus Torvalds 已提交
1028 1029 1030 1031 1032 1033 1034 1035
	return status;
}

/* This routine never returns NFS_OK!  If there are no other errors, it
 * will return NFSERR_SAME or NFSERR_NOT_SAME depending on whether the
 * attributes matched.  VERIFY is implemented by mapping NFSERR_SAME
 * to NFS_OK after the call; NVERIFY by mapping NFSERR_NOT_SAME to NFS_OK.
 */
1036
static __be32
1037
_nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1038
	     struct nfsd4_verify *verify)
L
Linus Torvalds 已提交
1039
{
A
Al Viro 已提交
1040
	__be32 *buf, *p;
L
Linus Torvalds 已提交
1041
	int count;
1042
	__be32 status;
L
Linus Torvalds 已提交
1043

M
Miklos Szeredi 已提交
1044
	status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
L
Linus Torvalds 已提交
1045 1046 1047
	if (status)
		return status;

1048 1049 1050 1051
	status = check_attr_support(rqstp, cstate, verify->ve_bmval, NULL);
	if (status)
		return status;

L
Linus Torvalds 已提交
1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063
	if ((verify->ve_bmval[0] & FATTR4_WORD0_RDATTR_ERROR)
	    || (verify->ve_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1))
		return nfserr_inval;
	if (verify->ve_attrlen & 3)
		return nfserr_inval;

	/* count in words:
	 *   bitmap_len(1) + bitmap(2) + attr_len(1) = 4
	 */
	count = 4 + (verify->ve_attrlen >> 2);
	buf = kmalloc(count << 2, GFP_KERNEL);
	if (!buf)
1064
		return nfserr_jukebox;
L
Linus Torvalds 已提交
1065

1066
	p = buf;
1067 1068
	status = nfsd4_encode_fattr(&cstate->current_fh,
				    cstate->current_fh.fh_export,
1069 1070
				    cstate->current_fh.fh_dentry, &p,
				    count, verify->ve_bmval,
1071
				    rqstp, 0);
L
Linus Torvalds 已提交
1072 1073

	/* this means that nfsd4_encode_fattr() ran out of space */
1074
	if (status == nfserr_resource)
L
Linus Torvalds 已提交
1075 1076 1077 1078
		status = nfserr_not_same;
	if (status)
		goto out_kfree;

1079 1080
	/* skip bitmap */
	p = buf + 1 + ntohl(buf[0]);
L
Linus Torvalds 已提交
1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091
	status = nfserr_not_same;
	if (ntohl(*p++) != verify->ve_attrlen)
		goto out_kfree;
	if (!memcmp(p, verify->ve_attrval, verify->ve_attrlen))
		status = nfserr_same;

out_kfree:
	kfree(buf);
	return status;
}

1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111
static __be32
nfsd4_nverify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
	      struct nfsd4_verify *verify)
{
	__be32 status;

	status = _nfsd4_verify(rqstp, cstate, verify);
	return status == nfserr_not_same ? nfs_ok : status;
}

static __be32
nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
	     struct nfsd4_verify *verify)
{
	__be32 status;

	status = _nfsd4_verify(rqstp, cstate, verify);
	return status == nfserr_same ? nfs_ok : status;
}

L
Linus Torvalds 已提交
1112 1113 1114
/*
 * NULL call.
 */
A
Al Viro 已提交
1115
static __be32
L
Linus Torvalds 已提交
1116 1117 1118 1119 1120
nfsd4_proc_null(struct svc_rqst *rqstp, void *argp, void *resp)
{
	return nfs_ok;
}

1121 1122 1123 1124 1125 1126
static inline void nfsd4_increment_op_stats(u32 opnum)
{
	if (opnum >= FIRST_NFS4_OP && opnum <= LAST_NFS4_OP)
		nfsdstats.nfs4_opcount[opnum]++;
}

1127 1128
typedef __be32(*nfsd4op_func)(struct svc_rqst *, struct nfsd4_compound_state *,
			      void *);
1129
typedef u32(*nfsd4op_rsize)(struct svc_rqst *, struct nfsd4_op *op);
1130 1131
typedef void(*stateid_setter)(struct nfsd4_compound_state *, void *);
typedef void(*stateid_getter)(struct nfsd4_compound_state *, void *);
1132

1133 1134
enum nfsd4_op_flags {
	ALLOWED_WITHOUT_FH = 1 << 0,	/* No current filehandle required */
1135 1136
	ALLOWED_ON_ABSENT_FS = 1 << 1,	/* ops processed on absent fs */
	ALLOWED_AS_FIRST_OP = 1 << 2,	/* ops reqired first in compound */
1137 1138 1139
	/* For rfc 5661 section 2.6.3.1.1: */
	OP_HANDLES_WRONGSEC = 1 << 3,
	OP_IS_PUTFH_LIKE = 1 << 4,
1140
	/*
1141 1142 1143 1144 1145 1146 1147 1148
	 * These are the ops whose result size we estimate before
	 * encoding, to avoid performing an op then not being able to
	 * respond or cache a response.  This includes writes and setattrs
	 * as well as the operations usually called "nonidempotent":
	 */
	OP_MODIFIES_SOMETHING = 1 << 5,
	/*
	 * Cache compounds containing these ops in the xid-based drc:
1149 1150 1151 1152 1153 1154 1155
	 * We use the DRC for compounds containing non-idempotent
	 * operations, *except* those that are 4.1-specific (since
	 * sessions provide their own EOS), and except for stateful
	 * operations other than setclientid and setclientid_confirm
	 * (since sequence numbers provide EOS for open, lock, etc in
	 * the v4.0 case).
	 */
1156
	OP_CACHEME = 1 << 6,
1157 1158 1159 1160
	/*
	 * These are ops which clear current state id.
	 */
	OP_CLEAR_STATEID = 1 << 7,
1161 1162 1163 1164 1165 1166
};

struct nfsd4_operation {
	nfsd4op_func op_func;
	u32 op_flags;
	char *op_name;
1167 1168
	/* Try to get response size before operation */
	nfsd4op_rsize op_rsize_bop;
1169 1170
	stateid_getter op_get_currentstateid;
	stateid_setter op_set_currentstateid;
1171 1172 1173 1174
};

static struct nfsd4_operation nfsd4_ops[];

1175
#ifdef NFSD_DEBUG
A
Adrian Bunk 已提交
1176
static const char *nfsd4_op_name(unsigned opnum);
1177
#endif
B
Benny Halevy 已提交
1178

1179
/*
1180
 * Enforce NFSv4.1 COMPOUND ordering rules:
1181
 *
1182 1183 1184
 * Also note, enforced elsewhere:
 *	- SEQUENCE other than as first op results in
 *	  NFS4ERR_SEQUENCE_POS. (Enforced in nfsd4_sequence().)
1185 1186
 *	- BIND_CONN_TO_SESSION must be the only op in its compound.
 *	  (Enforced in nfsd4_bind_conn_to_session().)
1187 1188 1189
 *	- DESTROY_SESSION must be the final operation in a compound, if
 *	  sessionid's in SEQUENCE and DESTROY_SESSION are the same.
 *	  (Enforced in nfsd4_destroy_session().)
1190
 */
1191
static __be32 nfs41_check_op_ordering(struct nfsd4_compoundargs *args)
1192
{
1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209
	struct nfsd4_op *op = &args->ops[0];

	/* These ordering requirements don't apply to NFSv4.0: */
	if (args->minorversion == 0)
		return nfs_ok;
	/* This is weird, but OK, not our problem: */
	if (args->opcnt == 0)
		return nfs_ok;
	if (op->status == nfserr_op_illegal)
		return nfs_ok;
	if (!(nfsd4_ops[op->opnum].op_flags & ALLOWED_AS_FIRST_OP))
		return nfserr_op_not_in_session;
	if (op->opnum == OP_SEQUENCE)
		return nfs_ok;
	if (args->opcnt != 1)
		return nfserr_not_only_op;
	return nfs_ok;
1210 1211
}

J
J. Bruce Fields 已提交
1212 1213 1214 1215 1216
static inline struct nfsd4_operation *OPDESC(struct nfsd4_op *op)
{
	return &nfsd4_ops[op->opnum];
}

1217 1218
bool nfsd4_cache_this_op(struct nfsd4_op *op)
{
1219
	return OPDESC(op)->op_flags & OP_CACHEME;
1220 1221
}

1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254
static bool need_wrongsec_check(struct svc_rqst *rqstp)
{
	struct nfsd4_compoundres *resp = rqstp->rq_resp;
	struct nfsd4_compoundargs *argp = rqstp->rq_argp;
	struct nfsd4_op *this = &argp->ops[resp->opcnt - 1];
	struct nfsd4_op *next = &argp->ops[resp->opcnt];
	struct nfsd4_operation *thisd;
	struct nfsd4_operation *nextd;

	thisd = OPDESC(this);
	/*
	 * Most ops check wronsec on our own; only the putfh-like ops
	 * have special rules.
	 */
	if (!(thisd->op_flags & OP_IS_PUTFH_LIKE))
		return false;
	/*
	 * rfc 5661 2.6.3.1.1.6: don't bother erroring out a
	 * put-filehandle operation if we're not going to use the
	 * result:
	 */
	if (argp->opcnt == resp->opcnt)
		return false;

	nextd = OPDESC(next);
	/*
	 * Rest of 2.6.3.1.1: certain operations will return WRONGSEC
	 * errors themselves as necessary; others should check for them
	 * now:
	 */
	return !(nextd->op_flags & OP_HANDLES_WRONGSEC);
}

L
Linus Torvalds 已提交
1255 1256 1257
/*
 * COMPOUND call.
 */
A
Al Viro 已提交
1258
static __be32
L
Linus Torvalds 已提交
1259 1260 1261 1262 1263
nfsd4_proc_compound(struct svc_rqst *rqstp,
		    struct nfsd4_compoundargs *args,
		    struct nfsd4_compoundres *resp)
{
	struct nfsd4_op	*op;
1264
	struct nfsd4_operation *opdesc;
1265
	struct nfsd4_compound_state *cstate = &resp->cstate;
1266
	int		slack_bytes;
1267
	u32		plen = 0;
1268
	__be32		status;
L
Linus Torvalds 已提交
1269 1270

	resp->xbuf = &rqstp->rq_res;
1271 1272
	resp->p = rqstp->rq_res.head[0].iov_base +
						rqstp->rq_res.head[0].iov_len;
L
Linus Torvalds 已提交
1273 1274 1275 1276 1277 1278 1279 1280
	resp->tagp = resp->p;
	/* reserve space for: taglen, tag, and opcnt */
	resp->p += 2 + XDR_QUADLEN(args->taglen);
	resp->end = rqstp->rq_res.head[0].iov_base + PAGE_SIZE;
	resp->taglen = args->taglen;
	resp->tag = args->tag;
	resp->opcnt = 0;
	resp->rqstp = rqstp;
A
Andy Adamson 已提交
1281
	resp->cstate.minorversion = args->minorversion;
1282
	resp->cstate.replay_owner = NULL;
1283
	resp->cstate.session = NULL;
1284 1285
	fh_init(&resp->cstate.current_fh, NFS4_FHSIZE);
	fh_init(&resp->cstate.save_fh, NFS4_FHSIZE);
N
NeilBrown 已提交
1286 1287 1288 1289 1290
	/*
	 * Don't use the deferral mechanism for NFSv4; compounds make it
	 * too hard to avoid non-idempotency problems.
	 */
	rqstp->rq_usedeferral = 0;
L
Linus Torvalds 已提交
1291 1292 1293 1294 1295

	/*
	 * According to RFC3010, this takes precedence over all other errors.
	 */
	status = nfserr_minor_vers_mismatch;
1296
	if (nfsd_minorversion(args->minorversion, NFSD_TEST) <= 0)
L
Linus Torvalds 已提交
1297 1298
		goto out;

1299 1300
	status = nfs41_check_op_ordering(args);
	if (status) {
1301
		op = &args->ops[0];
1302
		op->status = status;
1303 1304 1305
		goto encode_op;
	}

L
Linus Torvalds 已提交
1306 1307 1308
	while (!status && resp->opcnt < args->opcnt) {
		op = &args->ops[resp->opcnt++];

B
Benny Halevy 已提交
1309 1310 1311
		dprintk("nfsv4 compound op #%d/%d: %d (%s)\n",
			resp->opcnt, args->opcnt, op->opnum,
			nfsd4_op_name(op->opnum));
L
Linus Torvalds 已提交
1312 1313 1314 1315 1316
		/*
		 * The XDR decode routines may have pre-set op->status;
		 * for example, if there is a miscellaneous XDR error
		 * it will be set to nfserr_bad_xdr.
		 */
1317 1318 1319
		if (op->status) {
			if (op->opnum == OP_OPEN)
				op->status = nfsd4_open_omfg(rqstp, cstate, op);
L
Linus Torvalds 已提交
1320
			goto encode_op;
1321
		}
L
Linus Torvalds 已提交
1322 1323 1324 1325 1326 1327

		/* We must be able to encode a successful response to
		 * this operation, with enough room left over to encode a
		 * failed response to the next operation.  If we don't
		 * have enough room, fail with ERR_RESOURCE.
		 */
1328 1329 1330 1331
		slack_bytes = (char *)resp->end - (char *)resp->p;
		if (slack_bytes < COMPOUND_SLACK_SPACE
				+ COMPOUND_ERR_SLACK_SPACE) {
			BUG_ON(slack_bytes < COMPOUND_ERR_SLACK_SPACE);
L
Linus Torvalds 已提交
1332 1333 1334 1335
			op->status = nfserr_resource;
			goto encode_op;
		}

J
J. Bruce Fields 已提交
1336
		opdesc = OPDESC(op);
1337

1338
		if (!cstate->current_fh.fh_dentry) {
1339
			if (!(opdesc->op_flags & ALLOWED_WITHOUT_FH)) {
1340 1341 1342
				op->status = nfserr_nofilehandle;
				goto encode_op;
			}
1343 1344
		} else if (cstate->current_fh.fh_export->ex_fslocs.migrated &&
			  !(opdesc->op_flags & ALLOWED_ON_ABSENT_FS)) {
1345
			op->status = nfserr_moved;
L
Linus Torvalds 已提交
1346 1347
			goto encode_op;
		}
1348

1349 1350 1351 1352 1353 1354 1355 1356 1357
		/* If op is non-idempotent */
		if (opdesc->op_flags & OP_MODIFIES_SOMETHING) {
			plen = opdesc->op_rsize_bop(rqstp, op);
			op->status = nfsd4_check_resp_size(resp, plen);
		}

		if (op->status)
			goto encode_op;

J
J. Bruce Fields 已提交
1358 1359 1360
		if (opdesc->op_get_currentstateid)
			opdesc->op_get_currentstateid(cstate, &op->u);
		op->status = opdesc->op_func(rqstp, cstate, &op->u);
L
Linus Torvalds 已提交
1361

1362 1363 1364 1365 1366
		if (!op->status) {
			if (opdesc->op_set_currentstateid)
				opdesc->op_set_currentstateid(cstate, &op->u);

			if (opdesc->op_flags & OP_CLEAR_STATEID)
1367
				clear_current_stateid(cstate);
1368 1369 1370 1371

			if (need_wrongsec_check(rqstp))
				op->status = check_nfsd_access(cstate->current_fh.fh_export, rqstp);
		}
1372

L
Linus Torvalds 已提交
1373
encode_op:
1374
		/* Only from SEQUENCE */
A
Andy Adamson 已提交
1375 1376
		if (resp->cstate.status == nfserr_replay_cache) {
			dprintk("%s NFS4.1 replay from cache\n", __func__);
1377
			status = op->status;
A
Andy Adamson 已提交
1378 1379
			goto out;
		}
A
Al Viro 已提交
1380
		if (op->status == nfserr_replay_me) {
1381
			op->replay = &cstate->replay_owner->so_replay;
L
Linus Torvalds 已提交
1382 1383 1384 1385 1386 1387
			nfsd4_encode_replay(resp, op);
			status = op->status = op->replay->rp_status;
		} else {
			nfsd4_encode_operation(resp, op);
			status = op->status;
		}
1388 1389 1390 1391 1392

		dprintk("nfsv4 compound op %p opcnt %d #%d: %d: status %d\n",
			args->ops, args->opcnt, resp->opcnt, op->opnum,
			be32_to_cpu(status));

1393
		if (cstate->replay_owner) {
1394
			nfs4_unlock_state();
1395
			cstate->replay_owner = NULL;
L
Linus Torvalds 已提交
1396
		}
1397 1398 1399
		/* XXX Ugh, we need to get rid of this kind of special case: */
		if (op->opnum == OP_READ && op->u.read.rd_filp)
			fput(op->u.read.rd_filp);
1400 1401

		nfsd4_increment_op_stats(op->opnum);
L
Linus Torvalds 已提交
1402 1403
	}

A
Andy Adamson 已提交
1404
	resp->cstate.status = status;
1405 1406 1407
	fh_put(&resp->cstate.current_fh);
	fh_put(&resp->cstate.save_fh);
	BUG_ON(resp->cstate.replay_owner);
L
Linus Torvalds 已提交
1408
out:
1409 1410
	/* Reset deferral mechanism for RPC deferrals */
	rqstp->rq_usedeferral = 1;
1411
	dprintk("nfsv4 compound returned %d\n", ntohl(status));
L
Linus Torvalds 已提交
1412 1413 1414
	return status;
}

1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552
#define op_encode_hdr_size		(2)
#define op_encode_stateid_maxsz		(XDR_QUADLEN(NFS4_STATEID_SIZE))
#define op_encode_verifier_maxsz	(XDR_QUADLEN(NFS4_VERIFIER_SIZE))
#define op_encode_change_info_maxsz	(5)
#define nfs4_fattr_bitmap_maxsz		(4)

#define op_encode_lockowner_maxsz	(1 + XDR_QUADLEN(IDMAP_NAMESZ))
#define op_encode_lock_denied_maxsz	(8 + op_encode_lockowner_maxsz)

#define nfs4_owner_maxsz		(1 + XDR_QUADLEN(IDMAP_NAMESZ))

#define op_encode_ace_maxsz		(3 + nfs4_owner_maxsz)
#define op_encode_delegation_maxsz	(1 + op_encode_stateid_maxsz + 1 + \
					 op_encode_ace_maxsz)

#define op_encode_channel_attrs_maxsz	(6 + 1 + 1)

static inline u32 nfsd4_only_status_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
{
	return (op_encode_hdr_size) * sizeof(__be32);
}

static inline u32 nfsd4_status_stateid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
{
	return (op_encode_hdr_size + op_encode_stateid_maxsz)* sizeof(__be32);
}

static inline u32 nfsd4_commit_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
{
	return (op_encode_hdr_size + op_encode_verifier_maxsz) * sizeof(__be32);
}

static inline u32 nfsd4_create_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
{
	return (op_encode_hdr_size + op_encode_change_info_maxsz
		+ nfs4_fattr_bitmap_maxsz) * sizeof(__be32);
}

static inline u32 nfsd4_link_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
{
	return (op_encode_hdr_size + op_encode_change_info_maxsz)
		* sizeof(__be32);
}

static inline u32 nfsd4_lock_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
{
	return (op_encode_hdr_size + op_encode_lock_denied_maxsz)
		* sizeof(__be32);
}

static inline u32 nfsd4_open_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
{
	return (op_encode_hdr_size + op_encode_stateid_maxsz
		+ op_encode_change_info_maxsz + 1
		+ nfs4_fattr_bitmap_maxsz
		+ op_encode_delegation_maxsz) * sizeof(__be32);
}

static inline u32 nfsd4_read_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
{
	u32 maxcount = 0, rlen = 0;

	maxcount = svc_max_payload(rqstp);
	rlen = op->u.read.rd_length;

	if (rlen > maxcount)
		rlen = maxcount;

	return (op_encode_hdr_size + 2) * sizeof(__be32) + rlen;
}

static inline u32 nfsd4_readdir_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
{
	u32 rlen = op->u.readdir.rd_maxcount;

	if (rlen > PAGE_SIZE)
		rlen = PAGE_SIZE;

	return (op_encode_hdr_size + op_encode_verifier_maxsz)
		 * sizeof(__be32) + rlen;
}

static inline u32 nfsd4_remove_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
{
	return (op_encode_hdr_size + op_encode_change_info_maxsz)
		* sizeof(__be32);
}

static inline u32 nfsd4_rename_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
{
	return (op_encode_hdr_size + op_encode_change_info_maxsz
		+ op_encode_change_info_maxsz) * sizeof(__be32);
}

static inline u32 nfsd4_setattr_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
{
	return (op_encode_hdr_size + nfs4_fattr_bitmap_maxsz) * sizeof(__be32);
}

static inline u32 nfsd4_setclientid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
{
	return (op_encode_hdr_size + 2 + 1024) * sizeof(__be32);
}

static inline u32 nfsd4_write_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
{
	return (op_encode_hdr_size + op_encode_verifier_maxsz) * sizeof(__be32);
}

static inline u32 nfsd4_exchange_id_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
{
	return (op_encode_hdr_size + 2 + 1 + /* eir_clientid, eir_sequenceid */\
		1 + 1 + 0 + /* eir_flags, spr_how, SP4_NONE (for now) */\
		2 + /*eir_server_owner.so_minor_id */\
		/* eir_server_owner.so_major_id<> */\
		XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\
		/* eir_server_scope<> */\
		XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\
		1 + /* eir_server_impl_id array length */\
		0 /* ignored eir_server_impl_id contents */) * sizeof(__be32);
}

static inline u32 nfsd4_bind_conn_to_session_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
{
	return (op_encode_hdr_size + \
		XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* bctsr_sessid */\
		2 /* bctsr_dir, use_conn_in_rdma_mode */) * sizeof(__be32);
}

static inline u32 nfsd4_create_session_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
{
	return (op_encode_hdr_size + \
		XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* sessionid */\
		2 + /* csr_sequence, csr_flags */\
		op_encode_channel_attrs_maxsz + \
		op_encode_channel_attrs_maxsz) * sizeof(__be32);
}

B
Benny Halevy 已提交
1553
static struct nfsd4_operation nfsd4_ops[] = {
1554 1555
	[OP_ACCESS] = {
		.op_func = (nfsd4op_func)nfsd4_access,
B
Benny Halevy 已提交
1556
		.op_name = "OP_ACCESS",
1557 1558 1559
	},
	[OP_CLOSE] = {
		.op_func = (nfsd4op_func)nfsd4_close,
1560
		.op_flags = OP_MODIFIES_SOMETHING,
B
Benny Halevy 已提交
1561
		.op_name = "OP_CLOSE",
1562
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize,
1563 1564
		.op_get_currentstateid = (stateid_getter)nfsd4_get_closestateid,
		.op_set_currentstateid = (stateid_setter)nfsd4_set_closestateid,
1565 1566 1567
	},
	[OP_COMMIT] = {
		.op_func = (nfsd4op_func)nfsd4_commit,
1568
		.op_flags = OP_MODIFIES_SOMETHING,
B
Benny Halevy 已提交
1569
		.op_name = "OP_COMMIT",
1570
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_commit_rsize,
1571 1572 1573
	},
	[OP_CREATE] = {
		.op_func = (nfsd4op_func)nfsd4_create,
1574
		.op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME | OP_CLEAR_STATEID,
B
Benny Halevy 已提交
1575
		.op_name = "OP_CREATE",
1576
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_create_rsize,
1577 1578 1579
	},
	[OP_DELEGRETURN] = {
		.op_func = (nfsd4op_func)nfsd4_delegreturn,
1580
		.op_flags = OP_MODIFIES_SOMETHING,
B
Benny Halevy 已提交
1581
		.op_name = "OP_DELEGRETURN",
1582
		.op_rsize_bop = nfsd4_only_status_rsize,
1583
		.op_get_currentstateid = (stateid_getter)nfsd4_get_delegreturnstateid,
1584 1585 1586
	},
	[OP_GETATTR] = {
		.op_func = (nfsd4op_func)nfsd4_getattr,
1587
		.op_flags = ALLOWED_ON_ABSENT_FS,
B
Benny Halevy 已提交
1588
		.op_name = "OP_GETATTR",
1589 1590 1591
	},
	[OP_GETFH] = {
		.op_func = (nfsd4op_func)nfsd4_getfh,
B
Benny Halevy 已提交
1592
		.op_name = "OP_GETFH",
1593 1594 1595
	},
	[OP_LINK] = {
		.op_func = (nfsd4op_func)nfsd4_link,
1596 1597
		.op_flags = ALLOWED_ON_ABSENT_FS | OP_MODIFIES_SOMETHING
				| OP_CACHEME,
B
Benny Halevy 已提交
1598
		.op_name = "OP_LINK",
1599
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_link_rsize,
1600 1601 1602
	},
	[OP_LOCK] = {
		.op_func = (nfsd4op_func)nfsd4_lock,
1603
		.op_flags = OP_MODIFIES_SOMETHING,
B
Benny Halevy 已提交
1604
		.op_name = "OP_LOCK",
1605
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_lock_rsize,
1606
		.op_set_currentstateid = (stateid_setter)nfsd4_set_lockstateid,
1607 1608 1609
	},
	[OP_LOCKT] = {
		.op_func = (nfsd4op_func)nfsd4_lockt,
B
Benny Halevy 已提交
1610
		.op_name = "OP_LOCKT",
1611 1612 1613
	},
	[OP_LOCKU] = {
		.op_func = (nfsd4op_func)nfsd4_locku,
1614
		.op_flags = OP_MODIFIES_SOMETHING,
B
Benny Halevy 已提交
1615
		.op_name = "OP_LOCKU",
1616
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize,
1617
		.op_get_currentstateid = (stateid_getter)nfsd4_get_lockustateid,
1618 1619 1620
	},
	[OP_LOOKUP] = {
		.op_func = (nfsd4op_func)nfsd4_lookup,
1621
		.op_flags = OP_HANDLES_WRONGSEC | OP_CLEAR_STATEID,
B
Benny Halevy 已提交
1622
		.op_name = "OP_LOOKUP",
1623 1624 1625
	},
	[OP_LOOKUPP] = {
		.op_func = (nfsd4op_func)nfsd4_lookupp,
1626
		.op_flags = OP_HANDLES_WRONGSEC | OP_CLEAR_STATEID,
B
Benny Halevy 已提交
1627
		.op_name = "OP_LOOKUPP",
1628 1629 1630
	},
	[OP_NVERIFY] = {
		.op_func = (nfsd4op_func)nfsd4_nverify,
B
Benny Halevy 已提交
1631
		.op_name = "OP_NVERIFY",
1632 1633 1634
	},
	[OP_OPEN] = {
		.op_func = (nfsd4op_func)nfsd4_open,
1635
		.op_flags = OP_HANDLES_WRONGSEC | OP_MODIFIES_SOMETHING,
B
Benny Halevy 已提交
1636
		.op_name = "OP_OPEN",
1637
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_open_rsize,
1638
		.op_set_currentstateid = (stateid_setter)nfsd4_set_openstateid,
1639 1640 1641
	},
	[OP_OPEN_CONFIRM] = {
		.op_func = (nfsd4op_func)nfsd4_open_confirm,
1642
		.op_flags = OP_MODIFIES_SOMETHING,
B
Benny Halevy 已提交
1643
		.op_name = "OP_OPEN_CONFIRM",
1644
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize,
1645 1646 1647
	},
	[OP_OPEN_DOWNGRADE] = {
		.op_func = (nfsd4op_func)nfsd4_open_downgrade,
1648
		.op_flags = OP_MODIFIES_SOMETHING,
B
Benny Halevy 已提交
1649
		.op_name = "OP_OPEN_DOWNGRADE",
1650
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize,
1651 1652
		.op_get_currentstateid = (stateid_getter)nfsd4_get_opendowngradestateid,
		.op_set_currentstateid = (stateid_setter)nfsd4_set_opendowngradestateid,
1653 1654 1655
	},
	[OP_PUTFH] = {
		.op_func = (nfsd4op_func)nfsd4_putfh,
1656
		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
1657 1658
				| OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING
				| OP_CLEAR_STATEID,
B
Benny Halevy 已提交
1659
		.op_name = "OP_PUTFH",
1660
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
1661
	},
1662
	[OP_PUTPUBFH] = {
1663
		.op_func = (nfsd4op_func)nfsd4_putrootfh,
1664
		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
1665 1666
				| OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING
				| OP_CLEAR_STATEID,
B
Benny Halevy 已提交
1667
		.op_name = "OP_PUTPUBFH",
1668
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
1669
	},
1670 1671
	[OP_PUTROOTFH] = {
		.op_func = (nfsd4op_func)nfsd4_putrootfh,
1672
		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
1673 1674
				| OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING
				| OP_CLEAR_STATEID,
B
Benny Halevy 已提交
1675
		.op_name = "OP_PUTROOTFH",
1676
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
1677 1678 1679
	},
	[OP_READ] = {
		.op_func = (nfsd4op_func)nfsd4_read,
1680
		.op_flags = OP_MODIFIES_SOMETHING,
B
Benny Halevy 已提交
1681
		.op_name = "OP_READ",
1682
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_read_rsize,
1683
		.op_get_currentstateid = (stateid_getter)nfsd4_get_readstateid,
1684 1685 1686
	},
	[OP_READDIR] = {
		.op_func = (nfsd4op_func)nfsd4_readdir,
1687
		.op_flags = OP_MODIFIES_SOMETHING,
B
Benny Halevy 已提交
1688
		.op_name = "OP_READDIR",
1689
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_readdir_rsize,
1690 1691 1692
	},
	[OP_READLINK] = {
		.op_func = (nfsd4op_func)nfsd4_readlink,
B
Benny Halevy 已提交
1693
		.op_name = "OP_READLINK",
1694 1695 1696
	},
	[OP_REMOVE] = {
		.op_func = (nfsd4op_func)nfsd4_remove,
1697
		.op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
B
Benny Halevy 已提交
1698
		.op_name = "OP_REMOVE",
1699
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_remove_rsize,
1700 1701 1702
	},
	[OP_RENAME] = {
		.op_func = (nfsd4op_func)nfsd4_rename,
1703
		.op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
1704 1705
		.op_name = "OP_RENAME",
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_rename_rsize,
1706 1707 1708
	},
	[OP_RENEW] = {
		.op_func = (nfsd4op_func)nfsd4_renew,
1709 1710
		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
				| OP_MODIFIES_SOMETHING,
B
Benny Halevy 已提交
1711
		.op_name = "OP_RENEW",
1712 1713
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,

1714 1715 1716
	},
	[OP_RESTOREFH] = {
		.op_func = (nfsd4op_func)nfsd4_restorefh,
1717
		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
1718
				| OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING,
B
Benny Halevy 已提交
1719
		.op_name = "OP_RESTOREFH",
1720
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
1721 1722 1723
	},
	[OP_SAVEFH] = {
		.op_func = (nfsd4op_func)nfsd4_savefh,
1724
		.op_flags = OP_HANDLES_WRONGSEC | OP_MODIFIES_SOMETHING,
B
Benny Halevy 已提交
1725
		.op_name = "OP_SAVEFH",
1726
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
1727
	},
A
Andy Adamson 已提交
1728 1729
	[OP_SECINFO] = {
		.op_func = (nfsd4op_func)nfsd4_secinfo,
1730
		.op_flags = OP_HANDLES_WRONGSEC,
B
Benny Halevy 已提交
1731
		.op_name = "OP_SECINFO",
A
Andy Adamson 已提交
1732
	},
1733 1734
	[OP_SETATTR] = {
		.op_func = (nfsd4op_func)nfsd4_setattr,
B
Benny Halevy 已提交
1735
		.op_name = "OP_SETATTR",
1736
		.op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
1737
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_setattr_rsize,
1738
		.op_get_currentstateid = (stateid_getter)nfsd4_get_setattrstateid,
1739 1740 1741
	},
	[OP_SETCLIENTID] = {
		.op_func = (nfsd4op_func)nfsd4_setclientid,
1742
		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
1743
				| OP_MODIFIES_SOMETHING | OP_CACHEME,
B
Benny Halevy 已提交
1744
		.op_name = "OP_SETCLIENTID",
1745
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_setclientid_rsize,
1746 1747 1748
	},
	[OP_SETCLIENTID_CONFIRM] = {
		.op_func = (nfsd4op_func)nfsd4_setclientid_confirm,
1749
		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
1750
				| OP_MODIFIES_SOMETHING | OP_CACHEME,
B
Benny Halevy 已提交
1751
		.op_name = "OP_SETCLIENTID_CONFIRM",
1752
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
1753 1754 1755
	},
	[OP_VERIFY] = {
		.op_func = (nfsd4op_func)nfsd4_verify,
B
Benny Halevy 已提交
1756
		.op_name = "OP_VERIFY",
1757 1758 1759
	},
	[OP_WRITE] = {
		.op_func = (nfsd4op_func)nfsd4_write,
1760
		.op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
B
Benny Halevy 已提交
1761
		.op_name = "OP_WRITE",
1762
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_write_rsize,
1763
		.op_get_currentstateid = (stateid_getter)nfsd4_get_writestateid,
1764 1765 1766
	},
	[OP_RELEASE_LOCKOWNER] = {
		.op_func = (nfsd4op_func)nfsd4_release_lockowner,
1767 1768
		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
				| OP_MODIFIES_SOMETHING,
B
Benny Halevy 已提交
1769
		.op_name = "OP_RELEASE_LOCKOWNER",
1770
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
1771
	},
A
Andy Adamson 已提交
1772 1773 1774 1775

	/* NFSv4.1 operations */
	[OP_EXCHANGE_ID] = {
		.op_func = (nfsd4op_func)nfsd4_exchange_id,
1776 1777
		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
				| OP_MODIFIES_SOMETHING,
A
Andy Adamson 已提交
1778
		.op_name = "OP_EXCHANGE_ID",
1779
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_exchange_id_rsize,
A
Andy Adamson 已提交
1780
	},
1781 1782 1783 1784 1785 1786
	[OP_BACKCHANNEL_CTL] = {
		.op_func = (nfsd4op_func)nfsd4_backchannel_ctl,
		.op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING,
		.op_name = "OP_BACKCHANNEL_CTL",
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
	},
1787 1788
	[OP_BIND_CONN_TO_SESSION] = {
		.op_func = (nfsd4op_func)nfsd4_bind_conn_to_session,
1789 1790
		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
				| OP_MODIFIES_SOMETHING,
1791
		.op_name = "OP_BIND_CONN_TO_SESSION",
1792
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_bind_conn_to_session_rsize,
1793
	},
A
Andy Adamson 已提交
1794 1795
	[OP_CREATE_SESSION] = {
		.op_func = (nfsd4op_func)nfsd4_create_session,
1796 1797
		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
				| OP_MODIFIES_SOMETHING,
A
Andy Adamson 已提交
1798
		.op_name = "OP_CREATE_SESSION",
1799
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_create_session_rsize,
A
Andy Adamson 已提交
1800 1801 1802
	},
	[OP_DESTROY_SESSION] = {
		.op_func = (nfsd4op_func)nfsd4_destroy_session,
1803 1804
		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
				| OP_MODIFIES_SOMETHING,
A
Andy Adamson 已提交
1805
		.op_name = "OP_DESTROY_SESSION",
1806
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
A
Andy Adamson 已提交
1807 1808 1809
	},
	[OP_SEQUENCE] = {
		.op_func = (nfsd4op_func)nfsd4_sequence,
1810
		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP,
A
Andy Adamson 已提交
1811 1812
		.op_name = "OP_SEQUENCE",
	},
1813
	[OP_DESTROY_CLIENTID] = {
1814
		.op_func = (nfsd4op_func)nfsd4_destroy_clientid,
1815 1816
		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
				| OP_MODIFIES_SOMETHING,
1817
		.op_name = "OP_DESTROY_CLIENTID",
1818
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
1819
	},
1820 1821
	[OP_RECLAIM_COMPLETE] = {
		.op_func = (nfsd4op_func)nfsd4_reclaim_complete,
1822
		.op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING,
1823
		.op_name = "OP_RECLAIM_COMPLETE",
1824
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
1825
	},
J
J. Bruce Fields 已提交
1826 1827
	[OP_SECINFO_NO_NAME] = {
		.op_func = (nfsd4op_func)nfsd4_secinfo_no_name,
1828
		.op_flags = OP_HANDLES_WRONGSEC,
J
J. Bruce Fields 已提交
1829 1830
		.op_name = "OP_SECINFO_NO_NAME",
	},
1831 1832 1833 1834 1835
	[OP_TEST_STATEID] = {
		.op_func = (nfsd4op_func)nfsd4_test_stateid,
		.op_flags = ALLOWED_WITHOUT_FH,
		.op_name = "OP_TEST_STATEID",
	},
1836 1837
	[OP_FREE_STATEID] = {
		.op_func = (nfsd4op_func)nfsd4_free_stateid,
1838
		.op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING,
1839
		.op_name = "OP_FREE_STATEID",
1840
		.op_get_currentstateid = (stateid_getter)nfsd4_get_freestateid,
1841
		.op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
1842
	},
1843 1844
};

1845
#ifdef NFSD_DEBUG
A
Adrian Bunk 已提交
1846
static const char *nfsd4_op_name(unsigned opnum)
B
Benny Halevy 已提交
1847 1848 1849 1850 1851
{
	if (opnum < ARRAY_SIZE(nfsd4_ops))
		return nfsd4_ops[opnum].op_name;
	return "unknown_operation";
}
1852
#endif
B
Benny Halevy 已提交
1853

L
Linus Torvalds 已提交
1854 1855 1856 1857
#define nfsd4_voidres			nfsd4_voidargs
struct nfsd4_voidargs { int dummy; };

static struct svc_procedure		nfsd_procedures4[2] = {
1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871
	[NFSPROC4_NULL] = {
		.pc_func = (svc_procfunc) nfsd4_proc_null,
		.pc_encode = (kxdrproc_t) nfs4svc_encode_voidres,
		.pc_argsize = sizeof(struct nfsd4_voidargs),
		.pc_ressize = sizeof(struct nfsd4_voidres),
		.pc_cachetype = RC_NOCACHE,
		.pc_xdrressize = 1,
	},
	[NFSPROC4_COMPOUND] = {
		.pc_func = (svc_procfunc) nfsd4_proc_compound,
		.pc_decode = (kxdrproc_t) nfs4svc_decode_compoundargs,
		.pc_encode = (kxdrproc_t) nfs4svc_encode_compoundres,
		.pc_argsize = sizeof(struct nfsd4_compoundargs),
		.pc_ressize = sizeof(struct nfsd4_compoundres),
1872
		.pc_release = nfsd4_release_compoundargs,
1873 1874 1875
		.pc_cachetype = RC_NOCACHE,
		.pc_xdrressize = NFSD_BUFSIZE/4,
	},
L
Linus Torvalds 已提交
1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890
};

struct svc_version	nfsd_version4 = {
		.vs_vers	= 4,
		.vs_nproc	= 2,
		.vs_proc	= nfsd_procedures4,
		.vs_dispatch	= nfsd_dispatch,
		.vs_xdrsize	= NFS4_SVC_XDRSIZE,
};

/*
 * Local variables:
 *  c-basic-offset: 8
 * End:
 */