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>

14 files changed, 40 insertions, 42 deletions

diff --git a/drivers/virt/acrn/hsm.c b/drivers/virt/acrn/hsm.c
index e4e196abdaac..c73a566d135d 100644
--- a/drivers/virt/acrn/hsm.c
+++ b/drivers/virt/acrn/hsm.c
@@ -30,7 +30,7 @@ static int acrn_dev_open(struct inode *inode, struct file *filp)
 {
 	struct acrn_vm *vm;
 
-	vm = kzalloc(sizeof(*vm), GFP_KERNEL);
+	vm = kzalloc_obj(*vm, GFP_KERNEL);
 	if (!vm)
 		return -ENOMEM;
 
@@ -64,7 +64,7 @@ static int pmcmd_ioctl(u64 cmd, void __user *uptr)
 		kfree(pm_info);
 		break;
 	case ACRN_PMCMD_GET_PX_DATA:
-		px_data = kzalloc(sizeof(*px_data), GFP_KERNEL);
+		px_data = kzalloc_obj(*px_data, GFP_KERNEL);
 		if (!px_data)
 			return -ENOMEM;
 
@@ -79,7 +79,7 @@ static int pmcmd_ioctl(u64 cmd, void __user *uptr)
 		kfree(px_data);
 		break;
 	case ACRN_PMCMD_GET_CX_DATA:
-		cx_data = kzalloc(sizeof(*cx_data), GFP_KERNEL);
+		cx_data = kzalloc_obj(*cx_data, GFP_KERNEL);
 		if (!cx_data)
 			return -ENOMEM;
 
diff --git a/drivers/virt/acrn/ioeventfd.c b/drivers/virt/acrn/ioeventfd.c
index 4e845c6ca0b5..5daccfaa127b 100644
--- a/drivers/virt/acrn/ioeventfd.c
+++ b/drivers/virt/acrn/ioeventfd.c
@@ -96,7 +96,7 @@ static int acrn_ioeventfd_assign(struct acrn_vm *vm,
 	if (IS_ERR(eventfd))
 		return PTR_ERR(eventfd);
 
-	p = kzalloc(sizeof(*p), GFP_KERNEL);
+	p = kzalloc_obj(*p, GFP_KERNEL);
 	if (!p) {
 		ret = -ENOMEM;
 		goto fail;
diff --git a/drivers/virt/acrn/ioreq.c b/drivers/virt/acrn/ioreq.c
index 55ddfa4840af..2216e62406e0 100644
--- a/drivers/virt/acrn/ioreq.c
+++ b/drivers/virt/acrn/ioreq.c
@@ -123,7 +123,7 @@ int acrn_ioreq_range_add(struct acrn_ioreq_client *client,
 		return -EINVAL;
 	}
 
-	range = kzalloc(sizeof(*range), GFP_KERNEL);
+	range = kzalloc_obj(*range, GFP_KERNEL);
 	if (!range)
 		return -ENOMEM;
 
@@ -424,7 +424,7 @@ struct acrn_ioreq_client *acrn_ioreq_client_create(struct acrn_vm *vm,
 			"Cannot create non-default client w/o handler!\n");
 		return NULL;
 	}
-	client = kzalloc(sizeof(*client), GFP_KERNEL);
+	client = kzalloc_obj(*client, GFP_KERNEL);
 	if (!client)
 		return NULL;
 
@@ -602,7 +602,7 @@ int acrn_ioreq_init(struct acrn_vm *vm, u64 buf_vma)
 	if (vm->ioreq_buf)
 		return -EEXIST;
 
-	set_buffer = kzalloc(sizeof(*set_buffer), GFP_KERNEL);
+	set_buffer = kzalloc_obj(*set_buffer, GFP_KERNEL);
 	if (!set_buffer)
 		return -ENOMEM;
 
diff --git a/drivers/virt/acrn/irqfd.c b/drivers/virt/acrn/irqfd.c
index 64d32c8fbf79..f0ff5140699f 100644
--- a/drivers/virt/acrn/irqfd.c
+++ b/drivers/virt/acrn/irqfd.c
@@ -112,7 +112,7 @@ static int acrn_irqfd_assign(struct acrn_vm *vm, struct acrn_irqfd *args)
 	__poll_t events;
 	int ret = 0;
 
-	irqfd = kzalloc(sizeof(*irqfd), GFP_KERNEL);
+	irqfd = kzalloc_obj(*irqfd, GFP_KERNEL);
 	if (!irqfd)
 		return -ENOMEM;
 
diff --git a/drivers/virt/acrn/mm.c b/drivers/virt/acrn/mm.c
index bfb3031885e8..86b386761ee3 100644
--- a/drivers/virt/acrn/mm.c
+++ b/drivers/virt/acrn/mm.c
@@ -21,7 +21,7 @@ static int modify_region(struct acrn_vm *vm, struct vm_memory_region_op *region)
 	struct vm_memory_region_batch *regions;
 	int ret;
 
-	regions = kzalloc(sizeof(*regions), GFP_KERNEL);
+	regions = kzalloc_obj(*regions, GFP_KERNEL);
 	if (!regions)
 		return -ENOMEM;
 
@@ -55,7 +55,7 @@ int acrn_mm_region_add(struct acrn_vm *vm, u64 user_gpa, u64 service_gpa,
 	struct vm_memory_region_op *region;
 	int ret = 0;
 
-	region = kzalloc(sizeof(*region), GFP_KERNEL);
+	region = kzalloc_obj(*region, GFP_KERNEL);
 	if (!region)
 		return -ENOMEM;
 
@@ -87,7 +87,7 @@ int acrn_mm_region_del(struct acrn_vm *vm, u64 user_gpa, u64 size)
 	struct vm_memory_region_op *region;
 	int ret = 0;
 
-	region = kzalloc(sizeof(*region), GFP_KERNEL);
+	region = kzalloc_obj(*region, GFP_KERNEL);
 	if (!region)
 		return -ENOMEM;
 
@@ -285,8 +285,8 @@ int acrn_vm_ram_map(struct acrn_vm *vm, struct acrn_vm_memmap *memmap)
 	}
 
 	/* Prepare the vm_memory_region_batch */
-	regions_info = kzalloc(struct_size(regions_info, regions_op,
-					   nr_regions), GFP_KERNEL);
+	regions_info = kzalloc_flex(*regions_info, regions_op, nr_regions,
+				    GFP_KERNEL);
 	if (!regions_info) {
 		ret = -ENOMEM;
 		goto unmap_kernel_map;
diff --git a/drivers/virt/acrn/vm.c b/drivers/virt/acrn/vm.c
index fbc9f1042000..3753b27c5312 100644
--- a/drivers/virt/acrn/vm.c
+++ b/drivers/virt/acrn/vm.c
@@ -107,7 +107,7 @@ int acrn_msi_inject(struct acrn_vm *vm, u64 msi_addr, u64 msi_data)
 	int ret;
 
 	/* might be used in interrupt context, so use GFP_ATOMIC */
-	msi = kzalloc(sizeof(*msi), GFP_ATOMIC);
+	msi = kzalloc_obj(*msi, GFP_ATOMIC);
 	if (!msi)
 		return -ENOMEM;
 
diff --git a/drivers/virt/coco/guest/report.c b/drivers/virt/coco/guest/report.c
index d3d18fc22bc2..ab50adfec7ec 100644
--- a/drivers/virt/coco/guest/report.c
+++ b/drivers/virt/coco/guest/report.c
@@ -428,7 +428,7 @@ static struct config_item *tsm_report_make_item(struct config_group *group,
 	if (!provider.ops)
 		return ERR_PTR(-ENXIO);
 
-	state = kzalloc(sizeof(*state), GFP_KERNEL);
+	state = kzalloc_obj(*state, GFP_KERNEL);
 	if (!state)
 		return ERR_PTR(-ENOMEM);
 
diff --git a/drivers/virt/coco/guest/tsm-mr.c b/drivers/virt/coco/guest/tsm-mr.c
index bc509df04db1..37859cc8eefb 100644
--- a/drivers/virt/coco/guest/tsm-mr.c
+++ b/drivers/virt/coco/guest/tsm-mr.c
@@ -176,7 +176,7 @@ tsm_mr_create_attribute_group(const struct tsm_measurements *tm)
 	const struct bin_attribute **attrs __free(kfree) =
 		kzalloc(sizeof(*attrs) * (tm->nr_mrs + 1) + nlen, GFP_KERNEL);
 	struct tm_context *ctx __free(kfree) =
-		kzalloc(struct_size(ctx, mrs, tm->nr_mrs), GFP_KERNEL);
+		kzalloc_flex(*ctx, mrs, tm->nr_mrs, GFP_KERNEL);
 	char *name, *end;
 
 	if (!ctx || !attrs)
diff --git a/drivers/virt/coco/sev-guest/sev-guest.c b/drivers/virt/coco/sev-guest/sev-guest.c
index b01ec99106cd..e001e6769a43 100644
--- a/drivers/virt/coco/sev-guest/sev-guest.c
+++ b/drivers/virt/coco/sev-guest/sev-guest.c
@@ -75,7 +75,7 @@ static int get_report(struct snp_guest_dev *snp_dev, struct snp_guest_request_io
 	if (!arg->req_data || !arg->resp_data)
 		return -EINVAL;
 
-	report_req = kzalloc(sizeof(*report_req), GFP_KERNEL_ACCOUNT);
+	report_req = kzalloc_obj(*report_req, GFP_KERNEL_ACCOUNT);
 	if (!report_req)
 		return -ENOMEM;
 
@@ -135,7 +135,7 @@ static int get_derived_key(struct snp_guest_dev *snp_dev, struct snp_guest_reque
 	if (!derived_key_resp)
 		return -ENOMEM;
 
-	derived_key_req = kzalloc(sizeof(*derived_key_req), GFP_KERNEL_ACCOUNT);
+	derived_key_req = kzalloc_obj(*derived_key_req, GFP_KERNEL_ACCOUNT);
 	if (!derived_key_req)
 		return -ENOMEM;
 
@@ -181,7 +181,7 @@ static int get_ext_report(struct snp_guest_dev *snp_dev, struct snp_guest_reques
 	if (sockptr_is_null(io->req_data) || sockptr_is_null(io->resp_data))
 		return -EINVAL;
 
-	report_req = kzalloc(sizeof(*report_req), GFP_KERNEL_ACCOUNT);
+	report_req = kzalloc_obj(*report_req, GFP_KERNEL_ACCOUNT);
 	if (!report_req)
 		return -ENOMEM;
 
diff --git a/drivers/virt/coco/tsm-core.c b/drivers/virt/coco/tsm-core.c
index 8712df8596a1..b783fd36fc7e 100644
--- a/drivers/virt/coco/tsm-core.c
+++ b/drivers/virt/coco/tsm-core.c
@@ -35,7 +35,7 @@ static struct tsm_dev *alloc_tsm_dev(struct device *parent)
 	int id;
 
 	struct tsm_dev *tsm_dev __free(kfree) =
-		kzalloc(sizeof(*tsm_dev), GFP_KERNEL);
+		kzalloc_obj(*tsm_dev, GFP_KERNEL);
 	if (!tsm_dev)
 		return ERR_PTR(-ENOMEM);
 
diff --git a/drivers/virt/fsl_hypervisor.c b/drivers/virt/fsl_hypervisor.c
index e92e2ceb12a4..541ee3a4909c 100644
--- a/drivers/virt/fsl_hypervisor.c
+++ b/drivers/virt/fsl_hypervisor.c
@@ -226,7 +226,7 @@ static long ioctl_memcpy(struct fsl_hv_ioctl_memcpy __user *p)
 	 * 'pages' is an array of struct page pointers that's initialized by
 	 * get_user_pages_fast().
 	 */
-	pages = kcalloc(num_pages, sizeof(struct page *), GFP_KERNEL);
+	pages = kzalloc_objs(struct page *, num_pages, GFP_KERNEL);
 	if (!pages) {
 		pr_debug("fsl-hv: could not allocate page list\n");
 		return -ENOMEM;
@@ -660,7 +660,7 @@ static int fsl_hv_open(struct inode *inode, struct file *filp)
 	struct doorbell_queue *dbq;
 	unsigned long flags;
 
-	dbq = kzalloc(sizeof(struct doorbell_queue), GFP_KERNEL);
+	dbq = kzalloc_obj(struct doorbell_queue, GFP_KERNEL);
 	if (!dbq) {
 		pr_err("fsl-hv: out of memory\n");
 		return -ENOMEM;
@@ -845,7 +845,7 @@ static int __init fsl_hypervisor_init(void)
 			continue;
 		}
 
-		dbisr = kzalloc(sizeof(*dbisr), GFP_KERNEL);
+		dbisr = kzalloc_obj(*dbisr, GFP_KERNEL);
 		if (!dbisr)
 			goto out_of_memory;
 
diff --git a/drivers/virt/nitro_enclaves/ne_misc_dev.c b/drivers/virt/nitro_enclaves/ne_misc_dev.c
index 241b94f62e56..1ad44e92348a 100644
--- a/drivers/virt/nitro_enclaves/ne_misc_dev.c
+++ b/drivers/virt/nitro_enclaves/ne_misc_dev.c
@@ -294,9 +294,9 @@ static int ne_setup_cpu_pool(const char *ne_cpu_list)
 
 	ne_cpu_pool.nr_parent_vm_cores = nr_cpu_ids / ne_cpu_pool.nr_threads_per_core;
 
-	ne_cpu_pool.avail_threads_per_core = kcalloc(ne_cpu_pool.nr_parent_vm_cores,
-						     sizeof(*ne_cpu_pool.avail_threads_per_core),
-						     GFP_KERNEL);
+	ne_cpu_pool.avail_threads_per_core = kzalloc_objs(*ne_cpu_pool.avail_threads_per_core,
+							  ne_cpu_pool.nr_parent_vm_cores,
+							  GFP_KERNEL);
 	if (!ne_cpu_pool.avail_threads_per_core) {
 		rc = -ENOMEM;
 
@@ -928,23 +928,22 @@ static int ne_set_user_memory_region_ioctl(struct ne_enclave *ne_enclave,
 	if (rc < 0)
 		return rc;
 
-	ne_mem_region = kzalloc(sizeof(*ne_mem_region), GFP_KERNEL);
+	ne_mem_region = kzalloc_obj(*ne_mem_region, GFP_KERNEL);
 	if (!ne_mem_region)
 		return -ENOMEM;
 
 	max_nr_pages = mem_region.memory_size / NE_MIN_MEM_REGION_SIZE;
 
-	ne_mem_region->pages = kcalloc(max_nr_pages, sizeof(*ne_mem_region->pages),
-				       GFP_KERNEL);
+	ne_mem_region->pages = kzalloc_objs(*ne_mem_region->pages, max_nr_pages,
+					    GFP_KERNEL);
 	if (!ne_mem_region->pages) {
 		rc = -ENOMEM;
 
 		goto free_mem_region;
 	}
 
-	phys_contig_mem_regions.regions = kcalloc(max_nr_pages,
-						  sizeof(*phys_contig_mem_regions.regions),
-						  GFP_KERNEL);
+	phys_contig_mem_regions.regions = kzalloc_objs(*phys_contig_mem_regions.regions,
+						       max_nr_pages, GFP_KERNEL);
 	if (!phys_contig_mem_regions.regions) {
 		rc = -ENOMEM;
 
@@ -1617,7 +1616,7 @@ static int ne_create_vm_ioctl(struct ne_pci_dev *ne_pci_dev, u64 __user *slot_ui
 
 	mutex_unlock(&ne_cpu_pool.mutex);
 
-	ne_enclave = kzalloc(sizeof(*ne_enclave), GFP_KERNEL);
+	ne_enclave = kzalloc_obj(*ne_enclave, GFP_KERNEL);
 	if (!ne_enclave)
 		return -ENOMEM;
 
@@ -1629,9 +1628,9 @@ static int ne_create_vm_ioctl(struct ne_pci_dev *ne_pci_dev, u64 __user *slot_ui
 
 	mutex_unlock(&ne_cpu_pool.mutex);
 
-	ne_enclave->threads_per_core = kcalloc(ne_enclave->nr_parent_vm_cores,
-					       sizeof(*ne_enclave->threads_per_core),
-					       GFP_KERNEL);
+	ne_enclave->threads_per_core = kzalloc_objs(*ne_enclave->threads_per_core,
+						    ne_enclave->nr_parent_vm_cores,
+						    GFP_KERNEL);
 	if (!ne_enclave->threads_per_core) {
 		rc = -ENOMEM;
 
diff --git a/drivers/virt/nitro_enclaves/ne_pci_dev.c b/drivers/virt/nitro_enclaves/ne_pci_dev.c
index 6b81e8f3a5dc..a219657ace80 100644
--- a/drivers/virt/nitro_enclaves/ne_pci_dev.c
+++ b/drivers/virt/nitro_enclaves/ne_pci_dev.c
@@ -468,7 +468,7 @@ static int ne_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
 	struct ne_pci_dev *ne_pci_dev = NULL;
 	int rc = -EINVAL;
 
-	ne_pci_dev = kzalloc(sizeof(*ne_pci_dev), GFP_KERNEL);
+	ne_pci_dev = kzalloc_obj(*ne_pci_dev, GFP_KERNEL);
 	if (!ne_pci_dev)
 		return -ENOMEM;
 
diff --git a/drivers/virt/vboxguest/vboxguest_core.c b/drivers/virt/vboxguest/vboxguest_core.c
index b177a534b6a4..9621606fc5db 100644
--- a/drivers/virt/vboxguest/vboxguest_core.c
+++ b/drivers/virt/vboxguest/vboxguest_core.c
@@ -74,7 +74,7 @@ static void vbg_guest_mappings_init(struct vbg_dev *gdev)
 	/* Add 4M so that we can align the vmap to 4MiB as the host requires. */
 	size = PAGE_ALIGN(req->hypervisor_size) + SZ_4M;
 
-	pages = kmalloc_array(size >> PAGE_SHIFT, sizeof(*pages), GFP_KERNEL);
+	pages = kmalloc_objs(*pages, size >> PAGE_SHIFT, GFP_KERNEL);
 	if (!pages)
 		goto out;
 
@@ -275,9 +275,8 @@ static int vbg_balloon_inflate(struct vbg_dev *gdev, u32 chunk_idx)
 	struct page **pages;
 	int i, rc, ret;
 
-	pages = kmalloc_array(VMMDEV_MEMORY_BALLOON_CHUNK_PAGES,
-			      sizeof(*pages),
-			      GFP_KERNEL | __GFP_NOWARN);
+	pages = kmalloc_objs(*pages, VMMDEV_MEMORY_BALLOON_CHUNK_PAGES,
+			     GFP_KERNEL | __GFP_NOWARN);
 	if (!pages)
 		return -ENOMEM;
 
@@ -1081,7 +1080,7 @@ struct vbg_session *vbg_core_open_session(struct vbg_dev *gdev, u32 requestor)
 {
 	struct vbg_session *session;
 
-	session = kzalloc(sizeof(*session), GFP_KERNEL);
+	session = kzalloc_obj(*session, GFP_KERNEL);
 	if (!session)
 		return ERR_PTR(-ENOMEM);