Convert remaining multi-line kmalloc_obj/flex GFP_KERNEL uses

Conversion performed via this Coccinelle script:

// SPDX-License-Identifier: GPL-2.0-only
// Options: --include-headers-for-types --all-includes --include-headers --keep-comments
virtual patch

@gfp depends on patch && !(file in "tools") && !(file in "samples")@
identifier ALLOC = {kmalloc_obj,kmalloc_objs,kmalloc_flex,
kzalloc_obj,kzalloc_objs,kzalloc_flex,
kvmalloc_obj,kvmalloc_objs,kvmalloc_flex,
kvzalloc_obj,kvzalloc_objs,kvzalloc_flex};
@@

ALLOC(...
- , GFP_KERNEL
)

$ make coccicheck MODE=patch COCCI=gfp.cocci

Build and boot tested x86_64 with Fedora 42's GCC and Clang:

Linux version 6.19.0+ (user@host) (gcc (GCC) 15.2.1 20260123 (Red Hat 15.2.1-7), GNU ld version 2.44-12.fc42) #1 SMP PREEMPT_DYNAMIC 1970-01-01
Linux version 6.19.0+ (user@host) (clang version 20.1.8 (Fedora 20.1.8-4.fc42), LLD 20.1.8) #1 SMP PREEMPT_DYNAMIC 1970-01-01

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

arch/arm/probes/kprobes/test-core.c

···
 static int coverage_start(const union decode_item *table)
 {
 	coverage.base = kmalloc_objs(struct coverage_entry,
-				     MAX_COVERAGE_ENTRIES, GFP_KERNEL);
+				     MAX_COVERAGE_ENTRIES);
 	coverage.num_entries = 0;
 	coverage.nesting = 0;
 	return table_iter(table, coverage_start_fn, &coverage);

arch/mips/kernel/smp-cps.c

···
 	/* Allocate cluster boot configuration structs */
 	nclusters = mips_cps_numclusters();
 	mips_cps_cluster_bootcfg = kzalloc_objs(*mips_cps_cluster_bootcfg,
-						nclusters, GFP_KERNEL);
+						nclusters);
 	if (!mips_cps_cluster_bootcfg)
 		goto err_out;
 
···
 			int v;
 			core_vpes = core_vpe_count(cl, c);
 			core_bootcfg[c].vpe_config = kzalloc_objs(*core_bootcfg[c].vpe_config,
-								  core_vpes,
-								  GFP_KERNEL);
+								  core_vpes);
 			for (v = 0; v < core_vpes; v++)
 				cpumask_set_cpu(nvpe++, &mips_cps_cluster_bootcfg[cl].cpumask);
 			if (!core_bootcfg[c].vpe_config)

arch/powerpc/kvm/e500_mmu.c

···
 	vcpu_e500->gtlb_params[1].sets = 1;
 
 	vcpu_e500->gtlb_arch = kmalloc_objs(*vcpu_e500->gtlb_arch,
-					    KVM_E500_TLB0_SIZE + KVM_E500_TLB1_SIZE,
-					    GFP_KERNEL);
+					    KVM_E500_TLB0_SIZE + KVM_E500_TLB1_SIZE);
 	if (!vcpu_e500->gtlb_arch)
 		return -ENOMEM;
 
···
 	vcpu_e500->gtlb_offset[1] = KVM_E500_TLB0_SIZE;
 
 	vcpu_e500->gtlb_priv[0] = kzalloc_objs(struct tlbe_ref,
-					       vcpu_e500->gtlb_params[0].entries,
-					       GFP_KERNEL);
+					       vcpu_e500->gtlb_params[0].entries);
 	if (!vcpu_e500->gtlb_priv[0])
 		goto free_vcpu;
 
 	vcpu_e500->gtlb_priv[1] = kzalloc_objs(struct tlbe_ref,
-					       vcpu_e500->gtlb_params[1].entries,
-					       GFP_KERNEL);
+					       vcpu_e500->gtlb_params[1].entries);
 	if (!vcpu_e500->gtlb_priv[1])
 		goto free_vcpu;
 

arch/powerpc/perf/imc-pmu.c

···
 		/* Needed for hotplug/migration */
 		if (!per_nest_pmu_arr) {
 			per_nest_pmu_arr = kzalloc_objs(struct imc_pmu *,
-							get_max_nest_dev() + 1,
-							GFP_KERNEL);
+							get_max_nest_dev() + 1);
 			if (!per_nest_pmu_arr)
 				goto err;
 		}

arch/powerpc/platforms/cell/spufs/file.c

···
 	}
 
 	ctx->switch_log = kmalloc_flex(*ctx->switch_log, log,
-				       SWITCH_LOG_BUFSIZE, GFP_KERNEL);
+				       SWITCH_LOG_BUFSIZE);
 
 	if (!ctx->switch_log) {
 		rc = -ENOMEM;

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

···
 
 	opal_max_async_tokens = be32_to_cpup(async);
 	opal_async_tokens = kzalloc_objs(*opal_async_tokens,
-					 opal_max_async_tokens, GFP_KERNEL);
+					 opal_max_async_tokens);
 	if (!opal_async_tokens) {
 		err = -ENOMEM;
 		goto out_opal_node;

arch/powerpc/platforms/pseries/papr_platform_attributes.c

···
 	/* Allocate the groups before registering */
 	for (idx = 0; idx < num_attrs; idx++) {
 		papr_groups[idx].pg.attrs = kzalloc_objs(*papr_groups[idx].pg.attrs,
-							 KOBJ_MAX_ATTRS + 1,
-							 GFP_KERNEL);
+							 KOBJ_MAX_ATTRS + 1);
 		if (!papr_groups[idx].pg.attrs)
 			goto out_pgattrs;
 

arch/riscv/kernel/module.c

···
 
 	/* Number of relocations may be large, so kvmalloc it */
 	*relocation_hashtable = kvmalloc_objs(**relocation_hashtable,
-					      hashtable_size, GFP_KERNEL);
+					      hashtable_size);
 	if (!*relocation_hashtable)
 		return 0;
 

arch/riscv/kvm/vcpu_sbi_fwft.c

···
 	int i;
 
 	fwft->configs = kzalloc_objs(struct kvm_sbi_fwft_config,
-				     ARRAY_SIZE(features), GFP_KERNEL);
+				     ARRAY_SIZE(features));
 	if (!fwft->configs)
 		return -ENOMEM;
 

arch/s390/kernel/perf_pai.c

···
 			need_paiext_cb = true;
 		}
 		cpump->save = kvmalloc_objs(struct pai_userdata,
-					    pai_pmu[idx].num_avail + 1,
-					    GFP_KERNEL);
+					    pai_pmu[idx].num_avail + 1);
 		if (!cpump->area || !cpump->save ||
 		    (need_paiext_cb && !cpump->paiext_cb)) {
 			pai_free(mp);

arch/um/drivers/ubd_kern.c

···
 		return -1;
 
 	irq_req_buffer = kmalloc_objs(struct io_thread_req *,
-				      UBD_REQ_BUFFER_SIZE, GFP_KERNEL);
+				      UBD_REQ_BUFFER_SIZE);
 	irq_remainder = 0;
 
 	if (irq_req_buffer == NULL) {
···
 		return -ENOMEM;
 	}
 	io_req_buffer = kmalloc_objs(struct io_thread_req *,
-				     UBD_REQ_BUFFER_SIZE, GFP_KERNEL);
+				     UBD_REQ_BUFFER_SIZE);
 
 	io_remainder = 0;
 

arch/um/drivers/vfio_kern.c

···
 	}
 
 	dev->intr_ctx = kmalloc_objs(struct uml_vfio_intr_ctx,
-				     dev->udev.irq_count, GFP_KERNEL);
+				     dev->udev.irq_count);
 	if (!dev->intr_ctx) {
 		pr_err("Failed to allocate interrupt context (%s)\n",
 		       dev->name);

arch/x86/events/intel/core.c

···
 
 	x86_pmu.num_hybrid_pmus = hweight_long(pmus_mask);
 	x86_pmu.hybrid_pmu = kzalloc_objs(struct x86_hybrid_pmu,
-					  x86_pmu.num_hybrid_pmus, GFP_KERNEL);
+					  x86_pmu.num_hybrid_pmus);
 	if (!x86_pmu.hybrid_pmu)
 		return -ENOMEM;
 

arch/x86/events/intel/uncore_discovery.c

···
 	int i = 0;
 
 	uncores = kzalloc_objs(struct intel_uncore_type *,
-			       num_discovered_types[type_id] + num_extra + 1,
-			       GFP_KERNEL);
+			       num_discovered_types[type_id] + num_extra + 1);
 	if (!uncores)
 		return empty_uncore;
 

arch/x86/kvm/vmx/tdx.c

···
 	/* TDVPS = TDVPR(4K page) + TDCX(multiple 4K pages), -1 for TDVPR. */
 	kvm_tdx->td.tdcx_nr_pages = tdx_sysinfo->td_ctrl.tdvps_base_size / PAGE_SIZE - 1;
 	tdcs_pages = kzalloc_objs(*kvm_tdx->td.tdcs_pages,
-				  kvm_tdx->td.tdcs_nr_pages, GFP_KERNEL);
+				  kvm_tdx->td.tdcs_nr_pages);
 	if (!tdcs_pages)
 		goto free_tdr;
 

block/blk-crypto-fallback.c

···
 		goto fail_destroy_profile;
 
 	blk_crypto_keyslots = kzalloc_objs(blk_crypto_keyslots[0],
-					   blk_crypto_num_keyslots, GFP_KERNEL);
+					   blk_crypto_num_keyslots);
 	if (!blk_crypto_keyslots)
 		goto fail_free_wq;
 

block/blk-zoned.c

···
 
 	disk->zone_wplugs_hash =
 		kzalloc_objs(struct hlist_head,
-			     disk_zone_wplugs_hash_size(disk), GFP_KERNEL);
+			     disk_zone_wplugs_hash_size(disk));
 	if (!disk->zone_wplugs_hash)
 		return -ENOMEM;
 

drivers/accel/habanalabs/common/context.c

···
 	atomic_set(&ctx->thread_ctx_switch_token, 1);
 	ctx->thread_ctx_switch_wait_token = 0;
 	ctx->cs_pending = kzalloc_objs(struct hl_fence *,
-				       hdev->asic_prop.max_pending_cs,
-				       GFP_KERNEL);
+				       hdev->asic_prop.max_pending_cs);
 	if (!ctx->cs_pending)
 		return -ENOMEM;
 

drivers/accel/habanalabs/common/device.c

···
 
 	if (hdev->asic_prop.completion_queues_count) {
 		hdev->cq_wq = kzalloc_objs(struct workqueue_struct *,
-					   hdev->asic_prop.completion_queues_count,
-					   GFP_KERNEL);
+					   hdev->asic_prop.completion_queues_count);
 		if (!hdev->cq_wq) {
 			rc = -ENOMEM;
 			goto asid_fini;
···
 
 	if (user_interrupt_cnt) {
 		hdev->user_interrupt = kzalloc_objs(*hdev->user_interrupt,
-						    user_interrupt_cnt,
-						    GFP_KERNEL);
+						    user_interrupt_cnt);
 		if (!hdev->user_interrupt) {
 			rc = -ENOMEM;
 			goto early_fini;
···
 	 */
 	if (cq_cnt) {
 		hdev->completion_queue = kzalloc_objs(*hdev->completion_queue,
-						      cq_cnt, GFP_KERNEL);
+						      cq_cnt);
 
 		if (!hdev->completion_queue) {
 			dev_err(hdev->dev,
···
 	}
 
 	hdev->shadow_cs_queue = kzalloc_objs(struct hl_cs *,
-					     hdev->asic_prop.max_pending_cs,
-					     GFP_KERNEL);
+					     hdev->asic_prop.max_pending_cs);
 	if (!hdev->shadow_cs_queue) {
 		rc = -ENOMEM;
 		goto cq_fini;

drivers/accel/habanalabs/common/hw_queue.c

···
 	int i, rc, q_ready_cnt;
 
 	hdev->kernel_queues = kzalloc_objs(*hdev->kernel_queues,
-					   asic->max_queues, GFP_KERNEL);
+					   asic->max_queues);
 
 	if (!hdev->kernel_queues) {
 		dev_err(hdev->dev, "Not enough memory for H/W queues\n");

drivers/accel/habanalabs/common/hwmon.c

···
 	}
 
 	channels_info = kzalloc_objs(struct hwmon_channel_info *,
-				     num_active_sensor_types + 1, GFP_KERNEL);
+				     num_active_sensor_types + 1);
 	if (!channels_info) {
 		rc = -ENOMEM;
 		goto channels_info_array_err;

drivers/accel/habanalabs/gaudi/gaudi.c

···
 
 	prop->max_queues = GAUDI_QUEUE_ID_SIZE;
 	prop->hw_queues_props = kzalloc_objs(struct hw_queue_properties,
-					     prop->max_queues, GFP_KERNEL);
+					     prop->max_queues);
 
 	if (!prop->hw_queues_props)
 		return -ENOMEM;

drivers/accel/habanalabs/gaudi2/gaudi2.c

···
 
 	prop->max_queues = GAUDI2_QUEUE_ID_SIZE;
 	prop->hw_queues_props = kzalloc_objs(struct hw_queue_properties,
-					     prop->max_queues, GFP_KERNEL);
+					     prop->max_queues);
 
 	if (!prop->hw_queues_props)
 		return -ENOMEM;
···
 	prop->glbl_err_max_cause_num = GAUDI2_GLBL_ERR_MAX_CAUSE_NUM;
 	prop->num_of_special_blocks = ARRAY_SIZE(gaudi2_special_blocks);
 	prop->special_blocks = kmalloc_objs(*prop->special_blocks,
-					    prop->num_of_special_blocks,
-					    GFP_KERNEL);
+					    prop->num_of_special_blocks);
 	if (!prop->special_blocks)
 		return -ENOMEM;
 
···
 	if (ARRAY_SIZE(gaudi2_iterator_skip_block_types)) {
 		prop->skip_special_blocks_cfg.block_types =
 				kmalloc_objs(gaudi2_iterator_skip_block_types[0],
-					     ARRAY_SIZE(gaudi2_iterator_skip_block_types),
-					     GFP_KERNEL);
+					     ARRAY_SIZE(gaudi2_iterator_skip_block_types));
 		if (!prop->skip_special_blocks_cfg.block_types) {
 			rc = -ENOMEM;
 			goto free_special_blocks;
···
 	if (ARRAY_SIZE(gaudi2_iterator_skip_block_ranges)) {
 		prop->skip_special_blocks_cfg.block_ranges =
 				kmalloc_objs(gaudi2_iterator_skip_block_ranges[0],
-					     ARRAY_SIZE(gaudi2_iterator_skip_block_ranges),
-					     GFP_KERNEL);
+					     ARRAY_SIZE(gaudi2_iterator_skip_block_ranges));
 		if (!prop->skip_special_blocks_cfg.block_ranges) {
 			rc = -ENOMEM;
 			goto free_skip_special_blocks_types;

drivers/accel/habanalabs/goya/goya.c

···
 
 	prop->max_queues = GOYA_QUEUE_ID_SIZE;
 	prop->hw_queues_props = kzalloc_objs(struct hw_queue_properties,
-					     prop->max_queues, GFP_KERNEL);
+					     prop->max_queues);
 
 	if (!prop->hw_queues_props)
 		return -ENOMEM;

drivers/accel/rocket/rocket_job.c

···
 {
 	struct rocket_device *rdev = rocket_priv->rdev;
 	struct drm_gpu_scheduler **scheds = kmalloc_objs(*scheds,
-							 rdev->num_cores,
-							 GFP_KERNEL);
+							 rdev->num_cores);
 	unsigned int core;
 	int ret;
 

drivers/acpi/acpi_video.c

···
 	 * special levels (see below)
 	 */
 	br->levels = kmalloc_objs(*br->levels,
-				  obj->package.count + ACPI_VIDEO_FIRST_LEVEL,
-				  GFP_KERNEL);
+				  obj->package.count + ACPI_VIDEO_FIRST_LEVEL);
 	if (!br->levels) {
 		result = -ENOMEM;
 		goto out_free;
···
 			  dod->package.count);
 
 	active_list = kzalloc_objs(struct acpi_video_enumerated_device,
-				   1 + dod->package.count, GFP_KERNEL);
+				   1 + dod->package.count);
 	if (!active_list) {
 		status = -ENOMEM;
 		goto out;

drivers/acpi/riscv/irq.c

···
 			acpi_get_handle(handle, entry->source, &link_handle);
 			dep_devices.count = 1;
 			dep_devices.handles = kzalloc_objs(*dep_devices.handles,
-							   1, GFP_KERNEL);
+							   1);
 			if (!dep_devices.handles) {
 				acpi_handle_err(handle, "failed to allocate memory\n");
 				continue;
···
 			gsi_handle = riscv_acpi_get_gsi_handle(entry->source_index);
 			dep_devices.count = 1;
 			dep_devices.handles = kzalloc_objs(*dep_devices.handles,
-							   1, GFP_KERNEL);
+							   1);
 			if (!dep_devices.handles) {
 				acpi_handle_err(handle, "failed to allocate memory\n");
 				continue;

drivers/acpi/x86/s2idle.c

···
 			}
 
 			lpi_constraints_table = kzalloc_objs(*lpi_constraints_table,
-							     package->package.count,
-							     GFP_KERNEL);
+							     package->package.count);
 
 			if (!lpi_constraints_table)
 				goto free_acpi_buffer;
···
 		return;
 
 	lpi_constraints_table = kzalloc_objs(*lpi_constraints_table,
-					     out_obj->package.count, GFP_KERNEL);
+					     out_obj->package.count);
 	if (!lpi_constraints_table)
 		goto free_acpi_buffer;
 

drivers/android/binder.c

···
 		}
 
 		target_procs = kzalloc_objs(struct binder_proc *,
-					    target_procs_count, GFP_KERNEL);
+					    target_procs_count);
 
 		if (!target_procs) {
 			mutex_unlock(&binder_procs_lock);

drivers/android/binder_alloc.c

···
 	alloc->vm_start = vma->vm_start;
 
 	alloc->pages = kvzalloc_objs(alloc->pages[0],
-				     alloc->buffer_size / PAGE_SIZE, GFP_KERNEL);
+				     alloc->buffer_size / PAGE_SIZE);
 	if (!alloc->pages) {
 		ret = -ENOMEM;
 		failure_string = "alloc page array";

drivers/atm/eni.c

···
 	buffer_mem = eni_dev->mem - (buf - eni_dev->ram);
 	eni_dev->free_list_size = buffer_mem/MID_MIN_BUF_SIZE/2;
 	eni_dev->free_list = kmalloc_objs(*eni_dev->free_list,
-					  eni_dev->free_list_size + 1,
-					  GFP_KERNEL);
+					  eni_dev->free_list_size + 1);
 	if (!eni_dev->free_list) {
 		printk(KERN_ERR DEV_LABEL "(itf %d): couldn't get free page\n",
 		    dev->number);

drivers/base/cacheinfo.c

···
 
 	/* Allocate all required memory */
 	per_cpu_index_dev(cpu) = kzalloc_objs(struct device *,
-					      cache_leaves(cpu), GFP_KERNEL);
+					      cache_leaves(cpu));
 	if (unlikely(per_cpu_index_dev(cpu) == NULL))
 		goto err_out;
 

drivers/block/rnbd/rnbd-clt.c

···
 	 * nr_poll_queues: the number of polling queues
 	 */
 	dev->hw_queues = kzalloc_objs(*dev->hw_queues,
-				      nr_cpu_ids + nr_poll_queues, GFP_KERNEL);
+				      nr_cpu_ids + nr_poll_queues);
 	if (!dev->hw_queues) {
 		ret = -ENOMEM;
 		goto out_alloc;

drivers/block/xen-blkfront.c

···
 		rinfo->shadow[i].grants_used =
 			kvzalloc_objs(rinfo->shadow[i].grants_used[0], grants);
 		rinfo->shadow[i].sg = kvzalloc_objs(rinfo->shadow[i].sg[0],
-						    psegs, GFP_KERNEL);
+						    psegs);
 		if (info->max_indirect_segments)
 			rinfo->shadow[i].indirect_grants =
 				kvzalloc_objs(rinfo->shadow[i].indirect_grants[0],
-					      INDIRECT_GREFS(grants),
-					      GFP_KERNEL);
+					      INDIRECT_GREFS(grants));
 		if ((rinfo->shadow[i].grants_used == NULL) ||
 			(rinfo->shadow[i].sg == NULL) ||
 		     (info->max_indirect_segments &&

drivers/bus/mhi/ep/main.c

···
 	mhi_ep_mmio_init(mhi_cntrl);
 
 	mhi_cntrl->mhi_event = kzalloc_objs(*mhi_cntrl->mhi_event,
-					    mhi_cntrl->event_rings, GFP_KERNEL);
+					    mhi_cntrl->event_rings);
 	if (!mhi_cntrl->mhi_event)
 		return -ENOMEM;
 
···
 	 * only the defined channels
 	 */
 	mhi_cntrl->mhi_chan = kzalloc_objs(*mhi_cntrl->mhi_chan,
-					   mhi_cntrl->max_chan, GFP_KERNEL);
+					   mhi_cntrl->max_chan);
 	if (!mhi_cntrl->mhi_chan)
 		return -ENOMEM;
 

drivers/bus/mhi/ep/ring.c

···
 
 	/* Allocate ring cache memory for holding the copy of host ring */
 	ring->ring_cache = kzalloc_objs(struct mhi_ring_element,
-					ring->ring_size, GFP_KERNEL);
+					ring->ring_size);
 	if (!ring->ring_cache)
 		return -ENOMEM;
 

drivers/clk/aspeed/clk-ast2600.c

···
 	soc_rev = (readl(scu_g6_base + ASPEED_G6_SILICON_REV) & CHIP_REVISION_ID) >> 16;
 
 	aspeed_g6_clk_data = kzalloc_flex(*aspeed_g6_clk_data, hws,
-				          ASPEED_G6_NUM_CLKS, GFP_KERNEL);
+				          ASPEED_G6_NUM_CLKS);
 	if (!aspeed_g6_clk_data)
 		return;
 	aspeed_g6_clk_data->num = ASPEED_G6_NUM_CLKS;

drivers/clk/clk-clps711x.c

···
 	BUG_ON(!base);
 
 	clps711x_clk = kzalloc_flex(*clps711x_clk, clk_data.hws,
-				    CLPS711X_CLK_MAX, GFP_KERNEL);
+				    CLPS711X_CLK_MAX);
 	BUG_ON(!clps711x_clk);
 
 	spin_lock_init(&clps711x_clk->lock);

drivers/clk/clk-npcm7xx.c

···
 		goto npcm7xx_init_error;
 
 	npcm7xx_clk_data = kzalloc_flex(*npcm7xx_clk_data, hws,
-					NPCM7XX_NUM_CLOCKS, GFP_KERNEL);
+					NPCM7XX_NUM_CLOCKS);
 	if (!npcm7xx_clk_data)
 		goto npcm7xx_init_np_err;
 

drivers/clocksource/ingenic-sysost.c

···
 	ost->soc_info = id->data;
 
 	ost->clocks = kzalloc_flex(*ost->clocks, hws,
-				   ost->soc_info->num_channels, GFP_KERNEL);
+				   ost->soc_info->num_channels);
 	if (!ost->clocks) {
 		ret = -ENOMEM;
 		goto err_clk_disable;

drivers/comedi/drivers/ni_tio.c

···
 
 	counter_dev->counters = kzalloc_objs(*counter, num_counters);
 	counter_dev->regs = kzalloc_objs(*counter_dev->regs,
-					 counter_dev->num_chips, GFP_KERNEL);
+					 counter_dev->num_chips);
 	if (!counter_dev->regs || !counter_dev->counters) {
 		kfree(counter_dev->regs);
 		kfree(counter_dev->counters);

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

···
 		goto err_free_tl;
 
 	telemetry->regs_hist_buff = kmalloc_objs(*telemetry->regs_hist_buff,
-						 tl_data->num_hbuff, GFP_KERNEL);
+						 tl_data->num_hbuff);
 	if (!telemetry->regs_hist_buff)
 		goto err_free_rp_indexes;
 

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

···
 
 	if (suof_handle->img_table.num_simgs != 0) {
 		suof_img_hdr = kzalloc_objs(img_header,
-					    suof_handle->img_table.num_simgs,
-					    GFP_KERNEL);
+					    suof_handle->img_table.num_simgs);
 		if (!suof_img_hdr)
 			return -ENOMEM;
 		suof_handle->img_table.simg_hdr = suof_img_hdr;
···
 		sobj_chunk_num = sobj_hdr->num_chunks;
 
 	mobj_hdr = kzalloc_objs(*mobj_hdr,
-				size_add(uobj_chunk_num, sobj_chunk_num),
-				GFP_KERNEL);
+				size_add(uobj_chunk_num, sobj_chunk_num));
 	if (!mobj_hdr)
 		return -ENOMEM;
 

drivers/edac/edac_device.c

···
 	dev_ctl->instances = dev_inst;
 
 	dev_blk = kzalloc_objs(struct edac_device_block,
-			       nr_instances * nr_blocks, GFP_KERNEL);
+			       nr_instances * nr_blocks);
 	if (!dev_blk)
 		goto free;
 

drivers/edac/sb_edac.c

···
 		return NULL;
 
 	sbridge_dev->pdev = kzalloc_objs(*sbridge_dev->pdev,
-					 table->n_devs_per_imc, GFP_KERNEL);
+					 table->n_devs_per_imc);
 	if (!sbridge_dev->pdev) {
 		kfree(sbridge_dev);
 		return NULL;

drivers/extcon/extcon.c

···
 		return 0;
 
 	edev->extcon_dev_type.groups = kzalloc_objs(*edev->extcon_dev_type.groups,
-						    edev->max_supported + 2,
-						    GFP_KERNEL);
+						    edev->max_supported + 2);
 	if (!edev->extcon_dev_type.groups)
 		return -ENOMEM;
 

drivers/firewire/core-iso.c

···
 int fw_iso_buffer_alloc(struct fw_iso_buffer *buffer, int page_count)
 {
 	struct page **page_array __free(kfree) = kzalloc_objs(page_array[0],
-							      page_count,
-							      GFP_KERNEL);
+							      page_count);
 
 	if (!page_array)
 		return -ENOMEM;
···
 			  enum dma_data_direction direction)
 {
 	dma_addr_t *dma_addrs __free(kfree) = kzalloc_objs(dma_addrs[0],
-							   buffer->page_count,
-							   GFP_KERNEL);
+							   buffer->page_count);
 	int i;
 
 	if (!dma_addrs)

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

···
 			 */
 			ip_hw_instance = kzalloc_flex(*ip_hw_instance,
 						      base_addr,
-						      ip->num_base_address,
-						      GFP_KERNEL);
+						      ip->num_base_address);
 			if (!ip_hw_instance) {
 				DRM_ERROR("no memory for ip_hw_instance");
 				return -ENOMEM;

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

···
 	bool valid;
 
 	adev->gmc.mem_partitions = kzalloc_objs(struct amdgpu_mem_partition_info,
-						AMDGPU_MAX_MEM_RANGES,
-						GFP_KERNEL);
+						AMDGPU_MAX_MEM_RANGES);
 	if (!adev->gmc.mem_partitions)
 		return -ENOMEM;
 

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

···
 	if (!adev->irq.client[client_id].sources) {
 		adev->irq.client[client_id].sources =
 			kzalloc_objs(struct amdgpu_irq_src *,
-				     AMDGPU_MAX_IRQ_SRC_ID, GFP_KERNEL);
+				     AMDGPU_MAX_IRQ_SRC_ID);
 		if (!adev->irq.client[client_id].sources)
 			return -ENOMEM;
 	}

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

···
 		return -ENOMEM;
 
 	fmt_attr_group->attrs = kzalloc_objs(*fmt_attr_group->attrs,
-					     config->num_formats + 1,
-					     GFP_KERNEL);
+					     config->num_formats + 1);
 
 	if (!fmt_attr_group->attrs)
 		goto err_fmt_attr_grp;
···
 		goto err_evt_attr;
 
 	evt_attr_group->attrs = kzalloc_objs(*evt_attr_group->attrs,
-					     config->num_events + 1, GFP_KERNEL);
+					     config->num_events + 1);
 
 	if (!evt_attr_group->attrs)
 		goto err_evt_attr_grp;

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

···
 	if (from_rom) {
 		err_data.err_addr =
 			kzalloc_objs(struct eeprom_table_record,
-				     adev->umc.retire_unit, GFP_KERNEL);
+				     adev->umc.retire_unit);
 		if (!err_data.err_addr) {
 			dev_warn(adev->dev, "Failed to alloc UMC error address record in mca2pa conversion!\n");
 			return -ENOMEM;

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

···
 		return 0;
 
 	adev->mman.ttm_pools = kzalloc_objs(*adev->mman.ttm_pools,
-					    adev->gmc.num_mem_partitions,
-					    GFP_KERNEL);
+					    adev->gmc.num_mem_partitions);
 	if (!adev->mman.ttm_pools)
 		return -ENOMEM;
 

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

···
 
 	err_data.err_addr =
 		kzalloc_objs(struct eeprom_table_record,
-			     adev->umc.max_ras_err_cnt_per_query, GFP_KERNEL);
+			     adev->umc.max_ras_err_cnt_per_query);
 	if (!err_data.err_addr) {
 		dev_warn(adev->dev,
 			"Failed to alloc memory for umc error record in MCA notifier!\n");
···
 
 	err_data->err_addr =
 		kzalloc_objs(struct eeprom_table_record,
-			     adev->umc.max_ras_err_cnt_per_query, GFP_KERNEL);
+			     adev->umc.max_ras_err_cnt_per_query);
 
 	/* still call query_ras_error_address to clear error status
 	 * even NOMEM error is encountered
···
 			    adev->umc.max_ras_err_cnt_per_query) {
 				err_data->err_addr =
 					kzalloc_objs(struct eeprom_table_record,
-						     adev->umc.max_ras_err_cnt_per_query,
-						     GFP_KERNEL);
+						     adev->umc.max_ras_err_cnt_per_query);
 
 				/* still call query_ras_error_address to clear error status
 				 * even NOMEM error is encountered
···
 			    adev->umc.max_ras_err_cnt_per_query) {
 				err_data->err_addr =
 					kzalloc_objs(struct eeprom_table_record,
-						     adev->umc.max_ras_err_cnt_per_query,
-						     GFP_KERNEL);
+						     adev->umc.max_ras_err_cnt_per_query);
 
 				/* still call query_ras_error_address to clear error status
 				 * even NOMEM error is encountered
···
 	struct ras_err_data err_data;
 
 	err_data.err_addr = kzalloc_objs(struct eeprom_table_record,
-					 adev->umc.retire_unit, GFP_KERNEL);
+					 adev->umc.retire_unit);
 	if (!err_data.err_addr) {
 		dev_warn(adev->dev, "Failed to alloc memory in bad page lookup!\n");
 		return 0;

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

···
 	struct amdgpu_device *adev = ip_block->adev;
 
 	adev->amdgpu_vkms_output = kzalloc_objs(struct amdgpu_vkms_output,
-						adev->mode_info.num_crtc,
-						GFP_KERNEL);
+						adev->mode_info.num_crtc);
 	if (!adev->amdgpu_vkms_output)
 		return -ENOMEM;
 

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

···
 	 * the amount of memory allocated by user
 	 */
 	pa = kzalloc_objs(struct kfd_process_device_apertures,
-			  args->num_of_nodes, GFP_KERNEL);
+			  args->num_of_nodes);
 	if (!pa)
 		return -ENOMEM;
 

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

···
 	int i;
 
 	crtc_ctx = kzalloc_objs(struct secure_display_crtc_context,
-				adev->mode_info.num_crtc, GFP_KERNEL);
+				adev->mode_info.num_crtc);
 
 	if (!crtc_ctx) {
 		adev->dm.secure_display_ctx.crtc_ctx = NULL;

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

···
 	display_e2e_pipe_params_st *pipes;
 
 	pipes = kzalloc_objs(display_e2e_pipe_params_st,
-			     dc->res_pool->pipe_count, GFP_KERNEL);
+			     dc->res_pool->pipe_count);
 	if (!pipes)
 		return DC_FAIL_BANDWIDTH_VALIDATE;
 

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

···
 	display_e2e_pipe_params_st *pipes;
 
 	pipes = kzalloc_objs(display_e2e_pipe_params_st,
-			     dc->res_pool->pipe_count, GFP_KERNEL);
+			     dc->res_pool->pipe_count);
 	if (!pipes)
 		return DC_FAIL_BANDWIDTH_VALIDATE;
 

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

···
 	int vlevel = 0;
 	int pipe_cnt = 0;
 	display_e2e_pipe_params_st *pipes = kzalloc_objs(display_e2e_pipe_params_st,
-							 dc->res_pool->pipe_count,
-							 GFP_KERNEL);
+							 dc->res_pool->pipe_count);
 	DC_LOGGER_INIT(dc->ctx->logger);
 
 	BW_VAL_TRACE_COUNT();

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

···
 	int vlevel = 0;
 	int pipe_cnt = 0;
 	display_e2e_pipe_params_st *pipes = kzalloc_objs(display_e2e_pipe_params_st,
-							 dc->res_pool->pipe_count,
-							 GFP_KERNEL);
+							 dc->res_pool->pipe_count);
 	DC_LOGGER_INIT(dc->ctx->logger);
 
 	BW_VAL_TRACE_COUNT();

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

···
 	int vlevel = 0;
 	int pipe_cnt = 0;
 	display_e2e_pipe_params_st *pipes = kzalloc_objs(display_e2e_pipe_params_st,
-							 dc->res_pool->pipe_count,
-							 GFP_KERNEL);
+							 dc->res_pool->pipe_count);
 	DC_LOGGER_INIT(dc->ctx->logger);
 
 	BW_VAL_TRACE_COUNT();

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

···
 	int vlevel = 0;
 	int pipe_cnt = 0;
 	display_e2e_pipe_params_st *pipes = kzalloc_objs(display_e2e_pipe_params_st,
-							 dc->res_pool->pipe_count,
-							 GFP_KERNEL);
+							 dc->res_pool->pipe_count);
 
 	/* To handle Freesync properly, setting FreeSync DML parameters
 	 * to its default state for the first stage of validation

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

···
 
 	if (map_user_ramp && ramp && ramp->type == GAMMA_RGB_256) {
 		rgb_user = kvzalloc_objs(*rgb_user,
-					 ramp->num_entries + _EXTRA_POINTS,
-					 GFP_KERNEL);
+					 ramp->num_entries + _EXTRA_POINTS);
 		if (!rgb_user)
 			goto rgb_user_alloc_fail;
 
 		axis_x = kvzalloc_objs(*axis_x,
-				       ramp->num_entries + _EXTRA_POINTS,
-				       GFP_KERNEL);
+				       ramp->num_entries + _EXTRA_POINTS);
 		if (!axis_x)
 			goto axis_x_alloc_fail;
 
···
 	if (ramp && ramp->type != GAMMA_CS_TFM_1D &&
 	    (map_user_ramp || ramp->type != GAMMA_RGB_256)) {
 		rgb_user = kvzalloc_objs(*rgb_user,
-					 ramp->num_entries + _EXTRA_POINTS,
-					 GFP_KERNEL);
+					 ramp->num_entries + _EXTRA_POINTS);
 		if (!rgb_user)
 			goto rgb_user_alloc_fail;
 

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

···
 		 le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset));
 
 	adev->pm.dpm.ps = kzalloc_objs(struct amdgpu_ps,
-				       state_array->ucNumEntries, GFP_KERNEL);
+				       state_array->ucNumEntries);
 	if (!adev->pm.dpm.ps)
 		return -ENOMEM;
 	power_state_offset = (u8 *)state_array->states;

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

···
 
 			adev->pm.dpm.dyn_state.phase_shedding_limits_table.entries =
 				kzalloc_objs(struct amdgpu_phase_shedding_limits_entry,
-					     psl->ucNumEntries, GFP_KERNEL);
+					     psl->ucNumEntries);
 			if (!adev->pm.dpm.dyn_state.phase_shedding_limits_table.entries)
 				return -ENOMEM;
 

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

···
 		 le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset));
 
 	adev->pm.dpm.ps = kzalloc_objs(struct amdgpu_ps,
-				       state_array->ucNumEntries, GFP_KERNEL);
+				       state_array->ucNumEntries);
 	if (!adev->pm.dpm.ps)
 		return -ENOMEM;
 	power_state_offset = (u8 *)state_array->states;

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

···
 		"Invalid PowerPlay Table!", return -1);
 
 	mclk_table = kzalloc_flex(*mclk_table, entries,
-				  mclk_dep_table->ucNumEntries, GFP_KERNEL);
+				  mclk_dep_table->ucNumEntries);
 	if (!mclk_table)
 		return -ENOMEM;
 
···
 			"Invalid PowerPlay Table!", return -1);
 
 		sclk_table = kzalloc_flex(*sclk_table, entries,
-					  tonga_table->ucNumEntries, GFP_KERNEL);
+					  tonga_table->ucNumEntries);
 		if (!sclk_table)
 			return -ENOMEM;
 
···
 			"Invalid PowerPlay Table!", return -1);
 
 		sclk_table = kzalloc_flex(*sclk_table, entries,
-					  polaris_table->ucNumEntries,
-					  GFP_KERNEL);
+					  polaris_table->ucNumEntries);
 		if (!sclk_table)
 			return -ENOMEM;
 
···
 			"Invalid PowerPlay Table!", return -1);
 
 		pcie_table = kzalloc_flex(*pcie_table, entries,
-					  atom_pcie_table->ucNumEntries,
-					  GFP_KERNEL);
+					  atom_pcie_table->ucNumEntries);
 		if (!pcie_table)
 			return -ENOMEM;
 
···
 			"Invalid PowerPlay Table!", return -1);
 
 		pcie_table = kzalloc_flex(*pcie_table, entries,
-					  atom_pcie_table->ucNumEntries,
-					  GFP_KERNEL);
+					  atom_pcie_table->ucNumEntries);
 		if (!pcie_table)
 			return -ENOMEM;
 
···
 	PP_ASSERT_WITH_CODE((0 != mm_dependency_table->ucNumEntries),
 		"Invalid PowerPlay Table!", return -1);
 	mm_table = kzalloc_flex(*mm_table, entries,
-				mm_dependency_table->ucNumEntries, GFP_KERNEL);
+				mm_dependency_table->ucNumEntries);
 	if (!mm_table)
 		return -ENOMEM;
 

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

···
 		return -EINVAL;
 
 	cac_leakage_table = kzalloc_flex(*cac_leakage_table, entries,
-					 table->ucNumEntries, GFP_KERNEL);
+					 table->ucNumEntries);
 	if (!cac_leakage_table)
 		return -ENOMEM;
 
···
 
 
 			table = kzalloc_flex(*table, entries,
-					     ptable->ucNumEntries, GFP_KERNEL);
+					     ptable->ucNumEntries);
 			if (!table)
 				return -ENOMEM;
 

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

···
 			"Invalid PowerPlay Table!", return -1);
 
 	mm_table = kzalloc_flex(*mm_table, entries,
-				mm_dependency_table->ucNumEntries, GFP_KERNEL);
+				mm_dependency_table->ucNumEntries);
 	if (!mm_table)
 		return -ENOMEM;
 
···
 		"Invalid PowerPlay Table!", return -1);
 
 	clk_table = kzalloc_flex(*clk_table, entries,
-				 clk_dep_table->ucNumEntries, GFP_KERNEL);
+				 clk_dep_table->ucNumEntries);
 	if (!clk_table)
 		return -ENOMEM;
 
···
 		"Invalid PowerPlay Table!", return -1);
 
 	mclk_table = kzalloc_flex(*mclk_table, entries,
-				  mclk_dep_table->ucNumEntries, GFP_KERNEL);
+				  mclk_dep_table->ucNumEntries);
 	if (!mclk_table)
 		return -ENOMEM;
 
···
 			"Invalid PowerPlay Table!", return -1);
 
 	clk_table = kzalloc_flex(*clk_table, entries,
-				 clk_dep_table->ucNumEntries, GFP_KERNEL);
+				 clk_dep_table->ucNumEntries);
 	if (!clk_table)
 		return -ENOMEM;
 
···
 			"Invalid PowerPlay Table!", return -1);
 
 	clk_table = kzalloc_flex(*clk_table, entries,
-				 clk_dep_table->ucNumEntries, GFP_KERNEL);
+				 clk_dep_table->ucNumEntries);
 	if (!clk_table)
 		return -ENOMEM;
 
···
 			return 0);
 
 	pcie_table = kzalloc_flex(*pcie_table, entries,
-				  atom_pcie_table->ucNumEntries, GFP_KERNEL);
+				  atom_pcie_table->ucNumEntries);
 	if (!pcie_table)
 		return -ENOMEM;
 

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

···
 		return -EINVAL;
 
 	activity_monitor_external = kzalloc_objs(*activity_monitor_external,
-						 PP_SMC_POWER_PROFILE_COUNT,
-						 GFP_KERNEL);
+						 PP_SMC_POWER_PROFILE_COUNT);
 	if (!activity_monitor_external)
 		return -ENOMEM;
 

drivers/gpu/drm/display/drm_dp_mst_topology.c

···
 
 		num_commit_deps = hweight32(mst_state->pending_crtc_mask);
 		mst_state->commit_deps = kmalloc_objs(*mst_state->commit_deps,
-						      num_commit_deps,
-						      GFP_KERNEL);
+						      num_commit_deps);
 		if (!mst_state->commit_deps)
 			return -ENOMEM;
 		mst_state->num_commit_deps = num_commit_deps;

drivers/gpu/drm/drm_atomic.c

···
 	if (!state->crtcs)
 		goto fail;
 	state->planes = kzalloc_objs(*state->planes,
-				     dev->mode_config.num_total_plane,
-				     GFP_KERNEL);
+				     dev->mode_config.num_total_plane);
 	if (!state->planes)
 		goto fail;
 	state->colorops = kzalloc_objs(*state->colorops,
-				       dev->mode_config.num_colorop, GFP_KERNEL);
+				       dev->mode_config.num_colorop);
 	if (!state->colorops)
 		goto fail;
 

drivers/gpu/drm/drm_buddy.c

···
 
 	for_each_free_tree(i) {
 		mm->free_trees[i] = kmalloc_objs(struct rb_root,
-						 mm->max_order + 1, GFP_KERNEL);
+						 mm->max_order + 1);
 		if (!mm->free_trees[i])
 			goto out_free_tree;
 

drivers/gpu/drm/drm_client_modeset.c

···
 
 	for (modeset = client->modesets; modeset->crtc; modeset++) {
 		modeset->connectors = kzalloc_objs(*modeset->connectors,
-						   max_connector_count,
-						   GFP_KERNEL);
+						   max_connector_count);
 		if (!modeset->connectors)
 			goto err_free;
 	}

drivers/gpu/drm/drm_crtc.c

···
 		}
 
 		connector_set = kmalloc_objs(struct drm_connector *,
-					     crtc_req->count_connectors,
-					     GFP_KERNEL);
+					     crtc_req->count_connectors);
 		if (!connector_set) {
 			ret = -ENOMEM;
 			goto out;

drivers/gpu/drm/drm_crtc_helper.c

···
 	 * connector data.
 	 */
 	save_encoder_crtcs = kzalloc_objs(struct drm_crtc *,
-					  dev->mode_config.num_encoder,
-					  GFP_KERNEL);
+					  dev->mode_config.num_encoder);
 	if (!save_encoder_crtcs)
 		return -ENOMEM;
 
 	save_connector_encoders = kzalloc_objs(struct drm_encoder *,
-					       dev->mode_config.num_connector,
-					       GFP_KERNEL);
+					       dev->mode_config.num_connector);
 	if (!save_connector_encoders) {
 		kfree(save_encoder_crtcs);
 		return -ENOMEM;

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

···
 	power_domains->power_well_count = power_well_count;
 	power_domains->power_wells =
 				kzalloc_objs(*power_domains->power_wells,
-					     power_well_count, GFP_KERNEL);
+					     power_well_count);
 	if (!power_domains->power_wells)
 		return -ENOMEM;
 

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

···
 
 	if (!data->streams)
 		data->streams = kzalloc_objs(struct hdcp2_streamid_type,
-					     INTEL_NUM_PIPES(display),
-					     GFP_KERNEL);
+					     INTEL_NUM_PIPES(display));
 	if (!data->streams) {
 		drm_err(display->drm, "Out of Memory\n");
 		return -ENOMEM;

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

···
 
 	for (i = 0; i < GUC_CAPTURE_LIST_TYPE_MAX; ++i) {
 		new->reginfo[i].regs = kzalloc_objs(struct guc_mmio_reg,
-						    guc->capture->max_mmio_per_node,
-						    GFP_KERNEL);
+						    guc->capture->max_mmio_per_node);
 		if (!new->reginfo[i].regs) {
 			while (i)
 				kfree(new->reginfo[--i].regs);

drivers/gpu/drm/nouveau/nouveau_sched.c

···
 		}
 
 		job->out_sync.objs = kzalloc_objs(*job->out_sync.objs,
-						  job->out_sync.count,
-						  GFP_KERNEL);
+						  job->out_sync.count);
 		if (!job->out_sync.objs) {
 			ret = -ENOMEM;
 			goto err_free_out_sync;
 		}
 
 		job->out_sync.chains = kzalloc_objs(*job->out_sync.chains,
-						    job->out_sync.count,
-						    GFP_KERNEL);
+						    job->out_sync.count);
 		if (!job->out_sync.chains) {
 			ret = -ENOMEM;
 			goto err_free_objs;

drivers/gpu/drm/omapdrm/omap_dmm_tiler.c

···
 
 	/* alloc engines */
 	omap_dmm->engines = kzalloc_objs(*omap_dmm->engines,
-					 omap_dmm->num_engines, GFP_KERNEL);
+					 omap_dmm->num_engines);
 	if (!omap_dmm->engines) {
 		ret = -ENOMEM;
 		goto fail;

drivers/gpu/drm/panthor/panthor_mmu.c

···
 		   ((ALIGN(va + size, 1ull << 21) - ALIGN_DOWN(va, 1ull << 21)) >> 21);
 
 	op_ctx->rsvd_page_tables.pages = kzalloc_objs(*op_ctx->rsvd_page_tables.pages,
-						      pt_count, GFP_KERNEL);
+						      pt_count);
 	if (!op_ctx->rsvd_page_tables.pages) {
 		ret = -ENOMEM;
 		goto err_cleanup;
···
 
 	if (pt_count) {
 		op_ctx->rsvd_page_tables.pages = kzalloc_objs(*op_ctx->rsvd_page_tables.pages,
-							      pt_count,
-							      GFP_KERNEL);
+							      pt_count);
 		if (!op_ctx->rsvd_page_tables.pages) {
 			ret = -ENOMEM;
 			goto err_cleanup;

drivers/gpu/drm/qxl/qxl_display.c

···
 	}
 	if (!qdev->client_monitors_config) {
 		qdev->client_monitors_config = kzalloc_flex(*qdev->client_monitors_config,
-							    heads, count,
-							    GFP_KERNEL);
+							    heads, count);
 		if (!qdev->client_monitors_config)
 			return -ENOMEM;
 	}

drivers/gpu/drm/radeon/ci_dpm.c

···
 		 le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset));
 
 	rdev->pm.dpm.ps = kzalloc_objs(struct radeon_ps,
-				       state_array->ucNumEntries, GFP_KERNEL);
+				       state_array->ucNumEntries);
 	if (!rdev->pm.dpm.ps)
 		return -ENOMEM;
 	power_state_offset = (u8 *)state_array->states;

drivers/gpu/drm/radeon/kv_dpm.c

···
 		 le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset));
 
 	rdev->pm.dpm.ps = kzalloc_objs(struct radeon_ps,
-				       state_array->ucNumEntries, GFP_KERNEL);
+				       state_array->ucNumEntries);
 	if (!rdev->pm.dpm.ps)
 		return -ENOMEM;
 	power_state_offset = (u8 *)state_array->states;

drivers/gpu/drm/radeon/ni_dpm.c

···
 	power_info = (union power_info *)(mode_info->atom_context->bios + data_offset);
 
 	rdev->pm.dpm.ps = kzalloc_objs(struct radeon_ps,
-				       power_info->pplib.ucNumStates,
-				       GFP_KERNEL);
+				       power_info->pplib.ucNumStates);
 	if (!rdev->pm.dpm.ps)
 		return -ENOMEM;
 

drivers/gpu/drm/radeon/r600_dpm.c

···
 	ATOM_PPLIB_Clock_Voltage_Dependency_Record *entry;
 
 	radeon_table->entries = kzalloc_objs(struct radeon_clock_voltage_dependency_entry,
-					     atom_table->ucNumEntries,
-					     GFP_KERNEL);
+					     atom_table->ucNumEntries);
 	if (!radeon_table->entries)
 		return -ENOMEM;
 
···
 
 			rdev->pm.dpm.dyn_state.phase_shedding_limits_table.entries =
 				kzalloc_objs(struct radeon_phase_shedding_limits_entry,
-					     psl->ucNumEntries, GFP_KERNEL);
+					     psl->ucNumEntries);
 			if (!rdev->pm.dpm.dyn_state.phase_shedding_limits_table.entries) {
 				r600_free_extended_power_table(rdev);
 				return -ENOMEM;

drivers/gpu/drm/radeon/radeon_atombios.c

···
 	if (num_modes == 0)
 		return state_index;
 	rdev->pm.power_state = kzalloc_objs(struct radeon_power_state,
-					    num_modes, GFP_KERNEL);
+					    num_modes);
 	if (!rdev->pm.power_state)
 		return state_index;
 	/* last mode is usually default, array is low to high */
···
 	if (power_info->pplib.ucNumStates == 0)
 		return state_index;
 	rdev->pm.power_state = kzalloc_objs(struct radeon_power_state,
-					    power_info->pplib.ucNumStates,
-					    GFP_KERNEL);
+					    power_info->pplib.ucNumStates);
 	if (!rdev->pm.power_state)
 		return state_index;
 	/* first mode is usually default, followed by low to high */
···
 			  power_info->pplib.ucNonClockSize));
 		rdev->pm.power_state[i].clock_info =
 			kzalloc_objs(struct radeon_pm_clock_info,
-				     (power_info->pplib.ucStateEntrySize - 1) ? (power_info->pplib.ucStateEntrySize - 1) : 1,
-				     GFP_KERNEL);
+				     (power_info->pplib.ucStateEntrySize - 1) ? (power_info->pplib.ucStateEntrySize - 1) : 1);
 		if (!rdev->pm.power_state[i].clock_info)
 			return state_index;
 		if (power_info->pplib.ucStateEntrySize - 1) {
···
 	if (state_array->ucNumEntries == 0)
 		return state_index;
 	rdev->pm.power_state = kzalloc_objs(struct radeon_power_state,
-					    state_array->ucNumEntries,
-					    GFP_KERNEL);
+					    state_array->ucNumEntries);
 	if (!rdev->pm.power_state)
 		return state_index;
 	power_state_offset = (u8 *)state_array->states;
···
 			&non_clock_info_array->nonClockInfo[non_clock_array_index];
 		rdev->pm.power_state[i].clock_info =
 			kzalloc_objs(struct radeon_pm_clock_info,
-				     power_state->v2.ucNumDPMLevels ? power_state->v2.ucNumDPMLevels : 1,
-				     GFP_KERNEL);
+				     power_state->v2.ucNumDPMLevels ? power_state->v2.ucNumDPMLevels : 1);
 		if (!rdev->pm.power_state[i].clock_info)
 			return state_index;
 		if (power_state->v2.ucNumDPMLevels) {

drivers/gpu/drm/radeon/rs780_dpm.c

···
 	power_info = (union power_info *)(mode_info->atom_context->bios + data_offset);
 
 	rdev->pm.dpm.ps = kzalloc_objs(struct radeon_ps,
-				       power_info->pplib.ucNumStates,
-				       GFP_KERNEL);
+				       power_info->pplib.ucNumStates);
 	if (!rdev->pm.dpm.ps)
 		return -ENOMEM;
 

drivers/gpu/drm/radeon/rv6xx_dpm.c

···
 	power_info = (union power_info *)(mode_info->atom_context->bios + data_offset);
 
 	rdev->pm.dpm.ps = kzalloc_objs(struct radeon_ps,
-				       power_info->pplib.ucNumStates,
-				       GFP_KERNEL);
+				       power_info->pplib.ucNumStates);
 	if (!rdev->pm.dpm.ps)
 		return -ENOMEM;
 

drivers/gpu/drm/radeon/rv770_dpm.c

···
 	power_info = (union power_info *)(mode_info->atom_context->bios + data_offset);
 
 	rdev->pm.dpm.ps = kzalloc_objs(struct radeon_ps,
-				       power_info->pplib.ucNumStates,
-				       GFP_KERNEL);
+				       power_info->pplib.ucNumStates);
 	if (!rdev->pm.dpm.ps)
 		return -ENOMEM;
 

drivers/gpu/drm/radeon/si_dpm.c

···
 		 le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset));
 
 	rdev->pm.dpm.ps = kzalloc_objs(struct radeon_ps,
-				       state_array->ucNumEntries, GFP_KERNEL);
+				       state_array->ucNumEntries);
 	if (!rdev->pm.dpm.ps)
 		return -ENOMEM;
 	power_state_offset = (u8 *)state_array->states;

drivers/gpu/drm/radeon/sumo_dpm.c

···
 		 le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset));
 
 	rdev->pm.dpm.ps = kzalloc_objs(struct radeon_ps,
-				       state_array->ucNumEntries, GFP_KERNEL);
+				       state_array->ucNumEntries);
 	if (!rdev->pm.dpm.ps)
 		return -ENOMEM;
 	power_state_offset = (u8 *)state_array->states;

drivers/gpu/drm/radeon/trinity_dpm.c

···
 		 le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset));
 
 	rdev->pm.dpm.ps = kzalloc_objs(struct radeon_ps,
-				       state_array->ucNumEntries, GFP_KERNEL);
+				       state_array->ucNumEntries);
 	if (!rdev->pm.dpm.ps)
 		return -ENOMEM;
 	power_state_offset = (u8 *)state_array->states;

drivers/gpu/drm/v3d/v3d_submit.c

···
 	job->job_type = V3D_CPU_JOB_TYPE_TIMESTAMP_QUERY;
 
 	query_info->queries = kvmalloc_objs(struct v3d_timestamp_query,
-					    timestamp.count, GFP_KERNEL);
+					    timestamp.count);
 	if (!query_info->queries)
 		return -ENOMEM;
 
···
 	job->job_type = V3D_CPU_JOB_TYPE_RESET_TIMESTAMP_QUERY;
 
 	query_info->queries = kvmalloc_objs(struct v3d_timestamp_query,
-					    reset.count, GFP_KERNEL);
+					    reset.count);
 	if (!query_info->queries)
 		return -ENOMEM;
 
···
 	job->job_type = V3D_CPU_JOB_TYPE_COPY_TIMESTAMP_QUERY;
 
 	query_info->queries = kvmalloc_objs(struct v3d_timestamp_query,
-					    copy.count, GFP_KERNEL);
+					    copy.count);
 	if (!query_info->queries)
 		return -ENOMEM;
 

drivers/gpu/drm/vmwgfx/vmwgfx_msg.c

···
 
 	/* Allocate statically-sized temp arrays for pages -- too big to keep in frame */
 	pages_stat = (struct page **) kmalloc_objs(*pages_stat,
-						   ARRAY_SIZE(pdesc->statPPNs) + ARRAY_SIZE(pdesc->infoPPNs) + ARRAY_SIZE(pdesc->strsPPNs),
-						   GFP_KERNEL);
+						   ARRAY_SIZE(pdesc->statPPNs) + ARRAY_SIZE(pdesc->infoPPNs) + ARRAY_SIZE(pdesc->strsPPNs));
 
 	if (!pages_stat)
 		goto err_nomem;

drivers/gpu/drm/xen/xen_drm_front_evtchnl.c

···
 
 	front_info->evt_pairs =
 			kzalloc_objs(struct xen_drm_front_evtchnl_pair,
-				     cfg->num_connectors, GFP_KERNEL);
+				     cfg->num_connectors);
 	if (!front_info->evt_pairs) {
 		ret = -ENOMEM;
 		goto fail;

drivers/hid/hid-core.c

···
 	end = start + size;
 
 	device->collection = kzalloc_objs(struct hid_collection,
-					  HID_DEFAULT_NUM_COLLECTIONS,
-					  GFP_KERNEL);
+					  HID_DEFAULT_NUM_COLLECTIONS);
 	if (!device->collection) {
 		ret = -ENOMEM;
 		goto err;

drivers/hv/connection.c

···
 		version >> 16, version & 0xFFFF);
 
 	vmbus_connection.channels = kzalloc_objs(struct vmbus_channel *,
-						 MAX_CHANNEL_RELIDS, GFP_KERNEL);
+						 MAX_CHANNEL_RELIDS);
 	if (vmbus_connection.channels == NULL) {
 		ret = -ENOMEM;
 		goto cleanup;

drivers/hwmon/acpi_power_meter.c

···
 		goto end;
 
 	resource->domain_devices = kzalloc_objs(struct acpi_device *,
-						pss->package.count, GFP_KERNEL);
+						pss->package.count);
 	if (!resource->domain_devices) {
 		res = -ENOMEM;
 		goto end;

drivers/hwmon/coretemp.c

···
 		 */
 		pdata->nr_cores = NUM_REAL_CORES;
 		pdata->core_data = kzalloc_objs(struct temp_data *,
-						pdata->nr_cores, GFP_KERNEL);
+						pdata->nr_cores);
 		if (!pdata->core_data)
 			return NULL;
 	}

drivers/iio/adc/ti-tsc2046.c

···
 		return -ENOSPC;
 
 	struct tsc2046_adc_atom *tx_buf __free(kfree) = kzalloc_objs(*tx_buf,
-								     max_count,
-								     GFP_KERNEL);
+								     max_count);
 	if (!tx_buf)
 		return -ENOMEM;
 
 	struct tsc2046_adc_atom *rx_buf __free(kfree) = kzalloc_objs(*rx_buf,
-								     max_count,
-								     GFP_KERNEL);
+								     max_count);
 	if (!rx_buf)
 		return -ENOMEM;
 

drivers/iio/dac/ad5360.c

···
 	unsigned int i;
 
 	channels = kzalloc_objs(struct iio_chan_spec,
-				st->chip_info->num_channels, GFP_KERNEL);
+				st->chip_info->num_channels);
 
 	if (!channels)
 		return -ENOMEM;

drivers/iio/industrialio-core.c

···
 
 	iio_dev_opaque->chan_attr_group.attrs =
 		kzalloc_objs(iio_dev_opaque->chan_attr_group.attrs[0],
-			     attrcount + 1, GFP_KERNEL);
+			     attrcount + 1);
 	if (iio_dev_opaque->chan_attr_group.attrs == NULL) {
 		ret = -ENOMEM;
 		goto error_clear_attrs;

drivers/iio/industrialio-event.c

···
 
 	ev_int->group.name = iio_event_group_name;
 	ev_int->group.attrs = kzalloc_objs(ev_int->group.attrs[0],
-					   attrcount + 1, GFP_KERNEL);
+					   attrcount + 1);
 	if (ev_int->group.attrs == NULL) {
 		ret = -ENOMEM;
 		goto error_free_setup_event_lines;

drivers/infiniband/core/cache.c

···
 
 	if (update_pkeys) {
 		pkey_cache = kmalloc_flex(*pkey_cache, table,
-					  tprops->pkey_tbl_len, GFP_KERNEL);
+					  tprops->pkey_tbl_len);
 		if (!pkey_cache) {
 			ret = -ENOMEM;
 			goto err;

drivers/infiniband/core/cma.c

···
 
 	cma_dev->device = device;
 	cma_dev->default_gid_type = kzalloc_objs(*cma_dev->default_gid_type,
-						 device->phys_port_cnt,
-						 GFP_KERNEL);
+						 device->phys_port_cnt);
 	if (!cma_dev->default_gid_type) {
 		ret = -ENOMEM;
 		goto free_cma_dev;

drivers/infiniband/core/device.c

···
 	 * empty slots at the beginning.
 	 */
 	pdata_rcu = kzalloc_flex(*pdata_rcu, pdata,
-				 size_add(rdma_end_port(device), 1), GFP_KERNEL);
+				 size_add(rdma_end_port(device), 1));
 	if (!pdata_rcu)
 		return -ENOMEM;
 	/*

drivers/infiniband/core/iwpm_util.c

···
 int iwpm_init(u8 nl_client)
 {
 	iwpm_hash_bucket = kzalloc_objs(struct hlist_head,
-					IWPM_MAPINFO_HASH_SIZE, GFP_KERNEL);
+					IWPM_MAPINFO_HASH_SIZE);
 	if (!iwpm_hash_bucket)
 		return -ENOMEM;
 
 	iwpm_reminfo_bucket = kzalloc_objs(struct hlist_head,
-					   IWPM_REMINFO_HASH_SIZE, GFP_KERNEL);
+					   IWPM_REMINFO_HASH_SIZE);
 	if (!iwpm_reminfo_bucket) {
 		kfree(iwpm_hash_bucket);
 		return -ENOMEM;

drivers/infiniband/core/sysfs.c

···
 	if (!data)
 		goto err_free_stats;
 	data->group.attrs = kzalloc_objs(*data->group.attrs,
-					 stats->num_counters + 2, GFP_KERNEL);
+					 stats->num_counters + 2);
 	if (!data->group.attrs)
 		goto err_free_data;
 
···
 	int ret;
 
 	gid_attr_group = kzalloc_flex(*gid_attr_group, attrs_list,
-				      size_mul(attr->gid_tbl_len, 2),
-				      GFP_KERNEL);
+				      size_mul(attr->gid_tbl_len, 2));
 	if (!gid_attr_group)
 		return -ENOMEM;
 	gid_attr_group->port = port;
···
 	int ret;
 
 	p = kvzalloc_flex(*p, attrs_list,
-			  size_add(attr->gid_tbl_len, attr->pkey_tbl_len),
-			  GFP_KERNEL);
+			  size_add(attr->gid_tbl_len, attr->pkey_tbl_len));
 	if (!p)
 		return ERR_PTR(-ENOMEM);
 	p->ibdev = device;

drivers/infiniband/core/uverbs_uapi.c

···
 	uapi->num_write = max_write + 1;
 	uapi->num_write_ex = max_write_ex + 1;
 	data = kmalloc_objs(*uapi->write_methods,
-			    uapi->num_write + uapi->num_write_ex, GFP_KERNEL);
+			    uapi->num_write + uapi->num_write_ex);
 	if (!data)
 		return -ENOMEM;
 

drivers/infiniband/hw/bnxt_re/qplib_res.c

···
 	/* Allocate one extra to hold the QP1 entries */
 	rcfw->qp_tbl_size = max_t(u32, BNXT_RE_MAX_QPC_COUNT + 1, dev_attr->max_qp);
 	rcfw->qp_tbl = kzalloc_objs(struct bnxt_qplib_qp_node,
-				    rcfw->qp_tbl_size, GFP_KERNEL);
+				    rcfw->qp_tbl_size);
 	if (!rcfw->qp_tbl)
 		return -ENOMEM;
 

drivers/infiniband/hw/cxgb4/device.c

···
 
 	if (c4iw_wr_log) {
 		rdev->wr_log = kzalloc_objs(*rdev->wr_log,
-					    1 << c4iw_wr_log_size_order,
-					    GFP_KERNEL);
+					    1 << c4iw_wr_log_size_order);
 		if (rdev->wr_log) {
 			rdev->wr_log_size = 1 << c4iw_wr_log_size_order;
 			atomic_set(&rdev->wr_log_idx, 0);

drivers/infiniband/hw/cxgb4/qp.c

···
 		if (!wq->sw_rq)
 			goto err_put_qpid;
 		wq->pending_wrs = kzalloc_objs(*srq->wq.pending_wrs,
-					       srq->wq.size, GFP_KERNEL);
+					       srq->wq.size);
 		if (!wq->pending_wrs)
 			goto err_free_sw_rq;
 	}

drivers/infiniband/hw/hfi1/affinity.c

···
 	}
 
 	dd->comp_vect_mappings = kzalloc_objs(*dd->comp_vect_mappings,
-					      dd->comp_vect_possible_cpus,
-					      GFP_KERNEL);
+					      dd->comp_vect_possible_cpus);
 	if (!dd->comp_vect_mappings) {
 		ret = -ENOMEM;
 		goto fail;

drivers/infiniband/hw/hfi1/pio.c

···
 	dd->hw_to_sw = kmalloc_array(TXE_NUM_CONTEXTS, sizeof(u8),
 					GFP_KERNEL);
 	dd->send_contexts = kzalloc_objs(struct send_context_info,
-					 dd->num_send_contexts, GFP_KERNEL);
+					 dd->num_send_contexts);
 	if (!dd->send_contexts || !dd->hw_to_sw) {
 		kfree(dd->hw_to_sw);
 		kfree(dd->send_contexts);
···
 	int i;
 
 	dd->cr_base = kzalloc_objs(struct credit_return_base,
-				   node_affinity.num_possible_nodes, GFP_KERNEL);
+				   node_affinity.num_possible_nodes);
 	if (!dd->cr_base) {
 		ret = -ENOMEM;
 		goto done;

drivers/infiniband/hw/hfi1/user_exp_rcv.c

···
 	if (!HFI1_CAP_UGET_MASK(uctxt->flags, TID_UNMAP)) {
 		fd->invalid_tid_idx = 0;
 		fd->invalid_tids = kzalloc_objs(*fd->invalid_tids,
-						uctxt->expected_count,
-						GFP_KERNEL);
+						uctxt->expected_count);
 		if (!fd->invalid_tids) {
 			kfree(fd->entry_to_rb);
 			fd->entry_to_rb = NULL;

drivers/infiniband/hw/hns/hns_roce_hem.c

···
 				goto err_kcalloc_bt_l1;
 
 			table->bt_l1_dma_addr = kzalloc_objs(*table->bt_l1_dma_addr,
-							     num_bt_l1,
-							     GFP_KERNEL);
+							     num_bt_l1);
 
 			if (!table->bt_l1_dma_addr)
 				goto err_kcalloc_l1_dma;
···
 				goto err_kcalloc_bt_l0;
 
 			table->bt_l0_dma_addr = kzalloc_objs(*table->bt_l0_dma_addr,
-							     num_bt_l0,
-							     GFP_KERNEL);
+							     num_bt_l0);
 			if (!table->bt_l0_dma_addr)
 				goto err_kcalloc_l0_dma;
 		}

drivers/infiniband/hw/hns/hns_roce_mr.c

···
 
 	mr->npages = 0;
 	mr->page_list = kvzalloc_objs(dma_addr_t,
-				      mr->pbl_mtr.hem_cfg.buf_pg_count,
-				      GFP_KERNEL);
+				      mr->pbl_mtr.hem_cfg.buf_pg_count);
 	if (!mr->page_list)
 		return sg_num;
 

drivers/infiniband/hw/mana/main.c

···
 		return err;
 
 	mdev->eqs = kzalloc_objs(struct gdma_queue *,
-				 mdev->ib_dev.num_comp_vectors, GFP_KERNEL);
+				 mdev->ib_dev.num_comp_vectors);
 	if (!mdev->eqs) {
 		err = -ENOMEM;
 		goto destroy_fatal_eq;

drivers/infiniband/hw/mlx4/mad.c

···
 	int i;
 
 	ctx->tun = kzalloc_objs(struct mlx4_ib_demux_pv_ctx *,
-				dev->dev->caps.sqp_demux, GFP_KERNEL);
+				dev->dev->caps.sqp_demux);
 	if (!ctx->tun)
 		return -ENOMEM;
 

drivers/infiniband/hw/mlx4/main.c

···
 	int i, j, eq = 0, total_eqs = 0;
 
 	ibdev->eq_table = kzalloc_objs(ibdev->eq_table[0],
-				       dev->caps.num_comp_vectors, GFP_KERNEL);
+				       dev->caps.num_comp_vectors);
 	if (!ibdev->eq_table)
 		return;
 

drivers/infiniband/hw/mlx5/macsec.c

···
 	max_gids = MLX5_CAP_ROCE(dev->mdev, roce_address_table_size);
 	for (i = 0; i < dev->num_ports; i++) {
 		dev->port[i].reserved_gids = kzalloc_objs(*dev->port[i].reserved_gids,
-							  max_gids, GFP_KERNEL);
+							  max_gids);
 		if (!dev->port[i].reserved_gids)
 			goto err;
 

drivers/infiniband/hw/mlx5/main.c

···
 		return ERR_PTR(-ENOMEM);
 
 	mplane->port = kzalloc_objs(*mplane->port,
-				    mparent->num_plane * mparent->num_ports,
-				    GFP_KERNEL);
+				    mparent->num_plane * mparent->num_ports);
 	if (!mplane->port) {
 		ret = -ENOMEM;
 		goto fail_kcalloc;

drivers/infiniband/hw/mthca/mthca_cmd.c

···
 	int i;
 
 	dev->cmd.context = kmalloc_objs(struct mthca_cmd_context,
-					dev->cmd.max_cmds, GFP_KERNEL);
+					dev->cmd.max_cmds);
 	if (!dev->cmd.context)
 		return -ENOMEM;
 

drivers/infiniband/hw/mthca/mthca_memfree.c

···
 	dev->db_tab->min_group2 = dev->db_tab->npages - 1;
 
 	dev->db_tab->page = kmalloc_objs(*dev->db_tab->page,
-					 dev->db_tab->npages, GFP_KERNEL);
+					 dev->db_tab->npages);
 	if (!dev->db_tab->page) {
 		kfree(dev->db_tab);
 		return -ENOMEM;

drivers/infiniband/hw/usnic/usnic_uiom.c

···
 
 		while (ret) {
 			chunk = kmalloc_flex(*chunk, page_list,
-					     min_t(int, ret, USNIC_UIOM_PAGE_CHUNK),
-					     GFP_KERNEL);
+					     min_t(int, ret, USNIC_UIOM_PAGE_CHUNK));
 			if (!chunk) {
 				ret = -ENOMEM;
 				goto out;

drivers/infiniband/hw/vmw_pvrdma/pvrdma_main.c

···
 		ib_set_device_ops(&dev->ib_dev, &pvrdma_dev_srq_ops);
 
 		dev->srq_tbl = kzalloc_objs(struct pvrdma_srq *,
-					    dev->dsr->caps.max_srq, GFP_KERNEL);
+					    dev->dsr->caps.max_srq);
 		if (!dev->srq_tbl)
 			goto err_qp_free;
 	}

drivers/infiniband/ulp/iser/iser_initiator.c

···
 
 	iser_conn->num_rx_descs = session->cmds_max;
 	iser_conn->rx_descs = kmalloc_objs(struct iser_rx_desc,
-					   iser_conn->num_rx_descs, GFP_KERNEL);
+					   iser_conn->num_rx_descs);
 	if (!iser_conn->rx_descs)
 		goto rx_desc_alloc_fail;
 

drivers/infiniband/ulp/isert/ib_isert.c

···
 	int i, j;
 
 	isert_conn->rx_descs = kzalloc_objs(struct iser_rx_desc,
-					    ISERT_QP_MAX_RECV_DTOS, GFP_KERNEL);
+					    ISERT_QP_MAX_RECV_DTOS);
 	if (!isert_conn->rx_descs)
 		return -ENOMEM;
 

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

···
 
 		if (!clt_path->rbufs) {
 			clt_path->rbufs = kzalloc_objs(*clt_path->rbufs,
-						       queue_depth, GFP_KERNEL);
+						       queue_depth);
 			if (!clt_path->rbufs)
 				return -ENOMEM;
 		}

drivers/iommu/amd/init.c

···
 static inline int __init alloc_rlookup_table(struct amd_iommu_pci_seg *pci_seg)
 {
 	pci_seg->rlookup_table = kvzalloc_objs(*pci_seg->rlookup_table,
-					       pci_seg->last_bdf + 1,
-					       GFP_KERNEL);
+					       pci_seg->last_bdf + 1);
 	if (pci_seg->rlookup_table == NULL)
 		return -ENOMEM;
 
···
 static inline int __init alloc_irq_lookup_table(struct amd_iommu_pci_seg *pci_seg)
 {
 	pci_seg->irq_lookup_table = kvzalloc_objs(*pci_seg->irq_lookup_table,
-						  pci_seg->last_bdf + 1,
-						  GFP_KERNEL);
+						  pci_seg->last_bdf + 1);
 	if (pci_seg->irq_lookup_table == NULL)
 		return -ENOMEM;
 
···
 	int i;
 
 	pci_seg->alias_table = kvmalloc_objs(*pci_seg->alias_table,
-					     pci_seg->last_bdf + 1, GFP_KERNEL);
+					     pci_seg->last_bdf + 1);
 	if (!pci_seg->alias_table)
 		return -ENOMEM;
 

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

···
 			DIV_ROUND_UP(max_contexts, CTXDESC_L2_ENTRIES);
 
 		cd_table->l2.l2ptrs = kzalloc_objs(*cd_table->l2.l2ptrs,
-						   cd_table->l2.num_l1_ents,
-						   GFP_KERNEL);
+						   cd_table->l2.num_l1_ents);
 		if (!cd_table->l2.l2ptrs)
 			return -ENOMEM;
 

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

···
 	vintf->base = cmdqv->base + TEGRA241_VINTF(idx);
 
 	vintf->lvcmdqs = kzalloc_objs(*vintf->lvcmdqs,
-				      cmdqv->num_lvcmdqs_per_vintf, GFP_KERNEL);
+				      cmdqv->num_lvcmdqs_per_vintf);
 	if (!vintf->lvcmdqs) {
 		ida_free(&cmdqv->vintf_ids, idx);
 		return -ENOMEM;

drivers/iommu/iova.c

···
 	int i, ret;
 
 	iovad->rcaches = kzalloc_objs(struct iova_rcache,
-				      IOVA_RANGE_CACHE_MAX_SIZE, GFP_KERNEL);
+				      IOVA_RANGE_CACHE_MAX_SIZE);
 	if (!iovad->rcaches)
 		return -ENOMEM;
 

drivers/irqchip/irq-mtk-sysirq.c

···
 	}
 
 	chip_data->intpol_bases = kzalloc_objs(*chip_data->intpol_bases,
-					       nr_intpol_bases, GFP_KERNEL);
+					       nr_intpol_bases);
 	if (!chip_data->intpol_bases) {
 		ret = -ENOMEM;
 		goto out_free_intpol_words;

drivers/irqchip/irq-riscv-imsic-state.c

···
 
 		/* Allocate vector array */
 		lpriv->vectors = kzalloc_objs(*lpriv->vectors,
-					      global->nr_ids + 1, GFP_KERNEL);
+					      global->nr_ids + 1);
 		if (!lpriv->vectors)
 			goto fail_local_cleanup;
 

drivers/irqchip/irq-stm32-exti.c

···
 
 	host_data->drv_data = dd;
 	host_data->chips_data = kzalloc_objs(struct stm32_exti_chip_data,
-					     dd->bank_nr, GFP_KERNEL);
+					     dd->bank_nr);
 	if (!host_data->chips_data)
 		goto free_host_data;
 

drivers/md/dm-crypt.c

···
 	int err;
 
 	cc->cipher_tfm.tfms = kzalloc_objs(struct crypto_skcipher *,
-					   cc->tfms_count, GFP_KERNEL);
+					   cc->tfms_count);
 	if (!cc->cipher_tfm.tfms)
 		return -ENOMEM;
 

drivers/md/dm-integrity.c

···
 			}
 
 			sg = kvmalloc_objs(struct scatterlist,
-					   ic->journal_pages + 1, GFP_KERNEL);
+					   ic->journal_pages + 1);
 			if (!sg) {
 				*error = "Unable to allocate sg list";
 				r = -ENOMEM;
···
 			goto bad;
 		}
 		ic->bbs = kvmalloc_objs(struct bitmap_block_status,
-					ic->n_bitmap_blocks, GFP_KERNEL);
+					ic->n_bitmap_blocks);
 		if (!ic->bbs) {
 			ti->error = "Could not allocate memory for bitmap";
 			r = -ENOMEM;

drivers/md/dm-pcache/cache.c

···
 	int ret;
 
 	cache->segments = kvzalloc_objs(struct pcache_cache_segment,
-					cache_dev->seg_num, GFP_KERNEL);
+					cache_dev->seg_num);
 	if (!cache->segments) {
 		ret = -ENOMEM;
 		goto err;

drivers/md/dm-pcache/cache_key.c

···
 	 * an RB tree root and a spinlock for protecting its contents.
 	 */
 	cache_tree->subtrees = kvzalloc_objs(struct pcache_cache_subtree,
-					     cache_tree->n_subtrees, GFP_KERNEL);
+					     cache_tree->n_subtrees);
 	if (!cache_tree->subtrees) {
 		ret = -ENOMEM;
 		goto key_pool_exit;

drivers/md/dm-stats.c

···
 			(*n_histogram_entries)++;
 
 	*histogram_boundaries = kmalloc_objs(unsigned long long,
-					     *n_histogram_entries, GFP_KERNEL);
+					     *n_histogram_entries);
 	if (!*histogram_boundaries)
 		return -ENOMEM;
 

drivers/md/md-cluster.c

···
 
 	cinfo->other_bitmap_lockres =
 		kzalloc_objs(struct dlm_lock_resource *,
-			     mddev->bitmap_info.nodes - 1, GFP_KERNEL);
+			     mddev->bitmap_info.nodes - 1);
 	if (!cinfo->other_bitmap_lockres) {
 		pr_err("md: can't alloc mem for other bitmap locks\n");
 		return 0;

drivers/md/raid10.c

···
 
 	/* FIXME calc properly */
 	conf->mirrors = kzalloc_objs(struct raid10_info,
-				     mddev->raid_disks + max(0, -mddev->delta_disks),
-				     GFP_KERNEL);
+				     mddev->raid_disks + max(0, -mddev->delta_disks));
 	if (!conf->mirrors)
 		goto out;
 
···
 		/* allocate new 'mirrors' list */
 		conf->mirrors_new =
 			kzalloc_objs(struct raid10_info,
-				     mddev->raid_disks + mddev->delta_disks,
-				     GFP_KERNEL);
+				     mddev->raid_disks + mddev->delta_disks);
 		if (!conf->mirrors_new)
 			return -ENOMEM;
 	}

drivers/media/pci/tw686x/tw686x-core.c

···
 	sprintf(dev->name, "tw%04X", pci_dev->device);
 
 	dev->video_channels = kzalloc_objs(*dev->video_channels,
-					   max_channels(dev), GFP_KERNEL);
+					   max_channels(dev));
 	if (!dev->video_channels) {
 		err = -ENOMEM;
 		goto free_dev;
 	}
 
 	dev->audio_channels = kzalloc_objs(*dev->audio_channels,
-					   max_channels(dev), GFP_KERNEL);
+					   max_channels(dev));
 	if (!dev->audio_channels) {
 		err = -ENOMEM;
 		goto free_video;

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

···
 
 	/* Define and configure additional controls from cx2341x module. */
 	hdw->mpeg_ctrl_info = kzalloc_objs(*(hdw->mpeg_ctrl_info),
-					   MPEGDEF_COUNT, GFP_KERNEL);
+					   MPEGDEF_COUNT);
 	if (!hdw->mpeg_ctrl_info) goto fail;
 	for (idx = 0; idx < MPEGDEF_COUNT; idx++) {
 		cptr = hdw->controls + idx + CTRLDEF_COUNT;

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

···
 
 	if (new_configs.num_configs) {
 		new_configs.configs = kvzalloc_objs(*new_configs.configs,
-						    new_configs.num_configs,
-						    GFP_KERNEL);
+						    new_configs.num_configs);
 
 		if (!new_configs.configs)
 			return -ENOMEM;

drivers/memstick/core/mspro_block.c

···
 		attr_count = attr->count;
 
 	msb->attr_group.attrs = kzalloc_objs(*msb->attr_group.attrs,
-					     attr_count + 1, GFP_KERNEL);
+					     attr_count + 1);
 	if (!msb->attr_group.attrs) {
 		rc = -ENOMEM;
 		goto out_free_attr;

drivers/message/fusion/mptsas.c

···
 
 	port_info->num_phys = buffer->NumPhys;
 	port_info->phy_info = kzalloc_objs(struct mptsas_phyinfo,
-					   port_info->num_phys, GFP_KERNEL);
+					   port_info->num_phys);
 	if (!port_info->phy_info) {
 		error = -ENOMEM;
 		goto out_free_consistent;
···
 	/* save config data */
 	port_info->num_phys = (buffer->NumPhys) ? buffer->NumPhys : 1;
 	port_info->phy_info = kzalloc_objs(struct mptsas_phyinfo,
-					   port_info->num_phys, GFP_KERNEL);
+					   port_info->num_phys);
 	if (!port_info->phy_info) {
 		error = -ENOMEM;
 		goto out_free_consistent;
···
 	port_info->num_phys = (expander_data->NumPhys) ?
 	    expander_data->NumPhys : 1;
 	port_info->phy_info = kzalloc_objs(struct mptsas_phyinfo,
-					   port_info->num_phys, GFP_KERNEL);
+					   port_info->num_phys);
 	BUG_ON(!port_info->phy_info);
 	memcpy(&sas_address, &expander_data->SASAddress, sizeof(__le64));
 	for (i = 0; i < port_info->num_phys; i++) {

drivers/mtd/chips/cfi_cmdset_0001.c

···
 
 	mtd->numeraseregions = cfi->cfiq->NumEraseRegions * cfi->numchips;
 	mtd->eraseregions = kzalloc_objs(struct mtd_erase_region_info,
-					 mtd->numeraseregions, GFP_KERNEL);
+					 mtd->numeraseregions);
 	if (!mtd->eraseregions)
 		goto setup_err;
 

drivers/mtd/chips/cfi_cmdset_0002.c

···
 
 	mtd->numeraseregions = cfi->cfiq->NumEraseRegions * cfi->numchips;
 	mtd->eraseregions = kmalloc_objs(struct mtd_erase_region_info,
-					 mtd->numeraseregions, GFP_KERNEL);
+					 mtd->numeraseregions);
 	if (!mtd->eraseregions)
 		goto setup_err;
 

drivers/mtd/chips/cfi_cmdset_0020.c

···
 
 	mtd->numeraseregions = cfi->cfiq->NumEraseRegions * cfi->numchips;
 	mtd->eraseregions = kmalloc_objs(struct mtd_erase_region_info,
-					 mtd->numeraseregions, GFP_KERNEL);
+					 mtd->numeraseregions);
 	if (!mtd->eraseregions) {
 		kfree(cfi->cmdset_priv);
 		kfree(mtd);

drivers/mtd/nand/onenand/onenand_base.c

···
 		mtd->numeraseregions = this->dies << 1;
 		mtd->eraseregions =
 			kzalloc_objs(struct mtd_erase_region_info,
-				     this->dies << 1, GFP_KERNEL);
+				     this->dies << 1);
 		if (!mtd->eraseregions)
 			return -ENOMEM;
 	}

drivers/mtd/nand/raw/nand_base.c

···
 
 	chip->nr_secure_regions = nr_elem / 2;
 	chip->secure_regions = kzalloc_objs(*chip->secure_regions,
-					    chip->nr_secure_regions, GFP_KERNEL);
+					    chip->nr_secure_regions);
 	if (!chip->secure_regions)
 		return -ENOMEM;
 

drivers/mtd/parsers/sharpslpart.c

···
 	}
 
 	sharpsl_nand_parts = kzalloc_objs(*sharpsl_nand_parts,
-					  SHARPSL_NAND_PARTS, GFP_KERNEL);
+					  SHARPSL_NAND_PARTS);
 	if (!sharpsl_nand_parts)
 		return -ENOMEM;
 

drivers/net/can/usb/ucan.c

···
 	ucan_release_context_array(up);
 
 	up->context_array = kzalloc_objs(*up->context_array,
-					 up->device_info.tx_fifo, GFP_KERNEL);
+					 up->device_info.tx_fifo);
 	if (!up->context_array) {
 		netdev_err(up->netdev,
 			   "Not enough memory to allocate tx contexts\n");

drivers/net/dsa/mv88e6xxx/devlink.c

···
 	int fid = -1, err = 0, count = 0;
 
 	table = kzalloc_objs(struct mv88e6xxx_devlink_atu_entry,
-			     mv88e6xxx_num_databases(chip), GFP_KERNEL);
+			     mv88e6xxx_num_databases(chip));
 	if (!table)
 		return -ENOMEM;
 
···
 	int err;
 
 	table = kzalloc_objs(struct mv88e6xxx_devlink_vtu_entry,
-			     mv88e6xxx_max_vid(chip) + 1, GFP_KERNEL);
+			     mv88e6xxx_max_vid(chip) + 1);
 	if (!table)
 		return -ENOMEM;
 
···
 	int err;
 
 	table = kzalloc_objs(struct mv88e6xxx_devlink_stu_entry,
-			     mv88e6xxx_max_sid(chip) + 1, GFP_KERNEL);
+			     mv88e6xxx_max_sid(chip) + 1);
 	if (!table)
 		return -ENOMEM;
 

drivers/net/dsa/sja1105/sja1105_vl.c

···
 		rule->vl.cycle_time = cycle_time;
 		rule->vl.num_entries = num_entries;
 		rule->vl.entries = kzalloc_objs(struct action_gate_entry,
-						num_entries, GFP_KERNEL);
+						num_entries);
 		if (!rule->vl.entries) {
 			rc = -ENOMEM;
 			goto out;

drivers/net/ethernet/amd/pds_core/core.c

···
 	enum pds_core_vif_types vt;
 
 	pdsc->viftype_status = kzalloc_objs(*pdsc->viftype_status,
-					    ARRAY_SIZE(pdsc_viftype_defaults),
-					    GFP_KERNEL);
+					    ARRAY_SIZE(pdsc_viftype_defaults));
 	if (!pdsc->viftype_status)
 		return -ENOMEM;
 

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

···
 			   index, cos);
 
 			txdata->tx_buf_ring = kzalloc_objs(struct sw_tx_bd,
-							   NUM_TX_BD,
-							   GFP_KERNEL);
+							   NUM_TX_BD);
 			if (!txdata->tx_buf_ring)
 				goto alloc_mem_err;
 			txdata->tx_desc_ring = BNX2X_PCI_ALLOC(&txdata->tx_desc_mapping,
···
 	for (i = 0; i < bp->fp_array_size; i++) {
 		fp[i].tpa_info =
 			kzalloc_objs(struct bnx2x_agg_info,
-				     ETH_MAX_AGGREGATION_QUEUES_E1H_E2,
-				     GFP_KERNEL);
+				     ETH_MAX_AGGREGATION_QUEUES_E1H_E2);
 		if (!(fp[i].tpa_info))
 			goto alloc_err;
 	}

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

···
 
 	/* allocate the queue arrays for all VFs */
 	bp->vfdb->vfqs = kzalloc_objs(struct bnx2x_vf_queue,
-				      BNX2X_MAX_NUM_VF_QUEUES, GFP_KERNEL);
+				      BNX2X_MAX_NUM_VF_QUEUES);
 
 	if (!bp->vfdb->vfqs) {
 		BNX2X_ERR("failed to allocate vf queue array\n");

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

···
 
 	if (irq_re_init) {
 		bp->grp_info = kzalloc_objs(struct bnxt_ring_grp_info,
-					    bp->cp_nr_rings, GFP_KERNEL);
+					    bp->cp_nr_rings);
 		if (!bp->grp_info)
 			return -ENOMEM;
 	}
···
 		}
 
 		bp->rx_ring = kzalloc_objs(struct bnxt_rx_ring_info,
-					   bp->rx_nr_rings, GFP_KERNEL);
+					   bp->rx_nr_rings);
 		if (!bp->rx_ring)
 			return -ENOMEM;
 
···
 		}
 
 		bp->tx_ring = kzalloc_objs(struct bnxt_tx_ring_info,
-					   bp->tx_nr_rings, GFP_KERNEL);
+					   bp->tx_nr_rings);
 		if (!bp->tx_ring)
 			return -ENOMEM;
 

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

···
 	pps_info->num_pins = resp->num_pins;
 	ptp_info->n_pins = pps_info->num_pins;
 	ptp_info->pin_config = kzalloc_objs(*ptp_info->pin_config,
-					    ptp_info->n_pins, GFP_KERNEL);
+					    ptp_info->n_pins);
 	if (!ptp_info->pin_config) {
 		hwrm_req_drop(bp, req);
 		return -ENOMEM;

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

···
 	d->sbdma_maxdescr = maxdescr;
 
 	d->sbdma_dscrtable_unaligned = kzalloc_objs(*d->sbdma_dscrtable,
-						    d->sbdma_maxdescr + 1,
-						    GFP_KERNEL);
+						    d->sbdma_maxdescr + 1);
 
 	/*
 	 * The descriptor table must be aligned to at least 16 bytes or the

drivers/net/ethernet/broadcom/tg3.c

···
 
 	for (i = 0; i < tp->txq_cnt; i++, tnapi++) {
 		tnapi->tx_buffers = kzalloc_objs(struct tg3_tx_ring_info,
-						 TG3_TX_RING_SIZE, GFP_KERNEL);
+						 TG3_TX_RING_SIZE);
 		if (!tnapi->tx_buffers)
 			goto err_out;
 

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

···
 	if (cfg_flags & BNAD_CF_MSIX) {
 		intr_info->intr_type = BNA_INTR_T_MSIX;
 		intr_info->idl = kzalloc_objs(struct bna_intr_descr,
-					      intr_info->num, GFP_KERNEL);
+					      intr_info->num);
 		if (!intr_info->idl)
 			return -ENOMEM;
 
···
 		intr_info->intr_type = BNA_INTR_T_INTX;
 		intr_info->num = 1;
 		intr_info->idl = kzalloc_objs(struct bna_intr_descr,
-					      intr_info->num, GFP_KERNEL);
+					      intr_info->num);
 		if (!intr_info->idl)
 			return -ENOMEM;
 

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

···
 				[IRQ_NAME_OFF(MAX_IOQ_INTERRUPTS_PER_PF)];
 
 		oct->msix_entries = kzalloc_objs(struct msix_entry,
-						 oct->num_msix_irqs, GFP_KERNEL);
+						 oct->num_msix_irqs);
 		if (!oct->msix_entries) {
 			dev_err(&oct->pci_dev->dev, "Memory Alloc failed...\n");
 			kfree(oct->irq_name_storage);

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

···
 	}
 
 	adap->sge.ingr_map = kzalloc_objs(*adap->sge.ingr_map,
-					  adap->sge.ingr_sz, GFP_KERNEL);
+					  adap->sge.ingr_sz);
 	if (!adap->sge.ingr_map) {
 		ret = -ENOMEM;
 		goto bye;
···
 		}
 		/* Allocate and set up VF Information. */
 		adap->vfinfo = kzalloc_objs(struct vf_info,
-					    pci_sriov_get_totalvfs(pdev),
-					    GFP_KERNEL);
+					    pci_sriov_get_totalvfs(pdev));
 		if (!adap->vfinfo) {
 			unregister_netdev(adap->port[0]);
 			free_netdev(adap->port[0]);

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

···
 	/* Allocate ETHOFLD hardware queue structures if not done already */
 	if (!refcount_read(&adap->tc_mqprio->refcnt)) {
 		adap->sge.eohw_rxq = kzalloc_objs(struct sge_ofld_rxq,
-						  adap->sge.eoqsets, GFP_KERNEL);
+						  adap->sge.eoqsets);
 		if (!adap->sge.eohw_rxq)
 			return -ENOMEM;
 
 		adap->sge.eohw_txq = kzalloc_objs(struct sge_eohw_txq,
-						  adap->sge.eoqsets, GFP_KERNEL);
+						  adap->sge.eoqsets);
 		if (!adap->sge.eohw_txq) {
 			kfree(adap->sge.eohw_rxq);
 			return -ENOMEM;

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

···
 		goto free_queues;
 
 	enic->napi = kzalloc_objs(struct napi_struct,
-				  enic->wq_avail + enic->rq_avail, GFP_KERNEL);
+				  enic->wq_avail + enic->rq_avail);
 	if (!enic->napi)
 		goto free_queues;
 

drivers/net/ethernet/engleder/tsnep_main.c

···
 		return -EOPNOTSUPP;
 
 	queue->rx->page_buffer = kzalloc_objs(*queue->rx->page_buffer,
-					      TSNEP_RING_SIZE, GFP_KERNEL);
+					      TSNEP_RING_SIZE);
 	if (!queue->rx->page_buffer)
 		return -ENOMEM;
 	queue->rx->xdp_batch = kzalloc_objs(*queue->rx->xdp_batch,
-					    TSNEP_RING_SIZE, GFP_KERNEL);
+					    TSNEP_RING_SIZE);
 	if (!queue->rx->xdp_batch) {
 		kfree(queue->rx->page_buffer);
 		queue->rx->page_buffer = NULL;

drivers/net/ethernet/freescale/dpaa2/dpaa2-eth-devlink.c

···
 	priv->trap_data = dpaa2_eth_trap_data;
 
 	dpaa2_eth_trap_data->trap_items_arr = kzalloc_objs(struct dpaa2_eth_trap_item,
-							   ARRAY_SIZE(dpaa2_eth_traps_arr),
-							   GFP_KERNEL);
+							   ARRAY_SIZE(dpaa2_eth_traps_arr));
 	if (!dpaa2_eth_trap_data->trap_items_arr) {
 		err = -ENOMEM;
 		goto trap_data_free;

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

···
 	}
 
 	ethsw->filter_blocks = kzalloc_objs(*ethsw->filter_blocks,
-					    ethsw->sw_attr.num_ifs, GFP_KERNEL);
+					    ethsw->sw_attr.num_ifs);
 	if (!ethsw->filter_blocks) {
 		err = -ENOMEM;
 		goto err_free_fdbs;

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

···
 	pf->total_vfs = pci_sriov_get_totalvfs(pdev);
 	if (pf->total_vfs) {
 		pf->vf_state = kzalloc_objs(struct enetc_vf_state,
-					    pf->total_vfs, GFP_KERNEL);
+					    pf->total_vfs);
 		if (!pf->vf_state)
 			goto err_alloc_vf_state;
 	}

drivers/net/ethernet/freescale/gianfar.c

···
 		tx_queue = priv->tx_queue[i];
 		tx_queue->tx_skbuff =
 			kmalloc_objs(*tx_queue->tx_skbuff,
-				     tx_queue->tx_ring_size, GFP_KERNEL);
+				     tx_queue->tx_ring_size);
 		if (!tx_queue->tx_skbuff)
 			goto cleanup;
 
···
 	for (i = 0; i < priv->num_rx_queues; i++) {
 		rx_queue = priv->rx_queue[i];
 		rx_queue->rx_buff = kzalloc_objs(*rx_queue->rx_buff,
-						 rx_queue->rx_ring_size,
-						 GFP_KERNEL);
+						 rx_queue->rx_ring_size);
 		if (!rx_queue->rx_buff)
 			goto cleanup;
 	}

drivers/net/ethernet/freescale/ucc_geth.c

···
 		/* Setup the skbuff rings */
 		ugeth->tx_skbuff[j] =
 			kzalloc_objs(struct sk_buff *,
-				     ugeth->ug_info->bdRingLenTx[j], GFP_KERNEL);
+				     ugeth->ug_info->bdRingLenTx[j]);
 
 		if (ugeth->tx_skbuff[j] == NULL) {
 			if (netif_msg_ifup(ugeth))
···
 		/* Setup the skbuff rings */
 		ugeth->rx_skbuff[j] =
 			kzalloc_objs(struct sk_buff *,
-				     ugeth->ug_info->bdRingLenRx[j], GFP_KERNEL);
+				     ugeth->ug_info->bdRingLenRx[j]);
 
 		if (ugeth->rx_skbuff[j] == NULL) {
 			if (netif_msg_ifup(ugeth))

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

···
 
 	flow_rules_cache->rules_cache =
 		kvzalloc_objs(*flow_rules_cache->rules_cache,
-			      GVE_FLOW_RULES_CACHE_SIZE, GFP_KERNEL);
+			      GVE_FLOW_RULES_CACHE_SIZE);
 	if (!flow_rules_cache->rules_cache) {
 		dev_err(&priv->pdev->dev, "Cannot alloc flow rules cache\n");
 		return -ENOMEM;
···
 	int err;
 
 	priv->msix_vectors = kvzalloc_objs(*priv->msix_vectors,
-					   num_vecs_requested, GFP_KERNEL);
+					   num_vecs_requested);
 	if (!priv->msix_vectors)
 		return -ENOMEM;
 	for (i = 0; i < num_vecs_requested; i++)

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

···
 	int i;
 
 	tx->dqo.tx_qpl_buf_next = kvzalloc_objs(tx->dqo.tx_qpl_buf_next[0],
-						num_tx_qpl_bufs, GFP_KERNEL);
+						num_tx_qpl_bufs);
 	if (!tx->dqo.tx_qpl_buf_next)
 		return -ENOMEM;
 
···
 
 	tx->dqo.num_pending_packets = min_t(int, num_pending_packets, S16_MAX);
 	tx->dqo.pending_packets = kvzalloc_objs(tx->dqo.pending_packets[0],
-						tx->dqo.num_pending_packets,
-						GFP_KERNEL);
+						tx->dqo.num_pending_packets);
 	if (!tx->dqo.pending_packets)
 		goto err;
 

drivers/net/ethernet/hisilicon/hns3/hns3_ethtool.c

···
 	int i;
 
 	tmp_rings = kzalloc_objs(struct hns3_enet_ring,
-				 handle->kinfo.num_tqps * 2, GFP_KERNEL);
+				 handle->kinfo.num_tqps * 2);
 	if (!tmp_rings)
 		return NULL;
 

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

···
 	struct hinic3_nic_dev *nic_dev = netdev_priv(netdev);
 
 	nic_dev->intr_coalesce = kzalloc_objs(*nic_dev->intr_coalesce,
-					      nic_dev->max_qps, GFP_KERNEL);
+					      nic_dev->max_qps);
 
 	if (!nic_dev->intr_coalesce)
 		return -ENOMEM;

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

···
 	nic_dev->num_qp_irq = 0;
 
 	nic_dev->qps_msix_entries = kzalloc_objs(struct msix_entry,
-						 nic_dev->max_qps, GFP_KERNEL);
+						 nic_dev->max_qps);
 	if (!nic_dev->qps_msix_entries)
 		return -ENOMEM;
 
···
 	int err;
 
 	q_params->txqs_res = kzalloc_objs(*q_params->txqs_res,
-					  q_params->num_qps, GFP_KERNEL);
+					  q_params->num_qps);
 	if (!q_params->txqs_res)
 		return -ENOMEM;
 
 	q_params->rxqs_res = kzalloc_objs(*q_params->rxqs_res,
-					  q_params->num_qps, GFP_KERNEL);
+					  q_params->num_qps);
 	if (!q_params->rxqs_res) {
 		err = -ENOMEM;
 		goto err_free_txqs_res_arr;

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

···
 			goto err_free_tqres;
 
 		tqres->bds = kzalloc_objs(*tqres->bds,
-					  sq_depth * HINIC3_BDS_PER_SQ_WQEBB + HINIC3_MAX_SQ_SGE,
-					  GFP_KERNEL);
+					  sq_depth * HINIC3_BDS_PER_SQ_WQEBB + HINIC3_MAX_SQ_SGE);
 		if (!tqres->bds) {
 			kfree(tqres->tx_info);
 			goto err_free_tqres;

drivers/net/ethernet/ibm/ibmvnic.c

···
 {
 	adapter->tx_stats_buffers =
 				kzalloc_objs(struct ibmvnic_tx_queue_stats,
-					     IBMVNIC_MAX_QUEUES, GFP_KERNEL);
+					     IBMVNIC_MAX_QUEUES);
 	if (!adapter->tx_stats_buffers)
 		return -ENOMEM;
 
 	adapter->rx_stats_buffers =
 				kzalloc_objs(struct ibmvnic_rx_queue_stats,
-					     IBMVNIC_MAX_QUEUES, GFP_KERNEL);
+					     IBMVNIC_MAX_QUEUES);
 	if (!adapter->rx_stats_buffers)
 		return -ENOMEM;
 
···
 		}
 
 		rx_pool->rx_buff = kzalloc_objs(struct ibmvnic_rx_buff,
-						rx_pool->size, GFP_KERNEL);
+						rx_pool->size);
 		if (!rx_pool->rx_buff) {
 			dev_err(dev, "Couldn't alloc rx buffers\n");
 			rc = -ENOMEM;
···
 	}
 
 	adapter->tx_scrq = kzalloc_objs(*adapter->tx_scrq,
-					adapter->req_tx_queues, GFP_KERNEL);
+					adapter->req_tx_queues);
 	if (!adapter->tx_scrq)
 		goto tx_failed;
 
···
 	}
 
 	adapter->rx_scrq = kzalloc_objs(*adapter->rx_scrq,
-					adapter->req_rx_queues, GFP_KERNEL);
+					adapter->req_rx_queues);
 	if (!adapter->rx_scrq)
 		goto rx_failed;
 

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

···
 static int e1000_alloc_queues(struct e1000_adapter *adapter)
 {
 	adapter->tx_ring = kzalloc_objs(struct e1000_tx_ring,
-					adapter->num_tx_queues, GFP_KERNEL);
+					adapter->num_tx_queues);
 	if (!adapter->tx_ring)
 		return -ENOMEM;
 
 	adapter->rx_ring = kzalloc_objs(struct e1000_rx_ring,
-					adapter->num_rx_queues, GFP_KERNEL);
+					adapter->num_rx_queues);
 	if (!adapter->rx_ring) {
 		kfree(adapter->tx_ring);
 		return -ENOMEM;

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

···
 		if (adapter->flags & FLAG_HAS_MSIX) {
 			adapter->num_vectors = 3; /* RxQ0, TxQ0 and other */
 			adapter->msix_entries = kzalloc_objs(struct msix_entry,
-							     adapter->num_vectors,
-							     GFP_KERNEL);
+							     adapter->num_vectors);
 			if (adapter->msix_entries) {
 				struct e1000_adapter *a = adapter;
 
···
 	for (i = 0; i < rx_ring->count; i++) {
 		buffer_info = &rx_ring->buffer_info[i];
 		buffer_info->ps_pages = kzalloc_objs(struct e1000_ps_page,
-						     PS_PAGE_BUFFERS,
-						     GFP_KERNEL);
+						     PS_PAGE_BUFFERS);
 		if (!buffer_info->ps_pages)
 			goto err_pages;
 	}

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

···
 	u32 v_idx, i, reg_idx, reg;
 
 	ldev->qvlist_info = kzalloc_flex(*ldev->qvlist_info, qv_info,
-					 qvlist_info->num_vectors, GFP_KERNEL);
+					 qvlist_info->num_vectors);
 	if (!ldev->qvlist_info)
 		return -ENOMEM;
 	ldev->qvlist_info->num_vectors = qvlist_info->num_vectors;

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

···
 			    "Changing Rx descriptor count from %d to %d\n",
 			    vsi->rx_rings[0]->count, new_rx_count);
 		rx_rings = kzalloc_objs(struct i40e_ring,
-					vsi->alloc_queue_pairs, GFP_KERNEL);
+					vsi->alloc_queue_pairs);
 		if (!rx_rings) {
 			err = -ENOMEM;
 			goto free_tx;

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

···
 	pf->ptp_caps.n_per_out = 2;
 
 	pf->ptp_caps.pin_config = kzalloc_objs(*pf->ptp_caps.pin_config,
-					       pf->ptp_caps.n_pins, GFP_KERNEL);
+					       pf->ptp_caps.n_pins);
 	if (!pf->ptp_caps.pin_config)
 		return -ENOMEM;
 

drivers/net/ethernet/intel/ice/devlink/port.c

···
 	int status;
 
 	options = kzalloc_objs(*options,
-			       ICE_AQC_PORT_OPT_MAX * ICE_MAX_PORT_PER_PCI_DEV,
-			       GFP_KERNEL);
+			       ICE_AQC_PORT_OPT_MAX * ICE_MAX_PORT_PER_PCI_DEV);
 	if (!options)
 		return;
 

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

···
 {
 	if (pool_present) {
 		rx_ring->xdp_buf = kzalloc_objs(*rx_ring->xdp_buf,
-						rx_ring->count, GFP_KERNEL);
+						rx_ring->count);
 		if (!rx_ring->xdp_buf)
 			return -ENOMEM;
 	} else {

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

···
 
 	privd->mapped_mem_regions =
 		kzalloc_objs(struct iidc_rdma_lan_mapped_mem_region,
-			     adapter->hw.num_lan_regs, GFP_KERNEL);
+			     adapter->hw.num_lan_regs);
 	if (!privd->mapped_mem_regions) {
 		err = -ENOMEM;
 		goto err_plug_aux_dev;

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

···
 		}
 
 		adapter->rdma_msix_entries = kzalloc_objs(struct msix_entry,
-							  num_rdma_vecs,
-							  GFP_KERNEL);
+							  num_rdma_vecs);
 		if (!adapter->rdma_msix_entries) {
 			err = -ENOMEM;
 			goto free_irq;

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

···
 		goto config;
 
 	q_vector->xsksq = kzalloc_objs(*q_vector->xsksq,
-				       DIV_ROUND_UP(rsrc->num_rxq_grp, rsrc->num_q_vectors),
-				       GFP_KERNEL);
+				       DIV_ROUND_UP(rsrc->num_rxq_grp, rsrc->num_q_vectors));
 	if (!q_vector->xsksq)
 		return -ENOMEM;
 
···
 			continue;
 
 		tx_qgrp->complq = kzalloc_objs(*tx_qgrp->complq,
-					       IDPF_COMPLQ_PER_GROUP,
-					       GFP_KERNEL);
+					       IDPF_COMPLQ_PER_GROUP);
 		if (!tx_qgrp->complq)
 			goto err_alloc;
 
···
 		}
 
 		rx_qgrp->splitq.bufq_sets = kzalloc_objs(struct idpf_bufq_set,
-							 rsrc->num_bufqs_per_qgrp,
-							 GFP_KERNEL);
+							 rsrc->num_bufqs_per_qgrp);
 		if (!rx_qgrp->splitq.bufq_sets) {
 			err = -ENOMEM;
 			goto err_alloc;
···
 				idpf_queue_set(GEN_CHK, refillq);
 				idpf_queue_set(RFL_GEN_CHK, refillq);
 				refillq->ring = kzalloc_objs(*refillq->ring,
-							     refillq->desc_count,
-							     GFP_KERNEL);
+							     refillq->desc_count);
 				if (!refillq->ring) {
 					err = -ENOMEM;
 					goto err_alloc;
···
 	user_config = &vport->adapter->vport_config[idx]->user_config;
 
 	rsrc->q_vectors = kzalloc_objs(struct idpf_q_vector,
-				       rsrc->num_q_vectors, GFP_KERNEL);
+				       rsrc->num_q_vectors);
 	if (!rsrc->q_vectors)
 		return -ENOMEM;
 
···
 			goto error;
 
 		q_vector->complq = kzalloc_objs(*q_vector->complq,
-						complqs_per_vector, GFP_KERNEL);
+						complqs_per_vector);
 		if (!q_vector->complq)
 			goto error;
 
···
 			continue;
 
 		q_vector->xsksq = kzalloc_objs(*q_vector->xsksq,
-					       rxqs_per_vector, GFP_KERNEL);
+					       rxqs_per_vector);
 		if (!q_vector->xsksq)
 			goto error;
 	}

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

···
 	u16 num_max_vports = idpf_get_max_vports(adapter);
 
 	adapter->vport_params_reqd = kzalloc_objs(*adapter->vport_params_reqd,
-						  num_max_vports, GFP_KERNEL);
+						  num_max_vports);
 	if (!adapter->vport_params_reqd)
 		return -ENOMEM;
 
 	adapter->vport_params_recvd = kzalloc_objs(*adapter->vport_params_recvd,
-						   num_max_vports, GFP_KERNEL);
+						   num_max_vports);
 	if (!adapter->vport_params_recvd)
 		goto err_mem;
 
···
 		return 0;
 
 	adapter->vport_config = kzalloc_objs(*adapter->vport_config,
-					     num_max_vports, GFP_KERNEL);
+					     num_max_vports);
 	if (!adapter->vport_config)
 		goto err_mem;
 
···
 
 	if (!adapter->netdevs) {
 		adapter->netdevs = kzalloc_objs(struct net_device *,
-						num_max_vports, GFP_KERNEL);
+						num_max_vports);
 		if (!adapter->netdevs) {
 			err = -ENOMEM;
 			goto err_netdev_alloc;

drivers/net/ethernet/intel/igb/igb_main.c

···
 		adapter->vfs_allocated_count = num_vfs;
 
 	adapter->vf_data = kzalloc_objs(struct vf_data_storage,
-					adapter->vfs_allocated_count,
-					GFP_KERNEL);
+					adapter->vfs_allocated_count);
 
 	/* if allocation failed then we do not support SR-IOV */
 	if (!adapter->vf_data) {
···
 			      adapter->vfs_allocated_count);
 
 	adapter->vf_mac_list = kzalloc_objs(struct vf_mac_filter,
-					    num_vf_mac_filters, GFP_KERNEL);
+					    num_vf_mac_filters);
 
 	mac_list = adapter->vf_mac_list;
 	INIT_LIST_HEAD(&adapter->vf_macs.l);
···
 	adapter->flags |= IGB_FLAG_HAS_MSIX;
 
 	adapter->mac_table = kzalloc_objs(struct igb_mac_addr,
-					  hw->mac.rar_entry_count, GFP_KERNEL);
+					  hw->mac.rar_entry_count);
 	if (!adapter->mac_table)
 		return -ENOMEM;
 

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

···
 		adapter->jump_tables[i] = NULL;
 
 	adapter->mac_table = kzalloc_objs(struct ixgbe_mac_addr,
-					  hw->mac.num_rar_entries, GFP_KERNEL);
+					  hw->mac.num_rar_entries);
 	if (!adapter->mac_table)
 		return -ENOMEM;
 

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

···
 			return status;
 
 		fwlog->ring.rings = kzalloc_objs(*fwlog->ring.rings,
-						 LIBIE_FWLOG_RING_SIZE_DFLT,
-						 GFP_KERNEL);
+						 LIBIE_FWLOG_RING_SIZE_DFLT);
 		if (!fwlog->ring.rings) {
 			dev_warn(&fwlog->pdev->dev, "Unable to allocate memory for FW log rings\n");
 			return -ENOMEM;

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

···
 		goto err_free_mem;
 
 	qset->sq = kzalloc_objs(struct otx2_snd_queue,
-				otx2_get_total_tx_queues(pf), GFP_KERNEL);
+				otx2_get_total_tx_queues(pf));
 	if (!qset->sq)
 		goto err_free_mem;
 

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

···
 		return -ENOMEM;
 
 	trap_data->trap_items_arr = kzalloc_objs(struct prestera_trap_item,
-						 traps_count, GFP_KERNEL);
+						 traps_count);
 	if (!trap_data->trap_items_arr) {
 		err = -ENOMEM;
 		goto err_trap_items_alloc;

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

···
 
 		priv->mfunc.master.vf_admin =
 			kzalloc_objs(struct mlx4_vf_admin_state,
-				     dev->num_slaves, GFP_KERNEL);
+				     dev->num_slaves);
 		if (!priv->mfunc.master.vf_admin)
 			goto err_comm_admin;
 
···
 	int err = 0;
 
 	priv->cmd.context = kmalloc_objs(struct mlx4_cmd_context,
-					 priv->cmd.max_cmds, GFP_KERNEL);
+					 priv->cmd.max_cmds);
 	if (!priv->cmd.context)
 		return -ENOMEM;
 

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

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

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

···
 	struct mlx4_priv *priv = mlx4_priv(dev);
 
 	priv->eq_table.eq = kzalloc_objs(*priv->eq_table.eq,
-					 dev->caps.num_eqs - dev->caps.reserved_eqs,
-					 GFP_KERNEL);
+					 dev->caps.num_eqs - dev->caps.reserved_eqs);
 	if (!priv->eq_table.eq)
 		return -ENOMEM;
 
···
 	int i;
 
 	priv->eq_table.uar_map = kzalloc_objs(*priv->eq_table.uar_map,
-					      mlx4_num_eq_uar(dev), GFP_KERNEL);
+					      mlx4_num_eq_uar(dev));
 	if (!priv->eq_table.uar_map) {
 		err = -ENOMEM;
 		goto err_out_free;

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

···
 		return priv->adev_idx;
 
 	priv->adev = kzalloc_objs(struct mlx4_adev *,
-				  ARRAY_SIZE(mlx4_adev_devices), GFP_KERNEL);
+				  ARRAY_SIZE(mlx4_adev_devices));
 	if (!priv->adev) {
 		ida_free(&mlx4_adev_ida, priv->adev_idx);
 		return -ENOMEM;

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

···
 		/* In mfunc, calculate proxy and tunnel qp offsets for the PF here,
 		 * since the PF does not call mlx4_slave_caps */
 		dev->caps.spec_qps = kzalloc_objs(*dev->caps.spec_qps,
-						  dev->caps.num_ports,
-						  GFP_KERNEL);
+						  dev->caps.num_ports);
 		if (!dev->caps.spec_qps) {
 			err = -ENOMEM;
 			goto err_mem;

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

···
 			&priv->mfunc.master.res_tracker.res_alloc[i];
 		res_alloc->quota = kmalloc_objs(int, dev->persist->num_vfs + 1);
 		res_alloc->guaranteed = kmalloc_objs(int,
-						     dev->persist->num_vfs + 1,
-						     GFP_KERNEL);
+						     dev->persist->num_vfs + 1);
 		if (i == RES_MAC || i == RES_VLAN)
 			res_alloc->allocated =
 				kzalloc_objs(int,
-					     MLX4_MAX_PORTS * (dev->persist->num_vfs + 1),
-					     GFP_KERNEL);
+					     MLX4_MAX_PORTS * (dev->persist->num_vfs + 1));
 		else
 			res_alloc->allocated =
 				kzalloc_objs(int, dev->persist->num_vfs + 1);

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

···
 	struct mlx5_priv *priv = &dev->priv;
 
 	priv->adev = kzalloc_objs(struct mlx5_adev *,
-				  ARRAY_SIZE(mlx5_adev_devices), GFP_KERNEL);
+				  ARRAY_SIZE(mlx5_adev_devices));
 	if (!priv->adev)
 		return -ENOMEM;
 

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

···
 		struct mlx5e_sq_stats **stats_list;
 
 		stats_list = kvzalloc_objs(*stats_list,
-					   mlx5e_qos_max_leaf_nodes(priv->mdev),
-					   GFP_KERNEL);
+					   mlx5e_qos_max_leaf_nodes(priv->mdev));
 		if (!stats_list)
 			return -ENOMEM;
 

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

···
 	u32 rate_limit_elem_ix;
 
 	vport->qos.sched_nodes = kzalloc_objs(struct mlx5_esw_sched_node *,
-					      num_tcs, GFP_KERNEL);
+					      num_tcs);
 	if (!vport->qos.sched_nodes) {
 		NL_SET_ERR_MSG_MOD(extack,
 				   "Allocating the vport TC scheduling elements failed.");

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

···
 
 	steering->rdma_transport_rx_root_ns =
 			kzalloc_objs(*steering->rdma_transport_rx_root_ns,
-				     total_vports, GFP_KERNEL);
+				     total_vports);
 	if (!steering->rdma_transport_rx_root_ns)
 		return -ENOMEM;
 
···
 
 	steering->rdma_transport_tx_root_ns =
 			kzalloc_objs(*steering->rdma_transport_tx_root_ns,
-				     total_vports, GFP_KERNEL);
+				     total_vports);
 	if (!steering->rdma_transport_tx_root_ns)
 		return -ENOMEM;
 
···
 	int err;
 
 	steering->fdb_sub_ns = kzalloc_objs(*steering->fdb_sub_ns,
-					    FDB_NUM_CHAINS, GFP_KERNEL);
+					    FDB_NUM_CHAINS);
 	if (!steering->fdb_sub_ns)
 		return -ENOMEM;
 

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

···
 	hwmon->module_scount = mon_cap ? 1 : 0;
 	sensors_count = hwmon->asic_platform_scount + hwmon->module_scount;
 	hwmon->temp_channel_desc = kzalloc_objs(*hwmon->temp_channel_desc,
-						sensors_count, GFP_KERNEL);
+						sensors_count);
 	if (!hwmon->temp_channel_desc) {
 		err = -ENOMEM;
 		goto err_free_hwmon;

drivers/net/ethernet/mellanox/mlx5/core/lib/clock.c

···
 
 	clock->ptp_info.pin_config =
 			kzalloc_objs(*clock->ptp_info.pin_config,
-				     clock->ptp_info.n_pins, GFP_KERNEL);
+				     clock->ptp_info.n_pins);
 	if (!clock->ptp_info.pin_config)
 		return;
 	clock->ptp_info.enable = mlx5_ptp_enable;

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

···
 
 	bwc_matcher->size_of_at_array = MLX5HWS_BWC_MATCHER_ATTACH_AT_NUM;
 	bwc_matcher->at = kzalloc_objs(*bwc_matcher->at,
-				       bwc_matcher->size_of_at_array,
-				       GFP_KERNEL);
+				       bwc_matcher->size_of_at_array);
 	if (!bwc_matcher->at)
 		goto free_bwc_matcher_rules;
 

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

···
 	queue->used_entries = 0;
 
 	queue->completed.entries = kzalloc_objs(queue->completed.entries[0],
-						queue->num_entries, GFP_KERNEL);
+						queue->num_entries);
 	if (!queue->completed.entries)
 		return -ENOMEM;
 
···
 	ctx->queues += bwc_queues;
 
 	ctx->bwc_send_queue_locks = kzalloc_objs(*ctx->bwc_send_queue_locks,
-						 bwc_queues, GFP_KERNEL);
+						 bwc_queues);
 
 	if (!ctx->bwc_send_queue_locks)
 		return -ENOMEM;
 
 	ctx->bwc_lock_class_keys = kzalloc_objs(*ctx->bwc_lock_class_keys,
-						bwc_queues, GFP_KERNEL);
+						bwc_queues);
 	if (!ctx->bwc_lock_class_keys)
 		goto err_lock_class_keys;
 

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

···
 	pool->th = max_hot_size;
 
 	pool->hot_chunks_arr = kvzalloc_objs(struct mlx5dr_icm_hot_chunk,
-					     num_of_chunks, GFP_KERNEL);
+					     num_of_chunks);
 	if (!pool->hot_chunks_arr)
 		goto free_pool;
 

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

···
 	}
 
 	fs_dr_actions = kzalloc_objs(*fs_dr_actions,
-				     MLX5_FLOW_CONTEXT_ACTION_MAX, GFP_KERNEL);
+				     MLX5_FLOW_CONTEXT_ACTION_MAX);
 	if (!fs_dr_actions) {
 		err = -ENOMEM;
 		goto free_actions_alloc;

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

···
 		mlxsw_core->max_ports = MLXSW_PORT_MAX_PORTS_DEFAULT + 1;
 
 	mlxsw_core->ports = kzalloc_objs(struct mlxsw_core_port,
-					 mlxsw_core->max_ports, GFP_KERNEL);
+					 mlxsw_core->max_ports);
 	if (!mlxsw_core->ports)
 		return -ENOMEM;
 

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

···
 	for (i = 0; i < env->num_of_slots; i++) {
 		env->line_cards[i] = kzalloc_flex(*env->line_cards[i],
 						  module_info,
-						  env->max_module_count,
-						  GFP_KERNEL);
+						  env->max_module_count);
 		if (!env->line_cards[i])
 			goto kzalloc_err;
 

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

···
 	}
 
 	types_info->ini_files = kmalloc_objs(struct mlxsw_linecard_ini_file *,
-					     types_info->count, GFP_KERNEL);
+					     types_info->count);
 	if (!types_info->ini_files) {
 		err = -ENOMEM;
 		goto err_ini_files_alloc;

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

···
 		return 0;
 
 	area->tz_module_arr = kzalloc_objs(*area->tz_module_arr,
-					   area->tz_module_num, GFP_KERNEL);
+					   area->tz_module_num);
 	if (!area->tz_module_arr)
 		return -ENOMEM;
 
···
 
 	area->tz_gearbox_num = gbox_num;
 	area->tz_gearbox_arr = kzalloc_objs(*area->tz_gearbox_arr,
-					    area->tz_gearbox_num, GFP_KERNEL);
+					    area->tz_gearbox_num);
 	if (!area->tz_gearbox_arr)
 		return -ENOMEM;
 

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

···
 		return -ENOMEM;
 
 	mlxsw_m->line_cards = kzalloc_objs(*mlxsw_m->line_cards,
-					   mlxsw_m->num_of_slots, GFP_KERNEL);
+					   mlxsw_m->num_of_slots);
 	if (!mlxsw_m->line_cards) {
 		err = -ENOMEM;
 		goto err_kcalloc;
···
 	for (i = 0; i < mlxsw_m->num_of_slots; i++) {
 		mlxsw_m->line_cards[i] =
 			kzalloc_flex(*mlxsw_m->line_cards[i], module_to_port,
-				     mlxsw_m->max_modules_per_slot, GFP_KERNEL);
+				     mlxsw_m->max_modules_per_slot);
 		if (!mlxsw_m->line_cards[i]) {
 			err = -ENOMEM;
 			goto err_kmalloc_array;

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

···
 	int err;
 
 	mlxsw_sp->port_mapping = kzalloc_objs(struct mlxsw_sp_port_mapping,
-					      max_ports, GFP_KERNEL);
+					      max_ports);
 	if (!mlxsw_sp->port_mapping)
 		return -ENOMEM;
 

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

···
 	mr_tcam_region->parman = parman;
 
 	parman_prios = kmalloc_objs(*parman_prios,
-				    MLXSW_SP_MR_ROUTE_PRIO_MAX + 1, GFP_KERNEL);
+				    MLXSW_SP_MR_ROUTE_PRIO_MAX + 1);
 	if (!parman_prios) {
 		err = -ENOMEM;
 		goto err_parman_prios_alloc;

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

···
 
 	if (ops->num_classes) {
 		mlxsw_sp_qdisc->qdiscs = kzalloc_objs(*mlxsw_sp_qdisc->qdiscs,
-						      ops->num_classes,
-						      GFP_KERNEL);
+						      ops->num_classes);
 		if (!mlxsw_sp_qdisc->qdiscs)
 			return -ENOMEM;
 

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

···
 	max_trees = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_LPM_TREES);
 	mlxsw_sp->router->lpm.tree_count = max_trees - MLXSW_SP_LPM_TREE_MIN;
 	mlxsw_sp->router->lpm.trees = kzalloc_objs(struct mlxsw_sp_lpm_tree,
-						   mlxsw_sp->router->lpm.tree_count,
-						   GFP_KERNEL);
+						   mlxsw_sp->router->lpm.tree_count);
 	if (!mlxsw_sp->router->lpm.trees)
 		return -ENOMEM;
 

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

···
 	nfp_prog = env->prog->aux->offload->dev_priv;
 	nfp_prog->subprog_cnt = env->subprog_cnt;
 	nfp_prog->subprog = kzalloc_objs(nfp_prog->subprog[0],
-					 nfp_prog->subprog_cnt, GFP_KERNEL);
+					 nfp_prog->subprog_cnt);
 	if (!nfp_prog->subprog)
 		return -ENOMEM;
 

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

···
 	/* Init timestamps for mask id*/
 	priv->mask_ids.last_used =
 		kmalloc_objs(*priv->mask_ids.last_used,
-			     NFP_FLOWER_MASK_ENTRY_RS, GFP_KERNEL);
+			     NFP_FLOWER_MASK_ENTRY_RS);
 	if (!priv->mask_ids.last_used)
 		goto err_free_mask_id;
 

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

···
 		goto alloc_err;
 
 	qm_info->qm_pq_params = kzalloc_objs(*qm_info->qm_pq_params,
-					     qed_init_qm_get_num_pqs(p_hwfn),
-					     GFP_KERNEL);
+					     qed_init_qm_get_num_pqs(p_hwfn));
 	if (!qm_info->qm_pq_params)
 		goto alloc_err;
 
 	qm_info->qm_vport_params = kzalloc_objs(*qm_info->qm_vport_params,
-						qed_init_qm_get_num_vports(p_hwfn),
-						GFP_KERNEL);
+						qed_init_qm_get_num_vports(p_hwfn));
 	if (!qm_info->qm_vport_params)
 		goto alloc_err;
 
 	qm_info->qm_port_params = kzalloc_objs(*qm_info->qm_port_params,
-					       p_hwfn->cdev->num_ports_in_engine,
-					       GFP_KERNEL);
+					       p_hwfn->cdev->num_ports_in_engine);
 	if (!qm_info->qm_port_params)
 		goto alloc_err;
 
 	qm_info->wfq_data = kzalloc_objs(*qm_info->wfq_data,
-					 qed_init_qm_get_num_vports(p_hwfn),
-					 GFP_KERNEL);
+					 qed_init_qm_get_num_vports(p_hwfn));
 	if (!qm_info->wfq_data)
 		goto alloc_err;
 

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

···
 		goto err;
 
 	iwarp_info->partial_fpdus = kzalloc_objs(*iwarp_info->partial_fpdus,
-						 (u16)p_hwfn->p_rdma_info->num_qps,
-						 GFP_KERNEL);
+						 (u16)p_hwfn->p_rdma_info->num_qps);
 	if (!iwarp_info->partial_fpdus) {
 		rc = -ENOMEM;
 		goto err;
···
 	 * we allocate enough to take care of all rx packets
 	 */
 	iwarp_info->mpa_bufs = kzalloc_objs(*iwarp_info->mpa_bufs,
-					    data.input.rx_num_desc, GFP_KERNEL);
+					    data.input.rx_num_desc);
 	if (!iwarp_info->mpa_bufs) {
 		rc = -ENOMEM;
 		goto err;

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

···
 
 	/* Allocate LL2's set struct */
 	p_ll2_connections = kzalloc_objs(struct qed_ll2_info,
-					 QED_MAX_NUM_OF_LL2_CONNECTIONS,
-					 GFP_KERNEL);
+					 QED_MAX_NUM_OF_LL2_CONNECTIONS);
 	if (!p_ll2_connections) {
 		DP_NOTICE(p_hwfn, "Failed to allocate `struct qed_ll2'\n");
 		return -ENOMEM;

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

···
 	}
 
 	nvm_info.image_att = kmalloc_objs(struct bist_nvm_image_att,
-					  nvm_info.num_images, GFP_KERNEL);
+					  nvm_info.num_images);
 	if (!nvm_info.image_att) {
 		rc = -ENOMEM;
 		goto err0;

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

···
 	INIT_LIST_HEAD(&p_ooo_info->free_isles_list);
 
 	p_ooo_info->p_isles_mem = kzalloc_objs(struct qed_ooo_isle,
-					       max_num_isles, GFP_KERNEL);
+					       max_num_isles);
 	if (!p_ooo_info->p_isles_mem)
 		goto no_isles_mem;
 
···
 
 	p_ooo_info->p_archipelagos_mem =
 				kzalloc_objs(struct qed_ooo_archipelago,
-					     max_num_archipelagos, GFP_KERNEL);
+					     max_num_archipelagos);
 	if (!p_ooo_info->p_archipelagos_mem)
 		goto no_archipelagos_mem;
 
···
 
 	p_ooo_info->ooo_history.p_cqes =
 				kzalloc_objs(struct ooo_opaque,
-					     QED_MAX_NUM_OOO_HISTORY_ENTRIES,
-					     GFP_KERNEL);
+					     QED_MAX_NUM_OOO_HISTORY_ENTRIES);
 	if (!p_ooo_info->ooo_history.p_cqes)
 		goto no_history_mem;
 

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

···
 
 	if (!edev->coal_entry) {
 		edev->coal_entry = kzalloc_objs(*edev->coal_entry,
-						QEDE_MAX_RSS_CNT(edev),
-						GFP_KERNEL);
+						QEDE_MAX_RSS_CNT(edev));
 		if (!edev->coal_entry) {
 			DP_ERR(edev, "coalesce entry allocation failed\n");
 			goto err;

drivers/net/ethernet/qlogic/qla3xxx.c

···
 		qdev->lrg_buf_q_alloc_size = qdev->lrg_buf_q_size * 2;
 
 	qdev->lrg_buf = kmalloc_objs(struct ql_rcv_buf_cb,
-				     qdev->num_large_buffers, GFP_KERNEL);
+				     qdev->num_large_buffers);
 	if (qdev->lrg_buf == NULL)
 		return -ENOMEM;
 

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

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

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

···
 
 	if (!adapter->msix_entries) {
 		adapter->msix_entries = kzalloc_objs(struct msix_entry,
-						     num_msix, GFP_KERNEL);
+						     num_msix);
 		if (!adapter->msix_entries)
 			return -ENOMEM;
 	}
···
 
 	if (!adapter->msix_entries) {
 		adapter->msix_entries = kzalloc_objs(struct msix_entry,
-						     num_msix, GFP_KERNEL);
+						     num_msix);
 		if (!adapter->msix_entries)
 			return -ENOMEM;
 	}
···
 	}
 
 	adapter->eswitch = kzalloc_objs(struct qlcnic_eswitch,
-					QLCNIC_NIU_MAX_XG_PORTS, GFP_KERNEL);
+					QLCNIC_NIU_MAX_XG_PORTS);
 	if (!adapter->eswitch) {
 		ret = -ENOMEM;
 		goto err_npars;
···
 	struct qlcnic_cmd_buffer *cmd_buf_arr;
 
 	tx_ring = kzalloc_objs(struct qlcnic_host_tx_ring,
-			       adapter->drv_tx_rings, GFP_KERNEL);
+			       adapter->drv_tx_rings);
 	if (tx_ring == NULL)
 		return -ENOMEM;
 

drivers/net/ethernet/renesas/ravb_main.c

···
 
 	/* Allocate RX buffers */
 	priv->rx_buffers[q] = kzalloc_objs(*priv->rx_buffers[q],
-					   priv->num_rx_ring[q], GFP_KERNEL);
+					   priv->num_rx_ring[q]);
 	if (!priv->rx_buffers[q])
 		goto error;
 

drivers/net/ethernet/sfc/efx_channels.c

···
 
 		/* Allocate array for XDP TX queue lookup. */
 		efx->xdp_tx_queues = kzalloc_objs(*efx->xdp_tx_queues,
-						  efx->xdp_tx_queue_count,
-						  GFP_KERNEL);
+						  efx->xdp_tx_queue_count);
 		if (!efx->xdp_tx_queues)
 			return -ENOMEM;
 	}

drivers/net/ethernet/sfc/efx_common.c

···
 	spin_lock_init(&efx->rps_hash_lock);
 	/* Failure to allocate is not fatal, but may degrade ARFS performance */
 	efx->rps_hash_table = kzalloc_objs(*efx->rps_hash_table,
-					   EFX_ARFS_HASH_TABLE_SIZE, GFP_KERNEL);
+					   EFX_ARFS_HASH_TABLE_SIZE);
 #endif
 	spin_lock_init(&efx->vf_reps_lock);
 	INIT_LIST_HEAD(&efx->vf_reps);

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

···
 		return -ENOMEM;
 
 	tx_queue->cb_page = kzalloc_objs(tx_queue->cb_page[0],
-					 ef4_tx_cb_page_count(tx_queue),
-					 GFP_KERNEL);
+					 ef4_tx_cb_page_count(tx_queue));
 	if (!tx_queue->cb_page) {
 		rc = -ENOMEM;
 		goto fail1;

drivers/net/ethernet/sfc/mae.c

···
 			goto fail;
 		rc = -ENOMEM;
 		desc->keys = kzalloc_objs(struct efx_tc_table_field_fmt,
-					  desc->n_keys, GFP_KERNEL);
+					  desc->n_keys);
 		if (!desc->keys)
 			goto fail;
 		desc->resps = kzalloc_objs(struct efx_tc_table_field_fmt,
-					   desc->n_resps, GFP_KERNEL);
+					   desc->n_resps);
 		if (!desc->resps)
 			goto fail;
 	}

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

···
 
 		/* Allocate array for XDP TX queue lookup. */
 		efx->xdp_tx_queues = kzalloc_objs(*efx->xdp_tx_queues,
-						  efx->xdp_tx_queue_count,
-						  GFP_KERNEL);
+						  efx->xdp_tx_queue_count);
 		if (!efx->xdp_tx_queues)
 			return -ENOMEM;
 	}

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

···
 	spin_lock_init(&efx->rps_hash_lock);
 	/* Failure to allocate is not fatal, but may degrade ARFS performance */
 	efx->rps_hash_table = kzalloc_objs(*efx->rps_hash_table,
-					   EFX_ARFS_HASH_TABLE_SIZE, GFP_KERNEL);
+					   EFX_ARFS_HASH_TABLE_SIZE);
 #endif
 	efx->mdio.dev = net_dev;
 	INIT_WORK(&efx->mac_work, efx_mac_work);

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

···
 		return -ENOMEM;
 
 	tx_queue->cb_page = kzalloc_objs(tx_queue->cb_page[0],
-					 efx_tx_cb_page_count(tx_queue),
-					 GFP_KERNEL);
+					 efx_tx_cb_page_count(tx_queue));
 	if (!tx_queue->cb_page) {
 		rc = -ENOMEM;
 		goto fail1;

drivers/net/ethernet/sfc/tx_common.c

···
 		return -ENOMEM;
 
 	tx_queue->cb_page = kzalloc_objs(tx_queue->cb_page[0],
-					 efx_tx_cb_page_count(tx_queue),
-					 GFP_KERNEL);
+					 efx_tx_cb_page_count(tx_queue));
 	if (!tx_queue->cb_page) {
 		rc = -ENOMEM;
 		goto fail1;

drivers/net/ethernet/spacemit/k1_emac.c

···
 	struct platform_device *pdev = priv->pdev;
 
 	tx_ring->tx_desc_buf = kzalloc_objs(*tx_ring->tx_desc_buf,
-					    tx_ring->total_cnt, GFP_KERNEL);
+					    tx_ring->total_cnt);
 
 	if (!tx_ring->tx_desc_buf)
 		return -ENOMEM;
···
 	struct platform_device *pdev = priv->pdev;
 
 	rx_ring->rx_desc_buf = kzalloc_objs(*rx_ring->rx_desc_buf,
-					    rx_ring->total_cnt, GFP_KERNEL);
+					    rx_ring->total_cnt);
 	if (!rx_ring->rx_desc_buf)
 		return -ENOMEM;
 

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

···
 	tx_q->priv_data = priv;
 
 	tx_q->tx_skbuff_dma = kzalloc_objs(*tx_q->tx_skbuff_dma,
-					   dma_conf->dma_tx_size, GFP_KERNEL);
+					   dma_conf->dma_tx_size);
 	if (!tx_q->tx_skbuff_dma)
 		return -ENOMEM;
 

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

···
 
 	/* Array of descriptor data */
 	ring->desc_data_head = kzalloc_objs(struct xlgmac_desc_data,
-					    dma_desc_count, GFP_KERNEL);
+					    dma_desc_count);
 	if (!ring->desc_data_head)
 		return -ENOMEM;
 

drivers/net/ethernet/toshiba/ps3_gelic_wireless.c

···
 
 	/* allocate scan list */
 	wl->networks = kzalloc_objs(struct gelic_wl_scan_info,
-				    GELIC_WL_BSS_MAX_ENT, GFP_KERNEL);
+				    GELIC_WL_BSS_MAX_ENT);
 
 	if (!wl->networks)
 		goto fail_bss;

drivers/net/ethernet/via/via-velocity.c

···
 	int ret = -ENOMEM;
 
 	vptr->rx.info = kzalloc_objs(struct velocity_rd_info,
-				     vptr->options.numrx, GFP_KERNEL);
+				     vptr->options.numrx);
 	if (!vptr->rx.info)
 		goto out;
 
···
 	for (j = 0; j < vptr->tx.numq; j++) {
 
 		vptr->tx.infos[j] = kzalloc_objs(struct velocity_td_info,
-						 vptr->options.numtx,
-						 GFP_KERNEL);
+						 vptr->options.numtx);
 		if (!vptr->tx.infos[j])	{
 			while (--j >= 0)
 				kfree(vptr->tx.infos[j]);

drivers/net/ethernet/wangxun/libwx/wx_hw.c

···
 			WX_RSS_FIELD_IPV6 | WX_RSS_FIELD_IPV6_TCP;
 
 	wx->mac_table = kzalloc_objs(struct wx_mac_addr,
-				     wx->mac.num_rar_entries, GFP_KERNEL);
+				     wx->mac.num_rar_entries);
 	if (!wx->mac_table) {
 		wx_err(wx, "mac_table allocation failed\n");
 		kfree(wx->rss_key);

drivers/net/netdevsim/dev.c

···
 		return -ENOMEM;
 
 	nsim_trap_data->trap_items_arr = kzalloc_objs(struct nsim_trap_item,
-						      ARRAY_SIZE(nsim_traps_arr),
-						      GFP_KERNEL);
+						      ARRAY_SIZE(nsim_traps_arr));
 	if (!nsim_trap_data->trap_items_arr) {
 		err = -ENOMEM;
 		goto err_trap_data_free;

drivers/net/phy/dp83640.c

···
 		goto out;
 
 	clock->caps.pin_config = kzalloc_objs(struct ptp_pin_desc,
-					      DP83640_N_PINS, GFP_KERNEL);
+					      DP83640_N_PINS);
 	if (!clock->caps.pin_config) {
 		kfree(clock);
 		clock = NULL;

drivers/net/phy/phy_led_triggers.c

···
 		goto out_free_link;
 
 	phy->phy_led_triggers = kzalloc_objs(struct phy_led_trigger,
-					     phy->phy_num_led_triggers,
-					     GFP_KERNEL);
+					     phy->phy_num_led_triggers);
 	if (!phy->phy_led_triggers) {
 		err = -ENOMEM;
 		goto out_unreg_link;

drivers/net/pse-pd/pd692x0.c

···
 
 	pw_table = pd692x0_class_pw_table;
 	c33_pw_limit_ranges = kzalloc_objs(*c33_pw_limit_ranges,
-					   PD692X0_CLASS_PW_TABLE_SIZE,
-					   GFP_KERNEL);
+					   PD692X0_CLASS_PW_TABLE_SIZE);
 	if (!c33_pw_limit_ranges)
 		return -ENOMEM;
 

drivers/net/wireless/ath/ath11k/debugfs.c

···
 	dbr_dbg_data->num_ring_debug_entries = ATH11K_DEBUG_DBR_ENTRIES_MAX;
 	dbr_dbg_data->dbr_debug_idx = 0;
 	dbr_dbg_data->entries = kzalloc_objs(struct ath11k_dbg_dbr_entry,
-					     ATH11K_DEBUG_DBR_ENTRIES_MAX,
-					     GFP_KERNEL);
+					     ATH11K_DEBUG_DBR_ENTRIES_MAX);
 	if (!dbr_dbg_data->entries)
 		return -ENOMEM;
 

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

···
 
 	dp->num_bank_profiles = num_tcl_banks;
 	dp->bank_profiles = kmalloc_objs(struct ath12k_dp_tx_bank_profile,
-					 num_tcl_banks, GFP_KERNEL);
+					 num_tcl_banks);
 	if (!dp->bank_profiles)
 		return -ENOMEM;
 

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

···
 		ds, ah->desc_len, (unsigned long long)ah->desc_daddr);
 
 	bf = kzalloc_objs(struct ath5k_buf,
-			  1 + ATH_TXBUF + ATH_RXBUF + ATH_BCBUF, GFP_KERNEL);
+			  1 + ATH_TXBUF + ATH_RXBUF + ATH_BCBUF);
 	if (bf == NULL) {
 		ATH5K_ERR(ah, "can't allocate bufptr\n");
 		ret = -ENOMEM;

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

···
 		/* Allocate pd_curves for this cal pier */
 		chinfo[pier].pd_curves =
 			kzalloc_objs(struct ath5k_pdgain_info,
-				     AR5K_EEPROM_N_PD_CURVES, GFP_KERNEL);
+				     AR5K_EEPROM_N_PD_CURVES);
 
 		if (!chinfo[pier].pd_curves)
 			goto err_out;
···
 		/* Allocate pd_curves for this cal pier */
 		chinfo[pier].pd_curves =
 				kzalloc_objs(struct ath5k_pdgain_info,
-					     AR5K_EEPROM_N_PD_CURVES,
-					     GFP_KERNEL);
+					     AR5K_EEPROM_N_PD_CURVES);
 
 		if (!chinfo[pier].pd_curves)
 			goto err_out;
···
 		/* Allocate pd_curves for this cal pier */
 		chinfo[pier].pd_curves =
 				kzalloc_objs(struct ath5k_pdgain_info,
-					     AR5K_EEPROM_N_PD_CURVES,
-					     GFP_KERNEL);
+					     AR5K_EEPROM_N_PD_CURVES);
 
 		if (!chinfo[pier].pd_curves)
 			goto err_out;

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

···
 		return -ENODEV;
 
 	wil->dbg_data.data_arr = kzalloc_objs(struct wil_debugfs_iomem_data,
-					      dbg_off_count, GFP_KERNEL);
+					      dbg_off_count);
 	if (!wil->dbg_data.data_arr) {
 		debugfs_remove_recursive(dbg);
 		wil->debug = NULL;

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

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

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

···
 	if ((phy->type == B43legacy_PHYTYPE_B) ||
 	    (phy->type == B43legacy_PHYTYPE_G)) {
 		phy->_lo_pairs = kzalloc_objs(struct b43legacy_lopair,
-					      B43legacy_LO_COUNT, GFP_KERNEL);
+					      B43legacy_LO_COUNT);
 		if (!phy->_lo_pairs)
 			return -ENOMEM;
 	}

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

···
 	msgbuf->max_flowrings = if_msgbuf->max_flowrings;
 	msgbuf->flowring_dma_handle =
 		kzalloc_objs(*msgbuf->flowring_dma_handle,
-			     msgbuf->max_flowrings, GFP_KERNEL);
+			     msgbuf->max_flowrings);
 	if (!msgbuf->flowring_dma_handle)
 		goto fail;
 

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

···
 		bg_band->band = NL80211_BAND_2GHZ;
 		bg_band->n_channels = geo->bg_channels;
 		bg_band->channels = kzalloc_objs(struct ieee80211_channel,
-						 geo->bg_channels, GFP_KERNEL);
+						 geo->bg_channels);
 		if (!bg_band->channels) {
 			ipw2100_down(priv);
 			return -ENOMEM;
···
 	}
 
 	priv->tx_buffers = kmalloc_objs(struct ipw2100_tx_packet,
-					TX_PENDED_QUEUE_LENGTH, GFP_KERNEL);
+					TX_PENDED_QUEUE_LENGTH);
 	if (!priv->tx_buffers) {
 		bd_queue_free(priv, &priv->tx_queue);
 		return -ENOMEM;
···
 	 * allocate packets
 	 */
 	priv->rx_buffers = kmalloc_objs(struct ipw2100_rx_packet,
-					RX_QUEUE_LENGTH, GFP_KERNEL);
+					RX_QUEUE_LENGTH);
 	if (!priv->rx_buffers) {
 		IPW_DEBUG_INFO("can't allocate rx packet buffer table\n");
 

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

···
 		bg_band->band = NL80211_BAND_2GHZ;
 		bg_band->n_channels = geo->bg_channels;
 		bg_band->channels = kzalloc_objs(struct ieee80211_channel,
-						 geo->bg_channels, GFP_KERNEL);
+						 geo->bg_channels);
 		if (!bg_band->channels) {
 			rc = -ENOMEM;
 			goto out;
···
 		a_band->band = NL80211_BAND_5GHZ;
 		a_band->n_channels = geo->a_channels;
 		a_band->channels = kzalloc_objs(struct ieee80211_channel,
-						geo->a_channels, GFP_KERNEL);
+						geo->a_channels);
 		if (!a_band->channels) {
 			rc = -ENOMEM;
 			goto out;

drivers/net/wireless/intel/iwlwifi/dvm/tt.c

···
 	if (priv->lib->adv_thermal_throttle) {
 		IWL_DEBUG_TEMP(priv, "Advanced Thermal Throttling\n");
 		tt->restriction = kzalloc_objs(struct iwl_tt_restriction,
-					       IWL_TI_STATE_MAX, GFP_KERNEL);
+					       IWL_TI_STATE_MAX);
 		tt->transaction = kzalloc_objs(struct iwl_tt_trans,
-					       IWL_TI_STATE_MAX * (IWL_TI_STATE_MAX - 1),
-					       GFP_KERNEL);
+					       IWL_TI_STATE_MAX * (IWL_TI_STATE_MAX - 1));
 		if (!tt->restriction || !tt->transaction) {
 			IWL_ERR(priv, "Fallback to Legacy Throttling\n");
 			priv->thermal_throttle.advanced_tt = false;

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

···
 	unsigned long ts = jiffies;
 
 	ll->pkts_counters = kzalloc_objs(*ll->pkts_counters,
-					 mld->trans->info.num_rxqs, GFP_KERNEL);
+					 mld->trans->info.num_rxqs);
 	if (!ll->pkts_counters)
 		return -ENOMEM;
 

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

···
 		}
 
 		mld->channel_survey = kzalloc_flex(*mld->channel_survey,
-						   channels, n_channels,
-						   GFP_KERNEL);
+						   channels, n_channels);
 
 		if (!mld->channel_survey)
 			return;

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

···
 		return;
 
 	mld_sta->mpdu_counters = kzalloc_objs(*mld_sta->mpdu_counters,
-				              mld->trans->info.num_rxqs,
-				              GFP_KERNEL);
+				              mld->trans->info.num_rxqs);
 	if (!mld_sta->mpdu_counters)
 		return;
 

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

···
 
 			WARN_ON(rcu_access_pointer(mvmsta->ptk_pn[keyidx]));
 			ptk_pn = kzalloc_flex(*ptk_pn, q,
-					      mvm->trans->info.num_rxqs,
-					      GFP_KERNEL);
+					      mvm->trans->info.num_rxqs);
 			if (!ptk_pn) {
 				ret = -ENOMEM;
 				break;

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

···
 		}
 
 		mvm->acs_survey = kzalloc_flex(*mvm->acs_survey, channels,
-					       n_channels, GFP_KERNEL);
+					       n_channels);
 
 		if (!mvm->acs_survey)
 			return;

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

···
 
 	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);
+					   RX_POOL_SIZE(trans_pcie->num_rx_bufs));
 	trans_pcie->global_table =
 		kzalloc_objs(trans_pcie->global_table[0],
-			     RX_POOL_SIZE(trans_pcie->num_rx_bufs), GFP_KERNEL);
+			     RX_POOL_SIZE(trans_pcie->num_rx_bufs));
 	if (!trans_pcie->rxq || !trans_pcie->rx_pool ||
 	    !trans_pcie->global_table) {
 		ret = -ENOMEM;

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

···
 
 	trans_pcie->txq_memory =
 		kzalloc_objs(struct iwl_txq,
-			     trans->mac_cfg->base->num_of_queues, GFP_KERNEL);
+			     trans->mac_cfg->base->num_of_queues);
 	if (!trans_pcie->txq_memory) {
 		IWL_ERR(trans, "Not enough memory for txq\n");
 		ret = -ENOMEM;

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

···
 		goto err_out;
 
 	tmp->channels = kzalloc_objs(struct ieee80211_channel,
-				     list->band_channel_num[band], GFP_KERNEL);
+				     list->band_channel_num[band]);
 	if (!tmp->channels)
 		goto err_out;
 

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

···
 	 */
 	adapter->num_in_chan_stats = 2 * (n_channels_bg + n_channels_a);
 	adapter->chan_stats = kzalloc_objs(*adapter->chan_stats,
-					   adapter->num_in_chan_stats,
-					   GFP_KERNEL);
+					   adapter->num_in_chan_stats);
 
 	if (!adapter->chan_stats)
 		return -ENOMEM;

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

···
 
 	/* Allocate and initialize struct cmd_ctrl_node */
 	cmd_array = kzalloc_objs(struct cmd_ctrl_node,
-				 MWIFIEX_NUM_OF_CMD_BUFFER, GFP_KERNEL);
+				 MWIFIEX_NUM_OF_CMD_BUFFER);
 	if (!cmd_array)
 		return -ENOMEM;
 

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

···
 	}
 
 	scan_chan_list = kzalloc_objs(struct mwifiex_chan_scan_param_set,
-				      MWIFIEX_USER_SCAN_CHAN_MAX, GFP_KERNEL);
+				      MWIFIEX_USER_SCAN_CHAN_MAX);
 	if (!scan_chan_list) {
 		kfree(scan_cfg_out);
 		ret = -ENOMEM;

drivers/net/wireless/quantenna/qtnfmac/commands.c

···
 
 	mac_info->n_if_comb = resp_info->n_iface_combinations;
 	mac_info->if_comb = kzalloc_objs(*mac->macinfo.if_comb,
-					 mac->macinfo.n_if_comb, GFP_KERNEL);
+					 mac->macinfo.n_if_comb);
 
 	if (!mac->macinfo.if_comb)
 		return -ENOMEM;

drivers/nvme/host/fc.c

···
 
 	ret = -ENOMEM;
 	ctrl->queues = kzalloc_objs(struct nvme_fc_queue,
-				    ctrl->ctrl.queue_count, GFP_KERNEL);
+				    ctrl->ctrl.queue_count);
 	if (!ctrl->queues)
 		goto out_free_ida;
 

drivers/nvme/target/pci-epf.c

···
 static int nvmet_pci_epf_alloc_irq_vectors(struct nvmet_pci_epf_ctrl *ctrl)
 {
 	ctrl->irq_vectors = kzalloc_objs(struct nvmet_pci_epf_irq_vector,
-					 ctrl->nr_queues, GFP_KERNEL);
+					 ctrl->nr_queues);
 	if (!ctrl->irq_vectors)
 		return -ENOMEM;
 

drivers/parisc/iosapic.c

···
 	DBG_IRT("iosapic_register: num vectors = %d\n", isi->isi_num_vectors);
 
 	vip = isi->isi_vector = kzalloc_objs(struct vector_info,
-					     isi->isi_num_vectors, GFP_KERNEL);
+					     isi->isi_num_vectors);
 	if (vip == NULL) {
 		kfree(isi);
 		return NULL;

drivers/platform/x86/amd/wbrf.c

···
 	num_of_elements = 2 * num_of_ranges + 2;
 
 	union acpi_object *tmp __free(kfree) = kzalloc_objs(*tmp,
-							    num_of_elements,
-							    GFP_KERNEL);
+							    num_of_elements);
 	if (!tmp)
 		return -ENOMEM;
 

drivers/platform/x86/dell/dell-wmi-base.c

···
 	}
 
 	keymap = kzalloc_objs(struct key_entry,
-			      dmi_results.keymap_size + ARRAY_SIZE(dell_wmi_keymap_type_0000) + ARRAY_SIZE(dell_wmi_keymap_type_0010) + ARRAY_SIZE(dell_wmi_keymap_type_0011) + ARRAY_SIZE(dell_wmi_keymap_type_0012) + 1,
-			      GFP_KERNEL);
+			      dmi_results.keymap_size + ARRAY_SIZE(dell_wmi_keymap_type_0000) + ARRAY_SIZE(dell_wmi_keymap_type_0010) + ARRAY_SIZE(dell_wmi_keymap_type_0011) + ARRAY_SIZE(dell_wmi_keymap_type_0012) + 1);
 	if (!keymap) {
 		kfree(dmi_results.keymap);
 		err = -ENOMEM;

drivers/platform/x86/dell/dell-wmi-privacy.c

···
 
 	/* remap the wmi keymap event to new keymap */
 	keymap = kzalloc_objs(struct key_entry,
-			      ARRAY_SIZE(dell_wmi_keymap_type_0012), GFP_KERNEL);
+			      ARRAY_SIZE(dell_wmi_keymap_type_0012));
 	if (!keymap)
 		return -ENOMEM;
 

drivers/platform/x86/dell/dell-wmi-sysman/enum-attributes.c

···
 	wmi_priv.enumeration_instances_count =
 		get_instance_count(DELL_WMI_BIOS_ENUMERATION_ATTRIBUTE_GUID);
 	wmi_priv.enumeration_data = kzalloc_objs(struct enumeration_data,
-						 wmi_priv.enumeration_instances_count,
-						 GFP_KERNEL);
+						 wmi_priv.enumeration_instances_count);
 	if (!wmi_priv.enumeration_data) {
 		wmi_priv.enumeration_instances_count = 0;
 		ret = -ENOMEM;

drivers/platform/x86/dell/dell-wmi-sysman/int-attributes.c

···
 
 	wmi_priv.integer_instances_count = get_instance_count(DELL_WMI_BIOS_INTEGER_ATTRIBUTE_GUID);
 	wmi_priv.integer_data = kzalloc_objs(struct integer_data,
-					     wmi_priv.integer_instances_count,
-					     GFP_KERNEL);
+					     wmi_priv.integer_instances_count);
 	if (!wmi_priv.integer_data) {
 		wmi_priv.integer_instances_count = 0;
 		ret = -ENOMEM;

drivers/platform/x86/dell/dell-wmi-sysman/passobj-attributes.c

···
 
 	wmi_priv.po_instances_count = get_instance_count(DELL_WMI_BIOS_PASSOBJ_ATTRIBUTE_GUID);
 	wmi_priv.po_data = kzalloc_objs(struct po_data,
-					wmi_priv.po_instances_count, GFP_KERNEL);
+					wmi_priv.po_instances_count);
 	if (!wmi_priv.po_data) {
 		wmi_priv.po_instances_count = 0;
 		ret = -ENOMEM;

drivers/platform/x86/dell/dell-wmi-sysman/string-attributes.c

···
 
 	wmi_priv.str_instances_count = get_instance_count(DELL_WMI_BIOS_STRING_ATTRIBUTE_GUID);
 	wmi_priv.str_data = kzalloc_objs(struct str_data,
-					 wmi_priv.str_instances_count,
-					 GFP_KERNEL);
+					 wmi_priv.str_instances_count);
 	if (!wmi_priv.str_data) {
 		wmi_priv.str_instances_count = 0;
 		ret = -ENOMEM;

drivers/platform/x86/hp/hp-bioscfg/enum-attributes.c

···
 		hp_get_instance_count(HP_WMI_BIOS_ENUMERATION_GUID);
 
 	bioscfg_drv.enumeration_data = kzalloc_objs(*bioscfg_drv.enumeration_data,
-						    bioscfg_drv.enumeration_instances_count,
-						    GFP_KERNEL);
+						    bioscfg_drv.enumeration_instances_count);
 	if (!bioscfg_drv.enumeration_data) {
 		bioscfg_drv.enumeration_instances_count = 0;
 		return -ENOMEM;

drivers/platform/x86/hp/hp-bioscfg/int-attributes.c

···
 {
 	bioscfg_drv.integer_instances_count = hp_get_instance_count(HP_WMI_BIOS_INTEGER_GUID);
 	bioscfg_drv.integer_data = kzalloc_objs(*bioscfg_drv.integer_data,
-						bioscfg_drv.integer_instances_count,
-						GFP_KERNEL);
+						bioscfg_drv.integer_instances_count);
 
 	if (!bioscfg_drv.integer_data) {
 		bioscfg_drv.integer_instances_count = 0;

drivers/platform/x86/hp/hp-bioscfg/order-list-attributes.c

···
 	bioscfg_drv.ordered_list_instances_count =
 		hp_get_instance_count(HP_WMI_BIOS_ORDERED_LIST_GUID);
 	bioscfg_drv.ordered_list_data = kzalloc_objs(*bioscfg_drv.ordered_list_data,
-						     bioscfg_drv.ordered_list_instances_count,
-						     GFP_KERNEL);
+						     bioscfg_drv.ordered_list_instances_count);
 	if (!bioscfg_drv.ordered_list_data) {
 		bioscfg_drv.ordered_list_instances_count = 0;
 		return -ENOMEM;

drivers/platform/x86/hp/hp-bioscfg/passwdobj-attributes.c

···
 {
 	bioscfg_drv.password_instances_count = hp_get_instance_count(HP_WMI_BIOS_PASSWORD_GUID);
 	bioscfg_drv.password_data = kzalloc_objs(*bioscfg_drv.password_data,
-						 bioscfg_drv.password_instances_count,
-						 GFP_KERNEL);
+						 bioscfg_drv.password_instances_count);
 	if (!bioscfg_drv.password_data) {
 		bioscfg_drv.password_instances_count = 0;
 		return -ENOMEM;

drivers/platform/x86/hp/hp-bioscfg/string-attributes.c

···
 {
 	bioscfg_drv.string_instances_count = hp_get_instance_count(HP_WMI_BIOS_STRING_GUID);
 	bioscfg_drv.string_data = kzalloc_objs(*bioscfg_drv.string_data,
-					       bioscfg_drv.string_instances_count,
-					       GFP_KERNEL);
+					       bioscfg_drv.string_instances_count);
 	if (!bioscfg_drv.string_data) {
 		bioscfg_drv.string_instances_count = 0;
 		return -ENOMEM;

drivers/platform/x86/intel/int1092/intel_sar.c

···
 		return AE_ERROR;
 
 	data->device_mode_info = kmalloc_objs(struct wwan_device_mode_info,
-					      data->total_dev_mode, GFP_KERNEL);
+					      data->total_dev_mode);
 	if (!data->device_mode_info)
 		return AE_ERROR;
 

drivers/platform/x86/intel/speed_select_if/isst_tpmi_core.c

···
 	}
 
 	isst_common.sst_inst = kzalloc_objs(*isst_common.sst_inst,
-					    topology_max_packages(), GFP_KERNEL);
+					    topology_max_packages());
 	if (!isst_common.sst_inst) {
 		ret = -ENOMEM;
 		goto init_done;

drivers/platform/x86/intel/tpmi_power_domains.c

···
 		return ret;
 
 	tpmi_power_domain_mask = kzalloc_objs(*tpmi_power_domain_mask,
-					      size_mul(topology_max_packages(), MAX_POWER_DOMAINS),
-					      GFP_KERNEL);
+					      size_mul(topology_max_packages(), MAX_POWER_DOMAINS));
 	if (!tpmi_power_domain_mask)
 		return -ENOMEM;
 

drivers/platform/x86/uv_sysfs.c

···
 	}
 	for (j = 0; j < uv_bios_obj_cnt; j++) {
 		uv_hubs[j]->ports = kzalloc_objs(*uv_hubs[j]->ports,
-						 hub_buf[j].ports, GFP_KERNEL);
+						 hub_buf[j].ports);
 		if (!uv_hubs[j]->ports) {
 			ret = -ENOMEM;
 			j--;

drivers/powercap/powercap_sys.c

···
 	if (!power_zone->name)
 		goto err_name_alloc;
 	power_zone->constraints = kzalloc_objs(*power_zone->constraints,
-					       nr_constraints, GFP_KERNEL);
+					       nr_constraints);
 	if (!power_zone->constraints)
 		goto err_const_alloc;
 

drivers/resctrl/mpam_devices.c

···
 				continue;
 
 			mbwu_state = kzalloc_objs(*ris->mbwu_state,
-						  ris->props.num_mbwu_mon,
-						  GFP_KERNEL);
+						  ris->props.num_mbwu_mon);
 			if (!mbwu_state) {
 				__destroy_component_cfg(comp);
 				return -ENOMEM;

drivers/s390/crypto/zcrypt_api.c

···
 			* sizeof(struct zcrypt_device_status_ext);
 
 		device_status = kvzalloc_objs(struct zcrypt_device_status_ext,
-					      MAX_ZDEV_ENTRIES_EXT, GFP_KERNEL);
+					      MAX_ZDEV_ENTRIES_EXT);
 		if (!device_status)
 			return -ENOMEM;
 		zcrypt_device_status_mask_ext(device_status,

drivers/scsi/aacraid/aachba.c

···
 		fsa_dev_ptr = dev->fsa_dev;
 
 		dev->fsa_dev = kzalloc_objs(*fsa_dev_ptr,
-					    maximum_num_containers, GFP_KERNEL);
+					    maximum_num_containers);
 
 		kfree(fsa_dev_ptr);
 		fsa_dev_ptr = NULL;

drivers/scsi/be2iscsi/be_main.c

···
 	/* Allocate memory for wrb_context */
 	phwi_ctrlr = phba->phwi_ctrlr;
 	phwi_ctrlr->wrb_context = kzalloc_objs(struct hwi_wrb_context,
-					       phba->params.cxns_per_ctrl,
-					       GFP_KERNEL);
+					       phba->params.cxns_per_ctrl);
 	if (!phwi_ctrlr->wrb_context) {
 		kfree(phba->phwi_ctrlr);
 		return -ENOMEM;
···
 	/* Allocate memory for WRBQ */
 	phwi_ctxt = phwi_ctrlr->phwi_ctxt;
 	phwi_ctxt->be_wrbq = kzalloc_objs(struct be_queue_info,
-					  phba->params.cxns_per_ctrl,
-					  GFP_KERNEL);
+					  phba->params.cxns_per_ctrl);
 	if (!phwi_ctxt->be_wrbq) {
 		beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
 			    "BM_%d : WRBQ Mem Alloc Failed\n");
···
 		pwrb_context = &phwi_ctrlr->wrb_context[index];
 		pwrb_context->pwrb_handle_base =
 				kzalloc_objs(struct wrb_handle *,
-					     phba->params.wrbs_per_cxn,
-					     GFP_KERNEL);
+					     phba->params.wrbs_per_cxn);
 		if (!pwrb_context->pwrb_handle_base) {
 			beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
 				    "BM_%d : Mem Alloc Failed. Failing to load\n");
···
 		}
 		pwrb_context->pwrb_handle_basestd =
 				kzalloc_objs(struct wrb_handle *,
-					     phba->params.wrbs_per_cxn,
-					     GFP_KERNEL);
+					     phba->params.wrbs_per_cxn);
 		if (!pwrb_context->pwrb_handle_basestd) {
 			beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
 				    "BM_%d : Mem Alloc Failed. Failing to load\n");
···
 	mem_descr_sglh += HWI_MEM_SGLH;
 	if (1 == mem_descr_sglh->num_elements) {
 		phba->io_sgl_hndl_base = kzalloc_objs(struct sgl_handle *,
-						      phba->params.ios_per_ctrl,
-						      GFP_KERNEL);
+						      phba->params.ios_per_ctrl);
 		if (!phba->io_sgl_hndl_base) {
 			beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
 				    "BM_%d : Mem Alloc Failed. Failing to load\n");
···
 		}
 		phba->eh_sgl_hndl_base =
 			kzalloc_objs(struct sgl_handle *,
-				     phba->params.icds_per_ctrl - phba->params.ios_per_ctrl,
-				     GFP_KERNEL);
+				     phba->params.icds_per_ctrl - phba->params.ios_per_ctrl);
 		if (!phba->eh_sgl_hndl_base) {
 			kfree(phba->io_sgl_hndl_base);
 			beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
···
 		}
 	}
 	phba->ep_array = kzalloc_objs(struct iscsi_endpoint *,
-				      phba->params.cxns_per_ctrl, GFP_KERNEL);
+				      phba->params.cxns_per_ctrl);
 	if (!phba->ep_array) {
 		ret = -ENOMEM;
 
···
 	}
 
 	phba->conn_table = kzalloc_objs(struct beiscsi_conn *,
-					phba->params.cxns_per_ctrl, GFP_KERNEL);
+					phba->params.cxns_per_ctrl);
 	if (!phba->conn_table) {
 		kfree(phba->ep_array);
 		phba->ep_array = NULL;

drivers/scsi/csiostor/csio_wr.c

···
 
 			flq = wrm->q_arr[q->un.iq.flq_idx];
 			flq->un.fl.bufs = kzalloc_objs(struct csio_dma_buf,
-						       flq->credits, GFP_KERNEL);
+						       flq->credits);
 			if (!flq->un.fl.bufs) {
 				csio_err(hw,
 					 "Failed to allocate FL queue bufs"

drivers/scsi/esas2r/esas2r_init.c

···
 	/* allocate the request table */
 	a->req_table =
 		kzalloc_objs(struct esas2r_request *,
-			     num_requests + num_ae_requests + 1, GFP_KERNEL);
+			     num_requests + num_ae_requests + 1);
 
 	if (a->req_table == NULL) {
 		esas2r_log(ESAS2R_LOG_CRIT,

drivers/scsi/hpsa.c

···
 	for (i = 0; i < h->nr_cmds; i++) {
 		h->ioaccel2_cmd_sg_list[i] =
 			kmalloc_objs(*h->ioaccel2_cmd_sg_list[i],
-				     h->maxsgentries, GFP_KERNEL);
+				     h->maxsgentries);
 		if (!h->ioaccel2_cmd_sg_list[i])
 			goto clean;
 	}
···
 
 	for (i = 0; i < h->nr_cmds; i++) {
 		h->cmd_sg_list[i] = kmalloc_objs(*h->cmd_sg_list[i],
-						 h->chainsize, GFP_KERNEL);
+						 h->chainsize);
 		if (!h->cmd_sg_list[i])
 			goto clean;
 

drivers/scsi/ibmvscsi/ibmvfc.c

···
 		goto free_login_buffer;
 
 	vhost->trace = kzalloc_objs(struct ibmvfc_trace_entry,
-				    IBMVFC_NUM_TRACE_ENTRIES, GFP_KERNEL);
+				    IBMVFC_NUM_TRACE_ENTRIES);
 	atomic_set(&vhost->trace_index, -1);
 
 	if (!vhost->trace)

drivers/scsi/ipr.c

···
 		return -ENOMEM;
 
 	ioa_cfg->ipr_cmnd_list = kzalloc_objs(struct ipr_cmnd *,
-					      IPR_NUM_CMD_BLKS, GFP_KERNEL);
+					      IPR_NUM_CMD_BLKS);
 	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) {
···
 
 	ENTER;
 	ioa_cfg->res_entries = kzalloc_objs(struct ipr_resource_entry,
-					    ioa_cfg->max_devs_supported,
-					    GFP_KERNEL);
+					    ioa_cfg->max_devs_supported);
 
 	if (!ioa_cfg->res_entries)
 		goto out;
···
 	}
 
 	ioa_cfg->trace = kzalloc_objs(struct ipr_trace_entry,
-				      IPR_NUM_TRACE_ENTRIES, GFP_KERNEL);
+				      IPR_NUM_TRACE_ENTRIES);
 
 	if (!ioa_cfg->trace)
 		goto out_free_hostrcb_dma;

drivers/scsi/lpfc/lpfc_debugfs.c

···
 				    &lpfc_debugfs_op_slow_ring_trc);
 		if (!phba->slow_ring_trc) {
 			phba->slow_ring_trc = kzalloc_objs(struct lpfc_debugfs_trc,
-							   lpfc_debugfs_max_slow_ring_trc,
-							   GFP_KERNEL);
+							   lpfc_debugfs_max_slow_ring_trc);
 			if (!phba->slow_ring_trc) {
 				lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
 						 "0416 Cannot create debugfs "

drivers/scsi/lpfc/lpfc_init.c

···
 
 	if (!phba->sli.sli3_ring)
 		phba->sli.sli3_ring = kzalloc_objs(struct lpfc_sli_ring,
-						   LPFC_SLI3_MAX_RING,
-						   GFP_KERNEL);
+						   LPFC_SLI3_MAX_RING);
 	if (!phba->sli.sli3_ring)
 		return -ENOMEM;
 
···
 	}
 
 	phba->sli4_hba.hba_eq_hdl = kzalloc_objs(struct lpfc_hba_eq_hdl,
-						 phba->cfg_irq_chann,
-						 GFP_KERNEL);
+						 phba->cfg_irq_chann);
 	if (!phba->sli4_hba.hba_eq_hdl) {
 		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2572 Failed allocate memory for "
···
 	}
 
 	phba->sli4_hba.cpu_map = kzalloc_objs(struct lpfc_vector_map_info,
-					      phba->sli4_hba.num_possible_cpu,
-					      GFP_KERNEL);
+					      phba->sli4_hba.num_possible_cpu);
 	if (!phba->sli4_hba.cpu_map) {
 		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"3327 Failed allocate memory for msi-x "
···
 	}
 
 	phba->sli4_hba.idle_stat = kzalloc_objs(*phba->sli4_hba.idle_stat,
-						phba->sli4_hba.num_possible_cpu,
-						GFP_KERNEL);
+						phba->sli4_hba.num_possible_cpu);
 	if (!phba->sli4_hba.idle_stat) {
 		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"3390 Failed allocation for idle_stat\n");
···
 
 	if (!phba->sli4_hba.hdwq) {
 		phba->sli4_hba.hdwq = kzalloc_objs(struct lpfc_sli4_hdw_queue,
-						   phba->cfg_hdw_queue,
-						   GFP_KERNEL);
+						   phba->cfg_hdw_queue);
 		if (!phba->sli4_hba.hdwq) {
 			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"6427 Failed allocate memory for "
···
 	if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) {
 		if (phba->nvmet_support) {
 			phba->sli4_hba.nvmet_cqset = kzalloc_objs(struct lpfc_queue *,
-								  phba->cfg_nvmet_mrq,
-								  GFP_KERNEL);
+								  phba->cfg_nvmet_mrq);
 			if (!phba->sli4_hba.nvmet_cqset) {
 				lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"3121 Fail allocate memory for "
···
 				goto out_error;
 			}
 			phba->sli4_hba.nvmet_mrq_hdr = kzalloc_objs(struct lpfc_queue *,
-								    phba->cfg_nvmet_mrq,
-								    GFP_KERNEL);
+								    phba->cfg_nvmet_mrq);
 			if (!phba->sli4_hba.nvmet_mrq_hdr) {
 				lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"3122 Fail allocate memory for "
···
 				goto out_error;
 			}
 			phba->sli4_hba.nvmet_mrq_data = kzalloc_objs(struct lpfc_queue *,
-								     phba->cfg_nvmet_mrq,
-								     GFP_KERNEL);
+								     phba->cfg_nvmet_mrq);
 			if (!phba->sli4_hba.nvmet_mrq_data) {
 				lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"3124 Fail allocate memory for "
···
 	if (phba->sli4_hba.cq_max) {
 		kfree(phba->sli4_hba.cq_lookup);
 		phba->sli4_hba.cq_lookup = kzalloc_objs(struct lpfc_queue *,
-							(phba->sli4_hba.cq_max + 1),
-							GFP_KERNEL);
+							(phba->sli4_hba.cq_max + 1));
 		if (!phba->sli4_hba.cq_lookup) {
 			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"0549 Failed setup of CQ Lookup table: "

drivers/scsi/lpfc/lpfc_nvmet.c

···
 			phba->sli4_hba.nvmet_xri_cnt);
 
 	phba->sli4_hba.nvmet_ctx_info = kzalloc_objs(struct lpfc_nvmet_ctx_info,
-						     phba->sli4_hba.num_possible_cpu * phba->cfg_nvmet_mrq,
-						     GFP_KERNEL);
+						     phba->sli4_hba.num_possible_cpu * phba->cfg_nvmet_mrq);
 	if (!phba->sli4_hba.nvmet_ctx_info) {
 		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6419 Failed allocate memory for "

drivers/scsi/mac53c94.c

···
 	 * XXX FIXME: Use DMA consistent routines
 	 */
        	dma_cmd_space = kmalloc_objs(struct dbdma_cmd,
-					    host->sg_tablesize + 2, GFP_KERNEL);
+					    host->sg_tablesize + 2);
 	if (!dma_cmd_space) {
 		printk(KERN_ERR "mac53c94: couldn't allocate dma "
 		       "command space for %pOF\n", node);

drivers/scsi/megaraid/megaraid_sas_base.c

···
 	if (instance->adapter_type >= VENTURA_SERIES) {
 		fusion->stream_detect_by_ld =
 			kzalloc_objs(struct LD_STREAM_DETECT *,
-				     MAX_LOGICAL_DRIVES_EXT, GFP_KERNEL);
+				     MAX_LOGICAL_DRIVES_EXT);
 		if (!fusion->stream_detect_by_ld) {
 			dev_err(&instance->pdev->dev,
 				"unable to allocate stream detection for pool of LDs\n");

drivers/scsi/mpi3mr/mpi3mr_fw.c

···
 	    op_reply_q->segment_qd);
 
 	op_reply_q->q_segments = kzalloc_objs(struct segments,
-					      op_reply_q->num_segments,
-					      GFP_KERNEL);
+					      op_reply_q->num_segments);
 	if (!op_reply_q->q_segments)
 		return -ENOMEM;
 
···
 	    op_req_q->segment_qd);
 
 	op_req_q->q_segments = kzalloc_objs(struct segments,
-					    op_req_q->num_segments, GFP_KERNEL);
+					    op_req_q->num_segments);
 	if (!op_req_q->q_segments)
 		return -ENOMEM;
 

drivers/scsi/mpi3mr/mpi3mr_transport.c

···
 		goto out_fail;
 	}
 	sas_expander->phy = kzalloc_objs(struct mpi3mr_sas_phy,
-					 sas_expander->num_phys, GFP_KERNEL);
+					 sas_expander->num_phys);
 	if (!sas_expander->phy) {
 		rc = -1;
 		goto out_fail;

drivers/scsi/mpt3sas/mpt3sas_base.c

···
 
 	if (iopoll_q_count) {
 		ioc->io_uring_poll_queues = kzalloc_objs(struct io_uring_poll_queue,
-							 iopoll_q_count,
-							 GFP_KERNEL);
+							 iopoll_q_count);
 		if (!ioc->io_uring_poll_queues)
 			iopoll_q_count = 0;
 	}
···
 		 * MPT3_SUP_REPLY_POST_HOST_INDEX_REG_OFFSET from previous one.
 		 */
 		ioc->replyPostRegisterIndex = kzalloc_objs(resource_size_t *,
-							   ioc->combined_reply_index_count,
-							   GFP_KERNEL);
+							   ioc->combined_reply_index_count);
 		if (!ioc->replyPostRegisterIndex) {
 			ioc_err(ioc,
 			    "allocation for replyPostRegisterIndex failed!\n");
···
 
 	/* initialize hi-priority queue smid's */
 	ioc->hpr_lookup = kzalloc_objs(struct request_tracker,
-				       ioc->hi_priority_depth, GFP_KERNEL);
+				       ioc->hi_priority_depth);
 	if (!ioc->hpr_lookup) {
 		ioc_err(ioc, "hpr_lookup: kcalloc failed\n");
 		goto out;
···
 
 	/* initialize internal queue smid's */
 	ioc->internal_lookup = kzalloc_objs(struct request_tracker,
-					    ioc->internal_depth, GFP_KERNEL);
+					    ioc->internal_depth);
 	if (!ioc->internal_lookup) {
 		ioc_err(ioc, "internal_lookup: kcalloc failed\n");
 		goto out;
···
 
 	if (ioc->is_warpdrive) {
 		ioc->reply_post_host_index = kzalloc_objs(resource_size_t *,
-							  ioc->cpu_msix_table_sz,
-							  GFP_KERNEL);
+							  ioc->cpu_msix_table_sz);
 		if (!ioc->reply_post_host_index) {
 			ioc_info(ioc, "Allocation for reply_post_host_index failed!!!\n");
 			r = -ENOMEM;
···
 		goto out_free_resources;
 
 	ioc->pfacts = kzalloc_objs(struct mpt3sas_port_facts,
-				   ioc->facts.NumberOfPorts, GFP_KERNEL);
+				   ioc->facts.NumberOfPorts);
 	if (!ioc->pfacts) {
 		r = -ENOMEM;
 		goto out_free_resources;

drivers/scsi/mpt3sas/mpt3sas_ctl.c

···
 	ioc->event_context = 0;
 	ioc->aen_event_read_flag = 0;
 	ioc->event_log = kzalloc_objs(struct MPT3_IOCTL_EVENTS,
-				      MPT3SAS_CTL_EVENT_LOG_SIZE, GFP_KERNEL);
+				      MPT3SAS_CTL_EVENT_LOG_SIZE);
 	if (!ioc->event_log) {
 		pr_err("failure at %s:%d/%s()!\n",
 		    __FILE__, __LINE__, __func__);

drivers/scsi/mpt3sas/mpt3sas_scsih.c

···
 	ioc->sas_hba.nr_phys_allocated = max_t(u8,
 	    MPT_MAX_HBA_NUM_PHYS, num_phys);
 	ioc->sas_hba.phy = kzalloc_objs(struct _sas_phy,
-					ioc->sas_hba.nr_phys_allocated,
-					GFP_KERNEL);
+					ioc->sas_hba.nr_phys_allocated);
 	if (!ioc->sas_hba.phy) {
 		ioc_err(ioc, "failure at %s:%d/%s()!\n",
 			__FILE__, __LINE__, __func__);
···
 		goto out_fail;
 	}
 	sas_expander->phy = kzalloc_objs(struct _sas_phy,
-					 sas_expander->num_phys, GFP_KERNEL);
+					 sas_expander->num_phys);
 	if (!sas_expander->phy) {
 		ioc_err(ioc, "failure at %s:%d/%s()!\n",
 			__FILE__, __LINE__, __func__);

drivers/scsi/pmcraid.c

···
 
 	pinstance->res_entries =
 			kzalloc_objs(struct pmcraid_resource_entry,
-				     PMCRAID_MAX_RESOURCES, GFP_KERNEL);
+				     PMCRAID_MAX_RESOURCES);
 
 	if (NULL == pinstance->res_entries) {
 		pmcraid_err("failed to allocate memory for resource table\n");

drivers/scsi/qedi/qedi_main.c

···
 	int ret = 0;
 
 	qedi->fp_array = kzalloc_objs(struct qedi_fastpath,
-				      MIN_NUM_CPUS_MSIX(qedi), GFP_KERNEL);
+				      MIN_NUM_CPUS_MSIX(qedi));
 	if (!qedi->fp_array) {
 		QEDI_ERR(&qedi->dbg_ctx,
 			 "fastpath fp array allocation failed.\n");
···
 	}
 
 	qedi->sb_array = kzalloc_objs(struct qed_sb_info,
-				      MIN_NUM_CPUS_MSIX(qedi), GFP_KERNEL);
+				      MIN_NUM_CPUS_MSIX(qedi));
 	if (!qedi->sb_array) {
 		QEDI_ERR(&qedi->dbg_ctx,
 			 "fastpath sb array allocation failed.\n");
···
 		return -ENOMEM;
 
 	qedi->cid_que.conn_cid_tbl = kmalloc_objs(struct qedi_conn *,
-						  qedi->max_active_conns,
-						  GFP_KERNEL);
+						  qedi->max_active_conns);
 	if (!qedi->cid_que.conn_cid_tbl) {
 		kfree(qedi->cid_que.cid_que_base);
 		qedi->cid_que.cid_que_base = NULL;
···
 static int qedi_alloc_itt(struct qedi_ctx *qedi)
 {
 	qedi->itt_map = kzalloc_objs(struct qedi_itt_map,
-				     MAX_ISCSI_TASK_ENTRIES, GFP_KERNEL);
+				     MAX_ISCSI_TASK_ENTRIES);
 	if (!qedi->itt_map) {
 		QEDI_ERR(&qedi->dbg_ctx,
 			 "Unable to allocate itt map array memory\n");

drivers/scsi/qla2xxx/qla_init.c

···
 		 */
 		req->num_outstanding_cmds = MIN_OUTSTANDING_COMMANDS;
 		req->outstanding_cmds = kzalloc_objs(srb_t *,
-						     req->num_outstanding_cmds,
-						     GFP_KERNEL);
+						     req->num_outstanding_cmds);
 
 		if (!req->outstanding_cmds) {
 			ql_log(ql_log_fatal, NULL, 0x0126,

drivers/scsi/qla2xxx/qla_os.c

···
 
 	if ((ql2xmqsupport || ql2xnvmeenable) && ha->max_qpairs) {
 		ha->queue_pair_map = kzalloc_objs(struct qla_qpair *,
-						  ha->max_qpairs, GFP_KERNEL);
+						  ha->max_qpairs);
 		if (!ha->queue_pair_map) {
 			ql_log(ql_log_fatal, vha, 0x0180,
 			    "Unable to allocate memory for queue pair ptrs.\n");
···
 
 	if (QLA_TGT_MODE_ENABLED() || EDIF_CAP(ha)) {
 		ha->vp_map = kzalloc_objs(struct qla_vp_map,
-					  MAX_MULTI_ID_FABRIC, GFP_KERNEL);
+					  MAX_MULTI_ID_FABRIC);
 		if (!ha->vp_map)
 			goto fail;
 	}
···
 	/* Allocate memory for NVRAM data for vports */
 	if (ha->nvram_npiv_size) {
 		ha->npiv_info = kzalloc_objs(struct qla_npiv_entry,
-					     ha->nvram_npiv_size, GFP_KERNEL);
+					     ha->nvram_npiv_size);
 		if (!ha->npiv_info) {
 			ql_log_pci(ql_log_fatal, ha->pdev, 0x002d,
 			    "Failed to allocate memory for npiv_info.\n");

drivers/scsi/smartpqi/smartpqi_init.c

···
 	num_physicals = get_unaligned_be32(&rpl_8byte_wwid_list->header.list_length) / sizeof(rpl_8byte_wwid_list->lun_entries[0]);
 
 	rpl_16byte_wwid_list = kmalloc_flex(*rpl_16byte_wwid_list, lun_entries,
-					    num_physicals, GFP_KERNEL);
+					    num_physicals);
 	if (!rpl_16byte_wwid_list) {
 		rc = -ENOMEM;
 		goto out_free_rpl_list;
···
 	struct pqi_io_request *io_request;
 
 	ctrl_info->io_request_pool = kzalloc_objs(ctrl_info->io_request_pool[0],
-						  ctrl_info->max_io_slots,
-						  GFP_KERNEL);
+						  ctrl_info->max_io_slots);
 
 	if (!ctrl_info->io_request_pool) {
 		dev_err(&ctrl_info->pci_dev->dev,

drivers/soundwire/qcom.c

···
 	int maxport, pn, nports = 0;
 	unsigned int m_port;
 	struct sdw_port_config *pconfig __free(kfree) = kzalloc_objs(*pconfig,
-								     ctrl->nports,
-								     GFP_KERNEL);
+								     ctrl->nports);
 	if (!pconfig)
 		return -ENOMEM;
 

drivers/staging/greybus/power_supply.c

···
 	}
 
 	gbpsy->props_raw = kzalloc_objs(*gbpsy->props_raw,
-					gbpsy->properties_count, GFP_KERNEL);
+					gbpsy->properties_count);
 	if (!gbpsy->props_raw) {
 		ret = -ENOMEM;
 		goto out_put_operation;
···
 		goto out;
 
 	supplies->supply = kzalloc_objs(struct gb_power_supply,
-					supplies->supplies_count, GFP_KERNEL);
+					supplies->supplies_count);
 
 	if (!supplies->supply) {
 		ret = -ENOMEM;

drivers/staging/media/atomisp/pci/atomisp_csi2_bridge.c

···
 
 	/* Max num GPIOs we've seen plus a terminator */
 	int3472 = kzalloc_flex(*int3472, gpios.table,
-			       INT3472_MAX_SENSOR_GPIOS + 1, GFP_KERNEL);
+			       INT3472_MAX_SENSOR_GPIOS + 1);
 	if (!int3472)
 		return -ENOMEM;
 

drivers/staging/media/atomisp/pci/sh_css.c

···
 			return err;
 		mycs->num_yuv_scaler = cas_scaler_descr.num_stage;
 		mycs->yuv_scaler_binary = kzalloc_objs(struct ia_css_binary,
-						       cas_scaler_descr.num_stage,
-						       GFP_KERNEL);
+						       cas_scaler_descr.num_stage);
 		if (!mycs->yuv_scaler_binary) {
 			mycs->num_yuv_scaler = 0;
 			err = -ENOMEM;
 			return err;
 		}
 		mycs->is_output_stage = kzalloc_objs(bool,
-						     cas_scaler_descr.num_stage,
-						     GFP_KERNEL);
+						     cas_scaler_descr.num_stage);
 		if (!mycs->is_output_stage) {
 			err = -ENOMEM;
 			return err;
···
 		}
 		mycs->num_yuv_scaler = cas_scaler_descr.num_stage;
 		mycs->yuv_scaler_binary = kzalloc_objs(struct ia_css_binary,
-						       cas_scaler_descr.num_stage,
-						       GFP_KERNEL);
+						       cas_scaler_descr.num_stage);
 		if (!mycs->yuv_scaler_binary) {
 			err = -ENOMEM;
 			IA_CSS_LEAVE_ERR_PRIVATE(err);
 			return err;
 		}
 		mycs->is_output_stage = kzalloc_objs(bool,
-						     cas_scaler_descr.num_stage,
-						     GFP_KERNEL);
+						     cas_scaler_descr.num_stage);
 		if (!mycs->is_output_stage) {
 			err = -ENOMEM;
 			IA_CSS_LEAVE_ERR_PRIVATE(err);
···
 	descr->num_stage = num_stages;
 
 	descr->in_info = kmalloc_objs(struct ia_css_frame_info,
-				      descr->num_stage, GFP_KERNEL);
+				      descr->num_stage);
 	if (!descr->in_info) {
 		err = -ENOMEM;
 		goto ERR;
···
 		mycs->num_output = cas_scaler_descr.num_output_stage;
 		mycs->num_yuv_scaler = cas_scaler_descr.num_stage;
 		mycs->yuv_scaler_binary = kzalloc_objs(struct ia_css_binary,
-						       cas_scaler_descr.num_stage,
-						       GFP_KERNEL);
+						       cas_scaler_descr.num_stage);
 		if (!mycs->yuv_scaler_binary) {
 			err = -ENOMEM;
 			goto ERR;
 		}
 		mycs->is_output_stage = kzalloc_objs(bool,
-						     cas_scaler_descr.num_stage,
-						     GFP_KERNEL);
+						     cas_scaler_descr.num_stage);
 		if (!mycs->is_output_stage) {
 			err = -ENOMEM;
 			goto ERR;

drivers/tee/qcomtee/call.c

···
 
 	/* +1 for ending QCOMTEE_ARG_TYPE_INV. */
 	struct qcomtee_arg *u __free(kfree) = kzalloc_objs(*u,
-							   arg->num_params + 1,
-							   GFP_KERNEL);
+							   arg->num_params + 1);
 	if (!u)
 		return -ENOMEM;
 

drivers/thermal/cpufreq_cooling.c

···
 	unsigned int num_cpus = cpumask_weight(cpufreq_cdev->policy->related_cpus);
 
 	cpufreq_cdev->idle_time = kzalloc_objs(*cpufreq_cdev->idle_time,
-					       num_cpus, GFP_KERNEL);
+					       num_cpus);
 	if (!cpufreq_cdev->idle_time)
 		return -ENOMEM;
 

drivers/thermal/intel/int340x_thermal/int3400_thermal.c

···
 
 	if (priv->odvp_attrs == NULL) {
 		priv->odvp_attrs = kzalloc_objs(struct odvp_attr,
-						priv->odvp_count, GFP_KERNEL);
+						priv->odvp_count);
 		if (!priv->odvp_attrs) {
 			ret = -ENOMEM;
 			goto out_err;

drivers/thermal/intel/int340x_thermal/int340x_thermal_zone.c

···
 		int34x_zone->aux_trip_nr = trip_cnt;
 
 	zone_trips = kzalloc_objs(*zone_trips,
-				  trip_cnt + INT340X_THERMAL_MAX_TRIP_COUNT,
-				  GFP_KERNEL);
+				  trip_cnt + INT340X_THERMAL_MAX_TRIP_COUNT);
 	if (!zone_trips) {
 		ret = -ENOMEM;
 		goto err_trips_alloc;

drivers/thermal/testing/zone.c

···
 		return -EINVAL;
 
 	struct thermal_trip *trips __free(kfree) = kzalloc_objs(*trips,
-								tt_zone->num_trips,
-								GFP_KERNEL);
+								tt_zone->num_trips);
 	if (!trips)
 		return -ENOMEM;
 

drivers/tty/serial/sunsab.c

···
 
 	if (num_channels) {
 		sunsab_ports = kzalloc_objs(struct uart_sunsab_port,
-					    num_channels, GFP_KERNEL);
+					    num_channels);
 		if (!sunsab_ports)
 			return -ENOMEM;
 

drivers/usb/gadget/configfs.c

···
 	if (!nlangs)
 		return NULL;
 
-	gadget_strings = kzalloc_objs(struct usb_gadget_strings *, nlangs + 1,
-				      GFP_KERNEL)/* including NULL terminator */;
+	gadget_strings = kzalloc_objs(struct usb_gadget_strings *, nlangs + 1)/* including NULL terminator */;
 	if (!gadget_strings)
 		return ERR_PTR(-ENOMEM);
 
···
 		}
 
 		stringtab = kzalloc_objs(struct usb_string,
-					 language->nstrings + 1, GFP_KERNEL);
+					 language->nstrings + 1);
 		if (!stringtab) {
 			us = ERR_PTR(-ENOMEM);
 			goto cleanup;

drivers/usb/gadget/function/f_midi2.c

···
 	}
 
 	midi2->string_defs = kzalloc_objs(*midi2->string_defs,
-					  midi2->total_blocks + 1, GFP_KERNEL);
+					  midi2->total_blocks + 1);
 	if (!midi2->string_defs) {
 		do_f_midi2_free(midi2, opts);
 		return ERR_PTR(-ENOMEM);

drivers/usb/gadget/function/u_audio.c

···
 		prm->srate = params->c_srates[0];
 
 		prm->reqs = kzalloc_objs(struct usb_request *,
-					 params->req_number, GFP_KERNEL);
+					 params->req_number);
 		if (!prm->reqs) {
 			err = -ENOMEM;
 			goto fail;
···
 		prm->srate = params->p_srates[0];
 
 		prm->reqs = kzalloc_objs(struct usb_request *,
-					 params->req_number, GFP_KERNEL);
+					 params->req_number);
 		if (!prm->reqs) {
 			err = -ENOMEM;
 			goto fail;

drivers/usb/isp1760/isp1760-hcd.c

···
 	priv->hcd = hcd;
 
 	priv->atl_slots = kzalloc_objs(struct isp1760_slotinfo,
-				       mem_layout->slot_num, GFP_KERNEL);
+				       mem_layout->slot_num);
 	if (!priv->atl_slots) {
 		ret = -ENOMEM;
 		goto put_hcd;
 	}
 
 	priv->int_slots = kzalloc_objs(struct isp1760_slotinfo,
-				       mem_layout->slot_num, GFP_KERNEL);
+				       mem_layout->slot_num);
 	if (!priv->int_slots) {
 		ret = -ENOMEM;
 		goto free_atl_slots;

drivers/usb/storage/ene_ub6250.c

···
 					    info->MS_Lib.BytesPerSector,
 					    GFP_KERNEL);
 	info->MS_Lib.blkext = kmalloc_objs(struct ms_lib_type_extdat,
-					   info->MS_Lib.PagesPerBlock,
-					   GFP_KERNEL);
+					   info->MS_Lib.PagesPerBlock);
 
 	if ((info->MS_Lib.blkpag == NULL) || (info->MS_Lib.blkext == NULL)) {
 		ms_lib_free_writebuf(us);

drivers/vdpa/mlx5/net/mlx5_vnet.c

···
 		return;
 
 	ndev->irqp.entries = kzalloc_objs(*ndev->irqp.entries,
-					  ndev->mvdev.max_vqs, GFP_KERNEL);
+					  ndev->mvdev.max_vqs);
 	if (!ndev->irqp.entries)
 		return;
 

drivers/vdpa/vdpa_sim/vdpa_sim.c

···
 		goto err_iommu;
 
 	vdpasim->iommu_pt = kmalloc_objs(*vdpasim->iommu_pt,
-					 vdpasim->dev_attr.nas, GFP_KERNEL);
+					 vdpasim->dev_attr.nas);
 	if (!vdpasim->iommu_pt)
 		goto err_iommu;
 

drivers/vhost/scsi.c

···
 
 		if (vs->inline_sg_cnt) {
 			tv_cmd->sgl = kzalloc_objs(struct scatterlist,
-						   vs->inline_sg_cnt,
-						   GFP_KERNEL);
+						   vs->inline_sg_cnt);
 			if (!tv_cmd->sgl) {
 				pr_err("Unable to allocate tv_cmd->sgl\n");
 				goto out;
···
 		if (vhost_has_feature(vq, VIRTIO_SCSI_F_T10_PI) &&
 		    vs->inline_sg_cnt) {
 			tv_cmd->prot_sgl = kzalloc_objs(struct scatterlist,
-							vs->inline_sg_cnt,
-							GFP_KERNEL);
+							vs->inline_sg_cnt);
 			if (!tv_cmd->prot_sgl) {
 				pr_err("Unable to allocate tv_cmd->prot_sgl\n");
 				goto out;

drivers/virt/nitro_enclaves/ne_misc_dev.c

···
 	ne_cpu_pool.nr_parent_vm_cores = nr_cpu_ids / ne_cpu_pool.nr_threads_per_core;
 
 	ne_cpu_pool.avail_threads_per_core = kzalloc_objs(*ne_cpu_pool.avail_threads_per_core,
-							  ne_cpu_pool.nr_parent_vm_cores,
-							  GFP_KERNEL);
+							  ne_cpu_pool.nr_parent_vm_cores);
 	if (!ne_cpu_pool.avail_threads_per_core) {
 		rc = -ENOMEM;
 
···
 	}
 
 	phys_contig_mem_regions.regions = kzalloc_objs(*phys_contig_mem_regions.regions,
-						       max_nr_pages, GFP_KERNEL);
+						       max_nr_pages);
 	if (!phys_contig_mem_regions.regions) {
 		rc = -ENOMEM;
 
···
 	mutex_unlock(&ne_cpu_pool.mutex);
 
 	ne_enclave->threads_per_core = kzalloc_objs(*ne_enclave->threads_per_core,
-						    ne_enclave->nr_parent_vm_cores,
-						    GFP_KERNEL);
+						    ne_enclave->nr_parent_vm_cores);
 	if (!ne_enclave->threads_per_core) {
 		rc = -ENOMEM;
 

drivers/xen/events/events_base.c

···
 				  xen_evtchn_cpu_prepare, xen_evtchn_cpu_dead);
 
 	evtchn_to_irq = kzalloc_objs(*evtchn_to_irq,
-				     EVTCHN_ROW(xen_evtchn_max_channels()),
-				     GFP_KERNEL);
+				     EVTCHN_ROW(xen_evtchn_max_channels()));
 	BUG_ON(!evtchn_to_irq);
 
 	/* No event channels are 'live' right now. */

drivers/xen/gntdev-dmabuf.c

···
 		goto fail_no_free;
 
 	gntdev_dmabuf->u.imp.refs = kzalloc_objs(gntdev_dmabuf->u.imp.refs[0],
-						 count, GFP_KERNEL);
+						 count);
 	if (!gntdev_dmabuf->u.imp.refs)
 		goto fail;
 

drivers/xen/xen-acpi-processor.c

···
 		     sizeof(struct acpi_processor_px));
 
 	dst_states = kzalloc_objs(struct xen_processor_px,
-				  _pr->performance->state_count, GFP_KERNEL);
+				  _pr->performance->state_count);
 	if (!dst_states)
 		return ERR_PTR(-ENOMEM);
 

drivers/xen/xen-front-pgdir-shbuf.c

···
 		return -ENOMEM;
 
 	buf->backend_map_handles = kzalloc_objs(*buf->backend_map_handles,
-						buf->num_pages, GFP_KERNEL);
+						buf->num_pages);
 	if (!buf->backend_map_handles) {
 		kfree(map_ops);
 		return -ENOMEM;

fs/afs/cmservice.c

···
 
 		_debug("unmarshall FID array");
 		call->request = kzalloc_objs(struct afs_callback_break,
-					     call->count, GFP_KERNEL);
+					     call->count);
 		if (!call->request)
 			return -ENOMEM;
 
···
 
 		_debug("unmarshall FID array");
 		call->request = kzalloc_objs(struct afs_callback_break,
-					     call->count, GFP_KERNEL);
+					     call->count);
 		if (!call->request)
 			return -ENOMEM;
 

fs/afs/dir.c

···
 	/* Need space for examining all the selected files */
 	if (op->nr_files > 2) {
 		op->more_files = kvzalloc_objs(struct afs_vnode_param,
-					       op->nr_files - 2, GFP_KERNEL);
+					       op->nr_files - 2);
 		if (!op->more_files) {
 			afs_op_nomem(op);
 			goto out_op;

fs/afs/rotate.c

···
 	read_unlock(&op->volume->servers_lock);
 
 	op->server_states = kzalloc_objs(op->server_states[0],
-					 op->server_list->nr_servers,
-					 GFP_KERNEL);
+					 op->server_list->nr_servers);
 	if (!op->server_states) {
 		afs_op_nomem(op);
 		trace_afs_rotate(op, afs_rotate_trace_nomem, 0);

fs/btrfs/fiemap.c

···
 
 	cache.entries_size = PAGE_SIZE / sizeof(struct btrfs_fiemap_entry);
 	cache.entries = kmalloc_objs(struct btrfs_fiemap_entry,
-				     cache.entries_size, GFP_KERNEL);
+				     cache.entries_size);
 	backref_ctx = btrfs_alloc_backref_share_check_ctx();
 	path = btrfs_alloc_path();
 	if (!cache.entries || !backref_ctx || !path) {

fs/btrfs/scrub.c

···
 		goto error;
 
 	stripe->sectors = kzalloc_objs(struct scrub_sector_verification,
-				       stripe->nr_sectors, GFP_KERNEL);
+				       stripe->nr_sectors);
 	if (!stripe->sectors)
 		goto error;
 
···
 		ASSERT(sctx->raid56_data_stripes == NULL);
 
 		sctx->raid56_data_stripes = kzalloc_objs(struct scrub_stripe,
-							 nr_data_stripes(map),
-							 GFP_KERNEL);
+							 nr_data_stripes(map));
 		if (!sctx->raid56_data_stripes) {
 			ret = -ENOMEM;
 			goto out;

fs/btrfs/send.c

···
 		}
 		send_buf_num_pages = sctx->send_max_size >> PAGE_SHIFT;
 		sctx->send_buf_pages = kzalloc_objs(*sctx->send_buf_pages,
-						    send_buf_num_pages,
-						    GFP_KERNEL);
+						    send_buf_num_pages);
 		if (!sctx->send_buf_pages) {
 			ret = -ENOMEM;
 			goto out;
···
 	}
 
 	sctx->clone_roots = kvzalloc_objs(*sctx->clone_roots,
-					  arg->clone_sources_count + 1,
-					  GFP_KERNEL);
+					  arg->clone_sources_count + 1);
 	if (!sctx->clone_roots) {
 		ret = -ENOMEM;
 		goto out;

fs/ceph/mds_client.c

···
 		}
 
 		cap_auths = kzalloc_objs(struct ceph_mds_cap_auth,
-					 cap_auths_num, GFP_KERNEL);
+					 cap_auths_num);
 		if (!cap_auths) {
 			pr_err_client(cl, "No memory for cap_auths\n");
 			return;

fs/erofs/zutil.c

···
 	if (z_erofs_rsv_nrpages) {
 		z_erofs_rsvbuf = &z_erofs_gbufpool[total - 1];
 		z_erofs_rsvbuf->pages = kzalloc_objs(*z_erofs_rsvbuf->pages,
-						     z_erofs_rsv_nrpages,
-						     GFP_KERNEL);
+						     z_erofs_rsv_nrpages);
 		if (!z_erofs_rsvbuf->pages) {
 			z_erofs_rsvbuf = NULL;
 			z_erofs_rsv_nrpages = 0;

fs/ext4/mballoc.c

···
 	sbi->s_mb_nr_global_goals = umin(num_possible_cpus(),
 					 DIV_ROUND_UP(sbi->s_groups_count, 4));
 	sbi->s_mb_last_groups = kzalloc_objs(ext4_group_t,
-					     sbi->s_mb_nr_global_goals,
-					     GFP_KERNEL);
+					     sbi->s_mb_nr_global_goals);
 	if (sbi->s_mb_last_groups == NULL) {
 		ret = -ENOMEM;
 		goto out;

fs/isofs/compress.c

···
 		pcount = 1;
 	}
 	pages = kzalloc_objs(*pages,
-			     max_t(unsigned int, zisofs_pages_per_cblock, 1),
-			     GFP_KERNEL);
+			     max_t(unsigned int, zisofs_pages_per_cblock, 1));
 	if (!pages) {
 		folio_unlock(folio);
 		return -ENOMEM;

fs/jffs2/fs.c

···
 
 	c->inocache_hashsize = calculate_inocache_hashsize(c->flash_size);
 	c->inocache_list = kzalloc_objs(struct jffs2_inode_cache *,
-					c->inocache_hashsize, GFP_KERNEL);
+					c->inocache_hashsize);
 	if (!c->inocache_list) {
 		ret = -ENOMEM;
 		goto out_wbuf;

fs/nfs/callback_xdr.c

···
 		if (unlikely(p == NULL))
 			goto out;
 		rc_list->rcl_refcalls = kmalloc_objs(*rc_list->rcl_refcalls,
-						     rc_list->rcl_nrefcalls,
-						     GFP_KERNEL);
+						     rc_list->rcl_nrefcalls);
 		if (unlikely(rc_list->rcl_refcalls == NULL))
 			goto out;
 		for (i = 0; i < rc_list->rcl_nrefcalls; i++) {
···
 	args->csa_rclists = NULL;
 	if (args->csa_nrclists) {
 		args->csa_rclists = kmalloc_objs(*args->csa_rclists,
-						 args->csa_nrclists, GFP_KERNEL);
+						 args->csa_nrclists);
 		if (unlikely(args->csa_rclists == NULL))
 			return htonl(NFS4ERR_RESOURCE);
 

fs/nfs/delegation.c

···
 	delegation_buckets = roundup_pow_of_two(nfs_delegation_watermark / 16);
 	server->delegation_hash_mask = delegation_buckets - 1;
 	server->delegation_hash_table = kmalloc_objs(*server->delegation_hash_table,
-						     delegation_buckets,
-						     GFP_KERNEL);
+						     delegation_buckets);
 	if (!server->delegation_hash_table)
 		return -ENOMEM;
 	for (i = 0; i < delegation_buckets; i++)

fs/nfsd/export.c

···
 		return 0;
 
 	fsloc->locations = kzalloc_objs(struct nfsd4_fs_location,
-					fsloc->locations_count, GFP_KERNEL);
+					fsloc->locations_count);
 	if (!fsloc->locations)
 		return -ENOMEM;
 	for (i=0; i < fsloc->locations_count; i++) {

fs/nfsd/nfs4recover.c

···
 	int i;
 
 	nn->reclaim_str_hashtbl = kmalloc_objs(struct list_head,
-					       CLIENT_HASH_SIZE, GFP_KERNEL);
+					       CLIENT_HASH_SIZE);
 	if (!nn->reclaim_str_hashtbl)
 		return -ENOMEM;
 
···
 	int i;
 
 	nn->reclaim_str_hashtbl = kmalloc_objs(struct list_head,
-					       CLIENT_HASH_SIZE, GFP_KERNEL);
+					       CLIENT_HASH_SIZE);
 	if (!nn->reclaim_str_hashtbl)
 		return -ENOMEM;
 

fs/nfsd/nfs4state.c

···
 	if (clp->cl_name.data == NULL)
 		goto err_no_name;
 	clp->cl_ownerstr_hashtbl = kmalloc_objs(struct list_head,
-						OWNER_HASH_SIZE, GFP_KERNEL);
+						OWNER_HASH_SIZE);
 	if (!clp->cl_ownerstr_hashtbl)
 		goto err_no_hashtbl;
 	clp->cl_callback_wq = alloc_ordered_workqueue("nfsd4_callbacks", 0);
···
 	if (!nn->unconf_id_hashtbl)
 		goto err_unconf_id;
 	nn->sessionid_hashtbl = kmalloc_objs(struct list_head,
-					     SESSION_HASH_SIZE, GFP_KERNEL);
+					     SESSION_HASH_SIZE);
 	if (!nn->sessionid_hashtbl)
 		goto err_sessionid;
 

fs/pstore/ram_core.c

···
 
 	/* allocate workspace instead of using stack VLA */
 	prz->ecc_info.par = kmalloc_objs(*prz->ecc_info.par,
-					 prz->ecc_info.ecc_size, GFP_KERNEL);
+					 prz->ecc_info.ecc_size);
 	if (!prz->ecc_info.par) {
 		pr_err("cannot allocate ECC parity workspace\n");
 		return -ENOMEM;

fs/smb/client/smbdirect.c

···
 		}
 
 		mr->sgt.sgl = kzalloc_objs(struct scatterlist,
-					   sp->max_frmr_depth, GFP_KERNEL);
+					   sp->max_frmr_depth);
 		if (!mr->sgt.sgl) {
 			ret = -ENOMEM;
 			log_rdma_mr(ERR, "failed to allocate sgl\n");

fs/squashfs/file.c

···
 		 * if a 'large' file is read.
 		 */
 		msblk->meta_index = kzalloc_objs(*(msblk->meta_index),
-						 SQUASHFS_META_SLOTS,
-						 GFP_KERNEL);
+						 SQUASHFS_META_SLOTS);
 		if (msblk->meta_index == NULL) {
 			ERROR("Failed to allocate meta_index\n");
 			goto failed;

fs/udf/super.c

···
 	data.size_part_descs = PART_DESC_ALLOC_STEP;
 	data.num_part_descs = 0;
 	data.part_descs_loc = kzalloc_objs(*data.part_descs_loc,
-					   data.size_part_descs, GFP_KERNEL);
+					   data.size_part_descs);
 	if (!data.part_descs_loc)
 		return -ENOMEM;
 

kernel/bpf/syscall.c

···
 		}
 
 	used_maps_new = kmalloc_objs(used_maps_new[0],
-				     prog->aux->used_map_cnt + 1, GFP_KERNEL);
+				     prog->aux->used_map_cnt + 1);
 	if (!used_maps_new) {
 		ret = -ENOMEM;
 		goto out_unlock;

kernel/events/hw_breakpoint.c

···
 bp_slots_histogram_alloc(struct bp_slots_histogram *hist, enum bp_type_idx type)
 {
 	hist->count = kzalloc_objs(*hist->count,
-				   hw_breakpoint_slots_cached(type), GFP_KERNEL);
+				   hw_breakpoint_slots_cached(type));
 	return hist->count;
 }
 

kernel/locking/locktorture.c

···
 	ww_mutex_init(&torture_ww_mutex_2, &torture_ww_class);
 
 	ww_acquire_ctxs = kmalloc_objs(*ww_acquire_ctxs,
-				       cxt.nrealwriters_stress, GFP_KERNEL);
+				       cxt.nrealwriters_stress);
 	if (!ww_acquire_ctxs)
 		VERBOSE_TOROUT_STRING("ww_acquire_ctx: Out of memory");
 }
···
 	if (call_rcu_chains <= 0)
 		return 0;
 	call_rcu_chain_list = kzalloc_objs(*call_rcu_chain_list,
-					   call_rcu_chains, GFP_KERNEL);
+					   call_rcu_chains);
 	if (!call_rcu_chain_list)
 		return -ENOMEM;
 	for (i = 0; i < call_rcu_chains; i++) {
···
 
 		if (nreaders_stress) {
 			cxt.lrsa = kmalloc_objs(*cxt.lrsa,
-						cxt.nrealreaders_stress,
-						GFP_KERNEL);
+						cxt.nrealreaders_stress);
 			if (cxt.lrsa == NULL) {
 				VERBOSE_TOROUT_STRING("cxt.lrsa: Out of memory");
 				firsterr = -ENOMEM;
···
 
 	if (nwriters_stress) {
 		writer_tasks = kzalloc_objs(writer_tasks[0],
-					    cxt.nrealwriters_stress, GFP_KERNEL);
+					    cxt.nrealwriters_stress);
 		if (writer_tasks == NULL) {
 			TOROUT_ERRSTRING("writer_tasks: Out of memory");
 			firsterr = -ENOMEM;
···
 
 	if (cxt.cur_ops->readlock) {
 		reader_tasks = kzalloc_objs(reader_tasks[0],
-					    cxt.nrealreaders_stress, GFP_KERNEL);
+					    cxt.nrealreaders_stress);
 		if (reader_tasks == NULL) {
 			TOROUT_ERRSTRING("reader_tasks: Out of memory");
 			kfree(writer_tasks);

kernel/rcu/rcuscale.c

···
 			kfree_by_call_rcu);
 
 	kfree_reader_tasks = kzalloc_objs(kfree_reader_tasks[0],
-					  kfree_nrealthreads, GFP_KERNEL);
+					  kfree_nrealthreads);
 	if (kfree_reader_tasks == NULL) {
 		firsterr = -ENOMEM;
 		goto unwind;
···
 			goto unwind;
 		}
 		writer_freelists = kzalloc_objs(writer_freelists[0],
-						nrealwriters, GFP_KERNEL);
+						nrealwriters);
 	}
 	if (!writer_tasks || !writer_durations || !writer_n_durations || !writer_done ||
 	    (gp_async && !writer_freelists)) {
···
 			init_llist_head(&wflp->ws_lhg);
 			init_llist_head(&wflp->ws_lhp);
 			wflp->ws_mblocks = kzalloc_objs(wflp->ws_mblocks[0],
-							gp_async_max,
-							GFP_KERNEL);
+							gp_async_max);
 			if (!wflp->ws_mblocks) {
 				firsterr = -ENOMEM;
 				goto unwind;

kernel/rcu/rcutorture.c

···
 	rcu_torture_write_types();
 	if (nrealfakewriters > 0) {
 		fakewriter_tasks = kzalloc_objs(fakewriter_tasks[0],
-						nrealfakewriters, GFP_KERNEL);
+						nrealfakewriters);
 		if (fakewriter_tasks == NULL) {
 			TOROUT_ERRSTRING("out of memory");
 			firsterr = -ENOMEM;
···
 	}
 	reader_tasks = kzalloc_objs(reader_tasks[0], nrealreaders);
 	rcu_torture_reader_mbchk = kzalloc_objs(*rcu_torture_reader_mbchk,
-						nrealreaders, GFP_KERNEL);
+						nrealreaders);
 	if (!reader_tasks || !rcu_torture_reader_mbchk) {
 		TOROUT_ERRSTRING("out of memory");
 		firsterr = -ENOMEM;

kernel/rcu/tasks.h

···
 	lim = rcu_task_enqueue_lim;
 
 	rtp->rtpcp_array = kzalloc_objs(struct rcu_tasks_percpu *,
-					num_possible_cpus(), GFP_KERNEL);
+					num_possible_cpus());
 	BUG_ON(!rtp->rtpcp_array);
 
 	for_each_possible_cpu(cpu) {

kernel/sched/ext_idle.c

···
 
 	/* Allocate per-node idle cpumasks */
 	scx_idle_node_masks = kzalloc_objs(*scx_idle_node_masks,
-					   num_possible_nodes(), GFP_KERNEL);
+					   num_possible_nodes());
 	BUG_ON(!scx_idle_node_masks);
 
 	for_each_node(i) {

kernel/time/timer_migration.c

···
 	tmigr_crossnode_level = cpulvl;
 
 	tmigr_level_list = kzalloc_objs(struct list_head,
-					tmigr_hierarchy_levels, GFP_KERNEL);
+					tmigr_hierarchy_levels);
 	if (!tmigr_level_list)
 		goto err;
 

kernel/trace/trace_events_synth.c

···
 
 	if (n_dynamic_fields) {
 		event->dynamic_fields = kzalloc_objs(*event->dynamic_fields,
-						     n_dynamic_fields,
-						     GFP_KERNEL);
+						     n_dynamic_fields);
 		if (!event->dynamic_fields) {
 			free_synth_event(event);
 			event = ERR_PTR(-ENOMEM);

kernel/trace/trace_syscalls.c

···
 
 	if (!IS_ENABLED(CONFIG_HAVE_SPARSE_SYSCALL_NR)) {
 		syscalls_metadata = kzalloc_objs(*syscalls_metadata,
-						 NR_syscalls, GFP_KERNEL);
+						 NR_syscalls);
 		if (!syscalls_metadata) {
 			WARN_ON(1);
 			return;

kernel/user_namespace.c

···
 
 		/* Allocate memory for 340 mappings. */
 		forward = kmalloc_objs(struct uid_gid_extent,
-				       UID_GID_MAP_MAX_EXTENTS, GFP_KERNEL);
+				       UID_GID_MAP_MAX_EXTENTS);
 		if (!forward)
 			return -ENOMEM;
 

lib/objagg.c

···
 	int i;
 
 	objagg_stats = kzalloc_flex(*objagg_stats, stats_info,
-				    objagg->obj_count, GFP_KERNEL);
+				    objagg->obj_count);
 	if (!objagg_stats)
 		return ERR_PTR(-ENOMEM);
 
···
 	int i;
 
 	objagg_stats = kzalloc_flex(*objagg_stats, stats_info,
-				    objagg_hints->node_count, GFP_KERNEL);
+				    objagg_hints->node_count);
 	if (!objagg_stats)
 		return ERR_PTR(-ENOMEM);
 

mm/damon/stat.c

···
 	damon_for_each_target(t, c) {
 		/* there is only one target */
 		region_pointers = kmalloc_objs(*region_pointers,
-					       damon_nr_regions(t), GFP_KERNEL);
+					       damon_nr_regions(t));
 		if (!region_pointers)
 			return -ENOMEM;
 		damon_for_each_region(r, t) {

mm/damon/tests/sysfs-kunit.h

···
 		kunit_skip(test, "sysfs_targets alloc fail");
 	sysfs_targets->nr = 1;
 	sysfs_targets->targets_arr = kmalloc_objs(*sysfs_targets->targets_arr,
-						  1, GFP_KERNEL);
+						  1);
 	if (!sysfs_targets->targets_arr) {
 		kfree(sysfs_targets);
 		kunit_skip(test, "targets_arr alloc fail");

net/bridge/br_mdb.c

···
 	}
 
 	cfg->src_entries = kzalloc_objs(struct br_mdb_src_entry,
-					cfg->num_src_entries, GFP_KERNEL);
+					cfg->num_src_entries);
 	if (!cfg->src_entries)
 		return -ENOMEM;
 

net/core/devmem.c

···
 
 	if (direction == DMA_TO_DEVICE) {
 		binding->tx_vec = kvmalloc_objs(struct net_iov *,
-						dmabuf->size / PAGE_SIZE,
-						GFP_KERNEL);
+						dmabuf->size / PAGE_SIZE);
 		if (!binding->tx_vec) {
 			err = -ENOMEM;
 			goto err_unmap;
···
 		}
 
 		owner->area.niovs = kvmalloc_objs(*owner->area.niovs,
-						  owner->area.num_niovs,
-						  GFP_KERNEL);
+						  owner->area.num_niovs);
 		if (!owner->area.niovs) {
 			err = -ENOMEM;
 			goto err_free_chunks;

net/ipv4/cipso_ipv4.c

···
 	u32 iter;
 
 	cipso_v4_cache = kzalloc_objs(struct cipso_v4_map_cache_bkt,
-				      CIPSO_V4_CACHE_BUCKETS, GFP_KERNEL);
+				      CIPSO_V4_CACHE_BUCKETS);
 	if (!cipso_v4_cache)
 		return -ENOMEM;
 

net/ipv4/devinet.c

···
 
 	err = -ENOMEM;
 	net->ipv4.inet_addr_lst = kmalloc_objs(struct hlist_head,
-					       IN4_ADDR_HSIZE, GFP_KERNEL);
+					       IN4_ADDR_HSIZE);
 	if (!net->ipv4.inet_addr_lst)
 		goto err_alloc_hash;
 

net/ipv4/nexthop.c

···
 	info->id = nh->id;
 	info->type = NH_NOTIFIER_INFO_TYPE_GRP_HW_STATS;
 	info->nh_grp_hw_stats = kzalloc_flex(*info->nh_grp_hw_stats, stats,
-					     nhg->num_nh, GFP_KERNEL);
+					     nhg->num_nh);
 	if (!info->nh_grp_hw_stats)
 		return -ENOMEM;
 

net/ipv4/udp_tunnel_nic.c

···
 
 	for (i = 0; i < n_tables; i++) {
 		utn->entries[i] = kzalloc_objs(*utn->entries[i],
-					       info->tables[i].n_entries,
-					       GFP_KERNEL);
+					       info->tables[i].n_entries);
 		if (!utn->entries[i])
 			goto err_free_prev_entries;
 	}

net/ipv6/addrconf.c

···
 	spin_lock_init(&net->ipv6.addrconf_hash_lock);
 	INIT_DEFERRABLE_WORK(&net->ipv6.addr_chk_work, addrconf_verify_work);
 	net->ipv6.inet6_addr_lst = kzalloc_objs(struct hlist_head,
-						IN6_ADDR_HSIZE, GFP_KERNEL);
+						IN6_ADDR_HSIZE);
 	if (!net->ipv6.inet6_addr_lst)
 		goto err_alloc_addr;
 

net/ipv6/calipso.c

···
 	u32 iter;
 
 	calipso_cache = kzalloc_objs(struct calipso_map_cache_bkt,
-				     CALIPSO_CACHE_BUCKETS, GFP_KERNEL);
+				     CALIPSO_CACHE_BUCKETS);
 	if (!calipso_cache)
 		return -ENOMEM;
 

net/mac80211/cfg.c

···
 	if (beacon->mbssid_ies && beacon->mbssid_ies->cnt) {
 		new_beacon->mbssid_ies =
 			kzalloc_flex(*new_beacon->mbssid_ies, elem,
-				     beacon->mbssid_ies->cnt, GFP_KERNEL);
+				     beacon->mbssid_ies->cnt);
 		if (!new_beacon->mbssid_ies) {
 			kfree(new_beacon);
 			return NULL;
···
 		if (beacon->rnr_ies && beacon->rnr_ies->cnt) {
 			new_beacon->rnr_ies =
 				kzalloc_flex(*new_beacon->rnr_ies, elem,
-					     beacon->rnr_ies->cnt, GFP_KERNEL);
+					     beacon->rnr_ies->cnt);
 			if (!new_beacon->rnr_ies) {
 				kfree(new_beacon->mbssid_ies);
 				kfree(new_beacon);

net/mac80211/main.c

···
 
 
 	local->int_scan_req = kzalloc_flex(*local->int_scan_req, channels,
-					   channels, GFP_KERNEL);
+					   channels);
 	if (!local->int_scan_req)
 		return -ENOMEM;
 

net/netfilter/ipvs/ip_vs_mh.c

···
 
 	if (svc->num_dests >= 1) {
 		s->dest_setup = kzalloc_objs(struct ip_vs_mh_dest_setup,
-					     svc->num_dests, GFP_KERNEL);
+					     svc->num_dests);
 		if (!s->dest_setup)
 			return -ENOMEM;
 	}

net/netfilter/nf_tables_api.c

···
 	size = 0;
 	if (nla[NFTA_RULE_EXPRESSIONS]) {
 		expr_info = kvmalloc_objs(struct nft_expr_info,
-					  NFT_RULE_MAXEXPRS, GFP_KERNEL);
+					  NFT_RULE_MAXEXPRS);
 		if (!expr_info)
 			return -ENOMEM;
 

net/netfilter/nfnetlink_cthelper.c

···
 		return -EOVERFLOW;
 
 	expect_policy = kzalloc_objs(struct nf_conntrack_expect_policy,
-				     class_max, GFP_KERNEL);
+				     class_max);
 	if (expect_policy == NULL)
 		return -ENOMEM;
 

net/sched/sch_htb.c

···
 
 		q->num_direct_qdiscs = dev->real_num_tx_queues;
 		q->direct_qdiscs = kzalloc_objs(*q->direct_qdiscs,
-						q->num_direct_qdiscs,
-						GFP_KERNEL);
+						q->num_direct_qdiscs);
 		if (!q->direct_qdiscs)
 			return -ENOMEM;
 	}

net/smc/smc_wr.c

···
 	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);
+					 link->max_send_wr);
 	if (!link->wr_tx_rdmas)
 		goto no_mem_wr_rx_ibs;
 	link->wr_tx_rdma_sges = kzalloc_objs(link->wr_tx_rdma_sges[0],
-					     link->max_send_wr, GFP_KERNEL);
+					     link->max_send_wr);
 	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);
···
 	if (!link->wr_tx_mask)
 		goto no_mem_wr_rx_sges;
 	link->wr_tx_pends = kzalloc_objs(link->wr_tx_pends[0],
-					 link->max_send_wr, GFP_KERNEL);
+					 link->max_send_wr);
 	if (!link->wr_tx_pends)
 		goto no_mem_wr_tx_mask;
 	link->wr_tx_compl = kzalloc_objs(link->wr_tx_compl[0],
-					 link->max_send_wr, GFP_KERNEL);
+					 link->max_send_wr);
 	if (!link->wr_tx_compl)
 		goto no_mem_wr_tx_pends;
 

net/unix/af_unix.c

···
 		goto err_proc;
 
 	net->unx.table.buckets = kvmalloc_objs(struct hlist_head,
-					       UNIX_HASH_SIZE, GFP_KERNEL);
+					       UNIX_HASH_SIZE);
 	if (!net->unx.table.buckets)
 		goto free_locks;
 

net/wireless/core.c

···
 		int idx;
 
 		wiphy->radio_cfg = kzalloc_objs(*wiphy->radio_cfg,
-						wiphy->n_radio, GFP_KERNEL);
+						wiphy->n_radio);
 		if (!wiphy->radio_cfg)
 			return -ENOMEM;
 		/*

net/wireless/nl80211.c

···
 
 	if (n_thresholds) {
 		cqm_config = kzalloc_flex(*cqm_config, rssi_thresholds,
-					  n_thresholds, GFP_KERNEL);
+					  n_thresholds);
 		if (!cqm_config)
 			return -ENOMEM;
 
···
 			return -EINVAL;
 
 		new_triggers.patterns = kzalloc_objs(new_triggers.patterns[0],
-						     n_patterns, GFP_KERNEL);
+						     n_patterns);
 		if (!new_triggers.patterns)
 			return -ENOMEM;
 

net/xdp/xsk_buff_pool.c

···
 	}
 
 	pool->dma_pages = kvzalloc_objs(*pool->dma_pages,
-					dma_map->dma_pages_cnt, GFP_KERNEL);
+					dma_map->dma_pages_cnt);
 	if (!pool->dma_pages)
 		return -ENOMEM;
 

net/xfrm/xfrm_iptfs.c

···
 	/* saved array is for saving 1..N seq nums from wantseq */
 	if (xc->reorder_win_size) {
 		xtfs->w_saved = kzalloc_objs(*xtfs->w_saved,
-					     xc->reorder_win_size, GFP_KERNEL);
+					     xc->reorder_win_size);
 		if (!xtfs->w_saved) {
 			NL_SET_ERR_MSG(extack, "Cannot alloc reorder window");
 			return -ENOMEM;
···
 	xtfs->ra_newskb = NULL;
 	if (xtfs->cfg.reorder_win_size) {
 		xtfs->w_saved = kzalloc_objs(*xtfs->w_saved,
-					     xtfs->cfg.reorder_win_size,
-					     GFP_KERNEL);
+					     xtfs->cfg.reorder_win_size);
 		if (!xtfs->w_saved) {
 			kfree_sensitive(xtfs);
 			return -ENOMEM;

security/integrity/ima/ima_crypto.c

···
 		ima_hash_algo_idx = NR_BANKS(ima_tpm_chip) + ima_extra_slots++;
 
 	ima_algo_array = kzalloc_objs(*ima_algo_array,
-				      NR_BANKS(ima_tpm_chip) + ima_extra_slots,
-				      GFP_KERNEL);
+				      NR_BANKS(ima_tpm_chip) + ima_extra_slots);
 	if (!ima_algo_array) {
 		rc = -ENOMEM;
 		goto out;

security/selinux/ss/conditional.c

···
 {
 	kfree(p->bool_val_to_struct);
 	p->bool_val_to_struct = kmalloc_objs(*p->bool_val_to_struct,
-					     p->p_bools.nprim, GFP_KERNEL);
+					     p->p_bools.nprim);
 	if (!p->bool_val_to_struct)
 		return -ENOMEM;
 
···
 	int rc;
 
 	cond_bool_array = kmalloc_objs(*orig->bool_val_to_struct,
-				       orig->p_bools.nprim, GFP_KERNEL);
+				       orig->p_bools.nprim);
 	if (!cond_bool_array)
 		return -ENOMEM;
 

security/selinux/ss/policydb.c

···
 	symtab_hash_eval(p->symtab);
 
 	p->class_val_to_struct = kzalloc_objs(*p->class_val_to_struct,
-					      p->p_classes.nprim, GFP_KERNEL);
+					      p->p_classes.nprim);
 	if (!p->class_val_to_struct)
 		return -ENOMEM;
 
 	p->role_val_to_struct = kzalloc_objs(*p->role_val_to_struct,
-					     p->p_roles.nprim, GFP_KERNEL);
+					     p->p_roles.nprim);
 	if (!p->role_val_to_struct)
 		return -ENOMEM;
 
 	p->user_val_to_struct = kzalloc_objs(*p->user_val_to_struct,
-					     p->p_users.nprim, GFP_KERNEL);
+					     p->p_users.nprim);
 	if (!p->user_val_to_struct)
 		return -ENOMEM;
 
 	p->type_val_to_struct = kvzalloc_objs(*p->type_val_to_struct,
-					      p->p_types.nprim, GFP_KERNEL);
+					      p->p_types.nprim);
 	if (!p->type_val_to_struct)
 		return -ENOMEM;
 
···
 
 	rc = -ENOMEM;
 	p->type_attr_map_array = kvzalloc_objs(*p->type_attr_map_array,
-					       p->p_types.nprim, GFP_KERNEL);
+					       p->p_types.nprim);
 	if (!p->type_attr_map_array)
 		goto bad;
 

sound/core/seq/oss/seq_oss_synth.c

···
 		info->nr_voices = rec->nr_voices;
 		if (info->nr_voices > 0) {
 			info->ch = kzalloc_objs(struct seq_oss_chinfo,
-						info->nr_voices, GFP_KERNEL);
+						info->nr_voices);
 			if (!info->ch) {
 				rec->oper.close(&info->arg);
 				module_put(rec->oper.owner);

sound/firewire/amdtp-stream.c

···
 							  queue_size * 3 / 2);
 			s->ctx_data.tx.cache.pos = 0;
 			s->ctx_data.tx.cache.descs = kzalloc_objs(*s->ctx_data.tx.cache.descs,
-								  s->ctx_data.tx.cache.size,
-								  GFP_KERNEL);
+								  s->ctx_data.tx.cache.size);
 			if (!s->ctx_data.tx.cache.descs) {
 				err = -ENOMEM;
 				goto err_context;
···
 		};
 
 		s->ctx_data.rx.seq.descs = kzalloc_objs(*s->ctx_data.rx.seq.descs,
-							queue_size, GFP_KERNEL);
+							queue_size);
 		if (!s->ctx_data.rx.seq.descs) {
 			err = -ENOMEM;
 			goto err_context;

sound/pci/emu10k1/emufx.c

···
 		goto __err_gpr;
 
 	controls = kzalloc_objs(struct snd_emu10k1_fx8010_control_gpr,
-				SND_EMU10K1_GPR_CONTROLS, GFP_KERNEL);
+				SND_EMU10K1_GPR_CONTROLS);
 	if (!controls)
 		goto __err_ctrls;
 

sound/soc/codecs/pcm6240.c

···
 	config_offset += 4;
 
 	bk_da = cfg_info->blk_data = kzalloc_objs(struct pcmdevice_block_data *,
-						  cfg_info->nblocks, GFP_KERNEL);
+						  cfg_info->nblocks);
 	if (!bk_da) {
 		*status = -ENOMEM;
 		goto out;

sound/soc/codecs/tas2781-fmwlib.c

···
 	 * these firmwares.
 	 */
 	bk_da = cfg_info->blk_data = kzalloc_objs(struct tasdev_blk_data *,
-						  cfg_info->nblocks, GFP_KERNEL);
+						  cfg_info->nblocks);
 	if (!bk_da) {
 		*status = -ENOMEM;
 		goto out;
···
 	}
 
 	tas_fmw->programs = kzalloc_objs(struct tasdevice_prog,
-					 tas_fmw->nr_programs, GFP_KERNEL);
+					 tas_fmw->nr_programs);
 	if (!tas_fmw->programs) {
 		offset = -ENOMEM;
 		goto out;
···
 	}
 
 	tas_fmw->configs = kzalloc_objs(struct tasdevice_config,
-					tas_fmw->nr_configurations, GFP_KERNEL);
+					tas_fmw->nr_configurations);
 	if (!tas_fmw->configs) {
 		offset = -ENOMEM;
 		goto out;
···
 		goto out;
 	}
 	tas_fmw->configs = kzalloc_objs(struct tasdevice_config,
-					tas_fmw->nr_configurations, GFP_KERNEL);
+					tas_fmw->nr_configurations);
 	if (!tas_fmw->configs) {
 		offset = -ENOMEM;
 		goto out;
···
 	}
 
 	tas_fmw->calibrations = kzalloc_objs(struct tasdevice_calibration,
-					     tas_fmw->nr_calibrations,
-					     GFP_KERNEL);
+					     tas_fmw->nr_calibrations);
 	if (!tas_fmw->calibrations) {
 		offset = -ENOMEM;
 		goto out;

sound/soc/qcom/qdsp6/topology.c

···
 			struct audioreach_module_priv_data *pdata;
 
 			pdata = kzalloc_flex(*pdata, data,
-					     le32_to_cpu(mod_array->size),
-					     GFP_KERNEL);
+					     le32_to_cpu(mod_array->size));
 			if (!pdata)
 				return ERR_PTR(-ENOMEM);
 

sound/soc/soc-dapm.c

···
 
 		if (w->num_kcontrols) {
 			w->kcontrols = kzalloc_objs(struct snd_kcontrol *,
-						    w->num_kcontrols,
-						    GFP_KERNEL);
+						    w->num_kcontrols);
 			if (!w->kcontrols) {
 				snd_soc_dapm_mutex_unlock(card);
 				return -ENOMEM;

sound/soc/sof/ipc4-pcm.c

···
 
 	/* allocate memory for the pipeline data */
 	trigger_list = kzalloc_flex(*trigger_list, pipeline_instance_ids,
-				    pipeline_list->count, GFP_KERNEL);
+				    pipeline_list->count);
 	if (!trigger_list)
 		return -ENOMEM;
 
···
 
 		/* allocate memory for max number of pipeline IDs */
 		pipeline_list->pipelines = kzalloc_objs(*pipeline_list->pipelines,
-							ipc4_data->max_num_pipelines,
-							GFP_KERNEL);
+							ipc4_data->max_num_pipelines);
 		if (!pipeline_list->pipelines) {
 			sof_ipc4_pcm_free(sdev, spcm);
 			return -ENOMEM;

sound/soc/sof/ipc4-topology.c

···
 
 	if (available_fmt->num_input_formats) {
 		in_format = kzalloc_objs(*in_format,
-					 available_fmt->num_input_formats,
-					 GFP_KERNEL);
+					 available_fmt->num_input_formats);
 		if (!in_format)
 			return -ENOMEM;
 		available_fmt->input_pin_fmts = in_format;
···
 
 	if (available_fmt->num_output_formats) {
 		out_format = kzalloc_objs(*out_format,
-					  available_fmt->num_output_formats,
-					  GFP_KERNEL);
+					  available_fmt->num_output_formats);
 		if (!out_format) {
 			ret = -ENOMEM;
 			goto err_in;

sound/synth/emux/emux_effect.c

···
 {
 	int i;
 	p->effect = kzalloc_objs(struct snd_emux_effect_table,
-				 p->chset.max_channels, GFP_KERNEL);
+				 p->chset.max_channels);
 	if (p->effect) {
 		for (i = 0; i < p->chset.max_channels; i++)
 			p->chset.channels[i].private = p->effect + i;

sound/usb/qcom/qc_audio_offload.c

···
 		uadev[card_num].num_intf =
 			subs->dev->config->desc.bNumInterfaces;
 		uadev[card_num].info = kzalloc_objs(struct intf_info,
-						    uadev[card_num].num_intf,
-						    GFP_KERNEL);
+						    uadev[card_num].num_intf);
 		if (!uadev[card_num].info) {
 			ret = -ENOMEM;
 			goto unmap_er;

sound/xen/xen_snd_front_evtchnl.c

···
 
 	front_info->evt_pairs =
 			kzalloc_objs(struct xen_snd_front_evtchnl_pair,
-				     num_streams, GFP_KERNEL);
+				     num_streams);
 	if (!front_info->evt_pairs)
 		return -ENOMEM;