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