treewide: Replace kmalloc with kmalloc_obj for non-scalar types

This is the result of running the Coccinelle script from
scripts/coccinelle/api/kmalloc_objs.cocci. The script is designed to
avoid scalar types (which need careful case-by-case checking), and
instead replace kmalloc-family calls that allocate struct or union
object instances:

Single allocations:	kmalloc(sizeof(TYPE), ...)
are replaced with:	kmalloc_obj(TYPE, ...)

Array allocations:	kmalloc_array(COUNT, sizeof(TYPE), ...)
are replaced with:	kmalloc_objs(TYPE, COUNT, ...)

Flex array allocations:	kmalloc(struct_size(PTR, FAM, COUNT), ...)
are replaced with:	kmalloc_flex(*PTR, FAM, COUNT, ...)

(where TYPE may also be *VAR)

The resulting allocations no longer return "void *", instead returning
"TYPE *".

Signed-off-by: Kees Cook <kees@kernel.org>

24 files changed, 56 insertions, 57 deletions

diff --git a/net/sunrpc/auth.c b/net/sunrpc/auth.c
index 5a827afd8e3b..fb33a4d0cdc7 100644
--- a/net/sunrpc/auth.c
+++ b/net/sunrpc/auth.c
@@ -290,12 +290,12 @@ rpcauth_init_credcache(struct rpc_auth *auth)
 	struct rpc_cred_cache *new;
 	unsigned int hashsize;
 
-	new = kmalloc(sizeof(*new), GFP_KERNEL);
+	new = kmalloc_obj(*new, GFP_KERNEL);
 	if (!new)
 		goto out_nocache;
 	new->hashbits = auth_hashbits;
 	hashsize = 1U << new->hashbits;
-	new->hashtable = kcalloc(hashsize, sizeof(new->hashtable[0]), GFP_KERNEL);
+	new->hashtable = kzalloc_objs(new->hashtable[0], hashsize, GFP_KERNEL);
 	if (!new->hashtable)
 		goto out_nohashtbl;
 	spin_lock_init(&new->lock);
diff --git a/net/sunrpc/auth_gss/auth_gss.c b/net/sunrpc/auth_gss/auth_gss.c
index bb3c3db2713b..f8a0d6386635 100644
--- a/net/sunrpc/auth_gss/auth_gss.c
+++ b/net/sunrpc/auth_gss/auth_gss.c
@@ -164,7 +164,7 @@ gss_alloc_context(void)
 {
 	struct gss_cl_ctx *ctx;
 
-	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
+	ctx = kzalloc_obj(*ctx, GFP_KERNEL);
 	if (ctx != NULL) {
 		ctx->gc_proc = RPC_GSS_PROC_DATA;
 		ctx->gc_seq = 1;	/* NetApp 6.4R1 doesn't accept seq. no. 0 */
@@ -529,7 +529,7 @@ gss_alloc_msg(struct gss_auth *gss_auth,
 	int vers;
 	int err = -ENOMEM;
 
-	gss_msg = kzalloc(sizeof(*gss_msg), GFP_KERNEL);
+	gss_msg = kzalloc_obj(*gss_msg, GFP_KERNEL);
 	if (gss_msg == NULL)
 		goto err;
 	vers = get_pipe_version(gss_auth->net);
@@ -914,7 +914,7 @@ static struct gss_pipe *gss_pipe_alloc(struct rpc_clnt *clnt,
 	struct gss_pipe *p;
 	int err = -ENOMEM;
 
-	p = kmalloc(sizeof(*p), GFP_KERNEL);
+	p = kmalloc_obj(*p, GFP_KERNEL);
 	if (p == NULL)
 		goto err;
 	p->pipe = rpc_mkpipe_data(upcall_ops, RPC_PIPE_WAIT_FOR_OPEN);
@@ -1029,7 +1029,7 @@ gss_create_new(const struct rpc_auth_create_args *args, struct rpc_clnt *clnt)
 
 	if (!try_module_get(THIS_MODULE))
 		return ERR_PTR(err);
-	if (!(gss_auth = kmalloc(sizeof(*gss_auth), GFP_KERNEL)))
+	if (!(gss_auth = kmalloc_obj(*gss_auth, GFP_KERNEL)))
 		goto out_dec;
 	INIT_HLIST_NODE(&gss_auth->hash);
 	gss_auth->target_name = NULL;
@@ -1246,7 +1246,7 @@ gss_dup_cred(struct gss_auth *gss_auth, struct gss_cred *gss_cred)
 	struct gss_cred *new;
 
 	/* Make a copy of the cred so that we can reference count it */
-	new = kzalloc(sizeof(*gss_cred), GFP_KERNEL);
+	new = kzalloc_obj(*gss_cred, GFP_KERNEL);
 	if (new) {
 		struct auth_cred acred = {
 			.cred = gss_cred->gc_base.cr_cred,
@@ -1380,7 +1380,7 @@ gss_create_cred(struct rpc_auth *auth, struct auth_cred *acred, int flags, gfp_t
 	struct gss_cred	*cred = NULL;
 	int err = -ENOMEM;
 
-	if (!(cred = kzalloc(sizeof(*cred), gfp)))
+	if (!(cred = kzalloc_obj(*cred, gfp)))
 		goto out_err;
 
 	rpcauth_init_cred(&cred->gc_base, acred, auth, &gss_credops);
@@ -1817,9 +1817,8 @@ alloc_enc_pages(struct rpc_rqst *rqstp)
 	last = (snd_buf->page_base + snd_buf->page_len - 1) >> PAGE_SHIFT;
 	rqstp->rq_enc_pages_num = last - first + 1 + 1;
 	rqstp->rq_enc_pages
-		= kmalloc_array(rqstp->rq_enc_pages_num,
-				sizeof(struct page *),
-				GFP_KERNEL);
+		= kmalloc_objs(struct page *, rqstp->rq_enc_pages_num,
+			       GFP_KERNEL);
 	if (!rqstp->rq_enc_pages)
 		goto out;
 	for (i=0; i < rqstp->rq_enc_pages_num; i++) {
diff --git a/net/sunrpc/auth_gss/gss_krb5_mech.c b/net/sunrpc/auth_gss/gss_krb5_mech.c
index 3366505bc669..6db64a9111a9 100644
--- a/net/sunrpc/auth_gss/gss_krb5_mech.c
+++ b/net/sunrpc/auth_gss/gss_krb5_mech.c
@@ -473,7 +473,7 @@ gss_krb5_import_sec_context(const void *p, size_t len, struct gss_ctx *ctx_id,
 	struct  krb5_ctx *ctx;
 	int ret;
 
-	ctx = kzalloc(sizeof(*ctx), gfp_mask);
+	ctx = kzalloc_obj(*ctx, gfp_mask);
 	if (ctx == NULL)
 		return -ENOMEM;
 
diff --git a/net/sunrpc/auth_gss/gss_mech_switch.c b/net/sunrpc/auth_gss/gss_mech_switch.c
index c84d0cf61980..78eab245f94a 100644
--- a/net/sunrpc/auth_gss/gss_mech_switch.c
+++ b/net/sunrpc/auth_gss/gss_mech_switch.c
@@ -355,7 +355,7 @@ gss_import_sec_context(const void *input_token, size_t bufsize,
 		       time64_t			*endtime,
 		       gfp_t gfp_mask)
 {
-	if (!(*ctx_id = kzalloc(sizeof(**ctx_id), gfp_mask)))
+	if (!(*ctx_id = kzalloc_obj(**ctx_id, gfp_mask)))
 		return -ENOMEM;
 	(*ctx_id)->mech_type = gss_mech_get(mech);
 
diff --git a/net/sunrpc/auth_gss/gss_rpc_upcall.c b/net/sunrpc/auth_gss/gss_rpc_upcall.c
index f549e4c05def..e02e6d4a3185 100644
--- a/net/sunrpc/auth_gss/gss_rpc_upcall.c
+++ b/net/sunrpc/auth_gss/gss_rpc_upcall.c
@@ -214,7 +214,7 @@ static int gssp_alloc_receive_pages(struct gssx_arg_accept_sec_context *arg)
 	unsigned int i;
 
 	arg->npages = DIV_ROUND_UP(NGROUPS_MAX * 4, PAGE_SIZE);
-	arg->pages = kcalloc(arg->npages, sizeof(struct page *), GFP_KERNEL);
+	arg->pages = kzalloc_objs(struct page *, arg->npages, GFP_KERNEL);
 	if (!arg->pages)
 		return -ENOMEM;
 	for (i = 0; i < arg->npages; i++) {
diff --git a/net/sunrpc/auth_gss/gss_rpc_xdr.c b/net/sunrpc/auth_gss/gss_rpc_xdr.c
index f320c0a8e604..e1e01965ef58 100644
--- a/net/sunrpc/auth_gss/gss_rpc_xdr.c
+++ b/net/sunrpc/auth_gss/gss_rpc_xdr.c
@@ -244,11 +244,11 @@ static int gssx_dec_option_array(struct xdr_stream *xdr,
 	/* we recognize only 1 currently: CREDS_VALUE */
 	oa->count = 1;
 
-	oa->data = kmalloc(sizeof(struct gssx_option), GFP_KERNEL);
+	oa->data = kmalloc_obj(struct gssx_option, GFP_KERNEL);
 	if (!oa->data)
 		return -ENOMEM;
 
-	creds = kzalloc(sizeof(struct svc_cred), GFP_KERNEL);
+	creds = kzalloc_obj(struct svc_cred, GFP_KERNEL);
 	if (!creds) {
 		err = -ENOMEM;
 		goto free_oa;
diff --git a/net/sunrpc/auth_gss/svcauth_gss.c b/net/sunrpc/auth_gss/svcauth_gss.c
index e2f0df8cdaa6..411297c9527d 100644
--- a/net/sunrpc/auth_gss/svcauth_gss.c
+++ b/net/sunrpc/auth_gss/svcauth_gss.c
@@ -197,7 +197,7 @@ static void update_rsi(struct cache_head *cnew, struct cache_head *citem)
 
 static struct cache_head *rsi_alloc(void)
 {
-	struct rsi *rsii = kmalloc(sizeof(*rsii), GFP_KERNEL);
+	struct rsi *rsii = kmalloc_obj(*rsii, GFP_KERNEL);
 	if (rsii)
 		return &rsii->h;
 	else
@@ -449,7 +449,7 @@ update_rsc(struct cache_head *cnew, struct cache_head *ctmp)
 static struct cache_head *
 rsc_alloc(void)
 {
-	struct rsc *rsci = kmalloc(sizeof(*rsci), GFP_KERNEL);
+	struct rsc *rsci = kmalloc_obj(*rsci, GFP_KERNEL);
 	if (rsci)
 		return &rsci->h;
 	else
@@ -814,7 +814,7 @@ svcauth_gss_register_pseudoflavor(u32 pseudoflavor, char * name)
 	struct auth_domain	*test;
 	int			stat = -ENOMEM;
 
-	new = kmalloc(sizeof(*new), GFP_KERNEL);
+	new = kmalloc_obj(*new, GFP_KERNEL);
 	if (!new)
 		goto out;
 	kref_init(&new->h.ref);
@@ -1069,7 +1069,7 @@ static int gss_read_proxy_verf(struct svc_rqst *rqstp,
 		goto out_denied_free;
 
 	pages = DIV_ROUND_UP(inlen, PAGE_SIZE);
-	in_token->pages = kcalloc(pages + 1, sizeof(struct page *), GFP_KERNEL);
+	in_token->pages = kzalloc_objs(struct page *, pages + 1, GFP_KERNEL);
 	if (!in_token->pages)
 		goto out_denied_free;
 	in_token->page_base = 0;
@@ -1631,7 +1631,7 @@ svcauth_gss_accept(struct svc_rqst *rqstp)
 
 	rqstp->rq_auth_stat = rpc_autherr_failed;
 	if (!svcdata)
-		svcdata = kmalloc(sizeof(*svcdata), GFP_KERNEL);
+		svcdata = kmalloc_obj(*svcdata, GFP_KERNEL);
 	if (!svcdata)
 		goto auth_err;
 	rqstp->rq_auth_data = svcdata;
diff --git a/net/sunrpc/auth_unix.c b/net/sunrpc/auth_unix.c
index 1e091d3fa607..6c742a3400c4 100644
--- a/net/sunrpc/auth_unix.c
+++ b/net/sunrpc/auth_unix.c
@@ -45,7 +45,7 @@ static struct rpc_cred *unx_lookup_cred(struct rpc_auth *auth,
 {
 	struct rpc_cred *ret;
 
-	ret = kmalloc(sizeof(*ret), rpc_task_gfp_mask());
+	ret = kmalloc_obj(*ret, rpc_task_gfp_mask());
 	if (!ret) {
 		if (!(flags & RPCAUTH_LOOKUP_ASYNC))
 			return ERR_PTR(-ENOMEM);
diff --git a/net/sunrpc/backchannel_rqst.c b/net/sunrpc/backchannel_rqst.c
index 6b9dee4119d5..0ffa4d01a938 100644
--- a/net/sunrpc/backchannel_rqst.c
+++ b/net/sunrpc/backchannel_rqst.c
@@ -94,7 +94,7 @@ static struct rpc_rqst *xprt_alloc_bc_req(struct rpc_xprt *xprt)
 	struct rpc_rqst *req;
 
 	/* Pre-allocate one backchannel rpc_rqst */
-	req = kzalloc(sizeof(*req), gfp_flags);
+	req = kzalloc_obj(*req, gfp_flags);
 	if (req == NULL)
 		return NULL;
 
diff --git a/net/sunrpc/cache.c b/net/sunrpc/cache.c
index d808c0b63f30..5129f3dace8c 100644
--- a/net/sunrpc/cache.c
+++ b/net/sunrpc/cache.c
@@ -1038,7 +1038,7 @@ static int cache_open(struct inode *inode, struct file *filp,
 		return -EACCES;
 	nonseekable_open(inode, filp);
 	if (filp->f_mode & FMODE_READ) {
-		rp = kmalloc(sizeof(*rp), GFP_KERNEL);
+		rp = kmalloc_obj(*rp, GFP_KERNEL);
 		if (!rp) {
 			module_put(cd->owner);
 			return -ENOMEM;
@@ -1225,7 +1225,7 @@ static int cache_pipe_upcall(struct cache_detail *detail, struct cache_head *h)
 	if (!buf)
 		return -EAGAIN;
 
-	crq = kmalloc(sizeof (*crq), GFP_KERNEL);
+	crq = kmalloc_obj(*crq, GFP_KERNEL);
 	if (!crq) {
 		kfree(buf);
 		return -EAGAIN;
@@ -1745,8 +1745,8 @@ struct cache_detail *cache_create_net(const struct cache_detail *tmpl, struct ne
 	if (cd == NULL)
 		return ERR_PTR(-ENOMEM);
 
-	cd->hash_table = kcalloc(cd->hash_size, sizeof(struct hlist_head),
-				 GFP_KERNEL);
+	cd->hash_table = kzalloc_objs(struct hlist_head, cd->hash_size,
+				      GFP_KERNEL);
 	if (cd->hash_table == NULL) {
 		kfree(cd);
 		return ERR_PTR(-ENOMEM);
diff --git a/net/sunrpc/clnt.c b/net/sunrpc/clnt.c
index 58442ae1c2da..f6e086b62053 100644
--- a/net/sunrpc/clnt.c
+++ b/net/sunrpc/clnt.c
@@ -374,7 +374,7 @@ static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args,
 		goto out_err;
 
 	err = -ENOMEM;
-	clnt = kzalloc(sizeof(*clnt), GFP_KERNEL);
+	clnt = kzalloc_obj(*clnt, GFP_KERNEL);
 	if (!clnt)
 		goto out_err;
 	clnt->cl_parent = parent ? : clnt;
@@ -2976,7 +2976,7 @@ int rpc_clnt_test_and_add_xprt(struct rpc_clnt *clnt,
 		return -EINVAL;
 	}
 
-	data = kmalloc(sizeof(*data), GFP_KERNEL);
+	data = kmalloc_obj(*data, GFP_KERNEL);
 	if (!data)
 		return -ENOMEM;
 	data->xps = xprt_switch_get(xps);
diff --git a/net/sunrpc/rpc_pipe.c b/net/sunrpc/rpc_pipe.c
index 379daefc4847..a4b3c51be0f3 100644
--- a/net/sunrpc/rpc_pipe.c
+++ b/net/sunrpc/rpc_pipe.c
@@ -511,7 +511,7 @@ struct rpc_pipe *rpc_mkpipe_data(const struct rpc_pipe_ops *ops, int flags)
 {
 	struct rpc_pipe *pipe;
 
-	pipe = kzalloc(sizeof(struct rpc_pipe), GFP_KERNEL);
+	pipe = kzalloc_obj(struct rpc_pipe, GFP_KERNEL);
 	if (!pipe)
 		return ERR_PTR(-ENOMEM);
 	init_pipe(pipe);
diff --git a/net/sunrpc/rpcb_clnt.c b/net/sunrpc/rpcb_clnt.c
index 53bcca365fb1..6aa372188c86 100644
--- a/net/sunrpc/rpcb_clnt.c
+++ b/net/sunrpc/rpcb_clnt.c
@@ -737,7 +737,7 @@ void rpcb_getport_async(struct rpc_task *task)
 		goto bailout_nofree;
 	}
 
-	map = kzalloc(sizeof(struct rpcbind_args), rpc_task_gfp_mask());
+	map = kzalloc_obj(struct rpcbind_args, rpc_task_gfp_mask());
 	if (!map) {
 		status = -ENOMEM;
 		goto bailout_release_client;
diff --git a/net/sunrpc/stats.c b/net/sunrpc/stats.c
index 383860cb1d5b..36308711e0e9 100644
--- a/net/sunrpc/stats.c
+++ b/net/sunrpc/stats.c
@@ -126,7 +126,7 @@ struct rpc_iostats *rpc_alloc_iostats(struct rpc_clnt *clnt)
 	struct rpc_iostats *stats;
 	int i;
 
-	stats = kcalloc(clnt->cl_maxproc, sizeof(*stats), GFP_KERNEL);
+	stats = kzalloc_objs(*stats, clnt->cl_maxproc, GFP_KERNEL);
 	if (stats) {
 		for (i = 0; i < clnt->cl_maxproc; i++)
 			spin_lock_init(&stats[i].om_lock);
diff --git a/net/sunrpc/svc.c b/net/sunrpc/svc.c
index 346ac560dcc2..bc160368a7dc 100644
--- a/net/sunrpc/svc.c
+++ b/net/sunrpc/svc.c
@@ -488,7 +488,7 @@ __svc_create(struct svc_program *prog, int nprogs, struct svc_stat *stats,
 	unsigned int xdrsize;
 	unsigned int i;
 
-	if (!(serv = kzalloc(sizeof(*serv), GFP_KERNEL)))
+	if (!(serv = kzalloc_obj(*serv, GFP_KERNEL)))
 		return NULL;
 	serv->sv_name      = prog->pg_name;
 	serv->sv_programs  = prog;
@@ -523,8 +523,7 @@ __svc_create(struct svc_program *prog, int nprogs, struct svc_stat *stats,
 
 	serv->sv_nrpools = npools;
 	serv->sv_pools =
-		kcalloc(serv->sv_nrpools, sizeof(struct svc_pool),
-			GFP_KERNEL);
+		kzalloc_objs(struct svc_pool, serv->sv_nrpools, GFP_KERNEL);
 	if (!serv->sv_pools) {
 		kfree(serv);
 		return NULL;
diff --git a/net/sunrpc/svcauth_unix.c b/net/sunrpc/svcauth_unix.c
index 8ca98b146ec8..7f952d9201f5 100644
--- a/net/sunrpc/svcauth_unix.c
+++ b/net/sunrpc/svcauth_unix.c
@@ -72,7 +72,7 @@ struct auth_domain *unix_domain_find(char *name)
 			return rv;
 		}
 
-		new = kmalloc(sizeof(*new), GFP_KERNEL);
+		new = kmalloc_obj(*new, GFP_KERNEL);
 		if (new == NULL)
 			return NULL;
 		kref_init(&new->h.ref);
@@ -143,7 +143,7 @@ static void update(struct cache_head *cnew, struct cache_head *citem)
 }
 static struct cache_head *ip_map_alloc(void)
 {
-	struct ip_map *i = kmalloc(sizeof(*i), GFP_KERNEL);
+	struct ip_map *i = kmalloc_obj(*i, GFP_KERNEL);
 	if (i)
 		return &i->h;
 	else
@@ -458,7 +458,7 @@ static void unix_gid_update(struct cache_head *cnew, struct cache_head *citem)
 }
 static struct cache_head *unix_gid_alloc(void)
 {
-	struct unix_gid *g = kmalloc(sizeof(*g), GFP_KERNEL);
+	struct unix_gid *g = kmalloc_obj(*g, GFP_KERNEL);
 	if (g)
 		return &g->h;
 	else
diff --git a/net/sunrpc/svcsock.c b/net/sunrpc/svcsock.c
index d61cd9b40491..e1576c807e07 100644
--- a/net/sunrpc/svcsock.c
+++ b/net/sunrpc/svcsock.c
@@ -1436,12 +1436,13 @@ static struct svc_sock *svc_setup_socket(struct svc_serv *serv,
 		return ERR_PTR(sendpages);
 
 	pages = svc_serv_maxpages(serv);
-	svsk = kzalloc(struct_size(svsk, sk_pages, pages), GFP_KERNEL);
+	svsk = kzalloc_flex(*svsk, sk_pages, pages, GFP_KERNEL);
 	if (!svsk)
 		return ERR_PTR(-ENOMEM);
 
 	if (sendpages) {
-		svsk->sk_bvec = kcalloc(sendpages, sizeof(*svsk->sk_bvec), GFP_KERNEL);
+		svsk->sk_bvec = kzalloc_objs(*svsk->sk_bvec, sendpages,
+					     GFP_KERNEL);
 		if (!svsk->sk_bvec) {
 			kfree(svsk);
 			return ERR_PTR(-ENOMEM);
diff --git a/net/sunrpc/sysfs.c b/net/sunrpc/sysfs.c
index 8b01b7ae2690..ec6ddfa11f86 100644
--- a/net/sunrpc/sysfs.c
+++ b/net/sunrpc/sysfs.c
@@ -48,7 +48,7 @@ static struct kobject *rpc_sysfs_object_alloc(const char *name,
 {
 	struct kobject *kobj;
 
-	kobj = kzalloc(sizeof(*kobj), GFP_KERNEL);
+	kobj = kzalloc_obj(*kobj, GFP_KERNEL);
 	if (kobj) {
 		kobj->kset = kset;
 		if (kobject_init_and_add(kobj, &rpc_sysfs_object_type,
@@ -397,7 +397,7 @@ static ssize_t rpc_sysfs_xprt_dstaddr_store(struct kobject *kobj,
 	dst_addr = kstrndup(buf, buf_len, GFP_KERNEL);
 	if (!dst_addr)
 		goto out_err;
-	saved_addr = kzalloc(sizeof(*saved_addr), GFP_KERNEL);
+	saved_addr = kzalloc_obj(*saved_addr, GFP_KERNEL);
 	if (!saved_addr)
 		goto out_err_free;
 	saved_addr->addr =
@@ -663,7 +663,7 @@ static struct rpc_sysfs_client *rpc_sysfs_client_alloc(struct kobject *parent,
 {
 	struct rpc_sysfs_client *p;
 
-	p = kzalloc(sizeof(*p), GFP_KERNEL);
+	p = kzalloc_obj(*p, GFP_KERNEL);
 	if (p) {
 		p->net = net;
 		p->kobject.kset = rpc_sunrpc_kset;
@@ -683,7 +683,7 @@ rpc_sysfs_xprt_switch_alloc(struct kobject *parent,
 {
 	struct rpc_sysfs_xprt_switch *p;
 
-	p = kzalloc(sizeof(*p), gfp_flags);
+	p = kzalloc_obj(*p, gfp_flags);
 	if (p) {
 		p->net = net;
 		p->kobject.kset = rpc_sunrpc_kset;
@@ -703,7 +703,7 @@ static struct rpc_sysfs_xprt *rpc_sysfs_xprt_alloc(struct kobject *parent,
 {
 	struct rpc_sysfs_xprt *p;
 
-	p = kzalloc(sizeof(*p), gfp_flags);
+	p = kzalloc_obj(*p, gfp_flags);
 	if (!p)
 		goto out;
 	p->kobject.kset = rpc_sunrpc_kset;
diff --git a/net/sunrpc/xdr.c b/net/sunrpc/xdr.c
index 70efc727a9cd..e83d5d0be78b 100644
--- a/net/sunrpc/xdr.c
+++ b/net/sunrpc/xdr.c
@@ -118,7 +118,7 @@ xdr_alloc_bvec(struct xdr_buf *buf, gfp_t gfp)
 	size_t i, n = xdr_buf_pagecount(buf);
 
 	if (n != 0 && buf->bvec == NULL) {
-		buf->bvec = kmalloc_array(n, sizeof(buf->bvec[0]), gfp);
+		buf->bvec = kmalloc_objs(buf->bvec[0], n, gfp);
 		if (!buf->bvec)
 			return -ENOMEM;
 		for (i = 0; i < n; i++) {
diff --git a/net/sunrpc/xprt.c b/net/sunrpc/xprt.c
index 1023361845f9..16f6989a0a2d 100644
--- a/net/sunrpc/xprt.c
+++ b/net/sunrpc/xprt.c
@@ -1709,7 +1709,7 @@ static struct rpc_rqst *xprt_dynamic_alloc_slot(struct rpc_xprt *xprt)
 		goto out;
 	++xprt->num_reqs;
 	spin_unlock(&xprt->reserve_lock);
-	req = kzalloc(sizeof(*req), rpc_task_gfp_mask());
+	req = kzalloc_obj(*req, rpc_task_gfp_mask());
 	spin_lock(&xprt->reserve_lock);
 	if (req != NULL)
 		goto out;
@@ -1829,7 +1829,7 @@ struct rpc_xprt *xprt_alloc(struct net *net, size_t size,
 	xprt_init(xprt, net);
 
 	for (i = 0; i < num_prealloc; i++) {
-		req = kzalloc(sizeof(struct rpc_rqst), GFP_KERNEL);
+		req = kzalloc_obj(struct rpc_rqst, GFP_KERNEL);
 		if (!req)
 			goto out_free;
 		list_add(&req->rq_list, &xprt->free);
diff --git a/net/sunrpc/xprtmultipath.c b/net/sunrpc/xprtmultipath.c
index 4c5e08b0aa64..3ba818d637be 100644
--- a/net/sunrpc/xprtmultipath.c
+++ b/net/sunrpc/xprtmultipath.c
@@ -150,7 +150,7 @@ struct rpc_xprt_switch *xprt_switch_alloc(struct rpc_xprt *xprt,
 {
 	struct rpc_xprt_switch *xps;
 
-	xps = kmalloc(sizeof(*xps), gfp_flags);
+	xps = kmalloc_obj(*xps, gfp_flags);
 	if (xps != NULL) {
 		spin_lock_init(&xps->xps_lock);
 		kref_init(&xps->xps_kref);
diff --git a/net/sunrpc/xprtrdma/ib_client.c b/net/sunrpc/xprtrdma/ib_client.c
index 28c68b5f6823..e5b6dfaf01aa 100644
--- a/net/sunrpc/xprtrdma/ib_client.c
+++ b/net/sunrpc/xprtrdma/ib_client.c
@@ -108,7 +108,7 @@ static int rpcrdma_add_one(struct ib_device *device)
 {
 	struct rpcrdma_device *rd;
 
-	rd = kzalloc(sizeof(*rd), GFP_KERNEL);
+	rd = kzalloc_obj(*rd, GFP_KERNEL);
 	if (!rd)
 		return -ENOMEM;
 
diff --git a/net/sunrpc/xprtrdma/svc_rdma_pcl.c b/net/sunrpc/xprtrdma/svc_rdma_pcl.c
index b63cfeaa2923..b7c09a1f1c62 100644
--- a/net/sunrpc/xprtrdma/svc_rdma_pcl.c
+++ b/net/sunrpc/xprtrdma/svc_rdma_pcl.c
@@ -29,7 +29,7 @@ static struct svc_rdma_chunk *pcl_alloc_chunk(u32 segcount, u32 position)
 {
 	struct svc_rdma_chunk *chunk;
 
-	chunk = kmalloc(struct_size(chunk, ch_segments, segcount), GFP_KERNEL);
+	chunk = kmalloc_flex(*chunk, ch_segments, segcount, GFP_KERNEL);
 	if (!chunk)
 		return NULL;
 
diff --git a/net/sunrpc/xprtrdma/verbs.c b/net/sunrpc/xprtrdma/verbs.c
index 63262ef0c2e3..15bbf953dfad 100644
--- a/net/sunrpc/xprtrdma/verbs.c
+++ b/net/sunrpc/xprtrdma/verbs.c
@@ -383,7 +383,7 @@ static int rpcrdma_ep_create(struct rpcrdma_xprt *r_xprt)
 	struct rpcrdma_ep *ep;
 	int rc;
 
-	ep = kzalloc(sizeof(*ep), XPRTRDMA_GFP_FLAGS);
+	ep = kzalloc_obj(*ep, XPRTRDMA_GFP_FLAGS);
 	if (!ep)
 		return -ENOTCONN;
 	ep->re_xprt = &r_xprt->rx_xprt;
@@ -615,8 +615,8 @@ static struct rpcrdma_sendctx *rpcrdma_sendctx_create(struct rpcrdma_ep *ep)
 {
 	struct rpcrdma_sendctx *sc;
 
-	sc = kzalloc(struct_size(sc, sc_sges, ep->re_attr.cap.max_send_sge),
-		     XPRTRDMA_GFP_FLAGS);
+	sc = kzalloc_flex(*sc, sc_sges, ep->re_attr.cap.max_send_sge,
+			  XPRTRDMA_GFP_FLAGS);
 	if (!sc)
 		return NULL;
 
@@ -639,7 +639,7 @@ static int rpcrdma_sendctxs_create(struct rpcrdma_xprt *r_xprt)
 	 * Sends are posted.
 	 */
 	i = r_xprt->rx_ep->re_max_requests + RPCRDMA_MAX_BC_REQUESTS;
-	buf->rb_sc_ctxs = kcalloc(i, sizeof(sc), XPRTRDMA_GFP_FLAGS);
+	buf->rb_sc_ctxs = kzalloc_objs(sc, i, XPRTRDMA_GFP_FLAGS);
 	if (!buf->rb_sc_ctxs)
 		return -ENOMEM;
 
@@ -822,7 +822,7 @@ struct rpcrdma_req *rpcrdma_req_create(struct rpcrdma_xprt *r_xprt,
 	struct rpcrdma_buffer *buffer = &r_xprt->rx_buf;
 	struct rpcrdma_req *req;
 
-	req = kzalloc(sizeof(*req), XPRTRDMA_GFP_FLAGS);
+	req = kzalloc_obj(*req, XPRTRDMA_GFP_FLAGS);
 	if (req == NULL)
 		goto out1;
 
@@ -952,7 +952,7 @@ struct rpcrdma_rep *rpcrdma_rep_create(struct rpcrdma_xprt *r_xprt)
 	struct ib_device *device = ep->re_id->device;
 	struct rpcrdma_rep *rep;
 
-	rep = kzalloc(sizeof(*rep), XPRTRDMA_GFP_FLAGS);
+	rep = kzalloc_obj(*rep, XPRTRDMA_GFP_FLAGS);
 	if (rep == NULL)
 		goto out;