Convert 'alloc_obj' family to use the new default GFP_KERNEL argument

This was done entirely with mindless brute force, using

    git grep -l '\<k[vmz]*alloc_objs*(.*, GFP_KERNEL)' |
        xargs sed -i 's/\(alloc_objs*(.*\), GFP_KERNEL)/\1)/'

to convert the new alloc_obj() users that had a simple GFP_KERNEL
argument to just drop that argument.

Note that due to the extreme simplicity of the scripting, any slightly
more complex cases spread over multiple lines would not be triggered:
they definitely exist, but this covers the vast bulk of the cases, and
the resulting diff is also then easier to check automatically.

For the same reason the 'flex' versions will be done as a separate
conversion.

Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

65 files changed, 116 insertions, 116 deletions

diff --git a/drivers/md/bcache/alloc.c b/drivers/md/bcache/alloc.c
index 90cc6ed4bd6d..3ec240ec685d 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_obj(*b, GFP_KERNEL);
+		struct open_bucket *b = kzalloc_obj(*b);
 
 		if (!b)
 			return -ENOMEM;
diff --git a/drivers/md/bcache/debug.c b/drivers/md/bcache/debug.c
index 55f5e202015d..2691a5da3368 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_obj(struct dump_iterator, GFP_KERNEL);
+	i = kzalloc_obj(struct dump_iterator);
 	if (!i)
 		return -ENOMEM;
 
diff --git a/drivers/md/bcache/super.c b/drivers/md/bcache/super.c
index a304ef80820b..64bb38c95895 100644
--- a/drivers/md/bcache/super.c
+++ b/drivers/md/bcache/super.c
@@ -1527,7 +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_obj(struct bcache_device, GFP_KERNEL);
+	struct bcache_device *d = kzalloc_obj(struct bcache_device);
 	if (!d)
 		goto err_ret;
 
@@ -1863,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_obj(struct cache_set, GFP_KERNEL);
+	struct cache_set *c = kzalloc_obj(struct cache_set);
 
 	if (!c)
 		return NULL;
@@ -2542,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_obj(struct cached_dev, GFP_KERNEL);
-	return kzalloc_obj(struct cache, GFP_KERNEL);
+		return kzalloc_obj(struct cached_dev);
+	return kzalloc_obj(struct cache);
 }
 
 static ssize_t register_bcache(struct kobject *k, struct kobj_attribute *attr,
@@ -2580,7 +2580,7 @@ static ssize_t register_bcache(struct kobject *k, struct kobj_attribute *attr,
 	if (!path)
 		goto out_module_put;
 
-	sb = kmalloc_obj(struct cache_sb, GFP_KERNEL);
+	sb = kmalloc_obj(struct cache_sb);
 	if (!sb)
 		goto out_free_path;
 
@@ -2632,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_obj(struct async_reg_args, GFP_KERNEL);
+			kzalloc_obj(struct async_reg_args);
 
 		if (!args) {
 			ret = -ENOMEM;
@@ -2709,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_obj(struct pdev, GFP_KERNEL);
+		pdev = kmalloc_obj(struct pdev);
 		if (!pdev)
 			break;
 		pdev->dc = dc;
diff --git a/drivers/md/bcache/sysfs.c b/drivers/md/bcache/sysfs.c
index b30424075106..cfac56caa804 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_obj(struct kobj_uevent_env, GFP_KERNEL);
+		env = kzalloc_obj(struct kobj_uevent_env);
 		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 fc8bb30dc533..29b916c05082 100644
--- a/drivers/md/dm-bio-prison-v1.c
+++ b/drivers/md/dm-bio-prison-v1.c
@@ -301,7 +301,7 @@ struct dm_deferred_set *dm_deferred_set_create(void)
 	int i;
 	struct dm_deferred_set *ds;
 
-	ds = kmalloc_obj(*ds, GFP_KERNEL);
+	ds = kmalloc_obj(*ds);
 	if (!ds)
 		return NULL;
 
diff --git a/drivers/md/dm-bio-prison-v2.c b/drivers/md/dm-bio-prison-v2.c
index d4daf426c2c7..4e2af53ad99e 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_obj(*prison, GFP_KERNEL);
+	struct dm_bio_prison_v2 *prison = kzalloc_obj(*prison);
 	int ret;
 
 	if (!prison)
diff --git a/drivers/md/dm-cache-background-tracker.c b/drivers/md/dm-cache-background-tracker.c
index fb5efaab11a3..2ca3a3e2e50e 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_obj(*b, GFP_KERNEL);
+	struct background_tracker *b = kmalloc_obj(*b);
 
 	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 5060a58605a2..57158c02d096 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_obj(*cmd, GFP_KERNEL);
+	cmd = kzalloc_obj(*cmd);
 	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 bec1b5e95170..b328d9601046 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_obj(*mq, GFP_KERNEL);
+	struct smq_policy *mq = kzalloc_obj(*mq);
 
 	if (!mq)
 		return NULL;
diff --git a/drivers/md/dm-cache-target.c b/drivers/md/dm-cache-target.c
index be1af992b931..935ab79b1d0c 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_obj(*cache, GFP_KERNEL);
+	cache = kzalloc_obj(*cache);
 	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_obj(*ca, GFP_KERNEL);
+	ca = kzalloc_obj(*ca);
 	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 cb474e852548..e50a5b5a4aea 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_obj(*cmd, GFP_KERNEL);
+	cmd = kzalloc_obj(*cmd);
 	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 c9b25af70063..c0f9b93983d4 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_objs(struct hash_table_bucket, sz, GFP_KERNEL);
+	clone->ht = kvmalloc_objs(struct hash_table_bucket, sz);
 	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_obj(*clone, GFP_KERNEL);
+	clone = kzalloc_obj(*clone);
 	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 a2f9f0f0db5e..9a17b3b603d1 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -2363,7 +2363,7 @@ static int crypt_alloc_tfms_aead(struct crypt_config *cc, char *ciphermode)
 {
 	int err;
 
-	cc->cipher_tfm.tfms = kmalloc_obj(struct crypto_skcipher *, GFP_KERNEL);
+	cc->cipher_tfm.tfms = kmalloc_obj(struct crypto_skcipher *);
 	if (!cc->cipher_tfm.tfms)
 		return -ENOMEM;
 
diff --git a/drivers/md/dm-delay.c b/drivers/md/dm-delay.c
index 5d2dd07a19b0..4864671c2222 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_obj(*dc, GFP_KERNEL);
+	dc = kzalloc_obj(*dc);
 	if (!dc) {
 		ti->error = "Cannot allocate context";
 		return -ENOMEM;
diff --git a/drivers/md/dm-dust.c b/drivers/md/dm-dust.c
index a91f96bad0b9..c7e3077fb1f5 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_obj(*bblock, GFP_KERNEL);
+	bblock = kmalloc_obj(*bblock);
 	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_obj(struct dust_device, GFP_KERNEL);
+	dd = kzalloc_obj(struct dust_device);
 	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 4c9a25ae90d6..1e52bde48b91 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_obj(*ec, GFP_KERNEL);
+	ec = ti->private = kzalloc_obj(*ec);
 	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 9bec72f04b9b..05285c04ff2c 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_obj(*md, GFP_KERNEL);
+	struct era_metadata *md = kzalloc_obj(*md);
 
 	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_obj(*era, GFP_KERNEL);
+	era = kzalloc_obj(*era);
 	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 91d541c66709..58cbc5e5475b 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_obj(*tmp_store, GFP_KERNEL);
+	tmp_store = kzalloc_obj(*tmp_store);
 	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 922e75bfcf17..572225b0e691 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_obj(*fc, GFP_KERNEL);
+	fc = kzalloc_obj(*fc);
 	if (!fc) {
 		ti->error = "Cannot allocate context";
 		return -ENOMEM;
diff --git a/drivers/md/dm-init.c b/drivers/md/dm-init.c
index 703250739a8a..7403823384c5 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_obj(*sp, GFP_KERNEL);
+	sp = kzalloc_obj(*sp);
 	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_obj(*dev, GFP_KERNEL);
+		dev = kzalloc_obj(*dev);
 		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 3da3ce600758..a52ee38dc30c 100644
--- a/drivers/md/dm-integrity.c
+++ b/drivers/md/dm-integrity.c
@@ -4296,7 +4296,7 @@ static struct scatterlist **dm_integrity_alloc_journal_scatterlist(struct dm_int
 
 		n_pages = (end_index - start_index + 1);
 
-		s = kvmalloc_objs(struct scatterlist, n_pages, GFP_KERNEL);
+		s = kvmalloc_objs(struct scatterlist, n_pages);
 		if (!s) {
 			dm_integrity_free_journal_scatterlist(ic, sl);
 			return NULL;
@@ -4701,7 +4701,7 @@ static int dm_integrity_ctr(struct dm_target *ti, unsigned int argc, char **argv
 		return -EINVAL;
 	}
 
-	ic = kzalloc_obj(struct dm_integrity_c, GFP_KERNEL);
+	ic = kzalloc_obj(struct dm_integrity_c);
 	if (!ic) {
 		ti->error = "Cannot allocate integrity context";
 		return -ENOMEM;
diff --git a/drivers/md/dm-io.c b/drivers/md/dm-io.c
index d08399b40dac..1db565b37620 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_obj(*client, GFP_KERNEL);
+	client = kzalloc_obj(*client);
 	if (!client)
 		return ERR_PTR(-ENOMEM);
 
diff --git a/drivers/md/dm-ioctl.c b/drivers/md/dm-ioctl.c
index 7ab970430acd..3ab8b4beff86 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_obj(*hc, GFP_KERNEL);
+	hc = kmalloc_obj(*hc);
 	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_obj(struct dm_file, GFP_KERNEL);
+	priv = filp->private_data = kmalloc_obj(struct dm_file);
 	if (!priv)
 		return -ENOMEM;
 
diff --git a/drivers/md/dm-kcopyd.c b/drivers/md/dm-kcopyd.c
index 03b81b39c65c..96c8b8ff61c2 100644
--- a/drivers/md/dm-kcopyd.c
+++ b/drivers/md/dm-kcopyd.c
@@ -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_obj(*kc, GFP_KERNEL);
+	kc = kzalloc_obj(*kc);
 	if (!kc)
 		return ERR_PTR(-ENOMEM);
 
diff --git a/drivers/md/dm-linear.c b/drivers/md/dm-linear.c
index 3123227a6e1d..38c17846deb0 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_obj(*lc, GFP_KERNEL);
+	lc = kmalloc_obj(*lc);
 	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 d1bc7d0c89d9..9d5918eb0a30 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_obj(*lc, GFP_KERNEL);
+	lc = kzalloc_obj(*lc);
 	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 a1040e8049aa..c72e07c3f5a0 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_obj(struct log_writes_c, GFP_KERNEL);
+	lc = kzalloc_obj(struct log_writes_c);
 	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_obj(struct pending_block, GFP_KERNEL);
+	block = kzalloc_obj(struct pending_block);
 	if (!block) {
 		DMERR("Error allocating pending block");
 		return -ENOMEM;
diff --git a/drivers/md/dm-log.c b/drivers/md/dm-log.c
index 7865002678f5..1aa6a4a7d232 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_obj(*log, GFP_KERNEL);
+	log = kmalloc_obj(*log);
 	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_obj(*lc, GFP_KERNEL);
+	lc = kmalloc_obj(*lc);
 	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 e47cfdf4f5d1..8f4ae2f51545 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_obj(*pgpath, GFP_KERNEL);
+	struct pgpath *pgpath = kzalloc_obj(*pgpath);
 
 	if (!pgpath)
 		return NULL;
@@ -179,7 +179,7 @@ static struct priority_group *alloc_priority_group(void)
 {
 	struct priority_group *pg;
 
-	pg = kzalloc_obj(*pg, GFP_KERNEL);
+	pg = kzalloc_obj(*pg);
 
 	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_obj(*m, GFP_KERNEL);
+	m = kzalloc_obj(*m);
 	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 28dc759e957a..006a7991f45b 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_obj(*psi, GFP_KERNEL);
+	struct ps_internal *psi = kzalloc_obj(*psi);
 
 	if (psi)
 		psi->pst = *pst;
diff --git a/drivers/md/dm-pcache/dm_pcache.c b/drivers/md/dm-pcache/dm_pcache.c
index c36f2afdadc1..81c795c0400e 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_obj(struct dm_pcache, GFP_KERNEL);
+	pcache = kzalloc_obj(struct dm_pcache);
 	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 a526b5ab0453..c4755112287a 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_obj(*s, GFP_KERNEL);
+	struct selector *s = kmalloc_obj(*s);
 
 	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_obj(*pi, GFP_KERNEL);
+	pi = kmalloc_obj(*pi);
 	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 5d69a4a93684..526d94d138f9 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_obj(*pi, GFP_KERNEL);
+	pi = kzalloc_obj(*pi);
 	if (!pi) {
 		*error = "io-affinity ps: Error allocating path context";
 		return -ENOMEM;
@@ -112,11 +112,11 @@ static int ioa_create(struct path_selector *ps, unsigned int argc, char **argv)
 {
 	struct selector *s;
 
-	s = kmalloc_obj(*s, GFP_KERNEL);
+	s = kmalloc_obj(*s);
 	if (!s)
 		return -ENOMEM;
 
-	s->path_map = kzalloc_objs(struct path_info *, nr_cpu_ids, GFP_KERNEL);
+	s->path_map = kzalloc_objs(struct path_info *, nr_cpu_ids);
 	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 d2663b1b136c..4afea160afab 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_obj(*s, GFP_KERNEL);
+	struct selector *s = kmalloc_obj(*s);
 
 	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_obj(*pi, GFP_KERNEL);
+	pi = kmalloc_obj(*pi);
 	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 ec8b9f27d3e7..81c89cda3158 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_obj(*s, GFP_KERNEL);
+	struct selector *s = kmalloc_obj(*s);
 
 	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_obj(*pi, GFP_KERNEL);
+	pi = kmalloc_obj(*pi);
 	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 dc119955fadd..83721910e5ea 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_obj(*s, GFP_KERNEL);
+	struct selector *s = kmalloc_obj(*s);
 
 	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_obj(*pi, GFP_KERNEL);
+	pi = kmalloc_obj(*pi);
 	if (!pi) {
 		*error = "service-time ps: Error allocating path context";
 		return -ENOMEM;
diff --git a/drivers/md/dm-region-hash.c b/drivers/md/dm-region-hash.c
index a3489965103c..3ad3aecfdff7 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_obj(*rh, GFP_KERNEL);
+	rh = kzalloc_obj(*rh);
 	if (!rh) {
 		DMERR("unable to allocate region hash memory");
 		return ERR_PTR(-ENOMEM);
diff --git a/drivers/md/dm-snap-persistent.c b/drivers/md/dm-snap-persistent.c
index c8128af1dcad..2f429ca8e5aa 100644
--- a/drivers/md/dm-snap-persistent.c
+++ b/drivers/md/dm-snap-persistent.c
@@ -854,7 +854,7 @@ static int persistent_ctr(struct dm_exception_store *store, char *options)
 	int r;
 
 	/* allocate the pstore */
-	ps = kzalloc_obj(*ps, GFP_KERNEL);
+	ps = kzalloc_obj(*ps);
 	if (!ps)
 		return -ENOMEM;
 
diff --git a/drivers/md/dm-snap-transient.c b/drivers/md/dm-snap-transient.c
index b7b449db6c34..8680d38cdfcc 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_obj(struct transient_c, GFP_KERNEL);
+	tc = kmalloc_obj(struct transient_c);
 	if (!tc)
 		return -ENOMEM;
 
diff --git a/drivers/md/dm-snap.c b/drivers/md/dm-snap.c
index 5a77ccd33232..f31e4b8f4457 100644
--- a/drivers/md/dm-snap.c
+++ b/drivers/md/dm-snap.c
@@ -354,7 +354,7 @@ static int init_origin_hash(void)
 {
 	int i;
 
-	_origins = kmalloc_objs(struct list_head, ORIGIN_HASH_SIZE, GFP_KERNEL);
+	_origins = kmalloc_objs(struct list_head, ORIGIN_HASH_SIZE);
 	if (!_origins) {
 		DMERR("unable to allocate memory for _origins");
 		return -ENOMEM;
@@ -557,7 +557,7 @@ static int register_snapshot(struct dm_snapshot *snap)
 	struct block_device *bdev = snap->origin->bdev;
 	int r = 0;
 
-	new_o = kmalloc_obj(*new_o, GFP_KERNEL);
+	new_o = kmalloc_obj(*new_o);
 	if (!new_o)
 		return -ENOMEM;
 
@@ -664,7 +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_objs(struct dm_hlist_head, size, GFP_KERNEL);
+	et->table = kvmalloc_objs(struct dm_hlist_head, size);
 	if (!et->table)
 		return -ENOMEM;
 
@@ -1249,7 +1249,7 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 		origin_mode = BLK_OPEN_WRITE;
 	}
 
-	s = kzalloc_obj(*s, GFP_KERNEL);
+	s = kzalloc_obj(*s);
 	if (!s) {
 		ti->error = "Cannot allocate private snapshot structure";
 		r = -ENOMEM;
@@ -2623,7 +2623,7 @@ static int origin_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 		return -EINVAL;
 	}
 
-	o = kmalloc_obj(struct dm_origin, GFP_KERNEL);
+	o = kmalloc_obj(struct dm_origin);
 	if (!o) {
 		ti->error = "Cannot allocate private origin structure";
 		r = -ENOMEM;
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 4b4712e54797..dc2eff6b739d 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_obj(*t, GFP_KERNEL);
+	t = kzalloc_obj(*t);
 
 	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_obj(*dd, GFP_KERNEL);
+		dd = kmalloc_obj(*dd);
 		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_obj(*dmcp, GFP_KERNEL);
+	dmcp = kmalloc_obj(*dmcp);
 	if (!dmcp)
 		return -ENOMEM;
 	dmcp->md = t->md;
diff --git a/drivers/md/dm-target.c b/drivers/md/dm-target.c
index a138e8a24327..3d294365e3ba 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_obj(*ioec, GFP_KERNEL);
+	ioec = kmalloc_obj(*ioec);
 	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 c924ec4d300d..b6a2d2081a24 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_obj(*pmd, GFP_KERNEL);
+	pmd = kmalloc_obj(*pmd);
 	if (!pmd) {
 		DMERR("could not allocate metadata struct");
 		return ERR_PTR(-ENOMEM);
diff --git a/drivers/md/dm-thin.c b/drivers/md/dm-thin.c
index 492ead2d9356..59392de7a477 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_obj(*pool, GFP_KERNEL);
+	pool = kzalloc_obj(*pool);
 	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_obj(*pt, GFP_KERNEL);
+	pt = kzalloc_obj(*pt);
 	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_obj(*tc, GFP_KERNEL);
+	tc = ti->private = kzalloc_obj(*tc);
 	if (!tc) {
 		ti->error = "Out of memory";
 		r = -ENOMEM;
diff --git a/drivers/md/dm-unstripe.c b/drivers/md/dm-unstripe.c
index c595d0a138fc..bfcbe6bfa71a 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_obj(*uc, GFP_KERNEL);
+	uc = kzalloc_obj(*uc);
 	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 08bb75f00891..14be4d888af3 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_obj(struct dm_verity_fec, GFP_KERNEL);
+	f = kzalloc_obj(struct dm_verity_fec);
 	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 9dd0c195091f..61073cd01d13 100644
--- a/drivers/md/dm-verity-target.c
+++ b/drivers/md/dm-verity-target.c
@@ -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_obj(struct sha256_ctx, GFP_KERNEL);
+			kmalloc_obj(struct sha256_ctx);
 		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_obj(struct dm_verity, GFP_KERNEL);
+	v = kzalloc_obj(struct dm_verity);
 	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 bca442478a8d..98bd945f6da7 100644
--- a/drivers/md/dm-writecache.c
+++ b/drivers/md/dm-writecache.c
@@ -2245,7 +2245,7 @@ static int writecache_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 	as.argc = argc;
 	as.argv = argv;
 
-	wc = kzalloc_obj(struct dm_writecache, GFP_KERNEL);
+	wc = kzalloc_obj(struct dm_writecache);
 	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 b9a473ffdb70..8d7edd18117d 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_obj(struct dm_zone, GFP_KERNEL);
+	struct dm_zone *zone = kzalloc_obj(struct dm_zone);
 
 	if (!zone)
 		return ERR_PTR(-ENOMEM);
@@ -1311,7 +1311,7 @@ static int dmz_load_sb(struct dmz_metadata *zmd)
 		int i;
 		struct dmz_sb *sb;
 
-		sb = kzalloc_obj(struct dmz_sb, GFP_KERNEL);
+		sb = kzalloc_obj(struct dmz_sb);
 		if (!sb)
 			return -ENOMEM;
 		for (i = 1; i < zmd->nr_devs; i++) {
@@ -2868,7 +2868,7 @@ int dmz_ctr_metadata(struct dmz_dev *dev, int num_dev,
 	struct dm_zone *zone;
 	int ret;
 
-	zmd = kzalloc_obj(struct dmz_metadata, GFP_KERNEL);
+	zmd = kzalloc_obj(struct dmz_metadata);
 	if (!zmd)
 		return -ENOMEM;
 
diff --git a/drivers/md/dm-zoned-reclaim.c b/drivers/md/dm-zoned-reclaim.c
index 8598cc9eb40f..ad9c7bc21d54 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_obj(struct dmz_reclaim, GFP_KERNEL);
+	zrc = kzalloc_obj(struct dmz_reclaim);
 	if (!zrc)
 		return -ENOMEM;
 
diff --git a/drivers/md/dm-zoned-target.c b/drivers/md/dm-zoned-target.c
index 0e6ddfb96e03..d55500fc88ef 100644
--- a/drivers/md/dm-zoned-target.c
+++ b/drivers/md/dm-zoned-target.c
@@ -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_obj(struct dmz_target, GFP_KERNEL);
+	dmz = kzalloc_obj(struct dmz_target);
 	if (!dmz) {
 		ti->error = "Unable to allocate the zoned target descriptor";
 		return -ENOMEM;
 	}
-	dmz->dev = kzalloc_objs(struct dmz_dev, argc, GFP_KERNEL);
+	dmz->dev = kzalloc_objs(struct dmz_dev, argc);
 	if (!dmz->dev) {
 		ti->error = "Unable to allocate the zoned device descriptors";
 		kfree(dmz);
 		return -ENOMEM;
 	}
-	dmz->ddev = kzalloc_objs(struct dm_dev *, argc, GFP_KERNEL);
+	dmz->ddev = kzalloc_objs(struct dm_dev *, argc);
 	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 ca833f147c6a..83378c033c72 100644
--- a/drivers/md/md-bitmap.c
+++ b/drivers/md/md-bitmap.c
@@ -1025,7 +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_objs(struct page *, num_pages, GFP_KERNEL);
+	store->filemap = kmalloc_objs(struct page *, num_pages);
 	if (!store->filemap)
 		return -ENOMEM;
 
@@ -2120,7 +2120,7 @@ static struct bitmap *__bitmap_create(struct mddev *mddev, int slot)
 		return ERR_PTR(-EBUSY);
 	}
 
-	bitmap = kzalloc_obj(*bitmap, GFP_KERNEL);
+	bitmap = kzalloc_obj(*bitmap);
 	if (!bitmap)
 		return ERR_PTR(-ENOMEM);
 
@@ -2435,7 +2435,7 @@ static int __bitmap_resize(struct bitmap *bitmap, sector_t blocks,
 
 	pages = DIV_ROUND_UP(chunks, PAGE_COUNTER_RATIO);
 
-	new_bp = kzalloc_objs(*new_bp, pages, GFP_KERNEL);
+	new_bp = kzalloc_objs(*new_bp, pages);
 	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 c588c972ad54..856e4b3c2bde 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_obj(struct dlm_lock_resource, GFP_KERNEL);
+	res = kzalloc_obj(struct dlm_lock_resource);
 	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_obj(struct md_cluster_info, GFP_KERNEL);
+	cinfo = kzalloc_obj(struct md_cluster_info);
 	if (!cinfo)
 		return -ENOMEM;
 
diff --git a/drivers/md/md-llbitmap.c b/drivers/md/md-llbitmap.c
index e8d7af0c665a..bf398d7476b3 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_obj(*llbitmap, GFP_KERNEL);
+	llbitmap = kzalloc_obj(*llbitmap);
 	if (!llbitmap)
 		return -ENOMEM;
 
diff --git a/drivers/md/md.c b/drivers/md/md.c
index b7ac2440fbbb..3ce6f9e9d38e 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_obj(*new, GFP_KERNEL);
+	new = kzalloc_obj(*new);
 	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_obj(*tmp1, GFP_KERNEL);
-	tmp2 = kmalloc_obj(*tmp2, GFP_KERNEL);
+	tmp1 = kmalloc_obj(*tmp1);
+	tmp2 = kmalloc_obj(*tmp2);
 
 	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_obj(*rdev, GFP_KERNEL);
+	rdev = kzalloc_obj(*rdev);
 	if (!rdev)
 		return ERR_PTR(-ENOMEM);
 
@@ -8541,7 +8541,7 @@ struct md_thread *md_register_thread(void (*run) (struct md_thread *),
 {
 	struct md_thread *thread;
 
-	thread = kzalloc_obj(struct md_thread, GFP_KERNEL);
+	thread = kzalloc_obj(struct md_thread);
 	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_obj(*node_detected_dev, GFP_KERNEL);
+	node_detected_dev = kzalloc_obj(*node_detected_dev);
 	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 43bd64b77a7d..a5003774f8bf 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_obj(*bm, GFP_KERNEL);
+	bm = kmalloc_obj(*bm);
 	if (!bm) {
 		r = -ENOMEM;
 		goto bad;
diff --git a/drivers/md/persistent-data/dm-space-map-disk.c b/drivers/md/persistent-data/dm-space-map-disk.c
index 1d3cfc87701a..27c0be9c5a37 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_obj(*smd, GFP_KERNEL);
+	smd = kmalloc_obj(*smd);
 	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_obj(*smd, GFP_KERNEL);
+	smd = kmalloc_obj(*smd);
 	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 3c82a715ceed..4bffddeed8ec 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_obj(*smm, GFP_KERNEL);
+	smm = kvmalloc_obj(*smm);
 	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 1f50f50665ef..7401add01d12 100644
--- a/drivers/md/persistent-data/dm-transaction-manager.c
+++ b/drivers/md/persistent-data/dm-transaction-manager.c
@@ -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_obj(*tm, GFP_KERNEL);
+	tm = kmalloc_obj(*tm);
 	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_obj(*tm, GFP_KERNEL);
+	tm = kmalloc_obj(*tm);
 	if (tm) {
 		tm->is_clone = 1;
 		tm->real = real;
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index f316267a2c02..b79d1a0883dc 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_obj(*conf, GFP_KERNEL);
+	struct r0conf *conf = kzalloc_obj(*conf);
 	unsigned int blksize = 512;
 
 	if (!mddev_is_dm(mddev))
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index d5fd7841dd9f..cef705c5ffd4 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -3069,7 +3069,7 @@ static struct r1conf *setup_conf(struct mddev *mddev)
 	size_t r1bio_size;
 	int err = -ENOMEM;
 
-	conf = kzalloc_obj(struct r1conf, GFP_KERNEL);
+	conf = kzalloc_obj(struct r1conf);
 	if (!conf)
 		goto abort;
 
@@ -3083,11 +3083,11 @@ static struct r1conf *setup_conf(struct mddev *mddev)
 	if (!conf->nr_waiting)
 		goto abort;
 
-	conf->nr_queued = kzalloc_objs(atomic_t, BARRIER_BUCKETS_NR, GFP_KERNEL);
+	conf->nr_queued = kzalloc_objs(atomic_t, BARRIER_BUCKETS_NR);
 	if (!conf->nr_queued)
 		goto abort;
 
-	conf->barrier = kzalloc_objs(atomic_t, BARRIER_BUCKETS_NR, GFP_KERNEL);
+	conf->barrier = kzalloc_objs(atomic_t, BARRIER_BUCKETS_NR);
 	if (!conf->barrier)
 		goto abort;
 
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index bdd3a7feaea7..968bc83b8597 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -3852,7 +3852,7 @@ static struct r10conf *setup_conf(struct mddev *mddev)
 	}
 
 	err = -ENOMEM;
-	conf = kzalloc_obj(struct r10conf, GFP_KERNEL);
+	conf = kzalloc_obj(struct r10conf);
 	if (!conf)
 		goto out;
 
diff --git a/drivers/md/raid5-cache.c b/drivers/md/raid5-cache.c
index 3ae22f6aacda..66b10cbda96d 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_obj(*ctx, GFP_KERNEL);
+	ctx = kzalloc_obj(*ctx);
 	if (!ctx)
 		return -ENOMEM;
 
@@ -3071,7 +3071,7 @@ int r5l_init_log(struct r5conf *conf, struct md_rdev *rdev)
 		return -EINVAL;
 	}
 
-	log = kzalloc_obj(*log, GFP_KERNEL);
+	log = kzalloc_obj(*log);
 	if (!log)
 		return -ENOMEM;
 	log->rdev = rdev;
diff --git a/drivers/md/raid5-ppl.c b/drivers/md/raid5-ppl.c
index 9dfa07ed723f..b0c524e920cb 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_obj(struct ppl_conf, GFP_KERNEL);
+	ppl_conf = kzalloc_obj(struct ppl_conf);
 	if (!ppl_conf)
 		return -ENOMEM;
 
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index ba8381cbb2f1..b785d129ef50 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 = kzalloc_objs(struct page *, nr_pages, GFP_KERNEL);
+	sh->pages = kzalloc_objs(struct page *, nr_pages);
 	if (!sh->pages)
 		return -ENOMEM;
 	sh->nr_pages = nr_pages;
@@ -7497,7 +7497,7 @@ static struct r5conf *setup_conf(struct mddev *mddev)
 		return ERR_PTR(-EINVAL);
 	}
 
-	conf = kzalloc_obj(struct r5conf, GFP_KERNEL);
+	conf = kzalloc_obj(struct r5conf);
 	if (conf == NULL)
 		goto abort;
 
@@ -7556,7 +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 = kzalloc_objs(struct disk_info, max_disks, GFP_KERNEL);
+	conf->disks = kzalloc_objs(struct disk_info, max_disks);
 
 	if (!conf->disks)
 		goto abort;