Pull more overflow updates from Kees Cook: "The rest of the overflow changes for v4.18-rc1. This includes the explicit overflow fixes from Silvio, further struct_size() conversions from Matthew, and a bug fix from Dan. But the bulk of it is the treewide conversions to use either the 2-factor argument allocators (e.g. kmalloc(a * b, ...) into kmalloc_array(a, b, ...) or the array_size() macros (e.g. vmalloc(a * b) into vmalloc(array_size(a, b)). Coccinelle was fighting me on several fronts, so I've done a bunch of manual whitespace updates in the patches as well. Summary: - Error path bug fix for overflow tests (Dan) - Additional struct_size() conversions (Matthew, Kees) - Explicitly reported overflow fixes (Silvio, Kees) - Add missing kvcalloc() function (Kees) - Treewide conversions of allocators to use either 2-factor argument variant when available, or array_size() and array3_size() as needed (Kees)" * tag 'overflow-v4.18-rc1-part2' of git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux: (26 commits) treewide: Use array_size in f2fs_kvzalloc() treewide: Use array_size() in f2fs_kzalloc() treewide: Use array_size() in f2fs_kmalloc() treewide: Use array_size() in sock_kmalloc() treewide: Use array_size() in kvzalloc_node() treewide: Use array_size() in vzalloc_node() treewide: Use array_size() in vzalloc() treewide: Use array_size() in vmalloc() treewide: devm_kzalloc() -> devm_kcalloc() treewide: devm_kmalloc() -> devm_kmalloc_array() treewide: kvzalloc() -> kvcalloc() treewide: kvmalloc() -> kvmalloc_array() treewide: kzalloc_node() -> kcalloc_node() treewide: kzalloc() -> kcalloc() treewide: kmalloc() -> kmalloc_array() mm: Introduce kvcalloc() video: uvesafb: Fix integer overflow in allocation UBIFS: Fix potential integer overflow in allocation leds: Use struct_size() in allocation Convert intel uncore to struct_size ...
Unified · Split
| @@ -286,7 +286,7 @@ asmlinkage long sys_oabi_epoll_wait(int epfd, · 285 unmodified lines | ||
| 286 | 286 | return -EINVAL; |
| 287 | 287 | if (!access_ok(VERIFY_WRITE, events, sizeof(*events) * maxevents)) |
| 288 | 288 | return -EFAULT; |
| 289 | − kbuf = kmalloc(sizeof(*kbuf) * maxevents, GFP_KERNEL); | |
| 289 | + kbuf = kmalloc_array(maxevents, sizeof(*kbuf), GFP_KERNEL); | |
| 290 | 290 | if (!kbuf) |
| 291 | 291 | return -ENOMEM; |
| 292 | 292 | fs = get_fs(); |
| @@ -324,7 +324,7 @@ asmlinkage long sys_oabi_semtimedop(int semid, · 31 unmodified lines | ||
| 324 | 324 | return -EINVAL; |
| 325 | 325 | if (!access_ok(VERIFY_READ, tsops, sizeof(*tsops) * nsops)) |
| 326 | 326 | return -EFAULT; |
| 327 | − sops = kmalloc(sizeof(*sops) * nsops, GFP_KERNEL); | |
| 327 | + sops = kmalloc_array(nsops, sizeof(*sops), GFP_KERNEL); | |
| 328 | 328 | if (!sops) |
| 329 | 329 | return -ENOMEM; |
| 330 | 330 | err = 0; |
| @@ -252,7 +252,7 @@ int __init dc21285_setup(int nr, struct pci_sys_data *sys) · 251 unmodified lines | ||
| 252 | 252 | if (nr || !footbridge_cfn_mode()) |
| 253 | 253 | return 0; |
| 254 | 254 | |
| 255 | − res = kzalloc(sizeof(struct resource) * 2, GFP_KERNEL); | |
| 255 | + res = kcalloc(2, sizeof(struct resource), GFP_KERNEL); | |
| 256 | 256 | if (!res) { |
| 257 | 257 | printk("out of memory for root bus resources"); |
| 258 | 258 | return 0; |
| @@ -421,7 +421,7 @@ int ixp4xx_setup(int nr, struct pci_sys_data *sys) · 420 unmodified lines | ||
| 421 | 421 | if (nr >= 1) |
| 422 | 422 | return 0; |
| 423 | 423 | |
| 424 | − res = kzalloc(sizeof(*res) * 2, GFP_KERNEL); | |
| 424 | + res = kcalloc(2, sizeof(*res), GFP_KERNEL); | |
| 425 | 425 | if (res == NULL) { |
| 426 | 426 | /* |
| 427 | 427 | * If we're out of memory this early, something is wrong, |
| @@ -389,7 +389,7 @@ static void omap_mcbsp_register_board_cfg(struct resource *res, int res_count, · 388 unmodified lines | ||
| 389 | 389 | { |
| 390 | 390 | int i; |
| 391 | 391 | |
| 392 | − omap_mcbsp_devices = kzalloc(size * sizeof(struct platform_device *), | |
| 392 | + omap_mcbsp_devices = kcalloc(size, sizeof(struct platform_device *), | |
| 393 | 393 | GFP_KERNEL); |
| 394 | 394 | if (!omap_mcbsp_devices) { |
| 395 | 395 | printk(KERN_ERR "Could not register McBSP devices\n"); |
| @@ -34,7 +34,7 @@ static int __init omap_hsmmc_pdata_init(struct omap2_hsmmc_info *c, · 33 unmodified lines | ||
| 34 | 34 | { |
| 35 | 35 | char *hc_name; |
| 36 | 36 | |
| 37 | − hc_name = kzalloc(sizeof(char) * (HSMMC_NAME_LEN + 1), GFP_KERNEL); | |
| 37 | + hc_name = kzalloc(HSMMC_NAME_LEN + 1, GFP_KERNEL); | |
| 38 | 38 | if (!hc_name) { |
| 39 | 39 | kfree(hc_name); |
| 40 | 40 | return -ENOMEM; |
| @@ -162,7 +162,7 @@ static int omap_device_build_from_dt(struct platform_device *pdev) · 161 unmodified lines | ||
| 162 | 162 | !omap_hwmod_parse_module_range(NULL, node, &res)) |
| 163 | 163 | return -ENODEV; |
| 164 | 164 | |
| 165 | − hwmods = kzalloc(sizeof(struct omap_hwmod *) * oh_cnt, GFP_KERNEL); | |
| 165 | + hwmods = kcalloc(oh_cnt, sizeof(struct omap_hwmod *), GFP_KERNEL); | |
| 166 | 166 | if (!hwmods) { |
| 167 | 167 | ret = -ENOMEM; |
| 168 | 168 | goto odbfd_exit; |
| @@ -413,7 +413,7 @@ omap_device_copy_resources(struct omap_hwmod *oh, · 244 unmodified lines | ||
| 413 | 413 | goto error; |
| 414 | 414 | } |
| 415 | 415 | |
| 416 | − res = kzalloc(sizeof(*res) * 2, GFP_KERNEL); | |
| 416 | + res = kcalloc(2, sizeof(*res), GFP_KERNEL); | |
| 417 | 417 | if (!res) |
| 418 | 418 | return -ENOMEM; |
| 419 | 419 | |
| @@ -285,10 +285,11 @@ int omap_prcm_register_chain_handler(struct omap_prcm_irq_setup *irq_setup) · 284 unmodified lines | ||
| 285 | 285 | |
| 286 | 286 | prcm_irq_setup = irq_setup; |
| 287 | 287 | |
| 288 | − prcm_irq_chips = kzalloc(sizeof(void *) * nr_regs, GFP_KERNEL); | |
| 289 | − prcm_irq_setup->saved_mask = kzalloc(sizeof(u32) * nr_regs, GFP_KERNEL); | |
| 290 | − prcm_irq_setup->priority_mask = kzalloc(sizeof(u32) * nr_regs, | |
| 291 | − GFP_KERNEL); | |
| 288 | + prcm_irq_chips = kcalloc(nr_regs, sizeof(void *), GFP_KERNEL); | |
| 289 | + prcm_irq_setup->saved_mask = kcalloc(nr_regs, sizeof(u32), | |
| 290 | + GFP_KERNEL); | |
| 291 | + prcm_irq_setup->priority_mask = kcalloc(nr_regs, sizeof(u32), | |
| 292 | + GFP_KERNEL); | |
| 292 | 293 | |
| 293 | 294 | if (!prcm_irq_chips || !prcm_irq_setup->saved_mask || |
| 294 | 295 | !prcm_irq_setup->priority_mask) |
| @@ -403,7 +403,7 @@ static int ve_spc_populate_opps(uint32_t cluster) · 402 unmodified lines | ||
| 403 | 403 | uint32_t data = 0, off, ret, idx; |
| 404 | 404 | struct ve_spc_opp *opps; |
| 405 | 405 | |
| 406 | − opps = kzalloc(sizeof(*opps) * MAX_OPPS, GFP_KERNEL); | |
| 406 | + opps = kcalloc(MAX_OPPS, sizeof(*opps), GFP_KERNEL); | |
| 407 | 407 | if (!opps) |
| 408 | 408 | return -ENOMEM; |
| 409 | 409 | |
| @@ -2162,8 +2162,8 @@ arm_iommu_create_mapping(struct bus_type *bus, dma_addr_t base, u64 size) · 2161 unmodified lines | ||
| 2162 | 2162 | goto err; |
| 2163 | 2163 | |
| 2164 | 2164 | mapping->bitmap_size = bitmap_size; |
| 2165 | − mapping->bitmaps = kzalloc(extensions * sizeof(unsigned long *), | |
| 2166 | − GFP_KERNEL); | |
| 2165 | + mapping->bitmaps = kcalloc(extensions, sizeof(unsigned long *), | |
| 2166 | + GFP_KERNEL); | |
| 2167 | 2167 | if (!mapping->bitmaps) |
| 2168 | 2168 | goto err2; |
| 2169 | 2169 | |
| @@ -20,7 +20,7 @@ · 19 unmodified lines | ||
| 20 | 20 | #include "mm.h" |
| 21 | 21 | |
| 22 | 22 | #ifdef CONFIG_ARM_LPAE |
| 23 | −#define __pgd_alloc() kmalloc(PTRS_PER_PGD * sizeof(pgd_t), GFP_KERNEL) | |
| 23 | +#define __pgd_alloc() kmalloc_array(PTRS_PER_PGD, sizeof(pgd_t), GFP_KERNEL) | |
| 24 | 24 | #define __pgd_free(pgd) kfree(pgd) |
| 25 | 25 | #else |
| 26 | 26 | #define __pgd_alloc() (pgd_t *)__get_free_pages(GFP_KERNEL, 2) |
| @@ -766,8 +766,9 @@ static int coverage_start_fn(const struct decode_header *h, void *args) · 765 unmodified lines | ||
| 766 | 766 | |
| 767 | 767 | static int coverage_start(const union decode_item *table) |
| 768 | 768 | { |
| 769 | − coverage.base = kmalloc(MAX_COVERAGE_ENTRIES * | |
| 770 | − sizeof(struct coverage_entry), GFP_KERNEL); | |
| 769 | + coverage.base = kmalloc_array(MAX_COVERAGE_ENTRIES, | |
| 770 | + sizeof(struct coverage_entry), | |
| 771 | + GFP_KERNEL); | |
| 771 | 772 | coverage.num_entries = 0; |
| 772 | 773 | coverage.nesting = 0; |
| 773 | 774 | return table_iter(table, coverage_start_fn, &coverage); |
| @@ -234,8 +234,8 @@ static void __init register_insn_emulation_sysctl(void) · 233 unmodified lines | ||
| 234 | 234 | struct insn_emulation *insn; |
| 235 | 235 | struct ctl_table *insns_sysctl, *sysctl; |
| 236 | 236 | |
| 237 | − insns_sysctl = kzalloc(sizeof(*sysctl) * (nr_insn_emulated + 1), | |
| 238 | − GFP_KERNEL); | |
| 237 | + insns_sysctl = kcalloc(nr_insn_emulated + 1, sizeof(*sysctl), | |
| 238 | + GFP_KERNEL); | |
| 239 | 239 | |
| 240 | 240 | raw_spin_lock_irqsave(&insn_emulation_lock, flags); |
| 241 | 241 | list_for_each_entry(insn, &insn_emulation, node) { |
| @@ -263,7 +263,7 @@ static int asids_init(void) · 262 unmodified lines | ||
| 263 | 263 | */ |
| 264 | 264 | WARN_ON(NUM_USER_ASIDS - 1 <= num_possible_cpus()); |
| 265 | 265 | atomic64_set(&asid_generation, ASID_FIRST_VERSION); |
| 266 | − asid_map = kzalloc(BITS_TO_LONGS(NUM_USER_ASIDS) * sizeof(*asid_map), | |
| 266 | + asid_map = kcalloc(BITS_TO_LONGS(NUM_USER_ASIDS), sizeof(*asid_map), | |
| 267 | 267 | GFP_KERNEL); |
| 268 | 268 | if (!asid_map) |
| 269 | 269 | panic("Failed to allocate bitmap for %lu ASIDs\n", |
| @@ -350,7 +350,8 @@ init_record_index_pools(void) · 349 unmodified lines | ||
| 350 | 350 | /* - 3 - */ |
| 351 | 351 | slidx_pool.max_idx = (rec_max_size/sect_min_size) * 2 + 1; |
| 352 | 352 | slidx_pool.buffer = |
| 353 | − kmalloc(slidx_pool.max_idx * sizeof(slidx_list_t), GFP_KERNEL); | |
| 353 | + kmalloc_array(slidx_pool.max_idx, sizeof(slidx_list_t), | |
| 354 | + GFP_KERNEL); | |
| 354 | 355 | |
| 355 | 356 | return slidx_pool.buffer ? 0 : -ENOMEM; |
| 356 | 357 | } |
| @@ -85,7 +85,7 @@ static int __init topology_init(void) · 84 unmodified lines | ||
| 85 | 85 | } |
| 86 | 86 | #endif |
| 87 | 87 | |
| 88 | − sysfs_cpus = kzalloc(sizeof(struct ia64_cpu) * NR_CPUS, GFP_KERNEL); | |
| 88 | + sysfs_cpus = kcalloc(NR_CPUS, sizeof(struct ia64_cpu), GFP_KERNEL); | |
| 89 | 89 | if (!sysfs_cpus) |
| 90 | 90 | panic("kzalloc in topology_init failed - NR_CPUS too big?"); |
| 91 | 91 | |
| @@ -319,8 +319,8 @@ static int cpu_cache_sysfs_init(unsigned int cpu) · 227 unmodified lines | ||
| 319 | 319 | return -1; |
| 320 | 320 | } |
| 321 | 321 | |
| 322 | − this_cache=kzalloc(sizeof(struct cache_info)*unique_caches, | |
| 323 | − GFP_KERNEL); | |
| 322 | + this_cache=kcalloc(unique_caches, sizeof(struct cache_info), | |
| 323 | + GFP_KERNEL); | |
| 324 | 324 | if (this_cache == NULL) |
| 325 | 325 | return -ENOMEM; |
| 326 | 326 | |
| @@ -430,8 +430,9 @@ int ia64_itr_entry(u64 target_mask, u64 va, u64 pte, u64 log_size) · 429 unmodified lines | ||
| 430 | 430 | int cpu = smp_processor_id(); |
| 431 | 431 | |
| 432 | 432 | if (!ia64_idtrs[cpu]) { |
| 433 | − ia64_idtrs[cpu] = kmalloc(2 * IA64_TR_ALLOC_MAX * | |
| 434 | − sizeof (struct ia64_tr_entry), GFP_KERNEL); | |
| 433 | + ia64_idtrs[cpu] = kmalloc_array(2 * IA64_TR_ALLOC_MAX, | |
| 434 | + sizeof(struct ia64_tr_entry), | |
| 435 | + GFP_KERNEL); | |
| 435 | 436 | if (!ia64_idtrs[cpu]) |
| 436 | 437 | return -ENOMEM; |
| 437 | 438 | } |
| @@ -132,7 +132,7 @@ static s64 sn_device_fixup_war(u64 nasid, u64 widget, int device, · 131 unmodified lines | ||
| 132 | 132 | printk_once(KERN_WARNING |
| 133 | 133 | "PROM version < 4.50 -- implementing old PROM flush WAR\n"); |
| 134 | 134 | |
| 135 | − war_list = kzalloc(DEV_PER_WIDGET * sizeof(*war_list), GFP_KERNEL); | |
| 135 | + war_list = kcalloc(DEV_PER_WIDGET, sizeof(*war_list), GFP_KERNEL); | |
| 136 | 136 | BUG_ON(!war_list); |
| 137 | 137 | |
| 138 | 138 | SAL_CALL_NOLOCK(isrv, SN_SAL_IOIF_GET_WIDGET_DMAFLUSH_LIST, |
| @@ -474,7 +474,8 @@ void __init sn_irq_lh_init(void) · 473 unmodified lines | ||
| 474 | 474 | { |
| 475 | 475 | int i; |
| 476 | 476 | |
| 477 | − sn_irq_lh = kmalloc(sizeof(struct list_head *) * NR_IRQS, GFP_KERNEL); | |
| 477 | + sn_irq_lh = kmalloc_array(NR_IRQS, sizeof(struct list_head *), | |
| 478 | + GFP_KERNEL); | |
| 478 | 479 | if (!sn_irq_lh) |
| 479 | 480 | panic("SN PCI INIT: Failed to allocate memory for PCI init\n"); |
| 480 | 481 | |
| @@ -184,7 +184,7 @@ pcibr_bus_fixup(struct pcibus_bussoft *prom_bussoft, struct pci_controller *cont · 183 unmodified lines | ||
| 184 | 184 | /* Setup the PMU ATE map */ |
| 185 | 185 | soft->pbi_int_ate_resource.lowest_free_index = 0; |
| 186 | 186 | soft->pbi_int_ate_resource.ate = |
| 187 | − kzalloc(soft->pbi_int_ate_size * sizeof(u64), GFP_KERNEL); | |
| 187 | + kcalloc(soft->pbi_int_ate_size, sizeof(u64), GFP_KERNEL); | |
| 188 | 188 | |
| 189 | 189 | if (!soft->pbi_int_ate_resource.ate) { |
| 190 | 190 | kfree(soft); |
| @@ -985,7 +985,7 @@ static int __init alchemy_clk_setup_imux(int ctype) · 984 unmodified lines | ||
| 985 | 985 | return -ENODEV; |
| 986 | 986 | } |
| 987 | 987 | |
| 988 | − a = kzalloc((sizeof(*a)) * 6, GFP_KERNEL); | |
| 988 | + a = kcalloc(6, sizeof(*a), GFP_KERNEL); | |
| 989 | 989 | if (!a) |
| 990 | 990 | return -ENOMEM; |
| 991 | 991 | |
| @@ -411,8 +411,8 @@ u32 au1xxx_dbdma_ring_alloc(u32 chanid, int entries) · 410 unmodified lines | ||
| 411 | 411 | * and if we try that first we are likely to not waste larger |
| 412 | 412 | * slabs of memory. |
| 413 | 413 | */ |
| 414 | − desc_base = (u32)kmalloc(entries * sizeof(au1x_ddma_desc_t), | |
| 415 | − GFP_KERNEL|GFP_DMA); | |
| 414 | + desc_base = (u32)kmalloc_array(entries, sizeof(au1x_ddma_desc_t), | |
| 415 | + GFP_KERNEL|GFP_DMA); | |
| 416 | 416 | if (desc_base == 0) |
| 417 | 417 | return 0; |
| 418 | 418 | |
| @@ -1050,7 +1050,7 @@ static int __init dbdma_setup(unsigned int irq, dbdev_tab_t *idtable) · 631 unmodified lines | ||
| 1050 | 1050 | { |
| 1051 | 1051 | int ret; |
| 1052 | 1052 | |
| 1053 | − dbdev_tab = kzalloc(sizeof(dbdev_tab_t) * DBDEV_TAB_SIZE, GFP_KERNEL); | |
| 1053 | + dbdev_tab = kcalloc(DBDEV_TAB_SIZE, sizeof(dbdev_tab_t), GFP_KERNEL); | |
| 1054 | 1054 | if (!dbdev_tab) |
| 1055 | 1055 | return -ENOMEM; |
| 1056 | 1056 | |
| @@ -115,7 +115,7 @@ static void __init alchemy_setup_uarts(int ctype) · 114 unmodified lines | ||
| 115 | 115 | uartclk = clk_get_rate(clk); |
| 116 | 116 | clk_put(clk); |
| 117 | 117 | |
| 118 | − ports = kzalloc(s * (c + 1), GFP_KERNEL); | |
| 118 | + ports = kcalloc(s, (c + 1), GFP_KERNEL); | |
| 119 | 119 | if (!ports) { |
| 120 | 120 | printk(KERN_INFO "Alchemy: no memory for UART data\n"); |
| 121 | 121 | return; |
| @@ -198,7 +198,7 @@ static unsigned long alchemy_ehci_data[][2] __initdata = { · 76 unmodified lines | ||
| 198 | 198 | |
| 199 | 199 | static int __init _new_usbres(struct resource **r, struct platform_device **d) |
| 200 | 200 | { |
| 201 | − *r = kzalloc(sizeof(struct resource) * 2, GFP_KERNEL); | |
| 201 | + *r = kcalloc(2, sizeof(struct resource), GFP_KERNEL); | |
| 202 | 202 | if (!*r) |
| 203 | 203 | return -ENOMEM; |
| 204 | 204 | *d = kzalloc(sizeof(struct platform_device), GFP_KERNEL); |
| @@ -103,7 +103,7 @@ int __init db1x_register_pcmcia_socket(phys_addr_t pcmcia_attr_start, · 102 unmodified lines | ||
| 103 | 103 | if (stschg_irq) |
| 104 | 104 | cnt++; |
| 105 | 105 | |
| 106 | − sr = kzalloc(sizeof(struct resource) * cnt, GFP_KERNEL); | |
| 106 | + sr = kcalloc(cnt, sizeof(struct resource), GFP_KERNEL); | |
| 107 | 107 | if (!sr) |
| 108 | 108 | return -ENOMEM; |
| 109 | 109 | |
| @@ -178,7 +178,7 @@ int __init db1x_register_norflash(unsigned long size, int width, · 68 unmodified lines | ||
| 178 | 178 | return -EINVAL; |
| 179 | 179 | |
| 180 | 180 | ret = -ENOMEM; |
| 181 | − parts = kzalloc(sizeof(struct mtd_partition) * 5, GFP_KERNEL); | |
| 181 | + parts = kcalloc(5, sizeof(struct mtd_partition), GFP_KERNEL); | |
| 182 | 182 | if (!parts) |
| 183 | 183 | goto out; |
| 184 | 184 | |
| @@ -94,7 +94,7 @@ static int __init bmips_init_dma_ranges(void) · 93 unmodified lines | ||
| 94 | 94 | goto out_bad; |
| 95 | 95 | |
| 96 | 96 | /* add a dummy (zero) entry at the end as a sentinel */ |
| 97 | − bmips_dma_ranges = kzalloc(sizeof(struct bmips_dma_range) * (len + 1), | |
| 97 | + bmips_dma_ranges = kcalloc(len + 1, sizeof(struct bmips_dma_range), | |
| 98 | 98 | GFP_KERNEL); |
| 99 | 99 | if (!bmips_dma_ranges) |
| 100 | 100 | goto out_bad; |
| @@ -219,7 +219,7 @@ static int __init rbtx4939_led_probe(struct platform_device *pdev) · 218 unmodified lines | ||
| 219 | 219 | "nand-disk", |
| 220 | 220 | }; |
| 221 | 221 | |
| 222 | − leds_data = kzalloc(sizeof(*leds_data) * RBTX4939_MAX_7SEGLEDS, | |
| 222 | + leds_data = kcalloc(RBTX4939_MAX_7SEGLEDS, sizeof(*leds_data), | |
| 223 | 223 | GFP_KERNEL); |
| 224 | 224 | if (!leds_data) |
| 225 | 225 | return -ENOMEM; |
| @@ -559,7 +559,8 @@ static int __init rtas_event_scan_init(void) · 558 unmodified lines | ||
| 559 | 559 | rtas_error_log_max = rtas_get_error_log_max(); |
| 560 | 560 | rtas_error_log_buffer_max = rtas_error_log_max + sizeof(int); |
| 561 | 561 | |
| 562 | − rtas_log_buf = vmalloc(rtas_error_log_buffer_max*LOG_NUMBER); | |
| 562 | + rtas_log_buf = vmalloc(array_size(LOG_NUMBER, | |
| 563 | + rtas_error_log_buffer_max)); | |
| 563 | 564 | if (!rtas_log_buf) { |
| 564 | 565 | printk(KERN_ERR "rtasd: no memory\n"); |
| 565 | 566 | return -ENOMEM; |
| @@ -791,7 +791,7 @@ static int __init vdso_init(void) · 790 unmodified lines | ||
| 791 | 791 | |
| 792 | 792 | #ifdef CONFIG_VDSO32 |
| 793 | 793 | /* Make sure pages are in the correct state */ |
| 794 | − vdso32_pagelist = kzalloc(sizeof(struct page *) * (vdso32_pages + 2), | |
| 794 | + vdso32_pagelist = kcalloc(vdso32_pages + 2, sizeof(struct page *), | |
| 795 | 795 | GFP_KERNEL); |
| 796 | 796 | BUG_ON(vdso32_pagelist == NULL); |
| 797 | 797 | for (i = 0; i < vdso32_pages; i++) { |
| @@ -805,7 +805,7 @@ static int __init vdso_init(void) · 7 unmodified lines | ||
| 805 | 805 | #endif |
| 806 | 806 | |
| 807 | 807 | #ifdef CONFIG_PPC64 |
| 808 | − vdso64_pagelist = kzalloc(sizeof(struct page *) * (vdso64_pages + 2), | |
| 808 | + vdso64_pagelist = kcalloc(vdso64_pages + 2, sizeof(struct page *), | |
| 809 | 809 | GFP_KERNEL); |
| 810 | 810 | BUG_ON(vdso64_pagelist == NULL); |
| 811 | 811 | for (i = 0; i < vdso64_pages; i++) { |
| @@ -108,7 +108,7 @@ int kvmppc_allocate_hpt(struct kvm_hpt_info *info, u32 order) · 107 unmodified lines | ||
| 108 | 108 | npte = 1ul << (order - 4); |
| 109 | 109 | |
| 110 | 110 | /* Allocate reverse map array */ |
| 111 | − rev = vmalloc(sizeof(struct revmap_entry) * npte); | |
| 111 | + rev = vmalloc(array_size(npte, sizeof(struct revmap_entry))); | |
| 112 | 112 | if (!rev) { |
| 113 | 113 | if (cma) |
| 114 | 114 | kvm_free_hpt_cma(page, 1 << (order - PAGE_SHIFT)); |
| @@ -3548,7 +3548,7 @@ static void kvmppc_core_free_memslot_hv(struct kvm_memory_slot *free, · 3547 unmodified lines | ||
| 3548 | 3548 | static int kvmppc_core_create_memslot_hv(struct kvm_memory_slot *slot, |
| 3549 | 3549 | unsigned long npages) |
| 3550 | 3550 | { |
| 3551 | − slot->arch.rmap = vzalloc(npages * sizeof(*slot->arch.rmap)); | |
| 3551 | + slot->arch.rmap = vzalloc(array_size(npages, sizeof(*slot->arch.rmap))); | |
| 3552 | 3552 | if (!slot->arch.rmap) |
| 3553 | 3553 | return -ENOMEM; |
| 3554 | 3554 | |
| @@ -54,7 +54,7 @@ static int grow(rh_info_t * info, int max_blocks) · 53 unmodified lines | ||
| 54 | 54 | |
| 55 | 55 | new_blocks = max_blocks - info->max_blocks; |
| 56 | 56 | |
| 57 | − block = kmalloc(sizeof(rh_block_t) * max_blocks, GFP_ATOMIC); | |
| 57 | + block = kmalloc_array(max_blocks, sizeof(rh_block_t), GFP_ATOMIC); | |
| 58 | 58 | if (block == NULL) |
| 59 | 59 | return -ENOMEM; |
| 60 | 60 | |
| @@ -159,7 +159,7 @@ long mm_iommu_get(struct mm_struct *mm, unsigned long ua, unsigned long entries, · 158 unmodified lines | ||
| 159 | 159 | goto unlock_exit; |
| 160 | 160 | } |
| 161 | 161 | |
| 162 | − mem->hpas = vzalloc(entries * sizeof(mem->hpas[0])); | |
| 162 | + mem->hpas = vzalloc(array_size(entries, sizeof(mem->hpas[0]))); | |
| 163 | 163 | if (!mem->hpas) { |
| 164 | 164 | kfree(mem); |
| 165 | 165 | ret = -ENOMEM; |
| @@ -1316,7 +1316,7 @@ int numa_update_cpu_topology(bool cpus_locked) · 1315 unmodified lines | ||
| 1316 | 1316 | if (!weight) |
| 1317 | 1317 | return 0; |
| 1318 | 1318 | |
| 1319 | − updates = kzalloc(weight * (sizeof(*updates)), GFP_KERNEL); | |
| 1319 | + updates = kcalloc(weight, sizeof(*updates), GFP_KERNEL); | |
| 1320 | 1320 | if (!updates) |
| 1321 | 1321 | return 0; |
| 1322 | 1322 | |
| @@ -566,7 +566,7 @@ void bpf_jit_compile(struct bpf_prog *fp) · 565 unmodified lines | ||
| 566 | 566 | if (!bpf_jit_enable) |
| 567 | 567 | return; |
| 568 | 568 | |
| 569 | − addrs = kzalloc((flen+1) * sizeof(*addrs), GFP_KERNEL); | |
| 569 | + addrs = kcalloc(flen + 1, sizeof(*addrs), GFP_KERNEL); | |
| 570 | 570 | if (addrs == NULL) |
| 571 | 571 | return; |
| 572 | 572 | |
| @@ -949,7 +949,7 @@ struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *fp) · 948 unmodified lines | ||
| 949 | 949 | goto skip_init_ctx; |
| 950 | 950 | } |
| 951 | 951 | |
| 952 | − addrs = kzalloc((flen+1) * sizeof(*addrs), GFP_KERNEL); | |
| 952 | + addrs = kcalloc(flen + 1, sizeof(*addrs), GFP_KERNEL); | |
| 953 | 953 | if (addrs == NULL) { |
| 954 | 954 | fp = org_fp; |
| 955 | 955 | goto out_addrs; |
| @@ -210,8 +210,8 @@ int start_spu_profiling_cycles(unsigned int cycles_reset) · 209 unmodified lines | ||
| 210 | 210 | timer.function = profile_spus; |
| 211 | 211 | |
| 212 | 212 | /* Allocate arrays for collecting SPU PC samples */ |
| 213 | − samples = kzalloc(SPUS_PER_NODE * | |
| 214 | − TRACE_ARRAY_SIZE * sizeof(u32), GFP_KERNEL); | |
| 213 | + samples = kcalloc(SPUS_PER_NODE * TRACE_ARRAY_SIZE, sizeof(u32), | |
| 214 | + GFP_KERNEL); | |
| 215 | 215 | |
| 216 | 216 | if (!samples) |
| 217 | 217 | return -ENOMEM; |
| @@ -156,7 +156,8 @@ static int hsta_msi_probe(struct platform_device *pdev) · 155 unmodified lines | ||
| 156 | 156 | if (ret) |
| 157 | 157 | goto out; |
| 158 | 158 | |
| 159 | − ppc4xx_hsta_msi.irq_map = kmalloc(sizeof(int) * irq_count, GFP_KERNEL); | |
| 159 | + ppc4xx_hsta_msi.irq_map = kmalloc_array(irq_count, sizeof(int), | |
| 160 | + GFP_KERNEL); | |
| 160 | 161 | if (!ppc4xx_hsta_msi.irq_map) { |
| 161 | 162 | ret = -ENOMEM; |
| 162 | 163 | goto out1; |
| @@ -89,7 +89,7 @@ static int ppc4xx_setup_msi_irqs(struct pci_dev *dev, int nvec, int type) · 88 unmodified lines | ||
| 89 | 89 | if (type == PCI_CAP_ID_MSIX) |
| 90 | 90 | pr_debug("ppc4xx msi: MSI-X untested, trying anyway.\n"); |
| 91 | 91 | |
| 92 | − msi_data->msi_virqs = kmalloc((msi_irqs) * sizeof(int), GFP_KERNEL); | |
| 92 | + msi_data->msi_virqs = kmalloc_array(msi_irqs, sizeof(int), GFP_KERNEL); | |
| 93 | 93 | if (!msi_data->msi_virqs) |
| 94 | 94 | return -ENOMEM; |
| 95 | 95 | |
| @@ -1449,7 +1449,7 @@ static int __init ppc4xx_pciex_check_core_init(struct device_node *np) · 1448 unmodified lines | ||
| 1449 | 1449 | count = ppc4xx_pciex_hwops->core_init(np); |
| 1450 | 1450 | if (count > 0) { |
| 1451 | 1451 | ppc4xx_pciex_ports = |
| 1452 | − kzalloc(count * sizeof(struct ppc4xx_pciex_port), | |
| 1452 | + kcalloc(count, sizeof(struct ppc4xx_pciex_port), | |
| 1453 | 1453 | GFP_KERNEL); |
| 1454 | 1454 | if (ppc4xx_pciex_ports) { |
| 1455 | 1455 | ppc4xx_pciex_port_count = count; |
| @@ -198,21 +198,21 @@ void __init opal_sys_param_init(void) · 197 unmodified lines | ||
| 198 | 198 | goto out_param_buf; |
| 199 | 199 | } |
| 200 | 200 | |
| 201 | − id = kzalloc(sizeof(*id) * count, GFP_KERNEL); | |
| 201 | + id = kcalloc(count, sizeof(*id), GFP_KERNEL); | |
| 202 | 202 | if (!id) { |
| 203 | 203 | pr_err("SYSPARAM: Failed to allocate memory to read parameter " |
| 204 | 204 | "id\n"); |
| 205 | 205 | goto out_param_buf; |
| 206 | 206 | } |
| 207 | 207 | |
| 208 | − size = kzalloc(sizeof(*size) * count, GFP_KERNEL); | |
| 208 | + size = kcalloc(count, sizeof(*size), GFP_KERNEL); | |
| 209 | 209 | if (!size) { |
| 210 | 210 | pr_err("SYSPARAM: Failed to allocate memory to read parameter " |
| 211 | 211 | "size\n"); |
| 212 | 212 | goto out_free_id; |
| 213 | 213 | } |
| 214 | 214 | |
| 215 | − perm = kzalloc(sizeof(*perm) * count, GFP_KERNEL); | |
| 215 | + perm = kcalloc(count, sizeof(*perm), GFP_KERNEL); | |
| 216 | 216 | if (!perm) { |
| 217 | 217 | pr_err("SYSPARAM: Failed to allocate memory to read supported " |
| 218 | 218 | "action on the parameter"); |
| @@ -235,7 +235,7 @@ void __init opal_sys_param_init(void) · 16 unmodified lines | ||
| 235 | 235 | goto out_free_perm; |
| 236 | 236 | } |
| 237 | 237 | |
| 238 | − attr = kzalloc(sizeof(*attr) * count, GFP_KERNEL); | |
| 238 | + attr = kcalloc(count, sizeof(*attr), GFP_KERNEL); | |
| 239 | 239 | if (!attr) { |
| 240 | 240 | pr_err("SYSPARAM: Failed to allocate memory for parameter " |
| 241 | 241 | "attributes\n"); |
| @@ -544,7 +544,7 @@ static void __init mpic_scan_ht_pics(struct mpic *mpic) · 543 unmodified lines | ||
| 544 | 544 | printk(KERN_INFO "mpic: Setting up HT PICs workarounds for U3/U4\n"); |
| 545 | 545 | |
| 546 | 546 | /* Allocate fixups array */ |
| 547 | − mpic->fixups = kzalloc(128 * sizeof(*mpic->fixups), GFP_KERNEL); | |
| 547 | + mpic->fixups = kcalloc(128, sizeof(*mpic->fixups), GFP_KERNEL); | |
| 548 | 548 | BUG_ON(mpic->fixups == NULL); |
| 549 | 549 | |
| 550 | 550 | /* Init spinlock */ |
| @@ -1324,7 +1324,7 @@ struct mpic * __init mpic_alloc(struct device_node *node, · 773 unmodified lines | ||
| 1324 | 1324 | if (psrc) { |
| 1325 | 1325 | /* Allocate a bitmap with one bit per interrupt */ |
| 1326 | 1326 | unsigned int mapsize = BITS_TO_LONGS(intvec_top + 1); |
| 1327 | − mpic->protected = kzalloc(mapsize*sizeof(long), GFP_KERNEL); | |
| 1327 | + mpic->protected = kcalloc(mapsize, sizeof(long), GFP_KERNEL); | |
| 1328 | 1328 | BUG_ON(mpic->protected == NULL); |
| 1329 | 1329 | for (i = 0; i < psize/sizeof(u32); i++) { |
| 1330 | 1330 | if (psrc[i] > intvec_top) |
| @@ -1639,8 +1639,9 @@ void __init mpic_init(struct mpic *mpic) · 308 unmodified lines | ||
| 1639 | 1639 | |
| 1640 | 1640 | #ifdef CONFIG_PM |
| 1641 | 1641 | /* allocate memory to save mpic state */ |
| 1642 | − mpic->save_data = kmalloc(mpic->num_sources * sizeof(*mpic->save_data), | |
| 1643 | − GFP_KERNEL); | |
| 1642 | + mpic->save_data = kmalloc_array(mpic->num_sources, | |
| 1643 | + sizeof(*mpic->save_data), | |
| 1644 | + GFP_KERNEL); | |
| 1644 | 1645 | BUG_ON(mpic->save_data == NULL); |
| 1645 | 1646 | #endif |
| 1646 | 1647 | |
| @@ -489,7 +489,7 @@ static bool xive_parse_provisioning(struct device_node *np) · 488 unmodified lines | ||
| 489 | 489 | if (rc == 0) |
| 490 | 490 | return true; |
| 491 | 491 | |
| 492 | − xive_provision_chips = kzalloc(4 * xive_provision_chip_count, | |
| 492 | + xive_provision_chips = kcalloc(4, xive_provision_chip_count, | |
| 493 | 493 | GFP_KERNEL); |
| 494 | 494 | if (WARN_ON(!xive_provision_chips)) |
| 495 | 495 | return false; |
| @@ -391,7 +391,7 @@ int appldata_register_ops(struct appldata_ops *ops) · 390 unmodified lines | ||
| 391 | 391 | if (ops->size > APPLDATA_MAX_REC_SIZE) |
| 392 | 392 | return -EINVAL; |
| 393 | 393 | |
| 394 | − ops->ctl_table = kzalloc(4 * sizeof(struct ctl_table), GFP_KERNEL); | |
| 394 | + ops->ctl_table = kcalloc(4, sizeof(struct ctl_table), GFP_KERNEL); | |
| 395 | 395 | if (!ops->ctl_table) |
| 396 | 396 | return -ENOMEM; |
| 397 | 397 | |
| @@ -239,7 +239,7 @@ static void *page_align_ptr(void *ptr) · 238 unmodified lines | ||
| 239 | 239 | static void *diag204_alloc_vbuf(int pages) |
| 240 | 240 | { |
| 241 | 241 | /* The buffer has to be page aligned! */ |
| 242 | − diag204_buf_vmalloc = vmalloc(PAGE_SIZE * (pages + 1)); | |
| 242 | + diag204_buf_vmalloc = vmalloc(array_size(PAGE_SIZE, (pages + 1))); | |
| 243 | 243 | if (!diag204_buf_vmalloc) |
| 244 | 244 | return ERR_PTR(-ENOMEM); |
| 245 | 245 | diag204_buf = page_align_ptr(diag204_buf_vmalloc); |
| @@ -49,7 +49,8 @@ static void *diag0c_store(unsigned int *count) · 48 unmodified lines | ||
| 49 | 49 | |
| 50 | 50 | get_online_cpus(); |
| 51 | 51 | cpu_count = num_online_cpus(); |
| 52 | − cpu_vec = kmalloc(sizeof(*cpu_vec) * num_possible_cpus(), GFP_KERNEL); | |
| 52 | + cpu_vec = kmalloc_array(num_possible_cpus(), sizeof(*cpu_vec), | |
| 53 | + GFP_KERNEL); | |
| 53 | 54 | if (!cpu_vec) |
| 54 | 55 | goto fail_put_online_cpus; |
| 55 | 56 | /* Note: Diag 0c needs 8 byte alignment and real storage */ |
| @@ -194,11 +194,13 @@ static debug_entry_t ***debug_areas_alloc(int pages_per_area, int nr_areas) · 193 unmodified lines | ||
| 194 | 194 | debug_entry_t ***areas; |
| 195 | 195 | int i, j; |
| 196 | 196 | |
| 197 | − areas = kmalloc(nr_areas * sizeof(debug_entry_t **), GFP_KERNEL); | |
| 197 | + areas = kmalloc_array(nr_areas, sizeof(debug_entry_t **), GFP_KERNEL); | |
| 198 | 198 | if (!areas) |
| 199 | 199 | goto fail_malloc_areas; |
| 200 | 200 | for (i = 0; i < nr_areas; i++) { |
| 201 | − areas[i] = kmalloc(pages_per_area * sizeof(debug_entry_t *), GFP_KERNEL); | |
| 201 | + areas[i] = kmalloc_array(pages_per_area, | |
| 202 | + sizeof(debug_entry_t *), | |
| 203 | + GFP_KERNEL); | |
| 202 | 204 | if (!areas[i]) |
| 203 | 205 | goto fail_malloc_areas2; |
| 204 | 206 | for (j = 0; j < pages_per_area; j++) { |
| @@ -123,8 +123,8 @@ int module_frob_arch_sections(Elf_Ehdr *hdr, Elf_Shdr *sechdrs, · 122 unmodified lines | ||
| 123 | 123 | |
| 124 | 124 | /* Allocate one syminfo structure per symbol. */ |
| 125 | 125 | me->arch.nsyms = symtab->sh_size / sizeof(Elf_Sym); |
| 126 | − me->arch.syminfo = vmalloc(me->arch.nsyms * | |
| 127 | − sizeof(struct mod_arch_syminfo)); | |
| 126 | + me->arch.syminfo = vmalloc(array_size(sizeof(struct mod_arch_syminfo), | |
| 127 | + me->arch.nsyms)); | |
| 128 | 128 | if (!me->arch.syminfo) |
| 129 | 129 | return -ENOMEM; |
| 130 | 130 | symbols = (void *) hdr + symtab->sh_offset; |
| @@ -527,7 +527,7 @@ static __init struct attribute **merge_attr(struct attribute **a, · 526 unmodified lines | ||
| 527 | 527 | j++; |
| 528 | 528 | j++; |
| 529 | 529 | |
| 530 | − new = kmalloc(sizeof(struct attribute *) * j, GFP_KERNEL); | |
| 530 | + new = kmalloc_array(j, sizeof(struct attribute *), GFP_KERNEL); | |
| 531 | 531 | if (!new) |
| 532 | 532 | return NULL; |
| 533 | 533 | j = 0; |
| @@ -315,7 +315,7 @@ static void fill_diag(struct sthyi_sctns *sctns) · 314 unmodified lines | ||
| 315 | 315 | if (pages <= 0) |
| 316 | 316 | return; |
| 317 | 317 | |
| 318 | − diag204_buf = vmalloc(PAGE_SIZE * pages); | |
| 318 | + diag204_buf = vmalloc(array_size(pages, PAGE_SIZE)); | |
| 319 | 319 | if (!diag204_buf) |
| 320 | 320 | return; |
| 321 | 321 | |
| @@ -285,7 +285,7 @@ static int __init vdso_init(void) · 284 unmodified lines | ||
| 285 | 285 | + PAGE_SIZE - 1) >> PAGE_SHIFT) + 1; |
| 286 | 286 | |
| 287 | 287 | /* Make sure pages are in the correct state */ |
| 288 | − vdso32_pagelist = kzalloc(sizeof(struct page *) * (vdso32_pages + 1), | |
| 288 | + vdso32_pagelist = kcalloc(vdso32_pages + 1, sizeof(struct page *), | |
| 289 | 289 | GFP_KERNEL); |
| 290 | 290 | BUG_ON(vdso32_pagelist == NULL); |
| 291 | 291 | for (i = 0; i < vdso32_pages - 1; i++) { |
| @@ -303,7 +303,7 @@ static int __init vdso_init(void) · 11 unmodified lines | ||
| 303 | 303 | + PAGE_SIZE - 1) >> PAGE_SHIFT) + 1; |
| 304 | 304 | |
| 305 | 305 | /* Make sure pages are in the correct state */ |
| 306 | − vdso64_pagelist = kzalloc(sizeof(struct page *) * (vdso64_pages + 1), | |
| 306 | + vdso64_pagelist = kcalloc(vdso64_pages + 1, sizeof(struct page *), | |
| 307 | 307 | GFP_KERNEL); |
| 308 | 308 | BUG_ON(vdso64_pagelist == NULL); |
| 309 | 309 | for (i = 0; i < vdso64_pages - 1; i++) { |
| @@ -847,7 +847,7 @@ int access_guest(struct kvm_vcpu *vcpu, unsigned long ga, u8 ar, void *data, · 846 unmodified lines | ||
| 847 | 847 | nr_pages = (((ga & ~PAGE_MASK) + len - 1) >> PAGE_SHIFT) + 1; |
| 848 | 848 | pages = pages_array; |
| 849 | 849 | if (nr_pages > ARRAY_SIZE(pages_array)) |
| 850 | − pages = vmalloc(nr_pages * sizeof(unsigned long)); | |
| 850 | + pages = vmalloc(array_size(nr_pages, sizeof(unsigned long))); | |
| 851 | 851 | if (!pages) |
| 852 | 852 | return -ENOMEM; |
| 853 | 853 | need_ipte_lock = psw_bits(*psw).dat && !asce.r; |
| @@ -1729,7 +1729,7 @@ static int kvm_s390_set_cmma_bits(struct kvm *kvm, · 1728 unmodified lines | ||
| 1729 | 1729 | if (args->count == 0) |
| 1730 | 1730 | return 0; |
| 1731 | 1731 | |
| 1732 | − bits = vmalloc(sizeof(*bits) * args->count); | |
| 1732 | + bits = vmalloc(array_size(sizeof(*bits), args->count)); | |
| 1733 | 1733 | if (!bits) |
| 1734 | 1734 | return -ENOMEM; |
| 1735 | 1735 | |
| @@ -103,7 +103,7 @@ static int scode_set; · 102 unmodified lines | ||
| 103 | 103 | static int |
| 104 | 104 | dcss_set_subcodes(void) |
| 105 | 105 | { |
| 106 | − char *name = kmalloc(8 * sizeof(char), GFP_KERNEL | GFP_DMA); | |
| 106 | + char *name = kmalloc(8, GFP_KERNEL | GFP_DMA); | |
| 107 | 107 | unsigned long rx, ry; |
| 108 | 108 | int rc; |
| 109 | 109 | |
| @@ -154,7 +154,7 @@ static int __init dmabrg_init(void) · 153 unmodified lines | ||
| 154 | 154 | unsigned long or; |
| 155 | 155 | int ret; |
| 156 | 156 | |
| 157 | − dmabrg_handlers = kzalloc(10 * sizeof(struct dmabrg_handler), | |
| 157 | + dmabrg_handlers = kcalloc(10, sizeof(struct dmabrg_handler), | |
| 158 | 158 | GFP_KERNEL); |
| 159 | 159 | if (!dmabrg_handlers) |
| 160 | 160 | return -ENOMEM; |
| @@ -561,7 +561,7 @@ static int __init sh7786_pcie_init(void) · 560 unmodified lines | ||
| 561 | 561 | if (unlikely(nr_ports == 0)) |
| 562 | 562 | return -ENODEV; |
| 563 | 563 | |
| 564 | − sh7786_pcie_ports = kzalloc(nr_ports * sizeof(struct sh7786_pcie_port), | |
| 564 | + sh7786_pcie_ports = kcalloc(nr_ports, sizeof(struct sh7786_pcie_port), | |
| 565 | 565 | GFP_KERNEL); |
| 566 | 566 | if (unlikely(!sh7786_pcie_ports)) |
| 567 | 567 | return -ENOMEM; |
| @@ -166,7 +166,8 @@ static int __init check_nmi_watchdog(void) · 165 unmodified lines | ||
| 166 | 166 | if (!atomic_read(&nmi_active)) |
| 167 | 167 | return 0; |
| 168 | 168 | |
| 169 | − prev_nmi_count = kmalloc(nr_cpu_ids * sizeof(unsigned int), GFP_KERNEL); | |
| 169 | + prev_nmi_count = kmalloc_array(nr_cpu_ids, sizeof(unsigned int), | |
| 170 | + GFP_KERNEL); | |
| 170 | 171 | if (!prev_nmi_count) { |
| 171 | 172 | err = -ENOMEM; |
| 172 | 173 | goto error; |
| @@ -565,7 +565,8 @@ SYSCALL_DEFINE5(utrap_install, utrap_entry_t, type, · 564 unmodified lines | ||
| 565 | 565 | } |
| 566 | 566 | if (!current_thread_info()->utraps) { |
| 567 | 567 | current_thread_info()->utraps = |
| 568 | − kzalloc((UT_TRAP_INSTRUCTION_31+1)*sizeof(long), GFP_KERNEL); | |
| 568 | + kcalloc(UT_TRAP_INSTRUCTION_31 + 1, sizeof(long), | |
| 569 | + GFP_KERNEL); | |
| 569 | 570 | if (!current_thread_info()->utraps) |
| 570 | 571 | return -ENOMEM; |
| 571 | 572 | current_thread_info()->utraps[0] = 1; |
| @@ -575,8 +576,9 @@ SYSCALL_DEFINE5(utrap_install, utrap_entry_t, type, · 3 unmodified lines | ||
| 575 | 576 | unsigned long *p = current_thread_info()->utraps; |
| 576 | 577 | |
| 577 | 578 | current_thread_info()->utraps = |
| 578 | − kmalloc((UT_TRAP_INSTRUCTION_31+1)*sizeof(long), | |
| 579 | − GFP_KERNEL); | |
| 579 | + kmalloc_array(UT_TRAP_INSTRUCTION_31 + 1, | |
| 580 | + sizeof(long), | |
| 581 | + GFP_KERNEL); | |
| 580 | 582 | if (!current_thread_info()->utraps) { |
| 581 | 583 | current_thread_info()->utraps = p; |
| 582 | 584 | return -ENOMEM; |
| @@ -335,7 +335,7 @@ void bpf_jit_compile(struct bpf_prog *fp) · 334 unmodified lines | ||
| 335 | 335 | if (!bpf_jit_enable) |
| 336 | 336 | return; |
| 337 | 337 | |
| 338 | − addrs = kmalloc(flen * sizeof(*addrs), GFP_KERNEL); | |
| 338 | + addrs = kmalloc_array(flen, sizeof(*addrs), GFP_KERNEL); | |
| 339 | 339 | if (addrs == NULL) |
| 340 | 340 | return; |
| 341 | 341 | |
| @@ -1127,9 +1127,9 @@ static int __init ubd_init(void) · 1126 unmodified lines | ||
| 1127 | 1127 | return -1; |
| 1128 | 1128 | } |
| 1129 | 1129 | |
| 1130 | − irq_req_buffer = kmalloc( | |
| 1131 | − sizeof(struct io_thread_req *) * UBD_REQ_BUFFER_SIZE, | |
| 1132 | − GFP_KERNEL | |
| 1130 | + irq_req_buffer = kmalloc_array(UBD_REQ_BUFFER_SIZE, | |
| 1131 | + sizeof(struct io_thread_req *), | |
| 1132 | + GFP_KERNEL | |
| 1133 | 1133 | ); |
| 1134 | 1134 | irq_remainder = 0; |
| 1135 | 1135 | |
| @@ -1137,9 +1137,9 @@ static int __init ubd_init(void) · 1 unmodified line | ||
| 1137 | 1137 | printk(KERN_ERR "Failed to initialize ubd buffering\n"); |
| 1138 | 1138 | return -1; |
| 1139 | 1139 | } |
| 1140 | − io_req_buffer = kmalloc( | |
| 1141 | − sizeof(struct io_thread_req *) * UBD_REQ_BUFFER_SIZE, | |
| 1142 | − GFP_KERNEL | |
| 1140 | + io_req_buffer = kmalloc_array(UBD_REQ_BUFFER_SIZE, | |
| 1141 | + sizeof(struct io_thread_req *), | |
| 1142 | + GFP_KERNEL | |
| 1143 | 1143 | ); |
| 1144 | 1144 | |
| 1145 | 1145 | io_remainder = 0; |
| @@ -527,14 +527,14 @@ static struct vector_queue *create_queue( · 526 unmodified lines | ||
| 527 | 527 | result->max_iov_frags = num_extra_frags; |
| 528 | 528 | for (i = 0; i < max_size; i++) { |
| 529 | 529 | if (vp->header_size > 0) |
| 530 | − iov = kmalloc( | |
| 531 | − sizeof(struct iovec) * (3 + num_extra_frags), | |
| 532 | − GFP_KERNEL | |
| 530 | + iov = kmalloc_array(3 + num_extra_frags, | |
| 531 | + sizeof(struct iovec), | |
| 532 | + GFP_KERNEL | |
| 533 | 533 | ); |
| 534 | 534 | else |
| 535 | − iov = kmalloc( | |
| 536 | − sizeof(struct iovec) * (2 + num_extra_frags), | |
| 537 | − GFP_KERNEL | |
| 535 | + iov = kmalloc_array(2 + num_extra_frags, | |
| 536 | + sizeof(struct iovec), | |
| 537 | + GFP_KERNEL | |
| 538 | 538 | ); |
| 539 | 539 | if (iov == NULL) |
| 540 | 540 | goto out_fail; |
| @@ -109,8 +109,9 @@ static int __init puv3_pm_init(void) · 108 unmodified lines | ||
| 109 | 109 | return -EINVAL; |
| 110 | 110 | } |
| 111 | 111 | |
| 112 | − sleep_save = kmalloc(puv3_cpu_pm_fns->save_count | |
| 113 | − * sizeof(unsigned long), GFP_KERNEL); | |
| 112 | + sleep_save = kmalloc_array(puv3_cpu_pm_fns->save_count, | |
| 113 | + sizeof(unsigned long), | |
| 114 | + GFP_KERNEL); | |
| 114 | 115 | if (!sleep_save) { |
| 115 | 116 | printk(KERN_ERR "failed to alloc memory for pm save\n"); |
| 116 | 117 | return -ENOMEM; |
| @@ -387,7 +387,7 @@ static __init int _init_events_attrs(void) · 386 unmodified lines | ||
| 387 | 387 | while (amd_iommu_v2_event_descs[i].attr.attr.name) |
| 388 | 388 | i++; |
| 389 | 389 | |
| 390 | − attrs = kzalloc(sizeof(struct attribute **) * (i + 1), GFP_KERNEL); | |
| 390 | + attrs = kcalloc(i + 1, sizeof(struct attribute **), GFP_KERNEL); | |
| 391 | 391 | if (!attrs) |
| 392 | 392 | return -ENOMEM; |
| 393 | 393 | |
| @@ -1637,7 +1637,7 @@ __init struct attribute **merge_attr(struct attribute **a, struct attribute **b) · 1636 unmodified lines | ||
| 1637 | 1637 | j++; |
| 1638 | 1638 | j++; |
| 1639 | 1639 | |
| 1640 | − new = kmalloc(sizeof(struct attribute *) * j, GFP_KERNEL); | |
| 1640 | + new = kmalloc_array(j, sizeof(struct attribute *), GFP_KERNEL); | |
| 1641 | 1641 | if (!new) |
| 1642 | 1642 | return NULL; |
| 1643 | 1643 | |
| @@ -865,12 +865,10 @@ static void uncore_types_exit(struct intel_uncore_type **types) · 864 unmodified lines | ||
| 865 | 865 | static int __init uncore_type_init(struct intel_uncore_type *type, bool setid) |
| 866 | 866 | { |
| 867 | 867 | struct intel_uncore_pmu *pmus; |
| 868 | − struct attribute_group *attr_group; | |
| 869 | − struct attribute **attrs; | |
| 870 | 868 | size_t size; |
| 871 | 869 | int i, j; |
| 872 | 870 | |
| 873 | − pmus = kzalloc(sizeof(*pmus) * type->num_boxes, GFP_KERNEL); | |
| 871 | + pmus = kcalloc(type->num_boxes, sizeof(*pmus), GFP_KERNEL); | |
| 874 | 872 | if (!pmus) |
| 875 | 873 | return -ENOMEM; |
| 876 | 874 | |
| @@ -891,21 +889,24 @@ static int __init uncore_type_init(struct intel_uncore_type *type, bool setid) · 14 unmodified lines | ||
| 891 | 889 | 0, type->num_counters, 0, 0); |
| 892 | 890 | |
| 893 | 891 | if (type->event_descs) { |
| 892 | + struct { | |
| 893 | + struct attribute_group group; | |
| 894 | + struct attribute *attrs[]; | |
| 895 | + } *attr_group; | |
| 894 | 896 | for (i = 0; type->event_descs[i].attr.attr.name; i++); |
| 895 | 897 | |
| 896 | − attr_group = kzalloc(sizeof(struct attribute *) * (i + 1) + | |
| 897 | − sizeof(*attr_group), GFP_KERNEL); | |
| 898 | + attr_group = kzalloc(struct_size(attr_group, attrs, i + 1), | |
| 899 | + GFP_KERNEL); | |
| 898 | 900 | if (!attr_group) |
| 899 | 901 | goto err; |
| 900 | 902 | |
| 901 | − attrs = (struct attribute **)(attr_group + 1); | |
| 902 | − attr_group->name = "events"; | |
| 903 | − attr_group->attrs = attrs; | |
| 903 | + attr_group->group.name = "events"; | |
| 904 | + attr_group->group.attrs = attr_group->attrs; | |
| 904 | 905 | |
| 905 | 906 | for (j = 0; j < i; j++) |
| 906 | − attrs[j] = &type->event_descs[j].attr.attr; | |
| 907 | + attr_group->attrs[j] = &type->event_descs[j].attr.attr; | |
| 907 | 908 | |
| 908 | − type->events_group = attr_group; | |
| 909 | + type->events_group = &attr_group->group; | |
| 909 | 910 | } |
| 910 | 911 | |
| 911 | 912 | type->pmu_group = &uncore_pmu_attr_group; |
| @@ -1457,7 +1457,7 @@ static int __mcheck_cpu_mce_banks_init(void) · 1456 unmodified lines | ||
| 1457 | 1457 | int i; |
| 1458 | 1458 | u8 num_banks = mca_cfg.banks; |
| 1459 | 1459 | |
| 1460 | − mce_banks = kzalloc(num_banks * sizeof(struct mce_bank), GFP_KERNEL); | |
| 1460 | + mce_banks = kcalloc(num_banks, sizeof(struct mce_bank), GFP_KERNEL); | |
| 1461 | 1461 | if (!mce_banks) |
| 1462 | 1462 | return -ENOMEM; |
| 1463 | 1463 | |
| @@ -1384,7 +1384,7 @@ int mce_threshold_create_device(unsigned int cpu) · 1383 unmodified lines | ||
| 1384 | 1384 | if (bp) |
| 1385 | 1385 | return 0; |
| 1386 | 1386 | |
| 1387 | − bp = kzalloc(sizeof(struct threshold_bank *) * mca_cfg.banks, | |
| 1387 | + bp = kcalloc(mca_cfg.banks, sizeof(struct threshold_bank *), | |
| 1388 | 1388 | GFP_KERNEL); |
| 1389 | 1389 | if (!bp) |
| 1390 | 1390 | return -ENOMEM; |
| @@ -43,7 +43,7 @@ mtrr_file_add(unsigned long base, unsigned long size, · 42 unmodified lines | ||
| 43 | 43 | |
| 44 | 44 | max = num_var_ranges; |
| 45 | 45 | if (fcount == NULL) { |
| 46 | − fcount = kzalloc(max * sizeof *fcount, GFP_KERNEL); | |
| 46 | + fcount = kcalloc(max, sizeof(*fcount), GFP_KERNEL); | |
| 47 | 47 | if (!fcount) |
| 48 | 48 | return -ENOMEM; |
| 49 | 49 | FILE_FCOUNT(file) = fcount; |
| @@ -610,7 +610,7 @@ static void hpet_msi_capability_lookup(unsigned int start_timer) · 609 unmodified lines | ||
| 610 | 610 | if (!hpet_domain) |
| 611 | 611 | return; |
| 612 | 612 | |
| 613 | − hpet_devs = kzalloc(sizeof(struct hpet_dev) * num_timers, GFP_KERNEL); | |
| 613 | + hpet_devs = kcalloc(num_timers, sizeof(struct hpet_dev), GFP_KERNEL); | |
| 614 | 614 | if (!hpet_devs) |
| 615 | 615 | return; |
| 616 | 616 | |
| @@ -966,8 +966,8 @@ int __init hpet_enable(void) · 349 unmodified lines | ||
| 966 | 966 | #endif |
| 967 | 967 | |
| 968 | 968 | cfg = hpet_readl(HPET_CFG); |
| 969 | − hpet_boot_cfg = kmalloc((last + 2) * sizeof(*hpet_boot_cfg), | |
| 970 | − GFP_KERNEL); | |
| 969 | + hpet_boot_cfg = kmalloc_array(last + 2, sizeof(*hpet_boot_cfg), | |
| 970 | + GFP_KERNEL); | |
| 971 | 971 | if (hpet_boot_cfg) |
| 972 | 972 | *hpet_boot_cfg = cfg; |
| 973 | 973 | else |
| @@ -283,7 +283,7 @@ static int __init create_setup_data_nodes(struct kobject *parent) · 282 unmodified lines | ||
| 283 | 283 | if (ret) |
| 284 | 284 | goto out_setup_data_kobj; |
| 285 | 285 | |
| 286 | − kobjp = kmalloc(sizeof(*kobjp) * nr, GFP_KERNEL); | |
| 286 | + kobjp = kmalloc_array(nr, sizeof(*kobjp), GFP_KERNEL); | |
| 287 | 287 | if (!kobjp) { |
| 288 | 288 | ret = -ENOMEM; |
| 289 | 289 | goto out_setup_data_kobj; |
| @@ -203,8 +203,9 @@ int kvm_vcpu_ioctl_set_cpuid(struct kvm_vcpu *vcpu, · 202 unmodified lines | ||
| 203 | 203 | goto out; |
| 204 | 204 | r = -ENOMEM; |
| 205 | 205 | if (cpuid->nent) { |
| 206 | − cpuid_entries = vmalloc(sizeof(struct kvm_cpuid_entry) * | |
| 207 | − cpuid->nent); | |
| 206 | + cpuid_entries = | |
| 207 | + vmalloc(array_size(sizeof(struct kvm_cpuid_entry), | |
| 208 | + cpuid->nent)); | |
| 208 | 209 | if (!cpuid_entries) |
| 209 | 210 | goto out; |
| 210 | 211 | r = -EFAULT; |
| @@ -785,7 +786,8 @@ int kvm_dev_ioctl_get_cpuid(struct kvm_cpuid2 *cpuid, · 574 unmodified lines | ||
| 785 | 786 | return -EINVAL; |
| 786 | 787 | |
| 787 | 788 | r = -ENOMEM; |
| 788 | − cpuid_entries = vzalloc(sizeof(struct kvm_cpuid_entry2) * cpuid->nent); | |
| 789 | + cpuid_entries = vzalloc(array_size(sizeof(struct kvm_cpuid_entry2), | |
| 790 | + cpuid->nent)); | |
| 789 | 791 | if (!cpuid_entries) |
| 790 | 792 | goto out; |
| 791 | 793 | |
| @@ -40,8 +40,9 @@ int kvm_page_track_create_memslot(struct kvm_memory_slot *slot, · 39 unmodified lines | ||
| 40 | 40 | int i; |
| 41 | 41 | |
| 42 | 42 | for (i = 0; i < KVM_PAGE_TRACK_MAX; i++) { |
| 43 | − slot->arch.gfn_track[i] = kvzalloc(npages * | |
| 44 | − sizeof(*slot->arch.gfn_track[i]), GFP_KERNEL); | |
| 43 | + slot->arch.gfn_track[i] = | |
| 44 | + kvcalloc(npages, sizeof(*slot->arch.gfn_track[i]), | |
| 45 | + GFP_KERNEL); | |
| 45 | 46 | if (!slot->arch.gfn_track[i]) |
| 46 | 47 | goto track_free; |
| 47 | 48 | } |
| @@ -1001,7 +1001,9 @@ static int svm_cpu_init(int cpu) · 1000 unmodified lines | ||
| 1001 | 1001 | |
| 1002 | 1002 | if (svm_sev_enabled()) { |
| 1003 | 1003 | r = -ENOMEM; |
| 1004 | − sd->sev_vmcbs = kmalloc((max_sev_asid + 1) * sizeof(void *), GFP_KERNEL); | |
| 1004 | + sd->sev_vmcbs = kmalloc_array(max_sev_asid + 1, | |
| 1005 | + sizeof(void *), | |
| 1006 | + GFP_KERNEL); | |
| 1005 | 1007 | if (!sd->sev_vmcbs) |
| 1006 | 1008 | goto err_1; |
| 1007 | 1009 | } |
| @@ -8900,13 +8900,14 @@ int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot, · 8899 unmodified lines | ||
| 8900 | 8900 | slot->base_gfn, level) + 1; |
| 8901 | 8901 | |
| 8902 | 8902 | slot->arch.rmap[i] = |
| 8903 | − kvzalloc(lpages * sizeof(*slot->arch.rmap[i]), GFP_KERNEL); | |
| 8903 | + kvcalloc(lpages, sizeof(*slot->arch.rmap[i]), | |
| 8904 | + GFP_KERNEL); | |
| 8904 | 8905 | if (!slot->arch.rmap[i]) |
| 8905 | 8906 | goto out_free; |
| 8906 | 8907 | if (i == 0) |
| 8907 | 8908 | continue; |
| 8908 | 8909 | |
| 8909 | − linfo = kvzalloc(lpages * sizeof(*linfo), GFP_KERNEL); | |
| 8910 | + linfo = kvcalloc(lpages, sizeof(*linfo), GFP_KERNEL); | |
| 8910 | 8911 | if (!linfo) |
| 8911 | 8912 | goto out_free; |
| 8912 | 8913 | |
| @@ -1107,7 +1107,7 @@ struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *prog) · 1106 unmodified lines | ||
| 1107 | 1107 | extra_pass = true; |
| 1108 | 1108 | goto skip_init_addrs; |
| 1109 | 1109 | } |
| 1110 | − addrs = kmalloc(prog->len * sizeof(*addrs), GFP_KERNEL); | |
| 1110 | + addrs = kmalloc_array(prog->len, sizeof(*addrs), GFP_KERNEL); | |
| 1111 | 1111 | if (!addrs) { |
| 1112 | 1112 | prog = orig_prog; |
| 1113 | 1113 | goto out_addrs; |
| @@ -2345,7 +2345,7 @@ struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *prog) · 2344 unmodified lines | ||
| 2345 | 2345 | prog = tmp; |
| 2346 | 2346 | } |
| 2347 | 2347 | |
| 2348 | − addrs = kmalloc(prog->len * sizeof(*addrs), GFP_KERNEL); | |
| 2348 | + addrs = kmalloc_array(prog->len, sizeof(*addrs), GFP_KERNEL); | |
| 2349 | 2349 | if (!addrs) { |
| 2350 | 2350 | prog = orig_prog; |
| 2351 | 2351 | goto out; |
| @@ -168,7 +168,7 @@ static int xen_setup_msi_irqs(struct pci_dev *dev, int nvec, int type) · 167 unmodified lines | ||
| 168 | 168 | if (type == PCI_CAP_ID_MSI && nvec > 1) |
| 169 | 169 | return 1; |
| 170 | 170 | |
| 171 | − v = kzalloc(sizeof(int) * max(1, nvec), GFP_KERNEL); | |
| 171 | + v = kcalloc(max(1, nvec), sizeof(int), GFP_KERNEL); | |
| 172 | 172 | if (!v) |
| 173 | 173 | return -ENOMEM; |
| 174 | 174 | |
| @@ -2142,7 +2142,7 @@ static int __init init_per_cpu(int nuvhubs, int base_part_pnode) · 2141 unmodified lines | ||
| 2142 | 2142 | if (is_uv3_hub() || is_uv2_hub() || is_uv1_hub()) |
| 2143 | 2143 | timeout_us = calculate_destination_timeout(); |
| 2144 | 2144 | |
| 2145 | − vp = kmalloc(nuvhubs * sizeof(struct uvhub_desc), GFP_KERNEL); | |
| 2145 | + vp = kmalloc_array(nuvhubs, sizeof(struct uvhub_desc), GFP_KERNEL); | |
| 2146 | 2146 | uvhub_descs = (struct uvhub_desc *)vp; |
| 2147 | 2147 | memset(uvhub_descs, 0, nuvhubs * sizeof(struct uvhub_desc)); |
| 2148 | 2148 | uvhub_mask = kzalloc((nuvhubs+7)/8, GFP_KERNEL); |
| @@ -158,7 +158,7 @@ static __init int uv_rtc_allocate_timers(void) · 157 unmodified lines | ||
| 158 | 158 | { |
| 159 | 159 | int cpu; |
| 160 | 160 | |
| 161 | − blade_info = kzalloc(uv_possible_blades * sizeof(void *), GFP_KERNEL); | |
| 161 | + blade_info = kcalloc(uv_possible_blades, sizeof(void *), GFP_KERNEL); | |
| 162 | 162 | if (!blade_info) |
| 163 | 163 | return -ENOMEM; |
| 164 | 164 | |
| @@ -2091,7 +2091,8 @@ static int __init init_bio(void) · 2090 unmodified lines | ||
| 2091 | 2091 | { |
| 2092 | 2092 | bio_slab_max = 2; |
| 2093 | 2093 | bio_slab_nr = 0; |
| 2094 | − bio_slabs = kzalloc(bio_slab_max * sizeof(struct bio_slab), GFP_KERNEL); | |
| 2094 | + bio_slabs = kcalloc(bio_slab_max, sizeof(struct bio_slab), | |
| 2095 | + GFP_KERNEL); | |
| 2095 | 2096 | if (!bio_slabs) |
| 2096 | 2097 | panic("bio: can't allocate bios\n"); |
| 2097 | 2098 | |
| @@ -1903,7 +1903,7 @@ struct blk_mq_tags *blk_mq_alloc_rq_map(struct blk_mq_tag_set *set, · 1902 unmodified lines | ||
| 1903 | 1903 | if (!tags) |
| 1904 | 1904 | return NULL; |
| 1905 | 1905 | |
| 1906 | − tags->rqs = kzalloc_node(nr_tags * sizeof(struct request *), | |
| 1906 | + tags->rqs = kcalloc_node(nr_tags, sizeof(struct request *), | |
| 1907 | 1907 | GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY, |
| 1908 | 1908 | node); |
| 1909 | 1909 | if (!tags->rqs) { |
| @@ -1911,9 +1911,9 @@ struct blk_mq_tags *blk_mq_alloc_rq_map(struct blk_mq_tag_set *set, · 1 unmodified line | ||
| 1911 | 1911 | return NULL; |
| 1912 | 1912 | } |
| 1913 | 1913 | |
| 1914 | − tags->static_rqs = kzalloc_node(nr_tags * sizeof(struct request *), | |
| 1915 | − GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY, | |
| 1916 | − node); | |
| 1914 | + tags->static_rqs = kcalloc_node(nr_tags, sizeof(struct request *), | |
| 1915 | + GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY, | |
| 1916 | + node); | |
| 1917 | 1917 | if (!tags->static_rqs) { |
| 1918 | 1918 | kfree(tags->rqs); |
| 1919 | 1919 | blk_mq_free_tags(tags); |
| @@ -2522,7 +2522,7 @@ struct request_queue *blk_mq_init_allocated_queue(struct blk_mq_tag_set *set, · 602 unmodified lines | ||
| 2522 | 2522 | /* init q->mq_kobj and sw queues' kobjects */ |
| 2523 | 2523 | blk_mq_sysfs_init(q); |
| 2524 | 2524 | |
| 2525 | − q->queue_hw_ctx = kzalloc_node(nr_cpu_ids * sizeof(*(q->queue_hw_ctx)), | |
| 2525 | + q->queue_hw_ctx = kcalloc_node(nr_cpu_ids, sizeof(*(q->queue_hw_ctx)), | |
| 2526 | 2526 | GFP_KERNEL, set->numa_node); |
| 2527 | 2527 | if (!q->queue_hw_ctx) |
| 2528 | 2528 | goto err_percpu; |
| @@ -2741,14 +2741,14 @@ int blk_mq_alloc_tag_set(struct blk_mq_tag_set *set) · 212 unmodified lines | ||
| 2741 | 2741 | if (set->nr_hw_queues > nr_cpu_ids) |
| 2742 | 2742 | set->nr_hw_queues = nr_cpu_ids; |
| 2743 | 2743 | |
| 2744 | − set->tags = kzalloc_node(nr_cpu_ids * sizeof(struct blk_mq_tags *), | |
| 2744 | + set->tags = kcalloc_node(nr_cpu_ids, sizeof(struct blk_mq_tags *), | |
| 2745 | 2745 | GFP_KERNEL, set->numa_node); |
| 2746 | 2746 | if (!set->tags) |
| 2747 | 2747 | return -ENOMEM; |
| 2748 | 2748 | |
| 2749 | 2749 | ret = -ENOMEM; |
| 2750 | − set->mq_map = kzalloc_node(sizeof(*set->mq_map) * nr_cpu_ids, | |
| 2751 | − GFP_KERNEL, set->numa_node); | |
| 2750 | + set->mq_map = kcalloc_node(nr_cpu_ids, sizeof(*set->mq_map), | |
| 2751 | + GFP_KERNEL, set->numa_node); | |
| 2752 | 2752 | if (!set->mq_map) |
| 2753 | 2753 | goto out_free_tags; |
| 2754 | 2754 | |
| @@ -99,12 +99,12 @@ init_tag_map(struct request_queue *q, struct blk_queue_tag *tags, int depth) · 98 unmodified lines | ||
| 99 | 99 | __func__, depth); |
| 100 | 100 | } |
| 101 | 101 | |
| 102 | − tag_index = kzalloc(depth * sizeof(struct request *), GFP_ATOMIC); | |
| 102 | + tag_index = kcalloc(depth, sizeof(struct request *), GFP_ATOMIC); | |
| 103 | 103 | if (!tag_index) |
| 104 | 104 | goto fail; |
| 105 | 105 | |
| 106 | 106 | nr_ulongs = ALIGN(depth, BITS_PER_LONG) / BITS_PER_LONG; |
| 107 | − tag_map = kzalloc(nr_ulongs * sizeof(unsigned long), GFP_ATOMIC); | |
| 107 | + tag_map = kcalloc(nr_ulongs, sizeof(unsigned long), GFP_ATOMIC); | |
| 108 | 108 | if (!tag_map) |
| 109 | 109 | goto fail; |
| 110 | 110 | |
| @@ -331,8 +331,8 @@ int blkdev_report_zones_ioctl(struct block_device *bdev, fmode_t mode, · 330 unmodified lines | ||
| 331 | 331 | if (rep.nr_zones > INT_MAX / sizeof(struct blk_zone)) |
| 332 | 332 | return -ERANGE; |
| 333 | 333 | |
| 334 | − zones = kvmalloc(rep.nr_zones * sizeof(struct blk_zone), | |
| 335 | − GFP_KERNEL | __GFP_ZERO); | |
| 334 | + zones = kvmalloc_array(rep.nr_zones, sizeof(struct blk_zone), | |
| 335 | + GFP_KERNEL | __GFP_ZERO); | |
| 336 | 336 | if (!zones) |
| 337 | 337 | return -ENOMEM; |
| 338 | 338 | |
| @@ -122,7 +122,7 @@ static struct parsed_partitions *allocate_partitions(struct gendisk *hd) · 121 unmodified lines | ||
| 122 | 122 | return NULL; |
| 123 | 123 | |
| 124 | 124 | nr = disk_max_parts(hd); |
| 125 | − state->parts = vzalloc(nr * sizeof(state->parts[0])); | |
| 125 | + state->parts = vzalloc(array_size(nr, sizeof(state->parts[0]))); | |
| 126 | 126 | if (!state->parts) { |
| 127 | 127 | kfree(state); |
| 128 | 128 | return NULL; |
| @@ -378,7 +378,7 @@ static bool ldm_validate_tocblocks(struct parsed_partitions *state, · 377 unmodified lines | ||
| 378 | 378 | BUG_ON(!state || !ldb); |
| 379 | 379 | ph = &ldb->ph; |
| 380 | 380 | tb[0] = &ldb->toc; |
| 381 | − tb[1] = kmalloc(sizeof(*tb[1]) * 3, GFP_KERNEL); | |
| 381 | + tb[1] = kmalloc_array(3, sizeof(*tb[1]), GFP_KERNEL); | |
| 382 | 382 | if (!tb[1]) { |
| 383 | 383 | ldm_crit("Out of memory."); |
| 384 | 384 | goto err; |
| @@ -255,8 +255,8 @@ static int _aead_recvmsg(struct socket *sock, struct msghdr *msg, · 254 unmodified lines | ||
| 255 | 255 | processed - as); |
| 256 | 256 | if (!areq->tsgl_entries) |
| 257 | 257 | areq->tsgl_entries = 1; |
| 258 | − areq->tsgl = sock_kmalloc(sk, sizeof(*areq->tsgl) * | |
| 259 | − areq->tsgl_entries, | |
| 258 | + areq->tsgl = sock_kmalloc(sk, array_size(sizeof(*areq->tsgl), | |
| 259 | + areq->tsgl_entries), | |
| 260 | 260 | GFP_KERNEL); |
| 261 | 261 | if (!areq->tsgl) { |
| 262 | 262 | err = -ENOMEM; |
| @@ -100,7 +100,8 @@ static int _skcipher_recvmsg(struct socket *sock, struct msghdr *msg, · 99 unmodified lines | ||
| 100 | 100 | areq->tsgl_entries = af_alg_count_tsgl(sk, len, 0); |
| 101 | 101 | if (!areq->tsgl_entries) |
| 102 | 102 | areq->tsgl_entries = 1; |
| 103 | − areq->tsgl = sock_kmalloc(sk, sizeof(*areq->tsgl) * areq->tsgl_entries, | |
| 103 | + areq->tsgl = sock_kmalloc(sk, array_size(sizeof(*areq->tsgl), | |
| 104 | + areq->tsgl_entries), | |
| 104 | 105 | GFP_KERNEL); |
| 105 | 106 | if (!areq->tsgl) { |
| 106 | 107 | err = -ENOMEM; |
| @@ -603,7 +603,8 @@ static int __test_aead(struct crypto_aead *tfm, int enc, · 602 unmodified lines | ||
| 603 | 603 | goto out_nooutbuf; |
| 604 | 604 | |
| 605 | 605 | /* avoid "the frame size is larger than 1024 bytes" compiler warning */ |
| 606 | − sg = kmalloc(sizeof(*sg) * 8 * (diff_dst ? 4 : 2), GFP_KERNEL); | |
| 606 | + sg = kmalloc(array3_size(sizeof(*sg), 8, (diff_dst ? 4 : 2)), | |
| 607 | + GFP_KERNEL); | |
| 607 | 608 | if (!sg) |
| 608 | 609 | goto out_nosg; |
| 609 | 610 | sgout = &sg[16]; |
| @@ -82,7 +82,7 @@ struct platform_device *acpi_create_platform_device(struct acpi_device *adev, · 81 unmodified lines | ||
| 82 | 82 | if (count < 0) { |
| 83 | 83 | return NULL; |
| 84 | 84 | } else if (count > 0) { |
| 85 | − resources = kzalloc(count * sizeof(struct resource), | |
| 85 | + resources = kcalloc(count, sizeof(struct resource), | |
| 86 | 86 | GFP_KERNEL); |
| 87 | 87 | if (!resources) { |
| 88 | 88 | dev_err(&adev->dev, "No memory for resources\n"); |
| @@ -832,8 +832,9 @@ int acpi_video_get_levels(struct acpi_device *device, · 831 unmodified lines | ||
| 832 | 832 | * in order to account for buggy BIOS which don't export the first two |
| 833 | 833 | * special levels (see below) |
| 834 | 834 | */ |
| 835 | − br->levels = kmalloc((obj->package.count + ACPI_VIDEO_FIRST_LEVEL) * | |
| 836 | − sizeof(*br->levels), GFP_KERNEL); | |
| 835 | + br->levels = kmalloc_array(obj->package.count + ACPI_VIDEO_FIRST_LEVEL, | |
| 836 | + sizeof(*br->levels), | |
| 837 | + GFP_KERNEL); | |
| 837 | 838 | if (!br->levels) { |
| 838 | 839 | result = -ENOMEM; |
| 839 | 840 | goto out_free; |
| @@ -524,7 +524,8 @@ retry: · 523 unmodified lines | ||
| 524 | 524 | pr_warn(FW_WARN "too many record IDs!\n"); |
| 525 | 525 | return 0; |
| 526 | 526 | } |
| 527 | − new_entries = kvmalloc(new_size * sizeof(entries[0]), GFP_KERNEL); | |
| 527 | + new_entries = kvmalloc_array(new_size, sizeof(entries[0]), | |
| 528 | + GFP_KERNEL); | |
| 528 | 529 | if (!new_entries) |
| 529 | 530 | return -ENOMEM; |
| 530 | 531 | memcpy(new_entries, entries, |
| @@ -195,7 +195,8 @@ static int __init hest_ghes_dev_register(unsigned int ghes_count) · 194 unmodified lines | ||
| 195 | 195 | struct ghes_arr ghes_arr; |
| 196 | 196 | |
| 197 | 197 | ghes_arr.count = 0; |
| 198 | − ghes_arr.ghes_devs = kmalloc(sizeof(void *) * ghes_count, GFP_KERNEL); | |
| 198 | + ghes_arr.ghes_devs = kmalloc_array(ghes_count, sizeof(void *), | |
| 199 | + GFP_KERNEL); | |
| 199 | 200 | if (!ghes_arr.ghes_devs) |
| 200 | 201 | return -ENOMEM; |
| 201 | 202 | |
| @@ -298,8 +298,8 @@ static int acpi_fan_get_fps(struct acpi_device *device) · 297 unmodified lines | ||
| 298 | 298 | } |
| 299 | 299 | |
| 300 | 300 | fan->fps_count = obj->package.count - 1; /* minus revision field */ |
| 301 | − fan->fps = devm_kzalloc(&device->dev, | |
| 302 | − fan->fps_count * sizeof(struct acpi_fan_fps), | |
| 301 | + fan->fps = devm_kcalloc(&device->dev, | |
| 302 | + fan->fps_count, sizeof(struct acpi_fan_fps), | |
| 303 | 303 | GFP_KERNEL); |
| 304 | 304 | if (!fan->fps) { |
| 305 | 305 | dev_err(&device->dev, "Not enough memory\n"); |
| @@ -1082,9 +1082,10 @@ static int __nfit_mem_init(struct acpi_nfit_desc *acpi_desc, · 1081 unmodified lines | ||
| 1082 | 1082 | continue; |
| 1083 | 1083 | nfit_mem->nfit_flush = nfit_flush; |
| 1084 | 1084 | flush = nfit_flush->flush; |
| 1085 | − nfit_mem->flush_wpq = devm_kzalloc(acpi_desc->dev, | |
| 1086 | − flush->hint_count | |
| 1087 | − * sizeof(struct resource), GFP_KERNEL); | |
| 1085 | + nfit_mem->flush_wpq = devm_kcalloc(acpi_desc->dev, | |
| 1086 | + flush->hint_count, | |
| 1087 | + sizeof(struct resource), | |
| 1088 | + GFP_KERNEL); | |
| 1088 | 1089 | if (!nfit_mem->flush_wpq) |
| 1089 | 1090 | return -ENOMEM; |
| 1090 | 1091 | for (i = 0; i < flush->hint_count; i++) { |
| @@ -343,8 +343,9 @@ static int acpi_processor_get_performance_states(struct acpi_processor *pr) · 342 unmodified lines | ||
| 343 | 343 | |
| 344 | 344 | pr->performance->state_count = pss->package.count; |
| 345 | 345 | pr->performance->states = |
| 346 | − kmalloc(sizeof(struct acpi_processor_px) * pss->package.count, | |
| 347 | − GFP_KERNEL); | |
| 346 | + kmalloc_array(pss->package.count, | |
| 347 | + sizeof(struct acpi_processor_px), | |
| 348 | + GFP_KERNEL); | |
| 348 | 349 | if (!pr->performance->states) { |
| 349 | 350 | result = -ENOMEM; |
| 350 | 351 | goto end; |
| @@ -534,8 +534,9 @@ static int acpi_processor_get_throttling_states(struct acpi_processor *pr) · 533 unmodified lines | ||
| 534 | 534 | |
| 535 | 535 | pr->throttling.state_count = tss->package.count; |
| 536 | 536 | pr->throttling.states_tss = |
| 537 | − kmalloc(sizeof(struct acpi_processor_tx_tss) * tss->package.count, | |
| 538 | − GFP_KERNEL); | |
| 537 | + kmalloc_array(tss->package.count, | |
| 538 | + sizeof(struct acpi_processor_tx_tss), | |
| 539 | + GFP_KERNEL); | |
| 539 | 540 | if (!pr->throttling.states_tss) { |
| 540 | 541 | result = -ENOMEM; |
| 541 | 542 | goto end; |
| @@ -857,12 +857,12 @@ void acpi_irq_stats_init(void) · 856 unmodified lines | ||
| 857 | 857 | num_gpes = acpi_current_gpe_count; |
| 858 | 858 | num_counters = num_gpes + ACPI_NUM_FIXED_EVENTS + NUM_COUNTERS_EXTRA; |
| 859 | 859 | |
| 860 | − all_attrs = kzalloc(sizeof(struct attribute *) * (num_counters + 1), | |
| 860 | + all_attrs = kcalloc(num_counters + 1, sizeof(struct attribute *), | |
| 861 | 861 | GFP_KERNEL); |
| 862 | 862 | if (all_attrs == NULL) |
| 863 | 863 | return; |
| 864 | 864 | |
| 865 | − all_counters = kzalloc(sizeof(struct event_counter) * (num_counters), | |
| 865 | + all_counters = kcalloc(num_counters, sizeof(struct event_counter), | |
| 866 | 866 | GFP_KERNEL); |
| 867 | 867 | if (all_counters == NULL) |
| 868 | 868 | goto fail; |
| @@ -871,7 +871,7 @@ void acpi_irq_stats_init(void) · 2 unmodified lines | ||
| 871 | 871 | if (ACPI_FAILURE(status)) |
| 872 | 872 | goto fail; |
| 873 | 873 | |
| 874 | − counter_attrs = kzalloc(sizeof(struct kobj_attribute) * (num_counters), | |
| 874 | + counter_attrs = kcalloc(num_counters, sizeof(struct kobj_attribute), | |
| 875 | 875 | GFP_KERNEL); |
| 876 | 876 | if (counter_attrs == NULL) |
| 877 | 877 | goto fail; |
| @@ -692,8 +692,8 @@ int binder_alloc_mmap_handler(struct binder_alloc *alloc, · 691 unmodified lines | ||
| 692 | 692 | } |
| 693 | 693 | } |
| 694 | 694 | #endif |
| 695 | − alloc->pages = kzalloc(sizeof(alloc->pages[0]) * | |
| 696 | − ((vma->vm_end - vma->vm_start) / PAGE_SIZE), | |
| 695 | + alloc->pages = kcalloc((vma->vm_end - vma->vm_start) / PAGE_SIZE, | |
| 696 | + sizeof(alloc->pages[0]), | |
| 697 | 697 | GFP_KERNEL); |
| 698 | 698 | if (alloc->pages == NULL) { |
| 699 | 699 | ret = -ENOMEM; |
| @@ -6987,7 +6987,7 @@ static void __init ata_parse_force_param(void) · 6986 unmodified lines | ||
| 6987 | 6987 | if (*p == ',') |
| 6988 | 6988 | size++; |
| 6989 | 6989 | |
| 6990 | − ata_force_tbl = kzalloc(sizeof(ata_force_tbl[0]) * size, GFP_KERNEL); | |
| 6990 | + ata_force_tbl = kcalloc(size, sizeof(ata_force_tbl[0]), GFP_KERNEL); | |
| 6991 | 6991 | if (!ata_force_tbl) { |
| 6992 | 6992 | printk(KERN_WARNING "ata: failed to extend force table, " |
| 6993 | 6993 | "libata.force ignored\n"); |
| @@ -340,7 +340,7 @@ static int sata_pmp_init_links (struct ata_port *ap, int nr_ports) · 339 unmodified lines | ||
| 340 | 340 | int i, err; |
| 341 | 341 | |
| 342 | 342 | if (!pmp_link) { |
| 343 | − pmp_link = kzalloc(sizeof(pmp_link[0]) * SATA_PMP_MAX_PORTS, | |
| 343 | + pmp_link = kcalloc(SATA_PMP_MAX_PORTS, sizeof(pmp_link[0]), | |
| 344 | 344 | GFP_NOIO); |
| 345 | 345 | if (!pmp_link) |
| 346 | 346 | return -ENOMEM; |
| @@ -4114,13 +4114,13 @@ static int mv_platform_probe(struct platform_device *pdev) · 4113 unmodified lines | ||
| 4114 | 4114 | |
| 4115 | 4115 | if (!host || !hpriv) |
| 4116 | 4116 | return -ENOMEM; |
| 4117 | − hpriv->port_clks = devm_kzalloc(&pdev->dev, | |
| 4118 | − sizeof(struct clk *) * n_ports, | |
| 4117 | + hpriv->port_clks = devm_kcalloc(&pdev->dev, | |
| 4118 | + n_ports, sizeof(struct clk *), | |
| 4119 | 4119 | GFP_KERNEL); |
| 4120 | 4120 | if (!hpriv->port_clks) |
| 4121 | 4121 | return -ENOMEM; |
| 4122 | − hpriv->port_phys = devm_kzalloc(&pdev->dev, | |
| 4123 | − sizeof(struct phy *) * n_ports, | |
| 4122 | + hpriv->port_phys = devm_kcalloc(&pdev->dev, | |
| 4123 | + n_ports, sizeof(struct phy *), | |
| 4124 | 4124 | GFP_KERNEL); |
| 4125 | 4125 | if (!hpriv->port_phys) |
| 4126 | 4126 | return -ENOMEM; |
| @@ -2094,7 +2094,8 @@ static int fore200e_alloc_rx_buf(struct fore200e *fore200e) · 2093 unmodified lines | ||
| 2094 | 2094 | DPRINTK(2, "rx buffers %d / %d are being allocated\n", scheme, magn); |
| 2095 | 2095 | |
| 2096 | 2096 | /* allocate the array of receive buffers */ |
| 2097 | − buffer = bsq->buffer = kzalloc(nbr * sizeof(struct buffer), GFP_KERNEL); | |
| 2097 | + buffer = bsq->buffer = kcalloc(nbr, sizeof(struct buffer), | |
| 2098 | + GFP_KERNEL); | |
| 2098 | 2099 | |
| 2099 | 2100 | if (buffer == NULL) |
| 2100 | 2101 | return -ENOMEM; |
| @@ -1618,7 +1618,7 @@ static int rx_init(struct atm_dev *dev) · 1617 unmodified lines | ||
| 1618 | 1618 | skb_queue_head_init(&iadev->rx_dma_q); |
| 1619 | 1619 | iadev->rx_free_desc_qhead = NULL; |
| 1620 | 1620 | |
| 1621 | − iadev->rx_open = kzalloc(4 * iadev->num_vc, GFP_KERNEL); | |
| 1621 | + iadev->rx_open = kcalloc(4, iadev->num_vc, GFP_KERNEL); | |
| 1622 | 1622 | if (!iadev->rx_open) { |
| 1623 | 1623 | printk(KERN_ERR DEV_LABEL "itf %d couldn't get free page\n", |
| 1624 | 1624 | dev->number); |
| @@ -1291,7 +1291,8 @@ static int fpga_probe(struct pci_dev *dev, const struct pci_device_id *id) · 1290 unmodified lines | ||
| 1291 | 1291 | card->using_dma = 1; |
| 1292 | 1292 | if (1) { /* All known FPGA versions so far */ |
| 1293 | 1293 | card->dma_alignment = 3; |
| 1294 | − card->dma_bounce = kmalloc(card->nr_ports * BUF_SIZE, GFP_KERNEL); | |
| 1294 | + card->dma_bounce = kmalloc_array(card->nr_ports, | |
| 1295 | + BUF_SIZE, GFP_KERNEL); | |
| 1295 | 1296 | if (!card->dma_bounce) { |
| 1296 | 1297 | dev_warn(&card->dev->dev, "Failed to allocate DMA bounce buffers\n"); |
| 1297 | 1298 | err = -ENOMEM; |
| @@ -333,8 +333,8 @@ static int __init cfag12864b_init(void) · 332 unmodified lines | ||
| 333 | 333 | goto none; |
| 334 | 334 | } |
| 335 | 335 | |
| 336 | − cfag12864b_cache = kmalloc(sizeof(unsigned char) * | |
| 337 | − CFAG12864B_SIZE, GFP_KERNEL); | |
| 336 | + cfag12864b_cache = kmalloc(CFAG12864B_SIZE, | |
| 337 | + GFP_KERNEL); | |
| 338 | 338 | if (cfag12864b_cache == NULL) { |
| 339 | 339 | printk(KERN_ERR CFAG12864B_NAME ": ERROR: " |
| 340 | 340 | "can't alloc cache buffer (%i bytes)\n", |
| @@ -403,7 +403,7 @@ static int fw_realloc_pages(struct fw_sysfs *fw_sysfs, int min_size) · 402 unmodified lines | ||
| 403 | 403 | fw_priv->page_array_size * 2); |
| 404 | 404 | struct page **new_pages; |
| 405 | 405 | |
| 406 | − new_pages = vmalloc(new_array_size * sizeof(void *)); | |
| 406 | + new_pages = vmalloc(array_size(new_array_size, sizeof(void *))); | |
| 407 | 407 | if (!new_pages) { |
| 408 | 408 | fw_load_abort(fw_sysfs); |
| 409 | 409 | return -ENOMEM; |
| @@ -5719,8 +5719,8 @@ static bool DAC960_CheckStatusBuffer(DAC960_Controller_T *Controller, · 5718 unmodified lines | ||
| 5719 | 5719 | Controller->CombinedStatusBufferLength = NewStatusBufferLength; |
| 5720 | 5720 | return true; |
| 5721 | 5721 | } |
| 5722 | − NewStatusBuffer = kmalloc(2 * Controller->CombinedStatusBufferLength, | |
| 5723 | − GFP_ATOMIC); | |
| 5722 | + NewStatusBuffer = kmalloc_array(2, Controller->CombinedStatusBufferLength, | |
| 5723 | + GFP_ATOMIC); | |
| 5724 | 5724 | if (NewStatusBuffer == NULL) |
| 5725 | 5725 | { |
| 5726 | 5726 | DAC960_Warning("Unable to expand Combined Status Buffer - Truncating\n", |
| @@ -511,7 +511,8 @@ static void drbd_calc_cpu_mask(cpumask_var_t *cpu_mask) · 510 unmodified lines | ||
| 511 | 511 | { |
| 512 | 512 | unsigned int *resources_per_cpu, min_index = ~0; |
| 513 | 513 | |
| 514 | − resources_per_cpu = kzalloc(nr_cpu_ids * sizeof(*resources_per_cpu), GFP_KERNEL); | |
| 514 | + resources_per_cpu = kcalloc(nr_cpu_ids, sizeof(*resources_per_cpu), | |
| 515 | + GFP_KERNEL); | |
| 515 | 516 | if (resources_per_cpu) { |
| 516 | 517 | struct drbd_resource *resource; |
| 517 | 518 | unsigned int cpu, min = ~0; |
| @@ -524,7 +524,8 @@ static int lo_rw_aio(struct loop_device *lo, struct loop_cmd *cmd, · 523 unmodified lines | ||
| 524 | 524 | |
| 525 | 525 | __rq_for_each_bio(bio, rq) |
| 526 | 526 | segments += bio_segments(bio); |
| 527 | − bvec = kmalloc(sizeof(struct bio_vec) * segments, GFP_NOIO); | |
| 527 | + bvec = kmalloc_array(segments, sizeof(struct bio_vec), | |
| 528 | + GFP_NOIO); | |
| 528 | 529 | if (!bvec) |
| 529 | 530 | return -EIO; |
| 530 | 531 | cmd->bvec = bvec; |
| @@ -1575,12 +1575,12 @@ static int setup_commands(struct nullb_queue *nq) · 1574 unmodified lines | ||
| 1575 | 1575 | struct nullb_cmd *cmd; |
| 1576 | 1576 | int i, tag_size; |
| 1577 | 1577 | |
| 1578 | − nq->cmds = kzalloc(nq->queue_depth * sizeof(*cmd), GFP_KERNEL); | |
| 1578 | + nq->cmds = kcalloc(nq->queue_depth, sizeof(*cmd), GFP_KERNEL); | |
| 1579 | 1579 | if (!nq->cmds) |
| 1580 | 1580 | return -ENOMEM; |
| 1581 | 1581 | |
| 1582 | 1582 | tag_size = ALIGN(nq->queue_depth, BITS_PER_LONG) / BITS_PER_LONG; |
| 1583 | − nq->tag_map = kzalloc(tag_size * sizeof(unsigned long), GFP_KERNEL); | |
| 1583 | + nq->tag_map = kcalloc(tag_size, sizeof(unsigned long), GFP_KERNEL); | |
| 1584 | 1584 | if (!nq->tag_map) { |
| 1585 | 1585 | kfree(nq->cmds); |
| 1586 | 1586 | return -ENOMEM; |
| @@ -1598,8 +1598,9 @@ static int setup_commands(struct nullb_queue *nq) · 11 unmodified lines | ||
| 1598 | 1598 | |
| 1599 | 1599 | static int setup_queues(struct nullb *nullb) |
| 1600 | 1600 | { |
| 1601 | − nullb->queues = kzalloc(nullb->dev->submit_queues * | |
| 1602 | − sizeof(struct nullb_queue), GFP_KERNEL); | |
| 1601 | + nullb->queues = kcalloc(nullb->dev->submit_queues, | |
| 1602 | + sizeof(struct nullb_queue), | |
| 1603 | + GFP_KERNEL); | |
| 1603 | 1604 | if (!nullb->queues) |
| 1604 | 1605 | return -ENOMEM; |
| 1605 | 1606 | |
| @@ -407,8 +407,9 @@ static int ps3vram_cache_init(struct ps3_system_bus_device *dev) · 406 unmodified lines | ||
| 407 | 407 | |
| 408 | 408 | priv->cache.page_count = CACHE_PAGE_COUNT; |
| 409 | 409 | priv->cache.page_size = CACHE_PAGE_SIZE; |
| 410 | − priv->cache.tags = kzalloc(sizeof(struct ps3vram_tag) * | |
| 411 | − CACHE_PAGE_COUNT, GFP_KERNEL); | |
| 410 | + priv->cache.tags = kcalloc(CACHE_PAGE_COUNT, | |
| 411 | + sizeof(struct ps3vram_tag), | |
| 412 | + GFP_KERNEL); | |
| 412 | 413 | if (!priv->cache.tags) |
| 413 | 414 | return -ENOMEM; |
| 414 | 415 | |
| @@ -873,7 +873,8 @@ static int rsxx_pci_probe(struct pci_dev *dev, · 872 unmodified lines | ||
| 873 | 873 | dev_info(CARD_TO_DEV(card), |
| 874 | 874 | "Failed reading the number of DMA targets\n"); |
| 875 | 875 | |
| 876 | − card->ctrl = kzalloc(card->n_targets * sizeof(*card->ctrl), GFP_KERNEL); | |
| 876 | + card->ctrl = kcalloc(card->n_targets, sizeof(*card->ctrl), | |
| 877 | + GFP_KERNEL); | |
| 877 | 878 | if (!card->ctrl) { |
| 878 | 879 | st = -ENOMEM; |
| 879 | 880 | goto failed_dma_setup; |
| @@ -1038,7 +1038,7 @@ int rsxx_eeh_save_issued_dmas(struct rsxx_cardinfo *card) · 1037 unmodified lines | ||
| 1038 | 1038 | struct rsxx_dma *dma; |
| 1039 | 1039 | struct list_head *issued_dmas; |
| 1040 | 1040 | |
| 1041 | − issued_dmas = kzalloc(sizeof(*issued_dmas) * card->n_targets, | |
| 1041 | + issued_dmas = kcalloc(card->n_targets, sizeof(*issued_dmas), | |
| 1042 | 1042 | GFP_KERNEL); |
| 1043 | 1043 | if (!issued_dmas) |
| 1044 | 1044 | return -ENOMEM; |
| @@ -139,7 +139,8 @@ static int xen_blkif_alloc_rings(struct xen_blkif *blkif) · 138 unmodified lines | ||
| 139 | 139 | { |
| 140 | 140 | unsigned int r; |
| 141 | 141 | |
| 142 | − blkif->rings = kzalloc(blkif->nr_rings * sizeof(struct xen_blkif_ring), GFP_KERNEL); | |
| 142 | + blkif->rings = kcalloc(blkif->nr_rings, sizeof(struct xen_blkif_ring), | |
| 143 | + GFP_KERNEL); | |
| 143 | 144 | if (!blkif->rings) |
| 144 | 145 | return -ENOMEM; |
| 145 | 146 | |
| @@ -1906,7 +1906,9 @@ static int negotiate_mq(struct blkfront_info *info) · 1905 unmodified lines | ||
| 1906 | 1906 | if (!info->nr_rings) |
| 1907 | 1907 | info->nr_rings = 1; |
| 1908 | 1908 | |
| 1909 | − info->rinfo = kzalloc(sizeof(struct blkfront_ring_info) * info->nr_rings, GFP_KERNEL); | |
| 1909 | + info->rinfo = kcalloc(info->nr_rings, | |
| 1910 | + sizeof(struct blkfront_ring_info), | |
| 1911 | + GFP_KERNEL); | |
| 1910 | 1912 | if (!info->rinfo) { |
| 1911 | 1913 | xenbus_dev_fatal(info->xbdev, -ENOMEM, "allocating ring_info structure"); |
| 1912 | 1914 | return -ENOMEM; |
| @@ -2216,15 +2218,18 @@ static int blkfront_setup_indirect(struct blkfront_ring_info *rinfo) · 303 unmodified lines | ||
| 2216 | 2218 | } |
| 2217 | 2219 | |
| 2218 | 2220 | for (i = 0; i < BLK_RING_SIZE(info); i++) { |
| 2219 | − rinfo->shadow[i].grants_used = kzalloc( | |
| 2220 | − sizeof(rinfo->shadow[i].grants_used[0]) * grants, | |
| 2221 | − GFP_NOIO); | |
| 2222 | − rinfo->shadow[i].sg = kzalloc(sizeof(rinfo->shadow[i].sg[0]) * psegs, GFP_NOIO); | |
| 2223 | − if (info->max_indirect_segments) | |
| 2224 | − rinfo->shadow[i].indirect_grants = kzalloc( | |
| 2225 | − sizeof(rinfo->shadow[i].indirect_grants[0]) * | |
| 2226 | − INDIRECT_GREFS(grants), | |
| 2221 | + rinfo->shadow[i].grants_used = | |
| 2222 | + kcalloc(grants, | |
| 2223 | + sizeof(rinfo->shadow[i].grants_used[0]), | |
| 2227 | 2224 | GFP_NOIO); |
| 2225 | + rinfo->shadow[i].sg = kcalloc(psegs, | |
| 2226 | + sizeof(rinfo->shadow[i].sg[0]), | |
| 2227 | + GFP_NOIO); | |
| 2228 | + if (info->max_indirect_segments) | |
| 2229 | + rinfo->shadow[i].indirect_grants = | |
| 2230 | + kcalloc(INDIRECT_GREFS(grants), | |
| 2231 | + sizeof(rinfo->shadow[i].indirect_grants[0]), | |
| 2232 | + GFP_NOIO); | |
| 2228 | 2233 | if ((rinfo->shadow[i].grants_used == NULL) || |
| 2229 | 2234 | (rinfo->shadow[i].sg == NULL) || |
| 2230 | 2235 | (info->max_indirect_segments && |
| @@ -197,8 +197,9 @@ static int z2_open(struct block_device *bdev, fmode_t mode) · 196 unmodified lines | ||
| 197 | 197 | vaddr = (unsigned long)z_remap_nocache_nonser(paddr, size); |
| 198 | 198 | #endif |
| 199 | 199 | z2ram_map = |
| 200 | − kmalloc((size/Z2RAM_CHUNKSIZE)*sizeof(z2ram_map[0]), | |
| 201 | − GFP_KERNEL); | |
| 200 | + kmalloc_array(size / Z2RAM_CHUNKSIZE, | |
| 201 | + sizeof(z2ram_map[0]), | |
| 202 | + GFP_KERNEL); | |
| 202 | 203 | if ( z2ram_map == NULL ) |
| 203 | 204 | { |
| 204 | 205 | printk( KERN_ERR DEVICE_NAME |
| @@ -898,7 +898,7 @@ static bool zram_meta_alloc(struct zram *zram, u64 disksize) · 897 unmodified lines | ||
| 898 | 898 | size_t num_pages; |
| 899 | 899 | |
| 900 | 900 | num_pages = disksize >> PAGE_SHIFT; |
| 901 | − zram->table = vzalloc(num_pages * sizeof(*zram->table)); | |
| 901 | + zram->table = vzalloc(array_size(num_pages, sizeof(*zram->table))); | |
| 902 | 902 | if (!zram->table) |
| 903 | 903 | return false; |
| 904 | 904 | |
| @@ -354,8 +354,8 @@ int fsl_mc_populate_irq_pool(struct fsl_mc_bus *mc_bus, · 353 unmodified lines | ||
| 354 | 354 | if (error < 0) |
| 355 | 355 | return error; |
| 356 | 356 | |
| 357 | − irq_resources = devm_kzalloc(&mc_bus_dev->dev, | |
| 358 | − sizeof(*irq_resources) * irq_count, | |
| 357 | + irq_resources = devm_kcalloc(&mc_bus_dev->dev, | |
| 358 | + irq_count, sizeof(*irq_resources), | |
| 359 | 359 | GFP_KERNEL); |
| 360 | 360 | if (!irq_resources) { |
| 361 | 361 | error = -ENOMEM; |
| @@ -455,7 +455,7 @@ int __must_check fsl_mc_allocate_irqs(struct fsl_mc_device *mc_dev) · 93 unmodified lines | ||
| 455 | 455 | return -ENOSPC; |
| 456 | 456 | } |
| 457 | 457 | |
| 458 | − irqs = devm_kzalloc(&mc_dev->dev, irq_count * sizeof(irqs[0]), | |
| 458 | + irqs = devm_kcalloc(&mc_dev->dev, irq_count, sizeof(irqs[0]), | |
| 459 | 459 | GFP_KERNEL); |
| 460 | 460 | if (!irqs) |
| 461 | 461 | return -ENOMEM; |
| @@ -2132,7 +2132,7 @@ static int cdrom_read_cdda_old(struct cdrom_device_info *cdi, __u8 __user *ubuf, · 2131 unmodified lines | ||
| 2132 | 2132 | */ |
| 2133 | 2133 | nr = nframes; |
| 2134 | 2134 | do { |
| 2135 | − cgc.buffer = kmalloc(CD_FRAMESIZE_RAW * nr, GFP_KERNEL); | |
| 2135 | + cgc.buffer = kmalloc_array(nr, CD_FRAMESIZE_RAW, GFP_KERNEL); | |
| 2136 | 2136 | if (cgc.buffer) |
| 2137 | 2137 | break; |
| 2138 | 2138 | |
| @@ -85,7 +85,8 @@ static int amd_create_gatt_pages(int nr_tables) · 84 unmodified lines | ||
| 85 | 85 | int retval = 0; |
| 86 | 86 | int i; |
| 87 | 87 | |
| 88 | − tables = kzalloc((nr_tables + 1) * sizeof(struct amd_page_map *),GFP_KERNEL); | |
| 88 | + tables = kcalloc(nr_tables + 1, sizeof(struct amd_page_map *), | |
| 89 | + GFP_KERNEL); | |
| 89 | 90 | if (tables == NULL) |
| 90 | 91 | return -ENOMEM; |
| 91 | 92 | |
| @@ -108,7 +108,8 @@ static int ati_create_gatt_pages(int nr_tables) · 107 unmodified lines | ||
| 108 | 108 | int retval = 0; |
| 109 | 109 | int i; |
| 110 | 110 | |
| 111 | − tables = kzalloc((nr_tables + 1) * sizeof(struct ati_page_map *),GFP_KERNEL); | |
| 111 | + tables = kcalloc(nr_tables + 1, sizeof(struct ati_page_map *), | |
| 112 | + GFP_KERNEL); | |
| 112 | 113 | if (tables == NULL) |
| 113 | 114 | return -ENOMEM; |
| 114 | 115 | |
| @@ -98,11 +98,15 @@ static int compat_agpioc_reserve_wrap(struct agp_file_private *priv, void __user · 97 unmodified lines | ||
| 98 | 98 | if (ureserve.seg_count >= 16384) |
| 99 | 99 | return -EINVAL; |
| 100 | 100 | |
| 101 | − usegment = kmalloc(sizeof(*usegment) * ureserve.seg_count, GFP_KERNEL); | |
| 101 | + usegment = kmalloc_array(ureserve.seg_count, | |
| 102 | + sizeof(*usegment), | |
| 103 | + GFP_KERNEL); | |
| 102 | 104 | if (!usegment) |
| 103 | 105 | return -ENOMEM; |
| 104 | 106 | |
| 105 | − ksegment = kmalloc(sizeof(*ksegment) * kreserve.seg_count, GFP_KERNEL); | |
| 107 | + ksegment = kmalloc_array(kreserve.seg_count, | |
| 108 | + sizeof(*ksegment), | |
| 109 | + GFP_KERNEL); | |
| 106 | 110 | if (!ksegment) { |
| 107 | 111 | kfree(usegment); |
| 108 | 112 | return -ENOMEM; |
| @@ -93,7 +93,8 @@ static int agp_3_5_isochronous_node_enable(struct agp_bridge_data *bridge, · 92 unmodified lines | ||
| 93 | 93 | * We'll work with an array of isoch_data's (one for each |
| 94 | 94 | * device in dev_list) throughout this function. |
| 95 | 95 | */ |
| 96 | − if ((master = kmalloc(ndevs * sizeof(*master), GFP_KERNEL)) == NULL) { | |
| 96 | + master = kmalloc_array(ndevs, sizeof(*master), GFP_KERNEL); | |
| 97 | + if (master == NULL) { | |
| 97 | 98 | ret = -ENOMEM; |
| 98 | 99 | goto get_out; |
| 99 | 100 | } |
| @@ -280,9 +280,9 @@ static int agp_sgi_init(void) · 279 unmodified lines | ||
| 280 | 280 | else |
| 281 | 281 | return 0; |
| 282 | 282 | |
| 283 | − sgi_tioca_agp_bridges = kmalloc(tioca_gart_found * | |
| 284 | − sizeof(struct agp_bridge_data *), | |
| 285 | − GFP_KERNEL); | |
| 283 | + sgi_tioca_agp_bridges = kmalloc_array(tioca_gart_found, | |
| 284 | + sizeof(struct agp_bridge_data *), | |
| 285 | + GFP_KERNEL); | |
| 286 | 286 | if (!sgi_tioca_agp_bridges) |
| 287 | 287 | return -ENOMEM; |
| 288 | 288 | |
| @@ -96,7 +96,7 @@ static int serverworks_create_gatt_pages(int nr_tables) · 95 unmodified lines | ||
| 96 | 96 | int retval = 0; |
| 97 | 97 | int i; |
| 98 | 98 | |
| 99 | − tables = kzalloc((nr_tables + 1) * sizeof(struct serverworks_page_map *), | |
| 99 | + tables = kcalloc(nr_tables + 1, sizeof(struct serverworks_page_map *), | |
| 100 | 100 | GFP_KERNEL); |
| 101 | 101 | if (tables == NULL) |
| 102 | 102 | return -ENOMEM; |
| @@ -402,7 +402,9 @@ static int uninorth_create_gatt_table(struct agp_bridge_data *bridge) · 401 unmodified lines | ||
| 402 | 402 | if (table == NULL) |
| 403 | 403 | return -ENOMEM; |
| 404 | 404 | |
| 405 | − uninorth_priv.pages_arr = kmalloc((1 << page_order) * sizeof(struct page*), GFP_KERNEL); | |
| 405 | + uninorth_priv.pages_arr = kmalloc_array(1 << page_order, | |
| 406 | + sizeof(struct page *), | |
| 407 | + GFP_KERNEL); | |
| 406 | 408 | if (uninorth_priv.pages_arr == NULL) |
| 407 | 409 | goto enomem; |
| 408 | 410 | |
| @@ -1757,7 +1757,8 @@ static unsigned short *ssif_address_list(void) · 1756 unmodified lines | ||
| 1757 | 1757 | list_for_each_entry(info, &ssif_infos, link) |
| 1758 | 1758 | count++; |
| 1759 | 1759 | |
| 1760 | − address_list = kzalloc(sizeof(*address_list) * (count + 1), GFP_KERNEL); | |
| 1760 | + address_list = kcalloc(count + 1, sizeof(*address_list), | |
| 1761 | + GFP_KERNEL); | |
| 1761 | 1762 | if (!address_list) |
| 1762 | 1763 | return NULL; |
| 1763 | 1764 | |
| @@ -321,7 +321,8 @@ static int __init raw_init(void) · 320 unmodified lines | ||
| 321 | 321 | max_raw_minors = MAX_RAW_MINORS; |
| 322 | 322 | } |
| 323 | 323 | |
| 324 | − raw_devices = vzalloc(sizeof(struct raw_device_data) * max_raw_minors); | |
| 324 | + raw_devices = vzalloc(array_size(max_raw_minors, | |
| 325 | + sizeof(struct raw_device_data))); | |
| 325 | 326 | if (!raw_devices) { |
| 326 | 327 | printk(KERN_ERR "Not enough memory for raw device structures\n"); |
| 327 | 328 | ret = -ENOMEM; |
| @@ -980,7 +980,7 @@ static int tpm2_get_cc_attrs_tbl(struct tpm_chip *chip) · 979 unmodified lines | ||
| 980 | 980 | goto out; |
| 981 | 981 | } |
| 982 | 982 | |
| 983 | − chip->cc_attrs_tbl = devm_kzalloc(&chip->dev, 4 * nr_commands, | |
| 983 | + chip->cc_attrs_tbl = devm_kcalloc(&chip->dev, 4, nr_commands, | |
| 984 | 984 | GFP_KERNEL); |
| 985 | 985 | |
| 986 | 986 | rc = tpm_buf_init(&buf, TPM2_ST_NO_SESSIONS, TPM2_CC_GET_CAPABILITY); |
| @@ -433,8 +433,7 @@ static struct port_buffer *alloc_buf(struct virtio_device *vdev, size_t buf_size · 432 unmodified lines | ||
| 433 | 433 | * Allocate buffer and the sg list. The sg list array is allocated |
| 434 | 434 | * directly after the port_buffer struct. |
| 435 | 435 | */ |
| 436 | − buf = kmalloc(sizeof(*buf) + sizeof(struct scatterlist) * pages, | |
| 437 | − GFP_KERNEL); | |
| 436 | + buf = kmalloc(struct_size(buf, sg, pages), GFP_KERNEL); | |
| 438 | 437 | if (!buf) |
| 439 | 438 | goto fail; |
| 440 | 439 | |
| @@ -1892,13 +1891,14 @@ static int init_vqs(struct ports_device *portdev) · 1451 unmodified lines | ||
| 1892 | 1891 | nr_ports = portdev->max_nr_ports; |
| 1893 | 1892 | nr_queues = use_multiport(portdev) ? (nr_ports + 1) * 2 : 2; |
| 1894 | 1893 | |
| 1895 | − vqs = kmalloc(nr_queues * sizeof(struct virtqueue *), GFP_KERNEL); | |
| 1896 | − io_callbacks = kmalloc(nr_queues * sizeof(vq_callback_t *), GFP_KERNEL); | |
| 1897 | − io_names = kmalloc(nr_queues * sizeof(char *), GFP_KERNEL); | |
| 1898 | − portdev->in_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *), | |
| 1899 | − GFP_KERNEL); | |
| 1900 | − portdev->out_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *), | |
| 1901 | − GFP_KERNEL); | |
| 1894 | + vqs = kmalloc_array(nr_queues, sizeof(struct virtqueue *), GFP_KERNEL); | |
| 1895 | + io_callbacks = kmalloc_array(nr_queues, sizeof(vq_callback_t *), | |
| 1896 | + GFP_KERNEL); | |
| 1897 | + io_names = kmalloc_array(nr_queues, sizeof(char *), GFP_KERNEL); | |
| 1898 | + portdev->in_vqs = kmalloc_array(nr_ports, sizeof(struct virtqueue *), | |
| 1899 | + GFP_KERNEL); | |
| 1900 | + portdev->out_vqs = kmalloc_array(nr_ports, sizeof(struct virtqueue *), | |
| 1901 | + GFP_KERNEL); | |
| 1902 | 1902 | if (!vqs || !io_callbacks || !io_names || !portdev->in_vqs || |
| 1903 | 1903 | !portdev->out_vqs) { |
| 1904 | 1904 | err = -ENOMEM; |
| @@ -734,7 +734,7 @@ static void bcm2835_pll_debug_init(struct clk_hw *hw, · 733 unmodified lines | ||
| 734 | 734 | const struct bcm2835_pll_data *data = pll->data; |
| 735 | 735 | struct debugfs_reg32 *regs; |
| 736 | 736 | |
| 737 | − regs = devm_kzalloc(cprman->dev, 7 * sizeof(*regs), GFP_KERNEL); | |
| 737 | + regs = devm_kcalloc(cprman->dev, 7, sizeof(*regs), GFP_KERNEL); | |
| 738 | 738 | if (!regs) |
| 739 | 739 | return; |
| 740 | 740 | |
| @@ -865,7 +865,7 @@ static void bcm2835_pll_divider_debug_init(struct clk_hw *hw, · 124 unmodified lines | ||
| 865 | 865 | const struct bcm2835_pll_divider_data *data = divider->data; |
| 866 | 866 | struct debugfs_reg32 *regs; |
| 867 | 867 | |
| 868 | − regs = devm_kzalloc(cprman->dev, 7 * sizeof(*regs), GFP_KERNEL); | |
| 868 | + regs = devm_kcalloc(cprman->dev, 7, sizeof(*regs), GFP_KERNEL); | |
| 869 | 869 | if (!regs) |
| 870 | 870 | return; |
| 871 | 871 | |
| @@ -161,7 +161,7 @@ static void __init r8a7740_cpg_clocks_init(struct device_node *np) · 160 unmodified lines | ||
| 161 | 161 | } |
| 162 | 162 | |
| 163 | 163 | cpg = kzalloc(sizeof(*cpg), GFP_KERNEL); |
| 164 | − clks = kzalloc(num_clks * sizeof(*clks), GFP_KERNEL); | |
| 164 | + clks = kcalloc(num_clks, sizeof(*clks), GFP_KERNEL); | |
| 165 | 165 | if (cpg == NULL || clks == NULL) { |
| 166 | 166 | /* We're leaking memory on purpose, there's no point in cleaning |
| 167 | 167 | * up as the system won't boot anyway. |
| @@ -138,7 +138,7 @@ static void __init r8a7779_cpg_clocks_init(struct device_node *np) · 137 unmodified lines | ||
| 138 | 138 | } |
| 139 | 139 | |
| 140 | 140 | cpg = kzalloc(sizeof(*cpg), GFP_KERNEL); |
| 141 | − clks = kzalloc(CPG_NUM_CLOCKS * sizeof(*clks), GFP_KERNEL); | |
| 141 | + clks = kcalloc(CPG_NUM_CLOCKS, sizeof(*clks), GFP_KERNEL); | |
| 142 | 142 | if (cpg == NULL || clks == NULL) { |
| 143 | 143 | /* We're leaking memory on purpose, there's no point in cleaning |
| 144 | 144 | * up as the system won't boot anyway. |
| @@ -417,7 +417,7 @@ static void __init rcar_gen2_cpg_clocks_init(struct device_node *np) · 416 unmodified lines | ||
| 417 | 417 | } |
| 418 | 418 | |
| 419 | 419 | cpg = kzalloc(sizeof(*cpg), GFP_KERNEL); |
| 420 | − clks = kzalloc(num_clks * sizeof(*clks), GFP_KERNEL); | |
| 420 | + clks = kcalloc(num_clks, sizeof(*clks), GFP_KERNEL); | |
| 421 | 421 | if (cpg == NULL || clks == NULL) { |
| 422 | 422 | /* We're leaking memory on purpose, there's no point in cleaning |
| 423 | 423 | * up as the system won't boot anyway. |
| @@ -97,7 +97,7 @@ static void __init rz_cpg_clocks_init(struct device_node *np) · 96 unmodified lines | ||
| 97 | 97 | return; |
| 98 | 98 | |
| 99 | 99 | cpg = kzalloc(sizeof(*cpg), GFP_KERNEL); |
| 100 | − clks = kzalloc(num_clks * sizeof(*clks), GFP_KERNEL); | |
| 100 | + clks = kcalloc(num_clks, sizeof(*clks), GFP_KERNEL); | |
| 101 | 101 | BUG_ON(!cpg || !clks); |
| 102 | 102 | |
| 103 | 103 | cpg->data.clks = clks; |
| @@ -874,7 +874,7 @@ static void __init st_of_create_quadfs_fsynths( · 873 unmodified lines | ||
| 874 | 874 | return; |
| 875 | 875 | |
| 876 | 876 | clk_data->clk_num = QUADFS_MAX_CHAN; |
| 877 | − clk_data->clks = kzalloc(QUADFS_MAX_CHAN * sizeof(struct clk *), | |
| 877 | + clk_data->clks = kcalloc(QUADFS_MAX_CHAN, sizeof(struct clk *), | |
| 878 | 878 | GFP_KERNEL); |
| 879 | 879 | |
| 880 | 880 | if (!clk_data->clks) { |
| @@ -738,7 +738,7 @@ static void __init clkgen_c32_pll_setup(struct device_node *np, · 737 unmodified lines | ||
| 738 | 738 | return; |
| 739 | 739 | |
| 740 | 740 | clk_data->clk_num = num_odfs; |
| 741 | − clk_data->clks = kzalloc(clk_data->clk_num * sizeof(struct clk *), | |
| 741 | + clk_data->clks = kcalloc(clk_data->clk_num, sizeof(struct clk *), | |
| 742 | 742 | GFP_KERNEL); |
| 743 | 743 | |
| 744 | 744 | if (!clk_data->clks) |
| @@ -122,7 +122,7 @@ static void __init sunxi_usb_clk_setup(struct device_node *node, · 121 unmodified lines | ||
| 122 | 122 | if (!clk_data) |
| 123 | 123 | return; |
| 124 | 124 | |
| 125 | − clk_data->clks = kzalloc((qty+1) * sizeof(struct clk *), GFP_KERNEL); | |
| 125 | + clk_data->clks = kcalloc(qty + 1, sizeof(struct clk *), GFP_KERNEL); | |
| 126 | 126 | if (!clk_data->clks) { |
| 127 | 127 | kfree(clk_data); |
| 128 | 128 | return; |
| @@ -216,14 +216,15 @@ struct clk ** __init tegra_clk_init(void __iomem *regs, int num, int banks) · 215 unmodified lines | ||
| 216 | 216 | if (WARN_ON(banks > ARRAY_SIZE(periph_regs))) |
| 217 | 217 | return NULL; |
| 218 | 218 | |
| 219 | − periph_clk_enb_refcnt = kzalloc(32 * banks * | |
| 220 | − sizeof(*periph_clk_enb_refcnt), GFP_KERNEL); | |
| 219 | + periph_clk_enb_refcnt = kcalloc(32 * banks, | |
| 220 | + sizeof(*periph_clk_enb_refcnt), | |
| 221 | + GFP_KERNEL); | |
| 221 | 222 | if (!periph_clk_enb_refcnt) |
| 222 | 223 | return NULL; |
| 223 | 224 | |
| 224 | 225 | periph_banks = banks; |
| 225 | 226 | |
| 226 | − clks = kzalloc(num * sizeof(struct clk *), GFP_KERNEL); | |
| 227 | + clks = kcalloc(num, sizeof(struct clk *), GFP_KERNEL); | |
| 227 | 228 | if (!clks) |
| 228 | 229 | kfree(periph_clk_enb_refcnt); |
| 229 | 230 | |
| @@ -501,8 +501,9 @@ static int ti_adpll_init_dco(struct ti_adpll_data *d) · 500 unmodified lines | ||
| 501 | 501 | const char *postfix; |
| 502 | 502 | int width, err; |
| 503 | 503 | |
| 504 | − d->outputs.clks = devm_kzalloc(d->dev, sizeof(struct clk *) * | |
| 504 | + d->outputs.clks = devm_kcalloc(d->dev, | |
| 505 | 505 | MAX_ADPLL_OUTPUTS, |
| 506 | + sizeof(struct clk *), | |
| 506 | 507 | GFP_KERNEL); |
| 507 | 508 | if (!d->outputs.clks) |
| 508 | 509 | return -ENOMEM; |
| @@ -915,8 +916,9 @@ static int ti_adpll_probe(struct platform_device *pdev) · 406 unmodified lines | ||
| 915 | 916 | if (err) |
| 916 | 917 | return err; |
| 917 | 918 | |
| 918 | − d->clocks = devm_kzalloc(d->dev, sizeof(struct ti_adpll_clock) * | |
| 919 | + d->clocks = devm_kcalloc(d->dev, | |
| 919 | 920 | TI_ADPLL_NR_CLOCKS, |
| 921 | + sizeof(struct ti_adpll_clock), | |
| 920 | 922 | GFP_KERNEL); |
| 921 | 923 | if (!d->clocks) |
| 922 | 924 | return -ENOMEM; |
| @@ -206,7 +206,7 @@ static void __init of_dra7_apll_setup(struct device_node *node) · 205 unmodified lines | ||
| 206 | 206 | goto cleanup; |
| 207 | 207 | } |
| 208 | 208 | |
| 209 | − parent_names = kzalloc(sizeof(char *) * init->num_parents, GFP_KERNEL); | |
| 209 | + parent_names = kcalloc(init->num_parents, sizeof(char *), GFP_KERNEL); | |
| 210 | 210 | if (!parent_names) |
| 211 | 211 | goto cleanup; |
| 212 | 212 | |
| @@ -366,7 +366,7 @@ int ti_clk_parse_divider_data(int *div_table, int num_dividers, int max_div, · 365 unmodified lines | ||
| 366 | 366 | |
| 367 | 367 | num_dividers = i; |
| 368 | 368 | |
| 369 | − tmp = kzalloc(sizeof(*tmp) * (valid_div + 1), GFP_KERNEL); | |
| 369 | + tmp = kcalloc(valid_div + 1, sizeof(*tmp), GFP_KERNEL); | |
| 370 | 370 | if (!tmp) |
| 371 | 371 | return -ENOMEM; |
| 372 | 372 | |
| @@ -496,7 +496,7 @@ __init ti_clk_get_div_table(struct device_node *node) · 123 unmodified lines | ||
| 496 | 496 | return ERR_PTR(-EINVAL); |
| 497 | 497 | } |
| 498 | 498 | |
| 499 | − table = kzalloc(sizeof(*table) * (valid_div + 1), GFP_KERNEL); | |
| 499 | + table = kcalloc(valid_div + 1, sizeof(*table), GFP_KERNEL); | |
| 500 | 500 | |
| 501 | 501 | if (!table) |
| 502 | 502 | return ERR_PTR(-ENOMEM); |
| @@ -309,7 +309,7 @@ static void __init of_ti_dpll_setup(struct device_node *node, · 308 unmodified lines | ||
| 309 | 309 | goto cleanup; |
| 310 | 310 | } |
| 311 | 311 | |
| 312 | − parent_names = kzalloc(sizeof(char *) * init->num_parents, GFP_KERNEL); | |
| 312 | + parent_names = kcalloc(init->num_parents, sizeof(char *), GFP_KERNEL); | |
| 313 | 313 | if (!parent_names) |
| 314 | 314 | goto cleanup; |
| 315 | 315 | |
| @@ -1000,7 +1000,7 @@ static int sh_cmt_setup(struct sh_cmt_device *cmt, struct platform_device *pdev) · 999 unmodified lines | ||
| 1000 | 1000 | |
| 1001 | 1001 | /* Allocate and setup the channels. */ |
| 1002 | 1002 | cmt->num_channels = hweight8(cmt->hw_channels); |
| 1003 | − cmt->channels = kzalloc(cmt->num_channels * sizeof(*cmt->channels), | |
| 1003 | + cmt->channels = kcalloc(cmt->num_channels, sizeof(*cmt->channels), | |
| 1004 | 1004 | GFP_KERNEL); |
| 1005 | 1005 | if (cmt->channels == NULL) { |
| 1006 | 1006 | ret = -ENOMEM; |
| @@ -418,7 +418,7 @@ static int sh_mtu2_setup(struct sh_mtu2_device *mtu, · 417 unmodified lines | ||
| 418 | 418 | /* Allocate and setup the channels. */ |
| 419 | 419 | mtu->num_channels = 3; |
| 420 | 420 | |
| 421 | − mtu->channels = kzalloc(sizeof(*mtu->channels) * mtu->num_channels, | |
| 421 | + mtu->channels = kcalloc(mtu->num_channels, sizeof(*mtu->channels), | |
| 422 | 422 | GFP_KERNEL); |
| 423 | 423 | if (mtu->channels == NULL) { |
| 424 | 424 | ret = -ENOMEM; |
| @@ -569,7 +569,7 @@ static int sh_tmu_setup(struct sh_tmu_device *tmu, struct platform_device *pdev) · 568 unmodified lines | ||
| 569 | 569 | } |
| 570 | 570 | |
| 571 | 571 | /* Allocate and setup the channels. */ |
| 572 | − tmu->channels = kzalloc(sizeof(*tmu->channels) * tmu->num_channels, | |
| 572 | + tmu->channels = kcalloc(tmu->num_channels, sizeof(*tmu->channels), | |
| 573 | 573 | GFP_KERNEL); |
| 574 | 574 | if (tmu->channels == NULL) { |
| 575 | 575 | ret = -ENOMEM; |
| @@ -759,8 +759,8 @@ static int acpi_cpufreq_cpu_init(struct cpufreq_policy *policy) · 758 unmodified lines | ||
| 759 | 759 | goto err_unreg; |
| 760 | 760 | } |
| 761 | 761 | |
| 762 | − freq_table = kzalloc(sizeof(*freq_table) * | |
| 763 | − (perf->state_count+1), GFP_KERNEL); | |
| 762 | + freq_table = kcalloc(perf->state_count + 1, sizeof(*freq_table), | |
| 763 | + GFP_KERNEL); | |
| 764 | 764 | if (!freq_table) { |
| 765 | 765 | result = -ENOMEM; |
| 766 | 766 | goto err_unreg; |
| @@ -280,7 +280,7 @@ static int merge_cluster_tables(void) · 279 unmodified lines | ||
| 280 | 280 | for (i = 0; i < MAX_CLUSTERS; i++) |
| 281 | 281 | count += get_table_count(freq_table[i]); |
| 282 | 282 | |
| 283 | − table = kzalloc(sizeof(*table) * count, GFP_KERNEL); | |
| 283 | + table = kcalloc(count, sizeof(*table), GFP_KERNEL); | |
| 284 | 284 | if (!table) |
| 285 | 285 | return -ENOMEM; |
| 286 | 286 | |
| @@ -71,7 +71,7 @@ bmips_cpufreq_get_freq_table(const struct cpufreq_policy *policy) · 70 unmodified lines | ||
| 71 | 71 | |
| 72 | 72 | cpu_freq = htp_freq_to_cpu_freq(priv->clk_mult); |
| 73 | 73 | |
| 74 | − table = kmalloc((priv->max_freqs + 1) * sizeof(*table), GFP_KERNEL); | |
| 74 | + table = kmalloc_array(priv->max_freqs + 1, sizeof(*table), GFP_KERNEL); | |
| 75 | 75 | if (!table) |
| 76 | 76 | return ERR_PTR(-ENOMEM); |
| 77 | 77 | |
| @@ -410,7 +410,7 @@ brcm_avs_get_freq_table(struct device *dev, struct private_data *priv) · 409 unmodified lines | ||
| 410 | 410 | if (ret) |
| 411 | 411 | return ERR_PTR(ret); |
| 412 | 412 | |
| 413 | − table = devm_kzalloc(dev, (AVS_PSTATE_MAX + 1) * sizeof(*table), | |
| 413 | + table = devm_kcalloc(dev, AVS_PSTATE_MAX + 1, sizeof(*table), | |
| 414 | 414 | GFP_KERNEL); |
| 415 | 415 | if (!table) |
| 416 | 416 | return ERR_PTR(-ENOMEM); |
| @@ -313,7 +313,8 @@ static int __init cppc_cpufreq_init(void) · 312 unmodified lines | ||
| 313 | 313 | if (acpi_disabled) |
| 314 | 314 | return -ENODEV; |
| 315 | 315 | |
| 316 | − all_cpu_data = kzalloc(sizeof(void *) * num_possible_cpus(), GFP_KERNEL); | |
| 316 | + all_cpu_data = kcalloc(num_possible_cpus(), sizeof(void *), | |
| 317 | + GFP_KERNEL); | |
| 317 | 318 | if (!all_cpu_data) |
| 318 | 319 | return -ENOMEM; |
| 319 | 320 | |
| @@ -241,8 +241,8 @@ acpi_cpufreq_cpu_init ( · 240 unmodified lines | ||
| 241 | 241 | } |
| 242 | 242 | |
| 243 | 243 | /* alloc freq_table */ |
| 244 | − freq_table = kzalloc(sizeof(*freq_table) * | |
| 245 | − (data->acpi_data.state_count + 1), | |
| 244 | + freq_table = kcalloc(data->acpi_data.state_count + 1, | |
| 245 | + sizeof(*freq_table), | |
| 246 | 246 | GFP_KERNEL); |
| 247 | 247 | if (!freq_table) { |
| 248 | 248 | result = -ENOMEM; |
| @@ -377,7 +377,8 @@ static int imx6q_cpufreq_probe(struct platform_device *pdev) · 376 unmodified lines | ||
| 377 | 377 | } |
| 378 | 378 | |
| 379 | 379 | /* Make imx6_soc_volt array's size same as arm opp number */ |
| 380 | − imx6_soc_volt = devm_kzalloc(cpu_dev, sizeof(*imx6_soc_volt) * num, GFP_KERNEL); | |
| 380 | + imx6_soc_volt = devm_kcalloc(cpu_dev, num, sizeof(*imx6_soc_volt), | |
| 381 | + GFP_KERNEL); | |
| 381 | 382 | if (imx6_soc_volt == NULL) { |
| 382 | 383 | ret = -ENOMEM; |
| 383 | 384 | goto free_freq_table; |
| @@ -2339,7 +2339,7 @@ hwp_cpu_matched: · 2338 unmodified lines | ||
| 2339 | 2339 | |
| 2340 | 2340 | pr_info("Intel P-state driver initializing\n"); |
| 2341 | 2341 | |
| 2342 | − all_cpu_data = vzalloc(sizeof(void *) * num_possible_cpus()); | |
| 2342 | + all_cpu_data = vzalloc(array_size(sizeof(void *), num_possible_cpus())); | |
| 2343 | 2343 | if (!all_cpu_data) |
| 2344 | 2344 | return -ENOMEM; |
| 2345 | 2345 | |
| @@ -474,8 +474,8 @@ static int longhaul_get_ranges(void) · 473 unmodified lines | ||
| 474 | 474 | return -EINVAL; |
| 475 | 475 | } |
| 476 | 476 | |
| 477 | − longhaul_table = kzalloc((numscales + 1) * sizeof(*longhaul_table), | |
| 478 | − GFP_KERNEL); | |
| 477 | + longhaul_table = kcalloc(numscales + 1, sizeof(*longhaul_table), | |
| 478 | + GFP_KERNEL); | |
| 479 | 479 | if (!longhaul_table) |
| 480 | 480 | return -ENOMEM; |
| 481 | 481 | |
| @@ -93,7 +93,7 @@ static int setup_freqs_table(struct cpufreq_policy *policy, · 92 unmodified lines | ||
| 93 | 93 | struct cpufreq_frequency_table *table; |
| 94 | 94 | int i; |
| 95 | 95 | |
| 96 | − table = kzalloc((num + 1) * sizeof(*table), GFP_KERNEL); | |
| 96 | + table = kcalloc(num + 1, sizeof(*table), GFP_KERNEL); | |
| 97 | 97 | if (table == NULL) |
| 98 | 98 | return -ENOMEM; |
| 99 | 99 | |
| @@ -562,7 +562,7 @@ static int s3c_cpufreq_build_freq(void) · 561 unmodified lines | ||
| 562 | 562 | size = cpu_cur.info->calc_freqtable(&cpu_cur, NULL, 0); |
| 563 | 563 | size++; |
| 564 | 564 | |
| 565 | − ftab = kzalloc(sizeof(*ftab) * size, GFP_KERNEL); | |
| 565 | + ftab = kcalloc(size, sizeof(*ftab), GFP_KERNEL); | |
| 566 | 566 | if (!ftab) |
| 567 | 567 | return -ENOMEM; |
| 568 | 568 | |
| @@ -95,8 +95,8 @@ static int __init sfi_cpufreq_init(void) · 94 unmodified lines | ||
| 95 | 95 | if (ret) |
| 96 | 96 | return ret; |
| 97 | 97 | |
| 98 | − freq_table = kzalloc(sizeof(*freq_table) * | |
| 99 | − (num_freq_table_entries + 1), GFP_KERNEL); | |
| 98 | + freq_table = kcalloc(num_freq_table_entries + 1, sizeof(*freq_table), | |
| 99 | + GFP_KERNEL); | |
| 100 | 100 | if (!freq_table) { |
| 101 | 101 | ret = -ENOMEM; |
| 102 | 102 | goto err_free_array; |
| @@ -195,7 +195,7 @@ static int spear_cpufreq_probe(struct platform_device *pdev) · 194 unmodified lines | ||
| 195 | 195 | cnt = prop->length / sizeof(u32); |
| 196 | 196 | val = prop->value; |
| 197 | 197 | |
| 198 | − freq_tbl = kzalloc(sizeof(*freq_tbl) * (cnt + 1), GFP_KERNEL); | |
| 198 | + freq_tbl = kcalloc(cnt + 1, sizeof(*freq_tbl), GFP_KERNEL); | |
| 199 | 199 | if (!freq_tbl) { |
| 200 | 200 | ret = -ENOMEM; |
| 201 | 201 | goto out_put_node; |
| @@ -141,11 +141,11 @@ static void crypto4xx_hw_init(struct crypto4xx_device *dev) · 140 unmodified lines | ||
| 141 | 141 | |
| 142 | 142 | int crypto4xx_alloc_sa(struct crypto4xx_ctx *ctx, u32 size) |
| 143 | 143 | { |
| 144 | − ctx->sa_in = kzalloc(size * 4, GFP_ATOMIC); | |
| 144 | + ctx->sa_in = kcalloc(size, 4, GFP_ATOMIC); | |
| 145 | 145 | if (ctx->sa_in == NULL) |
| 146 | 146 | return -ENOMEM; |
| 147 | 147 | |
| 148 | − ctx->sa_out = kzalloc(size * 4, GFP_ATOMIC); | |
| 148 | + ctx->sa_out = kcalloc(size, 4, GFP_ATOMIC); | |
| 149 | 149 | if (ctx->sa_out == NULL) { |
| 150 | 150 | kfree(ctx->sa_in); |
| 151 | 151 | ctx->sa_in = NULL; |
| @@ -180,8 +180,8 @@ static u32 crypto4xx_build_pdr(struct crypto4xx_device *dev) · 28 unmodified lines | ||
| 180 | 180 | if (!dev->pdr) |
| 181 | 181 | return -ENOMEM; |
| 182 | 182 | |
| 183 | − dev->pdr_uinfo = kzalloc(sizeof(struct pd_uinfo) * PPC4XX_NUM_PD, | |
| 184 | − GFP_KERNEL); | |
| 183 | + dev->pdr_uinfo = kcalloc(PPC4XX_NUM_PD, sizeof(struct pd_uinfo), | |
| 184 | + GFP_KERNEL); | |
| 185 | 185 | if (!dev->pdr_uinfo) { |
| 186 | 186 | dma_free_coherent(dev->core_dev->device, |
| 187 | 187 | sizeof(struct ce_pd) * PPC4XX_NUM_PD, |
| @@ -254,7 +254,7 @@ static int nitrox_enable_msix(struct nitrox_device *ndev) · 253 unmodified lines | ||
| 254 | 254 | * Entry 192: NPS_CORE_INT_ACTIVE |
| 255 | 255 | */ |
| 256 | 256 | nr_entries = (ndev->nr_queues * NR_RING_VECTORS) + 1; |
| 257 | − entries = kzalloc_node(nr_entries * sizeof(struct msix_entry), | |
| 257 | + entries = kcalloc_node(nr_entries, sizeof(struct msix_entry), | |
| 258 | 258 | GFP_KERNEL, ndev->node); |
| 259 | 259 | if (!entries) |
| 260 | 260 | return -ENOMEM; |
| @@ -240,7 +240,7 @@ static int tls_copy_ivs(struct sock *sk, struct sk_buff *skb) · 239 unmodified lines | ||
| 240 | 240 | } |
| 241 | 241 | |
| 242 | 242 | /* generate the IVs */ |
| 243 | − ivs = kmalloc(number_of_ivs * CIPHER_BLOCK_SIZE, GFP_ATOMIC); | |
| 243 | + ivs = kmalloc_array(CIPHER_BLOCK_SIZE, number_of_ivs, GFP_ATOMIC); | |
| 244 | 244 | if (!ivs) |
| 245 | 245 | return -ENOMEM; |
| 246 | 246 | get_random_bytes(ivs, number_of_ivs * CIPHER_BLOCK_SIZE); |
| @@ -922,7 +922,7 @@ int safexcel_hmac_setkey(const char *alg, const u8 *key, unsigned int keylen, · 921 unmodified lines | ||
| 922 | 922 | crypto_ahash_clear_flags(tfm, ~0); |
| 923 | 923 | blocksize = crypto_tfm_alg_blocksize(crypto_ahash_tfm(tfm)); |
| 924 | 924 | |
| 925 | − ipad = kzalloc(2 * blocksize, GFP_KERNEL); | |
| 925 | + ipad = kcalloc(2, blocksize, GFP_KERNEL); | |
| 926 | 926 | if (!ipad) { |
| 927 | 927 | ret = -ENOMEM; |
| 928 | 928 | goto free_request; |
| @@ -471,7 +471,7 @@ static int mv_cesa_probe(struct platform_device *pdev) · 470 unmodified lines | ||
| 471 | 471 | sram_size = CESA_SA_MIN_SRAM_SIZE; |
| 472 | 472 | |
| 473 | 473 | cesa->sram_size = sram_size; |
| 474 | − cesa->engines = devm_kzalloc(dev, caps->nengines * sizeof(*engines), | |
| 474 | + cesa->engines = devm_kcalloc(dev, caps->nengines, sizeof(*engines), | |
| 475 | 475 | GFP_KERNEL); |
| 476 | 476 | if (!cesa->engines) |
| 477 | 477 | return -ENOMEM; |
| @@ -1198,7 +1198,7 @@ static int mv_cesa_ahmac_setkey(const char *hash_alg_name, · 1197 unmodified lines | ||
| 1198 | 1198 | |
| 1199 | 1199 | blocksize = crypto_tfm_alg_blocksize(crypto_ahash_tfm(tfm)); |
| 1200 | 1200 | |
| 1201 | − ipad = kzalloc(2 * blocksize, GFP_KERNEL); | |
| 1201 | + ipad = kcalloc(2, blocksize, GFP_KERNEL); | |
| 1202 | 1202 | if (!ipad) { |
| 1203 | 1203 | ret = -ENOMEM; |
| 1204 | 1204 | goto free_req; |
| @@ -1919,12 +1919,12 @@ static int grab_global_resources(void) · 1918 unmodified lines | ||
| 1919 | 1919 | goto out_hvapi_release; |
| 1920 | 1920 | |
| 1921 | 1921 | err = -ENOMEM; |
| 1922 | − cpu_to_cwq = kzalloc(sizeof(struct spu_queue *) * NR_CPUS, | |
| 1922 | + cpu_to_cwq = kcalloc(NR_CPUS, sizeof(struct spu_queue *), | |
| 1923 | 1923 | GFP_KERNEL); |
| 1924 | 1924 | if (!cpu_to_cwq) |
| 1925 | 1925 | goto out_queue_cache_destroy; |
| 1926 | 1926 | |
| 1927 | − cpu_to_mau = kzalloc(sizeof(struct spu_queue *) * NR_CPUS, | |
| 1927 | + cpu_to_mau = kcalloc(NR_CPUS, sizeof(struct spu_queue *), | |
| 1928 | 1928 | GFP_KERNEL); |
| 1929 | 1929 | if (!cpu_to_mau) |
| 1930 | 1930 | goto out_free_cwq_table; |
| @@ -238,7 +238,7 @@ static int adf_isr_alloc_msix_entry_table(struct adf_accel_dev *accel_dev) · 237 unmodified lines | ||
| 238 | 238 | if (!accel_dev->pf.vf_info) |
| 239 | 239 | msix_num_entries += hw_data->num_banks; |
| 240 | 240 | |
| 241 | − entries = kzalloc_node(msix_num_entries * sizeof(*entries), | |
| 241 | + entries = kcalloc_node(msix_num_entries, sizeof(*entries), | |
| 242 | 242 | GFP_KERNEL, dev_to_node(&GET_DEV(accel_dev))); |
| 243 | 243 | if (!entries) |
| 244 | 244 | return -ENOMEM; |
| @@ -1162,8 +1162,9 @@ static int qat_uclo_map_suof(struct icp_qat_fw_loader_handle *handle, · 1161 unmodified lines | ||
| 1162 | 1162 | suof_handle->img_table.num_simgs = suof_ptr->num_chunks - 1; |
| 1163 | 1163 | |
| 1164 | 1164 | if (suof_handle->img_table.num_simgs != 0) { |
| 1165 | − suof_img_hdr = kzalloc(suof_handle->img_table.num_simgs * | |
| 1166 | − sizeof(img_header), GFP_KERNEL); | |
| 1165 | + suof_img_hdr = kcalloc(suof_handle->img_table.num_simgs, | |
| 1166 | + sizeof(img_header), | |
| 1167 | + GFP_KERNEL); | |
| 1167 | 1168 | if (!suof_img_hdr) |
| 1168 | 1169 | return -ENOMEM; |
| 1169 | 1170 | suof_handle->img_table.simg_hdr = suof_img_hdr; |
| @@ -970,8 +970,9 @@ static int stm32_hash_export(struct ahash_request *req, void *out) · 969 unmodified lines | ||
| 970 | 970 | while (!(stm32_hash_read(hdev, HASH_SR) & HASH_SR_DATA_INPUT_READY)) |
| 971 | 971 | cpu_relax(); |
| 972 | 972 | |
| 973 | − rctx->hw_context = kmalloc(sizeof(u32) * (3 + HASH_CSR_REGISTER_NUMBER), | |
| 974 | − GFP_KERNEL); | |
| 973 | + rctx->hw_context = kmalloc_array(3 + HASH_CSR_REGISTER_NUMBER, | |
| 974 | + sizeof(u32), | |
| 975 | + GFP_KERNEL); | |
| 975 | 976 | |
| 976 | 977 | preg = rctx->hw_context; |
| 977 | 978 | |
| @@ -3393,8 +3393,10 @@ static int talitos_probe(struct platform_device *ofdev) · 3392 unmodified lines | ||
| 3393 | 3393 | } |
| 3394 | 3394 | } |
| 3395 | 3395 | |
| 3396 | − priv->chan = devm_kzalloc(dev, sizeof(struct talitos_channel) * | |
| 3397 | − priv->num_channels, GFP_KERNEL); | |
| 3396 | + priv->chan = devm_kcalloc(dev, | |
| 3397 | + priv->num_channels, | |
| 3398 | + sizeof(struct talitos_channel), | |
| 3399 | + GFP_KERNEL); | |
| 3398 | 3400 | if (!priv->chan) { |
| 3399 | 3401 | dev_err(dev, "failed to allocate channel management space\n"); |
| 3400 | 3402 | err = -ENOMEM; |
| @@ -3411,9 +3413,10 @@ static int talitos_probe(struct platform_device *ofdev) · 10 unmodified lines | ||
| 3411 | 3413 | spin_lock_init(&priv->chan[i].head_lock); |
| 3412 | 3414 | spin_lock_init(&priv->chan[i].tail_lock); |
| 3413 | 3415 | |
| 3414 | − priv->chan[i].fifo = devm_kzalloc(dev, | |
| 3415 | − sizeof(struct talitos_request) * | |
| 3416 | − priv->fifo_len, GFP_KERNEL); | |
| 3416 | + priv->chan[i].fifo = devm_kcalloc(dev, | |
| 3417 | + priv->fifo_len, | |
| 3418 | + sizeof(struct talitos_request), | |
| 3419 | + GFP_KERNEL); | |
| 3417 | 3420 | if (!priv->chan[i].fifo) { |
| 3418 | 3421 | dev_err(dev, "failed to allocate request fifo %d\n", i); |
| 3419 | 3422 | err = -ENOMEM; |
| @@ -371,7 +371,7 @@ __virtio_crypto_ablkcipher_do_req(struct virtio_crypto_sym_request *vc_sym_req, · 370 unmodified lines | ||
| 371 | 371 | |
| 372 | 372 | /* Why 3? outhdr + iv + inhdr */ |
| 373 | 373 | sg_total = src_nents + dst_nents + 3; |
| 374 | − sgs = kzalloc_node(sg_total * sizeof(*sgs), GFP_ATOMIC, | |
| 374 | + sgs = kcalloc_node(sg_total, sizeof(*sgs), GFP_ATOMIC, | |
| 375 | 375 | dev_to_node(&vcrypto->vdev->dev)); |
| 376 | 376 | if (!sgs) |
| 377 | 377 | return -ENOMEM; |
| @@ -628,14 +628,15 @@ struct devfreq *devfreq_add_device(struct device *dev, · 627 unmodified lines | ||
| 628 | 628 | goto err_dev; |
| 629 | 629 | } |
| 630 | 630 | |
| 631 | − devfreq->trans_table = devm_kzalloc(&devfreq->dev, | |
| 632 | − sizeof(unsigned int) * | |
| 633 | − devfreq->profile->max_state * | |
| 634 | − devfreq->profile->max_state, | |
| 635 | − GFP_KERNEL); | |
| 636 | − devfreq->time_in_state = devm_kzalloc(&devfreq->dev, | |
| 637 | − sizeof(unsigned long) * | |
| 631 | + devfreq->trans_table = | |
| 632 | + devm_kzalloc(&devfreq->dev, | |
| 633 | + array3_size(sizeof(unsigned int), | |
| 634 | + devfreq->profile->max_state, | |
| 635 | + devfreq->profile->max_state), | |
| 636 | + GFP_KERNEL); | |
| 637 | + devfreq->time_in_state = devm_kcalloc(&devfreq->dev, | |
| 638 | 638 | devfreq->profile->max_state, |
| 639 | + sizeof(unsigned long), | |
| 639 | 640 | GFP_KERNEL); |
| 640 | 641 | devfreq->last_stat_updated = jiffies; |
| 641 | 642 | |
| @@ -518,7 +518,7 @@ static int of_get_devfreq_events(struct device_node *np, · 517 unmodified lines | ||
| 518 | 518 | event_ops = exynos_bus_get_ops(np); |
| 519 | 519 | |
| 520 | 520 | count = of_get_child_count(events_np); |
| 521 | − desc = devm_kzalloc(dev, sizeof(*desc) * count, GFP_KERNEL); | |
| 521 | + desc = devm_kcalloc(dev, count, sizeof(*desc), GFP_KERNEL); | |
| 522 | 522 | if (!desc) |
| 523 | 523 | return -ENOMEM; |
| 524 | 524 | info->num_events = count; |
| @@ -87,7 +87,8 @@ bcom_task_alloc(int bd_count, int bd_size, int priv_size) · 86 unmodified lines | ||
| 87 | 87 | |
| 88 | 88 | /* Init the BDs, if needed */ |
| 89 | 89 | if (bd_count) { |
| 90 | − tsk->cookie = kmalloc(sizeof(void*) * bd_count, GFP_KERNEL); | |
| 90 | + tsk->cookie = kmalloc_array(bd_count, sizeof(void *), | |
| 91 | + GFP_KERNEL); | |
| 91 | 92 | if (!tsk->cookie) |
| 92 | 93 | goto error; |
| 93 | 94 | |
| @@ -322,10 +322,10 @@ static int ioat_dma_self_test(struct ioatdma_device *ioat_dma) · 321 unmodified lines | ||
| 322 | 322 | unsigned long tmo; |
| 323 | 323 | unsigned long flags; |
| 324 | 324 | |
| 325 | − src = kzalloc(sizeof(u8) * IOAT_TEST_SIZE, GFP_KERNEL); | |
| 325 | + src = kzalloc(IOAT_TEST_SIZE, GFP_KERNEL); | |
| 326 | 326 | if (!src) |
| 327 | 327 | return -ENOMEM; |
| 328 | − dest = kzalloc(sizeof(u8) * IOAT_TEST_SIZE, GFP_KERNEL); | |
| 328 | + dest = kzalloc(IOAT_TEST_SIZE, GFP_KERNEL); | |
| 329 | 329 | if (!dest) { |
| 330 | 330 | kfree(src); |
| 331 | 331 | return -ENOMEM; |
| @@ -910,7 +910,8 @@ out: · 909 unmodified lines | ||
| 910 | 910 | /* Called with ichan->chan_mutex held */ |
| 911 | 911 | static int idmac_desc_alloc(struct idmac_channel *ichan, int n) |
| 912 | 912 | { |
| 913 | − struct idmac_tx_desc *desc = vmalloc(n * sizeof(struct idmac_tx_desc)); | |
| 913 | + struct idmac_tx_desc *desc = | |
| 914 | + vmalloc(array_size(n, sizeof(struct idmac_tx_desc))); | |
| 914 | 915 | struct idmac *idmac = to_idmac(ichan->dma_chan.device); |
| 915 | 916 | |
| 916 | 917 | if (!desc) |
| @@ -848,8 +848,8 @@ static int k3_dma_probe(struct platform_device *op) · 847 unmodified lines | ||
| 848 | 848 | return -ENOMEM; |
| 849 | 849 | |
| 850 | 850 | /* init phy channel */ |
| 851 | − d->phy = devm_kzalloc(&op->dev, | |
| 852 | − d->dma_channels * sizeof(struct k3_dma_phy), GFP_KERNEL); | |
| 851 | + d->phy = devm_kcalloc(&op->dev, | |
| 852 | + d->dma_channels, sizeof(struct k3_dma_phy), GFP_KERNEL); | |
| 853 | 853 | if (d->phy == NULL) |
| 854 | 854 | return -ENOMEM; |
| 855 | 855 | |
| @@ -879,8 +879,8 @@ static int k3_dma_probe(struct platform_device *op) · 23 unmodified lines | ||
| 879 | 879 | d->slave.copy_align = DMAENGINE_ALIGN_8_BYTES; |
| 880 | 880 | |
| 881 | 881 | /* init virtual channel */ |
| 882 | − d->chans = devm_kzalloc(&op->dev, | |
| 883 | − d->dma_requests * sizeof(struct k3_dma_chan), GFP_KERNEL); | |
| 882 | + d->chans = devm_kcalloc(&op->dev, | |
| 883 | + d->dma_requests, sizeof(struct k3_dma_chan), GFP_KERNEL); | |
| 884 | 884 | if (d->chans == NULL) |
| 885 | 885 | return -ENOMEM; |
| 886 | 886 | |
| @@ -385,7 +385,8 @@ static int mic_dma_alloc_desc_ring(struct mic_dma_chan *ch) · 384 unmodified lines | ||
| 385 | 385 | if (dma_mapping_error(dev, ch->desc_ring_micpa)) |
| 386 | 386 | goto map_error; |
| 387 | 387 | |
| 388 | − ch->tx_array = vzalloc(MIC_DMA_DESC_RX_SIZE * sizeof(*ch->tx_array)); | |
| 388 | + ch->tx_array = vzalloc(array_size(MIC_DMA_DESC_RX_SIZE, | |
| 389 | + sizeof(*ch->tx_array))); | |
| 389 | 390 | if (!ch->tx_array) |
| 390 | 391 | goto tx_error; |
| 391 | 392 | return 0; |
| @@ -777,11 +777,11 @@ static int mv_chan_memcpy_self_test(struct mv_xor_chan *mv_chan) · 776 unmodified lines | ||
| 777 | 777 | struct dmaengine_unmap_data *unmap; |
| 778 | 778 | int err = 0; |
| 779 | 779 | |
| 780 | − src = kmalloc(sizeof(u8) * PAGE_SIZE, GFP_KERNEL); | |
| 780 | + src = kmalloc(PAGE_SIZE, GFP_KERNEL); | |
| 781 | 781 | if (!src) |
| 782 | 782 | return -ENOMEM; |
| 783 | 783 | |
| 784 | − dest = kzalloc(sizeof(u8) * PAGE_SIZE, GFP_KERNEL); | |
| 784 | + dest = kzalloc(PAGE_SIZE, GFP_KERNEL); | |
| 785 | 785 | if (!dest) { |
| 786 | 786 | kfree(src); |
| 787 | 787 | return -ENOMEM; |
| @@ -809,8 +809,9 @@ static int mv_xor_v2_probe(struct platform_device *pdev) · 808 unmodified lines | ||
| 809 | 809 | } |
| 810 | 810 | |
| 811 | 811 | /* alloc memory for the SW descriptors */ |
| 812 | − xor_dev->sw_desq = devm_kzalloc(&pdev->dev, sizeof(*sw_desc) * | |
| 813 | − MV_XOR_V2_DESC_NUM, GFP_KERNEL); | |
| 812 | + xor_dev->sw_desq = devm_kcalloc(&pdev->dev, | |
| 813 | + MV_XOR_V2_DESC_NUM, sizeof(*sw_desc), | |
| 814 | + GFP_KERNEL); | |
| 814 | 815 | if (!xor_dev->sw_desq) { |
| 815 | 816 | ret = -ENOMEM; |
| 816 | 817 | goto free_hw_desq; |
| @@ -1866,7 +1866,7 @@ static int dmac_alloc_threads(struct pl330_dmac *pl330) · 1865 unmodified lines | ||
| 1866 | 1866 | int i; |
| 1867 | 1867 | |
| 1868 | 1868 | /* Allocate 1 Manager and 'chans' Channel threads */ |
| 1869 | − pl330->channels = kzalloc((1 + chans) * sizeof(*thrd), | |
| 1869 | + pl330->channels = kcalloc(1 + chans, sizeof(*thrd), | |
| 1870 | 1870 | GFP_KERNEL); |
| 1871 | 1871 | if (!pl330->channels) |
| 1872 | 1872 | return -ENOMEM; |
| @@ -2990,7 +2990,7 @@ pl330_probe(struct amba_device *adev, const struct amba_id *id) · 1117 unmodified lines | ||
| 2990 | 2990 | |
| 2991 | 2991 | pl330->num_peripherals = num_chan; |
| 2992 | 2992 | |
| 2993 | − pl330->peripherals = kzalloc(num_chan * sizeof(*pch), GFP_KERNEL); | |
| 2993 | + pl330->peripherals = kcalloc(num_chan, sizeof(*pch), GFP_KERNEL); | |
| 2994 | 2994 | if (!pl330->peripherals) { |
| 2995 | 2995 | ret = -ENOMEM; |
| 2996 | 2996 | goto probe_err2; |
| @@ -1223,9 +1223,9 @@ static int s3c24xx_dma_probe(struct platform_device *pdev) · 1222 unmodified lines | ||
| 1223 | 1223 | if (IS_ERR(s3cdma->base)) |
| 1224 | 1224 | return PTR_ERR(s3cdma->base); |
| 1225 | 1225 | |
| 1226 | − s3cdma->phy_chans = devm_kzalloc(&pdev->dev, | |
| 1227 | − sizeof(struct s3c24xx_dma_phy) * | |
| 1228 | − pdata->num_phy_channels, | |
| 1226 | + s3cdma->phy_chans = devm_kcalloc(&pdev->dev, | |
| 1227 | + pdata->num_phy_channels, | |
| 1228 | + sizeof(struct s3c24xx_dma_phy), | |
| 1229 | 1229 | GFP_KERNEL); |
| 1230 | 1230 | if (!s3cdma->phy_chans) |
| 1231 | 1231 | return -ENOMEM; |
| @@ -1045,8 +1045,9 @@ EXPORT_SYMBOL(shdma_cleanup); · 1044 unmodified lines | ||
| 1045 | 1045 | |
| 1046 | 1046 | static int __init shdma_enter(void) |
| 1047 | 1047 | { |
| 1048 | − shdma_slave_used = kzalloc(DIV_ROUND_UP(slave_num, BITS_PER_LONG) * | |
| 1049 | − sizeof(long), GFP_KERNEL); | |
| 1048 | + shdma_slave_used = kcalloc(DIV_ROUND_UP(slave_num, BITS_PER_LONG), | |
| 1049 | + sizeof(long), | |
| 1050 | + GFP_KERNEL); | |
| 1050 | 1051 | if (!shdma_slave_used) |
| 1051 | 1052 | return -ENOMEM; |
| 1052 | 1053 | return 0; |
| @@ -471,7 +471,7 @@ static int zynqmp_dma_alloc_chan_resources(struct dma_chan *dchan) · 470 unmodified lines | ||
| 471 | 471 | if (ret < 0) |
| 472 | 472 | return ret; |
| 473 | 473 | |
| 474 | − chan->sw_desc_pool = kzalloc(sizeof(*desc) * ZYNQMP_DMA_NUM_DESCS, | |
| 474 | + chan->sw_desc_pool = kcalloc(ZYNQMP_DMA_NUM_DESCS, sizeof(*desc), | |
| 475 | 475 | GFP_KERNEL); |
| 476 | 476 | if (!chan->sw_desc_pool) |
| 477 | 477 | return -ENOMEM; |
| @@ -798,8 +798,8 @@ static int zx_dma_probe(struct platform_device *op) · 797 unmodified lines | ||
| 798 | 798 | return -ENOMEM; |
| 799 | 799 | |
| 800 | 800 | /* init phy channel */ |
| 801 | − d->phy = devm_kzalloc(&op->dev, | |
| 802 | − d->dma_channels * sizeof(struct zx_dma_phy), GFP_KERNEL); | |
| 801 | + d->phy = devm_kcalloc(&op->dev, | |
| 802 | + d->dma_channels, sizeof(struct zx_dma_phy), GFP_KERNEL); | |
| 803 | 803 | if (!d->phy) |
| 804 | 804 | return -ENOMEM; |
| 805 | 805 | |
| @@ -834,8 +834,8 @@ static int zx_dma_probe(struct platform_device *op) · 28 unmodified lines | ||
| 834 | 834 | d->slave.residue_granularity = DMA_RESIDUE_GRANULARITY_SEGMENT; |
| 835 | 835 | |
| 836 | 836 | /* init virtual channel */ |
| 837 | − d->chans = devm_kzalloc(&op->dev, | |
| 838 | − d->dma_requests * sizeof(struct zx_dma_chan), GFP_KERNEL); | |
| 837 | + d->chans = devm_kcalloc(&op->dev, | |
| 838 | + d->dma_requests, sizeof(struct zx_dma_chan), GFP_KERNEL); | |
| 839 | 839 | if (!d->chans) |
| 840 | 840 | return -ENOMEM; |
| 841 | 841 | |
| @@ -3451,7 +3451,7 @@ static int __init amd64_edac_init(void) · 3450 unmodified lines | ||
| 3451 | 3451 | opstate_init(); |
| 3452 | 3452 | |
| 3453 | 3453 | err = -ENOMEM; |
| 3454 | − ecc_stngs = kzalloc(amd_nb_num() * sizeof(ecc_stngs[0]), GFP_KERNEL); | |
| 3454 | + ecc_stngs = kcalloc(amd_nb_num(), sizeof(ecc_stngs[0]), GFP_KERNEL); | |
| 3455 | 3455 | if (!ecc_stngs) |
| 3456 | 3456 | goto err_free; |
| 3457 | 3457 | |
| @@ -461,7 +461,7 @@ static struct i7core_dev *alloc_i7core_dev(u8 socket, · 460 unmodified lines | ||
| 461 | 461 | if (!i7core_dev) |
| 462 | 462 | return NULL; |
| 463 | 463 | |
| 464 | − i7core_dev->pdev = kzalloc(sizeof(*i7core_dev->pdev) * table->n_devs, | |
| 464 | + i7core_dev->pdev = kcalloc(table->n_devs, sizeof(*i7core_dev->pdev), | |
| 465 | 465 | GFP_KERNEL); |
| 466 | 466 | if (!i7core_dev->pdev) { |
| 467 | 467 | kfree(i7core_dev); |
| @@ -1126,8 +1126,9 @@ int extcon_dev_register(struct extcon_dev *edev) · 1125 unmodified lines | ||
| 1126 | 1126 | char *str; |
| 1127 | 1127 | struct extcon_cable *cable; |
| 1128 | 1128 | |
| 1129 | − edev->cables = kzalloc(sizeof(struct extcon_cable) * | |
| 1130 | − edev->max_supported, GFP_KERNEL); | |
| 1129 | + edev->cables = kcalloc(edev->max_supported, | |
| 1130 | + sizeof(struct extcon_cable), | |
| 1131 | + GFP_KERNEL); | |
| 1131 | 1132 | if (!edev->cables) { |
| 1132 | 1133 | ret = -ENOMEM; |
| 1133 | 1134 | goto err_sysfs_alloc; |
| @@ -1136,7 +1137,7 @@ int extcon_dev_register(struct extcon_dev *edev) · 2 unmodified lines | ||
| 1136 | 1137 | cable = &edev->cables[index]; |
| 1137 | 1138 | |
| 1138 | 1139 | snprintf(buf, 10, "cable.%d", index); |
| 1139 | − str = kzalloc(sizeof(char) * (strlen(buf) + 1), | |
| 1140 | + str = kzalloc(strlen(buf) + 1, | |
| 1140 | 1141 | GFP_KERNEL); |
| 1141 | 1142 | if (!str) { |
| 1142 | 1143 | for (index--; index >= 0; index--) { |
| @@ -1177,15 +1178,17 @@ int extcon_dev_register(struct extcon_dev *edev) · 34 unmodified lines | ||
| 1177 | 1178 | for (index = 0; edev->mutually_exclusive[index]; index++) |
| 1178 | 1179 | ; |
| 1179 | 1180 | |
| 1180 | − edev->attrs_muex = kzalloc(sizeof(struct attribute *) * | |
| 1181 | − (index + 1), GFP_KERNEL); | |
| 1181 | + edev->attrs_muex = kcalloc(index + 1, | |
| 1182 | + sizeof(struct attribute *), | |
| 1183 | + GFP_KERNEL); | |
| 1182 | 1184 | if (!edev->attrs_muex) { |
| 1183 | 1185 | ret = -ENOMEM; |
| 1184 | 1186 | goto err_muex; |
| 1185 | 1187 | } |
| 1186 | 1188 | |
| 1187 | − edev->d_attrs_muex = kzalloc(sizeof(struct device_attribute) * | |
| 1188 | − index, GFP_KERNEL); | |
| 1189 | + edev->d_attrs_muex = kcalloc(index, | |
| 1190 | + sizeof(struct device_attribute), | |
| 1191 | + GFP_KERNEL); | |
| 1189 | 1192 | if (!edev->d_attrs_muex) { |
| 1190 | 1193 | ret = -ENOMEM; |
| 1191 | 1194 | kfree(edev->attrs_muex); |
| @@ -1194,7 +1197,7 @@ int extcon_dev_register(struct extcon_dev *edev) · 2 unmodified lines | ||
| 1194 | 1197 | |
| 1195 | 1198 | for (index = 0; edev->mutually_exclusive[index]; index++) { |
| 1196 | 1199 | sprintf(buf, "0x%x", edev->mutually_exclusive[index]); |
| 1197 | − name = kzalloc(sizeof(char) * (strlen(buf) + 1), | |
| 1200 | + name = kzalloc(strlen(buf) + 1, | |
| 1198 | 1201 | GFP_KERNEL); |
| 1199 | 1202 | if (!name) { |
| 1200 | 1203 | for (index--; index >= 0; index--) { |
| @@ -1220,8 +1223,9 @@ int extcon_dev_register(struct extcon_dev *edev) · 19 unmodified lines | ||
| 1220 | 1223 | |
| 1221 | 1224 | if (edev->max_supported) { |
| 1222 | 1225 | edev->extcon_dev_type.groups = |
| 1223 | − kzalloc(sizeof(struct attribute_group *) * | |
| 1224 | − (edev->max_supported + 2), GFP_KERNEL); | |
| 1226 | + kcalloc(edev->max_supported + 2, | |
| 1227 | + sizeof(struct attribute_group *), | |
| 1228 | + GFP_KERNEL); | |
| 1225 | 1229 | if (!edev->extcon_dev_type.groups) { |
| 1226 | 1230 | ret = -ENOMEM; |
| 1227 | 1231 | goto err_alloc_groups; |
| @@ -45,8 +45,8 @@ int fw_iso_buffer_alloc(struct fw_iso_buffer *buffer, int page_count) · 44 unmodified lines | ||
| 45 | 45 | |
| 46 | 46 | buffer->page_count = 0; |
| 47 | 47 | buffer->page_count_mapped = 0; |
| 48 | − buffer->pages = kmalloc(page_count * sizeof(buffer->pages[0]), | |
| 49 | − GFP_KERNEL); | |
| 48 | + buffer->pages = kmalloc_array(page_count, sizeof(buffer->pages[0]), | |
| 49 | + GFP_KERNEL); | |
| 50 | 50 | if (buffer->pages == NULL) |
| 51 | 51 | return -ENOMEM; |
| 52 | 52 | |
| @@ -1121,7 +1121,7 @@ static int fwnet_broadcast_start(struct fwnet_device *dev) · 1120 unmodified lines | ||
| 1121 | 1121 | max_receive = 1U << (dev->card->max_receive + 1); |
| 1122 | 1122 | num_packets = (FWNET_ISO_PAGE_COUNT * PAGE_SIZE) / max_receive; |
| 1123 | 1123 | |
| 1124 | − ptrptr = kmalloc(sizeof(void *) * num_packets, GFP_KERNEL); | |
| 1124 | + ptrptr = kmalloc_array(num_packets, sizeof(void *), GFP_KERNEL); | |
| 1125 | 1125 | if (!ptrptr) { |
| 1126 | 1126 | retval = -ENOMEM; |
| 1127 | 1127 | goto failed; |
| @@ -890,7 +890,7 @@ static int scpi_alloc_xfer_list(struct device *dev, struct scpi_chan *ch) · 889 unmodified lines | ||
| 890 | 890 | int i; |
| 891 | 891 | struct scpi_xfer *xfers; |
| 892 | 892 | |
| 893 | − xfers = devm_kzalloc(dev, MAX_SCPI_XFERS * sizeof(*xfers), GFP_KERNEL); | |
| 893 | + xfers = devm_kcalloc(dev, MAX_SCPI_XFERS, sizeof(*xfers), GFP_KERNEL); | |
| 894 | 894 | if (!xfers) |
| 895 | 895 | return -ENOMEM; |
| 896 | 896 | |
| @@ -146,7 +146,7 @@ static int create_packet(void *data, size_t length) · 145 unmodified lines | ||
| 146 | 146 | packet_array_size = max( |
| 147 | 147 | (unsigned int)(allocation_floor / rbu_data.packetsize), |
| 148 | 148 | (unsigned int)1); |
| 149 | − invalid_addr_packet_array = kzalloc(packet_array_size * sizeof(void*), | |
| 149 | + invalid_addr_packet_array = kcalloc(packet_array_size, sizeof(void *), | |
| 150 | 150 | GFP_KERNEL); |
| 151 | 151 | |
| 152 | 152 | if (!invalid_addr_packet_array) { |
| @@ -231,7 +231,7 @@ int efi_capsule_update(efi_capsule_header_t *capsule, phys_addr_t *pages) · 230 unmodified lines | ||
| 231 | 231 | count = DIV_ROUND_UP(imagesize, PAGE_SIZE); |
| 232 | 232 | sg_count = sg_pages_num(count); |
| 233 | 233 | |
| 234 | − sg_pages = kzalloc(sg_count * sizeof(*sg_pages), GFP_KERNEL); | |
| 234 | + sg_pages = kcalloc(sg_count, sizeof(*sg_pages), GFP_KERNEL); | |
| 235 | 235 | if (!sg_pages) |
| 236 | 236 | return -ENOMEM; |
| 237 | 237 | |
| @@ -166,7 +166,7 @@ int __init efi_runtime_map_init(struct kobject *efi_kobj) · 165 unmodified lines | ||
| 166 | 166 | if (!efi_enabled(EFI_MEMMAP)) |
| 167 | 167 | return 0; |
| 168 | 168 | |
| 169 | − map_entries = kzalloc(efi.memmap.nr_map * sizeof(entry), GFP_KERNEL); | |
| 169 | + map_entries = kcalloc(efi.memmap.nr_map, sizeof(entry), GFP_KERNEL); | |
| 170 | 170 | if (!map_entries) { |
| 171 | 171 | ret = -ENOMEM; |
| 172 | 172 | goto out; |
| @@ -1854,9 +1854,9 @@ static int ti_sci_probe(struct platform_device *pdev) · 1853 unmodified lines | ||
| 1854 | 1854 | if (!minfo->xfer_block) |
| 1855 | 1855 | return -ENOMEM; |
| 1856 | 1856 | |
| 1857 | − minfo->xfer_alloc_table = devm_kzalloc(dev, | |
| 1858 | − BITS_TO_LONGS(desc->max_msgs) | |
| 1859 | − * sizeof(unsigned long), | |
| 1857 | + minfo->xfer_alloc_table = devm_kcalloc(dev, | |
| 1858 | + BITS_TO_LONGS(desc->max_msgs), | |
| 1859 | + sizeof(unsigned long), | |
| 1860 | 1860 | GFP_KERNEL); |
| 1861 | 1861 | if (!minfo->xfer_alloc_table) |
| 1862 | 1862 | return -ENOMEM; |
| @@ -48,8 +48,8 @@ static struct sdb_array *__fmc_scan_sdb_tree(struct fmc_device *fmc, · 47 unmodified lines | ||
| 48 | 48 | arr = kzalloc(sizeof(*arr), GFP_KERNEL); |
| 49 | 49 | if (!arr) |
| 50 | 50 | return ERR_PTR(-ENOMEM); |
| 51 | − arr->record = kzalloc(sizeof(arr->record[0]) * n, GFP_KERNEL); | |
| 52 | − arr->subtree = kzalloc(sizeof(arr->subtree[0]) * n, GFP_KERNEL); | |
| 51 | + arr->record = kcalloc(n, sizeof(arr->record[0]), GFP_KERNEL); | |
| 52 | + arr->subtree = kcalloc(n, sizeof(arr->subtree[0]), GFP_KERNEL); | |
| 53 | 53 | if (!arr->record || !arr->subtree) { |
| 54 | 54 | kfree(arr->record); |
| 55 | 55 | kfree(arr->subtree); |
| @@ -427,7 +427,7 @@ static int adnp_irq_setup(struct adnp *adnp) · 426 unmodified lines | ||
| 427 | 427 | * is chosen to match the register layout of the hardware in that |
| 428 | 428 | * each segment contains the corresponding bits for all interrupts. |
| 429 | 429 | */ |
| 430 | − adnp->irq_enable = devm_kzalloc(chip->parent, num_regs * 6, | |
| 430 | + adnp->irq_enable = devm_kcalloc(chip->parent, num_regs, 6, | |
| 431 | 431 | GFP_KERNEL); |
| 432 | 432 | if (!adnp->irq_enable) |
| 433 | 433 | return -ENOMEM; |
| @@ -897,8 +897,8 @@ static int __init aspeed_gpio_probe(struct platform_device *pdev) · 896 unmodified lines | ||
| 897 | 897 | |
| 898 | 898 | /* Allocate a cache of the output registers */ |
| 899 | 899 | banks = gpio->config->nr_gpios >> 5; |
| 900 | − gpio->dcache = devm_kzalloc(&pdev->dev, | |
| 901 | − sizeof(u32) * banks, GFP_KERNEL); | |
| 900 | + gpio->dcache = devm_kcalloc(&pdev->dev, | |
| 901 | + banks, sizeof(u32), GFP_KERNEL); | |
| 902 | 902 | if (!gpio->dcache) |
| 903 | 903 | return -ENOMEM; |
| 904 | 904 | |
| @@ -601,9 +601,10 @@ static int bcm_kona_gpio_probe(struct platform_device *pdev) · 600 unmodified lines | ||
| 601 | 601 | GPIO_MAX_BANK_NUM); |
| 602 | 602 | return -ENXIO; |
| 603 | 603 | } |
| 604 | − kona_gpio->banks = devm_kzalloc(dev, | |
| 605 | − kona_gpio->num_bank * | |
| 606 | − sizeof(*kona_gpio->banks), GFP_KERNEL); | |
| 604 | + kona_gpio->banks = devm_kcalloc(dev, | |
| 605 | + kona_gpio->num_bank, | |
| 606 | + sizeof(*kona_gpio->banks), | |
| 607 | + GFP_KERNEL); | |
| 607 | 608 | if (!kona_gpio->banks) |
| 608 | 609 | return -ENOMEM; |
| 609 | 610 | |
| @@ -198,8 +198,8 @@ static int davinci_gpio_probe(struct platform_device *pdev) · 197 unmodified lines | ||
| 198 | 198 | ngpio = ARCH_NR_GPIOS; |
| 199 | 199 | |
| 200 | 200 | nbank = DIV_ROUND_UP(ngpio, 32); |
| 201 | − chips = devm_kzalloc(dev, | |
| 202 | − nbank * sizeof(struct davinci_gpio_controller), | |
| 201 | + chips = devm_kcalloc(dev, | |
| 202 | + nbank, sizeof(struct davinci_gpio_controller), | |
| 203 | 203 | GFP_KERNEL); |
| 204 | 204 | if (!chips) |
| 205 | 205 | return -ENOMEM; |
| @@ -321,8 +321,8 @@ static int __init egpio_probe(struct platform_device *pdev) · 320 unmodified lines | ||
| 321 | 321 | platform_set_drvdata(pdev, ei); |
| 322 | 322 | |
| 323 | 323 | ei->nchips = pdata->num_chips; |
| 324 | − ei->chip = devm_kzalloc(&pdev->dev, | |
| 325 | − sizeof(struct egpio_chip) * ei->nchips, | |
| 324 | + ei->chip = devm_kcalloc(&pdev->dev, | |
| 325 | + ei->nchips, sizeof(struct egpio_chip), | |
| 326 | 326 | GFP_KERNEL); |
| 327 | 327 | if (!ei->chip) { |
| 328 | 328 | ret = -ENOMEM; |
| @@ -443,7 +443,7 @@ static int ioh_gpio_probe(struct pci_dev *pdev, · 442 unmodified lines | ||
| 443 | 443 | goto err_iomap; |
| 444 | 444 | } |
| 445 | 445 | |
| 446 | − chip_save = kzalloc(sizeof(*chip) * 8, GFP_KERNEL); | |
| 446 | + chip_save = kcalloc(8, sizeof(*chip), GFP_KERNEL); | |
| 447 | 447 | if (chip_save == NULL) { |
| 448 | 448 | ret = -ENOMEM; |
| 449 | 449 | goto err_kzalloc; |
| @@ -504,16 +504,17 @@ static int thunderx_gpio_probe(struct pci_dev *pdev, · 503 unmodified lines | ||
| 504 | 504 | txgpio->base_msi = (c >> 8) & 0xff; |
| 505 | 505 | } |
| 506 | 506 | |
| 507 | − txgpio->msix_entries = devm_kzalloc(dev, | |
| 508 | − sizeof(struct msix_entry) * ngpio, | |
| 507 | + txgpio->msix_entries = devm_kcalloc(dev, | |
| 508 | + ngpio, sizeof(struct msix_entry), | |
| 509 | 509 | GFP_KERNEL); |
| 510 | 510 | if (!txgpio->msix_entries) { |
| 511 | 511 | err = -ENOMEM; |
| 512 | 512 | goto out; |
| 513 | 513 | } |
| 514 | 514 | |
| 515 | − txgpio->line_entries = devm_kzalloc(dev, | |
| 516 | − sizeof(struct thunderx_line) * ngpio, | |
| 515 | + txgpio->line_entries = devm_kcalloc(dev, | |
| 516 | + ngpio, | |
| 517 | + sizeof(struct thunderx_line), | |
| 517 | 518 | GFP_KERNEL); |
| 518 | 519 | if (!txgpio->line_entries) { |
| 519 | 520 | err = -ENOMEM; |
| @@ -310,20 +310,20 @@ static int acp_hw_init(void *handle) · 309 unmodified lines | ||
| 310 | 310 | pm_genpd_init(&adev->acp.acp_genpd->gpd, NULL, false); |
| 311 | 311 | } |
| 312 | 312 | |
| 313 | − adev->acp.acp_cell = kzalloc(sizeof(struct mfd_cell) * ACP_DEVS, | |
| 313 | + adev->acp.acp_cell = kcalloc(ACP_DEVS, sizeof(struct mfd_cell), | |
| 314 | 314 | GFP_KERNEL); |
| 315 | 315 | |
| 316 | 316 | if (adev->acp.acp_cell == NULL) |
| 317 | 317 | return -ENOMEM; |
| 318 | 318 | |
| 319 | − adev->acp.acp_res = kzalloc(sizeof(struct resource) * 4, GFP_KERNEL); | |
| 319 | + adev->acp.acp_res = kcalloc(4, sizeof(struct resource), GFP_KERNEL); | |
| 320 | 320 | |
| 321 | 321 | if (adev->acp.acp_res == NULL) { |
| 322 | 322 | kfree(adev->acp.acp_cell); |
| 323 | 323 | return -ENOMEM; |
| 324 | 324 | } |
| 325 | 325 | |
| 326 | − i2s_pdata = kzalloc(sizeof(struct i2s_platform_data) * 2, GFP_KERNEL); | |
| 326 | + i2s_pdata = kcalloc(2, sizeof(struct i2s_platform_data), GFP_KERNEL); | |
| 327 | 327 | if (i2s_pdata == NULL) { |
| 328 | 328 | kfree(adev->acp.acp_res); |
| 329 | 329 | kfree(adev->acp.acp_cell); |
| @@ -407,7 +407,7 @@ static int kgd_hqd_dump(struct kgd_dev *kgd, · 406 unmodified lines | ||
| 407 | 407 | (*dump)[i++][1] = RREG32(addr); \ |
| 408 | 408 | } while (0) |
| 409 | 409 | |
| 410 | − *dump = kmalloc(HQD_N_REGS*2*sizeof(uint32_t), GFP_KERNEL); | |
| 410 | + *dump = kmalloc_array(HQD_N_REGS * 2, sizeof(uint32_t), GFP_KERNEL); | |
| 411 | 411 | if (*dump == NULL) |
| 412 | 412 | return -ENOMEM; |
| 413 | 413 | |
| @@ -504,7 +504,7 @@ static int kgd_hqd_sdma_dump(struct kgd_dev *kgd, · 90 unmodified lines | ||
| 504 | 504 | #undef HQD_N_REGS |
| 505 | 505 | #define HQD_N_REGS (19+4) |
| 506 | 506 | |
| 507 | − *dump = kmalloc(HQD_N_REGS*2*sizeof(uint32_t), GFP_KERNEL); | |
| 507 | + *dump = kmalloc_array(HQD_N_REGS * 2, sizeof(uint32_t), GFP_KERNEL); | |
| 508 | 508 | if (*dump == NULL) |
| 509 | 509 | return -ENOMEM; |
| 510 | 510 | |
| @@ -395,7 +395,7 @@ static int kgd_hqd_dump(struct kgd_dev *kgd, · 394 unmodified lines | ||
| 395 | 395 | (*dump)[i++][1] = RREG32(addr); \ |
| 396 | 396 | } while (0) |
| 397 | 397 | |
| 398 | − *dump = kmalloc(HQD_N_REGS*2*sizeof(uint32_t), GFP_KERNEL); | |
| 398 | + *dump = kmalloc_array(HQD_N_REGS * 2, sizeof(uint32_t), GFP_KERNEL); | |
| 399 | 399 | if (*dump == NULL) |
| 400 | 400 | return -ENOMEM; |
| 401 | 401 | |
| @@ -491,7 +491,7 @@ static int kgd_hqd_sdma_dump(struct kgd_dev *kgd, · 89 unmodified lines | ||
| 491 | 491 | #undef HQD_N_REGS |
| 492 | 492 | #define HQD_N_REGS (19+4+2+3+7) |
| 493 | 493 | |
| 494 | − *dump = kmalloc(HQD_N_REGS*2*sizeof(uint32_t), GFP_KERNEL); | |
| 494 | + *dump = kmalloc_array(HQD_N_REGS * 2, sizeof(uint32_t), GFP_KERNEL); | |
| 495 | 495 | if (*dump == NULL) |
| 496 | 496 | return -ENOMEM; |
| 497 | 497 | |
| @@ -504,7 +504,7 @@ static int kgd_hqd_dump(struct kgd_dev *kgd, · 503 unmodified lines | ||
| 504 | 504 | (*dump)[i++][1] = RREG32(addr); \ |
| 505 | 505 | } while (0) |
| 506 | 506 | |
| 507 | − *dump = kmalloc(HQD_N_REGS*2*sizeof(uint32_t), GFP_KERNEL); | |
| 507 | + *dump = kmalloc_array(HQD_N_REGS * 2, sizeof(uint32_t), GFP_KERNEL); | |
| 508 | 508 | if (*dump == NULL) |
| 509 | 509 | return -ENOMEM; |
| 510 | 510 | |
| @@ -606,7 +606,7 @@ static int kgd_hqd_sdma_dump(struct kgd_dev *kgd, · 95 unmodified lines | ||
| 606 | 606 | #undef HQD_N_REGS |
| 607 | 607 | #define HQD_N_REGS (19+6+7+10) |
| 608 | 608 | |
| 609 | − *dump = kmalloc(HQD_N_REGS*2*sizeof(uint32_t), GFP_KERNEL); | |
| 609 | + *dump = kmalloc_array(HQD_N_REGS * 2, sizeof(uint32_t), GFP_KERNEL); | |
| 610 | 610 | if (*dump == NULL) |
| 611 | 611 | return -ENOMEM; |
| 612 | 612 | |
| @@ -452,7 +452,7 @@ int amdgpu_parse_extended_power_table(struct amdgpu_device *adev) · 451 unmodified lines | ||
| 452 | 452 | ATOM_PPLIB_PhaseSheddingLimits_Record *entry; |
| 453 | 453 | |
| 454 | 454 | adev->pm.dpm.dyn_state.phase_shedding_limits_table.entries = |
| 455 | − kzalloc(psl->ucNumEntries * | |
| 455 | + kcalloc(psl->ucNumEntries, | |
| 456 | 456 | sizeof(struct amdgpu_phase_shedding_limits_entry), |
| 457 | 457 | GFP_KERNEL); |
| 458 | 458 | if (!adev->pm.dpm.dyn_state.phase_shedding_limits_table.entries) { |
| @@ -369,7 +369,8 @@ int amdgpu_gart_init(struct amdgpu_device *adev) · 368 unmodified lines | ||
| 369 | 369 | |
| 370 | 370 | #ifdef CONFIG_DRM_AMDGPU_GART_DEBUGFS |
| 371 | 371 | /* Allocate pages table */ |
| 372 | − adev->gart.pages = vzalloc(sizeof(void *) * adev->gart.num_cpu_pages); | |
| 372 | + adev->gart.pages = vzalloc(array_size(sizeof(void *), | |
| 373 | + adev->gart.num_cpu_pages)); | |
| 373 | 374 | if (adev->gart.pages == NULL) |
| 374 | 375 | return -ENOMEM; |
| 375 | 376 | #endif |
| @@ -53,7 +53,7 @@ static void amdgpu_do_test_moves(struct amdgpu_device *adev) · 52 unmodified lines | ||
| 53 | 53 | n -= adev->irq.ih.ring_size; |
| 54 | 54 | n /= size; |
| 55 | 55 | |
| 56 | − gtt_obj = kzalloc(n * sizeof(*gtt_obj), GFP_KERNEL); | |
| 56 | + gtt_obj = kcalloc(n, sizeof(*gtt_obj), GFP_KERNEL); | |
| 57 | 57 | if (!gtt_obj) { |
| 58 | 58 | DRM_ERROR("Failed to allocate %d pointers\n", n); |
| 59 | 59 | r = 1; |
| @@ -1221,7 +1221,7 @@ static int amdgpu_atom_execute_table_locked(struct atom_context *ctx, int index, · 1220 unmodified lines | ||
| 1221 | 1221 | ectx.abort = false; |
| 1222 | 1222 | ectx.last_jump = 0; |
| 1223 | 1223 | if (ws) |
| 1224 | − ectx.ws = kzalloc(4 * ws, GFP_KERNEL); | |
| 1224 | + ectx.ws = kcalloc(4, ws, GFP_KERNEL); | |
| 1225 | 1225 | else |
| 1226 | 1226 | ectx.ws = NULL; |
| 1227 | 1227 | |
| @@ -5679,8 +5679,9 @@ static int ci_parse_power_table(struct amdgpu_device *adev) · 5678 unmodified lines | ||
| 5679 | 5679 | (mode_info->atom_context->bios + data_offset + |
| 5680 | 5680 | le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset)); |
| 5681 | 5681 | |
| 5682 | − adev->pm.dpm.ps = kzalloc(sizeof(struct amdgpu_ps) * | |
| 5683 | − state_array->ucNumEntries, GFP_KERNEL); | |
| 5682 | + adev->pm.dpm.ps = kcalloc(state_array->ucNumEntries, | |
| 5683 | + sizeof(struct amdgpu_ps), | |
| 5684 | + GFP_KERNEL); | |
| 5684 | 5685 | if (!adev->pm.dpm.ps) |
| 5685 | 5686 | return -ENOMEM; |
| 5686 | 5687 | power_state_offset = (u8 *)state_array->states; |
| @@ -5927,7 +5928,9 @@ static int ci_dpm_init(struct amdgpu_device *adev) · 240 unmodified lines | ||
| 5927 | 5928 | ci_set_private_data_variables_based_on_pptable(adev); |
| 5928 | 5929 | |
| 5929 | 5930 | adev->pm.dpm.dyn_state.vddc_dependency_on_dispclk.entries = |
| 5930 | − kzalloc(4 * sizeof(struct amdgpu_clock_voltage_dependency_entry), GFP_KERNEL); | |
| 5931 | + kcalloc(4, | |
| 5932 | + sizeof(struct amdgpu_clock_voltage_dependency_entry), | |
| 5933 | + GFP_KERNEL); | |
| 5931 | 5934 | if (!adev->pm.dpm.dyn_state.vddc_dependency_on_dispclk.entries) { |
| 5932 | 5935 | ci_dpm_fini(adev); |
| 5933 | 5936 | return -ENOMEM; |
| @@ -2727,8 +2727,9 @@ static int kv_parse_power_table(struct amdgpu_device *adev) · 2726 unmodified lines | ||
| 2727 | 2727 | (mode_info->atom_context->bios + data_offset + |
| 2728 | 2728 | le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset)); |
| 2729 | 2729 | |
| 2730 | − adev->pm.dpm.ps = kzalloc(sizeof(struct amdgpu_ps) * | |
| 2731 | − state_array->ucNumEntries, GFP_KERNEL); | |
| 2730 | + adev->pm.dpm.ps = kcalloc(state_array->ucNumEntries, | |
| 2731 | + sizeof(struct amdgpu_ps), | |
| 2732 | + GFP_KERNEL); | |
| 2732 | 2733 | if (!adev->pm.dpm.ps) |
| 2733 | 2734 | return -ENOMEM; |
| 2734 | 2735 | power_state_offset = (u8 *)state_array->states; |
| @@ -7242,8 +7242,9 @@ static int si_parse_power_table(struct amdgpu_device *adev) · 7241 unmodified lines | ||
| 7242 | 7242 | (mode_info->atom_context->bios + data_offset + |
| 7243 | 7243 | le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset)); |
| 7244 | 7244 | |
| 7245 | − adev->pm.dpm.ps = kzalloc(sizeof(struct amdgpu_ps) * | |
| 7246 | − state_array->ucNumEntries, GFP_KERNEL); | |
| 7245 | + adev->pm.dpm.ps = kcalloc(state_array->ucNumEntries, | |
| 7246 | + sizeof(struct amdgpu_ps), | |
| 7247 | + GFP_KERNEL); | |
| 7247 | 7248 | if (!adev->pm.dpm.ps) |
| 7248 | 7249 | return -ENOMEM; |
| 7249 | 7250 | power_state_offset = (u8 *)state_array->states; |
| @@ -7346,7 +7347,9 @@ static int si_dpm_init(struct amdgpu_device *adev) · 96 unmodified lines | ||
| 7346 | 7347 | return ret; |
| 7347 | 7348 | |
| 7348 | 7349 | adev->pm.dpm.dyn_state.vddc_dependency_on_dispclk.entries = |
| 7349 | − kzalloc(4 * sizeof(struct amdgpu_clock_voltage_dependency_entry), GFP_KERNEL); | |
| 7350 | + kcalloc(4, | |
| 7351 | + sizeof(struct amdgpu_clock_voltage_dependency_entry), | |
| 7352 | + GFP_KERNEL); | |
| 7350 | 7353 | if (!adev->pm.dpm.dyn_state.vddc_dependency_on_dispclk.entries) { |
| 7351 | 7354 | amdgpu_free_extended_power_table(adev); |
| 7352 | 7355 | return -ENOMEM; |
| @@ -435,7 +435,7 @@ bool dm_helpers_submit_i2c( · 434 unmodified lines | ||
| 435 | 435 | return false; |
| 436 | 436 | } |
| 437 | 437 | |
| 438 | − msgs = kzalloc(num * sizeof(struct i2c_msg), GFP_KERNEL); | |
| 438 | + msgs = kcalloc(num, sizeof(struct i2c_msg), GFP_KERNEL); | |
| 439 | 439 | |
| 440 | 440 | if (!msgs) |
| 441 | 441 | return false; |
| @@ -364,7 +364,7 @@ void dm_logger_open( · 363 unmodified lines | ||
| 364 | 364 | entry->type = log_type; |
| 365 | 365 | entry->logger = logger; |
| 366 | 366 | |
| 367 | − entry->buf = kzalloc(DAL_LOGGER_BUFFER_MAX_SIZE * sizeof(char), | |
| 367 | + entry->buf = kzalloc(DAL_LOGGER_BUFFER_MAX_SIZE, | |
| 368 | 368 | GFP_KERNEL); |
| 369 | 369 | |
| 370 | 370 | entry->buf_offset = 0; |
| @@ -40,7 +40,7 @@ bool dal_vector_construct( · 39 unmodified lines | ||
| 40 | 40 | return false; |
| 41 | 41 | } |
| 42 | 42 | |
| 43 | − vector->container = kzalloc(struct_size * capacity, GFP_KERNEL); | |
| 43 | + vector->container = kcalloc(capacity, struct_size, GFP_KERNEL); | |
| 44 | 44 | if (vector->container == NULL) |
| 45 | 45 | return false; |
| 46 | 46 | vector->capacity = capacity; |
| @@ -67,7 +67,7 @@ bool dal_vector_presized_costruct( · 20 unmodified lines | ||
| 67 | 67 | return false; |
| 68 | 68 | } |
| 69 | 69 | |
| 70 | − vector->container = kzalloc(struct_size * count, GFP_KERNEL); | |
| 70 | + vector->container = kcalloc(count, struct_size, GFP_KERNEL); | |
| 71 | 71 | |
| 72 | 72 | if (vector->container == NULL) |
| 73 | 73 | return false; |
| @@ -1079,13 +1079,15 @@ static void get_ss_info_from_atombios( · 1078 unmodified lines | ||
| 1079 | 1079 | if (*ss_entries_num == 0) |
| 1080 | 1080 | return; |
| 1081 | 1081 | |
| 1082 | − ss_info = kzalloc(sizeof(struct spread_spectrum_info) * (*ss_entries_num), | |
| 1082 | + ss_info = kcalloc(*ss_entries_num, | |
| 1083 | + sizeof(struct spread_spectrum_info), | |
| 1083 | 1084 | GFP_KERNEL); |
| 1084 | 1085 | ss_info_cur = ss_info; |
| 1085 | 1086 | if (ss_info == NULL) |
| 1086 | 1087 | return; |
| 1087 | 1088 | |
| 1088 | − ss_data = kzalloc(sizeof(struct spread_spectrum_data) * (*ss_entries_num), | |
| 1089 | + ss_data = kcalloc(*ss_entries_num, | |
| 1090 | + sizeof(struct spread_spectrum_data), | |
| 1089 | 1091 | GFP_KERNEL); |
| 1090 | 1092 | if (ss_data == NULL) |
| 1091 | 1093 | goto out_free_info; |
| @@ -98,7 +98,8 @@ struct gpio_service *dal_gpio_service_create( · 97 unmodified lines | ||
| 98 | 98 | if (number_of_bits) { |
| 99 | 99 | uint32_t index_of_uint = 0; |
| 100 | 100 | |
| 101 | − slot = kzalloc(number_of_uints * sizeof(uint32_t), | |
| 101 | + slot = kcalloc(number_of_uints, | |
| 102 | + sizeof(uint32_t), | |
| 102 | 103 | GFP_KERNEL); |
| 103 | 104 | |
| 104 | 105 | if (!slot) { |
| @@ -1274,19 +1274,22 @@ bool mod_color_calculate_regamma_params(struct dc_transfer_func *output_tf, · 1273 unmodified lines | ||
| 1274 | 1274 | |
| 1275 | 1275 | output_tf->type = TF_TYPE_DISTRIBUTED_POINTS; |
| 1276 | 1276 | |
| 1277 | − rgb_user = kvzalloc(sizeof(*rgb_user) * (ramp->num_entries + _EXTRA_POINTS), | |
| 1277 | + rgb_user = kvcalloc(ramp->num_entries + _EXTRA_POINTS, | |
| 1278 | + sizeof(*rgb_user), | |
| 1278 | 1279 | GFP_KERNEL); |
| 1279 | 1280 | if (!rgb_user) |
| 1280 | 1281 | goto rgb_user_alloc_fail; |
| 1281 | − rgb_regamma = kvzalloc(sizeof(*rgb_regamma) * (MAX_HW_POINTS + _EXTRA_POINTS), | |
| 1282 | + rgb_regamma = kvcalloc(MAX_HW_POINTS + _EXTRA_POINTS, | |
| 1283 | + sizeof(*rgb_regamma), | |
| 1282 | 1284 | GFP_KERNEL); |
| 1283 | 1285 | if (!rgb_regamma) |
| 1284 | 1286 | goto rgb_regamma_alloc_fail; |
| 1285 | − axix_x = kvzalloc(sizeof(*axix_x) * (ramp->num_entries + 3), | |
| 1287 | + axix_x = kvcalloc(ramp->num_entries + 3, sizeof(*axix_x), | |
| 1286 | 1288 | GFP_KERNEL); |
| 1287 | 1289 | if (!axix_x) |
| 1288 | 1290 | goto axix_x_alloc_fail; |
| 1289 | − coeff = kvzalloc(sizeof(*coeff) * (MAX_HW_POINTS + _EXTRA_POINTS), GFP_KERNEL); | |
| 1291 | + coeff = kvcalloc(MAX_HW_POINTS + _EXTRA_POINTS, sizeof(*coeff), | |
| 1292 | + GFP_KERNEL); | |
| 1290 | 1293 | if (!coeff) |
| 1291 | 1294 | goto coeff_alloc_fail; |
| 1292 | 1295 | |
| @@ -1413,13 +1416,15 @@ bool calculate_user_regamma_ramp(struct dc_transfer_func *output_tf, · 120 unmodified lines | ||
| 1413 | 1416 | |
| 1414 | 1417 | output_tf->type = TF_TYPE_DISTRIBUTED_POINTS; |
| 1415 | 1418 | |
| 1416 | − rgb_user = kzalloc(sizeof(*rgb_user) * (GAMMA_RGB_256_ENTRIES + _EXTRA_POINTS), | |
| 1417 | − GFP_KERNEL); | |
| 1419 | + rgb_user = kcalloc(GAMMA_RGB_256_ENTRIES + _EXTRA_POINTS, | |
| 1420 | + sizeof(*rgb_user), | |
| 1421 | + GFP_KERNEL); | |
| 1418 | 1422 | if (!rgb_user) |
| 1419 | 1423 | goto rgb_user_alloc_fail; |
| 1420 | 1424 | |
| 1421 | − rgb_regamma = kzalloc(sizeof(*rgb_regamma) * (MAX_HW_POINTS + _EXTRA_POINTS), | |
| 1422 | − GFP_KERNEL); | |
| 1425 | + rgb_regamma = kcalloc(MAX_HW_POINTS + _EXTRA_POINTS, | |
| 1426 | + sizeof(*rgb_regamma), | |
| 1427 | + GFP_KERNEL); | |
| 1423 | 1428 | if (!rgb_regamma) |
| 1424 | 1429 | goto rgb_regamma_alloc_fail; |
| 1425 | 1430 | |
| @@ -1480,19 +1485,21 @@ bool mod_color_calculate_degamma_params(struct dc_transfer_func *input_tf, · 54 unmodified lines | ||
| 1480 | 1485 | |
| 1481 | 1486 | input_tf->type = TF_TYPE_DISTRIBUTED_POINTS; |
| 1482 | 1487 | |
| 1483 | − rgb_user = kvzalloc(sizeof(*rgb_user) * (ramp->num_entries + _EXTRA_POINTS), | |
| 1488 | + rgb_user = kvcalloc(ramp->num_entries + _EXTRA_POINTS, | |
| 1489 | + sizeof(*rgb_user), | |
| 1484 | 1490 | GFP_KERNEL); |
| 1485 | 1491 | if (!rgb_user) |
| 1486 | 1492 | goto rgb_user_alloc_fail; |
| 1487 | − curve = kvzalloc(sizeof(*curve) * (MAX_HW_POINTS + _EXTRA_POINTS), | |
| 1493 | + curve = kvcalloc(MAX_HW_POINTS + _EXTRA_POINTS, sizeof(*curve), | |
| 1488 | 1494 | GFP_KERNEL); |
| 1489 | 1495 | if (!curve) |
| 1490 | 1496 | goto curve_alloc_fail; |
| 1491 | − axix_x = kvzalloc(sizeof(*axix_x) * (ramp->num_entries + _EXTRA_POINTS), | |
| 1497 | + axix_x = kvcalloc(ramp->num_entries + _EXTRA_POINTS, sizeof(*axix_x), | |
| 1492 | 1498 | GFP_KERNEL); |
| 1493 | 1499 | if (!axix_x) |
| 1494 | 1500 | goto axix_x_alloc_fail; |
| 1495 | − coeff = kvzalloc(sizeof(*coeff) * (MAX_HW_POINTS + _EXTRA_POINTS), GFP_KERNEL); | |
| 1501 | + coeff = kvcalloc(MAX_HW_POINTS + _EXTRA_POINTS, sizeof(*coeff), | |
| 1502 | + GFP_KERNEL); | |
| 1496 | 1503 | if (!coeff) |
| 1497 | 1504 | goto coeff_alloc_fail; |
| 1498 | 1505 | |
| @@ -1569,8 +1576,8 @@ bool mod_color_calculate_curve(enum dc_transfer_func_predefined trans, · 70 unmodified lines | ||
| 1569 | 1576 | } |
| 1570 | 1577 | ret = true; |
| 1571 | 1578 | } else if (trans == TRANSFER_FUNCTION_PQ) { |
| 1572 | − rgb_regamma = kvzalloc(sizeof(*rgb_regamma) * | |
| 1573 | − (MAX_HW_POINTS + _EXTRA_POINTS), | |
| 1579 | + rgb_regamma = kvcalloc(MAX_HW_POINTS + _EXTRA_POINTS, | |
| 1580 | + sizeof(*rgb_regamma), | |
| 1574 | 1581 | GFP_KERNEL); |
| 1575 | 1582 | if (!rgb_regamma) |
| 1576 | 1583 | goto rgb_regamma_alloc_fail; |
| @@ -1594,8 +1601,8 @@ bool mod_color_calculate_curve(enum dc_transfer_func_predefined trans, · 17 unmodified lines | ||
| 1594 | 1601 | kvfree(rgb_regamma); |
| 1595 | 1602 | } else if (trans == TRANSFER_FUNCTION_SRGB || |
| 1596 | 1603 | trans == TRANSFER_FUNCTION_BT709) { |
| 1597 | − rgb_regamma = kvzalloc(sizeof(*rgb_regamma) * | |
| 1598 | − (MAX_HW_POINTS + _EXTRA_POINTS), | |
| 1604 | + rgb_regamma = kvcalloc(MAX_HW_POINTS + _EXTRA_POINTS, | |
| 1605 | + sizeof(*rgb_regamma), | |
| 1599 | 1606 | GFP_KERNEL); |
| 1600 | 1607 | if (!rgb_regamma) |
| 1601 | 1608 | goto rgb_regamma_alloc_fail; |
| @@ -1638,8 +1645,8 @@ bool mod_color_calculate_degamma_curve(enum dc_transfer_func_predefined trans, · 36 unmodified lines | ||
| 1638 | 1645 | } |
| 1639 | 1646 | ret = true; |
| 1640 | 1647 | } else if (trans == TRANSFER_FUNCTION_PQ) { |
| 1641 | − rgb_degamma = kvzalloc(sizeof(*rgb_degamma) * | |
| 1642 | − (MAX_HW_POINTS + _EXTRA_POINTS), | |
| 1648 | + rgb_degamma = kvcalloc(MAX_HW_POINTS + _EXTRA_POINTS, | |
| 1649 | + sizeof(*rgb_degamma), | |
| 1643 | 1650 | GFP_KERNEL); |
| 1644 | 1651 | if (!rgb_degamma) |
| 1645 | 1652 | goto rgb_degamma_alloc_fail; |
| @@ -1658,8 +1665,8 @@ bool mod_color_calculate_degamma_curve(enum dc_transfer_func_predefined trans, · 12 unmodified lines | ||
| 1658 | 1665 | kvfree(rgb_degamma); |
| 1659 | 1666 | } else if (trans == TRANSFER_FUNCTION_SRGB || |
| 1660 | 1667 | trans == TRANSFER_FUNCTION_BT709) { |
| 1661 | − rgb_degamma = kvzalloc(sizeof(*rgb_degamma) * | |
| 1662 | − (MAX_HW_POINTS + _EXTRA_POINTS), | |
| 1668 | + rgb_degamma = kvcalloc(MAX_HW_POINTS + _EXTRA_POINTS, | |
| 1669 | + sizeof(*rgb_degamma), | |
| 1663 | 1670 | GFP_KERNEL); |
| 1664 | 1671 | if (!rgb_degamma) |
| 1665 | 1672 | goto rgb_degamma_alloc_fail; |
| @@ -155,7 +155,8 @@ struct mod_freesync *mod_freesync_create(struct dc *dc) · 154 unmodified lines | ||
| 155 | 155 | if (core_freesync == NULL) |
| 156 | 156 | goto fail_alloc_context; |
| 157 | 157 | |
| 158 | − core_freesync->map = kzalloc(sizeof(struct freesync_entity) * MOD_FREESYNC_MAX_CONCURRENT_STREAMS, | |
| 158 | + core_freesync->map = kcalloc(MOD_FREESYNC_MAX_CONCURRENT_STREAMS, | |
| 159 | + sizeof(struct freesync_entity), | |
| 159 | 160 | GFP_KERNEL); |
| 160 | 161 | |
| 161 | 162 | if (core_freesync->map == NULL) |
| @@ -141,19 +141,17 @@ struct mod_stats *mod_stats_create(struct dc *dc) · 140 unmodified lines | ||
| 141 | 141 | else |
| 142 | 142 | core_stats->entries = reg_data; |
| 143 | 143 | } |
| 144 | − core_stats->time = kzalloc( | |
| 145 | − sizeof(struct stats_time_cache) * | |
| 146 | − core_stats->entries, | |
| 144 | + core_stats->time = kcalloc(core_stats->entries, | |
| 145 | + sizeof(struct stats_time_cache), | |
| 147 | 146 | GFP_KERNEL); |
| 148 | 147 | |
| 149 | 148 | if (core_stats->time == NULL) |
| 150 | 149 | goto fail_construct_time; |
| 151 | 150 | |
| 152 | 151 | core_stats->event_entries = DAL_STATS_EVENT_ENTRIES_DEFAULT; |
| 153 | − core_stats->events = kzalloc( | |
| 154 | − sizeof(struct stats_event_cache) * | |
| 155 | − core_stats->event_entries, | |
| 156 | − GFP_KERNEL); | |
| 152 | + core_stats->events = kcalloc(core_stats->event_entries, | |
| 153 | + sizeof(struct stats_event_cache), | |
| 154 | + GFP_KERNEL); | |
| 157 | 155 | |
| 158 | 156 | if (core_stats->events == NULL) |
| 159 | 157 | goto fail_construct_events; |
| @@ -50,7 +50,7 @@ int psm_init_power_state_table(struct pp_hwmgr *hwmgr) · 49 unmodified lines | ||
| 50 | 50 | return 0; |
| 51 | 51 | } |
| 52 | 52 | |
| 53 | − hwmgr->ps = kzalloc(size * table_entries, GFP_KERNEL); | |
| 53 | + hwmgr->ps = kcalloc(table_entries, size, GFP_KERNEL); | |
| 54 | 54 | if (hwmgr->ps == NULL) |
| 55 | 55 | return -ENOMEM; |
| 56 | 56 | |
| @@ -1633,7 +1633,8 @@ struct edid *drm_do_get_edid(struct drm_connector *connector, · 1632 unmodified lines | ||
| 1633 | 1633 | edid[EDID_LENGTH-1] += edid[0x7e] - valid_extensions; |
| 1634 | 1634 | edid[0x7e] = valid_extensions; |
| 1635 | 1635 | |
| 1636 | − new = kmalloc((valid_extensions + 1) * EDID_LENGTH, GFP_KERNEL); | |
| 1636 | + new = kmalloc_array(valid_extensions + 1, EDID_LENGTH, | |
| 1637 | + GFP_KERNEL); | |
| 1637 | 1638 | if (!new) |
| 1638 | 1639 | goto out; |
| 1639 | 1640 | |
| @@ -47,7 +47,7 @@ int drm_ht_create(struct drm_open_hash *ht, unsigned int order) · 46 unmodified lines | ||
| 47 | 47 | if (size <= PAGE_SIZE / sizeof(*ht->table)) |
| 48 | 48 | ht->table = kcalloc(size, sizeof(*ht->table), GFP_KERNEL); |
| 49 | 49 | else |
| 50 | − ht->table = vzalloc(size*sizeof(*ht->table)); | |
| 50 | + ht->table = vzalloc(array_size(size, sizeof(*ht->table))); | |
| 51 | 51 | if (!ht->table) { |
| 52 | 52 | DRM_ERROR("Out of memory for hash table\n"); |
| 53 | 53 | return -ENOMEM; |
| @@ -80,7 +80,7 @@ static void *agp_remap(unsigned long offset, unsigned long size, · 79 unmodified lines | ||
| 80 | 80 | * page-table instead (that's probably faster anyhow...). |
| 81 | 81 | */ |
| 82 | 82 | /* note: use vmalloc() because num_pages could be large... */ |
| 83 | − page_map = vmalloc(num_pages * sizeof(struct page *)); | |
| 83 | + page_map = vmalloc(array_size(num_pages, sizeof(struct page *))); | |
| 84 | 84 | if (!page_map) |
| 85 | 85 | return NULL; |
| 86 | 86 | |
| @@ -1723,8 +1723,8 @@ static int exynos_dsi_probe(struct platform_device *pdev) · 1722 unmodified lines | ||
| 1723 | 1723 | return -EPROBE_DEFER; |
| 1724 | 1724 | } |
| 1725 | 1725 | |
| 1726 | − dsi->clks = devm_kzalloc(dev, | |
| 1727 | − sizeof(*dsi->clks) * dsi->driver_data->num_clks, | |
| 1726 | + dsi->clks = devm_kcalloc(dev, | |
| 1727 | + dsi->driver_data->num_clks, sizeof(*dsi->clks), | |
| 1728 | 1728 | GFP_KERNEL); |
| 1729 | 1729 | if (!dsi->clks) |
| 1730 | 1730 | return -ENOMEM; |
| @@ -1271,7 +1271,8 @@ static int fimc_probe(struct platform_device *pdev) · 1270 unmodified lines | ||
| 1271 | 1271 | |
| 1272 | 1272 | /* construct formats/limits array */ |
| 1273 | 1273 | num_formats = ARRAY_SIZE(fimc_formats) + ARRAY_SIZE(fimc_tiled_formats); |
| 1274 | − formats = devm_kzalloc(dev, sizeof(*formats) * num_formats, GFP_KERNEL); | |
| 1274 | + formats = devm_kcalloc(dev, num_formats, sizeof(*formats), | |
| 1275 | + GFP_KERNEL); | |
| 1275 | 1276 | if (!formats) |
| 1276 | 1277 | return -ENOMEM; |
| 1277 | 1278 | |
| @@ -1202,8 +1202,9 @@ static int gsc_probe(struct platform_device *pdev) · 1201 unmodified lines | ||
| 1202 | 1202 | if (!ctx) |
| 1203 | 1203 | return -ENOMEM; |
| 1204 | 1204 | |
| 1205 | − formats = devm_kzalloc(dev, sizeof(*formats) * | |
| 1206 | − (ARRAY_SIZE(gsc_formats)), GFP_KERNEL); | |
| 1205 | + formats = devm_kcalloc(dev, | |
| 1206 | + ARRAY_SIZE(gsc_formats), sizeof(*formats), | |
| 1207 | + GFP_KERNEL); | |
| 1207 | 1208 | if (!formats) |
| 1208 | 1209 | return -ENOMEM; |
| 1209 | 1210 | |
| @@ -1692,7 +1692,7 @@ static int hdmi_clk_init(struct hdmi_context *hdata) · 1691 unmodified lines | ||
| 1692 | 1692 | if (!count) |
| 1693 | 1693 | return 0; |
| 1694 | 1694 | |
| 1695 | − clks = devm_kzalloc(dev, sizeof(*clks) * count, GFP_KERNEL); | |
| 1695 | + clks = devm_kcalloc(dev, count, sizeof(*clks), GFP_KERNEL); | |
| 1696 | 1696 | if (!clks) |
| 1697 | 1697 | return -ENOMEM; |
| 1698 | 1698 | |
| @@ -239,7 +239,7 @@ static int mid_get_vbt_data_r10(struct drm_psb_private *dev_priv, u32 addr) · 238 unmodified lines | ||
| 239 | 239 | if (read_vbt_r10(addr, &vbt)) |
| 240 | 240 | return -1; |
| 241 | 241 | |
| 242 | − gct = kmalloc(sizeof(*gct) * vbt.panel_count, GFP_KERNEL); | |
| 242 | + gct = kmalloc_array(vbt.panel_count, sizeof(*gct), GFP_KERNEL); | |
| 243 | 243 | if (!gct) |
| 244 | 244 | return -ENOMEM; |
| 245 | 245 | |
| @@ -1585,8 +1585,9 @@ static struct intel_vgpu_mm *intel_vgpu_create_ggtt_mm(struct intel_vgpu *vgpu) · 1584 unmodified lines | ||
| 1585 | 1585 | mm->type = INTEL_GVT_MM_GGTT; |
| 1586 | 1586 | |
| 1587 | 1587 | nr_entries = gvt_ggtt_gm_sz(vgpu->gvt) >> I915_GTT_PAGE_SHIFT; |
| 1588 | − mm->ggtt_mm.virtual_ggtt = vzalloc(nr_entries * | |
| 1589 | − vgpu->gvt->device_info.gtt_entry_size); | |
| 1588 | + mm->ggtt_mm.virtual_ggtt = | |
| 1589 | + vzalloc(array_size(nr_entries, | |
| 1590 | + vgpu->gvt->device_info.gtt_entry_size)); | |
| 1590 | 1591 | if (!mm->ggtt_mm.virtual_ggtt) { |
| 1591 | 1592 | vgpu_free_mm(mm); |
| 1592 | 1593 | return ERR_PTR(-ENOMEM); |
| @@ -267,7 +267,7 @@ int intel_vgpu_init_mmio(struct intel_vgpu *vgpu) · 266 unmodified lines | ||
| 267 | 267 | { |
| 268 | 268 | const struct intel_gvt_device_info *info = &vgpu->gvt->device_info; |
| 269 | 269 | |
| 270 | − vgpu->mmio.vreg = vzalloc(info->mmio_size * 2); | |
| 270 | + vgpu->mmio.vreg = vzalloc(array_size(info->mmio_size, 2)); | |
| 271 | 271 | if (!vgpu->mmio.vreg) |
| 272 | 272 | return -ENOMEM; |
| 273 | 273 | |
| @@ -121,7 +121,7 @@ int intel_gvt_init_vgpu_types(struct intel_gvt *gvt) · 120 unmodified lines | ||
| 121 | 121 | high_avail = gvt_hidden_sz(gvt) - HOST_HIGH_GM_SIZE; |
| 122 | 122 | num_types = sizeof(vgpu_types) / sizeof(vgpu_types[0]); |
| 123 | 123 | |
| 124 | − gvt->types = kzalloc(num_types * sizeof(struct intel_vgpu_type), | |
| 124 | + gvt->types = kcalloc(num_types, sizeof(struct intel_vgpu_type), | |
| 125 | 125 | GFP_KERNEL); |
| 126 | 126 | if (!gvt->types) |
| 127 | 127 | return -ENOMEM; |
| @@ -429,7 +429,7 @@ int intel_hdcp_auth_downstream(struct intel_digital_port *intel_dig_port, · 428 unmodified lines | ||
| 429 | 429 | if (num_downstream == 0) |
| 430 | 430 | return -EINVAL; |
| 431 | 431 | |
| 432 | − ksv_fifo = kzalloc(num_downstream * DRM_HDCP_KSV_LEN, GFP_KERNEL); | |
| 432 | + ksv_fifo = kcalloc(DRM_HDCP_KSV_LEN, num_downstream, GFP_KERNEL); | |
| 433 | 433 | if (!ksv_fifo) |
| 434 | 434 | return -ENOMEM; |
| 435 | 435 | |
| @@ -137,7 +137,7 @@ static int intel_uncore_check_forcewake_domains(struct drm_i915_private *dev_pri · 136 unmodified lines | ||
| 137 | 137 | if (!IS_ENABLED(CONFIG_DRM_I915_SELFTEST_BROKEN)) |
| 138 | 138 | return 0; |
| 139 | 139 | |
| 140 | − valid = kzalloc(BITS_TO_LONGS(FW_RANGE) * sizeof(*valid), | |
| 140 | + valid = kcalloc(BITS_TO_LONGS(FW_RANGE), sizeof(*valid), | |
| 141 | 141 | GFP_KERNEL); |
| 142 | 142 | if (!valid) |
| 143 | 143 | return -ENOMEM; |
| @@ -157,8 +157,10 @@ static struct hdmi *msm_hdmi_init(struct platform_device *pdev) · 156 unmodified lines | ||
| 157 | 157 | hdmi->qfprom_mmio = NULL; |
| 158 | 158 | } |
| 159 | 159 | |
| 160 | − hdmi->hpd_regs = devm_kzalloc(&pdev->dev, sizeof(hdmi->hpd_regs[0]) * | |
| 161 | − config->hpd_reg_cnt, GFP_KERNEL); | |
| 160 | + hdmi->hpd_regs = devm_kcalloc(&pdev->dev, | |
| 161 | + config->hpd_reg_cnt, | |
| 162 | + sizeof(hdmi->hpd_regs[0]), | |
| 163 | + GFP_KERNEL); | |
| 162 | 164 | if (!hdmi->hpd_regs) { |
| 163 | 165 | ret = -ENOMEM; |
| 164 | 166 | goto fail; |
| @@ -178,8 +180,10 @@ static struct hdmi *msm_hdmi_init(struct platform_device *pdev) · 13 unmodified lines | ||
| 178 | 180 | hdmi->hpd_regs[i] = reg; |
| 179 | 181 | } |
| 180 | 182 | |
| 181 | − hdmi->pwr_regs = devm_kzalloc(&pdev->dev, sizeof(hdmi->pwr_regs[0]) * | |
| 182 | − config->pwr_reg_cnt, GFP_KERNEL); | |
| 183 | + hdmi->pwr_regs = devm_kcalloc(&pdev->dev, | |
| 184 | + config->pwr_reg_cnt, | |
| 185 | + sizeof(hdmi->pwr_regs[0]), | |
| 186 | + GFP_KERNEL); | |
| 183 | 187 | if (!hdmi->pwr_regs) { |
| 184 | 188 | ret = -ENOMEM; |
| 185 | 189 | goto fail; |
| @@ -199,8 +203,10 @@ static struct hdmi *msm_hdmi_init(struct platform_device *pdev) · 13 unmodified lines | ||
| 199 | 203 | hdmi->pwr_regs[i] = reg; |
| 200 | 204 | } |
| 201 | 205 | |
| 202 | − hdmi->hpd_clks = devm_kzalloc(&pdev->dev, sizeof(hdmi->hpd_clks[0]) * | |
| 203 | − config->hpd_clk_cnt, GFP_KERNEL); | |
| 206 | + hdmi->hpd_clks = devm_kcalloc(&pdev->dev, | |
| 207 | + config->hpd_clk_cnt, | |
| 208 | + sizeof(hdmi->hpd_clks[0]), | |
| 209 | + GFP_KERNEL); | |
| 204 | 210 | if (!hdmi->hpd_clks) { |
| 205 | 211 | ret = -ENOMEM; |
| 206 | 212 | goto fail; |
| @@ -219,8 +225,10 @@ static struct hdmi *msm_hdmi_init(struct platform_device *pdev) · 12 unmodified lines | ||
| 219 | 225 | hdmi->hpd_clks[i] = clk; |
| 220 | 226 | } |
| 221 | 227 | |
| 222 | − hdmi->pwr_clks = devm_kzalloc(&pdev->dev, sizeof(hdmi->pwr_clks[0]) * | |
| 223 | − config->pwr_clk_cnt, GFP_KERNEL); | |
| 228 | + hdmi->pwr_clks = devm_kcalloc(&pdev->dev, | |
| 229 | + config->pwr_clk_cnt, | |
| 230 | + sizeof(hdmi->pwr_clks[0]), | |
| 231 | + GFP_KERNEL); | |
| 224 | 232 | if (!hdmi->pwr_clks) { |
| 225 | 233 | ret = -ENOMEM; |
| 226 | 234 | goto fail; |
| @@ -21,12 +21,12 @@ static int msm_hdmi_phy_resource_init(struct hdmi_phy *phy) · 20 unmodified lines | ||
| 21 | 21 | struct device *dev = &phy->pdev->dev; |
| 22 | 22 | int i, ret; |
| 23 | 23 | |
| 24 | − phy->regs = devm_kzalloc(dev, sizeof(phy->regs[0]) * cfg->num_regs, | |
| 24 | + phy->regs = devm_kcalloc(dev, cfg->num_regs, sizeof(phy->regs[0]), | |
| 25 | 25 | GFP_KERNEL); |
| 26 | 26 | if (!phy->regs) |
| 27 | 27 | return -ENOMEM; |
| 28 | 28 | |
| 29 | − phy->clks = devm_kzalloc(dev, sizeof(phy->clks[0]) * cfg->num_clks, | |
| 29 | + phy->clks = devm_kcalloc(dev, cfg->num_clks, sizeof(phy->clks[0]), | |
| 30 | 30 | GFP_KERNEL); |
| 31 | 31 | if (!phy->clks) |
| 32 | 32 | return -ENOMEM; |
| @@ -141,7 +141,7 @@ nv84_fence_suspend(struct nouveau_drm *drm) · 140 unmodified lines | ||
| 141 | 141 | struct nv84_fence_priv *priv = drm->fence; |
| 142 | 142 | int i; |
| 143 | 143 | |
| 144 | − priv->suspend = vmalloc(drm->chan.nr * sizeof(u32)); | |
| 144 | + priv->suspend = vmalloc(array_size(sizeof(u32), drm->chan.nr)); | |
| 145 | 145 | if (priv->suspend) { |
| 146 | 146 | for (i = 0; i < drm->chan.nr; i++) |
| 147 | 147 | priv->suspend[i] = nouveau_bo_rd32(priv->bo, i*4); |
| @@ -50,8 +50,8 @@ nvif_fifo_runlists(struct nvif_device *device) · 49 unmodified lines | ||
| 50 | 50 | goto done; |
| 51 | 51 | |
| 52 | 52 | device->runlists = fls64(a->v.runlists.data); |
| 53 | − device->runlist = kzalloc(sizeof(*device->runlist) * | |
| 54 | − device->runlists, GFP_KERNEL); | |
| 53 | + device->runlist = kcalloc(device->runlists, sizeof(*device->runlist), | |
| 54 | + GFP_KERNEL); | |
| 55 | 55 | if (!device->runlist) { |
| 56 | 56 | ret = -ENOMEM; |
| 57 | 57 | goto done; |
| @@ -65,12 +65,15 @@ nvif_mmu_init(struct nvif_object *parent, s32 oclass, struct nvif_mmu *mmu) · 64 unmodified lines | ||
| 65 | 65 | goto done; |
| 66 | 66 | mmu->mem = mems[ret].oclass; |
| 67 | 67 | |
| 68 | − mmu->heap = kmalloc(sizeof(*mmu->heap) * mmu->heap_nr, GFP_KERNEL); | |
| 69 | − mmu->type = kmalloc(sizeof(*mmu->type) * mmu->type_nr, GFP_KERNEL); | |
| 68 | + mmu->heap = kmalloc_array(mmu->heap_nr, sizeof(*mmu->heap), | |
| 69 | + GFP_KERNEL); | |
| 70 | + mmu->type = kmalloc_array(mmu->type_nr, sizeof(*mmu->type), | |
| 71 | + GFP_KERNEL); | |
| 70 | 72 | if (ret = -ENOMEM, !mmu->heap || !mmu->type) |
| 71 | 73 | goto done; |
| 72 | 74 | |
| 73 | − mmu->kind = kmalloc(sizeof(*mmu->kind) * mmu->kind_nr, GFP_KERNEL); | |
| 75 | + mmu->kind = kmalloc_array(mmu->kind_nr, sizeof(*mmu->kind), | |
| 76 | + GFP_KERNEL); | |
| 74 | 77 | if (!mmu->kind && mmu->kind_nr) |
| 75 | 78 | goto done; |
| 76 | 79 | |
| @@ -83,7 +83,7 @@ nvif_object_sclass_get(struct nvif_object *object, struct nvif_sclass **psclass) · 82 unmodified lines | ||
| 83 | 83 | return ret; |
| 84 | 84 | } |
| 85 | 85 | |
| 86 | − *psclass = kzalloc(sizeof(**psclass) * args->sclass.count, GFP_KERNEL); | |
| 86 | + *psclass = kcalloc(args->sclass.count, sizeof(**psclass), GFP_KERNEL); | |
| 87 | 87 | if (*psclass) { |
| 88 | 88 | for (i = 0; i < args->sclass.count; i++) { |
| 89 | 89 | (*psclass)[i].oclass = args->sclass.oclass[i].oclass; |
| @@ -138,7 +138,8 @@ nvif_vmm_init(struct nvif_mmu *mmu, s32 oclass, u64 addr, u64 size, · 137 unmodified lines | ||
| 138 | 138 | vmm->limit = args->size; |
| 139 | 139 | |
| 140 | 140 | vmm->page_nr = args->page_nr; |
| 141 | − vmm->page = kmalloc(sizeof(*vmm->page) * vmm->page_nr, GFP_KERNEL); | |
| 141 | + vmm->page = kmalloc_array(vmm->page_nr, sizeof(*vmm->page), | |
| 142 | + GFP_KERNEL); | |
| 142 | 143 | if (!vmm->page) { |
| 143 | 144 | ret = -ENOMEM; |
| 144 | 145 | goto done; |
| @@ -84,7 +84,8 @@ int · 83 unmodified lines | ||
| 84 | 84 | nvkm_event_init(const struct nvkm_event_func *func, int types_nr, int index_nr, |
| 85 | 85 | struct nvkm_event *event) |
| 86 | 86 | { |
| 87 | − event->refs = kzalloc(sizeof(*event->refs) * index_nr * types_nr, | |
| 87 | + event->refs = kzalloc(array3_size(index_nr, types_nr, | |
| 88 | + sizeof(*event->refs)), | |
| 88 | 89 | GFP_KERNEL); |
| 89 | 90 | if (!event->refs) |
| 90 | 91 | return -ENOMEM; |
| @@ -910,7 +910,7 @@ gk104_fifo_oneinit(struct nvkm_fifo *base) · 909 unmodified lines | ||
| 910 | 910 | nvkm_debug(subdev, "%d PBDMA(s)\n", fifo->pbdma_nr); |
| 911 | 911 | |
| 912 | 912 | /* Read PBDMA->runlist(s) mapping from HW. */ |
| 913 | − if (!(map = kzalloc(sizeof(*map) * fifo->pbdma_nr, GFP_KERNEL))) | |
| 913 | + if (!(map = kcalloc(fifo->pbdma_nr, sizeof(*map), GFP_KERNEL))) | |
| 914 | 914 | return -ENOMEM; |
| 915 | 915 | |
| 916 | 916 | for (i = 0; i < fifo->pbdma_nr; i++) |
| @@ -73,7 +73,8 @@ nvbios_iccsense_parse(struct nvkm_bios *bios, struct nvbios_iccsense *iccsense) · 72 unmodified lines | ||
| 73 | 73 | } |
| 74 | 74 | |
| 75 | 75 | iccsense->nr_entry = cnt; |
| 76 | − iccsense->rail = kmalloc(sizeof(struct pwr_rail_t) * cnt, GFP_KERNEL); | |
| 76 | + iccsense->rail = kmalloc_array(cnt, sizeof(struct pwr_rail_t), | |
| 77 | + GFP_KERNEL); | |
| 77 | 78 | if (!iccsense->rail) |
| 78 | 79 | return -ENOMEM; |
| 79 | 80 | |
| @@ -171,7 +171,7 @@ gt215_link_train(struct gt215_ram *ram) · 170 unmodified lines | ||
| 171 | 171 | return -ENOSYS; |
| 172 | 172 | |
| 173 | 173 | /* XXX: Multiple partitions? */ |
| 174 | − result = kmalloc(64 * sizeof(u32), GFP_KERNEL); | |
| 174 | + result = kmalloc_array(64, sizeof(u32), GFP_KERNEL); | |
| 175 | 175 | if (!result) |
| 176 | 176 | return -ENOMEM; |
| 177 | 177 | |
| @@ -191,9 +191,9 @@ nvkm_mem_new_host(struct nvkm_mmu *mmu, int type, u8 page, u64 size, · 190 unmodified lines | ||
| 191 | 191 | nvkm_memory_ctor(&nvkm_mem_dma, &mem->memory); |
| 192 | 192 | size = ALIGN(size, PAGE_SIZE) >> PAGE_SHIFT; |
| 193 | 193 | |
| 194 | − if (!(mem->mem = kvmalloc(sizeof(*mem->mem) * size, GFP_KERNEL))) | |
| 194 | + if (!(mem->mem = kvmalloc_array(size, sizeof(*mem->mem), GFP_KERNEL))) | |
| 195 | 195 | return -ENOMEM; |
| 196 | − if (!(mem->dma = kvmalloc(sizeof(*mem->dma) * size, GFP_KERNEL))) | |
| 196 | + if (!(mem->dma = kvmalloc_array(size, sizeof(*mem->dma), GFP_KERNEL))) | |
| 197 | 197 | return -ENOMEM; |
| 198 | 198 | |
| 199 | 199 | if (mmu->dma_bits > 32) |
| @@ -59,7 +59,7 @@ nvkm_vmm_pt_new(const struct nvkm_vmm_desc *desc, bool sparse, · 58 unmodified lines | ||
| 59 | 59 | pgt->sparse = sparse; |
| 60 | 60 | |
| 61 | 61 | if (desc->type == PGD) { |
| 62 | − pgt->pde = kvzalloc(sizeof(*pgt->pde) * pten, GFP_KERNEL); | |
| 62 | + pgt->pde = kvcalloc(pten, sizeof(*pgt->pde), GFP_KERNEL); | |
| 63 | 63 | if (!pgt->pde) { |
| 64 | 64 | kfree(pgt); |
| 65 | 65 | return NULL; |
| @@ -940,8 +940,8 @@ int tiler_map_show(struct seq_file *s, void *arg) · 939 unmodified lines | ||
| 940 | 940 | h_adj = omap_dmm->container_height / ydiv; |
| 941 | 941 | w_adj = omap_dmm->container_width / xdiv; |
| 942 | 942 | |
| 943 | − map = kmalloc(h_adj * sizeof(*map), GFP_KERNEL); | |
| 944 | − global_map = kmalloc((w_adj + 1) * h_adj, GFP_KERNEL); | |
| 943 | + map = kmalloc_array(h_adj, sizeof(*map), GFP_KERNEL); | |
| 944 | + global_map = kmalloc_array(w_adj + 1, h_adj, GFP_KERNEL); | |
| 945 | 945 | |
| 946 | 946 | if (!map || !global_map) |
| 947 | 947 | goto error; |
| @@ -244,7 +244,7 @@ static int omap_gem_attach_pages(struct drm_gem_object *obj) · 243 unmodified lines | ||
| 244 | 244 | * DSS, GPU, etc. are not cache coherent: |
| 245 | 245 | */ |
| 246 | 246 | if (omap_obj->flags & (OMAP_BO_WC|OMAP_BO_UNCACHED)) { |
| 247 | − addrs = kmalloc(npages * sizeof(*addrs), GFP_KERNEL); | |
| 247 | + addrs = kmalloc_array(npages, sizeof(*addrs), GFP_KERNEL); | |
| 248 | 248 | if (!addrs) { |
| 249 | 249 | ret = -ENOMEM; |
| 250 | 250 | goto free_pages; |
| @@ -268,7 +268,7 @@ static int omap_gem_attach_pages(struct drm_gem_object *obj) · 17 unmodified lines | ||
| 268 | 268 | } |
| 269 | 269 | } |
| 270 | 270 | } else { |
| 271 | − addrs = kzalloc(npages * sizeof(*addrs), GFP_KERNEL); | |
| 271 | + addrs = kcalloc(npages, sizeof(*addrs), GFP_KERNEL); | |
| 272 | 272 | if (!addrs) { |
| 273 | 273 | ret = -ENOMEM; |
| 274 | 274 | goto free_pages; |
| @@ -241,7 +241,7 @@ static int qxlfb_create(struct qxl_fbdev *qfbdev, · 240 unmodified lines | ||
| 241 | 241 | DRM_DEBUG_DRIVER("%dx%d %d\n", mode_cmd.width, |
| 242 | 242 | mode_cmd.height, mode_cmd.pitches[0]); |
| 243 | 243 | |
| 244 | − shadow = vmalloc(mode_cmd.pitches[0] * mode_cmd.height); | |
| 244 | + shadow = vmalloc(array_size(mode_cmd.pitches[0], mode_cmd.height)); | |
| 245 | 245 | /* TODO: what's the usual response to memory allocation errors? */ |
| 246 | 246 | BUG_ON(!shadow); |
| 247 | 247 | DRM_DEBUG_DRIVER("surface0 at gpu offset %lld, mmap_offset %lld (virt %p, shadow %p)\n", |
| @@ -200,8 +200,8 @@ int qxl_device_init(struct qxl_device *qdev, · 199 unmodified lines | ||
| 200 | 200 | (~(uint64_t)0) >> (qdev->slot_id_bits + qdev->slot_gen_bits); |
| 201 | 201 | |
| 202 | 202 | qdev->mem_slots = |
| 203 | − kmalloc(qdev->n_mem_slots * sizeof(struct qxl_memslot), | |
| 204 | − GFP_KERNEL); | |
| 203 | + kmalloc_array(qdev->n_mem_slots, sizeof(struct qxl_memslot), | |
| 204 | + GFP_KERNEL); | |
| 205 | 205 | |
| 206 | 206 | idr_init(&qdev->release_idr); |
| 207 | 207 | spin_lock_init(&qdev->release_idr_lock); |
| @@ -1176,7 +1176,7 @@ static int atom_execute_table_locked(struct atom_context *ctx, int index, uint32 · 1175 unmodified lines | ||
| 1176 | 1176 | ectx.abort = false; |
| 1177 | 1177 | ectx.last_jump = 0; |
| 1178 | 1178 | if (ws) |
| 1179 | − ectx.ws = kzalloc(4 * ws, GFP_KERNEL); | |
| 1179 | + ectx.ws = kcalloc(4, ws, GFP_KERNEL); | |
| 1180 | 1180 | else |
| 1181 | 1181 | ectx.ws = NULL; |
| 1182 | 1182 | |
| @@ -2581,7 +2581,9 @@ int btc_dpm_init(struct radeon_device *rdev) · 2580 unmodified lines | ||
| 2581 | 2581 | return ret; |
| 2582 | 2582 | |
| 2583 | 2583 | rdev->pm.dpm.dyn_state.vddc_dependency_on_dispclk.entries = |
| 2584 | − kzalloc(4 * sizeof(struct radeon_clock_voltage_dependency_entry), GFP_KERNEL); | |
| 2584 | + kcalloc(4, | |
| 2585 | + sizeof(struct radeon_clock_voltage_dependency_entry), | |
| 2586 | + GFP_KERNEL); | |
| 2585 | 2587 | if (!rdev->pm.dpm.dyn_state.vddc_dependency_on_dispclk.entries) { |
| 2586 | 2588 | r600_free_extended_power_table(rdev); |
| 2587 | 2589 | return -ENOMEM; |
| @@ -5568,8 +5568,9 @@ static int ci_parse_power_table(struct radeon_device *rdev) · 5567 unmodified lines | ||
| 5568 | 5568 | (mode_info->atom_context->bios + data_offset + |
| 5569 | 5569 | le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset)); |
| 5570 | 5570 | |
| 5571 | − rdev->pm.dpm.ps = kzalloc(sizeof(struct radeon_ps) * | |
| 5572 | − state_array->ucNumEntries, GFP_KERNEL); | |
| 5571 | + rdev->pm.dpm.ps = kcalloc(state_array->ucNumEntries, | |
| 5572 | + sizeof(struct radeon_ps), | |
| 5573 | + GFP_KERNEL); | |
| 5573 | 5574 | if (!rdev->pm.dpm.ps) |
| 5574 | 5575 | return -ENOMEM; |
| 5575 | 5576 | power_state_offset = (u8 *)state_array->states; |
| @@ -5770,7 +5771,9 @@ int ci_dpm_init(struct radeon_device *rdev) · 194 unmodified lines | ||
| 5770 | 5771 | ci_set_private_data_variables_based_on_pptable(rdev); |
| 5771 | 5772 | |
| 5772 | 5773 | rdev->pm.dpm.dyn_state.vddc_dependency_on_dispclk.entries = |
| 5773 | − kzalloc(4 * sizeof(struct radeon_clock_voltage_dependency_entry), GFP_KERNEL); | |
| 5774 | + kcalloc(4, | |
| 5775 | + sizeof(struct radeon_clock_voltage_dependency_entry), | |
| 5776 | + GFP_KERNEL); | |
| 5774 | 5777 | if (!rdev->pm.dpm.dyn_state.vddc_dependency_on_dispclk.entries) { |
| 5775 | 5778 | ci_dpm_fini(rdev); |
| 5776 | 5779 | return -ENOMEM; |
| @@ -2660,8 +2660,9 @@ static int kv_parse_power_table(struct radeon_device *rdev) · 2659 unmodified lines | ||
| 2660 | 2660 | (mode_info->atom_context->bios + data_offset + |
| 2661 | 2661 | le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset)); |
| 2662 | 2662 | |
| 2663 | − rdev->pm.dpm.ps = kzalloc(sizeof(struct radeon_ps) * | |
| 2664 | − state_array->ucNumEntries, GFP_KERNEL); | |
| 2663 | + rdev->pm.dpm.ps = kcalloc(state_array->ucNumEntries, | |
| 2664 | + sizeof(struct radeon_ps), | |
| 2665 | + GFP_KERNEL); | |
| 2665 | 2666 | if (!rdev->pm.dpm.ps) |
| 2666 | 2667 | return -ENOMEM; |
| 2667 | 2668 | power_state_offset = (u8 *)state_array->states; |
| @@ -3998,8 +3998,9 @@ static int ni_parse_power_table(struct radeon_device *rdev) · 3997 unmodified lines | ||
| 3998 | 3998 | return -EINVAL; |
| 3999 | 3999 | power_info = (union power_info *)(mode_info->atom_context->bios + data_offset); |
| 4000 | 4000 | |
| 4001 | − rdev->pm.dpm.ps = kzalloc(sizeof(struct radeon_ps) * | |
| 4002 | − power_info->pplib.ucNumStates, GFP_KERNEL); | |
| 4001 | + rdev->pm.dpm.ps = kcalloc(power_info->pplib.ucNumStates, | |
| 4002 | + sizeof(struct radeon_ps), | |
| 4003 | + GFP_KERNEL); | |
| 4003 | 4004 | if (!rdev->pm.dpm.ps) |
| 4004 | 4005 | return -ENOMEM; |
| 4005 | 4006 | |
| @@ -4075,7 +4076,9 @@ int ni_dpm_init(struct radeon_device *rdev) · 69 unmodified lines | ||
| 4075 | 4076 | return ret; |
| 4076 | 4077 | |
| 4077 | 4078 | rdev->pm.dpm.dyn_state.vddc_dependency_on_dispclk.entries = |
| 4078 | − kzalloc(4 * sizeof(struct radeon_clock_voltage_dependency_entry), GFP_KERNEL); | |
| 4079 | + kcalloc(4, | |
| 4080 | + sizeof(struct radeon_clock_voltage_dependency_entry), | |
| 4081 | + GFP_KERNEL); | |
| 4079 | 4082 | if (!rdev->pm.dpm.dyn_state.vddc_dependency_on_dispclk.entries) { |
| 4080 | 4083 | r600_free_extended_power_table(rdev); |
| 4081 | 4084 | return -ENOMEM; |
| @@ -991,7 +991,7 @@ int r600_parse_extended_power_table(struct radeon_device *rdev) · 990 unmodified lines | ||
| 991 | 991 | ATOM_PPLIB_PhaseSheddingLimits_Record *entry; |
| 992 | 992 | |
| 993 | 993 | rdev->pm.dpm.dyn_state.phase_shedding_limits_table.entries = |
| 994 | − kzalloc(psl->ucNumEntries * | |
| 994 | + kcalloc(psl->ucNumEntries, | |
| 995 | 995 | sizeof(struct radeon_phase_shedding_limits_entry), |
| 996 | 996 | GFP_KERNEL); |
| 997 | 997 | if (!rdev->pm.dpm.dyn_state.phase_shedding_limits_table.entries) { |
| @@ -2126,13 +2126,16 @@ static int radeon_atombios_parse_power_table_1_3(struct radeon_device *rdev) · 2125 unmodified lines | ||
| 2126 | 2126 | num_modes = ATOM_MAX_NUMBEROF_POWER_BLOCK; |
| 2127 | 2127 | if (num_modes == 0) |
| 2128 | 2128 | return state_index; |
| 2129 | − rdev->pm.power_state = kzalloc(sizeof(struct radeon_power_state) * num_modes, GFP_KERNEL); | |
| 2129 | + rdev->pm.power_state = kcalloc(num_modes, | |
| 2130 | + sizeof(struct radeon_power_state), | |
| 2131 | + GFP_KERNEL); | |
| 2130 | 2132 | if (!rdev->pm.power_state) |
| 2131 | 2133 | return state_index; |
| 2132 | 2134 | /* last mode is usually default, array is low to high */ |
| 2133 | 2135 | for (i = 0; i < num_modes; i++) { |
| 2134 | 2136 | rdev->pm.power_state[state_index].clock_info = |
| 2135 | − kzalloc(sizeof(struct radeon_pm_clock_info) * 1, GFP_KERNEL); | |
| 2137 | + kcalloc(1, sizeof(struct radeon_pm_clock_info), | |
| 2138 | + GFP_KERNEL); | |
| 2136 | 2139 | if (!rdev->pm.power_state[state_index].clock_info) |
| 2137 | 2140 | return state_index; |
| 2138 | 2141 | rdev->pm.power_state[state_index].num_clock_modes = 1; |
| @@ -2587,8 +2590,9 @@ static int radeon_atombios_parse_power_table_4_5(struct radeon_device *rdev) · 448 unmodified lines | ||
| 2587 | 2590 | radeon_atombios_add_pplib_thermal_controller(rdev, &power_info->pplib.sThermalController); |
| 2588 | 2591 | if (power_info->pplib.ucNumStates == 0) |
| 2589 | 2592 | return state_index; |
| 2590 | − rdev->pm.power_state = kzalloc(sizeof(struct radeon_power_state) * | |
| 2591 | − power_info->pplib.ucNumStates, GFP_KERNEL); | |
| 2593 | + rdev->pm.power_state = kcalloc(power_info->pplib.ucNumStates, | |
| 2594 | + sizeof(struct radeon_power_state), | |
| 2595 | + GFP_KERNEL); | |
| 2592 | 2596 | if (!rdev->pm.power_state) |
| 2593 | 2597 | return state_index; |
| 2594 | 2598 | /* first mode is usually default, followed by low to high */ |
| @@ -2603,10 +2607,11 @@ static int radeon_atombios_parse_power_table_4_5(struct radeon_device *rdev) · 8 unmodified lines | ||
| 2603 | 2607 | le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset) + |
| 2604 | 2608 | (power_state->v1.ucNonClockStateIndex * |
| 2605 | 2609 | power_info->pplib.ucNonClockSize)); |
| 2606 | − rdev->pm.power_state[i].clock_info = kzalloc(sizeof(struct radeon_pm_clock_info) * | |
| 2607 | − ((power_info->pplib.ucStateEntrySize - 1) ? | |
| 2608 | − (power_info->pplib.ucStateEntrySize - 1) : 1), | |
| 2609 | − GFP_KERNEL); | |
| 2610 | + rdev->pm.power_state[i].clock_info = | |
| 2611 | + kcalloc((power_info->pplib.ucStateEntrySize - 1) ? | |
| 2612 | + (power_info->pplib.ucStateEntrySize - 1) : 1, | |
| 2613 | + sizeof(struct radeon_pm_clock_info), | |
| 2614 | + GFP_KERNEL); | |
| 2610 | 2615 | if (!rdev->pm.power_state[i].clock_info) |
| 2611 | 2616 | return state_index; |
| 2612 | 2617 | if (power_info->pplib.ucStateEntrySize - 1) { |
| @@ -2688,8 +2693,9 @@ static int radeon_atombios_parse_power_table_6(struct radeon_device *rdev) · 75 unmodified lines | ||
| 2688 | 2693 | le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset)); |
| 2689 | 2694 | if (state_array->ucNumEntries == 0) |
| 2690 | 2695 | return state_index; |
| 2691 | − rdev->pm.power_state = kzalloc(sizeof(struct radeon_power_state) * | |
| 2692 | − state_array->ucNumEntries, GFP_KERNEL); | |
| 2696 | + rdev->pm.power_state = kcalloc(state_array->ucNumEntries, | |
| 2697 | + sizeof(struct radeon_power_state), | |
| 2698 | + GFP_KERNEL); | |
| 2693 | 2699 | if (!rdev->pm.power_state) |
| 2694 | 2700 | return state_index; |
| 2695 | 2701 | power_state_offset = (u8 *)state_array->states; |
| @@ -2699,10 +2705,11 @@ static int radeon_atombios_parse_power_table_6(struct radeon_device *rdev) · 3 unmodified lines | ||
| 2699 | 2705 | non_clock_array_index = power_state->v2.nonClockInfoIndex; |
| 2700 | 2706 | non_clock_info = (struct _ATOM_PPLIB_NONCLOCK_INFO *) |
| 2701 | 2707 | &non_clock_info_array->nonClockInfo[non_clock_array_index]; |
| 2702 | − rdev->pm.power_state[i].clock_info = kzalloc(sizeof(struct radeon_pm_clock_info) * | |
| 2703 | − (power_state->v2.ucNumDPMLevels ? | |
| 2704 | − power_state->v2.ucNumDPMLevels : 1), | |
| 2705 | − GFP_KERNEL); | |
| 2708 | + rdev->pm.power_state[i].clock_info = | |
| 2709 | + kcalloc(power_state->v2.ucNumDPMLevels ? | |
| 2710 | + power_state->v2.ucNumDPMLevels : 1, | |
| 2711 | + sizeof(struct radeon_pm_clock_info), | |
| 2712 | + GFP_KERNEL); | |
| 2706 | 2713 | if (!rdev->pm.power_state[i].clock_info) |
| 2707 | 2714 | return state_index; |
| 2708 | 2715 | if (power_state->v2.ucNumDPMLevels) { |
| @@ -2782,7 +2789,9 @@ void radeon_atombios_get_power_modes(struct radeon_device *rdev) · 73 unmodified lines | ||
| 2782 | 2789 | rdev->pm.power_state = kzalloc(sizeof(struct radeon_power_state), GFP_KERNEL); |
| 2783 | 2790 | if (rdev->pm.power_state) { |
| 2784 | 2791 | rdev->pm.power_state[0].clock_info = |
| 2785 | − kzalloc(sizeof(struct radeon_pm_clock_info) * 1, GFP_KERNEL); | |
| 2792 | + kcalloc(1, | |
| 2793 | + sizeof(struct radeon_pm_clock_info), | |
| 2794 | + GFP_KERNEL); | |
| 2786 | 2795 | if (rdev->pm.power_state[0].clock_info) { |
| 2787 | 2796 | /* add the default mode */ |
| 2788 | 2797 | rdev->pm.power_state[state_index].type = |
| @@ -2642,13 +2642,16 @@ void radeon_combios_get_power_modes(struct radeon_device *rdev) · 2641 unmodified lines | ||
| 2642 | 2642 | rdev->pm.default_power_state_index = -1; |
| 2643 | 2643 | |
| 2644 | 2644 | /* allocate 2 power states */ |
| 2645 | − rdev->pm.power_state = kzalloc(sizeof(struct radeon_power_state) * 2, GFP_KERNEL); | |
| 2645 | + rdev->pm.power_state = kcalloc(2, sizeof(struct radeon_power_state), | |
| 2646 | + GFP_KERNEL); | |
| 2646 | 2647 | if (rdev->pm.power_state) { |
| 2647 | 2648 | /* allocate 1 clock mode per state */ |
| 2648 | 2649 | rdev->pm.power_state[0].clock_info = |
| 2649 | − kzalloc(sizeof(struct radeon_pm_clock_info) * 1, GFP_KERNEL); | |
| 2650 | + kcalloc(1, sizeof(struct radeon_pm_clock_info), | |
| 2651 | + GFP_KERNEL); | |
| 2650 | 2652 | rdev->pm.power_state[1].clock_info = |
| 2651 | − kzalloc(sizeof(struct radeon_pm_clock_info) * 1, GFP_KERNEL); | |
| 2653 | + kcalloc(1, sizeof(struct radeon_pm_clock_info), | |
| 2654 | + GFP_KERNEL); | |
| 2652 | 2655 | if (!rdev->pm.power_state[0].clock_info || |
| 2653 | 2656 | !rdev->pm.power_state[1].clock_info) |
| 2654 | 2657 | goto pm_failed; |
| @@ -347,13 +347,14 @@ int radeon_gart_init(struct radeon_device *rdev) · 346 unmodified lines | ||
| 347 | 347 | DRM_INFO("GART: num cpu pages %u, num gpu pages %u\n", |
| 348 | 348 | rdev->gart.num_cpu_pages, rdev->gart.num_gpu_pages); |
| 349 | 349 | /* Allocate pages table */ |
| 350 | − rdev->gart.pages = vzalloc(sizeof(void *) * rdev->gart.num_cpu_pages); | |
| 350 | + rdev->gart.pages = vzalloc(array_size(sizeof(void *), | |
| 351 | + rdev->gart.num_cpu_pages)); | |
| 351 | 352 | if (rdev->gart.pages == NULL) { |
| 352 | 353 | radeon_gart_fini(rdev); |
| 353 | 354 | return -ENOMEM; |
| 354 | 355 | } |
| 355 | − rdev->gart.pages_entry = vmalloc(sizeof(uint64_t) * | |
| 356 | − rdev->gart.num_gpu_pages); | |
| 356 | + rdev->gart.pages_entry = vmalloc(array_size(sizeof(uint64_t), | |
| 357 | + rdev->gart.num_gpu_pages)); | |
| 357 | 358 | if (rdev->gart.pages_entry == NULL) { |
| 358 | 359 | radeon_gart_fini(rdev); |
| 359 | 360 | return -ENOMEM; |
| @@ -59,7 +59,7 @@ static void radeon_do_test_moves(struct radeon_device *rdev, int flag) · 58 unmodified lines | ||
| 59 | 59 | n = rdev->mc.gtt_size - rdev->gart_pin_size; |
| 60 | 60 | n /= size; |
| 61 | 61 | |
| 62 | − gtt_obj = kzalloc(n * sizeof(*gtt_obj), GFP_KERNEL); | |
| 62 | + gtt_obj = kcalloc(n, sizeof(*gtt_obj), GFP_KERNEL); | |
| 63 | 63 | if (!gtt_obj) { |
| 64 | 64 | DRM_ERROR("Failed to allocate %d pointers\n", n); |
| 65 | 65 | r = 1; |
| @@ -804,8 +804,9 @@ static int rs780_parse_power_table(struct radeon_device *rdev) · 803 unmodified lines | ||
| 804 | 804 | return -EINVAL; |
| 805 | 805 | power_info = (union power_info *)(mode_info->atom_context->bios + data_offset); |
| 806 | 806 | |
| 807 | − rdev->pm.dpm.ps = kzalloc(sizeof(struct radeon_ps) * | |
| 808 | − power_info->pplib.ucNumStates, GFP_KERNEL); | |
| 807 | + rdev->pm.dpm.ps = kcalloc(power_info->pplib.ucNumStates, | |
| 808 | + sizeof(struct radeon_ps), | |
| 809 | + GFP_KERNEL); | |
| 809 | 810 | if (!rdev->pm.dpm.ps) |
| 810 | 811 | return -ENOMEM; |
| 811 | 812 | |
| @@ -1888,8 +1888,9 @@ static int rv6xx_parse_power_table(struct radeon_device *rdev) · 1887 unmodified lines | ||
| 1888 | 1888 | return -EINVAL; |
| 1889 | 1889 | power_info = (union power_info *)(mode_info->atom_context->bios + data_offset); |
| 1890 | 1890 | |
| 1891 | − rdev->pm.dpm.ps = kzalloc(sizeof(struct radeon_ps) * | |
| 1892 | − power_info->pplib.ucNumStates, GFP_KERNEL); | |
| 1891 | + rdev->pm.dpm.ps = kcalloc(power_info->pplib.ucNumStates, | |
| 1892 | + sizeof(struct radeon_ps), | |
| 1893 | + GFP_KERNEL); | |
| 1893 | 1894 | if (!rdev->pm.dpm.ps) |
| 1894 | 1895 | return -ENOMEM; |
| 1895 | 1896 | |
| @@ -2282,8 +2282,9 @@ int rv7xx_parse_power_table(struct radeon_device *rdev) · 2281 unmodified lines | ||
| 2282 | 2282 | return -EINVAL; |
| 2283 | 2283 | power_info = (union power_info *)(mode_info->atom_context->bios + data_offset); |
| 2284 | 2284 | |
| 2285 | − rdev->pm.dpm.ps = kzalloc(sizeof(struct radeon_ps) * | |
| 2286 | − power_info->pplib.ucNumStates, GFP_KERNEL); | |
| 2285 | + rdev->pm.dpm.ps = kcalloc(power_info->pplib.ucNumStates, | |
| 2286 | + sizeof(struct radeon_ps), | |
| 2287 | + GFP_KERNEL); | |
| 2287 | 2288 | if (!rdev->pm.dpm.ps) |
| 2288 | 2289 | return -ENOMEM; |
| 2289 | 2290 | |
| @@ -6832,8 +6832,9 @@ static int si_parse_power_table(struct radeon_device *rdev) · 6831 unmodified lines | ||
| 6832 | 6832 | (mode_info->atom_context->bios + data_offset + |
| 6833 | 6833 | le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset)); |
| 6834 | 6834 | |
| 6835 | − rdev->pm.dpm.ps = kzalloc(sizeof(struct radeon_ps) * | |
| 6836 | − state_array->ucNumEntries, GFP_KERNEL); | |
| 6835 | + rdev->pm.dpm.ps = kcalloc(state_array->ucNumEntries, | |
| 6836 | + sizeof(struct radeon_ps), | |
| 6837 | + GFP_KERNEL); | |
| 6837 | 6838 | if (!rdev->pm.dpm.ps) |
| 6838 | 6839 | return -ENOMEM; |
| 6839 | 6840 | power_state_offset = (u8 *)state_array->states; |
| @@ -6941,7 +6942,9 @@ int si_dpm_init(struct radeon_device *rdev) · 101 unmodified lines | ||
| 6941 | 6942 | return ret; |
| 6942 | 6943 | |
| 6943 | 6944 | rdev->pm.dpm.dyn_state.vddc_dependency_on_dispclk.entries = |
| 6944 | − kzalloc(4 * sizeof(struct radeon_clock_voltage_dependency_entry), GFP_KERNEL); | |
| 6945 | + kcalloc(4, | |
| 6946 | + sizeof(struct radeon_clock_voltage_dependency_entry), | |
| 6947 | + GFP_KERNEL); | |
| 6945 | 6948 | if (!rdev->pm.dpm.dyn_state.vddc_dependency_on_dispclk.entries) { |
| 6946 | 6949 | r600_free_extended_power_table(rdev); |
| 6947 | 6950 | return -ENOMEM; |
| @@ -1482,8 +1482,9 @@ static int sumo_parse_power_table(struct radeon_device *rdev) · 1481 unmodified lines | ||
| 1482 | 1482 | (mode_info->atom_context->bios + data_offset + |
| 1483 | 1483 | le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset)); |
| 1484 | 1484 | |
| 1485 | − rdev->pm.dpm.ps = kzalloc(sizeof(struct radeon_ps) * | |
| 1486 | − state_array->ucNumEntries, GFP_KERNEL); | |
| 1485 | + rdev->pm.dpm.ps = kcalloc(state_array->ucNumEntries, | |
| 1486 | + sizeof(struct radeon_ps), | |
| 1487 | + GFP_KERNEL); | |
| 1487 | 1488 | if (!rdev->pm.dpm.ps) |
| 1488 | 1489 | return -ENOMEM; |
| 1489 | 1490 | power_state_offset = (u8 *)state_array->states; |
| @@ -1757,8 +1757,9 @@ static int trinity_parse_power_table(struct radeon_device *rdev) · 1756 unmodified lines | ||
| 1757 | 1757 | (mode_info->atom_context->bios + data_offset + |
| 1758 | 1758 | le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset)); |
| 1759 | 1759 | |
| 1760 | − rdev->pm.dpm.ps = kzalloc(sizeof(struct radeon_ps) * | |
| 1761 | − state_array->ucNumEntries, GFP_KERNEL); | |
| 1760 | + rdev->pm.dpm.ps = kcalloc(state_array->ucNumEntries, | |
| 1761 | + sizeof(struct radeon_ps), | |
| 1762 | + GFP_KERNEL); | |
| 1762 | 1763 | if (!rdev->pm.dpm.ps) |
| 1763 | 1764 | return -ENOMEM; |
| 1764 | 1765 | power_state_offset = (u8 *)state_array->states; |
| @@ -298,8 +298,9 @@ static int savage_dma_init(drm_savage_private_t * dev_priv) · 297 unmodified lines | ||
| 298 | 298 | |
| 299 | 299 | dev_priv->nr_dma_pages = dev_priv->cmd_dma->size / |
| 300 | 300 | (SAVAGE_DMA_PAGE_SIZE * 4); |
| 301 | − dev_priv->dma_pages = kmalloc(sizeof(drm_savage_dma_page_t) * | |
| 302 | − dev_priv->nr_dma_pages, GFP_KERNEL); | |
| 301 | + dev_priv->dma_pages = kmalloc_array(dev_priv->nr_dma_pages, | |
| 302 | + sizeof(drm_savage_dma_page_t), | |
| 303 | + GFP_KERNEL); | |
| 303 | 304 | if (dev_priv->dma_pages == NULL) |
| 304 | 305 | return -ENOMEM; |
| 305 | 306 | |
| @@ -389,7 +389,7 @@ static int __igt_reserve(unsigned int count, u64 size) · 388 unmodified lines | ||
| 389 | 389 | if (!order) |
| 390 | 390 | goto err; |
| 391 | 391 | |
| 392 | − nodes = vzalloc(sizeof(*nodes) * count); | |
| 392 | + nodes = vzalloc(array_size(count, sizeof(*nodes))); | |
| 393 | 393 | if (!nodes) |
| 394 | 394 | goto err_order; |
| 395 | 395 | |
| @@ -579,7 +579,7 @@ static int __igt_insert(unsigned int count, u64 size, bool replace) · 183 unmodified lines | ||
| 579 | 579 | DRM_MM_BUG_ON(!size); |
| 580 | 580 | |
| 581 | 581 | ret = -ENOMEM; |
| 582 | − nodes = vmalloc(count * sizeof(*nodes)); | |
| 582 | + nodes = vmalloc(array_size(count, sizeof(*nodes))); | |
| 583 | 583 | if (!nodes) |
| 584 | 584 | goto err; |
| 585 | 585 | |
| @@ -889,7 +889,7 @@ static int __igt_insert_range(unsigned int count, u64 size, u64 start, u64 end) · 303 unmodified lines | ||
| 889 | 889 | */ |
| 890 | 890 | |
| 891 | 891 | ret = -ENOMEM; |
| 892 | − nodes = vzalloc(count * sizeof(*nodes)); | |
| 892 | + nodes = vzalloc(array_size(count, sizeof(*nodes))); | |
| 893 | 893 | if (!nodes) |
| 894 | 894 | goto err; |
| 895 | 895 | |
| @@ -1046,7 +1046,7 @@ static int igt_align(void *ignored) · 150 unmodified lines | ||
| 1046 | 1046 | * meets our requirements. |
| 1047 | 1047 | */ |
| 1048 | 1048 | |
| 1049 | − nodes = vzalloc(max_count * sizeof(*nodes)); | |
| 1049 | + nodes = vzalloc(array_size(max_count, sizeof(*nodes))); | |
| 1050 | 1050 | if (!nodes) |
| 1051 | 1051 | goto err; |
| 1052 | 1052 | |
| @@ -1416,7 +1416,7 @@ static int igt_evict(void *ignored) · 363 unmodified lines | ||
| 1416 | 1416 | */ |
| 1417 | 1417 | |
| 1418 | 1418 | ret = -ENOMEM; |
| 1419 | − nodes = vzalloc(size * sizeof(*nodes)); | |
| 1419 | + nodes = vzalloc(array_size(size, sizeof(*nodes))); | |
| 1420 | 1420 | if (!nodes) |
| 1421 | 1421 | goto err; |
| 1422 | 1422 | |
| @@ -1526,7 +1526,7 @@ static int igt_evict_range(void *ignored) · 103 unmodified lines | ||
| 1526 | 1526 | */ |
| 1527 | 1527 | |
| 1528 | 1528 | ret = -ENOMEM; |
| 1529 | − nodes = vzalloc(size * sizeof(*nodes)); | |
| 1529 | + nodes = vzalloc(array_size(size, sizeof(*nodes))); | |
| 1530 | 1530 | if (!nodes) |
| 1531 | 1531 | goto err; |
| 1532 | 1532 | |
| @@ -1627,11 +1627,11 @@ static int igt_topdown(void *ignored) · 94 unmodified lines | ||
| 1627 | 1627 | */ |
| 1628 | 1628 | |
| 1629 | 1629 | ret = -ENOMEM; |
| 1630 | − nodes = vzalloc(count * sizeof(*nodes)); | |
| 1630 | + nodes = vzalloc(array_size(count, sizeof(*nodes))); | |
| 1631 | 1631 | if (!nodes) |
| 1632 | 1632 | goto err; |
| 1633 | 1633 | |
| 1634 | − bitmap = kzalloc(count / BITS_PER_LONG * sizeof(unsigned long), | |
| 1634 | + bitmap = kcalloc(count / BITS_PER_LONG, sizeof(unsigned long), | |
| 1635 | 1635 | GFP_KERNEL); |
| 1636 | 1636 | if (!bitmap) |
| 1637 | 1637 | goto err_nodes; |
| @@ -1741,11 +1741,11 @@ static int igt_bottomup(void *ignored) · 103 unmodified lines | ||
| 1741 | 1741 | */ |
| 1742 | 1742 | |
| 1743 | 1743 | ret = -ENOMEM; |
| 1744 | − nodes = vzalloc(count * sizeof(*nodes)); | |
| 1744 | + nodes = vzalloc(array_size(count, sizeof(*nodes))); | |
| 1745 | 1745 | if (!nodes) |
| 1746 | 1746 | goto err; |
| 1747 | 1747 | |
| 1748 | − bitmap = kzalloc(count / BITS_PER_LONG * sizeof(unsigned long), | |
| 1748 | + bitmap = kcalloc(count / BITS_PER_LONG, sizeof(unsigned long), | |
| 1749 | 1749 | GFP_KERNEL); |
| 1750 | 1750 | if (!bitmap) |
| 1751 | 1751 | goto err_nodes; |
| @@ -2098,7 +2098,7 @@ static int igt_color_evict(void *ignored) · 346 unmodified lines | ||
| 2098 | 2098 | */ |
| 2099 | 2099 | |
| 2100 | 2100 | ret = -ENOMEM; |
| 2101 | − nodes = vzalloc(total_size * sizeof(*nodes)); | |
| 2101 | + nodes = vzalloc(array_size(total_size, sizeof(*nodes))); | |
| 2102 | 2102 | if (!nodes) |
| 2103 | 2103 | goto err; |
| 2104 | 2104 | |
| @@ -2199,7 +2199,7 @@ static int igt_color_evict_range(void *ignored) · 94 unmodified lines | ||
| 2199 | 2199 | */ |
| 2200 | 2200 | |
| 2201 | 2201 | ret = -ENOMEM; |
| 2202 | − nodes = vzalloc(total_size * sizeof(*nodes)); | |
| 2202 | + nodes = vzalloc(array_size(total_size, sizeof(*nodes))); | |
| 2203 | 2203 | if (!nodes) |
| 2204 | 2204 | goto err; |
| 2205 | 2205 | |
| @@ -548,7 +548,7 @@ static int repaper_fb_dirty(struct drm_framebuffer *fb, · 547 unmodified lines | ||
| 548 | 548 | DRM_DEBUG("Flushing [FB:%d] st=%ums\n", fb->base.id, |
| 549 | 549 | epd->factored_stage_time); |
| 550 | 550 | |
| 551 | − buf = kmalloc(fb->width * fb->height, GFP_KERNEL); | |
| 551 | + buf = kmalloc_array(fb->width, fb->height, GFP_KERNEL); | |
| 552 | 552 | if (!buf) |
| 553 | 553 | return -ENOMEM; |
| 554 | 554 | |
| @@ -348,8 +348,9 @@ static int ttm_page_pool_free(struct ttm_page_pool *pool, unsigned nr_free, · 347 unmodified lines | ||
| 348 | 348 | if (use_static) |
| 349 | 349 | pages_to_free = static_buf; |
| 350 | 350 | else |
| 351 | − pages_to_free = kmalloc(npages_to_free * sizeof(struct page *), | |
| 352 | − GFP_KERNEL); | |
| 351 | + pages_to_free = kmalloc_array(npages_to_free, | |
| 352 | + sizeof(struct page *), | |
| 353 | + GFP_KERNEL); | |
| 353 | 354 | if (!pages_to_free) { |
| 354 | 355 | pr_debug("Failed to allocate memory for pool free operation\n"); |
| 355 | 356 | return 0; |
| @@ -547,7 +548,8 @@ static int ttm_alloc_new_pages(struct list_head *pages, gfp_t gfp_flags, · 191 unmodified lines | ||
| 547 | 548 | unsigned max_cpages = min(count << order, (unsigned)NUM_PAGES_TO_ALLOC); |
| 548 | 549 | |
| 549 | 550 | /* allocate array for page caching change */ |
| 550 | − caching_array = kmalloc(max_cpages*sizeof(struct page *), GFP_KERNEL); | |
| 551 | + caching_array = kmalloc_array(max_cpages, sizeof(struct page *), | |
| 552 | + GFP_KERNEL); | |
| 551 | 553 | |
| 552 | 554 | if (!caching_array) { |
| 553 | 555 | pr_debug("Unable to allocate table for new pages\n"); |
| @@ -463,8 +463,9 @@ static unsigned ttm_dma_page_pool_free(struct dma_pool *pool, unsigned nr_free, · 462 unmodified lines | ||
| 463 | 463 | if (use_static) |
| 464 | 464 | pages_to_free = static_buf; |
| 465 | 465 | else |
| 466 | − pages_to_free = kmalloc(npages_to_free * sizeof(struct page *), | |
| 467 | − GFP_KERNEL); | |
| 466 | + pages_to_free = kmalloc_array(npages_to_free, | |
| 467 | + sizeof(struct page *), | |
| 468 | + GFP_KERNEL); | |
| 468 | 469 | |
| 469 | 470 | if (!pages_to_free) { |
| 470 | 471 | pr_debug("%s: Failed to allocate memory for pool free operation\n", |
| @@ -753,7 +754,8 @@ static int ttm_dma_pool_alloc_new_pages(struct dma_pool *pool, · 282 unmodified lines | ||
| 753 | 754 | (unsigned)(PAGE_SIZE/sizeof(struct page *))); |
| 754 | 755 | |
| 755 | 756 | /* allocate array for page caching change */ |
| 756 | − caching_array = kmalloc(max_cpages*sizeof(struct page *), GFP_KERNEL); | |
| 757 | + caching_array = kmalloc_array(max_cpages, sizeof(struct page *), | |
| 758 | + GFP_KERNEL); | |
| 757 | 759 | |
| 758 | 760 | if (!caching_array) { |
| 759 | 761 | pr_debug("%s: Unable to allocate table for new pages\n", |
| @@ -209,7 +209,7 @@ static void vc4_dlist_write(struct vc4_plane_state *vc4_state, u32 val) · 208 unmodified lines | ||
| 209 | 209 | { |
| 210 | 210 | if (vc4_state->dlist_count == vc4_state->dlist_size) { |
| 211 | 211 | u32 new_size = max(4u, vc4_state->dlist_count * 2); |
| 212 | − u32 *new_dlist = kmalloc(new_size * 4, GFP_KERNEL); | |
| 212 | + u32 *new_dlist = kmalloc_array(new_size, 4, GFP_KERNEL); | |
| 213 | 213 | |
| 214 | 214 | if (!new_dlist) |
| 215 | 215 | return; |
| @@ -235,7 +235,7 @@ via_lock_all_dma_pages(drm_via_sg_info_t *vsg, drm_via_dmablit_t *xfer) · 234 unmodified lines | ||
| 235 | 235 | vsg->num_pages = VIA_PFN(xfer->mem_addr + (xfer->num_lines * xfer->mem_stride - 1)) - |
| 236 | 236 | first_pfn + 1; |
| 237 | 237 | |
| 238 | − vsg->pages = vzalloc(sizeof(struct page *) * vsg->num_pages); | |
| 238 | + vsg->pages = vzalloc(array_size(sizeof(struct page *), vsg->num_pages)); | |
| 239 | 239 | if (NULL == vsg->pages) |
| 240 | 240 | return -ENOMEM; |
| 241 | 241 | ret = get_user_pages_fast((unsigned long)xfer->mem_addr, |
| @@ -134,8 +134,11 @@ static int open_collection(struct hid_parser *parser, unsigned type) · 133 unmodified lines | ||
| 134 | 134 | } |
| 135 | 135 | |
| 136 | 136 | if (parser->device->maxcollection == parser->device->collection_size) { |
| 137 | − collection = kmalloc(sizeof(struct hid_collection) * | |
| 138 | − parser->device->collection_size * 2, GFP_KERNEL); | |
| 137 | + collection = kmalloc( | |
| 138 | + array3_size(sizeof(struct hid_collection), | |
| 139 | + parser->device->collection_size, | |
| 140 | + 2), | |
| 141 | + GFP_KERNEL); | |
| 139 | 142 | if (collection == NULL) { |
| 140 | 143 | hid_err(parser->device, "failed to reallocate collection array\n"); |
| 141 | 144 | return -ENOMEM; |
| @@ -1278,7 +1281,7 @@ static void hid_input_field(struct hid_device *hid, struct hid_field *field, · 1136 unmodified lines | ||
| 1278 | 1281 | __s32 max = field->logical_maximum; |
| 1279 | 1282 | __s32 *value; |
| 1280 | 1283 | |
| 1281 | − value = kmalloc(sizeof(__s32) * count, GFP_ATOMIC); | |
| 1284 | + value = kmalloc_array(count, sizeof(__s32), GFP_ATOMIC); | |
| 1282 | 1285 | if (!value) |
| 1283 | 1286 | return; |
| 1284 | 1287 | |
| @@ -457,7 +457,7 @@ static char *resolv_usage_page(unsigned page, struct seq_file *f) { · 456 unmodified lines | ||
| 457 | 457 | char *buf = NULL; |
| 458 | 458 | |
| 459 | 459 | if (!f) { |
| 460 | − buf = kzalloc(sizeof(char) * HID_DEBUG_BUFSIZE, GFP_ATOMIC); | |
| 460 | + buf = kzalloc(HID_DEBUG_BUFSIZE, GFP_ATOMIC); | |
| 461 | 461 | if (!buf) |
| 462 | 462 | return ERR_PTR(-ENOMEM); |
| 463 | 463 | } |
| @@ -685,7 +685,7 @@ void hid_dump_report(struct hid_device *hid, int type, u8 *data, · 221 unmodified lines | ||
| 685 | 685 | char *buf; |
| 686 | 686 | unsigned int i; |
| 687 | 687 | |
| 688 | − buf = kmalloc(sizeof(char) * HID_DEBUG_BUFSIZE, GFP_ATOMIC); | |
| 688 | + buf = kmalloc(HID_DEBUG_BUFSIZE, GFP_ATOMIC); | |
| 689 | 689 | |
| 690 | 690 | if (!buf) |
| 691 | 691 | return; |
| @@ -1088,7 +1088,7 @@ static int hid_debug_events_open(struct inode *inode, struct file *file) · 396 unmodified lines | ||
| 1088 | 1088 | goto out; |
| 1089 | 1089 | } |
| 1090 | 1090 | |
| 1091 | − if (!(list->hid_debug_buf = kzalloc(sizeof(char) * HID_DEBUG_BUFSIZE, GFP_KERNEL))) { | |
| 1091 | + if (!(list->hid_debug_buf = kzalloc(HID_DEBUG_BUFSIZE, GFP_KERNEL))) { | |
| 1092 | 1092 | err = -ENOMEM; |
| 1093 | 1093 | kfree(list); |
| 1094 | 1094 | goto out; |
| @@ -394,7 +394,8 @@ static int picolcd_set_par(struct fb_info *info) · 393 unmodified lines | ||
| 394 | 394 | return -EINVAL; |
| 395 | 395 | |
| 396 | 396 | o_fb = fbdata->bitmap; |
| 397 | − tmp_fb = kmalloc(PICOLCDFB_SIZE*info->var.bits_per_pixel, GFP_KERNEL); | |
| 397 | + tmp_fb = kmalloc_array(PICOLCDFB_SIZE, info->var.bits_per_pixel, | |
| 398 | + GFP_KERNEL); | |
| 398 | 399 | if (!tmp_fb) |
| 399 | 400 | return -ENOMEM; |
| 400 | 401 | |
| @@ -624,7 +624,8 @@ static int sensor_hub_probe(struct hid_device *hdev, · 623 unmodified lines | ||
| 624 | 624 | ret = -EINVAL; |
| 625 | 625 | goto err_stop_hw; |
| 626 | 626 | } |
| 627 | − sd->hid_sensor_hub_client_devs = devm_kzalloc(&hdev->dev, dev_cnt * | |
| 627 | + sd->hid_sensor_hub_client_devs = devm_kcalloc(&hdev->dev, | |
| 628 | + dev_cnt, | |
| 628 | 629 | sizeof(struct mfd_cell), |
| 629 | 630 | GFP_KERNEL); |
| 630 | 631 | if (sd->hid_sensor_hub_client_devs == NULL) { |
| @@ -218,7 +218,7 @@ static ssize_t hidraw_get_report(struct file *file, char __user *buffer, size_t · 217 unmodified lines | ||
| 218 | 218 | goto out; |
| 219 | 219 | } |
| 220 | 220 | |
| 221 | − buf = kmalloc(count * sizeof(__u8), GFP_KERNEL); | |
| 221 | + buf = kmalloc(count, GFP_KERNEL); | |
| 222 | 222 | if (!buf) { |
| 223 | 223 | ret = -ENOMEM; |
| 224 | 224 | goto out; |
| @@ -121,9 +121,9 @@ static void process_recv(struct ishtp_cl *hid_ishtp_cl, void *recv_buf, · 120 unmodified lines | ||
| 121 | 121 | } |
| 122 | 122 | client_data->hid_dev_count = (unsigned int)*payload; |
| 123 | 123 | if (!client_data->hid_devices) |
| 124 | − client_data->hid_devices = devm_kzalloc( | |
| 124 | + client_data->hid_devices = devm_kcalloc( | |
| 125 | 125 | &client_data->cl_device->dev, |
| 126 | − client_data->hid_dev_count * | |
| 126 | + client_data->hid_dev_count, | |
| 127 | 127 | sizeof(struct device_info), |
| 128 | 128 | GFP_KERNEL); |
| 129 | 129 | if (!client_data->hid_devices) { |
| @@ -1363,7 +1363,7 @@ static int wacom_led_groups_alloc_and_register_one(struct device *dev, · 1362 unmodified lines | ||
| 1363 | 1363 | if (!devres_open_group(dev, &wacom->led.groups[group_id], GFP_KERNEL)) |
| 1364 | 1364 | return -ENOMEM; |
| 1365 | 1365 | |
| 1366 | − leds = devm_kzalloc(dev, sizeof(struct wacom_led) * count, GFP_KERNEL); | |
| 1366 | + leds = devm_kcalloc(dev, count, sizeof(struct wacom_led), GFP_KERNEL); | |
| 1367 | 1367 | if (!leds) { |
| 1368 | 1368 | error = -ENOMEM; |
| 1369 | 1369 | goto err; |
| @@ -1463,7 +1463,7 @@ static int wacom_led_groups_allocate(struct wacom *wacom, int count) · 93 unmodified lines | ||
| 1463 | 1463 | struct wacom_group_leds *groups; |
| 1464 | 1464 | int error; |
| 1465 | 1465 | |
| 1466 | − groups = devm_kzalloc(dev, sizeof(struct wacom_group_leds) * count, | |
| 1466 | + groups = devm_kcalloc(dev, count, sizeof(struct wacom_group_leds), | |
| 1467 | 1467 | GFP_KERNEL); |
| 1468 | 1468 | if (!groups) |
| 1469 | 1469 | return -ENOMEM; |
| @@ -190,7 +190,7 @@ int hv_synic_alloc(void) · 189 unmodified lines | ||
| 190 | 190 | { |
| 191 | 191 | int cpu; |
| 192 | 192 | |
| 193 | − hv_context.hv_numa_map = kzalloc(sizeof(struct cpumask) * nr_node_ids, | |
| 193 | + hv_context.hv_numa_map = kcalloc(nr_node_ids, sizeof(struct cpumask), | |
| 194 | 194 | GFP_KERNEL); |
| 195 | 195 | if (hv_context.hv_numa_map == NULL) { |
| 196 | 196 | pr_err("Unable to allocate NUMA map\n"); |
| @@ -202,7 +202,7 @@ int hv_ringbuffer_init(struct hv_ring_buffer_info *ring_info, · 201 unmodified lines | ||
| 202 | 202 | * First page holds struct hv_ring_buffer, do wraparound mapping for |
| 203 | 203 | * the rest. |
| 204 | 204 | */ |
| 205 | − pages_wraparound = kzalloc(sizeof(struct page *) * (page_cnt * 2 - 1), | |
| 205 | + pages_wraparound = kcalloc(page_cnt * 2 - 1, sizeof(struct page *), | |
| 206 | 206 | GFP_KERNEL); |
| 207 | 207 | if (!pages_wraparound) |
| 208 | 208 | return -ENOMEM; |
| @@ -575,8 +575,9 @@ static int read_domain_devices(struct acpi_power_meter_resource *resource) · 574 unmodified lines | ||
| 575 | 575 | if (!pss->package.count) |
| 576 | 576 | goto end; |
| 577 | 577 | |
| 578 | − resource->domain_devices = kzalloc(sizeof(struct acpi_device *) * | |
| 579 | − pss->package.count, GFP_KERNEL); | |
| 578 | + resource->domain_devices = kcalloc(pss->package.count, | |
| 579 | + sizeof(struct acpi_device *), | |
| 580 | + GFP_KERNEL); | |
| 580 | 581 | if (!resource->domain_devices) { |
| 581 | 582 | res = -ENOMEM; |
| 582 | 583 | goto end; |
| @@ -796,7 +797,7 @@ static int read_capabilities(struct acpi_power_meter_resource *resource) · 213 unmodified lines | ||
| 796 | 797 | goto error; |
| 797 | 798 | } |
| 798 | 799 | |
| 799 | − *str = kzalloc(sizeof(u8) * (element->string.length + 1), | |
| 800 | + *str = kcalloc(element->string.length + 1, sizeof(u8), | |
| 800 | 801 | GFP_KERNEL); |
| 801 | 802 | if (!*str) { |
| 802 | 803 | res = -ENOMEM; |
| @@ -894,7 +894,7 @@ static int aspeed_create_fan(struct device *dev, · 893 unmodified lines | ||
| 894 | 894 | count = of_property_count_u8_elems(child, "aspeed,fan-tach-ch"); |
| 895 | 895 | if (count < 1) |
| 896 | 896 | return -EINVAL; |
| 897 | − fan_tach_ch = devm_kzalloc(dev, sizeof(*fan_tach_ch) * count, | |
| 897 | + fan_tach_ch = devm_kcalloc(dev, count, sizeof(*fan_tach_ch), | |
| 898 | 898 | GFP_KERNEL); |
| 899 | 899 | if (!fan_tach_ch) |
| 900 | 900 | return -ENOMEM; |
| @@ -742,7 +742,7 @@ static int __init coretemp_init(void) · 741 unmodified lines | ||
| 742 | 742 | return -ENODEV; |
| 743 | 743 | |
| 744 | 744 | max_packages = topology_max_packages(); |
| 745 | − pkg_devices = kzalloc(max_packages * sizeof(struct platform_device *), | |
| 745 | + pkg_devices = kcalloc(max_packages, sizeof(struct platform_device *), | |
| 746 | 746 | GFP_KERNEL); |
| 747 | 747 | if (!pkg_devices) |
| 748 | 748 | return -ENOMEM; |
| @@ -441,8 +441,8 @@ static int gpio_fan_get_of_data(struct gpio_fan_data *fan_data) · 440 unmodified lines | ||
| 441 | 441 | dev_err(dev, "DT properties empty / missing"); |
| 442 | 442 | return -ENODEV; |
| 443 | 443 | } |
| 444 | − gpios = devm_kzalloc(dev, | |
| 445 | − fan_data->num_gpios * sizeof(struct gpio_desc *), | |
| 444 | + gpios = devm_kcalloc(dev, | |
| 445 | + fan_data->num_gpios, sizeof(struct gpio_desc *), | |
| 446 | 446 | GFP_KERNEL); |
| 447 | 447 | if (!gpios) |
| 448 | 448 | return -ENOMEM; |
| @@ -471,8 +471,8 @@ static int gpio_fan_get_of_data(struct gpio_fan_data *fan_data) · 22 unmodified lines | ||
| 471 | 471 | * Speed map is in the form <RPM ctrl_val RPM ctrl_val ...> |
| 472 | 472 | * this needs splitting into pairs to create gpio_fan_speed structs |
| 473 | 473 | */ |
| 474 | − speed = devm_kzalloc(dev, | |
| 475 | − fan_data->num_speed * sizeof(struct gpio_fan_speed), | |
| 474 | + speed = devm_kcalloc(dev, | |
| 475 | + fan_data->num_speed, sizeof(struct gpio_fan_speed), | |
| 476 | 476 | GFP_KERNEL); |
| 477 | 477 | if (!speed) |
| 478 | 478 | return -ENOMEM; |
| @@ -274,8 +274,9 @@ static int i5k_amb_hwmon_init(struct platform_device *pdev) · 273 unmodified lines | ||
| 274 | 274 | num_ambs += hweight16(data->amb_present[i] & 0x7fff); |
| 275 | 275 | |
| 276 | 276 | /* Set up sysfs stuff */ |
| 277 | − data->attrs = kzalloc(sizeof(*data->attrs) * num_ambs * KNOBS_PER_AMB, | |
| 278 | − GFP_KERNEL); | |
| 277 | + data->attrs = kzalloc(array3_size(num_ambs, KNOBS_PER_AMB, | |
| 278 | + sizeof(*data->attrs)), | |
| 279 | + GFP_KERNEL); | |
| 279 | 280 | if (!data->attrs) |
| 280 | 281 | return -ENOMEM; |
| 281 | 282 | data->num_attrs = 0; |
| @@ -387,7 +387,7 @@ static int ibmpex_find_sensors(struct ibmpex_bmc_data *data) · 386 unmodified lines | ||
| 387 | 387 | return -ENOENT; |
| 388 | 388 | data->num_sensors = err; |
| 389 | 389 | |
| 390 | − data->sensors = kzalloc(data->num_sensors * sizeof(*data->sensors), | |
| 390 | + data->sensors = kcalloc(data->num_sensors, sizeof(*data->sensors), | |
| 391 | 391 | GFP_KERNEL); |
| 392 | 392 | if (!data->sensors) |
| 393 | 393 | return -ENOMEM; |
| @@ -326,9 +326,9 @@ static int populate_attr_groups(struct platform_device *pdev) · 325 unmodified lines | ||
| 326 | 326 | of_node_put(opal); |
| 327 | 327 | |
| 328 | 328 | for (type = 0; type < MAX_SENSOR_TYPE; type++) { |
| 329 | − sensor_groups[type].group.attrs = devm_kzalloc(&pdev->dev, | |
| 330 | − sizeof(struct attribute *) * | |
| 331 | − (sensor_groups[type].attr_count + 1), | |
| 329 | + sensor_groups[type].group.attrs = devm_kcalloc(&pdev->dev, | |
| 330 | + sensor_groups[type].attr_count + 1, | |
| 331 | + sizeof(struct attribute *), | |
| 332 | 332 | GFP_KERNEL); |
| 333 | 333 | if (!sensor_groups[type].group.attrs) |
| 334 | 334 | return -ENOMEM; |
| @@ -409,7 +409,8 @@ static int create_device_attrs(struct platform_device *pdev) · 74 unmodified lines | ||
| 409 | 409 | int err = 0; |
| 410 | 410 | |
| 411 | 411 | opal = of_find_node_by_path("/ibm,opal/sensors"); |
| 412 | − sdata = devm_kzalloc(&pdev->dev, pdata->sensors_count * sizeof(*sdata), | |
| 412 | + sdata = devm_kcalloc(&pdev->dev, | |
| 413 | + pdata->sensors_count, sizeof(*sdata), | |
| 413 | 414 | GFP_KERNEL); |
| 414 | 415 | if (!sdata) { |
| 415 | 416 | err = -ENOMEM; |
| @@ -92,8 +92,8 @@ static int iio_hwmon_probe(struct platform_device *pdev) · 91 unmodified lines | ||
| 92 | 92 | while (st->channels[st->num_channels].indio_dev) |
| 93 | 93 | st->num_channels++; |
| 94 | 94 | |
| 95 | − st->attrs = devm_kzalloc(dev, | |
| 96 | − sizeof(*st->attrs) * (st->num_channels + 1), | |
| 95 | + st->attrs = devm_kcalloc(dev, | |
| 96 | + st->num_channels + 1, sizeof(*st->attrs), | |
| 97 | 97 | GFP_KERNEL); |
| 98 | 98 | if (st->attrs == NULL) { |
| 99 | 99 | ret = -ENOMEM; |
| @@ -426,12 +426,12 @@ nct6683_create_attr_group(struct device *dev, · 425 unmodified lines | ||
| 426 | 426 | if (group == NULL) |
| 427 | 427 | return ERR_PTR(-ENOMEM); |
| 428 | 428 | |
| 429 | − attrs = devm_kzalloc(dev, sizeof(*attrs) * (repeat * count + 1), | |
| 429 | + attrs = devm_kcalloc(dev, repeat * count + 1, sizeof(*attrs), | |
| 430 | 430 | GFP_KERNEL); |
| 431 | 431 | if (attrs == NULL) |
| 432 | 432 | return ERR_PTR(-ENOMEM); |
| 433 | 433 | |
| 434 | − su = devm_kzalloc(dev, sizeof(*su) * repeat * count, | |
| 434 | + su = devm_kzalloc(dev, array3_size(repeat, count, sizeof(*su)), | |
| 435 | 435 | GFP_KERNEL); |
| 436 | 436 | if (su == NULL) |
| 437 | 437 | return ERR_PTR(-ENOMEM); |
| @@ -1190,12 +1190,12 @@ nct6775_create_attr_group(struct device *dev, · 1189 unmodified lines | ||
| 1190 | 1190 | if (group == NULL) |
| 1191 | 1191 | return ERR_PTR(-ENOMEM); |
| 1192 | 1192 | |
| 1193 | − attrs = devm_kzalloc(dev, sizeof(*attrs) * (repeat * count + 1), | |
| 1193 | + attrs = devm_kcalloc(dev, repeat * count + 1, sizeof(*attrs), | |
| 1194 | 1194 | GFP_KERNEL); |
| 1195 | 1195 | if (attrs == NULL) |
| 1196 | 1196 | return ERR_PTR(-ENOMEM); |
| 1197 | 1197 | |
| 1198 | − su = devm_kzalloc(dev, sizeof(*su) * repeat * count, | |
| 1198 | + su = devm_kzalloc(dev, array3_size(repeat, count, sizeof(*su)), | |
| 1199 | 1199 | GFP_KERNEL); |
| 1200 | 1200 | if (su == NULL) |
| 1201 | 1201 | return ERR_PTR(-ENOMEM); |
| @@ -2176,8 +2176,8 @@ static int pmbus_init_debugfs(struct i2c_client *client, · 2175 unmodified lines | ||
| 2176 | 2176 | } |
| 2177 | 2177 | |
| 2178 | 2178 | /* Allocate the max possible entries we need. */ |
| 2179 | − entries = devm_kzalloc(data->dev, | |
| 2180 | − sizeof(*entries) * (data->info->pages * 10), | |
| 2179 | + entries = devm_kcalloc(data->dev, | |
| 2180 | + data->info->pages * 10, sizeof(*entries), | |
| 2181 | 2181 | GFP_KERNEL); |
| 2182 | 2182 | if (!entries) |
| 2183 | 2183 | return -ENOMEM; |
| @@ -454,8 +454,8 @@ static int ucd9000_init_debugfs(struct i2c_client *client, · 453 unmodified lines | ||
| 454 | 454 | */ |
| 455 | 455 | if (mid->driver_data == ucd9090 || mid->driver_data == ucd90160 || |
| 456 | 456 | mid->driver_data == ucd90910) { |
| 457 | − entries = devm_kzalloc(&client->dev, | |
| 458 | − sizeof(*entries) * UCD9000_GPI_COUNT, | |
| 457 | + entries = devm_kcalloc(&client->dev, | |
| 458 | + UCD9000_GPI_COUNT, sizeof(*entries), | |
| 459 | 459 | GFP_KERNEL); |
| 460 | 460 | if (!entries) |
| 461 | 461 | return -ENOMEM; |
| @@ -180,7 +180,7 @@ static int pwm_fan_of_get_cooling_data(struct device *dev, · 179 unmodified lines | ||
| 180 | 180 | } |
| 181 | 181 | |
| 182 | 182 | num = ret; |
| 183 | − ctx->pwm_fan_cooling_levels = devm_kzalloc(dev, num * sizeof(u32), | |
| 183 | + ctx->pwm_fan_cooling_levels = devm_kcalloc(dev, num, sizeof(u32), | |
| 184 | 184 | GFP_KERNEL); |
| 185 | 185 | if (!ctx->pwm_fan_cooling_levels) |
| 186 | 186 | return -ENOMEM; |
| @@ -683,8 +683,8 @@ static int etb_probe(struct amba_device *adev, const struct amba_id *id) · 682 unmodified lines | ||
| 683 | 683 | if (drvdata->buffer_depth & 0x80000000) |
| 684 | 684 | return -EINVAL; |
| 685 | 685 | |
| 686 | − drvdata->buf = devm_kzalloc(dev, | |
| 687 | − drvdata->buffer_depth * 4, GFP_KERNEL); | |
| 686 | + drvdata->buf = devm_kcalloc(dev, | |
| 687 | + drvdata->buffer_depth, 4, GFP_KERNEL); | |
| 688 | 688 | if (!drvdata->buf) |
| 689 | 689 | return -ENOMEM; |
| 690 | 690 | |
| @@ -71,21 +71,24 @@ static int of_coresight_alloc_memory(struct device *dev, · 70 unmodified lines | ||
| 71 | 71 | struct coresight_platform_data *pdata) |
| 72 | 72 | { |
| 73 | 73 | /* List of output port on this component */ |
| 74 | − pdata->outports = devm_kzalloc(dev, pdata->nr_outport * | |
| 74 | + pdata->outports = devm_kcalloc(dev, | |
| 75 | + pdata->nr_outport, | |
| 75 | 76 | sizeof(*pdata->outports), |
| 76 | 77 | GFP_KERNEL); |
| 77 | 78 | if (!pdata->outports) |
| 78 | 79 | return -ENOMEM; |
| 79 | 80 | |
| 80 | 81 | /* Children connected to this component via @outports */ |
| 81 | − pdata->child_names = devm_kzalloc(dev, pdata->nr_outport * | |
| 82 | + pdata->child_names = devm_kcalloc(dev, | |
| 83 | + pdata->nr_outport, | |
| 82 | 84 | sizeof(*pdata->child_names), |
| 83 | 85 | GFP_KERNEL); |
| 84 | 86 | if (!pdata->child_names) |
| 85 | 87 | return -ENOMEM; |
| 86 | 88 | |
| 87 | 89 | /* Port number on the child this component is connected to */ |
| 88 | − pdata->child_ports = devm_kzalloc(dev, pdata->nr_outport * | |
| 90 | + pdata->child_ports = devm_kcalloc(dev, | |
| 91 | + pdata->nr_outport, | |
| 89 | 92 | sizeof(*pdata->child_ports), |
| 90 | 93 | GFP_KERNEL); |
| 91 | 94 | if (!pdata->child_ports) |
| @@ -169,12 +169,12 @@ static int __init amd756_s4882_init(void) · 168 unmodified lines | ||
| 169 | 169 | |
| 170 | 170 | printk(KERN_INFO "Enabling SMBus multiplexing for Tyan S4882\n"); |
| 171 | 171 | /* Define the 5 virtual adapters and algorithms structures */ |
| 172 | − if (!(s4882_adapter = kzalloc(5 * sizeof(struct i2c_adapter), | |
| 172 | + if (!(s4882_adapter = kcalloc(5, sizeof(struct i2c_adapter), | |
| 173 | 173 | GFP_KERNEL))) { |
| 174 | 174 | error = -ENOMEM; |
| 175 | 175 | goto ERROR1; |
| 176 | 176 | } |
| 177 | − if (!(s4882_algo = kzalloc(5 * sizeof(struct i2c_algorithm), | |
| 177 | + if (!(s4882_algo = kcalloc(5, sizeof(struct i2c_algorithm), | |
| 178 | 178 | GFP_KERNEL))) { |
| 179 | 179 | error = -ENOMEM; |
| 180 | 180 | goto ERROR2; |
| @@ -164,12 +164,12 @@ static int __init nforce2_s4985_init(void) · 163 unmodified lines | ||
| 164 | 164 | |
| 165 | 165 | printk(KERN_INFO "Enabling SMBus multiplexing for Tyan S4985\n"); |
| 166 | 166 | /* Define the 5 virtual adapters and algorithms structures */ |
| 167 | − s4985_adapter = kzalloc(5 * sizeof(struct i2c_adapter), GFP_KERNEL); | |
| 167 | + s4985_adapter = kcalloc(5, sizeof(struct i2c_adapter), GFP_KERNEL); | |
| 168 | 168 | if (!s4985_adapter) { |
| 169 | 169 | error = -ENOMEM; |
| 170 | 170 | goto ERROR1; |
| 171 | 171 | } |
| 172 | − s4985_algo = kzalloc(5 * sizeof(struct i2c_algorithm), GFP_KERNEL); | |
| 172 | + s4985_algo = kcalloc(5, sizeof(struct i2c_algorithm), GFP_KERNEL); | |
| 173 | 173 | if (!s4985_algo) { |
| 174 | 174 | error = -ENOMEM; |
| 175 | 175 | goto ERROR2; |
| @@ -381,7 +381,7 @@ static int nforce2_probe(struct pci_dev *dev, const struct pci_device_id *id) · 380 unmodified lines | ||
| 381 | 381 | int res1, res2; |
| 382 | 382 | |
| 383 | 383 | /* we support 2 SMBus adapters */ |
| 384 | − smbuses = kzalloc(2 * sizeof(struct nforce2_smbus), GFP_KERNEL); | |
| 384 | + smbuses = kcalloc(2, sizeof(struct nforce2_smbus), GFP_KERNEL); | |
| 385 | 385 | if (!smbuses) |
| 386 | 386 | return -ENOMEM; |
| 387 | 387 | pci_set_drvdata(dev, smbuses); |
| @@ -1691,8 +1691,8 @@ static int qup_i2c_probe(struct platform_device *pdev) · 1690 unmodified lines | ||
| 1691 | 1691 | |
| 1692 | 1692 | qup->max_xfer_sg_len = (MX_BLOCKS << 1); |
| 1693 | 1693 | blocks = (MX_DMA_BLOCKS << 1) + 1; |
| 1694 | − qup->btx.sg = devm_kzalloc(&pdev->dev, | |
| 1695 | − sizeof(*qup->btx.sg) * blocks, | |
| 1694 | + qup->btx.sg = devm_kcalloc(&pdev->dev, | |
| 1695 | + blocks, sizeof(*qup->btx.sg), | |
| 1696 | 1696 | GFP_KERNEL); |
| 1697 | 1697 | if (!qup->btx.sg) { |
| 1698 | 1698 | ret = -ENOMEM; |
| @@ -1700,8 +1700,8 @@ static int qup_i2c_probe(struct platform_device *pdev) · 1 unmodified line | ||
| 1700 | 1700 | } |
| 1701 | 1701 | sg_init_table(qup->btx.sg, blocks); |
| 1702 | 1702 | |
| 1703 | − qup->brx.sg = devm_kzalloc(&pdev->dev, | |
| 1704 | − sizeof(*qup->brx.sg) * blocks, | |
| 1703 | + qup->brx.sg = devm_kcalloc(&pdev->dev, | |
| 1704 | + blocks, sizeof(*qup->brx.sg), | |
| 1705 | 1705 | GFP_KERNEL); |
| 1706 | 1706 | if (!qup->brx.sg) { |
| 1707 | 1707 | ret = -ENOMEM; |
| @@ -244,7 +244,7 @@ static noinline int i2cdev_ioctl_rdwr(struct i2c_client *client, · 243 unmodified lines | ||
| 244 | 244 | u8 __user **data_ptrs; |
| 245 | 245 | int i, res; |
| 246 | 246 | |
| 247 | − data_ptrs = kmalloc(nmsgs * sizeof(u8 __user *), GFP_KERNEL); | |
| 247 | + data_ptrs = kmalloc_array(nmsgs, sizeof(u8 __user *), GFP_KERNEL); | |
| 248 | 248 | if (data_ptrs == NULL) { |
| 249 | 249 | kfree(msgs); |
| 250 | 250 | return -ENOMEM; |
| @@ -338,8 +338,9 @@ static int __init i2c_stub_allocate_banks(int i) · 337 unmodified lines | ||
| 338 | 338 | chip->bank_mask >>= 1; |
| 339 | 339 | } |
| 340 | 340 | |
| 341 | − chip->bank_words = kzalloc(chip->bank_mask * chip->bank_size * | |
| 342 | − sizeof(u16), GFP_KERNEL); | |
| 341 | + chip->bank_words = kcalloc(chip->bank_mask * chip->bank_size, | |
| 342 | + sizeof(u16), | |
| 343 | + GFP_KERNEL); | |
| 343 | 344 | if (!chip->bank_words) |
| 344 | 345 | return -ENOMEM; |
| 345 | 346 | |
| @@ -88,8 +88,8 @@ static int i2c_mux_gpio_probe_dt(struct gpiomux *mux, · 87 unmodified lines | ||
| 88 | 88 | |
| 89 | 89 | mux->data.n_values = of_get_child_count(np); |
| 90 | 90 | |
| 91 | − values = devm_kzalloc(&pdev->dev, | |
| 92 | − sizeof(*mux->data.values) * mux->data.n_values, | |
| 91 | + values = devm_kcalloc(&pdev->dev, | |
| 92 | + mux->data.n_values, sizeof(*mux->data.values), | |
| 93 | 93 | GFP_KERNEL); |
| 94 | 94 | if (!values) { |
| 95 | 95 | dev_err(&pdev->dev, "Cannot allocate values array"); |
| @@ -111,8 +111,9 @@ static int i2c_mux_gpio_probe_dt(struct gpiomux *mux, · 15 unmodified lines | ||
| 111 | 111 | return -EINVAL; |
| 112 | 112 | } |
| 113 | 113 | |
| 114 | − gpios = devm_kzalloc(&pdev->dev, | |
| 115 | − sizeof(*mux->data.gpios) * mux->data.n_gpios, GFP_KERNEL); | |
| 114 | + gpios = devm_kcalloc(&pdev->dev, | |
| 115 | + mux->data.n_gpios, sizeof(*mux->data.gpios), | |
| 116 | + GFP_KERNEL); | |
| 116 | 117 | if (!gpios) { |
| 117 | 118 | dev_err(&pdev->dev, "Cannot allocate gpios array"); |
| 118 | 119 | return -ENOMEM; |
| @@ -124,8 +124,8 @@ static int i2c_mux_reg_probe_dt(struct regmux *mux, · 123 unmodified lines | ||
| 124 | 124 | } |
| 125 | 125 | mux->data.write_only = of_property_read_bool(np, "write-only"); |
| 126 | 126 | |
| 127 | − values = devm_kzalloc(&pdev->dev, | |
| 128 | − sizeof(*mux->data.values) * mux->data.n_values, | |
| 127 | + values = devm_kcalloc(&pdev->dev, | |
| 128 | + mux->data.n_values, sizeof(*mux->data.values), | |
| 129 | 129 | GFP_KERNEL); |
| 130 | 130 | if (!values) { |
| 131 | 131 | dev_err(&pdev->dev, "Cannot allocate values array"); |
| @@ -1455,7 +1455,7 @@ static int hpt366_init_one(struct pci_dev *dev, const struct pci_device_id *id) · 1454 unmodified lines | ||
| 1455 | 1455 | if (info == &hpt36x || info == &hpt374) |
| 1456 | 1456 | dev2 = pci_get_slot(dev->bus, dev->devfn + 1); |
| 1457 | 1457 | |
| 1458 | − dyn_info = kzalloc(sizeof(*dyn_info) * (dev2 ? 2 : 1), GFP_KERNEL); | |
| 1458 | + dyn_info = kcalloc(dev2 ? 2 : 1, sizeof(*dyn_info), GFP_KERNEL); | |
| 1459 | 1459 | if (dyn_info == NULL) { |
| 1460 | 1460 | printk(KERN_ERR "%s %s: out of memory!\n", |
| 1461 | 1461 | d.name, pci_name(dev)); |
| @@ -985,8 +985,9 @@ static int hwif_init(ide_hwif_t *hwif) · 984 unmodified lines | ||
| 985 | 985 | if (!hwif->sg_max_nents) |
| 986 | 986 | hwif->sg_max_nents = PRD_ENTRIES; |
| 987 | 987 | |
| 988 | − hwif->sg_table = kmalloc(sizeof(struct scatterlist)*hwif->sg_max_nents, | |
| 989 | − GFP_KERNEL); | |
| 988 | + hwif->sg_table = kmalloc_array(hwif->sg_max_nents, | |
| 989 | + sizeof(struct scatterlist), | |
| 990 | + GFP_KERNEL); | |
| 990 | 991 | if (!hwif->sg_table) { |
| 991 | 992 | printk(KERN_ERR "%s: unable to allocate SG table.\n", hwif->name); |
| 992 | 993 | goto out; |
| @@ -652,7 +652,7 @@ static int it821x_init_one(struct pci_dev *dev, const struct pci_device_id *id) · 651 unmodified lines | ||
| 652 | 652 | struct it821x_dev *itdevs; |
| 653 | 653 | int rc; |
| 654 | 654 | |
| 655 | − itdevs = kzalloc(2 * sizeof(*itdevs), GFP_KERNEL); | |
| 655 | + itdevs = kcalloc(2, sizeof(*itdevs), GFP_KERNEL); | |
| 656 | 656 | if (itdevs == NULL) { |
| 657 | 657 | printk(KERN_ERR DRV_NAME " %s: out of memory\n", pci_name(dev)); |
| 658 | 658 | return -ENOMEM; |
| @@ -624,8 +624,8 @@ static int at91_adc_trigger_init(struct iio_dev *idev) · 623 unmodified lines | ||
| 624 | 624 | struct at91_adc_state *st = iio_priv(idev); |
| 625 | 625 | int i, ret; |
| 626 | 626 | |
| 627 | − st->trig = devm_kzalloc(&idev->dev, | |
| 628 | − st->trigger_number * sizeof(*st->trig), | |
| 627 | + st->trig = devm_kcalloc(&idev->dev, | |
| 628 | + st->trigger_number, sizeof(*st->trig), | |
| 629 | 629 | GFP_KERNEL); |
| 630 | 630 | |
| 631 | 631 | if (st->trig == NULL) { |
| @@ -908,7 +908,8 @@ static int at91_adc_probe_dt(struct at91_adc_state *st, · 276 unmodified lines | ||
| 908 | 908 | st->registers = &st->caps->registers; |
| 909 | 909 | st->num_channels = st->caps->num_channels; |
| 910 | 910 | st->trigger_number = of_get_child_count(node); |
| 911 | − st->trigger_list = devm_kzalloc(&idev->dev, st->trigger_number * | |
| 911 | + st->trigger_list = devm_kcalloc(&idev->dev, | |
| 912 | + st->trigger_number, | |
| 912 | 913 | sizeof(struct at91_adc_trigger), |
| 913 | 914 | GFP_KERNEL); |
| 914 | 915 | if (!st->trigger_list) { |
| @@ -422,8 +422,8 @@ static int max1027_probe(struct spi_device *spi) · 421 unmodified lines | ||
| 422 | 422 | indio_dev->num_channels = st->info->num_channels; |
| 423 | 423 | indio_dev->available_scan_masks = st->info->available_scan_masks; |
| 424 | 424 | |
| 425 | − st->buffer = devm_kmalloc(&indio_dev->dev, | |
| 426 | − indio_dev->num_channels * 2, | |
| 425 | + st->buffer = devm_kmalloc_array(&indio_dev->dev, | |
| 426 | + indio_dev->num_channels, 2, | |
| 427 | 427 | GFP_KERNEL); |
| 428 | 428 | if (st->buffer == NULL) { |
| 429 | 429 | dev_err(&indio_dev->dev, "Can't allocate buffer\n"); |
| @@ -1453,8 +1453,10 @@ static int max1363_alloc_scan_masks(struct iio_dev *indio_dev) · 1452 unmodified lines | ||
| 1453 | 1453 | int i; |
| 1454 | 1454 | |
| 1455 | 1455 | masks = devm_kzalloc(&indio_dev->dev, |
| 1456 | − BITS_TO_LONGS(MAX1363_MAX_CHANNELS) * sizeof(long) * | |
| 1457 | − (st->chip_info->num_modes + 1), GFP_KERNEL); | |
| 1456 | + array3_size(BITS_TO_LONGS(MAX1363_MAX_CHANNELS), | |
| 1457 | + sizeof(long), | |
| 1458 | + st->chip_info->num_modes + 1), | |
| 1459 | + GFP_KERNEL); | |
| 1458 | 1460 | if (!masks) |
| 1459 | 1461 | return -ENOMEM; |
| 1460 | 1462 | |
| @@ -898,9 +898,10 @@ static int twl6030_gpadc_probe(struct platform_device *pdev) · 897 unmodified lines | ||
| 898 | 898 | |
| 899 | 899 | gpadc = iio_priv(indio_dev); |
| 900 | 900 | |
| 901 | − gpadc->twl6030_cal_tbl = devm_kzalloc(dev, | |
| 902 | − sizeof(*gpadc->twl6030_cal_tbl) * | |
| 903 | − pdata->nchannels, GFP_KERNEL); | |
| 901 | + gpadc->twl6030_cal_tbl = devm_kcalloc(dev, | |
| 902 | + pdata->nchannels, | |
| 903 | + sizeof(*gpadc->twl6030_cal_tbl), | |
| 904 | + GFP_KERNEL); | |
| 904 | 905 | if (!gpadc->twl6030_cal_tbl) |
| 905 | 906 | return -ENOMEM; |
| 906 | 907 | |
| @@ -536,8 +536,9 @@ static int ad5592r_alloc_channels(struct ad5592r_state *st) · 535 unmodified lines | ||
| 536 | 536 | st->channel_offstate[reg] = tmp; |
| 537 | 537 | } |
| 538 | 538 | |
| 539 | − channels = devm_kzalloc(st->dev, | |
| 540 | − (1 + 2 * num_channels) * sizeof(*channels), GFP_KERNEL); | |
| 539 | + channels = devm_kcalloc(st->dev, | |
| 540 | + 1 + 2 * num_channels, sizeof(*channels), | |
| 541 | + GFP_KERNEL); | |
| 541 | 542 | if (!channels) |
| 542 | 543 | return -ENOMEM; |
| 543 | 544 | |
| @@ -38,7 +38,7 @@ int adis_update_scan_mode(struct iio_dev *indio_dev, · 37 unmodified lines | ||
| 38 | 38 | if (!adis->xfer) |
| 39 | 39 | return -ENOMEM; |
| 40 | 40 | |
| 41 | − adis->buffer = kzalloc(indio_dev->scan_bytes * 2, GFP_KERNEL); | |
| 41 | + adis->buffer = kcalloc(indio_dev->scan_bytes, 2, GFP_KERNEL); | |
| 42 | 42 | if (!adis->buffer) |
| 43 | 43 | return -ENOMEM; |
| 44 | 44 | |
| @@ -436,7 +436,7 @@ struct iio_channel *iio_channel_get_all(struct device *dev) · 435 unmodified lines | ||
| 436 | 436 | } |
| 437 | 437 | |
| 438 | 438 | /* NULL terminated array to save passing size */ |
| 439 | − chans = kzalloc(sizeof(*chans)*(nummaps + 1), GFP_KERNEL); | |
| 439 | + chans = kcalloc(nummaps + 1, sizeof(*chans), GFP_KERNEL); | |
| 440 | 440 | if (chans == NULL) { |
| 441 | 441 | ret = -ENOMEM; |
| 442 | 442 | goto error_ret; |
| @@ -281,9 +281,10 @@ static int mux_configure_channel(struct device *dev, struct mux *mux, · 280 unmodified lines | ||
| 281 | 281 | if (!page) |
| 282 | 282 | return -ENOMEM; |
| 283 | 283 | } |
| 284 | − child->ext_info_cache = devm_kzalloc(dev, | |
| 285 | − sizeof(*child->ext_info_cache) * | |
| 286 | − num_ext_info, GFP_KERNEL); | |
| 284 | + child->ext_info_cache = devm_kcalloc(dev, | |
| 285 | + num_ext_info, | |
| 286 | + sizeof(*child->ext_info_cache), | |
| 287 | + GFP_KERNEL); | |
| 287 | 288 | if (!child->ext_info_cache) |
| 288 | 289 | return -ENOMEM; |
| 289 | 290 | |
| @@ -1245,8 +1245,9 @@ int ib_cache_setup_one(struct ib_device *device) · 1244 unmodified lines | ||
| 1245 | 1245 | rwlock_init(&device->cache.lock); |
| 1246 | 1246 | |
| 1247 | 1247 | device->cache.ports = |
| 1248 | − kzalloc(sizeof(*device->cache.ports) * | |
| 1249 | − (rdma_end_port(device) - rdma_start_port(device) + 1), GFP_KERNEL); | |
| 1248 | + kcalloc(rdma_end_port(device) - rdma_start_port(device) + 1, | |
| 1249 | + sizeof(*device->cache.ports), | |
| 1250 | + GFP_KERNEL); | |
| 1250 | 1251 | if (!device->cache.ports) |
| 1251 | 1252 | return -ENOMEM; |
| 1252 | 1253 | |
| @@ -1855,8 +1855,8 @@ static struct rdma_id_private *cma_new_conn_id(struct rdma_cm_id *listen_id, · 1854 unmodified lines | ||
| 1855 | 1855 | |
| 1856 | 1856 | rt = &id->route; |
| 1857 | 1857 | rt->num_paths = ib_event->param.req_rcvd.alternate_path ? 2 : 1; |
| 1858 | − rt->path_rec = kmalloc(sizeof *rt->path_rec * rt->num_paths, | |
| 1859 | − GFP_KERNEL); | |
| 1858 | + rt->path_rec = kmalloc_array(rt->num_paths, sizeof(*rt->path_rec), | |
| 1859 | + GFP_KERNEL); | |
| 1860 | 1860 | if (!rt->path_rec) |
| 1861 | 1861 | goto err; |
| 1862 | 1862 | |
| @@ -336,8 +336,8 @@ static int read_port_immutable(struct ib_device *device) · 335 unmodified lines | ||
| 336 | 336 | * Therefore port_immutable is declared as a 1 based array with |
| 337 | 337 | * potential empty slots at the beginning. |
| 338 | 338 | */ |
| 339 | − device->port_immutable = kzalloc(sizeof(*device->port_immutable) | |
| 340 | − * (end_port + 1), | |
| 339 | + device->port_immutable = kcalloc(end_port + 1, | |
| 340 | + sizeof(*device->port_immutable), | |
| 341 | 341 | GFP_KERNEL); |
| 342 | 342 | if (!device->port_immutable) |
| 343 | 343 | return -ENOMEM; |
| @@ -235,8 +235,9 @@ struct ib_fmr_pool *ib_create_fmr_pool(struct ib_pd *pd, · 234 unmodified lines | ||
| 235 | 235 | |
| 236 | 236 | if (params->cache) { |
| 237 | 237 | pool->cache_bucket = |
| 238 | − kmalloc(IB_FMR_HASH_SIZE * sizeof *pool->cache_bucket, | |
| 239 | − GFP_KERNEL); | |
| 238 | + kmalloc_array(IB_FMR_HASH_SIZE, | |
| 239 | + sizeof(*pool->cache_bucket), | |
| 240 | + GFP_KERNEL); | |
| 240 | 241 | if (!pool->cache_bucket) { |
| 241 | 242 | ret = -ENOMEM; |
| 242 | 243 | goto out_free_pool; |
| @@ -56,14 +56,16 @@ int iwpm_init(u8 nl_client) · 55 unmodified lines | ||
| 56 | 56 | int ret = 0; |
| 57 | 57 | mutex_lock(&iwpm_admin_lock); |
| 58 | 58 | if (atomic_read(&iwpm_admin.refcount) == 0) { |
| 59 | − iwpm_hash_bucket = kzalloc(IWPM_MAPINFO_HASH_SIZE * | |
| 60 | − sizeof(struct hlist_head), GFP_KERNEL); | |
| 59 | + iwpm_hash_bucket = kcalloc(IWPM_MAPINFO_HASH_SIZE, | |
| 60 | + sizeof(struct hlist_head), | |
| 61 | + GFP_KERNEL); | |
| 61 | 62 | if (!iwpm_hash_bucket) { |
| 62 | 63 | ret = -ENOMEM; |
| 63 | 64 | goto init_exit; |
| 64 | 65 | } |
| 65 | − iwpm_reminfo_bucket = kzalloc(IWPM_REMINFO_HASH_SIZE * | |
| 66 | − sizeof(struct hlist_head), GFP_KERNEL); | |
| 66 | + iwpm_reminfo_bucket = kcalloc(IWPM_REMINFO_HASH_SIZE, | |
| 67 | + sizeof(struct hlist_head), | |
| 68 | + GFP_KERNEL); | |
| 67 | 69 | if (!iwpm_reminfo_bucket) { |
| 68 | 70 | kfree(iwpm_hash_bucket); |
| 69 | 71 | ret = -ENOMEM; |
| @@ -285,13 +285,15 @@ struct ib_umem *ib_alloc_odp_umem(struct ib_ucontext *context, · 284 unmodified lines | ||
| 285 | 285 | mutex_init(&odp_data->umem_mutex); |
| 286 | 286 | init_completion(&odp_data->notifier_completion); |
| 287 | 287 | |
| 288 | − odp_data->page_list = vzalloc(pages * sizeof(*odp_data->page_list)); | |
| 288 | + odp_data->page_list = | |
| 289 | + vzalloc(array_size(pages, sizeof(*odp_data->page_list))); | |
| 289 | 290 | if (!odp_data->page_list) { |
| 290 | 291 | ret = -ENOMEM; |
| 291 | 292 | goto out_odp_data; |
| 292 | 293 | } |
| 293 | 294 | |
| 294 | − odp_data->dma_list = vzalloc(pages * sizeof(*odp_data->dma_list)); | |
| 295 | + odp_data->dma_list = | |
| 296 | + vzalloc(array_size(pages, sizeof(*odp_data->dma_list))); | |
| 295 | 297 | if (!odp_data->dma_list) { |
| 296 | 298 | ret = -ENOMEM; |
| 297 | 299 | goto out_page_list; |
| @@ -371,15 +373,17 @@ int ib_umem_odp_get(struct ib_ucontext *context, struct ib_umem *umem, · 73 unmodified lines | ||
| 371 | 373 | init_completion(&umem->odp_data->notifier_completion); |
| 372 | 374 | |
| 373 | 375 | if (ib_umem_num_pages(umem)) { |
| 374 | − umem->odp_data->page_list = vzalloc(ib_umem_num_pages(umem) * | |
| 375 | − sizeof(*umem->odp_data->page_list)); | |
| 376 | + umem->odp_data->page_list = | |
| 377 | + vzalloc(array_size(sizeof(*umem->odp_data->page_list), | |
| 378 | + ib_umem_num_pages(umem))); | |
| 376 | 379 | if (!umem->odp_data->page_list) { |
| 377 | 380 | ret_val = -ENOMEM; |
| 378 | 381 | goto out_odp_data; |
| 379 | 382 | } |
| 380 | 383 | |
| 381 | − umem->odp_data->dma_list = vzalloc(ib_umem_num_pages(umem) * | |
| 382 | − sizeof(*umem->odp_data->dma_list)); | |
| 384 | + umem->odp_data->dma_list = | |
| 385 | + vzalloc(array_size(sizeof(*umem->odp_data->dma_list), | |
| 386 | + ib_umem_num_pages(umem))); | |
| 383 | 387 | if (!umem->odp_data->dma_list) { |
| 384 | 388 | ret_val = -ENOMEM; |
| 385 | 389 | goto out_page_list; |
| @@ -3559,8 +3559,8 @@ int ib_uverbs_ex_create_flow(struct ib_uverbs_file *file, · 3558 unmodified lines | ||
| 3559 | 3559 | goto err_uobj; |
| 3560 | 3560 | } |
| 3561 | 3561 | |
| 3562 | − flow_attr = kzalloc(sizeof(*flow_attr) + cmd.flow_attr.num_of_specs * | |
| 3563 | − sizeof(union ib_flow_spec), GFP_KERNEL); | |
| 3562 | + flow_attr = kzalloc(struct_size(flow_attr, flows, | |
| 3563 | + cmd.flow_attr.num_of_specs), GFP_KERNEL); | |
| 3564 | 3564 | if (!flow_attr) { |
| 3565 | 3565 | err = -ENOMEM; |
| 3566 | 3566 | goto err_put; |
| @@ -279,7 +279,7 @@ int cxio_create_qp(struct cxio_rdev *rdev_p, u32 kernel_domain, · 278 unmodified lines | ||
| 279 | 279 | if (!wq->qpid) |
| 280 | 280 | return -ENOMEM; |
| 281 | 281 | |
| 282 | − wq->rq = kzalloc(depth * sizeof(struct t3_swrq), GFP_KERNEL); | |
| 282 | + wq->rq = kcalloc(depth, sizeof(struct t3_swrq), GFP_KERNEL); | |
| 283 | 283 | if (!wq->rq) |
| 284 | 284 | goto err1; |
| 285 | 285 | |
| @@ -287,7 +287,7 @@ int cxio_create_qp(struct cxio_rdev *rdev_p, u32 kernel_domain, · 1 unmodified line | ||
| 287 | 287 | if (!wq->rq_addr) |
| 288 | 288 | goto err2; |
| 289 | 289 | |
| 290 | − wq->sq = kzalloc(depth * sizeof(struct t3_swsq), GFP_KERNEL); | |
| 290 | + wq->sq = kcalloc(depth, sizeof(struct t3_swsq), GFP_KERNEL); | |
| 291 | 291 | if (!wq->sq) |
| 292 | 292 | goto err3; |
| 293 | 293 | |
| @@ -859,8 +859,9 @@ static int c4iw_rdev_open(struct c4iw_rdev *rdev) · 858 unmodified lines | ||
| 859 | 859 | rdev->status_page->cq_size = rdev->lldi.vr->cq.size; |
| 860 | 860 | |
| 861 | 861 | if (c4iw_wr_log) { |
| 862 | − rdev->wr_log = kzalloc((1 << c4iw_wr_log_size_order) * | |
| 863 | − sizeof(*rdev->wr_log), GFP_KERNEL); | |
| 862 | + rdev->wr_log = kcalloc(1 << c4iw_wr_log_size_order, | |
| 863 | + sizeof(*rdev->wr_log), | |
| 864 | + GFP_KERNEL); | |
| 864 | 865 | if (rdev->wr_log) { |
| 865 | 866 | rdev->wr_log_size = 1 << c4iw_wr_log_size_order; |
| 866 | 867 | atomic_set(&rdev->wr_log_idx, 0); |
| @@ -1445,7 +1446,7 @@ static void recover_queues(struct uld_ctx *ctx) · 578 unmodified lines | ||
| 1445 | 1446 | ctx->dev->db_state = RECOVERY; |
| 1446 | 1447 | idr_for_each(&ctx->dev->qpidr, count_qps, &count); |
| 1447 | 1448 | |
| 1448 | − qp_list.qps = kzalloc(count * sizeof *qp_list.qps, GFP_ATOMIC); | |
| 1449 | + qp_list.qps = kcalloc(count, sizeof(*qp_list.qps), GFP_ATOMIC); | |
| 1449 | 1450 | if (!qp_list.qps) { |
| 1450 | 1451 | spin_unlock_irq(&ctx->dev->lock); |
| 1451 | 1452 | return; |
| @@ -92,8 +92,8 @@ int c4iw_id_table_alloc(struct c4iw_id_table *alloc, u32 start, u32 num, · 91 unmodified lines | ||
| 92 | 92 | alloc->last = 0; |
| 93 | 93 | alloc->max = num; |
| 94 | 94 | spin_lock_init(&alloc->lock); |
| 95 | − alloc->table = kmalloc(BITS_TO_LONGS(num) * sizeof(long), | |
| 96 | − GFP_KERNEL); | |
| 95 | + alloc->table = kmalloc_array(BITS_TO_LONGS(num), sizeof(long), | |
| 96 | + GFP_KERNEL); | |
| 97 | 97 | if (!alloc->table) |
| 98 | 98 | return -ENOMEM; |
| 99 | 99 | |
| @@ -216,15 +216,15 @@ static int create_qp(struct c4iw_rdev *rdev, struct t4_wq *wq, · 215 unmodified lines | ||
| 216 | 216 | } |
| 217 | 217 | |
| 218 | 218 | if (!user) { |
| 219 | − wq->sq.sw_sq = kzalloc(wq->sq.size * sizeof *wq->sq.sw_sq, | |
| 220 | − GFP_KERNEL); | |
| 219 | + wq->sq.sw_sq = kcalloc(wq->sq.size, sizeof(*wq->sq.sw_sq), | |
| 220 | + GFP_KERNEL); | |
| 221 | 221 | if (!wq->sq.sw_sq) { |
| 222 | 222 | ret = -ENOMEM; |
| 223 | 223 | goto free_rq_qid; |
| 224 | 224 | } |
| 225 | 225 | |
| 226 | − wq->rq.sw_rq = kzalloc(wq->rq.size * sizeof *wq->rq.sw_rq, | |
| 227 | − GFP_KERNEL); | |
| 226 | + wq->rq.sw_rq = kcalloc(wq->rq.size, sizeof(*wq->rq.sw_rq), | |
| 227 | + GFP_KERNEL); | |
| 228 | 228 | if (!wq->rq.sw_rq) { |
| 229 | 229 | ret = -ENOMEM; |
| 230 | 230 | goto free_sw_sq; |
| @@ -1461,7 +1461,8 @@ int sdma_init(struct hfi1_devdata *dd, u8 port) · 1460 unmodified lines | ||
| 1461 | 1461 | if (!sde->descq) |
| 1462 | 1462 | goto bail; |
| 1463 | 1463 | sde->tx_ring = |
| 1464 | − kvzalloc_node(sizeof(struct sdma_txreq *) * descq_cnt, | |
| 1464 | + kvzalloc_node(array_size(descq_cnt, | |
| 1465 | + sizeof(struct sdma_txreq *)), | |
| 1465 | 1466 | GFP_KERNEL, dd->node); |
| 1466 | 1467 | if (!sde->tx_ring) |
| 1467 | 1468 | goto bail; |
| @@ -3177,7 +3177,7 @@ static int hns_roce_v2_modify_qp(struct ib_qp *ibqp, · 3176 unmodified lines | ||
| 3177 | 3177 | struct device *dev = hr_dev->dev; |
| 3178 | 3178 | int ret = -EINVAL; |
| 3179 | 3179 | |
| 3180 | − context = kzalloc(2 * sizeof(*context), GFP_KERNEL); | |
| 3180 | + context = kcalloc(2, sizeof(*context), GFP_KERNEL); | |
| 3181 | 3181 | if (!context) |
| 3182 | 3182 | return -ENOMEM; |
| 3183 | 3183 | |
| @@ -144,7 +144,7 @@ static int hns_roce_buddy_init(struct hns_roce_buddy *buddy, int max_order) · 143 unmodified lines | ||
| 144 | 144 | buddy->bits[i] = kcalloc(s, sizeof(long), GFP_KERNEL | |
| 145 | 145 | __GFP_NOWARN); |
| 146 | 146 | if (!buddy->bits[i]) { |
| 147 | − buddy->bits[i] = vzalloc(s * sizeof(long)); | |
| 147 | + buddy->bits[i] = vzalloc(array_size(s, sizeof(long))); | |
| 148 | 148 | if (!buddy->bits[i]) |
| 149 | 149 | goto err_out_free; |
| 150 | 150 | } |
| @@ -1613,7 +1613,8 @@ static int mlx4_ib_alloc_pv_bufs(struct mlx4_ib_demux_pv_ctx *ctx, · 1612 unmodified lines | ||
| 1613 | 1613 | |
| 1614 | 1614 | tun_qp = &ctx->qp[qp_type]; |
| 1615 | 1615 | |
| 1616 | − tun_qp->ring = kzalloc(sizeof (struct mlx4_ib_buf) * MLX4_NUM_TUNNEL_BUFS, | |
| 1616 | + tun_qp->ring = kcalloc(MLX4_NUM_TUNNEL_BUFS, | |
| 1617 | + sizeof(struct mlx4_ib_buf), | |
| 1617 | 1618 | GFP_KERNEL); |
| 1618 | 1619 | if (!tun_qp->ring) |
| 1619 | 1620 | return -ENOMEM; |
| @@ -302,7 +302,8 @@ static int mlx4_ib_add_gid(const union ib_gid *gid, · 301 unmodified lines | ||
| 302 | 302 | ctx->refcount++; |
| 303 | 303 | } |
| 304 | 304 | if (!ret && hw_update) { |
| 305 | − gids = kmalloc(sizeof(*gids) * MLX4_MAX_PORT_GIDS, GFP_ATOMIC); | |
| 305 | + gids = kmalloc_array(MLX4_MAX_PORT_GIDS, sizeof(*gids), | |
| 306 | + GFP_ATOMIC); | |
| 306 | 307 | if (!gids) { |
| 307 | 308 | ret = -ENOMEM; |
| 308 | 309 | } else { |
| @@ -355,7 +356,8 @@ static int mlx4_ib_del_gid(const struct ib_gid_attr *attr, void **context) · 46 unmodified lines | ||
| 355 | 356 | if (!ret && hw_update) { |
| 356 | 357 | int i; |
| 357 | 358 | |
| 358 | − gids = kmalloc(sizeof(*gids) * MLX4_MAX_PORT_GIDS, GFP_ATOMIC); | |
| 359 | + gids = kmalloc_array(MLX4_MAX_PORT_GIDS, sizeof(*gids), | |
| 360 | + GFP_ATOMIC); | |
| 359 | 361 | if (!gids) { |
| 360 | 362 | ret = -ENOMEM; |
| 361 | 363 | } else { |
| @@ -2872,9 +2874,9 @@ static void *mlx4_ib_add(struct mlx4_dev *dev) · 2510 unmodified lines | ||
| 2872 | 2874 | goto err_counter; |
| 2873 | 2875 | |
| 2874 | 2876 | ibdev->ib_uc_qpns_bitmap = |
| 2875 | − kmalloc(BITS_TO_LONGS(ibdev->steer_qpn_count) * | |
| 2876 | − sizeof(long), | |
| 2877 | − GFP_KERNEL); | |
| 2877 | + kmalloc_array(BITS_TO_LONGS(ibdev->steer_qpn_count), | |
| 2878 | + sizeof(long), | |
| 2879 | + GFP_KERNEL); | |
| 2878 | 2880 | if (!ibdev->ib_uc_qpns_bitmap) |
| 2879 | 2881 | goto err_steer_qp_release; |
| 2880 | 2882 | |
| @@ -573,8 +573,8 @@ static int alloc_proxy_bufs(struct ib_device *dev, struct mlx4_ib_qp *qp) · 572 unmodified lines | ||
| 573 | 573 | int i; |
| 574 | 574 | |
| 575 | 575 | qp->sqp_proxy_rcv = |
| 576 | − kmalloc(sizeof (struct mlx4_ib_buf) * qp->rq.wqe_cnt, | |
| 577 | − GFP_KERNEL); | |
| 576 | + kmalloc_array(qp->rq.wqe_cnt, sizeof(struct mlx4_ib_buf), | |
| 577 | + GFP_KERNEL); | |
| 578 | 578 | if (!qp->sqp_proxy_rcv) |
| 579 | 579 | return -ENOMEM; |
| 580 | 580 | for (i = 0; i < qp->rq.wqe_cnt; i++) { |
| @@ -127,7 +127,7 @@ static int create_srq_user(struct ib_pd *pd, struct mlx5_ib_srq *srq, · 126 unmodified lines | ||
| 127 | 127 | goto err_umem; |
| 128 | 128 | } |
| 129 | 129 | |
| 130 | − in->pas = kvzalloc(sizeof(*in->pas) * ncont, GFP_KERNEL); | |
| 130 | + in->pas = kvcalloc(ncont, sizeof(*in->pas), GFP_KERNEL); | |
| 131 | 131 | if (!in->pas) { |
| 132 | 132 | err = -ENOMEM; |
| 133 | 133 | goto err_umem; |
| @@ -189,7 +189,7 @@ static int create_srq_kernel(struct mlx5_ib_dev *dev, struct mlx5_ib_srq *srq, · 55 unmodified lines | ||
| 189 | 189 | } |
| 190 | 190 | |
| 191 | 191 | mlx5_ib_dbg(dev, "srq->buf.page_shift = %d\n", srq->buf.page_shift); |
| 192 | − in->pas = kvzalloc(sizeof(*in->pas) * srq->buf.npages, GFP_KERNEL); | |
| 192 | + in->pas = kvcalloc(srq->buf.npages, sizeof(*in->pas), GFP_KERNEL); | |
| 193 | 193 | if (!in->pas) { |
| 194 | 194 | err = -ENOMEM; |
| 195 | 195 | goto err_buf; |
| @@ -90,8 +90,8 @@ int mthca_alloc_init(struct mthca_alloc *alloc, u32 num, u32 mask, · 89 unmodified lines | ||
| 90 | 90 | alloc->max = num; |
| 91 | 91 | alloc->mask = mask; |
| 92 | 92 | spin_lock_init(&alloc->lock); |
| 93 | − alloc->table = kmalloc(BITS_TO_LONGS(num) * sizeof (long), | |
| 94 | − GFP_KERNEL); | |
| 93 | + alloc->table = kmalloc_array(BITS_TO_LONGS(num), sizeof(long), | |
| 94 | + GFP_KERNEL); | |
| 95 | 95 | if (!alloc->table) |
| 96 | 96 | return -ENOMEM; |
| 97 | 97 | |
| @@ -162,7 +162,8 @@ int mthca_array_init(struct mthca_array *array, int nent) · 64 unmodified lines | ||
| 162 | 162 | int npage = (nent * sizeof (void *) + PAGE_SIZE - 1) / PAGE_SIZE; |
| 163 | 163 | int i; |
| 164 | 164 | |
| 165 | − array->page_list = kmalloc(npage * sizeof *array->page_list, GFP_KERNEL); | |
| 165 | + array->page_list = kmalloc_array(npage, sizeof(*array->page_list), | |
| 166 | + GFP_KERNEL); | |
| 166 | 167 | if (!array->page_list) |
| 167 | 168 | return -ENOMEM; |
| 168 | 169 | |
| @@ -220,7 +221,8 @@ int mthca_buf_alloc(struct mthca_dev *dev, int size, int max_direct, · 51 unmodified lines | ||
| 220 | 221 | npages *= 2; |
| 221 | 222 | } |
| 222 | 223 | |
| 223 | − dma_list = kmalloc(npages * sizeof *dma_list, GFP_KERNEL); | |
| 224 | + dma_list = kmalloc_array(npages, sizeof(*dma_list), | |
| 225 | + GFP_KERNEL); | |
| 224 | 226 | if (!dma_list) |
| 225 | 227 | goto err_free; |
| 226 | 228 | |
| @@ -231,12 +233,14 @@ int mthca_buf_alloc(struct mthca_dev *dev, int size, int max_direct, · 4 unmodified lines | ||
| 231 | 233 | npages = (size + PAGE_SIZE - 1) / PAGE_SIZE; |
| 232 | 234 | shift = PAGE_SHIFT; |
| 233 | 235 | |
| 234 | − dma_list = kmalloc(npages * sizeof *dma_list, GFP_KERNEL); | |
| 236 | + dma_list = kmalloc_array(npages, sizeof(*dma_list), | |
| 237 | + GFP_KERNEL); | |
| 235 | 238 | if (!dma_list) |
| 236 | 239 | return -ENOMEM; |
| 237 | 240 | |
| 238 | − buf->page_list = kmalloc(npages * sizeof *buf->page_list, | |
| 239 | − GFP_KERNEL); | |
| 241 | + buf->page_list = kmalloc_array(npages, | |
| 242 | + sizeof(*buf->page_list), | |
| 243 | + GFP_KERNEL); | |
| 240 | 244 | if (!buf->page_list) |
| 241 | 245 | goto err_out; |
| 242 | 246 | |
| @@ -565,9 +565,9 @@ int mthca_cmd_use_events(struct mthca_dev *dev) · 564 unmodified lines | ||
| 565 | 565 | { |
| 566 | 566 | int i; |
| 567 | 567 | |
| 568 | − dev->cmd.context = kmalloc(dev->cmd.max_cmds * | |
| 569 | − sizeof (struct mthca_cmd_context), | |
| 570 | − GFP_KERNEL); | |
| 568 | + dev->cmd.context = kmalloc_array(dev->cmd.max_cmds, | |
| 569 | + sizeof(struct mthca_cmd_context), | |
| 570 | + GFP_KERNEL); | |
| 571 | 571 | if (!dev->cmd.context) |
| 572 | 572 | return -ENOMEM; |
| 573 | 573 | |
| @@ -479,15 +479,15 @@ static int mthca_create_eq(struct mthca_dev *dev, · 478 unmodified lines | ||
| 479 | 479 | eq->nent = roundup_pow_of_two(max(nent, 2)); |
| 480 | 480 | npages = ALIGN(eq->nent * MTHCA_EQ_ENTRY_SIZE, PAGE_SIZE) / PAGE_SIZE; |
| 481 | 481 | |
| 482 | − eq->page_list = kmalloc(npages * sizeof *eq->page_list, | |
| 483 | − GFP_KERNEL); | |
| 482 | + eq->page_list = kmalloc_array(npages, sizeof(*eq->page_list), | |
| 483 | + GFP_KERNEL); | |
| 484 | 484 | if (!eq->page_list) |
| 485 | 485 | goto err_out; |
| 486 | 486 | |
| 487 | 487 | for (i = 0; i < npages; ++i) |
| 488 | 488 | eq->page_list[i].buf = NULL; |
| 489 | 489 | |
| 490 | − dma_list = kmalloc(npages * sizeof *dma_list, GFP_KERNEL); | |
| 490 | + dma_list = kmalloc_array(npages, sizeof(*dma_list), GFP_KERNEL); | |
| 491 | 491 | if (!dma_list) |
| 492 | 492 | goto err_out_free; |
| 493 | 493 | |
| @@ -712,9 +712,9 @@ int mthca_init_db_tab(struct mthca_dev *dev) · 711 unmodified lines | ||
| 712 | 712 | dev->db_tab->max_group1 = 0; |
| 713 | 713 | dev->db_tab->min_group2 = dev->db_tab->npages - 1; |
| 714 | 714 | |
| 715 | − dev->db_tab->page = kmalloc(dev->db_tab->npages * | |
| 716 | − sizeof *dev->db_tab->page, | |
| 717 | − GFP_KERNEL); | |
| 715 | + dev->db_tab->page = kmalloc_array(dev->db_tab->npages, | |
| 716 | + sizeof(*dev->db_tab->page), | |
| 717 | + GFP_KERNEL); | |
| 718 | 718 | if (!dev->db_tab->page) { |
| 719 | 719 | kfree(dev->db_tab); |
| 720 | 720 | return -ENOMEM; |
| @@ -144,7 +144,7 @@ static int mthca_buddy_init(struct mthca_buddy *buddy, int max_order) · 143 unmodified lines | ||
| 144 | 144 | buddy->max_order = max_order; |
| 145 | 145 | spin_lock_init(&buddy->lock); |
| 146 | 146 | |
| 147 | − buddy->bits = kzalloc((buddy->max_order + 1) * sizeof (long *), | |
| 147 | + buddy->bits = kcalloc(buddy->max_order + 1, sizeof(long *), | |
| 148 | 148 | GFP_KERNEL); |
| 149 | 149 | buddy->num_free = kcalloc((buddy->max_order + 1), sizeof *buddy->num_free, |
| 150 | 150 | GFP_KERNEL); |
| @@ -153,7 +153,7 @@ static int mthca_buddy_init(struct mthca_buddy *buddy, int max_order) · 2 unmodified lines | ||
| 153 | 153 | |
| 154 | 154 | for (i = 0; i <= buddy->max_order; ++i) { |
| 155 | 155 | s = BITS_TO_LONGS(1 << (buddy->max_order - i)); |
| 156 | − buddy->bits[i] = kmalloc(s * sizeof (long), GFP_KERNEL); | |
| 156 | + buddy->bits[i] = kmalloc_array(s, sizeof(long), GFP_KERNEL); | |
| 157 | 157 | if (!buddy->bits[i]) |
| 158 | 158 | goto err_out_free; |
| 159 | 159 | bitmap_zero(buddy->bits[i], |
| @@ -79,7 +79,7 @@ s64 mthca_make_profile(struct mthca_dev *dev, · 78 unmodified lines | ||
| 79 | 79 | struct mthca_resource *profile; |
| 80 | 80 | int i, j; |
| 81 | 81 | |
| 82 | − profile = kzalloc(MTHCA_RES_NUM * sizeof *profile, GFP_KERNEL); | |
| 82 | + profile = kcalloc(MTHCA_RES_NUM, sizeof(*profile), GFP_KERNEL); | |
| 83 | 83 | if (!profile) |
| 84 | 84 | return -ENOMEM; |
| 85 | 85 | |
| @@ -1054,8 +1054,8 @@ static int mthca_alloc_wqe_buf(struct mthca_dev *dev, · 1053 unmodified lines | ||
| 1054 | 1054 | size = PAGE_ALIGN(qp->send_wqe_offset + |
| 1055 | 1055 | (qp->sq.max << qp->sq.wqe_shift)); |
| 1056 | 1056 | |
| 1057 | − qp->wrid = kmalloc((qp->rq.max + qp->sq.max) * sizeof (u64), | |
| 1058 | − GFP_KERNEL); | |
| 1057 | + qp->wrid = kmalloc_array(qp->rq.max + qp->sq.max, sizeof(u64), | |
| 1058 | + GFP_KERNEL); | |
| 1059 | 1059 | if (!qp->wrid) |
| 1060 | 1060 | goto err_out; |
| 1061 | 1061 | |
| @@ -155,7 +155,7 @@ static int mthca_alloc_srq_buf(struct mthca_dev *dev, struct mthca_pd *pd, · 154 unmodified lines | ||
| 155 | 155 | if (pd->ibpd.uobject) |
| 156 | 156 | return 0; |
| 157 | 157 | |
| 158 | − srq->wrid = kmalloc(srq->max * sizeof (u64), GFP_KERNEL); | |
| 158 | + srq->wrid = kmalloc_array(srq->max, sizeof(u64), GFP_KERNEL); | |
| 159 | 159 | if (!srq->wrid) |
| 160 | 160 | return -ENOMEM; |
| 161 | 161 | |
| @@ -878,7 +878,8 @@ int nes_init_mgt_qp(struct nes_device *nesdev, struct net_device *netdev, struct · 877 unmodified lines | ||
| 878 | 878 | int ret; |
| 879 | 879 | |
| 880 | 880 | /* Allocate space the all mgt QPs once */ |
| 881 | − mgtvnic = kzalloc(NES_MGT_QP_COUNT * sizeof(struct nes_vnic_mgt), GFP_KERNEL); | |
| 881 | + mgtvnic = kcalloc(NES_MGT_QP_COUNT, sizeof(struct nes_vnic_mgt), | |
| 882 | + GFP_KERNEL); | |
| 882 | 883 | if (!mgtvnic) |
| 883 | 884 | return -ENOMEM; |
| 884 | 885 | |
| @@ -904,7 +904,7 @@ static void nes_netdev_set_multicast_list(struct net_device *netdev) · 903 unmodified lines | ||
| 904 | 904 | int i; |
| 905 | 905 | struct netdev_hw_addr *ha; |
| 906 | 906 | |
| 907 | − addrs = kmalloc(ETH_ALEN * mc_count, GFP_ATOMIC); | |
| 907 | + addrs = kmalloc_array(mc_count, ETH_ALEN, GFP_ATOMIC); | |
| 908 | 908 | if (!addrs) { |
| 909 | 909 | set_allmulti(nesdev, nic_active_bit); |
| 910 | 910 | goto unlock; |
| @@ -2254,8 +2254,9 @@ static struct ib_mr *nes_reg_user_mr(struct ib_pd *pd, u64 start, u64 length, · 2253 unmodified lines | ||
| 2254 | 2254 | ibmr = ERR_PTR(-ENOMEM); |
| 2255 | 2255 | goto reg_user_mr_err; |
| 2256 | 2256 | } |
| 2257 | − root_vpbl.leaf_vpbl = kzalloc(sizeof(*root_vpbl.leaf_vpbl)*1024, | |
| 2258 | − GFP_KERNEL); | |
| 2257 | + root_vpbl.leaf_vpbl = kcalloc(1024, | |
| 2258 | + sizeof(*root_vpbl.leaf_vpbl), | |
| 2259 | + GFP_KERNEL); | |
| 2259 | 2260 | if (!root_vpbl.leaf_vpbl) { |
| 2260 | 2261 | ib_umem_release(region); |
| 2261 | 2262 | pci_free_consistent(nesdev->pcidev, 8192, root_vpbl.pbl_vbase, |
| @@ -3096,7 +3096,7 @@ static int ocrdma_create_eqs(struct ocrdma_dev *dev) · 3095 unmodified lines | ||
| 3096 | 3096 | if (!num_eq) |
| 3097 | 3097 | return -EINVAL; |
| 3098 | 3098 | |
| 3099 | − dev->eq_tbl = kzalloc(sizeof(struct ocrdma_eq) * num_eq, GFP_KERNEL); | |
| 3099 | + dev->eq_tbl = kcalloc(num_eq, sizeof(struct ocrdma_eq), GFP_KERNEL); | |
| 3100 | 3100 | if (!dev->eq_tbl) |
| 3101 | 3101 | return -ENOMEM; |
| 3102 | 3102 | |
| @@ -221,19 +221,20 @@ static int ocrdma_register_device(struct ocrdma_dev *dev) · 220 unmodified lines | ||
| 221 | 221 | static int ocrdma_alloc_resources(struct ocrdma_dev *dev) |
| 222 | 222 | { |
| 223 | 223 | mutex_init(&dev->dev_lock); |
| 224 | − dev->cq_tbl = kzalloc(sizeof(struct ocrdma_cq *) * | |
| 225 | − OCRDMA_MAX_CQ, GFP_KERNEL); | |
| 224 | + dev->cq_tbl = kcalloc(OCRDMA_MAX_CQ, sizeof(struct ocrdma_cq *), | |
| 225 | + GFP_KERNEL); | |
| 226 | 226 | if (!dev->cq_tbl) |
| 227 | 227 | goto alloc_err; |
| 228 | 228 | |
| 229 | 229 | if (dev->attr.max_qp) { |
| 230 | − dev->qp_tbl = kzalloc(sizeof(struct ocrdma_qp *) * | |
| 231 | − OCRDMA_MAX_QP, GFP_KERNEL); | |
| 230 | + dev->qp_tbl = kcalloc(OCRDMA_MAX_QP, | |
| 231 | + sizeof(struct ocrdma_qp *), | |
| 232 | + GFP_KERNEL); | |
| 232 | 233 | if (!dev->qp_tbl) |
| 233 | 234 | goto alloc_err; |
| 234 | 235 | } |
| 235 | 236 | |
| 236 | − dev->stag_arr = kzalloc(sizeof(u64) * OCRDMA_MAX_STAG, GFP_KERNEL); | |
| 237 | + dev->stag_arr = kcalloc(OCRDMA_MAX_STAG, sizeof(u64), GFP_KERNEL); | |
| 237 | 238 | if (dev->stag_arr == NULL) |
| 238 | 239 | goto alloc_err; |
| 239 | 240 | |
| @@ -843,8 +843,8 @@ static int ocrdma_build_pbl_tbl(struct ocrdma_dev *dev, struct ocrdma_hw_mr *mr) · 842 unmodified lines | ||
| 843 | 843 | void *va; |
| 844 | 844 | dma_addr_t pa; |
| 845 | 845 | |
| 846 | − mr->pbl_table = kzalloc(sizeof(struct ocrdma_pbl) * | |
| 847 | − mr->num_pbls, GFP_KERNEL); | |
| 846 | + mr->pbl_table = kcalloc(mr->num_pbls, sizeof(struct ocrdma_pbl), | |
| 847 | + GFP_KERNEL); | |
| 848 | 848 | |
| 849 | 849 | if (!mr->pbl_table) |
| 850 | 850 | return -ENOMEM; |
| @@ -1323,12 +1323,12 @@ static void ocrdma_set_qp_db(struct ocrdma_dev *dev, struct ocrdma_qp *qp, · 472 unmodified lines | ||
| 1323 | 1323 | static int ocrdma_alloc_wr_id_tbl(struct ocrdma_qp *qp) |
| 1324 | 1324 | { |
| 1325 | 1325 | qp->wqe_wr_id_tbl = |
| 1326 | − kzalloc(sizeof(*(qp->wqe_wr_id_tbl)) * qp->sq.max_cnt, | |
| 1326 | + kcalloc(qp->sq.max_cnt, sizeof(*(qp->wqe_wr_id_tbl)), | |
| 1327 | 1327 | GFP_KERNEL); |
| 1328 | 1328 | if (qp->wqe_wr_id_tbl == NULL) |
| 1329 | 1329 | return -ENOMEM; |
| 1330 | 1330 | qp->rqe_wr_id_tbl = |
| 1331 | − kzalloc(sizeof(u64) * qp->rq.max_cnt, GFP_KERNEL); | |
| 1331 | + kcalloc(qp->rq.max_cnt, sizeof(u64), GFP_KERNEL); | |
| 1332 | 1332 | if (qp->rqe_wr_id_tbl == NULL) |
| 1333 | 1333 | return -ENOMEM; |
| 1334 | 1334 | |
| @@ -1865,15 +1865,16 @@ struct ib_srq *ocrdma_create_srq(struct ib_pd *ibpd, · 530 unmodified lines | ||
| 1865 | 1865 | |
| 1866 | 1866 | if (udata == NULL) { |
| 1867 | 1867 | status = -ENOMEM; |
| 1868 | − srq->rqe_wr_id_tbl = kzalloc(sizeof(u64) * srq->rq.max_cnt, | |
| 1869 | − GFP_KERNEL); | |
| 1868 | + srq->rqe_wr_id_tbl = kcalloc(srq->rq.max_cnt, sizeof(u64), | |
| 1869 | + GFP_KERNEL); | |
| 1870 | 1870 | if (srq->rqe_wr_id_tbl == NULL) |
| 1871 | 1871 | goto arm_err; |
| 1872 | 1872 | |
| 1873 | 1873 | srq->bit_fields_len = (srq->rq.max_cnt / 32) + |
| 1874 | 1874 | (srq->rq.max_cnt % 32 ? 1 : 0); |
| 1875 | 1875 | srq->idx_bit_fields = |
| 1876 | − kmalloc(srq->bit_fields_len * sizeof(u32), GFP_KERNEL); | |
| 1876 | + kmalloc_array(srq->bit_fields_len, sizeof(u32), | |
| 1877 | + GFP_KERNEL); | |
| 1877 | 1878 | if (srq->idx_bit_fields == NULL) |
| 1878 | 1879 | goto arm_err; |
| 1879 | 1880 | memset(srq->idx_bit_fields, 0xff, |
| @@ -317,8 +317,8 @@ static int qedr_alloc_resources(struct qedr_dev *dev) · 316 unmodified lines | ||
| 317 | 317 | u16 n_entries; |
| 318 | 318 | int i, rc; |
| 319 | 319 | |
| 320 | − dev->sgid_tbl = kzalloc(sizeof(union ib_gid) * | |
| 321 | − QEDR_MAX_SGID, GFP_KERNEL); | |
| 320 | + dev->sgid_tbl = kcalloc(QEDR_MAX_SGID, sizeof(union ib_gid), | |
| 321 | + GFP_KERNEL); | |
| 322 | 322 | if (!dev->sgid_tbl) |
| 323 | 323 | return -ENOMEM; |
| 324 | 324 | |
| @@ -1614,7 +1614,7 @@ static int qedr_create_kernel_qp(struct qedr_dev *dev, · 1613 unmodified lines | ||
| 1614 | 1614 | qp->sq.max_wr = min_t(u32, attrs->cap.max_send_wr * dev->wq_multiplier, |
| 1615 | 1615 | dev->attr.max_sqe); |
| 1616 | 1616 | |
| 1617 | − qp->wqe_wr_id = kzalloc(qp->sq.max_wr * sizeof(*qp->wqe_wr_id), | |
| 1617 | + qp->wqe_wr_id = kcalloc(qp->sq.max_wr, sizeof(*qp->wqe_wr_id), | |
| 1618 | 1618 | GFP_KERNEL); |
| 1619 | 1619 | if (!qp->wqe_wr_id) { |
| 1620 | 1620 | DP_ERR(dev, "create qp: failed SQ shadow memory allocation\n"); |
| @@ -1632,7 +1632,7 @@ static int qedr_create_kernel_qp(struct qedr_dev *dev, · 11 unmodified lines | ||
| 1632 | 1632 | qp->rq.max_wr = (u16) max_t(u32, attrs->cap.max_recv_wr, 1); |
| 1633 | 1633 | |
| 1634 | 1634 | /* Allocate driver internal RQ array */ |
| 1635 | − qp->rqe_wr_id = kzalloc(qp->rq.max_wr * sizeof(*qp->rqe_wr_id), | |
| 1635 | + qp->rqe_wr_id = kcalloc(qp->rq.max_wr, sizeof(*qp->rqe_wr_id), | |
| 1636 | 1636 | GFP_KERNEL); |
| 1637 | 1637 | if (!qp->rqe_wr_id) { |
| 1638 | 1638 | DP_ERR(dev, |
| @@ -2496,15 +2496,16 @@ static void init_6120_cntrnames(struct qib_devdata *dd) · 2495 unmodified lines | ||
| 2496 | 2496 | dd->cspec->cntrnamelen = sizeof(cntr6120names) - 1; |
| 2497 | 2497 | else |
| 2498 | 2498 | dd->cspec->cntrnamelen = 1 + s - cntr6120names; |
| 2499 | − dd->cspec->cntrs = kmalloc(dd->cspec->ncntrs | |
| 2500 | − * sizeof(u64), GFP_KERNEL); | |
| 2499 | + dd->cspec->cntrs = kmalloc_array(dd->cspec->ncntrs, sizeof(u64), | |
| 2500 | + GFP_KERNEL); | |
| 2501 | 2501 | |
| 2502 | 2502 | for (i = 0, s = (char *)portcntr6120names; s; i++) |
| 2503 | 2503 | s = strchr(s + 1, '\n'); |
| 2504 | 2504 | dd->cspec->nportcntrs = i - 1; |
| 2505 | 2505 | dd->cspec->portcntrnamelen = sizeof(portcntr6120names) - 1; |
| 2506 | − dd->cspec->portcntrs = kmalloc(dd->cspec->nportcntrs | |
| 2507 | − * sizeof(u64), GFP_KERNEL); | |
| 2506 | + dd->cspec->portcntrs = kmalloc_array(dd->cspec->nportcntrs, | |
| 2507 | + sizeof(u64), | |
| 2508 | + GFP_KERNEL); | |
| 2508 | 2509 | } |
| 2509 | 2510 | |
| 2510 | 2511 | static u32 qib_read_6120cntrs(struct qib_devdata *dd, loff_t pos, char **namep, |
| @@ -3147,15 +3147,16 @@ static void init_7220_cntrnames(struct qib_devdata *dd) · 3146 unmodified lines | ||
| 3147 | 3147 | dd->cspec->cntrnamelen = sizeof(cntr7220names) - 1; |
| 3148 | 3148 | else |
| 3149 | 3149 | dd->cspec->cntrnamelen = 1 + s - cntr7220names; |
| 3150 | − dd->cspec->cntrs = kmalloc(dd->cspec->ncntrs | |
| 3151 | − * sizeof(u64), GFP_KERNEL); | |
| 3150 | + dd->cspec->cntrs = kmalloc_array(dd->cspec->ncntrs, sizeof(u64), | |
| 3151 | + GFP_KERNEL); | |
| 3152 | 3152 | |
| 3153 | 3153 | for (i = 0, s = (char *)portcntr7220names; s; i++) |
| 3154 | 3154 | s = strchr(s + 1, '\n'); |
| 3155 | 3155 | dd->cspec->nportcntrs = i - 1; |
| 3156 | 3156 | dd->cspec->portcntrnamelen = sizeof(portcntr7220names) - 1; |
| 3157 | − dd->cspec->portcntrs = kmalloc(dd->cspec->nportcntrs | |
| 3158 | − * sizeof(u64), GFP_KERNEL); | |
| 3157 | + dd->cspec->portcntrs = kmalloc_array(dd->cspec->nportcntrs, | |
| 3158 | + sizeof(u64), | |
| 3159 | + GFP_KERNEL); | |
| 3159 | 3160 | } |
| 3160 | 3161 | |
| 3161 | 3162 | static u32 qib_read_7220cntrs(struct qib_devdata *dd, loff_t pos, char **namep, |
| @@ -3648,8 +3648,9 @@ static int qib_do_7322_reset(struct qib_devdata *dd) · 3647 unmodified lines | ||
| 3648 | 3648 | |
| 3649 | 3649 | if (msix_entries) { |
| 3650 | 3650 | /* can be up to 512 bytes, too big for stack */ |
| 3651 | − msix_vecsave = kmalloc(2 * dd->cspec->num_msix_entries * | |
| 3652 | − sizeof(u64), GFP_KERNEL); | |
| 3651 | + msix_vecsave = kmalloc_array(2 * dd->cspec->num_msix_entries, | |
| 3652 | + sizeof(u64), | |
| 3653 | + GFP_KERNEL); | |
| 3653 | 3654 | } |
| 3654 | 3655 | |
| 3655 | 3656 | /* |
| @@ -5009,16 +5010,17 @@ static void init_7322_cntrnames(struct qib_devdata *dd) · 1353 unmodified lines | ||
| 5009 | 5010 | dd->cspec->cntrnamelen = sizeof(cntr7322names) - 1; |
| 5010 | 5011 | else |
| 5011 | 5012 | dd->cspec->cntrnamelen = 1 + s - cntr7322names; |
| 5012 | − dd->cspec->cntrs = kmalloc(dd->cspec->ncntrs | |
| 5013 | − * sizeof(u64), GFP_KERNEL); | |
| 5013 | + dd->cspec->cntrs = kmalloc_array(dd->cspec->ncntrs, sizeof(u64), | |
| 5014 | + GFP_KERNEL); | |
| 5014 | 5015 | |
| 5015 | 5016 | for (i = 0, s = (char *)portcntr7322names; s; i++) |
| 5016 | 5017 | s = strchr(s + 1, '\n'); |
| 5017 | 5018 | dd->cspec->nportcntrs = i - 1; |
| 5018 | 5019 | dd->cspec->portcntrnamelen = sizeof(portcntr7322names) - 1; |
| 5019 | 5020 | for (i = 0; i < dd->num_pports; ++i) { |
| 5020 | − dd->pport[i].cpspec->portcntrs = kmalloc(dd->cspec->nportcntrs | |
| 5021 | − * sizeof(u64), GFP_KERNEL); | |
| 5021 | + dd->pport[i].cpspec->portcntrs = | |
| 5022 | + kmalloc_array(dd->cspec->nportcntrs, sizeof(u64), | |
| 5023 | + GFP_KERNEL); | |
| 5022 | 5024 | } |
| 5023 | 5025 | } |
| 5024 | 5026 | |
| @@ -6412,12 +6414,15 @@ static int qib_init_7322_variables(struct qib_devdata *dd) · 1387 unmodified lines | ||
| 6412 | 6414 | sbufcnt = dd->piobcnt2k + dd->piobcnt4k + |
| 6413 | 6415 | NUM_VL15_BUFS + BITS_PER_LONG - 1; |
| 6414 | 6416 | sbufcnt /= BITS_PER_LONG; |
| 6415 | − dd->cspec->sendchkenable = kmalloc(sbufcnt * | |
| 6416 | − sizeof(*dd->cspec->sendchkenable), GFP_KERNEL); | |
| 6417 | − dd->cspec->sendgrhchk = kmalloc(sbufcnt * | |
| 6418 | − sizeof(*dd->cspec->sendgrhchk), GFP_KERNEL); | |
| 6419 | − dd->cspec->sendibchk = kmalloc(sbufcnt * | |
| 6420 | − sizeof(*dd->cspec->sendibchk), GFP_KERNEL); | |
| 6417 | + dd->cspec->sendchkenable = | |
| 6418 | + kmalloc_array(sbufcnt, sizeof(*dd->cspec->sendchkenable), | |
| 6419 | + GFP_KERNEL); | |
| 6420 | + dd->cspec->sendgrhchk = | |
| 6421 | + kmalloc_array(sbufcnt, sizeof(*dd->cspec->sendgrhchk), | |
| 6422 | + GFP_KERNEL); | |
| 6423 | + dd->cspec->sendibchk = | |
| 6424 | + kmalloc_array(sbufcnt, sizeof(*dd->cspec->sendibchk), | |
| 6425 | + GFP_KERNEL); | |
| 6421 | 6426 | if (!dd->cspec->sendchkenable || !dd->cspec->sendgrhchk || |
| 6422 | 6427 | !dd->cspec->sendibchk) { |
| 6423 | 6428 | ret = -ENOMEM; |
| @@ -7290,8 +7295,9 @@ struct qib_devdata *qib_init_iba7322_funcs(struct pci_dev *pdev, · 866 unmodified lines | ||
| 7290 | 7295 | actual_cnt -= dd->num_pports; |
| 7291 | 7296 | |
| 7292 | 7297 | tabsize = actual_cnt; |
| 7293 | − dd->cspec->msix_entries = kzalloc(tabsize * | |
| 7294 | − sizeof(struct qib_msix_entry), GFP_KERNEL); | |
| 7298 | + dd->cspec->msix_entries = kcalloc(tabsize, | |
| 7299 | + sizeof(struct qib_msix_entry), | |
| 7300 | + GFP_KERNEL); | |
| 7295 | 7301 | if (!dd->cspec->msix_entries) |
| 7296 | 7302 | tabsize = 0; |
| 7297 | 7303 | |
| @@ -369,11 +369,13 @@ static void init_shadow_tids(struct qib_devdata *dd) · 368 unmodified lines | ||
| 369 | 369 | struct page **pages; |
| 370 | 370 | dma_addr_t *addrs; |
| 371 | 371 | |
| 372 | − pages = vzalloc(dd->cfgctxts * dd->rcvtidcnt * sizeof(struct page *)); | |
| 372 | + pages = vzalloc(array_size(sizeof(struct page *), | |
| 373 | + dd->cfgctxts * dd->rcvtidcnt)); | |
| 373 | 374 | if (!pages) |
| 374 | 375 | goto bail; |
| 375 | 376 | |
| 376 | − addrs = vzalloc(dd->cfgctxts * dd->rcvtidcnt * sizeof(dma_addr_t)); | |
| 377 | + addrs = vzalloc(array_size(sizeof(dma_addr_t), | |
| 378 | + dd->cfgctxts * dd->rcvtidcnt)); | |
| 377 | 379 | if (!addrs) |
| 378 | 380 | goto bail_free; |
| 379 | 381 | |
| @@ -1134,8 +1136,8 @@ struct qib_devdata *qib_alloc_devdata(struct pci_dev *pdev, size_t extra) · 754 unmodified lines | ||
| 1134 | 1136 | if (!qib_cpulist_count) { |
| 1135 | 1137 | u32 count = num_online_cpus(); |
| 1136 | 1138 | |
| 1137 | − qib_cpulist = kzalloc(BITS_TO_LONGS(count) * | |
| 1138 | − sizeof(long), GFP_KERNEL); | |
| 1139 | + qib_cpulist = kcalloc(BITS_TO_LONGS(count), sizeof(long), | |
| 1140 | + GFP_KERNEL); | |
| 1139 | 1141 | if (qib_cpulist) |
| 1140 | 1142 | qib_cpulist_count = count; |
| 1141 | 1143 | } |
| @@ -1673,8 +1675,8 @@ int qib_setup_eagerbufs(struct qib_ctxtdata *rcd) · 531 unmodified lines | ||
| 1673 | 1675 | size = rcd->rcvegrbuf_size; |
| 1674 | 1676 | if (!rcd->rcvegrbuf) { |
| 1675 | 1677 | rcd->rcvegrbuf = |
| 1676 | − kzalloc_node(chunk * sizeof(rcd->rcvegrbuf[0]), | |
| 1677 | − GFP_KERNEL, rcd->node_id); | |
| 1678 | + kcalloc_node(chunk, sizeof(rcd->rcvegrbuf[0]), | |
| 1679 | + GFP_KERNEL, rcd->node_id); | |
| 1678 | 1680 | if (!rcd->rcvegrbuf) |
| 1679 | 1681 | goto bail; |
| 1680 | 1682 | } |
| @@ -543,7 +543,7 @@ alloc_res_chunk_list(struct usnic_vnic *vnic, · 542 unmodified lines | ||
| 543 | 543 | /* Do Nothing */ |
| 544 | 544 | } |
| 545 | 545 | |
| 546 | − res_chunk_list = kzalloc(sizeof(*res_chunk_list)*(res_lst_sz+1), | |
| 546 | + res_chunk_list = kcalloc(res_lst_sz + 1, sizeof(*res_chunk_list), | |
| 547 | 547 | GFP_ATOMIC); |
| 548 | 548 | if (!res_chunk_list) |
| 549 | 549 | return ERR_PTR(-ENOMEM); |
| @@ -312,7 +312,7 @@ static int usnic_vnic_alloc_res_chunk(struct usnic_vnic *vnic, · 311 unmodified lines | ||
| 312 | 312 | } |
| 313 | 313 | |
| 314 | 314 | chunk->cnt = chunk->free_cnt = cnt; |
| 315 | − chunk->res = kzalloc(sizeof(*(chunk->res))*cnt, GFP_KERNEL); | |
| 315 | + chunk->res = kcalloc(cnt, sizeof(*(chunk->res)), GFP_KERNEL); | |
| 316 | 316 | if (!chunk->res) |
| 317 | 317 | return -ENOMEM; |
| 318 | 318 | |
| @@ -813,7 +813,7 @@ struct ib_qp *rvt_create_qp(struct ib_pd *ibpd, · 812 unmodified lines | ||
| 813 | 813 | sz = sizeof(struct rvt_sge) * |
| 814 | 814 | init_attr->cap.max_send_sge + |
| 815 | 815 | sizeof(struct rvt_swqe); |
| 816 | − swq = vzalloc_node(sqsize * sz, rdi->dparms.node); | |
| 816 | + swq = vzalloc_node(array_size(sz, sqsize), rdi->dparms.node); | |
| 817 | 817 | if (!swq) |
| 818 | 818 | return ERR_PTR(-ENOMEM); |
| 819 | 819 | |
| @@ -836,11 +836,10 @@ struct ib_qp *rvt_create_qp(struct ib_pd *ibpd, · 16 unmodified lines | ||
| 836 | 836 | RCU_INIT_POINTER(qp->next, NULL); |
| 837 | 837 | if (init_attr->qp_type == IB_QPT_RC) { |
| 838 | 838 | qp->s_ack_queue = |
| 839 | − kzalloc_node( | |
| 840 | − sizeof(*qp->s_ack_queue) * | |
| 841 | − rvt_max_atomic(rdi), | |
| 842 | − GFP_KERNEL, | |
| 843 | − rdi->dparms.node); | |
| 839 | + kcalloc_node(rvt_max_atomic(rdi), | |
| 840 | + sizeof(*qp->s_ack_queue), | |
| 841 | + GFP_KERNEL, | |
| 842 | + rdi->dparms.node); | |
| 844 | 843 | if (!qp->s_ack_queue) |
| 845 | 844 | goto bail_qp; |
| 846 | 845 | } |
| @@ -358,7 +358,8 @@ static int ipoib_cm_nonsrq_init_rx(struct net_device *dev, struct ib_cm_id *cm_i · 357 unmodified lines | ||
| 358 | 358 | int ret; |
| 359 | 359 | int i; |
| 360 | 360 | |
| 361 | − rx->rx_ring = vzalloc(ipoib_recvq_size * sizeof *rx->rx_ring); | |
| 361 | + rx->rx_ring = vzalloc(array_size(ipoib_recvq_size, | |
| 362 | + sizeof(*rx->rx_ring))); | |
| 362 | 363 | if (!rx->rx_ring) |
| 363 | 364 | return -ENOMEM; |
| 364 | 365 | |
| @@ -1145,7 +1146,7 @@ static int ipoib_cm_tx_init(struct ipoib_cm_tx *p, u32 qpn, · 780 unmodified lines | ||
| 1145 | 1146 | int ret; |
| 1146 | 1147 | |
| 1147 | 1148 | noio_flag = memalloc_noio_save(); |
| 1148 | − p->tx_ring = vzalloc(ipoib_sendq_size * sizeof(*p->tx_ring)); | |
| 1149 | + p->tx_ring = vzalloc(array_size(ipoib_sendq_size, sizeof(*p->tx_ring))); | |
| 1149 | 1150 | if (!p->tx_ring) { |
| 1150 | 1151 | memalloc_noio_restore(noio_flag); |
| 1151 | 1152 | ret = -ENOMEM; |
| @@ -1570,7 +1571,8 @@ static void ipoib_cm_create_srq(struct net_device *dev, int max_sge) · 418 unmodified lines | ||
| 1570 | 1571 | return; |
| 1571 | 1572 | } |
| 1572 | 1573 | |
| 1573 | − priv->cm.srq_ring = vzalloc(ipoib_recvq_size * sizeof *priv->cm.srq_ring); | |
| 1574 | + priv->cm.srq_ring = vzalloc(array_size(ipoib_recvq_size, | |
| 1575 | + sizeof(*priv->cm.srq_ring))); | |
| 1574 | 1576 | if (!priv->cm.srq_ring) { |
| 1575 | 1577 | ib_destroy_srq(priv->cm.srq); |
| 1576 | 1578 | priv->cm.srq = NULL; |
| @@ -1526,7 +1526,7 @@ static int ipoib_neigh_hash_init(struct ipoib_dev_priv *priv) · 1525 unmodified lines | ||
| 1526 | 1526 | return -ENOMEM; |
| 1527 | 1527 | set_bit(IPOIB_STOP_NEIGH_GC, &priv->flags); |
| 1528 | 1528 | size = roundup_pow_of_two(arp_tbl.gc_thresh3); |
| 1529 | − buckets = kzalloc(size * sizeof(*buckets), GFP_KERNEL); | |
| 1529 | + buckets = kcalloc(size, sizeof(*buckets), GFP_KERNEL); | |
| 1530 | 1530 | if (!buckets) { |
| 1531 | 1531 | kfree(htbl); |
| 1532 | 1532 | return -ENOMEM; |
| @@ -1704,12 +1704,14 @@ static int ipoib_dev_init_default(struct net_device *dev) · 171 unmodified lines | ||
| 1704 | 1704 | ipoib_napi_add(dev); |
| 1705 | 1705 | |
| 1706 | 1706 | /* Allocate RX/TX "rings" to hold queued skbs */ |
| 1707 | − priv->rx_ring = kzalloc(ipoib_recvq_size * sizeof *priv->rx_ring, | |
| 1708 | − GFP_KERNEL); | |
| 1707 | + priv->rx_ring = kcalloc(ipoib_recvq_size, | |
| 1708 | + sizeof(*priv->rx_ring), | |
| 1709 | + GFP_KERNEL); | |
| 1709 | 1710 | if (!priv->rx_ring) |
| 1710 | 1711 | goto out; |
| 1711 | 1712 | |
| 1712 | − priv->tx_ring = vzalloc(ipoib_sendq_size * sizeof *priv->tx_ring); | |
| 1713 | + priv->tx_ring = vzalloc(array_size(ipoib_sendq_size, | |
| 1714 | + sizeof(*priv->tx_ring))); | |
| 1713 | 1715 | if (!priv->tx_ring) { |
| 1714 | 1716 | pr_warn("%s: failed to allocate TX ring (%d entries)\n", |
| 1715 | 1717 | priv->ca->name, ipoib_sendq_size); |
| @@ -258,8 +258,9 @@ int iser_alloc_rx_descriptors(struct iser_conn *iser_conn, · 257 unmodified lines | ||
| 258 | 258 | goto alloc_login_buf_fail; |
| 259 | 259 | |
| 260 | 260 | iser_conn->num_rx_descs = session->cmds_max; |
| 261 | − iser_conn->rx_descs = kmalloc(iser_conn->num_rx_descs * | |
| 262 | − sizeof(struct iser_rx_desc), GFP_KERNEL); | |
| 261 | + iser_conn->rx_descs = kmalloc_array(iser_conn->num_rx_descs, | |
| 262 | + sizeof(struct iser_rx_desc), | |
| 263 | + GFP_KERNEL); | |
| 263 | 264 | if (!iser_conn->rx_descs) |
| 264 | 265 | goto rx_desc_alloc_fail; |
| 265 | 266 | |
| @@ -181,8 +181,9 @@ isert_alloc_rx_descriptors(struct isert_conn *isert_conn) · 180 unmodified lines | ||
| 181 | 181 | u64 dma_addr; |
| 182 | 182 | int i, j; |
| 183 | 183 | |
| 184 | − isert_conn->rx_descs = kzalloc(ISERT_QP_MAX_RECV_DTOS * | |
| 185 | − sizeof(struct iser_rx_desc), GFP_KERNEL); | |
| 184 | + isert_conn->rx_descs = kcalloc(ISERT_QP_MAX_RECV_DTOS, | |
| 185 | + sizeof(struct iser_rx_desc), | |
| 186 | + GFP_KERNEL); | |
| 186 | 187 | if (!isert_conn->rx_descs) |
| 187 | 188 | return -ENOMEM; |
| 188 | 189 | |
| @@ -1035,16 +1035,17 @@ static int srp_alloc_req_data(struct srp_rdma_ch *ch) · 1034 unmodified lines | ||
| 1035 | 1035 | |
| 1036 | 1036 | for (i = 0; i < target->req_ring_size; ++i) { |
| 1037 | 1037 | req = &ch->req_ring[i]; |
| 1038 | − mr_list = kmalloc(target->mr_per_cmd * sizeof(void *), | |
| 1039 | − GFP_KERNEL); | |
| 1038 | + mr_list = kmalloc_array(target->mr_per_cmd, sizeof(void *), | |
| 1039 | + GFP_KERNEL); | |
| 1040 | 1040 | if (!mr_list) |
| 1041 | 1041 | goto out; |
| 1042 | 1042 | if (srp_dev->use_fast_reg) { |
| 1043 | 1043 | req->fr_list = mr_list; |
| 1044 | 1044 | } else { |
| 1045 | 1045 | req->fmr_list = mr_list; |
| 1046 | − req->map_page = kmalloc(srp_dev->max_pages_per_mr * | |
| 1047 | − sizeof(void *), GFP_KERNEL); | |
| 1046 | + req->map_page = kmalloc_array(srp_dev->max_pages_per_mr, | |
| 1047 | + sizeof(void *), | |
| 1048 | + GFP_KERNEL); | |
| 1048 | 1049 | if (!req->map_page) |
| 1049 | 1050 | goto out; |
| 1050 | 1051 | } |
| @@ -720,7 +720,7 @@ static struct srpt_ioctx **srpt_alloc_ioctx_ring(struct srpt_device *sdev, · 719 unmodified lines | ||
| 720 | 720 | WARN_ON(ioctx_size != sizeof(struct srpt_recv_ioctx) |
| 721 | 721 | && ioctx_size != sizeof(struct srpt_send_ioctx)); |
| 722 | 722 | |
| 723 | − ring = kmalloc(ring_size * sizeof(ring[0]), GFP_KERNEL); | |
| 723 | + ring = kmalloc_array(ring_size, sizeof(ring[0]), GFP_KERNEL); | |
| 724 | 724 | if (!ring) |
| 725 | 725 | goto out; |
| 726 | 726 | for (i = 0; i < ring_size; ++i) { |
| @@ -80,7 +80,7 @@ static int joydump_connect(struct gameport *gameport, struct gameport_driver *dr · 79 unmodified lines | ||
| 80 | 80 | |
| 81 | 81 | timeout = gameport_time(gameport, 10000); /* 10 ms */ |
| 82 | 82 | |
| 83 | − buf = kmalloc(BUF_SIZE * sizeof(struct joydump), GFP_KERNEL); | |
| 83 | + buf = kmalloc_array(BUF_SIZE, sizeof(struct joydump), GFP_KERNEL); | |
| 84 | 84 | if (!buf) { |
| 85 | 85 | printk(KERN_INFO "joydump: no memory for testing\n"); |
| 86 | 86 | goto jd_end; |
| @@ -109,8 +109,8 @@ static int clps711x_keypad_probe(struct platform_device *pdev) · 108 unmodified lines | ||
| 109 | 109 | if (priv->row_count < 1) |
| 110 | 110 | return -EINVAL; |
| 111 | 111 | |
| 112 | − priv->gpio_data = devm_kzalloc(dev, | |
| 113 | − sizeof(*priv->gpio_data) * priv->row_count, | |
| 112 | + priv->gpio_data = devm_kcalloc(dev, | |
| 113 | + priv->row_count, sizeof(*priv->gpio_data), | |
| 114 | 114 | GFP_KERNEL); |
| 115 | 115 | if (!priv->gpio_data) |
| 116 | 116 | return -ENOMEM; |
| @@ -443,9 +443,9 @@ matrix_keypad_parse_dt(struct device *dev) · 442 unmodified lines | ||
| 443 | 443 | of_property_read_u32(np, "col-scan-delay-us", |
| 444 | 444 | &pdata->col_scan_delay_us); |
| 445 | 445 | |
| 446 | − gpios = devm_kzalloc(dev, | |
| 447 | − sizeof(unsigned int) * | |
| 448 | − (pdata->num_row_gpios + pdata->num_col_gpios), | |
| 446 | + gpios = devm_kcalloc(dev, | |
| 447 | + pdata->num_row_gpios + pdata->num_col_gpios, | |
| 448 | + sizeof(unsigned int), | |
| 449 | 449 | GFP_KERNEL); |
| 450 | 450 | if (!gpios) { |
| 451 | 451 | dev_err(dev, "could not allocate memory for gpios\n"); |
| @@ -337,7 +337,8 @@ static int omap4_keypad_probe(struct platform_device *pdev) · 336 unmodified lines | ||
| 337 | 337 | |
| 338 | 338 | keypad_data->row_shift = get_count_order(keypad_data->cols); |
| 339 | 339 | max_keys = keypad_data->rows << keypad_data->row_shift; |
| 340 | − keypad_data->keymap = kzalloc(max_keys * sizeof(keypad_data->keymap[0]), | |
| 340 | + keypad_data->keymap = kcalloc(max_keys, | |
| 341 | + sizeof(keypad_data->keymap[0]), | |
| 341 | 342 | GFP_KERNEL); |
| 342 | 343 | if (!keypad_data->keymap) { |
| 343 | 344 | dev_err(&pdev->dev, "Not enough memory for keymap\n"); |
| @@ -281,7 +281,7 @@ samsung_keypad_parse_dt(struct device *dev) · 280 unmodified lines | ||
| 281 | 281 | |
| 282 | 282 | key_count = of_get_child_count(np); |
| 283 | 283 | keymap_data->keymap_size = key_count; |
| 284 | − keymap = devm_kzalloc(dev, sizeof(uint32_t) * key_count, GFP_KERNEL); | |
| 284 | + keymap = devm_kcalloc(dev, key_count, sizeof(uint32_t), GFP_KERNEL); | |
| 285 | 285 | if (!keymap) { |
| 286 | 286 | dev_err(dev, "could not allocate memory for keymap\n"); |
| 287 | 287 | return ERR_PTR(-ENOMEM); |
| @@ -170,8 +170,8 @@ int matrix_keypad_build_keymap(const struct matrix_keymap_data *keymap_data, · 169 unmodified lines | ||
| 170 | 170 | return -EINVAL; |
| 171 | 171 | |
| 172 | 172 | if (!keymap) { |
| 173 | − keymap = devm_kzalloc(input_dev->dev.parent, | |
| 174 | − max_keys * sizeof(*keymap), | |
| 173 | + keymap = devm_kcalloc(input_dev->dev.parent, | |
| 174 | + max_keys, sizeof(*keymap), | |
| 175 | 175 | GFP_KERNEL); |
| 176 | 176 | if (!keymap) { |
| 177 | 177 | dev_err(input_dev->dev.parent, |
| @@ -283,8 +283,8 @@ static int rotary_encoder_probe(struct platform_device *pdev) · 282 unmodified lines | ||
| 283 | 283 | } |
| 284 | 284 | |
| 285 | 285 | encoder->irq = |
| 286 | − devm_kzalloc(dev, | |
| 287 | − sizeof(*encoder->irq) * encoder->gpios->ndescs, | |
| 286 | + devm_kcalloc(dev, | |
| 287 | + encoder->gpios->ndescs, sizeof(*encoder->irq), | |
| 288 | 288 | GFP_KERNEL); |
| 289 | 289 | if (!encoder->irq) |
| 290 | 290 | return -ENOMEM; |
| @@ -636,9 +636,10 @@ int rmi_read_register_desc(struct rmi_device *d, u16 addr, · 635 unmodified lines | ||
| 636 | 636 | rdesc->num_registers = bitmap_weight(rdesc->presense_map, |
| 637 | 637 | RMI_REG_DESC_PRESENSE_BITS); |
| 638 | 638 | |
| 639 | − rdesc->registers = devm_kzalloc(&d->dev, rdesc->num_registers * | |
| 640 | − sizeof(struct rmi_register_desc_item), | |
| 641 | − GFP_KERNEL); | |
| 639 | + rdesc->registers = devm_kcalloc(&d->dev, | |
| 640 | + rdesc->num_registers, | |
| 641 | + sizeof(struct rmi_register_desc_item), | |
| 642 | + GFP_KERNEL); | |
| 642 | 643 | if (!rdesc->registers) |
| 643 | 644 | return -ENOMEM; |
| 644 | 645 | |
| @@ -1061,7 +1062,7 @@ int rmi_probe_interrupts(struct rmi_driver_data *data) · 416 unmodified lines | ||
| 1061 | 1062 | data->num_of_irq_regs = (data->irq_count + 7) / 8; |
| 1062 | 1063 | |
| 1063 | 1064 | size = BITS_TO_LONGS(data->irq_count) * sizeof(unsigned long); |
| 1064 | − data->irq_memory = devm_kzalloc(dev, size * 4, GFP_KERNEL); | |
| 1065 | + data->irq_memory = devm_kcalloc(dev, size, 4, GFP_KERNEL); | |
| 1065 | 1066 | if (!data->irq_memory) { |
| 1066 | 1067 | dev_err(dev, "Failed to allocate memory for irq masks.\n"); |
| 1067 | 1068 | return -ENOMEM; |
| @@ -1190,14 +1190,15 @@ static int rmi_f11_initialize(struct rmi_function *fn) · 1189 unmodified lines | ||
| 1190 | 1190 | f11->sensor.attn_size += f11->sensor.nbr_fingers * 2; |
| 1191 | 1191 | |
| 1192 | 1192 | /* allocate the in-kernel tracking buffers */ |
| 1193 | − sensor->tracking_pos = devm_kzalloc(&fn->dev, | |
| 1194 | − sizeof(struct input_mt_pos) * sensor->nbr_fingers, | |
| 1193 | + sensor->tracking_pos = devm_kcalloc(&fn->dev, | |
| 1194 | + sensor->nbr_fingers, sizeof(struct input_mt_pos), | |
| 1195 | + GFP_KERNEL); | |
| 1196 | + sensor->tracking_slots = devm_kcalloc(&fn->dev, | |
| 1197 | + sensor->nbr_fingers, sizeof(int), GFP_KERNEL); | |
| 1198 | + sensor->objs = devm_kcalloc(&fn->dev, | |
| 1199 | + sensor->nbr_fingers, | |
| 1200 | + sizeof(struct rmi_2d_sensor_abs_object), | |
| 1195 | 1201 | GFP_KERNEL); |
| 1196 | − sensor->tracking_slots = devm_kzalloc(&fn->dev, | |
| 1197 | − sizeof(int) * sensor->nbr_fingers, GFP_KERNEL); | |
| 1198 | − sensor->objs = devm_kzalloc(&fn->dev, | |
| 1199 | − sizeof(struct rmi_2d_sensor_abs_object) | |
| 1200 | − * sensor->nbr_fingers, GFP_KERNEL); | |
| 1201 | 1202 | if (!sensor->tracking_pos || !sensor->tracking_slots || !sensor->objs) |
| 1202 | 1203 | return -ENOMEM; |
| 1203 | 1204 | |
| @@ -502,14 +502,15 @@ static int rmi_f12_probe(struct rmi_function *fn) · 501 unmodified lines | ||
| 502 | 502 | } |
| 503 | 503 | |
| 504 | 504 | /* allocate the in-kernel tracking buffers */ |
| 505 | − sensor->tracking_pos = devm_kzalloc(&fn->dev, | |
| 506 | − sizeof(struct input_mt_pos) * sensor->nbr_fingers, | |
| 505 | + sensor->tracking_pos = devm_kcalloc(&fn->dev, | |
| 506 | + sensor->nbr_fingers, sizeof(struct input_mt_pos), | |
| 507 | + GFP_KERNEL); | |
| 508 | + sensor->tracking_slots = devm_kcalloc(&fn->dev, | |
| 509 | + sensor->nbr_fingers, sizeof(int), GFP_KERNEL); | |
| 510 | + sensor->objs = devm_kcalloc(&fn->dev, | |
| 511 | + sensor->nbr_fingers, | |
| 512 | + sizeof(struct rmi_2d_sensor_abs_object), | |
| 507 | 513 | GFP_KERNEL); |
| 508 | − sensor->tracking_slots = devm_kzalloc(&fn->dev, | |
| 509 | − sizeof(int) * sensor->nbr_fingers, GFP_KERNEL); | |
| 510 | − sensor->objs = devm_kzalloc(&fn->dev, | |
| 511 | − sizeof(struct rmi_2d_sensor_abs_object) | |
| 512 | − * sensor->nbr_fingers, GFP_KERNEL); | |
| 513 | 514 | if (!sensor->tracking_pos || !sensor->tracking_slots || !sensor->objs) |
| 514 | 515 | return -ENOMEM; |
| 515 | 516 | |
| @@ -685,7 +685,7 @@ static int rmi_f54_probe(struct rmi_function *fn) · 684 unmodified lines | ||
| 685 | 685 | rx = f54->num_rx_electrodes; |
| 686 | 686 | tx = f54->num_tx_electrodes; |
| 687 | 687 | f54->report_data = devm_kzalloc(&fn->dev, |
| 688 | − sizeof(u16) * tx * rx, | |
| 688 | + array3_size(tx, rx, sizeof(u16)), | |
| 689 | 689 | GFP_KERNEL); |
| 690 | 690 | if (f54->report_data == NULL) |
| 691 | 691 | return -ENOMEM; |
| @@ -69,7 +69,7 @@ static int rmi_spi_manage_pools(struct rmi_spi_xport *rmi_spi, int len) · 68 unmodified lines | ||
| 69 | 69 | buf_size = RMI_SPI_XFER_SIZE_LIMIT; |
| 70 | 70 | |
| 71 | 71 | tmp = rmi_spi->rx_buf; |
| 72 | − buf = devm_kzalloc(&spi->dev, buf_size * 2, | |
| 72 | + buf = devm_kcalloc(&spi->dev, buf_size, 2, | |
| 73 | 73 | GFP_KERNEL | GFP_DMA); |
| 74 | 74 | if (!buf) |
| 75 | 75 | return -ENOMEM; |
| @@ -96,9 +96,10 @@ static int rmi_spi_manage_pools(struct rmi_spi_xport *rmi_spi, int len) · 20 unmodified lines | ||
| 96 | 96 | * per byte delays. |
| 97 | 97 | */ |
| 98 | 98 | tmp = rmi_spi->rx_xfers; |
| 99 | − xfer_buf = devm_kzalloc(&spi->dev, | |
| 100 | − (rmi_spi->rx_xfer_count + rmi_spi->tx_xfer_count) | |
| 101 | − * sizeof(struct spi_transfer), GFP_KERNEL); | |
| 99 | + xfer_buf = devm_kcalloc(&spi->dev, | |
| 100 | + rmi_spi->rx_xfer_count + rmi_spi->tx_xfer_count, | |
| 101 | + sizeof(struct spi_transfer), | |
| 102 | + GFP_KERNEL); | |
| 102 | 103 | if (!xfer_buf) |
| 103 | 104 | return -ENOMEM; |
| 104 | 105 | |
| @@ -2082,7 +2082,7 @@ static int arm_smmu_device_probe(struct platform_device *pdev) · 2081 unmodified lines | ||
| 2082 | 2082 | return -ENODEV; |
| 2083 | 2083 | } |
| 2084 | 2084 | |
| 2085 | − smmu->irqs = devm_kzalloc(dev, sizeof(*smmu->irqs) * num_irqs, | |
| 2085 | + smmu->irqs = devm_kcalloc(dev, num_irqs, sizeof(*smmu->irqs), | |
| 2086 | 2086 | GFP_KERNEL); |
| 2087 | 2087 | if (!smmu->irqs) { |
| 2088 | 2088 | dev_err(dev, "failed to allocate %d irqs\n", num_irqs); |
| @@ -1458,7 +1458,7 @@ int dmar_enable_qi(struct intel_iommu *iommu) · 1457 unmodified lines | ||
| 1458 | 1458 | |
| 1459 | 1459 | qi->desc = page_address(desc_page); |
| 1460 | 1460 | |
| 1461 | − qi->desc_status = kzalloc(QI_LENGTH * sizeof(int), GFP_ATOMIC); | |
| 1461 | + qi->desc_status = kcalloc(QI_LENGTH, sizeof(int), GFP_ATOMIC); | |
| 1462 | 1462 | if (!qi->desc_status) { |
| 1463 | 1463 | free_page((unsigned long) qi->desc); |
| 1464 | 1464 | kfree(qi); |
| @@ -3189,7 +3189,7 @@ static int copy_translation_tables(struct intel_iommu *iommu) · 3188 unmodified lines | ||
| 3189 | 3189 | /* This is too big for the stack - allocate it from slab */ |
| 3190 | 3190 | ctxt_table_entries = ext ? 512 : 256; |
| 3191 | 3191 | ret = -ENOMEM; |
| 3192 | − ctxt_tbls = kzalloc(ctxt_table_entries * sizeof(void *), GFP_KERNEL); | |
| 3192 | + ctxt_tbls = kcalloc(ctxt_table_entries, sizeof(void *), GFP_KERNEL); | |
| 3193 | 3193 | if (!ctxt_tbls) |
| 3194 | 3194 | goto out_unmap; |
| 3195 | 3195 | |
| @@ -4032,7 +4032,7 @@ static int iommu_suspend(void) · 836 unmodified lines | ||
| 4032 | 4032 | unsigned long flag; |
| 4033 | 4033 | |
| 4034 | 4034 | for_each_active_iommu(iommu, drhd) { |
| 4035 | − iommu->iommu_state = kzalloc(sizeof(u32) * MAX_SR_DMAR_REGS, | |
| 4035 | + iommu->iommu_state = kcalloc(MAX_SR_DMAR_REGS, sizeof(u32), | |
| 4036 | 4036 | GFP_ATOMIC); |
| 4037 | 4037 | if (!iommu->iommu_state) |
| 4038 | 4038 | goto nomem; |
| @@ -1455,7 +1455,7 @@ static int omap_iommu_add_device(struct device *dev) · 1454 unmodified lines | ||
| 1455 | 1455 | if (num_iommus < 0) |
| 1456 | 1456 | return 0; |
| 1457 | 1457 | |
| 1458 | − arch_data = kzalloc((num_iommus + 1) * sizeof(*arch_data), GFP_KERNEL); | |
| 1458 | + arch_data = kcalloc(num_iommus + 1, sizeof(*arch_data), GFP_KERNEL); | |
| 1459 | 1459 | if (!arch_data) |
| 1460 | 1460 | return -ENOMEM; |
| 1461 | 1461 | |
| @@ -1135,7 +1135,7 @@ static int rk_iommu_probe(struct platform_device *pdev) · 1134 unmodified lines | ||
| 1135 | 1135 | iommu->dev = dev; |
| 1136 | 1136 | iommu->num_mmu = 0; |
| 1137 | 1137 | |
| 1138 | − iommu->bases = devm_kzalloc(dev, sizeof(*iommu->bases) * num_res, | |
| 1138 | + iommu->bases = devm_kcalloc(dev, num_res, sizeof(*iommu->bases), | |
| 1139 | 1139 | GFP_KERNEL); |
| 1140 | 1140 | if (!iommu->bases) |
| 1141 | 1141 | return -ENOMEM; |
| @@ -465,7 +465,7 @@ static int tegra_gart_probe(struct platform_device *pdev) · 464 unmodified lines | ||
| 465 | 465 | gart->iovmm_base = (dma_addr_t)res_remap->start; |
| 466 | 466 | gart->page_count = (resource_size(res_remap) >> GART_PAGE_SHIFT); |
| 467 | 467 | |
| 468 | − gart->savedata = vmalloc(sizeof(u32) * gart->page_count); | |
| 468 | + gart->savedata = vmalloc(array_size(sizeof(u32), gart->page_count)); | |
| 469 | 469 | if (!gart->savedata) { |
| 470 | 470 | dev_err(dev, "failed to allocate context save area\n"); |
| 471 | 471 | return -ENOMEM; |
| @@ -457,8 +457,8 @@ static int tpci200_install(struct tpci200_board *tpci200) · 456 unmodified lines | ||
| 457 | 457 | { |
| 458 | 458 | int res; |
| 459 | 459 | |
| 460 | − tpci200->slots = kzalloc( | |
| 461 | − TPCI200_NB_SLOT * sizeof(struct tpci200_slot), GFP_KERNEL); | |
| 460 | + tpci200->slots = kcalloc(TPCI200_NB_SLOT, sizeof(struct tpci200_slot), | |
| 461 | + GFP_KERNEL); | |
| 462 | 462 | if (tpci200->slots == NULL) |
| 463 | 463 | return -ENOMEM; |
| 464 | 464 | |
| @@ -268,7 +268,8 @@ static int alpine_msix_init(struct device_node *node, · 267 unmodified lines | ||
| 268 | 268 | goto err_priv; |
| 269 | 269 | } |
| 270 | 270 | |
| 271 | − priv->msi_map = kzalloc(sizeof(*priv->msi_map) * BITS_TO_LONGS(priv->num_spis), | |
| 271 | + priv->msi_map = kcalloc(BITS_TO_LONGS(priv->num_spis), | |
| 272 | + sizeof(*priv->msi_map), | |
| 272 | 273 | GFP_KERNEL); |
| 273 | 274 | if (!priv->msi_map) { |
| 274 | 275 | ret = -ENOMEM; |
| @@ -361,7 +361,7 @@ static int __init gicv2m_init_one(struct fwnode_handle *fwnode, · 360 unmodified lines | ||
| 361 | 361 | break; |
| 362 | 362 | } |
| 363 | 363 | |
| 364 | − v2m->bm = kzalloc(sizeof(long) * BITS_TO_LONGS(v2m->nr_spis), | |
| 364 | + v2m->bm = kcalloc(BITS_TO_LONGS(v2m->nr_spis), sizeof(long), | |
| 365 | 365 | GFP_KERNEL); |
| 366 | 366 | if (!v2m->bm) { |
| 367 | 367 | ret = -ENOMEM; |
| @@ -1239,7 +1239,7 @@ static int its_vlpi_map(struct irq_data *d, struct its_cmd_info *info) · 1238 unmodified lines | ||
| 1239 | 1239 | if (!its_dev->event_map.vm) { |
| 1240 | 1240 | struct its_vlpi_map *maps; |
| 1241 | 1241 | |
| 1242 | − maps = kzalloc(sizeof(*maps) * its_dev->event_map.nr_lpis, | |
| 1242 | + maps = kcalloc(its_dev->event_map.nr_lpis, sizeof(*maps), | |
| 1243 | 1243 | GFP_KERNEL); |
| 1244 | 1244 | if (!maps) { |
| 1245 | 1245 | ret = -ENOMEM; |
| @@ -1437,7 +1437,7 @@ static int __init its_lpi_init(u32 id_bits) · 191 unmodified lines | ||
| 1437 | 1437 | { |
| 1438 | 1438 | lpi_chunks = its_lpi_to_chunk(1UL << id_bits); |
| 1439 | 1439 | |
| 1440 | − lpi_bitmap = kzalloc(BITS_TO_LONGS(lpi_chunks) * sizeof(long), | |
| 1440 | + lpi_bitmap = kcalloc(BITS_TO_LONGS(lpi_chunks), sizeof(long), | |
| 1441 | 1441 | GFP_KERNEL); |
| 1442 | 1442 | if (!lpi_bitmap) { |
| 1443 | 1443 | lpi_chunks = 0; |
| @@ -1471,7 +1471,8 @@ static unsigned long *its_lpi_alloc_chunks(int nr_irqs, int *base, int *nr_ids) · 27 unmodified lines | ||
| 1471 | 1471 | if (!nr_chunks) |
| 1472 | 1472 | goto out; |
| 1473 | 1473 | |
| 1474 | − bitmap = kzalloc(BITS_TO_LONGS(nr_chunks * IRQS_PER_CHUNK) * sizeof (long), | |
| 1474 | + bitmap = kcalloc(BITS_TO_LONGS(nr_chunks * IRQS_PER_CHUNK), | |
| 1475 | + sizeof(long), | |
| 1475 | 1476 | GFP_ATOMIC); |
| 1476 | 1477 | if (!bitmap) |
| 1477 | 1478 | goto out; |
| @@ -1823,7 +1824,7 @@ static int its_alloc_tables(struct its_node *its) · 345 unmodified lines | ||
| 1823 | 1824 | |
| 1824 | 1825 | static int its_alloc_collections(struct its_node *its) |
| 1825 | 1826 | { |
| 1826 | − its->collections = kzalloc(nr_cpu_ids * sizeof(*its->collections), | |
| 1827 | + its->collections = kcalloc(nr_cpu_ids, sizeof(*its->collections), | |
| 1827 | 1828 | GFP_KERNEL); |
| 1828 | 1829 | if (!its->collections) |
| 1829 | 1830 | return -ENOMEM; |
| @@ -2124,10 +2125,10 @@ static struct its_device *its_create_device(struct its_node *its, u32 dev_id, · 294 unmodified lines | ||
| 2124 | 2125 | if (alloc_lpis) { |
| 2125 | 2126 | lpi_map = its_lpi_alloc_chunks(nvecs, &lpi_base, &nr_lpis); |
| 2126 | 2127 | if (lpi_map) |
| 2127 | − col_map = kzalloc(sizeof(*col_map) * nr_lpis, | |
| 2128 | + col_map = kcalloc(nr_lpis, sizeof(*col_map), | |
| 2128 | 2129 | GFP_KERNEL); |
| 2129 | 2130 | } else { |
| 2130 | − col_map = kzalloc(sizeof(*col_map) * nr_ites, GFP_KERNEL); | |
| 2131 | + col_map = kcalloc(nr_ites, sizeof(*col_map), GFP_KERNEL); | |
| 2131 | 2132 | nr_lpis = 0; |
| 2132 | 2133 | lpi_base = 0; |
| 2133 | 2134 | } |
| @@ -3183,7 +3184,7 @@ static int its_init_vpe_domain(void) · 1049 unmodified lines | ||
| 3183 | 3184 | its = list_first_entry(&its_nodes, struct its_node, entry); |
| 3184 | 3185 | |
| 3185 | 3186 | entries = roundup_pow_of_two(nr_cpu_ids); |
| 3186 | − vpe_proxy.vpes = kzalloc(sizeof(*vpe_proxy.vpes) * entries, | |
| 3187 | + vpe_proxy.vpes = kcalloc(entries, sizeof(*vpe_proxy.vpes), | |
| 3187 | 3188 | GFP_KERNEL); |
| 3188 | 3189 | if (!vpe_proxy.vpes) { |
| 3189 | 3190 | pr_err("ITS: Can't allocate GICv4 proxy device array\n"); |
| @@ -3567,8 +3568,8 @@ static void __init acpi_table_parse_srat_its(void) · 377 unmodified lines | ||
| 3567 | 3568 | if (count <= 0) |
| 3568 | 3569 | return; |
| 3569 | 3570 | |
| 3570 | − its_srat_maps = kmalloc(count * sizeof(struct its_srat_map), | |
| 3571 | − GFP_KERNEL); | |
| 3571 | + its_srat_maps = kmalloc_array(count, sizeof(struct its_srat_map), | |
| 3572 | + GFP_KERNEL); | |
| 3572 | 3573 | if (!its_srat_maps) { |
| 3573 | 3574 | pr_warn("SRAT: Failed to allocate memory for its_srat_maps!\n"); |
| 3574 | 3575 | return; |
| @@ -1167,7 +1167,7 @@ static void __init gic_populate_ppi_partitions(struct device_node *gic_node) · 1166 unmodified lines | ||
| 1167 | 1167 | if (!nr_parts) |
| 1168 | 1168 | goto out_put_node; |
| 1169 | 1169 | |
| 1170 | − parts = kzalloc(sizeof(*parts) * nr_parts, GFP_KERNEL); | |
| 1170 | + parts = kcalloc(nr_parts, sizeof(*parts), GFP_KERNEL); | |
| 1171 | 1171 | if (WARN_ON(!parts)) |
| 1172 | 1172 | goto out_put_node; |
| 1173 | 1173 | |
| @@ -1289,7 +1289,8 @@ static int __init gic_of_init(struct device_node *node, struct device_node *pare · 115 unmodified lines | ||
| 1289 | 1289 | if (of_property_read_u32(node, "#redistributor-regions", &nr_redist_regions)) |
| 1290 | 1290 | nr_redist_regions = 1; |
| 1291 | 1291 | |
| 1292 | − rdist_regs = kzalloc(sizeof(*rdist_regs) * nr_redist_regions, GFP_KERNEL); | |
| 1292 | + rdist_regs = kcalloc(nr_redist_regions, sizeof(*rdist_regs), | |
| 1293 | + GFP_KERNEL); | |
| 1293 | 1294 | if (!rdist_regs) { |
| 1294 | 1295 | err = -ENOMEM; |
| 1295 | 1296 | goto out_unmap_dist; |
| @@ -354,7 +354,7 @@ static int pdc_intc_probe(struct platform_device *pdev) · 353 unmodified lines | ||
| 354 | 354 | priv->nr_syswakes = val; |
| 355 | 355 | |
| 356 | 356 | /* Get peripheral IRQ numbers */ |
| 357 | − priv->perip_irqs = devm_kzalloc(&pdev->dev, 4 * priv->nr_perips, | |
| 357 | + priv->perip_irqs = devm_kcalloc(&pdev->dev, 4, priv->nr_perips, | |
| 358 | 358 | GFP_KERNEL); |
| 359 | 359 | if (!priv->perip_irqs) { |
| 360 | 360 | dev_err(&pdev->dev, "cannot allocate perip IRQ list\n"); |
| @@ -191,8 +191,8 @@ static int mvebu_gicp_probe(struct platform_device *pdev) · 190 unmodified lines | ||
| 191 | 191 | gicp->spi_ranges_cnt = ret / 2; |
| 192 | 192 | |
| 193 | 193 | gicp->spi_ranges = |
| 194 | − devm_kzalloc(&pdev->dev, | |
| 195 | − gicp->spi_ranges_cnt * | |
| 194 | + devm_kcalloc(&pdev->dev, | |
| 195 | + gicp->spi_ranges_cnt, | |
| 196 | 196 | sizeof(struct mvebu_gicp_spi_range), |
| 197 | 197 | GFP_KERNEL); |
| 198 | 198 | if (!gicp->spi_ranges) |
| @@ -210,8 +210,8 @@ static int mvebu_gicp_probe(struct platform_device *pdev) · 11 unmodified lines | ||
| 210 | 210 | gicp->spi_cnt += gicp->spi_ranges[i].count; |
| 211 | 211 | } |
| 212 | 212 | |
| 213 | − gicp->spi_bitmap = devm_kzalloc(&pdev->dev, | |
| 214 | − BITS_TO_LONGS(gicp->spi_cnt) * sizeof(long), | |
| 213 | + gicp->spi_bitmap = devm_kcalloc(&pdev->dev, | |
| 214 | + BITS_TO_LONGS(gicp->spi_cnt), sizeof(long), | |
| 215 | 215 | GFP_KERNEL); |
| 216 | 216 | if (!gicp->spi_bitmap) |
| 217 | 217 | return -ENOMEM; |
| @@ -229,7 +229,7 @@ struct partition_desc *partition_create_desc(struct fwnode_handle *fwnode, · 228 unmodified lines | ||
| 229 | 229 | goto out; |
| 230 | 230 | desc->domain = d; |
| 231 | 231 | |
| 232 | − desc->bitmap = kzalloc(sizeof(long) * BITS_TO_LONGS(nr_parts), | |
| 232 | + desc->bitmap = kcalloc(BITS_TO_LONGS(nr_parts), sizeof(long), | |
| 233 | 233 | GFP_KERNEL); |
| 234 | 234 | if (WARN_ON(!desc->bitmap)) |
| 235 | 235 | goto out; |
| @@ -1261,7 +1261,7 @@ static int __init s3c_init_intc_of(struct device_node *np, · 1260 unmodified lines | ||
| 1261 | 1261 | return -ENOMEM; |
| 1262 | 1262 | |
| 1263 | 1263 | intc->domain = domain; |
| 1264 | − intc->irqs = kzalloc(sizeof(struct s3c_irq_data) * 32, | |
| 1264 | + intc->irqs = kcalloc(32, sizeof(struct s3c_irq_data), | |
| 1265 | 1265 | GFP_KERNEL); |
| 1266 | 1266 | if (!intc->irqs) { |
| 1267 | 1267 | kfree(intc); |
| @@ -1260,7 +1260,7 @@ static int __init capinc_tty_init(void) · 1259 unmodified lines | ||
| 1260 | 1260 | if (capi_ttyminors <= 0) |
| 1261 | 1261 | capi_ttyminors = CAPINC_NR_PORTS; |
| 1262 | 1262 | |
| 1263 | − capiminors = kzalloc(sizeof(struct capiminor *) * capi_ttyminors, | |
| 1263 | + capiminors = kcalloc(capi_ttyminors, sizeof(struct capiminor *), | |
| 1264 | 1264 | GFP_KERNEL); |
| 1265 | 1265 | if (!capiminors) |
| 1266 | 1266 | return -ENOMEM; |
| @@ -2268,7 +2268,8 @@ static int capidrv_addcontr(u16 contr, struct capi_profile *profp) · 2267 unmodified lines | ||
| 2268 | 2268 | strcpy(card->name, id); |
| 2269 | 2269 | card->contrnr = contr; |
| 2270 | 2270 | card->nbchan = profp->nbchannel; |
| 2271 | − card->bchans = kmalloc(sizeof(capidrv_bchan) * card->nbchan, GFP_ATOMIC); | |
| 2271 | + card->bchans = kmalloc_array(card->nbchan, sizeof(capidrv_bchan), | |
| 2272 | + GFP_ATOMIC); | |
| 2272 | 2273 | if (!card->bchans) { |
| 2273 | 2274 | printk(KERN_WARNING |
| 2274 | 2275 | "capidrv: (%s) Could not allocate bchan-structs.\n", id); |
| @@ -252,7 +252,7 @@ static inline void dump_rawmsg(enum debuglevel level, const char *tag, · 251 unmodified lines | ||
| 252 | 252 | return; |
| 253 | 253 | if (l > 64) |
| 254 | 254 | l = 64; /* arbitrary limit */ |
| 255 | − dbgline = kmalloc(3 * l, GFP_ATOMIC); | |
| 255 | + dbgline = kmalloc_array(3, l, GFP_ATOMIC); | |
| 256 | 256 | if (!dbgline) |
| 257 | 257 | return; |
| 258 | 258 | for (i = 0; i < l; i++) { |
| @@ -272,7 +272,7 @@ static inline void dump_rawmsg(enum debuglevel level, const char *tag, · 13 unmodified lines | ||
| 272 | 272 | return; |
| 273 | 273 | if (l > 64) |
| 274 | 274 | l = 64; /* arbitrary limit */ |
| 275 | − dbgline = kmalloc(3 * l, GFP_ATOMIC); | |
| 275 | + dbgline = kmalloc_array(3, l, GFP_ATOMIC); | |
| 276 | 276 | if (!dbgline) |
| 277 | 277 | return; |
| 278 | 278 | data += CAPIMSG_LEN(data); |
| @@ -1370,7 +1370,7 @@ static void do_connect_req(struct gigaset_capi_ctr *iif, · 1091 unmodified lines | ||
| 1370 | 1370 | cmsg->adr.adrPLCI |= (bcs->channel + 1) << 8; |
| 1371 | 1371 | |
| 1372 | 1372 | /* build command table */ |
| 1373 | − commands = kzalloc(AT_NUM * (sizeof *commands), GFP_KERNEL); | |
| 1373 | + commands = kcalloc(AT_NUM, sizeof(*commands), GFP_KERNEL); | |
| 1374 | 1374 | if (!commands) |
| 1375 | 1375 | goto oom; |
| 1376 | 1376 | |
| @@ -710,7 +710,7 @@ struct cardstate *gigaset_initcs(struct gigaset_driver *drv, int channels, · 709 unmodified lines | ||
| 710 | 710 | cs->mode = M_UNKNOWN; |
| 711 | 711 | cs->mstate = MS_UNINITIALIZED; |
| 712 | 712 | |
| 713 | − cs->bcs = kmalloc(channels * sizeof(struct bc_state), GFP_KERNEL); | |
| 713 | + cs->bcs = kmalloc_array(channels, sizeof(struct bc_state), GFP_KERNEL); | |
| 714 | 714 | cs->inbuf = kmalloc(sizeof(struct inbuf_t), GFP_KERNEL); |
| 715 | 715 | if (!cs->bcs || !cs->inbuf) { |
| 716 | 716 | pr_err("out of memory\n"); |
| @@ -1089,7 +1089,7 @@ struct gigaset_driver *gigaset_initdriver(unsigned minor, unsigned minors, · 372 unmodified lines | ||
| 1089 | 1089 | drv->owner = owner; |
| 1090 | 1090 | INIT_LIST_HEAD(&drv->list); |
| 1091 | 1091 | |
| 1092 | − drv->cs = kmalloc(minors * sizeof *drv->cs, GFP_KERNEL); | |
| 1092 | + drv->cs = kmalloc_array(minors, sizeof(*drv->cs), GFP_KERNEL); | |
| 1093 | 1093 | if (!drv->cs) |
| 1094 | 1094 | goto error; |
| 1095 | 1095 | |
| @@ -243,7 +243,7 @@ static int command_from_LL(isdn_ctrl *cntrl) · 242 unmodified lines | ||
| 243 | 243 | dev_kfree_skb(bcs->rx_skb); |
| 244 | 244 | gigaset_new_rx_skb(bcs); |
| 245 | 245 | |
| 246 | − commands = kzalloc(AT_NUM * (sizeof *commands), GFP_ATOMIC); | |
| 246 | + commands = kcalloc(AT_NUM, sizeof(*commands), GFP_ATOMIC); | |
| 247 | 247 | if (!commands) { |
| 248 | 248 | gigaset_free_channel(bcs); |
| 249 | 249 | dev_err(cs->dev, "ISDN_CMD_DIAL: out of memory\n"); |
| @@ -72,7 +72,7 @@ avmcard *b1_alloc_card(int nr_controllers) · 71 unmodified lines | ||
| 72 | 72 | if (!card) |
| 73 | 73 | return NULL; |
| 74 | 74 | |
| 75 | − cinfo = kzalloc(sizeof(*cinfo) * nr_controllers, GFP_KERNEL); | |
| 75 | + cinfo = kcalloc(nr_controllers, sizeof(*cinfo), GFP_KERNEL); | |
| 76 | 76 | if (!cinfo) { |
| 77 | 77 | kfree(card); |
| 78 | 78 | return NULL; |
| @@ -27,7 +27,9 @@ FsmNew(struct Fsm *fsm, struct FsmNode *fnlist, int fncount) · 26 unmodified lines | ||
| 27 | 27 | int i; |
| 28 | 28 | |
| 29 | 29 | fsm->jumpmatrix = |
| 30 | − kzalloc(sizeof(FSMFNPTR) * fsm->state_count * fsm->event_count, GFP_KERNEL); | |
| 30 | + kzalloc(array3_size(sizeof(FSMFNPTR), fsm->state_count, | |
| 31 | + fsm->event_count), | |
| 32 | + GFP_KERNEL); | |
| 31 | 33 | if (!fsm->jumpmatrix) |
| 32 | 34 | return -ENOMEM; |
| 33 | 35 | |
| @@ -1024,7 +1024,7 @@ static unsigned int · 1023 unmodified lines | ||
| 1024 | 1024 | int i; |
| 1025 | 1025 | unsigned *send; |
| 1026 | 1026 | |
| 1027 | − if (!(send = kmalloc(cnt * sizeof(unsigned int), GFP_ATOMIC))) { | |
| 1027 | + if (!(send = kmalloc_array(cnt, sizeof(unsigned int), GFP_ATOMIC))) { | |
| 1028 | 1028 | printk(KERN_WARNING |
| 1029 | 1029 | "HiSax: No memory for hfcd.send\n"); |
| 1030 | 1030 | return (NULL); |
| @@ -557,7 +557,8 @@ init_send(struct BCState *bcs) · 556 unmodified lines | ||
| 557 | 557 | { |
| 558 | 558 | int i; |
| 559 | 559 | |
| 560 | − if (!(bcs->hw.hfc.send = kmalloc(32 * sizeof(unsigned int), GFP_ATOMIC))) { | |
| 560 | + bcs->hw.hfc.send = kmalloc_array(32, sizeof(unsigned int), GFP_ATOMIC); | |
| 561 | + if (!bcs->hw.hfc.send) { | |
| 561 | 562 | printk(KERN_WARNING |
| 562 | 563 | "HiSax: No memory for hfc.send\n"); |
| 563 | 564 | return; |
| @@ -912,8 +912,10 @@ setstack_tiger(struct PStack *st, struct BCState *bcs) · 911 unmodified lines | ||
| 912 | 912 | void |
| 913 | 913 | inittiger(struct IsdnCardState *cs) |
| 914 | 914 | { |
| 915 | − if (!(cs->bcs[0].hw.tiger.send = kmalloc(NETJET_DMA_TXSIZE * sizeof(unsigned int), | |
| 916 | − GFP_KERNEL | GFP_DMA))) { | |
| 915 | + cs->bcs[0].hw.tiger.send = kmalloc_array(NETJET_DMA_TXSIZE, | |
| 916 | + sizeof(unsigned int), | |
| 917 | + GFP_KERNEL | GFP_DMA); | |
| 918 | + if (!cs->bcs[0].hw.tiger.send) { | |
| 917 | 919 | printk(KERN_WARNING |
| 918 | 920 | "HiSax: No memory for tiger.send\n"); |
| 919 | 921 | return; |
| @@ -933,8 +935,10 @@ inittiger(struct IsdnCardState *cs) · 13 unmodified lines | ||
| 933 | 935 | cs->hw.njet.base + NETJET_DMA_READ_IRQ); |
| 934 | 936 | outl(virt_to_bus(cs->bcs[0].hw.tiger.s_end), |
| 935 | 937 | cs->hw.njet.base + NETJET_DMA_READ_END); |
| 936 | − if (!(cs->bcs[0].hw.tiger.rec = kmalloc(NETJET_DMA_RXSIZE * sizeof(unsigned int), | |
| 937 | − GFP_KERNEL | GFP_DMA))) { | |
| 938 | + cs->bcs[0].hw.tiger.rec = kmalloc_array(NETJET_DMA_RXSIZE, | |
| 939 | + sizeof(unsigned int), | |
| 940 | + GFP_KERNEL | GFP_DMA); | |
| 941 | + if (!cs->bcs[0].hw.tiger.rec) { | |
| 938 | 942 | printk(KERN_WARNING |
| 939 | 943 | "HiSax: No memory for tiger.rec\n"); |
| 940 | 944 | return; |
| @@ -340,7 +340,7 @@ static void *bsd_alloc(struct isdn_ppp_comp_data *data) · 339 unmodified lines | ||
| 340 | 340 | * Allocate space for the dictionary. This may be more than one page in |
| 341 | 341 | * length. |
| 342 | 342 | */ |
| 343 | − db->dict = vmalloc(hsize * sizeof(struct bsd_dict)); | |
| 343 | + db->dict = vmalloc(array_size(hsize, sizeof(struct bsd_dict))); | |
| 344 | 344 | if (!db->dict) { |
| 345 | 345 | bsd_free(db); |
| 346 | 346 | return NULL; |
| @@ -353,7 +353,8 @@ static void *bsd_alloc(struct isdn_ppp_comp_data *data) · 6 unmodified lines | ||
| 353 | 353 | if (!decomp) |
| 354 | 354 | db->lens = NULL; |
| 355 | 355 | else { |
| 356 | − db->lens = vmalloc((maxmaxcode + 1) * sizeof(db->lens[0])); | |
| 356 | + db->lens = vmalloc(array_size(sizeof(db->lens[0]), | |
| 357 | + maxmaxcode + 1)); | |
| 357 | 358 | if (!db->lens) { |
| 358 | 359 | bsd_free(db); |
| 359 | 360 | return (NULL); |
| @@ -2070,14 +2070,14 @@ isdn_add_channels(isdn_driver_t *d, int drvidx, int n, int adding) · 2069 unmodified lines | ||
| 2070 | 2070 | |
| 2071 | 2071 | if ((adding) && (d->rcverr)) |
| 2072 | 2072 | kfree(d->rcverr); |
| 2073 | − if (!(d->rcverr = kzalloc(sizeof(int) * m, GFP_ATOMIC))) { | |
| 2073 | + if (!(d->rcverr = kcalloc(m, sizeof(int), GFP_ATOMIC))) { | |
| 2074 | 2074 | printk(KERN_WARNING "register_isdn: Could not alloc rcverr\n"); |
| 2075 | 2075 | return -1; |
| 2076 | 2076 | } |
| 2077 | 2077 | |
| 2078 | 2078 | if ((adding) && (d->rcvcount)) |
| 2079 | 2079 | kfree(d->rcvcount); |
| 2080 | − if (!(d->rcvcount = kzalloc(sizeof(int) * m, GFP_ATOMIC))) { | |
| 2080 | + if (!(d->rcvcount = kcalloc(m, sizeof(int), GFP_ATOMIC))) { | |
| 2081 | 2081 | printk(KERN_WARNING "register_isdn: Could not alloc rcvcount\n"); |
| 2082 | 2082 | if (!adding) |
| 2083 | 2083 | kfree(d->rcverr); |
| @@ -2089,7 +2089,8 @@ isdn_add_channels(isdn_driver_t *d, int drvidx, int n, int adding) · 5 unmodified lines | ||
| 2089 | 2089 | skb_queue_purge(&d->rpqueue[j]); |
| 2090 | 2090 | kfree(d->rpqueue); |
| 2091 | 2091 | } |
| 2092 | − if (!(d->rpqueue = kmalloc(sizeof(struct sk_buff_head) * m, GFP_ATOMIC))) { | |
| 2092 | + d->rpqueue = kmalloc_array(m, sizeof(struct sk_buff_head), GFP_ATOMIC); | |
| 2093 | + if (!d->rpqueue) { | |
| 2093 | 2094 | printk(KERN_WARNING "register_isdn: Could not alloc rpqueue\n"); |
| 2094 | 2095 | if (!adding) { |
| 2095 | 2096 | kfree(d->rcvcount); |
| @@ -2103,7 +2104,8 @@ isdn_add_channels(isdn_driver_t *d, int drvidx, int n, int adding) · 7 unmodified lines | ||
| 2103 | 2104 | |
| 2104 | 2105 | if ((adding) && (d->rcv_waitq)) |
| 2105 | 2106 | kfree(d->rcv_waitq); |
| 2106 | − d->rcv_waitq = kmalloc(sizeof(wait_queue_head_t) * 2 * m, GFP_ATOMIC); | |
| 2107 | + d->rcv_waitq = kmalloc(array3_size(sizeof(wait_queue_head_t), 2, m), | |
| 2108 | + GFP_ATOMIC); | |
| 2107 | 2109 | if (!d->rcv_waitq) { |
| 2108 | 2110 | printk(KERN_WARNING "register_isdn: Could not alloc rcv_waitq\n"); |
| 2109 | 2111 | if (!adding) { |
| @@ -32,8 +32,10 @@ mISDN_FsmNew(struct Fsm *fsm, · 31 unmodified lines | ||
| 32 | 32 | { |
| 33 | 33 | int i; |
| 34 | 34 | |
| 35 | − fsm->jumpmatrix = kzalloc(sizeof(FSMFNPTR) * fsm->state_count * | |
| 36 | − fsm->event_count, GFP_KERNEL); | |
| 35 | + fsm->jumpmatrix = | |
| 36 | + kzalloc(array3_size(sizeof(FSMFNPTR), fsm->state_count, | |
| 37 | + fsm->event_count), | |
| 38 | + GFP_KERNEL); | |
| 37 | 39 | if (fsm->jumpmatrix == NULL) |
| 38 | 40 | return -ENOMEM; |
| 39 | 41 | |
| @@ -108,7 +108,7 @@ static int adp5520_led_probe(struct platform_device *pdev) · 107 unmodified lines | ||
| 108 | 108 | return -EFAULT; |
| 109 | 109 | } |
| 110 | 110 | |
| 111 | − led = devm_kzalloc(&pdev->dev, sizeof(*led) * pdata->num_leds, | |
| 111 | + led = devm_kcalloc(&pdev->dev, pdata->num_leds, sizeof(*led), | |
| 112 | 112 | GFP_KERNEL); |
| 113 | 113 | if (!led) |
| 114 | 114 | return -ENOMEM; |
| @@ -171,8 +171,8 @@ static int apu_led_config(struct device *dev, struct apu_led_pdata *apuld) · 170 unmodified lines | ||
| 171 | 171 | int i; |
| 172 | 172 | int err; |
| 173 | 173 | |
| 174 | − apu_led->pled = devm_kzalloc(dev, | |
| 175 | − sizeof(struct apu_led_priv) * apu_led->num_led_instances, | |
| 174 | + apu_led->pled = devm_kcalloc(dev, | |
| 175 | + apu_led->num_led_instances, sizeof(struct apu_led_priv), | |
| 176 | 176 | GFP_KERNEL); |
| 177 | 177 | |
| 178 | 178 | if (!apu_led->pled) |
| @@ -237,8 +237,7 @@ static int cr0014114_probe(struct spi_device *spi) · 236 unmodified lines | ||
| 237 | 237 | return -ENODEV; |
| 238 | 238 | } |
| 239 | 239 | |
| 240 | − priv = devm_kzalloc(&spi->dev, | |
| 241 | − sizeof(*priv) + sizeof(*priv->leds) * count, | |
| 240 | + priv = devm_kzalloc(&spi->dev, struct_size(priv, leds, count), | |
| 242 | 241 | GFP_KERNEL); |
| 243 | 242 | if (!priv) |
| 244 | 243 | return -ENOMEM; |
| @@ -113,8 +113,8 @@ static int da9052_led_probe(struct platform_device *pdev) · 112 unmodified lines | ||
| 113 | 113 | goto err; |
| 114 | 114 | } |
| 115 | 115 | |
| 116 | − led = devm_kzalloc(&pdev->dev, | |
| 117 | − sizeof(struct da9052_led) * pled->num_leds, | |
| 116 | + led = devm_kcalloc(&pdev->dev, | |
| 117 | + pled->num_leds, sizeof(struct da9052_led), | |
| 118 | 118 | GFP_KERNEL); |
| 119 | 119 | if (!led) { |
| 120 | 120 | error = -ENOMEM; |
| @@ -533,8 +533,8 @@ static int lp5521_probe(struct i2c_client *client, · 532 unmodified lines | ||
| 533 | 533 | if (!chip) |
| 534 | 534 | return -ENOMEM; |
| 535 | 535 | |
| 536 | − led = devm_kzalloc(&client->dev, | |
| 537 | − sizeof(*led) * pdata->num_channels, GFP_KERNEL); | |
| 536 | + led = devm_kcalloc(&client->dev, | |
| 537 | + pdata->num_channels, sizeof(*led), GFP_KERNEL); | |
| 538 | 538 | if (!led) |
| 539 | 539 | return -ENOMEM; |
| 540 | 540 | |
| @@ -898,8 +898,8 @@ static int lp5523_probe(struct i2c_client *client, · 897 unmodified lines | ||
| 898 | 898 | if (!chip) |
| 899 | 899 | return -ENOMEM; |
| 900 | 900 | |
| 901 | − led = devm_kzalloc(&client->dev, | |
| 902 | − sizeof(*led) * pdata->num_channels, GFP_KERNEL); | |
| 901 | + led = devm_kcalloc(&client->dev, | |
| 902 | + pdata->num_channels, sizeof(*led), GFP_KERNEL); | |
| 903 | 903 | if (!led) |
| 904 | 904 | return -ENOMEM; |
| 905 | 905 | |
| @@ -534,8 +534,8 @@ static int lp5562_probe(struct i2c_client *client, · 533 unmodified lines | ||
| 534 | 534 | if (!chip) |
| 535 | 535 | return -ENOMEM; |
| 536 | 536 | |
| 537 | − led = devm_kzalloc(&client->dev, | |
| 538 | − sizeof(*led) * pdata->num_channels, GFP_KERNEL); | |
| 537 | + led = devm_kcalloc(&client->dev, | |
| 538 | + pdata->num_channels, sizeof(*led), GFP_KERNEL); | |
| 539 | 539 | if (!led) |
| 540 | 540 | return -ENOMEM; |
| 541 | 541 | |
| @@ -560,7 +560,7 @@ struct lp55xx_platform_data *lp55xx_of_populate_pdata(struct device *dev, · 559 unmodified lines | ||
| 560 | 560 | return ERR_PTR(-EINVAL); |
| 561 | 561 | } |
| 562 | 562 | |
| 563 | − cfg = devm_kzalloc(dev, sizeof(*cfg) * num_channels, GFP_KERNEL); | |
| 563 | + cfg = devm_kcalloc(dev, num_channels, sizeof(*cfg), GFP_KERNEL); | |
| 564 | 564 | if (!cfg) |
| 565 | 565 | return ERR_PTR(-ENOMEM); |
| 566 | 566 | |
| @@ -327,8 +327,8 @@ static int lp8501_probe(struct i2c_client *client, · 326 unmodified lines | ||
| 327 | 327 | if (!chip) |
| 328 | 328 | return -ENOMEM; |
| 329 | 329 | |
| 330 | − led = devm_kzalloc(&client->dev, | |
| 331 | − sizeof(*led) * pdata->num_channels, GFP_KERNEL); | |
| 330 | + led = devm_kcalloc(&client->dev, | |
| 331 | + pdata->num_channels, sizeof(*led), GFP_KERNEL); | |
| 332 | 332 | if (!led) |
| 333 | 333 | return -ENOMEM; |
| 334 | 334 | |
| @@ -128,8 +128,8 @@ static int lt3593_led_probe(struct platform_device *pdev) · 127 unmodified lines | ||
| 128 | 128 | if (!pdata) |
| 129 | 129 | return -EBUSY; |
| 130 | 130 | |
| 131 | − leds_data = devm_kzalloc(&pdev->dev, | |
| 132 | − sizeof(struct lt3593_led_data) * pdata->num_leds, | |
| 131 | + leds_data = devm_kcalloc(&pdev->dev, | |
| 132 | + pdata->num_leds, sizeof(struct lt3593_led_data), | |
| 133 | 133 | GFP_KERNEL); |
| 134 | 134 | if (!leds_data) |
| 135 | 135 | return -ENOMEM; |
| @@ -136,7 +136,7 @@ static struct mc13xxx_leds_platform_data __init *mc13xxx_led_probe_dt( · 135 unmodified lines | ||
| 136 | 136 | |
| 137 | 137 | pdata->num_leds = of_get_child_count(parent); |
| 138 | 138 | |
| 139 | − pdata->led = devm_kzalloc(dev, pdata->num_leds * sizeof(*pdata->led), | |
| 139 | + pdata->led = devm_kcalloc(dev, pdata->num_leds, sizeof(*pdata->led), | |
| 140 | 140 | GFP_KERNEL); |
| 141 | 141 | if (!pdata->led) { |
| 142 | 142 | ret = -ENOMEM; |
| @@ -210,7 +210,7 @@ static int __init mc13xxx_led_probe(struct platform_device *pdev) · 67 unmodified lines | ||
| 210 | 210 | return -EINVAL; |
| 211 | 211 | } |
| 212 | 212 | |
| 213 | − leds->led = devm_kzalloc(dev, leds->num_leds * sizeof(*leds->led), | |
| 213 | + leds->led = devm_kcalloc(dev, leds->num_leds, sizeof(*leds->led), | |
| 214 | 214 | GFP_KERNEL); |
| 215 | 215 | if (!leds->led) |
| 216 | 216 | return -ENOMEM; |
| @@ -329,8 +329,10 @@ static int mlxcpld_led_config(struct device *dev, · 328 unmodified lines | ||
| 329 | 329 | int i; |
| 330 | 330 | int err; |
| 331 | 331 | |
| 332 | − cpld->pled = devm_kzalloc(dev, sizeof(struct mlxcpld_led_priv) * | |
| 333 | − cpld->num_led_instances, GFP_KERNEL); | |
| 332 | + cpld->pled = devm_kcalloc(dev, | |
| 333 | + cpld->num_led_instances, | |
| 334 | + sizeof(struct mlxcpld_led_priv), | |
| 335 | + GFP_KERNEL); | |
| 334 | 336 | if (!cpld->pled) |
| 335 | 337 | return -ENOMEM; |
| 336 | 338 | |
| @@ -335,7 +335,7 @@ static int gpio_ext_get_of_pdata(struct device *dev, struct device_node *np, · 334 unmodified lines | ||
| 335 | 335 | return ret; |
| 336 | 336 | } |
| 337 | 337 | num_addr = ret; |
| 338 | − addr = devm_kzalloc(dev, num_addr * sizeof(*addr), GFP_KERNEL); | |
| 338 | + addr = devm_kcalloc(dev, num_addr, sizeof(*addr), GFP_KERNEL); | |
| 339 | 339 | if (!addr) |
| 340 | 340 | return -ENOMEM; |
| 341 | 341 | |
| @@ -355,7 +355,7 @@ static int gpio_ext_get_of_pdata(struct device *dev, struct device_node *np, · 13 unmodified lines | ||
| 355 | 355 | return ret; |
| 356 | 356 | } |
| 357 | 357 | num_data = ret; |
| 358 | − data = devm_kzalloc(dev, num_data * sizeof(*data), GFP_KERNEL); | |
| 358 | + data = devm_kcalloc(dev, num_data, sizeof(*data), GFP_KERNEL); | |
| 359 | 359 | if (!data) |
| 360 | 360 | return -ENOMEM; |
| 361 | 361 | |
| @@ -415,7 +415,7 @@ static int netxbig_leds_get_of_pdata(struct device *dev, · 53 unmodified lines | ||
| 415 | 415 | if (ret % 3) |
| 416 | 416 | return -EINVAL; |
| 417 | 417 | num_timers = ret / 3; |
| 418 | − timers = devm_kzalloc(dev, num_timers * sizeof(*timers), | |
| 418 | + timers = devm_kcalloc(dev, num_timers, sizeof(*timers), | |
| 419 | 419 | GFP_KERNEL); |
| 420 | 420 | if (!timers) |
| 421 | 421 | return -ENOMEM; |
| @@ -444,7 +444,7 @@ static int netxbig_leds_get_of_pdata(struct device *dev, · 22 unmodified lines | ||
| 444 | 444 | return -ENODEV; |
| 445 | 445 | } |
| 446 | 446 | |
| 447 | − leds = devm_kzalloc(dev, num_leds * sizeof(*leds), GFP_KERNEL); | |
| 447 | + leds = devm_kcalloc(dev, num_leds, sizeof(*leds), GFP_KERNEL); | |
| 448 | 448 | if (!leds) |
| 449 | 449 | return -ENOMEM; |
| 450 | 450 | |
| @@ -470,8 +470,8 @@ static int netxbig_leds_get_of_pdata(struct device *dev, · 19 unmodified lines | ||
| 470 | 470 | goto err_node_put; |
| 471 | 471 | |
| 472 | 472 | mode_val = |
| 473 | − devm_kzalloc(dev, | |
| 474 | − NETXBIG_LED_MODE_NUM * sizeof(*mode_val), | |
| 473 | + devm_kcalloc(dev, | |
| 474 | + NETXBIG_LED_MODE_NUM, sizeof(*mode_val), | |
| 475 | 475 | GFP_KERNEL); |
| 476 | 476 | if (!mode_val) { |
| 477 | 477 | ret = -ENOMEM; |
| @@ -560,8 +560,8 @@ static int netxbig_led_probe(struct platform_device *pdev) · 82 unmodified lines | ||
| 560 | 560 | return ret; |
| 561 | 561 | } |
| 562 | 562 | |
| 563 | − leds_data = devm_kzalloc(&pdev->dev, | |
| 564 | − pdata->num_leds * sizeof(*leds_data), | |
| 563 | + leds_data = devm_kcalloc(&pdev->dev, | |
| 564 | + pdata->num_leds, sizeof(*leds_data), | |
| 565 | 565 | GFP_KERNEL); |
| 566 | 566 | if (!leds_data) |
| 567 | 567 | return -ENOMEM; |
| @@ -264,7 +264,7 @@ ns2_leds_get_of_pdata(struct device *dev, struct ns2_led_platform_data *pdata) · 263 unmodified lines | ||
| 264 | 264 | if (!num_leds) |
| 265 | 265 | return -ENODEV; |
| 266 | 266 | |
| 267 | − leds = devm_kzalloc(dev, num_leds * sizeof(struct ns2_led), | |
| 267 | + leds = devm_kcalloc(dev, num_leds, sizeof(struct ns2_led), | |
| 268 | 268 | GFP_KERNEL); |
| 269 | 269 | if (!leds) |
| 270 | 270 | return -ENOMEM; |
| @@ -298,8 +298,9 @@ ns2_leds_get_of_pdata(struct device *dev, struct ns2_led_platform_data *pdata) · 27 unmodified lines | ||
| 298 | 298 | } |
| 299 | 299 | |
| 300 | 300 | num_modes = ret / 3; |
| 301 | − modval = devm_kzalloc(dev, | |
| 302 | − num_modes * sizeof(struct ns2_led_modval), | |
| 301 | + modval = devm_kcalloc(dev, | |
| 302 | + num_modes, | |
| 303 | + sizeof(struct ns2_led_modval), | |
| 303 | 304 | GFP_KERNEL); |
| 304 | 305 | if (!modval) |
| 305 | 306 | return -ENOMEM; |
| @@ -390,8 +390,8 @@ pca955x_pdata_of_init(struct i2c_client *client, struct pca955x_chipdef *chip) · 389 unmodified lines | ||
| 390 | 390 | if (!pdata) |
| 391 | 391 | return ERR_PTR(-ENOMEM); |
| 392 | 392 | |
| 393 | − pdata->leds = devm_kzalloc(&client->dev, | |
| 394 | − sizeof(struct pca955x_led) * chip->bits, | |
| 393 | + pdata->leds = devm_kcalloc(&client->dev, | |
| 394 | + chip->bits, sizeof(struct pca955x_led), | |
| 395 | 395 | GFP_KERNEL); |
| 396 | 396 | if (!pdata->leds) |
| 397 | 397 | return ERR_PTR(-ENOMEM); |
| @@ -494,8 +494,8 @@ static int pca955x_probe(struct i2c_client *client, · 96 unmodified lines | ||
| 494 | 494 | if (!pca955x) |
| 495 | 495 | return -ENOMEM; |
| 496 | 496 | |
| 497 | − pca955x->leds = devm_kzalloc(&client->dev, | |
| 498 | − sizeof(*pca955x_led) * chip->bits, GFP_KERNEL); | |
| 497 | + pca955x->leds = devm_kcalloc(&client->dev, | |
| 498 | + chip->bits, sizeof(*pca955x_led), GFP_KERNEL); | |
| 499 | 499 | if (!pca955x->leds) |
| 500 | 500 | return -ENOMEM; |
| 501 | 501 | |
| @@ -300,8 +300,8 @@ pca963x_dt_init(struct i2c_client *client, struct pca963x_chipdef *chip) · 299 unmodified lines | ||
| 300 | 300 | if (!count || count > chip->n_leds) |
| 301 | 301 | return ERR_PTR(-ENODEV); |
| 302 | 302 | |
| 303 | − pca963x_leds = devm_kzalloc(&client->dev, | |
| 304 | − sizeof(struct led_info) * chip->n_leds, GFP_KERNEL); | |
| 303 | + pca963x_leds = devm_kcalloc(&client->dev, | |
| 304 | + chip->n_leds, sizeof(struct led_info), GFP_KERNEL); | |
| 305 | 305 | if (!pca963x_leds) |
| 306 | 306 | return ERR_PTR(-ENOMEM); |
| 307 | 307 | |
| @@ -407,7 +407,7 @@ static int pca963x_probe(struct i2c_client *client, · 99 unmodified lines | ||
| 407 | 407 | GFP_KERNEL); |
| 408 | 408 | if (!pca963x_chip) |
| 409 | 409 | return -ENOMEM; |
| 410 | − pca963x = devm_kzalloc(&client->dev, chip->n_leds * sizeof(*pca963x), | |
| 410 | + pca963x = devm_kcalloc(&client->dev, chip->n_leds, sizeof(*pca963x), | |
| 411 | 411 | GFP_KERNEL); |
| 412 | 412 | if (!pca963x) |
| 413 | 413 | return -ENOMEM; |
| @@ -697,8 +697,8 @@ tca6507_led_dt_init(struct i2c_client *client) · 696 unmodified lines | ||
| 697 | 697 | if (!count || count > NUM_LEDS) |
| 698 | 698 | return ERR_PTR(-ENODEV); |
| 699 | 699 | |
| 700 | − tca_leds = devm_kzalloc(&client->dev, | |
| 701 | − sizeof(struct led_info) * NUM_LEDS, GFP_KERNEL); | |
| 700 | + tca_leds = devm_kcalloc(&client->dev, | |
| 701 | + NUM_LEDS, sizeof(struct led_info), GFP_KERNEL); | |
| 702 | 702 | if (!tca_leds) |
| 703 | 703 | return ERR_PTR(-ENOMEM); |
| 704 | 704 | |
| @@ -88,7 +88,7 @@ static void pblk_gc_line_ws(struct work_struct *work) · 87 unmodified lines | ||
| 88 | 88 | |
| 89 | 89 | up(&gc->gc_sem); |
| 90 | 90 | |
| 91 | − gc_rq->data = vmalloc(gc_rq->nr_secs * geo->csecs); | |
| 91 | + gc_rq->data = vmalloc(array_size(gc_rq->nr_secs, geo->csecs)); | |
| 92 | 92 | if (!gc_rq->data) { |
| 93 | 93 | pr_err("pblk: could not GC line:%d (%d/%d)\n", |
| 94 | 94 | line->id, *line->vsc, gc_rq->nr_secs); |
| @@ -187,7 +187,7 @@ static int pblk_rwb_init(struct pblk *pblk) · 186 unmodified lines | ||
| 187 | 187 | |
| 188 | 188 | nr_entries = pblk_rb_calculate_size(buffer_size); |
| 189 | 189 | |
| 190 | − entries = vzalloc(nr_entries * sizeof(struct pblk_rb_entry)); | |
| 190 | + entries = vzalloc(array_size(nr_entries, sizeof(struct pblk_rb_entry))); | |
| 191 | 191 | if (!entries) |
| 192 | 192 | return -ENOMEM; |
| 193 | 193 | |
| @@ -379,7 +379,7 @@ static int pblk_core_init(struct pblk *pblk) · 185 unmodified lines | ||
| 379 | 379 | return -EINVAL; |
| 380 | 380 | } |
| 381 | 381 | |
| 382 | − pblk->pad_dist = kzalloc((pblk->min_write_pgs - 1) * sizeof(atomic64_t), | |
| 382 | + pblk->pad_dist = kcalloc(pblk->min_write_pgs - 1, sizeof(atomic64_t), | |
| 383 | 383 | GFP_KERNEL); |
| 384 | 384 | if (!pblk->pad_dist) |
| 385 | 385 | return -ENOMEM; |
| @@ -833,8 +833,8 @@ static int pblk_alloc_line_meta(struct pblk *pblk, struct pblk_line *line) · 447 unmodified lines | ||
| 833 | 833 | goto free_blk_bitmap; |
| 834 | 834 | |
| 835 | 835 | |
| 836 | − line->chks = kmalloc(lm->blk_per_line * sizeof(struct nvm_chk_meta), | |
| 837 | − GFP_KERNEL); | |
| 836 | + line->chks = kmalloc_array(lm->blk_per_line, | |
| 837 | + sizeof(struct nvm_chk_meta), GFP_KERNEL); | |
| 838 | 838 | if (!line->chks) |
| 839 | 839 | goto free_erase_bitmap; |
| 840 | 840 | |
| @@ -260,7 +260,7 @@ static int pblk_recov_pad_oob(struct pblk *pblk, struct pblk_line *line, · 259 unmodified lines | ||
| 260 | 260 | if (!pad_rq) |
| 261 | 261 | return -ENOMEM; |
| 262 | 262 | |
| 263 | − data = vzalloc(pblk->max_write_pgs * geo->csecs); | |
| 263 | + data = vzalloc(array_size(pblk->max_write_pgs, geo->csecs)); | |
| 264 | 264 | if (!data) { |
| 265 | 265 | ret = -ENOMEM; |
| 266 | 266 | goto free_rq; |
| @@ -282,13 +282,13 @@ static int hi6220_mbox_probe(struct platform_device *pdev) · 281 unmodified lines | ||
| 282 | 282 | |
| 283 | 283 | mbox->dev = dev; |
| 284 | 284 | mbox->chan_num = MBOX_CHAN_MAX; |
| 285 | − mbox->mchan = devm_kzalloc(dev, | |
| 286 | − mbox->chan_num * sizeof(*mbox->mchan), GFP_KERNEL); | |
| 285 | + mbox->mchan = devm_kcalloc(dev, | |
| 286 | + mbox->chan_num, sizeof(*mbox->mchan), GFP_KERNEL); | |
| 287 | 287 | if (!mbox->mchan) |
| 288 | 288 | return -ENOMEM; |
| 289 | 289 | |
| 290 | − mbox->chan = devm_kzalloc(dev, | |
| 291 | − mbox->chan_num * sizeof(*mbox->chan), GFP_KERNEL); | |
| 290 | + mbox->chan = devm_kcalloc(dev, | |
| 291 | + mbox->chan_num, sizeof(*mbox->chan), GFP_KERNEL); | |
| 292 | 292 | if (!mbox->chan) |
| 293 | 293 | return -ENOMEM; |
| 294 | 294 | |
| @@ -442,8 +442,8 @@ static int sti_mbox_probe(struct platform_device *pdev) · 441 unmodified lines | ||
| 442 | 442 | if (!mbox) |
| 443 | 443 | return -ENOMEM; |
| 444 | 444 | |
| 445 | − chans = devm_kzalloc(&pdev->dev, | |
| 446 | − sizeof(*chans) * STI_MBOX_CHAN_MAX, GFP_KERNEL); | |
| 445 | + chans = devm_kcalloc(&pdev->dev, | |
| 446 | + STI_MBOX_CHAN_MAX, sizeof(*chans), GFP_KERNEL); | |
| 447 | 447 | if (!chans) |
| 448 | 448 | return -ENOMEM; |
| 449 | 449 | |
| @@ -729,7 +729,7 @@ static int omap_mbox_probe(struct platform_device *pdev) · 728 unmodified lines | ||
| 729 | 729 | return -ENODEV; |
| 730 | 730 | } |
| 731 | 731 | |
| 732 | − finfoblk = devm_kzalloc(&pdev->dev, info_count * sizeof(*finfoblk), | |
| 732 | + finfoblk = devm_kcalloc(&pdev->dev, info_count, sizeof(*finfoblk), | |
| 733 | 733 | GFP_KERNEL); |
| 734 | 734 | if (!finfoblk) |
| 735 | 735 | return -ENOMEM; |
| @@ -773,23 +773,23 @@ static int omap_mbox_probe(struct platform_device *pdev) · 37 unmodified lines | ||
| 773 | 773 | if (IS_ERR(mdev->mbox_base)) |
| 774 | 774 | return PTR_ERR(mdev->mbox_base); |
| 775 | 775 | |
| 776 | − mdev->irq_ctx = devm_kzalloc(&pdev->dev, num_users * sizeof(u32), | |
| 776 | + mdev->irq_ctx = devm_kcalloc(&pdev->dev, num_users, sizeof(u32), | |
| 777 | 777 | GFP_KERNEL); |
| 778 | 778 | if (!mdev->irq_ctx) |
| 779 | 779 | return -ENOMEM; |
| 780 | 780 | |
| 781 | 781 | /* allocate one extra for marking end of list */ |
| 782 | − list = devm_kzalloc(&pdev->dev, (info_count + 1) * sizeof(*list), | |
| 782 | + list = devm_kcalloc(&pdev->dev, info_count + 1, sizeof(*list), | |
| 783 | 783 | GFP_KERNEL); |
| 784 | 784 | if (!list) |
| 785 | 785 | return -ENOMEM; |
| 786 | 786 | |
| 787 | − chnls = devm_kzalloc(&pdev->dev, (info_count + 1) * sizeof(*chnls), | |
| 787 | + chnls = devm_kcalloc(&pdev->dev, info_count + 1, sizeof(*chnls), | |
| 788 | 788 | GFP_KERNEL); |
| 789 | 789 | if (!chnls) |
| 790 | 790 | return -ENOMEM; |
| 791 | 791 | |
| 792 | − mboxblk = devm_kzalloc(&pdev->dev, info_count * sizeof(*mbox), | |
| 792 | + mboxblk = devm_kcalloc(&pdev->dev, info_count, sizeof(*mbox), | |
| 793 | 793 | GFP_KERNEL); |
| 794 | 794 | if (!mboxblk) |
| 795 | 795 | return -ENOMEM; |
| @@ -466,7 +466,8 @@ static int __init acpi_pcc_probe(void) · 465 unmodified lines | ||
| 466 | 466 | return -EINVAL; |
| 467 | 467 | } |
| 468 | 468 | |
| 469 | − pcc_mbox_channels = kzalloc(sizeof(struct mbox_chan) * count, GFP_KERNEL); | |
| 469 | + pcc_mbox_channels = kcalloc(count, sizeof(struct mbox_chan), | |
| 470 | + GFP_KERNEL); | |
| 470 | 471 | if (!pcc_mbox_channels) { |
| 471 | 472 | pr_err("Could not allocate space for PCC mbox channels\n"); |
| 472 | 473 | return -ENOMEM; |
| @@ -568,12 +568,12 @@ static int ti_msgmgr_probe(struct platform_device *pdev) · 567 unmodified lines | ||
| 568 | 568 | } |
| 569 | 569 | inst->num_valid_queues = queue_count; |
| 570 | 570 | |
| 571 | − qinst = devm_kzalloc(dev, sizeof(*qinst) * queue_count, GFP_KERNEL); | |
| 571 | + qinst = devm_kcalloc(dev, queue_count, sizeof(*qinst), GFP_KERNEL); | |
| 572 | 572 | if (!qinst) |
| 573 | 573 | return -ENOMEM; |
| 574 | 574 | inst->qinsts = qinst; |
| 575 | 575 | |
| 576 | − chans = devm_kzalloc(dev, sizeof(*chans) * queue_count, GFP_KERNEL); | |
| 576 | + chans = devm_kcalloc(dev, queue_count, sizeof(*chans), GFP_KERNEL); | |
| 577 | 577 | if (!chans) |
| 578 | 578 | return -ENOMEM; |
| 579 | 579 | inst->chans = chans; |
| @@ -1715,7 +1715,7 @@ struct cache_set *bch_cache_set_alloc(struct cache_sb *sb) · 1714 unmodified lines | ||
| 1715 | 1715 | iter_size = (sb->bucket_size / sb->block_size + 1) * |
| 1716 | 1716 | sizeof(struct btree_iter_set); |
| 1717 | 1717 | |
| 1718 | − if (!(c->devices = kzalloc(c->nr_uuids * sizeof(void *), GFP_KERNEL)) || | |
| 1718 | + if (!(c->devices = kcalloc(c->nr_uuids, sizeof(void *), GFP_KERNEL)) || | |
| 1719 | 1719 | mempool_init_slab_pool(&c->search, 32, bch_search_cache) || |
| 1720 | 1720 | mempool_init_kmalloc_pool(&c->bio_meta, 2, |
| 1721 | 1721 | sizeof(struct bbio) + sizeof(struct bio_vec) * |
| @@ -2041,10 +2041,11 @@ static int cache_alloc(struct cache *ca) · 319 unmodified lines | ||
| 2041 | 2041 | !init_fifo(&ca->free[RESERVE_NONE], free, GFP_KERNEL) || |
| 2042 | 2042 | !init_fifo(&ca->free_inc, free << 2, GFP_KERNEL) || |
| 2043 | 2043 | !init_heap(&ca->heap, free << 3, GFP_KERNEL) || |
| 2044 | − !(ca->buckets = vzalloc(sizeof(struct bucket) * | |
| 2045 | − ca->sb.nbuckets)) || | |
| 2046 | − !(ca->prio_buckets = kzalloc(sizeof(uint64_t) * prio_buckets(ca) * | |
| 2047 | − 2, GFP_KERNEL)) || | |
| 2044 | + !(ca->buckets = vzalloc(array_size(sizeof(struct bucket), | |
| 2045 | + ca->sb.nbuckets))) || | |
| 2046 | + !(ca->prio_buckets = kzalloc(array3_size(sizeof(uint64_t), | |
| 2047 | + prio_buckets(ca), 2), | |
| 2048 | + GFP_KERNEL)) || | |
| 2048 | 2049 | !(ca->disk_buckets = alloc_bucket_pages(GFP_KERNEL, ca))) |
| 2049 | 2050 | return -ENOMEM; |
| 2050 | 2051 | |
| @@ -881,7 +881,8 @@ SHOW(__bch_cache) · 880 unmodified lines | ||
| 881 | 881 | uint16_t q[31], *p, *cached; |
| 882 | 882 | ssize_t ret; |
| 883 | 883 | |
| 884 | − cached = p = vmalloc(ca->sb.nbuckets * sizeof(uint16_t)); | |
| 884 | + cached = p = vmalloc(array_size(sizeof(uint16_t), | |
| 885 | + ca->sb.nbuckets)); | |
| 885 | 886 | if (!p) |
| 886 | 887 | return -ENOMEM; |
| 887 | 888 | |
| @@ -69,7 +69,7 @@ static int space_init(struct entry_space *es, unsigned nr_entries) · 68 unmodified lines | ||
| 69 | 69 | return 0; |
| 70 | 70 | } |
| 71 | 71 | |
| 72 | − es->begin = vzalloc(sizeof(struct entry) * nr_entries); | |
| 72 | + es->begin = vzalloc(array_size(nr_entries, sizeof(struct entry))); | |
| 73 | 73 | if (!es->begin) |
| 74 | 74 | return -ENOMEM; |
| 75 | 75 | |
| @@ -588,7 +588,7 @@ static int h_init(struct smq_hash_table *ht, struct entry_space *es, unsigned nr · 512 unmodified lines | ||
| 588 | 588 | nr_buckets = roundup_pow_of_two(max(nr_entries / 4u, 16u)); |
| 589 | 589 | ht->hash_bits = __ffs(nr_buckets); |
| 590 | 590 | |
| 591 | − ht->buckets = vmalloc(sizeof(*ht->buckets) * nr_buckets); | |
| 591 | + ht->buckets = vmalloc(array_size(nr_buckets, sizeof(*ht->buckets))); | |
| 592 | 592 | if (!ht->buckets) |
| 593 | 593 | return -ENOMEM; |
| 594 | 594 | |
| @@ -1878,8 +1878,9 @@ static int crypt_alloc_tfms_skcipher(struct crypt_config *cc, char *ciphermode) · 1877 unmodified lines | ||
| 1878 | 1878 | unsigned i; |
| 1879 | 1879 | int err; |
| 1880 | 1880 | |
| 1881 | − cc->cipher_tfm.tfms = kzalloc(cc->tfms_count * | |
| 1882 | − sizeof(struct crypto_skcipher *), GFP_KERNEL); | |
| 1881 | + cc->cipher_tfm.tfms = kcalloc(cc->tfms_count, | |
| 1882 | + sizeof(struct crypto_skcipher *), | |
| 1883 | + GFP_KERNEL); | |
| 1883 | 1884 | if (!cc->cipher_tfm.tfms) |
| 1884 | 1885 | return -ENOMEM; |
| 1885 | 1886 | |
| @@ -2448,7 +2448,9 @@ static struct scatterlist **dm_integrity_alloc_journal_scatterlist(struct dm_int · 2447 unmodified lines | ||
| 2448 | 2448 | struct scatterlist **sl; |
| 2449 | 2449 | unsigned i; |
| 2450 | 2450 | |
| 2451 | − sl = kvmalloc(ic->journal_sections * sizeof(struct scatterlist *), GFP_KERNEL | __GFP_ZERO); | |
| 2451 | + sl = kvmalloc_array(ic->journal_sections, | |
| 2452 | + sizeof(struct scatterlist *), | |
| 2453 | + GFP_KERNEL | __GFP_ZERO); | |
| 2452 | 2454 | if (!sl) |
| 2453 | 2455 | return NULL; |
| 2454 | 2456 | |
| @@ -2464,7 +2466,8 @@ static struct scatterlist **dm_integrity_alloc_journal_scatterlist(struct dm_int · 9 unmodified lines | ||
| 2464 | 2466 | |
| 2465 | 2467 | n_pages = (end_index - start_index + 1); |
| 2466 | 2468 | |
| 2467 | − s = kvmalloc(n_pages * sizeof(struct scatterlist), GFP_KERNEL); | |
| 2469 | + s = kvmalloc_array(n_pages, sizeof(struct scatterlist), | |
| 2470 | + GFP_KERNEL); | |
| 2468 | 2471 | if (!s) { |
| 2469 | 2472 | dm_integrity_free_journal_scatterlist(ic, sl); |
| 2470 | 2473 | return NULL; |
| @@ -2643,7 +2646,9 @@ static int create_journal(struct dm_integrity_c *ic, char **error) · 172 unmodified lines | ||
| 2643 | 2646 | goto bad; |
| 2644 | 2647 | } |
| 2645 | 2648 | |
| 2646 | − sg = kvmalloc((ic->journal_pages + 1) * sizeof(struct scatterlist), GFP_KERNEL); | |
| 2649 | + sg = kvmalloc_array(ic->journal_pages + 1, | |
| 2650 | + sizeof(struct scatterlist), | |
| 2651 | + GFP_KERNEL); | |
| 2647 | 2652 | if (!sg) { |
| 2648 | 2653 | *error = "Unable to allocate sg list"; |
| 2649 | 2654 | r = -ENOMEM; |
| @@ -2709,7 +2714,9 @@ static int create_journal(struct dm_integrity_c *ic, char **error) · 59 unmodified lines | ||
| 2709 | 2714 | r = -ENOMEM; |
| 2710 | 2715 | goto bad; |
| 2711 | 2716 | } |
| 2712 | − ic->sk_requests = kvmalloc(ic->journal_sections * sizeof(struct skcipher_request *), GFP_KERNEL | __GFP_ZERO); | |
| 2717 | + ic->sk_requests = kvmalloc_array(ic->journal_sections, | |
| 2718 | + sizeof(struct skcipher_request *), | |
| 2719 | + GFP_KERNEL | __GFP_ZERO); | |
| 2713 | 2720 | if (!ic->sk_requests) { |
| 2714 | 2721 | *error = "Unable to allocate sk requests"; |
| 2715 | 2722 | r = -ENOMEM; |
| @@ -2743,7 +2750,8 @@ static int create_journal(struct dm_integrity_c *ic, char **error) · 27 unmodified lines | ||
| 2743 | 2750 | r = -ENOMEM; |
| 2744 | 2751 | goto bad; |
| 2745 | 2752 | } |
| 2746 | − section_req->iv = kmalloc(ivsize * 2, GFP_KERNEL); | |
| 2753 | + section_req->iv = kmalloc_array(ivsize, 2, | |
| 2754 | + GFP_KERNEL); | |
| 2747 | 2755 | if (!section_req->iv) { |
| 2748 | 2756 | skcipher_request_free(section_req); |
| 2749 | 2757 | *error = "Unable to allocate iv"; |
| @@ -203,7 +203,7 @@ struct dm_region_hash *dm_region_hash_create( · 202 unmodified lines | ||
| 203 | 203 | rh->shift = RH_HASH_SHIFT; |
| 204 | 204 | rh->prime = RH_HASH_MULT; |
| 205 | 205 | |
| 206 | − rh->buckets = vmalloc(nr_buckets * sizeof(*rh->buckets)); | |
| 206 | + rh->buckets = vmalloc(array_size(nr_buckets, sizeof(*rh->buckets))); | |
| 207 | 207 | if (!rh->buckets) { |
| 208 | 208 | DMERR("unable to allocate region hash bucket memory"); |
| 209 | 209 | kfree(rh); |
| @@ -326,8 +326,8 @@ static int init_origin_hash(void) · 325 unmodified lines | ||
| 326 | 326 | { |
| 327 | 327 | int i; |
| 328 | 328 | |
| 329 | − _origins = kmalloc(ORIGIN_HASH_SIZE * sizeof(struct list_head), | |
| 330 | − GFP_KERNEL); | |
| 329 | + _origins = kmalloc_array(ORIGIN_HASH_SIZE, sizeof(struct list_head), | |
| 330 | + GFP_KERNEL); | |
| 331 | 331 | if (!_origins) { |
| 332 | 332 | DMERR("unable to allocate memory for _origins"); |
| 333 | 333 | return -ENOMEM; |
| @@ -335,8 +335,9 @@ static int init_origin_hash(void) · 1 unmodified line | ||
| 335 | 335 | for (i = 0; i < ORIGIN_HASH_SIZE; i++) |
| 336 | 336 | INIT_LIST_HEAD(_origins + i); |
| 337 | 337 | |
| 338 | − _dm_origins = kmalloc(ORIGIN_HASH_SIZE * sizeof(struct list_head), | |
| 339 | − GFP_KERNEL); | |
| 338 | + _dm_origins = kmalloc_array(ORIGIN_HASH_SIZE, | |
| 339 | + sizeof(struct list_head), | |
| 340 | + GFP_KERNEL); | |
| 340 | 341 | if (!_dm_origins) { |
| 341 | 342 | DMERR("unable to allocate memory for _dm_origins"); |
| 342 | 343 | kfree(_origins); |
| @@ -915,7 +915,9 @@ static int parse_histogram(const char *h, unsigned *n_histogram_entries, · 914 unmodified lines | ||
| 915 | 915 | if (*q == ',') |
| 916 | 916 | (*n_histogram_entries)++; |
| 917 | 917 | |
| 918 | − *histogram_boundaries = kmalloc(*n_histogram_entries * sizeof(unsigned long long), GFP_KERNEL); | |
| 918 | + *histogram_boundaries = kmalloc_array(*n_histogram_entries, | |
| 919 | + sizeof(unsigned long long), | |
| 920 | + GFP_KERNEL); | |
| 919 | 921 | if (!*histogram_boundaries) |
| 920 | 922 | return -ENOMEM; |
| 921 | 923 | |
| @@ -114,7 +114,8 @@ static int alloc_region_table(struct dm_target *ti, unsigned nr_paths) · 113 unmodified lines | ||
| 114 | 114 | return -EINVAL; |
| 115 | 115 | } |
| 116 | 116 | |
| 117 | − sctx->region_table = vmalloc(nr_slots * sizeof(region_table_slot_t)); | |
| 117 | + sctx->region_table = vmalloc(array_size(nr_slots, | |
| 118 | + sizeof(region_table_slot_t))); | |
| 118 | 119 | if (!sctx->region_table) { |
| 119 | 120 | ti->error = "Cannot allocate region table"; |
| 120 | 121 | return -ENOMEM; |
| @@ -561,7 +561,7 @@ static char **realloc_argv(unsigned *size, char **old_argv) · 560 unmodified lines | ||
| 561 | 561 | new_size = 8; |
| 562 | 562 | gfp = GFP_NOIO; |
| 563 | 563 | } |
| 564 | − argv = kmalloc(new_size * sizeof(*argv), gfp); | |
| 564 | + argv = kmalloc_array(new_size, sizeof(*argv), gfp); | |
| 565 | 565 | if (argv) { |
| 566 | 566 | memcpy(argv, old_argv, *size * sizeof(*argv)); |
| 567 | 567 | *size = new_size; |
| @@ -2940,7 +2940,9 @@ static struct pool *pool_create(struct mapped_device *pool_md, · 2939 unmodified lines | ||
| 2940 | 2940 | goto bad_mapping_pool; |
| 2941 | 2941 | } |
| 2942 | 2942 | |
| 2943 | − pool->cell_sort_array = vmalloc(sizeof(*pool->cell_sort_array) * CELL_SORT_ARRAY_SIZE); | |
| 2943 | + pool->cell_sort_array = | |
| 2944 | + vmalloc(array_size(CELL_SORT_ARRAY_SIZE, | |
| 2945 | + sizeof(*pool->cell_sort_array))); | |
| 2944 | 2946 | if (!pool->cell_sort_array) { |
| 2945 | 2947 | *error = "Error allocating cell sort array"; |
| 2946 | 2948 | err_p = ERR_PTR(-ENOMEM); |
| @@ -797,8 +797,9 @@ static int verity_alloc_most_once(struct dm_verity *v) · 796 unmodified lines | ||
| 797 | 797 | return -E2BIG; |
| 798 | 798 | } |
| 799 | 799 | |
| 800 | − v->validated_blocks = kvzalloc(BITS_TO_LONGS(v->data_blocks) * | |
| 801 | − sizeof(unsigned long), GFP_KERNEL); | |
| 800 | + v->validated_blocks = kvcalloc(BITS_TO_LONGS(v->data_blocks), | |
| 801 | + sizeof(unsigned long), | |
| 802 | + GFP_KERNEL); | |
| 802 | 803 | if (!v->validated_blocks) { |
| 803 | 804 | ti->error = "failed to allocate bitset for check_at_most_once"; |
| 804 | 805 | return -ENOMEM; |
| @@ -789,8 +789,8 @@ static int bitmap_storage_alloc(struct bitmap_storage *store, · 788 unmodified lines | ||
| 789 | 789 | num_pages = DIV_ROUND_UP(bytes, PAGE_SIZE); |
| 790 | 790 | offset = slot_number * num_pages; |
| 791 | 791 | |
| 792 | − store->filemap = kmalloc(sizeof(struct page *) | |
| 793 | − * num_pages, GFP_KERNEL); | |
| 792 | + store->filemap = kmalloc_array(num_pages, sizeof(struct page *), | |
| 793 | + GFP_KERNEL); | |
| 794 | 794 | if (!store->filemap) |
| 795 | 795 | return -ENOMEM; |
| 796 | 796 | |
| @@ -2117,7 +2117,7 @@ int bitmap_resize(struct bitmap *bitmap, sector_t blocks, · 1320 unmodified lines | ||
| 2117 | 2117 | |
| 2118 | 2118 | pages = DIV_ROUND_UP(chunks, PAGE_COUNTER_RATIO); |
| 2119 | 2119 | |
| 2120 | − new_bp = kzalloc(pages * sizeof(*new_bp), GFP_KERNEL); | |
| 2120 | + new_bp = kcalloc(pages, sizeof(*new_bp), GFP_KERNEL); | |
| 2121 | 2121 | ret = -ENOMEM; |
| 2122 | 2122 | if (!new_bp) { |
| 2123 | 2123 | bitmap_file_unmap(&store); |
| @@ -1380,9 +1380,9 @@ static int lock_all_bitmaps(struct mddev *mddev) · 1379 unmodified lines | ||
| 1380 | 1380 | char str[64]; |
| 1381 | 1381 | struct md_cluster_info *cinfo = mddev->cluster_info; |
| 1382 | 1382 | |
| 1383 | − cinfo->other_bitmap_lockres = kzalloc((mddev->bitmap_info.nodes - 1) * | |
| 1384 | − sizeof(struct dlm_lock_resource *), | |
| 1385 | − GFP_KERNEL); | |
| 1383 | + cinfo->other_bitmap_lockres = | |
| 1384 | + kcalloc(mddev->bitmap_info.nodes - 1, | |
| 1385 | + sizeof(struct dlm_lock_resource *), GFP_KERNEL); | |
| 1386 | 1386 | if (!cinfo->other_bitmap_lockres) { |
| 1387 | 1387 | pr_err("md: can't alloc mem for other bitmap locks\n"); |
| 1388 | 1388 | return 0; |
| @@ -399,7 +399,8 @@ static int multipath_run (struct mddev *mddev) · 398 unmodified lines | ||
| 399 | 399 | if (!conf) |
| 400 | 400 | goto out; |
| 401 | 401 | |
| 402 | − conf->multipaths = kzalloc(sizeof(struct multipath_info)*mddev->raid_disks, | |
| 402 | + conf->multipaths = kcalloc(mddev->raid_disks, | |
| 403 | + sizeof(struct multipath_info), | |
| 403 | 404 | GFP_KERNEL); |
| 404 | 405 | if (!conf->multipaths) |
| 405 | 406 | goto out_free_conf; |
| @@ -159,12 +159,14 @@ static int create_strip_zones(struct mddev *mddev, struct r0conf **private_conf) · 158 unmodified lines | ||
| 159 | 159 | } |
| 160 | 160 | |
| 161 | 161 | err = -ENOMEM; |
| 162 | − conf->strip_zone = kzalloc(sizeof(struct strip_zone)* | |
| 163 | − conf->nr_strip_zones, GFP_KERNEL); | |
| 162 | + conf->strip_zone = kcalloc(conf->nr_strip_zones, | |
| 163 | + sizeof(struct strip_zone), | |
| 164 | + GFP_KERNEL); | |
| 164 | 165 | if (!conf->strip_zone) |
| 165 | 166 | goto abort; |
| 166 | − conf->devlist = kzalloc(sizeof(struct md_rdev*)* | |
| 167 | − conf->nr_strip_zones*mddev->raid_disks, | |
| 167 | + conf->devlist = kzalloc(array3_size(sizeof(struct md_rdev *), | |
| 168 | + conf->nr_strip_zones, | |
| 169 | + mddev->raid_disks), | |
| 168 | 170 | GFP_KERNEL); |
| 169 | 171 | if (!conf->devlist) |
| 170 | 172 | goto abort; |
| @@ -126,8 +126,8 @@ static void * r1buf_pool_alloc(gfp_t gfp_flags, void *data) · 125 unmodified lines | ||
| 126 | 126 | if (!r1_bio) |
| 127 | 127 | return NULL; |
| 128 | 128 | |
| 129 | − rps = kmalloc(sizeof(struct resync_pages) * pi->raid_disks, | |
| 130 | − gfp_flags); | |
| 129 | + rps = kmalloc_array(pi->raid_disks, sizeof(struct resync_pages), | |
| 130 | + gfp_flags); | |
| 131 | 131 | if (!rps) |
| 132 | 132 | goto out_free_r1bio; |
| 133 | 133 | |
| @@ -2936,9 +2936,9 @@ static struct r1conf *setup_conf(struct mddev *mddev) · 2802 unmodified lines | ||
| 2936 | 2936 | if (!conf->barrier) |
| 2937 | 2937 | goto abort; |
| 2938 | 2938 | |
| 2939 | − conf->mirrors = kzalloc(sizeof(struct raid1_info) | |
| 2940 | − * mddev->raid_disks * 2, | |
| 2941 | − GFP_KERNEL); | |
| 2939 | + conf->mirrors = kzalloc(array3_size(sizeof(struct raid1_info), | |
| 2940 | + mddev->raid_disks, 2), | |
| 2941 | + GFP_KERNEL); | |
| 2942 | 2942 | if (!conf->mirrors) |
| 2943 | 2943 | goto abort; |
| 2944 | 2944 | |
| @@ -3241,7 +3241,8 @@ static int raid1_reshape(struct mddev *mddev) · 296 unmodified lines | ||
| 3241 | 3241 | kfree(newpoolinfo); |
| 3242 | 3242 | return ret; |
| 3243 | 3243 | } |
| 3244 | − newmirrors = kzalloc(sizeof(struct raid1_info) * raid_disks * 2, | |
| 3244 | + newmirrors = kzalloc(array3_size(sizeof(struct raid1_info), | |
| 3245 | + raid_disks, 2), | |
| 3245 | 3246 | GFP_KERNEL); |
| 3246 | 3247 | if (!newmirrors) { |
| 3247 | 3248 | kfree(newpoolinfo); |
| @@ -175,7 +175,7 @@ static void * r10buf_pool_alloc(gfp_t gfp_flags, void *data) · 174 unmodified lines | ||
| 175 | 175 | nalloc_rp = nalloc; |
| 176 | 176 | else |
| 177 | 177 | nalloc_rp = nalloc * 2; |
| 178 | − rps = kmalloc(sizeof(struct resync_pages) * nalloc_rp, gfp_flags); | |
| 178 | + rps = kmalloc_array(nalloc_rp, sizeof(struct resync_pages), gfp_flags); | |
| 179 | 179 | if (!rps) |
| 180 | 180 | goto out_free_r10bio; |
| 181 | 181 | |
| @@ -3688,8 +3688,8 @@ static struct r10conf *setup_conf(struct mddev *mddev) · 3506 unmodified lines | ||
| 3688 | 3688 | goto out; |
| 3689 | 3689 | |
| 3690 | 3690 | /* FIXME calc properly */ |
| 3691 | − conf->mirrors = kzalloc(sizeof(struct raid10_info)*(mddev->raid_disks + | |
| 3692 | − max(0,-mddev->delta_disks)), | |
| 3691 | + conf->mirrors = kcalloc(mddev->raid_disks + max(0, -mddev->delta_disks), | |
| 3692 | + sizeof(struct raid10_info), | |
| 3693 | 3693 | GFP_KERNEL); |
| 3694 | 3694 | if (!conf->mirrors) |
| 3695 | 3695 | goto out; |
| @@ -4129,11 +4129,10 @@ static int raid10_check_reshape(struct mddev *mddev) · 433 unmodified lines | ||
| 4129 | 4129 | conf->mirrors_new = NULL; |
| 4130 | 4130 | if (mddev->delta_disks > 0) { |
| 4131 | 4131 | /* allocate new 'mirrors' list */ |
| 4132 | − conf->mirrors_new = kzalloc( | |
| 4133 | − sizeof(struct raid10_info) | |
| 4134 | − *(mddev->raid_disks + | |
| 4135 | − mddev->delta_disks), | |
| 4136 | − GFP_KERNEL); | |
| 4132 | + conf->mirrors_new = | |
| 4133 | + kcalloc(mddev->raid_disks + mddev->delta_disks, | |
| 4134 | + sizeof(struct raid10_info), | |
| 4135 | + GFP_KERNEL); | |
| 4137 | 4136 | if (!conf->mirrors_new) |
| 4138 | 4137 | return -ENOMEM; |
| 4139 | 4138 | } |
| @@ -2396,7 +2396,7 @@ static int resize_stripes(struct r5conf *conf, int newsize) · 2395 unmodified lines | ||
| 2396 | 2396 | * is completely stalled, so now is a good time to resize |
| 2397 | 2397 | * conf->disks and the scribble region |
| 2398 | 2398 | */ |
| 2399 | − ndisks = kzalloc(newsize * sizeof(struct disk_info), GFP_NOIO); | |
| 2399 | + ndisks = kcalloc(newsize, sizeof(struct disk_info), GFP_NOIO); | |
| 2400 | 2400 | if (ndisks) { |
| 2401 | 2401 | for (i = 0; i < conf->pool_size; i++) |
| 2402 | 2402 | ndisks[i] = conf->disks[i]; |
| @@ -6664,9 +6664,9 @@ static int alloc_thread_groups(struct r5conf *conf, int cnt, · 4261 unmodified lines | ||
| 6664 | 6664 | } |
| 6665 | 6665 | *group_cnt = num_possible_nodes(); |
| 6666 | 6666 | size = sizeof(struct r5worker) * cnt; |
| 6667 | − workers = kzalloc(size * *group_cnt, GFP_NOIO); | |
| 6668 | − *worker_groups = kzalloc(sizeof(struct r5worker_group) * | |
| 6669 | − *group_cnt, GFP_NOIO); | |
| 6667 | + workers = kcalloc(size, *group_cnt, GFP_NOIO); | |
| 6668 | + *worker_groups = kcalloc(*group_cnt, sizeof(struct r5worker_group), | |
| 6669 | + GFP_NOIO); | |
| 6670 | 6670 | if (!*worker_groups || !workers) { |
| 6671 | 6671 | kfree(workers); |
| 6672 | 6672 | kfree(*worker_groups); |
| @@ -6894,8 +6894,9 @@ static struct r5conf *setup_conf(struct mddev *mddev) · 221 unmodified lines | ||
| 6894 | 6894 | goto abort; |
| 6895 | 6895 | INIT_LIST_HEAD(&conf->free_list); |
| 6896 | 6896 | INIT_LIST_HEAD(&conf->pending_list); |
| 6897 | − conf->pending_data = kzalloc(sizeof(struct r5pending_data) * | |
| 6898 | − PENDING_IO_MAX, GFP_KERNEL); | |
| 6897 | + conf->pending_data = kcalloc(PENDING_IO_MAX, | |
| 6898 | + sizeof(struct r5pending_data), | |
| 6899 | + GFP_KERNEL); | |
| 6899 | 6900 | if (!conf->pending_data) |
| 6900 | 6901 | goto abort; |
| 6901 | 6902 | for (i = 0; i < PENDING_IO_MAX; i++) |
| @@ -6944,7 +6945,7 @@ static struct r5conf *setup_conf(struct mddev *mddev) · 42 unmodified lines | ||
| 6944 | 6945 | conf->previous_raid_disks = mddev->raid_disks - mddev->delta_disks; |
| 6945 | 6946 | max_disks = max(conf->raid_disks, conf->previous_raid_disks); |
| 6946 | 6947 | |
| 6947 | − conf->disks = kzalloc(max_disks * sizeof(struct disk_info), | |
| 6948 | + conf->disks = kcalloc(max_disks, sizeof(struct disk_info), | |
| 6948 | 6949 | GFP_KERNEL); |
| 6949 | 6950 | |
| 6950 | 6951 | if (!conf->disks) |
| @@ -119,12 +119,14 @@ int tpg_alloc(struct tpg_data *tpg, unsigned max_w) · 118 unmodified lines | ||
| 119 | 119 | for (plane = 0; plane < TPG_MAX_PLANES; plane++) { |
| 120 | 120 | unsigned pixelsz = plane ? 2 : 4; |
| 121 | 121 | |
| 122 | − tpg->lines[pat][plane] = vzalloc(max_w * 2 * pixelsz); | |
| 122 | + tpg->lines[pat][plane] = | |
| 123 | + vzalloc(array3_size(max_w, 2, pixelsz)); | |
| 123 | 124 | if (!tpg->lines[pat][plane]) |
| 124 | 125 | return -ENOMEM; |
| 125 | 126 | if (plane == 0) |
| 126 | 127 | continue; |
| 127 | − tpg->downsampled_lines[pat][plane] = vzalloc(max_w * 2 * pixelsz); | |
| 128 | + tpg->downsampled_lines[pat][plane] = | |
| 129 | + vzalloc(array3_size(max_w, 2, pixelsz)); | |
| 128 | 130 | if (!tpg->downsampled_lines[pat][plane]) |
| 129 | 131 | return -ENOMEM; |
| 130 | 132 | } |
| @@ -132,13 +134,16 @@ int tpg_alloc(struct tpg_data *tpg, unsigned max_w) · 1 unmodified line | ||
| 132 | 134 | for (plane = 0; plane < TPG_MAX_PLANES; plane++) { |
| 133 | 135 | unsigned pixelsz = plane ? 2 : 4; |
| 134 | 136 | |
| 135 | − tpg->contrast_line[plane] = vzalloc(max_w * pixelsz); | |
| 137 | + tpg->contrast_line[plane] = | |
| 138 | + vzalloc(array_size(pixelsz, max_w)); | |
| 136 | 139 | if (!tpg->contrast_line[plane]) |
| 137 | 140 | return -ENOMEM; |
| 138 | − tpg->black_line[plane] = vzalloc(max_w * pixelsz); | |
| 141 | + tpg->black_line[plane] = | |
| 142 | + vzalloc(array_size(pixelsz, max_w)); | |
| 139 | 143 | if (!tpg->black_line[plane]) |
| 140 | 144 | return -ENOMEM; |
| 141 | − tpg->random_line[plane] = vzalloc(max_w * 2 * pixelsz); | |
| 145 | + tpg->random_line[plane] = | |
| 146 | + vzalloc(array3_size(max_w, 2, pixelsz)); | |
| 142 | 147 | if (!tpg->random_line[plane]) |
| 143 | 148 | return -ENOMEM; |
| 144 | 149 | } |
| @@ -1417,7 +1417,8 @@ int dvb_dmxdev_init(struct dmxdev *dmxdev, struct dvb_adapter *dvb_adapter) · 1416 unmodified lines | ||
| 1417 | 1417 | if (dmxdev->demux->open(dmxdev->demux) < 0) |
| 1418 | 1418 | return -EUSERS; |
| 1419 | 1419 | |
| 1420 | − dmxdev->filter = vmalloc(dmxdev->filternum * sizeof(struct dmxdev_filter)); | |
| 1420 | + dmxdev->filter = vmalloc(array_size(sizeof(struct dmxdev_filter), | |
| 1421 | + dmxdev->filternum)); | |
| 1421 | 1422 | if (!dmxdev->filter) |
| 1422 | 1423 | return -ENOMEM; |
| 1423 | 1424 | |
| @@ -1247,12 +1247,14 @@ int dvb_dmx_init(struct dvb_demux *dvbdemux) · 1246 unmodified lines | ||
| 1247 | 1247 | |
| 1248 | 1248 | dvbdemux->cnt_storage = NULL; |
| 1249 | 1249 | dvbdemux->users = 0; |
| 1250 | − dvbdemux->filter = vmalloc(dvbdemux->filternum * sizeof(struct dvb_demux_filter)); | |
| 1250 | + dvbdemux->filter = vmalloc(array_size(sizeof(struct dvb_demux_filter), | |
| 1251 | + dvbdemux->filternum)); | |
| 1251 | 1252 | |
| 1252 | 1253 | if (!dvbdemux->filter) |
| 1253 | 1254 | return -ENOMEM; |
| 1254 | 1255 | |
| 1255 | − dvbdemux->feed = vmalloc(dvbdemux->feednum * sizeof(struct dvb_demux_feed)); | |
| 1256 | + dvbdemux->feed = vmalloc(array_size(sizeof(struct dvb_demux_feed), | |
| 1257 | + dvbdemux->feednum)); | |
| 1256 | 1258 | if (!dvbdemux->feed) { |
| 1257 | 1259 | vfree(dvbdemux->filter); |
| 1258 | 1260 | dvbdemux->filter = NULL; |
| @@ -2018,10 +2018,10 @@ static int dib7000pc_detection(struct i2c_adapter *i2c_adap) · 2017 unmodified lines | ||
| 2018 | 2018 | }; |
| 2019 | 2019 | int ret = 0; |
| 2020 | 2020 | |
| 2021 | − tx = kzalloc(2*sizeof(u8), GFP_KERNEL); | |
| 2021 | + tx = kzalloc(2, GFP_KERNEL); | |
| 2022 | 2022 | if (!tx) |
| 2023 | 2023 | return -ENOMEM; |
| 2024 | − rx = kzalloc(2*sizeof(u8), GFP_KERNEL); | |
| 2024 | + rx = kzalloc(2, GFP_KERNEL); | |
| 2025 | 2025 | if (!rx) { |
| 2026 | 2026 | ret = -ENOMEM; |
| 2027 | 2027 | goto rx_memory_error; |
| @@ -4271,12 +4271,12 @@ static int dib8000_i2c_enumeration(struct i2c_adapter *host, int no_of_demods, · 4270 unmodified lines | ||
| 4271 | 4271 | u8 new_addr = 0; |
| 4272 | 4272 | struct i2c_device client = {.adap = host }; |
| 4273 | 4273 | |
| 4274 | − client.i2c_write_buffer = kzalloc(4 * sizeof(u8), GFP_KERNEL); | |
| 4274 | + client.i2c_write_buffer = kzalloc(4, GFP_KERNEL); | |
| 4275 | 4275 | if (!client.i2c_write_buffer) { |
| 4276 | 4276 | dprintk("%s: not enough memory\n", __func__); |
| 4277 | 4277 | return -ENOMEM; |
| 4278 | 4278 | } |
| 4279 | − client.i2c_read_buffer = kzalloc(4 * sizeof(u8), GFP_KERNEL); | |
| 4279 | + client.i2c_read_buffer = kzalloc(4, GFP_KERNEL); | |
| 4280 | 4280 | if (!client.i2c_read_buffer) { |
| 4281 | 4281 | dprintk("%s: not enough memory\n", __func__); |
| 4282 | 4282 | ret = -ENOMEM; |
| @@ -2381,12 +2381,12 @@ int dib9000_i2c_enumeration(struct i2c_adapter *i2c, int no_of_demods, u8 defaul · 2380 unmodified lines | ||
| 2381 | 2381 | u8 new_addr = 0; |
| 2382 | 2382 | struct i2c_device client = {.i2c_adap = i2c }; |
| 2383 | 2383 | |
| 2384 | − client.i2c_write_buffer = kzalloc(4 * sizeof(u8), GFP_KERNEL); | |
| 2384 | + client.i2c_write_buffer = kzalloc(4, GFP_KERNEL); | |
| 2385 | 2385 | if (!client.i2c_write_buffer) { |
| 2386 | 2386 | dprintk("%s: not enough memory\n", __func__); |
| 2387 | 2387 | return -ENOMEM; |
| 2388 | 2388 | } |
| 2389 | − client.i2c_read_buffer = kzalloc(4 * sizeof(u8), GFP_KERNEL); | |
| 2389 | + client.i2c_read_buffer = kzalloc(4, GFP_KERNEL); | |
| 2390 | 2390 | if (!client.i2c_read_buffer) { |
| 2391 | 2391 | dprintk("%s: not enough memory\n", __func__); |
| 2392 | 2392 | ret = -ENOMEM; |
| @@ -373,7 +373,7 @@ static int s5k5baf_fw_parse(struct device *dev, struct s5k5baf_fw **fw, · 372 unmodified lines | ||
| 373 | 373 | data += S5K5BAG_FW_TAG_LEN; |
| 374 | 374 | count -= S5K5BAG_FW_TAG_LEN; |
| 375 | 375 | |
| 376 | − d = devm_kzalloc(dev, count * sizeof(u16), GFP_KERNEL); | |
| 376 | + d = devm_kcalloc(dev, count, sizeof(u16), GFP_KERNEL); | |
| 377 | 377 | if (!d) |
| 378 | 378 | return -ENOMEM; |
| 379 | 379 | |
| @@ -256,7 +256,8 @@ bttv_risc_overlay(struct bttv *btv, struct btcx_riscmem *risc, · 255 unmodified lines | ||
| 256 | 256 | u32 addr; |
| 257 | 257 | |
| 258 | 258 | /* skip list for window clipping */ |
| 259 | − if (NULL == (skips = kmalloc(sizeof(*skips) * ov->nclips,GFP_KERNEL))) | |
| 259 | + skips = kmalloc_array(ov->nclips, sizeof(*skips),GFP_KERNEL); | |
| 260 | + if (NULL == skips) | |
| 260 | 261 | return -ENOMEM; |
| 261 | 262 | |
| 262 | 263 | /* estimate risc mem: worst case is (1.5*clip+1) * lines instructions |
| @@ -95,7 +95,7 @@ static int cx23885_alsa_dma_init(struct cx23885_audio_dev *chip, int nr_pages) · 94 unmodified lines | ||
| 95 | 95 | memset(buf->vaddr, 0, nr_pages << PAGE_SHIFT); |
| 96 | 96 | buf->nr_pages = nr_pages; |
| 97 | 97 | |
| 98 | − buf->sglist = vzalloc(buf->nr_pages * sizeof(*buf->sglist)); | |
| 98 | + buf->sglist = vzalloc(array_size(sizeof(*buf->sglist), buf->nr_pages)); | |
| 99 | 99 | if (NULL == buf->sglist) |
| 100 | 100 | goto vzalloc_err; |
| 101 | 101 | |
| @@ -159,7 +159,7 @@ static int cx25821_alsa_dma_init(struct cx25821_audio_dev *chip, int nr_pages) · 158 unmodified lines | ||
| 159 | 159 | memset(buf->vaddr, 0, nr_pages << PAGE_SHIFT); |
| 160 | 160 | buf->nr_pages = nr_pages; |
| 161 | 161 | |
| 162 | − buf->sglist = vzalloc(buf->nr_pages * sizeof(*buf->sglist)); | |
| 162 | + buf->sglist = vzalloc(array_size(sizeof(*buf->sglist), buf->nr_pages)); | |
| 163 | 163 | if (NULL == buf->sglist) |
| 164 | 164 | goto vzalloc_err; |
| 165 | 165 | |
| @@ -298,7 +298,7 @@ static int cx88_alsa_dma_init(struct cx88_audio_dev *chip, int nr_pages) · 297 unmodified lines | ||
| 298 | 298 | memset(buf->vaddr, 0, nr_pages << PAGE_SHIFT); |
| 299 | 299 | buf->nr_pages = nr_pages; |
| 300 | 300 | |
| 301 | − buf->sglist = vzalloc(buf->nr_pages * sizeof(*buf->sglist)); | |
| 301 | + buf->sglist = vzalloc(array_size(sizeof(*buf->sglist), buf->nr_pages)); | |
| 302 | 302 | if (!buf->sglist) |
| 303 | 303 | goto vzalloc_err; |
| 304 | 304 | |
| @@ -1077,7 +1077,7 @@ static int ivtvfb_init_vidmode(struct ivtv *itv) · 1076 unmodified lines | ||
| 1077 | 1077 | |
| 1078 | 1078 | /* Allocate the pseudo palette */ |
| 1079 | 1079 | oi->ivtvfb_info.pseudo_palette = |
| 1080 | − kmalloc(sizeof(u32) * 16, GFP_KERNEL|__GFP_NOWARN); | |
| 1080 | + kmalloc_array(16, sizeof(u32), GFP_KERNEL|__GFP_NOWARN); | |
| 1081 | 1081 | |
| 1082 | 1082 | if (!oi->ivtvfb_info.pseudo_palette) { |
| 1083 | 1083 | IVTVFB_ERR("abort, unable to alloc pseudo palette\n"); |
| @@ -1625,7 +1625,7 @@ static int meye_probe(struct pci_dev *pcidev, const struct pci_device_id *ent) · 1624 unmodified lines | ||
| 1625 | 1625 | ret = -ENOMEM; |
| 1626 | 1626 | meye.mchip_dev = pcidev; |
| 1627 | 1627 | |
| 1628 | − meye.grab_temp = vmalloc(MCHIP_NB_PAGES_MJPEG * PAGE_SIZE); | |
| 1628 | + meye.grab_temp = vmalloc(array_size(PAGE_SIZE, MCHIP_NB_PAGES_MJPEG)); | |
| 1629 | 1629 | if (!meye.grab_temp) |
| 1630 | 1630 | goto outvmalloc; |
| 1631 | 1631 | |
| @@ -615,7 +615,7 @@ static int pt1_init_tables(struct pt1 *pt1) · 614 unmodified lines | ||
| 615 | 615 | if (!pt1_nr_tables) |
| 616 | 616 | return 0; |
| 617 | 617 | |
| 618 | − tables = vmalloc(sizeof(struct pt1_table) * pt1_nr_tables); | |
| 618 | + tables = vmalloc(array_size(pt1_nr_tables, sizeof(struct pt1_table))); | |
| 619 | 619 | if (tables == NULL) |
| 620 | 620 | return -ENOMEM; |
| 621 | 621 | |
| @@ -279,7 +279,7 @@ static int saa7134_alsa_dma_init(struct saa7134_dev *dev, int nr_pages) · 278 unmodified lines | ||
| 279 | 279 | memset(dma->vaddr, 0, nr_pages << PAGE_SHIFT); |
| 280 | 280 | dma->nr_pages = nr_pages; |
| 281 | 281 | |
| 282 | − dma->sglist = vzalloc(dma->nr_pages * sizeof(*dma->sglist)); | |
| 282 | + dma->sglist = vzalloc(array_size(sizeof(*dma->sglist), dma->nr_pages)); | |
| 283 | 283 | if (NULL == dma->sglist) |
| 284 | 284 | goto vzalloc_err; |
| 285 | 285 | |
| @@ -24,7 +24,7 @@ void av7110_ipack_reset(struct ipack *p) · 23 unmodified lines | ||
| 24 | 24 | int av7110_ipack_init(struct ipack *p, int size, |
| 25 | 25 | void (*func)(u8 *buf, int size, void *priv)) |
| 26 | 26 | { |
| 27 | − if (!(p->buf = vmalloc(size*sizeof(u8)))) { | |
| 27 | + if (!(p->buf = vmalloc(size))) { | |
| 28 | 28 | printk(KERN_WARNING "Couldn't allocate memory for ipack\n"); |
| 29 | 29 | return -ENOMEM; |
| 30 | 30 | } |
| @@ -2586,8 +2586,10 @@ static int vpfe_probe(struct platform_device *pdev) · 2585 unmodified lines | ||
| 2586 | 2586 | |
| 2587 | 2587 | pm_runtime_put_sync(&pdev->dev); |
| 2588 | 2588 | |
| 2589 | − vpfe->sd = devm_kzalloc(&pdev->dev, sizeof(struct v4l2_subdev *) * | |
| 2590 | − ARRAY_SIZE(vpfe->cfg->asd), GFP_KERNEL); | |
| 2589 | + vpfe->sd = devm_kcalloc(&pdev->dev, | |
| 2590 | + ARRAY_SIZE(vpfe->cfg->asd), | |
| 2591 | + sizeof(struct v4l2_subdev *), | |
| 2592 | + GFP_KERNEL); | |
| 2591 | 2593 | if (!vpfe->sd) { |
| 2592 | 2594 | ret = -ENOMEM; |
| 2593 | 2595 | goto probe_out_v4l2_unregister; |
| @@ -1528,8 +1528,10 @@ vpif_capture_get_pdata(struct platform_device *pdev) · 1527 unmodified lines | ||
| 1528 | 1528 | if (!pdata) |
| 1529 | 1529 | return NULL; |
| 1530 | 1530 | pdata->subdev_info = |
| 1531 | − devm_kzalloc(&pdev->dev, sizeof(*pdata->subdev_info) * | |
| 1532 | − VPIF_CAPTURE_NUM_CHANNELS, GFP_KERNEL); | |
| 1531 | + devm_kcalloc(&pdev->dev, | |
| 1532 | + VPIF_CAPTURE_NUM_CHANNELS, | |
| 1533 | + sizeof(*pdata->subdev_info), | |
| 1534 | + GFP_KERNEL); | |
| 1533 | 1535 | |
| 1534 | 1536 | if (!pdata->subdev_info) |
| 1535 | 1537 | return NULL; |
| @@ -1546,9 +1548,9 @@ vpif_capture_get_pdata(struct platform_device *pdev) · 10 unmodified lines | ||
| 1546 | 1548 | |
| 1547 | 1549 | sdinfo = &pdata->subdev_info[i]; |
| 1548 | 1550 | chan = &pdata->chan_config[i]; |
| 1549 | − chan->inputs = devm_kzalloc(&pdev->dev, | |
| 1550 | − sizeof(*chan->inputs) * | |
| 1551 | + chan->inputs = devm_kcalloc(&pdev->dev, | |
| 1551 | 1552 | VPIF_CAPTURE_NUM_CHANNELS, |
| 1553 | + sizeof(*chan->inputs), | |
| 1552 | 1554 | GFP_KERNEL); |
| 1553 | 1555 | if (!chan->inputs) |
| 1554 | 1556 | return NULL; |
| @@ -845,7 +845,7 @@ int msm_csid_subdev_init(struct csid_device *csid, · 844 unmodified lines | ||
| 845 | 845 | while (res->clock[csid->nclocks]) |
| 846 | 846 | csid->nclocks++; |
| 847 | 847 | |
| 848 | − csid->clock = devm_kzalloc(dev, csid->nclocks * sizeof(*csid->clock), | |
| 848 | + csid->clock = devm_kcalloc(dev, csid->nclocks, sizeof(*csid->clock), | |
| 849 | 849 | GFP_KERNEL); |
| 850 | 850 | if (!csid->clock) |
| 851 | 851 | return -ENOMEM; |
| @@ -868,8 +868,10 @@ int msm_csid_subdev_init(struct csid_device *csid, · 16 unmodified lines | ||
| 868 | 868 | continue; |
| 869 | 869 | } |
| 870 | 870 | |
| 871 | − clock->freq = devm_kzalloc(dev, clock->nfreqs * | |
| 872 | − sizeof(*clock->freq), GFP_KERNEL); | |
| 871 | + clock->freq = devm_kcalloc(dev, | |
| 872 | + clock->nfreqs, | |
| 873 | + sizeof(*clock->freq), | |
| 874 | + GFP_KERNEL); | |
| 873 | 875 | if (!clock->freq) |
| 874 | 876 | return -ENOMEM; |
| 875 | 877 | |
| @@ -732,8 +732,9 @@ int msm_csiphy_subdev_init(struct csiphy_device *csiphy, · 731 unmodified lines | ||
| 732 | 732 | while (res->clock[csiphy->nclocks]) |
| 733 | 733 | csiphy->nclocks++; |
| 734 | 734 | |
| 735 | − csiphy->clock = devm_kzalloc(dev, csiphy->nclocks * | |
| 736 | − sizeof(*csiphy->clock), GFP_KERNEL); | |
| 735 | + csiphy->clock = devm_kcalloc(dev, | |
| 736 | + csiphy->nclocks, sizeof(*csiphy->clock), | |
| 737 | + GFP_KERNEL); | |
| 737 | 738 | if (!csiphy->clock) |
| 738 | 739 | return -ENOMEM; |
| 739 | 740 | |
| @@ -755,8 +756,10 @@ int msm_csiphy_subdev_init(struct csiphy_device *csiphy, · 15 unmodified lines | ||
| 755 | 756 | continue; |
| 756 | 757 | } |
| 757 | 758 | |
| 758 | − clock->freq = devm_kzalloc(dev, clock->nfreqs * | |
| 759 | − sizeof(*clock->freq), GFP_KERNEL); | |
| 759 | + clock->freq = devm_kcalloc(dev, | |
| 760 | + clock->nfreqs, | |
| 761 | + sizeof(*clock->freq), | |
| 762 | + GFP_KERNEL); | |
| 760 | 763 | if (!clock->freq) |
| 761 | 764 | return -ENOMEM; |
| 762 | 765 | |
| @@ -948,7 +948,8 @@ int msm_ispif_subdev_init(struct ispif_device *ispif, · 947 unmodified lines | ||
| 948 | 948 | while (res->clock[ispif->nclocks]) |
| 949 | 949 | ispif->nclocks++; |
| 950 | 950 | |
| 951 | − ispif->clock = devm_kzalloc(dev, ispif->nclocks * sizeof(*ispif->clock), | |
| 951 | + ispif->clock = devm_kcalloc(dev, | |
| 952 | + ispif->nclocks, sizeof(*ispif->clock), | |
| 952 | 953 | GFP_KERNEL); |
| 953 | 954 | if (!ispif->clock) |
| 954 | 955 | return -ENOMEM; |
| @@ -968,8 +969,10 @@ int msm_ispif_subdev_init(struct ispif_device *ispif, · 13 unmodified lines | ||
| 968 | 969 | while (res->clock_for_reset[ispif->nclocks_for_reset]) |
| 969 | 970 | ispif->nclocks_for_reset++; |
| 970 | 971 | |
| 971 | − ispif->clock_for_reset = devm_kzalloc(dev, ispif->nclocks_for_reset * | |
| 972 | − sizeof(*ispif->clock_for_reset), GFP_KERNEL); | |
| 972 | + ispif->clock_for_reset = devm_kcalloc(dev, | |
| 973 | + ispif->nclocks_for_reset, | |
| 974 | + sizeof(*ispif->clock_for_reset), | |
| 975 | + GFP_KERNEL); | |
| 973 | 976 | if (!ispif->clock_for_reset) |
| 974 | 977 | return -ENOMEM; |
| 975 | 978 | |
| @@ -2794,7 +2794,7 @@ int msm_vfe_subdev_init(struct vfe_device *vfe, const struct resources *res) · 2793 unmodified lines | ||
| 2794 | 2794 | while (res->clock[vfe->nclocks]) |
| 2795 | 2795 | vfe->nclocks++; |
| 2796 | 2796 | |
| 2797 | − vfe->clock = devm_kzalloc(dev, vfe->nclocks * sizeof(*vfe->clock), | |
| 2797 | + vfe->clock = devm_kcalloc(dev, vfe->nclocks, sizeof(*vfe->clock), | |
| 2798 | 2798 | GFP_KERNEL); |
| 2799 | 2799 | if (!vfe->clock) |
| 2800 | 2800 | return -ENOMEM; |
| @@ -2817,8 +2817,10 @@ int msm_vfe_subdev_init(struct vfe_device *vfe, const struct resources *res) · 16 unmodified lines | ||
| 2817 | 2817 | continue; |
| 2818 | 2818 | } |
| 2819 | 2819 | |
| 2820 | − clock->freq = devm_kzalloc(dev, clock->nfreqs * | |
| 2821 | − sizeof(*clock->freq), GFP_KERNEL); | |
| 2820 | + clock->freq = devm_kcalloc(dev, | |
| 2821 | + clock->nfreqs, | |
| 2822 | + sizeof(*clock->freq), | |
| 2823 | + GFP_KERNEL); | |
| 2822 | 2824 | if (!clock->freq) |
| 2823 | 2825 | return -ENOMEM; |
| 2824 | 2826 | |
| @@ -271,7 +271,8 @@ static int camss_of_parse_endpoint_node(struct device *dev, · 270 unmodified lines | ||
| 271 | 271 | lncfg->clk.pol = mipi_csi2->lane_polarities[0]; |
| 272 | 272 | lncfg->num_data = mipi_csi2->num_data_lanes; |
| 273 | 273 | |
| 274 | − lncfg->data = devm_kzalloc(dev, lncfg->num_data * sizeof(*lncfg->data), | |
| 274 | + lncfg->data = devm_kcalloc(dev, | |
| 275 | + lncfg->num_data, sizeof(*lncfg->data), | |
| 275 | 276 | GFP_KERNEL); |
| 276 | 277 | if (!lncfg->data) |
| 277 | 278 | return -ENOMEM; |
| @@ -481,7 +481,8 @@ static int soc_camera_init_user_formats(struct soc_camera_device *icd) · 480 unmodified lines | ||
| 481 | 481 | return -ENXIO; |
| 482 | 482 | |
| 483 | 483 | icd->user_formats = |
| 484 | − vmalloc(fmts * sizeof(struct soc_camera_format_xlate)); | |
| 484 | + vmalloc(array_size(fmts, | |
| 485 | + sizeof(struct soc_camera_format_xlate))); | |
| 485 | 486 | if (!icd->user_formats) |
| 486 | 487 | return -ENOMEM; |
| 487 | 488 | |
| @@ -844,10 +844,10 @@ static int vivid_create_instance(struct platform_device *pdev, int inst) · 843 unmodified lines | ||
| 844 | 844 | tpg_init(&dev->tpg, 640, 360); |
| 845 | 845 | if (tpg_alloc(&dev->tpg, MAX_ZOOM * MAX_WIDTH)) |
| 846 | 846 | goto free_dev; |
| 847 | − dev->scaled_line = vzalloc(MAX_ZOOM * MAX_WIDTH); | |
| 847 | + dev->scaled_line = vzalloc(array_size(MAX_WIDTH, MAX_ZOOM)); | |
| 848 | 848 | if (!dev->scaled_line) |
| 849 | 849 | goto free_dev; |
| 850 | − dev->blended_line = vzalloc(MAX_ZOOM * MAX_WIDTH); | |
| 850 | + dev->blended_line = vzalloc(array_size(MAX_WIDTH, MAX_ZOOM)); | |
| 851 | 851 | if (!dev->blended_line) |
| 852 | 852 | goto free_dev; |
| 853 | 853 | |
| @@ -859,8 +859,9 @@ static int vivid_create_instance(struct platform_device *pdev, int inst) · 5 unmodified lines | ||
| 859 | 859 | /* create a string array containing the names of all the preset timings */ |
| 860 | 860 | while (v4l2_dv_timings_presets[dev->query_dv_timings_size].bt.width) |
| 861 | 861 | dev->query_dv_timings_size++; |
| 862 | − dev->query_dv_timings_qmenu = kmalloc(dev->query_dv_timings_size * | |
| 863 | − (sizeof(void *) + 32), GFP_KERNEL); | |
| 862 | + dev->query_dv_timings_qmenu = kmalloc_array(dev->query_dv_timings_size, | |
| 863 | + (sizeof(void *) + 32), | |
| 864 | + GFP_KERNEL); | |
| 864 | 865 | if (dev->query_dv_timings_qmenu == NULL) |
| 865 | 866 | goto free_dev; |
| 866 | 867 | for (i = 0; i < dev->query_dv_timings_size; i++) { |
| @@ -630,7 +630,8 @@ int vsp1_entity_init(struct vsp1_device *vsp1, struct vsp1_entity *entity, · 629 unmodified lines | ||
| 630 | 630 | entity->source_pad = num_pads - 1; |
| 631 | 631 | |
| 632 | 632 | /* Allocate and initialize pads. */ |
| 633 | − entity->pads = devm_kzalloc(vsp1->dev, num_pads * sizeof(*entity->pads), | |
| 633 | + entity->pads = devm_kcalloc(vsp1->dev, | |
| 634 | + num_pads, sizeof(*entity->pads), | |
| 634 | 635 | GFP_KERNEL); |
| 635 | 636 | if (entity->pads == NULL) |
| 636 | 637 | return -ENOMEM; |
| @@ -532,7 +532,7 @@ static int xvip_graph_init(struct xvip_composite_device *xdev) · 531 unmodified lines | ||
| 532 | 532 | |
| 533 | 533 | /* Register the subdevices notifier. */ |
| 534 | 534 | num_subdevs = xdev->num_subdevs; |
| 535 | − subdevs = devm_kzalloc(xdev->dev, sizeof(*subdevs) * num_subdevs, | |
| 535 | + subdevs = devm_kcalloc(xdev->dev, num_subdevs, sizeof(*subdevs), | |
| 536 | 536 | GFP_KERNEL); |
| 537 | 537 | if (subdevs == NULL) { |
| 538 | 538 | ret = -ENOMEM; |
| @@ -217,14 +217,14 @@ static int au0828_init_isoc(struct au0828_dev *dev, int max_packets, · 216 unmodified lines | ||
| 217 | 217 | dev->isoc_ctl.isoc_copy = isoc_copy; |
| 218 | 218 | dev->isoc_ctl.num_bufs = num_bufs; |
| 219 | 219 | |
| 220 | − dev->isoc_ctl.urb = kzalloc(sizeof(void *)*num_bufs, GFP_KERNEL); | |
| 220 | + dev->isoc_ctl.urb = kcalloc(num_bufs, sizeof(void *), GFP_KERNEL); | |
| 221 | 221 | if (!dev->isoc_ctl.urb) { |
| 222 | 222 | au0828_isocdbg("cannot alloc memory for usb buffers\n"); |
| 223 | 223 | return -ENOMEM; |
| 224 | 224 | } |
| 225 | 225 | |
| 226 | − dev->isoc_ctl.transfer_buffer = kzalloc(sizeof(void *)*num_bufs, | |
| 227 | − GFP_KERNEL); | |
| 226 | + dev->isoc_ctl.transfer_buffer = kcalloc(num_bufs, sizeof(void *), | |
| 227 | + GFP_KERNEL); | |
| 228 | 228 | if (!dev->isoc_ctl.transfer_buffer) { |
| 229 | 229 | au0828_isocdbg("cannot allocate memory for usb transfer\n"); |
| 230 | 230 | kfree(dev->isoc_ctl.urb); |
| @@ -663,7 +663,8 @@ static int submit_urbs(struct camera_data *cam) · 662 unmodified lines | ||
| 663 | 663 | if (cam->sbuf[i].data) |
| 664 | 664 | continue; |
| 665 | 665 | cam->sbuf[i].data = |
| 666 | − kmalloc(FRAMES_PER_DESC * FRAME_SIZE_PER_DESC, GFP_KERNEL); | |
| 666 | + kmalloc_array(FRAME_SIZE_PER_DESC, FRAMES_PER_DESC, | |
| 667 | + GFP_KERNEL); | |
| 667 | 668 | if (!cam->sbuf[i].data) { |
| 668 | 669 | while (--i >= 0) { |
| 669 | 670 | kfree(cam->sbuf[i].data); |
| @@ -710,7 +710,7 @@ static int cx231xx_audio_init(struct cx231xx *dev) · 709 unmodified lines | ||
| 710 | 710 | dev_info(dev->dev, |
| 711 | 711 | "audio EndPoint Addr 0x%x, Alternate settings: %i\n", |
| 712 | 712 | adev->end_point_addr, adev->num_alt); |
| 713 | − adev->alt_max_pkt_size = kmalloc(32 * adev->num_alt, GFP_KERNEL); | |
| 713 | + adev->alt_max_pkt_size = kmalloc_array(32, adev->num_alt, GFP_KERNEL); | |
| 714 | 714 | if (!adev->alt_max_pkt_size) { |
| 715 | 715 | err = -ENOMEM; |
| 716 | 716 | goto err_free_card; |
| @@ -1034,7 +1034,7 @@ int cx231xx_init_isoc(struct cx231xx *dev, int max_packets, · 1033 unmodified lines | ||
| 1034 | 1034 | dma_q->partial_buf[i] = 0; |
| 1035 | 1035 | |
| 1036 | 1036 | dev->video_mode.isoc_ctl.urb = |
| 1037 | − kzalloc(sizeof(void *) * num_bufs, GFP_KERNEL); | |
| 1037 | + kcalloc(num_bufs, sizeof(void *), GFP_KERNEL); | |
| 1038 | 1038 | if (!dev->video_mode.isoc_ctl.urb) { |
| 1039 | 1039 | dev_err(dev->dev, |
| 1040 | 1040 | "cannot alloc memory for usb buffers\n"); |
| @@ -1042,7 +1042,7 @@ int cx231xx_init_isoc(struct cx231xx *dev, int max_packets, · 1 unmodified line | ||
| 1042 | 1042 | } |
| 1043 | 1043 | |
| 1044 | 1044 | dev->video_mode.isoc_ctl.transfer_buffer = |
| 1045 | − kzalloc(sizeof(void *) * num_bufs, GFP_KERNEL); | |
| 1045 | + kcalloc(num_bufs, sizeof(void *), GFP_KERNEL); | |
| 1046 | 1046 | if (!dev->video_mode.isoc_ctl.transfer_buffer) { |
| 1047 | 1047 | dev_err(dev->dev, |
| 1048 | 1048 | "cannot allocate memory for usbtransfer\n"); |
| @@ -1169,7 +1169,7 @@ int cx231xx_init_bulk(struct cx231xx *dev, int max_packets, · 120 unmodified lines | ||
| 1169 | 1169 | dma_q->partial_buf[i] = 0; |
| 1170 | 1170 | |
| 1171 | 1171 | dev->video_mode.bulk_ctl.urb = |
| 1172 | − kzalloc(sizeof(void *) * num_bufs, GFP_KERNEL); | |
| 1172 | + kcalloc(num_bufs, sizeof(void *), GFP_KERNEL); | |
| 1173 | 1173 | if (!dev->video_mode.bulk_ctl.urb) { |
| 1174 | 1174 | dev_err(dev->dev, |
| 1175 | 1175 | "cannot alloc memory for usb buffers\n"); |
| @@ -1177,7 +1177,7 @@ int cx231xx_init_bulk(struct cx231xx *dev, int max_packets, · 1 unmodified line | ||
| 1177 | 1177 | } |
| 1178 | 1178 | |
| 1179 | 1179 | dev->video_mode.bulk_ctl.transfer_buffer = |
| 1180 | − kzalloc(sizeof(void *) * num_bufs, GFP_KERNEL); | |
| 1180 | + kcalloc(num_bufs, sizeof(void *), GFP_KERNEL); | |
| 1181 | 1181 | if (!dev->video_mode.bulk_ctl.transfer_buffer) { |
| 1182 | 1182 | dev_err(dev->dev, |
| 1183 | 1183 | "cannot allocate memory for usbtransfer\n"); |
| @@ -415,7 +415,7 @@ int cx231xx_init_vbi_isoc(struct cx231xx *dev, int max_packets, · 414 unmodified lines | ||
| 415 | 415 | for (i = 0; i < 8; i++) |
| 416 | 416 | dma_q->partial_buf[i] = 0; |
| 417 | 417 | |
| 418 | − dev->vbi_mode.bulk_ctl.urb = kzalloc(sizeof(void *) * num_bufs, | |
| 418 | + dev->vbi_mode.bulk_ctl.urb = kcalloc(num_bufs, sizeof(void *), | |
| 419 | 419 | GFP_KERNEL); |
| 420 | 420 | if (!dev->vbi_mode.bulk_ctl.urb) { |
| 421 | 421 | dev_err(dev->dev, |
| @@ -424,7 +424,7 @@ int cx231xx_init_vbi_isoc(struct cx231xx *dev, int max_packets, · 2 unmodified lines | ||
| 424 | 424 | } |
| 425 | 425 | |
| 426 | 426 | dev->vbi_mode.bulk_ctl.transfer_buffer = |
| 427 | − kzalloc(sizeof(void *) * num_bufs, GFP_KERNEL); | |
| 427 | + kcalloc(num_bufs, sizeof(void *), GFP_KERNEL); | |
| 428 | 428 | if (!dev->vbi_mode.bulk_ctl.transfer_buffer) { |
| 429 | 429 | dev_err(dev->dev, |
| 430 | 430 | "cannot allocate memory for usbtransfer\n"); |
| @@ -1579,7 +1579,7 @@ int go7007_construct_fw_image(struct go7007 *go, u8 **fw, int *fwlen) · 1578 unmodified lines | ||
| 1579 | 1579 | GO7007_FW_NAME); |
| 1580 | 1580 | return -1; |
| 1581 | 1581 | } |
| 1582 | − code = kzalloc(codespace * 2, GFP_KERNEL); | |
| 1582 | + code = kcalloc(codespace, 2, GFP_KERNEL); | |
| 1583 | 1583 | if (code == NULL) |
| 1584 | 1584 | goto fw_failed; |
| 1585 | 1585 | |
| @@ -1143,7 +1143,8 @@ static int go7007_usb_probe(struct usb_interface *intf, · 1142 unmodified lines | ||
| 1143 | 1143 | usb->intr_urb = usb_alloc_urb(0, GFP_KERNEL); |
| 1144 | 1144 | if (usb->intr_urb == NULL) |
| 1145 | 1145 | goto allocfail; |
| 1146 | − usb->intr_urb->transfer_buffer = kmalloc(2*sizeof(u16), GFP_KERNEL); | |
| 1146 | + usb->intr_urb->transfer_buffer = kmalloc_array(2, sizeof(u16), | |
| 1147 | + GFP_KERNEL); | |
| 1147 | 1148 | if (usb->intr_urb->transfer_buffer == NULL) |
| 1148 | 1149 | goto allocfail; |
| 1149 | 1150 | |
| @@ -363,7 +363,7 @@ static void reg_w_ixbuf(struct gspca_dev *gspca_dev, · 362 unmodified lines | ||
| 363 | 363 | if (len * 2 <= USB_BUF_SZ) { |
| 364 | 364 | p = tmpbuf = gspca_dev->usb_buf; |
| 365 | 365 | } else { |
| 366 | − p = tmpbuf = kmalloc(len * 2, GFP_KERNEL); | |
| 366 | + p = tmpbuf = kmalloc_array(len, 2, GFP_KERNEL); | |
| 367 | 367 | if (!tmpbuf) { |
| 368 | 368 | pr_err("Out of memory\n"); |
| 369 | 369 | return; |
| @@ -2413,7 +2413,7 @@ struct pvr2_hdw *pvr2_hdw_create(struct usb_interface *intf, · 2412 unmodified lines | ||
| 2413 | 2413 | |
| 2414 | 2414 | hdw->control_cnt = CTRLDEF_COUNT; |
| 2415 | 2415 | hdw->control_cnt += MPEGDEF_COUNT; |
| 2416 | − hdw->controls = kzalloc(sizeof(struct pvr2_ctrl) * hdw->control_cnt, | |
| 2416 | + hdw->controls = kcalloc(hdw->control_cnt, sizeof(struct pvr2_ctrl), | |
| 2417 | 2417 | GFP_KERNEL); |
| 2418 | 2418 | if (!hdw->controls) goto fail; |
| 2419 | 2419 | hdw->hdw_desc = hdw_desc; |
| @@ -361,7 +361,7 @@ struct v4l2_standard *pvr2_std_create_enum(unsigned int *countptr, · 360 unmodified lines | ||
| 361 | 361 | std_cnt); |
| 362 | 362 | if (!std_cnt) return NULL; // paranoia |
| 363 | 363 | |
| 364 | − stddefs = kzalloc(sizeof(struct v4l2_standard) * std_cnt, | |
| 364 | + stddefs = kcalloc(std_cnt, sizeof(struct v4l2_standard), | |
| 365 | 365 | GFP_KERNEL); |
| 366 | 366 | if (!stddefs) |
| 367 | 367 | return NULL; |
| @@ -290,8 +290,9 @@ static int stk1160_probe(struct usb_interface *interface, · 289 unmodified lines | ||
| 290 | 290 | return -ENODEV; |
| 291 | 291 | |
| 292 | 292 | /* Alloc an array for all possible max_pkt_size */ |
| 293 | − alt_max_pkt_size = kmalloc(sizeof(alt_max_pkt_size[0]) * | |
| 294 | − interface->num_altsetting, GFP_KERNEL); | |
| 293 | + alt_max_pkt_size = kmalloc_array(interface->num_altsetting, | |
| 294 | + sizeof(alt_max_pkt_size[0]), | |
| 295 | + GFP_KERNEL); | |
| 295 | 296 | if (alt_max_pkt_size == NULL) |
| 296 | 297 | return -ENOMEM; |
| 297 | 298 | |
| @@ -439,14 +439,14 @@ int stk1160_alloc_isoc(struct stk1160 *dev) · 438 unmodified lines | ||
| 439 | 439 | |
| 440 | 440 | dev->isoc_ctl.buf = NULL; |
| 441 | 441 | dev->isoc_ctl.max_pkt_size = dev->max_pkt_size; |
| 442 | − dev->isoc_ctl.urb = kzalloc(sizeof(void *)*num_bufs, GFP_KERNEL); | |
| 442 | + dev->isoc_ctl.urb = kcalloc(num_bufs, sizeof(void *), GFP_KERNEL); | |
| 443 | 443 | if (!dev->isoc_ctl.urb) { |
| 444 | 444 | stk1160_err("out of memory for urb array\n"); |
| 445 | 445 | return -ENOMEM; |
| 446 | 446 | } |
| 447 | 447 | |
| 448 | − dev->isoc_ctl.transfer_buffer = kzalloc(sizeof(void *)*num_bufs, | |
| 449 | − GFP_KERNEL); | |
| 448 | + dev->isoc_ctl.transfer_buffer = kcalloc(num_bufs, sizeof(void *), | |
| 449 | + GFP_KERNEL); | |
| 450 | 450 | if (!dev->isoc_ctl.transfer_buffer) { |
| 451 | 451 | stk1160_err("out of memory for usb transfers\n"); |
| 452 | 452 | kfree(dev->isoc_ctl.urb); |
| @@ -567,8 +567,9 @@ static int stk_prepare_sio_buffers(struct stk_camera *dev, unsigned n_sbufs) · 566 unmodified lines | ||
| 567 | 567 | if (dev->sio_bufs != NULL) |
| 568 | 568 | pr_err("sio_bufs already allocated\n"); |
| 569 | 569 | else { |
| 570 | − dev->sio_bufs = kzalloc(n_sbufs * sizeof(struct stk_sio_buffer), | |
| 571 | − GFP_KERNEL); | |
| 570 | + dev->sio_bufs = kcalloc(n_sbufs, | |
| 571 | + sizeof(struct stk_sio_buffer), | |
| 572 | + GFP_KERNEL); | |
| 572 | 573 | if (dev->sio_bufs == NULL) |
| 573 | 574 | return -ENOMEM; |
| 574 | 575 | for (i = 0; i < n_sbufs; i++) { |
| @@ -463,11 +463,12 @@ static int tm6000_alloc_urb_buffers(struct tm6000_core *dev) · 462 unmodified lines | ||
| 463 | 463 | if (dev->urb_buffer) |
| 464 | 464 | return 0; |
| 465 | 465 | |
| 466 | − dev->urb_buffer = kmalloc(sizeof(void *)*num_bufs, GFP_KERNEL); | |
| 466 | + dev->urb_buffer = kmalloc_array(num_bufs, sizeof(void *), GFP_KERNEL); | |
| 467 | 467 | if (!dev->urb_buffer) |
| 468 | 468 | return -ENOMEM; |
| 469 | 469 | |
| 470 | − dev->urb_dma = kmalloc(sizeof(dma_addr_t *)*num_bufs, GFP_KERNEL); | |
| 470 | + dev->urb_dma = kmalloc_array(num_bufs, sizeof(dma_addr_t *), | |
| 471 | + GFP_KERNEL); | |
| 471 | 472 | if (!dev->urb_dma) |
| 472 | 473 | return -ENOMEM; |
| 473 | 474 | |
| @@ -583,12 +584,14 @@ static int tm6000_prepare_isoc(struct tm6000_core *dev) · 109 unmodified lines | ||
| 583 | 584 | |
| 584 | 585 | dev->isoc_ctl.num_bufs = num_bufs; |
| 585 | 586 | |
| 586 | − dev->isoc_ctl.urb = kmalloc(sizeof(void *)*num_bufs, GFP_KERNEL); | |
| 587 | + dev->isoc_ctl.urb = kmalloc_array(num_bufs, sizeof(void *), | |
| 588 | + GFP_KERNEL); | |
| 587 | 589 | if (!dev->isoc_ctl.urb) |
| 588 | 590 | return -ENOMEM; |
| 589 | 591 | |
| 590 | − dev->isoc_ctl.transfer_buffer = kmalloc(sizeof(void *)*num_bufs, | |
| 591 | − GFP_KERNEL); | |
| 592 | + dev->isoc_ctl.transfer_buffer = kmalloc_array(num_bufs, | |
| 593 | + sizeof(void *), | |
| 594 | + GFP_KERNEL); | |
| 592 | 595 | if (!dev->isoc_ctl.transfer_buffer) { |
| 593 | 596 | kfree(dev->isoc_ctl.urb); |
| 594 | 597 | return -ENOMEM; |
| @@ -507,7 +507,7 @@ static struct urb *usbtv_setup_iso_transfer(struct usbtv *usbtv) · 506 unmodified lines | ||
| 507 | 507 | ip->pipe = usb_rcvisocpipe(usbtv->udev, USBTV_VIDEO_ENDP); |
| 508 | 508 | ip->interval = 1; |
| 509 | 509 | ip->transfer_flags = URB_ISO_ASAP; |
| 510 | − ip->transfer_buffer = kzalloc(size * USBTV_ISOC_PACKETS, | |
| 510 | + ip->transfer_buffer = kcalloc(USBTV_ISOC_PACKETS, size, | |
| 511 | 511 | GFP_KERNEL); |
| 512 | 512 | if (!ip->transfer_buffer) { |
| 513 | 513 | usb_free_urb(ip); |
| @@ -1492,7 +1492,8 @@ static int usbvision_probe(struct usb_interface *intf, · 1491 unmodified lines | ||
| 1492 | 1492 | |
| 1493 | 1493 | usbvision->num_alt = uif->num_altsetting; |
| 1494 | 1494 | PDEBUG(DBG_PROBE, "Alternate settings: %i", usbvision->num_alt); |
| 1495 | − usbvision->alt_max_pkt_size = kmalloc(32 * usbvision->num_alt, GFP_KERNEL); | |
| 1495 | + usbvision->alt_max_pkt_size = kmalloc_array(32, usbvision->num_alt, | |
| 1496 | + GFP_KERNEL); | |
| 1496 | 1497 | if (!usbvision->alt_max_pkt_size) { |
| 1497 | 1498 | ret = -ENOMEM; |
| 1498 | 1499 | goto err_pkt; |
| @@ -513,8 +513,8 @@ static int uvc_video_clock_init(struct uvc_streaming *stream) · 512 unmodified lines | ||
| 513 | 513 | spin_lock_init(&clock->lock); |
| 514 | 514 | clock->size = 32; |
| 515 | 515 | |
| 516 | − clock->samples = kmalloc(clock->size * sizeof(*clock->samples), | |
| 517 | − GFP_KERNEL); | |
| 516 | + clock->samples = kmalloc_array(clock->size, sizeof(*clock->samples), | |
| 517 | + GFP_KERNEL); | |
| 518 | 518 | if (clock->samples == NULL) |
| 519 | 519 | return -ENOMEM; |
| 520 | 520 | |
| @@ -215,8 +215,7 @@ int v4l2_event_subscribe(struct v4l2_fh *fh, · 214 unmodified lines | ||
| 215 | 215 | if (elems < 1) |
| 216 | 216 | elems = 1; |
| 217 | 217 | |
| 218 | − sev = kvzalloc(sizeof(*sev) + sizeof(struct v4l2_kevent) * elems, | |
| 219 | − GFP_KERNEL); | |
| 218 | + sev = kvzalloc(struct_size(sev, events, elems), GFP_KERNEL); | |
| 220 | 219 | if (!sev) |
| 221 | 220 | return -ENOMEM; |
| 222 | 221 | for (i = 0; i < elems; i++) |
| @@ -412,9 +412,10 @@ static int v4l2_flash_init_controls(struct v4l2_flash *v4l2_flash, · 411 unmodified lines | ||
| 412 | 412 | struct v4l2_ctrl_config *ctrl_cfg; |
| 413 | 413 | int i, ret, num_ctrls = 0; |
| 414 | 414 | |
| 415 | − v4l2_flash->ctrls = devm_kzalloc(v4l2_flash->sd.dev, | |
| 416 | − sizeof(*v4l2_flash->ctrls) * | |
| 417 | − (STROBE_SOURCE + 1), GFP_KERNEL); | |
| 415 | + v4l2_flash->ctrls = devm_kcalloc(v4l2_flash->sd.dev, | |
| 416 | + STROBE_SOURCE + 1, | |
| 417 | + sizeof(*v4l2_flash->ctrls), | |
| 418 | + GFP_KERNEL); | |
| 418 | 419 | if (!v4l2_flash->ctrls) |
| 419 | 420 | return -ENOMEM; |
| 420 | 421 | |
| @@ -69,7 +69,7 @@ static struct scatterlist *videobuf_vmalloc_to_sg(unsigned char *virt, · 68 unmodified lines | ||
| 69 | 69 | struct page *pg; |
| 70 | 70 | int i; |
| 71 | 71 | |
| 72 | − sglist = vzalloc(nr_pages * sizeof(*sglist)); | |
| 72 | + sglist = vzalloc(array_size(nr_pages, sizeof(*sglist))); | |
| 73 | 73 | if (NULL == sglist) |
| 74 | 74 | return NULL; |
| 75 | 75 | sg_init_table(sglist, nr_pages); |
| @@ -100,7 +100,7 @@ static struct scatterlist *videobuf_pages_to_sg(struct page **pages, · 24 unmodified lines | ||
| 100 | 100 | |
| 101 | 101 | if (NULL == pages[0]) |
| 102 | 102 | return NULL; |
| 103 | − sglist = vmalloc(nr_pages * sizeof(*sglist)); | |
| 103 | + sglist = vmalloc(array_size(nr_pages, sizeof(*sglist))); | |
| 104 | 104 | if (NULL == sglist) |
| 105 | 105 | return NULL; |
| 106 | 106 | sg_init_table(sglist, nr_pages); |
| @@ -175,7 +175,8 @@ static int videobuf_dma_init_user_locked(struct videobuf_dmabuf *dma, · 68 unmodified lines | ||
| 175 | 175 | dma->offset = data & ~PAGE_MASK; |
| 176 | 176 | dma->size = size; |
| 177 | 177 | dma->nr_pages = last-first+1; |
| 178 | − dma->pages = kmalloc(dma->nr_pages * sizeof(struct page *), GFP_KERNEL); | |
| 178 | + dma->pages = kmalloc_array(dma->nr_pages, sizeof(struct page *), | |
| 179 | + GFP_KERNEL); | |
| 179 | 180 | if (NULL == dma->pages) |
| 180 | 181 | return -ENOMEM; |
| 181 | 182 | |
| @@ -126,8 +126,8 @@ const struct lpddr2_timings *of_get_ddr_timings(struct device_node *np_ddr, · 125 unmodified lines | ||
| 126 | 126 | arr_sz++; |
| 127 | 127 | |
| 128 | 128 | if (arr_sz) |
| 129 | − timings = devm_kzalloc(dev, sizeof(*timings) * arr_sz, | |
| 130 | − GFP_KERNEL); | |
| 129 | + timings = devm_kcalloc(dev, arr_sz, sizeof(*timings), | |
| 130 | + GFP_KERNEL); | |
| 131 | 131 | |
| 132 | 132 | if (!timings) |
| 133 | 133 | goto default_timings; |
| @@ -1201,7 +1201,8 @@ static int msb_read_boot_blocks(struct msb_data *msb) · 1200 unmodified lines | ||
| 1201 | 1201 | dbg_verbose("Start of a scan for the boot blocks"); |
| 1202 | 1202 | |
| 1203 | 1203 | if (!msb->boot_page) { |
| 1204 | − page = kmalloc(sizeof(struct ms_boot_page)*2, GFP_KERNEL); | |
| 1204 | + page = kmalloc_array(2, sizeof(struct ms_boot_page), | |
| 1205 | + GFP_KERNEL); | |
| 1205 | 1206 | if (!page) |
| 1206 | 1207 | return -ENOMEM; |
| 1207 | 1208 | |
| @@ -1341,7 +1342,8 @@ static int msb_ftl_initialize(struct msb_data *msb) · 133 unmodified lines | ||
| 1341 | 1342 | msb->used_blocks_bitmap = kzalloc(msb->block_count / 8, GFP_KERNEL); |
| 1342 | 1343 | msb->erased_blocks_bitmap = kzalloc(msb->block_count / 8, GFP_KERNEL); |
| 1343 | 1344 | msb->lba_to_pba_table = |
| 1344 | − kmalloc(msb->logical_block_count * sizeof(u16), GFP_KERNEL); | |
| 1345 | + kmalloc_array(msb->logical_block_count, sizeof(u16), | |
| 1346 | + GFP_KERNEL); | |
| 1345 | 1347 | |
| 1346 | 1348 | if (!msb->used_blocks_bitmap || !msb->lba_to_pba_table || |
| 1347 | 1349 | !msb->erased_blocks_bitmap) { |
| @@ -394,7 +394,8 @@ mpt_lan_open(struct net_device *dev) · 393 unmodified lines | ||
| 394 | 394 | "a moment.\n"); |
| 395 | 395 | } |
| 396 | 396 | |
| 397 | − priv->mpt_txfidx = kmalloc(priv->tx_max_out * sizeof(int), GFP_KERNEL); | |
| 397 | + priv->mpt_txfidx = kmalloc_array(priv->tx_max_out, sizeof(int), | |
| 398 | + GFP_KERNEL); | |
| 398 | 399 | if (priv->mpt_txfidx == NULL) |
| 399 | 400 | goto out; |
| 400 | 401 | priv->mpt_txfidx_tail = -1; |
| @@ -408,8 +409,8 @@ mpt_lan_open(struct net_device *dev) · 7 unmodified lines | ||
| 408 | 409 | |
| 409 | 410 | dlprintk((KERN_INFO MYNAM "@lo: Finished initializing SendCtl\n")); |
| 410 | 411 | |
| 411 | − priv->mpt_rxfidx = kmalloc(priv->max_buckets_out * sizeof(int), | |
| 412 | − GFP_KERNEL); | |
| 412 | + priv->mpt_rxfidx = kmalloc_array(priv->max_buckets_out, sizeof(int), | |
| 413 | + GFP_KERNEL); | |
| 413 | 414 | if (priv->mpt_rxfidx == NULL) |
| 414 | 415 | goto out_SendCtl; |
| 415 | 416 | priv->mpt_rxfidx_tail = -1; |
| @@ -2659,18 +2659,18 @@ static int ab8500_debug_probe(struct platform_device *plf) · 2658 unmodified lines | ||
| 2659 | 2659 | ab8500 = dev_get_drvdata(plf->dev.parent); |
| 2660 | 2660 | num_irqs = ab8500->mask_size; |
| 2661 | 2661 | |
| 2662 | − irq_count = devm_kzalloc(&plf->dev, | |
| 2663 | − sizeof(*irq_count)*num_irqs, GFP_KERNEL); | |
| 2662 | + irq_count = devm_kcalloc(&plf->dev, | |
| 2663 | + num_irqs, sizeof(*irq_count), GFP_KERNEL); | |
| 2664 | 2664 | if (!irq_count) |
| 2665 | 2665 | return -ENOMEM; |
| 2666 | 2666 | |
| 2667 | − dev_attr = devm_kzalloc(&plf->dev, | |
| 2668 | − sizeof(*dev_attr)*num_irqs, GFP_KERNEL); | |
| 2667 | + dev_attr = devm_kcalloc(&plf->dev, | |
| 2668 | + num_irqs, sizeof(*dev_attr), GFP_KERNEL); | |
| 2669 | 2669 | if (!dev_attr) |
| 2670 | 2670 | return -ENOMEM; |
| 2671 | 2671 | |
| 2672 | − event_name = devm_kzalloc(&plf->dev, | |
| 2673 | − sizeof(*event_name)*num_irqs, GFP_KERNEL); | |
| 2672 | + event_name = devm_kcalloc(&plf->dev, | |
| 2673 | + num_irqs, sizeof(*event_name), GFP_KERNEL); | |
| 2674 | 2674 | if (!event_name) |
| 2675 | 2675 | return -ENOMEM; |
| 2676 | 2676 | |
| @@ -299,13 +299,14 @@ static void cros_ec_sensors_register(struct cros_ec_dev *ec) · 298 unmodified lines | ||
| 299 | 299 | resp = (struct ec_response_motion_sense *)msg->data; |
| 300 | 300 | sensor_num = resp->dump.sensor_count; |
| 301 | 301 | /* Allocate 1 extra sensors in FIFO are needed */ |
| 302 | − sensor_cells = kzalloc(sizeof(struct mfd_cell) * (sensor_num + 1), | |
| 302 | + sensor_cells = kcalloc(sensor_num + 1, sizeof(struct mfd_cell), | |
| 303 | 303 | GFP_KERNEL); |
| 304 | 304 | if (sensor_cells == NULL) |
| 305 | 305 | goto error; |
| 306 | 306 | |
| 307 | − sensor_platforms = kzalloc(sizeof(struct cros_ec_sensor_platform) * | |
| 308 | − (sensor_num + 1), GFP_KERNEL); | |
| 307 | + sensor_platforms = kcalloc(sensor_num + 1, | |
| 308 | + sizeof(struct cros_ec_sensor_platform), | |
| 309 | + GFP_KERNEL); | |
| 309 | 310 | if (sensor_platforms == NULL) |
| 310 | 311 | goto error_platforms; |
| 311 | 312 | |
| @@ -477,7 +477,9 @@ static int htcpld_setup_chips(struct platform_device *pdev) · 476 unmodified lines | ||
| 477 | 477 | |
| 478 | 478 | /* Setup each chip's output GPIOs */ |
| 479 | 479 | htcpld->nchips = pdata->num_chip; |
| 480 | − htcpld->chip = devm_kzalloc(dev, sizeof(struct htcpld_chip) * htcpld->nchips, | |
| 480 | + htcpld->chip = devm_kcalloc(dev, | |
| 481 | + htcpld->nchips, | |
| 482 | + sizeof(struct htcpld_chip), | |
| 481 | 483 | GFP_KERNEL); |
| 482 | 484 | if (!htcpld->chip) |
| 483 | 485 | return -ENOMEM; |
| @@ -158,7 +158,7 @@ static int mfd_add_device(struct device *parent, int id, · 157 unmodified lines | ||
| 158 | 158 | if (!pdev) |
| 159 | 159 | goto fail_alloc; |
| 160 | 160 | |
| 161 | − res = kzalloc(sizeof(*res) * cell->num_resources, GFP_KERNEL); | |
| 161 | + res = kcalloc(cell->num_resources, sizeof(*res), GFP_KERNEL); | |
| 162 | 162 | if (!res) |
| 163 | 163 | goto fail_device; |
| 164 | 164 | |
| @@ -173,9 +173,9 @@ static int cpcap_init_irq(struct cpcap_ddata *cpcap) · 172 unmodified lines | ||
| 173 | 173 | int ret; |
| 174 | 174 | |
| 175 | 175 | cpcap->irqs = devm_kzalloc(&cpcap->spi->dev, |
| 176 | − sizeof(*cpcap->irqs) * | |
| 177 | − CPCAP_NR_IRQ_REG_BANKS * | |
| 178 | − cpcap->regmap_conf->val_bits, | |
| 176 | + array3_size(sizeof(*cpcap->irqs), | |
| 177 | + CPCAP_NR_IRQ_REG_BANKS, | |
| 178 | + cpcap->regmap_conf->val_bits), | |
| 179 | 179 | GFP_KERNEL); |
| 180 | 180 | if (!cpcap->irqs) |
| 181 | 181 | return -ENOMEM; |
| @@ -199,8 +199,9 @@ static int sprd_pmic_probe(struct spi_device *spi) · 198 unmodified lines | ||
| 199 | 199 | ddata->irq_chip.num_irqs = pdata->num_irqs; |
| 200 | 200 | ddata->irq_chip.mask_invert = true; |
| 201 | 201 | |
| 202 | − ddata->irqs = devm_kzalloc(&spi->dev, sizeof(struct regmap_irq) * | |
| 203 | − pdata->num_irqs, GFP_KERNEL); | |
| 202 | + ddata->irqs = devm_kcalloc(&spi->dev, | |
| 203 | + pdata->num_irqs, sizeof(struct regmap_irq), | |
| 204 | + GFP_KERNEL); | |
| 204 | 205 | if (!ddata->irqs) |
| 205 | 206 | return -ENOMEM; |
| 206 | 207 | |
| @@ -707,8 +707,8 @@ static int timb_probe(struct pci_dev *dev, · 706 unmodified lines | ||
| 707 | 707 | goto err_config; |
| 708 | 708 | } |
| 709 | 709 | |
| 710 | − msix_entries = kzalloc(TIMBERDALE_NR_IRQS * sizeof(*msix_entries), | |
| 711 | − GFP_KERNEL); | |
| 710 | + msix_entries = kcalloc(TIMBERDALE_NR_IRQS, sizeof(*msix_entries), | |
| 711 | + GFP_KERNEL); | |
| 712 | 712 | if (!msix_entries) |
| 713 | 713 | goto err_config; |
| 714 | 714 | |
| @@ -1139,8 +1139,9 @@ twl_probe(struct i2c_client *client, const struct i2c_device_id *id) · 1138 unmodified lines | ||
| 1139 | 1139 | } |
| 1140 | 1140 | |
| 1141 | 1141 | num_slaves = twl_get_num_slaves(); |
| 1142 | − twl_priv->twl_modules = devm_kzalloc(&client->dev, | |
| 1143 | − sizeof(struct twl_client) * num_slaves, | |
| 1142 | + twl_priv->twl_modules = devm_kcalloc(&client->dev, | |
| 1143 | + num_slaves, | |
| 1144 | + sizeof(struct twl_client), | |
| 1144 | 1145 | GFP_KERNEL); |
| 1145 | 1146 | if (!twl_priv->twl_modules) { |
| 1146 | 1147 | status = -ENOMEM; |
| @@ -368,9 +368,10 @@ static int wm8994_device_init(struct wm8994 *wm8994, int irq) · 367 unmodified lines | ||
| 368 | 368 | goto err; |
| 369 | 369 | } |
| 370 | 370 | |
| 371 | − wm8994->supplies = devm_kzalloc(wm8994->dev, | |
| 372 | − sizeof(struct regulator_bulk_data) * | |
| 373 | − wm8994->num_supplies, GFP_KERNEL); | |
| 371 | + wm8994->supplies = devm_kcalloc(wm8994->dev, | |
| 372 | + wm8994->num_supplies, | |
| 373 | + sizeof(struct regulator_bulk_data), | |
| 374 | + GFP_KERNEL); | |
| 374 | 375 | if (!wm8994->supplies) { |
| 375 | 376 | ret = -ENOMEM; |
| 376 | 377 | goto err; |
| @@ -304,13 +304,13 @@ static int altera_execute(struct altera_state *astate, · 303 unmodified lines | ||
| 304 | 304 | if (sym_count <= 0) |
| 305 | 305 | goto exit_done; |
| 306 | 306 | |
| 307 | − vars = kzalloc(sym_count * sizeof(long), GFP_KERNEL); | |
| 307 | + vars = kcalloc(sym_count, sizeof(long), GFP_KERNEL); | |
| 308 | 308 | |
| 309 | 309 | if (vars == NULL) |
| 310 | 310 | status = -ENOMEM; |
| 311 | 311 | |
| 312 | 312 | if (status == 0) { |
| 313 | − var_size = kzalloc(sym_count * sizeof(s32), GFP_KERNEL); | |
| 313 | + var_size = kcalloc(sym_count, sizeof(s32), GFP_KERNEL); | |
| 314 | 314 | |
| 315 | 315 | if (var_size == NULL) |
| 316 | 316 | status = -ENOMEM; |
| @@ -1136,7 +1136,7 @@ exit_done: · 819 unmodified lines | ||
| 1136 | 1136 | /* Allocate a writable buffer for this array */ |
| 1137 | 1137 | count = var_size[variable_id]; |
| 1138 | 1138 | long_tmp = vars[variable_id]; |
| 1139 | − longptr_tmp = kzalloc(count * sizeof(long), | |
| 1139 | + longptr_tmp = kcalloc(count, sizeof(long), | |
| 1140 | 1140 | GFP_KERNEL); |
| 1141 | 1141 | vars[variable_id] = (long)longptr_tmp; |
| 1142 | 1142 | |
| @@ -89,7 +89,7 @@ static ssize_t guest_collect_vpd(struct cxl *adapter, struct cxl_afu *afu, · 88 unmodified lines | ||
| 89 | 89 | mod = 0; |
| 90 | 90 | } |
| 91 | 91 | |
| 92 | − vpd_buf = kzalloc(entries * sizeof(unsigned long *), GFP_KERNEL); | |
| 92 | + vpd_buf = kcalloc(entries, sizeof(unsigned long *), GFP_KERNEL); | |
| 93 | 93 | if (!vpd_buf) |
| 94 | 94 | return -ENOMEM; |
| 95 | 95 | |
| @@ -302,7 +302,7 @@ static int read_adapter_irq_config(struct cxl *adapter, struct device_node *np) · 301 unmodified lines | ||
| 302 | 302 | if (nranges == 0 || (nranges * 2 * sizeof(int)) != len) |
| 303 | 303 | return -EINVAL; |
| 304 | 304 | |
| 305 | − adapter->guest->irq_avail = kzalloc(nranges * sizeof(struct irq_avail), | |
| 305 | + adapter->guest->irq_avail = kcalloc(nranges, sizeof(struct irq_avail), | |
| 306 | 306 | GFP_KERNEL); |
| 307 | 307 | if (adapter->guest->irq_avail == NULL) |
| 308 | 308 | return -ENOMEM; |
| @@ -964,7 +964,7 @@ static ssize_t idt_dbgfs_csr_write(struct file *filep, const char __user *ubuf, · 963 unmodified lines | ||
| 964 | 964 | if (colon_ch != NULL) { |
| 965 | 965 | csraddr_len = colon_ch - buf; |
| 966 | 966 | csraddr_str = |
| 967 | − kmalloc(sizeof(char)*(csraddr_len + 1), GFP_KERNEL); | |
| 967 | + kmalloc(csraddr_len + 1, GFP_KERNEL); | |
| 968 | 968 | if (csraddr_str == NULL) { |
| 969 | 969 | ret = -ENOMEM; |
| 970 | 970 | goto free_buf; |
| @@ -1048,15 +1048,16 @@ static int setup_ddcb_queue(struct genwqe_dev *cd, struct ddcb_queue *queue) · 1047 unmodified lines | ||
| 1048 | 1048 | "[%s] **err: could not allocate DDCB **\n", __func__); |
| 1049 | 1049 | return -ENOMEM; |
| 1050 | 1050 | } |
| 1051 | − queue->ddcb_req = kzalloc(sizeof(struct ddcb_requ *) * | |
| 1052 | − queue->ddcb_max, GFP_KERNEL); | |
| 1051 | + queue->ddcb_req = kcalloc(queue->ddcb_max, sizeof(struct ddcb_requ *), | |
| 1052 | + GFP_KERNEL); | |
| 1053 | 1053 | if (!queue->ddcb_req) { |
| 1054 | 1054 | rc = -ENOMEM; |
| 1055 | 1055 | goto free_ddcbs; |
| 1056 | 1056 | } |
| 1057 | 1057 | |
| 1058 | − queue->ddcb_waitqs = kzalloc(sizeof(wait_queue_head_t) * | |
| 1059 | − queue->ddcb_max, GFP_KERNEL); | |
| 1058 | + queue->ddcb_waitqs = kcalloc(queue->ddcb_max, | |
| 1059 | + sizeof(wait_queue_head_t), | |
| 1060 | + GFP_KERNEL); | |
| 1060 | 1061 | if (!queue->ddcb_waitqs) { |
| 1061 | 1062 | rc = -ENOMEM; |
| 1062 | 1063 | goto free_requs; |
| @@ -416,7 +416,8 @@ xpc_setup_ch_structures(struct xpc_partition *part) · 415 unmodified lines | ||
| 416 | 416 | * memory. |
| 417 | 417 | */ |
| 418 | 418 | DBUG_ON(part->channels != NULL); |
| 419 | − part->channels = kzalloc(sizeof(struct xpc_channel) * XPC_MAX_NCHANNELS, | |
| 419 | + part->channels = kcalloc(XPC_MAX_NCHANNELS, | |
| 420 | + sizeof(struct xpc_channel), | |
| 420 | 421 | GFP_KERNEL); |
| 421 | 422 | if (part->channels == NULL) { |
| 422 | 423 | dev_err(xpc_chan, "can't get memory for channels\n"); |
| @@ -905,8 +906,9 @@ xpc_setup_partitions(void) · 482 unmodified lines | ||
| 905 | 906 | short partid; |
| 906 | 907 | struct xpc_partition *part; |
| 907 | 908 | |
| 908 | − xpc_partitions = kzalloc(sizeof(struct xpc_partition) * | |
| 909 | − xp_max_npartitions, GFP_KERNEL); | |
| 909 | + xpc_partitions = kcalloc(xp_max_npartitions, | |
| 910 | + sizeof(struct xpc_partition), | |
| 911 | + GFP_KERNEL); | |
| 910 | 912 | if (xpc_partitions == NULL) { |
| 911 | 913 | dev_err(xpc_part, "can't get memory for partition structure\n"); |
| 912 | 914 | return -ENOMEM; |
| @@ -425,7 +425,7 @@ xpc_discovery(void) · 424 unmodified lines | ||
| 425 | 425 | if (remote_rp == NULL) |
| 426 | 426 | return; |
| 427 | 427 | |
| 428 | − discovered_nasids = kzalloc(sizeof(long) * xpc_nasid_mask_nlongs, | |
| 428 | + discovered_nasids = kcalloc(xpc_nasid_mask_nlongs, sizeof(long), | |
| 429 | 429 | GFP_KERNEL); |
| 430 | 430 | if (discovered_nasids == NULL) { |
| 431 | 431 | kfree(remote_rp_base); |
| @@ -520,8 +520,9 @@ xpnet_init(void) · 519 unmodified lines | ||
| 520 | 520 | |
| 521 | 521 | dev_info(xpnet, "registering network device %s\n", XPNET_DEVICE_NAME); |
| 522 | 522 | |
| 523 | − xpnet_broadcast_partitions = kzalloc(BITS_TO_LONGS(xp_max_npartitions) * | |
| 524 | − sizeof(long), GFP_KERNEL); | |
| 523 | + xpnet_broadcast_partitions = kcalloc(BITS_TO_LONGS(xp_max_npartitions), | |
| 524 | + sizeof(long), | |
| 525 | + GFP_KERNEL); | |
| 525 | 526 | if (xpnet_broadcast_partitions == NULL) |
| 526 | 527 | return -ENOMEM; |
| 527 | 528 | |
| @@ -185,7 +185,7 @@ static int sram_reserve_regions(struct sram_dev *sram, struct resource *res) · 184 unmodified lines | ||
| 185 | 185 | * after the reserved blocks from the dt are processed. |
| 186 | 186 | */ |
| 187 | 187 | nblocks = (np) ? of_get_available_child_count(np) + 1 : 1; |
| 188 | − rblocks = kzalloc((nblocks) * sizeof(*rblocks), GFP_KERNEL); | |
| 188 | + rblocks = kcalloc(nblocks, sizeof(*rblocks), GFP_KERNEL); | |
| 189 | 189 | if (!rblocks) |
| 190 | 190 | return -ENOMEM; |
| 191 | 191 | |
| @@ -264,8 +264,8 @@ static int sram_reserve_regions(struct sram_dev *sram, struct resource *res) · 72 unmodified lines | ||
| 264 | 264 | list_sort(NULL, &reserve_list, sram_reserve_cmp); |
| 265 | 265 | |
| 266 | 266 | if (exports) { |
| 267 | − sram->partition = devm_kzalloc(sram->dev, | |
| 268 | − exports * sizeof(*sram->partition), | |
| 267 | + sram->partition = devm_kcalloc(sram->dev, | |
| 268 | + exports, sizeof(*sram->partition), | |
| 269 | 269 | GFP_KERNEL); |
| 270 | 270 | if (!sram->partition) { |
| 271 | 271 | ret = -ENOMEM; |
| @@ -449,12 +449,14 @@ static int qp_alloc_ppn_set(void *prod_q, · 448 unmodified lines | ||
| 449 | 449 | return VMCI_ERROR_ALREADY_EXISTS; |
| 450 | 450 | |
| 451 | 451 | produce_ppns = |
| 452 | − kmalloc(num_produce_pages * sizeof(*produce_ppns), GFP_KERNEL); | |
| 452 | + kmalloc_array(num_produce_pages, sizeof(*produce_ppns), | |
| 453 | + GFP_KERNEL); | |
| 453 | 454 | if (!produce_ppns) |
| 454 | 455 | return VMCI_ERROR_NO_MEM; |
| 455 | 456 | |
| 456 | 457 | consume_ppns = |
| 457 | − kmalloc(num_consume_pages * sizeof(*consume_ppns), GFP_KERNEL); | |
| 458 | + kmalloc_array(num_consume_pages, sizeof(*consume_ppns), | |
| 459 | + GFP_KERNEL); | |
| 458 | 460 | if (!consume_ppns) { |
| 459 | 461 | kfree(produce_ppns); |
| 460 | 462 | return VMCI_ERROR_NO_MEM; |
| @@ -797,8 +797,10 @@ static int sdhci_omap_config_iodelay_pinctrl_state(struct sdhci_omap_host · 796 unmodified lines | ||
| 797 | 797 | if (!(omap_host->flags & SDHCI_OMAP_REQUIRE_IODELAY)) |
| 798 | 798 | return 0; |
| 799 | 799 | |
| 800 | − pinctrl_state = devm_kzalloc(dev, sizeof(*pinctrl_state) * | |
| 801 | − (MMC_TIMING_MMC_HS200 + 1), GFP_KERNEL); | |
| 800 | + pinctrl_state = devm_kcalloc(dev, | |
| 801 | + MMC_TIMING_MMC_HS200 + 1, | |
| 802 | + sizeof(*pinctrl_state), | |
| 803 | + GFP_KERNEL); | |
| 802 | 804 | if (!pinctrl_state) |
| 803 | 805 | return -ENOMEM; |
| 804 | 806 | |
| @@ -55,7 +55,7 @@ static int create_mtd_partitions(struct mtd_info *master, · 54 unmodified lines | ||
| 55 | 55 | int retries = 10; |
| 56 | 56 | struct mtd_partition *ar7_parts; |
| 57 | 57 | |
| 58 | − ar7_parts = kzalloc(sizeof(*ar7_parts) * AR7_PARTS, GFP_KERNEL); | |
| 58 | + ar7_parts = kcalloc(AR7_PARTS, sizeof(*ar7_parts), GFP_KERNEL); | |
| 59 | 59 | if (!ar7_parts) |
| 60 | 60 | return -ENOMEM; |
| 61 | 61 | ar7_parts[0].name = "loader"; |
| @@ -110,7 +110,7 @@ static int bcm47xxpart_parse(struct mtd_info *master, · 109 unmodified lines | ||
| 110 | 110 | blocksize = 0x1000; |
| 111 | 111 | |
| 112 | 112 | /* Alloc */ |
| 113 | − parts = kzalloc(sizeof(struct mtd_partition) * BCM47XXPART_MAX_PARTS, | |
| 113 | + parts = kcalloc(BCM47XXPART_MAX_PARTS, sizeof(struct mtd_partition), | |
| 114 | 114 | GFP_KERNEL); |
| 115 | 115 | if (!parts) |
| 116 | 116 | return -ENOMEM; |
| @@ -608,8 +608,9 @@ static struct mtd_info *cfi_intelext_setup(struct mtd_info *mtd) · 607 unmodified lines | ||
| 608 | 608 | mtd->size = devsize * cfi->numchips; |
| 609 | 609 | |
| 610 | 610 | mtd->numeraseregions = cfi->cfiq->NumEraseRegions * cfi->numchips; |
| 611 | − mtd->eraseregions = kzalloc(sizeof(struct mtd_erase_region_info) | |
| 612 | − * mtd->numeraseregions, GFP_KERNEL); | |
| 611 | + mtd->eraseregions = kcalloc(mtd->numeraseregions, | |
| 612 | + sizeof(struct mtd_erase_region_info), | |
| 613 | + GFP_KERNEL); | |
| 613 | 614 | if (!mtd->eraseregions) |
| 614 | 615 | goto setup_err; |
| 615 | 616 | |
| @@ -758,7 +759,9 @@ static int cfi_intelext_partition_fixup(struct mtd_info *mtd, · 142 unmodified lines | ||
| 758 | 759 | newcfi = kmalloc(sizeof(struct cfi_private) + numvirtchips * sizeof(struct flchip), GFP_KERNEL); |
| 759 | 760 | if (!newcfi) |
| 760 | 761 | return -ENOMEM; |
| 761 | − shared = kmalloc(sizeof(struct flchip_shared) * cfi->numchips, GFP_KERNEL); | |
| 762 | + shared = kmalloc_array(cfi->numchips, | |
| 763 | + sizeof(struct flchip_shared), | |
| 764 | + GFP_KERNEL); | |
| 762 | 765 | if (!shared) { |
| 763 | 766 | kfree(newcfi); |
| 764 | 767 | return -ENOMEM; |
| @@ -692,8 +692,9 @@ static struct mtd_info *cfi_amdstd_setup(struct mtd_info *mtd) · 691 unmodified lines | ||
| 692 | 692 | mtd->size = devsize * cfi->numchips; |
| 693 | 693 | |
| 694 | 694 | mtd->numeraseregions = cfi->cfiq->NumEraseRegions * cfi->numchips; |
| 695 | − mtd->eraseregions = kmalloc(sizeof(struct mtd_erase_region_info) | |
| 696 | − * mtd->numeraseregions, GFP_KERNEL); | |
| 695 | + mtd->eraseregions = kmalloc_array(mtd->numeraseregions, | |
| 696 | + sizeof(struct mtd_erase_region_info), | |
| 697 | + GFP_KERNEL); | |
| 697 | 698 | if (!mtd->eraseregions) |
| 698 | 699 | goto setup_err; |
| 699 | 700 | |
| @@ -2635,7 +2636,7 @@ static int __maybe_unused cfi_ppb_unlock(struct mtd_info *mtd, loff_t ofs, · 1935 unmodified lines | ||
| 2635 | 2636 | * first check the locking status of all sectors and save |
| 2636 | 2637 | * it for future use. |
| 2637 | 2638 | */ |
| 2638 | − sect = kzalloc(MAX_SECTORS * sizeof(struct ppb_lock), GFP_KERNEL); | |
| 2639 | + sect = kcalloc(MAX_SECTORS, sizeof(struct ppb_lock), GFP_KERNEL); | |
| 2639 | 2640 | if (!sect) |
| 2640 | 2641 | return -ENOMEM; |
| 2641 | 2642 | |
| @@ -184,8 +184,9 @@ static struct mtd_info *cfi_staa_setup(struct map_info *map) · 183 unmodified lines | ||
| 184 | 184 | mtd->size = devsize * cfi->numchips; |
| 185 | 185 | |
| 186 | 186 | mtd->numeraseregions = cfi->cfiq->NumEraseRegions * cfi->numchips; |
| 187 | − mtd->eraseregions = kmalloc(sizeof(struct mtd_erase_region_info) | |
| 188 | − * mtd->numeraseregions, GFP_KERNEL); | |
| 187 | + mtd->eraseregions = kmalloc_array(mtd->numeraseregions, | |
| 188 | + sizeof(struct mtd_erase_region_info), | |
| 189 | + GFP_KERNEL); | |
| 189 | 190 | if (!mtd->eraseregions) { |
| 190 | 191 | kfree(cfi->cmdset_priv); |
| 191 | 192 | kfree(mtd); |
| @@ -1827,7 +1827,7 @@ doc_probe_device(struct docg3_cascade *cascade, int floor, struct device *dev) · 1826 unmodified lines | ||
| 1827 | 1827 | mtd->dev.parent = dev; |
| 1828 | 1828 | bbt_nbpages = DIV_ROUND_UP(docg3->max_block + 1, |
| 1829 | 1829 | 8 * DOC_LAYOUT_PAGE_SIZE); |
| 1830 | − docg3->bbt = kzalloc(bbt_nbpages * DOC_LAYOUT_PAGE_SIZE, GFP_KERNEL); | |
| 1830 | + docg3->bbt = kcalloc(DOC_LAYOUT_PAGE_SIZE, bbt_nbpages, GFP_KERNEL); | |
| 1831 | 1831 | if (!docg3->bbt) |
| 1832 | 1832 | goto nomem3; |
| 1833 | 1833 | |
| @@ -1993,7 +1993,7 @@ static int __init docg3_probe(struct platform_device *pdev) · 159 unmodified lines | ||
| 1993 | 1993 | base = devm_ioremap(dev, ress->start, DOC_IOSPACE_SIZE); |
| 1994 | 1994 | |
| 1995 | 1995 | ret = -ENOMEM; |
| 1996 | − cascade = devm_kzalloc(dev, sizeof(*cascade) * DOC_MAX_NBFLOORS, | |
| 1996 | + cascade = devm_kcalloc(dev, DOC_MAX_NBFLOORS, sizeof(*cascade), | |
| 1997 | 1997 | GFP_KERNEL); |
| 1998 | 1998 | if (!cascade) |
| 1999 | 1999 | return ret; |
| @@ -201,15 +201,16 @@ static int build_maps(partition_t *part) · 200 unmodified lines | ||
| 201 | 201 | /* Set up erase unit maps */ |
| 202 | 202 | part->DataUnits = le16_to_cpu(part->header.NumEraseUnits) - |
| 203 | 203 | part->header.NumTransferUnits; |
| 204 | − part->EUNInfo = kmalloc(part->DataUnits * sizeof(struct eun_info_t), | |
| 205 | − GFP_KERNEL); | |
| 204 | + part->EUNInfo = kmalloc_array(part->DataUnits, sizeof(struct eun_info_t), | |
| 205 | + GFP_KERNEL); | |
| 206 | 206 | if (!part->EUNInfo) |
| 207 | 207 | goto out; |
| 208 | 208 | for (i = 0; i < part->DataUnits; i++) |
| 209 | 209 | part->EUNInfo[i].Offset = 0xffffffff; |
| 210 | 210 | part->XferInfo = |
| 211 | − kmalloc(part->header.NumTransferUnits * sizeof(struct xfer_info_t), | |
| 212 | − GFP_KERNEL); | |
| 211 | + kmalloc_array(part->header.NumTransferUnits, | |
| 212 | + sizeof(struct xfer_info_t), | |
| 213 | + GFP_KERNEL); | |
| 213 | 214 | if (!part->XferInfo) |
| 214 | 215 | goto out_EUNInfo; |
| 215 | 216 | |
| @@ -262,15 +263,15 @@ static int build_maps(partition_t *part) · 46 unmodified lines | ||
| 262 | 263 | |
| 263 | 264 | /* Set up virtual page map */ |
| 264 | 265 | blocks = le32_to_cpu(header.FormattedSize) >> header.BlockSize; |
| 265 | − part->VirtualBlockMap = vmalloc(blocks * sizeof(uint32_t)); | |
| 266 | + part->VirtualBlockMap = vmalloc(array_size(blocks, sizeof(uint32_t))); | |
| 266 | 267 | if (!part->VirtualBlockMap) |
| 267 | 268 | goto out_XferInfo; |
| 268 | 269 | |
| 269 | 270 | memset(part->VirtualBlockMap, 0xff, blocks * sizeof(uint32_t)); |
| 270 | 271 | part->BlocksPerUnit = (1 << header.EraseUnitSize) >> header.BlockSize; |
| 271 | 272 | |
| 272 | − part->bam_cache = kmalloc(part->BlocksPerUnit * sizeof(uint32_t), | |
| 273 | − GFP_KERNEL); | |
| 273 | + part->bam_cache = kmalloc_array(part->BlocksPerUnit, sizeof(uint32_t), | |
| 274 | + GFP_KERNEL); | |
| 274 | 275 | if (!part->bam_cache) |
| 275 | 276 | goto out_VirtualBlockMap; |
| 276 | 277 | |
| @@ -270,7 +270,8 @@ static int find_boot_record(struct INFTLrecord *inftl) · 269 unmodified lines | ||
| 270 | 270 | inftl->nb_blocks = ip->lastUnit + 1; |
| 271 | 271 | |
| 272 | 272 | /* Memory alloc */ |
| 273 | − inftl->PUtable = kmalloc(inftl->nb_blocks * sizeof(u16), GFP_KERNEL); | |
| 273 | + inftl->PUtable = kmalloc_array(inftl->nb_blocks, sizeof(u16), | |
| 274 | + GFP_KERNEL); | |
| 274 | 275 | if (!inftl->PUtable) { |
| 275 | 276 | printk(KERN_WARNING "INFTL: allocation of PUtable " |
| 276 | 277 | "failed (%zd bytes)\n", |
| @@ -278,7 +279,8 @@ static int find_boot_record(struct INFTLrecord *inftl) · 1 unmodified line | ||
| 278 | 279 | return -ENOMEM; |
| 279 | 280 | } |
| 280 | 281 | |
| 281 | − inftl->VUtable = kmalloc(inftl->nb_blocks * sizeof(u16), GFP_KERNEL); | |
| 282 | + inftl->VUtable = kmalloc_array(inftl->nb_blocks, sizeof(u16), | |
| 283 | + GFP_KERNEL); | |
| 282 | 284 | if (!inftl->VUtable) { |
| 283 | 285 | kfree(inftl->PUtable); |
| 284 | 286 | printk(KERN_WARNING "INFTL: allocation of VUtable " |
| @@ -78,7 +78,7 @@ struct mtd_info *lpddr_cmdset(struct map_info *map) · 77 unmodified lines | ||
| 78 | 78 | mtd->erasesize = 1 << lpddr->qinfo->UniformBlockSizeShift; |
| 79 | 79 | mtd->writesize = 1 << lpddr->qinfo->BufSizeShift; |
| 80 | 80 | |
| 81 | − shared = kmalloc(sizeof(struct flchip_shared) * lpddr->numchips, | |
| 81 | + shared = kmalloc_array(lpddr->numchips, sizeof(struct flchip_shared), | |
| 82 | 82 | GFP_KERNEL); |
| 83 | 83 | if (!shared) { |
| 84 | 84 | kfree(lpddr); |
| @@ -124,7 +124,7 @@ static const char * const *of_get_probes(struct device_node *dp) · 123 unmodified lines | ||
| 124 | 124 | if (count < 0) |
| 125 | 125 | return part_probe_types_def; |
| 126 | 126 | |
| 127 | − res = kzalloc((count + 1) * sizeof(*res), GFP_KERNEL); | |
| 127 | + res = kcalloc(count + 1, sizeof(*res), GFP_KERNEL); | |
| 128 | 128 | if (!res) |
| 129 | 129 | return NULL; |
| 130 | 130 | |
| @@ -197,7 +197,7 @@ static int of_flash_probe(struct platform_device *dev) · 66 unmodified lines | ||
| 197 | 197 | |
| 198 | 198 | dev_set_drvdata(&dev->dev, info); |
| 199 | 199 | |
| 200 | − mtd_list = kzalloc(sizeof(*mtd_list) * count, GFP_KERNEL); | |
| 200 | + mtd_list = kcalloc(count, sizeof(*mtd_list), GFP_KERNEL); | |
| 201 | 201 | if (!mtd_list) |
| 202 | 202 | goto err_flash_remove; |
| 203 | 203 | |
| @@ -629,15 +629,15 @@ static int vmu_connect(struct maple_device *mdev) · 628 unmodified lines | ||
| 629 | 629 | * Not sure there are actually any multi-partition devices in the |
| 630 | 630 | * real world, but the hardware supports them, so, so will we |
| 631 | 631 | */ |
| 632 | − card->parts = kmalloc(sizeof(struct vmupart) * card->partitions, | |
| 633 | − GFP_KERNEL); | |
| 632 | + card->parts = kmalloc_array(card->partitions, sizeof(struct vmupart), | |
| 633 | + GFP_KERNEL); | |
| 634 | 634 | if (!card->parts) { |
| 635 | 635 | error = -ENOMEM; |
| 636 | 636 | goto fail_partitions; |
| 637 | 637 | } |
| 638 | 638 | |
| 639 | − card->mtd = kmalloc(sizeof(struct mtd_info) * card->partitions, | |
| 640 | − GFP_KERNEL); | |
| 639 | + card->mtd = kmalloc_array(card->partitions, sizeof(struct mtd_info), | |
| 640 | + GFP_KERNEL); | |
| 641 | 641 | if (!card->mtd) { |
| 642 | 642 | error = -ENOMEM; |
| 643 | 643 | goto fail_mtd_info; |
| @@ -778,8 +778,9 @@ struct mtd_info *mtd_concat_create(struct mtd_info *subdev[], /* subdevices to c · 777 unmodified lines | ||
| 778 | 778 | concat->mtd.erasesize = max_erasesize; |
| 779 | 779 | concat->mtd.numeraseregions = num_erase_region; |
| 780 | 780 | concat->mtd.eraseregions = erase_region_p = |
| 781 | − kmalloc(num_erase_region * | |
| 782 | − sizeof (struct mtd_erase_region_info), GFP_KERNEL); | |
| 781 | + kmalloc_array(num_erase_region, | |
| 782 | + sizeof(struct mtd_erase_region_info), | |
| 783 | + GFP_KERNEL); | |
| 783 | 784 | if (!erase_region_p) { |
| 784 | 785 | kfree(concat); |
| 785 | 786 | printk |
| @@ -330,8 +330,10 @@ static void mtdoops_notify_add(struct mtd_info *mtd) · 329 unmodified lines | ||
| 330 | 330 | } |
| 331 | 331 | |
| 332 | 332 | /* oops_page_used is a bit field */ |
| 333 | − cxt->oops_page_used = vmalloc(DIV_ROUND_UP(mtdoops_pages, | |
| 334 | − BITS_PER_LONG) * sizeof(unsigned long)); | |
| 333 | + cxt->oops_page_used = | |
| 334 | + vmalloc(array_size(sizeof(unsigned long), | |
| 335 | + DIV_ROUND_UP(mtdoops_pages, | |
| 336 | + BITS_PER_LONG))); | |
| 335 | 337 | if (!cxt->oops_page_used) { |
| 336 | 338 | printk(KERN_ERR "mtdoops: could not allocate page array\n"); |
| 337 | 339 | return; |
| @@ -1317,11 +1317,11 @@ static int mtdswap_init(struct mtdswap_dev *d, unsigned int eblocks, · 1316 unmodified lines | ||
| 1317 | 1317 | for (i = 0; i < MTDSWAP_TREE_CNT; i++) |
| 1318 | 1318 | d->trees[i].root = RB_ROOT; |
| 1319 | 1319 | |
| 1320 | − d->page_data = vmalloc(sizeof(int)*pages); | |
| 1320 | + d->page_data = vmalloc(array_size(pages, sizeof(int))); | |
| 1321 | 1321 | if (!d->page_data) |
| 1322 | 1322 | goto page_data_fail; |
| 1323 | 1323 | |
| 1324 | − d->revmap = vmalloc(sizeof(int)*blocks); | |
| 1324 | + d->revmap = vmalloc(array_size(blocks, sizeof(int))); | |
| 1325 | 1325 | if (!d->revmap) |
| 1326 | 1326 | goto revmap_fail; |
| 1327 | 1327 | |
| @@ -1340,7 +1340,7 @@ static int mtdswap_init(struct mtdswap_dev *d, unsigned int eblocks, · 12 unmodified lines | ||
| 1340 | 1340 | if (!d->page_buf) |
| 1341 | 1341 | goto page_buf_fail; |
| 1342 | 1342 | |
| 1343 | − d->oob_buf = kmalloc(2 * mtd->oobavail, GFP_KERNEL); | |
| 1343 | + d->oob_buf = kmalloc_array(2, mtd->oobavail, GFP_KERNEL); | |
| 1344 | 1344 | if (!d->oob_buf) |
| 1345 | 1345 | goto oob_buf_fail; |
| 1346 | 1346 | |
| @@ -3721,8 +3721,10 @@ static int onenand_probe(struct mtd_info *mtd) · 3720 unmodified lines | ||
| 3721 | 3721 | this->dies = ONENAND_IS_DDP(this) ? 2 : 1; |
| 3722 | 3722 | /* Maximum possible erase regions */ |
| 3723 | 3723 | mtd->numeraseregions = this->dies << 1; |
| 3724 | − mtd->eraseregions = kzalloc(sizeof(struct mtd_erase_region_info) | |
| 3725 | − * (this->dies << 1), GFP_KERNEL); | |
| 3724 | + mtd->eraseregions = | |
| 3725 | + kcalloc(this->dies << 1, | |
| 3726 | + sizeof(struct mtd_erase_region_info), | |
| 3727 | + GFP_KERNEL); | |
| 3726 | 3728 | if (!mtd->eraseregions) |
| 3727 | 3729 | return -ENOMEM; |
| 3728 | 3730 | } |
| @@ -186,7 +186,7 @@ struct nand_bch_control *nand_bch_init(struct mtd_info *mtd) · 185 unmodified lines | ||
| 186 | 186 | } |
| 187 | 187 | |
| 188 | 188 | nbc->eccmask = kmalloc(eccbytes, GFP_KERNEL); |
| 189 | − nbc->errloc = kmalloc(t*sizeof(*nbc->errloc), GFP_KERNEL); | |
| 189 | + nbc->errloc = kmalloc_array(t, sizeof(*nbc->errloc), GFP_KERNEL); | |
| 190 | 190 | if (!nbc->eccmask || !nbc->errloc) |
| 191 | 191 | goto fail; |
| 192 | 192 | /* |
| @@ -565,8 +565,9 @@ static int __init alloc_device(struct nandsim *ns) · 564 unmodified lines | ||
| 565 | 565 | err = -EINVAL; |
| 566 | 566 | goto err_close; |
| 567 | 567 | } |
| 568 | − ns->pages_written = vzalloc(BITS_TO_LONGS(ns->geom.pgnum) * | |
| 569 | − sizeof(unsigned long)); | |
| 568 | + ns->pages_written = | |
| 569 | + vzalloc(array_size(sizeof(unsigned long), | |
| 570 | + BITS_TO_LONGS(ns->geom.pgnum))); | |
| 570 | 571 | if (!ns->pages_written) { |
| 571 | 572 | NS_ERR("alloc_device: unable to allocate pages written array\n"); |
| 572 | 573 | err = -ENOMEM; |
| @@ -582,7 +583,7 @@ static int __init alloc_device(struct nandsim *ns) · 9 unmodified lines | ||
| 582 | 583 | return 0; |
| 583 | 584 | } |
| 584 | 585 | |
| 585 | − ns->pages = vmalloc(ns->geom.pgnum * sizeof(union ns_mem)); | |
| 586 | + ns->pages = vmalloc(array_size(sizeof(union ns_mem), ns->geom.pgnum)); | |
| 586 | 587 | if (!ns->pages) { |
| 587 | 588 | NS_ERR("alloc_device: unable to allocate page array\n"); |
| 588 | 589 | return -ENOMEM; |
| @@ -2510,8 +2510,8 @@ static int qcom_nandc_alloc(struct qcom_nand_controller *nandc) · 2509 unmodified lines | ||
| 2510 | 2510 | if (!nandc->regs) |
| 2511 | 2511 | return -ENOMEM; |
| 2512 | 2512 | |
| 2513 | − nandc->reg_read_buf = devm_kzalloc(nandc->dev, | |
| 2514 | − MAX_REG_RD * sizeof(*nandc->reg_read_buf), | |
| 2513 | + nandc->reg_read_buf = devm_kcalloc(nandc->dev, | |
| 2514 | + MAX_REG_RD, sizeof(*nandc->reg_read_buf), | |
| 2515 | 2515 | GFP_KERNEL); |
| 2516 | 2516 | if (!nandc->reg_read_buf) |
| 2517 | 2517 | return -ENOMEM; |
| @@ -1038,7 +1038,7 @@ static int s3c24xx_nand_probe_dt(struct platform_device *pdev) · 1037 unmodified lines | ||
| 1038 | 1038 | if (!pdata->nr_sets) |
| 1039 | 1039 | return 0; |
| 1040 | 1040 | |
| 1041 | − sets = devm_kzalloc(&pdev->dev, sizeof(*sets) * pdata->nr_sets, | |
| 1041 | + sets = devm_kcalloc(&pdev->dev, pdata->nr_sets, sizeof(*sets), | |
| 1042 | 1042 | GFP_KERNEL); |
| 1043 | 1043 | if (!sets) |
| 1044 | 1044 | return -ENOMEM; |
| @@ -199,13 +199,16 @@ device is already correct. · 198 unmodified lines | ||
| 199 | 199 | nftl->lastEUN = nftl->nb_blocks - 1; |
| 200 | 200 | |
| 201 | 201 | /* memory alloc */ |
| 202 | − nftl->EUNtable = kmalloc(nftl->nb_blocks * sizeof(u16), GFP_KERNEL); | |
| 202 | + nftl->EUNtable = kmalloc_array(nftl->nb_blocks, sizeof(u16), | |
| 203 | + GFP_KERNEL); | |
| 203 | 204 | if (!nftl->EUNtable) { |
| 204 | 205 | printk(KERN_NOTICE "NFTL: allocation of EUNtable failed\n"); |
| 205 | 206 | return -ENOMEM; |
| 206 | 207 | } |
| 207 | 208 | |
| 208 | − nftl->ReplUnitTable = kmalloc(nftl->nb_blocks * sizeof(u16), GFP_KERNEL); | |
| 209 | + nftl->ReplUnitTable = kmalloc_array(nftl->nb_blocks, | |
| 210 | + sizeof(u16), | |
| 211 | + GFP_KERNEL); | |
| 209 | 212 | if (!nftl->ReplUnitTable) { |
| 210 | 213 | kfree(nftl->EUNtable); |
| 211 | 214 | printk(KERN_NOTICE "NFTL: allocation of ReplUnitTable failed\n"); |
| @@ -71,7 +71,7 @@ static int parse_fixed_partitions(struct mtd_info *master, · 70 unmodified lines | ||
| 71 | 71 | if (nr_parts == 0) |
| 72 | 72 | return 0; |
| 73 | 73 | |
| 74 | − parts = kzalloc(nr_parts * sizeof(*parts), GFP_KERNEL); | |
| 74 | + parts = kcalloc(nr_parts, sizeof(*parts), GFP_KERNEL); | |
| 75 | 75 | if (!parts) |
| 76 | 76 | return -ENOMEM; |
| 77 | 77 | |
| @@ -177,7 +177,7 @@ static int parse_ofoldpart_partitions(struct mtd_info *master, · 99 unmodified lines | ||
| 177 | 177 | |
| 178 | 178 | nr_parts = plen / sizeof(part[0]); |
| 179 | 179 | |
| 180 | − parts = kzalloc(nr_parts * sizeof(*parts), GFP_KERNEL); | |
| 180 | + parts = kcalloc(nr_parts, sizeof(*parts), GFP_KERNEL); | |
| 181 | 181 | if (!parts) |
| 182 | 182 | return -ENOMEM; |
| 183 | 183 | |
| @@ -62,7 +62,7 @@ static int parser_trx_parse(struct mtd_info *mtd, · 61 unmodified lines | ||
| 62 | 62 | uint8_t curr_part = 0, i = 0; |
| 63 | 63 | int err; |
| 64 | 64 | |
| 65 | − parts = kzalloc(sizeof(struct mtd_partition) * TRX_PARSER_MAX_PARTS, | |
| 65 | + parts = kcalloc(TRX_PARSER_MAX_PARTS, sizeof(struct mtd_partition), | |
| 66 | 66 | GFP_KERNEL); |
| 67 | 67 | if (!parts) |
| 68 | 68 | return -ENOMEM; |
| @@ -362,8 +362,9 @@ static int sharpsl_parse_mtd_partitions(struct mtd_info *master, · 361 unmodified lines | ||
| 362 | 362 | return err; |
| 363 | 363 | } |
| 364 | 364 | |
| 365 | − sharpsl_nand_parts = kzalloc(sizeof(*sharpsl_nand_parts) * | |
| 366 | − SHARPSL_NAND_PARTS, GFP_KERNEL); | |
| 365 | + sharpsl_nand_parts = kcalloc(SHARPSL_NAND_PARTS, | |
| 366 | + sizeof(*sharpsl_nand_parts), | |
| 367 | + GFP_KERNEL); | |
| 367 | 368 | if (!sharpsl_nand_parts) |
| 368 | 369 | return -ENOMEM; |
| 369 | 370 | |
| @@ -189,7 +189,8 @@ static int scan_header(struct partition *part) · 188 unmodified lines | ||
| 189 | 189 | if (!part->blocks) |
| 190 | 190 | goto err; |
| 191 | 191 | |
| 192 | − part->sector_map = vmalloc(part->sector_count * sizeof(u_long)); | |
| 192 | + part->sector_map = vmalloc(array_size(sizeof(u_long), | |
| 193 | + part->sector_count)); | |
| 193 | 194 | if (!part->sector_map) { |
| 194 | 195 | printk(KERN_ERR PREFIX "'%s': unable to allocate memory for " |
| 195 | 196 | "sector map", part->mbd.mtd->name); |
| @@ -82,7 +82,7 @@ static struct attribute_group *sm_create_sysfs_attributes(struct sm_ftl *ftl) · 81 unmodified lines | ||
| 82 | 82 | |
| 83 | 83 | |
| 84 | 84 | /* Create array of pointers to the attributes */ |
| 85 | − attributes = kzalloc(sizeof(struct attribute *) * (NUM_ATTRIBUTES + 1), | |
| 85 | + attributes = kcalloc(NUM_ATTRIBUTES + 1, sizeof(struct attribute *), | |
| 86 | 86 | GFP_KERNEL); |
| 87 | 87 | if (!attributes) |
| 88 | 88 | goto error3; |
| @@ -750,7 +750,7 @@ static int sm_init_zone(struct sm_ftl *ftl, int zone_num) · 661 unmodified lines | ||
| 750 | 750 | dbg("initializing zone %d", zone_num); |
| 751 | 751 | |
| 752 | 752 | /* Allocate memory for FTL table */ |
| 753 | − zone->lba_to_phys_table = kmalloc(ftl->max_lba * 2, GFP_KERNEL); | |
| 753 | + zone->lba_to_phys_table = kmalloc_array(ftl->max_lba, 2, GFP_KERNEL); | |
| 754 | 754 | |
| 755 | 755 | if (!zone->lba_to_phys_table) |
| 756 | 756 | return -ENOMEM; |
| @@ -1137,7 +1137,7 @@ static void sm_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd) · 380 unmodified lines | ||
| 1137 | 1137 | goto error2; |
| 1138 | 1138 | |
| 1139 | 1139 | /* Allocate zone array, it will be initialized on demand */ |
| 1140 | − ftl->zones = kzalloc(sizeof(struct ftl_zone) * ftl->zone_count, | |
| 1140 | + ftl->zones = kcalloc(ftl->zone_count, sizeof(struct ftl_zone), | |
| 1141 | 1141 | GFP_KERNEL); |
| 1142 | 1142 | if (!ftl->zones) |
| 1143 | 1143 | goto error3; |
| @@ -332,8 +332,9 @@ static void ssfdcr_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd) · 331 unmodified lines | ||
| 332 | 332 | (long)ssfdc->sectors; |
| 333 | 333 | |
| 334 | 334 | /* Allocate logical block map */ |
| 335 | − ssfdc->logic_block_map = kmalloc(sizeof(ssfdc->logic_block_map[0]) * | |
| 336 | − ssfdc->map_len, GFP_KERNEL); | |
| 335 | + ssfdc->logic_block_map = | |
| 336 | + kmalloc_array(ssfdc->map_len, | |
| 337 | + sizeof(ssfdc->logic_block_map[0]), GFP_KERNEL); | |
| 337 | 338 | if (!ssfdc->logic_block_map) |
| 338 | 339 | goto out_err; |
| 339 | 340 | memset(ssfdc->logic_block_map, 0xff, sizeof(ssfdc->logic_block_map[0]) * |
| @@ -127,7 +127,7 @@ static int crosstest(void) · 126 unmodified lines | ||
| 127 | 127 | unsigned char *pp1, *pp2, *pp3, *pp4; |
| 128 | 128 | |
| 129 | 129 | pr_info("crosstest\n"); |
| 130 | − pp1 = kzalloc(pgsize * 4, GFP_KERNEL); | |
| 130 | + pp1 = kcalloc(pgsize, 4, GFP_KERNEL); | |
| 131 | 131 | if (!pp1) |
| 132 | 132 | return -ENOMEM; |
| 133 | 133 | pp2 = pp1 + pgsize; |
| @@ -199,7 +199,7 @@ static int __init mtd_stresstest_init(void) · 198 unmodified lines | ||
| 199 | 199 | err = -ENOMEM; |
| 200 | 200 | readbuf = vmalloc(bufsize); |
| 201 | 201 | writebuf = vmalloc(bufsize); |
| 202 | − offsets = kmalloc(ebcnt * sizeof(int), GFP_KERNEL); | |
| 202 | + offsets = kmalloc_array(ebcnt, sizeof(int), GFP_KERNEL); | |
| 203 | 203 | if (!readbuf || !writebuf || !offsets) |
| 204 | 204 | goto out; |
| 205 | 205 | for (i = 0; i < ebcnt; i++) |
| @@ -1536,11 +1536,11 @@ int self_check_eba(struct ubi_device *ubi, struct ubi_attach_info *ai_fastmap, · 1535 unmodified lines | ||
| 1536 | 1536 | |
| 1537 | 1537 | num_volumes = ubi->vtbl_slots + UBI_INT_VOL_COUNT; |
| 1538 | 1538 | |
| 1539 | − scan_eba = kmalloc(sizeof(*scan_eba) * num_volumes, GFP_KERNEL); | |
| 1539 | + scan_eba = kmalloc_array(num_volumes, sizeof(*scan_eba), GFP_KERNEL); | |
| 1540 | 1540 | if (!scan_eba) |
| 1541 | 1541 | return -ENOMEM; |
| 1542 | 1542 | |
| 1543 | − fm_eba = kmalloc(sizeof(*fm_eba) * num_volumes, GFP_KERNEL); | |
| 1543 | + fm_eba = kmalloc_array(num_volumes, sizeof(*fm_eba), GFP_KERNEL); | |
| 1544 | 1544 | if (!fm_eba) { |
| 1545 | 1545 | kfree(scan_eba); |
| 1546 | 1546 | return -ENOMEM; |
| @@ -1551,15 +1551,17 @@ int self_check_eba(struct ubi_device *ubi, struct ubi_attach_info *ai_fastmap, · 4 unmodified lines | ||
| 1551 | 1551 | if (!vol) |
| 1552 | 1552 | continue; |
| 1553 | 1553 | |
| 1554 | − scan_eba[i] = kmalloc(vol->reserved_pebs * sizeof(**scan_eba), | |
| 1555 | − GFP_KERNEL); | |
| 1554 | + scan_eba[i] = kmalloc_array(vol->reserved_pebs, | |
| 1555 | + sizeof(**scan_eba), | |
| 1556 | + GFP_KERNEL); | |
| 1556 | 1557 | if (!scan_eba[i]) { |
| 1557 | 1558 | ret = -ENOMEM; |
| 1558 | 1559 | goto out_free; |
| 1559 | 1560 | } |
| 1560 | 1561 | |
| 1561 | − fm_eba[i] = kmalloc(vol->reserved_pebs * sizeof(**fm_eba), | |
| 1562 | − GFP_KERNEL); | |
| 1562 | + fm_eba[i] = kmalloc_array(vol->reserved_pebs, | |
| 1563 | + sizeof(**fm_eba), | |
| 1564 | + GFP_KERNEL); | |
| 1563 | 1565 | if (!fm_eba[i]) { |
| 1564 | 1566 | ret = -ENOMEM; |
| 1565 | 1567 | goto out_free; |
| @@ -1592,7 +1592,7 @@ int ubi_wl_init(struct ubi_device *ubi, struct ubi_attach_info *ai) · 1591 unmodified lines | ||
| 1592 | 1592 | sprintf(ubi->bgt_name, UBI_BGT_NAME_PATTERN, ubi->ubi_num); |
| 1593 | 1593 | |
| 1594 | 1594 | err = -ENOMEM; |
| 1595 | − ubi->lookuptbl = kzalloc(ubi->peb_count * sizeof(void *), GFP_KERNEL); | |
| 1595 | + ubi->lookuptbl = kcalloc(ubi->peb_count, sizeof(void *), GFP_KERNEL); | |
| 1596 | 1596 | if (!ubi->lookuptbl) |
| 1597 | 1597 | return err; |
| 1598 | 1598 | |
| @@ -2418,7 +2418,7 @@ struct bond_vlan_tag *bond_verify_device_path(struct net_device *start_dev, · 2417 unmodified lines | ||
| 2418 | 2418 | struct list_head *iter; |
| 2419 | 2419 | |
| 2420 | 2420 | if (start_dev == end_dev) { |
| 2421 | − tags = kzalloc(sizeof(*tags) * (level + 1), GFP_ATOMIC); | |
| 2421 | + tags = kcalloc(level + 1, sizeof(*tags), GFP_ATOMIC); | |
| 2422 | 2422 | if (!tags) |
| 2423 | 2423 | return ERR_PTR(-ENOMEM); |
| 2424 | 2424 | tags[level].vlan_proto = VLAN_N_VID; |
| @@ -1057,7 +1057,7 @@ static int grcan_open(struct net_device *dev) · 1056 unmodified lines | ||
| 1057 | 1057 | return err; |
| 1058 | 1058 | } |
| 1059 | 1059 | |
| 1060 | − priv->echo_skb = kzalloc(dma->tx.size * sizeof(*priv->echo_skb), | |
| 1060 | + priv->echo_skb = kcalloc(dma->tx.size, sizeof(*priv->echo_skb), | |
| 1061 | 1061 | GFP_KERNEL); |
| 1062 | 1062 | if (!priv->echo_skb) { |
| 1063 | 1063 | err = -ENOMEM; |
| @@ -1066,7 +1066,7 @@ static int grcan_open(struct net_device *dev) · 2 unmodified lines | ||
| 1066 | 1066 | priv->can.echo_skb_max = dma->tx.size; |
| 1067 | 1067 | priv->can.echo_skb = priv->echo_skb; |
| 1068 | 1068 | |
| 1069 | − priv->txdlc = kzalloc(dma->tx.size * sizeof(*priv->txdlc), GFP_KERNEL); | |
| 1069 | + priv->txdlc = kcalloc(dma->tx.size, sizeof(*priv->txdlc), GFP_KERNEL); | |
| 1070 | 1070 | if (!priv->txdlc) { |
| 1071 | 1071 | err = -ENOMEM; |
| 1072 | 1072 | goto exit_free_echo_skb; |
| @@ -703,7 +703,7 @@ static int __init slcan_init(void) · 702 unmodified lines | ||
| 703 | 703 | pr_info("slcan: serial line CAN interface driver\n"); |
| 704 | 704 | pr_info("slcan: %d dynamic interface channels.\n", maxdev); |
| 705 | 705 | |
| 706 | − slcan_devs = kzalloc(sizeof(struct net_device *)*maxdev, GFP_KERNEL); | |
| 706 | + slcan_devs = kcalloc(maxdev, sizeof(struct net_device *), GFP_KERNEL); | |
| 707 | 707 | if (!slcan_devs) |
| 708 | 708 | return -ENOMEM; |
| 709 | 709 | |
| @@ -2044,14 +2044,14 @@ static int b53_switch_init(struct b53_device *dev) · 2043 unmodified lines | ||
| 2044 | 2044 | } |
| 2045 | 2045 | } |
| 2046 | 2046 | |
| 2047 | − dev->ports = devm_kzalloc(dev->dev, | |
| 2048 | − sizeof(struct b53_port) * dev->num_ports, | |
| 2047 | + dev->ports = devm_kcalloc(dev->dev, | |
| 2048 | + dev->num_ports, sizeof(struct b53_port), | |
| 2049 | 2049 | GFP_KERNEL); |
| 2050 | 2050 | if (!dev->ports) |
| 2051 | 2051 | return -ENOMEM; |
| 2052 | 2052 | |
| 2053 | − dev->vlans = devm_kzalloc(dev->dev, | |
| 2054 | − sizeof(struct b53_vlan) * dev->num_vlans, | |
| 2053 | + dev->vlans = devm_kcalloc(dev->dev, | |
| 2054 | + dev->num_vlans, sizeof(struct b53_vlan), | |
| 2055 | 2055 | GFP_KERNEL); |
| 2056 | 2056 | if (!dev->vlans) |
| 2057 | 2057 | return -ENOMEM; |
| @@ -838,8 +838,8 @@ static void ena_dump_stats_ex(struct ena_adapter *adapter, u8 *buf) · 837 unmodified lines | ||
| 838 | 838 | return; |
| 839 | 839 | } |
| 840 | 840 | |
| 841 | − strings_buf = devm_kzalloc(&adapter->pdev->dev, | |
| 842 | − strings_num * ETH_GSTRING_LEN, | |
| 841 | + strings_buf = devm_kcalloc(&adapter->pdev->dev, | |
| 842 | + ETH_GSTRING_LEN, strings_num, | |
| 843 | 843 | GFP_ATOMIC); |
| 844 | 844 | if (!strings_buf) { |
| 845 | 845 | netif_err(adapter, drv, netdev, |
| @@ -847,8 +847,8 @@ static void ena_dump_stats_ex(struct ena_adapter *adapter, u8 *buf) · 1 unmodified line | ||
| 847 | 847 | return; |
| 848 | 848 | } |
| 849 | 849 | |
| 850 | − data_buf = devm_kzalloc(&adapter->pdev->dev, | |
| 851 | − strings_num * sizeof(u64), | |
| 850 | + data_buf = devm_kcalloc(&adapter->pdev->dev, | |
| 851 | + strings_num, sizeof(u64), | |
| 852 | 852 | GFP_ATOMIC); |
| 853 | 853 | if (!data_buf) { |
| 854 | 854 | netif_err(adapter, drv, netdev, |
| @@ -551,13 +551,13 @@ static int __init lance_probe1(struct net_device *dev, int ioaddr, int irq, int · 550 unmodified lines | ||
| 551 | 551 | if (lance_debug > 6) printk(" (#0x%05lx)", (unsigned long)lp); |
| 552 | 552 | dev->ml_priv = lp; |
| 553 | 553 | lp->name = chipname; |
| 554 | − lp->rx_buffs = (unsigned long)kmalloc(PKT_BUF_SZ*RX_RING_SIZE, | |
| 555 | − GFP_DMA | GFP_KERNEL); | |
| 554 | + lp->rx_buffs = (unsigned long)kmalloc_array(RX_RING_SIZE, PKT_BUF_SZ, | |
| 555 | + GFP_DMA | GFP_KERNEL); | |
| 556 | 556 | if (!lp->rx_buffs) |
| 557 | 557 | goto out_lp; |
| 558 | 558 | if (lance_need_isa_bounce_buffers) { |
| 559 | − lp->tx_bounce_buffs = kmalloc(PKT_BUF_SZ*TX_RING_SIZE, | |
| 560 | − GFP_DMA | GFP_KERNEL); | |
| 559 | + lp->tx_bounce_buffs = kmalloc_array(TX_RING_SIZE, PKT_BUF_SZ, | |
| 560 | + GFP_DMA | GFP_KERNEL); | |
| 561 | 561 | if (!lp->tx_bounce_buffs) |
| 562 | 562 | goto out_rx; |
| 563 | 563 | } else |
| @@ -209,8 +209,8 @@ static int atl1c_get_eeprom(struct net_device *netdev, · 208 unmodified lines | ||
| 209 | 209 | first_dword = eeprom->offset >> 2; |
| 210 | 210 | last_dword = (eeprom->offset + eeprom->len - 1) >> 2; |
| 211 | 211 | |
| 212 | − eeprom_buff = kmalloc(sizeof(u32) * | |
| 213 | − (last_dword - first_dword + 1), GFP_KERNEL); | |
| 212 | + eeprom_buff = kmalloc_array(last_dword - first_dword + 1, sizeof(u32), | |
| 213 | + GFP_KERNEL); | |
| 214 | 214 | if (eeprom_buff == NULL) |
| 215 | 215 | return -ENOMEM; |
| 216 | 216 | |
| @@ -236,8 +236,8 @@ static int atl1e_get_eeprom(struct net_device *netdev, · 235 unmodified lines | ||
| 236 | 236 | first_dword = eeprom->offset >> 2; |
| 237 | 237 | last_dword = (eeprom->offset + eeprom->len - 1) >> 2; |
| 238 | 238 | |
| 239 | − eeprom_buff = kmalloc(sizeof(u32) * | |
| 240 | − (last_dword - first_dword + 1), GFP_KERNEL); | |
| 239 | + eeprom_buff = kmalloc_array(last_dword - first_dword + 1, sizeof(u32), | |
| 240 | + GFP_KERNEL); | |
| 241 | 241 | if (eeprom_buff == NULL) |
| 242 | 242 | return -ENOMEM; |
| 243 | 243 | |
| @@ -1941,8 +1941,8 @@ static int atl2_get_eeprom(struct net_device *netdev, · 1940 unmodified lines | ||
| 1941 | 1941 | first_dword = eeprom->offset >> 2; |
| 1942 | 1942 | last_dword = (eeprom->offset + eeprom->len - 1) >> 2; |
| 1943 | 1943 | |
| 1944 | − eeprom_buff = kmalloc(sizeof(u32) * (last_dword - first_dword + 1), | |
| 1945 | − GFP_KERNEL); | |
| 1944 | + eeprom_buff = kmalloc_array(last_dword - first_dword + 1, sizeof(u32), | |
| 1945 | + GFP_KERNEL); | |
| 1946 | 1946 | if (!eeprom_buff) |
| 1947 | 1947 | return -ENOMEM; |
| 1948 | 1948 | |
| @@ -2150,7 +2150,7 @@ static int bcm_enetsw_open(struct net_device *dev) · 2149 unmodified lines | ||
| 2150 | 2150 | priv->tx_desc_alloc_size = size; |
| 2151 | 2151 | priv->tx_desc_cpu = p; |
| 2152 | 2152 | |
| 2153 | − priv->tx_skb = kzalloc(sizeof(struct sk_buff *) * priv->tx_ring_size, | |
| 2153 | + priv->tx_skb = kcalloc(priv->tx_ring_size, sizeof(struct sk_buff *), | |
| 2154 | 2154 | GFP_KERNEL); |
| 2155 | 2155 | if (!priv->tx_skb) { |
| 2156 | 2156 | dev_err(kdev, "cannot allocate rx skb queue\n"); |
| @@ -2164,7 +2164,7 @@ static int bcm_enetsw_open(struct net_device *dev) · 7 unmodified lines | ||
| 2164 | 2164 | spin_lock_init(&priv->tx_lock); |
| 2165 | 2165 | |
| 2166 | 2166 | /* init & fill rx ring with skbs */ |
| 2167 | − priv->rx_skb = kzalloc(sizeof(struct sk_buff *) * priv->rx_ring_size, | |
| 2167 | + priv->rx_skb = kcalloc(priv->rx_ring_size, sizeof(struct sk_buff *), | |
| 2168 | 2168 | GFP_KERNEL); |
| 2169 | 2169 | if (!priv->rx_skb) { |
| 2170 | 2170 | dev_err(kdev, "cannot allocate rx skb queue\n"); |
| @@ -778,7 +778,7 @@ bnx2_alloc_rx_mem(struct bnx2 *bp) · 777 unmodified lines | ||
| 778 | 778 | int j; |
| 779 | 779 | |
| 780 | 780 | rxr->rx_buf_ring = |
| 781 | − vzalloc(SW_RXBD_RING_SIZE * bp->rx_max_ring); | |
| 781 | + vzalloc(array_size(SW_RXBD_RING_SIZE, bp->rx_max_ring)); | |
| 782 | 782 | if (!rxr->rx_buf_ring) |
| 783 | 783 | return -ENOMEM; |
| 784 | 784 | |
| @@ -794,8 +794,9 @@ bnx2_alloc_rx_mem(struct bnx2 *bp) · 9 unmodified lines | ||
| 794 | 794 | } |
| 795 | 795 | |
| 796 | 796 | if (bp->rx_pg_ring_size) { |
| 797 | − rxr->rx_pg_ring = vzalloc(SW_RXPG_RING_SIZE * | |
| 798 | − bp->rx_max_pg_ring); | |
| 797 | + rxr->rx_pg_ring = | |
| 798 | + vzalloc(array_size(SW_RXPG_RING_SIZE, | |
| 799 | + bp->rx_max_pg_ring)); | |
| 799 | 800 | if (!rxr->rx_pg_ring) |
| 800 | 801 | return -ENOMEM; |
| 801 | 802 | |
| @@ -2666,7 +2667,7 @@ bnx2_alloc_bad_rbuf(struct bnx2 *bp) · 1864 unmodified lines | ||
| 2666 | 2667 | u32 good_mbuf_cnt; |
| 2667 | 2668 | u32 val; |
| 2668 | 2669 | |
| 2669 | − good_mbuf = kmalloc(512 * sizeof(u16), GFP_KERNEL); | |
| 2670 | + good_mbuf = kmalloc_array(512, sizeof(u16), GFP_KERNEL); | |
| 2670 | 2671 | if (!good_mbuf) |
| 2671 | 2672 | return -ENOMEM; |
| 2672 | 2673 | |
| @@ -571,7 +571,7 @@ int bnx2x_vf_mcast(struct bnx2x *bp, struct bnx2x_virtf *vf, · 570 unmodified lines | ||
| 571 | 571 | else |
| 572 | 572 | set_bit(RAMROD_COMP_WAIT, &mcast.ramrod_flags); |
| 573 | 573 | if (mc_num) { |
| 574 | − mc = kzalloc(mc_num * sizeof(struct bnx2x_mcast_list_elem), | |
| 574 | + mc = kcalloc(mc_num, sizeof(struct bnx2x_mcast_list_elem), | |
| 575 | 575 | GFP_KERNEL); |
| 576 | 576 | if (!mc) { |
| 577 | 577 | BNX2X_ERR("Cannot Configure multicasts due to lack of memory\n"); |
| @@ -1253,8 +1253,9 @@ int bnx2x_iov_init_one(struct bnx2x *bp, int int_mode_param, · 675 unmodified lines | ||
| 1253 | 1253 | num_vfs_param, iov->nr_virtfn); |
| 1254 | 1254 | |
| 1255 | 1255 | /* allocate the vf array */ |
| 1256 | − bp->vfdb->vfs = kzalloc(sizeof(struct bnx2x_virtf) * | |
| 1257 | − BNX2X_NR_VIRTFN(bp), GFP_KERNEL); | |
| 1256 | + bp->vfdb->vfs = kcalloc(BNX2X_NR_VIRTFN(bp), | |
| 1257 | + sizeof(struct bnx2x_virtf), | |
| 1258 | + GFP_KERNEL); | |
| 1258 | 1259 | if (!bp->vfdb->vfs) { |
| 1259 | 1260 | BNX2X_ERR("failed to allocate vf array\n"); |
| 1260 | 1261 | err = -ENOMEM; |
| @@ -1278,9 +1279,9 @@ int bnx2x_iov_init_one(struct bnx2x *bp, int int_mode_param, · 17 unmodified lines | ||
| 1278 | 1279 | } |
| 1279 | 1280 | |
| 1280 | 1281 | /* allocate the queue arrays for all VFs */ |
| 1281 | − bp->vfdb->vfqs = kzalloc( | |
| 1282 | − BNX2X_MAX_NUM_VF_QUEUES * sizeof(struct bnx2x_vf_queue), | |
| 1283 | − GFP_KERNEL); | |
| 1282 | + bp->vfdb->vfqs = kcalloc(BNX2X_MAX_NUM_VF_QUEUES, | |
| 1283 | + sizeof(struct bnx2x_vf_queue), | |
| 1284 | + GFP_KERNEL); | |
| 1284 | 1285 | |
| 1285 | 1286 | if (!bp->vfdb->vfqs) { |
| 1286 | 1287 | BNX2X_ERR("failed to allocate vf queue array\n"); |
| @@ -444,8 +444,8 @@ static int bnxt_vf_reps_create(struct bnxt *bp) · 443 unmodified lines | ||
| 444 | 444 | return -ENOMEM; |
| 445 | 445 | |
| 446 | 446 | /* storage for cfa_code to vf-idx mapping */ |
| 447 | − cfa_code_map = kmalloc(sizeof(*bp->cfa_code_map) * MAX_CFA_CODE, | |
| 448 | − GFP_KERNEL); | |
| 447 | + cfa_code_map = kmalloc_array(MAX_CFA_CODE, sizeof(*bp->cfa_code_map), | |
| 448 | + GFP_KERNEL); | |
| 449 | 449 | if (!cfa_code_map) { |
| 450 | 450 | rc = -ENOMEM; |
| 451 | 451 | goto err; |
| @@ -660,7 +660,7 @@ static int cnic_init_id_tbl(struct cnic_id_tbl *id_tbl, u32 size, u32 start_id, · 659 unmodified lines | ||
| 660 | 660 | id_tbl->max = size; |
| 661 | 661 | id_tbl->next = next; |
| 662 | 662 | spin_lock_init(&id_tbl->lock); |
| 663 | − id_tbl->table = kzalloc(DIV_ROUND_UP(size, 32) * 4, GFP_KERNEL); | |
| 663 | + id_tbl->table = kcalloc(DIV_ROUND_UP(size, 32), 4, GFP_KERNEL); | |
| 664 | 664 | if (!id_tbl->table) |
| 665 | 665 | return -ENOMEM; |
| 666 | 666 | |
| @@ -1255,13 +1255,13 @@ static int cnic_alloc_bnx2x_resc(struct cnic_dev *dev) · 588 unmodified lines | ||
| 1255 | 1255 | cp->fcoe_init_cid = 0x10; |
| 1256 | 1256 | } |
| 1257 | 1257 | |
| 1258 | − cp->iscsi_tbl = kzalloc(sizeof(struct cnic_iscsi) * MAX_ISCSI_TBL_SZ, | |
| 1258 | + cp->iscsi_tbl = kcalloc(MAX_ISCSI_TBL_SZ, sizeof(struct cnic_iscsi), | |
| 1259 | 1259 | GFP_KERNEL); |
| 1260 | 1260 | if (!cp->iscsi_tbl) |
| 1261 | 1261 | goto error; |
| 1262 | 1262 | |
| 1263 | − cp->ctx_tbl = kzalloc(sizeof(struct cnic_context) * | |
| 1264 | − cp->max_cid_space, GFP_KERNEL); | |
| 1263 | + cp->ctx_tbl = kcalloc(cp->max_cid_space, sizeof(struct cnic_context), | |
| 1264 | + GFP_KERNEL); | |
| 1265 | 1265 | if (!cp->ctx_tbl) |
| 1266 | 1266 | goto error; |
| 1267 | 1267 | |
| @@ -4100,7 +4100,7 @@ static int cnic_cm_alloc_mem(struct cnic_dev *dev) · 2832 unmodified lines | ||
| 4100 | 4100 | struct cnic_local *cp = dev->cnic_priv; |
| 4101 | 4101 | u32 port_id; |
| 4102 | 4102 | |
| 4103 | − cp->csk_tbl = kzalloc(sizeof(struct cnic_sock) * MAX_CM_SK_TBL_SZ, | |
| 4103 | + cp->csk_tbl = kcalloc(MAX_CM_SK_TBL_SZ, sizeof(struct cnic_sock), | |
| 4104 | 4104 | GFP_KERNEL); |
| 4105 | 4105 | if (!cp->csk_tbl) |
| 4106 | 4106 | return -ENOMEM; |
| @@ -8631,8 +8631,9 @@ static int tg3_mem_tx_acquire(struct tg3 *tp) · 8630 unmodified lines | ||
| 8631 | 8631 | tnapi++; |
| 8632 | 8632 | |
| 8633 | 8633 | for (i = 0; i < tp->txq_cnt; i++, tnapi++) { |
| 8634 | − tnapi->tx_buffers = kzalloc(sizeof(struct tg3_tx_ring_info) * | |
| 8635 | − TG3_TX_RING_SIZE, GFP_KERNEL); | |
| 8634 | + tnapi->tx_buffers = kcalloc(TG3_TX_RING_SIZE, | |
| 8635 | + sizeof(struct tg3_tx_ring_info), | |
| 8636 | + GFP_KERNEL); | |
| 8636 | 8637 | if (!tnapi->tx_buffers) |
| 8637 | 8638 | goto err_out; |
| 8638 | 8639 | |
| @@ -3141,7 +3141,7 @@ bnad_set_rx_ucast_fltr(struct bnad *bnad) · 3140 unmodified lines | ||
| 3141 | 3141 | if (uc_count > bna_attr(&bnad->bna)->num_ucmac) |
| 3142 | 3142 | goto mode_default; |
| 3143 | 3143 | |
| 3144 | − mac_list = kzalloc(uc_count * ETH_ALEN, GFP_ATOMIC); | |
| 3144 | + mac_list = kcalloc(ETH_ALEN, uc_count, GFP_ATOMIC); | |
| 3145 | 3145 | if (mac_list == NULL) |
| 3146 | 3146 | goto mode_default; |
| 3147 | 3147 | |
| @@ -3182,7 +3182,7 @@ bnad_set_rx_mcast_fltr(struct bnad *bnad) · 34 unmodified lines | ||
| 3182 | 3182 | if (mc_count > bna_attr(&bnad->bna)->num_mcmac) |
| 3183 | 3183 | goto mode_allmulti; |
| 3184 | 3184 | |
| 3185 | − mac_list = kzalloc((mc_count + 1) * ETH_ALEN, GFP_ATOMIC); | |
| 3185 | + mac_list = kcalloc(mc_count + 1, ETH_ALEN, GFP_ATOMIC); | |
| 3186 | 3186 | |
| 3187 | 3187 | if (mac_list == NULL) |
| 3188 | 3188 | goto mode_allmulti; |
| @@ -739,7 +739,7 @@ static int xgmac_dma_desc_rings_init(struct net_device *dev) · 738 unmodified lines | ||
| 739 | 739 | |
| 740 | 740 | netdev_dbg(priv->dev, "mtu [%d] bfsize [%d]\n", dev->mtu, bfsize); |
| 741 | 741 | |
| 742 | − priv->rx_skbuff = kzalloc(sizeof(struct sk_buff *) * DMA_RX_RING_SZ, | |
| 742 | + priv->rx_skbuff = kcalloc(DMA_RX_RING_SZ, sizeof(struct sk_buff *), | |
| 743 | 743 | GFP_KERNEL); |
| 744 | 744 | if (!priv->rx_skbuff) |
| 745 | 745 | return -ENOMEM; |
| @@ -752,7 +752,7 @@ static int xgmac_dma_desc_rings_init(struct net_device *dev) · 6 unmodified lines | ||
| 752 | 752 | if (!priv->dma_rx) |
| 753 | 753 | goto err_dma_rx; |
| 754 | 754 | |
| 755 | − priv->tx_skbuff = kzalloc(sizeof(struct sk_buff *) * DMA_TX_RING_SZ, | |
| 755 | + priv->tx_skbuff = kcalloc(DMA_TX_RING_SZ, sizeof(struct sk_buff *), | |
| 756 | 756 | GFP_KERNEL); |
| 757 | 757 | if (!priv->tx_skbuff) |
| 758 | 758 | goto err_tx_skb; |
| @@ -281,13 +281,12 @@ int octeon_init_droq(struct octeon_device *oct, · 280 unmodified lines | ||
| 281 | 281 | droq->max_count); |
| 282 | 282 | |
| 283 | 283 | droq->recv_buf_list = (struct octeon_recv_buffer *) |
| 284 | − vzalloc_node(droq->max_count * | |
| 285 | − OCT_DROQ_RECVBUF_SIZE, | |
| 286 | − numa_node); | |
| 284 | + vzalloc_node(array_size(droq->max_count, OCT_DROQ_RECVBUF_SIZE), | |
| 285 | + numa_node); | |
| 287 | 286 | if (!droq->recv_buf_list) |
| 288 | 287 | droq->recv_buf_list = (struct octeon_recv_buffer *) |
| 289 | − vzalloc(droq->max_count * | |
| 290 | − OCT_DROQ_RECVBUF_SIZE); | |
| 288 | + vzalloc(array_size(droq->max_count, | |
| 289 | + OCT_DROQ_RECVBUF_SIZE)); | |
| 291 | 290 | if (!droq->recv_buf_list) { |
| 292 | 291 | dev_err(&oct->pci_dev->dev, "Output queue recv buf list alloc failed\n"); |
| 293 | 292 | goto init_droq_fail; |
| @@ -98,8 +98,9 @@ int octeon_init_instr_queue(struct octeon_device *oct, · 97 unmodified lines | ||
| 98 | 98 | iq->request_list = vmalloc_node((sizeof(*iq->request_list) * num_descs), |
| 99 | 99 | numa_node); |
| 100 | 100 | if (!iq->request_list) |
| 101 | − iq->request_list = vmalloc(sizeof(*iq->request_list) * | |
| 102 | − num_descs); | |
| 101 | + iq->request_list = | |
| 102 | + vmalloc(array_size(num_descs, | |
| 103 | + sizeof(*iq->request_list))); | |
| 103 | 104 | if (!iq->request_list) { |
| 104 | 105 | lio_dma_free(oct, q_size, iq->base_addr, iq->base_addr_dma); |
| 105 | 106 | dev_err(&oct->pci_dev->dev, "Alloc failed for IQ[%d] nr free list\n", |
| @@ -292,8 +292,8 @@ static int nicvf_init_rbdr(struct nicvf *nic, struct rbdr *rbdr, · 291 unmodified lines | ||
| 292 | 292 | rbdr->is_xdp = true; |
| 293 | 293 | } |
| 294 | 294 | rbdr->pgcnt = roundup_pow_of_two(rbdr->pgcnt); |
| 295 | − rbdr->pgcache = kzalloc(sizeof(*rbdr->pgcache) * | |
| 296 | − rbdr->pgcnt, GFP_KERNEL); | |
| 295 | + rbdr->pgcache = kcalloc(rbdr->pgcnt, sizeof(*rbdr->pgcache), | |
| 296 | + GFP_KERNEL); | |
| 297 | 297 | if (!rbdr->pgcache) |
| 298 | 298 | return -ENOMEM; |
| 299 | 299 | rbdr->pgidx = 0; |
| @@ -304,7 +304,7 @@ struct clip_tbl *t4_init_clip_tbl(unsigned int clipt_start, · 303 unmodified lines | ||
| 304 | 304 | for (i = 0; i < ctbl->clipt_size; ++i) |
| 305 | 305 | INIT_LIST_HEAD(&ctbl->hash_list[i]); |
| 306 | 306 | |
| 307 | − cl_list = kvzalloc(clipt_size*sizeof(struct clip_entry), GFP_KERNEL); | |
| 307 | + cl_list = kvcalloc(clipt_size, sizeof(struct clip_entry), GFP_KERNEL); | |
| 308 | 308 | if (!cl_list) { |
| 309 | 309 | kvfree(ctbl); |
| 310 | 310 | return NULL; |
| @@ -873,7 +873,7 @@ static int cctrl_tbl_show(struct seq_file *seq, void *v) · 872 unmodified lines | ||
| 873 | 873 | u16 (*incr)[NCCTRL_WIN]; |
| 874 | 874 | struct adapter *adap = seq->private; |
| 875 | 875 | |
| 876 | − incr = kmalloc(sizeof(*incr) * NMTUS, GFP_KERNEL); | |
| 876 | + incr = kmalloc_array(NMTUS, sizeof(*incr), GFP_KERNEL); | |
| 877 | 877 | if (!incr) |
| 878 | 878 | return -ENOMEM; |
| 879 | 879 | |
| @@ -713,7 +713,7 @@ int cxgb4_write_rss(const struct port_info *pi, const u16 *queues) · 712 unmodified lines | ||
| 713 | 713 | const struct sge_eth_rxq *rxq; |
| 714 | 714 | |
| 715 | 715 | rxq = &adapter->sge.ethrxq[pi->first_qset]; |
| 716 | − rss = kmalloc(pi->rss_size * sizeof(u16), GFP_KERNEL); | |
| 716 | + rss = kmalloc_array(pi->rss_size, sizeof(u16), GFP_KERNEL); | |
| 717 | 717 | if (!rss) |
| 718 | 718 | return -ENOMEM; |
| 719 | 719 | |
| @@ -4972,8 +4972,8 @@ static int enable_msix(struct adapter *adap) · 4252 unmodified lines | ||
| 4972 | 4972 | max_ingq += (MAX_OFLD_QSETS * adap->num_uld); |
| 4973 | 4973 | if (is_offload(adap)) |
| 4974 | 4974 | max_ingq += (MAX_OFLD_QSETS * adap->num_ofld_uld); |
| 4975 | − entries = kmalloc(sizeof(*entries) * (max_ingq + 1), | |
| 4976 | − GFP_KERNEL); | |
| 4975 | + entries = kmalloc_array(max_ingq + 1, sizeof(*entries), | |
| 4976 | + GFP_KERNEL); | |
| 4977 | 4977 | if (!entries) |
| 4978 | 4978 | return -ENOMEM; |
| 4979 | 4979 | |
| @@ -5646,8 +5646,8 @@ static int init_one(struct pci_dev *pdev, const struct pci_device_id *ent) · 666 unmodified lines | ||
| 5646 | 5646 | adapter->params.offload = 0; |
| 5647 | 5647 | } |
| 5648 | 5648 | |
| 5649 | − adapter->mps_encap = kvzalloc(sizeof(struct mps_encap_entry) * | |
| 5650 | − adapter->params.arch.mps_tcam_size, | |
| 5649 | + adapter->mps_encap = kvcalloc(adapter->params.arch.mps_tcam_size, | |
| 5650 | + sizeof(struct mps_encap_entry), | |
| 5651 | 5651 | GFP_KERNEL); |
| 5652 | 5652 | if (!adapter->mps_encap) |
| 5653 | 5653 | dev_warn(&pdev->dev, "could not allocate MPS Encap entries, continuing\n"); |
| @@ -457,7 +457,8 @@ struct cxgb4_tc_u32_table *cxgb4_init_tc_u32(struct adapter *adap) · 456 unmodified lines | ||
| 457 | 457 | unsigned int bmap_size; |
| 458 | 458 | |
| 459 | 459 | bmap_size = BITS_TO_LONGS(max_tids); |
| 460 | − link->tid_map = kvzalloc(sizeof(unsigned long) * bmap_size, GFP_KERNEL); | |
| 460 | + link->tid_map = kvcalloc(bmap_size, sizeof(unsigned long), | |
| 461 | + GFP_KERNEL); | |
| 461 | 462 | if (!link->tid_map) |
| 462 | 463 | goto out_no_mem; |
| 463 | 464 | bitmap_zero(link->tid_map, max_tids); |
| @@ -561,13 +561,13 @@ int t4_uld_mem_alloc(struct adapter *adap) · 560 unmodified lines | ||
| 561 | 561 | if (!adap->uld) |
| 562 | 562 | return -ENOMEM; |
| 563 | 563 | |
| 564 | − s->uld_rxq_info = kzalloc(CXGB4_ULD_MAX * | |
| 564 | + s->uld_rxq_info = kcalloc(CXGB4_ULD_MAX, | |
| 565 | 565 | sizeof(struct sge_uld_rxq_info *), |
| 566 | 566 | GFP_KERNEL); |
| 567 | 567 | if (!s->uld_rxq_info) |
| 568 | 568 | goto err_uld; |
| 569 | 569 | |
| 570 | − s->uld_txq_info = kzalloc(CXGB4_TX_MAX * | |
| 570 | + s->uld_txq_info = kcalloc(CXGB4_TX_MAX, | |
| 571 | 571 | sizeof(struct sge_uld_txq_info *), |
| 572 | 572 | GFP_KERNEL); |
| 573 | 573 | if (!s->uld_txq_info) |
| @@ -699,7 +699,7 @@ static void *alloc_ring(struct device *dev, size_t nelem, size_t elem_size, · 698 unmodified lines | ||
| 699 | 699 | if (!p) |
| 700 | 700 | return NULL; |
| 701 | 701 | if (sw_size) { |
| 702 | − s = kzalloc_node(nelem * sw_size, GFP_KERNEL, node); | |
| 702 | + s = kcalloc_node(sw_size, nelem, GFP_KERNEL, node); | |
| 703 | 703 | |
| 704 | 704 | if (!s) { |
| 705 | 705 | dma_free_coherent(dev, len, p, *phys); |
| @@ -910,8 +910,8 @@ static int geth_setup_freeq(struct gemini_ethernet *geth) · 909 unmodified lines | ||
| 910 | 910 | } |
| 911 | 911 | |
| 912 | 912 | /* Allocate a mapping to page look-up index */ |
| 913 | − geth->freeq_pages = kzalloc(pages * sizeof(*geth->freeq_pages), | |
| 914 | − GFP_KERNEL); | |
| 913 | + geth->freeq_pages = kcalloc(pages, sizeof(*geth->freeq_pages), | |
| 914 | + GFP_KERNEL); | |
| 915 | 915 | if (!geth->freeq_pages) |
| 916 | 916 | goto err_freeq; |
| 917 | 917 | geth->num_freeq_pages = pages; |
| @@ -1141,7 +1141,8 @@ static int ethoc_probe(struct platform_device *pdev) · 1140 unmodified lines | ||
| 1141 | 1141 | dev_dbg(&pdev->dev, "ethoc: num_tx: %d num_rx: %d\n", |
| 1142 | 1142 | priv->num_tx, priv->num_rx); |
| 1143 | 1143 | |
| 1144 | − priv->vma = devm_kzalloc(&pdev->dev, num_bd*sizeof(void *), GFP_KERNEL); | |
| 1144 | + priv->vma = devm_kcalloc(&pdev->dev, num_bd, sizeof(void *), | |
| 1145 | + GFP_KERNEL); | |
| 1145 | 1146 | if (!priv->vma) { |
| 1146 | 1147 | ret = -ENOMEM; |
| 1147 | 1148 | goto free; |
| @@ -664,7 +664,7 @@ static struct dpaa_fq *dpaa_fq_alloc(struct device *dev, · 663 unmodified lines | ||
| 664 | 664 | struct dpaa_fq *dpaa_fq; |
| 665 | 665 | int i; |
| 666 | 666 | |
| 667 | − dpaa_fq = devm_kzalloc(dev, sizeof(*dpaa_fq) * count, | |
| 667 | + dpaa_fq = devm_kcalloc(dev, count, sizeof(*dpaa_fq), | |
| 668 | 668 | GFP_KERNEL); |
| 669 | 669 | if (!dpaa_fq) |
| 670 | 670 | return NULL; |
| @@ -2253,9 +2253,9 @@ static int ucc_geth_alloc_tx(struct ucc_geth_private *ugeth) · 2252 unmodified lines | ||
| 2253 | 2253 | /* Init Tx bds */ |
| 2254 | 2254 | for (j = 0; j < ug_info->numQueuesTx; j++) { |
| 2255 | 2255 | /* Setup the skbuff rings */ |
| 2256 | − ugeth->tx_skbuff[j] = kmalloc(sizeof(struct sk_buff *) * | |
| 2257 | − ugeth->ug_info->bdRingLenTx[j], | |
| 2258 | − GFP_KERNEL); | |
| 2256 | + ugeth->tx_skbuff[j] = | |
| 2257 | + kmalloc_array(ugeth->ug_info->bdRingLenTx[j], | |
| 2258 | + sizeof(struct sk_buff *), GFP_KERNEL); | |
| 2259 | 2259 | |
| 2260 | 2260 | if (ugeth->tx_skbuff[j] == NULL) { |
| 2261 | 2261 | if (netif_msg_ifup(ugeth)) |
| @@ -2326,9 +2326,9 @@ static int ucc_geth_alloc_rx(struct ucc_geth_private *ugeth) · 64 unmodified lines | ||
| 2326 | 2326 | /* Init Rx bds */ |
| 2327 | 2327 | for (j = 0; j < ug_info->numQueuesRx; j++) { |
| 2328 | 2328 | /* Setup the skbuff rings */ |
| 2329 | − ugeth->rx_skbuff[j] = kmalloc(sizeof(struct sk_buff *) * | |
| 2330 | − ugeth->ug_info->bdRingLenRx[j], | |
| 2331 | − GFP_KERNEL); | |
| 2329 | + ugeth->rx_skbuff[j] = | |
| 2330 | + kmalloc_array(ugeth->ug_info->bdRingLenRx[j], | |
| 2331 | + sizeof(struct sk_buff *), GFP_KERNEL); | |
| 2332 | 2332 | |
| 2333 | 2333 | if (ugeth->rx_skbuff[j] == NULL) { |
| 2334 | 2334 | if (netif_msg_ifup(ugeth)) |
| @@ -1406,8 +1406,8 @@ static int hns_dsaf_init(struct dsaf_device *dsaf_dev) · 1405 unmodified lines | ||
| 1406 | 1406 | return ret; |
| 1407 | 1407 | |
| 1408 | 1408 | /* malloc mem for tcam mac key(vlan+mac) */ |
| 1409 | − priv->soft_mac_tbl = vzalloc(sizeof(*priv->soft_mac_tbl) | |
| 1410 | − * DSAF_TCAM_SUM); | |
| 1409 | + priv->soft_mac_tbl = vzalloc(array_size(DSAF_TCAM_SUM, | |
| 1410 | + sizeof(*priv->soft_mac_tbl))); | |
| 1411 | 1411 | if (!priv->soft_mac_tbl) { |
| 1412 | 1412 | ret = -ENOMEM; |
| 1413 | 1413 | goto remove_hw; |
| @@ -2197,7 +2197,8 @@ static int hns_nic_init_ring_data(struct hns_nic_priv *priv) · 2196 unmodified lines | ||
| 2197 | 2197 | return -EINVAL; |
| 2198 | 2198 | } |
| 2199 | 2199 | |
| 2200 | − priv->ring_data = kzalloc(h->q_num * sizeof(*priv->ring_data) * 2, | |
| 2200 | + priv->ring_data = kzalloc(array3_size(h->q_num, | |
| 2201 | + sizeof(*priv->ring_data), 2), | |
| 2201 | 2202 | GFP_KERNEL); |
| 2202 | 2203 | if (!priv->ring_data) |
| 2203 | 2204 | return -ENOMEM; |
| @@ -2846,8 +2846,10 @@ static int hns3_get_ring_config(struct hns3_nic_priv *priv) · 2845 unmodified lines | ||
| 2846 | 2846 | struct pci_dev *pdev = h->pdev; |
| 2847 | 2847 | int i, ret; |
| 2848 | 2848 | |
| 2849 | − priv->ring_data = devm_kzalloc(&pdev->dev, h->kinfo.num_tqps * | |
| 2850 | − sizeof(*priv->ring_data) * 2, | |
| 2849 | + priv->ring_data = devm_kzalloc(&pdev->dev, | |
| 2850 | + array3_size(h->kinfo.num_tqps, | |
| 2851 | + sizeof(*priv->ring_data), | |
| 2852 | + 2), | |
| 2851 | 2853 | GFP_KERNEL); |
| 2852 | 2854 | if (!priv->ring_data) |
| 2853 | 2855 | return -ENOMEM; |
| @@ -753,11 +753,12 @@ static int init_cmdq(struct hinic_cmdq *cmdq, struct hinic_wq *wq, · 752 unmodified lines | ||
| 753 | 753 | |
| 754 | 754 | spin_lock_init(&cmdq->cmdq_lock); |
| 755 | 755 | |
| 756 | − cmdq->done = vzalloc(wq->q_depth * sizeof(*cmdq->done)); | |
| 756 | + cmdq->done = vzalloc(array_size(sizeof(*cmdq->done), wq->q_depth)); | |
| 757 | 757 | if (!cmdq->done) |
| 758 | 758 | return -ENOMEM; |
| 759 | 759 | |
| 760 | − cmdq->errcode = vzalloc(wq->q_depth * sizeof(*cmdq->errcode)); | |
| 760 | + cmdq->errcode = vzalloc(array_size(sizeof(*cmdq->errcode), | |
| 761 | + wq->q_depth)); | |
| 761 | 762 | if (!cmdq->errcode) { |
| 762 | 763 | err = -ENOMEM; |
| 763 | 764 | goto err_errcode; |
| @@ -171,7 +171,7 @@ static int ibmveth_alloc_buffer_pool(struct ibmveth_buff_pool *pool) · 170 unmodified lines | ||
| 171 | 171 | { |
| 172 | 172 | int i; |
| 173 | 173 | |
| 174 | − pool->free_map = kmalloc(sizeof(u16) * pool->size, GFP_KERNEL); | |
| 174 | + pool->free_map = kmalloc_array(pool->size, sizeof(u16), GFP_KERNEL); | |
| 175 | 175 | |
| 176 | 176 | if (!pool->free_map) |
| 177 | 177 | return -1; |
| @@ -435,8 +435,8 @@ static int e1000_get_eeprom(struct net_device *netdev, · 434 unmodified lines | ||
| 435 | 435 | first_word = eeprom->offset >> 1; |
| 436 | 436 | last_word = (eeprom->offset + eeprom->len - 1) >> 1; |
| 437 | 437 | |
| 438 | − eeprom_buff = kmalloc(sizeof(u16) * | |
| 439 | − (last_word - first_word + 1), GFP_KERNEL); | |
| 438 | + eeprom_buff = kmalloc_array(last_word - first_word + 1, sizeof(u16), | |
| 439 | + GFP_KERNEL); | |
| 440 | 440 | if (!eeprom_buff) |
| 441 | 441 | return -ENOMEM; |
| 442 | 442 | |
| @@ -509,8 +509,8 @@ static int e1000_get_eeprom(struct net_device *netdev, · 508 unmodified lines | ||
| 509 | 509 | first_word = eeprom->offset >> 1; |
| 510 | 510 | last_word = (eeprom->offset + eeprom->len - 1) >> 1; |
| 511 | 511 | |
| 512 | − eeprom_buff = kmalloc(sizeof(u16) * (last_word - first_word + 1), | |
| 513 | − GFP_KERNEL); | |
| 512 | + eeprom_buff = kmalloc_array(last_word - first_word + 1, sizeof(u16), | |
| 513 | + GFP_KERNEL); | |
| 514 | 514 | if (!eeprom_buff) |
| 515 | 515 | return -ENOMEM; |
| 516 | 516 | |
| @@ -3312,7 +3312,7 @@ static int e1000e_write_mc_addr_list(struct net_device *netdev) · 3311 unmodified lines | ||
| 3312 | 3312 | return 0; |
| 3313 | 3313 | } |
| 3314 | 3314 | |
| 3315 | − mta_list = kzalloc(netdev_mc_count(netdev) * ETH_ALEN, GFP_ATOMIC); | |
| 3315 | + mta_list = kcalloc(netdev_mc_count(netdev), ETH_ALEN, GFP_ATOMIC); | |
| 3316 | 3316 | if (!mta_list) |
| 3317 | 3317 | return -ENOMEM; |
| 3318 | 3318 | |
| @@ -558,7 +558,7 @@ static int fm10k_set_ringparam(struct net_device *netdev, · 557 unmodified lines | ||
| 558 | 558 | |
| 559 | 559 | /* allocate temporary buffer to store rings in */ |
| 560 | 560 | i = max_t(int, interface->num_tx_queues, interface->num_rx_queues); |
| 561 | − temp_ring = vmalloc(i * sizeof(struct fm10k_ring)); | |
| 561 | + temp_ring = vmalloc(array_size(i, sizeof(struct fm10k_ring))); | |
| 562 | 562 | |
| 563 | 563 | if (!temp_ring) { |
| 564 | 564 | err = -ENOMEM; |
| @@ -736,8 +736,8 @@ static int igb_get_eeprom(struct net_device *netdev, · 735 unmodified lines | ||
| 736 | 736 | first_word = eeprom->offset >> 1; |
| 737 | 737 | last_word = (eeprom->offset + eeprom->len - 1) >> 1; |
| 738 | 738 | |
| 739 | − eeprom_buff = kmalloc(sizeof(u16) * | |
| 740 | − (last_word - first_word + 1), GFP_KERNEL); | |
| 739 | + eeprom_buff = kmalloc_array(last_word - first_word + 1, sizeof(u16), | |
| 740 | + GFP_KERNEL); | |
| 741 | 741 | if (!eeprom_buff) |
| 742 | 742 | return -ENOMEM; |
| 743 | 743 | |
| @@ -902,11 +902,11 @@ static int igb_set_ringparam(struct net_device *netdev, · 158 unmodified lines | ||
| 902 | 902 | } |
| 903 | 903 | |
| 904 | 904 | if (adapter->num_tx_queues > adapter->num_rx_queues) |
| 905 | − temp_ring = vmalloc(adapter->num_tx_queues * | |
| 906 | − sizeof(struct igb_ring)); | |
| 905 | + temp_ring = vmalloc(array_size(sizeof(struct igb_ring), | |
| 906 | + adapter->num_tx_queues)); | |
| 907 | 907 | else |
| 908 | − temp_ring = vmalloc(adapter->num_rx_queues * | |
| 909 | − sizeof(struct igb_ring)); | |
| 908 | + temp_ring = vmalloc(array_size(sizeof(struct igb_ring), | |
| 909 | + adapter->num_rx_queues)); | |
| 910 | 910 | |
| 911 | 911 | if (!temp_ring) { |
| 912 | 912 | err = -ENOMEM; |
| @@ -3245,8 +3245,8 @@ static int igb_get_module_eeprom(struct net_device *netdev, · 2332 unmodified lines | ||
| 3245 | 3245 | first_word = ee->offset >> 1; |
| 3246 | 3246 | last_word = (ee->offset + ee->len - 1) >> 1; |
| 3247 | 3247 | |
| 3248 | − dataword = kmalloc(sizeof(u16) * (last_word - first_word + 1), | |
| 3249 | − GFP_KERNEL); | |
| 3248 | + dataword = kmalloc_array(last_word - first_word + 1, sizeof(u16), | |
| 3249 | + GFP_KERNEL); | |
| 3250 | 3250 | if (!dataword) |
| 3251 | 3251 | return -ENOMEM; |
| 3252 | 3252 | |
| @@ -3763,8 +3763,9 @@ static int igb_sw_init(struct igb_adapter *adapter) · 3762 unmodified lines | ||
| 3763 | 3763 | /* Assume MSI-X interrupts, will be checked during IRQ allocation */ |
| 3764 | 3764 | adapter->flags |= IGB_FLAG_HAS_MSIX; |
| 3765 | 3765 | |
| 3766 | − adapter->mac_table = kzalloc(sizeof(struct igb_mac_addr) * | |
| 3767 | − hw->mac.rar_entry_count, GFP_ATOMIC); | |
| 3766 | + adapter->mac_table = kcalloc(hw->mac.rar_entry_count, | |
| 3767 | + sizeof(struct igb_mac_addr), | |
| 3768 | + GFP_ATOMIC); | |
| 3768 | 3769 | if (!adapter->mac_table) |
| 3769 | 3770 | return -ENOMEM; |
| 3770 | 3771 | |
| @@ -4752,7 +4753,7 @@ static int igb_write_mc_addr_list(struct net_device *netdev) · 981 unmodified lines | ||
| 4752 | 4753 | return 0; |
| 4753 | 4754 | } |
| 4754 | 4755 | |
| 4755 | − mta_list = kzalloc(netdev_mc_count(netdev) * 6, GFP_ATOMIC); | |
| 4756 | + mta_list = kcalloc(netdev_mc_count(netdev), 6, GFP_ATOMIC); | |
| 4756 | 4757 | if (!mta_list) |
| 4757 | 4758 | return -ENOMEM; |
| 4758 | 4759 | |
| @@ -375,8 +375,9 @@ ixgb_get_eeprom(struct net_device *netdev, · 374 unmodified lines | ||
| 375 | 375 | first_word = eeprom->offset >> 1; |
| 376 | 376 | last_word = (eeprom->offset + eeprom->len - 1) >> 1; |
| 377 | 377 | |
| 378 | − eeprom_buff = kmalloc(sizeof(__le16) * | |
| 379 | − (last_word - first_word + 1), GFP_KERNEL); | |
| 378 | + eeprom_buff = kmalloc_array(last_word - first_word + 1, | |
| 379 | + sizeof(__le16), | |
| 380 | + GFP_KERNEL); | |
| 380 | 381 | if (!eeprom_buff) |
| 381 | 382 | return -ENOMEM; |
| 382 | 383 | |
| @@ -1093,8 +1093,9 @@ ixgb_set_multi(struct net_device *netdev) · 1092 unmodified lines | ||
| 1093 | 1093 | rctl |= IXGB_RCTL_MPE; |
| 1094 | 1094 | IXGB_WRITE_REG(hw, RCTL, rctl); |
| 1095 | 1095 | } else { |
| 1096 | − u8 *mta = kmalloc(IXGB_MAX_NUM_MULTICAST_ADDRESSES * | |
| 1097 | − ETH_ALEN, GFP_ATOMIC); | |
| 1096 | + u8 *mta = kmalloc_array(ETH_ALEN, | |
| 1097 | + IXGB_MAX_NUM_MULTICAST_ADDRESSES, | |
| 1098 | + GFP_ATOMIC); | |
| 1098 | 1099 | u8 *addr; |
| 1099 | 1100 | if (!mta) |
| 1100 | 1101 | goto alloc_failed; |
| @@ -901,7 +901,7 @@ static int ixgbe_get_eeprom(struct net_device *netdev, · 900 unmodified lines | ||
| 901 | 901 | last_word = (eeprom->offset + eeprom->len - 1) >> 1; |
| 902 | 902 | eeprom_len = last_word - first_word + 1; |
| 903 | 903 | |
| 904 | − eeprom_buff = kmalloc(sizeof(u16) * eeprom_len, GFP_KERNEL); | |
| 904 | + eeprom_buff = kmalloc_array(eeprom_len, sizeof(u16), GFP_KERNEL); | |
| 905 | 905 | if (!eeprom_buff) |
| 906 | 906 | return -ENOMEM; |
| 907 | 907 | |
| @@ -1063,7 +1063,7 @@ static int ixgbe_set_ringparam(struct net_device *netdev, · 155 unmodified lines | ||
| 1063 | 1063 | /* allocate temporary buffer to store rings in */ |
| 1064 | 1064 | i = max_t(int, adapter->num_tx_queues + adapter->num_xdp_queues, |
| 1065 | 1065 | adapter->num_rx_queues); |
| 1066 | − temp_ring = vmalloc(i * sizeof(struct ixgbe_ring)); | |
| 1066 | + temp_ring = vmalloc(array_size(i, sizeof(struct ixgbe_ring))); | |
| 1067 | 1067 | |
| 1068 | 1068 | if (!temp_ring) { |
| 1069 | 1069 | err = -ENOMEM; |
| @@ -6034,8 +6034,8 @@ static int ixgbe_sw_init(struct ixgbe_adapter *adapter, · 6033 unmodified lines | ||
| 6034 | 6034 | for (i = 1; i < IXGBE_MAX_LINK_HANDLE; i++) |
| 6035 | 6035 | adapter->jump_tables[i] = NULL; |
| 6036 | 6036 | |
| 6037 | − adapter->mac_table = kzalloc(sizeof(struct ixgbe_mac_addr) * | |
| 6038 | − hw->mac.num_rar_entries, | |
| 6037 | + adapter->mac_table = kcalloc(hw->mac.num_rar_entries, | |
| 6038 | + sizeof(struct ixgbe_mac_addr), | |
| 6039 | 6039 | GFP_ATOMIC); |
| 6040 | 6040 | if (!adapter->mac_table) |
| 6041 | 6041 | return -ENOMEM; |
| @@ -282,8 +282,9 @@ static int ixgbevf_set_ringparam(struct net_device *netdev, · 281 unmodified lines | ||
| 282 | 282 | } |
| 283 | 283 | |
| 284 | 284 | if (new_tx_count != adapter->tx_ring_count) { |
| 285 | − tx_ring = vmalloc((adapter->num_tx_queues + | |
| 286 | − adapter->num_xdp_queues) * sizeof(*tx_ring)); | |
| 285 | + tx_ring = vmalloc(array_size(sizeof(*tx_ring), | |
| 286 | + adapter->num_tx_queues + | |
| 287 | + adapter->num_xdp_queues)); | |
| 287 | 288 | if (!tx_ring) { |
| 288 | 289 | err = -ENOMEM; |
| 289 | 290 | goto clear_reset; |
| @@ -327,7 +328,8 @@ static int ixgbevf_set_ringparam(struct net_device *netdev, · 37 unmodified lines | ||
| 327 | 328 | } |
| 328 | 329 | |
| 329 | 330 | if (new_rx_count != adapter->rx_ring_count) { |
| 330 | − rx_ring = vmalloc(adapter->num_rx_queues * sizeof(*rx_ring)); | |
| 331 | + rx_ring = vmalloc(array_size(sizeof(*rx_ring), | |
| 332 | + adapter->num_rx_queues)); | |
| 331 | 333 | if (!rx_ring) { |
| 332 | 334 | err = -ENOMEM; |
| 333 | 335 | goto clear_reset; |
| @@ -589,8 +589,9 @@ jme_setup_tx_resources(struct jme_adapter *jme) · 588 unmodified lines | ||
| 589 | 589 | atomic_set(&txring->next_to_clean, 0); |
| 590 | 590 | atomic_set(&txring->nr_free, jme->tx_ring_size); |
| 591 | 591 | |
| 592 | − txring->bufinf = kzalloc(sizeof(struct jme_buffer_info) * | |
| 593 | − jme->tx_ring_size, GFP_ATOMIC); | |
| 592 | + txring->bufinf = kcalloc(jme->tx_ring_size, | |
| 593 | + sizeof(struct jme_buffer_info), | |
| 594 | + GFP_ATOMIC); | |
| 594 | 595 | if (unlikely(!(txring->bufinf))) |
| 595 | 596 | goto err_free_txring; |
| 596 | 597 | |
| @@ -838,8 +839,9 @@ jme_setup_rx_resources(struct jme_adapter *jme) · 241 unmodified lines | ||
| 838 | 839 | rxring->next_to_use = 0; |
| 839 | 840 | atomic_set(&rxring->next_to_clean, 0); |
| 840 | 841 | |
| 841 | − rxring->bufinf = kzalloc(sizeof(struct jme_buffer_info) * | |
| 842 | − jme->rx_ring_size, GFP_ATOMIC); | |
| 842 | + rxring->bufinf = kcalloc(jme->rx_ring_size, | |
| 843 | + sizeof(struct jme_buffer_info), | |
| 844 | + GFP_ATOMIC); | |
| 843 | 845 | if (unlikely(!(rxring->bufinf))) |
| 844 | 846 | goto err_free_rxring; |
| 845 | 847 | |
| @@ -185,8 +185,8 @@ int mlx4_bitmap_init(struct mlx4_bitmap *bitmap, u32 num, u32 mask, · 184 unmodified lines | ||
| 185 | 185 | bitmap->avail = num - reserved_top - reserved_bot; |
| 186 | 186 | bitmap->effective_len = bitmap->avail; |
| 187 | 187 | spin_lock_init(&bitmap->lock); |
| 188 | − bitmap->table = kzalloc(BITS_TO_LONGS(bitmap->max) * | |
| 189 | − sizeof(long), GFP_KERNEL); | |
| 188 | + bitmap->table = kcalloc(BITS_TO_LONGS(bitmap->max), sizeof(long), | |
| 189 | + GFP_KERNEL); | |
| 190 | 190 | if (!bitmap->table) |
| 191 | 191 | return -ENOMEM; |
| 192 | 192 | |
| @@ -2377,20 +2377,23 @@ int mlx4_multi_func_init(struct mlx4_dev *dev) · 2376 unmodified lines | ||
| 2377 | 2377 | struct mlx4_vf_admin_state *vf_admin; |
| 2378 | 2378 | |
| 2379 | 2379 | priv->mfunc.master.slave_state = |
| 2380 | − kzalloc(dev->num_slaves * | |
| 2381 | − sizeof(struct mlx4_slave_state), GFP_KERNEL); | |
| 2380 | + kcalloc(dev->num_slaves, | |
| 2381 | + sizeof(struct mlx4_slave_state), | |
| 2382 | + GFP_KERNEL); | |
| 2382 | 2383 | if (!priv->mfunc.master.slave_state) |
| 2383 | 2384 | goto err_comm; |
| 2384 | 2385 | |
| 2385 | 2386 | priv->mfunc.master.vf_admin = |
| 2386 | − kzalloc(dev->num_slaves * | |
| 2387 | − sizeof(struct mlx4_vf_admin_state), GFP_KERNEL); | |
| 2387 | + kcalloc(dev->num_slaves, | |
| 2388 | + sizeof(struct mlx4_vf_admin_state), | |
| 2389 | + GFP_KERNEL); | |
| 2388 | 2390 | if (!priv->mfunc.master.vf_admin) |
| 2389 | 2391 | goto err_comm_admin; |
| 2390 | 2392 | |
| 2391 | 2393 | priv->mfunc.master.vf_oper = |
| 2392 | − kzalloc(dev->num_slaves * | |
| 2393 | − sizeof(struct mlx4_vf_oper_state), GFP_KERNEL); | |
| 2394 | + kcalloc(dev->num_slaves, | |
| 2395 | + sizeof(struct mlx4_vf_oper_state), | |
| 2396 | + GFP_KERNEL); | |
| 2394 | 2397 | if (!priv->mfunc.master.vf_oper) |
| 2395 | 2398 | goto err_comm_oper; |
| 2396 | 2399 | |
| @@ -2636,9 +2639,9 @@ int mlx4_cmd_use_events(struct mlx4_dev *dev) · 239 unmodified lines | ||
| 2636 | 2639 | int i; |
| 2637 | 2640 | int err = 0; |
| 2638 | 2641 | |
| 2639 | − priv->cmd.context = kmalloc(priv->cmd.max_cmds * | |
| 2640 | − sizeof(struct mlx4_cmd_context), | |
| 2641 | − GFP_KERNEL); | |
| 2642 | + priv->cmd.context = kmalloc_array(priv->cmd.max_cmds, | |
| 2643 | + sizeof(struct mlx4_cmd_context), | |
| 2644 | + GFP_KERNEL); | |
| 2642 | 2645 | if (!priv->cmd.context) |
| 2643 | 2646 | return -ENOMEM; |
| 2644 | 2647 | |
| @@ -2229,13 +2229,15 @@ static int mlx4_en_copy_priv(struct mlx4_en_priv *dst, · 2228 unmodified lines | ||
| 2229 | 2229 | if (!dst->tx_ring_num[t]) |
| 2230 | 2230 | continue; |
| 2231 | 2231 | |
| 2232 | − dst->tx_ring[t] = kzalloc(sizeof(struct mlx4_en_tx_ring *) * | |
| 2233 | − MAX_TX_RINGS, GFP_KERNEL); | |
| 2232 | + dst->tx_ring[t] = kcalloc(MAX_TX_RINGS, | |
| 2233 | + sizeof(struct mlx4_en_tx_ring *), | |
| 2234 | + GFP_KERNEL); | |
| 2234 | 2235 | if (!dst->tx_ring[t]) |
| 2235 | 2236 | goto err_free_tx; |
| 2236 | 2237 | |
| 2237 | − dst->tx_cq[t] = kzalloc(sizeof(struct mlx4_en_cq *) * | |
| 2238 | − MAX_TX_RINGS, GFP_KERNEL); | |
| 2238 | + dst->tx_cq[t] = kcalloc(MAX_TX_RINGS, | |
| 2239 | + sizeof(struct mlx4_en_cq *), | |
| 2240 | + GFP_KERNEL); | |
| 2239 | 2241 | if (!dst->tx_cq[t]) { |
| 2240 | 2242 | kfree(dst->tx_ring[t]); |
| 2241 | 2243 | goto err_free_tx; |
| @@ -3320,14 +3322,16 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port, · 1078 unmodified lines | ||
| 3320 | 3322 | if (!priv->tx_ring_num[t]) |
| 3321 | 3323 | continue; |
| 3322 | 3324 | |
| 3323 | − priv->tx_ring[t] = kzalloc(sizeof(struct mlx4_en_tx_ring *) * | |
| 3324 | − MAX_TX_RINGS, GFP_KERNEL); | |
| 3325 | + priv->tx_ring[t] = kcalloc(MAX_TX_RINGS, | |
| 3326 | + sizeof(struct mlx4_en_tx_ring *), | |
| 3327 | + GFP_KERNEL); | |
| 3325 | 3328 | if (!priv->tx_ring[t]) { |
| 3326 | 3329 | err = -ENOMEM; |
| 3327 | 3330 | goto out; |
| 3328 | 3331 | } |
| 3329 | − priv->tx_cq[t] = kzalloc(sizeof(struct mlx4_en_cq *) * | |
| 3330 | − MAX_TX_RINGS, GFP_KERNEL); | |
| 3332 | + priv->tx_cq[t] = kcalloc(MAX_TX_RINGS, | |
| 3333 | + sizeof(struct mlx4_en_cq *), | |
| 3334 | + GFP_KERNEL); | |
| 3331 | 3335 | if (!priv->tx_cq[t]) { |
| 3332 | 3336 | err = -ENOMEM; |
| 3333 | 3337 | goto out; |
| @@ -1211,8 +1211,9 @@ int mlx4_init_eq_table(struct mlx4_dev *dev) · 1210 unmodified lines | ||
| 1211 | 1211 | } |
| 1212 | 1212 | |
| 1213 | 1213 | priv->eq_table.irq_names = |
| 1214 | − kmalloc(MLX4_IRQNAME_SIZE * (dev->caps.num_comp_vectors + 1), | |
| 1215 | − GFP_KERNEL); | |
| 1214 | + kmalloc_array(MLX4_IRQNAME_SIZE, | |
| 1215 | + (dev->caps.num_comp_vectors + 1), | |
| 1216 | + GFP_KERNEL); | |
| 1216 | 1217 | if (!priv->eq_table.irq_names) { |
| 1217 | 1218 | err = -ENOMEM; |
| 1218 | 1219 | goto err_out_clr_int; |
| @@ -408,7 +408,7 @@ int mlx4_init_icm_table(struct mlx4_dev *dev, struct mlx4_icm_table *table, · 407 unmodified lines | ||
| 408 | 408 | return -EINVAL; |
| 409 | 409 | num_icm = (nobj + obj_per_chunk - 1) / obj_per_chunk; |
| 410 | 410 | |
| 411 | − table->icm = kvzalloc(num_icm * sizeof(*table->icm), GFP_KERNEL); | |
| 411 | + table->icm = kvcalloc(num_icm, sizeof(*table->icm), GFP_KERNEL); | |
| 412 | 412 | if (!table->icm) |
| 413 | 413 | return -ENOMEM; |
| 414 | 414 | table->virt = virt; |
| @@ -2982,7 +2982,8 @@ static int mlx4_init_steering(struct mlx4_dev *dev) · 2981 unmodified lines | ||
| 2982 | 2982 | int num_entries = dev->caps.num_ports; |
| 2983 | 2983 | int i, j; |
| 2984 | 2984 | |
| 2985 | − priv->steer = kzalloc(sizeof(struct mlx4_steer) * num_entries, GFP_KERNEL); | |
| 2985 | + priv->steer = kcalloc(num_entries, sizeof(struct mlx4_steer), | |
| 2986 | + GFP_KERNEL); | |
| 2986 | 2987 | if (!priv->steer) |
| 2987 | 2988 | return -ENOMEM; |
| 2988 | 2989 | |
| @@ -3103,7 +3104,7 @@ static u64 mlx4_enable_sriov(struct mlx4_dev *dev, struct pci_dev *pdev, · 114 unmodified lines | ||
| 3103 | 3104 | } |
| 3104 | 3105 | } |
| 3105 | 3106 | |
| 3106 | − dev->dev_vfs = kzalloc(total_vfs * sizeof(*dev->dev_vfs), GFP_KERNEL); | |
| 3107 | + dev->dev_vfs = kcalloc(total_vfs, sizeof(*dev->dev_vfs), GFP_KERNEL); | |
| 3107 | 3108 | if (NULL == dev->dev_vfs) { |
| 3108 | 3109 | mlx4_err(dev, "Failed to allocate memory for VFs\n"); |
| 3109 | 3110 | goto disable_sriov; |
| @@ -487,7 +487,7 @@ int mlx4_init_resource_tracker(struct mlx4_dev *dev) · 486 unmodified lines | ||
| 487 | 487 | int max_vfs_guarantee_counter = get_max_gauranteed_vfs_counter(dev); |
| 488 | 488 | |
| 489 | 489 | priv->mfunc.master.res_tracker.slave_list = |
| 490 | − kzalloc(dev->num_slaves * sizeof(struct slave_list), | |
| 490 | + kcalloc(dev->num_slaves, sizeof(struct slave_list), | |
| 491 | 491 | GFP_KERNEL); |
| 492 | 492 | if (!priv->mfunc.master.res_tracker.slave_list) |
| 493 | 493 | return -ENOMEM; |
| @@ -507,19 +507,21 @@ int mlx4_init_resource_tracker(struct mlx4_dev *dev) · 13 unmodified lines | ||
| 507 | 507 | for (i = 0; i < MLX4_NUM_OF_RESOURCE_TYPE; i++) { |
| 508 | 508 | struct resource_allocator *res_alloc = |
| 509 | 509 | &priv->mfunc.master.res_tracker.res_alloc[i]; |
| 510 | − res_alloc->quota = kmalloc((dev->persist->num_vfs + 1) * | |
| 511 | − sizeof(int), GFP_KERNEL); | |
| 512 | − res_alloc->guaranteed = kmalloc((dev->persist->num_vfs + 1) * | |
| 513 | − sizeof(int), GFP_KERNEL); | |
| 510 | + res_alloc->quota = kmalloc_array(dev->persist->num_vfs + 1, | |
| 511 | + sizeof(int), | |
| 512 | + GFP_KERNEL); | |
| 513 | + res_alloc->guaranteed = kmalloc_array(dev->persist->num_vfs + 1, | |
| 514 | + sizeof(int), | |
| 515 | + GFP_KERNEL); | |
| 514 | 516 | if (i == RES_MAC || i == RES_VLAN) |
| 515 | − res_alloc->allocated = kzalloc(MLX4_MAX_PORTS * | |
| 516 | − (dev->persist->num_vfs | |
| 517 | − + 1) * | |
| 518 | − sizeof(int), GFP_KERNEL); | |
| 517 | + res_alloc->allocated = | |
| 518 | + kcalloc(MLX4_MAX_PORTS * | |
| 519 | + (dev->persist->num_vfs + 1), | |
| 520 | + sizeof(int), GFP_KERNEL); | |
| 519 | 521 | else |
| 520 | − res_alloc->allocated = kzalloc((dev->persist-> | |
| 521 | − num_vfs + 1) * | |
| 522 | − sizeof(int), GFP_KERNEL); | |
| 522 | + res_alloc->allocated = | |
| 523 | + kcalloc(dev->persist->num_vfs + 1, | |
| 524 | + sizeof(int), GFP_KERNEL); | |
| 523 | 525 | /* Reduce the sink counter */ |
| 524 | 526 | if (i == RES_COUNTER) |
| 525 | 527 | res_alloc->res_free = dev->caps.max_counters - 1; |
| @@ -352,7 +352,7 @@ static int mlx5e_rq_alloc_mpwqe_info(struct mlx5e_rq *rq, · 351 unmodified lines | ||
| 352 | 352 | { |
| 353 | 353 | int wq_sz = mlx5_wq_ll_get_size(&rq->mpwqe.wq); |
| 354 | 354 | |
| 355 | − rq->mpwqe.info = kzalloc_node(wq_sz * sizeof(*rq->mpwqe.info), | |
| 355 | + rq->mpwqe.info = kcalloc_node(wq_sz, sizeof(*rq->mpwqe.info), | |
| 356 | 356 | GFP_KERNEL, cpu_to_node(c->cpu)); |
| 357 | 357 | if (!rq->mpwqe.info) |
| 358 | 358 | return -ENOMEM; |
| @@ -448,7 +448,7 @@ static int mlx5e_init_di_list(struct mlx5e_rq *rq, · 89 unmodified lines | ||
| 448 | 448 | { |
| 449 | 449 | int len = wq_sz << rq->wqe.info.log_num_frags; |
| 450 | 450 | |
| 451 | − rq->wqe.di = kvzalloc_node(len * sizeof(*rq->wqe.di), | |
| 451 | + rq->wqe.di = kvzalloc_node(array_size(len, sizeof(*rq->wqe.di)), | |
| 452 | 452 | GFP_KERNEL, cpu_to_node(cpu)); |
| 453 | 453 | if (!rq->wqe.di) |
| 454 | 454 | return -ENOMEM; |
| @@ -563,8 +563,8 @@ static int mlx5e_alloc_rq(struct mlx5e_channel *c, · 108 unmodified lines | ||
| 563 | 563 | |
| 564 | 564 | rq->wqe.info = rqp->frags_info; |
| 565 | 565 | rq->wqe.frags = |
| 566 | − kvzalloc_node((wq_sz << rq->wqe.info.log_num_frags) * | |
| 567 | − sizeof(*rq->wqe.frags), | |
| 566 | + kvzalloc_node(array_size(sizeof(*rq->wqe.frags), | |
| 567 | + (wq_sz << rq->wqe.info.log_num_frags)), | |
| 568 | 568 | GFP_KERNEL, cpu_to_node(c->cpu)); |
| 569 | 569 | if (!rq->wqe.frags) { |
| 570 | 570 | err = -ENOMEM; |
| @@ -972,7 +972,7 @@ static int mlx5e_alloc_xdpsq_db(struct mlx5e_xdpsq *sq, int numa) · 401 unmodified lines | ||
| 972 | 972 | { |
| 973 | 973 | int wq_sz = mlx5_wq_cyc_get_size(&sq->wq); |
| 974 | 974 | |
| 975 | − sq->db.di = kzalloc_node(sizeof(*sq->db.di) * wq_sz, | |
| 975 | + sq->db.di = kcalloc_node(wq_sz, sizeof(*sq->db.di), | |
| 976 | 976 | GFP_KERNEL, numa); |
| 977 | 977 | if (!sq->db.di) { |
| 978 | 978 | mlx5e_free_xdpsq_db(sq); |
| @@ -1031,7 +1031,7 @@ static int mlx5e_alloc_icosq_db(struct mlx5e_icosq *sq, int numa) · 52 unmodified lines | ||
| 1031 | 1031 | { |
| 1032 | 1032 | u8 wq_sz = mlx5_wq_cyc_get_size(&sq->wq); |
| 1033 | 1033 | |
| 1034 | − sq->db.ico_wqe = kzalloc_node(sizeof(*sq->db.ico_wqe) * wq_sz, | |
| 1034 | + sq->db.ico_wqe = kcalloc_node(wq_sz, sizeof(*sq->db.ico_wqe), | |
| 1035 | 1035 | GFP_KERNEL, numa); |
| 1036 | 1036 | if (!sq->db.ico_wqe) |
| 1037 | 1037 | return -ENOMEM; |
| @@ -1086,9 +1086,9 @@ static int mlx5e_alloc_txqsq_db(struct mlx5e_txqsq *sq, int numa) · 48 unmodified lines | ||
| 1086 | 1086 | int wq_sz = mlx5_wq_cyc_get_size(&sq->wq); |
| 1087 | 1087 | int df_sz = wq_sz * MLX5_SEND_WQEBB_NUM_DS; |
| 1088 | 1088 | |
| 1089 | − sq->db.dma_fifo = kzalloc_node(df_sz * sizeof(*sq->db.dma_fifo), | |
| 1089 | + sq->db.dma_fifo = kcalloc_node(df_sz, sizeof(*sq->db.dma_fifo), | |
| 1090 | 1090 | GFP_KERNEL, numa); |
| 1091 | − sq->db.wqe_info = kzalloc_node(wq_sz * sizeof(*sq->db.wqe_info), | |
| 1091 | + sq->db.wqe_info = kcalloc_node(wq_sz, sizeof(*sq->db.wqe_info), | |
| 1092 | 1092 | GFP_KERNEL, numa); |
| 1093 | 1093 | if (!sq->db.dma_fifo || !sq->db.wqe_info) { |
| 1094 | 1094 | mlx5e_free_txqsq_db(sq); |
| @@ -549,15 +549,17 @@ static int mlx5_fpga_conn_create_qp(struct mlx5_fpga_conn *conn, · 548 unmodified lines | ||
| 549 | 549 | if (err) |
| 550 | 550 | goto out; |
| 551 | 551 | |
| 552 | − conn->qp.rq.bufs = kvzalloc(sizeof(conn->qp.rq.bufs[0]) * | |
| 553 | − conn->qp.rq.size, GFP_KERNEL); | |
| 552 | + conn->qp.rq.bufs = kvcalloc(conn->qp.rq.size, | |
| 553 | + sizeof(conn->qp.rq.bufs[0]), | |
| 554 | + GFP_KERNEL); | |
| 554 | 555 | if (!conn->qp.rq.bufs) { |
| 555 | 556 | err = -ENOMEM; |
| 556 | 557 | goto err_wq; |
| 557 | 558 | } |
| 558 | 559 | |
| 559 | − conn->qp.sq.bufs = kvzalloc(sizeof(conn->qp.sq.bufs[0]) * | |
| 560 | − conn->qp.sq.size, GFP_KERNEL); | |
| 560 | + conn->qp.sq.bufs = kvcalloc(conn->qp.sq.size, | |
| 561 | + sizeof(conn->qp.sq.bufs[0]), | |
| 562 | + GFP_KERNEL); | |
| 561 | 563 | if (!conn->qp.sq.bufs) { |
| 562 | 564 | err = -ENOMEM; |
| 563 | 565 | goto err_rq_bufs; |
| @@ -381,7 +381,7 @@ int mlx5_fpga_ipsec_counters_read(struct mlx5_core_dev *mdev, u64 *counters, · 380 unmodified lines | ||
| 381 | 381 | |
| 382 | 382 | count = mlx5_fpga_ipsec_counters_count(mdev); |
| 383 | 383 | |
| 384 | − data = kzalloc(sizeof(*data) * count * 2, GFP_KERNEL); | |
| 384 | + data = kzalloc(array3_size(sizeof(*data), count, 2), GFP_KERNEL); | |
| 385 | 385 | if (!data) { |
| 386 | 386 | ret = -ENOMEM; |
| 387 | 387 | goto out; |
| @@ -394,8 +394,9 @@ static int mlx5_init_pin_config(struct mlx5_clock *clock) · 393 unmodified lines | ||
| 394 | 394 | int i; |
| 395 | 395 | |
| 396 | 396 | clock->ptp_info.pin_config = |
| 397 | − kzalloc(sizeof(*clock->ptp_info.pin_config) * | |
| 398 | − clock->ptp_info.n_pins, GFP_KERNEL); | |
| 397 | + kcalloc(clock->ptp_info.n_pins, | |
| 398 | + sizeof(*clock->ptp_info.pin_config), | |
| 399 | + GFP_KERNEL); | |
| 399 | 400 | if (!clock->ptp_info.pin_config) |
| 400 | 401 | return -ENOMEM; |
| 401 | 402 | clock->ptp_info.enable = mlx5_ptp_enable; |
| @@ -740,7 +740,8 @@ int mlxsw_sp_tc_qdisc_init(struct mlxsw_sp_port *mlxsw_sp_port) · 739 unmodified lines | ||
| 740 | 740 | mlxsw_sp_port->root_qdisc->prio_bitmap = 0xff; |
| 741 | 741 | mlxsw_sp_port->root_qdisc->tclass_num = MLXSW_SP_PORT_DEFAULT_TCLASS; |
| 742 | 742 | |
| 743 | − mlxsw_sp_qdisc = kzalloc(sizeof(*mlxsw_sp_qdisc) * IEEE_8021QAZ_MAX_TCS, | |
| 743 | + mlxsw_sp_qdisc = kcalloc(IEEE_8021QAZ_MAX_TCS, | |
| 744 | + sizeof(*mlxsw_sp_qdisc), | |
| 744 | 745 | GFP_KERNEL); |
| 745 | 746 | if (!mlxsw_sp_qdisc) |
| 746 | 747 | goto err_tclass_qdiscs_init; |
| @@ -4372,7 +4372,7 @@ static void ksz_update_timer(struct ksz_timer_info *info) · 4371 unmodified lines | ||
| 4372 | 4372 | */ |
| 4373 | 4373 | static int ksz_alloc_soft_desc(struct ksz_desc_info *desc_info, int transmit) |
| 4374 | 4374 | { |
| 4375 | − desc_info->ring = kzalloc(sizeof(struct ksz_desc) * desc_info->alloc, | |
| 4375 | + desc_info->ring = kcalloc(desc_info->alloc, sizeof(struct ksz_desc), | |
| 4376 | 4376 | GFP_KERNEL); |
| 4377 | 4377 | if (!desc_info->ring) |
| 4378 | 4378 | return 1; |
| @@ -507,15 +507,15 @@ static int moxart_mac_probe(struct platform_device *pdev) · 506 unmodified lines | ||
| 507 | 507 | goto init_fail; |
| 508 | 508 | } |
| 509 | 509 | |
| 510 | − priv->tx_buf_base = kmalloc(priv->tx_buf_size * TX_DESC_NUM, | |
| 511 | − GFP_ATOMIC); | |
| 510 | + priv->tx_buf_base = kmalloc_array(priv->tx_buf_size, TX_DESC_NUM, | |
| 511 | + GFP_ATOMIC); | |
| 512 | 512 | if (!priv->tx_buf_base) { |
| 513 | 513 | ret = -ENOMEM; |
| 514 | 514 | goto init_fail; |
| 515 | 515 | } |
| 516 | 516 | |
| 517 | − priv->rx_buf_base = kmalloc(priv->rx_buf_size * RX_DESC_NUM, | |
| 518 | − GFP_ATOMIC); | |
| 517 | + priv->rx_buf_base = kmalloc_array(priv->rx_buf_size, RX_DESC_NUM, | |
| 518 | + GFP_ATOMIC); | |
| 519 | 519 | if (!priv->rx_buf_base) { |
| 520 | 520 | ret = -ENOMEM; |
| 521 | 521 | goto init_fail; |
| @@ -2220,22 +2220,22 @@ __vxge_hw_channel_allocate(struct __vxge_hw_vpath_handle *vph, · 2219 unmodified lines | ||
| 2220 | 2220 | channel->length = length; |
| 2221 | 2221 | channel->vp_id = vp_id; |
| 2222 | 2222 | |
| 2223 | − channel->work_arr = kzalloc(sizeof(void *)*length, GFP_KERNEL); | |
| 2223 | + channel->work_arr = kcalloc(length, sizeof(void *), GFP_KERNEL); | |
| 2224 | 2224 | if (channel->work_arr == NULL) |
| 2225 | 2225 | goto exit1; |
| 2226 | 2226 | |
| 2227 | − channel->free_arr = kzalloc(sizeof(void *)*length, GFP_KERNEL); | |
| 2227 | + channel->free_arr = kcalloc(length, sizeof(void *), GFP_KERNEL); | |
| 2228 | 2228 | if (channel->free_arr == NULL) |
| 2229 | 2229 | goto exit1; |
| 2230 | 2230 | channel->free_ptr = length; |
| 2231 | 2231 | |
| 2232 | − channel->reserve_arr = kzalloc(sizeof(void *)*length, GFP_KERNEL); | |
| 2232 | + channel->reserve_arr = kcalloc(length, sizeof(void *), GFP_KERNEL); | |
| 2233 | 2233 | if (channel->reserve_arr == NULL) |
| 2234 | 2234 | goto exit1; |
| 2235 | 2235 | channel->reserve_ptr = length; |
| 2236 | 2236 | channel->reserve_top = 0; |
| 2237 | 2237 | |
| 2238 | − channel->orig_arr = kzalloc(sizeof(void *)*length, GFP_KERNEL); | |
| 2238 | + channel->orig_arr = kcalloc(length, sizeof(void *), GFP_KERNEL); | |
| 2239 | 2239 | if (channel->orig_arr == NULL) |
| 2240 | 2240 | goto exit1; |
| 2241 | 2241 | |
| @@ -2565,7 +2565,7 @@ __vxge_hw_mempool_grow(struct vxge_hw_mempool *mempool, u32 num_allocate, · 323 unmodified lines | ||
| 2565 | 2565 | * allocate new memblock and its private part at once. |
| 2566 | 2566 | * This helps to minimize memory usage a lot. */ |
| 2567 | 2567 | mempool->memblocks_priv_arr[i] = |
| 2568 | − vzalloc(mempool->items_priv_size * n_items); | |
| 2568 | + vzalloc(array_size(mempool->items_priv_size, n_items)); | |
| 2569 | 2569 | if (mempool->memblocks_priv_arr[i] == NULL) { |
| 2570 | 2570 | status = VXGE_HW_ERR_OUT_OF_MEMORY; |
| 2571 | 2571 | goto exit; |
| @@ -2665,7 +2665,7 @@ __vxge_hw_mempool_create(struct __vxge_hw_device *devh, · 93 unmodified lines | ||
| 2665 | 2665 | |
| 2666 | 2666 | /* allocate array of memblocks */ |
| 2667 | 2667 | mempool->memblocks_arr = |
| 2668 | − vzalloc(sizeof(void *) * mempool->memblocks_max); | |
| 2668 | + vzalloc(array_size(sizeof(void *), mempool->memblocks_max)); | |
| 2669 | 2669 | if (mempool->memblocks_arr == NULL) { |
| 2670 | 2670 | __vxge_hw_mempool_destroy(mempool); |
| 2671 | 2671 | status = VXGE_HW_ERR_OUT_OF_MEMORY; |
| @@ -2675,7 +2675,7 @@ __vxge_hw_mempool_create(struct __vxge_hw_device *devh, · 3 unmodified lines | ||
| 2675 | 2675 | |
| 2676 | 2676 | /* allocate array of private parts of items per memblocks */ |
| 2677 | 2677 | mempool->memblocks_priv_arr = |
| 2678 | − vzalloc(sizeof(void *) * mempool->memblocks_max); | |
| 2678 | + vzalloc(array_size(sizeof(void *), mempool->memblocks_max)); | |
| 2679 | 2679 | if (mempool->memblocks_priv_arr == NULL) { |
| 2680 | 2680 | __vxge_hw_mempool_destroy(mempool); |
| 2681 | 2681 | status = VXGE_HW_ERR_OUT_OF_MEMORY; |
| @@ -2685,8 +2685,8 @@ __vxge_hw_mempool_create(struct __vxge_hw_device *devh, · 3 unmodified lines | ||
| 2685 | 2685 | |
| 2686 | 2686 | /* allocate array of memblocks DMA objects */ |
| 2687 | 2687 | mempool->memblocks_dma_arr = |
| 2688 | − vzalloc(sizeof(struct vxge_hw_mempool_dma) * | |
| 2689 | − mempool->memblocks_max); | |
| 2688 | + vzalloc(array_size(sizeof(struct vxge_hw_mempool_dma), | |
| 2689 | + mempool->memblocks_max)); | |
| 2690 | 2690 | if (mempool->memblocks_dma_arr == NULL) { |
| 2691 | 2691 | __vxge_hw_mempool_destroy(mempool); |
| 2692 | 2692 | status = VXGE_HW_ERR_OUT_OF_MEMORY; |
| @@ -2695,7 +2695,8 @@ __vxge_hw_mempool_create(struct __vxge_hw_device *devh, · 2 unmodified lines | ||
| 2695 | 2695 | } |
| 2696 | 2696 | |
| 2697 | 2697 | /* allocate hash array of items */ |
| 2698 | − mempool->items_arr = vzalloc(sizeof(void *) * mempool->items_max); | |
| 2698 | + mempool->items_arr = vzalloc(array_size(sizeof(void *), | |
| 2699 | + mempool->items_max)); | |
| 2699 | 2700 | if (mempool->items_arr == NULL) { |
| 2700 | 2701 | __vxge_hw_mempool_destroy(mempool); |
| 2701 | 2702 | status = VXGE_HW_ERR_OUT_OF_MEMORY; |
| @@ -3429,8 +3429,8 @@ static int vxge_device_register(struct __vxge_hw_device *hldev, · 3428 unmodified lines | ||
| 3429 | 3429 | vxge_initialize_ethtool_ops(ndev); |
| 3430 | 3430 | |
| 3431 | 3431 | /* Allocate memory for vpath */ |
| 3432 | − vdev->vpaths = kzalloc((sizeof(struct vxge_vpath)) * | |
| 3433 | − no_of_vpath, GFP_KERNEL); | |
| 3432 | + vdev->vpaths = kcalloc(no_of_vpath, sizeof(struct vxge_vpath), | |
| 3433 | + GFP_KERNEL); | |
| 3434 | 3434 | if (!vdev->vpaths) { |
| 3435 | 3435 | vxge_debug_init(VXGE_ERR, |
| 3436 | 3436 | "%s: vpath memory allocation failed", |
| @@ -590,7 +590,7 @@ nfp_abm_vnic_alloc(struct nfp_app *app, struct nfp_net *nn, unsigned int id) · 589 unmodified lines | ||
| 590 | 590 | alink->id = id; |
| 591 | 591 | alink->parent = TC_H_ROOT; |
| 592 | 592 | alink->total_queues = alink->vnic->max_rx_rings; |
| 593 | − alink->qdiscs = kvzalloc(sizeof(*alink->qdiscs) * alink->total_queues, | |
| 593 | + alink->qdiscs = kvcalloc(alink->total_queues, sizeof(*alink->qdiscs), | |
| 594 | 594 | GFP_KERNEL); |
| 595 | 595 | if (!alink->qdiscs) { |
| 596 | 596 | err = -ENOMEM; |
| @@ -417,7 +417,8 @@ int nfp_flower_metadata_init(struct nfp_app *app) · 416 unmodified lines | ||
| 417 | 417 | |
| 418 | 418 | /* Init ring buffer and unallocated stats_ids. */ |
| 419 | 419 | priv->stats_ids.free_list.buf = |
| 420 | − vmalloc(NFP_FL_STATS_ENTRY_RS * NFP_FL_STATS_ELEM_RS); | |
| 420 | + vmalloc(array_size(NFP_FL_STATS_ELEM_RS, | |
| 421 | + NFP_FL_STATS_ENTRY_RS)); | |
| 421 | 422 | if (!priv->stats_ids.free_list.buf) |
| 422 | 423 | goto err_free_last_used; |
| 423 | 424 | |
| @@ -247,9 +247,8 @@ static int nixge_hw_dma_bd_init(struct net_device *ndev) · 246 unmodified lines | ||
| 247 | 247 | if (!priv->tx_bd_v) |
| 248 | 248 | goto out; |
| 249 | 249 | |
| 250 | − priv->tx_skb = devm_kzalloc(ndev->dev.parent, | |
| 251 | − sizeof(*priv->tx_skb) * | |
| 252 | − TX_BD_NUM, | |
| 250 | + priv->tx_skb = devm_kcalloc(ndev->dev.parent, | |
| 251 | + TX_BD_NUM, sizeof(*priv->tx_skb), | |
| 253 | 252 | GFP_KERNEL); |
| 254 | 253 | if (!priv->tx_skb) |
| 255 | 254 | goto out; |
| @@ -4630,8 +4630,10 @@ static int nv_set_ringparam(struct net_device *dev, struct ethtool_ringparam* ri · 4629 unmodified lines | ||
| 4630 | 4630 | ring->tx_pending), |
| 4631 | 4631 | &ring_addr, GFP_ATOMIC); |
| 4632 | 4632 | } |
| 4633 | − rx_skbuff = kmalloc(sizeof(struct nv_skb_map) * ring->rx_pending, GFP_KERNEL); | |
| 4634 | − tx_skbuff = kmalloc(sizeof(struct nv_skb_map) * ring->tx_pending, GFP_KERNEL); | |
| 4633 | + rx_skbuff = kmalloc_array(ring->rx_pending, sizeof(struct nv_skb_map), | |
| 4634 | + GFP_KERNEL); | |
| 4635 | + tx_skbuff = kmalloc_array(ring->tx_pending, sizeof(struct nv_skb_map), | |
| 4636 | + GFP_KERNEL); | |
| 4635 | 4637 | if (!rxtx_ring || !rx_skbuff || !tx_skbuff) { |
| 4636 | 4638 | /* fall back to old rings */ |
| 4637 | 4639 | if (!nv_optimized(np)) { |
| @@ -2178,7 +2178,7 @@ static void pch_gbe_set_multi(struct net_device *netdev) · 2177 unmodified lines | ||
| 2178 | 2178 | |
| 2179 | 2179 | if (mc_count >= PCH_GBE_MAR_ENTRIES) |
| 2180 | 2180 | return; |
| 2181 | − mta_list = kmalloc(mc_count * ETH_ALEN, GFP_ATOMIC); | |
| 2181 | + mta_list = kmalloc_array(ETH_ALEN, mc_count, GFP_ATOMIC); | |
| 2182 | 2182 | if (!mta_list) |
| 2183 | 2183 | return; |
| 2184 | 2184 | |
| @@ -390,8 +390,9 @@ static int pasemi_mac_setup_rx_resources(const struct net_device *dev) · 389 unmodified lines | ||
| 390 | 390 | spin_lock_init(&ring->lock); |
| 391 | 391 | |
| 392 | 392 | ring->size = RX_RING_SIZE; |
| 393 | − ring->ring_info = kzalloc(sizeof(struct pasemi_mac_buffer) * | |
| 394 | − RX_RING_SIZE, GFP_KERNEL); | |
| 393 | + ring->ring_info = kcalloc(RX_RING_SIZE, | |
| 394 | + sizeof(struct pasemi_mac_buffer), | |
| 395 | + GFP_KERNEL); | |
| 395 | 396 | |
| 396 | 397 | if (!ring->ring_info) |
| 397 | 398 | goto out_ring_info; |
| @@ -473,8 +474,9 @@ pasemi_mac_setup_tx_resources(const struct net_device *dev) · 75 unmodified lines | ||
| 473 | 474 | spin_lock_init(&ring->lock); |
| 474 | 475 | |
| 475 | 476 | ring->size = TX_RING_SIZE; |
| 476 | − ring->ring_info = kzalloc(sizeof(struct pasemi_mac_buffer) * | |
| 477 | − TX_RING_SIZE, GFP_KERNEL); | |
| 477 | + ring->ring_info = kcalloc(TX_RING_SIZE, | |
| 478 | + sizeof(struct pasemi_mac_buffer), | |
| 479 | + GFP_KERNEL); | |
| 478 | 480 | if (!ring->ring_info) |
| 479 | 481 | goto out_ring_info; |
| 480 | 482 | |
| @@ -6617,7 +6617,8 @@ static enum dbg_status qed_mcp_trace_alloc_meta(struct qed_hwfn *p_hwfn, · 6616 unmodified lines | ||
| 6617 | 6617 | |
| 6618 | 6618 | /* Read no. of modules and allocate memory for their pointers */ |
| 6619 | 6619 | meta->modules_num = qed_read_byte_from_buf(meta_buf_bytes, &offset); |
| 6620 | − meta->modules = kzalloc(meta->modules_num * sizeof(char *), GFP_KERNEL); | |
| 6620 | + meta->modules = kcalloc(meta->modules_num, sizeof(char *), | |
| 6621 | + GFP_KERNEL); | |
| 6621 | 6622 | if (!meta->modules) |
| 6622 | 6623 | return DBG_STATUS_VIRT_MEM_ALLOC_FAILED; |
| 6623 | 6624 | |
| @@ -6645,7 +6646,7 @@ static enum dbg_status qed_mcp_trace_alloc_meta(struct qed_hwfn *p_hwfn, · 21 unmodified lines | ||
| 6645 | 6646 | |
| 6646 | 6647 | /* Read number of formats and allocate memory for all formats */ |
| 6647 | 6648 | meta->formats_num = qed_read_dword_from_buf(meta_buf_bytes, &offset); |
| 6648 | − meta->formats = kzalloc(meta->formats_num * | |
| 6649 | + meta->formats = kcalloc(meta->formats_num, | |
| 6649 | 6650 | sizeof(struct mcp_trace_format), |
| 6650 | 6651 | GFP_KERNEL); |
| 6651 | 6652 | if (!meta->formats) |
| @@ -814,26 +814,26 @@ static int qed_alloc_qm_data(struct qed_hwfn *p_hwfn) · 813 unmodified lines | ||
| 814 | 814 | if (rc) |
| 815 | 815 | goto alloc_err; |
| 816 | 816 | |
| 817 | − qm_info->qm_pq_params = kzalloc(sizeof(*qm_info->qm_pq_params) * | |
| 818 | − qed_init_qm_get_num_pqs(p_hwfn), | |
| 817 | + qm_info->qm_pq_params = kcalloc(qed_init_qm_get_num_pqs(p_hwfn), | |
| 818 | + sizeof(*qm_info->qm_pq_params), | |
| 819 | 819 | GFP_KERNEL); |
| 820 | 820 | if (!qm_info->qm_pq_params) |
| 821 | 821 | goto alloc_err; |
| 822 | 822 | |
| 823 | − qm_info->qm_vport_params = kzalloc(sizeof(*qm_info->qm_vport_params) * | |
| 824 | − qed_init_qm_get_num_vports(p_hwfn), | |
| 823 | + qm_info->qm_vport_params = kcalloc(qed_init_qm_get_num_vports(p_hwfn), | |
| 824 | + sizeof(*qm_info->qm_vport_params), | |
| 825 | 825 | GFP_KERNEL); |
| 826 | 826 | if (!qm_info->qm_vport_params) |
| 827 | 827 | goto alloc_err; |
| 828 | 828 | |
| 829 | − qm_info->qm_port_params = kzalloc(sizeof(*qm_info->qm_port_params) * | |
| 830 | − p_hwfn->cdev->num_ports_in_engine, | |
| 829 | + qm_info->qm_port_params = kcalloc(p_hwfn->cdev->num_ports_in_engine, | |
| 830 | + sizeof(*qm_info->qm_port_params), | |
| 831 | 831 | GFP_KERNEL); |
| 832 | 832 | if (!qm_info->qm_port_params) |
| 833 | 833 | goto alloc_err; |
| 834 | 834 | |
| 835 | − qm_info->wfq_data = kzalloc(sizeof(*qm_info->wfq_data) * | |
| 836 | − qed_init_qm_get_num_vports(p_hwfn), | |
| 835 | + qm_info->wfq_data = kcalloc(qed_init_qm_get_num_vports(p_hwfn), | |
| 836 | + sizeof(*qm_info->wfq_data), | |
| 837 | 837 | GFP_KERNEL); |
| 838 | 838 | if (!qm_info->wfq_data) |
| 839 | 839 | goto alloc_err; |
| @@ -149,12 +149,12 @@ int qed_init_alloc(struct qed_hwfn *p_hwfn) · 148 unmodified lines | ||
| 149 | 149 | if (IS_VF(p_hwfn->cdev)) |
| 150 | 150 | return 0; |
| 151 | 151 | |
| 152 | − rt_data->b_valid = kzalloc(sizeof(bool) * RUNTIME_ARRAY_SIZE, | |
| 152 | + rt_data->b_valid = kcalloc(RUNTIME_ARRAY_SIZE, sizeof(bool), | |
| 153 | 153 | GFP_KERNEL); |
| 154 | 154 | if (!rt_data->b_valid) |
| 155 | 155 | return -ENOMEM; |
| 156 | 156 | |
| 157 | − rt_data->init_val = kzalloc(sizeof(u32) * RUNTIME_ARRAY_SIZE, | |
| 157 | + rt_data->init_val = kcalloc(RUNTIME_ARRAY_SIZE, sizeof(u32), | |
| 158 | 158 | GFP_KERNEL); |
| 159 | 159 | if (!rt_data->init_val) { |
| 160 | 160 | kfree(rt_data->b_valid); |
| @@ -98,7 +98,7 @@ int qed_l2_alloc(struct qed_hwfn *p_hwfn) · 97 unmodified lines | ||
| 98 | 98 | p_l2_info->queues = max_t(u8, rx, tx); |
| 99 | 99 | } |
| 100 | 100 | |
| 101 | − pp_qids = kzalloc(sizeof(unsigned long *) * p_l2_info->queues, | |
| 101 | + pp_qids = kcalloc(p_l2_info->queues, sizeof(unsigned long *), | |
| 102 | 102 | GFP_KERNEL); |
| 103 | 103 | if (!pp_qids) |
| 104 | 104 | return -ENOMEM; |
| @@ -2435,7 +2435,7 @@ static int qed_update_vport(struct qed_dev *cdev, · 2330 unmodified lines | ||
| 2435 | 2435 | if (!cdev) |
| 2436 | 2436 | return -ENODEV; |
| 2437 | 2437 | |
| 2438 | − rss = vzalloc(sizeof(*rss) * cdev->num_hwfns); | |
| 2438 | + rss = vzalloc(array_size(sizeof(*rss), cdev->num_hwfns)); | |
| 2439 | 2439 | if (!rss) |
| 2440 | 2440 | return -ENOMEM; |
| 2441 | 2441 | |
| @@ -2578,9 +2578,9 @@ int qed_mcp_nvm_info_populate(struct qed_hwfn *p_hwfn) · 2577 unmodified lines | ||
| 2578 | 2578 | goto err0; |
| 2579 | 2579 | } |
| 2580 | 2580 | |
| 2581 | − nvm_info->image_att = kmalloc(nvm_info->num_images * | |
| 2582 | − sizeof(struct bist_nvm_image_att), | |
| 2583 | − GFP_KERNEL); | |
| 2581 | + nvm_info->image_att = kmalloc_array(nvm_info->num_images, | |
| 2582 | + sizeof(struct bist_nvm_image_att), | |
| 2583 | + GFP_KERNEL); | |
| 2584 | 2584 | if (!nvm_info->image_att) { |
| 2585 | 2585 | rc = -ENOMEM; |
| 2586 | 2586 | goto err0; |
| @@ -342,8 +342,9 @@ int qede_alloc_arfs(struct qede_dev *edev) · 341 unmodified lines | ||
| 342 | 342 | for (i = 0; i <= QEDE_RFS_FLW_MASK; i++) |
| 343 | 343 | INIT_HLIST_HEAD(QEDE_ARFS_BUCKET_HEAD(edev, i)); |
| 344 | 344 | |
| 345 | − edev->arfs->arfs_fltr_bmap = vzalloc(BITS_TO_LONGS(QEDE_RFS_MAX_FLTR) * | |
| 346 | − sizeof(long)); | |
| 345 | + edev->arfs->arfs_fltr_bmap = | |
| 346 | + vzalloc(array_size(sizeof(long), | |
| 347 | + BITS_TO_LONGS(QEDE_RFS_MAX_FLTR))); | |
| 347 | 348 | if (!edev->arfs->arfs_fltr_bmap) { |
| 348 | 349 | vfree(edev->arfs); |
| 349 | 350 | edev->arfs = NULL; |
| @@ -386,8 +386,9 @@ int qlcnic_83xx_setup_intr(struct qlcnic_adapter *adapter) · 385 unmodified lines | ||
| 386 | 386 | } |
| 387 | 387 | |
| 388 | 388 | /* setup interrupt mapping table for fw */ |
| 389 | − ahw->intr_tbl = vzalloc(num_msix * | |
| 390 | − sizeof(struct qlcnic_intrpt_config)); | |
| 389 | + ahw->intr_tbl = | |
| 390 | + vzalloc(array_size(num_msix, | |
| 391 | + sizeof(struct qlcnic_intrpt_config))); | |
| 391 | 392 | if (!ahw->intr_tbl) |
| 392 | 393 | return -ENOMEM; |
| 393 | 394 | |
| @@ -916,8 +916,9 @@ int qlcnic_82xx_mq_intrpt(struct qlcnic_adapter *adapter, int op_type) · 915 unmodified lines | ||
| 916 | 916 | if (qlcnic_check_multi_tx(adapter) && |
| 917 | 917 | !ahw->diag_test && |
| 918 | 918 | (adapter->flags & QLCNIC_MSIX_ENABLED)) { |
| 919 | − ahw->intr_tbl = vzalloc(ahw->num_msix * | |
| 920 | − sizeof(struct qlcnic_intrpt_config)); | |
| 919 | + ahw->intr_tbl = | |
| 920 | + vzalloc(array_size(sizeof(struct qlcnic_intrpt_config), | |
| 921 | + ahw->num_msix)); | |
| 921 | 922 | if (!ahw->intr_tbl) |
| 922 | 923 | return -ENOMEM; |
| 923 | 924 | |
| @@ -1025,15 +1026,17 @@ int qlcnic_init_pci_info(struct qlcnic_adapter *adapter) · 101 unmodified lines | ||
| 1025 | 1026 | |
| 1026 | 1027 | act_pci_func = ahw->total_nic_func; |
| 1027 | 1028 | |
| 1028 | − adapter->npars = kzalloc(sizeof(struct qlcnic_npar_info) * | |
| 1029 | − act_pci_func, GFP_KERNEL); | |
| 1029 | + adapter->npars = kcalloc(act_pci_func, | |
| 1030 | + sizeof(struct qlcnic_npar_info), | |
| 1031 | + GFP_KERNEL); | |
| 1030 | 1032 | if (!adapter->npars) { |
| 1031 | 1033 | ret = -ENOMEM; |
| 1032 | 1034 | goto err_pci_info; |
| 1033 | 1035 | } |
| 1034 | 1036 | |
| 1035 | − adapter->eswitch = kzalloc(sizeof(struct qlcnic_eswitch) * | |
| 1036 | − QLCNIC_NIU_MAX_XG_PORTS, GFP_KERNEL); | |
| 1037 | + adapter->eswitch = kcalloc(QLCNIC_NIU_MAX_XG_PORTS, | |
| 1038 | + sizeof(struct qlcnic_eswitch), | |
| 1039 | + GFP_KERNEL); | |
| 1037 | 1040 | if (!adapter->eswitch) { |
| 1038 | 1041 | ret = -ENOMEM; |
| 1039 | 1042 | goto err_npars; |
| @@ -157,8 +157,8 @@ int qlcnic_sriov_init(struct qlcnic_adapter *adapter, int num_vfs) · 156 unmodified lines | ||
| 157 | 157 | adapter->ahw->sriov = sriov; |
| 158 | 158 | sriov->num_vfs = num_vfs; |
| 159 | 159 | bc = &sriov->bc; |
| 160 | − sriov->vf_info = kzalloc(sizeof(struct qlcnic_vf_info) * | |
| 161 | − num_vfs, GFP_KERNEL); | |
| 160 | + sriov->vf_info = kcalloc(num_vfs, sizeof(struct qlcnic_vf_info), | |
| 161 | + GFP_KERNEL); | |
| 162 | 162 | if (!sriov->vf_info) { |
| 163 | 163 | err = -ENOMEM; |
| 164 | 164 | goto qlcnic_free_sriov; |
| @@ -450,7 +450,7 @@ static int qlcnic_sriov_set_guest_vlan_mode(struct qlcnic_adapter *adapter, · 285 unmodified lines | ||
| 450 | 450 | return 0; |
| 451 | 451 | |
| 452 | 452 | num_vlans = sriov->num_allowed_vlans; |
| 453 | − sriov->allowed_vlans = kzalloc(sizeof(u16) * num_vlans, GFP_KERNEL); | |
| 453 | + sriov->allowed_vlans = kcalloc(num_vlans, sizeof(u16), GFP_KERNEL); | |
| 454 | 454 | if (!sriov->allowed_vlans) |
| 455 | 455 | return -ENOMEM; |
| 456 | 456 | |
| @@ -706,7 +706,7 @@ static inline int qlcnic_sriov_alloc_bc_trans(struct qlcnic_bc_trans **trans) · 249 unmodified lines | ||
| 706 | 706 | static inline int qlcnic_sriov_alloc_bc_msg(struct qlcnic_bc_hdr **hdr, |
| 707 | 707 | u32 size) |
| 708 | 708 | { |
| 709 | − *hdr = kzalloc(sizeof(struct qlcnic_bc_hdr) * size, GFP_ATOMIC); | |
| 709 | + *hdr = kcalloc(size, sizeof(struct qlcnic_bc_hdr), GFP_ATOMIC); | |
| 710 | 710 | if (!*hdr) |
| 711 | 711 | return -ENOMEM; |
| 712 | 712 | |
| @@ -2810,7 +2810,8 @@ static int ql_alloc_tx_resources(struct ql_adapter *qdev, · 2809 unmodified lines | ||
| 2810 | 2810 | goto pci_alloc_err; |
| 2811 | 2811 | |
| 2812 | 2812 | tx_ring->q = |
| 2813 | − kmalloc(tx_ring->wq_len * sizeof(struct tx_ring_desc), GFP_KERNEL); | |
| 2813 | + kmalloc_array(tx_ring->wq_len, sizeof(struct tx_ring_desc), | |
| 2814 | + GFP_KERNEL); | |
| 2814 | 2815 | if (tx_ring->q == NULL) |
| 2815 | 2816 | goto err; |
| 2816 | 2817 | |
| @@ -4984,7 +4984,8 @@ static int efx_ef10_filter_table_probe(struct efx_nic *efx) · 4983 unmodified lines | ||
| 4984 | 4984 | net_dev->hw_features &= ~NETIF_F_HW_VLAN_CTAG_FILTER; |
| 4985 | 4985 | } |
| 4986 | 4986 | |
| 4987 | − table->entry = vzalloc(HUNT_FILTER_TBL_ROWS * sizeof(*table->entry)); | |
| 4987 | + table->entry = vzalloc(array_size(HUNT_FILTER_TBL_ROWS, | |
| 4988 | + sizeof(*table->entry))); | |
| 4988 | 4989 | if (!table->entry) { |
| 4989 | 4990 | rc = -ENOMEM; |
| 4990 | 4991 | goto fail; |
| @@ -2755,7 +2755,8 @@ int ef4_farch_filter_table_probe(struct ef4_nic *efx) · 2754 unmodified lines | ||
| 2755 | 2755 | GFP_KERNEL); |
| 2756 | 2756 | if (!table->used_bitmap) |
| 2757 | 2757 | goto fail; |
| 2758 | − table->spec = vzalloc(table->size * sizeof(*table->spec)); | |
| 2758 | + table->spec = vzalloc(array_size(sizeof(*table->spec), | |
| 2759 | + table->size)); | |
| 2759 | 2760 | if (!table->spec) |
| 2760 | 2761 | goto fail; |
| 2761 | 2762 | } |
| @@ -2826,7 +2826,8 @@ int efx_farch_filter_table_probe(struct efx_nic *efx) · 2825 unmodified lines | ||
| 2826 | 2826 | GFP_KERNEL); |
| 2827 | 2827 | if (!table->used_bitmap) |
| 2828 | 2828 | goto fail; |
| 2829 | − table->spec = vzalloc(table->size * sizeof(*table->spec)); | |
| 2829 | + table->spec = vzalloc(array_size(sizeof(*table->spec), | |
| 2830 | + table->size)); | |
| 2830 | 2831 | if (!table->spec) |
| 2831 | 2832 | goto fail; |
| 2832 | 2833 | } |
| @@ -973,7 +973,7 @@ static int netsec_alloc_dring(struct netsec_priv *priv, enum ring_id id) · 972 unmodified lines | ||
| 973 | 973 | goto err; |
| 974 | 974 | } |
| 975 | 975 | |
| 976 | − dring->desc = kzalloc(DESC_NUM * sizeof(*dring->desc), GFP_KERNEL); | |
| 976 | + dring->desc = kcalloc(DESC_NUM, sizeof(*dring->desc), GFP_KERNEL); | |
| 977 | 977 | if (!dring->desc) { |
| 978 | 978 | ret = -ENOMEM; |
| 979 | 979 | goto err; |
| @@ -277,8 +277,8 @@ static int tc_init(struct stmmac_priv *priv) · 276 unmodified lines | ||
| 277 | 277 | |
| 278 | 278 | /* Reserve one last filter which lets all pass */ |
| 279 | 279 | priv->tc_entries_max = count; |
| 280 | − priv->tc_entries = devm_kzalloc(priv->device, | |
| 281 | − sizeof(*priv->tc_entries) * count, GFP_KERNEL); | |
| 280 | + priv->tc_entries = devm_kcalloc(priv->device, | |
| 281 | + count, sizeof(*priv->tc_entries), GFP_KERNEL); | |
| 282 | 282 | if (!priv->tc_entries) |
| 283 | 283 | return -ENOMEM; |
| 284 | 284 | |
| @@ -2740,8 +2740,9 @@ static int cpsw_probe_dt(struct cpsw_platform_data *data, · 2739 unmodified lines | ||
| 2740 | 2740 | } |
| 2741 | 2741 | data->active_slave = prop; |
| 2742 | 2742 | |
| 2743 | − data->slave_data = devm_kzalloc(&pdev->dev, data->slaves | |
| 2744 | − * sizeof(struct cpsw_slave_data), | |
| 2743 | + data->slave_data = devm_kcalloc(&pdev->dev, | |
| 2744 | + data->slaves, | |
| 2745 | + sizeof(struct cpsw_slave_data), | |
| 2745 | 2746 | GFP_KERNEL); |
| 2746 | 2747 | if (!data->slave_data) |
| 2747 | 2748 | return -ENOMEM; |
| @@ -3045,8 +3046,8 @@ static int cpsw_probe(struct platform_device *pdev) · 297 unmodified lines | ||
| 3045 | 3046 | |
| 3046 | 3047 | memcpy(ndev->dev_addr, priv->mac_addr, ETH_ALEN); |
| 3047 | 3048 | |
| 3048 | − cpsw->slaves = devm_kzalloc(&pdev->dev, | |
| 3049 | − sizeof(struct cpsw_slave) * data->slaves, | |
| 3049 | + cpsw->slaves = devm_kcalloc(&pdev->dev, | |
| 3050 | + data->slaves, sizeof(struct cpsw_slave), | |
| 3050 | 3051 | GFP_KERNEL); |
| 3051 | 3052 | if (!cpsw->slaves) { |
| 3052 | 3053 | ret = -ENOMEM; |
| @@ -3285,8 +3285,8 @@ static int set_xgbe_ethss10_priv(struct gbe_priv *gbe_dev, · 3284 unmodified lines | ||
| 3285 | 3285 | gbe_dev->et_stats = xgbe10_et_stats; |
| 3286 | 3286 | gbe_dev->num_et_stats = ARRAY_SIZE(xgbe10_et_stats); |
| 3287 | 3287 | |
| 3288 | − gbe_dev->hw_stats = devm_kzalloc(gbe_dev->dev, | |
| 3289 | − gbe_dev->num_et_stats * sizeof(u64), | |
| 3288 | + gbe_dev->hw_stats = devm_kcalloc(gbe_dev->dev, | |
| 3289 | + gbe_dev->num_et_stats, sizeof(u64), | |
| 3290 | 3290 | GFP_KERNEL); |
| 3291 | 3291 | if (!gbe_dev->hw_stats) { |
| 3292 | 3292 | dev_err(gbe_dev->dev, "hw_stats memory allocation failed\n"); |
| @@ -3294,8 +3294,8 @@ static int set_xgbe_ethss10_priv(struct gbe_priv *gbe_dev, · 1 unmodified line | ||
| 3294 | 3294 | } |
| 3295 | 3295 | |
| 3296 | 3296 | gbe_dev->hw_stats_prev = |
| 3297 | − devm_kzalloc(gbe_dev->dev, | |
| 3298 | − gbe_dev->num_et_stats * sizeof(u32), | |
| 3297 | + devm_kcalloc(gbe_dev->dev, | |
| 3298 | + gbe_dev->num_et_stats, sizeof(u32), | |
| 3299 | 3299 | GFP_KERNEL); |
| 3300 | 3300 | if (!gbe_dev->hw_stats_prev) { |
| 3301 | 3301 | dev_err(gbe_dev->dev, |
| @@ -3405,8 +3405,8 @@ static int set_gbe_ethss14_priv(struct gbe_priv *gbe_dev, · 103 unmodified lines | ||
| 3405 | 3405 | gbe_dev->et_stats = gbe13_et_stats; |
| 3406 | 3406 | gbe_dev->num_et_stats = ARRAY_SIZE(gbe13_et_stats); |
| 3407 | 3407 | |
| 3408 | − gbe_dev->hw_stats = devm_kzalloc(gbe_dev->dev, | |
| 3409 | − gbe_dev->num_et_stats * sizeof(u64), | |
| 3408 | + gbe_dev->hw_stats = devm_kcalloc(gbe_dev->dev, | |
| 3409 | + gbe_dev->num_et_stats, sizeof(u64), | |
| 3410 | 3410 | GFP_KERNEL); |
| 3411 | 3411 | if (!gbe_dev->hw_stats) { |
| 3412 | 3412 | dev_err(gbe_dev->dev, "hw_stats memory allocation failed\n"); |
| @@ -3414,8 +3414,8 @@ static int set_gbe_ethss14_priv(struct gbe_priv *gbe_dev, · 1 unmodified line | ||
| 3414 | 3414 | } |
| 3415 | 3415 | |
| 3416 | 3416 | gbe_dev->hw_stats_prev = |
| 3417 | − devm_kzalloc(gbe_dev->dev, | |
| 3418 | − gbe_dev->num_et_stats * sizeof(u32), | |
| 3417 | + devm_kcalloc(gbe_dev->dev, | |
| 3418 | + gbe_dev->num_et_stats, sizeof(u32), | |
| 3419 | 3419 | GFP_KERNEL); |
| 3420 | 3420 | if (!gbe_dev->hw_stats_prev) { |
| 3421 | 3421 | dev_err(gbe_dev->dev, |
| @@ -3477,8 +3477,8 @@ static int set_gbenu_ethss_priv(struct gbe_priv *gbe_dev, · 55 unmodified lines | ||
| 3477 | 3477 | gbe_dev->num_et_stats = GBENU_ET_STATS_HOST_SIZE + |
| 3478 | 3478 | GBENU_ET_STATS_PORT_SIZE; |
| 3479 | 3479 | |
| 3480 | − gbe_dev->hw_stats = devm_kzalloc(gbe_dev->dev, | |
| 3481 | − gbe_dev->num_et_stats * sizeof(u64), | |
| 3480 | + gbe_dev->hw_stats = devm_kcalloc(gbe_dev->dev, | |
| 3481 | + gbe_dev->num_et_stats, sizeof(u64), | |
| 3482 | 3482 | GFP_KERNEL); |
| 3483 | 3483 | if (!gbe_dev->hw_stats) { |
| 3484 | 3484 | dev_err(gbe_dev->dev, "hw_stats memory allocation failed\n"); |
| @@ -3486,8 +3486,8 @@ static int set_gbenu_ethss_priv(struct gbe_priv *gbe_dev, · 1 unmodified line | ||
| 3486 | 3486 | } |
| 3487 | 3487 | |
| 3488 | 3488 | gbe_dev->hw_stats_prev = |
| 3489 | − devm_kzalloc(gbe_dev->dev, | |
| 3490 | − gbe_dev->num_et_stats * sizeof(u32), | |
| 3489 | + devm_kcalloc(gbe_dev->dev, | |
| 3490 | + gbe_dev->num_et_stats, sizeof(u32), | |
| 3491 | 3491 | GFP_KERNEL); |
| 3492 | 3492 | if (!gbe_dev->hw_stats_prev) { |
| 3493 | 3493 | dev_err(gbe_dev->dev, |
| @@ -2320,8 +2320,9 @@ static struct net_device *gelic_wl_alloc(struct gelic_card *card) · 2319 unmodified lines | ||
| 2320 | 2320 | pr_debug("%s: wl=%p port=%p\n", __func__, wl, port); |
| 2321 | 2321 | |
| 2322 | 2322 | /* allocate scan list */ |
| 2323 | − wl->networks = kzalloc(sizeof(struct gelic_wl_scan_info) * | |
| 2324 | − GELIC_WL_BSS_MAX_ENT, GFP_KERNEL); | |
| 2323 | + wl->networks = kcalloc(GELIC_WL_BSS_MAX_ENT, | |
| 2324 | + sizeof(struct gelic_wl_scan_info), | |
| 2325 | + GFP_KERNEL); | |
| 2325 | 2326 | |
| 2326 | 2327 | if (!wl->networks) |
| 2327 | 2328 | goto fail_bss; |
| @@ -742,11 +742,13 @@ static int gtp_hashtable_new(struct gtp_dev *gtp, int hsize) · 741 unmodified lines | ||
| 742 | 742 | { |
| 743 | 743 | int i; |
| 744 | 744 | |
| 745 | − gtp->addr_hash = kmalloc(sizeof(struct hlist_head) * hsize, GFP_KERNEL); | |
| 745 | + gtp->addr_hash = kmalloc_array(hsize, sizeof(struct hlist_head), | |
| 746 | + GFP_KERNEL); | |
| 746 | 747 | if (gtp->addr_hash == NULL) |
| 747 | 748 | return -ENOMEM; |
| 748 | 749 | |
| 749 | − gtp->tid_hash = kmalloc(sizeof(struct hlist_head) * hsize, GFP_KERNEL); | |
| 750 | + gtp->tid_hash = kmalloc_array(hsize, sizeof(struct hlist_head), | |
| 751 | + GFP_KERNEL); | |
| 750 | 752 | if (gtp->tid_hash == NULL) |
| 751 | 753 | goto err1; |
| 752 | 754 | |
| @@ -1583,7 +1583,7 @@ static int rr_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) · 1582 unmodified lines | ||
| 1583 | 1583 | return -EPERM; |
| 1584 | 1584 | } |
| 1585 | 1585 | |
| 1586 | − image = kmalloc(EEPROM_WORDS * sizeof(u32), GFP_KERNEL); | |
| 1586 | + image = kmalloc_array(EEPROM_WORDS, sizeof(u32), GFP_KERNEL); | |
| 1587 | 1587 | if (!image) |
| 1588 | 1588 | return -ENOMEM; |
| 1589 | 1589 | |
| @@ -1097,8 +1097,9 @@ static struct dp83640_clock *dp83640_clock_get_bus(struct mii_bus *bus) · 1096 unmodified lines | ||
| 1097 | 1097 | if (!clock) |
| 1098 | 1098 | goto out; |
| 1099 | 1099 | |
| 1100 | − clock->caps.pin_config = kzalloc(sizeof(struct ptp_pin_desc) * | |
| 1101 | − DP83640_N_PINS, GFP_KERNEL); | |
| 1100 | + clock->caps.pin_config = kcalloc(DP83640_N_PINS, | |
| 1101 | + sizeof(struct ptp_pin_desc), | |
| 1102 | + GFP_KERNEL); | |
| 1102 | 1103 | if (!clock->caps.pin_config) { |
| 1103 | 1104 | kfree(clock); |
| 1104 | 1105 | clock = NULL; |
| @@ -128,9 +128,9 @@ int phy_led_triggers_register(struct phy_device *phy) · 127 unmodified lines | ||
| 128 | 128 | if (err) |
| 129 | 129 | goto out_free_link; |
| 130 | 130 | |
| 131 | − phy->phy_led_triggers = devm_kzalloc(&phy->mdio.dev, | |
| 132 | − sizeof(struct phy_led_trigger) * | |
| 133 | − phy->phy_num_led_triggers, | |
| 131 | + phy->phy_led_triggers = devm_kcalloc(&phy->mdio.dev, | |
| 132 | + phy->phy_num_led_triggers, | |
| 133 | + sizeof(struct phy_led_trigger), | |
| 134 | 134 | GFP_KERNEL); |
| 135 | 135 | if (!phy->phy_led_triggers) { |
| 136 | 136 | err = -ENOMEM; |
| @@ -406,7 +406,7 @@ static void *bsd_alloc (unsigned char *options, int opt_len, int decomp) · 405 unmodified lines | ||
| 406 | 406 | * Allocate space for the dictionary. This may be more than one page in |
| 407 | 407 | * length. |
| 408 | 408 | */ |
| 409 | − db->dict = vmalloc(hsize * sizeof(struct bsd_dict)); | |
| 409 | + db->dict = vmalloc(array_size(hsize, sizeof(struct bsd_dict))); | |
| 410 | 410 | if (!db->dict) |
| 411 | 411 | { |
| 412 | 412 | bsd_free (db); |
| @@ -425,7 +425,7 @@ static void *bsd_alloc (unsigned char *options, int opt_len, int decomp) · 12 unmodified lines | ||
| 425 | 425 | */ |
| 426 | 426 | else |
| 427 | 427 | { |
| 428 | − db->lens = vmalloc((maxmaxcode + 1) * sizeof(db->lens[0])); | |
| 428 | + db->lens = vmalloc(array_size(sizeof(db->lens[0]), (maxmaxcode + 1))); | |
| 429 | 429 | if (!db->lens) |
| 430 | 430 | { |
| 431 | 431 | bsd_free (db); |
| @@ -648,7 +648,7 @@ static int __init pptp_init_module(void) · 647 unmodified lines | ||
| 648 | 648 | int err = 0; |
| 649 | 649 | pr_info("PPTP driver version " PPTP_DRIVER_VERSION "\n"); |
| 650 | 650 | |
| 651 | − callid_sock = vzalloc((MAX_CALLID + 1) * sizeof(void *)); | |
| 651 | + callid_sock = vzalloc(array_size(sizeof(void *), (MAX_CALLID + 1))); | |
| 652 | 652 | if (!callid_sock) |
| 653 | 653 | return -ENOMEM; |
| 654 | 654 | |
| @@ -1307,7 +1307,7 @@ static int __init slip_init(void) · 1306 unmodified lines | ||
| 1307 | 1307 | printk(KERN_INFO "SLIP linefill/keepalive option.\n"); |
| 1308 | 1308 | #endif |
| 1309 | 1309 | |
| 1310 | − slip_devs = kzalloc(sizeof(struct net_device *)*slip_maxdev, | |
| 1310 | + slip_devs = kcalloc(slip_maxdev, sizeof(struct net_device *), | |
| 1311 | 1311 | GFP_KERNEL); |
| 1312 | 1312 | if (!slip_devs) |
| 1313 | 1313 | return -ENOMEM; |
| @@ -280,7 +280,7 @@ static int __team_options_register(struct team *team, · 279 unmodified lines | ||
| 280 | 280 | struct team_option **dst_opts; |
| 281 | 281 | int err; |
| 282 | 282 | |
| 283 | − dst_opts = kzalloc(sizeof(struct team_option *) * option_count, | |
| 283 | + dst_opts = kcalloc(option_count, sizeof(struct team_option *), | |
| 284 | 284 | GFP_KERNEL); |
| 285 | 285 | if (!dst_opts) |
| 286 | 286 | return -ENOMEM; |
| @@ -791,7 +791,8 @@ static int team_queue_override_init(struct team *team) · 504 unmodified lines | ||
| 791 | 791 | |
| 792 | 792 | if (!queue_cnt) |
| 793 | 793 | return 0; |
| 794 | − listarr = kmalloc(sizeof(struct list_head) * queue_cnt, GFP_KERNEL); | |
| 794 | + listarr = kmalloc_array(queue_cnt, sizeof(struct list_head), | |
| 795 | + GFP_KERNEL); | |
| 795 | 796 | if (!listarr) |
| 796 | 797 | return -ENOMEM; |
| 797 | 798 | team->qom_lists = listarr; |
| @@ -640,8 +640,8 @@ int asix_get_eeprom(struct net_device *net, struct ethtool_eeprom *eeprom, · 639 unmodified lines | ||
| 640 | 640 | first_word = eeprom->offset >> 1; |
| 641 | 641 | last_word = (eeprom->offset + eeprom->len - 1) >> 1; |
| 642 | 642 | |
| 643 | − eeprom_buff = kmalloc(sizeof(u16) * (last_word - first_word + 1), | |
| 644 | − GFP_KERNEL); | |
| 643 | + eeprom_buff = kmalloc_array(last_word - first_word + 1, sizeof(u16), | |
| 644 | + GFP_KERNEL); | |
| 645 | 645 | if (!eeprom_buff) |
| 646 | 646 | return -ENOMEM; |
| 647 | 647 | |
| @@ -680,8 +680,8 @@ int asix_set_eeprom(struct net_device *net, struct ethtool_eeprom *eeprom, · 32 unmodified lines | ||
| 680 | 680 | first_word = eeprom->offset >> 1; |
| 681 | 681 | last_word = (eeprom->offset + eeprom->len - 1) >> 1; |
| 682 | 682 | |
| 683 | − eeprom_buff = kmalloc(sizeof(u16) * (last_word - first_word + 1), | |
| 684 | − GFP_KERNEL); | |
| 683 | + eeprom_buff = kmalloc_array(last_word - first_word + 1, sizeof(u16), | |
| 684 | + GFP_KERNEL); | |
| 685 | 685 | if (!eeprom_buff) |
| 686 | 686 | return -ENOMEM; |
| 687 | 687 | |
| @@ -599,8 +599,8 @@ ax88179_get_eeprom(struct net_device *net, struct ethtool_eeprom *eeprom, · 598 unmodified lines | ||
| 599 | 599 | |
| 600 | 600 | first_word = eeprom->offset >> 1; |
| 601 | 601 | last_word = (eeprom->offset + eeprom->len - 1) >> 1; |
| 602 | − eeprom_buff = kmalloc(sizeof(u16) * (last_word - first_word + 1), | |
| 603 | − GFP_KERNEL); | |
| 602 | + eeprom_buff = kmalloc_array(last_word - first_word + 1, sizeof(u16), | |
| 603 | + GFP_KERNEL); | |
| 604 | 604 | if (!eeprom_buff) |
| 605 | 605 | return -ENOMEM; |
| 606 | 606 | |
| @@ -1661,7 +1661,7 @@ static int smsc95xx_suspend(struct usb_interface *intf, pm_message_t message) · 1660 unmodified lines | ||
| 1661 | 1661 | } |
| 1662 | 1662 | |
| 1663 | 1663 | if (pdata->wolopts & (WAKE_BCAST | WAKE_MCAST | WAKE_ARP | WAKE_UCAST)) { |
| 1664 | − u32 *filter_mask = kzalloc(sizeof(u32) * 32, GFP_KERNEL); | |
| 1664 | + u32 *filter_mask = kcalloc(32, sizeof(u32), GFP_KERNEL); | |
| 1665 | 1665 | u32 command[2]; |
| 1666 | 1666 | u32 offset[2]; |
| 1667 | 1667 | u32 crc[4]; |
| @@ -1323,8 +1323,8 @@ static int build_dma_sg(const struct sk_buff *skb, struct urb *urb) · 1322 unmodified lines | ||
| 1323 | 1323 | return 0; |
| 1324 | 1324 | |
| 1325 | 1325 | /* reserve one for zero packet */ |
| 1326 | − urb->sg = kmalloc((num_sgs + 1) * sizeof(struct scatterlist), | |
| 1327 | − GFP_ATOMIC); | |
| 1326 | + urb->sg = kmalloc_array(num_sgs + 1, sizeof(struct scatterlist), | |
| 1327 | + GFP_ATOMIC); | |
| 1328 | 1328 | if (!urb->sg) |
| 1329 | 1329 | return -ENOMEM; |
| 1330 | 1330 | |
| @@ -2552,17 +2552,17 @@ static int virtnet_find_vqs(struct virtnet_info *vi) · 2551 unmodified lines | ||
| 2552 | 2552 | virtio_has_feature(vi->vdev, VIRTIO_NET_F_CTRL_VQ); |
| 2553 | 2553 | |
| 2554 | 2554 | /* Allocate space for find_vqs parameters */ |
| 2555 | − vqs = kzalloc(total_vqs * sizeof(*vqs), GFP_KERNEL); | |
| 2555 | + vqs = kcalloc(total_vqs, sizeof(*vqs), GFP_KERNEL); | |
| 2556 | 2556 | if (!vqs) |
| 2557 | 2557 | goto err_vq; |
| 2558 | − callbacks = kmalloc(total_vqs * sizeof(*callbacks), GFP_KERNEL); | |
| 2558 | + callbacks = kmalloc_array(total_vqs, sizeof(*callbacks), GFP_KERNEL); | |
| 2559 | 2559 | if (!callbacks) |
| 2560 | 2560 | goto err_callback; |
| 2561 | − names = kmalloc(total_vqs * sizeof(*names), GFP_KERNEL); | |
| 2561 | + names = kmalloc_array(total_vqs, sizeof(*names), GFP_KERNEL); | |
| 2562 | 2562 | if (!names) |
| 2563 | 2563 | goto err_names; |
| 2564 | 2564 | if (!vi->big_packets || vi->mergeable_rx_bufs) { |
| 2565 | − ctx = kzalloc(total_vqs * sizeof(*ctx), GFP_KERNEL); | |
| 2565 | + ctx = kcalloc(total_vqs, sizeof(*ctx), GFP_KERNEL); | |
| 2566 | 2566 | if (!ctx) |
| 2567 | 2567 | goto err_ctx; |
| 2568 | 2568 | } else { |
| @@ -2626,10 +2626,10 @@ static int virtnet_alloc_queues(struct virtnet_info *vi) · 57 unmodified lines | ||
| 2626 | 2626 | vi->ctrl = kzalloc(sizeof(*vi->ctrl), GFP_KERNEL); |
| 2627 | 2627 | if (!vi->ctrl) |
| 2628 | 2628 | goto err_ctrl; |
| 2629 | − vi->sq = kzalloc(sizeof(*vi->sq) * vi->max_queue_pairs, GFP_KERNEL); | |
| 2629 | + vi->sq = kcalloc(vi->max_queue_pairs, sizeof(*vi->sq), GFP_KERNEL); | |
| 2630 | 2630 | if (!vi->sq) |
| 2631 | 2631 | goto err_sq; |
| 2632 | − vi->rq = kzalloc(sizeof(*vi->rq) * vi->max_queue_pairs, GFP_KERNEL); | |
| 2632 | + vi->rq = kcalloc(vi->max_queue_pairs, sizeof(*vi->rq), GFP_KERNEL); | |
| 2633 | 2633 | if (!vi->rq) |
| 2634 | 2634 | goto err_rq; |
| 2635 | 2635 | |
| @@ -198,12 +198,14 @@ static int uhdlc_init(struct ucc_hdlc_private *priv) · 197 unmodified lines | ||
| 198 | 198 | goto free_tx_bd; |
| 199 | 199 | } |
| 200 | 200 | |
| 201 | − priv->rx_skbuff = kzalloc(priv->rx_ring_size * sizeof(*priv->rx_skbuff), | |
| 201 | + priv->rx_skbuff = kcalloc(priv->rx_ring_size, | |
| 202 | + sizeof(*priv->rx_skbuff), | |
| 202 | 203 | GFP_KERNEL); |
| 203 | 204 | if (!priv->rx_skbuff) |
| 204 | 205 | goto free_ucc_pram; |
| 205 | 206 | |
| 206 | − priv->tx_skbuff = kzalloc(priv->tx_ring_size * sizeof(*priv->tx_skbuff), | |
| 207 | + priv->tx_skbuff = kcalloc(priv->tx_ring_size, | |
| 208 | + sizeof(*priv->tx_skbuff), | |
| 207 | 209 | GFP_KERNEL); |
| 208 | 210 | if (!priv->tx_skbuff) |
| 209 | 211 | goto free_rx_skbuff; |
| @@ -582,7 +582,7 @@ int ath10k_htt_rx_alloc(struct ath10k_htt *htt) · 581 unmodified lines | ||
| 582 | 582 | } |
| 583 | 583 | |
| 584 | 584 | htt->rx_ring.netbufs_ring = |
| 585 | − kzalloc(htt->rx_ring.size * sizeof(struct sk_buff *), | |
| 585 | + kcalloc(htt->rx_ring.size, sizeof(struct sk_buff *), | |
| 586 | 586 | GFP_KERNEL); |
| 587 | 587 | if (!htt->rx_ring.netbufs_ring) |
| 588 | 588 | goto err_netbuf; |
| @@ -155,7 +155,7 @@ ath10k_wmi_tlv_parse_alloc(struct ath10k *ar, const void *ptr, · 154 unmodified lines | ||
| 155 | 155 | const void **tb; |
| 156 | 156 | int ret; |
| 157 | 157 | |
| 158 | − tb = kzalloc(sizeof(*tb) * WMI_TLV_TAG_MAX, gfp); | |
| 158 | + tb = kcalloc(WMI_TLV_TAG_MAX, sizeof(*tb), gfp); | |
| 159 | 159 | if (!tb) |
| 160 | 160 | return ERR_PTR(-ENOMEM); |
| 161 | 161 | |
| @@ -931,7 +931,7 @@ static int open_file_eeprom(struct inode *inode, struct file *file) · 930 unmodified lines | ||
| 931 | 931 | |
| 932 | 932 | /* Create buffer and read in eeprom */ |
| 933 | 933 | |
| 934 | − buf = vmalloc(eesize * 2); | |
| 934 | + buf = vmalloc(array_size(eesize, 2)); | |
| 935 | 935 | if (!buf) { |
| 936 | 936 | ret = -ENOMEM; |
| 937 | 937 | goto err; |
| @@ -890,7 +890,8 @@ ath5k_hw_rfregs_init(struct ath5k_hw *ah, · 889 unmodified lines | ||
| 890 | 890 | * ah->ah_rf_banks based on ah->ah_rf_banks_size |
| 891 | 891 | * we set above */ |
| 892 | 892 | if (ah->ah_rf_banks == NULL) { |
| 893 | − ah->ah_rf_banks = kmalloc(sizeof(u32) * ah->ah_rf_banks_size, | |
| 893 | + ah->ah_rf_banks = kmalloc_array(ah->ah_rf_banks_size, | |
| 894 | + sizeof(u32), | |
| 894 | 895 | GFP_KERNEL); |
| 895 | 896 | if (ah->ah_rf_banks == NULL) { |
| 896 | 897 | ATH5K_ERR(ah, "out of memory\n"); |
| @@ -1041,7 +1041,7 @@ static int ath6kl_cfg80211_scan(struct wiphy *wiphy, · 1040 unmodified lines | ||
| 1041 | 1041 | |
| 1042 | 1042 | n_channels = request->n_channels; |
| 1043 | 1043 | |
| 1044 | − channels = kzalloc(n_channels * sizeof(u16), GFP_KERNEL); | |
| 1044 | + channels = kcalloc(n_channels, sizeof(u16), GFP_KERNEL); | |
| 1045 | 1045 | if (channels == NULL) { |
| 1046 | 1046 | ath6kl_warn("failed to set scan channels, scan all channels"); |
| 1047 | 1047 | n_channels = 0; |
| @@ -925,7 +925,7 @@ int ar9003_paprd_create_curve(struct ath_hw *ah, · 924 unmodified lines | ||
| 925 | 925 | |
| 926 | 926 | memset(caldata->pa_table[chain], 0, sizeof(caldata->pa_table[chain])); |
| 927 | 927 | |
| 928 | − buf = kmalloc(2 * 48 * sizeof(u32), GFP_KERNEL); | |
| 928 | + buf = kmalloc_array(2 * 48, sizeof(u32), GFP_KERNEL); | |
| 929 | 929 | if (!buf) |
| 930 | 930 | return -ENOMEM; |
| 931 | 931 | |
| @@ -127,13 +127,13 @@ void ath9k_hw_read_array(struct ath_hw *ah, u32 array[][2], int size) · 126 unmodified lines | ||
| 127 | 127 | u32 *tmp_reg_list, *tmp_data; |
| 128 | 128 | int i; |
| 129 | 129 | |
| 130 | − tmp_reg_list = kmalloc(size * sizeof(u32), GFP_KERNEL); | |
| 130 | + tmp_reg_list = kmalloc_array(size, sizeof(u32), GFP_KERNEL); | |
| 131 | 131 | if (!tmp_reg_list) { |
| 132 | 132 | dev_err(ah->dev, "%s: tmp_reg_list: alloc filed\n", __func__); |
| 133 | 133 | return; |
| 134 | 134 | } |
| 135 | 135 | |
| 136 | − tmp_data = kmalloc(size * sizeof(u32), GFP_KERNEL); | |
| 136 | + tmp_data = kmalloc_array(size, sizeof(u32), GFP_KERNEL); | |
| 137 | 137 | if (!tmp_data) { |
| 138 | 138 | dev_err(ah->dev, "%s tmp_data: alloc filed\n", __func__); |
| 139 | 139 | goto error_tmp_data; |
| @@ -1958,7 +1958,7 @@ static int carl9170_parse_eeprom(struct ar9170 *ar) · 1957 unmodified lines | ||
| 1958 | 1958 | if (!bands) |
| 1959 | 1959 | return -EINVAL; |
| 1960 | 1960 | |
| 1961 | − ar->survey = kzalloc(sizeof(struct survey_info) * chans, GFP_KERNEL); | |
| 1961 | + ar->survey = kcalloc(chans, sizeof(struct survey_info), GFP_KERNEL); | |
| 1962 | 1962 | if (!ar->survey) |
| 1963 | 1963 | return -ENOMEM; |
| 1964 | 1964 | ar->num_channels = chans; |
| @@ -1988,8 +1988,9 @@ int carl9170_register(struct ar9170 *ar) · 23 unmodified lines | ||
| 1988 | 1988 | if (WARN_ON(ar->mem_bitmap)) |
| 1989 | 1989 | return -EINVAL; |
| 1990 | 1990 | |
| 1991 | − ar->mem_bitmap = kzalloc(roundup(ar->fw.mem_blocks, BITS_PER_LONG) * | |
| 1992 | − sizeof(unsigned long), GFP_KERNEL); | |
| 1991 | + ar->mem_bitmap = kcalloc(roundup(ar->fw.mem_blocks, BITS_PER_LONG), | |
| 1992 | + sizeof(unsigned long), | |
| 1993 | + GFP_KERNEL); | |
| 1993 | 1994 | |
| 1994 | 1995 | if (!ar->mem_bitmap) |
| 1995 | 1996 | return -ENOMEM; |
| @@ -1518,7 +1518,7 @@ static int b43_nphy_load_samples(struct b43_wldev *dev, · 1517 unmodified lines | ||
| 1518 | 1518 | u16 i; |
| 1519 | 1519 | u32 *data; |
| 1520 | 1520 | |
| 1521 | − data = kzalloc(len * sizeof(u32), GFP_KERNEL); | |
| 1521 | + data = kcalloc(len, sizeof(u32), GFP_KERNEL); | |
| 1522 | 1522 | if (!data) { |
| 1523 | 1523 | b43err(dev->wl, "allocation for samples loading failed\n"); |
| 1524 | 1524 | return -ENOMEM; |
| @@ -3300,8 +3300,8 @@ static int b43legacy_wireless_core_init(struct b43legacy_wldev *dev) · 3299 unmodified lines | ||
| 3300 | 3300 | |
| 3301 | 3301 | if ((phy->type == B43legacy_PHYTYPE_B) || |
| 3302 | 3302 | (phy->type == B43legacy_PHYTYPE_G)) { |
| 3303 | − phy->_lo_pairs = kzalloc(sizeof(struct b43legacy_lopair) | |
| 3304 | − * B43legacy_LO_COUNT, | |
| 3303 | + phy->_lo_pairs = kcalloc(B43legacy_LO_COUNT, | |
| 3304 | + sizeof(struct b43legacy_lopair), | |
| 3305 | 3305 | GFP_KERNEL); |
| 3306 | 3306 | if (!phy->_lo_pairs) |
| 3307 | 3307 | return -ENOMEM; |
| @@ -1486,8 +1486,9 @@ int brcmf_proto_msgbuf_attach(struct brcmf_pub *drvr) · 1485 unmodified lines | ||
| 1486 | 1486 | (struct brcmf_commonring **)if_msgbuf->commonrings; |
| 1487 | 1487 | msgbuf->flowrings = (struct brcmf_commonring **)if_msgbuf->flowrings; |
| 1488 | 1488 | msgbuf->max_flowrings = if_msgbuf->max_flowrings; |
| 1489 | − msgbuf->flowring_dma_handle = kzalloc(msgbuf->max_flowrings * | |
| 1490 | − sizeof(*msgbuf->flowring_dma_handle), GFP_KERNEL); | |
| 1489 | + msgbuf->flowring_dma_handle = | |
| 1490 | + kcalloc(msgbuf->max_flowrings, | |
| 1491 | + sizeof(*msgbuf->flowring_dma_handle), GFP_KERNEL); | |
| 1491 | 1492 | if (!msgbuf->flowring_dma_handle) |
| 1492 | 1493 | goto fail; |
| 1493 | 1494 | |
| @@ -1058,7 +1058,7 @@ static s32 brcmf_p2p_act_frm_search(struct brcmf_p2p_info *p2p, u16 channel) · 1057 unmodified lines | ||
| 1058 | 1058 | channel_cnt = AF_PEER_SEARCH_CNT; |
| 1059 | 1059 | else |
| 1060 | 1060 | channel_cnt = SOCIAL_CHAN_CNT; |
| 1061 | − default_chan_list = kzalloc(channel_cnt * sizeof(*default_chan_list), | |
| 1061 | + default_chan_list = kcalloc(channel_cnt, sizeof(*default_chan_list), | |
| 1062 | 1062 | GFP_KERNEL); |
| 1063 | 1063 | if (default_chan_list == NULL) { |
| 1064 | 1064 | brcmf_err("channel list allocation failed\n"); |
| @@ -507,7 +507,7 @@ brcms_c_attach_malloc(uint unit, uint *err, uint devid) · 506 unmodified lines | ||
| 507 | 507 | wlc->hw->wlc = wlc; |
| 508 | 508 | |
| 509 | 509 | wlc->hw->bandstate[0] = |
| 510 | − kzalloc(sizeof(struct brcms_hw_band) * MAXBANDS, GFP_ATOMIC); | |
| 510 | + kcalloc(MAXBANDS, sizeof(struct brcms_hw_band), GFP_ATOMIC); | |
| 511 | 511 | if (wlc->hw->bandstate[0] == NULL) { |
| 512 | 512 | *err = 1006; |
| 513 | 513 | goto fail; |
| @@ -521,7 +521,8 @@ brcms_c_attach_malloc(uint unit, uint *err, uint devid) · 7 unmodified lines | ||
| 521 | 521 | } |
| 522 | 522 | |
| 523 | 523 | wlc->modulecb = |
| 524 | − kzalloc(sizeof(struct modulecb) * BRCMS_MAXMODULES, GFP_ATOMIC); | |
| 524 | + kcalloc(BRCMS_MAXMODULES, sizeof(struct modulecb), | |
| 525 | + GFP_ATOMIC); | |
| 525 | 526 | if (wlc->modulecb == NULL) { |
| 526 | 527 | *err = 1009; |
| 527 | 528 | goto fail; |
| @@ -553,7 +554,7 @@ brcms_c_attach_malloc(uint unit, uint *err, uint devid) · 25 unmodified lines | ||
| 553 | 554 | } |
| 554 | 555 | |
| 555 | 556 | wlc->bandstate[0] = |
| 556 | − kzalloc(sizeof(struct brcms_band)*MAXBANDS, GFP_ATOMIC); | |
| 557 | + kcalloc(MAXBANDS, sizeof(struct brcms_band), GFP_ATOMIC); | |
| 557 | 558 | if (wlc->bandstate[0] == NULL) { |
| 558 | 559 | *err = 1025; |
| 559 | 560 | goto fail; |
| @@ -1387,7 +1387,7 @@ wlc_lcnphy_rx_iq_cal(struct brcms_phy *pi, · 1386 unmodified lines | ||
| 1387 | 1387 | s16 *ptr; |
| 1388 | 1388 | struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy; |
| 1389 | 1389 | |
| 1390 | − ptr = kmalloc(sizeof(s16) * 131, GFP_ATOMIC); | |
| 1390 | + ptr = kmalloc_array(131, sizeof(s16), GFP_ATOMIC); | |
| 1391 | 1391 | if (NULL == ptr) |
| 1392 | 1392 | return false; |
| 1393 | 1393 | if (module == 2) { |
| @@ -2670,7 +2670,7 @@ wlc_lcnphy_tx_iqlo_cal(struct brcms_phy *pi, · 1276 unmodified lines | ||
| 2670 | 2670 | u16 *values_to_save; |
| 2671 | 2671 | struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy; |
| 2672 | 2672 | |
| 2673 | − values_to_save = kmalloc(sizeof(u16) * 20, GFP_ATOMIC); | |
| 2673 | + values_to_save = kmalloc_array(20, sizeof(u16), GFP_ATOMIC); | |
| 2674 | 2674 | if (NULL == values_to_save) |
| 2675 | 2675 | return; |
| 2676 | 2676 | |
| @@ -3678,11 +3678,11 @@ wlc_lcnphy_a1(struct brcms_phy *pi, int cal_type, int num_levels, · 1001 unmodified lines | ||
| 3678 | 3678 | u16 *phy_c32; |
| 3679 | 3679 | phy_c21 = 0; |
| 3680 | 3680 | phy_c10 = phy_c13 = phy_c14 = phy_c8 = 0; |
| 3681 | − ptr = kmalloc(sizeof(s16) * 131, GFP_ATOMIC); | |
| 3681 | + ptr = kmalloc_array(131, sizeof(s16), GFP_ATOMIC); | |
| 3682 | 3682 | if (NULL == ptr) |
| 3683 | 3683 | return; |
| 3684 | 3684 | |
| 3685 | − phy_c32 = kmalloc(sizeof(u16) * 20, GFP_ATOMIC); | |
| 3685 | + phy_c32 = kmalloc_array(20, sizeof(u16), GFP_ATOMIC); | |
| 3686 | 3686 | if (NULL == phy_c32) { |
| 3687 | 3687 | kfree(ptr); |
| 3688 | 3688 | return; |
| @@ -23032,7 +23032,7 @@ wlc_phy_loadsampletable_nphy(struct brcms_phy *pi, struct cordic_iq *tone_buf, · 23031 unmodified lines | ||
| 23032 | 23032 | u16 t; |
| 23033 | 23033 | u32 *data_buf = NULL; |
| 23034 | 23034 | |
| 23035 | − data_buf = kmalloc(sizeof(u32) * num_samps, GFP_ATOMIC); | |
| 23035 | + data_buf = kmalloc_array(num_samps, sizeof(u32), GFP_ATOMIC); | |
| 23036 | 23036 | if (data_buf == NULL) |
| 23037 | 23037 | return; |
| 23038 | 23038 | |
| @@ -23074,7 +23074,8 @@ wlc_phy_gen_load_samples_nphy(struct brcms_phy *pi, u32 f_kHz, u16 max_val, · 35 unmodified lines | ||
| 23074 | 23074 | tbl_len = (phy_bw << 1); |
| 23075 | 23075 | } |
| 23076 | 23076 | |
| 23077 | − tone_buf = kmalloc(sizeof(struct cordic_iq) * tbl_len, GFP_ATOMIC); | |
| 23077 | + tone_buf = kmalloc_array(tbl_len, sizeof(struct cordic_iq), | |
| 23078 | + GFP_ATOMIC); | |
| 23078 | 23079 | if (tone_buf == NULL) |
| 23079 | 23080 | return 0; |
| 23080 | 23081 | |
| @@ -7127,7 +7127,7 @@ static int airo_get_aplist(struct net_device *dev, · 7126 unmodified lines | ||
| 7127 | 7127 | int i; |
| 7128 | 7128 | int loseSync = capable(CAP_NET_ADMIN) ? 1: -1; |
| 7129 | 7129 | |
| 7130 | − qual = kmalloc(IW_MAX_AP * sizeof(*qual), GFP_KERNEL); | |
| 7130 | + qual = kmalloc_array(IW_MAX_AP, sizeof(*qual), GFP_KERNEL); | |
| 7131 | 7131 | if (!qual) |
| 7132 | 7132 | return -ENOMEM; |
| 7133 | 7133 | |
| @@ -3445,8 +3445,9 @@ static int ipw2100_msg_allocate(struct ipw2100_priv *priv) · 3444 unmodified lines | ||
| 3445 | 3445 | dma_addr_t p; |
| 3446 | 3446 | |
| 3447 | 3447 | priv->msg_buffers = |
| 3448 | − kmalloc(IPW_COMMAND_POOL_SIZE * sizeof(struct ipw2100_tx_packet), | |
| 3449 | − GFP_KERNEL); | |
| 3448 | + kmalloc_array(IPW_COMMAND_POOL_SIZE, | |
| 3449 | + sizeof(struct ipw2100_tx_packet), | |
| 3450 | + GFP_KERNEL); | |
| 3450 | 3451 | if (!priv->msg_buffers) |
| 3451 | 3452 | return -ENOMEM; |
| 3452 | 3453 | |
| @@ -4587,9 +4588,9 @@ static int ipw2100_rx_allocate(struct ipw2100_priv *priv) · 1134 unmodified lines | ||
| 4587 | 4588 | /* |
| 4588 | 4589 | * allocate packets |
| 4589 | 4590 | */ |
| 4590 | − priv->rx_buffers = kmalloc(RX_QUEUE_LENGTH * | |
| 4591 | − sizeof(struct ipw2100_rx_packet), | |
| 4592 | − GFP_KERNEL); | |
| 4591 | + priv->rx_buffers = kmalloc_array(RX_QUEUE_LENGTH, | |
| 4592 | + sizeof(struct ipw2100_rx_packet), | |
| 4593 | + GFP_KERNEL); | |
| 4593 | 4594 | if (!priv->rx_buffers) { |
| 4594 | 4595 | IPW_DEBUG_INFO("can't allocate rx packet buffer table\n"); |
| 4595 | 4596 | |
| @@ -3208,13 +3208,13 @@ static int ipw_load_firmware(struct ipw_priv *priv, u8 * data, size_t len) · 3207 unmodified lines | ||
| 3208 | 3208 | |
| 3209 | 3209 | IPW_DEBUG_TRACE("<< :\n"); |
| 3210 | 3210 | |
| 3211 | − virts = kmalloc(sizeof(void *) * CB_NUMBER_OF_ELEMENTS_SMALL, | |
| 3212 | − GFP_KERNEL); | |
| 3211 | + virts = kmalloc_array(CB_NUMBER_OF_ELEMENTS_SMALL, sizeof(void *), | |
| 3212 | + GFP_KERNEL); | |
| 3213 | 3213 | if (!virts) |
| 3214 | 3214 | return -ENOMEM; |
| 3215 | 3215 | |
| 3216 | − phys = kmalloc(sizeof(dma_addr_t) * CB_NUMBER_OF_ELEMENTS_SMALL, | |
| 3217 | − GFP_KERNEL); | |
| 3216 | + phys = kmalloc_array(CB_NUMBER_OF_ELEMENTS_SMALL, sizeof(dma_addr_t), | |
| 3217 | + GFP_KERNEL); | |
| 3218 | 3218 | if (!phys) { |
| 3219 | 3219 | kfree(virts); |
| 3220 | 3220 | return -ENOMEM; |
| @@ -3782,7 +3782,7 @@ static int ipw_queue_tx_init(struct ipw_priv *priv, · 561 unmodified lines | ||
| 3782 | 3782 | { |
| 3783 | 3783 | struct pci_dev *dev = priv->pci_dev; |
| 3784 | 3784 | |
| 3785 | − q->txb = kmalloc(sizeof(q->txb[0]) * count, GFP_KERNEL); | |
| 3785 | + q->txb = kmalloc_array(count, sizeof(q->txb[0]), GFP_KERNEL); | |
| 3786 | 3786 | if (!q->txb) { |
| 3787 | 3787 | IPW_ERROR("vmalloc for auxiliary BD structures failed\n"); |
| 3788 | 3788 | return -ENOMEM; |
| @@ -922,7 +922,7 @@ il_init_channel_map(struct il_priv *il) · 921 unmodified lines | ||
| 922 | 922 | D_EEPROM("Parsing data for %d channels.\n", il->channel_count); |
| 923 | 923 | |
| 924 | 924 | il->channel_info = |
| 925 | − kzalloc(sizeof(struct il_channel_info) * il->channel_count, | |
| 925 | + kcalloc(il->channel_count, sizeof(struct il_channel_info), | |
| 926 | 926 | GFP_KERNEL); |
| 927 | 927 | if (!il->channel_info) { |
| 928 | 928 | IL_ERR("Could not allocate channel_info\n"); |
| @@ -3041,9 +3041,9 @@ il_tx_queue_init(struct il_priv *il, u32 txq_id) · 2112 unmodified lines | ||
| 3041 | 3041 | } |
| 3042 | 3042 | |
| 3043 | 3043 | txq->meta = |
| 3044 | − kzalloc(sizeof(struct il_cmd_meta) * actual_slots, GFP_KERNEL); | |
| 3044 | + kcalloc(actual_slots, sizeof(struct il_cmd_meta), GFP_KERNEL); | |
| 3045 | 3045 | txq->cmd = |
| 3046 | − kzalloc(sizeof(struct il_device_cmd *) * actual_slots, GFP_KERNEL); | |
| 3046 | + kcalloc(actual_slots, sizeof(struct il_device_cmd *), GFP_KERNEL); | |
| 3047 | 3047 | |
| 3048 | 3048 | if (!txq->meta || !txq->cmd) |
| 3049 | 3049 | goto out_free_arrays; |
| @@ -3455,7 +3455,7 @@ il_init_geos(struct il_priv *il) · 405 unmodified lines | ||
| 3455 | 3455 | } |
| 3456 | 3456 | |
| 3457 | 3457 | channels = |
| 3458 | − kzalloc(sizeof(struct ieee80211_channel) * il->channel_count, | |
| 3458 | + kcalloc(il->channel_count, sizeof(struct ieee80211_channel), | |
| 3459 | 3459 | GFP_KERNEL); |
| 3460 | 3460 | if (!channels) |
| 3461 | 3461 | return -ENOMEM; |
| @@ -4654,8 +4654,9 @@ il_alloc_txq_mem(struct il_priv *il) · 1192 unmodified lines | ||
| 4654 | 4654 | { |
| 4655 | 4655 | if (!il->txq) |
| 4656 | 4656 | il->txq = |
| 4657 | − kzalloc(sizeof(struct il_tx_queue) * | |
| 4658 | − il->cfg->num_of_queues, GFP_KERNEL); | |
| 4657 | + kcalloc(il->cfg->num_of_queues, | |
| 4658 | + sizeof(struct il_tx_queue), | |
| 4659 | + GFP_KERNEL); | |
| 4659 | 4660 | if (!il->txq) { |
| 4660 | 4661 | IL_ERR("Not enough memory for txq\n"); |
| 4661 | 4662 | return -ENOMEM; |
| @@ -564,7 +564,7 @@ iwl_mvm_config_sched_scan_profiles(struct iwl_mvm *mvm, · 563 unmodified lines | ||
| 564 | 564 | else |
| 565 | 565 | blacklist_len = IWL_SCAN_MAX_BLACKLIST_LEN; |
| 566 | 566 | |
| 567 | − blacklist = kzalloc(sizeof(*blacklist) * blacklist_len, GFP_KERNEL); | |
| 567 | + blacklist = kcalloc(blacklist_len, sizeof(*blacklist), GFP_KERNEL); | |
| 568 | 568 | if (!blacklist) |
| 569 | 569 | return -ENOMEM; |
| 570 | 570 | |
| @@ -271,8 +271,9 @@ static void prism2_info_scanresults(local_info_t *local, unsigned char *buf, · 270 unmodified lines | ||
| 271 | 271 | left -= 4; |
| 272 | 272 | |
| 273 | 273 | new_count = left / sizeof(struct hfa384x_scan_result); |
| 274 | − results = kmalloc(new_count * sizeof(struct hfa384x_hostscan_result), | |
| 275 | − GFP_ATOMIC); | |
| 274 | + results = kmalloc_array(new_count, | |
| 275 | + sizeof(struct hfa384x_hostscan_result), | |
| 276 | + GFP_ATOMIC); | |
| 276 | 277 | if (results == NULL) |
| 277 | 278 | return; |
| 278 | 279 | |
| @@ -513,8 +513,8 @@ static int prism2_ioctl_giwaplist(struct net_device *dev, · 512 unmodified lines | ||
| 513 | 513 | return -EOPNOTSUPP; |
| 514 | 514 | } |
| 515 | 515 | |
| 516 | − addr = kmalloc(sizeof(struct sockaddr) * IW_MAX_AP, GFP_KERNEL); | |
| 517 | − qual = kmalloc(sizeof(struct iw_quality) * IW_MAX_AP, GFP_KERNEL); | |
| 516 | + addr = kmalloc_array(IW_MAX_AP, sizeof(struct sockaddr), GFP_KERNEL); | |
| 517 | + qual = kmalloc_array(IW_MAX_AP, sizeof(struct iw_quality), GFP_KERNEL); | |
| 518 | 518 | if (addr == NULL || qual == NULL) { |
| 519 | 519 | kfree(addr); |
| 520 | 520 | kfree(qual); |
| @@ -161,8 +161,9 @@ static int p54_generate_band(struct ieee80211_hw *dev, · 160 unmodified lines | ||
| 161 | 161 | if (!tmp) |
| 162 | 162 | goto err_out; |
| 163 | 163 | |
| 164 | − tmp->channels = kzalloc(sizeof(struct ieee80211_channel) * | |
| 165 | − list->band_channel_num[band], GFP_KERNEL); | |
| 164 | + tmp->channels = kcalloc(list->band_channel_num[band], | |
| 165 | + sizeof(struct ieee80211_channel), | |
| 166 | + GFP_KERNEL); | |
| 166 | 167 | if (!tmp->channels) |
| 167 | 168 | goto err_out; |
| 168 | 169 | |
| @@ -344,7 +345,7 @@ static int p54_generate_channel_lists(struct ieee80211_hw *dev) · 175 unmodified lines | ||
| 344 | 345 | goto free; |
| 345 | 346 | } |
| 346 | 347 | priv->chan_num = max_channel_num; |
| 347 | − priv->survey = kzalloc(sizeof(struct survey_info) * max_channel_num, | |
| 348 | + priv->survey = kcalloc(max_channel_num, sizeof(struct survey_info), | |
| 348 | 349 | GFP_KERNEL); |
| 349 | 350 | if (!priv->survey) { |
| 350 | 351 | ret = -ENOMEM; |
| @@ -352,8 +353,9 @@ static int p54_generate_channel_lists(struct ieee80211_hw *dev) · 1 unmodified line | ||
| 352 | 353 | } |
| 353 | 354 | |
| 354 | 355 | list->max_entries = max_channel_num; |
| 355 | − list->channels = kzalloc(sizeof(struct p54_channel_entry) * | |
| 356 | − max_channel_num, GFP_KERNEL); | |
| 356 | + list->channels = kcalloc(max_channel_num, | |
| 357 | + sizeof(struct p54_channel_entry), | |
| 358 | + GFP_KERNEL); | |
| 357 | 359 | if (!list->channels) { |
| 358 | 360 | ret = -ENOMEM; |
| 359 | 361 | goto free; |
| @@ -244,7 +244,7 @@ mgt_init(islpci_private *priv) · 243 unmodified lines | ||
| 244 | 244 | /* Alloc the cache */ |
| 245 | 245 | for (i = 0; i < OID_NUM_LAST; i++) { |
| 246 | 246 | if (isl_oid[i].flags & OID_FLAG_CACHED) { |
| 247 | − priv->mib[i] = kzalloc(isl_oid[i].size * | |
| 247 | + priv->mib[i] = kcalloc(isl_oid[i].size, | |
| 248 | 248 | (isl_oid[i].range + 1), |
| 249 | 249 | GFP_KERNEL); |
| 250 | 250 | if (!priv->mib[i]) |
| @@ -399,8 +399,8 @@ mwifiex_11n_create_rx_reorder_tbl(struct mwifiex_private *priv, u8 *ta, · 398 unmodified lines | ||
| 399 | 399 | |
| 400 | 400 | new_node->win_size = win_size; |
| 401 | 401 | |
| 402 | − new_node->rx_reorder_ptr = kzalloc(sizeof(void *) * win_size, | |
| 403 | − GFP_KERNEL); | |
| 402 | + new_node->rx_reorder_ptr = kcalloc(win_size, sizeof(void *), | |
| 403 | + GFP_KERNEL); | |
| 404 | 404 | if (!new_node->rx_reorder_ptr) { |
| 405 | 405 | kfree((u8 *) new_node); |
| 406 | 406 | mwifiex_dbg(priv->adapter, ERROR, |
| @@ -4242,8 +4242,8 @@ int mwifiex_init_channel_scan_gap(struct mwifiex_adapter *adapter) · 4241 unmodified lines | ||
| 4242 | 4242 | * additional active scan request for hidden SSIDs on passive channels. |
| 4243 | 4243 | */ |
| 4244 | 4244 | adapter->num_in_chan_stats = 2 * (n_channels_bg + n_channels_a); |
| 4245 | − adapter->chan_stats = vmalloc(sizeof(*adapter->chan_stats) * | |
| 4246 | − adapter->num_in_chan_stats); | |
| 4245 | + adapter->chan_stats = vmalloc(array_size(sizeof(*adapter->chan_stats), | |
| 4246 | + adapter->num_in_chan_stats)); | |
| 4247 | 4247 | |
| 4248 | 4248 | if (!adapter->chan_stats) |
| 4249 | 4249 | return -ENOMEM; |
| @@ -2106,15 +2106,16 @@ static int mwifiex_init_sdio(struct mwifiex_adapter *adapter) · 2105 unmodified lines | ||
| 2106 | 2106 | return -ENOMEM; |
| 2107 | 2107 | |
| 2108 | 2108 | /* Allocate skb pointer buffers */ |
| 2109 | − card->mpa_rx.skb_arr = kzalloc((sizeof(void *)) * | |
| 2110 | − card->mp_agg_pkt_limit, GFP_KERNEL); | |
| 2109 | + card->mpa_rx.skb_arr = kcalloc(card->mp_agg_pkt_limit, sizeof(void *), | |
| 2110 | + GFP_KERNEL); | |
| 2111 | 2111 | if (!card->mpa_rx.skb_arr) { |
| 2112 | 2112 | kfree(card->mp_regs); |
| 2113 | 2113 | return -ENOMEM; |
| 2114 | 2114 | } |
| 2115 | 2115 | |
| 2116 | − card->mpa_rx.len_arr = kzalloc(sizeof(*card->mpa_rx.len_arr) * | |
| 2117 | − card->mp_agg_pkt_limit, GFP_KERNEL); | |
| 2116 | + card->mpa_rx.len_arr = kcalloc(card->mp_agg_pkt_limit, | |
| 2117 | + sizeof(*card->mpa_rx.len_arr), | |
| 2118 | + GFP_KERNEL); | |
| 2118 | 2119 | if (!card->mpa_rx.len_arr) { |
| 2119 | 2120 | kfree(card->mp_regs); |
| 2120 | 2121 | kfree(card->mpa_rx.skb_arr); |
| @@ -181,7 +181,7 @@ mt76_init_sband(struct mt76_dev *dev, struct mt76_sband *msband, · 180 unmodified lines | ||
| 181 | 181 | if (!chanlist) |
| 182 | 182 | return -ENOMEM; |
| 183 | 183 | |
| 184 | − msband->chan = devm_kzalloc(dev->dev, n_chan * sizeof(*msband->chan), | |
| 184 | + msband->chan = devm_kcalloc(dev->dev, n_chan, sizeof(*msband->chan), | |
| 185 | 185 | GFP_KERNEL); |
| 186 | 186 | if (!msband->chan) |
| 187 | 187 | return -ENOMEM; |
| @@ -1216,7 +1216,7 @@ static int qtnf_parse_variable_mac_info(struct qtnf_wmac *mac, · 1215 unmodified lines | ||
| 1216 | 1216 | return -EINVAL; |
| 1217 | 1217 | } |
| 1218 | 1218 | |
| 1219 | − limits = kzalloc(sizeof(*limits) * rec->n_limits, | |
| 1219 | + limits = kcalloc(rec->n_limits, sizeof(*limits), | |
| 1220 | 1220 | GFP_KERNEL); |
| 1221 | 1221 | if (!limits) |
| 1222 | 1222 | return -ENOMEM; |
| @@ -397,7 +397,7 @@ static ssize_t rt2x00debug_read_crypto_stats(struct file *file, · 396 unmodified lines | ||
| 397 | 397 | if (*offset) |
| 398 | 398 | return 0; |
| 399 | 399 | |
| 400 | − data = kzalloc((1 + CIPHER_MAX) * MAX_LINE_LENGTH, GFP_KERNEL); | |
| 400 | + data = kcalloc(1 + CIPHER_MAX, MAX_LINE_LENGTH, GFP_KERNEL); | |
| 401 | 401 | if (!data) |
| 402 | 402 | return -ENOMEM; |
| 403 | 403 | |
| @@ -258,8 +258,8 @@ void read_efuse(struct ieee80211_hw *hw, u16 _offset, u16 _size_byte, u8 *pbuf) · 257 unmodified lines | ||
| 258 | 258 | } |
| 259 | 259 | |
| 260 | 260 | /* allocate memory for efuse_tbl and efuse_word */ |
| 261 | − efuse_tbl = kzalloc(rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE] * | |
| 262 | − sizeof(u8), GFP_ATOMIC); | |
| 261 | + efuse_tbl = kzalloc(rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE], | |
| 262 | + GFP_ATOMIC); | |
| 263 | 263 | if (!efuse_tbl) |
| 264 | 264 | return; |
| 265 | 265 | efuse_word = kcalloc(EFUSE_MAX_WORD_UNIT, sizeof(u16 *), GFP_ATOMIC); |
| @@ -1048,7 +1048,7 @@ int rtl_usb_probe(struct usb_interface *intf, · 1047 unmodified lines | ||
| 1048 | 1048 | } |
| 1049 | 1049 | rtlpriv = hw->priv; |
| 1050 | 1050 | rtlpriv->hw = hw; |
| 1051 | − rtlpriv->usb_data = kzalloc(RTL_USB_MAX_RX_COUNT * sizeof(u32), | |
| 1051 | + rtlpriv->usb_data = kcalloc(RTL_USB_MAX_RX_COUNT, sizeof(u32), | |
| 1052 | 1052 | GFP_KERNEL); |
| 1053 | 1053 | if (!rtlpriv->usb_data) |
| 1054 | 1054 | return -ENOMEM; |
| @@ -154,7 +154,7 @@ int cw1200_queue_stats_init(struct cw1200_queue_stats *stats, · 153 unmodified lines | ||
| 154 | 154 | spin_lock_init(&stats->lock); |
| 155 | 155 | init_waitqueue_head(&stats->wait_link_id_empty); |
| 156 | 156 | |
| 157 | − stats->link_map_cache = kzalloc(sizeof(int) * map_capacity, | |
| 157 | + stats->link_map_cache = kcalloc(map_capacity, sizeof(int), | |
| 158 | 158 | GFP_KERNEL); |
| 159 | 159 | if (!stats->link_map_cache) |
| 160 | 160 | return -ENOMEM; |
| @@ -181,13 +181,13 @@ int cw1200_queue_init(struct cw1200_queue *queue, · 20 unmodified lines | ||
| 181 | 181 | spin_lock_init(&queue->lock); |
| 182 | 182 | timer_setup(&queue->gc, cw1200_queue_gc, 0); |
| 183 | 183 | |
| 184 | − queue->pool = kzalloc(sizeof(struct cw1200_queue_item) * capacity, | |
| 185 | − GFP_KERNEL); | |
| 184 | + queue->pool = kcalloc(capacity, sizeof(struct cw1200_queue_item), | |
| 185 | + GFP_KERNEL); | |
| 186 | 186 | if (!queue->pool) |
| 187 | 187 | return -ENOMEM; |
| 188 | 188 | |
| 189 | − queue->link_map_cache = kzalloc(sizeof(int) * stats->map_capacity, | |
| 190 | − GFP_KERNEL); | |
| 189 | + queue->link_map_cache = kcalloc(stats->map_capacity, sizeof(int), | |
| 190 | + GFP_KERNEL); | |
| 191 | 191 | if (!queue->link_map_cache) { |
| 192 | 192 | kfree(queue->pool); |
| 193 | 193 | queue->pool = NULL; |
| @@ -230,9 +230,9 @@ void cw1200_scan_work(struct work_struct *work) · 229 unmodified lines | ||
| 230 | 230 | scan.type = WSM_SCAN_TYPE_BACKGROUND; |
| 231 | 231 | scan.flags = WSM_SCAN_FLAG_FORCE_BACKGROUND; |
| 232 | 232 | } |
| 233 | − scan.ch = kzalloc( | |
| 234 | − sizeof(struct wsm_scan_ch) * (it - priv->scan.curr), | |
| 235 | − GFP_KERNEL); | |
| 233 | + scan.ch = kcalloc(it - priv->scan.curr, | |
| 234 | + sizeof(struct wsm_scan_ch), | |
| 235 | + GFP_KERNEL); | |
| 236 | 236 | if (!scan.ch) { |
| 237 | 237 | priv->scan.status = -ENOMEM; |
| 238 | 238 | goto fail; |
| @@ -732,7 +732,8 @@ static int zd_mac_config_beacon(struct ieee80211_hw *hw, struct sk_buff *beacon, · 731 unmodified lines | ||
| 732 | 732 | |
| 733 | 733 | /* Alloc memory for full beacon write at once. */ |
| 734 | 734 | num_cmds = 1 + zd_chip_is_zd1211b(&mac->chip) + full_len; |
| 735 | − ioreqs = kmalloc(num_cmds * sizeof(struct zd_ioreq32), GFP_KERNEL); | |
| 735 | + ioreqs = kmalloc_array(num_cmds, sizeof(struct zd_ioreq32), | |
| 736 | + GFP_KERNEL); | |
| 736 | 737 | if (!ioreqs) { |
| 737 | 738 | r = -ENOMEM; |
| 738 | 739 | goto out_nofree; |
| @@ -977,8 +977,8 @@ static void connect(struct backend_info *be) · 976 unmodified lines | ||
| 977 | 977 | } |
| 978 | 978 | |
| 979 | 979 | /* Use the number of queues requested by the frontend */ |
| 980 | − be->vif->queues = vzalloc(requested_num_queues * | |
| 981 | − sizeof(struct xenvif_queue)); | |
| 980 | + be->vif->queues = vzalloc(array_size(requested_num_queues, | |
| 981 | + sizeof(struct xenvif_queue))); | |
| 982 | 982 | if (!be->vif->queues) { |
| 983 | 983 | xenbus_dev_fatal(dev, -ENOMEM, |
| 984 | 984 | "allocating queues"); |
| @@ -259,8 +259,8 @@ static void fdp_nci_i2c_read_device_properties(struct device *dev, · 258 unmodified lines | ||
| 259 | 259 | /* Add 1 to the length to inclue the length byte itself */ |
| 260 | 260 | len++; |
| 261 | 261 | |
| 262 | − *fw_vsc_cfg = devm_kmalloc(dev, | |
| 263 | − len * sizeof(**fw_vsc_cfg), | |
| 262 | + *fw_vsc_cfg = devm_kmalloc_array(dev, | |
| 263 | + len, sizeof(**fw_vsc_cfg), | |
| 264 | 264 | GFP_KERNEL); |
| 265 | 265 | |
| 266 | 266 | r = device_property_read_u8_array(dev, FDP_DP_FW_VSC_CFG_NAME, |
| @@ -592,12 +592,12 @@ static int ndev_init_isr(struct amd_ntb_dev *ndev, · 591 unmodified lines | ||
| 592 | 592 | ndev->db_mask = ndev->db_valid_mask; |
| 593 | 593 | |
| 594 | 594 | /* Try to set up msix irq */ |
| 595 | − ndev->vec = kzalloc_node(msix_max * sizeof(*ndev->vec), | |
| 595 | + ndev->vec = kcalloc_node(msix_max, sizeof(*ndev->vec), | |
| 596 | 596 | GFP_KERNEL, node); |
| 597 | 597 | if (!ndev->vec) |
| 598 | 598 | goto err_msix_vec_alloc; |
| 599 | 599 | |
| 600 | − ndev->msix = kzalloc_node(msix_max * sizeof(*ndev->msix), | |
| 600 | + ndev->msix = kcalloc_node(msix_max, sizeof(*ndev->msix), | |
| 601 | 601 | GFP_KERNEL, node); |
| 602 | 602 | if (!ndev->msix) |
| 603 | 603 | goto err_msix_alloc; |
| @@ -380,12 +380,12 @@ int ndev_init_isr(struct intel_ntb_dev *ndev, · 379 unmodified lines | ||
| 380 | 380 | |
| 381 | 381 | /* Try to set up msix irq */ |
| 382 | 382 | |
| 383 | − ndev->vec = kzalloc_node(msix_max * sizeof(*ndev->vec), | |
| 383 | + ndev->vec = kcalloc_node(msix_max, sizeof(*ndev->vec), | |
| 384 | 384 | GFP_KERNEL, node); |
| 385 | 385 | if (!ndev->vec) |
| 386 | 386 | goto err_msix_vec_alloc; |
| 387 | 387 | |
| 388 | − ndev->msix = kzalloc_node(msix_max * sizeof(*ndev->msix), | |
| 388 | + ndev->msix = kcalloc_node(msix_max, sizeof(*ndev->msix), | |
| 389 | 389 | GFP_KERNEL, node); |
| 390 | 390 | if (!ndev->msix) |
| 391 | 391 | goto err_msix_alloc; |
| @@ -1102,7 +1102,7 @@ static int ntb_transport_probe(struct ntb_client *self, struct ntb_dev *ndev) · 1101 unmodified lines | ||
| 1102 | 1102 | max_mw_count_for_spads = (spad_count - MW0_SZ_HIGH) / 2; |
| 1103 | 1103 | nt->mw_count = min(mw_count, max_mw_count_for_spads); |
| 1104 | 1104 | |
| 1105 | − nt->mw_vec = kzalloc_node(mw_count * sizeof(*nt->mw_vec), | |
| 1105 | + nt->mw_vec = kcalloc_node(mw_count, sizeof(*nt->mw_vec), | |
| 1106 | 1106 | GFP_KERNEL, node); |
| 1107 | 1107 | if (!nt->mw_vec) { |
| 1108 | 1108 | rc = -ENOMEM; |
| @@ -1143,7 +1143,7 @@ static int ntb_transport_probe(struct ntb_client *self, struct ntb_dev *ndev) · 34 unmodified lines | ||
| 1143 | 1143 | nt->qp_bitmap = qp_bitmap; |
| 1144 | 1144 | nt->qp_bitmap_free = qp_bitmap; |
| 1145 | 1145 | |
| 1146 | − nt->qp_vec = kzalloc_node(qp_count * sizeof(*nt->qp_vec), | |
| 1146 | + nt->qp_vec = kcalloc_node(qp_count, sizeof(*nt->qp_vec), | |
| 1147 | 1147 | GFP_KERNEL, node); |
| 1148 | 1148 | if (!nt->qp_vec) { |
| 1149 | 1149 | rc = -ENOMEM; |
| @@ -122,7 +122,8 @@ static int rockchip_rk3328_efuse_read(void *context, unsigned int offset, · 121 unmodified lines | ||
| 122 | 122 | addr_offset = offset % RK3399_NBYTES; |
| 123 | 123 | addr_len = addr_end - addr_start; |
| 124 | 124 | |
| 125 | − buf = kzalloc(sizeof(*buf) * addr_len * RK3399_NBYTES, GFP_KERNEL); | |
| 125 | + buf = kzalloc(array3_size(addr_len, RK3399_NBYTES, sizeof(*buf)), | |
| 126 | + GFP_KERNEL); | |
| 126 | 127 | if (!buf) { |
| 127 | 128 | ret = -ENOMEM; |
| 128 | 129 | goto nomem; |
| @@ -174,7 +175,8 @@ static int rockchip_rk3399_efuse_read(void *context, unsigned int offset, · 45 unmodified lines | ||
| 174 | 175 | addr_offset = offset % RK3399_NBYTES; |
| 175 | 176 | addr_len = addr_end - addr_start; |
| 176 | 177 | |
| 177 | − buf = kzalloc(sizeof(*buf) * addr_len * RK3399_NBYTES, GFP_KERNEL); | |
| 178 | + buf = kzalloc(array3_size(addr_len, RK3399_NBYTES, sizeof(*buf)), | |
| 179 | + GFP_KERNEL); | |
| 178 | 180 | if (!buf) { |
| 179 | 181 | clk_disable_unprepare(efuse->clk); |
| 180 | 182 | return -ENOMEM; |
| @@ -185,7 +185,7 @@ static int sunxi_sid_probe(struct platform_device *pdev) · 184 unmodified lines | ||
| 185 | 185 | if (IS_ERR(nvmem)) |
| 186 | 186 | return PTR_ERR(nvmem); |
| 187 | 187 | |
| 188 | − randomness = kzalloc(sizeof(u8) * (size), GFP_KERNEL); | |
| 188 | + randomness = kzalloc(size, GFP_KERNEL); | |
| 189 | 189 | if (!randomness) { |
| 190 | 190 | ret = -EINVAL; |
| 191 | 191 | goto err_unreg_nvmem; |
| @@ -129,7 +129,7 @@ struct platform_device *of_device_alloc(struct device_node *np, · 128 unmodified lines | ||
| 129 | 129 | |
| 130 | 130 | /* Populate the resource table */ |
| 131 | 131 | if (num_irq || num_reg) { |
| 132 | − res = kzalloc(sizeof(*res) * (num_irq + num_reg), GFP_KERNEL); | |
| 132 | + res = kcalloc(num_irq + num_reg, sizeof(*res), GFP_KERNEL); | |
| 133 | 133 | if (!res) { |
| 134 | 134 | platform_device_put(dev); |
| 135 | 135 | return NULL; |
| @@ -156,7 +156,7 @@ static void __init of_unittest_dynamic(void) · 155 unmodified lines | ||
| 156 | 156 | } |
| 157 | 157 | |
| 158 | 158 | /* Array of 4 properties for the purpose of testing */ |
| 159 | − prop = kzalloc(sizeof(*prop) * 4, GFP_KERNEL); | |
| 159 | + prop = kcalloc(4, sizeof(*prop), GFP_KERNEL); | |
| 160 | 160 | if (!prop) { |
| 161 | 161 | unittest(0, "kzalloc() failed\n"); |
| 162 | 162 | return; |
| @@ -122,8 +122,8 @@ static int _store_optimized_voltages(struct device *dev, · 121 unmodified lines | ||
| 122 | 122 | goto out; |
| 123 | 123 | } |
| 124 | 124 | |
| 125 | − table = kzalloc(sizeof(*data->vdd_table) * | |
| 126 | − data->num_vdd_table, GFP_KERNEL); | |
| 125 | + table = kcalloc(data->num_vdd_table, sizeof(*data->vdd_table), | |
| 126 | + GFP_KERNEL); | |
| 127 | 127 | if (!table) { |
| 128 | 128 | ret = -ENOMEM; |
| 129 | 129 | goto out; |
| @@ -91,7 +91,7 @@ int alloc_event_buffer(void) · 90 unmodified lines | ||
| 91 | 91 | return -EINVAL; |
| 92 | 92 | |
| 93 | 93 | buffer_pos = 0; |
| 94 | − event_buffer = vmalloc(sizeof(unsigned long) * buffer_size); | |
| 94 | + event_buffer = vmalloc(array_size(buffer_size, sizeof(unsigned long))); | |
| 95 | 95 | if (!event_buffer) |
| 96 | 96 | return -ENOMEM; |
| 97 | 97 | |
| @@ -639,11 +639,11 @@ static int __init dra7xx_pcie_probe(struct platform_device *pdev) · 638 unmodified lines | ||
| 639 | 639 | return phy_count; |
| 640 | 640 | } |
| 641 | 641 | |
| 642 | − phy = devm_kzalloc(dev, sizeof(*phy) * phy_count, GFP_KERNEL); | |
| 642 | + phy = devm_kcalloc(dev, phy_count, sizeof(*phy), GFP_KERNEL); | |
| 643 | 643 | if (!phy) |
| 644 | 644 | return -ENOMEM; |
| 645 | 645 | |
| 646 | − link = devm_kzalloc(dev, sizeof(*link) * phy_count, GFP_KERNEL); | |
| 646 | + link = devm_kcalloc(dev, phy_count, sizeof(*link), GFP_KERNEL); | |
| 647 | 647 | if (!link) |
| 648 | 648 | return -ENOMEM; |
| 649 | 649 | |
| @@ -366,19 +366,21 @@ int dw_pcie_ep_init(struct dw_pcie_ep *ep) · 365 unmodified lines | ||
| 366 | 366 | return -EINVAL; |
| 367 | 367 | } |
| 368 | 368 | |
| 369 | − ep->ib_window_map = devm_kzalloc(dev, sizeof(long) * | |
| 369 | + ep->ib_window_map = devm_kcalloc(dev, | |
| 370 | 370 | BITS_TO_LONGS(ep->num_ib_windows), |
| 371 | + sizeof(long), | |
| 371 | 372 | GFP_KERNEL); |
| 372 | 373 | if (!ep->ib_window_map) |
| 373 | 374 | return -ENOMEM; |
| 374 | 375 | |
| 375 | − ep->ob_window_map = devm_kzalloc(dev, sizeof(long) * | |
| 376 | + ep->ob_window_map = devm_kcalloc(dev, | |
| 376 | 377 | BITS_TO_LONGS(ep->num_ob_windows), |
| 378 | + sizeof(long), | |
| 377 | 379 | GFP_KERNEL); |
| 378 | 380 | if (!ep->ob_window_map) |
| 379 | 381 | return -ENOMEM; |
| 380 | 382 | |
| 381 | − addr = devm_kzalloc(dev, sizeof(phys_addr_t) * ep->num_ob_windows, | |
| 383 | + addr = devm_kcalloc(dev, ep->num_ob_windows, sizeof(phys_addr_t), | |
| 382 | 384 | GFP_KERNEL); |
| 383 | 385 | if (!addr) |
| 384 | 386 | return -ENOMEM; |
| @@ -467,7 +467,8 @@ static int cdns_pcie_ep_probe(struct platform_device *pdev) · 466 unmodified lines | ||
| 467 | 467 | dev_err(dev, "missing \"cdns,max-outbound-regions\"\n"); |
| 468 | 468 | return ret; |
| 469 | 469 | } |
| 470 | − ep->ob_addr = devm_kzalloc(dev, ep->max_regions * sizeof(*ep->ob_addr), | |
| 470 | + ep->ob_addr = devm_kcalloc(dev, | |
| 471 | + ep->max_regions, sizeof(*ep->ob_addr), | |
| 471 | 472 | GFP_KERNEL); |
| 472 | 473 | if (!ep->ob_addr) |
| 473 | 474 | return -ENOMEM; |
| @@ -593,7 +593,7 @@ static int rockchip_pcie_ep_probe(struct platform_device *pdev) · 592 unmodified lines | ||
| 593 | 593 | PCIE_CLIENT_CONFIG); |
| 594 | 594 | |
| 595 | 595 | max_regions = ep->max_regions; |
| 596 | − ep->ob_addr = devm_kzalloc(dev, max_regions * sizeof(*ep->ob_addr), | |
| 596 | + ep->ob_addr = devm_kcalloc(dev, max_regions, sizeof(*ep->ob_addr), | |
| 597 | 597 | GFP_KERNEL); |
| 598 | 598 | |
| 599 | 599 | if (!ep->ob_addr) { |
| @@ -474,7 +474,7 @@ static int populate_msi_sysfs(struct pci_dev *pdev) · 473 unmodified lines | ||
| 474 | 474 | return 0; |
| 475 | 475 | |
| 476 | 476 | /* Dynamically create the MSI attributes for the PCI device */ |
| 477 | − msi_attrs = kzalloc(sizeof(void *) * (num_msi + 1), GFP_KERNEL); | |
| 477 | + msi_attrs = kcalloc(num_msi + 1, sizeof(void *), GFP_KERNEL); | |
| 478 | 478 | if (!msi_attrs) |
| 479 | 479 | return -ENOMEM; |
| 480 | 480 | for_each_pci_msi_entry(entry, pdev) { |
| @@ -501,7 +501,7 @@ static int populate_msi_sysfs(struct pci_dev *pdev) · 20 unmodified lines | ||
| 501 | 501 | msi_irq_group->name = "msi_irqs"; |
| 502 | 502 | msi_irq_group->attrs = msi_attrs; |
| 503 | 503 | |
| 504 | − msi_irq_groups = kzalloc(sizeof(void *) * 2, GFP_KERNEL); | |
| 504 | + msi_irq_groups = kcalloc(2, sizeof(void *), GFP_KERNEL); | |
| 505 | 505 | if (!msi_irq_groups) |
| 506 | 506 | goto error_irq_group; |
| 507 | 507 | msi_irq_groups[0] = msi_irq_group; |
| @@ -1076,7 +1076,7 @@ void pci_create_legacy_files(struct pci_bus *b) · 1075 unmodified lines | ||
| 1076 | 1076 | { |
| 1077 | 1077 | int error; |
| 1078 | 1078 | |
| 1079 | − b->legacy_io = kzalloc(sizeof(struct bin_attribute) * 2, | |
| 1079 | + b->legacy_io = kcalloc(2, sizeof(struct bin_attribute), | |
| 1080 | 1080 | GFP_ATOMIC); |
| 1081 | 1081 | if (!b->legacy_io) |
| 1082 | 1082 | goto kzalloc_err; |
| @@ -1481,11 +1481,11 @@ static ssize_t pccard_extract_cis(struct pcmcia_socket *s, char *buf, · 1480 unmodified lines | ||
| 1481 | 1481 | u_char *tuplebuffer; |
| 1482 | 1482 | u_char *tempbuffer; |
| 1483 | 1483 | |
| 1484 | − tuplebuffer = kmalloc(sizeof(u_char) * 256, GFP_KERNEL); | |
| 1484 | + tuplebuffer = kmalloc_array(256, sizeof(u_char), GFP_KERNEL); | |
| 1485 | 1485 | if (!tuplebuffer) |
| 1486 | 1486 | return -ENOMEM; |
| 1487 | 1487 | |
| 1488 | − tempbuffer = kmalloc(sizeof(u_char) * 258, GFP_KERNEL); | |
| 1488 | + tempbuffer = kmalloc_array(258, sizeof(u_char), GFP_KERNEL); | |
| 1489 | 1489 | if (!tempbuffer) { |
| 1490 | 1490 | ret = -ENOMEM; |
| 1491 | 1491 | goto free_tuple; |
| @@ -628,7 +628,7 @@ static int pd6729_pci_probe(struct pci_dev *dev, · 627 unmodified lines | ||
| 628 | 628 | char configbyte; |
| 629 | 629 | struct pd6729_socket *socket; |
| 630 | 630 | |
| 631 | − socket = kzalloc(sizeof(struct pd6729_socket) * MAX_SOCKETS, | |
| 631 | + socket = kcalloc(MAX_SOCKETS, sizeof(struct pd6729_socket), | |
| 632 | 632 | GFP_KERNEL); |
| 633 | 633 | if (!socket) { |
| 634 | 634 | dev_warn(&dev->dev, "failed to kzalloc socket.\n"); |
| @@ -771,8 +771,8 @@ static int bcm2835_pctl_dt_node_to_map(struct pinctrl_dev *pctldev, · 770 unmodified lines | ||
| 771 | 771 | maps_per_pin++; |
| 772 | 772 | if (num_pulls) |
| 773 | 773 | maps_per_pin++; |
| 774 | − cur_map = maps = kzalloc(num_pins * maps_per_pin * sizeof(*maps), | |
| 775 | − GFP_KERNEL); | |
| 774 | + cur_map = maps = kcalloc(num_pins * maps_per_pin, sizeof(*maps), | |
| 775 | + GFP_KERNEL); | |
| 776 | 776 | if (!maps) |
| 777 | 777 | return -ENOMEM; |
| 778 | 778 | |
| @@ -216,8 +216,9 @@ static int berlin_pinctrl_build_state(struct platform_device *pdev) · 215 unmodified lines | ||
| 216 | 216 | } |
| 217 | 217 | |
| 218 | 218 | /* we will reallocate later */ |
| 219 | − pctrl->functions = devm_kzalloc(&pdev->dev, | |
| 220 | − max_functions * sizeof(*pctrl->functions), | |
| 219 | + pctrl->functions = devm_kcalloc(&pdev->dev, | |
| 220 | + max_functions, | |
| 221 | + sizeof(*pctrl->functions), | |
| 221 | 222 | GFP_KERNEL); |
| 222 | 223 | if (!pctrl->functions) |
| 223 | 224 | return -ENOMEM; |
| @@ -261,8 +262,9 @@ static int berlin_pinctrl_build_state(struct platform_device *pdev) · 37 unmodified lines | ||
| 261 | 262 | |
| 262 | 263 | if (!function->groups) { |
| 263 | 264 | function->groups = |
| 264 | − devm_kzalloc(&pdev->dev, | |
| 265 | − function->ngroups * sizeof(char *), | |
| 265 | + devm_kcalloc(&pdev->dev, | |
| 266 | + function->ngroups, | |
| 267 | + sizeof(char *), | |
| 266 | 268 | GFP_KERNEL); |
| 267 | 269 | |
| 268 | 270 | if (!function->groups) |
| @@ -81,7 +81,8 @@ static int imx_dt_node_to_map(struct pinctrl_dev *pctldev, · 80 unmodified lines | ||
| 81 | 81 | map_num++; |
| 82 | 82 | } |
| 83 | 83 | |
| 84 | − new_map = kmalloc(sizeof(struct pinctrl_map) * map_num, GFP_KERNEL); | |
| 84 | + new_map = kmalloc_array(map_num, sizeof(struct pinctrl_map), | |
| 85 | + GFP_KERNEL); | |
| 85 | 86 | if (!new_map) |
| 86 | 87 | return -ENOMEM; |
| 87 | 88 | |
| @@ -476,10 +477,12 @@ static int imx_pinctrl_parse_groups(struct device_node *np, · 388 unmodified lines | ||
| 476 | 477 | config = imx_pinconf_parse_generic_config(np, ipctl); |
| 477 | 478 | |
| 478 | 479 | grp->num_pins = size / pin_size; |
| 479 | − grp->data = devm_kzalloc(ipctl->dev, grp->num_pins * | |
| 480 | − sizeof(struct imx_pin), GFP_KERNEL); | |
| 481 | − grp->pins = devm_kzalloc(ipctl->dev, grp->num_pins * | |
| 482 | − sizeof(unsigned int), GFP_KERNEL); | |
| 480 | + grp->data = devm_kcalloc(ipctl->dev, | |
| 481 | + grp->num_pins, sizeof(struct imx_pin), | |
| 482 | + GFP_KERNEL); | |
| 483 | + grp->pins = devm_kcalloc(ipctl->dev, | |
| 484 | + grp->num_pins, sizeof(unsigned int), | |
| 485 | + GFP_KERNEL); | |
| 483 | 486 | if (!grp->pins || !grp->data) |
| 484 | 487 | return -ENOMEM; |
| 485 | 488 | |
| @@ -697,8 +700,9 @@ int imx_pinctrl_probe(struct platform_device *pdev, · 211 unmodified lines | ||
| 697 | 700 | if (!ipctl) |
| 698 | 701 | return -ENOMEM; |
| 699 | 702 | |
| 700 | − ipctl->pin_regs = devm_kmalloc(&pdev->dev, sizeof(*ipctl->pin_regs) * | |
| 701 | − info->npins, GFP_KERNEL); | |
| 703 | + ipctl->pin_regs = devm_kmalloc_array(&pdev->dev, | |
| 704 | + info->npins, sizeof(*ipctl->pin_regs), | |
| 705 | + GFP_KERNEL); | |
| 702 | 706 | if (!ipctl->pin_regs) |
| 703 | 707 | return -ENOMEM; |
| 704 | 708 | |
| @@ -241,7 +241,8 @@ static int imx1_dt_node_to_map(struct pinctrl_dev *pctldev, · 240 unmodified lines | ||
| 241 | 241 | for (i = 0; i < grp->npins; i++) |
| 242 | 242 | map_num++; |
| 243 | 243 | |
| 244 | − new_map = kmalloc(sizeof(struct pinctrl_map) * map_num, GFP_KERNEL); | |
| 244 | + new_map = kmalloc_array(map_num, sizeof(struct pinctrl_map), | |
| 245 | + GFP_KERNEL); | |
| 245 | 246 | if (!new_map) |
| 246 | 247 | return -ENOMEM; |
| 247 | 248 | |
| @@ -482,10 +483,10 @@ static int imx1_pinctrl_parse_groups(struct device_node *np, · 234 unmodified lines | ||
| 482 | 483 | } |
| 483 | 484 | |
| 484 | 485 | grp->npins = size / 12; |
| 485 | − grp->pins = devm_kzalloc(info->dev, | |
| 486 | − grp->npins * sizeof(struct imx1_pin), GFP_KERNEL); | |
| 487 | − grp->pin_ids = devm_kzalloc(info->dev, | |
| 488 | − grp->npins * sizeof(unsigned int), GFP_KERNEL); | |
| 486 | + grp->pins = devm_kcalloc(info->dev, | |
| 487 | + grp->npins, sizeof(struct imx1_pin), GFP_KERNEL); | |
| 488 | + grp->pin_ids = devm_kcalloc(info->dev, | |
| 489 | + grp->npins, sizeof(unsigned int), GFP_KERNEL); | |
| 489 | 490 | |
| 490 | 491 | if (!grp->pins || !grp->pin_ids) |
| 491 | 492 | return -ENOMEM; |
| @@ -522,8 +523,8 @@ static int imx1_pinctrl_parse_functions(struct device_node *np, · 30 unmodified lines | ||
| 522 | 523 | if (func->num_groups == 0) |
| 523 | 524 | return -EINVAL; |
| 524 | 525 | |
| 525 | − func->groups = devm_kzalloc(info->dev, | |
| 526 | − func->num_groups * sizeof(char *), GFP_KERNEL); | |
| 526 | + func->groups = devm_kcalloc(info->dev, | |
| 527 | + func->num_groups, sizeof(char *), GFP_KERNEL); | |
| 527 | 528 | |
| 528 | 529 | if (!func->groups) |
| 529 | 530 | return -ENOMEM; |
| @@ -565,12 +566,12 @@ static int imx1_pinctrl_parse_dt(struct platform_device *pdev, · 35 unmodified lines | ||
| 565 | 566 | } |
| 566 | 567 | |
| 567 | 568 | info->nfunctions = nfuncs; |
| 568 | − info->functions = devm_kzalloc(&pdev->dev, | |
| 569 | − nfuncs * sizeof(struct imx1_pmx_func), GFP_KERNEL); | |
| 569 | + info->functions = devm_kcalloc(&pdev->dev, | |
| 570 | + nfuncs, sizeof(struct imx1_pmx_func), GFP_KERNEL); | |
| 570 | 571 | |
| 571 | 572 | info->ngroups = ngroups; |
| 572 | − info->groups = devm_kzalloc(&pdev->dev, | |
| 573 | − ngroups * sizeof(struct imx1_pin_group), GFP_KERNEL); | |
| 573 | + info->groups = devm_kcalloc(&pdev->dev, | |
| 574 | + ngroups, sizeof(struct imx1_pin_group), GFP_KERNEL); | |
| 574 | 575 | |
| 575 | 576 | |
| 576 | 577 | if (!info->functions || !info->groups) |
| @@ -89,7 +89,7 @@ static int mxs_dt_node_to_map(struct pinctrl_dev *pctldev, · 88 unmodified lines | ||
| 89 | 89 | if (!purecfg && config) |
| 90 | 90 | new_num = 2; |
| 91 | 91 | |
| 92 | − new_map = kzalloc(sizeof(*new_map) * new_num, GFP_KERNEL); | |
| 92 | + new_map = kcalloc(new_num, sizeof(*new_map), GFP_KERNEL); | |
| 93 | 93 | if (!new_map) |
| 94 | 94 | return -ENOMEM; |
| 95 | 95 | |
| @@ -370,12 +370,12 @@ static int mxs_pinctrl_parse_group(struct platform_device *pdev, · 274 unmodified lines | ||
| 370 | 370 | return -EINVAL; |
| 371 | 371 | g->npins = length / sizeof(u32); |
| 372 | 372 | |
| 373 | − g->pins = devm_kzalloc(&pdev->dev, g->npins * sizeof(*g->pins), | |
| 373 | + g->pins = devm_kcalloc(&pdev->dev, g->npins, sizeof(*g->pins), | |
| 374 | 374 | GFP_KERNEL); |
| 375 | 375 | if (!g->pins) |
| 376 | 376 | return -ENOMEM; |
| 377 | 377 | |
| 378 | − g->muxsel = devm_kzalloc(&pdev->dev, g->npins * sizeof(*g->muxsel), | |
| 378 | + g->muxsel = devm_kcalloc(&pdev->dev, g->npins, sizeof(*g->muxsel), | |
| 379 | 379 | GFP_KERNEL); |
| 380 | 380 | if (!g->muxsel) |
| 381 | 381 | return -ENOMEM; |
| @@ -426,13 +426,16 @@ static int mxs_pinctrl_probe_dt(struct platform_device *pdev, · 44 unmodified lines | ||
| 426 | 426 | } |
| 427 | 427 | } |
| 428 | 428 | |
| 429 | − soc->functions = devm_kzalloc(&pdev->dev, soc->nfunctions * | |
| 430 | − sizeof(*soc->functions), GFP_KERNEL); | |
| 429 | + soc->functions = devm_kcalloc(&pdev->dev, | |
| 430 | + soc->nfunctions, | |
| 431 | + sizeof(*soc->functions), | |
| 432 | + GFP_KERNEL); | |
| 431 | 433 | if (!soc->functions) |
| 432 | 434 | return -ENOMEM; |
| 433 | 435 | |
| 434 | − soc->groups = devm_kzalloc(&pdev->dev, soc->ngroups * | |
| 435 | − sizeof(*soc->groups), GFP_KERNEL); | |
| 436 | + soc->groups = devm_kcalloc(&pdev->dev, | |
| 437 | + soc->ngroups, sizeof(*soc->groups), | |
| 438 | + GFP_KERNEL); | |
| 436 | 439 | if (!soc->groups) |
| 437 | 440 | return -ENOMEM; |
| 438 | 441 | |
| @@ -492,7 +495,8 @@ static int mxs_pinctrl_probe_dt(struct platform_device *pdev, · 53 unmodified lines | ||
| 492 | 495 | |
| 493 | 496 | if (strcmp(fn, child->name)) { |
| 494 | 497 | f = &soc->functions[idxf++]; |
| 495 | − f->groups = devm_kzalloc(&pdev->dev, f->ngroups * | |
| 498 | + f->groups = devm_kcalloc(&pdev->dev, | |
| 499 | + f->ngroups, | |
| 496 | 500 | sizeof(*f->groups), |
| 497 | 501 | GFP_KERNEL); |
| 498 | 502 | if (!f->groups) |
| @@ -856,9 +856,10 @@ static int armada_37xx_fill_group(struct armada_37xx_pinctrl *info) · 855 unmodified lines | ||
| 856 | 856 | struct armada_37xx_pin_group *grp = &info->groups[n]; |
| 857 | 857 | int i, j, f; |
| 858 | 858 | |
| 859 | − grp->pins = devm_kzalloc(info->dev, | |
| 860 | − (grp->npins + grp->extra_npins) * | |
| 861 | − sizeof(*grp->pins), GFP_KERNEL); | |
| 859 | + grp->pins = devm_kcalloc(info->dev, | |
| 860 | + grp->npins + grp->extra_npins, | |
| 861 | + sizeof(*grp->pins), | |
| 862 | + GFP_KERNEL); | |
| 862 | 863 | if (!grp->pins) |
| 863 | 864 | return -ENOMEM; |
| 864 | 865 | |
| @@ -908,7 +909,8 @@ static int armada_37xx_fill_func(struct armada_37xx_pinctrl *info) · 43 unmodified lines | ||
| 908 | 909 | const char **groups; |
| 909 | 910 | int g; |
| 910 | 911 | |
| 911 | − funcs[n].groups = devm_kzalloc(info->dev, funcs[n].ngroups * | |
| 912 | + funcs[n].groups = devm_kcalloc(info->dev, | |
| 913 | + funcs[n].ngroups, | |
| 912 | 914 | sizeof(*(funcs[n].groups)), |
| 913 | 915 | GFP_KERNEL); |
| 914 | 916 | if (!funcs[n].groups) |
| @@ -948,8 +950,9 @@ static int armada_37xx_pinctrl_register(struct platform_device *pdev, · 33 unmodified lines | ||
| 948 | 950 | ctrldesc->pmxops = &armada_37xx_pmx_ops; |
| 949 | 951 | ctrldesc->confops = &armada_37xx_pinconf_ops; |
| 950 | 952 | |
| 951 | − pindesc = devm_kzalloc(&pdev->dev, sizeof(*pindesc) * | |
| 952 | − pin_data->nr_pins, GFP_KERNEL); | |
| 953 | + pindesc = devm_kcalloc(&pdev->dev, | |
| 954 | + pin_data->nr_pins, sizeof(*pindesc), | |
| 955 | + GFP_KERNEL); | |
| 953 | 956 | if (!pindesc) |
| 954 | 957 | return -ENOMEM; |
| 955 | 958 | |
| @@ -968,8 +971,10 @@ static int armada_37xx_pinctrl_register(struct platform_device *pdev, · 12 unmodified lines | ||
| 968 | 971 | * we allocate functions for number of pins and hope there are |
| 969 | 972 | * fewer unique functions than pins available |
| 970 | 973 | */ |
| 971 | − info->funcs = devm_kzalloc(&pdev->dev, pin_data->nr_pins * | |
| 972 | − sizeof(struct armada_37xx_pmx_func), GFP_KERNEL); | |
| 974 | + info->funcs = devm_kcalloc(&pdev->dev, | |
| 975 | + pin_data->nr_pins, | |
| 976 | + sizeof(struct armada_37xx_pmx_func), | |
| 977 | + GFP_KERNEL); | |
| 973 | 978 | if (!info->funcs) |
| 974 | 979 | return -ENOMEM; |
| 975 | 980 | |
| @@ -630,8 +630,8 @@ static int armada_xp_pinctrl_probe(struct platform_device *pdev) · 629 unmodified lines | ||
| 630 | 630 | |
| 631 | 631 | nregs = DIV_ROUND_UP(soc->nmodes, MVEBU_MPPS_PER_REG); |
| 632 | 632 | |
| 633 | − mpp_saved_regs = devm_kmalloc(&pdev->dev, nregs * sizeof(u32), | |
| 634 | − GFP_KERNEL); | |
| 633 | + mpp_saved_regs = devm_kmalloc_array(&pdev->dev, nregs, sizeof(u32), | |
| 634 | + GFP_KERNEL); | |
| 635 | 635 | if (!mpp_saved_regs) |
| 636 | 636 | return -ENOMEM; |
| 637 | 637 | |
| @@ -501,8 +501,9 @@ static int mvebu_pinctrl_build_functions(struct platform_device *pdev, · 500 unmodified lines | ||
| 501 | 501 | |
| 502 | 502 | /* we allocate functions for number of pins and hope |
| 503 | 503 | * there are fewer unique functions than pins available */ |
| 504 | − funcs = devm_kzalloc(&pdev->dev, funcsize * | |
| 505 | − sizeof(struct mvebu_pinctrl_function), GFP_KERNEL); | |
| 504 | + funcs = devm_kcalloc(&pdev->dev, | |
| 505 | + funcsize, sizeof(struct mvebu_pinctrl_function), | |
| 506 | + GFP_KERNEL); | |
| 506 | 507 | if (!funcs) |
| 507 | 508 | return -ENOMEM; |
| 508 | 509 | |
| @@ -549,8 +550,9 @@ static int mvebu_pinctrl_build_functions(struct platform_device *pdev, · 40 unmodified lines | ||
| 549 | 550 | |
| 550 | 551 | /* allocate group name array if not done already */ |
| 551 | 552 | if (!f->groups) { |
| 552 | − f->groups = devm_kzalloc(&pdev->dev, | |
| 553 | − f->num_groups * sizeof(char *), | |
| 553 | + f->groups = devm_kcalloc(&pdev->dev, | |
| 554 | + f->num_groups, | |
| 555 | + sizeof(char *), | |
| 554 | 556 | GFP_KERNEL); |
| 555 | 557 | if (!f->groups) |
| 556 | 558 | return -ENOMEM; |
| @@ -622,8 +624,10 @@ int mvebu_pinctrl_probe(struct platform_device *pdev) · 65 unmodified lines | ||
| 622 | 624 | } |
| 623 | 625 | } |
| 624 | 626 | |
| 625 | − pdesc = devm_kzalloc(&pdev->dev, pctl->desc.npins * | |
| 626 | − sizeof(struct pinctrl_pin_desc), GFP_KERNEL); | |
| 627 | + pdesc = devm_kcalloc(&pdev->dev, | |
| 628 | + pctl->desc.npins, | |
| 629 | + sizeof(struct pinctrl_pin_desc), | |
| 630 | + GFP_KERNEL); | |
| 627 | 631 | if (!pdesc) |
| 628 | 632 | return -ENOMEM; |
| 629 | 633 | |
| @@ -945,27 +945,30 @@ static int atmel_pinctrl_probe(struct platform_device *pdev) · 944 unmodified lines | ||
| 945 | 945 | return PTR_ERR(atmel_pioctrl->clk); |
| 946 | 946 | } |
| 947 | 947 | |
| 948 | − atmel_pioctrl->pins = devm_kzalloc(dev, sizeof(*atmel_pioctrl->pins) | |
| 949 | − * atmel_pioctrl->npins, GFP_KERNEL); | |
| 948 | + atmel_pioctrl->pins = devm_kcalloc(dev, | |
| 949 | + atmel_pioctrl->npins, | |
| 950 | + sizeof(*atmel_pioctrl->pins), | |
| 951 | + GFP_KERNEL); | |
| 950 | 952 | if (!atmel_pioctrl->pins) |
| 951 | 953 | return -ENOMEM; |
| 952 | 954 | |
| 953 | − pin_desc = devm_kzalloc(dev, sizeof(*pin_desc) | |
| 954 | − * atmel_pioctrl->npins, GFP_KERNEL); | |
| 955 | + pin_desc = devm_kcalloc(dev, atmel_pioctrl->npins, sizeof(*pin_desc), | |
| 956 | + GFP_KERNEL); | |
| 955 | 957 | if (!pin_desc) |
| 956 | 958 | return -ENOMEM; |
| 957 | 959 | atmel_pinctrl_desc.pins = pin_desc; |
| 958 | 960 | atmel_pinctrl_desc.npins = atmel_pioctrl->npins; |
| 959 | 961 | |
| 960 | 962 | /* One pin is one group since a pin can achieve all functions. */ |
| 961 | − group_names = devm_kzalloc(dev, sizeof(*group_names) | |
| 962 | − * atmel_pioctrl->npins, GFP_KERNEL); | |
| 963 | + group_names = devm_kcalloc(dev, | |
| 964 | + atmel_pioctrl->npins, sizeof(*group_names), | |
| 965 | + GFP_KERNEL); | |
| 963 | 966 | if (!group_names) |
| 964 | 967 | return -ENOMEM; |
| 965 | 968 | atmel_pioctrl->group_names = group_names; |
| 966 | 969 | |
| 967 | − atmel_pioctrl->groups = devm_kzalloc(&pdev->dev, | |
| 968 | − sizeof(*atmel_pioctrl->groups) * atmel_pioctrl->npins, | |
| 970 | + atmel_pioctrl->groups = devm_kcalloc(&pdev->dev, | |
| 971 | + atmel_pioctrl->npins, sizeof(*atmel_pioctrl->groups), | |
| 969 | 972 | GFP_KERNEL); |
| 970 | 973 | if (!atmel_pioctrl->groups) |
| 971 | 974 | return -ENOMEM; |
| @@ -1001,20 +1004,24 @@ static int atmel_pinctrl_probe(struct platform_device *pdev) · 29 unmodified lines | ||
| 1001 | 1004 | atmel_pioctrl->gpio_chip->parent = dev; |
| 1002 | 1005 | atmel_pioctrl->gpio_chip->names = atmel_pioctrl->group_names; |
| 1003 | 1006 | |
| 1004 | − atmel_pioctrl->pm_wakeup_sources = devm_kzalloc(dev, | |
| 1005 | − sizeof(*atmel_pioctrl->pm_wakeup_sources) | |
| 1006 | − * atmel_pioctrl->nbanks, GFP_KERNEL); | |
| 1007 | + atmel_pioctrl->pm_wakeup_sources = devm_kcalloc(dev, | |
| 1008 | + atmel_pioctrl->nbanks, | |
| 1009 | + sizeof(*atmel_pioctrl->pm_wakeup_sources), | |
| 1010 | + GFP_KERNEL); | |
| 1007 | 1011 | if (!atmel_pioctrl->pm_wakeup_sources) |
| 1008 | 1012 | return -ENOMEM; |
| 1009 | 1013 | |
| 1010 | − atmel_pioctrl->pm_suspend_backup = devm_kzalloc(dev, | |
| 1011 | − sizeof(*atmel_pioctrl->pm_suspend_backup) | |
| 1012 | − * atmel_pioctrl->nbanks, GFP_KERNEL); | |
| 1014 | + atmel_pioctrl->pm_suspend_backup = devm_kcalloc(dev, | |
| 1015 | + atmel_pioctrl->nbanks, | |
| 1016 | + sizeof(*atmel_pioctrl->pm_suspend_backup), | |
| 1017 | + GFP_KERNEL); | |
| 1013 | 1018 | if (!atmel_pioctrl->pm_suspend_backup) |
| 1014 | 1019 | return -ENOMEM; |
| 1015 | 1020 | |
| 1016 | − atmel_pioctrl->irqs = devm_kzalloc(dev, sizeof(*atmel_pioctrl->irqs) | |
| 1017 | − * atmel_pioctrl->nbanks, GFP_KERNEL); | |
| 1021 | + atmel_pioctrl->irqs = devm_kcalloc(dev, | |
| 1022 | + atmel_pioctrl->nbanks, | |
| 1023 | + sizeof(*atmel_pioctrl->irqs), | |
| 1024 | + GFP_KERNEL); | |
| 1018 | 1025 | if (!atmel_pioctrl->irqs) |
| 1019 | 1026 | return -ENOMEM; |
| 1020 | 1027 | |
| @@ -269,7 +269,8 @@ static int at91_dt_node_to_map(struct pinctrl_dev *pctldev, · 268 unmodified lines | ||
| 269 | 269 | } |
| 270 | 270 | |
| 271 | 271 | map_num += grp->npins; |
| 272 | − new_map = devm_kzalloc(pctldev->dev, sizeof(*new_map) * map_num, GFP_KERNEL); | |
| 272 | + new_map = devm_kcalloc(pctldev->dev, map_num, sizeof(*new_map), | |
| 273 | + GFP_KERNEL); | |
| 273 | 274 | if (!new_map) |
| 274 | 275 | return -ENOMEM; |
| 275 | 276 | |
| @@ -1049,7 +1050,8 @@ static int at91_pinctrl_mux_mask(struct at91_pinctrl *info, · 773 unmodified lines | ||
| 1049 | 1050 | } |
| 1050 | 1051 | info->nmux = size / gpio_banks; |
| 1051 | 1052 | |
| 1052 | − info->mux_mask = devm_kzalloc(info->dev, sizeof(u32) * size, GFP_KERNEL); | |
| 1053 | + info->mux_mask = devm_kcalloc(info->dev, size, sizeof(u32), | |
| 1054 | + GFP_KERNEL); | |
| 1053 | 1055 | if (!info->mux_mask) |
| 1054 | 1056 | return -ENOMEM; |
| 1055 | 1057 | |
| @@ -1087,10 +1089,12 @@ static int at91_pinctrl_parse_groups(struct device_node *np, · 31 unmodified lines | ||
| 1087 | 1089 | } |
| 1088 | 1090 | |
| 1089 | 1091 | grp->npins = size / 4; |
| 1090 | − pin = grp->pins_conf = devm_kzalloc(info->dev, grp->npins * sizeof(struct at91_pmx_pin), | |
| 1091 | − GFP_KERNEL); | |
| 1092 | − grp->pins = devm_kzalloc(info->dev, grp->npins * sizeof(unsigned int), | |
| 1093 | − GFP_KERNEL); | |
| 1092 | + pin = grp->pins_conf = devm_kcalloc(info->dev, | |
| 1093 | + grp->npins, | |
| 1094 | + sizeof(struct at91_pmx_pin), | |
| 1095 | + GFP_KERNEL); | |
| 1096 | + grp->pins = devm_kcalloc(info->dev, grp->npins, sizeof(unsigned int), | |
| 1097 | + GFP_KERNEL); | |
| 1094 | 1098 | if (!grp->pins_conf || !grp->pins) |
| 1095 | 1099 | return -ENOMEM; |
| 1096 | 1100 | |
| @@ -1129,8 +1133,8 @@ static int at91_pinctrl_parse_functions(struct device_node *np, · 32 unmodified lines | ||
| 1129 | 1133 | dev_err(info->dev, "no groups defined\n"); |
| 1130 | 1134 | return -EINVAL; |
| 1131 | 1135 | } |
| 1132 | − func->groups = devm_kzalloc(info->dev, | |
| 1133 | − func->ngroups * sizeof(char *), GFP_KERNEL); | |
| 1136 | + func->groups = devm_kcalloc(info->dev, | |
| 1137 | + func->ngroups, sizeof(char *), GFP_KERNEL); | |
| 1134 | 1138 | if (!func->groups) |
| 1135 | 1139 | return -ENOMEM; |
| 1136 | 1140 | |
| @@ -1192,12 +1196,16 @@ static int at91_pinctrl_probe_dt(struct platform_device *pdev, · 55 unmodified lines | ||
| 1192 | 1196 | |
| 1193 | 1197 | dev_dbg(&pdev->dev, "nfunctions = %d\n", info->nfunctions); |
| 1194 | 1198 | dev_dbg(&pdev->dev, "ngroups = %d\n", info->ngroups); |
| 1195 | − info->functions = devm_kzalloc(&pdev->dev, info->nfunctions * sizeof(struct at91_pmx_func), | |
| 1199 | + info->functions = devm_kcalloc(&pdev->dev, | |
| 1200 | + info->nfunctions, | |
| 1201 | + sizeof(struct at91_pmx_func), | |
| 1196 | 1202 | GFP_KERNEL); |
| 1197 | 1203 | if (!info->functions) |
| 1198 | 1204 | return -ENOMEM; |
| 1199 | 1205 | |
| 1200 | − info->groups = devm_kzalloc(&pdev->dev, info->ngroups * sizeof(struct at91_pin_group), | |
| 1206 | + info->groups = devm_kcalloc(&pdev->dev, | |
| 1207 | + info->ngroups, | |
| 1208 | + sizeof(struct at91_pin_group), | |
| 1201 | 1209 | GFP_KERNEL); |
| 1202 | 1210 | if (!info->groups) |
| 1203 | 1211 | return -ENOMEM; |
| @@ -1256,7 +1264,9 @@ static int at91_pinctrl_probe(struct platform_device *pdev) · 52 unmodified lines | ||
| 1256 | 1264 | at91_pinctrl_desc.name = dev_name(&pdev->dev); |
| 1257 | 1265 | at91_pinctrl_desc.npins = gpio_banks * MAX_NB_GPIO_PER_BANK; |
| 1258 | 1266 | at91_pinctrl_desc.pins = pdesc = |
| 1259 | − devm_kzalloc(&pdev->dev, sizeof(*pdesc) * at91_pinctrl_desc.npins, GFP_KERNEL); | |
| 1267 | + devm_kcalloc(&pdev->dev, | |
| 1268 | + at91_pinctrl_desc.npins, sizeof(*pdesc), | |
| 1269 | + GFP_KERNEL); | |
| 1260 | 1270 | |
| 1261 | 1271 | if (!at91_pinctrl_desc.pins) |
| 1262 | 1272 | return -ENOMEM; |
| @@ -1763,7 +1773,7 @@ static int at91_gpio_probe(struct platform_device *pdev) · 500 unmodified lines | ||
| 1763 | 1773 | chip->ngpio = ngpio; |
| 1764 | 1774 | } |
| 1765 | 1775 | |
| 1766 | − names = devm_kzalloc(&pdev->dev, sizeof(char *) * chip->ngpio, | |
| 1776 | + names = devm_kcalloc(&pdev->dev, chip->ngpio, sizeof(char *), | |
| 1767 | 1777 | GFP_KERNEL); |
| 1768 | 1778 | |
| 1769 | 1779 | if (!names) { |
| @@ -328,7 +328,8 @@ static void axp20x_funcs_groups_from_mask(struct device *dev, unsigned int mask, · 327 unmodified lines | ||
| 328 | 328 | |
| 329 | 329 | func->ngroups = ngroups; |
| 330 | 330 | if (func->ngroups > 0) { |
| 331 | − func->groups = devm_kzalloc(dev, ngroups * sizeof(const char *), | |
| 331 | + func->groups = devm_kcalloc(dev, | |
| 332 | + ngroups, sizeof(const char *), | |
| 332 | 333 | GFP_KERNEL); |
| 333 | 334 | group = func->groups; |
| 334 | 335 | for_each_set_bit(bit, &mask_cpy, mask_len) { |
| @@ -358,8 +359,8 @@ static void axp20x_build_funcs_groups(struct platform_device *pdev) · 23 unmodified lines | ||
| 358 | 359 | /* Every pin supports GPIO_OUT and GPIO_IN functions */ |
| 359 | 360 | for (i = 0; i <= AXP20X_FUNC_GPIO_IN; i++) { |
| 360 | 361 | pctl->funcs[i].ngroups = npins; |
| 361 | − pctl->funcs[i].groups = devm_kzalloc(&pdev->dev, | |
| 362 | − npins * sizeof(char *), | |
| 362 | + pctl->funcs[i].groups = devm_kcalloc(&pdev->dev, | |
| 363 | + npins, sizeof(char *), | |
| 363 | 364 | GFP_KERNEL); |
| 364 | 365 | for (pin = 0; pin < npins; pin++) |
| 365 | 366 | pctl->funcs[i].groups[pin] = pctl->desc->pins[pin].name; |
| @@ -291,10 +291,11 @@ static int dc_pinctrl_probe(struct platform_device *pdev) · 290 unmodified lines | ||
| 291 | 291 | if (IS_ERR(pmap->regs)) |
| 292 | 292 | return PTR_ERR(pmap->regs); |
| 293 | 293 | |
| 294 | − pins = devm_kzalloc(&pdev->dev, sizeof(*pins)*PINS_COUNT, GFP_KERNEL); | |
| 294 | + pins = devm_kcalloc(&pdev->dev, PINS_COUNT, sizeof(*pins), | |
| 295 | + GFP_KERNEL); | |
| 295 | 296 | if (!pins) |
| 296 | 297 | return -ENOMEM; |
| 297 | − pin_names = devm_kzalloc(&pdev->dev, name_len * PINS_COUNT, | |
| 298 | + pin_names = devm_kcalloc(&pdev->dev, PINS_COUNT, name_len, | |
| 298 | 299 | GFP_KERNEL); |
| 299 | 300 | if (!pin_names) |
| 300 | 301 | return -ENOMEM; |
| @@ -770,8 +770,8 @@ static int ingenic_pinctrl_probe(struct platform_device *pdev) · 769 unmodified lines | ||
| 770 | 770 | pctl_desc->pmxops = &ingenic_pmxops; |
| 771 | 771 | pctl_desc->confops = &ingenic_confops; |
| 772 | 772 | pctl_desc->npins = chip_info->num_chips * PINS_PER_GPIO_CHIP; |
| 773 | − pctl_desc->pins = jzpc->pdesc = devm_kzalloc(&pdev->dev, | |
| 774 | − sizeof(*jzpc->pdesc) * pctl_desc->npins, GFP_KERNEL); | |
| 773 | + pctl_desc->pins = jzpc->pdesc = devm_kcalloc(&pdev->dev, | |
| 774 | + pctl_desc->npins, sizeof(*jzpc->pdesc), GFP_KERNEL); | |
| 775 | 775 | if (!jzpc->pdesc) |
| 776 | 776 | return -ENOMEM; |
| 777 | 777 | |
| @@ -158,7 +158,8 @@ static int ltq_pinctrl_dt_node_to_map(struct pinctrl_dev *pctldev, · 157 unmodified lines | ||
| 158 | 158 | |
| 159 | 159 | for_each_child_of_node(np_config, np) |
| 160 | 160 | max_maps += ltq_pinctrl_dt_subnode_size(np); |
| 161 | − *map = kzalloc(max_maps * sizeof(struct pinctrl_map) * 2, GFP_KERNEL); | |
| 161 | + *map = kzalloc(array3_size(max_maps, sizeof(struct pinctrl_map), 2), | |
| 162 | + GFP_KERNEL); | |
| 162 | 163 | if (!*map) |
| 163 | 164 | return -ENOMEM; |
| 164 | 165 | tmp = *map; |
| @@ -1308,8 +1308,9 @@ static int lpc18xx_create_group_func_map(struct device *dev, · 1307 unmodified lines | ||
| 1308 | 1308 | } |
| 1309 | 1309 | |
| 1310 | 1310 | scu->func[func].ngroups = ngroups; |
| 1311 | − scu->func[func].groups = devm_kzalloc(dev, ngroups * | |
| 1312 | − sizeof(char *), GFP_KERNEL); | |
| 1311 | + scu->func[func].groups = devm_kcalloc(dev, | |
| 1312 | + ngroups, sizeof(char *), | |
| 1313 | + GFP_KERNEL); | |
| 1313 | 1314 | if (!scu->func[func].groups) |
| 1314 | 1315 | return -ENOMEM; |
| 1315 | 1316 | |
| @@ -330,7 +330,8 @@ static int ocelot_create_group_func_map(struct device *dev, · 329 unmodified lines | ||
| 330 | 330 | } |
| 331 | 331 | |
| 332 | 332 | info->func[f].ngroups = npins; |
| 333 | − info->func[f].groups = devm_kzalloc(dev, npins * | |
| 333 | + info->func[f].groups = devm_kcalloc(dev, | |
| 334 | + npins, | |
| 334 | 335 | sizeof(char *), |
| 335 | 336 | GFP_KERNEL); |
| 336 | 337 | if (!info->func[f].groups) |
| @@ -507,7 +507,7 @@ static int rockchip_dt_node_to_map(struct pinctrl_dev *pctldev, · 506 unmodified lines | ||
| 507 | 507 | } |
| 508 | 508 | |
| 509 | 509 | map_num += grp->npins; |
| 510 | − new_map = devm_kzalloc(pctldev->dev, sizeof(*new_map) * map_num, | |
| 510 | + new_map = devm_kcalloc(pctldev->dev, map_num, sizeof(*new_map), | |
| 511 | 511 | GFP_KERNEL); |
| 512 | 512 | if (!new_map) |
| 513 | 513 | return -ENOMEM; |
| @@ -2473,10 +2473,11 @@ static int rockchip_pinctrl_parse_groups(struct device_node *np, · 1959 unmodified lines | ||
| 2473 | 2473 | |
| 2474 | 2474 | grp->npins = size / 4; |
| 2475 | 2475 | |
| 2476 | − grp->pins = devm_kzalloc(info->dev, grp->npins * sizeof(unsigned int), | |
| 2476 | + grp->pins = devm_kcalloc(info->dev, grp->npins, sizeof(unsigned int), | |
| 2477 | 2477 | GFP_KERNEL); |
| 2478 | − grp->data = devm_kzalloc(info->dev, grp->npins * | |
| 2479 | − sizeof(struct rockchip_pin_config), | |
| 2478 | + grp->data = devm_kcalloc(info->dev, | |
| 2479 | + grp->npins, | |
| 2480 | + sizeof(struct rockchip_pin_config), | |
| 2480 | 2481 | GFP_KERNEL); |
| 2481 | 2482 | if (!grp->pins || !grp->data) |
| 2482 | 2483 | return -ENOMEM; |
| @@ -2528,8 +2529,8 @@ static int rockchip_pinctrl_parse_functions(struct device_node *np, · 45 unmodified lines | ||
| 2528 | 2529 | if (func->ngroups <= 0) |
| 2529 | 2530 | return 0; |
| 2530 | 2531 | |
| 2531 | − func->groups = devm_kzalloc(info->dev, | |
| 2532 | − func->ngroups * sizeof(char *), GFP_KERNEL); | |
| 2532 | + func->groups = devm_kcalloc(info->dev, | |
| 2533 | + func->ngroups, sizeof(char *), GFP_KERNEL); | |
| 2533 | 2534 | if (!func->groups) |
| 2534 | 2535 | return -ENOMEM; |
| 2535 | 2536 | |
| @@ -2560,13 +2561,15 @@ static int rockchip_pinctrl_parse_dt(struct platform_device *pdev, · 24 unmodified lines | ||
| 2560 | 2561 | dev_dbg(&pdev->dev, "nfunctions = %d\n", info->nfunctions); |
| 2561 | 2562 | dev_dbg(&pdev->dev, "ngroups = %d\n", info->ngroups); |
| 2562 | 2563 | |
| 2563 | − info->functions = devm_kzalloc(dev, info->nfunctions * | |
| 2564 | + info->functions = devm_kcalloc(dev, | |
| 2565 | + info->nfunctions, | |
| 2564 | 2566 | sizeof(struct rockchip_pmx_func), |
| 2565 | 2567 | GFP_KERNEL); |
| 2566 | 2568 | if (!info->functions) |
| 2567 | 2569 | return -EINVAL; |
| 2568 | 2570 | |
| 2569 | − info->groups = devm_kzalloc(dev, info->ngroups * | |
| 2571 | + info->groups = devm_kcalloc(dev, | |
| 2572 | + info->ngroups, | |
| 2570 | 2573 | sizeof(struct rockchip_pin_group), |
| 2571 | 2574 | GFP_KERNEL); |
| 2572 | 2575 | if (!info->groups) |
| @@ -2604,8 +2607,9 @@ static int rockchip_pinctrl_register(struct platform_device *pdev, · 31 unmodified lines | ||
| 2604 | 2607 | ctrldesc->pmxops = &rockchip_pmx_ops; |
| 2605 | 2608 | ctrldesc->confops = &rockchip_pinconf_ops; |
| 2606 | 2609 | |
| 2607 | − pindesc = devm_kzalloc(&pdev->dev, sizeof(*pindesc) * | |
| 2608 | − info->ctrl->nr_pins, GFP_KERNEL); | |
| 2610 | + pindesc = devm_kcalloc(&pdev->dev, | |
| 2611 | + info->ctrl->nr_pins, sizeof(*pindesc), | |
| 2612 | + GFP_KERNEL); | |
| 2609 | 2613 | if (!pindesc) |
| 2610 | 2614 | return -ENOMEM; |
| 2611 | 2615 | |
| @@ -712,8 +712,8 @@ static int pcs_allocate_pin_table(struct pcs_device *pcs) · 711 unmodified lines | ||
| 712 | 712 | } |
| 713 | 713 | |
| 714 | 714 | dev_dbg(pcs->dev, "allocating %i pins\n", nr_pins); |
| 715 | − pcs->pins.pa = devm_kzalloc(pcs->dev, | |
| 716 | − sizeof(*pcs->pins.pa) * nr_pins, | |
| 715 | + pcs->pins.pa = devm_kcalloc(pcs->dev, | |
| 716 | + nr_pins, sizeof(*pcs->pins.pa), | |
| 717 | 717 | GFP_KERNEL); |
| 718 | 718 | if (!pcs->pins.pa) |
| 719 | 719 | return -ENOMEM; |
| @@ -924,15 +924,15 @@ static int pcs_parse_pinconf(struct pcs_device *pcs, struct device_node *np, · 204 unmodified lines | ||
| 924 | 924 | if (!nconfs) |
| 925 | 925 | return 0; |
| 926 | 926 | |
| 927 | − func->conf = devm_kzalloc(pcs->dev, | |
| 928 | − sizeof(struct pcs_conf_vals) * nconfs, | |
| 927 | + func->conf = devm_kcalloc(pcs->dev, | |
| 928 | + nconfs, sizeof(struct pcs_conf_vals), | |
| 929 | 929 | GFP_KERNEL); |
| 930 | 930 | if (!func->conf) |
| 931 | 931 | return -ENOMEM; |
| 932 | 932 | func->nconfs = nconfs; |
| 933 | 933 | conf = &(func->conf[0]); |
| 934 | 934 | m++; |
| 935 | − settings = devm_kzalloc(pcs->dev, sizeof(unsigned long) * nconfs, | |
| 935 | + settings = devm_kcalloc(pcs->dev, nconfs, sizeof(unsigned long), | |
| 936 | 936 | GFP_KERNEL); |
| 937 | 937 | if (!settings) |
| 938 | 938 | return -ENOMEM; |
| @@ -988,11 +988,11 @@ static int pcs_parse_one_pinctrl_entry(struct pcs_device *pcs, · 49 unmodified lines | ||
| 988 | 988 | return -EINVAL; |
| 989 | 989 | } |
| 990 | 990 | |
| 991 | − vals = devm_kzalloc(pcs->dev, sizeof(*vals) * rows, GFP_KERNEL); | |
| 991 | + vals = devm_kcalloc(pcs->dev, rows, sizeof(*vals), GFP_KERNEL); | |
| 992 | 992 | if (!vals) |
| 993 | 993 | return -ENOMEM; |
| 994 | 994 | |
| 995 | − pins = devm_kzalloc(pcs->dev, sizeof(*pins) * rows, GFP_KERNEL); | |
| 995 | + pins = devm_kcalloc(pcs->dev, rows, sizeof(*pins), GFP_KERNEL); | |
| 996 | 996 | if (!pins) |
| 997 | 997 | goto free_vals; |
| 998 | 998 | |
| @@ -1089,13 +1089,15 @@ static int pcs_parse_bits_in_pinctrl_entry(struct pcs_device *pcs, · 90 unmodified lines | ||
| 1089 | 1089 | |
| 1090 | 1090 | npins_in_row = pcs->width / pcs->bits_per_pin; |
| 1091 | 1091 | |
| 1092 | − vals = devm_kzalloc(pcs->dev, sizeof(*vals) * rows * npins_in_row, | |
| 1093 | − GFP_KERNEL); | |
| 1092 | + vals = devm_kzalloc(pcs->dev, | |
| 1093 | + array3_size(rows, npins_in_row, sizeof(*vals)), | |
| 1094 | + GFP_KERNEL); | |
| 1094 | 1095 | if (!vals) |
| 1095 | 1096 | return -ENOMEM; |
| 1096 | 1097 | |
| 1097 | − pins = devm_kzalloc(pcs->dev, sizeof(*pins) * rows * npins_in_row, | |
| 1098 | − GFP_KERNEL); | |
| 1098 | + pins = devm_kzalloc(pcs->dev, | |
| 1099 | + array3_size(rows, npins_in_row, sizeof(*pins)), | |
| 1100 | + GFP_KERNEL); | |
| 1099 | 1101 | if (!pins) |
| 1100 | 1102 | goto free_vals; |
| 1101 | 1103 | |
| @@ -1217,7 +1219,7 @@ static int pcs_dt_node_to_map(struct pinctrl_dev *pctldev, · 115 unmodified lines | ||
| 1217 | 1219 | pcs = pinctrl_dev_get_drvdata(pctldev); |
| 1218 | 1220 | |
| 1219 | 1221 | /* create 2 maps. One is for pinmux, and the other is for pinconf. */ |
| 1220 | − *map = devm_kzalloc(pcs->dev, sizeof(**map) * 2, GFP_KERNEL); | |
| 1222 | + *map = devm_kcalloc(pcs->dev, 2, sizeof(**map), GFP_KERNEL); | |
| 1221 | 1223 | if (!*map) |
| 1222 | 1224 | return -ENOMEM; |
| 1223 | 1225 | |
| @@ -823,8 +823,8 @@ static int st_pctl_dt_node_to_map(struct pinctrl_dev *pctldev, · 822 unmodified lines | ||
| 823 | 823 | } |
| 824 | 824 | |
| 825 | 825 | map_num = grp->npins + 1; |
| 826 | − new_map = devm_kzalloc(pctldev->dev, | |
| 827 | − sizeof(*new_map) * map_num, GFP_KERNEL); | |
| 826 | + new_map = devm_kcalloc(pctldev->dev, | |
| 827 | + map_num, sizeof(*new_map), GFP_KERNEL); | |
| 828 | 828 | if (!new_map) |
| 829 | 829 | return -ENOMEM; |
| 830 | 830 | |
| @@ -1191,9 +1191,9 @@ static int st_pctl_dt_parse_groups(struct device_node *np, · 360 unmodified lines | ||
| 1191 | 1191 | |
| 1192 | 1192 | grp->npins = npins; |
| 1193 | 1193 | grp->name = np->name; |
| 1194 | − grp->pins = devm_kzalloc(info->dev, npins * sizeof(u32), GFP_KERNEL); | |
| 1195 | − grp->pin_conf = devm_kzalloc(info->dev, | |
| 1196 | − npins * sizeof(*conf), GFP_KERNEL); | |
| 1194 | + grp->pins = devm_kcalloc(info->dev, npins, sizeof(u32), GFP_KERNEL); | |
| 1195 | + grp->pin_conf = devm_kcalloc(info->dev, | |
| 1196 | + npins, sizeof(*conf), GFP_KERNEL); | |
| 1197 | 1197 | |
| 1198 | 1198 | if (!grp->pins || !grp->pin_conf) |
| 1199 | 1199 | return -ENOMEM; |
| @@ -1249,8 +1249,8 @@ static int st_pctl_parse_functions(struct device_node *np, · 49 unmodified lines | ||
| 1249 | 1249 | dev_err(info->dev, "No groups defined\n"); |
| 1250 | 1250 | return -EINVAL; |
| 1251 | 1251 | } |
| 1252 | − func->groups = devm_kzalloc(info->dev, | |
| 1253 | − func->ngroups * sizeof(char *), GFP_KERNEL); | |
| 1252 | + func->groups = devm_kcalloc(info->dev, | |
| 1253 | + func->ngroups, sizeof(char *), GFP_KERNEL); | |
| 1254 | 1254 | if (!func->groups) |
| 1255 | 1255 | return -ENOMEM; |
| 1256 | 1256 | |
| @@ -1573,14 +1573,15 @@ static int st_pctl_probe_dt(struct platform_device *pdev, · 316 unmodified lines | ||
| 1573 | 1573 | dev_info(&pdev->dev, "nfunctions = %d\n", info->nfunctions); |
| 1574 | 1574 | dev_info(&pdev->dev, "ngroups = %d\n", info->ngroups); |
| 1575 | 1575 | |
| 1576 | − info->functions = devm_kzalloc(&pdev->dev, | |
| 1577 | − info->nfunctions * sizeof(*info->functions), GFP_KERNEL); | |
| 1576 | + info->functions = devm_kcalloc(&pdev->dev, | |
| 1577 | + info->nfunctions, sizeof(*info->functions), GFP_KERNEL); | |
| 1578 | 1578 | |
| 1579 | − info->groups = devm_kzalloc(&pdev->dev, | |
| 1580 | − info->ngroups * sizeof(*info->groups) , GFP_KERNEL); | |
| 1579 | + info->groups = devm_kcalloc(&pdev->dev, | |
| 1580 | + info->ngroups, sizeof(*info->groups), | |
| 1581 | + GFP_KERNEL); | |
| 1581 | 1582 | |
| 1582 | − info->banks = devm_kzalloc(&pdev->dev, | |
| 1583 | − info->nbanks * sizeof(*info->banks), GFP_KERNEL); | |
| 1583 | + info->banks = devm_kcalloc(&pdev->dev, | |
| 1584 | + info->nbanks, sizeof(*info->banks), GFP_KERNEL); | |
| 1584 | 1585 | |
| 1585 | 1586 | if (!info->functions || !info->groups || !info->banks) |
| 1586 | 1587 | return -ENOMEM; |
| @@ -1608,8 +1609,8 @@ static int st_pctl_probe_dt(struct platform_device *pdev, · 21 unmodified lines | ||
| 1608 | 1609 | } |
| 1609 | 1610 | |
| 1610 | 1611 | pctl_desc->npins = info->nbanks * ST_GPIO_PINS_PER_BANK; |
| 1611 | − pdesc = devm_kzalloc(&pdev->dev, | |
| 1612 | − sizeof(*pdesc) * pctl_desc->npins, GFP_KERNEL); | |
| 1612 | + pdesc = devm_kcalloc(&pdev->dev, | |
| 1613 | + pctl_desc->npins, sizeof(*pdesc), GFP_KERNEL); | |
| 1613 | 1614 | if (!pdesc) |
| 1614 | 1615 | return -ENOMEM; |
| 1615 | 1616 | |
| @@ -1727,8 +1727,8 @@ static int pinmux_xway_probe(struct platform_device *pdev) · 1726 unmodified lines | ||
| 1727 | 1727 | xway_chip.ngpio = xway_soc->pin_count; |
| 1728 | 1728 | |
| 1729 | 1729 | /* load our pad descriptors */ |
| 1730 | − xway_info.pads = devm_kzalloc(&pdev->dev, | |
| 1731 | − sizeof(struct pinctrl_pin_desc) * xway_chip.ngpio, | |
| 1730 | + xway_info.pads = devm_kcalloc(&pdev->dev, | |
| 1731 | + xway_chip.ngpio, sizeof(struct pinctrl_pin_desc), | |
| 1732 | 1732 | GFP_KERNEL); |
| 1733 | 1733 | if (!xway_info.pads) |
| 1734 | 1734 | return -ENOMEM; |
| @@ -491,8 +491,9 @@ int exynos_eint_wkup_init(struct samsung_pinctrl_drv_data *d) · 490 unmodified lines | ||
| 491 | 491 | continue; |
| 492 | 492 | } |
| 493 | 493 | |
| 494 | − weint_data = devm_kzalloc(dev, bank->nr_pins | |
| 495 | − * sizeof(*weint_data), GFP_KERNEL); | |
| 494 | + weint_data = devm_kcalloc(dev, | |
| 495 | + bank->nr_pins, sizeof(*weint_data), | |
| 496 | + GFP_KERNEL); | |
| 496 | 497 | if (!weint_data) |
| 497 | 498 | return -ENOMEM; |
| 498 | 499 | |
| @@ -674,7 +674,7 @@ static struct samsung_pin_group *samsung_pinctrl_create_groups( · 673 unmodified lines | ||
| 674 | 674 | const struct pinctrl_pin_desc *pdesc; |
| 675 | 675 | int i; |
| 676 | 676 | |
| 677 | − groups = devm_kzalloc(dev, ctrldesc->npins * sizeof(*groups), | |
| 677 | + groups = devm_kcalloc(dev, ctrldesc->npins, sizeof(*groups), | |
| 678 | 678 | GFP_KERNEL); |
| 679 | 679 | if (!groups) |
| 680 | 680 | return ERR_PTR(-EINVAL); |
| @@ -711,7 +711,7 @@ static int samsung_pinctrl_create_function(struct device *dev, · 30 unmodified lines | ||
| 711 | 711 | |
| 712 | 712 | func->name = func_np->full_name; |
| 713 | 713 | |
| 714 | − func->groups = devm_kzalloc(dev, npins * sizeof(char *), GFP_KERNEL); | |
| 714 | + func->groups = devm_kcalloc(dev, npins, sizeof(char *), GFP_KERNEL); | |
| 715 | 715 | if (!func->groups) |
| 716 | 716 | return -ENOMEM; |
| 717 | 717 | |
| @@ -768,7 +768,7 @@ static struct samsung_pmx_func *samsung_pinctrl_create_functions( · 50 unmodified lines | ||
| 768 | 768 | } |
| 769 | 769 | } |
| 770 | 770 | |
| 771 | − functions = devm_kzalloc(dev, func_cnt * sizeof(*functions), | |
| 771 | + functions = devm_kcalloc(dev, func_cnt, sizeof(*functions), | |
| 772 | 772 | GFP_KERNEL); |
| 773 | 773 | if (!functions) |
| 774 | 774 | return ERR_PTR(-ENOMEM); |
| @@ -860,8 +860,9 @@ static int samsung_pinctrl_register(struct platform_device *pdev, · 85 unmodified lines | ||
| 860 | 860 | ctrldesc->pmxops = &samsung_pinmux_ops; |
| 861 | 861 | ctrldesc->confops = &samsung_pinconf_ops; |
| 862 | 862 | |
| 863 | − pindesc = devm_kzalloc(&pdev->dev, sizeof(*pindesc) * | |
| 864 | − drvdata->nr_pins, GFP_KERNEL); | |
| 863 | + pindesc = devm_kcalloc(&pdev->dev, | |
| 864 | + drvdata->nr_pins, sizeof(*pindesc), | |
| 865 | + GFP_KERNEL); | |
| 865 | 866 | if (!pindesc) |
| 866 | 867 | return -ENOMEM; |
| 867 | 868 | ctrldesc->pins = pindesc; |
| @@ -875,8 +876,10 @@ static int samsung_pinctrl_register(struct platform_device *pdev, · 7 unmodified lines | ||
| 875 | 876 | * allocate space for storing the dynamically generated names for all |
| 876 | 877 | * the pins which belong to this pin-controller. |
| 877 | 878 | */ |
| 878 | − pin_names = devm_kzalloc(&pdev->dev, sizeof(char) * PIN_NAME_LENGTH * | |
| 879 | − drvdata->nr_pins, GFP_KERNEL); | |
| 879 | + pin_names = devm_kzalloc(&pdev->dev, | |
| 880 | + array3_size(sizeof(char), PIN_NAME_LENGTH, | |
| 881 | + drvdata->nr_pins), | |
| 882 | + GFP_KERNEL); | |
| 880 | 883 | if (!pin_names) |
| 881 | 884 | return -ENOMEM; |
| 882 | 885 | |
| @@ -57,7 +57,7 @@ static int sh_pfc_map_resources(struct sh_pfc *pfc, · 56 unmodified lines | ||
| 57 | 57 | return -EINVAL; |
| 58 | 58 | |
| 59 | 59 | /* Allocate memory windows and IRQs arrays. */ |
| 60 | − windows = devm_kzalloc(pfc->dev, num_windows * sizeof(*windows), | |
| 60 | + windows = devm_kcalloc(pfc->dev, num_windows, sizeof(*windows), | |
| 61 | 61 | GFP_KERNEL); |
| 62 | 62 | if (windows == NULL) |
| 63 | 63 | return -ENOMEM; |
| @@ -66,7 +66,7 @@ static int sh_pfc_map_resources(struct sh_pfc *pfc, · 2 unmodified lines | ||
| 66 | 66 | pfc->windows = windows; |
| 67 | 67 | |
| 68 | 68 | if (num_irqs) { |
| 69 | − irqs = devm_kzalloc(pfc->dev, num_irqs * sizeof(*irqs), | |
| 69 | + irqs = devm_kcalloc(pfc->dev, num_irqs, sizeof(*irqs), | |
| 70 | 70 | GFP_KERNEL); |
| 71 | 71 | if (irqs == NULL) |
| 72 | 72 | return -ENOMEM; |
| @@ -444,7 +444,7 @@ static int sh_pfc_init_ranges(struct sh_pfc *pfc) · 371 unmodified lines | ||
| 444 | 444 | } |
| 445 | 445 | |
| 446 | 446 | pfc->nr_ranges = nr_ranges; |
| 447 | − pfc->ranges = devm_kzalloc(pfc->dev, sizeof(*pfc->ranges) * nr_ranges, | |
| 447 | + pfc->ranges = devm_kcalloc(pfc->dev, nr_ranges, sizeof(*pfc->ranges), | |
| 448 | 448 | GFP_KERNEL); |
| 449 | 449 | if (pfc->ranges == NULL) |
| 450 | 450 | return -ENOMEM; |
| @@ -107,7 +107,7 @@ static int gpio_setup_data_regs(struct sh_pfc_chip *chip) · 106 unmodified lines | ||
| 107 | 107 | for (i = 0; pfc->info->data_regs[i].reg_width; ++i) |
| 108 | 108 | ; |
| 109 | 109 | |
| 110 | − chip->regs = devm_kzalloc(pfc->dev, i * sizeof(*chip->regs), | |
| 110 | + chip->regs = devm_kcalloc(pfc->dev, i, sizeof(*chip->regs), | |
| 111 | 111 | GFP_KERNEL); |
| 112 | 112 | if (chip->regs == NULL) |
| 113 | 113 | return -ENOMEM; |
| @@ -224,8 +224,9 @@ static int gpio_pin_setup(struct sh_pfc_chip *chip) · 110 unmodified lines | ||
| 224 | 224 | struct gpio_chip *gc = &chip->gpio_chip; |
| 225 | 225 | int ret; |
| 226 | 226 | |
| 227 | − chip->pins = devm_kzalloc(pfc->dev, pfc->info->nr_pins * | |
| 228 | − sizeof(*chip->pins), GFP_KERNEL); | |
| 227 | + chip->pins = devm_kcalloc(pfc->dev, | |
| 228 | + pfc->info->nr_pins, sizeof(*chip->pins), | |
| 229 | + GFP_KERNEL); | |
| 229 | 230 | if (chip->pins == NULL) |
| 230 | 231 | return -ENOMEM; |
| 231 | 232 | |
| @@ -770,14 +770,14 @@ static int sh_pfc_map_pins(struct sh_pfc *pfc, struct sh_pfc_pinctrl *pmx) · 769 unmodified lines | ||
| 770 | 770 | unsigned int i; |
| 771 | 771 | |
| 772 | 772 | /* Allocate and initialize the pins and configs arrays. */ |
| 773 | − pmx->pins = devm_kzalloc(pfc->dev, | |
| 774 | − sizeof(*pmx->pins) * pfc->info->nr_pins, | |
| 773 | + pmx->pins = devm_kcalloc(pfc->dev, | |
| 774 | + pfc->info->nr_pins, sizeof(*pmx->pins), | |
| 775 | 775 | GFP_KERNEL); |
| 776 | 776 | if (unlikely(!pmx->pins)) |
| 777 | 777 | return -ENOMEM; |
| 778 | 778 | |
| 779 | − pmx->configs = devm_kzalloc(pfc->dev, | |
| 780 | − sizeof(*pmx->configs) * pfc->info->nr_pins, | |
| 779 | + pmx->configs = devm_kcalloc(pfc->dev, | |
| 780 | + pfc->info->nr_pins, sizeof(*pmx->configs), | |
| 781 | 781 | GFP_KERNEL); |
| 782 | 782 | if (unlikely(!pmx->configs)) |
| 783 | 783 | return -ENOMEM; |
| @@ -108,7 +108,7 @@ static int sirfsoc_dt_node_to_map(struct pinctrl_dev *pctldev, · 107 unmodified lines | ||
| 108 | 108 | return -ENODEV; |
| 109 | 109 | } |
| 110 | 110 | |
| 111 | − *map = kzalloc(sizeof(**map) * count, GFP_KERNEL); | |
| 111 | + *map = kcalloc(count, sizeof(**map), GFP_KERNEL); | |
| 112 | 112 | if (!*map) |
| 113 | 113 | return -ENOMEM; |
| 114 | 114 | |
| @@ -538,9 +538,9 @@ static int plgpio_probe(struct platform_device *pdev) · 537 unmodified lines | ||
| 538 | 538 | dev_warn(&pdev->dev, "clk_get() failed, work without it\n"); |
| 539 | 539 | |
| 540 | 540 | #ifdef CONFIG_PM_SLEEP |
| 541 | − plgpio->csave_regs = devm_kzalloc(&pdev->dev, | |
| 542 | − sizeof(*plgpio->csave_regs) * | |
| 541 | + plgpio->csave_regs = devm_kcalloc(&pdev->dev, | |
| 543 | 542 | DIV_ROUND_UP(plgpio->chip.ngpio, MAX_GPIO_PER_REG), |
| 543 | + sizeof(*plgpio->csave_regs), | |
| 544 | 544 | GFP_KERNEL); |
| 545 | 545 | if (!plgpio->csave_regs) |
| 546 | 546 | return -ENOMEM; |
| @@ -172,7 +172,7 @@ static int spear_pinctrl_dt_node_to_map(struct pinctrl_dev *pctldev, · 171 unmodified lines | ||
| 172 | 172 | return -ENODEV; |
| 173 | 173 | } |
| 174 | 174 | |
| 175 | − *map = kzalloc(sizeof(**map) * count, GFP_KERNEL); | |
| 175 | + *map = kcalloc(count, sizeof(**map), GFP_KERNEL); | |
| 176 | 176 | if (!*map) |
| 177 | 177 | return -ENOMEM; |
| 178 | 178 | |
| @@ -879,8 +879,9 @@ static int sprd_pinctrl_parse_groups(struct device_node *np, · 878 unmodified lines | ||
| 879 | 879 | |
| 880 | 880 | grp->name = np->name; |
| 881 | 881 | grp->npins = ret; |
| 882 | − grp->pins = devm_kzalloc(sprd_pctl->dev, grp->npins * | |
| 883 | − sizeof(unsigned int), GFP_KERNEL); | |
| 882 | + grp->pins = devm_kcalloc(sprd_pctl->dev, | |
| 883 | + grp->npins, sizeof(unsigned int), | |
| 884 | + GFP_KERNEL); | |
| 884 | 885 | if (!grp->pins) |
| 885 | 886 | return -ENOMEM; |
| 886 | 887 | |
| @@ -931,14 +932,15 @@ static int sprd_pinctrl_parse_dt(struct sprd_pinctrl *sprd_pctl) · 44 unmodified lines | ||
| 931 | 932 | if (!info->ngroups) |
| 932 | 933 | return 0; |
| 933 | 934 | |
| 934 | − info->groups = devm_kzalloc(sprd_pctl->dev, info->ngroups * | |
| 935 | + info->groups = devm_kcalloc(sprd_pctl->dev, | |
| 936 | + info->ngroups, | |
| 935 | 937 | sizeof(struct sprd_pin_group), |
| 936 | 938 | GFP_KERNEL); |
| 937 | 939 | if (!info->groups) |
| 938 | 940 | return -ENOMEM; |
| 939 | 941 | |
| 940 | − info->grp_names = devm_kzalloc(sprd_pctl->dev, | |
| 941 | − info->ngroups * sizeof(char *), | |
| 942 | + info->grp_names = devm_kcalloc(sprd_pctl->dev, | |
| 943 | + info->ngroups, sizeof(char *), | |
| 942 | 944 | GFP_KERNEL); |
| 943 | 945 | if (!info->grp_names) |
| 944 | 946 | return -ENOMEM; |
| @@ -980,8 +982,8 @@ static int sprd_pinctrl_add_pins(struct sprd_pinctrl *sprd_pctl, · 35 unmodified lines | ||
| 980 | 982 | int i; |
| 981 | 983 | |
| 982 | 984 | info->npins = pins_cnt; |
| 983 | − info->pins = devm_kzalloc(sprd_pctl->dev, | |
| 984 | − info->npins * sizeof(struct sprd_pin), | |
| 985 | + info->pins = devm_kcalloc(sprd_pctl->dev, | |
| 986 | + info->npins, sizeof(struct sprd_pin), | |
| 985 | 987 | GFP_KERNEL); |
| 986 | 988 | if (!info->pins) |
| 987 | 989 | return -ENOMEM; |
| @@ -1057,7 +1059,8 @@ int sprd_pinctrl_core_probe(struct platform_device *pdev, · 69 unmodified lines | ||
| 1057 | 1059 | return ret; |
| 1058 | 1060 | } |
| 1059 | 1061 | |
| 1060 | − pin_desc = devm_kzalloc(&pdev->dev, pinctrl_info->npins * | |
| 1062 | + pin_desc = devm_kcalloc(&pdev->dev, | |
| 1063 | + pinctrl_info->npins, | |
| 1061 | 1064 | sizeof(struct pinctrl_pin_desc), |
| 1062 | 1065 | GFP_KERNEL); |
| 1063 | 1066 | if (!pin_desc) |
| @@ -277,7 +277,7 @@ static unsigned long *sunxi_pctrl_build_pin_config(struct device_node *node, · 276 unmodified lines | ||
| 277 | 277 | if (!configlen) |
| 278 | 278 | return NULL; |
| 279 | 279 | |
| 280 | − pinconfig = kzalloc(configlen * sizeof(*pinconfig), GFP_KERNEL); | |
| 280 | + pinconfig = kcalloc(configlen, sizeof(*pinconfig), GFP_KERNEL); | |
| 281 | 281 | if (!pinconfig) |
| 282 | 282 | return ERR_PTR(-ENOMEM); |
| 283 | 283 | |
| @@ -352,7 +352,7 @@ static int sunxi_pctrl_dt_node_to_map(struct pinctrl_dev *pctldev, · 68 unmodified lines | ||
| 352 | 352 | * any configuration. |
| 353 | 353 | */ |
| 354 | 354 | nmaps = npins * 2; |
| 355 | − *map = kmalloc(nmaps * sizeof(struct pinctrl_map), GFP_KERNEL); | |
| 355 | + *map = kmalloc_array(nmaps, sizeof(struct pinctrl_map), GFP_KERNEL); | |
| 356 | 356 | if (!*map) |
| 357 | 357 | return -ENOMEM; |
| 358 | 358 | |
| @@ -1055,8 +1055,8 @@ static int sunxi_pinctrl_build_state(struct platform_device *pdev) · 696 unmodified lines | ||
| 1055 | 1055 | * this means that the number of pins is the maximum group |
| 1056 | 1056 | * number we will ever see. |
| 1057 | 1057 | */ |
| 1058 | − pctl->groups = devm_kzalloc(&pdev->dev, | |
| 1059 | − pctl->desc->npins * sizeof(*pctl->groups), | |
| 1058 | + pctl->groups = devm_kcalloc(&pdev->dev, | |
| 1059 | + pctl->desc->npins, sizeof(*pctl->groups), | |
| 1060 | 1060 | GFP_KERNEL); |
| 1061 | 1061 | if (!pctl->groups) |
| 1062 | 1062 | return -ENOMEM; |
| @@ -1079,8 +1079,9 @@ static int sunxi_pinctrl_build_state(struct platform_device *pdev) · 16 unmodified lines | ||
| 1079 | 1079 | * We suppose that we won't have any more functions than pins, |
| 1080 | 1080 | * we'll reallocate that later anyway |
| 1081 | 1081 | */ |
| 1082 | − pctl->functions = devm_kzalloc(&pdev->dev, | |
| 1083 | − pctl->ngroups * sizeof(*pctl->functions), | |
| 1082 | + pctl->functions = devm_kcalloc(&pdev->dev, | |
| 1083 | + pctl->ngroups, | |
| 1084 | + sizeof(*pctl->functions), | |
| 1084 | 1085 | GFP_KERNEL); |
| 1085 | 1086 | if (!pctl->functions) |
| 1086 | 1087 | return -ENOMEM; |
| @@ -1137,8 +1138,9 @@ static int sunxi_pinctrl_build_state(struct platform_device *pdev) · 50 unmodified lines | ||
| 1137 | 1138 | |
| 1138 | 1139 | if (!func_item->groups) { |
| 1139 | 1140 | func_item->groups = |
| 1140 | − devm_kzalloc(&pdev->dev, | |
| 1141 | − func_item->ngroups * sizeof(*func_item->groups), | |
| 1141 | + devm_kcalloc(&pdev->dev, | |
| 1142 | + func_item->ngroups, | |
| 1143 | + sizeof(*func_item->groups), | |
| 1142 | 1144 | GFP_KERNEL); |
| 1143 | 1145 | if (!func_item->groups) |
| 1144 | 1146 | return -ENOMEM; |
| @@ -1281,8 +1283,8 @@ int sunxi_pinctrl_init_with_variant(struct platform_device *pdev, · 136 unmodified lines | ||
| 1281 | 1283 | return ret; |
| 1282 | 1284 | } |
| 1283 | 1285 | |
| 1284 | − pins = devm_kzalloc(&pdev->dev, | |
| 1285 | − pctl->desc->npins * sizeof(*pins), | |
| 1286 | + pins = devm_kcalloc(&pdev->dev, | |
| 1287 | + pctl->desc->npins, sizeof(*pins), | |
| 1286 | 1288 | GFP_KERNEL); |
| 1287 | 1289 | if (!pins) |
| 1288 | 1290 | return -ENOMEM; |
| @@ -665,8 +665,8 @@ int tegra_pinctrl_probe(struct platform_device *pdev, · 664 unmodified lines | ||
| 665 | 665 | * Each mux group will appear in 4 functions' list of groups. |
| 666 | 666 | * This over-allocates slightly, since not all groups are mux groups. |
| 667 | 667 | */ |
| 668 | − pmx->group_pins = devm_kzalloc(&pdev->dev, | |
| 669 | − soc_data->ngroups * 4 * sizeof(*pmx->group_pins), | |
| 668 | + pmx->group_pins = devm_kcalloc(&pdev->dev, | |
| 669 | + soc_data->ngroups * 4, sizeof(*pmx->group_pins), | |
| 670 | 670 | GFP_KERNEL); |
| 671 | 671 | if (!pmx->group_pins) |
| 672 | 672 | return -ENOMEM; |
| @@ -708,7 +708,7 @@ int tegra_pinctrl_probe(struct platform_device *pdev, · 35 unmodified lines | ||
| 708 | 708 | } |
| 709 | 709 | pmx->nbanks = i; |
| 710 | 710 | |
| 711 | − pmx->regs = devm_kzalloc(&pdev->dev, pmx->nbanks * sizeof(*pmx->regs), | |
| 711 | + pmx->regs = devm_kcalloc(&pdev->dev, pmx->nbanks, sizeof(*pmx->regs), | |
| 712 | 712 | GFP_KERNEL); |
| 713 | 713 | if (!pmx->regs) |
| 714 | 714 | return -ENOMEM; |
| @@ -510,11 +510,11 @@ static int ti_iodelay_dt_node_to_map(struct pinctrl_dev *pctldev, · 509 unmodified lines | ||
| 510 | 510 | goto free_map; |
| 511 | 511 | } |
| 512 | 512 | |
| 513 | − pins = devm_kzalloc(iod->dev, sizeof(*pins) * rows, GFP_KERNEL); | |
| 513 | + pins = devm_kcalloc(iod->dev, rows, sizeof(*pins), GFP_KERNEL); | |
| 514 | 514 | if (!pins) |
| 515 | 515 | goto free_group; |
| 516 | 516 | |
| 517 | − cfg = devm_kzalloc(iod->dev, sizeof(*cfg) * rows, GFP_KERNEL); | |
| 517 | + cfg = devm_kcalloc(iod->dev, rows, sizeof(*cfg), GFP_KERNEL); | |
| 518 | 518 | if (!cfg) { |
| 519 | 519 | error = -ENOMEM; |
| 520 | 520 | goto free_pins; |
| @@ -749,7 +749,7 @@ static int ti_iodelay_alloc_pins(struct device *dev, · 228 unmodified lines | ||
| 749 | 749 | nr_pins = ti_iodelay_offset_to_pin(iod, r->regmap_config->max_register); |
| 750 | 750 | dev_dbg(dev, "Allocating %i pins\n", nr_pins); |
| 751 | 751 | |
| 752 | − iod->pa = devm_kzalloc(dev, sizeof(*iod->pa) * nr_pins, GFP_KERNEL); | |
| 752 | + iod->pa = devm_kcalloc(dev, nr_pins, sizeof(*iod->pa), GFP_KERNEL); | |
| 753 | 753 | if (!iod->pa) |
| 754 | 754 | return -ENOMEM; |
| 755 | 755 | |
| @@ -352,7 +352,7 @@ static int wmt_pctl_dt_node_to_map(struct pinctrl_dev *pctldev, · 351 unmodified lines | ||
| 352 | 352 | if (num_pulls) |
| 353 | 353 | maps_per_pin++; |
| 354 | 354 | |
| 355 | − cur_map = maps = kzalloc(num_pins * maps_per_pin * sizeof(*maps), | |
| 355 | + cur_map = maps = kcalloc(num_pins * maps_per_pin, sizeof(*maps), | |
| 356 | 356 | GFP_KERNEL); |
| 357 | 357 | if (!maps) |
| 358 | 358 | return -ENOMEM; |
| @@ -277,7 +277,7 @@ static int zx_pinctrl_build_state(struct platform_device *pdev) · 276 unmodified lines | ||
| 277 | 277 | |
| 278 | 278 | /* Every single pin composes a group */ |
| 279 | 279 | ngroups = info->npins; |
| 280 | − groups = devm_kzalloc(&pdev->dev, ngroups * sizeof(*groups), | |
| 280 | + groups = devm_kcalloc(&pdev->dev, ngroups, sizeof(*groups), | |
| 281 | 281 | GFP_KERNEL); |
| 282 | 282 | if (!groups) |
| 283 | 283 | return -ENOMEM; |
| @@ -362,8 +362,8 @@ static int zx_pinctrl_build_state(struct platform_device *pdev) · 78 unmodified lines | ||
| 362 | 362 | |
| 363 | 363 | func = functions + j; |
| 364 | 364 | if (!func->group_names) { |
| 365 | − func->group_names = devm_kzalloc(&pdev->dev, | |
| 366 | − func->num_group_names * | |
| 365 | + func->group_names = devm_kcalloc(&pdev->dev, | |
| 366 | + func->num_group_names, | |
| 367 | 367 | sizeof(*func->group_names), |
| 368 | 368 | GFP_KERNEL); |
| 369 | 369 | if (!func->group_names) { |
| @@ -217,7 +217,8 @@ static int mlxreg_hotplug_attr_init(struct mlxreg_hotplug_priv_data *priv) · 216 unmodified lines | ||
| 217 | 217 | } |
| 218 | 218 | } |
| 219 | 219 | |
| 220 | − priv->group.attrs = devm_kzalloc(&priv->pdev->dev, num_attrs * | |
| 220 | + priv->group.attrs = devm_kcalloc(&priv->pdev->dev, | |
| 221 | + num_attrs, | |
| 221 | 222 | sizeof(struct attribute *), |
| 222 | 223 | GFP_KERNEL); |
| 223 | 224 | if (!priv->group.attrs) |
| @@ -458,19 +458,19 @@ static int alienware_zone_init(struct platform_device *dev) · 457 unmodified lines | ||
| 458 | 458 | * - zone_data num_zones is for the distinct zones |
| 459 | 459 | */ |
| 460 | 460 | zone_dev_attrs = |
| 461 | − kzalloc(sizeof(struct device_attribute) * (quirks->num_zones + 1), | |
| 461 | + kcalloc(quirks->num_zones + 1, sizeof(struct device_attribute), | |
| 462 | 462 | GFP_KERNEL); |
| 463 | 463 | if (!zone_dev_attrs) |
| 464 | 464 | return -ENOMEM; |
| 465 | 465 | |
| 466 | 466 | zone_attrs = |
| 467 | − kzalloc(sizeof(struct attribute *) * (quirks->num_zones + 2), | |
| 467 | + kcalloc(quirks->num_zones + 2, sizeof(struct attribute *), | |
| 468 | 468 | GFP_KERNEL); |
| 469 | 469 | if (!zone_attrs) |
| 470 | 470 | return -ENOMEM; |
| 471 | 471 | |
| 472 | 472 | zone_data = |
| 473 | − kzalloc(sizeof(struct platform_zone) * (quirks->num_zones), | |
| 473 | + kcalloc(quirks->num_zones, sizeof(struct platform_zone), | |
| 474 | 474 | GFP_KERNEL); |
| 475 | 475 | if (!zone_data) |
| 476 | 476 | return -ENOMEM; |
| @@ -964,12 +964,12 @@ static int ips_monitor(void *data) · 963 unmodified lines | ||
| 964 | 964 | u16 *mcp_samples, *ctv1_samples, *ctv2_samples, *mch_samples; |
| 965 | 965 | u8 cur_seqno, last_seqno; |
| 966 | 966 | |
| 967 | − mcp_samples = kzalloc(sizeof(u16) * IPS_SAMPLE_COUNT, GFP_KERNEL); | |
| 968 | − ctv1_samples = kzalloc(sizeof(u16) * IPS_SAMPLE_COUNT, GFP_KERNEL); | |
| 969 | − ctv2_samples = kzalloc(sizeof(u16) * IPS_SAMPLE_COUNT, GFP_KERNEL); | |
| 970 | − mch_samples = kzalloc(sizeof(u16) * IPS_SAMPLE_COUNT, GFP_KERNEL); | |
| 971 | − cpu_samples = kzalloc(sizeof(u32) * IPS_SAMPLE_COUNT, GFP_KERNEL); | |
| 972 | − mchp_samples = kzalloc(sizeof(u32) * IPS_SAMPLE_COUNT, GFP_KERNEL); | |
| 967 | + mcp_samples = kcalloc(IPS_SAMPLE_COUNT, sizeof(u16), GFP_KERNEL); | |
| 968 | + ctv1_samples = kcalloc(IPS_SAMPLE_COUNT, sizeof(u16), GFP_KERNEL); | |
| 969 | + ctv2_samples = kcalloc(IPS_SAMPLE_COUNT, sizeof(u16), GFP_KERNEL); | |
| 970 | + mch_samples = kcalloc(IPS_SAMPLE_COUNT, sizeof(u16), GFP_KERNEL); | |
| 971 | + cpu_samples = kcalloc(IPS_SAMPLE_COUNT, sizeof(u32), GFP_KERNEL); | |
| 972 | + mchp_samples = kcalloc(IPS_SAMPLE_COUNT, sizeof(u32), GFP_KERNEL); | |
| 973 | 973 | if (!mcp_samples || !ctv1_samples || !ctv2_samples || !mch_samples || |
| 974 | 974 | !cpu_samples || !mchp_samples) { |
| 975 | 975 | dev_err(ips->dev, |
| @@ -571,7 +571,7 @@ static int acpi_pcc_hotkey_add(struct acpi_device *device) · 570 unmodified lines | ||
| 571 | 571 | return -ENOMEM; |
| 572 | 572 | } |
| 573 | 573 | |
| 574 | − pcc->sinf = kzalloc(sizeof(u32) * (num_sifr + 1), GFP_KERNEL); | |
| 574 | + pcc->sinf = kcalloc(num_sifr + 1, sizeof(u32), GFP_KERNEL); | |
| 575 | 575 | if (!pcc->sinf) { |
| 576 | 576 | result = -ENOMEM; |
| 577 | 577 | goto out_hotkey; |
| @@ -6006,7 +6006,7 @@ static int __init led_init(struct ibm_init_struct *iibm) · 6005 unmodified lines | ||
| 6006 | 6006 | if (led_supported == TPACPI_LED_NONE) |
| 6007 | 6007 | return 1; |
| 6008 | 6008 | |
| 6009 | − tpacpi_leds = kzalloc(sizeof(*tpacpi_leds) * TPACPI_LED_NUMLEDS, | |
| 6009 | + tpacpi_leds = kcalloc(TPACPI_LED_NUMLEDS, sizeof(*tpacpi_leds), | |
| 6010 | 6010 | GFP_KERNEL); |
| 6011 | 6011 | if (!tpacpi_leds) { |
| 6012 | 6012 | pr_err("Out of memory for LED data\n"); |
| @@ -1380,7 +1380,7 @@ static int charger_manager_register_sysfs(struct charger_manager *cm) · 1379 unmodified lines | ||
| 1380 | 1380 | |
| 1381 | 1381 | snprintf(buf, 10, "charger.%d", i); |
| 1382 | 1382 | str = devm_kzalloc(cm->dev, |
| 1383 | − sizeof(char) * (strlen(buf) + 1), GFP_KERNEL); | |
| 1383 | + strlen(buf) + 1, GFP_KERNEL); | |
| 1384 | 1384 | if (!str) |
| 1385 | 1385 | return -ENOMEM; |
| 1386 | 1386 | |
| @@ -1522,8 +1522,10 @@ static struct charger_desc *of_cm_parse_desc(struct device *dev) · 135 unmodified lines | ||
| 1522 | 1522 | of_property_read_u32(np, "cm-num-chargers", &num_chgs); |
| 1523 | 1523 | if (num_chgs) { |
| 1524 | 1524 | /* Allocate empty bin at the tail of array */ |
| 1525 | − desc->psy_charger_stat = devm_kzalloc(dev, sizeof(char *) | |
| 1526 | − * (num_chgs + 1), GFP_KERNEL); | |
| 1525 | + desc->psy_charger_stat = devm_kcalloc(dev, | |
| 1526 | + num_chgs + 1, | |
| 1527 | + sizeof(char *), | |
| 1528 | + GFP_KERNEL); | |
| 1527 | 1529 | if (desc->psy_charger_stat) { |
| 1528 | 1530 | int i; |
| 1529 | 1531 | for (i = 0; i < num_chgs; i++) |
| @@ -1555,8 +1557,9 @@ static struct charger_desc *of_cm_parse_desc(struct device *dev) · 25 unmodified lines | ||
| 1555 | 1557 | struct charger_regulator *chg_regs; |
| 1556 | 1558 | struct device_node *child; |
| 1557 | 1559 | |
| 1558 | − chg_regs = devm_kzalloc(dev, sizeof(*chg_regs) | |
| 1559 | − * desc->num_charger_regulators, | |
| 1560 | + chg_regs = devm_kcalloc(dev, | |
| 1561 | + desc->num_charger_regulators, | |
| 1562 | + sizeof(*chg_regs), | |
| 1560 | 1563 | GFP_KERNEL); |
| 1561 | 1564 | if (!chg_regs) |
| 1562 | 1565 | return ERR_PTR(-ENOMEM); |
| @@ -1573,9 +1576,10 @@ static struct charger_desc *of_cm_parse_desc(struct device *dev) · 10 unmodified lines | ||
| 1573 | 1576 | /* charger cables */ |
| 1574 | 1577 | chg_regs->num_cables = of_get_child_count(child); |
| 1575 | 1578 | if (chg_regs->num_cables) { |
| 1576 | − cables = devm_kzalloc(dev, sizeof(*cables) | |
| 1577 | − * chg_regs->num_cables, | |
| 1578 | − GFP_KERNEL); | |
| 1579 | + cables = devm_kcalloc(dev, | |
| 1580 | + chg_regs->num_cables, | |
| 1581 | + sizeof(*cables), | |
| 1582 | + GFP_KERNEL); | |
| 1579 | 1583 | if (!cables) { |
| 1580 | 1584 | of_node_put(child); |
| 1581 | 1585 | return ERR_PTR(-ENOMEM); |
| @@ -1725,10 +1729,11 @@ static int charger_manager_probe(struct platform_device *pdev) · 143 unmodified lines | ||
| 1725 | 1729 | cm->charger_psy_desc.name = cm->psy_name_buf; |
| 1726 | 1730 | |
| 1727 | 1731 | /* Allocate for psy properties because they may vary */ |
| 1728 | − cm->charger_psy_desc.properties = devm_kzalloc(&pdev->dev, | |
| 1729 | − sizeof(enum power_supply_property) | |
| 1730 | − * (ARRAY_SIZE(default_charger_props) + | |
| 1731 | − NUM_CHARGER_PSY_OPTIONAL), GFP_KERNEL); | |
| 1732 | + cm->charger_psy_desc.properties = | |
| 1733 | + devm_kcalloc(&pdev->dev, | |
| 1734 | + ARRAY_SIZE(default_charger_props) + | |
| 1735 | + NUM_CHARGER_PSY_OPTIONAL, | |
| 1736 | + sizeof(enum power_supply_property), GFP_KERNEL); | |
| 1732 | 1737 | if (!cm->charger_psy_desc.properties) |
| 1733 | 1738 | return -ENOMEM; |
| 1734 | 1739 | |
| @@ -263,8 +263,8 @@ static int power_supply_check_supplies(struct power_supply *psy) · 262 unmodified lines | ||
| 263 | 263 | if (!psy->supplied_from) |
| 264 | 264 | return -ENOMEM; |
| 265 | 265 | |
| 266 | − *psy->supplied_from = devm_kzalloc(&psy->dev, | |
| 267 | − sizeof(char *) * (cnt - 1), | |
| 266 | + *psy->supplied_from = devm_kcalloc(&psy->dev, | |
| 267 | + cnt - 1, sizeof(char *), | |
| 268 | 268 | GFP_KERNEL); |
| 269 | 269 | if (!*psy->supplied_from) |
| 270 | 270 | return -ENOMEM; |
| @@ -201,7 +201,7 @@ static int wm97xx_bat_probe(struct platform_device *dev) · 200 unmodified lines | ||
| 201 | 201 | if (pdata->min_voltage >= 0) |
| 202 | 202 | props++; /* POWER_SUPPLY_PROP_VOLTAGE_MIN */ |
| 203 | 203 | |
| 204 | − prop = kzalloc(props * sizeof(*prop), GFP_KERNEL); | |
| 204 | + prop = kcalloc(props, sizeof(*prop), GFP_KERNEL); | |
| 205 | 205 | if (!prop) { |
| 206 | 206 | ret = -ENOMEM; |
| 207 | 207 | goto err3; |
| @@ -146,7 +146,7 @@ static int z2_batt_ps_init(struct z2_charger *charger, int props) · 145 unmodified lines | ||
| 146 | 146 | if (info->min_voltage >= 0) |
| 147 | 147 | props++; /* POWER_SUPPLY_PROP_VOLTAGE_MIN */ |
| 148 | 148 | |
| 149 | − prop = kzalloc(props * sizeof(*prop), GFP_KERNEL); | |
| 149 | + prop = kcalloc(props, sizeof(*prop), GFP_KERNEL); | |
| 150 | 150 | if (!prop) |
| 151 | 151 | return -ENOMEM; |
| 152 | 152 | |
| @@ -545,15 +545,16 @@ struct powercap_zone *powercap_register_zone( · 544 unmodified lines | ||
| 545 | 545 | dev_set_name(&power_zone->dev, "%s:%x", |
| 546 | 546 | dev_name(power_zone->dev.parent), |
| 547 | 547 | power_zone->id); |
| 548 | − power_zone->constraints = kzalloc(sizeof(*power_zone->constraints) * | |
| 549 | − nr_constraints, GFP_KERNEL); | |
| 548 | + power_zone->constraints = kcalloc(nr_constraints, | |
| 549 | + sizeof(*power_zone->constraints), | |
| 550 | + GFP_KERNEL); | |
| 550 | 551 | if (!power_zone->constraints) |
| 551 | 552 | goto err_const_alloc; |
| 552 | 553 | |
| 553 | 554 | nr_attrs = nr_constraints * POWERCAP_CONSTRAINTS_ATTRS + |
| 554 | 555 | POWERCAP_ZONE_MAX_ATTRS + 1; |
| 555 | − power_zone->zone_dev_attrs = kzalloc(sizeof(void *) * | |
| 556 | − nr_attrs, GFP_KERNEL); | |
| 556 | + power_zone->zone_dev_attrs = kcalloc(nr_attrs, sizeof(void *), | |
| 557 | + GFP_KERNEL); | |
| 557 | 558 | if (!power_zone->zone_dev_attrs) |
| 558 | 559 | goto err_attr_alloc; |
| 559 | 560 | create_power_zone_common_attributes(power_zone); |
| @@ -225,7 +225,7 @@ static int lp3943_pwm_parse_dt(struct device *dev, · 224 unmodified lines | ||
| 225 | 225 | if (num_outputs == 0) |
| 226 | 226 | continue; |
| 227 | 227 | |
| 228 | − output = devm_kzalloc(dev, sizeof(*output) * num_outputs, | |
| 228 | + output = devm_kcalloc(dev, num_outputs, sizeof(*output), | |
| 229 | 229 | GFP_KERNEL); |
| 230 | 230 | if (!output) |
| 231 | 231 | return -ENOMEM; |
| @@ -975,7 +975,7 @@ static int rio_mport_transfer_ioctl(struct file *filp, void __user *arg) · 974 unmodified lines | ||
| 975 | 975 | priv->md->properties.transfer_mode) == 0) |
| 976 | 976 | return -ENODEV; |
| 977 | 977 | |
| 978 | − transfer = vmalloc(transaction.count * sizeof(*transfer)); | |
| 978 | + transfer = vmalloc(array_size(sizeof(*transfer), transaction.count)); | |
| 979 | 979 | if (!transfer) |
| 980 | 980 | return -ENOMEM; |
| 981 | 981 | |
| @@ -425,9 +425,9 @@ static struct rio_dev *rio_setup_device(struct rio_net *net, · 424 unmodified lines | ||
| 425 | 425 | rswitch = rdev->rswitch; |
| 426 | 426 | rswitch->port_ok = 0; |
| 427 | 427 | spin_lock_init(&rswitch->lock); |
| 428 | − rswitch->route_table = kzalloc(sizeof(u8)* | |
| 429 | − RIO_MAX_ROUTE_ENTRIES(port->sys_size), | |
| 430 | − GFP_KERNEL); | |
| 428 | + rswitch->route_table = | |
| 429 | + kzalloc(RIO_MAX_ROUTE_ENTRIES(port->sys_size), | |
| 430 | + GFP_KERNEL); | |
| 431 | 431 | if (!rswitch->route_table) |
| 432 | 432 | goto cleanup; |
| 433 | 433 | /* Initialize switch route table */ |
| @@ -424,9 +424,10 @@ static int act8865_pdata_from_dt(struct device *dev, · 423 unmodified lines | ||
| 424 | 424 | if (matched <= 0) |
| 425 | 425 | return matched; |
| 426 | 426 | |
| 427 | − pdata->regulators = devm_kzalloc(dev, | |
| 428 | − sizeof(struct act8865_regulator_data) * | |
| 429 | − num_matches, GFP_KERNEL); | |
| 427 | + pdata->regulators = devm_kcalloc(dev, | |
| 428 | + num_matches, | |
| 429 | + sizeof(struct act8865_regulator_data), | |
| 430 | + GFP_KERNEL); | |
| 430 | 431 | if (!pdata->regulators) |
| 431 | 432 | return -ENOMEM; |
| 432 | 433 | |
| @@ -239,8 +239,10 @@ static int as3711_regulator_probe(struct platform_device *pdev) · 238 unmodified lines | ||
| 239 | 239 | } |
| 240 | 240 | } |
| 241 | 241 | |
| 242 | − regs = devm_kzalloc(&pdev->dev, AS3711_REGULATOR_NUM * | |
| 243 | − sizeof(struct as3711_regulator), GFP_KERNEL); | |
| 242 | + regs = devm_kcalloc(&pdev->dev, | |
| 243 | + AS3711_REGULATOR_NUM, | |
| 244 | + sizeof(struct as3711_regulator), | |
| 245 | + GFP_KERNEL); | |
| 244 | 246 | if (!regs) |
| 245 | 247 | return -ENOMEM; |
| 246 | 248 | |
| @@ -383,8 +383,10 @@ static int bcm590xx_probe(struct platform_device *pdev) · 382 unmodified lines | ||
| 383 | 383 | |
| 384 | 384 | platform_set_drvdata(pdev, pmu); |
| 385 | 385 | |
| 386 | − pmu->desc = devm_kzalloc(&pdev->dev, BCM590XX_NUM_REGS * | |
| 387 | − sizeof(struct regulator_desc), GFP_KERNEL); | |
| 386 | + pmu->desc = devm_kcalloc(&pdev->dev, | |
| 387 | + BCM590XX_NUM_REGS, | |
| 388 | + sizeof(struct regulator_desc), | |
| 389 | + GFP_KERNEL); | |
| 388 | 390 | if (!pmu->desc) |
| 389 | 391 | return -ENOMEM; |
| 390 | 392 | |
| @@ -681,8 +681,8 @@ static struct da9063_regulators_pdata *da9063_parse_regulators_dt( · 680 unmodified lines | ||
| 681 | 681 | if (!pdata) |
| 682 | 682 | return ERR_PTR(-ENOMEM); |
| 683 | 683 | |
| 684 | − pdata->regulator_data = devm_kzalloc(&pdev->dev, | |
| 685 | − num * sizeof(*pdata->regulator_data), | |
| 684 | + pdata->regulator_data = devm_kcalloc(&pdev->dev, | |
| 685 | + num, sizeof(*pdata->regulator_data), | |
| 686 | 686 | GFP_KERNEL); |
| 687 | 687 | if (!pdata->regulator_data) |
| 688 | 688 | return ERR_PTR(-ENOMEM); |
| @@ -172,8 +172,8 @@ of_get_gpio_regulator_config(struct device *dev, struct device_node *np, · 171 unmodified lines | ||
| 172 | 172 | |
| 173 | 173 | if (ret > 0) { |
| 174 | 174 | config->nr_gpios = ret; |
| 175 | − config->gpios = devm_kzalloc(dev, | |
| 176 | − sizeof(struct gpio) * config->nr_gpios, | |
| 175 | + config->gpios = devm_kcalloc(dev, | |
| 176 | + config->nr_gpios, sizeof(struct gpio), | |
| 177 | 177 | GFP_KERNEL); |
| 178 | 178 | if (!config->gpios) |
| 179 | 179 | return ERR_PTR(-ENOMEM); |
| @@ -214,9 +214,9 @@ of_get_gpio_regulator_config(struct device *dev, struct device_node *np, · 34 unmodified lines | ||
| 214 | 214 | return ERR_PTR(-EINVAL); |
| 215 | 215 | } |
| 216 | 216 | |
| 217 | − config->states = devm_kzalloc(dev, | |
| 218 | − sizeof(struct gpio_regulator_state) | |
| 219 | − * (proplen / 2), | |
| 217 | + config->states = devm_kcalloc(dev, | |
| 218 | + proplen / 2, | |
| 219 | + sizeof(struct gpio_regulator_state), | |
| 220 | 220 | GFP_KERNEL); |
| 221 | 221 | if (!config->states) |
| 222 | 222 | return ERR_PTR(-ENOMEM); |
| @@ -194,8 +194,10 @@ static int of_get_max1586_platform_data(struct device *dev, · 193 unmodified lines | ||
| 194 | 194 | if (matched <= 0) |
| 195 | 195 | return matched; |
| 196 | 196 | |
| 197 | − pdata->subdevs = devm_kzalloc(dev, sizeof(struct max1586_subdev_data) * | |
| 198 | − matched, GFP_KERNEL); | |
| 197 | + pdata->subdevs = devm_kcalloc(dev, | |
| 198 | + matched, | |
| 199 | + sizeof(struct max1586_subdev_data), | |
| 200 | + GFP_KERNEL); | |
| 199 | 201 | if (!pdata->subdevs) |
| 200 | 202 | return -ENOMEM; |
| 201 | 203 | |
| @@ -351,8 +351,10 @@ static int max8660_pdata_from_dt(struct device *dev, · 350 unmodified lines | ||
| 351 | 351 | if (matched <= 0) |
| 352 | 352 | return matched; |
| 353 | 353 | |
| 354 | − pdata->subdevs = devm_kzalloc(dev, sizeof(struct max8660_subdev_data) * | |
| 355 | − matched, GFP_KERNEL); | |
| 354 | + pdata->subdevs = devm_kcalloc(dev, | |
| 355 | + matched, | |
| 356 | + sizeof(struct max8660_subdev_data), | |
| 357 | + GFP_KERNEL); | |
| 356 | 358 | if (!pdata->subdevs) |
| 357 | 359 | return -ENOMEM; |
| 358 | 360 | |
| @@ -929,8 +929,9 @@ static int max8997_pmic_dt_parse_pdata(struct platform_device *pdev, · 928 unmodified lines | ||
| 929 | 929 | /* count the number of regulators to be supported in pmic */ |
| 930 | 930 | pdata->num_regulators = of_get_child_count(regulators_np); |
| 931 | 931 | |
| 932 | − rdata = devm_kzalloc(&pdev->dev, sizeof(*rdata) * | |
| 933 | − pdata->num_regulators, GFP_KERNEL); | |
| 932 | + rdata = devm_kcalloc(&pdev->dev, | |
| 933 | + pdata->num_regulators, sizeof(*rdata), | |
| 934 | + GFP_KERNEL); | |
| 934 | 935 | if (!rdata) { |
| 935 | 936 | of_node_put(regulators_np); |
| 936 | 937 | return -ENOMEM; |
| @@ -670,8 +670,9 @@ static int max8998_pmic_dt_parse_pdata(struct max8998_dev *iodev, · 669 unmodified lines | ||
| 670 | 670 | /* count the number of regulators to be supported in pmic */ |
| 671 | 671 | pdata->num_regulators = of_get_child_count(regulators_np); |
| 672 | 672 | |
| 673 | − rdata = devm_kzalloc(iodev->dev, sizeof(*rdata) * | |
| 674 | − pdata->num_regulators, GFP_KERNEL); | |
| 673 | + rdata = devm_kcalloc(iodev->dev, | |
| 674 | + pdata->num_regulators, sizeof(*rdata), | |
| 675 | + GFP_KERNEL); | |
| 675 | 676 | if (!rdata) { |
| 676 | 677 | of_node_put(regulators_np); |
| 677 | 678 | return -ENOMEM; |
| @@ -171,7 +171,7 @@ struct mc13xxx_regulator_init_data *mc13xxx_parse_regulators_dt( · 170 unmodified lines | ||
| 171 | 171 | if (!parent) |
| 172 | 172 | return NULL; |
| 173 | 173 | |
| 174 | − data = devm_kzalloc(&pdev->dev, sizeof(*data) * priv->num_regulators, | |
| 174 | + data = devm_kcalloc(&pdev->dev, priv->num_regulators, sizeof(*data), | |
| 175 | 175 | GFP_KERNEL); |
| 176 | 176 | if (!data) { |
| 177 | 177 | of_node_put(parent); |
| @@ -173,8 +173,9 @@ static int pbias_regulator_probe(struct platform_device *pdev) · 172 unmodified lines | ||
| 173 | 173 | if (count < 0) |
| 174 | 174 | return count; |
| 175 | 175 | |
| 176 | − drvdata = devm_kzalloc(&pdev->dev, sizeof(struct pbias_regulator_data) | |
| 177 | − * count, GFP_KERNEL); | |
| 176 | + drvdata = devm_kcalloc(&pdev->dev, | |
| 177 | + count, sizeof(struct pbias_regulator_data), | |
| 178 | + GFP_KERNEL); | |
| 178 | 179 | if (!drvdata) |
| 179 | 180 | return -ENOMEM; |
| 180 | 181 | |
| @@ -132,8 +132,10 @@ static int rc5t583_regulator_probe(struct platform_device *pdev) · 131 unmodified lines | ||
| 132 | 132 | return -ENODEV; |
| 133 | 133 | } |
| 134 | 134 | |
| 135 | − regs = devm_kzalloc(&pdev->dev, RC5T583_REGULATOR_MAX * | |
| 136 | − sizeof(struct rc5t583_regulator), GFP_KERNEL); | |
| 135 | + regs = devm_kcalloc(&pdev->dev, | |
| 136 | + RC5T583_REGULATOR_MAX, | |
| 137 | + sizeof(struct rc5t583_regulator), | |
| 138 | + GFP_KERNEL); | |
| 137 | 139 | if (!regs) |
| 138 | 140 | return -ENOMEM; |
| 139 | 141 | |
| @@ -1139,8 +1139,8 @@ static int s2mps11_pmic_probe(struct platform_device *pdev) · 1138 unmodified lines | ||
| 1139 | 1139 | return -EINVAL; |
| 1140 | 1140 | } |
| 1141 | 1141 | |
| 1142 | − s2mps11->ext_control_gpio = devm_kmalloc(&pdev->dev, | |
| 1143 | − sizeof(*s2mps11->ext_control_gpio) * rdev_num, | |
| 1142 | + s2mps11->ext_control_gpio = devm_kmalloc_array(&pdev->dev, | |
| 1143 | + rdev_num, sizeof(*s2mps11->ext_control_gpio), | |
| 1144 | 1144 | GFP_KERNEL); |
| 1145 | 1145 | if (!s2mps11->ext_control_gpio) |
| 1146 | 1146 | return -ENOMEM; |
| @@ -1162,7 +1162,7 @@ static int s2mps11_pmic_probe(struct platform_device *pdev) · 15 unmodified lines | ||
| 1162 | 1162 | } |
| 1163 | 1163 | } |
| 1164 | 1164 | |
| 1165 | − rdata = kzalloc(sizeof(*rdata) * rdev_num, GFP_KERNEL); | |
| 1165 | + rdata = kcalloc(rdev_num, sizeof(*rdata), GFP_KERNEL); | |
| 1166 | 1166 | if (!rdata) |
| 1167 | 1167 | return -ENOMEM; |
| 1168 | 1168 | |
| @@ -553,13 +553,15 @@ static int s5m8767_pmic_dt_parse_pdata(struct platform_device *pdev, · 552 unmodified lines | ||
| 553 | 553 | /* count the number of regulators to be supported in pmic */ |
| 554 | 554 | pdata->num_regulators = of_get_child_count(regulators_np); |
| 555 | 555 | |
| 556 | − rdata = devm_kzalloc(&pdev->dev, sizeof(*rdata) * | |
| 557 | − pdata->num_regulators, GFP_KERNEL); | |
| 556 | + rdata = devm_kcalloc(&pdev->dev, | |
| 557 | + pdata->num_regulators, sizeof(*rdata), | |
| 558 | + GFP_KERNEL); | |
| 558 | 559 | if (!rdata) |
| 559 | 560 | return -ENOMEM; |
| 560 | 561 | |
| 561 | − rmode = devm_kzalloc(&pdev->dev, sizeof(*rmode) * | |
| 562 | − pdata->num_regulators, GFP_KERNEL); | |
| 562 | + rmode = devm_kcalloc(&pdev->dev, | |
| 563 | + pdata->num_regulators, sizeof(*rmode), | |
| 564 | + GFP_KERNEL); | |
| 563 | 565 | if (!rmode) |
| 564 | 566 | return -ENOMEM; |
| 565 | 567 | |
| @@ -532,13 +532,13 @@ static int ti_abb_init_table(struct device *dev, struct ti_abb *abb, · 531 unmodified lines | ||
| 532 | 532 | } |
| 533 | 533 | num_entries /= num_values; |
| 534 | 534 | |
| 535 | − info = devm_kzalloc(dev, sizeof(*info) * num_entries, GFP_KERNEL); | |
| 535 | + info = devm_kcalloc(dev, num_entries, sizeof(*info), GFP_KERNEL); | |
| 536 | 536 | if (!info) |
| 537 | 537 | return -ENOMEM; |
| 538 | 538 | |
| 539 | 539 | abb->info = info; |
| 540 | 540 | |
| 541 | − volt_table = devm_kzalloc(dev, sizeof(unsigned int) * num_entries, | |
| 541 | + volt_table = devm_kcalloc(dev, num_entries, sizeof(unsigned int), | |
| 542 | 542 | GFP_KERNEL); |
| 543 | 543 | if (!volt_table) |
| 544 | 544 | return -ENOMEM; |
| @@ -331,8 +331,9 @@ static struct tps65090_platform_data *tps65090_parse_dt_reg_data( · 330 unmodified lines | ||
| 331 | 331 | if (!tps65090_pdata) |
| 332 | 332 | return ERR_PTR(-ENOMEM); |
| 333 | 333 | |
| 334 | − reg_pdata = devm_kzalloc(&pdev->dev, TPS65090_REGULATOR_MAX * | |
| 335 | − sizeof(*reg_pdata), GFP_KERNEL); | |
| 334 | + reg_pdata = devm_kcalloc(&pdev->dev, | |
| 335 | + TPS65090_REGULATOR_MAX, sizeof(*reg_pdata), | |
| 336 | + GFP_KERNEL); | |
| 336 | 337 | if (!reg_pdata) |
| 337 | 338 | return ERR_PTR(-ENOMEM); |
| 338 | 339 | |
| @@ -429,8 +430,9 @@ static int tps65090_regulator_probe(struct platform_device *pdev) · 90 unmodified lines | ||
| 429 | 430 | return tps65090_pdata ? PTR_ERR(tps65090_pdata) : -EINVAL; |
| 430 | 431 | } |
| 431 | 432 | |
| 432 | − pmic = devm_kzalloc(&pdev->dev, TPS65090_REGULATOR_MAX * sizeof(*pmic), | |
| 433 | − GFP_KERNEL); | |
| 433 | + pmic = devm_kcalloc(&pdev->dev, | |
| 434 | + TPS65090_REGULATOR_MAX, sizeof(*pmic), | |
| 435 | + GFP_KERNEL); | |
| 434 | 436 | if (!pmic) |
| 435 | 437 | return -ENOMEM; |
| 436 | 438 | |
| @@ -229,8 +229,9 @@ static int tps65217_regulator_probe(struct platform_device *pdev) · 228 unmodified lines | ||
| 229 | 229 | unsigned int val; |
| 230 | 230 | |
| 231 | 231 | /* Allocate memory for strobes */ |
| 232 | − tps->strobes = devm_kzalloc(&pdev->dev, sizeof(u8) * | |
| 233 | − TPS65217_NUM_REGULATOR, GFP_KERNEL); | |
| 232 | + tps->strobes = devm_kcalloc(&pdev->dev, | |
| 233 | + TPS65217_NUM_REGULATOR, sizeof(u8), | |
| 234 | + GFP_KERNEL); | |
| 234 | 235 | |
| 235 | 236 | platform_set_drvdata(pdev, tps); |
| 236 | 237 | |
| @@ -324,8 +324,9 @@ static int tps65218_regulator_probe(struct platform_device *pdev) · 323 unmodified lines | ||
| 324 | 324 | config.regmap = tps->regmap; |
| 325 | 325 | |
| 326 | 326 | /* Allocate memory for strobes */ |
| 327 | − tps->strobes = devm_kzalloc(&pdev->dev, sizeof(u8) * | |
| 328 | − TPS65218_NUM_REGULATOR, GFP_KERNEL); | |
| 327 | + tps->strobes = devm_kcalloc(&pdev->dev, | |
| 328 | + TPS65218_NUM_REGULATOR, sizeof(u8), | |
| 329 | + GFP_KERNEL); | |
| 329 | 330 | if (!tps->strobes) |
| 330 | 331 | return -ENOMEM; |
| 331 | 332 | |
| @@ -1131,18 +1131,24 @@ static int tps65910_probe(struct platform_device *pdev) · 1130 unmodified lines | ||
| 1131 | 1131 | return -ENODEV; |
| 1132 | 1132 | } |
| 1133 | 1133 | |
| 1134 | − pmic->desc = devm_kzalloc(&pdev->dev, pmic->num_regulators * | |
| 1135 | − sizeof(struct regulator_desc), GFP_KERNEL); | |
| 1134 | + pmic->desc = devm_kcalloc(&pdev->dev, | |
| 1135 | + pmic->num_regulators, | |
| 1136 | + sizeof(struct regulator_desc), | |
| 1137 | + GFP_KERNEL); | |
| 1136 | 1138 | if (!pmic->desc) |
| 1137 | 1139 | return -ENOMEM; |
| 1138 | 1140 | |
| 1139 | − pmic->info = devm_kzalloc(&pdev->dev, pmic->num_regulators * | |
| 1140 | − sizeof(struct tps_info *), GFP_KERNEL); | |
| 1141 | + pmic->info = devm_kcalloc(&pdev->dev, | |
| 1142 | + pmic->num_regulators, | |
| 1143 | + sizeof(struct tps_info *), | |
| 1144 | + GFP_KERNEL); | |
| 1141 | 1145 | if (!pmic->info) |
| 1142 | 1146 | return -ENOMEM; |
| 1143 | 1147 | |
| 1144 | − pmic->rdev = devm_kzalloc(&pdev->dev, pmic->num_regulators * | |
| 1145 | − sizeof(struct regulator_dev *), GFP_KERNEL); | |
| 1148 | + pmic->rdev = devm_kcalloc(&pdev->dev, | |
| 1149 | + pmic->num_regulators, | |
| 1150 | + sizeof(struct regulator_dev *), | |
| 1151 | + GFP_KERNEL); | |
| 1146 | 1152 | if (!pmic->rdev) |
| 1147 | 1153 | return -ENOMEM; |
| 1148 | 1154 | |
| @@ -691,8 +691,8 @@ static int tps80031_regulator_probe(struct platform_device *pdev) · 690 unmodified lines | ||
| 691 | 691 | return -EINVAL; |
| 692 | 692 | } |
| 693 | 693 | |
| 694 | − pmic = devm_kzalloc(&pdev->dev, | |
| 695 | − TPS80031_REGULATOR_MAX * sizeof(*pmic), GFP_KERNEL); | |
| 694 | + pmic = devm_kcalloc(&pdev->dev, | |
| 695 | + TPS80031_REGULATOR_MAX, sizeof(*pmic), GFP_KERNEL); | |
| 696 | 696 | if (!pmic) |
| 697 | 697 | return -ENOMEM; |
| 698 | 698 | |
| @@ -189,7 +189,8 @@ static int ti_syscon_reset_probe(struct platform_device *pdev) · 188 unmodified lines | ||
| 189 | 189 | } |
| 190 | 190 | |
| 191 | 191 | nr_controls = (size / sizeof(*list)) / 7; |
| 192 | − controls = devm_kzalloc(dev, nr_controls * sizeof(*controls), GFP_KERNEL); | |
| 192 | + controls = devm_kcalloc(dev, nr_controls, sizeof(*controls), | |
| 193 | + GFP_KERNEL); | |
| 193 | 194 | if (!controls) |
| 194 | 195 | return -ENOMEM; |
| 195 | 196 | |
| @@ -561,8 +561,8 @@ static int dasd_eer_open(struct inode *inp, struct file *filp) · 560 unmodified lines | ||
| 561 | 561 | return -EINVAL; |
| 562 | 562 | } |
| 563 | 563 | eerb->buffersize = eerb->buffer_page_count * PAGE_SIZE; |
| 564 | − eerb->buffer = kmalloc(eerb->buffer_page_count * sizeof(char *), | |
| 565 | − GFP_KERNEL); | |
| 564 | + eerb->buffer = kmalloc_array(eerb->buffer_page_count, sizeof(char *), | |
| 565 | + GFP_KERNEL); | |
| 566 | 566 | if (!eerb->buffer) { |
| 567 | 567 | kfree(eerb); |
| 568 | 568 | return -ENOMEM; |
| @@ -238,9 +238,9 @@ dcssblk_is_continuous(struct dcssblk_dev_info *dev_info) · 237 unmodified lines | ||
| 238 | 238 | if (dev_info->num_of_segments <= 1) |
| 239 | 239 | return 0; |
| 240 | 240 | |
| 241 | − sort_list = kzalloc( | |
| 242 | − sizeof(struct segment_info) * dev_info->num_of_segments, | |
| 243 | − GFP_KERNEL); | |
| 241 | + sort_list = kcalloc(dev_info->num_of_segments, | |
| 242 | + sizeof(struct segment_info), | |
| 243 | + GFP_KERNEL); | |
| 244 | 244 | if (sort_list == NULL) |
| 245 | 245 | return -ENOMEM; |
| 246 | 246 | i = 0; |
| @@ -78,7 +78,7 @@ kbd_alloc(void) { · 77 unmodified lines | ||
| 78 | 78 | } |
| 79 | 79 | } |
| 80 | 80 | kbd->fn_handler = |
| 81 | − kzalloc(sizeof(fn_handler_fn *) * NR_FN_HANDLER, GFP_KERNEL); | |
| 81 | + kcalloc(NR_FN_HANDLER, sizeof(fn_handler_fn *), GFP_KERNEL); | |
| 82 | 82 | if (!kbd->fn_handler) |
| 83 | 83 | goto out_func; |
| 84 | 84 | kbd->accent_table = kmemdup(ebc_accent_table, |
| @@ -300,7 +300,7 @@ static int sclp_sd_store_data(struct sclp_sd_data *result, u8 di) · 299 unmodified lines | ||
| 300 | 300 | goto out_result; |
| 301 | 301 | |
| 302 | 302 | /* Allocate memory */ |
| 303 | − data = vzalloc((size_t) dsize * PAGE_SIZE); | |
| 303 | + data = vzalloc(array_size((size_t)dsize, PAGE_SIZE)); | |
| 304 | 304 | if (!data) { |
| 305 | 305 | rc = -ENOMEM; |
| 306 | 306 | goto out; |
| @@ -719,7 +719,8 @@ tty3270_alloc_view(void) · 718 unmodified lines | ||
| 719 | 719 | if (!tp) |
| 720 | 720 | goto out_err; |
| 721 | 721 | tp->freemem_pages = |
| 722 | − kmalloc(sizeof(void *) * TTY3270_STRING_PAGES, GFP_KERNEL); | |
| 722 | + kmalloc_array(TTY3270_STRING_PAGES, sizeof(void *), | |
| 723 | + GFP_KERNEL); | |
| 723 | 724 | if (!tp->freemem_pages) |
| 724 | 725 | goto out_tp; |
| 725 | 726 | INIT_LIST_HEAD(&tp->freemem); |
| @@ -242,7 +242,7 @@ static struct ccw1 *alloc_chan_prog(const char __user *ubuf, int rec_count, · 241 unmodified lines | ||
| 242 | 242 | * That means we allocate room for CCWs to cover count/reclen |
| 243 | 243 | * records plus a NOP. |
| 244 | 244 | */ |
| 245 | − cpa = kzalloc((rec_count + 1) * sizeof(struct ccw1), | |
| 245 | + cpa = kcalloc(rec_count + 1, sizeof(struct ccw1), | |
| 246 | 246 | GFP_KERNEL | GFP_DMA); |
| 247 | 247 | if (!cpa) |
| 248 | 248 | return ERR_PTR(-ENOMEM); |
| @@ -152,7 +152,7 @@ static int zcore_memmap_open(struct inode *inode, struct file *filp) · 151 unmodified lines | ||
| 152 | 152 | char *buf; |
| 153 | 153 | int i = 0; |
| 154 | 154 | |
| 155 | − buf = kzalloc(memblock.memory.cnt * CHUNK_INFO_SIZE, GFP_KERNEL); | |
| 155 | + buf = kcalloc(memblock.memory.cnt, CHUNK_INFO_SIZE, GFP_KERNEL); | |
| 156 | 156 | if (!buf) { |
| 157 | 157 | return -ENOMEM; |
| 158 | 158 | } |
| @@ -536,7 +536,7 @@ void qdio_print_subchannel_info(struct qdio_irq *irq_ptr, · 535 unmodified lines | ||
| 536 | 536 | |
| 537 | 537 | int qdio_enable_async_operation(struct qdio_output_q *outq) |
| 538 | 538 | { |
| 539 | − outq->aobs = kzalloc(sizeof(struct qaob *) * QDIO_MAX_BUFFERS_PER_Q, | |
| 539 | + outq->aobs = kcalloc(QDIO_MAX_BUFFERS_PER_Q, sizeof(struct qaob *), | |
| 540 | 540 | GFP_ATOMIC); |
| 541 | 541 | if (!outq->aobs) { |
| 542 | 542 | outq->use_cq = 0; |
| @@ -241,8 +241,9 @@ out: · 240 unmodified lines | ||
| 241 | 241 | /* allocate non-shared indicators and shared indicator */ |
| 242 | 242 | int __init tiqdio_allocate_memory(void) |
| 243 | 243 | { |
| 244 | − q_indicators = kzalloc(sizeof(struct indicator_t) * TIQDIO_NR_INDICATORS, | |
| 245 | − GFP_KERNEL); | |
| 244 | + q_indicators = kcalloc(TIQDIO_NR_INDICATORS, | |
| 245 | + sizeof(struct indicator_t), | |
| 246 | + GFP_KERNEL); | |
| 246 | 247 | if (!q_indicators) |
| 247 | 248 | return -ENOMEM; |
| 248 | 249 | return 0; |
| @@ -121,7 +121,7 @@ static int alloc_and_prep_cprbmem(size_t paramblen, · 120 unmodified lines | ||
| 121 | 121 | * allocate consecutive memory for request CPRB, request param |
| 122 | 122 | * block, reply CPRB and reply param block |
| 123 | 123 | */ |
| 124 | − cprbmem = kzalloc(2 * cprbplusparamblen, GFP_KERNEL); | |
| 124 | + cprbmem = kcalloc(2, cprbplusparamblen, GFP_KERNEL); | |
| 125 | 125 | if (!cprbmem) |
| 126 | 126 | return -ENOMEM; |
| 127 | 127 | |
| @@ -899,9 +899,9 @@ int pkey_findcard(const struct pkey_seckey *seckey, · 771 unmodified lines | ||
| 899 | 899 | return -EINVAL; |
| 900 | 900 | |
| 901 | 901 | /* fetch status of all crypto cards */ |
| 902 | − device_status = kmalloc(MAX_ZDEV_ENTRIES_EXT | |
| 903 | − * sizeof(struct zcrypt_device_status_ext), | |
| 904 | − GFP_KERNEL); | |
| 902 | + device_status = kmalloc_array(MAX_ZDEV_ENTRIES_EXT, | |
| 903 | + sizeof(struct zcrypt_device_status_ext), | |
| 904 | + GFP_KERNEL); | |
| 905 | 905 | if (!device_status) |
| 906 | 906 | return -ENOMEM; |
| 907 | 907 | zcrypt_device_status_mask_ext(device_status); |
| @@ -1379,7 +1379,7 @@ static int add_channel(struct ccw_device *cdev, enum ctcm_channel_types type, · 1378 unmodified lines | ||
| 1379 | 1379 | } else |
| 1380 | 1380 | ccw_num = 8; |
| 1381 | 1381 | |
| 1382 | − ch->ccw = kzalloc(ccw_num * sizeof(struct ccw1), GFP_KERNEL | GFP_DMA); | |
| 1382 | + ch->ccw = kcalloc(ccw_num, sizeof(struct ccw1), GFP_KERNEL | GFP_DMA); | |
| 1383 | 1383 | if (ch->ccw == NULL) |
| 1384 | 1384 | goto nomem_return; |
| 1385 | 1385 | |
| @@ -374,9 +374,10 @@ static int qeth_alloc_cq(struct qeth_card *card) · 373 unmodified lines | ||
| 374 | 374 | } |
| 375 | 375 | card->qdio.no_in_queues = 2; |
| 376 | 376 | card->qdio.out_bufstates = |
| 377 | − kzalloc(card->qdio.no_out_queues * | |
| 378 | − QDIO_MAX_BUFFERS_PER_Q * | |
| 379 | − sizeof(struct qdio_outbuf_state), GFP_KERNEL); | |
| 377 | + kcalloc(card->qdio.no_out_queues * | |
| 378 | + QDIO_MAX_BUFFERS_PER_Q, | |
| 379 | + sizeof(struct qdio_outbuf_state), | |
| 380 | + GFP_KERNEL); | |
| 380 | 381 | outbuf_states = card->qdio.out_bufstates; |
| 381 | 382 | if (outbuf_states == NULL) { |
| 382 | 383 | rc = -1; |
| @@ -2538,8 +2539,9 @@ static int qeth_alloc_qdio_buffers(struct qeth_card *card) · 2155 unmodified lines | ||
| 2538 | 2539 | |
| 2539 | 2540 | /* outbound */ |
| 2540 | 2541 | card->qdio.out_qs = |
| 2541 | − kzalloc(card->qdio.no_out_queues * | |
| 2542 | − sizeof(struct qeth_qdio_out_q *), GFP_KERNEL); | |
| 2542 | + kcalloc(card->qdio.no_out_queues, | |
| 2543 | + sizeof(struct qeth_qdio_out_q *), | |
| 2544 | + GFP_KERNEL); | |
| 2543 | 2545 | if (!card->qdio.out_qs) |
| 2544 | 2546 | goto out_freepool; |
| 2545 | 2547 | for (i = 0; i < card->qdio.no_out_queues; ++i) { |
| @@ -4963,8 +4965,8 @@ static int qeth_qdio_establish(struct qeth_card *card) · 2417 unmodified lines | ||
| 4963 | 4965 | |
| 4964 | 4966 | QETH_DBF_TEXT(SETUP, 2, "qdioest"); |
| 4965 | 4967 | |
| 4966 | − qib_param_field = kzalloc(QDIO_MAX_BUFFERS_PER_Q * sizeof(char), | |
| 4967 | − GFP_KERNEL); | |
| 4968 | + qib_param_field = kzalloc(QDIO_MAX_BUFFERS_PER_Q, | |
| 4969 | + GFP_KERNEL); | |
| 4968 | 4970 | if (!qib_param_field) { |
| 4969 | 4971 | rc = -ENOMEM; |
| 4970 | 4972 | goto out_free_nothing; |
| @@ -4973,8 +4975,8 @@ static int qeth_qdio_establish(struct qeth_card *card) · 2 unmodified lines | ||
| 4973 | 4975 | qeth_create_qib_param_field(card, qib_param_field); |
| 4974 | 4976 | qeth_create_qib_param_field_blkt(card, qib_param_field); |
| 4975 | 4977 | |
| 4976 | − in_sbal_ptrs = kzalloc(card->qdio.no_in_queues * | |
| 4977 | − QDIO_MAX_BUFFERS_PER_Q * sizeof(void *), | |
| 4978 | + in_sbal_ptrs = kcalloc(card->qdio.no_in_queues * QDIO_MAX_BUFFERS_PER_Q, | |
| 4979 | + sizeof(void *), | |
| 4978 | 4980 | GFP_KERNEL); |
| 4979 | 4981 | if (!in_sbal_ptrs) { |
| 4980 | 4982 | rc = -ENOMEM; |
| @@ -4985,7 +4987,7 @@ static int qeth_qdio_establish(struct qeth_card *card) · 4 unmodified lines | ||
| 4985 | 4987 | virt_to_phys(card->qdio.in_q->bufs[i].buffer); |
| 4986 | 4988 | } |
| 4987 | 4989 | |
| 4988 | − queue_start_poll = kzalloc(sizeof(void *) * card->qdio.no_in_queues, | |
| 4990 | + queue_start_poll = kcalloc(card->qdio.no_in_queues, sizeof(void *), | |
| 4989 | 4991 | GFP_KERNEL); |
| 4990 | 4992 | if (!queue_start_poll) { |
| 4991 | 4993 | rc = -ENOMEM; |
| @@ -4997,8 +4999,9 @@ static int qeth_qdio_establish(struct qeth_card *card) · 5 unmodified lines | ||
| 4997 | 4999 | qeth_qdio_establish_cq(card, in_sbal_ptrs, queue_start_poll); |
| 4998 | 5000 | |
| 4999 | 5001 | out_sbal_ptrs = |
| 5000 | − kzalloc(card->qdio.no_out_queues * QDIO_MAX_BUFFERS_PER_Q * | |
| 5001 | − sizeof(void *), GFP_KERNEL); | |
| 5002 | + kcalloc(card->qdio.no_out_queues * QDIO_MAX_BUFFERS_PER_Q, | |
| 5003 | + sizeof(void *), | |
| 5004 | + GFP_KERNEL); | |
| 5002 | 5005 | if (!out_sbal_ptrs) { |
| 5003 | 5006 | rc = -ENOMEM; |
| 5004 | 5007 | goto out_free_queue_start_poll; |
| @@ -2366,7 +2366,7 @@ static int __init blogic_init(void) · 2365 unmodified lines | ||
| 2366 | 2366 | if (blogic_probe_options.noprobe) |
| 2367 | 2367 | return -ENODEV; |
| 2368 | 2368 | blogic_probeinfo_list = |
| 2369 | − kzalloc(BLOGIC_MAX_ADAPTERS * sizeof(struct blogic_probeinfo), | |
| 2369 | + kcalloc(BLOGIC_MAX_ADAPTERS, sizeof(struct blogic_probeinfo), | |
| 2370 | 2370 | GFP_KERNEL); |
| 2371 | 2371 | if (blogic_probeinfo_list == NULL) { |
| 2372 | 2372 | blogic_err("BusLogic: Unable to allocate Probe Info List\n", |
| @@ -4132,7 +4132,7 @@ static int aac_convert_sgraw2(struct aac_raw_io2 *rio2, int pages, int nseg, int · 4131 unmodified lines | ||
| 4132 | 4132 | if (aac_convert_sgl == 0) |
| 4133 | 4133 | return 0; |
| 4134 | 4134 | |
| 4135 | − sge = kmalloc(nseg_new * sizeof(struct sge_ieee1212), GFP_ATOMIC); | |
| 4135 | + sge = kmalloc_array(nseg_new, sizeof(struct sge_ieee1212), GFP_ATOMIC); | |
| 4136 | 4136 | if (sge == NULL) |
| 4137 | 4137 | return -ENOMEM; |
| 4138 | 4138 | |
| @@ -1681,7 +1681,9 @@ static int aac_probe_one(struct pci_dev *pdev, const struct pci_device_id *id) · 1680 unmodified lines | ||
| 1681 | 1681 | if (aac_reset_devices || reset_devices) |
| 1682 | 1682 | aac->init_reset = true; |
| 1683 | 1683 | |
| 1684 | − aac->fibs = kzalloc(sizeof(struct fib) * (shost->can_queue + AAC_NUM_MGT_FIB), GFP_KERNEL); | |
| 1684 | + aac->fibs = kcalloc(shost->can_queue + AAC_NUM_MGT_FIB, | |
| 1685 | + sizeof(struct fib), | |
| 1686 | + GFP_KERNEL); | |
| 1685 | 1687 | if (!aac->fibs) |
| 1686 | 1688 | goto out_free_host; |
| 1687 | 1689 | spin_lock_init(&aac->fib_lock); |
| @@ -400,7 +400,8 @@ static int aha1542_queuecommand(struct Scsi_Host *sh, struct scsi_cmnd *cmd) · 399 unmodified lines | ||
| 400 | 400 | #endif |
| 401 | 401 | if (bufflen) { /* allocate memory before taking host_lock */ |
| 402 | 402 | sg_count = scsi_sg_count(cmd); |
| 403 | − cptr = kmalloc(sizeof(*cptr) * sg_count, GFP_KERNEL | GFP_DMA); | |
| 403 | + cptr = kmalloc_array(sg_count, sizeof(*cptr), | |
| 404 | + GFP_KERNEL | GFP_DMA); | |
| 404 | 405 | if (!cptr) |
| 405 | 406 | return SCSI_MLQUEUE_HOST_BUSY; |
| 406 | 407 | } else { |
| @@ -7063,7 +7063,8 @@ ahd_init(struct ahd_softc *ahd) · 7062 unmodified lines | ||
| 7063 | 7063 | AHD_ASSERT_MODES(ahd, AHD_MODE_SCSI_MSK, AHD_MODE_SCSI_MSK); |
| 7064 | 7064 | |
| 7065 | 7065 | ahd->stack_size = ahd_probe_stack_size(ahd); |
| 7066 | − ahd->saved_stack = kmalloc(ahd->stack_size * sizeof(uint16_t), GFP_ATOMIC); | |
| 7066 | + ahd->saved_stack = kmalloc_array(ahd->stack_size, sizeof(uint16_t), | |
| 7067 | + GFP_ATOMIC); | |
| 7067 | 7068 | if (ahd->saved_stack == NULL) |
| 7068 | 7069 | return (ENOMEM); |
| 7069 | 7070 | |
| @@ -4779,8 +4779,8 @@ ahc_init_scbdata(struct ahc_softc *ahc) · 4778 unmodified lines | ||
| 4779 | 4779 | SLIST_INIT(&scb_data->sg_maps); |
| 4780 | 4780 | |
| 4781 | 4781 | /* Allocate SCB resources */ |
| 4782 | − scb_data->scbarray = kzalloc(sizeof(struct scb) * AHC_SCB_MAX_ALLOC, | |
| 4783 | − GFP_ATOMIC); | |
| 4782 | + scb_data->scbarray = kcalloc(AHC_SCB_MAX_ALLOC, sizeof(struct scb), | |
| 4783 | + GFP_ATOMIC); | |
| 4784 | 4784 | if (scb_data->scbarray == NULL) |
| 4785 | 4785 | return (ENOMEM); |
| 4786 | 4786 | |
| @@ -220,8 +220,9 @@ static int asd_init_scbs(struct asd_ha_struct *asd_ha) · 219 unmodified lines | ||
| 220 | 220 | |
| 221 | 221 | /* allocate the index array and bitmap */ |
| 222 | 222 | asd_ha->seq.tc_index_bitmap_bits = asd_ha->hw_prof.max_scbs; |
| 223 | − asd_ha->seq.tc_index_array = kzalloc(asd_ha->seq.tc_index_bitmap_bits* | |
| 224 | − sizeof(void *), GFP_KERNEL); | |
| 223 | + asd_ha->seq.tc_index_array = kcalloc(asd_ha->seq.tc_index_bitmap_bits, | |
| 224 | + sizeof(void *), | |
| 225 | + GFP_KERNEL); | |
| 225 | 226 | if (!asd_ha->seq.tc_index_array) |
| 226 | 227 | return -ENOMEM; |
| 227 | 228 | |
| @@ -291,7 +292,8 @@ static int asd_alloc_edbs(struct asd_ha_struct *asd_ha, gfp_t gfp_flags) · 63 unmodified lines | ||
| 291 | 292 | struct asd_seq_data *seq = &asd_ha->seq; |
| 292 | 293 | int i; |
| 293 | 294 | |
| 294 | − seq->edb_arr = kmalloc(seq->num_edbs*sizeof(*seq->edb_arr), gfp_flags); | |
| 295 | + seq->edb_arr = kmalloc_array(seq->num_edbs, sizeof(*seq->edb_arr), | |
| 296 | + gfp_flags); | |
| 295 | 297 | if (!seq->edb_arr) |
| 296 | 298 | return -ENOMEM; |
| 297 | 299 | |
| @@ -323,8 +325,8 @@ static int asd_alloc_escbs(struct asd_ha_struct *asd_ha, · 25 unmodified lines | ||
| 323 | 325 | struct asd_ascb *escb; |
| 324 | 326 | int i, escbs; |
| 325 | 327 | |
| 326 | − seq->escb_arr = kmalloc(seq->num_escbs*sizeof(*seq->escb_arr), | |
| 327 | − gfp_flags); | |
| 328 | + seq->escb_arr = kmalloc_array(seq->num_escbs, sizeof(*seq->escb_arr), | |
| 329 | + gfp_flags); | |
| 328 | 330 | if (!seq->escb_arr) |
| 329 | 331 | return -ENOMEM; |
| 330 | 332 | |
| @@ -350,7 +350,7 @@ static ssize_t asd_store_update_bios(struct device *dev, · 349 unmodified lines | ||
| 350 | 350 | int flash_command = FLASH_CMD_NONE; |
| 351 | 351 | int err = 0; |
| 352 | 352 | |
| 353 | − cmd_ptr = kzalloc(count*2, GFP_KERNEL); | |
| 353 | + cmd_ptr = kcalloc(count, 2, GFP_KERNEL); | |
| 354 | 354 | |
| 355 | 355 | if (!cmd_ptr) { |
| 356 | 356 | err = FAIL_OUT_MEMORY; |
| @@ -70,7 +70,7 @@ int queue_initialise (Queue_t *queue) · 69 unmodified lines | ||
| 70 | 70 | * need to keep free lists or allocate this |
| 71 | 71 | * memory. |
| 72 | 72 | */ |
| 73 | − queue->alloc = q = kmalloc(sizeof(QE_t) * nqueues, GFP_KERNEL); | |
| 73 | + queue->alloc = q = kmalloc_array(nqueues, sizeof(QE_t), GFP_KERNEL); | |
| 74 | 74 | if (q) { |
| 75 | 75 | for (; nqueues; q++, nqueues--) { |
| 76 | 76 | SET_MAGIC(q, QUEUE_MAGIC_FREE); |
| @@ -2467,8 +2467,8 @@ static int beiscsi_alloc_mem(struct beiscsi_hba *phba) · 2466 unmodified lines | ||
| 2467 | 2467 | |
| 2468 | 2468 | /* Allocate memory for wrb_context */ |
| 2469 | 2469 | phwi_ctrlr = phba->phwi_ctrlr; |
| 2470 | − phwi_ctrlr->wrb_context = kzalloc(sizeof(struct hwi_wrb_context) * | |
| 2471 | − phba->params.cxns_per_ctrl, | |
| 2470 | + phwi_ctrlr->wrb_context = kcalloc(phba->params.cxns_per_ctrl, | |
| 2471 | + sizeof(struct hwi_wrb_context), | |
| 2472 | 2472 | GFP_KERNEL); |
| 2473 | 2473 | if (!phwi_ctrlr->wrb_context) { |
| 2474 | 2474 | kfree(phba->phwi_ctrlr); |
| @@ -2483,8 +2483,9 @@ static int beiscsi_alloc_mem(struct beiscsi_hba *phba) · 8 unmodified lines | ||
| 2483 | 2483 | return -ENOMEM; |
| 2484 | 2484 | } |
| 2485 | 2485 | |
| 2486 | − mem_arr_orig = kmalloc(sizeof(*mem_arr_orig) * BEISCSI_MAX_FRAGS_INIT, | |
| 2487 | − GFP_KERNEL); | |
| 2486 | + mem_arr_orig = kmalloc_array(BEISCSI_MAX_FRAGS_INIT, | |
| 2487 | + sizeof(*mem_arr_orig), | |
| 2488 | + GFP_KERNEL); | |
| 2488 | 2489 | if (!mem_arr_orig) { |
| 2489 | 2490 | kfree(phba->init_mem); |
| 2490 | 2491 | kfree(phwi_ctrlr->wrb_context); |
| @@ -2533,8 +2534,8 @@ static int beiscsi_alloc_mem(struct beiscsi_hba *phba) · 42 unmodified lines | ||
| 2533 | 2534 | } while (alloc_size); |
| 2534 | 2535 | mem_descr->num_elements = j; |
| 2535 | 2536 | mem_descr->size_in_bytes = phba->mem_req[i]; |
| 2536 | − mem_descr->mem_array = kmalloc(sizeof(*mem_arr) * j, | |
| 2537 | − GFP_KERNEL); | |
| 2537 | + mem_descr->mem_array = kmalloc_array(j, sizeof(*mem_arr), | |
| 2538 | + GFP_KERNEL); | |
| 2538 | 2539 | if (!mem_descr->mem_array) |
| 2539 | 2540 | goto free_mem; |
| 2540 | 2541 | |
| @@ -2620,8 +2621,8 @@ static int beiscsi_init_wrb_handle(struct beiscsi_hba *phba) · 79 unmodified lines | ||
| 2620 | 2621 | |
| 2621 | 2622 | /* Allocate memory for WRBQ */ |
| 2622 | 2623 | phwi_ctxt = phwi_ctrlr->phwi_ctxt; |
| 2623 | − phwi_ctxt->be_wrbq = kzalloc(sizeof(struct be_queue_info) * | |
| 2624 | − phba->params.cxns_per_ctrl, | |
| 2624 | + phwi_ctxt->be_wrbq = kcalloc(phba->params.cxns_per_ctrl, | |
| 2625 | + sizeof(struct be_queue_info), | |
| 2625 | 2626 | GFP_KERNEL); |
| 2626 | 2627 | if (!phwi_ctxt->be_wrbq) { |
| 2627 | 2628 | beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT, |
| @@ -2632,16 +2633,18 @@ static int beiscsi_init_wrb_handle(struct beiscsi_hba *phba) · 4 unmodified lines | ||
| 2632 | 2633 | for (index = 0; index < phba->params.cxns_per_ctrl; index++) { |
| 2633 | 2634 | pwrb_context = &phwi_ctrlr->wrb_context[index]; |
| 2634 | 2635 | pwrb_context->pwrb_handle_base = |
| 2635 | − kzalloc(sizeof(struct wrb_handle *) * | |
| 2636 | − phba->params.wrbs_per_cxn, GFP_KERNEL); | |
| 2636 | + kcalloc(phba->params.wrbs_per_cxn, | |
| 2637 | + sizeof(struct wrb_handle *), | |
| 2638 | + GFP_KERNEL); | |
| 2637 | 2639 | if (!pwrb_context->pwrb_handle_base) { |
| 2638 | 2640 | beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT, |
| 2639 | 2641 | "BM_%d : Mem Alloc Failed. Failing to load\n"); |
| 2640 | 2642 | goto init_wrb_hndl_failed; |
| 2641 | 2643 | } |
| 2642 | 2644 | pwrb_context->pwrb_handle_basestd = |
| 2643 | − kzalloc(sizeof(struct wrb_handle *) * | |
| 2644 | − phba->params.wrbs_per_cxn, GFP_KERNEL); | |
| 2645 | + kcalloc(phba->params.wrbs_per_cxn, | |
| 2646 | + sizeof(struct wrb_handle *), | |
| 2647 | + GFP_KERNEL); | |
| 2645 | 2648 | if (!pwrb_context->pwrb_handle_basestd) { |
| 2646 | 2649 | beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT, |
| 2647 | 2650 | "BM_%d : Mem Alloc Failed. Failing to load\n"); |
| @@ -3353,8 +3356,9 @@ beiscsi_create_wrb_rings(struct beiscsi_hba *phba, · 705 unmodified lines | ||
| 3353 | 3356 | idx = 0; |
| 3354 | 3357 | mem_descr = phba->init_mem; |
| 3355 | 3358 | mem_descr += HWI_MEM_WRB; |
| 3356 | − pwrb_arr = kmalloc(sizeof(*pwrb_arr) * phba->params.cxns_per_ctrl, | |
| 3357 | − GFP_KERNEL); | |
| 3359 | + pwrb_arr = kmalloc_array(phba->params.cxns_per_ctrl, | |
| 3360 | + sizeof(*pwrb_arr), | |
| 3361 | + GFP_KERNEL); | |
| 3358 | 3362 | if (!pwrb_arr) { |
| 3359 | 3363 | beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT, |
| 3360 | 3364 | "BM_%d : Memory alloc failed in create wrb ring.\n"); |
| @@ -3894,18 +3898,18 @@ static int beiscsi_init_sgl_handle(struct beiscsi_hba *phba) · 533 unmodified lines | ||
| 3894 | 3898 | mem_descr_sglh = phba->init_mem; |
| 3895 | 3899 | mem_descr_sglh += HWI_MEM_SGLH; |
| 3896 | 3900 | if (1 == mem_descr_sglh->num_elements) { |
| 3897 | − phba->io_sgl_hndl_base = kzalloc(sizeof(struct sgl_handle *) * | |
| 3898 | − phba->params.ios_per_ctrl, | |
| 3901 | + phba->io_sgl_hndl_base = kcalloc(phba->params.ios_per_ctrl, | |
| 3902 | + sizeof(struct sgl_handle *), | |
| 3899 | 3903 | GFP_KERNEL); |
| 3900 | 3904 | if (!phba->io_sgl_hndl_base) { |
| 3901 | 3905 | beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT, |
| 3902 | 3906 | "BM_%d : Mem Alloc Failed. Failing to load\n"); |
| 3903 | 3907 | return -ENOMEM; |
| 3904 | 3908 | } |
| 3905 | − phba->eh_sgl_hndl_base = kzalloc(sizeof(struct sgl_handle *) * | |
| 3906 | − (phba->params.icds_per_ctrl - | |
| 3907 | − phba->params.ios_per_ctrl), | |
| 3908 | − GFP_KERNEL); | |
| 3909 | + phba->eh_sgl_hndl_base = | |
| 3910 | + kcalloc(phba->params.icds_per_ctrl - | |
| 3911 | + phba->params.ios_per_ctrl, | |
| 3912 | + sizeof(struct sgl_handle *), GFP_KERNEL); | |
| 3909 | 3913 | if (!phba->eh_sgl_hndl_base) { |
| 3910 | 3914 | kfree(phba->io_sgl_hndl_base); |
| 3911 | 3915 | beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT, |
| @@ -4032,8 +4036,9 @@ static int hba_setup_cid_tbls(struct beiscsi_hba *phba) · 120 unmodified lines | ||
| 4032 | 4036 | phba->cid_array_info[ulp_num] = ptr_cid_info; |
| 4033 | 4037 | } |
| 4034 | 4038 | } |
| 4035 | − phba->ep_array = kzalloc(sizeof(struct iscsi_endpoint *) * | |
| 4036 | − phba->params.cxns_per_ctrl, GFP_KERNEL); | |
| 4039 | + phba->ep_array = kcalloc(phba->params.cxns_per_ctrl, | |
| 4040 | + sizeof(struct iscsi_endpoint *), | |
| 4041 | + GFP_KERNEL); | |
| 4037 | 4042 | if (!phba->ep_array) { |
| 4038 | 4043 | beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT, |
| 4039 | 4044 | "BM_%d : Failed to allocate memory in " |
| @@ -4043,8 +4048,9 @@ static int hba_setup_cid_tbls(struct beiscsi_hba *phba) · 3 unmodified lines | ||
| 4043 | 4048 | goto free_memory; |
| 4044 | 4049 | } |
| 4045 | 4050 | |
| 4046 | − phba->conn_table = kzalloc(sizeof(struct beiscsi_conn *) * | |
| 4047 | − phba->params.cxns_per_ctrl, GFP_KERNEL); | |
| 4051 | + phba->conn_table = kcalloc(phba->params.cxns_per_ctrl, | |
| 4052 | + sizeof(struct beiscsi_conn *), | |
| 4053 | + GFP_KERNEL); | |
| 4048 | 4054 | if (!phba->conn_table) { |
| 4049 | 4055 | beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT, |
| 4050 | 4056 | "BM_%d : Failed to allocate memory in" |
| @@ -927,7 +927,7 @@ bfad_im_num_of_discovered_ports_show(struct device *dev, · 926 unmodified lines | ||
| 927 | 927 | struct bfa_rport_qualifier_s *rports = NULL; |
| 928 | 928 | unsigned long flags; |
| 929 | 929 | |
| 930 | − rports = kzalloc(sizeof(struct bfa_rport_qualifier_s) * nrports, | |
| 930 | + rports = kcalloc(nrports, sizeof(struct bfa_rport_qualifier_s), | |
| 931 | 931 | GFP_ATOMIC); |
| 932 | 932 | if (rports == NULL) |
| 933 | 933 | return snprintf(buf, PAGE_SIZE, "Failed\n"); |
| @@ -3252,8 +3252,9 @@ bfad_fcxp_map_sg(struct bfad_s *bfad, void *payload_kbuf, · 3251 unmodified lines | ||
| 3252 | 3252 | struct bfa_sge_s *sg_table; |
| 3253 | 3253 | int sge_num = 1; |
| 3254 | 3254 | |
| 3255 | − buf_base = kzalloc((sizeof(struct bfad_buf_info) + | |
| 3256 | − sizeof(struct bfa_sge_s)) * sge_num, GFP_KERNEL); | |
| 3255 | + buf_base = kcalloc(sizeof(struct bfad_buf_info) + | |
| 3256 | + sizeof(struct bfa_sge_s), | |
| 3257 | + sge_num, GFP_KERNEL); | |
| 3257 | 3258 | if (!buf_base) |
| 3258 | 3259 | return NULL; |
| 3259 | 3260 | |
| @@ -1397,7 +1397,7 @@ static struct bnx2fc_hba *bnx2fc_hba_create(struct cnic_dev *cnic) · 1396 unmodified lines | ||
| 1397 | 1397 | hba->next_conn_id = 0; |
| 1398 | 1398 | |
| 1399 | 1399 | hba->tgt_ofld_list = |
| 1400 | − kzalloc(sizeof(struct bnx2fc_rport *) * BNX2FC_NUM_MAX_SESS, | |
| 1400 | + kcalloc(BNX2FC_NUM_MAX_SESS, sizeof(struct bnx2fc_rport *), | |
| 1401 | 1401 | GFP_KERNEL); |
| 1402 | 1402 | if (!hba->tgt_ofld_list) { |
| 1403 | 1403 | printk(KERN_ERR PFX "Unable to allocate tgt offload list\n"); |
| @@ -240,15 +240,15 @@ struct bnx2fc_cmd_mgr *bnx2fc_cmd_mgr_alloc(struct bnx2fc_hba *hba) · 239 unmodified lines | ||
| 240 | 240 | return NULL; |
| 241 | 241 | } |
| 242 | 242 | |
| 243 | − cmgr->free_list = kzalloc(sizeof(*cmgr->free_list) * | |
| 244 | − arr_sz, GFP_KERNEL); | |
| 243 | + cmgr->free_list = kcalloc(arr_sz, sizeof(*cmgr->free_list), | |
| 244 | + GFP_KERNEL); | |
| 245 | 245 | if (!cmgr->free_list) { |
| 246 | 246 | printk(KERN_ERR PFX "failed to alloc free_list\n"); |
| 247 | 247 | goto mem_err; |
| 248 | 248 | } |
| 249 | 249 | |
| 250 | − cmgr->free_list_lock = kzalloc(sizeof(*cmgr->free_list_lock) * | |
| 251 | − arr_sz, GFP_KERNEL); | |
| 250 | + cmgr->free_list_lock = kcalloc(arr_sz, sizeof(*cmgr->free_list_lock), | |
| 251 | + GFP_KERNEL); | |
| 252 | 252 | if (!cmgr->free_list_lock) { |
| 253 | 253 | printk(KERN_ERR PFX "failed to alloc free_list_lock\n"); |
| 254 | 254 | kfree(cmgr->free_list); |
| @@ -276,7 +276,7 @@ csio_wr_alloc_q(struct csio_hw *hw, uint32_t qsize, uint32_t wrsize, · 275 unmodified lines | ||
| 276 | 276 | q->un.iq.flq_idx = flq_idx; |
| 277 | 277 | |
| 278 | 278 | flq = wrm->q_arr[q->un.iq.flq_idx]; |
| 279 | − flq->un.fl.bufs = kzalloc(flq->credits * | |
| 279 | + flq->un.fl.bufs = kcalloc(flq->credits, | |
| 280 | 280 | sizeof(struct csio_dma_buf), |
| 281 | 281 | GFP_KERNEL); |
| 282 | 282 | if (!flq->un.fl.bufs) { |
| @@ -1579,7 +1579,7 @@ csio_wrm_init(struct csio_wrm *wrm, struct csio_hw *hw) · 1296 unmodified lines | ||
| 1579 | 1579 | return -EINVAL; |
| 1580 | 1580 | } |
| 1581 | 1581 | |
| 1582 | − wrm->q_arr = kzalloc(sizeof(struct csio_q *) * wrm->num_q, GFP_KERNEL); | |
| 1582 | + wrm->q_arr = kcalloc(wrm->num_q, sizeof(struct csio_q *), GFP_KERNEL); | |
| 1583 | 1583 | if (!wrm->q_arr) |
| 1584 | 1584 | goto err; |
| 1585 | 1585 | |
| @@ -833,7 +833,7 @@ bool esas2r_init_adapter_struct(struct esas2r_adapter *a, · 832 unmodified lines | ||
| 833 | 833 | |
| 834 | 834 | /* allocate requests for asynchronous events */ |
| 835 | 835 | a->first_ae_req = |
| 836 | − kzalloc(num_ae_requests * sizeof(struct esas2r_request), | |
| 836 | + kcalloc(num_ae_requests, sizeof(struct esas2r_request), | |
| 837 | 837 | GFP_KERNEL); |
| 838 | 838 | |
| 839 | 839 | if (a->first_ae_req == NULL) { |
| @@ -843,8 +843,8 @@ bool esas2r_init_adapter_struct(struct esas2r_adapter *a, · 3 unmodified lines | ||
| 843 | 843 | } |
| 844 | 844 | |
| 845 | 845 | /* allocate the S/G list memory descriptors */ |
| 846 | − a->sg_list_mds = kzalloc( | |
| 847 | − num_sg_lists * sizeof(struct esas2r_mem_desc), GFP_KERNEL); | |
| 846 | + a->sg_list_mds = kcalloc(num_sg_lists, sizeof(struct esas2r_mem_desc), | |
| 847 | + GFP_KERNEL); | |
| 848 | 848 | |
| 849 | 849 | if (a->sg_list_mds == NULL) { |
| 850 | 850 | esas2r_log(ESAS2R_LOG_CRIT, |
| @@ -854,8 +854,9 @@ bool esas2r_init_adapter_struct(struct esas2r_adapter *a, · 3 unmodified lines | ||
| 854 | 854 | |
| 855 | 855 | /* allocate the request table */ |
| 856 | 856 | a->req_table = |
| 857 | − kzalloc((num_requests + num_ae_requests + | |
| 858 | − 1) * sizeof(struct esas2r_request *), GFP_KERNEL); | |
| 857 | + kcalloc(num_requests + num_ae_requests + 1, | |
| 858 | + sizeof(struct esas2r_request *), | |
| 859 | + GFP_KERNEL); | |
| 859 | 860 | |
| 860 | 861 | if (a->req_table == NULL) { |
| 861 | 862 | esas2r_log(ESAS2R_LOG_CRIT, |
| @@ -1390,8 +1390,8 @@ static void fcoe_ctlr_recv_clr_vlink(struct fcoe_ctlr *fip, · 1389 unmodified lines | ||
| 1390 | 1390 | */ |
| 1391 | 1391 | num_vlink_desc = rlen / sizeof(*vp); |
| 1392 | 1392 | if (num_vlink_desc) |
| 1393 | − vlink_desc_arr = kmalloc(sizeof(vp) * num_vlink_desc, | |
| 1394 | − GFP_ATOMIC); | |
| 1393 | + vlink_desc_arr = kmalloc_array(num_vlink_desc, sizeof(vp), | |
| 1394 | + GFP_ATOMIC); | |
| 1395 | 1395 | if (!vlink_desc_arr) |
| 1396 | 1396 | return; |
| 1397 | 1397 | num_vlink_desc = 0; |
| @@ -233,8 +233,8 @@ static int fnic_trace_debugfs_open(struct inode *inode, · 232 unmodified lines | ||
| 233 | 233 | return -ENOMEM; |
| 234 | 234 | |
| 235 | 235 | if (*rdata_ptr == fc_trc_flag->fnic_trace) { |
| 236 | − fnic_dbg_prt->buffer = vmalloc(3 * | |
| 237 | − (trace_max_pages * PAGE_SIZE)); | |
| 236 | + fnic_dbg_prt->buffer = vmalloc(array3_size(3, trace_max_pages, | |
| 237 | + PAGE_SIZE)); | |
| 238 | 238 | if (!fnic_dbg_prt->buffer) { |
| 239 | 239 | kfree(fnic_dbg_prt); |
| 240 | 240 | return -ENOMEM; |
| @@ -244,7 +244,8 @@ static int fnic_trace_debugfs_open(struct inode *inode, · 3 unmodified lines | ||
| 244 | 244 | fnic_dbg_prt->buffer_len = fnic_get_trace_data(fnic_dbg_prt); |
| 245 | 245 | } else { |
| 246 | 246 | fnic_dbg_prt->buffer = |
| 247 | − vmalloc(3 * (fnic_fc_trace_max_pages * PAGE_SIZE)); | |
| 247 | + vmalloc(array3_size(3, fnic_fc_trace_max_pages, | |
| 248 | + PAGE_SIZE)); | |
| 248 | 249 | if (!fnic_dbg_prt->buffer) { |
| 249 | 250 | kfree(fnic_dbg_prt); |
| 250 | 251 | return -ENOMEM; |
| @@ -477,8 +477,9 @@ int fnic_trace_buf_init(void) · 476 unmodified lines | ||
| 477 | 477 | } |
| 478 | 478 | memset((void *)fnic_trace_buf_p, 0, (trace_max_pages * PAGE_SIZE)); |
| 479 | 479 | |
| 480 | − fnic_trace_entries.page_offset = vmalloc(fnic_max_trace_entries * | |
| 481 | − sizeof(unsigned long)); | |
| 480 | + fnic_trace_entries.page_offset = | |
| 481 | + vmalloc(array_size(fnic_max_trace_entries, | |
| 482 | + sizeof(unsigned long))); | |
| 482 | 483 | if (!fnic_trace_entries.page_offset) { |
| 483 | 484 | printk(KERN_ERR PFX "Failed to allocate memory for" |
| 484 | 485 | " page_offset\n"); |
| @@ -555,8 +556,9 @@ int fnic_fc_trace_init(void) · 70 unmodified lines | ||
| 555 | 556 | |
| 556 | 557 | fc_trace_max_entries = (fnic_fc_trace_max_pages * PAGE_SIZE)/ |
| 557 | 558 | FC_TRC_SIZE_BYTES; |
| 558 | − fnic_fc_ctlr_trace_buf_p = (unsigned long)vmalloc( | |
| 559 | − fnic_fc_trace_max_pages * PAGE_SIZE); | |
| 559 | + fnic_fc_ctlr_trace_buf_p = | |
| 560 | + (unsigned long)vmalloc(array_size(PAGE_SIZE, | |
| 561 | + fnic_fc_trace_max_pages)); | |
| 560 | 562 | if (!fnic_fc_ctlr_trace_buf_p) { |
| 561 | 563 | pr_err("fnic: Failed to allocate memory for " |
| 562 | 564 | "FC Control Trace Buf\n"); |
| @@ -568,8 +570,9 @@ int fnic_fc_trace_init(void) · 5 unmodified lines | ||
| 568 | 570 | fnic_fc_trace_max_pages * PAGE_SIZE); |
| 569 | 571 | |
| 570 | 572 | /* Allocate memory for page offset */ |
| 571 | − fc_trace_entries.page_offset = vmalloc(fc_trace_max_entries * | |
| 572 | − sizeof(unsigned long)); | |
| 573 | + fc_trace_entries.page_offset = | |
| 574 | + vmalloc(array_size(fc_trace_max_entries, | |
| 575 | + sizeof(unsigned long))); | |
| 573 | 576 | if (!fc_trace_entries.page_offset) { |
| 574 | 577 | pr_err("fnic:Failed to allocate memory for page_offset\n"); |
| 575 | 578 | if (fnic_fc_ctlr_trace_buf_p) { |
| @@ -1923,8 +1923,8 @@ static void adjust_hpsa_scsi_table(struct ctlr_info *h, · 1922 unmodified lines | ||
| 1923 | 1923 | } |
| 1924 | 1924 | spin_unlock_irqrestore(&h->reset_lock, flags); |
| 1925 | 1925 | |
| 1926 | − added = kzalloc(sizeof(*added) * HPSA_MAX_DEVICES, GFP_KERNEL); | |
| 1927 | − removed = kzalloc(sizeof(*removed) * HPSA_MAX_DEVICES, GFP_KERNEL); | |
| 1926 | + added = kcalloc(HPSA_MAX_DEVICES, sizeof(*added), GFP_KERNEL); | |
| 1927 | + removed = kcalloc(HPSA_MAX_DEVICES, sizeof(*removed), GFP_KERNEL); | |
| 1928 | 1928 | |
| 1929 | 1929 | if (!added || !removed) { |
| 1930 | 1930 | dev_warn(&h->pdev->dev, "out of memory in " |
| @@ -2171,14 +2171,15 @@ static int hpsa_allocate_ioaccel2_sg_chain_blocks(struct ctlr_info *h) · 240 unmodified lines | ||
| 2171 | 2171 | return 0; |
| 2172 | 2172 | |
| 2173 | 2173 | h->ioaccel2_cmd_sg_list = |
| 2174 | − kzalloc(sizeof(*h->ioaccel2_cmd_sg_list) * h->nr_cmds, | |
| 2174 | + kcalloc(h->nr_cmds, sizeof(*h->ioaccel2_cmd_sg_list), | |
| 2175 | 2175 | GFP_KERNEL); |
| 2176 | 2176 | if (!h->ioaccel2_cmd_sg_list) |
| 2177 | 2177 | return -ENOMEM; |
| 2178 | 2178 | for (i = 0; i < h->nr_cmds; i++) { |
| 2179 | 2179 | h->ioaccel2_cmd_sg_list[i] = |
| 2180 | − kmalloc(sizeof(*h->ioaccel2_cmd_sg_list[i]) * | |
| 2181 | − h->maxsgentries, GFP_KERNEL); | |
| 2180 | + kmalloc_array(h->maxsgentries, | |
| 2181 | + sizeof(*h->ioaccel2_cmd_sg_list[i]), | |
| 2182 | + GFP_KERNEL); | |
| 2182 | 2183 | if (!h->ioaccel2_cmd_sg_list[i]) |
| 2183 | 2184 | goto clean; |
| 2184 | 2185 | } |
| @@ -2210,14 +2211,15 @@ static int hpsa_alloc_sg_chain_blocks(struct ctlr_info *h) · 25 unmodified lines | ||
| 2210 | 2211 | if (h->chainsize <= 0) |
| 2211 | 2212 | return 0; |
| 2212 | 2213 | |
| 2213 | − h->cmd_sg_list = kzalloc(sizeof(*h->cmd_sg_list) * h->nr_cmds, | |
| 2214 | − GFP_KERNEL); | |
| 2214 | + h->cmd_sg_list = kcalloc(h->nr_cmds, sizeof(*h->cmd_sg_list), | |
| 2215 | + GFP_KERNEL); | |
| 2215 | 2216 | if (!h->cmd_sg_list) |
| 2216 | 2217 | return -ENOMEM; |
| 2217 | 2218 | |
| 2218 | 2219 | for (i = 0; i < h->nr_cmds; i++) { |
| 2219 | − h->cmd_sg_list[i] = kmalloc(sizeof(*h->cmd_sg_list[i]) * | |
| 2220 | − h->chainsize, GFP_KERNEL); | |
| 2220 | + h->cmd_sg_list[i] = kmalloc_array(h->chainsize, | |
| 2221 | + sizeof(*h->cmd_sg_list[i]), | |
| 2222 | + GFP_KERNEL); | |
| 2221 | 2223 | if (!h->cmd_sg_list[i]) |
| 2222 | 2224 | goto clean; |
| 2223 | 2225 | |
| @@ -4319,7 +4321,7 @@ static void hpsa_update_scsi_devices(struct ctlr_info *h) · 2095 unmodified lines | ||
| 4319 | 4321 | bool physical_device; |
| 4320 | 4322 | DECLARE_BITMAP(lunzerobits, MAX_EXT_TARGETS); |
| 4321 | 4323 | |
| 4322 | − currentsd = kzalloc(sizeof(*currentsd) * HPSA_MAX_DEVICES, GFP_KERNEL); | |
| 4324 | + currentsd = kcalloc(HPSA_MAX_DEVICES, sizeof(*currentsd), GFP_KERNEL); | |
| 4323 | 4325 | physdev_list = kzalloc(sizeof(*physdev_list), GFP_KERNEL); |
| 4324 | 4326 | logdev_list = kzalloc(sizeof(*logdev_list), GFP_KERNEL); |
| 4325 | 4327 | tmpdevice = kzalloc(sizeof(*tmpdevice), GFP_KERNEL); |
| @@ -6402,12 +6404,12 @@ static int hpsa_big_passthru_ioctl(struct ctlr_info *h, void __user *argp) · 2076 unmodified lines | ||
| 6402 | 6404 | status = -EINVAL; |
| 6403 | 6405 | goto cleanup1; |
| 6404 | 6406 | } |
| 6405 | − buff = kzalloc(SG_ENTRIES_IN_CMD * sizeof(char *), GFP_KERNEL); | |
| 6407 | + buff = kcalloc(SG_ENTRIES_IN_CMD, sizeof(char *), GFP_KERNEL); | |
| 6406 | 6408 | if (!buff) { |
| 6407 | 6409 | status = -ENOMEM; |
| 6408 | 6410 | goto cleanup1; |
| 6409 | 6411 | } |
| 6410 | − buff_size = kmalloc(SG_ENTRIES_IN_CMD * sizeof(int), GFP_KERNEL); | |
| 6412 | + buff_size = kmalloc_array(SG_ENTRIES_IN_CMD, sizeof(int), GFP_KERNEL); | |
| 6411 | 6413 | if (!buff_size) { |
| 6412 | 6414 | status = -ENOMEM; |
| 6413 | 6415 | goto cleanup1; |
| @@ -7151,7 +7153,7 @@ static int controller_reset_failed(struct CfgTable __iomem *cfgtable) · 737 unmodified lines | ||
| 7151 | 7153 | char *driver_ver, *old_driver_ver; |
| 7152 | 7154 | int rc, size = sizeof(cfgtable->driver_version); |
| 7153 | 7155 | |
| 7154 | − old_driver_ver = kmalloc(2 * size, GFP_KERNEL); | |
| 7156 | + old_driver_ver = kmalloc_array(2, size, GFP_KERNEL); | |
| 7155 | 7157 | if (!old_driver_ver) |
| 7156 | 7158 | return -ENOMEM; |
| 7157 | 7159 | driver_ver = old_driver_ver + size; |
| @@ -7931,9 +7933,9 @@ static void hpsa_free_cmd_pool(struct ctlr_info *h) · 773 unmodified lines | ||
| 7931 | 7933 | |
| 7932 | 7934 | static int hpsa_alloc_cmd_pool(struct ctlr_info *h) |
| 7933 | 7935 | { |
| 7934 | − h->cmd_pool_bits = kzalloc( | |
| 7935 | − DIV_ROUND_UP(h->nr_cmds, BITS_PER_LONG) * | |
| 7936 | − sizeof(unsigned long), GFP_KERNEL); | |
| 7936 | + h->cmd_pool_bits = kcalloc(DIV_ROUND_UP(h->nr_cmds, BITS_PER_LONG), | |
| 7937 | + sizeof(unsigned long), | |
| 7938 | + GFP_KERNEL); | |
| 7937 | 7939 | h->cmd_pool = pci_alloc_consistent(h->pdev, |
| 7938 | 7940 | h->nr_cmds * sizeof(*h->cmd_pool), |
| 7939 | 7941 | &(h->cmd_pool_dhandle)); |
| @@ -8507,7 +8509,7 @@ static struct ctlr_info *hpda_alloc_ctlr_info(void) · 567 unmodified lines | ||
| 8507 | 8509 | if (!h) |
| 8508 | 8510 | return NULL; |
| 8509 | 8511 | |
| 8510 | − h->reply_map = kzalloc(sizeof(*h->reply_map) * nr_cpu_ids, GFP_KERNEL); | |
| 8512 | + h->reply_map = kcalloc(nr_cpu_ids, sizeof(*h->reply_map), GFP_KERNEL); | |
| 8511 | 8513 | if (!h->reply_map) { |
| 8512 | 8514 | kfree(h); |
| 8513 | 8515 | return NULL; |
| @@ -4331,9 +4331,11 @@ static int ipr_alloc_dump(struct ipr_ioa_cfg *ioa_cfg) · 4330 unmodified lines | ||
| 4331 | 4331 | } |
| 4332 | 4332 | |
| 4333 | 4333 | if (ioa_cfg->sis64) |
| 4334 | − ioa_data = vmalloc(IPR_FMT3_MAX_NUM_DUMP_PAGES * sizeof(__be32 *)); | |
| 4334 | + ioa_data = vmalloc(array_size(IPR_FMT3_MAX_NUM_DUMP_PAGES, | |
| 4335 | + sizeof(__be32 *))); | |
| 4335 | 4336 | else |
| 4336 | − ioa_data = vmalloc(IPR_FMT2_MAX_NUM_DUMP_PAGES * sizeof(__be32 *)); | |
| 4337 | + ioa_data = vmalloc(array_size(IPR_FMT2_MAX_NUM_DUMP_PAGES, | |
| 4338 | + sizeof(__be32 *))); | |
| 4337 | 4339 | |
| 4338 | 4340 | if (!ioa_data) { |
| 4339 | 4341 | ipr_err("Dump memory allocation failed\n"); |
| @@ -9713,8 +9715,9 @@ static int ipr_alloc_mem(struct ipr_ioa_cfg *ioa_cfg) · 5373 unmodified lines | ||
| 9713 | 9715 | int i, rc = -ENOMEM; |
| 9714 | 9716 | |
| 9715 | 9717 | ENTER; |
| 9716 | − ioa_cfg->res_entries = kzalloc(sizeof(struct ipr_resource_entry) * | |
| 9717 | − ioa_cfg->max_devs_supported, GFP_KERNEL); | |
| 9718 | + ioa_cfg->res_entries = kcalloc(ioa_cfg->max_devs_supported, | |
| 9719 | + sizeof(struct ipr_resource_entry), | |
| 9720 | + GFP_KERNEL); | |
| 9718 | 9721 | |
| 9719 | 9722 | if (!ioa_cfg->res_entries) |
| 9720 | 9723 | goto out; |
| @@ -9775,8 +9778,9 @@ static int ipr_alloc_mem(struct ipr_ioa_cfg *ioa_cfg) · 54 unmodified lines | ||
| 9775 | 9778 | list_add_tail(&ioa_cfg->hostrcb[i]->queue, &ioa_cfg->hostrcb_free_q); |
| 9776 | 9779 | } |
| 9777 | 9780 | |
| 9778 | − ioa_cfg->trace = kzalloc(sizeof(struct ipr_trace_entry) * | |
| 9779 | − IPR_NUM_TRACE_ENTRIES, GFP_KERNEL); | |
| 9781 | + ioa_cfg->trace = kcalloc(IPR_NUM_TRACE_ENTRIES, | |
| 9782 | + sizeof(struct ipr_trace_entry), | |
| 9783 | + GFP_KERNEL); | |
| 9780 | 9784 | |
| 9781 | 9785 | if (!ioa_cfg->trace) |
| 9782 | 9786 | goto out_free_hostrcb_dma; |
| @@ -232,14 +232,14 @@ static int isci_register_sas_ha(struct isci_host *isci_host) · 231 unmodified lines | ||
| 232 | 232 | struct asd_sas_phy **sas_phys; |
| 233 | 233 | struct asd_sas_port **sas_ports; |
| 234 | 234 | |
| 235 | − sas_phys = devm_kzalloc(&isci_host->pdev->dev, | |
| 236 | − SCI_MAX_PHYS * sizeof(void *), | |
| 235 | + sas_phys = devm_kcalloc(&isci_host->pdev->dev, | |
| 236 | + SCI_MAX_PHYS, sizeof(void *), | |
| 237 | 237 | GFP_KERNEL); |
| 238 | 238 | if (!sas_phys) |
| 239 | 239 | return -ENOMEM; |
| 240 | 240 | |
| 241 | − sas_ports = devm_kzalloc(&isci_host->pdev->dev, | |
| 242 | − SCI_MAX_PORTS * sizeof(void *), | |
| 241 | + sas_ports = devm_kcalloc(&isci_host->pdev->dev, | |
| 242 | + SCI_MAX_PORTS, sizeof(void *), | |
| 243 | 243 | GFP_KERNEL); |
| 244 | 244 | if (!sas_ports) |
| 245 | 245 | return -ENOMEM; |
| @@ -2576,7 +2576,7 @@ iscsi_pool_init(struct iscsi_pool *q, int max, void ***items, int item_size) · 2575 unmodified lines | ||
| 2576 | 2576 | * the array. */ |
| 2577 | 2577 | if (items) |
| 2578 | 2578 | num_arrays++; |
| 2579 | − q->pool = kvzalloc(num_arrays * max * sizeof(void*), GFP_KERNEL); | |
| 2579 | + q->pool = kvcalloc(num_arrays * max, sizeof(void *), GFP_KERNEL); | |
| 2580 | 2580 | if (q->pool == NULL) |
| 2581 | 2581 | return -ENOMEM; |
| 2582 | 2582 | |
| @@ -443,7 +443,7 @@ static int sas_expander_discover(struct domain_device *dev) · 442 unmodified lines | ||
| 443 | 443 | struct expander_device *ex = &dev->ex_dev; |
| 444 | 444 | int res = -ENOMEM; |
| 445 | 445 | |
| 446 | − ex->ex_phy = kzalloc(sizeof(*ex->ex_phy)*ex->num_phys, GFP_KERNEL); | |
| 446 | + ex->ex_phy = kcalloc(ex->num_phys, sizeof(*ex->ex_phy), GFP_KERNEL); | |
| 447 | 447 | if (!ex->ex_phy) |
| 448 | 448 | return -ENOMEM; |
| 449 | 449 | |
| @@ -5723,8 +5723,9 @@ lpfc_sli_driver_resource_setup(struct lpfc_hba *phba) · 5722 unmodified lines | ||
| 5723 | 5723 | } |
| 5724 | 5724 | |
| 5725 | 5725 | if (!phba->sli.sli3_ring) |
| 5726 | − phba->sli.sli3_ring = kzalloc(LPFC_SLI3_MAX_RING * | |
| 5727 | − sizeof(struct lpfc_sli_ring), GFP_KERNEL); | |
| 5726 | + phba->sli.sli3_ring = kcalloc(LPFC_SLI3_MAX_RING, | |
| 5727 | + sizeof(struct lpfc_sli_ring), | |
| 5728 | + GFP_KERNEL); | |
| 5728 | 5729 | if (!phba->sli.sli3_ring) |
| 5729 | 5730 | return -ENOMEM; |
| 5730 | 5731 | |
| @@ -6233,7 +6234,7 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba) · 502 unmodified lines | ||
| 6233 | 6234 | |
| 6234 | 6235 | /* Allocate eligible FCF bmask memory for FCF roundrobin failover */ |
| 6235 | 6236 | longs = (LPFC_SLI4_FCF_TBL_INDX_MAX + BITS_PER_LONG - 1)/BITS_PER_LONG; |
| 6236 | − phba->fcf.fcf_rr_bmask = kzalloc(longs * sizeof(unsigned long), | |
| 6237 | + phba->fcf.fcf_rr_bmask = kcalloc(longs, sizeof(unsigned long), | |
| 6237 | 6238 | GFP_KERNEL); |
| 6238 | 6239 | if (!phba->fcf.fcf_rr_bmask) { |
| 6239 | 6240 | lpfc_printf_log(phba, KERN_ERR, LOG_INIT, |
| @@ -120,8 +120,9 @@ lpfc_mem_alloc(struct lpfc_hba *phba, int align) · 119 unmodified lines | ||
| 120 | 120 | if (!phba->lpfc_mbuf_pool) |
| 121 | 121 | goto fail_free_dma_buf_pool; |
| 122 | 122 | |
| 123 | − pool->elements = kmalloc(sizeof(struct lpfc_dmabuf) * | |
| 124 | − LPFC_MBUF_POOL_SIZE, GFP_KERNEL); | |
| 123 | + pool->elements = kmalloc_array(LPFC_MBUF_POOL_SIZE, | |
| 124 | + sizeof(struct lpfc_dmabuf), | |
| 125 | + GFP_KERNEL); | |
| 125 | 126 | if (!pool->elements) |
| 126 | 127 | goto fail_free_lpfc_mbuf_pool; |
| 127 | 128 | |
| @@ -1720,7 +1720,7 @@ lpfc_sli_next_iotag(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq) · 1719 unmodified lines | ||
| 1720 | 1720 | - LPFC_IOCBQ_LOOKUP_INCREMENT)) { |
| 1721 | 1721 | new_len = psli->iocbq_lookup_len + LPFC_IOCBQ_LOOKUP_INCREMENT; |
| 1722 | 1722 | spin_unlock_irq(&phba->hbalock); |
| 1723 | − new_arr = kzalloc(new_len * sizeof (struct lpfc_iocbq *), | |
| 1723 | + new_arr = kcalloc(new_len, sizeof(struct lpfc_iocbq *), | |
| 1724 | 1724 | GFP_KERNEL); |
| 1725 | 1725 | if (new_arr) { |
| 1726 | 1726 | spin_lock_irq(&phba->hbalock); |
| @@ -5142,16 +5142,17 @@ lpfc_sli_hba_setup(struct lpfc_hba *phba) · 3415 unmodified lines | ||
| 5142 | 5142 | */ |
| 5143 | 5143 | if ((phba->vpi_bmask == NULL) && (phba->vpi_ids == NULL)) { |
| 5144 | 5144 | longs = (phba->max_vpi + BITS_PER_LONG) / BITS_PER_LONG; |
| 5145 | − phba->vpi_bmask = kzalloc(longs * sizeof(unsigned long), | |
| 5145 | + phba->vpi_bmask = kcalloc(longs, | |
| 5146 | + sizeof(unsigned long), | |
| 5146 | 5147 | GFP_KERNEL); |
| 5147 | 5148 | if (!phba->vpi_bmask) { |
| 5148 | 5149 | rc = -ENOMEM; |
| 5149 | 5150 | goto lpfc_sli_hba_setup_error; |
| 5150 | 5151 | } |
| 5151 | 5152 | |
| 5152 | − phba->vpi_ids = kzalloc( | |
| 5153 | − (phba->max_vpi+1) * sizeof(uint16_t), | |
| 5154 | − GFP_KERNEL); | |
| 5153 | + phba->vpi_ids = kcalloc(phba->max_vpi + 1, | |
| 5154 | + sizeof(uint16_t), | |
| 5155 | + GFP_KERNEL); | |
| 5155 | 5156 | if (!phba->vpi_ids) { |
| 5156 | 5157 | kfree(phba->vpi_bmask); |
| 5157 | 5158 | rc = -ENOMEM; |
| @@ -5836,14 +5837,14 @@ lpfc_sli4_alloc_extent(struct lpfc_hba *phba, uint16_t type) · 678 unmodified lines | ||
| 5836 | 5837 | length = sizeof(struct lpfc_rsrc_blks); |
| 5837 | 5838 | switch (type) { |
| 5838 | 5839 | case LPFC_RSC_TYPE_FCOE_RPI: |
| 5839 | − phba->sli4_hba.rpi_bmask = kzalloc(longs * | |
| 5840 | + phba->sli4_hba.rpi_bmask = kcalloc(longs, | |
| 5840 | 5841 | sizeof(unsigned long), |
| 5841 | 5842 | GFP_KERNEL); |
| 5842 | 5843 | if (unlikely(!phba->sli4_hba.rpi_bmask)) { |
| 5843 | 5844 | rc = -ENOMEM; |
| 5844 | 5845 | goto err_exit; |
| 5845 | 5846 | } |
| 5846 | − phba->sli4_hba.rpi_ids = kzalloc(rsrc_id_cnt * | |
| 5847 | + phba->sli4_hba.rpi_ids = kcalloc(rsrc_id_cnt, | |
| 5847 | 5848 | sizeof(uint16_t), |
| 5848 | 5849 | GFP_KERNEL); |
| 5849 | 5850 | if (unlikely(!phba->sli4_hba.rpi_ids)) { |
| @@ -5865,15 +5866,13 @@ lpfc_sli4_alloc_extent(struct lpfc_hba *phba, uint16_t type) · 15 unmodified lines | ||
| 5865 | 5866 | ext_blk_list = &phba->sli4_hba.lpfc_rpi_blk_list; |
| 5866 | 5867 | break; |
| 5867 | 5868 | case LPFC_RSC_TYPE_FCOE_VPI: |
| 5868 | − phba->vpi_bmask = kzalloc(longs * | |
| 5869 | − sizeof(unsigned long), | |
| 5869 | + phba->vpi_bmask = kcalloc(longs, sizeof(unsigned long), | |
| 5870 | 5870 | GFP_KERNEL); |
| 5871 | 5871 | if (unlikely(!phba->vpi_bmask)) { |
| 5872 | 5872 | rc = -ENOMEM; |
| 5873 | 5873 | goto err_exit; |
| 5874 | 5874 | } |
| 5875 | − phba->vpi_ids = kzalloc(rsrc_id_cnt * | |
| 5876 | − sizeof(uint16_t), | |
| 5875 | + phba->vpi_ids = kcalloc(rsrc_id_cnt, sizeof(uint16_t), | |
| 5877 | 5876 | GFP_KERNEL); |
| 5878 | 5877 | if (unlikely(!phba->vpi_ids)) { |
| 5879 | 5878 | kfree(phba->vpi_bmask); |
| @@ -5887,7 +5886,7 @@ lpfc_sli4_alloc_extent(struct lpfc_hba *phba, uint16_t type) · 7 unmodified lines | ||
| 5887 | 5886 | ext_blk_list = &phba->lpfc_vpi_blk_list; |
| 5888 | 5887 | break; |
| 5889 | 5888 | case LPFC_RSC_TYPE_FCOE_XRI: |
| 5890 | − phba->sli4_hba.xri_bmask = kzalloc(longs * | |
| 5889 | + phba->sli4_hba.xri_bmask = kcalloc(longs, | |
| 5891 | 5890 | sizeof(unsigned long), |
| 5892 | 5891 | GFP_KERNEL); |
| 5893 | 5892 | if (unlikely(!phba->sli4_hba.xri_bmask)) { |
| @@ -5895,7 +5894,7 @@ lpfc_sli4_alloc_extent(struct lpfc_hba *phba, uint16_t type) · 1 unmodified line | ||
| 5895 | 5894 | goto err_exit; |
| 5896 | 5895 | } |
| 5897 | 5896 | phba->sli4_hba.max_cfg_param.xri_used = 0; |
| 5898 | − phba->sli4_hba.xri_ids = kzalloc(rsrc_id_cnt * | |
| 5897 | + phba->sli4_hba.xri_ids = kcalloc(rsrc_id_cnt, | |
| 5899 | 5898 | sizeof(uint16_t), |
| 5900 | 5899 | GFP_KERNEL); |
| 5901 | 5900 | if (unlikely(!phba->sli4_hba.xri_ids)) { |
| @@ -5910,14 +5909,14 @@ lpfc_sli4_alloc_extent(struct lpfc_hba *phba, uint16_t type) · 8 unmodified lines | ||
| 5910 | 5909 | ext_blk_list = &phba->sli4_hba.lpfc_xri_blk_list; |
| 5911 | 5910 | break; |
| 5912 | 5911 | case LPFC_RSC_TYPE_FCOE_VFI: |
| 5913 | − phba->sli4_hba.vfi_bmask = kzalloc(longs * | |
| 5912 | + phba->sli4_hba.vfi_bmask = kcalloc(longs, | |
| 5914 | 5913 | sizeof(unsigned long), |
| 5915 | 5914 | GFP_KERNEL); |
| 5916 | 5915 | if (unlikely(!phba->sli4_hba.vfi_bmask)) { |
| 5917 | 5916 | rc = -ENOMEM; |
| 5918 | 5917 | goto err_exit; |
| 5919 | 5918 | } |
| 5920 | − phba->sli4_hba.vfi_ids = kzalloc(rsrc_id_cnt * | |
| 5919 | + phba->sli4_hba.vfi_ids = kcalloc(rsrc_id_cnt, | |
| 5921 | 5920 | sizeof(uint16_t), |
| 5922 | 5921 | GFP_KERNEL); |
| 5923 | 5922 | if (unlikely(!phba->sli4_hba.vfi_ids)) { |
| @@ -6250,15 +6249,14 @@ lpfc_sli4_alloc_resource_identifiers(struct lpfc_hba *phba) · 326 unmodified lines | ||
| 6250 | 6249 | } |
| 6251 | 6250 | base = phba->sli4_hba.max_cfg_param.rpi_base; |
| 6252 | 6251 | longs = (count + BITS_PER_LONG - 1) / BITS_PER_LONG; |
| 6253 | − phba->sli4_hba.rpi_bmask = kzalloc(longs * | |
| 6252 | + phba->sli4_hba.rpi_bmask = kcalloc(longs, | |
| 6254 | 6253 | sizeof(unsigned long), |
| 6255 | 6254 | GFP_KERNEL); |
| 6256 | 6255 | if (unlikely(!phba->sli4_hba.rpi_bmask)) { |
| 6257 | 6256 | rc = -ENOMEM; |
| 6258 | 6257 | goto err_exit; |
| 6259 | 6258 | } |
| 6260 | − phba->sli4_hba.rpi_ids = kzalloc(count * | |
| 6261 | − sizeof(uint16_t), | |
| 6259 | + phba->sli4_hba.rpi_ids = kcalloc(count, sizeof(uint16_t), | |
| 6262 | 6260 | GFP_KERNEL); |
| 6263 | 6261 | if (unlikely(!phba->sli4_hba.rpi_ids)) { |
| 6264 | 6262 | rc = -ENOMEM; |
| @@ -6279,15 +6277,13 @@ lpfc_sli4_alloc_resource_identifiers(struct lpfc_hba *phba) · 14 unmodified lines | ||
| 6279 | 6277 | } |
| 6280 | 6278 | base = phba->sli4_hba.max_cfg_param.vpi_base; |
| 6281 | 6279 | longs = (count + BITS_PER_LONG - 1) / BITS_PER_LONG; |
| 6282 | − phba->vpi_bmask = kzalloc(longs * | |
| 6283 | − sizeof(unsigned long), | |
| 6280 | + phba->vpi_bmask = kcalloc(longs, sizeof(unsigned long), | |
| 6284 | 6281 | GFP_KERNEL); |
| 6285 | 6282 | if (unlikely(!phba->vpi_bmask)) { |
| 6286 | 6283 | rc = -ENOMEM; |
| 6287 | 6284 | goto free_rpi_ids; |
| 6288 | 6285 | } |
| 6289 | − phba->vpi_ids = kzalloc(count * | |
| 6290 | − sizeof(uint16_t), | |
| 6286 | + phba->vpi_ids = kcalloc(count, sizeof(uint16_t), | |
| 6291 | 6287 | GFP_KERNEL); |
| 6292 | 6288 | if (unlikely(!phba->vpi_ids)) { |
| 6293 | 6289 | rc = -ENOMEM; |
| @@ -6308,7 +6304,7 @@ lpfc_sli4_alloc_resource_identifiers(struct lpfc_hba *phba) · 14 unmodified lines | ||
| 6308 | 6304 | } |
| 6309 | 6305 | base = phba->sli4_hba.max_cfg_param.xri_base; |
| 6310 | 6306 | longs = (count + BITS_PER_LONG - 1) / BITS_PER_LONG; |
| 6311 | − phba->sli4_hba.xri_bmask = kzalloc(longs * | |
| 6307 | + phba->sli4_hba.xri_bmask = kcalloc(longs, | |
| 6312 | 6308 | sizeof(unsigned long), |
| 6313 | 6309 | GFP_KERNEL); |
| 6314 | 6310 | if (unlikely(!phba->sli4_hba.xri_bmask)) { |
| @@ -6316,8 +6312,7 @@ lpfc_sli4_alloc_resource_identifiers(struct lpfc_hba *phba) · 1 unmodified line | ||
| 6316 | 6312 | goto free_vpi_ids; |
| 6317 | 6313 | } |
| 6318 | 6314 | phba->sli4_hba.max_cfg_param.xri_used = 0; |
| 6319 | − phba->sli4_hba.xri_ids = kzalloc(count * | |
| 6320 | − sizeof(uint16_t), | |
| 6315 | + phba->sli4_hba.xri_ids = kcalloc(count, sizeof(uint16_t), | |
| 6321 | 6316 | GFP_KERNEL); |
| 6322 | 6317 | if (unlikely(!phba->sli4_hba.xri_ids)) { |
| 6323 | 6318 | rc = -ENOMEM; |
| @@ -6338,15 +6333,14 @@ lpfc_sli4_alloc_resource_identifiers(struct lpfc_hba *phba) · 14 unmodified lines | ||
| 6338 | 6333 | } |
| 6339 | 6334 | base = phba->sli4_hba.max_cfg_param.vfi_base; |
| 6340 | 6335 | longs = (count + BITS_PER_LONG - 1) / BITS_PER_LONG; |
| 6341 | − phba->sli4_hba.vfi_bmask = kzalloc(longs * | |
| 6336 | + phba->sli4_hba.vfi_bmask = kcalloc(longs, | |
| 6342 | 6337 | sizeof(unsigned long), |
| 6343 | 6338 | GFP_KERNEL); |
| 6344 | 6339 | if (unlikely(!phba->sli4_hba.vfi_bmask)) { |
| 6345 | 6340 | rc = -ENOMEM; |
| 6346 | 6341 | goto free_xri_ids; |
| 6347 | 6342 | } |
| 6348 | − phba->sli4_hba.vfi_ids = kzalloc(count * | |
| 6349 | − sizeof(uint16_t), | |
| 6343 | + phba->sli4_hba.vfi_ids = kcalloc(count, sizeof(uint16_t), | |
| 6350 | 6344 | GFP_KERNEL); |
| 6351 | 6345 | if (unlikely(!phba->sli4_hba.vfi_ids)) { |
| 6352 | 6346 | rc = -ENOMEM; |
| @@ -840,7 +840,7 @@ lpfc_create_vport_work_array(struct lpfc_hba *phba) · 839 unmodified lines | ||
| 840 | 840 | struct lpfc_vport *port_iterator; |
| 841 | 841 | struct lpfc_vport **vports; |
| 842 | 842 | int index = 0; |
| 843 | − vports = kzalloc((phba->max_vports + 1) * sizeof(struct lpfc_vport *), | |
| 843 | + vports = kcalloc(phba->max_vports + 1, sizeof(struct lpfc_vport *), | |
| 844 | 844 | GFP_KERNEL); |
| 845 | 845 | if (vports == NULL) |
| 846 | 846 | return NULL; |
| @@ -464,8 +464,9 @@ static int mac53c94_probe(struct macio_dev *mdev, const struct of_device_id *mat · 463 unmodified lines | ||
| 464 | 464 | * +1 to allow for aligning. |
| 465 | 465 | * XXX FIXME: Use DMA consistent routines |
| 466 | 466 | */ |
| 467 | − dma_cmd_space = kmalloc((host->sg_tablesize + 2) * | |
| 468 | − sizeof(struct dbdma_cmd), GFP_KERNEL); | |
| 467 | + dma_cmd_space = kmalloc_array(host->sg_tablesize + 2, | |
| 468 | + sizeof(struct dbdma_cmd), | |
| 469 | + GFP_KERNEL); | |
| 469 | 470 | if (dma_cmd_space == 0) { |
| 470 | 471 | printk(KERN_ERR "mac53c94: couldn't allocate dma " |
| 471 | 472 | "command space for %pOF\n", node); |
| @@ -4292,7 +4292,8 @@ megaraid_probe_one(struct pci_dev *pdev, const struct pci_device_id *id) · 4291 unmodified lines | ||
| 4292 | 4292 | goto out_host_put; |
| 4293 | 4293 | } |
| 4294 | 4294 | |
| 4295 | − adapter->scb_list = kmalloc(sizeof(scb_t) * MAX_COMMANDS, GFP_KERNEL); | |
| 4295 | + adapter->scb_list = kmalloc_array(MAX_COMMANDS, sizeof(scb_t), | |
| 4296 | + GFP_KERNEL); | |
| 4296 | 4297 | if (!adapter->scb_list) { |
| 4297 | 4298 | dev_warn(&pdev->dev, "out of RAM\n"); |
| 4298 | 4299 | goto out_free_cmd_buffer; |
| @@ -935,10 +935,12 @@ mraid_mm_register_adp(mraid_mmadp_t *lld_adp) · 934 unmodified lines | ||
| 935 | 935 | * Allocate single blocks of memory for all required kiocs, |
| 936 | 936 | * mailboxes and passthru structures. |
| 937 | 937 | */ |
| 938 | − adapter->kioc_list = kmalloc(sizeof(uioc_t) * lld_adp->max_kioc, | |
| 939 | − GFP_KERNEL); | |
| 940 | − adapter->mbox_list = kmalloc(sizeof(mbox64_t) * lld_adp->max_kioc, | |
| 941 | − GFP_KERNEL); | |
| 938 | + adapter->kioc_list = kmalloc_array(lld_adp->max_kioc, | |
| 939 | + sizeof(uioc_t), | |
| 940 | + GFP_KERNEL); | |
| 941 | + adapter->mbox_list = kmalloc_array(lld_adp->max_kioc, | |
| 942 | + sizeof(mbox64_t), | |
| 943 | + GFP_KERNEL); | |
| 942 | 944 | adapter->pthru_dma_pool = dma_pool_create("megaraid mm pthru pool", |
| 943 | 945 | &adapter->pdev->dev, |
| 944 | 946 | sizeof(mraid_passthru_t), |
| @@ -5419,9 +5419,9 @@ static int megasas_init_fw(struct megasas_instance *instance) · 5418 unmodified lines | ||
| 5419 | 5419 | /* stream detection initialization */ |
| 5420 | 5420 | if (instance->adapter_type == VENTURA_SERIES) { |
| 5421 | 5421 | fusion->stream_detect_by_ld = |
| 5422 | − kzalloc(sizeof(struct LD_STREAM_DETECT *) | |
| 5423 | − * MAX_LOGICAL_DRIVES_EXT, | |
| 5424 | − GFP_KERNEL); | |
| 5422 | + kcalloc(MAX_LOGICAL_DRIVES_EXT, | |
| 5423 | + sizeof(struct LD_STREAM_DETECT *), | |
| 5424 | + GFP_KERNEL); | |
| 5425 | 5425 | if (!fusion->stream_detect_by_ld) { |
| 5426 | 5426 | dev_err(&instance->pdev->dev, |
| 5427 | 5427 | "unable to allocate stream detection for pool of LDs\n"); |
| @@ -6139,7 +6139,7 @@ static inline int megasas_alloc_mfi_ctrl_mem(struct megasas_instance *instance) · 711 unmodified lines | ||
| 6139 | 6139 | */ |
| 6140 | 6140 | static int megasas_alloc_ctrl_mem(struct megasas_instance *instance) |
| 6141 | 6141 | { |
| 6142 | − instance->reply_map = kzalloc(sizeof(unsigned int) * nr_cpu_ids, | |
| 6142 | + instance->reply_map = kcalloc(nr_cpu_ids, sizeof(unsigned int), | |
| 6143 | 6143 | GFP_KERNEL); |
| 6144 | 6144 | if (!instance->reply_map) |
| 6145 | 6145 | return -ENOMEM; |
| @@ -487,7 +487,7 @@ megasas_alloc_cmdlist_fusion(struct megasas_instance *instance) · 486 unmodified lines | ||
| 487 | 487 | * commands. |
| 488 | 488 | */ |
| 489 | 489 | fusion->cmd_list = |
| 490 | − kzalloc(sizeof(struct megasas_cmd_fusion *) * max_mpt_cmd, | |
| 490 | + kcalloc(max_mpt_cmd, sizeof(struct megasas_cmd_fusion *), | |
| 491 | 491 | GFP_KERNEL); |
| 492 | 492 | if (!fusion->cmd_list) { |
| 493 | 493 | dev_err(&instance->pdev->dev, |
| @@ -4829,8 +4829,9 @@ megasas_alloc_fusion_context(struct megasas_instance *instance) · 4335 unmodified lines | ||
| 4829 | 4829 | (PLD_SPAN_INFO)__get_free_pages(GFP_KERNEL | __GFP_ZERO, |
| 4830 | 4830 | fusion->log_to_span_pages); |
| 4831 | 4831 | if (!fusion->log_to_span) { |
| 4832 | − fusion->log_to_span = vzalloc(MAX_LOGICAL_DRIVES_EXT * | |
| 4833 | − sizeof(LD_SPAN_INFO)); | |
| 4832 | + fusion->log_to_span = | |
| 4833 | + vzalloc(array_size(MAX_LOGICAL_DRIVES_EXT, | |
| 4834 | + sizeof(LD_SPAN_INFO))); | |
| 4834 | 4835 | if (!fusion->log_to_span) { |
| 4835 | 4836 | dev_err(&instance->pdev->dev, "Failed from %s %d\n", |
| 4836 | 4837 | __func__, __LINE__); |
| @@ -4844,8 +4845,9 @@ megasas_alloc_fusion_context(struct megasas_instance *instance) · 7 unmodified lines | ||
| 4844 | 4845 | (struct LD_LOAD_BALANCE_INFO *)__get_free_pages(GFP_KERNEL | __GFP_ZERO, |
| 4845 | 4846 | fusion->load_balance_info_pages); |
| 4846 | 4847 | if (!fusion->load_balance_info) { |
| 4847 | − fusion->load_balance_info = vzalloc(MAX_LOGICAL_DRIVES_EXT * | |
| 4848 | − sizeof(struct LD_LOAD_BALANCE_INFO)); | |
| 4848 | + fusion->load_balance_info = | |
| 4849 | + vzalloc(array_size(MAX_LOGICAL_DRIVES_EXT, | |
| 4850 | + sizeof(struct LD_LOAD_BALANCE_INFO))); | |
| 4849 | 4851 | if (!fusion->load_balance_info) |
| 4850 | 4852 | dev_err(&instance->pdev->dev, "Failed to allocate load_balance_info, " |
| 4851 | 4853 | "continuing without Load Balance support\n"); |
| @@ -381,7 +381,7 @@ static int osst_execute(struct osst_request *SRpnt, const unsigned char *cmd, · 380 unmodified lines | ||
| 381 | 381 | struct scatterlist *sg, *sgl = (struct scatterlist *)buffer; |
| 382 | 382 | int i; |
| 383 | 383 | |
| 384 | − pages = kzalloc(use_sg * sizeof(struct page *), GFP_KERNEL); | |
| 384 | + pages = kcalloc(use_sg, sizeof(struct page *), GFP_KERNEL); | |
| 385 | 385 | if (!pages) |
| 386 | 386 | goto free_req; |
| 387 | 387 | |
| @@ -1488,7 +1488,7 @@ static int osst_read_back_buffer_and_rewrite(struct osst_tape * STp, struct osst · 1100 unmodified lines | ||
| 1488 | 1488 | int dbg = debugging; |
| 1489 | 1489 | #endif |
| 1490 | 1490 | |
| 1491 | − if ((buffer = vmalloc((nframes + 1) * OS_DATA_SIZE)) == NULL) | |
| 1491 | + if ((buffer = vmalloc(array_size((nframes + 1), OS_DATA_SIZE))) == NULL) | |
| 1492 | 1492 | return (-EIO); |
| 1493 | 1493 | |
| 1494 | 1494 | printk(KERN_INFO "%s:I: Reading back %d frames from drive buffer%s\n", |
| @@ -5856,7 +5856,9 @@ static int osst_probe(struct device *dev) · 4361 unmodified lines | ||
| 5856 | 5856 | /* if this is the first attach, build the infrastructure */ |
| 5857 | 5857 | write_lock(&os_scsi_tapes_lock); |
| 5858 | 5858 | if (os_scsi_tapes == NULL) { |
| 5859 | − os_scsi_tapes = kmalloc(osst_max_dev * sizeof(struct osst_tape *), GFP_ATOMIC); | |
| 5859 | + os_scsi_tapes = kmalloc_array(osst_max_dev, | |
| 5860 | + sizeof(struct osst_tape *), | |
| 5861 | + GFP_ATOMIC); | |
| 5860 | 5862 | if (os_scsi_tapes == NULL) { |
| 5861 | 5863 | write_unlock(&os_scsi_tapes_lock); |
| 5862 | 5864 | printk(KERN_ERR "osst :E: Unable to allocate array for OnStream SCSI tapes.\n"); |
| @@ -705,7 +705,7 @@ static ssize_t pm8001_store_update_fw(struct device *cdev, · 704 unmodified lines | ||
| 705 | 705 | return -EINPROGRESS; |
| 706 | 706 | pm8001_ha->fw_status = FLASH_IN_PROGRESS; |
| 707 | 707 | |
| 708 | − cmd_ptr = kzalloc(count*2, GFP_KERNEL); | |
| 708 | + cmd_ptr = kcalloc(count, 2, GFP_KERNEL); | |
| 709 | 709 | if (!cmd_ptr) { |
| 710 | 710 | pm8001_ha->fw_status = FAIL_OUT_MEMORY; |
| 711 | 711 | return -ENOMEM; |
| @@ -4873,8 +4873,9 @@ static int pmcraid_allocate_config_buffers(struct pmcraid_instance *pinstance) · 4872 unmodified lines | ||
| 4873 | 4873 | int i; |
| 4874 | 4874 | |
| 4875 | 4875 | pinstance->res_entries = |
| 4876 | − kzalloc(sizeof(struct pmcraid_resource_entry) * | |
| 4877 | − PMCRAID_MAX_RESOURCES, GFP_KERNEL); | |
| 4876 | + kcalloc(PMCRAID_MAX_RESOURCES, | |
| 4877 | + sizeof(struct pmcraid_resource_entry), | |
| 4878 | + GFP_KERNEL); | |
| 4878 | 4879 | |
| 4879 | 4880 | if (NULL == pinstance->res_entries) { |
| 4880 | 4881 | pmcraid_err("failed to allocate memory for resource table\n"); |
| @@ -524,7 +524,7 @@ static int qedi_init_id_tbl(struct qedi_portid_tbl *id_tbl, u16 size, · 523 unmodified lines | ||
| 524 | 524 | id_tbl->max = size; |
| 525 | 525 | id_tbl->next = next; |
| 526 | 526 | spin_lock_init(&id_tbl->lock); |
| 527 | − id_tbl->table = kzalloc(DIV_ROUND_UP(size, 32) * 4, GFP_KERNEL); | |
| 527 | + id_tbl->table = kcalloc(DIV_ROUND_UP(size, 32), 4, GFP_KERNEL); | |
| 528 | 528 | if (!id_tbl->table) |
| 529 | 529 | return -ENOMEM; |
| 530 | 530 | |
| @@ -3089,8 +3089,9 @@ qla2x00_alloc_outstanding_cmds(struct qla_hw_data *ha, struct req_que *req) · 3088 unmodified lines | ||
| 3089 | 3089 | req->num_outstanding_cmds = ha->cur_fw_iocb_count; |
| 3090 | 3090 | } |
| 3091 | 3091 | |
| 3092 | − req->outstanding_cmds = kzalloc(sizeof(srb_t *) * | |
| 3093 | − req->num_outstanding_cmds, GFP_KERNEL); | |
| 3092 | + req->outstanding_cmds = kcalloc(req->num_outstanding_cmds, | |
| 3093 | + sizeof(srb_t *), | |
| 3094 | + GFP_KERNEL); | |
| 3094 | 3095 | |
| 3095 | 3096 | if (!req->outstanding_cmds) { |
| 3096 | 3097 | /* |
| @@ -3098,8 +3099,9 @@ qla2x00_alloc_outstanding_cmds(struct qla_hw_data *ha, struct req_que *req) · 1 unmodified line | ||
| 3098 | 3099 | * initialization. |
| 3099 | 3100 | */ |
| 3100 | 3101 | req->num_outstanding_cmds = MIN_OUTSTANDING_COMMANDS; |
| 3101 | − req->outstanding_cmds = kzalloc(sizeof(srb_t *) * | |
| 3102 | − req->num_outstanding_cmds, GFP_KERNEL); | |
| 3102 | + req->outstanding_cmds = kcalloc(req->num_outstanding_cmds, | |
| 3103 | + sizeof(srb_t *), | |
| 3104 | + GFP_KERNEL); | |
| 3103 | 3105 | |
| 3104 | 3106 | if (!req->outstanding_cmds) { |
| 3105 | 3107 | ql_log(ql_log_fatal, NULL, 0x0126, |
| @@ -3434,8 +3434,9 @@ qla24xx_enable_msix(struct qla_hw_data *ha, struct rsp_que *rsp) · 3433 unmodified lines | ||
| 3434 | 3434 | "Adjusted Max no of queues pairs: %d.\n", ha->max_qpairs); |
| 3435 | 3435 | } |
| 3436 | 3436 | } |
| 3437 | − ha->msix_entries = kzalloc(sizeof(struct qla_msix_entry) * | |
| 3438 | − ha->msix_count, GFP_KERNEL); | |
| 3437 | + ha->msix_entries = kcalloc(ha->msix_count, | |
| 3438 | + sizeof(struct qla_msix_entry), | |
| 3439 | + GFP_KERNEL); | |
| 3439 | 3440 | if (!ha->msix_entries) { |
| 3440 | 3441 | ql_log(ql_log_fatal, vha, 0x00c8, |
| 3441 | 3442 | "Failed to allocate memory for ha->msix_entries.\n"); |
| @@ -1230,7 +1230,7 @@ qla82xx_pinit_from_rom(scsi_qla_host_t *vha) · 1229 unmodified lines | ||
| 1230 | 1230 | ql_log(ql_log_info, vha, 0x0072, |
| 1231 | 1231 | "%d CRB init values found in ROM.\n", n); |
| 1232 | 1232 | |
| 1233 | − buf = kmalloc(n * sizeof(struct crb_addr_pair), GFP_KERNEL); | |
| 1233 | + buf = kmalloc_array(n, sizeof(struct crb_addr_pair), GFP_KERNEL); | |
| 1234 | 1234 | if (buf == NULL) { |
| 1235 | 1235 | ql_log(ql_log_fatal, vha, 0x010c, |
| 1236 | 1236 | "Unable to allocate memory.\n"); |
| @@ -410,7 +410,7 @@ static int qla2x00_alloc_queues(struct qla_hw_data *ha, struct req_que *req, · 409 unmodified lines | ||
| 410 | 410 | struct rsp_que *rsp) |
| 411 | 411 | { |
| 412 | 412 | scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev); |
| 413 | − ha->req_q_map = kzalloc(sizeof(struct req_que *) * ha->max_req_queues, | |
| 413 | + ha->req_q_map = kcalloc(ha->max_req_queues, sizeof(struct req_que *), | |
| 414 | 414 | GFP_KERNEL); |
| 415 | 415 | if (!ha->req_q_map) { |
| 416 | 416 | ql_log(ql_log_fatal, vha, 0x003b, |
| @@ -418,7 +418,7 @@ static int qla2x00_alloc_queues(struct qla_hw_data *ha, struct req_que *req, · 1 unmodified line | ||
| 418 | 418 | goto fail_req_map; |
| 419 | 419 | } |
| 420 | 420 | |
| 421 | − ha->rsp_q_map = kzalloc(sizeof(struct rsp_que *) * ha->max_rsp_queues, | |
| 421 | + ha->rsp_q_map = kcalloc(ha->max_rsp_queues, sizeof(struct rsp_que *), | |
| 422 | 422 | GFP_KERNEL); |
| 423 | 423 | if (!ha->rsp_q_map) { |
| 424 | 424 | ql_log(ql_log_fatal, vha, 0x003c, |
| @@ -4045,8 +4045,9 @@ qla2x00_mem_alloc(struct qla_hw_data *ha, uint16_t req_len, uint16_t rsp_len, · 3620 unmodified lines | ||
| 4045 | 4045 | (*rsp)->ring); |
| 4046 | 4046 | /* Allocate memory for NVRAM data for vports */ |
| 4047 | 4047 | if (ha->nvram_npiv_size) { |
| 4048 | − ha->npiv_info = kzalloc(sizeof(struct qla_npiv_entry) * | |
| 4049 | − ha->nvram_npiv_size, GFP_KERNEL); | |
| 4048 | + ha->npiv_info = kcalloc(ha->nvram_npiv_size, | |
| 4049 | + sizeof(struct qla_npiv_entry), | |
| 4050 | + GFP_KERNEL); | |
| 4050 | 4051 | if (!ha->npiv_info) { |
| 4051 | 4052 | ql_log_pci(ql_log_fatal, ha->pdev, 0x002d, |
| 4052 | 4053 | "Failed to allocate memory for npiv_info.\n"); |
| @@ -4080,8 +4081,9 @@ qla2x00_mem_alloc(struct qla_hw_data *ha, uint16_t req_len, uint16_t rsp_len, · 27 unmodified lines | ||
| 4080 | 4081 | INIT_LIST_HEAD(&ha->vp_list); |
| 4081 | 4082 | |
| 4082 | 4083 | /* Allocate memory for our loop_id bitmap */ |
| 4083 | − ha->loop_id_map = kzalloc(BITS_TO_LONGS(LOOPID_MAP_SIZE) * sizeof(long), | |
| 4084 | − GFP_KERNEL); | |
| 4084 | + ha->loop_id_map = kcalloc(BITS_TO_LONGS(LOOPID_MAP_SIZE), | |
| 4085 | + sizeof(long), | |
| 4086 | + GFP_KERNEL); | |
| 4085 | 4087 | if (!ha->loop_id_map) |
| 4086 | 4088 | goto fail_loop_id_map; |
| 4087 | 4089 | else { |
| @@ -6248,8 +6248,9 @@ int qlt_add_target(struct qla_hw_data *ha, struct scsi_qla_host *base_vha) · 6247 unmodified lines | ||
| 6248 | 6248 | return -ENOMEM; |
| 6249 | 6249 | } |
| 6250 | 6250 | |
| 6251 | − tgt->qphints = kzalloc((ha->max_qpairs + 1) * | |
| 6252 | − sizeof(struct qla_qpair_hint), GFP_KERNEL); | |
| 6251 | + tgt->qphints = kcalloc(ha->max_qpairs + 1, | |
| 6252 | + sizeof(struct qla_qpair_hint), | |
| 6253 | + GFP_KERNEL); | |
| 6253 | 6254 | if (!tgt->qphints) { |
| 6254 | 6255 | kfree(tgt); |
| 6255 | 6256 | ql_log(ql_log_warn, base_vha, 0x0197, |
| @@ -7089,8 +7090,9 @@ qlt_mem_alloc(struct qla_hw_data *ha) · 833 unmodified lines | ||
| 7089 | 7090 | if (!QLA_TGT_MODE_ENABLED()) |
| 7090 | 7091 | return 0; |
| 7091 | 7092 | |
| 7092 | − ha->tgt.tgt_vp_map = kzalloc(sizeof(struct qla_tgt_vp_map) * | |
| 7093 | − MAX_MULTI_ID_FABRIC, GFP_KERNEL); | |
| 7093 | + ha->tgt.tgt_vp_map = kcalloc(MAX_MULTI_ID_FABRIC, | |
| 7094 | + sizeof(struct qla_tgt_vp_map), | |
| 7095 | + GFP_KERNEL); | |
| 7094 | 7096 | if (!ha->tgt.tgt_vp_map) |
| 7095 | 7097 | return -ENOMEM; |
| 7096 | 7098 | |
| @@ -1661,7 +1661,9 @@ static int tcm_qla2xxx_init_lport(struct tcm_qla2xxx_lport *lport) · 1660 unmodified lines | ||
| 1661 | 1661 | return rc; |
| 1662 | 1662 | } |
| 1663 | 1663 | |
| 1664 | − lport->lport_loopid_map = vzalloc(sizeof(struct tcm_qla2xxx_fc_loopid) * 65536); | |
| 1664 | + lport->lport_loopid_map = | |
| 1665 | + vzalloc(array_size(65536, | |
| 1666 | + sizeof(struct tcm_qla2xxx_fc_loopid))); | |
| 1665 | 1667 | if (!lport->lport_loopid_map) { |
| 1666 | 1668 | pr_err("Unable to allocate lport->lport_loopid_map of %zu bytes\n", |
| 1667 | 1669 | sizeof(struct tcm_qla2xxx_fc_loopid) * 65536); |
| @@ -1077,7 +1077,7 @@ qla4_82xx_pinit_from_rom(struct scsi_qla_host *ha, int verbose) · 1076 unmodified lines | ||
| 1077 | 1077 | ql4_printk(KERN_INFO, ha, |
| 1078 | 1078 | "%s: %d CRB init values found in ROM.\n", DRIVER_NAME, n); |
| 1079 | 1079 | |
| 1080 | − buf = kmalloc(n * sizeof(struct crb_addr_pair), GFP_KERNEL); | |
| 1080 | + buf = kmalloc_array(n, sizeof(struct crb_addr_pair), GFP_KERNEL); | |
| 1081 | 1081 | if (buf == NULL) { |
| 1082 | 1082 | ql4_printk(KERN_WARNING, ha, |
| 1083 | 1083 | "%s: [ERROR] Unable to malloc memory.\n", DRIVER_NAME); |
| @@ -3450,7 +3450,7 @@ static int resp_comp_write(struct scsi_cmnd *scp, · 3449 unmodified lines | ||
| 3450 | 3450 | return check_condition_result; |
| 3451 | 3451 | } |
| 3452 | 3452 | dnum = 2 * num; |
| 3453 | − arr = kzalloc(dnum * lb_size, GFP_ATOMIC); | |
| 3453 | + arr = kcalloc(lb_size, dnum, GFP_ATOMIC); | |
| 3454 | 3454 | if (NULL == arr) { |
| 3455 | 3455 | mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC, |
| 3456 | 3456 | INSUFF_RES_ASCQ); |
| @@ -5439,7 +5439,8 @@ static int __init scsi_debug_init(void) · 1982 unmodified lines | ||
| 5439 | 5439 | } |
| 5440 | 5440 | |
| 5441 | 5441 | map_size = lba_to_map_index(sdebug_store_sectors - 1) + 1; |
| 5442 | − map_storep = vmalloc(BITS_TO_LONGS(map_size) * sizeof(long)); | |
| 5442 | + map_storep = vmalloc(array_size(sizeof(long), | |
| 5443 | + BITS_TO_LONGS(map_size))); | |
| 5443 | 5444 | |
| 5444 | 5445 | pr_info("%lu provisioning blocks\n", map_size); |
| 5445 | 5446 | |
| @@ -494,7 +494,7 @@ out_free: · 493 unmodified lines | ||
| 494 | 494 | static inline unsigned long * |
| 495 | 495 | sd_zbc_alloc_zone_bitmap(u32 nr_zones, int numa_node) |
| 496 | 496 | { |
| 497 | − return kzalloc_node(BITS_TO_LONGS(nr_zones) * sizeof(unsigned long), | |
| 497 | + return kcalloc_node(BITS_TO_LONGS(nr_zones), sizeof(unsigned long), | |
| 498 | 498 | GFP_KERNEL, numa_node); |
| 499 | 499 | } |
| 500 | 500 | |
| @@ -747,7 +747,7 @@ static int ses_intf_add(struct device *cdev, · 746 unmodified lines | ||
| 747 | 747 | buf = NULL; |
| 748 | 748 | } |
| 749 | 749 | page2_not_supported: |
| 750 | − scomp = kzalloc(sizeof(struct ses_component) * components, GFP_KERNEL); | |
| 750 | + scomp = kcalloc(components, sizeof(struct ses_component), GFP_KERNEL); | |
| 751 | 751 | if (!scomp) |
| 752 | 752 | goto err_free; |
| 753 | 753 | |
| @@ -1045,7 +1045,7 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg) · 1044 unmodified lines | ||
| 1045 | 1045 | else { |
| 1046 | 1046 | sg_req_info_t *rinfo; |
| 1047 | 1047 | |
| 1048 | − rinfo = kzalloc(SZ_SG_REQ_INFO * SG_MAX_QUEUE, | |
| 1048 | + rinfo = kcalloc(SG_MAX_QUEUE, SZ_SG_REQ_INFO, | |
| 1049 | 1049 | GFP_KERNEL); |
| 1050 | 1050 | if (!rinfo) |
| 1051 | 1051 | return -ENOMEM; |
| @@ -1820,8 +1820,9 @@ static int pqi_update_scsi_devices(struct pqi_ctrl_info *ctrl_info) · 1819 unmodified lines | ||
| 1820 | 1820 | |
| 1821 | 1821 | num_new_devices = num_physicals + num_logicals; |
| 1822 | 1822 | |
| 1823 | − new_device_list = kmalloc(sizeof(*new_device_list) * | |
| 1824 | − num_new_devices, GFP_KERNEL); | |
| 1823 | + new_device_list = kmalloc_array(num_new_devices, | |
| 1824 | + sizeof(*new_device_list), | |
| 1825 | + GFP_KERNEL); | |
| 1825 | 1826 | if (!new_device_list) { |
| 1826 | 1827 | dev_warn(&ctrl_info->pci_dev->dev, "%s\n", out_of_memory_msg); |
| 1827 | 1828 | rc = -ENOMEM; |
| @@ -4251,8 +4252,9 @@ static int pqi_alloc_io_resources(struct pqi_ctrl_info *ctrl_info) · 2423 unmodified lines | ||
| 4251 | 4252 | struct device *dev; |
| 4252 | 4253 | struct pqi_io_request *io_request; |
| 4253 | 4254 | |
| 4254 | − ctrl_info->io_request_pool = kzalloc(ctrl_info->max_io_slots * | |
| 4255 | − sizeof(ctrl_info->io_request_pool[0]), GFP_KERNEL); | |
| 4255 | + ctrl_info->io_request_pool = | |
| 4256 | + kcalloc(ctrl_info->max_io_slots, | |
| 4257 | + sizeof(ctrl_info->io_request_pool[0]), GFP_KERNEL); | |
| 4256 | 4258 | |
| 4257 | 4259 | if (!ctrl_info->io_request_pool) { |
| 4258 | 4260 | dev_err(&ctrl_info->pci_dev->dev, |
| @@ -3888,7 +3888,7 @@ static struct st_buffer *new_tape_buffer(int need_dma, int max_sg) · 3887 unmodified lines | ||
| 3888 | 3888 | tb->dma = need_dma; |
| 3889 | 3889 | tb->buffer_size = 0; |
| 3890 | 3890 | |
| 3891 | − tb->reserved_pages = kzalloc(max_sg * sizeof(struct page *), | |
| 3891 | + tb->reserved_pages = kcalloc(max_sg, sizeof(struct page *), | |
| 3892 | 3892 | GFP_KERNEL); |
| 3893 | 3893 | if (!tb->reserved_pages) { |
| 3894 | 3894 | kfree(tb); |
| @@ -4915,7 +4915,8 @@ static int sgl_map_user_pages(struct st_buffer *STbp, · 1020 unmodified lines | ||
| 4915 | 4915 | if (count == 0) |
| 4916 | 4916 | return 0; |
| 4917 | 4917 | |
| 4918 | − if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_KERNEL)) == NULL) | |
| 4918 | + pages = kmalloc_array(max_pages, sizeof(*pages), GFP_KERNEL); | |
| 4919 | + if (pages == NULL) | |
| 4919 | 4920 | return -ENOMEM; |
| 4920 | 4921 | |
| 4921 | 4922 | /* Try to fault in all of the necessary pages */ |
| @@ -86,8 +86,8 @@ static int ufshcd_parse_clock_info(struct ufs_hba *hba) · 85 unmodified lines | ||
| 86 | 86 | goto out; |
| 87 | 87 | } |
| 88 | 88 | |
| 89 | − clkfreq = devm_kzalloc(dev, sz * sizeof(*clkfreq), | |
| 90 | − GFP_KERNEL); | |
| 89 | + clkfreq = devm_kcalloc(dev, sz, sizeof(*clkfreq), | |
| 90 | + GFP_KERNEL); | |
| 91 | 91 | if (!clkfreq) { |
| 92 | 92 | ret = -ENOMEM; |
| 93 | 93 | goto out; |
| @@ -3357,8 +3357,8 @@ static int ufshcd_memory_alloc(struct ufs_hba *hba) · 3356 unmodified lines | ||
| 3357 | 3357 | } |
| 3358 | 3358 | |
| 3359 | 3359 | /* Allocate memory for local reference block */ |
| 3360 | − hba->lrb = devm_kzalloc(hba->dev, | |
| 3361 | − hba->nutrs * sizeof(struct ufshcd_lrb), | |
| 3360 | + hba->lrb = devm_kcalloc(hba->dev, | |
| 3361 | + hba->nutrs, sizeof(struct ufshcd_lrb), | |
| 3362 | 3362 | GFP_KERNEL); |
| 3363 | 3363 | if (!hba->lrb) { |
| 3364 | 3364 | dev_err(hba->dev, "LRB Memory allocation failed\n"); |
| @@ -794,9 +794,10 @@ static int virtscsi_init(struct virtio_device *vdev, · 793 unmodified lines | ||
| 794 | 794 | struct irq_affinity desc = { .pre_vectors = 2 }; |
| 795 | 795 | |
| 796 | 796 | num_vqs = vscsi->num_queues + VIRTIO_SCSI_VQ_BASE; |
| 797 | − vqs = kmalloc(num_vqs * sizeof(struct virtqueue *), GFP_KERNEL); | |
| 798 | − callbacks = kmalloc(num_vqs * sizeof(vq_callback_t *), GFP_KERNEL); | |
| 799 | − names = kmalloc(num_vqs * sizeof(char *), GFP_KERNEL); | |
| 797 | + vqs = kmalloc_array(num_vqs, sizeof(struct virtqueue *), GFP_KERNEL); | |
| 798 | + callbacks = kmalloc_array(num_vqs, sizeof(vq_callback_t *), | |
| 799 | + GFP_KERNEL); | |
| 800 | + names = kmalloc_array(num_vqs, sizeof(char *), GFP_KERNEL); | |
| 800 | 801 | |
| 801 | 802 | if (!callbacks || !vqs || !names) { |
| 802 | 803 | err = -ENOMEM; |
| @@ -249,7 +249,7 @@ static int __init sh_clk_div_register_ops(struct clk *clks, int nr, · 248 unmodified lines | ||
| 249 | 249 | int k; |
| 250 | 250 | |
| 251 | 251 | freq_table_size *= (nr_divs + 1); |
| 252 | − freq_table = kzalloc(freq_table_size * nr, GFP_KERNEL); | |
| 252 | + freq_table = kcalloc(nr, freq_table_size, GFP_KERNEL); | |
| 253 | 253 | if (!freq_table) { |
| 254 | 254 | pr_err("%s: unable to alloc memory\n", __func__); |
| 255 | 255 | return -ENOMEM; |
| @@ -203,7 +203,7 @@ int __init register_intc_controller(struct intc_desc *desc) · 202 unmodified lines | ||
| 203 | 203 | |
| 204 | 204 | if (desc->num_resources) { |
| 205 | 205 | d->nr_windows = desc->num_resources; |
| 206 | − d->window = kzalloc(d->nr_windows * sizeof(*d->window), | |
| 206 | + d->window = kcalloc(d->nr_windows, sizeof(*d->window), | |
| 207 | 207 | GFP_NOWAIT); |
| 208 | 208 | if (!d->window) |
| 209 | 209 | goto err1; |
| @@ -230,12 +230,12 @@ int __init register_intc_controller(struct intc_desc *desc) · 20 unmodified lines | ||
| 230 | 230 | d->nr_reg += hw->ack_regs ? hw->nr_ack_regs : 0; |
| 231 | 231 | d->nr_reg += hw->subgroups ? hw->nr_subgroups : 0; |
| 232 | 232 | |
| 233 | − d->reg = kzalloc(d->nr_reg * sizeof(*d->reg), GFP_NOWAIT); | |
| 233 | + d->reg = kcalloc(d->nr_reg, sizeof(*d->reg), GFP_NOWAIT); | |
| 234 | 234 | if (!d->reg) |
| 235 | 235 | goto err2; |
| 236 | 236 | |
| 237 | 237 | #ifdef CONFIG_SMP |
| 238 | − d->smp = kzalloc(d->nr_reg * sizeof(*d->smp), GFP_NOWAIT); | |
| 238 | + d->smp = kcalloc(d->nr_reg, sizeof(*d->smp), GFP_NOWAIT); | |
| 239 | 239 | if (!d->smp) |
| 240 | 240 | goto err3; |
| 241 | 241 | #endif |
| @@ -253,7 +253,7 @@ int __init register_intc_controller(struct intc_desc *desc) · 11 unmodified lines | ||
| 253 | 253 | } |
| 254 | 254 | |
| 255 | 255 | if (hw->prio_regs) { |
| 256 | − d->prio = kzalloc(hw->nr_vectors * sizeof(*d->prio), | |
| 256 | + d->prio = kcalloc(hw->nr_vectors, sizeof(*d->prio), | |
| 257 | 257 | GFP_NOWAIT); |
| 258 | 258 | if (!d->prio) |
| 259 | 259 | goto err4; |
| @@ -269,7 +269,7 @@ int __init register_intc_controller(struct intc_desc *desc) · 9 unmodified lines | ||
| 269 | 269 | } |
| 270 | 270 | |
| 271 | 271 | if (hw->sense_regs) { |
| 272 | − d->sense = kzalloc(hw->nr_vectors * sizeof(*d->sense), | |
| 272 | + d->sense = kcalloc(hw->nr_vectors, sizeof(*d->sense), | |
| 273 | 273 | GFP_NOWAIT); |
| 274 | 274 | if (!d->sense) |
| 275 | 275 | goto err5; |
| @@ -161,7 +161,7 @@ int maple_add_packet(struct maple_device *mdev, u32 function, u32 command, · 160 unmodified lines | ||
| 161 | 161 | void *sendbuf = NULL; |
| 162 | 162 | |
| 163 | 163 | if (length) { |
| 164 | − sendbuf = kzalloc(length * 4, GFP_KERNEL); | |
| 164 | + sendbuf = kcalloc(length, 4, GFP_KERNEL); | |
| 165 | 165 | if (!sendbuf) { |
| 166 | 166 | ret = -ENOMEM; |
| 167 | 167 | goto out; |
| @@ -540,7 +540,7 @@ static int qcom_slim_probe(struct platform_device *pdev) · 539 unmodified lines | ||
| 540 | 540 | ctrl->tx.sl_sz = SLIM_MSGQ_BUF_LEN; |
| 541 | 541 | ctrl->rx.n = QCOM_RX_MSGS; |
| 542 | 542 | ctrl->rx.sl_sz = SLIM_MSGQ_BUF_LEN; |
| 543 | − ctrl->wr_comp = kzalloc(sizeof(struct completion *) * QCOM_TX_MSGS, | |
| 543 | + ctrl->wr_comp = kcalloc(QCOM_TX_MSGS, sizeof(struct completion *), | |
| 544 | 544 | GFP_KERNEL); |
| 545 | 545 | if (!ctrl->wr_comp) |
| 546 | 546 | return -ENOMEM; |
| @@ -165,8 +165,10 @@ static int rpi_power_probe(struct platform_device *pdev) · 164 unmodified lines | ||
| 165 | 165 | return -ENOMEM; |
| 166 | 166 | |
| 167 | 167 | rpi_domains->xlate.domains = |
| 168 | − devm_kzalloc(dev, sizeof(*rpi_domains->xlate.domains) * | |
| 169 | − RPI_POWER_DOMAIN_COUNT, GFP_KERNEL); | |
| 168 | + devm_kcalloc(dev, | |
| 169 | + RPI_POWER_DOMAIN_COUNT, | |
| 170 | + sizeof(*rpi_domains->xlate.domains), | |
| 171 | + GFP_KERNEL); | |
| 170 | 172 | if (!rpi_domains->xlate.domains) |
| 171 | 173 | return -ENOMEM; |
| 172 | 174 | |
| @@ -1021,7 +1021,8 @@ int qman_alloc_fq_table(u32 _num_fqids) · 1020 unmodified lines | ||
| 1021 | 1021 | { |
| 1022 | 1022 | num_fqids = _num_fqids; |
| 1023 | 1023 | |
| 1024 | − fq_table = vzalloc(num_fqids * 2 * sizeof(struct qman_fq *)); | |
| 1024 | + fq_table = vzalloc(array3_size(sizeof(struct qman_fq *), | |
| 1025 | + num_fqids, 2)); | |
| 1025 | 1026 | if (!fq_table) |
| 1026 | 1027 | return -ENOMEM; |
| 1027 | 1028 | |
| @@ -1181,7 +1182,7 @@ static int qman_create_portal(struct qman_portal *portal, · 153 unmodified lines | ||
| 1181 | 1182 | qm_dqrr_set_ithresh(p, QMAN_PIRQ_DQRR_ITHRESH); |
| 1182 | 1183 | qm_mr_set_ithresh(p, QMAN_PIRQ_MR_ITHRESH); |
| 1183 | 1184 | qm_out(p, QM_REG_ITPR, QMAN_PIRQ_IPERIOD); |
| 1184 | − portal->cgrs = kmalloc(2 * sizeof(*cgrs), GFP_KERNEL); | |
| 1185 | + portal->cgrs = kmalloc_array(2, sizeof(*cgrs), GFP_KERNEL); | |
| 1185 | 1186 | if (!portal->cgrs) |
| 1186 | 1187 | goto fail_cgrs; |
| 1187 | 1188 | /* initial snapshot is no-depletion */ |
| @@ -376,15 +376,15 @@ static struct scp *init_scp(struct platform_device *pdev, · 375 unmodified lines | ||
| 376 | 376 | if (IS_ERR(scp->base)) |
| 377 | 377 | return ERR_CAST(scp->base); |
| 378 | 378 | |
| 379 | − scp->domains = devm_kzalloc(&pdev->dev, | |
| 380 | − sizeof(*scp->domains) * num, GFP_KERNEL); | |
| 379 | + scp->domains = devm_kcalloc(&pdev->dev, | |
| 380 | + num, sizeof(*scp->domains), GFP_KERNEL); | |
| 381 | 381 | if (!scp->domains) |
| 382 | 382 | return ERR_PTR(-ENOMEM); |
| 383 | 383 | |
| 384 | 384 | pd_data = &scp->pd_data; |
| 385 | 385 | |
| 386 | − pd_data->domains = devm_kzalloc(&pdev->dev, | |
| 387 | − sizeof(*pd_data->domains) * num, GFP_KERNEL); | |
| 386 | + pd_data->domains = devm_kcalloc(&pdev->dev, | |
| 387 | + num, sizeof(*pd_data->domains), GFP_KERNEL); | |
| 388 | 388 | if (!pd_data->domains) |
| 389 | 389 | return ERR_PTR(-ENOMEM); |
| 390 | 390 | |
| @@ -405,8 +405,8 @@ static int knav_acc_init_queue(struct knav_range_info *range, · 404 unmodified lines | ||
| 405 | 405 | { |
| 406 | 406 | unsigned id = kq->id - range->queue_base; |
| 407 | 407 | |
| 408 | − kq->descs = devm_kzalloc(range->kdev->dev, | |
| 409 | − ACC_DESCS_MAX * sizeof(u32), GFP_KERNEL); | |
| 408 | + kq->descs = devm_kcalloc(range->kdev->dev, | |
| 409 | + ACC_DESCS_MAX, sizeof(u32), GFP_KERNEL); | |
| 410 | 410 | if (!kq->descs) |
| 411 | 411 | return -ENOMEM; |
| 412 | 412 | |
| @@ -552,7 +552,7 @@ int knav_init_acc_range(struct knav_device *kdev, · 139 unmodified lines | ||
| 552 | 552 | info->list_size = list_size; |
| 553 | 553 | mem_size = PAGE_ALIGN(list_size * 2); |
| 554 | 554 | info->mem_size = mem_size; |
| 555 | − range->acc = devm_kzalloc(kdev->dev, channels * sizeof(*range->acc), | |
| 555 | + range->acc = devm_kcalloc(kdev->dev, channels, sizeof(*range->acc), | |
| 556 | 556 | GFP_KERNEL); |
| 557 | 557 | if (!range->acc) |
| 558 | 558 | return -ENOMEM; |
| @@ -923,9 +923,10 @@ static int davinci_spi_probe(struct platform_device *pdev) · 922 unmodified lines | ||
| 923 | 923 | /* pdata in dspi is now updated and point pdata to that */ |
| 924 | 924 | pdata = &dspi->pdata; |
| 925 | 925 | |
| 926 | − dspi->bytes_per_word = devm_kzalloc(&pdev->dev, | |
| 927 | − sizeof(*dspi->bytes_per_word) * | |
| 928 | − pdata->num_chipselect, GFP_KERNEL); | |
| 926 | + dspi->bytes_per_word = devm_kcalloc(&pdev->dev, | |
| 927 | + pdata->num_chipselect, | |
| 928 | + sizeof(*dspi->bytes_per_word), | |
| 929 | + GFP_KERNEL); | |
| 929 | 930 | if (dspi->bytes_per_word == NULL) { |
| 930 | 931 | ret = -ENOMEM; |
| 931 | 932 | goto free_master; |
| @@ -671,8 +671,8 @@ static int ep93xx_spi_probe(struct platform_device *pdev) · 670 unmodified lines | ||
| 671 | 671 | master->bits_per_word_mask = SPI_BPW_RANGE_MASK(4, 16); |
| 672 | 672 | |
| 673 | 673 | master->num_chipselect = info->num_chipselect; |
| 674 | − master->cs_gpios = devm_kzalloc(&master->dev, | |
| 675 | − sizeof(int) * master->num_chipselect, | |
| 674 | + master->cs_gpios = devm_kcalloc(&master->dev, | |
| 675 | + master->num_chipselect, sizeof(int), | |
| 676 | 676 | GFP_KERNEL); |
| 677 | 677 | if (!master->cs_gpios) { |
| 678 | 678 | error = -ENOMEM; |
| @@ -373,8 +373,9 @@ static int spi_gpio_probe(struct platform_device *pdev) · 372 unmodified lines | ||
| 373 | 373 | |
| 374 | 374 | spi_gpio = spi_master_get_devdata(master); |
| 375 | 375 | |
| 376 | − spi_gpio->cs_gpios = devm_kzalloc(&pdev->dev, | |
| 377 | − pdata->num_chipselect * sizeof(*spi_gpio->cs_gpios), | |
| 376 | + spi_gpio->cs_gpios = devm_kcalloc(&pdev->dev, | |
| 377 | + pdata->num_chipselect, | |
| 378 | + sizeof(*spi_gpio->cs_gpios), | |
| 378 | 379 | GFP_KERNEL); |
| 379 | 380 | if (!spi_gpio->cs_gpios) |
| 380 | 381 | return -ENOMEM; |
| @@ -1511,8 +1511,9 @@ static int spi_imx_probe(struct platform_device *pdev) · 1510 unmodified lines | ||
| 1511 | 1511 | if (mxc_platform_info) { |
| 1512 | 1512 | master->num_chipselect = mxc_platform_info->num_chipselect; |
| 1513 | 1513 | if (mxc_platform_info->chipselect) { |
| 1514 | − master->cs_gpios = devm_kzalloc(&master->dev, | |
| 1515 | − sizeof(int) * master->num_chipselect, GFP_KERNEL); | |
| 1514 | + master->cs_gpios = devm_kcalloc(&master->dev, | |
| 1515 | + master->num_chipselect, sizeof(int), | |
| 1516 | + GFP_KERNEL); | |
| 1516 | 1517 | if (!master->cs_gpios) |
| 1517 | 1518 | return -ENOMEM; |
| 1518 | 1519 | |
| @@ -213,8 +213,8 @@ static int tiny_spi_of_probe(struct platform_device *pdev) · 212 unmodified lines | ||
| 213 | 213 | return 0; |
| 214 | 214 | hw->gpio_cs_count = of_gpio_count(np); |
| 215 | 215 | if (hw->gpio_cs_count > 0) { |
| 216 | − hw->gpio_cs = devm_kzalloc(&pdev->dev, | |
| 217 | − hw->gpio_cs_count * sizeof(unsigned int), | |
| 216 | + hw->gpio_cs = devm_kcalloc(&pdev->dev, | |
| 217 | + hw->gpio_cs_count, sizeof(unsigned int), | |
| 218 | 218 | GFP_KERNEL); |
| 219 | 219 | if (!hw->gpio_cs) |
| 220 | 220 | return -ENOMEM; |
| @@ -2135,7 +2135,7 @@ static int pl022_probe(struct amba_device *adev, const struct amba_id *id) · 2134 unmodified lines | ||
| 2135 | 2135 | pl022->master_info = platform_info; |
| 2136 | 2136 | pl022->adev = adev; |
| 2137 | 2137 | pl022->vendor = id->data; |
| 2138 | − pl022->chipselects = devm_kzalloc(dev, num_cs * sizeof(int), | |
| 2138 | + pl022->chipselects = devm_kcalloc(dev, num_cs, sizeof(int), | |
| 2139 | 2139 | GFP_KERNEL); |
| 2140 | 2140 | if (!pl022->chipselects) { |
| 2141 | 2141 | status = -ENOMEM; |
| @@ -2049,7 +2049,7 @@ static int of_spi_register_master(struct spi_controller *ctlr) · 2048 unmodified lines | ||
| 2049 | 2049 | else if (nb < 0) |
| 2050 | 2050 | return nb; |
| 2051 | 2051 | |
| 2052 | − cs = devm_kzalloc(&ctlr->dev, sizeof(int) * ctlr->num_chipselect, | |
| 2052 | + cs = devm_kcalloc(&ctlr->dev, ctlr->num_chipselect, sizeof(int), | |
| 2053 | 2053 | GFP_KERNEL); |
| 2054 | 2054 | ctlr->cs_gpios = cs; |
| 2055 | 2055 | |
| @@ -25,7 +25,8 @@ void *ion_heap_map_kernel(struct ion_heap *heap, · 24 unmodified lines | ||
| 25 | 25 | pgprot_t pgprot; |
| 26 | 26 | struct sg_table *table = buffer->sg_table; |
| 27 | 27 | int npages = PAGE_ALIGN(buffer->size) / PAGE_SIZE; |
| 28 | − struct page **pages = vmalloc(sizeof(struct page *) * npages); | |
| 28 | + struct page **pages = vmalloc(array_size(npages, | |
| 29 | + sizeof(struct page *))); | |
| 29 | 30 | struct page **tmp = pages; |
| 30 | 31 | |
| 31 | 32 | if (!pages) |
| @@ -144,7 +144,7 @@ static const char **gb_generate_enum_strings(struct gbaudio_module_info *gb, · 143 unmodified lines | ||
| 144 | 144 | __u8 *data; |
| 145 | 145 | |
| 146 | 146 | items = le32_to_cpu(gbenum->items); |
| 147 | − strings = devm_kzalloc(gb->dev, sizeof(char *) * items, GFP_KERNEL); | |
| 147 | + strings = devm_kcalloc(gb->dev, items, sizeof(char *), GFP_KERNEL); | |
| 148 | 148 | data = gbenum->names; |
| 149 | 149 | |
| 150 | 150 | for (i = 0; i < items; i++) { |
| @@ -1175,8 +1175,9 @@ static int gb_camera_debugfs_init(struct gb_camera *gcam) · 1174 unmodified lines | ||
| 1175 | 1175 | |
| 1176 | 1176 | gcam->debugfs.root = debugfs_create_dir(dirname, gb_debugfs_get()); |
| 1177 | 1177 | |
| 1178 | − gcam->debugfs.buffers = vmalloc(sizeof(*gcam->debugfs.buffers) * | |
| 1179 | − GB_CAMERA_DEBUGFS_BUFFER_MAX); | |
| 1178 | + gcam->debugfs.buffers = | |
| 1179 | + vmalloc(array_size(GB_CAMERA_DEBUGFS_BUFFER_MAX, | |
| 1180 | + sizeof(*gcam->debugfs.buffers))); | |
| 1180 | 1181 | if (!gcam->debugfs.buffers) |
| 1181 | 1182 | return -ENOMEM; |
| 1182 | 1183 | |
| @@ -303,9 +303,9 @@ static int imx_media_alloc_pad_vdev_lists(struct imx_media_dev *imxmd) · 302 unmodified lines | ||
| 303 | 303 | |
| 304 | 304 | list_for_each_entry(sd, &imxmd->v4l2_dev.subdevs, list) { |
| 305 | 305 | entity = &sd->entity; |
| 306 | − vdev_lists = devm_kzalloc( | |
| 306 | + vdev_lists = devm_kcalloc( | |
| 307 | 307 | imxmd->md.dev, |
| 308 | − entity->num_pads * sizeof(*vdev_lists), | |
| 308 | + entity->num_pads, sizeof(*vdev_lists), | |
| 309 | 309 | GFP_KERNEL); |
| 310 | 310 | if (!vdev_lists) |
| 311 | 311 | return -ENOMEM; |
| @@ -544,7 +544,7 @@ static int imx_media_probe(struct platform_device *pdev) · 232 unmodified lines | ||
| 544 | 544 | goto unreg_dev; |
| 545 | 545 | } |
| 546 | 546 | |
| 547 | − subdevs = devm_kzalloc(imxmd->md.dev, sizeof(*subdevs) * num_subdevs, | |
| 547 | + subdevs = devm_kcalloc(imxmd->md.dev, num_subdevs, sizeof(*subdevs), | |
| 548 | 548 | GFP_KERNEL); |
| 549 | 549 | if (!subdevs) { |
| 550 | 550 | ret = -ENOMEM; |
| @@ -941,7 +941,7 @@ static int zoran_open(struct file *file) · 940 unmodified lines | ||
| 941 | 941 | /* used to be BUZ_MAX_WIDTH/HEIGHT, but that gives overflows |
| 942 | 942 | * on norm-change! */ |
| 943 | 943 | fh->overlay_mask = |
| 944 | − kmalloc(((768 + 31) / 32) * 576 * 4, GFP_KERNEL); | |
| 944 | + kmalloc(array3_size((768 + 31) / 32, 576, 4), GFP_KERNEL); | |
| 945 | 945 | if (!fh->overlay_mask) { |
| 946 | 946 | dprintk(1, |
| 947 | 947 | KERN_ERR |
| @@ -1220,7 +1220,8 @@ static int setup_window(struct zoran_fh *fh, · 272 unmodified lines | ||
| 1220 | 1220 | } |
| 1221 | 1221 | } else if (clipcount) { |
| 1222 | 1222 | /* write our own bitmap from the clips */ |
| 1223 | − vcp = vmalloc(sizeof(struct v4l2_clip) * (clipcount + 4)); | |
| 1223 | + vcp = vmalloc(array_size(sizeof(struct v4l2_clip), | |
| 1224 | + clipcount + 4)); | |
| 1224 | 1225 | if (vcp == NULL) { |
| 1225 | 1226 | dprintk(1, |
| 1226 | 1227 | KERN_ERR |
| @@ -143,7 +143,7 @@ static int rt2880_pinctrl_dt_node_to_map(struct pinctrl_dev *pctrldev, · 142 unmodified lines | ||
| 143 | 143 | if (!max_maps) |
| 144 | 144 | return max_maps; |
| 145 | 145 | |
| 146 | − *map = kzalloc(max_maps * sizeof(struct pinctrl_map), GFP_KERNEL); | |
| 146 | + *map = kcalloc(max_maps, sizeof(struct pinctrl_map), GFP_KERNEL); | |
| 147 | 147 | if (!*map) |
| 148 | 148 | return -ENOMEM; |
| 149 | 149 | |
| @@ -287,7 +287,8 @@ static int rt2880_pinmux_index(struct rt2880_priv *p) · 137 unmodified lines | ||
| 287 | 287 | } |
| 288 | 288 | |
| 289 | 289 | /* allocate the group names array needed by the gpio function */ |
| 290 | − p->group_names = devm_kzalloc(p->dev, sizeof(char *) * p->group_count, GFP_KERNEL); | |
| 290 | + p->group_names = devm_kcalloc(p->dev, p->group_count, sizeof(char *), | |
| 291 | + GFP_KERNEL); | |
| 291 | 292 | if (!p->group_names) |
| 292 | 293 | return -1; |
| 293 | 294 | |
| @@ -300,8 +301,12 @@ static int rt2880_pinmux_index(struct rt2880_priv *p) · 6 unmodified lines | ||
| 300 | 301 | p->func_count++; |
| 301 | 302 | |
| 302 | 303 | /* allocate our function and group mapping index buffers */ |
| 303 | − f = p->func = devm_kzalloc(p->dev, sizeof(struct rt2880_pmx_func) * p->func_count, GFP_KERNEL); | |
| 304 | − gpio_func.groups = devm_kzalloc(p->dev, sizeof(int) * p->group_count, GFP_KERNEL); | |
| 304 | + f = p->func = devm_kcalloc(p->dev, | |
| 305 | + p->func_count, | |
| 306 | + sizeof(struct rt2880_pmx_func), | |
| 307 | + GFP_KERNEL); | |
| 308 | + gpio_func.groups = devm_kcalloc(p->dev, p->group_count, sizeof(int), | |
| 309 | + GFP_KERNEL); | |
| 305 | 310 | if (!f || !gpio_func.groups) |
| 306 | 311 | return -1; |
| 307 | 312 | |
| @@ -337,7 +342,10 @@ static int rt2880_pinmux_pins(struct rt2880_priv *p) · 29 unmodified lines | ||
| 337 | 342 | if (!p->func[i]->pin_count) |
| 338 | 343 | continue; |
| 339 | 344 | |
| 340 | − p->func[i]->pins = devm_kzalloc(p->dev, sizeof(int) * p->func[i]->pin_count, GFP_KERNEL); | |
| 345 | + p->func[i]->pins = devm_kcalloc(p->dev, | |
| 346 | + p->func[i]->pin_count, | |
| 347 | + sizeof(int), | |
| 348 | + GFP_KERNEL); | |
| 341 | 349 | for (j = 0; j < p->func[i]->pin_count; j++) |
| 342 | 350 | p->func[i]->pins[j] = p->func[i]->pin_first + j; |
| 343 | 351 | |
| @@ -347,11 +355,11 @@ static int rt2880_pinmux_pins(struct rt2880_priv *p) · 3 unmodified lines | ||
| 347 | 355 | } |
| 348 | 356 | |
| 349 | 357 | /* the buffer that tells us which pins are gpio */ |
| 350 | − p->gpio = devm_kzalloc(p->dev,sizeof(uint8_t) * p->max_pins, | |
| 351 | − GFP_KERNEL); | |
| 358 | + p->gpio = devm_kcalloc(p->dev,p->max_pins, sizeof(uint8_t), | |
| 359 | + GFP_KERNEL); | |
| 352 | 360 | /* the pads needed to tell pinctrl about our pins */ |
| 353 | − p->pads = devm_kzalloc(p->dev, | |
| 354 | − sizeof(struct pinctrl_pin_desc) * p->max_pins, | |
| 361 | + p->pads = devm_kcalloc(p->dev, | |
| 362 | + p->max_pins, sizeof(struct pinctrl_pin_desc), | |
| 355 | 363 | GFP_KERNEL); |
| 356 | 364 | if (!p->pads || !p->gpio ) { |
| 357 | 365 | dev_err(p->dev, "Failed to allocate gpio data\n"); |
| @@ -53,7 +53,7 @@ int rtw_init_mlme_priv(struct adapter *padapter) · 52 unmodified lines | ||
| 53 | 53 | |
| 54 | 54 | memset(&pmlmepriv->assoc_ssid, 0, sizeof(struct ndis_802_11_ssid)); |
| 55 | 55 | |
| 56 | − pbuf = vzalloc(MAX_BSS_CNT * (sizeof(struct wlan_network))); | |
| 56 | + pbuf = vzalloc(array_size(MAX_BSS_CNT, sizeof(struct wlan_network))); | |
| 57 | 57 | |
| 58 | 58 | if (!pbuf) { |
| 59 | 59 | res = _FAIL; |
| @@ -597,8 +597,9 @@ static void RxReorderIndicatePacket(struct ieee80211_device *ieee, · 596 unmodified lines | ||
| 597 | 597 | bool bMatchWinStart = false, bPktInBuf = false; |
| 598 | 598 | IEEE80211_DEBUG(IEEE80211_DL_REORDER,"%s(): Seq is %d,pTS->RxIndicateSeq is %d, WinSize is %d\n",__func__,SeqNum,pTS->RxIndicateSeq,WinSize); |
| 599 | 599 | |
| 600 | − prxbIndicateArray = kmalloc(sizeof(struct ieee80211_rxb *) * | |
| 601 | − REORDER_WIN_SIZE, GFP_KERNEL); | |
| 600 | + prxbIndicateArray = kmalloc_array(REORDER_WIN_SIZE, | |
| 601 | + sizeof(struct ieee80211_rxb *), | |
| 602 | + GFP_KERNEL); | |
| 602 | 603 | if (!prxbIndicateArray) |
| 603 | 604 | return; |
| 604 | 605 | |
| @@ -1640,8 +1640,8 @@ static short rtl8192_usb_initendpoints(struct net_device *dev) · 1639 unmodified lines | ||
| 1640 | 1640 | { |
| 1641 | 1641 | struct r8192_priv *priv = ieee80211_priv(dev); |
| 1642 | 1642 | |
| 1643 | − priv->rx_urb = kmalloc(sizeof(struct urb *) * (MAX_RX_URB + 1), | |
| 1644 | − GFP_KERNEL); | |
| 1643 | + priv->rx_urb = kmalloc_array(MAX_RX_URB + 1, sizeof(struct urb *), | |
| 1644 | + GFP_KERNEL); | |
| 1645 | 1645 | if (!priv->rx_urb) |
| 1646 | 1646 | return -ENOMEM; |
| 1647 | 1647 | |
| @@ -37,7 +37,7 @@ sint _rtw_init_mlme_priv(struct adapter *padapter) · 36 unmodified lines | ||
| 37 | 37 | |
| 38 | 38 | memset(&pmlmepriv->assoc_ssid, 0, sizeof(struct ndis_802_11_ssid)); |
| 39 | 39 | |
| 40 | − pbuf = vzalloc(MAX_BSS_CNT * (sizeof(struct wlan_network))); | |
| 40 | + pbuf = vzalloc(array_size(MAX_BSS_CNT, sizeof(struct wlan_network))); | |
| 41 | 41 | |
| 42 | 42 | if (pbuf == NULL) { |
| 43 | 43 | res = _FAIL; |
| @@ -237,8 +237,8 @@ void read_efuse(struct ieee80211_hw *hw, u16 _offset, u16 _size_byte, u8 *pbuf) · 236 unmodified lines | ||
| 237 | 237 | } |
| 238 | 238 | |
| 239 | 239 | /* allocate memory for efuse_tbl and efuse_word */ |
| 240 | − efuse_tbl = kzalloc(rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE] * | |
| 241 | − sizeof(u8), GFP_ATOMIC); | |
| 240 | + efuse_tbl = kzalloc(rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE], | |
| 241 | + GFP_ATOMIC); | |
| 242 | 242 | if (!efuse_tbl) |
| 243 | 243 | return; |
| 244 | 244 | efuse_word = kcalloc(EFUSE_MAX_WORD_UNIT, sizeof(u16 *), GFP_ATOMIC); |
| @@ -2618,7 +2618,7 @@ static int ms_build_l2p_tbl(struct rtsx_chip *chip, int seg_no) · 2617 unmodified lines | ||
| 2618 | 2618 | segment = &ms_card->segment[seg_no]; |
| 2619 | 2619 | |
| 2620 | 2620 | if (!segment->l2p_table) { |
| 2621 | − segment->l2p_table = vmalloc(table_size * 2); | |
| 2621 | + segment->l2p_table = vmalloc(array_size(table_size, 2)); | |
| 2622 | 2622 | if (!segment->l2p_table) { |
| 2623 | 2623 | rtsx_trace(chip); |
| 2624 | 2624 | goto BUILD_FAIL; |
| @@ -1660,13 +1660,13 @@ int rtsx_write_cfg_seq(struct rtsx_chip *chip, u8 func, u16 addr, u8 *buf, · 1659 unmodified lines | ||
| 1660 | 1660 | |
| 1661 | 1661 | dev_dbg(rtsx_dev(chip), "dw_len = %d\n", dw_len); |
| 1662 | 1662 | |
| 1663 | − data = vzalloc(dw_len * 4); | |
| 1663 | + data = vzalloc(array_size(dw_len, 4)); | |
| 1664 | 1664 | if (!data) { |
| 1665 | 1665 | rtsx_trace(chip); |
| 1666 | 1666 | return STATUS_NOMEM; |
| 1667 | 1667 | } |
| 1668 | 1668 | |
| 1669 | − mask = vzalloc(dw_len * 4); | |
| 1669 | + mask = vzalloc(array_size(dw_len, 4)); | |
| 1670 | 1670 | if (!mask) { |
| 1671 | 1671 | vfree(data); |
| 1672 | 1672 | rtsx_trace(chip); |
| @@ -1721,7 +1721,7 @@ int rtsx_read_cfg_seq(struct rtsx_chip *chip, u8 func, u16 addr, u8 *buf, · 48 unmodified lines | ||
| 1721 | 1721 | |
| 1722 | 1722 | dev_dbg(rtsx_dev(chip), "dw_len = %d\n", dw_len); |
| 1723 | 1723 | |
| 1724 | − data = vmalloc(dw_len * 4); | |
| 1724 | + data = vmalloc(array_size(dw_len, 4)); | |
| 1725 | 1725 | if (!data) { |
| 1726 | 1726 | rtsx_trace(chip); |
| 1727 | 1727 | return STATUS_NOMEM; |
| @@ -865,7 +865,7 @@ static void do_scsi_nolinuxstat(struct uiscmdrsp *cmdrsp, · 864 unmodified lines | ||
| 865 | 865 | if (cmdrsp->scsi.no_disk_result == 0) |
| 866 | 866 | return; |
| 867 | 867 | |
| 868 | − buf = kzalloc(sizeof(char) * 36, GFP_KERNEL); | |
| 868 | + buf = kzalloc(36, GFP_KERNEL); | |
| 869 | 869 | if (!buf) |
| 870 | 870 | return; |
| 871 | 871 | |
| @@ -250,10 +250,10 @@ int transport_alloc_session_tags(struct se_session *se_sess, · 249 unmodified lines | ||
| 250 | 250 | { |
| 251 | 251 | int rc; |
| 252 | 252 | |
| 253 | − se_sess->sess_cmd_map = kzalloc(tag_num * tag_size, | |
| 253 | + se_sess->sess_cmd_map = kcalloc(tag_size, tag_num, | |
| 254 | 254 | GFP_KERNEL | __GFP_NOWARN | __GFP_RETRY_MAYFAIL); |
| 255 | 255 | if (!se_sess->sess_cmd_map) { |
| 256 | − se_sess->sess_cmd_map = vzalloc(tag_num * tag_size); | |
| 256 | + se_sess->sess_cmd_map = vzalloc(array_size(tag_size, tag_num)); | |
| 257 | 257 | if (!se_sess->sess_cmd_map) { |
| 258 | 258 | pr_err("Unable to allocate se_sess->sess_cmd_map\n"); |
| 259 | 259 | return -ENOMEM; |
| @@ -1717,8 +1717,9 @@ static int tcmu_configure_device(struct se_device *dev) · 1716 unmodified lines | ||
| 1717 | 1717 | |
| 1718 | 1718 | info = &udev->uio_info; |
| 1719 | 1719 | |
| 1720 | − udev->data_bitmap = kzalloc(BITS_TO_LONGS(udev->max_blocks) * | |
| 1721 | − sizeof(unsigned long), GFP_KERNEL); | |
| 1720 | + udev->data_bitmap = kcalloc(BITS_TO_LONGS(udev->max_blocks), | |
| 1721 | + sizeof(unsigned long), | |
| 1722 | + GFP_KERNEL); | |
| 1722 | 1723 | if (!udev->data_bitmap) { |
| 1723 | 1724 | ret = -ENOMEM; |
| 1724 | 1725 | goto err_bitmap_alloc; |
| @@ -96,7 +96,7 @@ int acpi_parse_trt(acpi_handle handle, int *trt_count, struct trt **trtp, · 95 unmodified lines | ||
| 96 | 96 | } |
| 97 | 97 | |
| 98 | 98 | *trt_count = p->package.count; |
| 99 | − trts = kzalloc(*trt_count * sizeof(struct trt), GFP_KERNEL); | |
| 99 | + trts = kcalloc(*trt_count, sizeof(struct trt), GFP_KERNEL); | |
| 100 | 100 | if (!trts) { |
| 101 | 101 | result = -ENOMEM; |
| 102 | 102 | goto end; |
| @@ -178,7 +178,7 @@ int acpi_parse_art(acpi_handle handle, int *art_count, struct art **artp, · 75 unmodified lines | ||
| 178 | 178 | |
| 179 | 179 | /* ignore p->package.elements[0], as this is _ART Revision field */ |
| 180 | 180 | *art_count = p->package.count - 1; |
| 181 | − arts = kzalloc(*art_count * sizeof(struct art), GFP_KERNEL); | |
| 181 | + arts = kcalloc(*art_count, sizeof(struct art), GFP_KERNEL); | |
| 182 | 182 | if (!arts) { |
| 183 | 183 | result = -ENOMEM; |
| 184 | 184 | goto end; |
| @@ -239,9 +239,10 @@ struct int34x_thermal_zone *int340x_thermal_zone_add(struct acpi_device *adev, · 238 unmodified lines | ||
| 239 | 239 | if (ACPI_FAILURE(status)) |
| 240 | 240 | trip_cnt = 0; |
| 241 | 241 | else { |
| 242 | − int34x_thermal_zone->aux_trips = kzalloc( | |
| 243 | − sizeof(*int34x_thermal_zone->aux_trips) * | |
| 244 | − trip_cnt, GFP_KERNEL); | |
| 242 | + int34x_thermal_zone->aux_trips = | |
| 243 | + kcalloc(trip_cnt, | |
| 244 | + sizeof(*int34x_thermal_zone->aux_trips), | |
| 245 | + GFP_KERNEL); | |
| 245 | 246 | if (!int34x_thermal_zone->aux_trips) { |
| 246 | 247 | ret = -ENOMEM; |
| 247 | 248 | goto err_trip_alloc; |
| @@ -853,7 +853,7 @@ __init *thermal_of_build_thermal_zone(struct device_node *np) · 852 unmodified lines | ||
| 853 | 853 | if (tz->ntrips == 0) /* must have at least one child */ |
| 854 | 854 | goto finish; |
| 855 | 855 | |
| 856 | − tz->trips = kzalloc(tz->ntrips * sizeof(*tz->trips), GFP_KERNEL); | |
| 856 | + tz->trips = kcalloc(tz->ntrips, sizeof(*tz->trips), GFP_KERNEL); | |
| 857 | 857 | if (!tz->trips) { |
| 858 | 858 | ret = -ENOMEM; |
| 859 | 859 | goto free_tz; |
| @@ -879,7 +879,7 @@ __init *thermal_of_build_thermal_zone(struct device_node *np) · 19 unmodified lines | ||
| 879 | 879 | if (tz->num_tbps == 0) |
| 880 | 880 | goto finish; |
| 881 | 881 | |
| 882 | − tz->tbps = kzalloc(tz->num_tbps * sizeof(*tz->tbps), GFP_KERNEL); | |
| 882 | + tz->tbps = kcalloc(tz->num_tbps, sizeof(*tz->tbps), GFP_KERNEL); | |
| 883 | 883 | if (!tz->tbps) { |
| 884 | 884 | ret = -ENOMEM; |
| 885 | 885 | goto free_trips; |
| @@ -1318,8 +1318,8 @@ static int tegra_soctherm_probe(struct platform_device *pdev) · 1317 unmodified lines | ||
| 1318 | 1318 | return PTR_ERR(tegra->clock_soctherm); |
| 1319 | 1319 | } |
| 1320 | 1320 | |
| 1321 | − tegra->calib = devm_kzalloc(&pdev->dev, | |
| 1322 | − sizeof(u32) * soc->num_tsensors, | |
| 1321 | + tegra->calib = devm_kcalloc(&pdev->dev, | |
| 1322 | + soc->num_tsensors, sizeof(u32), | |
| 1323 | 1323 | GFP_KERNEL); |
| 1324 | 1324 | if (!tegra->calib) |
| 1325 | 1325 | return -ENOMEM; |
| @@ -1338,8 +1338,8 @@ static int tegra_soctherm_probe(struct platform_device *pdev) · 12 unmodified lines | ||
| 1338 | 1338 | return err; |
| 1339 | 1339 | } |
| 1340 | 1340 | |
| 1341 | − tegra->thermctl_tzs = devm_kzalloc(&pdev->dev, | |
| 1342 | − sizeof(*z) * soc->num_ttgs, | |
| 1341 | + tegra->thermctl_tzs = devm_kcalloc(&pdev->dev, | |
| 1342 | + soc->num_ttgs, sizeof(*z), | |
| 1343 | 1343 | GFP_KERNEL); |
| 1344 | 1344 | if (!tegra->thermctl_tzs) |
| 1345 | 1345 | return -ENOMEM; |
| @@ -87,8 +87,9 @@ static int gadc_thermal_read_linear_lookup_table(struct device *dev, · 86 unmodified lines | ||
| 87 | 87 | return -EINVAL; |
| 88 | 88 | } |
| 89 | 89 | |
| 90 | − gti->lookup_table = devm_kzalloc(dev, sizeof(*gti->lookup_table) * | |
| 91 | − ntable, GFP_KERNEL); | |
| 90 | + gti->lookup_table = devm_kcalloc(dev, | |
| 91 | + ntable, sizeof(*gti->lookup_table), | |
| 92 | + GFP_KERNEL); | |
| 92 | 93 | if (!gti->lookup_table) |
| 93 | 94 | return -ENOMEM; |
| 94 | 95 | |
| @@ -516,7 +516,8 @@ static int __init pkg_temp_thermal_init(void) · 515 unmodified lines | ||
| 516 | 516 | return -ENODEV; |
| 517 | 517 | |
| 518 | 518 | max_packages = topology_max_packages(); |
| 519 | − packages = kzalloc(max_packages * sizeof(struct pkg_device *), GFP_KERNEL); | |
| 519 | + packages = kcalloc(max_packages, sizeof(struct pkg_device *), | |
| 520 | + GFP_KERNEL); | |
| 520 | 521 | if (!packages) |
| 521 | 522 | return -ENOMEM; |
| 522 | 523 | |
| @@ -754,7 +754,7 @@ static int __init ehv_bc_init(void) · 753 unmodified lines | ||
| 754 | 754 | * array, then you can use pointer math (e.g. "bc - bcs") to get its |
| 755 | 755 | * tty index. |
| 756 | 756 | */ |
| 757 | − bcs = kzalloc(count * sizeof(struct ehv_bc_data), GFP_KERNEL); | |
| 757 | + bcs = kcalloc(count, sizeof(struct ehv_bc_data), GFP_KERNEL); | |
| 758 | 758 | if (!bcs) |
| 759 | 759 | return -ENOMEM; |
| 760 | 760 | |
| @@ -245,8 +245,9 @@ static int goldfish_tty_create_driver(void) · 244 unmodified lines | ||
| 245 | 245 | int ret; |
| 246 | 246 | struct tty_driver *tty; |
| 247 | 247 | |
| 248 | − goldfish_ttys = kzalloc(sizeof(*goldfish_ttys) * | |
| 249 | − goldfish_tty_line_count, GFP_KERNEL); | |
| 248 | + goldfish_ttys = kcalloc(goldfish_tty_line_count, | |
| 249 | + sizeof(*goldfish_ttys), | |
| 250 | + GFP_KERNEL); | |
| 250 | 251 | if (goldfish_ttys == NULL) { |
| 251 | 252 | ret = -ENOMEM; |
| 252 | 253 | goto err_alloc_goldfish_ttys_failed; |
| @@ -1252,7 +1252,7 @@ static int hvc_iucv_setup_filter(const char *val) · 1251 unmodified lines | ||
| 1252 | 1252 | if (size > MAX_VMID_FILTER) |
| 1253 | 1253 | return -ENOSPC; |
| 1254 | 1254 | |
| 1255 | − array = kzalloc(size * 8, GFP_KERNEL); | |
| 1255 | + array = kcalloc(size, 8, GFP_KERNEL); | |
| 1256 | 1256 | if (!array) |
| 1257 | 1257 | return -ENOMEM; |
| 1258 | 1258 | |
| @@ -1441,7 +1441,8 @@ static int hvcs_alloc_index_list(int n) · 1440 unmodified lines | ||
| 1441 | 1441 | { |
| 1442 | 1442 | int i; |
| 1443 | 1443 | |
| 1444 | − hvcs_index_list = kmalloc(n * sizeof(hvcs_index_count),GFP_KERNEL); | |
| 1444 | + hvcs_index_list = kmalloc_array(n, sizeof(hvcs_index_count), | |
| 1445 | + GFP_KERNEL); | |
| 1445 | 1446 | if (!hvcs_index_list) |
| 1446 | 1447 | return -ENOMEM; |
| 1447 | 1448 | hvcs_index_count = n; |
| @@ -1477,7 +1477,7 @@ static int load_firmware(struct pci_dev *pdev, · 1476 unmodified lines | ||
| 1477 | 1477 | goto errrelfw; |
| 1478 | 1478 | } |
| 1479 | 1479 | |
| 1480 | − data = kmalloc(word_count * 2, GFP_KERNEL); | |
| 1480 | + data = kmalloc_array(word_count, 2, GFP_KERNEL); | |
| 1481 | 1481 | if (data == NULL) { |
| 1482 | 1482 | dev_err(&pdev->dev, "Card%d, firmware upload " |
| 1483 | 1483 | "failed, not enough memory\n", index + 1); |
| @@ -2738,8 +2738,9 @@ static int atmel_serial_probe(struct platform_device *pdev) · 2737 unmodified lines | ||
| 2738 | 2738 | |
| 2739 | 2739 | if (!atmel_use_pdc_rx(&atmel_port->uart)) { |
| 2740 | 2740 | ret = -ENOMEM; |
| 2741 | − data = kmalloc(sizeof(struct atmel_uart_char) | |
| 2742 | − * ATMEL_SERIAL_RINGSIZE, GFP_KERNEL); | |
| 2741 | + data = kmalloc_array(ATMEL_SERIAL_RINGSIZE, | |
| 2742 | + sizeof(struct atmel_uart_char), | |
| 2743 | + GFP_KERNEL); | |
| 2743 | 2744 | if (!data) |
| 2744 | 2745 | goto err_alloc_ring; |
| 2745 | 2746 | atmel_port->rx_ring.buf = data; |
| @@ -991,7 +991,7 @@ static unsigned int dma_handle_tx(struct eg20t_port *priv) · 990 unmodified lines | ||
| 991 | 991 | |
| 992 | 992 | priv->tx_dma_use = 1; |
| 993 | 993 | |
| 994 | − priv->sg_tx_p = kzalloc(sizeof(struct scatterlist)*num, GFP_ATOMIC); | |
| 994 | + priv->sg_tx_p = kcalloc(num, sizeof(struct scatterlist), GFP_ATOMIC); | |
| 995 | 995 | if (!priv->sg_tx_p) { |
| 996 | 996 | dev_err(priv->port.dev, "%s:kzalloc Failed\n", __func__); |
| 997 | 997 | return 0; |
| @@ -774,7 +774,7 @@ static int rp2_probe(struct pci_dev *pdev, · 773 unmodified lines | ||
| 774 | 774 | |
| 775 | 775 | rp2_init_card(card); |
| 776 | 776 | |
| 777 | − ports = devm_kzalloc(&pdev->dev, sizeof(*ports) * card->n_ports, | |
| 777 | + ports = devm_kcalloc(&pdev->dev, card->n_ports, sizeof(*ports), | |
| 778 | 778 | GFP_KERNEL); |
| 779 | 779 | if (!ports) |
| 780 | 780 | return -ENOMEM; |
| @@ -2445,7 +2445,7 @@ int uart_register_driver(struct uart_driver *drv) · 2444 unmodified lines | ||
| 2445 | 2445 | * Maybe we should be using a slab cache for this, especially if |
| 2446 | 2446 | * we have a large number of ports to handle. |
| 2447 | 2447 | */ |
| 2448 | − drv->state = kzalloc(sizeof(struct uart_state) * drv->nr, GFP_KERNEL); | |
| 2448 | + drv->state = kcalloc(drv->nr, sizeof(struct uart_state), GFP_KERNEL); | |
| 2449 | 2449 | if (!drv->state) |
| 2450 | 2450 | goto out; |
| 2451 | 2451 | |
| @@ -1125,8 +1125,9 @@ static int __init sunsab_init(void) · 1124 unmodified lines | ||
| 1125 | 1125 | } |
| 1126 | 1126 | |
| 1127 | 1127 | if (num_channels) { |
| 1128 | − sunsab_ports = kzalloc(sizeof(struct uart_sunsab_port) * | |
| 1129 | − num_channels, GFP_KERNEL); | |
| 1128 | + sunsab_ports = kcalloc(num_channels, | |
| 1129 | + sizeof(struct uart_sunsab_port), | |
| 1130 | + GFP_KERNEL); | |
| 1130 | 1131 | if (!sunsab_ports) |
| 1131 | 1132 | return -ENOMEM; |
| 1132 | 1133 | |
| @@ -231,7 +231,7 @@ static void set_inverse_trans_unicode(struct vc_data *conp, · 230 unmodified lines | ||
| 231 | 231 | q = p->inverse_trans_unicode; |
| 232 | 232 | if (!q) { |
| 233 | 233 | q = p->inverse_trans_unicode = |
| 234 | − kmalloc(MAX_GLYPH * sizeof(u16), GFP_KERNEL); | |
| 234 | + kmalloc_array(MAX_GLYPH, sizeof(u16), GFP_KERNEL); | |
| 235 | 235 | if (!q) |
| 236 | 236 | return; |
| 237 | 237 | } |
| @@ -479,7 +479,8 @@ con_insert_unipair(struct uni_pagedir *p, u_short unicode, u_short fontpos) · 241 unmodified lines | ||
| 479 | 479 | |
| 480 | 480 | p1 = p->uni_pgdir[n = unicode >> 11]; |
| 481 | 481 | if (!p1) { |
| 482 | − p1 = p->uni_pgdir[n] = kmalloc(32*sizeof(u16 *), GFP_KERNEL); | |
| 482 | + p1 = p->uni_pgdir[n] = kmalloc_array(32, sizeof(u16 *), | |
| 483 | + GFP_KERNEL); | |
| 483 | 484 | if (!p1) return -ENOMEM; |
| 484 | 485 | for (i = 0; i < 32; i++) |
| 485 | 486 | p1[i] = NULL; |
| @@ -487,7 +488,7 @@ con_insert_unipair(struct uni_pagedir *p, u_short unicode, u_short fontpos) · 1 unmodified line | ||
| 487 | 488 | |
| 488 | 489 | p2 = p1[n = (unicode >> 6) & 0x1f]; |
| 489 | 490 | if (!p2) { |
| 490 | − p2 = p1[n] = kmalloc(64*sizeof(u16), GFP_KERNEL); | |
| 491 | + p2 = p1[n] = kmalloc_array(64, sizeof(u16), GFP_KERNEL); | |
| 491 | 492 | if (!p2) return -ENOMEM; |
| 492 | 493 | memset(p2, 0xff, 64*sizeof(u16)); /* No glyphs for the characters (yet) */ |
| 493 | 494 | } |
| @@ -1624,7 +1624,7 @@ int vt_do_diacrit(unsigned int cmd, void __user *udp, int perm) · 1623 unmodified lines | ||
| 1624 | 1624 | struct kbdiacr *dia; |
| 1625 | 1625 | int i; |
| 1626 | 1626 | |
| 1627 | − dia = kmalloc(MAX_DIACR * sizeof(struct kbdiacr), | |
| 1627 | + dia = kmalloc_array(MAX_DIACR, sizeof(struct kbdiacr), | |
| 1628 | 1628 | GFP_KERNEL); |
| 1629 | 1629 | if (!dia) |
| 1630 | 1630 | return -ENOMEM; |
| @@ -1657,7 +1657,7 @@ int vt_do_diacrit(unsigned int cmd, void __user *udp, int perm) · 26 unmodified lines | ||
| 1657 | 1657 | struct kbdiacrsuc __user *a = udp; |
| 1658 | 1658 | void *buf; |
| 1659 | 1659 | |
| 1660 | − buf = kmalloc(MAX_DIACR * sizeof(struct kbdiacruc), | |
| 1660 | + buf = kmalloc_array(MAX_DIACR, sizeof(struct kbdiacruc), | |
| 1661 | 1661 | GFP_KERNEL); |
| 1662 | 1662 | if (buf == NULL) |
| 1663 | 1663 | return -ENOMEM; |
| @@ -280,7 +280,8 @@ int set_selection(const struct tiocl_selection __user *sel, struct tty_struct *t · 279 unmodified lines | ||
| 280 | 280 | |
| 281 | 281 | /* Allocate a new buffer before freeing the old one ... */ |
| 282 | 282 | multiplier = use_unicode ? 3 : 1; /* chars can take up to 3 bytes */ |
| 283 | − bp = kmalloc(((sel_end-sel_start)/2+1)*multiplier, GFP_KERNEL); | |
| 283 | + bp = kmalloc_array((sel_end - sel_start) / 2 + 1, multiplier, | |
| 284 | + GFP_KERNEL); | |
| 284 | 285 | if (!bp) { |
| 285 | 286 | printk(KERN_WARNING "selection: kmalloc() failed\n"); |
| 286 | 287 | clear_selection(); |
| @@ -129,7 +129,7 @@ static int pruss_probe(struct platform_device *pdev) · 128 unmodified lines | ||
| 129 | 129 | if (!gdev) |
| 130 | 130 | return -ENOMEM; |
| 131 | 131 | |
| 132 | − gdev->info = kzalloc(sizeof(*p) * MAX_PRUSS_EVT, GFP_KERNEL); | |
| 132 | + gdev->info = kcalloc(MAX_PRUSS_EVT, sizeof(*p), GFP_KERNEL); | |
| 133 | 133 | if (!gdev->info) { |
| 134 | 134 | kfree(gdev); |
| 135 | 135 | return -ENOMEM; |
| @@ -897,7 +897,7 @@ static int parse_usbdevfs_streams(struct usb_dev_state *ps, · 896 unmodified lines | ||
| 897 | 897 | if (num_streams_ret && (num_streams < 2 || num_streams > 65536)) |
| 898 | 898 | return -EINVAL; |
| 899 | 899 | |
| 900 | − eps = kmalloc(num_eps * sizeof(*eps), GFP_KERNEL); | |
| 900 | + eps = kmalloc_array(num_eps, sizeof(*eps), GFP_KERNEL); | |
| 901 | 901 | if (!eps) |
| 902 | 902 | return -ENOMEM; |
| 903 | 903 | |
| @@ -1602,8 +1602,9 @@ static int proc_do_submiturb(struct usb_dev_state *ps, struct usbdevfs_urb *uurb · 698 unmodified lines | ||
| 1602 | 1602 | as->mem_usage = u; |
| 1603 | 1603 | |
| 1604 | 1604 | if (num_sgs) { |
| 1605 | − as->urb->sg = kmalloc(num_sgs * sizeof(struct scatterlist), | |
| 1606 | − GFP_KERNEL); | |
| 1605 | + as->urb->sg = kmalloc_array(num_sgs, | |
| 1606 | + sizeof(struct scatterlist), | |
| 1607 | + GFP_KERNEL); | |
| 1607 | 1608 | if (!as->urb->sg) { |
| 1608 | 1609 | ret = -ENOMEM; |
| 1609 | 1610 | goto error; |
| @@ -1376,7 +1376,7 @@ static int hub_configure(struct usb_hub *hub, · 1375 unmodified lines | ||
| 1376 | 1376 | dev_info(hub_dev, "%d port%s detected\n", maxchild, |
| 1377 | 1377 | (maxchild == 1) ? "" : "s"); |
| 1378 | 1378 | |
| 1379 | − hub->ports = kzalloc(maxchild * sizeof(struct usb_port *), GFP_KERNEL); | |
| 1379 | + hub->ports = kcalloc(maxchild, sizeof(struct usb_port *), GFP_KERNEL); | |
| 1380 | 1380 | if (!hub->ports) { |
| 1381 | 1381 | ret = -ENOMEM; |
| 1382 | 1382 | goto fail; |
| @@ -390,7 +390,7 @@ int usb_sg_init(struct usb_sg_request *io, struct usb_device *dev, · 389 unmodified lines | ||
| 390 | 390 | } |
| 391 | 391 | |
| 392 | 392 | /* initialize all the urbs we'll use */ |
| 393 | − io->urbs = kmalloc(io->entries * sizeof(*io->urbs), mem_flags); | |
| 393 | + io->urbs = kmalloc_array(io->entries, sizeof(*io->urbs), mem_flags); | |
| 394 | 394 | if (!io->urbs) |
| 395 | 395 | goto nomem; |
| 396 | 396 | |
| @@ -1824,8 +1824,8 @@ int usb_set_configuration(struct usb_device *dev, int configuration) · 1427 unmodified lines | ||
| 1824 | 1824 | n = nintf = 0; |
| 1825 | 1825 | if (cp) { |
| 1826 | 1826 | nintf = cp->desc.bNumInterfaces; |
| 1827 | − new_interfaces = kmalloc(nintf * sizeof(*new_interfaces), | |
| 1828 | − GFP_NOIO); | |
| 1827 | + new_interfaces = kmalloc_array(nintf, sizeof(*new_interfaces), | |
| 1828 | + GFP_NOIO); | |
| 1829 | 1829 | if (!new_interfaces) |
| 1830 | 1830 | return -ENOMEM; |
| 1831 | 1831 | |
| @@ -5079,13 +5079,14 @@ int dwc2_hcd_init(struct dwc2_hsotg *hsotg) · 5078 unmodified lines | ||
| 5079 | 5079 | dev_dbg(hsotg->dev, "hcfg=%08x\n", hcfg); |
| 5080 | 5080 | |
| 5081 | 5081 | #ifdef CONFIG_USB_DWC2_TRACK_MISSED_SOFS |
| 5082 | − hsotg->frame_num_array = kzalloc(sizeof(*hsotg->frame_num_array) * | |
| 5083 | − FRAME_NUM_ARRAY_SIZE, GFP_KERNEL); | |
| 5082 | + hsotg->frame_num_array = kcalloc(FRAME_NUM_ARRAY_SIZE, | |
| 5083 | + sizeof(*hsotg->frame_num_array), | |
| 5084 | + GFP_KERNEL); | |
| 5084 | 5085 | if (!hsotg->frame_num_array) |
| 5085 | 5086 | goto error1; |
| 5086 | − hsotg->last_frame_num_array = kzalloc( | |
| 5087 | − sizeof(*hsotg->last_frame_num_array) * | |
| 5088 | − FRAME_NUM_ARRAY_SIZE, GFP_KERNEL); | |
| 5087 | + hsotg->last_frame_num_array = | |
| 5088 | + kcalloc(FRAME_NUM_ARRAY_SIZE, | |
| 5089 | + sizeof(*hsotg->last_frame_num_array), GFP_KERNEL); | |
| 5089 | 5090 | if (!hsotg->last_frame_num_array) |
| 5090 | 5091 | goto error1; |
| 5091 | 5092 | #endif |
| @@ -2036,7 +2036,7 @@ static struct usba_ep * atmel_udc_of_init(struct platform_device *pdev, · 2035 unmodified lines | ||
| 2036 | 2036 | udc->num_ep = usba_config_fifo_table(udc); |
| 2037 | 2037 | } |
| 2038 | 2038 | |
| 2039 | − eps = devm_kzalloc(&pdev->dev, sizeof(struct usba_ep) * udc->num_ep, | |
| 2039 | + eps = devm_kcalloc(&pdev->dev, udc->num_ep, sizeof(struct usba_ep), | |
| 2040 | 2040 | GFP_KERNEL); |
| 2041 | 2041 | if (!eps) |
| 2042 | 2042 | return ERR_PTR(-ENOMEM); |
| @@ -138,9 +138,9 @@ static int ep_bd_list_alloc(struct bdc_ep *ep) · 137 unmodified lines | ||
| 138 | 138 | __func__, ep, num_tabs); |
| 139 | 139 | |
| 140 | 140 | /* Allocate memory for table array */ |
| 141 | − ep->bd_list.bd_table_array = kzalloc( | |
| 142 | − num_tabs * sizeof(struct bd_table *), | |
| 143 | − GFP_ATOMIC); | |
| 141 | + ep->bd_list.bd_table_array = kcalloc(num_tabs, | |
| 142 | + sizeof(struct bd_table *), | |
| 143 | + GFP_ATOMIC); | |
| 144 | 144 | if (!ep->bd_list.bd_table_array) |
| 145 | 145 | return -ENOMEM; |
| 146 | 146 | |
| @@ -2246,7 +2246,7 @@ static int struct_udc_setup(struct fsl_udc *udc, · 2245 unmodified lines | ||
| 2246 | 2246 | pdata = dev_get_platdata(&pdev->dev); |
| 2247 | 2247 | udc->phy_mode = pdata->phy_mode; |
| 2248 | 2248 | |
| 2249 | − udc->eps = kzalloc(sizeof(struct fsl_ep) * udc->max_ep, GFP_KERNEL); | |
| 2249 | + udc->eps = kcalloc(udc->max_ep, sizeof(struct fsl_ep), GFP_KERNEL); | |
| 2250 | 2250 | if (!udc->eps) |
| 2251 | 2251 | return -1; |
| 2252 | 2252 | |
| @@ -2427,7 +2427,8 @@ static int renesas_usb3_init_ep(struct renesas_usb3 *usb3, struct device *dev, · 2426 unmodified lines | ||
| 2427 | 2427 | if (usb3->num_usb3_eps > USB3_MAX_NUM_PIPES) |
| 2428 | 2428 | usb3->num_usb3_eps = USB3_MAX_NUM_PIPES; |
| 2429 | 2429 | |
| 2430 | − usb3->usb3_ep = devm_kzalloc(dev, sizeof(*usb3_ep) * usb3->num_usb3_eps, | |
| 2430 | + usb3->usb3_ep = devm_kcalloc(dev, | |
| 2431 | + usb3->num_usb3_eps, sizeof(*usb3_ep), | |
| 2431 | 2432 | GFP_KERNEL); |
| 2432 | 2433 | if (!usb3->usb3_ep) |
| 2433 | 2434 | return -ENOMEM; |
| @@ -117,8 +117,9 @@ static struct ehci_tt *find_tt(struct usb_device *udev) · 116 unmodified lines | ||
| 117 | 117 | if (utt->multi) { |
| 118 | 118 | tt_index = utt->hcpriv; |
| 119 | 119 | if (!tt_index) { /* Create the index array */ |
| 120 | − tt_index = kzalloc(utt->hub->maxchild * | |
| 121 | − sizeof(*tt_index), GFP_ATOMIC); | |
| 120 | + tt_index = kcalloc(utt->hub->maxchild, | |
| 121 | + sizeof(*tt_index), | |
| 122 | + GFP_ATOMIC); | |
| 122 | 123 | if (!tt_index) |
| 123 | 124 | return ERR_PTR(-ENOMEM); |
| 124 | 125 | utt->hcpriv = tt_index; |
| @@ -189,7 +189,7 @@ u32 fhci_create_ep(struct fhci_usb *usb, enum fhci_mem_alloc data_mem, · 188 unmodified lines | ||
| 189 | 189 | goto err; |
| 190 | 190 | } |
| 191 | 191 | |
| 192 | − buff = kmalloc(1028 * sizeof(*buff), GFP_KERNEL); | |
| 192 | + buff = kmalloc_array(1028, sizeof(*buff), GFP_KERNEL); | |
| 193 | 193 | if (!buff) { |
| 194 | 194 | kfree(pkt); |
| 195 | 195 | err_for = "buffer"; |
| @@ -741,8 +741,8 @@ static int imx21_hc_urb_enqueue_isoc(struct usb_hcd *hcd, · 740 unmodified lines | ||
| 741 | 741 | if (urb_priv == NULL) |
| 742 | 742 | return -ENOMEM; |
| 743 | 743 | |
| 744 | − urb_priv->isoc_td = kzalloc( | |
| 745 | − sizeof(struct td) * urb->number_of_packets, mem_flags); | |
| 744 | + urb_priv->isoc_td = kcalloc(urb->number_of_packets, sizeof(struct td), | |
| 745 | + mem_flags); | |
| 746 | 746 | if (urb_priv->isoc_td == NULL) { |
| 747 | 747 | ret = -ENOMEM; |
| 748 | 748 | goto alloc_td_failed; |
| @@ -492,7 +492,7 @@ static ssize_t fill_periodic_buffer(struct debug_buffer *buf) · 491 unmodified lines | ||
| 492 | 492 | char *next; |
| 493 | 493 | unsigned i; |
| 494 | 494 | |
| 495 | − seen = kmalloc(DBG_SCHED_LIMIT * sizeof *seen, GFP_ATOMIC); | |
| 495 | + seen = kmalloc_array(DBG_SCHED_LIMIT, sizeof(*seen), GFP_ATOMIC); | |
| 496 | 496 | if (!seen) |
| 497 | 497 | return 0; |
| 498 | 498 | seen_count = 0; |
| @@ -2274,8 +2274,8 @@ static int xhci_setup_port_arrays(struct xhci_hcd *xhci, gfp_t flags) · 2273 unmodified lines | ||
| 2274 | 2274 | xhci->hw_ports[i].hw_portnum = i; |
| 2275 | 2275 | } |
| 2276 | 2276 | |
| 2277 | − xhci->rh_bw = kzalloc_node(sizeof(*xhci->rh_bw)*num_ports, flags, | |
| 2278 | − dev_to_node(dev)); | |
| 2277 | + xhci->rh_bw = kcalloc_node(num_ports, sizeof(*xhci->rh_bw), flags, | |
| 2278 | + dev_to_node(dev)); | |
| 2279 | 2279 | if (!xhci->rh_bw) |
| 2280 | 2280 | return -ENOMEM; |
| 2281 | 2281 | for (i = 0; i < num_ports; i++) { |
| @@ -695,7 +695,10 @@ static int ld_usb_probe(struct usb_interface *intf, const struct usb_device_id * · 694 unmodified lines | ||
| 695 | 695 | dev_warn(&intf->dev, "Interrupt out endpoint not found (using control endpoint instead)\n"); |
| 696 | 696 | |
| 697 | 697 | dev->interrupt_in_endpoint_size = usb_endpoint_maxp(dev->interrupt_in_endpoint); |
| 698 | − dev->ring_buffer = kmalloc(ring_buffer_size*(sizeof(size_t)+dev->interrupt_in_endpoint_size), GFP_KERNEL); | |
| 698 | + dev->ring_buffer = | |
| 699 | + kmalloc_array(ring_buffer_size, | |
| 700 | + sizeof(size_t) + dev->interrupt_in_endpoint_size, | |
| 701 | + GFP_KERNEL); | |
| 699 | 702 | if (!dev->ring_buffer) |
| 700 | 703 | goto error; |
| 701 | 704 | dev->interrupt_in_buffer = kmalloc(dev->interrupt_in_endpoint_size, GFP_KERNEL); |
| @@ -706,7 +709,9 @@ static int ld_usb_probe(struct usb_interface *intf, const struct usb_device_id * · 4 unmodified lines | ||
| 706 | 709 | goto error; |
| 707 | 710 | dev->interrupt_out_endpoint_size = dev->interrupt_out_endpoint ? usb_endpoint_maxp(dev->interrupt_out_endpoint) : |
| 708 | 711 | udev->descriptor.bMaxPacketSize0; |
| 709 | − dev->interrupt_out_buffer = kmalloc(write_buffer_size*dev->interrupt_out_endpoint_size, GFP_KERNEL); | |
| 712 | + dev->interrupt_out_buffer = | |
| 713 | + kmalloc_array(write_buffer_size, | |
| 714 | + dev->interrupt_out_endpoint_size, GFP_KERNEL); | |
| 710 | 715 | if (!dev->interrupt_out_buffer) |
| 711 | 716 | goto error; |
| 712 | 717 | dev->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL); |
| @@ -1243,7 +1243,7 @@ sisusbcon_font_set(struct vc_data *c, struct console_font *font, · 1242 unmodified lines | ||
| 1243 | 1243 | } |
| 1244 | 1244 | |
| 1245 | 1245 | if (!sisusb->font_backup) |
| 1246 | − sisusb->font_backup = vmalloc(charcount * 32); | |
| 1246 | + sisusb->font_backup = vmalloc(array_size(charcount, 32)); | |
| 1247 | 1247 | |
| 1248 | 1248 | if (sisusb->font_backup) { |
| 1249 | 1249 | memcpy(sisusb->font_backup, font->data, charcount * 32); |
| @@ -1024,7 +1024,8 @@ static long mon_bin_ioctl(struct file *file, unsigned int cmd, unsigned long arg · 1023 unmodified lines | ||
| 1024 | 1024 | return -EINVAL; |
| 1025 | 1025 | |
| 1026 | 1026 | size = CHUNK_ALIGN(arg); |
| 1027 | − vec = kzalloc(sizeof(struct mon_pgmap) * (size / CHUNK_SIZE), GFP_KERNEL); | |
| 1027 | + vec = kcalloc(size / CHUNK_SIZE, sizeof(struct mon_pgmap), | |
| 1028 | + GFP_KERNEL); | |
| 1028 | 1029 | if (vec == NULL) { |
| 1029 | 1030 | ret = -ENOMEM; |
| 1030 | 1031 | break; |
| @@ -1068,7 +1068,7 @@ int usbhs_mod_gadget_probe(struct usbhs_priv *priv) · 1067 unmodified lines | ||
| 1068 | 1068 | if (!gpriv) |
| 1069 | 1069 | return -ENOMEM; |
| 1070 | 1070 | |
| 1071 | − uep = kzalloc(sizeof(struct usbhsg_uep) * pipe_size, GFP_KERNEL); | |
| 1071 | + uep = kcalloc(pipe_size, sizeof(struct usbhsg_uep), GFP_KERNEL); | |
| 1072 | 1072 | if (!uep) { |
| 1073 | 1073 | ret = -ENOMEM; |
| 1074 | 1074 | goto usbhs_mod_gadget_probe_err_gpriv; |
| @@ -803,7 +803,8 @@ int usbhs_pipe_probe(struct usbhs_priv *priv) · 802 unmodified lines | ||
| 803 | 803 | return -EINVAL; |
| 804 | 804 | } |
| 805 | 805 | |
| 806 | − info->pipe = kzalloc(sizeof(struct usbhs_pipe) * pipe_size, GFP_KERNEL); | |
| 806 | + info->pipe = kcalloc(pipe_size, sizeof(struct usbhs_pipe), | |
| 807 | + GFP_KERNEL); | |
| 807 | 808 | if (!info->pipe) |
| 808 | 809 | return -ENOMEM; |
| 809 | 810 | |
| @@ -736,7 +736,7 @@ static int iuu_uart_on(struct usb_serial_port *port) · 735 unmodified lines | ||
| 736 | 736 | int status; |
| 737 | 737 | u8 *buf; |
| 738 | 738 | |
| 739 | − buf = kmalloc(sizeof(u8) * 4, GFP_KERNEL); | |
| 739 | + buf = kmalloc(4, GFP_KERNEL); | |
| 740 | 740 | |
| 741 | 741 | if (!buf) |
| 742 | 742 | return -ENOMEM; |
| @@ -790,7 +790,7 @@ static int iuu_uart_baud(struct usb_serial_port *port, u32 baud_base, · 47 unmodified lines | ||
| 790 | 790 | unsigned int T1FrekvensHZ = 0; |
| 791 | 791 | |
| 792 | 792 | dev_dbg(&port->dev, "%s - enter baud_base=%d\n", __func__, baud_base); |
| 793 | − dataout = kmalloc(sizeof(u8) * 5, GFP_KERNEL); | |
| 793 | + dataout = kmalloc(5, GFP_KERNEL); | |
| 794 | 794 | |
| 795 | 795 | if (!dataout) |
| 796 | 796 | return -ENOMEM; |
| @@ -1025,7 +1025,7 @@ static int alauda_write_data(struct us_data *us, unsigned long address, · 1024 unmodified lines | ||
| 1025 | 1025 | * We also need a temporary block buffer, where we read in the old data, |
| 1026 | 1026 | * overwrite parts with the new data, and manipulate the redundancy data |
| 1027 | 1027 | */ |
| 1028 | − blockbuffer = kmalloc((pagesize + 64) * blocksize, GFP_NOIO); | |
| 1028 | + blockbuffer = kmalloc_array(pagesize + 64, blocksize, GFP_NOIO); | |
| 1029 | 1029 | if (!blockbuffer) { |
| 1030 | 1030 | kfree(buffer); |
| 1031 | 1031 | return USB_STOR_TRANSPORT_ERROR; |
| @@ -807,8 +807,12 @@ static int ms_lib_alloc_logicalmap(struct us_data *us) · 806 unmodified lines | ||
| 807 | 807 | u32 i; |
| 808 | 808 | struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; |
| 809 | 809 | |
| 810 | − info->MS_Lib.Phy2LogMap = kmalloc(info->MS_Lib.NumberOfPhyBlock * sizeof(u16), GFP_KERNEL); | |
| 811 | − info->MS_Lib.Log2PhyMap = kmalloc(info->MS_Lib.NumberOfLogBlock * sizeof(u16), GFP_KERNEL); | |
| 810 | + info->MS_Lib.Phy2LogMap = kmalloc_array(info->MS_Lib.NumberOfPhyBlock, | |
| 811 | + sizeof(u16), | |
| 812 | + GFP_KERNEL); | |
| 813 | + info->MS_Lib.Log2PhyMap = kmalloc_array(info->MS_Lib.NumberOfLogBlock, | |
| 814 | + sizeof(u16), | |
| 815 | + GFP_KERNEL); | |
| 812 | 816 | |
| 813 | 817 | if ((info->MS_Lib.Phy2LogMap == NULL) || (info->MS_Lib.Log2PhyMap == NULL)) { |
| 814 | 818 | ms_lib_free_logicalmap(us); |
| @@ -1113,8 +1117,12 @@ static int ms_lib_alloc_writebuf(struct us_data *us) · 298 unmodified lines | ||
| 1113 | 1117 | |
| 1114 | 1118 | info->MS_Lib.wrtblk = (u16)-1; |
| 1115 | 1119 | |
| 1116 | − info->MS_Lib.blkpag = kmalloc(info->MS_Lib.PagesPerBlock * info->MS_Lib.BytesPerSector, GFP_KERNEL); | |
| 1117 | − info->MS_Lib.blkext = kmalloc(info->MS_Lib.PagesPerBlock * sizeof(struct ms_lib_type_extdat), GFP_KERNEL); | |
| 1120 | + info->MS_Lib.blkpag = kmalloc_array(info->MS_Lib.PagesPerBlock, | |
| 1121 | + info->MS_Lib.BytesPerSector, | |
| 1122 | + GFP_KERNEL); | |
| 1123 | + info->MS_Lib.blkext = kmalloc_array(info->MS_Lib.PagesPerBlock, | |
| 1124 | + sizeof(struct ms_lib_type_extdat), | |
| 1125 | + GFP_KERNEL); | |
| 1118 | 1126 | |
| 1119 | 1127 | if ((info->MS_Lib.blkpag == NULL) || (info->MS_Lib.blkext == NULL)) { |
| 1120 | 1128 | ms_lib_free_writebuf(us); |
| @@ -1231,8 +1231,8 @@ sddr09_read_map(struct us_data *us) { · 1230 unmodified lines | ||
| 1231 | 1231 | |
| 1232 | 1232 | kfree(info->lba_to_pba); |
| 1233 | 1233 | kfree(info->pba_to_lba); |
| 1234 | − info->lba_to_pba = kmalloc(numblocks*sizeof(int), GFP_NOIO); | |
| 1235 | − info->pba_to_lba = kmalloc(numblocks*sizeof(int), GFP_NOIO); | |
| 1234 | + info->lba_to_pba = kmalloc_array(numblocks, sizeof(int), GFP_NOIO); | |
| 1235 | + info->pba_to_lba = kmalloc_array(numblocks, sizeof(int), GFP_NOIO); | |
| 1236 | 1236 | |
| 1237 | 1237 | if (info->lba_to_pba == NULL || info->pba_to_lba == NULL) { |
| 1238 | 1238 | printk(KERN_WARNING "sddr09_read_map: out of memory\n"); |
| @@ -651,7 +651,7 @@ static int sddr55_read_map(struct us_data *us) { · 650 unmodified lines | ||
| 651 | 651 | |
| 652 | 652 | numblocks = info->capacity >> (info->blockshift + info->pageshift); |
| 653 | 653 | |
| 654 | − buffer = kmalloc( numblocks * 2, GFP_NOIO ); | |
| 654 | + buffer = kmalloc_array(numblocks, 2, GFP_NOIO ); | |
| 655 | 655 | |
| 656 | 656 | if (!buffer) |
| 657 | 657 | return -1; |
| @@ -684,8 +684,8 @@ static int sddr55_read_map(struct us_data *us) { · 26 unmodified lines | ||
| 684 | 684 | |
| 685 | 685 | kfree(info->lba_to_pba); |
| 686 | 686 | kfree(info->pba_to_lba); |
| 687 | − info->lba_to_pba = kmalloc(numblocks*sizeof(int), GFP_NOIO); | |
| 688 | − info->pba_to_lba = kmalloc(numblocks*sizeof(int), GFP_NOIO); | |
| 687 | + info->lba_to_pba = kmalloc_array(numblocks, sizeof(int), GFP_NOIO); | |
| 688 | + info->pba_to_lba = kmalloc_array(numblocks, sizeof(int), GFP_NOIO); | |
| 689 | 689 | |
| 690 | 690 | if (info->lba_to_pba == NULL || info->pba_to_lba == NULL) { |
| 691 | 691 | kfree(info->lba_to_pba); |
| @@ -470,7 +470,8 @@ error: · 469 unmodified lines | ||
| 470 | 470 | int wa_rpipes_create(struct wahc *wa) |
| 471 | 471 | { |
| 472 | 472 | wa->rpipes = le16_to_cpu(wa->wa_descr->wNumRPipes); |
| 473 | − wa->rpipe_bm = kzalloc(BITS_TO_LONGS(wa->rpipes)*sizeof(unsigned long), | |
| 473 | + wa->rpipe_bm = kcalloc(BITS_TO_LONGS(wa->rpipes), | |
| 474 | + sizeof(unsigned long), | |
| 474 | 475 | GFP_KERNEL); |
| 475 | 476 | if (wa->rpipe_bm == NULL) |
| 476 | 477 | return -ENOMEM; |
| @@ -217,7 +217,7 @@ static · 216 unmodified lines | ||
| 217 | 217 | int uwb_est_grow(void) |
| 218 | 218 | { |
| 219 | 219 | size_t actual_size = uwb_est_size * sizeof(uwb_est[0]); |
| 220 | − void *new = kmalloc(2 * actual_size, GFP_ATOMIC); | |
| 220 | + void *new = kmalloc_array(2, actual_size, GFP_ATOMIC); | |
| 221 | 221 | if (new == NULL) |
| 222 | 222 | return -ENOMEM; |
| 223 | 223 | memcpy(new, uwb_est, actual_size); |
| @@ -376,7 +376,7 @@ int i1480_usb_probe(struct usb_interface *iface, const struct usb_device_id *id) · 375 unmodified lines | ||
| 376 | 376 | |
| 377 | 377 | i1480 = &i1480_usb->i1480; |
| 378 | 378 | i1480->buf_size = 512; |
| 379 | − i1480->cmd_buf = kmalloc(2 * i1480->buf_size, GFP_KERNEL); | |
| 379 | + i1480->cmd_buf = kmalloc_array(2, i1480->buf_size, GFP_KERNEL); | |
| 380 | 380 | if (i1480->cmd_buf == NULL) { |
| 381 | 381 | dev_err(dev, "Cannot allocate transfer buffers\n"); |
| 382 | 382 | result = -ENOMEM; |
| @@ -274,8 +274,10 @@ static int vhost_net_set_ubuf_info(struct vhost_net *n) · 273 unmodified lines | ||
| 274 | 274 | zcopy = vhost_net_zcopy_mask & (0x1 << i); |
| 275 | 275 | if (!zcopy) |
| 276 | 276 | continue; |
| 277 | − n->vqs[i].ubuf_info = kmalloc(sizeof(*n->vqs[i].ubuf_info) * | |
| 278 | − UIO_MAXIOV, GFP_KERNEL); | |
| 277 | + n->vqs[i].ubuf_info = | |
| 278 | + kmalloc_array(UIO_MAXIOV, | |
| 279 | + sizeof(*n->vqs[i].ubuf_info), | |
| 280 | + GFP_KERNEL); | |
| 279 | 281 | if (!n->vqs[i].ubuf_info) |
| 280 | 282 | goto err; |
| 281 | 283 | } |
| @@ -943,7 +945,7 @@ static int vhost_net_open(struct inode *inode, struct file *f) · 661 unmodified lines | ||
| 943 | 945 | n = kvmalloc(sizeof *n, GFP_KERNEL | __GFP_RETRY_MAYFAIL); |
| 944 | 946 | if (!n) |
| 945 | 947 | return -ENOMEM; |
| 946 | − vqs = kmalloc(VHOST_NET_VQ_MAX * sizeof(*vqs), GFP_KERNEL); | |
| 948 | + vqs = kmalloc_array(VHOST_NET_VQ_MAX, sizeof(*vqs), GFP_KERNEL); | |
| 947 | 949 | if (!vqs) { |
| 948 | 950 | kvfree(n); |
| 949 | 951 | return -ENOMEM; |
| @@ -1378,7 +1378,7 @@ static int vhost_scsi_open(struct inode *inode, struct file *f) · 1377 unmodified lines | ||
| 1378 | 1378 | goto err_vs; |
| 1379 | 1379 | } |
| 1380 | 1380 | |
| 1381 | − vqs = kmalloc(VHOST_SCSI_MAX_VQ * sizeof(*vqs), GFP_KERNEL); | |
| 1381 | + vqs = kmalloc_array(VHOST_SCSI_MAX_VQ, sizeof(*vqs), GFP_KERNEL); | |
| 1382 | 1382 | if (!vqs) |
| 1383 | 1383 | goto err_vqs; |
| 1384 | 1384 | |
| @@ -1685,22 +1685,25 @@ static int vhost_scsi_nexus_cb(struct se_portal_group *se_tpg, · 300 unmodified lines | ||
| 1685 | 1685 | for (i = 0; i < VHOST_SCSI_DEFAULT_TAGS; i++) { |
| 1686 | 1686 | tv_cmd = &((struct vhost_scsi_cmd *)se_sess->sess_cmd_map)[i]; |
| 1687 | 1687 | |
| 1688 | − tv_cmd->tvc_sgl = kzalloc(sizeof(struct scatterlist) * | |
| 1689 | − VHOST_SCSI_PREALLOC_SGLS, GFP_KERNEL); | |
| 1688 | + tv_cmd->tvc_sgl = kcalloc(VHOST_SCSI_PREALLOC_SGLS, | |
| 1689 | + sizeof(struct scatterlist), | |
| 1690 | + GFP_KERNEL); | |
| 1690 | 1691 | if (!tv_cmd->tvc_sgl) { |
| 1691 | 1692 | pr_err("Unable to allocate tv_cmd->tvc_sgl\n"); |
| 1692 | 1693 | goto out; |
| 1693 | 1694 | } |
| 1694 | 1695 | |
| 1695 | − tv_cmd->tvc_upages = kzalloc(sizeof(struct page *) * | |
| 1696 | − VHOST_SCSI_PREALLOC_UPAGES, GFP_KERNEL); | |
| 1696 | + tv_cmd->tvc_upages = kcalloc(VHOST_SCSI_PREALLOC_UPAGES, | |
| 1697 | + sizeof(struct page *), | |
| 1698 | + GFP_KERNEL); | |
| 1697 | 1699 | if (!tv_cmd->tvc_upages) { |
| 1698 | 1700 | pr_err("Unable to allocate tv_cmd->tvc_upages\n"); |
| 1699 | 1701 | goto out; |
| 1700 | 1702 | } |
| 1701 | 1703 | |
| 1702 | − tv_cmd->tvc_prot_sgl = kzalloc(sizeof(struct scatterlist) * | |
| 1703 | − VHOST_SCSI_PREALLOC_PROT_SGLS, GFP_KERNEL); | |
| 1704 | + tv_cmd->tvc_prot_sgl = kcalloc(VHOST_SCSI_PREALLOC_PROT_SGLS, | |
| 1705 | + sizeof(struct scatterlist), | |
| 1706 | + GFP_KERNEL); | |
| 1704 | 1707 | if (!tv_cmd->tvc_prot_sgl) { |
| 1705 | 1708 | pr_err("Unable to allocate tv_cmd->tvc_prot_sgl\n"); |
| 1706 | 1709 | goto out; |
| @@ -107,7 +107,7 @@ static int vhost_test_open(struct inode *inode, struct file *f) · 106 unmodified lines | ||
| 107 | 107 | |
| 108 | 108 | if (!n) |
| 109 | 109 | return -ENOMEM; |
| 110 | − vqs = kmalloc(VHOST_TEST_VQ_MAX * sizeof(*vqs), GFP_KERNEL); | |
| 110 | + vqs = kmalloc_array(VHOST_TEST_VQ_MAX, sizeof(*vqs), GFP_KERNEL); | |
| 111 | 111 | if (!vqs) { |
| 112 | 112 | kfree(n); |
| 113 | 113 | return -ENOMEM; |
| @@ -385,10 +385,13 @@ static long vhost_dev_alloc_iovecs(struct vhost_dev *dev) · 384 unmodified lines | ||
| 385 | 385 | |
| 386 | 386 | for (i = 0; i < dev->nvqs; ++i) { |
| 387 | 387 | vq = dev->vqs[i]; |
| 388 | − vq->indirect = kmalloc(sizeof *vq->indirect * UIO_MAXIOV, | |
| 389 | − GFP_KERNEL); | |
| 390 | − vq->log = kmalloc(sizeof *vq->log * UIO_MAXIOV, GFP_KERNEL); | |
| 391 | − vq->heads = kmalloc(sizeof *vq->heads * UIO_MAXIOV, GFP_KERNEL); | |
| 388 | + vq->indirect = kmalloc_array(UIO_MAXIOV, | |
| 389 | + sizeof(*vq->indirect), | |
| 390 | + GFP_KERNEL); | |
| 391 | + vq->log = kmalloc_array(UIO_MAXIOV, sizeof(*vq->log), | |
| 392 | + GFP_KERNEL); | |
| 393 | + vq->heads = kmalloc_array(UIO_MAXIOV, sizeof(*vq->heads), | |
| 394 | + GFP_KERNEL); | |
| 392 | 395 | if (!vq->indirect || !vq->log || !vq->heads) |
| 393 | 396 | goto err_nomem; |
| 394 | 397 | } |
| @@ -1286,7 +1289,8 @@ static long vhost_set_memory(struct vhost_dev *d, struct vhost_memory __user *m) · 891 unmodified lines | ||
| 1286 | 1289 | return -EOPNOTSUPP; |
| 1287 | 1290 | if (mem.nregions > max_mem_regions) |
| 1288 | 1291 | return -E2BIG; |
| 1289 | − newmem = kvzalloc(size + mem.nregions * sizeof(*m->regions), GFP_KERNEL); | |
| 1292 | + newmem = kvzalloc(struct_size(newmem, regions, mem.nregions), | |
| 1293 | + GFP_KERNEL); | |
| 1290 | 1294 | if (!newmem) |
| 1291 | 1295 | return -ENOMEM; |
| 1292 | 1296 | |
| @@ -191,7 +191,7 @@ static int resize_iovec(struct vringh_kiov *iov, gfp_t gfp) · 190 unmodified lines | ||
| 191 | 191 | if (flag) |
| 192 | 192 | new = krealloc(iov->iov, new_num * sizeof(struct iovec), gfp); |
| 193 | 193 | else { |
| 194 | − new = kmalloc(new_num * sizeof(struct iovec), gfp); | |
| 194 | + new = kmalloc_array(new_num, sizeof(struct iovec), gfp); | |
| 195 | 195 | if (new) { |
| 196 | 196 | memcpy(new, iov->iov, |
| 197 | 197 | iov->max_num * sizeof(struct iovec)); |
| @@ -223,7 +223,7 @@ static int adp8860_led_probe(struct i2c_client *client) · 222 unmodified lines | ||
| 223 | 223 | struct led_info *cur_led; |
| 224 | 224 | int ret, i; |
| 225 | 225 | |
| 226 | − led = devm_kzalloc(&client->dev, sizeof(*led) * pdata->num_leds, | |
| 226 | + led = devm_kcalloc(&client->dev, pdata->num_leds, sizeof(*led), | |
| 227 | 227 | GFP_KERNEL); |
| 228 | 228 | if (led == NULL) |
| 229 | 229 | return -ENOMEM; |
| @@ -246,7 +246,7 @@ static int adp8870_led_probe(struct i2c_client *client) · 245 unmodified lines | ||
| 246 | 246 | struct led_info *cur_led; |
| 247 | 247 | int ret, i; |
| 248 | 248 | |
| 249 | − led = devm_kzalloc(&client->dev, pdata->num_leds * sizeof(*led), | |
| 249 | + led = devm_kcalloc(&client->dev, pdata->num_leds, sizeof(*led), | |
| 250 | 250 | GFP_KERNEL); |
| 251 | 251 | if (led == NULL) |
| 252 | 252 | return -ENOMEM; |
| @@ -374,7 +374,7 @@ static int lp855x_parse_dt(struct lp855x *lp) · 373 unmodified lines | ||
| 374 | 374 | struct device_node *child; |
| 375 | 375 | int i = 0; |
| 376 | 376 | |
| 377 | − rom = devm_kzalloc(dev, sizeof(*rom) * rom_length, GFP_KERNEL); | |
| 377 | + rom = devm_kcalloc(dev, rom_length, sizeof(*rom), GFP_KERNEL); | |
| 378 | 378 | if (!rom) |
| 379 | 379 | return -ENOMEM; |
| 380 | 380 | |
| @@ -649,7 +649,7 @@ static void *sti_bmode_font_raw(struct sti_cooked_font *f) · 648 unmodified lines | ||
| 649 | 649 | unsigned char *n, *p, *q; |
| 650 | 650 | int size = f->raw->bytes_per_char*256+sizeof(struct sti_rom_font); |
| 651 | 651 | |
| 652 | − n = kzalloc(4*size, STI_LOWMEM); | |
| 652 | + n = kcalloc(4, size, STI_LOWMEM); | |
| 653 | 653 | if (!n) |
| 654 | 654 | return NULL; |
| 655 | 655 | p = n + 3; |
| @@ -501,7 +501,7 @@ static int au1100fb_drv_probe(struct platform_device *dev) · 500 unmodified lines | ||
| 501 | 501 | fbdev->info.fix = au1100fb_fix; |
| 502 | 502 | |
| 503 | 503 | fbdev->info.pseudo_palette = |
| 504 | − devm_kzalloc(&dev->dev, sizeof(u32) * 16, GFP_KERNEL); | |
| 504 | + devm_kcalloc(&dev->dev, 16, sizeof(u32), GFP_KERNEL); | |
| 505 | 505 | if (!fbdev->info.pseudo_palette) |
| 506 | 506 | return -ENOMEM; |
| 507 | 507 | |
| @@ -617,7 +617,7 @@ static int broadsheet_spiflash_rewrite_sector(struct broadsheetfb_par *par, · 616 unmodified lines | ||
| 617 | 617 | int tail_start_addr; |
| 618 | 618 | int start_sector_addr; |
| 619 | 619 | |
| 620 | − sector_buffer = kzalloc(sizeof(char)*sector_size, GFP_KERNEL); | |
| 620 | + sector_buffer = kzalloc(sector_size, GFP_KERNEL); | |
| 621 | 621 | if (!sector_buffer) |
| 622 | 622 | return -ENOMEM; |
| 623 | 623 | |
| @@ -269,7 +269,7 @@ static void bit_cursor(struct vc_data *vc, struct fb_info *info, int mode, · 268 unmodified lines | ||
| 269 | 269 | if (attribute) { |
| 270 | 270 | u8 *dst; |
| 271 | 271 | |
| 272 | − dst = kmalloc(w * vc->vc_font.height, GFP_ATOMIC); | |
| 272 | + dst = kmalloc_array(w, vc->vc_font.height, GFP_ATOMIC); | |
| 273 | 273 | if (!dst) |
| 274 | 274 | return; |
| 275 | 275 | kfree(ops->cursor_data); |
| @@ -312,7 +312,7 @@ static void bit_cursor(struct vc_data *vc, struct fb_info *info, int mode, · 36 unmodified lines | ||
| 312 | 312 | vc->vc_cursor_type != ops->p->cursor_shape || |
| 313 | 313 | ops->cursor_state.mask == NULL || |
| 314 | 314 | ops->cursor_reset) { |
| 315 | − char *mask = kmalloc(w*vc->vc_font.height, GFP_ATOMIC); | |
| 315 | + char *mask = kmalloc_array(w, vc->vc_font.height, GFP_ATOMIC); | |
| 316 | 316 | int cur_height, size, i = 0; |
| 317 | 317 | u8 msk = 0xff; |
| 318 | 318 | |
| @@ -591,7 +591,8 @@ static void fbcon_prepare_logo(struct vc_data *vc, struct fb_info *info, · 590 unmodified lines | ||
| 591 | 591 | if (scr_readw(r) != vc->vc_video_erase_char) |
| 592 | 592 | break; |
| 593 | 593 | if (r != q && new_rows >= rows + logo_lines) { |
| 594 | − save = kmalloc(logo_lines * new_cols * 2, GFP_KERNEL); | |
| 594 | + save = kmalloc(array3_size(logo_lines, new_cols, 2), | |
| 595 | + GFP_KERNEL); | |
| 595 | 596 | if (save) { |
| 596 | 597 | int i = cols < new_cols ? cols : new_cols; |
| 597 | 598 | scr_memsetw(save, erase, logo_lines * new_cols * 2); |
| @@ -258,7 +258,7 @@ static void ccw_cursor(struct vc_data *vc, struct fb_info *info, int mode, · 257 unmodified lines | ||
| 258 | 258 | if (attribute) { |
| 259 | 259 | u8 *dst; |
| 260 | 260 | |
| 261 | − dst = kmalloc(w * vc->vc_font.width, GFP_ATOMIC); | |
| 261 | + dst = kmalloc_array(w, vc->vc_font.width, GFP_ATOMIC); | |
| 262 | 262 | if (!dst) |
| 263 | 263 | return; |
| 264 | 264 | kfree(ops->cursor_data); |
| @@ -304,14 +304,15 @@ static void ccw_cursor(struct vc_data *vc, struct fb_info *info, int mode, · 39 unmodified lines | ||
| 304 | 304 | vc->vc_cursor_type != ops->p->cursor_shape || |
| 305 | 305 | ops->cursor_state.mask == NULL || |
| 306 | 306 | ops->cursor_reset) { |
| 307 | − char *tmp, *mask = kmalloc(w*vc->vc_font.width, GFP_ATOMIC); | |
| 307 | + char *tmp, *mask = kmalloc_array(w, vc->vc_font.width, | |
| 308 | + GFP_ATOMIC); | |
| 308 | 309 | int cur_height, size, i = 0; |
| 309 | 310 | int width = (vc->vc_font.width + 7)/8; |
| 310 | 311 | |
| 311 | 312 | if (!mask) |
| 312 | 313 | return; |
| 313 | 314 | |
| 314 | − tmp = kmalloc(width * vc->vc_font.height, GFP_ATOMIC); | |
| 315 | + tmp = kmalloc_array(width, vc->vc_font.height, GFP_ATOMIC); | |
| 315 | 316 | |
| 316 | 317 | if (!tmp) { |
| 317 | 318 | kfree(mask); |
| @@ -241,7 +241,7 @@ static void cw_cursor(struct vc_data *vc, struct fb_info *info, int mode, · 240 unmodified lines | ||
| 241 | 241 | if (attribute) { |
| 242 | 242 | u8 *dst; |
| 243 | 243 | |
| 244 | − dst = kmalloc(w * vc->vc_font.width, GFP_ATOMIC); | |
| 244 | + dst = kmalloc_array(w, vc->vc_font.width, GFP_ATOMIC); | |
| 245 | 245 | if (!dst) |
| 246 | 246 | return; |
| 247 | 247 | kfree(ops->cursor_data); |
| @@ -287,14 +287,15 @@ static void cw_cursor(struct vc_data *vc, struct fb_info *info, int mode, · 39 unmodified lines | ||
| 287 | 287 | vc->vc_cursor_type != ops->p->cursor_shape || |
| 288 | 288 | ops->cursor_state.mask == NULL || |
| 289 | 289 | ops->cursor_reset) { |
| 290 | − char *tmp, *mask = kmalloc(w*vc->vc_font.width, GFP_ATOMIC); | |
| 290 | + char *tmp, *mask = kmalloc_array(w, vc->vc_font.width, | |
| 291 | + GFP_ATOMIC); | |
| 291 | 292 | int cur_height, size, i = 0; |
| 292 | 293 | int width = (vc->vc_font.width + 7)/8; |
| 293 | 294 | |
| 294 | 295 | if (!mask) |
| 295 | 296 | return; |
| 296 | 297 | |
| 297 | − tmp = kmalloc(width * vc->vc_font.height, GFP_ATOMIC); | |
| 298 | + tmp = kmalloc_array(width, vc->vc_font.height, GFP_ATOMIC); | |
| 298 | 299 | |
| 299 | 300 | if (!tmp) { |
| 300 | 301 | kfree(mask); |
| @@ -46,7 +46,7 @@ static int fbcon_rotate_font(struct fb_info *info, struct vc_data *vc) · 45 unmodified lines | ||
| 46 | 46 | info->fbops->fb_sync(info); |
| 47 | 47 | |
| 48 | 48 | if (ops->fd_size < d_cellsize * len) { |
| 49 | − dst = kmalloc(d_cellsize * len, GFP_KERNEL); | |
| 49 | + dst = kmalloc_array(len, d_cellsize, GFP_KERNEL); | |
| 50 | 50 | |
| 51 | 51 | if (dst == NULL) { |
| 52 | 52 | err = -ENOMEM; |
| @@ -289,7 +289,7 @@ static void ud_cursor(struct vc_data *vc, struct fb_info *info, int mode, · 288 unmodified lines | ||
| 289 | 289 | if (attribute) { |
| 290 | 290 | u8 *dst; |
| 291 | 291 | |
| 292 | − dst = kmalloc(w * vc->vc_font.height, GFP_ATOMIC); | |
| 292 | + dst = kmalloc_array(w, vc->vc_font.height, GFP_ATOMIC); | |
| 293 | 293 | if (!dst) |
| 294 | 294 | return; |
| 295 | 295 | kfree(ops->cursor_data); |
| @@ -335,7 +335,7 @@ static void ud_cursor(struct vc_data *vc, struct fb_info *info, int mode, · 39 unmodified lines | ||
| 335 | 335 | vc->vc_cursor_type != ops->p->cursor_shape || |
| 336 | 336 | ops->cursor_state.mask == NULL || |
| 337 | 337 | ops->cursor_reset) { |
| 338 | − char *mask = kmalloc(w*vc->vc_font.height, GFP_ATOMIC); | |
| 338 | + char *mask = kmalloc_array(w, vc->vc_font.height, GFP_ATOMIC); | |
| 339 | 339 | int cur_height, size, i = 0; |
| 340 | 340 | u8 msk = 0xff; |
| 341 | 341 | |
| @@ -489,7 +489,8 @@ static int fb_show_logo_line(struct fb_info *info, int rotate, · 488 unmodified lines | ||
| 489 | 489 | } |
| 490 | 490 | |
| 491 | 491 | if (fb_logo.depth <= 4) { |
| 492 | − logo_new = kmalloc(logo->width * logo->height, GFP_KERNEL); | |
| 492 | + logo_new = kmalloc_array(logo->width, logo->height, | |
| 493 | + GFP_KERNEL); | |
| 493 | 494 | if (logo_new == NULL) { |
| 494 | 495 | kfree(palette); |
| 495 | 496 | if (saved_pseudo_palette) |
| @@ -506,8 +507,8 @@ static int fb_show_logo_line(struct fb_info *info, int rotate, · 10 unmodified lines | ||
| 506 | 507 | image.height = logo->height; |
| 507 | 508 | |
| 508 | 509 | if (rotate) { |
| 509 | − logo_rotate = kmalloc(logo->width * | |
| 510 | − logo->height, GFP_KERNEL); | |
| 510 | + logo_rotate = kmalloc_array(logo->width, logo->height, | |
| 511 | + GFP_KERNEL); | |
| 511 | 512 | if (logo_rotate) |
| 512 | 513 | fb_rotate_logo(info, logo_rotate, &image, rotate); |
| 513 | 514 | } |
| @@ -620,7 +620,7 @@ static struct fb_videomode *fb_create_modedb(unsigned char *edid, int *dbsize, · 619 unmodified lines | ||
| 620 | 620 | int num = 0, i, first = 1; |
| 621 | 621 | int ver, rev; |
| 622 | 622 | |
| 623 | − mode = kzalloc(50 * sizeof(struct fb_videomode), GFP_KERNEL); | |
| 623 | + mode = kcalloc(50, sizeof(struct fb_videomode), GFP_KERNEL); | |
| 624 | 624 | if (mode == NULL) |
| 625 | 625 | return NULL; |
| 626 | 626 | |
| @@ -671,7 +671,7 @@ static struct fb_videomode *fb_create_modedb(unsigned char *edid, int *dbsize, · 44 unmodified lines | ||
| 671 | 671 | } |
| 672 | 672 | |
| 673 | 673 | *dbsize = num; |
| 674 | − m = kmalloc(num * sizeof(struct fb_videomode), GFP_KERNEL); | |
| 674 | + m = kmalloc_array(num, sizeof(struct fb_videomode), GFP_KERNEL); | |
| 675 | 675 | if (!m) |
| 676 | 676 | return mode; |
| 677 | 677 | memmove(m, mode, num * sizeof(struct fb_videomode)); |
| @@ -1055,8 +1055,9 @@ void fb_edid_add_monspecs(unsigned char *edid, struct fb_monspecs *specs) · 377 unmodified lines | ||
| 1055 | 1055 | if (!(num + svd_n)) |
| 1056 | 1056 | return; |
| 1057 | 1057 | |
| 1058 | − m = kzalloc((specs->modedb_len + num + svd_n) * | |
| 1059 | − sizeof(struct fb_videomode), GFP_KERNEL); | |
| 1058 | + m = kcalloc(specs->modedb_len + num + svd_n, | |
| 1059 | + sizeof(struct fb_videomode), | |
| 1060 | + GFP_KERNEL); | |
| 1060 | 1061 | |
| 1061 | 1062 | if (!m) |
| 1062 | 1063 | return; |
| @@ -662,7 +662,7 @@ static int imxfb_init_fbinfo(struct platform_device *pdev) · 661 unmodified lines | ||
| 662 | 662 | |
| 663 | 663 | pr_debug("%s\n",__func__); |
| 664 | 664 | |
| 665 | − info->pseudo_palette = kmalloc(sizeof(u32) * 16, GFP_KERNEL); | |
| 665 | + info->pseudo_palette = kmalloc_array(16, sizeof(u32), GFP_KERNEL); | |
| 666 | 666 | if (!info->pseudo_palette) |
| 667 | 667 | return -ENOMEM; |
| 668 | 668 | |
| @@ -245,7 +245,7 @@ static void mb86290fb_imageblit(struct fb_info *info, · 244 unmodified lines | ||
| 245 | 245 | return; |
| 246 | 246 | } |
| 247 | 247 | |
| 248 | − cmd = kmalloc(cmdlen * 4, GFP_DMA); | |
| 248 | + cmd = kmalloc_array(cmdlen, 4, GFP_DMA); | |
| 249 | 249 | if (!cmd) |
| 250 | 250 | return cfb_imageblit(info, image); |
| 251 | 251 | cmdfn(cmd, step, dx, dy, width, height, fgcolor, bgcolor, image, info); |
| @@ -493,8 +493,8 @@ static int modes_setup(struct mmpfb_info *fbi) · 492 unmodified lines | ||
| 493 | 493 | return 0; |
| 494 | 494 | } |
| 495 | 495 | /* put videomode list to info structure */ |
| 496 | − videomodes = kzalloc(sizeof(struct fb_videomode) * videomode_num, | |
| 497 | − GFP_KERNEL); | |
| 496 | + videomodes = kcalloc(videomode_num, sizeof(struct fb_videomode), | |
| 497 | + GFP_KERNEL); | |
| 498 | 498 | if (!videomodes) { |
| 499 | 499 | dev_err(fbi->dev, "can't malloc video modes\n"); |
| 500 | 500 | return -ENOMEM; |
| @@ -931,7 +931,7 @@ static int mxsfb_probe(struct platform_device *pdev) · 930 unmodified lines | ||
| 931 | 931 | if (IS_ERR(host->reg_lcd)) |
| 932 | 932 | host->reg_lcd = NULL; |
| 933 | 933 | |
| 934 | − fb_info->pseudo_palette = devm_kzalloc(&pdev->dev, sizeof(u32) * 16, | |
| 934 | + fb_info->pseudo_palette = devm_kcalloc(&pdev->dev, 16, sizeof(u32), | |
| 935 | 935 | GFP_KERNEL); |
| 936 | 936 | if (!fb_info->pseudo_palette) { |
| 937 | 937 | ret = -ENOMEM; |
| @@ -566,7 +566,7 @@ static int nvidiafb_cursor(struct fb_info *info, struct fb_cursor *cursor) · 565 unmodified lines | ||
| 566 | 566 | u8 *msk = (u8 *) cursor->mask; |
| 567 | 567 | u8 *src; |
| 568 | 568 | |
| 569 | − src = kmalloc(s_pitch * cursor->image.height, GFP_ATOMIC); | |
| 569 | + src = kmalloc_array(s_pitch, cursor->image.height, GFP_ATOMIC); | |
| 570 | 570 | |
| 571 | 571 | if (src) { |
| 572 | 572 | switch (cursor->rop) { |
| @@ -42,8 +42,8 @@ int dss_init_overlay_managers(void) · 41 unmodified lines | ||
| 42 | 42 | |
| 43 | 43 | num_managers = dss_feat_get_num_mgrs(); |
| 44 | 44 | |
| 45 | − managers = kzalloc(sizeof(struct omap_overlay_manager) * num_managers, | |
| 46 | − GFP_KERNEL); | |
| 45 | + managers = kcalloc(num_managers, sizeof(struct omap_overlay_manager), | |
| 46 | + GFP_KERNEL); | |
| 47 | 47 | |
| 48 | 48 | BUG_ON(managers == NULL); |
| 49 | 49 | |
| @@ -59,8 +59,8 @@ void dss_init_overlays(struct platform_device *pdev) · 58 unmodified lines | ||
| 59 | 59 | |
| 60 | 60 | num_overlays = dss_feat_get_num_ovls(); |
| 61 | 61 | |
| 62 | − overlays = kzalloc(sizeof(struct omap_overlay) * num_overlays, | |
| 63 | − GFP_KERNEL); | |
| 62 | + overlays = kcalloc(num_overlays, sizeof(struct omap_overlay), | |
| 63 | + GFP_KERNEL); | |
| 64 | 64 | |
| 65 | 65 | BUG_ON(overlays == NULL); |
| 66 | 66 | |
| @@ -359,8 +359,8 @@ static int __init vrfb_probe(struct platform_device *pdev) · 358 unmodified lines | ||
| 359 | 359 | |
| 360 | 360 | num_ctxs = pdev->num_resources - 1; |
| 361 | 361 | |
| 362 | − ctxs = devm_kzalloc(&pdev->dev, | |
| 363 | − sizeof(struct vrfb_ctx) * num_ctxs, | |
| 362 | + ctxs = devm_kcalloc(&pdev->dev, | |
| 363 | + num_ctxs, sizeof(struct vrfb_ctx), | |
| 364 | 364 | GFP_KERNEL); |
| 365 | 365 | |
| 366 | 366 | if (!ctxs) |
| @@ -682,7 +682,7 @@ static ssize_t pvr2fb_write(struct fb_info *info, const char *buf, · 681 unmodified lines | ||
| 682 | 682 | |
| 683 | 683 | nr_pages = (count + PAGE_SIZE - 1) >> PAGE_SHIFT; |
| 684 | 684 | |
| 685 | − pages = kmalloc(nr_pages * sizeof(struct page *), GFP_KERNEL); | |
| 685 | + pages = kmalloc_array(nr_pages, sizeof(struct page *), GFP_KERNEL); | |
| 686 | 686 | if (!pages) |
| 687 | 687 | return -ENOMEM; |
| 688 | 688 | |
| @@ -1615,7 +1615,7 @@ static int rivafb_cursor(struct fb_info *info, struct fb_cursor *cursor) · 1614 unmodified lines | ||
| 1615 | 1615 | u8 *msk = (u8 *) cursor->mask; |
| 1616 | 1616 | u8 *src; |
| 1617 | 1617 | |
| 1618 | − src = kmalloc(s_pitch * cursor->image.height, GFP_ATOMIC); | |
| 1618 | + src = kmalloc_array(s_pitch, cursor->image.height, GFP_ATOMIC); | |
| 1619 | 1619 | |
| 1620 | 1620 | if (src) { |
| 1621 | 1621 | switch (cursor->rop) { |
| @@ -486,8 +486,9 @@ static int uvesafb_vbe_getmodes(struct uvesafb_ktask *task, · 485 unmodified lines | ||
| 486 | 486 | mode++; |
| 487 | 487 | } |
| 488 | 488 | |
| 489 | − par->vbe_modes = kzalloc(sizeof(struct vbe_mode_ib) * | |
| 490 | − par->vbe_modes_cnt, GFP_KERNEL); | |
| 489 | + par->vbe_modes = kcalloc(par->vbe_modes_cnt, | |
| 490 | + sizeof(struct vbe_mode_ib), | |
| 491 | + GFP_KERNEL); | |
| 491 | 492 | if (!par->vbe_modes) |
| 492 | 493 | return -ENOMEM; |
| 493 | 494 | |
| @@ -858,7 +859,7 @@ static int uvesafb_vbe_init_mode(struct fb_info *info) · 364 unmodified lines | ||
| 858 | 859 | * Convert the modelist into a modedb so that we can use it with |
| 859 | 860 | * fb_find_mode(). |
| 860 | 861 | */ |
| 861 | − mode = kzalloc(i * sizeof(*mode), GFP_KERNEL); | |
| 862 | + mode = kcalloc(i, sizeof(*mode), GFP_KERNEL); | |
| 862 | 863 | if (mode) { |
| 863 | 864 | i = 0; |
| 864 | 865 | list_for_each(pos, &info->modelist) { |
| @@ -1044,7 +1045,8 @@ static int uvesafb_setcmap(struct fb_cmap *cmap, struct fb_info *info) · 179 unmodified lines | ||
| 1044 | 1045 | info->cmap.len || cmap->start < info->cmap.start) |
| 1045 | 1046 | return -EINVAL; |
| 1046 | 1047 | |
| 1047 | − entries = kmalloc(sizeof(*entries) * cmap->len, GFP_KERNEL); | |
| 1048 | + entries = kmalloc_array(cmap->len, sizeof(*entries), | |
| 1049 | + GFP_KERNEL); | |
| 1048 | 1050 | if (!entries) |
| 1049 | 1051 | return -ENOMEM; |
| 1050 | 1052 | |
| @@ -596,7 +596,8 @@ static int viafb_ioctl(struct fb_info *info, u_int cmd, u_long arg) · 595 unmodified lines | ||
| 596 | 596 | break; |
| 597 | 597 | |
| 598 | 598 | case VIAFB_GET_GAMMA_LUT: |
| 599 | − viafb_gamma_table = kmalloc(256 * sizeof(u32), GFP_KERNEL); | |
| 599 | + viafb_gamma_table = kmalloc_array(256, sizeof(u32), | |
| 600 | + GFP_KERNEL); | |
| 600 | 601 | if (!viafb_gamma_table) |
| 601 | 602 | return -ENOMEM; |
| 602 | 603 | viafb_get_gamma_table(viafb_gamma_table); |
| @@ -693,7 +693,8 @@ int w100fb_probe(struct platform_device *pdev) · 692 unmodified lines | ||
| 693 | 693 | goto out; |
| 694 | 694 | } |
| 695 | 695 | |
| 696 | − info->pseudo_palette = kmalloc(sizeof (u32) * MAX_PALETTES, GFP_KERNEL); | |
| 696 | + info->pseudo_palette = kmalloc_array(MAX_PALETTES, sizeof(u32), | |
| 697 | + GFP_KERNEL); | |
| 697 | 698 | if (!info->pseudo_palette) { |
| 698 | 699 | err = -ENOMEM; |
| 699 | 700 | goto out; |
| @@ -412,7 +412,7 @@ static int xenfb_probe(struct xenbus_device *dev, · 411 unmodified lines | ||
| 412 | 412 | |
| 413 | 413 | info->nr_pages = (fb_size + PAGE_SIZE - 1) >> PAGE_SHIFT; |
| 414 | 414 | |
| 415 | − info->gfns = vmalloc(sizeof(unsigned long) * info->nr_pages); | |
| 415 | + info->gfns = vmalloc(array_size(sizeof(unsigned long), info->nr_pages)); | |
| 416 | 416 | if (!info->gfns) |
| 417 | 417 | goto error_nomem; |
| 418 | 418 | |
| @@ -181,8 +181,9 @@ struct display_timings *of_get_display_timings(const struct device_node *np) · 180 unmodified lines | ||
| 181 | 181 | goto entryfail; |
| 182 | 182 | } |
| 183 | 183 | |
| 184 | − disp->timings = kzalloc(sizeof(struct display_timing *) * | |
| 185 | − disp->num_timings, GFP_KERNEL); | |
| 184 | + disp->timings = kcalloc(disp->num_timings, | |
| 185 | + sizeof(struct display_timing *), | |
| 186 | + GFP_KERNEL); | |
| 186 | 187 | if (!disp->timings) { |
| 187 | 188 | pr_err("%pOF: could not allocate timings array\n", np); |
| 188 | 189 | goto entryfail; |
| @@ -223,7 +223,7 @@ static long ioctl_memcpy(struct fsl_hv_ioctl_memcpy __user *p) · 222 unmodified lines | ||
| 223 | 223 | * 'pages' is an array of struct page pointers that's initialized by |
| 224 | 224 | * get_user_pages(). |
| 225 | 225 | */ |
| 226 | − pages = kzalloc(num_pages * sizeof(struct page *), GFP_KERNEL); | |
| 226 | + pages = kcalloc(num_pages, sizeof(struct page *), GFP_KERNEL); | |
| 227 | 227 | if (!pages) { |
| 228 | 228 | pr_debug("fsl-hv: could not allocate page list\n"); |
| 229 | 229 | return -ENOMEM; |
| @@ -69,7 +69,7 @@ static void vbg_guest_mappings_init(struct vbg_dev *gdev) · 68 unmodified lines | ||
| 69 | 69 | /* Add 4M so that we can align the vmap to 4MiB as the host requires. */ |
| 70 | 70 | size = PAGE_ALIGN(req->hypervisor_size) + SZ_4M; |
| 71 | 71 | |
| 72 | − pages = kmalloc(sizeof(*pages) * (size >> PAGE_SHIFT), GFP_KERNEL); | |
| 72 | + pages = kmalloc_array(size >> PAGE_SHIFT, sizeof(*pages), GFP_KERNEL); | |
| 73 | 73 | if (!pages) |
| 74 | 74 | goto out; |
| 75 | 75 | |
| @@ -262,8 +262,9 @@ static int vbg_balloon_inflate(struct vbg_dev *gdev, u32 chunk_idx) · 186 unmodified lines | ||
| 262 | 262 | struct page **pages; |
| 263 | 263 | int i, rc, ret; |
| 264 | 264 | |
| 265 | − pages = kmalloc(sizeof(*pages) * VMMDEV_MEMORY_BALLOON_CHUNK_PAGES, | |
| 266 | − GFP_KERNEL | __GFP_NOWARN); | |
| 265 | + pages = kmalloc_array(VMMDEV_MEMORY_BALLOON_CHUNK_PAGES, | |
| 266 | + sizeof(*pages), | |
| 267 | + GFP_KERNEL | __GFP_NOWARN); | |
| 267 | 268 | if (!pages) |
| 268 | 269 | return -ENOMEM; |
| 269 | 270 | |
| @@ -113,12 +113,13 @@ static int vp_request_msix_vectors(struct virtio_device *vdev, int nvectors, · 112 unmodified lines | ||
| 113 | 113 | |
| 114 | 114 | vp_dev->msix_vectors = nvectors; |
| 115 | 115 | |
| 116 | − vp_dev->msix_names = kmalloc(nvectors * sizeof *vp_dev->msix_names, | |
| 117 | − GFP_KERNEL); | |
| 116 | + vp_dev->msix_names = kmalloc_array(nvectors, | |
| 117 | + sizeof(*vp_dev->msix_names), | |
| 118 | + GFP_KERNEL); | |
| 118 | 119 | if (!vp_dev->msix_names) |
| 119 | 120 | goto error; |
| 120 | 121 | vp_dev->msix_affinity_masks |
| 121 | − = kzalloc(nvectors * sizeof *vp_dev->msix_affinity_masks, | |
| 122 | + = kcalloc(nvectors, sizeof(*vp_dev->msix_affinity_masks), | |
| 122 | 123 | GFP_KERNEL); |
| 123 | 124 | if (!vp_dev->msix_affinity_masks) |
| 124 | 125 | goto error; |
| @@ -247,7 +247,7 @@ static struct vring_desc *alloc_indirect(struct virtqueue *_vq, · 246 unmodified lines | ||
| 247 | 247 | */ |
| 248 | 248 | gfp &= ~__GFP_HIGHMEM; |
| 249 | 249 | |
| 250 | − desc = kmalloc(total_sg * sizeof(struct vring_desc), gfp); | |
| 250 | + desc = kmalloc_array(total_sg, sizeof(struct vring_desc), gfp); | |
| 251 | 251 | if (!desc) |
| 252 | 252 | return NULL; |
| 253 | 253 | |
| @@ -70,9 +70,9 @@ static int xen_map_device_mmio(const struct resource *resources, · 69 unmodified lines | ||
| 70 | 70 | if ((resource_type(r) != IORESOURCE_MEM) || (nr == 0)) |
| 71 | 71 | continue; |
| 72 | 72 | |
| 73 | − gpfns = kzalloc(sizeof(xen_pfn_t) * nr, GFP_KERNEL); | |
| 74 | − idxs = kzalloc(sizeof(xen_ulong_t) * nr, GFP_KERNEL); | |
| 75 | − errs = kzalloc(sizeof(int) * nr, GFP_KERNEL); | |
| 73 | + gpfns = kcalloc(nr, sizeof(xen_pfn_t), GFP_KERNEL); | |
| 74 | + idxs = kcalloc(nr, sizeof(xen_ulong_t), GFP_KERNEL); | |
| 75 | + errs = kcalloc(nr, sizeof(int), GFP_KERNEL); | |
| 76 | 76 | if (!gpfns || !idxs || !errs) { |
| 77 | 77 | kfree(gpfns); |
| 78 | 78 | kfree(idxs); |
| @@ -322,7 +322,7 @@ static int evtchn_resize_ring(struct per_user_data *u) · 321 unmodified lines | ||
| 322 | 322 | else |
| 323 | 323 | new_size = 2 * u->ring_size; |
| 324 | 324 | |
| 325 | − new_ring = kvmalloc(new_size * sizeof(*new_ring), GFP_KERNEL); | |
| 325 | + new_ring = kvmalloc_array(new_size, sizeof(*new_ring), GFP_KERNEL); | |
| 326 | 326 | if (!new_ring) |
| 327 | 327 | return -ENOMEM; |
| 328 | 328 | |
| @@ -1137,7 +1137,7 @@ static int gnttab_map(unsigned int start_idx, unsigned int end_idx) · 1136 unmodified lines | ||
| 1137 | 1137 | /* No need for kzalloc as it is initialized in following hypercall |
| 1138 | 1138 | * GNTTABOP_setup_table. |
| 1139 | 1139 | */ |
| 1140 | − frames = kmalloc(nr_gframes * sizeof(unsigned long), GFP_ATOMIC); | |
| 1140 | + frames = kmalloc_array(nr_gframes, sizeof(unsigned long), GFP_ATOMIC); | |
| 1141 | 1141 | if (!frames) |
| 1142 | 1142 | return -ENOMEM; |
| 1143 | 1143 | |
| @@ -1300,8 +1300,9 @@ int gnttab_init(void) · 156 unmodified lines | ||
| 1300 | 1300 | max_nr_glist_frames = (max_nr_grant_frames * |
| 1301 | 1301 | gnttab_interface->grefs_per_grant_frame / RPP); |
| 1302 | 1302 | |
| 1303 | − gnttab_list = kmalloc(max_nr_glist_frames * sizeof(grant_ref_t *), | |
| 1304 | − GFP_KERNEL); | |
| 1303 | + gnttab_list = kmalloc_array(max_nr_glist_frames, | |
| 1304 | + sizeof(grant_ref_t *), | |
| 1305 | + GFP_KERNEL); | |
| 1305 | 1306 | if (gnttab_list == NULL) |
| 1306 | 1307 | return -ENOMEM; |
| 1307 | 1308 | |
| @@ -234,7 +234,7 @@ int xen_pcibk_enable_msix(struct xen_pcibk_device *pdev, · 233 unmodified lines | ||
| 234 | 234 | if (dev->msi_enabled || !(cmd & PCI_COMMAND_MEMORY)) |
| 235 | 235 | return -ENXIO; |
| 236 | 236 | |
| 237 | − entries = kmalloc(op->value * sizeof(*entries), GFP_KERNEL); | |
| 237 | + entries = kmalloc_array(op->value, sizeof(*entries), GFP_KERNEL); | |
| 238 | 238 | if (entries == NULL) |
| 239 | 239 | return -ENOMEM; |
| 240 | 240 | |
| @@ -100,7 +100,7 @@ static int build_path_from_dentry(struct v9fs_session_info *v9ses, · 99 unmodified lines | ||
| 100 | 100 | for (ds = dentry; !IS_ROOT(ds); ds = ds->d_parent) |
| 101 | 101 | n++; |
| 102 | 102 | |
| 103 | − wnames = kmalloc(sizeof(char *) * n, GFP_KERNEL); | |
| 103 | + wnames = kmalloc_array(n, sizeof(char *), GFP_KERNEL); | |
| 104 | 104 | if (!wnames) |
| 105 | 105 | goto err_out; |
| 106 | 106 | |
| @@ -313,7 +313,7 @@ static struct adfs_discmap *adfs_read_map(struct super_block *sb, struct adfs_di · 312 unmodified lines | ||
| 313 | 313 | |
| 314 | 314 | asb->s_ids_per_zone = zone_size / (asb->s_idlen + 1); |
| 315 | 315 | |
| 316 | − dm = kmalloc(nzones * sizeof(*dm), GFP_KERNEL); | |
| 316 | + dm = kmalloc_array(nzones, sizeof(*dm), GFP_KERNEL); | |
| 317 | 317 | if (dm == NULL) { |
| 318 | 318 | adfs_error(sb, "not enough memory"); |
| 319 | 319 | return ERR_PTR(-ENOMEM); |
| @@ -191,7 +191,8 @@ static int afs_deliver_cb_callback(struct afs_call *call) · 190 unmodified lines | ||
| 191 | 191 | if (call->count > AFSCBMAX) |
| 192 | 192 | return afs_protocol_error(call, -EBADMSG); |
| 193 | 193 | |
| 194 | − call->buffer = kmalloc(call->count * 3 * 4, GFP_KERNEL); | |
| 194 | + call->buffer = kmalloc(array3_size(call->count, 3, 4), | |
| 195 | + GFP_KERNEL); | |
| 195 | 196 | if (!call->buffer) |
| 196 | 197 | return -ENOMEM; |
| 197 | 198 | call->offset = 0; |
| @@ -330,7 +331,7 @@ static int afs_deliver_cb_init_call_back_state3(struct afs_call *call) · 132 unmodified lines | ||
| 330 | 331 | switch (call->unmarshall) { |
| 331 | 332 | case 0: |
| 332 | 333 | call->offset = 0; |
| 333 | − call->buffer = kmalloc(11 * sizeof(__be32), GFP_KERNEL); | |
| 334 | + call->buffer = kmalloc_array(11, sizeof(__be32), GFP_KERNEL); | |
| 334 | 335 | if (!call->buffer) |
| 335 | 336 | return -ENOMEM; |
| 336 | 337 | call->unmarshall++; |
| @@ -453,7 +454,7 @@ static int afs_deliver_cb_probe_uuid(struct afs_call *call) · 116 unmodified lines | ||
| 453 | 454 | switch (call->unmarshall) { |
| 454 | 455 | case 0: |
| 455 | 456 | call->offset = 0; |
| 456 | − call->buffer = kmalloc(11 * sizeof(__be32), GFP_KERNEL); | |
| 457 | + call->buffer = kmalloc_array(11, sizeof(__be32), GFP_KERNEL); | |
| 457 | 458 | if (!call->buffer) |
| 458 | 459 | return -ENOMEM; |
| 459 | 460 | call->unmarshall++; |
| @@ -2010,7 +2010,7 @@ static int elf_note_info_init(struct elf_note_info *info) · 2009 unmodified lines | ||
| 2010 | 2010 | INIT_LIST_HEAD(&info->thread_list); |
| 2011 | 2011 | |
| 2012 | 2012 | /* Allocate space for ELF notes */ |
| 2013 | − info->notes = kmalloc(8 * sizeof(struct memelfnote), GFP_KERNEL); | |
| 2013 | + info->notes = kmalloc_array(8, sizeof(struct memelfnote), GFP_KERNEL); | |
| 2014 | 2014 | if (!info->notes) |
| 2015 | 2015 | return 0; |
| 2016 | 2016 | info->psinfo = kmalloc(sizeof(*info->psinfo), GFP_KERNEL); |
| @@ -2294,7 +2294,7 @@ static int elf_core_dump(struct coredump_params *cprm) · 277 unmodified lines | ||
| 2294 | 2294 | |
| 2295 | 2295 | if (segs - 1 > ULONG_MAX / sizeof(*vma_filesz)) |
| 2296 | 2296 | goto end_coredump; |
| 2297 | − vma_filesz = vmalloc((segs - 1) * sizeof(*vma_filesz)); | |
| 2297 | + vma_filesz = vmalloc(array_size(sizeof(*vma_filesz), (segs - 1))); | |
| 2298 | 2298 | if (!vma_filesz) |
| 2299 | 2299 | goto end_coredump; |
| 2300 | 2300 | |
| @@ -1600,7 +1600,8 @@ static int elf_fdpic_core_dump(struct coredump_params *cprm) · 1599 unmodified lines | ||
| 1600 | 1600 | psinfo = kmalloc(sizeof(*psinfo), GFP_KERNEL); |
| 1601 | 1601 | if (!psinfo) |
| 1602 | 1602 | goto cleanup; |
| 1603 | − notes = kmalloc(NUM_NOTES * sizeof(struct memelfnote), GFP_KERNEL); | |
| 1603 | + notes = kmalloc_array(NUM_NOTES, sizeof(struct memelfnote), | |
| 1604 | + GFP_KERNEL); | |
| 1604 | 1605 | if (!notes) |
| 1605 | 1606 | goto cleanup; |
| 1606 | 1607 | fpu = kmalloc(sizeof(*fpu), GFP_KERNEL); |
| @@ -205,7 +205,8 @@ __blkdev_direct_IO_simple(struct kiocb *iocb, struct iov_iter *iter, · 204 unmodified lines | ||
| 205 | 205 | if (nr_pages <= DIO_INLINE_BIO_VECS) |
| 206 | 206 | vecs = inline_vecs; |
| 207 | 207 | else { |
| 208 | − vecs = kmalloc(nr_pages * sizeof(struct bio_vec), GFP_KERNEL); | |
| 208 | + vecs = kmalloc_array(nr_pages, sizeof(struct bio_vec), | |
| 209 | + GFP_KERNEL); | |
| 209 | 210 | if (!vecs) |
| 210 | 211 | return -ENOMEM; |
| 211 | 212 | } |
| @@ -1603,8 +1603,8 @@ static int btrfsic_read_block(struct btrfsic_state *state, · 1602 unmodified lines | ||
| 1603 | 1603 | |
| 1604 | 1604 | num_pages = (block_ctx->len + (u64)PAGE_SIZE - 1) >> |
| 1605 | 1605 | PAGE_SHIFT; |
| 1606 | − block_ctx->mem_to_free = kzalloc((sizeof(*block_ctx->datav) + | |
| 1607 | − sizeof(*block_ctx->pagev)) * | |
| 1606 | + block_ctx->mem_to_free = kcalloc(sizeof(*block_ctx->datav) + | |
| 1607 | + sizeof(*block_ctx->pagev), | |
| 1608 | 1608 | num_pages, GFP_NOFS); |
| 1609 | 1609 | if (!block_ctx->mem_to_free) |
| 1610 | 1610 | return -ENOMEM; |
| @@ -370,7 +370,7 @@ static int start_read(struct inode *inode, struct ceph_rw_context *rw_ctx, · 369 unmodified lines | ||
| 370 | 370 | |
| 371 | 371 | /* build page vector */ |
| 372 | 372 | nr_pages = calc_pages_for(0, len); |
| 373 | − pages = kmalloc(sizeof(*pages) * nr_pages, GFP_KERNEL); | |
| 373 | + pages = kmalloc_array(nr_pages, sizeof(*pages), GFP_KERNEL); | |
| 374 | 374 | if (!pages) { |
| 375 | 375 | ret = -ENOMEM; |
| 376 | 376 | goto out_put; |
| @@ -966,8 +966,9 @@ get_more_pages: · 589 unmodified lines | ||
| 966 | 966 | |
| 967 | 967 | BUG_ON(pages); |
| 968 | 968 | max_pages = calc_pages_for(0, (u64)len); |
| 969 | − pages = kmalloc(max_pages * sizeof (*pages), | |
| 970 | − GFP_NOFS); | |
| 969 | + pages = kmalloc_array(max_pages, | |
| 970 | + sizeof(*pages), | |
| 971 | + GFP_NOFS); | |
| 971 | 972 | if (!pages) { |
| 972 | 973 | pool = fsc->wb_pagevec_pool; |
| 973 | 974 | pages = mempool_alloc(pool, GFP_NOFS); |
| @@ -1113,8 +1114,8 @@ new_request: · 139 unmodified lines | ||
| 1113 | 1114 | |
| 1114 | 1115 | /* allocate new pages array for next request */ |
| 1115 | 1116 | data_pages = pages; |
| 1116 | − pages = kmalloc(locked_pages * sizeof (*pages), | |
| 1117 | − GFP_NOFS); | |
| 1117 | + pages = kmalloc_array(locked_pages, sizeof(*pages), | |
| 1118 | + GFP_NOFS); | |
| 1118 | 1119 | if (!pages) { |
| 1119 | 1120 | pool = fsc->wb_pagevec_pool; |
| 1120 | 1121 | pages = mempool_alloc(pool, GFP_NOFS); |
| @@ -2992,8 +2992,9 @@ encode_again: · 2991 unmodified lines | ||
| 2992 | 2992 | num_flock_locks = 0; |
| 2993 | 2993 | } |
| 2994 | 2994 | if (num_fcntl_locks + num_flock_locks > 0) { |
| 2995 | − flocks = kmalloc((num_fcntl_locks + num_flock_locks) * | |
| 2996 | − sizeof(struct ceph_filelock), GFP_NOFS); | |
| 2995 | + flocks = kmalloc_array(num_fcntl_locks + num_flock_locks, | |
| 2996 | + sizeof(struct ceph_filelock), | |
| 2997 | + GFP_NOFS); | |
| 2997 | 2998 | if (!flocks) { |
| 2998 | 2999 | err = -ENOMEM; |
| 2999 | 3000 | goto out_free; |
| @@ -428,7 +428,7 @@ asn1_oid_decode(struct asn1_ctx *ctx, · 427 unmodified lines | ||
| 428 | 428 | if (size < 2 || size > UINT_MAX/sizeof(unsigned long)) |
| 429 | 429 | return 0; |
| 430 | 430 | |
| 431 | − *oid = kmalloc(size * sizeof(unsigned long), GFP_ATOMIC); | |
| 431 | + *oid = kmalloc_array(size, sizeof(unsigned long), GFP_ATOMIC); | |
| 432 | 432 | if (*oid == NULL) |
| 433 | 433 | return 0; |
| 434 | 434 | |
| @@ -747,8 +747,8 @@ static void parse_dacl(struct cifs_acl *pdacl, char *end_of_acl, · 746 unmodified lines | ||
| 747 | 747 | |
| 748 | 748 | if (num_aces > ULONG_MAX / sizeof(struct cifs_ace *)) |
| 749 | 749 | return; |
| 750 | − ppace = kmalloc(num_aces * sizeof(struct cifs_ace *), | |
| 751 | − GFP_KERNEL); | |
| 750 | + ppace = kmalloc_array(num_aces, sizeof(struct cifs_ace *), | |
| 751 | + GFP_KERNEL); | |
| 752 | 752 | if (!ppace) |
| 753 | 753 | return; |
| 754 | 754 | |
| @@ -2077,7 +2077,7 @@ struct cifs_writedata * · 2076 unmodified lines | ||
| 2077 | 2077 | cifs_writedata_alloc(unsigned int nr_pages, work_func_t complete) |
| 2078 | 2078 | { |
| 2079 | 2079 | struct page **pages = |
| 2080 | − kzalloc(sizeof(struct page *) * nr_pages, GFP_NOFS); | |
| 2080 | + kcalloc(nr_pages, sizeof(struct page *), GFP_NOFS); | |
| 2081 | 2081 | if (pages) |
| 2082 | 2082 | return cifs_writedata_direct_alloc(pages, complete); |
| 2083 | 2083 | |
| @@ -2900,7 +2900,7 @@ static struct cifs_readdata * · 2899 unmodified lines | ||
| 2900 | 2900 | cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete) |
| 2901 | 2901 | { |
| 2902 | 2902 | struct page **pages = |
| 2903 | − kzalloc(sizeof(struct page *) * nr_pages, GFP_KERNEL); | |
| 2903 | + kcalloc(nr_pages, sizeof(struct page *), GFP_KERNEL); | |
| 2904 | 2904 | struct cifs_readdata *ret = NULL; |
| 2905 | 2905 | |
| 2906 | 2906 | if (pages) { |
| @@ -1792,7 +1792,7 @@ cifs_rename2(struct inode *source_dir, struct dentry *source_dentry, · 1791 unmodified lines | ||
| 1792 | 1792 | * with unix extensions enabled. |
| 1793 | 1793 | */ |
| 1794 | 1794 | info_buf_source = |
| 1795 | − kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO), | |
| 1795 | + kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO), | |
| 1796 | 1796 | GFP_KERNEL); |
| 1797 | 1797 | if (info_buf_source == NULL) { |
| 1798 | 1798 | rc = -ENOMEM; |
| @@ -789,7 +789,7 @@ setup_aio_ctx_iter(struct cifs_aio_ctx *ctx, struct iov_iter *iter, int rw) · 788 unmodified lines | ||
| 789 | 789 | GFP_KERNEL); |
| 790 | 790 | |
| 791 | 791 | if (!bv) { |
| 792 | − bv = vmalloc(max_pages * sizeof(struct bio_vec)); | |
| 792 | + bv = vmalloc(array_size(max_pages, sizeof(struct bio_vec))); | |
| 793 | 793 | if (!bv) |
| 794 | 794 | return -ENOMEM; |
| 795 | 795 | } |
| @@ -799,7 +799,7 @@ setup_aio_ctx_iter(struct cifs_aio_ctx *ctx, struct iov_iter *iter, int rw) · 3 unmodified lines | ||
| 799 | 799 | GFP_KERNEL); |
| 800 | 800 | |
| 801 | 801 | if (!pages) { |
| 802 | − pages = vmalloc(max_pages * sizeof(struct page *)); | |
| 802 | + pages = vmalloc(array_size(max_pages, sizeof(struct page *))); | |
| 803 | 803 | if (!pages) { |
| 804 | 804 | kvfree(bv); |
| 805 | 805 | return -ENOMEM; |
| @@ -3471,7 +3471,7 @@ send_set_info(const unsigned int xid, struct cifs_tcon *tcon, · 3470 unmodified lines | ||
| 3471 | 3471 | if (!num) |
| 3472 | 3472 | return -EINVAL; |
| 3473 | 3473 | |
| 3474 | − iov = kmalloc(sizeof(struct kvec) * num, GFP_KERNEL); | |
| 3474 | + iov = kmalloc_array(num, sizeof(struct kvec), GFP_KERNEL); | |
| 3475 | 3475 | if (!iov) |
| 3476 | 3476 | return -ENOMEM; |
| 3477 | 3477 | |
| @@ -3535,7 +3535,7 @@ SMB2_rename(const unsigned int xid, struct cifs_tcon *tcon, · 57 unmodified lines | ||
| 3535 | 3535 | int rc; |
| 3536 | 3536 | int len = (2 * UniStrnlen((wchar_t *)target_file, PATH_MAX)); |
| 3537 | 3537 | |
| 3538 | − data = kmalloc(sizeof(void *) * 2, GFP_KERNEL); | |
| 3538 | + data = kmalloc_array(2, sizeof(void *), GFP_KERNEL); | |
| 3539 | 3539 | if (!data) |
| 3540 | 3540 | return -ENOMEM; |
| 3541 | 3541 | |
| @@ -3583,7 +3583,7 @@ SMB2_set_hardlink(const unsigned int xid, struct cifs_tcon *tcon, · 41 unmodified lines | ||
| 3583 | 3583 | int rc; |
| 3584 | 3584 | int len = (2 * UniStrnlen((wchar_t *)target_file, PATH_MAX)); |
| 3585 | 3585 | |
| 3586 | − data = kmalloc(sizeof(void *) * 2, GFP_KERNEL); | |
| 3586 | + data = kmalloc_array(2, sizeof(void *), GFP_KERNEL); | |
| 3587 | 3587 | if (!data) |
| 3588 | 3588 | return -ENOMEM; |
| 3589 | 3589 | |
| @@ -844,8 +844,8 @@ SendReceive2(const unsigned int xid, struct cifs_ses *ses, · 843 unmodified lines | ||
| 844 | 844 | int rc; |
| 845 | 845 | |
| 846 | 846 | if (n_vec + 1 > CIFS_MAX_IOV_SIZE) { |
| 847 | − new_iov = kmalloc(sizeof(struct kvec) * (n_vec + 1), | |
| 848 | − GFP_KERNEL); | |
| 847 | + new_iov = kmalloc_array(n_vec + 1, sizeof(struct kvec), | |
| 848 | + GFP_KERNEL); | |
| 849 | 849 | if (!new_iov) { |
| 850 | 850 | /* otherwise cifs_send_recv below sets resp_buf_type */ |
| 851 | 851 | *resp_buf_type = CIFS_NO_BUFFER; |
| @@ -886,8 +886,8 @@ smb2_send_recv(const unsigned int xid, struct cifs_ses *ses, · 34 unmodified lines | ||
| 886 | 886 | __be32 rfc1002_marker; |
| 887 | 887 | |
| 888 | 888 | if (n_vec + 1 > CIFS_MAX_IOV_SIZE) { |
| 889 | − new_iov = kmalloc(sizeof(struct kvec) * (n_vec + 1), | |
| 890 | − GFP_KERNEL); | |
| 889 | + new_iov = kmalloc_array(n_vec + 1, sizeof(struct kvec), | |
| 890 | + GFP_KERNEL); | |
| 891 | 891 | if (!new_iov) |
| 892 | 892 | return -ENOMEM; |
| 893 | 893 | } else |
| @@ -517,7 +517,7 @@ static int new_lockspace(const char *name, const char *cluster, · 516 unmodified lines | ||
| 517 | 517 | size = dlm_config.ci_rsbtbl_size; |
| 518 | 518 | ls->ls_rsbtbl_size = size; |
| 519 | 519 | |
| 520 | − ls->ls_rsbtbl = vmalloc(sizeof(struct dlm_rsbtable) * size); | |
| 520 | + ls->ls_rsbtbl = vmalloc(array_size(size, sizeof(struct dlm_rsbtable))); | |
| 521 | 521 | if (!ls->ls_rsbtbl) |
| 522 | 522 | goto out_lsfree; |
| 523 | 523 | for (i = 0; i < size; i++) { |
| @@ -110,8 +110,8 @@ static int pcol_try_alloc(struct page_collect *pcol) · 109 unmodified lines | ||
| 110 | 110 | pages = exofs_max_io_pages(&pcol->sbi->layout, pcol->expected_pages); |
| 111 | 111 | |
| 112 | 112 | for (; pages; pages >>= 1) { |
| 113 | − pcol->pages = kmalloc(pages * sizeof(struct page *), | |
| 114 | − GFP_KERNEL); | |
| 113 | + pcol->pages = kmalloc_array(pages, sizeof(struct page *), | |
| 114 | + GFP_KERNEL); | |
| 115 | 115 | if (likely(pcol->pages)) { |
| 116 | 116 | pcol->alloc_pages = pages; |
| 117 | 117 | return 0; |
| @@ -1082,7 +1082,9 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent) · 1081 unmodified lines | ||
| 1082 | 1082 | / EXT2_BLOCKS_PER_GROUP(sb)) + 1; |
| 1083 | 1083 | db_count = (sbi->s_groups_count + EXT2_DESC_PER_BLOCK(sb) - 1) / |
| 1084 | 1084 | EXT2_DESC_PER_BLOCK(sb); |
| 1085 | − sbi->s_group_desc = kmalloc (db_count * sizeof (struct buffer_head *), GFP_KERNEL); | |
| 1085 | + sbi->s_group_desc = kmalloc_array (db_count, | |
| 1086 | + sizeof(struct buffer_head *), | |
| 1087 | + GFP_KERNEL); | |
| 1086 | 1088 | if (sbi->s_group_desc == NULL) { |
| 1087 | 1089 | ext2_msg(sb, KERN_ERR, "error: not enough memory"); |
| 1088 | 1090 | goto failed_mount; |
| @@ -577,7 +577,7 @@ int ext4_ext_precache(struct inode *inode) · 576 unmodified lines | ||
| 577 | 577 | down_read(&ei->i_data_sem); |
| 578 | 578 | depth = ext_depth(inode); |
| 579 | 579 | |
| 580 | − path = kzalloc(sizeof(struct ext4_ext_path) * (depth + 1), | |
| 580 | + path = kcalloc(depth + 1, sizeof(struct ext4_ext_path), | |
| 581 | 581 | GFP_NOFS); |
| 582 | 582 | if (path == NULL) { |
| 583 | 583 | up_read(&ei->i_data_sem); |
| @@ -879,7 +879,7 @@ ext4_find_extent(struct inode *inode, ext4_lblk_t block, · 295 unmodified lines | ||
| 879 | 879 | } |
| 880 | 880 | if (!path) { |
| 881 | 881 | /* account possible depth increase */ |
| 882 | − path = kzalloc(sizeof(struct ext4_ext_path) * (depth + 2), | |
| 882 | + path = kcalloc(depth + 2, sizeof(struct ext4_ext_path), | |
| 883 | 883 | GFP_NOFS); |
| 884 | 884 | if (unlikely(!path)) |
| 885 | 885 | return ERR_PTR(-ENOMEM); |
| @@ -1063,7 +1063,7 @@ static int ext4_ext_split(handle_t *handle, struct inode *inode, · 177 unmodified lines | ||
| 1063 | 1063 | * We need this to handle errors and free blocks |
| 1064 | 1064 | * upon them. |
| 1065 | 1065 | */ |
| 1066 | − ablocks = kzalloc(sizeof(ext4_fsblk_t) * depth, GFP_NOFS); | |
| 1066 | + ablocks = kcalloc(depth, sizeof(ext4_fsblk_t), GFP_NOFS); | |
| 1067 | 1067 | if (!ablocks) |
| 1068 | 1068 | return -ENOMEM; |
| 1069 | 1069 | |
| @@ -2921,7 +2921,7 @@ again: · 1851 unmodified lines | ||
| 2921 | 2921 | path[k].p_block = |
| 2922 | 2922 | le16_to_cpu(path[k].p_hdr->eh_entries)+1; |
| 2923 | 2923 | } else { |
| 2924 | − path = kzalloc(sizeof(struct ext4_ext_path) * (depth + 1), | |
| 2924 | + path = kcalloc(depth + 1, sizeof(struct ext4_ext_path), | |
| 2925 | 2925 | GFP_NOFS); |
| 2926 | 2926 | if (path == NULL) { |
| 2927 | 2927 | ext4_journal_stop(handle); |
| @@ -204,12 +204,14 @@ static struct ext4_new_flex_group_data *alloc_flex_gd(unsigned long flexbg_size) · 203 unmodified lines | ||
| 204 | 204 | goto out2; |
| 205 | 205 | flex_gd->count = flexbg_size; |
| 206 | 206 | |
| 207 | − flex_gd->groups = kmalloc(sizeof(struct ext4_new_group_data) * | |
| 208 | − flexbg_size, GFP_NOFS); | |
| 207 | + flex_gd->groups = kmalloc_array(flexbg_size, | |
| 208 | + sizeof(struct ext4_new_group_data), | |
| 209 | + GFP_NOFS); | |
| 209 | 210 | if (flex_gd->groups == NULL) |
| 210 | 211 | goto out2; |
| 211 | 212 | |
| 212 | − flex_gd->bg_flags = kmalloc(flexbg_size * sizeof(__u16), GFP_NOFS); | |
| 213 | + flex_gd->bg_flags = kmalloc_array(flexbg_size, sizeof(__u16), | |
| 214 | + GFP_NOFS); | |
| 213 | 215 | if (flex_gd->bg_flags == NULL) |
| 214 | 216 | goto out1; |
| 215 | 217 | |
| @@ -969,7 +971,7 @@ static int reserve_backup_gdb(handle_t *handle, struct inode *inode, · 753 unmodified lines | ||
| 969 | 971 | int res, i; |
| 970 | 972 | int err; |
| 971 | 973 | |
| 972 | − primary = kmalloc(reserved_gdb * sizeof(*primary), GFP_NOFS); | |
| 974 | + primary = kmalloc_array(reserved_gdb, sizeof(*primary), GFP_NOFS); | |
| 973 | 975 | if (!primary) |
| 974 | 976 | return -ENOMEM; |
| 975 | 977 | |
| @@ -3993,9 +3993,9 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) · 3992 unmodified lines | ||
| 3993 | 3993 | goto failed_mount; |
| 3994 | 3994 | } |
| 3995 | 3995 | } |
| 3996 | − sbi->s_group_desc = kvmalloc(db_count * | |
| 3997 | − sizeof(struct buffer_head *), | |
| 3998 | − GFP_KERNEL); | |
| 3996 | + sbi->s_group_desc = kvmalloc_array(db_count, | |
| 3997 | + sizeof(struct buffer_head *), | |
| 3998 | + GFP_KERNEL); | |
| 3999 | 3999 | if (sbi->s_group_desc == NULL) { |
| 4000 | 4000 | ext4_msg(sb, KERN_ERR, "not enough memory"); |
| 4001 | 4001 | ret = -ENOMEM; |
| @@ -806,7 +806,8 @@ int f2fs_get_valid_checkpoint(struct f2fs_sb_info *sbi) · 805 unmodified lines | ||
| 806 | 806 | block_t cp_blk_no; |
| 807 | 807 | int i; |
| 808 | 808 | |
| 809 | − sbi->ckpt = f2fs_kzalloc(sbi, cp_blks * blk_size, GFP_KERNEL); | |
| 809 | + sbi->ckpt = f2fs_kzalloc(sbi, array_size(blk_size, cp_blks), | |
| 810 | + GFP_KERNEL); | |
| 810 | 811 | if (!sbi->ckpt) |
| 811 | 812 | return -ENOMEM; |
| 812 | 813 | /* |
| @@ -1122,12 +1122,14 @@ static int __exchange_data_block(struct inode *src_inode, · 1121 unmodified lines | ||
| 1122 | 1122 | olen = min((pgoff_t)4 * ADDRS_PER_BLOCK, len); |
| 1123 | 1123 | |
| 1124 | 1124 | src_blkaddr = f2fs_kvzalloc(F2FS_I_SB(src_inode), |
| 1125 | − sizeof(block_t) * olen, GFP_KERNEL); | |
| 1125 | + array_size(olen, sizeof(block_t)), | |
| 1126 | + GFP_KERNEL); | |
| 1126 | 1127 | if (!src_blkaddr) |
| 1127 | 1128 | return -ENOMEM; |
| 1128 | 1129 | |
| 1129 | 1130 | do_replace = f2fs_kvzalloc(F2FS_I_SB(src_inode), |
| 1130 | − sizeof(int) * olen, GFP_KERNEL); | |
| 1131 | + array_size(olen, sizeof(int)), | |
| 1132 | + GFP_KERNEL); | |
| 1131 | 1133 | if (!do_replace) { |
| 1132 | 1134 | kvfree(src_blkaddr); |
| 1133 | 1135 | return -ENOMEM; |
| @@ -2753,8 +2753,10 @@ static int init_free_nid_cache(struct f2fs_sb_info *sbi) · 2752 unmodified lines | ||
| 2753 | 2753 | struct f2fs_nm_info *nm_i = NM_I(sbi); |
| 2754 | 2754 | int i; |
| 2755 | 2755 | |
| 2756 | − nm_i->free_nid_bitmap = f2fs_kzalloc(sbi, nm_i->nat_blocks * | |
| 2757 | − sizeof(unsigned char *), GFP_KERNEL); | |
| 2756 | + nm_i->free_nid_bitmap = | |
| 2757 | + f2fs_kzalloc(sbi, array_size(sizeof(unsigned char *), | |
| 2758 | + nm_i->nat_blocks), | |
| 2759 | + GFP_KERNEL); | |
| 2758 | 2760 | if (!nm_i->free_nid_bitmap) |
| 2759 | 2761 | return -ENOMEM; |
| 2760 | 2762 | |
| @@ -2770,8 +2772,10 @@ static int init_free_nid_cache(struct f2fs_sb_info *sbi) · 9 unmodified lines | ||
| 2770 | 2772 | if (!nm_i->nat_block_bitmap) |
| 2771 | 2773 | return -ENOMEM; |
| 2772 | 2774 | |
| 2773 | − nm_i->free_nid_count = f2fs_kvzalloc(sbi, nm_i->nat_blocks * | |
| 2774 | − sizeof(unsigned short), GFP_KERNEL); | |
| 2775 | + nm_i->free_nid_count = | |
| 2776 | + f2fs_kvzalloc(sbi, array_size(sizeof(unsigned short), | |
| 2777 | + nm_i->nat_blocks), | |
| 2778 | + GFP_KERNEL); | |
| 2775 | 2779 | if (!nm_i->free_nid_count) |
| 2776 | 2780 | return -ENOMEM; |
| 2777 | 2781 | return 0; |
| @@ -3517,8 +3517,10 @@ static int build_sit_info(struct f2fs_sb_info *sbi) · 3516 unmodified lines | ||
| 3517 | 3517 | |
| 3518 | 3518 | SM_I(sbi)->sit_info = sit_i; |
| 3519 | 3519 | |
| 3520 | − sit_i->sentries = f2fs_kvzalloc(sbi, MAIN_SEGS(sbi) * | |
| 3521 | − sizeof(struct seg_entry), GFP_KERNEL); | |
| 3520 | + sit_i->sentries = | |
| 3521 | + f2fs_kvzalloc(sbi, array_size(sizeof(struct seg_entry), | |
| 3522 | + MAIN_SEGS(sbi)), | |
| 3523 | + GFP_KERNEL); | |
| 3522 | 3524 | if (!sit_i->sentries) |
| 3523 | 3525 | return -ENOMEM; |
| 3524 | 3526 | |
| @@ -3558,8 +3560,10 @@ static int build_sit_info(struct f2fs_sb_info *sbi) · 33 unmodified lines | ||
| 3558 | 3560 | return -ENOMEM; |
| 3559 | 3561 | |
| 3560 | 3562 | if (sbi->segs_per_sec > 1) { |
| 3561 | − sit_i->sec_entries = f2fs_kvzalloc(sbi, MAIN_SECS(sbi) * | |
| 3562 | − sizeof(struct sec_entry), GFP_KERNEL); | |
| 3563 | + sit_i->sec_entries = | |
| 3564 | + f2fs_kvzalloc(sbi, array_size(sizeof(struct sec_entry), | |
| 3565 | + MAIN_SECS(sbi)), | |
| 3566 | + GFP_KERNEL); | |
| 3563 | 3567 | if (!sit_i->sec_entries) |
| 3564 | 3568 | return -ENOMEM; |
| 3565 | 3569 | } |
| @@ -3635,7 +3639,8 @@ static int build_curseg(struct f2fs_sb_info *sbi) · 69 unmodified lines | ||
| 3635 | 3639 | struct curseg_info *array; |
| 3636 | 3640 | int i; |
| 3637 | 3641 | |
| 3638 | − array = f2fs_kzalloc(sbi, sizeof(*array) * NR_CURSEG_TYPE, GFP_KERNEL); | |
| 3642 | + array = f2fs_kzalloc(sbi, array_size(NR_CURSEG_TYPE, sizeof(*array)), | |
| 3643 | + GFP_KERNEL); | |
| 3639 | 3644 | if (!array) |
| 3640 | 3645 | return -ENOMEM; |
| 3641 | 3646 | |
| @@ -2419,8 +2419,10 @@ static int init_blkz_info(struct f2fs_sb_info *sbi, int devi) · 2418 unmodified lines | ||
| 2419 | 2419 | |
| 2420 | 2420 | #define F2FS_REPORT_NR_ZONES 4096 |
| 2421 | 2421 | |
| 2422 | − zones = f2fs_kzalloc(sbi, sizeof(struct blk_zone) * | |
| 2423 | − F2FS_REPORT_NR_ZONES, GFP_KERNEL); | |
| 2422 | + zones = f2fs_kzalloc(sbi, | |
| 2423 | + array_size(F2FS_REPORT_NR_ZONES, | |
| 2424 | + sizeof(struct blk_zone)), | |
| 2425 | + GFP_KERNEL); | |
| 2424 | 2426 | if (!zones) |
| 2425 | 2427 | return -ENOMEM; |
| 2426 | 2428 | |
| @@ -2560,8 +2562,10 @@ static int f2fs_scan_devices(struct f2fs_sb_info *sbi) · 133 unmodified lines | ||
| 2560 | 2562 | * Initialize multiple devices information, or single |
| 2561 | 2563 | * zoned block device information. |
| 2562 | 2564 | */ |
| 2563 | − sbi->devs = f2fs_kzalloc(sbi, sizeof(struct f2fs_dev_info) * | |
| 2564 | − max_devices, GFP_KERNEL); | |
| 2565 | + sbi->devs = f2fs_kzalloc(sbi, | |
| 2566 | + array_size(max_devices, | |
| 2567 | + sizeof(struct f2fs_dev_info)), | |
| 2568 | + GFP_KERNEL); | |
| 2565 | 2569 | if (!sbi->devs) |
| 2566 | 2570 | return -ENOMEM; |
| 2567 | 2571 | |
| @@ -2783,9 +2787,11 @@ try_onemore: · 215 unmodified lines | ||
| 2783 | 2787 | int n = (i == META) ? 1: NR_TEMP_TYPE; |
| 2784 | 2788 | int j; |
| 2785 | 2789 | |
| 2786 | − sbi->write_io[i] = f2fs_kmalloc(sbi, | |
| 2787 | − n * sizeof(struct f2fs_bio_info), | |
| 2788 | − GFP_KERNEL); | |
| 2790 | + sbi->write_io[i] = | |
| 2791 | + f2fs_kmalloc(sbi, | |
| 2792 | + array_size(n, | |
| 2793 | + sizeof(struct f2fs_bio_info)), | |
| 2794 | + GFP_KERNEL); | |
| 2789 | 2795 | if (!sbi->write_io[i]) { |
| 2790 | 2796 | err = -ENOMEM; |
| 2791 | 2797 | goto free_options; |
| @@ -664,7 +664,7 @@ static int vfat_add_entry(struct inode *dir, const struct qstr *qname, · 663 unmodified lines | ||
| 664 | 664 | if (len == 0) |
| 665 | 665 | return -ENOENT; |
| 666 | 666 | |
| 667 | − slots = kmalloc(sizeof(*slots) * MSDOS_SLOTS, GFP_NOFS); | |
| 667 | + slots = kmalloc_array(MSDOS_SLOTS, sizeof(*slots), GFP_NOFS); | |
| 668 | 668 | if (slots == NULL) |
| 669 | 669 | return -ENOMEM; |
| 670 | 670 | |
| @@ -64,9 +64,12 @@ static struct fuse_req *__fuse_request_alloc(unsigned npages, gfp_t flags) · 63 unmodified lines | ||
| 64 | 64 | pages = req->inline_pages; |
| 65 | 65 | page_descs = req->inline_page_descs; |
| 66 | 66 | } else { |
| 67 | − pages = kmalloc(sizeof(struct page *) * npages, flags); | |
| 68 | − page_descs = kmalloc(sizeof(struct fuse_page_desc) * | |
| 69 | − npages, flags); | |
| 67 | + pages = kmalloc_array(npages, sizeof(struct page *), | |
| 68 | + flags); | |
| 69 | + page_descs = | |
| 70 | + kmalloc_array(npages, | |
| 71 | + sizeof(struct fuse_page_desc), | |
| 72 | + flags); | |
| 70 | 73 | } |
| 71 | 74 | |
| 72 | 75 | if (!pages || !page_descs) { |
| @@ -1359,7 +1362,8 @@ static ssize_t fuse_dev_splice_read(struct file *in, loff_t *ppos, · 1286 unmodified lines | ||
| 1359 | 1362 | if (!fud) |
| 1360 | 1363 | return -EPERM; |
| 1361 | 1364 | |
| 1362 | − bufs = kmalloc(pipe->buffers * sizeof(struct pipe_buffer), GFP_KERNEL); | |
| 1365 | + bufs = kmalloc_array(pipe->buffers, sizeof(struct pipe_buffer), | |
| 1366 | + GFP_KERNEL); | |
| 1363 | 1367 | if (!bufs) |
| 1364 | 1368 | return -ENOMEM; |
| 1365 | 1369 | |
| @@ -1940,7 +1944,8 @@ static ssize_t fuse_dev_splice_write(struct pipe_inode_info *pipe, · 574 unmodified lines | ||
| 1940 | 1944 | if (!fud) |
| 1941 | 1945 | return -EPERM; |
| 1942 | 1946 | |
| 1943 | − bufs = kmalloc(pipe->buffers * sizeof(struct pipe_buffer), GFP_KERNEL); | |
| 1947 | + bufs = kmalloc_array(pipe->buffers, sizeof(struct pipe_buffer), | |
| 1948 | + GFP_KERNEL); | |
| 1944 | 1949 | if (!bufs) |
| 1945 | 1950 | return -ENOMEM; |
| 1946 | 1951 | |
| @@ -1055,7 +1055,7 @@ static int dir_split_leaf(struct inode *inode, const struct qstr *name) · 1054 unmodified lines | ||
| 1055 | 1055 | /* Change the pointers. |
| 1056 | 1056 | Don't bother distinguishing stuffed from non-stuffed. |
| 1057 | 1057 | This code is complicated enough already. */ |
| 1058 | − lp = kmalloc(half_len * sizeof(__be64), GFP_NOFS); | |
| 1058 | + lp = kmalloc_array(half_len, sizeof(__be64), GFP_NOFS); | |
| 1059 | 1059 | if (!lp) { |
| 1060 | 1060 | error = -ENOMEM; |
| 1061 | 1061 | goto fail_brelse; |
| @@ -1169,7 +1169,7 @@ static int dir_double_exhash(struct gfs2_inode *dip) · 107 unmodified lines | ||
| 1169 | 1169 | if (IS_ERR(hc)) |
| 1170 | 1170 | return PTR_ERR(hc); |
| 1171 | 1171 | |
| 1172 | − hc2 = kmalloc(hsize_bytes * 2, GFP_NOFS | __GFP_NOWARN); | |
| 1172 | + hc2 = kmalloc_array(hsize_bytes, 2, GFP_NOFS | __GFP_NOWARN); | |
| 1173 | 1173 | if (hc2 == NULL) |
| 1174 | 1174 | hc2 = __vmalloc(hsize_bytes * 2, GFP_NOFS, PAGE_KERNEL); |
| 1175 | 1175 | |
| @@ -1596,7 +1596,7 @@ int gfs2_dir_read(struct inode *inode, struct dir_context *ctx, · 420 unmodified lines | ||
| 1596 | 1596 | |
| 1597 | 1597 | error = -ENOMEM; |
| 1598 | 1598 | /* 96 is max number of dirents which can be stuffed into an inode */ |
| 1599 | − darr = kmalloc(96 * sizeof(struct gfs2_dirent *), GFP_NOFS); | |
| 1599 | + darr = kmalloc_array(96, sizeof(struct gfs2_dirent *), GFP_NOFS); | |
| 1600 | 1600 | if (darr) { |
| 1601 | 1601 | g.pdent = (const struct gfs2_dirent **)darr; |
| 1602 | 1602 | g.offset = 0; |
| @@ -1303,7 +1303,8 @@ int gfs2_glock_nq_m(unsigned int num_gh, struct gfs2_holder *ghs) · 1302 unmodified lines | ||
| 1303 | 1303 | default: |
| 1304 | 1304 | if (num_gh <= 4) |
| 1305 | 1305 | break; |
| 1306 | − pph = kmalloc(num_gh * sizeof(struct gfs2_holder *), GFP_NOFS); | |
| 1306 | + pph = kmalloc_array(num_gh, sizeof(struct gfs2_holder *), | |
| 1307 | + GFP_NOFS); | |
| 1307 | 1308 | if (!pph) |
| 1308 | 1309 | return -ENOMEM; |
| 1309 | 1310 | } |
| @@ -886,7 +886,7 @@ static int do_sync(unsigned int num_qd, struct gfs2_quota_data **qda) · 885 unmodified lines | ||
| 886 | 886 | gfs2_write_calc_reserv(ip, sizeof(struct gfs2_quota), |
| 887 | 887 | &data_blocks, &ind_blocks); |
| 888 | 888 | |
| 889 | − ghs = kmalloc(num_qd * sizeof(struct gfs2_holder), GFP_NOFS); | |
| 889 | + ghs = kmalloc_array(num_qd, sizeof(struct gfs2_holder), GFP_NOFS); | |
| 890 | 890 | if (!ghs) |
| 891 | 891 | return -ENOMEM; |
| 892 | 892 | |
| @@ -2605,8 +2605,9 @@ void gfs2_rlist_alloc(struct gfs2_rgrp_list *rlist, unsigned int state) · 2604 unmodified lines | ||
| 2605 | 2605 | { |
| 2606 | 2606 | unsigned int x; |
| 2607 | 2607 | |
| 2608 | − rlist->rl_ghs = kmalloc(rlist->rl_rgrps * sizeof(struct gfs2_holder), | |
| 2609 | − GFP_NOFS | __GFP_NOFAIL); | |
| 2608 | + rlist->rl_ghs = kmalloc_array(rlist->rl_rgrps, | |
| 2609 | + sizeof(struct gfs2_holder), | |
| 2610 | + GFP_NOFS | __GFP_NOFAIL); | |
| 2610 | 2611 | for (x = 0; x < rlist->rl_rgrps; x++) |
| 2611 | 2612 | gfs2_holder_init(rlist->rl_rgd[x]->rd_gl, |
| 2612 | 2613 | state, 0, |
| @@ -1097,7 +1097,7 @@ static int gfs2_statfs_slow(struct gfs2_sbd *sdp, struct gfs2_statfs_change_host · 1096 unmodified lines | ||
| 1097 | 1097 | int error = 0, err; |
| 1098 | 1098 | |
| 1099 | 1099 | memset(sc, 0, sizeof(struct gfs2_statfs_change_host)); |
| 1100 | − gha = kmalloc(slots * sizeof(struct gfs2_holder), GFP_KERNEL); | |
| 1100 | + gha = kmalloc_array(slots, sizeof(struct gfs2_holder), GFP_KERNEL); | |
| 1101 | 1101 | if (!gha) |
| 1102 | 1102 | return -ENOMEM; |
| 1103 | 1103 | for (x = 0; x < slots; x++) |
| @@ -33,7 +33,8 @@ int hpfs_add_pos(struct inode *inode, loff_t *pos) · 32 unmodified lines | ||
| 33 | 33 | if (hpfs_inode->i_rddir_off[i] == pos) |
| 34 | 34 | return 0; |
| 35 | 35 | if (!(i&0x0f)) { |
| 36 | − if (!(ppos = kmalloc((i+0x11) * sizeof(loff_t*), GFP_NOFS))) { | |
| 36 | + ppos = kmalloc_array(i + 0x11, sizeof(loff_t *), GFP_NOFS); | |
| 37 | + if (!ppos) { | |
| 37 | 38 | pr_err("out of memory for position list\n"); |
| 38 | 39 | return -ENOMEM; |
| 39 | 40 | } |
| @@ -115,7 +115,7 @@ __le32 *hpfs_load_bitmap_directory(struct super_block *s, secno bmp) · 114 unmodified lines | ||
| 115 | 115 | int n = (hpfs_sb(s)->sb_fs_size + 0x200000 - 1) >> 21; |
| 116 | 116 | int i; |
| 117 | 117 | __le32 *b; |
| 118 | − if (!(b = kmalloc(n * 512, GFP_KERNEL))) { | |
| 118 | + if (!(b = kmalloc_array(n, 512, GFP_KERNEL))) { | |
| 119 | 119 | pr_err("can't allocate memory for bitmap directory\n"); |
| 120 | 120 | return NULL; |
| 121 | 121 | } |
| @@ -223,7 +223,7 @@ static struct jbd2_revoke_table_s *jbd2_journal_init_revoke_table(int hash_size) · 222 unmodified lines | ||
| 223 | 223 | table->hash_size = hash_size; |
| 224 | 224 | table->hash_shift = shift; |
| 225 | 225 | table->hash_table = |
| 226 | − kmalloc(hash_size * sizeof(struct list_head), GFP_KERNEL); | |
| 226 | + kmalloc_array(hash_size, sizeof(struct list_head), GFP_KERNEL); | |
| 227 | 227 | if (!table->hash_table) { |
| 228 | 228 | kmem_cache_free(jbd2_revoke_table_cache, table); |
| 229 | 229 | table = NULL; |
| @@ -133,7 +133,8 @@ static void *jffs2_acl_to_medium(const struct posix_acl *acl, size_t *size) · 132 unmodified lines | ||
| 133 | 133 | size_t i; |
| 134 | 134 | |
| 135 | 135 | *size = jffs2_acl_size(acl->a_count); |
| 136 | − header = kmalloc(sizeof(*header) + acl->a_count * sizeof(*entry), GFP_KERNEL); | |
| 136 | + header = kmalloc(struct_size(header, a_entries, acl->a_count), | |
| 137 | + GFP_KERNEL); | |
| 137 | 138 | if (!header) |
| 138 | 139 | return ERR_PTR(-ENOMEM); |
| 139 | 140 | header->a_version = cpu_to_je32(JFFS2_ACL_VERSION); |
| @@ -22,6 +22,7 @@ struct jffs2_acl_entry_short { · 21 unmodified lines | ||
| 22 | 22 | |
| 23 | 23 | struct jffs2_acl_header { |
| 24 | 24 | jint32_t a_version; |
| 25 | + struct jffs2_acl_entry a_entries[]; | |
| 25 | 26 | }; |
| 26 | 27 | |
| 27 | 28 | #ifdef CONFIG_JFFS2_FS_POSIX_ACL |
| @@ -1208,7 +1208,7 @@ int jffs2_nand_flash_setup(struct jffs2_sb_info *c) · 1207 unmodified lines | ||
| 1208 | 1208 | if (!c->wbuf) |
| 1209 | 1209 | return -ENOMEM; |
| 1210 | 1210 | |
| 1211 | − c->oobbuf = kmalloc(NR_OOB_SCAN_PAGES * c->oobavail, GFP_KERNEL); | |
| 1211 | + c->oobbuf = kmalloc_array(NR_OOB_SCAN_PAGES, c->oobavail, GFP_KERNEL); | |
| 1212 | 1212 | if (!c->oobbuf) { |
| 1213 | 1213 | kfree(c->wbuf); |
| 1214 | 1214 | return -ENOMEM; |
| @@ -1641,7 +1641,7 @@ s64 dbDiscardAG(struct inode *ip, int agno, s64 minlen) · 1640 unmodified lines | ||
| 1641 | 1641 | max_ranges = nblocks; |
| 1642 | 1642 | do_div(max_ranges, minlen); |
| 1643 | 1643 | range_cnt = min_t(u64, max_ranges + 1, 32 * 1024); |
| 1644 | − totrim = kmalloc(sizeof(struct range2trim) * range_cnt, GFP_NOFS); | |
| 1644 | + totrim = kmalloc_array(range_cnt, sizeof(struct range2trim), GFP_NOFS); | |
| 1645 | 1645 | if (totrim == NULL) { |
| 1646 | 1646 | jfs_error(bmp->db_ipbmap->i_sb, "no memory for trim array\n"); |
| 1647 | 1647 | IWRITE_UNLOCK(ipbmap); |
| @@ -594,7 +594,8 @@ int dtSearch(struct inode *ip, struct component_name * key, ino_t * data, · 593 unmodified lines | ||
| 594 | 594 | struct component_name ciKey; |
| 595 | 595 | struct super_block *sb = ip->i_sb; |
| 596 | 596 | |
| 597 | − ciKey.name = kmalloc((JFS_NAME_MAX + 1) * sizeof(wchar_t), GFP_NOFS); | |
| 597 | + ciKey.name = kmalloc_array(JFS_NAME_MAX + 1, sizeof(wchar_t), | |
| 598 | + GFP_NOFS); | |
| 598 | 599 | if (!ciKey.name) { |
| 599 | 600 | rc = -ENOMEM; |
| 600 | 601 | goto dtSearch_Exit2; |
| @@ -957,7 +958,7 @@ static int dtSplitUp(tid_t tid, · 356 unmodified lines | ||
| 957 | 958 | smp = split->mp; |
| 958 | 959 | sp = DT_PAGE(ip, smp); |
| 959 | 960 | |
| 960 | − key.name = kmalloc((JFS_NAME_MAX + 2) * sizeof(wchar_t), GFP_NOFS); | |
| 961 | + key.name = kmalloc_array(JFS_NAME_MAX + 2, sizeof(wchar_t), GFP_NOFS); | |
| 961 | 962 | if (!key.name) { |
| 962 | 963 | DT_PUTPAGE(smp); |
| 963 | 964 | rc = -ENOMEM; |
| @@ -3779,12 +3780,12 @@ static int ciGetLeafPrefixKey(dtpage_t * lp, int li, dtpage_t * rp, · 2815 unmodified lines | ||
| 3779 | 3780 | struct component_name lkey; |
| 3780 | 3781 | struct component_name rkey; |
| 3781 | 3782 | |
| 3782 | − lkey.name = kmalloc((JFS_NAME_MAX + 1) * sizeof(wchar_t), | |
| 3783 | + lkey.name = kmalloc_array(JFS_NAME_MAX + 1, sizeof(wchar_t), | |
| 3783 | 3784 | GFP_KERNEL); |
| 3784 | 3785 | if (lkey.name == NULL) |
| 3785 | 3786 | return -ENOMEM; |
| 3786 | 3787 | |
| 3787 | − rkey.name = kmalloc((JFS_NAME_MAX + 1) * sizeof(wchar_t), | |
| 3788 | + rkey.name = kmalloc_array(JFS_NAME_MAX + 1, sizeof(wchar_t), | |
| 3788 | 3789 | GFP_KERNEL); |
| 3789 | 3790 | if (rkey.name == NULL) { |
| 3790 | 3791 | kfree(lkey.name); |
| @@ -121,7 +121,7 @@ int get_UCSname(struct component_name * uniName, struct dentry *dentry) · 120 unmodified lines | ||
| 121 | 121 | return -ENAMETOOLONG; |
| 122 | 122 | |
| 123 | 123 | uniName->name = |
| 124 | − kmalloc((length + 1) * sizeof(wchar_t), GFP_NOFS); | |
| 124 | + kmalloc_array(length + 1, sizeof(wchar_t), GFP_NOFS); | |
| 125 | 125 | |
| 126 | 126 | if (uniName->name == NULL) |
| 127 | 127 | return -ENOMEM; |
| @@ -353,8 +353,9 @@ struct mb_cache *mb_cache_create(int bucket_bits) · 352 unmodified lines | ||
| 353 | 353 | cache->c_max_entries = bucket_count << 4; |
| 354 | 354 | INIT_LIST_HEAD(&cache->c_list); |
| 355 | 355 | spin_lock_init(&cache->c_list_lock); |
| 356 | − cache->c_hash = kmalloc(bucket_count * sizeof(struct hlist_bl_head), | |
| 357 | − GFP_KERNEL); | |
| 356 | + cache->c_hash = kmalloc_array(bucket_count, | |
| 357 | + sizeof(struct hlist_bl_head), | |
| 358 | + GFP_KERNEL); | |
| 358 | 359 | if (!cache->c_hash) { |
| 359 | 360 | kfree(cache); |
| 360 | 361 | goto err_out; |
| @@ -537,12 +537,12 @@ static int __nd_alloc_stack(struct nameidata *nd) · 536 unmodified lines | ||
| 537 | 537 | struct saved *p; |
| 538 | 538 | |
| 539 | 539 | if (nd->flags & LOOKUP_RCU) { |
| 540 | − p= kmalloc(MAXSYMLINKS * sizeof(struct saved), | |
| 540 | + p= kmalloc_array(MAXSYMLINKS, sizeof(struct saved), | |
| 541 | 541 | GFP_ATOMIC); |
| 542 | 542 | if (unlikely(!p)) |
| 543 | 543 | return -ECHILD; |
| 544 | 544 | } else { |
| 545 | − p= kmalloc(MAXSYMLINKS * sizeof(struct saved), | |
| 545 | + p= kmalloc_array(MAXSYMLINKS, sizeof(struct saved), | |
| 546 | 546 | GFP_KERNEL); |
| 547 | 547 | if (unlikely(!p)) |
| 548 | 548 | return -ENOMEM; |
| @@ -461,7 +461,7 @@ ff_layout_alloc_lseg(struct pnfs_layout_hdr *lh, · 460 unmodified lines | ||
| 461 | 461 | fh_count = be32_to_cpup(p); |
| 462 | 462 | |
| 463 | 463 | fls->mirror_array[i]->fh_versions = |
| 464 | − kzalloc(fh_count * sizeof(struct nfs_fh), | |
| 464 | + kcalloc(fh_count, sizeof(struct nfs_fh), | |
| 465 | 465 | gfp_flags); |
| 466 | 466 | if (fls->mirror_array[i]->fh_versions == NULL) { |
| 467 | 467 | rc = -ENOMEM; |
| @@ -99,7 +99,8 @@ nfs4_ff_alloc_deviceid_node(struct nfs_server *server, struct pnfs_device *pdev, · 98 unmodified lines | ||
| 99 | 99 | version_count = be32_to_cpup(p); |
| 100 | 100 | dprintk("%s: version count %d\n", __func__, version_count); |
| 101 | 101 | |
| 102 | − ds_versions = kzalloc(version_count * sizeof(struct nfs4_ff_ds_version), | |
| 102 | + ds_versions = kcalloc(version_count, | |
| 103 | + sizeof(struct nfs4_ff_ds_version), | |
| 103 | 104 | gfp_flags); |
| 104 | 105 | if (!ds_versions) |
| 105 | 106 | goto out_scratch; |
| @@ -404,8 +404,9 @@ fsloc_parse(char **mesg, char *buf, struct nfsd4_fs_locations *fsloc) · 403 unmodified lines | ||
| 404 | 404 | if (fsloc->locations_count == 0) |
| 405 | 405 | return 0; |
| 406 | 406 | |
| 407 | − fsloc->locations = kzalloc(fsloc->locations_count | |
| 408 | − * sizeof(struct nfsd4_fs_location), GFP_KERNEL); | |
| 407 | + fsloc->locations = kcalloc(fsloc->locations_count, | |
| 408 | + sizeof(struct nfsd4_fs_location), | |
| 409 | + GFP_KERNEL); | |
| 409 | 410 | if (!fsloc->locations) |
| 410 | 411 | return -ENOMEM; |
| 411 | 412 | for (i=0; i < fsloc->locations_count; i++) { |
| @@ -510,8 +510,9 @@ nfs4_legacy_state_init(struct net *net) · 509 unmodified lines | ||
| 510 | 510 | struct nfsd_net *nn = net_generic(net, nfsd_net_id); |
| 511 | 511 | int i; |
| 512 | 512 | |
| 513 | − nn->reclaim_str_hashtbl = kmalloc(sizeof(struct list_head) * | |
| 514 | − CLIENT_HASH_SIZE, GFP_KERNEL); | |
| 513 | + nn->reclaim_str_hashtbl = kmalloc_array(CLIENT_HASH_SIZE, | |
| 514 | + sizeof(struct list_head), | |
| 515 | + GFP_KERNEL); | |
| 515 | 516 | if (!nn->reclaim_str_hashtbl) |
| 516 | 517 | return -ENOMEM; |
| 517 | 518 | |
| @@ -1807,8 +1807,9 @@ static struct nfs4_client *alloc_client(struct xdr_netobj name) · 1806 unmodified lines | ||
| 1807 | 1807 | clp->cl_name.data = kmemdup(name.data, name.len, GFP_KERNEL); |
| 1808 | 1808 | if (clp->cl_name.data == NULL) |
| 1809 | 1809 | goto err_no_name; |
| 1810 | − clp->cl_ownerstr_hashtbl = kmalloc(sizeof(struct list_head) * | |
| 1811 | − OWNER_HASH_SIZE, GFP_KERNEL); | |
| 1810 | + clp->cl_ownerstr_hashtbl = kmalloc_array(OWNER_HASH_SIZE, | |
| 1811 | + sizeof(struct list_head), | |
| 1812 | + GFP_KERNEL); | |
| 1812 | 1813 | if (!clp->cl_ownerstr_hashtbl) |
| 1813 | 1814 | goto err_no_hashtbl; |
| 1814 | 1815 | for (i = 0; i < OWNER_HASH_SIZE; i++) |
| @@ -7096,16 +7097,19 @@ static int nfs4_state_create_net(struct net *net) · 5281 unmodified lines | ||
| 7096 | 7097 | struct nfsd_net *nn = net_generic(net, nfsd_net_id); |
| 7097 | 7098 | int i; |
| 7098 | 7099 | |
| 7099 | − nn->conf_id_hashtbl = kmalloc(sizeof(struct list_head) * | |
| 7100 | − CLIENT_HASH_SIZE, GFP_KERNEL); | |
| 7100 | + nn->conf_id_hashtbl = kmalloc_array(CLIENT_HASH_SIZE, | |
| 7101 | + sizeof(struct list_head), | |
| 7102 | + GFP_KERNEL); | |
| 7101 | 7103 | if (!nn->conf_id_hashtbl) |
| 7102 | 7104 | goto err; |
| 7103 | − nn->unconf_id_hashtbl = kmalloc(sizeof(struct list_head) * | |
| 7104 | − CLIENT_HASH_SIZE, GFP_KERNEL); | |
| 7105 | + nn->unconf_id_hashtbl = kmalloc_array(CLIENT_HASH_SIZE, | |
| 7106 | + sizeof(struct list_head), | |
| 7107 | + GFP_KERNEL); | |
| 7105 | 7108 | if (!nn->unconf_id_hashtbl) |
| 7106 | 7109 | goto err_unconf_id; |
| 7107 | − nn->sessionid_hashtbl = kmalloc(sizeof(struct list_head) * | |
| 7108 | − SESSION_HASH_SIZE, GFP_KERNEL); | |
| 7110 | + nn->sessionid_hashtbl = kmalloc_array(SESSION_HASH_SIZE, | |
| 7111 | + sizeof(struct list_head), | |
| 7112 | + GFP_KERNEL); | |
| 7109 | 7113 | if (!nn->sessionid_hashtbl) |
| 7110 | 7114 | goto err_sessionid; |
| 7111 | 7115 | |
| @@ -177,7 +177,8 @@ int nfsd_reply_cache_init(void) · 176 unmodified lines | ||
| 177 | 177 | |
| 178 | 178 | drc_hashtbl = kcalloc(hashsize, sizeof(*drc_hashtbl), GFP_KERNEL); |
| 179 | 179 | if (!drc_hashtbl) { |
| 180 | − drc_hashtbl = vzalloc(hashsize * sizeof(*drc_hashtbl)); | |
| 180 | + drc_hashtbl = vzalloc(array_size(hashsize, | |
| 181 | + sizeof(*drc_hashtbl))); | |
| 181 | 182 | if (!drc_hashtbl) |
| 182 | 183 | goto out_nomem; |
| 183 | 184 | } |
| @@ -527,7 +527,7 @@ int ntfs_read_compressed_block(struct page *page) · 526 unmodified lines | ||
| 527 | 527 | BUG_ON(ni->type != AT_DATA); |
| 528 | 528 | BUG_ON(ni->name_len); |
| 529 | 529 | |
| 530 | − pages = kmalloc(nr_pages * sizeof(struct page *), GFP_NOFS); | |
| 530 | + pages = kmalloc_array(nr_pages, sizeof(struct page *), GFP_NOFS); | |
| 531 | 531 | |
| 532 | 532 | /* Allocate memory to store the buffer heads we need. */ |
| 533 | 533 | bhs_size = cb_size / block_size * sizeof(struct buffer_head *); |
| @@ -1078,7 +1078,7 @@ int o2net_send_message_vec(u32 msg_type, u32 key, struct kvec *caller_vec, · 1077 unmodified lines | ||
| 1078 | 1078 | o2net_set_nst_sock_container(&nst, sc); |
| 1079 | 1079 | |
| 1080 | 1080 | veclen = caller_veclen + 1; |
| 1081 | − vec = kmalloc(sizeof(struct kvec) * veclen, GFP_ATOMIC); | |
| 1081 | + vec = kmalloc_array(veclen, sizeof(struct kvec), GFP_ATOMIC); | |
| 1082 | 1082 | if (vec == NULL) { |
| 1083 | 1083 | mlog(0, "failed to %zu element kvec!\n", veclen); |
| 1084 | 1084 | ret = -ENOMEM; |
| @@ -86,7 +86,7 @@ static void dlm_free_pagevec(void **vec, int pages) · 85 unmodified lines | ||
| 86 | 86 | |
| 87 | 87 | static void **dlm_alloc_pagevec(int pages) |
| 88 | 88 | { |
| 89 | − void **vec = kmalloc(pages * sizeof(void *), GFP_KERNEL); | |
| 89 | + void **vec = kmalloc_array(pages, sizeof(void *), GFP_KERNEL); | |
| 90 | 90 | int i; |
| 91 | 91 | |
| 92 | 92 | if (!vec) |
| @@ -1383,7 +1383,7 @@ static int __ocfs2_recovery_thread(void *arg) · 1382 unmodified lines | ||
| 1383 | 1383 | goto bail; |
| 1384 | 1384 | } |
| 1385 | 1385 | |
| 1386 | − rm_quota = kzalloc(osb->max_slots * sizeof(int), GFP_NOFS); | |
| 1386 | + rm_quota = kcalloc(osb->max_slots, sizeof(int), GFP_NOFS); | |
| 1387 | 1387 | if (!rm_quota) { |
| 1388 | 1388 | status = -ENOMEM; |
| 1389 | 1389 | goto bail; |
| @@ -69,10 +69,11 @@ static struct inode **get_local_system_inode(struct ocfs2_super *osb, · 68 unmodified lines | ||
| 69 | 69 | spin_unlock(&osb->osb_lock); |
| 70 | 70 | |
| 71 | 71 | if (unlikely(!local_system_inodes)) { |
| 72 | − local_system_inodes = kzalloc(sizeof(struct inode *) * | |
| 73 | − NUM_LOCAL_SYSTEM_INODES * | |
| 74 | − osb->max_slots, | |
| 75 | − GFP_NOFS); | |
| 72 | + local_system_inodes = | |
| 73 | + kzalloc(array3_size(sizeof(struct inode *), | |
| 74 | + NUM_LOCAL_SYSTEM_INODES, | |
| 75 | + osb->max_slots), | |
| 76 | + GFP_NOFS); | |
| 76 | 77 | if (!local_system_inodes) { |
| 77 | 78 | mlog_errno(-ENOMEM); |
| 78 | 79 | /* |
| @@ -612,7 +612,7 @@ static int ovl_get_index_name_fh(struct ovl_fh *fh, struct qstr *name) · 611 unmodified lines | ||
| 612 | 612 | { |
| 613 | 613 | char *n, *s; |
| 614 | 614 | |
| 615 | − n = kzalloc(fh->len * 2, GFP_KERNEL); | |
| 615 | + n = kcalloc(fh->len, 2, GFP_KERNEL); | |
| 616 | 616 | if (!n) |
| 617 | 617 | return -ENOMEM; |
| 618 | 618 | |
| @@ -389,7 +389,8 @@ static int proc_pid_stack(struct seq_file *m, struct pid_namespace *ns, · 388 unmodified lines | ||
| 389 | 389 | unsigned long *entries; |
| 390 | 390 | int err; |
| 391 | 391 | |
| 392 | − entries = kmalloc(MAX_STACK_TRACE_DEPTH * sizeof(*entries), GFP_KERNEL); | |
| 392 | + entries = kmalloc_array(MAX_STACK_TRACE_DEPTH, sizeof(*entries), | |
| 393 | + GFP_KERNEL); | |
| 393 | 394 | if (!entries) |
| 394 | 395 | return -ENOMEM; |
| 395 | 396 | |
| @@ -1426,7 +1426,7 @@ static int register_leaf_sysctl_tables(const char *path, char *pos, · 1425 unmodified lines | ||
| 1426 | 1426 | /* If there are mixed files and directories we need a new table */ |
| 1427 | 1427 | if (nr_dirs && nr_files) { |
| 1428 | 1428 | struct ctl_table *new; |
| 1429 | − files = kzalloc(sizeof(struct ctl_table) * (nr_files + 1), | |
| 1429 | + files = kcalloc(nr_files + 1, sizeof(struct ctl_table), | |
| 1430 | 1430 | GFP_KERNEL); |
| 1431 | 1431 | if (!files) |
| 1432 | 1432 | goto out; |
| @@ -1473,7 +1473,7 @@ static ssize_t pagemap_read(struct file *file, char __user *buf, · 1472 unmodified lines | ||
| 1473 | 1473 | pm.show_pfn = file_ns_capable(file, &init_user_ns, CAP_SYS_ADMIN); |
| 1474 | 1474 | |
| 1475 | 1475 | pm.len = (PAGEMAP_WALK_SIZE >> PAGE_SHIFT); |
| 1476 | − pm.buffer = kmalloc(pm.len * PM_ENTRY_BYTES, GFP_KERNEL); | |
| 1476 | + pm.buffer = kmalloc_array(pm.len, PM_ENTRY_BYTES, GFP_KERNEL); | |
| 1477 | 1477 | ret = -ENOMEM; |
| 1478 | 1478 | if (!pm.buffer) |
| 1479 | 1479 | goto out_mm; |
| @@ -778,7 +778,7 @@ ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector, · 777 unmodified lines | ||
| 778 | 778 | goto out; |
| 779 | 779 | } |
| 780 | 780 | if (nr_segs > fast_segs) { |
| 781 | − iov = kmalloc(nr_segs*sizeof(struct iovec), GFP_KERNEL); | |
| 781 | + iov = kmalloc_array(nr_segs, sizeof(struct iovec), GFP_KERNEL); | |
| 782 | 782 | if (iov == NULL) { |
| 783 | 783 | ret = -ENOMEM; |
| 784 | 784 | goto out; |
| @@ -849,7 +849,7 @@ ssize_t compat_rw_copy_check_uvector(int type, · 64 unmodified lines | ||
| 849 | 849 | goto out; |
| 850 | 850 | if (nr_segs > fast_segs) { |
| 851 | 851 | ret = -ENOMEM; |
| 852 | − iov = kmalloc(nr_segs*sizeof(struct iovec), GFP_KERNEL); | |
| 852 | + iov = kmalloc_array(nr_segs, sizeof(struct iovec), GFP_KERNEL); | |
| 853 | 853 | if (iov == NULL) |
| 854 | 854 | goto out; |
| 855 | 855 | } |
| @@ -1456,7 +1456,7 @@ int reiserfs_init_bitmap_cache(struct super_block *sb) · 1455 unmodified lines | ||
| 1456 | 1456 | struct reiserfs_bitmap_info *bitmap; |
| 1457 | 1457 | unsigned int bmap_nr = reiserfs_bmap_count(sb); |
| 1458 | 1458 | |
| 1459 | − bitmap = vmalloc(sizeof(*bitmap) * bmap_nr); | |
| 1459 | + bitmap = vmalloc(array_size(bmap_nr, sizeof(*bitmap))); | |
| 1460 | 1460 | if (bitmap == NULL) |
| 1461 | 1461 | return -ENOMEM; |
| 1462 | 1462 | |
| @@ -1044,7 +1044,8 @@ research: · 1043 unmodified lines | ||
| 1044 | 1044 | if (blocks_needed == 1) { |
| 1045 | 1045 | un = &unf_single; |
| 1046 | 1046 | } else { |
| 1047 | − un = kzalloc(min(blocks_needed, max_to_insert) * UNFM_P_SIZE, GFP_NOFS); | |
| 1047 | + un = kcalloc(min(blocks_needed, max_to_insert), | |
| 1048 | + UNFM_P_SIZE, GFP_NOFS); | |
| 1048 | 1049 | if (!un) { |
| 1049 | 1050 | un = &unf_single; |
| 1050 | 1051 | blocks_needed = 1; |
| @@ -350,7 +350,8 @@ static struct reiserfs_journal_cnode *allocate_cnodes(int num_cnodes) · 349 unmodified lines | ||
| 350 | 350 | if (num_cnodes <= 0) { |
| 351 | 351 | return NULL; |
| 352 | 352 | } |
| 353 | − head = vzalloc(num_cnodes * sizeof(struct reiserfs_journal_cnode)); | |
| 353 | + head = vzalloc(array_size(num_cnodes, | |
| 354 | + sizeof(struct reiserfs_journal_cnode))); | |
| 354 | 355 | if (!head) { |
| 355 | 356 | return NULL; |
| 356 | 357 | } |
| @@ -2192,10 +2193,12 @@ static int journal_read_transaction(struct super_block *sb, · 1835 unmodified lines | ||
| 2192 | 2193 | * now we know we've got a good transaction, and it was |
| 2193 | 2194 | * inside the valid time ranges |
| 2194 | 2195 | */ |
| 2195 | − log_blocks = kmalloc(get_desc_trans_len(desc) * | |
| 2196 | − sizeof(struct buffer_head *), GFP_NOFS); | |
| 2197 | − real_blocks = kmalloc(get_desc_trans_len(desc) * | |
| 2198 | − sizeof(struct buffer_head *), GFP_NOFS); | |
| 2196 | + log_blocks = kmalloc_array(get_desc_trans_len(desc), | |
| 2197 | + sizeof(struct buffer_head *), | |
| 2198 | + GFP_NOFS); | |
| 2199 | + real_blocks = kmalloc_array(get_desc_trans_len(desc), | |
| 2200 | + sizeof(struct buffer_head *), | |
| 2201 | + GFP_NOFS); | |
| 2199 | 2202 | if (!log_blocks || !real_blocks) { |
| 2200 | 2203 | brelse(c_bh); |
| 2201 | 2204 | brelse(d_bh); |
| @@ -120,7 +120,8 @@ int reiserfs_resize(struct super_block *s, unsigned long block_count_new) · 119 unmodified lines | ||
| 120 | 120 | * array of bitmap block pointers |
| 121 | 121 | */ |
| 122 | 122 | bitmap = |
| 123 | − vzalloc(sizeof(struct reiserfs_bitmap_info) * bmap_nr_new); | |
| 123 | + vzalloc(array_size(bmap_nr_new, | |
| 124 | + sizeof(struct reiserfs_bitmap_info))); | |
| 124 | 125 | if (!bitmap) { |
| 125 | 126 | /* |
| 126 | 127 | * Journal bitmaps are still supersized, but the |
| @@ -1236,7 +1236,7 @@ static int compat_core_sys_select(int n, compat_ulong_t __user *inp, · 1235 unmodified lines | ||
| 1236 | 1236 | size = FDS_BYTES(n); |
| 1237 | 1237 | bits = stack_fds; |
| 1238 | 1238 | if (size > sizeof(stack_fds) / 6) { |
| 1239 | − bits = kmalloc(6 * size, GFP_KERNEL); | |
| 1239 | + bits = kmalloc_array(6, size, GFP_KERNEL); | |
| 1240 | 1240 | ret = -ENOMEM; |
| 1241 | 1241 | if (!bits) |
| 1242 | 1242 | goto out_nofds; |
| @@ -259,8 +259,9 @@ int splice_grow_spd(const struct pipe_inode_info *pipe, struct splice_pipe_desc · 258 unmodified lines | ||
| 259 | 259 | if (buffers <= PIPE_DEF_BUFFERS) |
| 260 | 260 | return 0; |
| 261 | 261 | |
| 262 | − spd->pages = kmalloc(buffers * sizeof(struct page *), GFP_KERNEL); | |
| 263 | − spd->partial = kmalloc(buffers * sizeof(struct partial_page), GFP_KERNEL); | |
| 262 | + spd->pages = kmalloc_array(buffers, sizeof(struct page *), GFP_KERNEL); | |
| 263 | + spd->partial = kmalloc_array(buffers, sizeof(struct partial_page), | |
| 264 | + GFP_KERNEL); | |
| 264 | 265 | |
| 265 | 266 | if (spd->pages && spd->partial) |
| 266 | 267 | return 0; |
| @@ -395,7 +396,7 @@ static ssize_t default_file_splice_read(struct file *in, loff_t *ppos, · 128 unmodified lines | ||
| 395 | 396 | |
| 396 | 397 | vec = __vec; |
| 397 | 398 | if (nr_pages > PIPE_DEF_BUFFERS) { |
| 398 | − vec = kmalloc(nr_pages * sizeof(struct kvec), GFP_KERNEL); | |
| 399 | + vec = kmalloc_array(nr_pages, sizeof(struct kvec), GFP_KERNEL); | |
| 399 | 400 | if (unlikely(!vec)) { |
| 400 | 401 | res = -ENOMEM; |
| 401 | 402 | goto out; |
| @@ -1282,10 +1282,11 @@ static int truncate_data_node(const struct ubifs_info *c, const struct inode *in · 1281 unmodified lines | ||
| 1282 | 1282 | int *new_len) |
| 1283 | 1283 | { |
| 1284 | 1284 | void *buf; |
| 1285 | − int err, dlen, compr_type, out_len, old_dlen; | |
| 1285 | + int err, compr_type; | |
| 1286 | + u32 dlen, out_len, old_dlen; | |
| 1286 | 1287 | |
| 1287 | 1288 | out_len = le32_to_cpu(dn->size); |
| 1288 | − buf = kmalloc(out_len * WORST_COMPR_FACTOR, GFP_NOFS); | |
| 1289 | + buf = kmalloc_array(out_len, WORST_COMPR_FACTOR, GFP_NOFS); | |
| 1289 | 1290 | if (!buf) |
| 1290 | 1291 | return -ENOMEM; |
| 1291 | 1292 | |
| @@ -628,11 +628,12 @@ int ubifs_create_dflt_lpt(struct ubifs_info *c, int *main_lebs, int lpt_first, · 627 unmodified lines | ||
| 628 | 628 | /* Needed by 'ubifs_pack_lsave()' */ |
| 629 | 629 | c->main_first = c->leb_cnt - *main_lebs; |
| 630 | 630 | |
| 631 | − lsave = kmalloc(sizeof(int) * c->lsave_cnt, GFP_KERNEL); | |
| 631 | + lsave = kmalloc_array(c->lsave_cnt, sizeof(int), GFP_KERNEL); | |
| 632 | 632 | pnode = kzalloc(sizeof(struct ubifs_pnode), GFP_KERNEL); |
| 633 | 633 | nnode = kzalloc(sizeof(struct ubifs_nnode), GFP_KERNEL); |
| 634 | 634 | buf = vmalloc(c->leb_size); |
| 635 | − ltab = vmalloc(sizeof(struct ubifs_lpt_lprops) * c->lpt_lebs); | |
| 635 | + ltab = vmalloc(array_size(sizeof(struct ubifs_lpt_lprops), | |
| 636 | + c->lpt_lebs)); | |
| 636 | 637 | if (!pnode || !nnode || !buf || !ltab || !lsave) { |
| 637 | 638 | err = -ENOMEM; |
| 638 | 639 | goto out; |
| @@ -1626,7 +1627,8 @@ static int lpt_init_rd(struct ubifs_info *c) · 987 unmodified lines | ||
| 1626 | 1627 | { |
| 1627 | 1628 | int err, i; |
| 1628 | 1629 | |
| 1629 | − c->ltab = vmalloc(sizeof(struct ubifs_lpt_lprops) * c->lpt_lebs); | |
| 1630 | + c->ltab = vmalloc(array_size(sizeof(struct ubifs_lpt_lprops), | |
| 1631 | + c->lpt_lebs)); | |
| 1630 | 1632 | if (!c->ltab) |
| 1631 | 1633 | return -ENOMEM; |
| 1632 | 1634 | |
| @@ -1636,15 +1638,17 @@ static int lpt_init_rd(struct ubifs_info *c) · 3 unmodified lines | ||
| 1636 | 1638 | return -ENOMEM; |
| 1637 | 1639 | |
| 1638 | 1640 | for (i = 0; i < LPROPS_HEAP_CNT; i++) { |
| 1639 | − c->lpt_heap[i].arr = kmalloc(sizeof(void *) * LPT_HEAP_SZ, | |
| 1640 | − GFP_KERNEL); | |
| 1641 | + c->lpt_heap[i].arr = kmalloc_array(LPT_HEAP_SZ, | |
| 1642 | + sizeof(void *), | |
| 1643 | + GFP_KERNEL); | |
| 1641 | 1644 | if (!c->lpt_heap[i].arr) |
| 1642 | 1645 | return -ENOMEM; |
| 1643 | 1646 | c->lpt_heap[i].cnt = 0; |
| 1644 | 1647 | c->lpt_heap[i].max_cnt = LPT_HEAP_SZ; |
| 1645 | 1648 | } |
| 1646 | 1649 | |
| 1647 | − c->dirty_idx.arr = kmalloc(sizeof(void *) * LPT_HEAP_SZ, GFP_KERNEL); | |
| 1650 | + c->dirty_idx.arr = kmalloc_array(LPT_HEAP_SZ, sizeof(void *), | |
| 1651 | + GFP_KERNEL); | |
| 1648 | 1652 | if (!c->dirty_idx.arr) |
| 1649 | 1653 | return -ENOMEM; |
| 1650 | 1654 | c->dirty_idx.cnt = 0; |
| @@ -1688,7 +1692,8 @@ static int lpt_init_wr(struct ubifs_info *c) · 37 unmodified lines | ||
| 1688 | 1692 | { |
| 1689 | 1693 | int err, i; |
| 1690 | 1694 | |
| 1691 | − c->ltab_cmt = vmalloc(sizeof(struct ubifs_lpt_lprops) * c->lpt_lebs); | |
| 1695 | + c->ltab_cmt = vmalloc(array_size(sizeof(struct ubifs_lpt_lprops), | |
| 1696 | + c->lpt_lebs)); | |
| 1692 | 1697 | if (!c->ltab_cmt) |
| 1693 | 1698 | return -ENOMEM; |
| 1694 | 1699 | |
| @@ -1697,7 +1702,7 @@ static int lpt_init_wr(struct ubifs_info *c) · 2 unmodified lines | ||
| 1697 | 1702 | return -ENOMEM; |
| 1698 | 1703 | |
| 1699 | 1704 | if (c->big_lpt) { |
| 1700 | − c->lsave = kmalloc(sizeof(int) * c->lsave_cnt, GFP_NOFS); | |
| 1705 | + c->lsave = kmalloc_array(c->lsave_cnt, sizeof(int), GFP_NOFS); | |
| 1701 | 1706 | if (!c->lsave) |
| 1702 | 1707 | return -ENOMEM; |
| 1703 | 1708 | err = read_lsave(c); |
| @@ -1939,8 +1944,8 @@ int ubifs_lpt_scan_nolock(struct ubifs_info *c, int start_lnum, int end_lnum, · 235 unmodified lines | ||
| 1939 | 1944 | return err; |
| 1940 | 1945 | } |
| 1941 | 1946 | |
| 1942 | − path = kmalloc(sizeof(struct lpt_scan_node) * (c->lpt_hght + 1), | |
| 1943 | − GFP_NOFS); | |
| 1947 | + path = kmalloc_array(c->lpt_hght + 1, sizeof(struct lpt_scan_node), | |
| 1948 | + GFP_NOFS); | |
| 1944 | 1949 | if (!path) |
| 1945 | 1950 | return -ENOMEM; |
| 1946 | 1951 | |
| @@ -1196,7 +1196,8 @@ static int mount_ubifs(struct ubifs_info *c) · 1195 unmodified lines | ||
| 1196 | 1196 | * never exceed 64. |
| 1197 | 1197 | */ |
| 1198 | 1198 | err = -ENOMEM; |
| 1199 | − c->bottom_up_buf = kmalloc(BOTTOM_UP_HEIGHT * sizeof(int), GFP_KERNEL); | |
| 1199 | + c->bottom_up_buf = kmalloc_array(BOTTOM_UP_HEIGHT, sizeof(int), | |
| 1200 | + GFP_KERNEL); | |
| 1200 | 1201 | if (!c->bottom_up_buf) |
| 1201 | 1202 | goto out_free; |
| 1202 | 1203 | |
| @@ -1104,8 +1104,9 @@ static struct ubifs_znode *dirty_cow_bottom_up(struct ubifs_info *c, · 1103 unmodified lines | ||
| 1104 | 1104 | ubifs_assert(znode); |
| 1105 | 1105 | if (c->zroot.znode->level > BOTTOM_UP_HEIGHT) { |
| 1106 | 1106 | kfree(c->bottom_up_buf); |
| 1107 | − c->bottom_up_buf = kmalloc(c->zroot.znode->level * sizeof(int), | |
| 1108 | − GFP_NOFS); | |
| 1107 | + c->bottom_up_buf = kmalloc_array(c->zroot.znode->level, | |
| 1108 | + sizeof(int), | |
| 1109 | + GFP_NOFS); | |
| 1109 | 1110 | if (!c->bottom_up_buf) |
| 1110 | 1111 | return ERR_PTR(-ENOMEM); |
| 1111 | 1112 | path = c->bottom_up_buf; |
| @@ -366,7 +366,8 @@ static int layout_in_gaps(struct ubifs_info *c, int cnt) · 365 unmodified lines | ||
| 366 | 366 | |
| 367 | 367 | dbg_gc("%d znodes to write", cnt); |
| 368 | 368 | |
| 369 | − c->gap_lebs = kmalloc(sizeof(int) * (c->lst.idx_lebs + 1), GFP_NOFS); | |
| 369 | + c->gap_lebs = kmalloc_array(c->lst.idx_lebs + 1, sizeof(int), | |
| 370 | + GFP_NOFS); | |
| 370 | 371 | if (!c->gap_lebs) |
| 371 | 372 | return -ENOMEM; |
| 372 | 373 | |
| @@ -674,7 +675,7 @@ static int alloc_idx_lebs(struct ubifs_info *c, int cnt) · 301 unmodified lines | ||
| 674 | 675 | dbg_cmt("need about %d empty LEBS for TNC commit", leb_cnt); |
| 675 | 676 | if (!leb_cnt) |
| 676 | 677 | return 0; |
| 677 | − c->ilebs = kmalloc(leb_cnt * sizeof(int), GFP_NOFS); | |
| 678 | + c->ilebs = kmalloc_array(leb_cnt, sizeof(int), GFP_NOFS); | |
| 678 | 679 | if (!c->ilebs) |
| 679 | 680 | return -ENOMEM; |
| 680 | 681 | for (i = 0; i < leb_cnt; i++) { |
| @@ -1585,7 +1585,7 @@ static struct udf_vds_record *handle_partition_descriptor( · 1584 unmodified lines | ||
| 1585 | 1585 | struct udf_vds_record *new_loc; |
| 1586 | 1586 | unsigned int new_size = ALIGN(partnum, PART_DESC_ALLOC_STEP); |
| 1587 | 1587 | |
| 1588 | − new_loc = kzalloc(sizeof(*new_loc) * new_size, GFP_KERNEL); | |
| 1588 | + new_loc = kcalloc(new_size, sizeof(*new_loc), GFP_KERNEL); | |
| 1589 | 1589 | if (!new_loc) |
| 1590 | 1590 | return ERR_PTR(-ENOMEM); |
| 1591 | 1591 | memcpy(new_loc, data->part_descs_loc, |
| @@ -1644,8 +1644,9 @@ static noinline int udf_process_sequence( · 52 unmodified lines | ||
| 1644 | 1644 | |
| 1645 | 1645 | memset(data.vds, 0, sizeof(struct udf_vds_record) * VDS_POS_LENGTH); |
| 1646 | 1646 | data.size_part_descs = PART_DESC_ALLOC_STEP; |
| 1647 | − data.part_descs_loc = kzalloc(sizeof(*data.part_descs_loc) * | |
| 1648 | − data.size_part_descs, GFP_KERNEL); | |
| 1647 | + data.part_descs_loc = kcalloc(data.size_part_descs, | |
| 1648 | + sizeof(*data.part_descs_loc), | |
| 1649 | + GFP_KERNEL); | |
| 1649 | 1650 | if (!data.part_descs_loc) |
| 1650 | 1651 | return -ENOMEM; |
| 1651 | 1652 | |
| @@ -541,7 +541,9 @@ static int ufs_read_cylinder_structures(struct super_block *sb) · 540 unmodified lines | ||
| 541 | 541 | * Read cylinder group (we read only first fragment from block |
| 542 | 542 | * at this time) and prepare internal data structures for cg caching. |
| 543 | 543 | */ |
| 544 | − if (!(sbi->s_ucg = kmalloc (sizeof(struct buffer_head *) * uspi->s_ncg, GFP_NOFS))) | |
| 544 | + sbi->s_ucg = kmalloc_array(uspi->s_ncg, sizeof(struct buffer_head *), | |
| 545 | + GFP_NOFS); | |
| 546 | + if (!sbi->s_ucg) | |
| 545 | 547 | goto failed; |
| 546 | 548 | for (i = 0; i < uspi->s_ncg; i++) |
| 547 | 549 | sbi->s_ucg[i] = NULL; |
| @@ -575,6 +575,11 @@ static inline void *kvmalloc_array(size_t n, size_t size, gfp_t flags) · 574 unmodified lines | ||
| 575 | 575 | return kvmalloc(bytes, flags); |
| 576 | 576 | } |
| 577 | 577 | |
| 578 | +static inline void *kvcalloc(size_t n, size_t size, gfp_t flags) | |
| 579 | +{ | |
| 580 | + return kvmalloc_array(n, size, flags | __GFP_ZERO); | |
| 581 | +} | |
| 582 | + | |
| 578 | 583 | extern void kvfree(const void *addr); |
| 579 | 584 | |
| 580 | 585 | static inline atomic_t *compound_mapcount_ptr(struct page *page) |
| @@ -2093,10 +2093,7 @@ struct ib_flow_attr { · 2092 unmodified lines | ||
| 2093 | 2093 | u32 flags; |
| 2094 | 2094 | u8 num_of_specs; |
| 2095 | 2095 | u8 port; |
| 2096 | − /* Following are the optional layers according to user request | |
| 2097 | − * struct ib_flow_spec_xxx | |
| 2098 | − * struct ib_flow_spec_yyy | |
| 2099 | − */ | |
| 2096 | + union ib_flow_spec flows[]; | |
| 2100 | 2097 | }; |
| 2101 | 2098 | |
| 2102 | 2099 | struct ib_flow { |
| @@ -1945,7 +1945,7 @@ static long do_semtimedop(int semid, struct sembuf __user *tsops, · 1944 unmodified lines | ||
| 1945 | 1945 | if (nsops > ns->sc_semopm) |
| 1946 | 1946 | return -E2BIG; |
| 1947 | 1947 | if (nsops > SEMOPM_FAST) { |
| 1948 | − sops = kvmalloc(sizeof(*sops)*nsops, GFP_KERNEL); | |
| 1948 | + sops = kvmalloc_array(nsops, sizeof(*sops), GFP_KERNEL); | |
| 1949 | 1949 | if (sops == NULL) |
| 1950 | 1950 | return -ENOMEM; |
| 1951 | 1951 | } |
| @@ -608,7 +608,7 @@ static int btf_add_type(struct btf_verifier_env *env, struct btf_type *t) · 607 unmodified lines | ||
| 608 | 608 | new_size = min_t(u32, BTF_MAX_TYPE, |
| 609 | 609 | btf->types_size + expand_by); |
| 610 | 610 | |
| 611 | − new_types = kvzalloc(new_size * sizeof(*new_types), | |
| 611 | + new_types = kvcalloc(new_size, sizeof(*new_types), | |
| 612 | 612 | GFP_KERNEL | __GFP_NOWARN); |
| 613 | 613 | if (!new_types) |
| 614 | 614 | return -ENOMEM; |
| @@ -698,17 +698,17 @@ static int env_resolve_init(struct btf_verifier_env *env) · 83 unmodified lines | ||
| 698 | 698 | u8 *visit_states = NULL; |
| 699 | 699 | |
| 700 | 700 | /* +1 for btf_void */ |
| 701 | − resolved_sizes = kvzalloc((nr_types + 1) * sizeof(*resolved_sizes), | |
| 701 | + resolved_sizes = kvcalloc(nr_types + 1, sizeof(*resolved_sizes), | |
| 702 | 702 | GFP_KERNEL | __GFP_NOWARN); |
| 703 | 703 | if (!resolved_sizes) |
| 704 | 704 | goto nomem; |
| 705 | 705 | |
| 706 | − resolved_ids = kvzalloc((nr_types + 1) * sizeof(*resolved_ids), | |
| 706 | + resolved_ids = kvcalloc(nr_types + 1, sizeof(*resolved_ids), | |
| 707 | 707 | GFP_KERNEL | __GFP_NOWARN); |
| 708 | 708 | if (!resolved_ids) |
| 709 | 709 | goto nomem; |
| 710 | 710 | |
| 711 | − visit_states = kvzalloc((nr_types + 1) * sizeof(*visit_states), | |
| 711 | + visit_states = kvcalloc(nr_types + 1, sizeof(*visit_states), | |
| 712 | 712 | GFP_KERNEL | __GFP_NOWARN); |
| 713 | 713 | if (!visit_states) |
| 714 | 714 | goto nomem; |
| @@ -623,8 +623,9 @@ static int trie_get_next_key(struct bpf_map *map, void *_key, void *_next_key) · 622 unmodified lines | ||
| 623 | 623 | if (!key || key->prefixlen > trie->max_prefixlen) |
| 624 | 624 | goto find_leftmost; |
| 625 | 625 | |
| 626 | − node_stack = kmalloc(trie->max_prefixlen * sizeof(struct lpm_trie_node *), | |
| 627 | − GFP_ATOMIC | __GFP_NOWARN); | |
| 626 | + node_stack = kmalloc_array(trie->max_prefixlen, | |
| 627 | + sizeof(struct lpm_trie_node *), | |
| 628 | + GFP_ATOMIC | __GFP_NOWARN); | |
| 628 | 629 | if (!node_stack) |
| 629 | 630 | return -ENOMEM; |
| 630 | 631 | |
| @@ -5206,7 +5206,8 @@ static int adjust_insn_aux_data(struct bpf_verifier_env *env, u32 prog_len, · 5205 unmodified lines | ||
| 5206 | 5206 | |
| 5207 | 5207 | if (cnt == 1) |
| 5208 | 5208 | return 0; |
| 5209 | − new_data = vzalloc(sizeof(struct bpf_insn_aux_data) * prog_len); | |
| 5209 | + new_data = vzalloc(array_size(prog_len, | |
| 5210 | + sizeof(struct bpf_insn_aux_data))); | |
| 5210 | 5211 | if (!new_data) |
| 5211 | 5212 | return -ENOMEM; |
| 5212 | 5213 | memcpy(new_data, old_data, sizeof(struct bpf_insn_aux_data) * off); |
| @@ -5447,7 +5448,7 @@ static int jit_subprogs(struct bpf_verifier_env *env) · 234 unmodified lines | ||
| 5447 | 5448 | insn->imm = 1; |
| 5448 | 5449 | } |
| 5449 | 5450 | |
| 5450 | − func = kzalloc(sizeof(prog) * env->subprog_cnt, GFP_KERNEL); | |
| 5451 | + func = kcalloc(env->subprog_cnt, sizeof(prog), GFP_KERNEL); | |
| 5451 | 5452 | if (!func) |
| 5452 | 5453 | return -ENOMEM; |
| 5453 | 5454 | |
| @@ -5870,8 +5871,9 @@ int bpf_check(struct bpf_prog **prog, union bpf_attr *attr) · 416 unmodified lines | ||
| 5870 | 5871 | return -ENOMEM; |
| 5871 | 5872 | log = &env->log; |
| 5872 | 5873 | |
| 5873 | − env->insn_aux_data = vzalloc(sizeof(struct bpf_insn_aux_data) * | |
| 5874 | − (*prog)->len); | |
| 5874 | + env->insn_aux_data = | |
| 5875 | + vzalloc(array_size(sizeof(struct bpf_insn_aux_data), | |
| 5876 | + (*prog)->len)); | |
| 5875 | 5877 | ret = -ENOMEM; |
| 5876 | 5878 | if (!env->insn_aux_data) |
| 5877 | 5879 | goto err_free_env; |
| @@ -195,9 +195,9 @@ struct cgroup_pidlist { · 194 unmodified lines | ||
| 195 | 195 | static void *pidlist_allocate(int count) |
| 196 | 196 | { |
| 197 | 197 | if (PIDLIST_TOO_LARGE(count)) |
| 198 | − return vmalloc(count * sizeof(pid_t)); | |
| 198 | + return vmalloc(array_size(count, sizeof(pid_t))); | |
| 199 | 199 | else |
| 200 | − return kmalloc(count * sizeof(pid_t), GFP_KERNEL); | |
| 200 | + return kmalloc_array(count, sizeof(pid_t), GFP_KERNEL); | |
| 201 | 201 | } |
| 202 | 202 | |
| 203 | 203 | static void pidlist_free(void *p) |
| @@ -683,7 +683,7 @@ static int generate_sched_domains(cpumask_var_t **domains, · 682 unmodified lines | ||
| 683 | 683 | goto done; |
| 684 | 684 | } |
| 685 | 685 | |
| 686 | − csa = kmalloc(nr_cpusets() * sizeof(cp), GFP_KERNEL); | |
| 686 | + csa = kmalloc_array(nr_cpusets(), sizeof(cp), GFP_KERNEL); | |
| 687 | 687 | if (!csa) |
| 688 | 688 | goto done; |
| 689 | 689 | csn = 0; |
| @@ -753,7 +753,8 @@ restart: · 63 unmodified lines | ||
| 753 | 753 | * The rest of the code, including the scheduler, can deal with |
| 754 | 754 | * dattr==NULL case. No need to abort if alloc fails. |
| 755 | 755 | */ |
| 756 | − dattr = kmalloc(ndoms * sizeof(struct sched_domain_attr), GFP_KERNEL); | |
| 756 | + dattr = kmalloc_array(ndoms, sizeof(struct sched_domain_attr), | |
| 757 | + GFP_KERNEL); | |
| 757 | 758 | |
| 758 | 759 | for (nslot = 0, i = 0; i < csn; i++) { |
| 759 | 760 | struct cpuset *a = csa[i]; |
| @@ -691,7 +691,7 @@ static int kdb_defcmd2(const char *cmdstr, const char *argv0) · 690 unmodified lines | ||
| 691 | 691 | } |
| 692 | 692 | if (!s->usable) |
| 693 | 693 | return KDB_NOTIMP; |
| 694 | − s->command = kzalloc((s->count + 1) * sizeof(*(s->command)), GFP_KDB); | |
| 694 | + s->command = kcalloc(s->count + 1, sizeof(*(s->command)), GFP_KDB); | |
| 695 | 695 | if (!s->command) { |
| 696 | 696 | kdb_printf("Could not allocate new kdb_defcmd table for %s\n", |
| 697 | 697 | cmdstr); |
| @@ -729,8 +729,8 @@ static int kdb_defcmd(int argc, const char **argv) · 31 unmodified lines | ||
| 729 | 729 | kdb_printf("Command only available during kdb_init()\n"); |
| 730 | 730 | return KDB_NOTIMP; |
| 731 | 731 | } |
| 732 | − defcmd_set = kmalloc((defcmd_set_count + 1) * sizeof(*defcmd_set), | |
| 733 | − GFP_KDB); | |
| 732 | + defcmd_set = kmalloc_array(defcmd_set_count + 1, sizeof(*defcmd_set), | |
| 733 | + GFP_KDB); | |
| 734 | 734 | if (!defcmd_set) |
| 735 | 735 | goto fail_defcmd; |
| 736 | 736 | memcpy(defcmd_set, save_defcmd_set, |
| @@ -2706,8 +2706,11 @@ int kdb_register_flags(char *cmd, · 1969 unmodified lines | ||
| 2706 | 2706 | } |
| 2707 | 2707 | |
| 2708 | 2708 | if (i >= kdb_max_commands) { |
| 2709 | − kdbtab_t *new = kmalloc((kdb_max_commands - KDB_BASE_CMD_MAX + | |
| 2710 | − kdb_command_extend) * sizeof(*new), GFP_KDB); | |
| 2709 | + kdbtab_t *new = kmalloc_array(kdb_max_commands - | |
| 2710 | + KDB_BASE_CMD_MAX + | |
| 2711 | + kdb_command_extend, | |
| 2712 | + sizeof(*new), | |
| 2713 | + GFP_KDB); | |
| 2711 | 2714 | if (!new) { |
| 2712 | 2715 | kdb_printf("Could not allocate new kdb_command " |
| 2713 | 2716 | "table\n"); |
| @@ -614,7 +614,8 @@ int rb_alloc_aux(struct ring_buffer *rb, struct perf_event *event, · 613 unmodified lines | ||
| 614 | 614 | } |
| 615 | 615 | } |
| 616 | 616 | |
| 617 | − rb->aux_pages = kzalloc_node(nr_pages * sizeof(void *), GFP_KERNEL, node); | |
| 617 | + rb->aux_pages = kcalloc_node(nr_pages, sizeof(void *), GFP_KERNEL, | |
| 618 | + node); | |
| 618 | 619 | if (!rb->aux_pages) |
| 619 | 620 | return -ENOMEM; |
| 620 | 621 | |
| @@ -1184,7 +1184,8 @@ static struct xol_area *__create_xol_area(unsigned long vaddr) · 1183 unmodified lines | ||
| 1184 | 1184 | if (unlikely(!area)) |
| 1185 | 1185 | goto out; |
| 1186 | 1186 | |
| 1187 | − area->bitmap = kzalloc(BITS_TO_LONGS(UINSNS_PER_PAGE) * sizeof(long), GFP_KERNEL); | |
| 1187 | + area->bitmap = kcalloc(BITS_TO_LONGS(UINSNS_PER_PAGE), sizeof(long), | |
| 1188 | + GFP_KERNEL); | |
| 1188 | 1189 | if (!area->bitmap) |
| 1189 | 1190 | goto free_area; |
| 1190 | 1191 | |
| @@ -258,7 +258,7 @@ static ssize_t fei_write(struct file *file, const char __user *buffer, · 257 unmodified lines | ||
| 258 | 258 | /* cut off if it is too long */ |
| 259 | 259 | if (count > KSYM_NAME_LEN) |
| 260 | 260 | count = KSYM_NAME_LEN; |
| 261 | − buf = kmalloc(sizeof(char) * (count + 1), GFP_KERNEL); | |
| 261 | + buf = kmalloc(count + 1, GFP_KERNEL); | |
| 262 | 262 | if (!buf) |
| 263 | 263 | return -ENOMEM; |
| 264 | 264 | |
| @@ -793,7 +793,7 @@ static int kexec_purgatory_setup_sechdrs(struct purgatory_info *pi, · 792 unmodified lines | ||
| 793 | 793 | * The section headers in kexec_purgatory are read-only. In order to |
| 794 | 794 | * have them modifiable make a temporary copy. |
| 795 | 795 | */ |
| 796 | − sechdrs = vzalloc(pi->ehdr->e_shnum * sizeof(Elf_Shdr)); | |
| 796 | + sechdrs = vzalloc(array_size(sizeof(Elf_Shdr), pi->ehdr->e_shnum)); | |
| 797 | 797 | if (!sechdrs) |
| 798 | 798 | return -ENOMEM; |
| 799 | 799 | memcpy(sechdrs, (void *)pi->ehdr + pi->ehdr->e_shoff, |
| @@ -913,7 +913,9 @@ static int __init lock_torture_init(void) · 912 unmodified lines | ||
| 913 | 913 | /* Initialize the statistics so that each run gets its own numbers. */ |
| 914 | 914 | if (nwriters_stress) { |
| 915 | 915 | lock_is_write_held = 0; |
| 916 | − cxt.lwsa = kmalloc(sizeof(*cxt.lwsa) * cxt.nrealwriters_stress, GFP_KERNEL); | |
| 916 | + cxt.lwsa = kmalloc_array(cxt.nrealwriters_stress, | |
| 917 | + sizeof(*cxt.lwsa), | |
| 918 | + GFP_KERNEL); | |
| 917 | 919 | if (cxt.lwsa == NULL) { |
| 918 | 920 | VERBOSE_TOROUT_STRING("cxt.lwsa: Out of memory"); |
| 919 | 921 | firsterr = -ENOMEM; |
| @@ -942,7 +944,9 @@ static int __init lock_torture_init(void) · 22 unmodified lines | ||
| 942 | 944 | |
| 943 | 945 | if (nreaders_stress) { |
| 944 | 946 | lock_is_read_held = 0; |
| 945 | − cxt.lrsa = kmalloc(sizeof(*cxt.lrsa) * cxt.nrealreaders_stress, GFP_KERNEL); | |
| 947 | + cxt.lrsa = kmalloc_array(cxt.nrealreaders_stress, | |
| 948 | + sizeof(*cxt.lrsa), | |
| 949 | + GFP_KERNEL); | |
| 946 | 950 | if (cxt.lrsa == NULL) { |
| 947 | 951 | VERBOSE_TOROUT_STRING("cxt.lrsa: Out of memory"); |
| 948 | 952 | firsterr = -ENOMEM; |
| @@ -985,7 +989,8 @@ static int __init lock_torture_init(void) · 36 unmodified lines | ||
| 985 | 989 | } |
| 986 | 990 | |
| 987 | 991 | if (nwriters_stress) { |
| 988 | − writer_tasks = kzalloc(cxt.nrealwriters_stress * sizeof(writer_tasks[0]), | |
| 992 | + writer_tasks = kcalloc(cxt.nrealwriters_stress, | |
| 993 | + sizeof(writer_tasks[0]), | |
| 989 | 994 | GFP_KERNEL); |
| 990 | 995 | if (writer_tasks == NULL) { |
| 991 | 996 | VERBOSE_TOROUT_ERRSTRING("writer_tasks: Out of memory"); |
| @@ -995,7 +1000,8 @@ static int __init lock_torture_init(void) · 3 unmodified lines | ||
| 995 | 1000 | } |
| 996 | 1001 | |
| 997 | 1002 | if (cxt.cur_ops->readlock) { |
| 998 | − reader_tasks = kzalloc(cxt.nrealreaders_stress * sizeof(reader_tasks[0]), | |
| 1003 | + reader_tasks = kcalloc(cxt.nrealreaders_stress, | |
| 1004 | + sizeof(reader_tasks[0]), | |
| 999 | 1005 | GFP_KERNEL); |
| 1000 | 1006 | if (reader_tasks == NULL) { |
| 1001 | 1007 | VERBOSE_TOROUT_ERRSTRING("reader_tasks: Out of memory"); |
| @@ -698,7 +698,7 @@ static int save_image_lzo(struct swap_map_handle *handle, · 697 unmodified lines | ||
| 698 | 698 | goto out_clean; |
| 699 | 699 | } |
| 700 | 700 | |
| 701 | − data = vmalloc(sizeof(*data) * nr_threads); | |
| 701 | + data = vmalloc(array_size(nr_threads, sizeof(*data))); | |
| 702 | 702 | if (!data) { |
| 703 | 703 | pr_err("Failed to allocate LZO data\n"); |
| 704 | 704 | ret = -ENOMEM; |
| @@ -1183,14 +1183,14 @@ static int load_image_lzo(struct swap_map_handle *handle, · 478 unmodified lines | ||
| 1183 | 1183 | nr_threads = num_online_cpus() - 1; |
| 1184 | 1184 | nr_threads = clamp_val(nr_threads, 1, LZO_THREADS); |
| 1185 | 1185 | |
| 1186 | − page = vmalloc(sizeof(*page) * LZO_MAX_RD_PAGES); | |
| 1186 | + page = vmalloc(array_size(LZO_MAX_RD_PAGES, sizeof(*page))); | |
| 1187 | 1187 | if (!page) { |
| 1188 | 1188 | pr_err("Failed to allocate LZO page\n"); |
| 1189 | 1189 | ret = -ENOMEM; |
| 1190 | 1190 | goto out_clean; |
| 1191 | 1191 | } |
| 1192 | 1192 | |
| 1193 | − data = vmalloc(sizeof(*data) * nr_threads); | |
| 1193 | + data = vmalloc(array_size(nr_threads, sizeof(*data))); | |
| 1194 | 1194 | if (!data) { |
| 1195 | 1195 | pr_err("Failed to allocate LZO data\n"); |
| 1196 | 1196 | ret = -ENOMEM; |
| @@ -831,8 +831,9 @@ rcu_torture_cbflood(void *arg) · 830 unmodified lines | ||
| 831 | 831 | cbflood_intra_holdoff > 0 && |
| 832 | 832 | cur_ops->call && |
| 833 | 833 | cur_ops->cb_barrier) { |
| 834 | − rhp = vmalloc(sizeof(*rhp) * | |
| 835 | − cbflood_n_burst * cbflood_n_per_burst); | |
| 834 | + rhp = vmalloc(array3_size(cbflood_n_burst, | |
| 835 | + cbflood_n_per_burst, | |
| 836 | + sizeof(*rhp))); | |
| 836 | 837 | err = !rhp; |
| 837 | 838 | } |
| 838 | 839 | if (err) { |
| @@ -169,7 +169,8 @@ static struct rchan_buf *relay_create_buf(struct rchan *chan) · 168 unmodified lines | ||
| 169 | 169 | buf = kzalloc(sizeof(struct rchan_buf), GFP_KERNEL); |
| 170 | 170 | if (!buf) |
| 171 | 171 | return NULL; |
| 172 | − buf->padding = kmalloc(chan->n_subbufs * sizeof(size_t *), GFP_KERNEL); | |
| 172 | + buf->padding = kmalloc_array(chan->n_subbufs, sizeof(size_t *), | |
| 173 | + GFP_KERNEL); | |
| 173 | 174 | if (!buf->padding) |
| 174 | 175 | goto free_buf; |
| 175 | 176 | |
| @@ -10215,10 +10215,10 @@ int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent) · 10214 unmodified lines | ||
| 10215 | 10215 | struct cfs_rq *cfs_rq; |
| 10216 | 10216 | int i; |
| 10217 | 10217 | |
| 10218 | − tg->cfs_rq = kzalloc(sizeof(cfs_rq) * nr_cpu_ids, GFP_KERNEL); | |
| 10218 | + tg->cfs_rq = kcalloc(nr_cpu_ids, sizeof(cfs_rq), GFP_KERNEL); | |
| 10219 | 10219 | if (!tg->cfs_rq) |
| 10220 | 10220 | goto err; |
| 10221 | − tg->se = kzalloc(sizeof(se) * nr_cpu_ids, GFP_KERNEL); | |
| 10221 | + tg->se = kcalloc(nr_cpu_ids, sizeof(se), GFP_KERNEL); | |
| 10222 | 10222 | if (!tg->se) |
| 10223 | 10223 | goto err; |
| 10224 | 10224 | |
| @@ -183,10 +183,10 @@ int alloc_rt_sched_group(struct task_group *tg, struct task_group *parent) · 182 unmodified lines | ||
| 183 | 183 | struct sched_rt_entity *rt_se; |
| 184 | 184 | int i; |
| 185 | 185 | |
| 186 | − tg->rt_rq = kzalloc(sizeof(rt_rq) * nr_cpu_ids, GFP_KERNEL); | |
| 186 | + tg->rt_rq = kcalloc(nr_cpu_ids, sizeof(rt_rq), GFP_KERNEL); | |
| 187 | 187 | if (!tg->rt_rq) |
| 188 | 188 | goto err; |
| 189 | − tg->rt_se = kzalloc(sizeof(rt_se) * nr_cpu_ids, GFP_KERNEL); | |
| 189 | + tg->rt_se = kcalloc(nr_cpu_ids, sizeof(rt_se), GFP_KERNEL); | |
| 190 | 190 | if (!tg->rt_se) |
| 191 | 191 | goto err; |
| 192 | 192 | |
| @@ -1750,7 +1750,7 @@ cpumask_var_t *alloc_sched_domains(unsigned int ndoms) · 1749 unmodified lines | ||
| 1750 | 1750 | int i; |
| 1751 | 1751 | cpumask_var_t *doms; |
| 1752 | 1752 | |
| 1753 | − doms = kmalloc(sizeof(*doms) * ndoms, GFP_KERNEL); | |
| 1753 | + doms = kmalloc_array(ndoms, sizeof(*doms), GFP_KERNEL); | |
| 1754 | 1754 | if (!doms) |
| 1755 | 1755 | return NULL; |
| 1756 | 1756 | for (i = 0; i < ndoms; i++) { |
| @@ -3047,7 +3047,8 @@ int proc_do_large_bitmap(struct ctl_table *table, int write, · 3046 unmodified lines | ||
| 3047 | 3047 | if (IS_ERR(kbuf)) |
| 3048 | 3048 | return PTR_ERR(kbuf); |
| 3049 | 3049 | |
| 3050 | − tmp_bitmap = kzalloc(BITS_TO_LONGS(bitmap_len) * sizeof(unsigned long), | |
| 3050 | + tmp_bitmap = kcalloc(BITS_TO_LONGS(bitmap_len), | |
| 3051 | + sizeof(unsigned long), | |
| 3051 | 3052 | GFP_KERNEL); |
| 3052 | 3053 | if (!tmp_bitmap) { |
| 3053 | 3054 | kfree(kbuf); |
| @@ -728,7 +728,7 @@ static int ftrace_profile_init_cpu(int cpu) · 727 unmodified lines | ||
| 728 | 728 | */ |
| 729 | 729 | size = FTRACE_PROFILE_HASH_SIZE; |
| 730 | 730 | |
| 731 | − stat->hash = kzalloc(sizeof(struct hlist_head) * size, GFP_KERNEL); | |
| 731 | + stat->hash = kcalloc(size, sizeof(struct hlist_head), GFP_KERNEL); | |
| 732 | 732 | |
| 733 | 733 | if (!stat->hash) |
| 734 | 734 | return -ENOMEM; |
| @@ -6830,9 +6830,10 @@ static int alloc_retstack_tasklist(struct ftrace_ret_stack **ret_stack_list) · 6095 unmodified lines | ||
| 6830 | 6830 | struct task_struct *g, *t; |
| 6831 | 6831 | |
| 6832 | 6832 | for (i = 0; i < FTRACE_RETSTACK_ALLOC_SIZE; i++) { |
| 6833 | − ret_stack_list[i] = kmalloc(FTRACE_RETFUNC_DEPTH | |
| 6834 | − * sizeof(struct ftrace_ret_stack), | |
| 6835 | − GFP_KERNEL); | |
| 6833 | + ret_stack_list[i] = | |
| 6834 | + kmalloc_array(FTRACE_RETFUNC_DEPTH, | |
| 6835 | + sizeof(struct ftrace_ret_stack), | |
| 6836 | + GFP_KERNEL); | |
| 6836 | 6837 | if (!ret_stack_list[i]) { |
| 6837 | 6838 | start = 0; |
| 6838 | 6839 | end = i; |
| @@ -6904,9 +6905,9 @@ static int start_graph_tracing(void) · 65 unmodified lines | ||
| 6904 | 6905 | struct ftrace_ret_stack **ret_stack_list; |
| 6905 | 6906 | int ret, cpu; |
| 6906 | 6907 | |
| 6907 | − ret_stack_list = kmalloc(FTRACE_RETSTACK_ALLOC_SIZE * | |
| 6908 | − sizeof(struct ftrace_ret_stack *), | |
| 6909 | − GFP_KERNEL); | |
| 6908 | + ret_stack_list = kmalloc_array(FTRACE_RETSTACK_ALLOC_SIZE, | |
| 6909 | + sizeof(struct ftrace_ret_stack *), | |
| 6910 | + GFP_KERNEL); | |
| 6910 | 6911 | |
| 6911 | 6912 | if (!ret_stack_list) |
| 6912 | 6913 | return -ENOMEM; |
| @@ -7088,9 +7089,10 @@ void ftrace_graph_init_idle_task(struct task_struct *t, int cpu) · 175 unmodified lines | ||
| 7088 | 7089 | |
| 7089 | 7090 | ret_stack = per_cpu(idle_ret_stack, cpu); |
| 7090 | 7091 | if (!ret_stack) { |
| 7091 | − ret_stack = kmalloc(FTRACE_RETFUNC_DEPTH | |
| 7092 | − * sizeof(struct ftrace_ret_stack), | |
| 7093 | − GFP_KERNEL); | |
| 7092 | + ret_stack = | |
| 7093 | + kmalloc_array(FTRACE_RETFUNC_DEPTH, | |
| 7094 | + sizeof(struct ftrace_ret_stack), | |
| 7095 | + GFP_KERNEL); | |
| 7094 | 7096 | if (!ret_stack) |
| 7095 | 7097 | return; |
| 7096 | 7098 | per_cpu(idle_ret_stack, cpu) = ret_stack; |
| @@ -7109,9 +7111,9 @@ void ftrace_graph_init_task(struct task_struct *t) · 12 unmodified lines | ||
| 7109 | 7111 | if (ftrace_graph_active) { |
| 7110 | 7112 | struct ftrace_ret_stack *ret_stack; |
| 7111 | 7113 | |
| 7112 | − ret_stack = kmalloc(FTRACE_RETFUNC_DEPTH | |
| 7113 | − * sizeof(struct ftrace_ret_stack), | |
| 7114 | − GFP_KERNEL); | |
| 7114 | + ret_stack = kmalloc_array(FTRACE_RETFUNC_DEPTH, | |
| 7115 | + sizeof(struct ftrace_ret_stack), | |
| 7116 | + GFP_KERNEL); | |
| 7115 | 7117 | if (!ret_stack) |
| 7116 | 7118 | return; |
| 7117 | 7119 | graph_init_task(t, ret_stack); |
| @@ -1751,12 +1751,13 @@ static inline void set_cmdline(int idx, const char *cmdline) · 1750 unmodified lines | ||
| 1751 | 1751 | static int allocate_cmdlines_buffer(unsigned int val, |
| 1752 | 1752 | struct saved_cmdlines_buffer *s) |
| 1753 | 1753 | { |
| 1754 | − s->map_cmdline_to_pid = kmalloc(val * sizeof(*s->map_cmdline_to_pid), | |
| 1755 | − GFP_KERNEL); | |
| 1754 | + s->map_cmdline_to_pid = kmalloc_array(val, | |
| 1755 | + sizeof(*s->map_cmdline_to_pid), | |
| 1756 | + GFP_KERNEL); | |
| 1756 | 1757 | if (!s->map_cmdline_to_pid) |
| 1757 | 1758 | return -ENOMEM; |
| 1758 | 1759 | |
| 1759 | − s->saved_cmdlines = kmalloc(val * TASK_COMM_LEN, GFP_KERNEL); | |
| 1760 | + s->saved_cmdlines = kmalloc_array(TASK_COMM_LEN, val, GFP_KERNEL); | |
| 1760 | 1761 | if (!s->saved_cmdlines) { |
| 1761 | 1762 | kfree(s->map_cmdline_to_pid); |
| 1762 | 1763 | return -ENOMEM; |
| @@ -4360,7 +4361,8 @@ int set_tracer_flag(struct trace_array *tr, unsigned int mask, int enabled) · 2597 unmodified lines | ||
| 4360 | 4361 | |
| 4361 | 4362 | if (mask == TRACE_ITER_RECORD_TGID) { |
| 4362 | 4363 | if (!tgid_map) |
| 4363 | − tgid_map = kzalloc((PID_MAX_DEFAULT + 1) * sizeof(*tgid_map), | |
| 4364 | + tgid_map = kcalloc(PID_MAX_DEFAULT + 1, | |
| 4365 | + sizeof(*tgid_map), | |
| 4364 | 4366 | GFP_KERNEL); |
| 4365 | 4367 | if (!tgid_map) { |
| 4366 | 4368 | tr->trace_flags &= ~TRACE_ITER_RECORD_TGID; |
| @@ -5063,7 +5065,7 @@ trace_insert_eval_map_file(struct module *mod, struct trace_eval_map **start, · 696 unmodified lines | ||
| 5063 | 5065 | * where the head holds the module and length of array, and the |
| 5064 | 5066 | * tail holds a pointer to the next list. |
| 5065 | 5067 | */ |
| 5066 | − map_array = kmalloc(sizeof(*map_array) * (len + 2), GFP_KERNEL); | |
| 5068 | + map_array = kmalloc_array(len + 2, sizeof(*map_array), GFP_KERNEL); | |
| 5067 | 5069 | if (!map_array) { |
| 5068 | 5070 | pr_warn("Unable to allocate trace eval mapping\n"); |
| 5069 | 5071 | return; |
| @@ -436,15 +436,15 @@ predicate_parse(const char *str, int nr_parens, int nr_preds, · 435 unmodified lines | ||
| 436 | 436 | |
| 437 | 437 | nr_preds += 2; /* For TRUE and FALSE */ |
| 438 | 438 | |
| 439 | − op_stack = kmalloc(sizeof(*op_stack) * nr_parens, GFP_KERNEL); | |
| 439 | + op_stack = kmalloc_array(nr_parens, sizeof(*op_stack), GFP_KERNEL); | |
| 440 | 440 | if (!op_stack) |
| 441 | 441 | return ERR_PTR(-ENOMEM); |
| 442 | − prog_stack = kmalloc(sizeof(*prog_stack) * nr_preds, GFP_KERNEL); | |
| 442 | + prog_stack = kmalloc_array(nr_preds, sizeof(*prog_stack), GFP_KERNEL); | |
| 443 | 443 | if (!prog_stack) { |
| 444 | 444 | parse_error(pe, -ENOMEM, 0); |
| 445 | 445 | goto out_free; |
| 446 | 446 | } |
| 447 | − inverts = kmalloc(sizeof(*inverts) * nr_preds, GFP_KERNEL); | |
| 447 | + inverts = kmalloc_array(nr_preds, sizeof(*inverts), GFP_KERNEL); | |
| 448 | 448 | if (!inverts) { |
| 449 | 449 | parse_error(pe, -ENOMEM, 0); |
| 450 | 450 | goto out_free; |
| @@ -1075,7 +1075,7 @@ int tracing_map_sort_entries(struct tracing_map *map, · 1074 unmodified lines | ||
| 1075 | 1075 | struct tracing_map_sort_entry *sort_entry, **entries; |
| 1076 | 1076 | int i, n_entries, ret; |
| 1077 | 1077 | |
| 1078 | − entries = vmalloc(map->max_elts * sizeof(sort_entry)); | |
| 1078 | + entries = vmalloc(array_size(sizeof(sort_entry), map->max_elts)); | |
| 1079 | 1079 | if (!entries) |
| 1080 | 1080 | return -ENOMEM; |
| 1081 | 1081 | |
| @@ -764,8 +764,9 @@ static int insert_extent(struct uid_gid_map *map, struct uid_gid_extent *extent) · 763 unmodified lines | ||
| 764 | 764 | struct uid_gid_extent *forward; |
| 765 | 765 | |
| 766 | 766 | /* Allocate memory for 340 mappings. */ |
| 767 | − forward = kmalloc(sizeof(struct uid_gid_extent) * | |
| 768 | − UID_GID_MAP_MAX_EXTENTS, GFP_KERNEL); | |
| 767 | + forward = kmalloc_array(UID_GID_MAP_MAX_EXTENTS, | |
| 768 | + sizeof(struct uid_gid_extent), | |
| 769 | + GFP_KERNEL); | |
| 769 | 770 | if (!forward) |
| 770 | 771 | return -ENOMEM; |
| 771 | 772 | |
| @@ -5638,7 +5638,7 @@ static void __init wq_numa_init(void) · 5637 unmodified lines | ||
| 5638 | 5638 | * available. Build one from cpu_to_node() which should have been |
| 5639 | 5639 | * fully initialized by now. |
| 5640 | 5640 | */ |
| 5641 | − tbl = kzalloc(nr_node_ids * sizeof(tbl[0]), GFP_KERNEL); | |
| 5641 | + tbl = kcalloc(nr_node_ids, sizeof(tbl[0]), GFP_KERNEL); | |
| 5642 | 5642 | BUG_ON(!tbl); |
| 5643 | 5643 | |
| 5644 | 5644 | for_each_node(node) |
| @@ -69,7 +69,7 @@ char **argv_split(gfp_t gfp, const char *str, int *argcp) · 68 unmodified lines | ||
| 69 | 69 | return NULL; |
| 70 | 70 | |
| 71 | 71 | argc = count_argc(argv_str); |
| 72 | − argv = kmalloc(sizeof(*argv) * (argc + 2), gfp); | |
| 72 | + argv = kmalloc_array(argc + 2, sizeof(*argv), gfp); | |
| 73 | 73 | if (!argv) { |
| 74 | 74 | kfree(argv_str); |
| 75 | 75 | return NULL; |
| @@ -64,11 +64,12 @@ static int interval_tree_test_init(void) · 63 unmodified lines | ||
| 64 | 64 | unsigned long results; |
| 65 | 65 | cycles_t time1, time2, time; |
| 66 | 66 | |
| 67 | − nodes = kmalloc(nnodes * sizeof(struct interval_tree_node), GFP_KERNEL); | |
| 67 | + nodes = kmalloc_array(nnodes, sizeof(struct interval_tree_node), | |
| 68 | + GFP_KERNEL); | |
| 68 | 69 | if (!nodes) |
| 69 | 70 | return -ENOMEM; |
| 70 | 71 | |
| 71 | − queries = kmalloc(nsearches * sizeof(int), GFP_KERNEL); | |
| 72 | + queries = kmalloc_array(nsearches, sizeof(int), GFP_KERNEL); | |
| 72 | 73 | if (!queries) { |
| 73 | 74 | kfree(nodes); |
| 74 | 75 | return -ENOMEM; |
| @@ -54,7 +54,7 @@ int __kfifo_alloc(struct __kfifo *fifo, unsigned int size, · 53 unmodified lines | ||
| 54 | 54 | return -EINVAL; |
| 55 | 55 | } |
| 56 | 56 | |
| 57 | − fifo->data = kmalloc(size * esize, gfp_mask); | |
| 57 | + fifo->data = kmalloc_array(esize, size, gfp_mask); | |
| 58 | 58 | |
| 59 | 59 | if (!fifo->data) { |
| 60 | 60 | fifo->mask = 0; |
| @@ -119,7 +119,7 @@ struct lru_cache *lc_create(const char *name, struct kmem_cache *cache, · 118 unmodified lines | ||
| 119 | 119 | slot = kcalloc(e_count, sizeof(struct hlist_head), GFP_KERNEL); |
| 120 | 120 | if (!slot) |
| 121 | 121 | goto out_fail; |
| 122 | − element = kzalloc(e_count * sizeof(struct lc_element *), GFP_KERNEL); | |
| 122 | + element = kcalloc(e_count, sizeof(struct lc_element *), GFP_KERNEL); | |
| 123 | 123 | if (!element) |
| 124 | 124 | goto out_fail; |
| 125 | 125 | |
| @@ -91,14 +91,14 @@ int mpi_resize(MPI a, unsigned nlimbs) · 90 unmodified lines | ||
| 91 | 91 | return 0; /* no need to do it */ |
| 92 | 92 | |
| 93 | 93 | if (a->d) { |
| 94 | − p = kmalloc(nlimbs * sizeof(mpi_limb_t), GFP_KERNEL); | |
| 94 | + p = kmalloc_array(nlimbs, sizeof(mpi_limb_t), GFP_KERNEL); | |
| 95 | 95 | if (!p) |
| 96 | 96 | return -ENOMEM; |
| 97 | 97 | memcpy(p, a->d, a->alloced * sizeof(mpi_limb_t)); |
| 98 | 98 | kzfree(a->d); |
| 99 | 99 | a->d = p; |
| 100 | 100 | } else { |
| 101 | − a->d = kzalloc(nlimbs * sizeof(mpi_limb_t), GFP_KERNEL); | |
| 101 | + a->d = kcalloc(nlimbs, sizeof(mpi_limb_t), GFP_KERNEL); | |
| 102 | 102 | if (!a->d) |
| 103 | 103 | return -ENOMEM; |
| 104 | 104 | } |
| @@ -247,7 +247,7 @@ static int __init rbtree_test_init(void) · 246 unmodified lines | ||
| 247 | 247 | cycles_t time1, time2, time; |
| 248 | 248 | struct rb_node *node; |
| 249 | 249 | |
| 250 | − nodes = kmalloc(nnodes * sizeof(*nodes), GFP_KERNEL); | |
| 250 | + nodes = kmalloc_array(nnodes, sizeof(*nodes), GFP_KERNEL); | |
| 251 | 251 | if (!nodes) |
| 252 | 252 | return -ENOMEM; |
| 253 | 253 | |
| @@ -88,15 +88,15 @@ static struct rs_codec *codec_init(int symsize, int gfpoly, int (*gffunc)(int), · 87 unmodified lines | ||
| 88 | 88 | rs->gffunc = gffunc; |
| 89 | 89 | |
| 90 | 90 | /* Allocate the arrays */ |
| 91 | − rs->alpha_to = kmalloc(sizeof(uint16_t) * (rs->nn + 1), gfp); | |
| 91 | + rs->alpha_to = kmalloc_array(rs->nn + 1, sizeof(uint16_t), gfp); | |
| 92 | 92 | if (rs->alpha_to == NULL) |
| 93 | 93 | goto err; |
| 94 | 94 | |
| 95 | − rs->index_of = kmalloc(sizeof(uint16_t) * (rs->nn + 1), gfp); | |
| 95 | + rs->index_of = kmalloc_array(rs->nn + 1, sizeof(uint16_t), gfp); | |
| 96 | 96 | if (rs->index_of == NULL) |
| 97 | 97 | goto err; |
| 98 | 98 | |
| 99 | − rs->genpoly = kmalloc(sizeof(uint16_t) * (rs->nroots + 1), gfp); | |
| 99 | + rs->genpoly = kmalloc_array(rs->nroots + 1, sizeof(uint16_t), gfp); | |
| 100 | 100 | if(rs->genpoly == NULL) |
| 101 | 101 | goto err; |
| 102 | 102 | |
| @@ -52,7 +52,7 @@ int sbitmap_init_node(struct sbitmap *sb, unsigned int depth, int shift, · 51 unmodified lines | ||
| 52 | 52 | return 0; |
| 53 | 53 | } |
| 54 | 54 | |
| 55 | − sb->map = kzalloc_node(sb->map_nr * sizeof(*sb->map), flags, node); | |
| 55 | + sb->map = kcalloc_node(sb->map_nr, sizeof(*sb->map), flags, node); | |
| 56 | 56 | if (!sb->map) |
| 57 | 57 | return -ENOMEM; |
| 58 | 58 | |
| @@ -170,7 +170,8 @@ static struct scatterlist *sg_kmalloc(unsigned int nents, gfp_t gfp_mask) · 169 unmodified lines | ||
| 170 | 170 | kmemleak_alloc(ptr, PAGE_SIZE, 1, gfp_mask); |
| 171 | 171 | return ptr; |
| 172 | 172 | } else |
| 173 | − return kmalloc(nents * sizeof(struct scatterlist), gfp_mask); | |
| 173 | + return kmalloc_array(nents, sizeof(struct scatterlist), | |
| 174 | + gfp_mask); | |
| 174 | 175 | } |
| 175 | 176 | |
| 176 | 177 | static void sg_kfree(struct scatterlist *sg, unsigned int nents) |
| @@ -618,8 +618,9 @@ static ssize_t trigger_batched_requests_store(struct device *dev, · 617 unmodified lines | ||
| 618 | 618 | |
| 619 | 619 | mutex_lock(&test_fw_mutex); |
| 620 | 620 | |
| 621 | − test_fw_config->reqs = vzalloc(sizeof(struct test_batched_req) * | |
| 622 | − test_fw_config->num_requests * 2); | |
| 621 | + test_fw_config->reqs = | |
| 622 | + vzalloc(array3_size(sizeof(struct test_batched_req), | |
| 623 | + test_fw_config->num_requests, 2)); | |
| 623 | 624 | if (!test_fw_config->reqs) { |
| 624 | 625 | rc = -ENOMEM; |
| 625 | 626 | goto out_unlock; |
| @@ -720,8 +721,9 @@ ssize_t trigger_batched_requests_async_store(struct device *dev, · 94 unmodified lines | ||
| 720 | 721 | |
| 721 | 722 | mutex_lock(&test_fw_mutex); |
| 722 | 723 | |
| 723 | − test_fw_config->reqs = vzalloc(sizeof(struct test_batched_req) * | |
| 724 | − test_fw_config->num_requests * 2); | |
| 724 | + test_fw_config->reqs = | |
| 725 | + vzalloc(array3_size(sizeof(struct test_batched_req), | |
| 726 | + test_fw_config->num_requests, 2)); | |
| 725 | 727 | if (!test_fw_config->reqs) { |
| 726 | 728 | rc = -ENOMEM; |
| 727 | 729 | goto out; |
| @@ -779,8 +779,9 @@ static int kmod_config_sync_info(struct kmod_test_device *test_dev) · 778 unmodified lines | ||
| 779 | 779 | struct test_config *config = &test_dev->config; |
| 780 | 780 | |
| 781 | 781 | free_test_dev_info(test_dev); |
| 782 | − test_dev->info = vzalloc(config->num_threads * | |
| 783 | − sizeof(struct kmod_test_device_info)); | |
| 782 | + test_dev->info = | |
| 783 | + vzalloc(array_size(sizeof(struct kmod_test_device_info), | |
| 784 | + config->num_threads)); | |
| 784 | 785 | if (!test_dev->info) |
| 785 | 786 | return -ENOMEM; |
| 786 | 787 | |
| @@ -367,7 +367,7 @@ static int __init test_overflow_allocation(void) · 366 unmodified lines | ||
| 367 | 367 | |
| 368 | 368 | /* Create dummy device for devm_kmalloc()-family tests. */ |
| 369 | 369 | dev = root_device_register(device_name); |
| 370 | − if (!dev) { | |
| 370 | + if (IS_ERR(dev)) { | |
| 371 | 371 | pr_warn("Cannot register test device\n"); |
| 372 | 372 | return 1; |
| 373 | 373 | } |
| @@ -285,12 +285,14 @@ static int __init test_rhltable(unsigned int entries) · 284 unmodified lines | ||
| 285 | 285 | if (entries == 0) |
| 286 | 286 | entries = 1; |
| 287 | 287 | |
| 288 | − rhl_test_objects = vzalloc(sizeof(*rhl_test_objects) * entries); | |
| 288 | + rhl_test_objects = vzalloc(array_size(entries, | |
| 289 | + sizeof(*rhl_test_objects))); | |
| 289 | 290 | if (!rhl_test_objects) |
| 290 | 291 | return -ENOMEM; |
| 291 | 292 | |
| 292 | 293 | ret = -ENOMEM; |
| 293 | − obj_in_table = vzalloc(BITS_TO_LONGS(entries) * sizeof(unsigned long)); | |
| 294 | + obj_in_table = vzalloc(array_size(sizeof(unsigned long), | |
| 295 | + BITS_TO_LONGS(entries))); | |
| 294 | 296 | if (!obj_in_table) |
| 295 | 297 | goto out_free; |
| 296 | 298 | |
| @@ -706,7 +708,8 @@ static int __init test_rht_init(void) · 409 unmodified lines | ||
| 706 | 708 | test_rht_params.max_size = max_size ? : roundup_pow_of_two(entries); |
| 707 | 709 | test_rht_params.nelem_hint = size; |
| 708 | 710 | |
| 709 | − objs = vzalloc((test_rht_params.max_size + 1) * sizeof(struct test_obj)); | |
| 711 | + objs = vzalloc(array_size(sizeof(struct test_obj), | |
| 712 | + test_rht_params.max_size + 1)); | |
| 710 | 713 | if (!objs) |
| 711 | 714 | return -ENOMEM; |
| 712 | 715 | |
| @@ -753,10 +756,10 @@ static int __init test_rht_init(void) · 40 unmodified lines | ||
| 753 | 756 | pr_info("Testing concurrent rhashtable access from %d threads\n", |
| 754 | 757 | tcount); |
| 755 | 758 | sema_init(&prestart_sem, 1 - tcount); |
| 756 | − tdata = vzalloc(tcount * sizeof(struct thread_data)); | |
| 759 | + tdata = vzalloc(array_size(tcount, sizeof(struct thread_data))); | |
| 757 | 760 | if (!tdata) |
| 758 | 761 | return -ENOMEM; |
| 759 | − objs = vzalloc(tcount * entries * sizeof(struct test_obj)); | |
| 762 | + objs = vzalloc(array3_size(sizeof(struct test_obj), tcount, entries)); | |
| 760 | 763 | if (!objs) { |
| 761 | 764 | vfree(tdata); |
| 762 | 765 | return -ENOMEM; |
| @@ -23,7 +23,7 @@ static int __gup_benchmark_ioctl(unsigned int cmd, · 22 unmodified lines | ||
| 23 | 23 | struct page **pages; |
| 24 | 24 | |
| 25 | 25 | nr_pages = gup->size / PAGE_SIZE; |
| 26 | − pages = kvzalloc(sizeof(void *) * nr_pages, GFP_KERNEL); | |
| 26 | + pages = kvcalloc(nr_pages, sizeof(void *), GFP_KERNEL); | |
| 27 | 27 | if (!pages) |
| 28 | 28 | return -ENOMEM; |
| 29 | 29 | |
| @@ -1131,8 +1131,8 @@ static int do_huge_pmd_wp_page_fallback(struct vm_fault *vmf, pmd_t orig_pmd, · 1130 unmodified lines | ||
| 1131 | 1131 | unsigned long mmun_start; /* For mmu_notifiers */ |
| 1132 | 1132 | unsigned long mmun_end; /* For mmu_notifiers */ |
| 1133 | 1133 | |
| 1134 | − pages = kmalloc(sizeof(struct page *) * HPAGE_PMD_NR, | |
| 1135 | − GFP_KERNEL); | |
| 1134 | + pages = kmalloc_array(HPAGE_PMD_NR, sizeof(struct page *), | |
| 1135 | + GFP_KERNEL); | |
| 1136 | 1136 | if (unlikely(!pages)) { |
| 1137 | 1137 | ret |= VM_FAULT_OOM; |
| 1138 | 1138 | goto out; |
| @@ -2798,7 +2798,8 @@ static int __init hugetlb_init(void) · 2797 unmodified lines | ||
| 2798 | 2798 | num_fault_mutexes = 1; |
| 2799 | 2799 | #endif |
| 2800 | 2800 | hugetlb_fault_mutex_table = |
| 2801 | − kmalloc(sizeof(struct mutex) * num_fault_mutexes, GFP_KERNEL); | |
| 2801 | + kmalloc_array(num_fault_mutexes, sizeof(struct mutex), | |
| 2802 | + GFP_KERNEL); | |
| 2802 | 2803 | BUG_ON(!hugetlb_fault_mutex_table); |
| 2803 | 2804 | |
| 2804 | 2805 | for (i = 0; i < num_fault_mutexes; i++) |
| @@ -144,7 +144,7 @@ alloc_buffer: · 143 unmodified lines | ||
| 144 | 144 | spin_unlock_irq(&pcpu_lock); |
| 145 | 145 | |
| 146 | 146 | /* there can be at most this many free and allocated fragments */ |
| 147 | − buffer = vmalloc((2 * max_nr_alloc + 1) * sizeof(int)); | |
| 147 | + buffer = vmalloc(array_size(sizeof(int), (2 * max_nr_alloc + 1))); | |
| 148 | 148 | if (!buffer) |
| 149 | 149 | return -ENOMEM; |
| 150 | 150 | |
| @@ -4338,7 +4338,8 @@ static int leaks_show(struct seq_file *m, void *p) · 4337 unmodified lines | ||
| 4338 | 4338 | if (x[0] == x[1]) { |
| 4339 | 4339 | /* Increase the buffer size */ |
| 4340 | 4340 | mutex_unlock(&slab_mutex); |
| 4341 | − m->private = kzalloc(x[0] * 4 * sizeof(unsigned long), GFP_KERNEL); | |
| 4341 | + m->private = kcalloc(x[0] * 4, sizeof(unsigned long), | |
| 4342 | + GFP_KERNEL); | |
| 4342 | 4343 | if (!m->private) { |
| 4343 | 4344 | /* Too bad, we are really out */ |
| 4344 | 4345 | m->private = x; |
| @@ -3623,8 +3623,9 @@ static void list_slab_objects(struct kmem_cache *s, struct page *page, · 3622 unmodified lines | ||
| 3623 | 3623 | #ifdef CONFIG_SLUB_DEBUG |
| 3624 | 3624 | void *addr = page_address(page); |
| 3625 | 3625 | void *p; |
| 3626 | − unsigned long *map = kzalloc(BITS_TO_LONGS(page->objects) * | |
| 3627 | − sizeof(long), GFP_ATOMIC); | |
| 3626 | + unsigned long *map = kcalloc(BITS_TO_LONGS(page->objects), | |
| 3627 | + sizeof(long), | |
| 3628 | + GFP_ATOMIC); | |
| 3628 | 3629 | if (!map) |
| 3629 | 3630 | return; |
| 3630 | 3631 | slab_err(s, page, text, s->name); |
| @@ -4412,8 +4413,9 @@ static long validate_slab_cache(struct kmem_cache *s) · 781 unmodified lines | ||
| 4412 | 4413 | { |
| 4413 | 4414 | int node; |
| 4414 | 4415 | unsigned long count = 0; |
| 4415 | − unsigned long *map = kmalloc(BITS_TO_LONGS(oo_objects(s->max)) * | |
| 4416 | − sizeof(unsigned long), GFP_KERNEL); | |
| 4416 | + unsigned long *map = kmalloc_array(BITS_TO_LONGS(oo_objects(s->max)), | |
| 4417 | + sizeof(unsigned long), | |
| 4418 | + GFP_KERNEL); | |
| 4417 | 4419 | struct kmem_cache_node *n; |
| 4418 | 4420 | |
| 4419 | 4421 | if (!map) |
| @@ -4573,8 +4575,9 @@ static int list_locations(struct kmem_cache *s, char *buf, · 153 unmodified lines | ||
| 4573 | 4575 | unsigned long i; |
| 4574 | 4576 | struct loc_track t = { 0, 0, NULL }; |
| 4575 | 4577 | int node; |
| 4576 | − unsigned long *map = kmalloc(BITS_TO_LONGS(oo_objects(s->max)) * | |
| 4577 | − sizeof(unsigned long), GFP_KERNEL); | |
| 4578 | + unsigned long *map = kmalloc_array(BITS_TO_LONGS(oo_objects(s->max)), | |
| 4579 | + sizeof(unsigned long), | |
| 4580 | + GFP_KERNEL); | |
| 4578 | 4581 | struct kmem_cache_node *n; |
| 4579 | 4582 | |
| 4580 | 4583 | if (!map || !alloc_loc_track(&t, PAGE_SIZE / sizeof(struct location), |
| @@ -4750,7 +4753,7 @@ static ssize_t show_slab_objects(struct kmem_cache *s, · 169 unmodified lines | ||
| 4750 | 4753 | int x; |
| 4751 | 4754 | unsigned long *nodes; |
| 4752 | 4755 | |
| 4753 | − nodes = kzalloc(sizeof(unsigned long) * nr_node_ids, GFP_KERNEL); | |
| 4756 | + nodes = kcalloc(nr_node_ids, sizeof(unsigned long), GFP_KERNEL); | |
| 4754 | 4757 | if (!nodes) |
| 4755 | 4758 | return -ENOMEM; |
| 4756 | 4759 | |
| @@ -5293,7 +5296,7 @@ static int show_stat(struct kmem_cache *s, char *buf, enum stat_item si) · 536 unmodified lines | ||
| 5293 | 5296 | unsigned long sum = 0; |
| 5294 | 5297 | int cpu; |
| 5295 | 5298 | int len; |
| 5296 | − int *data = kmalloc(nr_cpu_ids * sizeof(int), GFP_KERNEL); | |
| 5299 | + int *data = kmalloc_array(nr_cpu_ids, sizeof(int), GFP_KERNEL); | |
| 5297 | 5300 | |
| 5298 | 5301 | if (!data) |
| 5299 | 5302 | return -ENOMEM; |
| @@ -122,12 +122,12 @@ static int alloc_swap_slot_cache(unsigned int cpu) · 121 unmodified lines | ||
| 122 | 122 | * as kvzalloc could trigger reclaim and get_swap_page, |
| 123 | 123 | * which can lock swap_slots_cache_mutex. |
| 124 | 124 | */ |
| 125 | − slots = kvzalloc(sizeof(swp_entry_t) * SWAP_SLOTS_CACHE_SIZE, | |
| 125 | + slots = kvcalloc(SWAP_SLOTS_CACHE_SIZE, sizeof(swp_entry_t), | |
| 126 | 126 | GFP_KERNEL); |
| 127 | 127 | if (!slots) |
| 128 | 128 | return -ENOMEM; |
| 129 | 129 | |
| 130 | − slots_ret = kvzalloc(sizeof(swp_entry_t) * SWAP_SLOTS_CACHE_SIZE, | |
| 130 | + slots_ret = kvcalloc(SWAP_SLOTS_CACHE_SIZE, sizeof(swp_entry_t), | |
| 131 | 131 | GFP_KERNEL); |
| 132 | 132 | if (!slots_ret) { |
| 133 | 133 | kvfree(slots); |
| @@ -620,7 +620,7 @@ int init_swap_address_space(unsigned int type, unsigned long nr_pages) · 619 unmodified lines | ||
| 620 | 620 | unsigned int i, nr; |
| 621 | 621 | |
| 622 | 622 | nr = DIV_ROUND_UP(nr_pages, SWAP_ADDRESS_SPACE_PAGES); |
| 623 | − spaces = kvzalloc(sizeof(struct address_space) * nr, GFP_KERNEL); | |
| 623 | + spaces = kvcalloc(nr, sizeof(struct address_space), GFP_KERNEL); | |
| 624 | 624 | if (!spaces) |
| 625 | 625 | return -ENOMEM; |
| 626 | 626 | for (i = 0; i < nr; i++) { |
| @@ -3196,7 +3196,7 @@ SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags) · 3195 unmodified lines | ||
| 3196 | 3196 | p->cluster_next = 1 + (prandom_u32() % p->highest_bit); |
| 3197 | 3197 | nr_cluster = DIV_ROUND_UP(maxpages, SWAPFILE_CLUSTER); |
| 3198 | 3198 | |
| 3199 | − cluster_info = kvzalloc(nr_cluster * sizeof(*cluster_info), | |
| 3199 | + cluster_info = kvcalloc(nr_cluster, sizeof(*cluster_info), | |
| 3200 | 3200 | GFP_KERNEL); |
| 3201 | 3201 | if (!cluster_info) { |
| 3202 | 3202 | error = -ENOMEM; |
| @@ -3233,7 +3233,8 @@ SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags) · 30 unmodified lines | ||
| 3233 | 3233 | } |
| 3234 | 3234 | /* frontswap enabled? set up bit-per-page map for frontswap */ |
| 3235 | 3235 | if (IS_ENABLED(CONFIG_FRONTSWAP)) |
| 3236 | − frontswap_map = kvzalloc(BITS_TO_LONGS(maxpages) * sizeof(long), | |
| 3236 | + frontswap_map = kvcalloc(BITS_TO_LONGS(maxpages), | |
| 3237 | + sizeof(long), | |
| 3237 | 3238 | GFP_KERNEL); |
| 3238 | 3239 | |
| 3239 | 3240 | if (p->bdev &&(swap_flags & SWAP_FLAG_DISCARD) && swap_discardable(p)) { |
| @@ -242,8 +242,9 @@ p9pdu_vreadf(struct p9_fcall *pdu, int proto_version, const char *fmt, · 241 unmodified lines | ||
| 242 | 242 | "w", nwname); |
| 243 | 243 | if (!errcode) { |
| 244 | 244 | *wnames = |
| 245 | − kmalloc(sizeof(char *) * *nwname, | |
| 246 | − GFP_NOFS); | |
| 245 | + kmalloc_array(*nwname, | |
| 246 | + sizeof(char *), | |
| 247 | + GFP_NOFS); | |
| 247 | 248 | if (!*wnames) |
| 248 | 249 | errcode = -ENOMEM; |
| 249 | 250 | } |
| @@ -285,9 +286,9 @@ p9pdu_vreadf(struct p9_fcall *pdu, int proto_version, const char *fmt, · 35 unmodified lines | ||
| 285 | 286 | p9pdu_readf(pdu, proto_version, "w", nwqid); |
| 286 | 287 | if (!errcode) { |
| 287 | 288 | *wqids = |
| 288 | − kmalloc(*nwqid * | |
| 289 | − sizeof(struct p9_qid), | |
| 290 | − GFP_NOFS); | |
| 289 | + kmalloc_array(*nwqid, | |
| 290 | + sizeof(struct p9_qid), | |
| 291 | + GFP_NOFS); | |
| 291 | 292 | if (*wqids == NULL) |
| 292 | 293 | errcode = -ENOMEM; |
| 293 | 294 | } |
| @@ -360,7 +360,8 @@ static int p9_get_mapped_pages(struct virtio_chan *chan, · 359 unmodified lines | ||
| 360 | 360 | nr_pages = DIV_ROUND_UP((unsigned long)p + len, PAGE_SIZE) - |
| 361 | 361 | (unsigned long)p / PAGE_SIZE; |
| 362 | 362 | |
| 363 | − *pages = kmalloc(sizeof(struct page *) * nr_pages, GFP_NOFS); | |
| 363 | + *pages = kmalloc_array(nr_pages, sizeof(struct page *), | |
| 364 | + GFP_NOFS); | |
| 364 | 365 | if (!*pages) |
| 365 | 366 | return -ENOMEM; |
| 366 | 367 | |
| @@ -472,7 +472,7 @@ static const uint8_t *copy_macs(struct mpoa_client *mpc, · 471 unmodified lines | ||
| 472 | 472 | if (mpc->number_of_mps_macs != 0) |
| 473 | 473 | kfree(mpc->mps_macs); |
| 474 | 474 | mpc->number_of_mps_macs = 0; |
| 475 | − mpc->mps_macs = kmalloc(num_macs * ETH_ALEN, GFP_KERNEL); | |
| 475 | + mpc->mps_macs = kmalloc_array(ETH_ALEN, num_macs, GFP_KERNEL); | |
| 476 | 476 | if (mpc->mps_macs == NULL) { |
| 477 | 477 | pr_info("(%s) out of mem\n", mpc->dev->name); |
| 478 | 478 | return NULL; |
| @@ -1281,7 +1281,7 @@ int hci_inquiry(void __user *arg) · 1280 unmodified lines | ||
| 1281 | 1281 | /* cache_dump can't sleep. Therefore we allocate temp buffer and then |
| 1282 | 1282 | * copy it to the user space. |
| 1283 | 1283 | */ |
| 1284 | − buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL); | |
| 1284 | + buf = kmalloc_array(max_rsp, sizeof(struct inquiry_info), GFP_KERNEL); | |
| 1285 | 1285 | if (!buf) { |
| 1286 | 1286 | err = -ENOMEM; |
| 1287 | 1287 | goto done; |
| @@ -331,7 +331,7 @@ static int l2cap_seq_list_init(struct l2cap_seq_list *seq_list, u16 size) · 330 unmodified lines | ||
| 331 | 331 | */ |
| 332 | 332 | alloc_size = roundup_pow_of_two(size); |
| 333 | 333 | |
| 334 | − seq_list->list = kmalloc(sizeof(u16) * alloc_size, GFP_KERNEL); | |
| 334 | + seq_list->list = kmalloc_array(alloc_size, sizeof(u16), GFP_KERNEL); | |
| 335 | 335 | if (!seq_list->list) |
| 336 | 336 | return -ENOMEM; |
| 337 | 337 | |
| @@ -333,7 +333,7 @@ static int br_mdb_rehash(struct net_bridge_mdb_htable __rcu **mdbp, int max, · 332 unmodified lines | ||
| 333 | 333 | mdb->max = max; |
| 334 | 334 | mdb->old = old; |
| 335 | 335 | |
| 336 | − mdb->mhash = kzalloc(max * sizeof(*mdb->mhash), GFP_ATOMIC); | |
| 336 | + mdb->mhash = kcalloc(max, sizeof(*mdb->mhash), GFP_ATOMIC); | |
| 337 | 337 | if (!mdb->mhash) { |
| 338 | 338 | kfree(mdb); |
| 339 | 339 | return -ENOMEM; |
| @@ -903,12 +903,13 @@ static int translate_table(struct net *net, const char *name, · 902 unmodified lines | ||
| 903 | 903 | * if an error occurs |
| 904 | 904 | */ |
| 905 | 905 | newinfo->chainstack = |
| 906 | − vmalloc(nr_cpu_ids * sizeof(*(newinfo->chainstack))); | |
| 906 | + vmalloc(array_size(nr_cpu_ids, | |
| 907 | + sizeof(*(newinfo->chainstack)))); | |
| 907 | 908 | if (!newinfo->chainstack) |
| 908 | 909 | return -ENOMEM; |
| 909 | 910 | for_each_possible_cpu(i) { |
| 910 | 911 | newinfo->chainstack[i] = |
| 911 | − vmalloc(udc_cnt * sizeof(*(newinfo->chainstack[0]))); | |
| 912 | + vmalloc(array_size(udc_cnt, sizeof(*(newinfo->chainstack[0])))); | |
| 912 | 913 | if (!newinfo->chainstack[i]) { |
| 913 | 914 | while (i) |
| 914 | 915 | vfree(newinfo->chainstack[--i]); |
| @@ -918,7 +919,7 @@ static int translate_table(struct net *net, const char *name, · 3 unmodified lines | ||
| 918 | 919 | } |
| 919 | 920 | } |
| 920 | 921 | |
| 921 | − cl_s = vmalloc(udc_cnt * sizeof(*cl_s)); | |
| 922 | + cl_s = vmalloc(array_size(udc_cnt, sizeof(*cl_s))); | |
| 922 | 923 | if (!cl_s) |
| 923 | 924 | return -ENOMEM; |
| 924 | 925 | i = 0; /* the i'th udc */ |
| @@ -1293,7 +1294,7 @@ static int do_update_counters(struct net *net, const char *name, · 368 unmodified lines | ||
| 1293 | 1294 | if (num_counters == 0) |
| 1294 | 1295 | return -EINVAL; |
| 1295 | 1296 | |
| 1296 | − tmp = vmalloc(num_counters * sizeof(*tmp)); | |
| 1297 | + tmp = vmalloc(array_size(num_counters, sizeof(*tmp))); | |
| 1297 | 1298 | if (!tmp) |
| 1298 | 1299 | return -ENOMEM; |
| 1299 | 1300 | |
| @@ -1434,7 +1435,7 @@ static int copy_counters_to_user(struct ebt_table *t, · 134 unmodified lines | ||
| 1434 | 1435 | return -EINVAL; |
| 1435 | 1436 | } |
| 1436 | 1437 | |
| 1437 | − counterstmp = vmalloc(nentries * sizeof(*counterstmp)); | |
| 1438 | + counterstmp = vmalloc(array_size(nentries, sizeof(*counterstmp))); | |
| 1438 | 1439 | if (!counterstmp) |
| 1439 | 1440 | return -ENOMEM; |
| 1440 | 1441 | |
| @@ -923,8 +923,9 @@ static int bcm_tx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg, · 922 unmodified lines | ||
| 923 | 923 | |
| 924 | 924 | /* create array for CAN frames and copy the data */ |
| 925 | 925 | if (msg_head->nframes > 1) { |
| 926 | − op->frames = kmalloc(msg_head->nframes * op->cfsiz, | |
| 927 | − GFP_KERNEL); | |
| 926 | + op->frames = kmalloc_array(msg_head->nframes, | |
| 927 | + op->cfsiz, | |
| 928 | + GFP_KERNEL); | |
| 928 | 929 | if (!op->frames) { |
| 929 | 930 | kfree(op); |
| 930 | 931 | return -ENOMEM; |
| @@ -1095,15 +1096,17 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg, · 164 unmodified lines | ||
| 1095 | 1096 | |
| 1096 | 1097 | if (msg_head->nframes > 1) { |
| 1097 | 1098 | /* create array for CAN frames and copy the data */ |
| 1098 | − op->frames = kmalloc(msg_head->nframes * op->cfsiz, | |
| 1099 | − GFP_KERNEL); | |
| 1099 | + op->frames = kmalloc_array(msg_head->nframes, | |
| 1100 | + op->cfsiz, | |
| 1101 | + GFP_KERNEL); | |
| 1100 | 1102 | if (!op->frames) { |
| 1101 | 1103 | kfree(op); |
| 1102 | 1104 | return -ENOMEM; |
| 1103 | 1105 | } |
| 1104 | 1106 | |
| 1105 | 1107 | /* create and init array for received CAN frames */ |
| 1106 | − op->last_frames = kzalloc(msg_head->nframes * op->cfsiz, | |
| 1108 | + op->last_frames = kcalloc(msg_head->nframes, | |
| 1109 | + op->cfsiz, | |
| 1107 | 1110 | GFP_KERNEL); |
| 1108 | 1111 | if (!op->last_frames) { |
| 1109 | 1112 | kfree(op->frames); |
| @@ -1299,8 +1299,9 @@ static int set_primary_affinity(struct ceph_osdmap *map, int osd, u32 aff) · 1298 unmodified lines | ||
| 1299 | 1299 | if (!map->osd_primary_affinity) { |
| 1300 | 1300 | int i; |
| 1301 | 1301 | |
| 1302 | − map->osd_primary_affinity = kmalloc(map->max_osd*sizeof(u32), | |
| 1303 | − GFP_NOFS); | |
| 1302 | + map->osd_primary_affinity = kmalloc_array(map->max_osd, | |
| 1303 | + sizeof(u32), | |
| 1304 | + GFP_NOFS); | |
| 1304 | 1305 | if (!map->osd_primary_affinity) |
| 1305 | 1306 | return -ENOMEM; |
| 1306 | 1307 | |
| @@ -20,7 +20,7 @@ struct page **ceph_get_direct_page_vector(const void __user *data, · 19 unmodified lines | ||
| 20 | 20 | int got = 0; |
| 21 | 21 | int rc = 0; |
| 22 | 22 | |
| 23 | − pages = kmalloc(sizeof(*pages) * num_pages, GFP_NOFS); | |
| 23 | + pages = kmalloc_array(num_pages, sizeof(*pages), GFP_NOFS); | |
| 24 | 24 | if (!pages) |
| 25 | 25 | return ERR_PTR(-ENOMEM); |
| 26 | 26 | |
| @@ -74,7 +74,7 @@ struct page **ceph_alloc_page_vector(int num_pages, gfp_t flags) · 47 unmodified lines | ||
| 74 | 74 | struct page **pages; |
| 75 | 75 | int i; |
| 76 | 76 | |
| 77 | − pages = kmalloc(sizeof(*pages) * num_pages, flags); | |
| 77 | + pages = kmalloc_array(num_pages, sizeof(*pages), flags); | |
| 78 | 78 | if (!pages) |
| 79 | 79 | return ERR_PTR(-ENOMEM); |
| 80 | 80 | for (i = 0; i < num_pages; i++) { |
| @@ -8823,7 +8823,7 @@ static struct hlist_head * __net_init netdev_create_hash(void) · 8822 unmodified lines | ||
| 8823 | 8823 | int i; |
| 8824 | 8824 | struct hlist_head *hash; |
| 8825 | 8825 | |
| 8826 | − hash = kmalloc(sizeof(*hash) * NETDEV_HASHENTRIES, GFP_KERNEL); | |
| 8826 | + hash = kmalloc_array(NETDEV_HASHENTRIES, sizeof(*hash), GFP_KERNEL); | |
| 8827 | 8827 | if (hash != NULL) |
| 8828 | 8828 | for (i = 0; i < NETDEV_HASHENTRIES; i++) |
| 8829 | 8829 | INIT_HLIST_HEAD(&hash[i]); |
| @@ -911,7 +911,7 @@ static noinline_for_stack int ethtool_get_sset_info(struct net_device *dev, · 910 unmodified lines | ||
| 911 | 911 | memset(&info, 0, sizeof(info)); |
| 912 | 912 | info.cmd = ETHTOOL_GSSET_INFO; |
| 913 | 913 | |
| 914 | − info_buf = kzalloc(n_bits * sizeof(u32), GFP_USER); | |
| 914 | + info_buf = kcalloc(n_bits, sizeof(u32), GFP_USER); | |
| 915 | 915 | if (!info_buf) |
| 916 | 916 | return -ENOMEM; |
| 917 | 917 | |
| @@ -1017,7 +1017,7 @@ static noinline_for_stack int ethtool_get_rxnfc(struct net_device *dev, · 99 unmodified lines | ||
| 1017 | 1017 | if (info.cmd == ETHTOOL_GRXCLSRLALL) { |
| 1018 | 1018 | if (info.rule_cnt > 0) { |
| 1019 | 1019 | if (info.rule_cnt <= KMALLOC_MAX_SIZE / sizeof(u32)) |
| 1020 | − rule_buf = kzalloc(info.rule_cnt * sizeof(u32), | |
| 1020 | + rule_buf = kcalloc(info.rule_cnt, sizeof(u32), | |
| 1021 | 1021 | GFP_USER); |
| 1022 | 1022 | if (!rule_buf) |
| 1023 | 1023 | return -ENOMEM; |
| @@ -1816,7 +1816,7 @@ static int ethtool_self_test(struct net_device *dev, char __user *useraddr) · 792 unmodified lines | ||
| 1816 | 1816 | return -EFAULT; |
| 1817 | 1817 | |
| 1818 | 1818 | test.len = test_len; |
| 1819 | − data = kmalloc(test_len * sizeof(u64), GFP_USER); | |
| 1819 | + data = kmalloc_array(test_len, sizeof(u64), GFP_USER); | |
| 1820 | 1820 | if (!data) |
| 1821 | 1821 | return -ENOMEM; |
| 1822 | 1822 | |
| @@ -1852,7 +1852,7 @@ static int ethtool_get_strings(struct net_device *dev, void __user *useraddr) · 29 unmodified lines | ||
| 1852 | 1852 | WARN_ON_ONCE(!ret); |
| 1853 | 1853 | |
| 1854 | 1854 | gstrings.len = ret; |
| 1855 | − data = vzalloc(gstrings.len * ETH_GSTRING_LEN); | |
| 1855 | + data = vzalloc(array_size(gstrings.len, ETH_GSTRING_LEN)); | |
| 1856 | 1856 | if (gstrings.len && !data) |
| 1857 | 1857 | return -ENOMEM; |
| 1858 | 1858 | |
| @@ -1952,7 +1952,7 @@ static int ethtool_get_stats(struct net_device *dev, void __user *useraddr) · 93 unmodified lines | ||
| 1952 | 1952 | return -EFAULT; |
| 1953 | 1953 | |
| 1954 | 1954 | stats.n_stats = n_stats; |
| 1955 | − data = vzalloc(n_stats * sizeof(u64)); | |
| 1955 | + data = vzalloc(array_size(n_stats, sizeof(u64))); | |
| 1956 | 1956 | if (n_stats && !data) |
| 1957 | 1957 | return -ENOMEM; |
| 1958 | 1958 | |
| @@ -1996,7 +1996,7 @@ static int ethtool_get_phy_stats(struct net_device *dev, void __user *useraddr) · 37 unmodified lines | ||
| 1996 | 1996 | return -EFAULT; |
| 1997 | 1997 | |
| 1998 | 1998 | stats.n_stats = n_stats; |
| 1999 | − data = vzalloc(n_stats * sizeof(u64)); | |
| 1999 | + data = vzalloc(array_size(n_stats, sizeof(u64))); | |
| 2000 | 2000 | if (n_stats && !data) |
| 2001 | 2001 | return -ENOMEM; |
| 2002 | 2002 | |
| @@ -3603,7 +3603,8 @@ static int pktgen_add_device(struct pktgen_thread *t, const char *ifname) · 3602 unmodified lines | ||
| 3603 | 3603 | return -ENOMEM; |
| 3604 | 3604 | |
| 3605 | 3605 | strcpy(pkt_dev->odevname, ifname); |
| 3606 | − pkt_dev->flows = vzalloc_node(MAX_CFLOWS * sizeof(struct flow_state), | |
| 3606 | + pkt_dev->flows = vzalloc_node(array_size(MAX_CFLOWS, | |
| 3607 | + sizeof(struct flow_state)), | |
| 3607 | 3608 | node); |
| 3608 | 3609 | if (pkt_dev->flows == NULL) { |
| 3609 | 3610 | kfree(pkt_dev); |
| @@ -984,7 +984,8 @@ static int dcbnl_build_peer_app(struct net_device *netdev, struct sk_buff* skb, · 983 unmodified lines | ||
| 984 | 984 | */ |
| 985 | 985 | err = ops->peer_getappinfo(netdev, &info, &app_count); |
| 986 | 986 | if (!err && app_count) { |
| 987 | − table = kmalloc(sizeof(struct dcb_app) * app_count, GFP_KERNEL); | |
| 987 | + table = kmalloc_array(app_count, sizeof(struct dcb_app), | |
| 988 | + GFP_KERNEL); | |
| 988 | 989 | if (!table) |
| 989 | 990 | return -ENOMEM; |
| 990 | 991 | |
| @@ -46,7 +46,8 @@ static int ccid2_hc_tx_alloc_seq(struct ccid2_hc_tx_sock *hc) · 45 unmodified lines | ||
| 46 | 46 | return -ENOMEM; |
| 47 | 47 | |
| 48 | 48 | /* allocate buffer and initialize linked list */ |
| 49 | − seqp = kmalloc(CCID2_SEQBUF_LEN * sizeof(struct ccid2_seq), gfp_any()); | |
| 49 | + seqp = kmalloc_array(CCID2_SEQBUF_LEN, sizeof(struct ccid2_seq), | |
| 50 | + gfp_any()); | |
| 50 | 51 | if (seqp == NULL) |
| 51 | 52 | return -ENOMEM; |
| 52 | 53 | |
| @@ -38,7 +38,7 @@ static int ieee802154_nl_fill_phy(struct sk_buff *msg, u32 portid, · 37 unmodified lines | ||
| 38 | 38 | { |
| 39 | 39 | void *hdr; |
| 40 | 40 | int i, pages = 0; |
| 41 | − uint32_t *buf = kzalloc(32 * sizeof(uint32_t), GFP_KERNEL); | |
| 41 | + uint32_t *buf = kcalloc(32, sizeof(uint32_t), GFP_KERNEL); | |
| 42 | 42 | |
| 43 | 43 | pr_debug("%s\n", __func__); |
| 44 | 44 | |
| @@ -567,7 +567,7 @@ static int rtentry_to_fib_config(struct net *net, int cmd, struct rtentry *rt, · 566 unmodified lines | ||
| 567 | 567 | struct nlattr *mx; |
| 568 | 568 | int len = 0; |
| 569 | 569 | |
| 570 | − mx = kzalloc(3 * nla_total_size(4), GFP_KERNEL); | |
| 570 | + mx = kcalloc(3, nla_total_size(4), GFP_KERNEL); | |
| 571 | 571 | if (!mx) |
| 572 | 572 | return -ENOMEM; |
| 573 | 573 | |
| @@ -649,7 +649,7 @@ static void update_or_create_fnhe(struct fib_nh *nh, __be32 daddr, __be32 gw, · 648 unmodified lines | ||
| 649 | 649 | |
| 650 | 650 | hash = rcu_dereference(nh->nh_exceptions); |
| 651 | 651 | if (!hash) { |
| 652 | − hash = kzalloc(FNHE_HASH_SIZE * sizeof(*hash), GFP_ATOMIC); | |
| 652 | + hash = kcalloc(FNHE_HASH_SIZE, sizeof(*hash), GFP_ATOMIC); | |
| 653 | 653 | if (!hash) |
| 654 | 654 | goto out_unlock; |
| 655 | 655 | rcu_assign_pointer(nh->nh_exceptions, hash); |
| @@ -3146,7 +3146,8 @@ int __init ip_rt_init(void) · 2490 unmodified lines | ||
| 3146 | 3146 | { |
| 3147 | 3147 | int cpu; |
| 3148 | 3148 | |
| 3149 | − ip_idents = kmalloc(IP_IDENTS_SZ * sizeof(*ip_idents), GFP_KERNEL); | |
| 3149 | + ip_idents = kmalloc_array(IP_IDENTS_SZ, sizeof(*ip_idents), | |
| 3150 | + GFP_KERNEL); | |
| 3150 | 3151 | if (!ip_idents) |
| 3151 | 3152 | panic("IP: failed to allocate ip_idents\n"); |
| 3152 | 3153 | |
| @@ -956,7 +956,7 @@ static int __net_init icmpv6_sk_init(struct net *net) · 955 unmodified lines | ||
| 956 | 956 | int err, i, j; |
| 957 | 957 | |
| 958 | 958 | net->ipv6.icmp_sk = |
| 959 | − kzalloc(nr_cpu_ids * sizeof(struct sock *), GFP_KERNEL); | |
| 959 | + kcalloc(nr_cpu_ids, sizeof(struct sock *), GFP_KERNEL); | |
| 960 | 960 | if (!net->ipv6.icmp_sk) |
| 961 | 961 | return -ENOMEM; |
| 962 | 962 | |
| @@ -42,7 +42,8 @@ static int alloc_ila_locks(struct ila_net *ilan) · 41 unmodified lines | ||
| 42 | 42 | size = roundup_pow_of_two(nr_pcpus * LOCKS_PER_CPU); |
| 43 | 43 | |
| 44 | 44 | if (sizeof(spinlock_t) != 0) { |
| 45 | − ilan->locks = kvmalloc(size * sizeof(spinlock_t), GFP_KERNEL); | |
| 45 | + ilan->locks = kvmalloc_array(size, sizeof(spinlock_t), | |
| 46 | + GFP_KERNEL); | |
| 46 | 47 | if (!ilan->locks) |
| 47 | 48 | return -ENOMEM; |
| 48 | 49 | for (i = 0; i < size; i++) |
| @@ -1186,7 +1186,7 @@ static int ieee80211_chsw_switch_vifs(struct ieee80211_local *local, · 1185 unmodified lines | ||
| 1186 | 1186 | lockdep_assert_held(&local->mtx); |
| 1187 | 1187 | lockdep_assert_held(&local->chanctx_mtx); |
| 1188 | 1188 | |
| 1189 | − vif_chsw = kzalloc(sizeof(vif_chsw[0]) * n_vifs, GFP_KERNEL); | |
| 1189 | + vif_chsw = kcalloc(n_vifs, sizeof(vif_chsw[0]), GFP_KERNEL); | |
| 1190 | 1190 | if (!vif_chsw) |
| 1191 | 1191 | return -ENOMEM; |
| 1192 | 1192 | |
| @@ -772,7 +772,7 @@ static int ieee80211_init_cipher_suites(struct ieee80211_local *local) · 771 unmodified lines | ||
| 772 | 772 | if (have_mfp) |
| 773 | 773 | n_suites += 4; |
| 774 | 774 | |
| 775 | − suites = kmalloc(sizeof(u32) * n_suites, GFP_KERNEL); | |
| 775 | + suites = kmalloc_array(n_suites, sizeof(u32), GFP_KERNEL); | |
| 776 | 776 | if (!suites) |
| 777 | 777 | return -ENOMEM; |
| 778 | 778 | |
| @@ -592,11 +592,11 @@ minstrel_alloc_sta(void *priv, struct ieee80211_sta *sta, gfp_t gfp) · 591 unmodified lines | ||
| 592 | 592 | max_rates = sband->n_bitrates; |
| 593 | 593 | } |
| 594 | 594 | |
| 595 | − mi->r = kzalloc(sizeof(struct minstrel_rate) * max_rates, gfp); | |
| 595 | + mi->r = kcalloc(max_rates, sizeof(struct minstrel_rate), gfp); | |
| 596 | 596 | if (!mi->r) |
| 597 | 597 | goto error; |
| 598 | 598 | |
| 599 | − mi->sample_table = kmalloc(SAMPLE_COLUMNS * max_rates, gfp); | |
| 599 | + mi->sample_table = kmalloc_array(max_rates, SAMPLE_COLUMNS, gfp); | |
| 600 | 600 | if (!mi->sample_table) |
| 601 | 601 | goto error1; |
| 602 | 602 | |
| @@ -1313,11 +1313,11 @@ minstrel_ht_alloc_sta(void *priv, struct ieee80211_sta *sta, gfp_t gfp) · 1312 unmodified lines | ||
| 1313 | 1313 | if (!msp) |
| 1314 | 1314 | return NULL; |
| 1315 | 1315 | |
| 1316 | − msp->ratelist = kzalloc(sizeof(struct minstrel_rate) * max_rates, gfp); | |
| 1316 | + msp->ratelist = kcalloc(max_rates, sizeof(struct minstrel_rate), gfp); | |
| 1317 | 1317 | if (!msp->ratelist) |
| 1318 | 1318 | goto error; |
| 1319 | 1319 | |
| 1320 | − msp->sample_table = kmalloc(SAMPLE_COLUMNS * max_rates, gfp); | |
| 1320 | + msp->sample_table = kmalloc_array(max_rates, SAMPLE_COLUMNS, gfp); | |
| 1321 | 1321 | if (!msp->sample_table) |
| 1322 | 1322 | goto error1; |
| 1323 | 1323 | |
| @@ -1157,7 +1157,7 @@ int __ieee80211_request_sched_scan_start(struct ieee80211_sub_if_data *sdata, · 1156 unmodified lines | ||
| 1157 | 1157 | } |
| 1158 | 1158 | } |
| 1159 | 1159 | |
| 1160 | − ie = kzalloc(num_bands * iebufsz, GFP_KERNEL); | |
| 1160 | + ie = kcalloc(iebufsz, num_bands, GFP_KERNEL); | |
| 1161 | 1161 | if (!ie) { |
| 1162 | 1162 | ret = -ENOMEM; |
| 1163 | 1163 | goto out; |
| @@ -1803,8 +1803,9 @@ static int ieee80211_reconfig_nan(struct ieee80211_sub_if_data *sdata) · 1802 unmodified lines | ||
| 1803 | 1803 | if (WARN_ON(res)) |
| 1804 | 1804 | return res; |
| 1805 | 1805 | |
| 1806 | − funcs = kzalloc((sdata->local->hw.max_nan_de_entries + 1) * | |
| 1807 | − sizeof(*funcs), GFP_KERNEL); | |
| 1806 | + funcs = kcalloc(sdata->local->hw.max_nan_de_entries + 1, | |
| 1807 | + sizeof(*funcs), | |
| 1808 | + GFP_KERNEL); | |
| 1808 | 1809 | if (!funcs) |
| 1809 | 1810 | return -ENOMEM; |
| 1810 | 1811 | |
| @@ -1380,7 +1380,8 @@ int __init ip_vs_conn_init(void) · 1379 unmodified lines | ||
| 1380 | 1380 | /* |
| 1381 | 1381 | * Allocate the connection hash table and initialize its list heads |
| 1382 | 1382 | */ |
| 1383 | − ip_vs_conn_tab = vmalloc(ip_vs_conn_tab_size * sizeof(*ip_vs_conn_tab)); | |
| 1383 | + ip_vs_conn_tab = vmalloc(array_size(ip_vs_conn_tab_size, | |
| 1384 | + sizeof(*ip_vs_conn_tab))); | |
| 1384 | 1385 | if (!ip_vs_conn_tab) |
| 1385 | 1386 | return -ENOMEM; |
| 1386 | 1387 | |
| @@ -402,7 +402,8 @@ int nf_ct_l4proto_register_one(const struct nf_conntrack_l4proto *l4proto) · 401 unmodified lines | ||
| 402 | 402 | struct nf_conntrack_l4proto __rcu **proto_array; |
| 403 | 403 | int i; |
| 404 | 404 | |
| 405 | − proto_array = kmalloc(MAX_NF_CT_PROTO * | |
| 405 | + proto_array = | |
| 406 | + kmalloc_array(MAX_NF_CT_PROTO, | |
| 406 | 407 | sizeof(struct nf_conntrack_l4proto *), |
| 407 | 408 | GFP_KERNEL); |
| 408 | 409 | if (proto_array == NULL) { |
| @@ -691,8 +691,9 @@ int nf_nat_l4proto_register(u8 l3proto, const struct nf_nat_l4proto *l4proto) · 690 unmodified lines | ||
| 691 | 691 | |
| 692 | 692 | mutex_lock(&nf_nat_proto_mutex); |
| 693 | 693 | if (nf_nat_l4protos[l3proto] == NULL) { |
| 694 | − l4protos = kmalloc(IPPROTO_MAX * sizeof(struct nf_nat_l4proto *), | |
| 695 | − GFP_KERNEL); | |
| 694 | + l4protos = kmalloc_array(IPPROTO_MAX, | |
| 695 | + sizeof(struct nf_nat_l4proto *), | |
| 696 | + GFP_KERNEL); | |
| 696 | 697 | if (l4protos == NULL) { |
| 697 | 698 | ret = -ENOMEM; |
| 698 | 699 | goto out; |
| @@ -5303,7 +5303,7 @@ static int nf_tables_flowtable_parse_hook(const struct nft_ctx *ctx, · 5302 unmodified lines | ||
| 5303 | 5303 | if (err < 0) |
| 5304 | 5304 | return err; |
| 5305 | 5305 | |
| 5306 | − ops = kzalloc(sizeof(struct nf_hook_ops) * n, GFP_KERNEL); | |
| 5306 | + ops = kcalloc(n, sizeof(struct nf_hook_ops), GFP_KERNEL); | |
| 5307 | 5307 | if (!ops) |
| 5308 | 5308 | return -ENOMEM; |
| 5309 | 5309 | |
| @@ -7164,8 +7164,8 @@ static int __init nf_tables_module_init(void) · 1854 unmodified lines | ||
| 7164 | 7164 | |
| 7165 | 7165 | nft_chain_filter_init(); |
| 7166 | 7166 | |
| 7167 | − info = kmalloc(sizeof(struct nft_expr_info) * NFT_RULE_MAXEXPRS, | |
| 7168 | − GFP_KERNEL); | |
| 7167 | + info = kmalloc_array(NFT_RULE_MAXEXPRS, sizeof(struct nft_expr_info), | |
| 7168 | + GFP_KERNEL); | |
| 7169 | 7169 | if (info == NULL) { |
| 7170 | 7170 | err = -ENOMEM; |
| 7171 | 7171 | goto err1; |
| @@ -190,8 +190,9 @@ nfnl_cthelper_parse_expect_policy(struct nf_conntrack_helper *helper, · 189 unmodified lines | ||
| 190 | 190 | if (class_max > NF_CT_MAX_EXPECT_CLASSES) |
| 191 | 191 | return -EOVERFLOW; |
| 192 | 192 | |
| 193 | − expect_policy = kzalloc(sizeof(struct nf_conntrack_expect_policy) * | |
| 194 | − class_max, GFP_KERNEL); | |
| 193 | + expect_policy = kcalloc(class_max, | |
| 194 | + sizeof(struct nf_conntrack_expect_policy), | |
| 195 | + GFP_KERNEL); | |
| 195 | 196 | if (expect_policy == NULL) |
| 196 | 197 | return -ENOMEM; |
| 197 | 198 | |
| @@ -1904,7 +1904,7 @@ static int __init xt_init(void) · 1903 unmodified lines | ||
| 1904 | 1904 | seqcount_init(&per_cpu(xt_recseq, i)); |
| 1905 | 1905 | } |
| 1906 | 1906 | |
| 1907 | − xt = kmalloc(sizeof(struct xt_af) * NFPROTO_NUMPROTO, GFP_KERNEL); | |
| 1907 | + xt = kmalloc_array(NFPROTO_NUMPROTO, sizeof(struct xt_af), GFP_KERNEL); | |
| 1908 | 1908 | if (!xt) |
| 1909 | 1909 | return -ENOMEM; |
| 1910 | 1910 | |
| @@ -352,8 +352,9 @@ int genl_register_family(struct genl_family *family) · 351 unmodified lines | ||
| 352 | 352 | } |
| 353 | 353 | |
| 354 | 354 | if (family->maxattr && !family->parallel_ops) { |
| 355 | − family->attrbuf = kmalloc((family->maxattr+1) * | |
| 356 | − sizeof(struct nlattr *), GFP_KERNEL); | |
| 355 | + family->attrbuf = kmalloc_array(family->maxattr + 1, | |
| 356 | + sizeof(struct nlattr *), | |
| 357 | + GFP_KERNEL); | |
| 357 | 358 | if (family->attrbuf == NULL) { |
| 358 | 359 | err = -ENOMEM; |
| 359 | 360 | goto errout_locked; |
| @@ -566,8 +567,9 @@ static int genl_family_rcv_msg(const struct genl_family *family, · 206 unmodified lines | ||
| 566 | 567 | return -EOPNOTSUPP; |
| 567 | 568 | |
| 568 | 569 | if (family->maxattr && family->parallel_ops) { |
| 569 | − attrbuf = kmalloc((family->maxattr+1) * | |
| 570 | − sizeof(struct nlattr *), GFP_KERNEL); | |
| 570 | + attrbuf = kmalloc_array(family->maxattr + 1, | |
| 571 | + sizeof(struct nlattr *), | |
| 572 | + GFP_KERNEL); | |
| 571 | 573 | if (attrbuf == NULL) |
| 572 | 574 | return -ENOMEM; |
| 573 | 575 | } else |
| @@ -1395,7 +1395,7 @@ static int __init nr_proto_init(void) · 1394 unmodified lines | ||
| 1395 | 1395 | return -1; |
| 1396 | 1396 | } |
| 1397 | 1397 | |
| 1398 | − dev_nr = kzalloc(nr_ndevs * sizeof(struct net_device *), GFP_KERNEL); | |
| 1398 | + dev_nr = kcalloc(nr_ndevs, sizeof(struct net_device *), GFP_KERNEL); | |
| 1399 | 1399 | if (dev_nr == NULL) { |
| 1400 | 1400 | printk(KERN_ERR "NET/ROM: nr_proto_init - unable to allocate device array\n"); |
| 1401 | 1401 | return -1; |
| @@ -1578,8 +1578,9 @@ static int ovs_dp_cmd_new(struct sk_buff *skb, struct genl_info *info) · 1577 unmodified lines | ||
| 1578 | 1578 | goto err_destroy_table; |
| 1579 | 1579 | } |
| 1580 | 1580 | |
| 1581 | − dp->ports = kmalloc(DP_VPORT_HASH_BUCKETS * sizeof(struct hlist_head), | |
| 1582 | − GFP_KERNEL); | |
| 1581 | + dp->ports = kmalloc_array(DP_VPORT_HASH_BUCKETS, | |
| 1582 | + sizeof(struct hlist_head), | |
| 1583 | + GFP_KERNEL); | |
| 1583 | 1584 | if (!dp->ports) { |
| 1584 | 1585 | err = -ENOMEM; |
| 1585 | 1586 | goto err_destroy_percpu; |
| @@ -47,7 +47,7 @@ static struct hlist_head *dev_table; · 46 unmodified lines | ||
| 47 | 47 | */ |
| 48 | 48 | int ovs_vport_init(void) |
| 49 | 49 | { |
| 50 | − dev_table = kzalloc(VPORT_HASH_BUCKETS * sizeof(struct hlist_head), | |
| 50 | + dev_table = kcalloc(VPORT_HASH_BUCKETS, sizeof(struct hlist_head), | |
| 51 | 51 | GFP_KERNEL); |
| 52 | 52 | if (!dev_table) |
| 53 | 53 | return -ENOMEM; |
| @@ -4161,7 +4161,7 @@ static char *alloc_one_pg_vec_page(unsigned long order) · 4160 unmodified lines | ||
| 4161 | 4161 | return buffer; |
| 4162 | 4162 | |
| 4163 | 4163 | /* __get_free_pages failed, fall back to vmalloc */ |
| 4164 | − buffer = vzalloc((1 << order) * PAGE_SIZE); | |
| 4164 | + buffer = vzalloc(array_size((1 << order), PAGE_SIZE)); | |
| 4165 | 4165 | if (buffer) |
| 4166 | 4166 | return buffer; |
| 4167 | 4167 | |
| @@ -163,7 +163,8 @@ static void rds_ib_add_one(struct ib_device *device) · 162 unmodified lines | ||
| 163 | 163 | rds_ibdev->max_initiator_depth = device->attrs.max_qp_init_rd_atom; |
| 164 | 164 | rds_ibdev->max_responder_resources = device->attrs.max_qp_rd_atom; |
| 165 | 165 | |
| 166 | − rds_ibdev->vector_load = kzalloc(sizeof(int) * device->num_comp_vectors, | |
| 166 | + rds_ibdev->vector_load = kcalloc(device->num_comp_vectors, | |
| 167 | + sizeof(int), | |
| 167 | 168 | GFP_KERNEL); |
| 168 | 169 | if (!rds_ibdev->vector_load) { |
| 169 | 170 | pr_err("RDS/IB: %s failed to allocate vector memory\n", |
| @@ -526,7 +526,8 @@ static int rds_ib_setup_qp(struct rds_connection *conn) · 525 unmodified lines | ||
| 526 | 526 | goto recv_hdrs_dma_out; |
| 527 | 527 | } |
| 528 | 528 | |
| 529 | − ic->i_sends = vzalloc_node(ic->i_send_ring.w_nr * sizeof(struct rds_ib_send_work), | |
| 529 | + ic->i_sends = vzalloc_node(array_size(sizeof(struct rds_ib_send_work), | |
| 530 | + ic->i_send_ring.w_nr), | |
| 530 | 531 | ibdev_to_node(dev)); |
| 531 | 532 | if (!ic->i_sends) { |
| 532 | 533 | ret = -ENOMEM; |
| @@ -534,7 +535,8 @@ static int rds_ib_setup_qp(struct rds_connection *conn) · 1 unmodified line | ||
| 534 | 535 | goto ack_dma_out; |
| 535 | 536 | } |
| 536 | 537 | |
| 537 | − ic->i_recvs = vzalloc_node(ic->i_recv_ring.w_nr * sizeof(struct rds_ib_recv_work), | |
| 538 | + ic->i_recvs = vzalloc_node(array_size(sizeof(struct rds_ib_recv_work), | |
| 539 | + ic->i_recv_ring.w_nr), | |
| 538 | 540 | ibdev_to_node(dev)); |
| 539 | 541 | if (!ic->i_recvs) { |
| 540 | 542 | ret = -ENOMEM; |
| @@ -188,7 +188,7 @@ int rds_info_getsockopt(struct socket *sock, int optname, char __user *optval, · 187 unmodified lines | ||
| 188 | 188 | nr_pages = (PAGE_ALIGN(start + len) - (start & PAGE_MASK)) |
| 189 | 189 | >> PAGE_SHIFT; |
| 190 | 190 | |
| 191 | − pages = kmalloc(nr_pages * sizeof(struct page *), GFP_KERNEL); | |
| 191 | + pages = kmalloc_array(nr_pages, sizeof(struct page *), GFP_KERNEL); | |
| 192 | 192 | if (!pages) { |
| 193 | 193 | ret = -ENOMEM; |
| 194 | 194 | goto out; |
| @@ -1514,7 +1514,8 @@ static int __init rose_proto_init(void) · 1513 unmodified lines | ||
| 1514 | 1514 | |
| 1515 | 1515 | rose_callsign = null_ax25_address; |
| 1516 | 1516 | |
| 1517 | − dev_rose = kzalloc(rose_ndevs * sizeof(struct net_device *), GFP_KERNEL); | |
| 1517 | + dev_rose = kcalloc(rose_ndevs, sizeof(struct net_device *), | |
| 1518 | + GFP_KERNEL); | |
| 1518 | 1519 | if (dev_rose == NULL) { |
| 1519 | 1520 | printk(KERN_ERR "ROSE: rose_proto_init - unable to allocate device structure\n"); |
| 1520 | 1521 | rc = -ENOMEM; |
| @@ -432,7 +432,7 @@ static int rxkad_verify_packet_2(struct rxrpc_call *call, struct sk_buff *skb, · 431 unmodified lines | ||
| 432 | 432 | |
| 433 | 433 | sg = _sg; |
| 434 | 434 | if (unlikely(nsg > 4)) { |
| 435 | − sg = kmalloc(sizeof(*sg) * nsg, GFP_NOIO); | |
| 435 | + sg = kmalloc_array(nsg, sizeof(*sg), GFP_NOIO); | |
| 436 | 436 | if (!sg) |
| 437 | 437 | goto nomem; |
| 438 | 438 | } |
| @@ -489,11 +489,12 @@ static int fq_codel_init(struct Qdisc *sch, struct nlattr *opt, · 488 unmodified lines | ||
| 489 | 489 | return err; |
| 490 | 490 | |
| 491 | 491 | if (!q->flows) { |
| 492 | − q->flows = kvzalloc(q->flows_cnt * | |
| 493 | − sizeof(struct fq_codel_flow), GFP_KERNEL); | |
| 492 | + q->flows = kvcalloc(q->flows_cnt, | |
| 493 | + sizeof(struct fq_codel_flow), | |
| 494 | + GFP_KERNEL); | |
| 494 | 495 | if (!q->flows) |
| 495 | 496 | return -ENOMEM; |
| 496 | − q->backlogs = kvzalloc(q->flows_cnt * sizeof(u32), GFP_KERNEL); | |
| 497 | + q->backlogs = kvcalloc(q->flows_cnt, sizeof(u32), GFP_KERNEL); | |
| 497 | 498 | if (!q->backlogs) |
| 498 | 499 | return -ENOMEM; |
| 499 | 500 | for (i = 0; i < q->flows_cnt; i++) { |
| @@ -599,8 +599,8 @@ static int hhf_init(struct Qdisc *sch, struct nlattr *opt, · 598 unmodified lines | ||
| 599 | 599 | |
| 600 | 600 | if (!q->hh_flows) { |
| 601 | 601 | /* Initialize heavy-hitter flow table. */ |
| 602 | − q->hh_flows = kvzalloc(HH_FLOWS_CNT * | |
| 603 | − sizeof(struct list_head), GFP_KERNEL); | |
| 602 | + q->hh_flows = kvcalloc(HH_FLOWS_CNT, sizeof(struct list_head), | |
| 603 | + GFP_KERNEL); | |
| 604 | 604 | if (!q->hh_flows) |
| 605 | 605 | return -ENOMEM; |
| 606 | 606 | for (i = 0; i < HH_FLOWS_CNT; i++) |
| @@ -614,8 +614,9 @@ static int hhf_init(struct Qdisc *sch, struct nlattr *opt, · 7 unmodified lines | ||
| 614 | 614 | |
| 615 | 615 | /* Initialize heavy-hitter filter arrays. */ |
| 616 | 616 | for (i = 0; i < HHF_ARRAYS_CNT; i++) { |
| 617 | − q->hhf_arrays[i] = kvzalloc(HHF_ARRAYS_LEN * | |
| 618 | − sizeof(u32), GFP_KERNEL); | |
| 617 | + q->hhf_arrays[i] = kvcalloc(HHF_ARRAYS_LEN, | |
| 618 | + sizeof(u32), | |
| 619 | + GFP_KERNEL); | |
| 619 | 620 | if (!q->hhf_arrays[i]) { |
| 620 | 621 | /* Note: hhf_destroy() will be called |
| 621 | 622 | * by our caller. |
| @@ -482,8 +482,9 @@ int sctp_auth_init_hmacs(struct sctp_endpoint *ep, gfp_t gfp) · 481 unmodified lines | ||
| 482 | 482 | return 0; |
| 483 | 483 | |
| 484 | 484 | /* Allocated the array of pointers to transorms */ |
| 485 | − ep->auth_hmacs = kzalloc(sizeof(struct crypto_shash *) * | |
| 486 | − SCTP_AUTH_NUM_HMACS, gfp); | |
| 485 | + ep->auth_hmacs = kcalloc(SCTP_AUTH_NUM_HMACS, | |
| 486 | + sizeof(struct crypto_shash *), | |
| 487 | + gfp); | |
| 487 | 488 | if (!ep->auth_hmacs) |
| 488 | 489 | return -ENOMEM; |
| 489 | 490 | |
| @@ -1438,7 +1438,7 @@ static __init int sctp_init(void) · 1437 unmodified lines | ||
| 1438 | 1438 | /* Allocate and initialize the endpoint hash table. */ |
| 1439 | 1439 | sctp_ep_hashsize = 64; |
| 1440 | 1440 | sctp_ep_hashtable = |
| 1441 | − kmalloc(64 * sizeof(struct sctp_hashbucket), GFP_KERNEL); | |
| 1441 | + kmalloc_array(64, sizeof(struct sctp_hashbucket), GFP_KERNEL); | |
| 1442 | 1442 | if (!sctp_ep_hashtable) { |
| 1443 | 1443 | pr_err("Failed endpoint_hash alloc\n"); |
| 1444 | 1444 | status = -ENOMEM; |
| @@ -584,9 +584,9 @@ int smc_wr_alloc_link_mem(struct smc_link *link) · 583 unmodified lines | ||
| 584 | 584 | GFP_KERNEL); |
| 585 | 585 | if (!link->wr_rx_sges) |
| 586 | 586 | goto no_mem_wr_tx_sges; |
| 587 | − link->wr_tx_mask = kzalloc( | |
| 588 | − BITS_TO_LONGS(SMC_WR_BUF_CNT) * sizeof(*link->wr_tx_mask), | |
| 589 | − GFP_KERNEL); | |
| 587 | + link->wr_tx_mask = kcalloc(BITS_TO_LONGS(SMC_WR_BUF_CNT), | |
| 588 | + sizeof(*link->wr_tx_mask), | |
| 589 | + GFP_KERNEL); | |
| 590 | 590 | if (!link->wr_tx_mask) |
| 591 | 591 | goto no_mem_wr_rx_sges; |
| 592 | 592 | link->wr_tx_pends = kcalloc(SMC_WR_BUF_CNT, |
| @@ -1753,7 +1753,8 @@ alloc_enc_pages(struct rpc_rqst *rqstp) · 1752 unmodified lines | ||
| 1753 | 1753 | last = (snd_buf->page_base + snd_buf->page_len - 1) >> PAGE_SHIFT; |
| 1754 | 1754 | rqstp->rq_enc_pages_num = last - first + 1 + 1; |
| 1755 | 1755 | rqstp->rq_enc_pages |
| 1756 | − = kmalloc(rqstp->rq_enc_pages_num * sizeof(struct page *), | |
| 1756 | + = kmalloc_array(rqstp->rq_enc_pages_num, | |
| 1757 | + sizeof(struct page *), | |
| 1757 | 1758 | GFP_NOFS); |
| 1758 | 1759 | if (!rqstp->rq_enc_pages) |
| 1759 | 1760 | goto out; |
| @@ -224,7 +224,7 @@ static void gssp_free_receive_pages(struct gssx_arg_accept_sec_context *arg) · 223 unmodified lines | ||
| 224 | 224 | static int gssp_alloc_receive_pages(struct gssx_arg_accept_sec_context *arg) |
| 225 | 225 | { |
| 226 | 226 | arg->npages = DIV_ROUND_UP(NGROUPS_MAX * 4, PAGE_SIZE); |
| 227 | − arg->pages = kzalloc(arg->npages * sizeof(struct page *), GFP_KERNEL); | |
| 227 | + arg->pages = kcalloc(arg->npages, sizeof(struct page *), GFP_KERNEL); | |
| 228 | 228 | /* |
| 229 | 229 | * XXX: actual pages are allocated by xdr layer in |
| 230 | 230 | * xdr_partial_copy_from_skb. |
| @@ -1683,7 +1683,7 @@ struct cache_detail *cache_create_net(const struct cache_detail *tmpl, struct ne · 1682 unmodified lines | ||
| 1683 | 1683 | if (cd == NULL) |
| 1684 | 1684 | return ERR_PTR(-ENOMEM); |
| 1685 | 1685 | |
| 1686 | − cd->hash_table = kzalloc(cd->hash_size * sizeof(struct hlist_head), | |
| 1686 | + cd->hash_table = kcalloc(cd->hash_size, sizeof(struct hlist_head), | |
| 1687 | 1687 | GFP_KERNEL); |
| 1688 | 1688 | if (cd->hash_table == NULL) { |
| 1689 | 1689 | kfree(cd); |
| @@ -285,8 +285,9 @@ static int __tipc_nl_compat_doit(struct tipc_nl_compat_cmd_doit *cmd, · 284 unmodified lines | ||
| 285 | 285 | if (!trans_buf) |
| 286 | 286 | return -ENOMEM; |
| 287 | 287 | |
| 288 | − attrbuf = kmalloc((tipc_genl_family.maxattr + 1) * | |
| 289 | − sizeof(struct nlattr *), GFP_KERNEL); | |
| 288 | + attrbuf = kmalloc_array(tipc_genl_family.maxattr + 1, | |
| 289 | + sizeof(struct nlattr *), | |
| 290 | + GFP_KERNEL); | |
| 290 | 291 | if (!attrbuf) { |
| 291 | 292 | err = -ENOMEM; |
| 292 | 293 | goto trans_out; |
| @@ -10833,7 +10833,7 @@ static int nl80211_parse_wowlan_nd(struct cfg80211_registered_device *rdev, · 10832 unmodified lines | ||
| 10833 | 10833 | struct nlattr **tb; |
| 10834 | 10834 | int err; |
| 10835 | 10835 | |
| 10836 | − tb = kzalloc(NUM_NL80211_ATTR * sizeof(*tb), GFP_KERNEL); | |
| 10836 | + tb = kcalloc(NUM_NL80211_ATTR, sizeof(*tb), GFP_KERNEL); | |
| 10837 | 10837 | if (!tb) |
| 10838 | 10838 | return -ENOMEM; |
| 10839 | 10839 | |
| @@ -11793,7 +11793,7 @@ static int nl80211_nan_add_func(struct sk_buff *skb, · 953 unmodified lines | ||
| 11793 | 11793 | |
| 11794 | 11794 | func->srf_num_macs = n_entries; |
| 11795 | 11795 | func->srf_macs = |
| 11796 | − kzalloc(sizeof(*func->srf_macs) * n_entries, | |
| 11796 | + kcalloc(n_entries, sizeof(*func->srf_macs), | |
| 11797 | 11797 | GFP_KERNEL); |
| 11798 | 11798 | if (!func->srf_macs) { |
| 11799 | 11799 | err = -ENOMEM; |
| @@ -475,7 +475,7 @@ static bool unpack_trans_table(struct aa_ext *e, struct aa_profile *profile) · 474 unmodified lines | ||
| 475 | 475 | /* currently 4 exec bits and entries 0-3 are reserved iupcx */ |
| 476 | 476 | if (size > 16 - 4) |
| 477 | 477 | goto fail; |
| 478 | − profile->file.trans.table = kzalloc(sizeof(char *) * size, | |
| 478 | + profile->file.trans.table = kcalloc(size, sizeof(char *), | |
| 479 | 479 | GFP_KERNEL); |
| 480 | 480 | if (!profile->file.trans.table) |
| 481 | 481 | goto fail; |
| @@ -1148,7 +1148,7 @@ static long trusted_read(const struct key *key, char __user *buffer, · 1147 unmodified lines | ||
| 1148 | 1148 | return -EINVAL; |
| 1149 | 1149 | |
| 1150 | 1150 | if (buffer && buflen >= 2 * p->blob_len) { |
| 1151 | − ascii_buf = kmalloc(2 * p->blob_len, GFP_KERNEL); | |
| 1151 | + ascii_buf = kmalloc_array(2, p->blob_len, GFP_KERNEL); | |
| 1152 | 1152 | if (!ascii_buf) |
| 1153 | 1153 | return -ENOMEM; |
| 1154 | 1154 | |
| @@ -2118,7 +2118,7 @@ int security_load_policy(struct selinux_state *state, void *data, size_t len) · 2117 unmodified lines | ||
| 2118 | 2118 | int rc = 0; |
| 2119 | 2119 | struct policy_file file = { data, len }, *fp = &file; |
| 2120 | 2120 | |
| 2121 | − oldpolicydb = kzalloc(2 * sizeof(*oldpolicydb), GFP_KERNEL); | |
| 2121 | + oldpolicydb = kcalloc(2, sizeof(*oldpolicydb), GFP_KERNEL); | |
| 2122 | 2122 | if (!oldpolicydb) { |
| 2123 | 2123 | rc = -ENOMEM; |
| 2124 | 2124 | goto out; |
| @@ -426,7 +426,7 @@ static int snd_pcm_ioctl_xfern_compat(struct snd_pcm_substream *substream, · 425 unmodified lines | ||
| 426 | 426 | get_user(frames, &data32->frames)) |
| 427 | 427 | return -EFAULT; |
| 428 | 428 | bufptr = compat_ptr(buf); |
| 429 | − bufs = kmalloc(sizeof(void __user *) * ch, GFP_KERNEL); | |
| 429 | + bufs = kmalloc_array(ch, sizeof(void __user *), GFP_KERNEL); | |
| 430 | 430 | if (bufs == NULL) |
| 431 | 431 | return -ENOMEM; |
| 432 | 432 | for (i = 0; i < ch; i++) { |
| @@ -3072,7 +3072,7 @@ static ssize_t snd_pcm_readv(struct kiocb *iocb, struct iov_iter *to) · 3071 unmodified lines | ||
| 3072 | 3072 | if (!frame_aligned(runtime, to->iov->iov_len)) |
| 3073 | 3073 | return -EINVAL; |
| 3074 | 3074 | frames = bytes_to_samples(runtime, to->iov->iov_len); |
| 3075 | − bufs = kmalloc(sizeof(void *) * to->nr_segs, GFP_KERNEL); | |
| 3075 | + bufs = kmalloc_array(to->nr_segs, sizeof(void *), GFP_KERNEL); | |
| 3076 | 3076 | if (bufs == NULL) |
| 3077 | 3077 | return -ENOMEM; |
| 3078 | 3078 | for (i = 0; i < to->nr_segs; ++i) |
| @@ -3107,7 +3107,7 @@ static ssize_t snd_pcm_writev(struct kiocb *iocb, struct iov_iter *from) · 28 unmodified lines | ||
| 3107 | 3107 | !frame_aligned(runtime, from->iov->iov_len)) |
| 3108 | 3108 | return -EINVAL; |
| 3109 | 3109 | frames = bytes_to_samples(runtime, from->iov->iov_len); |
| 3110 | − bufs = kmalloc(sizeof(void *) * from->nr_segs, GFP_KERNEL); | |
| 3110 | + bufs = kmalloc_array(from->nr_segs, sizeof(void *), GFP_KERNEL); | |
| 3111 | 3111 | if (bufs == NULL) |
| 3112 | 3112 | return -ENOMEM; |
| 3113 | 3113 | for (i = 0; i < from->nr_segs; ++i) |
| @@ -389,7 +389,8 @@ int snd_seq_pool_init(struct snd_seq_pool *pool) · 388 unmodified lines | ||
| 389 | 389 | if (snd_BUG_ON(!pool)) |
| 390 | 390 | return -EINVAL; |
| 391 | 391 | |
| 392 | − cellptr = vmalloc(sizeof(struct snd_seq_event_cell) * pool->size); | |
| 392 | + cellptr = vmalloc(array_size(sizeof(struct snd_seq_event_cell), | |
| 393 | + pool->size)); | |
| 393 | 394 | if (!cellptr) |
| 394 | 395 | return -ENOMEM; |
| 395 | 396 | |
| @@ -657,7 +657,7 @@ static struct snd_midi_channel *snd_midi_channel_init_set(int n) · 656 unmodified lines | ||
| 657 | 657 | struct snd_midi_channel *chan; |
| 658 | 658 | int i; |
| 659 | 659 | |
| 660 | − chan = kmalloc(n * sizeof(struct snd_midi_channel), GFP_KERNEL); | |
| 660 | + chan = kmalloc_array(n, sizeof(struct snd_midi_channel), GFP_KERNEL); | |
| 661 | 661 | if (chan) { |
| 662 | 662 | for (i = 0; i < n; i++) |
| 663 | 663 | snd_midi_channel_init(chan+i, i); |
| @@ -147,7 +147,7 @@ static int ff400_switch_fetching_mode(struct snd_ff *ff, bool enable) · 146 unmodified lines | ||
| 147 | 147 | __le32 *reg; |
| 148 | 148 | int i; |
| 149 | 149 | |
| 150 | − reg = kzalloc(sizeof(__le32) * 18, GFP_KERNEL); | |
| 150 | + reg = kcalloc(18, sizeof(__le32), GFP_KERNEL); | |
| 151 | 151 | if (reg == NULL) |
| 152 | 152 | return -ENOMEM; |
| 153 | 153 | |
| @@ -27,7 +27,7 @@ int iso_packets_buffer_init(struct iso_packets_buffer *b, struct fw_unit *unit, · 26 unmodified lines | ||
| 27 | 27 | void *p; |
| 28 | 28 | int err; |
| 29 | 29 | |
| 30 | − b->packets = kmalloc(count * sizeof(*b->packets), GFP_KERNEL); | |
| 30 | + b->packets = kmalloc_array(count, sizeof(*b->packets), GFP_KERNEL); | |
| 31 | 31 | if (!b->packets) { |
| 32 | 32 | err = -ENOMEM; |
| 33 | 33 | goto error; |
| @@ -420,7 +420,7 @@ static int sq_allocate_buffers(struct sound_queue *sq, int num, int size) · 419 unmodified lines | ||
| 420 | 420 | return 0; |
| 421 | 421 | sq->numBufs = num; |
| 422 | 422 | sq->bufSize = size; |
| 423 | − sq->buffers = kmalloc (num * sizeof(char *), GFP_KERNEL); | |
| 423 | + sq->buffers = kmalloc_array (num, sizeof(char *), GFP_KERNEL); | |
| 424 | 424 | if (!sq->buffers) |
| 425 | 425 | return -ENOMEM; |
| 426 | 426 | for (i = 0; i < num; i++) { |
| @@ -460,7 +460,7 @@ static int load_firmware(struct snd_cs46xx *chip, · 459 unmodified lines | ||
| 460 | 460 | entry->size = le32_to_cpu(fwdat[fwlen++]); |
| 461 | 461 | if (fwlen + entry->size > fwsize) |
| 462 | 462 | goto error_inval; |
| 463 | − entry->data = kmalloc(entry->size * 4, GFP_KERNEL); | |
| 463 | + entry->data = kmalloc_array(entry->size, 4, GFP_KERNEL); | |
| 464 | 464 | if (!entry->data) |
| 465 | 465 | goto error; |
| 466 | 466 | memcpy_le32(entry->data, &fwdat[fwlen], entry->size * 4); |
| @@ -4036,8 +4036,9 @@ int snd_cs46xx_create(struct snd_card *card, · 3569 unmodified lines | ||
| 4036 | 4036 | snd_cs46xx_proc_init(card, chip); |
| 4037 | 4037 | |
| 4038 | 4038 | #ifdef CONFIG_PM_SLEEP |
| 4039 | − chip->saved_regs = kmalloc(sizeof(*chip->saved_regs) * | |
| 4040 | − ARRAY_SIZE(saved_regs), GFP_KERNEL); | |
| 4039 | + chip->saved_regs = kmalloc_array(ARRAY_SIZE(saved_regs), | |
| 4040 | + sizeof(*chip->saved_regs), | |
| 4041 | + GFP_KERNEL); | |
| 4041 | 4042 | if (!chip->saved_regs) { |
| 4042 | 4043 | snd_cs46xx_free(chip); |
| 4043 | 4044 | return -ENOMEM; |
| @@ -240,10 +240,13 @@ struct dsp_spos_instance *cs46xx_dsp_spos_create (struct snd_cs46xx * chip) · 239 unmodified lines | ||
| 240 | 240 | return NULL; |
| 241 | 241 | |
| 242 | 242 | /* better to use vmalloc for this big table */ |
| 243 | − ins->symbol_table.symbols = vmalloc(sizeof(struct dsp_symbol_entry) * | |
| 244 | − DSP_MAX_SYMBOLS); | |
| 243 | + ins->symbol_table.symbols = | |
| 244 | + vmalloc(array_size(DSP_MAX_SYMBOLS, | |
| 245 | + sizeof(struct dsp_symbol_entry))); | |
| 245 | 246 | ins->code.data = kmalloc(DSP_CODE_BYTE_SIZE, GFP_KERNEL); |
| 246 | − ins->modules = kmalloc(sizeof(struct dsp_module_desc) * DSP_MAX_MODULES, GFP_KERNEL); | |
| 247 | + ins->modules = kmalloc_array(DSP_MAX_MODULES, | |
| 248 | + sizeof(struct dsp_module_desc), | |
| 249 | + GFP_KERNEL); | |
| 247 | 250 | if (!ins->symbol_table.symbols || !ins->code.data || !ins->modules) { |
| 248 | 251 | cs46xx_dsp_spos_destroy(chip); |
| 249 | 252 | goto error; |
| @@ -275,7 +275,7 @@ static int atc_pcm_playback_prepare(struct ct_atc *atc, struct ct_atc_pcm *apcm) · 274 unmodified lines | ||
| 275 | 275 | |
| 276 | 276 | /* Get AMIXER resource */ |
| 277 | 277 | n_amixer = (n_amixer < 2) ? 2 : n_amixer; |
| 278 | − apcm->amixers = kzalloc(sizeof(void *)*n_amixer, GFP_KERNEL); | |
| 278 | + apcm->amixers = kcalloc(n_amixer, sizeof(void *), GFP_KERNEL); | |
| 279 | 279 | if (!apcm->amixers) { |
| 280 | 280 | err = -ENOMEM; |
| 281 | 281 | goto error1; |
| @@ -543,18 +543,18 @@ atc_pcm_capture_get_resources(struct ct_atc *atc, struct ct_atc_pcm *apcm) · 261 unmodified lines | ||
| 543 | 543 | } |
| 544 | 544 | |
| 545 | 545 | if (n_srcc) { |
| 546 | − apcm->srccs = kzalloc(sizeof(void *)*n_srcc, GFP_KERNEL); | |
| 546 | + apcm->srccs = kcalloc(n_srcc, sizeof(void *), GFP_KERNEL); | |
| 547 | 547 | if (!apcm->srccs) |
| 548 | 548 | return -ENOMEM; |
| 549 | 549 | } |
| 550 | 550 | if (n_amixer) { |
| 551 | − apcm->amixers = kzalloc(sizeof(void *)*n_amixer, GFP_KERNEL); | |
| 551 | + apcm->amixers = kcalloc(n_amixer, sizeof(void *), GFP_KERNEL); | |
| 552 | 552 | if (!apcm->amixers) { |
| 553 | 553 | err = -ENOMEM; |
| 554 | 554 | goto error1; |
| 555 | 555 | } |
| 556 | 556 | } |
| 557 | − apcm->srcimps = kzalloc(sizeof(void *)*n_srcimp, GFP_KERNEL); | |
| 557 | + apcm->srcimps = kcalloc(n_srcimp, sizeof(void *), GFP_KERNEL); | |
| 558 | 558 | if (!apcm->srcimps) { |
| 559 | 559 | err = -ENOMEM; |
| 560 | 560 | goto error1; |
| @@ -819,7 +819,7 @@ static int spdif_passthru_playback_get_resources(struct ct_atc *atc, · 258 unmodified lines | ||
| 819 | 819 | |
| 820 | 820 | /* Get AMIXER resource */ |
| 821 | 821 | n_amixer = (n_amixer < 2) ? 2 : n_amixer; |
| 822 | − apcm->amixers = kzalloc(sizeof(void *)*n_amixer, GFP_KERNEL); | |
| 822 | + apcm->amixers = kcalloc(n_amixer, sizeof(void *), GFP_KERNEL); | |
| 823 | 823 | if (!apcm->amixers) { |
| 824 | 824 | err = -ENOMEM; |
| 825 | 825 | goto error1; |
| @@ -1378,19 +1378,19 @@ static int atc_get_resources(struct ct_atc *atc) · 552 unmodified lines | ||
| 1378 | 1378 | num_daios = ((atc->model == CTSB1270) ? 8 : 7); |
| 1379 | 1379 | num_srcs = ((atc->model == CTSB1270) ? 6 : 4); |
| 1380 | 1380 | |
| 1381 | − atc->daios = kzalloc(sizeof(void *)*num_daios, GFP_KERNEL); | |
| 1381 | + atc->daios = kcalloc(num_daios, sizeof(void *), GFP_KERNEL); | |
| 1382 | 1382 | if (!atc->daios) |
| 1383 | 1383 | return -ENOMEM; |
| 1384 | 1384 | |
| 1385 | − atc->srcs = kzalloc(sizeof(void *)*num_srcs, GFP_KERNEL); | |
| 1385 | + atc->srcs = kcalloc(num_srcs, sizeof(void *), GFP_KERNEL); | |
| 1386 | 1386 | if (!atc->srcs) |
| 1387 | 1387 | return -ENOMEM; |
| 1388 | 1388 | |
| 1389 | − atc->srcimps = kzalloc(sizeof(void *)*num_srcs, GFP_KERNEL); | |
| 1389 | + atc->srcimps = kcalloc(num_srcs, sizeof(void *), GFP_KERNEL); | |
| 1390 | 1390 | if (!atc->srcimps) |
| 1391 | 1391 | return -ENOMEM; |
| 1392 | 1392 | |
| 1393 | − atc->pcm = kzalloc(sizeof(void *)*(2*4), GFP_KERNEL); | |
| 1393 | + atc->pcm = kcalloc(2 * 4, sizeof(void *), GFP_KERNEL); | |
| 1394 | 1394 | if (!atc->pcm) |
| 1395 | 1395 | return -ENOMEM; |
| 1396 | 1396 | |
| @@ -398,7 +398,8 @@ static int dao_rsc_init(struct dao *dao, · 397 unmodified lines | ||
| 398 | 398 | if (err) |
| 399 | 399 | return err; |
| 400 | 400 | |
| 401 | − dao->imappers = kzalloc(sizeof(void *)*desc->msr*2, GFP_KERNEL); | |
| 401 | + dao->imappers = kzalloc(array3_size(sizeof(void *), desc->msr, 2), | |
| 402 | + GFP_KERNEL); | |
| 402 | 403 | if (!dao->imappers) { |
| 403 | 404 | err = -ENOMEM; |
| 404 | 405 | goto error1; |
| @@ -910,13 +910,14 @@ static int ct_mixer_get_mem(struct ct_mixer **rmixer) · 909 unmodified lines | ||
| 910 | 910 | if (!mixer) |
| 911 | 911 | return -ENOMEM; |
| 912 | 912 | |
| 913 | − mixer->amixers = kzalloc(sizeof(void *)*(NUM_CT_AMIXERS*CHN_NUM), | |
| 913 | + mixer->amixers = kcalloc(NUM_CT_AMIXERS * CHN_NUM, sizeof(void *), | |
| 914 | 914 | GFP_KERNEL); |
| 915 | 915 | if (!mixer->amixers) { |
| 916 | 916 | err = -ENOMEM; |
| 917 | 917 | goto error1; |
| 918 | 918 | } |
| 919 | − mixer->sums = kzalloc(sizeof(void *)*(NUM_CT_SUMS*CHN_NUM), GFP_KERNEL); | |
| 919 | + mixer->sums = kcalloc(NUM_CT_SUMS * CHN_NUM, sizeof(void *), | |
| 920 | + GFP_KERNEL); | |
| 920 | 921 | if (!mixer->sums) { |
| 921 | 922 | err = -ENOMEM; |
| 922 | 923 | goto error2; |
| @@ -679,7 +679,7 @@ static int srcimp_rsc_init(struct srcimp *srcimp, · 678 unmodified lines | ||
| 679 | 679 | return err; |
| 680 | 680 | |
| 681 | 681 | /* Reserve memory for imapper nodes */ |
| 682 | − srcimp->imappers = kzalloc(sizeof(struct imapper)*desc->msr, | |
| 682 | + srcimp->imappers = kcalloc(desc->msr, sizeof(struct imapper), | |
| 683 | 683 | GFP_KERNEL); |
| 684 | 684 | if (!srcimp->imappers) { |
| 685 | 685 | err = -ENOMEM; |
| @@ -1941,9 +1941,10 @@ int snd_emu10k1_create(struct snd_card *card, · 1940 unmodified lines | ||
| 1941 | 1941 | (unsigned long)emu->ptb_pages.addr, |
| 1942 | 1942 | (unsigned long)(emu->ptb_pages.addr + emu->ptb_pages.bytes)); |
| 1943 | 1943 | |
| 1944 | − emu->page_ptr_table = vmalloc(emu->max_cache_pages * sizeof(void *)); | |
| 1945 | − emu->page_addr_table = vmalloc(emu->max_cache_pages * | |
| 1946 | − sizeof(unsigned long)); | |
| 1944 | + emu->page_ptr_table = vmalloc(array_size(sizeof(void *), | |
| 1945 | + emu->max_cache_pages)); | |
| 1946 | + emu->page_addr_table = vmalloc(array_size(sizeof(unsigned long), | |
| 1947 | + emu->max_cache_pages)); | |
| 1947 | 1948 | if (emu->page_ptr_table == NULL || emu->page_addr_table == NULL) { |
| 1948 | 1949 | err = -ENOMEM; |
| 1949 | 1950 | goto error; |
| @@ -2099,7 +2100,7 @@ static int alloc_pm_buffer(struct snd_emu10k1 *emu) · 149 unmodified lines | ||
| 2099 | 2100 | size = ARRAY_SIZE(saved_regs); |
| 2100 | 2101 | if (emu->audigy) |
| 2101 | 2102 | size += ARRAY_SIZE(saved_regs_audigy); |
| 2102 | − emu->saved_ptr = vmalloc(4 * NUM_G * size); | |
| 2103 | + emu->saved_ptr = vmalloc(array3_size(4, NUM_G, size)); | |
| 2103 | 2104 | if (!emu->saved_ptr) |
| 2104 | 2105 | return -ENOMEM; |
| 2105 | 2106 | if (snd_emu10k1_efx_alloc_pm_buffer(emu) < 0) |
| @@ -2683,16 +2683,16 @@ int snd_emu10k1_efx_alloc_pm_buffer(struct snd_emu10k1 *emu) · 2682 unmodified lines | ||
| 2683 | 2683 | int len; |
| 2684 | 2684 | |
| 2685 | 2685 | len = emu->audigy ? 0x200 : 0x100; |
| 2686 | − emu->saved_gpr = kmalloc(len * 4, GFP_KERNEL); | |
| 2686 | + emu->saved_gpr = kmalloc_array(len, 4, GFP_KERNEL); | |
| 2687 | 2687 | if (! emu->saved_gpr) |
| 2688 | 2688 | return -ENOMEM; |
| 2689 | 2689 | len = emu->audigy ? 0x100 : 0xa0; |
| 2690 | − emu->tram_val_saved = kmalloc(len * 4, GFP_KERNEL); | |
| 2691 | − emu->tram_addr_saved = kmalloc(len * 4, GFP_KERNEL); | |
| 2690 | + emu->tram_val_saved = kmalloc_array(len, 4, GFP_KERNEL); | |
| 2691 | + emu->tram_addr_saved = kmalloc_array(len, 4, GFP_KERNEL); | |
| 2692 | 2692 | if (! emu->tram_val_saved || ! emu->tram_addr_saved) |
| 2693 | 2693 | return -ENOMEM; |
| 2694 | 2694 | len = emu->audigy ? 2 * 1024 : 2 * 512; |
| 2695 | − emu->saved_icode = vmalloc(len * 4); | |
| 2695 | + emu->saved_icode = vmalloc(array_size(len, 4)); | |
| 2696 | 2696 | if (! emu->saved_icode) |
| 2697 | 2697 | return -ENOMEM; |
| 2698 | 2698 | return 0; |
| @@ -874,7 +874,7 @@ int snd_p16v_mixer(struct snd_emu10k1 *emu) · 873 unmodified lines | ||
| 874 | 874 | |
| 875 | 875 | int snd_p16v_alloc_pm_buffer(struct snd_emu10k1 *emu) |
| 876 | 876 | { |
| 877 | − emu->p16v_saved = vmalloc(NUM_CHS * 4 * 0x80); | |
| 877 | + emu->p16v_saved = vmalloc(array_size(NUM_CHS * 4, 0x80)); | |
| 878 | 878 | if (! emu->p16v_saved) |
| 879 | 879 | return -ENOMEM; |
| 880 | 880 | return 0; |
| @@ -158,7 +158,7 @@ static int read_and_add_raw_conns(struct hda_codec *codec, hda_nid_t nid) · 157 unmodified lines | ||
| 158 | 158 | len = snd_hda_get_raw_connections(codec, nid, list, ARRAY_SIZE(list)); |
| 159 | 159 | if (len == -ENOSPC) { |
| 160 | 160 | len = snd_hda_get_num_raw_conns(codec, nid); |
| 161 | − result = kmalloc(sizeof(hda_nid_t) * len, GFP_KERNEL); | |
| 161 | + result = kmalloc_array(len, sizeof(hda_nid_t), GFP_KERNEL); | |
| 162 | 162 | if (!result) |
| 163 | 163 | return -ENOMEM; |
| 164 | 164 | len = snd_hda_get_raw_connections(codec, nid, result, len); |
| @@ -438,7 +438,7 @@ static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node) · 273 unmodified lines | ||
| 438 | 438 | int i; |
| 439 | 439 | hda_nid_t nid; |
| 440 | 440 | |
| 441 | − codec->wcaps = kmalloc(codec->core.num_nodes * 4, GFP_KERNEL); | |
| 441 | + codec->wcaps = kmalloc_array(codec->core.num_nodes, 4, GFP_KERNEL); | |
| 442 | 442 | if (!codec->wcaps) |
| 443 | 443 | return -ENOMEM; |
| 444 | 444 | nid = codec->core.start_nid; |
| @@ -825,8 +825,9 @@ static void print_codec_info(struct snd_info_entry *entry, · 824 unmodified lines | ||
| 825 | 825 | if (wid_caps & AC_WCAP_CONN_LIST) { |
| 826 | 826 | conn_len = snd_hda_get_num_raw_conns(codec, nid); |
| 827 | 827 | if (conn_len > 0) { |
| 828 | − conn = kmalloc(sizeof(hda_nid_t) * conn_len, | |
| 829 | − GFP_KERNEL); | |
| 828 | + conn = kmalloc_array(conn_len, | |
| 829 | + sizeof(hda_nid_t), | |
| 830 | + GFP_KERNEL); | |
| 830 | 831 | if (!conn) |
| 831 | 832 | return; |
| 832 | 833 | if (snd_hda_get_raw_connections(codec, nid, conn, |
| @@ -7482,7 +7482,9 @@ static int ca0132_prepare_verbs(struct hda_codec *codec) · 7481 unmodified lines | ||
| 7482 | 7482 | spec->chip_init_verbs = ca0132_init_verbs0; |
| 7483 | 7483 | if (spec->quirk == QUIRK_SBZ) |
| 7484 | 7484 | spec->sbz_init_verbs = sbz_init_verbs; |
| 7485 | − spec->spec_init_verbs = kzalloc(sizeof(struct hda_verb) * NUM_SPEC_VERBS, GFP_KERNEL); | |
| 7485 | + spec->spec_init_verbs = kcalloc(NUM_SPEC_VERBS, | |
| 7486 | + sizeof(struct hda_verb), | |
| 7487 | + GFP_KERNEL); | |
| 7486 | 7488 | if (!spec->spec_init_verbs) |
| 7487 | 7489 | return -ENOMEM; |
| 7488 | 7490 | |
| @@ -2657,7 +2657,10 @@ snd_m3_create(struct snd_card *card, struct pci_dev *pci, · 2656 unmodified lines | ||
| 2657 | 2657 | chip->irq = pci->irq; |
| 2658 | 2658 | |
| 2659 | 2659 | #ifdef CONFIG_PM_SLEEP |
| 2660 | − chip->suspend_mem = vmalloc(sizeof(u16) * (REV_B_CODE_MEMORY_LENGTH + REV_B_DATA_MEMORY_LENGTH)); | |
| 2660 | + chip->suspend_mem = | |
| 2661 | + vmalloc(array_size(sizeof(u16), | |
| 2662 | + REV_B_CODE_MEMORY_LENGTH + | |
| 2663 | + REV_B_DATA_MEMORY_LENGTH)); | |
| 2661 | 2664 | if (chip->suspend_mem == NULL) |
| 2662 | 2665 | dev_warn(card->dev, "can't allocate apm buffer\n"); |
| 2663 | 2666 | #endif |
| @@ -3362,7 +3362,9 @@ static int snd_trident_tlb_alloc(struct snd_trident *trident) · 3361 unmodified lines | ||
| 3362 | 3362 | trident->tlb.entries = (unsigned int*)ALIGN((unsigned long)trident->tlb.buffer.area, SNDRV_TRIDENT_MAX_PAGES * 4); |
| 3363 | 3363 | trident->tlb.entries_dmaaddr = ALIGN(trident->tlb.buffer.addr, SNDRV_TRIDENT_MAX_PAGES * 4); |
| 3364 | 3364 | /* allocate shadow TLB page table (virtual addresses) */ |
| 3365 | − trident->tlb.shadow_entries = vmalloc(SNDRV_TRIDENT_MAX_PAGES*sizeof(unsigned long)); | |
| 3365 | + trident->tlb.shadow_entries = | |
| 3366 | + vmalloc(array_size(SNDRV_TRIDENT_MAX_PAGES, | |
| 3367 | + sizeof(unsigned long))); | |
| 3366 | 3368 | if (!trident->tlb.shadow_entries) |
| 3367 | 3369 | return -ENOMEM; |
| 3368 | 3370 | |
| @@ -439,7 +439,9 @@ static int build_via_table(struct viadev *dev, struct snd_pcm_substream *substre · 438 unmodified lines | ||
| 439 | 439 | return -ENOMEM; |
| 440 | 440 | } |
| 441 | 441 | if (! dev->idx_table) { |
| 442 | − dev->idx_table = kmalloc(sizeof(*dev->idx_table) * VIA_TABLE_SIZE, GFP_KERNEL); | |
| 442 | + dev->idx_table = kmalloc_array(VIA_TABLE_SIZE, | |
| 443 | + sizeof(*dev->idx_table), | |
| 444 | + GFP_KERNEL); | |
| 443 | 445 | if (! dev->idx_table) |
| 444 | 446 | return -ENOMEM; |
| 445 | 447 | } |
| @@ -292,7 +292,9 @@ static int build_via_table(struct viadev *dev, struct snd_pcm_substream *substre · 291 unmodified lines | ||
| 292 | 292 | return -ENOMEM; |
| 293 | 293 | } |
| 294 | 294 | if (! dev->idx_table) { |
| 295 | − dev->idx_table = kmalloc(sizeof(*dev->idx_table) * VIA_TABLE_SIZE, GFP_KERNEL); | |
| 295 | + dev->idx_table = kmalloc_array(VIA_TABLE_SIZE, | |
| 296 | + sizeof(*dev->idx_table), | |
| 297 | + GFP_KERNEL); | |
| 296 | 298 | if (! dev->idx_table) |
| 297 | 299 | return -ENOMEM; |
| 298 | 300 | } |
| @@ -2435,8 +2435,8 @@ int snd_ymfpci_create(struct snd_card *card, · 2434 unmodified lines | ||
| 2435 | 2435 | goto free_chip; |
| 2436 | 2436 | |
| 2437 | 2437 | #ifdef CONFIG_PM_SLEEP |
| 2438 | − chip->saved_regs = kmalloc(YDSXGR_NUM_SAVED_REGS * sizeof(u32), | |
| 2439 | − GFP_KERNEL); | |
| 2438 | + chip->saved_regs = kmalloc_array(YDSXGR_NUM_SAVED_REGS, sizeof(u32), | |
| 2439 | + GFP_KERNEL); | |
| 2440 | 2440 | if (chip->saved_regs == NULL) { |
| 2441 | 2441 | err = -ENOMEM; |
| 2442 | 2442 | goto free_chip; |
| @@ -339,8 +339,8 @@ static int au1xpsc_pcm_drvprobe(struct platform_device *pdev) · 338 unmodified lines | ||
| 339 | 339 | { |
| 340 | 340 | struct au1xpsc_audio_dmadata *dmadata; |
| 341 | 341 | |
| 342 | − dmadata = devm_kzalloc(&pdev->dev, | |
| 343 | − 2 * sizeof(struct au1xpsc_audio_dmadata), | |
| 342 | + dmadata = devm_kcalloc(&pdev->dev, | |
| 343 | + 2, sizeof(struct au1xpsc_audio_dmadata), | |
| 344 | 344 | GFP_KERNEL); |
| 345 | 345 | if (!dmadata) |
| 346 | 346 | return -ENOMEM; |
| @@ -771,7 +771,7 @@ static int hdmi_codec_probe(struct platform_device *pdev) · 770 unmodified lines | ||
| 771 | 771 | hcp->hcd = *hcd; |
| 772 | 772 | mutex_init(&hcp->current_stream_lock); |
| 773 | 773 | |
| 774 | − hcp->daidrv = devm_kzalloc(dev, dai_count * sizeof(*hcp->daidrv), | |
| 774 | + hcp->daidrv = devm_kcalloc(dev, dai_count, sizeof(*hcp->daidrv), | |
| 775 | 775 | GFP_KERNEL); |
| 776 | 776 | if (!hcp->daidrv) |
| 777 | 777 | return -ENOMEM; |
| @@ -3449,8 +3449,9 @@ static int rt5645_probe(struct snd_soc_component *component) · 3448 unmodified lines | ||
| 3449 | 3449 | if (rt5645->pdata.long_name) |
| 3450 | 3450 | component->card->long_name = rt5645->pdata.long_name; |
| 3451 | 3451 | |
| 3452 | − rt5645->eq_param = devm_kzalloc(component->dev, | |
| 3453 | − RT5645_HWEQ_NUM * sizeof(struct rt5645_eq_param_s), GFP_KERNEL); | |
| 3452 | + rt5645->eq_param = devm_kcalloc(component->dev, | |
| 3453 | + RT5645_HWEQ_NUM, sizeof(struct rt5645_eq_param_s), | |
| 3454 | + GFP_KERNEL); | |
| 3454 | 3455 | |
| 3455 | 3456 | return 0; |
| 3456 | 3457 | } |
| @@ -2023,8 +2023,9 @@ static void wm8904_handle_pdata(struct snd_soc_component *component) · 2022 unmodified lines | ||
| 2023 | 2023 | wm8904_get_drc_enum, wm8904_put_drc_enum); |
| 2024 | 2024 | |
| 2025 | 2025 | /* We need an array of texts for the enum API */ |
| 2026 | − wm8904->drc_texts = kmalloc(sizeof(char *) | |
| 2027 | − * pdata->num_drc_cfgs, GFP_KERNEL); | |
| 2026 | + wm8904->drc_texts = kmalloc_array(pdata->num_drc_cfgs, | |
| 2027 | + sizeof(char *), | |
| 2028 | + GFP_KERNEL); | |
| 2028 | 2029 | if (!wm8904->drc_texts) |
| 2029 | 2030 | return; |
| 2030 | 2031 | |
| @@ -932,8 +932,9 @@ void wm8958_dsp2_init(struct snd_soc_component *component) · 931 unmodified lines | ||
| 932 | 932 | }; |
| 933 | 933 | |
| 934 | 934 | /* We need an array of texts for the enum API */ |
| 935 | − wm8994->mbc_texts = kmalloc(sizeof(char *) | |
| 936 | − * pdata->num_mbc_cfgs, GFP_KERNEL); | |
| 935 | + wm8994->mbc_texts = kmalloc_array(pdata->num_mbc_cfgs, | |
| 936 | + sizeof(char *), | |
| 937 | + GFP_KERNEL); | |
| 937 | 938 | if (!wm8994->mbc_texts) |
| 938 | 939 | return; |
| 939 | 940 | |
| @@ -957,8 +958,9 @@ void wm8958_dsp2_init(struct snd_soc_component *component) · 17 unmodified lines | ||
| 957 | 958 | }; |
| 958 | 959 | |
| 959 | 960 | /* We need an array of texts for the enum API */ |
| 960 | − wm8994->vss_texts = kmalloc(sizeof(char *) | |
| 961 | − * pdata->num_vss_cfgs, GFP_KERNEL); | |
| 961 | + wm8994->vss_texts = kmalloc_array(pdata->num_vss_cfgs, | |
| 962 | + sizeof(char *), | |
| 963 | + GFP_KERNEL); | |
| 962 | 964 | if (!wm8994->vss_texts) |
| 963 | 965 | return; |
| 964 | 966 | |
| @@ -983,8 +985,9 @@ void wm8958_dsp2_init(struct snd_soc_component *component) · 18 unmodified lines | ||
| 983 | 985 | }; |
| 984 | 986 | |
| 985 | 987 | /* We need an array of texts for the enum API */ |
| 986 | − wm8994->vss_hpf_texts = kmalloc(sizeof(char *) | |
| 987 | − * pdata->num_vss_hpf_cfgs, GFP_KERNEL); | |
| 988 | + wm8994->vss_hpf_texts = kmalloc_array(pdata->num_vss_hpf_cfgs, | |
| 989 | + sizeof(char *), | |
| 990 | + GFP_KERNEL); | |
| 988 | 991 | if (!wm8994->vss_hpf_texts) |
| 989 | 992 | return; |
| 990 | 993 | |
| @@ -1010,8 +1013,9 @@ void wm8958_dsp2_init(struct snd_soc_component *component) · 19 unmodified lines | ||
| 1010 | 1013 | }; |
| 1011 | 1014 | |
| 1012 | 1015 | /* We need an array of texts for the enum API */ |
| 1013 | − wm8994->enh_eq_texts = kmalloc(sizeof(char *) | |
| 1014 | − * pdata->num_enh_eq_cfgs, GFP_KERNEL); | |
| 1016 | + wm8994->enh_eq_texts = kmalloc_array(pdata->num_enh_eq_cfgs, | |
| 1017 | + sizeof(char *), | |
| 1018 | + GFP_KERNEL); | |
| 1015 | 1019 | if (!wm8994->enh_eq_texts) |
| 1016 | 1020 | return; |
| 1017 | 1021 | |
| @@ -3298,8 +3298,8 @@ static void wm8994_handle_pdata(struct wm8994_priv *wm8994) · 3297 unmodified lines | ||
| 3298 | 3298 | }; |
| 3299 | 3299 | |
| 3300 | 3300 | /* We need an array of texts for the enum API */ |
| 3301 | − wm8994->drc_texts = devm_kzalloc(wm8994->hubs.component->dev, | |
| 3302 | − sizeof(char *) * pdata->num_drc_cfgs, GFP_KERNEL); | |
| 3301 | + wm8994->drc_texts = devm_kcalloc(wm8994->hubs.component->dev, | |
| 3302 | + pdata->num_drc_cfgs, sizeof(char *), GFP_KERNEL); | |
| 3303 | 3303 | if (!wm8994->drc_texts) |
| 3304 | 3304 | return; |
| 3305 | 3305 | |
| @@ -1899,7 +1899,7 @@ static void *wm_adsp_read_algs(struct wm_adsp *dsp, size_t n_algs, · 1898 unmodified lines | ||
| 1899 | 1899 | adsp_warn(dsp, "Algorithm list end %x 0x%x != 0xbedead\n", |
| 1900 | 1900 | pos + len, be32_to_cpu(val)); |
| 1901 | 1901 | |
| 1902 | − alg = kzalloc(len * 2, GFP_KERNEL | GFP_DMA); | |
| 1902 | + alg = kcalloc(len, 2, GFP_KERNEL | GFP_DMA); | |
| 1903 | 1903 | if (!alg) |
| 1904 | 1904 | return ERR_PTR(-ENOMEM); |
| 1905 | 1905 | |
| @@ -1868,8 +1868,8 @@ static int davinci_mcasp_probe(struct platform_device *pdev) · 1867 unmodified lines | ||
| 1868 | 1868 | |
| 1869 | 1869 | mcasp->num_serializer = pdata->num_serializer; |
| 1870 | 1870 | #ifdef CONFIG_PM_SLEEP |
| 1871 | − mcasp->context.xrsr_regs = devm_kzalloc(&pdev->dev, | |
| 1872 | − sizeof(u32) * mcasp->num_serializer, | |
| 1871 | + mcasp->context.xrsr_regs = devm_kcalloc(&pdev->dev, | |
| 1872 | + mcasp->num_serializer, sizeof(u32), | |
| 1873 | 1873 | GFP_KERNEL); |
| 1874 | 1874 | if (!mcasp->context.xrsr_regs) { |
| 1875 | 1875 | ret = -ENOMEM; |
| @@ -2004,13 +2004,15 @@ static int davinci_mcasp_probe(struct platform_device *pdev) · 128 unmodified lines | ||
| 2004 | 2004 | * bytes. |
| 2005 | 2005 | */ |
| 2006 | 2006 | mcasp->chconstr[SNDRV_PCM_STREAM_PLAYBACK].list = |
| 2007 | − devm_kzalloc(mcasp->dev, sizeof(unsigned int) * | |
| 2008 | − (32 + mcasp->num_serializer - 1), | |
| 2007 | + devm_kcalloc(mcasp->dev, | |
| 2008 | + 32 + mcasp->num_serializer - 1, | |
| 2009 | + sizeof(unsigned int), | |
| 2009 | 2010 | GFP_KERNEL); |
| 2010 | 2011 | |
| 2011 | 2012 | mcasp->chconstr[SNDRV_PCM_STREAM_CAPTURE].list = |
| 2012 | − devm_kzalloc(mcasp->dev, sizeof(unsigned int) * | |
| 2013 | − (32 + mcasp->num_serializer - 1), | |
| 2013 | + devm_kcalloc(mcasp->dev, | |
| 2014 | + 32 + mcasp->num_serializer - 1, | |
| 2015 | + sizeof(unsigned int), | |
| 2014 | 2016 | GFP_KERNEL); |
| 2015 | 2017 | |
| 2016 | 2018 | if (!mcasp->chconstr[SNDRV_PCM_STREAM_PLAYBACK].list || |
| @@ -296,8 +296,8 @@ static int asoc_graph_card_probe(struct platform_device *pdev) · 295 unmodified lines | ||
| 296 | 296 | if (num == 0) |
| 297 | 297 | return -EINVAL; |
| 298 | 298 | |
| 299 | − dai_props = devm_kzalloc(dev, sizeof(*dai_props) * num, GFP_KERNEL); | |
| 300 | − dai_link = devm_kzalloc(dev, sizeof(*dai_link) * num, GFP_KERNEL); | |
| 299 | + dai_props = devm_kcalloc(dev, num, sizeof(*dai_props), GFP_KERNEL); | |
| 300 | + dai_link = devm_kcalloc(dev, num, sizeof(*dai_link), GFP_KERNEL); | |
| 301 | 301 | if (!dai_props || !dai_link) |
| 302 | 302 | return -ENOMEM; |
| 303 | 303 | |
| @@ -348,8 +348,8 @@ static int asoc_graph_card_probe(struct platform_device *pdev) · 347 unmodified lines | ||
| 348 | 348 | if (num == 0) |
| 349 | 349 | return -EINVAL; |
| 350 | 350 | |
| 351 | − dai_props = devm_kzalloc(dev, sizeof(*dai_props) * num, GFP_KERNEL); | |
| 352 | − dai_link = devm_kzalloc(dev, sizeof(*dai_link) * num, GFP_KERNEL); | |
| 351 | + dai_props = devm_kcalloc(dev, num, sizeof(*dai_props), GFP_KERNEL); | |
| 352 | + dai_link = devm_kcalloc(dev, num, sizeof(*dai_link), GFP_KERNEL); | |
| 353 | 353 | if (!dai_props || !dai_link) |
| 354 | 354 | return -ENOMEM; |
| 355 | 355 | |
| @@ -340,8 +340,8 @@ static int asoc_simple_card_parse_aux_devs(struct device_node *node, · 339 unmodified lines | ||
| 340 | 340 | if (n <= 0) |
| 341 | 341 | return -EINVAL; |
| 342 | 342 | |
| 343 | − card->aux_dev = devm_kzalloc(dev, | |
| 344 | − n * sizeof(*card->aux_dev), GFP_KERNEL); | |
| 343 | + card->aux_dev = devm_kcalloc(dev, | |
| 344 | + n, sizeof(*card->aux_dev), GFP_KERNEL); | |
| 345 | 345 | if (!card->aux_dev) |
| 346 | 346 | return -ENOMEM; |
| 347 | 347 | |
| @@ -435,8 +435,8 @@ static int asoc_simple_card_probe(struct platform_device *pdev) · 87 unmodified lines | ||
| 435 | 435 | if (!priv) |
| 436 | 436 | return -ENOMEM; |
| 437 | 437 | |
| 438 | − dai_props = devm_kzalloc(dev, sizeof(*dai_props) * num, GFP_KERNEL); | |
| 439 | − dai_link = devm_kzalloc(dev, sizeof(*dai_link) * num, GFP_KERNEL); | |
| 438 | + dai_props = devm_kcalloc(dev, num, sizeof(*dai_props), GFP_KERNEL); | |
| 439 | + dai_link = devm_kcalloc(dev, num, sizeof(*dai_link), GFP_KERNEL); | |
| 440 | 440 | if (!dai_props || !dai_link) |
| 441 | 441 | return -ENOMEM; |
| 442 | 442 | |
| @@ -246,8 +246,8 @@ static int asoc_simple_card_probe(struct platform_device *pdev) · 245 unmodified lines | ||
| 246 | 246 | |
| 247 | 247 | num = of_get_child_count(np); |
| 248 | 248 | |
| 249 | − dai_props = devm_kzalloc(dev, sizeof(*dai_props) * num, GFP_KERNEL); | |
| 250 | − dai_link = devm_kzalloc(dev, sizeof(*dai_link) * num, GFP_KERNEL); | |
| 249 | + dai_props = devm_kcalloc(dev, num, sizeof(*dai_props), GFP_KERNEL); | |
| 250 | + dai_link = devm_kcalloc(dev, num, sizeof(*dai_link), GFP_KERNEL); | |
| 251 | 251 | if (!dai_props || !dai_link) |
| 252 | 252 | return -ENOMEM; |
| 253 | 253 | |
| @@ -509,8 +509,8 @@ static int img_i2s_in_probe(struct platform_device *pdev) · 508 unmodified lines | ||
| 509 | 509 | |
| 510 | 510 | pm_runtime_put(&pdev->dev); |
| 511 | 511 | |
| 512 | − i2s->suspend_ch_ctl = devm_kzalloc(dev, | |
| 513 | − sizeof(*i2s->suspend_ch_ctl) * i2s->max_i2s_chan, GFP_KERNEL); | |
| 512 | + i2s->suspend_ch_ctl = devm_kcalloc(dev, | |
| 513 | + i2s->max_i2s_chan, sizeof(*i2s->suspend_ch_ctl), GFP_KERNEL); | |
| 514 | 514 | if (!i2s->suspend_ch_ctl) { |
| 515 | 515 | ret = -ENOMEM; |
| 516 | 516 | goto err_suspend; |
| @@ -479,8 +479,8 @@ static int img_i2s_out_probe(struct platform_device *pdev) · 478 unmodified lines | ||
| 479 | 479 | return PTR_ERR(i2s->clk_ref); |
| 480 | 480 | } |
| 481 | 481 | |
| 482 | − i2s->suspend_ch_ctl = devm_kzalloc(dev, | |
| 483 | − sizeof(*i2s->suspend_ch_ctl) * i2s->max_i2s_chan, GFP_KERNEL); | |
| 482 | + i2s->suspend_ch_ctl = devm_kcalloc(dev, | |
| 483 | + i2s->max_i2s_chan, sizeof(*i2s->suspend_ch_ctl), GFP_KERNEL); | |
| 484 | 484 | if (!i2s->suspend_ch_ctl) |
| 485 | 485 | return -ENOMEM; |
| 486 | 486 | |
| @@ -121,8 +121,8 @@ static int msg_empty_list_init(struct sst_generic_ipc *ipc) · 120 unmodified lines | ||
| 121 | 121 | { |
| 122 | 122 | int i; |
| 123 | 123 | |
| 124 | − ipc->msg = kzalloc(sizeof(struct ipc_message) * | |
| 125 | − IPC_EMPTY_LIST_SIZE, GFP_KERNEL); | |
| 124 | + ipc->msg = kcalloc(IPC_EMPTY_LIST_SIZE, sizeof(struct ipc_message), | |
| 125 | + GFP_KERNEL); | |
| 126 | 126 | if (ipc->msg == NULL) |
| 127 | 127 | return -ENOMEM; |
| 128 | 128 | |
| @@ -2428,8 +2428,10 @@ static int skl_tplg_get_token(struct device *dev, · 2427 unmodified lines | ||
| 2428 | 2428 | |
| 2429 | 2429 | case SKL_TKN_U8_DYN_IN_PIN: |
| 2430 | 2430 | if (!mconfig->m_in_pin) |
| 2431 | − mconfig->m_in_pin = devm_kzalloc(dev, MAX_IN_QUEUE * | |
| 2432 | − sizeof(*mconfig->m_in_pin), GFP_KERNEL); | |
| 2431 | + mconfig->m_in_pin = | |
| 2432 | + devm_kcalloc(dev, MAX_IN_QUEUE, | |
| 2433 | + sizeof(*mconfig->m_in_pin), | |
| 2434 | + GFP_KERNEL); | |
| 2433 | 2435 | if (!mconfig->m_in_pin) |
| 2434 | 2436 | return -ENOMEM; |
| 2435 | 2437 | |
| @@ -2439,8 +2441,10 @@ static int skl_tplg_get_token(struct device *dev, · 3 unmodified lines | ||
| 2439 | 2441 | |
| 2440 | 2442 | case SKL_TKN_U8_DYN_OUT_PIN: |
| 2441 | 2443 | if (!mconfig->m_out_pin) |
| 2442 | − mconfig->m_out_pin = devm_kzalloc(dev, MAX_IN_QUEUE * | |
| 2443 | − sizeof(*mconfig->m_in_pin), GFP_KERNEL); | |
| 2444 | + mconfig->m_out_pin = | |
| 2445 | + devm_kcalloc(dev, MAX_IN_QUEUE, | |
| 2446 | + sizeof(*mconfig->m_in_pin), | |
| 2447 | + GFP_KERNEL); | |
| 2444 | 2448 | if (!mconfig->m_out_pin) |
| 2445 | 2449 | return -ENOMEM; |
| 2446 | 2450 | |
| @@ -2852,14 +2856,14 @@ static int skl_tplg_get_pvt_data_v4(struct snd_soc_tplg_dapm_widget *tplg_w, · 405 unmodified lines | ||
| 2852 | 2856 | mconfig->time_slot = dfw->time_slot; |
| 2853 | 2857 | mconfig->formats_config.caps_size = dfw->caps.caps_size; |
| 2854 | 2858 | |
| 2855 | − mconfig->m_in_pin = devm_kzalloc(dev, | |
| 2856 | − MAX_IN_QUEUE * sizeof(*mconfig->m_in_pin), | |
| 2859 | + mconfig->m_in_pin = devm_kcalloc(dev, | |
| 2860 | + MAX_IN_QUEUE, sizeof(*mconfig->m_in_pin), | |
| 2857 | 2861 | GFP_KERNEL); |
| 2858 | 2862 | if (!mconfig->m_in_pin) |
| 2859 | 2863 | return -ENOMEM; |
| 2860 | 2864 | |
| 2861 | − mconfig->m_out_pin = devm_kzalloc(dev, | |
| 2862 | − MAX_OUT_QUEUE * sizeof(*mconfig->m_out_pin), | |
| 2865 | + mconfig->m_out_pin = devm_kcalloc(dev, | |
| 2866 | + MAX_OUT_QUEUE, sizeof(*mconfig->m_out_pin), | |
| 2863 | 2867 | GFP_KERNEL); |
| 2864 | 2868 | if (!mconfig->m_out_pin) |
| 2865 | 2869 | return -ENOMEM; |
| @@ -1347,7 +1347,8 @@ static int mt2701_afe_pcm_dev_probe(struct platform_device *pdev) · 1346 unmodified lines | ||
| 1347 | 1347 | afe->dev = &pdev->dev; |
| 1348 | 1348 | dev = afe->dev; |
| 1349 | 1349 | |
| 1350 | − afe_priv->i2s_path = devm_kzalloc(dev, afe_priv->soc->i2s_num * | |
| 1350 | + afe_priv->i2s_path = devm_kcalloc(dev, | |
| 1351 | + afe_priv->soc->i2s_num, | |
| 1351 | 1352 | sizeof(struct mt2701_i2s_path), |
| 1352 | 1353 | GFP_KERNEL); |
| 1353 | 1354 | if (!afe_priv->i2s_path) |
| @@ -425,8 +425,8 @@ static int asoc_mmp_sspa_probe(struct platform_device *pdev) · 424 unmodified lines | ||
| 425 | 425 | if (priv->sspa == NULL) |
| 426 | 426 | return -ENOMEM; |
| 427 | 427 | |
| 428 | − priv->dma_params = devm_kzalloc(&pdev->dev, | |
| 429 | − 2 * sizeof(struct snd_dmaengine_dai_dma_data), | |
| 428 | + priv->dma_params = devm_kcalloc(&pdev->dev, | |
| 429 | + 2, sizeof(struct snd_dmaengine_dai_dma_data), | |
| 430 | 430 | GFP_KERNEL); |
| 431 | 431 | if (priv->dma_params == NULL) |
| 432 | 432 | return -ENOMEM; |
| @@ -462,7 +462,7 @@ static int rockchip_sound_of_parse_dais(struct device *dev, · 461 unmodified lines | ||
| 462 | 462 | num_routes = 0; |
| 463 | 463 | for (i = 0; i < ARRAY_SIZE(rockchip_routes); i++) |
| 464 | 464 | num_routes += rockchip_routes[i].num_routes; |
| 465 | − routes = devm_kzalloc(dev, num_routes * sizeof(*routes), | |
| 465 | + routes = devm_kcalloc(dev, num_routes, sizeof(*routes), | |
| 466 | 466 | GFP_KERNEL); |
| 467 | 467 | if (!routes) |
| 468 | 468 | return -ENOMEM; |
| @@ -155,7 +155,7 @@ int rsnd_cmd_probe(struct rsnd_priv *priv) · 154 unmodified lines | ||
| 155 | 155 | if (!nr) |
| 156 | 156 | return 0; |
| 157 | 157 | |
| 158 | − cmd = devm_kzalloc(dev, sizeof(*cmd) * nr, GFP_KERNEL); | |
| 158 | + cmd = devm_kcalloc(dev, nr, sizeof(*cmd), GFP_KERNEL); | |
| 159 | 159 | if (!cmd) |
| 160 | 160 | return -ENOMEM; |
| 161 | 161 | |
| @@ -1110,8 +1110,8 @@ static int rsnd_dai_probe(struct rsnd_priv *priv) · 1109 unmodified lines | ||
| 1110 | 1110 | if (!nr) |
| 1111 | 1111 | return -EINVAL; |
| 1112 | 1112 | |
| 1113 | − rdrv = devm_kzalloc(dev, sizeof(*rdrv) * nr, GFP_KERNEL); | |
| 1114 | − rdai = devm_kzalloc(dev, sizeof(*rdai) * nr, GFP_KERNEL); | |
| 1113 | + rdrv = devm_kcalloc(dev, nr, sizeof(*rdrv), GFP_KERNEL); | |
| 1114 | + rdai = devm_kcalloc(dev, nr, sizeof(*rdai), GFP_KERNEL); | |
| 1115 | 1115 | if (!rdrv || !rdai) |
| 1116 | 1116 | return -ENOMEM; |
| 1117 | 1117 | |
| @@ -378,7 +378,7 @@ int rsnd_ctu_probe(struct rsnd_priv *priv) · 377 unmodified lines | ||
| 378 | 378 | goto rsnd_ctu_probe_done; |
| 379 | 379 | } |
| 380 | 380 | |
| 381 | − ctu = devm_kzalloc(dev, sizeof(*ctu) * nr, GFP_KERNEL); | |
| 381 | + ctu = devm_kcalloc(dev, nr, sizeof(*ctu), GFP_KERNEL); | |
| 382 | 382 | if (!ctu) { |
| 383 | 383 | ret = -ENOMEM; |
| 384 | 384 | goto rsnd_ctu_probe_done; |
| @@ -344,7 +344,7 @@ int rsnd_dvc_probe(struct rsnd_priv *priv) · 343 unmodified lines | ||
| 344 | 344 | goto rsnd_dvc_probe_done; |
| 345 | 345 | } |
| 346 | 346 | |
| 347 | − dvc = devm_kzalloc(dev, sizeof(*dvc) * nr, GFP_KERNEL); | |
| 347 | + dvc = devm_kcalloc(dev, nr, sizeof(*dvc), GFP_KERNEL); | |
| 348 | 348 | if (!dvc) { |
| 349 | 349 | ret = -ENOMEM; |
| 350 | 350 | goto rsnd_dvc_probe_done; |
| @@ -294,7 +294,7 @@ int rsnd_mix_probe(struct rsnd_priv *priv) · 293 unmodified lines | ||
| 294 | 294 | goto rsnd_mix_probe_done; |
| 295 | 295 | } |
| 296 | 296 | |
| 297 | − mix = devm_kzalloc(dev, sizeof(*mix) * nr, GFP_KERNEL); | |
| 297 | + mix = devm_kcalloc(dev, nr, sizeof(*mix), GFP_KERNEL); | |
| 298 | 298 | if (!mix) { |
| 299 | 299 | ret = -ENOMEM; |
| 300 | 300 | goto rsnd_mix_probe_done; |
| @@ -575,7 +575,7 @@ int rsnd_src_probe(struct rsnd_priv *priv) · 574 unmodified lines | ||
| 575 | 575 | goto rsnd_src_probe_done; |
| 576 | 576 | } |
| 577 | 577 | |
| 578 | − src = devm_kzalloc(dev, sizeof(*src) * nr, GFP_KERNEL); | |
| 578 | + src = devm_kcalloc(dev, nr, sizeof(*src), GFP_KERNEL); | |
| 579 | 579 | if (!src) { |
| 580 | 580 | ret = -ENOMEM; |
| 581 | 581 | goto rsnd_src_probe_done; |
| @@ -1116,7 +1116,7 @@ int rsnd_ssi_probe(struct rsnd_priv *priv) · 1115 unmodified lines | ||
| 1116 | 1116 | goto rsnd_ssi_probe_done; |
| 1117 | 1117 | } |
| 1118 | 1118 | |
| 1119 | − ssi = devm_kzalloc(dev, sizeof(*ssi) * nr, GFP_KERNEL); | |
| 1119 | + ssi = devm_kcalloc(dev, nr, sizeof(*ssi), GFP_KERNEL); | |
| 1120 | 1120 | if (!ssi) { |
| 1121 | 1121 | ret = -ENOMEM; |
| 1122 | 1122 | goto rsnd_ssi_probe_done; |
| @@ -258,7 +258,7 @@ int rsnd_ssiu_probe(struct rsnd_priv *priv) · 257 unmodified lines | ||
| 258 | 258 | |
| 259 | 259 | /* same number to SSI */ |
| 260 | 260 | nr = priv->ssi_nr; |
| 261 | − ssiu = devm_kzalloc(dev, sizeof(*ssiu) * nr, GFP_KERNEL); | |
| 261 | + ssiu = devm_kcalloc(dev, nr, sizeof(*ssiu), GFP_KERNEL); | |
| 262 | 262 | if (!ssiu) |
| 263 | 263 | return -ENOMEM; |
| 264 | 264 | |
| @@ -373,8 +373,8 @@ static struct snd_soc_pcm_runtime *soc_new_pcm_runtime( · 372 unmodified lines | ||
| 373 | 373 | if (!rtd->dai_link->ops) |
| 374 | 374 | rtd->dai_link->ops = &null_snd_soc_ops; |
| 375 | 375 | |
| 376 | − rtd->codec_dais = kzalloc(sizeof(struct snd_soc_dai *) * | |
| 377 | − dai_link->num_codecs, | |
| 376 | + rtd->codec_dais = kcalloc(dai_link->num_codecs, | |
| 377 | + sizeof(struct snd_soc_dai *), | |
| 378 | 378 | GFP_KERNEL); |
| 379 | 379 | if (!rtd->codec_dais) { |
| 380 | 380 | kfree(rtd); |
| @@ -3354,7 +3354,7 @@ int snd_soc_of_parse_audio_routing(struct snd_soc_card *card, · 2973 unmodified lines | ||
| 3354 | 3354 | return -EINVAL; |
| 3355 | 3355 | } |
| 3356 | 3356 | |
| 3357 | − routes = devm_kzalloc(card->dev, num_routes * sizeof(*routes), | |
| 3357 | + routes = devm_kcalloc(card->dev, num_routes, sizeof(*routes), | |
| 3358 | 3358 | GFP_KERNEL); |
| 3359 | 3359 | if (!routes) { |
| 3360 | 3360 | dev_err(card->dev, |
| @@ -3678,8 +3678,8 @@ int snd_soc_of_get_dai_link_codecs(struct device *dev, · 317 unmodified lines | ||
| 3678 | 3678 | dev_err(dev, "Bad phandle in 'sound-dai'\n"); |
| 3679 | 3679 | return num_codecs; |
| 3680 | 3680 | } |
| 3681 | − component = devm_kzalloc(dev, | |
| 3682 | − sizeof *component * num_codecs, | |
| 3681 | + component = devm_kcalloc(dev, | |
| 3682 | + num_codecs, sizeof(*component), | |
| 3683 | 3683 | GFP_KERNEL); |
| 3684 | 3684 | if (!component) |
| 3685 | 3685 | return -ENOMEM; |
| @@ -3055,7 +3055,7 @@ int snd_soc_dapm_new_widgets(struct snd_soc_card *card) · 3054 unmodified lines | ||
| 3055 | 3055 | continue; |
| 3056 | 3056 | |
| 3057 | 3057 | if (w->num_kcontrols) { |
| 3058 | − w->kcontrols = kzalloc(w->num_kcontrols * | |
| 3058 | + w->kcontrols = kcalloc(w->num_kcontrols, | |
| 3059 | 3059 | sizeof(struct snd_kcontrol *), |
| 3060 | 3060 | GFP_KERNEL); |
| 3061 | 3061 | if (!w->kcontrols) { |
| @@ -885,7 +885,7 @@ static int soc_tplg_denum_create_texts(struct soc_enum *se, · 884 unmodified lines | ||
| 885 | 885 | int i, ret; |
| 886 | 886 | |
| 887 | 887 | se->dobj.control.dtexts = |
| 888 | − kzalloc(sizeof(char *) * ec->items, GFP_KERNEL); | |
| 888 | + kcalloc(ec->items, sizeof(char *), GFP_KERNEL); | |
| 889 | 889 | if (se->dobj.control.dtexts == NULL) |
| 890 | 890 | return -ENOMEM; |
| 891 | 891 | |
| @@ -624,15 +624,17 @@ int uniphier_aio_probe(struct platform_device *pdev) · 623 unmodified lines | ||
| 624 | 624 | return PTR_ERR(chip->rst); |
| 625 | 625 | |
| 626 | 626 | chip->num_aios = chip->chip_spec->num_dais; |
| 627 | − chip->aios = devm_kzalloc(dev, | |
| 628 | − sizeof(struct uniphier_aio) * chip->num_aios, | |
| 627 | + chip->aios = devm_kcalloc(dev, | |
| 628 | + chip->num_aios, sizeof(struct uniphier_aio), | |
| 629 | 629 | GFP_KERNEL); |
| 630 | 630 | if (!chip->aios) |
| 631 | 631 | return -ENOMEM; |
| 632 | 632 | |
| 633 | 633 | chip->num_plls = chip->chip_spec->num_plls; |
| 634 | − chip->plls = devm_kzalloc(dev, sizeof(struct uniphier_aio_pll) * | |
| 635 | − chip->num_plls, GFP_KERNEL); | |
| 634 | + chip->plls = devm_kcalloc(dev, | |
| 635 | + chip->num_plls, | |
| 636 | + sizeof(struct uniphier_aio_pll), | |
| 637 | + GFP_KERNEL); | |
| 636 | 638 | if (!chip->plls) |
| 637 | 639 | return -ENOMEM; |
| 638 | 640 | memcpy(chip->plls, chip->chip_spec->plls, |
| @@ -591,12 +591,14 @@ static int usb6fire_pcm_buffers_init(struct pcm_runtime *rt) · 590 unmodified lines | ||
| 591 | 591 | int i; |
| 592 | 592 | |
| 593 | 593 | for (i = 0; i < PCM_N_URBS; i++) { |
| 594 | − rt->out_urbs[i].buffer = kzalloc(PCM_N_PACKETS_PER_URB | |
| 595 | − * PCM_MAX_PACKET_SIZE, GFP_KERNEL); | |
| 594 | + rt->out_urbs[i].buffer = kcalloc(PCM_MAX_PACKET_SIZE, | |
| 595 | + PCM_N_PACKETS_PER_URB, | |
| 596 | + GFP_KERNEL); | |
| 596 | 597 | if (!rt->out_urbs[i].buffer) |
| 597 | 598 | return -ENOMEM; |
| 598 | − rt->in_urbs[i].buffer = kzalloc(PCM_N_PACKETS_PER_URB | |
| 599 | − * PCM_MAX_PACKET_SIZE, GFP_KERNEL); | |
| 599 | + rt->in_urbs[i].buffer = kcalloc(PCM_MAX_PACKET_SIZE, | |
| 600 | + PCM_N_PACKETS_PER_URB, | |
| 601 | + GFP_KERNEL); | |
| 600 | 602 | if (!rt->in_urbs[i].buffer) |
| 601 | 603 | return -ENOMEM; |
| 602 | 604 | } |
| @@ -728,7 +728,7 @@ static struct urb **alloc_urbs(struct snd_usb_caiaqdev *cdev, int dir, int *ret) · 727 unmodified lines | ||
| 728 | 728 | usb_sndisocpipe(usb_dev, ENDPOINT_PLAYBACK) : |
| 729 | 729 | usb_rcvisocpipe(usb_dev, ENDPOINT_CAPTURE); |
| 730 | 730 | |
| 731 | − urbs = kmalloc(N_URBS * sizeof(*urbs), GFP_KERNEL); | |
| 731 | + urbs = kmalloc_array(N_URBS, sizeof(*urbs), GFP_KERNEL); | |
| 732 | 732 | if (!urbs) { |
| 733 | 733 | *ret = -ENOMEM; |
| 734 | 734 | return NULL; |
| @@ -742,7 +742,8 @@ static struct urb **alloc_urbs(struct snd_usb_caiaqdev *cdev, int dir, int *ret) · 7 unmodified lines | ||
| 742 | 742 | } |
| 743 | 743 | |
| 744 | 744 | urbs[i]->transfer_buffer = |
| 745 | − kmalloc(FRAMES_PER_URB * BYTES_PER_FRAME, GFP_KERNEL); | |
| 745 | + kmalloc_array(BYTES_PER_FRAME, FRAMES_PER_URB, | |
| 746 | + GFP_KERNEL); | |
| 746 | 747 | if (!urbs[i]->transfer_buffer) { |
| 747 | 748 | *ret = -ENOMEM; |
| 748 | 749 | return urbs; |
| @@ -857,7 +858,7 @@ int snd_usb_caiaq_audio_init(struct snd_usb_caiaqdev *cdev) · 108 unmodified lines | ||
| 857 | 858 | &snd_usb_caiaq_ops); |
| 858 | 859 | |
| 859 | 860 | cdev->data_cb_info = |
| 860 | − kmalloc(sizeof(struct snd_usb_caiaq_cb_info) * N_URBS, | |
| 861 | + kmalloc_array(N_URBS, sizeof(struct snd_usb_caiaq_cb_info), | |
| 861 | 862 | GFP_KERNEL); |
| 862 | 863 | |
| 863 | 864 | if (!cdev->data_cb_info) |
| @@ -188,7 +188,8 @@ static int parse_audio_format_rates_v1(struct snd_usb_audio *chip, struct audiof · 187 unmodified lines | ||
| 188 | 188 | */ |
| 189 | 189 | int r, idx; |
| 190 | 190 | |
| 191 | − fp->rate_table = kmalloc(sizeof(int) * nr_rates, GFP_KERNEL); | |
| 191 | + fp->rate_table = kmalloc_array(nr_rates, sizeof(int), | |
| 192 | + GFP_KERNEL); | |
| 192 | 193 | if (fp->rate_table == NULL) |
| 193 | 194 | return -ENOMEM; |
| 194 | 195 | |
| @@ -362,7 +363,7 @@ static int parse_audio_format_rates_v2v3(struct snd_usb_audio *chip, · 167 unmodified lines | ||
| 362 | 363 | goto err_free; |
| 363 | 364 | } |
| 364 | 365 | |
| 365 | − fp->rate_table = kmalloc(sizeof(int) * fp->nr_rates, GFP_KERNEL); | |
| 366 | + fp->rate_table = kmalloc_array(fp->nr_rates, sizeof(int), GFP_KERNEL); | |
| 366 | 367 | if (!fp->rate_table) { |
| 367 | 368 | ret = -ENOMEM; |
| 368 | 369 | goto err_free; |
| @@ -264,8 +264,8 @@ int line6_create_audio_in_urbs(struct snd_line6_pcm *line6pcm) · 263 unmodified lines | ||
| 264 | 264 | struct usb_line6 *line6 = line6pcm->line6; |
| 265 | 265 | int i; |
| 266 | 266 | |
| 267 | − line6pcm->in.urbs = kzalloc( | |
| 268 | − sizeof(struct urb *) * line6->iso_buffers, GFP_KERNEL); | |
| 267 | + line6pcm->in.urbs = kcalloc(line6->iso_buffers, sizeof(struct urb *), | |
| 268 | + GFP_KERNEL); | |
| 269 | 269 | if (line6pcm->in.urbs == NULL) |
| 270 | 270 | return -ENOMEM; |
| 271 | 271 | |
| @@ -158,8 +158,10 @@ static int line6_buffer_acquire(struct snd_line6_pcm *line6pcm, · 157 unmodified lines | ||
| 158 | 158 | |
| 159 | 159 | /* Invoked multiple times in a row so allocate once only */ |
| 160 | 160 | if (!test_and_set_bit(type, &pstr->opened) && !pstr->buffer) { |
| 161 | − pstr->buffer = kmalloc(line6pcm->line6->iso_buffers * | |
| 162 | − LINE6_ISO_PACKETS * pkt_size, GFP_KERNEL); | |
| 161 | + pstr->buffer = | |
| 162 | + kmalloc(array3_size(line6pcm->line6->iso_buffers, | |
| 163 | + LINE6_ISO_PACKETS, pkt_size), | |
| 164 | + GFP_KERNEL); | |
| 163 | 165 | if (!pstr->buffer) |
| 164 | 166 | return -ENOMEM; |
| 165 | 167 | } |
| @@ -409,8 +409,8 @@ int line6_create_audio_out_urbs(struct snd_line6_pcm *line6pcm) · 408 unmodified lines | ||
| 409 | 409 | struct usb_line6 *line6 = line6pcm->line6; |
| 410 | 410 | int i; |
| 411 | 411 | |
| 412 | − line6pcm->out.urbs = kzalloc( | |
| 413 | − sizeof(struct urb *) * line6->iso_buffers, GFP_KERNEL); | |
| 412 | + line6pcm->out.urbs = kcalloc(line6->iso_buffers, sizeof(struct urb *), | |
| 413 | + GFP_KERNEL); | |
| 414 | 414 | if (line6pcm->out.urbs == NULL) |
| 415 | 415 | return -ENOMEM; |
| 416 | 416 | |
| @@ -2515,7 +2515,7 @@ static int parse_audio_selector_unit(struct mixer_build *state, int unitid, · 2514 unmodified lines | ||
| 2515 | 2515 | cval->control = (desc->bDescriptorSubtype == UAC2_CLOCK_SELECTOR) ? |
| 2516 | 2516 | UAC2_CX_CLOCK_SELECTOR : UAC2_SU_SELECTOR; |
| 2517 | 2517 | |
| 2518 | − namelist = kmalloc(sizeof(char *) * desc->bNrInPins, GFP_KERNEL); | |
| 2518 | + namelist = kmalloc_array(desc->bNrInPins, sizeof(char *), GFP_KERNEL); | |
| 2519 | 2519 | if (!namelist) { |
| 2520 | 2520 | kfree(cval); |
| 2521 | 2521 | return -ENOMEM; |
| @@ -1123,7 +1123,7 @@ static int snd_usb_pcm_check_knot(struct snd_pcm_runtime *runtime, · 1122 unmodified lines | ||
| 1123 | 1123 | return 0; |
| 1124 | 1124 | |
| 1125 | 1125 | subs->rate_list.list = rate_list = |
| 1126 | − kmalloc(sizeof(int) * count, GFP_KERNEL); | |
| 1126 | + kmalloc_array(count, sizeof(int), GFP_KERNEL); | |
| 1127 | 1127 | if (!subs->rate_list.list) |
| 1128 | 1128 | return -ENOMEM; |
| 1129 | 1129 | subs->rate_list.count = count; |
| @@ -266,7 +266,9 @@ int usX2Y_AsyncSeq04_init(struct usX2Ydev *usX2Y) · 265 unmodified lines | ||
| 266 | 266 | int err = 0, |
| 267 | 267 | i; |
| 268 | 268 | |
| 269 | − if (NULL == (usX2Y->AS04.buffer = kmalloc(URB_DataLen_AsyncSeq*URBS_AsyncSeq, GFP_KERNEL))) { | |
| 269 | + usX2Y->AS04.buffer = kmalloc_array(URBS_AsyncSeq, | |
| 270 | + URB_DataLen_AsyncSeq, GFP_KERNEL); | |
| 271 | + if (NULL == usX2Y->AS04.buffer) { | |
| 270 | 272 | err = -ENOMEM; |
| 271 | 273 | } else |
| 272 | 274 | for (i = 0; i < URBS_AsyncSeq; ++i) { |
| @@ -436,7 +436,9 @@ static int usX2Y_urbs_allocate(struct snd_usX2Y_substream *subs) · 435 unmodified lines | ||
| 436 | 436 | } |
| 437 | 437 | if (!is_playback && !(*purb)->transfer_buffer) { |
| 438 | 438 | /* allocate a capture buffer per urb */ |
| 439 | − (*purb)->transfer_buffer = kmalloc(subs->maxpacksize * nr_of_packs(), GFP_KERNEL); | |
| 439 | + (*purb)->transfer_buffer = | |
| 440 | + kmalloc_array(subs->maxpacksize, | |
| 441 | + nr_of_packs(), GFP_KERNEL); | |
| 440 | 442 | if (NULL == (*purb)->transfer_buffer) { |
| 441 | 443 | usX2Y_urbs_release(subs); |
| 442 | 444 | return -ENOMEM; |
| @@ -662,7 +664,8 @@ static int usX2Y_rate_set(struct usX2Ydev *usX2Y, int rate) · 219 unmodified lines | ||
| 662 | 664 | err = -ENOMEM; |
| 663 | 665 | goto cleanup; |
| 664 | 666 | } |
| 665 | − usbdata = kmalloc(sizeof(int) * NOOF_SETRATE_URBS, GFP_KERNEL); | |
| 667 | + usbdata = kmalloc_array(NOOF_SETRATE_URBS, sizeof(int), | |
| 668 | + GFP_KERNEL); | |
| 666 | 669 | if (NULL == usbdata) { |
| 667 | 670 | err = -ENOMEM; |
| 668 | 671 | goto cleanup; |
| @@ -126,7 +126,7 @@ int vgic_v4_init(struct kvm *kvm) · 125 unmodified lines | ||
| 126 | 126 | |
| 127 | 127 | nr_vcpus = atomic_read(&kvm->online_vcpus); |
| 128 | 128 | |
| 129 | − dist->its_vm.vpes = kzalloc(sizeof(*dist->its_vm.vpes) * nr_vcpus, | |
| 129 | + dist->its_vm.vpes = kcalloc(nr_vcpus, sizeof(*dist->its_vm.vpes), | |
| 130 | 130 | GFP_KERNEL); |
| 131 | 131 | if (!dist->its_vm.vpes) |
| 132 | 132 | return -ENOMEM; |
| @@ -3076,7 +3076,8 @@ static long kvm_vm_ioctl(struct file *filp, · 3075 unmodified lines | ||
| 3076 | 3076 | goto out; |
| 3077 | 3077 | if (routing.nr) { |
| 3078 | 3078 | r = -ENOMEM; |
| 3079 | − entries = vmalloc(routing.nr * sizeof(*entries)); | |
| 3079 | + entries = vmalloc(array_size(sizeof(*entries), | |
| 3080 | + routing.nr)); | |
| 3080 | 3081 | if (!entries) |
| 3081 | 3082 | goto out; |
| 3082 | 3083 | r = -EFAULT; |