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

Commit e51000db authored by Sriharsha Basavapatna's avatar Sriharsha Basavapatna Committed by David S. Miller
Browse files

be2net: Replace dma/pci_alloc_coherent() calls with dma_zalloc_coherent() 



There are several places in the driver (all in control paths) where
coherent dma memory is being allocated using either dma_alloc_coherent()
or the deprecated pci_alloc_consistent(). All these calls should be
changed to use dma_zalloc_coherent() to avoid uninitialized fields in
data structures backed by this memory.

Reported-by: default avatarJoerg Roedel <jroedel@suse.de>
Tested-by: default avatarJoerg Roedel <jroedel@suse.de>
Signed-off-by: default avatarSriharsha Basavapatna <sriharsha.basavapatna@avagotech.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 1d7c4903

drivers/net/ethernet/emulex/benet/be_cmds.c

+50 −37
Original line number Diff line number Diff line
@@ -1720,9 +1720,9 @@ int be_cmd_get_regs(struct be_adapter *adapter, u32 buf_len, void *buf) 
	total_size = buf_len;



	get_fat_cmd.size = sizeof(struct be_cmd_req_get_fat) + 60*1024;

	get_fat_cmd.va = pci_alloc_consistent(adapter->pdev,

	get_fat_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,

					     get_fat_cmd.size,

					      &get_fat_cmd.dma);

					     &get_fat_cmd.dma, GFP_ATOMIC);

	if (!get_fat_cmd.va) {

		dev_err(&adapter->pdev->dev,

			"Memory allocation failure while reading FAT data\n");
@@ -1767,7 +1767,7 @@ int be_cmd_get_regs(struct be_adapter *adapter, u32 buf_len, void *buf) 
		log_offset += buf_size;

	}

err:

	pci_free_consistent(adapter->pdev, get_fat_cmd.size,

	dma_free_coherent(&adapter->pdev->dev, get_fat_cmd.size,

			  get_fat_cmd.va, get_fat_cmd.dma);

	spin_unlock_bh(&adapter->mcc_lock);

	return status;
@@ -2215,12 +2215,12 @@ int be_cmd_read_port_transceiver_data(struct be_adapter *adapter, 
		return -EINVAL;



	cmd.size = sizeof(struct be_cmd_resp_port_type);

	cmd.va = pci_alloc_consistent(adapter->pdev, cmd.size, &cmd.dma);

	cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,

				     GFP_ATOMIC);

	if (!cmd.va) {

		dev_err(&adapter->pdev->dev, "Memory allocation failed\n");

		return -ENOMEM;

	}

	memset(cmd.va, 0, cmd.size);



	spin_lock_bh(&adapter->mcc_lock);
@@ -2245,7 +2245,7 @@ int be_cmd_read_port_transceiver_data(struct be_adapter *adapter, 
	}

err:

	spin_unlock_bh(&adapter->mcc_lock);

	pci_free_consistent(adapter->pdev, cmd.size, cmd.va, cmd.dma);

	dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va, cmd.dma);

	return status;

}
@@ -2720,7 +2720,8 @@ int be_cmd_get_phy_info(struct be_adapter *adapter) 
		goto err;

	}

	cmd.size = sizeof(struct be_cmd_req_get_phy_info);

	cmd.va = pci_alloc_consistent(adapter->pdev, cmd.size, &cmd.dma);

	cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,

				     GFP_ATOMIC);

	if (!cmd.va) {

		dev_err(&adapter->pdev->dev, "Memory alloc failure\n");

		status = -ENOMEM;
@@ -2754,7 +2755,7 @@ int be_cmd_get_phy_info(struct be_adapter *adapter) 
				BE_SUPPORTED_SPEED_1GBPS;

		}

	}

	pci_free_consistent(adapter->pdev, cmd.size, cmd.va, cmd.dma);

	dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va, cmd.dma);

err:

	spin_unlock_bh(&adapter->mcc_lock);

	return status;
@@ -2805,8 +2806,9 @@ int be_cmd_get_cntl_attributes(struct be_adapter *adapter) 


	memset(&attribs_cmd, 0, sizeof(struct be_dma_mem));

	attribs_cmd.size = sizeof(struct be_cmd_resp_cntl_attribs);

	attribs_cmd.va = pci_alloc_consistent(adapter->pdev, attribs_cmd.size,

					      &attribs_cmd.dma);

	attribs_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,

					     attribs_cmd.size,

					     &attribs_cmd.dma, GFP_ATOMIC);

	if (!attribs_cmd.va) {

		dev_err(&adapter->pdev->dev, "Memory allocation failure\n");

		status = -ENOMEM;
@@ -2833,7 +2835,7 @@ int be_cmd_get_cntl_attributes(struct be_adapter *adapter) 
err:

	mutex_unlock(&adapter->mbox_lock);

	if (attribs_cmd.va)

		pci_free_consistent(adapter->pdev, attribs_cmd.size,

		dma_free_coherent(&adapter->pdev->dev, attribs_cmd.size,

				  attribs_cmd.va, attribs_cmd.dma);

	return status;

}
@@ -2972,9 +2974,10 @@ int be_cmd_get_mac_from_list(struct be_adapter *adapter, u8 *mac, 


	memset(&get_mac_list_cmd, 0, sizeof(struct be_dma_mem));

	get_mac_list_cmd.size = sizeof(struct be_cmd_resp_get_mac_list);

	get_mac_list_cmd.va = pci_alloc_consistent(adapter->pdev,

	get_mac_list_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,

						  get_mac_list_cmd.size,

						   &get_mac_list_cmd.dma);

						  &get_mac_list_cmd.dma,

						  GFP_ATOMIC);



	if (!get_mac_list_cmd.va) {

		dev_err(&adapter->pdev->dev,
@@ -3047,7 +3050,7 @@ int be_cmd_get_mac_from_list(struct be_adapter *adapter, u8 *mac, 


out:

	spin_unlock_bh(&adapter->mcc_lock);

	pci_free_consistent(adapter->pdev, get_mac_list_cmd.size,

	dma_free_coherent(&adapter->pdev->dev, get_mac_list_cmd.size,

			  get_mac_list_cmd.va, get_mac_list_cmd.dma);

	return status;

}
@@ -3101,8 +3104,8 @@ int be_cmd_set_mac_list(struct be_adapter *adapter, u8 *mac_array, 


	memset(&cmd, 0, sizeof(struct be_dma_mem));

	cmd.size = sizeof(struct be_cmd_req_set_mac_list);

	cmd.va = dma_alloc_coherent(&adapter->pdev->dev, cmd.size,

				    &cmd.dma, GFP_KERNEL);

	cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,

				     GFP_KERNEL);

	if (!cmd.va)

		return -ENOMEM;
@@ -3291,7 +3294,8 @@ int be_cmd_get_acpi_wol_cap(struct be_adapter *adapter) 


	memset(&cmd, 0, sizeof(struct be_dma_mem));

	cmd.size = sizeof(struct be_cmd_resp_acpi_wol_magic_config_v1);

	cmd.va = pci_alloc_consistent(adapter->pdev, cmd.size, &cmd.dma);

	cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,

				     GFP_ATOMIC);

	if (!cmd.va) {

		dev_err(&adapter->pdev->dev, "Memory allocation failure\n");

		status = -ENOMEM;
@@ -3326,7 +3330,8 @@ int be_cmd_get_acpi_wol_cap(struct be_adapter *adapter) 
err:

	mutex_unlock(&adapter->mbox_lock);

	if (cmd.va)

		pci_free_consistent(adapter->pdev, cmd.size, cmd.va, cmd.dma);

		dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va,

				  cmd.dma);

	return status;



}
@@ -3340,8 +3345,9 @@ int be_cmd_set_fw_log_level(struct be_adapter *adapter, u32 level) 


	memset(&extfat_cmd, 0, sizeof(struct be_dma_mem));

	extfat_cmd.size = sizeof(struct be_cmd_resp_get_ext_fat_caps);

	extfat_cmd.va = pci_alloc_consistent(adapter->pdev, extfat_cmd.size,

					     &extfat_cmd.dma);

	extfat_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,

					    extfat_cmd.size, &extfat_cmd.dma,

					    GFP_ATOMIC);

	if (!extfat_cmd.va)

		return -ENOMEM;
@@ -3363,7 +3369,7 @@ int be_cmd_set_fw_log_level(struct be_adapter *adapter, u32 level) 


	status = be_cmd_set_ext_fat_capabilites(adapter, &extfat_cmd, cfgs);

err:

	pci_free_consistent(adapter->pdev, extfat_cmd.size, extfat_cmd.va,

	dma_free_coherent(&adapter->pdev->dev, extfat_cmd.size, extfat_cmd.va,

			  extfat_cmd.dma);

	return status;

}
@@ -3377,8 +3383,9 @@ int be_cmd_get_fw_log_level(struct be_adapter *adapter) 


	memset(&extfat_cmd, 0, sizeof(struct be_dma_mem));

	extfat_cmd.size = sizeof(struct be_cmd_resp_get_ext_fat_caps);

	extfat_cmd.va = pci_alloc_consistent(adapter->pdev, extfat_cmd.size,

					     &extfat_cmd.dma);

	extfat_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,

					    extfat_cmd.size, &extfat_cmd.dma,

					    GFP_ATOMIC);



	if (!extfat_cmd.va) {

		dev_err(&adapter->pdev->dev, "%s: Memory allocation failure\n",
@@ -3396,7 +3403,7 @@ int be_cmd_get_fw_log_level(struct be_adapter *adapter) 
				level = cfgs->module[0].trace_lvl[j].dbg_lvl;

		}

	}

	pci_free_consistent(adapter->pdev, extfat_cmd.size, extfat_cmd.va,

	dma_free_coherent(&adapter->pdev->dev, extfat_cmd.size, extfat_cmd.va,

			  extfat_cmd.dma);

err:

	return level;
@@ -3595,7 +3602,8 @@ int be_cmd_get_func_config(struct be_adapter *adapter, struct be_resources *res) 


	memset(&cmd, 0, sizeof(struct be_dma_mem));

	cmd.size = sizeof(struct be_cmd_resp_get_func_config);

	cmd.va = pci_alloc_consistent(adapter->pdev, cmd.size, &cmd.dma);

	cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,

				     GFP_ATOMIC);

	if (!cmd.va) {

		dev_err(&adapter->pdev->dev, "Memory alloc failure\n");

		status = -ENOMEM;
@@ -3635,7 +3643,8 @@ int be_cmd_get_func_config(struct be_adapter *adapter, struct be_resources *res) 
err:

	mutex_unlock(&adapter->mbox_lock);

	if (cmd.va)

		pci_free_consistent(adapter->pdev, cmd.size, cmd.va, cmd.dma);

		dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va,

				  cmd.dma);

	return status;

}
@@ -3656,7 +3665,8 @@ int be_cmd_get_profile_config(struct be_adapter *adapter, 


	memset(&cmd, 0, sizeof(struct be_dma_mem));

	cmd.size = sizeof(struct be_cmd_resp_get_profile_config);

	cmd.va = pci_alloc_consistent(adapter->pdev, cmd.size, &cmd.dma);

	cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,

				     GFP_ATOMIC);

	if (!cmd.va)

		return -ENOMEM;
@@ -3702,7 +3712,8 @@ int be_cmd_get_profile_config(struct be_adapter *adapter, 
		res->vf_if_cap_flags = vf_res->cap_flags;

err:

	if (cmd.va)

		pci_free_consistent(adapter->pdev, cmd.size, cmd.va, cmd.dma);

		dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va,

				  cmd.dma);

	return status;

}
@@ -3717,7 +3728,8 @@ static int be_cmd_set_profile_config(struct be_adapter *adapter, void *desc, 


	memset(&cmd, 0, sizeof(struct be_dma_mem));

	cmd.size = sizeof(struct be_cmd_req_set_profile_config);

	cmd.va = pci_alloc_consistent(adapter->pdev, cmd.size, &cmd.dma);

	cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,

				     GFP_ATOMIC);

	if (!cmd.va)

		return -ENOMEM;
@@ -3733,7 +3745,8 @@ static int be_cmd_set_profile_config(struct be_adapter *adapter, void *desc, 
	status = be_cmd_notify_wait(adapter, &wrb);



	if (cmd.va)

		pci_free_consistent(adapter->pdev, cmd.size, cmd.va, cmd.dma);

		dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va,

				  cmd.dma);

	return status;

}

drivers/net/ethernet/emulex/benet/be_ethtool.c

+10 −8
Original line number Diff line number Diff line
@@ -264,8 +264,8 @@ static int lancer_cmd_read_file(struct be_adapter *adapter, u8 *file_name, 
	int status = 0;



	read_cmd.size = LANCER_READ_FILE_CHUNK;

	read_cmd.va = pci_alloc_consistent(adapter->pdev, read_cmd.size,

					   &read_cmd.dma);

	read_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, read_cmd.size,

					  &read_cmd.dma, GFP_ATOMIC);



	if (!read_cmd.va) {

		dev_err(&adapter->pdev->dev,
@@ -289,7 +289,7 @@ static int lancer_cmd_read_file(struct be_adapter *adapter, u8 *file_name, 
			break;

		}

	}

	pci_free_consistent(adapter->pdev, read_cmd.size, read_cmd.va,

	dma_free_coherent(&adapter->pdev->dev, read_cmd.size, read_cmd.va,

			  read_cmd.dma);



	return status;
@@ -818,8 +818,9 @@ static int be_test_ddr_dma(struct be_adapter *adapter) 
	};



	ddrdma_cmd.size = sizeof(struct be_cmd_req_ddrdma_test);

	ddrdma_cmd.va = dma_alloc_coherent(&adapter->pdev->dev, ddrdma_cmd.size,

					   &ddrdma_cmd.dma, GFP_KERNEL);

	ddrdma_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,

					    ddrdma_cmd.size, &ddrdma_cmd.dma,

					    GFP_KERNEL);

	if (!ddrdma_cmd.va)

		return -ENOMEM;
@@ -941,8 +942,9 @@ static int be_read_eeprom(struct net_device *netdev, 


	memset(&eeprom_cmd, 0, sizeof(struct be_dma_mem));

	eeprom_cmd.size = sizeof(struct be_cmd_req_seeprom_read);

	eeprom_cmd.va = dma_alloc_coherent(&adapter->pdev->dev, eeprom_cmd.size,

					   &eeprom_cmd.dma, GFP_KERNEL);

	eeprom_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,

					    eeprom_cmd.size, &eeprom_cmd.dma,

					    GFP_KERNEL);



	if (!eeprom_cmd.va)

		return -ENOMEM;

drivers/net/ethernet/emulex/benet/be_main.c

+7 −8
Original line number Diff line number Diff line
@@ -4605,7 +4605,7 @@ static int lancer_fw_download(struct be_adapter *adapter, 


	flash_cmd.size = sizeof(struct lancer_cmd_req_write_object)

				+ LANCER_FW_DOWNLOAD_CHUNK;

	flash_cmd.va = dma_alloc_coherent(dev, flash_cmd.size,

	flash_cmd.va = dma_zalloc_coherent(dev, flash_cmd.size,

					   &flash_cmd.dma, GFP_KERNEL);

	if (!flash_cmd.va)

		return -ENOMEM;
@@ -4739,7 +4739,7 @@ static int be_fw_download(struct be_adapter *adapter, const struct firmware* fw) 
	}



	flash_cmd.size = sizeof(struct be_cmd_write_flashrom);

	flash_cmd.va = dma_alloc_coherent(dev, flash_cmd.size, &flash_cmd.dma,

	flash_cmd.va = dma_zalloc_coherent(dev, flash_cmd.size, &flash_cmd.dma,

					   GFP_KERNEL);

	if (!flash_cmd.va)

		return -ENOMEM;
@@ -5291,7 +5291,7 @@ static int be_drv_init(struct be_adapter *adapter) 
	int status = 0;



	mbox_mem_alloc->size = sizeof(struct be_mcc_mailbox) + 16;

	mbox_mem_alloc->va = dma_alloc_coherent(dev, mbox_mem_alloc->size,

	mbox_mem_alloc->va = dma_zalloc_coherent(dev, mbox_mem_alloc->size,

						 &mbox_mem_alloc->dma,

						 GFP_KERNEL);

	if (!mbox_mem_alloc->va)
@@ -5300,7 +5300,6 @@ static int be_drv_init(struct be_adapter *adapter) 
	mbox_mem_align->size = sizeof(struct be_mcc_mailbox);

	mbox_mem_align->va = PTR_ALIGN(mbox_mem_alloc->va, 16);

	mbox_mem_align->dma = PTR_ALIGN(mbox_mem_alloc->dma, 16);

	memset(mbox_mem_align->va, 0, sizeof(struct be_mcc_mailbox));



	rx_filter->size = sizeof(struct be_cmd_req_rx_filter);

	rx_filter->va = dma_zalloc_coherent(dev, rx_filter->size,