kvzalloc already zeroes the memory during the allocation.
pci_alloc_consistent calls dma_alloc_coherent directly.
In commit 
518a2f1925c3
("dma-mapping: zero memory returned from dma_alloc_*"),
dma_alloc_coherent has already zeroed the memory.
So the memset after these function is not needed.
Signed-off-by: Fuqian Huang <huangfq.daxian@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
 
                goto err_nomem;
        }
 
-       memset(ring_header->desc, 0, ring_header->size);
-
        /* init TPD ring */
        tpd_ring->dma = ring_header->dma;
        offset = (tpd_ring->dma & 0x7) ? (8 - (ring_header->dma & 0x7)) : 0;
 
                &adapter->ring_dma);
        if (!adapter->ring_vir_addr)
                return -ENOMEM;
-       memset(adapter->ring_vir_addr, 0, adapter->ring_size);
 
        /* Init TXD Ring */
        adapter->txd_dma = adapter->ring_dma ;
 
                        mapping = txr->tx_push_mapping +
                                sizeof(struct tx_push_bd);
                        txr->data_mapping = cpu_to_le64(mapping);
-
-                       memset(txr->tx_push, 0, sizeof(struct tx_push_bd));
                }
                qidx = bp->tc_to_qidx[j];
                ring->queue_id = bp->q_info[qidx].queue_id;
 
                goto out_err;
 
        /* Bind queue to specified class */
-       memset(qe, 0, sizeof(*qe));
        qe->cntxt_id = qid;
        memcpy(&qe->param, p, sizeof(qe->param));
 
 
                return -ENOMEM;
        }
 
-       memset(cbd_base, 0, bd_size);
-
        /* Get the Ethernet address */
        fec_get_mac(ndev);
        /* make sure MAC we just acquired is programmed into the hw */
 
        if (unlikely(!(txring->bufinf)))
                goto err_free_txring;
 
-       /*
-        * Initialize Transmit Descriptors
-        */
-       memset(txring->alloc, 0, TX_RING_ALLOC_SIZE(jme->tx_ring_size));
-
        return 0;
 
 err_free_txring:
 
                goto free_pci_mem;
        }
 
-       memset(skge->mem, 0, skge->mem_size);
-
        err = skge_ring_alloc(&skge->rx_ring, skge->mem, skge->dma);
        if (err)
                goto free_pci_mem;
 
 
                dma_list[i] = t;
                eq->page_list[i].map = t;
-
-               memset(eq->page_list[i].buf, 0, PAGE_SIZE);
        }
 
        eq->eqn = mlx4_bitmap_alloc(&priv->eq_table.bitmap);
 
        MLX5_SET(query_vport_counter_in, in, vport_number, vport->vport);
        MLX5_SET(query_vport_counter_in, in, other_vport, 1);
 
-       memset(out, 0, outlen);
        err = mlx5_cmd_exec(esw->dev, in, sizeof(in), out, outlen);
        if (err)
                goto free_out;
 
        }
 
        /* create send-to-vport group */
-       memset(flow_group_in, 0, inlen);
        MLX5_SET(create_flow_group_in, flow_group_in, match_criteria_enable,
                 MLX5_MATCH_MISC_PARAMETERS);
 
                return -ENOMEM;
 
        /* create vport rx group */
-       memset(flow_group_in, 0, inlen);
-
        esw_set_flow_group_source_port(esw, flow_group_in);
 
        MLX5_SET(create_flow_group_in, flow_group_in, start_flow_index, 0);
 
                                             &mem_item->mapaddr);
        if (!mem_item->buf)
                return -ENOMEM;
-       memset(mem_item->buf, 0, mem_item->size);
 
        q->elem_info = kcalloc(q->count, sizeof(*q->elem_info), GFP_KERNEL);
        if (!q->elem_info) {
 
                                return -ENOMEM;
                        }
                        mem_allocated += size;
-                       memset(tmp_v_addr, 0, size);
 
                        size = sizeof(struct rxd_info) *
                                rxd_count[nic->rxd_mode];
 
                goto out_free_rq;
        }
 
-       memset(rq_addr, 0, rq_size);
        prq = rq_addr;
 
-       memset(rsp_addr, 0, rsp_size);
        prsp = rsp_addr;
 
        prq->host_rsp_dma_addr = cpu_to_le64(rsp_phys_addr);
                return -ENOMEM;
        }
 
-       memset(addr, 0, sizeof(struct netxen_ring_ctx));
        recv_ctx->hwctx = addr;
        recv_ctx->hwctx->ctx_id = cpu_to_le32(port);
        recv_ctx->hwctx->cmd_consumer_offset =
 
                       dev->name);
                return -ENOMEM;
        }
-       memset(priv->dma_storage, 0, dma_size);
        priv->rx_list = (struct tlan_list *)
                ALIGN((unsigned long)priv->dma_storage, 8);
        priv->rx_list_dma = ALIGN(priv->dma_storage_dma, 8);