Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit bb5420c3 authored by Himanshu Jha's avatar Himanshu Jha Committed by Martin K. Petersen
Browse files

scsi: bnx2fc: Use zeroing allocator rather than allocator/memset 



Use dma_zalloc_coherent instead of dma_alloc_coherent followed by memset
0.

Generated-by: scripts/coccinelle/api/alloc/kzalloc-simple.cocci

Suggested-by: default avatarLuis R. Rodriguez <mcgrof@kernel.org>
Signed-off-by: default avatarHimanshu Jha <himanshujha199640@gmail.com>
Acked-by: default avatarChad Dupuis <chad.dupuis@cavium.com>
Signed-off-by: default avatarMartin K. Petersen <martin.petersen@oracle.com>
parent 468f4b8d

drivers/scsi/bnx2fc/bnx2fc_hwi.c

+25 −35
Original line number Diff line number Diff line
@@ -1857,7 +1857,7 @@ int bnx2fc_setup_task_ctx(struct bnx2fc_hba *hba) 
	 * entries. Hence the limit with one page is 8192 task context

	 * entries.

	 */

	hba->task_ctx_bd_tbl = dma_alloc_coherent(&hba->pcidev->dev,

	hba->task_ctx_bd_tbl = dma_zalloc_coherent(&hba->pcidev->dev,

						   PAGE_SIZE,

						   &hba->task_ctx_bd_dma,

						   GFP_KERNEL);
@@ -1866,7 +1866,6 @@ int bnx2fc_setup_task_ctx(struct bnx2fc_hba *hba) 
		rc = -1;

		goto out;

	}

	memset(hba->task_ctx_bd_tbl, 0, PAGE_SIZE);



	/*

	 * Allocate task_ctx which is an array of pointers pointing to
@@ -1895,7 +1894,7 @@ int bnx2fc_setup_task_ctx(struct bnx2fc_hba *hba) 
	task_ctx_bdt = (struct regpair *)hba->task_ctx_bd_tbl;

	for (i = 0; i < task_ctx_arr_sz; i++) {



		hba->task_ctx[i] = dma_alloc_coherent(&hba->pcidev->dev,

		hba->task_ctx[i] = dma_zalloc_coherent(&hba->pcidev->dev,

						       PAGE_SIZE,

						       &hba->task_ctx_dma[i],

						       GFP_KERNEL);
@@ -1904,7 +1903,6 @@ int bnx2fc_setup_task_ctx(struct bnx2fc_hba *hba) 
			rc = -1;

			goto out3;

		}

		memset(hba->task_ctx[i], 0, PAGE_SIZE);

		addr = (u64)hba->task_ctx_dma[i];

		task_ctx_bdt->hi = cpu_to_le32((u64)addr >> 32);

		task_ctx_bdt->lo = cpu_to_le32((u32)addr);
@@ -2033,8 +2031,7 @@ static int bnx2fc_allocate_hash_table(struct bnx2fc_hba *hba) 
	}



	for (i = 0; i < segment_count; ++i) {

		hba->hash_tbl_segments[i] =

			dma_alloc_coherent(&hba->pcidev->dev,

		hba->hash_tbl_segments[i] = dma_zalloc_coherent(&hba->pcidev->dev,

								BNX2FC_HASH_TBL_CHUNK_SIZE,

								&dma_segment_array[i],

								GFP_KERNEL);
@@ -2042,19 +2039,15 @@ static int bnx2fc_allocate_hash_table(struct bnx2fc_hba *hba) 
			printk(KERN_ERR PFX "hash segment alloc failed\n");

			goto cleanup_dma;

		}

		memset(hba->hash_tbl_segments[i], 0,

		       BNX2FC_HASH_TBL_CHUNK_SIZE);

	}



	hba->hash_tbl_pbl = dma_alloc_coherent(&hba->pcidev->dev,

					       PAGE_SIZE,

	hba->hash_tbl_pbl = dma_zalloc_coherent(&hba->pcidev->dev, PAGE_SIZE,

						&hba->hash_tbl_pbl_dma,

						GFP_KERNEL);

	if (!hba->hash_tbl_pbl) {

		printk(KERN_ERR PFX "hash table pbl alloc failed\n");

		goto cleanup_dma;

	}

	memset(hba->hash_tbl_pbl, 0, PAGE_SIZE);



	pbl = hba->hash_tbl_pbl;

	for (i = 0; i < segment_count; ++i) {
@@ -2111,7 +2104,8 @@ int bnx2fc_setup_fw_resc(struct bnx2fc_hba *hba) 
		return -ENOMEM;



	mem_size = BNX2FC_NUM_MAX_SESS * sizeof(struct regpair);

	hba->t2_hash_tbl_ptr = dma_alloc_coherent(&hba->pcidev->dev, mem_size,

	hba->t2_hash_tbl_ptr = dma_zalloc_coherent(&hba->pcidev->dev,

						   mem_size,

						   &hba->t2_hash_tbl_ptr_dma,

						   GFP_KERNEL);

	if (!hba->t2_hash_tbl_ptr) {
@@ -2119,11 +2113,10 @@ int bnx2fc_setup_fw_resc(struct bnx2fc_hba *hba) 
		bnx2fc_free_fw_resc(hba);

		return -ENOMEM;

	}

	memset(hba->t2_hash_tbl_ptr, 0x00, mem_size);



	mem_size = BNX2FC_NUM_MAX_SESS *

				sizeof(struct fcoe_t2_hash_table_entry);

	hba->t2_hash_tbl = dma_alloc_coherent(&hba->pcidev->dev, mem_size,

	hba->t2_hash_tbl = dma_zalloc_coherent(&hba->pcidev->dev, mem_size,

					       &hba->t2_hash_tbl_dma,

					       GFP_KERNEL);

	if (!hba->t2_hash_tbl) {
@@ -2131,7 +2124,6 @@ int bnx2fc_setup_fw_resc(struct bnx2fc_hba *hba) 
		bnx2fc_free_fw_resc(hba);

		return -ENOMEM;

	}

	memset(hba->t2_hash_tbl, 0x00, mem_size);

	for (i = 0; i < BNX2FC_NUM_MAX_SESS; i++) {

		addr = (unsigned long) hba->t2_hash_tbl_dma +

			 ((i+1) * sizeof(struct fcoe_t2_hash_table_entry));
@@ -2148,8 +2140,7 @@ int bnx2fc_setup_fw_resc(struct bnx2fc_hba *hba) 
		return -ENOMEM;

	}



	hba->stats_buffer = dma_alloc_coherent(&hba->pcidev->dev,

					       PAGE_SIZE,

	hba->stats_buffer = dma_zalloc_coherent(&hba->pcidev->dev, PAGE_SIZE,

						&hba->stats_buf_dma,

						GFP_KERNEL);

	if (!hba->stats_buffer) {
@@ -2157,7 +2148,6 @@ int bnx2fc_setup_fw_resc(struct bnx2fc_hba *hba) 
		bnx2fc_free_fw_resc(hba);

		return -ENOMEM;

	}

	memset(hba->stats_buffer, 0x00, PAGE_SIZE);



	return 0;

}

drivers/scsi/bnx2fc/bnx2fc_tgt.c

+22 −29
Original line number Diff line number Diff line
@@ -672,48 +672,45 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba, 
	tgt->sq_mem_size = (tgt->sq_mem_size + (CNIC_PAGE_SIZE - 1)) &

			   CNIC_PAGE_MASK;



	tgt->sq = dma_alloc_coherent(&hba->pcidev->dev, tgt->sq_mem_size,

	tgt->sq = dma_zalloc_coherent(&hba->pcidev->dev, tgt->sq_mem_size,

				      &tgt->sq_dma, GFP_KERNEL);

	if (!tgt->sq) {

		printk(KERN_ERR PFX "unable to allocate SQ memory %d\n",

			tgt->sq_mem_size);

		goto mem_alloc_failure;

	}

	memset(tgt->sq, 0, tgt->sq_mem_size);



	/* Allocate and map CQ */

	tgt->cq_mem_size = tgt->max_cqes * BNX2FC_CQ_WQE_SIZE;

	tgt->cq_mem_size = (tgt->cq_mem_size + (CNIC_PAGE_SIZE - 1)) &

			   CNIC_PAGE_MASK;



	tgt->cq = dma_alloc_coherent(&hba->pcidev->dev, tgt->cq_mem_size,

	tgt->cq = dma_zalloc_coherent(&hba->pcidev->dev, tgt->cq_mem_size,

				      &tgt->cq_dma, GFP_KERNEL);

	if (!tgt->cq) {

		printk(KERN_ERR PFX "unable to allocate CQ memory %d\n",

			tgt->cq_mem_size);

		goto mem_alloc_failure;

	}

	memset(tgt->cq, 0, tgt->cq_mem_size);



	/* Allocate and map RQ and RQ PBL */

	tgt->rq_mem_size = tgt->max_rqes * BNX2FC_RQ_WQE_SIZE;

	tgt->rq_mem_size = (tgt->rq_mem_size + (CNIC_PAGE_SIZE - 1)) &

			   CNIC_PAGE_MASK;



	tgt->rq = dma_alloc_coherent(&hba->pcidev->dev, tgt->rq_mem_size,

	tgt->rq = dma_zalloc_coherent(&hba->pcidev->dev, tgt->rq_mem_size,

				      &tgt->rq_dma, GFP_KERNEL);

	if (!tgt->rq) {

		printk(KERN_ERR PFX "unable to allocate RQ memory %d\n",

			tgt->rq_mem_size);

		goto mem_alloc_failure;

	}

	memset(tgt->rq, 0, tgt->rq_mem_size);



	tgt->rq_pbl_size = (tgt->rq_mem_size / CNIC_PAGE_SIZE) * sizeof(void *);

	tgt->rq_pbl_size = (tgt->rq_pbl_size + (CNIC_PAGE_SIZE - 1)) &

			   CNIC_PAGE_MASK;



	tgt->rq_pbl = dma_alloc_coherent(&hba->pcidev->dev, tgt->rq_pbl_size,

	tgt->rq_pbl = dma_zalloc_coherent(&hba->pcidev->dev, tgt->rq_pbl_size,

					  &tgt->rq_pbl_dma, GFP_KERNEL);

	if (!tgt->rq_pbl) {

		printk(KERN_ERR PFX "unable to allocate RQ PBL %d\n",
@@ -721,7 +718,6 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba, 
		goto mem_alloc_failure;

	}



	memset(tgt->rq_pbl, 0, tgt->rq_pbl_size);

	num_pages = tgt->rq_mem_size / CNIC_PAGE_SIZE;

	page = tgt->rq_dma;

	pbl = (u32 *)tgt->rq_pbl;
@@ -739,35 +735,35 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba, 
	tgt->xferq_mem_size = (tgt->xferq_mem_size + (CNIC_PAGE_SIZE - 1)) &

			       CNIC_PAGE_MASK;



	tgt->xferq = dma_alloc_coherent(&hba->pcidev->dev, tgt->xferq_mem_size,

					&tgt->xferq_dma, GFP_KERNEL);

	tgt->xferq = dma_zalloc_coherent(&hba->pcidev->dev,

					 tgt->xferq_mem_size, &tgt->xferq_dma,

					 GFP_KERNEL);

	if (!tgt->xferq) {

		printk(KERN_ERR PFX "unable to allocate XFERQ %d\n",

			tgt->xferq_mem_size);

		goto mem_alloc_failure;

	}

	memset(tgt->xferq, 0, tgt->xferq_mem_size);



	/* Allocate and map CONFQ & CONFQ PBL */

	tgt->confq_mem_size = tgt->max_sqes * BNX2FC_CONFQ_WQE_SIZE;

	tgt->confq_mem_size = (tgt->confq_mem_size + (CNIC_PAGE_SIZE - 1)) &

			       CNIC_PAGE_MASK;



	tgt->confq = dma_alloc_coherent(&hba->pcidev->dev, tgt->confq_mem_size,

					&tgt->confq_dma, GFP_KERNEL);

	tgt->confq = dma_zalloc_coherent(&hba->pcidev->dev,

					 tgt->confq_mem_size, &tgt->confq_dma,

					 GFP_KERNEL);

	if (!tgt->confq) {

		printk(KERN_ERR PFX "unable to allocate CONFQ %d\n",

			tgt->confq_mem_size);

		goto mem_alloc_failure;

	}

	memset(tgt->confq, 0, tgt->confq_mem_size);



	tgt->confq_pbl_size =

		(tgt->confq_mem_size / CNIC_PAGE_SIZE) * sizeof(void *);

	tgt->confq_pbl_size =

		(tgt->confq_pbl_size + (CNIC_PAGE_SIZE - 1)) & CNIC_PAGE_MASK;



	tgt->confq_pbl = dma_alloc_coherent(&hba->pcidev->dev,

	tgt->confq_pbl = dma_zalloc_coherent(&hba->pcidev->dev,

					     tgt->confq_pbl_size,

					     &tgt->confq_pbl_dma, GFP_KERNEL);

	if (!tgt->confq_pbl) {
@@ -776,7 +772,6 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba, 
		goto mem_alloc_failure;

	}



	memset(tgt->confq_pbl, 0, tgt->confq_pbl_size);

	num_pages = tgt->confq_mem_size / CNIC_PAGE_SIZE;

	page = tgt->confq_dma;

	pbl = (u32 *)tgt->confq_pbl;
@@ -792,7 +787,7 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba, 
	/* Allocate and map ConnDB */

	tgt->conn_db_mem_size = sizeof(struct fcoe_conn_db);



	tgt->conn_db = dma_alloc_coherent(&hba->pcidev->dev,

	tgt->conn_db = dma_zalloc_coherent(&hba->pcidev->dev,

					   tgt->conn_db_mem_size,

					   &tgt->conn_db_dma, GFP_KERNEL);

	if (!tgt->conn_db) {
@@ -800,7 +795,6 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba, 
						tgt->conn_db_mem_size);

		goto mem_alloc_failure;

	}

	memset(tgt->conn_db, 0, tgt->conn_db_mem_size);





	/* Allocate and map LCQ */
@@ -808,7 +802,7 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba, 
	tgt->lcq_mem_size = (tgt->lcq_mem_size + (CNIC_PAGE_SIZE - 1)) &

			     CNIC_PAGE_MASK;



	tgt->lcq = dma_alloc_coherent(&hba->pcidev->dev, tgt->lcq_mem_size,

	tgt->lcq = dma_zalloc_coherent(&hba->pcidev->dev, tgt->lcq_mem_size,

				       &tgt->lcq_dma, GFP_KERNEL);



	if (!tgt->lcq) {
@@ -816,7 +810,6 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba, 
		       tgt->lcq_mem_size);

		goto mem_alloc_failure;

	}

	memset(tgt->lcq, 0, tgt->lcq_mem_size);



	tgt->conn_db->rq_prod = 0x8000;