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>

38 files changed, 65 insertions, 73 deletions

diff --git a/drivers/char/agp/amd-k7-agp.c b/drivers/char/agp/amd-k7-agp.c
index 795c8c9ff680..7cf521d36e3b 100644
--- a/drivers/char/agp/amd-k7-agp.c
+++ b/drivers/char/agp/amd-k7-agp.c
@@ -85,13 +85,12 @@ static int amd_create_gatt_pages(int nr_tables)
 	int retval = 0;
 	int i;
 
-	tables = kcalloc(nr_tables + 1, sizeof(struct amd_page_map *),
-			 GFP_KERNEL);
+	tables = kzalloc_objs(struct amd_page_map *, nr_tables + 1, GFP_KERNEL);
 	if (tables == NULL)
 		return -ENOMEM;
 
 	for (i = 0; i < nr_tables; i++) {
-		entry = kzalloc(sizeof(struct amd_page_map), GFP_KERNEL);
+		entry = kzalloc_obj(struct amd_page_map, GFP_KERNEL);
 		tables[i] = entry;
 		if (entry == NULL) {
 			retval = -ENOMEM;
diff --git a/drivers/char/agp/ati-agp.c b/drivers/char/agp/ati-agp.c
index f7871afe08cf..65afee75d8e3 100644
--- a/drivers/char/agp/ati-agp.c
+++ b/drivers/char/agp/ati-agp.c
@@ -112,13 +112,12 @@ static int ati_create_gatt_pages(int nr_tables)
 	int retval = 0;
 	int i;
 
-	tables = kcalloc(nr_tables + 1, sizeof(struct ati_page_map *),
-			 GFP_KERNEL);
+	tables = kzalloc_objs(struct ati_page_map *, nr_tables + 1, GFP_KERNEL);
 	if (tables == NULL)
 		return -ENOMEM;
 
 	for (i = 0; i < nr_tables; i++) {
-		entry = kzalloc(sizeof(struct ati_page_map), GFP_KERNEL);
+		entry = kzalloc_obj(struct ati_page_map, GFP_KERNEL);
 		tables[i] = entry;
 		if (entry == NULL) {
 			retval = -ENOMEM;
diff --git a/drivers/char/agp/backend.c b/drivers/char/agp/backend.c
index 1776afd3ee07..90554f4f2146 100644
--- a/drivers/char/agp/backend.c
+++ b/drivers/char/agp/backend.c
@@ -238,7 +238,7 @@ struct agp_bridge_data *agp_alloc_bridge(void)
 {
 	struct agp_bridge_data *bridge;
 
-	bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
+	bridge = kzalloc_obj(*bridge, GFP_KERNEL);
 	if (!bridge)
 		return NULL;
 
diff --git a/drivers/char/agp/generic.c b/drivers/char/agp/generic.c
index 3ffbb1c80c5c..66ba14eac583 100644
--- a/drivers/char/agp/generic.c
+++ b/drivers/char/agp/generic.c
@@ -101,7 +101,7 @@ static struct agp_memory *agp_create_user_memory(unsigned long num_agp_pages)
 	if (INT_MAX/sizeof(struct page *) < num_agp_pages)
 		return NULL;
 
-	new = kzalloc(sizeof(struct agp_memory), GFP_KERNEL);
+	new = kzalloc_obj(struct agp_memory, GFP_KERNEL);
 	if (new == NULL)
 		return NULL;
 
@@ -127,7 +127,7 @@ struct agp_memory *agp_create_memory(int scratch_pages)
 {
 	struct agp_memory *new;
 
-	new = kzalloc(sizeof(struct agp_memory), GFP_KERNEL);
+	new = kzalloc_obj(struct agp_memory, GFP_KERNEL);
 	if (new == NULL)
 		return NULL;
 
diff --git a/drivers/char/agp/isoch.c b/drivers/char/agp/isoch.c
index 7ecf20a6d19c..b7deecb40922 100644
--- a/drivers/char/agp/isoch.c
+++ b/drivers/char/agp/isoch.c
@@ -92,7 +92,7 @@ static int agp_3_5_isochronous_node_enable(struct agp_bridge_data *bridge,
 	 * We'll work with an array of isoch_data's (one for each
 	 * device in dev_list) throughout this function.
 	 */
-	master = kmalloc_array(ndevs, sizeof(*master), GFP_KERNEL);
+	master = kmalloc_objs(*master, ndevs, GFP_KERNEL);
 	if (master == NULL) {
 		ret = -ENOMEM;
 		goto get_out;
@@ -333,7 +333,7 @@ int agp_3_5_enable(struct agp_bridge_data *bridge)
 	 * Allocate a head for our AGP 3.5 device list
 	 * (multiple AGP v3 devices are allowed behind a single bridge).
 	 */
-	if ((dev_list = kmalloc(sizeof(*dev_list), GFP_KERNEL)) == NULL) {
+	if ((dev_list = kmalloc_obj(*dev_list, GFP_KERNEL)) == NULL) {
 		ret = -ENOMEM;
 		goto get_out;
 	}
@@ -362,7 +362,7 @@ int agp_3_5_enable(struct agp_bridge_data *bridge)
 
 			case 0x0300:    /* Display controller */
 			case 0x0400:    /* Multimedia controller */
-				if ((cur = kmalloc(sizeof(*cur), GFP_KERNEL)) == NULL) {
+				if ((cur = kmalloc_obj(*cur, GFP_KERNEL)) == NULL) {
 					ret = -ENOMEM;
 					goto free_and_exit;
 				}
diff --git a/drivers/char/agp/sworks-agp.c b/drivers/char/agp/sworks-agp.c
index 0ab7562d17c9..03f21b90d368 100644
--- a/drivers/char/agp/sworks-agp.c
+++ b/drivers/char/agp/sworks-agp.c
@@ -96,13 +96,13 @@ static int serverworks_create_gatt_pages(int nr_tables)
 	int retval = 0;
 	int i;
 
-	tables = kcalloc(nr_tables + 1, sizeof(struct serverworks_page_map *),
-			 GFP_KERNEL);
+	tables = kzalloc_objs(struct serverworks_page_map *, nr_tables + 1,
+			      GFP_KERNEL);
 	if (tables == NULL)
 		return -ENOMEM;
 
 	for (i = 0; i < nr_tables; i++) {
-		entry = kzalloc(sizeof(struct serverworks_page_map), GFP_KERNEL);
+		entry = kzalloc_obj(struct serverworks_page_map, GFP_KERNEL);
 		if (entry == NULL) {
 			retval = -ENOMEM;
 			break;
diff --git a/drivers/char/agp/uninorth-agp.c b/drivers/char/agp/uninorth-agp.c
index b8d7115b8c9e..5d5ba7c7d9ba 100644
--- a/drivers/char/agp/uninorth-agp.c
+++ b/drivers/char/agp/uninorth-agp.c
@@ -404,9 +404,8 @@ static int uninorth_create_gatt_table(struct agp_bridge_data *bridge)
 	if (table == NULL)
 		return -ENOMEM;
 
-	uninorth_priv.pages_arr = kmalloc_array(1 << page_order,
-						sizeof(struct page *),
-						GFP_KERNEL);
+	uninorth_priv.pages_arr = kmalloc_objs(struct page *, 1 << page_order,
+					       GFP_KERNEL);
 	if (uninorth_priv.pages_arr == NULL)
 		goto enomem;
 
diff --git a/drivers/char/apm-emulation.c b/drivers/char/apm-emulation.c
index 4aa5d1c76f83..54e921eac4d3 100644
--- a/drivers/char/apm-emulation.c
+++ b/drivers/char/apm-emulation.c
@@ -343,7 +343,7 @@ static int apm_open(struct inode * inode, struct file * filp)
 {
 	struct apm_user *as;
 
-	as = kzalloc(sizeof(*as), GFP_KERNEL);
+	as = kzalloc_obj(*as, GFP_KERNEL);
 	if (as) {
 		/*
 		 * XXX - this is a tiny bit broken, when we consider BSD
diff --git a/drivers/char/bsr.c b/drivers/char/bsr.c
index 837109ef6766..57d236398a81 100644
--- a/drivers/char/bsr.c
+++ b/drivers/char/bsr.c
@@ -186,8 +186,7 @@ static int bsr_add_node(struct device_node *bn)
 	num_bsr_devs = bsr_bytes_len / sizeof(u32);
 
 	for (i = 0 ; i < num_bsr_devs; i++) {
-		struct bsr_dev *cur = kzalloc(sizeof(struct bsr_dev),
-					      GFP_KERNEL);
+		struct bsr_dev *cur = kzalloc_obj(struct bsr_dev, GFP_KERNEL);
 		struct resource res;
 		int result;
 
diff --git a/drivers/char/hpet.c b/drivers/char/hpet.c
index 4f5ccd3a1f56..1813e931c2b0 100644
--- a/drivers/char/hpet.c
+++ b/drivers/char/hpet.c
@@ -823,8 +823,7 @@ int hpet_alloc(struct hpet_data *hdp)
 		return 0;
 	}
 
-	hpetp = kzalloc(struct_size(hpetp, hp_dev, hdp->hd_nirqs),
-			GFP_KERNEL);
+	hpetp = kzalloc_flex(*hpetp, hp_dev, hdp->hd_nirqs, GFP_KERNEL);
 
 	if (!hpetp)
 		return -ENOMEM;
diff --git a/drivers/char/hw_random/amd-rng.c b/drivers/char/hw_random/amd-rng.c
index 9a24d19236dc..bc228e26929e 100644
--- a/drivers/char/hw_random/amd-rng.c
+++ b/drivers/char/hw_random/amd-rng.c
@@ -154,7 +154,7 @@ found:
 		goto put_dev;
 	}
 
-	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+	priv = kzalloc_obj(*priv, GFP_KERNEL);
 	if (!priv) {
 		err = -ENOMEM;
 		goto put_dev;
diff --git a/drivers/char/hw_random/geode-rng.c b/drivers/char/hw_random/geode-rng.c
index 159baf00a867..45e2696fad23 100644
--- a/drivers/char/hw_random/geode-rng.c
+++ b/drivers/char/hw_random/geode-rng.c
@@ -107,7 +107,7 @@ static int __init geode_rng_init(void)
 	return err;
 
 found:
-	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+	priv = kzalloc_obj(*priv, GFP_KERNEL);
 	if (!priv) {
 		err = -ENOMEM;
 		goto put_dev;
diff --git a/drivers/char/hw_random/intel-rng.c b/drivers/char/hw_random/intel-rng.c
index 7b171cb3b825..e18041c2610d 100644
--- a/drivers/char/hw_random/intel-rng.c
+++ b/drivers/char/hw_random/intel-rng.c
@@ -346,7 +346,7 @@ static int __init intel_rng_mod_init(void)
 		goto fwh_done;
 	}
 
-	intel_rng_hw = kmalloc(sizeof(*intel_rng_hw), GFP_KERNEL);
+	intel_rng_hw = kmalloc_obj(*intel_rng_hw, GFP_KERNEL);
 	if (!intel_rng_hw) {
 		pci_dev_put(dev);
 		goto out;
diff --git a/drivers/char/hw_random/virtio-rng.c b/drivers/char/hw_random/virtio-rng.c
index eb80a031c7be..ba35f83d5c31 100644
--- a/drivers/char/hw_random/virtio-rng.c
+++ b/drivers/char/hw_random/virtio-rng.c
@@ -134,7 +134,7 @@ static int probe_common(struct virtio_device *vdev)
 	int err, index;
 	struct virtrng_info *vi = NULL;
 
-	vi = kzalloc(sizeof(struct virtrng_info), GFP_KERNEL);
+	vi = kzalloc_obj(struct virtrng_info, GFP_KERNEL);
 	if (!vi)
 		return -ENOMEM;
 
diff --git a/drivers/char/ipmi/ipmb_dev_int.c b/drivers/char/ipmi/ipmb_dev_int.c
index ee2bdc7ed0da..2fe1d205ce4e 100644
--- a/drivers/char/ipmi/ipmb_dev_int.c
+++ b/drivers/char/ipmi/ipmb_dev_int.c
@@ -208,7 +208,7 @@ static void ipmb_handle_request(struct ipmb_dev *ipmb_dev)
 			REQUEST_QUEUE_MAX_LEN)
 		return;
 
-	queue_elem = kmalloc(sizeof(*queue_elem), GFP_ATOMIC);
+	queue_elem = kmalloc_obj(*queue_elem, GFP_ATOMIC);
 	if (!queue_elem)
 		return;
 
diff --git a/drivers/char/ipmi/ipmi_devintf.c b/drivers/char/ipmi/ipmi_devintf.c
index e6ba35b71f10..c8a4f261bd58 100644
--- a/drivers/char/ipmi/ipmi_devintf.c
+++ b/drivers/char/ipmi/ipmi_devintf.c
@@ -90,7 +90,7 @@ static int ipmi_open(struct inode *inode, struct file *file)
 	int                      rv;
 	struct ipmi_file_private *priv;
 
-	priv = kmalloc(sizeof(*priv), GFP_KERNEL);
+	priv = kmalloc_obj(*priv, GFP_KERNEL);
 	if (!priv)
 		return -ENOMEM;
 
@@ -813,7 +813,7 @@ static void ipmi_new_smi(int if_num, struct device *device)
 	dev_t dev = MKDEV(ipmi_major, if_num);
 	struct ipmi_reg_list *entry;
 
-	entry = kmalloc(sizeof(*entry), GFP_KERNEL);
+	entry = kmalloc_obj(*entry, GFP_KERNEL);
 	if (!entry) {
 		pr_err("ipmi_devintf: Unable to create the ipmi class device link\n");
 		return;
diff --git a/drivers/char/ipmi/ipmi_dmi.c b/drivers/char/ipmi/ipmi_dmi.c
index bbf7029e224b..2462d2557331 100644
--- a/drivers/char/ipmi/ipmi_dmi.c
+++ b/drivers/char/ipmi/ipmi_dmi.c
@@ -74,7 +74,7 @@ static void __init dmi_add_platform_ipmi(unsigned long base_addr,
 	p.slave_addr = slave_addr;
 	p.addr_source = SI_SMBIOS;
 
-	info = kmalloc(sizeof(*info), GFP_KERNEL);
+	info = kmalloc_obj(*info, GFP_KERNEL);
 	if (!info) {
 		pr_warn("Could not allocate dmi info\n");
 	} else {
diff --git a/drivers/char/ipmi/ipmi_msghandler.c b/drivers/char/ipmi/ipmi_msghandler.c
index 3f48fc6ab596..b4f05d15d2df 100644
--- a/drivers/char/ipmi/ipmi_msghandler.c
+++ b/drivers/char/ipmi/ipmi_msghandler.c
@@ -761,13 +761,11 @@ int ipmi_smi_watcher_register(struct ipmi_smi_watcher *watcher)
 	list_for_each_entry(intf, &ipmi_interfaces, link)
 		count++;
 	if (count > 0) {
-		interfaces = kmalloc_array(count, sizeof(*interfaces),
-					   GFP_KERNEL);
+		interfaces = kmalloc_objs(*interfaces, count, GFP_KERNEL);
 		if (!interfaces) {
 			rv = -ENOMEM;
 		} else {
-			devices = kmalloc_array(count, sizeof(*devices),
-						GFP_KERNEL);
+			devices = kmalloc_objs(*devices, count, GFP_KERNEL);
 			if (!devices) {
 				kfree(interfaces);
 				interfaces = NULL;
@@ -1686,7 +1684,7 @@ int ipmi_register_for_cmd(struct ipmi_user *user,
 	if (!user)
 		return -ENODEV;
 
-	rcvr = kmalloc(sizeof(*rcvr), GFP_KERNEL);
+	rcvr = kmalloc_obj(*rcvr, GFP_KERNEL);
 	if (!rcvr) {
 		rv = -ENOMEM;
 		goto out_release;
@@ -3146,7 +3144,7 @@ static int __ipmi_bmc_register(struct ipmi_smi *intf,
 			 bmc->id.product_id,
 			 bmc->id.device_id);
 	} else {
-		bmc = kzalloc(sizeof(*bmc), GFP_KERNEL);
+		bmc = kzalloc_obj(*bmc, GFP_KERNEL);
 		if (!bmc) {
 			rv = -ENOMEM;
 			goto out;
@@ -3582,7 +3580,7 @@ int ipmi_add_smi(struct module         *owner,
 	if (rv)
 		return rv;
 
-	intf = kzalloc(sizeof(*intf), GFP_KERNEL);
+	intf = kzalloc_obj(*intf, GFP_KERNEL);
 	if (!intf)
 		return -ENOMEM;
 
@@ -5195,7 +5193,7 @@ static void free_smi_msg(struct ipmi_smi_msg *msg)
 struct ipmi_smi_msg *ipmi_alloc_smi_msg(void)
 {
 	struct ipmi_smi_msg *rv;
-	rv = kmalloc(sizeof(struct ipmi_smi_msg), GFP_ATOMIC);
+	rv = kmalloc_obj(struct ipmi_smi_msg, GFP_ATOMIC);
 	if (rv) {
 		rv->done = free_smi_msg;
 		rv->recv_msg = NULL;
@@ -5225,7 +5223,7 @@ static struct ipmi_recv_msg *ipmi_alloc_recv_msg(struct ipmi_user *user)
 		}
 	}
 
-	rv = kmalloc(sizeof(struct ipmi_recv_msg), GFP_ATOMIC);
+	rv = kmalloc_obj(struct ipmi_recv_msg, GFP_ATOMIC);
 	if (!rv) {
 		if (user)
 			atomic_dec(&user->nr_msgs);
diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c
index 5459ffdde8dc..c6137eb56548 100644
--- a/drivers/char/ipmi/ipmi_si_intf.c
+++ b/drivers/char/ipmi/ipmi_si_intf.c
@@ -1914,7 +1914,7 @@ int ipmi_si_add_smi(struct si_sm_io *io)
 		}
 	}
 
-	new_smi = kzalloc(sizeof(*new_smi), GFP_KERNEL);
+	new_smi = kzalloc_obj(*new_smi, GFP_KERNEL);
 	if (!new_smi)
 		return -ENOMEM;
 	spin_lock_init(&new_smi->si_lock);
diff --git a/drivers/char/ipmi/ipmi_ssif.c b/drivers/char/ipmi/ipmi_ssif.c
index ef1582a029f4..579cf30cd52f 100644
--- a/drivers/char/ipmi/ipmi_ssif.c
+++ b/drivers/char/ipmi/ipmi_ssif.c
@@ -1602,7 +1602,7 @@ static int ssif_add_infos(struct i2c_client *client)
 {
 	struct ssif_addr_info *info;
 
-	info = kzalloc(sizeof(*info), GFP_KERNEL);
+	info = kzalloc_obj(*info, GFP_KERNEL);
 	if (!info)
 		return -ENOMEM;
 	info->addr_src = SI_ACPI;
@@ -1667,7 +1667,7 @@ static int ssif_probe(struct i2c_client *client)
 		return -ENOMEM;
 	}
 
-	ssif_info = kzalloc(sizeof(*ssif_info), GFP_KERNEL);
+	ssif_info = kzalloc_obj(*ssif_info, GFP_KERNEL);
 	if (!ssif_info) {
 		kfree(resp);
 		mutex_unlock(&ssif_infos_mutex);
@@ -1948,7 +1948,7 @@ static int new_ssif_client(int addr, char *adapter_name,
 		goto out_unlock;
 	}
 
-	addr_info = kzalloc(sizeof(*addr_info), GFP_KERNEL);
+	addr_info = kzalloc_obj(*addr_info, GFP_KERNEL);
 	if (!addr_info) {
 		rv = -ENOMEM;
 		goto out_unlock;
diff --git a/drivers/char/ipmi/kcs_bmc_serio.c b/drivers/char/ipmi/kcs_bmc_serio.c
index 1793358be782..4c3a70dc7425 100644
--- a/drivers/char/ipmi/kcs_bmc_serio.c
+++ b/drivers/char/ipmi/kcs_bmc_serio.c
@@ -77,7 +77,7 @@ static int kcs_bmc_serio_add_device(struct kcs_bmc_device *kcs_bmc)
 		return -ENOMEM;
 
 	/* Use kzalloc() as the allocation is cleaned up with kfree() via serio_unregister_port() */
-	port = kzalloc(sizeof(*port), GFP_KERNEL);
+	port = kzalloc_obj(*port, GFP_KERNEL);
 	if (!port)
 		return -ENOMEM;
 
diff --git a/drivers/char/powernv-op-panel.c b/drivers/char/powernv-op-panel.c
index 53467b0a6187..7405d645ff62 100644
--- a/drivers/char/powernv-op-panel.c
+++ b/drivers/char/powernv-op-panel.c
@@ -167,7 +167,7 @@ static int oppanel_probe(struct platform_device *pdev)
 	if (!oppanel_data)
 		return -ENOMEM;
 
-	oppanel_lines = kcalloc(num_lines, sizeof(oppanel_line_t), GFP_KERNEL);
+	oppanel_lines = kzalloc_objs(oppanel_line_t, num_lines, GFP_KERNEL);
 	if (!oppanel_lines) {
 		rc = -ENOMEM;
 		goto free_oppanel_data;
diff --git a/drivers/char/ppdev.c b/drivers/char/ppdev.c
index d1dfbd8d4d42..2468040d745f 100644
--- a/drivers/char/ppdev.c
+++ b/drivers/char/ppdev.c
@@ -689,7 +689,7 @@ static int pp_open(struct inode *inode, struct file *file)
 	if (minor >= PARPORT_MAX)
 		return -ENXIO;
 
-	pp = kmalloc(sizeof(struct pp_struct), GFP_KERNEL);
+	pp = kmalloc_obj(struct pp_struct, GFP_KERNEL);
 	if (!pp)
 		return -ENOMEM;
 
diff --git a/drivers/char/ps3flash.c b/drivers/char/ps3flash.c
index 23871cde41fb..5892d2b1cb72 100644
--- a/drivers/char/ps3flash.c
+++ b/drivers/char/ps3flash.c
@@ -361,7 +361,7 @@ static int ps3flash_probe(struct ps3_system_bus_device *_dev)
 
 	ps3flash_dev = dev;
 
-	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+	priv = kzalloc_obj(*priv, GFP_KERNEL);
 	if (!priv) {
 		error = -ENOMEM;
 		goto fail;
diff --git a/drivers/char/random.c b/drivers/char/random.c
index bab03c7c4194..91dc486b9ffa 100644
--- a/drivers/char/random.c
+++ b/drivers/char/random.c
@@ -1248,7 +1248,7 @@ void __cold rand_initialize_disk(struct gendisk *disk)
 	 * If kzalloc returns null, we just won't use that entropy
 	 * source.
 	 */
-	state = kzalloc(sizeof(struct timer_rand_state), GFP_KERNEL);
+	state = kzalloc_obj(struct timer_rand_state, GFP_KERNEL);
 	if (state) {
 		state->last_time = INITIAL_JIFFIES;
 		disk->random = state;
diff --git a/drivers/char/tlclk.c b/drivers/char/tlclk.c
index b381ea7e85d2..8f3dd530f56c 100644
--- a/drivers/char/tlclk.c
+++ b/drivers/char/tlclk.c
@@ -776,7 +776,7 @@ static int __init tlclk_init(void)
 
 	telclk_interrupt = (inb(TLCLK_REG7) & 0x0f);
 
-	alarm_events = kzalloc( sizeof(struct tlclk_alarms), GFP_KERNEL);
+	alarm_events = kzalloc_obj(struct tlclk_alarms, GFP_KERNEL);
 	if (!alarm_events) {
 		ret = -ENOMEM;
 		goto out1;
diff --git a/drivers/char/tpm/tpm-chip.c b/drivers/char/tpm/tpm-chip.c
index 082b910ddf0d..986990723db2 100644
--- a/drivers/char/tpm/tpm-chip.c
+++ b/drivers/char/tpm/tpm-chip.c
@@ -295,7 +295,7 @@ struct tpm_chip *tpm_chip_alloc(struct device *pdev,
 	struct tpm_chip *chip;
 	int rc;
 
-	chip = kzalloc(sizeof(*chip), GFP_KERNEL);
+	chip = kzalloc_obj(*chip, GFP_KERNEL);
 	if (chip == NULL)
 		return ERR_PTR(-ENOMEM);
 
diff --git a/drivers/char/tpm/tpm-dev.c b/drivers/char/tpm/tpm-dev.c
index 97c94b5e9340..bd197be15923 100644
--- a/drivers/char/tpm/tpm-dev.c
+++ b/drivers/char/tpm/tpm-dev.c
@@ -30,7 +30,7 @@ static int tpm_open(struct inode *inode, struct file *file)
 		return -EBUSY;
 	}
 
-	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+	priv = kzalloc_obj(*priv, GFP_KERNEL);
 	if (priv == NULL)
 		goto out;
 
diff --git a/drivers/char/tpm/tpm2-sessions.c b/drivers/char/tpm/tpm2-sessions.c
index 09df6353ef04..c00817faf88e 100644
--- a/drivers/char/tpm/tpm2-sessions.c
+++ b/drivers/char/tpm/tpm2-sessions.c
@@ -991,7 +991,7 @@ int tpm2_start_auth_session(struct tpm_chip *chip)
 		return 0;
 	}
 
-	auth = kzalloc(sizeof(*auth), GFP_KERNEL);
+	auth = kzalloc_obj(*auth, GFP_KERNEL);
 	if (!auth)
 		return -ENOMEM;
 
diff --git a/drivers/char/tpm/tpm_crb_ffa.c b/drivers/char/tpm/tpm_crb_ffa.c
index 755b77b32ea4..1bc1c6c2f257 100644
--- a/drivers/char/tpm/tpm_crb_ffa.c
+++ b/drivers/char/tpm/tpm_crb_ffa.c
@@ -346,7 +346,7 @@ static int tpm_crb_ffa_probe(struct ffa_device *ffa_dev)
 		return -EINVAL;
 	}
 
-	p = kzalloc(sizeof(*tpm_crb_ffa), GFP_KERNEL);
+	p = kzalloc_obj(*tpm_crb_ffa, GFP_KERNEL);
 	if (!p)
 		return -ENOMEM;
 	tpm_crb_ffa = p;
diff --git a/drivers/char/tpm/tpm_ibmvtpm.c b/drivers/char/tpm/tpm_ibmvtpm.c
index 4734a69406ce..2bd4e1dce322 100644
--- a/drivers/char/tpm/tpm_ibmvtpm.c
+++ b/drivers/char/tpm/tpm_ibmvtpm.c
@@ -611,7 +611,7 @@ static int tpm_ibmvtpm_probe(struct vio_dev *vio_dev,
 	if (IS_ERR(chip))
 		return PTR_ERR(chip);
 
-	ibmvtpm = kzalloc(sizeof(struct ibmvtpm_dev), GFP_KERNEL);
+	ibmvtpm = kzalloc_obj(struct ibmvtpm_dev, GFP_KERNEL);
 	if (!ibmvtpm) {
 		dev_err(dev, "kzalloc for ibmvtpm failed\n");
 		goto cleanup;
diff --git a/drivers/char/tpm/tpm_vtpm_proxy.c b/drivers/char/tpm/tpm_vtpm_proxy.c
index 0818bb517805..b84d745a9797 100644
--- a/drivers/char/tpm/tpm_vtpm_proxy.c
+++ b/drivers/char/tpm/tpm_vtpm_proxy.c
@@ -491,7 +491,7 @@ static struct proxy_dev *vtpm_proxy_create_proxy_dev(void)
 	struct tpm_chip *chip;
 	int err;
 
-	proxy_dev = kzalloc(sizeof(*proxy_dev), GFP_KERNEL);
+	proxy_dev = kzalloc_obj(*proxy_dev, GFP_KERNEL);
 	if (proxy_dev == NULL)
 		return ERR_PTR(-ENOMEM);
 
diff --git a/drivers/char/tpm/tpmrm-dev.c b/drivers/char/tpm/tpmrm-dev.c
index c25df7ea064e..cace5bc7369a 100644
--- a/drivers/char/tpm/tpmrm-dev.c
+++ b/drivers/char/tpm/tpmrm-dev.c
@@ -17,7 +17,7 @@ static int tpmrm_open(struct inode *inode, struct file *file)
 	int rc;
 
 	chip = container_of(inode->i_cdev, struct tpm_chip, cdevs);
-	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+	priv = kzalloc_obj(*priv, GFP_KERNEL);
 	if (priv == NULL)
 		return -ENOMEM;
 
diff --git a/drivers/char/tpm/xen-tpmfront.c b/drivers/char/tpm/xen-tpmfront.c
index 556bf2256716..c1a4a5531b0a 100644
--- a/drivers/char/tpm/xen-tpmfront.c
+++ b/drivers/char/tpm/xen-tpmfront.c
@@ -338,7 +338,7 @@ static int tpmfront_probe(struct xenbus_device *dev,
 	struct tpm_private *priv;
 	int rv;
 
-	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+	priv = kzalloc_obj(*priv, GFP_KERNEL);
 	if (!priv) {
 		xenbus_dev_fatal(dev, -ENOMEM, "allocating priv structure");
 		return -ENOMEM;
diff --git a/drivers/char/virtio_console.c b/drivers/char/virtio_console.c
index 088182e54deb..2c1c864a9de9 100644
--- a/drivers/char/virtio_console.c
+++ b/drivers/char/virtio_console.c
@@ -412,7 +412,7 @@ static struct port_buffer *alloc_buf(struct virtio_device *vdev, size_t buf_size
 	 * Allocate buffer and the sg list. The sg list array is allocated
 	 * directly after the port_buffer struct.
 	 */
-	buf = kmalloc(struct_size(buf, sg, pages), GFP_KERNEL);
+	buf = kmalloc_flex(*buf, sg, pages, GFP_KERNEL);
 	if (!buf)
 		goto fail;
 
@@ -1325,7 +1325,7 @@ static int add_port(struct ports_device *portdev, u32 id)
 	dev_t devt;
 	int err;
 
-	port = kmalloc(sizeof(*port), GFP_KERNEL);
+	port = kmalloc_obj(*port, GFP_KERNEL);
 	if (!port) {
 		err = -ENOMEM;
 		goto fail;
@@ -1809,12 +1809,11 @@ static int init_vqs(struct ports_device *portdev)
 	nr_ports = portdev->max_nr_ports;
 	nr_queues = use_multiport(portdev) ? (nr_ports + 1) * 2 : 2;
 
-	vqs = kmalloc_array(nr_queues, sizeof(struct virtqueue *), GFP_KERNEL);
-	vqs_info = kcalloc(nr_queues, sizeof(*vqs_info), GFP_KERNEL);
-	portdev->in_vqs = kmalloc_array(nr_ports, sizeof(struct virtqueue *),
+	vqs = kmalloc_objs(struct virtqueue *, nr_queues, GFP_KERNEL);
+	vqs_info = kzalloc_objs(*vqs_info, nr_queues, GFP_KERNEL);
+	portdev->in_vqs = kmalloc_objs(struct virtqueue *, nr_ports, GFP_KERNEL);
+	portdev->out_vqs = kmalloc_objs(struct virtqueue *, nr_ports,
 					GFP_KERNEL);
-	portdev->out_vqs = kmalloc_array(nr_ports, sizeof(struct virtqueue *),
-					 GFP_KERNEL);
 	if (!vqs || !vqs_info || !portdev->in_vqs || !portdev->out_vqs) {
 		err = -ENOMEM;
 		goto free;
@@ -1965,7 +1964,7 @@ static int virtcons_probe(struct virtio_device *vdev)
 		return -EINVAL;
 	}
 
-	portdev = kmalloc(sizeof(*portdev), GFP_KERNEL);
+	portdev = kmalloc_obj(*portdev, GFP_KERNEL);
 	if (!portdev) {
 		err = -ENOMEM;
 		goto fail;
diff --git a/drivers/char/xillybus/xillybus_class.c b/drivers/char/xillybus/xillybus_class.c
index c92a628e389e..4bc5a2152abb 100644
--- a/drivers/char/xillybus/xillybus_class.c
+++ b/drivers/char/xillybus/xillybus_class.c
@@ -57,7 +57,7 @@ int xillybus_init_chrdev(struct device *dev,
 	size_t namelen;
 	struct xilly_unit *unit, *u;
 
-	unit = kzalloc(sizeof(*unit), GFP_KERNEL);
+	unit = kzalloc_obj(*unit, GFP_KERNEL);
 
 	if (!unit)
 		return -ENOMEM;
diff --git a/drivers/char/xillybus/xillybus_core.c b/drivers/char/xillybus/xillybus_core.c
index fc4e69b5cb6a..86dccc6009f8 100644
--- a/drivers/char/xillybus/xillybus_core.c
+++ b/drivers/char/xillybus/xillybus_core.c
@@ -319,7 +319,7 @@ static int xilly_map_single(struct xilly_endpoint *ep,
 	dma_addr_t addr;
 	struct xilly_mapping *this;
 
-	this = kzalloc(sizeof(*this), GFP_KERNEL);
+	this = kzalloc_obj(*this, GFP_KERNEL);
 	if (!this)
 		return -ENOMEM;
 
diff --git a/drivers/char/xillybus/xillyusb.c b/drivers/char/xillybus/xillyusb.c
index 386531474213..568e82b73823 100644
--- a/drivers/char/xillybus/xillyusb.c
+++ b/drivers/char/xillybus/xillyusb.c
@@ -495,7 +495,7 @@ static struct xillyusb_endpoint
 
 	struct xillyusb_endpoint *ep;
 
-	ep = kzalloc(sizeof(*ep), GFP_KERNEL);
+	ep = kzalloc_obj(*ep, GFP_KERNEL);
 
 	if (!ep)
 		return NULL;
@@ -522,7 +522,7 @@ static struct xillyusb_endpoint
 		struct xillybuffer *xb;
 		unsigned long addr;
 
-		xb = kzalloc(sizeof(*xb), GFP_KERNEL);
+		xb = kzalloc_obj(*xb, GFP_KERNEL);
 
 		if (!xb) {
 			endpoint_dealloc(ep);
@@ -1336,7 +1336,7 @@ static int xillyusb_open(struct inode *inode, struct file *filp)
 	}
 
 	if (filp->f_mode & FMODE_READ) {
-		in_fifo = kzalloc(sizeof(*in_fifo), GFP_KERNEL);
+		in_fifo = kzalloc_obj(*in_fifo, GFP_KERNEL);
 
 		if (!in_fifo) {
 			rc = -ENOMEM;
@@ -1943,7 +1943,7 @@ static int setup_channels(struct xillyusb_dev *xdev,
 	struct xillyusb_channel *chan, *new_channels;
 	int i;
 
-	chan = kcalloc(num_channels, sizeof(*chan), GFP_KERNEL);
+	chan = kzalloc_objs(*chan, num_channels, GFP_KERNEL);
 	if (!chan)
 		return -ENOMEM;
 
@@ -2149,7 +2149,7 @@ static int xillyusb_probe(struct usb_interface *interface,
 	struct xillyusb_dev *xdev;
 	int rc;
 
-	xdev = kzalloc(sizeof(*xdev), GFP_KERNEL);
+	xdev = kzalloc_obj(*xdev, GFP_KERNEL);
 	if (!xdev)
 		return -ENOMEM;