Implement support for SRIOV + LAG
Subsystems (3)
v4 cover Implement support for SRIOV + LAG
Implement support for SRIOV VF's on interfaces that are in an aggregate interface.
The first interface added into the aggregate will be flagged as the primary interface, and this primary interface will be responsible for managing the VF's resources. VF's created on the primary are the only VFs that will be supported on the aggregate. Only Active-Backup mode will be supported and only aggregates whose primary interface is in switchdev mode will be supported.
Additional restrictions on what interfaces can be added to the aggregate and still support SRIOV VFs are:
- interfaces have to all be on the same physical NIC
- all interfaces have to have the same QoS settings
- interfaces have to have the FW LLDP agent disabled
- only the primary interface is to be put into switchdev mode
- no more than two interfaces in the aggregate
Changes since v1:
Fix typo in commit message
Fix typos in warning messages
Fix typo in function header
Use correct bitwise operator instead of boolean
Changes since v2:
Rebase on current next-queue
Fix typos in commits
Fix typos in function headers
use %u for unsigned values in debug message
Refactor common code in node moves to subfunction
Changes since v3:
Fix typos in warning messages
move refactor of common code to earlier patch expand use of refactored code
move prototype and func call into patch that defines func
Dave Ertman (9):
ice: Add driver support for firmware changes for LAG
ice: changes to the interface with the HW and FW for SRIOV_VF+LAG
ice: implement lag netdev event handler
ice: process events created by lag netdev event handler
ice: Flesh out implementation of support for SRIOV on bonded interface
ice: support non-standard teardown of bond interface
ice: enforce interface eligibility and add messaging for SRIOV LAG
ice: enforce no DCB config changing when in bond
ice: update reset path for SRIOV LAG support
Jacob Keller (1):
ice: Correctly initialize queue context values
drivers/net/ethernet/intel/ice/ice.h | 5 + .../net/ethernet/intel/ice/ice_adminq_cmd.h | 53 +- drivers/net/ethernet/intel/ice/ice_common.c | 56 + drivers/net/ethernet/intel/ice/ice_common.h | 4 + drivers/net/ethernet/intel/ice/ice_dcb_nl.c | 50 + drivers/net/ethernet/intel/ice/ice_lag.c | 1812 ++++++++++++++++- drivers/net/ethernet/intel/ice/ice_lag.h | 34 +- drivers/net/ethernet/intel/ice/ice_lib.c | 2 +- drivers/net/ethernet/intel/ice/ice_lib.h | 1 + drivers/net/ethernet/intel/ice/ice_main.c | 26 +- drivers/net/ethernet/intel/ice/ice_sched.c | 37 +- drivers/net/ethernet/intel/ice/ice_sched.h | 21 + drivers/net/ethernet/intel/ice/ice_switch.c | 88 +- drivers/net/ethernet/intel/ice/ice_switch.h | 29 + drivers/net/ethernet/intel/ice/ice_type.h | 2 + drivers/net/ethernet/intel/ice/ice_virtchnl.c | 2 + 16 files changed, 2092 insertions(+), 130 deletions(-)
Signature · 1 line
2.40.1
PATCH v4 1/10 ice: Correctly initialize queue context values
From: Jacob Keller <[email protected]>
The ice_alloc_lan_q_ctx function allocates the queue context array for a given traffic class. This function uses devm_kcalloc which will zero-allocate the structure. Thus, prior to any queue being setup by ice_ena_vsi_txq, the q_ctx structure will have a q_handle of 0 and a q_teid of 0. These are potentially valid values.
Modify the ice_alloc_lan_q_ctx function to initialize every member of the q_ctx array to have invalid values. Modify ice_dis_vsi_txq to ensure that it assigns q_teid to an invalid value when it assigns q_handle to the invalid value as well.
This will allow other code to check whether the queue context is currently valid before operating on it.
--- drivers/net/ethernet/intel/ice/ice_common.c | 1 + drivers/net/ethernet/intel/ice/ice_sched.c | 23 ++++++++++++++++----- 2 files changed, 19 insertions(+), 5 deletions(-)
drivers/net/ethernet/intel/ice/ice_common.c +1 -0
@@ -4673,6 +4673,7 @@ ice_dis_vsi_txq(struct ice_port_info *pi, u16 vsi_handle, u8 tc, u8 num_queues,break ;ice_free_sched_node (pi, node); q_ctx->q_handle =ICE_INVAL_Q_HANDLE ; + q_ctx->q_teid =ICE_INVAL_TEID ; }mutex_unlock (&pi->sched_lock);kfree (qg_list);
drivers/net/ethernet/intel/ice/ice_sched.c +18 -5
@@ -569,18 +569,24 @@ ice_alloc_lan_q_ctx(struct ice_hw *hw, u16 vsi_handle, u8 tc, u16 new_numqs) {struct ice_vsi_ctx *vsi_ctx;struct ice_q_ctx *q_ctx; +u16 idx; vsi_ctx =ice_get_vsi_ctx (hw, vsi_handle);if (!vsi_ctx)return -EINVAL ;/* allocate LAN queue contexts */ if (!vsi_ctx->lan_q_ctx[tc]) { - vsi_ctx->lan_q_ctx[tc] =devm_kcalloc (ice_hw_to_dev (hw), - new_numqs, -sizeof (*q_ctx), -GFP_KERNEL ); -if (!vsi_ctx->lan_q_ctx[tc]) + q_ctx =devm_kcalloc (ice_hw_to_dev (hw), new_numqs, +sizeof (*q_ctx),GFP_KERNEL ); +if (!q_ctx)return -ENOMEM ; + +for (idx =0 ; idx < new_numqs; idx++) { + q_ctx[idx].q_handle =ICE_INVAL_Q_HANDLE ; + q_ctx[idx].q_teid =ICE_INVAL_TEID ; + } + + vsi_ctx->lan_q_ctx[tc] = q_ctx; vsi_ctx->num_lan_q_entries[tc] = new_numqs;return 0 ; }
@@ -592,9 +598,16 @@ ice_alloc_lan_q_ctx(struct ice_hw *hw, u16 vsi_handle, u8 tc, u16 new_numqs) sizeof(*q_ctx), GFP_KERNEL);if (!q_ctx)return -ENOMEM ; +memcpy (q_ctx, vsi_ctx->lan_q_ctx[tc], prev_num *sizeof (*q_ctx));devm_kfree (ice_hw_to_dev (hw), vsi_ctx->lan_q_ctx[tc]); + +for (idx = prev_num; idx < new_numqs; idx++) { + q_ctx[idx].q_handle =ICE_INVAL_Q_HANDLE ; + q_ctx[idx].q_teid =ICE_INVAL_TEID ; + } + vsi_ctx->lan_q_ctx[tc] = q_ctx; vsi_ctx->num_lan_q_entries[tc] = new_numqs; }
Signature · 1 line
2.40.1
Re: [PATCH iwl-next v4 01/10] ice: Correctly initialize queue context values
Quoted 13 lines · Dave Ertman
From: Jacob Keller <[email protected]>
The
ice_alloc_lan_q_ctxfunction allocates the queue context array for a given traffic class. This function usesdevm_kcallocwhich will zero-allocate the structure. Thus, prior to any queue being setup byice_ena_vsi_txq, theq_ctxstructure will have aq_handleof 0 and aq_teidof 0. These are potentially valid values.Modify the
ice_alloc_lan_q_ctxfunction to initialize every member of theq_ctxarray to have invalid values. Modifyice_dis_vsi_txqto ensure that it assignsq_teidto an invalid value when it assignsq_handleto the invalid value as well.
Quoted 6 lines
This will allow other code to check whether the queue context is currently valid before operating on it.
Reviewed-by Daniel Machon <[email protected]>Signed-off-by Jacob Keller <[email protected]>Signed-off-by Dave Ertman <[email protected]>
PATCH v4 2/10 ice: Add driver support for firmware changes for LAG
In reply to Dave ErtmanAdd the defines, fields, and detection code for FW support of LAG for SRIOV. Also exposes some previously static functions to allow access in the lag code.
Clean up code that is unused or not needed for LAG support. Also add an ordered workqueue for processing LAG events.
--- drivers/net/ethernet/intel/ice/ice.h | 5 ++ .../net/ethernet/intel/ice/ice_adminq_cmd.h | 3 ++ drivers/net/ethernet/intel/ice/ice_common.c | 8 +++ drivers/net/ethernet/intel/ice/ice_lag.c | 53 ++++++++++--------- drivers/net/ethernet/intel/ice/ice_lib.c | 2 +- drivers/net/ethernet/intel/ice/ice_lib.h | 1 + drivers/net/ethernet/intel/ice/ice_main.c | 12 +++++ drivers/net/ethernet/intel/ice/ice_type.h | 2 + 8 files changed, 59 insertions(+), 27 deletions(-)
drivers/net/ethernet/intel/ice/ice.h +5 -0
@@ -200,6 +200,8 @@ enum ice_feature {ICE_F_PTP_EXTTS ,ICE_F_SMA_CTRL ,ICE_F_GNSS , +ICE_F_ROCE_LAG , +ICE_F_SRIOV_LAG , ICE_F_MAX };
@@ -569,6 +571,7 @@ struct ice_pf {struct mutex sw_mutex;/* lock for protecting VSI alloc flow */ struct mutex tc_mutex;/* lock to protect TC changes */ struct mutex adev_mutex;/* lock to protect aux device access */ +struct mutex lag_mutex;/* protect ice_lag struct in PF */ u32 msg_enable;struct ice_ptp ptp;struct gnss_serial *gnss_serial;
@@ -639,6 +642,8 @@ struct ice_pf {struct ice_agg_node vf_agg_node[ICE_MAX_VF_AGG_NODES ]; }; +extern struct workqueue_struct *ice_lag_wq; +struct ice_netdev_priv {struct ice_vsi *vsi;struct ice_repr *repr;
drivers/net/ethernet/intel/ice/ice_adminq_cmd.h +3 -0
@@ -120,6 +120,9 @@ struct ice_aqc_list_caps_elem {#define ICE_AQC_CAPS_PCIE_RESET_AVOIDANCE 0x0076#define ICE_AQC_CAPS_POST_UPDATE_RESET_RESTRICT 0x0077#define ICE_AQC_CAPS_NVM_MGMT 0x0080 +#define ICE_AQC_CAPS_FW_LAG_SUPPORT 0x0092 +#define ICE_AQC_BIT_ROCEV2_LAG 0x01 +#define ICE_AQC_BIT_SRIOV_LAG 0x02u8 major_ver;u8 minor_ver;
drivers/net/ethernet/intel/ice/ice_common.c +8 -0
@@ -2241,6 +2241,14 @@ ice_parse_common_caps(struct ice_hw *hw, struct ice_hw_common_caps *caps,"%s: reset_restrict_support = %d\n" , prefix, caps->reset_restrict_support);break ; +case ICE_AQC_CAPS_FW_LAG_SUPPORT : + caps->roce_lag = !!(number &ICE_AQC_BIT_ROCEV2_LAG ); +ice_debug (hw,ICE_DBG_INIT ,"%s: roce_lag = %u\n" , + prefix, caps->roce_lag); + caps->sriov_lag = !!(number &ICE_AQC_BIT_SRIOV_LAG ); +ice_debug (hw,ICE_DBG_INIT ,"%s: sriov_lag = %u\n" , + prefix, caps->sriov_lag); +break ;default :/* Not one of the recognized common capabilities */ found = false;
drivers/net/ethernet/intel/ice/ice_lag.c +27 -26
91 lines not on this page · raw message
drivers/net/ethernet/intel/ice/ice_lib.c +1 -1
@@ -3997,7 +3997,7 @@ bool ice_is_feature_supported(struct ice_pf *pf, enum ice_feature f)* @pf: pointer to the struct ice_pf instance * @f: feature enum to set */ -static void ice_set_feature_support (struct ice_pf *pf,enum ice_feature f) +void ice_set_feature_support (struct ice_pf *pf,enum ice_feature f) {if (f <0 || f >=ICE_F_MAX )return ;
drivers/net/ethernet/intel/ice/ice_lib.h +1 -0
@@ -163,6 +163,7 @@ int ice_vsi_del_vlan_zero(struct ice_vsi *vsi);bool ice_vsi_has_non_zero_vlans (struct ice_vsi *vsi);u16 ice_vsi_num_non_zero_vlans (struct ice_vsi *vsi);bool ice_is_feature_supported (struct ice_pf *pf,enum ice_feature f); +void ice_set_feature_support (struct ice_pf *pf,enum ice_feature f);void ice_clear_feature_support (struct ice_pf *pf,enum ice_feature f);void ice_init_feature_support (struct ice_pf *pf);bool ice_vsi_is_rx_queue_active (struct ice_vsi *vsi);
drivers/net/ethernet/intel/ice/ice_main.c +12 -0
@@ -64,6 +64,7 @@ struct device *ice_hw_to_dev(struct ice_hw *hw) }static struct workqueue_struct *ice_wq; +struct workqueue_struct *ice_lag_wq;static const struct net_device_ops ice_netdev_safe_mode_ops;static const struct net_device_ops ice_netdev_ops;
@@ -3795,6 +3796,7 @@ u16 ice_get_avail_rxq_count(struct ice_pf *pf)static void ice_deinit_pf (struct ice_pf *pf) {ice_service_task_stop (pf); +mutex_destroy (&pf->lag_mutex);mutex_destroy (&pf->adev_mutex);mutex_destroy (&pf->sw_mutex);mutex_destroy (&pf->tc_mutex);
@@ -3875,6 +3877,7 @@ static int ice_init_pf(struct ice_pf *pf)mutex_init (&pf->sw_mutex);mutex_init (&pf->tc_mutex);mutex_init (&pf->adev_mutex); +mutex_init (&pf->lag_mutex);INIT_HLIST_HEAD (&pf->aq_wait_list);spin_lock_init (&pf->aq_wait_lock);
@@ -5576,10 +5579,18 @@ static int __init ice_module_init(void)return -ENOMEM ; } + ice_lag_wq =alloc_ordered_workqueue ("ice_lag_wq" ,0 ); +if (!ice_lag_wq) { +pr_err ("Failed to create LAG workqueue\n" ); +destroy_workqueue (ice_wq); +return -ENOMEM ; + } + status =pci_register_driver (&ice_driver);if (status) {pr_err ("failed to register PCI driver, err %d\n" , status);destroy_workqueue (ice_wq); +destroy_workqueue (ice_lag_wq); }return status;
@@ -5596,6 +5607,7 @@ static void __exit ice_module_exit(void) {pci_unregister_driver (&ice_driver);destroy_workqueue (ice_wq); +destroy_workqueue (ice_lag_wq);pr_info ("module unloaded\n" ); }module_exit (ice_module_exit);
drivers/net/ethernet/intel/ice/ice_type.h +2 -0
@@ -277,6 +277,8 @@ struct ice_hw_common_caps {u8 dcb;u8 ieee_1588;u8 rdma; +u8 roce_lag; +u8 sriov_lag;bool nvm_update_pending_nvm;bool nvm_update_pending_orom;
Signature · 1 line
2.40.1
Re: [PATCH iwl-next v4 02/10] ice: Add driver support for firmware changes for LAG
On Fri, Jun 09, 2023 at 02:16:18PM -0700, Dave Ertman wrote:
...
Hi Dave,
some minor feedback from my side.
drivers/net/ethernet/intel/ice/ice_main.c static int __init ice_module_init(void) · line 5584
Quoted 7 lines
drivers/net/ethernet/intel/ice/ice_main.c +3
-0@@ -5576,10 +5579,18 @@ static int __init ice_module_init(void)return -ENOMEM ; } + ice_lag_wq =alloc_ordered_workqueue ("ice_lag_wq" ,0 ); +if (!ice_lag_wq) { +pr_err ("Failed to create LAG workqueue\n" );
Is the allocation failure already logged by core code? If so, perhaps this is unnecessary?
drivers/net/ethernet/intel/ice/ice_main.c static int __init ice_module_init(void) · line 5596
Quoted 12 lines
drivers/net/ethernet/intel/ice/ice_main.c +5
-0+destroy_workqueue (ice_wq); +return -ENOMEM ; + } + status =pci_register_driver (&ice_driver);if (status) {pr_err ("failed to register PCI driver, err %d\n" , status);destroy_workqueue (ice_wq); +destroy_workqueue (ice_lag_wq); }return status;
As there are now a few things (more than zero) to unwind I think it would be best to use the Kernel's idiomatic goto-based approach.
(Completely untested!)
ice_lag_wq = alloc_ordered_workqueue("ice_lag_wq", 0);
if (!ice_lag_wq) {
pr_err("Failed to create LAG workqueue\n");
status = -ENOMEM;
goto err_destroy_ice_wq;
}
status = pci_register_driver(&ice_driver);
if (status) {
pr_err("failed to register PCI driver, err %d\n", status);
goto err_destroy_lag_wq;
}
return status;err_destroy_lag_wq:
destroy_workqueue(ice_lag_wq); err_destroy_ice_wq: destroy_workqueue(ice_wq); return status
drivers/net/ethernet/intel/ice/ice_main.c static void __exit ice_module_exit(void) · line 5613
Quoted 8 lines
drivers/net/ethernet/intel/ice/ice_main.c +1
-0@@ -5596,6 +5607,7 @@ static void __exit ice_module_exit(void) {pci_unregister_driver (&ice_driver);destroy_workqueue (ice_wq); +destroy_workqueue (ice_lag_wq);pr_info ("module unloaded\n" ); }module_exit (ice_module_exit);
...
_______________________________________________
Intel-wired-lan mailing list
[email protected]
https://lists.osuosl.org/mailman/listinfo/intel-wired-lan
RE: [PATCH iwl-next v4 02/10] ice: Add driver support for firmware changes for LAG
Quoted 21 lines
-----Original Message-----
From: Simon Horman <[email protected]>
Sent: Wednesday, June 14, 2023 4:18 AM
To: Ertman, David M <[email protected]>
Cc: [email protected]; [email protected]; [email protected]
Subject: Re: [PATCH iwl-next v4 02/10] ice: Add driver support for firmware changes for LAGOn Fri, Jun 09, 2023 at 02:16:18PM -0700, Dave Ertman wrote:
...
Hi Dave,
some minor feedback from my side.
Quoted 4 lines
drivers/net/ethernet/intel/ice/ice_main.c +0
-0@@ -5576,10 +5579,18 @@ static int __init ice_module_init(void)return -ENOMEM ; }
Quoted 6 lines
drivers/net/ethernet/intel/ice/ice_main.c static int __init ice_module_init(void) · line 5584
Quoted 3 lines
drivers/net/ethernet/intel/ice/ice_main.c +3
-0+ ice_lag_wq =alloc_ordered_workqueue ("ice_lag_wq" ,0 ); +if (!ice_lag_wq) { +pr_err ("Failed to create LAG workqueue\n" );Is the allocation failure already logged by core code? If so, perhaps this is unnecessary?
I do not see any messaging from the core, so I should probably leave this here unless you can point out something I missed 😊
Quoted 12 lines
Quoted 12 lines
drivers/net/ethernet/intel/ice/ice_main.c +5
-0+destroy_workqueue (ice_wq); +return -ENOMEM ; + } + status =pci_register_driver (&ice_driver);if (status) {pr_err ("failed to register PCI driver, err %d\n" , status);destroy_workqueue (ice_wq); +destroy_workqueue (ice_lag_wq); }
Quoted 5 lines
drivers/net/ethernet/intel/ice/ice_main.c static int __init ice_module_init(void) · line 5596
Quoted 1 line
drivers/net/ethernet/intel/ice/ice_main.c +0
-0return status;As there are now a few things (more than zero) to unwind I think it would be best to use the Kernel's idiomatic goto-based approach.
Sounds reasonable - will switch to a goto based approach.
Changes to come in v5.
DaveE
Quoted 34 lines
(Completely untested!)
ice_lag_wq = alloc_ordered_workqueue("ice_lag_wq", 0); if (!ice_lag_wq) { pr_err("Failed to create LAG workqueue\n"); status = -ENOMEM; goto err_destroy_ice_wq; } status = pci_register_driver(&ice_driver); if (status) { pr_err("failed to register PCI driver, err %d\n", status); goto err_destroy_lag_wq; } return status;
err_destroy_lag_wq:destroy_workqueue(ice_lag_wq); err_destroy_ice_wq: destroy_workqueue(ice_wq); return statusQuoted 8 lines
drivers/net/ethernet/intel/ice/ice_main.c +1
-0@@ -5596,6 +5607,7 @@ static void __exit ice_module_exit(void) {pci_unregister_driver (&ice_driver);destroy_workqueue (ice_wq); +destroy_workqueue (ice_lag_wq);pr_info ("module unloaded\n" ); }module_exit (ice_module_exit);...
Re: [PATCH iwl-next v4 02/10] ice: Add driver support for firmware changes for LAG
Quoted 28 lines · David M
Quoted 21 lines
-----Original Message-----
From: Simon Horman <[email protected]>
Sent: Wednesday, June 14, 2023 4:18 AM
To: Ertman, David M <[email protected]>
Cc: [email protected]; [email protected]; [email protected]
Subject: Re: [PATCH iwl-next v4 02/10] ice: Add driver support for firmware changes for LAGOn Fri, Jun 09, 2023 at 02:16:18PM -0700, Dave Ertman wrote:
...
Hi Dave,
some minor feedback from my side.
Quoted 4 lines
drivers/net/ethernet/intel/ice/ice_main.c +0
-0@@ -5576,10 +5579,18 @@ static int __init ice_module_init(void)return -ENOMEM ; }Quoted 6 lines
drivers/net/ethernet/intel/ice/ice_main.c static int __init ice_module_init(void) · line 5584
Quoted 3 lines
drivers/net/ethernet/intel/ice/ice_main.c +3
-0+ ice_lag_wq =alloc_ordered_workqueue ("ice_lag_wq" ,0 ); +if (!ice_lag_wq) { +pr_err ("Failed to create LAG workqueue\n" );Is the allocation failure already logged by core code? If so, perhaps this is unnecessary?
Quoted 2 lines
I do not see any messaging from the core, so I should probably leave this here unless you can point out something I missed 😊
Let's keep it :)
...
_______________________________________________
Intel-wired-lan mailing list
[email protected]
https://lists.osuosl.org/mailman/listinfo/intel-wired-lan
Re: [PATCH iwl-next v4 02/10] ice: Add driver support for firmware changes for LAG
In reply to Dave ErtmanQuoted 104 lines · Dave Ertman
Caution: This message originated from an External Source. Use proper caution when opening attachments, clicking links, or responding.
Add the defines, fields, and detection code for FW support of LAG for SRIOV. Also exposes some previously static functions to allow access in the lag code.
Clean up code that is unused or not needed for LAG support. Also add an ordered workqueue for processing LAG events.
Reviewed-by Daniel Machon <[email protected]>Signed-off-by Dave Ertman <[email protected]>--- drivers/net/ethernet/intel/ice/ice.h | 5 ++ .../net/ethernet/intel/ice/ice_adminq_cmd.h | 3 ++ drivers/net/ethernet/intel/ice/ice_common.c | 8 +++ drivers/net/ethernet/intel/ice/ice_lag.c | 53 ++++++++++--------- drivers/net/ethernet/intel/ice/ice_lib.c | 2 +- drivers/net/ethernet/intel/ice/ice_lib.h | 1 + drivers/net/ethernet/intel/ice/ice_main.c | 12 +++++ drivers/net/ethernet/intel/ice/ice_type.h | 2 + 8 files changed, 59 insertions(+), 27 deletions(-)drivers/net/ethernet/intel/ice/ice.h +5
-0@@ -200,6 +200,8 @@ enum ice_feature {ICE_F_PTP_EXTTS ,ICE_F_SMA_CTRL ,ICE_F_GNSS , +ICE_F_ROCE_LAG , +ICE_F_SRIOV_LAG , ICE_F_MAX };@@ -569,6 +571,7 @@ struct ice_pf {struct mutex sw_mutex;/* lock for protecting VSI alloc flow */ struct mutex tc_mutex;/* lock to protect TC changes */ struct mutex adev_mutex;/* lock to protect aux device access */ +struct mutex lag_mutex;/* protect ice_lag struct in PF */ u32 msg_enable;struct ice_ptp ptp;struct gnss_serial *gnss_serial;@@ -639,6 +642,8 @@ struct ice_pf {struct ice_agg_node vf_agg_node[ICE_MAX_VF_AGG_NODES ]; }; +extern struct workqueue_struct *ice_lag_wq; +struct ice_netdev_priv {struct ice_vsi *vsi;struct ice_repr *repr;drivers/net/ethernet/intel/ice/ice_adminq_cmd.h +3
-0@@ -120,6 +120,9 @@ struct ice_aqc_list_caps_elem {#define ICE_AQC_CAPS_PCIE_RESET_AVOIDANCE 0x0076#define ICE_AQC_CAPS_POST_UPDATE_RESET_RESTRICT 0x0077#define ICE_AQC_CAPS_NVM_MGMT 0x0080 +#define ICE_AQC_CAPS_FW_LAG_SUPPORT 0x0092 +#define ICE_AQC_BIT_ROCEV2_LAG 0x01 +#define ICE_AQC_BIT_SRIOV_LAG 0x02u8 major_ver;u8 minor_ver;drivers/net/ethernet/intel/ice/ice_common.c +8
-0@@ -2241,6 +2241,14 @@ ice_parse_common_caps(struct ice_hw *hw, struct ice_hw_common_caps *caps,"%s: reset_restrict_support = %d\n" , prefix, caps->reset_restrict_support);break ; +case ICE_AQC_CAPS_FW_LAG_SUPPORT : + caps->roce_lag = !!(number &ICE_AQC_BIT_ROCEV2_LAG ); +ice_debug (hw,ICE_DBG_INIT ,"%s: roce_lag = %u\n" , + prefix, caps->roce_lag); + caps->sriov_lag = !!(number &ICE_AQC_BIT_SRIOV_LAG ); +ice_debug (hw,ICE_DBG_INIT ,"%s: sriov_lag = %u\n" , + prefix, caps->sriov_lag); +break ;default :/* Not one of the recognized common capabilities */ found = false;drivers/net/ethernet/intel/ice/ice_lag.c +4
-0@@ -4,8 +4,12 @@/* Link Aggregation code */ #include "ice.h" +#include "ice_lib.h" #include "ice_lag.h" +#define ICE_LAG_RES_SHARED BIT(14) +#define ICE_LAG_RES_VALID BIT(15) +/** * ice_lag_set_primary - set PF LAG state as Primary * @lag: LAG info struct
drivers/net/ethernet/intel/ice/ice_lag.c static void ice_lag_unregister(struct ice_lag *lag, struct net_device *netdev) · line 236
Quoted 8 lines
drivers/net/ethernet/intel/ice/ice_lag.c +5
-0@@ -225,6 +229,26 @@ static void ice_lag_unregister(struct ice_lag *lag, struct net_device *netdev) lag->role =ICE_LAG_NONE ; } +/** +* ice_lag_check_nvm_support - Check for NVM support for LAG +* @pf: PF struct +*/ +static void ice_lag_check_nvm_support (struct ice_pf *pf)
Nit, but this name is a bit misleading to me. I would expect it to be called something like "ice_lag_init_feature_support_flag()" or something similar that better describes what the function is doing.
drivers/net/ethernet/intel/ice/ice_lag.c static void ice_lag_unregister(struct ice_lag *lag, struct net_device *netdev) · line 240
Quoted 4 lines
drivers/net/ethernet/intel/ice/ice_lag.c +4
-0+{ +struct ice_hw_dev_caps *caps; + + caps = &pf->hw.dev_caps;
Nit, but since you are already creating a local variable you could go one level further to the common_cap, so it could be:
common_cap->roce_lag and common_cap->sriov_lag
Quoted 11 lines
drivers/net/ethernet/intel/ice/ice_lag.c +11
-0+if (caps->common_cap.roce_lag) +ice_set_feature_support (pf,ICE_F_ROCE_LAG ); +else +ice_clear_feature_support (pf,ICE_F_ROCE_LAG ); + +if (caps->common_cap.sriov_lag) +ice_set_feature_support (pf,ICE_F_SRIOV_LAG ); +else +ice_clear_feature_support (pf,ICE_F_SRIOV_LAG ); +} +
[...]
RE: [PATCH iwl-next v4 02/10] ice: Add driver support for firmware changes for LAG
Quoted 24 lines
-----Original Message-----
From: Brett Creeley <[email protected]>
Sent: Wednesday, June 14, 2023 2:24 PM
To: Ertman, David M <[email protected]>; intel-wired- [email protected]
Cc: [email protected]; [email protected]; [email protected]
Subject: Re: [PATCH iwl-next v4 02/10] ice: Add driver support for firmware changes for LAGQuoted 1 line · Dave Ertman
Caution: This message originated from an External Source. Use proper
caution when opening attachments, clicking links, or responding.
Quoted 11 lines
Add the defines, fields, and detection code for FW support of LAG for SRIOV. Also exposes some previously static functions to allow access in the lag code.
Clean up code that is unused or not needed for LAG support. Also add an ordered workqueue for processing LAG events.
Reviewed-by Daniel Machon <[email protected]>Signed-off-by Dave Ertman <[email protected]>
...
Quoted 9 lines
drivers/net/ethernet/intel/ice/ice_lag.c static void ice_lag_unregister(struct ice_lag *lag, struct net_device *netdev) · line 236
Quoted 5 lines
drivers/net/ethernet/intel/ice/ice_lag.c +5
-0+/** +* ice_lag_check_nvm_support - Check for NVM support for LAG +* @pf: PF struct +*/ +static void ice_lag_check_nvm_support (struct ice_pf *pf)Nit, but this name is a bit misleading to me. I would expect it to be called something like "
ice_lag_init_feature_support_flag()" or something similar that better describes what the function is doing.
Name changed
Quoted 10 lines
drivers/net/ethernet/intel/ice/ice_lag.c static void ice_lag_unregister(struct ice_lag *lag, struct net_device *netdev) · line 240
Quoted 5 lines
drivers/net/ethernet/intel/ice/ice_lag.c +4
-0+{ +struct ice_hw_dev_caps *caps; + + caps = &pf->hw.dev_caps;Nit, but since you are already creating a local variable you could go one level further to the
common_cap, so it could be:
common_cap->roce_lagandcommon_cap->sriov_lag
Variable changed to go down one mor level.
Changes to come out in v5
DaveE
Quoted 15 lines
Quoted 12 lines
drivers/net/ethernet/intel/ice/ice_lag.c +11
-0+if (caps->common_cap.roce_lag) +ice_set_feature_support (pf,ICE_F_ROCE_LAG ); +else +ice_clear_feature_support (pf,ICE_F_ROCE_LAG ); + +if (caps->common_cap.sriov_lag) +ice_set_feature_support (pf,ICE_F_SRIOV_LAG ); +else +ice_clear_feature_support (pf,ICE_F_SRIOV_LAG ); +} +[...]
PATCH v4 3/10 ice: changes to the interface with the HW and FW for SRIOV_VF+LAG
In reply to Dave ErtmanAdd defines needed for interaction with the FW admin queue interface in relation to supporting LAG and SRIOV VFs interacting.
Add code, or make non-static previously static functions, to access the new and changed admin queue calls for LAG.
--- .../net/ethernet/intel/ice/ice_adminq_cmd.h | 50 +++++++++++- drivers/net/ethernet/intel/ice/ice_common.c | 47 +++++++++++ drivers/net/ethernet/intel/ice/ice_common.h | 4 + drivers/net/ethernet/intel/ice/ice_sched.c | 14 ++-- drivers/net/ethernet/intel/ice/ice_sched.h | 21 +++++ drivers/net/ethernet/intel/ice/ice_switch.c | 78 ++++++++++++++----- drivers/net/ethernet/intel/ice/ice_switch.h | 26 +++++++ 7 files changed, 211 insertions(+), 29 deletions(-)
drivers/net/ethernet/intel/ice/ice_adminq_cmd.h +49 -1
@@ -235,6 +235,8 @@ struct ice_aqc_set_port_params {#define ICE_AQC_SET_P_PARAMS_DOUBLE_VLAN_ENA BIT(2)__le16 bad_frame_vsi;__le16 swid; +#define ICE_AQC_PORT_SWID_VALID BIT(15) +#define ICE_AQC_PORT_SWID_M 0xFFu8 reserved[10 ]; };
@@ -244,10 +246,12 @@ struct ice_aqc_set_port_params {* Allocate Resources command (indirect 0x0208) * Free Resources command (indirect 0x0209) * Get Allocated Resource Descriptors Command (indirect 0x020A) +* Share Resource command (indirect 0x020B) */ #define ICE_AQC_RES_TYPE_VSI_LIST_REP 0x03#define ICE_AQC_RES_TYPE_VSI_LIST_PRUNE 0x04#define ICE_AQC_RES_TYPE_RECIPE 0x05 +#define ICE_AQC_RES_TYPE_SWID 0x07#define ICE_AQC_RES_TYPE_FDIR_COUNTER_BLOCK 0x21#define ICE_AQC_RES_TYPE_FDIR_GUARANTEED_ENTRIES 0x22#define ICE_AQC_RES_TYPE_FDIR_SHARED_ENTRIES 0x23
@@ -267,6 +271,7 @@ struct ice_aqc_set_port_params {/* Allocate Resources command (indirect 0x0208) * Free Resources command (indirect 0x0209) +* Share Resource command (indirect 0x020B) */ struct ice_aqc_alloc_free_res_cmd {__le16 num_entries;/* Number of Resource entries */
@@ -821,7 +826,11 @@ struct ice_aqc_txsched_move_grp_info_hdr {__le32 src_parent_teid;__le32 dest_parent_teid;__le16 num_elems; -__le16 reserved; +u8 mode; +#define ICE_AQC_MOVE_ELEM_MODE_SAME_PF 0x0 +#define ICE_AQC_MOVE_ELEM_MODE_GIVE_OWN 0x1 +#define ICE_AQC_MOVE_ELEM_MODE_KEEP_OWN 0x2 +u8 reserved; };struct ice_aqc_move_elem {
@@ -1923,6 +1932,42 @@ struct ice_aqc_dis_txq_item {__le16 q_id[]; } __packed; +/* Move/Reconfigure Tx queue (indirect 0x0C32) */ +struct ice_aqc_cfg_txqs { +u8 cmd_type; +#define ICE_AQC_Q_CFG_MOVE_NODE 0x1 +#define ICE_AQC_Q_CFG_TC_CHNG 0x2 +#define ICE_AQC_Q_CFG_MOVE_TC_CHNG 0x3 +#define ICE_AQC_Q_CFG_SUBSEQ_CALL BIT(2) +#define ICE_AQC_Q_CFG_FLUSH BIT(3) +u8 num_qs; +u8 port_num_chng; +#define ICE_AQC_Q_CFG_SRC_PRT_M 0x7 +#define ICE_AQC_Q_CFG_DST_PRT_S 3 +#define ICE_AQC_Q_CFG_DST_PRT_M (0x7 << ICE_AQC_Q_CFG_DST_PRT_S) +u8 time_out; +#define ICE_AQC_Q_CFG_TIMEOUT_S 2 +#define ICE_AQC_Q_CFG_TIMEOUT_M (0x1F << ICE_AQC_Q_CFG_TIMEOUT_S) +__le32 blocked_cgds; +__le32 addr_high; +__le32 addr_low; +}; + +/* Per Q struct for Move/Reconfigure Tx LAN Queues (indirect 0x0C32) */ +struct ice_aqc_cfg_txq_perq { +__le16 q_handle; +u8 tc; +u8 rsvd; +__le32 q_teid; +}; + +/* The buffer for Move/Reconfigure Tx LAN Queues (indirect 0x0C32) */ +struct ice_aqc_cfg_txqs_buf { +__le32 src_parent_teid; +__le32 dst_parent_teid; +struct ice_aqc_cfg_txq_perq queue_info[]; +}; +/* Add Tx RDMA Queue Set (indirect 0x0C33) */ struct ice_aqc_add_rdma_qset {u8 num_qset_grps;
@@ -2181,6 +2226,7 @@ struct ice_aq_desc {struct ice_aqc_neigh_dev_req neigh_dev;struct ice_aqc_add_txqs add_txqs;struct ice_aqc_dis_txqs dis_txqs; +struct ice_aqc_cfg_txqs cfg_txqs;struct ice_aqc_add_rdma_qset add_rdma_qset;struct ice_aqc_add_get_update_free_vsi vsi_cmd;struct ice_aqc_add_update_free_vsi_resp add_update_free_vsi_res;
@@ -2263,6 +2309,7 @@ enum ice_adminq_opc {/* Alloc/Free/Get Resources */ ice_aqc_opc_alloc_res =0x0208 , ice_aqc_opc_free_res =0x0209 , + ice_aqc_opc_share_res =0x020B , ice_aqc_opc_set_vlan_mode_parameters =0x020C , ice_aqc_opc_get_vlan_mode_parameters = 0x020D,
@@ -2356,6 +2403,7 @@ enum ice_adminq_opc {/* Tx queue handling commands/events */ ice_aqc_opc_add_txqs =0x0C30 , ice_aqc_opc_dis_txqs =0x0C31 , + ice_aqc_opc_cfg_txqs =0x0C32 , ice_aqc_opc_add_rdma_qset = 0x0C33,/* package commands */
drivers/net/ethernet/intel/ice/ice_common.c +47 -0
53 lines not on this page · raw message
drivers/net/ethernet/intel/ice/ice_common.h +4 -0
@@ -186,6 +186,10 @@ int ice_ena_vsi_txq(struct ice_port_info *pi, u16 vsi_handle, u8 tc, u16 q_handle, u8 num_qgrps, struct ice_aqc_add_tx_qgrp *buf, u16 buf_size, struct ice_sq_cd *cd); +int +ice_aq_cfg_lan_txq (struct ice_hw *hw,struct ice_aqc_cfg_txqs_buf *buf, +u16 buf_size,u16 num_qs,u8 oldport,u8 newport, +struct ice_sq_cd *cd);int ice_replay_vsi (struct ice_hw *hw,u16 vsi_handle);void ice_replay_post (struct ice_hw *hw);void ice_output_fw_log (struct ice_hw *hw,struct ice_aq_desc *desc,void *buf);
drivers/net/ethernet/intel/ice/ice_sched.c +7 -7
@@ -447,7 +447,7 @@ ice_aq_cfg_sched_elems(struct ice_hw *hw, u16 elems_req,* * Move scheduling elements (0x0408) */ -static int +int ice_aq_move_sched_elems (struct ice_hw *hw,u16 grps_req,struct ice_aqc_move_elem *buf,u16 buf_size,u16 *grps_movd,struct ice_sq_cd *cd)
@@ -526,7 +526,7 @@ ice_aq_query_sched_res(struct ice_hw *hw, u16 buf_size,* * This function suspends or resumes HW nodes */ -static int +int ice_sched_suspend_resume_elems (struct ice_hw *hw,u8 num_nodes,u32 *node_teids,bool suspend) {
@@ -1057,7 +1057,7 @@ ice_sched_add_nodes_to_hw_layer(struct ice_port_info *pi,* * This function add nodes to a given layer. */ -static int +int ice_sched_add_nodes_to_layer(struct ice_port_info *pi, struct ice_sched_node *tc_node, struct ice_sched_node *parent, u8 layer,
@@ -1132,7 +1132,7 @@ static u8 ice_sched_get_qgrp_layer(struct ice_hw *hw)* * This function returns the current VSI layer number */ -static u8 ice_sched_get_vsi_layer (struct ice_hw *hw) +u8 ice_sched_get_vsi_layer (struct ice_hw *hw) {/* Num Layers VSI layer * 9 6
@@ -1155,7 +1155,7 @@ static u8 ice_sched_get_vsi_layer(struct ice_hw *hw)* * This function returns the current aggregator layer number */ -static u8 ice_sched_get_agg_layer (struct ice_hw *hw) +u8 ice_sched_get_agg_layer (struct ice_hw *hw) {/* Num Layers aggregator layer * 9 4
@@ -1590,7 +1590,7 @@ ice_sched_get_vsi_node(struct ice_port_info *pi, struct ice_sched_node *tc_node,* This function retrieves an aggregator node for a given aggregator ID from * a given TC branch */ -static struct ice_sched_node * +struct ice_sched_node *ice_sched_get_agg_node (struct ice_port_info *pi,struct ice_sched_node *tc_node,u32 agg_id) {
@@ -2152,7 +2152,7 @@ ice_get_agg_info(struct ice_hw *hw, u32 agg_id)* This function walks through the aggregator subtree to find a free parent * node */ -static struct ice_sched_node * +struct ice_sched_node *ice_sched_get_free_vsi_parent (struct ice_hw *hw,struct ice_sched_node *node,u16 *num_nodes) {
drivers/net/ethernet/intel/ice/ice_sched.h +21 -0
@@ -146,8 +146,29 @@ ice_sched_set_node_bw_lmt_per_tc(struct ice_port_info *pi, u32 id, enum ice_agg_type agg_type, u8 tc, enum ice_rl_type rl_type, u32 bw);int ice_cfg_rl_burst_size (struct ice_hw *hw,u32 bytes); +int +ice_sched_suspend_resume_elems (struct ice_hw *hw,u8 num_nodes,u32 *node_teids, +bool suspend); +struct ice_sched_node * +ice_sched_get_agg_node (struct ice_port_info *pi,struct ice_sched_node *tc_node, +u32 agg_id); +u8 ice_sched_get_agg_layer (struct ice_hw *hw); +u8 ice_sched_get_vsi_layer (struct ice_hw *hw); +struct ice_sched_node * +ice_sched_get_free_vsi_parent (struct ice_hw *hw,struct ice_sched_node *node, +u16 *num_nodes); +int +ice_sched_add_nodes_to_layer (struct ice_port_info *pi, +struct ice_sched_node *tc_node, +struct ice_sched_node *parent,u8 layer, +u16 num_nodes,u32 *first_node_teid, +u16 *num_nodes_added);void ice_sched_replay_agg_vsi_preinit (struct ice_hw *hw);void ice_sched_replay_agg (struct ice_hw *hw); +int +ice_aq_move_sched_elems (struct ice_hw *hw,u16 grps_req, +struct ice_aqc_move_elem *buf,u16 buf_size, +u16 *grps_movd,struct ice_sq_cd *cd);int ice_replay_vsi_agg (struct ice_hw *hw,u16 vsi_handle);int ice_sched_replay_q_bw (struct ice_port_info *pi,struct ice_q_ctx *q_ctx);#endif /* _ICE_SCHED_H_ */
drivers/net/ethernet/intel/ice/ice_switch.c +57 -21
144 lines not on this page · raw message
drivers/net/ethernet/intel/ice/ice_switch.h +26 -0
@@ -24,6 +24,14 @@#define ICE_PROFID_IPV4_PFCP_NODE 79#define ICE_PROFID_IPV6_PFCP_SESSION 82 +#define ICE_SW_RULE_VSI_LIST_SIZE (s, n) struct_size((s), vsi, (n)) +#define ICE_SW_RULE_RX_TX_HDR_SIZE (s, l) struct_size((s), hdr_data, (l)) +#define ICE_SW_RULE_RX_TX_ETH_HDR_SIZE (s) \ + ICE_SW_RULE_RX_TX_HDR_SIZE((s), DUMMY_ETH_HDR_LEN) +#define ICE_SW_RULE_RX_TX_NO_HDR_SIZE (s) \ + ICE_SW_RULE_RX_TX_HDR_SIZE((s), 0) +#define ICE_SW_RULE_LG_ACT_SIZE (s, n) struct_size((s), act, (n)) +/* VSI context structure for add/get/update/free operations */ struct ice_vsi_ctx {u16 vsi_num;
@@ -347,6 +355,7 @@ ice_alloc_res_cntr(struct ice_hw *hw, u8 type, u8 alloc_shared, u16 num_items,int ice_free_res_cntr (struct ice_hw *hw,u8 type,u8 alloc_shared,u16 num_items,u16 counter_id); +int ice_share_res (struct ice_hw *hw,u16 type,u8 shared,u16 res_id);/* Switch/bridge related commands */ void ice_rule_add_tunnel_metadata (struct ice_adv_lkup_elem *lkup);
@@ -404,4 +413,21 @@ int ice_update_recipe_lkup_idx(struct ice_hw *hw, struct ice_update_recipe_lkup_idx_params *params);void ice_change_proto_id_to_dvm (void ); +struct ice_vsi_list_map_info * +ice_find_vsi_list_entry (struct ice_hw *hw,u8 recp_id,u16 vsi_handle, +u16 *vsi_list_id); +int ice_alloc_recipe (struct ice_hw *hw,u16 *rid); +int ice_aq_get_recipe (struct ice_hw *hw, +struct ice_aqc_recipe_data_elem *s_recipe_list, +u16 *num_recipes,u16 recipe_root,struct ice_sq_cd *cd); +int ice_aq_add_recipe (struct ice_hw *hw, +struct ice_aqc_recipe_data_elem *s_recipe_list, +u16 num_recipes,struct ice_sq_cd *cd); +int +ice_aq_get_recipe_to_profile (struct ice_hw *hw,u32 profile_id,u8 *r_bitmap, +struct ice_sq_cd *cd); +int +ice_aq_map_recipe_to_profile (struct ice_hw *hw,u32 profile_id,u8 *r_bitmap, +struct ice_sq_cd *cd); +#endif /* _ICE_SWITCH_H_ */
Signature · 1 line
2.40.1
PATCH v4 4/10 ice: implement lag netdev event handler
In reply to Dave ErtmanThe event handler for LAG will create a work item to place on the ordered workqueue to be processed.
Add in defines for training packets and new recipes to be used by the switching block of the HW for LAG packet steering.
Update the ice_lag struct to reflect the new processing methodology.
--- drivers/net/ethernet/intel/ice/ice_lag.c | 125 ++++++++++++++++++++--- drivers/net/ethernet/intel/ice/ice_lag.h | 30 +++++- 2 files changed, 141 insertions(+), 14 deletions(-)
drivers/net/ethernet/intel/ice/ice_lag.c +112 -13
@@ -56,11 +56,10 @@ static void ice_lag_set_backup(struct ice_lag *lag)*/ static void ice_display_lag_info (struct ice_lag *lag) { -const char *name, *peer, *upper, *role, *bonded, *primary; +const char *name, *upper, *role, *bonded, *primary;struct device *dev = &lag->pf->pdev->dev; name = lag->netdev ?netdev_name (lag->netdev) :"unset" ; - peer = lag->peer_netdev ?netdev_name (lag->peer_netdev) :"unset" ; upper = lag->upper_netdev ?netdev_name (lag->upper_netdev) :"unset" ; primary = lag->primary ?"TRUE" :"FALSE" ; bonded = lag->bonded ?"BONDED" :"UNBONDED" ;
@@ -82,8 +81,8 @@ static void ice_display_lag_info(struct ice_lag *lag) role ="ERROR" ; } -dev_dbg (dev,"%s %s, peer:%s, upper:%s, role:%s, primary:%s\n" , name, - bonded, peer, upper, role, primary); +dev_dbg (dev,"%s %s, upper:%s, role:%s, primary:%s\n" , name, bonded, + upper, role, primary); }/**
@@ -198,7 +197,6 @@ ice_lag_unlink(struct ice_lag *lag, lag->upper_netdev =NULL ; } - lag->peer_netdev =NULL ;ice_set_rdma_cap (pf); lag->bonded = false; lag->role =ICE_LAG_NONE ;
@@ -288,6 +286,60 @@ static void ice_lag_changeupper_event(struct ice_lag *lag, void *ptr)ice_display_lag_info (lag); } +/** +* ice_lag_process_event - process a task assigned to the lag_wq +* @work: pointer to work_struct +*/ +static void ice_lag_process_event (struct work_struct *work) +{ +struct netdev_notifier_changeupper_info *info; +struct ice_lag_work *lag_work; +struct net_device *netdev; +struct list_head *tmp, *n; +struct ice_pf *pf; + + lag_work = container_of(work, struct ice_lag_work, lag_task); + pf = lag_work->lag->pf; + +mutex_lock (&pf->lag_mutex); + lag_work->lag->netdev_head = &lag_work->netdev_list.node; + +switch (lag_work->event) { +case NETDEV_CHANGEUPPER : + info = &lag_work->info.changeupper_info; +if (ice_is_feature_supported (pf,ICE_F_SRIOV_LAG )) +ice_lag_changeupper_event (lag_work->lag, info); +break ; +case NETDEV_BONDING_INFO : +ice_lag_info_event (lag_work->lag, &lag_work->info.bonding_info); +break ; +case NETDEV_UNREGISTER : +if (ice_is_feature_supported (pf,ICE_F_SRIOV_LAG )) { + netdev = lag_work->info.bonding_info.info.dev; +if ((netdev == lag_work->lag->netdev || + lag_work->lag->primary) && lag_work->lag->bonded) +ice_lag_unregister (lag_work->lag, netdev); + } +break ; +default : +break ; + } + +/* cleanup resources allocated for this work item */ +list_for_each_safe (tmp, n, &lag_work->netdev_list.node) { +struct ice_lag_netdev_list *entry; + + entry = list_entry(tmp, struct ice_lag_netdev_list, node); +list_del (&entry->node); +kfree (entry); + } + lag_work->lag->netdev_head =NULL ; + +mutex_unlock (&pf->lag_mutex); + +kfree (work); +} +/** * ice_lag_event_handler - handle LAG events from netdev * @notif_blk: notifier block registered by this netdev
@@ -299,31 +351,79 @@ ice_lag_event_handler(struct notifier_block *notif_blk, unsigned long event, void *ptr) {struct net_device *netdev =netdev_notifier_info_to_dev (ptr); +struct net_device *upper_netdev; +struct ice_lag_work *lag_work;struct ice_lag *lag; - lag = container_of(notif_blk, struct ice_lag, notif_block); +if (!netif_is_ice (netdev)) +return NOTIFY_DONE ; + +if (event !=NETDEV_CHANGEUPPER && event !=NETDEV_BONDING_INFO && + event !=NETDEV_UNREGISTER ) +return NOTIFY_DONE ; +if (!(netdev->priv_flags &IFF_BONDING )) +return NOTIFY_DONE ; + + lag = container_of(notif_blk, struct ice_lag, notif_block);if (!lag->netdev)return NOTIFY_DONE ; -/* Check that the netdev is in the working namespace */ if (!net_eq (dev_net (netdev), &init_net))return NOTIFY_DONE ; +/* This memory will be freed at the end of ice_lag_process_event */ + lag_work =kzalloc (sizeof (*lag_work),GFP_KERNEL ); +if (!lag_work) +return -ENOMEM ; + + lag_work->event_netdev = netdev; + lag_work->lag = lag; + lag_work->event = event; +if (event ==NETDEV_CHANGEUPPER ) { +struct netdev_notifier_changeupper_info *info; + + info = ptr; + upper_netdev = info->upper_dev; + }else { + upper_netdev =netdev_master_upper_dev_get (netdev); + } + +INIT_LIST_HEAD (&lag_work->netdev_list.node); +if (upper_netdev) { +struct ice_lag_netdev_list *nd_list; +struct net_device *tmp_nd; + +rcu_read_lock (); +for_each_netdev_in_bond_rcu (upper_netdev, tmp_nd) { + nd_list =kzalloc (sizeof (*nd_list),GFP_KERNEL ); +if (!nd_list) +break ; + + nd_list->netdev = tmp_nd; +list_add (&nd_list->node, &lag_work->netdev_list.node); + } +rcu_read_unlock (); + } +switch (event) {case NETDEV_CHANGEUPPER : -ice_lag_changeupper_event (lag, ptr); + lag_work->info.changeupper_info = + *((struct netdev_notifier_changeupper_info *)ptr);break ;case NETDEV_BONDING_INFO : -ice_lag_info_event (lag, ptr); -break ; -case NETDEV_UNREGISTER : -ice_lag_unregister (lag, netdev); + lag_work->info.bonding_info = + *((struct netdev_notifier_bonding_info *)ptr);break ;default : + lag_work->info.notifier_info = + *((struct netdev_notifier_info *)ptr);break ; } +INIT_WORK (&lag_work->lag_task, ice_lag_process_event); +queue_work (ice_lag_wq, &lag_work->lag_task); +return NOTIFY_DONE ; }
@@ -398,7 +498,6 @@ int ice_init_lag(struct ice_pf *pf) lag->netdev = vsi->netdev; lag->role =ICE_LAG_NONE ; lag->bonded = false; - lag->peer_netdev =NULL ; lag->upper_netdev =NULL ; lag->notif_block.notifier_call =NULL ;
drivers/net/ethernet/intel/ice/ice_lag.h +29 -1
@@ -14,20 +14,48 @@ enum ice_lag_role {ICE_LAG_UNSET }; +#define ICE_LAG_INVALID_PORT 0xFF +struct ice_pf ; +struct ice_vf ; + +struct ice_lag_netdev_list { +struct list_head node; +struct net_device *netdev; +};/* LAG info struct */ struct ice_lag {struct ice_pf *pf;/* backlink to PF struct */ struct net_device *netdev;/* this PF's netdev */ -struct net_device *peer_netdev;struct net_device *upper_netdev;/* upper bonding netdev */ +struct list_head *netdev_head;struct notifier_block notif_block; +s32 bond_mode; +u16 bond_swid;/* swid for primary interface */ +u8 active_port;/* lport value for the current active port */ u8 bonded:1 ;/* currently bonded */ u8 primary:1 ;/* this is primary */ +u16 pf_recipe; +u16 pf_rule_id; +u16 cp_rule_idx;u8 role; }; +/* LAG workqueue struct */ +struct ice_lag_work { +struct work_struct lag_task; +struct ice_lag_netdev_list netdev_list; +struct ice_lag *lag; +unsigned long event; +struct net_device *event_netdev; +union { +struct netdev_notifier_changeupper_info changeupper_info; +struct netdev_notifier_bonding_info bonding_info; +struct netdev_notifier_info notifier_info; + } info; +}; +int ice_init_lag (struct ice_pf *pf);void ice_deinit_lag (struct ice_pf *pf);#endif /* _ICE_LAG_H_ */
Signature · 1 line
2.40.1
Re: [PATCH iwl-next v4 04/10] ice: implement lag netdev event handler
Quoted 21 lines · Dave Ertman
Caution: This message originated from an External Source. Use proper caution when opening attachments, clicking links, or responding.
The event handler for LAG will create a work item to place on the ordered workqueue to be processed.
Add in defines for training packets and new recipes to be used by the switching block of the HW for LAG packet steering.
Update the
ice_lagstruct to reflect the new processing methodology.Signed-off-by Dave Ertman <[email protected]>--- drivers/net/ethernet/intel/ice/ice_lag.c | 125 ++++++++++++++++++++--- drivers/net/ethernet/intel/ice/ice_lag.h | 30 +++++- 2 files changed, 141 insertions(+), 14 deletions(-)drivers/net/ethernet/intel/ice/ice_lag.c +0
-0
[...]
Quoted 42 lines
drivers/net/ethernet/intel/ice/ice_lag.c +42
-0+/** +* ice_lag_process_event - process a task assigned to the lag_wq +* @work: pointer to work_struct +*/ +static void ice_lag_process_event (struct work_struct *work) +{ +struct netdev_notifier_changeupper_info *info; +struct ice_lag_work *lag_work; +struct net_device *netdev; +struct list_head *tmp, *n; +struct ice_pf *pf; + + lag_work = container_of(work, struct ice_lag_work, lag_task); + pf = lag_work->lag->pf; + +mutex_lock (&pf->lag_mutex); + lag_work->lag->netdev_head = &lag_work->netdev_list.node; + +switch (lag_work->event) { +case NETDEV_CHANGEUPPER : + info = &lag_work->info.changeupper_info; +if (ice_is_feature_supported (pf,ICE_F_SRIOV_LAG )) +ice_lag_changeupper_event (lag_work->lag, info); +break ; +case NETDEV_BONDING_INFO : +ice_lag_info_event (lag_work->lag, &lag_work->info.bonding_info); +break ; +case NETDEV_UNREGISTER : +if (ice_is_feature_supported (pf,ICE_F_SRIOV_LAG )) { + netdev = lag_work->info.bonding_info.info.dev; +if ((netdev == lag_work->lag->netdev || + lag_work->lag->primary) && lag_work->lag->bonded) +ice_lag_unregister (lag_work->lag, netdev); + } +break ; +default : +break ; + } + +/* cleanup resources allocated for this work item */ +list_for_each_safe (tmp, n, &lag_work->netdev_list.node) { +struct ice_lag_netdev_list *entry;
drivers/net/ethernet/intel/ice/ice_lag.c static void ice_lag_changeupper_event(struct ice_lag *lag, void *ptr) · line 340
Quoted 10 lines
drivers/net/ethernet/intel/ice/ice_lag.c +10
-0+ + entry = list_entry(tmp, struct ice_lag_netdev_list, node); +list_del (&entry->node); +kfree (entry); + } + lag_work->lag->netdev_head =NULL ; + +mutex_unlock (&pf->lag_mutex); + +kfree (work);
Should this be freeing lag_work instead?
Quoted 10 lines
drivers/net/ethernet/intel/ice/ice_lag.c +3
-0+} +/** * ice_lag_event_handler - handle LAG events from netdev * @notif_blk: notifier block registered by this netdev @@ -299,31 +351,79 @@ ice_lag_event_handler(struct notifier_block *notif_blk, unsigned long event, void *ptr) {struct net_device *netdev =netdev_notifier_info_to_dev (ptr); +struct net_device *upper_netdev;
drivers/net/ethernet/intel/ice/ice_lag.c ice_lag_event_handler(struct notifier_block *notif_blk, unsigned long event, · line 363
Quoted 10 lines
drivers/net/ethernet/intel/ice/ice_lag.c +7
-1+struct ice_lag_work *lag_work;struct ice_lag *lag; - lag = container_of(notif_blk, struct ice_lag, notif_block); +if (!netif_is_ice (netdev)) +return NOTIFY_DONE ; + +if (event !=NETDEV_CHANGEUPPER && event !=NETDEV_BONDING_INFO && + event !=NETDEV_UNREGISTER ) +return NOTIFY_DONE ;
Would it make more sense to prevent the work item and any related work if the ice_is_feature_supported(pf, ICE_F_SRIOV_LAG) check is moved to this function along with the events that require that feature?
Something like:
if ((event == NETDEV_CHANGEUPPER || event == NETDEV_UNREGISTER) &&
!ice_is_feature_supported(pf, ICE_F_SRIOV_LAG)) return NOTIFY_DONE;
Quoted 72 lines
drivers/net/ethernet/intel/ice/ice_lag.c +47
-6+if (!(netdev->priv_flags &IFF_BONDING )) +return NOTIFY_DONE ; + + lag = container_of(notif_blk, struct ice_lag, notif_block);if (!lag->netdev)return NOTIFY_DONE ; -/* Check that the netdev is in the working namespace */ if (!net_eq (dev_net (netdev), &init_net))return NOTIFY_DONE ; +/* This memory will be freed at the end of ice_lag_process_event */ + lag_work =kzalloc (sizeof (*lag_work),GFP_KERNEL ); +if (!lag_work) +return -ENOMEM ; + + lag_work->event_netdev = netdev; + lag_work->lag = lag; + lag_work->event = event; +if (event ==NETDEV_CHANGEUPPER ) { +struct netdev_notifier_changeupper_info *info; + + info = ptr; + upper_netdev = info->upper_dev; + }else { + upper_netdev =netdev_master_upper_dev_get (netdev); + } + +INIT_LIST_HEAD (&lag_work->netdev_list.node); +if (upper_netdev) { +struct ice_lag_netdev_list *nd_list; +struct net_device *tmp_nd; + +rcu_read_lock (); +for_each_netdev_in_bond_rcu (upper_netdev, tmp_nd) { + nd_list =kzalloc (sizeof (*nd_list),GFP_KERNEL ); +if (!nd_list) +break ; + + nd_list->netdev = tmp_nd; +list_add (&nd_list->node, &lag_work->netdev_list.node); + } +rcu_read_unlock (); + } +switch (event) {case NETDEV_CHANGEUPPER : -ice_lag_changeupper_event (lag, ptr); + lag_work->info.changeupper_info = + *((struct netdev_notifier_changeupper_info *)ptr);break ;case NETDEV_BONDING_INFO : -ice_lag_info_event (lag, ptr); -break ; -case NETDEV_UNREGISTER : -ice_lag_unregister (lag, netdev); + lag_work->info.bonding_info = + *((struct netdev_notifier_bonding_info *)ptr);break ;default : + lag_work->info.notifier_info = + *((struct netdev_notifier_info *)ptr);break ; } +INIT_WORK (&lag_work->lag_task, ice_lag_process_event); +queue_work (ice_lag_wq, &lag_work->lag_task); +return NOTIFY_DONE ; }
[...]
RE: [PATCH iwl-next v4 04/10] ice: implement lag netdev event handler
Quoted 85 lines
-----Original Message-----
From: Brett Creeley <[email protected]>
Sent: Wednesday, June 14, 2023 2:24 PM
To: Ertman, David M <[email protected]>; intel-wired- [email protected]
Cc: [email protected]; [email protected]; [email protected]
Subject: Re: [PATCH iwl-next v4 04/10] ice: implement lag netdev event handlerQuoted 1 line · Dave Ertman
Caution: This message originated from an External Source. Use proper
caution when opening attachments, clicking links, or responding.
Quoted 5 lines
The event handler for LAG will create a work item to place on the ordered workqueue to be processed.
Quoted 8 lines
Add in defines for training packets and new recipes to be used by the switching block of the HW for LAG packet steering.
Update the
ice_lagstruct to reflect the new processing methodology.Signed-off-by Dave Ertman <[email protected]>--- drivers/net/ethernet/intel/ice/ice_lag.c | 125 ++++++++++++++++++++---
Review
Quoted 4 lines
drivers/net/ethernet/intel/ice/ice_lag.h | 30 +++++- 2 files changed, 141 insertions(+), 14 deletions(-)(quoted diff) +0
-0
b/drivers/net/ethernet/intel/ice/ice_lag.cQuoted 3 lines
index
73bfc5cd8b37..529abfb904d0100644drivers/net/ethernet/intel/ice/ice_lag.c +0
-0[...]
Quoted 47 lines
drivers/net/ethernet/intel/ice/ice_lag.c +26
-0+/** +* ice_lag_process_event - process a task assigned to the lag_wq +* @work: pointer to work_struct +*/ +static void ice_lag_process_event (struct work_struct *work) +{ +struct netdev_notifier_changeupper_info *info; +struct ice_lag_work *lag_work; +struct net_device *netdev; +struct list_head *tmp, *n; +struct ice_pf *pf; + + lag_work = container_of(work, struct ice_lag_work, lag_task); + pf = lag_work->lag->pf; + +mutex_lock (&pf->lag_mutex); + lag_work->lag->netdev_head = &lag_work->netdev_list.node; + +switch (lag_work->event) { +case NETDEV_CHANGEUPPER : + info = &lag_work->info.changeupper_info; +if (ice_is_feature_supported (pf,ICE_F_SRIOV_LAG )) +ice_lag_changeupper_event (lag_work->lag, info); +break ; +case NETDEV_BONDING_INFO : + ice_lag_info_event(lag_work->lag, &lag_work-info.bonding_info);
drivers/net/ethernet/intel/ice/ice_lag.c +20
-0+break ; +case NETDEV_UNREGISTER : +if (ice_is_feature_supported (pf,ICE_F_SRIOV_LAG )) { + netdev = lag_work->info.bonding_info.info.dev; +if ((netdev == lag_work->lag->netdev || + lag_work->lag->primary) && lag_work->lag->bonded) +ice_lag_unregister (lag_work->lag, netdev); + } +break ; +default : +break ; + } + +/* cleanup resources allocated for this work item */ +list_for_each_safe (tmp, n, &lag_work->netdev_list.node) { +struct ice_lag_netdev_list *entry; + + entry = list_entry(tmp, struct ice_lag_netdev_list, node); +list_del (&entry->node); +kfree (entry);
Quoted 8 lines
drivers/net/ethernet/intel/ice/ice_lag.c static void ice_lag_changeupper_event(struct ice_lag *lag, void *ptr) · line 340
Quoted 6 lines
drivers/net/ethernet/intel/ice/ice_lag.c +6
-0+ } + lag_work->lag->netdev_head =NULL ; + +mutex_unlock (&pf->lag_mutex); + +kfree (work);Should this be freeing
lag_workinstead?
Nice catch!!! You are right, lag_work is what is allocated not it's element work!
Quoted 28 lines
drivers/net/ethernet/intel/ice/ice_lag.c ice_lag_event_handler(struct notifier_block
Quoted 7 lines
drivers/net/ethernet/intel/ice/ice_lag.c +2
-0+} +/** * ice_lag_event_handler - handle LAG events from netdev * @notif_blk: notifier block registered by this netdev @@ -299,31 +351,79 @@ ice_lag_event_handler(struct notifier_block
*notif_blk, unsigned long event,drivers/net/ethernet/intel/ice/ice_lag.c ice_lag_event_handler(struct notifier_block *notif_blk, unsigned long event,
Quoted 12 lines
drivers/net/ethernet/intel/ice/ice_lag.c +6
-1void *ptr) { struct net_device *netdev = netdev_notifier_info_to_dev(ptr); + struct net_device *upper_netdev; + struct ice_lag_work *lag_work; struct ice_lag *lag; - lag = container_of(notif_blk, struct ice_lag, notif_block); + if (!netif_is_ice(netdev)) + return NOTIFY_DONE; + + if (event != NETDEV_CHANGEUPPER && event !=
NETDEV_BONDING_INFO&&drivers/net/ethernet/intel/ice/ice_lag.c ice_lag_event_handler(struct notifier_block · line 363
Quoted 2 lines
drivers/net/ethernet/intel/ice/ice_lag.c +2
-0+ event != NETDEV_UNREGISTER) +return NOTIFY_DONE ;Would it make more sense to prevent the work item and any related work if the
ice_is_feature_supported(pf, ICE_F_SRIOV_LAG)check is moved to this function along with the events that require that feature?
Quoted 7 lines
Something like:
if ((event ==
NETDEV_CHANGEUPPER|| event ==NETDEV_UNREGISTER) &&!ice_is_feature_supported(pf, ICE_F_SRIOV_LAG)) return NOTIFY_DONE;
Even if SRIOV is not supported, there are still tasks that need to be performed for bonding events - e.g. unplug the RDMA aux devices, so we don't want to avoid creating a workqueue entry when feature not supported. Which makes me notice that ice_lag_changeupper_event is under a feature check and it should not be here.
Will change it. Changes coming in v5.
DaveE
Quoted 4 lines
Quoted 4 lines
drivers/net/ethernet/intel/ice/ice_lag.c +3
-0+if (!(netdev->priv_flags &IFF_BONDING )) +return NOTIFY_DONE ; +
Re: [PATCH iwl-next v4 04/10] ice: implement lag netdev event handler
Quoted 135 lines · David M
Caution: This message originated from an External Source. Use proper caution when opening attachments, clicking links, or responding.
Quoted 85 lines
-----Original Message-----
From: Brett Creeley <[email protected]>
Sent: Wednesday, June 14, 2023 2:24 PM
To: Ertman, David M <[email protected]>; intel-wired- [email protected]
Cc: [email protected]; [email protected]; [email protected]
Subject: Re: [PATCH iwl-next v4 04/10] ice: implement lag netdev event handlerQuoted 1 line · Dave Ertman
Caution: This message originated from an External Source. Use proper
caution when opening attachments, clicking links, or responding.
Quoted 5 lines
The event handler for LAG will create a work item to place on the ordered workqueue to be processed.
Quoted 8 lines
Add in defines for training packets and new recipes to be used by the switching block of the HW for LAG packet steering.
Update the
ice_lagstruct to reflect the new processing methodology.Signed-off-by Dave Ertman <[email protected]>--- drivers/net/ethernet/intel/ice/ice_lag.c | 125 ++++++++++++++++++++---
Review
Quoted 4 lines
drivers/net/ethernet/intel/ice/ice_lag.h | 30 +++++- 2 files changed, 141 insertions(+), 14 deletions(-)(quoted diff) +0
-0
b/drivers/net/ethernet/intel/ice/ice_lag.cQuoted 3 lines
index
73bfc5cd8b37..529abfb904d0100644drivers/net/ethernet/intel/ice/ice_lag.c +0
-0[...]
Quoted 47 lines
drivers/net/ethernet/intel/ice/ice_lag.c +26
-0+/** +* ice_lag_process_event - process a task assigned to the lag_wq +* @work: pointer to work_struct +*/ +static void ice_lag_process_event (struct work_struct *work) +{ +struct netdev_notifier_changeupper_info *info; +struct ice_lag_work *lag_work; +struct net_device *netdev; +struct list_head *tmp, *n; +struct ice_pf *pf; + + lag_work = container_of(work, struct ice_lag_work, lag_task); + pf = lag_work->lag->pf; + +mutex_lock (&pf->lag_mutex); + lag_work->lag->netdev_head = &lag_work->netdev_list.node; + +switch (lag_work->event) { +case NETDEV_CHANGEUPPER : + info = &lag_work->info.changeupper_info; +if (ice_is_feature_supported (pf,ICE_F_SRIOV_LAG )) +ice_lag_changeupper_event (lag_work->lag, info); +break ; +case NETDEV_BONDING_INFO : + ice_lag_info_event(lag_work->lag, &lag_work-info.bonding_info);
drivers/net/ethernet/intel/ice/ice_lag.c +20
-0+break ; +case NETDEV_UNREGISTER : +if (ice_is_feature_supported (pf,ICE_F_SRIOV_LAG )) { + netdev = lag_work->info.bonding_info.info.dev; +if ((netdev == lag_work->lag->netdev || + lag_work->lag->primary) && lag_work->lag->bonded) +ice_lag_unregister (lag_work->lag, netdev); + } +break ; +default : +break ; + } + +/* cleanup resources allocated for this work item */ +list_for_each_safe (tmp, n, &lag_work->netdev_list.node) { +struct ice_lag_netdev_list *entry; + + entry = list_entry(tmp, struct ice_lag_netdev_list, node); +list_del (&entry->node); +kfree (entry);Quoted 8 lines
drivers/net/ethernet/intel/ice/ice_lag.c static void ice_lag_changeupper_event(struct ice_lag *lag, void *ptr) · line 340
Quoted 6 lines
drivers/net/ethernet/intel/ice/ice_lag.c +6
-0+ } + lag_work->lag->netdev_head =NULL ; + +mutex_unlock (&pf->lag_mutex); + +kfree (work);Should this be freeing
lag_workinstead?Nice catch!!! You are right,
lag_workis what is allocated not it's element work!Quoted 28 lines
drivers/net/ethernet/intel/ice/ice_lag.c ice_lag_event_handler(struct notifier_block
Quoted 7 lines
drivers/net/ethernet/intel/ice/ice_lag.c +2
-0+} +/** * ice_lag_event_handler - handle LAG events from netdev * @notif_blk: notifier block registered by this netdev @@ -299,31 +351,79 @@ ice_lag_event_handler(struct notifier_block
*notif_blk, unsigned long event,drivers/net/ethernet/intel/ice/ice_lag.c ice_lag_event_handler(struct notifier_block *notif_blk, unsigned long event,
Quoted 12 lines
drivers/net/ethernet/intel/ice/ice_lag.c +6
-1void *ptr) { struct net_device *netdev = netdev_notifier_info_to_dev(ptr); + struct net_device *upper_netdev; + struct ice_lag_work *lag_work; struct ice_lag *lag; - lag = container_of(notif_blk, struct ice_lag, notif_block); + if (!netif_is_ice(netdev)) + return NOTIFY_DONE; + + if (event != NETDEV_CHANGEUPPER && event !=
NETDEV_BONDING_INFO&&drivers/net/ethernet/intel/ice/ice_lag.c ice_lag_event_handler(struct notifier_block · line 363
Quoted 2 lines
drivers/net/ethernet/intel/ice/ice_lag.c +2
-0+ event != NETDEV_UNREGISTER) +return NOTIFY_DONE ;Would it make more sense to prevent the work item and any related work if the
ice_is_feature_supported(pf, ICE_F_SRIOV_LAG)check is moved to this function along with the events that require that feature?Quoted 7 lines
Something like:
if ((event ==
NETDEV_CHANGEUPPER|| event ==NETDEV_UNREGISTER) &&!ice_is_feature_supported(pf, ICE_F_SRIOV_LAG)) return NOTIFY_DONE;
Quoted 7 lines
Even if SRIOV is not supported, there are still tasks that need to be performed for bonding events - e.g. unplug the RDMA aux devices, so we don't want to avoid creating a workqueue entry when feature not supported. Which makes me notice that
ice_lag_changeupper_eventis under a feature check and it should not be here.Will change it. Changes coming in v5.
DaveE
Ah, okay makes sense. Thanks for the explanation.
Quoted 6 lines
Quoted 5 lines
drivers/net/ethernet/intel/ice/ice_lag.c ice_lag_event_handler(struct notifier_block *notif_blk, unsigned long event, · line 367
Quoted 5 lines
drivers/net/ethernet/intel/ice/ice_lag.c +3
-0+if (!(netdev->priv_flags &IFF_BONDING )) +return NOTIFY_DONE ; +
_______________________________________________
Intel-wired-lan mailing list
[email protected]
https://lists.osuosl.org/mailman/listinfo/intel-wired-lan
PATCH v4 5/10 ice: process events created by lag netdev event handler
In reply to Dave ErtmanAdd in the function framework for the processing of LAG events. Also add in helper function to perform common tasks.
Add the basis of the process of linking a lower netdev to an upper netdev.
--- drivers/net/ethernet/intel/ice/ice_lag.c | 535 +++++++++++++++--- drivers/net/ethernet/intel/ice/ice_lag.h | 1 + drivers/net/ethernet/intel/ice/ice_switch.c | 10 +- drivers/net/ethernet/intel/ice/ice_switch.h | 3 + drivers/net/ethernet/intel/ice/ice_virtchnl.c | 2 + 5 files changed, 478 insertions(+), 73 deletions(-)
drivers/net/ethernet/intel/ice/ice_lag.c +463 -72
@@ -10,6 +10,13 @@#define ICE_LAG_RES_SHARED BIT(14)#define ICE_LAG_RES_VALID BIT(15) +#define ICE_RECIPE_LEN 64 +static const u8 ice_dflt_vsi_rcp[ICE_RECIPE_LEN ] = { +0x05 ,0 ,0 ,0 ,0x20 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 , +0x85 ,0 ,0x01 ,0 ,0 ,0 ,0xff ,0xff ,0x08 ,0 ,0 ,0 ,0 ,0 ,0 ,0 , +0 ,0 ,0 ,0 ,0 ,0 ,0x30 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 , +0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 }; +/** * ice_lag_set_primary - set PF LAG state as Primary * @lag: LAG info struct
@@ -50,6 +57,147 @@ static void ice_lag_set_backup(struct ice_lag *lag) lag->role =ICE_LAG_BACKUP ; } +/** +* ice_netdev_to_lag - return pointer to associated lag struct from netdev +* @netdev: pointer to net_device struct to query +*/ +static struct ice_lag *ice_netdev_to_lag (struct net_device *netdev) +{ +struct ice_netdev_priv *np; +struct ice_vsi *vsi; + +if (!netif_is_ice (netdev)) +return NULL ; + + np =netdev_priv (netdev); +if (!np) +return NULL ; + + vsi = np->vsi; +if (!vsi) +return NULL ; + +return vsi->back->lag; +} + +/** +* ice_lag_find_primary - returns pointer to primary interfaces lag struct +* @lag: local interfaces lag struct +*/ +static struct ice_lag *ice_lag_find_primary (struct ice_lag *lag) +{ +struct ice_lag *primary_lag =NULL ; +struct list_head *tmp; + +list_for_each (tmp, lag->netdev_head) { +struct ice_lag_netdev_list *entry; +struct ice_lag *tmp_lag; + + entry = list_entry(tmp, struct ice_lag_netdev_list, node); + tmp_lag =ice_netdev_to_lag (entry->netdev); +if (tmp_lag && tmp_lag->primary) { + primary_lag = tmp_lag; +break ; + } + } + +return primary_lag; +} + +/** +* ice_lag_cfg_dflt_fltr - Add/Remove default VSI rule for LAG +* @lag: lag struct for local interface +* @add: boolean on whether we are adding filters +*/ +static int +ice_lag_cfg_dflt_fltr (struct ice_lag *lag,bool add) +{ +struct ice_sw_rule_lkup_rx_tx *s_rule; +u16 s_rule_sz, vsi_num; +struct ice_hw *hw; +u32 act, opc; +u8 *eth_hdr; +int err; + + hw = &lag->pf->hw; + vsi_num =ice_get_hw_vsi_num (hw,0 ); + + s_rule_sz =ICE_SW_RULE_RX_TX_ETH_HDR_SIZE (s_rule); + s_rule =kzalloc (s_rule_sz,GFP_KERNEL ); +if (!s_rule) { +dev_err (ice_pf_to_dev (lag->pf),"error allocating rule for LAG default VSI\n" ); +return -ENOMEM ; + } + +if (add) { + eth_hdr = s_rule->hdr_data; +ice_fill_eth_hdr (eth_hdr); + + act = (vsi_num <<ICE_SINGLE_ACT_VSI_ID_S ) & +ICE_SINGLE_ACT_VSI_ID_M ; + act |=ICE_SINGLE_ACT_VSI_FORWARDING | +ICE_SINGLE_ACT_VALID_BIT |ICE_SINGLE_ACT_LAN_ENABLE ; + + s_rule->hdr.type =cpu_to_le16 (ICE_AQC_SW_RULES_T_LKUP_RX ); + s_rule->recipe_id =cpu_to_le16 (lag->pf_recipe); + s_rule->src =cpu_to_le16 (hw->port_info->lport); + s_rule->act =cpu_to_le32 (act); + s_rule->hdr_len =cpu_to_le16 (DUMMY_ETH_HDR_LEN ); + opc = ice_aqc_opc_add_sw_rules; + }else { + s_rule->index =cpu_to_le16 (lag->pf_rule_id); + opc = ice_aqc_opc_remove_sw_rules; + } + + err =ice_aq_sw_rules (&lag->pf->hw, s_rule, s_rule_sz,1 , opc,NULL ); +if (err) + goto dflt_fltr_free; + +if (add) + lag->pf_rule_id =le16_to_cpu (s_rule->index); +else + lag->pf_rule_id =0 ; + +dflt_fltr_free: +kfree (s_rule); +return err; +} + +/** +* ice_lag_cfg_pf_fltrs - set filters up for new active port +* @lag: local interfaces lag struct +* @ptr: opaque data containing notifier event +*/ +static void +ice_lag_cfg_pf_fltrs (struct ice_lag *lag,void *ptr) +{ +struct netdev_notifier_bonding_info *info; +struct netdev_bonding_info *bonding_info; +struct net_device *event_netdev; +struct device *dev; + + event_netdev =netdev_notifier_info_to_dev (ptr); +/* not for this netdev */ +if (event_netdev != lag->netdev) +return ; + + info = (struct netdev_notifier_bonding_info *)ptr; + bonding_info = &info->bonding_info; + dev =ice_pf_to_dev (lag->pf); + +/* interface not active - remove old default VSI rule */ +if (bonding_info->slave.state && lag->pf_rule_id) { +if (ice_lag_cfg_dflt_fltr (lag, false)) +dev_err (dev,"Error removing old default VSI filter\n" ); +return ; + } + +/* interface becoming active - add new default VSI rule */ +if (!bonding_info->slave.state && !lag->pf_rule_id) +if (ice_lag_cfg_dflt_fltr (lag, true)) +dev_err (dev,"Error adding new default VSI filter\n" ); +} +/** * ice_display_lag_info - print LAG info * @lag: LAG info struct
@@ -85,6 +233,83 @@ static void ice_display_lag_info(struct ice_lag *lag) upper, role, primary); } +/** +* ice_lag_move_vf_node_tc - move scheduling nodes for one VF on one TC +* @lag: lag info struct +* @oldport: lport of previous nodes location +* @newport: lport of destination nodes location +* @vsi_num: array index of VSI in PF space +* @tc: traffic class to move +*/ +static void +ice_lag_move_vf_node_tc (struct ice_lag *lag,u8 oldport,u8 newport, +u16 vsi_num,u8 tc) +{ +} + +/** +* ice_lag_move_single_vf_nodes - Move Tx scheduling nodes for single VF +* @lag: primary interface LAG struct +* @oldport: lport of previous interface +* @newport: lport of destination interface +* @vsi_num: SW index of VF's VSI +*/ +static void +ice_lag_move_single_vf_nodes (struct ice_lag *lag,u8 oldport,u8 newport, +u16 vsi_num) +{ +u8 tc; + +ice_for_each_traffic_class (tc) +ice_lag_move_vf_node_tc (lag, oldport, newport, vsi_num, tc); +} + +/** +* ice_lag_move_new_vf_nodes - Move Tx scheduling nodes for a VF if required +* @vf: the VF to move Tx nodes for +* +* Called just after configuring new VF queues. Check whether the VF Tx +* scheduling nodes need to be updated to fail over to the active port. If so, +* move them now. +*/ +void ice_lag_move_new_vf_nodes (struct ice_vf *vf) +{ +} + +/** +* ice_lag_move_vf_nodes - move Tx scheduling nodes for all VFs to new port +* @lag: lag info struct +* @oldport: lport of previous interface +* @newport: lport of destination interface +*/ +static void ice_lag_move_vf_nodes (struct ice_lag *lag,u8 oldport,u8 newport) +{ +struct ice_pf *pf; +int i; + +if (!lag->primary) +return ; + + pf = lag->pf; +ice_for_each_vsi (pf, i) +if (pf->vsi[i] && (pf->vsi[i]->type ==ICE_VSI_VF || + pf->vsi[i]->type ==ICE_VSI_SWITCHDEV_CTRL )) +ice_lag_move_single_vf_nodes (lag, oldport, newport, i); +} + +#define ICE_LAG_SRIOV_CP_RECIPE 10 +#define ICE_LAG_SRIOV_TRAIN_PKT_LEN 16 + +/** +* ice_lag_cfg_cp_fltr - configure filter for control packets +* @lag: local interface's lag struct +* @add: add or remove rule +*/ +static void +ice_lag_cfg_cp_fltr (struct ice_lag *lag,bool add) +{ +} +/** * ice_lag_info_event - handle NETDEV_BONDING_INFO event * @lag: LAG info struct
@@ -126,105 +351,171 @@ static void ice_lag_info_event(struct ice_lag *lag, void *ptr)ice_display_lag_info (lag); } +/** +* ice_lag_reclaim_vf_tc - move scheduling nodes back to primary interface +* @lag: primary interface lag struct +* @src_hw: HW struct current node location +* @vsi_num: VSI index in PF space +* @tc: traffic class to move +*/ +static void +ice_lag_reclaim_vf_tc (struct ice_lag *lag,struct ice_hw *src_hw,u16 vsi_num, +u8 tc) +{ +} + +/** +* ice_lag_reclaim_vf_nodes - When interface leaving bond primary reclaims nodes +* @lag: primary interface lag struct +* @src_hw: HW struct for current node location +*/ +static void +ice_lag_reclaim_vf_nodes (struct ice_lag *lag,struct ice_hw *src_hw) +{ +struct ice_pf *pf; +int i, tc; + +if (!lag->primary || !src_hw) +return ; + + pf = lag->pf; +ice_for_each_vsi (pf, i) +if (pf->vsi[i] && (pf->vsi[i]->type ==ICE_VSI_VF || + pf->vsi[i]->type ==ICE_VSI_SWITCHDEV_CTRL )) +ice_for_each_traffic_class (tc) +ice_lag_reclaim_vf_tc (lag, src_hw, i, tc); +} +/** * ice_lag_link - handle LAG link event * @lag: LAG info struct -* @info: info from the netdev notifier */ -static void -ice_lag_link (struct ice_lag *lag,struct netdev_notifier_changeupper_info *info) +static void ice_lag_link (struct ice_lag *lag) { -struct net_device *netdev_tmp, *upper = info->upper_dev;struct ice_pf *pf = lag->pf; -int peers =0 ;if (lag->bonded)dev_warn (ice_pf_to_dev (pf),"%s Already part of a bond\n" ,netdev_name (lag->netdev)); -rcu_read_lock (); -for_each_netdev_in_bond_rcu (upper, netdev_tmp) - peers++; -rcu_read_unlock (); - -if (lag->upper_netdev != upper) { -dev_hold (upper); - lag->upper_netdev = upper; - } -ice_clear_rdma_cap (pf); lag->bonded = true; lag->role =ICE_LAG_UNSET ; - -/* if this is the first element in an LAG mark as primary */ - lag->primary = !!(peers ==1 ); }/** * ice_lag_unlink - handle unlink event * @lag: LAG info struct -* @info: info from netdev notification */ -static void -ice_lag_unlink (struct ice_lag *lag, -struct netdev_notifier_changeupper_info *info) +static void ice_lag_unlink (struct ice_lag *lag) { -struct net_device *netdev_tmp, *upper = info->upper_dev; +u8 pri_port, act_port, loc_port;struct ice_pf *pf = lag->pf; -bool found = false;if (!lag->bonded) {netdev_dbg (lag->netdev,"bonding unlink event on non-LAG netdev\n" );return ; } -/* determine if we are in the new LAG config or not */ -rcu_read_lock (); -for_each_netdev_in_bond_rcu (upper, netdev_tmp) { -if (netdev_tmp == lag->netdev) { - found = true; -break ; +if (lag->primary) { + act_port = lag->active_port; + pri_port = lag->pf->hw.port_info->lport; +if (act_port != pri_port && act_port !=ICE_LAG_INVALID_PORT ) +ice_lag_move_vf_nodes (lag, act_port, pri_port); + lag->primary = false; + lag->active_port =ICE_LAG_INVALID_PORT ; + }else { +struct ice_lag *primary_lag; + + primary_lag =ice_lag_find_primary (lag); +if (primary_lag) { + act_port = primary_lag->active_port; + pri_port = primary_lag->pf->hw.port_info->lport; + loc_port = pf->hw.port_info->lport; +if (act_port == loc_port && + act_port !=ICE_LAG_INVALID_PORT ) { +ice_lag_reclaim_vf_nodes (primary_lag, + &lag->pf->hw); + primary_lag->active_port =ICE_LAG_INVALID_PORT ; + } } } -rcu_read_unlock (); - -if (found) -return ; - -if (lag->upper_netdev) { -dev_put (lag->upper_netdev); - lag->upper_netdev =NULL ; - }ice_set_rdma_cap (pf); lag->bonded = false; lag->role =ICE_LAG_NONE ; + lag->upper_netdev =NULL ; }/** -* ice_lag_unregister - handle netdev unregister events -* @lag: LAG info struct -* @netdev: netdev reporting the event +* ice_lag_link_unlink - helper function to call lag_link/unlink +* @lag: lag info struct +* @ptr: opaque pointer data */ -static void ice_lag_unregister (struct ice_lag *lag,struct net_device *netdev) +static void ice_lag_link_unlink (struct ice_lag *lag,void *ptr) { -struct ice_pf *pf = lag->pf; +struct net_device *netdev =netdev_notifier_info_to_dev (ptr); +struct netdev_notifier_changeupper_info *info = ptr; -/* check to see if this event is for this netdev -* check that we are in an aggregate -*/ -if (netdev != lag->netdev || !lag->bonded) +if (netdev != lag->netdev)return ; -if (lag->upper_netdev) { -dev_put (lag->upper_netdev); - lag->upper_netdev =NULL ; -ice_set_rdma_cap (pf); - } -/* perform some cleanup in case we come back */ - lag->bonded = false; - lag->role =ICE_LAG_NONE ; +if (info->linking) +ice_lag_link (lag); +else +ice_lag_unlink (lag); +} + +/** +* ice_lag_set_swid - set the SWID on secondary interface +* @primary_swid: primary interface's SWID +* @local_lag: local interfaces LAG struct +* @link: Is this a linking activity +* +* If link is false, then primary_swid should be expected to not be valid +*/ +static void +ice_lag_set_swid (u16 primary_swid,struct ice_lag *local_lag, +bool link) +{ +} + +/** +* ice_lag_primary_swid - set/clear the SHARED attrib of primary's SWID +* @lag: primary interfaces lag struct +* @link: is this a linking activity +* +* Implement setting primary SWID as shared using 0x020B +*/ +static void ice_lag_primary_swid (struct ice_lag *lag,bool link) +{ +struct ice_hw *hw; +u16 swid; + + hw = &lag->pf->hw; + swid = hw->port_info->sw_id; + +if (ice_share_res (hw,ICE_AQC_RES_TYPE_SWID , link, swid)) +dev_warn (ice_pf_to_dev (lag->pf),"Failure to set primary interface shared status\n" ); +} + +/** +* ice_lag_add_prune_list - Adds event_pf's VSI to primary's prune list +* @lag: lag info struct +* @event_pf: PF struct for VSI we are adding to primary's prune list +*/ +static void ice_lag_add_prune_list (struct ice_lag *lag,struct ice_pf *event_pf) +{ +} + +/** +* ice_lag_del_prune_list - Remove secondary's vsi from primary's prune list +* @lag: primary interface's ice_lag struct +* @event_pf: PF struct for unlinking interface +*/ +static void ice_lag_del_prune_list (struct ice_lag *lag,struct ice_pf *event_pf) +{ }/**
@@ -257,6 +548,7 @@ static void ice_lag_check_nvm_support(struct ice_pf *pf)static void ice_lag_changeupper_event (struct ice_lag *lag,void *ptr) {struct netdev_notifier_changeupper_info *info; +struct ice_lag *primary_lag;struct net_device *netdev; info = ptr;
@@ -266,24 +558,84 @@ static void ice_lag_changeupper_event(struct ice_lag *lag, void *ptr)if (netdev != lag->netdev)return ; -if (!info->upper_dev) { -netdev_dbg (netdev,"changeupper rcvd, but no upper defined\n" ); -return ; + primary_lag =ice_lag_find_primary (lag); +if (info->linking) { + lag->upper_netdev = info->upper_dev; +/* If there is not already a primary interface in the LAG, +* then mark this one as primary. +*/ +if (!primary_lag) { + lag->primary = true; +/* Configure primary's SWID to be shared */ +ice_lag_primary_swid (lag, true); + primary_lag = lag; + }else { +u16 swid; + + swid = primary_lag->pf->hw.port_info->sw_id; +ice_lag_set_swid (swid, lag, true); +ice_lag_add_prune_list (primary_lag, lag->pf); + } +/* add filter for primary control packets */ +ice_lag_cfg_cp_fltr (lag, true); + }else { +if (!primary_lag && lag->primary) + primary_lag = lag; + +if (primary_lag) { +if (!lag->primary) { +ice_lag_set_swid (0 , lag, false); + }else { +ice_lag_primary_swid (lag, false); +ice_lag_del_prune_list (primary_lag, lag->pf); + } +ice_lag_cfg_cp_fltr (lag, false); + } } +} -netdev_dbg (netdev,"bonding %s\n" , info->linking ?"LINK" :"UNLINK" ); +/** +* ice_lag_monitor_link - monitor interfaces entering/leaving the aggregate +* @lag: lag info struct +* @ptr: opaque data containing notifier event +* +* This function only operates after a primary has been set. +*/ +static void ice_lag_monitor_link (struct ice_lag *lag,void *ptr) +{ +} -if (!netif_is_lag_master (info->upper_dev)) { -netdev_dbg (netdev,"changeupper rcvd, but not primary. bail\n" ); -return ; - } +/** +* ice_lag_monitor_active - main PF keep track of which port is active +* @lag: lag info struct +* @ptr: opaque data containing notifier event +* +* This function is for the primary PF to monitor changes in which port is +* active and handle changes for SRIOV VF functionality +*/ +static void ice_lag_monitor_active (struct ice_lag *lag,void *ptr) +{ +} -if (info->linking) -ice_lag_link (lag, info); -else -ice_lag_unlink (lag, info); +/** +* ice_lag_chk_comp - evaluate bonded interface for feature support +* @lag: lag info struct +* @ptr: opaque data for netdev event info +*/ +static bool +ice_lag_chk_comp (struct ice_lag *lag,void *ptr) +{ +return true; +} -ice_display_lag_info (lag); +/** +* ice_lag_unregister - handle netdev unregister events +* @lag: LAG info struct +* @event_netdev: netdev struct for target of notifier event +*/ +static void +ice_lag_unregister (struct ice_lag *lag,struct net_device *event_netdev) +{ }/**
@@ -307,17 +659,30 @@ static void ice_lag_process_event(struct work_struct *work)switch (lag_work->event) {case NETDEV_CHANGEUPPER : info = &lag_work->info.changeupper_info; -if (ice_is_feature_supported (pf,ICE_F_SRIOV_LAG )) +if (ice_is_feature_supported (pf,ICE_F_SRIOV_LAG )) { +ice_lag_monitor_link (lag_work->lag, info);ice_lag_changeupper_event (lag_work->lag, info); +ice_lag_link_unlink (lag_work->lag, info); + }break ;case NETDEV_BONDING_INFO : +if (ice_is_feature_supported (pf,ICE_F_SRIOV_LAG )) { +if (!ice_lag_chk_comp (lag_work->lag, + &lag_work->info.bonding_info)) { + goto lag_cleanup; + } +ice_lag_monitor_active (lag_work->lag, + &lag_work->info.bonding_info); +ice_lag_cfg_pf_fltrs (lag_work->lag, + &lag_work->info.bonding_info); + }ice_lag_info_event (lag_work->lag, &lag_work->info.bonding_info);break ;case NETDEV_UNREGISTER :if (ice_is_feature_supported (pf,ICE_F_SRIOV_LAG )) { netdev = lag_work->info.bonding_info.info.dev; -if ((netdev == lag_work->lag->netdev || - lag_work->lag->primary) && lag_work->lag->bonded) +if (netdev == lag_work->lag->netdev && + lag_work->lag->bonded)ice_lag_unregister (lag_work->lag, netdev); }break ;
@@ -325,6 +690,7 @@ static void ice_lag_process_event(struct work_struct *work)break ; } +lag_cleanup:/* cleanup resources allocated for this work item */ list_for_each_safe (tmp, n, &lag_work->netdev_list.node) {struct ice_lag_netdev_list *entry;
@@ -466,6 +832,22 @@ static void ice_unregister_lag_handler(struct ice_lag *lag) } } +/** +* ice_create_lag_recipe +* @hw: pointer to HW struct +* @base_recipe: recipe to base the new recipe on +* @prio: priority for new recipe +* +* function returns 0 on error +*/ +static u16 ice_create_lag_recipe (struct ice_hw *hw,const u8 *base_recipe, +u8 prio) +{ +u16 rid =0 ; + +return rid; +} +/** * ice_init_lag - initialize support for LAG * @pf: PF struct
@@ -507,6 +889,12 @@ int ice_init_lag(struct ice_pf *pf) goto lag_error; } + lag->pf_recipe =ice_create_lag_recipe (&pf->hw, ice_dflt_vsi_rcp,1 ); +if (!lag->pf_recipe) { + err = -EINVAL ; + goto lag_error; + } +ice_display_lag_info (lag);dev_dbg (dev,"INIT LAG complete\n" );
@@ -539,6 +927,9 @@ void ice_deinit_lag(struct ice_pf *pf)flush_workqueue (ice_lag_wq); +ice_free_hw_res (&pf->hw,ICE_AQC_RES_TYPE_RECIPE ,1 , + &pf->lag->pf_recipe); +kfree (lag); pf->lag =NULL ;
drivers/net/ethernet/intel/ice/ice_lag.h +1 -0
@@ -56,6 +56,7 @@ struct ice_lag_work { } info; }; +void ice_lag_move_new_vf_nodes (struct ice_vf *vf);int ice_init_lag (struct ice_pf *pf);void ice_deinit_lag (struct ice_pf *pf);#endif /* _ICE_LAG_H_ */
drivers/net/ethernet/intel/ice/ice_switch.c +9 -1
@@ -25,7 +25,6 @@* In case of Ether type filter it is treated as header without VLAN tag * and byte 12 and 13 is used to program a given Ether type instead */ -#define DUMMY_ETH_HDR_LEN 16static const u8 dummy_eth_header[DUMMY_ETH_HDR_LEN ] = {0x2 ,0 ,0 ,0 ,0 ,0 ,0x2 ,0 ,0 ,0 ,0 ,0 ,0x81 ,0 ,0 ,0 };
@@ -2534,6 +2533,15 @@ static void ice_fill_sw_info(struct ice_hw *hw, struct ice_fltr_info *fi) } } +/** +* ice_fill_eth_hdr - helper to copy dummy_eth_hdr into supplied buffer +* @eth_hdr: pointer to buffer to populate +*/ +void ice_fill_eth_hdr (u8 *eth_hdr) +{ +memcpy (eth_hdr, dummy_eth_header,DUMMY_ETH_HDR_LEN ); +} +/** * ice_fill_sw_rule - Helper function to fill switch rule structure * @hw: pointer to the hardware structure
drivers/net/ethernet/intel/ice/ice_switch.h +3 -0
@@ -32,6 +32,8 @@ ICE_SW_RULE_RX_TX_HDR_SIZE((s), 0)#define ICE_SW_RULE_LG_ACT_SIZE (s, n) struct_size((s), act, (n)) +#define DUMMY_ETH_HDR_LEN 16 +/* VSI context structure for add/get/update/free operations */ struct ice_vsi_ctx {u16 vsi_num;
@@ -405,6 +407,7 @@ u16 ice_get_hw_vsi_num(struct ice_hw *hw, u16 vsi_handle);int ice_replay_vsi_all_fltr (struct ice_hw *hw,u16 vsi_handle);void ice_rm_all_sw_replay_rule_info (struct ice_hw *hw); +void ice_fill_eth_hdr (u8 *eth_hdr); int ice_aq_sw_rules(struct ice_hw *hw, void *rule_list, u16 rule_list_sz,
drivers/net/ethernet/intel/ice/ice_virtchnl.c +2 -0
@@ -1724,6 +1724,8 @@ static int ice_vc_cfg_qs_msg(struct ice_vf *vf, u8 *msg) vf->vf_id, i); } +ice_lag_move_new_vf_nodes (vf); +/* send the response to the VF */ return ice_vc_send_msg_to_vf (vf,VIRTCHNL_OP_CONFIG_VSI_QUEUES ,VIRTCHNL_STATUS_ERR_PARAM ,NULL ,0 );
Signature · 1 line
2.40.1
Re: [PATCH iwl-next v4 05/10] ice: process events created by lag netdev event handler
Quoted 18 lines · Dave Ertman
Caution: This message originated from an External Source. Use proper caution when opening attachments, clicking links, or responding.
Add in the function framework for the processing of LAG events. Also add in helper function to perform common tasks.
Add the basis of the process of linking a lower netdev to an upper netdev.
Reviewed-by Daniel Machon <[email protected]>Signed-off-by Dave Ertman <[email protected]>--- drivers/net/ethernet/intel/ice/ice_lag.c | 535 +++++++++++++++--- drivers/net/ethernet/intel/ice/ice_lag.h | 1 + drivers/net/ethernet/intel/ice/ice_switch.c | 10 +- drivers/net/ethernet/intel/ice/ice_switch.h | 3 + drivers/net/ethernet/intel/ice/ice_virtchnl.c | 2 + 5 files changed, 478 insertions(+), 73 deletions(-)
[...]
Quoted 10 lines
drivers/net/ethernet/intel/ice/ice_lag.c +10
-0+/** +* ice_lag_reclaim_vf_nodes - When interface leaving bond primary reclaims nodes +* @lag: primary interface lag struct +* @src_hw: HW struct for current node location +*/ +static void +ice_lag_reclaim_vf_nodes (struct ice_lag *lag,struct ice_hw *src_hw) +{ +struct ice_pf *pf; +int i, tc;
drivers/net/ethernet/intel/ice/ice_lag.c static void ice_lag_info_event(struct ice_lag *lag, void *ptr) · line 386
Quoted 10 lines
drivers/net/ethernet/intel/ice/ice_lag.c +10
-0+ +if (!lag->primary || !src_hw) +return ; + + pf = lag->pf; +ice_for_each_vsi (pf, i) +if (pf->vsi[i] && (pf->vsi[i]->type ==ICE_VSI_VF || + pf->vsi[i]->type ==ICE_VSI_SWITCHDEV_CTRL )) +ice_for_each_traffic_class (tc) +ice_lag_reclaim_vf_tc (lag, src_hw, i, tc);
Seems like indentation got messed up here for ice_lag_reclaim_vf_tc()? Is this supposed to be under the if block?
Quoted 2 lines
(quoted diff) +2
-0+} +
[...]
RE: [PATCH iwl-next v4 05/10] ice: process events created by lag netdev event handler
Quoted 51 lines
-----Original Message-----
From: Brett Creeley <[email protected]>
Sent: Wednesday, June 14, 2023 2:24 PM
To: Ertman, David M <[email protected]>; intel-wired- [email protected]
Cc: [email protected]; [email protected]; [email protected]
Subject: Re: [PATCH iwl-next v4 05/10] ice: process events created by lag netdev event handlerQuoted 1 line · Dave Ertman
Caution: This message originated from an External Source. Use proper
caution when opening attachments, clicking links, or responding.
Quoted 17 lines
Add in the function framework for the processing of LAG events. Also add in helper function to perform common tasks.
Add the basis of the process of linking a lower netdev to an upper netdev.
Reviewed-by Daniel Machon <[email protected]>Signed-off-by Dave Ertman <[email protected]>--- drivers/net/ethernet/intel/ice/ice_lag.c | 535 +++++++++++++++--- drivers/net/ethernet/intel/ice/ice_lag.h | 1 + drivers/net/ethernet/intel/ice/ice_switch.c | 10 +- drivers/net/ethernet/intel/ice/ice_switch.h | 3 + drivers/net/ethernet/intel/ice/ice_virtchnl.c | 2 + 5 files changed, 478 insertions(+), 73 deletions(-)[...]
Quoted 2 lines
+/**
+ *ice_lag_reclaim_vf_nodes- When interface leaving bond primaryreclaims nodes
Quoted 13 lines
+ * @lag: primary interface lag struct
+ * @src_hw: HW struct for current node location
+ */drivers/net/ethernet/intel/ice/ice_lag.c +10
-0+static void +ice_lag_reclaim_vf_nodes (struct ice_lag *lag,struct ice_hw *src_hw) +{ +struct ice_pf *pf; +int i, tc; + +if (!lag->primary || !src_hw) +return ; + + pf = lag->pf;
Quoted 8 lines
drivers/net/ethernet/intel/ice/ice_lag.c static void ice_lag_info_event(struct ice_lag *lag, void *ptr) · line 386
Quoted 5 lines
drivers/net/ethernet/intel/ice/ice_lag.c +5
-0+ice_for_each_vsi (pf, i) +if (pf->vsi[i] && (pf->vsi[i]->type ==ICE_VSI_VF || + pf->vsi[i]->type ==ICE_VSI_SWITCHDEV_CTRL )) +ice_for_each_traffic_class (tc) +ice_lag_reclaim_vf_tc (lag, src_hw, i, tc);Seems like indentation got messed up here for
ice_lag_reclaim_vf_tc()? Is this supposed to be under the if block?
Unless I am missing something, looks correct to me? The if statement has a parenthetical sub block that the second line of the if statement is aligning to. The ice_for_each_traffic_class is one indent in from the if block, and the ice_lag_reclaim_vf_tc is under the macro'd for statement.
DaveE
Quoted 6 lines
Quoted 3 lines
(quoted diff) +2
-0+} +[...]
_______________________________________________
Intel-wired-lan mailing list
[email protected]
https://lists.osuosl.org/mailman/listinfo/intel-wired-lan
Re: [PATCH iwl-next v4 05/10] ice: process events created by lag netdev event handler
Quoted 61 lines · David M
Caution: This message originated from an External Source. Use proper caution when opening attachments, clicking links, or responding.
Quoted 49 lines
-----Original Message-----
From: Brett Creeley <[email protected]>
Sent: Wednesday, June 14, 2023 2:24 PM
To: Ertman, David M <[email protected]>; intel-wired- [email protected]
Cc: [email protected]; [email protected]; [email protected]
Subject: Re: [PATCH iwl-next v4 05/10] ice: process events created by lag netdev event handlerQuoted 1 line · Dave Ertman
Caution: This message originated from an External Source. Use proper
caution when opening attachments, clicking links, or responding.
Quoted 17 lines
Add in the function framework for the processing of LAG events. Also add in helper function to perform common tasks.
Add the basis of the process of linking a lower netdev to an upper netdev.
Reviewed-by Daniel Machon <[email protected]>Signed-off-by Dave Ertman <[email protected]>--- drivers/net/ethernet/intel/ice/ice_lag.c | 535 +++++++++++++++--- drivers/net/ethernet/intel/ice/ice_lag.h | 1 + drivers/net/ethernet/intel/ice/ice_switch.c | 10 +- drivers/net/ethernet/intel/ice/ice_switch.h | 3 + drivers/net/ethernet/intel/ice/ice_virtchnl.c | 2 + 5 files changed, 478 insertions(+), 73 deletions(-)[...]
Quoted 2 lines
+/**
+ *ice_lag_reclaim_vf_nodes- When interface leaving bond primaryreclaims nodes
Quoted 13 lines
+ * @lag: primary interface lag struct
+ * @src_hw: HW struct for current node location
+ */drivers/net/ethernet/intel/ice/ice_lag.c +10
-0+static void +ice_lag_reclaim_vf_nodes (struct ice_lag *lag,struct ice_hw *src_hw) +{ +struct ice_pf *pf; +int i, tc; + +if (!lag->primary || !src_hw) +return ; + + pf = lag->pf;Quoted 8 lines
drivers/net/ethernet/intel/ice/ice_lag.c static void ice_lag_info_event(struct ice_lag *lag, void *ptr) · line 386
Quoted 5 lines
drivers/net/ethernet/intel/ice/ice_lag.c +5
-0+ice_for_each_vsi (pf, i) +if (pf->vsi[i] && (pf->vsi[i]->type ==ICE_VSI_VF || + pf->vsi[i]->type ==ICE_VSI_SWITCHDEV_CTRL )) +ice_for_each_traffic_class (tc) +ice_lag_reclaim_vf_tc (lag, src_hw, i, tc);Seems like indentation got messed up here for
ice_lag_reclaim_vf_tc()? Is this supposed to be under the if block?
Quoted 5 lines
Unless I am missing something, looks correct to me? The if statement has a parenthetical sub block that the second line of the if statement is aligning to. The
ice_for_each_traffic_classis one indent in from the if block, and theice_lag_reclaim_vf_tcis under the macro'd for statement.DaveE
Yeah, you are right. I misread the ice_for_each_traffic_class() as a function call for some reason, which is where my confusion came in. Thanks!
Quoted 6 lines
Quoted 6 lines
Quoted 3 lines
(quoted diff) +2
-0+} +[...]
PATCH v4 6/10 ice: Flesh out implementation of support for SRIOV on bonded interface
In reply to Dave ErtmanAdd in the functions that will allow a VF created on the primary interface of a bond to "fail-over" to another PF interface in the bond and continue to Tx and Rx.
Add in an ordered take-down path for the bonded interface.
--- drivers/net/ethernet/intel/ice/ice_lag.c | 821 ++++++++++++++++++++++- 1 file changed, 811 insertions(+), 10 deletions(-)
drivers/net/ethernet/intel/ice/ice_lag.c +811 -10
@@ -10,6 +10,11 @@#define ICE_LAG_RES_SHARED BIT(14)#define ICE_LAG_RES_VALID BIT(15) +#define LACP_TRAIN_PKT_LEN 16 +static const u8 lacp_train_pkt[LACP_TRAIN_PKT_LEN ] = {0 ,0 ,0 ,0 ,0 ,0 , +0 ,0 ,0 ,0 ,0 ,0 , +0x88 ,0x09 ,0 ,0 }; +#define ICE_RECIPE_LEN 64static const u8 ice_dflt_vsi_rcp[ICE_RECIPE_LEN ] = {0x05 ,0 ,0 ,0 ,0x20 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,
@@ -57,6 +62,39 @@ static void ice_lag_set_backup(struct ice_lag *lag) lag->role =ICE_LAG_BACKUP ; } +/** +* netif_is_same_ice - determine if netdev is on the same ice NIC as local PF +* @pf: local PF struct +* @netdev: netdev we are evaluating +*/ +static bool netif_is_same_ice (struct ice_pf *pf,struct net_device *netdev) +{ +struct ice_netdev_priv *np; +struct ice_pf *test_pf; +struct ice_vsi *vsi; + +if (!netif_is_ice (netdev)) +return false; + + np =netdev_priv (netdev); +if (!np) +return false; + + vsi = np->vsi; +if (!vsi) +return false; + + test_pf = vsi->back; +if (!test_pf) +return false; + +if (pf->pdev->bus != test_pf->pdev->bus || + pf->pdev->slot != test_pf->pdev->slot) +return false; + +return true; +} +/** * ice_netdev_to_lag - return pointer to associated lag struct from netdev * @netdev: pointer to net_device struct to query
@@ -80,6 +118,38 @@ static struct ice_lag *ice_netdev_to_lag(struct net_device *netdev)return vsi->back->lag; } +/** +* ice_lag_find_hw_by_lport - return an hw struct from bond members lport +* @lag: lag struct +* @lport: lport value to search for +*/ +static struct ice_hw * +ice_lag_find_hw_by_lport (struct ice_lag *lag,u8 lport) +{ +struct ice_lag_netdev_list *entry; +struct net_device *tmp_netdev; +struct ice_netdev_priv *np; +struct list_head *tmp; +struct ice_hw *hw; + +list_for_each (tmp, lag->netdev_head) { + entry = list_entry(tmp, struct ice_lag_netdev_list, node); + tmp_netdev = entry->netdev; +if (!tmp_netdev || !netif_is_ice (tmp_netdev)) +continue ; + + np =netdev_priv (tmp_netdev); +if (!np || !np->vsi) +continue ; + + hw = &np->vsi->back->hw; +if (hw->port_info->lport == lport) +return hw; + } + +return NULL ; +} +/** * ice_lag_find_primary - returns pointer to primary interfaces lag struct * @lag: local interfaces lag struct
@@ -233,6 +303,113 @@ static void ice_display_lag_info(struct ice_lag *lag) upper, role, primary); } +/** +* ice_lag_qbuf_recfg - generate a buffer of queues for a reconfigure command +* @hw: HW struct that contains the queue contexts +* @qbuf: pointer to buffer to populate +* @vsi_num: index of the VSI in PF space +* @numq: number of queues to search for +* @tc: traffic class that contains the queues +* +* function returns the number of valid queues in buffer +*/ +static u16 +ice_lag_qbuf_recfg (struct ice_hw *hw,struct ice_aqc_cfg_txqs_buf *qbuf, +u16 vsi_num,u16 numq,u8 tc) +{ +struct ice_q_ctx *q_ctx; +u16 qid, count =0 ; +struct ice_pf *pf; +int i; + + pf = hw->back; +for (i =0 ; i < numq; i++) { + q_ctx =ice_get_lan_q_ctx (hw, vsi_num, tc, i); +if (!q_ctx || q_ctx->q_handle ==ICE_INVAL_Q_HANDLE ) { +dev_dbg (ice_hw_to_dev (hw),"%s queue %d %s\n" , __func__, + i, q_ctx ?"INVAL Q HANDLE" :"NO Q CONTEXT" ); +continue ; + } + + qid = pf->vsi[vsi_num]->txq_map[q_ctx->q_handle]; + qbuf->queue_info[count].q_handle =cpu_to_le16 (qid); + qbuf->queue_info[count].tc = tc; + qbuf->queue_info[count].q_teid =cpu_to_le32 (q_ctx->q_teid); + count++; + } + +return count; +} + +/** +* ice_lag_get_sched_parent - locate or create a sched node parent +* @hw: HW struct for getting parent in +* @tc: traffic class on parent/node +*/ +static struct ice_sched_node * +ice_lag_get_sched_parent (struct ice_hw *hw,u8 tc) +{ +struct ice_sched_node *tc_node, *aggnode, *parent =NULL ; +u16 num_nodes[ICE_AQC_TOPO_MAX_LEVEL_NUM ] = {0 }; +struct ice_port_info *pi = hw->port_info; +struct device *dev; +u8 aggl, vsil; +int n; + + dev =ice_hw_to_dev (hw); + + tc_node =ice_sched_get_tc_node (pi, tc); +if (!tc_node) { +dev_warn (dev,"Failure to find TC node in for LAG move\n" ); +return parent; + } + + aggnode =ice_sched_get_agg_node (pi, tc_node,ICE_DFLT_AGG_ID ); +if (!aggnode) { +dev_warn (dev,"Failure to find aggregate node for LAG move\n" ); +return parent; + } + + aggl =ice_sched_get_agg_layer (hw); + vsil =ice_sched_get_vsi_layer (hw); + +for (n = aggl +1 ; n < vsil; n++) + num_nodes[n] =1 ; + +for (n =0 ; n < aggnode->num_children; n++) { + parent =ice_sched_get_free_vsi_parent (hw, aggnode->children[n], + num_nodes); +if (parent) +return parent; + } + +/* if free parent not found - add one */ + parent = aggnode; +for (n = aggl +1 ; n < vsil; n++) { +u16 num_nodes_added; +u32 first_teid; +int err; + + err =ice_sched_add_nodes_to_layer (pi, tc_node, parent, n, + num_nodes[n], &first_teid, + &num_nodes_added); +if (err || num_nodes[n] != num_nodes_added) +return NULL ; + +if (num_nodes_added) + parent =ice_sched_find_node_by_teid (tc_node, + first_teid); +else + parent = parent->children[0 ]; +if (!parent) { +dev_warn (dev,"Failure to add new parent for LAG move\n" ); +return parent; + } + } + +return parent; +} +/** * ice_lag_move_vf_node_tc - move scheduling nodes for one VF on one TC * @lag: lag info struct
@@ -245,6 +422,110 @@ static void ice_lag_move_vf_node_tc(struct ice_lag *lag, u8 oldport, u8 newport, u16 vsi_num, u8 tc) { + u16 numq, valq, buf_size, num_moved, qbuf_size; +struct device *dev =ice_pf_to_dev (lag->pf); +struct ice_aqc_cfg_txqs_buf *qbuf; +struct ice_aqc_move_elem *buf; +struct ice_sched_node *n_prt; +struct ice_hw *new_hw =NULL ; +__le32 teid, parent_teid; +struct ice_vsi_ctx *ctx; +u32 tmp_teid; + + ctx =ice_get_vsi_ctx (&lag->pf->hw, vsi_num); +if (!ctx) { +dev_warn (dev,"Unable to locate VSI context for LAG failover\n" ); +return ; + } + +/* check to see if this VF is enabled on this TC */ +if (!ctx->sched.vsi_node[tc]) +return ; + +/* locate HW struct for destination port */ + new_hw =ice_lag_find_hw_by_lport (lag, newport); +if (!new_hw) { +dev_warn (dev,"Unable to locate HW struct for LAG node destination\n" ); +return ; + } + + numq = ctx->num_lan_q_entries[tc]; + teid = ctx->sched.vsi_node[tc]->info.node_teid; + tmp_teid =le32_to_cpu (teid); + parent_teid = ctx->sched.vsi_node[tc]->info.parent_teid; +/* if no teid assigned or numq == 0, then this TC is not active */ +if (!tmp_teid || !numq) +return ; + +/* suspend VSI subtree for Traffic Class "tc" on +* this VF's VSI +*/ +if (ice_sched_suspend_resume_elems (&lag->pf->hw,1 , &tmp_teid, true)) +dev_dbg (dev,"Problem suspending traffic for LAG node move\n" ); + +/* reconfigure all VF's queues on this Traffic Class +* to new port +*/ + qbuf_size =struct_size (qbuf, queue_info, numq); + qbuf =kzalloc (qbuf_size,GFP_KERNEL ); +if (!qbuf) { +dev_warn (dev,"Failure allocating memory for VF queue recfg buffer\n" ); + goto resume_traffic; + } + +/* add the per queue info for the reconfigure command buffer */ + valq =ice_lag_qbuf_recfg (&lag->pf->hw, qbuf, vsi_num, numq, tc); +if (!valq) { +dev_dbg (dev,"No valid queues found for LAG failover\n" ); + goto qbuf_none; + } + +if (ice_aq_cfg_lan_txq (&lag->pf->hw, qbuf, qbuf_size, valq, oldport, + newport,NULL )) { +dev_warn (dev,"Failure to configure queues for LAG failover\n" ); + goto qbuf_err; + } + +qbuf_none: +kfree (qbuf); + +/* find new parent in destination port's tree for VF VSI node on this +* Traffic Class +*/ + n_prt =ice_lag_get_sched_parent (new_hw, tc); +if (!n_prt) + goto resume_traffic; + +/* Move Vf's VSI node for this TC to newport's scheduler tree */ + buf_size =struct_size (buf, teid,1 ); + buf =kzalloc (buf_size,GFP_KERNEL ); +if (!buf) { +dev_warn (dev,"Failure to alloc memory for VF node failover\n" ); + goto resume_traffic; + } + + buf->hdr.src_parent_teid = parent_teid; + buf->hdr.dest_parent_teid = n_prt->info.node_teid; + buf->hdr.num_elems =cpu_to_le16 (1 ); + buf->hdr.mode =ICE_AQC_MOVE_ELEM_MODE_KEEP_OWN ; + buf->teid[0 ] = teid; + +if (ice_aq_move_sched_elems (&lag->pf->hw,1 , buf, buf_size, &num_moved, +NULL )) +dev_warn (dev,"Failure to move VF nodes for failover\n" ); +else +ice_sched_update_parent (n_prt, ctx->sched.vsi_node[tc]); + +kfree (buf); + goto resume_traffic; + +qbuf_err: +kfree (qbuf); + +resume_traffic: +/* restart traffic for VSI node */ +if (ice_sched_suspend_resume_elems (&lag->pf->hw,1 , &tmp_teid, false)) +dev_dbg (dev,"Problem restarting traffic for LAG node move\n" ); }/**
@@ -274,6 +555,66 @@ ice_lag_move_single_vf_nodes(struct ice_lag *lag, u8 oldport, u8 newport,*/ void ice_lag_move_new_vf_nodes (struct ice_vf *vf) { +struct ice_lag_netdev_list ndlist; +struct list_head *tmp, *n; +u8 pri_port, act_port; +struct ice_lag *lag; +struct ice_vsi *vsi; +struct ice_pf *pf; + + vsi =ice_get_vf_vsi (vf); + +if (WARN_ON (!vsi)) +return ; + +if (WARN_ON (vsi->type !=ICE_VSI_VF )) +return ; + + pf = vf->pf; + lag = pf->lag; + +mutex_lock (&pf->lag_mutex); +if (!lag->bonded) + goto new_vf_unlock; + + pri_port = pf->hw.port_info->lport; + act_port = lag->active_port; + +if (lag->upper_netdev) { +struct ice_lag_netdev_list *nl; +struct net_device *tmp_nd; + +INIT_LIST_HEAD (&ndlist.node); +rcu_read_lock (); +for_each_netdev_in_bond_rcu (lag->upper_netdev, tmp_nd) { + nl =kzalloc (sizeof (*nl),GFP_KERNEL ); +if (!nl) +break ; + + nl->netdev = tmp_nd; +list_add (&nl->node, &ndlist.node); + } +rcu_read_unlock (); + } + + lag->netdev_head = &ndlist.node; + +if (ice_is_feature_supported (pf,ICE_F_SRIOV_LAG ) && + lag->bonded && lag->primary && pri_port != act_port && + !list_empty (lag->netdev_head)) +ice_lag_move_single_vf_nodes (lag, pri_port, act_port, vsi->idx); + +list_for_each_safe (tmp, n, &ndlist.node) { +struct ice_lag_netdev_list *entry; + + entry = list_entry(tmp, struct ice_lag_netdev_list, node); +list_del (&entry->node); +kfree (entry); + } + lag->netdev_head =NULL ; + +new_vf_unlock: +mutex_unlock (&pf->lag_mutex); }/**
@@ -308,6 +649,50 @@ static void ice_lag_move_vf_nodes(struct ice_lag *lag, u8 oldport, u8 newport)static void ice_lag_cfg_cp_fltr (struct ice_lag *lag,bool add) { +struct ice_sw_rule_lkup_rx_tx *s_rule =NULL ; +struct ice_vsi *vsi; +u16 buf_len, opc; + + vsi = lag->pf->vsi[0 ]; + + buf_len =ICE_SW_RULE_RX_TX_HDR_SIZE (s_rule, +ICE_LAG_SRIOV_TRAIN_PKT_LEN ); + s_rule =kzalloc (buf_len,GFP_KERNEL ); +if (!s_rule) { +netdev_warn (lag->netdev,"-ENOMEM error configuring CP filter\n" ); +return ; + } + +if (add) { + s_rule->hdr.type =cpu_to_le16 (ICE_AQC_SW_RULES_T_LKUP_RX ); + s_rule->recipe_id =cpu_to_le16 (ICE_LAG_SRIOV_CP_RECIPE ); + s_rule->src =cpu_to_le16 (vsi->port_info->lport); + s_rule->act =cpu_to_le32 (ICE_FWD_TO_VSI | +ICE_SINGLE_ACT_LAN_ENABLE | +ICE_SINGLE_ACT_VALID_BIT | + ((vsi->vsi_num << +ICE_SINGLE_ACT_VSI_ID_S ) & +ICE_SINGLE_ACT_VSI_ID_M )); + s_rule->hdr_len =cpu_to_le16 (ICE_LAG_SRIOV_TRAIN_PKT_LEN ); +memcpy (s_rule->hdr_data, lacp_train_pkt,LACP_TRAIN_PKT_LEN ); + opc = ice_aqc_opc_add_sw_rules; + }else { + opc = ice_aqc_opc_remove_sw_rules; + s_rule->index =cpu_to_le16 (lag->cp_rule_idx); + } +if (ice_aq_sw_rules (&lag->pf->hw, s_rule, buf_len,1 , opc,NULL )) { +netdev_warn (lag->netdev,"Error %s CP rule for fail-over\n" , + add ?"ADDING" :"REMOVING" ); + goto cp_free; + } + +if (add) + lag->cp_rule_idx =le16_to_cpu (s_rule->index); +else + lag->cp_rule_idx =0 ; + +cp_free: +kfree (s_rule); }/**
@@ -362,6 +747,100 @@ static void ice_lag_reclaim_vf_tc(struct ice_lag *lag, struct ice_hw *src_hw, u16 vsi_num, u8 tc) { + u16 numq, valq, buf_size, num_moved, qbuf_size; +struct device *dev =ice_pf_to_dev (lag->pf); +struct ice_aqc_cfg_txqs_buf *qbuf; +struct ice_aqc_move_elem *buf; +struct ice_sched_node *n_prt; +__le32 teid, parent_teid; +struct ice_vsi_ctx *ctx; +struct ice_hw *hw; +u32 tmp_teid; + + hw = &lag->pf->hw; + ctx =ice_get_vsi_ctx (hw, vsi_num); +if (!ctx) { +dev_warn (dev,"Unable to locate VSI context for LAG reclaim\n" ); +return ; + } + +/* check to see if this VF is enabled on this TC */ +if (!ctx->sched.vsi_node[tc]) +return ; + + numq = ctx->num_lan_q_entries[tc]; + teid = ctx->sched.vsi_node[tc]->info.node_teid; + tmp_teid =le32_to_cpu (teid); + parent_teid = ctx->sched.vsi_node[tc]->info.parent_teid; + +/* if !teid or !numq, then this TC is not active */ +if (!tmp_teid || !numq) +return ; + +/* suspend traffic */ +if (ice_sched_suspend_resume_elems (hw,1 , &tmp_teid, true)) +dev_dbg (dev,"Problem suspending traffic for LAG node move\n" ); + +/* reconfig queues for new port */ + qbuf_size =struct_size (qbuf, queue_info, numq); + qbuf =kzalloc (qbuf_size,GFP_KERNEL ); +if (!qbuf) { +dev_warn (dev,"Failure allocating memory for VF queue recfg buffer\n" ); + goto resume_reclaim; + } + +/* add the per queue info for the reconfigure command buffer */ + valq =ice_lag_qbuf_recfg (hw, qbuf, vsi_num, numq, tc); +if (!valq) { +dev_dbg (dev,"No valid queues found for LAG reclaim\n" ); + goto reclaim_none; + } + +if (ice_aq_cfg_lan_txq (hw, qbuf, qbuf_size, numq, + src_hw->port_info->lport, hw->port_info->lport, +NULL )) { +dev_warn (dev,"Failure to configure queues for LAG failover\n" ); + goto reclaim_qerr; + } + +reclaim_none: +kfree (qbuf); + +/* find parent in primary tree */ + n_prt =ice_lag_get_sched_parent (hw, tc); +if (!n_prt) + goto resume_reclaim; + +/* Move node to new parent */ + buf_size =struct_size (buf, teid,1 ); + buf =kzalloc (buf_size,GFP_KERNEL ); +if (!buf) { +dev_warn (dev,"Failure to alloc memory for VF node failover\n" ); + goto resume_reclaim; + } + + buf->hdr.src_parent_teid = parent_teid; + buf->hdr.dest_parent_teid = n_prt->info.node_teid; + buf->hdr.num_elems =cpu_to_le16 (1 ); + buf->hdr.mode =ICE_AQC_MOVE_ELEM_MODE_KEEP_OWN ; + buf->teid[0 ] = teid; + +if (ice_aq_move_sched_elems (&lag->pf->hw,1 , buf, buf_size, &num_moved, +NULL )) +dev_warn (dev,"Failure to move VF nodes for LAG reclaim\n" ); +else +ice_sched_update_parent (n_prt, ctx->sched.vsi_node[tc]); + +kfree (buf); + goto resume_reclaim; + +reclaim_qerr: +kfree (qbuf); + +resume_reclaim: +/* restart traffic */ +if (ice_sched_suspend_resume_elems (hw,1 , &tmp_teid, false)) +dev_warn (dev,"Problem restarting traffic for LAG node reclaim\n" ); }/**
@@ -479,6 +958,65 @@ static void ice_lag_set_swid(u16 primary_swid, struct ice_lag *local_lag, bool link) { + struct ice_aqc_alloc_free_res_elem *buf; +struct ice_aqc_set_port_params *cmd; +struct ice_aq_desc desc; +u16 buf_len, swid; +int status; + + buf_len =struct_size (buf, elem,1 ); + buf =kzalloc (buf_len,GFP_KERNEL ); +if (!buf) { +dev_err (ice_pf_to_dev (local_lag->pf),"-ENOMEM error setting SWID\n" ); +return ; + } + + buf->num_elems =cpu_to_le16 (1 ); + buf->res_type =cpu_to_le16 (ICE_AQC_RES_TYPE_SWID ); +/* if unlinnking need to free the shared resource */ +if (!link && local_lag->bond_swid) { + buf->elem[0 ].e.sw_resp =cpu_to_le16 (local_lag->bond_swid); + status =ice_aq_alloc_free_res (&local_lag->pf->hw,1 , buf, + buf_len, ice_aqc_opc_free_res, +NULL ); +if (status) +dev_err (ice_pf_to_dev (local_lag->pf),"Error freeing SWID during LAG unlink\n" ); + local_lag->bond_swid =0 ; + } + +if (link) { + buf->res_type |=cpu_to_le16 (ICE_LAG_RES_SHARED | +ICE_LAG_RES_VALID ); +/* store the primary's SWID in case it leaves bond first */ + local_lag->bond_swid = primary_swid; + buf->elem[0 ].e.sw_resp =cpu_to_le16 (local_lag->bond_swid); + }else { + buf->elem[0 ].e.sw_resp = +cpu_to_le16 (local_lag->pf->hw.port_info->sw_id); + } + + status =ice_aq_alloc_free_res (&local_lag->pf->hw,1 , buf, buf_len, + ice_aqc_opc_alloc_res,NULL ); +if (status) +dev_err (ice_pf_to_dev (local_lag->pf),"Error subscribing to SWID 0x%04X\n" , + local_lag->bond_swid); + +kfree (buf); + +/* Configure port param SWID to correct value */ +if (link) + swid = primary_swid; +else + swid = local_lag->pf->hw.port_info->sw_id; + + cmd = &desc.params.set_port_params; +ice_fill_dflt_direct_cmd_desc (&desc, ice_aqc_opc_set_port_params); + + cmd->swid =cpu_to_le16 (ICE_AQC_PORT_SWID_VALID | swid); + status =ice_aq_send_cmd (&local_lag->pf->hw, &desc,NULL ,0 ,NULL ); +if (status) +dev_err (ice_pf_to_dev (local_lag->pf),"Error setting SWID in port params %d\n" , + status); }/**
@@ -507,6 +1045,38 @@ static void ice_lag_primary_swid(struct ice_lag *lag, bool link)*/ static void ice_lag_add_prune_list (struct ice_lag *lag,struct ice_pf *event_pf) { +u16 num_vsi, rule_buf_sz, vsi_list_id, event_vsi_num, prim_vsi_idx; +struct ice_sw_rule_vsi_list *s_rule =NULL ; +struct device *dev; + + num_vsi =1 ; + + dev =ice_pf_to_dev (lag->pf); + event_vsi_num = event_pf->vsi[0 ]->vsi_num; + prim_vsi_idx = lag->pf->vsi[0 ]->idx; + +if (!ice_find_vsi_list_entry (&lag->pf->hw,ICE_SW_LKUP_VLAN , + prim_vsi_idx, &vsi_list_id)) { +dev_warn (dev,"Could not locate prune list when setting up SRIOV LAG\n" ); +return ; + } + + rule_buf_sz = (u16 )ICE_SW_RULE_VSI_LIST_SIZE (s_rule, num_vsi); + s_rule =kzalloc (rule_buf_sz,GFP_KERNEL ); +if (!s_rule) { +dev_warn (dev,"Error allocating space for prune list when configuring SRIOV LAG\n" ); +return ; + } + + s_rule->hdr.type =cpu_to_le16 (ICE_AQC_SW_RULES_T_PRUNE_LIST_SET ); + s_rule->index =cpu_to_le16 (vsi_list_id); + s_rule->number_vsi =cpu_to_le16 (num_vsi); + s_rule->vsi[0 ] =cpu_to_le16 (event_vsi_num); + +if (ice_aq_sw_rules (&event_pf->hw, s_rule, rule_buf_sz,1 , + ice_aqc_opc_update_sw_rules,NULL )) +dev_warn (dev,"Error adding VSI prune list\n" ); +kfree (s_rule); }/**
@@ -516,6 +1086,39 @@ static void ice_lag_add_prune_list(struct ice_lag *lag, struct ice_pf *event_pf)*/ static void ice_lag_del_prune_list (struct ice_lag *lag,struct ice_pf *event_pf) { +u16 num_vsi, vsi_num, vsi_idx, rule_buf_sz, vsi_list_id; +struct ice_sw_rule_vsi_list *s_rule =NULL ; +struct device *dev; + + num_vsi =1 ; + + dev =ice_pf_to_dev (lag->pf); + vsi_num = event_pf->vsi[0 ]->vsi_num; + vsi_idx = lag->pf->vsi[0 ]->idx; + +if (!ice_find_vsi_list_entry (&lag->pf->hw,ICE_SW_LKUP_VLAN , + vsi_idx, &vsi_list_id)) { +dev_warn (dev,"Could not locate prune list when unwinding SRIOV LAG\n" ); +return ; + } + + rule_buf_sz = (u16 )ICE_SW_RULE_VSI_LIST_SIZE (s_rule, num_vsi); + s_rule =kzalloc (rule_buf_sz,GFP_KERNEL ); +if (!s_rule) { +dev_warn (dev,"Error allocating prune list when unwinding SRIOV LAG\n" ); +return ; + } + + s_rule->hdr.type =cpu_to_le16 (ICE_AQC_SW_RULES_T_PRUNE_LIST_CLEAR ); + s_rule->index =cpu_to_le16 (vsi_list_id); + s_rule->number_vsi =cpu_to_le16 (num_vsi); + s_rule->vsi[0 ] =cpu_to_le16 (vsi_num); + +if (ice_aq_sw_rules (&event_pf->hw, (struct ice_aqc_sw_rules *)s_rule, + rule_buf_sz,1 , ice_aqc_opc_update_sw_rules,NULL )) +dev_warn (dev,"Error clearing VSI prune list\n" ); + +kfree (s_rule); }/**
@@ -542,8 +1145,6 @@ static void ice_lag_check_nvm_support(struct ice_pf *pf)* ice_lag_changeupper_event - handle LAG changeupper event * @lag: LAG info struct * @ptr: opaque pointer data -* -* ptr is to be cast into netdev_notifier_changeupper_info */ static void ice_lag_changeupper_event (struct ice_lag *lag,void *ptr) {
@@ -603,6 +1204,40 @@ static void ice_lag_changeupper_event(struct ice_lag *lag, void *ptr)*/ static void ice_lag_monitor_link (struct ice_lag *lag,void *ptr) { +struct netdev_notifier_changeupper_info *info; +struct ice_hw *prim_hw, *active_hw; +struct net_device *event_netdev; +struct ice_pf *pf; +u8 prim_port; + +if (!lag->primary) +return ; + + event_netdev =netdev_notifier_info_to_dev (ptr); +if (!netif_is_same_ice (lag->pf, event_netdev)) +return ; + + pf = lag->pf; + prim_hw = &pf->hw; + prim_port = prim_hw->port_info->lport; + + info = (struct netdev_notifier_changeupper_info *)ptr; +if (info->upper_dev != lag->upper_netdev) +return ; + +if (!info->linking) { +/* Since there are only two interfaces allowed in SRIOV+LAG, if +* one port is leaving, then nodes need to be on primary +* interface. +*/ +if (prim_port != lag->active_port && + lag->active_port !=ICE_LAG_INVALID_PORT ) { + active_hw =ice_lag_find_hw_by_lport (lag, + lag->active_port); +ice_lag_reclaim_vf_nodes (lag, active_hw); + lag->active_port =ICE_LAG_INVALID_PORT ; + } + } }/**
@@ -615,6 +1250,67 @@ static void ice_lag_monitor_link(struct ice_lag *lag, void *ptr)*/ static void ice_lag_monitor_active (struct ice_lag *lag,void *ptr) { +struct net_device *event_netdev, *event_upper; +struct netdev_notifier_bonding_info *info; +struct netdev_bonding_info *bonding_info; +struct ice_netdev_priv *event_np; +struct ice_pf *pf, *event_pf; +u8 prim_port, event_port; + +if (!lag->primary) +return ; + + pf = lag->pf; +if (!pf) +return ; + + event_netdev =netdev_notifier_info_to_dev (ptr); +rcu_read_lock (); + event_upper =netdev_master_upper_dev_get_rcu (event_netdev); +rcu_read_unlock (); +if (!netif_is_ice (event_netdev) || event_upper != lag->upper_netdev) +return ; + + event_np =netdev_priv (event_netdev); + event_pf = event_np->vsi->back; + event_port = event_pf->hw.port_info->lport; + prim_port = pf->hw.port_info->lport; + + info = (struct netdev_notifier_bonding_info *)ptr; + bonding_info = &info->bonding_info; + +if (!bonding_info->slave.state) { +/* if no port is currently active, then nodes and filters exist +* on primary port, check if we need to move them +*/ +if (lag->active_port ==ICE_LAG_INVALID_PORT ) { +if (event_port != prim_port) +ice_lag_move_vf_nodes (lag, prim_port, + event_port); + lag->active_port = event_port; +return ; + } + +/* active port is already set and is current event port */ +if (lag->active_port == event_port) +return ; +/* new active port */ +ice_lag_move_vf_nodes (lag, lag->active_port, event_port); + lag->active_port = event_port; + }else { +/* port not set as currently active (e.g. new active port +* has already claimed the nodes and filters +*/ +if (lag->active_port != event_port) +return ; +/* This is the case when neither port is active (both link down) +* Link down on the bond - set active port to invalid and move +* nodes and filters back to primary if not already there +*/ +if (event_port != prim_port) +ice_lag_move_vf_nodes (lag, event_port, prim_port); + lag->active_port =ICE_LAG_INVALID_PORT ; + } }/**
@@ -625,6 +1321,73 @@ static void ice_lag_monitor_active(struct ice_lag *lag, void *ptr)static bool ice_lag_chk_comp (struct ice_lag *lag,void *ptr) { +struct net_device *event_netdev, *event_upper; +struct netdev_notifier_bonding_info *info; +struct netdev_bonding_info *bonding_info; +struct list_head *tmp; +int count =0 ; + +if (!lag->primary) +return true; + + event_netdev =netdev_notifier_info_to_dev (ptr); +rcu_read_lock (); + event_upper =netdev_master_upper_dev_get_rcu (event_netdev); +rcu_read_unlock (); +if (event_upper != lag->upper_netdev) +return true; + + info = (struct netdev_notifier_bonding_info *)ptr; + bonding_info = &info->bonding_info; + lag->bond_mode = bonding_info->master.bond_mode; +if (lag->bond_mode !=BOND_MODE_ACTIVEBACKUP ) { +netdev_info (lag->netdev,"Bond Mode not ACTIVE-BACKUP\n" ); +return false; + } + +list_for_each (tmp, lag->netdev_head) { +#if !defined(NO_DCB_SUPPORT ) || defined(ADQ_SUPPORT ) +struct ice_dcbx_cfg *dcb_cfg, *peer_dcb_cfg; +#endif /* !NO_DCB_SUPPORT || ADQ_SUPPORT */ +struct ice_lag_netdev_list *entry; +struct ice_netdev_priv *peer_np; +struct net_device *peer_netdev; +struct ice_vsi *vsi, *peer_vsi; + + entry = list_entry(tmp, struct ice_lag_netdev_list, node); + peer_netdev = entry->netdev; +if (!netif_is_ice (peer_netdev)) { +netdev_info (lag->netdev,"Found non-ice netdev in LAG\n" ); +return false; + } + + count++; +if (count >2 ) { +netdev_info (lag->netdev,"Found more than two netdevs in LAG\n" ); +return false; + } + + peer_np =netdev_priv (peer_netdev); + vsi =ice_get_main_vsi (lag->pf); + peer_vsi = peer_np->vsi; +if (lag->pf->pdev->bus != peer_vsi->back->pdev->bus || + lag->pf->pdev->slot != peer_vsi->back->pdev->slot) { +netdev_info (lag->netdev,"Found netdev on different device in LAG\n" ); +return false; + } + +#if !defined(NO_DCB_SUPPORT ) || defined(ADQ_SUPPORT ) + dcb_cfg = &vsi->port_info->qos_cfg.local_dcbx_cfg; + peer_dcb_cfg = &peer_vsi->port_info->qos_cfg.local_dcbx_cfg; +if (memcmp (dcb_cfg, peer_dcb_cfg, +sizeof (struct ice_dcbx_cfg ))) { +netdev_info (lag->netdev,"Found netdev with different DCB config in LAG\n" ); +return false; + } + +#endif /* !NO_DCB_SUPPORT || ADQ_SUPPORT */ + } +return true; }
@@ -835,17 +1598,40 @@ static void ice_unregister_lag_handler(struct ice_lag *lag)/** * ice_create_lag_recipe * @hw: pointer to HW struct +* @rid: pointer to u16 to pass back recipe index * @base_recipe: recipe to base the new recipe on * @prio: priority for new recipe * * function returns 0 on error */ -static u16 ice_create_lag_recipe (struct ice_hw *hw,const u8 *base_recipe, -u8 prio) +static int ice_create_lag_recipe (struct ice_hw *hw,u16 *rid, +const u8 *base_recipe,u8 prio) { -u16 rid =0 ; +struct ice_aqc_recipe_data_elem *new_rcp; +int err; + + err =ice_alloc_recipe (hw, rid); +if (err) +return err; + + new_rcp =kzalloc (ICE_RECIPE_LEN *ICE_MAX_NUM_RECIPES ,GFP_KERNEL ); +if (!new_rcp) +return -ENOMEM ; + +memcpy (new_rcp, base_recipe,ICE_RECIPE_LEN ); + new_rcp->content.act_ctrl_fwd_priority = prio; + new_rcp->content.rid = *rid |ICE_AQ_RECIPE_ID_IS_ROOT ; + new_rcp->recipe_indx = *rid; +bitmap_zero ((unsigned long *)new_rcp->recipe_bitmap, +ICE_MAX_NUM_RECIPES ); +set_bit (*rid, (unsigned long *)new_rcp->recipe_bitmap); -return rid; + err =ice_aq_add_recipe (hw, new_rcp,1 ,NULL ); +if (err) + *rid =0 ; + +kfree (new_rcp); +return err; }/**
@@ -860,7 +1646,8 @@ int ice_init_lag(struct ice_pf *pf)struct device *dev =ice_pf_to_dev (pf);struct ice_lag *lag;struct ice_vsi *vsi; -int err; +u64 recipe_bits =0 ; +int n, err;ice_lag_check_nvm_support (pf);
@@ -879,6 +1666,7 @@ int ice_init_lag(struct ice_pf *pf) lag->pf = pf; lag->netdev = vsi->netdev; lag->role =ICE_LAG_NONE ; + lag->active_port =ICE_LAG_INVALID_PORT ; lag->bonded = false; lag->upper_netdev =NULL ; lag->notif_block.notifier_call =NULL ;
@@ -889,10 +1677,23 @@ int ice_init_lag(struct ice_pf *pf) goto lag_error; } - lag->pf_recipe =ice_create_lag_recipe (&pf->hw, ice_dflt_vsi_rcp,1 ); -if (!lag->pf_recipe) { - err = -EINVAL ; + err =ice_create_lag_recipe (&pf->hw, &lag->pf_recipe, ice_dflt_vsi_rcp, +1 ); +if (err) goto lag_error; + +/* associate recipes to profiles */ +for (n =0 ; n <ICE_PROFID_IPV6_GTPU_IPV6_TCP_INNER ; n++) { + err =ice_aq_get_recipe_to_profile (&pf->hw, n, + (u8 *)&recipe_bits,NULL ); +if (err) +continue ; + +if (recipe_bits &BIT (ICE_SW_LKUP_DFLT )) { + recipe_bits |=BIT (lag->pf_recipe); +ice_aq_map_recipe_to_profile (&pf->hw, n, + (u8 *)&recipe_bits,NULL ); + } }ice_display_lag_info (lag);
Signature · 1 line
2.40.1
Re: [PATCH iwl-next v4 06/10] ice: Flesh out implementation of support for SRIOV on bonded interface
Quoted 15 lines · Dave Ertman
Caution: This message originated from an External Source. Use proper caution when opening attachments, clicking links, or responding.
Add in the functions that will allow a VF created on the primary interface of a bond to "fail-over" to another PF interface in the bond and continue to Tx and Rx.
Add in an ordered take-down path for the bonded interface.
Reviewed-by Daniel Machon <[email protected]>Signed-off-by Dave Ertman <[email protected]>--- drivers/net/ethernet/intel/ice/ice_lag.c | 821 ++++++++++++++++++++++- 1 file changed, 811 insertions(+), 10 deletions(-)
[...]
Quoted 13 lines
drivers/net/ethernet/intel/ice/ice_lag.c +13
-0+/** +* ice_lag_qbuf_recfg - generate a buffer of queues for a reconfigure command +* @hw: HW struct that contains the queue contexts +* @qbuf: pointer to buffer to populate +* @vsi_num: index of the VSI in PF space +* @numq: number of queues to search for +* @tc: traffic class that contains the queues +* +* function returns the number of valid queues in buffer +*/ +static u16 +ice_lag_qbuf_recfg (struct ice_hw *hw,struct ice_aqc_cfg_txqs_buf *qbuf, +u16 vsi_num,u16 numq,u8 tc)
drivers/net/ethernet/intel/ice/ice_lag.c static void ice_display_lag_info(struct ice_lag *lag) · line 328
Quoted 10 lines
drivers/net/ethernet/intel/ice/ice_lag.c +10
-0+{ +struct ice_q_ctx *q_ctx; +u16 qid, count =0 ; +struct ice_pf *pf; +int i; + + pf = hw->back; +for (i =0 ; i < numq; i++) { + q_ctx =ice_get_lan_q_ctx (hw, vsi_num, tc, i); +if (!q_ctx || q_ctx->q_handle ==ICE_INVAL_Q_HANDLE ) {
Should q_ctx->q_teid be checked against ICE_INVAL_TEID as well? If so, the dev_dbg() should also be updated.
Quoted 25 lines
drivers/net/ethernet/intel/ice/ice_lag.c +25
-0+dev_dbg (ice_hw_to_dev (hw),"%s queue %d %s\n" , __func__, + i, q_ctx ?"INVAL Q HANDLE" :"NO Q CONTEXT" ); +continue ; + } + + qid = pf->vsi[vsi_num]->txq_map[q_ctx->q_handle]; + qbuf->queue_info[count].q_handle =cpu_to_le16 (qid); + qbuf->queue_info[count].tc = tc; + qbuf->queue_info[count].q_teid =cpu_to_le32 (q_ctx->q_teid); + count++; + } + +return count; +} + +/** +* ice_lag_get_sched_parent - locate or create a sched node parent +* @hw: HW struct for getting parent in +* @tc: traffic class on parent/node +*/ +static struct ice_sched_node * +ice_lag_get_sched_parent (struct ice_hw *hw,u8 tc) +{ +struct ice_sched_node *tc_node, *aggnode, *parent =NULL ; +u16 num_nodes[ICE_AQC_TOPO_MAX_LEVEL_NUM ] = {0 };
drivers/net/ethernet/intel/ice/ice_lag.c static void ice_display_lag_info(struct ice_lag *lag) · line 363
Quoted 10 lines
drivers/net/ethernet/intel/ice/ice_lag.c +10
-0+struct ice_port_info *pi = hw->port_info; +struct device *dev; +u8 aggl, vsil; +int n; + + dev =ice_hw_to_dev (hw); + + tc_node =ice_sched_get_tc_node (pi, tc); +if (!tc_node) { +dev_warn (dev,"Failure to find TC node in for LAG move\n" );
Nit, but seems like there's a stray "in" in the log message?
Quoted 49 lines
drivers/net/ethernet/intel/ice/ice_lag.c +49
-0+return parent; + } + + aggnode =ice_sched_get_agg_node (pi, tc_node,ICE_DFLT_AGG_ID ); +if (!aggnode) { +dev_warn (dev,"Failure to find aggregate node for LAG move\n" ); +return parent; + } + + aggl =ice_sched_get_agg_layer (hw); + vsil =ice_sched_get_vsi_layer (hw); + +for (n = aggl +1 ; n < vsil; n++) + num_nodes[n] =1 ; + +for (n =0 ; n < aggnode->num_children; n++) { + parent =ice_sched_get_free_vsi_parent (hw, aggnode->children[n], + num_nodes); +if (parent) +return parent; + } + +/* if free parent not found - add one */ + parent = aggnode; +for (n = aggl +1 ; n < vsil; n++) { +u16 num_nodes_added; +u32 first_teid; +int err; + + err =ice_sched_add_nodes_to_layer (pi, tc_node, parent, n, + num_nodes[n], &first_teid, + &num_nodes_added); +if (err || num_nodes[n] != num_nodes_added) +return NULL ; + +if (num_nodes_added) + parent =ice_sched_find_node_by_teid (tc_node, + first_teid); +else + parent = parent->children[0 ]; +if (!parent) { +dev_warn (dev,"Failure to add new parent for LAG move\n" ); +return parent; + } + } + +return parent; +} +
[...]
Quoted 23 lines
/**
drivers/net/ethernet/intel/ice/ice_lag.c +18
-0@@ -625,6 +1321,73 @@ static void ice_lag_monitor_active(struct ice_lag *lag, void *ptr)static bool ice_lag_chk_comp (struct ice_lag *lag,void *ptr) { +struct net_device *event_netdev, *event_upper; +struct netdev_notifier_bonding_info *info; +struct netdev_bonding_info *bonding_info; +struct list_head *tmp; +int count =0 ; + +if (!lag->primary) +return true; + + event_netdev =netdev_notifier_info_to_dev (ptr); +rcu_read_lock (); + event_upper =netdev_master_upper_dev_get_rcu (event_netdev); +rcu_read_unlock (); +if (event_upper != lag->upper_netdev) +return true; + + info = (struct netdev_notifier_bonding_info *)ptr; + bonding_info = &info->bonding_info;
drivers/net/ethernet/intel/ice/ice_lag.c static void ice_lag_monitor_active(struct ice_lag *lag, void *ptr) · line 1351
Quoted 10 lines
drivers/net/ethernet/intel/ice/ice_lag.c +10
-0+ lag->bond_mode = bonding_info->master.bond_mode; +if (lag->bond_mode !=BOND_MODE_ACTIVEBACKUP ) { +netdev_info (lag->netdev,"Bond Mode not ACTIVE-BACKUP\n" ); +return false; + } + +list_for_each (tmp, lag->netdev_head) { +#if !defined(NO_DCB_SUPPORT ) || defined(ADQ_SUPPORT ) +struct ice_dcbx_cfg *dcb_cfg, *peer_dcb_cfg; +#endif /* !NO_DCB_SUPPORT || ADQ_SUPPORT */
These #ifdefs don't belong here.
Quoted 27 lines
drivers/net/ethernet/intel/ice/ice_lag.c +27
-0+struct ice_lag_netdev_list *entry; +struct ice_netdev_priv *peer_np; +struct net_device *peer_netdev; +struct ice_vsi *vsi, *peer_vsi; + + entry = list_entry(tmp, struct ice_lag_netdev_list, node); + peer_netdev = entry->netdev; +if (!netif_is_ice (peer_netdev)) { +netdev_info (lag->netdev,"Found non-ice netdev in LAG\n" ); +return false; + } + + count++; +if (count >2 ) { +netdev_info (lag->netdev,"Found more than two netdevs in LAG\n" ); +return false; + } + + peer_np =netdev_priv (peer_netdev); + vsi =ice_get_main_vsi (lag->pf); + peer_vsi = peer_np->vsi; +if (lag->pf->pdev->bus != peer_vsi->back->pdev->bus || + lag->pf->pdev->slot != peer_vsi->back->pdev->slot) { +netdev_info (lag->netdev,"Found netdev on different device in LAG\n" ); +return false; + } +
drivers/net/ethernet/intel/ice/ice_lag.c static void ice_lag_monitor_active(struct ice_lag *lag, void *ptr) · line 1388
Quoted 10 lines
drivers/net/ethernet/intel/ice/ice_lag.c +10
-0+#if !defined(NO_DCB_SUPPORT ) || defined(ADQ_SUPPORT ) + dcb_cfg = &vsi->port_info->qos_cfg.local_dcbx_cfg; + peer_dcb_cfg = &peer_vsi->port_info->qos_cfg.local_dcbx_cfg; +if (memcmp (dcb_cfg, peer_dcb_cfg, +sizeof (struct ice_dcbx_cfg ))) { +netdev_info (lag->netdev,"Found netdev with different DCB config in LAG\n" ); +return false; + } + +#endif /* !NO_DCB_SUPPORT || ADQ_SUPPORT */
Ditto on the #ifdefs
Quoted 5 lines
drivers/net/ethernet/intel/ice/ice_lag.c +2
-0+ } +return true; }
[...]
RE: [PATCH iwl-next v4 06/10] ice: Flesh out implementation of support for SRIOV on bonded interface
Quoted 45 lines
-----Original Message-----
From: Brett Creeley <[email protected]>
Sent: Wednesday, June 14, 2023 2:25 PM
To: Ertman, David M <[email protected]>; intel-wired- [email protected]
Cc: [email protected]; [email protected]; [email protected]
Subject: Re: [PATCH iwl-next v4 06/10] ice: Flesh out implementation of support for SRIOV on bonded interfaceQuoted 1 line · Dave Ertman
Caution: This message originated from an External Source. Use proper
caution when opening attachments, clicking links, or responding.
Quoted 6 lines
Add in the functions that will allow a VF created on the primary interface of a bond to "fail-over" to another PF interface in the bond and continue to Tx and Rx.
Quoted 6 lines
Add in an ordered take-down path for the bonded interface.
Reviewed-by Daniel Machon <[email protected]>Signed-off-by Dave Ertman <[email protected]>--- drivers/net/ethernet/intel/ice/ice_lag.c | 821++++++++++++++++++++++-
Quoted 2 lines
1 file changed, 811 insertions(+), 10 deletions(-)[...]
Quoted 2 lines
+/**
+ *ice_lag_qbuf_recfg- generate a buffer of queues for a reconfigurecommand
Review
Quoted 10 lines
+ * @hw: HW struct that contains the queue contexts
+ * @qbuf: pointer to buffer to populate
+ * @vsi_num: index of the VSI in PF space
+ * @numq: number of queues to search for
+ * @tc: traffic class that contains the queues
+ *
+ * function returns the number of valid queues in buffer
+ */(quoted diff) +2
-0+static u16 +ice_lag_qbuf_recfg(struct ice_hw *hw, struct ice_aqc_cfg_txqs_buf*qbuf,
Quoted 14 lines
drivers/net/ethernet/intel/ice/ice_lag.c static void ice_display_lag_info(struct ice_lag *lag) · line 328
Quoted 11 lines
drivers/net/ethernet/intel/ice/ice_lag.c +11
-0+ u16 vsi_num, u16 numq, u8 tc) +{ + struct ice_q_ctx *q_ctx; +u16 qid, count =0 ; +struct ice_pf *pf; +int i; + + pf = hw->back; +for (i =0 ; i < numq; i++) { + q_ctx =ice_get_lan_q_ctx (hw, vsi_num, tc, i); +if (!q_ctx || q_ctx->q_handle ==ICE_INVAL_Q_HANDLE ) {Should
q_ctx->q_teidbe checked againstICE_INVAL_TEIDas well? If so, thedev_dbg()should also be updated.
Reasonable - added check for ICE_INVAL_TEID and DBG statement.
Quoted 31 lines
Quoted 2 lines
+ dev_dbg(ice_hw_to_dev(hw), "%s queue %d %s\n",
__func__,Quoted 28 lines
drivers/net/ethernet/intel/ice/ice_lag.c +28
-0+ i, q_ctx ? "INVAL Q HANDLE" : "NO Q CONTEXT"); +continue ; + } + + qid = pf->vsi[vsi_num]->txq_map[q_ctx->q_handle]; + qbuf->queue_info[count].q_handle =cpu_to_le16 (qid); + qbuf->queue_info[count].tc = tc; + qbuf->queue_info[count].q_teid =cpu_to_le32 (q_ctx->q_teid); + count++; + } + +return count; +} + +/** +* ice_lag_get_sched_parent - locate or create a sched node parent +* @hw: HW struct for getting parent in +* @tc: traffic class on parent/node +*/ +static struct ice_sched_node * +ice_lag_get_sched_parent (struct ice_hw *hw,u8 tc) +{ +struct ice_sched_node *tc_node, *aggnode, *parent =NULL ; +u16 num_nodes[ICE_AQC_TOPO_MAX_LEVEL_NUM ] = {0 }; +struct ice_port_info *pi = hw->port_info; +struct device *dev; +u8 aggl, vsil; +int n;
Quoted 8 lines
drivers/net/ethernet/intel/ice/ice_lag.c static void ice_display_lag_info(struct ice_lag *lag) · line 363
Quoted 6 lines
drivers/net/ethernet/intel/ice/ice_lag.c +6
-0+ + dev =ice_hw_to_dev (hw); + + tc_node =ice_sched_get_tc_node (pi, tc); +if (!tc_node) { +dev_warn (dev,"Failure to find TC node in for LAG move\n" );Nit, but seems like there's a stray "in" in the log message?
Removed "in" in warning
Quoted 82 lines
Quoted 51 lines
drivers/net/ethernet/intel/ice/ice_lag.c +17
-0+return parent; + } + + aggnode =ice_sched_get_agg_node (pi, tc_node,ICE_DFLT_AGG_ID ); +if (!aggnode) { +dev_warn (dev,"Failure to find aggregate node for LAG move\n" ); +return parent; + } + + aggl =ice_sched_get_agg_layer (hw); + vsil =ice_sched_get_vsi_layer (hw); + +for (n = aggl +1 ; n < vsil; n++) + num_nodes[n] =1 ; + +for (n =0 ; n < aggnode->num_children; n++) { + parent = ice_sched_get_free_vsi_parent(hw, aggnode-children[n],
drivers/net/ethernet/intel/ice/ice_lag.c +32
-0+ num_nodes); +if (parent) +return parent; + } + +/* if free parent not found - add one */ + parent = aggnode; +for (n = aggl +1 ; n < vsil; n++) { +u16 num_nodes_added; +u32 first_teid; +int err; + + err =ice_sched_add_nodes_to_layer (pi, tc_node, parent, n, + num_nodes[n], &first_teid, + &num_nodes_added); +if (err || num_nodes[n] != num_nodes_added) +return NULL ; + +if (num_nodes_added) + parent =ice_sched_find_node_by_teid (tc_node, + first_teid); +else + parent = parent->children[0 ]; +if (!parent) { +dev_warn (dev,"Failure to add new parent for LAG move\n" ); +return parent; + } + } + +return parent; +} +[...]
Review static void ice_lag_monitor_active(struct ice_lag
Quoted 2 lines
/**
(quoted diff) +0
-0@@ -625,6 +1321,73 @@ static void ice_lag_monitor_active(struct ice_lag*lag, void *ptr)
Quoted 25 lines
drivers/net/ethernet/intel/ice/ice_lag.c +22
-0static bool ice_lag_chk_comp (struct ice_lag *lag,void *ptr) { +struct net_device *event_netdev, *event_upper; +struct netdev_notifier_bonding_info *info; +struct netdev_bonding_info *bonding_info; +struct list_head *tmp; +int count =0 ; + +if (!lag->primary) +return true; + + event_netdev =netdev_notifier_info_to_dev (ptr); +rcu_read_lock (); + event_upper =netdev_master_upper_dev_get_rcu (event_netdev); +rcu_read_unlock (); +if (event_upper != lag->upper_netdev) +return true; + + info = (struct netdev_notifier_bonding_info *)ptr; + bonding_info = &info->bonding_info; + lag->bond_mode = bonding_info->master.bond_mode; +if (lag->bond_mode !=BOND_MODE_ACTIVEBACKUP ) { +netdev_info (lag->netdev,"Bond Mode not ACTIVE-BACKUP\n" ); +return false;
Quoted 8 lines
drivers/net/ethernet/intel/ice/ice_lag.c static void ice_lag_monitor_active(struct ice_lag *lag, void *ptr) · line 1351
Quoted 6 lines
drivers/net/ethernet/intel/ice/ice_lag.c +6
-0+ } + +list_for_each (tmp, lag->netdev_head) { +#if !defined(NO_DCB_SUPPORT ) || defined(ADQ_SUPPORT ) +struct ice_dcbx_cfg *dcb_cfg, *peer_dcb_cfg; +#endif /* !NO_DCB_SUPPORT || ADQ_SUPPORT */ These #ifdefs don't belong here.
Removed them - thanks for catching this!
Quoted 37 lines
Quoted 6 lines
drivers/net/ethernet/intel/ice/ice_lag.c +5
-0+struct ice_lag_netdev_list *entry; +struct ice_netdev_priv *peer_np; +struct net_device *peer_netdev; +struct ice_vsi *vsi, *peer_vsi; +drivers/net/ethernet/intel/ice/ice_lag.c static void ice_lag_monitor_active(struct ice_lag *lag, void *ptr)
Quoted 10 lines
drivers/net/ethernet/intel/ice/ice_lag.c +10
-0+ entry = list_entry(tmp, struct ice_lag_netdev_list, node); + peer_netdev = entry->netdev; +if (!netif_is_ice (peer_netdev)) { +netdev_info (lag->netdev,"Found non-ice netdev in LAG\n" ); +return false; + } + + count++; +if (count >2 ) { + netdev_info(lag->netdev, "Found more than two netdevs inLAG\n");
drivers/net/ethernet/intel/ice/ice_lag.c static void ice_lag_monitor_active(struct ice_lag *lag, void *ptr)
Quoted 9 lines
drivers/net/ethernet/intel/ice/ice_lag.c +9
-0+return false; + } + + peer_np =netdev_priv (peer_netdev); + vsi =ice_get_main_vsi (lag->pf); + peer_vsi = peer_np->vsi; +if (lag->pf->pdev->bus != peer_vsi->back->pdev->bus || + lag->pf->pdev->slot != peer_vsi->back->pdev->slot) { + netdev_info(lag->netdev, "Found netdev on different devicein LAG\n");
drivers/net/ethernet/intel/ice/ice_lag.c static void ice_lag_monitor_active(struct ice_lag *lag, void *ptr)
Quoted 9 lines
drivers/net/ethernet/intel/ice/ice_lag.c +9
-0+return false; + } + +#if !defined(NO_DCB_SUPPORT ) || defined(ADQ_SUPPORT ) + dcb_cfg = &vsi->port_info->qos_cfg.local_dcbx_cfg; + peer_dcb_cfg = &peer_vsi->port_info->qos_cfg.local_dcbx_cfg; +if (memcmp (dcb_cfg, peer_dcb_cfg, +sizeof (struct ice_dcbx_cfg ))) { + netdev_info(lag->netdev, "Found netdev with different DCBconfig in LAG\n");
Quoted 6 lines
drivers/net/ethernet/intel/ice/ice_lag.c static void ice_lag_monitor_active(struct ice_lag *lag, void *ptr) · line 1351
Quoted 4 lines
drivers/net/ethernet/intel/ice/ice_lag.c +4
-0+ return false; + } + +#endif /* !NO_DCB_SUPPORT || ADQ_SUPPORT */ Ditto on the #ifdefs
Also removed
Quoted 8 lines
Quoted 6 lines
drivers/net/ethernet/intel/ice/ice_lag.c +2
-0+ } +return true; }[...]
PATCH v4 7/10 ice: support non-standard teardown of bond interface
In reply to Dave ErtmanCode for supporting removal of the PF driver (NETDEV_UNREGISTER) events for both when the bond has the primary interface as active and when failed over to thew secondary interface.
--- drivers/net/ethernet/intel/ice/ice_lag.c | 47 ++++++++++++++++++++---- 1 file changed, 40 insertions(+), 7 deletions(-)
drivers/net/ethernet/intel/ice/ice_lag.c +40 -7
@@ -1183,15 +1183,16 @@ static void ice_lag_changeupper_event(struct ice_lag *lag, void *ptr)if (!primary_lag && lag->primary) primary_lag = lag; -if (primary_lag) { -if (!lag->primary) { -ice_lag_set_swid (0 , lag, false); - }else { +if (!lag->primary) { +ice_lag_set_swid (0 , lag, false); + }else { +if (primary_lag && lag->primary) {ice_lag_primary_swid (lag, false);ice_lag_del_prune_list (primary_lag, lag->pf); } -ice_lag_cfg_cp_fltr (lag, false); } +/* remove filter for control packets */ +ice_lag_cfg_cp_fltr (lag, false); } }
@@ -1399,6 +1400,38 @@ ice_lag_chk_comp(struct ice_lag *lag, void *ptr)static void ice_lag_unregister (struct ice_lag *lag,struct net_device *event_netdev) { +struct ice_netdev_priv *np; +struct ice_pf *event_pf; +struct ice_lag *p_lag; + + p_lag =ice_lag_find_primary (lag); + np =netdev_priv (event_netdev); + event_pf = np->vsi->back; + +if (p_lag) { +if (p_lag->active_port != p_lag->pf->hw.port_info->lport && + p_lag->active_port !=ICE_LAG_INVALID_PORT ) { +struct ice_hw *active_hw; + + active_hw =ice_lag_find_hw_by_lport (lag, + p_lag->active_port); +if (active_hw) +ice_lag_reclaim_vf_nodes (p_lag, active_hw); + lag->active_port =ICE_LAG_INVALID_PORT ; + } + } + +/* primary processing for primary */ +if (lag->primary && lag->netdev == event_netdev) +ice_lag_primary_swid (lag, false); + +/* primary processing for secondary */ +if (lag->primary && lag->netdev != event_netdev) +ice_lag_del_prune_list (lag, event_pf); + +/* secondary processing for secondary */ +if (!lag->primary && lag->netdev == event_netdev) +ice_lag_set_swid (0 , lag, false); }/**
@@ -1444,8 +1477,8 @@ static void ice_lag_process_event(struct work_struct *work)case NETDEV_UNREGISTER :if (ice_is_feature_supported (pf,ICE_F_SRIOV_LAG )) { netdev = lag_work->info.bonding_info.info.dev; -if (netdev == lag_work->lag->netdev && - lag_work->lag->bonded) +if ((netdev == lag_work->lag->netdev || + lag_work->lag->primary) && lag_work->lag->bonded)ice_lag_unregister (lag_work->lag, netdev); }break ;
Signature · 1 line
2.40.1
PATCH v4 8/10 ice: enforce interface eligibility and add messaging for SRIOV LAG
In reply to Dave ErtmanImplement checks on what interfaces are eligible for supporting SRIOV VFs when a member of an aggregate interface.
Implement unwind path for interfaces that become ineligible.
checks for the SRIOV LAG feature bit wrap most of the functional code for manipulating resources that apply to this feature. Utilize this bit to track compliant aggregates. Also flag any new entries into the aggregate as not supporting SRIOV LAG for the time they are in the non-compliant aggregate.
Once an aggregate has been flagged as non-compliant, only unpopulating the aggregate and re-populating it will return SRIOV LAG functionality.
--- drivers/net/ethernet/intel/ice/ice_lag.c | 88 ++++++++++++++++++++++-- 1 file changed, 83 insertions(+), 5 deletions(-)
drivers/net/ethernet/intel/ice/ice_lag.c +83 -5
@@ -881,6 +881,7 @@ static void ice_lag_link(struct ice_lag *lag) lag->bonded = true; lag->role =ICE_LAG_UNSET ; +netdev_info (lag->netdev,"Shared SR-IOV resources in bond are active\n" ); }/**
@@ -1326,6 +1327,7 @@ ice_lag_chk_comp(struct ice_lag *lag, void *ptr)struct netdev_notifier_bonding_info *info;struct netdev_bonding_info *bonding_info;struct list_head *tmp; +struct device *dev;int count =0 ;if (!lag->primary)
@@ -1338,11 +1340,21 @@ ice_lag_chk_comp(struct ice_lag *lag, void *ptr)if (event_upper != lag->upper_netdev)return true; + dev =ice_pf_to_dev (lag->pf); + +/* only supporting switchdev mode for SRIOV VF LAG. +* primary interface has to be in switchdev mode +*/ +if (!ice_is_switchdev_running (lag->pf)) { +dev_info (dev,"Primary interface not in switchdev mode - VF LAG disabled\n" ); +return false; + } + info = (struct netdev_notifier_bonding_info *)ptr; bonding_info = &info->bonding_info; lag->bond_mode = bonding_info->master.bond_mode;if (lag->bond_mode !=BOND_MODE_ACTIVEBACKUP ) { -netdev_info (lag->netdev,"Bond Mode not ACTIVE-BACKUP\n" ); +dev_info (dev,"Bond Mode not ACTIVE-BACKUP - VF LAG disabled\n" );return false; }
@@ -1354,17 +1366,19 @@ ice_lag_chk_comp(struct ice_lag *lag, void *ptr)struct ice_netdev_priv *peer_np;struct net_device *peer_netdev;struct ice_vsi *vsi, *peer_vsi; +struct ice_pf *peer_pf; entry = list_entry(tmp, struct ice_lag_netdev_list, node); peer_netdev = entry->netdev;if (!netif_is_ice (peer_netdev)) { -netdev_info (lag->netdev,"Found non-ice netdev in LAG\n" ); +dev_info (dev,"Found %s non-ice netdev in LAG - VF LAG disabled\n" , +netdev_name (peer_netdev));return false; } count++;if (count >2 ) { -netdev_info (lag->netdev,"Found more than two netdevs in LAG\n" ); +dev_info (dev,"Found more than two netdevs in LAG - VF LAG disabled\n" );return false; }
@@ -1373,7 +1387,8 @@ ice_lag_chk_comp(struct ice_lag *lag, void *ptr) peer_vsi = peer_np->vsi;if (lag->pf->pdev->bus != peer_vsi->back->pdev->bus || lag->pf->pdev->slot != peer_vsi->back->pdev->slot) { -netdev_info (lag->netdev,"Found netdev on different device in LAG\n" ); +dev_info (dev,"Found %s on different device in LAG - VF LAG disabled\n" , +netdev_name (peer_netdev));return false; }
@@ -1382,11 +1397,18 @@ ice_lag_chk_comp(struct ice_lag *lag, void *ptr) peer_dcb_cfg = &peer_vsi->port_info->qos_cfg.local_dcbx_cfg;if (memcmp (dcb_cfg, peer_dcb_cfg,sizeof (struct ice_dcbx_cfg ))) { -netdev_info (lag->netdev,"Found netdev with different DCB config in LAG\n" ); +dev_info (dev,"Found %s with different DCB in LAG - VF LAG disabled\n" , +netdev_name (peer_netdev));return false; }#endif /* !NO_DCB_SUPPORT || ADQ_SUPPORT */ + peer_pf = peer_vsi->back; +if (test_bit (ICE_FLAG_FW_LLDP_AGENT , peer_pf->flags)) { +dev_warn (dev,"Found %s with FW LLDP agent active - VF LAG disabled\n" , +netdev_name (peer_netdev)); +return false; + } }return true;
@@ -1434,6 +1456,58 @@ ice_lag_unregister(struct ice_lag *lag, struct net_device *event_netdev)ice_lag_set_swid (0 , lag, false); } +/** +* ice_lag_chk_disabled_bond - monitor interfaces entering/leaving disabled bond +* @lag: lag info struct +* @ptr: opaque data containing event +* +* as interfaces enter a bond - determine if the bond is currently +* SRIOV LAG compliant and flag if not. As interfaces leave the +* bond, reset their compliant status. +*/ +static void ice_lag_chk_disabled_bond (struct ice_lag *lag,void *ptr) +{ +struct net_device *netdev =netdev_notifier_info_to_dev (ptr); +struct netdev_notifier_changeupper_info *info = ptr; +struct ice_lag *prim_lag; + +if (netdev != lag->netdev) +return ; + +if (info->linking) { + prim_lag =ice_lag_find_primary (lag); +if (prim_lag && + !ice_is_feature_supported (prim_lag->pf,ICE_F_SRIOV_LAG )) { +ice_clear_feature_support (lag->pf,ICE_F_SRIOV_LAG ); +netdev_info (netdev,"Interface added to non-compliant SRIOV LAG aggregate\n" ); + } + }else { +ice_lag_check_nvm_support (lag->pf); + } +} + +/** +* ice_lag_disable_sriov_bond - set members of bond as not supporting SRIOV LAG +* @lag: primary interfaces lag struct +*/ +static void ice_lag_disable_sriov_bond (struct ice_lag *lag) +{ +struct ice_lag_netdev_list *entry; +struct ice_netdev_priv *np; +struct net_device *netdev; +struct list_head *tmp; +struct ice_pf *pf; + +list_for_each (tmp, lag->netdev_head) { + entry = list_entry(tmp, struct ice_lag_netdev_list, node); + netdev = entry->netdev; + np =netdev_priv (netdev); + pf = np->vsi->back; + +ice_clear_feature_support (pf,ICE_F_SRIOV_LAG ); + } +} +/** * ice_lag_process_event - process a task assigned to the lag_wq * @work: pointer to work_struct
@@ -1455,6 +1529,7 @@ static void ice_lag_process_event(struct work_struct *work)switch (lag_work->event) {case NETDEV_CHANGEUPPER : info = &lag_work->info.changeupper_info; +ice_lag_chk_disabled_bond (lag_work->lag, info);if (ice_is_feature_supported (pf,ICE_F_SRIOV_LAG )) {ice_lag_monitor_link (lag_work->lag, info);ice_lag_changeupper_event (lag_work->lag, info);
@@ -1465,6 +1540,9 @@ static void ice_lag_process_event(struct work_struct *work)if (ice_is_feature_supported (pf,ICE_F_SRIOV_LAG )) {if (!ice_lag_chk_comp (lag_work->lag, &lag_work->info.bonding_info)) { + netdev = lag_work->info.bonding_info.info.dev; +ice_lag_disable_sriov_bond (lag_work->lag); +ice_lag_unregister (lag_work->lag, netdev); goto lag_cleanup; } ice_lag_monitor_active(lag_work->lag,
Signature · 1 line
2.40.1
PATCH v4 9/10 ice: enforce no DCB config changing when in bond
In reply to Dave ErtmanTo support SRIOV LAG, the driver cannot allow changes to an interface's DCB configuration when in a bond. This would break the ability to modify interfaces Tx scheduling for fail-over interfaces.
Block kernel generated DCB config events when in a bond.
--- drivers/net/ethernet/intel/ice/ice_dcb_nl.c | 50 +++++++++++++++++++++ 1 file changed, 50 insertions(+)
drivers/net/ethernet/intel/ice/ice_dcb_nl.c +50 -0
@@ -70,6 +70,11 @@ static int ice_dcbnl_setets(struct net_device *netdev, struct ieee_ets *ets) !(pf->dcbx_cap & DCB_CAP_DCBX_VER_IEEE))return -EINVAL ; +if (pf->lag && pf->lag->bonded) { +netdev_err (netdev,"DCB changes not allowed when in a bond\n" ); +return -EINVAL ; + } + new_cfg = &pf->hw.port_info->qos_cfg.desired_dcbx_cfg;mutex_lock (&pf->tc_mutex);
@@ -170,6 +175,11 @@ static u8 ice_dcbnl_setdcbx(struct net_device *netdev, u8 mode)if (mode == pf->dcbx_cap)return ICE_DCB_NO_HW_CHG ; +if (pf->lag && pf->lag->bonded) { +netdev_err (netdev,"DCB changes not allowed when in a bond\n" ); +return ICE_DCB_NO_HW_CHG ; + } + qos_cfg = &pf->hw.port_info->qos_cfg;/* DSCP configuration is not DCBx negotiated */
@@ -261,6 +271,11 @@ static int ice_dcbnl_setpfc(struct net_device *netdev, struct ieee_pfc *pfc) !(pf->dcbx_cap & DCB_CAP_DCBX_VER_IEEE))return -EINVAL ; +if (pf->lag && pf->lag->bonded) { +netdev_err (netdev,"DCB changes not allowed when in a bond\n" ); +return -EINVAL ; + } +mutex_lock (&pf->tc_mutex); new_cfg = &pf->hw.port_info->qos_cfg.desired_dcbx_cfg;
@@ -323,6 +338,11 @@ static void ice_dcbnl_set_pfc_cfg(struct net_device *netdev, int prio, u8 set)if (prio >=ICE_MAX_USER_PRIORITY )return ; +if (pf->lag && pf->lag->bonded) { +netdev_err (netdev,"DCB changes not allowed when in a bond\n" ); +return ; + } + new_cfg = &pf->hw.port_info->qos_cfg.desired_dcbx_cfg; new_cfg->pfc.pfccap = pf->hw.func_caps.common_cap.maxtc;
@@ -379,6 +399,11 @@ static u8 ice_dcbnl_setstate(struct net_device *netdev, u8 state) !(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE))return ICE_DCB_NO_HW_CHG ; +if (pf->lag && pf->lag->bonded) { +netdev_err (netdev,"DCB changes not allowed when in a bond\n" ); +return ICE_DCB_NO_HW_CHG ; + } +/* Nothing to do */ if (!!state ==test_bit (ICE_FLAG_DCB_ENA , pf->flags))return ICE_DCB_NO_HW_CHG ;
@@ -451,6 +476,11 @@ ice_dcbnl_set_pg_tc_cfg_tx(struct net_device *netdev, int tc,if (tc >=ICE_MAX_TRAFFIC_CLASS )return ; +if (pf->lag && pf->lag->bonded) { +netdev_err (netdev,"DCB changes not allowed when in a bond\n" ); +return ; + } + new_cfg = &pf->hw.port_info->qos_cfg.desired_dcbx_cfg;/* prio_type, bwg_id and bw_pct per UP are not supported */
@@ -505,6 +535,11 @@ ice_dcbnl_set_pg_bwg_cfg_tx(struct net_device *netdev, int pgid, u8 bw_pct)if (pgid >=ICE_MAX_TRAFFIC_CLASS )return ; +if (pf->lag && pf->lag->bonded) { +netdev_err (netdev,"DCB changes not allowed when in a bond\n" ); +return ; + } + new_cfg = &pf->hw.port_info->qos_cfg.desired_dcbx_cfg; new_cfg->etscfg.tcbwtable[pgid] = bw_pct;
@@ -725,6 +760,11 @@ static int ice_dcbnl_setapp(struct net_device *netdev, struct dcb_app *app)return -EINVAL ; } +if (pf->lag && pf->lag->bonded) { +netdev_err (netdev,"DCB changes not allowed when in a bond\n" ); +return -EINVAL ; + } + max_tc = pf->hw.func_caps.common_cap.maxtc;if (app->priority >= max_tc) { netdev_err(netdev, "TC %d out of range, max TC %d\n",
@@ -836,6 +876,11 @@ static int ice_dcbnl_delapp(struct net_device *netdev, struct dcb_app *app)return -EINVAL ; } +if (pf->lag && pf->lag->bonded) { +netdev_err (netdev,"DCB changes not allowed when in a bond\n" ); +return -EINVAL ; + } +mutex_lock (&pf->tc_mutex); old_cfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg;
@@ -937,6 +982,11 @@ static u8 ice_dcbnl_cee_set_all(struct net_device *netdev) !(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE))return ICE_DCB_NO_HW_CHG ; +if (pf->lag && pf->lag->bonded) { +netdev_err (netdev,"DCB changes not allowed when in a bond\n" ); +return ICE_DCB_NO_HW_CHG ; + } + new_cfg = &pf->hw.port_info->qos_cfg.desired_dcbx_cfg;mutex_lock (&pf->tc_mutex);
Signature · 1 line
2.40.1
PATCH v4 10/10 ice: update reset path for SRIOV LAG support
In reply to Dave ErtmanAdd code to rebuild the LAG resources when rebuilding the state of the interface after a reset.
Also added in a function for building per-queue information into the buffer used to configure VF queues for LAG fail-over. This improves code reuse.
Due to differences in timing per interface for recovering from a reset, add in the ability to retry on non-local dependencies where needed.
--- drivers/net/ethernet/intel/ice/ice_lag.c | 231 +++++++++++++++++++++- drivers/net/ethernet/intel/ice/ice_lag.h | 3 + drivers/net/ethernet/intel/ice/ice_main.c | 14 +- 3 files changed, 244 insertions(+), 4 deletions(-)
drivers/net/ethernet/intel/ice/ice_lag.c +228 -3
@@ -954,6 +954,7 @@ static void ice_lag_link_unlink(struct ice_lag *lag, void *ptr)* @link: Is this a linking activity * * If link is false, then primary_swid should be expected to not be valid +* This function should never be called in interrupt context. */ static void ice_lag_set_swid(u16 primary_swid, struct ice_lag *local_lag,
@@ -963,7 +964,7 @@ ice_lag_set_swid(u16 primary_swid, struct ice_lag *local_lag,struct ice_aqc_set_port_params *cmd;struct ice_aq_desc desc;u16 buf_len, swid; -int status; +int status, i; buf_len =struct_size (buf, elem,1 ); buf =kzalloc (buf_len,GFP_KERNEL );
@@ -1014,7 +1015,20 @@ ice_lag_set_swid(u16 primary_swid, struct ice_lag *local_lag,ice_fill_dflt_direct_cmd_desc (&desc, ice_aqc_opc_set_port_params); cmd->swid =cpu_to_le16 (ICE_AQC_PORT_SWID_VALID | swid); - status =ice_aq_send_cmd (&local_lag->pf->hw, &desc,NULL ,0 ,NULL ); +/* If this is happening in reset context, it is possible that the +* primary interface has not finished setting its SWID to SHARED +* yet. Allow retries to account for this timing issue between +* interfaces. +*/ +for (i =0 ; i <ICE_LAG_RESET_RETRIES ; i++) { + status =ice_aq_send_cmd (&local_lag->pf->hw, &desc,NULL ,0 , +NULL ); +if (!status) +break ; + +usleep_range (1000 ,2000 ); + } +if (status)dev_err (ice_pf_to_dev (local_lag->pf),"Error setting SWID in port params %d\n" , status);
@@ -1022,7 +1036,7 @@ ice_lag_set_swid(u16 primary_swid, struct ice_lag *local_lag,/** * ice_lag_primary_swid - set/clear the SHARED attrib of primary's SWID -* @lag: primary interfaces lag struct +* @lag: primary interface's lag struct * @link: is this a linking activity * * Implement setting primary SWID as shared using 0x020B
@@ -1745,6 +1759,135 @@ static int ice_create_lag_recipe(struct ice_hw *hw, u16 *rid,return err; } +/** +* ice_lag_move_vf_nodes_tc_sync - move a VF's nodes for a tc during reset +* @lag: primary interfaces lag struct +* @dest_hw: HW struct for destination's interface +* @vsi_num: VSI index in PF space +* @tc: traffic class to move +*/ +static void +ice_lag_move_vf_nodes_tc_sync (struct ice_lag *lag,struct ice_hw *dest_hw, +u16 vsi_num,u8 tc) +{ +u16 numq, valq, buf_size, num_moved, qbuf_size; +struct device *dev =ice_pf_to_dev (lag->pf); +struct ice_aqc_cfg_txqs_buf *qbuf; +struct ice_aqc_move_elem *buf; +struct ice_sched_node *n_prt; +__le32 teid, parent_teid; +struct ice_vsi_ctx *ctx; +struct ice_hw *hw; +u32 tmp_teid; + + hw = &lag->pf->hw; + ctx =ice_get_vsi_ctx (hw, vsi_num); +if (!ctx) { +dev_warn (dev,"LAG rebuild failed after reset due to VSI Context failure\n" ); +return ; + } + +if (!ctx->sched.vsi_node[tc]) +return ; + + numq = ctx->num_lan_q_entries[tc]; + teid = ctx->sched.vsi_node[tc]->info.node_teid; + tmp_teid =le32_to_cpu (teid); + parent_teid = ctx->sched.vsi_node[tc]->info.parent_teid; + +if (!tmp_teid || !numq) +return ; + +if (ice_sched_suspend_resume_elems (hw,1 , &tmp_teid, true)) +dev_dbg (dev,"Problem suspending traffic during reset rebuild\n" ); + +/* reconfig queues for new port */ + qbuf_size =struct_size (qbuf, queue_info, numq); + qbuf =kzalloc (qbuf_size,GFP_KERNEL ); +if (!qbuf) { +dev_warn (dev,"Failure allocating VF queue recfg buffer for reset rebuild\n" ); + goto resume_sync; + } + +/* add the per queue info for the reconfigure command buffer */ + valq =ice_lag_qbuf_recfg (hw, qbuf, vsi_num, numq, tc); +if (!valq) { +dev_warn (dev,"Failure to reconfig queues for LAG reset rebuild\n" ); + goto sync_none; + } + +if (ice_aq_cfg_lan_txq (hw, qbuf, qbuf_size, numq, hw->port_info->lport, + dest_hw->port_info->lport,NULL )) { +dev_warn (dev,"Failure to configure queues for LAG reset rebuild\n" ); + goto sync_qerr; + } + +sync_none: +kfree (qbuf); + +/* find parent in destination tree */ + n_prt =ice_lag_get_sched_parent (dest_hw, tc); +if (!n_prt) + goto resume_sync; + +/* Move node to new parent */ + buf_size =struct_size (buf, teid,1 ); + buf =kzalloc (buf_size,GFP_KERNEL ); +if (!buf) { +dev_warn (dev,"Failure to alloc for VF node move in reset rebuild\n" ); + goto resume_sync; + } + + buf->hdr.src_parent_teid = parent_teid; + buf->hdr.dest_parent_teid = n_prt->info.node_teid; + buf->hdr.num_elems =cpu_to_le16 (1 ); + buf->hdr.mode =ICE_AQC_MOVE_ELEM_MODE_KEEP_OWN ; + buf->teid[0 ] = teid; + +if (ice_aq_move_sched_elems (&lag->pf->hw,1 , buf, buf_size, &num_moved, +NULL )) +dev_warn (dev,"Failure to move VF nodes for LAG reset rebuild\n" ); +else +ice_sched_update_parent (n_prt, ctx->sched.vsi_node[tc]); + +kfree (buf); + goto resume_sync; + +sync_qerr: +kfree (qbuf); + +resume_sync: +if (ice_sched_suspend_resume_elems (hw,1 , &tmp_teid, false)) +dev_warn (dev,"Problem restarting traffic for LAG node reset rebuild\n" ); +} + +/** +* ice_lag_move_vf_nodes_sync - move vf nodes to active interface +* @lag: primary interfaces lag struct +* @dest_hw: lport value for currently active port +* +* This function is used in a reset context, outside of event handling, +* to move the VF nodes to the secondary interface when that interface +* is the active interface during a reset rebuild +*/ +static void +ice_lag_move_vf_nodes_sync (struct ice_lag *lag,struct ice_hw *dest_hw) +{ +struct ice_pf *pf; +int i, tc; + +if (!lag->primary || !dest_hw) +return ; + + pf = lag->pf; +ice_for_each_vsi (pf, i) +if (pf->vsi[i] && (pf->vsi[i]->type ==ICE_VSI_VF || + pf->vsi[i]->type ==ICE_VSI_SWITCHDEV_CTRL )) +ice_for_each_traffic_class (tc) +ice_lag_move_vf_nodes_tc_sync (lag, dest_hw, i, + tc); +} +/** * ice_init_lag - initialize support for LAG * @pf: PF struct
@@ -1846,3 +1989,85 @@ void ice_deinit_lag(struct ice_pf *pf) pf->lag =NULL ; } + +/** +* ice_lag_rebuild - rebuild lag resources after reset +* @pf: pointer to local pf struct +* +* PF resets are promoted to CORER resets when interface in an aggregate. This +* means that we need to rebuild the PF resources for the interface. Since +* this will happen outside the normal event processing, need to acquire the lag +* lock. +* +* This function will also evaluate the VF resources if this is the primary +* interface. +*/ +void ice_lag_rebuild (struct ice_pf *pf) +{ +struct ice_lag_netdev_list ndlist; +struct ice_lag *lag, *prim_lag; +struct list_head *tmp, *n; +u8 act_port, loc_port; + +if (!pf->lag || !pf->lag->bonded) +return ; + +mutex_lock (&pf->lag_mutex); + + lag = pf->lag; +if (lag->primary) { + prim_lag = lag; + }else { +struct ice_lag_netdev_list *nl; +struct net_device *tmp_nd; + +INIT_LIST_HEAD (&ndlist.node); +rcu_read_lock (); +for_each_netdev_in_bond_rcu (lag->upper_netdev, tmp_nd) { + nl =kzalloc (sizeof (*nl),GFP_KERNEL ); +if (!nl) +break ; + + nl->netdev = tmp_nd; +list_add (&nl->node, &ndlist.node); + } +rcu_read_unlock (); + lag->netdev_head = &ndlist.node; + prim_lag =ice_lag_find_primary (lag); + } + +if (!prim_lag) { +dev_dbg (ice_pf_to_dev (pf),"No primary interface in aggregate, can't rebuild\n" ); + goto lag_rebuild_out; + } + + act_port = prim_lag->active_port; + loc_port = lag->pf->hw.port_info->lport; + +/* configure SWID for this port */ +if (lag->primary) { +ice_lag_primary_swid (lag, true); + }else { +ice_lag_set_swid (prim_lag->pf->hw.port_info->sw_id, lag, true); +ice_lag_add_prune_list (prim_lag, pf); +if (act_port == loc_port) +ice_lag_move_vf_nodes_sync (prim_lag, &pf->hw); + } + +ice_lag_cfg_cp_fltr (lag, true); + +if (lag->pf_rule_id) +if (ice_lag_cfg_dflt_fltr (lag, true)) +dev_err (ice_pf_to_dev (pf),"Error adding default VSI rule in rebuild\n" ); + +ice_clear_rdma_cap (pf); +lag_rebuild_out: +list_for_each_safe (tmp, n, &ndlist.node) { +struct ice_lag_netdev_list *entry; + + entry = list_entry(tmp, struct ice_lag_netdev_list, node); +list_del (&entry->node); +kfree (entry); + } +mutex_unlock (&pf->lag_mutex); +}
drivers/net/ethernet/intel/ice/ice_lag.h +3 -0
@@ -16,6 +16,8 @@ enum ice_lag_role {#define ICE_LAG_INVALID_PORT 0xFF +#define ICE_LAG_RESET_RETRIES 5 +struct ice_pf ;struct ice_vf ;
@@ -59,4 +61,5 @@ struct ice_lag_work {void ice_lag_move_new_vf_nodes (struct ice_vf *vf);int ice_init_lag (struct ice_pf *pf);void ice_deinit_lag (struct ice_pf *pf); +void ice_lag_rebuild (struct ice_pf *pf);#endif /* _ICE_LAG_H_ */
drivers/net/ethernet/intel/ice/ice_main.c +13 -1
@@ -636,6 +636,11 @@ static void ice_do_reset(struct ice_pf *pf, enum ice_reset_req reset_type)dev_dbg (dev,"reset_type 0x%x requested\n" , reset_type); +if (pf->lag && pf->lag->bonded && reset_type ==ICE_RESET_PFR ) { +dev_dbg (dev,"PFR on a bonded interface, promoting to CORER\n" ); + reset_type =ICE_RESET_CORER ; + } +ice_prepare_for_reset (pf, reset_type);/* trigger the reset */
@@ -719,8 +724,13 @@ static void ice_reset_subtask(struct ice_pf *pf) }/* No pending resets to finish processing. Check for new resets */ -if (test_bit (ICE_PFR_REQ , pf->state)) +if (test_bit (ICE_PFR_REQ , pf->state)) { reset_type =ICE_RESET_PFR ; +if (pf->lag && pf->lag->bonded) { +dev_dbg (ice_pf_to_dev (pf),"PFR on a bonded interface, promoting to CORER\n" ); + reset_type =ICE_RESET_CORER ; + } + }if (test_bit (ICE_CORER_REQ , pf->state)) reset_type =ICE_RESET_CORER ;if (test_bit (ICE_GLOBR_REQ , pf->state))
@@ -7361,6 +7371,8 @@ static void ice_rebuild(struct ice_pf *pf, enum ice_reset_req reset_type)clear_bit (ICE_RESET_FAILED , pf->state);ice_plug_aux_dev (pf); +if (ice_is_feature_supported (pf,ICE_F_SRIOV_LAG )) +ice_lag_rebuild (pf);return ; err_vsi_rebuild:
Signature · 1 line
2.40.1
Hmm. v4 series does not apply. Seems like patch #3 is causing some trouble.
Quoted 72 lines
Implement support for SRIOV VF's on interfaces that are in an aggregate interface.
The first interface added into the aggregate will be flagged as the primary interface, and this primary interface will be responsible for managing the VF's resources. VF's created on the primary are the only VFs that will be supported on the aggregate. Only Active-Backup mode will be supported and only aggregates whose primary interface is in switchdev mode will be supported.
Additional restrictions on what interfaces can be added to the aggregate and still support SRIOV VFs are:
- interfaces have to all be on the same physical NIC
- all interfaces have to have the same QoS settings
- interfaces have to have the FW LLDP agent disabled
- only the primary interface is to be put into switchdev mode
- no more than two interfaces in the aggregateChanges since v1:
Fix typo in commit message
Fix typos in warning messages
Fix typo in function header
Use correct bitwise operator instead of booleanChanges since v2:
Rebase on current next-queue
Fix typos in commits
Fix typos in function headers
use %u for unsigned values in debug message
Refactor common code in node moves to subfunctionChanges since v3:
Fix typos in warning messages
move refactor of common code to earlier patch expand use of refactored code
move prototype and func call into patch that defines funcDave Ertman (9):
ice: Add driver support for firmware changes for LAG
ice: changes to the interface with the HW and FW for SRIOV_VF+LAG
ice: implement lag netdev event handler
ice: process events created by lag netdev event handler
ice: Flesh out implementation of support for SRIOV on bonded interface
ice: support non-standard teardown of bond interface
ice: enforce interface eligibility and add messaging for SRIOV LAG
ice: enforce no DCB config changing when in bond
ice: update reset path for SRIOV LAG supportJacob Keller (1):
ice: Correctly initialize queue context valuesdrivers/net/ethernet/intel/ice/ice.h | 5 + .../net/ethernet/intel/ice/ice_adminq_cmd.h | 53 +- drivers/net/ethernet/intel/ice/ice_common.c | 56 + drivers/net/ethernet/intel/ice/ice_common.h | 4 + drivers/net/ethernet/intel/ice/ice_dcb_nl.c | 50 + drivers/net/ethernet/intel/ice/ice_lag.c | 1812 ++++++++++++++++- drivers/net/ethernet/intel/ice/ice_lag.h | 34 +- drivers/net/ethernet/intel/ice/ice_lib.c | 2 +- drivers/net/ethernet/intel/ice/ice_lib.h | 1 + drivers/net/ethernet/intel/ice/ice_main.c | 26 +- drivers/net/ethernet/intel/ice/ice_sched.c | 37 +- drivers/net/ethernet/intel/ice/ice_sched.h | 21 + drivers/net/ethernet/intel/ice/ice_switch.c | 88 +- drivers/net/ethernet/intel/ice/ice_switch.h | 29 + drivers/net/ethernet/intel/ice/ice_type.h | 2 + drivers/net/ethernet/intel/ice/ice_virtchnl.c | 2 + 16 files changed, 2092 insertions(+), 130 deletions(-)--
2.40.1