Commit 7dad171c authored by Prarit Bhargava's avatar Prarit Bhargava Committed by David S. Miller
Browse files

vxge: Fix checkstack warning in vxge_probe() 



Linux 2.6.33 reports this checkstack warning:

drivers/net/vxge/vxge-main.c: In function 'vxge_probe':
drivers/net/vxge/vxge-main.c:4409: warning: the frame size of 1028 bytes is larger than 1024 bytes

This warning does not occur in the latest linux-2.6 or linux-next, however,
when I do a 'make -j32 CONFIG_FRAME_WARN=512' instead of 1024 I see

drivers/net/vxge/vxge-main.c: In function ‘vxge_probe’:
drivers/net/vxge/vxge-main.c:4423: warning: the frame size of 1024 bytes is larger than 512 bytes

This patch moves the large vxge_config struct off the stack.

Signed-off-by: default avatarPrarit Bhargava <prarit@redhat.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent c2d9ba9b

drivers/net/vxge/vxge-main.c

+51 −42
Original line number Diff line number Diff line
@@ -4012,7 +4012,7 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre) 
	int high_dma = 0;

	u64 vpath_mask = 0;

	struct vxgedev *vdev;

	struct vxge_config ll_config;

	struct vxge_config *ll_config = NULL;

	struct vxge_hw_device_config *device_config = NULL;

	struct vxge_hw_device_attr attr;

	int i, j, no_of_vpath = 0, max_vpath_supported = 0;
@@ -4071,17 +4071,24 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre) 
		goto _exit0;

	}



	memset(&ll_config, 0, sizeof(struct vxge_config));

	ll_config.tx_steering_type = TX_MULTIQ_STEERING;

	ll_config.intr_type = MSI_X;

	ll_config.napi_weight = NEW_NAPI_WEIGHT;

	ll_config.rth_steering = RTH_STEERING;

	ll_config = kzalloc(sizeof(*ll_config), GFP_KERNEL);

	if (!ll_config) {

		ret = -ENOMEM;

		vxge_debug_init(VXGE_ERR,

			"ll_config : malloc failed %s %d",

			__FILE__, __LINE__);

		goto _exit0;

	}

	ll_config->tx_steering_type = TX_MULTIQ_STEERING;

	ll_config->intr_type = MSI_X;

	ll_config->napi_weight = NEW_NAPI_WEIGHT;

	ll_config->rth_steering = RTH_STEERING;



	/* get the default configuration parameters */

	vxge_hw_device_config_default_get(device_config);



	/* initialize configuration parameters */

	vxge_device_config_init(device_config, &ll_config.intr_type);

	vxge_device_config_init(device_config, &ll_config->intr_type);



	ret = pci_enable_device(pdev);

	if (ret) {
@@ -4134,7 +4141,7 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre) 
		(unsigned long long)pci_resource_start(pdev, 0));



	status = vxge_hw_device_hw_info_get(attr.bar0,

			&ll_config.device_hw_info);

			&ll_config->device_hw_info);

	if (status != VXGE_HW_OK) {

		vxge_debug_init(VXGE_ERR,

			"%s: Reading of hardware info failed."
@@ -4143,7 +4150,7 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre) 
		goto _exit3;

	}



	if (ll_config.device_hw_info.fw_version.major !=

	if (ll_config->device_hw_info.fw_version.major !=

		VXGE_DRIVER_FW_VERSION_MAJOR) {

		vxge_debug_init(VXGE_ERR,

			"%s: Incorrect firmware version."
@@ -4153,7 +4160,7 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre) 
		goto _exit3;

	}



	vpath_mask = ll_config.device_hw_info.vpath_mask;

	vpath_mask = ll_config->device_hw_info.vpath_mask;

	if (vpath_mask == 0) {

		vxge_debug_ll_config(VXGE_TRACE,

			"%s: No vpaths available in device", VXGE_DRIVER_NAME);
@@ -4165,10 +4172,10 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre) 
		"%s:%d  Vpath mask = %llx", __func__, __LINE__,

		(unsigned long long)vpath_mask);



	function_mode = ll_config.device_hw_info.function_mode;

	host_type = ll_config.device_hw_info.host_type;

	function_mode = ll_config->device_hw_info.function_mode;

	host_type = ll_config->device_hw_info.host_type;

	is_privileged = __vxge_hw_device_is_privilaged(host_type,

		ll_config.device_hw_info.func_id);

		ll_config->device_hw_info.func_id);



	/* Check how many vpaths are available */

	for (i = 0; i < VXGE_HW_MAX_VIRTUAL_PATHS; i++) {
@@ -4182,7 +4189,7 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre) 


	/* Enable SRIOV mode, if firmware has SRIOV support and if it is a PF */

	if (is_sriov(function_mode) && (max_config_dev > 1) &&

		(ll_config.intr_type != INTA) &&

		(ll_config->intr_type != INTA) &&

		(is_privileged == VXGE_HW_OK)) {

		ret = pci_enable_sriov(pdev, ((max_config_dev - 1) < num_vfs)

			? (max_config_dev - 1) : num_vfs);
@@ -4195,7 +4202,7 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre) 
	 * Configure vpaths and get driver configured number of vpaths

	 * which is less than or equal to the maximum vpaths per function.

	 */

	no_of_vpath = vxge_config_vpaths(device_config, vpath_mask, &ll_config);

	no_of_vpath = vxge_config_vpaths(device_config, vpath_mask, ll_config);

	if (!no_of_vpath) {

		vxge_debug_ll_config(VXGE_ERR,

			"%s: No more vpaths to configure", VXGE_DRIVER_NAME);
@@ -4230,21 +4237,21 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre) 
	/* set private device info */

	pci_set_drvdata(pdev, hldev);



	ll_config.gro_enable = VXGE_GRO_ALWAYS_AGGREGATE;

	ll_config.fifo_indicate_max_pkts = VXGE_FIFO_INDICATE_MAX_PKTS;

	ll_config.addr_learn_en = addr_learn_en;

	ll_config.rth_algorithm = RTH_ALG_JENKINS;

	ll_config.rth_hash_type_tcpipv4 = VXGE_HW_RING_HASH_TYPE_TCP_IPV4;

	ll_config.rth_hash_type_ipv4 = VXGE_HW_RING_HASH_TYPE_NONE;

	ll_config.rth_hash_type_tcpipv6 = VXGE_HW_RING_HASH_TYPE_NONE;

	ll_config.rth_hash_type_ipv6 = VXGE_HW_RING_HASH_TYPE_NONE;

	ll_config.rth_hash_type_tcpipv6ex = VXGE_HW_RING_HASH_TYPE_NONE;

	ll_config.rth_hash_type_ipv6ex = VXGE_HW_RING_HASH_TYPE_NONE;

	ll_config.rth_bkt_sz = RTH_BUCKET_SIZE;

	ll_config.tx_pause_enable = VXGE_PAUSE_CTRL_ENABLE;

	ll_config.rx_pause_enable = VXGE_PAUSE_CTRL_ENABLE;



	if (vxge_device_register(hldev, &ll_config, high_dma, no_of_vpath,

	ll_config->gro_enable = VXGE_GRO_ALWAYS_AGGREGATE;

	ll_config->fifo_indicate_max_pkts = VXGE_FIFO_INDICATE_MAX_PKTS;

	ll_config->addr_learn_en = addr_learn_en;

	ll_config->rth_algorithm = RTH_ALG_JENKINS;

	ll_config->rth_hash_type_tcpipv4 = VXGE_HW_RING_HASH_TYPE_TCP_IPV4;

	ll_config->rth_hash_type_ipv4 = VXGE_HW_RING_HASH_TYPE_NONE;

	ll_config->rth_hash_type_tcpipv6 = VXGE_HW_RING_HASH_TYPE_NONE;

	ll_config->rth_hash_type_ipv6 = VXGE_HW_RING_HASH_TYPE_NONE;

	ll_config->rth_hash_type_tcpipv6ex = VXGE_HW_RING_HASH_TYPE_NONE;

	ll_config->rth_hash_type_ipv6ex = VXGE_HW_RING_HASH_TYPE_NONE;

	ll_config->rth_bkt_sz = RTH_BUCKET_SIZE;

	ll_config->tx_pause_enable = VXGE_PAUSE_CTRL_ENABLE;

	ll_config->rx_pause_enable = VXGE_PAUSE_CTRL_ENABLE;



	if (vxge_device_register(hldev, ll_config, high_dma, no_of_vpath,

		&vdev)) {

		ret = -EINVAL;

		goto _exit4;
@@ -4275,7 +4282,7 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre) 
		vdev->vpaths[j].vdev = vdev;

		vdev->vpaths[j].max_mac_addr_cnt = max_mac_vpath;

		memcpy((u8 *)vdev->vpaths[j].macaddr,

				(u8 *)ll_config.device_hw_info.mac_addrs[i],

				ll_config->device_hw_info.mac_addrs[i],

				ETH_ALEN);



		/* Initialize the mac address list header */
@@ -4296,18 +4303,18 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre) 


	macaddr = (u8 *)vdev->vpaths[0].macaddr;



	ll_config.device_hw_info.serial_number[VXGE_HW_INFO_LEN - 1] = '\0';

	ll_config.device_hw_info.product_desc[VXGE_HW_INFO_LEN - 1] = '\0';

	ll_config.device_hw_info.part_number[VXGE_HW_INFO_LEN - 1] = '\0';

	ll_config->device_hw_info.serial_number[VXGE_HW_INFO_LEN - 1] = '\0';

	ll_config->device_hw_info.product_desc[VXGE_HW_INFO_LEN - 1] = '\0';

	ll_config->device_hw_info.part_number[VXGE_HW_INFO_LEN - 1] = '\0';



	vxge_debug_init(VXGE_TRACE, "%s: SERIAL NUMBER: %s",

		vdev->ndev->name, ll_config.device_hw_info.serial_number);

		vdev->ndev->name, ll_config->device_hw_info.serial_number);



	vxge_debug_init(VXGE_TRACE, "%s: PART NUMBER: %s",

		vdev->ndev->name, ll_config.device_hw_info.part_number);

		vdev->ndev->name, ll_config->device_hw_info.part_number);



	vxge_debug_init(VXGE_TRACE, "%s: Neterion %s Server Adapter",

		vdev->ndev->name, ll_config.device_hw_info.product_desc);

		vdev->ndev->name, ll_config->device_hw_info.product_desc);



	vxge_debug_init(VXGE_TRACE, "%s: MAC ADDR: %pM",

		vdev->ndev->name, macaddr);
@@ -4317,11 +4324,11 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre) 


	vxge_debug_init(VXGE_TRACE,

		"%s: Firmware version : %s Date : %s", vdev->ndev->name,

		ll_config.device_hw_info.fw_version.version,

		ll_config.device_hw_info.fw_date.date);

		ll_config->device_hw_info.fw_version.version,

		ll_config->device_hw_info.fw_date.date);



	if (new_device) {

		switch (ll_config.device_hw_info.function_mode) {

		switch (ll_config->device_hw_info.function_mode) {

		case VXGE_HW_FUNCTION_MODE_SINGLE_FUNCTION:

			vxge_debug_init(VXGE_TRACE,

			"%s: Single Function Mode Enabled", vdev->ndev->name);
@@ -4344,7 +4351,7 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre) 
	vxge_print_parm(vdev, vpath_mask);



	/* Store the fw version for ethttool option */

	strcpy(vdev->fw_version, ll_config.device_hw_info.fw_version.version);

	strcpy(vdev->fw_version, ll_config->device_hw_info.fw_version.version);

	memcpy(vdev->ndev->dev_addr, (u8 *)vdev->vpaths[0].macaddr, ETH_ALEN);

	memcpy(vdev->ndev->perm_addr, vdev->ndev->dev_addr, ETH_ALEN);
@@ -4383,7 +4390,7 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre) 
	 * present to prevent such a failure.

	 */



	if (ll_config.device_hw_info.function_mode ==

	if (ll_config->device_hw_info.function_mode ==

		VXGE_HW_FUNCTION_MODE_MULTI_FUNCTION)

		if (vdev->config.intr_type == INTA)

			vxge_hw_device_unmask_all(hldev);
@@ -4395,6 +4402,7 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre) 
	VXGE_COPY_DEBUG_INFO_TO_LL(vdev, vxge_hw_device_error_level_get(hldev),

		vxge_hw_device_trace_level_get(hldev));



	kfree(ll_config);

	return 0;



_exit5:
@@ -4412,6 +4420,7 @@ _exit2: 
_exit1:

	pci_disable_device(pdev);

_exit0:

	kfree(ll_config);

	kfree(device_config);

	driver_config->config_dev_cnt--;

	pci_set_drvdata(pdev, NULL);

CRA Git | Maintained and supported by SUSTech CRA and CCSE