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>

75 files changed, 185 insertions, 199 deletions

diff --git a/drivers/md/bcache/alloc.c b/drivers/md/bcache/alloc.c
index 7708d92df23e..90cc6ed4bd6d 100644
--- a/drivers/md/bcache/alloc.c
+++ b/drivers/md/bcache/alloc.c
@@ -697,7 +697,7 @@ int bch_open_buckets_alloc(struct cache_set *c)
 	spin_lock_init(&c->data_bucket_lock);
 
 	for (i = 0; i < MAX_OPEN_BUCKETS; i++) {
-		struct open_bucket *b = kzalloc(sizeof(*b), GFP_KERNEL);
+		struct open_bucket *b = kzalloc_obj(*b, GFP_KERNEL);
 
 		if (!b)
 			return -ENOMEM;
diff --git a/drivers/md/bcache/btree.c b/drivers/md/bcache/btree.c
index 3ed39c823826..27a129d47d0a 100644
--- a/drivers/md/bcache/btree.c
+++ b/drivers/md/bcache/btree.c
@@ -585,7 +585,7 @@ static struct btree *mca_bucket_alloc(struct cache_set *c,
 	 * kzalloc() is necessary here for initialization,
 	 * see code comments in bch_btree_keys_init().
 	 */
-	struct btree *b = kzalloc(sizeof(struct btree), gfp);
+	struct btree *b = kzalloc_obj(struct btree, gfp);
 
 	if (!b)
 		return NULL;
diff --git a/drivers/md/bcache/debug.c b/drivers/md/bcache/debug.c
index f327456fc4e0..55f5e202015d 100644
--- a/drivers/md/bcache/debug.c
+++ b/drivers/md/bcache/debug.c
@@ -208,7 +208,7 @@ static int bch_dump_open(struct inode *inode, struct file *file)
 	struct cache_set *c = inode->i_private;
 	struct dump_iterator *i;
 
-	i = kzalloc(sizeof(struct dump_iterator), GFP_KERNEL);
+	i = kzalloc_obj(struct dump_iterator, GFP_KERNEL);
 	if (!i)
 		return -ENOMEM;
 
diff --git a/drivers/md/bcache/super.c b/drivers/md/bcache/super.c
index 238d12ffdae8..a304ef80820b 100644
--- a/drivers/md/bcache/super.c
+++ b/drivers/md/bcache/super.c
@@ -1527,8 +1527,7 @@ static CLOSURE_CALLBACK(flash_dev_flush)
 static int flash_dev_run(struct cache_set *c, struct uuid_entry *u)
 {
 	int err = -ENOMEM;
-	struct bcache_device *d = kzalloc(sizeof(struct bcache_device),
-					  GFP_KERNEL);
+	struct bcache_device *d = kzalloc_obj(struct bcache_device, GFP_KERNEL);
 	if (!d)
 		goto err_ret;
 
@@ -1864,7 +1863,7 @@ struct cache_set *bch_cache_set_alloc(struct cache_sb *sb)
 {
 	int iter_size;
 	struct cache *ca = container_of(sb, struct cache, sb);
-	struct cache_set *c = kzalloc(sizeof(struct cache_set), GFP_KERNEL);
+	struct cache_set *c = kzalloc_obj(struct cache_set, GFP_KERNEL);
 
 	if (!c)
 		return NULL;
@@ -2543,8 +2542,8 @@ static void register_device_async(struct async_reg_args *args)
 static void *alloc_holder_object(struct cache_sb *sb)
 {
 	if (SB_IS_BDEV(sb))
-		return kzalloc(sizeof(struct cached_dev), GFP_KERNEL);
-	return kzalloc(sizeof(struct cache), GFP_KERNEL);
+		return kzalloc_obj(struct cached_dev, GFP_KERNEL);
+	return kzalloc_obj(struct cache, GFP_KERNEL);
 }
 
 static ssize_t register_bcache(struct kobject *k, struct kobj_attribute *attr,
@@ -2581,7 +2580,7 @@ static ssize_t register_bcache(struct kobject *k, struct kobj_attribute *attr,
 	if (!path)
 		goto out_module_put;
 
-	sb = kmalloc(sizeof(struct cache_sb), GFP_KERNEL);
+	sb = kmalloc_obj(struct cache_sb, GFP_KERNEL);
 	if (!sb)
 		goto out_free_path;
 
@@ -2633,7 +2632,7 @@ static ssize_t register_bcache(struct kobject *k, struct kobj_attribute *attr,
 	if (async_registration) {
 		/* register in asynchronous way */
 		struct async_reg_args *args =
-			kzalloc(sizeof(struct async_reg_args), GFP_KERNEL);
+			kzalloc_obj(struct async_reg_args, GFP_KERNEL);
 
 		if (!args) {
 			ret = -ENOMEM;
@@ -2710,7 +2709,7 @@ static ssize_t bch_pending_bdevs_cleanup(struct kobject *k,
 
 	mutex_lock(&bch_register_lock);
 	list_for_each_entry_safe(dc, tdc, &uncached_devices, list) {
-		pdev = kmalloc(sizeof(struct pdev), GFP_KERNEL);
+		pdev = kmalloc_obj(struct pdev, GFP_KERNEL);
 		if (!pdev)
 			break;
 		pdev->dc = dc;
diff --git a/drivers/md/bcache/sysfs.c b/drivers/md/bcache/sysfs.c
index 72f38e5b6f5c..b30424075106 100644
--- a/drivers/md/bcache/sysfs.c
+++ b/drivers/md/bcache/sysfs.c
@@ -415,7 +415,7 @@ STORE(__cached_dev)
 			       buf, SB_LABEL_SIZE);
 			bch_uuid_write(dc->disk.c);
 		}
-		env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
+		env = kzalloc_obj(struct kobj_uevent_env, GFP_KERNEL);
 		if (!env)
 			return -ENOMEM;
 		add_uevent_var(env, "DRIVER=bcache");
diff --git a/drivers/md/dm-bio-prison-v1.c b/drivers/md/dm-bio-prison-v1.c
index b4d1c4329df3..fc8bb30dc533 100644
--- a/drivers/md/dm-bio-prison-v1.c
+++ b/drivers/md/dm-bio-prison-v1.c
@@ -44,7 +44,7 @@ struct dm_bio_prison *dm_bio_prison_create(void)
 	struct dm_bio_prison *prison;
 
 	num_locks = dm_num_hash_locks();
-	prison = kzalloc(struct_size(prison, regions, num_locks), GFP_KERNEL);
+	prison = kzalloc_flex(*prison, regions, num_locks, GFP_KERNEL);
 	if (!prison)
 		return NULL;
 	prison->num_locks = num_locks;
@@ -301,7 +301,7 @@ struct dm_deferred_set *dm_deferred_set_create(void)
 	int i;
 	struct dm_deferred_set *ds;
 
-	ds = kmalloc(sizeof(*ds), GFP_KERNEL);
+	ds = kmalloc_obj(*ds, GFP_KERNEL);
 	if (!ds)
 		return NULL;
 
diff --git a/drivers/md/dm-bio-prison-v2.c b/drivers/md/dm-bio-prison-v2.c
index cf433b0cf742..d4daf426c2c7 100644
--- a/drivers/md/dm-bio-prison-v2.c
+++ b/drivers/md/dm-bio-prison-v2.c
@@ -36,7 +36,7 @@ static struct kmem_cache *_cell_cache;
  */
 struct dm_bio_prison_v2 *dm_bio_prison_create_v2(struct workqueue_struct *wq)
 {
-	struct dm_bio_prison_v2 *prison = kzalloc(sizeof(*prison), GFP_KERNEL);
+	struct dm_bio_prison_v2 *prison = kzalloc_obj(*prison, GFP_KERNEL);
 	int ret;
 
 	if (!prison)
diff --git a/drivers/md/dm-cache-background-tracker.c b/drivers/md/dm-cache-background-tracker.c
index b4165f172d62..fb5efaab11a3 100644
--- a/drivers/md/dm-cache-background-tracker.c
+++ b/drivers/md/dm-cache-background-tracker.c
@@ -26,7 +26,7 @@ struct kmem_cache *btracker_work_cache = NULL;
 
 struct background_tracker *btracker_create(unsigned int max_work)
 {
-	struct background_tracker *b = kmalloc(sizeof(*b), GFP_KERNEL);
+	struct background_tracker *b = kmalloc_obj(*b, GFP_KERNEL);
 
 	if (!b) {
 		DMERR("couldn't create background_tracker");
diff --git a/drivers/md/dm-cache-metadata.c b/drivers/md/dm-cache-metadata.c
index a9a1ab284076..5060a58605a2 100644
--- a/drivers/md/dm-cache-metadata.c
+++ b/drivers/md/dm-cache-metadata.c
@@ -760,7 +760,7 @@ static struct dm_cache_metadata *metadata_open(struct block_device *bdev,
 	int r;
 	struct dm_cache_metadata *cmd;
 
-	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+	cmd = kzalloc_obj(*cmd, GFP_KERNEL);
 	if (!cmd) {
 		DMERR("could not allocate metadata struct");
 		return ERR_PTR(-ENOMEM);
diff --git a/drivers/md/dm-cache-policy-smq.c b/drivers/md/dm-cache-policy-smq.c
index 7e1e8cc0e33a..bec1b5e95170 100644
--- a/drivers/md/dm-cache-policy-smq.c
+++ b/drivers/md/dm-cache-policy-smq.c
@@ -1735,7 +1735,7 @@ __smq_create(dm_cblock_t cache_size, sector_t origin_size, sector_t cache_block_
 	unsigned int i;
 	unsigned int nr_sentinels_per_queue = 2u * NR_CACHE_LEVELS;
 	unsigned int total_sentinels = 2u * nr_sentinels_per_queue;
-	struct smq_policy *mq = kzalloc(sizeof(*mq), GFP_KERNEL);
+	struct smq_policy *mq = kzalloc_obj(*mq, GFP_KERNEL);
 
 	if (!mq)
 		return NULL;
diff --git a/drivers/md/dm-cache-target.c b/drivers/md/dm-cache-target.c
index 62d1060619dd..be1af992b931 100644
--- a/drivers/md/dm-cache-target.c
+++ b/drivers/md/dm-cache-target.c
@@ -2387,7 +2387,7 @@ static int cache_create(struct cache_args *ca, struct cache **result)
 	struct dm_cache_metadata *cmd;
 	bool may_format = ca->features.mode == CM_WRITE;
 
-	cache = kzalloc(sizeof(*cache), GFP_KERNEL);
+	cache = kzalloc_obj(*cache, GFP_KERNEL);
 	if (!cache)
 		return -ENOMEM;
 
@@ -2612,7 +2612,7 @@ static int cache_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 	struct cache_args *ca;
 	struct cache *cache = NULL;
 
-	ca = kzalloc(sizeof(*ca), GFP_KERNEL);
+	ca = kzalloc_obj(*ca, GFP_KERNEL);
 	if (!ca) {
 		ti->error = "Error allocating memory for cache";
 		return -ENOMEM;
diff --git a/drivers/md/dm-clone-metadata.c b/drivers/md/dm-clone-metadata.c
index 14c5c28d938b..cb474e852548 100644
--- a/drivers/md/dm-clone-metadata.c
+++ b/drivers/md/dm-clone-metadata.c
@@ -553,7 +553,7 @@ struct dm_clone_metadata *dm_clone_metadata_open(struct block_device *bdev,
 	int r;
 	struct dm_clone_metadata *cmd;
 
-	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
+	cmd = kzalloc_obj(*cmd, GFP_KERNEL);
 	if (!cmd) {
 		DMERR("Failed to allocate memory for dm-clone metadata");
 		return ERR_PTR(-ENOMEM);
diff --git a/drivers/md/dm-clone-target.c b/drivers/md/dm-clone-target.c
index a7f73861a8cd..c9b25af70063 100644
--- a/drivers/md/dm-clone-target.c
+++ b/drivers/md/dm-clone-target.c
@@ -580,7 +580,7 @@ static int hash_table_init(struct clone *clone)
 
 	sz = 1 << HASH_TABLE_BITS;
 
-	clone->ht = kvmalloc_array(sz, sizeof(struct hash_table_bucket), GFP_KERNEL);
+	clone->ht = kvmalloc_objs(struct hash_table_bucket, sz, GFP_KERNEL);
 	if (!clone->ht)
 		return -ENOMEM;
 
@@ -1766,7 +1766,7 @@ static int clone_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 	as.argc = argc;
 	as.argv = argv;
 
-	clone = kzalloc(sizeof(*clone), GFP_KERNEL);
+	clone = kzalloc_obj(*clone, GFP_KERNEL);
 	if (!clone) {
 		ti->error = "Failed to allocate clone structure";
 		return -ENOMEM;
diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index 339976d4c2ca..a2f9f0f0db5e 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -2334,9 +2334,8 @@ static int crypt_alloc_tfms_skcipher(struct crypt_config *cc, char *ciphermode)
 	unsigned int i;
 	int err;
 
-	cc->cipher_tfm.tfms = kcalloc(cc->tfms_count,
-				      sizeof(struct crypto_skcipher *),
-				      GFP_KERNEL);
+	cc->cipher_tfm.tfms = kzalloc_objs(struct crypto_skcipher *,
+					   cc->tfms_count, GFP_KERNEL);
 	if (!cc->cipher_tfm.tfms)
 		return -ENOMEM;
 
@@ -2364,7 +2363,7 @@ static int crypt_alloc_tfms_aead(struct crypt_config *cc, char *ciphermode)
 {
 	int err;
 
-	cc->cipher_tfm.tfms = kmalloc(sizeof(struct crypto_skcipher *), GFP_KERNEL);
+	cc->cipher_tfm.tfms = kmalloc_obj(struct crypto_skcipher *, GFP_KERNEL);
 	if (!cc->cipher_tfm.tfms)
 		return -ENOMEM;
 
@@ -3238,7 +3237,7 @@ static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 		return -EINVAL;
 	}
 
-	cc = kzalloc(struct_size(cc, key, key_size), GFP_KERNEL);
+	cc = kzalloc_flex(*cc, key, key_size, GFP_KERNEL);
 	if (!cc) {
 		ti->error = "Cannot allocate encryption context";
 		return -ENOMEM;
diff --git a/drivers/md/dm-delay.c b/drivers/md/dm-delay.c
index 029f04776490..5d2dd07a19b0 100644
--- a/drivers/md/dm-delay.c
+++ b/drivers/md/dm-delay.c
@@ -224,7 +224,7 @@ static int delay_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 		return -EINVAL;
 	}
 
-	dc = kzalloc(sizeof(*dc), GFP_KERNEL);
+	dc = kzalloc_obj(*dc, GFP_KERNEL);
 	if (!dc) {
 		ti->error = "Cannot allocate context";
 		return -ENOMEM;
diff --git a/drivers/md/dm-dust.c b/drivers/md/dm-dust.c
index e75310232bbf..a91f96bad0b9 100644
--- a/drivers/md/dm-dust.c
+++ b/drivers/md/dm-dust.c
@@ -108,7 +108,7 @@ static int dust_add_block(struct dust_device *dd, unsigned long long block,
 	struct badblock *bblock;
 	unsigned long flags;
 
-	bblock = kmalloc(sizeof(*bblock), GFP_KERNEL);
+	bblock = kmalloc_obj(*bblock, GFP_KERNEL);
 	if (bblock == NULL) {
 		if (!dd->quiet_mode)
 			DMERR("%s: badblock allocation failed", __func__);
@@ -360,7 +360,7 @@ static int dust_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 		return -EINVAL;
 	}
 
-	dd = kzalloc(sizeof(struct dust_device), GFP_KERNEL);
+	dd = kzalloc_obj(struct dust_device, GFP_KERNEL);
 	if (dd == NULL) {
 		ti->error = "Cannot allocate context";
 		return -ENOMEM;
diff --git a/drivers/md/dm-ebs-target.c b/drivers/md/dm-ebs-target.c
index b354e74a670e..4c9a25ae90d6 100644
--- a/drivers/md/dm-ebs-target.c
+++ b/drivers/md/dm-ebs-target.c
@@ -257,7 +257,7 @@ static int ebs_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 		return -EINVAL;
 	}
 
-	ec = ti->private = kzalloc(sizeof(*ec), GFP_KERNEL);
+	ec = ti->private = kzalloc_obj(*ec, GFP_KERNEL);
 	if (!ec) {
 		ti->error = "Cannot allocate ebs context";
 		return -ENOMEM;
diff --git a/drivers/md/dm-era-target.c b/drivers/md/dm-era-target.c
index 9c84e9d13eca..9bec72f04b9b 100644
--- a/drivers/md/dm-era-target.c
+++ b/drivers/md/dm-era-target.c
@@ -808,7 +808,7 @@ static struct era_metadata *metadata_open(struct block_device *bdev,
 					  bool may_format)
 {
 	int r;
-	struct era_metadata *md = kzalloc(sizeof(*md), GFP_KERNEL);
+	struct era_metadata *md = kzalloc_obj(*md, GFP_KERNEL);
 
 	if (!md)
 		return NULL;
@@ -1473,7 +1473,7 @@ static int era_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 		return -EINVAL;
 	}
 
-	era = kzalloc(sizeof(*era), GFP_KERNEL);
+	era = kzalloc_obj(*era, GFP_KERNEL);
 	if (!era) {
 		ti->error = "Error allocating era structure";
 		return -ENOMEM;
diff --git a/drivers/md/dm-exception-store.c b/drivers/md/dm-exception-store.c
index 88f119a0a2ae..91d541c66709 100644
--- a/drivers/md/dm-exception-store.c
+++ b/drivers/md/dm-exception-store.c
@@ -204,7 +204,7 @@ int dm_exception_store_create(struct dm_target *ti, int argc, char **argv,
 		return -EINVAL;
 	}
 
-	tmp_store = kzalloc(sizeof(*tmp_store), GFP_KERNEL);
+	tmp_store = kzalloc_obj(*tmp_store, GFP_KERNEL);
 	if (!tmp_store) {
 		ti->error = "Exception store allocation failed";
 		return -ENOMEM;
diff --git a/drivers/md/dm-flakey.c b/drivers/md/dm-flakey.c
index 08925aca838c..922e75bfcf17 100644
--- a/drivers/md/dm-flakey.c
+++ b/drivers/md/dm-flakey.c
@@ -277,7 +277,7 @@ static int flakey_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 		return -EINVAL;
 	}
 
-	fc = kzalloc(sizeof(*fc), GFP_KERNEL);
+	fc = kzalloc_obj(*fc, GFP_KERNEL);
 	if (!fc) {
 		ti->error = "Cannot allocate context";
 		return -ENOMEM;
diff --git a/drivers/md/dm-init.c b/drivers/md/dm-init.c
index b37bbe762500..703250739a8a 100644
--- a/drivers/md/dm-init.c
+++ b/drivers/md/dm-init.c
@@ -127,7 +127,7 @@ static char __init *dm_parse_table_entry(struct dm_device *dev, char *str)
 	/* Delimit last field that can be terminated by comma */
 	next = str_field_delimit(&field[i], ',');
 
-	sp = kzalloc(sizeof(*sp), GFP_KERNEL);
+	sp = kzalloc_obj(*sp, GFP_KERNEL);
 	if (!sp)
 		return ERR_PTR(-ENOMEM);
 	dev->table[n] = sp;
@@ -244,7 +244,7 @@ static int __init dm_parse_devices(struct list_head *devices, char *str)
 
 	DMDEBUG("parsing \"%s\"", str);
 	while (device) {
-		dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+		dev = kzalloc_obj(*dev, GFP_KERNEL);
 		if (!dev)
 			return -ENOMEM;
 		list_add_tail(&dev->list, devices);
diff --git a/drivers/md/dm-integrity.c b/drivers/md/dm-integrity.c
index 681b00958d42..3da3ce600758 100644
--- a/drivers/md/dm-integrity.c
+++ b/drivers/md/dm-integrity.c
@@ -4243,7 +4243,8 @@ static struct page_list *dm_integrity_alloc_page_list(unsigned int n_pages)
 	struct page_list *pl;
 	unsigned int i;
 
-	pl = kvmalloc_array(n_pages + 1, sizeof(struct page_list), GFP_KERNEL | __GFP_ZERO);
+	pl = kvmalloc_objs(struct page_list, n_pages + 1,
+			   GFP_KERNEL | __GFP_ZERO);
 	if (!pl)
 		return NULL;
 
@@ -4277,9 +4278,8 @@ static struct scatterlist **dm_integrity_alloc_journal_scatterlist(struct dm_int
 	struct scatterlist **sl;
 	unsigned int i;
 
-	sl = kvmalloc_array(ic->journal_sections,
-			    sizeof(struct scatterlist *),
-			    GFP_KERNEL | __GFP_ZERO);
+	sl = kvmalloc_objs(struct scatterlist *, ic->journal_sections,
+			   GFP_KERNEL | __GFP_ZERO);
 	if (!sl)
 		return NULL;
 
@@ -4296,8 +4296,7 @@ static struct scatterlist **dm_integrity_alloc_journal_scatterlist(struct dm_int
 
 		n_pages = (end_index - start_index + 1);
 
-		s = kvmalloc_array(n_pages, sizeof(struct scatterlist),
-				   GFP_KERNEL);
+		s = kvmalloc_objs(struct scatterlist, n_pages, GFP_KERNEL);
 		if (!s) {
 			dm_integrity_free_journal_scatterlist(ic, sl);
 			return NULL;
@@ -4500,9 +4499,8 @@ static int create_journal(struct dm_integrity_c *ic, char **error)
 				goto bad;
 			}
 
-			sg = kvmalloc_array(ic->journal_pages + 1,
-					    sizeof(struct scatterlist),
-					    GFP_KERNEL);
+			sg = kvmalloc_objs(struct scatterlist,
+					   ic->journal_pages + 1, GFP_KERNEL);
 			if (!sg) {
 				*error = "Unable to allocate sg list";
 				r = -ENOMEM;
@@ -4569,9 +4567,9 @@ static int create_journal(struct dm_integrity_c *ic, char **error)
 				r = -ENOMEM;
 				goto bad;
 			}
-			ic->sk_requests = kvmalloc_array(ic->journal_sections,
-							 sizeof(struct skcipher_request *),
-							 GFP_KERNEL | __GFP_ZERO);
+			ic->sk_requests = kvmalloc_objs(struct skcipher_request *,
+							ic->journal_sections,
+							GFP_KERNEL | __GFP_ZERO);
 			if (!ic->sk_requests) {
 				*error = "Unable to allocate sk requests";
 				r = -ENOMEM;
@@ -4703,7 +4701,7 @@ static int dm_integrity_ctr(struct dm_target *ti, unsigned int argc, char **argv
 		return -EINVAL;
 	}
 
-	ic = kzalloc(sizeof(struct dm_integrity_c), GFP_KERNEL);
+	ic = kzalloc_obj(struct dm_integrity_c, GFP_KERNEL);
 	if (!ic) {
 		ti->error = "Cannot allocate integrity context";
 		return -ENOMEM;
@@ -5272,7 +5270,8 @@ try_smaller_buffer:
 			r = -ENOMEM;
 			goto bad;
 		}
-		ic->bbs = kvmalloc_array(ic->n_bitmap_blocks, sizeof(struct bitmap_block_status), GFP_KERNEL);
+		ic->bbs = kvmalloc_objs(struct bitmap_block_status,
+					ic->n_bitmap_blocks, GFP_KERNEL);
 		if (!ic->bbs) {
 			ti->error = "Could not allocate memory for bitmap";
 			r = -ENOMEM;
diff --git a/drivers/md/dm-io.c b/drivers/md/dm-io.c
index c37668790577..d08399b40dac 100644
--- a/drivers/md/dm-io.c
+++ b/drivers/md/dm-io.c
@@ -52,7 +52,7 @@ struct dm_io_client *dm_io_client_create(void)
 	unsigned int min_ios = dm_get_reserved_bio_based_ios();
 	int ret;
 
-	client = kzalloc(sizeof(*client), GFP_KERNEL);
+	client = kzalloc_obj(*client, GFP_KERNEL);
 	if (!client)
 		return ERR_PTR(-ENOMEM);
 
diff --git a/drivers/md/dm-ioctl.c b/drivers/md/dm-ioctl.c
index fd4bf8e1d73e..7ab970430acd 100644
--- a/drivers/md/dm-ioctl.c
+++ b/drivers/md/dm-ioctl.c
@@ -218,7 +218,7 @@ static struct hash_cell *alloc_cell(const char *name, const char *uuid,
 {
 	struct hash_cell *hc;
 
-	hc = kmalloc(sizeof(*hc), GFP_KERNEL);
+	hc = kmalloc_obj(*hc, GFP_KERNEL);
 	if (!hc)
 		return NULL;
 
@@ -2136,7 +2136,7 @@ static int dm_open(struct inode *inode, struct file *filp)
 	if (unlikely(r))
 		return r;
 
-	priv = filp->private_data = kmalloc(sizeof(struct dm_file), GFP_KERNEL);
+	priv = filp->private_data = kmalloc_obj(struct dm_file, GFP_KERNEL);
 	if (!priv)
 		return -ENOMEM;
 
diff --git a/drivers/md/dm-kcopyd.c b/drivers/md/dm-kcopyd.c
index cec9a60227b6..03b81b39c65c 100644
--- a/drivers/md/dm-kcopyd.c
+++ b/drivers/md/dm-kcopyd.c
@@ -219,7 +219,7 @@ static struct page_list *alloc_pl(gfp_t gfp)
 {
 	struct page_list *pl;
 
-	pl = kmalloc(sizeof(*pl), gfp);
+	pl = kmalloc_obj(*pl, gfp);
 	if (!pl)
 		return NULL;
 
@@ -918,7 +918,7 @@ struct dm_kcopyd_client *dm_kcopyd_client_create(struct dm_kcopyd_throttle *thro
 	unsigned int reserve_pages;
 	struct dm_kcopyd_client *kc;
 
-	kc = kzalloc(sizeof(*kc), GFP_KERNEL);
+	kc = kzalloc_obj(*kc, GFP_KERNEL);
 	if (!kc)
 		return ERR_PTR(-ENOMEM);
 
diff --git a/drivers/md/dm-linear.c b/drivers/md/dm-linear.c
index 73bf290af181..3123227a6e1d 100644
--- a/drivers/md/dm-linear.c
+++ b/drivers/md/dm-linear.c
@@ -39,7 +39,7 @@ static int linear_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 		return -EINVAL;
 	}
 
-	lc = kmalloc(sizeof(*lc), GFP_KERNEL);
+	lc = kmalloc_obj(*lc, GFP_KERNEL);
 	if (lc == NULL) {
 		ti->error = "Cannot allocate linear context";
 		return -ENOMEM;
diff --git a/drivers/md/dm-log-userspace-base.c b/drivers/md/dm-log-userspace-base.c
index 607436804a8b..d1bc7d0c89d9 100644
--- a/drivers/md/dm-log-userspace-base.c
+++ b/drivers/md/dm-log-userspace-base.c
@@ -205,7 +205,7 @@ static int userspace_ctr(struct dm_dirty_log *log, struct dm_target *ti,
 		return -EINVAL;
 	}
 
-	lc = kzalloc(sizeof(*lc), GFP_KERNEL);
+	lc = kzalloc_obj(*lc, GFP_KERNEL);
 	if (!lc) {
 		DMWARN("Unable to allocate userspace log context.");
 		return -ENOMEM;
diff --git a/drivers/md/dm-log-writes.c b/drivers/md/dm-log-writes.c
index f0c84e7a5daa..a1040e8049aa 100644
--- a/drivers/md/dm-log-writes.c
+++ b/drivers/md/dm-log-writes.c
@@ -519,7 +519,7 @@ static int log_writes_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 		return -EINVAL;
 	}
 
-	lc = kzalloc(sizeof(struct log_writes_c), GFP_KERNEL);
+	lc = kzalloc_obj(struct log_writes_c, GFP_KERNEL);
 	if (!lc) {
 		ti->error = "Cannot allocate context";
 		return -ENOMEM;
@@ -587,7 +587,7 @@ static int log_mark(struct log_writes_c *lc, char *data)
 	struct pending_block *block;
 	size_t maxsize = lc->sectorsize - sizeof(struct log_write_entry);
 
-	block = kzalloc(sizeof(struct pending_block), GFP_KERNEL);
+	block = kzalloc_obj(struct pending_block, GFP_KERNEL);
 	if (!block) {
 		DMERR("Error allocating pending block");
 		return -ENOMEM;
diff --git a/drivers/md/dm-log.c b/drivers/md/dm-log.c
index bced5a783ee3..7865002678f5 100644
--- a/drivers/md/dm-log.c
+++ b/drivers/md/dm-log.c
@@ -153,7 +153,7 @@ struct dm_dirty_log *dm_dirty_log_create(const char *type_name,
 	struct dm_dirty_log_type *type;
 	struct dm_dirty_log *log;
 
-	log = kmalloc(sizeof(*log), GFP_KERNEL);
+	log = kmalloc_obj(*log, GFP_KERNEL);
 	if (!log)
 		return NULL;
 
@@ -402,7 +402,7 @@ static int create_log_context(struct dm_dirty_log *log, struct dm_target *ti,
 
 	region_count = dm_sector_div_up(ti->len, region_size);
 
-	lc = kmalloc(sizeof(*lc), GFP_KERNEL);
+	lc = kmalloc_obj(*lc, GFP_KERNEL);
 	if (!lc) {
 		DMWARN("couldn't allocate core log");
 		return -ENOMEM;
diff --git a/drivers/md/dm-mpath.c b/drivers/md/dm-mpath.c
index de03f9b06584..e47cfdf4f5d1 100644
--- a/drivers/md/dm-mpath.c
+++ b/drivers/md/dm-mpath.c
@@ -160,7 +160,7 @@ static bool mpath_double_check_test_bit(int MPATHF_bit, struct multipath *m)
  */
 static struct pgpath *alloc_pgpath(void)
 {
-	struct pgpath *pgpath = kzalloc(sizeof(*pgpath), GFP_KERNEL);
+	struct pgpath *pgpath = kzalloc_obj(*pgpath, GFP_KERNEL);
 
 	if (!pgpath)
 		return NULL;
@@ -179,7 +179,7 @@ static struct priority_group *alloc_priority_group(void)
 {
 	struct priority_group *pg;
 
-	pg = kzalloc(sizeof(*pg), GFP_KERNEL);
+	pg = kzalloc_obj(*pg, GFP_KERNEL);
 
 	if (pg)
 		INIT_LIST_HEAD(&pg->pgpaths);
@@ -216,7 +216,7 @@ static struct multipath *alloc_multipath(struct dm_target *ti)
 {
 	struct multipath *m;
 
-	m = kzalloc(sizeof(*m), GFP_KERNEL);
+	m = kzalloc_obj(*m, GFP_KERNEL);
 	if (m) {
 		INIT_LIST_HEAD(&m->priority_groups);
 		spin_lock_init(&m->lock);
diff --git a/drivers/md/dm-path-selector.c b/drivers/md/dm-path-selector.c
index 2b0ac200f1c0..28dc759e957a 100644
--- a/drivers/md/dm-path-selector.c
+++ b/drivers/md/dm-path-selector.c
@@ -87,7 +87,7 @@ out:
 
 static struct ps_internal *_alloc_path_selector(struct path_selector_type *pst)
 {
-	struct ps_internal *psi = kzalloc(sizeof(*psi), GFP_KERNEL);
+	struct ps_internal *psi = kzalloc_obj(*psi, GFP_KERNEL);
 
 	if (psi)
 		psi->pst = *pst;
diff --git a/drivers/md/dm-pcache/cache.c b/drivers/md/dm-pcache/cache.c
index 534bf07b794f..a616255b83e2 100644
--- a/drivers/md/dm-pcache/cache.c
+++ b/drivers/md/dm-pcache/cache.c
@@ -138,7 +138,8 @@ static int cache_init(struct dm_pcache *pcache)
 	struct pcache_cache_dev *cache_dev = &pcache->cache_dev;
 	int ret;
 
-	cache->segments = kvcalloc(cache_dev->seg_num, sizeof(struct pcache_cache_segment), GFP_KERNEL);
+	cache->segments = kvzalloc_objs(struct pcache_cache_segment,
+					cache_dev->seg_num, GFP_KERNEL);
 	if (!cache->segments) {
 		ret = -ENOMEM;
 		goto err;
diff --git a/drivers/md/dm-pcache/cache_key.c b/drivers/md/dm-pcache/cache_key.c
index 2b77e121f89b..3de356abf952 100644
--- a/drivers/md/dm-pcache/cache_key.c
+++ b/drivers/md/dm-pcache/cache_key.c
@@ -837,7 +837,8 @@ int cache_tree_init(struct pcache_cache *cache, struct pcache_cache_tree *cache_
 	 * Each element is a cache tree structure that contains
 	 * an RB tree root and a spinlock for protecting its contents.
 	 */
-	cache_tree->subtrees = kvcalloc(cache_tree->n_subtrees, sizeof(struct pcache_cache_subtree), GFP_KERNEL);
+	cache_tree->subtrees = kvzalloc_objs(struct pcache_cache_subtree,
+					     cache_tree->n_subtrees, GFP_KERNEL);
 	if (!cache_tree->subtrees) {
 		ret = -ENOMEM;
 		goto key_pool_exit;
diff --git a/drivers/md/dm-pcache/dm_pcache.c b/drivers/md/dm-pcache/dm_pcache.c
index e5f5936fa6f0..c36f2afdadc1 100644
--- a/drivers/md/dm-pcache/dm_pcache.c
+++ b/drivers/md/dm-pcache/dm_pcache.c
@@ -281,7 +281,7 @@ static int dm_pcache_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 	}
 
 	/* Allocate memory for the cache structure */
-	pcache = kzalloc(sizeof(struct dm_pcache), GFP_KERNEL);
+	pcache = kzalloc_obj(struct dm_pcache, GFP_KERNEL);
 	if (!pcache)
 		return -ENOMEM;
 
diff --git a/drivers/md/dm-ps-historical-service-time.c b/drivers/md/dm-ps-historical-service-time.c
index f07e773d9cc0..a526b5ab0453 100644
--- a/drivers/md/dm-ps-historical-service-time.c
+++ b/drivers/md/dm-ps-historical-service-time.c
@@ -129,7 +129,7 @@ static u64 fixed_ema(u64 last, u64 next, u64 weight)
 
 static struct selector *alloc_selector(void)
 {
-	struct selector *s = kmalloc(sizeof(*s), GFP_KERNEL);
+	struct selector *s = kmalloc_obj(*s, GFP_KERNEL);
 
 	if (s) {
 		INIT_LIST_HEAD(&s->valid_paths);
@@ -289,7 +289,7 @@ static int hst_add_path(struct path_selector *ps, struct dm_path *path,
 	}
 
 	/* allocate the path */
-	pi = kmalloc(sizeof(*pi), GFP_KERNEL);
+	pi = kmalloc_obj(*pi, GFP_KERNEL);
 	if (!pi) {
 		*error = "historical-service-time ps: Error allocating path context";
 		return -ENOMEM;
diff --git a/drivers/md/dm-ps-io-affinity.c b/drivers/md/dm-ps-io-affinity.c
index 80415a045c68..5d69a4a93684 100644
--- a/drivers/md/dm-ps-io-affinity.c
+++ b/drivers/md/dm-ps-io-affinity.c
@@ -53,7 +53,7 @@ static int ioa_add_path(struct path_selector *ps, struct dm_path *path,
 		return -EINVAL;
 	}
 
-	pi = kzalloc(sizeof(*pi), GFP_KERNEL);
+	pi = kzalloc_obj(*pi, GFP_KERNEL);
 	if (!pi) {
 		*error = "io-affinity ps: Error allocating path context";
 		return -ENOMEM;
@@ -112,12 +112,11 @@ static int ioa_create(struct path_selector *ps, unsigned int argc, char **argv)
 {
 	struct selector *s;
 
-	s = kmalloc(sizeof(*s), GFP_KERNEL);
+	s = kmalloc_obj(*s, GFP_KERNEL);
 	if (!s)
 		return -ENOMEM;
 
-	s->path_map = kcalloc(nr_cpu_ids, sizeof(struct path_info *),
-			      GFP_KERNEL);
+	s->path_map = kzalloc_objs(struct path_info *, nr_cpu_ids, GFP_KERNEL);
 	if (!s->path_map)
 		goto free_selector;
 
diff --git a/drivers/md/dm-ps-queue-length.c b/drivers/md/dm-ps-queue-length.c
index 9c68701ed7a4..d2663b1b136c 100644
--- a/drivers/md/dm-ps-queue-length.c
+++ b/drivers/md/dm-ps-queue-length.c
@@ -42,7 +42,7 @@ struct path_info {
 
 static struct selector *alloc_selector(void)
 {
-	struct selector *s = kmalloc(sizeof(*s), GFP_KERNEL);
+	struct selector *s = kmalloc_obj(*s, GFP_KERNEL);
 
 	if (s) {
 		INIT_LIST_HEAD(&s->valid_paths);
@@ -142,7 +142,7 @@ static int ql_add_path(struct path_selector *ps, struct dm_path *path,
 	}
 
 	/* Allocate the path information structure */
-	pi = kmalloc(sizeof(*pi), GFP_KERNEL);
+	pi = kmalloc_obj(*pi, GFP_KERNEL);
 	if (!pi) {
 		*error = "queue-length ps: Error allocating path information";
 		return -ENOMEM;
diff --git a/drivers/md/dm-ps-round-robin.c b/drivers/md/dm-ps-round-robin.c
index 0c12f4073461..ec8b9f27d3e7 100644
--- a/drivers/md/dm-ps-round-robin.c
+++ b/drivers/md/dm-ps-round-robin.c
@@ -55,7 +55,7 @@ struct selector {
 
 static struct selector *alloc_selector(void)
 {
-	struct selector *s = kmalloc(sizeof(*s), GFP_KERNEL);
+	struct selector *s = kmalloc_obj(*s, GFP_KERNEL);
 
 	if (s) {
 		INIT_LIST_HEAD(&s->valid_paths);
@@ -144,7 +144,7 @@ static int rr_add_path(struct path_selector *ps, struct dm_path *path,
 	}
 
 	/* allocate the path */
-	pi = kmalloc(sizeof(*pi), GFP_KERNEL);
+	pi = kmalloc_obj(*pi, GFP_KERNEL);
 	if (!pi) {
 		*error = "round-robin ps: Error allocating path context";
 		return -ENOMEM;
diff --git a/drivers/md/dm-ps-service-time.c b/drivers/md/dm-ps-service-time.c
index 0543fe7969c4..dc119955fadd 100644
--- a/drivers/md/dm-ps-service-time.c
+++ b/drivers/md/dm-ps-service-time.c
@@ -38,7 +38,7 @@ struct path_info {
 
 static struct selector *alloc_selector(void)
 {
-	struct selector *s = kmalloc(sizeof(*s), GFP_KERNEL);
+	struct selector *s = kmalloc_obj(*s, GFP_KERNEL);
 
 	if (s) {
 		INIT_LIST_HEAD(&s->valid_paths);
@@ -153,7 +153,7 @@ static int st_add_path(struct path_selector *ps, struct dm_path *path,
 	}
 
 	/* allocate the path */
-	pi = kmalloc(sizeof(*pi), GFP_KERNEL);
+	pi = kmalloc_obj(*pi, GFP_KERNEL);
 	if (!pi) {
 		*error = "service-time ps: Error allocating path context";
 		return -ENOMEM;
diff --git a/drivers/md/dm-raid.c b/drivers/md/dm-raid.c
index 4bacdc499984..939d403fda30 100644
--- a/drivers/md/dm-raid.c
+++ b/drivers/md/dm-raid.c
@@ -744,7 +744,7 @@ static struct raid_set *raid_set_alloc(struct dm_target *ti, struct raid_type *r
 		return ERR_PTR(-EINVAL);
 	}
 
-	rs = kzalloc(struct_size(rs, dev, raid_devs), GFP_KERNEL);
+	rs = kzalloc_flex(*rs, dev, raid_devs, GFP_KERNEL);
 	if (!rs) {
 		ti->error = "Cannot allocate raid context";
 		return ERR_PTR(-ENOMEM);
diff --git a/drivers/md/dm-raid1.c b/drivers/md/dm-raid1.c
index 943c0c6b2087..9fb2182ef287 100644
--- a/drivers/md/dm-raid1.c
+++ b/drivers/md/dm-raid1.c
@@ -890,7 +890,7 @@ static struct mirror_set *alloc_context(unsigned int nr_mirrors,
 					struct dm_dirty_log *dl)
 {
 	struct mirror_set *ms =
-		kzalloc(struct_size(ms, mirror, nr_mirrors), GFP_KERNEL);
+		kzalloc_flex(*ms, mirror, nr_mirrors, GFP_KERNEL);
 
 	if (!ms) {
 		ti->error = "Cannot allocate mirror context";
diff --git a/drivers/md/dm-region-hash.c b/drivers/md/dm-region-hash.c
index e9b47b659976..a3489965103c 100644
--- a/drivers/md/dm-region-hash.c
+++ b/drivers/md/dm-region-hash.c
@@ -184,7 +184,7 @@ struct dm_region_hash *dm_region_hash_create(
 		;
 	nr_buckets >>= 1;
 
-	rh = kzalloc(sizeof(*rh), GFP_KERNEL);
+	rh = kzalloc_obj(*rh, GFP_KERNEL);
 	if (!rh) {
 		DMERR("unable to allocate region hash memory");
 		return ERR_PTR(-ENOMEM);
@@ -294,7 +294,7 @@ static struct dm_region *__rh_alloc(struct dm_region_hash *rh, region_t region)
 
 	nreg = mempool_alloc(&rh->region_pool, GFP_ATOMIC);
 	if (unlikely(!nreg))
-		nreg = kmalloc(sizeof(*nreg), GFP_NOIO | __GFP_NOFAIL);
+		nreg = kmalloc_obj(*nreg, GFP_NOIO | __GFP_NOFAIL);
 
 	nreg->state = rh->log->type->in_sync(rh->log, region, 1) ?
 		      DM_RH_CLEAN : DM_RH_NOSYNC;
diff --git a/drivers/md/dm-snap-persistent.c b/drivers/md/dm-snap-persistent.c
index 0e13d60bfdd1..c8128af1dcad 100644
--- a/drivers/md/dm-snap-persistent.c
+++ b/drivers/md/dm-snap-persistent.c
@@ -626,8 +626,8 @@ static int persistent_read_metadata(struct dm_exception_store *store,
 	 */
 	ps->exceptions_per_area = (ps->store->chunk_size << SECTOR_SHIFT) /
 				  sizeof(struct disk_exception);
-	ps->callbacks = kvcalloc(ps->exceptions_per_area,
-				 sizeof(*ps->callbacks), GFP_KERNEL);
+	ps->callbacks = kvzalloc_objs(*ps->callbacks, ps->exceptions_per_area,
+				      GFP_KERNEL);
 	if (!ps->callbacks)
 		return -ENOMEM;
 
@@ -854,7 +854,7 @@ static int persistent_ctr(struct dm_exception_store *store, char *options)
 	int r;
 
 	/* allocate the pstore */
-	ps = kzalloc(sizeof(*ps), GFP_KERNEL);
+	ps = kzalloc_obj(*ps, GFP_KERNEL);
 	if (!ps)
 		return -ENOMEM;
 
diff --git a/drivers/md/dm-snap-transient.c b/drivers/md/dm-snap-transient.c
index 1e07a745bedd..b7b449db6c34 100644
--- a/drivers/md/dm-snap-transient.c
+++ b/drivers/md/dm-snap-transient.c
@@ -77,7 +77,7 @@ static int transient_ctr(struct dm_exception_store *store, char *options)
 {
 	struct transient_c *tc;
 
-	tc = kmalloc(sizeof(struct transient_c), GFP_KERNEL);
+	tc = kmalloc_obj(struct transient_c, GFP_KERNEL);
 	if (!tc)
 		return -ENOMEM;
 
diff --git a/drivers/md/dm-snap.c b/drivers/md/dm-snap.c
index dbd148967de4..5a77ccd33232 100644
--- a/drivers/md/dm-snap.c
+++ b/drivers/md/dm-snap.c
@@ -354,8 +354,7 @@ static int init_origin_hash(void)
 {
 	int i;
 
-	_origins = kmalloc_array(ORIGIN_HASH_SIZE, sizeof(struct list_head),
-				 GFP_KERNEL);
+	_origins = kmalloc_objs(struct list_head, ORIGIN_HASH_SIZE, GFP_KERNEL);
 	if (!_origins) {
 		DMERR("unable to allocate memory for _origins");
 		return -ENOMEM;
@@ -363,9 +362,8 @@ static int init_origin_hash(void)
 	for (i = 0; i < ORIGIN_HASH_SIZE; i++)
 		INIT_LIST_HEAD(_origins + i);
 
-	_dm_origins = kmalloc_array(ORIGIN_HASH_SIZE,
-				    sizeof(struct list_head),
-				    GFP_KERNEL);
+	_dm_origins = kmalloc_objs(struct list_head, ORIGIN_HASH_SIZE,
+				   GFP_KERNEL);
 	if (!_dm_origins) {
 		DMERR("unable to allocate memory for _dm_origins");
 		kfree(_origins);
@@ -559,7 +557,7 @@ static int register_snapshot(struct dm_snapshot *snap)
 	struct block_device *bdev = snap->origin->bdev;
 	int r = 0;
 
-	new_o = kmalloc(sizeof(*new_o), GFP_KERNEL);
+	new_o = kmalloc_obj(*new_o, GFP_KERNEL);
 	if (!new_o)
 		return -ENOMEM;
 
@@ -666,8 +664,7 @@ static int dm_exception_table_init(struct dm_exception_table *et,
 
 	et->hash_shift = hash_shift;
 	et->hash_mask = size - 1;
-	et->table = kvmalloc_array(size, sizeof(struct dm_hlist_head),
-				   GFP_KERNEL);
+	et->table = kvmalloc_objs(struct dm_hlist_head, size, GFP_KERNEL);
 	if (!et->table)
 		return -ENOMEM;
 
@@ -1252,7 +1249,7 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 		origin_mode = BLK_OPEN_WRITE;
 	}
 
-	s = kzalloc(sizeof(*s), GFP_KERNEL);
+	s = kzalloc_obj(*s, GFP_KERNEL);
 	if (!s) {
 		ti->error = "Cannot allocate private snapshot structure";
 		r = -ENOMEM;
@@ -2626,7 +2623,7 @@ static int origin_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 		return -EINVAL;
 	}
 
-	o = kmalloc(sizeof(struct dm_origin), GFP_KERNEL);
+	o = kmalloc_obj(struct dm_origin, GFP_KERNEL);
 	if (!o) {
 		ti->error = "Cannot allocate private origin structure";
 		r = -ENOMEM;
diff --git a/drivers/md/dm-stats.c b/drivers/md/dm-stats.c
index 1e5d988f44da..b26656dea4ec 100644
--- a/drivers/md/dm-stats.c
+++ b/drivers/md/dm-stats.c
@@ -971,9 +971,8 @@ static int parse_histogram(const char *h, unsigned int *n_histogram_entries,
 		if (*q == ',')
 			(*n_histogram_entries)++;
 
-	*histogram_boundaries = kmalloc_array(*n_histogram_entries,
-					      sizeof(unsigned long long),
-					      GFP_KERNEL);
+	*histogram_boundaries = kmalloc_objs(unsigned long long,
+					     *n_histogram_entries, GFP_KERNEL);
 	if (!*histogram_boundaries)
 		return -ENOMEM;
 
diff --git a/drivers/md/dm-stripe.c b/drivers/md/dm-stripe.c
index 20cce876d80c..e06bb1f7518e 100644
--- a/drivers/md/dm-stripe.c
+++ b/drivers/md/dm-stripe.c
@@ -129,7 +129,7 @@ static int stripe_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 		return -EINVAL;
 	}
 
-	sc = kmalloc(struct_size(sc, stripe, stripes), GFP_KERNEL);
+	sc = kmalloc_flex(*sc, stripe, stripes, GFP_KERNEL);
 	if (!sc) {
 		ti->error = "Memory allocation for striped context failed";
 		return -ENOMEM;
diff --git a/drivers/md/dm-switch.c b/drivers/md/dm-switch.c
index 50a52ca50b34..00dffd4a9ea8 100644
--- a/drivers/md/dm-switch.c
+++ b/drivers/md/dm-switch.c
@@ -62,7 +62,7 @@ static struct switch_ctx *alloc_switch_ctx(struct dm_target *ti, unsigned int nr
 {
 	struct switch_ctx *sctx;
 
-	sctx = kzalloc(struct_size(sctx, path_list, nr_paths), GFP_KERNEL);
+	sctx = kzalloc_flex(*sctx, path_list, nr_paths, GFP_KERNEL);
 	if (!sctx)
 		return NULL;
 
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 7be1d8dc8bdd..4b4712e54797 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -133,7 +133,7 @@ int dm_table_create(struct dm_table **result, blk_mode_t mode,
 	if (num_targets > DM_MAX_TARGETS)
 		return -EOVERFLOW;
 
-	t = kzalloc(sizeof(*t), GFP_KERNEL);
+	t = kzalloc_obj(*t, GFP_KERNEL);
 
 	if (!t)
 		return -ENOMEM;
@@ -381,7 +381,7 @@ int dm_get_device(struct dm_target *ti, const char *path, blk_mode_t mode,
 
 	dd = find_device(&t->devices, dev);
 	if (!dd) {
-		dd = kmalloc(sizeof(*dd), GFP_KERNEL);
+		dd = kmalloc_obj(*dd, GFP_KERNEL);
 		if (!dd)
 			return -ENOMEM;
 
@@ -1391,7 +1391,7 @@ static int dm_table_construct_crypto_profile(struct dm_table *t)
 	unsigned int i;
 	bool empty_profile = true;
 
-	dmcp = kmalloc(sizeof(*dmcp), GFP_KERNEL);
+	dmcp = kmalloc_obj(*dmcp, GFP_KERNEL);
 	if (!dmcp)
 		return -ENOMEM;
 	dmcp->md = t->md;
diff --git a/drivers/md/dm-target.c b/drivers/md/dm-target.c
index 1fd41289de36..a138e8a24327 100644
--- a/drivers/md/dm-target.c
+++ b/drivers/md/dm-target.c
@@ -128,7 +128,7 @@ static int io_err_get_args(struct dm_target *tt, unsigned int argc, char **args)
 	char dummy;
 	int ret;
 
-	ioec = kmalloc(sizeof(*ioec), GFP_KERNEL);
+	ioec = kmalloc_obj(*ioec, GFP_KERNEL);
 	if (!ioec) {
 		tt->error = "Cannot allocate io_err context";
 		return -ENOMEM;
diff --git a/drivers/md/dm-thin-metadata.c b/drivers/md/dm-thin-metadata.c
index f90679cfec5b..c924ec4d300d 100644
--- a/drivers/md/dm-thin-metadata.c
+++ b/drivers/md/dm-thin-metadata.c
@@ -957,7 +957,7 @@ struct dm_pool_metadata *dm_pool_metadata_open(struct block_device *bdev,
 	int r;
 	struct dm_pool_metadata *pmd;
 
-	pmd = kmalloc(sizeof(*pmd), GFP_KERNEL);
+	pmd = kmalloc_obj(*pmd, GFP_KERNEL);
 	if (!pmd) {
 		DMERR("could not allocate metadata struct");
 		return ERR_PTR(-ENOMEM);
@@ -1077,7 +1077,7 @@ static int __open_device(struct dm_pool_metadata *pmd,
 		details_le.snapshotted_time = cpu_to_le32(pmd->time);
 	}
 
-	*td = kmalloc(sizeof(**td), GFP_NOIO);
+	*td = kmalloc_obj(**td, GFP_NOIO);
 	if (!*td)
 		return -ENOMEM;
 
diff --git a/drivers/md/dm-thin.c b/drivers/md/dm-thin.c
index 52ffb495f5a8..492ead2d9356 100644
--- a/drivers/md/dm-thin.c
+++ b/drivers/md/dm-thin.c
@@ -2949,7 +2949,7 @@ static struct pool *pool_create(struct mapped_device *pool_md,
 		return ERR_CAST(pmd);
 	}
 
-	pool = kzalloc(sizeof(*pool), GFP_KERNEL);
+	pool = kzalloc_obj(*pool, GFP_KERNEL);
 	if (!pool) {
 		*error = "Error allocating memory for pool";
 		err_p = ERR_PTR(-ENOMEM);
@@ -3354,7 +3354,7 @@ static int pool_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 		goto out;
 	}
 
-	pt = kzalloc(sizeof(*pt), GFP_KERNEL);
+	pt = kzalloc_obj(*pt, GFP_KERNEL);
 	if (!pt) {
 		r = -ENOMEM;
 		goto out;
@@ -4193,7 +4193,7 @@ static int thin_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 		goto out_unlock;
 	}
 
-	tc = ti->private = kzalloc(sizeof(*tc), GFP_KERNEL);
+	tc = ti->private = kzalloc_obj(*tc, GFP_KERNEL);
 	if (!tc) {
 		ti->error = "Out of memory";
 		r = -ENOMEM;
diff --git a/drivers/md/dm-unstripe.c b/drivers/md/dm-unstripe.c
index 17be48359564..c595d0a138fc 100644
--- a/drivers/md/dm-unstripe.c
+++ b/drivers/md/dm-unstripe.c
@@ -48,7 +48,7 @@ static int unstripe_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 		return -EINVAL;
 	}
 
-	uc = kzalloc(sizeof(*uc), GFP_KERNEL);
+	uc = kzalloc_obj(*uc, GFP_KERNEL);
 	if (!uc) {
 		ti->error = "Memory allocation for unstriped context failed";
 		return -ENOMEM;
diff --git a/drivers/md/dm-verity-fec.c b/drivers/md/dm-verity-fec.c
index 7583607a8aa6..08bb75f00891 100644
--- a/drivers/md/dm-verity-fec.c
+++ b/drivers/md/dm-verity-fec.c
@@ -607,7 +607,7 @@ int verity_fec_ctr_alloc(struct dm_verity *v)
 {
 	struct dm_verity_fec *f;
 
-	f = kzalloc(sizeof(struct dm_verity_fec), GFP_KERNEL);
+	f = kzalloc_obj(struct dm_verity_fec, GFP_KERNEL);
 	if (!f) {
 		v->ti->error = "Cannot allocate FEC structure";
 		return -ENOMEM;
diff --git a/drivers/md/dm-verity-target.c b/drivers/md/dm-verity-target.c
index 8089cb74b75d..9dd0c195091f 100644
--- a/drivers/md/dm-verity-target.c
+++ b/drivers/md/dm-verity-target.c
@@ -764,8 +764,8 @@ static void verity_submit_prefetch(struct dm_verity *v, struct dm_verity_io *io,
 			return;
 	}
 
-	pw = kmalloc(sizeof(struct dm_verity_prefetch_work),
-		GFP_NOIO | __GFP_NORETRY | __GFP_NOMEMALLOC | __GFP_NOWARN);
+	pw = kmalloc_obj(struct dm_verity_prefetch_work,
+			 GFP_NOIO | __GFP_NORETRY | __GFP_NOMEMALLOC | __GFP_NOWARN);
 
 	if (!pw)
 		return;
@@ -1369,7 +1369,7 @@ static int verity_setup_salt_and_hashstate(struct dm_verity *v, const char *arg)
 	if (likely(v->use_sha256_lib)) {
 		/* Implies version 1: salt at beginning */
 		v->initial_hashstate.sha256 =
-			kmalloc(sizeof(struct sha256_ctx), GFP_KERNEL);
+			kmalloc_obj(struct sha256_ctx, GFP_KERNEL);
 		if (!v->initial_hashstate.sha256) {
 			ti->error = "Cannot allocate initial hash state";
 			return -ENOMEM;
@@ -1430,7 +1430,7 @@ static int verity_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 	char dummy;
 	char *root_hash_digest_to_validate;
 
-	v = kzalloc(sizeof(struct dm_verity), GFP_KERNEL);
+	v = kzalloc_obj(struct dm_verity, GFP_KERNEL);
 	if (!v) {
 		ti->error = "Cannot allocate verity structure";
 		return -ENOMEM;
diff --git a/drivers/md/dm-writecache.c b/drivers/md/dm-writecache.c
index af54e289bceb..bca442478a8d 100644
--- a/drivers/md/dm-writecache.c
+++ b/drivers/md/dm-writecache.c
@@ -1848,9 +1848,8 @@ static void __writecache_writeback_pmem(struct dm_writecache *wc, struct writeba
 		bio->bi_iter.bi_sector = read_original_sector(wc, e);
 
 		if (unlikely(max_pages > WB_LIST_INLINE))
-			wb->wc_list = kmalloc_array(max_pages, sizeof(struct wc_entry *),
-						    GFP_NOIO | __GFP_NORETRY |
-						    __GFP_NOMEMALLOC | __GFP_NOWARN);
+			wb->wc_list = kmalloc_objs(struct wc_entry *, max_pages,
+						   GFP_NOIO | __GFP_NORETRY | __GFP_NOMEMALLOC | __GFP_NOWARN);
 
 		if (likely(max_pages <= WB_LIST_INLINE) || unlikely(!wb->wc_list)) {
 			wb->wc_list = wb->wc_list_inline;
@@ -2246,7 +2245,7 @@ static int writecache_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 	as.argc = argc;
 	as.argv = argv;
 
-	wc = kzalloc(sizeof(struct dm_writecache), GFP_KERNEL);
+	wc = kzalloc_obj(struct dm_writecache, GFP_KERNEL);
 	if (!wc) {
 		ti->error = "Cannot allocate writecache structure";
 		r = -ENOMEM;
diff --git a/drivers/md/dm-zoned-metadata.c b/drivers/md/dm-zoned-metadata.c
index 83fcd7b31ed9..b9a473ffdb70 100644
--- a/drivers/md/dm-zoned-metadata.c
+++ b/drivers/md/dm-zoned-metadata.c
@@ -303,7 +303,7 @@ static struct dm_zone *dmz_get(struct dmz_metadata *zmd, unsigned int zone_id)
 static struct dm_zone *dmz_insert(struct dmz_metadata *zmd,
 				  unsigned int zone_id, struct dmz_dev *dev)
 {
-	struct dm_zone *zone = kzalloc(sizeof(struct dm_zone), GFP_KERNEL);
+	struct dm_zone *zone = kzalloc_obj(struct dm_zone, GFP_KERNEL);
 
 	if (!zone)
 		return ERR_PTR(-ENOMEM);
@@ -419,7 +419,7 @@ static struct dmz_mblock *dmz_alloc_mblock(struct dmz_metadata *zmd,
 	}
 
 	/* Allocate a new block */
-	mblk = kmalloc(sizeof(struct dmz_mblock), GFP_NOIO);
+	mblk = kmalloc_obj(struct dmz_mblock, GFP_NOIO);
 	if (!mblk)
 		return NULL;
 
@@ -1311,7 +1311,7 @@ static int dmz_load_sb(struct dmz_metadata *zmd)
 		int i;
 		struct dmz_sb *sb;
 
-		sb = kzalloc(sizeof(struct dmz_sb), GFP_KERNEL);
+		sb = kzalloc_obj(struct dmz_sb, GFP_KERNEL);
 		if (!sb)
 			return -ENOMEM;
 		for (i = 1; i < zmd->nr_devs; i++) {
@@ -1686,8 +1686,8 @@ static int dmz_load_mapping(struct dmz_metadata *zmd)
 	unsigned int bzone_id;
 
 	/* Metadata block array for the chunk mapping table */
-	zmd->map_mblk = kcalloc(zmd->nr_map_blocks,
-				sizeof(struct dmz_mblock *), GFP_KERNEL);
+	zmd->map_mblk = kzalloc_objs(struct dmz_mblock *, zmd->nr_map_blocks,
+				     GFP_KERNEL);
 	if (!zmd->map_mblk)
 		return -ENOMEM;
 
@@ -2868,7 +2868,7 @@ int dmz_ctr_metadata(struct dmz_dev *dev, int num_dev,
 	struct dm_zone *zone;
 	int ret;
 
-	zmd = kzalloc(sizeof(struct dmz_metadata), GFP_KERNEL);
+	zmd = kzalloc_obj(struct dmz_metadata, GFP_KERNEL);
 	if (!zmd)
 		return -ENOMEM;
 
diff --git a/drivers/md/dm-zoned-reclaim.c b/drivers/md/dm-zoned-reclaim.c
index 76e2c6868548..8598cc9eb40f 100644
--- a/drivers/md/dm-zoned-reclaim.c
+++ b/drivers/md/dm-zoned-reclaim.c
@@ -556,7 +556,7 @@ int dmz_ctr_reclaim(struct dmz_metadata *zmd,
 	struct dmz_reclaim *zrc;
 	int ret;
 
-	zrc = kzalloc(sizeof(struct dmz_reclaim), GFP_KERNEL);
+	zrc = kzalloc_obj(struct dmz_reclaim, GFP_KERNEL);
 	if (!zrc)
 		return -ENOMEM;
 
diff --git a/drivers/md/dm-zoned-target.c b/drivers/md/dm-zoned-target.c
index 9da329078ea4..0e6ddfb96e03 100644
--- a/drivers/md/dm-zoned-target.c
+++ b/drivers/md/dm-zoned-target.c
@@ -545,7 +545,7 @@ static int dmz_queue_chunk_work(struct dmz_target *dmz, struct bio *bio)
 		dmz_get_chunk_work(cw);
 	} else {
 		/* Create a new chunk work */
-		cw = kmalloc(sizeof(struct dm_chunk_work), GFP_NOIO);
+		cw = kmalloc_obj(struct dm_chunk_work, GFP_NOIO);
 		if (unlikely(!cw)) {
 			ret = -ENOMEM;
 			goto out;
@@ -838,18 +838,18 @@ static int dmz_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 	}
 
 	/* Allocate and initialize the target descriptor */
-	dmz = kzalloc(sizeof(struct dmz_target), GFP_KERNEL);
+	dmz = kzalloc_obj(struct dmz_target, GFP_KERNEL);
 	if (!dmz) {
 		ti->error = "Unable to allocate the zoned target descriptor";
 		return -ENOMEM;
 	}
-	dmz->dev = kcalloc(argc, sizeof(struct dmz_dev), GFP_KERNEL);
+	dmz->dev = kzalloc_objs(struct dmz_dev, argc, GFP_KERNEL);
 	if (!dmz->dev) {
 		ti->error = "Unable to allocate the zoned device descriptors";
 		kfree(dmz);
 		return -ENOMEM;
 	}
-	dmz->ddev = kcalloc(argc, sizeof(struct dm_dev *), GFP_KERNEL);
+	dmz->ddev = kzalloc_objs(struct dm_dev *, argc, GFP_KERNEL);
 	if (!dmz->ddev) {
 		ti->error = "Unable to allocate the dm device descriptors";
 		ret = -ENOMEM;
diff --git a/drivers/md/md-bitmap.c b/drivers/md/md-bitmap.c
index 1d4a050dab3a..ca833f147c6a 100644
--- a/drivers/md/md-bitmap.c
+++ b/drivers/md/md-bitmap.c
@@ -1025,8 +1025,7 @@ static int md_bitmap_storage_alloc(struct bitmap_storage *store,
 	num_pages = DIV_ROUND_UP(bytes, PAGE_SIZE);
 	offset = slot_number * num_pages;
 
-	store->filemap = kmalloc_array(num_pages, sizeof(struct page *),
-				       GFP_KERNEL);
+	store->filemap = kmalloc_objs(struct page *, num_pages, GFP_KERNEL);
 	if (!store->filemap)
 		return -ENOMEM;
 
@@ -2121,7 +2120,7 @@ static struct bitmap *__bitmap_create(struct mddev *mddev, int slot)
 		return ERR_PTR(-EBUSY);
 	}
 
-	bitmap = kzalloc(sizeof(*bitmap), GFP_KERNEL);
+	bitmap = kzalloc_obj(*bitmap, GFP_KERNEL);
 	if (!bitmap)
 		return ERR_PTR(-ENOMEM);
 
@@ -2436,7 +2435,7 @@ static int __bitmap_resize(struct bitmap *bitmap, sector_t blocks,
 
 	pages = DIV_ROUND_UP(chunks, PAGE_COUNTER_RATIO);
 
-	new_bp = kcalloc(pages, sizeof(*new_bp), GFP_KERNEL);
+	new_bp = kzalloc_objs(*new_bp, pages, GFP_KERNEL);
 	ret = -ENOMEM;
 	if (!new_bp) {
 		md_bitmap_file_unmap(&store);
diff --git a/drivers/md/md-cluster.c b/drivers/md/md-cluster.c
index 896279988dfd..c588c972ad54 100644
--- a/drivers/md/md-cluster.c
+++ b/drivers/md/md-cluster.c
@@ -196,7 +196,7 @@ static struct dlm_lock_resource *lockres_init(struct mddev *mddev,
 	int ret, namelen;
 	struct md_cluster_info *cinfo = mddev->cluster_info;
 
-	res = kzalloc(sizeof(struct dlm_lock_resource), GFP_KERNEL);
+	res = kzalloc_obj(struct dlm_lock_resource, GFP_KERNEL);
 	if (!res)
 		return NULL;
 	init_waitqueue_head(&res->sync_locking);
@@ -886,7 +886,7 @@ static int join(struct mddev *mddev, int nodes)
 	int ret, ops_rv;
 	char str[64];
 
-	cinfo = kzalloc(sizeof(struct md_cluster_info), GFP_KERNEL);
+	cinfo = kzalloc_obj(struct md_cluster_info, GFP_KERNEL);
 	if (!cinfo)
 		return -ENOMEM;
 
@@ -1543,8 +1543,8 @@ static int lock_all_bitmaps(struct mddev *mddev)
 	struct md_cluster_info *cinfo = mddev->cluster_info;
 
 	cinfo->other_bitmap_lockres =
-		kcalloc(mddev->bitmap_info.nodes - 1,
-			sizeof(struct dlm_lock_resource *), GFP_KERNEL);
+		kzalloc_objs(struct dlm_lock_resource *,
+			     mddev->bitmap_info.nodes - 1, GFP_KERNEL);
 	if (!cinfo->other_bitmap_lockres) {
 		pr_err("md: can't alloc mem for other bitmap locks\n");
 		return 0;
diff --git a/drivers/md/md-linear.c b/drivers/md/md-linear.c
index 8d7b82c4a723..beeb88274da4 100644
--- a/drivers/md/md-linear.c
+++ b/drivers/md/md-linear.c
@@ -92,7 +92,7 @@ static struct linear_conf *linear_conf(struct mddev *mddev, int raid_disks)
 	int cnt;
 	int i;
 
-	conf = kzalloc(struct_size(conf, disks, raid_disks), GFP_KERNEL);
+	conf = kzalloc_flex(*conf, disks, raid_disks, GFP_KERNEL);
 	if (!conf)
 		return ERR_PTR(-ENOMEM);
 
diff --git a/drivers/md/md-llbitmap.c b/drivers/md/md-llbitmap.c
index cd713a7dc270..e8d7af0c665a 100644
--- a/drivers/md/md-llbitmap.c
+++ b/drivers/md/md-llbitmap.c
@@ -982,7 +982,7 @@ static int llbitmap_create(struct mddev *mddev)
 	if (ret)
 		return ret;
 
-	llbitmap = kzalloc(sizeof(*llbitmap), GFP_KERNEL);
+	llbitmap = kzalloc_obj(*llbitmap, GFP_KERNEL);
 	if (!llbitmap)
 		return -ENOMEM;
 
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 72a1c7267851..b7ac2440fbbb 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -853,7 +853,7 @@ static struct mddev *mddev_alloc(dev_t unit)
 	if (unit && MAJOR(unit) != MD_MAJOR)
 		unit &= ~((1 << MdpMinorShift) - 1);
 
-	new = kzalloc(sizeof(*new), GFP_KERNEL);
+	new = kzalloc_obj(*new, GFP_KERNEL);
 	if (!new)
 		return ERR_PTR(-ENOMEM);
 
@@ -1222,8 +1222,8 @@ static int md_sb_equal(mdp_super_t *sb1, mdp_super_t *sb2)
 	int ret;
 	mdp_super_t *tmp1, *tmp2;
 
-	tmp1 = kmalloc(sizeof(*tmp1),GFP_KERNEL);
-	tmp2 = kmalloc(sizeof(*tmp2),GFP_KERNEL);
+	tmp1 = kmalloc_obj(*tmp1, GFP_KERNEL);
+	tmp2 = kmalloc_obj(*tmp2, GFP_KERNEL);
 
 	if (!tmp1 || !tmp2) {
 		ret = 0;
@@ -3817,7 +3817,7 @@ static struct md_rdev *md_import_device(dev_t newdev, int super_format, int supe
 	sector_t size;
 	int err;
 
-	rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
+	rdev = kzalloc_obj(*rdev, GFP_KERNEL);
 	if (!rdev)
 		return ERR_PTR(-ENOMEM);
 
@@ -7238,7 +7238,7 @@ static int get_bitmap_file(struct mddev *mddev, void __user * arg)
 	char *ptr;
 	int err;
 
-	file = kzalloc(sizeof(*file), GFP_NOIO);
+	file = kzalloc_obj(*file, GFP_NOIO);
 	if (!file)
 		return -ENOMEM;
 
@@ -8541,7 +8541,7 @@ struct md_thread *md_register_thread(void (*run) (struct md_thread *),
 {
 	struct md_thread *thread;
 
-	thread = kzalloc(sizeof(struct md_thread), GFP_KERNEL);
+	thread = kzalloc_obj(struct md_thread, GFP_KERNEL);
 	if (!thread)
 		return NULL;
 
@@ -10749,7 +10749,7 @@ void md_autodetect_dev(dev_t dev)
 {
 	struct detected_devices_node *node_detected_dev;
 
-	node_detected_dev = kzalloc(sizeof(*node_detected_dev), GFP_KERNEL);
+	node_detected_dev = kzalloc_obj(*node_detected_dev, GFP_KERNEL);
 	if (node_detected_dev) {
 		node_detected_dev->dev = dev;
 		mutex_lock(&detected_devices_mutex);
diff --git a/drivers/md/persistent-data/dm-block-manager.c b/drivers/md/persistent-data/dm-block-manager.c
index 1ef71e5fcde7..43bd64b77a7d 100644
--- a/drivers/md/persistent-data/dm-block-manager.c
+++ b/drivers/md/persistent-data/dm-block-manager.c
@@ -388,7 +388,7 @@ struct dm_block_manager *dm_block_manager_create(struct block_device *bdev,
 	int r;
 	struct dm_block_manager *bm;
 
-	bm = kmalloc(sizeof(*bm), GFP_KERNEL);
+	bm = kmalloc_obj(*bm, GFP_KERNEL);
 	if (!bm) {
 		r = -ENOMEM;
 		goto bad;
diff --git a/drivers/md/persistent-data/dm-btree.c b/drivers/md/persistent-data/dm-btree.c
index 0c7a2e8d1846..dd02eee4a23c 100644
--- a/drivers/md/persistent-data/dm-btree.c
+++ b/drivers/md/persistent-data/dm-btree.c
@@ -280,7 +280,7 @@ int dm_btree_del(struct dm_btree_info *info, dm_block_t root)
 	 * considered an FS op.  We can't recurse back into the FS, so we
 	 * allocate GFP_NOFS.
 	 */
-	s = kmalloc(sizeof(*s), GFP_NOFS);
+	s = kmalloc_obj(*s, GFP_NOFS);
 	if (!s)
 		return -ENOMEM;
 	s->info = info;
diff --git a/drivers/md/persistent-data/dm-space-map-disk.c b/drivers/md/persistent-data/dm-space-map-disk.c
index f4241f54e20e..1d3cfc87701a 100644
--- a/drivers/md/persistent-data/dm-space-map-disk.c
+++ b/drivers/md/persistent-data/dm-space-map-disk.c
@@ -220,7 +220,7 @@ struct dm_space_map *dm_sm_disk_create(struct dm_transaction_manager *tm,
 	int r;
 	struct sm_disk *smd;
 
-	smd = kmalloc(sizeof(*smd), GFP_KERNEL);
+	smd = kmalloc_obj(*smd, GFP_KERNEL);
 	if (!smd)
 		return ERR_PTR(-ENOMEM);
 
@@ -254,7 +254,7 @@ struct dm_space_map *dm_sm_disk_open(struct dm_transaction_manager *tm,
 	int r;
 	struct sm_disk *smd;
 
-	smd = kmalloc(sizeof(*smd), GFP_KERNEL);
+	smd = kmalloc_obj(*smd, GFP_KERNEL);
 	if (!smd)
 		return ERR_PTR(-ENOMEM);
 
diff --git a/drivers/md/persistent-data/dm-space-map-metadata.c b/drivers/md/persistent-data/dm-space-map-metadata.c
index d48c4fafc779..3c82a715ceed 100644
--- a/drivers/md/persistent-data/dm-space-map-metadata.c
+++ b/drivers/md/persistent-data/dm-space-map-metadata.c
@@ -772,7 +772,7 @@ struct dm_space_map *dm_sm_metadata_init(void)
 {
 	struct sm_metadata *smm;
 
-	smm = kvmalloc(sizeof(*smm), GFP_KERNEL);
+	smm = kvmalloc_obj(*smm, GFP_KERNEL);
 	if (!smm)
 		return ERR_PTR(-ENOMEM);
 
diff --git a/drivers/md/persistent-data/dm-transaction-manager.c b/drivers/md/persistent-data/dm-transaction-manager.c
index 98c745d90f48..1f50f50665ef 100644
--- a/drivers/md/persistent-data/dm-transaction-manager.c
+++ b/drivers/md/persistent-data/dm-transaction-manager.c
@@ -137,7 +137,7 @@ static void insert_shadow(struct dm_transaction_manager *tm, dm_block_t b)
 	unsigned int bucket;
 	struct shadow_info *si;
 
-	si = kmalloc(sizeof(*si), GFP_NOIO);
+	si = kmalloc_obj(*si, GFP_NOIO);
 	if (si) {
 		struct rb_node **node, *parent;
 		si->where = b;
@@ -185,7 +185,7 @@ static struct dm_transaction_manager *dm_tm_create(struct dm_block_manager *bm,
 	unsigned int i;
 	struct dm_transaction_manager *tm;
 
-	tm = kmalloc(sizeof(*tm), GFP_KERNEL);
+	tm = kmalloc_obj(*tm, GFP_KERNEL);
 	if (!tm)
 		return ERR_PTR(-ENOMEM);
 
@@ -207,7 +207,7 @@ struct dm_transaction_manager *dm_tm_create_non_blocking_clone(struct dm_transac
 {
 	struct dm_transaction_manager *tm;
 
-	tm = kmalloc(sizeof(*tm), GFP_KERNEL);
+	tm = kmalloc_obj(*tm, GFP_KERNEL);
 	if (tm) {
 		tm->is_clone = 1;
 		tm->real = real;
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index d83b2b1c0049..f316267a2c02 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -69,7 +69,7 @@ static int create_strip_zones(struct mddev *mddev, struct r0conf **private_conf)
 	struct md_rdev *smallest, *rdev1, *rdev2, *rdev, **dev;
 	struct strip_zone *zone;
 	int cnt;
-	struct r0conf *conf = kzalloc(sizeof(*conf), GFP_KERNEL);
+	struct r0conf *conf = kzalloc_obj(*conf, GFP_KERNEL);
 	unsigned int blksize = 512;
 
 	if (!mddev_is_dm(mddev))
@@ -143,9 +143,8 @@ static int create_strip_zones(struct mddev *mddev, struct r0conf **private_conf)
 	}
 
 	err = -ENOMEM;
-	conf->strip_zone = kcalloc(conf->nr_strip_zones,
-				   sizeof(struct strip_zone),
-				   GFP_KERNEL);
+	conf->strip_zone = kzalloc_objs(struct strip_zone, conf->nr_strip_zones,
+					GFP_KERNEL);
 	if (!conf->strip_zone)
 		goto abort;
 	conf->devlist = kzalloc(array3_size(sizeof(struct md_rdev *),
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 867db18bc3ba..d5fd7841dd9f 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -155,8 +155,7 @@ static void * r1buf_pool_alloc(gfp_t gfp_flags, void *data)
 	if (!r1_bio)
 		return NULL;
 
-	rps = kmalloc_array(conf->raid_disks * 2, sizeof(struct resync_pages),
-			    gfp_flags);
+	rps = kmalloc_objs(struct resync_pages, conf->raid_disks * 2, gfp_flags);
 	if (!rps)
 		goto out_free_r1bio;
 
@@ -3070,27 +3069,25 @@ static struct r1conf *setup_conf(struct mddev *mddev)
 	size_t r1bio_size;
 	int err = -ENOMEM;
 
-	conf = kzalloc(sizeof(struct r1conf), GFP_KERNEL);
+	conf = kzalloc_obj(struct r1conf, GFP_KERNEL);
 	if (!conf)
 		goto abort;
 
-	conf->nr_pending = kcalloc(BARRIER_BUCKETS_NR,
-				   sizeof(atomic_t), GFP_KERNEL);
+	conf->nr_pending = kzalloc_objs(atomic_t, BARRIER_BUCKETS_NR,
+					GFP_KERNEL);
 	if (!conf->nr_pending)
 		goto abort;
 
-	conf->nr_waiting = kcalloc(BARRIER_BUCKETS_NR,
-				   sizeof(atomic_t), GFP_KERNEL);
+	conf->nr_waiting = kzalloc_objs(atomic_t, BARRIER_BUCKETS_NR,
+					GFP_KERNEL);
 	if (!conf->nr_waiting)
 		goto abort;
 
-	conf->nr_queued = kcalloc(BARRIER_BUCKETS_NR,
-				  sizeof(atomic_t), GFP_KERNEL);
+	conf->nr_queued = kzalloc_objs(atomic_t, BARRIER_BUCKETS_NR, GFP_KERNEL);
 	if (!conf->nr_queued)
 		goto abort;
 
-	conf->barrier = kcalloc(BARRIER_BUCKETS_NR,
-				sizeof(atomic_t), GFP_KERNEL);
+	conf->barrier = kzalloc_objs(atomic_t, BARRIER_BUCKETS_NR, GFP_KERNEL);
 	if (!conf->barrier)
 		goto abort;
 
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 9debb20cf129..bdd3a7feaea7 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -152,7 +152,7 @@ static void * r10buf_pool_alloc(gfp_t gfp_flags, void *data)
 		nalloc_rp = nalloc;
 	else
 		nalloc_rp = nalloc * 2;
-	rps = kmalloc_array(nalloc_rp, sizeof(struct resync_pages), gfp_flags);
+	rps = kmalloc_objs(struct resync_pages, nalloc_rp, gfp_flags);
 	if (!rps)
 		goto out_free_r10bio;
 
@@ -3852,14 +3852,14 @@ static struct r10conf *setup_conf(struct mddev *mddev)
 	}
 
 	err = -ENOMEM;
-	conf = kzalloc(sizeof(struct r10conf), GFP_KERNEL);
+	conf = kzalloc_obj(struct r10conf, GFP_KERNEL);
 	if (!conf)
 		goto out;
 
 	/* FIXME calc properly */
-	conf->mirrors = kcalloc(mddev->raid_disks + max(0, -mddev->delta_disks),
-				sizeof(struct raid10_info),
-				GFP_KERNEL);
+	conf->mirrors = kzalloc_objs(struct raid10_info,
+				     mddev->raid_disks + max(0, -mddev->delta_disks),
+				     GFP_KERNEL);
 	if (!conf->mirrors)
 		goto out;
 
@@ -4281,9 +4281,9 @@ static int raid10_check_reshape(struct mddev *mddev)
 	if (mddev->delta_disks > 0) {
 		/* allocate new 'mirrors' list */
 		conf->mirrors_new =
-			kcalloc(mddev->raid_disks + mddev->delta_disks,
-				sizeof(struct raid10_info),
-				GFP_KERNEL);
+			kzalloc_objs(struct raid10_info,
+				     mddev->raid_disks + mddev->delta_disks,
+				     GFP_KERNEL);
 		if (!conf->mirrors_new)
 			return -ENOMEM;
 	}
@@ -4918,7 +4918,7 @@ static int handle_reshape_read_error(struct mddev *mddev,
 	int idx = 0;
 	struct page **pages;
 
-	r10b = kmalloc(struct_size(r10b, devs, conf->copies), GFP_NOIO);
+	r10b = kmalloc_flex(*r10b, devs, conf->copies, GFP_NOIO);
 	if (!r10b) {
 		set_bit(MD_RECOVERY_INTR, &mddev->recovery);
 		return -ENOMEM;
diff --git a/drivers/md/raid5-cache.c b/drivers/md/raid5-cache.c
index e29e69335c69..3ae22f6aacda 100644
--- a/drivers/md/raid5-cache.c
+++ b/drivers/md/raid5-cache.c
@@ -2447,7 +2447,7 @@ static int r5l_recovery_log(struct r5l_log *log)
 	int ret;
 	sector_t pos;
 
-	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
+	ctx = kzalloc_obj(*ctx, GFP_KERNEL);
 	if (!ctx)
 		return -ENOMEM;
 
@@ -3071,7 +3071,7 @@ int r5l_init_log(struct r5conf *conf, struct md_rdev *rdev)
 		return -EINVAL;
 	}
 
-	log = kzalloc(sizeof(*log), GFP_KERNEL);
+	log = kzalloc_obj(*log, GFP_KERNEL);
 	if (!log)
 		return -ENOMEM;
 	log->rdev = rdev;
diff --git a/drivers/md/raid5-ppl.c b/drivers/md/raid5-ppl.c
index 56b234683ee6..9dfa07ed723f 100644
--- a/drivers/md/raid5-ppl.c
+++ b/drivers/md/raid5-ppl.c
@@ -1352,7 +1352,7 @@ int ppl_init_log(struct r5conf *conf)
 		return -EINVAL;
 	}
 
-	ppl_conf = kzalloc(sizeof(struct ppl_conf), GFP_KERNEL);
+	ppl_conf = kzalloc_obj(struct ppl_conf, GFP_KERNEL);
 	if (!ppl_conf)
 		return -ENOMEM;
 
@@ -1378,8 +1378,8 @@ int ppl_init_log(struct r5conf *conf)
 		goto err;
 
 	ppl_conf->count = conf->raid_disks;
-	ppl_conf->child_logs = kcalloc(ppl_conf->count, sizeof(struct ppl_log),
-				       GFP_KERNEL);
+	ppl_conf->child_logs = kzalloc_objs(struct ppl_log, ppl_conf->count,
+					    GFP_KERNEL);
 	if (!ppl_conf->child_logs) {
 		ret = -ENOMEM;
 		goto err;
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 8854e024f311..ba8381cbb2f1 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -513,7 +513,7 @@ init_stripe_shared_pages(struct stripe_head *sh, struct r5conf *conf, int disks)
 	cnt = PAGE_SIZE / conf->stripe_size;
 	nr_pages = (disks + cnt - 1) / cnt;
 
-	sh->pages = kcalloc(nr_pages, sizeof(struct page *), GFP_KERNEL);
+	sh->pages = kzalloc_objs(struct page *, nr_pages, GFP_KERNEL);
 	if (!sh->pages)
 		return -ENOMEM;
 	sh->nr_pages = nr_pages;
@@ -2610,7 +2610,7 @@ static int resize_stripes(struct r5conf *conf, int newsize)
 	 * is completely stalled, so now is a good time to resize
 	 * conf->disks and the scribble region
 	 */
-	ndisks = kcalloc(newsize, sizeof(struct disk_info), GFP_NOIO);
+	ndisks = kzalloc_objs(struct disk_info, newsize, GFP_NOIO);
 	if (ndisks) {
 		for (i = 0; i < conf->pool_size; i++)
 			ndisks[i] = conf->disks[i];
@@ -7267,8 +7267,8 @@ static int alloc_thread_groups(struct r5conf *conf, int cnt, int *group_cnt,
 	*group_cnt = num_possible_nodes();
 	size = sizeof(struct r5worker) * cnt;
 	workers = kcalloc(size, *group_cnt, GFP_NOIO);
-	*worker_groups = kcalloc(*group_cnt, sizeof(struct r5worker_group),
-				 GFP_NOIO);
+	*worker_groups = kzalloc_objs(struct r5worker_group, *group_cnt,
+				      GFP_NOIO);
 	if (!*worker_groups || !workers) {
 		kfree(workers);
 		kfree(*worker_groups);
@@ -7497,7 +7497,7 @@ static struct r5conf *setup_conf(struct mddev *mddev)
 		return ERR_PTR(-EINVAL);
 	}
 
-	conf = kzalloc(sizeof(struct r5conf), GFP_KERNEL);
+	conf = kzalloc_obj(struct r5conf, GFP_KERNEL);
 	if (conf == NULL)
 		goto abort;
 
@@ -7508,9 +7508,8 @@ static struct r5conf *setup_conf(struct mddev *mddev)
 #endif
 	INIT_LIST_HEAD(&conf->free_list);
 	INIT_LIST_HEAD(&conf->pending_list);
-	conf->pending_data = kcalloc(PENDING_IO_MAX,
-				     sizeof(struct r5pending_data),
-				     GFP_KERNEL);
+	conf->pending_data = kzalloc_objs(struct r5pending_data, PENDING_IO_MAX,
+					  GFP_KERNEL);
 	if (!conf->pending_data)
 		goto abort;
 	for (i = 0; i < PENDING_IO_MAX; i++)
@@ -7557,8 +7556,7 @@ static struct r5conf *setup_conf(struct mddev *mddev)
 		conf->previous_raid_disks = mddev->raid_disks - mddev->delta_disks;
 	max_disks = max(conf->raid_disks, conf->previous_raid_disks);
 
-	conf->disks = kcalloc(max_disks, sizeof(struct disk_info),
-			      GFP_KERNEL);
+	conf->disks = kzalloc_objs(struct disk_info, max_disks, GFP_KERNEL);
 
 	if (!conf->disks)
 		goto abort;