Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ad9a19d0 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'nfsd-4.14' of git://linux-nfs.org/~bfields/linux 

Pull nfsd updates from Bruce Fields:
 "More RDMA work and some op-structure constification from Chuck Lever,
  and a small cleanup to our xdr encoding"

* tag 'nfsd-4.14' of git://linux-nfs.org/~bfields/linux:
  svcrdma: Estimate Send Queue depth properly
  rdma core: Add rdma_rw_mr_payload()
  svcrdma: Limit RQ depth
  svcrdma: Populate tail iovec when receiving
  nfsd: Incoming xdr_bufs may have content in tail buffer
  svcrdma: Clean up svc_rdma_build_read_chunk()
  sunrpc: Const-ify struct sv_serv_ops
  nfsd: Const-ify NFSv4 encoding and decoding ops arrays
  sunrpc: Const-ify instances of struct svc_xprt_ops
  nfsd4: individual encoders no longer see error cases
  nfsd4: skip encoder in trivial error cases
  nfsd4: define ->op_release for compound ops
  nfsd4: opdesc will be useful outside nfs4proc.c
  nfsd4: move some nfsd4 op definitions to xdr4.h
parents 66ba772e 26fb2254

drivers/infiniband/core/rw.c

+24 −0
Original line number Diff line number Diff line
@@ -643,6 +643,30 @@ void rdma_rw_ctx_destroy_signature(struct rdma_rw_ctx *ctx, struct ib_qp *qp, 
}

EXPORT_SYMBOL(rdma_rw_ctx_destroy_signature);



/**

 * rdma_rw_mr_factor - return number of MRs required for a payload

 * @device:	device handling the connection

 * @port_num:	port num to which the connection is bound

 * @maxpages:	maximum payload pages per rdma_rw_ctx

 *

 * Returns the number of MRs the device requires to move @maxpayload

 * bytes. The returned value is used during transport creation to

 * compute max_rdma_ctxts and the size of the transport's Send and

 * Send Completion Queues.

 */

unsigned int rdma_rw_mr_factor(struct ib_device *device, u8 port_num,

			       unsigned int maxpages)

{

	unsigned int mr_pages;



	if (rdma_rw_can_use_mr(device, port_num))

		mr_pages = rdma_rw_fr_page_list_len(device);

	else

		mr_pages = device->attrs.max_sge_rd;

	return DIV_ROUND_UP(maxpages, mr_pages);

}

EXPORT_SYMBOL(rdma_rw_mr_factor);



void rdma_rw_init_qp(struct ib_device *dev, struct ib_qp_init_attr *attr)

{

	u32 factor;

fs/lockd/svc.c

+1 −1
Original line number Diff line number Diff line
@@ -396,7 +396,7 @@ static int lockd_start_svc(struct svc_serv *serv) 
	return error;

}



static struct svc_serv_ops lockd_sv_ops = {

static const struct svc_serv_ops lockd_sv_ops = {

	.svo_shutdown		= svc_rpcb_cleanup,

	.svo_enqueue_xprt	= svc_xprt_do_enqueue,

};

fs/nfs/callback.c

+5 −5
Original line number Diff line number Diff line
@@ -226,26 +226,26 @@ static int nfs_callback_up_net(int minorversion, struct svc_serv *serv, 
	return ret;

}



static struct svc_serv_ops nfs40_cb_sv_ops = {

static const struct svc_serv_ops nfs40_cb_sv_ops = {

	.svo_function		= nfs4_callback_svc,

	.svo_enqueue_xprt	= svc_xprt_do_enqueue,

	.svo_setup		= svc_set_num_threads_sync,

	.svo_module		= THIS_MODULE,

};

#if defined(CONFIG_NFS_V4_1)

static struct svc_serv_ops nfs41_cb_sv_ops = {

static const struct svc_serv_ops nfs41_cb_sv_ops = {

	.svo_function		= nfs41_callback_svc,

	.svo_enqueue_xprt	= svc_xprt_do_enqueue,

	.svo_setup		= svc_set_num_threads_sync,

	.svo_module		= THIS_MODULE,

};



static struct svc_serv_ops *nfs4_cb_sv_ops[] = {

static const struct svc_serv_ops *nfs4_cb_sv_ops[] = {

	[0] = &nfs40_cb_sv_ops,

	[1] = &nfs41_cb_sv_ops,

};

#else

static struct svc_serv_ops *nfs4_cb_sv_ops[] = {

static const struct svc_serv_ops *nfs4_cb_sv_ops[] = {

	[0] = &nfs40_cb_sv_ops,

	[1] = NULL,

};
@@ -254,8 +254,8 @@ static struct svc_serv_ops *nfs4_cb_sv_ops[] = { 
static struct svc_serv *nfs_callback_create_svc(int minorversion)

{

	struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion];

	const struct svc_serv_ops *sv_ops;

	struct svc_serv *serv;

	struct svc_serv_ops *sv_ops;



	/*

	 * Check whether we're already up and running.

fs/nfsd/nfs4proc.c

+50 −60
Original line number Diff line number Diff line
@@ -784,6 +784,14 @@ nfsd4_read(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 
	return status;

}





static void

nfsd4_read_release(union nfsd4_op_u *u)

{

	if (u->read.rd_filp)

		fput(u->read.rd_filp);

}



static __be32

nfsd4_readdir(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,

	      union nfsd4_op_u *u)
@@ -912,6 +920,13 @@ nfsd4_secinfo_no_name(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstat 
	return nfs_ok;

}



static void

nfsd4_secinfo_release(union nfsd4_op_u *u)

{

	if (u->secinfo.si_exp)

		exp_put(u->secinfo.si_exp);

}



static __be32

nfsd4_setattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,

	      union nfsd4_op_u *u)
@@ -1335,6 +1350,12 @@ nfsd4_getdeviceinfo(struct svc_rqst *rqstp, 
	return nfserr;

}



static void

nfsd4_getdeviceinfo_release(union nfsd4_op_u *u)

{

	kfree(u->getdeviceinfo.gd_device);

}



static __be32

nfsd4_layoutget(struct svc_rqst *rqstp,

		struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
@@ -1415,6 +1436,12 @@ nfsd4_layoutget(struct svc_rqst *rqstp, 
	return nfserr;

}



static void

nfsd4_layoutget_release(union nfsd4_op_u *u)

{

	kfree(u->layoutget.lg_content);

}



static __be32

nfsd4_layoutcommit(struct svc_rqst *rqstp,

		struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
@@ -1541,49 +1568,6 @@ static inline void nfsd4_increment_op_stats(u32 opnum) 
		nfsdstats.nfs4_opcount[opnum]++;

}



enum nfsd4_op_flags {

	ALLOWED_WITHOUT_FH = 1 << 0,	/* No current filehandle required */

	ALLOWED_ON_ABSENT_FS = 1 << 1,	/* ops processed on absent fs */

	ALLOWED_AS_FIRST_OP = 1 << 2,	/* ops reqired first in compound */

	/* For rfc 5661 section 2.6.3.1.1: */

	OP_HANDLES_WRONGSEC = 1 << 3,

	OP_IS_PUTFH_LIKE = 1 << 4,

	/*

	 * 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:

	 * 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).

	 */

	OP_CACHEME = 1 << 6,

	/*

	 * These are ops which clear current state id.

	 */

	OP_CLEAR_STATEID = 1 << 7,

};



struct nfsd4_operation {

	__be32 (*op_func)(struct svc_rqst *, struct nfsd4_compound_state *,

			union nfsd4_op_u *);

	u32 op_flags;

	char *op_name;

	/* Try to get response size before operation */

	u32 (*op_rsize_bop)(struct svc_rqst *, struct nfsd4_op *);

	void (*op_get_currentstateid)(struct nfsd4_compound_state *,

			union nfsd4_op_u *);

	void (*op_set_currentstateid)(struct nfsd4_compound_state *,

			union nfsd4_op_u *);

};



static const struct nfsd4_operation nfsd4_ops[];



static const char *nfsd4_op_name(unsigned opnum);
@@ -1621,7 +1605,7 @@ static __be32 nfs41_check_op_ordering(struct nfsd4_compoundargs *args) 
	return nfs_ok;

}



static inline const struct nfsd4_operation *OPDESC(struct nfsd4_op *op)

const struct nfsd4_operation *OPDESC(struct nfsd4_op *op)

{

	return &nfsd4_ops[op->opnum];

}
@@ -1694,7 +1678,6 @@ nfsd4_proc_compound(struct svc_rqst *rqstp) 
	struct nfsd4_compoundargs *args = rqstp->rq_argp;

	struct nfsd4_compoundres *resp = rqstp->rq_resp;

	struct nfsd4_op	*op;

	const struct nfsd4_operation *opdesc;

	struct nfsd4_compound_state *cstate = &resp->cstate;

	struct svc_fh *current_fh = &cstate->current_fh;

	struct svc_fh *save_fh = &cstate->save_fh;
@@ -1747,15 +1730,13 @@ nfsd4_proc_compound(struct svc_rqst *rqstp) 
			goto encode_op;

		}



		opdesc = OPDESC(op);



		if (!current_fh->fh_dentry) {

			if (!(opdesc->op_flags & ALLOWED_WITHOUT_FH)) {

			if (!(op->opdesc->op_flags & ALLOWED_WITHOUT_FH)) {

				op->status = nfserr_nofilehandle;

				goto encode_op;

			}

		} else if (current_fh->fh_export->ex_fslocs.migrated &&

			  !(opdesc->op_flags & ALLOWED_ON_ABSENT_FS)) {

			  !(op->opdesc->op_flags & ALLOWED_ON_ABSENT_FS)) {

			op->status = nfserr_moved;

			goto encode_op;

		}
@@ -1763,12 +1744,12 @@ nfsd4_proc_compound(struct svc_rqst *rqstp) 
		fh_clear_wcc(current_fh);



		/* If op is non-idempotent */

		if (opdesc->op_flags & OP_MODIFIES_SOMETHING) {

		if (op->opdesc->op_flags & OP_MODIFIES_SOMETHING) {

			/*

			 * Don't execute this op if we couldn't encode a

			 * succesful reply:

			 */

			u32 plen = opdesc->op_rsize_bop(rqstp, op);

			u32 plen = op->opdesc->op_rsize_bop(rqstp, op);

			/*

			 * Plus if there's another operation, make sure

			 * we'll have space to at least encode an error:
@@ -1781,9 +1762,9 @@ nfsd4_proc_compound(struct svc_rqst *rqstp) 
		if (op->status)

			goto encode_op;



		if (opdesc->op_get_currentstateid)

			opdesc->op_get_currentstateid(cstate, &op->u);

		op->status = opdesc->op_func(rqstp, cstate, &op->u);

		if (op->opdesc->op_get_currentstateid)

			op->opdesc->op_get_currentstateid(cstate, &op->u);

		op->status = op->opdesc->op_func(rqstp, cstate, &op->u);



		/* Only from SEQUENCE */

		if (cstate->status == nfserr_replay_cache) {
@@ -1792,10 +1773,10 @@ nfsd4_proc_compound(struct svc_rqst *rqstp) 
			goto out;

		}

		if (!op->status) {

			if (opdesc->op_set_currentstateid)

				opdesc->op_set_currentstateid(cstate, &op->u);

			if (op->opdesc->op_set_currentstateid)

				op->opdesc->op_set_currentstateid(cstate, &op->u);



			if (opdesc->op_flags & OP_CLEAR_STATEID)

			if (op->opdesc->op_flags & OP_CLEAR_STATEID)

				clear_current_stateid(cstate);



			if (need_wrongsec_check(rqstp))
@@ -2160,13 +2141,15 @@ static const struct nfsd4_operation nfsd4_ops[] = { 
	},

	[OP_LOCK] = {

		.op_func = nfsd4_lock,

		.op_flags = OP_MODIFIES_SOMETHING,

		.op_flags = OP_MODIFIES_SOMETHING |

				OP_NONTRIVIAL_ERROR_ENCODE,

		.op_name = "OP_LOCK",

		.op_rsize_bop = nfsd4_lock_rsize,

		.op_set_currentstateid = nfsd4_set_lockstateid,

	},

	[OP_LOCKT] = {

		.op_func = nfsd4_lockt,

		.op_flags = OP_NONTRIVIAL_ERROR_ENCODE,

		.op_name = "OP_LOCKT",

		.op_rsize_bop = nfsd4_lock_rsize,

	},
@@ -2238,6 +2221,7 @@ static const struct nfsd4_operation nfsd4_ops[] = { 
	},

	[OP_READ] = {

		.op_func = nfsd4_read,

		.op_release = nfsd4_read_release,

		.op_name = "OP_READ",

		.op_rsize_bop = nfsd4_read_rsize,

		.op_get_currentstateid = nfsd4_get_readstateid,
@@ -2287,6 +2271,7 @@ static const struct nfsd4_operation nfsd4_ops[] = { 
	},

	[OP_SECINFO] = {

		.op_func = nfsd4_secinfo,

		.op_release = nfsd4_secinfo_release,

		.op_flags = OP_HANDLES_WRONGSEC,

		.op_name = "OP_SECINFO",

		.op_rsize_bop = nfsd4_secinfo_rsize,
@@ -2294,14 +2279,16 @@ static const struct nfsd4_operation nfsd4_ops[] = { 
	[OP_SETATTR] = {

		.op_func = nfsd4_setattr,

		.op_name = "OP_SETATTR",

		.op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,

		.op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME

				| OP_NONTRIVIAL_ERROR_ENCODE,

		.op_rsize_bop = nfsd4_setattr_rsize,

		.op_get_currentstateid = nfsd4_get_setattrstateid,

	},

	[OP_SETCLIENTID] = {

		.op_func = nfsd4_setclientid,

		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS

				| OP_MODIFIES_SOMETHING | OP_CACHEME,

				| OP_MODIFIES_SOMETHING | OP_CACHEME

				| OP_NONTRIVIAL_ERROR_ENCODE,

		.op_name = "OP_SETCLIENTID",

		.op_rsize_bop = nfsd4_setclientid_rsize,

	},
@@ -2388,6 +2375,7 @@ static const struct nfsd4_operation nfsd4_ops[] = { 
	},

	[OP_SECINFO_NO_NAME] = {

		.op_func = nfsd4_secinfo_no_name,

		.op_release = nfsd4_secinfo_release,

		.op_flags = OP_HANDLES_WRONGSEC,

		.op_name = "OP_SECINFO_NO_NAME",

		.op_rsize_bop = nfsd4_secinfo_rsize,
@@ -2408,12 +2396,14 @@ static const struct nfsd4_operation nfsd4_ops[] = { 
#ifdef CONFIG_NFSD_PNFS

	[OP_GETDEVICEINFO] = {

		.op_func = nfsd4_getdeviceinfo,

		.op_release = nfsd4_getdeviceinfo_release,

		.op_flags = ALLOWED_WITHOUT_FH,

		.op_name = "OP_GETDEVICEINFO",

		.op_rsize_bop = nfsd4_getdeviceinfo_rsize,

	},

	[OP_LAYOUTGET] = {

		.op_func = nfsd4_layoutget,

		.op_release = nfsd4_layoutget_release,

		.op_flags = OP_MODIFIES_SOMETHING,

		.op_name = "OP_LAYOUTGET",

		.op_rsize_bop = nfsd4_layoutget_rsize,

fs/nfsd/nfs4xdr.c

+132 −214
Original line number Diff line number Diff line
@@ -159,6 +159,25 @@ static __be32 *read_buf(struct nfsd4_compoundargs *argp, u32 nbytes) 
	 */

	unsigned int avail = (char *)argp->end - (char *)argp->p;

	__be32 *p;



	if (argp->pagelen == 0) {

		struct kvec *vec = &argp->rqstp->rq_arg.tail[0];



		if (!argp->tail) {

			argp->tail = true;

			avail = vec->iov_len;

			argp->p = vec->iov_base;

			argp->end = vec->iov_base + avail;

		}



		if (avail < nbytes)

			return NULL;



		p = argp->p;

		argp->p += XDR_QUADLEN(nbytes);

		return p;

	}



	if (avail + argp->pagelen < nbytes)

		return NULL;

	if (avail + PAGE_SIZE < nbytes) /* need more than a page !! */
@@ -1778,7 +1797,7 @@ nfsd4_decode_notsupp(struct nfsd4_compoundargs *argp, void *p) 


typedef __be32(*nfsd4_dec)(struct nfsd4_compoundargs *argp, void *);



static nfsd4_dec nfsd4_dec_ops[] = {

static const nfsd4_dec nfsd4_dec_ops[] = {

	[OP_ACCESS]		= (nfsd4_dec)nfsd4_decode_access,

	[OP_CLOSE]		= (nfsd4_dec)nfsd4_decode_close,

	[OP_COMMIT]		= (nfsd4_dec)nfsd4_decode_commit,
@@ -1927,6 +1946,7 @@ nfsd4_decode_compound(struct nfsd4_compoundargs *argp) 
			op->opnum = OP_ILLEGAL;

			op->status = nfserr_op_illegal;

		}

		op->opdesc = OPDESC(op);

		/*

		 * We'll try to cache the result in the DRC if any one

		 * op in the compound wants to be cached:
@@ -3102,14 +3122,12 @@ nfsd4_encode_access(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_ 
	struct xdr_stream *xdr = &resp->xdr;

	__be32 *p;



	if (!nfserr) {

	p = xdr_reserve_space(xdr, 8);

	if (!p)

		return nfserr_resource;

	*p++ = cpu_to_be32(access->ac_supported);

	*p++ = cpu_to_be32(access->ac_resp_access);

	}

	return nfserr;

	return 0;

}



static __be32 nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_bind_conn_to_session *bcts)
@@ -3117,7 +3135,6 @@ static __be32 nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres *resp, 
	struct xdr_stream *xdr = &resp->xdr;

	__be32 *p;



	if (!nfserr) {

	p = xdr_reserve_space(xdr, NFS4_MAX_SESSIONID_LEN + 8);

	if (!p)

		return nfserr_resource;
@@ -3126,8 +3143,7 @@ static __be32 nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres *resp, 
	*p++ = cpu_to_be32(bcts->dir);

	/* Upshifting from TCP to RDMA is not supported */

	*p++ = cpu_to_be32(0);

	}

	return nfserr;

	return 0;

}



static __be32
@@ -3135,10 +3151,7 @@ nfsd4_encode_close(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_c 
{

	struct xdr_stream *xdr = &resp->xdr;



	if (!nfserr)

		nfserr = nfsd4_encode_stateid(xdr, &close->cl_stateid);



	return nfserr;

	return nfsd4_encode_stateid(xdr, &close->cl_stateid);

}
@@ -3148,14 +3161,12 @@ nfsd4_encode_commit(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_ 
	struct xdr_stream *xdr = &resp->xdr;

	__be32 *p;



	if (!nfserr) {

	p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE);

	if (!p)

		return nfserr_resource;

	p = xdr_encode_opaque_fixed(p, commit->co_verf.data,

						NFS4_VERIFIER_SIZE);

	}

	return nfserr;

	return 0;

}



static __be32
@@ -3164,15 +3175,13 @@ nfsd4_encode_create(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_ 
	struct xdr_stream *xdr = &resp->xdr;

	__be32 *p;



	if (!nfserr) {

	p = xdr_reserve_space(xdr, 20);

	if (!p)

		return nfserr_resource;

	encode_cinfo(p, &create->cr_cinfo);

	nfserr = nfsd4_encode_bitmap(xdr, create->cr_bmval[0],

			create->cr_bmval[1], create->cr_bmval[2]);

	}

	return nfserr;

	return 0;

}



static __be32
@@ -3181,13 +3190,8 @@ nfsd4_encode_getattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4 
	struct svc_fh *fhp = getattr->ga_fhp;

	struct xdr_stream *xdr = &resp->xdr;



	if (nfserr)

		return nfserr;



	nfserr = nfsd4_encode_fattr(xdr, fhp, fhp->fh_export, fhp->fh_dentry,

				    getattr->ga_bmval,

				    resp->rqstp, 0);

	return nfserr;

	return nfsd4_encode_fattr(xdr, fhp, fhp->fh_export, fhp->fh_dentry,

				    getattr->ga_bmval, resp->rqstp, 0);

}



static __be32
@@ -3198,14 +3202,12 @@ nfsd4_encode_getfh(struct nfsd4_compoundres *resp, __be32 nfserr, struct svc_fh 
	unsigned int len;

	__be32 *p;



	if (!nfserr) {

	len = fhp->fh_handle.fh_size;

	p = xdr_reserve_space(xdr, len + 4);

	if (!p)

		return nfserr_resource;

	p = xdr_encode_opaque(p, &fhp->fh_handle.fh_base, len);

	}

	return nfserr;

	return 0;

}



/*
@@ -3275,10 +3277,7 @@ nfsd4_encode_locku(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_l 
{

	struct xdr_stream *xdr = &resp->xdr;



	if (!nfserr)

		nfserr = nfsd4_encode_stateid(xdr, &locku->lu_stateid);



	return nfserr;

	return nfsd4_encode_stateid(xdr, &locku->lu_stateid);

}
@@ -3288,13 +3287,11 @@ nfsd4_encode_link(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_li 
	struct xdr_stream *xdr = &resp->xdr;

	__be32 *p;



	if (!nfserr) {

	p = xdr_reserve_space(xdr, 20);

	if (!p)

		return nfserr_resource;

	p = encode_cinfo(p, &link->li_cinfo);

	}

	return nfserr;

	return 0;

}
@@ -3304,12 +3301,9 @@ nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_op 
	struct xdr_stream *xdr = &resp->xdr;

	__be32 *p;



	if (nfserr)

		goto out;



	nfserr = nfsd4_encode_stateid(xdr, &open->op_stateid);

	if (nfserr)

		goto out;

		return nfserr;

	p = xdr_reserve_space(xdr, 24);

	if (!p)

		return nfserr_resource;
@@ -3319,7 +3313,7 @@ nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_op 
	nfserr = nfsd4_encode_bitmap(xdr, open->op_bmval[0], open->op_bmval[1],

					open->op_bmval[2]);

	if (nfserr)

		goto out;

		return nfserr;



	p = xdr_reserve_space(xdr, 4);

	if (!p)
@@ -3392,8 +3386,7 @@ nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_op 
		BUG();

	}

	/* XXX save filehandle here */

out:

	return nfserr;

	return 0;

}



static __be32
@@ -3401,10 +3394,7 @@ nfsd4_encode_open_confirm(struct nfsd4_compoundres *resp, __be32 nfserr, struct 
{

	struct xdr_stream *xdr = &resp->xdr;



	if (!nfserr)

		nfserr = nfsd4_encode_stateid(xdr, &oc->oc_resp_stateid);



	return nfserr;

	return nfsd4_encode_stateid(xdr, &oc->oc_resp_stateid);

}



static __be32
@@ -3412,10 +3402,7 @@ nfsd4_encode_open_downgrade(struct nfsd4_compoundres *resp, __be32 nfserr, struc 
{

	struct xdr_stream *xdr = &resp->xdr;



	if (!nfserr)

		nfserr = nfsd4_encode_stateid(xdr, &od->od_stateid);



	return nfserr;

	return nfsd4_encode_stateid(xdr, &od->od_stateid);

}



static __be32 nfsd4_encode_splice_read(
@@ -3552,20 +3539,15 @@ nfsd4_encode_read(struct nfsd4_compoundres *resp, __be32 nfserr, 
	struct raparms *ra = NULL;

	__be32 *p;



	if (nfserr)

		goto out;



	p = xdr_reserve_space(xdr, 8); /* eof flag and byte count */

	if (!p) {

		WARN_ON_ONCE(test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags));

		nfserr = nfserr_resource;

		goto out;

		return nfserr_resource;

	}

	if (resp->xdr.buf->page_len &&

	    test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags)) {

		WARN_ON_ONCE(1);

		nfserr = nfserr_resource;

		goto out;

		return nfserr_resource;

	}

	xdr_commit_encode(xdr);
@@ -3589,9 +3571,6 @@ nfsd4_encode_read(struct nfsd4_compoundres *resp, __be32 nfserr, 
	if (nfserr)

		xdr_truncate_encode(xdr, starting_len);



out:

	if (file)

		fput(file);

	return nfserr;

}
@@ -3605,9 +3584,6 @@ nfsd4_encode_readlink(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd 
	int length_offset = xdr->buf->len;

	__be32 *p;



	if (nfserr)

		return nfserr;



	p = xdr_reserve_space(xdr, 4);

	if (!p)

		return nfserr_resource;
@@ -3651,9 +3627,6 @@ nfsd4_encode_readdir(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4 
	int starting_len = xdr->buf->len;

	__be32 *p;



	if (nfserr)

		return nfserr;



	p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE);

	if (!p)

		return nfserr_resource;
@@ -3739,13 +3712,11 @@ nfsd4_encode_remove(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_ 
	struct xdr_stream *xdr = &resp->xdr;

	__be32 *p;



	if (!nfserr) {

	p = xdr_reserve_space(xdr, 20);

	if (!p)

		return nfserr_resource;

	p = encode_cinfo(p, &remove->rm_cinfo);

	}

	return nfserr;

	return 0;

}



static __be32
@@ -3754,19 +3725,16 @@ nfsd4_encode_rename(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_ 
	struct xdr_stream *xdr = &resp->xdr;

	__be32 *p;



	if (!nfserr) {

	p = xdr_reserve_space(xdr, 40);

	if (!p)

		return nfserr_resource;

	p = encode_cinfo(p, &rename->rn_sinfo);

	p = encode_cinfo(p, &rename->rn_tinfo);

	}

	return nfserr;

	return 0;

}



static __be32

nfsd4_do_encode_secinfo(struct xdr_stream *xdr,

			 __be32 nfserr, struct svc_export *exp)

nfsd4_do_encode_secinfo(struct xdr_stream *xdr, struct svc_export *exp)

{

	u32 i, nflavs, supported;

	struct exp_flavor_info *flavs;
@@ -3774,9 +3742,6 @@ nfsd4_do_encode_secinfo(struct xdr_stream *xdr, 
	__be32 *p, *flavorsp;

	static bool report = true;



	if (nfserr)

		goto out;

	nfserr = nfserr_resource;

	if (exp->ex_nflavors) {

		flavs = exp->ex_flavors;

		nflavs = exp->ex_nflavors;
@@ -3800,7 +3765,7 @@ nfsd4_do_encode_secinfo(struct xdr_stream *xdr, 
	supported = 0;

	p = xdr_reserve_space(xdr, 4);

	if (!p)

		goto out;

		return nfserr_resource;

	flavorsp = p++;		/* to be backfilled later */



	for (i = 0; i < nflavs; i++) {
@@ -3812,7 +3777,7 @@ nfsd4_do_encode_secinfo(struct xdr_stream *xdr, 
			p = xdr_reserve_space(xdr, 4 + 4 +

					      XDR_LEN(info.oid.len) + 4 + 4);

			if (!p)

				goto out;

				return nfserr_resource;

			*p++ = cpu_to_be32(RPC_AUTH_GSS);

			p = xdr_encode_opaque(p,  info.oid.data, info.oid.len);

			*p++ = cpu_to_be32(info.qop);
@@ -3821,7 +3786,7 @@ nfsd4_do_encode_secinfo(struct xdr_stream *xdr, 
			supported++;

			p = xdr_reserve_space(xdr, 4);

			if (!p)

				goto out;

				return nfserr_resource;

			*p++ = cpu_to_be32(pf);

		} else {

			if (report)
@@ -3833,11 +3798,7 @@ nfsd4_do_encode_secinfo(struct xdr_stream *xdr, 
	if (nflavs != supported)

		report = false;

	*flavorsp = htonl(supported);

	nfserr = 0;

out:

	if (exp)

		exp_put(exp);

	return nfserr;

	return 0;

}



static __be32
@@ -3846,7 +3807,7 @@ nfsd4_encode_secinfo(struct nfsd4_compoundres *resp, __be32 nfserr, 
{

	struct xdr_stream *xdr = &resp->xdr;



	return nfsd4_do_encode_secinfo(xdr, nfserr, secinfo->si_exp);

	return nfsd4_do_encode_secinfo(xdr, secinfo->si_exp);

}



static __be32
@@ -3855,7 +3816,7 @@ nfsd4_encode_secinfo_no_name(struct nfsd4_compoundres *resp, __be32 nfserr, 
{

	struct xdr_stream *xdr = &resp->xdr;



	return nfsd4_do_encode_secinfo(xdr, nfserr, secinfo->sin_exp);

	return nfsd4_do_encode_secinfo(xdr, secinfo->sin_exp);

}



/*
@@ -3916,7 +3877,6 @@ nfsd4_encode_write(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_w 
	struct xdr_stream *xdr = &resp->xdr;

	__be32 *p;



	if (!nfserr) {

	p = xdr_reserve_space(xdr, 16);

	if (!p)

		return nfserr_resource;
@@ -3924,8 +3884,7 @@ nfsd4_encode_write(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_w 
	*p++ = cpu_to_be32(write->wr_how_written);

	p = xdr_encode_opaque_fixed(p, write->wr_verifier.data,

						NFS4_VERIFIER_SIZE);

	}

	return nfserr;

	return 0;

}



static __be32
@@ -3938,12 +3897,8 @@ nfsd4_encode_exchange_id(struct nfsd4_compoundres *resp, __be32 nfserr, 
	char *server_scope;

	int major_id_sz;

	int server_scope_sz;

	int status = 0;

	uint64_t minor_id = 0;



	if (nfserr)

		return nfserr;



	major_id = utsname()->nodename;

	major_id_sz = strlen(major_id);

	server_scope = utsname()->nodename;
@@ -3968,19 +3923,19 @@ nfsd4_encode_exchange_id(struct nfsd4_compoundres *resp, __be32 nfserr, 
		break;

	case SP4_MACH_CRED:

		/* spo_must_enforce bitmap: */

		status = nfsd4_encode_bitmap(xdr,

		nfserr = nfsd4_encode_bitmap(xdr,

					exid->spo_must_enforce[0],

					exid->spo_must_enforce[1],

					exid->spo_must_enforce[2]);

		if (status)

			goto out;

		if (nfserr)

			return nfserr;

		/* spo_must_allow bitmap: */

		status = nfsd4_encode_bitmap(xdr,

		nfserr = nfsd4_encode_bitmap(xdr,

					exid->spo_must_allow[0],

					exid->spo_must_allow[1],

					exid->spo_must_allow[2]);

		if (status)

			goto out;

		if (nfserr)

			return nfserr;

		break;

	default:

		WARN_ON_ONCE(1);
@@ -4007,8 +3962,6 @@ nfsd4_encode_exchange_id(struct nfsd4_compoundres *resp, __be32 nfserr, 
	/* Implementation id */

	*p++ = cpu_to_be32(0);	/* zero length nfs_impl_id4 array */

	return 0;

out:

	return status;

}



static __be32
@@ -4018,9 +3971,6 @@ nfsd4_encode_create_session(struct nfsd4_compoundres *resp, __be32 nfserr, 
	struct xdr_stream *xdr = &resp->xdr;

	__be32 *p;



	if (nfserr)

		return nfserr;



	p = xdr_reserve_space(xdr, 24);

	if (!p)

		return nfserr_resource;
@@ -4074,9 +4024,6 @@ nfsd4_encode_sequence(struct nfsd4_compoundres *resp, __be32 nfserr, 
	struct xdr_stream *xdr = &resp->xdr;

	__be32 *p;



	if (nfserr)

		return nfserr;



	p = xdr_reserve_space(xdr, NFS4_MAX_SESSIONID_LEN + 20);

	if (!p)

		return nfserr_resource;
@@ -4101,9 +4048,6 @@ nfsd4_encode_test_stateid(struct nfsd4_compoundres *resp, __be32 nfserr, 
	struct nfsd4_test_stateid_id *stateid, *next;

	__be32 *p;



	if (nfserr)

		return nfserr;



	p = xdr_reserve_space(xdr, 4 + (4 * test_stateid->ts_num_ids));

	if (!p)

		return nfserr_resource;
@@ -4113,7 +4057,7 @@ nfsd4_encode_test_stateid(struct nfsd4_compoundres *resp, __be32 nfserr, 
		*p++ = stateid->ts_id_status;

	}



	return nfserr;

	return 0;

}



#ifdef CONFIG_NFSD_PNFS
@@ -4126,14 +4070,9 @@ nfsd4_encode_getdeviceinfo(struct nfsd4_compoundres *resp, __be32 nfserr, 
	u32 starting_len = xdr->buf->len, needed_len;

	__be32 *p;



	dprintk("%s: err %d\n", __func__, be32_to_cpu(nfserr));

	if (nfserr)

		goto out;



	nfserr = nfserr_resource;

	p = xdr_reserve_space(xdr, 4);

	if (!p)

		goto out;

		return nfserr_resource;



	*p++ = cpu_to_be32(gdev->gd_layout_type);
@@ -4149,42 +4088,33 @@ nfsd4_encode_getdeviceinfo(struct nfsd4_compoundres *resp, __be32 nfserr, 
			 */

			if (xdr->buf->len + 4 > gdev->gd_maxcount)

				goto toosmall;

			goto out;

			return nfserr;

		}

	}



	nfserr = nfserr_resource;

	if (gdev->gd_notify_types) {

		p = xdr_reserve_space(xdr, 4 + 4);

		if (!p)

			goto out;

			return nfserr_resource;

		*p++ = cpu_to_be32(1);			/* bitmap length */

		*p++ = cpu_to_be32(gdev->gd_notify_types);

	} else {

		p = xdr_reserve_space(xdr, 4);

		if (!p)

			goto out;

			return nfserr_resource;

		*p++ = 0;

	}



	nfserr = 0;

out:

	kfree(gdev->gd_device);

	dprintk("%s: done: %d\n", __func__, be32_to_cpu(nfserr));

	return nfserr;



	return 0;

toosmall:

	dprintk("%s: maxcount too small\n", __func__);

	needed_len = xdr->buf->len + 4 /* notifications */;

	xdr_truncate_encode(xdr, starting_len);

	p = xdr_reserve_space(xdr, 4);

	if (!p) {

		nfserr = nfserr_resource;

	} else {

	if (!p)

		return nfserr_resource;

	*p++ = cpu_to_be32(needed_len);

		nfserr = nfserr_toosmall;

	}

	goto out;

	return nfserr_toosmall;

}



static __be32
@@ -4195,14 +4125,9 @@ nfsd4_encode_layoutget(struct nfsd4_compoundres *resp, __be32 nfserr, 
	const struct nfsd4_layout_ops *ops;

	__be32 *p;



	dprintk("%s: err %d\n", __func__, nfserr);

	if (nfserr)

		goto out;



	nfserr = nfserr_resource;

	p = xdr_reserve_space(xdr, 36 + sizeof(stateid_opaque_t));

	if (!p)

		goto out;

		return nfserr_resource;



	*p++ = cpu_to_be32(1);	/* we always set return-on-close */

	*p++ = cpu_to_be32(lgp->lg_sid.si_generation);
@@ -4216,10 +4141,7 @@ nfsd4_encode_layoutget(struct nfsd4_compoundres *resp, __be32 nfserr, 
	*p++ = cpu_to_be32(lgp->lg_layout_type);



	ops = nfsd4_layout_ops[lgp->lg_layout_type];

	nfserr = ops->encode_layoutget(xdr, lgp);

out:

	kfree(lgp->lg_content);

	return nfserr;

	return ops->encode_layoutget(xdr, lgp);

}



static __be32
@@ -4229,9 +4151,6 @@ nfsd4_encode_layoutcommit(struct nfsd4_compoundres *resp, __be32 nfserr, 
	struct xdr_stream *xdr = &resp->xdr;

	__be32 *p;



	if (nfserr)

		return nfserr;



	p = xdr_reserve_space(xdr, 4);

	if (!p)

		return nfserr_resource;
@@ -4243,7 +4162,7 @@ nfsd4_encode_layoutcommit(struct nfsd4_compoundres *resp, __be32 nfserr, 
		p = xdr_encode_hyper(p, lcp->lc_newsize);

	}



	return nfs_ok;

	return 0;

}



static __be32
@@ -4253,16 +4172,13 @@ nfsd4_encode_layoutreturn(struct nfsd4_compoundres *resp, __be32 nfserr, 
	struct xdr_stream *xdr = &resp->xdr;

	__be32 *p;



	if (nfserr)

		return nfserr;



	p = xdr_reserve_space(xdr, 4);

	if (!p)

		return nfserr_resource;

	*p++ = cpu_to_be32(lrp->lrs_present);

	if (lrp->lrs_present)

		return nfsd4_encode_stateid(xdr, &lrp->lr_sid);

	return nfs_ok;

	return 0;

}

#endif /* CONFIG_NFSD_PNFS */
@@ -4289,7 +4205,6 @@ nfsd4_encode_copy(struct nfsd4_compoundres *resp, __be32 nfserr, 
{

	__be32 *p;



	if (!nfserr) {

	nfserr = nfsd42_encode_write_res(resp, &copy->cp_res);

	if (nfserr)

		return nfserr;
@@ -4297,8 +4212,7 @@ nfsd4_encode_copy(struct nfsd4_compoundres *resp, __be32 nfserr, 
	p = xdr_reserve_space(&resp->xdr, 4 + 4);

	*p++ = cpu_to_be32(copy->cp_consecutive);

	*p++ = cpu_to_be32(copy->cp_synchronous);

	}

	return nfserr;

	return 0;

}



static __be32
@@ -4307,14 +4221,11 @@ nfsd4_encode_seek(struct nfsd4_compoundres *resp, __be32 nfserr, 
{

	__be32 *p;



	if (nfserr)

		return nfserr;



	p = xdr_reserve_space(&resp->xdr, 4 + 8);

	*p++ = cpu_to_be32(seek->seek_eof);

	p = xdr_encode_hyper(p, seek->seek_pos);



	return nfserr;

	return 0;

}



static __be32
@@ -4330,7 +4241,7 @@ typedef __be32(* nfsd4_enc)(struct nfsd4_compoundres *, __be32, void *); 
 * since we don't need to filter out obsolete ops as this is

 * done in the decoding phase.

 */

static nfsd4_enc nfsd4_enc_ops[] = {

static const nfsd4_enc nfsd4_enc_ops[] = {

	[OP_ACCESS]		= (nfsd4_enc)nfsd4_encode_access,

	[OP_CLOSE]		= (nfsd4_enc)nfsd4_encode_close,

	[OP_COMMIT]		= (nfsd4_enc)nfsd4_encode_commit,
@@ -4449,6 +4360,7 @@ nfsd4_encode_operation(struct nfsd4_compoundres *resp, struct nfsd4_op *op) 
	struct xdr_stream *xdr = &resp->xdr;

	struct nfs4_stateowner *so = resp->cstate.replay_owner;

	struct svc_rqst *rqstp = resp->rqstp;

	const struct nfsd4_operation *opdesc = op->opdesc;

	int post_err_offset;

	nfsd4_enc encoder;

	__be32 *p;
@@ -4463,10 +4375,15 @@ nfsd4_encode_operation(struct nfsd4_compoundres *resp, struct nfsd4_op *op) 


	if (op->opnum == OP_ILLEGAL)

		goto status;

	if (op->status && opdesc &&

			!(opdesc->op_flags & OP_NONTRIVIAL_ERROR_ENCODE))

		goto status;

	BUG_ON(op->opnum < 0 || op->opnum >= ARRAY_SIZE(nfsd4_enc_ops) ||

	       !nfsd4_enc_ops[op->opnum]);

	encoder = nfsd4_enc_ops[op->opnum];

	op->status = encoder(resp, op->status, &op->u);

	if (opdesc && opdesc->op_release)

		opdesc->op_release(&op->u);

	xdr_commit_encode(xdr);



	/* nfsd4_check_resp_size guarantees enough room for error status */
@@ -4573,6 +4490,7 @@ nfs4svc_decode_compoundargs(struct svc_rqst *rqstp, __be32 *p) 
	args->end = rqstp->rq_arg.head[0].iov_base + rqstp->rq_arg.head[0].iov_len;

	args->pagelist = rqstp->rq_arg.pages;

	args->pagelen = rqstp->rq_arg.page_len;

	args->tail = false;

	args->tmpp = NULL;

	args->to_free = NULL;

	args->ops = args->iops;