64 files changed, 195 insertions, 163 deletions

diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index bd53a71f6b00..63e3844c5bec 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -2418,7 +2418,7 @@ struct bond_vlan_tag *bond_verify_device_path(struct net_device *start_dev,
         struct list_head  *iter;
 
         if (start_dev == end_dev) {
-                tags = kzalloc(sizeof(*tags) * (level + 1), GFP_ATOMIC);
+                tags = kcalloc(level + 1, sizeof(*tags), GFP_ATOMIC);
                 if (!tags)
                         return ERR_PTR(-ENOMEM);
                 tags[level].vlan_proto = VLAN_N_VID;
diff --git a/drivers/net/can/grcan.c b/drivers/net/can/grcan.c
index 2d3046afa80d..7eec1d9f86a0 100644
--- a/drivers/net/can/grcan.c
+++ b/drivers/net/can/grcan.c
@@ -1057,7 +1057,7 @@ static int grcan_open(struct net_device *dev)
                 return err;
         }
 
-        priv->echo_skb = kzalloc(dma->tx.size * sizeof(*priv->echo_skb),
+        priv->echo_skb = kcalloc(dma->tx.size, sizeof(*priv->echo_skb),
                                  GFP_KERNEL);
         if (!priv->echo_skb) {
                 err = -ENOMEM;
@@ -1066,7 +1066,7 @@ static int grcan_open(struct net_device *dev)
         priv->can.echo_skb_max = dma->tx.size;
         priv->can.echo_skb = priv->echo_skb;
 
-        priv->txdlc = kzalloc(dma->tx.size * sizeof(*priv->txdlc), GFP_KERNEL);
+        priv->txdlc = kcalloc(dma->tx.size, sizeof(*priv->txdlc), GFP_KERNEL);
         if (!priv->txdlc) {
                 err = -ENOMEM;
                 goto exit_free_echo_skb;
diff --git a/drivers/net/can/slcan.c b/drivers/net/can/slcan.c
index 89d60d8e467c..aa97dbc797b6 100644
--- a/drivers/net/can/slcan.c
+++ b/drivers/net/can/slcan.c
@@ -703,7 +703,7 @@ static int __init slcan_init(void)
         pr_info("slcan: serial line CAN interface driver\n");
         pr_info("slcan: %d dynamic interface channels.\n", maxdev);
 
-        slcan_devs = kzalloc(sizeof(struct net_device *)*maxdev, GFP_KERNEL);
+        slcan_devs = kcalloc(maxdev, sizeof(struct net_device *), GFP_KERNEL);
         if (!slcan_devs)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/broadcom/bcm63xx_enet.c b/drivers/net/ethernet/broadcom/bcm63xx_enet.c
index 14a59e51db67..897302adc38e 100644
--- a/drivers/net/ethernet/broadcom/bcm63xx_enet.c
+++ b/drivers/net/ethernet/broadcom/bcm63xx_enet.c
@@ -2150,7 +2150,7 @@ static int bcm_enetsw_open(struct net_device *dev)
         priv->tx_desc_alloc_size = size;
         priv->tx_desc_cpu = p;
 
-        priv->tx_skb = kzalloc(sizeof(struct sk_buff *) * priv->tx_ring_size,
+        priv->tx_skb = kcalloc(priv->tx_ring_size, sizeof(struct sk_buff *),
                                GFP_KERNEL);
         if (!priv->tx_skb) {
                 dev_err(kdev, "cannot allocate rx skb queue\n");
@@ -2164,7 +2164,7 @@ static int bcm_enetsw_open(struct net_device *dev)
         spin_lock_init(&priv->tx_lock);
 
         /* init & fill rx ring with skbs */
-        priv->rx_skb = kzalloc(sizeof(struct sk_buff *) * priv->rx_ring_size,
+        priv->rx_skb = kcalloc(priv->rx_ring_size, sizeof(struct sk_buff *),
                                GFP_KERNEL);
         if (!priv->rx_skb) {
                 dev_err(kdev, "cannot allocate rx skb queue\n");
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c
index ffa7959f6b31..dc77bfded865 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c
@@ -571,7 +571,7 @@ int bnx2x_vf_mcast(struct bnx2x *bp, struct bnx2x_virtf *vf,
         else
                 set_bit(RAMROD_COMP_WAIT, &mcast.ramrod_flags);
         if (mc_num) {
-                mc = kzalloc(mc_num * sizeof(struct bnx2x_mcast_list_elem),
+                mc = kcalloc(mc_num, sizeof(struct bnx2x_mcast_list_elem),
                              GFP_KERNEL);
                 if (!mc) {
                         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,
            num_vfs_param, iov->nr_virtfn);
 
         /* allocate the vf array */
-        bp->vfdb->vfs = kzalloc(sizeof(struct bnx2x_virtf) *
-                                BNX2X_NR_VIRTFN(bp), GFP_KERNEL);
+        bp->vfdb->vfs = kcalloc(BNX2X_NR_VIRTFN(bp),
+                                sizeof(struct bnx2x_virtf),
+                                GFP_KERNEL);
         if (!bp->vfdb->vfs) {
                 BNX2X_ERR("failed to allocate vf array\n");
                 err = -ENOMEM;
@@ -1278,9 +1279,9 @@ int bnx2x_iov_init_one(struct bnx2x *bp, int int_mode_param,
         }
 
         /* allocate the queue arrays for all VFs */
-        bp->vfdb->vfqs = kzalloc(
-                BNX2X_MAX_NUM_VF_QUEUES * sizeof(struct bnx2x_vf_queue),
-                GFP_KERNEL);
+        bp->vfdb->vfqs = kcalloc(BNX2X_MAX_NUM_VF_QUEUES,
+                                 sizeof(struct bnx2x_vf_queue),
+                                 GFP_KERNEL);
 
         if (!bp->vfdb->vfqs) {
                 BNX2X_ERR("failed to allocate vf queue array\n");
diff --git a/drivers/net/ethernet/broadcom/cnic.c b/drivers/net/ethernet/broadcom/cnic.c
index 8bc126a156e8..30273a7717e2 100644
--- a/drivers/net/ethernet/broadcom/cnic.c
+++ b/drivers/net/ethernet/broadcom/cnic.c
@@ -660,7 +660,7 @@ static int cnic_init_id_tbl(struct cnic_id_tbl *id_tbl, u32 size, u32 start_id,
         id_tbl->max = size;
         id_tbl->next = next;
         spin_lock_init(&id_tbl->lock);
-        id_tbl->table = kzalloc(DIV_ROUND_UP(size, 32) * 4, GFP_KERNEL);
+        id_tbl->table = kcalloc(DIV_ROUND_UP(size, 32), 4, GFP_KERNEL);
         if (!id_tbl->table)
                 return -ENOMEM;
 
@@ -1255,13 +1255,13 @@ static int cnic_alloc_bnx2x_resc(struct cnic_dev *dev)
                         cp->fcoe_init_cid = 0x10;
         }
 
-        cp->iscsi_tbl = kzalloc(sizeof(struct cnic_iscsi) * MAX_ISCSI_TBL_SZ,
+        cp->iscsi_tbl = kcalloc(MAX_ISCSI_TBL_SZ, sizeof(struct cnic_iscsi),
                                 GFP_KERNEL);
         if (!cp->iscsi_tbl)
                 goto error;
 
-        cp->ctx_tbl = kzalloc(sizeof(struct cnic_context) *
-                                cp->max_cid_space, GFP_KERNEL);
+        cp->ctx_tbl = kcalloc(cp->max_cid_space, sizeof(struct cnic_context),
+                              GFP_KERNEL);
         if (!cp->ctx_tbl)
                 goto error;
 
@@ -4100,7 +4100,7 @@ static int cnic_cm_alloc_mem(struct cnic_dev *dev)
         struct cnic_local *cp = dev->cnic_priv;
         u32 port_id;
 
-        cp->csk_tbl = kzalloc(sizeof(struct cnic_sock) * MAX_CM_SK_TBL_SZ,
+        cp->csk_tbl = kcalloc(MAX_CM_SK_TBL_SZ, sizeof(struct cnic_sock),
                               GFP_KERNEL);
         if (!cp->csk_tbl)
                 return -ENOMEM;
diff --git a/drivers/net/ethernet/broadcom/tg3.c b/drivers/net/ethernet/broadcom/tg3.c
index 9f59b1270a7c..3be87efdc93d 100644
--- a/drivers/net/ethernet/broadcom/tg3.c
+++ b/drivers/net/ethernet/broadcom/tg3.c
@@ -8631,8 +8631,9 @@ static int tg3_mem_tx_acquire(struct tg3 *tp)
                 tnapi++;
 
         for (i = 0; i < tp->txq_cnt; i++, tnapi++) {
-                tnapi->tx_buffers = kzalloc(sizeof(struct tg3_tx_ring_info) *
-                                            TG3_TX_RING_SIZE, GFP_KERNEL);
+                tnapi->tx_buffers = kcalloc(TG3_TX_RING_SIZE,
+                                            sizeof(struct tg3_tx_ring_info),
+                                            GFP_KERNEL);
                 if (!tnapi->tx_buffers)
                         goto err_out;
 
diff --git a/drivers/net/ethernet/brocade/bna/bnad.c b/drivers/net/ethernet/brocade/bna/bnad.c
index 69cc3e0119d6..ea5f32ea308a 100644
--- a/drivers/net/ethernet/brocade/bna/bnad.c
+++ b/drivers/net/ethernet/brocade/bna/bnad.c
@@ -3141,7 +3141,7 @@ bnad_set_rx_ucast_fltr(struct bnad *bnad)
         if (uc_count > bna_attr(&bnad->bna)->num_ucmac)
                 goto mode_default;
 
-        mac_list = kzalloc(uc_count * ETH_ALEN, GFP_ATOMIC);
+        mac_list = kcalloc(ETH_ALEN, uc_count, GFP_ATOMIC);
         if (mac_list == NULL)
                 goto mode_default;
 
@@ -3182,7 +3182,7 @@ bnad_set_rx_mcast_fltr(struct bnad *bnad)
         if (mc_count > bna_attr(&bnad->bna)->num_mcmac)
                 goto mode_allmulti;
 
-        mac_list = kzalloc((mc_count + 1) * ETH_ALEN, GFP_ATOMIC);
+        mac_list = kcalloc(mc_count + 1, ETH_ALEN, GFP_ATOMIC);
 
         if (mac_list == NULL)
                 goto mode_allmulti;
diff --git a/drivers/net/ethernet/calxeda/xgmac.c b/drivers/net/ethernet/calxeda/xgmac.c
index 2bd7c638b178..2c63afff1382 100644
--- a/drivers/net/ethernet/calxeda/xgmac.c
+++ b/drivers/net/ethernet/calxeda/xgmac.c
@@ -739,7 +739,7 @@ static int xgmac_dma_desc_rings_init(struct net_device *dev)
 
         netdev_dbg(priv->dev, "mtu [%d] bfsize [%d]\n", dev->mtu, bfsize);
 
-        priv->rx_skbuff = kzalloc(sizeof(struct sk_buff *) * DMA_RX_RING_SZ,
+        priv->rx_skbuff = kcalloc(DMA_RX_RING_SZ, sizeof(struct sk_buff *),
                                   GFP_KERNEL);
         if (!priv->rx_skbuff)
                 return -ENOMEM;
@@ -752,7 +752,7 @@ static int xgmac_dma_desc_rings_init(struct net_device *dev)
         if (!priv->dma_rx)
                 goto err_dma_rx;
 
-        priv->tx_skbuff = kzalloc(sizeof(struct sk_buff *) * DMA_TX_RING_SZ,
+        priv->tx_skbuff = kcalloc(DMA_TX_RING_SZ, sizeof(struct sk_buff *),
                                   GFP_KERNEL);
         if (!priv->tx_skbuff)
                 goto err_tx_skb;
diff --git a/drivers/net/ethernet/cavium/thunder/nicvf_queues.c b/drivers/net/ethernet/cavium/thunder/nicvf_queues.c
index d42704d07484..187a249ff2d1 100644
--- a/drivers/net/ethernet/cavium/thunder/nicvf_queues.c
+++ b/drivers/net/ethernet/cavium/thunder/nicvf_queues.c
@@ -292,8 +292,8 @@ static int  nicvf_init_rbdr(struct nicvf *nic, struct rbdr *rbdr,
                 rbdr->is_xdp = true;
         }
         rbdr->pgcnt = roundup_pow_of_two(rbdr->pgcnt);
-        rbdr->pgcache = kzalloc(sizeof(*rbdr->pgcache) *
-                                rbdr->pgcnt, GFP_KERNEL);
+        rbdr->pgcache = kcalloc(rbdr->pgcnt, sizeof(*rbdr->pgcache),
+                                GFP_KERNEL);
         if (!rbdr->pgcache)
                 return -ENOMEM;
         rbdr->pgidx = 0;
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.c b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.c
index a95cde0fadf7..4bc211093c98 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.c
@@ -561,13 +561,13 @@ int t4_uld_mem_alloc(struct adapter *adap)
         if (!adap->uld)
                 return -ENOMEM;
 
-        s->uld_rxq_info = kzalloc(CXGB4_ULD_MAX *
+        s->uld_rxq_info = kcalloc(CXGB4_ULD_MAX,
                                   sizeof(struct sge_uld_rxq_info *),
                                   GFP_KERNEL);
         if (!s->uld_rxq_info)
                 goto err_uld;
 
-        s->uld_txq_info = kzalloc(CXGB4_TX_MAX *
+        s->uld_txq_info = kcalloc(CXGB4_TX_MAX,
                                   sizeof(struct sge_uld_txq_info *),
                                   GFP_KERNEL);
         if (!s->uld_txq_info)
diff --git a/drivers/net/ethernet/cortina/gemini.c b/drivers/net/ethernet/cortina/gemini.c
index ff9eb45f67f8..6d7404f66f84 100644
--- a/drivers/net/ethernet/cortina/gemini.c
+++ b/drivers/net/ethernet/cortina/gemini.c
@@ -910,8 +910,8 @@ static int geth_setup_freeq(struct gemini_ethernet *geth)
         }
 
         /* Allocate a mapping to page look-up index */
-        geth->freeq_pages = kzalloc(pages * sizeof(*geth->freeq_pages),
-                                   GFP_KERNEL);
+        geth->freeq_pages = kcalloc(pages, sizeof(*geth->freeq_pages),
+                                    GFP_KERNEL);
         if (!geth->freeq_pages)
                 goto err_freeq;
         geth->num_freeq_pages = pages;
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_enet.c b/drivers/net/ethernet/hisilicon/hns/hns_enet.c
index 1ccb6443d2ed..ef9ef703d13a 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_enet.c
+++ b/drivers/net/ethernet/hisilicon/hns/hns_enet.c
@@ -2197,7 +2197,8 @@ static int hns_nic_init_ring_data(struct hns_nic_priv *priv)
                 return -EINVAL;
         }
 
-        priv->ring_data = kzalloc(h->q_num * sizeof(*priv->ring_data) * 2,
+        priv->ring_data = kzalloc(array3_size(h->q_num,
+                                              sizeof(*priv->ring_data), 2),
                                   GFP_KERNEL);
         if (!priv->ring_data)
                 return -ENOMEM;
diff --git a/drivers/net/ethernet/intel/e1000e/netdev.c b/drivers/net/ethernet/intel/e1000e/netdev.c
index acf1e8b52b8e..3ba0c90e7055 100644
--- a/drivers/net/ethernet/intel/e1000e/netdev.c
+++ b/drivers/net/ethernet/intel/e1000e/netdev.c
@@ -3312,7 +3312,7 @@ static int e1000e_write_mc_addr_list(struct net_device *netdev)
                 return 0;
         }
 
-        mta_list = kzalloc(netdev_mc_count(netdev) * ETH_ALEN, GFP_ATOMIC);
+        mta_list = kcalloc(netdev_mc_count(netdev), ETH_ALEN, GFP_ATOMIC);
         if (!mta_list)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/intel/igb/igb_main.c b/drivers/net/ethernet/intel/igb/igb_main.c
index c33821d2afb3..f707709969ac 100644
--- a/drivers/net/ethernet/intel/igb/igb_main.c
+++ b/drivers/net/ethernet/intel/igb/igb_main.c
@@ -3763,8 +3763,9 @@ static int igb_sw_init(struct igb_adapter *adapter)
         /* Assume MSI-X interrupts, will be checked during IRQ allocation */
         adapter->flags |= IGB_FLAG_HAS_MSIX;
 
-        adapter->mac_table = kzalloc(sizeof(struct igb_mac_addr) *
-                                     hw->mac.rar_entry_count, GFP_ATOMIC);
+        adapter->mac_table = kcalloc(hw->mac.rar_entry_count,
+                                     sizeof(struct igb_mac_addr),
+                                     GFP_ATOMIC);
         if (!adapter->mac_table)
                 return -ENOMEM;
 
@@ -4752,7 +4753,7 @@ static int igb_write_mc_addr_list(struct net_device *netdev)
                 return 0;
         }
 
-        mta_list = kzalloc(netdev_mc_count(netdev) * 6, GFP_ATOMIC);
+        mta_list = kcalloc(netdev_mc_count(netdev), 6, GFP_ATOMIC);
         if (!mta_list)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
index 4929f7265598..0b1ba3ae159c 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
@@ -6034,8 +6034,8 @@ static int ixgbe_sw_init(struct ixgbe_adapter *adapter,
         for (i = 1; i < IXGBE_MAX_LINK_HANDLE; i++)
                 adapter->jump_tables[i] = NULL;
 
-        adapter->mac_table = kzalloc(sizeof(struct ixgbe_mac_addr) *
-                                     hw->mac.num_rar_entries,
+        adapter->mac_table = kcalloc(hw->mac.num_rar_entries,
+                                     sizeof(struct ixgbe_mac_addr),
                                      GFP_ATOMIC);
         if (!adapter->mac_table)
                 return -ENOMEM;
diff --git a/drivers/net/ethernet/jme.c b/drivers/net/ethernet/jme.c
index 8a165842fa85..06ff185eb188 100644
--- a/drivers/net/ethernet/jme.c
+++ b/drivers/net/ethernet/jme.c
@@ -589,8 +589,9 @@ jme_setup_tx_resources(struct jme_adapter *jme)
         atomic_set(&txring->next_to_clean, 0);
         atomic_set(&txring->nr_free, jme->tx_ring_size);
 
-        txring->bufinf          = kzalloc(sizeof(struct jme_buffer_info) *
-                                        jme->tx_ring_size, GFP_ATOMIC);
+        txring->bufinf          = kcalloc(jme->tx_ring_size,
+                                                sizeof(struct jme_buffer_info),
+                                                GFP_ATOMIC);
         if (unlikely(!(txring->bufinf)))
                 goto err_free_txring;
 
@@ -838,8 +839,9 @@ jme_setup_rx_resources(struct jme_adapter *jme)
         rxring->next_to_use     = 0;
         atomic_set(&rxring->next_to_clean, 0);
 
-        rxring->bufinf          = kzalloc(sizeof(struct jme_buffer_info) *
-                                        jme->rx_ring_size, GFP_ATOMIC);
+        rxring->bufinf          = kcalloc(jme->rx_ring_size,
+                                                sizeof(struct jme_buffer_info),
+                                                GFP_ATOMIC);
         if (unlikely(!(rxring->bufinf)))
                 goto err_free_rxring;
 
diff --git a/drivers/net/ethernet/mellanox/mlx4/alloc.c b/drivers/net/ethernet/mellanox/mlx4/alloc.c
index 6dabd983e7e0..4bdf25059542 100644
--- a/drivers/net/ethernet/mellanox/mlx4/alloc.c
+++ b/drivers/net/ethernet/mellanox/mlx4/alloc.c
@@ -185,8 +185,8 @@ int mlx4_bitmap_init(struct mlx4_bitmap *bitmap, u32 num, u32 mask,
         bitmap->avail = num - reserved_top - reserved_bot;
         bitmap->effective_len = bitmap->avail;
         spin_lock_init(&bitmap->lock);
-        bitmap->table = kzalloc(BITS_TO_LONGS(bitmap->max) *
-                                sizeof(long), GFP_KERNEL);
+        bitmap->table = kcalloc(BITS_TO_LONGS(bitmap->max), sizeof(long),
+                                GFP_KERNEL);
         if (!bitmap->table)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/mellanox/mlx4/cmd.c b/drivers/net/ethernet/mellanox/mlx4/cmd.c
index 03375c705df7..e65bc3c95630 100644
--- a/drivers/net/ethernet/mellanox/mlx4/cmd.c
+++ b/drivers/net/ethernet/mellanox/mlx4/cmd.c
@@ -2377,20 +2377,23 @@ int mlx4_multi_func_init(struct mlx4_dev *dev)
                 struct mlx4_vf_admin_state *vf_admin;
 
                 priv->mfunc.master.slave_state =
-                        kzalloc(dev->num_slaves *
-                                sizeof(struct mlx4_slave_state), GFP_KERNEL);
+                        kcalloc(dev->num_slaves,
+                                sizeof(struct mlx4_slave_state),
+                                GFP_KERNEL);
                 if (!priv->mfunc.master.slave_state)
                         goto err_comm;
 
                 priv->mfunc.master.vf_admin =
-                        kzalloc(dev->num_slaves *
-                                sizeof(struct mlx4_vf_admin_state), GFP_KERNEL);
+                        kcalloc(dev->num_slaves,
+                                sizeof(struct mlx4_vf_admin_state),
+                                GFP_KERNEL);
                 if (!priv->mfunc.master.vf_admin)
                         goto err_comm_admin;
 
                 priv->mfunc.master.vf_oper =
-                        kzalloc(dev->num_slaves *
-                                sizeof(struct mlx4_vf_oper_state), GFP_KERNEL);
+                        kcalloc(dev->num_slaves,
+                                sizeof(struct mlx4_vf_oper_state),
+                                GFP_KERNEL);
                 if (!priv->mfunc.master.vf_oper)
                         goto err_comm_oper;
 
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_netdev.c b/drivers/net/ethernet/mellanox/mlx4/en_netdev.c
index 9670b33fc9b1..65eb06e017e4 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_netdev.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_netdev.c
@@ -2229,13 +2229,15 @@ static int mlx4_en_copy_priv(struct mlx4_en_priv *dst,
                 if (!dst->tx_ring_num[t])
                         continue;
 
-                dst->tx_ring[t] = kzalloc(sizeof(struct mlx4_en_tx_ring *) *
-                                          MAX_TX_RINGS, GFP_KERNEL);
+                dst->tx_ring[t] = kcalloc(MAX_TX_RINGS,
+                                          sizeof(struct mlx4_en_tx_ring *),
+                                          GFP_KERNEL);
                 if (!dst->tx_ring[t])
                         goto err_free_tx;
 
-                dst->tx_cq[t] = kzalloc(sizeof(struct mlx4_en_cq *) *
-                                        MAX_TX_RINGS, GFP_KERNEL);
+                dst->tx_cq[t] = kcalloc(MAX_TX_RINGS,
+                                        sizeof(struct mlx4_en_cq *),
+                                        GFP_KERNEL);
                 if (!dst->tx_cq[t]) {
                         kfree(dst->tx_ring[t]);
                         goto err_free_tx;
@@ -3320,14 +3322,16 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
                 if (!priv->tx_ring_num[t])
                         continue;
 
-                priv->tx_ring[t] = kzalloc(sizeof(struct mlx4_en_tx_ring *) *
-                                           MAX_TX_RINGS, GFP_KERNEL);
+                priv->tx_ring[t] = kcalloc(MAX_TX_RINGS,
+                                           sizeof(struct mlx4_en_tx_ring *),
+                                           GFP_KERNEL);
                 if (!priv->tx_ring[t]) {
                         err = -ENOMEM;
                         goto out;
                 }
-                priv->tx_cq[t] = kzalloc(sizeof(struct mlx4_en_cq *) *
-                                         MAX_TX_RINGS, GFP_KERNEL);
+                priv->tx_cq[t] = kcalloc(MAX_TX_RINGS,
+                                         sizeof(struct mlx4_en_cq *),
+                                         GFP_KERNEL);
                 if (!priv->tx_cq[t]) {
                         err = -ENOMEM;
                         goto out;
diff --git a/drivers/net/ethernet/mellanox/mlx4/main.c b/drivers/net/ethernet/mellanox/mlx4/main.c
index 0a30d81aab3b..872014702fc1 100644
--- a/drivers/net/ethernet/mellanox/mlx4/main.c
+++ b/drivers/net/ethernet/mellanox/mlx4/main.c
@@ -2982,7 +2982,8 @@ static int mlx4_init_steering(struct mlx4_dev *dev)
         int num_entries = dev->caps.num_ports;
         int i, j;
 
-        priv->steer = kzalloc(sizeof(struct mlx4_steer) * num_entries, GFP_KERNEL);
+        priv->steer = kcalloc(num_entries, sizeof(struct mlx4_steer),
+                              GFP_KERNEL);
         if (!priv->steer)
                 return -ENOMEM;
 
@@ -3103,7 +3104,7 @@ static u64 mlx4_enable_sriov(struct mlx4_dev *dev, struct pci_dev *pdev,
                 }
         }
 
-        dev->dev_vfs = kzalloc(total_vfs * sizeof(*dev->dev_vfs), GFP_KERNEL);
+        dev->dev_vfs = kcalloc(total_vfs, sizeof(*dev->dev_vfs), GFP_KERNEL);
         if (NULL == dev->dev_vfs) {
                 mlx4_err(dev, "Failed to allocate memory for VFs\n");
                 goto disable_sriov;
diff --git a/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c b/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c
index b0e11255a355..7b1b5ac986d0 100644
--- a/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c
+++ b/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c
@@ -487,7 +487,7 @@ int mlx4_init_resource_tracker(struct mlx4_dev *dev)
         int max_vfs_guarantee_counter = get_max_gauranteed_vfs_counter(dev);
 
         priv->mfunc.master.res_tracker.slave_list =
-                kzalloc(dev->num_slaves * sizeof(struct slave_list),
+                kcalloc(dev->num_slaves, sizeof(struct slave_list),
                         GFP_KERNEL);
         if (!priv->mfunc.master.res_tracker.slave_list)
                 return -ENOMEM;
@@ -514,14 +514,14 @@ int mlx4_init_resource_tracker(struct mlx4_dev *dev)
                                                       sizeof(int),
                                                       GFP_KERNEL);
                 if (i == RES_MAC || i == RES_VLAN)
-                        res_alloc->allocated = kzalloc(MLX4_MAX_PORTS *
-                                                       (dev->persist->num_vfs
-                                                       + 1) *
-                                                       sizeof(int), GFP_KERNEL);
+                        res_alloc->allocated =
+                                kcalloc(MLX4_MAX_PORTS *
+                                                (dev->persist->num_vfs + 1),
+                                        sizeof(int), GFP_KERNEL);
                 else
-                        res_alloc->allocated = kzalloc((dev->persist->
-                                                        num_vfs + 1) *
-                                                       sizeof(int), GFP_KERNEL);
+                        res_alloc->allocated =
+                                kcalloc(dev->persist->num_vfs + 1,
+                                        sizeof(int), GFP_KERNEL);
                 /* Reduce the sink counter */
                 if (i == RES_COUNTER)
                         res_alloc->res_free = dev->caps.max_counters - 1;
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/fpga/ipsec.c b/drivers/net/ethernet/mellanox/mlx5/core/fpga/ipsec.c
index a0433b48e833..5645a4facad2 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/fpga/ipsec.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/fpga/ipsec.c
@@ -381,7 +381,7 @@ int mlx5_fpga_ipsec_counters_read(struct mlx5_core_dev *mdev, u64 *counters,
 
         count = mlx5_fpga_ipsec_counters_count(mdev);
 
-        data = kzalloc(sizeof(*data) * count * 2, GFP_KERNEL);
+        data = kzalloc(array3_size(sizeof(*data), count, 2), GFP_KERNEL);
         if (!data) {
                 ret = -ENOMEM;
                 goto out;
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/lib/clock.c b/drivers/net/ethernet/mellanox/mlx5/core/lib/clock.c
index 857035583ccd..1e062e6b2587 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/lib/clock.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/lib/clock.c
@@ -394,8 +394,9 @@ static int mlx5_init_pin_config(struct mlx5_clock *clock)
         int i;
 
         clock->ptp_info.pin_config =
-                        kzalloc(sizeof(*clock->ptp_info.pin_config) *
-                                clock->ptp_info.n_pins, GFP_KERNEL);
+                        kcalloc(clock->ptp_info.n_pins,
+                                sizeof(*clock->ptp_info.pin_config),
+                                GFP_KERNEL);
         if (!clock->ptp_info.pin_config)
                 return -ENOMEM;
         clock->ptp_info.enable = mlx5_ptp_enable;
diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum_qdisc.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum_qdisc.c
index 91262b0573e3..cad603c35271 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum_qdisc.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum_qdisc.c
@@ -740,7 +740,8 @@ int mlxsw_sp_tc_qdisc_init(struct mlxsw_sp_port *mlxsw_sp_port)
         mlxsw_sp_port->root_qdisc->prio_bitmap = 0xff;
         mlxsw_sp_port->root_qdisc->tclass_num = MLXSW_SP_PORT_DEFAULT_TCLASS;
 
-        mlxsw_sp_qdisc = kzalloc(sizeof(*mlxsw_sp_qdisc) * IEEE_8021QAZ_MAX_TCS,
+        mlxsw_sp_qdisc = kcalloc(IEEE_8021QAZ_MAX_TCS,
+                                 sizeof(*mlxsw_sp_qdisc),
                                  GFP_KERNEL);
         if (!mlxsw_sp_qdisc)
                 goto err_tclass_qdiscs_init;
diff --git a/drivers/net/ethernet/micrel/ksz884x.c b/drivers/net/ethernet/micrel/ksz884x.c
index 52207508744c..b72d1bd11296 100644
--- a/drivers/net/ethernet/micrel/ksz884x.c
+++ b/drivers/net/ethernet/micrel/ksz884x.c
@@ -4372,7 +4372,7 @@ static void ksz_update_timer(struct ksz_timer_info *info)
  */
 static int ksz_alloc_soft_desc(struct ksz_desc_info *desc_info, int transmit)
 {
-        desc_info->ring = kzalloc(sizeof(struct ksz_desc) * desc_info->alloc,
+        desc_info->ring = kcalloc(desc_info->alloc, sizeof(struct ksz_desc),
                                   GFP_KERNEL);
         if (!desc_info->ring)
                 return 1;
diff --git a/drivers/net/ethernet/neterion/vxge/vxge-config.c b/drivers/net/ethernet/neterion/vxge/vxge-config.c
index c60da9e8bf14..8d0295655933 100644
--- a/drivers/net/ethernet/neterion/vxge/vxge-config.c
+++ b/drivers/net/ethernet/neterion/vxge/vxge-config.c
@@ -2220,22 +2220,22 @@ __vxge_hw_channel_allocate(struct __vxge_hw_vpath_handle *vph,
         channel->length = length;
         channel->vp_id = vp_id;
 
-        channel->work_arr = kzalloc(sizeof(void *)*length, GFP_KERNEL);
+        channel->work_arr = kcalloc(length, sizeof(void *), GFP_KERNEL);
         if (channel->work_arr == NULL)
                 goto exit1;
 
-        channel->free_arr = kzalloc(sizeof(void *)*length, GFP_KERNEL);
+        channel->free_arr = kcalloc(length, sizeof(void *), GFP_KERNEL);
         if (channel->free_arr == NULL)
                 goto exit1;
         channel->free_ptr = length;
 
-        channel->reserve_arr = kzalloc(sizeof(void *)*length, GFP_KERNEL);
+        channel->reserve_arr = kcalloc(length, sizeof(void *), GFP_KERNEL);
         if (channel->reserve_arr == NULL)
                 goto exit1;
         channel->reserve_ptr = length;
         channel->reserve_top = 0;
 
-        channel->orig_arr = kzalloc(sizeof(void *)*length, GFP_KERNEL);
+        channel->orig_arr = kcalloc(length, sizeof(void *), GFP_KERNEL);
         if (channel->orig_arr == NULL)
                 goto exit1;
 
diff --git a/drivers/net/ethernet/neterion/vxge/vxge-main.c b/drivers/net/ethernet/neterion/vxge/vxge-main.c
index a8918bb7c802..5ae3fa82909f 100644
--- a/drivers/net/ethernet/neterion/vxge/vxge-main.c
+++ b/drivers/net/ethernet/neterion/vxge/vxge-main.c
@@ -3429,8 +3429,8 @@ static int vxge_device_register(struct __vxge_hw_device *hldev,
         vxge_initialize_ethtool_ops(ndev);
 
         /* Allocate memory for vpath */
-        vdev->vpaths = kzalloc((sizeof(struct vxge_vpath)) *
-                                no_of_vpath, GFP_KERNEL);
+        vdev->vpaths = kcalloc(no_of_vpath, sizeof(struct vxge_vpath),
+                               GFP_KERNEL);
         if (!vdev->vpaths) {
                 vxge_debug_init(VXGE_ERR,
                         "%s: vpath memory allocation failed",
diff --git a/drivers/net/ethernet/pasemi/pasemi_mac.c b/drivers/net/ethernet/pasemi/pasemi_mac.c
index 07a2eb3781b1..8a31a02c9f47 100644
--- a/drivers/net/ethernet/pasemi/pasemi_mac.c
+++ b/drivers/net/ethernet/pasemi/pasemi_mac.c
@@ -390,8 +390,9 @@ static int pasemi_mac_setup_rx_resources(const struct net_device *dev)
         spin_lock_init(&ring->lock);
 
         ring->size = RX_RING_SIZE;
-        ring->ring_info = kzalloc(sizeof(struct pasemi_mac_buffer) *
-                                  RX_RING_SIZE, GFP_KERNEL);
+        ring->ring_info = kcalloc(RX_RING_SIZE,
+                                  sizeof(struct pasemi_mac_buffer),
+                                  GFP_KERNEL);
 
         if (!ring->ring_info)
                 goto out_ring_info;
@@ -473,8 +474,9 @@ pasemi_mac_setup_tx_resources(const struct net_device *dev)
         spin_lock_init(&ring->lock);
 
         ring->size = TX_RING_SIZE;
-        ring->ring_info = kzalloc(sizeof(struct pasemi_mac_buffer) *
-                                  TX_RING_SIZE, GFP_KERNEL);
+        ring->ring_info = kcalloc(TX_RING_SIZE,
+                                  sizeof(struct pasemi_mac_buffer),
+                                  GFP_KERNEL);
         if (!ring->ring_info)
                 goto out_ring_info;
 
diff --git a/drivers/net/ethernet/qlogic/qed/qed_debug.c b/drivers/net/ethernet/qlogic/qed/qed_debug.c
index b9ec460dd996..a14e48489029 100644
--- a/drivers/net/ethernet/qlogic/qed/qed_debug.c
+++ b/drivers/net/ethernet/qlogic/qed/qed_debug.c
@@ -6617,7 +6617,8 @@ static enum dbg_status qed_mcp_trace_alloc_meta(struct qed_hwfn *p_hwfn,
 
         /* Read no. of modules and allocate memory for their pointers */
         meta->modules_num = qed_read_byte_from_buf(meta_buf_bytes, &offset);
-        meta->modules = kzalloc(meta->modules_num * sizeof(char *), GFP_KERNEL);
+        meta->modules = kcalloc(meta->modules_num, sizeof(char *),
+                                GFP_KERNEL);
         if (!meta->modules)
                 return DBG_STATUS_VIRT_MEM_ALLOC_FAILED;
 
@@ -6645,7 +6646,7 @@ static enum dbg_status qed_mcp_trace_alloc_meta(struct qed_hwfn *p_hwfn,
 
         /* Read number of formats and allocate memory for all formats */
         meta->formats_num = qed_read_dword_from_buf(meta_buf_bytes, &offset);
-        meta->formats = kzalloc(meta->formats_num *
+        meta->formats = kcalloc(meta->formats_num,
                                 sizeof(struct mcp_trace_format),
                                 GFP_KERNEL);
         if (!meta->formats)
diff --git a/drivers/net/ethernet/qlogic/qed/qed_dev.c b/drivers/net/ethernet/qlogic/qed/qed_dev.c
index b285edc8d6a1..329781cda77f 100644
--- a/drivers/net/ethernet/qlogic/qed/qed_dev.c
+++ b/drivers/net/ethernet/qlogic/qed/qed_dev.c
@@ -814,26 +814,26 @@ static int qed_alloc_qm_data(struct qed_hwfn *p_hwfn)
         if (rc)
                 goto alloc_err;
 
-        qm_info->qm_pq_params = kzalloc(sizeof(*qm_info->qm_pq_params) *
-                                        qed_init_qm_get_num_pqs(p_hwfn),
+        qm_info->qm_pq_params = kcalloc(qed_init_qm_get_num_pqs(p_hwfn),
+                                        sizeof(*qm_info->qm_pq_params),
                                         GFP_KERNEL);
         if (!qm_info->qm_pq_params)
                 goto alloc_err;
 
-        qm_info->qm_vport_params = kzalloc(sizeof(*qm_info->qm_vport_params) *
-                                           qed_init_qm_get_num_vports(p_hwfn),
+        qm_info->qm_vport_params = kcalloc(qed_init_qm_get_num_vports(p_hwfn),
+                                           sizeof(*qm_info->qm_vport_params),
                                            GFP_KERNEL);
         if (!qm_info->qm_vport_params)
                 goto alloc_err;
 
-        qm_info->qm_port_params = kzalloc(sizeof(*qm_info->qm_port_params) *
-                                          p_hwfn->cdev->num_ports_in_engine,
+        qm_info->qm_port_params = kcalloc(p_hwfn->cdev->num_ports_in_engine,
+                                          sizeof(*qm_info->qm_port_params),
                                           GFP_KERNEL);
         if (!qm_info->qm_port_params)
                 goto alloc_err;
 
-        qm_info->wfq_data = kzalloc(sizeof(*qm_info->wfq_data) *
-                                    qed_init_qm_get_num_vports(p_hwfn),
+        qm_info->wfq_data = kcalloc(qed_init_qm_get_num_vports(p_hwfn),
+                                    sizeof(*qm_info->wfq_data),
                                     GFP_KERNEL);
         if (!qm_info->wfq_data)
                 goto alloc_err;
diff --git a/drivers/net/ethernet/qlogic/qed/qed_init_ops.c b/drivers/net/ethernet/qlogic/qed/qed_init_ops.c
index 3bb76da6baa2..d9ab5add27a8 100644
--- a/drivers/net/ethernet/qlogic/qed/qed_init_ops.c
+++ b/drivers/net/ethernet/qlogic/qed/qed_init_ops.c
@@ -149,12 +149,12 @@ int qed_init_alloc(struct qed_hwfn *p_hwfn)
         if (IS_VF(p_hwfn->cdev))
                 return 0;
 
-        rt_data->b_valid = kzalloc(sizeof(bool) * RUNTIME_ARRAY_SIZE,
+        rt_data->b_valid = kcalloc(RUNTIME_ARRAY_SIZE, sizeof(bool),
                                    GFP_KERNEL);
         if (!rt_data->b_valid)
                 return -ENOMEM;
 
-        rt_data->init_val = kzalloc(sizeof(u32) * RUNTIME_ARRAY_SIZE,
+        rt_data->init_val = kcalloc(RUNTIME_ARRAY_SIZE, sizeof(u32),
                                     GFP_KERNEL);
         if (!rt_data->init_val) {
                 kfree(rt_data->b_valid);
diff --git a/drivers/net/ethernet/qlogic/qed/qed_l2.c b/drivers/net/ethernet/qlogic/qed/qed_l2.c
index 1f6ac848109d..de1c70843efd 100644
--- a/drivers/net/ethernet/qlogic/qed/qed_l2.c
+++ b/drivers/net/ethernet/qlogic/qed/qed_l2.c
@@ -98,7 +98,7 @@ int qed_l2_alloc(struct qed_hwfn *p_hwfn)
                 p_l2_info->queues = max_t(u8, rx, tx);
         }
 
-        pp_qids = kzalloc(sizeof(unsigned long *) * p_l2_info->queues,
+        pp_qids = kcalloc(p_l2_info->queues, sizeof(unsigned long *),
                           GFP_KERNEL);
         if (!pp_qids)
                 return -ENOMEM;
diff --git a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c
index 1b5f7d57b6f8..8c6724063231 100644
--- a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c
+++ b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c
@@ -1025,15 +1025,17 @@ int qlcnic_init_pci_info(struct qlcnic_adapter *adapter)
 
         act_pci_func = ahw->total_nic_func;
 
-        adapter->npars = kzalloc(sizeof(struct qlcnic_npar_info) *
-                                 act_pci_func, GFP_KERNEL);
+        adapter->npars = kcalloc(act_pci_func,
+                                 sizeof(struct qlcnic_npar_info),
+                                 GFP_KERNEL);
         if (!adapter->npars) {
                 ret = -ENOMEM;
                 goto err_pci_info;
         }
 
-        adapter->eswitch = kzalloc(sizeof(struct qlcnic_eswitch) *
-                                QLCNIC_NIU_MAX_XG_PORTS, GFP_KERNEL);
+        adapter->eswitch = kcalloc(QLCNIC_NIU_MAX_XG_PORTS,
+                                   sizeof(struct qlcnic_eswitch),
+                                   GFP_KERNEL);
         if (!adapter->eswitch) {
                 ret = -ENOMEM;
                 goto err_npars;
diff --git a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_sriov_common.c b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_sriov_common.c
index c58180f40844..0c744b9c6e0a 100644
--- a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_sriov_common.c
+++ b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_sriov_common.c
@@ -157,8 +157,8 @@ int qlcnic_sriov_init(struct qlcnic_adapter *adapter, int num_vfs)
         adapter->ahw->sriov = sriov;
         sriov->num_vfs = num_vfs;
         bc = &sriov->bc;
-        sriov->vf_info = kzalloc(sizeof(struct qlcnic_vf_info) *
-                                 num_vfs, GFP_KERNEL);
+        sriov->vf_info = kcalloc(num_vfs, sizeof(struct qlcnic_vf_info),
+                                 GFP_KERNEL);
         if (!sriov->vf_info) {
                 err = -ENOMEM;
                 goto qlcnic_free_sriov;
@@ -450,7 +450,7 @@ static int qlcnic_sriov_set_guest_vlan_mode(struct qlcnic_adapter *adapter,
                 return 0;
 
         num_vlans = sriov->num_allowed_vlans;
-        sriov->allowed_vlans = kzalloc(sizeof(u16) * num_vlans, GFP_KERNEL);
+        sriov->allowed_vlans = kcalloc(num_vlans, sizeof(u16), GFP_KERNEL);
         if (!sriov->allowed_vlans)
                 return -ENOMEM;
 
@@ -706,7 +706,7 @@ static inline int qlcnic_sriov_alloc_bc_trans(struct qlcnic_bc_trans **trans)
 static inline int qlcnic_sriov_alloc_bc_msg(struct qlcnic_bc_hdr **hdr,
                                             u32 size)
 {
-        *hdr = kzalloc(sizeof(struct qlcnic_bc_hdr) * size, GFP_ATOMIC);
+        *hdr = kcalloc(size, sizeof(struct qlcnic_bc_hdr), GFP_ATOMIC);
         if (!*hdr)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/socionext/netsec.c b/drivers/net/ethernet/socionext/netsec.c
index ce8071fc90c4..e080d3e7c582 100644
--- a/drivers/net/ethernet/socionext/netsec.c
+++ b/drivers/net/ethernet/socionext/netsec.c
@@ -973,7 +973,7 @@ static int netsec_alloc_dring(struct netsec_priv *priv, enum ring_id id)
                 goto err;
         }
 
-        dring->desc = kzalloc(DESC_NUM * sizeof(*dring->desc), GFP_KERNEL);
+        dring->desc = kcalloc(DESC_NUM, sizeof(*dring->desc), GFP_KERNEL);
         if (!dring->desc) {
                 ret = -ENOMEM;
                 goto err;
diff --git a/drivers/net/ethernet/toshiba/ps3_gelic_wireless.c b/drivers/net/ethernet/toshiba/ps3_gelic_wireless.c
index eed18f88bdff..302079e22b06 100644
--- a/drivers/net/ethernet/toshiba/ps3_gelic_wireless.c
+++ b/drivers/net/ethernet/toshiba/ps3_gelic_wireless.c
@@ -2320,8 +2320,9 @@ static struct net_device *gelic_wl_alloc(struct gelic_card *card)
         pr_debug("%s: wl=%p port=%p\n", __func__, wl, port);
 
         /* allocate scan list */
-        wl->networks = kzalloc(sizeof(struct gelic_wl_scan_info) *
-                               GELIC_WL_BSS_MAX_ENT, GFP_KERNEL);
+        wl->networks = kcalloc(GELIC_WL_BSS_MAX_ENT,
+                               sizeof(struct gelic_wl_scan_info),
+                               GFP_KERNEL);
 
         if (!wl->networks)
                 goto fail_bss;
diff --git a/drivers/net/phy/dp83640.c b/drivers/net/phy/dp83640.c
index a6c87793d899..79e9b103188b 100644
--- a/drivers/net/phy/dp83640.c
+++ b/drivers/net/phy/dp83640.c
@@ -1097,8 +1097,9 @@ static struct dp83640_clock *dp83640_clock_get_bus(struct mii_bus *bus)
         if (!clock)
                 goto out;
 
-        clock->caps.pin_config = kzalloc(sizeof(struct ptp_pin_desc) *
-                                         DP83640_N_PINS, GFP_KERNEL);
+        clock->caps.pin_config = kcalloc(DP83640_N_PINS,
+                                         sizeof(struct ptp_pin_desc),
+                                         GFP_KERNEL);
         if (!clock->caps.pin_config) {
                 kfree(clock);
                 clock = NULL;
diff --git a/drivers/net/slip/slip.c b/drivers/net/slip/slip.c
index 8940417c30e5..b008266e91ea 100644
--- a/drivers/net/slip/slip.c
+++ b/drivers/net/slip/slip.c
@@ -1307,7 +1307,7 @@ static int __init slip_init(void)
         printk(KERN_INFO "SLIP linefill/keepalive option.\n");
 #endif
 
-        slip_devs = kzalloc(sizeof(struct net_device *)*slip_maxdev,
+        slip_devs = kcalloc(slip_maxdev, sizeof(struct net_device *),
                                                                 GFP_KERNEL);
         if (!slip_devs)
                 return -ENOMEM;
diff --git a/drivers/net/team/team.c b/drivers/net/team/team.c
index ca0af0e15a2c..b070959737ff 100644
--- a/drivers/net/team/team.c
+++ b/drivers/net/team/team.c
@@ -280,7 +280,7 @@ static int __team_options_register(struct team *team,
         struct team_option **dst_opts;
         int err;
 
-        dst_opts = kzalloc(sizeof(struct team_option *) * option_count,
+        dst_opts = kcalloc(option_count, sizeof(struct team_option *),
                            GFP_KERNEL);
         if (!dst_opts)
                 return -ENOMEM;
diff --git a/drivers/net/usb/smsc95xx.c b/drivers/net/usb/smsc95xx.c
index 309b88acd3d0..06b4d290784d 100644
--- a/drivers/net/usb/smsc95xx.c
+++ b/drivers/net/usb/smsc95xx.c
@@ -1661,7 +1661,7 @@ static int smsc95xx_suspend(struct usb_interface *intf, pm_message_t message)
         }
 
         if (pdata->wolopts & (WAKE_BCAST | WAKE_MCAST | WAKE_ARP | WAKE_UCAST)) {
-                u32 *filter_mask = kzalloc(sizeof(u32) * 32, GFP_KERNEL);
+                u32 *filter_mask = kcalloc(32, sizeof(u32), GFP_KERNEL);
                 u32 command[2];
                 u32 offset[2];
                 u32 crc[4];
diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index 15b9a83bbd9d..b6c9a2af3732 100644
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -2552,7 +2552,7 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
                     virtio_has_feature(vi->vdev, VIRTIO_NET_F_CTRL_VQ);
 
         /* Allocate space for find_vqs parameters */
-        vqs = kzalloc(total_vqs * sizeof(*vqs), GFP_KERNEL);
+        vqs = kcalloc(total_vqs, sizeof(*vqs), GFP_KERNEL);
         if (!vqs)
                 goto err_vq;
         callbacks = kmalloc_array(total_vqs, sizeof(*callbacks), GFP_KERNEL);
@@ -2562,7 +2562,7 @@ static int virtnet_find_vqs(struct virtnet_info *vi)
         if (!names)
                 goto err_names;
         if (!vi->big_packets || vi->mergeable_rx_bufs) {
-                ctx = kzalloc(total_vqs * sizeof(*ctx), GFP_KERNEL);
+                ctx = kcalloc(total_vqs, sizeof(*ctx), GFP_KERNEL);
                 if (!ctx)
                         goto err_ctx;
         } else {
@@ -2626,10 +2626,10 @@ static int virtnet_alloc_queues(struct virtnet_info *vi)
         vi->ctrl = kzalloc(sizeof(*vi->ctrl), GFP_KERNEL);
         if (!vi->ctrl)
                 goto err_ctrl;
-        vi->sq = kzalloc(sizeof(*vi->sq) * vi->max_queue_pairs, GFP_KERNEL);
+        vi->sq = kcalloc(vi->max_queue_pairs, sizeof(*vi->sq), GFP_KERNEL);
         if (!vi->sq)
                 goto err_sq;
-        vi->rq = kzalloc(sizeof(*vi->rq) * vi->max_queue_pairs, GFP_KERNEL);
+        vi->rq = kcalloc(vi->max_queue_pairs, sizeof(*vi->rq), GFP_KERNEL);
         if (!vi->rq)
                 goto err_rq;
 
diff --git a/drivers/net/wan/fsl_ucc_hdlc.c b/drivers/net/wan/fsl_ucc_hdlc.c
index 4205dfd19da3..9b09c9d0d0fb 100644
--- a/drivers/net/wan/fsl_ucc_hdlc.c
+++ b/drivers/net/wan/fsl_ucc_hdlc.c
@@ -198,12 +198,14 @@ static int uhdlc_init(struct ucc_hdlc_private *priv)
                 goto free_tx_bd;
         }
 
-        priv->rx_skbuff = kzalloc(priv->rx_ring_size * sizeof(*priv->rx_skbuff),
+        priv->rx_skbuff = kcalloc(priv->rx_ring_size,
+                                  sizeof(*priv->rx_skbuff),
                                   GFP_KERNEL);
         if (!priv->rx_skbuff)
                 goto free_ucc_pram;
 
-        priv->tx_skbuff = kzalloc(priv->tx_ring_size * sizeof(*priv->tx_skbuff),
+        priv->tx_skbuff = kcalloc(priv->tx_ring_size,
+                                  sizeof(*priv->tx_skbuff),
                                   GFP_KERNEL);
         if (!priv->tx_skbuff)
                 goto free_rx_skbuff;
diff --git a/drivers/net/wireless/ath/ath10k/htt_rx.c b/drivers/net/wireless/ath/ath10k/htt_rx.c
index bd23f6940488..c72d8af122a2 100644
--- a/drivers/net/wireless/ath/ath10k/htt_rx.c
+++ b/drivers/net/wireless/ath/ath10k/htt_rx.c
@@ -582,7 +582,7 @@ int ath10k_htt_rx_alloc(struct ath10k_htt *htt)
         }
 
         htt->rx_ring.netbufs_ring =
-                kzalloc(htt->rx_ring.size * sizeof(struct sk_buff *),
+                kcalloc(htt->rx_ring.size, sizeof(struct sk_buff *),
                         GFP_KERNEL);
         if (!htt->rx_ring.netbufs_ring)
                 goto err_netbuf;
diff --git a/drivers/net/wireless/ath/ath10k/wmi-tlv.c b/drivers/net/wireless/ath/ath10k/wmi-tlv.c
index 2e34a1fc5ba6..8c49a26fc571 100644
--- a/drivers/net/wireless/ath/ath10k/wmi-tlv.c
+++ b/drivers/net/wireless/ath/ath10k/wmi-tlv.c
@@ -155,7 +155,7 @@ ath10k_wmi_tlv_parse_alloc(struct ath10k *ar, const void *ptr,
         const void **tb;
         int ret;
 
-        tb = kzalloc(sizeof(*tb) * WMI_TLV_TAG_MAX, gfp);
+        tb = kcalloc(WMI_TLV_TAG_MAX, sizeof(*tb), gfp);
         if (!tb)
                 return ERR_PTR(-ENOMEM);
 
diff --git a/drivers/net/wireless/ath/ath6kl/cfg80211.c b/drivers/net/wireless/ath/ath6kl/cfg80211.c
index 2ba8cf3f38af..0687697d5e2d 100644
--- a/drivers/net/wireless/ath/ath6kl/cfg80211.c
+++ b/drivers/net/wireless/ath/ath6kl/cfg80211.c
@@ -1041,7 +1041,7 @@ static int ath6kl_cfg80211_scan(struct wiphy *wiphy,
 
                 n_channels = request->n_channels;
 
-                channels = kzalloc(n_channels * sizeof(u16), GFP_KERNEL);
+                channels = kcalloc(n_channels, sizeof(u16), GFP_KERNEL);
                 if (channels == NULL) {
                         ath6kl_warn("failed to set scan channels, scan all channels");
                         n_channels = 0;
diff --git a/drivers/net/wireless/ath/carl9170/main.c b/drivers/net/wireless/ath/carl9170/main.c
index 29e93c953d93..7f1bdea742b8 100644
--- a/drivers/net/wireless/ath/carl9170/main.c
+++ b/drivers/net/wireless/ath/carl9170/main.c
@@ -1958,7 +1958,7 @@ static int carl9170_parse_eeprom(struct ar9170 *ar)
         if (!bands)
                 return -EINVAL;
 
-        ar->survey = kzalloc(sizeof(struct survey_info) * chans, GFP_KERNEL);
+        ar->survey = kcalloc(chans, sizeof(struct survey_info), GFP_KERNEL);
         if (!ar->survey)
                 return -ENOMEM;
         ar->num_channels = chans;
@@ -1988,8 +1988,9 @@ int carl9170_register(struct ar9170 *ar)
         if (WARN_ON(ar->mem_bitmap))
                 return -EINVAL;
 
-        ar->mem_bitmap = kzalloc(roundup(ar->fw.mem_blocks, BITS_PER_LONG) *
-                                 sizeof(unsigned long), GFP_KERNEL);
+        ar->mem_bitmap = kcalloc(roundup(ar->fw.mem_blocks, BITS_PER_LONG),
+                                 sizeof(unsigned long),
+                                 GFP_KERNEL);
 
         if (!ar->mem_bitmap)
                 return -ENOMEM;
diff --git a/drivers/net/wireless/broadcom/b43/phy_n.c b/drivers/net/wireless/broadcom/b43/phy_n.c
index f2a2f41e3c96..44ab080d6518 100644
--- a/drivers/net/wireless/broadcom/b43/phy_n.c
+++ b/drivers/net/wireless/broadcom/b43/phy_n.c
@@ -1518,7 +1518,7 @@ static int b43_nphy_load_samples(struct b43_wldev *dev,
         u16 i;
         u32 *data;
 
-        data = kzalloc(len * sizeof(u32), GFP_KERNEL);
+        data = kcalloc(len, sizeof(u32), GFP_KERNEL);
         if (!data) {
                 b43err(dev->wl, "allocation for samples loading failed\n");
                 return -ENOMEM;
diff --git a/drivers/net/wireless/broadcom/b43legacy/main.c b/drivers/net/wireless/broadcom/b43legacy/main.c
index f1e3dad57629..55f411925960 100644
--- a/drivers/net/wireless/broadcom/b43legacy/main.c
+++ b/drivers/net/wireless/broadcom/b43legacy/main.c
@@ -3300,8 +3300,8 @@ static int b43legacy_wireless_core_init(struct b43legacy_wldev *dev)
 
         if ((phy->type == B43legacy_PHYTYPE_B) ||
             (phy->type == B43legacy_PHYTYPE_G)) {
-                phy->_lo_pairs = kzalloc(sizeof(struct b43legacy_lopair)
-                                         * B43legacy_LO_COUNT,
+                phy->_lo_pairs = kcalloc(B43legacy_LO_COUNT,
+                                         sizeof(struct b43legacy_lopair),
                                          GFP_KERNEL);
                 if (!phy->_lo_pairs)
                         return -ENOMEM;
diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/msgbuf.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/msgbuf.c
index 49d37ad96958..c40ba8855cd5 100644
--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/msgbuf.c
+++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/msgbuf.c
@@ -1486,8 +1486,9 @@ int brcmf_proto_msgbuf_attach(struct brcmf_pub *drvr)
                 (struct brcmf_commonring **)if_msgbuf->commonrings;
         msgbuf->flowrings = (struct brcmf_commonring **)if_msgbuf->flowrings;
         msgbuf->max_flowrings = if_msgbuf->max_flowrings;
-        msgbuf->flowring_dma_handle = kzalloc(msgbuf->max_flowrings *
-                sizeof(*msgbuf->flowring_dma_handle), GFP_KERNEL);
+        msgbuf->flowring_dma_handle =
+                kcalloc(msgbuf->max_flowrings,
+                        sizeof(*msgbuf->flowring_dma_handle), GFP_KERNEL);
         if (!msgbuf->flowring_dma_handle)
                 goto fail;
 
diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/p2p.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/p2p.c
index 4b2149b48362..3e9c4f2f5dd1 100644
--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/p2p.c
+++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/p2p.c
@@ -1058,7 +1058,7 @@ static s32 brcmf_p2p_act_frm_search(struct brcmf_p2p_info *p2p, u16 channel)
                 channel_cnt = AF_PEER_SEARCH_CNT;
         else
                 channel_cnt = SOCIAL_CHAN_CNT;
-        default_chan_list = kzalloc(channel_cnt * sizeof(*default_chan_list),
+        default_chan_list = kcalloc(channel_cnt, sizeof(*default_chan_list),
                                     GFP_KERNEL);
         if (default_chan_list == NULL) {
                 brcmf_err("channel list allocation failed\n");
diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmsmac/main.c b/drivers/net/wireless/broadcom/brcm80211/brcmsmac/main.c
index 0a14942b8216..7d4e8f589fdc 100644
--- a/drivers/net/wireless/broadcom/brcm80211/brcmsmac/main.c
+++ b/drivers/net/wireless/broadcom/brcm80211/brcmsmac/main.c
@@ -507,7 +507,7 @@ brcms_c_attach_malloc(uint unit, uint *err, uint devid)
         wlc->hw->wlc = wlc;
 
         wlc->hw->bandstate[0] =
-                kzalloc(sizeof(struct brcms_hw_band) * MAXBANDS, GFP_ATOMIC);
+                kcalloc(MAXBANDS, sizeof(struct brcms_hw_band), GFP_ATOMIC);
         if (wlc->hw->bandstate[0] == NULL) {
                 *err = 1006;
                 goto fail;
@@ -521,7 +521,8 @@ brcms_c_attach_malloc(uint unit, uint *err, uint devid)
         }
 
         wlc->modulecb =
-                kzalloc(sizeof(struct modulecb) * BRCMS_MAXMODULES, GFP_ATOMIC);
+                kcalloc(BRCMS_MAXMODULES, sizeof(struct modulecb),
+                        GFP_ATOMIC);
         if (wlc->modulecb == NULL) {
                 *err = 1009;
                 goto fail;
@@ -553,7 +554,7 @@ brcms_c_attach_malloc(uint unit, uint *err, uint devid)
         }
 
         wlc->bandstate[0] =
-                kzalloc(sizeof(struct brcms_band)*MAXBANDS, GFP_ATOMIC);
+                kcalloc(MAXBANDS, sizeof(struct brcms_band), GFP_ATOMIC);
         if (wlc->bandstate[0] == NULL) {
                 *err = 1025;
                 goto fail;
diff --git a/drivers/net/wireless/intel/iwlegacy/common.c b/drivers/net/wireless/intel/iwlegacy/common.c
index 063e19ced7c8..6514baf799fe 100644
--- a/drivers/net/wireless/intel/iwlegacy/common.c
+++ b/drivers/net/wireless/intel/iwlegacy/common.c
@@ -922,7 +922,7 @@ il_init_channel_map(struct il_priv *il)
         D_EEPROM("Parsing data for %d channels.\n", il->channel_count);
 
         il->channel_info =
-            kzalloc(sizeof(struct il_channel_info) * il->channel_count,
+            kcalloc(il->channel_count, sizeof(struct il_channel_info),
                     GFP_KERNEL);
         if (!il->channel_info) {
                 IL_ERR("Could not allocate channel_info\n");
@@ -3041,9 +3041,9 @@ il_tx_queue_init(struct il_priv *il, u32 txq_id)
         }
 
         txq->meta =
-            kzalloc(sizeof(struct il_cmd_meta) * actual_slots, GFP_KERNEL);
+            kcalloc(actual_slots, sizeof(struct il_cmd_meta), GFP_KERNEL);
         txq->cmd =
-            kzalloc(sizeof(struct il_device_cmd *) * actual_slots, GFP_KERNEL);
+            kcalloc(actual_slots, sizeof(struct il_device_cmd *), GFP_KERNEL);
 
         if (!txq->meta || !txq->cmd)
                 goto out_free_arrays;
@@ -3455,7 +3455,7 @@ il_init_geos(struct il_priv *il)
         }
 
         channels =
-            kzalloc(sizeof(struct ieee80211_channel) * il->channel_count,
+            kcalloc(il->channel_count, sizeof(struct ieee80211_channel),
                     GFP_KERNEL);
         if (!channels)
                 return -ENOMEM;
@@ -4654,8 +4654,9 @@ il_alloc_txq_mem(struct il_priv *il)
 {
         if (!il->txq)
                 il->txq =
-                    kzalloc(sizeof(struct il_tx_queue) *
-                            il->cfg->num_of_queues, GFP_KERNEL);
+                    kcalloc(il->cfg->num_of_queues,
+                            sizeof(struct il_tx_queue),
+                            GFP_KERNEL);
         if (!il->txq) {
                 IL_ERR("Not enough memory for txq\n");
                 return -ENOMEM;
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/scan.c b/drivers/net/wireless/intel/iwlwifi/mvm/scan.c
index 4b3753d78d03..11ecdf63b732 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/scan.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/scan.c
@@ -564,7 +564,7 @@ iwl_mvm_config_sched_scan_profiles(struct iwl_mvm *mvm,
         else
                 blacklist_len = IWL_SCAN_MAX_BLACKLIST_LEN;
 
-        blacklist = kzalloc(sizeof(*blacklist) * blacklist_len, GFP_KERNEL);
+        blacklist = kcalloc(blacklist_len, sizeof(*blacklist), GFP_KERNEL);
         if (!blacklist)
                 return -ENOMEM;
 
diff --git a/drivers/net/wireless/intersil/p54/eeprom.c b/drivers/net/wireless/intersil/p54/eeprom.c
index d4c73d39336f..de2ef95c386c 100644
--- a/drivers/net/wireless/intersil/p54/eeprom.c
+++ b/drivers/net/wireless/intersil/p54/eeprom.c
@@ -161,8 +161,9 @@ static int p54_generate_band(struct ieee80211_hw *dev,
         if (!tmp)
                 goto err_out;
 
-        tmp->channels = kzalloc(sizeof(struct ieee80211_channel) *
-                                list->band_channel_num[band], GFP_KERNEL);
+        tmp->channels = kcalloc(list->band_channel_num[band],
+                                sizeof(struct ieee80211_channel),
+                                GFP_KERNEL);
         if (!tmp->channels)
                 goto err_out;
 
@@ -344,7 +345,7 @@ static int p54_generate_channel_lists(struct ieee80211_hw *dev)
                 goto free;
         }
         priv->chan_num = max_channel_num;
-        priv->survey = kzalloc(sizeof(struct survey_info) * max_channel_num,
+        priv->survey = kcalloc(max_channel_num, sizeof(struct survey_info),
                                GFP_KERNEL);
         if (!priv->survey) {
                 ret = -ENOMEM;
@@ -352,8 +353,9 @@ static int p54_generate_channel_lists(struct ieee80211_hw *dev)
         }
 
         list->max_entries = max_channel_num;
-        list->channels = kzalloc(sizeof(struct p54_channel_entry) *
-                                 max_channel_num, GFP_KERNEL);
+        list->channels = kcalloc(max_channel_num,
+                                 sizeof(struct p54_channel_entry),
+                                 GFP_KERNEL);
         if (!list->channels) {
                 ret = -ENOMEM;
                 goto free;
diff --git a/drivers/net/wireless/intersil/prism54/oid_mgt.c b/drivers/net/wireless/intersil/prism54/oid_mgt.c
index 6528ed5b9b1d..6d57e1cbcc07 100644
--- a/drivers/net/wireless/intersil/prism54/oid_mgt.c
+++ b/drivers/net/wireless/intersil/prism54/oid_mgt.c
@@ -244,7 +244,7 @@ mgt_init(islpci_private *priv)
         /* Alloc the cache */
         for (i = 0; i < OID_NUM_LAST; i++) {
                 if (isl_oid[i].flags & OID_FLAG_CACHED) {
-                        priv->mib[i] = kzalloc(isl_oid[i].size *
+                        priv->mib[i] = kcalloc(isl_oid[i].size,
                                                (isl_oid[i].range + 1),
                                                GFP_KERNEL);
                         if (!priv->mib[i])
diff --git a/drivers/net/wireless/marvell/mwifiex/11n_rxreorder.c b/drivers/net/wireless/marvell/mwifiex/11n_rxreorder.c
index 1edcddaf7b4b..7ab44cd32a9d 100644
--- a/drivers/net/wireless/marvell/mwifiex/11n_rxreorder.c
+++ b/drivers/net/wireless/marvell/mwifiex/11n_rxreorder.c
@@ -399,8 +399,8 @@ mwifiex_11n_create_rx_reorder_tbl(struct mwifiex_private *priv, u8 *ta,
 
         new_node->win_size = win_size;
 
-        new_node->rx_reorder_ptr = kzalloc(sizeof(void *) * win_size,
-                                        GFP_KERNEL);
+        new_node->rx_reorder_ptr = kcalloc(win_size, sizeof(void *),
+                                           GFP_KERNEL);
         if (!new_node->rx_reorder_ptr) {
                 kfree((u8 *) new_node);
                 mwifiex_dbg(priv->adapter, ERROR,
diff --git a/drivers/net/wireless/marvell/mwifiex/sdio.c b/drivers/net/wireless/marvell/mwifiex/sdio.c
index 47d2dcc3f28f..dfdcbc4f141a 100644
--- a/drivers/net/wireless/marvell/mwifiex/sdio.c
+++ b/drivers/net/wireless/marvell/mwifiex/sdio.c
@@ -2106,15 +2106,16 @@ static int mwifiex_init_sdio(struct mwifiex_adapter *adapter)
                 return -ENOMEM;
 
         /* Allocate skb pointer buffers */
-        card->mpa_rx.skb_arr = kzalloc((sizeof(void *)) *
-                                       card->mp_agg_pkt_limit, GFP_KERNEL);
+        card->mpa_rx.skb_arr = kcalloc(card->mp_agg_pkt_limit, sizeof(void *),
+                                       GFP_KERNEL);
         if (!card->mpa_rx.skb_arr) {
                 kfree(card->mp_regs);
                 return -ENOMEM;
         }
 
-        card->mpa_rx.len_arr = kzalloc(sizeof(*card->mpa_rx.len_arr) *
-                                       card->mp_agg_pkt_limit, GFP_KERNEL);
+        card->mpa_rx.len_arr = kcalloc(card->mp_agg_pkt_limit,
+                                       sizeof(*card->mpa_rx.len_arr),
+                                       GFP_KERNEL);
         if (!card->mpa_rx.len_arr) {
                 kfree(card->mp_regs);
                 kfree(card->mpa_rx.skb_arr);
diff --git a/drivers/net/wireless/quantenna/qtnfmac/commands.c b/drivers/net/wireless/quantenna/qtnfmac/commands.c
index 5eb143667539..c5d94a95e21a 100644
--- a/drivers/net/wireless/quantenna/qtnfmac/commands.c
+++ b/drivers/net/wireless/quantenna/qtnfmac/commands.c
@@ -1216,7 +1216,7 @@ static int qtnf_parse_variable_mac_info(struct qtnf_wmac *mac,
                                 return -EINVAL;
                         }
 
-                        limits = kzalloc(sizeof(*limits) * rec->n_limits,
+                        limits = kcalloc(rec->n_limits, sizeof(*limits),
                                          GFP_KERNEL);
                         if (!limits)
                                 return -ENOMEM;
diff --git a/drivers/net/wireless/ralink/rt2x00/rt2x00debug.c b/drivers/net/wireless/ralink/rt2x00/rt2x00debug.c
index 0eee479583b8..acc399b5574e 100644
--- a/drivers/net/wireless/ralink/rt2x00/rt2x00debug.c
+++ b/drivers/net/wireless/ralink/rt2x00/rt2x00debug.c
@@ -397,7 +397,7 @@ static ssize_t rt2x00debug_read_crypto_stats(struct file *file,
         if (*offset)
                 return 0;
 
-        data = kzalloc((1 + CIPHER_MAX) * MAX_LINE_LENGTH, GFP_KERNEL);
+        data = kcalloc(1 + CIPHER_MAX, MAX_LINE_LENGTH, GFP_KERNEL);
         if (!data)
                 return -ENOMEM;
 
diff --git a/drivers/net/wireless/realtek/rtlwifi/efuse.c b/drivers/net/wireless/realtek/rtlwifi/efuse.c
index fd13d4ef53b8..9729e51fce38 100644
--- a/drivers/net/wireless/realtek/rtlwifi/efuse.c
+++ b/drivers/net/wireless/realtek/rtlwifi/efuse.c
@@ -258,8 +258,8 @@ void read_efuse(struct ieee80211_hw *hw, u16 _offset, u16 _size_byte, u8 *pbuf)
         }
 
         /* allocate memory for efuse_tbl and efuse_word */
-        efuse_tbl = kzalloc(rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE] *
-                            sizeof(u8), GFP_ATOMIC);
+        efuse_tbl = kzalloc(rtlpriv->cfg->maps[EFUSE_HWSET_MAX_SIZE],
+                            GFP_ATOMIC);
         if (!efuse_tbl)
                 return;
         efuse_word = kcalloc(EFUSE_MAX_WORD_UNIT, sizeof(u16 *), GFP_ATOMIC);
diff --git a/drivers/net/wireless/realtek/rtlwifi/usb.c b/drivers/net/wireless/realtek/rtlwifi/usb.c
index ce3103bb8ebb..f9faffc498bc 100644
--- a/drivers/net/wireless/realtek/rtlwifi/usb.c
+++ b/drivers/net/wireless/realtek/rtlwifi/usb.c
@@ -1048,7 +1048,7 @@ int rtl_usb_probe(struct usb_interface *intf,
         }
         rtlpriv = hw->priv;
         rtlpriv->hw = hw;
-        rtlpriv->usb_data = kzalloc(RTL_USB_MAX_RX_COUNT * sizeof(u32),
+        rtlpriv->usb_data = kcalloc(RTL_USB_MAX_RX_COUNT, sizeof(u32),
                                     GFP_KERNEL);
         if (!rtlpriv->usb_data)
                 return -ENOMEM;
diff --git a/drivers/net/wireless/st/cw1200/queue.c b/drivers/net/wireless/st/cw1200/queue.c
index 5153d2cfd991..7c31b63b8258 100644
--- a/drivers/net/wireless/st/cw1200/queue.c
+++ b/drivers/net/wireless/st/cw1200/queue.c
@@ -154,7 +154,7 @@ int cw1200_queue_stats_init(struct cw1200_queue_stats *stats,
         spin_lock_init(&stats->lock);
         init_waitqueue_head(&stats->wait_link_id_empty);
 
-        stats->link_map_cache = kzalloc(sizeof(int) * map_capacity,
+        stats->link_map_cache = kcalloc(map_capacity, sizeof(int),
                                         GFP_KERNEL);
         if (!stats->link_map_cache)
                 return -ENOMEM;
@@ -181,13 +181,13 @@ int cw1200_queue_init(struct cw1200_queue *queue,
         spin_lock_init(&queue->lock);
         timer_setup(&queue->gc, cw1200_queue_gc, 0);
 
-        queue->pool = kzalloc(sizeof(struct cw1200_queue_item) * capacity,
-                        GFP_KERNEL);
+        queue->pool = kcalloc(capacity, sizeof(struct cw1200_queue_item),
+                              GFP_KERNEL);
         if (!queue->pool)
                 return -ENOMEM;
 
-        queue->link_map_cache = kzalloc(sizeof(int) * stats->map_capacity,
-                        GFP_KERNEL);
+        queue->link_map_cache = kcalloc(stats->map_capacity, sizeof(int),
+                                        GFP_KERNEL);
         if (!queue->link_map_cache) {
                 kfree(queue->pool);
                 queue->pool = NULL;
diff --git a/drivers/net/wireless/st/cw1200/scan.c b/drivers/net/wireless/st/cw1200/scan.c
index cc2ce60f4f09..67213f11acbd 100644
--- a/drivers/net/wireless/st/cw1200/scan.c
+++ b/drivers/net/wireless/st/cw1200/scan.c
@@ -230,9 +230,9 @@ void cw1200_scan_work(struct work_struct *work)
                         scan.type = WSM_SCAN_TYPE_BACKGROUND;
                         scan.flags = WSM_SCAN_FLAG_FORCE_BACKGROUND;
                 }
-                scan.ch = kzalloc(
-                        sizeof(struct wsm_scan_ch) * (it - priv->scan.curr),
-                        GFP_KERNEL);
+                scan.ch = kcalloc(it - priv->scan.curr,
+                                  sizeof(struct wsm_scan_ch),
+                                  GFP_KERNEL);
                 if (!scan.ch) {
                         priv->scan.status = -ENOMEM;
                         goto fail;