Convert more 'alloc_obj' cases to default GFP_KERNEL arguments

This converts some of the visually simpler cases that have been split
over multiple lines. I only did the ones that are easy to verify the
resulting diff by having just that final GFP_KERNEL argument on the next
line.

Somebody should probably do a proper coccinelle script for this, but for
me the trivial script actually resulted in an assertion failure in the
middle of the script. I probably had made it a bit _too_ trivial.

So after fighting that far a while I decided to just do some of the
syntactically simpler cases with variations of the previous 'sed'
scripts.

The more syntactically complex multi-line cases would mostly really want
whitespace cleanup anyway.

Signed-off-by: Linus Torvalds <[e-mail]>

arch/arm/mach-omap1/mcbsp.c

···
 {
 	int i;
 
-	omap_mcbsp_devices = kzalloc_objs(struct platform_device *, size,
-					  GFP_KERNEL);
+	omap_mcbsp_devices = kzalloc_objs(struct platform_device *, size);
 	if (!omap_mcbsp_devices) {
 		printk(KERN_ERR "Could not register McBSP devices\n");
 		return;

arch/arm64/kernel/vdso.c

···
 			vdso_info[abi].vdso_code_start) >>
 			PAGE_SHIFT;
 
-	vdso_pagelist = kzalloc_objs(struct page *, vdso_info[abi].vdso_pages,
-				     GFP_KERNEL);
+	vdso_pagelist = kzalloc_objs(struct page *, vdso_info[abi].vdso_pages);
 	if (vdso_pagelist == NULL)
 		return -ENOMEM;
 

arch/loongarch/kernel/vdso.c

···
 
 	vdso_info.size = PAGE_ALIGN(vdso_end - vdso_start);
 	vdso_info.code_mapping.pages =
-		kzalloc_objs(struct page *, vdso_info.size / PAGE_SIZE,
-			     GFP_KERNEL);
+		kzalloc_objs(struct page *, vdso_info.size / PAGE_SIZE);
 
 	if (!vdso_info.code_mapping.pages)
 		return -ENOMEM;

arch/powerpc/kvm/book3s_pr.c

···
 	vcpu->arch.book3s = vcpu_book3s;
 
 #ifdef CONFIG_KVM_BOOK3S_32_HANDLER
-	vcpu->arch.shadow_vcpu = kzalloc_obj(*vcpu->arch.shadow_vcpu,
-					     GFP_KERNEL);
+	vcpu->arch.shadow_vcpu = kzalloc_obj(*vcpu->arch.shadow_vcpu);
 	if (!vcpu->arch.shadow_vcpu)
 		goto free_vcpu3s;
 #endif

arch/powerpc/mm/book3s64/mmu_context.c

···
 {
 	int index;
 
-	mm->context.hash_context = kmalloc_obj(struct hash_mm_context,
-					       GFP_KERNEL);
+	mm->context.hash_context = kmalloc_obj(struct hash_mm_context);
 	if (!mm->context.hash_context)
 		return -ENOMEM;
 
···
 #ifdef CONFIG_PPC_SUBPAGE_PROT
 		/* inherit subpage prot details if we have one. */
 		if (current->mm->context.hash_context->spt) {
-			mm->context.hash_context->spt = kmalloc_obj(struct subpage_prot_table,
-								    GFP_KERNEL);
+			mm->context.hash_context->spt = kmalloc_obj(struct subpage_prot_table);
 			if (!mm->context.hash_context->spt) {
 				kfree(mm->context.hash_context);
 				return -ENOMEM;

arch/powerpc/perf/hv-24x7.c

···
 		goto e_event_attrs;
 	}
 
-	event_long_descs = kmalloc_objs(*event_long_descs, event_idx + 1,
-					GFP_KERNEL);
+	event_long_descs = kmalloc_objs(*event_long_descs, event_idx + 1);
 	if (!event_long_descs) {
 		ret = -ENOMEM;
 		goto e_event_descs;

arch/powerpc/perf/imc-pmu.c

···
 {
 	int nid, i, cpu;
 
-	nest_imc_refc = kzalloc_objs(*nest_imc_refc, num_possible_nodes(),
-				     GFP_KERNEL);
+	nest_imc_refc = kzalloc_objs(*nest_imc_refc, num_possible_nodes());
 
 	if (!nest_imc_refc)
 		return -ENOMEM;
···
 			goto err;
 
 		nr_cores = DIV_ROUND_UP(num_possible_cpus(), threads_per_core);
-		pmu_ptr->mem_info = kzalloc_objs(struct imc_mem_info, nr_cores,
-						 GFP_KERNEL);
+		pmu_ptr->mem_info = kzalloc_objs(struct imc_mem_info, nr_cores);
 
 		if (!pmu_ptr->mem_info)
 			goto err;
 
-		core_imc_refc = kzalloc_objs(struct imc_pmu_ref, nr_cores,
-					     GFP_KERNEL);
+		core_imc_refc = kzalloc_objs(struct imc_pmu_ref, nr_cores);
 
 		if (!core_imc_refc) {
 			kfree(pmu_ptr->mem_info);
···
 			return -ENOMEM;
 
 		nr_cores = DIV_ROUND_UP(num_possible_cpus(), threads_per_core);
-		trace_imc_refc = kzalloc_objs(struct imc_pmu_ref, nr_cores,
-					      GFP_KERNEL);
+		trace_imc_refc = kzalloc_objs(struct imc_pmu_ref, nr_cores);
 		if (!trace_imc_refc)
 			return -ENOMEM;
 

arch/powerpc/platforms/powernv/idle.c

···
 	nr_idle_states = of_property_count_u32_elems(np,
 						"ibm,cpu-idle-state-flags");
 
-	pnv_idle_states = kzalloc_objs(*pnv_idle_states, nr_idle_states,
-				       GFP_KERNEL);
+	pnv_idle_states = kzalloc_objs(*pnv_idle_states, nr_idle_states);
 	temp_u32 = kcalloc(nr_idle_states, sizeof(u32),  GFP_KERNEL);
 	temp_u64 = kcalloc(nr_idle_states, sizeof(u64),  GFP_KERNEL);
 	temp_string = kcalloc(nr_idle_states, sizeof(char *),  GFP_KERNEL);

arch/powerpc/platforms/powernv/memtrace.c

···
 	u32 nid;
 	u64 m;
 
-	memtrace_array = kzalloc_objs(struct memtrace_entry, num_online_nodes(),
-				      GFP_KERNEL);
+	memtrace_array = kzalloc_objs(struct memtrace_entry, num_online_nodes());
 	if (!memtrace_array) {
 		pr_err("Failed to allocate memtrace_array\n");
 		return -EINVAL;

arch/powerpc/platforms/powernv/opal-imc.c

···
 								nr_chips))
 		goto error;
 
-	pmu_ptr->mem_info = kzalloc_objs(*pmu_ptr->mem_info, nr_chips + 1,
-					 GFP_KERNEL);
+	pmu_ptr->mem_info = kzalloc_objs(*pmu_ptr->mem_info, nr_chips + 1);
 	if (!pmu_ptr->mem_info)
 		goto error;
 

arch/powerpc/platforms/powernv/opal-powercap.c

···
 			has_cur = true;
 		}
 
-		pcaps[i].pattrs = kzalloc_objs(struct powercap_attr, j,
-					       GFP_KERNEL);
+		pcaps[i].pattrs = kzalloc_objs(struct powercap_attr, j);
 		if (!pcaps[i].pattrs)
 			goto out_pcaps_pattrs;
 
-		pcaps[i].pg.attrs = kzalloc_objs(struct attribute *, j + 1,
-						 GFP_KERNEL);
+		pcaps[i].pg.attrs = kzalloc_objs(struct attribute *, j + 1);
 		if (!pcaps[i].pg.attrs) {
 			kfree(pcaps[i].pattrs);
 			goto out_pcaps_pattrs;

arch/powerpc/platforms/powernv/opal-psr.c

···
 		return;
 	}
 
-	psr_attrs = kzalloc_objs(*psr_attrs, of_get_child_count(psr),
-				 GFP_KERNEL);
+	psr_attrs = kzalloc_objs(*psr_attrs, of_get_child_count(psr));
 	if (!psr_attrs)
 		goto out_put_psr;
 

arch/powerpc/platforms/powernv/opal-sensor-groups.c

···
 		if (!nr_attrs)
 			continue;
 
-		sgs[i].sgattrs = kzalloc_objs(*sgs[i].sgattrs, nr_attrs,
-					      GFP_KERNEL);
+		sgs[i].sgattrs = kzalloc_objs(*sgs[i].sgattrs, nr_attrs);
 		if (!sgs[i].sgattrs)
 			goto out_sgs_sgattrs;
 
-		sgs[i].sg.attrs = kzalloc_objs(*sgs[i].sg.attrs, nr_attrs + 1,
-					       GFP_KERNEL);
+		sgs[i].sg.attrs = kzalloc_objs(*sgs[i].sg.attrs, nr_attrs + 1);
 
 		if (!sgs[i].sg.attrs) {
 			kfree(sgs[i].sgattrs);

arch/powerpc/sysdev/mpic.c

···
 
 #ifdef CONFIG_PM
 	/* allocate memory to save mpic state */
-	mpic->save_data = kmalloc_objs(*mpic->save_data, mpic->num_sources,
-				       GFP_KERNEL);
+	mpic->save_data = kmalloc_objs(*mpic->save_data, mpic->num_sources);
 	BUG_ON(mpic->save_data == NULL);
 #endif
 

arch/powerpc/sysdev/mpic_msgr.c

···
 		dev_info(&dev->dev, "Found %d message registers\n",
 				mpic_msgr_count);
 
-		mpic_msgrs = kzalloc_objs(*mpic_msgrs, mpic_msgr_count,
-					  GFP_KERNEL);
+		mpic_msgrs = kzalloc_objs(*mpic_msgrs, mpic_msgr_count);
 		if (!mpic_msgrs) {
 			dev_err(&dev->dev,
 				"No memory for message register blocks\n");

arch/riscv/kernel/vdso.c

···
 		vdso_info->vdso_code_start) >>
 		PAGE_SHIFT;
 
-	vdso_pagelist = kzalloc_objs(struct page *, vdso_info->vdso_pages,
-				     GFP_KERNEL);
+	vdso_pagelist = kzalloc_objs(struct page *, vdso_info->vdso_pages);
 	if (vdso_pagelist == NULL)
 		panic("vDSO kcalloc failed!\n");
 

arch/s390/kvm/pci.c

···
 		return -EPERM;
 
 	mutex_lock(&aift->aift_lock);
-	aift->kzdev = kzalloc_objs(struct kvm_zdev *, ZPCI_NR_DEVICES,
-				   GFP_KERNEL);
+	aift->kzdev = kzalloc_objs(struct kvm_zdev *, ZPCI_NR_DEVICES);
 	if (!aift->kzdev) {
 		rc = -ENOMEM;
 		goto unlock;

arch/s390/pci/pci.c

···
 	if (!zdev_fmb_cache)
 		goto error_fmb;
 
-	zpci_iomap_start = kzalloc_objs(*zpci_iomap_start, ZPCI_IOMAP_ENTRIES,
-					GFP_KERNEL);
+	zpci_iomap_start = kzalloc_objs(*zpci_iomap_start, ZPCI_IOMAP_ENTRIES);
 	if (!zpci_iomap_start)
 		goto error_iomap;
 

arch/sh/drivers/pci/pcie-sh7786.c

···
 	if (unlikely(nr_ports == 0))
 		return -ENODEV;
 
-	sh7786_pcie_ports = kzalloc_objs(struct sh7786_pcie_port, nr_ports,
-					 GFP_KERNEL);
+	sh7786_pcie_ports = kzalloc_objs(struct sh7786_pcie_port, nr_ports);
 	if (unlikely(!sh7786_pcie_ports))
 		return -ENOMEM;
 

arch/sparc/kernel/smp_64.c

···
 	unsigned long hv_err;
 	int i;
 
-	hdesc = kzalloc_flex(*hdesc, maps, num_kernel_image_mappings,
-		             GFP_KERNEL);
+	hdesc = kzalloc_flex(*hdesc, maps, num_kernel_image_mappings);
 	if (!hdesc) {
 		printk(KERN_ERR "ldom_startcpu_cpuid: Cannot allocate "
 		       "hvtramp_descr.\n");

arch/sparc/kernel/sys_sparc_64.c

···
 	}
 	if (!current_thread_info()->utraps) {
 		current_thread_info()->utraps =
-			kzalloc_objs(long, UT_TRAP_INSTRUCTION_31 + 1,
-				     GFP_KERNEL);
+			kzalloc_objs(long, UT_TRAP_INSTRUCTION_31 + 1);
 		if (!current_thread_info()->utraps)
 			return -ENOMEM;
 		current_thread_info()->utraps[0] = 1;
···
 			unsigned long *p = current_thread_info()->utraps;
 
 			current_thread_info()->utraps =
-				kmalloc_objs(long, UT_TRAP_INSTRUCTION_31 + 1,
-					     GFP_KERNEL);
+				kmalloc_objs(long, UT_TRAP_INSTRUCTION_31 + 1);
 			if (!current_thread_info()->utraps) {
 				current_thread_info()->utraps = p;
 				return -ENOMEM;

arch/um/drivers/vector_kern.c

···
 	result->max_iov_frags = num_extra_frags;
 	for (i = 0; i < max_size; i++) {
 		if (vp->header_size > 0)
-			iov = kmalloc_objs(struct iovec, 3 + num_extra_frags,
-					   GFP_KERNEL);
+			iov = kmalloc_objs(struct iovec, 3 + num_extra_frags);
 		else
-			iov = kmalloc_objs(struct iovec, 2 + num_extra_frags,
-					   GFP_KERNEL);
+			iov = kmalloc_objs(struct iovec, 2 + num_extra_frags);
 		if (iov == NULL)
 			goto out_fail;
 		mmsg_vector->msg_hdr.msg_iov = iov;

arch/x86/events/intel/uncore_snbep.c

···
 		goto err;
 
 	for (die = 0; die < uncore_max_dies(); die++) {
-		topology[die] = kzalloc_objs(**topology, type->num_boxes,
-					     GFP_KERNEL);
+		topology[die] = kzalloc_objs(**topology, type->num_boxes);
 		if (!topology[die])
 			goto clear;
 		for (idx = 0; idx < type->num_boxes; idx++) {

arch/x86/hyperv/hv_init.c

···
 	if (hv_isolation_type_tdx())
 		hv_vp_assist_page = NULL;
 	else
-		hv_vp_assist_page = kzalloc_objs(*hv_vp_assist_page, nr_cpu_ids,
-						 GFP_KERNEL);
+		hv_vp_assist_page = kzalloc_objs(*hv_vp_assist_page, nr_cpu_ids);
 	if (!hv_vp_assist_page) {
 		ms_hyperv.hints &= ~HV_X64_ENLIGHTENED_VMCS_RECOMMENDED;
 

arch/x86/kernel/amd_nb.c

···
 
 	amd_northbridges.num = amd_num_nodes();
 
-	nb = kzalloc_objs(struct amd_northbridge, amd_northbridges.num,
-			  GFP_KERNEL);
+	nb = kzalloc_objs(struct amd_northbridge, amd_northbridges.num);
 	if (!nb)
 		return -ENOMEM;
 

arch/x86/kernel/cpu/sgx/main.c

···
 	int nid;
 	int i;
 
-	sgx_numa_nodes = kmalloc_objs(*sgx_numa_nodes, num_possible_nodes(),
-				      GFP_KERNEL);
+	sgx_numa_nodes = kmalloc_objs(*sgx_numa_nodes, num_possible_nodes());
 	if (!sgx_numa_nodes)
 		return false;
 

arch/x86/kvm/cpuid.c

···
 	if (sanity_check_entries(entries, cpuid->nent, type))
 		return -EINVAL;
 
-	array.entries = kvzalloc_objs(struct kvm_cpuid_entry2, cpuid->nent,
-				      GFP_KERNEL);
+	array.entries = kvzalloc_objs(struct kvm_cpuid_entry2, cpuid->nent);
 	if (!array.entries)
 		return -ENOMEM;
 

arch/x86/kvm/vmx/tdx.c

···
 	if (nr_user_entries < td_conf->num_cpuid_config)
 		return -E2BIG;
 
-	caps = kzalloc_flex(*caps, cpuid.entries, td_conf->num_cpuid_config,
-			    GFP_KERNEL);
+	caps = kzalloc_flex(*caps, cpuid.entries, td_conf->num_cpuid_config);
 	if (!caps)
 		return -ENOMEM;
 

block/blk-crypto-fallback.c

···
 		goto out;
 
 	/* Dynamic allocation is needed because of lockdep_register_key(). */
-	blk_crypto_fallback_profile = kzalloc_obj(*blk_crypto_fallback_profile,
-						  GFP_KERNEL);
+	blk_crypto_fallback_profile = kzalloc_obj(*blk_crypto_fallback_profile);
 	if (!blk_crypto_fallback_profile) {
 		err = -ENOMEM;
 		goto fail_free_bioset;

block/blk-crypto-profile.c

···
 
 	profile->log_slot_ht_size = ilog2(slot_hashtable_size);
 	profile->slot_hashtable =
-		kvmalloc_objs(profile->slot_hashtable[0], slot_hashtable_size,
-			      GFP_KERNEL);
+		kvmalloc_objs(profile->slot_hashtable[0], slot_hashtable_size);
 	if (!profile->slot_hashtable)
 		goto err_destroy;
 	for (i = 0; i < slot_hashtable_size; i++)

drivers/accel/amdxdna/amdxdna_gem.c

···
 		return -ENOMEM;
 
 	nr_pages = (PAGE_ALIGN(addr + len) - (addr & PAGE_MASK)) >> PAGE_SHIFT;
-	mapp->range.hmm_pfns = kvzalloc_objs(*mapp->range.hmm_pfns, nr_pages,
-					     GFP_KERNEL);
+	mapp->range.hmm_pfns = kvzalloc_objs(*mapp->range.hmm_pfns, nr_pages);
 	if (!mapp->range.hmm_pfns) {
 		ret = -ENOMEM;
 		goto free_map;

drivers/accel/ethosu/ethosu_drv.c

···
 	if (!try_module_get(THIS_MODULE))
 		return -EINVAL;
 
-	struct ethosu_file_priv __free(kfree) *priv = kzalloc_obj(*priv,
-								  GFP_KERNEL);
+	struct ethosu_file_priv __free(kfree) *priv = kzalloc_obj(*priv);
 	if (!priv) {
 		ret = -ENOMEM;
 		goto err_put_mod;

drivers/accel/ethosu/ethosu_gem.c

···
 						  struct ethosu_gem_object *bo,
 						  u32 size)
 {
-	struct ethosu_validated_cmdstream_info __free(kfree) *info = kzalloc_obj(*info,
-										 GFP_KERNEL);
+	struct ethosu_validated_cmdstream_info __free(kfree) *info = kzalloc_obj(*info);
 	struct ethosu_device *edev = to_ethosu_device(ddev);
 	u32 *bocmds = bo->base.vaddr;
 	struct cmd_state st;

drivers/accel/habanalabs/common/command_submission.c

···
 
 	*cs_chunk_array = kmalloc_objs(**cs_chunk_array, num_chunks, GFP_ATOMIC);
 	if (!*cs_chunk_array)
-		*cs_chunk_array = kmalloc_objs(**cs_chunk_array, num_chunks,
-					       GFP_KERNEL);
+		*cs_chunk_array = kmalloc_objs(**cs_chunk_array, num_chunks);
 	if (!*cs_chunk_array) {
 		atomic64_inc(&ctx->cs_counters.out_of_mem_drop_cnt);
 		atomic64_inc(&hdev->aggregated_cs_counters.out_of_mem_drop_cnt);

drivers/accel/habanalabs/common/debugfs.c

···
 	int count = ARRAY_SIZE(hl_debugfs_list);
 
 	dev_entry->hdev = hdev;
-	dev_entry->entry_arr = kmalloc_objs(struct hl_debugfs_entry, count,
-					    GFP_KERNEL);
+	dev_entry->entry_arr = kmalloc_objs(struct hl_debugfs_entry, count);
 	if (!dev_entry->entry_arr)
 		return -ENOMEM;
 

drivers/accel/habanalabs/common/hw_queue.c

···
 
 	q->kernel_address = p;
 
-	q->shadow_queue = kmalloc_objs(struct hl_cs_job *, HL_QUEUE_LENGTH,
-				       GFP_KERNEL);
+	q->shadow_queue = kmalloc_objs(struct hl_cs_job *, HL_QUEUE_LENGTH);
 	if (!q->shadow_queue) {
 		dev_err(hdev->dev,
 			"Failed to allocate shadow queue for H/W queue %d\n",

drivers/accel/habanalabs/common/mmu/mmu.c

···
 		return -ENOMEM;
 	}
 
-	hr_priv->mmu_asid_hop0 = kvzalloc_objs(struct pgt_info, prop->max_asid,
-					       GFP_KERNEL);
+	hr_priv->mmu_asid_hop0 = kvzalloc_objs(struct pgt_info, prop->max_asid);
 	if (ZERO_OR_NULL_PTR(hr_priv->mmu_asid_hop0)) {
 		dev_err(hdev->dev, "Failed to allocate hr-mmu hop0 table\n");
 		rc = -ENOMEM;

drivers/accel/habanalabs/common/security.c

···
 	int i, j;
 	struct hl_block_glbl_sec *glbl_sec;
 
-	glbl_sec = kzalloc_objs(struct hl_block_glbl_sec, blocks_array_size,
-				GFP_KERNEL);
+	glbl_sec = kzalloc_objs(struct hl_block_glbl_sec, blocks_array_size);
 	if (!glbl_sec)
 		return -ENOMEM;
 
···
 	int i, j, rc = 0;
 	struct hl_block_glbl_sec *glbl_sec;
 
-	glbl_sec = kzalloc_objs(struct hl_block_glbl_sec, blocks_array_size,
-				GFP_KERNEL);
+	glbl_sec = kzalloc_objs(struct hl_block_glbl_sec, blocks_array_size);
 	if (!glbl_sec)
 		return -ENOMEM;
 
···
 	int i, rc = 0;
 	struct hl_block_glbl_sec *glbl_sec;
 
-	glbl_sec = kzalloc_objs(struct hl_block_glbl_sec, blocks_array_size,
-				GFP_KERNEL);
+	glbl_sec = kzalloc_objs(struct hl_block_glbl_sec, blocks_array_size);
 	if (!glbl_sec)
 		return -ENOMEM;
 
···
 	int i;
 	struct hl_block_glbl_sec *glbl_sec;
 
-	glbl_sec = kzalloc_objs(struct hl_block_glbl_sec, blocks_array_size,
-				GFP_KERNEL);
+	glbl_sec = kzalloc_objs(struct hl_block_glbl_sec, blocks_array_size);
 	if (!glbl_sec)
 		return -ENOMEM;
 

drivers/accel/habanalabs/gaudi2/gaudi2_security.c

···
 
 	block_array_size = ARRAY_SIZE(gaudi2_pb_dcr0_tpc0);
 
-	glbl_sec = kzalloc_objs(struct hl_block_glbl_sec, block_array_size,
-				GFP_KERNEL);
+	glbl_sec = kzalloc_objs(struct hl_block_glbl_sec, block_array_size);
 	if (!glbl_sec)
 		return -ENOMEM;
 

drivers/accel/qaic/qaic_ssr.c

···
 	}
 
 	/* Buffer used to send MEMORY READ request to device via MHI */
-	dump_info->read_buf_req = kzalloc_obj(*dump_info->read_buf_req,
-					      GFP_KERNEL);
+	dump_info->read_buf_req = kzalloc_obj(*dump_info->read_buf_req);
 	if (!dump_info->read_buf_req) {
 		ret = -ENOMEM;
 		goto free_dump_info;

drivers/acpi/apei/einj-core.c

···
 {
 	char name[32];
 
-	syndrome_data = kzalloc_objs(syndrome_data[0], max_nr_components,
-				     GFP_KERNEL);
+	syndrome_data = kzalloc_objs(syndrome_data[0], max_nr_components);
 	if (!syndrome_data)
 		return false;
 

drivers/acpi/cppc_acpi.c

···
 	if (pcc_data[pcc_ss_id]) {
 		pcc_data[pcc_ss_id]->refcount++;
 	} else {
-		pcc_data[pcc_ss_id] = kzalloc_obj(struct cppc_pcc_data,
-						  GFP_KERNEL);
+		pcc_data[pcc_ss_id] = kzalloc_obj(struct cppc_pcc_data);
 		if (!pcc_data[pcc_ss_id])
 			return -ENOMEM;
 		pcc_data[pcc_ss_id]->refcount++;

drivers/acpi/mipi-disco-img.c

···
 		return AE_OK;
 	}
 
-	conn = kmalloc_flex(*conn, remote_name, csi2_res_src_length + 1,
-			    GFP_KERNEL);
+	conn = kmalloc_flex(*conn, remote_name, csi2_res_src_length + 1);
 	if (!conn)
 		return AE_OK;
 

drivers/acpi/platform_profile.c

···
 	    !ops->profile_set || !ops->probe))
 		return ERR_PTR(-EINVAL);
 
-	struct platform_profile_handler *pprof __free(kfree) = kzalloc_obj(*pprof,
-									   GFP_KERNEL);
+	struct platform_profile_handler *pprof __free(kfree) = kzalloc_obj(*pprof);
 	if (!pprof)
 		return ERR_PTR(-ENOMEM);
 

drivers/acpi/processor_perflib.c

···
 
 	pr->performance->state_count = pss->package.count;
 	pr->performance->states =
-	    kmalloc_objs(struct acpi_processor_px, pss->package.count,
-			 GFP_KERNEL);
+	    kmalloc_objs(struct acpi_processor_px, pss->package.count);
 	if (!pr->performance->states) {
 		result = -ENOMEM;
 		goto end;

drivers/acpi/processor_throttling.c

···
 
 	pr->throttling.state_count = tss->package.count;
 	pr->throttling.states_tss =
-	    kmalloc_objs(struct acpi_processor_tx_tss, tss->package.count,
-			 GFP_KERNEL);
+	    kmalloc_objs(struct acpi_processor_tx_tss, tss->package.count);
 	if (!pr->throttling.states_tss) {
 		result = -ENOMEM;
 		goto end;

drivers/acpi/riscv/irq.c

···
 	     riscv_acpi_irq_get_dep(handle, i, &gsi_handle);
 	     i++) {
 		dep_devices.count = 1;
-		dep_devices.handles = kzalloc_objs(*dep_devices.handles, 1,
-						   GFP_KERNEL);
+		dep_devices.handles = kzalloc_objs(*dep_devices.handles, 1);
 		if (!dep_devices.handles) {
 			acpi_handle_err(handle, "failed to allocate memory\n");
 			continue;

drivers/acpi/scan.c

···
 		if (result)
 			goto err_unlock;
 	} else {
-		acpi_device_bus_id = kzalloc_obj(*acpi_device_bus_id,
-						 GFP_KERNEL);
+		acpi_device_bus_id = kzalloc_obj(*acpi_device_bus_id);
 		if (!acpi_device_bus_id) {
 			result = -ENOMEM;
 			goto err_unlock;

drivers/ata/libahci_platform.c

···
 	 * We cannot use devm_ here, since ahci_platform_put_resources() uses
 	 * target_pwrs after devm_ have freed memory
 	 */
-	hpriv->target_pwrs = kzalloc_objs(*hpriv->target_pwrs, hpriv->nports,
-					  GFP_KERNEL);
+	hpriv->target_pwrs = kzalloc_objs(*hpriv->target_pwrs, hpriv->nports);
 	if (!hpriv->target_pwrs) {
 		rc = -ENOMEM;
 		goto err_out;

drivers/atm/he.c

···
 	}
 
 	/* rbpl_virt 64-bit pointers */
-	he_dev->rbpl_virt = kmalloc_objs(*he_dev->rbpl_virt, RBPL_TABLE_SIZE,
-					 GFP_KERNEL);
+	he_dev->rbpl_virt = kmalloc_objs(*he_dev->rbpl_virt, RBPL_TABLE_SIZE);
 	if (!he_dev->rbpl_virt) {
 		hprintk("unable to allocate rbpl virt table\n");
 		goto out_free_rbpl_table;

drivers/atm/iphase.c

···
 		buf_desc_ptr++;		  
 		tx_pkt_start += iadev->tx_buf_sz;  
 	}  
-	iadev->tx_buf = kmalloc_objs(*iadev->tx_buf, iadev->num_tx_desc,
-				     GFP_KERNEL);
+	iadev->tx_buf = kmalloc_objs(*iadev->tx_buf, iadev->num_tx_desc);
         if (!iadev->tx_buf) {
             printk(KERN_ERR DEV_LABEL " couldn't get mem\n");
 	    goto err_free_dle;
···
 						       sizeof(*cpcs),
 						       DMA_TO_DEVICE);
         }
-	iadev->desc_tbl = kmalloc_objs(*iadev->desc_tbl, iadev->num_tx_desc,
-				       GFP_KERNEL);
+	iadev->desc_tbl = kmalloc_objs(*iadev->desc_tbl, iadev->num_tx_desc);
 	if (!iadev->desc_tbl) {
 		printk(KERN_ERR DEV_LABEL " couldn't get mem\n");
 		goto err_free_all_tx_bufs;
···
 	memset((caddr_t)(iadev->seg_ram+i),  0, iadev->num_vc*4);
 	vc = (struct main_vc *)iadev->MAIN_VC_TABLE_ADDR;  
 	evc = (struct ext_vc *)iadev->EXT_VC_TABLE_ADDR;  
-	iadev->testTable = kmalloc_objs(*iadev->testTable, iadev->num_vc,
-					GFP_KERNEL);
+	iadev->testTable = kmalloc_objs(*iadev->testTable, iadev->num_vc);
         if (!iadev->testTable) {
            printk("Get freepage  failed\n");
 	   goto err_free_desc_tbl;
···
 	{  
 		memset((caddr_t)vc, 0, sizeof(*vc));  
 		memset((caddr_t)evc, 0, sizeof(*evc));  
-                iadev->testTable[i] = kmalloc_obj(struct testTable_t,
-						  GFP_KERNEL);
+                iadev->testTable[i] = kmalloc_obj(struct testTable_t);
 		if (!iadev->testTable[i])
 			goto err_free_test_tables;
               	iadev->testTable[i]->lastTime = 0;

drivers/base/physical_location.c

···
 	if (!acpi_get_physical_device_location(ACPI_HANDLE(dev), &pld))
 		return false;
 
-	dev->physical_location = kzalloc_obj(*dev->physical_location,
-					     GFP_KERNEL);
+	dev->physical_location = kzalloc_obj(*dev->physical_location);
 	if (!dev->physical_location) {
 		ACPI_FREE(pld);
 		return false;

drivers/block/drbd/drbd_receiver.c

···
 		if (my_usize != p_usize) {
 			struct disk_conf *old_disk_conf, *new_disk_conf = NULL;
 
-			new_disk_conf = kzalloc_obj(struct disk_conf,
-						    GFP_KERNEL);
+			new_disk_conf = kzalloc_obj(struct disk_conf);
 			if (!new_disk_conf) {
 				put_ldev(device);
 				return -ENOMEM;

drivers/block/ps3vram.c

···
 
 	priv->cache.page_count = CACHE_PAGE_COUNT;
 	priv->cache.page_size = CACHE_PAGE_SIZE;
-	priv->cache.tags = kzalloc_objs(struct ps3vram_tag, CACHE_PAGE_COUNT,
-					GFP_KERNEL);
+	priv->cache.tags = kzalloc_objs(struct ps3vram_tag, CACHE_PAGE_COUNT);
 	if (!priv->cache.tags)
 		return -ENOMEM;
 

drivers/block/xen-blkback/blkback.c

···
 			 * We are using persistent grants, the grant is
 			 * not mapped but we might have room for it.
 			 */
-			persistent_gnt = kmalloc_obj(struct persistent_gnt,
-						     GFP_KERNEL);
+			persistent_gnt = kmalloc_obj(struct persistent_gnt);
 			if (!persistent_gnt) {
 				/*
 				 * If we don't have enough memory to

drivers/block/xen-blkback/xenbus.c

···
 {
 	unsigned int r;
 
-	blkif->rings = kzalloc_objs(struct xen_blkif_ring, blkif->nr_rings,
-				    GFP_KERNEL);
+	blkif->rings = kzalloc_objs(struct xen_blkif_ring, blkif->nr_rings);
 	if (!blkif->rings)
 		return -ENOMEM;
 
···
 			goto fail;
 		list_add_tail(&req->free_list, &ring->pending_free);
 		for (j = 0; j < MAX_INDIRECT_SEGMENTS; j++) {
-			req->segments[j] = kzalloc_obj(*req->segments[0],
-						       GFP_KERNEL);
+			req->segments[j] = kzalloc_obj(*req->segments[0]);
 			if (!req->segments[j])
 				goto fail;
 		}
 		for (j = 0; j < MAX_INDIRECT_PAGES; j++) {
-			req->indirect_pages[j] = kzalloc_obj(*req->indirect_pages[0],
-							     GFP_KERNEL);
+			req->indirect_pages[j] = kzalloc_obj(*req->indirect_pages[0]);
 			if (!req->indirect_pages[j])
 				goto fail;
 		}

drivers/block/xen-blkfront.c

···
 
 	for (i = 0; i < BLK_RING_SIZE(info); i++) {
 		rinfo->shadow[i].grants_used =
-			kvzalloc_objs(rinfo->shadow[i].grants_used[0], grants,
-				      GFP_KERNEL);
+			kvzalloc_objs(rinfo->shadow[i].grants_used[0], grants);
 		rinfo->shadow[i].sg = kvzalloc_objs(rinfo->shadow[i].sg[0],
 						    psegs, GFP_KERNEL);
 		if (info->max_indirect_segments)

drivers/block/z2ram.c

···
 			    (unsigned long)z_remap_nocache_nonser(paddr, size);
 #endif
 			z2ram_map =
-			    kmalloc_objs(z2ram_map[0], size / Z2RAM_CHUNKSIZE,
-					 GFP_KERNEL);
+			    kmalloc_objs(z2ram_map[0], size / Z2RAM_CHUNKSIZE);
 			if (z2ram_map == NULL) {
 				printk(KERN_ERR DEVICE_NAME
 				       ": cannot get mem for z2ram_map\n");

drivers/bus/mhi/ep/main.c

···
 	if (ret)
 		return ret;
 
-	mhi_cntrl->mhi_cmd = kzalloc_objs(*mhi_cntrl->mhi_cmd, NR_OF_CMD_RINGS,
-					  GFP_KERNEL);
+	mhi_cntrl->mhi_cmd = kzalloc_objs(*mhi_cntrl->mhi_cmd, NR_OF_CMD_RINGS);
 	if (!mhi_cntrl->mhi_cmd) {
 		ret = -ENOMEM;
 		goto err_free_ch;

drivers/bus/mhi/host/boot.c

···
 		return -ENOMEM;
 
 	/* Allocate memory for entries */
-	img_info->mhi_buf = kzalloc_objs(*img_info->mhi_buf, segments,
-					 GFP_KERNEL);
+	img_info->mhi_buf = kzalloc_objs(*img_info->mhi_buf, segments);
 	if (!img_info->mhi_buf)
 		goto error_alloc_mhi_buf;
 

drivers/bus/mhi/host/init.c

···
 
 	num = config->num_events;
 	mhi_cntrl->total_ev_rings = num;
-	mhi_cntrl->mhi_event = kzalloc_objs(*mhi_cntrl->mhi_event, num,
-					    GFP_KERNEL);
+	mhi_cntrl->mhi_event = kzalloc_objs(*mhi_cntrl->mhi_event, num);
 	if (!mhi_cntrl->mhi_event)
 		return -ENOMEM;
 
···
 	if (ret)
 		return -EINVAL;
 
-	mhi_cntrl->mhi_cmd = kzalloc_objs(*mhi_cntrl->mhi_cmd, NR_OF_CMD_RINGS,
-					  GFP_KERNEL);
+	mhi_cntrl->mhi_cmd = kzalloc_objs(*mhi_cntrl->mhi_cmd, NR_OF_CMD_RINGS);
 	if (!mhi_cntrl->mhi_cmd) {
 		ret = -ENOMEM;
 		goto err_free_event;

drivers/char/agp/sworks-agp.c

···
 	int retval = 0;
 	int i;
 
-	tables = kzalloc_objs(struct serverworks_page_map *, nr_tables + 1,
-			      GFP_KERNEL);
+	tables = kzalloc_objs(struct serverworks_page_map *, nr_tables + 1);
 	if (tables == NULL)
 		return -ENOMEM;
 

drivers/char/agp/uninorth-agp.c

···
 	if (table == NULL)
 		return -ENOMEM;
 
-	uninorth_priv.pages_arr = kmalloc_objs(struct page *, 1 << page_order,
-					       GFP_KERNEL);
+	uninorth_priv.pages_arr = kmalloc_objs(struct page *, 1 << page_order);
 	if (uninorth_priv.pages_arr == NULL)
 		goto enomem;
 

drivers/char/virtio_console.c

···
 	vqs = kmalloc_objs(struct virtqueue *, nr_queues);
 	vqs_info = kzalloc_objs(*vqs_info, nr_queues);
 	portdev->in_vqs = kmalloc_objs(struct virtqueue *, nr_ports);
-	portdev->out_vqs = kmalloc_objs(struct virtqueue *, nr_ports,
-					GFP_KERNEL);
+	portdev->out_vqs = kmalloc_objs(struct virtqueue *, nr_ports);
 	if (!vqs || !vqs_info || !portdev->in_vqs || !portdev->out_vqs) {
 		err = -ENOMEM;
 		goto free;

drivers/clk/aspeed/clk-aspeed.c

···
 	if (!scu_base)
 		return;
 
-	aspeed_clk_data = kzalloc_flex(*aspeed_clk_data, hws, ASPEED_NUM_CLKS,
-				       GFP_KERNEL);
+	aspeed_clk_data = kzalloc_flex(*aspeed_clk_data, hws, ASPEED_NUM_CLKS);
 	if (!aspeed_clk_data)
 		return;
 	aspeed_clk_data->num = ASPEED_NUM_CLKS;

drivers/clk/bcm/clk-iproc-asiu.c

···
 	if (WARN_ON(!asiu))
 		return;
 
-	asiu->clk_data = kzalloc_flex(*asiu->clk_data, hws, num_clks,
-				      GFP_KERNEL);
+	asiu->clk_data = kzalloc_flex(*asiu->clk_data, hws, num_clks);
 	if (WARN_ON(!asiu->clk_data))
 		goto err_clks;
 	asiu->clk_data->num = num_clks;

drivers/clk/clk-gemini.c

···
 	int ret;
 	int i;
 
-	gemini_clk_data = kzalloc_flex(*gemini_clk_data, hws, GEMINI_NUM_CLKS,
-				       GFP_KERNEL);
+	gemini_clk_data = kzalloc_flex(*gemini_clk_data, hws, GEMINI_NUM_CLKS);
 	if (!gemini_clk_data)
 		return;
 	gemini_clk_data->num = GEMINI_NUM_CLKS;

drivers/clk/clk-milbeaut.c

···
 	const char *parent_name;
 	struct clk_hw *hw;
 
-	m10v_clk_data = kzalloc_flex(*m10v_clk_data, hws, M10V_NUM_CLKS,
-				     GFP_KERNEL);
+	m10v_clk_data = kzalloc_flex(*m10v_clk_data, hws, M10V_NUM_CLKS);
 
 	if (!m10v_clk_data)
 		return;

drivers/clk/clk-stm32f4.c

···
 
 	stm32fx_end_primary_clk = data->end_primary;
 
-	clks = kmalloc_objs(*clks, data->gates_num + stm32fx_end_primary_clk,
-			    GFP_KERNEL);
+	clks = kmalloc_objs(*clks, data->gates_num + stm32fx_end_primary_clk);
 	if (!clks)
 		goto fail;
 

drivers/clk/imx/clk-imx6q.c

···
 	void __iomem *anatop_base, *base;
 	int ret;
 
-	clk_hw_data = kzalloc_flex(*clk_hw_data, hws, IMX6QDL_CLK_END,
-				   GFP_KERNEL);
+	clk_hw_data = kzalloc_flex(*clk_hw_data, hws, IMX6QDL_CLK_END);
 	if (WARN_ON(!clk_hw_data))
 		return;
 

drivers/clk/imx/clk-imx6sl.c

···
 	void __iomem *base;
 	int ret;
 
-	clk_hw_data = kzalloc_flex(*clk_hw_data, hws, IMX6SL_CLK_END,
-				   GFP_KERNEL);
+	clk_hw_data = kzalloc_flex(*clk_hw_data, hws, IMX6SL_CLK_END);
 	if (WARN_ON(!clk_hw_data))
 		return;
 

drivers/clk/imx/clk-imx6sll.c

···
 	struct device_node *np;
 	void __iomem *base;
 
-	clk_hw_data = kzalloc_flex(*clk_hw_data, hws, IMX6SLL_CLK_END,
-				   GFP_KERNEL);
+	clk_hw_data = kzalloc_flex(*clk_hw_data, hws, IMX6SLL_CLK_END);
 	if (WARN_ON(!clk_hw_data))
 		return;
 

drivers/clk/imx/clk-imx6sx.c

···
 	void __iomem *base;
 	bool lcdif1_assigned_clk;
 
-	clk_hw_data = kzalloc_flex(*clk_hw_data, hws, IMX6SX_CLK_CLK_END,
-				   GFP_KERNEL);
+	clk_hw_data = kzalloc_flex(*clk_hw_data, hws, IMX6SX_CLK_CLK_END);
 	if (WARN_ON(!clk_hw_data))
 		return;
 

drivers/clk/imx/clk-imx6ul.c

···
 	struct device_node *np;
 	void __iomem *base;
 
-	clk_hw_data = kzalloc_flex(*clk_hw_data, hws, IMX6UL_CLK_END,
-				   GFP_KERNEL);
+	clk_hw_data = kzalloc_flex(*clk_hw_data, hws, IMX6UL_CLK_END);
 	if (WARN_ON(!clk_hw_data))
 		return;
 

drivers/clk/imx/clk-imx7ulp.c

···
 	struct clk_hw **hws;
 	void __iomem *base;
 
-	clk_data = kzalloc_flex(*clk_data, hws, IMX7ULP_CLK_SCG1_END,
-				GFP_KERNEL);
+	clk_data = kzalloc_flex(*clk_data, hws, IMX7ULP_CLK_SCG1_END);
 	if (!clk_data)
 		return;
 
···
 	struct clk_hw **hws;
 	void __iomem *base;
 
-	clk_data = kzalloc_flex(*clk_data, hws, IMX7ULP_CLK_PCC2_END,
-				GFP_KERNEL);
+	clk_data = kzalloc_flex(*clk_data, hws, IMX7ULP_CLK_PCC2_END);
 	if (!clk_data)
 		return;
 
···
 	struct clk_hw **hws;
 	void __iomem *base;
 
-	clk_data = kzalloc_flex(*clk_data, hws, IMX7ULP_CLK_PCC3_END,
-				GFP_KERNEL);
+	clk_data = kzalloc_flex(*clk_data, hws, IMX7ULP_CLK_PCC3_END);
 	if (!clk_data)
 		return;
 
···
 	struct clk_hw **hws;
 	void __iomem *base;
 
-	clk_data = kzalloc_flex(*clk_data, hws, IMX7ULP_CLK_SMC1_END,
-				GFP_KERNEL);
+	clk_data = kzalloc_flex(*clk_data, hws, IMX7ULP_CLK_SMC1_END);
 	if (!clk_data)
 		return;
 

drivers/clk/imx/clk-imx8mm.c

···
 	void __iomem *base;
 	int ret;
 
-	clk_hw_data = kzalloc_flex(*clk_hw_data, hws, IMX8MM_CLK_END,
-				   GFP_KERNEL);
+	clk_hw_data = kzalloc_flex(*clk_hw_data, hws, IMX8MM_CLK_END);
 	if (WARN_ON(!clk_hw_data))
 		return -ENOMEM;
 

drivers/clk/ingenic/cgu.c

···
 	unsigned i;
 	int err;
 
-	cgu->clocks.clks = kzalloc_objs(struct clk *, cgu->clocks.clk_num,
-					GFP_KERNEL);
+	cgu->clocks.clks = kzalloc_objs(struct clk *, cgu->clocks.clk_num);
 	if (!cgu->clocks.clks) {
 		err = -ENOMEM;
 		goto err_out;

drivers/clk/mvebu/common.c

···
 	if (desc->get_refclk_freq)
 		clk_data.clk_num += 1;
 
-	clk_data.clks = kzalloc_objs(*clk_data.clks, clk_data.clk_num,
-				     GFP_KERNEL);
+	clk_data.clks = kzalloc_objs(*clk_data.clks, clk_data.clk_num);
 	if (WARN_ON(!clk_data.clks)) {
 		iounmap(base);
 		return;

drivers/clk/st/clk-flexgen.c

···
 	} else
 		clk_data->clk_num = data->outputs_nb;
 
-	clk_data->clks = kzalloc_objs(struct clk *, clk_data->clk_num,
-				      GFP_KERNEL);
+	clk_data->clks = kzalloc_objs(struct clk *, clk_data->clk_num);
 	if (!clk_data->clks)
 		goto err;
 

drivers/clk/st/clkgen-pll.c

···
 		return;
 
 	clk_data->clk_num = num_odfs;
-	clk_data->clks = kzalloc_objs(struct clk *, clk_data->clk_num,
-				      GFP_KERNEL);
+	clk_data->clks = kzalloc_objs(struct clk *, clk_data->clk_num);
 
 	if (!clk_data->clks)
 		goto err;

drivers/clk/tegra/clk.c

···
 	if (WARN_ON(banks > ARRAY_SIZE(periph_regs)))
 		return NULL;
 
-	periph_clk_enb_refcnt = kzalloc_objs(*periph_clk_enb_refcnt, 32 * banks,
-					     GFP_KERNEL);
+	periph_clk_enb_refcnt = kzalloc_objs(*periph_clk_enb_refcnt, 32 * banks);
 	if (!periph_clk_enb_refcnt)
 		return NULL;
 

drivers/clocksource/dw_apb_timer.c

···
 dw_apb_clockevent_init(int cpu, const char *name, unsigned rating,
 		       void __iomem *base, int irq, unsigned long freq)
 {
-	struct dw_apb_clock_event_device *dw_ced = kzalloc_obj(*dw_ced,
-							       GFP_KERNEL);
+	struct dw_apb_clock_event_device *dw_ced = kzalloc_obj(*dw_ced);
 	int err;
 
 	if (!dw_ced)

drivers/clocksource/sh_cmt.c

···
 
 	/* Allocate and setup the channels. */
 	cmt->num_channels = hweight8(cmt->hw_channels);
-	cmt->channels = kzalloc_objs(*cmt->channels, cmt->num_channels,
-				     GFP_KERNEL);
+	cmt->channels = kzalloc_objs(*cmt->channels, cmt->num_channels);
 	if (cmt->channels == NULL) {
 		ret = -ENOMEM;
 		goto err_unmap;

drivers/clocksource/sh_mtu2.c

···
 	mtu->num_channels = min_t(unsigned int, ret,
 				  ARRAY_SIZE(sh_mtu2_channel_offsets));
 
-	mtu->channels = kzalloc_objs(*mtu->channels, mtu->num_channels,
-				     GFP_KERNEL);
+	mtu->channels = kzalloc_objs(*mtu->channels, mtu->num_channels);
 	if (mtu->channels == NULL) {
 		ret = -ENOMEM;
 		goto err_unmap;

drivers/clocksource/sh_tmu.c

···
 	}
 
 	/* Allocate and setup the channels. */
-	tmu->channels = kzalloc_objs(*tmu->channels, tmu->num_channels,
-				     GFP_KERNEL);
+	tmu->channels = kzalloc_objs(*tmu->channels, tmu->num_channels);
 	if (tmu->channels == NULL) {
 		ret = -ENOMEM;
 		goto err_unmap;

drivers/comedi/drivers/ni_670x.c

···
 	if (s->n_chan == 32) {
 		const struct comedi_lrange **range_table_list;
 
-		range_table_list = kmalloc_objs(*range_table_list, 32,
-						GFP_KERNEL);
+		range_table_list = kmalloc_objs(*range_table_list, 32);
 		if (!range_table_list)
 			return -ENOMEM;
 		s->range_table_list = range_table_list;

drivers/connector/cn_proc.c

···
 	if (nsp->sk) {
 		sk = nsp->sk;
 		if (sk->sk_user_data == NULL) {
-			sk->sk_user_data = kzalloc_obj(struct proc_input,
-						       GFP_KERNEL);
+			sk->sk_user_data = kzalloc_obj(struct proc_input);
 			if (sk->sk_user_data == NULL) {
 				err = ENOMEM;
 				goto out;

drivers/cpufreq/acpi-cpufreq.c

···
 		goto err_unreg;
 	}
 
-	freq_table = kzalloc_objs(*freq_table, perf->state_count + 1,
-				  GFP_KERNEL);
+	freq_table = kzalloc_objs(*freq_table, perf->state_count + 1);
 	if (!freq_table) {
 		result = -ENOMEM;
 		goto err_unreg;

drivers/cpufreq/armada-37xx-cpufreq.c

···
 		return -EINVAL;
 	}
 
-	armada37xx_cpufreq_state = kmalloc_obj(*armada37xx_cpufreq_state,
-					       GFP_KERNEL);
+	armada37xx_cpufreq_state = kmalloc_obj(*armada37xx_cpufreq_state);
 	if (!armada37xx_cpufreq_state) {
 		clk_put(clk);
 		return -ENOMEM;

drivers/cpufreq/longhaul.c

···
 		return -EINVAL;
 	}
 
-	longhaul_table = kzalloc_objs(*longhaul_table, numscales + 1,
-				      GFP_KERNEL);
+	longhaul_table = kzalloc_objs(*longhaul_table, numscales + 1);
 	if (!longhaul_table)
 		return -ENOMEM;
 

drivers/cpufreq/sparc-us2e-cpufreq.c

···
 	impl  = ((ver >> 32) & 0xffff);
 
 	if (manuf == 0x17 && impl == 0x13) {
-		us2e_freq_table = kzalloc_objs(*us2e_freq_table, NR_CPUS,
-					       GFP_KERNEL);
+		us2e_freq_table = kzalloc_objs(*us2e_freq_table, NR_CPUS);
 		if (!us2e_freq_table)
 			return -ENOMEM;
 

drivers/cpufreq/sparc-us3-cpufreq.c

···
 	     impl == CHEETAH_PLUS_IMPL ||
 	     impl == JAGUAR_IMPL ||
 	     impl == PANTHER_IMPL)) {
-		us3_freq_table = kzalloc_objs(*us3_freq_table, NR_CPUS,
-					      GFP_KERNEL);
+		us3_freq_table = kzalloc_objs(*us3_freq_table, NR_CPUS);
 		if (!us3_freq_table)
 			return -ENOMEM;
 

drivers/crypto/amcc/crypto4xx_core.c

···
 	if (!dev->pdr)
 		return -ENOMEM;
 
-	dev->pdr_uinfo = kzalloc_objs(struct pd_uinfo, PPC4XX_NUM_PD,
-				      GFP_KERNEL);
+	dev->pdr_uinfo = kzalloc_objs(struct pd_uinfo, PPC4XX_NUM_PD);
 	if (!dev->pdr_uinfo) {
 		dma_free_coherent(dev->core_dev->device,
 				  sizeof(struct ce_pd) * PPC4XX_NUM_PD,

drivers/crypto/cavium/nitrox/nitrox_mbx.c

···
 	struct nitrox_vfdev *vfdev;
 	int i;
 
-	ndev->iov.vfdev = kzalloc_objs(struct nitrox_vfdev, ndev->iov.num_vfs,
-				       GFP_KERNEL);
+	ndev->iov.vfdev = kzalloc_objs(struct nitrox_vfdev, ndev->iov.num_vfs);
 	if (!ndev->iov.vfdev)
 		return -ENOMEM;
 

drivers/crypto/hisilicon/qm.c

···
 	if (!qm->qp_array)
 		return -ENOMEM;
 
-	qm->poll_data = kzalloc_objs(struct hisi_qm_poll_data, qm->qp_num,
-				     GFP_KERNEL);
+	qm->poll_data = kzalloc_objs(struct hisi_qm_poll_data, qm->qp_num);
 	if (!qm->poll_data) {
 		kfree(qm->qp_array);
 		return -ENOMEM;
···
 
 	if (test_bit(QM_SUPPORT_FUNC_QOS, &qm->caps)) {
 		total_func = pci_sriov_get_totalvfs(qm->pdev) + 1;
-		qm->factor = kzalloc_objs(struct qm_shaper_factor, total_func,
-					  GFP_KERNEL);
+		qm->factor = kzalloc_objs(struct qm_shaper_factor, total_func);
 		if (!qm->factor)
 			return -ENOMEM;
 

drivers/crypto/hisilicon/sec2/sec_crypto.c

···
 	ctx->hlf_q_num = sec->ctx_q_num >> 1;
 
 	ctx->pbuf_supported = ctx->sec->iommu_used;
-	ctx->qp_ctx = kzalloc_objs(struct sec_qp_ctx, sec->ctx_q_num,
-				   GFP_KERNEL);
+	ctx->qp_ctx = kzalloc_objs(struct sec_qp_ctx, sec->ctx_q_num);
 	if (!ctx->qp_ctx) {
 		ret = -ENOMEM;
 		goto err_destroy_qps;

drivers/crypto/hisilicon/zip/zip_crypto.c

···
 		}
 		spin_lock_init(&req_q->req_lock);
 
-		req_q->q = kzalloc_objs(struct hisi_zip_req, req_q->size,
-					GFP_KERNEL);
+		req_q->q = kzalloc_objs(struct hisi_zip_req, req_q->size);
 		if (!req_q->q) {
 			ret = -ENOMEM;
 			if (i == 0)

drivers/crypto/intel/qat/qat_common/adf_fw_counters.c

···
 	if (unlikely(!ae_count))
 		return ERR_PTR(-EINVAL);
 
-	fw_counters = kmalloc_flex(*fw_counters, ae_counters, ae_count,
-				   GFP_KERNEL);
+	fw_counters = kmalloc_flex(*fw_counters, ae_counters, ae_count);
 	if (!fw_counters)
 		return ERR_PTR(-ENOMEM);
 

drivers/crypto/intel/qat/qat_common/adf_sriov.c

···
 		goto err_del_cfg;
 
 	/* Allocate memory for VF info structs */
-	accel_dev->pf.vf_info = kzalloc_objs(struct adf_accel_vf_info, totalvfs,
-					     GFP_KERNEL);
+	accel_dev->pf.vf_info = kzalloc_objs(struct adf_accel_vf_info, totalvfs);
 	ret = -ENOMEM;
 	if (!accel_dev->pf.vf_info)
 		goto err_del_cfg;

drivers/crypto/marvell/octeontx2/otx2_cptpf_main.c

···
 	if (!cptpf->flr_wq)
 		return -ENOMEM;
 
-	cptpf->flr_work = kzalloc_objs(struct cptpf_flr_work, num_vfs,
-				       GFP_KERNEL);
+	cptpf->flr_work = kzalloc_objs(struct cptpf_flr_work, num_vfs);
 	if (!cptpf->flr_work)
 		goto destroy_wq;
 

drivers/crypto/stm32/stm32-cryp.c

···
 		return alloc_sg_len;
 
 	/* We allocate to much sg entry, but it is easier */
-	*new_sg = kmalloc_objs(struct scatterlist, (size_t)alloc_sg_len,
-			       GFP_KERNEL);
+	*new_sg = kmalloc_objs(struct scatterlist, (size_t)alloc_sg_len);
 	if (!*new_sg)
 		return -ENOMEM;
 

drivers/crypto/virtio/virtio_crypto_core.c

···
 
 static int virtcrypto_alloc_queues(struct virtio_crypto *vi)
 {
-	vi->data_vq = kzalloc_objs(*vi->data_vq, vi->max_data_queues,
-				   GFP_KERNEL);
+	vi->data_vq = kzalloc_objs(*vi->data_vq, vi->max_data_queues);
 	if (!vi->data_vq)
 		return -ENOMEM;
 

drivers/devfreq/governor_userspace.c

···
 static int userspace_init(struct devfreq *devfreq)
 {
 	int err = 0;
-	struct userspace_data *data = kzalloc_obj(struct userspace_data,
-						  GFP_KERNEL);
+	struct userspace_data *data = kzalloc_obj(struct userspace_data);
 
 	if (!data) {
 		err = -ENOMEM;

drivers/dma-buf/udmabuf.c

···
 	if (!ubuf->offsets)
 		return -ENOMEM;
 
-	ubuf->pinned_folios = kvmalloc_objs(*ubuf->pinned_folios, pgcnt,
-					    GFP_KERNEL);
+	ubuf->pinned_folios = kvmalloc_objs(*ubuf->pinned_folios, pgcnt);
 	if (!ubuf->pinned_folios)
 		return -ENOMEM;
 

drivers/dma/amba-pl08x.c

···
 	}
 
 	/* Initialize physical channels */
-	pl08x->phy_chans = kzalloc_objs(*pl08x->phy_chans, vd->channels,
-					GFP_KERNEL);
+	pl08x->phy_chans = kzalloc_objs(*pl08x->phy_chans, vd->channels);
 	if (!pl08x->phy_chans) {
 		ret = -ENOMEM;
 		goto out_no_phychans;

drivers/dma/plx_dma.c

···
 	struct plx_dma_desc *desc;
 	int i;
 
-	plxdev->desc_ring = kzalloc_objs(*plxdev->desc_ring, PLX_DMA_RING_COUNT,
-					 GFP_KERNEL);
+	plxdev->desc_ring = kzalloc_objs(*plxdev->desc_ring, PLX_DMA_RING_COUNT);
 	if (!plxdev->desc_ring)
 		return -ENOMEM;
 

drivers/dma/xilinx/zynqmp_dma.c

···
 	if (ret < 0)
 		return ret;
 
-	chan->sw_desc_pool = kzalloc_objs(*desc, ZYNQMP_DMA_NUM_DESCS,
-					  GFP_KERNEL);
+	chan->sw_desc_pool = kzalloc_objs(*desc, ZYNQMP_DMA_NUM_DESCS);
 	if (!chan->sw_desc_pool)
 		return -ENOMEM;
 

drivers/edac/edac_device.c

···
 	if (!dev_ctl)
 		return NULL;
 
-	dev_inst = kzalloc_objs(struct edac_device_instance, nr_instances,
-				GFP_KERNEL);
+	dev_inst = kzalloc_objs(struct edac_device_instance, nr_instances);
 	if (!dev_inst)
 		goto free;
 
···
 	if (!ctx)
 		return -ENOMEM;
 
-	ras_attr_groups = kzalloc_objs(*ras_attr_groups, attr_gcnt + 1,
-				       GFP_KERNEL);
+	ras_attr_groups = kzalloc_objs(*ras_attr_groups, attr_gcnt + 1);
 	if (!ras_attr_groups)
 		goto ctx_free;
 
···
 	}
 
 	if (mem_repair_cnt) {
-		ctx->mem_repair = kzalloc_objs(*ctx->mem_repair, mem_repair_cnt,
-					       GFP_KERNEL);
+		ctx->mem_repair = kzalloc_objs(*ctx->mem_repair, mem_repair_cnt);
 		if (!ctx->mem_repair)
 			goto data_mem_free;
 	}

drivers/edac/edac_mc.c

···
 		csr->csrow_idx = row;
 		csr->mci = mci;
 		csr->nr_channels = tot_channels;
-		csr->channels = kzalloc_objs(*csr->channels, tot_channels,
-					     GFP_KERNEL);
+		csr->channels = kzalloc_objs(*csr->channels, tot_channels);
 		if (!csr->channels)
 			return -ENOMEM;
 

drivers/edac/i7core_edac.c

···
 	if (!i7core_dev)
 		return NULL;
 
-	i7core_dev->pdev = kzalloc_objs(*i7core_dev->pdev, table->n_devs,
-					GFP_KERNEL);
+	i7core_dev->pdev = kzalloc_objs(*i7core_dev->pdev, table->n_devs);
 	if (!i7core_dev->pdev) {
 		kfree(i7core_dev);
 		return NULL;
···
 		goto err_put_addrmatch;
 
 	if (!pvt->is_registered) {
-		pvt->chancounts_dev = kzalloc_obj(*pvt->chancounts_dev,
-						  GFP_KERNEL);
+		pvt->chancounts_dev = kzalloc_obj(*pvt->chancounts_dev);
 		if (!pvt->chancounts_dev) {
 			rc = -ENOMEM;
 			goto err_del_addrmatch;

drivers/extcon/extcon.c

···
 	if (!edev->max_supported)
 		return 0;
 
-	edev->cables = kzalloc_objs(*edev->cables, edev->max_supported,
-				    GFP_KERNEL);
+	edev->cables = kzalloc_objs(*edev->cables, edev->max_supported);
 	if (!edev->cables)
 		return -ENOMEM;
 
···
 	for (index = 0; edev->mutually_exclusive[index]; index++)
 		;
 
-	edev->attrs_muex = kzalloc_objs(*edev->attrs_muex, index + 1,
-					GFP_KERNEL);
+	edev->attrs_muex = kzalloc_objs(*edev->attrs_muex, index + 1);
 	if (!edev->attrs_muex)
 		return -ENOMEM;
 
-	edev->d_attrs_muex = kzalloc_objs(*edev->d_attrs_muex, index,
-					  GFP_KERNEL);
+	edev->d_attrs_muex = kzalloc_objs(*edev->d_attrs_muex, index);
 	if (!edev->d_attrs_muex) {
 		kfree(edev->attrs_muex);
 		return -ENOMEM;
···
 
 	spin_lock_init(&edev->lock);
 	if (edev->max_supported) {
-		edev->nh = kzalloc_objs(*edev->nh, edev->max_supported,
-					GFP_KERNEL);
+		edev->nh = kzalloc_objs(*edev->nh, edev->max_supported);
 		if (!edev->nh) {
 			ret = -ENOMEM;
 			goto err_alloc_nh;

drivers/firmware/efi/apple-properties.c

···
 			goto skip_device;
 		}
 
-		entry = kzalloc_objs(*entry, dev_header->prop_count + 1,
-				     GFP_KERNEL);
+		entry = kzalloc_objs(*entry, dev_header->prop_count + 1);
 		if (!entry) {
 			dev_err(dev, "cannot allocate properties\n");
 			goto skip_device;

drivers/firmware/efi/test/efi_test.c

···
 	if (qcaps.capsule_count == ULONG_MAX)
 		return -EINVAL;
 
-	capsules = kzalloc_objs(efi_capsule_header_t, qcaps.capsule_count + 1,
-				GFP_KERNEL);
+	capsules = kzalloc_objs(efi_capsule_header_t, qcaps.capsule_count + 1);
 	if (!capsules)
 		return -ENOMEM;
 

drivers/firmware/qcom/qcom_tzmem.c

···
 		return ERR_PTR(-EINVAL);
 	}
 
-	struct qcom_tzmem_pool *pool __free(kfree) = kzalloc_obj(*pool,
-								 GFP_KERNEL);
+	struct qcom_tzmem_pool *pool __free(kfree) = kzalloc_obj(*pool);
 	if (!pool)
 		return ERR_PTR(-ENOMEM);
 

drivers/fpga/dfl.c

···
 
 	/* then add irq resource */
 	if (feature->nr_irqs) {
-		ddev->irqs = kzalloc_objs(*ddev->irqs, feature->nr_irqs,
-					  GFP_KERNEL);
+		ddev->irqs = kzalloc_objs(*ddev->irqs, feature->nr_irqs);
 		if (!ddev->irqs) {
 			ret = -ENOMEM;
 			goto put_dev;
···
 	if (binfo->len - ofst < size)
 		return -EINVAL;
 
-	finfo = kzalloc_flex(*finfo, params, dfh_psize / sizeof(u64),
-			     GFP_KERNEL);
+	finfo = kzalloc_flex(*finfo, params, dfh_psize / sizeof(u64));
 	if (!finfo)
 		return -ENOMEM;
 

drivers/gpib/agilent_82350b/agilent_82350b.c

···
 
 static int agilent_82350b_allocate_private(struct gpib_board *board)
 {
-	board->private_data = kzalloc_obj(struct agilent_82350b_priv,
-					  GFP_KERNEL);
+	board->private_data = kzalloc_obj(struct agilent_82350b_priv);
 	if (!board->private_data)
 		return -ENOMEM;
 	return 0;

drivers/gpib/agilent_82357a/agilent_82357a.c

···
 {
 	struct agilent_82357a_priv *a_priv;
 
-	board->private_data = kzalloc_obj(struct agilent_82357a_priv,
-					  GFP_KERNEL);
+	board->private_data = kzalloc_obj(struct agilent_82357a_priv);
 	if (!board->private_data)
 		return -ENOMEM;
 	a_priv = board->private_data;

drivers/gpib/common/gpib_os.c

···
 		mutex_unlock(&file_priv->descriptors_mutex);
 		return -ERANGE;
 	}
-	file_priv->descriptors[i] = kmalloc_obj(struct gpib_descriptor,
-						GFP_KERNEL);
+	file_priv->descriptors[i] = kmalloc_obj(struct gpib_descriptor);
 	if (!file_priv->descriptors[i]) {
 		mutex_unlock(&file_priv->descriptors_mutex);
 		return -ENOMEM;

drivers/gpio/gpio-sim.c

···
 {
 	int id;
 
-	struct gpio_sim_device *dev __free(kfree) = kzalloc_obj(*dev,
-								GFP_KERNEL);
+	struct gpio_sim_device *dev __free(kfree) = kzalloc_obj(*dev);
 	if (!dev)
 		return ERR_PTR(-ENOMEM);
 

drivers/gpio/gpio-virtuser.c

···
 gpio_virtuser_config_make_device_group(struct config_group *group,
 				       const char *name)
 {
-	struct gpio_virtuser_device *dev __free(kfree) = kzalloc_obj(*dev,
-								     GFP_KERNEL);
+	struct gpio_virtuser_device *dev __free(kfree) = kzalloc_obj(*dev);
 	if (!dev)
 		return ERR_PTR(-ENOMEM);
 

drivers/gpio/gpiolib-shared.c

···
 {
 	char *con_id_cpy __free(kfree) = NULL;
 
-	struct gpio_shared_ref *ref __free(kfree) = kzalloc_obj(*ref,
-								GFP_KERNEL);
+	struct gpio_shared_ref *ref __free(kfree) = kzalloc_obj(*ref);
 	if (!ref)
 		return NULL;
 

drivers/gpu/drm/amd/amdgpu/amdgpu_acp.c

···
 	switch (acp_machine_id) {
 	case ST_JADEITE:
 	{
-		adev->acp.acp_cell = kzalloc_objs(struct mfd_cell, 2,
-						  GFP_KERNEL);
+		adev->acp.acp_cell = kzalloc_objs(struct mfd_cell, 2);
 		if (!adev->acp.acp_cell) {
 			r = -ENOMEM;
 			goto failure;
···
 			goto failure;
 		}
 
-		i2s_pdata = kzalloc_objs(struct i2s_platform_data, 1,
-					 GFP_KERNEL);
+		i2s_pdata = kzalloc_objs(struct i2s_platform_data, 1);
 		if (!i2s_pdata) {
 			r = -ENOMEM;
 			goto failure;
···
 		break;
 	}
 	default:
-		adev->acp.acp_cell = kzalloc_objs(struct mfd_cell, ACP_DEVS,
-						  GFP_KERNEL);
+		adev->acp.acp_cell = kzalloc_objs(struct mfd_cell, ACP_DEVS);
 
 		if (!adev->acp.acp_cell) {
 			r = -ENOMEM;
···
 			goto failure;
 		}
 
-		i2s_pdata = kzalloc_objs(struct i2s_platform_data, 3,
-					 GFP_KERNEL);
+		i2s_pdata = kzalloc_objs(struct i2s_platform_data, 3);
 		if (!i2s_pdata) {
 			r = -ENOMEM;
 			goto failure;

drivers/gpu/drm/amd/amdgpu/amdgpu_cgs.c

···
 
 struct cgs_device *amdgpu_cgs_create_device(struct amdgpu_device *adev)
 {
-	struct amdgpu_cgs_device *cgs_device = kmalloc_obj(*cgs_device,
-							   GFP_KERNEL);
+	struct amdgpu_cgs_device *cgs_device = kmalloc_obj(*cgs_device);
 
 	if (!cgs_device) {
 		drm_err(adev_to_drm(adev), "Couldn't allocate CGS device structure\n");

drivers/gpu/drm/amd/amdgpu/amdgpu_connectors.c

···
 	}
 
 	if (is_dp_bridge) {
-		amdgpu_dig_connector = kzalloc_obj(struct amdgpu_connector_atom_dig,
-						   GFP_KERNEL);
+		amdgpu_dig_connector = kzalloc_obj(struct amdgpu_connector_atom_dig);
 		if (!amdgpu_dig_connector)
 			goto failed;
 		amdgpu_connector->con_priv = amdgpu_dig_connector;
···
 			break;
 		case DRM_MODE_CONNECTOR_DVII:
 		case DRM_MODE_CONNECTOR_DVID:
-			amdgpu_dig_connector = kzalloc_obj(struct amdgpu_connector_atom_dig,
-							   GFP_KERNEL);
+			amdgpu_dig_connector = kzalloc_obj(struct amdgpu_connector_atom_dig);
 			if (!amdgpu_dig_connector)
 				goto failed;
 			amdgpu_connector->con_priv = amdgpu_dig_connector;
···
 			break;
 		case DRM_MODE_CONNECTOR_HDMIA:
 		case DRM_MODE_CONNECTOR_HDMIB:
-			amdgpu_dig_connector = kzalloc_obj(struct amdgpu_connector_atom_dig,
-							   GFP_KERNEL);
+			amdgpu_dig_connector = kzalloc_obj(struct amdgpu_connector_atom_dig);
 			if (!amdgpu_dig_connector)
 				goto failed;
 			amdgpu_connector->con_priv = amdgpu_dig_connector;
···
 				connector->doublescan_allowed = false;
 			break;
 		case DRM_MODE_CONNECTOR_DisplayPort:
-			amdgpu_dig_connector = kzalloc_obj(struct amdgpu_connector_atom_dig,
-							   GFP_KERNEL);
+			amdgpu_dig_connector = kzalloc_obj(struct amdgpu_connector_atom_dig);
 			if (!amdgpu_dig_connector)
 				goto failed;
 			amdgpu_connector->con_priv = amdgpu_dig_connector;
···
 			connector->doublescan_allowed = false;
 			break;
 		case DRM_MODE_CONNECTOR_eDP:
-			amdgpu_dig_connector = kzalloc_obj(struct amdgpu_connector_atom_dig,
-							   GFP_KERNEL);
+			amdgpu_dig_connector = kzalloc_obj(struct amdgpu_connector_atom_dig);
 			if (!amdgpu_dig_connector)
 				goto failed;
 			amdgpu_connector->con_priv = amdgpu_dig_connector;
···
 			connector->doublescan_allowed = false;
 			break;
 		case DRM_MODE_CONNECTOR_LVDS:
-			amdgpu_dig_connector = kzalloc_obj(struct amdgpu_connector_atom_dig,
-							   GFP_KERNEL);
+			amdgpu_dig_connector = kzalloc_obj(struct amdgpu_connector_atom_dig);
 			if (!amdgpu_dig_connector)
 				goto failed;
 			amdgpu_connector->con_priv = amdgpu_dig_connector;

drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c

···
 		return PTR_ERR(chunk_array);
 
 	p->nchunks = cs->in.num_chunks;
-	p->chunks = kvmalloc_objs(struct amdgpu_cs_chunk, p->nchunks,
-				  GFP_KERNEL);
+	p->chunks = kvmalloc_objs(struct amdgpu_cs_chunk, p->nchunks);
 	if (!p->chunks) {
 		ret = -ENOMEM;
 		goto free_chunk;

drivers/gpu/drm/amd/amdgpu/amdgpu_discovery.c

···
 
 	switch (le16_to_cpu(nps_info->v1.header.version_major)) {
 	case 1:
-		mem_ranges = kvzalloc_objs(*mem_ranges, nps_info->v1.count,
-					   GFP_KERNEL);
+		mem_ranges = kvzalloc_objs(*mem_ranges, nps_info->v1.count);
 		if (!mem_ranges)
 			return -ENOMEM;
 		*nps_type = nps_info->v1.nps_type;

drivers/gpu/drm/amd/amdgpu/amdgpu_ring_mux.c

···
 	mux->real_ring = ring;
 	mux->num_ring_entries = 0;
 
-	mux->ring_entry = kzalloc_objs(struct amdgpu_mux_entry, entry_size,
-				       GFP_KERNEL);
+	mux->ring_entry = kzalloc_objs(struct amdgpu_mux_entry, entry_size);
 	if (!mux->ring_entry)
 		return -ENOMEM;
 

drivers/gpu/drm/amd/amdgpu/amdgpu_virt.c

···
 	}
 
 	/* Allocate for init_data_hdr */
-	init_data_hdr = kzalloc_obj(struct amd_sriov_msg_init_data_header,
-				    GFP_KERNEL);
+	init_data_hdr = kzalloc_obj(struct amd_sriov_msg_init_data_header);
 	if (!init_data_hdr)
 		return -ENOMEM;
 

drivers/gpu/drm/amd/amdgpu/atombios_encoders.c

···
 amdgpu_atombios_encoder_get_dig_info(struct amdgpu_encoder *amdgpu_encoder)
 {
 	int encoder_enum = (amdgpu_encoder->encoder_enum & ENUM_ID_MASK) >> ENUM_ID_SHIFT;
-	struct amdgpu_encoder_atom_dig *dig = kzalloc_obj(struct amdgpu_encoder_atom_dig,
-							  GFP_KERNEL);
+	struct amdgpu_encoder_atom_dig *dig = kzalloc_obj(struct amdgpu_encoder_atom_dig);
 
 	if (!dig)
 		return NULL;

drivers/gpu/drm/amd/amdgpu/dce_v10_0.c

···
 
 	/* DCE10 has audio blocks tied to DIG encoders */
 	for (i = 0; i < adev->mode_info.num_dig; i++) {
-		adev->mode_info.afmt[i] = kzalloc_obj(struct amdgpu_afmt,
-						      GFP_KERNEL);
+		adev->mode_info.afmt[i] = kzalloc_obj(struct amdgpu_afmt);
 		if (adev->mode_info.afmt[i]) {
 			adev->mode_info.afmt[i]->offset = dig_offsets[i];
 			adev->mode_info.afmt[i]->id = i;

drivers/gpu/drm/amd/amdgpu/dce_v6_0.c

···
 
 	/* DCE6 has audio blocks tied to DIG encoders */
 	for (i = 0; i < adev->mode_info.num_dig; i++) {
-		adev->mode_info.afmt[i] = kzalloc_obj(struct amdgpu_afmt,
-						      GFP_KERNEL);
+		adev->mode_info.afmt[i] = kzalloc_obj(struct amdgpu_afmt);
 		if (adev->mode_info.afmt[i]) {
 			adev->mode_info.afmt[i]->offset = dig_offsets[i];
 			adev->mode_info.afmt[i]->id = i;

drivers/gpu/drm/amd/amdgpu/dce_v8_0.c

···
 
 	/* DCE8 has audio blocks tied to DIG encoders */
 	for (i = 0; i < adev->mode_info.num_dig; i++) {
-		adev->mode_info.afmt[i] = kzalloc_obj(struct amdgpu_afmt,
-						      GFP_KERNEL);
+		adev->mode_info.afmt[i] = kzalloc_obj(struct amdgpu_afmt);
 		if (adev->mode_info.afmt[i]) {
 			adev->mode_info.afmt[i]->offset = dig_offsets[i];
 			adev->mode_info.afmt[i]->id = i;

drivers/gpu/drm/amd/amdgpu/gmc_v7_0.c

···
 		adev->vm_manager.vram_base_offset = 0;
 	}
 
-	adev->gmc.vm_fault_info = kmalloc_obj(struct kfd_vm_fault_info,
-					      GFP_KERNEL);
+	adev->gmc.vm_fault_info = kmalloc_obj(struct kfd_vm_fault_info);
 	if (!adev->gmc.vm_fault_info)
 		return -ENOMEM;
 	atomic_set_release(&adev->gmc.vm_fault_info_updated, 0);

drivers/gpu/drm/amd/amdgpu/gmc_v8_0.c

···
 		adev->vm_manager.vram_base_offset = 0;
 	}
 
-	adev->gmc.vm_fault_info = kmalloc_obj(struct kfd_vm_fault_info,
-					      GFP_KERNEL);
+	adev->gmc.vm_fault_info = kmalloc_obj(struct kfd_vm_fault_info);
 	if (!adev->gmc.vm_fault_info)
 		return -ENOMEM;
 	atomic_set_release(&adev->gmc.vm_fault_info_updated, 0);

drivers/gpu/drm/amd/amdkfd/kfd_chardev.c

···
 	if (*priv_offset + (args->num_devices * sizeof(*device_privs)) > max_priv_data_size)
 		return -EINVAL;
 
-	device_buckets = kmalloc_objs(*device_buckets, args->num_devices,
-				      GFP_KERNEL);
+	device_buckets = kmalloc_objs(*device_buckets, args->num_devices);
 	if (!device_buckets)
 		return -ENOMEM;
 

drivers/gpu/drm/amd/amdkfd/kfd_events.c

···
 	struct kfd_event_waiter *event_waiters;
 	uint32_t i;
 
-	event_waiters = kzalloc_objs(struct kfd_event_waiter, num_events,
-				     GFP_KERNEL);
+	event_waiters = kzalloc_objs(struct kfd_event_waiter, num_events);
 	if (!event_waiters)
 		return NULL;
 

drivers/gpu/drm/amd/amdkfd/kfd_process.c

···
 	wave_cnt = 0;
 	max_waves_per_cu = 0;
 
-	cu_occupancy = kzalloc_objs(*cu_occupancy, AMDGPU_MAX_QUEUES,
-				    GFP_KERNEL);
+	cu_occupancy = kzalloc_objs(*cu_occupancy, AMDGPU_MAX_QUEUES);
 	if (!cu_occupancy)
 		return -ENOMEM;
 

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

···
 	int i = 0;
 	struct hpd_rx_irq_offload_work_queue *hpd_rx_offload_wq = NULL;
 
-	hpd_rx_offload_wq = kzalloc_objs(*hpd_rx_offload_wq, max_caps,
-					 GFP_KERNEL);
+	hpd_rx_offload_wq = kzalloc_objs(*hpd_rx_offload_wq, max_caps);
 
 	if (!hpd_rx_offload_wq)
 		return NULL;
···
 	}
 	if (dc_is_dmub_outbox_supported(adev->dm.dc)) {
 		init_completion(&adev->dm.dmub_aux_transfer_done);
-		adev->dm.dmub_notify = kzalloc_obj(struct dmub_notification,
-						   GFP_KERNEL);
+		adev->dm.dmub_notify = kzalloc_obj(struct dmub_notification);
 		if (!adev->dm.dmub_notify) {
 			drm_info(adev_to_drm(adev), "fail to allocate adev->dm.dmub_notify");
 			goto error;
···
 static void schedule_hpd_rx_offload_work(struct amdgpu_device *adev, struct hpd_rx_irq_offload_work_queue *offload_wq,
 							union hpd_irq_data hpd_irq_data)
 {
-	struct hpd_rx_irq_offload_work *offload_work = kzalloc_obj(*offload_work,
-								   GFP_KERNEL);
+	struct hpd_rx_irq_offload_work *offload_work = kzalloc_obj(*offload_work);
 
 	if (!offload_work) {
 		drm_err(adev_to_drm(adev), "Failed to allocate hpd_rx_irq_offload_work.\n");
···
 		link = dc_get_link_at_index(dm->dc, i);
 
 		if (link->connector_signal == SIGNAL_TYPE_VIRTUAL) {
-			struct amdgpu_dm_wb_connector *wbcon = kzalloc_obj(*wbcon,
-									   GFP_KERNEL);
+			struct amdgpu_dm_wb_connector *wbcon = kzalloc_obj(*wbcon);
 
 			if (!wbcon) {
 				drm_err(adev_to_drm(adev), "KMS: Failed to allocate writeback connector\n");

drivers/gpu/drm/amd/display/dc/basics/dce_calcs.c

···
 	if (!sclk)
 		goto free_yclk;
 
-	tiling_mode = kzalloc_objs(*tiling_mode, maximum_number_of_surfaces,
-				   GFP_KERNEL);
+	tiling_mode = kzalloc_objs(*tiling_mode, maximum_number_of_surfaces);
 	if (!tiling_mode)
 		goto free_sclk;
 
-	surface_type = kzalloc_objs(*surface_type, maximum_number_of_surfaces,
-				    GFP_KERNEL);
+	surface_type = kzalloc_objs(*surface_type, maximum_number_of_surfaces);
 	if (!surface_type)
 		goto free_tiling_mode;
 
···
 	int pipe_count,
 	struct dce_bw_output *calcs_output)
 {
-	struct bw_calcs_data *data = kzalloc_obj(struct bw_calcs_data,
-						 GFP_KERNEL);
+	struct bw_calcs_data *data = kzalloc_obj(struct bw_calcs_data);
 	if (!data)
 		return false;
 

drivers/gpu/drm/amd/display/dc/clk_mgr/clk_mgr.c

···
 	switch (asic_id.chip_family) {
 #if defined(CONFIG_DRM_AMD_DC_SI)
 	case FAMILY_SI: {
-		struct clk_mgr_internal *clk_mgr = kzalloc_obj(*clk_mgr,
-							       GFP_KERNEL);
+		struct clk_mgr_internal *clk_mgr = kzalloc_obj(*clk_mgr);
 
 		if (clk_mgr == NULL) {
 			BREAK_TO_DEBUGGER();
···
 #endif
 	case FAMILY_CI:
 	case FAMILY_KV: {
-		struct clk_mgr_internal *clk_mgr = kzalloc_obj(*clk_mgr,
-							       GFP_KERNEL);
+		struct clk_mgr_internal *clk_mgr = kzalloc_obj(*clk_mgr);
 
 		if (clk_mgr == NULL) {
 			BREAK_TO_DEBUGGER();
···
 		return &clk_mgr->base;
 	}
 	case FAMILY_CZ: {
-		struct clk_mgr_internal *clk_mgr = kzalloc_obj(*clk_mgr,
-							       GFP_KERNEL);
+		struct clk_mgr_internal *clk_mgr = kzalloc_obj(*clk_mgr);
 
 		if (clk_mgr == NULL) {
 			BREAK_TO_DEBUGGER();
···
 		return &clk_mgr->base;
 	}
 	case FAMILY_VI: {
-		struct clk_mgr_internal *clk_mgr = kzalloc_obj(*clk_mgr,
-							       GFP_KERNEL);
+		struct clk_mgr_internal *clk_mgr = kzalloc_obj(*clk_mgr);
 
 		if (clk_mgr == NULL) {
 			BREAK_TO_DEBUGGER();
···
 		return &clk_mgr->base;
 	}
 	case FAMILY_AI: {
-		struct clk_mgr_internal *clk_mgr = kzalloc_obj(*clk_mgr,
-							       GFP_KERNEL);
+		struct clk_mgr_internal *clk_mgr = kzalloc_obj(*clk_mgr);
 
 		if (clk_mgr == NULL) {
 			BREAK_TO_DEBUGGER();
···
 	}
 #if defined(CONFIG_DRM_AMD_DC_FP)
 	case FAMILY_RV: {
-		struct clk_mgr_internal *clk_mgr = kzalloc_obj(*clk_mgr,
-							       GFP_KERNEL);
+		struct clk_mgr_internal *clk_mgr = kzalloc_obj(*clk_mgr);
 
 		if (clk_mgr == NULL) {
 			BREAK_TO_DEBUGGER();
···
 		return &clk_mgr->base;
 	}
 	case FAMILY_NV: {
-		struct clk_mgr_internal *clk_mgr = kzalloc_obj(*clk_mgr,
-							       GFP_KERNEL);
+		struct clk_mgr_internal *clk_mgr = kzalloc_obj(*clk_mgr);
 
 		if (clk_mgr == NULL) {
 			BREAK_TO_DEBUGGER();
···
 	}
 	case FAMILY_VGH:
 		if (ASICREV_IS_VANGOGH(asic_id.hw_internal_rev)) {
-			struct clk_mgr_vgh *clk_mgr = kzalloc_obj(*clk_mgr,
-								  GFP_KERNEL);
+			struct clk_mgr_vgh *clk_mgr = kzalloc_obj(*clk_mgr);
 
 			if (clk_mgr == NULL) {
 				BREAK_TO_DEBUGGER();
···
 		break;
 
 	case FAMILY_YELLOW_CARP: {
-		struct clk_mgr_dcn31 *clk_mgr = kzalloc_obj(*clk_mgr,
-							    GFP_KERNEL);
+		struct clk_mgr_dcn31 *clk_mgr = kzalloc_obj(*clk_mgr);
 
 		if (clk_mgr == NULL) {
 			BREAK_TO_DEBUGGER();
···
 	}
 		break;
 	case AMDGPU_FAMILY_GC_10_3_6: {
-		struct clk_mgr_dcn315 *clk_mgr = kzalloc_obj(*clk_mgr,
-							     GFP_KERNEL);
+		struct clk_mgr_dcn315 *clk_mgr = kzalloc_obj(*clk_mgr);
 
 		if (clk_mgr == NULL) {
 			BREAK_TO_DEBUGGER();
···
 	}
 		break;
 	case AMDGPU_FAMILY_GC_10_3_7: {
-		struct clk_mgr_dcn316 *clk_mgr = kzalloc_obj(*clk_mgr,
-							     GFP_KERNEL);
+		struct clk_mgr_dcn316 *clk_mgr = kzalloc_obj(*clk_mgr);
 
 		if (clk_mgr == NULL) {
 			BREAK_TO_DEBUGGER();
···
 	}
 		break;
 	case AMDGPU_FAMILY_GC_11_0_0: {
-		struct clk_mgr_internal *clk_mgr = kzalloc_obj(*clk_mgr,
-							       GFP_KERNEL);
+		struct clk_mgr_internal *clk_mgr = kzalloc_obj(*clk_mgr);
 
 		if (clk_mgr == NULL) {
 			BREAK_TO_DEBUGGER();
···
 	}
 
 	case AMDGPU_FAMILY_GC_11_0_1: {
-		struct clk_mgr_dcn314 *clk_mgr = kzalloc_obj(*clk_mgr,
-							     GFP_KERNEL);
+		struct clk_mgr_dcn314 *clk_mgr = kzalloc_obj(*clk_mgr);
 
 		if (clk_mgr == NULL) {
 			BREAK_TO_DEBUGGER();
···
 	break;
 
 	case AMDGPU_FAMILY_GC_11_5_0: {
-		struct clk_mgr_dcn35 *clk_mgr = kzalloc_obj(*clk_mgr,
-							    GFP_KERNEL);
+		struct clk_mgr_dcn35 *clk_mgr = kzalloc_obj(*clk_mgr);
 
 		if (clk_mgr == NULL) {
 			BREAK_TO_DEBUGGER();

drivers/gpu/drm/amd/display/dc/clk_mgr/dcn30/dcn30_clk_mgr.c

···
 
 	dce_clock_read_ss_info(clk_mgr);
 
-	clk_mgr->base.bw_params = kzalloc_obj(*clk_mgr->base.bw_params,
-					      GFP_KERNEL);
+	clk_mgr->base.bw_params = kzalloc_obj(*clk_mgr->base.bw_params);
 	if (!clk_mgr->base.bw_params) {
 		BREAK_TO_DEBUGGER();
 		return;

drivers/gpu/drm/amd/display/dc/clk_mgr/dcn32/dcn32_clk_mgr.c

···
 
 	clk_mgr->smu_present = false;
 
-	clk_mgr->base.bw_params = kzalloc_obj(*clk_mgr->base.bw_params,
-					      GFP_KERNEL);
+	clk_mgr->base.bw_params = kzalloc_obj(*clk_mgr->base.bw_params);
 	if (!clk_mgr->base.bw_params) {
 		BREAK_TO_DEBUGGER();
 		return;

drivers/gpu/drm/amd/display/dc/clk_mgr/dcn401/dcn401_clk_mgr.c

···
 		struct dccg *dccg)
 {
 	struct clk_log_info log_info = {0};
-	struct dcn401_clk_mgr *clk_mgr401 = kzalloc_obj(struct dcn401_clk_mgr,
-							GFP_KERNEL);
+	struct dcn401_clk_mgr *clk_mgr401 = kzalloc_obj(struct dcn401_clk_mgr);
 	struct clk_mgr_internal *clk_mgr;
 
 	if (!clk_mgr401)
···
 
 	clk_mgr->smu_present = false;
 
-	clk_mgr->base.bw_params = kzalloc_obj(*clk_mgr->base.bw_params,
-					      GFP_KERNEL);
+	clk_mgr->base.bw_params = kzalloc_obj(*clk_mgr->base.bw_params);
 	if (!clk_mgr->base.bw_params) {
 		BREAK_TO_DEBUGGER();
 		kfree(clk_mgr401);

drivers/gpu/drm/amd/display/dc/core/dc.c

···
 	enum gpio_result gpio_result = GPIO_RESULT_NON_SPECIFIC_ERROR;
 	struct gpio_pin_info pin_info;
 	struct gpio *generic;
-	struct gpio_generic_mux_config *config = kzalloc_obj(struct gpio_generic_mux_config,
-							     GFP_KERNEL);
+	struct gpio_generic_mux_config *config = kzalloc_obj(struct gpio_generic_mux_config);
 
 	if (!config)
 		return false;

drivers/gpu/drm/amd/display/dc/dce/dce_clock_source.c

···
 	if (*ss_entries_num == 0)
 		return;
 
-	ss_info = kzalloc_objs(struct spread_spectrum_info, *ss_entries_num,
-			       GFP_KERNEL);
+	ss_info = kzalloc_objs(struct spread_spectrum_info, *ss_entries_num);
 	ss_info_cur = ss_info;
 	if (ss_info == NULL)
 		return;
 
-	ss_data = kzalloc_objs(struct spread_spectrum_data, *ss_entries_num,
-			       GFP_KERNEL);
+	ss_data = kzalloc_objs(struct spread_spectrum_data, *ss_entries_num);
 	if (ss_data == NULL)
 		goto out_free_info;
 

drivers/gpu/drm/amd/display/dc/resource/dce100/dce100_resource.c

···
 	struct dc_context *ctx,
 	uint32_t inst)
 {
-	struct dce_mem_input *dce_mi = kzalloc_obj(struct dce_mem_input,
-						   GFP_KERNEL);
+	struct dce_mem_input *dce_mi = kzalloc_obj(struct dce_mem_input);
 
 	if (!dce_mi) {
 		BREAK_TO_DEBUGGER();

drivers/gpu/drm/amd/display/dc/resource/dce110/dce110_resource.c

···
 	struct dc_context *ctx,
 	uint32_t inst)
 {
-	struct dce_mem_input *dce_mi = kzalloc_obj(struct dce_mem_input,
-						   GFP_KERNEL);
+	struct dce_mem_input *dce_mi = kzalloc_obj(struct dce_mem_input);
 
 	if (!dce_mi) {
 		BREAK_TO_DEBUGGER();
···
 
 static bool underlay_create(struct dc_context *ctx, struct resource_pool *pool)
 {
-	struct dce110_timing_generator *dce110_tgv = kzalloc_obj(*dce110_tgv,
-								 GFP_KERNEL);
-	struct dce_transform *dce110_xfmv = kzalloc_obj(*dce110_xfmv,
-							GFP_KERNEL);
+	struct dce110_timing_generator *dce110_tgv = kzalloc_obj(*dce110_tgv);
+	struct dce_transform *dce110_xfmv = kzalloc_obj(*dce110_xfmv);
 	struct dce_mem_input *dce110_miv = kzalloc_obj(*dce110_miv);
 	struct dce110_opp *dce110_oppv = kzalloc_obj(*dce110_oppv);
 

drivers/gpu/drm/amd/display/dc/resource/dce112/dce112_resource.c

···
 	struct dc_context *ctx,
 	uint32_t inst)
 {
-	struct dce_mem_input *dce_mi = kzalloc_obj(struct dce_mem_input,
-						   GFP_KERNEL);
+	struct dce_mem_input *dce_mi = kzalloc_obj(struct dce_mem_input);
 
 	if (!dce_mi) {
 		BREAK_TO_DEBUGGER();

drivers/gpu/drm/amd/display/dc/resource/dce120/dce120_resource.c

···
 	struct dc_context *ctx,
 	uint32_t inst)
 {
-	struct dce_mem_input *dce_mi = kzalloc_obj(struct dce_mem_input,
-						   GFP_KERNEL);
+	struct dce_mem_input *dce_mi = kzalloc_obj(struct dce_mem_input);
 
 	if (!dce_mi) {
 		BREAK_TO_DEBUGGER();

drivers/gpu/drm/amd/display/dc/resource/dce60/dce60_resource.c

···
 	struct dc_context *ctx,
 	uint32_t inst)
 {
-	struct dce_mem_input *dce_mi = kzalloc_obj(struct dce_mem_input,
-						   GFP_KERNEL);
+	struct dce_mem_input *dce_mi = kzalloc_obj(struct dce_mem_input);
 
 	if (!dce_mi) {
 		BREAK_TO_DEBUGGER();

drivers/gpu/drm/amd/display/dc/resource/dce80/dce80_resource.c

···
 	struct dc_context *ctx,
 	uint32_t inst)
 {
-	struct dce_mem_input *dce_mi = kzalloc_obj(struct dce_mem_input,
-						   GFP_KERNEL);
+	struct dce_mem_input *dce_mi = kzalloc_obj(struct dce_mem_input);
 
 	if (!dce_mi) {
 		BREAK_TO_DEBUGGER();

drivers/gpu/drm/amd/display/dc/resource/dcn10/dcn10_resource.c

···
 
 static struct hubbub *dcn10_hubbub_create(struct dc_context *ctx)
 {
-	struct dcn10_hubbub *dcn10_hubbub = kzalloc_obj(struct dcn10_hubbub,
-							GFP_KERNEL);
+	struct dcn10_hubbub *dcn10_hubbub = kzalloc_obj(struct dcn10_hubbub);
 
 	if (!dcn10_hubbub)
 		return NULL;

drivers/gpu/drm/amd/display/dc/resource/dcn20/dcn20_resource.c

···
 struct hubbub *dcn20_hubbub_create(struct dc_context *ctx)
 {
 	int i;
-	struct dcn20_hubbub *hubbub = kzalloc_obj(struct dcn20_hubbub,
-						  GFP_KERNEL);
+	struct dcn20_hubbub *hubbub = kzalloc_obj(struct dcn20_hubbub);
 
 	if (!hubbub)
 		return NULL;
···
 	uint32_t pipe_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < pipe_count; i++) {
-		struct dcn20_dwbc *dwbc20 = kzalloc_obj(struct dcn20_dwbc,
-							GFP_KERNEL);
+		struct dcn20_dwbc *dwbc20 = kzalloc_obj(struct dcn20_dwbc);
 
 		if (!dwbc20) {
 			dm_error("DC: failed to create dwbc20!\n");
···
 	ASSERT(pipe_count > 0);
 
 	for (i = 0; i < pipe_count; i++) {
-		struct dcn20_mmhubbub *mcif_wb20 = kzalloc_obj(struct dcn20_mmhubbub,
-							       GFP_KERNEL);
+		struct dcn20_mmhubbub *mcif_wb20 = kzalloc_obj(struct dcn20_mmhubbub);
 
 		if (!mcif_wb20) {
 			dm_error("DC: failed to create mcif_wb20!\n");

drivers/gpu/drm/amd/display/dc/resource/dcn201/dcn201_resource.c

···
 
 static struct hubbub *dcn201_hubbub_create(struct dc_context *ctx)
 {
-	struct dcn20_hubbub *hubbub = kzalloc_obj(struct dcn20_hubbub,
-						  GFP_KERNEL);
+	struct dcn20_hubbub *hubbub = kzalloc_obj(struct dcn20_hubbub);
 
 	if (!hubbub)
 		return NULL;

drivers/gpu/drm/amd/display/dc/resource/dcn21/dcn21_resource.c

···
 {
 	int i;
 
-	struct dcn20_hubbub *hubbub = kzalloc_obj(struct dcn20_hubbub,
-						  GFP_KERNEL);
+	struct dcn20_hubbub *hubbub = kzalloc_obj(struct dcn20_hubbub);
 
 	if (!hubbub)
 		return NULL;

drivers/gpu/drm/amd/display/dc/resource/dcn30/dcn30_resource.c

···
 {
 	int i;
 
-	struct dcn20_hubbub *hubbub3 = kzalloc_obj(struct dcn20_hubbub,
-						   GFP_KERNEL);
+	struct dcn20_hubbub *hubbub3 = kzalloc_obj(struct dcn20_hubbub);
 
 	if (!hubbub3)
 		return NULL;
···
 	uint32_t pipe_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < pipe_count; i++) {
-		struct dcn30_dwbc *dwbc30 = kzalloc_obj(struct dcn30_dwbc,
-							GFP_KERNEL);
+		struct dcn30_dwbc *dwbc30 = kzalloc_obj(struct dcn30_dwbc);
 
 		if (!dwbc30) {
 			dm_error("DC: failed to create dwbc30!\n");
···
 	uint32_t pipe_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < pipe_count; i++) {
-		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub,
-							       GFP_KERNEL);
+		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub);
 
 		if (!mcif_wb30) {
 			dm_error("DC: failed to create mcif_wb30!\n");

drivers/gpu/drm/amd/display/dc/resource/dcn301/dcn301_resource.c

···
 {
 	int i;
 
-	struct dcn20_hubbub *hubbub3 = kzalloc_obj(struct dcn20_hubbub,
-						   GFP_KERNEL);
+	struct dcn20_hubbub *hubbub3 = kzalloc_obj(struct dcn20_hubbub);
 
 	if (!hubbub3)
 		return NULL;
···
 	uint32_t pipe_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < pipe_count; i++) {
-		struct dcn30_dwbc *dwbc30 = kzalloc_obj(struct dcn30_dwbc,
-							GFP_KERNEL);
+		struct dcn30_dwbc *dwbc30 = kzalloc_obj(struct dcn30_dwbc);
 
 		if (!dwbc30) {
 			dm_error("DC: failed to create dwbc30!\n");
···
 	uint32_t pipe_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < pipe_count; i++) {
-		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub,
-							       GFP_KERNEL);
+		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub);
 
 		if (!mcif_wb30) {
 			dm_error("DC: failed to create mcif_wb30!\n");

drivers/gpu/drm/amd/display/dc/resource/dcn302/dcn302_resource.c

···
 {
 	int i;
 
-	struct dcn20_hubbub *hubbub3 = kzalloc_obj(struct dcn20_hubbub,
-						   GFP_KERNEL);
+	struct dcn20_hubbub *hubbub3 = kzalloc_obj(struct dcn20_hubbub);
 
 	if (!hubbub3)
 		return NULL;
···
 static struct clock_source *dcn302_clock_source_create(struct dc_context *ctx, struct dc_bios *bios,
 		enum clock_source_id id, const struct dce110_clk_src_regs *regs, bool dp_clk_src)
 {
-	struct dce110_clk_src *clk_src = kzalloc_obj(struct dce110_clk_src,
-						     GFP_KERNEL);
+	struct dce110_clk_src *clk_src = kzalloc_obj(struct dce110_clk_src);
 
 	if (!clk_src)
 		return NULL;
···
 	uint32_t pipe_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < pipe_count; i++) {
-		struct dcn30_dwbc *dwbc30 = kzalloc_obj(struct dcn30_dwbc,
-							GFP_KERNEL);
+		struct dcn30_dwbc *dwbc30 = kzalloc_obj(struct dcn30_dwbc);
 
 		if (!dwbc30) {
 			dm_error("DC: failed to create dwbc30!\n");
···
 	uint32_t pipe_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < pipe_count; i++) {
-		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub,
-							       GFP_KERNEL);
+		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub);
 
 		if (!mcif_wb30) {
 			dm_error("DC: failed to create mcif_wb30!\n");
···
 
 static struct dce_aux *dcn302_aux_engine_create(struct dc_context *ctx, uint32_t inst)
 {
-	struct aux_engine_dce110 *aux_engine = kzalloc_obj(struct aux_engine_dce110,
-							   GFP_KERNEL);
+	struct aux_engine_dce110 *aux_engine = kzalloc_obj(struct aux_engine_dce110);
 
 	if (!aux_engine)
 		return NULL;
···
 
 static struct dce_i2c_hw *dcn302_i2c_hw_create(struct dc_context *ctx, uint32_t inst)
 {
-	struct dce_i2c_hw *dce_i2c_hw = kzalloc_obj(struct dce_i2c_hw,
-						    GFP_KERNEL);
+	struct dce_i2c_hw *dce_i2c_hw = kzalloc_obj(struct dce_i2c_hw);
 
 	if (!dce_i2c_hw)
 		return NULL;
···
 	struct dc_context *ctx,
 	const struct encoder_init_data *enc_init_data)
 {
-	struct dcn20_link_encoder *enc20 = kzalloc_obj(struct dcn20_link_encoder,
-						       GFP_KERNEL);
+	struct dcn20_link_encoder *enc20 = kzalloc_obj(struct dcn20_link_encoder);
 
 	if (!enc20 || enc_init_data->hpd_source >= ARRAY_SIZE(link_enc_hpd_regs))
 		return NULL;
···
 
 static struct panel_cntl *dcn302_panel_cntl_create(const struct panel_cntl_init_data *init_data)
 {
-	struct dce_panel_cntl *panel_cntl = kzalloc_obj(struct dce_panel_cntl,
-							GFP_KERNEL);
+	struct dce_panel_cntl *panel_cntl = kzalloc_obj(struct dce_panel_cntl);
 
 	if (!panel_cntl)
 		return NULL;
···
 
 struct resource_pool *dcn302_create_resource_pool(const struct dc_init_data *init_data, struct dc *dc)
 {
-	struct resource_pool *pool = kzalloc_obj(struct resource_pool,
-						 GFP_KERNEL);
+	struct resource_pool *pool = kzalloc_obj(struct resource_pool);
 
 	if (!pool)
 		return NULL;

drivers/gpu/drm/amd/display/dc/resource/dcn303/dcn303_resource.c

···
 {
 	int i;
 
-	struct dcn20_hubbub *hubbub3 = kzalloc_obj(struct dcn20_hubbub,
-						   GFP_KERNEL);
+	struct dcn20_hubbub *hubbub3 = kzalloc_obj(struct dcn20_hubbub);
 
 	if (!hubbub3)
 		return NULL;
···
 static struct clock_source *dcn303_clock_source_create(struct dc_context *ctx, struct dc_bios *bios,
 		enum clock_source_id id, const struct dce110_clk_src_regs *regs, bool dp_clk_src)
 {
-	struct dce110_clk_src *clk_src = kzalloc_obj(struct dce110_clk_src,
-						     GFP_KERNEL);
+	struct dce110_clk_src *clk_src = kzalloc_obj(struct dce110_clk_src);
 
 	if (!clk_src)
 		return NULL;
···
 	uint32_t pipe_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < pipe_count; i++) {
-		struct dcn30_dwbc *dwbc30 = kzalloc_obj(struct dcn30_dwbc,
-							GFP_KERNEL);
+		struct dcn30_dwbc *dwbc30 = kzalloc_obj(struct dcn30_dwbc);
 
 		if (!dwbc30) {
 			dm_error("DC: failed to create dwbc30!\n");
···
 	uint32_t pipe_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < pipe_count; i++) {
-		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub,
-							       GFP_KERNEL);
+		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub);
 
 		if (!mcif_wb30) {
 			dm_error("DC: failed to create mcif_wb30!\n");
···
 
 static struct dce_aux *dcn303_aux_engine_create(struct dc_context *ctx, uint32_t inst)
 {
-	struct aux_engine_dce110 *aux_engine = kzalloc_obj(struct aux_engine_dce110,
-							   GFP_KERNEL);
+	struct aux_engine_dce110 *aux_engine = kzalloc_obj(struct aux_engine_dce110);
 
 	if (!aux_engine)
 		return NULL;
···
 
 static struct dce_i2c_hw *dcn303_i2c_hw_create(struct dc_context *ctx, uint32_t inst)
 {
-	struct dce_i2c_hw *dce_i2c_hw = kzalloc_obj(struct dce_i2c_hw,
-						    GFP_KERNEL);
+	struct dce_i2c_hw *dce_i2c_hw = kzalloc_obj(struct dce_i2c_hw);
 
 	if (!dce_i2c_hw)
 		return NULL;
···
 	struct dc_context *ctx,
 	const struct encoder_init_data *enc_init_data)
 {
-	struct dcn20_link_encoder *enc20 = kzalloc_obj(struct dcn20_link_encoder,
-						       GFP_KERNEL);
+	struct dcn20_link_encoder *enc20 = kzalloc_obj(struct dcn20_link_encoder);
 
 	if (!enc20 || enc_init_data->hpd_source >= ARRAY_SIZE(link_enc_hpd_regs))
 		return NULL;
···
 
 static struct panel_cntl *dcn303_panel_cntl_create(const struct panel_cntl_init_data *init_data)
 {
-	struct dce_panel_cntl *panel_cntl = kzalloc_obj(struct dce_panel_cntl,
-							GFP_KERNEL);
+	struct dce_panel_cntl *panel_cntl = kzalloc_obj(struct dce_panel_cntl);
 
 	if (!panel_cntl)
 		return NULL;
···
 
 struct resource_pool *dcn303_create_resource_pool(const struct dc_init_data *init_data, struct dc *dc)
 {
-	struct resource_pool *pool = kzalloc_obj(struct resource_pool,
-						 GFP_KERNEL);
+	struct resource_pool *pool = kzalloc_obj(struct resource_pool);
 
 	if (!pool)
 		return NULL;

drivers/gpu/drm/amd/display/dc/resource/dcn31/dcn31_resource.c

···
 {
 	int i;
 
-	struct dcn20_hubbub *hubbub3 = kzalloc_obj(struct dcn20_hubbub,
-						   GFP_KERNEL);
+	struct dcn20_hubbub *hubbub3 = kzalloc_obj(struct dcn20_hubbub);
 
 	if (!hubbub3)
 		return NULL;
···
 	apg_inst = hpo_dp_inst;
 
 	/* allocate HPO stream encoder and create VPG sub-block */
-	hpo_dp_enc31 = kzalloc_obj(struct dcn31_hpo_dp_stream_encoder,
-				   GFP_KERNEL);
+	hpo_dp_enc31 = kzalloc_obj(struct dcn31_hpo_dp_stream_encoder);
 	vpg = dcn31_vpg_create(ctx, vpg_inst);
 	apg = dcn31_apg_create(ctx, apg_inst);
 
···
 	uint32_t pipe_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < pipe_count; i++) {
-		struct dcn30_dwbc *dwbc30 = kzalloc_obj(struct dcn30_dwbc,
-							GFP_KERNEL);
+		struct dcn30_dwbc *dwbc30 = kzalloc_obj(struct dcn30_dwbc);
 
 		if (!dwbc30) {
 			dm_error("DC: failed to create dwbc30!\n");
···
 	uint32_t pipe_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < pipe_count; i++) {
-		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub,
-							       GFP_KERNEL);
+		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub);
 
 		if (!mcif_wb30) {
 			dm_error("DC: failed to create mcif_wb30!\n");

drivers/gpu/drm/amd/display/dc/resource/dcn314/dcn314_resource.c

···
 {
 	int i;
 
-	struct dcn20_hubbub *hubbub3 = kzalloc_obj(struct dcn20_hubbub,
-						   GFP_KERNEL);
+	struct dcn20_hubbub *hubbub3 = kzalloc_obj(struct dcn20_hubbub);
 
 	if (!hubbub3)
 		return NULL;
···
 	apg_inst = hpo_dp_inst;
 
 	/* allocate HPO stream encoder and create VPG sub-block */
-	hpo_dp_enc31 = kzalloc_obj(struct dcn31_hpo_dp_stream_encoder,
-				   GFP_KERNEL);
+	hpo_dp_enc31 = kzalloc_obj(struct dcn31_hpo_dp_stream_encoder);
 	vpg = dcn31_vpg_create(ctx, vpg_inst);
 	apg = dcn31_apg_create(ctx, apg_inst);
 
···
 	uint32_t pipe_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < pipe_count; i++) {
-		struct dcn30_dwbc *dwbc30 = kzalloc_obj(struct dcn30_dwbc,
-							GFP_KERNEL);
+		struct dcn30_dwbc *dwbc30 = kzalloc_obj(struct dcn30_dwbc);
 
 		if (!dwbc30) {
 			dm_error("DC: failed to create dwbc30!\n");
···
 	uint32_t pipe_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < pipe_count; i++) {
-		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub,
-							       GFP_KERNEL);
+		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub);
 
 		if (!mcif_wb30) {
 			dm_error("DC: failed to create mcif_wb30!\n");

drivers/gpu/drm/amd/display/dc/resource/dcn315/dcn315_resource.c

···
 {
 	int i;
 
-	struct dcn20_hubbub *hubbub3 = kzalloc_obj(struct dcn20_hubbub,
-						   GFP_KERNEL);
+	struct dcn20_hubbub *hubbub3 = kzalloc_obj(struct dcn20_hubbub);
 
 	if (!hubbub3)
 		return NULL;
···
 	apg_inst = hpo_dp_inst;
 
 	/* allocate HPO stream encoder and create VPG sub-block */
-	hpo_dp_enc31 = kzalloc_obj(struct dcn31_hpo_dp_stream_encoder,
-				   GFP_KERNEL);
+	hpo_dp_enc31 = kzalloc_obj(struct dcn31_hpo_dp_stream_encoder);
 	vpg = dcn31_vpg_create(ctx, vpg_inst);
 	apg = dcn31_apg_create(ctx, apg_inst);
 
···
 	uint32_t pipe_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < pipe_count; i++) {
-		struct dcn30_dwbc *dwbc30 = kzalloc_obj(struct dcn30_dwbc,
-							GFP_KERNEL);
+		struct dcn30_dwbc *dwbc30 = kzalloc_obj(struct dcn30_dwbc);
 
 		if (!dwbc30) {
 			dm_error("DC: failed to create dwbc30!\n");
···
 	uint32_t pipe_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < pipe_count; i++) {
-		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub,
-							       GFP_KERNEL);
+		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub);
 
 		if (!mcif_wb30) {
 			dm_error("DC: failed to create mcif_wb30!\n");

drivers/gpu/drm/amd/display/dc/resource/dcn316/dcn316_resource.c

···
 {
 	int i;
 
-	struct dcn20_hubbub *hubbub3 = kzalloc_obj(struct dcn20_hubbub,
-						   GFP_KERNEL);
+	struct dcn20_hubbub *hubbub3 = kzalloc_obj(struct dcn20_hubbub);
 
 	if (!hubbub3)
 		return NULL;
···
 	apg_inst = hpo_dp_inst;
 
 	/* allocate HPO stream encoder and create VPG sub-block */
-	hpo_dp_enc31 = kzalloc_obj(struct dcn31_hpo_dp_stream_encoder,
-				   GFP_KERNEL);
+	hpo_dp_enc31 = kzalloc_obj(struct dcn31_hpo_dp_stream_encoder);
 	vpg = dcn31_vpg_create(ctx, vpg_inst);
 	apg = dcn31_apg_create(ctx, apg_inst);
 
···
 	uint32_t pipe_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < pipe_count; i++) {
-		struct dcn30_dwbc *dwbc30 = kzalloc_obj(struct dcn30_dwbc,
-							GFP_KERNEL);
+		struct dcn30_dwbc *dwbc30 = kzalloc_obj(struct dcn30_dwbc);
 
 		if (!dwbc30) {
 			dm_error("DC: failed to create dwbc30!\n");
···
 	uint32_t pipe_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < pipe_count; i++) {
-		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub,
-							       GFP_KERNEL);
+		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub);
 
 		if (!mcif_wb30) {
 			dm_error("DC: failed to create mcif_wb30!\n");

drivers/gpu/drm/amd/display/dc/resource/dcn32/dcn32_resource.c

···
 {
 	int i;
 
-	struct dcn20_hubbub *hubbub2 = kzalloc_obj(struct dcn20_hubbub,
-						   GFP_KERNEL);
+	struct dcn20_hubbub *hubbub2 = kzalloc_obj(struct dcn20_hubbub);
 
 	if (!hubbub2)
 		return NULL;
···
 	apg_inst = hpo_dp_inst;
 
 	/* allocate HPO stream encoder and create VPG sub-block */
-	hpo_dp_enc31 = kzalloc_obj(struct dcn31_hpo_dp_stream_encoder,
-				   GFP_KERNEL);
+	hpo_dp_enc31 = kzalloc_obj(struct dcn31_hpo_dp_stream_encoder);
 	vpg = dcn32_vpg_create(ctx, vpg_inst);
 	apg = dcn31_apg_create(ctx, apg_inst);
 
···
 	uint32_t dwb_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < dwb_count; i++) {
-		struct dcn30_dwbc *dwbc30 = kzalloc_obj(struct dcn30_dwbc,
-							GFP_KERNEL);
+		struct dcn30_dwbc *dwbc30 = kzalloc_obj(struct dcn30_dwbc);
 
 		if (!dwbc30) {
 			dm_error("DC: failed to create dwbc30!\n");
···
 	uint32_t dwb_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < dwb_count; i++) {
-		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub,
-							       GFP_KERNEL);
+		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub);
 
 		if (!mcif_wb30) {
 			dm_error("DC: failed to create mcif_wb30!\n");

drivers/gpu/drm/amd/display/dc/resource/dcn321/dcn321_resource.c

···
 {
 	int i;
 
-	struct dcn20_hubbub *hubbub2 = kzalloc_obj(struct dcn20_hubbub,
-						   GFP_KERNEL);
+	struct dcn20_hubbub *hubbub2 = kzalloc_obj(struct dcn20_hubbub);
 
 	if (!hubbub2)
 		return NULL;
···
 	apg_inst = hpo_dp_inst;
 
 	/* allocate HPO stream encoder and create VPG sub-block */
-	hpo_dp_enc31 = kzalloc_obj(struct dcn31_hpo_dp_stream_encoder,
-				   GFP_KERNEL);
+	hpo_dp_enc31 = kzalloc_obj(struct dcn31_hpo_dp_stream_encoder);
 	vpg = dcn321_vpg_create(ctx, vpg_inst);
 	apg = dcn321_apg_create(ctx, apg_inst);
 
···
 	uint32_t dwb_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < dwb_count; i++) {
-		struct dcn30_dwbc *dwbc30 = kzalloc_obj(struct dcn30_dwbc,
-							GFP_KERNEL);
+		struct dcn30_dwbc *dwbc30 = kzalloc_obj(struct dcn30_dwbc);
 
 		if (!dwbc30) {
 			dm_error("DC: failed to create dwbc30!\n");
···
 	uint32_t dwb_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < dwb_count; i++) {
-		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub,
-							       GFP_KERNEL);
+		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub);
 
 		if (!mcif_wb30) {
 			dm_error("DC: failed to create mcif_wb30!\n");

drivers/gpu/drm/amd/display/dc/resource/dcn35/dcn35_resource.c

···
 {
 	int i;
 
-	struct dcn20_hubbub *hubbub3 = kzalloc_obj(struct dcn20_hubbub,
-						   GFP_KERNEL);
+	struct dcn20_hubbub *hubbub3 = kzalloc_obj(struct dcn20_hubbub);
 
 	if (!hubbub3)
 		return NULL;
···
 	apg_inst = hpo_dp_inst;
 
 	/* allocate HPO stream encoder and create VPG sub-block */
-	hpo_dp_enc31 = kzalloc_obj(struct dcn31_hpo_dp_stream_encoder,
-				   GFP_KERNEL);
+	hpo_dp_enc31 = kzalloc_obj(struct dcn31_hpo_dp_stream_encoder);
 	vpg = dcn31_vpg_create(ctx, vpg_inst);
 	apg = dcn31_apg_create(ctx, apg_inst);
 
···
 	uint32_t pipe_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < pipe_count; i++) {
-		struct dcn30_dwbc *dwbc30 = kzalloc_obj(struct dcn30_dwbc,
-							GFP_KERNEL);
+		struct dcn30_dwbc *dwbc30 = kzalloc_obj(struct dcn30_dwbc);
 
 		if (!dwbc30) {
 			dm_error("DC: failed to create dwbc30!\n");
···
 	uint32_t pipe_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < pipe_count; i++) {
-		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub,
-							       GFP_KERNEL);
+		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub);
 
 		if (!mcif_wb30) {
 			dm_error("DC: failed to create mcif_wb30!\n");

drivers/gpu/drm/amd/display/dc/resource/dcn351/dcn351_resource.c

···
 {
 	int i;
 
-	struct dcn20_hubbub *hubbub3 = kzalloc_obj(struct dcn20_hubbub,
-						   GFP_KERNEL);
+	struct dcn20_hubbub *hubbub3 = kzalloc_obj(struct dcn20_hubbub);
 
 	if (!hubbub3)
 		return NULL;
···
 	apg_inst = hpo_dp_inst;
 
 	/* allocate HPO stream encoder and create VPG sub-block */
-	hpo_dp_enc31 = kzalloc_obj(struct dcn31_hpo_dp_stream_encoder,
-				   GFP_KERNEL);
+	hpo_dp_enc31 = kzalloc_obj(struct dcn31_hpo_dp_stream_encoder);
 	vpg = dcn31_vpg_create(ctx, vpg_inst);
 	apg = dcn31_apg_create(ctx, apg_inst);
 
···
 	uint32_t pipe_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < pipe_count; i++) {
-		struct dcn30_dwbc *dwbc30 = kzalloc_obj(struct dcn30_dwbc,
-							GFP_KERNEL);
+		struct dcn30_dwbc *dwbc30 = kzalloc_obj(struct dcn30_dwbc);
 
 		if (!dwbc30) {
 			dm_error("DC: failed to create dwbc30!\n");
···
 	uint32_t pipe_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < pipe_count; i++) {
-		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub,
-							       GFP_KERNEL);
+		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub);
 
 		if (!mcif_wb30) {
 			dm_error("DC: failed to create mcif_wb30!\n");

drivers/gpu/drm/amd/display/dc/resource/dcn36/dcn36_resource.c

···
 {
 	int i;
 
-	struct dcn20_hubbub *hubbub3 = kzalloc_obj(struct dcn20_hubbub,
-						   GFP_KERNEL);
+	struct dcn20_hubbub *hubbub3 = kzalloc_obj(struct dcn20_hubbub);
 
 	if (!hubbub3)
 		return NULL;
···
 	apg_inst = hpo_dp_inst;
 
 	/* allocate HPO stream encoder and create VPG sub-block */
-	hpo_dp_enc31 = kzalloc_obj(struct dcn31_hpo_dp_stream_encoder,
-				   GFP_KERNEL);
+	hpo_dp_enc31 = kzalloc_obj(struct dcn31_hpo_dp_stream_encoder);
 	vpg = dcn31_vpg_create(ctx, vpg_inst);
 	apg = dcn31_apg_create(ctx, apg_inst);
 
···
 	uint32_t pipe_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < pipe_count; i++) {
-		struct dcn30_dwbc *dwbc30 = kzalloc_obj(struct dcn30_dwbc,
-							GFP_KERNEL);
+		struct dcn30_dwbc *dwbc30 = kzalloc_obj(struct dcn30_dwbc);
 
 		if (!dwbc30) {
 			dm_error("DC: failed to create dwbc30!\n");
···
 	uint32_t pipe_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < pipe_count; i++) {
-		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub,
-							       GFP_KERNEL);
+		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub);
 
 		if (!mcif_wb30) {
 			dm_error("DC: failed to create mcif_wb30!\n");

drivers/gpu/drm/amd/display/dc/resource/dcn401/dcn401_resource.c

···
 {
 	int i;
 
-	struct dcn20_hubbub *hubbub2 = kzalloc_obj(struct dcn20_hubbub,
-						   GFP_KERNEL);
+	struct dcn20_hubbub *hubbub2 = kzalloc_obj(struct dcn20_hubbub);
 
 	if (!hubbub2)
 		return NULL;
···
 	apg_inst = hpo_dp_inst;
 
 	/* allocate HPO stream encoder and create VPG sub-block */
-	hpo_dp_enc31 = kzalloc_obj(struct dcn31_hpo_dp_stream_encoder,
-				   GFP_KERNEL);
+	hpo_dp_enc31 = kzalloc_obj(struct dcn31_hpo_dp_stream_encoder);
 	vpg = dcn401_vpg_create(ctx, vpg_inst);
 	apg = dcn401_apg_create(ctx, apg_inst);
 
···
 	uint32_t dwb_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < dwb_count; i++) {
-		struct dcn30_dwbc *dwbc401 = kzalloc_obj(struct dcn30_dwbc,
-							 GFP_KERNEL);
+		struct dcn30_dwbc *dwbc401 = kzalloc_obj(struct dcn30_dwbc);
 
 		if (!dwbc401) {
 			dm_error("DC: failed to create dwbc401!\n");
···
 	uint32_t dwb_count = pool->res_cap->num_dwb;
 
 	for (i = 0; i < dwb_count; i++) {
-		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub,
-							       GFP_KERNEL);
+		struct dcn30_mmhubbub *mcif_wb30 = kzalloc_obj(struct dcn30_mmhubbub);
 
 		if (!mcif_wb30) {
 			dm_error("DC: failed to create mcif_wb30!\n");

drivers/gpu/drm/amd/display/modules/color/color_gamma.c

···
 		if (!rgb_user)
 			goto rgb_user_alloc_fail;
 
-		axis_x = kvzalloc_objs(*axis_x, ramp->num_entries + 3,
-				       GFP_KERNEL);
+		axis_x = kvzalloc_objs(*axis_x, ramp->num_entries + 3);
 		if (!axis_x)
 			goto axis_x_alloc_fail;
 
···
 			scale_gamma_dx(rgb_user, ramp, dividers);
 	}
 
-	rgb_regamma = kvzalloc_objs(*rgb_regamma, MAX_HW_POINTS + _EXTRA_POINTS,
-				    GFP_KERNEL);
+	rgb_regamma = kvzalloc_objs(*rgb_regamma, MAX_HW_POINTS + _EXTRA_POINTS);
 	if (!rgb_regamma)
 		goto rgb_regamma_alloc_fail;
 

drivers/gpu/drm/amd/pm/legacy-dpm/legacy_dpm.c

···
 					 le16_to_cpu(ext_hdr->usPowerTuneTableOffset));
 			ATOM_PowerTune_Table *pt;
 			adev->pm.dpm.dyn_state.cac_tdp_table =
-				kzalloc_obj(struct amdgpu_cac_tdp_table,
-					    GFP_KERNEL);
+				kzalloc_obj(struct amdgpu_cac_tdp_table);
 			if (!adev->pm.dpm.dyn_state.cac_tdp_table)
 				return -ENOMEM;
 			if (rev > 0) {

drivers/gpu/drm/amd/pm/legacy-dpm/si_dpm.c

···
 		return ret;
 
 	adev->pm.dpm.dyn_state.vddc_dependency_on_dispclk.entries =
-		kzalloc_objs(struct amdgpu_clock_voltage_dependency_entry, 4,
-			     GFP_KERNEL);
+		kzalloc_objs(struct amdgpu_clock_voltage_dependency_entry, 4);
 	if (!adev->pm.dpm.dyn_state.vddc_dependency_on_dispclk.entries)
 		return -ENOMEM;
 

drivers/gpu/drm/amd/pm/powerplay/hwmgr/process_pptables_v1_0.c

···
 	PP_ASSERT_WITH_CODE((0 != clk_volt_pp_table->count),
 		"Invalid PowerPlay Table!", return -1);
 
-	table = kzalloc_flex(*table, values, clk_volt_pp_table->count,
-			     GFP_KERNEL);
+	table = kzalloc_flex(*table, values, clk_volt_pp_table->count);
 	if (!table)
 		return -ENOMEM;
 

drivers/gpu/drm/amd/pm/powerplay/hwmgr/processpptables.c

···
 	unsigned long i;
 	struct phm_clock_voltage_dependency_table *dep_table;
 
-	dep_table = kzalloc_flex(*dep_table, entries, table->ucNumEntries,
-				 GFP_KERNEL);
+	dep_table = kzalloc_flex(*dep_table, entries, table->ucNumEntries);
 	if (NULL == dep_table)
 		return -ENOMEM;
 
···
 	unsigned long i;
 	struct phm_clock_array *clock_table;
 
-	clock_table = kzalloc_flex(*clock_table, values, table->count,
-				   GFP_KERNEL);
+	clock_table = kzalloc_flex(*clock_table, values, table->count);
 	if (!clock_table)
 		return -ENOMEM;
 
···
 	unsigned long i;
 	struct phm_uvd_clock_voltage_dependency_table *uvd_table;
 
-	uvd_table = kzalloc_flex(*uvd_table, entries, table->numEntries,
-				 GFP_KERNEL);
+	uvd_table = kzalloc_flex(*uvd_table, entries, table->numEntries);
 	if (!uvd_table)
 		return -ENOMEM;
 
···
 	unsigned long i;
 	struct phm_vce_clock_voltage_dependency_table *vce_table;
 
-	vce_table = kzalloc_flex(*vce_table, entries, table->numEntries,
-				 GFP_KERNEL);
+	vce_table = kzalloc_flex(*vce_table, entries, table->numEntries);
 	if (!vce_table)
 		return -ENOMEM;
 
···
 	unsigned long i;
 	struct phm_samu_clock_voltage_dependency_table *samu_table;
 
-	samu_table = kzalloc_flex(*samu_table, entries, table->numEntries,
-				  GFP_KERNEL);
+	samu_table = kzalloc_flex(*samu_table, entries, table->numEntries);
 	if (!samu_table)
 		return -ENOMEM;
 
···
 	unsigned long i;
 	struct phm_acp_clock_voltage_dependency_table *acp_table;
 
-	acp_table = kzalloc_flex(*acp_table, entries, table->numEntries,
-				 GFP_KERNEL);
+	acp_table = kzalloc_flex(*acp_table, entries, table->numEntries);
 	if (!acp_table)
 		return -ENOMEM;
 
···
 static int get_platform_power_management_table(struct pp_hwmgr *hwmgr,
 			ATOM_PPLIB_PPM_Table *atom_ppm_table)
 {
-	struct phm_ppm_table *ptr = kzalloc_obj(struct phm_ppm_table,
-						GFP_KERNEL);
+	struct phm_ppm_table *ptr = kzalloc_obj(struct phm_ppm_table);
 
 	if (NULL == ptr)
 		return -ENOMEM;

drivers/gpu/drm/amd/pm/powerplay/hwmgr/vega10_processpptables.c

···
 	PP_ASSERT_WITH_CODE(clk_volt_pp_table->count,
 			"Invalid PowerPlay Table!", return -1);
 
-	table = kzalloc_flex(*table, values, clk_volt_pp_table->count,
-			     GFP_KERNEL);
+	table = kzalloc_flex(*table, values, clk_volt_pp_table->count);
 	if (!table)
 		return -ENOMEM;
 

drivers/gpu/drm/amd/pm/swsmu/smu11/arcturus_ppt.c

···
 	struct smu_dpm_context *smu_dpm = &smu->smu_dpm;
 	struct smu_dpm_policy *policy;
 
-	smu_dpm->dpm_context = kzalloc_obj(struct smu_11_0_dpm_context,
-					   GFP_KERNEL);
+	smu_dpm->dpm_context = kzalloc_obj(struct smu_11_0_dpm_context);
 	if (!smu_dpm->dpm_context)
 		return -ENOMEM;
 	smu_dpm->dpm_context_size = sizeof(struct smu_11_0_dpm_context);

drivers/gpu/drm/amd/pm/swsmu/smu11/navi10_ppt.c

···
 {
 	struct smu_dpm_context *smu_dpm = &smu->smu_dpm;
 
-	smu_dpm->dpm_context = kzalloc_obj(struct smu_11_0_dpm_context,
-					   GFP_KERNEL);
+	smu_dpm->dpm_context = kzalloc_obj(struct smu_11_0_dpm_context);
 	if (!smu_dpm->dpm_context)
 		return -ENOMEM;
 

drivers/gpu/drm/amd/pm/swsmu/smu11/sienna_cichlid_ppt.c

···
 {
 	struct smu_dpm_context *smu_dpm = &smu->smu_dpm;
 
-	smu_dpm->dpm_context = kzalloc_obj(struct smu_11_0_dpm_context,
-					   GFP_KERNEL);
+	smu_dpm->dpm_context = kzalloc_obj(struct smu_11_0_dpm_context);
 	if (!smu_dpm->dpm_context)
 		return -ENOMEM;
 

drivers/gpu/drm/amd/pm/swsmu/smu11/vangogh_ppt.c

···
 {
 	struct smu_dpm_context *smu_dpm = &smu->smu_dpm;
 
-	smu_dpm->dpm_context = kzalloc_obj(struct smu_11_0_dpm_context,
-					   GFP_KERNEL);
+	smu_dpm->dpm_context = kzalloc_obj(struct smu_11_0_dpm_context);
 	if (!smu_dpm->dpm_context)
 		return -ENOMEM;
 

drivers/gpu/drm/amd/pm/swsmu/smu13/aldebaran_ppt.c

···
 	struct smu_dpm_context *smu_dpm = &smu->smu_dpm;
 	struct smu_dpm_policy *policy;
 
-	smu_dpm->dpm_context = kzalloc_obj(struct smu_13_0_dpm_context,
-					   GFP_KERNEL);
+	smu_dpm->dpm_context = kzalloc_obj(struct smu_13_0_dpm_context);
 	if (!smu_dpm->dpm_context)
 		return -ENOMEM;
 	smu_dpm->dpm_context_size = sizeof(struct smu_13_0_dpm_context);

drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0.c

···
 	if (smu_power->power_context || smu_power->power_context_size != 0)
 		return -EINVAL;
 
-	smu_power->power_context = kzalloc_obj(struct smu_13_0_power_context,
-					       GFP_KERNEL);
+	smu_power->power_context = kzalloc_obj(struct smu_13_0_power_context);
 	if (!smu_power->power_context)
 		return -ENOMEM;
 	smu_power->power_context_size = sizeof(struct smu_13_0_power_context);

drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_0_ppt.c

···
 {
 	struct smu_dpm_context *smu_dpm = &smu->smu_dpm;
 
-	smu_dpm->dpm_context = kzalloc_obj(struct smu_13_0_dpm_context,
-					   GFP_KERNEL);
+	smu_dpm->dpm_context = kzalloc_obj(struct smu_13_0_dpm_context);
 	if (!smu_dpm->dpm_context)
 		return -ENOMEM;
 

drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_7_ppt.c

···
 {
 	struct smu_dpm_context *smu_dpm = &smu->smu_dpm;
 
-	smu_dpm->dpm_context = kzalloc_obj(struct smu_13_0_dpm_context,
-					   GFP_KERNEL);
+	smu_dpm->dpm_context = kzalloc_obj(struct smu_13_0_dpm_context);
 	if (!smu_dpm->dpm_context)
 		return -ENOMEM;
 

drivers/gpu/drm/amd/pm/swsmu/smu14/smu_v14_0.c

···
 	if (smu_power->power_context || smu_power->power_context_size != 0)
 		return -EINVAL;
 
-	smu_power->power_context = kzalloc_obj(struct smu_14_0_dpm_context,
-					       GFP_KERNEL);
+	smu_power->power_context = kzalloc_obj(struct smu_14_0_dpm_context);
 	if (!smu_power->power_context)
 		return -ENOMEM;
 	smu_power->power_context_size = sizeof(struct smu_14_0_dpm_context);

drivers/gpu/drm/amd/pm/swsmu/smu14/smu_v14_0_2_ppt.c

···
 {
 	struct smu_dpm_context *smu_dpm = &smu->smu_dpm;
 
-	smu_dpm->dpm_context = kzalloc_obj(struct smu_14_0_dpm_context,
-					   GFP_KERNEL);
+	smu_dpm->dpm_context = kzalloc_obj(struct smu_14_0_dpm_context);
 	if (!smu_dpm->dpm_context)
 		return -ENOMEM;
 

drivers/gpu/drm/amd/pm/swsmu/smu15/smu_v15_0.c

···
 	if (smu_power->power_context || smu_power->power_context_size != 0)
 		return -EINVAL;
 
-	smu_power->power_context = kzalloc_obj(struct smu_15_0_dpm_context,
-					       GFP_KERNEL);
+	smu_power->power_context = kzalloc_obj(struct smu_15_0_dpm_context);
 	if (!smu_power->power_context)
 		return -ENOMEM;
 	smu_power->power_context_size = sizeof(struct smu_15_0_dpm_context);

drivers/gpu/drm/amd/ras/ras_mgr/amdgpu_virt_ras_cmd.c

···
 {
 	struct amdgpu_ras_mgr *ras_mgr = amdgpu_ras_mgr_get_context(adev);
 
-	ras_mgr->virt_ras_cmd = kzalloc_obj(struct amdgpu_virt_ras_cmd,
-					    GFP_KERNEL);
+	ras_mgr->virt_ras_cmd = kzalloc_obj(struct amdgpu_virt_ras_cmd);
 	if (!ras_mgr->virt_ras_cmd)
 		return -ENOMEM;
 

drivers/gpu/drm/arm/malidp_mw.c

···
 
 static void malidp_mw_connector_reset(struct drm_connector *connector)
 {
-	struct malidp_mw_connector_state *mw_state = kzalloc_obj(*mw_state,
-								 GFP_KERNEL);
+	struct malidp_mw_connector_state *mw_state = kzalloc_obj(*mw_state);
 
 	if (connector->state)
 		__drm_atomic_helper_connector_destroy_state(connector->state);

drivers/gpu/drm/ast/ast_dp.c

···
 
 static void ast_astdp_connector_reset(struct drm_connector *connector)
 {
-	struct ast_astdp_connector_state *astdp_state = kzalloc_obj(*astdp_state,
-								    GFP_KERNEL);
+	struct ast_astdp_connector_state *astdp_state = kzalloc_obj(*astdp_state);
 
 	if (connector->state)
 		connector->funcs->atomic_destroy_state(connector, connector->state);

drivers/gpu/drm/drm_atomic.c

···
 	 */
 	state->allow_modeset = true;
 
-	state->crtcs = kzalloc_objs(*state->crtcs, dev->mode_config.num_crtc,
-				    GFP_KERNEL);
+	state->crtcs = kzalloc_objs(*state->crtcs, dev->mode_config.num_crtc);
 	if (!state->crtcs)
 		goto fail;
 	state->planes = kzalloc_objs(*state->planes,

drivers/gpu/drm/drm_atomic_helper.c

···
 	}
 
 	if (!state->fake_commit) {
-		state->fake_commit = kzalloc_obj(*state->fake_commit,
-						 GFP_KERNEL);
+		state->fake_commit = kzalloc_obj(*state->fake_commit);
 		if (!state->fake_commit)
 			return NULL;
 

drivers/gpu/drm/drm_atomic_state_helper.c

···
  */
 void drm_atomic_helper_connector_reset(struct drm_connector *connector)
 {
-	struct drm_connector_state *conn_state = kzalloc_obj(*conn_state,
-							     GFP_KERNEL);
+	struct drm_connector_state *conn_state = kzalloc_obj(*conn_state);
 
 	if (connector->state)
 		__drm_atomic_helper_connector_destroy_state(connector->state);

drivers/gpu/drm/drm_buddy.c

···
 
 	BUG_ON(mm->max_order > DRM_BUDDY_MAX_ORDER);
 
-	mm->free_trees = kmalloc_objs(*mm->free_trees, DRM_BUDDY_MAX_FREE_TREES,
-				      GFP_KERNEL);
+	mm->free_trees = kmalloc_objs(*mm->free_trees, DRM_BUDDY_MAX_FREE_TREES);
 	if (!mm->free_trees)
 		return -ENOMEM;
 
···
 
 	mm->n_roots = hweight64(size);
 
-	mm->roots = kmalloc_objs(struct drm_buddy_block *, mm->n_roots,
-				 GFP_KERNEL);
+	mm->roots = kmalloc_objs(struct drm_buddy_block *, mm->n_roots);
 	if (!mm->roots)
 		goto out_free_tree;
 

drivers/gpu/drm/drm_client_modeset.c

···
 	int i = 0;
 
 	/* Add terminating zero entry to enable index less iteration */
-	client->modesets = kzalloc_objs(*client->modesets, num_crtc + 1,
-					GFP_KERNEL);
+	client->modesets = kzalloc_objs(*client->modesets, num_crtc + 1);
 	if (!client->modesets)
 		return -ENOMEM;
 

drivers/gpu/drm/drm_gem_atomic_helper.c

···
 	if (!plane_state)
 		return NULL;
 
-	new_shadow_plane_state = kzalloc_obj(*new_shadow_plane_state,
-					     GFP_KERNEL);
+	new_shadow_plane_state = kzalloc_obj(*new_shadow_plane_state);
 	if (!new_shadow_plane_state)
 		return NULL;
 	__drm_gem_duplicate_shadow_plane_state(plane, new_shadow_plane_state);

drivers/gpu/drm/drm_lease.c

···
 	int ret;
 	bool universal_planes = READ_ONCE(lessor_priv->universal_planes);
 
-	objects = kzalloc_objs(struct drm_mode_object *, object_count,
-			       GFP_KERNEL);
+	objects = kzalloc_objs(struct drm_mode_object *, object_count);
 	if (!objects)
 		return -ENOMEM;
 

drivers/gpu/drm/drm_plane.c

···
 	int len = 0;
 	int i;
 
-	all_pipelines = kzalloc_objs(*all_pipelines, num_pipelines + 1,
-				     GFP_KERNEL);
+	all_pipelines = kzalloc_objs(*all_pipelines, num_pipelines + 1);
 
 	if (!all_pipelines) {
 		drm_err(plane->dev, "failed to allocate color pipeline\n");

drivers/gpu/drm/drm_plane_helper.c

···
 	/* Find current connectors for CRTC */
 	num_connectors = get_connectors_for_crtc(crtc, NULL, 0);
 	BUG_ON(num_connectors == 0);
-	connector_list = kzalloc_objs(*connector_list, num_connectors,
-				      GFP_KERNEL);
+	connector_list = kzalloc_objs(*connector_list, num_connectors);
 	if (!connector_list)
 		return -ENOMEM;
 	get_connectors_for_crtc(crtc, connector_list, num_connectors);

drivers/gpu/drm/drm_writeback.c

···
 	WARN_ON(conn_state->connector->connector_type != DRM_MODE_CONNECTOR_WRITEBACK);
 
 	if (!conn_state->writeback_job) {
-		conn_state->writeback_job = kzalloc_obj(*conn_state->writeback_job,
-							GFP_KERNEL);
+		conn_state->writeback_job = kzalloc_obj(*conn_state->writeback_job);
 		if (!conn_state->writeback_job)
 			return -ENOMEM;
 

drivers/gpu/drm/etnaviv/etnaviv_flop_reset.c

···
 	 * (input and output image, and shader), we keep this buffer
 	 * for the whole life time the driver is bound
 	 */
-	priv->flop_reset_data_ppu = kzalloc_obj(*priv->flop_reset_data_ppu,
-						GFP_KERNEL);
+	priv->flop_reset_data_ppu = kzalloc_obj(*priv->flop_reset_data_ppu);
 
 	if (!priv->flop_reset_data_ppu)
 		return -ENOMEM;

drivers/gpu/drm/etnaviv/etnaviv_gem_submit.c

···
 	if (!submit)
 		return NULL;
 
-	submit->pmrs = kzalloc_objs(struct etnaviv_perfmon_request, nr_pmrs,
-				    GFP_KERNEL);
+	submit->pmrs = kzalloc_objs(struct etnaviv_perfmon_request, nr_pmrs);
 	if (!submit->pmrs) {
 		kfree(submit);
 		return NULL;

drivers/gpu/drm/exynos/exynos_drm_g2d.c

···
 	offset = userptr & ~PAGE_MASK;
 	end = PAGE_ALIGN(userptr + size);
 	npages = (end - start) >> PAGE_SHIFT;
-	g2d_userptr->pages = kvmalloc_objs(*g2d_userptr->pages, npages,
-					   GFP_KERNEL);
+	g2d_userptr->pages = kvmalloc_objs(*g2d_userptr->pages, npages);
 	if (!g2d_userptr->pages) {
 		ret = -ENOMEM;
 		goto err_free;

drivers/gpu/drm/gma500/intel_gmbus.c

···
 	struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
 	int ret, i;
 
-	dev_priv->gmbus = kzalloc_objs(struct intel_gmbus, GMBUS_NUM_PORTS,
-				       GFP_KERNEL);
+	dev_priv->gmbus = kzalloc_objs(struct intel_gmbus, GMBUS_NUM_PORTS);
 	if (dev_priv->gmbus == NULL)
 		return -ENOMEM;
 

drivers/gpu/drm/gma500/psb_intel_sdvo.c

···
 	struct gma_connector *intel_connector;
 	struct psb_intel_sdvo_connector *psb_intel_sdvo_connector;
 
-	psb_intel_sdvo_connector = kzalloc_obj(struct psb_intel_sdvo_connector,
-					       GFP_KERNEL);
+	psb_intel_sdvo_connector = kzalloc_obj(struct psb_intel_sdvo_connector);
 	if (!psb_intel_sdvo_connector)
 		return false;
 
···
 	struct gma_connector *intel_connector;
 	struct psb_intel_sdvo_connector *psb_intel_sdvo_connector;
 
-	psb_intel_sdvo_connector = kzalloc_obj(struct psb_intel_sdvo_connector,
-					       GFP_KERNEL);
+	psb_intel_sdvo_connector = kzalloc_obj(struct psb_intel_sdvo_connector);
 	if (!psb_intel_sdvo_connector)
 		return false;
 
···
 	struct gma_connector *intel_connector;
 	struct psb_intel_sdvo_connector *psb_intel_sdvo_connector;
 
-	psb_intel_sdvo_connector = kzalloc_obj(struct psb_intel_sdvo_connector,
-					       GFP_KERNEL);
+	psb_intel_sdvo_connector = kzalloc_obj(struct psb_intel_sdvo_connector);
 	if (!psb_intel_sdvo_connector)
 		return false;
 
···
 	struct gma_connector *intel_connector;
 	struct psb_intel_sdvo_connector *psb_intel_sdvo_connector;
 
-	psb_intel_sdvo_connector = kzalloc_obj(struct psb_intel_sdvo_connector,
-					       GFP_KERNEL);
+	psb_intel_sdvo_connector = kzalloc_obj(struct psb_intel_sdvo_connector);
 	if (!psb_intel_sdvo_connector)
 		return false;
 

drivers/gpu/drm/gud/gud_connector.c

···
 	if (drm_edid && edid_ctx.edid_override)
 		goto out;
 
-	reqmodes = kmalloc_objs(*reqmodes, GUD_CONNECTOR_MAX_NUM_MODES,
-				GFP_KERNEL);
+	reqmodes = kmalloc_objs(*reqmodes, GUD_CONNECTOR_MAX_NUM_MODES);
 	if (!reqmodes)
 		goto out;
 
···
 	unsigned int i, num_properties;
 	int ret;
 
-	properties = kzalloc_objs(*properties, GUD_CONNECTOR_PROPERTIES_MAX_NUM,
-				  GFP_KERNEL);
+	properties = kzalloc_objs(*properties, GUD_CONNECTOR_PROPERTIES_MAX_NUM);
 	if (!properties)
 		return -ENOMEM;
 

drivers/gpu/drm/gud/gud_drv.c

···
 	unsigned int i, num_properties;
 	int ret;
 
-	properties = kzalloc_objs(*properties, GUD_PROPERTIES_MAX_NUM,
-				  GFP_KERNEL);
+	properties = kzalloc_objs(*properties, GUD_PROPERTIES_MAX_NUM);
 	if (!properties)
 		return -ENOMEM;
 

drivers/gpu/drm/i915/display/intel_bios.c

···
 	if (section_id == BDB_MIPI_SEQUENCE && *(const u8 *)block >= 3)
 		block_size += 5;
 
-	entry = kzalloc_flex(*entry, data, max(min_size, block_size) + 3,
-			     GFP_KERNEL);
+	entry = kzalloc_flex(*entry, data, max(min_size, block_size) + 3);
 	if (!entry) {
 		kfree(temp_block);
 		return;

drivers/gpu/drm/i915/display/intel_dp_tunnel.c

···
 	}
 
 	if (!state->inherited_dp_tunnels) {
-		state->inherited_dp_tunnels = kzalloc_obj(*state->inherited_dp_tunnels,
-							  GFP_KERNEL);
+		state->inherited_dp_tunnels = kzalloc_obj(*state->inherited_dp_tunnels);
 		if (!state->inherited_dp_tunnels)
 			return -ENOMEM;
 	}

drivers/gpu/drm/i915/gem/i915_gem_create.c

···
 		obj->mm.placements = &i915->mm.regions[mr->id];
 		obj->mm.n_placements = 1;
 	} else {
-		arr = kmalloc_objs(struct intel_memory_region *, n_placements,
-				   GFP_KERNEL);
+		arr = kmalloc_objs(struct intel_memory_region *, n_placements);
 		if (!arr)
 			return -ENOMEM;
 

drivers/gpu/drm/i915/gt/intel_ggtt_fencing.c

···
 	if (intel_vgpu_active(i915))
 		num_fences = intel_uncore_read(uncore,
 					       vgtif_reg(avail_rs.fence_num));
-	ggtt->fence_regs = kzalloc_objs(*ggtt->fence_regs, num_fences,
-					GFP_KERNEL);
+	ggtt->fence_regs = kzalloc_objs(*ggtt->fence_regs, num_fences);
 	if (!ggtt->fence_regs)
 		num_fences = 0;
 

drivers/gpu/drm/i915/gt/intel_workarounds.c

···
 	if (IS_ALIGNED(wal->count, grow)) { /* Either uninitialized or full. */
 		struct i915_wa *list;
 
-		list = kmalloc_objs(*list, ALIGN(wal->count + 1, grow),
-				    GFP_KERNEL);
+		list = kmalloc_objs(*list, ALIGN(wal->count + 1, grow));
 		if (!list) {
 			drm_err(&i915->drm, "No space for workaround init!\n");
 			return;

drivers/gpu/drm/i915/gt/selftest_execlists.c

···
 	u32 *cs;
 	int n;
 
-	smoke.contexts = kmalloc_objs(*smoke.contexts, smoke.ncontext,
-				      GFP_KERNEL);
+	smoke.contexts = kmalloc_objs(*smoke.contexts, smoke.ncontext);
 	if (!smoke.contexts)
 		return -ENOMEM;
 

drivers/gpu/drm/i915/gt/selftest_timeline.c

···
 	 * independently to each of their breadcrumb slots.
 	 */
 
-	timelines = kvmalloc_objs(*timelines, NUM_TIMELINES * I915_NUM_ENGINES,
-				  GFP_KERNEL);
+	timelines = kvmalloc_objs(*timelines, NUM_TIMELINES * I915_NUM_ENGINES);
 	if (!timelines)
 		return -ENOMEM;
 
···
 	 * engines.
 	 */
 
-	timelines = kvmalloc_objs(*timelines, NUM_TIMELINES * I915_NUM_ENGINES,
-				  GFP_KERNEL);
+	timelines = kvmalloc_objs(*timelines, NUM_TIMELINES * I915_NUM_ENGINES);
 	if (!timelines)
 		return -ENOMEM;
 

drivers/gpu/drm/i915/gt/uc/intel_guc_capture.c

···
 		return;
 
 	/* allocate an extra for an end marker */
-	extlists = kzalloc_objs(struct __guc_mmio_reg_descr_group, 2,
-				GFP_KERNEL);
+	extlists = kzalloc_objs(struct __guc_mmio_reg_descr_group, 2);
 	if (!extlists)
 		return;
 

drivers/gpu/drm/i915/i915_cmd_parser.c

···
 		for (j = 0; j < table->count; j++) {
 			const struct drm_i915_cmd_descriptor *desc =
 				&table->table[j];
-			struct cmd_node *desc_node = kmalloc_obj(*desc_node,
-								 GFP_KERNEL);
+			struct cmd_node *desc_node = kmalloc_obj(*desc_node);
 
 			if (!desc_node)
 				return -ENOMEM;

drivers/gpu/drm/i915/selftests/i915_request.c

···
 
 	smoke[0].request_alloc = __live_request_alloc;
 	smoke[0].ncontexts = 64;
-	smoke[0].contexts = kzalloc_objs(*smoke[0].contexts, smoke[0].ncontexts,
-					 GFP_KERNEL);
+	smoke[0].contexts = kzalloc_objs(*smoke[0].contexts, smoke[0].ncontexts);
 	if (!smoke[0].contexts) {
 		ret = -ENOMEM;
 		goto out_threads;

drivers/gpu/drm/mgag200/mgag200_mode.c

···
 	if (!crtc_state)
 		return NULL;
 
-	new_mgag200_crtc_state = kzalloc_obj(*new_mgag200_crtc_state,
-					     GFP_KERNEL);
+	new_mgag200_crtc_state = kzalloc_obj(*new_mgag200_crtc_state);
 	if (!new_mgag200_crtc_state)
 		return NULL;
 	__drm_atomic_helper_crtc_duplicate_state(crtc, &new_mgag200_crtc_state->base);

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

···
 
 static void mdp5_crtc_reset(struct drm_crtc *crtc)
 {
-	struct mdp5_crtc_state *mdp5_cstate = kzalloc_obj(*mdp5_cstate,
-						          GFP_KERNEL);
+	struct mdp5_crtc_state *mdp5_cstate = kzalloc_obj(*mdp5_cstate);
 
 	if (crtc->state)
 		mdp5_crtc_destroy_state(crtc, crtc->state);

drivers/gpu/drm/nouveau/dispnv04/overlay.c

···
 nv10_overlay_init(struct drm_device *device)
 {
 	struct nouveau_drm *drm = nouveau_drm(device);
-	struct nouveau_plane *plane = kzalloc_obj(struct nouveau_plane,
-						  GFP_KERNEL);
+	struct nouveau_plane *plane = kzalloc_obj(struct nouveau_plane);
 	unsigned int num_formats = ARRAY_SIZE(formats);
 	int ret;
 
···
 nv04_overlay_init(struct drm_device *device)
 {
 	struct nouveau_drm *drm = nouveau_drm(device);
-	struct nouveau_plane *plane = kzalloc_obj(struct nouveau_plane,
-						  GFP_KERNEL);
+	struct nouveau_plane *plane = kzalloc_obj(struct nouveau_plane);
 	int ret;
 
 	if (!plane)

drivers/gpu/drm/nouveau/nouveau_svm.c

···
 	if (ret)
 		return ret;
 
-	buffer->fault = kvzalloc_objs(*buffer->fault, buffer->entries,
-				      GFP_KERNEL);
+	buffer->fault = kvzalloc_objs(*buffer->fault, buffer->entries);
 	if (!buffer->fault)
 		return -ENOMEM;
 

drivers/gpu/drm/nouveau/nvif/fifo.c

···
 		goto done;
 
 	device->runlists = fls64(a->v.runlists.data);
-	device->runlist = kzalloc_objs(*device->runlist, device->runlists,
-				       GFP_KERNEL);
+	device->runlist = kzalloc_objs(*device->runlist, device->runlists);
 	if (!device->runlist) {
 		ret = -ENOMEM;
 		goto done;

drivers/gpu/drm/omapdrm/omap_dmm_tiler.c

···
 		list_add(&omap_dmm->engines[i].idle_node, &omap_dmm->idle_head);
 	}
 
-	omap_dmm->tcm = kzalloc_objs(*omap_dmm->tcm, omap_dmm->num_lut,
-				     GFP_KERNEL);
+	omap_dmm->tcm = kzalloc_objs(*omap_dmm->tcm, omap_dmm->num_lut);
 	if (!omap_dmm->tcm) {
 		ret = -ENOMEM;
 		goto fail;

drivers/gpu/drm/qxl/qxl_display.c

···
 		qxl_bo_physical_address(qdev, qdev->monitors_config_bo, 0);
 
 	memset(qdev->monitors_config, 0, monitors_config_size);
-	qdev->dumb_heads = kzalloc_objs(qdev->dumb_heads[0], qxl_num_crtc,
-					GFP_KERNEL);
+	qdev->dumb_heads = kzalloc_objs(qdev->dumb_heads[0], qxl_num_crtc);
 	if (!qdev->dumb_heads) {
 		qxl_destroy_monitors_object(qdev);
 		return -ENOMEM;

drivers/gpu/drm/qxl/qxl_ioctl.c

···
 		       cmd->command_size))
 		return -EFAULT;
 
-	reloc_info = kmalloc_objs(struct qxl_reloc_info, cmd->relocs_num,
-				  GFP_KERNEL);
+	reloc_info = kmalloc_objs(struct qxl_reloc_info, cmd->relocs_num);
 	if (!reloc_info)
 		return -ENOMEM;
 

drivers/gpu/drm/radeon/atombios_encoders.c

···
 {
 	struct drm_device *dev = radeon_encoder->base.dev;
 	struct radeon_device *rdev = dev->dev_private;
-	struct radeon_encoder_atom_dac *dac = kzalloc_obj(struct radeon_encoder_atom_dac,
-							  GFP_KERNEL);
+	struct radeon_encoder_atom_dac *dac = kzalloc_obj(struct radeon_encoder_atom_dac);
 
 	if (!dac)
 		return NULL;
···
 radeon_atombios_set_dig_info(struct radeon_encoder *radeon_encoder)
 {
 	int encoder_enum = (radeon_encoder->encoder_enum & ENUM_ID_MASK) >> ENUM_ID_SHIFT;
-	struct radeon_encoder_atom_dig *dig = kzalloc_obj(struct radeon_encoder_atom_dig,
-							  GFP_KERNEL);
+	struct radeon_encoder_atom_dig *dig = kzalloc_obj(struct radeon_encoder_atom_dig);
 
 	if (!dig)
 		return NULL;

drivers/gpu/drm/radeon/btc_dpm.c

···
 		return ret;
 
 	rdev->pm.dpm.dyn_state.vddc_dependency_on_dispclk.entries =
-		kzalloc_objs(struct radeon_clock_voltage_dependency_entry, 4,
-			     GFP_KERNEL);
+		kzalloc_objs(struct radeon_clock_voltage_dependency_entry, 4);
 	if (!rdev->pm.dpm.dyn_state.vddc_dependency_on_dispclk.entries) {
 		r600_free_extended_power_table(rdev);
 		return -ENOMEM;

drivers/gpu/drm/radeon/ci_dpm.c

···
 	ci_set_private_data_variables_based_on_pptable(rdev);
 
 	rdev->pm.dpm.dyn_state.vddc_dependency_on_dispclk.entries =
-		kzalloc_objs(struct radeon_clock_voltage_dependency_entry, 4,
-			     GFP_KERNEL);
+		kzalloc_objs(struct radeon_clock_voltage_dependency_entry, 4);
 	if (!rdev->pm.dpm.dyn_state.vddc_dependency_on_dispclk.entries) {
 		ci_dpm_fini(rdev);
 		return -ENOMEM;

drivers/gpu/drm/radeon/ni_dpm.c

···
 		return ret;
 
 	rdev->pm.dpm.dyn_state.vddc_dependency_on_dispclk.entries =
-		kzalloc_objs(struct radeon_clock_voltage_dependency_entry, 4,
-			     GFP_KERNEL);
+		kzalloc_objs(struct radeon_clock_voltage_dependency_entry, 4);
 	if (!rdev->pm.dpm.dyn_state.vddc_dependency_on_dispclk.entries) {
 		r600_free_extended_power_table(rdev);
 		return -ENOMEM;

drivers/gpu/drm/radeon/r600_dpm.c

···
 					 le16_to_cpu(ext_hdr->usPowerTuneTableOffset));
 			ATOM_PowerTune_Table *pt;
 			rdev->pm.dpm.dyn_state.cac_tdp_table =
-				kzalloc_obj(struct radeon_cac_tdp_table,
-					    GFP_KERNEL);
+				kzalloc_obj(struct radeon_cac_tdp_table);
 			if (!rdev->pm.dpm.dyn_state.cac_tdp_table) {
 				r600_free_extended_power_table(rdev);
 				return -ENOMEM;

drivers/gpu/drm/radeon/radeon_atombios.c

···
 		dac_info = (struct _COMPASSIONATE_DATA *)
 			(mode_info->atom_context->bios + data_offset);
 
-		p_dac = kzalloc_obj(struct radeon_encoder_primary_dac,
-				    GFP_KERNEL);
+		p_dac = kzalloc_obj(struct radeon_encoder_primary_dac);
 
 		if (!p_dac)
 			return NULL;
···
 		/* avoid memory leaks from invalid modes or unknown frev. */
 		if (!rdev->pm.power_state[state_index].clock_info) {
 			rdev->pm.power_state[state_index].clock_info =
-				kzalloc_obj(struct radeon_pm_clock_info,
-					    GFP_KERNEL);
+				kzalloc_obj(struct radeon_pm_clock_info);
 		}
 		if (!rdev->pm.power_state[state_index].clock_info)
 			goto out;
···
 	}
 
 	if (state_index == 0) {
-		rdev->pm.power_state = kzalloc_obj(struct radeon_power_state,
-						   GFP_KERNEL);
+		rdev->pm.power_state = kzalloc_obj(struct radeon_power_state);
 		if (rdev->pm.power_state) {
 			rdev->pm.power_state[0].clock_info =
-				kzalloc_objs(struct radeon_pm_clock_info, 1,
-				             GFP_KERNEL);
+				kzalloc_objs(struct radeon_pm_clock_info, 1);
 			if (rdev->pm.power_state[0].clock_info) {
 				/* add the default mode */
 				rdev->pm.power_state[state_index].type =

drivers/gpu/drm/radeon/radeon_combios.c

···
 	rdev->pm.default_power_state_index = -1;
 
 	/* allocate 2 power states */
-	rdev->pm.power_state = kzalloc_objs(struct radeon_power_state, 2,
-					    GFP_KERNEL);
+	rdev->pm.power_state = kzalloc_objs(struct radeon_power_state, 2);
 	if (rdev->pm.power_state) {
 		/* allocate 1 clock mode per state */
 		rdev->pm.power_state[0].clock_info =

drivers/gpu/drm/radeon/radeon_connectors.c

···
 	}
 
 	if (is_dp_bridge) {
-		radeon_dig_connector = kzalloc_obj(struct radeon_connector_atom_dig,
-						   GFP_KERNEL);
+		radeon_dig_connector = kzalloc_obj(struct radeon_connector_atom_dig);
 		if (!radeon_dig_connector)
 			goto failed;
 		radeon_dig_connector->igp_lane_info = igp_lane_info;
···
 			break;
 		case DRM_MODE_CONNECTOR_DVII:
 		case DRM_MODE_CONNECTOR_DVID:
-			radeon_dig_connector = kzalloc_obj(struct radeon_connector_atom_dig,
-							   GFP_KERNEL);
+			radeon_dig_connector = kzalloc_obj(struct radeon_connector_atom_dig);
 			if (!radeon_dig_connector)
 				goto failed;
 			radeon_dig_connector->igp_lane_info = igp_lane_info;
···
 			break;
 		case DRM_MODE_CONNECTOR_HDMIA:
 		case DRM_MODE_CONNECTOR_HDMIB:
-			radeon_dig_connector = kzalloc_obj(struct radeon_connector_atom_dig,
-							   GFP_KERNEL);
+			radeon_dig_connector = kzalloc_obj(struct radeon_connector_atom_dig);
 			if (!radeon_dig_connector)
 				goto failed;
 			radeon_dig_connector->igp_lane_info = igp_lane_info;
···
 				connector->doublescan_allowed = false;
 			break;
 		case DRM_MODE_CONNECTOR_DisplayPort:
-			radeon_dig_connector = kzalloc_obj(struct radeon_connector_atom_dig,
-							   GFP_KERNEL);
+			radeon_dig_connector = kzalloc_obj(struct radeon_connector_atom_dig);
 			if (!radeon_dig_connector)
 				goto failed;
 			radeon_dig_connector->igp_lane_info = igp_lane_info;
···
 			connector->doublescan_allowed = false;
 			break;
 		case DRM_MODE_CONNECTOR_eDP:
-			radeon_dig_connector = kzalloc_obj(struct radeon_connector_atom_dig,
-							   GFP_KERNEL);
+			radeon_dig_connector = kzalloc_obj(struct radeon_connector_atom_dig);
 			if (!radeon_dig_connector)
 				goto failed;
 			radeon_dig_connector->igp_lane_info = igp_lane_info;
···
 			connector->doublescan_allowed = false;
 			break;
 		case DRM_MODE_CONNECTOR_LVDS:
-			radeon_dig_connector = kzalloc_obj(struct radeon_connector_atom_dig,
-							   GFP_KERNEL);
+			radeon_dig_connector = kzalloc_obj(struct radeon_connector_atom_dig);
 			if (!radeon_dig_connector)
 				goto failed;
 			radeon_dig_connector->igp_lane_info = igp_lane_info;

drivers/gpu/drm/radeon/radeon_cs.c

···
 	}
 	p->cs_flags = 0;
 	p->nchunks = cs->num_chunks;
-	p->chunks = kvzalloc_objs(struct radeon_cs_chunk, p->nchunks,
-				  GFP_KERNEL);
+	p->chunks = kvzalloc_objs(struct radeon_cs_chunk, p->nchunks);
 	if (p->chunks == NULL) {
 		return -ENOMEM;
 	}

drivers/gpu/drm/radeon/radeon_display.c

···
 
 		BUG_ON(num_afmt > ARRAY_SIZE(eg_offsets));
 		for (i = 0; i < num_afmt; i++) {
-			rdev->mode_info.afmt[i] = kzalloc_obj(struct radeon_afmt,
-							      GFP_KERNEL);
+			rdev->mode_info.afmt[i] = kzalloc_obj(struct radeon_afmt);
 			if (rdev->mode_info.afmt[i]) {
 				rdev->mode_info.afmt[i]->offset = eg_offsets[i];
 				rdev->mode_info.afmt[i]->id = i;
···
 		}
 	} else if (ASIC_IS_DCE3(rdev)) {
 		/* DCE3.x has 2 audio blocks tied to DIG encoders */
-		rdev->mode_info.afmt[0] = kzalloc_obj(struct radeon_afmt,
-						      GFP_KERNEL);
+		rdev->mode_info.afmt[0] = kzalloc_obj(struct radeon_afmt);
 		if (rdev->mode_info.afmt[0]) {
 			rdev->mode_info.afmt[0]->offset = DCE3_HDMI_OFFSET0;
 			rdev->mode_info.afmt[0]->id = 0;
 		}
-		rdev->mode_info.afmt[1] = kzalloc_obj(struct radeon_afmt,
-						      GFP_KERNEL);
+		rdev->mode_info.afmt[1] = kzalloc_obj(struct radeon_afmt);
 		if (rdev->mode_info.afmt[1]) {
 			rdev->mode_info.afmt[1]->offset = DCE3_HDMI_OFFSET1;
 			rdev->mode_info.afmt[1]->id = 1;
 		}
 	} else if (ASIC_IS_DCE2(rdev)) {
 		/* DCE2 has at least 1 routable audio block */
-		rdev->mode_info.afmt[0] = kzalloc_obj(struct radeon_afmt,
-						      GFP_KERNEL);
+		rdev->mode_info.afmt[0] = kzalloc_obj(struct radeon_afmt);
 		if (rdev->mode_info.afmt[0]) {
 			rdev->mode_info.afmt[0]->offset = DCE2_HDMI_OFFSET0;
 			rdev->mode_info.afmt[0]->id = 0;
 		}
 		/* r6xx has 2 routable audio blocks */
 		if (rdev->family >= CHIP_R600) {
-			rdev->mode_info.afmt[1] = kzalloc_obj(struct radeon_afmt,
-							      GFP_KERNEL);
+			rdev->mode_info.afmt[1] = kzalloc_obj(struct radeon_afmt);
 			if (rdev->mode_info.afmt[1]) {
 				rdev->mode_info.afmt[1]->offset = DCE2_HDMI_OFFSET1;
 				rdev->mode_info.afmt[1]->id = 1;

drivers/gpu/drm/radeon/radeon_vm.c

···
 	struct radeon_bo_list *list;
 	unsigned i, idx;
 
-	list = kvmalloc_objs(struct radeon_bo_list, vm->max_pde_used + 2,
-			     GFP_KERNEL);
+	list = kvmalloc_objs(struct radeon_bo_list, vm->max_pde_used + 2);
 	if (!list)
 		return NULL;
 

drivers/gpu/drm/radeon/si_dpm.c

···
 		return ret;
 
 	rdev->pm.dpm.dyn_state.vddc_dependency_on_dispclk.entries =
-		kzalloc_objs(struct radeon_clock_voltage_dependency_entry, 4,
-			     GFP_KERNEL);
+		kzalloc_objs(struct radeon_clock_voltage_dependency_entry, 4);
 	if (!rdev->pm.dpm.dyn_state.vddc_dependency_on_dispclk.entries) {
 		r600_free_extended_power_table(rdev);
 		return -ENOMEM;

drivers/gpu/drm/rockchip/rockchip_drm_vop.c

···
 
 static void vop_crtc_reset(struct drm_crtc *crtc)
 {
-	struct rockchip_crtc_state *crtc_state = kzalloc_obj(*crtc_state,
-						             GFP_KERNEL);
+	struct rockchip_crtc_state *crtc_state = kzalloc_obj(*crtc_state);
 
 	if (crtc->state)
 		vop_crtc_destroy_state(crtc, crtc->state);

drivers/gpu/drm/scheduler/sched_main.c

···
 		goto Out_check_own;
 	sched->num_rqs = args->num_rqs;
 	for (i = DRM_SCHED_PRIORITY_KERNEL; i < sched->num_rqs; i++) {
-		sched->sched_rq[i] = kzalloc_obj(*sched->sched_rq[i],
-						 GFP_KERNEL);
+		sched->sched_rq[i] = kzalloc_obj(*sched->sched_rq[i]);
 		if (!sched->sched_rq[i])
 			goto Out_unroll;
 		drm_sched_rq_init(sched, sched->sched_rq[i]);

drivers/gpu/drm/tiny/appletbdrm.c

···
 	if (!appletbdrm_state->request)
 		return -ENOMEM;
 
-	appletbdrm_state->response = kzalloc_obj(*appletbdrm_state->response,
-						 GFP_KERNEL);
+	appletbdrm_state->response = kzalloc_obj(*appletbdrm_state->response);
 
 	if (!appletbdrm_state->response)
 		return -ENOMEM;

drivers/gpu/drm/ttm/ttm_tt.c

···
 
 static int ttm_sg_tt_alloc_page_directory(struct ttm_tt *ttm)
 {
-	ttm->dma_address = kvzalloc_objs(*ttm->dma_address, ttm->num_pages,
-					 GFP_KERNEL);
+	ttm->dma_address = kvzalloc_objs(*ttm->dma_address, ttm->num_pages);
 	if (!ttm->dma_address)
 		return -ENOMEM;
 

drivers/gpu/drm/v3d/v3d_submit.c

···
 		return 0;
 
 	se->out_syncs = (struct v3d_submit_outsync *)
-			kvmalloc_objs(struct v3d_submit_outsync, count,
-				      GFP_KERNEL);
+			kvmalloc_objs(struct v3d_submit_outsync, count);
 	if (!se->out_syncs)
 		return -ENOMEM;
 
···
 	job->job_type = V3D_CPU_JOB_TYPE_RESET_PERFORMANCE_QUERY;
 
 	query_info->queries =
-		kvmalloc_objs(struct v3d_performance_query, reset.count,
-			      GFP_KERNEL);
+		kvmalloc_objs(struct v3d_performance_query, reset.count);
 	if (!query_info->queries)
 		return -ENOMEM;
 
···
 	job->job_type = V3D_CPU_JOB_TYPE_COPY_PERFORMANCE_QUERY;
 
 	query_info->queries =
-		kvmalloc_objs(struct v3d_performance_query, copy.count,
-			      GFP_KERNEL);
+		kvmalloc_objs(struct v3d_performance_query, copy.count);
 	if (!query_info->queries)
 		return -ENOMEM;
 
···
 		goto fail;
 	}
 
-	job->base.bo = kzalloc_objs(*job->base.bo, ARRAY_SIZE(args->bo_handles),
-				    GFP_KERNEL);
+	job->base.bo = kzalloc_objs(*job->base.bo, ARRAY_SIZE(args->bo_handles));
 	if (!job->base.bo) {
 		ret = -ENOMEM;
 		goto fail;

drivers/gpu/drm/vc4/vc4_bo.c

···
 	 * use.  This lets us avoid a bunch of string reallocation in
 	 * the kernel's draw and BO allocation paths.
 	 */
-	vc4->bo_labels = kzalloc_objs(*vc4->bo_labels, VC4_BO_TYPE_COUNT,
-				      GFP_KERNEL);
+	vc4->bo_labels = kzalloc_objs(*vc4->bo_labels, VC4_BO_TYPE_COUNT);
 	if (!vc4->bo_labels)
 		return -ENOMEM;
 	vc4->num_labels = VC4_BO_TYPE_COUNT;

drivers/gpu/drm/virtio/virtgpu_fence.c

···
 {
 	uint64_t fence_context = base_fence_ctx + ring_idx;
 	struct virtio_gpu_fence_driver *drv = &vgdev->fence_drv;
-	struct virtio_gpu_fence *fence = kzalloc_obj(struct virtio_gpu_fence,
-						     GFP_KERNEL);
+	struct virtio_gpu_fence *fence = kzalloc_obj(struct virtio_gpu_fence);
 
 	if (!fence)
 		return fence;

drivers/gpu/drm/virtio/virtgpu_prime.c

···
 	if (IS_ERR(sgt))
 		return PTR_ERR(sgt);
 
-	*ents = kvmalloc_objs(struct virtio_gpu_mem_entry, sgt->nents,
-			      GFP_KERNEL);
+	*ents = kvmalloc_objs(struct virtio_gpu_mem_entry, sgt->nents);
 	if (!(*ents)) {
 		dma_buf_unmap_attachment(attach, sgt, DMA_BIDIRECTIONAL);
 		return -ENOMEM;

drivers/gpu/drm/vkms/vkms_crtc.c

···
 
 static void vkms_atomic_crtc_reset(struct drm_crtc *crtc)
 {
-	struct vkms_crtc_state *vkms_state = kzalloc_obj(*vkms_state,
-						         GFP_KERNEL);
+	struct vkms_crtc_state *vkms_state = kzalloc_obj(*vkms_state);
 
 	if (crtc->state)
 		vkms_atomic_crtc_destroy_state(crtc, crtc->state);
···
 		i++;
 	}
 
-	vkms_state->active_planes = kzalloc_objs(*vkms_state->active_planes, i,
-						 GFP_KERNEL);
+	vkms_state->active_planes = kzalloc_objs(*vkms_state->active_planes, i);
 	if (!vkms_state->active_planes)
 		return -ENOMEM;
 	vkms_state->num_active_planes = i;

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

···
 					    w, h, diff);
 
 	if (!src->ttm->pages && src->ttm->sg) {
-		src_pages = kvmalloc_objs(struct page *, src->ttm->num_pages,
-					  GFP_KERNEL);
+		src_pages = kvmalloc_objs(struct page *, src->ttm->num_pages);
 		if (!src_pages)
 			return -ENOMEM;
 		ret = drm_prime_sg_to_page_array(src->ttm->sg, src_pages,
···
 			goto out;
 	}
 	if (!dst->ttm->pages && dst->ttm->sg) {
-		dst_pages = kvmalloc_objs(struct page *, dst->ttm->num_pages,
-					  GFP_KERNEL);
+		dst_pages = kvmalloc_objs(struct page *, dst->ttm->num_pages);
 		if (!dst_pages) {
 			ret = -ENOMEM;
 			goto out;

drivers/gpu/drm/vmwgfx/vmwgfx_kms.c

···
 	uint32_t i;
 	int ret = 0;
 
-	rects = kzalloc_objs(struct drm_rect, dev->mode_config.num_crtc,
-			     GFP_KERNEL);
+	rects = kzalloc_objs(struct drm_rect, dev->mode_config.num_crtc);
 	if (!rects)
 		return -ENOMEM;
 

drivers/gpu/drm/vmwgfx/vmwgfx_surface.c

···
 		ret = PTR_ERR(metadata->sizes);
 		goto out_no_sizes;
 	}
-	srf->offsets = kmalloc_objs(*srf->offsets, metadata->num_sizes,
-				    GFP_KERNEL);
+	srf->offsets = kmalloc_objs(*srf->offsets, metadata->num_sizes);
 	if (unlikely(!srf->offsets)) {
 		ret = -ENOMEM;
 		goto out_no_offsets;

drivers/gpu/drm/xe/xe_eu_stall.c

···
 	struct xe_bo *bo;
 	u32 size;
 
-	stream->xecore_buf = kzalloc_objs(*stream->xecore_buf, last_xecore,
-					  GFP_KERNEL);
+	stream->xecore_buf = kzalloc_objs(*stream->xecore_buf, last_xecore);
 	if (!stream->xecore_buf)
 		return -ENOMEM;
 

drivers/gpu/drm/xe/xe_oa.c

···
 	}
 
 	if (param->num_syncs) {
-		param->syncs = kzalloc_objs(*param->syncs, param->num_syncs,
-					    GFP_KERNEL);
+		param->syncs = kzalloc_objs(*param->syncs, param->num_syncs);
 		if (!param->syncs) {
 			ret = -ENOMEM;
 			goto exit;

drivers/gpu/drm/xe/xe_pt.c

···
 	entry->pt_bo->update_index = -1;
 
 	if (alloc_entries) {
-		entry->pt_entries = kmalloc_objs(*entry->pt_entries, XE_PDES,
-						 GFP_KERNEL);
+		entry->pt_entries = kmalloc_objs(*entry->pt_entries, XE_PDES);
 		if (!entry->pt_entries)
 			return -ENOMEM;
 	}

drivers/gpu/drm/xe/xe_vm_madvise.c

···
 	lockdep_assert_held(&vm->lock);
 
 	madvise_range->num_vmas = 0;
-	madvise_range->vmas = kmalloc_objs(*madvise_range->vmas, max_vmas,
-					   GFP_KERNEL);
+	madvise_range->vmas = kmalloc_objs(*madvise_range->vmas, max_vmas);
 	if (!madvise_range->vmas)
 		return -ENOMEM;
 

drivers/gpu/drm/xen/xen_drm_front_gem.c

···
 				 size_t buf_size)
 {
 	xen_obj->num_pages = DIV_ROUND_UP(buf_size, PAGE_SIZE);
-	xen_obj->pages = kvmalloc_objs(struct page *, xen_obj->num_pages,
-				       GFP_KERNEL);
+	xen_obj->pages = kvmalloc_objs(struct page *, xen_obj->num_pages);
 	return !xen_obj->pages ? -ENOMEM : 0;
 }
 

drivers/gpu/host1x/channel.c

···
 int host1x_channel_list_init(struct host1x_channel_list *chlist,
 			     unsigned int num_channels)
 {
-	chlist->channels = kzalloc_objs(struct host1x_channel, num_channels,
-					GFP_KERNEL);
+	chlist->channels = kzalloc_objs(struct host1x_channel, num_channels);
 	if (!chlist->channels)
 		return -ENOMEM;
 

drivers/greybus/manifest.c

···
 	if (!count)
 		return 0;
 
-	bundle->cport_desc = kzalloc_objs(*bundle->cport_desc, count,
-					  GFP_KERNEL);
+	bundle->cport_desc = kzalloc_objs(*bundle->cport_desc, count);
 	if (!bundle->cport_desc)
 		goto exit;
 

drivers/greybus/svc.c

···
 	if (!rail_names)
 		goto err_pwrmon_debugfs;
 
-	svc->pwrmon_rails = kzalloc_objs(*svc->pwrmon_rails, rail_count,
-					 GFP_KERNEL);
+	svc->pwrmon_rails = kzalloc_objs(*svc->pwrmon_rails, rail_count);
 	if (!svc->pwrmon_rails)
 		goto err_pwrmon_debugfs_free;
 

drivers/hid/hid-google-hammer.c

···
 	struct cros_ec_command *msg;
 	int ret;
 
-	msg = kzalloc_flex(*msg, data, max(sizeof(u32), sizeof(*params)),
-			   GFP_KERNEL);
+	msg = kzalloc_flex(*msg, data, max(sizeof(u32), sizeof(*params)));
 	if (!msg)
 		return -ENOMEM;
 

drivers/hid/hid-haptic.c

···
 		ret = -ENOMEM;
 		goto duration_map;
 	}
-	haptic->effect = kzalloc_objs(struct hid_haptic_effect, FF_MAX_EFFECTS,
-				      GFP_KERNEL);
+	haptic->effect = kzalloc_objs(struct hid_haptic_effect, FF_MAX_EFFECTS);
 	if (!haptic->effect) {
 		ret = -ENOMEM;
 		goto output_queue;

drivers/hid/intel-ish-hid/ishtp/hbm.c

···
 		return;
 
 	/* allocate storage for fw clients representation */
-	clients = kzalloc_objs(struct ishtp_fw_client, dev->fw_clients_num,
-			       GFP_KERNEL);
+	clients = kzalloc_objs(struct ishtp_fw_client, dev->fw_clients_num);
 	if (!clients) {
 		dev->dev_state = ISHTP_DEV_RESETTING;
 		ish_hw_reset(dev);

drivers/hv/hv.c

···
 		memset(hv_cpu, 0, sizeof(*hv_cpu));
 	}
 
-	hv_context.hv_numa_map = kzalloc_objs(struct cpumask, nr_node_ids,
-					      GFP_KERNEL);
+	hv_context.hv_numa_map = kzalloc_objs(struct cpumask, nr_node_ids);
 	if (!hv_context.hv_numa_map) {
 		pr_err("Unable to allocate NUMA map\n");
 		goto err;

drivers/hv/ring_buffer.c

···
 	 * First page holds struct hv_ring_buffer, do wraparound mapping for
 	 * the rest.
 	 */
-	pages_wraparound = kzalloc_objs(struct page *, page_cnt * 2 - 1,
-					GFP_KERNEL);
+	pages_wraparound = kzalloc_objs(struct page *, page_cnt * 2 - 1);
 	if (!pages_wraparound)
 		return -ENOMEM;
 

drivers/hwmon/coretemp.c

···
 		return -ENODEV;
 
 	max_zones = topology_max_packages() * topology_max_dies_per_package();
-	zone_devices = kzalloc_objs(struct platform_device *, max_zones,
-				    GFP_KERNEL);
+	zone_devices = kzalloc_objs(struct platform_device *, max_zones);
 	if (!zone_devices)
 		return -ENOMEM;
 

drivers/hwmon/ibmpex.c

···
 		return -ENOENT;
 	data->num_sensors = err;
 
-	data->sensors = kzalloc_objs(*data->sensors, data->num_sensors,
-				     GFP_KERNEL);
+	data->sensors = kzalloc_objs(*data->sensors, data->num_sensors);
 	if (!data->sensors)
 		return -ENOMEM;
 

drivers/hwtracing/coresight/coresight-tmc-etr.c

···
 	struct device *real_dev = dev->parent;
 
 	nr_pages = tmc_pages->nr_pages;
-	tmc_pages->daddrs = kzalloc_objs(*tmc_pages->daddrs, nr_pages,
-					 GFP_KERNEL);
+	tmc_pages->daddrs = kzalloc_objs(*tmc_pages->daddrs, nr_pages);
 	if (!tmc_pages->daddrs)
 		return -ENOMEM;
 	tmc_pages->pages = kzalloc_objs(*tmc_pages->pages, nr_pages);

drivers/i2c/busses/i2c-qcom-geni.c

···
 
 	if (gi2c->is_tx_multi_desc_xfer) {
 		tx_multi_xfer->dma_buf = kcalloc(num, sizeof(void *), GFP_KERNEL);
-		tx_multi_xfer->dma_addr = kzalloc_objs(dma_addr_t, num,
-						       GFP_KERNEL);
+		tx_multi_xfer->dma_addr = kzalloc_objs(dma_addr_t, num);
 		if (!tx_multi_xfer->dma_buf || !tx_multi_xfer->dma_addr) {
 			ret = -ENOMEM;
 			goto err;

drivers/i2c/i2c-dev.c

···
 		if (rdwr_arg.nmsgs > I2C_RDWR_IOCTL_MAX_MSGS)
 			return -EINVAL;
 
-		rdwr_pa = kmalloc_objs(struct i2c_msg, rdwr_arg.nmsgs,
-				       GFP_KERNEL);
+		rdwr_pa = kmalloc_objs(struct i2c_msg, rdwr_arg.nmsgs);
 		if (!rdwr_pa)
 			return -ENOMEM;
 

drivers/i3c/master.c

···
 	void *bounce __free(kfree) = NULL;
 	void *dma_buf = buf;
 
-	struct i3c_dma *dma_xfer __free(kfree) = kzalloc_obj(*dma_xfer,
-							     GFP_KERNEL);
+	struct i3c_dma *dma_xfer __free(kfree) = kzalloc_obj(*dma_xfer);
 	if (!dma_xfer)
 		return NULL;
 

drivers/i3c/master/mipi-i3c-hci/dma.c

···
 		rh->resp = dma_alloc_coherent(rings->sysdev, resps_sz,
 					      &rh->resp_dma, GFP_KERNEL);
 		rh->src_xfers =
-			kmalloc_objs(*rh->src_xfers, rh->xfer_entries,
-				     GFP_KERNEL);
+			kmalloc_objs(*rh->src_xfers, rh->xfer_entries);
 		ret = -ENOMEM;
 		if (!rh->xfer || !rh->resp || !rh->src_xfers)
 			goto err_out;

drivers/infiniband/core/cache.c

···
 
 	ndev = rcu_dereference_protected(attr->ndev, 1);
 	if (ndev) {
-		entry->ndev_storage = kzalloc_obj(*entry->ndev_storage,
-						  GFP_KERNEL);
+		entry->ndev_storage = kzalloc_obj(*entry->ndev_storage);
 		if (!entry->ndev_storage) {
 			kfree(entry);
 			return NULL;

drivers/infiniband/core/cm.c

···
 	int count = 0;
 	u32 i;
 
-	cm_dev = kzalloc_flex(*cm_dev, port, ib_device->phys_port_cnt,
-			      GFP_KERNEL);
+	cm_dev = kzalloc_flex(*cm_dev, port, ib_device->phys_port_cnt);
 	if (!cm_dev)
 		return -ENOMEM;
 

drivers/infiniband/core/cma.c

···
 
 	rt = &id->route;
 	rt->num_pri_alt_paths = ib_event->param.req_rcvd.alternate_path ? 2 : 1;
-	rt->path_rec = kmalloc_objs(*rt->path_rec, rt->num_pri_alt_paths,
-				    GFP_KERNEL);
+	rt->path_rec = kmalloc_objs(*rt->path_rec, rt->num_pri_alt_paths);
 	if (!rt->path_rec)
 		goto err;
 
···
 	struct rdma_route *route = &work->id->id.route;
 
 	if (!route->path_rec_inbound) {
-		route->path_rec_inbound = kzalloc_obj(*route->path_rec_inbound,
-						      GFP_KERNEL);
+		route->path_rec_inbound = kzalloc_obj(*route->path_rec_inbound);
 		if (!route->path_rec_inbound)
 			return -ENOMEM;
 	}
···
 	struct rdma_route *route = &work->id->id.route;
 
 	if (!route->path_rec_outbound) {
-		route->path_rec_outbound = kzalloc_obj(*route->path_rec_outbound,
-						       GFP_KERNEL);
+		route->path_rec_outbound = kzalloc_obj(*route->path_rec_outbound);
 		if (!route->path_rec_outbound)
 			return -ENOMEM;
 	}

drivers/infiniband/core/roce_gid_mgmt.c

···
 				struct net_device *ndev)
 {
 	unsigned int i;
-	struct netdev_event_work *ndev_work = kmalloc_obj(*ndev_work,
-							  GFP_KERNEL);
+	struct netdev_event_work *ndev_work = kmalloc_obj(*ndev_work);
 
 	if (!ndev_work)
 		return NOTIFY_DONE;

drivers/infiniband/core/rw.c

···
 	int i, ret, count = 0;
 	u32 nents = 0;
 
-	ctx->reg = kzalloc_objs(*ctx->reg, DIV_ROUND_UP(nr_bvec, pages_per_mr),
-				GFP_KERNEL);
+	ctx->reg = kzalloc_objs(*ctx->reg, DIV_ROUND_UP(nr_bvec, pages_per_mr));
 	if (!ctx->reg)
 		return -ENOMEM;
 
···
 	 * Build scatterlist from bvecs using the iterator. This follows
 	 * the pattern from __blk_rq_map_sg.
 	 */
-	ctx->reg[0].sgt.sgl = kmalloc_objs(*ctx->reg[0].sgt.sgl, nr_bvec,
-					   GFP_KERNEL);
+	ctx->reg[0].sgt.sgl = kmalloc_objs(*ctx->reg[0].sgt.sgl, nr_bvec);
 	if (!ctx->reg[0].sgt.sgl) {
 		ret = -ENOMEM;
 		goto out_free_reg;

drivers/infiniband/core/sa_query.c

···
 	s = rdma_start_port(device);
 	e = rdma_end_port(device);
 
-	sa_dev = kzalloc_flex(*sa_dev, port, size_add(size_sub(e, s), 1),
-			      GFP_KERNEL);
+	sa_dev = kzalloc_flex(*sa_dev, port, size_add(size_sub(e, s), 1));
 	if (!sa_dev)
 		return -ENOMEM;
 

drivers/infiniband/core/sysfs.c

···
 	 * Two extra attribue elements here, one for the lifespan entry and
 	 * one to NULL terminate the list for the sysfs core code
 	 */
-	data = kzalloc_flex(*data, attrs, size_add(stats->num_counters, 1),
-			    GFP_KERNEL);
+	data = kzalloc_flex(*data, attrs, size_add(stats->num_counters, 1));
 	if (!data)
 		goto err_free_stats;
 	data->group.attrs = kzalloc_objs(*data->group.attrs,
···
 	 * Two extra attribue elements here, one for the lifespan entry and
 	 * one to NULL terminate the list for the sysfs core code
 	 */
-	data = kzalloc_flex(*data, attrs, size_add(stats->num_counters, 1),
-			    GFP_KERNEL);
+	data = kzalloc_flex(*data, attrs, size_add(stats->num_counters, 1));
 	if (!data)
 		goto err_free_stats;
-	group->attrs = kzalloc_objs(*group->attrs, stats->num_counters + 2,
-				    GFP_KERNEL);
+	group->attrs = kzalloc_objs(*group->attrs, stats->num_counters + 2);
 	if (!group->attrs)
 		goto err_free_data;
 

drivers/infiniband/core/user_mad.c

···
 	s = rdma_start_port(device);
 	e = rdma_end_port(device);
 
-	umad_dev = kzalloc_flex(*umad_dev, ports, size_add(size_sub(e, s), 1),
-				GFP_KERNEL);
+	umad_dev = kzalloc_flex(*umad_dev, ports, size_add(size_sub(e, s), 1));
 	if (!umad_dev)
 		return -ENOMEM;
 

drivers/infiniband/core/uverbs_cmd.c

···
 		goto err_put;
 	}
 
-	flow_attr = kzalloc_flex(*flow_attr, flows, cmd.flow_attr.num_of_specs,
-				 GFP_KERNEL);
+	flow_attr = kzalloc_flex(*flow_attr, flows, cmd.flow_attr.num_of_specs);
 	if (!flow_attr) {
 		err = -ENOMEM;
 		goto err_put;

drivers/infiniband/hw/bng_re/bng_fw.c

···
 		goto fail;
 	}
 
-	rcfw->crsqe_tbl = kzalloc_objs(*rcfw->crsqe_tbl, cmdq->hwq.max_elements,
-				       GFP_KERNEL);
+	rcfw->crsqe_tbl = kzalloc_objs(*rcfw->crsqe_tbl, cmdq->hwq.max_elements);
 	if (!rcfw->crsqe_tbl)
 		goto fail;
 

drivers/infiniband/hw/bnxt_re/ib_verbs.c

···
 
 	rdev = qp->rdev;
 	/* Create a shadow QP to handle the QP1 traffic */
-	sqp_tbl = kzalloc_objs(*sqp_tbl, BNXT_RE_MAX_GSI_SQP_ENTRIES,
-			       GFP_KERNEL);
+	sqp_tbl = kzalloc_objs(*sqp_tbl, BNXT_RE_MAX_GSI_SQP_ENTRIES);
 	if (!sqp_tbl)
 		return -ENOMEM;
 	rdev->gsi_ctx.sqp_tbl = sqp_tbl;
···
 		cq->qplib_cq.dpi = &uctx->dpi;
 	} else {
 		cq->max_cql = min_t(u32, entries, MAX_CQL_PER_POLL);
-		cq->cql = kzalloc_objs(struct bnxt_qplib_cqe, cq->max_cql,
-				       GFP_KERNEL);
+		cq->cql = kzalloc_objs(struct bnxt_qplib_cqe, cq->max_cql);
 		if (!cq->cql) {
 			rc = -ENOMEM;
 			goto fail;

drivers/infiniband/hw/bnxt_re/qplib_fp.c

···
 	srq->start_idx = 0;
 	srq->last_idx = srq->hwq.max_elements - 1;
 	if (!srq->hwq.is_user) {
-		srq->swq = kzalloc_objs(*srq->swq, srq->hwq.max_elements,
-					GFP_KERNEL);
+		srq->swq = kzalloc_objs(*srq->swq, srq->hwq.max_elements);
 		if (!srq->swq) {
 			rc = -ENOMEM;
 			goto fail;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

···
 		goto fail;
 	}
 
-	rcfw->crsqe_tbl = kzalloc_objs(*rcfw->crsqe_tbl, cmdq->hwq.max_elements,
-				       GFP_KERNEL);
+	rcfw->crsqe_tbl = kzalloc_objs(*rcfw->crsqe_tbl, cmdq->hwq.max_elements);
 	if (!rcfw->crsqe_tbl)
 		goto fail;
 

drivers/infiniband/hw/cxgb4/qp.c

···
 	}
 
 	if (!user) {
-		wq->sq.sw_sq = kzalloc_objs(*wq->sq.sw_sq, wq->sq.size,
-					    GFP_KERNEL);
+		wq->sq.sw_sq = kzalloc_objs(*wq->sq.sw_sq, wq->sq.size);
 		if (!wq->sq.sw_sq) {
 			ret = -ENOMEM;
 			goto free_rq_qid;//FIXME
 		}
 
 		if (need_rq) {
-			wq->rq.sw_rq = kzalloc_objs(*wq->rq.sw_rq, wq->rq.size,
-						    GFP_KERNEL);
+			wq->rq.sw_rq = kzalloc_objs(*wq->rq.sw_rq, wq->rq.size);
 			if (!wq->rq.sw_rq) {
 				ret = -ENOMEM;
 				goto free_sw_sq;
···
 		}
 		memset(&uresp, 0, sizeof(uresp));
 		if (t4_sq_onchip(&qhp->wq.sq)) {
-			ma_sync_key_mm = kmalloc_obj(*ma_sync_key_mm,
-						     GFP_KERNEL);
+			ma_sync_key_mm = kmalloc_obj(*ma_sync_key_mm);
 			if (!ma_sync_key_mm) {
 				ret = -ENOMEM;
 				goto err_free_rq_db_key;

drivers/infiniband/hw/efa/efa_verbs.c

···
 	chunk_list_size = DIV_ROUND_UP(page_cnt, EFA_PTRS_PER_CHUNK);
 
 	chunk_list->size = chunk_list_size;
-	chunk_list->chunks = kzalloc_objs(*chunk_list->chunks, chunk_list_size,
-					  GFP_KERNEL);
+	chunk_list->chunks = kzalloc_objs(*chunk_list->chunks, chunk_list_size);
 	if (!chunk_list->chunks)
 		return -ENOMEM;
 

drivers/infiniband/hw/hfi1/pio.c

···
 			vl_scontexts[i] = sc_per_vl + (extra > 0 ? 1 : 0);
 	}
 	/* build new map */
-	newmap = kzalloc_flex(*newmap, map, roundup_pow_of_two(num_vls),
-			      GFP_KERNEL);
+	newmap = kzalloc_flex(*newmap, map, roundup_pow_of_two(num_vls));
 	if (!newmap)
 		goto bail;
 	newmap->actual_vls = num_vls;
···
 			int sz = roundup_pow_of_two(vl_scontexts[i]);
 
 			/* only allocate once */
-			newmap->map[i] = kzalloc_flex(*newmap->map[i], ksc, sz,
-						      GFP_KERNEL);
+			newmap->map[i] = kzalloc_flex(*newmap->map[i], ksc, sz);
 			if (!newmap->map[i])
 				goto bail;
 			newmap->map[i]->mask = (1 << ilog2(sz)) - 1;

drivers/infiniband/hw/hfi1/user_exp_rcv.c

···
 {
 	int ret = 0;
 
-	fd->entry_to_rb = kzalloc_objs(*fd->entry_to_rb, uctxt->expected_count,
-				       GFP_KERNEL);
+	fd->entry_to_rb = kzalloc_objs(*fd->entry_to_rb, uctxt->expected_count);
 	if (!fd->entry_to_rb)
 		return -ENOMEM;
 

drivers/infiniband/hw/hns/hns_roce_main.c

···
 
 static int hns_roce_alloc_dfx_cnt(struct hns_roce_dev *hr_dev)
 {
-	hr_dev->dfx_cnt = kvzalloc_objs(atomic64_t, HNS_ROCE_DFX_CNT_TOTAL,
-					GFP_KERNEL);
+	hr_dev->dfx_cnt = kvzalloc_objs(atomic64_t, HNS_ROCE_DFX_CNT_TOTAL);
 	if (!hr_dev->dfx_cnt)
 		return -ENOMEM;
 

drivers/infiniband/hw/ionic/ionic_admin.c

···
 		goto out;
 	}
 
-	dev->eq_vec = kmalloc_objs(*dev->eq_vec, dev->lif_cfg.eq_count,
-				   GFP_KERNEL);
+	dev->eq_vec = kmalloc_objs(*dev->eq_vec, dev->lif_cfg.eq_count);
 	if (!dev->eq_vec) {
 		rc = -ENOMEM;
 		goto out;
···
 
 	dev->lif_cfg.eq_count = eq_i;
 
-	dev->aq_vec = kmalloc_objs(*dev->aq_vec, dev->lif_cfg.aq_count,
-				   GFP_KERNEL);
+	dev->aq_vec = kmalloc_objs(*dev->aq_vec, dev->lif_cfg.aq_count);
 	if (!dev->aq_vec) {
 		rc = -ENOMEM;
 		goto out;

drivers/infiniband/hw/ionic/ionic_controlpath.c

···
 
 		ionic_queue_dbell_init(&qp->sq, qp->qpid);
 
-		qp->sq_meta = kmalloc_objs(*qp->sq_meta, (u32)qp->sq.mask + 1,
-					   GFP_KERNEL);
+		qp->sq_meta = kmalloc_objs(*qp->sq_meta, (u32)qp->sq.mask + 1);
 		if (!qp->sq_meta) {
 			rc = -ENOMEM;
 			goto err_sq_meta;
···
 
 		ionic_queue_dbell_init(&qp->rq, qp->qpid);
 
-		qp->rq_meta = kmalloc_objs(*qp->rq_meta, (u32)qp->rq.mask + 1,
-					   GFP_KERNEL);
+		qp->rq_meta = kmalloc_objs(*qp->rq_meta, (u32)qp->rq.mask + 1);
 		if (!qp->rq_meta) {
 			rc = -ENOMEM;
 			goto err_rq_meta;

drivers/infiniband/hw/ionic/ionic_hw_stats.c

···
 	dev->hw_stats_count = hw_stats_count;
 
 	/* alloc and init array of names, for alloc_hw_stats */
-	dev->hw_stats_hdrs = kzalloc_objs(*dev->hw_stats_hdrs, hw_stats_count,
-					  GFP_KERNEL);
+	dev->hw_stats_hdrs = kzalloc_objs(*dev->hw_stats_hdrs, hw_stats_count);
 	if (!dev->hw_stats_hdrs) {
 		rc = -ENOMEM;
 		goto err_dma;
···
 	cs->queue_stats_count = hw_stats_count;
 
 	/* alloc and init array of names */
-	cs->stats_hdrs = kzalloc_objs(*cs->stats_hdrs, hw_stats_count,
-				      GFP_KERNEL);
+	cs->stats_hdrs = kzalloc_objs(*cs->stats_hdrs, hw_stats_count);
 	if (!cs->stats_hdrs) {
 		rc = -ENOMEM;
 		goto err_dma;
···
 	}
 
 	if (stats_type & IONIC_LIF_RDMA_STAT_QP) {
-		dev->counter_stats = kzalloc_obj(*dev->counter_stats,
-						 GFP_KERNEL);
+		dev->counter_stats = kzalloc_obj(*dev->counter_stats);
 		if (!dev->counter_stats)
 			return;
 

drivers/infiniband/hw/irdma/cm.c

···
 			ibdev_dbg(&iwdev->ibdev, "CM: IP=%pI6, vlan_id=%d, MAC=%pM\n",
 				  &ifp->addr, rdma_vlan_dev_vlan_id(ip_dev),
 				  ip_dev->dev_addr);
-			child_listen_node = kzalloc_obj(*child_listen_node,
-							GFP_KERNEL);
+			child_listen_node = kzalloc_obj(*child_listen_node);
 			ibdev_dbg(&iwdev->ibdev, "CM: Allocating child listener %p\n",
 				  child_listen_node);
 			if (!child_listen_node) {
···
 				  "CM: Allocating child CM Listener forIP=%pI4, vlan_id=%d, MAC=%pM\n",
 				  &ifa->ifa_address, rdma_vlan_dev_vlan_id(ip_dev),
 				  ip_dev->dev_addr);
-			child_listen_node = kzalloc_obj(*child_listen_node,
-							GFP_KERNEL);
+			child_listen_node = kzalloc_obj(*child_listen_node);
 			cm_parent_listen_node->cm_core->stats_listen_nodes_created++;
 			ibdev_dbg(&iwdev->ibdev, "CM: Allocating child listener %p\n",
 				  child_listen_node);

drivers/infiniband/hw/irdma/icrdma_if.c

···
 	int i;
 
 	rf->msix_count = num_online_cpus() + IRDMA_NUM_AEQ_MSIX;
-	rf->msix_entries = kzalloc_objs(*rf->msix_entries, rf->msix_count,
-					GFP_KERNEL);
+	rf->msix_entries = kzalloc_objs(*rf->msix_entries, rf->msix_count);
 	if (!rf->msix_entries)
 		return -ENOMEM;
 

drivers/infiniband/hw/irdma/ig3rdma_if.c

···
 		return -ENOMEM;
 
 	hw->num_io_regions = le16_to_cpu(idc_priv->num_memory_regions);
-	hw->io_regs = kzalloc_objs(struct irdma_mmio_region, hw->num_io_regions,
-				   GFP_KERNEL);
+	hw->io_regs = kzalloc_objs(struct irdma_mmio_region, hw->num_io_regions);
 
 	if (!hw->io_regs) {
 		iounmap(hw->rdma_reg.addr);

drivers/infiniband/hw/irdma/verbs.c

···
 		return status;
 
 	iwqp->kqp.sq_wrid_mem =
-		kzalloc_objs(*iwqp->kqp.sq_wrid_mem, ukinfo->sq_depth,
-			     GFP_KERNEL);
+		kzalloc_objs(*iwqp->kqp.sq_wrid_mem, ukinfo->sq_depth);
 	if (!iwqp->kqp.sq_wrid_mem)
 		return -ENOMEM;
 
 	iwqp->kqp.rq_wrid_mem =
-		kzalloc_objs(*iwqp->kqp.rq_wrid_mem, ukinfo->rq_depth,
-			     GFP_KERNEL);
+		kzalloc_objs(*iwqp->kqp.rq_wrid_mem, ukinfo->rq_depth);
 
 	if (!iwqp->kqp.rq_wrid_mem) {
 		kfree(iwqp->kqp.sq_wrid_mem);

drivers/infiniband/hw/mlx4/alias_GUID.c

···
 
 	if (!mlx4_is_master(dev->dev))
 		return 0;
-	dev->sriov.alias_guid.sa_client = kzalloc_obj(*dev->sriov.alias_guid.sa_client,
-						      GFP_KERNEL);
+	dev->sriov.alias_guid.sa_client = kzalloc_obj(*dev->sriov.alias_guid.sa_client);
 	if (!dev->sriov.alias_guid.sa_client)
 		return -ENOMEM;
 

drivers/infiniband/hw/mlx4/mad.c

···
 	if (!tun_qp->ring)
 		return -ENOMEM;
 
-	tun_qp->tx_ring = kzalloc_objs(struct mlx4_ib_tun_tx_buf, nmbr_bufs,
-				       GFP_KERNEL);
+	tun_qp->tx_ring = kzalloc_objs(struct mlx4_ib_tun_tx_buf, nmbr_bufs);
 	if (!tun_qp->tx_ring) {
 		kfree(tun_qp->ring);
 		tun_qp->ring = NULL;

drivers/infiniband/hw/mlx4/main.c

···
 	if (mlx4_is_bonded(dev))
 		for (i = 1; i < ibdev->num_ports ; ++i) {
 			new_counter_index =
-					kmalloc_obj(struct counter_index,
-						    GFP_KERNEL);
+					kmalloc_obj(struct counter_index);
 			if (!new_counter_index) {
 				err = -ENOMEM;
 				goto err_counter;

drivers/infiniband/hw/mlx4/sysfs.c

···
 	 *	gids (operational)
 	 *	mcg_table
 	 */
-	port->dentr_ar = kzalloc_obj(struct mlx4_ib_iov_sysfs_attr_ar,
-				     GFP_KERNEL);
+	port->dentr_ar = kzalloc_obj(struct mlx4_ib_iov_sysfs_attr_ar);
 	if (!port->dentr_ar) {
 		ret = -ENOMEM;
 		goto err;

drivers/infiniband/hw/mlx5/counters.c

···
 skip_non_qcounters:
 	cnts->num_op_counters = num_op_counters;
 	num_counters += num_op_counters;
-	cnts->descs = kzalloc_objs(struct rdma_stat_desc, num_counters,
-				   GFP_KERNEL);
+	cnts->descs = kzalloc_objs(struct rdma_stat_desc, num_counters);
 	if (!cnts->descs)
 		return -ENOMEM;
 
···
 		if (cntrs_data->ncounters > MAX_COUNTERS_NUM)
 			return -EINVAL;
 
-		desc_data = kzalloc_objs(*desc_data, cntrs_data->ncounters,
-					 GFP_KERNEL);
+		desc_data = kzalloc_objs(*desc_data, cntrs_data->ncounters);
 		if (!desc_data)
 			return  -ENOMEM;
 

drivers/infiniband/hw/mlx5/fs.c

···
 
 	for (i = 0; i < MLX5_RDMA_TRANSPORT_BYPASS_PRIO; i++) {
 		dev->flow_db->rdma_transport_rx[i] =
-			kzalloc_objs(struct mlx5_ib_flow_prio, dev->num_ports,
-				     GFP_KERNEL);
+			kzalloc_objs(struct mlx5_ib_flow_prio, dev->num_ports);
 		if (!dev->flow_db->rdma_transport_rx[i])
 			goto free_rdma_transport_rx;
 	}
 
 	for (j = 0; j < MLX5_RDMA_TRANSPORT_BYPASS_PRIO; j++) {
 		dev->flow_db->rdma_transport_tx[j] =
-			kzalloc_objs(struct mlx5_ib_flow_prio, dev->num_ports,
-				     GFP_KERNEL);
+			kzalloc_objs(struct mlx5_ib_flow_prio, dev->num_ports);
 		if (!dev->flow_db->rdma_transport_tx[j])
 			goto free_rdma_transport_tx;
 	}

drivers/infiniband/hw/mlx5/gsi.c

···
 		return -ENOMEM;
 
 	gsi->outstanding_wrs =
-		kzalloc_objs(*gsi->outstanding_wrs, attr->cap.max_send_wr,
-			     GFP_KERNEL);
+		kzalloc_objs(*gsi->outstanding_wrs, attr->cap.max_send_wr);
 	if (!gsi->outstanding_wrs) {
 		ret = -ENOMEM;
 		goto err_free_tx;

drivers/infiniband/hw/mlx5/mr.c

···
 	int i;
 
 	for (i = 0; i < num; i++) {
-		async_create = kzalloc_obj(struct mlx5r_async_create_mkey,
-					   GFP_KERNEL);
+		async_create = kzalloc_obj(struct mlx5r_async_create_mkey);
 		if (!async_create)
 			return -ENOMEM;
 		mkc = MLX5_ADDR_OF(create_mkey_in, async_create->in,

drivers/infiniband/hw/mlx5/qp.c

···
 					sizeof(*qp->sq.wr_data), GFP_KERNEL);
 	qp->rq.wrid = kvmalloc_array(qp->rq.wqe_cnt,
 				     sizeof(*qp->rq.wrid), GFP_KERNEL);
-	qp->sq.w_list = kvmalloc_objs(*qp->sq.w_list, qp->sq.wqe_cnt,
-				      GFP_KERNEL);
+	qp->sq.w_list = kvmalloc_objs(*qp->sq.w_list, qp->sq.wqe_cnt);
 	qp->sq.wqe_head = kvmalloc_array(qp->sq.wqe_cnt,
 					 sizeof(*qp->sq.wqe_head), GFP_KERNEL);
 

drivers/infiniband/hw/mthca/mthca_allocator.c

···
 		if (!dma_list)
 			return -ENOMEM;
 
-		buf->page_list = kmalloc_objs(*buf->page_list, npages,
-					      GFP_KERNEL);
+		buf->page_list = kmalloc_objs(*buf->page_list, npages);
 		if (!buf->page_list)
 			goto err_out;
 

drivers/infiniband/hw/mthca/mthca_mr.c

···
 
 	buddy->bits = kcalloc(buddy->max_order + 1, sizeof(*buddy->bits),
 			      GFP_KERNEL);
-	buddy->num_free = kzalloc_objs(*buddy->num_free, (buddy->max_order + 1),
-				       GFP_KERNEL);
+	buddy->num_free = kzalloc_objs(*buddy->num_free, (buddy->max_order + 1));
 	if (!buddy->bits || !buddy->num_free)
 		goto err_out;
 

drivers/infiniband/hw/ocrdma/ocrdma_main.c

···
 static int ocrdma_alloc_resources(struct ocrdma_dev *dev)
 {
 	mutex_init(&dev->dev_lock);
-	dev->cq_tbl = kzalloc_objs(struct ocrdma_cq *, OCRDMA_MAX_CQ,
-				   GFP_KERNEL);
+	dev->cq_tbl = kzalloc_objs(struct ocrdma_cq *, OCRDMA_MAX_CQ);
 	if (!dev->cq_tbl)
 		goto alloc_err;
 
 	if (dev->attr.max_qp) {
-		dev->qp_tbl = kzalloc_objs(struct ocrdma_qp *, OCRDMA_MAX_QP,
-					   GFP_KERNEL);
+		dev->qp_tbl = kzalloc_objs(struct ocrdma_qp *, OCRDMA_MAX_QP);
 		if (!dev->qp_tbl)
 			goto alloc_err;
 	}

drivers/infiniband/hw/ocrdma/ocrdma_verbs.c

···
 	void *va;
 	dma_addr_t pa;
 
-	mr->pbl_table = kzalloc_objs(struct ocrdma_pbl, mr->num_pbls,
-				     GFP_KERNEL);
+	mr->pbl_table = kzalloc_objs(struct ocrdma_pbl, mr->num_pbls);
 
 	if (!mr->pbl_table)
 		return -ENOMEM;

drivers/infiniband/hw/vmw_pvrdma/pvrdma_main.c

···
 	mutex_init(&dev->port_mutex);
 	spin_lock_init(&dev->desc_lock);
 
-	dev->cq_tbl = kzalloc_objs(struct pvrdma_cq *, dev->dsr->caps.max_cq,
-				   GFP_KERNEL);
+	dev->cq_tbl = kzalloc_objs(struct pvrdma_cq *, dev->dsr->caps.max_cq);
 	if (!dev->cq_tbl)
 		return ret;
 	spin_lock_init(&dev->cq_tbl_lock);
 
-	dev->qp_tbl = kzalloc_objs(struct pvrdma_qp *, dev->dsr->caps.max_qp,
-				   GFP_KERNEL);
+	dev->qp_tbl = kzalloc_objs(struct pvrdma_qp *, dev->dsr->caps.max_qp);
 	if (!dev->qp_tbl)
 		goto err_cq_free;
 	spin_lock_init(&dev->qp_tbl_lock);
···
 	}
 
 	/* Allocate GID table */
-	dev->sgid_tbl = kzalloc_objs(union ib_gid, dev->dsr->caps.gid_tbl_len,
-				     GFP_KERNEL);
+	dev->sgid_tbl = kzalloc_objs(union ib_gid, dev->dsr->caps.gid_tbl_len);
 	if (!dev->sgid_tbl) {
 		ret = -ENOMEM;
 		goto err_free_uar_table;

drivers/infiniband/ulp/ipoib/ipoib_main.c

···
 	ipoib_napi_add(dev);
 
 	/* Allocate RX/TX "rings" to hold queued skbs */
-	priv->rx_ring =	kzalloc_objs(*priv->rx_ring, ipoib_recvq_size,
-					    GFP_KERNEL);
+	priv->rx_ring =	kzalloc_objs(*priv->rx_ring, ipoib_recvq_size);
 	if (!priv->rx_ring)
 		goto out;
 

drivers/infiniband/ulp/isert/ib_isert.c

···
 {
 	int ret;
 
-	isert_conn->login_desc = kzalloc_obj(*isert_conn->login_desc,
-					     GFP_KERNEL);
+	isert_conn->login_desc = kzalloc_obj(*isert_conn->login_desc);
 	if (!isert_conn->login_desc)
 		return -ENOMEM;
 

drivers/infiniband/ulp/rtrs/rtrs-clt.c

···
 	enum ib_mr_type mr_type;
 	int i, err = -ENOMEM;
 
-	clt_path->reqs = kzalloc_objs(*clt_path->reqs, clt_path->queue_depth,
-				      GFP_KERNEL);
+	clt_path->reqs = kzalloc_objs(*clt_path->reqs, clt_path->queue_depth);
 	if (!clt_path->reqs)
 		return -ENOMEM;
 

drivers/infiniband/ulp/rtrs/rtrs-srv.c

···
 	struct rtrs_srv_op *id;
 	int i, ret;
 
-	srv_path->ops_ids = kzalloc_objs(*srv_path->ops_ids, srv->queue_depth,
-					 GFP_KERNEL);
+	srv_path->ops_ids = kzalloc_objs(*srv_path->ops_ids, srv->queue_depth);
 	if (!srv_path->ops_ids)
 		goto err;
 
···
 
 	srv_path->stats->srv_path = srv_path;
 
-	srv_path->dma_addr = kzalloc_objs(*srv_path->dma_addr, srv->queue_depth,
-					  GFP_KERNEL);
+	srv_path->dma_addr = kzalloc_objs(*srv_path->dma_addr, srv->queue_depth);
 	if (!srv_path->dma_addr)
 		goto err_free_percpu;
 

drivers/infiniband/ulp/srpt/ib_srpt.c

···
 	if (nbufs == 1) {
 		ioctx->rw_ctxs = &ioctx->s_rw_ctx;
 	} else {
-		ioctx->rw_ctxs = kmalloc_objs(*ioctx->rw_ctxs, nbufs,
-					      GFP_KERNEL);
+		ioctx->rw_ctxs = kmalloc_objs(*ioctx->rw_ctxs, nbufs);
 		if (!ioctx->rw_ctxs)
 			return -ENOMEM;
 	}

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

···
 	int ret = 0;
 	struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(master->dev);
 
-	master->streams = kzalloc_objs(*master->streams, fwspec->num_ids,
-				       GFP_KERNEL);
+	master->streams = kzalloc_objs(*master->streams, fwspec->num_ids);
 	if (!master->streams)
 		return -ENOMEM;
 	master->num_streams = fwspec->num_ids;

drivers/ipack/carriers/tpci200.c

···
 {
 	int res;
 
-	tpci200->slots = kzalloc_objs(struct tpci200_slot, TPCI200_NB_SLOT,
-				      GFP_KERNEL);
+	tpci200->slots = kzalloc_objs(struct tpci200_slot, TPCI200_NB_SLOT);
 	if (tpci200->slots == NULL)
 		return -ENOMEM;
 

drivers/irqchip/irq-alpine-msi.c

···
 
 static int alpine_msix_init(struct device_node *node, struct device_node *parent)
 {
-	struct alpine_msix_data *priv __free(kfree) = kzalloc_obj(*priv,
-								  GFP_KERNEL);
+	struct alpine_msix_data *priv __free(kfree) = kzalloc_obj(*priv);
 	struct resource res;
 	int ret;
 

drivers/irqchip/irq-bcm6345-l1.c

···
 	else if (intc->n_words != n_words)
 		return -EINVAL;
 
-	cpu = intc->cpus[idx] = kzalloc_flex(*cpu, enable_cache, n_words,
-					     GFP_KERNEL);
+	cpu = intc->cpus[idx] = kzalloc_flex(*cpu, enable_cache, n_words);
 	if (!cpu)
 		return -ENOMEM;
 

drivers/irqchip/irq-bcm7038-l1.c

···
 		return -EINVAL;
 	}
 
-	cpu = intc->cpus[idx] = kzalloc_flex(*cpu, mask_cache, n_words,
-					     GFP_KERNEL);
+	cpu = intc->cpus[idx] = kzalloc_flex(*cpu, mask_cache, n_words);
 	if (!cpu)
 		return -ENOMEM;
 

drivers/irqchip/irq-bcm7120-l2.c

···
 		goto out_unmap;
 	}
 
-	data->l1_data = kzalloc_objs(*data->l1_data, data->num_parent_irqs,
-				     GFP_KERNEL);
+	data->l1_data = kzalloc_objs(*data->l1_data, data->num_parent_irqs);
 	if (!data->l1_data) {
 		ret = -ENOMEM;
 		goto out_free_l1_data;

drivers/irqchip/irq-gic-v3-its.c

···
 {
 	int i;
 
-	its->collections = kzalloc_objs(*its->collections, nr_cpu_ids,
-					GFP_KERNEL);
+	its->collections = kzalloc_objs(*its->collections, nr_cpu_ids);
 	if (!its->collections)
 		return -ENOMEM;
 

drivers/irqchip/irq-gic-v5-iwb.c

···
 	unsigned int n;
 	int ret;
 
-	struct gicv5_iwb_chip_data *iwb_node __free(kfree) = kzalloc_obj(*iwb_node,
-									 GFP_KERNEL);
+	struct gicv5_iwb_chip_data *iwb_node __free(kfree) = kzalloc_obj(*iwb_node);
 	if (!iwb_node)
 		return ERR_PTR(-ENOMEM);
 

drivers/irqchip/irq-riscv-intc.c

···
 		if (count <= 0)
 			return -EINVAL;
 
-		rintc_acpi_data = kzalloc_objs(*rintc_acpi_data, count,
-					       GFP_KERNEL);
+		rintc_acpi_data = kzalloc_objs(*rintc_acpi_data, count);
 		if (!rintc_acpi_data)
 			return -ENOMEM;
 	}

drivers/isdn/capi/capi.c

···
 	if (capi_ttyminors <= 0)
 		capi_ttyminors = CAPINC_NR_PORTS;
 
-	capiminors = kzalloc_objs(struct capiminor *, capi_ttyminors,
-				  GFP_KERNEL);
+	capiminors = kzalloc_objs(struct capiminor *, capi_ttyminors);
 	if (!capiminors)
 		return -ENOMEM;
 

drivers/macintosh/windfarm_pm121.c

···
 	control = controls[param->control_id];
 
 	/* Alloc & initialize state */
-	pm121_sys_state[loop_id] = kmalloc_obj(struct pm121_sys_state,
-				               GFP_KERNEL);
+	pm121_sys_state[loop_id] = kmalloc_obj(struct pm121_sys_state);
 	if (pm121_sys_state[loop_id] == NULL) {
 		printk(KERN_WARNING "pm121: Memory allocation error\n");
 		goto fail;

drivers/macintosh/windfarm_pm91.c

···
 	};
 
 	/* Alloc & initialize state */
-	wf_smu_drive_fans = kmalloc_obj(struct wf_smu_drive_fans_state,
-				        GFP_KERNEL);
+	wf_smu_drive_fans = kmalloc_obj(struct wf_smu_drive_fans_state);
 	if (wf_smu_drive_fans == NULL) {
 		printk(KERN_WARNING "windfarm: Memory allocation error"
 		       " max fan speed\n");
···
 	};
 
 	/* Alloc & initialize state */
-	wf_smu_slots_fans = kmalloc_obj(struct wf_smu_slots_fans_state,
-				        GFP_KERNEL);
+	wf_smu_slots_fans = kmalloc_obj(struct wf_smu_slots_fans_state);
 	if (wf_smu_slots_fans == NULL) {
 		printk(KERN_WARNING "windfarm: Memory allocation error"
 		       " max fan speed\n");

drivers/md/dm-snap-persistent.c

···
 	 */
 	ps->exceptions_per_area = (ps->store->chunk_size << SECTOR_SHIFT) /
 				  sizeof(struct disk_exception);
-	ps->callbacks = kvzalloc_objs(*ps->callbacks, ps->exceptions_per_area,
-				      GFP_KERNEL);
+	ps->callbacks = kvzalloc_objs(*ps->callbacks, ps->exceptions_per_area);
 	if (!ps->callbacks)
 		return -ENOMEM;
 

drivers/md/dm-snap.c

···
 	for (i = 0; i < ORIGIN_HASH_SIZE; i++)
 		INIT_LIST_HEAD(_origins + i);
 
-	_dm_origins = kmalloc_objs(struct list_head, ORIGIN_HASH_SIZE,
-				   GFP_KERNEL);
+	_dm_origins = kmalloc_objs(struct list_head, ORIGIN_HASH_SIZE);
 	if (!_dm_origins) {
 		DMERR("unable to allocate memory for _dm_origins");
 		kfree(_origins);

drivers/md/dm-zoned-metadata.c

···
 	unsigned int bzone_id;
 
 	/* Metadata block array for the chunk mapping table */
-	zmd->map_mblk = kzalloc_objs(struct dmz_mblock *, zmd->nr_map_blocks,
-				     GFP_KERNEL);
+	zmd->map_mblk = kzalloc_objs(struct dmz_mblock *, zmd->nr_map_blocks);
 	if (!zmd->map_mblk)
 		return -ENOMEM;
 

drivers/md/raid0.c

···
 	}
 
 	err = -ENOMEM;
-	conf->strip_zone = kzalloc_objs(struct strip_zone, conf->nr_strip_zones,
-					GFP_KERNEL);
+	conf->strip_zone = kzalloc_objs(struct strip_zone, conf->nr_strip_zones);
 	if (!conf->strip_zone)
 		goto abort;
 	conf->devlist = kzalloc(array3_size(sizeof(struct md_rdev *),

drivers/md/raid1.c

···
 	if (!conf)
 		goto abort;
 
-	conf->nr_pending = kzalloc_objs(atomic_t, BARRIER_BUCKETS_NR,
-					GFP_KERNEL);
+	conf->nr_pending = kzalloc_objs(atomic_t, BARRIER_BUCKETS_NR);
 	if (!conf->nr_pending)
 		goto abort;
 
-	conf->nr_waiting = kzalloc_objs(atomic_t, BARRIER_BUCKETS_NR,
-					GFP_KERNEL);
+	conf->nr_waiting = kzalloc_objs(atomic_t, BARRIER_BUCKETS_NR);
 	if (!conf->nr_waiting)
 		goto abort;
 

drivers/md/raid5-ppl.c

···
 		goto err;
 
 	ppl_conf->count = conf->raid_disks;
-	ppl_conf->child_logs = kzalloc_objs(struct ppl_log, ppl_conf->count,
-					    GFP_KERNEL);
+	ppl_conf->child_logs = kzalloc_objs(struct ppl_log, ppl_conf->count);
 	if (!ppl_conf->child_logs) {
 		ret = -ENOMEM;
 		goto err;

drivers/md/raid5.c

···
 #endif
 	INIT_LIST_HEAD(&conf->free_list);
 	INIT_LIST_HEAD(&conf->pending_list);
-	conf->pending_data = kzalloc_objs(struct r5pending_data, PENDING_IO_MAX,
-					  GFP_KERNEL);
+	conf->pending_data = kzalloc_objs(struct r5pending_data, PENDING_IO_MAX);
 	if (!conf->pending_data)
 		goto abort;
 	for (i = 0; i < PENDING_IO_MAX; i++)

drivers/media/common/b2c2/flexcop.c

···
 struct flexcop_device *flexcop_device_kmalloc(size_t bus_specific_len)
 {
 	void *bus;
-	struct flexcop_device *fc = kzalloc_obj(struct flexcop_device,
-						GFP_KERNEL);
+	struct flexcop_device *fc = kzalloc_obj(struct flexcop_device);
 	if (!fc) {
 		err("no memory");
 		return NULL;

drivers/media/dvb-core/dvbdev.c

···
 {
 	int i;
 
-	dvbdev->tsout_pads = kzalloc_objs(*dvbdev->tsout_pads, npads,
-					  GFP_KERNEL);
+	dvbdev->tsout_pads = kzalloc_objs(*dvbdev->tsout_pads, npads);
 	if (!dvbdev->tsout_pads)
 		return -ENOMEM;
 
-	dvbdev->tsout_entity = kzalloc_objs(*dvbdev->tsout_entity, npads,
-					    GFP_KERNEL);
+	dvbdev->tsout_entity = kzalloc_objs(*dvbdev->tsout_entity, npads);
 	if (!dvbdev->tsout_entity)
 		return -ENOMEM;
 

drivers/media/dvb-frontends/dib0070.c

···
 
 struct dvb_frontend *dib0070_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c, struct dib0070_config *cfg)
 {
-	struct dib0070_state *state = kzalloc_obj(struct dib0070_state,
-						  GFP_KERNEL);
+	struct dib0070_state *state = kzalloc_obj(struct dib0070_state);
 	if (state == NULL)
 		return NULL;
 

drivers/media/dvb-frontends/dib0090.c

···
 
 struct dvb_frontend *dib0090_fw_register(struct dvb_frontend *fe, struct i2c_adapter *i2c, const struct dib0090_config *config)
 {
-	struct dib0090_fw_state *st = kzalloc_obj(struct dib0090_fw_state,
-						  GFP_KERNEL);
+	struct dib0090_fw_state *st = kzalloc_obj(struct dib0090_fw_state);
 	if (st == NULL)
 		return NULL;
 

drivers/media/dvb-frontends/s5h1420.c

···
 				    struct i2c_adapter *i2c)
 {
 	/* allocate memory for the internal state */
-	struct s5h1420_state *state = kzalloc_obj(struct s5h1420_state,
-						  GFP_KERNEL);
+	struct s5h1420_state *state = kzalloc_obj(struct s5h1420_state);
 	u8 i;
 
 	if (state == NULL)

drivers/media/dvb-frontends/stv0900_core.c

···
 		while (new_node->next_inode != NULL)
 			new_node = new_node->next_inode;
 
-		new_node->next_inode = kmalloc_obj(struct stv0900_inode,
-						   GFP_KERNEL);
+		new_node->next_inode = kmalloc_obj(struct stv0900_inode);
 		if (new_node->next_inode != NULL)
 			new_node = new_node->next_inode;
 		else
···
 		dprintk("%s: Find Internal Structure!\n", __func__);
 		return STV0900_NO_ERROR;
 	} else {
-		state->internal = kmalloc_obj(struct stv0900_internal,
-					      GFP_KERNEL);
+		state->internal = kmalloc_obj(struct stv0900_internal);
 		if (state->internal == NULL)
 			return STV0900_INVALID_HANDLE;
 		temp_int = append_internal(state->internal);

drivers/media/platform/nxp/imx8-isi/imx8-isi-core.c

···
 
 	isi->pdata = of_device_get_match_data(dev);
 
-	isi->pipes = kzalloc_objs(isi->pipes[0], isi->pdata->num_channels,
-				  GFP_KERNEL);
+	isi->pipes = kzalloc_objs(isi->pipes[0], isi->pdata->num_channels);
 	if (!isi->pipes)
 		return -ENOMEM;
 

drivers/media/platform/renesas/vsp1/vsp1_video.c

···
 	}
 
 	pipe->partitions = DIV_ROUND_UP(format->width, div_size);
-	pipe->part_table = kzalloc_objs(*pipe->part_table, pipe->partitions,
-					GFP_KERNEL);
+	pipe->part_table = kzalloc_objs(*pipe->part_table, pipe->partitions);
 	if (!pipe->part_table)
 		return -ENOMEM;
 

drivers/media/test-drivers/vidtv/vidtv_psi.c

···
 		program = program->next;
 	}
 
-	pmt_secs = kzalloc_objs(struct vidtv_psi_table_pmt *, num_pmt,
-				GFP_KERNEL);
+	pmt_secs = kzalloc_objs(struct vidtv_psi_table_pmt *, num_pmt);
 	if (!pmt_secs)
 		return NULL;
 

drivers/media/test-drivers/vimc/vimc-core.c

···
 		return ret;
 	}
 	/* allocate ent_devs */
-	vimc->ent_devs = kzalloc_objs(*vimc->ent_devs, vimc->pipe_cfg->num_ents,
-				      GFP_KERNEL);
+	vimc->ent_devs = kzalloc_objs(*vimc->ent_devs, vimc->pipe_cfg->num_ents);
 	if (!vimc->ent_devs) {
 		ret = -ENOMEM;
 		goto err_v4l2_unregister;

drivers/media/usb/dvb-usb/cinergyT2-fe.c

···
 
 struct dvb_frontend *cinergyt2_fe_attach(struct dvb_usb_device *d)
 {
-	struct cinergyt2_fe_state *s = kzalloc_obj(struct cinergyt2_fe_state,
-						   GFP_KERNEL);
+	struct cinergyt2_fe_state *s = kzalloc_obj(struct cinergyt2_fe_state);
 	if (s == NULL)
 		return NULL;
 

drivers/media/usb/dvb-usb/vp702x-fe.c

···
 
 struct dvb_frontend * vp702x_fe_attach(struct dvb_usb_device *d)
 {
-	struct vp702x_fe_state *s = kzalloc_obj(struct vp702x_fe_state,
-						GFP_KERNEL);
+	struct vp702x_fe_state *s = kzalloc_obj(struct vp702x_fe_state);
 	if (s == NULL)
 		goto error;
 

drivers/media/usb/dvb-usb/vp7045-fe.c

···
 
 struct dvb_frontend * vp7045_fe_attach(struct dvb_usb_device *d)
 {
-	struct vp7045_fe_state *s = kzalloc_obj(struct vp7045_fe_state,
-						GFP_KERNEL);
+	struct vp7045_fe_state *s = kzalloc_obj(struct vp7045_fe_state);
 	if (s == NULL)
 		goto error;
 

drivers/media/usb/pvrusb2/pvrusb2-hdw.c

···
 
 	hdw->control_cnt = CTRLDEF_COUNT;
 	hdw->control_cnt += MPEGDEF_COUNT;
-	hdw->controls = kzalloc_objs(struct pvr2_ctrl, hdw->control_cnt,
-				     GFP_KERNEL);
+	hdw->controls = kzalloc_objs(struct pvr2_ctrl, hdw->control_cnt);
 	if (!hdw->controls) goto fail;
 	hdw->hdw_desc = hdw_desc;
 	hdw->ir_scheme_active = hdw->hdw_desc->ir_scheme;

drivers/media/v4l2-core/v4l2-ctrls-core.c

···
 	INIT_LIST_HEAD(&hdl->ctrls);
 	INIT_LIST_HEAD(&hdl->ctrl_refs);
 	hdl->nr_of_buckets = 1 + nr_of_controls_hint / 8;
-	hdl->buckets = kvzalloc_objs(hdl->buckets[0], hdl->nr_of_buckets,
-				     GFP_KERNEL);
+	hdl->buckets = kvzalloc_objs(hdl->buckets[0], hdl->nr_of_buckets);
 	hdl->error = hdl->buckets ? 0 : -ENOMEM;
 	v4l2_ctrl_handler_init_request(hdl);
 	return hdl->error;

drivers/media/v4l2-core/v4l2-flash-led-class.c

···
 		return -ENOMEM;
 
 	/* allocate memory dynamically so as not to exceed stack frame size */
-	ctrl_init_data = kzalloc_objs(*ctrl_init_data, NUM_FLASH_CTRLS,
-				      GFP_KERNEL);
+	ctrl_init_data = kzalloc_objs(*ctrl_init_data, NUM_FLASH_CTRLS);
 	if (!ctrl_init_data)
 		return -ENOMEM;
 

drivers/media/v4l2-core/v4l2-subdev.c

···
 
 	/* Drivers that support streams do not need the legacy pad config */
 	if (!(sd->flags & V4L2_SUBDEV_FL_STREAMS) && sd->entity.num_pads) {
-		state->pads = kvzalloc_objs(*state->pads, sd->entity.num_pads,
-					    GFP_KERNEL);
+		state->pads = kvzalloc_objs(*state->pads, sd->entity.num_pads);
 		if (!state->pads) {
 			ret = -ENOMEM;
 			goto err;

drivers/message/fusion/mptlan.c

···
 		goto out;
 	priv->mpt_txfidx_tail = -1;
 
-	priv->SendCtl = kzalloc_objs(struct BufferControl, priv->tx_max_out,
-				     GFP_KERNEL);
+	priv->SendCtl = kzalloc_objs(struct BufferControl, priv->tx_max_out);
 	if (priv->SendCtl == NULL)
 		goto out_mpt_txfidx;
 	for (i = 0; i < priv->tx_max_out; i++)
···
 		goto out_SendCtl;
 	priv->mpt_rxfidx_tail = -1;
 
-	priv->RcvCtl = kzalloc_objs(struct BufferControl, priv->max_buckets_out,
-				    GFP_KERNEL);
+	priv->RcvCtl = kzalloc_objs(struct BufferControl, priv->max_buckets_out);
 	if (priv->RcvCtl == NULL)
 		goto out_mpt_rxfidx;
 	for (i = 0; i < priv->max_buckets_out; i++)

drivers/message/fusion/mptsas.c

···
 		 * Forming a port
 		 */
 		if (!port_details) {
-			port_details = kzalloc_obj(struct mptsas_portinfo_details,
-						   GFP_KERNEL);
+			port_details = kzalloc_obj(struct mptsas_portinfo_details);
 			if (!port_details)
 				goto out;
 			port_details->num_phys = 1;

drivers/mfd/timberdale.c

···
 		goto err_config;
 	}
 
-	msix_entries = kzalloc_objs(*msix_entries, TIMBERDALE_NR_IRQS,
-				    GFP_KERNEL);
+	msix_entries = kzalloc_objs(*msix_entries, TIMBERDALE_NR_IRQS);
 	if (!msix_entries)
 		goto err_config;
 

drivers/misc/altera-stapl/altera.c

···
 				/* Allocate a writable buffer for this array */
 				count = var_size[variable_id];
 				long_tmp = vars[variable_id];
-				longptr_tmp = kzalloc_objs(long, count,
-							   GFP_KERNEL);
+				longptr_tmp = kzalloc_objs(long, count);
 				vars[variable_id] = (long)longptr_tmp;
 
 				if (vars[variable_id] == 0) {

drivers/misc/fastrpc.c

···
 			kfree(ctx);
 			return ERR_PTR(-ENOMEM);
 		}
-		ctx->olaps = kzalloc_objs(*ctx->olaps, ctx->nscalars,
-					  GFP_KERNEL);
+		ctx->olaps = kzalloc_objs(*ctx->olaps, ctx->nscalars);
 		if (!ctx->olaps) {
 			kfree(ctx->maps);
 			kfree(ctx);
···
 	} inbuf;
 	u32 sc;
 
-	args = kzalloc_objs(*args, FASTRPC_CREATE_STATIC_PROCESS_NARGS,
-			    GFP_KERNEL);
+	args = kzalloc_objs(*args, FASTRPC_CREATE_STATIC_PROCESS_NARGS);
 	if (!args)
 		return -ENOMEM;
 

drivers/misc/genwqe/card_ddcb.c

···
 			"[%s] **err: could not allocate DDCB **\n", __func__);
 		return -ENOMEM;
 	}
-	queue->ddcb_req = kzalloc_objs(struct ddcb_requ *, queue->ddcb_max,
-				       GFP_KERNEL);
+	queue->ddcb_req = kzalloc_objs(struct ddcb_requ *, queue->ddcb_max);
 	if (!queue->ddcb_req) {
 		rc = -ENOMEM;
 		goto free_ddcbs;
 	}
 
-	queue->ddcb_waitqs = kzalloc_objs(wait_queue_head_t, queue->ddcb_max,
-					  GFP_KERNEL);
+	queue->ddcb_waitqs = kzalloc_objs(wait_queue_head_t, queue->ddcb_max);
 	if (!queue->ddcb_waitqs) {
 		rc = -ENOMEM;
 		goto free_requs;

drivers/misc/mchp_pci1xxxx/mchp_pci1xxxx_gp.c

···
 	if (!aux_bus)
 		return -ENOMEM;
 
-	aux_bus->aux_device_wrapper[0] = kzalloc_obj(*aux_bus->aux_device_wrapper[0],
-						     GFP_KERNEL);
+	aux_bus->aux_device_wrapper[0] = kzalloc_obj(*aux_bus->aux_device_wrapper[0]);
 	if (!aux_bus->aux_device_wrapper[0])
 		return -ENOMEM;
 
···
 	if (retval)
 		goto err_aux_dev_add_0;
 
-	aux_bus->aux_device_wrapper[1] = kzalloc_obj(*aux_bus->aux_device_wrapper[1],
-						     GFP_KERNEL);
+	aux_bus->aux_device_wrapper[1] = kzalloc_obj(*aux_bus->aux_device_wrapper[1]);
 	if (!aux_bus->aux_device_wrapper[1]) {
 		retval =  -ENOMEM;
 		goto err_aux_dev_add_0;

drivers/misc/mei/interrupt.c

···
 				break;
 			case MEI_EXT_HDR_GSC:
 				gsc_f2h = (struct mei_ext_hdr_gsc_f2h *)ext;
-				cb->ext_hdr = (struct mei_ext_hdr *) kzalloc_obj(*gsc_f2h,
-										 GFP_KERNEL);
+				cb->ext_hdr = (struct mei_ext_hdr *) kzalloc_obj(*gsc_f2h);
 				if (!cb->ext_hdr) {
 					cb->status = -ENOMEM;
 					goto discard;

drivers/misc/sgi-xp/xpc_main.c

···
 	 * memory.
 	 */
 	DBUG_ON(part->channels != NULL);
-	part->channels = kzalloc_objs(struct xpc_channel, XPC_MAX_NCHANNELS,
-				      GFP_KERNEL);
+	part->channels = kzalloc_objs(struct xpc_channel, XPC_MAX_NCHANNELS);
 	if (part->channels == NULL) {
 		dev_err(xpc_chan, "can't get memory for channels\n");
 		return xpNoMemory;
···
 	short partid;
 	struct xpc_partition *part;
 
-	xpc_partitions = kzalloc_objs(struct xpc_partition, xp_max_npartitions,
-				      GFP_KERNEL);
+	xpc_partitions = kzalloc_objs(struct xpc_partition, xp_max_npartitions);
 	if (xpc_partitions == NULL) {
 		dev_err(xpc_part, "can't get memory for partition structure\n");
 		return -ENOMEM;

drivers/misc/sgi-xp/xpc_uv.c

···
 
 	DBUG_ON(ch->flags & XPC_C_SETUP);
 
-	ch_uv->cached_notify_gru_mq_desc = kmalloc_obj(struct gru_message_queue_desc,
-						       GFP_KERNEL);
+	ch_uv->cached_notify_gru_mq_desc = kmalloc_obj(struct gru_message_queue_desc);
 	if (ch_uv->cached_notify_gru_mq_desc == NULL)
 		return xpNoMemory;
 

drivers/mtd/chips/cfi_cmdset_0001.c

···
 		newcfi = kmalloc_flex(*newcfi, chips, numvirtchips);
 		if (!newcfi)
 			return -ENOMEM;
-		shared = kmalloc_objs(struct flchip_shared, cfi->numchips,
-				      GFP_KERNEL);
+		shared = kmalloc_objs(struct flchip_shared, cfi->numchips);
 		if (!shared) {
 			kfree(newcfi);
 			return -ENOMEM;

drivers/mtd/chips/cfi_probe.c

···
 	if (!num_erase_regions)
 		return 0;
 
-	cfi->cfiq = kmalloc_flex(*cfi->cfiq, EraseRegionInfo, num_erase_regions,
-				 GFP_KERNEL);
+	cfi->cfiq = kmalloc_flex(*cfi->cfiq, EraseRegionInfo, num_erase_regions);
 	if (!cfi->cfiq)
 		return 0;
 

drivers/mtd/chips/jedec_probe.c

···
 
 	num_erase_regions = jedec_table[index].nr_regions;
 
-	cfi->cfiq = kmalloc_flex(*cfi->cfiq, EraseRegionInfo, num_erase_regions,
-				 GFP_KERNEL);
+	cfi->cfiq = kmalloc_flex(*cfi->cfiq, EraseRegionInfo, num_erase_regions);
 	if (!cfi->cfiq) {
 		//xx printk(KERN_WARNING "%s: kmalloc failed for CFI ident structure\n", map->name);
 		return 0;

drivers/mtd/ftl.c

···
     for (i = 0; i < part->DataUnits; i++)
 	part->EUNInfo[i].Offset = 0xffffffff;
     part->XferInfo =
-	kmalloc_objs(struct xfer_info_t, part->header.NumTransferUnits,
-                     GFP_KERNEL);
+	kmalloc_objs(struct xfer_info_t, part->header.NumTransferUnits);
     if (!part->XferInfo)
 	    goto out_EUNInfo;
 

drivers/mtd/mtdconcat.c

···
 		concat->mtd.erasesize = max_erasesize;
 		concat->mtd.numeraseregions = num_erase_region;
 		concat->mtd.eraseregions = erase_region_p =
-		    kmalloc_objs(struct mtd_erase_region_info, num_erase_region,
-				 GFP_KERNEL);
+		    kmalloc_objs(struct mtd_erase_region_info, num_erase_region);
 		if (!erase_region_p) {
 			kfree(concat);
 			printk

drivers/mtd/parsers/bcm47xxpart.c

···
 		blocksize = 0x1000;
 
 	/* Alloc */
-	parts = kzalloc_objs(struct mtd_partition, BCM47XXPART_MAX_PARTS,
-			     GFP_KERNEL);
+	parts = kzalloc_objs(struct mtd_partition, BCM47XXPART_MAX_PARTS);
 	if (!parts)
 		return -ENOMEM;
 

drivers/mtd/parsers/parser_trx.c

···
 	if (err != 0 && err != -EINVAL)
 		pr_err("failed to parse \"brcm,trx-magic\" DT attribute, using default: %d\n", err);
 
-	parts = kzalloc_objs(struct mtd_partition, TRX_PARSER_MAX_PARTS,
-			     GFP_KERNEL);
+	parts = kzalloc_objs(struct mtd_partition, TRX_PARSER_MAX_PARTS);
 	if (!parts)
 		return -ENOMEM;
 

drivers/mtd/parsers/scpart.c

···
 		goto free;
 	}
 
-	parts = kzalloc_objs(*parts, of_get_child_count(ofpart_node),
-			     GFP_KERNEL);
+	parts = kzalloc_objs(*parts, of_get_child_count(ofpart_node));
 	if (!parts) {
 		res = -ENOMEM;
 		goto free;

drivers/mtd/rfd_ftl.c

···
 	if (!part->header_cache)
 		goto err;
 
-	part->blocks = kzalloc_objs(struct block, part->total_blocks,
-				    GFP_KERNEL);
+	part->blocks = kzalloc_objs(struct block, part->total_blocks);
 	if (!part->blocks)
 		goto err;
 

drivers/mtd/sm_ftl.c

···
 
 
 	/* Create array of pointers to the attributes */
-	attributes = kzalloc_objs(struct attribute *, NUM_ATTRIBUTES + 1,
-				  GFP_KERNEL);
+	attributes = kzalloc_objs(struct attribute *, NUM_ATTRIBUTES + 1);
 	if (!attributes)
 		goto error3;
 	attributes[0] = &vendor_attribute->dev_attr.attr;

drivers/mtd/ubi/eba.c

···
 		if (!vol)
 			continue;
 
-		scan_eba[i] = kmalloc_objs(**scan_eba, vol->reserved_pebs,
-					   GFP_KERNEL);
+		scan_eba[i] = kmalloc_objs(**scan_eba, vol->reserved_pebs);
 		if (!scan_eba[i]) {
 			ret = -ENOMEM;
 			goto out_free;
 		}
 
-		fm_eba[i] = kmalloc_objs(**fm_eba, vol->reserved_pebs,
-					 GFP_KERNEL);
+		fm_eba[i] = kmalloc_objs(**fm_eba, vol->reserved_pebs);
 		if (!fm_eba[i]) {
 			ret = -ENOMEM;
 			kfree(scan_eba[i]);

drivers/net/bonding/bond_main.c

···
 		return NULL;
 
 	if (BOND_MODE(bond) == BOND_MODE_8023AD) {
-		SLAVE_AD_INFO(slave) = kzalloc_obj(struct ad_slave_info,
-						   GFP_KERNEL);
+		SLAVE_AD_INFO(slave) = kzalloc_obj(struct ad_slave_info);
 		if (!SLAVE_AD_INFO(slave)) {
 			kobject_put(&slave->kobj);
 			return NULL;
···
 
 	might_sleep();
 
-	usable_slaves = kzalloc_flex(*usable_slaves, arr, bond->slave_cnt,
-				     GFP_KERNEL);
+	usable_slaves = kzalloc_flex(*usable_slaves, arr, bond->slave_cnt);
 	all_slaves = kzalloc_flex(*all_slaves, arr, bond->slave_cnt);
 	if (!usable_slaves || !all_slaves) {
 		ret = -ENOMEM;

drivers/net/dsa/ocelot/felix.c

···
 	ocelot->npi_xtr_prefix	= OCELOT_TAG_PREFIX_SHORT;
 	ocelot->devlink		= felix->ds->devlink;
 
-	port_phy_modes = kzalloc_objs(phy_interface_t, num_phys_ports,
-				      GFP_KERNEL);
+	port_phy_modes = kzalloc_objs(phy_interface_t, num_phys_ports);
 	if (!port_phy_modes)
 		return -ENOMEM;
 

drivers/net/dsa/sja1105/sja1105_devlink.c

···
 	struct devlink_region *region;
 	u64 size;
 
-	priv->regions = kzalloc_objs(struct devlink_region *, num_regions,
-				     GFP_KERNEL);
+	priv->regions = kzalloc_objs(struct devlink_region *, num_regions);
 	if (!priv->regions)
 		return -ENOMEM;
 

drivers/net/ethernet/amd/pcnet32.c

···
 	if (!lp->rx_dma_addr)
 		return -ENOMEM;
 
-	lp->tx_skbuff = kzalloc_objs(struct sk_buff *, lp->tx_ring_size,
-				     GFP_KERNEL);
+	lp->tx_skbuff = kzalloc_objs(struct sk_buff *, lp->tx_ring_size);
 	if (!lp->tx_skbuff)
 		return -ENOMEM;
 
-	lp->rx_skbuff = kzalloc_objs(struct sk_buff *, lp->rx_ring_size,
-				     GFP_KERNEL);
+	lp->rx_skbuff = kzalloc_objs(struct sk_buff *, lp->rx_ring_size);
 	if (!lp->rx_skbuff)
 		return -ENOMEM;
 

drivers/net/ethernet/apm/xgene-v2/main.c

···
 	if (!ring->desc_addr)
 		goto err;
 
-	ring->pkt_info = kzalloc_objs(*ring->pkt_info, XGENE_ENET_NUM_DESC,
-				      GFP_KERNEL);
+	ring->pkt_info = kzalloc_objs(*ring->pkt_info, XGENE_ENET_NUM_DESC);
 	if (!ring->pkt_info)
 		goto err;
 

drivers/net/ethernet/aquantia/atlantic/aq_ptp.c

···
 	if (!info->n_pins)
 		return;
 
-	info->pin_config = kzalloc_objs(struct ptp_pin_desc, info->n_pins,
-					GFP_KERNEL);
+	info->pin_config = kzalloc_objs(struct ptp_pin_desc, info->n_pins);
 
 	if (!info->pin_config)
 		return;

drivers/net/ethernet/broadcom/asp2/bcmasp_intf.c

···
 	if (!intf->tx_spb_cpu)
 		goto free_rx_edpkt_dma;
 
-	intf->tx_cbs = kzalloc_objs(struct bcmasp_tx_cb, DESC_RING_COUNT,
-				    GFP_KERNEL);
+	intf->tx_cbs = kzalloc_objs(struct bcmasp_tx_cb, DESC_RING_COUNT);
 	if (!intf->tx_cbs)
 		goto free_tx_spb_dma;
 

drivers/net/ethernet/broadcom/bcm63xx_enet.c

···
 	priv->tx_desc_alloc_size = size;
 	priv->tx_desc_cpu = p;
 
-	priv->tx_skb = kzalloc_objs(struct sk_buff *, priv->tx_ring_size,
-				    GFP_KERNEL);
+	priv->tx_skb = kzalloc_objs(struct sk_buff *, priv->tx_ring_size);
 	if (!priv->tx_skb) {
 		ret = -ENOMEM;
 		goto out_free_tx_ring;
···
 	priv->tx_desc_alloc_size = size;
 	priv->tx_desc_cpu = p;
 
-	priv->tx_skb = kzalloc_objs(struct sk_buff *, priv->tx_ring_size,
-				    GFP_KERNEL);
+	priv->tx_skb = kzalloc_objs(struct sk_buff *, priv->tx_ring_size);
 	if (!priv->tx_skb) {
 		dev_err(kdev, "cannot allocate tx skb queue\n");
 		ret = -ENOMEM;

drivers/net/ethernet/broadcom/bcmsysport.c

···
 	priv->rx_bds = priv->base + SYS_PORT_RDMA_OFFSET;
 	priv->rx_c_index = 0;
 	priv->rx_read_ptr = 0;
-	priv->rx_cbs = kzalloc_objs(struct bcm_sysport_cb, priv->num_rx_bds,
-				    GFP_KERNEL);
+	priv->rx_cbs = kzalloc_objs(struct bcm_sysport_cb, priv->num_rx_bds);
 	if (!priv->rx_cbs) {
 		netif_err(priv, hw, priv->netdev, "CB allocation failed\n");
 		return -ENOMEM;

drivers/net/ethernet/broadcom/bnge/bnge_netdev.c

···
 	for (i = 0; i < bd->rx_nr_rings; i++) {
 		struct bnge_rx_ring_info *rxr = &bn->rx_ring[i];
 
-		rxr->rx_tpa = kzalloc_objs(struct bnge_tpa_info, bn->max_tpa,
-					   GFP_KERNEL);
+		rxr->rx_tpa = kzalloc_objs(struct bnge_tpa_info, bn->max_tpa);
 		if (!rxr->rx_tpa)
 			goto err_free_tpa_info;
 
···
 				goto err_free_tpa_info;
 			rxr->rx_tpa[j].agg_arr = agg;
 		}
-		rxr->rx_tpa_idx_map = kzalloc_obj(*rxr->rx_tpa_idx_map,
-						  GFP_KERNEL);
+		rxr->rx_tpa_idx_map = kzalloc_obj(*rxr->rx_tpa_idx_map);
 		if (!rxr->rx_tpa_idx_map)
 			goto err_free_tpa_info;
 	}
···
 	 */
 	num_vnics = 1;
 
-	bn->vnic_info = kzalloc_objs(struct bnge_vnic_info, num_vnics,
-				     GFP_KERNEL);
+	bn->vnic_info = kzalloc_objs(struct bnge_vnic_info, num_vnics);
 	if (!bn->vnic_info)
 		return -ENOMEM;
 
···
 	struct bnge_dev *bd = bn->bd;
 	int i;
 
-	bn->grp_info = kzalloc_objs(struct bnge_ring_grp_info, bd->nq_nr_rings,
-				    GFP_KERNEL);
+	bn->grp_info = kzalloc_objs(struct bnge_ring_grp_info, bd->nq_nr_rings);
 	if (!bn->grp_info)
 		return -ENOMEM;
 	for (i = 0; i < bd->nq_nr_rings; i++) {
···
 		nqr->ring_struct.ring_mem.flags = BNGE_RMEM_RING_PTE_FLAG;
 	}
 
-	bn->rx_ring = kzalloc_objs(struct bnge_rx_ring_info, bd->rx_nr_rings,
-				   GFP_KERNEL);
+	bn->rx_ring = kzalloc_objs(struct bnge_rx_ring_info, bd->rx_nr_rings);
 	if (!bn->rx_ring)
 		goto err_free_core;
 
···
 		bn->bnapi[i]->rx_ring = &bn->rx_ring[i];
 	}
 
-	bn->tx_ring = kzalloc_objs(struct bnge_tx_ring_info, bd->tx_nr_rings,
-				   GFP_KERNEL);
+	bn->tx_ring = kzalloc_objs(struct bnge_tx_ring_info, bd->tx_nr_rings);
 	if (!bn->tx_ring)
 		goto err_free_core;
 

drivers/net/ethernet/broadcom/bnge/bnge_rmem.c

···
 		int nr_tbls, i;
 
 		rmem->depth = 2;
-		ctx_pg->ctx_pg_tbl = kzalloc_objs(ctx_pg, MAX_CTX_PAGES,
-						  GFP_KERNEL);
+		ctx_pg->ctx_pg_tbl = kzalloc_objs(ctx_pg, MAX_CTX_PAGES);
 		if (!ctx_pg->ctx_pg_tbl)
 			return -ENOMEM;
 		nr_tbls = DIV_ROUND_UP(ctx_pg->nr_pages, MAX_CTX_PAGES);

drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c

···
 	bp->fp = fp;
 
 	/* allocate sp objs */
-	bp->sp_objs = kzalloc_objs(struct bnx2x_sp_objs, bp->fp_array_size,
-				   GFP_KERNEL);
+	bp->sp_objs = kzalloc_objs(struct bnx2x_sp_objs, bp->fp_array_size);
 	if (!bp->sp_objs)
 		goto alloc_err;
 
 	/* allocate fp_stats */
-	bp->fp_stats = kzalloc_objs(struct bnx2x_fp_stats, bp->fp_array_size,
-				    GFP_KERNEL);
+	bp->fp_stats = kzalloc_objs(struct bnx2x_fp_stats, bp->fp_array_size);
 	if (!bp->fp_stats)
 		goto alloc_err;
 
···
 		BNX2X_MAX_RSS_COUNT(bp) * BNX2X_MULTI_TX_COS + CNIC_SUPPORT(bp);
 	BNX2X_DEV_INFO("txq_array_size %d", txq_array_size);
 
-	bp->bnx2x_txq = kzalloc_objs(struct bnx2x_fp_txdata, txq_array_size,
-				     GFP_KERNEL);
+	bp->bnx2x_txq = kzalloc_objs(struct bnx2x_fp_txdata, txq_array_size);
 	if (!bp->bnx2x_txq)
 		goto alloc_err;
 

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c

···
 			goto alloc_mem_err;
 		allocated += bp->context[i].size;
 	}
-	bp->ilt->lines = kzalloc_objs(struct ilt_line, ILT_MAX_LINES,
-				      GFP_KERNEL);
+	bp->ilt->lines = kzalloc_objs(struct ilt_line, ILT_MAX_LINES);
 	if (!bp->ilt->lines)
 		goto alloc_mem_err;
 

drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c

···
 	else
 		set_bit(RAMROD_COMP_WAIT, &mcast.ramrod_flags);
 	if (mc_num) {
-		mc = kzalloc_objs(struct bnx2x_mcast_list_elem, mc_num,
-				  GFP_KERNEL);
+		mc = kzalloc_objs(struct bnx2x_mcast_list_elem, mc_num);
 		if (!mc) {
 			BNX2X_ERR("Cannot Configure multicasts due to lack of memory\n");
 			return -ENOMEM;
···
 	   num_vfs_param, iov->nr_virtfn);
 
 	/* allocate the vf array */
-	bp->vfdb->vfs = kzalloc_objs(struct bnx2x_virtf, BNX2X_NR_VIRTFN(bp),
-				     GFP_KERNEL);
+	bp->vfdb->vfs = kzalloc_objs(struct bnx2x_virtf, BNX2X_NR_VIRTFN(bp));
 	if (!bp->vfdb->vfs) {
 		BNX2X_ERR("failed to allocate vf array\n");
 		err = -ENOMEM;

drivers/net/ethernet/broadcom/bnxt/bnxt.c

···
 	struct rx_agg_cmp *agg;
 	int i;
 
-	rxr->rx_tpa = kzalloc_objs(struct bnxt_tpa_info, bp->max_tpa,
-				   GFP_KERNEL);
+	rxr->rx_tpa = kzalloc_objs(struct bnxt_tpa_info, bp->max_tpa);
 	if (!rxr->rx_tpa)
 		return -ENOMEM;
 
···
 	cpr->cp_desc_ring = kzalloc_objs(*cpr->cp_desc_ring, n);
 	if (!cpr->cp_desc_ring)
 		return -ENOMEM;
-	cpr->cp_desc_mapping = kzalloc_objs(*cpr->cp_desc_mapping, n,
-					    GFP_KERNEL);
+	cpr->cp_desc_mapping = kzalloc_objs(*cpr->cp_desc_mapping, n);
 	if (!cpr->cp_desc_mapping)
 		return -ENOMEM;
 	return 0;
···
 	if (BNXT_CHIP_TYPE_NITRO_A0(bp))
 		num_vnics++;
 
-	bp->vnic_info = kzalloc_objs(struct bnxt_vnic_info, num_vnics,
-				     GFP_KERNEL);
+	bp->vnic_info = kzalloc_objs(struct bnxt_vnic_info, num_vnics);
 	if (!bp->vnic_info)
 		return -ENOMEM;
 
···
 		int nr_tbls, i;
 
 		rmem->depth = 2;
-		ctx_pg->ctx_pg_tbl = kzalloc_objs(ctx_pg, MAX_CTX_PAGES,
-						  GFP_KERNEL);
+		ctx_pg->ctx_pg_tbl = kzalloc_objs(ctx_pg, MAX_CTX_PAGES);
 		if (!ctx_pg->ctx_pg_tbl)
 			return -ENOMEM;
 		nr_tbls = DIV_ROUND_UP(ctx_pg->nr_pages, MAX_CTX_PAGES);

drivers/net/ethernet/broadcom/bnxt/bnxt_ulp.c

···
 			return;
 
 		if (!err) {
-			ent = kzalloc_objs(*ent, ulp->msix_requested,
-					   GFP_KERNEL);
+			ent = kzalloc_objs(*ent, ulp->msix_requested);
 			if (!ent)
 				return;
 			bnxt_fill_msix_vecs(bp, ent);

drivers/net/ethernet/broadcom/cnic.c

···
 			cp->fcoe_init_cid = 0x10;
 	}
 
-	cp->iscsi_tbl = kzalloc_objs(struct cnic_iscsi, MAX_ISCSI_TBL_SZ,
-				     GFP_KERNEL);
+	cp->iscsi_tbl = kzalloc_objs(struct cnic_iscsi, MAX_ISCSI_TBL_SZ);
 	if (!cp->iscsi_tbl)
 		goto error;
 
-	cp->ctx_tbl = kzalloc_objs(struct cnic_context, cp->max_cid_space,
-				   GFP_KERNEL);
+	cp->ctx_tbl = kzalloc_objs(struct cnic_context, cp->max_cid_space);
 	if (!cp->ctx_tbl)
 		goto error;
 
···
 	u32 port_id;
 	int i;
 
-	cp->csk_tbl = kvzalloc_objs(struct cnic_sock, MAX_CM_SK_TBL_SZ,
-				    GFP_KERNEL);
+	cp->csk_tbl = kvzalloc_objs(struct cnic_sock, MAX_CM_SK_TBL_SZ);
 	if (!cp->csk_tbl)
 		return -ENOMEM;
 

drivers/net/ethernet/broadcom/genet/bcmgenet.c

···
 	/* Initialize common Rx ring structures */
 	priv->rx_bds = priv->base + priv->hw_params->rdma_offset;
 	priv->num_rx_bds = TOTAL_DESC;
-	priv->rx_cbs = kzalloc_objs(struct enet_cb, priv->num_rx_bds,
-				    GFP_KERNEL);
+	priv->rx_cbs = kzalloc_objs(struct enet_cb, priv->num_rx_bds);
 	if (!priv->rx_cbs)
 		return -ENOMEM;
 
···
 	/* Initialize common TX ring structures */
 	priv->tx_bds = priv->base + priv->hw_params->tdma_offset;
 	priv->num_tx_bds = TOTAL_DESC;
-	priv->tx_cbs = kzalloc_objs(struct enet_cb, priv->num_tx_bds,
-				    GFP_KERNEL);
+	priv->tx_cbs = kzalloc_objs(struct enet_cb, priv->num_tx_bds);
 	if (!priv->tx_cbs) {
 		kfree(priv->rx_cbs);
 		return -ENOMEM;

drivers/net/ethernet/broadcom/sb1250-mac.c

···
 	 * And context table
 	 */
 
-	d->sbdma_ctxtable = kzalloc_objs(*d->sbdma_ctxtable, d->sbdma_maxdescr,
-					 GFP_KERNEL);
+	d->sbdma_ctxtable = kzalloc_objs(*d->sbdma_ctxtable, d->sbdma_maxdescr);
 
 #ifdef CONFIG_SBMAC_COALESCE
 	/*

drivers/net/ethernet/brocade/bna/bnad.c

···
 		return 0;
 	}
 
-	mem_info->mdl = kzalloc_objs(struct bna_mem_descr, mem_info->num,
-				     GFP_KERNEL);
+	mem_info->mdl = kzalloc_objs(struct bna_mem_descr, mem_info->num);
 	if (mem_info->mdl == NULL)
 		return -ENOMEM;
 

drivers/net/ethernet/calxeda/xgmac.c

···
 
 	netdev_dbg(priv->dev, "mtu [%d] bfsize [%d]\n", dev->mtu, bfsize);
 
-	priv->rx_skbuff = kzalloc_objs(struct sk_buff *, DMA_RX_RING_SZ,
-				       GFP_KERNEL);
+	priv->rx_skbuff = kzalloc_objs(struct sk_buff *, DMA_RX_RING_SZ);
 	if (!priv->rx_skbuff)
 		return -ENOMEM;
 
···
 	if (!priv->dma_rx)
 		goto err_dma_rx;
 
-	priv->tx_skbuff = kzalloc_objs(struct sk_buff *, DMA_TX_RING_SZ,
-				       GFP_KERNEL);
+	priv->tx_skbuff = kzalloc_objs(struct sk_buff *, DMA_TX_RING_SZ);
 	if (!priv->tx_skbuff)
 		goto err_tx_skb;
 

drivers/net/ethernet/cavium/liquidio/lio_core.c

···
 	/* allocate memory to store virtual and dma base address of
 	 * per glist consistent memory
 	 */
-	lio->glists_virt_base = kzalloc_objs(*lio->glists_virt_base, num_iqs,
-					     GFP_KERNEL);
-	lio->glists_dma_base = kzalloc_objs(*lio->glists_dma_base, num_iqs,
-					    GFP_KERNEL);
+	lio->glists_virt_base = kzalloc_objs(*lio->glists_virt_base, num_iqs);
+	lio->glists_dma_base = kzalloc_objs(*lio->glists_dma_base, num_iqs);
 
 	if (!lio->glists_virt_base || !lio->glists_dma_base) {
 		lio_delete_glists(lio);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_ethtool.c

···
 	if (!eth_filter)
 		return -ENOMEM;
 
-	eth_filter_info = kzalloc_objs(*eth_filter_info, adap->params.nports,
-				       GFP_KERNEL);
+	eth_filter_info = kzalloc_objs(*eth_filter_info, adap->params.nports);
 	if (!eth_filter_info) {
 		ret = -ENOMEM;
 		goto free_eth_filter;

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

···
 	adap->sge.egr_sz = val[0] - adap->sge.egr_start + 1;
 	adap->sge.ingr_sz = val[1] - adap->sge.ingr_start + 1;
 
-	adap->sge.egr_map = kzalloc_objs(*adap->sge.egr_map, adap->sge.egr_sz,
-					 GFP_KERNEL);
+	adap->sge.egr_map = kzalloc_objs(*adap->sge.egr_map, adap->sge.egr_sz);
 	if (!adap->sge.egr_map) {
 		ret = -ENOMEM;
 		goto bye;

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_matchall.c

···
 	if (!tc_matchall)
 		return -ENOMEM;
 
-	tc_port_matchall = kzalloc_objs(*tc_port_matchall, adap->params.nports,
-					GFP_KERNEL);
+	tc_port_matchall = kzalloc_objs(*tc_port_matchall, adap->params.nports);
 	if (!tc_port_matchall) {
 		ret = -ENOMEM;
 		goto out_free_matchall;

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_mqprio.c

···
 	if (!tc_mqprio)
 		return -ENOMEM;
 
-	tc_port_mqprio = kzalloc_objs(*tc_port_mqprio, adap->params.nports,
-				      GFP_KERNEL);
+	tc_port_mqprio = kzalloc_objs(*tc_port_mqprio, adap->params.nports);
 	if (!tc_port_mqprio) {
 		ret = -ENOMEM;
 		goto out_free_mqprio;
···
 	tc_mqprio->port_mqprio = tc_port_mqprio;
 	for (i = 0; i < adap->params.nports; i++) {
 		port_mqprio = &tc_mqprio->port_mqprio[i];
-		eosw_txq = kzalloc_objs(*eosw_txq, adap->tids.neotids,
-					GFP_KERNEL);
+		eosw_txq = kzalloc_objs(*eosw_txq, adap->tids.neotids);
 		if (!eosw_txq) {
 			ret = -ENOMEM;
 			goto out_free_ports;

drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.c

···
 		i = min_t(int, uld_info->ntxq, num_online_cpus());
 		txq_info->ntxq = roundup(i, adap->params.nports);
 	}
-	txq_info->uldtxq = kzalloc_objs(struct sge_uld_txq, txq_info->ntxq,
-					GFP_KERNEL);
+	txq_info->uldtxq = kzalloc_objs(struct sge_uld_txq, txq_info->ntxq);
 	if (!txq_info->uldtxq) {
 		kfree(txq_info);
 		return -ENOMEM;
···
 	if (!adap->uld)
 		return -ENOMEM;
 
-	s->uld_rxq_info = kzalloc_objs(struct sge_uld_rxq_info *, CXGB4_ULD_MAX,
-				       GFP_KERNEL);
+	s->uld_rxq_info = kzalloc_objs(struct sge_uld_rxq_info *, CXGB4_ULD_MAX);
 	if (!s->uld_rxq_info)
 		goto err_uld;
 
-	s->uld_txq_info = kzalloc_objs(struct sge_uld_txq_info *, CXGB4_TX_MAX,
-				       GFP_KERNEL);
+	s->uld_txq_info = kzalloc_objs(struct sge_uld_txq_info *, CXGB4_TX_MAX);
 	if (!s->uld_txq_info)
 		goto err_uld_rx;
 	return 0;

drivers/net/ethernet/cisco/enic/enic_main.c

···
 	if (!enic->napi)
 		goto free_queues;
 
-	enic->msix_entry = kzalloc_objs(struct msix_entry, enic->intr_avail,
-					GFP_KERNEL);
+	enic->msix_entry = kzalloc_objs(struct msix_entry, enic->intr_avail);
 	if (!enic->msix_entry)
 		goto free_queues;
 
-	enic->msix = kzalloc_objs(struct enic_msix_entry, enic->intr_avail,
-				  GFP_KERNEL);
+	enic->msix = kzalloc_objs(struct enic_msix_entry, enic->intr_avail);
 	if (!enic->msix)
 		goto free_queues;
 
-	enic->intr = kzalloc_objs(struct vnic_intr, enic->intr_avail,
-				  GFP_KERNEL);
+	enic->intr = kzalloc_objs(struct vnic_intr, enic->intr_avail);
 	if (!enic->intr)
 		goto free_queues;
 

drivers/net/ethernet/emulex/benet/be_main.c

···
 	if (!adapter->pmac_id)
 		return -ENOMEM;
 
-	adapter->mc_list = kzalloc_objs(*adapter->mc_list, be_max_mc(adapter),
-					GFP_KERNEL);
+	adapter->mc_list = kzalloc_objs(*adapter->mc_list, be_max_mc(adapter));
 	if (!adapter->mc_list)
 		return -ENOMEM;
 
-	adapter->uc_list = kzalloc_objs(*adapter->uc_list, be_max_uc(adapter),
-					GFP_KERNEL);
+	adapter->uc_list = kzalloc_objs(*adapter->uc_list, be_max_uc(adapter));
 	if (!adapter->uc_list)
 		return -ENOMEM;
 

drivers/net/ethernet/freescale/dpaa2/dpaa2-switch.c

···
 	if (err)
 		goto err_free_cmdport;
 
-	ethsw->ports = kzalloc_objs(*ethsw->ports, ethsw->sw_attr.num_ifs,
-				    GFP_KERNEL);
+	ethsw->ports = kzalloc_objs(*ethsw->ports, ethsw->sw_attr.num_ifs);
 	if (!(ethsw->ports)) {
 		err = -ENOMEM;
 		goto err_teardown;
 	}
 
-	ethsw->fdbs = kzalloc_objs(*ethsw->fdbs, ethsw->sw_attr.num_ifs,
-				   GFP_KERNEL);
+	ethsw->fdbs = kzalloc_objs(*ethsw->fdbs, ethsw->sw_attr.num_ifs);
 	if (!ethsw->fdbs) {
 		err = -ENOMEM;
 		goto err_free_ports;

drivers/net/ethernet/freescale/enetc/enetc.c

···
 {
 	struct enetc_si *si = priv->si;
 
-	priv->cls_rules = kzalloc_objs(*priv->cls_rules, si->num_fs_entries,
-				       GFP_KERNEL);
+	priv->cls_rules = kzalloc_objs(*priv->cls_rules, si->num_fs_entries);
 	if (!priv->cls_rules)
 		return -ENOMEM;
 

drivers/net/ethernet/freescale/gianfar.c

···
 	int i;
 
 	for (i = 0; i < priv->num_tx_queues; i++) {
-		priv->tx_queue[i] = kzalloc_obj(struct gfar_priv_tx_q,
-						GFP_KERNEL);
+		priv->tx_queue[i] = kzalloc_obj(struct gfar_priv_tx_q);
 		if (!priv->tx_queue[i])
 			return -ENOMEM;
 
···
 	int i;
 
 	for (i = 0; i < priv->num_rx_queues; i++) {
-		priv->rx_queue[i] = kzalloc_obj(struct gfar_priv_rx_q,
-						GFP_KERNEL);
+		priv->rx_queue[i] = kzalloc_obj(struct gfar_priv_rx_q);
 		if (!priv->rx_queue[i])
 			return -ENOMEM;
 

drivers/net/ethernet/google/gve/gve_ethtool.c

···
 	priv = netdev_priv(netdev);
 	num_tx_queues = gve_num_tx_queues(priv);
 	report_stats = priv->stats_report->stats;
-	rx_qid_to_stats_idx = kmalloc_objs(int, priv->rx_cfg.num_queues,
-					   GFP_KERNEL);
+	rx_qid_to_stats_idx = kmalloc_objs(int, priv->rx_cfg.num_queues);
 	if (!rx_qid_to_stats_idx)
 		return;
 	for (ring = 0; ring < priv->rx_cfg.num_queues; ring++) {

drivers/net/ethernet/google/gve/gve_main.c

···
 	}
 
 	if (!gve_is_gqi(priv)) {
-		priv->ptype_lut_dqo = kvzalloc_obj(*priv->ptype_lut_dqo,
-						   GFP_KERNEL);
+		priv->ptype_lut_dqo = kvzalloc_obj(*priv->ptype_lut_dqo);
 		if (!priv->ptype_lut_dqo) {
 			err = -ENOMEM;
 			goto abort_with_stats_report;

drivers/net/ethernet/google/gve/gve_rx.c

···
 	int err = 0;
 	int i, j;
 
-	rx = kvzalloc_objs(struct gve_rx_ring, cfg->qcfg_rx->max_queues,
-			   GFP_KERNEL);
+	rx = kvzalloc_objs(struct gve_rx_ring, cfg->qcfg_rx->max_queues);
 	if (!rx)
 		return -ENOMEM;
 

drivers/net/ethernet/google/gve/gve_rx_dqo.c

···
 	int err;
 	int i;
 
-	rx = kvzalloc_objs(struct gve_rx_ring, cfg->qcfg_rx->max_queues,
-			   GFP_KERNEL);
+	rx = kvzalloc_objs(struct gve_rx_ring, cfg->qcfg_rx->max_queues);
 	if (!rx)
 		return -ENOMEM;
 

drivers/net/ethernet/google/gve/gve_tx.c

···
 		return -EINVAL;
 	}
 
-	tx = kvzalloc_objs(struct gve_tx_ring, cfg->qcfg->max_queues,
-			   GFP_KERNEL);
+	tx = kvzalloc_objs(struct gve_tx_ring, cfg->qcfg->max_queues);
 	if (!tx)
 		return -ENOMEM;
 

drivers/net/ethernet/google/gve/gve_tx_dqo.c

···
 		return -EINVAL;
 	}
 
-	tx = kvzalloc_objs(struct gve_tx_ring, cfg->qcfg->max_queues,
-			   GFP_KERNEL);
+	tx = kvzalloc_objs(struct gve_tx_ring, cfg->qcfg->max_queues);
 	if (!tx)
 		return -ENOMEM;
 

drivers/net/ethernet/hisilicon/hns/hnae.c

···
 	assert(ring->next_to_use == 0);
 	assert(ring->next_to_clean == 0);
 
-	ring->desc_cb = kzalloc_objs(ring->desc_cb[0], ring->desc_num,
-				     GFP_KERNEL);
+	ring->desc_cb = kzalloc_objs(ring->desc_cb[0], ring->desc_num);
 	if (!ring->desc_cb) {
 		ret = -ENOMEM;
 		goto out;

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

···
 
 	spin_lock_init(&cmdq->cmdq_lock);
 
-	cmdq->cmd_infos = kzalloc_objs(*cmdq->cmd_infos, cmdq->wq.q_depth,
-				       GFP_KERNEL);
+	cmdq->cmd_infos = kzalloc_objs(*cmdq->cmd_infos, cmdq->wq.q_depth);
 	if (!cmdq->cmd_infos) {
 		err = -ENOMEM;
 		return err;

drivers/net/ethernet/huawei/hinic3/hinic3_netdev_ops.c

···
 		goto err_free_txqs_res_arr;
 	}
 
-	q_params->irq_cfg = kzalloc_objs(*q_params->irq_cfg, q_params->num_qps,
-					 GFP_KERNEL);
+	q_params->irq_cfg = kzalloc_objs(*q_params->irq_cfg, q_params->num_qps);
 	if (!q_params->irq_cfg) {
 		err = -ENOMEM;
 		goto err_free_rxqs_res_arr;

drivers/net/ethernet/huawei/hinic3/hinic3_queue_common.c

···
 	u32 pg_idx;
 	int err;
 
-	qpages->pages = kzalloc_objs(qpages->pages[0], qpages->num_pages,
-				     GFP_KERNEL);
+	qpages->pages = kzalloc_objs(qpages->pages[0], qpages->num_pages);
 	if (!qpages->pages)
 		return -ENOMEM;
 

drivers/net/ethernet/huawei/hinic3/hinic3_rx.c

···
 
 	for (idx = 0; idx < num_rq; idx++) {
 		rqres = &rxqs_res[idx];
-		rqres->rx_info = kzalloc_objs(*rqres->rx_info, rq_depth,
-					      GFP_KERNEL);
+		rqres->rx_info = kzalloc_objs(*rqres->rx_info, rq_depth);
 		if (!rqres->rx_info)
 			goto err_free_rqres;
 

drivers/net/ethernet/huawei/hinic3/hinic3_tx.c

···
 	for (idx = 0; idx < num_sq; idx++) {
 		tqres = &txqs_res[idx];
 
-		tqres->tx_info = kzalloc_objs(*tqres->tx_info, sq_depth,
-					      GFP_KERNEL);
+		tqres->tx_info = kzalloc_objs(*tqres->tx_info, sq_depth);
 		if (!tqres->tx_info)
 			goto err_free_tqres;
 

drivers/net/ethernet/ibm/ibmvnic.c

···
 	/* Allocate/populate the pools. */
 	release_rx_pools(adapter);
 
-	adapter->rx_pool = kzalloc_objs(struct ibmvnic_rx_pool, num_pools,
-					GFP_KERNEL);
+	adapter->rx_pool = kzalloc_objs(struct ibmvnic_rx_pool, num_pools);
 	if (!adapter->rx_pool) {
 		dev_err(dev, "Failed to allocate rx pools\n");
 		return -ENOMEM;
···
 {
 	int i;
 
-	tx_pool->tx_buff = kzalloc_objs(struct ibmvnic_tx_buff, pool_size,
-					GFP_KERNEL);
+	tx_pool->tx_buff = kzalloc_objs(struct ibmvnic_tx_buff, pool_size);
 	if (!tx_pool->tx_buff)
 		return -ENOMEM;
 
···
 	pool_size = adapter->req_tx_entries_per_subcrq;
 	num_pools = adapter->num_active_tx_scrqs;
 
-	adapter->tx_pool = kzalloc_objs(struct ibmvnic_tx_pool, num_pools,
-					GFP_KERNEL);
+	adapter->tx_pool = kzalloc_objs(struct ibmvnic_tx_pool, num_pools);
 	if (!adapter->tx_pool)
 		return -ENOMEM;
 
-	adapter->tso_pool = kzalloc_objs(struct ibmvnic_tx_pool, num_pools,
-					 GFP_KERNEL);
+	adapter->tso_pool = kzalloc_objs(struct ibmvnic_tx_pool, num_pools);
 	/* To simplify release_tx_pools() ensure that ->tx_pool and
 	 * ->tso_pool are either both NULL or both non-NULL.
 	 */
···
 {
 	int i;
 
-	adapter->napi = kzalloc_objs(struct napi_struct, adapter->req_rx_queues,
-				     GFP_KERNEL);
+	adapter->napi = kzalloc_objs(struct napi_struct, adapter->req_rx_queues);
 	if (!adapter->napi)
 		return -ENOMEM;
 

drivers/net/ethernet/intel/e1000/e1000_ethtool.c

···
 	rx_old = adapter->rx_ring;
 
 	err = -ENOMEM;
-	txdr = kzalloc_objs(struct e1000_tx_ring, adapter->num_tx_queues,
-			    GFP_KERNEL);
+	txdr = kzalloc_objs(struct e1000_tx_ring, adapter->num_tx_queues);
 	if (!txdr)
 		goto err_alloc_tx;
 
-	rxdr = kzalloc_objs(struct e1000_rx_ring, adapter->num_rx_queues,
-			    GFP_KERNEL);
+	rxdr = kzalloc_objs(struct e1000_rx_ring, adapter->num_rx_queues);
 	if (!rxdr)
 		goto err_alloc_rx;
 
···
 	if (!txdr->count)
 		txdr->count = E1000_DEFAULT_TXD;
 
-	txdr->buffer_info = kzalloc_objs(struct e1000_tx_buffer, txdr->count,
-					 GFP_KERNEL);
+	txdr->buffer_info = kzalloc_objs(struct e1000_tx_buffer, txdr->count);
 	if (!txdr->buffer_info) {
 		ret_val = 1;
 		goto err_nomem;
···
 	if (!rxdr->count)
 		rxdr->count = E1000_DEFAULT_RXD;
 
-	rxdr->buffer_info = kzalloc_objs(struct e1000_rx_buffer, rxdr->count,
-					 GFP_KERNEL);
+	rxdr->buffer_info = kzalloc_objs(struct e1000_rx_buffer, rxdr->count);
 	if (!rxdr->buffer_info) {
 		ret_val = 5;
 		goto err_nomem;

drivers/net/ethernet/intel/e1000e/ethtool.c

···
 	if (!tx_ring->count)
 		tx_ring->count = E1000_DEFAULT_TXD;
 
-	tx_ring->buffer_info = kzalloc_objs(struct e1000_buffer, tx_ring->count,
-					    GFP_KERNEL);
+	tx_ring->buffer_info = kzalloc_objs(struct e1000_buffer, tx_ring->count);
 	if (!tx_ring->buffer_info) {
 		ret_val = 1;
 		goto err_nomem;
···
 	if (!rx_ring->count)
 		rx_ring->count = E1000_DEFAULT_RXD;
 
-	rx_ring->buffer_info = kzalloc_objs(struct e1000_buffer, rx_ring->count,
-					    GFP_KERNEL);
+	rx_ring->buffer_info = kzalloc_objs(struct e1000_buffer, rx_ring->count);
 	if (!rx_ring->buffer_info) {
 		ret_val = 5;
 		goto err_nomem;

drivers/net/ethernet/intel/fm10k/fm10k_main.c

···
 	v_budget = min_t(int, v_budget, hw->mac.max_msix_vectors);
 
 	/* A failure in MSI-X entry allocation is fatal. */
-	interface->msix_entries = kzalloc_objs(struct msix_entry, v_budget,
-					       GFP_KERNEL);
+	interface->msix_entries = kzalloc_objs(struct msix_entry, v_budget);
 	if (!interface->msix_entries)
 		return -ENOMEM;
 

drivers/net/ethernet/intel/i40e/i40e_debugfs.c

···
 			int i, ret;
 			u16 switch_id;
 
-			bw_data = kzalloc_obj(struct i40e_aqc_query_port_ets_config_resp,
-					      GFP_KERNEL);
+			bw_data = kzalloc_obj(struct i40e_aqc_query_port_ets_config_resp);
 			if (!bw_data) {
 				ret = -ENOMEM;
 				goto command_write_done;

drivers/net/ethernet/intel/i40e/i40e_ethtool.c

···
 		netdev_info(netdev,
 			    "Changing Tx descriptor count from %d to %d.\n",
 			    vsi->tx_rings[0]->count, new_tx_count);
-		tx_rings = kzalloc_objs(struct i40e_ring, tx_alloc_queue_pairs,
-					GFP_KERNEL);
+		tx_rings = kzalloc_objs(struct i40e_ring, tx_alloc_queue_pairs);
 		if (!tx_rings) {
 			err = -ENOMEM;
 			goto done;

drivers/net/ethernet/intel/iavf/iavf_main.c

···
 					  (int)(num_online_cpus()));
 
 
-	adapter->tx_rings = kzalloc_objs(struct iavf_ring, num_active_queues,
-					 GFP_KERNEL);
+	adapter->tx_rings = kzalloc_objs(struct iavf_ring, num_active_queues);
 	if (!adapter->tx_rings)
 		goto err_out;
-	adapter->rx_rings = kzalloc_objs(struct iavf_ring, num_active_queues,
-					 GFP_KERNEL);
+	adapter->rx_rings = kzalloc_objs(struct iavf_ring, num_active_queues);
 	if (!adapter->rx_rings)
 		goto err_out;
 
···
 	v_budget = min_t(int, pairs + NONQ_VECS,
 			 (int)adapter->vf_res->max_vectors);
 
-	adapter->msix_entries = kzalloc_objs(struct msix_entry, v_budget,
-					     GFP_KERNEL);
+	adapter->msix_entries = kzalloc_objs(struct msix_entry, v_budget);
 	if (!adapter->msix_entries) {
 		err = -ENOMEM;
 		goto out;

drivers/net/ethernet/intel/ice/ice_arfs.c

···
 	if (!vsi->arfs_fltr_cntrs)
 		return -ENOMEM;
 
-	vsi->arfs_last_fltr_id = kzalloc_obj(*vsi->arfs_last_fltr_id,
-					     GFP_KERNEL);
+	vsi->arfs_last_fltr_id = kzalloc_obj(*vsi->arfs_last_fltr_id);
 	if (!vsi->arfs_last_fltr_id) {
 		kfree(vsi->arfs_fltr_cntrs);
 		vsi->arfs_fltr_cntrs = NULL;
···
 	if (!vsi || vsi->type != ICE_VSI_PF || ice_is_arfs_active(vsi))
 		return;
 
-	arfs_fltr_list = kzalloc_objs(*arfs_fltr_list, ICE_MAX_ARFS_LIST,
-				      GFP_KERNEL);
+	arfs_fltr_list = kzalloc_objs(*arfs_fltr_list, ICE_MAX_ARFS_LIST);
 	if (!arfs_fltr_list)
 		return;
 

drivers/net/ethernet/intel/ice/ice_common.c

···
 
 	/* Get MAC information */
 	/* A single port can report up to two (LAN and WoL) addresses */
-	mac_buf = kzalloc_objs(struct ice_aqc_manage_mac_read_resp, 2,
-			       GFP_KERNEL);
+	mac_buf = kzalloc_objs(struct ice_aqc_manage_mac_read_resp, 2);
 	if (!mac_buf) {
 		status = -ENOMEM;
 		goto err_unroll_fltr_mgmt_struct;

drivers/net/ethernet/intel/ice/ice_lib.c

···
 		return -ENOMEM;
 
 	vsi_stat->tx_ring_stats =
-		kzalloc_objs(*vsi_stat->tx_ring_stats, vsi->alloc_txq,
-			     GFP_KERNEL);
+		kzalloc_objs(*vsi_stat->tx_ring_stats, vsi->alloc_txq);
 	if (!vsi_stat->tx_ring_stats)
 		goto err_alloc_tx;
 
 	vsi_stat->rx_ring_stats =
-		kzalloc_objs(*vsi_stat->rx_ring_stats, vsi->alloc_rxq,
-			     GFP_KERNEL);
+		kzalloc_objs(*vsi_stat->rx_ring_stats, vsi->alloc_rxq);
 	if (!vsi_stat->rx_ring_stats)
 		goto err_alloc_rx;
 
···
 	if (ret)
 		goto unlock;
 
-	coalesce = kzalloc_objs(struct ice_coalesce_stored, vsi->num_q_vectors,
-				GFP_KERNEL);
+	coalesce = kzalloc_objs(struct ice_coalesce_stored, vsi->num_q_vectors);
 	if (!coalesce) {
 		ret = -ENOMEM;
 		goto decfg;

drivers/net/ethernet/intel/idpf/idpf_controlq.c

···
 		idpf_ctlq_init_rxq_bufs(cq);
 	} else {
 		/* Allocate the array of msg pointers for TX queues */
-		cq->bi.tx_msg = kzalloc_objs(struct idpf_ctlq_msg *, qinfo->len,
-					     GFP_KERNEL);
+		cq->bi.tx_msg = kzalloc_objs(struct idpf_ctlq_msg *, qinfo->len);
 		if (!cq->bi.tx_msg) {
 			err = -ENOMEM;
 			goto init_dealloc_q_mem;

drivers/net/ethernet/intel/idpf/idpf_controlq_setup.c

···
 	/* We'll be allocating the buffer info memory first, then we can
 	 * allocate the mapped buffers for the event processing
 	 */
-	cq->bi.rx_buff = kzalloc_objs(struct idpf_dma_mem *, cq->ring_size,
-				      GFP_KERNEL);
+	cq->bi.rx_buff = kzalloc_objs(struct idpf_dma_mem *, cq->ring_size);
 	if (!cq->bi.rx_buff)
 		return -ENOMEM;
 
···
 		struct idpf_dma_mem *bi;
 		int num = 1; /* number of idpf_dma_mem to be allocated */
 
-		cq->bi.rx_buff[i] = kzalloc_objs(struct idpf_dma_mem, num,
-						 GFP_KERNEL);
+		cq->bi.rx_buff[i] = kzalloc_objs(struct idpf_dma_mem, num);
 		if (!cq->bi.rx_buff[i])
 			goto unwind_alloc_cq_bufs;
 

drivers/net/ethernet/intel/idpf/idpf_lib.c

···
 	}
 
 	num_lan_vecs = actual_vecs - num_rdma_vecs;
-	adapter->msix_entries = kzalloc_objs(struct msix_entry, num_lan_vecs,
-					     GFP_KERNEL);
+	adapter->msix_entries = kzalloc_objs(struct msix_entry, num_lan_vecs);
 	if (!adapter->msix_entries) {
 		err = -ENOMEM;
 		goto free_rdma_msix;

drivers/net/ethernet/intel/idpf/idpf_txrx.c

···
 		tx_q->buf_pool_size = U16_MAX;
 	else
 		tx_q->buf_pool_size = tx_q->desc_count;
-	tx_q->tx_buf = kzalloc_objs(*tx_q->tx_buf, tx_q->buf_pool_size,
-				    GFP_KERNEL);
+	tx_q->tx_buf = kzalloc_objs(*tx_q->tx_buf, tx_q->buf_pool_size);
 	if (!tx_q->tx_buf)
 		return -ENOMEM;
 
···
 {
 	bool split, flow_sch_en;
 
-	rsrc->txq_grps = kzalloc_objs(*rsrc->txq_grps, rsrc->num_txq_grp,
-				      GFP_KERNEL);
+	rsrc->txq_grps = kzalloc_objs(*rsrc->txq_grps, rsrc->num_txq_grp);
 	if (!rsrc->txq_grps)
 		return -ENOMEM;
 
···
 		tx_qgrp->num_txq = num_txq;
 
 		for (unsigned int j = 0; j < tx_qgrp->num_txq; j++) {
-			tx_qgrp->txqs[j] = kzalloc_obj(*tx_qgrp->txqs[j],
-						       GFP_KERNEL);
+			tx_qgrp->txqs[j] = kzalloc_obj(*tx_qgrp->txqs[j]);
 			if (!tx_qgrp->txqs[j])
 				goto err_alloc;
 		}
···
 	bool hs, rsc;
 	int err = 0;
 
-	rsrc->rxq_grps = kzalloc_objs(struct idpf_rxq_group, rsrc->num_rxq_grp,
-				      GFP_KERNEL);
+	rsrc->rxq_grps = kzalloc_objs(struct idpf_rxq_group, rsrc->num_rxq_grp);
 	if (!rsrc->rxq_grps)
 		return -ENOMEM;
 
···
 		if (!idpf_is_queue_model_split(rsrc->rxq_model)) {
 			rx_qgrp->singleq.num_rxq = num_rxq;
 			for (unsigned int j = 0; j < num_rxq; j++) {
-				rx_qgrp->singleq.rxqs[j] = kzalloc_obj(*rx_qgrp->singleq.rxqs[j],
-								       GFP_KERNEL);
+				rx_qgrp->singleq.rxqs[j] = kzalloc_obj(*rx_qgrp->singleq.rxqs[j]);
 				if (!rx_qgrp->singleq.rxqs[j]) {
 					err = -ENOMEM;
 					goto err_alloc;
···
 		q_vector->rx_intr_mode = q_coal->rx_intr_mode;
 		q_vector->rx_itr_idx = VIRTCHNL2_ITR_IDX_0;
 
-		q_vector->tx = kzalloc_objs(*q_vector->tx, txqs_per_vector,
-					    GFP_KERNEL);
+		q_vector->tx = kzalloc_objs(*q_vector->tx, txqs_per_vector);
 		if (!q_vector->tx)
 			goto error;
 
-		q_vector->rx = kzalloc_objs(*q_vector->rx, rxqs_per_vector,
-					    GFP_KERNEL);
+		q_vector->rx = kzalloc_objs(*q_vector->rx, rxqs_per_vector);
 		if (!q_vector->rx)
 			goto error;
 
 		if (!idpf_is_queue_model_split(rsrc->rxq_model))
 			continue;
 
-		q_vector->bufq = kzalloc_objs(*q_vector->bufq, bufqs_per_vector,
-					      GFP_KERNEL);
+		q_vector->bufq = kzalloc_objs(*q_vector->bufq, bufqs_per_vector);
 		if (!q_vector->bufq)
 			goto error;
 

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

···
 
 	kfree(q_info->queue_chunks);
 
-	q_info->queue_chunks = kzalloc_objs(*q_info->queue_chunks, num_chunks,
-					    GFP_KERNEL);
+	q_info->queue_chunks = kzalloc_objs(*q_info->queue_chunks, num_chunks);
 	if (!q_info->queue_chunks) {
 		q_info->num_chunks = 0;
 		return -ENOMEM;
···
 	u16 next_ptype_id = 0;
 	ssize_t reply_sz;
 
-	singleq_pt_lkup = kzalloc_objs(*singleq_pt_lkup, IDPF_RX_MAX_BASE_PTYPE,
-				       GFP_KERNEL);
+	singleq_pt_lkup = kzalloc_objs(*singleq_pt_lkup, IDPF_RX_MAX_BASE_PTYPE);
 	if (!singleq_pt_lkup)
 		return -ENOMEM;
 
···
 	int err = 0;
 
 	if (!adapter->vcxn_mngr) {
-		adapter->vcxn_mngr = kzalloc_obj(*adapter->vcxn_mngr,
-						 GFP_KERNEL);
+		adapter->vcxn_mngr = kzalloc_obj(*adapter->vcxn_mngr);
 		if (!adapter->vcxn_mngr) {
 			err = -ENOMEM;
 			goto init_failed;
···
 	pci_sriov_set_totalvfs(adapter->pdev, idpf_get_max_vfs(adapter));
 	num_max_vports = idpf_get_max_vports(adapter);
 	adapter->max_vports = num_max_vports;
-	adapter->vports = kzalloc_objs(*adapter->vports, num_max_vports,
-				       GFP_KERNEL);
+	adapter->vports = kzalloc_objs(*adapter->vports, num_max_vports);
 	if (!adapter->vports)
 		return -ENOMEM;
 

drivers/net/ethernet/intel/idpf/idpf_virtchnl_ptp.c

···
 	u32 temp_offset;
 	int reply_sz;
 
-	recv_ptp_caps_msg = kzalloc_obj(struct virtchnl2_ptp_get_caps,
-					GFP_KERNEL);
+	recv_ptp_caps_msg = kzalloc_obj(struct virtchnl2_ptp_get_caps);
 	if (!recv_ptp_caps_msg)
 		return -ENOMEM;
 

drivers/net/ethernet/intel/igc/igc_main.c

···
 	/* add 1 vector for link status interrupts */
 	numvecs++;
 
-	adapter->msix_entries = kzalloc_objs(struct msix_entry, numvecs,
-				             GFP_KERNEL);
+	adapter->msix_entries = kzalloc_objs(struct msix_entry, numvecs);
 
 	if (!adapter->msix_entries)
 		return;

drivers/net/ethernet/intel/ixgbe/ixgbe_dcb_nl.c

···
 		return -EINVAL;
 
 	if (!adapter->ixgbe_ieee_ets) {
-		adapter->ixgbe_ieee_ets = kmalloc_obj(struct ieee_ets,
-						      GFP_KERNEL);
+		adapter->ixgbe_ieee_ets = kmalloc_obj(struct ieee_ets);
 		if (!adapter->ixgbe_ieee_ets)
 			return -ENOMEM;
 
···
 		return -EINVAL;
 
 	if (!adapter->ixgbe_ieee_pfc) {
-		adapter->ixgbe_ieee_pfc = kmalloc_obj(struct ieee_pfc,
-						      GFP_KERNEL);
+		adapter->ixgbe_ieee_pfc = kmalloc_obj(struct ieee_pfc);
 		if (!adapter->ixgbe_ieee_pfc)
 			return -ENOMEM;
 	}

drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c

···
 	 */
 	vector_threshold = MIN_MSIX_COUNT;
 
-	adapter->msix_entries = kzalloc_objs(struct msix_entry, vectors,
-					     GFP_KERNEL);
+	adapter->msix_entries = kzalloc_objs(struct msix_entry, vectors);
 	if (!adapter->msix_entries)
 		return -ENOMEM;
 

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

···
 #endif /* IXGBE_FCOE */
 
 	/* initialize static ixgbe jump table entries */
-	adapter->jump_tables[0] = kzalloc_obj(*adapter->jump_tables[0],
-					      GFP_KERNEL);
+	adapter->jump_tables[0] = kzalloc_obj(*adapter->jump_tables[0]);
 	if (!adapter->jump_tables[0])
 		return -ENOMEM;
 	adapter->jump_tables[0]->mat = ixgbe_ipv4_fields;

drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c

···
 			  IXGBE_FLAG_VMDQ_ENABLED;
 
 	/* Allocate memory for per VF control structures */
-	adapter->vfinfo = kzalloc_objs(struct vf_data_storage, num_vfs,
-				       GFP_KERNEL);
+	adapter->vfinfo = kzalloc_objs(struct vf_data_storage, num_vfs);
 	if (!adapter->vfinfo)
 		return -ENOMEM;
 

drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c

···
 	v_budget = min_t(int, v_budget, num_online_cpus());
 	v_budget += NON_Q_VECTORS;
 
-	adapter->msix_entries = kzalloc_objs(struct msix_entry, v_budget,
-					     GFP_KERNEL);
+	adapter->msix_entries = kzalloc_objs(struct msix_entry, v_budget);
 	if (!adapter->msix_entries)
 		return -ENOMEM;
 

drivers/net/ethernet/intel/libie/fwlog.c

···
 	/* allocate space for this first because if it fails then we don't
 	 * need to unwind
 	 */
-	fw_modules = kzalloc_objs(*fw_modules, LIBIE_NR_FW_LOG_MODULES,
-				  GFP_KERNEL);
+	fw_modules = kzalloc_objs(*fw_modules, LIBIE_NR_FW_LOG_MODULES);
 	if (!fw_modules)
 		return;
 

drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c

···
 	for (thread = 0; thread < port->priv->nthreads; thread++) {
 		txq_pcpu = per_cpu_ptr(txq->pcpu, thread);
 		txq_pcpu->size = txq->size;
-		txq_pcpu->buffs = kmalloc_objs(*txq_pcpu->buffs, txq_pcpu->size,
-					       GFP_KERNEL);
+		txq_pcpu->buffs = kmalloc_objs(*txq_pcpu->buffs, txq_pcpu->size);
 		if (!txq_pcpu->buffs)
 			return -ENOMEM;
 

drivers/net/ethernet/marvell/octeon_ep/octep_main.c

···
 
 	/* Generic interrupts apart from input/output queues */
 	num_msix = oct->num_oqs + CFG_GET_NON_IOQ_MSIX(oct->conf);
-	oct->msix_entries = kzalloc_objs(struct msix_entry, num_msix,
-					 GFP_KERNEL);
+	oct->msix_entries = kzalloc_objs(struct msix_entry, num_msix);
 	if (!oct->msix_entries)
 		goto msix_alloc_err;
 

drivers/net/ethernet/marvell/octeon_ep_vf/octep_vf_main.c

···
 	/* Generic interrupts apart from input/output queues */
 	//num_msix = oct->num_oqs + CFG_GET_NON_IOQ_MSIX(oct->conf);
 	num_msix = oct->num_oqs;
-	oct->msix_entries = kzalloc_objs(struct msix_entry, num_msix,
-					 GFP_KERNEL);
+	oct->msix_entries = kzalloc_objs(struct msix_entry, num_msix);
 	if (!oct->msix_entries)
 		goto msix_alloc_err;
 

drivers/net/ethernet/marvell/octeontx2/nic/otx2_pf.c

···
 	/* CQ size of SQ */
 	qset->sqe_cnt = qset->sqe_cnt ? qset->sqe_cnt : Q_COUNT(Q_SIZE_4K);
 
-	qset->cq = kzalloc_objs(struct otx2_cq_queue, pf->qset.cq_cnt,
-				GFP_KERNEL);
+	qset->cq = kzalloc_objs(struct otx2_cq_queue, pf->qset.cq_cnt);
 	if (!qset->cq)
 		goto err_free_mem;
 
···
 	if (!qset->sq)
 		goto err_free_mem;
 
-	qset->rq = kzalloc_objs(struct otx2_rcv_queue, pf->hw.rx_queues,
-				GFP_KERNEL);
+	qset->rq = kzalloc_objs(struct otx2_rcv_queue, pf->hw.rx_queues);
 	if (!qset->rq)
 		goto err_free_mem;
 

drivers/net/ethernet/marvell/prestera/prestera_counter.c

···
 	if (err)
 		goto err_block;
 
-	block->stats = kzalloc_objs(*block->stats, block->num_counters,
-				    GFP_KERNEL);
+	block->stats = kzalloc_objs(*block->stats, block->num_counters);
 	if (!block->stats) {
 		err = -ENOMEM;
 		goto err_stats;

drivers/net/ethernet/marvell/sky2.c

···
 	if (!sky2->tx_le)
 		goto nomem;
 
-	sky2->tx_ring = kzalloc_objs(struct tx_ring_info, sky2->tx_ring_size,
-				     GFP_KERNEL);
+	sky2->tx_ring = kzalloc_objs(struct tx_ring_info, sky2->tx_ring_size);
 	if (!sky2->tx_ring)
 		goto nomem;
 
···
 	if (!sky2->rx_le)
 		goto nomem;
 
-	sky2->rx_ring = kzalloc_objs(struct rx_ring_info, sky2->rx_pending,
-				     GFP_KERNEL);
+	sky2->rx_ring = kzalloc_objs(struct rx_ring_info, sky2->rx_pending);
 	if (!sky2->rx_ring)
 		goto nomem;
 

drivers/net/ethernet/mellanox/mlx4/alloc.c

···
 		buf->nbufs      = DIV_ROUND_UP(size, PAGE_SIZE);
 		buf->npages	= buf->nbufs;
 		buf->page_shift  = PAGE_SHIFT;
-		buf->page_list   = kzalloc_objs(*buf->page_list, buf->nbufs,
-						GFP_KERNEL);
+		buf->page_list   = kzalloc_objs(*buf->page_list, buf->nbufs);
 		if (!buf->page_list)
 			return -ENOMEM;
 

drivers/net/ethernet/mellanox/mlx4/cmd.c

···
 		struct mlx4_vf_admin_state *vf_admin;
 
 		priv->mfunc.master.slave_state =
-			kzalloc_objs(struct mlx4_slave_state, dev->num_slaves,
-				     GFP_KERNEL);
+			kzalloc_objs(struct mlx4_slave_state, dev->num_slaves);
 		if (!priv->mfunc.master.slave_state)
 			goto err_comm;
 
···
 			goto err_comm_admin;
 
 		priv->mfunc.master.vf_oper =
-			kzalloc_objs(struct mlx4_vf_oper_state, dev->num_slaves,
-				     GFP_KERNEL);
+			kzalloc_objs(struct mlx4_vf_oper_state, dev->num_slaves);
 		if (!priv->mfunc.master.vf_oper)
 			goto err_comm_oper;
 
···
 				struct mlx4_vport_state *oper_vport;
 
 				s_state->vlan_filter[port] =
-					kzalloc_obj(struct mlx4_vlan_fltr,
-						    GFP_KERNEL);
+					kzalloc_obj(struct mlx4_vlan_fltr);
 				if (!s_state->vlan_filter[port]) {
 					if (--port)
 						kfree(s_state->vlan_filter[port]);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

···
 		if (!dst->tx_ring[t])
 			goto err_free_tx;
 
-		dst->tx_cq[t] = kzalloc_objs(struct mlx4_en_cq *, MAX_TX_RINGS,
-					     GFP_KERNEL);
+		dst->tx_cq[t] = kzalloc_objs(struct mlx4_en_cq *, MAX_TX_RINGS);
 		if (!dst->tx_cq[t]) {
 			kfree(dst->tx_ring[t]);
 			goto err_free_tx;
···
 			err = -ENOMEM;
 			goto out;
 		}
-		priv->tx_cq[t] = kzalloc_objs(struct mlx4_en_cq *, MAX_TX_RINGS,
-					      GFP_KERNEL);
+		priv->tx_cq[t] = kzalloc_objs(struct mlx4_en_cq *, MAX_TX_RINGS);
 		if (!priv->tx_cq[t]) {
 			err = -ENOMEM;
 			goto out;

drivers/net/ethernet/mellanox/mlx4/main.c

···
 	int i, err = 0;
 
 	func_cap = kzalloc_obj(*func_cap);
-	caps->spec_qps = kzalloc_objs(*caps->spec_qps, caps->num_ports,
-				      GFP_KERNEL);
+	caps->spec_qps = kzalloc_objs(*caps->spec_qps, caps->num_ports);
 
 	if (!func_cap || !caps->spec_qps) {
 		mlx4_err(dev, "Failed to allocate memory for special qps cap\n");
···
 					MLX4_MAX_NUM_VF);
 
 	if (reset_flow) {
-		dev->dev_vfs = kzalloc_objs(*dev->dev_vfs, total_vfs,
-					    GFP_KERNEL);
+		dev->dev_vfs = kzalloc_objs(*dev->dev_vfs, total_vfs);
 		if (!dev->dev_vfs)
 			goto free_mem;
 		return dev_flags;

drivers/net/ethernet/mellanox/mlx4/resource_tracker.c

···
 	for (i = 0; i < MLX4_NUM_OF_RESOURCE_TYPE; i++) {
 		struct resource_allocator *res_alloc =
 			&priv->mfunc.master.res_tracker.res_alloc[i];
-		res_alloc->quota = kmalloc_objs(int, dev->persist->num_vfs + 1,
-						GFP_KERNEL);
+		res_alloc->quota = kmalloc_objs(int, dev->persist->num_vfs + 1);
 		res_alloc->guaranteed = kmalloc_objs(int,
 						     dev->persist->num_vfs + 1,
 						     GFP_KERNEL);
···
 					     GFP_KERNEL);
 		else
 			res_alloc->allocated =
-				kzalloc_objs(int, dev->persist->num_vfs + 1,
-					     GFP_KERNEL);
+				kzalloc_objs(int, dev->persist->num_vfs + 1);
 		/* Reduce the sink counter */
 		if (i == RES_COUNTER)
 			res_alloc->res_free = dev->caps.max_counters - 1;
···
 
 	memset(data, 0, sizeof(*data));
 
-	counters_arr = kmalloc_objs(*counters_arr, dev->caps.max_counters,
-				    GFP_KERNEL);
+	counters_arr = kmalloc_objs(*counters_arr, dev->caps.max_counters);
 	if (!counters_arr)
 		return -ENOMEM;
 
···
 		mlx4_warn(dev, "rem_slave_counters: Could not move all counters - too busy for slave %d\n",
 			  slave);
 
-	counters_arr = kmalloc_objs(*counters_arr, dev->caps.max_counters,
-				    GFP_KERNEL);
+	counters_arr = kmalloc_objs(*counters_arr, dev->caps.max_counters);
 	if (!counters_arr)
 		return;
 

drivers/net/ethernet/mellanox/mlx5/core/en/qos.c

···
 	for (i = 0; i < chs->num; i++) {
 		struct mlx5e_txqsq **sqs;
 
-		sqs = kvzalloc_objs(struct mlx5e_txqsq *, qos_sqs_size,
-				    GFP_KERNEL);
+		sqs = kvzalloc_objs(struct mlx5e_txqsq *, qos_sqs_size);
 		if (!sqs)
 			goto err_free;
 

drivers/net/ethernet/mellanox/mlx5/core/en/xsk/pool.c

···
 static int mlx5e_xsk_get_pools(struct mlx5e_xsk *xsk)
 {
 	if (!xsk->pools) {
-		xsk->pools = kzalloc_objs(*xsk->pools, MLX5E_MAX_NUM_CHANNELS,
-					  GFP_KERNEL);
+		xsk->pools = kzalloc_objs(*xsk->pools, MLX5E_MAX_NUM_CHANNELS);
 		if (unlikely(!xsk->pools))
 			return -ENOMEM;
 	}

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

···
 	if (!priv->channel_stats)
 		goto err_free_tx_rates;
 
-	priv->fec_ranges = kzalloc_objs(*priv->fec_ranges, ETHTOOL_FEC_HIST_MAX,
-					GFP_KERNEL);
+	priv->fec_ranges = kzalloc_objs(*priv->fec_ranges, ETHTOOL_FEC_HIST_MAX);
 	if (!priv->fec_ranges)
 		goto err_free_channel_stats;
 

drivers/net/ethernet/mellanox/mlx5/core/fpga/conn.c

···
 	if (err)
 		goto out;
 
-	conn->qp.rq.bufs = kvzalloc_objs(conn->qp.rq.bufs[0], conn->qp.rq.size,
-					 GFP_KERNEL);
+	conn->qp.rq.bufs = kvzalloc_objs(conn->qp.rq.bufs[0], conn->qp.rq.size);
 	if (!conn->qp.rq.bufs) {
 		err = -ENOMEM;
 		goto err_wq;
 	}
 
-	conn->qp.sq.bufs = kvzalloc_objs(conn->qp.sq.bufs[0], conn->qp.sq.size,
-					 GFP_KERNEL);
+	conn->qp.sq.bufs = kvzalloc_objs(conn->qp.sq.bufs[0], conn->qp.sq.size);
 	if (!conn->qp.sq.bufs) {
 		err = -ENOMEM;
 		goto err_rq_bufs;

drivers/net/ethernet/mellanox/mlx5/core/rl.c

···
 		return 0;
 	}
 
-	table->rl_entry = kzalloc_objs(struct mlx5_rl_entry, table->max_size,
-				       GFP_KERNEL);
+	table->rl_entry = kzalloc_objs(struct mlx5_rl_entry, table->max_size);
 	if (!table->rl_entry)
 		return -ENOMEM;
 

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/action.c

···
 		;
 
 	at->num_actions = num_actions - 1;
-	at->action_type_arr = kzalloc_objs(*action_type, num_actions,
-					   GFP_KERNEL);
+	at->action_type_arr = kzalloc_objs(*action_type, num_actions);
 	if (!at->action_type_arr)
 		goto free_at;
 

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/bwc.c

···
 	struct mlx5hws_matcher_attr attr = {0};
 	int i;
 
-	bwc_matcher->rules = kzalloc_objs(*bwc_matcher->rules, bwc_queues,
-					  GFP_KERNEL);
+	bwc_matcher->rules = kzalloc_objs(*bwc_matcher->rules, bwc_queues);
 	if (!bwc_matcher->rules)
 		goto err;
 

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/fs_hws.c

···
 	int num_actions = 0;
 	int err;
 
-	*ractions = kzalloc_objs(**ractions, MLX5_FLOW_CONTEXT_ACTION_MAX,
-				 GFP_KERNEL);
+	*ractions = kzalloc_objs(**ractions, MLX5_FLOW_CONTEXT_ACTION_MAX);
 	if (!*ractions) {
 		err = -ENOMEM;
 		goto out_err;
 	}
 
-	fs_actions = kzalloc_objs(*fs_actions, MLX5_FLOW_CONTEXT_ACTION_MAX,
-				  GFP_KERNEL);
+	fs_actions = kzalloc_objs(*fs_actions, MLX5_FLOW_CONTEXT_ACTION_MAX);
 	if (!fs_actions) {
 		err = -ENOMEM;
 		goto free_actions_alloc;
 	}
 
-	dest_actions = kzalloc_objs(*dest_actions, MLX5_FLOW_CONTEXT_ACTION_MAX,
-				    GFP_KERNEL);
+	dest_actions = kzalloc_objs(*dest_actions, MLX5_FLOW_CONTEXT_ACTION_MAX);
 	if (!dest_actions) {
 		err = -ENOMEM;
 		goto free_fs_actions_alloc;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/matcher.c

···
 
 	matcher->size_of_at_array =
 		num_of_at + matcher->attr.max_num_of_at_attach;
-	matcher->at = kvzalloc_objs(*matcher->at, matcher->size_of_at_array,
-				    GFP_KERNEL);
+	matcher->at = kvzalloc_objs(*matcher->at, matcher->size_of_at_array);
 	if (!matcher->at) {
 		mlx5hws_err(ctx, "Failed to allocate action template array\n");
 		ret = -ENOMEM;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/send.c

···
 	if (err)
 		return err;
 
-	ctx->send_queue = kzalloc_objs(*ctx->send_queue, ctx->queues,
-				       GFP_KERNEL);
+	ctx->send_queue = kzalloc_objs(*ctx->send_queue, ctx->queues);
 	if (!ctx->send_queue) {
 		err = -ENOMEM;
 		goto free_bwc_locks;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_buddy.c

···
 
 	INIT_LIST_HEAD(&buddy->list_node);
 
-	buddy->bitmap = kzalloc_objs(*buddy->bitmap, buddy->max_order + 1,
-				     GFP_KERNEL);
-	buddy->num_free = kzalloc_objs(*buddy->num_free, buddy->max_order + 1,
-				       GFP_KERNEL);
+	buddy->bitmap = kzalloc_objs(*buddy->bitmap, buddy->max_order + 1);
+	buddy->num_free = kzalloc_objs(*buddy->num_free, buddy->max_order + 1);
 
 	if (!buddy->bitmap || !buddy->num_free)
 		goto err_free_all;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

···
 	int num_of_entries =
 		mlx5dr_icm_pool_chunk_size_to_entries(buddy->pool->max_log_chunk_sz);
 
-	buddy->ste_arr = kvzalloc_objs(struct mlx5dr_ste, num_of_entries,
-				       GFP_KERNEL);
+	buddy->ste_arr = kvzalloc_objs(struct mlx5dr_ste, num_of_entries);
 	if (!buddy->ste_arr)
 		return -ENOMEM;
 

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

···
 	if (mlx5_fs_cmd_is_fw_term_table(ft))
 		return mlx5_fs_cmd_get_fw_cmds()->create_fte(ns, ft, group, fte);
 
-	actions = kzalloc_objs(*actions, MLX5_FLOW_CONTEXT_ACTION_MAX,
-			       GFP_KERNEL);
+	actions = kzalloc_objs(*actions, MLX5_FLOW_CONTEXT_ACTION_MAX);
 	if (!actions) {
 		err = -ENOMEM;
 		goto out_err;
···
 		goto free_actions_alloc;
 	}
 
-	term_actions = kzalloc_objs(*term_actions, MLX5_FLOW_CONTEXT_ACTION_MAX,
-				    GFP_KERNEL);
+	term_actions = kzalloc_objs(*term_actions, MLX5_FLOW_CONTEXT_ACTION_MAX);
 	if (!term_actions) {
 		err = -ENOMEM;
 		goto free_fs_dr_actions_alloc;

drivers/net/ethernet/mellanox/mlxsw/core_acl_flex_keys.c

···
 	struct mlxsw_afk_key_info *key_info;
 	int err;
 
-	key_info = kzalloc_flex(*key_info, blocks, mlxsw_afk->max_blocks,
-				GFP_KERNEL);
+	key_info = kzalloc_flex(*key_info, blocks, mlxsw_afk->max_blocks);
 	if (!key_info)
 		return ERR_PTR(-ENOMEM);
 	err = mlxsw_afk_picker(mlxsw_afk, key_info, elusage);

drivers/net/ethernet/mellanox/mlxsw/core_hwmon.c

···
 	mlxsw_reg_mgpir_unpack(mgpir_pl, NULL, NULL, NULL, NULL,
 			       &num_of_slots);
 
-	mlxsw_hwmon = kzalloc_flex(*mlxsw_hwmon, line_cards, num_of_slots + 1,
-				   GFP_KERNEL);
+	mlxsw_hwmon = kzalloc_flex(*mlxsw_hwmon, line_cards, num_of_slots + 1);
 	if (!mlxsw_hwmon)
 		return -ENOMEM;
 

drivers/net/ethernet/mellanox/mlxsw/core_thermal.c

···
 	mlxsw_reg_mgpir_unpack(mgpir_pl, NULL, NULL, NULL, NULL,
 			       &num_of_slots);
 
-	thermal = kzalloc_flex(*thermal, line_cards, num_of_slots + 1,
-			       GFP_KERNEL);
+	thermal = kzalloc_flex(*thermal, line_cards, num_of_slots + 1);
 	if (!thermal)
 		return -ENOMEM;
 

drivers/net/ethernet/mellanox/mlxsw/pci.c

···
 	int i;
 	int err;
 
-	mlxsw_pci->fw_area.items = kzalloc_objs(*mem_item, num_pages,
-						GFP_KERNEL);
+	mlxsw_pci->fw_area.items = kzalloc_objs(*mem_item, num_pages);
 	if (!mlxsw_pci->fw_area.items)
 		return -ENOMEM;
 	mlxsw_pci->fw_area.count = num_pages;

drivers/net/ethernet/mellanox/mlxsw/spectrum.c

···
 	if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_CPU_POLICERS))
 		return -EIO;
 	max_policers = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_CPU_POLICERS);
-	trap = kzalloc_flex(*trap, policers_usage, BITS_TO_LONGS(max_policers),
-			    GFP_KERNEL);
+	trap = kzalloc_flex(*trap, policers_usage, BITS_TO_LONGS(max_policers));
 	if (!trap)
 		return -ENOMEM;
 	trap->max_policers = max_policers;
···
 	if (err)
 		return err;
 
-	mlxsw_sp->lags = kzalloc_objs(struct mlxsw_sp_lag, mlxsw_sp->max_lag,
-				      GFP_KERNEL);
+	mlxsw_sp->lags = kzalloc_objs(struct mlxsw_sp_lag, mlxsw_sp->max_lag);
 	if (!mlxsw_sp->lags) {
 		err = -ENOMEM;
 		goto err_kcalloc;

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_bloom_filter.c

···
 	 * is 2^ACL_MAX_BF_LOG
 	 */
 	bf_bank_size = 1 << MLXSW_CORE_RES_GET(mlxsw_sp->core, ACL_MAX_BF_LOG);
-	bf = kzalloc_flex(*bf, refcnt, size_mul(bf_bank_size, num_erp_banks),
-			  GFP_KERNEL);
+	bf = kzalloc_flex(*bf, refcnt, size_mul(bf_bank_size, num_erp_banks));
 	if (!bf)
 		return ERR_PTR(-ENOMEM);
 

drivers/net/ethernet/mellanox/mlxsw/spectrum_buffers.c

···
 	int i;
 	int err;
 
-	mlxsw_sp->sb->ports = kzalloc_objs(struct mlxsw_sp_sb_port, max_ports,
-					   GFP_KERNEL);
+	mlxsw_sp->sb->ports = kzalloc_objs(struct mlxsw_sp_sb_port, max_ports);
 	if (!mlxsw_sp->sb->ports)
 		return -ENOMEM;
 

drivers/net/ethernet/mellanox/mlxsw/spectrum_dcb.c

···
 
 static int mlxsw_sp_port_ets_init(struct mlxsw_sp_port *mlxsw_sp_port)
 {
-	mlxsw_sp_port->dcb.ets = kzalloc_obj(*mlxsw_sp_port->dcb.ets,
-					     GFP_KERNEL);
+	mlxsw_sp_port->dcb.ets = kzalloc_obj(*mlxsw_sp_port->dcb.ets);
 	if (!mlxsw_sp_port->dcb.ets)
 		return -ENOMEM;
 
···
 {
 	int i;
 
-	mlxsw_sp_port->dcb.maxrate = kmalloc_obj(*mlxsw_sp_port->dcb.maxrate,
-						 GFP_KERNEL);
+	mlxsw_sp_port->dcb.maxrate = kmalloc_obj(*mlxsw_sp_port->dcb.maxrate);
 	if (!mlxsw_sp_port->dcb.maxrate)
 		return -ENOMEM;
 
···
 
 static int mlxsw_sp_port_pfc_init(struct mlxsw_sp_port *mlxsw_sp_port)
 {
-	mlxsw_sp_port->dcb.pfc = kzalloc_obj(*mlxsw_sp_port->dcb.pfc,
-					     GFP_KERNEL);
+	mlxsw_sp_port->dcb.pfc = kzalloc_obj(*mlxsw_sp_port->dcb.pfc);
 	if (!mlxsw_sp_port->dcb.pfc)
 		return -ENOMEM;
 

drivers/net/ethernet/mellanox/mlxsw/spectrum_nve.c

···
 	struct mlxsw_sp_nve_mc_record *mc_record;
 	int err;
 
-	mc_record = kzalloc_flex(*mc_record, entries, num_max_entries,
-				 GFP_KERNEL);
+	mc_record = kzalloc_flex(*mc_record, entries, num_max_entries);
 	if (!mc_record)
 		return ERR_PTR(-ENOMEM);
 

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c

···
 		return -EIO;
 
 	max_vrs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS);
-	mlxsw_sp->router->vrs = kzalloc_objs(struct mlxsw_sp_vr, max_vrs,
-					     GFP_KERNEL);
+	mlxsw_sp->router->vrs = kzalloc_objs(struct mlxsw_sp_vr, max_vrs);
 	if (!mlxsw_sp->router->vrs)
 		return -ENOMEM;
 
···
 	mlxsw_sp->router->max_rif_mac_profile =
 		MLXSW_CORE_RES_GET(core, MAX_RIF_MAC_PROFILES);
 
-	mlxsw_sp->router->rifs = kzalloc_objs(struct mlxsw_sp_rif *, max_rifs,
-					      GFP_KERNEL);
+	mlxsw_sp->router->rifs = kzalloc_objs(struct mlxsw_sp_rif *, max_rifs);
 	if (!mlxsw_sp->router->rifs)
 		return -ENOMEM;
 

drivers/net/ethernet/micrel/ksz884x.c

···
  */
 static int ksz_alloc_soft_desc(struct ksz_desc_info *desc_info, int transmit)
 {
-	desc_info->ring = kzalloc_objs(struct ksz_desc, desc_info->alloc,
-				       GFP_KERNEL);
+	desc_info->ring = kzalloc_objs(struct ksz_desc, desc_info->alloc);
 	if (!desc_info->ring)
 		return 1;
 	hw_init_desc(desc_info, transmit);

drivers/net/ethernet/microchip/lan966x/lan966x_fdma.c

···
 	struct fdma *fdma = &tx->fdma;
 	int err;
 
-	tx->dcbs_buf = kzalloc_objs(struct lan966x_tx_dcb_buf, fdma->n_dcbs,
-				    GFP_KERNEL);
+	tx->dcbs_buf = kzalloc_objs(struct lan966x_tx_dcb_buf, fdma->n_dcbs);
 	if (!tx->dcbs_buf)
 		return -ENOMEM;
 

drivers/net/ethernet/microchip/sparx5/sparx5_main.c

···
 	}
 	sparx5->port_count = of_get_child_count(ports);
 
-	configs = kzalloc_objs(struct initial_port_config, sparx5->port_count,
-			       GFP_KERNEL);
+	configs = kzalloc_objs(struct initial_port_config, sparx5->port_count);
 	if (!configs) {
 		err = -ENOMEM;
 		goto cleanup_pnode;

drivers/net/ethernet/microsoft/mana/mana_en.c

···
 	int err;
 	int i;
 
-	apc->tx_qp = kzalloc_objs(struct mana_tx_qp, apc->num_queues,
-				  GFP_KERNEL);
+	apc->tx_qp = kzalloc_objs(struct mana_tx_qp, apc->num_queues);
 	if (!apc->tx_qp)
 		return -ENOMEM;
 
···
 	if (!apc->indir_table)
 		return -ENOMEM;
 
-	apc->rxobj_table = kzalloc_objs(mana_handle_t, apc->indir_table_sz,
-					GFP_KERNEL);
+	apc->rxobj_table = kzalloc_objs(mana_handle_t, apc->indir_table_sz);
 	if (!apc->rxobj_table) {
 		kfree(apc->indir_table);
 		return -ENOMEM;

drivers/net/ethernet/myricom/myri10ge/myri10ge.c

···
 	 * slices. We give up on MSI-X if we can only get a single
 	 * vector. */
 
-	mgp->msix_vectors = kzalloc_objs(*mgp->msix_vectors, mgp->num_slices,
-					 GFP_KERNEL);
+	mgp->msix_vectors = kzalloc_objs(*mgp->msix_vectors, mgp->num_slices);
 	if (mgp->msix_vectors == NULL)
 		goto no_msix;
 	for (i = 0; i < mgp->num_slices; i++) {

drivers/net/ethernet/netronome/nfp/bpf/offload.c

···
 	if (!cnt)
 		goto out;
 
-	nfp_prog->map_records = kmalloc_objs(nfp_prog->map_records[0], cnt,
-					     GFP_KERNEL);
+	nfp_prog->map_records = kmalloc_objs(nfp_prog->map_records[0], cnt);
 	if (!nfp_prog->map_records) {
 		err = -ENOMEM;
 		goto out;

drivers/net/ethernet/netronome/nfp/flower/lag_conf.c

···
 			continue;
 		}
 
-		acti_netdevs = kmalloc_objs(*acti_netdevs, entry->slave_cnt,
-					    GFP_KERNEL);
+		acti_netdevs = kmalloc_objs(*acti_netdevs, entry->slave_cnt);
 		if (!acti_netdevs) {
 			schedule_delayed_work(&lag->work,
 					      NFP_FL_LAG_DELAY);

drivers/net/ethernet/netronome/nfp/nfd3/rings.c

···
 		goto err_alloc;
 	}
 
-	tx_ring->txbufs = kvzalloc_objs(*tx_ring->txbufs, tx_ring->cnt,
-					GFP_KERNEL);
+	tx_ring->txbufs = kvzalloc_objs(*tx_ring->txbufs, tx_ring->cnt);
 	if (!tx_ring->txbufs)
 		goto err_alloc;
 

drivers/net/ethernet/netronome/nfp/nfdk/rings.c

···
 		goto err_alloc;
 	}
 
-	tx_ring->ktxbufs = kvzalloc_objs(*tx_ring->ktxbufs, tx_ring->cnt,
-					 GFP_KERNEL);
+	tx_ring->ktxbufs = kvzalloc_objs(*tx_ring->ktxbufs, tx_ring->cnt);
 	if (!tx_ring->ktxbufs)
 		goto err_alloc;
 

drivers/net/ethernet/netronome/nfp/nfp_net_common.c

···
 				  nn->dp.num_r_vecs, num_online_cpus());
 	nn->max_r_vecs = nn->dp.num_r_vecs;
 
-	nn->dp.xsk_pools = kzalloc_objs(*nn->dp.xsk_pools, nn->max_r_vecs,
-					GFP_KERNEL);
+	nn->dp.xsk_pools = kzalloc_objs(*nn->dp.xsk_pools, nn->max_r_vecs);
 	if (!nn->dp.xsk_pools) {
 		err = -ENOMEM;
 		goto err_free_nn;

drivers/net/ethernet/netronome/nfp/nfp_net_main.c

···
 	wanted_irqs = 0;
 	list_for_each_entry(nn, &pf->vnics, vnic_list)
 		wanted_irqs += NFP_NET_NON_Q_VECTORS + nn->dp.num_r_vecs;
-	pf->irq_entries = kzalloc_objs(*pf->irq_entries, wanted_irqs,
-				       GFP_KERNEL);
+	pf->irq_entries = kzalloc_objs(*pf->irq_entries, wanted_irqs);
 	if (!pf->irq_entries)
 		return -ENOMEM;
 

drivers/net/ethernet/netronome/nfp/nfp_shared_buf.c

···
 
 	entry_sz = nfp_cpp_area_size(sb_desc_area) / num_entries;
 
-	pf->shared_bufs = kmalloc_objs(pf->shared_bufs[0], num_entries,
-				       GFP_KERNEL);
+	pf->shared_bufs = kmalloc_objs(pf->shared_bufs[0], num_entries);
 	if (!pf->shared_bufs) {
 		err = -ENOMEM;
 		goto err_release_area;

drivers/net/ethernet/nvidia/forcedeth.c

···
 			goto out_unmap;
 		np->tx_ring.ex = &np->rx_ring.ex[np->rx_ring_size];
 	}
-	np->rx_skb = kzalloc_objs(struct nv_skb_map, np->rx_ring_size,
-				  GFP_KERNEL);
-	np->tx_skb = kzalloc_objs(struct nv_skb_map, np->tx_ring_size,
-				  GFP_KERNEL);
+	np->rx_skb = kzalloc_objs(struct nv_skb_map, np->rx_ring_size);
+	np->tx_skb = kzalloc_objs(struct nv_skb_map, np->tx_ring_size);
 	if (!np->rx_skb || !np->tx_skb)
 		goto out_freering;
 

drivers/net/ethernet/pasemi/pasemi_mac.c

···
 	spin_lock_init(&ring->lock);
 
 	ring->size = RX_RING_SIZE;
-	ring->ring_info = kzalloc_objs(struct pasemi_mac_buffer, RX_RING_SIZE,
-				       GFP_KERNEL);
+	ring->ring_info = kzalloc_objs(struct pasemi_mac_buffer, RX_RING_SIZE);
 
 	if (!ring->ring_info)
 		goto out_ring_info;
···
 	spin_lock_init(&ring->lock);
 
 	ring->size = TX_RING_SIZE;
-	ring->ring_info = kzalloc_objs(struct pasemi_mac_buffer, TX_RING_SIZE,
-				       GFP_KERNEL);
+	ring->ring_info = kzalloc_objs(struct pasemi_mac_buffer, TX_RING_SIZE);
 	if (!ring->ring_info)
 		goto out_ring_info;
 

drivers/net/ethernet/qlogic/netxen/netxen_nic_init.c

···
 
 	recv_ctx = &adapter->recv_ctx;
 
-	rds_ring = kzalloc_objs(struct nx_host_rds_ring, adapter->max_rds_rings,
-				GFP_KERNEL);
+	rds_ring = kzalloc_objs(struct nx_host_rds_ring, adapter->max_rds_rings);
 	if (rds_ring == NULL)
 		goto err_out;
 

drivers/net/ethernet/qlogic/qed/qed_cxt.c

···
 	p_t2->num_pages = DIV_ROUND_UP(total_size, psz);
 
 	/* allocate t2 */
-	p_t2->dma_mem = kzalloc_objs(struct phys_mem_desc, p_t2->num_pages,
-				     GFP_KERNEL);
+	p_t2->dma_mem = kzalloc_objs(struct phys_mem_desc, p_t2->num_pages);
 	if (!p_t2->dma_mem) {
 		DP_NOTICE(p_hwfn, "Failed to allocate t2 table\n");
 		rc = -ENOMEM;
···
 	int rc;
 
 	size = qed_cxt_ilt_shadow_size(clients);
-	p_mngr->ilt_shadow = kzalloc_objs(struct phys_mem_desc, size,
-					  GFP_KERNEL);
+	p_mngr->ilt_shadow = kzalloc_objs(struct phys_mem_desc, size);
 	if (!p_mngr->ilt_shadow) {
 		rc = -ENOMEM;
 		goto ilt_shadow_fail;

drivers/net/ethernet/qlogic/qed/qed_debug.c

···
 
 	/* Read number of formats and allocate memory for all formats */
 	meta->formats_num = qed_read_dword_from_buf(meta_buf_bytes, &offset);
-	meta->formats = kzalloc_objs(struct mcp_trace_format, meta->formats_num,
-				     GFP_KERNEL);
+	meta->formats = kzalloc_objs(struct mcp_trace_format, meta->formats_num);
 	if (!meta->formats)
 		return DBG_STATUS_VIRT_MEM_ALLOC_FAILED;
 

drivers/net/ethernet/qlogic/qed/qed_init_fw_funcs.c

···
 	if (!buf_size)
 		return NULL;
 
-	allocated_mem = kzalloc_objs(struct phys_mem_desc, NUM_STORMS,
-				     GFP_KERNEL);
+	allocated_mem = kzalloc_objs(struct phys_mem_desc, NUM_STORMS);
 	if (!allocated_mem)
 		return NULL;
 

drivers/net/ethernet/qlogic/qede/qede_main.c

···
 	struct qede_fastpath *fp;
 	int i;
 
-	edev->fp_array = kzalloc_objs(*edev->fp_array, QEDE_QUEUE_CNT(edev),
-				      GFP_KERNEL);
+	edev->fp_array = kzalloc_objs(*edev->fp_array, QEDE_QUEUE_CNT(edev));
 	if (!edev->fp_array) {
 		DP_NOTICE(edev, "fp array allocation failed\n");
 		goto err;
···
 		}
 
 		if (fp->type & QEDE_FASTPATH_TX) {
-			fp->txq = kzalloc_objs(*fp->txq, edev->dev_info.num_tc,
-					       GFP_KERNEL);
+			fp->txq = kzalloc_objs(*fp->txq, edev->dev_info.num_tc);
 			if (!fp->txq)
 				goto err;
 		}
···
 				goto err;
 
 			if (edev->xdp_prog) {
-				fp->xdp_tx = kzalloc_obj(*fp->xdp_tx,
-							 GFP_KERNEL);
+				fp->xdp_tx = kzalloc_obj(*fp->xdp_tx);
 				if (!fp->xdp_tx)
 					goto err;
 				fp->type |= QEDE_FASTPATH_XDP;

drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c

···
 
 	act_pci_func = ahw->total_nic_func;
 
-	adapter->npars = kzalloc_objs(struct qlcnic_npar_info, act_pci_func,
-				      GFP_KERNEL);
+	adapter->npars = kzalloc_objs(struct qlcnic_npar_info, act_pci_func);
 	if (!adapter->npars) {
 		ret = -ENOMEM;
 		goto err_pci_info;

drivers/net/ethernet/qlogic/qlcnic/qlcnic_sriov_common.c

···
 	adapter->ahw->sriov = sriov;
 	sriov->num_vfs = num_vfs;
 	bc = &sriov->bc;
-	sriov->vf_info = kzalloc_objs(struct qlcnic_vf_info, num_vfs,
-				      GFP_KERNEL);
+	sriov->vf_info = kzalloc_objs(struct qlcnic_vf_info, num_vfs);
 	if (!sriov->vf_info) {
 		err = -ENOMEM;
 		goto qlcnic_free_sriov;

drivers/net/ethernet/renesas/ravb_main.c

···
 		goto error;
 
 	/* Allocate TX skb rings */
-	priv->tx_skb[q] = kzalloc_objs(*priv->tx_skb[q], priv->num_tx_ring[q],
-				       GFP_KERNEL);
+	priv->tx_skb[q] = kzalloc_objs(*priv->tx_skb[q], priv->num_tx_ring[q]);
 	if (!priv->tx_skb[q])
 		goto error;
 

drivers/net/ethernet/renesas/rswitch_main.c

···
 	gq->ndev = ndev;
 
 	if (!dir_tx) {
-		gq->rx_bufs = kzalloc_objs(*gq->rx_bufs, gq->ring_size,
-					   GFP_KERNEL);
+		gq->rx_bufs = kzalloc_objs(*gq->rx_bufs, gq->ring_size);
 		if (!gq->rx_bufs)
 			return -ENOMEM;
 		if (rswitch_gwca_queue_alloc_rx_buf(gq, 0, gq->ring_size) < 0)
···
 		gq->skbs = kzalloc_objs(*gq->skbs, gq->ring_size);
 		if (!gq->skbs)
 			return -ENOMEM;
-		gq->unmap_addrs = kzalloc_objs(*gq->unmap_addrs, gq->ring_size,
-					       GFP_KERNEL);
+		gq->unmap_addrs = kzalloc_objs(*gq->unmap_addrs, gq->ring_size);
 		if (!gq->unmap_addrs)
 			goto out;
 		gq->tx_ring = dma_alloc_coherent(ndev->dev.parent,

drivers/net/ethernet/renesas/sh_eth.c

···
 		mdp->rx_buf_sz += NET_IP_ALIGN;
 
 	/* Allocate RX and TX skb rings */
-	mdp->rx_skbuff = kzalloc_objs(*mdp->rx_skbuff, mdp->num_rx_ring,
-				      GFP_KERNEL);
+	mdp->rx_skbuff = kzalloc_objs(*mdp->rx_skbuff, mdp->num_rx_ring);
 	if (!mdp->rx_skbuff)
 		return -ENOMEM;
 
-	mdp->tx_skbuff = kzalloc_objs(*mdp->tx_skbuff, mdp->num_tx_ring,
-				      GFP_KERNEL);
+	mdp->tx_skbuff = kzalloc_objs(*mdp->tx_skbuff, mdp->num_tx_ring);
 	if (!mdp->tx_skbuff)
 		goto ring_free;
 

drivers/net/ethernet/rocker/rocker_main.c

···
 	if (msix_entries != ROCKER_MSIX_VEC_COUNT(rocker->port_count))
 		return -EINVAL;
 
-	rocker->msix_entries = kmalloc_objs(struct msix_entry, msix_entries,
-					    GFP_KERNEL);
+	rocker->msix_entries = kmalloc_objs(struct msix_entry, msix_entries);
 	if (!rocker->msix_entries)
 		return -ENOMEM;
 

drivers/net/ethernet/samsung/sxgbe/sxgbe_main.c

···
 		goto err_free_dma_rx;
 	}
 
-	rx_ring->rx_skbuff = kmalloc_objs(struct sk_buff *, rx_rsize,
-					  GFP_KERNEL);
+	rx_ring->rx_skbuff = kmalloc_objs(struct sk_buff *, rx_rsize);
 	if (!rx_ring->rx_skbuff) {
 		ret = -ENOMEM;
 		goto err_free_skbuff_dma;

drivers/net/ethernet/sfc/falcon/rx.c

···
 
 	page_ring_size = roundup_pow_of_two(bufs_in_recycle_ring /
 					    efx->rx_bufs_per_page);
-	rx_queue->page_ring = kzalloc_objs(*rx_queue->page_ring, page_ring_size,
-				           GFP_KERNEL);
+	rx_queue->page_ring = kzalloc_objs(*rx_queue->page_ring, page_ring_size);
 	if (!rx_queue->page_ring)
 		rx_queue->page_ptr_mask = 0;
 	else

drivers/net/ethernet/sfc/falcon/selftest.c

···
 		/* Determine how many packets to send */
 		state->packet_count = efx->txq_entries / 3;
 		state->packet_count = min(1 << (i << 2), state->packet_count);
-		state->skbs = kzalloc_objs(state->skbs[0], state->packet_count,
-					   GFP_KERNEL);
+		state->skbs = kzalloc_objs(state->skbs[0], state->packet_count);
 		if (!state->skbs)
 			return -ENOMEM;
 		state->flush = false;

drivers/net/ethernet/sfc/mcdi_mon.c

···
 		rc = -ENOMEM;
 		goto fail;
 	}
-	hwmon->group.attrs = kzalloc_objs(struct attribute *, n_attrs + 1,
-					  GFP_KERNEL);
+	hwmon->group.attrs = kzalloc_objs(struct attribute *, n_attrs + 1);
 	if (!hwmon->group.attrs) {
 		rc = -ENOMEM;
 		goto fail;

drivers/net/ethernet/sfc/rx_common.c

···
 	bufs_in_recycle_ring = efx_rx_recycle_ring_size(efx);
 	page_ring_size = roundup_pow_of_two(bufs_in_recycle_ring /
 					    efx->rx_bufs_per_page);
-	rx_queue->page_ring = kzalloc_objs(*rx_queue->page_ring, page_ring_size,
-				           GFP_KERNEL);
+	rx_queue->page_ring = kzalloc_objs(*rx_queue->page_ring, page_ring_size);
 	if (!rx_queue->page_ring)
 		rx_queue->page_ptr_mask = 0;
 	else

drivers/net/ethernet/sfc/selftest.c

···
 		/* Determine how many packets to send */
 		state->packet_count = efx->txq_entries / 3;
 		state->packet_count = min(1 << (i << 2), state->packet_count);
-		state->skbs = kzalloc_objs(state->skbs[0], state->packet_count,
-					   GFP_KERNEL);
+		state->skbs = kzalloc_objs(state->skbs[0], state->packet_count);
 		if (!state->skbs)
 			return -ENOMEM;
 		state->flush = false;

drivers/net/ethernet/sfc/siena/mcdi_mon.c

···
 		rc = -ENOMEM;
 		goto fail;
 	}
-	hwmon->group.attrs = kzalloc_objs(struct attribute *, n_attrs + 1,
-					  GFP_KERNEL);
+	hwmon->group.attrs = kzalloc_objs(struct attribute *, n_attrs + 1);
 	if (!hwmon->group.attrs) {
 		rc = -ENOMEM;
 		goto fail;

drivers/net/ethernet/sfc/siena/rx_common.c

···
 	bufs_in_recycle_ring = efx_rx_recycle_ring_size(efx);
 	page_ring_size = roundup_pow_of_two(bufs_in_recycle_ring /
 					    efx->rx_bufs_per_page);
-	rx_queue->page_ring = kzalloc_objs(*rx_queue->page_ring, page_ring_size,
-				           GFP_KERNEL);
+	rx_queue->page_ring = kzalloc_objs(*rx_queue->page_ring, page_ring_size);
 	if (!rx_queue->page_ring)
 		rx_queue->page_ptr_mask = 0;
 	else

drivers/net/ethernet/sfc/siena/selftest.c

···
 		/* Determine how many packets to send */
 		state->packet_count = efx->txq_entries / 3;
 		state->packet_count = min(1 << (i << 2), state->packet_count);
-		state->skbs = kzalloc_objs(state->skbs[0], state->packet_count,
-					   GFP_KERNEL);
+		state->skbs = kzalloc_objs(state->skbs[0], state->packet_count);
 		if (!state->skbs)
 			return -ENOMEM;
 		state->flush = false;

drivers/net/ethernet/smsc/smsc9420.c

···
 
 	BUG_ON(!pd->tx_ring);
 
-	pd->tx_buffers = kmalloc_objs(struct smsc9420_ring_info, TX_RING_SIZE,
-				      GFP_KERNEL);
+	pd->tx_buffers = kmalloc_objs(struct smsc9420_ring_info, TX_RING_SIZE);
 	if (!pd->tx_buffers)
 		return -ENOMEM;
 
···
 
 	BUG_ON(!pd->rx_ring);
 
-	pd->rx_buffers = kmalloc_objs(struct smsc9420_ring_info, RX_RING_SIZE,
-				      GFP_KERNEL);
+	pd->rx_buffers = kmalloc_objs(struct smsc9420_ring_info, RX_RING_SIZE);
 	if (pd->rx_buffers == NULL)
 		goto out;
 

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

···
 		return ret;
 	}
 
-	rx_q->buf_pool = kzalloc_objs(*rx_q->buf_pool, dma_conf->dma_rx_size,
-				      GFP_KERNEL);
+	rx_q->buf_pool = kzalloc_objs(*rx_q->buf_pool, dma_conf->dma_rx_size);
 	if (!rx_q->buf_pool)
 		return -ENOMEM;
 
···
 	if (!tx_q->tx_skbuff_dma)
 		return -ENOMEM;
 
-	tx_q->tx_skbuff = kzalloc_objs(struct sk_buff *, dma_conf->dma_tx_size,
-				       GFP_KERNEL);
+	tx_q->tx_skbuff = kzalloc_objs(struct sk_buff *, dma_conf->dma_tx_size);
 	if (!tx_q->tx_skbuff)
 		return -ENOMEM;
 

drivers/net/ethernet/synopsys/dwc-xlgmac-desc.c

···
 	int ret = -ENOMEM;
 	unsigned int i;
 
-	channel_head = kzalloc_objs(struct xlgmac_channel, pdata->channel_count,
-				    GFP_KERNEL);
+	channel_head = kzalloc_objs(struct xlgmac_channel, pdata->channel_count);
 	if (!channel_head)
 		return ret;
 
 	netif_dbg(pdata, drv, pdata->netdev,
 		  "channel_head=%p\n", channel_head);
 
-	tx_ring = kzalloc_objs(struct xlgmac_ring, pdata->tx_ring_count,
-			       GFP_KERNEL);
+	tx_ring = kzalloc_objs(struct xlgmac_ring, pdata->tx_ring_count);
 	if (!tx_ring)
 		goto err_tx_ring;
 
-	rx_ring = kzalloc_objs(struct xlgmac_ring, pdata->rx_ring_count,
-			       GFP_KERNEL);
+	rx_ring = kzalloc_objs(struct xlgmac_ring, pdata->rx_ring_count);
 	if (!rx_ring)
 		goto err_rx_ring;
 

drivers/net/ethernet/ti/k3-cppi-desc-pool.c

···
 
 	pool->gen_pool->name = pool_name;
 
-	pool->desc_infos = kzalloc_objs(*pool->desc_infos, pool->num_desc,
-					GFP_KERNEL);
+	pool->desc_infos = kzalloc_objs(*pool->desc_infos, pool->num_desc);
 	if (!pool->desc_infos)
 		goto gen_pool_desc_infos_alloc_fail;
 

drivers/net/ethernet/xilinx/xilinx_axienet_main.c

···
 	lp->tx_ring_head = 0;
 	lp->rx_ring_tail = 0;
 	lp->rx_ring_head = 0;
-	lp->tx_skb_ring = kzalloc_objs(*lp->tx_skb_ring, TX_BD_NUM_MAX,
-				       GFP_KERNEL);
+	lp->tx_skb_ring = kzalloc_objs(*lp->tx_skb_ring, TX_BD_NUM_MAX);
 	if (!lp->tx_skb_ring) {
 		ret = -ENOMEM;
 		goto err_dma_release_rx;
···
 		lp->tx_skb_ring[i] = skbuf_dma;
 	}
 
-	lp->rx_skb_ring = kzalloc_objs(*lp->rx_skb_ring, RX_BUF_NUM_DEFAULT,
-				       GFP_KERNEL);
+	lp->rx_skb_ring = kzalloc_objs(*lp->rx_skb_ring, RX_BUF_NUM_DEFAULT);
 	if (!lp->rx_skb_ring) {
 		ret = -ENOMEM;
 		goto err_free_tx_skb_ring;

drivers/net/hyperv/netvsc_drv.c

···
 		data[i++] = xdp_tx;
 	}
 
-	pcpu_sum = kvmalloc_objs(struct netvsc_ethtool_pcpu_stats, nr_cpu_ids,
-				 GFP_KERNEL);
+	pcpu_sum = kvmalloc_objs(struct netvsc_ethtool_pcpu_stats, nr_cpu_ids);
 	if (!pcpu_sum)
 		return;
 

drivers/net/ieee802154/ca8210.c

···
 				&priv->spi->dev,
 				"Resetting MAC...\n");
 
-			mlme_reset_wpc = kmalloc_obj(*mlme_reset_wpc,
-						     GFP_KERNEL);
+			mlme_reset_wpc = kmalloc_obj(*mlme_reset_wpc);
 			if (!mlme_reset_wpc)
 				goto finish;
 			INIT_WORK(

drivers/net/ipa/gsi_trans.c

···
 	 * modulo that number to determine the next one that's free.
 	 * Transactions are allocated one at a time.
 	 */
-	trans_info->trans = kzalloc_objs(*trans_info->trans, tre_count,
-					 GFP_KERNEL);
+	trans_info->trans = kzalloc_objs(*trans_info->trans, tre_count);
 	if (!trans_info->trans)
 		return -ENOMEM;
 	trans_info->free_id = 0;	/* all modulo channel->tre_count */

drivers/net/pcs/pcs-rzn1-miic.c

···
 	s8 *dt_val;
 	u32 conf;
 
-	dt_val = kmalloc_objs(*dt_val, miic->of_data->conf_conv_count,
-			      GFP_KERNEL);
+	dt_val = kmalloc_objs(*dt_val, miic->of_data->conf_conv_count);
 	if (!dt_val)
 		return -ENOMEM;
 

drivers/net/usb/hso.c

···
 		if (!serial->tiocmget)
 			goto exit;
 		serial->tiocmget->serial_state_notification
-			= kzalloc_obj(struct hso_serial_state_notification,
-				      GFP_KERNEL);
+			= kzalloc_obj(struct hso_serial_state_notification);
 		if (!serial->tiocmget->serial_state_notification)
 			goto exit;
 		tiocmget = serial->tiocmget;

drivers/net/usb/smsc75xx.c

···
 		return ret;
 	}
 
-	dev->data[0] = (unsigned long) kzalloc_obj(struct smsc75xx_priv,
-						   GFP_KERNEL);
+	dev->data[0] = (unsigned long) kzalloc_obj(struct smsc75xx_priv);
 
 	pdata = (struct smsc75xx_priv *)(dev->data[0]);
 	if (!pdata)

drivers/net/wan/fsl_ucc_hdlc.c

···
 		goto free_tx_bd;
 	}
 
-	priv->rx_skbuff = kzalloc_objs(*priv->rx_skbuff, priv->rx_ring_size,
-				       GFP_KERNEL);
+	priv->rx_skbuff = kzalloc_objs(*priv->rx_skbuff, priv->rx_ring_size);
 	if (!priv->rx_skbuff) {
 		ret = -ENOMEM;
 		goto free_ucc_pram;
 	}
 
-	priv->tx_skbuff = kzalloc_objs(*priv->tx_skbuff, priv->tx_ring_size,
-				       GFP_KERNEL);
+	priv->tx_skbuff = kzalloc_objs(*priv->tx_skbuff, priv->tx_ring_size);
 	if (!priv->tx_skbuff) {
 		ret = -ENOMEM;
 		goto free_rx_skbuff;

drivers/net/wireless/ath/ath10k/ce.c

···
 
 	nentries = roundup_pow_of_two(nentries);
 
-	src_ring = kzalloc_flex(*src_ring, per_transfer_context, nentries,
-				GFP_KERNEL);
+	src_ring = kzalloc_flex(*src_ring, per_transfer_context, nentries);
 	if (src_ring == NULL)
 		return ERR_PTR(-ENOMEM);
 
···
 
 	nentries = roundup_pow_of_two(nentries);
 
-	src_ring = kzalloc_flex(*src_ring, per_transfer_context, nentries,
-				GFP_KERNEL);
+	src_ring = kzalloc_flex(*src_ring, per_transfer_context, nentries);
 	if (!src_ring)
 		return ERR_PTR(-ENOMEM);
 
···
 
 	nentries = roundup_pow_of_two(attr->dest_nentries);
 
-	dest_ring = kzalloc_flex(*dest_ring, per_transfer_context, nentries,
-				 GFP_KERNEL);
+	dest_ring = kzalloc_flex(*dest_ring, per_transfer_context, nentries);
 	if (dest_ring == NULL)
 		return ERR_PTR(-ENOMEM);
 
···
 
 	nentries = roundup_pow_of_two(attr->dest_nentries);
 
-	dest_ring = kzalloc_flex(*dest_ring, per_transfer_context, nentries,
-				 GFP_KERNEL);
+	dest_ring = kzalloc_flex(*dest_ring, per_transfer_context, nentries);
 	if (!dest_ring)
 		return ERR_PTR(-ENOMEM);
 

drivers/net/wireless/ath/ath10k/mac.c

···
 		}
 
 		if (ath10k_debug_is_extd_tx_stats_enabled(ar)) {
-			arsta->tx_stats = kzalloc_obj(*arsta->tx_stats,
-						      GFP_KERNEL);
+			arsta->tx_stats = kzalloc_obj(*arsta->tx_stats);
 			if (!arsta->tx_stats) {
 				ath10k_mac_dec_num_stations(arvif, sta);
 				ret = -ENOMEM;

drivers/net/wireless/ath/ath12k/dp.c

···
 	if (dp->num_spt_pages > ATH12K_MAX_PPT_ENTRIES)
 		dp->num_spt_pages = ATH12K_MAX_PPT_ENTRIES;
 
-	dp->spt_info = kzalloc_objs(struct ath12k_spt_info, dp->num_spt_pages,
-				    GFP_KERNEL);
+	dp->spt_info = kzalloc_objs(struct ath12k_spt_info, dp->num_spt_pages);
 
 	if (!dp->spt_info) {
 		ath12k_warn(ab, "SPT page allocation failure");

drivers/net/wireless/ath/ath12k/mac.c

···
 							    u8 link_id)
 {
 	if (!ahvif->cache[link_id]) {
-		ahvif->cache[link_id] = kzalloc_obj(*ahvif->cache[0],
-						    GFP_KERNEL);
+		ahvif->cache[link_id] = kzalloc_obj(*ahvif->cache[0]);
 		if (ahvif->cache[link_id])
 			INIT_LIST_HEAD(&ahvif->cache[link_id]->key_conf.list);
 	}
···
 		if (ar->ab->hw_params->single_pdev_only)
 			n_combinations = 2;
 
-		combinations = kzalloc_objs(*combinations, n_combinations,
-					    GFP_KERNEL);
+		combinations = kzalloc_objs(*combinations, n_combinations);
 		if (!combinations)
 			return -ENOMEM;
 

drivers/net/wireless/ath/ath5k/eeprom.c

···
 		if (!pd->pd_step)
 			goto err_out;
 
-		pd->pd_pwr = kzalloc_objs(s16, AR5K_EEPROM_N_PWR_POINTS_5111,
-					  GFP_KERNEL);
+		pd->pd_pwr = kzalloc_objs(s16, AR5K_EEPROM_N_PWR_POINTS_5111);
 		if (!pd->pd_pwr)
 			goto err_out;
 
···
 				if (!pd->pd_step)
 					goto err_out;
 
-				pd->pd_pwr = kzalloc_objs(s16, pd->pd_points,
-							  GFP_KERNEL);
+				pd->pd_pwr = kzalloc_objs(s16, pd->pd_points);
 
 				if (!pd->pd_pwr)
 					goto err_out;
···
 				if (!pd->pd_step)
 					goto err_out;
 
-				pd->pd_pwr = kzalloc_objs(s16, pd->pd_points,
-							  GFP_KERNEL);
+				pd->pd_pwr = kzalloc_objs(s16, pd->pd_points);
 
 				if (!pd->pd_pwr)
 					goto err_out;
···
 			if (!pd->pd_step)
 				goto err_out;
 
-			pd->pd_pwr = kzalloc_objs(s16, pd->pd_points,
-						  GFP_KERNEL);
+			pd->pd_pwr = kzalloc_objs(s16, pd->pd_points);
 
 			if (!pd->pd_pwr)
 				goto err_out;

drivers/net/wireless/ath/wil6210/fw_inc.c

···
 		return -EINVAL;
 	}
 
-	wil->brd_info = kzalloc_objs(struct wil_brd_info, max_num_ent,
-				     GFP_KERNEL);
+	wil->brd_info = kzalloc_objs(struct wil_brd_info, max_num_ent);
 	if (!wil->brd_info)
 		return -ENOMEM;
 

drivers/net/wireless/ath/wil6210/pmc.c

···
 		     num_descriptors, descriptor_size);
 
 	/* allocate descriptors info list in pmc context*/
-	pmc->descriptors = kzalloc_objs(struct desc_alloc_info, num_descriptors,
-					GFP_KERNEL);
+	pmc->descriptors = kzalloc_objs(struct desc_alloc_info, num_descriptors);
 	if (!pmc->descriptors) {
 		wil_err(wil, "ERROR allocating pmc skb list\n");
 		goto no_release_err;

drivers/net/wireless/ath/wil6210/txrx_edma.c

···
 	struct list_head *free = &wil->rx_buff_mgmt.free;
 	int i;
 
-	wil->rx_buff_mgmt.buff_arr = kzalloc_objs(struct wil_rx_buff, size + 1,
-						  GFP_KERNEL);
+	wil->rx_buff_mgmt.buff_arr = kzalloc_objs(struct wil_rx_buff, size + 1);
 	if (!wil->rx_buff_mgmt.buff_arr)
 		return -ENOMEM;
 

drivers/net/wireless/broadcom/b43/debugfs.c

···
 	}
 	e->dev = dev;
 	log = &e->txstatlog;
-	log->log = kzalloc_objs(struct b43_txstatus, B43_NR_LOGGED_TXSTATUS,
-				GFP_KERNEL);
+	log->log = kzalloc_objs(struct b43_txstatus, B43_NR_LOGGED_TXSTATUS);
 	if (!log->log) {
 		b43err(dev->wl, "debugfs: add device txstatus OOM\n");
 		kfree(e);

drivers/net/wireless/broadcom/b43/dma.c

···
 	if (for_tx)
 		ring->nr_slots = B43_TXRING_SLOTS;
 
-	ring->meta = kzalloc_objs(struct b43_dmadesc_meta, ring->nr_slots,
-				  GFP_KERNEL);
+	ring->meta = kzalloc_objs(struct b43_dmadesc_meta, ring->nr_slots);
 	if (!ring->meta)
 		goto err_kfree_ring;
 	for (i = 0; i < ring->nr_slots; i++)

drivers/net/wireless/broadcom/b43legacy/dma.c

···
 	if (for_tx)
 		nr_slots = B43legacy_TXRING_SLOTS;
 
-	ring->meta = kzalloc_objs(struct b43legacy_dmadesc_meta, nr_slots,
-				  GFP_KERNEL);
+	ring->meta = kzalloc_objs(struct b43legacy_dmadesc_meta, nr_slots);
 	if (!ring->meta)
 		goto err_kfree_ring;
 	if (for_tx) {

drivers/net/wireless/broadcom/brcm80211/brcmfmac/pcie.c

···
 		bus->msgbuf->commonrings[i] =
 				&devinfo->shared.commonrings[i]->commonring;
 
-	flowrings = kzalloc_objs(*flowrings, devinfo->shared.max_flowrings,
-				 GFP_KERNEL);
+	flowrings = kzalloc_objs(*flowrings, devinfo->shared.max_flowrings);
 	if (!flowrings)
 		goto fail;
 

drivers/net/wireless/intel/ipw2x00/ipw2100.c

···
 	dma_addr_t p;
 
 	priv->msg_buffers =
-	    kmalloc_objs(struct ipw2100_tx_packet, IPW_COMMAND_POOL_SIZE,
-			 GFP_KERNEL);
+	    kmalloc_objs(struct ipw2100_tx_packet, IPW_COMMAND_POOL_SIZE);
 	if (!priv->msg_buffers)
 		return -ENOMEM;
 

drivers/net/wireless/intel/ipw2x00/libipw_module.c

···
 	int i, j;
 
 	for (i = 0; i < MAX_NETWORK_COUNT; i++) {
-		ieee->networks[i] = kzalloc_obj(struct libipw_network,
-						GFP_KERNEL);
+		ieee->networks[i] = kzalloc_obj(struct libipw_network);
 		if (!ieee->networks[i]) {
 			LIBIPW_ERROR("Out of memory allocating beacons\n");
 			for (j = 0; j < i; j++)

drivers/net/wireless/intel/iwlegacy/common.c

···
 	/* Driver ilate data, only for Tx (not command) queues,
 	 * not shared with device. */
 	if (id != il->cmd_queue) {
-		txq->skbs = kzalloc_objs(struct sk_buff *, TFD_QUEUE_SIZE_MAX,
-					 GFP_KERNEL);
+		txq->skbs = kzalloc_objs(struct sk_buff *, TFD_QUEUE_SIZE_MAX);
 		if (!txq->skbs) {
 			IL_ERR("Fail to alloc skbs\n");
 			goto error;
···
 	}
 
 	channels =
-	    kzalloc_objs(struct ieee80211_channel, il->channel_count,
-			 GFP_KERNEL);
+	    kzalloc_objs(struct ieee80211_channel, il->channel_count);
 	if (!channels)
 		return -ENOMEM;
 
···
 {
 	if (!il->txq)
 		il->txq =
-		    kzalloc_objs(struct il_tx_queue, il->cfg->num_of_queues,
-				 GFP_KERNEL);
+		    kzalloc_objs(struct il_tx_queue, il->cfg->num_of_queues);
 	if (!il->txq) {
 		IL_ERR("Not enough memory for txq\n");
 		return -ENOMEM;

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

···
 		struct iwl_fw_dump_desc *iwl_dump_error_desc;
 		int ret;
 
-		iwl_dump_error_desc = kmalloc_obj(*iwl_dump_error_desc,
-						  GFP_KERNEL);
+		iwl_dump_error_desc = kmalloc_obj(*iwl_dump_error_desc);
 
 		if (!iwl_dump_error_desc)
 			return -ENOMEM;

drivers/net/wireless/intel/iwlwifi/iwl-nvm-parse.c

···
 	u8 tx_chains = fw->valid_rx_ant;
 
 	if (cfg->uhb_supported)
-		data = kzalloc_flex(*data, channels, IWL_NVM_NUM_CHANNELS_UHB,
-				    GFP_KERNEL);
+		data = kzalloc_flex(*data, channels, IWL_NVM_NUM_CHANNELS_UHB);
 	else
-		data = kzalloc_flex(*data, channels, IWL_NVM_NUM_CHANNELS_EXT,
-				    GFP_KERNEL);
+		data = kzalloc_flex(*data, channels, IWL_NVM_NUM_CHANNELS_EXT);
 	if (!data)
 		return NULL;
 
···
 	const __le16 *ch_section;
 
 	if (cfg->uhb_supported)
-		data = kzalloc_flex(*data, channels, IWL_NVM_NUM_CHANNELS_UHB,
-				    GFP_KERNEL);
+		data = kzalloc_flex(*data, channels, IWL_NVM_NUM_CHANNELS_UHB);
 	else if (cfg->nvm_type != IWL_NVM_EXT)
-		data = kzalloc_flex(*data, channels, IWL_NVM_NUM_CHANNELS,
-				    GFP_KERNEL);
+		data = kzalloc_flex(*data, channels, IWL_NVM_NUM_CHANNELS);
 	else
-		data = kzalloc_flex(*data, channels, IWL_NVM_NUM_CHANNELS_EXT,
-				    GFP_KERNEL);
+		data = kzalloc_flex(*data, channels, IWL_NVM_NUM_CHANNELS_EXT);
 	if (!data)
 		return NULL;
 

drivers/net/wireless/intel/iwlwifi/mld/d3.c

···
 		goto out;
 	}
 	n_matches = hweight_long(matched_profiles);
-	netdetect_info = kzalloc_flex(*netdetect_info, matches, n_matches,
-				      GFP_KERNEL);
+	netdetect_info = kzalloc_flex(*netdetect_info, matches, n_matches);
 	if (netdetect_info)
 		iwl_mld_set_netdetect_info(mld, netdetect_cfg, netdetect_info,
 					   resume_data->netdetect_res,
···
 
 	iwl_fw_dbg_read_d3_debug_data(&mld->fwrt);
 
-	resume_data.wowlan_status = kzalloc_obj(*resume_data.wowlan_status,
-						GFP_KERNEL);
+	resume_data.wowlan_status = kzalloc_obj(*resume_data.wowlan_status);
 	if (!resume_data.wowlan_status)
 		return -ENOMEM;
 

drivers/net/wireless/intel/iwlwifi/mld/sta.c

···
 	if (mld->fw_status.in_hw_restart)
 		return 0;
 
-	dup_data = kzalloc_objs(*dup_data, mld->trans->info.num_rxqs,
-				GFP_KERNEL);
+	dup_data = kzalloc_objs(*dup_data, mld->trans->info.num_rxqs);
 	if (!dup_data)
 		return -ENOMEM;
 

drivers/net/wireless/intel/iwlwifi/mld/time_sync.c

···
 static int iwl_mld_init_time_sync(struct iwl_mld *mld, u32 protocols,
 				  const u8 *addr)
 {
-	struct iwl_mld_time_sync_data *time_sync = kzalloc_obj(*time_sync,
-							       GFP_KERNEL);
+	struct iwl_mld_time_sync_data *time_sync = kzalloc_obj(*time_sync);
 
 	if (!time_sync)
 		return -ENOMEM;

drivers/net/wireless/intel/iwlwifi/mvm/sta.c

···
 	if (iwl_mvm_has_new_rx_api(mvm)) {
 		int q;
 
-		dup_data = kzalloc_objs(*dup_data, mvm->trans->info.num_rxqs,
-					GFP_KERNEL);
+		dup_data = kzalloc_objs(*dup_data, mvm->trans->info.num_rxqs);
 		if (!dup_data)
 			return -ENOMEM;
 		/*

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/rx.c

···
 	if (WARN_ON(trans_pcie->rxq))
 		return -EINVAL;
 
-	trans_pcie->rxq = kzalloc_objs(struct iwl_rxq, trans->info.num_rxqs,
-				       GFP_KERNEL);
+	trans_pcie->rxq = kzalloc_objs(struct iwl_rxq, trans->info.num_rxqs);
 	trans_pcie->rx_pool = kzalloc_objs(trans_pcie->rx_pool[0],
 					   RX_POOL_SIZE(trans_pcie->num_rx_bufs),
 					   GFP_KERNEL);

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/tx.c

···
 
 	txq->n_window = slots_num;
 
-	txq->entries = kzalloc_objs(struct iwl_pcie_txq_entry, slots_num,
-				    GFP_KERNEL);
+	txq->entries = kzalloc_objs(struct iwl_pcie_txq_entry, slots_num);
 
 	if (!txq->entries)
 		goto error;

drivers/net/wireless/intersil/p54/eeprom.c

···
 		goto free;
 	}
 	priv->chan_num = max_channel_num;
-	priv->survey = kzalloc_objs(struct survey_info, max_channel_num,
-				    GFP_KERNEL);
+	priv->survey = kzalloc_objs(struct survey_info, max_channel_num);
 	if (!priv->survey) {
 		ret = -ENOMEM;
 		goto free;
 	}
 
 	list->max_entries = max_channel_num;
-	list->channels = kzalloc_objs(struct p54_channel_entry, max_channel_num,
-				      GFP_KERNEL);
+	list->channels = kzalloc_objs(struct p54_channel_entry, max_channel_num);
 	if (!list->channels) {
 		ret = -ENOMEM;
 		goto free;

drivers/net/wireless/marvell/mwifiex/scan.c

···
 	adapter->scan_processing = true;
 	spin_unlock_bh(&adapter->mwifiex_cmd_lock);
 
-	scan_cfg_out = kzalloc_obj(union mwifiex_scan_cmd_config_tlv,
-				   GFP_KERNEL);
+	scan_cfg_out = kzalloc_obj(union mwifiex_scan_cmd_config_tlv);
 	if (!scan_cfg_out) {
 		ret = -ENOMEM;
 		goto done;

drivers/net/wireless/microchip/wilc1000/cfg80211.c

···
 static int wilc_wfi_cfg_allocate_wpa_entry(struct wilc_priv *priv, u8 idx)
 {
 	if (!priv->wilc_gtk[idx]) {
-		priv->wilc_gtk[idx] = kzalloc_obj(*priv->wilc_gtk[idx],
-						  GFP_KERNEL);
+		priv->wilc_gtk[idx] = kzalloc_obj(*priv->wilc_gtk[idx]);
 		if (!priv->wilc_gtk[idx])
 			return -ENOMEM;
 	}
 
 	if (!priv->wilc_ptk[idx]) {
-		priv->wilc_ptk[idx] = kzalloc_obj(*priv->wilc_ptk[idx],
-						  GFP_KERNEL);
+		priv->wilc_ptk[idx] = kzalloc_obj(*priv->wilc_ptk[idx]);
 		if (!priv->wilc_ptk[idx])
 			return -ENOMEM;
 	}
···
 {
 	idx -= 4;
 	if (!priv->wilc_igtk[idx]) {
-		priv->wilc_igtk[idx] = kzalloc_obj(*priv->wilc_igtk[idx],
-						   GFP_KERNEL);
+		priv->wilc_igtk[idx] = kzalloc_obj(*priv->wilc_igtk[idx]);
 		if (!priv->wilc_igtk[idx])
 			return -ENOMEM;
 	}

drivers/net/wireless/quantenna/qtnfmac/commands.c

···
 	if (WARN_ON(resp->n_reg_rules > NL80211_MAX_SUPP_REG_RULES))
 		return -E2BIG;
 
-	mac->rd = kzalloc_flex(*mac->rd, reg_rules, resp->n_reg_rules,
-			       GFP_KERNEL);
+	mac->rd = kzalloc_flex(*mac->rd, reg_rules, resp->n_reg_rules);
 	if (!mac->rd)
 		return -ENOMEM;
 
···
 				return -EINVAL;
 			}
 
-			limits = kzalloc_objs(*limits, rec->n_limits,
-					      GFP_KERNEL);
+			limits = kzalloc_objs(*limits, rec->n_limits);
 			if (!limits)
 				return -ENOMEM;
 
···
 	if (band->n_iftype_data == 0)
 		return 0;
 
-	iftype_data = kzalloc_objs(*iftype_data, band->n_iftype_data,
-				   GFP_KERNEL);
+	iftype_data = kzalloc_objs(*iftype_data, band->n_iftype_data);
 	if (!iftype_data) {
 		band->n_iftype_data = 0;
 		return -ENOMEM;
···
 		return 0;
 
 	if (!band->channels)
-		band->channels = kzalloc_objs(*chan, band->n_channels,
-					      GFP_KERNEL);
+		band->channels = kzalloc_objs(*chan, band->n_channels);
 	if (!band->channels) {
 		band->n_channels = 0;
 		return -ENOMEM;

drivers/net/wireless/ralink/rt2x00/rt2800lib.c

···
 		return -ENOMEM;
 
 	rt2x00dev->chan_survey =
-		kzalloc_objs(struct rt2x00_chan_survey, spec->num_channels,
-			     GFP_KERNEL);
+		kzalloc_objs(struct rt2x00_chan_survey, spec->num_channels);
 	if (!rt2x00dev->chan_survey) {
 		kfree(info);
 		return -ENOMEM;

drivers/net/wireless/realtek/rtlwifi/rtl8192du/sw.c

···
 	rtlpriv->curveindex_5g = kcalloc(TARGET_CHNL_NUM_5G,
 					 sizeof(*rtlpriv->curveindex_5g),
 					 GFP_KERNEL);
-	rtlpriv->mutex_for_power_on_off = kzalloc_obj(*rtlpriv->mutex_for_power_on_off,
-						      GFP_KERNEL);
-	rtlpriv->mutex_for_hw_init = kzalloc_obj(*rtlpriv->mutex_for_hw_init,
-						 GFP_KERNEL);
+	rtlpriv->mutex_for_power_on_off = kzalloc_obj(*rtlpriv->mutex_for_power_on_off);
+	rtlpriv->mutex_for_hw_init = kzalloc_obj(*rtlpriv->mutex_for_hw_init);
 
 	if (!rtlpriv->curveindex_2g || !rtlpriv->curveindex_5g ||
 	    !rtlpriv->mutex_for_power_on_off || !rtlpriv->mutex_for_hw_init) {

drivers/net/wireless/realtek/rtw88/sdio.c

···
 
 	for (i = 0; i < RTK_MAX_TX_QUEUE_NUM; i++)
 		skb_queue_head_init(&rtwsdio->tx_queue[i]);
-	rtwsdio->tx_handler_data = kmalloc_obj(*rtwsdio->tx_handler_data,
-					       GFP_KERNEL);
+	rtwsdio->tx_handler_data = kmalloc_obj(*rtwsdio->tx_handler_data);
 	if (!rtwsdio->tx_handler_data)
 		goto err_destroy_wq;
 

drivers/net/wireless/realtek/rtw89/usb.c

···
 	if (ret)
 		return ret;
 
-	rtwusb->vendor_req_buf = kmalloc_obj(*rtwusb->vendor_req_buf,
-					     GFP_KERNEL);
+	rtwusb->vendor_req_buf = kmalloc_obj(*rtwusb->vendor_req_buf);
 	if (!rtwusb->vendor_req_buf)
 		return -ENOMEM;
 

drivers/net/wireless/st/cw1200/debug.c

···
 int cw1200_debug_init(struct cw1200_common *priv)
 {
 	int ret = -ENOMEM;
-	struct cw1200_debug_priv *d = kzalloc_obj(struct cw1200_debug_priv,
-						  GFP_KERNEL);
+	struct cw1200_debug_priv *d = kzalloc_obj(struct cw1200_debug_priv);
 	priv->debug = d;
 	if (!d)
 		return ret;

drivers/net/wireless/st/cw1200/queue.c

···
 	spin_lock_init(&queue->lock);
 	timer_setup(&queue->gc, cw1200_queue_gc, 0);
 
-	queue->pool = kzalloc_objs(struct cw1200_queue_item, capacity,
-				   GFP_KERNEL);
+	queue->pool = kzalloc_objs(struct cw1200_queue_item, capacity);
 	if (!queue->pool)
 		return -ENOMEM;
 
-	queue->link_map_cache = kzalloc_objs(int, stats->map_capacity,
-					     GFP_KERNEL);
+	queue->link_map_cache = kzalloc_objs(int, stats->map_capacity);
 	if (!queue->link_map_cache) {
 		kfree(queue->pool);
 		queue->pool = NULL;

drivers/net/wireless/st/cw1200/scan.c

···
 			scan.type = WSM_SCAN_TYPE_BACKGROUND;
 			scan.flags = WSM_SCAN_FLAG_FORCE_BACKGROUND;
 		}
-		scan.ch = kzalloc_objs(struct wsm_scan_ch, it - priv->scan.curr,
-				       GFP_KERNEL);
+		scan.ch = kzalloc_objs(struct wsm_scan_ch, it - priv->scan.curr);
 		if (!scan.ch) {
 			priv->scan.status = -ENOMEM;
 			goto fail;

drivers/net/wireless/ti/wl1251/init.c

···
 	int ret;
 
 	/* asking for the data path parameters */
-	wl->data_path = kzalloc_obj(struct acx_data_path_params_resp,
-				    GFP_KERNEL);
+	wl->data_path = kzalloc_obj(struct acx_data_path_params_resp);
 	if (!wl->data_path)
 		return -ENOMEM;
 

drivers/net/wwan/iosm/iosm_ipc_protocol.c

···
 
 struct iosm_protocol *ipc_protocol_init(struct iosm_imem *ipc_imem)
 {
-	struct iosm_protocol *ipc_protocol = kzalloc_obj(*ipc_protocol,
-							 GFP_KERNEL);
+	struct iosm_protocol *ipc_protocol = kzalloc_obj(*ipc_protocol);
 	struct ipc_protocol_context_info *p_ci;
 	u64 addr;
 

drivers/net/xen-netfront.c

···
 	unsigned int i;
 	int ret;
 
-	info->queues = kzalloc_objs(struct netfront_queue, *num_queues,
-				    GFP_KERNEL);
+	info->queues = kzalloc_objs(struct netfront_queue, *num_queues);
 	if (!info->queues)
 		return -ENOMEM;
 

drivers/nvdimm/btt.c

···
 	struct log_entry log_new;
 	u32 i, map_entry, log_oldmap, log_newmap;
 
-	arena->freelist = kzalloc_objs(struct free_entry, arena->nfree,
-				       GFP_KERNEL);
+	arena->freelist = kzalloc_objs(struct free_entry, arena->nfree);
 	if (!arena->freelist)
 		return -ENOMEM;
 
···
 {
 	u32 i;
 
-	arena->map_locks = kzalloc_objs(struct aligned_lock, arena->nfree,
-					GFP_KERNEL);
+	arena->map_locks = kzalloc_objs(struct aligned_lock, arena->nfree);
 	if (!arena->map_locks)
 		return -ENOMEM;
 

drivers/nvdimm/nd_perf.c

···
 	}
 
 	/* Allocate memory for cpumask attribute group */
-	nvdimm_pmu_cpumask_group = kzalloc_obj(*nvdimm_pmu_cpumask_group,
-					       GFP_KERNEL);
+	nvdimm_pmu_cpumask_group = kzalloc_obj(*nvdimm_pmu_cpumask_group);
 	if (!nvdimm_pmu_cpumask_group) {
 		kfree(pmu_events_attr);
 		kfree(attrs_group);

drivers/nvdimm/region_devs.c

···
 	}
 
 	nd_region =
-		kzalloc_flex(*nd_region, mapping, ndr_desc->num_mappings,
-			     GFP_KERNEL);
+		kzalloc_flex(*nd_region, mapping, ndr_desc->num_mappings);
 
 	if (!nd_region)
 		return NULL;

drivers/nvme/host/auth.c

···
 	if (!ctrl->opts->dhchap_secret && !ctrl->opts->dhchap_ctrl_secret)
 		return 0;
 
-	ctrl->dhchap_ctxs = kvzalloc_objs(*chap, ctrl_max_dhchaps(ctrl),
-					  GFP_KERNEL);
+	ctrl->dhchap_ctxs = kvzalloc_objs(*chap, ctrl_max_dhchaps(ctrl));
 	if (!ctrl->dhchap_ctxs) {
 		ret = -ENOMEM;
 		goto err_free_dhchap_ctrl_secret;

drivers/nvme/host/rdma.c

···
 	ctrl->ctrl.kato = opts->kato;
 
 	ret = -ENOMEM;
-	ctrl->queues = kzalloc_objs(*ctrl->queues, ctrl->ctrl.queue_count,
-				    GFP_KERNEL);
+	ctrl->queues = kzalloc_objs(*ctrl->queues, ctrl->ctrl.queue_count);
 	if (!ctrl->queues)
 		goto out_free_ctrl;
 

drivers/nvme/host/tcp.c

···
 		goto out_free_ctrl;
 	}
 
-	ctrl->queues = kzalloc_objs(*ctrl->queues, ctrl->ctrl.queue_count,
-				    GFP_KERNEL);
+	ctrl->queues = kzalloc_objs(*ctrl->queues, ctrl->ctrl.queue_count);
 	if (!ctrl->queues) {
 		ret = -ENOMEM;
 		goto out_free_ctrl;

drivers/nvme/target/configfs.c

···
 	if (!port)
 		return ERR_PTR(-ENOMEM);
 
-	port->ana_state = kzalloc_objs(*port->ana_state, NVMET_MAX_ANAGRPS + 1,
-				       GFP_KERNEL);
+	port->ana_state = kzalloc_objs(*port->ana_state, NVMET_MAX_ANAGRPS + 1);
 	if (!port->ana_state) {
 		kfree(port);
 		return ERR_PTR(-ENOMEM);

drivers/nvme/target/core.c

···
 	if (!ctrl->changed_ns_list)
 		goto out_free_ctrl;
 
-	ctrl->sqs = kzalloc_objs(struct nvmet_sq *, subsys->max_qid + 1,
-				 GFP_KERNEL);
+	ctrl->sqs = kzalloc_objs(struct nvmet_sq *, subsys->max_qid + 1);
 	if (!ctrl->sqs)
 		goto out_free_changed_ns_list;
 
-	ctrl->cqs = kzalloc_objs(struct nvmet_cq *, subsys->max_qid + 1,
-				 GFP_KERNEL);
+	ctrl->cqs = kzalloc_objs(struct nvmet_cq *, subsys->max_qid + 1);
 	if (!ctrl->cqs)
 		goto out_free_sqs;
 

drivers/nvme/target/fc.c

···
 	struct nvmet_fc_ls_iod *iod;
 	int i;
 
-	iod = kzalloc_objs(struct nvmet_fc_ls_iod, NVMET_LS_CTX_COUNT,
-			   GFP_KERNEL);
+	iod = kzalloc_objs(struct nvmet_fc_ls_iod, NVMET_LS_CTX_COUNT);
 	if (!iod)
 		return -ENOMEM;
 

drivers/nvme/target/loop.c

···
 	ctrl->ctrl.kato = opts->kato;
 	ctrl->port = nvme_loop_find_port(&ctrl->ctrl);
 
-	ctrl->queues = kzalloc_objs(*ctrl->queues, opts->nr_io_queues + 1,
-				    GFP_KERNEL);
+	ctrl->queues = kzalloc_objs(*ctrl->queues, opts->nr_io_queues + 1);
 	if (!ctrl->queues)
 		goto out_uninit_ctrl;
 

drivers/nvme/target/pci-epf.c

···
 {
 	unsigned int qid;
 
-	ctrl->sq = kzalloc_objs(struct nvmet_pci_epf_queue, ctrl->nr_queues,
-				GFP_KERNEL);
+	ctrl->sq = kzalloc_objs(struct nvmet_pci_epf_queue, ctrl->nr_queues);
 	if (!ctrl->sq)
 		return -ENOMEM;
 
-	ctrl->cq = kzalloc_objs(struct nvmet_pci_epf_queue, ctrl->nr_queues,
-				GFP_KERNEL);
+	ctrl->cq = kzalloc_objs(struct nvmet_pci_epf_queue, ctrl->nr_queues);
 	if (!ctrl->cq) {
 		kfree(ctrl->sq);
 		ctrl->sq = NULL;

drivers/opp/core.c

···
 	if (opp_table->regulators)
 		return 0;
 
-	opp_table->regulators = kmalloc_objs(*opp_table->regulators, count,
-					     GFP_KERNEL);
+	opp_table->regulators = kmalloc_objs(*opp_table->regulators, count);
 	if (!opp_table->regulators)
 		return -ENOMEM;
 

drivers/opp/of.c

···
 	if (!count)
 		return 0;
 
-	opp->required_opps = kzalloc_objs(*opp->required_opps, count,
-					  GFP_KERNEL);
+	opp->required_opps = kzalloc_objs(*opp->required_opps, count);
 	if (!opp->required_opps)
 		return -ENOMEM;
 

drivers/pci/hotplug/cpqphp_nvram.c

···
 		}
 
 		while (numpmem--) {
-			p_mem_node = kmalloc_obj(struct pci_resource,
-						 GFP_KERNEL);
+			p_mem_node = kmalloc_obj(struct pci_resource);
 
 			if (!p_mem_node)
 				break;

drivers/pci/hotplug/cpqphp_pci.c

···
 			pci_bus_read_config_word(pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, &w_length);
 
 			if ((w_base <= w_length) && (save_command & 0x02)) {
-				p_mem_node = kmalloc_obj(*p_mem_node,
-							 GFP_KERNEL);
+				p_mem_node = kmalloc_obj(*p_mem_node);
 				if (!p_mem_node)
 					return -ENOMEM;
 
···
 						temp_register = base & 0xFFFFFFFE;
 						temp_register = (~temp_register) + 1;
 
-						io_node = kmalloc_obj(*io_node,
-								      GFP_KERNEL);
+						io_node = kmalloc_obj(*io_node);
 						if (!io_node)
 							return -ENOMEM;
 
···
 						temp_register = base & 0xFFFFFFF0;
 						temp_register = (~temp_register) + 1;
 
-						p_mem_node = kmalloc_obj(*p_mem_node,
-									 GFP_KERNEL);
+						p_mem_node = kmalloc_obj(*p_mem_node);
 						if (!p_mem_node)
 							return -ENOMEM;
 
···
 						temp_register = base & 0xFFFFFFF0;
 						temp_register = (~temp_register) + 1;
 
-						mem_node = kmalloc_obj(*mem_node,
-								       GFP_KERNEL);
+						mem_node = kmalloc_obj(*mem_node);
 						if (!mem_node)
 							return -ENOMEM;
 
···
 						temp_register = base & 0xFFFFFFFE;
 						temp_register = (~temp_register) + 1;
 
-						io_node = kmalloc_obj(*io_node,
-								      GFP_KERNEL);
+						io_node = kmalloc_obj(*io_node);
 						if (!io_node)
 							return -ENOMEM;
 
···
 						temp_register = base & 0xFFFFFFF0;
 						temp_register = (~temp_register) + 1;
 
-						p_mem_node = kmalloc_obj(*p_mem_node,
-									 GFP_KERNEL);
+						p_mem_node = kmalloc_obj(*p_mem_node);
 						if (!p_mem_node)
 							return -ENOMEM;
 
···
 						temp_register = base & 0xFFFFFFF0;
 						temp_register = (~temp_register) + 1;
 
-						mem_node = kmalloc_obj(*mem_node,
-								       GFP_KERNEL);
+						mem_node = kmalloc_obj(*mem_node);
 						if (!mem_node)
 							return -ENOMEM;
 

drivers/pci/hotplug/ibmphp_ebda.c

···
 			debug("now enter io table ---\n");
 			debug("rio blk id: %x\n", blk_id);
 
-			rio_table_ptr = kzalloc_obj(struct rio_table_hdr,
-						    GFP_KERNEL);
+			rio_table_ptr = kzalloc_obj(struct rio_table_hdr);
 			if (!rio_table_ptr) {
 				rc = -ENOMEM;
 				goto out;
···
 	list_for_each_entry(rio_detail_ptr, &rio_lo_head, rio_detail_list) {
 		opt_rio_lo_ptr = search_opt_lo(rio_detail_ptr->chassis_num);
 		if (!opt_rio_lo_ptr) {
-			opt_rio_lo_ptr = kzalloc_obj(struct opt_rio_lo,
-						     GFP_KERNEL);
+			opt_rio_lo_ptr = kzalloc_obj(struct opt_rio_lo);
 			if (!opt_rio_lo_ptr)
 				return -ENOMEM;
 			opt_rio_lo_ptr->rio_type = rio_detail_ptr->rio_type;
···
 
 			bus_info_ptr2 = ibmphp_find_same_bus_num(slot_ptr->slot_bus_num);
 			if (!bus_info_ptr2) {
-				bus_info_ptr1 = kzalloc_obj(struct bus_info,
-							    GFP_KERNEL);
+				bus_info_ptr1 = kzalloc_obj(struct bus_info);
 				if (!bus_info_ptr1) {
 					rc = -ENOMEM;
 					goto error_no_slot;

drivers/pci/hotplug/ibmphp_pci.c

···
 						cleanup_count = 6;
 						goto error;
 					}
-					newfunc = kzalloc_obj(*newfunc,
-							      GFP_KERNEL);
+					newfunc = kzalloc_obj(*newfunc);
 					if (!newfunc)
 						return -ENOMEM;
 
···
 					flag = 0;
 					for (i = 0; i < 32; i++) {
 						if (func->devices[i]) {
-							newfunc = kzalloc_obj(*newfunc,
-									      GFP_KERNEL);
+							newfunc = kzalloc_obj(*newfunc);
 							if (!newfunc)
 								return -ENOMEM;
 
···
 						}
 					}
 
-					newfunc = kzalloc_obj(*newfunc,
-							      GFP_KERNEL);
+					newfunc = kzalloc_obj(*newfunc);
 					if (!newfunc)
 						return -ENOMEM;
 
···
 					for (i = 0; i < 32; i++) {
 						if (func->devices[i]) {
 							debug("inside for loop, device is %x\n", i);
-							newfunc = kzalloc_obj(*newfunc,
-									      GFP_KERNEL);
+							newfunc = kzalloc_obj(*newfunc);
 							if (!newfunc)
 								return -ENOMEM;
 
···
 
 			debug("len[count] in IO %x, count %d\n", len[count], count);
 
-			io[count] = kzalloc_obj(struct resource_node,
-						GFP_KERNEL);
+			io[count] = kzalloc_obj(struct resource_node);
 
 			if (!io[count])
 				return -ENOMEM;
···
 
 				debug("len[count] in PFMEM %x, count %d\n", len[count], count);
 
-				pfmem[count] = kzalloc_obj(struct resource_node,
-							   GFP_KERNEL);
+				pfmem[count] = kzalloc_obj(struct resource_node);
 				if (!pfmem[count])
 					return -ENOMEM;
 
···
 					ibmphp_add_resource(pfmem[count]);
 					func->pfmem[count] = pfmem[count];
 				} else {
-					mem_tmp = kzalloc_obj(*mem_tmp,
-							      GFP_KERNEL);
+					mem_tmp = kzalloc_obj(*mem_tmp);
 					if (!mem_tmp) {
 						kfree(pfmem[count]);
 						return -ENOMEM;
···
 
 				debug("len[count] in Mem %x, count %d\n", len[count], count);
 
-				mem[count] = kzalloc_obj(struct resource_node,
-							 GFP_KERNEL);
+				mem[count] = kzalloc_obj(struct resource_node);
 				if (!mem[count])
 					return -ENOMEM;
 
···
 
 			debug("len[count] in IO = %x\n", len[count]);
 
-			bus_io[count] = kzalloc_obj(struct resource_node,
-						    GFP_KERNEL);
+			bus_io[count] = kzalloc_obj(struct resource_node);
 
 			if (!bus_io[count]) {
 				retval = -ENOMEM;
···
 
 				debug("len[count] in PFMEM = %x\n", len[count]);
 
-				bus_pfmem[count] = kzalloc_obj(struct resource_node,
-							       GFP_KERNEL);
+				bus_pfmem[count] = kzalloc_obj(struct resource_node);
 				if (!bus_pfmem[count]) {
 					retval = -ENOMEM;
 					goto error;
···
 					ibmphp_add_resource(bus_pfmem[count]);
 					func->pfmem[count] = bus_pfmem[count];
 				} else {
-					mem_tmp = kzalloc_obj(*mem_tmp,
-							      GFP_KERNEL);
+					mem_tmp = kzalloc_obj(*mem_tmp);
 					if (!mem_tmp) {
 						retval = -ENOMEM;
 						goto error;
···
 
 				debug("len[count] in Memory is %x\n", len[count]);
 
-				bus_mem[count] = kzalloc_obj(struct resource_node,
-							     GFP_KERNEL);
+				bus_mem[count] = kzalloc_obj(struct resource_node);
 				if (!bus_mem[count]) {
 					retval = -ENOMEM;
 					goto error;

drivers/pci/hotplug/ibmphp_res.c

···
 
 				bus_cur->firstPFMemFromMem = pfmem_cur;
 
-				mem = kzalloc_obj(struct resource_node,
-						  GFP_KERNEL);
+				mem = kzalloc_obj(struct resource_node);
 				if (!mem)
 					return -ENOMEM;
 
···
 						end_address |= (upper_io_end << 16);
 
 						if ((start_address) && (start_address <= end_address)) {
-							range = kzalloc_obj(struct range_node,
-									    GFP_KERNEL);
+							range = kzalloc_obj(struct range_node);
 							if (!range)
 								return -ENOMEM;
 
···
 							fix_resources(bus_sec);
 
 							if (ibmphp_find_resource(bus_cur, start_address, &io, IO)) {
-								io = kzalloc_obj(struct resource_node,
-										 GFP_KERNEL);
+								io = kzalloc_obj(struct resource_node);
 								if (!io) {
 									kfree(range);
 									return -ENOMEM;
···
 
 						if ((start_address) && (start_address <= end_address)) {
 
-							range = kzalloc_obj(struct range_node,
-									    GFP_KERNEL);
+							range = kzalloc_obj(struct range_node);
 							if (!range)
 								return -ENOMEM;
 
···
 							fix_resources(bus_sec);
 
 							if (ibmphp_find_resource(bus_cur, start_address, &mem, MEM)) {
-								mem = kzalloc_obj(struct resource_node,
-										  GFP_KERNEL);
+								mem = kzalloc_obj(struct resource_node);
 								if (!mem) {
 									kfree(range);
 									return -ENOMEM;
···
 
 						if ((start_address) && (start_address <= end_address)) {
 
-							range = kzalloc_obj(struct range_node,
-									    GFP_KERNEL);
+							range = kzalloc_obj(struct range_node);
 							if (!range)
 								return -ENOMEM;
 
···
 
 							fix_resources(bus_sec);
 							if (ibmphp_find_resource(bus_cur, start_address, &pfmem, PFMEM)) {
-								pfmem = kzalloc_obj(struct resource_node,
-										    GFP_KERNEL);
+								pfmem = kzalloc_obj(struct resource_node);
 								if (!pfmem) {
 									kfree(range);
 									return -ENOMEM;

drivers/perf/riscv_pmu_sbi.c

···
 	int i, j, k, result = 0, count = 0;
 	struct sbiret ret;
 
-	event_info_shmem = kzalloc_objs(*event_info_shmem, num_events,
-					GFP_KERNEL);
+	event_info_shmem = kzalloc_objs(*event_info_shmem, num_events);
 	if (!event_info_shmem)
 		return -ENOMEM;
 

drivers/pinctrl/bcm/pinctrl-bcm2835.c

···
 		maps_per_pin++;
 	if (num_pulls)
 		maps_per_pin++;
-	cur_map = maps = kzalloc_objs(*maps, num_pins * maps_per_pin,
-				      GFP_KERNEL);
+	cur_map = maps = kzalloc_objs(*maps, num_pins * maps_per_pin);
 	if (!maps)
 		return -ENOMEM;
 

drivers/pinctrl/berlin/berlin.c

···
 	}
 
 	/* we will reallocate later */
-	pctrl->functions = kzalloc_objs(*pctrl->functions, max_functions,
-					GFP_KERNEL);
+	pctrl->functions = kzalloc_objs(*pctrl->functions, max_functions);
 	if (!pctrl->functions)
 		return -ENOMEM;
 

drivers/pinctrl/pinctrl-apple-gpio.c

···
 		girq->parents = kmalloc_array(girq->num_parents,
 					      sizeof(*girq->parents),
 					      GFP_KERNEL);
-		irq_data = kmalloc_objs(*irq_data, girq->num_parents,
-					GFP_KERNEL);
+		irq_data = kmalloc_objs(*irq_data, girq->num_parents);
 		if (!girq->parents || !irq_data) {
 			ret = -ENOMEM;
 			goto out_free_irq_data;

drivers/pinctrl/sunxi/pinctrl-sunxi.c

···
 	 * special functions per pin, plus one entry for the sentinel.
 	 * We'll reallocate that later anyway.
 	 */
-	pctl->functions = kzalloc_objs(*pctl->functions, 7 * pctl->ngroups + 4,
-				       GFP_KERNEL);
+	pctl->functions = kzalloc_objs(*pctl->functions, 7 * pctl->ngroups + 4);
 	if (!pctl->functions)
 		return -ENOMEM;
 

drivers/pinctrl/vt8500/pinctrl-wmt.c

···
 	if (num_pulls)
 		maps_per_pin++;
 
-	cur_map = maps = kzalloc_objs(*maps, num_pins * maps_per_pin,
-				      GFP_KERNEL);
+	cur_map = maps = kzalloc_objs(*maps, num_pins * maps_per_pin);
 	if (!maps)
 		return -ENOMEM;
 

drivers/platform/chrome/chromeos_laptop.c

···
 	if (!n_peripherals)
 		return 0;
 
-	acpi_peripherals = kzalloc_objs(*src->acpi_peripherals, n_peripherals,
-					GFP_KERNEL);
+	acpi_peripherals = kzalloc_objs(*src->acpi_peripherals, n_peripherals);
 	if (!acpi_peripherals)
 		return -ENOMEM;
 

drivers/platform/x86/asus-armoury.c

···
 	/* Initialize AC power tunables */
 	ac_limits = power_data->ac_data;
 	if (ac_limits) {
-		ac_rog_tunables = kzalloc_obj(*asus_armoury.rog_tunables[ASUS_ROG_TUNABLE_AC],
-					      GFP_KERNEL);
+		ac_rog_tunables = kzalloc_obj(*asus_armoury.rog_tunables[ASUS_ROG_TUNABLE_AC]);
 		if (!ac_rog_tunables)
 			goto err_nomem;
 
···
 	/* Initialize DC power tunables */
 	dc_limits = power_data->dc_data;
 	if (dc_limits) {
-		dc_rog_tunables = kzalloc_obj(*asus_armoury.rog_tunables[ASUS_ROG_TUNABLE_DC],
-					      GFP_KERNEL);
+		dc_rog_tunables = kzalloc_obj(*asus_armoury.rog_tunables[ASUS_ROG_TUNABLE_DC]);
 		if (!dc_rog_tunables) {
 			kfree(ac_rog_tunables);
 			goto err_nomem;

drivers/platform/x86/dell/dell-smbios-base.c

···
 		return -ENOMEM;
 
 	/* need to store both location and value + terminator*/
-	token_attrs = kzalloc_objs(*token_attrs, (2 * da_num_tokens) + 1,
-				   GFP_KERNEL);
+	token_attrs = kzalloc_objs(*token_attrs, (2 * da_num_tokens) + 1);
 	if (!token_attrs)
 		goto out_allocate_attrs;
 

drivers/platform/x86/intel/int3472/tps68470.c

···
 		if (!board_data)
 			return dev_err_probe(&client->dev, -ENODEV, "No board-data found for this model\n");
 
-		cells = kzalloc_objs(*cells, TPS68470_WIN_MFD_CELL_COUNT,
-				     GFP_KERNEL);
+		cells = kzalloc_objs(*cells, TPS68470_WIN_MFD_CELL_COUNT);
 		if (!cells)
 			return -ENOMEM;
 

drivers/platform/x86/intel/speed_select_if/isst_if_common.c

···
 {
 	int ret;
 
-	isst_cpu_info = kzalloc_objs(*isst_cpu_info, num_possible_cpus(),
-				     GFP_KERNEL);
+	isst_cpu_info = kzalloc_objs(*isst_cpu_info, num_possible_cpus());
 	if (!isst_cpu_info)
 		return -ENOMEM;
 
-	isst_pkg_info = kzalloc_objs(*isst_pkg_info, topology_max_packages(),
-				     GFP_KERNEL);
+	isst_pkg_info = kzalloc_objs(*isst_pkg_info, topology_max_packages());
 	if (!isst_pkg_info) {
 		kfree(isst_cpu_info);
 		return -ENOMEM;

drivers/platform/x86/intel/uncore-frequency/uncore-frequency.c

···
 
 	uncore_max_entries = topology_max_packages() *
 					topology_max_dies_per_package();
-	uncore_instances = kzalloc_objs(*uncore_instances, uncore_max_entries,
-					GFP_KERNEL);
+	uncore_instances = kzalloc_objs(*uncore_instances, uncore_max_entries);
 	if (!uncore_instances)
 		return -ENOMEM;
 

drivers/platform/x86/sony-laptop.c

···
 	case ACPI_RESOURCE_TYPE_START_DEPENDENT:
 		{
 			/* start IO enumeration */
-			struct sony_pic_ioport *ioport = kzalloc_obj(*ioport,
-								     GFP_KERNEL);
+			struct sony_pic_ioport *ioport = kzalloc_obj(*ioport);
 			if (!ioport)
 				return AE_ERROR;
 

drivers/platform/x86/uv_sysfs.c

···
 	u64 sz;
 	int i, ret;
 
-	prev_obj_to_cnode = kmalloc_objs(*prev_obj_to_cnode, uv_bios_obj_cnt,
-					 GFP_KERNEL);
+	prev_obj_to_cnode = kmalloc_objs(*prev_obj_to_cnode, uv_bios_obj_cnt);
 	if (!prev_obj_to_cnode)
 		return -ENOMEM;
 
···
 	}
 	for (j = 0; j < uv_bios_obj_cnt; j++) {
 		for (k = 0; k < hub_buf[j].ports; k++) {
-			uv_hubs[j]->ports[k] = kzalloc_obj(*uv_hubs[j]->ports[k],
-							   GFP_KERNEL);
+			uv_hubs[j]->ports[k] = kzalloc_obj(*uv_hubs[j]->ports[k]);
 			if (!uv_hubs[j]->ports[k]) {
 				ret = -ENOMEM;
 				k--;
···
 			}
 			num_pci_lines = l;
 
-			uv_pci_objs = kzalloc_objs(*uv_pci_objs, num_pci_lines,
-						   GFP_KERNEL);
+			uv_pci_objs = kzalloc_objs(*uv_pci_objs, num_pci_lines);
 			if (!uv_pci_objs) {
 				kfree(pci_top_str);
 				ret = -ENOMEM;
···
 			}
 			start = pci_top_str;
 			while ((found = strsep(&start, "\n")) != NULL) {
-				uv_pci_objs[k] = kzalloc_obj(*uv_pci_objs[k],
-							     GFP_KERNEL);
+				uv_pci_objs[k] = kzalloc_obj(*uv_pci_objs[k]);
 				if (!uv_pci_objs[k]) {
 					ret = -ENOMEM;
 					goto err_pci_obj;

drivers/platform/x86/x86-android-tablets/core.c

···
 		exit_handler = dev_info->exit;
 	}
 
-	i2c_clients = kzalloc_objs(*i2c_clients, dev_info->i2c_client_count,
-				   GFP_KERNEL);
+	i2c_clients = kzalloc_objs(*i2c_clients, dev_info->i2c_client_count);
 	if (!i2c_clients) {
 		x86_android_tablet_remove(pdev);
 		return -ENOMEM;

drivers/powercap/intel_rapl_common.c

···
 	}
 	pr_debug("found %d domains on %s\n", rp->nr_domains, rp->name);
 
-	rp->domains = kzalloc_objs(struct rapl_domain, rp->nr_domains,
-				   GFP_KERNEL);
+	rp->domains = kzalloc_objs(struct rapl_domain, rp->nr_domains);
 	if (!rp->domains)
 		return -ENOMEM;
 

drivers/regulator/of_regulator.c

···
 	}
 	if (num_consumers == 0)
 		return 0;
-	_consumers = kmalloc_objs(struct regulator_bulk_data, num_consumers,
-				  GFP_KERNEL);
+	_consumers = kmalloc_objs(struct regulator_bulk_data, num_consumers);
 	if (!_consumers)
 		return -ENOMEM;
 	goto restart;

drivers/s390/block/dcssblk.c

···
 	if (dev_info->num_of_segments <= 1)
 		return 0;
 
-	sort_list = kzalloc_objs(struct segment_info, dev_info->num_of_segments,
-				 GFP_KERNEL);
+	sort_list = kzalloc_objs(struct segment_info, dev_info->num_of_segments);
 	if (sort_list == NULL)
 		return -ENOMEM;
 	i = 0;
···
 		 * get a struct dcssblk_dev_info
 		 */
 		if (num_of_segments == 0) {
-			dev_info = kzalloc_obj(struct dcssblk_dev_info,
-					       GFP_KERNEL);
+			dev_info = kzalloc_obj(struct dcssblk_dev_info);
 			if (dev_info == NULL) {
 				rc = -ENOMEM;
 				goto out;

drivers/s390/block/scm_blk.c

···
 	if (!scmrq->aob)
 		goto free;
 
-	scmrq->request = kzalloc_objs(scmrq->request[0], nr_requests_per_io,
-				      GFP_KERNEL);
+	scmrq->request = kzalloc_objs(scmrq->request[0], nr_requests_per_io);
 	if (!scmrq->request)
 		goto free;
 

drivers/s390/char/con3270.c

···
 	if (!screen)
 		goto out_err;
 	for (lines = 0; lines < allocated; lines++) {
-		screen[lines].cells = kzalloc_objs(struct tty3270_cell, cols,
-						   GFP_KERNEL);
+		screen[lines].cells = kzalloc_objs(struct tty3270_cell, cols);
 		if (!screen[lines].cells)
 			goto out_screen;
 	}

drivers/s390/cio/css.c

···
 		goto out_err;
 	}
 
-	css->pseudo_subchannel = kzalloc_obj(*css->pseudo_subchannel,
-					     GFP_KERNEL);
+	css->pseudo_subchannel = kzalloc_obj(*css->pseudo_subchannel);
 	if (!css->pseudo_subchannel) {
 		device_unregister(&css->device);
 		ret = -ENOMEM;

drivers/s390/cio/qdio_thinint.c

···
 {
 	int rc;
 
-	q_indicators = kzalloc_objs(struct indicator_t, TIQDIO_NR_INDICATORS,
-				    GFP_KERNEL);
+	q_indicators = kzalloc_objs(struct indicator_t, TIQDIO_NR_INDICATORS);
 	if (!q_indicators)
 		return -ENOMEM;
 

drivers/s390/cio/vfio_ccw_ops.c

···
 	INIT_WORK(&private->io_work, vfio_ccw_sch_io_todo);
 	INIT_WORK(&private->crw_work, vfio_ccw_crw_todo);
 
-	private->cp.guest_cp = kzalloc_objs(struct ccw1, CCWCHAIN_LEN_MAX,
-					    GFP_KERNEL);
+	private->cp.guest_cp = kzalloc_objs(struct ccw1, CCWCHAIN_LEN_MAX);
 	if (!private->cp.guest_cp)
 		goto out_free_private;
 

drivers/scsi/53c700.c

···
 STATIC int
 NCR_700_sdev_init(struct scsi_device *SDp)
 {
-	SDp->hostdata = kzalloc_obj(struct NCR_700_Device_Parameters,
-				    GFP_KERNEL);
+	SDp->hostdata = kzalloc_obj(struct NCR_700_Device_Parameters);
 
 	if (!SDp->hostdata)
 		return -ENOMEM;

drivers/scsi/BusLogic.c

···
 	if (blogic_probe_options.noprobe)
 		return -ENODEV;
 	blogic_probeinfo_list =
-	    kzalloc_objs(struct blogic_probeinfo, BLOGIC_MAX_ADAPTERS,
-			 GFP_KERNEL);
+	    kzalloc_objs(struct blogic_probeinfo, BLOGIC_MAX_ADAPTERS);
 	if (blogic_probeinfo_list == NULL) {
 		blogic_err("BusLogic: Unable to allocate Probe Info List\n",
 				NULL);

drivers/scsi/aacraid/linit.c

···
 	if (aac_reset_devices || reset_devices)
 		aac->init_reset = true;
 
-	aac->fibs = kzalloc_objs(struct fib, shost->can_queue + AAC_NUM_MGT_FIB,
-				 GFP_KERNEL);
+	aac->fibs = kzalloc_objs(struct fib, shost->can_queue + AAC_NUM_MGT_FIB);
 	if (!aac->fibs) {
 		error = -ENOMEM;
 		goto out_free_host;

drivers/scsi/be2iscsi/be_main.c

···
 		return -ENOMEM;
 	}
 
-	mem_arr_orig = kmalloc_objs(*mem_arr_orig, BEISCSI_MAX_FRAGS_INIT,
-				    GFP_KERNEL);
+	mem_arr_orig = kmalloc_objs(*mem_arr_orig, BEISCSI_MAX_FRAGS_INIT);
 	if (!mem_arr_orig) {
 		kfree(phba->init_mem);
 		kfree(phwi_ctrlr->wrb_context);
···
 	idx = 0;
 	mem_descr = phba->init_mem;
 	mem_descr += HWI_MEM_WRB;
-	pwrb_arr = kmalloc_objs(*pwrb_arr, phba->params.cxns_per_ctrl,
-				GFP_KERNEL);
+	pwrb_arr = kmalloc_objs(*pwrb_arr, phba->params.cxns_per_ctrl);
 	if (!pwrb_arr) {
 		beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
 			    "BM_%d : Memory alloc failed in create wrb ring.\n");
···
 
 	for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++) {
 		if (test_bit(ulp_num, (void *)&phba->fw_config.ulp_supported)) {
-			ptr_cid_info = kzalloc_obj(struct ulp_cid_info,
-						   GFP_KERNEL);
+			ptr_cid_info = kzalloc_obj(struct ulp_cid_info);
 
 			if (!ptr_cid_info) {
 				ret = -ENOMEM;

drivers/scsi/bnx2fc/bnx2fc_fcoe.c

···
 	hba->next_conn_id = 0;
 
 	hba->tgt_ofld_list =
-		kzalloc_objs(struct bnx2fc_rport *, BNX2FC_NUM_MAX_SESS,
-			     GFP_KERNEL);
+		kzalloc_objs(struct bnx2fc_rport *, BNX2FC_NUM_MAX_SESS);
 	if (!hba->tgt_ofld_list) {
 		printk(KERN_ERR PFX "Unable to allocate tgt offload list\n");
 		goto tgtofld_err;

drivers/scsi/bnx2fc/bnx2fc_io.c

···
 		goto mem_err;
 	}
 
-	cmgr->free_list_lock = kzalloc_objs(*cmgr->free_list_lock, arr_sz,
-					    GFP_KERNEL);
+	cmgr->free_list_lock = kzalloc_objs(*cmgr->free_list_lock, arr_sz);
 	if (!cmgr->free_list_lock) {
 		printk(KERN_ERR PFX "failed to alloc free_list_lock\n");
 		kfree(cmgr->free_list);

drivers/scsi/csiostor/csio_lnode.c

···
 			ln->fcfinfo = pln->fcfinfo;
 		} else {
 			/* Another non-root physical lnode (FCF) */
-			ln->fcfinfo = kzalloc_obj(struct csio_fcf_info,
-						  GFP_KERNEL);
+			ln->fcfinfo = kzalloc_obj(struct csio_fcf_info);
 			if (!ln->fcfinfo) {
 				csio_ln_err(ln, "Failed to alloc FCF info\n");
 				CSIO_INC_STATS(hw, n_err_nomem);

drivers/scsi/elx/efct/efct_hw.c

···
 		for (i = 0; i < hw->hw_rq_count; i++)
 			count += hw->hw_rq[i]->entry_count;
 
-		hw->seq_pool = kmalloc_objs(struct efc_hw_sequence, count,
-					    GFP_KERNEL);
+		hw->seq_pool = kmalloc_objs(struct efc_hw_sequence, count);
 		if (!hw->seq_pool)
 			return -ENOMEM;
 	}

drivers/scsi/esas2r/esas2r_init.c

···
 static bool alloc_vda_req(struct esas2r_adapter *a,
 			  struct esas2r_request *rq)
 {
-	struct esas2r_mem_desc *memdesc = kzalloc_obj(struct esas2r_mem_desc,
-						      GFP_KERNEL);
+	struct esas2r_mem_desc *memdesc = kzalloc_obj(struct esas2r_mem_desc);
 
 	if (memdesc == NULL) {
 		esas2r_hdebug("could not alloc mem for vda request memdesc\n");
···
 	}
 
 	/* allocate the S/G list memory descriptors */
-	a->sg_list_mds = kzalloc_objs(struct esas2r_mem_desc, num_sg_lists,
-				      GFP_KERNEL);
+	a->sg_list_mds = kzalloc_objs(struct esas2r_mem_desc, num_sg_lists);
 
 	if (a->sg_list_mds == NULL) {
 		esas2r_log(ESAS2R_LOG_CRIT,

drivers/scsi/ibmvscsi/ibmvfc.c

···
 	int i, j;
 	int rc = 0;
 
-	channels->scrqs = kzalloc_objs(*channels->scrqs, channels->max_queues,
-				       GFP_KERNEL);
+	channels->scrqs = kzalloc_objs(*channels->scrqs, channels->max_queues);
 	if (!channels->scrqs)
 		return -ENOMEM;
 

drivers/scsi/ipr.c

···
 
 	ioa_cfg->ipr_cmnd_list = kzalloc_objs(struct ipr_cmnd *,
 					      IPR_NUM_CMD_BLKS, GFP_KERNEL);
-	ioa_cfg->ipr_cmnd_list_dma = kzalloc_objs(dma_addr_t, IPR_NUM_CMD_BLKS,
-						  GFP_KERNEL);
+	ioa_cfg->ipr_cmnd_list_dma = kzalloc_objs(dma_addr_t, IPR_NUM_CMD_BLKS);
 
 	if (!ioa_cfg->ipr_cmnd_list || !ioa_cfg->ipr_cmnd_list_dma) {
 		ipr_free_cmd_blks(ioa_cfg);

drivers/scsi/lpfc/lpfc_els.c

···
 
 	if (!vport->qfpa_res) {
 		max_desc = FCELSSIZE / sizeof(*vport->qfpa_res);
-		vport->qfpa_res = kzalloc_objs(*vport->qfpa_res, max_desc,
-					       GFP_KERNEL);
+		vport->qfpa_res = kzalloc_objs(*vport->qfpa_res, max_desc);
 		if (!vport->qfpa_res)
 			goto out;
 	}
···
 	desc = (struct priority_range_desc *)(pcmd + 8);
 	vmid_range = vport->vmid_priority.vmid_range;
 	if (!vmid_range) {
-		vmid_range = kzalloc_objs(*vmid_range, MAX_PRIORITY_DESC,
-					  GFP_KERNEL);
+		vmid_range = kzalloc_objs(*vmid_range, MAX_PRIORITY_DESC);
 		if (!vmid_range) {
 			kfree(vport->qfpa_res);
 			goto out;

drivers/scsi/lpfc/lpfc_init.c

···
 
 	if (lpfc_is_vmid_enabled(phba)) {
 		vport->vmid =
-		    kzalloc_objs(struct lpfc_vmid, phba->cfg_max_vmid,
-				 GFP_KERNEL);
+		    kzalloc_objs(struct lpfc_vmid, phba->cfg_max_vmid);
 		if (!vport->vmid)
 			return -ENOMEM;
 

drivers/scsi/lpfc/lpfc_mbox.c

···
 	pcount = (pcount > LPFC_SLI4_MBX_SGE_MAX_PAGES) ?
 				LPFC_SLI4_MBX_SGE_MAX_PAGES : pcount;
 	/* Allocate record for keeping SGE virtual addresses */
-	mbox->sge_array = kzalloc_obj(struct lpfc_mbx_nembed_sge_virt,
-				      GFP_KERNEL);
+	mbox->sge_array = kzalloc_obj(struct lpfc_mbx_nembed_sge_virt);
 	if (!mbox->sge_array) {
 		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
 				"2527 Failed to allocate non-embedded SGE "

drivers/scsi/lpfc/lpfc_mem.c

···
 	if (!phba->lpfc_mbuf_pool)
 		goto fail;
 
-	pool->elements = kmalloc_objs(struct lpfc_dmabuf, LPFC_MBUF_POOL_SIZE,
-				      GFP_KERNEL);
+	pool->elements = kmalloc_objs(struct lpfc_dmabuf, LPFC_MBUF_POOL_SIZE);
 	if (!pool->elements)
 		goto fail_free_lpfc_mbuf_pool;
 

drivers/scsi/lpfc/lpfc_sli.c

···
 int lpfc_rx_monitor_create_ring(struct lpfc_rx_info_monitor *rx_monitor,
 				u32 entries)
 {
-	rx_monitor->ring = kmalloc_objs(struct rx_info_entry, entries,
-					GFP_KERNEL);
+	rx_monitor->ring = kmalloc_objs(struct rx_info_entry, entries);
 	if (!rx_monitor->ring)
 		return -ENOMEM;
 

drivers/scsi/lpfc/lpfc_vport.c

···
 	struct lpfc_vport *port_iterator;
 	struct lpfc_vport **vports;
 	int index = 0;
-	vports = kzalloc_objs(struct lpfc_vport *, phba->max_vports + 1,
-			      GFP_KERNEL);
+	vports = kzalloc_objs(struct lpfc_vport *, phba->max_vports + 1);
 	if (vports == NULL)
 		return NULL;
 	spin_lock_irq(&phba->port_list_lock);

drivers/scsi/megaraid/megaraid_mm.c

···
 	 * Allocate single blocks of memory for all required kiocs,
 	 * mailboxes and passthru structures.
 	 */
-	adapter->kioc_list	= kmalloc_objs(uioc_t, lld_adp->max_kioc,
-						 GFP_KERNEL);
-	adapter->mbox_list	= kmalloc_objs(mbox64_t, lld_adp->max_kioc,
-						 GFP_KERNEL);
+	adapter->kioc_list	= kmalloc_objs(uioc_t, lld_adp->max_kioc);
+	adapter->mbox_list	= kmalloc_objs(mbox64_t, lld_adp->max_kioc);
 	adapter->pthru_dma_pool = dma_pool_create("megaraid mm pthru pool",
 						&adapter->pdev->dev,
 						sizeof(mraid_passthru_t),

drivers/scsi/megaraid/megaraid_sas_base.c

···
 	 * Allocate the dynamic array first and then allocate individual
 	 * commands.
 	 */
-	instance->cmd_list = kzalloc_objs(struct megasas_cmd *, max_cmd,
-					  GFP_KERNEL);
+	instance->cmd_list = kzalloc_objs(struct megasas_cmd *, max_cmd);
 
 	if (!instance->cmd_list) {
 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "out of memory\n");
···
 	}
 
 	for (i = 0; i < max_cmd; i++) {
-		instance->cmd_list[i] = kmalloc_obj(struct megasas_cmd,
-						    GFP_KERNEL);
+		instance->cmd_list[i] = kmalloc_obj(struct megasas_cmd);
 
 		if (!instance->cmd_list[i]) {
 

drivers/scsi/megaraid/megaraid_sas_fusion.c

···
 	 * commands.
 	 */
 	fusion->cmd_list =
-		kzalloc_objs(struct megasas_cmd_fusion *, max_mpt_cmd,
-			     GFP_KERNEL);
+		kzalloc_objs(struct megasas_cmd_fusion *, max_mpt_cmd);
 	if (!fusion->cmd_list) {
 		dev_err(&instance->pdev->dev,
 			"Failed from %s %d\n",  __func__, __LINE__);
···
 	}
 
 	for (i = 0; i < max_mpt_cmd; i++) {
-		fusion->cmd_list[i] = kzalloc_obj(struct megasas_cmd_fusion,
-						  GFP_KERNEL);
+		fusion->cmd_list[i] = kzalloc_obj(struct megasas_cmd_fusion);
 		if (!fusion->cmd_list[i]) {
 			for (j = 0; j < i; j++)
 				kfree(fusion->cmd_list[j]);

drivers/scsi/mpi3mr/mpi3mr_fw.c

···
 	    num_queues);
 
 	if (!mrioc->req_qinfo) {
-		mrioc->req_qinfo = kzalloc_objs(struct op_req_qinfo, num_queues,
-						GFP_KERNEL);
+		mrioc->req_qinfo = kzalloc_objs(struct op_req_qinfo, num_queues);
 		if (!mrioc->req_qinfo) {
 			retval = -1;
 			goto out_failed;

drivers/scsi/mpi3mr/mpi3mr_transport.c

···
 	mrioc->sas_hba.host_node = 1;
 	INIT_LIST_HEAD(&mrioc->sas_hba.sas_port_list);
 	mrioc->sas_hba.parent_dev = &mrioc->shost->shost_gendev;
-	mrioc->sas_hba.phy = kzalloc_objs(struct mpi3mr_sas_phy, num_phys,
-					  GFP_KERNEL);
+	mrioc->sas_hba.phy = kzalloc_objs(struct mpi3mr_sas_phy, num_phys);
 	if (!mrioc->sas_hba.phy)
 		return;
 

drivers/scsi/mpt3sas/mpt3sas_base.c

···
 		sizeof(Mpi2DefaultReplyDescriptor_t);
 	int count = ioc->rdpq_array_enable ? ioc->reply_queue_count : 1;
 
-	ioc->reply_post = kzalloc_objs(struct reply_post_struct, count,
-				       GFP_KERNEL);
+	ioc->reply_post = kzalloc_objs(struct reply_post_struct, count);
 	if (!ioc->reply_post)
 		return -ENOMEM;
 	/*

drivers/scsi/mpt3sas/mpt3sas_ctl.c

···
 	rc = min(sizeof(struct SL_WH_MASTER_TRIGGER_T), count);
 
 	if (ioc->supports_trigger_pages) {
-		master_tg = kzalloc_obj(struct SL_WH_MASTER_TRIGGER_T,
-					GFP_KERNEL);
+		master_tg = kzalloc_obj(struct SL_WH_MASTER_TRIGGER_T);
 		if (!master_tg)
 			return -ENOMEM;
 
···
 
 	sz = min(sizeof(struct SL_WH_EVENT_TRIGGERS_T), count);
 	if (ioc->supports_trigger_pages) {
-		event_tg = kzalloc_obj(struct SL_WH_EVENT_TRIGGERS_T,
-				       GFP_KERNEL);
+		event_tg = kzalloc_obj(struct SL_WH_EVENT_TRIGGERS_T);
 		if (!event_tg)
 			return -ENOMEM;
 

drivers/scsi/mpt3sas/mpt3sas_scsih.c

···
 				port_id = sas_iounit_pg0->PhyData[i].Port;
 				mport = mpt3sas_get_port_by_id(ioc, port_id, 1);
 				if (!mport) {
-					mport = kzalloc_obj(struct hba_port,
-							    GFP_KERNEL);
+					mport = kzalloc_obj(struct hba_port);
 					if (!mport)
 						break;
 					mport->port_id = port_id;
···
 	}
 	ioc->sas_hba.num_phys = num_phys;
 
-	port_table = kzalloc_objs(struct hba_port, ioc->sas_hba.num_phys,
-				  GFP_KERNEL);
+	port_table = kzalloc_objs(struct hba_port, ioc->sas_hba.num_phys);
 	if (!port_table)
 		return;
 

drivers/scsi/mvumi.c

···
 			found = mvumi_match_devices(mhba, id, wwid);
 			if (!found) {
 				mvumi_remove_devices(mhba, id);
-				mv_dev = kzalloc_obj(struct mvumi_device,
-						     GFP_KERNEL);
+				mv_dev = kzalloc_obj(struct mvumi_device);
 				if (!mv_dev) {
 					dev_err(&mhba->pdev->dev,
 						"%s alloc mv_dev failed\n",

drivers/scsi/qedf/qedf_io.c

···
 		}
 
 		/* Allocate task parameters to pass to f/w init funcions */
-		io_req->task_params = kzalloc_obj(*io_req->task_params,
-						  GFP_KERNEL);
+		io_req->task_params = kzalloc_obj(*io_req->task_params);
 		if (!io_req->task_params) {
 			QEDF_ERR(&(qedf->dbg_ctx),
 				 "Failed to allocate task_params for xid=0x%x\n",
···
 		 * Allocate scatter/gather list info to pass to f/w init
 		 * functions.
 		 */
-		io_req->sgl_task_params = kzalloc_obj(struct scsi_sgl_task_params,
-						      GFP_KERNEL);
+		io_req->sgl_task_params = kzalloc_obj(struct scsi_sgl_task_params);
 		if (!io_req->sgl_task_params) {
 			QEDF_ERR(&(qedf->dbg_ctx),
 				 "Failed to allocate sgl_task_params for xid=0x%x\n",

drivers/scsi/qedf/qedf_main.c

···
 
 	/* Allocate a CQ and an associated PBL for each MSI-X vector */
 	for (i = 0; i < qedf->num_queues; i++) {
-		qedf->global_queues[i] = kzalloc_obj(struct global_queue,
-						     GFP_KERNEL);
+		qedf->global_queues[i] = kzalloc_obj(struct global_queue);
 		if (!qedf->global_queues[i]) {
 			QEDF_WARN(&(qedf->dbg_ctx), "Unable to allocate "
 				   "global queue %d.\n", i);

drivers/scsi/qedi/qedi_main.c

···
 	 */
 	for (i = 0; i < qedi->num_queues; i++) {
 		qedi->global_queues[i] =
-					kzalloc_obj(*qedi->global_queues[0],
-						    GFP_KERNEL);
+					kzalloc_obj(*qedi->global_queues[0]);
 		if (!qedi->global_queues[i]) {
 			QEDI_ERR(&qedi->dbg_ctx,
 				 "Unable to allocation global queue %d.\n", i);

drivers/scsi/qla2xxx/qla_init.c

···
 			req->num_outstanding_cmds = ha->cur_fw_iocb_count;
 	}
 
-	req->outstanding_cmds = kzalloc_objs(srb_t *, req->num_outstanding_cmds,
-					     GFP_KERNEL);
+	req->outstanding_cmds = kzalloc_objs(srb_t *, req->num_outstanding_cmds);
 
 	if (!req->outstanding_cmds) {
 		/*
···
 
 	/* Try GID_PT to get device list, else GAN. */
 	if (!ha->swl)
-		ha->swl = kzalloc_objs(sw_info_t, ha->max_fibre_devices,
-				       GFP_KERNEL);
+		ha->swl = kzalloc_objs(sw_info_t, ha->max_fibre_devices);
 	swl = ha->swl;
 	if (!swl) {
 		/*EMPTY*/

drivers/scsi/qla2xxx/qla_inline.h

···
 	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
 
 	if (!ha->qp_cpu_map) {
-		ha->qp_cpu_map = kzalloc_objs(struct qla_qpair *, NR_CPUS,
-					      GFP_KERNEL);
+		ha->qp_cpu_map = kzalloc_objs(struct qla_qpair *, NR_CPUS);
 		if (!ha->qp_cpu_map) {
 			ql_log(ql_log_fatal, vha, 0x0180,
 			       "Unable to allocate memory for qp_cpu_map ptrs.\n");

drivers/scsi/qla2xxx/qla_isr.c

···
 		}
 	}
 	vha->irq_offset = desc.pre_vectors;
-	ha->msix_entries = kzalloc_objs(struct qla_msix_entry, ha->msix_count,
-					GFP_KERNEL);
+	ha->msix_entries = kzalloc_objs(struct qla_msix_entry, ha->msix_count);
 	if (!ha->msix_entries) {
 		ql_log(ql_log_fatal, vha, 0x00c8,
 		    "Failed to allocate memory for ha->msix_entries.\n");

drivers/scsi/qla2xxx/qla_mid.c

···
 		return -ENOMEM;
 	}
 	sz = qp->req->length * sizeof(dma_addr_t);
-	qp->buf_pool.dma_array = kzalloc_objs(dma_addr_t, qp->req->length,
-					      GFP_KERNEL);
+	qp->buf_pool.dma_array = kzalloc_objs(dma_addr_t, qp->req->length);
 	if (!qp->buf_pool.dma_array) {
 		ql_log(ql_log_warn, vha, 0x0186,
 		    "Failed to allocate dma_array(%d).\n", sz);

drivers/scsi/qla2xxx/qla_os.c

···
 {
 	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
 
-	ha->req_q_map = kzalloc_objs(struct req_que *, ha->max_req_queues,
-				     GFP_KERNEL);
+	ha->req_q_map = kzalloc_objs(struct req_que *, ha->max_req_queues);
 	if (!ha->req_q_map) {
 		ql_log(ql_log_fatal, vha, 0x003b,
 		    "Unable to allocate memory for request queue ptrs.\n");
 		goto fail_req_map;
 	}
 
-	ha->rsp_q_map = kzalloc_objs(struct rsp_que *, ha->max_rsp_queues,
-				     GFP_KERNEL);
+	ha->rsp_q_map = kzalloc_objs(struct rsp_que *, ha->max_rsp_queues);
 	if (!ha->rsp_q_map) {
 		ql_log(ql_log_fatal, vha, 0x003c,
 		    "Unable to allocate memory for response queue ptrs.\n");
···
 	INIT_LIST_HEAD(&ha->vp_list);
 
 	/* Allocate memory for our loop_id bitmap */
-	ha->loop_id_map = kzalloc_objs(long, BITS_TO_LONGS(LOOPID_MAP_SIZE),
-				       GFP_KERNEL);
+	ha->loop_id_map = kzalloc_objs(long, BITS_TO_LONGS(LOOPID_MAP_SIZE));
 	if (!ha->loop_id_map)
 		goto fail_loop_id_map;
 	else {

drivers/scsi/qla2xxx/qla_target.c

···
 		return -ENOMEM;
 	}
 
-	tgt->qphints = kzalloc_objs(struct qla_qpair_hint, ha->max_qpairs + 1,
-				    GFP_KERNEL);
+	tgt->qphints = kzalloc_objs(struct qla_qpair_hint, ha->max_qpairs + 1);
 	if (!tgt->qphints) {
 		kfree(tgt);
 		ql_log(ql_log_warn, base_vha, 0x0197,

drivers/scsi/scsi_debug.c

···
 			devip->max_open = sdeb_zbc_max_open;
 	}
 
-	devip->zstate = kzalloc_objs(struct sdeb_zone_state, devip->nr_zones,
-				     GFP_KERNEL);
+	devip->zstate = kzalloc_objs(struct sdeb_zone_state, devip->nr_zones);
 	if (!devip->zstate)
 		return -ENOMEM;
 
···
 	if (sdebug_ptype == TYPE_TAPE) {
 		if (!devip->tape_blocks[0]) {
 			devip->tape_blocks[0] =
-				kzalloc_objs(struct tape_block, TAPE_UNITS,
-					     GFP_KERNEL);
+				kzalloc_objs(struct tape_block, TAPE_UNITS);
 			if (!devip->tape_blocks[0])
 				return 1;
 		}

drivers/scsi/ses.c

···
 	}
 page2_not_supported:
 	if (components > 0) {
-		scomp = kzalloc_objs(struct ses_component, components,
-				     GFP_KERNEL);
+		scomp = kzalloc_objs(struct ses_component, components);
 		if (!scomp)
 			goto err_free;
 	}

drivers/scsi/smartpqi/smartpqi_init.c

···
 
 	num_new_devices = num_physicals + num_logicals;
 
-	new_device_list = kmalloc_objs(*new_device_list, num_new_devices,
-				       GFP_KERNEL);
+	new_device_list = kmalloc_objs(*new_device_list, num_new_devices);
 	if (!new_device_list) {
 		dev_warn(&ctrl_info->pci_dev->dev, "%s\n", out_of_memory_msg);
 		rc = -ENOMEM;

drivers/scsi/vmw_pvscsi.c

···
 	 */
 	pvscsi_setup_all_rings(adapter);
 
-	adapter->cmd_map = kzalloc_objs(struct pvscsi_ctx, adapter->req_depth,
-					GFP_KERNEL);
+	adapter->cmd_map = kzalloc_objs(struct pvscsi_ctx, adapter->req_depth);
 	if (!adapter->cmd_map) {
 		printk(KERN_ERR "vmw_pvscsi: failed to allocate memory.\n");
 		error = -ENOMEM;

drivers/soc/qcom/pdr_interface.c

···
 	int domains_read = 0;
 	int ret, i;
 
-	struct servreg_get_domain_list_resp *resp __free(kfree) = kzalloc_obj(*resp,
-									      GFP_KERNEL);
+	struct servreg_get_domain_list_resp *resp __free(kfree) = kzalloc_obj(*resp);
 	if (!resp)
 		return -ENOMEM;
 

drivers/soc/renesas/rz-sysc.c

···
 	struct rz_sysc *sysc;
 	int ret;
 
-	struct regmap_config *regmap_cfg __free(kfree) = kzalloc_obj(*regmap_cfg,
-								     GFP_KERNEL);
+	struct regmap_config *regmap_cfg __free(kfree) = kzalloc_obj(*regmap_cfg);
 	if (!regmap_cfg)
 		return -ENOMEM;
 

drivers/soundwire/amd_init.c

···
 
 	ctx->count = count;
 	ctx->link_mask = res->link_mask;
-	struct resource *sdw_res __free(kfree) = kzalloc_obj(*sdw_res,
-							     GFP_KERNEL);
+	struct resource *sdw_res __free(kfree) = kzalloc_obj(*sdw_res);
 	if (!sdw_res) {
 		kfree(ctx);
 		return NULL;
···
 			num_slaves++;
 	}
 
-	ctx->peripherals = kmalloc_flex(*ctx->peripherals, array, num_slaves,
-					GFP_KERNEL);
+	ctx->peripherals = kmalloc_flex(*ctx->peripherals, array, num_slaves);
 	if (!ctx->peripherals)
 		return -ENOMEM;
 	ctx->peripherals->num_peripherals = num_slaves;

drivers/soundwire/amd_manager.c

···
 	sconfig.bps = snd_pcm_format_width(params_format(params));
 
 	/* Port configuration */
-	struct sdw_port_config *pconfig __free(kfree) = kzalloc_obj(*pconfig,
-								    GFP_KERNEL);
+	struct sdw_port_config *pconfig __free(kfree) = kzalloc_obj(*pconfig);
 	if (!pconfig)
 		return -ENOMEM;
 

drivers/soundwire/intel.c

···
 	sconfig.bps = snd_pcm_format_width(params_format(params));
 
 	/* Port configuration */
-	struct sdw_port_config *pconfig __free(kfree) = kzalloc_obj(*pconfig,
-								    GFP_KERNEL);
+	struct sdw_port_config *pconfig __free(kfree) = kzalloc_obj(*pconfig);
 	if (!pconfig)
 		return -ENOMEM;
 

drivers/soundwire/intel_ace2x.c

···
 	sconfig.bps = snd_pcm_format_width(params_format(params));
 
 	/* Port configuration */
-	struct sdw_port_config *pconfig __free(kfree) = kzalloc_obj(*pconfig,
-								    GFP_KERNEL);
+	struct sdw_port_config *pconfig __free(kfree) = kzalloc_obj(*pconfig);
 	if (!pconfig)
 		return -ENOMEM;
 

drivers/soundwire/intel_init.c

···
 			num_slaves++;
 	}
 
-	ctx->peripherals = kmalloc_flex(*ctx->peripherals, array, num_slaves,
-					GFP_KERNEL);
+	ctx->peripherals = kmalloc_flex(*ctx->peripherals, array, num_slaves);
 	if (!ctx->peripherals)
 		goto err;
 	ctx->peripherals->num_peripherals = num_slaves;

drivers/spi/spi-bcm-qspi.c

···
 			return PTR_ERR(qspi->base[CHIP_SELECT]);
 	}
 
-	qspi->dev_ids = kzalloc_objs(struct bcm_qspi_dev_id, num_irqs,
-				     GFP_KERNEL);
+	qspi->dev_ids = kzalloc_objs(struct bcm_qspi_dev_id, num_irqs);
 	if (!qspi->dev_ids)
 		return -ENOMEM;
 

drivers/spi/spi-mpc52xx.c

···
 	ms->gpio_cs_count = gpiod_count(&op->dev, NULL);
 	if (ms->gpio_cs_count > 0) {
 		host->num_chipselect = ms->gpio_cs_count;
-		ms->gpio_cs = kmalloc_objs(*ms->gpio_cs, ms->gpio_cs_count,
-					   GFP_KERNEL);
+		ms->gpio_cs = kmalloc_objs(*ms->gpio_cs, ms->gpio_cs_count);
 		if (!ms->gpio_cs) {
 			rc = -ENOMEM;
 			goto err_alloc_gpio;

drivers/spi/spi-virtio.c

···
 	unsigned int incnt = 0;
 	int ret;
 
-	struct virtio_spi_req *spi_req __free(kfree) = kzalloc_obj(*spi_req,
-								   GFP_KERNEL);
+	struct virtio_spi_req *spi_req __free(kfree) = kzalloc_obj(*spi_req);
 	if (!spi_req)
 		return -ENOMEM;
 

drivers/staging/greybus/light.c

···
 	channel->attr_group = kzalloc_obj(*channel->attr_group);
 	if (!channel->attr_group)
 		return -ENOMEM;
-	channel->attr_groups = kzalloc_objs(*channel->attr_groups, 2,
-					    GFP_KERNEL);
+	channel->attr_groups = kzalloc_objs(*channel->attr_groups, 2);
 	if (!channel->attr_groups)
 		return -ENOMEM;
 
···
 	light->name = kstrndup(conf.name, NAMES_MAX, GFP_KERNEL);
 	if (!light->name)
 		return -ENOMEM;
-	light->channels = kzalloc_objs(struct gb_channel, conf.channel_count,
-				       GFP_KERNEL);
+	light->channels = kzalloc_objs(struct gb_channel, conf.channel_count);
 	if (!light->channels)
 		return -ENOMEM;
 	/*
···
 	if (ret < 0)
 		goto out;
 
-	glights->lights = kzalloc_objs(struct gb_light, glights->lights_count,
-				       GFP_KERNEL);
+	glights->lights = kzalloc_objs(struct gb_light, glights->lights_count);
 	if (!glights->lights) {
 		ret = -ENOMEM;
 		goto out;

drivers/staging/greybus/power_supply.c

···
 		}
 	}
 
-	gbpsy->props = kzalloc_objs(*gbpsy->props, gbpsy->properties_count,
-				    GFP_KERNEL);
+	gbpsy->props = kzalloc_objs(*gbpsy->props, gbpsy->properties_count);
 	if (!gbpsy->props) {
 		ret = -ENOMEM;
 		goto out_put_operation;

drivers/staging/media/atomisp/pci/atomisp_ioctl.c

···
 			ATOMISP_S3A_BUF_QUEUE_DEPTH_FOR_HAL;
 		dev_dbg(isp->dev, "allocating %d 3a buffers\n", count);
 		while (count--) {
-			s3a_buf = kzalloc_obj(struct atomisp_s3a_buf,
-					      GFP_KERNEL);
+			s3a_buf = kzalloc_obj(struct atomisp_s3a_buf);
 			if (!s3a_buf)
 				goto error;
 
···
 		count = ATOMISP_CSS_Q_DEPTH + 1;
 		dev_dbg(isp->dev, "allocating %d dis buffers\n", count);
 		while (count--) {
-			dis_buf = kzalloc_obj(struct atomisp_dis_buf,
-					      GFP_KERNEL);
+			dis_buf = kzalloc_obj(struct atomisp_dis_buf);
 			if (!dis_buf)
 				goto error;
 			if (atomisp_css_allocate_stat_buffers(
···
 			dev_dbg(isp->dev, "allocating %d metadata buffers for type %d\n",
 				count, i);
 			while (count--) {
-				md_buf = kzalloc_obj(struct atomisp_metadata_buf,
-						     GFP_KERNEL);
+				md_buf = kzalloc_obj(struct atomisp_metadata_buf);
 				if (!md_buf)
 					goto error;
 

drivers/staging/media/atomisp/pci/sh_css.c

···
 
 		mycs->num_vf_pp = 1;
 	}
-	mycs->vf_pp_binary = kzalloc_objs(struct ia_css_binary, mycs->num_vf_pp,
-					  GFP_KERNEL);
+	mycs->vf_pp_binary = kzalloc_objs(struct ia_css_binary, mycs->num_vf_pp);
 	if (!mycs->vf_pp_binary) {
 		err = -ENOMEM;
 		goto ERR;
···
 
 	/* allocate pipes */
 	curr_stream->num_pipes = num_pipes;
-	curr_stream->pipes = kzalloc_objs(struct ia_css_pipe *, num_pipes,
-					  GFP_KERNEL);
+	curr_stream->pipes = kzalloc_objs(struct ia_css_pipe *, num_pipes);
 	if (!curr_stream->pipes) {
 		curr_stream->num_pipes = 0;
 		kfree(curr_stream);

drivers/staging/media/atomisp/pci/sh_css_firmware.c

···
 		sh_css_blob_info = NULL;
 	}
 
-	fw_minibuffer = kzalloc_objs(struct fw_param, sh_css_num_binaries,
-				     GFP_KERNEL);
+	fw_minibuffer = kzalloc_objs(struct fw_param, sh_css_num_binaries);
 	if (!fw_minibuffer)
 		return -ENOMEM;
 

drivers/staging/media/atomisp/pci/sh_css_params.c

···
 	if (!params || !params->pipe_dvs_6axis_config[IA_CSS_PIPE_ID_VIDEO])
 		goto err;
 
-	dvs_config = kvzalloc_objs(struct ia_css_dvs_6axis_config, 1,
-				   GFP_KERNEL);
+	dvs_config = kvzalloc_objs(struct ia_css_dvs_6axis_config, 1);
 	if (!dvs_config)
 		goto err;
 

drivers/staging/vme_user/vme_tsi148.c

···
 	if (err_chk) {
 		master_num--;
 
-		tsi148_device->flush_image = kmalloc_obj(*tsi148_device->flush_image,
-							 GFP_KERNEL);
+		tsi148_device->flush_image = kmalloc_obj(*tsi148_device->flush_image);
 		if (!tsi148_device->flush_image) {
 			retval = -ENOMEM;
 			goto err_master;

drivers/target/target_core_iblock.c

···
 	}
 	ib_dev->ibd_exclusive = true;
 
-	ib_dev->ibd_plug = kzalloc_objs(*ib_dev->ibd_plug, nr_cpu_ids,
-					GFP_KERNEL);
+	ib_dev->ibd_plug = kzalloc_objs(*ib_dev->ibd_plug, nr_cpu_ids);
 	if (!ib_dev->ibd_plug)
 		goto free_dev;
 

drivers/target/target_core_pr.c

···
 		 * the dest_node_acl and dest_se_deve pointers for the
 		 * loop below.
 		 */
-		tidh_new = kzalloc_obj(struct pr_transport_id_holder,
-				       GFP_KERNEL);
+		tidh_new = kzalloc_obj(struct pr_transport_id_holder);
 		if (!tidh_new) {
 			pr_err("Unable to allocate tidh_new\n");
 			core_scsi3_lunacl_undepend_item(dest_se_deve);

drivers/tee/qcomtee/call.c

···
 
 static int qcomtee_open(struct tee_context *ctx)
 {
-	struct qcomtee_context_data *ctxdata __free(kfree) = kzalloc_obj(*ctxdata,
-									 GFP_KERNEL);
+	struct qcomtee_context_data *ctxdata __free(kfree) = kzalloc_obj(*ctxdata);
 	if (!ctxdata)
 		return -ENOMEM;
 

drivers/tee/qcomtee/mem_obj.c

···
 	struct tee_shm *shm;
 	int err;
 
-	struct qcomtee_mem_object *mem_object __free(kfree) = kzalloc_obj(*mem_object,
-									  GFP_KERNEL);
+	struct qcomtee_mem_object *mem_object __free(kfree) = kzalloc_obj(*mem_object);
 	if (!mem_object)
 		return -ENOMEM;
 

drivers/tee/tee_core.c

···
 		return -EINVAL;
 
 	if (arg.num_params) {
-		params = kzalloc_objs(struct tee_param, arg.num_params,
-				      GFP_KERNEL);
+		params = kzalloc_objs(struct tee_param, arg.num_params);
 		if (!params)
 			return -ENOMEM;
 		uparams = uarg->params;
···
 		return -EINVAL;
 
 	if (arg.num_params) {
-		params = kzalloc_objs(struct tee_param, arg.num_params,
-				      GFP_KERNEL);
+		params = kzalloc_objs(struct tee_param, arg.num_params);
 		if (!params)
 			return -ENOMEM;
 		uparams = uarg->params;
···
 		return -EINVAL;
 
 	if (arg.num_params) {
-		params = kzalloc_objs(struct tee_param, arg.num_params,
-				      GFP_KERNEL);
+		params = kzalloc_objs(struct tee_param, arg.num_params);
 		if (!params)
 			return -ENOMEM;
 		uparams = uarg->params;

drivers/thermal/intel/intel_hfi.c

···
 	 * This allocation may fail. CPU hotplug callbacks must check
 	 * for a null pointer.
 	 */
-	hfi_instances = kzalloc_objs(*hfi_instances, max_hfi_instances,
-				     GFP_KERNEL);
+	hfi_instances = kzalloc_objs(*hfi_instances, max_hfi_instances);
 	if (!hfi_instances)
 		return;
 

drivers/thermal/testing/zone.c

···
 {
 	int ret;
 
-	struct tt_thermal_zone *tt_zone __free(kfree) = kzalloc_obj(*tt_zone,
-								    GFP_KERNEL);
+	struct tt_thermal_zone *tt_zone __free(kfree) = kzalloc_obj(*tt_zone);
 	if (!tt_zone)
 		return -ENOMEM;
 
-	struct tt_work *tt_work __free(kfree) = kzalloc_obj(*tt_work,
-							    GFP_KERNEL);
+	struct tt_work *tt_work __free(kfree) = kzalloc_obj(*tt_work);
 	if (!tt_work)
 		return -ENOMEM;
 
···
 	if (ret != 1)
 		return -EINVAL;
 
-	struct tt_work *tt_work __free(kfree) = kzalloc_obj(*tt_work,
-							    GFP_KERNEL);
+	struct tt_work *tt_work __free(kfree) = kzalloc_obj(*tt_work);
 	if (!tt_work)
 		return -ENOMEM;
 
···
 {
 	int id;
 
-	struct tt_work *tt_work __free(kfree) = kzalloc_obj(*tt_work,
-							    GFP_KERNEL);
+	struct tt_work *tt_work __free(kfree) = kzalloc_obj(*tt_work);
 	if (!tt_work)
 		return -ENOMEM;
 
-	struct tt_trip *tt_trip __free(kfree) = kzalloc_obj(*tt_trip,
-							    GFP_KERNEL);
+	struct tt_trip *tt_trip __free(kfree) = kzalloc_obj(*tt_trip);
 	if (!tt_trip)
 		return -ENOMEM;
 

drivers/thermal/thermal_of.c

···
 	if (!count)
 		return NULL;
 
-	struct thermal_trip *tt __free(kfree) = kzalloc_objs(*tt, count,
-							     GFP_KERNEL);
+	struct thermal_trip *tt __free(kfree) = kzalloc_objs(*tt, count);
 	if (!tt)
 		return ERR_PTR(-ENOMEM);
 

drivers/thunderbolt/switch.c

···
 	}
 
 	/* initialize ports */
-	sw->ports = kzalloc_objs(*sw->ports, sw->config.max_port_number + 1,
-				 GFP_KERNEL);
+	sw->ports = kzalloc_objs(*sw->ports, sw->config.max_port_number + 1);
 	if (!sw->ports) {
 		ret = -ENOMEM;
 		goto err_free_sw_ports;

drivers/tty/goldfish.c

···
 	int ret;
 	struct tty_driver *tty;
 
-	goldfish_ttys = kzalloc_objs(*goldfish_ttys, goldfish_tty_line_count,
-				     GFP_KERNEL);
+	goldfish_ttys = kzalloc_objs(*goldfish_ttys, goldfish_tty_line_count);
 	if (goldfish_ttys == NULL) {
 		ret = -ENOMEM;
 		goto err_alloc_goldfish_ttys_failed;

drivers/tty/serial/8250/8250_platform.c

···
 	struct resource *regs;
 	int ret, line;
 
-	struct uart_8250_port *uart __free(kfree) = kzalloc_obj(*uart,
-								GFP_KERNEL);
+	struct uart_8250_port *uart __free(kfree) = kzalloc_obj(*uart);
 	if (!uart)
 		return -ENOMEM;
 
···
 {
 	int ret, i;
 
-	struct uart_8250_port *uart __free(kfree) = kzalloc_obj(*uart,
-								GFP_KERNEL);
+	struct uart_8250_port *uart __free(kfree) = kzalloc_obj(*uart);
 	if (!uart)
 		return -ENOMEM;
 

drivers/tty/serial/jsm/jsm_tty.c

···
 			 * Okay to malloc with GFP_KERNEL, we are not at
 			 * interrupt context, and there are no locks held.
 			 */
-			brd->channels[i] = kzalloc_obj(struct jsm_channel,
-						       GFP_KERNEL);
+			brd->channels[i] = kzalloc_obj(struct jsm_channel);
 			if (!brd->channels[i]) {
 				jsm_dbg(CORE, &brd->pci_dev,
 					"%s:%d Unable to allocate memory for channel struct\n",

drivers/tty/serial/serial_core.c

···
 	if (uport->attr_group)
 		num_groups++;
 
-	uport->tty_groups = kzalloc_objs(*uport->tty_groups, num_groups,
-					 GFP_KERNEL);
+	uport->tty_groups = kzalloc_objs(*uport->tty_groups, num_groups);
 	if (!uport->tty_groups)
 		return -ENOMEM;
 

drivers/tty/tty_io.c

···
 
 	if (!(flags & TTY_DRIVER_DEVPTS_MEM)) {
 		driver->ttys = kzalloc_objs(*driver->ttys, lines);
-		driver->termios = kzalloc_objs(*driver->termios, lines,
-					       GFP_KERNEL);
+		driver->termios = kzalloc_objs(*driver->termios, lines);
 		if (!driver->ttys || !driver->termios) {
 			err = -ENOMEM;
 			goto err_free_all;

drivers/tty/vt/keyboard.c

···
 {
 	int error;
 
-	struct input_handle __free(kfree) *handle = kzalloc_obj(*handle,
-								GFP_KERNEL);
+	struct input_handle __free(kfree) *handle = kzalloc_obj(*handle);
 	if (!handle)
 		return -ENOMEM;
 

drivers/usb/core/hcd.c

···
 	if (!hcd)
 		return NULL;
 	if (primary_hcd == NULL) {
-		hcd->address0_mutex = kmalloc_obj(*hcd->address0_mutex,
-						  GFP_KERNEL);
+		hcd->address0_mutex = kmalloc_obj(*hcd->address0_mutex);
 		if (!hcd->address0_mutex) {
 			kfree(hcd);
 			dev_dbg(dev, "hcd address0 mutex alloc failed\n");
 			return NULL;
 		}
 		mutex_init(hcd->address0_mutex);
-		hcd->bandwidth_mutex = kmalloc_obj(*hcd->bandwidth_mutex,
-						   GFP_KERNEL);
+		hcd->bandwidth_mutex = kmalloc_obj(*hcd->bandwidth_mutex);
 		if (!hcd->bandwidth_mutex) {
 			kfree(hcd->address0_mutex);
 			kfree(hcd);

drivers/usb/gadget/function/f_midi.c

···
 		goto fail;
 
 	/* allocate temporary function list */
-	midi_function = kzalloc_objs(*midi_function, (MAX_PORTS * 4) + 11,
-				     GFP_KERNEL);
+	midi_function = kzalloc_objs(*midi_function, (MAX_PORTS * 4) + 11);
 	if (!midi_function) {
 		status = -ENOMEM;
 		goto fail;

drivers/usb/gadget/function/f_midi2.c

···
 		return -ENODEV;
 	usb_ep->complete = complete;
 
-	usb_ep->reqs = kzalloc_objs(*usb_ep->reqs, midi2->info.num_reqs,
-				    GFP_KERNEL);
+	usb_ep->reqs = kzalloc_objs(*usb_ep->reqs, midi2->info.num_reqs);
 	if (!usb_ep->reqs)
 		return -ENOMEM;
 	for (i = 0; i < midi2->info.num_reqs; i++) {

drivers/usb/gadget/udc/bdc/bdc_core.c

···
 		"ieps:%d eops:%d num_eps:%d\n",
 		num_ieps, num_oeps, bdc->num_eps);
 	/* allocate array of ep pointers */
-	bdc->bdc_ep_array = kzalloc_objs(struct bdc_ep *, bdc->num_eps,
-					 GFP_KERNEL);
+	bdc->bdc_ep_array = kzalloc_objs(struct bdc_ep *, bdc->num_eps);
 	if (!bdc->bdc_ep_array)
 		goto fail;
 

drivers/usb/host/uhci-hcd.c

···
 		goto err_alloc_frame;
 	}
 
-	uhci->frame_cpu = kzalloc_objs(*uhci->frame_cpu, UHCI_NUMFRAMES,
-				       GFP_KERNEL);
+	uhci->frame_cpu = kzalloc_objs(*uhci->frame_cpu, UHCI_NUMFRAMES);
 	if (!uhci->frame_cpu)
 		goto err_alloc_frame_cpu;
 

drivers/usb/host/xhci-mtk-sch.c

···
 	if (utt->multi) {
 		tt_index = utt->hcpriv;
 		if (!tt_index) {	/* Create the index array */
-			tt_index = kzalloc_objs(*tt_index, utt->hub->maxchild,
-						GFP_KERNEL);
+			tt_index = kzalloc_objs(*tt_index, utt->hub->maxchild);
 			if (!tt_index)
 				return ERR_PTR(-ENOMEM);
 			utt->hcpriv = tt_index;

drivers/usb/mon/mon_bin.c

···
 			return -EINVAL;
 
 		size = CHUNK_ALIGN(arg);
-		vec = kzalloc_objs(struct mon_pgmap, size / CHUNK_SIZE,
-				   GFP_KERNEL);
+		vec = kzalloc_objs(struct mon_pgmap, size / CHUNK_SIZE);
 		if (vec == NULL) {
 			ret = -ENOMEM;
 			break;

drivers/usb/serial/mos7840.c

···
 	/* Initialize LED timers */
 	if (mos7840_port->has_led) {
 		mos7840_port->led_urb = usb_alloc_urb(0, GFP_KERNEL);
-		mos7840_port->led_dr = kmalloc_obj(*mos7840_port->led_dr,
-						   GFP_KERNEL);
+		mos7840_port->led_dr = kmalloc_obj(*mos7840_port->led_dr);
 		if (!mos7840_port->led_urb || !mos7840_port->led_dr) {
 			status = -ENOMEM;
 			goto error;

drivers/usb/typec/ucsi/ucsi.c

···
 	}
 
 	/* Allocate the connectors. Released in ucsi_unregister() */
-	connector = kzalloc_objs(*connector, ucsi->cap.num_connectors + 1,
-				 GFP_KERNEL);
+	connector = kzalloc_objs(*connector, ucsi->cap.num_connectors + 1);
 	if (!connector) {
 		ret = -ENOMEM;
 		goto err_reset;

drivers/usb/usbip/vhci_sysfs.c

···
 {
 	int id;
 
-	status_attrs = kzalloc_objs(struct status_attr, vhci_num_controllers,
-				    GFP_KERNEL);
+	status_attrs = kzalloc_objs(struct status_attr, vhci_num_controllers);
 	if (status_attrs == NULL)
 		return -ENOMEM;
 
···
 	struct attribute **attrs;
 	int ret, i;
 
-	attrs = kzalloc_objs(struct attribute *, (vhci_num_controllers + 5),
-			     GFP_KERNEL);
+	attrs = kzalloc_objs(struct attribute *, (vhci_num_controllers + 5));
 	if (attrs == NULL)
 		return -ENOMEM;
 

drivers/vdpa/mlx5/net/mlx5_vnet.c

···
 	mlx5_cmd_init_async_ctx(mdev, &mvdev->async_ctx);
 
 	ndev->vqs = kzalloc_objs(*ndev->vqs, max_vqs);
-	ndev->event_cbs = kzalloc_objs(*ndev->event_cbs, max_vqs + 1,
-				       GFP_KERNEL);
+	ndev->event_cbs = kzalloc_objs(*ndev->event_cbs, max_vqs + 1);
 	if (!ndev->vqs || !ndev->event_cbs) {
 		err = -ENOMEM;
 		goto err_alloc;

drivers/vdpa/vdpa_sim/vdpa_sim.c

···
 	if (!vdpasim->config)
 		goto err_iommu;
 
-	vdpasim->vqs = kzalloc_objs(struct vdpasim_virtqueue, dev_attr->nvqs,
-				    GFP_KERNEL);
+	vdpasim->vqs = kzalloc_objs(struct vdpasim_virtqueue, dev_attr->nvqs);
 	if (!vdpasim->vqs)
 		goto err_iommu;
 
-	vdpasim->iommu = kmalloc_objs(*vdpasim->iommu, vdpasim->dev_attr.nas,
-				      GFP_KERNEL);
+	vdpasim->iommu = kmalloc_objs(*vdpasim->iommu, vdpasim->dev_attr.nas);
 	if (!vdpasim->iommu)
 		goto err_iommu;
 

drivers/vfio/pci/pds/dirty.c

···
 	u8 num_regions;
 	int err;
 
-	region_info = kzalloc_objs(struct pds_lm_dirty_region_info, max_regions,
-				   GFP_KERNEL);
+	region_info = kzalloc_objs(struct pds_lm_dirty_region_info, max_regions);
 	if (!region_info)
 		return;
 

drivers/vfio/pci/vfio_pci_dmabuf.c

···
 		ret = -ENOMEM;
 		goto err_free_ranges;
 	}
-	priv->phys_vec = kzalloc_objs(*priv->phys_vec, get_dma_buf.nr_ranges,
-				      GFP_KERNEL);
+	priv->phys_vec = kzalloc_objs(*priv->phys_vec, get_dma_buf.nr_ranges);
 	if (!priv->phys_vec) {
 		ret = -ENOMEM;
 		goto err_free_priv;

drivers/vhost/net.c

···
 		if (!zcopy)
 			continue;
 		n->vqs[i].ubuf_info =
-			kmalloc_objs(*n->vqs[i].ubuf_info, UIO_MAXIOV,
-				     GFP_KERNEL);
+			kmalloc_objs(*n->vqs[i].ubuf_info, UIO_MAXIOV);
 		if  (!n->vqs[i].ubuf_info)
 			goto err;
 	}

drivers/vhost/scsi.c

···
 				   unsigned int log_num)
 {
 	if (!cmd->tvc_log)
-		cmd->tvc_log = kmalloc_objs(*cmd->tvc_log, vq->dev->iov_limit,
-					    GFP_KERNEL);
+		cmd->tvc_log = kmalloc_objs(*cmd->tvc_log, vq->dev->iov_limit);
 
 	if (unlikely(!cmd->tvc_log)) {
 		vq_err(vq, "Failed to alloc tvc_log\n");
···
 		return -ENOMEM;
 	}
 
-	svq->upages = kzalloc_objs(struct page *, VHOST_SCSI_PREALLOC_UPAGES,
-				   GFP_KERNEL);
+	svq->upages = kzalloc_objs(struct page *, VHOST_SCSI_PREALLOC_UPAGES);
 	if (!svq->upages)
 		goto out;
 

drivers/vhost/vhost.c

···
 
 	for (i = 0; i < dev->nvqs; ++i) {
 		vq = dev->vqs[i];
-		vq->indirect = kmalloc_objs(*vq->indirect, UIO_MAXIOV,
-					    GFP_KERNEL);
+		vq->indirect = kmalloc_objs(*vq->indirect, UIO_MAXIOV);
 		vq->log = kmalloc_objs(*vq->log, dev->iov_limit);
 		vq->heads = kmalloc_objs(*vq->heads, dev->iov_limit);
 		vq->nheads = kmalloc_array(dev->iov_limit, sizeof(*vq->nheads),

drivers/video/fbdev/arkfb.c

···
 
 static struct dac_info * ics5342_init(dac_read_regs_t drr, dac_write_regs_t dwr, void *data)
 {
-	struct ics5342_info *ics_info = kzalloc_obj(struct ics5342_info,
-						    GFP_KERNEL);
+	struct ics5342_info *ics_info = kzalloc_obj(struct ics5342_info);
 	struct dac_info *info = &ics_info->dac;
 
 	if (!ics_info)

drivers/video/fbdev/mmp/fb/mmpfb.c

···
 		return 0;
 	}
 	/* put videomode list to info structure */
-	videomodes = kzalloc_objs(struct fb_videomode, videomode_num,
-				  GFP_KERNEL);
+	videomodes = kzalloc_objs(struct fb_videomode, videomode_num);
 	if (!videomodes)
 		return -ENOMEM;
 

drivers/video/fbdev/omap2/omapfb/dss/manager.c

···
 
 	num_managers = dss_feat_get_num_mgrs();
 
-	managers = kzalloc_objs(struct omap_overlay_manager, num_managers,
-				GFP_KERNEL);
+	managers = kzalloc_objs(struct omap_overlay_manager, num_managers);
 
 	BUG_ON(managers == NULL);
 

drivers/video/fbdev/smscufx.c

···
 
 	/* TODO: Help propose a standard fb.h ioctl to report mmap damage */
 	if (cmd == UFX_IOCTL_REPORT_DAMAGE) {
-		struct dloarea *area __free(kfree) = kmalloc_obj(*area,
-								 GFP_KERNEL);
+		struct dloarea *area __free(kfree) = kmalloc_obj(*area);
 		if (!area)
 			return -ENOMEM;
 

drivers/video/fbdev/udlfb.c

···
 
 static void dlfb_deferred_vfree(struct dlfb_data *dlfb, void *mem)
 {
-	struct dlfb_deferred_free *d = kmalloc_obj(struct dlfb_deferred_free,
-						   GFP_KERNEL);
+	struct dlfb_deferred_free *d = kmalloc_obj(struct dlfb_deferred_free);
 	if (!d)
 		return;
 	d->mem = mem;

drivers/video/fbdev/uvesafb.c

···
 		mode++;
 	}
 
-	par->vbe_modes = kzalloc_objs(struct vbe_mode_ib, par->vbe_modes_cnt,
-				      GFP_KERNEL);
+	par->vbe_modes = kzalloc_objs(struct vbe_mode_ib, par->vbe_modes_cnt);
 	if (!par->vbe_modes)
 		return -ENOMEM;
 

drivers/video/of_display_timing.c

···
 		goto timingfail;
 	}
 
-	disp->timings = kzalloc_objs(struct display_timing *, disp->num_timings,
-				     GFP_KERNEL);
+	disp->timings = kzalloc_objs(struct display_timing *, disp->num_timings);
 	if (!disp->timings) {
 		pr_err("%pOF: could not allocate timings array\n", np);
 		goto timingfail;

drivers/virt/acrn/mm.c

···
 	}
 
 	/* Prepare the vm_memory_region_batch */
-	regions_info = kzalloc_flex(*regions_info, regions_op, nr_regions,
-				    GFP_KERNEL);
+	regions_info = kzalloc_flex(*regions_info, regions_op, nr_regions);
 	if (!regions_info) {
 		ret = -ENOMEM;
 		goto unmap_kernel_map;

drivers/virt/nitro_enclaves/ne_misc_dev.c

···
 
 	max_nr_pages = mem_region.memory_size / NE_MIN_MEM_REGION_SIZE;
 
-	ne_mem_region->pages = kzalloc_objs(*ne_mem_region->pages, max_nr_pages,
-					    GFP_KERNEL);
+	ne_mem_region->pages = kzalloc_objs(*ne_mem_region->pages, max_nr_pages);
 	if (!ne_mem_region->pages) {
 		rc = -ENOMEM;
 

drivers/virtio/virtio_pci_common.c

···
 
 	vp_dev->msix_vectors = nvectors;
 
-	vp_dev->msix_names = kmalloc_objs(*vp_dev->msix_names, nvectors,
-					  GFP_KERNEL);
+	vp_dev->msix_names = kmalloc_objs(*vp_dev->msix_names, nvectors);
 	if (!vp_dev->msix_names)
 		goto error;
 	vp_dev->msix_affinity_masks
-		= kzalloc_objs(*vp_dev->msix_affinity_masks, nvectors,
-			       GFP_KERNEL);
+		= kzalloc_objs(*vp_dev->msix_affinity_masks, nvectors);
 	if (!vp_dev->msix_affinity_masks)
 		goto error;
 	for (i = 0; i < nvectors; ++i)

drivers/xen/gntdev.c

···
 	    NULL == add->being_removed)
 		goto err;
 	if (xen_pv_domain()) {
-		add->kmap_ops   = kvmalloc_objs(add->kmap_ops[0], count,
-						GFP_KERNEL);
-		add->kunmap_ops = kvmalloc_objs(add->kunmap_ops[0], count,
-						GFP_KERNEL);
+		add->kmap_ops   = kvmalloc_objs(add->kmap_ops[0], count);
+		add->kunmap_ops = kvmalloc_objs(add->kunmap_ops[0], count);
 		if (NULL == add->kmap_ops || NULL == add->kunmap_ops)
 			goto err;
 	}

drivers/xen/grant-table.c

···
 	 */
 	max_nr_glist_frames = max_nr_grefs / RPP;
 
-	gnttab_list = kmalloc_objs(grant_ref_t *, max_nr_glist_frames,
-				   GFP_KERNEL);
+	gnttab_list = kmalloc_objs(grant_ref_t *, max_nr_glist_frames);
 	if (gnttab_list == NULL)
 		return -ENOMEM;
 

drivers/xen/xen-acpi-processor.c

···
 	unsigned int i, ok;
 	int ret = 0;
 
-	dst_cx_states = kzalloc_objs(struct xen_processor_cx, _pr->power.count,
-				     GFP_KERNEL);
+	dst_cx_states = kzalloc_objs(struct xen_processor_cx, _pr->power.count);
 	if (!dst_cx_states)
 		return -ENOMEM;
 
···
 		return -ENOMEM;
 	}
 
-	acpi_psd = kzalloc_objs(struct acpi_psd_package, nr_acpi_bits,
-				GFP_KERNEL);
+	acpi_psd = kzalloc_objs(struct acpi_psd_package, nr_acpi_bits);
 	if (!acpi_psd) {
 		bitmap_free(acpi_id_present);
 		bitmap_free(acpi_id_cst_present);

drivers/xen/xen-scsiback.c

···
 	}
 
 	/* free of (sgl) in fast_flush_area() */
-	pending_req->sgl = kmalloc_objs(struct scatterlist, nr_segments,
-					GFP_KERNEL);
+	pending_req->sgl = kmalloc_objs(struct scatterlist, nr_segments);
 	if (!pending_req->sgl)
 		return -ENOMEM;
 

fs/aio.c

···
 
 	ctx->ring_folios = ctx->internal_folios;
 	if (nr_pages > AIO_RING_PAGES) {
-		ctx->ring_folios = kzalloc_objs(struct folio *, nr_pages,
-						GFP_KERNEL);
+		ctx->ring_folios = kzalloc_objs(struct folio *, nr_pages);
 		if (!ctx->ring_folios) {
 			put_aio_ring_file(ctx);
 			return -ENOMEM;

fs/binfmt_elf.c

···
 	/*
 	 * Allocate a structure for each thread.
 	 */
-	info->thread = kzalloc_flex(*info->thread, notes, info->thread_notes,
-				    GFP_KERNEL);
+	info->thread = kzalloc_flex(*info->thread, notes, info->thread_notes);
 	if (unlikely(!info->thread))
 		return 0;
 

fs/btrfs/ioctl.c

···
 	ret = get_anon_bdev(&pending_snapshot->anon_dev);
 	if (ret < 0)
 		goto free_pending;
-	pending_snapshot->root_item = kzalloc_obj(struct btrfs_root_item,
-						  GFP_KERNEL);
+	pending_snapshot->root_item = kzalloc_obj(struct btrfs_root_item);
 	pending_snapshot->path = btrfs_alloc_path();
 	if (!pending_snapshot->root_item || !pending_snapshot->path) {
 		ret = -ENOMEM;

fs/btrfs/tests/btrfs-tests.c

···
 
 struct btrfs_fs_info *btrfs_alloc_dummy_fs_info(u32 nodesize, u32 sectorsize)
 {
-	struct btrfs_fs_info *fs_info = kzalloc_obj(struct btrfs_fs_info,
-						    GFP_KERNEL);
+	struct btrfs_fs_info *fs_info = kzalloc_obj(struct btrfs_fs_info);
 
 	if (!fs_info)
 		return fs_info;

fs/btrfs/zoned.c

···
 		goto out;
 	}
 
-	zones = kvzalloc_objs(struct blk_zone, BTRFS_REPORT_NR_ZONES,
-			      GFP_KERNEL);
+	zones = kvzalloc_objs(struct blk_zone, BTRFS_REPORT_NR_ZONES);
 	if (!zones) {
 		ret = -ENOMEM;
 		goto out;

fs/cachefiles/ondemand.c

···
 	if (!cachefiles_in_ondemand_mode(volume->cache))
 		return 0;
 
-	object->ondemand = kzalloc_obj(struct cachefiles_ondemand_info,
-				       GFP_KERNEL);
+	object->ondemand = kzalloc_obj(struct cachefiles_ondemand_info);
 	if (!object->ondemand)
 		return -ENOMEM;
 

fs/coredump.c

···
 	gate_vma = get_gate_vma(mm);
 	cprm->vma_count = mm->map_count + (gate_vma ? 1 : 0);
 
-	cprm->vma_meta = kvmalloc_objs(*cprm->vma_meta, cprm->vma_count,
-				       GFP_KERNEL);
+	cprm->vma_meta = kvmalloc_objs(*cprm->vma_meta, cprm->vma_count);
 	if (!cprm->vma_meta) {
 		mmap_write_unlock(mm);
 		return false;

fs/erofs/xattr.c

···
 	}
 	vi->xattr_name_filter = le32_to_cpu(ih->h_name_filter);
 	vi->xattr_shared_count = ih->h_shared_count;
-	vi->xattr_shared_xattrs = kmalloc_objs(uint, vi->xattr_shared_count,
-					       GFP_KERNEL);
+	vi->xattr_shared_xattrs = kmalloc_objs(uint, vi->xattr_shared_count);
 	if (!vi->xattr_shared_xattrs) {
 		erofs_put_metabuf(&buf);
 		ret = -ENOMEM;

fs/exfat/balloc.c

···
 	}
 	sbi->map_sectors = ((need_map_size - 1) >>
 			(sb->s_blocksize_bits)) + 1;
-	sbi->vol_amap = kvmalloc_objs(struct buffer_head *, sbi->map_sectors,
-				      GFP_KERNEL);
+	sbi->vol_amap = kvmalloc_objs(struct buffer_head *, sbi->map_sectors);
 	if (!sbi->vol_amap)
 		return -ENOMEM;
 

fs/ext2/super.c

···
 	}
 	db_count = (sbi->s_groups_count + EXT2_DESC_PER_BLOCK(sb) - 1) /
 		   EXT2_DESC_PER_BLOCK(sb);
-	sbi->s_group_desc = kvmalloc_objs(struct buffer_head *, db_count,
-					  GFP_KERNEL);
+	sbi->s_group_desc = kvmalloc_objs(struct buffer_head *, db_count);
 	if (sbi->s_group_desc == NULL) {
 		ret = -ENOMEM;
 		ext2_msg(sb, KERN_ERR, "error: not enough memory");

fs/ext4/orphan.c

···
 	}
 	oi->of_blocks = inode->i_size >> sb->s_blocksize_bits;
 	oi->of_csum_seed = EXT4_I(inode)->i_csum_seed;
-	oi->of_binfo = kvmalloc_objs(struct ext4_orphan_block, oi->of_blocks,
-				     GFP_KERNEL);
+	oi->of_binfo = kvmalloc_objs(struct ext4_orphan_block, oi->of_blocks);
 	if (!oi->of_binfo) {
 		ret = -ENOMEM;
 		goto out_put;

fs/fhandle.c

···
 	if (f_handle.handle_bytes > MAX_HANDLE_SZ)
 		return -EINVAL;
 
-	handle = kzalloc_flex(*handle, f_handle, f_handle.handle_bytes,
-			      GFP_KERNEL);
+	handle = kzalloc_flex(*handle, f_handle, f_handle.handle_bytes);
 	if (!handle)
 		return -ENOMEM;
 
···
 	if (retval)
 		goto out_path;
 
-	handle = kmalloc_flex(*handle, f_handle, f_handle.handle_bytes,
-			      GFP_KERNEL);
+	handle = kmalloc_flex(*handle, f_handle, f_handle.handle_bytes);
 	if (!handle) {
 		retval = -ENOMEM;
 		goto out_path;

fs/jbd2/journal.c

···
 
 	/* Are we called twice? */
 	WARN_ON(journal->j_fc_wbuf != NULL);
-	journal->j_fc_wbuf = kmalloc_objs(struct buffer_head *, num_fc_blks,
-					  GFP_KERNEL);
+	journal->j_fc_wbuf = kmalloc_objs(struct buffer_head *, num_fc_blks);
 	if (!journal->j_fc_wbuf)
 		return -ENOMEM;
 

fs/jffs2/summary.c

···
 int jffs2_sum_add_inode_mem(struct jffs2_summary *s, struct jffs2_raw_inode *ri,
 				uint32_t ofs)
 {
-	struct jffs2_sum_inode_mem *temp = kmalloc_obj(struct jffs2_sum_inode_mem,
-						       GFP_KERNEL);
+	struct jffs2_sum_inode_mem *temp = kmalloc_obj(struct jffs2_sum_inode_mem);
 
 	if (!temp)
 		return -ENOMEM;
···
 	switch (je16_to_cpu(node->u.nodetype)) {
 		case JFFS2_NODETYPE_INODE: {
 			struct jffs2_sum_inode_mem *temp =
-				kmalloc_obj(struct jffs2_sum_inode_mem,
-					    GFP_KERNEL);
+				kmalloc_obj(struct jffs2_sum_inode_mem);
 
 			if (!temp)
 				goto no_mem;
···
 #ifdef CONFIG_JFFS2_FS_XATTR
 		case JFFS2_NODETYPE_XATTR: {
 			struct jffs2_sum_xattr_mem *temp;
-			temp = kmalloc_obj(struct jffs2_sum_xattr_mem,
-					   GFP_KERNEL);
+			temp = kmalloc_obj(struct jffs2_sum_xattr_mem);
 			if (!temp)
 				goto no_mem;
 
···
 		}
 		case JFFS2_NODETYPE_XREF: {
 			struct jffs2_sum_xref_mem *temp;
-			temp = kmalloc_obj(struct jffs2_sum_xref_mem,
-					   GFP_KERNEL);
+			temp = kmalloc_obj(struct jffs2_sum_xref_mem);
 			if (!temp)
 				goto no_mem;
 			temp->nodetype = node->r.nodetype;

fs/jffs2/xattr.c

···
 
 	BUG_ON(!(c->flags & JFFS2_SB_FLAG_BUILDING));
 
-	xref_tmphash = kzalloc_objs(struct jffs2_xattr_ref *, XREF_TMPHASH_SIZE,
-				    GFP_KERNEL);
+	xref_tmphash = kzalloc_objs(struct jffs2_xattr_ref *, XREF_TMPHASH_SIZE);
 	if (!xref_tmphash)
 		return -ENOMEM;
 

fs/mbcache.c

···
 	cache->c_max_entries = bucket_count << 4;
 	INIT_LIST_HEAD(&cache->c_list);
 	spin_lock_init(&cache->c_list_lock);
-	cache->c_hash = kmalloc_objs(struct hlist_bl_head, bucket_count,
-				     GFP_KERNEL);
+	cache->c_hash = kmalloc_objs(struct hlist_bl_head, bucket_count);
 	if (!cache->c_hash) {
 		kfree(cache);
 		goto err_out;

fs/nfsd/nfs4proc.c

···
 		if (atomic_inc_return(&nn->pending_async_copies) >
 				(int)rqstp->rq_pool->sp_nrthreads)
 			goto out_dec_async_copy_err;
-		async_copy->cp_src = kmalloc_obj(*async_copy->cp_src,
-						 GFP_KERNEL);
+		async_copy->cp_src = kmalloc_obj(*async_copy->cp_src);
 		if (!async_copy->cp_src)
 			goto out_dec_async_copy_err;
 		if (!nfs4_init_copy_state(nn, copy))

fs/nfsd/nfs4state.c

···
 	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
 	int i;
 
-	nn->conf_id_hashtbl = kmalloc_objs(struct list_head, CLIENT_HASH_SIZE,
-					   GFP_KERNEL);
+	nn->conf_id_hashtbl = kmalloc_objs(struct list_head, CLIENT_HASH_SIZE);
 	if (!nn->conf_id_hashtbl)
 		goto err;
-	nn->unconf_id_hashtbl = kmalloc_objs(struct list_head, CLIENT_HASH_SIZE,
-					     GFP_KERNEL);
+	nn->unconf_id_hashtbl = kmalloc_objs(struct list_head, CLIENT_HASH_SIZE);
 	if (!nn->unconf_id_hashtbl)
 		goto err_unconf_id;
 	nn->sessionid_hashtbl = kmalloc_objs(struct list_head,

fs/ocfs2/cluster/heartbeat.c

···
 	if (reg->hr_tmp_block == NULL)
 		return -ENOMEM;
 
-	reg->hr_slots = kzalloc_objs(struct o2hb_disk_slot, reg->hr_blocks,
-				     GFP_KERNEL);
+	reg->hr_slots = kzalloc_objs(struct o2hb_disk_slot, reg->hr_blocks);
 	if (reg->hr_slots == NULL)
 		return -ENOMEM;
 
···
 			   "at %u blocks per page\n",
 	     reg->hr_num_pages, reg->hr_blocks, spp);
 
-	reg->hr_slot_data = kzalloc_objs(struct page *, reg->hr_num_pages,
-					 GFP_KERNEL);
+	reg->hr_slot_data = kzalloc_objs(struct page *, reg->hr_num_pages);
 	if (!reg->hr_slot_data)
 		return -ENOMEM;
 

fs/ocfs2/journal.c

···
 	if (osb->replay_map)
 		return 0;
 
-	replay_map = kzalloc_flex(*replay_map, rm_replay_slots, osb->max_slots,
-				  GFP_KERNEL);
+	replay_map = kzalloc_flex(*replay_map, rm_replay_slots, osb->max_slots);
 	if (!replay_map) {
 		mlog_errno(-ENOMEM);
 		return -ENOMEM;

fs/ocfs2/slot_map.c

···
 
 	trace_ocfs2_map_slot_buffers(bytes, si->si_blocks);
 
-	si->si_bh = kzalloc_objs(struct buffer_head *, si->si_blocks,
-				 GFP_KERNEL);
+	si->si_bh = kzalloc_objs(struct buffer_head *, si->si_blocks);
 	if (!si->si_bh) {
 		status = -ENOMEM;
 		mlog_errno(status);

fs/orangefs/orangefs-bufmap.c

···
 		goto out_free_bufmap;
 
 	bufmap->desc_array =
-		kzalloc_objs(struct orangefs_bufmap_desc, bufmap->desc_count,
-			     GFP_KERNEL);
+		kzalloc_objs(struct orangefs_bufmap_desc, bufmap->desc_count);
 	if (!bufmap->desc_array)
 		goto out_free_index_array;
 

fs/pstore/ram.c

···
 			 */
 			struct persistent_ram_zone *tmp_prz, *prz_next;
 
-			tmp_prz = kzalloc_obj(struct persistent_ram_zone,
-					      GFP_KERNEL);
+			tmp_prz = kzalloc_obj(struct persistent_ram_zone);
 			if (!tmp_prz)
 				return -ENOMEM;
 			prz = tmp_prz;

fs/select.c

···
 		todo -= walk->len;
 
 		len = min(todo, POLLFD_PER_PAGE);
-		walk = walk->next = kmalloc_flex(*walk, entries, len,
-						 GFP_KERNEL);
+		walk = walk->next = kmalloc_flex(*walk, entries, len);
 		if (!walk) {
 			err = -ENOMEM;
 			goto out_fds;

fs/smb/client/misc.c

···
 	cifs_dbg(FYI, "num_referrals: %d dfs flags: 0x%x ...\n",
 		 *num_of_nodes, le32_to_cpu(rsp->DFSFlags));
 
-	*target_nodes = kzalloc_objs(struct dfs_info3_param, *num_of_nodes,
-				     GFP_KERNEL);
+	*target_nodes = kzalloc_objs(struct dfs_info3_param, *num_of_nodes);
 	if (*target_nodes == NULL) {
 		rc = -ENOMEM;
 		goto parse_DFS_referrals_exit;

fs/xfs/xfs_super.c

···
 	if (!mp)
 		return -ENOMEM;
 #ifdef DEBUG
-	mp->m_errortag = kzalloc_objs(*mp->m_errortag, XFS_ERRTAG_MAX,
-				      GFP_KERNEL);
+	mp->m_errortag = kzalloc_objs(*mp->m_errortag, XFS_ERRTAG_MAX);
 	if (!mp->m_errortag) {
 		kfree(mp);
 		return -ENOMEM;

fs/xfs/xfs_zone_gc.c

···
 	data = kzalloc_obj(*data);
 	if (!data)
 		return NULL;
-	data->iter.recs = kzalloc_objs(*data->iter.recs, XFS_ZONE_GC_RECS,
-				       GFP_KERNEL);
+	data->iter.recs = kzalloc_objs(*data->iter.recs, XFS_ZONE_GC_RECS);
 	if (!data->iter.recs)
 		goto out_free_data;
 

fs/zonefs/super.c

···
 	struct block_device *bdev = zd->sb->s_bdev;
 	int ret;
 
-	zd->zones = kvzalloc_objs(struct blk_zone, bdev_nr_zones(bdev),
-				  GFP_KERNEL);
+	zd->zones = kvzalloc_objs(struct blk_zone, bdev_nr_zones(bdev));
 	if (!zd->zones)
 		return -ENOMEM;
 
···
 	if (!zgroup->g_nr_zones)
 		return 0;
 
-	zgroup->g_zones = kvzalloc_objs(struct zonefs_zone, zgroup->g_nr_zones,
-					GFP_KERNEL);
+	zgroup->g_zones = kvzalloc_objs(struct zonefs_zone, zgroup->g_nr_zones);
 	if (!zgroup->g_zones)
 		return -ENOMEM;
 

include/net/udp.h

···
 	up->forward_threshold = sk->sk_rcvbuf >> 2;
 	set_bit(SOCK_CUSTOM_SOCKOPT, &sk->sk_socket->flags);
 
-	up->udp_prod_queue = kzalloc_objs(*up->udp_prod_queue, nr_node_ids,
-					  GFP_KERNEL);
+	up->udp_prod_queue = kzalloc_objs(*up->udp_prod_queue, nr_node_ids);
 	if (!up->udp_prod_queue)
 		return -ENOMEM;
 	for (int i = 0; i < nr_node_ids; i++)

kernel/bpf/core.c

···
 	struct bpf_prog_pack *pack;
 	int err;
 
-	pack = kzalloc_flex(*pack, bitmap, BITS_TO_LONGS(BPF_PROG_CHUNK_COUNT),
-			    GFP_KERNEL);
+	pack = kzalloc_flex(*pack, bitmap, BITS_TO_LONGS(BPF_PROG_CHUNK_COUNT));
 	if (!pack)
 		return NULL;
 	pack->ptr = bpf_jit_alloc_exec(BPF_PROG_PACK_SIZE);

kernel/gcov/fs.c

···
 	if (!node)
 		goto err_nomem;
 	if (info) {
-		node->loaded_info = kzalloc_objs(struct gcov_info *, 1,
-						 GFP_KERNEL);
+		node->loaded_info = kzalloc_objs(struct gcov_info *, 1);
 		if (!node->loaded_info)
 			goto err_nomem;
 	}

kernel/gcov/gcc_4_7.c

···
 	if (!dup->filename)
 		goto err_free;
 
-	dup->functions = kzalloc_objs(struct gcov_fn_info *, info->n_functions,
-				      GFP_KERNEL);
+	dup->functions = kzalloc_objs(struct gcov_fn_info *, info->n_functions);
 	if (!dup->functions)
 		goto err_free;
 

kernel/locking/locktorture.c

···
 	/* Initialize the statistics so that each run gets its own numbers. */
 	if (nwriters_stress) {
 		lock_is_write_held = false;
-		cxt.lwsa = kmalloc_objs(*cxt.lwsa, cxt.nrealwriters_stress,
-					GFP_KERNEL);
+		cxt.lwsa = kmalloc_objs(*cxt.lwsa, cxt.nrealwriters_stress);
 		if (cxt.lwsa == NULL) {
 			VERBOSE_TOROUT_STRING("cxt.lwsa: Out of memory");
 			firsterr = -ENOMEM;

kernel/padata.c

···
 #endif
 
 	possible_cpus = num_possible_cpus();
-	padata_works = kmalloc_objs(struct padata_work, possible_cpus,
-				    GFP_KERNEL);
+	padata_works = kmalloc_objs(struct padata_work, possible_cpus);
 	if (!padata_works)
 		goto remove_dead_state;
 

kernel/params.c

···
 			return -ENOMEM;
 		mk->mp->grp.name = "parameters";
 		/* NULL-terminated attribute array. */
-		mk->mp->grp.attrs = kzalloc_obj(mk->mp->grp.attrs[0],
-						GFP_KERNEL);
+		mk->mp->grp.attrs = kzalloc_obj(mk->mp->grp.attrs[0]);
 		/* Caller will cleanup via free_module_param_attrs */
 		if (!mk->mp->grp.attrs)
 			return -ENOMEM;

kernel/rcu/rcuscale.c

···
 		}
 
 		for (i = 0; i < kfree_alloc_num; i++) {
-			alloc_ptr = kzalloc_objs(struct kfree_obj, kfree_mult,
-						 GFP_KERNEL);
+			alloc_ptr = kzalloc_objs(struct kfree_obj, kfree_mult);
 			if (!alloc_ptr)
 				return -ENOMEM;
 
···
 		schedule_timeout_uninterruptible(1);
 	writer_tasks = kzalloc_objs(writer_tasks[0], nrealwriters);
 	writer_durations = kcalloc(nrealwriters, sizeof(*writer_durations), GFP_KERNEL);
-	writer_n_durations = kzalloc_objs(*writer_n_durations, nrealwriters,
-					  GFP_KERNEL);
+	writer_n_durations = kzalloc_objs(*writer_n_durations, nrealwriters);
 	writer_done = kzalloc_objs(writer_done[0], nrealwriters);
 	if (gp_async) {
 		if (gp_async_max <= 0) {

kernel/rcu/rcutorture.c

···
 	if (WARN_ON(nocbs_toggle < 0))
 		nocbs_toggle = HZ;
 	if (nrealnocbers > 0) {
-		nocb_tasks = kzalloc_objs(nocb_tasks[0], nrealnocbers,
-					  GFP_KERNEL);
+		nocb_tasks = kzalloc_objs(nocb_tasks[0], nrealnocbers);
 		if (nocb_tasks == NULL) {
 			TOROUT_ERRSTRING("out of memory");
 			firsterr = -ENOMEM;

kernel/sched/ext.c

···
 	if (ret < 0)
 		goto err_free_ei;
 
-	sch->global_dsqs = kzalloc_objs(sch->global_dsqs[0], nr_node_ids,
-					GFP_KERNEL);
+	sch->global_dsqs = kzalloc_objs(sch->global_dsqs[0], nr_node_ids);
 	if (!sch->global_dsqs) {
 		ret = -ENOMEM;
 		goto err_free_hash;

kernel/trace/trace.c

···
 	if (!iter)
 		return ERR_PTR(-ENOMEM);
 
-	iter->buffer_iter = kzalloc_objs(*iter->buffer_iter, nr_cpu_ids,
-					 GFP_KERNEL);
+	iter->buffer_iter = kzalloc_objs(*iter->buffer_iter, nr_cpu_ids);
 	if (!iter->buffer_iter)
 		goto release;
 
···
 	       mod_addr_comp, NULL, NULL);
 
 	if (IS_ENABLED(CONFIG_MODULES)) {
-		module_delta = kzalloc_flex(*module_delta, delta, nr_entries,
-					    GFP_KERNEL);
+		module_delta = kzalloc_flex(*module_delta, delta, nr_entries);
 		if (!module_delta) {
 			pr_info("module_delta allocation failed. Not able to decode module address.");
 			goto reset;
···
 void __init early_trace_init(void)
 {
 	if (tracepoint_printk) {
-		tracepoint_print_iter = kzalloc_obj(*tracepoint_print_iter,
-						    GFP_KERNEL);
+		tracepoint_print_iter = kzalloc_obj(*tracepoint_print_iter);
 		if (MEM_FAIL(!tracepoint_print_iter,
 			     "Failed to allocate trace iterator\n"))
 			tracepoint_printk = 0;

kernel/trace/trace_events_hist.c

···
 			(HIST_FIELD_FL_PERCENT | HIST_FIELD_FL_GRAPH)))
 			continue;
 		if (!stats) {
-			stats = kzalloc_objs(*stats, hist_data->n_vals,
-					     GFP_KERNEL);
+			stats = kzalloc_objs(*stats, hist_data->n_vals);
 			if (!stats) {
 				n_entries = -ENOMEM;
 				goto out;

kernel/trace/trace_probe.c

···
 		if (!earg)
 			return -ENOMEM;
 		earg->size = 2 * tp->nr_args + 1;
-		earg->code = kzalloc_objs(struct fetch_insn, earg->size,
-					  GFP_KERNEL);
+		earg->code = kzalloc_objs(struct fetch_insn, earg->size);
 		if (!earg->code) {
 			kfree(earg);
 			return -ENOMEM;

kernel/unwind/deferred.c

···
 		return -EINVAL;
 
 	if (!info->cache) {
-		info->cache = kzalloc_flex(*cache, entries, UNWIND_MAX_ENTRIES,
-					   GFP_KERNEL);
+		info->cache = kzalloc_flex(*cache, entries, UNWIND_MAX_ENTRIES);
 		if (!info->cache)
 			return -ENOMEM;
 	}

lib/assoc_array.c

···
 			node = parent;
 
 			/* Create a new node to collapse into */
-			new_n0 = kzalloc_obj(struct assoc_array_node,
-					     GFP_KERNEL);
+			new_n0 = kzalloc_obj(struct assoc_array_node);
 			if (!new_n0)
 				goto enomem;
 			edit->new_meta[0] = assoc_array_node_to_ptr(new_n0);

lib/kunit/executor.c

···
 	/* Parse attribute filters */
 	if (filters) {
 		filter_count = kunit_get_filter_count(filters);
-		parsed_filters = kzalloc_objs(*parsed_filters, filter_count,
-					      GFP_KERNEL);
+		parsed_filters = kzalloc_objs(*parsed_filters, filter_count);
 		if (!parsed_filters) {
 			*err = -ENOMEM;
 			goto free_parsed_glob;

lib/tests/test_ratelimit.c

···
 	int i;
 	const int n_stress_kthread = cpumask_weight(cpu_online_mask);
 	struct stress_kthread skt = { 0 };
-	struct stress_kthread *sktp = kzalloc_objs(*sktp, n_stress_kthread,
-						   GFP_KERNEL);
+	struct stress_kthread *sktp = kzalloc_objs(*sktp, n_stress_kthread);
 
 	KUNIT_EXPECT_NOT_NULL_MSG(test, sktp, "Memory allocation failure");
 	for (i = 0; i < n_stress_kthread; i++) {

mm/damon/sysfs-schemes.c

···
 static struct damon_sysfs_scheme_region *damon_sysfs_scheme_region_alloc(
 		struct damon_region *region)
 {
-	struct damon_sysfs_scheme_region *sysfs_region = kmalloc_obj(*sysfs_region,
-								     GFP_KERNEL);
+	struct damon_sysfs_scheme_region *sysfs_region = kmalloc_obj(*sysfs_region);
 
 	if (!sysfs_region)
 		return NULL;
···
 static struct damon_sysfs_scheme_regions *
 damon_sysfs_scheme_regions_alloc(void)
 {
-	struct damon_sysfs_scheme_regions *regions = kmalloc_obj(*regions,
-								 GFP_KERNEL);
+	struct damon_sysfs_scheme_regions *regions = kmalloc_obj(*regions);
 
 	if (!regions)
 		return NULL;
···
 		enum damos_wmark_metric metric, unsigned long interval_us,
 		unsigned long high, unsigned long mid, unsigned long low)
 {
-	struct damon_sysfs_watermarks *watermarks = kmalloc_obj(*watermarks,
-								GFP_KERNEL);
+	struct damon_sysfs_watermarks *watermarks = kmalloc_obj(*watermarks);
 
 	if (!watermarks)
 		return NULL;
···
 static
 struct damon_sysfs_access_pattern *damon_sysfs_access_pattern_alloc(void)
 {
-	struct damon_sysfs_access_pattern *access_pattern = kmalloc_obj(*access_pattern,
-									GFP_KERNEL);
+	struct damon_sysfs_access_pattern *access_pattern = kmalloc_obj(*access_pattern);
 
 	if (!access_pattern)
 		return NULL;
···
 	struct damos_migrate_dests *dests = &scheme->migrate_dests;
 	int i;
 
-	dests->node_id_arr = kmalloc_objs(*dests->node_id_arr, sysfs_dests->nr,
-					  GFP_KERNEL);
+	dests->node_id_arr = kmalloc_objs(*dests->node_id_arr, sysfs_dests->nr);
 	if (!dests->node_id_arr)
 		return -ENOMEM;
-	dests->weight_arr = kmalloc_objs(*dests->weight_arr, sysfs_dests->nr,
-					 GFP_KERNEL);
+	dests->weight_arr = kmalloc_objs(*dests->weight_arr, sysfs_dests->nr);
 	if (!dests->weight_arr)
 		/* ->node_id_arr will be freed by scheme destruction */
 		return -ENOMEM;

mm/damon/sysfs.c

···
 		unsigned long sample_us, unsigned long aggr_us,
 		unsigned long update_us)
 {
-	struct damon_sysfs_intervals *intervals = kmalloc_obj(*intervals,
-							      GFP_KERNEL);
+	struct damon_sysfs_intervals *intervals = kmalloc_obj(*intervals);
 
 	if (!intervals)
 		return NULL;

mm/damon/tests/core-kunit.h

···
 {
 	size_t i;
 
-	dests->node_id_arr = kmalloc_objs(*dests->node_id_arr, nr_dests,
-					  GFP_KERNEL);
+	dests->node_id_arr = kmalloc_objs(*dests->node_id_arr, nr_dests);
 	if (!dests->node_id_arr)
 		return -ENOMEM;
-	dests->weight_arr = kmalloc_objs(*dests->weight_arr, nr_dests,
-					 GFP_KERNEL);
+	dests->weight_arr = kmalloc_objs(*dests->weight_arr, nr_dests);
 	if (!dests->weight_arr) {
 		kfree(dests->node_id_arr);
 		dests->node_id_arr = NULL;

mm/damon/vaddr.c

···
 	use_target_nid = dests->nr_dests == 0;
 	nr_dests = use_target_nid ? 1 : dests->nr_dests;
 	priv.scheme = s;
-	priv.migration_lists = kmalloc_objs(*priv.migration_lists, nr_dests,
-					    GFP_KERNEL);
+	priv.migration_lists = kmalloc_objs(*priv.migration_lists, nr_dests);
 	if (!priv.migration_lists)
 		return 0;
 

mm/ksm.c

···
 			 * Allocate stable and unstable together:
 			 * MAXSMP NODES_SHIFT 10 will use 16kB.
 			 */
-			buf = kzalloc_objs(*buf, nr_node_ids + nr_node_ids,
-					   GFP_KERNEL);
+			buf = kzalloc_objs(*buf, nr_node_ids + nr_node_ids);
 			/* Let us assume that RB_ROOT is NULL is zero */
 			if (!buf)
 				err = -ENOMEM;

mm/memory-tiers.c

···
 		panic("%s() failed to register memory tier subsystem\n", __func__);
 
 #ifdef CONFIG_MIGRATION
-	node_demotion = kzalloc_objs(struct demotion_nodes, nr_node_ids,
-				     GFP_KERNEL);
+	node_demotion = kzalloc_objs(struct demotion_nodes, nr_node_ids);
 	WARN_ON(!node_demotion);
 #endif
 

mm/mempolicy.c

···
 	if (!new_bw)
 		return -ENOMEM;
 
-	new_wi_state = kmalloc_flex(*new_wi_state, iw_table, nr_node_ids,
-				    GFP_KERNEL);
+	new_wi_state = kmalloc_flex(*new_wi_state, iw_table, nr_node_ids);
 	if (!new_wi_state) {
 		kfree(new_bw);
 		return -ENOMEM;
···
 	    kstrtou8(buf, 0, &weight) || weight == 0)
 		return -EINVAL;
 
-	new_wi_state = kzalloc_flex(*new_wi_state, iw_table, nr_node_ids,
-				    GFP_KERNEL);
+	new_wi_state = kzalloc_flex(*new_wi_state, iw_table, nr_node_ids);
 	if (!new_wi_state)
 		return -ENOMEM;
 
···
 	if (kstrtobool(buf, &input))
 		return -EINVAL;
 
-	new_wi_state = kzalloc_flex(*new_wi_state, iw_table, nr_node_ids,
-				    GFP_KERNEL);
+	new_wi_state = kzalloc_flex(*new_wi_state, iw_table, nr_node_ids);
 	if (!new_wi_state)
 		return -ENOMEM;
 	for (i = 0; i < nr_node_ids; i++)

mm/mmu_notifier.c

···
 		 * know that mm->notifier_subscriptions can't change while we
 		 * hold the write side of the mmap_lock.
 		 */
-		subscriptions = kzalloc_obj(struct mmu_notifier_subscriptions,
-					    GFP_KERNEL);
+		subscriptions = kzalloc_obj(struct mmu_notifier_subscriptions);
 		if (!subscriptions)
 			return -ENOMEM;
 

mm/swapfile.c

···
 		spin_lock_init(&cluster_info[i].lock);
 
 	if (!(si->flags & SWP_SOLIDSTATE)) {
-		si->global_cluster = kmalloc_obj(*si->global_cluster,
-						 GFP_KERNEL);
+		si->global_cluster = kmalloc_obj(*si->global_cluster);
 		if (!si->global_cluster)
 			goto err;
 		for (i = 0; i < SWAP_NR_ORDERS; i++)

net/bluetooth/l2cap_sock.c

···
 	    (chan->mode == L2CAP_MODE_ERTM ||
 	     chan->mode == L2CAP_MODE_LE_FLOWCTL ||
 	     chan->mode == L2CAP_MODE_EXT_FLOWCTL)) {
-		struct l2cap_rx_busy *rx_busy = kmalloc_obj(*rx_busy,
-							    GFP_KERNEL);
+		struct l2cap_rx_busy *rx_busy = kmalloc_obj(*rx_busy);
 		if (!rx_busy) {
 			err = -ENOMEM;
 			goto done;

net/can/af_can.c

···
 static int can_pernet_init(struct net *net)
 {
 	spin_lock_init(&net->can.rcvlists_lock);
-	net->can.rx_alldev_list = kzalloc_obj(*net->can.rx_alldev_list,
-					      GFP_KERNEL);
+	net->can.rx_alldev_list = kzalloc_obj(*net->can.rx_alldev_list);
 	if (!net->can.rx_alldev_list)
 		goto out;
 	net->can.pkg_stats = kzalloc_obj(*net->can.pkg_stats);
 	if (!net->can.pkg_stats)
 		goto out_free_rx_alldev_list;
-	net->can.rcv_lists_stats = kzalloc_obj(*net->can.rcv_lists_stats,
-					       GFP_KERNEL);
+	net->can.rcv_lists_stats = kzalloc_obj(*net->can.rcv_lists_stats);
 	if (!net->can.rcv_lists_stats)
 		goto out_free_pkg_stats;
 

net/ceph/mon_client.c

···
 	int i;
 
 	/* build initial monmap */
-	monc->monmap = kzalloc_flex(*monc->monmap, mon_inst, num_mon,
-				    GFP_KERNEL);
+	monc->monmap = kzalloc_flex(*monc->monmap, mon_inst, num_mon);
 	if (!monc->monmap)
 		return -ENOMEM;
 	monc->monmap->num_mon = num_mon;

net/core/dev.c

···
 	int err;
 	int rc;
 
-	dev->offload_xstats_l3 = kzalloc_obj(*dev->offload_xstats_l3,
-					     GFP_KERNEL);
+	dev->offload_xstats_l3 = kzalloc_obj(*dev->offload_xstats_l3);
 	if (!dev->offload_xstats_l3)
 		return -ENOMEM;
 

net/core/drop_monitor.c

···
 	struct net_dm_hw_entries *hw_entries;
 	unsigned long flags;
 
-	hw_entries = kzalloc_flex(*hw_entries, entries, dm_hit_limit,
-				  GFP_KERNEL);
+	hw_entries = kzalloc_flex(*hw_entries, entries, dm_hit_limit);
 	if (!hw_entries) {
 		/* If the memory allocation failed, we try to perform another
 		 * allocation in 1/10 second. Otherwise, the probe function

net/core/flow_offload.c

···
 	struct flow_offload_action *fl_action;
 	int i;
 
-	fl_action = kzalloc_flex(*fl_action, action.entries, num_actions,
-				 GFP_KERNEL);
+	fl_action = kzalloc_flex(*fl_action, action.entries, num_actions);
 	if (!fl_action)
 		return NULL;
 

net/ethtool/mse.c

···
 	if (!data->capability.supported_caps)
 		return 0;
 
-	data->snapshots = kzalloc_objs(*data->snapshots, PHY_MSE_CHANNEL_COUNT,
-				       GFP_KERNEL);
+	data->snapshots = kzalloc_objs(*data->snapshots, PHY_MSE_CHANNEL_COUNT);
 	if (!data->snapshots)
 		return -ENOMEM;
 

net/ipv4/af_inet.c

···
 	net->mib.icmp_statistics = alloc_percpu(struct icmp_mib);
 	if (!net->mib.icmp_statistics)
 		goto err_icmp_mib;
-	net->mib.icmpmsg_statistics = kzalloc_obj(struct icmpmsg_mib,
-						  GFP_KERNEL);
+	net->mib.icmpmsg_statistics = kzalloc_obj(struct icmpmsg_mib);
 	if (!net->mib.icmpmsg_statistics)
 		goto err_icmpmsg_mib;
 

net/ipv4/fib_semantics.c

···
 static struct hlist_head *fib_info_hash_alloc(unsigned int hash_bits)
 {
 	/* The second half is used for prefsrc */
-	return kvzalloc_objs(struct hlist_head, (1 << hash_bits) * 2,
-			     GFP_KERNEL);
+	return kvzalloc_objs(struct hlist_head, (1 << hash_bits) * 2);
 }
 
 static void fib_info_hash_free(struct hlist_head *head)

net/ipv4/nexthop.c

···
 	int i;
 
 	info->type = NH_NOTIFIER_INFO_TYPE_GRP;
-	info->nh_grp = kzalloc_flex(*info->nh_grp, nh_entries, num_nh,
-				    GFP_KERNEL);
+	info->nh_grp = kzalloc_flex(*info->nh_grp, nh_entries, num_nh);
 	if (!info->nh_grp)
 		return -ENOMEM;
 

net/ipv6/addrconf.c

···
 	}
 
 
-	idev->stats.icmpv6dev = kzalloc_obj(struct icmpv6_mib_device,
-					    GFP_KERNEL);
+	idev->stats.icmpv6dev = kzalloc_obj(struct icmpv6_mib_device);
 	if (!idev->stats.icmpv6dev)
 		goto err_icmp;
 	idev->stats.icmpv6msgdev = kzalloc_obj(struct icmpv6msg_mib_device,

net/ipv6/af_inet6.c

···
 	net->mib.icmpv6_statistics = alloc_percpu(struct icmpv6_mib);
 	if (!net->mib.icmpv6_statistics)
 		goto err_icmp_mib;
-	net->mib.icmpv6msg_statistics = kzalloc_obj(struct icmpv6msg_mib,
-						    GFP_KERNEL);
+	net->mib.icmpv6msg_statistics = kzalloc_obj(struct icmpv6msg_mib);
 	if (!net->mib.icmpv6msg_statistics)
 		goto err_icmpmsg_mib;
 	return 0;

net/ipv6/ip6_fib.c

···
 
 	spin_lock_init(&net->ipv6.fib_table_hash_lock);
 
-	net->ipv6.fib6_main_tbl = kzalloc_obj(*net->ipv6.fib6_main_tbl,
-					      GFP_KERNEL);
+	net->ipv6.fib6_main_tbl = kzalloc_obj(*net->ipv6.fib6_main_tbl);
 	if (!net->ipv6.fib6_main_tbl)
 		goto out_fib_table_hash;
 
···
 	INIT_HLIST_HEAD(&net->ipv6.fib6_main_tbl->tb6_gc_hlist);
 
 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
-	net->ipv6.fib6_local_tbl = kzalloc_obj(*net->ipv6.fib6_local_tbl,
-					       GFP_KERNEL);
+	net->ipv6.fib6_local_tbl = kzalloc_obj(*net->ipv6.fib6_local_tbl);
 	if (!net->ipv6.fib6_local_tbl)
 		goto out_fib6_main_tbl;
 	net->ipv6.fib6_local_tbl->tb6_id = RT6_TABLE_LOCAL;

net/mac80211/util.c

···
 	if (WARN_ON(res))
 		return res;
 
-	funcs = kzalloc_objs(*funcs, sdata->local->hw.max_nan_de_entries + 1,
-			     GFP_KERNEL);
+	funcs = kzalloc_objs(*funcs, sdata->local->hw.max_nan_de_entries + 1);
 	if (!funcs)
 		return -ENOMEM;
 

net/netfilter/ipvs/ip_vs_conn.c

···
 	 */
 	tab_array_size = array_size(ip_vs_conn_tab_size,
 				    sizeof(*ip_vs_conn_tab));
-	ip_vs_conn_tab = kvmalloc_objs(*ip_vs_conn_tab, ip_vs_conn_tab_size,
-				       GFP_KERNEL);
+	ip_vs_conn_tab = kvmalloc_objs(*ip_vs_conn_tab, ip_vs_conn_tab_size);
 	if (!ip_vs_conn_tab)
 		return -ENOMEM;
 

net/netfilter/ipvs/ip_vs_mh.c

···
 	if (!s)
 		return -ENOMEM;
 
-	s->lookup = kzalloc_objs(struct ip_vs_mh_lookup, IP_VS_MH_TAB_SIZE,
-				 GFP_KERNEL);
+	s->lookup = kzalloc_objs(struct ip_vs_mh_lookup, IP_VS_MH_TAB_SIZE);
 	if (!s->lookup) {
 		kfree(s);
 		return -ENOMEM;

net/netfilter/nfnetlink_cthelper.c

···
 	struct nf_conntrack_expect_policy *policy;
 	int i, ret = 0;
 
-	new_policy = kmalloc_objs(*new_policy, helper->expect_class_max + 1,
-				  GFP_KERNEL);
+	new_policy = kmalloc_objs(*new_policy, helper->expect_class_max + 1);
 	if (!new_policy)
 		return -ENOMEM;
 

net/netlink/policy.c

···
 {
 	struct netlink_policy_dump_state *state;
 
-	state = kzalloc_flex(*state, policies, INITIAL_POLICIES_ALLOC,
-			     GFP_KERNEL);
+	state = kzalloc_flex(*state, policies, INITIAL_POLICIES_ALLOC);
 	if (!state)
 		return ERR_PTR(-ENOMEM);
 	state->n_alloc = INITIAL_POLICIES_ALLOC;

net/openvswitch/conntrack.c

···
 {
 	int i, err;
 
-	ovs_net->ct_limit_info = kmalloc_obj(*ovs_net->ct_limit_info,
-					     GFP_KERNEL);
+	ovs_net->ct_limit_info = kmalloc_obj(*ovs_net->ct_limit_info);
 	if (!ovs_net->ct_limit_info)
 		return -ENOMEM;
 
 	ovs_net->ct_limit_info->default_limit = OVS_CT_LIMIT_DEFAULT;
 	ovs_net->ct_limit_info->limits =
-		kmalloc_objs(struct hlist_head, CT_LIMIT_HASH_BUCKETS,
-			     GFP_KERNEL);
+		kmalloc_objs(struct hlist_head, CT_LIMIT_HASH_BUCKETS);
 	if (!ovs_net->ct_limit_info->limits) {
 		kfree(ovs_net->ct_limit_info);
 		return -ENOMEM;

net/openvswitch/datapath.c

···
 {
 	int i;
 
-	dp->ports = kmalloc_objs(struct hlist_head, DP_VPORT_HASH_BUCKETS,
-				 GFP_KERNEL);
+	dp->ports = kmalloc_objs(struct hlist_head, DP_VPORT_HASH_BUCKETS);
 	if (!dp->ports)
 		return -ENOMEM;
 

net/openvswitch/vport.c

···
  */
 int ovs_vport_init(void)
 {
-	dev_table = kzalloc_objs(struct hlist_head, VPORT_HASH_BUCKETS,
-				 GFP_KERNEL);
+	dev_table = kzalloc_objs(struct hlist_head, VPORT_HASH_BUCKETS);
 	if (!dev_table)
 		return -ENOMEM;
 

net/packet/af_packet.c

···
 			/* legacy PACKET_FANOUT_MAX */
 			args->max_num_members = 256;
 		err = -ENOMEM;
-		match = kvzalloc_flex(*match, arr, args->max_num_members,
-				      GFP_KERNEL);
+		match = kvzalloc_flex(*match, arr, args->max_num_members);
 		if (!match)
 			goto out;
 		write_pnet(&match->net, sock_net(sk));

net/rds/ib.c

···
 	rds_ibdev->max_initiator_depth = device->attrs.max_qp_init_rd_atom;
 	rds_ibdev->max_responder_resources = device->attrs.max_qp_rd_atom;
 
-	rds_ibdev->vector_load = kzalloc_objs(int, device->num_comp_vectors,
-					      GFP_KERNEL);
+	rds_ibdev->vector_load = kzalloc_objs(int, device->num_comp_vectors);
 	if (!rds_ibdev->vector_load) {
 		pr_err("RDS/IB: %s failed to allocate vector memory\n",
 			__func__);

net/rds/rdma.c

···
 		 * would have to use GFP_ATOMIC there, and don't want to deal
 		 * with failed allocations.
 		 */
-		rm->atomic.op_notifier = kmalloc_obj(*rm->atomic.op_notifier,
-						     GFP_KERNEL);
+		rm->atomic.op_notifier = kmalloc_obj(*rm->atomic.op_notifier);
 		if (!rm->atomic.op_notifier) {
 			ret = -ENOMEM;
 			goto err;

net/sched/cls_api.c

···
 	 * This reference might be taken later from tcf_exts_get_net().
 	 */
 	exts->net = net;
-	exts->actions = kzalloc_objs(struct tc_action *, TCA_ACT_MAX_PRIO,
-				     GFP_KERNEL);
+	exts->actions = kzalloc_objs(struct tc_action *, TCA_ACT_MAX_PRIO);
 	if (!exts->actions)
 		return -ENOMEM;
 #endif

net/sched/cls_u32.c

···
 #ifdef CONFIG_NET_CLS_ACT
 	pr_info("    Actions configured\n");
 #endif
-	tc_u_common_hash = kvmalloc_objs(struct hlist_head, U32_HASH_SIZE,
-					 GFP_KERNEL);
+	tc_u_common_hash = kvmalloc_objs(struct hlist_head, U32_HASH_SIZE);
 	if (!tc_u_common_hash)
 		return -ENOMEM;
 

net/sched/sch_cake.c

···
 	for (i = 1; i <= CAKE_QUEUES; i++)
 		quantum_div[i] = 65535 / i;
 
-	qd->tins = kvzalloc_objs(struct cake_tin_data, CAKE_MAX_TINS,
-				 GFP_KERNEL);
+	qd->tins = kvzalloc_objs(struct cake_tin_data, CAKE_MAX_TINS);
 	if (!qd->tins)
 		return -ENOMEM;
 

net/sched/sch_fq_codel.c

···
 		goto init_failure;
 
 	if (!q->flows) {
-		q->flows = kvzalloc_objs(struct fq_codel_flow, q->flows_cnt,
-					 GFP_KERNEL);
+		q->flows = kvzalloc_objs(struct fq_codel_flow, q->flows_cnt);
 		if (!q->flows) {
 			err = -ENOMEM;
 			goto init_failure;

net/sched/sch_hhf.c

···
 
 	if (!q->hh_flows) {
 		/* Initialize heavy-hitter flow table. */
-		q->hh_flows = kvzalloc_objs(struct list_head, HH_FLOWS_CNT,
-					    GFP_KERNEL);
+		q->hh_flows = kvzalloc_objs(struct list_head, HH_FLOWS_CNT);
 		if (!q->hh_flows)
 			return -ENOMEM;
 		for (i = 0; i < HH_FLOWS_CNT; i++)

net/sched/sch_mq.c

···
 		return -EOPNOTSUPP;
 
 	/* pre-allocate qdiscs, attachment can't fail */
-	priv->qdiscs = kzalloc_objs(priv->qdiscs[0], dev->num_tx_queues,
-				    GFP_KERNEL);
+	priv->qdiscs = kzalloc_objs(priv->qdiscs[0], dev->num_tx_queues);
 	if (!priv->qdiscs)
 		return -ENOMEM;
 

net/sched/sch_mqprio.c

···
 	}
 
 	/* pre-allocate qdisc, attachment can't fail */
-	priv->qdiscs = kzalloc_objs(priv->qdiscs[0], dev->num_tx_queues,
-				    GFP_KERNEL);
+	priv->qdiscs = kzalloc_objs(priv->qdiscs[0], dev->num_tx_queues);
 	if (!priv->qdiscs)
 		return -ENOMEM;
 

net/sched/sch_taprio.c

···
 {
 	struct __tc_taprio_qopt_offload *__offload;
 
-	__offload = kzalloc_flex(*__offload, offload.entries, num_entries,
-				 GFP_KERNEL);
+	__offload = kzalloc_flex(*__offload, offload.entries, num_entries);
 	if (!__offload)
 		return NULL;
 

net/smc/smc_wr.c

···
 				   GFP_KERNEL);
 	if (!link->wr_rx_bufs)
 		goto no_mem_wr_tx_bufs;
-	link->wr_tx_ibs = kzalloc_objs(link->wr_tx_ibs[0], link->max_send_wr,
-				       GFP_KERNEL);
+	link->wr_tx_ibs = kzalloc_objs(link->wr_tx_ibs[0], link->max_send_wr);
 	if (!link->wr_tx_ibs)
 		goto no_mem_wr_rx_bufs;
-	link->wr_rx_ibs = kzalloc_objs(link->wr_rx_ibs[0], link->max_recv_wr,
-				       GFP_KERNEL);
+	link->wr_rx_ibs = kzalloc_objs(link->wr_rx_ibs[0], link->max_recv_wr);
 	if (!link->wr_rx_ibs)
 		goto no_mem_wr_tx_ibs;
 	link->wr_tx_rdmas = kzalloc_objs(link->wr_tx_rdmas[0],
···
 					     link->max_send_wr, GFP_KERNEL);
 	if (!link->wr_tx_rdma_sges)
 		goto no_mem_wr_tx_rdmas;
-	link->wr_tx_sges = kzalloc_objs(link->wr_tx_sges[0], link->max_send_wr,
-					GFP_KERNEL);
+	link->wr_tx_sges = kzalloc_objs(link->wr_tx_sges[0], link->max_send_wr);
 	if (!link->wr_tx_sges)
 		goto no_mem_wr_tx_rdma_sges;
 	link->wr_rx_sges = kcalloc(link->max_recv_wr,
···
 		link->wr_tx_v2_ib = kzalloc_obj(*link->wr_tx_v2_ib);
 		if (!link->wr_tx_v2_ib)
 			goto no_mem_tx_compl;
-		link->wr_tx_v2_sge = kzalloc_obj(*link->wr_tx_v2_sge,
-						 GFP_KERNEL);
+		link->wr_tx_v2_sge = kzalloc_obj(*link->wr_tx_v2_sge);
 		if (!link->wr_tx_v2_sge)
 			goto no_mem_v2_ib;
-		link->wr_tx_v2_pend = kzalloc_obj(*link->wr_tx_v2_pend,
-						  GFP_KERNEL);
+		link->wr_tx_v2_pend = kzalloc_obj(*link->wr_tx_v2_pend);
 		if (!link->wr_tx_v2_pend)
 			goto no_mem_v2_sge;
 	}

net/sunrpc/auth_gss/auth_gss.c

···
 	last = (snd_buf->page_base + snd_buf->page_len - 1) >> PAGE_SHIFT;
 	rqstp->rq_enc_pages_num = last - first + 1 + 1;
 	rqstp->rq_enc_pages
-		= kmalloc_objs(struct page *, rqstp->rq_enc_pages_num,
-			       GFP_KERNEL);
+		= kmalloc_objs(struct page *, rqstp->rq_enc_pages_num);
 	if (!rqstp->rq_enc_pages)
 		goto out;
 	for (i=0; i < rqstp->rq_enc_pages_num; i++) {

net/sunrpc/cache.c

···
 	if (cd == NULL)
 		return ERR_PTR(-ENOMEM);
 
-	cd->hash_table = kzalloc_objs(struct hlist_head, cd->hash_size,
-				      GFP_KERNEL);
+	cd->hash_table = kzalloc_objs(struct hlist_head, cd->hash_size);
 	if (cd->hash_table == NULL) {
 		kfree(cd);
 		return ERR_PTR(-ENOMEM);

net/sunrpc/svcsock.c

···
 		return ERR_PTR(-ENOMEM);
 
 	if (sendpages) {
-		svsk->sk_bvec = kzalloc_objs(*svsk->sk_bvec, sendpages,
-					     GFP_KERNEL);
+		svsk->sk_bvec = kzalloc_objs(*svsk->sk_bvec, sendpages);
 		if (!svsk->sk_bvec) {
 			kfree(svsk);
 			return ERR_PTR(-ENOMEM);

net/tipc/netlink_compat.c

···
 		return -ENOMEM;
 	}
 
-	attrbuf = kzalloc_objs(struct nlattr *, tipc_genl_family.maxattr + 1,
-			       GFP_KERNEL);
+	attrbuf = kzalloc_objs(struct nlattr *, tipc_genl_family.maxattr + 1);
 	if (!attrbuf) {
 		err = -ENOMEM;
 		goto err_out;
···
 	if (!trans_buf)
 		return -ENOMEM;
 
-	attrbuf = kmalloc_objs(struct nlattr *, tipc_genl_family.maxattr + 1,
-			       GFP_KERNEL);
+	attrbuf = kmalloc_objs(struct nlattr *, tipc_genl_family.maxattr + 1);
 	if (!attrbuf) {
 		err = -ENOMEM;
 		goto trans_out;

net/unix/af_unix.c

···
 		goto err_sysctl;
 #endif
 
-	net->unx.table.locks = kvmalloc_objs(spinlock_t, UNIX_HASH_SIZE,
-					     GFP_KERNEL);
+	net->unx.table.locks = kvmalloc_objs(spinlock_t, UNIX_HASH_SIZE);
 	if (!net->unx.table.locks)
 		goto err_proc;
 

net/wireless/nl80211.c

···
 		struct nlattr **attrbuf_free = NULL;
 
 		if (!attrbuf) {
-			attrbuf = kzalloc_objs(*attrbuf, NUM_NL80211_ATTR,
-					       GFP_KERNEL);
+			attrbuf = kzalloc_objs(*attrbuf, NUM_NL80211_ATTR);
 			if (!attrbuf)
 				return -ENOMEM;
 			attrbuf_free = attrbuf;
···
 	if (n_patterns > coalesce->n_patterns)
 		return -EINVAL;
 
-	new_rule->patterns = kzalloc_objs(new_rule->patterns[0], n_patterns,
-					  GFP_KERNEL);
+	new_rule->patterns = kzalloc_objs(new_rule->patterns[0], n_patterns);
 	if (!new_rule->patterns)
 		return -ENOMEM;
 
···
 
 			func->srf_num_macs = n_entries;
 			func->srf_macs =
-				kzalloc_objs(*func->srf_macs, n_entries,
-					     GFP_KERNEL);
+				kzalloc_objs(*func->srf_macs, n_entries);
 			if (!func->srf_macs) {
 				err = -ENOMEM;
 				goto out;

net/xdp/xsk_buff_pool.c

···
 
 int xp_alloc_tx_descs(struct xsk_buff_pool *pool, struct xdp_sock *xs)
 {
-	pool->tx_descs = kvzalloc_objs(*pool->tx_descs, xs->tx->nentries,
-				       GFP_KERNEL);
+	pool->tx_descs = kvzalloc_objs(*pool->tx_descs, xs->tx->nentries);
 	if (!pool->tx_descs)
 		return -ENOMEM;
 
···
 	if (!dma_map)
 		return NULL;
 
-	dma_map->dma_pages = kvzalloc_objs(*dma_map->dma_pages, nr_pages,
-					   GFP_KERNEL);
+	dma_map->dma_pages = kvzalloc_objs(*dma_map->dma_pages, nr_pages);
 	if (!dma_map->dma_pages) {
 		kfree(dma_map);
 		return NULL;

security/apparmor/policy_unpack.c

···
 		if (!aa_unpack_array(e, NULL, &size))
 			goto fail;
 
-		rules->secmark = kzalloc_objs(struct aa_secmark, size,
-					      GFP_KERNEL);
+		rules->secmark = kzalloc_objs(struct aa_secmark, size);
 		if (!rules->secmark)
 			goto fail;
 

security/integrity/ima/ima_policy.c

···
 	for (rules = arch_rules; *rules != NULL; rules++)
 		arch_entries++;
 
-	arch_policy_entry = kzalloc_objs(*arch_policy_entry, arch_entries + 1,
-					 GFP_KERNEL);
+	arch_policy_entry = kzalloc_objs(*arch_policy_entry, arch_entries + 1);
 	if (!arch_policy_entry)
 		return 0;
 

security/selinux/ss/conditional.c

···
 		return rc;
 
 	newp->cond_list_len = 0;
-	newp->cond_list = kzalloc_objs(*newp->cond_list, origp->cond_list_len,
-				       GFP_KERNEL);
+	newp->cond_list = kzalloc_objs(*newp->cond_list, origp->cond_list_len);
 	if (!newp->cond_list)
 		goto error;
 

security/selinux/ss/policydb.c

···
 					return rc;
 				if (p->policyvers >=
 				    POLICYDB_VERSION_CONSTRAINT_NAMES) {
-					e->type_names = kzalloc_obj(*e->type_names,
-								    GFP_KERNEL);
+					e->type_names = kzalloc_obj(*e->type_names);
 					if (!e->type_names)
 						return -ENOMEM;
 					type_set_init(e->type_names);

sound/aoa/codecs/onyx.c

···
 	/* if no inputs are present... */
 	if ((onyx->codec.connected & 0xC) == 0) {
 		if (!onyx->codec_info)
-			onyx->codec_info = kmalloc_obj(struct codec_info,
-						       GFP_KERNEL);
+			onyx->codec_info = kmalloc_obj(struct codec_info);
 		if (!onyx->codec_info)
 			return -ENOMEM;
 		ci = onyx->codec_info;
···
 	/* if no outputs are present... */
 	if ((onyx->codec.connected & 3) == 0) {
 		if (!onyx->codec_info)
-			onyx->codec_info = kmalloc_obj(struct codec_info,
-						       GFP_KERNEL);
+			onyx->codec_info = kmalloc_obj(struct codec_info);
 		if (!onyx->codec_info)
 			return -ENOMEM;
 		ci = onyx->codec_info;

sound/core/oss/pcm_plugin.c

···
 		channels = src_format->channels;
 	else
 		channels = dst_format->channels;
-	plugin->buf_channels = kzalloc_objs(*plugin->buf_channels, channels,
-					    GFP_KERNEL);
+	plugin->buf_channels = kzalloc_objs(*plugin->buf_channels, channels);
 	if (plugin->buf_channels == NULL) {
 		snd_pcm_plugin_free(plugin);
 		return -ENOMEM;

sound/core/seq/seq_memory.c

···
 	if (snd_BUG_ON(!pool))
 		return -EINVAL;
 
-	cellptr = kvmalloc_objs(struct snd_seq_event_cell, pool->size,
-				GFP_KERNEL);
+	cellptr = kvmalloc_objs(struct snd_seq_event_cell, pool->size);
 	if (!cellptr)
 		return -ENOMEM;
 

sound/core/ump.c

···
 	bool input, output;
 	int err, num;
 
-	ump->out_cvts = kzalloc_objs(*ump->out_cvts, SNDRV_UMP_MAX_GROUPS,
-				     GFP_KERNEL);
+	ump->out_cvts = kzalloc_objs(*ump->out_cvts, SNDRV_UMP_MAX_GROUPS);
 	if (!ump->out_cvts)
 		return -ENOMEM;
 

sound/drivers/vx/vx_pcm.c

···
 	chip->audio_info = rmh.Stat[1];
 
 	/* allocate pipes */
-	chip->playback_pipes = kzalloc_objs(struct vx_pipe *, chip->audio_outs,
-					    GFP_KERNEL);
+	chip->playback_pipes = kzalloc_objs(struct vx_pipe *, chip->audio_outs);
 	if (!chip->playback_pipes)
 		return -ENOMEM;
-	chip->capture_pipes = kzalloc_objs(struct vx_pipe *, chip->audio_ins,
-					   GFP_KERNEL);
+	chip->capture_pipes = kzalloc_objs(struct vx_pipe *, chip->audio_ins);
 	if (!chip->capture_pipes) {
 		kfree(chip->playback_pipes);
 		return -ENOMEM;

sound/hda/codecs/ca0132.c

···
 	 */
 	if (ca0132_use_pci_mmio(spec))
 		spec->desktop_init_verbs = ca0132_init_verbs1;
-	spec->spec_init_verbs = kzalloc_objs(struct hda_verb, NUM_SPEC_VERBS,
-					     GFP_KERNEL);
+	spec->spec_init_verbs = kzalloc_objs(struct hda_verb, NUM_SPEC_VERBS);
 	if (!spec->spec_init_verbs)
 		return -ENOMEM;
 

sound/hda/common/proc.c

···
 		if (wid_caps & AC_WCAP_CONN_LIST) {
 			conn_len = snd_hda_get_num_raw_conns(codec, nid);
 			if (conn_len > 0) {
-				conn = kmalloc_objs(hda_nid_t, conn_len,
-						    GFP_KERNEL);
+				conn = kmalloc_objs(hda_nid_t, conn_len);
 				if (!conn)
 					return;
 				if (snd_hda_get_raw_connections(codec, nid, conn,

sound/hda/core/ext/stream.c

···
 		setup_op = snd_hdac_stream_setup;
 
 	for (i = 0; i < num_stream; i++) {
-		struct hdac_ext_stream *hext_stream = kzalloc_obj(*hext_stream,
-								  GFP_KERNEL);
+		struct hdac_ext_stream *hext_stream = kzalloc_obj(*hext_stream);
 		if (!hext_stream)
 			return -ENOMEM;
 		tag = ++stream_tag;

sound/hda/core/sysfs.c

···
 	if (!tree->root)
 		return -ENOMEM;
 
-	tree->nodes = kzalloc_objs(*tree->nodes, codec->num_nodes + 1,
-				   GFP_KERNEL);
+	tree->nodes = kzalloc_objs(*tree->nodes, codec->num_nodes + 1);
 	if (!tree->nodes)
 		return -ENOMEM;
 

sound/pci/cs46xx/dsp_spos.c

···
 
 struct dsp_spos_instance *cs46xx_dsp_spos_create (struct snd_cs46xx * chip)
 {
-	struct dsp_spos_instance * ins = kzalloc_obj(struct dsp_spos_instance,
-						     GFP_KERNEL);
+	struct dsp_spos_instance * ins = kzalloc_obj(struct dsp_spos_instance);
 
 	if (ins == NULL)
 		return NULL;
···
 		vmalloc(array_size(DSP_MAX_SYMBOLS,
 				   sizeof(struct dsp_symbol_entry)));
 	ins->code.data = kmalloc(DSP_CODE_BYTE_SIZE, GFP_KERNEL);
-	ins->modules = kmalloc_objs(struct dsp_module_desc, DSP_MAX_MODULES,
-				    GFP_KERNEL);
+	ins->modules = kmalloc_objs(struct dsp_module_desc, DSP_MAX_MODULES);
 	if (!ins->symbol_table.symbols || !ins->code.data || !ins->modules) {
 		cs46xx_dsp_spos_destroy(chip);
 		goto error;

sound/pci/emu10k1/emufx.c

···
 	if (!icode)
 		return err;
 
-	icode->gpr_map = kzalloc_objs(u_int32_t, 512 + 256 + 256 + 2 * 1024,
-				      GFP_KERNEL);
+	icode->gpr_map = kzalloc_objs(u_int32_t, 512 + 256 + 256 + 2 * 1024);
 	if (!icode->gpr_map)
 		goto __err_gpr;
 	controls = kzalloc_objs(*controls, SND_EMU10K1_GPR_CONTROLS);
···
 	if (!icode)
 		return err;
 
-	icode->gpr_map = kzalloc_objs(u_int32_t, 256 + 160 + 160 + 2 * 512,
-				      GFP_KERNEL);
+	icode->gpr_map = kzalloc_objs(u_int32_t, 256 + 160 + 160 + 2 * 512);
 	if (!icode->gpr_map)
 		goto __err_gpr;
 

sound/pci/via82xx.c

···
 			return -ENOMEM;
 	}
 	if (! dev->idx_table) {
-		dev->idx_table = kmalloc_objs(*dev->idx_table, VIA_TABLE_SIZE,
-					      GFP_KERNEL);
+		dev->idx_table = kmalloc_objs(*dev->idx_table, VIA_TABLE_SIZE);
 		if (! dev->idx_table)
 			return -ENOMEM;
 	}

sound/pci/via82xx_modem.c

···
 			return -ENOMEM;
 	}
 	if (! dev->idx_table) {
-		dev->idx_table = kmalloc_objs(*dev->idx_table, VIA_TABLE_SIZE,
-					      GFP_KERNEL);
+		dev->idx_table = kmalloc_objs(*dev->idx_table, VIA_TABLE_SIZE);
 		if (! dev->idx_table)
 			return -ENOMEM;
 	}

sound/soc/au1x/dma.c

···
 		pointer->start = (u32)(dma_start + (i * period_bytes));
 		pointer->relative_end = (u32) (((i+1) * period_bytes) - 0x1);
 		if (i < periods - 1) {
-			pointer->next = kmalloc_obj(struct pcm_period,
-						    GFP_KERNEL);
+			pointer->next = kmalloc_obj(struct pcm_period);
 			if (!pointer->next) {
 				au1000_release_dma_link(stream);
 				return -ENOMEM;

sound/soc/codecs/aw88395/aw88395_lib.c

···
 {
 	int ret;
 
-	struct aw_all_prof_info *all_prof_info __free(kfree) = kzalloc_obj(*all_prof_info,
-									   GFP_KERNEL);
+	struct aw_all_prof_info *all_prof_info __free(kfree) = kzalloc_obj(*all_prof_info);
 	if (!all_prof_info)
 		return -ENOMEM;
 

sound/soc/codecs/da7219.c

···
 
 	/* For DT platforms allocate onecell data for clock registration */
 	if (np) {
-		clk_data = kzalloc_flex(*clk_data, hws, DA7219_DAI_NUM_CLKS,
-					GFP_KERNEL);
+		clk_data = kzalloc_flex(*clk_data, hws, DA7219_DAI_NUM_CLKS);
 		if (!clk_data)
 			return -ENOMEM;
 

sound/soc/codecs/lpass-rx-macro.c

···
 		rx->rxn_reg_stride = 0x80;
 		rx->rxn_reg_stride2 = 0xc;
 		def_count = ARRAY_SIZE(rx_defaults) + ARRAY_SIZE(rx_pre_2_5_defaults);
-		reg_defaults = kmalloc_objs(struct reg_default, def_count,
-					    GFP_KERNEL);
+		reg_defaults = kmalloc_objs(struct reg_default, def_count);
 		if (!reg_defaults)
 			return -ENOMEM;
 		memcpy(&reg_defaults[0], rx_defaults, sizeof(rx_defaults));
···
 		rx->rxn_reg_stride = 0xc0;
 		rx->rxn_reg_stride2 = 0x0;
 		def_count = ARRAY_SIZE(rx_defaults) + ARRAY_SIZE(rx_2_5_defaults);
-		reg_defaults = kmalloc_objs(struct reg_default, def_count,
-					    GFP_KERNEL);
+		reg_defaults = kmalloc_objs(struct reg_default, def_count);
 		if (!reg_defaults)
 			return -ENOMEM;
 		memcpy(&reg_defaults[0], rx_defaults, sizeof(rx_defaults));

sound/soc/codecs/lpass-wsa-macro.c

···
 	case LPASS_CODEC_VERSION_2_1:
 		wsa->reg_layout = &wsa_codec_v2_1;
 		def_count = ARRAY_SIZE(wsa_defaults) + ARRAY_SIZE(wsa_defaults_v2_1);
-		reg_defaults = kmalloc_objs(*reg_defaults, def_count,
-					    GFP_KERNEL);
+		reg_defaults = kmalloc_objs(*reg_defaults, def_count);
 		if (!reg_defaults)
 			return -ENOMEM;
 		memcpy(&reg_defaults[0], wsa_defaults, sizeof(wsa_defaults));
···
 	case LPASS_CODEC_VERSION_2_9:
 		wsa->reg_layout = &wsa_codec_v2_5;
 		def_count = ARRAY_SIZE(wsa_defaults) + ARRAY_SIZE(wsa_defaults_v2_5);
-		reg_defaults = kmalloc_objs(*reg_defaults, def_count,
-					    GFP_KERNEL);
+		reg_defaults = kmalloc_objs(*reg_defaults, def_count);
 		if (!reg_defaults)
 			return -ENOMEM;
 		memcpy(&reg_defaults[0], wsa_defaults, sizeof(wsa_defaults));

sound/soc/codecs/tas2781-fmwlib.c

···
 	img_data->nr_blk = get_unaligned_be32(&data[offset]);
 	offset += 4;
 
-	img_data->dev_blks = kzalloc_objs(struct tasdev_blk, img_data->nr_blk,
-					  GFP_KERNEL);
+	img_data->dev_blks = kzalloc_objs(struct tasdev_blk, img_data->nr_blk);
 	if (!img_data->dev_blks) {
 		offset = -ENOMEM;
 		goto out;
···
 	img_data->nr_blk = get_unaligned_be16(&data[offset]);
 	offset += 2;
 
-	img_data->dev_blks = kzalloc_objs(struct tasdev_blk, img_data->nr_blk,
-					  GFP_KERNEL);
+	img_data->dev_blks = kzalloc_objs(struct tasdev_blk, img_data->nr_blk);
 	if (!img_data->dev_blks) {
 		offset = -ENOMEM;
 		goto out;
···
 	}
 
 	tas_fmw->programs =
-		kzalloc_objs(struct tasdevice_prog, tas_fmw->nr_programs,
-			     GFP_KERNEL);
+		kzalloc_objs(struct tasdevice_prog, tas_fmw->nr_programs);
 	if (!tas_fmw->programs) {
 		offset = -ENOMEM;
 		goto out;
···
 	fmw.size = fw_entry->size;
 	fmw.data = fw_entry->data;
 
-	tas_fmw = tasdev->cali_data_fmw = kzalloc_obj(struct tasdevice_fw,
-						      GFP_KERNEL);
+	tas_fmw = tasdev->cali_data_fmw = kzalloc_obj(struct tasdevice_fw);
 	if (!tasdev->cali_data_fmw) {
 		ret = -ENOMEM;
 		goto out;

sound/soc/codecs/wm_adsp.c

···
 	u32 offset = 0;
 	int i, ret;
 
-	buf->regions = kzalloc_objs(*buf->regions, caps->num_regions,
-				    GFP_KERNEL);
+	buf->regions = kzalloc_objs(*buf->regions, caps->num_regions);
 	if (!buf->regions)
 		return -ENOMEM;
 

sound/soc/soc-dapm.c

···
 	 * stuff that increases stack usage.
 	 * So, we use kzalloc()/kfree() for params in this function.
 	 */
-	struct snd_pcm_hw_params *params __free(kfree) = kzalloc_obj(*params,
-								     GFP_KERNEL);
+	struct snd_pcm_hw_params *params __free(kfree) = kzalloc_obj(*params);
 	if (!params)
 		return -ENOMEM;
 

sound/soc/sof/ipc3-topology.c

···
 			continue;
 
 		/* Reserve memory for all hw configs, eventually freed by widget */
-		config = kzalloc_objs(*config, slink->num_hw_configs,
-				      GFP_KERNEL);
+		config = kzalloc_objs(*config, slink->num_hw_configs);
 		if (!config) {
 			ret = -ENOMEM;
 			goto free_comp;

sound/soc/sof/ipc4-topology.c

···
 			SOF_IPC4_NODE_INDEX_INTEL_DMIC(ipc4_copier->dai_index);
 		break;
 	default:
-		ipc4_copier->gtw_attr = kzalloc_obj(*ipc4_copier->gtw_attr,
-						    GFP_KERNEL);
+		ipc4_copier->gtw_attr = kzalloc_obj(*ipc4_copier->gtw_attr);
 		if (!ipc4_copier->gtw_attr) {
 			ret = -ENOMEM;
 			goto free_available_fmt;

sound/synth/emux/emux.c

···
 
 	emu->card = card;
 	emu->name = kstrdup_const(name, GFP_KERNEL);
-	emu->voices = kzalloc_objs(struct snd_emux_voice, emu->max_voices,
-				   GFP_KERNEL);
+	emu->voices = kzalloc_objs(struct snd_emux_voice, emu->max_voices);
 	if (emu->name == NULL || emu->voices == NULL)
 		return -ENOMEM;
 

sound/synth/emux/emux_seq.c

···
 	if (!p)
 		return NULL;
 
-	p->chset.channels = kzalloc_objs(*p->chset.channels, max_channels,
-					 GFP_KERNEL);
+	p->chset.channels = kzalloc_objs(*p->chset.channels, max_channels);
 	if (!p->chset.channels) {
 		kfree(p);
 		return NULL;

sound/usb/6fire/control.c

···
 {
 	int i;
 	int ret;
-	struct control_runtime *rt = kzalloc_obj(struct control_runtime,
-						 GFP_KERNEL);
+	struct control_runtime *rt = kzalloc_obj(struct control_runtime);
 	struct comm_runtime *comm_rt = chip->comm;
 
 	if (!rt)

sound/usb/line6/capture.c

···
 	struct usb_line6 *line6 = line6pcm->line6;
 	int i;
 
-	line6pcm->in.urbs = kzalloc_objs(struct urb *, line6->iso_buffers,
-					 GFP_KERNEL);
+	line6pcm->in.urbs = kzalloc_objs(struct urb *, line6->iso_buffers);
 	if (line6pcm->in.urbs == NULL)
 		return -ENOMEM;
 

sound/usb/line6/playback.c

···
 	struct usb_line6 *line6 = line6pcm->line6;
 	int i;
 
-	line6pcm->out.urbs = kzalloc_objs(struct urb *, line6->iso_buffers,
-					  GFP_KERNEL);
+	line6pcm->out.urbs = kzalloc_objs(struct urb *, line6->iso_buffers);
 	if (line6pcm->out.urbs == NULL)
 		return -ENOMEM;
 

sound/usb/mixer.c

···
 		return -ENOMEM;
 	mixer->chip = chip;
 	mixer->ignore_ctl_error = !!(chip->quirk_flags & QUIRK_FLAG_IGNORE_CTL_ERROR);
-	mixer->id_elems = kzalloc_objs(*mixer->id_elems, MAX_ID_ELEMS,
-				       GFP_KERNEL);
+	mixer->id_elems = kzalloc_objs(*mixer->id_elems, MAX_ID_ELEMS);
 	if (!mixer->id_elems) {
 		kfree(mixer);
 		return -ENOMEM;

sound/usb/mixer_quirks.c

···
 	mixer->rc_urb = usb_alloc_urb(0, GFP_KERNEL);
 	if (!mixer->rc_urb)
 		return -ENOMEM;
-	mixer->rc_setup_packet = kmalloc_obj(*mixer->rc_setup_packet,
-					     GFP_KERNEL);
+	mixer->rc_setup_packet = kmalloc_obj(*mixer->rc_setup_packet);
 	if (!mixer->rc_setup_packet) {
 		usb_free_urb(mixer->rc_urb);
 		mixer->rc_urb = NULL;

sound/usb/usx2y/usbusx2yaudio.c

···
 
 	for (i = playback_endpoint ? SNDRV_PCM_STREAM_PLAYBACK : SNDRV_PCM_STREAM_CAPTURE;
 	     i <= SNDRV_PCM_STREAM_CAPTURE; ++i) {
-		usx2y_substream[i] = kzalloc_obj(struct snd_usx2y_substream,
-						 GFP_KERNEL);
+		usx2y_substream[i] = kzalloc_obj(struct snd_usx2y_substream);
 		if (!usx2y_substream[i])
 			return -ENOMEM;
 

sound/xen/xen_snd_front_alsa.c

···
 
 	stream->buffer_sz = buffer_sz;
 	stream->num_pages = DIV_ROUND_UP(stream->buffer_sz, PAGE_SIZE);
-	stream->pages = kzalloc_objs(struct page *, stream->num_pages,
-				     GFP_KERNEL);
+	stream->pages = kzalloc_objs(struct page *, stream->num_pages);
 	if (!stream->pages)
 		return -ENOMEM;