* [PATCH net-next 01/12] ice: Skip adv rules removal upon switchdev release
2023-06-20 17:44 [PATCH net-next 00/12][pull request] ice: switchdev bridge offload Tony Nguyen
@ 2023-06-20 17:44 ` Tony Nguyen
2023-06-20 17:44 ` [PATCH net-next 02/12] ice: Prohibit rx mode change in switchdev mode Tony Nguyen
` (11 subsequent siblings)
12 siblings, 0 replies; 29+ messages in thread
From: Tony Nguyen @ 2023-06-20 17:44 UTC (permalink / raw)
To: davem, kuba, pabeni, edumazet, netdev
Cc: Wojciech Drewek, anthony.l.nguyen, jiri, ivecera, simon.horman,
Paul Menzel, Sujai Buvaneswaran
From: Wojciech Drewek <wojciech.drewek@intel.com>
Advanced rules for ctrl VSI will be removed anyway when the
VSI will cleaned up, no need to do it explicitly.
Reviewed-by: Paul Menzel <pmenzel@molgen.mpg.de>
Reviewed-by: Simon Horman <simon.horman@corigine.com>
Signed-off-by: Wojciech Drewek <wojciech.drewek@intel.com>
Tested-by: Sujai Buvaneswaran <sujai.buvaneswaran@intel.com>
Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
---
drivers/net/ethernet/intel/ice/ice_eswitch.c | 1 -
drivers/net/ethernet/intel/ice/ice_switch.c | 53 --------------------
drivers/net/ethernet/intel/ice/ice_switch.h | 1 -
3 files changed, 55 deletions(-)
diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch.c b/drivers/net/ethernet/intel/ice/ice_eswitch.c
index ad0a007b7398..be5b22691f7c 100644
--- a/drivers/net/ethernet/intel/ice/ice_eswitch.c
+++ b/drivers/net/ethernet/intel/ice/ice_eswitch.c
@@ -503,7 +503,6 @@ static void ice_eswitch_disable_switchdev(struct ice_pf *pf)
ice_eswitch_napi_disable(pf);
ice_eswitch_release_env(pf);
- ice_rem_adv_rule_for_vsi(&pf->hw, ctrl_vsi->idx);
ice_eswitch_release_reprs(pf, ctrl_vsi);
ice_vsi_release(ctrl_vsi);
ice_repr_rem_from_all_vfs(pf);
diff --git a/drivers/net/ethernet/intel/ice/ice_switch.c b/drivers/net/ethernet/intel/ice/ice_switch.c
index 2ea9e1ae5517..92e16e9720ae 100644
--- a/drivers/net/ethernet/intel/ice/ice_switch.c
+++ b/drivers/net/ethernet/intel/ice/ice_switch.c
@@ -6539,59 +6539,6 @@ ice_rem_adv_rule_by_id(struct ice_hw *hw,
return -ENOENT;
}
-/**
- * ice_rem_adv_rule_for_vsi - removes existing advanced switch rules for a
- * given VSI handle
- * @hw: pointer to the hardware structure
- * @vsi_handle: VSI handle for which we are supposed to remove all the rules.
- *
- * This function is used to remove all the rules for a given VSI and as soon
- * as removing a rule fails, it will return immediately with the error code,
- * else it will return success.
- */
-int ice_rem_adv_rule_for_vsi(struct ice_hw *hw, u16 vsi_handle)
-{
- struct ice_adv_fltr_mgmt_list_entry *list_itr, *tmp_entry;
- struct ice_vsi_list_map_info *map_info;
- struct ice_adv_rule_info rinfo;
- struct list_head *list_head;
- struct ice_switch_info *sw;
- int status;
- u8 rid;
-
- sw = hw->switch_info;
- for (rid = 0; rid < ICE_MAX_NUM_RECIPES; rid++) {
- if (!sw->recp_list[rid].recp_created)
- continue;
- if (!sw->recp_list[rid].adv_rule)
- continue;
-
- list_head = &sw->recp_list[rid].filt_rules;
- list_for_each_entry_safe(list_itr, tmp_entry, list_head,
- list_entry) {
- rinfo = list_itr->rule_info;
-
- if (rinfo.sw_act.fltr_act == ICE_FWD_TO_VSI_LIST) {
- map_info = list_itr->vsi_list_info;
- if (!map_info)
- continue;
-
- if (!test_bit(vsi_handle, map_info->vsi_map))
- continue;
- } else if (rinfo.sw_act.vsi_handle != vsi_handle) {
- continue;
- }
-
- rinfo.sw_act.vsi_handle = vsi_handle;
- status = ice_rem_adv_rule(hw, list_itr->lkups,
- list_itr->lkups_cnt, &rinfo);
- if (status)
- return status;
- }
- }
- return 0;
-}
-
/**
* ice_replay_vsi_adv_rule - Replay advanced rule for requested VSI
* @hw: pointer to the hardware structure
diff --git a/drivers/net/ethernet/intel/ice/ice_switch.h b/drivers/net/ethernet/intel/ice/ice_switch.h
index c84b56fe84a5..db08509805ce 100644
--- a/drivers/net/ethernet/intel/ice/ice_switch.h
+++ b/drivers/net/ethernet/intel/ice/ice_switch.h
@@ -379,7 +379,6 @@ int
ice_set_vlan_vsi_promisc(struct ice_hw *hw, u16 vsi_handle, u8 promisc_mask,
bool rm_vlan_promisc);
-int ice_rem_adv_rule_for_vsi(struct ice_hw *hw, u16 vsi_handle);
int
ice_rem_adv_rule_by_id(struct ice_hw *hw,
struct ice_rule_query_data *remove_entry);
--
2.38.1
^ permalink raw reply related [flat|nested] 29+ messages in thread* [PATCH net-next 02/12] ice: Prohibit rx mode change in switchdev mode
2023-06-20 17:44 [PATCH net-next 00/12][pull request] ice: switchdev bridge offload Tony Nguyen
2023-06-20 17:44 ` [PATCH net-next 01/12] ice: Skip adv rules removal upon switchdev release Tony Nguyen
@ 2023-06-20 17:44 ` Tony Nguyen
2023-06-20 17:44 ` [PATCH net-next 03/12] ice: Don't tx before switchdev is fully configured Tony Nguyen
` (10 subsequent siblings)
12 siblings, 0 replies; 29+ messages in thread
From: Tony Nguyen @ 2023-06-20 17:44 UTC (permalink / raw)
To: davem, kuba, pabeni, edumazet, netdev
Cc: Wojciech Drewek, anthony.l.nguyen, jiri, ivecera, simon.horman,
Paul Menzel, Sujai Buvaneswaran
From: Wojciech Drewek <wojciech.drewek@intel.com>
Don't allow to change promisc mode in switchdev mode.
When switchdev is configured, PF netdev is set to be a
default VSI. This is needed for the slow-path to work correctly.
All the unmatched packets will be directed to PF netdev.
It is possible that this setting might be overwritten by
ndo_set_rx_mode. Prevent this by checking if switchdev is
enabled in ice_set_rx_mode.
Reviewed-by: Paul Menzel <pmenzel@molgen.mpg.de>
Reviewed-by: Simon Horman <simon.horman@corigine.com>
Signed-off-by: Wojciech Drewek <wojciech.drewek@intel.com>
Tested-by: Sujai Buvaneswaran <sujai.buvaneswaran@intel.com>
Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
---
drivers/net/ethernet/intel/ice/ice_main.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/drivers/net/ethernet/intel/ice/ice_main.c b/drivers/net/ethernet/intel/ice/ice_main.c
index 65bf399a0efc..7e0da19689f2 100644
--- a/drivers/net/ethernet/intel/ice/ice_main.c
+++ b/drivers/net/ethernet/intel/ice/ice_main.c
@@ -5698,7 +5698,7 @@ static void ice_set_rx_mode(struct net_device *netdev)
struct ice_netdev_priv *np = netdev_priv(netdev);
struct ice_vsi *vsi = np->vsi;
- if (!vsi)
+ if (!vsi || ice_is_switchdev_running(vsi->back))
return;
/* Set the flags to synchronize filters
--
2.38.1
^ permalink raw reply related [flat|nested] 29+ messages in thread* [PATCH net-next 03/12] ice: Don't tx before switchdev is fully configured
2023-06-20 17:44 [PATCH net-next 00/12][pull request] ice: switchdev bridge offload Tony Nguyen
2023-06-20 17:44 ` [PATCH net-next 01/12] ice: Skip adv rules removal upon switchdev release Tony Nguyen
2023-06-20 17:44 ` [PATCH net-next 02/12] ice: Prohibit rx mode change in switchdev mode Tony Nguyen
@ 2023-06-20 17:44 ` Tony Nguyen
2023-06-20 17:44 ` [PATCH net-next 04/12] ice: Disable vlan pruning for uplink VSI Tony Nguyen
` (9 subsequent siblings)
12 siblings, 0 replies; 29+ messages in thread
From: Tony Nguyen @ 2023-06-20 17:44 UTC (permalink / raw)
To: davem, kuba, pabeni, edumazet, netdev
Cc: Wojciech Drewek, anthony.l.nguyen, jiri, ivecera, simon.horman,
Paul Menzel, Sujai Buvaneswaran
From: Wojciech Drewek <wojciech.drewek@intel.com>
There is possibility that ice_eswitch_port_start_xmit might be
called while some resources are still not allocated which might
cause NULL pointer dereference. Fix this by checking if switchdev
configuration was finished.
Reviewed-by: Paul Menzel <pmenzel@molgen.mpg.de>
Reviewed-by: Simon Horman <simon.horman@corigine.com>
Signed-off-by: Wojciech Drewek <wojciech.drewek@intel.com>
Tested-by: Sujai Buvaneswaran <sujai.buvaneswaran@intel.com>
Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
---
drivers/net/ethernet/intel/ice/ice_eswitch.c | 3 +++
1 file changed, 3 insertions(+)
diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch.c b/drivers/net/ethernet/intel/ice/ice_eswitch.c
index be5b22691f7c..15a4c148c28b 100644
--- a/drivers/net/ethernet/intel/ice/ice_eswitch.c
+++ b/drivers/net/ethernet/intel/ice/ice_eswitch.c
@@ -331,6 +331,9 @@ ice_eswitch_port_start_xmit(struct sk_buff *skb, struct net_device *netdev)
np = netdev_priv(netdev);
vsi = np->vsi;
+ if (!vsi || !ice_is_switchdev_running(vsi->back))
+ return NETDEV_TX_BUSY;
+
if (ice_is_reset_in_progress(vsi->back->state) ||
test_bit(ICE_VF_DIS, vsi->back->state))
return NETDEV_TX_BUSY;
--
2.38.1
^ permalink raw reply related [flat|nested] 29+ messages in thread* [PATCH net-next 04/12] ice: Disable vlan pruning for uplink VSI
2023-06-20 17:44 [PATCH net-next 00/12][pull request] ice: switchdev bridge offload Tony Nguyen
` (2 preceding siblings ...)
2023-06-20 17:44 ` [PATCH net-next 03/12] ice: Don't tx before switchdev is fully configured Tony Nguyen
@ 2023-06-20 17:44 ` Tony Nguyen
2023-06-20 17:44 ` [PATCH net-next 05/12] ice: Unset src prune on " Tony Nguyen
` (8 subsequent siblings)
12 siblings, 0 replies; 29+ messages in thread
From: Tony Nguyen @ 2023-06-20 17:44 UTC (permalink / raw)
To: davem, kuba, pabeni, edumazet, netdev
Cc: Wojciech Drewek, anthony.l.nguyen, jiri, ivecera, simon.horman,
Paul Menzel, Sujai Buvaneswaran
From: Wojciech Drewek <wojciech.drewek@intel.com>
In switchdev mode, uplink VSI is configured to be default
VSI which means it will receive all unmatched packets.
In order to receive vlan packets we need to disable vlan pruning
as well. This is done by dis_rx_filtering vlan op.
Reviewed-by: Paul Menzel <pmenzel@molgen.mpg.de>
Reviewed-by: Simon Horman <simon.horman@corigine.com>
Signed-off-by: Wojciech Drewek <wojciech.drewek@intel.com>
Tested-by: Sujai Buvaneswaran <sujai.buvaneswaran@intel.com>
Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
---
drivers/net/ethernet/intel/ice/ice_eswitch.c | 10 ++++++++++
1 file changed, 10 insertions(+)
diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch.c b/drivers/net/ethernet/intel/ice/ice_eswitch.c
index 15a4c148c28b..bfd003135fc8 100644
--- a/drivers/net/ethernet/intel/ice/ice_eswitch.c
+++ b/drivers/net/ethernet/intel/ice/ice_eswitch.c
@@ -103,6 +103,10 @@ static int ice_eswitch_setup_env(struct ice_pf *pf)
rule_added = true;
}
+ vlan_ops = ice_get_compat_vsi_vlan_ops(uplink_vsi);
+ if (vlan_ops->dis_rx_filtering(uplink_vsi))
+ goto err_dis_rx;
+
if (ice_vsi_update_security(uplink_vsi, ice_vsi_ctx_set_allow_override))
goto err_override_uplink;
@@ -114,6 +118,8 @@ static int ice_eswitch_setup_env(struct ice_pf *pf)
err_override_control:
ice_vsi_update_security(uplink_vsi, ice_vsi_ctx_clear_allow_override);
err_override_uplink:
+ vlan_ops->ena_rx_filtering(uplink_vsi);
+err_dis_rx:
if (rule_added)
ice_clear_dflt_vsi(uplink_vsi);
err_def_rx:
@@ -381,9 +387,13 @@ static void ice_eswitch_release_env(struct ice_pf *pf)
{
struct ice_vsi *uplink_vsi = pf->switchdev.uplink_vsi;
struct ice_vsi *ctrl_vsi = pf->switchdev.control_vsi;
+ struct ice_vsi_vlan_ops *vlan_ops;
+
+ vlan_ops = ice_get_compat_vsi_vlan_ops(uplink_vsi);
ice_vsi_update_security(ctrl_vsi, ice_vsi_ctx_clear_allow_override);
ice_vsi_update_security(uplink_vsi, ice_vsi_ctx_clear_allow_override);
+ vlan_ops->ena_rx_filtering(uplink_vsi);
ice_clear_dflt_vsi(uplink_vsi);
ice_fltr_add_mac_and_broadcast(uplink_vsi,
uplink_vsi->port_info->mac.perm_addr,
--
2.38.1
^ permalink raw reply related [flat|nested] 29+ messages in thread* [PATCH net-next 05/12] ice: Unset src prune on uplink VSI
2023-06-20 17:44 [PATCH net-next 00/12][pull request] ice: switchdev bridge offload Tony Nguyen
` (3 preceding siblings ...)
2023-06-20 17:44 ` [PATCH net-next 04/12] ice: Disable vlan pruning for uplink VSI Tony Nguyen
@ 2023-06-20 17:44 ` Tony Nguyen
2023-06-20 17:44 ` [PATCH net-next 06/12] ice: Implement basic eswitch bridge setup Tony Nguyen
` (7 subsequent siblings)
12 siblings, 0 replies; 29+ messages in thread
From: Tony Nguyen @ 2023-06-20 17:44 UTC (permalink / raw)
To: davem, kuba, pabeni, edumazet, netdev
Cc: Wojciech Drewek, anthony.l.nguyen, jiri, ivecera, simon.horman,
Sujai Buvaneswaran
From: Wojciech Drewek <wojciech.drewek@intel.com>
In switchdev mode uplink VSI is supposed to receive all packets that
were not matched by existing filters. If ICE_AQ_VSI_SW_FLAG_LOCAL_LB
bit is unset and we have a filter associated with uplink VSI
which matches on dst mac equal to MAC1, then packets with src mac equal
to MAC1 will be pruned from reaching uplink VSI.
Fix this by updating uplink VSI with ICE_AQ_VSI_SW_FLAG_LOCAL_LB bit
set when configuring switchdev mode.
Reviewed-by: Simon Horman <simon.horman@corigine.com>
Signed-off-by: Wojciech Drewek <wojciech.drewek@intel.com>
Tested-by: Sujai Buvaneswaran <sujai.buvaneswaran@intel.com>
Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
---
drivers/net/ethernet/intel/ice/ice_eswitch.c | 6 +++++
drivers/net/ethernet/intel/ice/ice_lib.c | 25 ++++++++++++++++++++
drivers/net/ethernet/intel/ice/ice_lib.h | 1 +
3 files changed, 32 insertions(+)
diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch.c b/drivers/net/ethernet/intel/ice/ice_eswitch.c
index bfd003135fc8..4fe235da1182 100644
--- a/drivers/net/ethernet/intel/ice/ice_eswitch.c
+++ b/drivers/net/ethernet/intel/ice/ice_eswitch.c
@@ -113,8 +113,13 @@ static int ice_eswitch_setup_env(struct ice_pf *pf)
if (ice_vsi_update_security(ctrl_vsi, ice_vsi_ctx_set_allow_override))
goto err_override_control;
+ if (ice_vsi_update_local_lb(uplink_vsi, true))
+ goto err_override_local_lb;
+
return 0;
+err_override_local_lb:
+ ice_vsi_update_security(ctrl_vsi, ice_vsi_ctx_clear_allow_override);
err_override_control:
ice_vsi_update_security(uplink_vsi, ice_vsi_ctx_clear_allow_override);
err_override_uplink:
@@ -391,6 +396,7 @@ static void ice_eswitch_release_env(struct ice_pf *pf)
vlan_ops = ice_get_compat_vsi_vlan_ops(uplink_vsi);
+ ice_vsi_update_local_lb(uplink_vsi, false);
ice_vsi_update_security(ctrl_vsi, ice_vsi_ctx_clear_allow_override);
ice_vsi_update_security(uplink_vsi, ice_vsi_ctx_clear_allow_override);
vlan_ops->ena_rx_filtering(uplink_vsi);
diff --git a/drivers/net/ethernet/intel/ice/ice_lib.c b/drivers/net/ethernet/intel/ice/ice_lib.c
index 5ddb95d1073a..e8142bea2eb2 100644
--- a/drivers/net/ethernet/intel/ice/ice_lib.c
+++ b/drivers/net/ethernet/intel/ice/ice_lib.c
@@ -4117,3 +4117,28 @@ void ice_vsi_ctx_clear_allow_override(struct ice_vsi_ctx *ctx)
{
ctx->info.sec_flags &= ~ICE_AQ_VSI_SEC_FLAG_ALLOW_DEST_OVRD;
}
+
+/**
+ * ice_vsi_update_local_lb - update sw block in VSI with local loopback bit
+ * @vsi: pointer to VSI structure
+ * @set: set or unset the bit
+ */
+int
+ice_vsi_update_local_lb(struct ice_vsi *vsi, bool set)
+{
+ struct ice_vsi_ctx ctx = {
+ .info = vsi->info,
+ };
+
+ ctx.info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_SW_VALID);
+ if (set)
+ ctx.info.sw_flags |= ICE_AQ_VSI_SW_FLAG_LOCAL_LB;
+ else
+ ctx.info.sw_flags &= ~ICE_AQ_VSI_SW_FLAG_LOCAL_LB;
+
+ if (ice_update_vsi(&vsi->back->hw, vsi->idx, &ctx, NULL))
+ return -ENODEV;
+
+ vsi->info = ctx.info;
+ return 0;
+}
diff --git a/drivers/net/ethernet/intel/ice/ice_lib.h b/drivers/net/ethernet/intel/ice/ice_lib.h
index e985766e6bb5..1628385a9672 100644
--- a/drivers/net/ethernet/intel/ice/ice_lib.h
+++ b/drivers/net/ethernet/intel/ice/ice_lib.h
@@ -157,6 +157,7 @@ void ice_vsi_ctx_clear_antispoof(struct ice_vsi_ctx *ctx);
void ice_vsi_ctx_set_allow_override(struct ice_vsi_ctx *ctx);
void ice_vsi_ctx_clear_allow_override(struct ice_vsi_ctx *ctx);
+int ice_vsi_update_local_lb(struct ice_vsi *vsi, bool set);
int ice_vsi_add_vlan_zero(struct ice_vsi *vsi);
int ice_vsi_del_vlan_zero(struct ice_vsi *vsi);
bool ice_vsi_has_non_zero_vlans(struct ice_vsi *vsi);
--
2.38.1
^ permalink raw reply related [flat|nested] 29+ messages in thread* [PATCH net-next 06/12] ice: Implement basic eswitch bridge setup
2023-06-20 17:44 [PATCH net-next 00/12][pull request] ice: switchdev bridge offload Tony Nguyen
` (4 preceding siblings ...)
2023-06-20 17:44 ` [PATCH net-next 05/12] ice: Unset src prune on " Tony Nguyen
@ 2023-06-20 17:44 ` Tony Nguyen
2023-06-26 14:26 ` Michal Swiatkowski
2023-06-20 17:44 ` [PATCH net-next 07/12] ice: Switchdev FDB events support Tony Nguyen
` (6 subsequent siblings)
12 siblings, 1 reply; 29+ messages in thread
From: Tony Nguyen @ 2023-06-20 17:44 UTC (permalink / raw)
To: davem, kuba, pabeni, edumazet, netdev
Cc: Wojciech Drewek, anthony.l.nguyen, jiri, ivecera, simon.horman,
Sujai Buvaneswaran
From: Wojciech Drewek <wojciech.drewek@intel.com>
With this patch, ice driver is able to track if the port
representors or uplink port were added to the linux bridge in
switchdev mode. Listen for NETDEV_CHANGEUPPER events in order to
detect this. ice_esw_br data structure reflects the linux bridge
and stores all the ports of the bridge (ice_esw_br_port) in
xarray, it's created when the first port is added to the bridge and
freed once the last port is removed. Note that only one bridge is
supported per eswitch.
Bridge port (ice_esw_br_port) can be either a VF port representor
port or uplink port (ice_esw_br_port_type). In both cases bridge port
holds a reference to the VSI, VF's VSI in case of the PR and uplink
VSI in case of the uplink. VSI's index is used as an index to the
xarray in which ports are stored.
Add a check which prevents configuring switchdev mode if uplink is
already added to any bridge. This is needed because we need to listen
for NETDEV_CHANGEUPPER events to record if the uplink was added to
the bridge. Netdevice notifier is registered after eswitch mode
is changed to switchdev.
Reviewed-by: Simon Horman <simon.horman@corigine.com>
Signed-off-by: Wojciech Drewek <wojciech.drewek@intel.com>
Tested-by: Sujai Buvaneswaran <sujai.buvaneswaran@intel.com>
Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
---
drivers/net/ethernet/intel/ice/Makefile | 2 +-
drivers/net/ethernet/intel/ice/ice.h | 4 +-
drivers/net/ethernet/intel/ice/ice_eswitch.c | 26 +-
.../net/ethernet/intel/ice/ice_eswitch_br.c | 384 ++++++++++++++++++
.../net/ethernet/intel/ice/ice_eswitch_br.h | 42 ++
drivers/net/ethernet/intel/ice/ice_main.c | 2 +-
drivers/net/ethernet/intel/ice/ice_repr.c | 2 +-
drivers/net/ethernet/intel/ice/ice_repr.h | 3 +-
8 files changed, 456 insertions(+), 9 deletions(-)
create mode 100644 drivers/net/ethernet/intel/ice/ice_eswitch_br.c
create mode 100644 drivers/net/ethernet/intel/ice/ice_eswitch_br.h
diff --git a/drivers/net/ethernet/intel/ice/Makefile b/drivers/net/ethernet/intel/ice/Makefile
index 817977e3039d..960277d78e09 100644
--- a/drivers/net/ethernet/intel/ice/Makefile
+++ b/drivers/net/ethernet/intel/ice/Makefile
@@ -47,5 +47,5 @@ ice-$(CONFIG_PTP_1588_CLOCK) += ice_ptp.o ice_ptp_hw.o
ice-$(CONFIG_DCB) += ice_dcb.o ice_dcb_nl.o ice_dcb_lib.o
ice-$(CONFIG_RFS_ACCEL) += ice_arfs.o
ice-$(CONFIG_XDP_SOCKETS) += ice_xsk.o
-ice-$(CONFIG_ICE_SWITCHDEV) += ice_eswitch.o
+ice-$(CONFIG_ICE_SWITCHDEV) += ice_eswitch.o ice_eswitch_br.o
ice-$(CONFIG_GNSS) += ice_gnss.o
diff --git a/drivers/net/ethernet/intel/ice/ice.h b/drivers/net/ethernet/intel/ice/ice.h
index 4ba3d99439a0..8918a4b836a2 100644
--- a/drivers/net/ethernet/intel/ice/ice.h
+++ b/drivers/net/ethernet/intel/ice/ice.h
@@ -517,6 +517,7 @@ enum ice_misc_thread_tasks {
struct ice_switchdev_info {
struct ice_vsi *control_vsi;
struct ice_vsi *uplink_vsi;
+ struct ice_esw_br_offloads *br_offloads;
bool is_running;
};
@@ -626,6 +627,7 @@ struct ice_pf {
struct ice_lag *lag; /* Link Aggregation information */
struct ice_switchdev_info switchdev;
+ struct ice_esw_br_port *br_port;
#define ICE_INVALID_AGG_NODE_ID 0
#define ICE_PF_AGG_NODE_ID_START 1
@@ -853,7 +855,7 @@ static inline bool ice_is_adq_active(struct ice_pf *pf)
return false;
}
-bool netif_is_ice(struct net_device *dev);
+bool netif_is_ice(const struct net_device *dev);
int ice_vsi_setup_tx_rings(struct ice_vsi *vsi);
int ice_vsi_setup_rx_rings(struct ice_vsi *vsi);
int ice_vsi_open_ctrl(struct ice_vsi *vsi);
diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch.c b/drivers/net/ethernet/intel/ice/ice_eswitch.c
index 4fe235da1182..9a53a5e5d73e 100644
--- a/drivers/net/ethernet/intel/ice/ice_eswitch.c
+++ b/drivers/net/ethernet/intel/ice/ice_eswitch.c
@@ -4,6 +4,7 @@
#include "ice.h"
#include "ice_lib.h"
#include "ice_eswitch.h"
+#include "ice_eswitch_br.h"
#include "ice_fltr.h"
#include "ice_repr.h"
#include "ice_devlink.h"
@@ -317,6 +318,9 @@ void ice_eswitch_update_repr(struct ice_vsi *vsi)
repr->src_vsi = vsi;
repr->dst->u.port_info.port_id = vsi->vsi_num;
+ if (repr->br_port)
+ repr->br_port->vsi = vsi;
+
ret = ice_vsi_update_security(vsi, ice_vsi_ctx_clear_antispoof);
if (ret) {
ice_fltr_add_mac_and_broadcast(vsi, vf->hw_lan_addr, ICE_FWD_TO_VSI);
@@ -474,16 +478,24 @@ static void ice_eswitch_napi_disable(struct ice_pf *pf)
*/
static int ice_eswitch_enable_switchdev(struct ice_pf *pf)
{
- struct ice_vsi *ctrl_vsi;
+ struct ice_vsi *ctrl_vsi, *uplink_vsi;
+
+ uplink_vsi = ice_get_main_vsi(pf);
+ if (!uplink_vsi)
+ return -ENODEV;
+
+ if (netif_is_any_bridge_port(uplink_vsi->netdev)) {
+ dev_err(ice_pf_to_dev(pf),
+ "Uplink port cannot be a bridge port\n");
+ return -EINVAL;
+ }
pf->switchdev.control_vsi = ice_eswitch_vsi_setup(pf, pf->hw.port_info);
if (!pf->switchdev.control_vsi)
return -ENODEV;
ctrl_vsi = pf->switchdev.control_vsi;
- pf->switchdev.uplink_vsi = ice_get_main_vsi(pf);
- if (!pf->switchdev.uplink_vsi)
- goto err_vsi;
+ pf->switchdev.uplink_vsi = uplink_vsi;
if (ice_eswitch_setup_env(pf))
goto err_vsi;
@@ -499,10 +511,15 @@ static int ice_eswitch_enable_switchdev(struct ice_pf *pf)
if (ice_vsi_open(ctrl_vsi))
goto err_setup_reprs;
+ if (ice_eswitch_br_offloads_init(pf))
+ goto err_br_offloads;
+
ice_eswitch_napi_enable(pf);
return 0;
+err_br_offloads:
+ ice_vsi_close(ctrl_vsi);
err_setup_reprs:
ice_repr_rem_from_all_vfs(pf);
err_repr_add:
@@ -521,6 +538,7 @@ static void ice_eswitch_disable_switchdev(struct ice_pf *pf)
struct ice_vsi *ctrl_vsi = pf->switchdev.control_vsi;
ice_eswitch_napi_disable(pf);
+ ice_eswitch_br_offloads_deinit(pf);
ice_eswitch_release_env(pf);
ice_eswitch_release_reprs(pf, ctrl_vsi);
ice_vsi_release(ctrl_vsi);
diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch_br.c b/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
new file mode 100644
index 000000000000..8b9ab68dfd53
--- /dev/null
+++ b/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
@@ -0,0 +1,384 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (C) 2023, Intel Corporation. */
+
+#include "ice.h"
+#include "ice_eswitch_br.h"
+#include "ice_repr.h"
+
+static bool ice_eswitch_br_is_dev_valid(const struct net_device *dev)
+{
+ /* Accept only PF netdev and PRs */
+ return ice_is_port_repr_netdev(dev) || netif_is_ice(dev);
+}
+
+static struct ice_esw_br_port *
+ice_eswitch_br_netdev_to_port(struct net_device *dev)
+{
+ if (ice_is_port_repr_netdev(dev)) {
+ struct ice_repr *repr = ice_netdev_to_repr(dev);
+
+ return repr->br_port;
+ } else if (netif_is_ice(dev)) {
+ struct ice_pf *pf = ice_netdev_to_pf(dev);
+
+ return pf->br_port;
+ }
+
+ return NULL;
+}
+
+static void
+ice_eswitch_br_port_deinit(struct ice_esw_br *bridge,
+ struct ice_esw_br_port *br_port)
+{
+ struct ice_vsi *vsi = br_port->vsi;
+
+ if (br_port->type == ICE_ESWITCH_BR_UPLINK_PORT && vsi->back)
+ vsi->back->br_port = NULL;
+ else if (vsi->vf)
+ vsi->vf->repr->br_port = NULL;
+
+ xa_erase(&bridge->ports, br_port->vsi_idx);
+ kfree(br_port);
+}
+
+static struct ice_esw_br_port *
+ice_eswitch_br_port_init(struct ice_esw_br *bridge)
+{
+ struct ice_esw_br_port *br_port;
+
+ br_port = kzalloc(sizeof(*br_port), GFP_KERNEL);
+ if (!br_port)
+ return ERR_PTR(-ENOMEM);
+
+ br_port->bridge = bridge;
+
+ return br_port;
+}
+
+static int
+ice_eswitch_br_vf_repr_port_init(struct ice_esw_br *bridge,
+ struct ice_repr *repr)
+{
+ struct ice_esw_br_port *br_port;
+ int err;
+
+ br_port = ice_eswitch_br_port_init(bridge);
+ if (IS_ERR(br_port))
+ return PTR_ERR(br_port);
+
+ br_port->vsi = repr->src_vsi;
+ br_port->vsi_idx = br_port->vsi->idx;
+ br_port->type = ICE_ESWITCH_BR_VF_REPR_PORT;
+ repr->br_port = br_port;
+
+ err = xa_insert(&bridge->ports, br_port->vsi_idx, br_port, GFP_KERNEL);
+ if (err) {
+ ice_eswitch_br_port_deinit(bridge, br_port);
+ return err;
+ }
+
+ return 0;
+}
+
+static int
+ice_eswitch_br_uplink_port_init(struct ice_esw_br *bridge, struct ice_pf *pf)
+{
+ struct ice_vsi *vsi = pf->switchdev.uplink_vsi;
+ struct ice_esw_br_port *br_port;
+ int err;
+
+ br_port = ice_eswitch_br_port_init(bridge);
+ if (IS_ERR(br_port))
+ return PTR_ERR(br_port);
+
+ br_port->vsi = vsi;
+ br_port->vsi_idx = br_port->vsi->idx;
+ br_port->type = ICE_ESWITCH_BR_UPLINK_PORT;
+ pf->br_port = br_port;
+
+ err = xa_insert(&bridge->ports, br_port->vsi_idx, br_port, GFP_KERNEL);
+ if (err) {
+ ice_eswitch_br_port_deinit(bridge, br_port);
+ return err;
+ }
+
+ return 0;
+}
+
+static void
+ice_eswitch_br_ports_flush(struct ice_esw_br *bridge)
+{
+ struct ice_esw_br_port *port;
+ unsigned long i;
+
+ xa_for_each(&bridge->ports, i, port)
+ ice_eswitch_br_port_deinit(bridge, port);
+}
+
+static void
+ice_eswitch_br_deinit(struct ice_esw_br_offloads *br_offloads,
+ struct ice_esw_br *bridge)
+{
+ if (!bridge)
+ return;
+
+ /* Cleanup all the ports that were added asynchronously
+ * through NETDEV_CHANGEUPPER event.
+ */
+ ice_eswitch_br_ports_flush(bridge);
+ WARN_ON(!xa_empty(&bridge->ports));
+ xa_destroy(&bridge->ports);
+ br_offloads->bridge = NULL;
+ kfree(bridge);
+}
+
+static struct ice_esw_br *
+ice_eswitch_br_init(struct ice_esw_br_offloads *br_offloads, int ifindex)
+{
+ struct ice_esw_br *bridge;
+
+ bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
+ if (!bridge)
+ return ERR_PTR(-ENOMEM);
+
+ bridge->br_offloads = br_offloads;
+ bridge->ifindex = ifindex;
+ xa_init(&bridge->ports);
+ br_offloads->bridge = bridge;
+
+ return bridge;
+}
+
+static struct ice_esw_br *
+ice_eswitch_br_get(struct ice_esw_br_offloads *br_offloads, int ifindex,
+ struct netlink_ext_ack *extack)
+{
+ struct ice_esw_br *bridge = br_offloads->bridge;
+
+ if (bridge) {
+ if (bridge->ifindex != ifindex) {
+ NL_SET_ERR_MSG_MOD(extack,
+ "Only one bridge is supported per eswitch");
+ return ERR_PTR(-EOPNOTSUPP);
+ }
+ return bridge;
+ }
+
+ /* Create the bridge if it doesn't exist yet */
+ bridge = ice_eswitch_br_init(br_offloads, ifindex);
+ if (IS_ERR(bridge))
+ NL_SET_ERR_MSG_MOD(extack, "Failed to init the bridge");
+
+ return bridge;
+}
+
+static void
+ice_eswitch_br_verify_deinit(struct ice_esw_br_offloads *br_offloads,
+ struct ice_esw_br *bridge)
+{
+ /* Remove the bridge if it exists and there are no ports left */
+ if (!bridge || !xa_empty(&bridge->ports))
+ return;
+
+ ice_eswitch_br_deinit(br_offloads, bridge);
+}
+
+static int
+ice_eswitch_br_port_unlink(struct ice_esw_br_offloads *br_offloads,
+ struct net_device *dev, int ifindex,
+ struct netlink_ext_ack *extack)
+{
+ struct ice_esw_br_port *br_port = ice_eswitch_br_netdev_to_port(dev);
+ struct ice_esw_br *bridge;
+
+ if (!br_port) {
+ NL_SET_ERR_MSG_MOD(extack,
+ "Port representor is not attached to any bridge");
+ return -EINVAL;
+ }
+
+ if (br_port->bridge->ifindex != ifindex) {
+ NL_SET_ERR_MSG_MOD(extack,
+ "Port representor is attached to another bridge");
+ return -EINVAL;
+ }
+
+ bridge = br_port->bridge;
+
+ ice_eswitch_br_port_deinit(br_port->bridge, br_port);
+ ice_eswitch_br_verify_deinit(br_offloads, bridge);
+
+ return 0;
+}
+
+static int
+ice_eswitch_br_port_link(struct ice_esw_br_offloads *br_offloads,
+ struct net_device *dev, int ifindex,
+ struct netlink_ext_ack *extack)
+{
+ struct ice_esw_br *bridge;
+ int err;
+
+ if (ice_eswitch_br_netdev_to_port(dev)) {
+ NL_SET_ERR_MSG_MOD(extack,
+ "Port is already attached to the bridge");
+ return -EINVAL;
+ }
+
+ bridge = ice_eswitch_br_get(br_offloads, ifindex, extack);
+ if (IS_ERR(bridge))
+ return PTR_ERR(bridge);
+
+ if (ice_is_port_repr_netdev(dev)) {
+ struct ice_repr *repr = ice_netdev_to_repr(dev);
+
+ err = ice_eswitch_br_vf_repr_port_init(bridge, repr);
+ } else {
+ struct ice_pf *pf = ice_netdev_to_pf(dev);
+
+ err = ice_eswitch_br_uplink_port_init(bridge, pf);
+ }
+ if (err) {
+ NL_SET_ERR_MSG_MOD(extack, "Failed to init bridge port");
+ goto err_port_init;
+ }
+
+ return 0;
+
+err_port_init:
+ ice_eswitch_br_verify_deinit(br_offloads, bridge);
+ return err;
+}
+
+static int
+ice_eswitch_br_port_changeupper(struct notifier_block *nb, void *ptr)
+{
+ struct net_device *dev = netdev_notifier_info_to_dev(ptr);
+ struct netdev_notifier_changeupper_info *info = ptr;
+ struct ice_esw_br_offloads *br_offloads;
+ struct netlink_ext_ack *extack;
+ struct net_device *upper;
+
+ br_offloads = ice_nb_to_br_offloads(nb, netdev_nb);
+
+ if (!ice_eswitch_br_is_dev_valid(dev))
+ return 0;
+
+ upper = info->upper_dev;
+ if (!netif_is_bridge_master(upper))
+ return 0;
+
+ extack = netdev_notifier_info_to_extack(&info->info);
+
+ if (info->linking)
+ return ice_eswitch_br_port_link(br_offloads, dev,
+ upper->ifindex, extack);
+ else
+ return ice_eswitch_br_port_unlink(br_offloads, dev,
+ upper->ifindex, extack);
+}
+
+static int
+ice_eswitch_br_port_event(struct notifier_block *nb,
+ unsigned long event, void *ptr)
+{
+ int err = 0;
+
+ switch (event) {
+ case NETDEV_CHANGEUPPER:
+ err = ice_eswitch_br_port_changeupper(nb, ptr);
+ break;
+ }
+
+ return notifier_from_errno(err);
+}
+
+static void
+ice_eswitch_br_offloads_dealloc(struct ice_pf *pf)
+{
+ struct ice_esw_br_offloads *br_offloads = pf->switchdev.br_offloads;
+
+ ASSERT_RTNL();
+
+ if (!br_offloads)
+ return;
+
+ ice_eswitch_br_deinit(br_offloads, br_offloads->bridge);
+
+ pf->switchdev.br_offloads = NULL;
+ kfree(br_offloads);
+}
+
+static struct ice_esw_br_offloads *
+ice_eswitch_br_offloads_alloc(struct ice_pf *pf)
+{
+ struct ice_esw_br_offloads *br_offloads;
+
+ ASSERT_RTNL();
+
+ if (pf->switchdev.br_offloads)
+ return ERR_PTR(-EEXIST);
+
+ br_offloads = kzalloc(sizeof(*br_offloads), GFP_KERNEL);
+ if (!br_offloads)
+ return ERR_PTR(-ENOMEM);
+
+ pf->switchdev.br_offloads = br_offloads;
+ br_offloads->pf = pf;
+
+ return br_offloads;
+}
+
+void
+ice_eswitch_br_offloads_deinit(struct ice_pf *pf)
+{
+ struct ice_esw_br_offloads *br_offloads;
+
+ br_offloads = pf->switchdev.br_offloads;
+ if (!br_offloads)
+ return;
+
+ unregister_netdevice_notifier(&br_offloads->netdev_nb);
+ /* Although notifier block is unregistered just before,
+ * so we don't get any new events, some events might be
+ * already in progress. Hold the rtnl lock and wait for
+ * them to finished.
+ */
+ rtnl_lock();
+ ice_eswitch_br_offloads_dealloc(pf);
+ rtnl_unlock();
+}
+
+int
+ice_eswitch_br_offloads_init(struct ice_pf *pf)
+{
+ struct ice_esw_br_offloads *br_offloads;
+ struct device *dev = ice_pf_to_dev(pf);
+ int err;
+
+ rtnl_lock();
+ br_offloads = ice_eswitch_br_offloads_alloc(pf);
+ rtnl_unlock();
+ if (IS_ERR(br_offloads)) {
+ dev_err(dev, "Failed to init eswitch bridge\n");
+ return PTR_ERR(br_offloads);
+ }
+
+ br_offloads->netdev_nb.notifier_call = ice_eswitch_br_port_event;
+ err = register_netdevice_notifier(&br_offloads->netdev_nb);
+ if (err) {
+ dev_err(dev,
+ "Failed to register bridge port event notifier\n");
+ goto err_reg_netdev_nb;
+ }
+
+ return 0;
+
+err_reg_netdev_nb:
+ rtnl_lock();
+ ice_eswitch_br_offloads_dealloc(pf);
+ rtnl_unlock();
+
+ return err;
+}
diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch_br.h b/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
new file mode 100644
index 000000000000..3ad28a17298f
--- /dev/null
+++ b/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
@@ -0,0 +1,42 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/* Copyright (C) 2023, Intel Corporation. */
+
+#ifndef _ICE_ESWITCH_BR_H_
+#define _ICE_ESWITCH_BR_H_
+
+enum ice_esw_br_port_type {
+ ICE_ESWITCH_BR_UPLINK_PORT = 0,
+ ICE_ESWITCH_BR_VF_REPR_PORT = 1,
+};
+
+struct ice_esw_br_port {
+ struct ice_esw_br *bridge;
+ struct ice_vsi *vsi;
+ enum ice_esw_br_port_type type;
+ u16 vsi_idx;
+};
+
+struct ice_esw_br {
+ struct ice_esw_br_offloads *br_offloads;
+ struct xarray ports;
+
+ int ifindex;
+};
+
+struct ice_esw_br_offloads {
+ struct ice_pf *pf;
+ struct ice_esw_br *bridge;
+ struct notifier_block netdev_nb;
+};
+
+#define ice_nb_to_br_offloads(nb, nb_name) \
+ container_of(nb, \
+ struct ice_esw_br_offloads, \
+ nb_name)
+
+void
+ice_eswitch_br_offloads_deinit(struct ice_pf *pf);
+int
+ice_eswitch_br_offloads_init(struct ice_pf *pf);
+
+#endif /* _ICE_ESWITCH_BR_H_ */
diff --git a/drivers/net/ethernet/intel/ice/ice_main.c b/drivers/net/ethernet/intel/ice/ice_main.c
index 7e0da19689f2..dd22a1b21c09 100644
--- a/drivers/net/ethernet/intel/ice/ice_main.c
+++ b/drivers/net/ethernet/intel/ice/ice_main.c
@@ -80,7 +80,7 @@ ice_indr_setup_tc_cb(struct net_device *netdev, struct Qdisc *sch,
void *data,
void (*cleanup)(struct flow_block_cb *block_cb));
-bool netif_is_ice(struct net_device *dev)
+bool netif_is_ice(const struct net_device *dev)
{
return dev && (dev->netdev_ops == &ice_netdev_ops);
}
diff --git a/drivers/net/ethernet/intel/ice/ice_repr.c b/drivers/net/ethernet/intel/ice/ice_repr.c
index e30e12321abd..c686ac0935eb 100644
--- a/drivers/net/ethernet/intel/ice/ice_repr.c
+++ b/drivers/net/ethernet/intel/ice/ice_repr.c
@@ -254,7 +254,7 @@ static const struct net_device_ops ice_repr_netdev_ops = {
* ice_is_port_repr_netdev - Check if a given netdevice is a port representor netdev
* @netdev: pointer to netdev
*/
-bool ice_is_port_repr_netdev(struct net_device *netdev)
+bool ice_is_port_repr_netdev(const struct net_device *netdev)
{
return netdev && (netdev->netdev_ops == &ice_repr_netdev_ops);
}
diff --git a/drivers/net/ethernet/intel/ice/ice_repr.h b/drivers/net/ethernet/intel/ice/ice_repr.h
index 9c2a6f496b3b..e1ee2d2c1d2d 100644
--- a/drivers/net/ethernet/intel/ice/ice_repr.h
+++ b/drivers/net/ethernet/intel/ice/ice_repr.h
@@ -12,6 +12,7 @@ struct ice_repr {
struct ice_q_vector *q_vector;
struct net_device *netdev;
struct metadata_dst *dst;
+ struct ice_esw_br_port *br_port;
#ifdef CONFIG_ICE_SWITCHDEV
/* info about slow path rule */
struct ice_rule_query_data sp_rule;
@@ -27,5 +28,5 @@ void ice_repr_stop_tx_queues(struct ice_repr *repr);
void ice_repr_set_traffic_vsi(struct ice_repr *repr, struct ice_vsi *vsi);
struct ice_repr *ice_netdev_to_repr(struct net_device *netdev);
-bool ice_is_port_repr_netdev(struct net_device *netdev);
+bool ice_is_port_repr_netdev(const struct net_device *netdev);
#endif
--
2.38.1
^ permalink raw reply related [flat|nested] 29+ messages in thread* Re: [PATCH net-next 06/12] ice: Implement basic eswitch bridge setup
2023-06-20 17:44 ` [PATCH net-next 06/12] ice: Implement basic eswitch bridge setup Tony Nguyen
@ 2023-06-26 14:26 ` Michal Swiatkowski
2023-06-26 14:31 ` Vlad Buslov
2023-06-26 17:35 ` Jakub Kicinski
0 siblings, 2 replies; 29+ messages in thread
From: Michal Swiatkowski @ 2023-06-26 14:26 UTC (permalink / raw)
To: Tony Nguyen
Cc: davem, kuba, pabeni, edumazet, netdev, Wojciech Drewek, jiri,
ivecera, simon.horman, Sujai Buvaneswaran, Vlad Buslov
On Tue, Jun 20, 2023 at 10:44:17AM -0700, Tony Nguyen wrote:
> From: Wojciech Drewek <wojciech.drewek@intel.com>
>
> With this patch, ice driver is able to track if the port
> representors or uplink port were added to the linux bridge in
> switchdev mode. Listen for NETDEV_CHANGEUPPER events in order to
> detect this. ice_esw_br data structure reflects the linux bridge
> and stores all the ports of the bridge (ice_esw_br_port) in
> xarray, it's created when the first port is added to the bridge and
> freed once the last port is removed. Note that only one bridge is
> supported per eswitch.
>
> Bridge port (ice_esw_br_port) can be either a VF port representor
> port or uplink port (ice_esw_br_port_type). In both cases bridge port
> holds a reference to the VSI, VF's VSI in case of the PR and uplink
> VSI in case of the uplink. VSI's index is used as an index to the
> xarray in which ports are stored.
>
> Add a check which prevents configuring switchdev mode if uplink is
> already added to any bridge. This is needed because we need to listen
> for NETDEV_CHANGEUPPER events to record if the uplink was added to
> the bridge. Netdevice notifier is registered after eswitch mode
> is changed to switchdev.
>
> Reviewed-by: Simon Horman <simon.horman@corigine.com>
> Signed-off-by: Wojciech Drewek <wojciech.drewek@intel.com>
> Tested-by: Sujai Buvaneswaran <sujai.buvaneswaran@intel.com>
> Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
> ---
> drivers/net/ethernet/intel/ice/Makefile | 2 +-
> drivers/net/ethernet/intel/ice/ice.h | 4 +-
> drivers/net/ethernet/intel/ice/ice_eswitch.c | 26 +-
> .../net/ethernet/intel/ice/ice_eswitch_br.c | 384 ++++++++++++++++++
> .../net/ethernet/intel/ice/ice_eswitch_br.h | 42 ++
> drivers/net/ethernet/intel/ice/ice_main.c | 2 +-
> drivers/net/ethernet/intel/ice/ice_repr.c | 2 +-
> drivers/net/ethernet/intel/ice/ice_repr.h | 3 +-
> 8 files changed, 456 insertions(+), 9 deletions(-)
> create mode 100644 drivers/net/ethernet/intel/ice/ice_eswitch_br.c
> create mode 100644 drivers/net/ethernet/intel/ice/ice_eswitch_br.h
> +
> +static int
> +ice_eswitch_br_port_changeupper(struct notifier_block *nb, void *ptr)
> +{
> + struct net_device *dev = netdev_notifier_info_to_dev(ptr);
> + struct netdev_notifier_changeupper_info *info = ptr;
> + struct ice_esw_br_offloads *br_offloads;
> + struct netlink_ext_ack *extack;
> + struct net_device *upper;
> +
> + br_offloads = ice_nb_to_br_offloads(nb, netdev_nb);
> +
> + if (!ice_eswitch_br_is_dev_valid(dev))
> + return 0;
> +
> + upper = info->upper_dev;
> + if (!netif_is_bridge_master(upper))
> + return 0;
> +
> + extack = netdev_notifier_info_to_extack(&info->info);
> +
> + if (info->linking)
> + return ice_eswitch_br_port_link(br_offloads, dev,
> + upper->ifindex, extack);
> + else
> + return ice_eswitch_br_port_unlink(br_offloads, dev,
> + upper->ifindex, extack);
> +}
> +
> +static int
> +ice_eswitch_br_port_event(struct notifier_block *nb,
> + unsigned long event, void *ptr)
> +{
> + int err = 0;
> +
> + switch (event) {
> + case NETDEV_CHANGEUPPER:
> + err = ice_eswitch_br_port_changeupper(nb, ptr);
> + break;
> + }
> +
> + return notifier_from_errno(err);
> +}
Hi Vlad,
We found out that adding VF and corresponding port representor to the
bridge cause loop in the bridge. Packets are looping through the bridge.
I know that it isn't valid configuration, howevere, it can happen and
after that the server is quite unstable.
Does mellanox validate the port for this scenario? Or we should assume
that user will add port wisely? I was looking at your code, but didn't
find that. You are using NETDEV_PRECHANGEUPPER, do you think we should
validate if user is trying to add VF when his PR is currently added?
Thanks in advance,
Michal
^ permalink raw reply [flat|nested] 29+ messages in thread* Re: [PATCH net-next 06/12] ice: Implement basic eswitch bridge setup
2023-06-26 14:26 ` Michal Swiatkowski
@ 2023-06-26 14:31 ` Vlad Buslov
2023-06-27 6:46 ` Michal Swiatkowski
2023-06-26 17:35 ` Jakub Kicinski
1 sibling, 1 reply; 29+ messages in thread
From: Vlad Buslov @ 2023-06-26 14:31 UTC (permalink / raw)
To: Michal Swiatkowski
Cc: Tony Nguyen, davem, kuba, pabeni, edumazet, netdev,
Wojciech Drewek, jiri, ivecera, simon.horman, Sujai Buvaneswaran
On Mon 26 Jun 2023 at 16:26, Michal Swiatkowski <michal.swiatkowski@linux.intel.com> wrote:
> On Tue, Jun 20, 2023 at 10:44:17AM -0700, Tony Nguyen wrote:
>> From: Wojciech Drewek <wojciech.drewek@intel.com>
>>
>> With this patch, ice driver is able to track if the port
>> representors or uplink port were added to the linux bridge in
>> switchdev mode. Listen for NETDEV_CHANGEUPPER events in order to
>> detect this. ice_esw_br data structure reflects the linux bridge
>> and stores all the ports of the bridge (ice_esw_br_port) in
>> xarray, it's created when the first port is added to the bridge and
>> freed once the last port is removed. Note that only one bridge is
>> supported per eswitch.
>>
>> Bridge port (ice_esw_br_port) can be either a VF port representor
>> port or uplink port (ice_esw_br_port_type). In both cases bridge port
>> holds a reference to the VSI, VF's VSI in case of the PR and uplink
>> VSI in case of the uplink. VSI's index is used as an index to the
>> xarray in which ports are stored.
>>
>> Add a check which prevents configuring switchdev mode if uplink is
>> already added to any bridge. This is needed because we need to listen
>> for NETDEV_CHANGEUPPER events to record if the uplink was added to
>> the bridge. Netdevice notifier is registered after eswitch mode
>> is changed to switchdev.
>>
>> Reviewed-by: Simon Horman <simon.horman@corigine.com>
>> Signed-off-by: Wojciech Drewek <wojciech.drewek@intel.com>
>> Tested-by: Sujai Buvaneswaran <sujai.buvaneswaran@intel.com>
>> Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
>> ---
>> drivers/net/ethernet/intel/ice/Makefile | 2 +-
>> drivers/net/ethernet/intel/ice/ice.h | 4 +-
>> drivers/net/ethernet/intel/ice/ice_eswitch.c | 26 +-
>> .../net/ethernet/intel/ice/ice_eswitch_br.c | 384 ++++++++++++++++++
>> .../net/ethernet/intel/ice/ice_eswitch_br.h | 42 ++
>> drivers/net/ethernet/intel/ice/ice_main.c | 2 +-
>> drivers/net/ethernet/intel/ice/ice_repr.c | 2 +-
>> drivers/net/ethernet/intel/ice/ice_repr.h | 3 +-
>> 8 files changed, 456 insertions(+), 9 deletions(-)
>> create mode 100644 drivers/net/ethernet/intel/ice/ice_eswitch_br.c
>> create mode 100644 drivers/net/ethernet/intel/ice/ice_eswitch_br.h
>> +
>> +static int
>> +ice_eswitch_br_port_changeupper(struct notifier_block *nb, void *ptr)
>> +{
>> + struct net_device *dev = netdev_notifier_info_to_dev(ptr);
>> + struct netdev_notifier_changeupper_info *info = ptr;
>> + struct ice_esw_br_offloads *br_offloads;
>> + struct netlink_ext_ack *extack;
>> + struct net_device *upper;
>> +
>> + br_offloads = ice_nb_to_br_offloads(nb, netdev_nb);
>> +
>> + if (!ice_eswitch_br_is_dev_valid(dev))
>> + return 0;
>> +
>> + upper = info->upper_dev;
>> + if (!netif_is_bridge_master(upper))
>> + return 0;
>> +
>> + extack = netdev_notifier_info_to_extack(&info->info);
>> +
>> + if (info->linking)
>> + return ice_eswitch_br_port_link(br_offloads, dev,
>> + upper->ifindex, extack);
>> + else
>> + return ice_eswitch_br_port_unlink(br_offloads, dev,
>> + upper->ifindex, extack);
>> +}
>> +
>> +static int
>> +ice_eswitch_br_port_event(struct notifier_block *nb,
>> + unsigned long event, void *ptr)
>> +{
>> + int err = 0;
>> +
>> + switch (event) {
>> + case NETDEV_CHANGEUPPER:
>> + err = ice_eswitch_br_port_changeupper(nb, ptr);
>> + break;
>> + }
>> +
>> + return notifier_from_errno(err);
>> +}
> Hi Vlad,
>
> We found out that adding VF and corresponding port representor to the
> bridge cause loop in the bridge. Packets are looping through the bridge.
> I know that it isn't valid configuration, howevere, it can happen and
> after that the server is quite unstable.
>
> Does mellanox validate the port for this scenario? Or we should assume
> that user will add port wisely? I was looking at your code, but didn't
> find that. You are using NETDEV_PRECHANGEUPPER, do you think we should
> validate if user is trying to add VF when his PR is currently added?
Hmm, no, it is not something we validate. Also, I assume it will be
quite tricky to properly test for it, since user could try to add some
other netdevice connected to the VF (VLAN, tunneling dev, bonding, etc.)
which will probably lead to same result.
^ permalink raw reply [flat|nested] 29+ messages in thread* Re: [PATCH net-next 06/12] ice: Implement basic eswitch bridge setup
2023-06-26 14:31 ` Vlad Buslov
@ 2023-06-27 6:46 ` Michal Swiatkowski
0 siblings, 0 replies; 29+ messages in thread
From: Michal Swiatkowski @ 2023-06-27 6:46 UTC (permalink / raw)
To: Vlad Buslov
Cc: Tony Nguyen, davem, kuba, pabeni, edumazet, netdev,
Wojciech Drewek, jiri, ivecera, simon.horman, Sujai Buvaneswaran
On Mon, Jun 26, 2023 at 05:31:14PM +0300, Vlad Buslov wrote:
> On Mon 26 Jun 2023 at 16:26, Michal Swiatkowski <michal.swiatkowski@linux.intel.com> wrote:
> > On Tue, Jun 20, 2023 at 10:44:17AM -0700, Tony Nguyen wrote:
> >> From: Wojciech Drewek <wojciech.drewek@intel.com>
> >>
> >> With this patch, ice driver is able to track if the port
> >> representors or uplink port were added to the linux bridge in
> >> switchdev mode. Listen for NETDEV_CHANGEUPPER events in order to
> >> detect this. ice_esw_br data structure reflects the linux bridge
> >> and stores all the ports of the bridge (ice_esw_br_port) in
> >> xarray, it's created when the first port is added to the bridge and
> >> freed once the last port is removed. Note that only one bridge is
> >> supported per eswitch.
> >>
> >> Bridge port (ice_esw_br_port) can be either a VF port representor
> >> port or uplink port (ice_esw_br_port_type). In both cases bridge port
> >> holds a reference to the VSI, VF's VSI in case of the PR and uplink
> >> VSI in case of the uplink. VSI's index is used as an index to the
> >> xarray in which ports are stored.
> >>
> >> Add a check which prevents configuring switchdev mode if uplink is
> >> already added to any bridge. This is needed because we need to listen
> >> for NETDEV_CHANGEUPPER events to record if the uplink was added to
> >> the bridge. Netdevice notifier is registered after eswitch mode
> >> is changed to switchdev.
> >>
> >> Reviewed-by: Simon Horman <simon.horman@corigine.com>
> >> Signed-off-by: Wojciech Drewek <wojciech.drewek@intel.com>
> >> Tested-by: Sujai Buvaneswaran <sujai.buvaneswaran@intel.com>
> >> Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
> >> ---
> >> drivers/net/ethernet/intel/ice/Makefile | 2 +-
> >> drivers/net/ethernet/intel/ice/ice.h | 4 +-
> >> drivers/net/ethernet/intel/ice/ice_eswitch.c | 26 +-
> >> .../net/ethernet/intel/ice/ice_eswitch_br.c | 384 ++++++++++++++++++
> >> .../net/ethernet/intel/ice/ice_eswitch_br.h | 42 ++
> >> drivers/net/ethernet/intel/ice/ice_main.c | 2 +-
> >> drivers/net/ethernet/intel/ice/ice_repr.c | 2 +-
> >> drivers/net/ethernet/intel/ice/ice_repr.h | 3 +-
> >> 8 files changed, 456 insertions(+), 9 deletions(-)
> >> create mode 100644 drivers/net/ethernet/intel/ice/ice_eswitch_br.c
> >> create mode 100644 drivers/net/ethernet/intel/ice/ice_eswitch_br.h
> >> +
> >> +static int
> >> +ice_eswitch_br_port_changeupper(struct notifier_block *nb, void *ptr)
> >> +{
> >> + struct net_device *dev = netdev_notifier_info_to_dev(ptr);
> >> + struct netdev_notifier_changeupper_info *info = ptr;
> >> + struct ice_esw_br_offloads *br_offloads;
> >> + struct netlink_ext_ack *extack;
> >> + struct net_device *upper;
> >> +
> >> + br_offloads = ice_nb_to_br_offloads(nb, netdev_nb);
> >> +
> >> + if (!ice_eswitch_br_is_dev_valid(dev))
> >> + return 0;
> >> +
> >> + upper = info->upper_dev;
> >> + if (!netif_is_bridge_master(upper))
> >> + return 0;
> >> +
> >> + extack = netdev_notifier_info_to_extack(&info->info);
> >> +
> >> + if (info->linking)
> >> + return ice_eswitch_br_port_link(br_offloads, dev,
> >> + upper->ifindex, extack);
> >> + else
> >> + return ice_eswitch_br_port_unlink(br_offloads, dev,
> >> + upper->ifindex, extack);
> >> +}
> >> +
> >> +static int
> >> +ice_eswitch_br_port_event(struct notifier_block *nb,
> >> + unsigned long event, void *ptr)
> >> +{
> >> + int err = 0;
> >> +
> >> + switch (event) {
> >> + case NETDEV_CHANGEUPPER:
> >> + err = ice_eswitch_br_port_changeupper(nb, ptr);
> >> + break;
> >> + }
> >> +
> >> + return notifier_from_errno(err);
> >> +}
> > Hi Vlad,
> >
> > We found out that adding VF and corresponding port representor to the
> > bridge cause loop in the bridge. Packets are looping through the bridge.
> > I know that it isn't valid configuration, howevere, it can happen and
> > after that the server is quite unstable.
> >
> > Does mellanox validate the port for this scenario? Or we should assume
> > that user will add port wisely? I was looking at your code, but didn't
> > find that. You are using NETDEV_PRECHANGEUPPER, do you think we should
> > validate if user is trying to add VF when his PR is currently added?
>
> Hmm, no, it is not something we validate. Also, I assume it will be
> quite tricky to properly test for it, since user could try to add some
> other netdevice connected to the VF (VLAN, tunneling dev, bonding, etc.)
> which will probably lead to same result.
>
Agree, thanks. As Jakub wrote, STP should be turned on to prevent this kind
of problem.
^ permalink raw reply [flat|nested] 29+ messages in thread
* Re: [PATCH net-next 06/12] ice: Implement basic eswitch bridge setup
2023-06-26 14:26 ` Michal Swiatkowski
2023-06-26 14:31 ` Vlad Buslov
@ 2023-06-26 17:35 ` Jakub Kicinski
2023-06-27 6:41 ` Michal Swiatkowski
1 sibling, 1 reply; 29+ messages in thread
From: Jakub Kicinski @ 2023-06-26 17:35 UTC (permalink / raw)
To: Michal Swiatkowski
Cc: Tony Nguyen, davem, pabeni, edumazet, netdev, Wojciech Drewek,
jiri, ivecera, simon.horman, Sujai Buvaneswaran, Vlad Buslov
On Mon, 26 Jun 2023 16:26:15 +0200 Michal Swiatkowski wrote:
> We found out that adding VF and corresponding port representor to the
> bridge cause loop in the bridge. Packets are looping through the bridge.
> I know that it isn't valid configuration, howevere, it can happen and
> after that the server is quite unstable.
>
> Does mellanox validate the port for this scenario? Or we should assume
> that user will add port wisely? I was looking at your code, but didn't
> find that. You are using NETDEV_PRECHANGEUPPER, do you think we should
> validate if user is trying to add VF when his PR is currently added?
Can you try to plug two ends of a veth into a bridge and see if the
same thing happens? My instinct is that this is a classic bridge
problem and the answer is STP.
^ permalink raw reply [flat|nested] 29+ messages in thread
* Re: [PATCH net-next 06/12] ice: Implement basic eswitch bridge setup
2023-06-26 17:35 ` Jakub Kicinski
@ 2023-06-27 6:41 ` Michal Swiatkowski
0 siblings, 0 replies; 29+ messages in thread
From: Michal Swiatkowski @ 2023-06-27 6:41 UTC (permalink / raw)
To: Jakub Kicinski
Cc: Tony Nguyen, davem, pabeni, edumazet, netdev, Wojciech Drewek,
jiri, ivecera, simon.horman, Sujai Buvaneswaran, Vlad Buslov
On Mon, Jun 26, 2023 at 10:35:42AM -0700, Jakub Kicinski wrote:
> On Mon, 26 Jun 2023 16:26:15 +0200 Michal Swiatkowski wrote:
> > We found out that adding VF and corresponding port representor to the
> > bridge cause loop in the bridge. Packets are looping through the bridge.
> > I know that it isn't valid configuration, howevere, it can happen and
> > after that the server is quite unstable.
> >
> > Does mellanox validate the port for this scenario? Or we should assume
> > that user will add port wisely? I was looking at your code, but didn't
> > find that. You are using NETDEV_PRECHANGEUPPER, do you think we should
> > validate if user is trying to add VF when his PR is currently added?
>
> Can you try to plug two ends of a veth into a bridge and see if the
> same thing happens? My instinct is that this is a classic bridge
> problem and the answer is STP.
Yeah, the same happens with veth connected to the bridge with both ends.
Turning STP on on the bridge fix the problem. Thanks for help :)
Michal
^ permalink raw reply [flat|nested] 29+ messages in thread
* [PATCH net-next 07/12] ice: Switchdev FDB events support
2023-06-20 17:44 [PATCH net-next 00/12][pull request] ice: switchdev bridge offload Tony Nguyen
` (5 preceding siblings ...)
2023-06-20 17:44 ` [PATCH net-next 06/12] ice: Implement basic eswitch bridge setup Tony Nguyen
@ 2023-06-20 17:44 ` Tony Nguyen
2023-06-21 13:55 ` Simon Horman
2023-06-22 11:53 ` Vlad Buslov
2023-06-20 17:44 ` [PATCH net-next 08/12] ice: Add guard rule when creating FDB in switchdev Tony Nguyen
` (5 subsequent siblings)
12 siblings, 2 replies; 29+ messages in thread
From: Tony Nguyen @ 2023-06-20 17:44 UTC (permalink / raw)
To: davem, kuba, pabeni, edumazet, netdev
Cc: Wojciech Drewek, anthony.l.nguyen, jiri, ivecera, simon.horman,
Sujai Buvaneswaran
From: Wojciech Drewek <wojciech.drewek@intel.com>
Listen for SWITCHDEV_FDB_{ADD|DEL}_TO_DEVICE events while in switchdev
mode. Accept these events on both uplink and VF PR ports. Add HW
rules in newly created workqueue. FDB entries are stored in rhashtable
for lookup when removing the entry and in the list for cleanup
purpose. Direction of the HW rule depends on the type of the ports
on which the FDB event was received:
ICE_ESWITCH_BR_UPLINK_PORT:
TX rule that forwards the packet to the LAN (egress).
ICE_ESWITCH_BR_VF_REPR_PORT:
RX rule that forwards the packet to the VF associated
with the port representor.
In both cases the rule matches on the dst mac address.
All the FDB entries are stored in the bridge structure.
When the port is removed all the FDB entries associated with
this port are removed as well. This is achieved thanks to the reference
to the port that FDB entry holds.
In the fwd rule we use only one lookup type (MAC address)
but lkups_cnt variable is already introduced because
we will have more lookups in the subsequent patches.
Signed-off-by: Wojciech Drewek <wojciech.drewek@intel.com>
Tested-by: Sujai Buvaneswaran <sujai.buvaneswaran@intel.com>
Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
---
.../net/ethernet/intel/ice/ice_eswitch_br.c | 439 +++++++++++++++++-
.../net/ethernet/intel/ice/ice_eswitch_br.h | 46 ++
2 files changed, 484 insertions(+), 1 deletion(-)
diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch_br.c b/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
index 8b9ab68dfd53..8f22da490a69 100644
--- a/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
+++ b/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
@@ -4,6 +4,14 @@
#include "ice.h"
#include "ice_eswitch_br.h"
#include "ice_repr.h"
+#include "ice_switch.h"
+
+static const struct rhashtable_params ice_fdb_ht_params = {
+ .key_offset = offsetof(struct ice_esw_br_fdb_entry, data),
+ .key_len = sizeof(struct ice_esw_br_fdb_data),
+ .head_offset = offsetof(struct ice_esw_br_fdb_entry, ht_node),
+ .automatic_shrinking = true,
+};
static bool ice_eswitch_br_is_dev_valid(const struct net_device *dev)
{
@@ -27,15 +35,412 @@ ice_eswitch_br_netdev_to_port(struct net_device *dev)
return NULL;
}
+static void
+ice_eswitch_br_ingress_rule_setup(struct ice_adv_rule_info *rule_info,
+ u8 pf_id, u16 vf_vsi_idx)
+{
+ rule_info->sw_act.vsi_handle = vf_vsi_idx;
+ rule_info->sw_act.flag |= ICE_FLTR_RX;
+ rule_info->sw_act.src = pf_id;
+ rule_info->priority = 5;
+}
+
+static void
+ice_eswitch_br_egress_rule_setup(struct ice_adv_rule_info *rule_info,
+ u16 pf_vsi_idx)
+{
+ rule_info->sw_act.vsi_handle = pf_vsi_idx;
+ rule_info->sw_act.flag |= ICE_FLTR_TX;
+ rule_info->flags_info.act = ICE_SINGLE_ACT_LAN_ENABLE;
+ rule_info->flags_info.act_valid = true;
+ rule_info->priority = 5;
+}
+
+static int
+ice_eswitch_br_rule_delete(struct ice_hw *hw, struct ice_rule_query_data *rule)
+{
+ int err;
+
+ if (!rule)
+ return -EINVAL;
+
+ err = ice_rem_adv_rule_by_id(hw, rule);
+ kfree(rule);
+
+ return err;
+}
+
+static struct ice_rule_query_data *
+ice_eswitch_br_fwd_rule_create(struct ice_hw *hw, int vsi_idx, int port_type,
+ const unsigned char *mac)
+{
+ struct ice_adv_rule_info rule_info = { 0 };
+ struct ice_rule_query_data *rule;
+ struct ice_adv_lkup_elem *list;
+ u16 lkups_cnt = 1;
+ int err;
+
+ rule = kzalloc(sizeof(*rule), GFP_KERNEL);
+ if (!rule)
+ return ERR_PTR(-ENOMEM);
+
+ list = kcalloc(lkups_cnt, sizeof(*list), GFP_ATOMIC);
+ if (!list) {
+ err = -ENOMEM;
+ goto err_list_alloc;
+ }
+
+ switch (port_type) {
+ case ICE_ESWITCH_BR_UPLINK_PORT:
+ ice_eswitch_br_egress_rule_setup(&rule_info, vsi_idx);
+ break;
+ case ICE_ESWITCH_BR_VF_REPR_PORT:
+ ice_eswitch_br_ingress_rule_setup(&rule_info, hw->pf_id,
+ vsi_idx);
+ break;
+ default:
+ err = -EINVAL;
+ goto err_add_rule;
+ }
+
+ list[0].type = ICE_MAC_OFOS;
+ ether_addr_copy(list[0].h_u.eth_hdr.dst_addr, mac);
+ eth_broadcast_addr(list[0].m_u.eth_hdr.dst_addr);
+
+ rule_info.sw_act.fltr_act = ICE_FWD_TO_VSI;
+
+ err = ice_add_adv_rule(hw, list, lkups_cnt, &rule_info, rule);
+ if (err)
+ goto err_add_rule;
+
+ kfree(list);
+
+ return rule;
+
+err_add_rule:
+ kfree(list);
+err_list_alloc:
+ kfree(rule);
+
+ return ERR_PTR(err);
+}
+
+static struct ice_esw_br_flow *
+ice_eswitch_br_flow_create(struct device *dev, struct ice_hw *hw, int vsi_idx,
+ int port_type, const unsigned char *mac)
+{
+ struct ice_rule_query_data *fwd_rule;
+ struct ice_esw_br_flow *flow;
+ int err;
+
+ flow = kzalloc(sizeof(*flow), GFP_KERNEL);
+ if (!flow)
+ return ERR_PTR(-ENOMEM);
+
+ fwd_rule = ice_eswitch_br_fwd_rule_create(hw, vsi_idx, port_type, mac);
+ err = PTR_ERR_OR_ZERO(fwd_rule);
+ if (err) {
+ dev_err(dev, "Failed to create eswitch bridge %sgress forward rule, err: %d\n",
+ port_type == ICE_ESWITCH_BR_UPLINK_PORT ? "e" : "in",
+ err);
+ goto err_fwd_rule;
+ }
+
+ flow->fwd_rule = fwd_rule;
+
+ return flow;
+
+err_fwd_rule:
+ kfree(flow);
+
+ return ERR_PTR(err);
+}
+
+static struct ice_esw_br_fdb_entry *
+ice_eswitch_br_fdb_find(struct ice_esw_br *bridge, const unsigned char *mac,
+ u16 vid)
+{
+ struct ice_esw_br_fdb_data data = {
+ .vid = vid,
+ };
+
+ ether_addr_copy(data.addr, mac);
+ return rhashtable_lookup_fast(&bridge->fdb_ht, &data,
+ ice_fdb_ht_params);
+}
+
+static void
+ice_eswitch_br_flow_delete(struct ice_pf *pf, struct ice_esw_br_flow *flow)
+{
+ struct device *dev = ice_pf_to_dev(pf);
+ int err;
+
+ err = ice_eswitch_br_rule_delete(&pf->hw, flow->fwd_rule);
+ if (err)
+ dev_err(dev, "Failed to delete FDB forward rule, err: %d\n",
+ err);
+
+ kfree(flow);
+}
+
+static void
+ice_eswitch_br_fdb_entry_delete(struct ice_esw_br *bridge,
+ struct ice_esw_br_fdb_entry *fdb_entry)
+{
+ struct ice_pf *pf = bridge->br_offloads->pf;
+
+ rhashtable_remove_fast(&bridge->fdb_ht, &fdb_entry->ht_node,
+ ice_fdb_ht_params);
+ list_del(&fdb_entry->list);
+
+ ice_eswitch_br_flow_delete(pf, fdb_entry->flow);
+
+ kfree(fdb_entry);
+}
+
+static void
+ice_eswitch_br_fdb_offload_notify(struct net_device *dev,
+ const unsigned char *mac, u16 vid,
+ unsigned long val)
+{
+ struct switchdev_notifier_fdb_info fdb_info = {
+ .addr = mac,
+ .vid = vid,
+ .offloaded = true,
+ };
+
+ call_switchdev_notifiers(val, dev, &fdb_info.info, NULL);
+}
+
+static void
+ice_eswitch_br_fdb_entry_notify_and_cleanup(struct ice_esw_br *bridge,
+ struct ice_esw_br_fdb_entry *entry)
+{
+ if (!(entry->flags & ICE_ESWITCH_BR_FDB_ADDED_BY_USER))
+ ice_eswitch_br_fdb_offload_notify(entry->dev, entry->data.addr,
+ entry->data.vid,
+ SWITCHDEV_FDB_DEL_TO_BRIDGE);
+ ice_eswitch_br_fdb_entry_delete(bridge, entry);
+}
+
+static void
+ice_eswitch_br_fdb_entry_find_and_delete(struct ice_esw_br *bridge,
+ const unsigned char *mac, u16 vid)
+{
+ struct ice_pf *pf = bridge->br_offloads->pf;
+ struct ice_esw_br_fdb_entry *fdb_entry;
+ struct device *dev = ice_pf_to_dev(pf);
+
+ fdb_entry = ice_eswitch_br_fdb_find(bridge, mac, vid);
+ if (!fdb_entry) {
+ dev_err(dev, "FDB entry with mac: %pM and vid: %u not found\n",
+ mac, vid);
+ return;
+ }
+
+ ice_eswitch_br_fdb_entry_notify_and_cleanup(bridge, fdb_entry);
+}
+
+static void
+ice_eswitch_br_fdb_entry_create(struct net_device *netdev,
+ struct ice_esw_br_port *br_port,
+ bool added_by_user,
+ const unsigned char *mac, u16 vid)
+{
+ struct ice_esw_br *bridge = br_port->bridge;
+ struct ice_pf *pf = bridge->br_offloads->pf;
+ struct device *dev = ice_pf_to_dev(pf);
+ struct ice_esw_br_fdb_entry *fdb_entry;
+ struct ice_esw_br_flow *flow;
+ struct ice_hw *hw = &pf->hw;
+ unsigned long event;
+ int err;
+
+ fdb_entry = ice_eswitch_br_fdb_find(bridge, mac, vid);
+ if (fdb_entry)
+ ice_eswitch_br_fdb_entry_notify_and_cleanup(bridge, fdb_entry);
+
+ fdb_entry = kzalloc(sizeof(*fdb_entry), GFP_KERNEL);
+ if (!fdb_entry) {
+ err = -ENOMEM;
+ goto err_exit;
+ }
+
+ flow = ice_eswitch_br_flow_create(dev, hw, br_port->vsi_idx,
+ br_port->type, mac);
+ if (IS_ERR(flow)) {
+ err = PTR_ERR(flow);
+ goto err_add_flow;
+ }
+
+ ether_addr_copy(fdb_entry->data.addr, mac);
+ fdb_entry->data.vid = vid;
+ fdb_entry->br_port = br_port;
+ fdb_entry->flow = flow;
+ fdb_entry->dev = netdev;
+ event = SWITCHDEV_FDB_ADD_TO_BRIDGE;
+
+ if (added_by_user) {
+ fdb_entry->flags |= ICE_ESWITCH_BR_FDB_ADDED_BY_USER;
+ event = SWITCHDEV_FDB_OFFLOADED;
+ }
+
+ err = rhashtable_insert_fast(&bridge->fdb_ht, &fdb_entry->ht_node,
+ ice_fdb_ht_params);
+ if (err)
+ goto err_fdb_insert;
+
+ list_add(&fdb_entry->list, &bridge->fdb_list);
+
+ ice_eswitch_br_fdb_offload_notify(netdev, mac, vid, event);
+
+ return;
+
+err_fdb_insert:
+ ice_eswitch_br_flow_delete(pf, flow);
+err_add_flow:
+ kfree(fdb_entry);
+err_exit:
+ dev_err(dev, "Failed to create fdb entry, err: %d\n", err);
+}
+
+static void
+ice_eswitch_br_fdb_work_dealloc(struct ice_esw_br_fdb_work *fdb_work)
+{
+ kfree(fdb_work->fdb_info.addr);
+ kfree(fdb_work);
+}
+
+static void
+ice_eswitch_br_fdb_event_work(struct work_struct *work)
+{
+ struct ice_esw_br_fdb_work *fdb_work = ice_work_to_fdb_work(work);
+ bool added_by_user = fdb_work->fdb_info.added_by_user;
+ struct ice_esw_br_port *br_port = fdb_work->br_port;
+ const unsigned char *mac = fdb_work->fdb_info.addr;
+ u16 vid = fdb_work->fdb_info.vid;
+
+ rtnl_lock();
+
+ if (!br_port || !br_port->bridge)
+ goto err_exit;
+
+ switch (fdb_work->event) {
+ case SWITCHDEV_FDB_ADD_TO_DEVICE:
+ ice_eswitch_br_fdb_entry_create(fdb_work->dev, br_port,
+ added_by_user, mac, vid);
+ break;
+ case SWITCHDEV_FDB_DEL_TO_DEVICE:
+ ice_eswitch_br_fdb_entry_find_and_delete(br_port->bridge,
+ mac, vid);
+ break;
+ default:
+ goto err_exit;
+ }
+
+err_exit:
+ rtnl_unlock();
+ dev_put(fdb_work->dev);
+ ice_eswitch_br_fdb_work_dealloc(fdb_work);
+}
+
+static struct ice_esw_br_fdb_work *
+ice_eswitch_br_fdb_work_alloc(struct switchdev_notifier_fdb_info *fdb_info,
+ struct ice_esw_br_port *br_port,
+ struct net_device *dev,
+ unsigned long event)
+{
+ struct ice_esw_br_fdb_work *work;
+ unsigned char *mac;
+
+ work = kzalloc(sizeof(*work), GFP_ATOMIC);
+ if (!work)
+ return ERR_PTR(-ENOMEM);
+
+ INIT_WORK(&work->work, ice_eswitch_br_fdb_event_work);
+ memcpy(&work->fdb_info, fdb_info, sizeof(work->fdb_info));
+
+ mac = kzalloc(ETH_ALEN, GFP_ATOMIC);
+ if (!mac) {
+ kfree(work);
+ return ERR_PTR(-ENOMEM);
+ }
+
+ ether_addr_copy(mac, fdb_info->addr);
+ work->fdb_info.addr = mac;
+ work->br_port = br_port;
+ work->event = event;
+ work->dev = dev;
+
+ return work;
+}
+
+static int
+ice_eswitch_br_switchdev_event(struct notifier_block *nb,
+ unsigned long event, void *ptr)
+{
+ struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
+ struct switchdev_notifier_fdb_info *fdb_info;
+ struct switchdev_notifier_info *info = ptr;
+ struct ice_esw_br_offloads *br_offloads;
+ struct ice_esw_br_fdb_work *work;
+ struct ice_esw_br_port *br_port;
+ struct netlink_ext_ack *extack;
+ struct net_device *upper;
+
+ br_offloads = ice_nb_to_br_offloads(nb, switchdev_nb);
+ extack = switchdev_notifier_info_to_extack(ptr);
+
+ upper = netdev_master_upper_dev_get_rcu(dev);
+ if (!upper)
+ return NOTIFY_DONE;
+
+ if (!netif_is_bridge_master(upper))
+ return NOTIFY_DONE;
+
+ if (!ice_eswitch_br_is_dev_valid(dev))
+ return NOTIFY_DONE;
+
+ br_port = ice_eswitch_br_netdev_to_port(dev);
+ if (!br_port)
+ return NOTIFY_DONE;
+
+ switch (event) {
+ case SWITCHDEV_FDB_ADD_TO_DEVICE:
+ case SWITCHDEV_FDB_DEL_TO_DEVICE:
+ fdb_info = container_of(info, typeof(*fdb_info), info);
+
+ work = ice_eswitch_br_fdb_work_alloc(fdb_info, br_port, dev,
+ event);
+ if (IS_ERR(work)) {
+ NL_SET_ERR_MSG_MOD(extack, "Failed to init switchdev fdb work");
+ return notifier_from_errno(PTR_ERR(work));
+ }
+ dev_hold(dev);
+
+ queue_work(br_offloads->wq, &work->work);
+ break;
+ default:
+ break;
+ }
+ return NOTIFY_DONE;
+}
+
static void
ice_eswitch_br_port_deinit(struct ice_esw_br *bridge,
struct ice_esw_br_port *br_port)
{
+ struct ice_esw_br_fdb_entry *fdb_entry, *tmp;
struct ice_vsi *vsi = br_port->vsi;
+ list_for_each_entry_safe(fdb_entry, tmp, &bridge->fdb_list, list) {
+ if (br_port == fdb_entry->br_port)
+ ice_eswitch_br_fdb_entry_delete(bridge, fdb_entry);
+ }
+
if (br_port->type == ICE_ESWITCH_BR_UPLINK_PORT && vsi->back)
vsi->back->br_port = NULL;
- else if (vsi->vf)
+ else if (vsi->vf && vsi->vf->repr)
vsi->vf->repr->br_port = NULL;
xa_erase(&bridge->ports, br_port->vsi_idx);
@@ -129,6 +534,8 @@ ice_eswitch_br_deinit(struct ice_esw_br_offloads *br_offloads,
ice_eswitch_br_ports_flush(bridge);
WARN_ON(!xa_empty(&bridge->ports));
xa_destroy(&bridge->ports);
+ rhashtable_destroy(&bridge->fdb_ht);
+
br_offloads->bridge = NULL;
kfree(bridge);
}
@@ -137,11 +544,19 @@ static struct ice_esw_br *
ice_eswitch_br_init(struct ice_esw_br_offloads *br_offloads, int ifindex)
{
struct ice_esw_br *bridge;
+ int err;
bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
if (!bridge)
return ERR_PTR(-ENOMEM);
+ err = rhashtable_init(&bridge->fdb_ht, &ice_fdb_ht_params);
+ if (err) {
+ kfree(bridge);
+ return ERR_PTR(err);
+ }
+
+ INIT_LIST_HEAD(&bridge->fdb_list);
bridge->br_offloads = br_offloads;
bridge->ifindex = ifindex;
xa_init(&bridge->ports);
@@ -340,6 +755,8 @@ ice_eswitch_br_offloads_deinit(struct ice_pf *pf)
return;
unregister_netdevice_notifier(&br_offloads->netdev_nb);
+ unregister_switchdev_notifier(&br_offloads->switchdev_nb);
+ destroy_workqueue(br_offloads->wq);
/* Although notifier block is unregistered just before,
* so we don't get any new events, some events might be
* already in progress. Hold the rtnl lock and wait for
@@ -365,6 +782,22 @@ ice_eswitch_br_offloads_init(struct ice_pf *pf)
return PTR_ERR(br_offloads);
}
+ br_offloads->wq = alloc_ordered_workqueue("ice_bridge_wq", 0);
+ if (!br_offloads->wq) {
+ err = -ENOMEM;
+ dev_err(dev, "Failed to allocate bridge workqueue\n");
+ goto err_alloc_wq;
+ }
+
+ br_offloads->switchdev_nb.notifier_call =
+ ice_eswitch_br_switchdev_event;
+ err = register_switchdev_notifier(&br_offloads->switchdev_nb);
+ if (err) {
+ dev_err(dev,
+ "Failed to register switchdev notifier\n");
+ goto err_reg_switchdev_nb;
+ }
+
br_offloads->netdev_nb.notifier_call = ice_eswitch_br_port_event;
err = register_netdevice_notifier(&br_offloads->netdev_nb);
if (err) {
@@ -376,6 +809,10 @@ ice_eswitch_br_offloads_init(struct ice_pf *pf)
return 0;
err_reg_netdev_nb:
+ unregister_switchdev_notifier(&br_offloads->switchdev_nb);
+err_reg_switchdev_nb:
+ destroy_workqueue(br_offloads->wq);
+err_alloc_wq:
rtnl_lock();
ice_eswitch_br_offloads_dealloc(pf);
rtnl_unlock();
diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch_br.h b/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
index 3ad28a17298f..6fcacf545b98 100644
--- a/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
+++ b/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
@@ -4,6 +4,33 @@
#ifndef _ICE_ESWITCH_BR_H_
#define _ICE_ESWITCH_BR_H_
+#include <linux/rhashtable.h>
+
+struct ice_esw_br_fdb_data {
+ unsigned char addr[ETH_ALEN];
+ u16 vid;
+};
+
+struct ice_esw_br_flow {
+ struct ice_rule_query_data *fwd_rule;
+};
+
+enum {
+ ICE_ESWITCH_BR_FDB_ADDED_BY_USER = BIT(0),
+};
+
+struct ice_esw_br_fdb_entry {
+ struct ice_esw_br_fdb_data data;
+ struct rhash_head ht_node;
+ struct list_head list;
+
+ int flags;
+
+ struct net_device *dev;
+ struct ice_esw_br_port *br_port;
+ struct ice_esw_br_flow *flow;
+};
+
enum ice_esw_br_port_type {
ICE_ESWITCH_BR_UPLINK_PORT = 0,
ICE_ESWITCH_BR_VF_REPR_PORT = 1,
@@ -20,6 +47,9 @@ struct ice_esw_br {
struct ice_esw_br_offloads *br_offloads;
struct xarray ports;
+ struct rhashtable fdb_ht;
+ struct list_head fdb_list;
+
int ifindex;
};
@@ -27,6 +57,17 @@ struct ice_esw_br_offloads {
struct ice_pf *pf;
struct ice_esw_br *bridge;
struct notifier_block netdev_nb;
+ struct notifier_block switchdev_nb;
+
+ struct workqueue_struct *wq;
+};
+
+struct ice_esw_br_fdb_work {
+ struct work_struct work;
+ struct switchdev_notifier_fdb_info fdb_info;
+ struct ice_esw_br_port *br_port;
+ struct net_device *dev;
+ unsigned long event;
};
#define ice_nb_to_br_offloads(nb, nb_name) \
@@ -34,6 +75,11 @@ struct ice_esw_br_offloads {
struct ice_esw_br_offloads, \
nb_name)
+#define ice_work_to_fdb_work(w) \
+ container_of(w, \
+ struct ice_esw_br_fdb_work, \
+ work)
+
void
ice_eswitch_br_offloads_deinit(struct ice_pf *pf);
int
--
2.38.1
^ permalink raw reply related [flat|nested] 29+ messages in thread* Re: [PATCH net-next 07/12] ice: Switchdev FDB events support
2023-06-20 17:44 ` [PATCH net-next 07/12] ice: Switchdev FDB events support Tony Nguyen
@ 2023-06-21 13:55 ` Simon Horman
2023-06-22 11:53 ` Vlad Buslov
1 sibling, 0 replies; 29+ messages in thread
From: Simon Horman @ 2023-06-21 13:55 UTC (permalink / raw)
To: Tony Nguyen
Cc: davem, kuba, pabeni, edumazet, netdev, Wojciech Drewek, jiri,
ivecera, Sujai Buvaneswaran
On Tue, Jun 20, 2023 at 10:44:18AM -0700, Tony Nguyen wrote:
> From: Wojciech Drewek <wojciech.drewek@intel.com>
>
> Listen for SWITCHDEV_FDB_{ADD|DEL}_TO_DEVICE events while in switchdev
> mode. Accept these events on both uplink and VF PR ports. Add HW
> rules in newly created workqueue. FDB entries are stored in rhashtable
> for lookup when removing the entry and in the list for cleanup
> purpose. Direction of the HW rule depends on the type of the ports
> on which the FDB event was received:
>
> ICE_ESWITCH_BR_UPLINK_PORT:
> TX rule that forwards the packet to the LAN (egress).
>
> ICE_ESWITCH_BR_VF_REPR_PORT:
> RX rule that forwards the packet to the VF associated
> with the port representor.
>
> In both cases the rule matches on the dst mac address.
> All the FDB entries are stored in the bridge structure.
> When the port is removed all the FDB entries associated with
> this port are removed as well. This is achieved thanks to the reference
> to the port that FDB entry holds.
>
> In the fwd rule we use only one lookup type (MAC address)
> but lkups_cnt variable is already introduced because
> we will have more lookups in the subsequent patches.
>
> Signed-off-by: Wojciech Drewek <wojciech.drewek@intel.com>
> Tested-by: Sujai Buvaneswaran <sujai.buvaneswaran@intel.com>
> Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
Reviewed-by: Simon Horman <simon.horman@corigine.com>
^ permalink raw reply [flat|nested] 29+ messages in thread* Re: [PATCH net-next 07/12] ice: Switchdev FDB events support
2023-06-20 17:44 ` [PATCH net-next 07/12] ice: Switchdev FDB events support Tony Nguyen
2023-06-21 13:55 ` Simon Horman
@ 2023-06-22 11:53 ` Vlad Buslov
2023-06-22 12:55 ` Drewek, Wojciech
1 sibling, 1 reply; 29+ messages in thread
From: Vlad Buslov @ 2023-06-22 11:53 UTC (permalink / raw)
To: Tony Nguyen
Cc: davem, kuba, pabeni, edumazet, netdev, Wojciech Drewek, jiri,
ivecera, simon.horman, Sujai Buvaneswaran
On Tue 20 Jun 2023 at 10:44, Tony Nguyen <anthony.l.nguyen@intel.com> wrote:
> From: Wojciech Drewek <wojciech.drewek@intel.com>
>
> Listen for SWITCHDEV_FDB_{ADD|DEL}_TO_DEVICE events while in switchdev
> mode. Accept these events on both uplink and VF PR ports. Add HW
> rules in newly created workqueue. FDB entries are stored in rhashtable
> for lookup when removing the entry and in the list for cleanup
> purpose. Direction of the HW rule depends on the type of the ports
> on which the FDB event was received:
>
> ICE_ESWITCH_BR_UPLINK_PORT:
> TX rule that forwards the packet to the LAN (egress).
>
> ICE_ESWITCH_BR_VF_REPR_PORT:
> RX rule that forwards the packet to the VF associated
> with the port representor.
Just to clarify, does this implementation support offloading of VF-to-VF
traffic?
>
> In both cases the rule matches on the dst mac address.
> All the FDB entries are stored in the bridge structure.
> When the port is removed all the FDB entries associated with
> this port are removed as well. This is achieved thanks to the reference
> to the port that FDB entry holds.
>
> In the fwd rule we use only one lookup type (MAC address)
> but lkups_cnt variable is already introduced because
> we will have more lookups in the subsequent patches.
>
> Signed-off-by: Wojciech Drewek <wojciech.drewek@intel.com>
> Tested-by: Sujai Buvaneswaran <sujai.buvaneswaran@intel.com>
> Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
> ---
> .../net/ethernet/intel/ice/ice_eswitch_br.c | 439 +++++++++++++++++-
> .../net/ethernet/intel/ice/ice_eswitch_br.h | 46 ++
> 2 files changed, 484 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch_br.c b/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
> index 8b9ab68dfd53..8f22da490a69 100644
> --- a/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
> +++ b/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
> @@ -4,6 +4,14 @@
> #include "ice.h"
> #include "ice_eswitch_br.h"
> #include "ice_repr.h"
> +#include "ice_switch.h"
> +
> +static const struct rhashtable_params ice_fdb_ht_params = {
> + .key_offset = offsetof(struct ice_esw_br_fdb_entry, data),
> + .key_len = sizeof(struct ice_esw_br_fdb_data),
> + .head_offset = offsetof(struct ice_esw_br_fdb_entry, ht_node),
> + .automatic_shrinking = true,
> +};
>
> static bool ice_eswitch_br_is_dev_valid(const struct net_device *dev)
> {
> @@ -27,15 +35,412 @@ ice_eswitch_br_netdev_to_port(struct net_device *dev)
> return NULL;
> }
>
> +static void
> +ice_eswitch_br_ingress_rule_setup(struct ice_adv_rule_info *rule_info,
> + u8 pf_id, u16 vf_vsi_idx)
> +{
> + rule_info->sw_act.vsi_handle = vf_vsi_idx;
> + rule_info->sw_act.flag |= ICE_FLTR_RX;
> + rule_info->sw_act.src = pf_id;
> + rule_info->priority = 5;
> +}
> +
> +static void
> +ice_eswitch_br_egress_rule_setup(struct ice_adv_rule_info *rule_info,
> + u16 pf_vsi_idx)
> +{
> + rule_info->sw_act.vsi_handle = pf_vsi_idx;
> + rule_info->sw_act.flag |= ICE_FLTR_TX;
> + rule_info->flags_info.act = ICE_SINGLE_ACT_LAN_ENABLE;
> + rule_info->flags_info.act_valid = true;
> + rule_info->priority = 5;
> +}
> +
> +static int
> +ice_eswitch_br_rule_delete(struct ice_hw *hw, struct ice_rule_query_data *rule)
> +{
> + int err;
> +
> + if (!rule)
> + return -EINVAL;
> +
> + err = ice_rem_adv_rule_by_id(hw, rule);
> + kfree(rule);
> +
> + return err;
> +}
> +
> +static struct ice_rule_query_data *
> +ice_eswitch_br_fwd_rule_create(struct ice_hw *hw, int vsi_idx, int port_type,
> + const unsigned char *mac)
> +{
> + struct ice_adv_rule_info rule_info = { 0 };
> + struct ice_rule_query_data *rule;
> + struct ice_adv_lkup_elem *list;
> + u16 lkups_cnt = 1;
> + int err;
> +
> + rule = kzalloc(sizeof(*rule), GFP_KERNEL);
> + if (!rule)
> + return ERR_PTR(-ENOMEM);
> +
> + list = kcalloc(lkups_cnt, sizeof(*list), GFP_ATOMIC);
> + if (!list) {
> + err = -ENOMEM;
> + goto err_list_alloc;
> + }
> +
> + switch (port_type) {
> + case ICE_ESWITCH_BR_UPLINK_PORT:
> + ice_eswitch_br_egress_rule_setup(&rule_info, vsi_idx);
> + break;
> + case ICE_ESWITCH_BR_VF_REPR_PORT:
> + ice_eswitch_br_ingress_rule_setup(&rule_info, hw->pf_id,
> + vsi_idx);
> + break;
> + default:
> + err = -EINVAL;
> + goto err_add_rule;
> + }
> +
> + list[0].type = ICE_MAC_OFOS;
> + ether_addr_copy(list[0].h_u.eth_hdr.dst_addr, mac);
> + eth_broadcast_addr(list[0].m_u.eth_hdr.dst_addr);
> +
> + rule_info.sw_act.fltr_act = ICE_FWD_TO_VSI;
> +
> + err = ice_add_adv_rule(hw, list, lkups_cnt, &rule_info, rule);
> + if (err)
> + goto err_add_rule;
> +
> + kfree(list);
> +
> + return rule;
> +
> +err_add_rule:
> + kfree(list);
> +err_list_alloc:
> + kfree(rule);
> +
> + return ERR_PTR(err);
> +}
> +
> +static struct ice_esw_br_flow *
> +ice_eswitch_br_flow_create(struct device *dev, struct ice_hw *hw, int vsi_idx,
> + int port_type, const unsigned char *mac)
> +{
> + struct ice_rule_query_data *fwd_rule;
> + struct ice_esw_br_flow *flow;
> + int err;
> +
> + flow = kzalloc(sizeof(*flow), GFP_KERNEL);
> + if (!flow)
> + return ERR_PTR(-ENOMEM);
> +
> + fwd_rule = ice_eswitch_br_fwd_rule_create(hw, vsi_idx, port_type, mac);
> + err = PTR_ERR_OR_ZERO(fwd_rule);
> + if (err) {
> + dev_err(dev, "Failed to create eswitch bridge %sgress forward rule, err: %d\n",
> + port_type == ICE_ESWITCH_BR_UPLINK_PORT ? "e" : "in",
> + err);
> + goto err_fwd_rule;
> + }
> +
> + flow->fwd_rule = fwd_rule;
> +
> + return flow;
> +
> +err_fwd_rule:
> + kfree(flow);
> +
> + return ERR_PTR(err);
> +}
> +
> +static struct ice_esw_br_fdb_entry *
> +ice_eswitch_br_fdb_find(struct ice_esw_br *bridge, const unsigned char *mac,
> + u16 vid)
> +{
> + struct ice_esw_br_fdb_data data = {
> + .vid = vid,
> + };
> +
> + ether_addr_copy(data.addr, mac);
> + return rhashtable_lookup_fast(&bridge->fdb_ht, &data,
> + ice_fdb_ht_params);
> +}
> +
> +static void
> +ice_eswitch_br_flow_delete(struct ice_pf *pf, struct ice_esw_br_flow *flow)
> +{
> + struct device *dev = ice_pf_to_dev(pf);
> + int err;
> +
> + err = ice_eswitch_br_rule_delete(&pf->hw, flow->fwd_rule);
> + if (err)
> + dev_err(dev, "Failed to delete FDB forward rule, err: %d\n",
> + err);
> +
> + kfree(flow);
> +}
> +
> +static void
> +ice_eswitch_br_fdb_entry_delete(struct ice_esw_br *bridge,
> + struct ice_esw_br_fdb_entry *fdb_entry)
> +{
> + struct ice_pf *pf = bridge->br_offloads->pf;
> +
> + rhashtable_remove_fast(&bridge->fdb_ht, &fdb_entry->ht_node,
> + ice_fdb_ht_params);
> + list_del(&fdb_entry->list);
> +
> + ice_eswitch_br_flow_delete(pf, fdb_entry->flow);
> +
> + kfree(fdb_entry);
> +}
> +
> +static void
> +ice_eswitch_br_fdb_offload_notify(struct net_device *dev,
> + const unsigned char *mac, u16 vid,
> + unsigned long val)
> +{
> + struct switchdev_notifier_fdb_info fdb_info = {
> + .addr = mac,
> + .vid = vid,
> + .offloaded = true,
> + };
> +
> + call_switchdev_notifiers(val, dev, &fdb_info.info, NULL);
> +}
> +
> +static void
> +ice_eswitch_br_fdb_entry_notify_and_cleanup(struct ice_esw_br *bridge,
> + struct ice_esw_br_fdb_entry *entry)
> +{
> + if (!(entry->flags & ICE_ESWITCH_BR_FDB_ADDED_BY_USER))
> + ice_eswitch_br_fdb_offload_notify(entry->dev, entry->data.addr,
> + entry->data.vid,
> + SWITCHDEV_FDB_DEL_TO_BRIDGE);
> + ice_eswitch_br_fdb_entry_delete(bridge, entry);
> +}
> +
> +static void
> +ice_eswitch_br_fdb_entry_find_and_delete(struct ice_esw_br *bridge,
> + const unsigned char *mac, u16 vid)
> +{
> + struct ice_pf *pf = bridge->br_offloads->pf;
> + struct ice_esw_br_fdb_entry *fdb_entry;
> + struct device *dev = ice_pf_to_dev(pf);
> +
> + fdb_entry = ice_eswitch_br_fdb_find(bridge, mac, vid);
> + if (!fdb_entry) {
> + dev_err(dev, "FDB entry with mac: %pM and vid: %u not found\n",
> + mac, vid);
> + return;
> + }
> +
> + ice_eswitch_br_fdb_entry_notify_and_cleanup(bridge, fdb_entry);
> +}
> +
> +static void
> +ice_eswitch_br_fdb_entry_create(struct net_device *netdev,
> + struct ice_esw_br_port *br_port,
> + bool added_by_user,
> + const unsigned char *mac, u16 vid)
> +{
> + struct ice_esw_br *bridge = br_port->bridge;
> + struct ice_pf *pf = bridge->br_offloads->pf;
> + struct device *dev = ice_pf_to_dev(pf);
> + struct ice_esw_br_fdb_entry *fdb_entry;
> + struct ice_esw_br_flow *flow;
> + struct ice_hw *hw = &pf->hw;
> + unsigned long event;
> + int err;
> +
> + fdb_entry = ice_eswitch_br_fdb_find(bridge, mac, vid);
> + if (fdb_entry)
> + ice_eswitch_br_fdb_entry_notify_and_cleanup(bridge, fdb_entry);
> +
> + fdb_entry = kzalloc(sizeof(*fdb_entry), GFP_KERNEL);
> + if (!fdb_entry) {
> + err = -ENOMEM;
> + goto err_exit;
> + }
> +
> + flow = ice_eswitch_br_flow_create(dev, hw, br_port->vsi_idx,
> + br_port->type, mac);
> + if (IS_ERR(flow)) {
> + err = PTR_ERR(flow);
> + goto err_add_flow;
> + }
> +
> + ether_addr_copy(fdb_entry->data.addr, mac);
> + fdb_entry->data.vid = vid;
> + fdb_entry->br_port = br_port;
> + fdb_entry->flow = flow;
> + fdb_entry->dev = netdev;
> + event = SWITCHDEV_FDB_ADD_TO_BRIDGE;
> +
> + if (added_by_user) {
> + fdb_entry->flags |= ICE_ESWITCH_BR_FDB_ADDED_BY_USER;
> + event = SWITCHDEV_FDB_OFFLOADED;
> + }
> +
> + err = rhashtable_insert_fast(&bridge->fdb_ht, &fdb_entry->ht_node,
> + ice_fdb_ht_params);
> + if (err)
> + goto err_fdb_insert;
> +
> + list_add(&fdb_entry->list, &bridge->fdb_list);
> +
> + ice_eswitch_br_fdb_offload_notify(netdev, mac, vid, event);
> +
> + return;
> +
> +err_fdb_insert:
> + ice_eswitch_br_flow_delete(pf, flow);
> +err_add_flow:
> + kfree(fdb_entry);
> +err_exit:
> + dev_err(dev, "Failed to create fdb entry, err: %d\n", err);
> +}
> +
> +static void
> +ice_eswitch_br_fdb_work_dealloc(struct ice_esw_br_fdb_work *fdb_work)
> +{
> + kfree(fdb_work->fdb_info.addr);
> + kfree(fdb_work);
> +}
> +
> +static void
> +ice_eswitch_br_fdb_event_work(struct work_struct *work)
> +{
> + struct ice_esw_br_fdb_work *fdb_work = ice_work_to_fdb_work(work);
> + bool added_by_user = fdb_work->fdb_info.added_by_user;
> + struct ice_esw_br_port *br_port = fdb_work->br_port;
> + const unsigned char *mac = fdb_work->fdb_info.addr;
> + u16 vid = fdb_work->fdb_info.vid;
> +
> + rtnl_lock();
> +
> + if (!br_port || !br_port->bridge)
> + goto err_exit;
> +
> + switch (fdb_work->event) {
> + case SWITCHDEV_FDB_ADD_TO_DEVICE:
> + ice_eswitch_br_fdb_entry_create(fdb_work->dev, br_port,
> + added_by_user, mac, vid);
> + break;
> + case SWITCHDEV_FDB_DEL_TO_DEVICE:
> + ice_eswitch_br_fdb_entry_find_and_delete(br_port->bridge,
> + mac, vid);
> + break;
> + default:
> + goto err_exit;
> + }
> +
> +err_exit:
> + rtnl_unlock();
> + dev_put(fdb_work->dev);
> + ice_eswitch_br_fdb_work_dealloc(fdb_work);
> +}
> +
> +static struct ice_esw_br_fdb_work *
> +ice_eswitch_br_fdb_work_alloc(struct switchdev_notifier_fdb_info *fdb_info,
> + struct ice_esw_br_port *br_port,
> + struct net_device *dev,
> + unsigned long event)
> +{
> + struct ice_esw_br_fdb_work *work;
> + unsigned char *mac;
> +
> + work = kzalloc(sizeof(*work), GFP_ATOMIC);
> + if (!work)
> + return ERR_PTR(-ENOMEM);
> +
> + INIT_WORK(&work->work, ice_eswitch_br_fdb_event_work);
> + memcpy(&work->fdb_info, fdb_info, sizeof(work->fdb_info));
> +
> + mac = kzalloc(ETH_ALEN, GFP_ATOMIC);
> + if (!mac) {
> + kfree(work);
> + return ERR_PTR(-ENOMEM);
> + }
> +
> + ether_addr_copy(mac, fdb_info->addr);
> + work->fdb_info.addr = mac;
> + work->br_port = br_port;
> + work->event = event;
> + work->dev = dev;
> +
> + return work;
> +}
> +
> +static int
> +ice_eswitch_br_switchdev_event(struct notifier_block *nb,
> + unsigned long event, void *ptr)
> +{
> + struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
> + struct switchdev_notifier_fdb_info *fdb_info;
> + struct switchdev_notifier_info *info = ptr;
> + struct ice_esw_br_offloads *br_offloads;
> + struct ice_esw_br_fdb_work *work;
> + struct ice_esw_br_port *br_port;
> + struct netlink_ext_ack *extack;
> + struct net_device *upper;
> +
> + br_offloads = ice_nb_to_br_offloads(nb, switchdev_nb);
> + extack = switchdev_notifier_info_to_extack(ptr);
> +
> + upper = netdev_master_upper_dev_get_rcu(dev);
> + if (!upper)
> + return NOTIFY_DONE;
> +
> + if (!netif_is_bridge_master(upper))
> + return NOTIFY_DONE;
> +
> + if (!ice_eswitch_br_is_dev_valid(dev))
> + return NOTIFY_DONE;
> +
> + br_port = ice_eswitch_br_netdev_to_port(dev);
> + if (!br_port)
> + return NOTIFY_DONE;
> +
> + switch (event) {
> + case SWITCHDEV_FDB_ADD_TO_DEVICE:
> + case SWITCHDEV_FDB_DEL_TO_DEVICE:
> + fdb_info = container_of(info, typeof(*fdb_info), info);
> +
> + work = ice_eswitch_br_fdb_work_alloc(fdb_info, br_port, dev,
> + event);
> + if (IS_ERR(work)) {
> + NL_SET_ERR_MSG_MOD(extack, "Failed to init switchdev fdb work");
> + return notifier_from_errno(PTR_ERR(work));
> + }
> + dev_hold(dev);
> +
> + queue_work(br_offloads->wq, &work->work);
> + break;
> + default:
> + break;
> + }
> + return NOTIFY_DONE;
> +}
> +
> static void
> ice_eswitch_br_port_deinit(struct ice_esw_br *bridge,
> struct ice_esw_br_port *br_port)
> {
> + struct ice_esw_br_fdb_entry *fdb_entry, *tmp;
> struct ice_vsi *vsi = br_port->vsi;
>
> + list_for_each_entry_safe(fdb_entry, tmp, &bridge->fdb_list, list) {
> + if (br_port == fdb_entry->br_port)
> + ice_eswitch_br_fdb_entry_delete(bridge, fdb_entry);
> + }
> +
> if (br_port->type == ICE_ESWITCH_BR_UPLINK_PORT && vsi->back)
> vsi->back->br_port = NULL;
> - else if (vsi->vf)
> + else if (vsi->vf && vsi->vf->repr)
Shouldn't this check be in the previous patch? Don't see anything that
would influence this pointer assignment in this patch.
> vsi->vf->repr->br_port = NULL;
>
> xa_erase(&bridge->ports, br_port->vsi_idx);
> @@ -129,6 +534,8 @@ ice_eswitch_br_deinit(struct ice_esw_br_offloads *br_offloads,
> ice_eswitch_br_ports_flush(bridge);
> WARN_ON(!xa_empty(&bridge->ports));
> xa_destroy(&bridge->ports);
> + rhashtable_destroy(&bridge->fdb_ht);
> +
> br_offloads->bridge = NULL;
> kfree(bridge);
> }
> @@ -137,11 +544,19 @@ static struct ice_esw_br *
> ice_eswitch_br_init(struct ice_esw_br_offloads *br_offloads, int ifindex)
> {
> struct ice_esw_br *bridge;
> + int err;
>
> bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
> if (!bridge)
> return ERR_PTR(-ENOMEM);
>
> + err = rhashtable_init(&bridge->fdb_ht, &ice_fdb_ht_params);
> + if (err) {
> + kfree(bridge);
> + return ERR_PTR(err);
> + }
> +
> + INIT_LIST_HEAD(&bridge->fdb_list);
> bridge->br_offloads = br_offloads;
> bridge->ifindex = ifindex;
> xa_init(&bridge->ports);
> @@ -340,6 +755,8 @@ ice_eswitch_br_offloads_deinit(struct ice_pf *pf)
> return;
>
> unregister_netdevice_notifier(&br_offloads->netdev_nb);
> + unregister_switchdev_notifier(&br_offloads->switchdev_nb);
> + destroy_workqueue(br_offloads->wq);
> /* Although notifier block is unregistered just before,
> * so we don't get any new events, some events might be
> * already in progress. Hold the rtnl lock and wait for
> @@ -365,6 +782,22 @@ ice_eswitch_br_offloads_init(struct ice_pf *pf)
> return PTR_ERR(br_offloads);
> }
>
> + br_offloads->wq = alloc_ordered_workqueue("ice_bridge_wq", 0);
> + if (!br_offloads->wq) {
> + err = -ENOMEM;
> + dev_err(dev, "Failed to allocate bridge workqueue\n");
> + goto err_alloc_wq;
> + }
> +
> + br_offloads->switchdev_nb.notifier_call =
> + ice_eswitch_br_switchdev_event;
> + err = register_switchdev_notifier(&br_offloads->switchdev_nb);
> + if (err) {
> + dev_err(dev,
> + "Failed to register switchdev notifier\n");
> + goto err_reg_switchdev_nb;
> + }
> +
> br_offloads->netdev_nb.notifier_call = ice_eswitch_br_port_event;
> err = register_netdevice_notifier(&br_offloads->netdev_nb);
> if (err) {
> @@ -376,6 +809,10 @@ ice_eswitch_br_offloads_init(struct ice_pf *pf)
> return 0;
>
> err_reg_netdev_nb:
> + unregister_switchdev_notifier(&br_offloads->switchdev_nb);
> +err_reg_switchdev_nb:
> + destroy_workqueue(br_offloads->wq);
> +err_alloc_wq:
> rtnl_lock();
> ice_eswitch_br_offloads_dealloc(pf);
> rtnl_unlock();
> diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch_br.h b/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
> index 3ad28a17298f..6fcacf545b98 100644
> --- a/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
> +++ b/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
> @@ -4,6 +4,33 @@
> #ifndef _ICE_ESWITCH_BR_H_
> #define _ICE_ESWITCH_BR_H_
>
> +#include <linux/rhashtable.h>
> +
> +struct ice_esw_br_fdb_data {
> + unsigned char addr[ETH_ALEN];
> + u16 vid;
> +};
> +
> +struct ice_esw_br_flow {
> + struct ice_rule_query_data *fwd_rule;
> +};
> +
> +enum {
> + ICE_ESWITCH_BR_FDB_ADDED_BY_USER = BIT(0),
> +};
> +
> +struct ice_esw_br_fdb_entry {
> + struct ice_esw_br_fdb_data data;
> + struct rhash_head ht_node;
> + struct list_head list;
> +
> + int flags;
> +
> + struct net_device *dev;
> + struct ice_esw_br_port *br_port;
> + struct ice_esw_br_flow *flow;
> +};
> +
> enum ice_esw_br_port_type {
> ICE_ESWITCH_BR_UPLINK_PORT = 0,
> ICE_ESWITCH_BR_VF_REPR_PORT = 1,
> @@ -20,6 +47,9 @@ struct ice_esw_br {
> struct ice_esw_br_offloads *br_offloads;
> struct xarray ports;
>
> + struct rhashtable fdb_ht;
> + struct list_head fdb_list;
> +
> int ifindex;
> };
>
> @@ -27,6 +57,17 @@ struct ice_esw_br_offloads {
> struct ice_pf *pf;
> struct ice_esw_br *bridge;
> struct notifier_block netdev_nb;
> + struct notifier_block switchdev_nb;
> +
> + struct workqueue_struct *wq;
> +};
> +
> +struct ice_esw_br_fdb_work {
> + struct work_struct work;
> + struct switchdev_notifier_fdb_info fdb_info;
> + struct ice_esw_br_port *br_port;
> + struct net_device *dev;
> + unsigned long event;
> };
>
> #define ice_nb_to_br_offloads(nb, nb_name) \
> @@ -34,6 +75,11 @@ struct ice_esw_br_offloads {
> struct ice_esw_br_offloads, \
> nb_name)
>
> +#define ice_work_to_fdb_work(w) \
> + container_of(w, \
> + struct ice_esw_br_fdb_work, \
> + work)
> +
> void
> ice_eswitch_br_offloads_deinit(struct ice_pf *pf);
> int
^ permalink raw reply [flat|nested] 29+ messages in thread* RE: [PATCH net-next 07/12] ice: Switchdev FDB events support
2023-06-22 11:53 ` Vlad Buslov
@ 2023-06-22 12:55 ` Drewek, Wojciech
0 siblings, 0 replies; 29+ messages in thread
From: Drewek, Wojciech @ 2023-06-22 12:55 UTC (permalink / raw)
To: Vlad Buslov, Nguyen, Anthony L
Cc: davem@davemloft.net, kuba@kernel.org, pabeni@redhat.com,
edumazet@google.com, netdev@vger.kernel.org, jiri@resnulli.us,
ivecera, simon.horman@corigine.com, Buvaneswaran, Sujai
> -----Original Message-----
> From: Vlad Buslov <vladbu@nvidia.com>
> Sent: czwartek, 22 czerwca 2023 13:54
> To: Nguyen, Anthony L <anthony.l.nguyen@intel.com>
> Cc: davem@davemloft.net; kuba@kernel.org; pabeni@redhat.com; edumazet@google.com; netdev@vger.kernel.org; Drewek,
> Wojciech <wojciech.drewek@intel.com>; jiri@resnulli.us; ivecera <ivecera@redhat.com>; simon.horman@corigine.com;
> Buvaneswaran, Sujai <sujai.buvaneswaran@intel.com>
> Subject: Re: [PATCH net-next 07/12] ice: Switchdev FDB events support
>
> On Tue 20 Jun 2023 at 10:44, Tony Nguyen <anthony.l.nguyen@intel.com> wrote:
> > From: Wojciech Drewek <wojciech.drewek@intel.com>
> >
> > Listen for SWITCHDEV_FDB_{ADD|DEL}_TO_DEVICE events while in switchdev
> > mode. Accept these events on both uplink and VF PR ports. Add HW
> > rules in newly created workqueue. FDB entries are stored in rhashtable
> > for lookup when removing the entry and in the list for cleanup
> > purpose. Direction of the HW rule depends on the type of the ports
> > on which the FDB event was received:
> >
> > ICE_ESWITCH_BR_UPLINK_PORT:
> > TX rule that forwards the packet to the LAN (egress).
> >
> > ICE_ESWITCH_BR_VF_REPR_PORT:
> > RX rule that forwards the packet to the VF associated
> > with the port representor.
>
> Just to clarify, does this implementation support offloading of VF-to-VF
> traffic?
Yes
>
> >
> > In both cases the rule matches on the dst mac address.
> > All the FDB entries are stored in the bridge structure.
> > When the port is removed all the FDB entries associated with
> > this port are removed as well. This is achieved thanks to the reference
> > to the port that FDB entry holds.
> >
> > In the fwd rule we use only one lookup type (MAC address)
> > but lkups_cnt variable is already introduced because
> > we will have more lookups in the subsequent patches.
> >
> > Signed-off-by: Wojciech Drewek <wojciech.drewek@intel.com>
> > Tested-by: Sujai Buvaneswaran <sujai.buvaneswaran@intel.com>
> > Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
> > ---
> > .../net/ethernet/intel/ice/ice_eswitch_br.c | 439 +++++++++++++++++-
> > .../net/ethernet/intel/ice/ice_eswitch_br.h | 46 ++
> > 2 files changed, 484 insertions(+), 1 deletion(-)
> >
> > diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch_br.c b/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
> > index 8b9ab68dfd53..8f22da490a69 100644
> > --- a/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
> > +++ b/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
> > @@ -4,6 +4,14 @@
> > #include "ice.h"
> > #include "ice_eswitch_br.h"
> > #include "ice_repr.h"
> > +#include "ice_switch.h"
> > +
> > +static const struct rhashtable_params ice_fdb_ht_params = {
> > + .key_offset = offsetof(struct ice_esw_br_fdb_entry, data),
> > + .key_len = sizeof(struct ice_esw_br_fdb_data),
> > + .head_offset = offsetof(struct ice_esw_br_fdb_entry, ht_node),
> > + .automatic_shrinking = true,
> > +};
> >
> > static bool ice_eswitch_br_is_dev_valid(const struct net_device *dev)
> > {
> > @@ -27,15 +35,412 @@ ice_eswitch_br_netdev_to_port(struct net_device *dev)
> > return NULL;
> > }
> >
> > +static void
> > +ice_eswitch_br_ingress_rule_setup(struct ice_adv_rule_info *rule_info,
> > + u8 pf_id, u16 vf_vsi_idx)
> > +{
> > + rule_info->sw_act.vsi_handle = vf_vsi_idx;
> > + rule_info->sw_act.flag |= ICE_FLTR_RX;
> > + rule_info->sw_act.src = pf_id;
> > + rule_info->priority = 5;
> > +}
> > +
> > +static void
> > +ice_eswitch_br_egress_rule_setup(struct ice_adv_rule_info *rule_info,
> > + u16 pf_vsi_idx)
> > +{
> > + rule_info->sw_act.vsi_handle = pf_vsi_idx;
> > + rule_info->sw_act.flag |= ICE_FLTR_TX;
> > + rule_info->flags_info.act = ICE_SINGLE_ACT_LAN_ENABLE;
> > + rule_info->flags_info.act_valid = true;
> > + rule_info->priority = 5;
> > +}
> > +
> > +static int
> > +ice_eswitch_br_rule_delete(struct ice_hw *hw, struct ice_rule_query_data *rule)
> > +{
> > + int err;
> > +
> > + if (!rule)
> > + return -EINVAL;
> > +
> > + err = ice_rem_adv_rule_by_id(hw, rule);
> > + kfree(rule);
> > +
> > + return err;
> > +}
> > +
> > +static struct ice_rule_query_data *
> > +ice_eswitch_br_fwd_rule_create(struct ice_hw *hw, int vsi_idx, int port_type,
> > + const unsigned char *mac)
> > +{
> > + struct ice_adv_rule_info rule_info = { 0 };
> > + struct ice_rule_query_data *rule;
> > + struct ice_adv_lkup_elem *list;
> > + u16 lkups_cnt = 1;
> > + int err;
> > +
> > + rule = kzalloc(sizeof(*rule), GFP_KERNEL);
> > + if (!rule)
> > + return ERR_PTR(-ENOMEM);
> > +
> > + list = kcalloc(lkups_cnt, sizeof(*list), GFP_ATOMIC);
> > + if (!list) {
> > + err = -ENOMEM;
> > + goto err_list_alloc;
> > + }
> > +
> > + switch (port_type) {
> > + case ICE_ESWITCH_BR_UPLINK_PORT:
> > + ice_eswitch_br_egress_rule_setup(&rule_info, vsi_idx);
> > + break;
> > + case ICE_ESWITCH_BR_VF_REPR_PORT:
> > + ice_eswitch_br_ingress_rule_setup(&rule_info, hw->pf_id,
> > + vsi_idx);
> > + break;
> > + default:
> > + err = -EINVAL;
> > + goto err_add_rule;
> > + }
> > +
> > + list[0].type = ICE_MAC_OFOS;
> > + ether_addr_copy(list[0].h_u.eth_hdr.dst_addr, mac);
> > + eth_broadcast_addr(list[0].m_u.eth_hdr.dst_addr);
> > +
> > + rule_info.sw_act.fltr_act = ICE_FWD_TO_VSI;
> > +
> > + err = ice_add_adv_rule(hw, list, lkups_cnt, &rule_info, rule);
> > + if (err)
> > + goto err_add_rule;
> > +
> > + kfree(list);
> > +
> > + return rule;
> > +
> > +err_add_rule:
> > + kfree(list);
> > +err_list_alloc:
> > + kfree(rule);
> > +
> > + return ERR_PTR(err);
> > +}
> > +
> > +static struct ice_esw_br_flow *
> > +ice_eswitch_br_flow_create(struct device *dev, struct ice_hw *hw, int vsi_idx,
> > + int port_type, const unsigned char *mac)
> > +{
> > + struct ice_rule_query_data *fwd_rule;
> > + struct ice_esw_br_flow *flow;
> > + int err;
> > +
> > + flow = kzalloc(sizeof(*flow), GFP_KERNEL);
> > + if (!flow)
> > + return ERR_PTR(-ENOMEM);
> > +
> > + fwd_rule = ice_eswitch_br_fwd_rule_create(hw, vsi_idx, port_type, mac);
> > + err = PTR_ERR_OR_ZERO(fwd_rule);
> > + if (err) {
> > + dev_err(dev, "Failed to create eswitch bridge %sgress forward rule, err: %d\n",
> > + port_type == ICE_ESWITCH_BR_UPLINK_PORT ? "e" : "in",
> > + err);
> > + goto err_fwd_rule;
> > + }
> > +
> > + flow->fwd_rule = fwd_rule;
> > +
> > + return flow;
> > +
> > +err_fwd_rule:
> > + kfree(flow);
> > +
> > + return ERR_PTR(err);
> > +}
> > +
> > +static struct ice_esw_br_fdb_entry *
> > +ice_eswitch_br_fdb_find(struct ice_esw_br *bridge, const unsigned char *mac,
> > + u16 vid)
> > +{
> > + struct ice_esw_br_fdb_data data = {
> > + .vid = vid,
> > + };
> > +
> > + ether_addr_copy(data.addr, mac);
> > + return rhashtable_lookup_fast(&bridge->fdb_ht, &data,
> > + ice_fdb_ht_params);
> > +}
> > +
> > +static void
> > +ice_eswitch_br_flow_delete(struct ice_pf *pf, struct ice_esw_br_flow *flow)
> > +{
> > + struct device *dev = ice_pf_to_dev(pf);
> > + int err;
> > +
> > + err = ice_eswitch_br_rule_delete(&pf->hw, flow->fwd_rule);
> > + if (err)
> > + dev_err(dev, "Failed to delete FDB forward rule, err: %d\n",
> > + err);
> > +
> > + kfree(flow);
> > +}
> > +
> > +static void
> > +ice_eswitch_br_fdb_entry_delete(struct ice_esw_br *bridge,
> > + struct ice_esw_br_fdb_entry *fdb_entry)
> > +{
> > + struct ice_pf *pf = bridge->br_offloads->pf;
> > +
> > + rhashtable_remove_fast(&bridge->fdb_ht, &fdb_entry->ht_node,
> > + ice_fdb_ht_params);
> > + list_del(&fdb_entry->list);
> > +
> > + ice_eswitch_br_flow_delete(pf, fdb_entry->flow);
> > +
> > + kfree(fdb_entry);
> > +}
> > +
> > +static void
> > +ice_eswitch_br_fdb_offload_notify(struct net_device *dev,
> > + const unsigned char *mac, u16 vid,
> > + unsigned long val)
> > +{
> > + struct switchdev_notifier_fdb_info fdb_info = {
> > + .addr = mac,
> > + .vid = vid,
> > + .offloaded = true,
> > + };
> > +
> > + call_switchdev_notifiers(val, dev, &fdb_info.info, NULL);
> > +}
> > +
> > +static void
> > +ice_eswitch_br_fdb_entry_notify_and_cleanup(struct ice_esw_br *bridge,
> > + struct ice_esw_br_fdb_entry *entry)
> > +{
> > + if (!(entry->flags & ICE_ESWITCH_BR_FDB_ADDED_BY_USER))
> > + ice_eswitch_br_fdb_offload_notify(entry->dev, entry->data.addr,
> > + entry->data.vid,
> > + SWITCHDEV_FDB_DEL_TO_BRIDGE);
> > + ice_eswitch_br_fdb_entry_delete(bridge, entry);
> > +}
> > +
> > +static void
> > +ice_eswitch_br_fdb_entry_find_and_delete(struct ice_esw_br *bridge,
> > + const unsigned char *mac, u16 vid)
> > +{
> > + struct ice_pf *pf = bridge->br_offloads->pf;
> > + struct ice_esw_br_fdb_entry *fdb_entry;
> > + struct device *dev = ice_pf_to_dev(pf);
> > +
> > + fdb_entry = ice_eswitch_br_fdb_find(bridge, mac, vid);
> > + if (!fdb_entry) {
> > + dev_err(dev, "FDB entry with mac: %pM and vid: %u not found\n",
> > + mac, vid);
> > + return;
> > + }
> > +
> > + ice_eswitch_br_fdb_entry_notify_and_cleanup(bridge, fdb_entry);
> > +}
> > +
> > +static void
> > +ice_eswitch_br_fdb_entry_create(struct net_device *netdev,
> > + struct ice_esw_br_port *br_port,
> > + bool added_by_user,
> > + const unsigned char *mac, u16 vid)
> > +{
> > + struct ice_esw_br *bridge = br_port->bridge;
> > + struct ice_pf *pf = bridge->br_offloads->pf;
> > + struct device *dev = ice_pf_to_dev(pf);
> > + struct ice_esw_br_fdb_entry *fdb_entry;
> > + struct ice_esw_br_flow *flow;
> > + struct ice_hw *hw = &pf->hw;
> > + unsigned long event;
> > + int err;
> > +
> > + fdb_entry = ice_eswitch_br_fdb_find(bridge, mac, vid);
> > + if (fdb_entry)
> > + ice_eswitch_br_fdb_entry_notify_and_cleanup(bridge, fdb_entry);
> > +
> > + fdb_entry = kzalloc(sizeof(*fdb_entry), GFP_KERNEL);
> > + if (!fdb_entry) {
> > + err = -ENOMEM;
> > + goto err_exit;
> > + }
> > +
> > + flow = ice_eswitch_br_flow_create(dev, hw, br_port->vsi_idx,
> > + br_port->type, mac);
> > + if (IS_ERR(flow)) {
> > + err = PTR_ERR(flow);
> > + goto err_add_flow;
> > + }
> > +
> > + ether_addr_copy(fdb_entry->data.addr, mac);
> > + fdb_entry->data.vid = vid;
> > + fdb_entry->br_port = br_port;
> > + fdb_entry->flow = flow;
> > + fdb_entry->dev = netdev;
> > + event = SWITCHDEV_FDB_ADD_TO_BRIDGE;
> > +
> > + if (added_by_user) {
> > + fdb_entry->flags |= ICE_ESWITCH_BR_FDB_ADDED_BY_USER;
> > + event = SWITCHDEV_FDB_OFFLOADED;
> > + }
> > +
> > + err = rhashtable_insert_fast(&bridge->fdb_ht, &fdb_entry->ht_node,
> > + ice_fdb_ht_params);
> > + if (err)
> > + goto err_fdb_insert;
> > +
> > + list_add(&fdb_entry->list, &bridge->fdb_list);
> > +
> > + ice_eswitch_br_fdb_offload_notify(netdev, mac, vid, event);
> > +
> > + return;
> > +
> > +err_fdb_insert:
> > + ice_eswitch_br_flow_delete(pf, flow);
> > +err_add_flow:
> > + kfree(fdb_entry);
> > +err_exit:
> > + dev_err(dev, "Failed to create fdb entry, err: %d\n", err);
> > +}
> > +
> > +static void
> > +ice_eswitch_br_fdb_work_dealloc(struct ice_esw_br_fdb_work *fdb_work)
> > +{
> > + kfree(fdb_work->fdb_info.addr);
> > + kfree(fdb_work);
> > +}
> > +
> > +static void
> > +ice_eswitch_br_fdb_event_work(struct work_struct *work)
> > +{
> > + struct ice_esw_br_fdb_work *fdb_work = ice_work_to_fdb_work(work);
> > + bool added_by_user = fdb_work->fdb_info.added_by_user;
> > + struct ice_esw_br_port *br_port = fdb_work->br_port;
> > + const unsigned char *mac = fdb_work->fdb_info.addr;
> > + u16 vid = fdb_work->fdb_info.vid;
> > +
> > + rtnl_lock();
> > +
> > + if (!br_port || !br_port->bridge)
> > + goto err_exit;
> > +
> > + switch (fdb_work->event) {
> > + case SWITCHDEV_FDB_ADD_TO_DEVICE:
> > + ice_eswitch_br_fdb_entry_create(fdb_work->dev, br_port,
> > + added_by_user, mac, vid);
> > + break;
> > + case SWITCHDEV_FDB_DEL_TO_DEVICE:
> > + ice_eswitch_br_fdb_entry_find_and_delete(br_port->bridge,
> > + mac, vid);
> > + break;
> > + default:
> > + goto err_exit;
> > + }
> > +
> > +err_exit:
> > + rtnl_unlock();
> > + dev_put(fdb_work->dev);
> > + ice_eswitch_br_fdb_work_dealloc(fdb_work);
> > +}
> > +
> > +static struct ice_esw_br_fdb_work *
> > +ice_eswitch_br_fdb_work_alloc(struct switchdev_notifier_fdb_info *fdb_info,
> > + struct ice_esw_br_port *br_port,
> > + struct net_device *dev,
> > + unsigned long event)
> > +{
> > + struct ice_esw_br_fdb_work *work;
> > + unsigned char *mac;
> > +
> > + work = kzalloc(sizeof(*work), GFP_ATOMIC);
> > + if (!work)
> > + return ERR_PTR(-ENOMEM);
> > +
> > + INIT_WORK(&work->work, ice_eswitch_br_fdb_event_work);
> > + memcpy(&work->fdb_info, fdb_info, sizeof(work->fdb_info));
> > +
> > + mac = kzalloc(ETH_ALEN, GFP_ATOMIC);
> > + if (!mac) {
> > + kfree(work);
> > + return ERR_PTR(-ENOMEM);
> > + }
> > +
> > + ether_addr_copy(mac, fdb_info->addr);
> > + work->fdb_info.addr = mac;
> > + work->br_port = br_port;
> > + work->event = event;
> > + work->dev = dev;
> > +
> > + return work;
> > +}
> > +
> > +static int
> > +ice_eswitch_br_switchdev_event(struct notifier_block *nb,
> > + unsigned long event, void *ptr)
> > +{
> > + struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
> > + struct switchdev_notifier_fdb_info *fdb_info;
> > + struct switchdev_notifier_info *info = ptr;
> > + struct ice_esw_br_offloads *br_offloads;
> > + struct ice_esw_br_fdb_work *work;
> > + struct ice_esw_br_port *br_port;
> > + struct netlink_ext_ack *extack;
> > + struct net_device *upper;
> > +
> > + br_offloads = ice_nb_to_br_offloads(nb, switchdev_nb);
> > + extack = switchdev_notifier_info_to_extack(ptr);
> > +
> > + upper = netdev_master_upper_dev_get_rcu(dev);
> > + if (!upper)
> > + return NOTIFY_DONE;
> > +
> > + if (!netif_is_bridge_master(upper))
> > + return NOTIFY_DONE;
> > +
> > + if (!ice_eswitch_br_is_dev_valid(dev))
> > + return NOTIFY_DONE;
> > +
> > + br_port = ice_eswitch_br_netdev_to_port(dev);
> > + if (!br_port)
> > + return NOTIFY_DONE;
> > +
> > + switch (event) {
> > + case SWITCHDEV_FDB_ADD_TO_DEVICE:
> > + case SWITCHDEV_FDB_DEL_TO_DEVICE:
> > + fdb_info = container_of(info, typeof(*fdb_info), info);
> > +
> > + work = ice_eswitch_br_fdb_work_alloc(fdb_info, br_port, dev,
> > + event);
> > + if (IS_ERR(work)) {
> > + NL_SET_ERR_MSG_MOD(extack, "Failed to init switchdev fdb work");
> > + return notifier_from_errno(PTR_ERR(work));
> > + }
> > + dev_hold(dev);
> > +
> > + queue_work(br_offloads->wq, &work->work);
> > + break;
> > + default:
> > + break;
> > + }
> > + return NOTIFY_DONE;
> > +}
> > +
> > static void
> > ice_eswitch_br_port_deinit(struct ice_esw_br *bridge,
> > struct ice_esw_br_port *br_port)
> > {
> > + struct ice_esw_br_fdb_entry *fdb_entry, *tmp;
> > struct ice_vsi *vsi = br_port->vsi;
> >
> > + list_for_each_entry_safe(fdb_entry, tmp, &bridge->fdb_list, list) {
> > + if (br_port == fdb_entry->br_port)
> > + ice_eswitch_br_fdb_entry_delete(bridge, fdb_entry);
> > + }
> > +
> > if (br_port->type == ICE_ESWITCH_BR_UPLINK_PORT && vsi->back)
> > vsi->back->br_port = NULL;
> > - else if (vsi->vf)
> > + else if (vsi->vf && vsi->vf->repr)
>
> Shouldn't this check be in the previous patch? Don't see anything that
> would influence this pointer assignment in this patch.
Yes, you're right. Small fix was squashed into wrong patch.
>
> > vsi->vf->repr->br_port = NULL;
> >
> > xa_erase(&bridge->ports, br_port->vsi_idx);
> > @@ -129,6 +534,8 @@ ice_eswitch_br_deinit(struct ice_esw_br_offloads *br_offloads,
> > ice_eswitch_br_ports_flush(bridge);
> > WARN_ON(!xa_empty(&bridge->ports));
> > xa_destroy(&bridge->ports);
> > + rhashtable_destroy(&bridge->fdb_ht);
> > +
> > br_offloads->bridge = NULL;
> > kfree(bridge);
> > }
> > @@ -137,11 +544,19 @@ static struct ice_esw_br *
> > ice_eswitch_br_init(struct ice_esw_br_offloads *br_offloads, int ifindex)
> > {
> > struct ice_esw_br *bridge;
> > + int err;
> >
> > bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
> > if (!bridge)
> > return ERR_PTR(-ENOMEM);
> >
> > + err = rhashtable_init(&bridge->fdb_ht, &ice_fdb_ht_params);
> > + if (err) {
> > + kfree(bridge);
> > + return ERR_PTR(err);
> > + }
> > +
> > + INIT_LIST_HEAD(&bridge->fdb_list);
> > bridge->br_offloads = br_offloads;
> > bridge->ifindex = ifindex;
> > xa_init(&bridge->ports);
> > @@ -340,6 +755,8 @@ ice_eswitch_br_offloads_deinit(struct ice_pf *pf)
> > return;
> >
> > unregister_netdevice_notifier(&br_offloads->netdev_nb);
> > + unregister_switchdev_notifier(&br_offloads->switchdev_nb);
> > + destroy_workqueue(br_offloads->wq);
> > /* Although notifier block is unregistered just before,
> > * so we don't get any new events, some events might be
> > * already in progress. Hold the rtnl lock and wait for
> > @@ -365,6 +782,22 @@ ice_eswitch_br_offloads_init(struct ice_pf *pf)
> > return PTR_ERR(br_offloads);
> > }
> >
> > + br_offloads->wq = alloc_ordered_workqueue("ice_bridge_wq", 0);
> > + if (!br_offloads->wq) {
> > + err = -ENOMEM;
> > + dev_err(dev, "Failed to allocate bridge workqueue\n");
> > + goto err_alloc_wq;
> > + }
> > +
> > + br_offloads->switchdev_nb.notifier_call =
> > + ice_eswitch_br_switchdev_event;
> > + err = register_switchdev_notifier(&br_offloads->switchdev_nb);
> > + if (err) {
> > + dev_err(dev,
> > + "Failed to register switchdev notifier\n");
> > + goto err_reg_switchdev_nb;
> > + }
> > +
> > br_offloads->netdev_nb.notifier_call = ice_eswitch_br_port_event;
> > err = register_netdevice_notifier(&br_offloads->netdev_nb);
> > if (err) {
> > @@ -376,6 +809,10 @@ ice_eswitch_br_offloads_init(struct ice_pf *pf)
> > return 0;
> >
> > err_reg_netdev_nb:
> > + unregister_switchdev_notifier(&br_offloads->switchdev_nb);
> > +err_reg_switchdev_nb:
> > + destroy_workqueue(br_offloads->wq);
> > +err_alloc_wq:
> > rtnl_lock();
> > ice_eswitch_br_offloads_dealloc(pf);
> > rtnl_unlock();
> > diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch_br.h b/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
> > index 3ad28a17298f..6fcacf545b98 100644
> > --- a/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
> > +++ b/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
> > @@ -4,6 +4,33 @@
> > #ifndef _ICE_ESWITCH_BR_H_
> > #define _ICE_ESWITCH_BR_H_
> >
> > +#include <linux/rhashtable.h>
> > +
> > +struct ice_esw_br_fdb_data {
> > + unsigned char addr[ETH_ALEN];
> > + u16 vid;
> > +};
> > +
> > +struct ice_esw_br_flow {
> > + struct ice_rule_query_data *fwd_rule;
> > +};
> > +
> > +enum {
> > + ICE_ESWITCH_BR_FDB_ADDED_BY_USER = BIT(0),
> > +};
> > +
> > +struct ice_esw_br_fdb_entry {
> > + struct ice_esw_br_fdb_data data;
> > + struct rhash_head ht_node;
> > + struct list_head list;
> > +
> > + int flags;
> > +
> > + struct net_device *dev;
> > + struct ice_esw_br_port *br_port;
> > + struct ice_esw_br_flow *flow;
> > +};
> > +
> > enum ice_esw_br_port_type {
> > ICE_ESWITCH_BR_UPLINK_PORT = 0,
> > ICE_ESWITCH_BR_VF_REPR_PORT = 1,
> > @@ -20,6 +47,9 @@ struct ice_esw_br {
> > struct ice_esw_br_offloads *br_offloads;
> > struct xarray ports;
> >
> > + struct rhashtable fdb_ht;
> > + struct list_head fdb_list;
> > +
> > int ifindex;
> > };
> >
> > @@ -27,6 +57,17 @@ struct ice_esw_br_offloads {
> > struct ice_pf *pf;
> > struct ice_esw_br *bridge;
> > struct notifier_block netdev_nb;
> > + struct notifier_block switchdev_nb;
> > +
> > + struct workqueue_struct *wq;
> > +};
> > +
> > +struct ice_esw_br_fdb_work {
> > + struct work_struct work;
> > + struct switchdev_notifier_fdb_info fdb_info;
> > + struct ice_esw_br_port *br_port;
> > + struct net_device *dev;
> > + unsigned long event;
> > };
> >
> > #define ice_nb_to_br_offloads(nb, nb_name) \
> > @@ -34,6 +75,11 @@ struct ice_esw_br_offloads {
> > struct ice_esw_br_offloads, \
> > nb_name)
> >
> > +#define ice_work_to_fdb_work(w) \
> > + container_of(w, \
> > + struct ice_esw_br_fdb_work, \
> > + work)
> > +
> > void
> > ice_eswitch_br_offloads_deinit(struct ice_pf *pf);
> > int
^ permalink raw reply [flat|nested] 29+ messages in thread
* [PATCH net-next 08/12] ice: Add guard rule when creating FDB in switchdev
2023-06-20 17:44 [PATCH net-next 00/12][pull request] ice: switchdev bridge offload Tony Nguyen
` (6 preceding siblings ...)
2023-06-20 17:44 ` [PATCH net-next 07/12] ice: Switchdev FDB events support Tony Nguyen
@ 2023-06-20 17:44 ` Tony Nguyen
2023-06-20 17:44 ` [PATCH net-next 09/12] ice: Add VLAN FDB support in switchdev mode Tony Nguyen
` (4 subsequent siblings)
12 siblings, 0 replies; 29+ messages in thread
From: Tony Nguyen @ 2023-06-20 17:44 UTC (permalink / raw)
To: davem, kuba, pabeni, edumazet, netdev
Cc: Marcin Szycik, anthony.l.nguyen, jiri, ivecera, simon.horman,
Wojciech Drewek, Sujai Buvaneswaran
From: Marcin Szycik <marcin.szycik@intel.com>
Introduce new "guard" rule upon FDB entry creation.
It matches on src_mac, has valid bit unset, allow_pass_l2 set
and has a nop action.
Previously introduced "forward" rule matches on dst_mac, has valid
bit set, need_pass_l2 set and has a forward action.
With these rules, a packet will be offloaded only if FDB exists in both
directions (RX and TX).
Let's assume link partner sends a packet to VF1: src_mac = LP_MAC,
dst_mac = is VF1_MAC. Bridge adds FDB, two rules are created:
1. Guard rule matching on src_mac == LP_MAC
2. Forward rule matching on dst_mac == LP_MAC
Now VF1 responds with src_mac = VF1_MAC, dst_mac = LP_MAC. Before this
change, only one rule with dst_mac == LP_MAC would have existed, and the
packet would have been offloaded, meaning the bridge wouldn't add FDB in
the opposite direction. Now, the forward rule matches (dst_mac == LP_MAC),
but it has need_pass_l2 set an there is no guard rule with
src_mac == VF1_MAC, so the packet goes through slow-path and the bridge
adds FDB. Two rules are created:
1. Guard rule matching on src_mac == VF1_MAC
2. Forward rule matching on dst_mac == VF1_MAC
Further packets in both directions will be offloaded.
The same example is true in opposite direction (i.e. VF1 is the first to
send a packet out).
Reviewed-by: Simon Horman <simon.horman@corigine.com>
Signed-off-by: Marcin Szycik <marcin.szycik@intel.com>
Signed-off-by: Wojciech Drewek <wojciech.drewek@intel.com>
Tested-by: Sujai Buvaneswaran <sujai.buvaneswaran@intel.com>
Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
---
.../net/ethernet/intel/ice/ice_eswitch_br.c | 64 +++++++++++-
.../net/ethernet/intel/ice/ice_eswitch_br.h | 1 +
drivers/net/ethernet/intel/ice/ice_switch.c | 97 ++++++++++++-------
drivers/net/ethernet/intel/ice/ice_switch.h | 5 +
drivers/net/ethernet/intel/ice/ice_type.h | 1 +
5 files changed, 132 insertions(+), 36 deletions(-)
diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch_br.c b/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
index 8f22da490a69..1e57ce7b22d3 100644
--- a/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
+++ b/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
@@ -107,6 +107,8 @@ ice_eswitch_br_fwd_rule_create(struct ice_hw *hw, int vsi_idx, int port_type,
ether_addr_copy(list[0].h_u.eth_hdr.dst_addr, mac);
eth_broadcast_addr(list[0].m_u.eth_hdr.dst_addr);
+ rule_info.need_pass_l2 = true;
+
rule_info.sw_act.fltr_act = ICE_FWD_TO_VSI;
err = ice_add_adv_rule(hw, list, lkups_cnt, &rule_info, rule);
@@ -125,11 +127,54 @@ ice_eswitch_br_fwd_rule_create(struct ice_hw *hw, int vsi_idx, int port_type,
return ERR_PTR(err);
}
+static struct ice_rule_query_data *
+ice_eswitch_br_guard_rule_create(struct ice_hw *hw, u16 vsi_idx,
+ const unsigned char *mac)
+{
+ struct ice_adv_rule_info rule_info = { 0 };
+ struct ice_rule_query_data *rule;
+ struct ice_adv_lkup_elem *list;
+ const u16 lkups_cnt = 1;
+ int err = -ENOMEM;
+
+ rule = kzalloc(sizeof(*rule), GFP_KERNEL);
+ if (!rule)
+ goto err_exit;
+
+ list = kcalloc(lkups_cnt, sizeof(*list), GFP_ATOMIC);
+ if (!list)
+ goto err_list_alloc;
+
+ list[0].type = ICE_MAC_OFOS;
+ ether_addr_copy(list[0].h_u.eth_hdr.src_addr, mac);
+ eth_broadcast_addr(list[0].m_u.eth_hdr.src_addr);
+
+ rule_info.allow_pass_l2 = true;
+ rule_info.sw_act.vsi_handle = vsi_idx;
+ rule_info.sw_act.fltr_act = ICE_NOP;
+ rule_info.priority = 5;
+
+ err = ice_add_adv_rule(hw, list, lkups_cnt, &rule_info, rule);
+ if (err)
+ goto err_add_rule;
+
+ kfree(list);
+
+ return rule;
+
+err_add_rule:
+ kfree(list);
+err_list_alloc:
+ kfree(rule);
+err_exit:
+ return ERR_PTR(err);
+}
+
static struct ice_esw_br_flow *
ice_eswitch_br_flow_create(struct device *dev, struct ice_hw *hw, int vsi_idx,
int port_type, const unsigned char *mac)
{
- struct ice_rule_query_data *fwd_rule;
+ struct ice_rule_query_data *fwd_rule, *guard_rule;
struct ice_esw_br_flow *flow;
int err;
@@ -146,10 +191,22 @@ ice_eswitch_br_flow_create(struct device *dev, struct ice_hw *hw, int vsi_idx,
goto err_fwd_rule;
}
+ guard_rule = ice_eswitch_br_guard_rule_create(hw, vsi_idx, mac);
+ err = PTR_ERR_OR_ZERO(guard_rule);
+ if (err) {
+ dev_err(dev, "Failed to create eswitch bridge %sgress guard rule, err: %d\n",
+ port_type == ICE_ESWITCH_BR_UPLINK_PORT ? "e" : "in",
+ err);
+ goto err_guard_rule;
+ }
+
flow->fwd_rule = fwd_rule;
+ flow->guard_rule = guard_rule;
return flow;
+err_guard_rule:
+ ice_eswitch_br_rule_delete(hw, fwd_rule);
err_fwd_rule:
kfree(flow);
@@ -180,6 +237,11 @@ ice_eswitch_br_flow_delete(struct ice_pf *pf, struct ice_esw_br_flow *flow)
dev_err(dev, "Failed to delete FDB forward rule, err: %d\n",
err);
+ err = ice_eswitch_br_rule_delete(&pf->hw, flow->guard_rule);
+ if (err)
+ dev_err(dev, "Failed to delete FDB guard rule, err: %d\n",
+ err);
+
kfree(flow);
}
diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch_br.h b/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
index 6fcacf545b98..7afd00cdea9a 100644
--- a/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
+++ b/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
@@ -13,6 +13,7 @@ struct ice_esw_br_fdb_data {
struct ice_esw_br_flow {
struct ice_rule_query_data *fwd_rule;
+ struct ice_rule_query_data *guard_rule;
};
enum {
diff --git a/drivers/net/ethernet/intel/ice/ice_switch.c b/drivers/net/ethernet/intel/ice/ice_switch.c
index 92e16e9720ae..d78be14c9073 100644
--- a/drivers/net/ethernet/intel/ice/ice_switch.c
+++ b/drivers/net/ethernet/intel/ice/ice_switch.c
@@ -2277,6 +2277,10 @@ ice_get_recp_frm_fw(struct ice_hw *hw, struct ice_sw_recipe *recps, u8 rid,
/* Propagate some data to the recipe database */
recps[idx].is_root = !!is_root;
recps[idx].priority = root_bufs.content.act_ctrl_fwd_priority;
+ recps[idx].need_pass_l2 = root_bufs.content.act_ctrl &
+ ICE_AQ_RECIPE_ACT_NEED_PASS_L2;
+ recps[idx].allow_pass_l2 = root_bufs.content.act_ctrl &
+ ICE_AQ_RECIPE_ACT_ALLOW_PASS_L2;
bitmap_zero(recps[idx].res_idxs, ICE_MAX_FV_WORDS);
if (root_bufs.content.result_indx & ICE_AQ_RECIPE_RESULT_EN) {
recps[idx].chain_idx = root_bufs.content.result_indx &
@@ -4618,13 +4622,13 @@ static struct ice_protocol_entry ice_prot_id_tbl[ICE_PROTOCOL_LAST] = {
* ice_find_recp - find a recipe
* @hw: pointer to the hardware structure
* @lkup_exts: extension sequence to match
- * @tun_type: type of recipe tunnel
+ * @rinfo: information regarding the rule e.g. priority and action info
*
* Returns index of matching recipe, or ICE_MAX_NUM_RECIPES if not found.
*/
static u16
ice_find_recp(struct ice_hw *hw, struct ice_prot_lkup_ext *lkup_exts,
- enum ice_sw_tunnel_type tun_type)
+ const struct ice_adv_rule_info *rinfo)
{
bool refresh_required = true;
struct ice_sw_recipe *recp;
@@ -4685,9 +4689,12 @@ ice_find_recp(struct ice_hw *hw, struct ice_prot_lkup_ext *lkup_exts,
}
/* If for "i"th recipe the found was never set to false
* then it means we found our match
- * Also tun type of recipe needs to be checked
+ * Also tun type and *_pass_l2 of recipe needs to be
+ * checked
*/
- if (found && recp[i].tun_type == tun_type)
+ if (found && recp[i].tun_type == rinfo->tun_type &&
+ recp[i].need_pass_l2 == rinfo->need_pass_l2 &&
+ recp[i].allow_pass_l2 == rinfo->allow_pass_l2)
return i; /* Return the recipe ID */
}
}
@@ -4957,6 +4964,7 @@ ice_add_sw_recipe(struct ice_hw *hw, struct ice_sw_recipe *rm,
unsigned long *profiles)
{
DECLARE_BITMAP(result_idx_bm, ICE_MAX_FV_WORDS);
+ struct ice_aqc_recipe_content *content;
struct ice_aqc_recipe_data_elem *tmp;
struct ice_aqc_recipe_data_elem *buf;
struct ice_recp_grp_entry *entry;
@@ -5017,6 +5025,8 @@ ice_add_sw_recipe(struct ice_hw *hw, struct ice_sw_recipe *rm,
if (status)
goto err_unroll;
+ content = &buf[recps].content;
+
/* Clear the result index of the located recipe, as this will be
* updated, if needed, later in the recipe creation process.
*/
@@ -5027,26 +5037,24 @@ ice_add_sw_recipe(struct ice_hw *hw, struct ice_sw_recipe *rm,
/* if the recipe is a non-root recipe RID should be programmed
* as 0 for the rules to be applied correctly.
*/
- buf[recps].content.rid = 0;
- memset(&buf[recps].content.lkup_indx, 0,
- sizeof(buf[recps].content.lkup_indx));
+ content->rid = 0;
+ memset(&content->lkup_indx, 0,
+ sizeof(content->lkup_indx));
/* All recipes use look-up index 0 to match switch ID. */
- buf[recps].content.lkup_indx[0] = ICE_AQ_SW_ID_LKUP_IDX;
- buf[recps].content.mask[0] =
- cpu_to_le16(ICE_AQ_SW_ID_LKUP_MASK);
+ content->lkup_indx[0] = ICE_AQ_SW_ID_LKUP_IDX;
+ content->mask[0] = cpu_to_le16(ICE_AQ_SW_ID_LKUP_MASK);
/* Setup lkup_indx 1..4 to INVALID/ignore and set the mask
* to be 0
*/
for (i = 1; i <= ICE_NUM_WORDS_RECIPE; i++) {
- buf[recps].content.lkup_indx[i] = 0x80;
- buf[recps].content.mask[i] = 0;
+ content->lkup_indx[i] = 0x80;
+ content->mask[i] = 0;
}
for (i = 0; i < entry->r_group.n_val_pairs; i++) {
- buf[recps].content.lkup_indx[i + 1] = entry->fv_idx[i];
- buf[recps].content.mask[i + 1] =
- cpu_to_le16(entry->fv_mask[i]);
+ content->lkup_indx[i + 1] = entry->fv_idx[i];
+ content->mask[i + 1] = cpu_to_le16(entry->fv_mask[i]);
}
if (rm->n_grp_count > 1) {
@@ -5060,7 +5068,7 @@ ice_add_sw_recipe(struct ice_hw *hw, struct ice_sw_recipe *rm,
}
entry->chain_idx = chain_idx;
- buf[recps].content.result_indx =
+ content->result_indx =
ICE_AQ_RECIPE_RESULT_EN |
((chain_idx << ICE_AQ_RECIPE_RESULT_DATA_S) &
ICE_AQ_RECIPE_RESULT_DATA_M);
@@ -5074,7 +5082,13 @@ ice_add_sw_recipe(struct ice_hw *hw, struct ice_sw_recipe *rm,
ICE_MAX_NUM_RECIPES);
set_bit(buf[recps].recipe_indx,
(unsigned long *)buf[recps].recipe_bitmap);
- buf[recps].content.act_ctrl_fwd_priority = rm->priority;
+ content->act_ctrl_fwd_priority = rm->priority;
+
+ if (rm->need_pass_l2)
+ content->act_ctrl |= ICE_AQ_RECIPE_ACT_NEED_PASS_L2;
+
+ if (rm->allow_pass_l2)
+ content->act_ctrl |= ICE_AQ_RECIPE_ACT_ALLOW_PASS_L2;
recps++;
}
@@ -5112,9 +5126,11 @@ ice_add_sw_recipe(struct ice_hw *hw, struct ice_sw_recipe *rm,
if (status)
goto err_unroll;
+ content = &buf[recps].content;
+
buf[recps].recipe_indx = (u8)rid;
- buf[recps].content.rid = (u8)rid;
- buf[recps].content.rid |= ICE_AQ_RECIPE_ID_IS_ROOT;
+ content->rid = (u8)rid;
+ content->rid |= ICE_AQ_RECIPE_ID_IS_ROOT;
/* the new entry created should also be part of rg_list to
* make sure we have complete recipe
*/
@@ -5126,16 +5142,13 @@ ice_add_sw_recipe(struct ice_hw *hw, struct ice_sw_recipe *rm,
goto err_unroll;
}
last_chain_entry->rid = rid;
- memset(&buf[recps].content.lkup_indx, 0,
- sizeof(buf[recps].content.lkup_indx));
+ memset(&content->lkup_indx, 0, sizeof(content->lkup_indx));
/* All recipes use look-up index 0 to match switch ID. */
- buf[recps].content.lkup_indx[0] = ICE_AQ_SW_ID_LKUP_IDX;
- buf[recps].content.mask[0] =
- cpu_to_le16(ICE_AQ_SW_ID_LKUP_MASK);
+ content->lkup_indx[0] = ICE_AQ_SW_ID_LKUP_IDX;
+ content->mask[0] = cpu_to_le16(ICE_AQ_SW_ID_LKUP_MASK);
for (i = 1; i <= ICE_NUM_WORDS_RECIPE; i++) {
- buf[recps].content.lkup_indx[i] =
- ICE_AQ_RECIPE_LKUP_IGNORE;
- buf[recps].content.mask[i] = 0;
+ content->lkup_indx[i] = ICE_AQ_RECIPE_LKUP_IGNORE;
+ content->mask[i] = 0;
}
i = 1;
@@ -5147,8 +5160,8 @@ ice_add_sw_recipe(struct ice_hw *hw, struct ice_sw_recipe *rm,
last_chain_entry->chain_idx = ICE_INVAL_CHAIN_IND;
list_for_each_entry(entry, &rm->rg_list, l_entry) {
last_chain_entry->fv_idx[i] = entry->chain_idx;
- buf[recps].content.lkup_indx[i] = entry->chain_idx;
- buf[recps].content.mask[i++] = cpu_to_le16(0xFFFF);
+ content->lkup_indx[i] = entry->chain_idx;
+ content->mask[i++] = cpu_to_le16(0xFFFF);
set_bit(entry->rid, rm->r_bitmap);
}
list_add(&last_chain_entry->l_entry, &rm->rg_list);
@@ -5160,7 +5173,7 @@ ice_add_sw_recipe(struct ice_hw *hw, struct ice_sw_recipe *rm,
status = -EINVAL;
goto err_unroll;
}
- buf[recps].content.act_ctrl_fwd_priority = rm->priority;
+ content->act_ctrl_fwd_priority = rm->priority;
recps++;
rm->root_rid = (u8)rid;
@@ -5225,6 +5238,8 @@ ice_add_sw_recipe(struct ice_hw *hw, struct ice_sw_recipe *rm,
recp->priority = buf[buf_idx].content.act_ctrl_fwd_priority;
recp->n_grp_count = rm->n_grp_count;
recp->tun_type = rm->tun_type;
+ recp->need_pass_l2 = rm->need_pass_l2;
+ recp->allow_pass_l2 = rm->allow_pass_l2;
recp->recp_created = true;
}
rm->root_buf = buf;
@@ -5393,6 +5408,9 @@ ice_add_adv_recipe(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups,
/* set the recipe priority if specified */
rm->priority = (u8)rinfo->priority;
+ rm->need_pass_l2 = rinfo->need_pass_l2;
+ rm->allow_pass_l2 = rinfo->allow_pass_l2;
+
/* Find offsets from the field vector. Pick the first one for all the
* recipes.
*/
@@ -5408,7 +5426,7 @@ ice_add_adv_recipe(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups,
}
/* Look for a recipe which matches our requested fv / mask list */
- *rid = ice_find_recp(hw, lkup_exts, rinfo->tun_type);
+ *rid = ice_find_recp(hw, lkup_exts, rinfo);
if (*rid < ICE_MAX_NUM_RECIPES)
/* Success if found a recipe that match the existing criteria */
goto err_unroll;
@@ -5846,7 +5864,9 @@ static bool ice_rules_equal(const struct ice_adv_rule_info *first,
return first->sw_act.flag == second->sw_act.flag &&
first->tun_type == second->tun_type &&
first->vlan_type == second->vlan_type &&
- first->src_vsi == second->src_vsi;
+ first->src_vsi == second->src_vsi &&
+ first->need_pass_l2 == second->need_pass_l2 &&
+ first->allow_pass_l2 == second->allow_pass_l2;
}
/**
@@ -6085,7 +6105,8 @@ ice_add_adv_rule(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups,
if (!(rinfo->sw_act.fltr_act == ICE_FWD_TO_VSI ||
rinfo->sw_act.fltr_act == ICE_FWD_TO_Q ||
rinfo->sw_act.fltr_act == ICE_FWD_TO_QGRP ||
- rinfo->sw_act.fltr_act == ICE_DROP_PACKET)) {
+ rinfo->sw_act.fltr_act == ICE_DROP_PACKET ||
+ rinfo->sw_act.fltr_act == ICE_NOP)) {
status = -EIO;
goto free_pkt_profile;
}
@@ -6096,7 +6117,8 @@ ice_add_adv_rule(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups,
goto free_pkt_profile;
}
- if (rinfo->sw_act.fltr_act == ICE_FWD_TO_VSI)
+ if (rinfo->sw_act.fltr_act == ICE_FWD_TO_VSI ||
+ rinfo->sw_act.fltr_act == ICE_NOP)
rinfo->sw_act.fwd_id.hw_vsi_id =
ice_get_hw_vsi_num(hw, vsi_handle);
@@ -6166,6 +6188,11 @@ ice_add_adv_rule(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups,
act |= ICE_SINGLE_ACT_VSI_FORWARDING | ICE_SINGLE_ACT_DROP |
ICE_SINGLE_ACT_VALID_BIT;
break;
+ case ICE_NOP:
+ act |= FIELD_PREP(ICE_SINGLE_ACT_VSI_ID_M,
+ rinfo->sw_act.fwd_id.hw_vsi_id);
+ act &= ~ICE_SINGLE_ACT_VALID_BIT;
+ break;
default:
status = -EIO;
goto err_ice_add_adv_rule;
@@ -6446,7 +6473,7 @@ ice_rem_adv_rule(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups,
return -EIO;
}
- rid = ice_find_recp(hw, &lkup_exts, rinfo->tun_type);
+ rid = ice_find_recp(hw, &lkup_exts, rinfo);
/* If did not find a recipe that match the existing criteria */
if (rid == ICE_MAX_NUM_RECIPES)
return -EINVAL;
diff --git a/drivers/net/ethernet/intel/ice/ice_switch.h b/drivers/net/ethernet/intel/ice/ice_switch.h
index db08509805ce..10f5a0ae199e 100644
--- a/drivers/net/ethernet/intel/ice/ice_switch.h
+++ b/drivers/net/ethernet/intel/ice/ice_switch.h
@@ -191,6 +191,8 @@ struct ice_adv_rule_info {
u16 vlan_type;
u16 fltr_rule_id;
u32 priority;
+ u16 need_pass_l2:1;
+ u16 allow_pass_l2:1;
u16 src_vsi;
struct ice_sw_act_ctrl sw_act;
struct ice_adv_rule_flags_info flags_info;
@@ -254,6 +256,9 @@ struct ice_sw_recipe {
*/
u8 priority;
+ u8 need_pass_l2:1;
+ u8 allow_pass_l2:1;
+
struct list_head rg_list;
/* AQ buffer associated with this recipe */
diff --git a/drivers/net/ethernet/intel/ice/ice_type.h b/drivers/net/ethernet/intel/ice/ice_type.h
index a09556e57803..df9171a1a34f 100644
--- a/drivers/net/ethernet/intel/ice/ice_type.h
+++ b/drivers/net/ethernet/intel/ice/ice_type.h
@@ -1033,6 +1033,7 @@ enum ice_sw_fwd_act_type {
ICE_FWD_TO_Q,
ICE_FWD_TO_QGRP,
ICE_DROP_PACKET,
+ ICE_NOP,
ICE_INVAL_ACT
};
--
2.38.1
^ permalink raw reply related [flat|nested] 29+ messages in thread* [PATCH net-next 09/12] ice: Add VLAN FDB support in switchdev mode
2023-06-20 17:44 [PATCH net-next 00/12][pull request] ice: switchdev bridge offload Tony Nguyen
` (7 preceding siblings ...)
2023-06-20 17:44 ` [PATCH net-next 08/12] ice: Add guard rule when creating FDB in switchdev Tony Nguyen
@ 2023-06-20 17:44 ` Tony Nguyen
2023-06-21 13:59 ` Simon Horman
2023-06-22 12:03 ` Vlad Buslov
2023-06-20 17:44 ` [PATCH net-next 10/12] ice: implement bridge port vlan Tony Nguyen
` (3 subsequent siblings)
12 siblings, 2 replies; 29+ messages in thread
From: Tony Nguyen @ 2023-06-20 17:44 UTC (permalink / raw)
To: davem, kuba, pabeni, edumazet, netdev
Cc: Marcin Szycik, anthony.l.nguyen, jiri, ivecera, simon.horman,
Wojciech Drewek, Sujai Buvaneswaran
From: Marcin Szycik <marcin.szycik@intel.com>
Add support for matching on VLAN tag in bridge offloads.
Currently only trunk mode is supported.
To enable VLAN filtering (existing FDB entries will be deleted):
ip link set $BR type bridge vlan_filtering 1
To add VLANs to bridge in trunk mode:
bridge vlan add dev $PF1 vid 110-111
bridge vlan add dev $VF1_PR vid 110-111
Signed-off-by: Marcin Szycik <marcin.szycik@intel.com>
Signed-off-by: Wojciech Drewek <wojciech.drewek@intel.com>
Tested-by: Sujai Buvaneswaran <sujai.buvaneswaran@intel.com>
Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
---
.../net/ethernet/intel/ice/ice_eswitch_br.c | 296 +++++++++++++++++-
.../net/ethernet/intel/ice/ice_eswitch_br.h | 21 ++
2 files changed, 309 insertions(+), 8 deletions(-)
diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch_br.c b/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
index 1e57ce7b22d3..805a6b2fd965 100644
--- a/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
+++ b/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
@@ -70,16 +70,34 @@ ice_eswitch_br_rule_delete(struct ice_hw *hw, struct ice_rule_query_data *rule)
return err;
}
+static u16
+ice_eswitch_br_get_lkups_cnt(u16 vid)
+{
+ return ice_eswitch_br_is_vid_valid(vid) ? 2 : 1;
+}
+
+static void
+ice_eswitch_br_add_vlan_lkup(struct ice_adv_lkup_elem *list, u16 vid)
+{
+ if (ice_eswitch_br_is_vid_valid(vid)) {
+ list[1].type = ICE_VLAN_OFOS;
+ list[1].h_u.vlan_hdr.vlan = cpu_to_be16(vid & VLAN_VID_MASK);
+ list[1].m_u.vlan_hdr.vlan = cpu_to_be16(0xFFFF);
+ }
+}
+
static struct ice_rule_query_data *
ice_eswitch_br_fwd_rule_create(struct ice_hw *hw, int vsi_idx, int port_type,
- const unsigned char *mac)
+ const unsigned char *mac, u16 vid)
{
struct ice_adv_rule_info rule_info = { 0 };
struct ice_rule_query_data *rule;
struct ice_adv_lkup_elem *list;
- u16 lkups_cnt = 1;
+ u16 lkups_cnt;
int err;
+ lkups_cnt = ice_eswitch_br_get_lkups_cnt(vid);
+
rule = kzalloc(sizeof(*rule), GFP_KERNEL);
if (!rule)
return ERR_PTR(-ENOMEM);
@@ -107,6 +125,8 @@ ice_eswitch_br_fwd_rule_create(struct ice_hw *hw, int vsi_idx, int port_type,
ether_addr_copy(list[0].h_u.eth_hdr.dst_addr, mac);
eth_broadcast_addr(list[0].m_u.eth_hdr.dst_addr);
+ ice_eswitch_br_add_vlan_lkup(list, vid);
+
rule_info.need_pass_l2 = true;
rule_info.sw_act.fltr_act = ICE_FWD_TO_VSI;
@@ -129,13 +149,15 @@ ice_eswitch_br_fwd_rule_create(struct ice_hw *hw, int vsi_idx, int port_type,
static struct ice_rule_query_data *
ice_eswitch_br_guard_rule_create(struct ice_hw *hw, u16 vsi_idx,
- const unsigned char *mac)
+ const unsigned char *mac, u16 vid)
{
struct ice_adv_rule_info rule_info = { 0 };
struct ice_rule_query_data *rule;
struct ice_adv_lkup_elem *list;
- const u16 lkups_cnt = 1;
int err = -ENOMEM;
+ u16 lkups_cnt;
+
+ lkups_cnt = ice_eswitch_br_get_lkups_cnt(vid);
rule = kzalloc(sizeof(*rule), GFP_KERNEL);
if (!rule)
@@ -149,6 +171,8 @@ ice_eswitch_br_guard_rule_create(struct ice_hw *hw, u16 vsi_idx,
ether_addr_copy(list[0].h_u.eth_hdr.src_addr, mac);
eth_broadcast_addr(list[0].m_u.eth_hdr.src_addr);
+ ice_eswitch_br_add_vlan_lkup(list, vid);
+
rule_info.allow_pass_l2 = true;
rule_info.sw_act.vsi_handle = vsi_idx;
rule_info.sw_act.fltr_act = ICE_NOP;
@@ -172,7 +196,7 @@ ice_eswitch_br_guard_rule_create(struct ice_hw *hw, u16 vsi_idx,
static struct ice_esw_br_flow *
ice_eswitch_br_flow_create(struct device *dev, struct ice_hw *hw, int vsi_idx,
- int port_type, const unsigned char *mac)
+ int port_type, const unsigned char *mac, u16 vid)
{
struct ice_rule_query_data *fwd_rule, *guard_rule;
struct ice_esw_br_flow *flow;
@@ -182,7 +206,8 @@ ice_eswitch_br_flow_create(struct device *dev, struct ice_hw *hw, int vsi_idx,
if (!flow)
return ERR_PTR(-ENOMEM);
- fwd_rule = ice_eswitch_br_fwd_rule_create(hw, vsi_idx, port_type, mac);
+ fwd_rule = ice_eswitch_br_fwd_rule_create(hw, vsi_idx, port_type, mac,
+ vid);
err = PTR_ERR_OR_ZERO(fwd_rule);
if (err) {
dev_err(dev, "Failed to create eswitch bridge %sgress forward rule, err: %d\n",
@@ -191,7 +216,7 @@ ice_eswitch_br_flow_create(struct device *dev, struct ice_hw *hw, int vsi_idx,
goto err_fwd_rule;
}
- guard_rule = ice_eswitch_br_guard_rule_create(hw, vsi_idx, mac);
+ guard_rule = ice_eswitch_br_guard_rule_create(hw, vsi_idx, mac, vid);
err = PTR_ERR_OR_ZERO(guard_rule);
if (err) {
dev_err(dev, "Failed to create eswitch bridge %sgress guard rule, err: %d\n",
@@ -245,6 +270,30 @@ ice_eswitch_br_flow_delete(struct ice_pf *pf, struct ice_esw_br_flow *flow)
kfree(flow);
}
+static struct ice_esw_br_vlan *
+ice_esw_br_port_vlan_lookup(struct ice_esw_br *bridge, u16 vsi_idx, u16 vid)
+{
+ struct ice_pf *pf = bridge->br_offloads->pf;
+ struct device *dev = ice_pf_to_dev(pf);
+ struct ice_esw_br_port *port;
+ struct ice_esw_br_vlan *vlan;
+
+ port = xa_load(&bridge->ports, vsi_idx);
+ if (!port) {
+ dev_info(dev, "Bridge port lookup failed (vsi=%u)\n", vsi_idx);
+ return ERR_PTR(-EINVAL);
+ }
+
+ vlan = xa_load(&port->vlans, vid);
+ if (!vlan) {
+ dev_info(dev, "Bridge port vlan metadata lookup failed (vsi=%u)\n",
+ vsi_idx);
+ return ERR_PTR(-EINVAL);
+ }
+
+ return vlan;
+}
+
static void
ice_eswitch_br_fdb_entry_delete(struct ice_esw_br *bridge,
struct ice_esw_br_fdb_entry *fdb_entry)
@@ -314,10 +363,25 @@ ice_eswitch_br_fdb_entry_create(struct net_device *netdev,
struct device *dev = ice_pf_to_dev(pf);
struct ice_esw_br_fdb_entry *fdb_entry;
struct ice_esw_br_flow *flow;
+ struct ice_esw_br_vlan *vlan;
struct ice_hw *hw = &pf->hw;
unsigned long event;
int err;
+ /* untagged filtering is not yet supported */
+ if (!(bridge->flags & ICE_ESWITCH_BR_VLAN_FILTERING) && vid)
+ return;
+
+ if ((bridge->flags & ICE_ESWITCH_BR_VLAN_FILTERING)) {
+ vlan = ice_esw_br_port_vlan_lookup(bridge, br_port->vsi_idx,
+ vid);
+ if (IS_ERR(vlan)) {
+ dev_err(dev, "Failed to find vlan lookup, err: %ld\n",
+ PTR_ERR(vlan));
+ return;
+ }
+ }
+
fdb_entry = ice_eswitch_br_fdb_find(bridge, mac, vid);
if (fdb_entry)
ice_eswitch_br_fdb_entry_notify_and_cleanup(bridge, fdb_entry);
@@ -329,7 +393,7 @@ ice_eswitch_br_fdb_entry_create(struct net_device *netdev,
}
flow = ice_eswitch_br_flow_create(dev, hw, br_port->vsi_idx,
- br_port->type, mac);
+ br_port->type, mac, vid);
if (IS_ERR(flow)) {
err = PTR_ERR(flow);
goto err_add_flow;
@@ -488,6 +552,207 @@ ice_eswitch_br_switchdev_event(struct notifier_block *nb,
return NOTIFY_DONE;
}
+static void ice_eswitch_br_fdb_flush(struct ice_esw_br *bridge)
+{
+ struct ice_esw_br_fdb_entry *entry, *tmp;
+
+ list_for_each_entry_safe(entry, tmp, &bridge->fdb_list, list)
+ ice_eswitch_br_fdb_entry_notify_and_cleanup(bridge, entry);
+}
+
+static void
+ice_eswitch_br_vlan_filtering_set(struct ice_esw_br *bridge, bool enable)
+{
+ if (enable == !!(bridge->flags & ICE_ESWITCH_BR_VLAN_FILTERING))
+ return;
+
+ ice_eswitch_br_fdb_flush(bridge);
+ if (enable)
+ bridge->flags |= ICE_ESWITCH_BR_VLAN_FILTERING;
+ else
+ bridge->flags &= ~ICE_ESWITCH_BR_VLAN_FILTERING;
+}
+
+static void
+ice_eswitch_br_vlan_cleanup(struct ice_esw_br_port *port,
+ struct ice_esw_br_vlan *vlan)
+{
+ xa_erase(&port->vlans, vlan->vid);
+ kfree(vlan);
+}
+
+static void ice_eswitch_br_port_vlans_flush(struct ice_esw_br_port *port)
+{
+ struct ice_esw_br_vlan *vlan;
+ unsigned long index;
+
+ xa_for_each(&port->vlans, index, vlan)
+ ice_eswitch_br_vlan_cleanup(port, vlan);
+}
+
+static struct ice_esw_br_vlan *
+ice_eswitch_br_vlan_create(u16 vid, u16 flags, struct ice_esw_br_port *port)
+{
+ struct ice_esw_br_vlan *vlan;
+ int err;
+
+ vlan = kzalloc(sizeof(*vlan), GFP_KERNEL);
+ if (!vlan)
+ return ERR_PTR(-ENOMEM);
+
+ vlan->vid = vid;
+ vlan->flags = flags;
+
+ err = xa_insert(&port->vlans, vlan->vid, vlan, GFP_KERNEL);
+ if (err) {
+ kfree(vlan);
+ return ERR_PTR(err);
+ }
+
+ return vlan;
+}
+
+static int
+ice_eswitch_br_port_vlan_add(struct ice_esw_br *bridge, u16 vsi_idx, u16 vid,
+ u16 flags, struct netlink_ext_ack *extack)
+{
+ struct ice_esw_br_port *port;
+ struct ice_esw_br_vlan *vlan;
+
+ port = xa_load(&bridge->ports, vsi_idx);
+ if (!port)
+ return -EINVAL;
+
+ vlan = xa_load(&port->vlans, vid);
+ if (vlan) {
+ if (vlan->flags == flags)
+ return 0;
+
+ ice_eswitch_br_vlan_cleanup(port, vlan);
+ }
+
+ vlan = ice_eswitch_br_vlan_create(vid, flags, port);
+ if (IS_ERR(vlan)) {
+ NL_SET_ERR_MSG_FMT_MOD(extack, "Failed to create VLAN entry, vid: %u, vsi: %u",
+ vid, vsi_idx);
+ return PTR_ERR(vlan);
+ }
+
+ return 0;
+}
+
+static void
+ice_eswitch_br_port_vlan_del(struct ice_esw_br *bridge, u16 vsi_idx, u16 vid)
+{
+ struct ice_esw_br_port *port;
+ struct ice_esw_br_vlan *vlan;
+
+ port = xa_load(&bridge->ports, vsi_idx);
+ if (!port)
+ return;
+
+ vlan = xa_load(&port->vlans, vid);
+ if (!vlan)
+ return;
+
+ ice_eswitch_br_vlan_cleanup(port, vlan);
+}
+
+static int
+ice_eswitch_br_port_obj_add(struct net_device *netdev, const void *ctx,
+ const struct switchdev_obj *obj,
+ struct netlink_ext_ack *extack)
+{
+ struct ice_esw_br_port *br_port = ice_eswitch_br_netdev_to_port(netdev);
+ struct switchdev_obj_port_vlan *vlan;
+ int err;
+
+ if (!br_port)
+ return -EINVAL;
+
+ switch (obj->id) {
+ case SWITCHDEV_OBJ_ID_PORT_VLAN:
+ vlan = SWITCHDEV_OBJ_PORT_VLAN(obj);
+ err = ice_eswitch_br_port_vlan_add(br_port->bridge,
+ br_port->vsi_idx, vlan->vid,
+ vlan->flags, extack);
+ return err;
+ default:
+ return -EOPNOTSUPP;
+ }
+}
+
+static int
+ice_eswitch_br_port_obj_del(struct net_device *netdev, const void *ctx,
+ const struct switchdev_obj *obj)
+{
+ struct ice_esw_br_port *br_port = ice_eswitch_br_netdev_to_port(netdev);
+ struct switchdev_obj_port_vlan *vlan;
+
+ if (!br_port)
+ return -EINVAL;
+
+ switch (obj->id) {
+ case SWITCHDEV_OBJ_ID_PORT_VLAN:
+ vlan = SWITCHDEV_OBJ_PORT_VLAN(obj);
+ ice_eswitch_br_port_vlan_del(br_port->bridge, br_port->vsi_idx,
+ vlan->vid);
+ return 0;
+ default:
+ return -EOPNOTSUPP;
+ }
+}
+
+static int
+ice_eswitch_br_port_obj_attr_set(struct net_device *netdev, const void *ctx,
+ const struct switchdev_attr *attr,
+ struct netlink_ext_ack *extack)
+{
+ struct ice_esw_br_port *br_port = ice_eswitch_br_netdev_to_port(netdev);
+
+ if (!br_port)
+ return -EINVAL;
+
+ switch (attr->id) {
+ case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
+ ice_eswitch_br_vlan_filtering_set(br_port->bridge,
+ attr->u.vlan_filtering);
+ return 0;
+ default:
+ return -EOPNOTSUPP;
+ }
+}
+
+static int
+ice_eswitch_br_event_blocking(struct notifier_block *nb, unsigned long event,
+ void *ptr)
+{
+ struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
+ int err;
+
+ switch (event) {
+ case SWITCHDEV_PORT_OBJ_ADD:
+ err = switchdev_handle_port_obj_add(dev, ptr,
+ ice_eswitch_br_is_dev_valid,
+ ice_eswitch_br_port_obj_add);
+ break;
+ case SWITCHDEV_PORT_OBJ_DEL:
+ err = switchdev_handle_port_obj_del(dev, ptr,
+ ice_eswitch_br_is_dev_valid,
+ ice_eswitch_br_port_obj_del);
+ break;
+ case SWITCHDEV_PORT_ATTR_SET:
+ err = switchdev_handle_port_attr_set(dev, ptr,
+ ice_eswitch_br_is_dev_valid,
+ ice_eswitch_br_port_obj_attr_set);
+ break;
+ default:
+ err = 0;
+ }
+
+ return notifier_from_errno(err);
+}
+
static void
ice_eswitch_br_port_deinit(struct ice_esw_br *bridge,
struct ice_esw_br_port *br_port)
@@ -506,6 +771,7 @@ ice_eswitch_br_port_deinit(struct ice_esw_br *bridge,
vsi->vf->repr->br_port = NULL;
xa_erase(&bridge->ports, br_port->vsi_idx);
+ ice_eswitch_br_port_vlans_flush(br_port);
kfree(br_port);
}
@@ -518,6 +784,8 @@ ice_eswitch_br_port_init(struct ice_esw_br *bridge)
if (!br_port)
return ERR_PTR(-ENOMEM);
+ xa_init(&br_port->vlans);
+
br_port->bridge = bridge;
return br_port;
@@ -817,6 +1085,7 @@ ice_eswitch_br_offloads_deinit(struct ice_pf *pf)
return;
unregister_netdevice_notifier(&br_offloads->netdev_nb);
+ unregister_switchdev_blocking_notifier(&br_offloads->switchdev_blk);
unregister_switchdev_notifier(&br_offloads->switchdev_nb);
destroy_workqueue(br_offloads->wq);
/* Although notifier block is unregistered just before,
@@ -860,6 +1129,15 @@ ice_eswitch_br_offloads_init(struct ice_pf *pf)
goto err_reg_switchdev_nb;
}
+ br_offloads->switchdev_blk.notifier_call =
+ ice_eswitch_br_event_blocking;
+ err = register_switchdev_blocking_notifier(&br_offloads->switchdev_blk);
+ if (err) {
+ dev_err(dev,
+ "Failed to register bridge blocking switchdev notifier\n");
+ goto err_reg_switchdev_blk;
+ }
+
br_offloads->netdev_nb.notifier_call = ice_eswitch_br_port_event;
err = register_netdevice_notifier(&br_offloads->netdev_nb);
if (err) {
@@ -871,6 +1149,8 @@ ice_eswitch_br_offloads_init(struct ice_pf *pf)
return 0;
err_reg_netdev_nb:
+ unregister_switchdev_blocking_notifier(&br_offloads->switchdev_blk);
+err_reg_switchdev_blk:
unregister_switchdev_notifier(&br_offloads->switchdev_nb);
err_reg_switchdev_nb:
destroy_workqueue(br_offloads->wq);
diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch_br.h b/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
index 7afd00cdea9a..dd49b273451a 100644
--- a/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
+++ b/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
@@ -42,6 +42,11 @@ struct ice_esw_br_port {
struct ice_vsi *vsi;
enum ice_esw_br_port_type type;
u16 vsi_idx;
+ struct xarray vlans;
+};
+
+enum {
+ ICE_ESWITCH_BR_VLAN_FILTERING = BIT(0),
};
struct ice_esw_br {
@@ -52,12 +57,14 @@ struct ice_esw_br {
struct list_head fdb_list;
int ifindex;
+ u32 flags;
};
struct ice_esw_br_offloads {
struct ice_pf *pf;
struct ice_esw_br *bridge;
struct notifier_block netdev_nb;
+ struct notifier_block switchdev_blk;
struct notifier_block switchdev_nb;
struct workqueue_struct *wq;
@@ -71,6 +78,11 @@ struct ice_esw_br_fdb_work {
unsigned long event;
};
+struct ice_esw_br_vlan {
+ u16 vid;
+ u16 flags;
+};
+
#define ice_nb_to_br_offloads(nb, nb_name) \
container_of(nb, \
struct ice_esw_br_offloads, \
@@ -81,6 +93,15 @@ struct ice_esw_br_fdb_work {
struct ice_esw_br_fdb_work, \
work)
+static inline bool ice_eswitch_br_is_vid_valid(u16 vid)
+{
+ /* In trunk VLAN mode, for untagged traffic the bridge sends requests
+ * to offload VLAN 1 with pvid and untagged flags set. Since these
+ * flags are not supported, add a MAC filter instead.
+ */
+ return vid > 1;
+}
+
void
ice_eswitch_br_offloads_deinit(struct ice_pf *pf);
int
--
2.38.1
^ permalink raw reply related [flat|nested] 29+ messages in thread* Re: [PATCH net-next 09/12] ice: Add VLAN FDB support in switchdev mode
2023-06-20 17:44 ` [PATCH net-next 09/12] ice: Add VLAN FDB support in switchdev mode Tony Nguyen
@ 2023-06-21 13:59 ` Simon Horman
2023-06-22 12:03 ` Vlad Buslov
1 sibling, 0 replies; 29+ messages in thread
From: Simon Horman @ 2023-06-21 13:59 UTC (permalink / raw)
To: Tony Nguyen
Cc: davem, kuba, pabeni, edumazet, netdev, Marcin Szycik, jiri,
ivecera, Wojciech Drewek, Sujai Buvaneswaran
On Tue, Jun 20, 2023 at 10:44:20AM -0700, Tony Nguyen wrote:
> From: Marcin Szycik <marcin.szycik@intel.com>
>
> Add support for matching on VLAN tag in bridge offloads.
> Currently only trunk mode is supported.
>
> To enable VLAN filtering (existing FDB entries will be deleted):
> ip link set $BR type bridge vlan_filtering 1
>
> To add VLANs to bridge in trunk mode:
> bridge vlan add dev $PF1 vid 110-111
> bridge vlan add dev $VF1_PR vid 110-111
>
> Signed-off-by: Marcin Szycik <marcin.szycik@intel.com>
> Signed-off-by: Wojciech Drewek <wojciech.drewek@intel.com>
> Tested-by: Sujai Buvaneswaran <sujai.buvaneswaran@intel.com>
> Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
Reviewed-by: Simon Horman <simon.horman@corigine.com>
^ permalink raw reply [flat|nested] 29+ messages in thread
* Re: [PATCH net-next 09/12] ice: Add VLAN FDB support in switchdev mode
2023-06-20 17:44 ` [PATCH net-next 09/12] ice: Add VLAN FDB support in switchdev mode Tony Nguyen
2023-06-21 13:59 ` Simon Horman
@ 2023-06-22 12:03 ` Vlad Buslov
2023-06-22 13:06 ` Drewek, Wojciech
1 sibling, 1 reply; 29+ messages in thread
From: Vlad Buslov @ 2023-06-22 12:03 UTC (permalink / raw)
To: Tony Nguyen
Cc: davem, kuba, pabeni, edumazet, netdev, Marcin Szycik, jiri,
ivecera, simon.horman, Wojciech Drewek, Sujai Buvaneswaran
On Tue 20 Jun 2023 at 10:44, Tony Nguyen <anthony.l.nguyen@intel.com> wrote:
> From: Marcin Szycik <marcin.szycik@intel.com>
>
> Add support for matching on VLAN tag in bridge offloads.
> Currently only trunk mode is supported.
>
> To enable VLAN filtering (existing FDB entries will be deleted):
> ip link set $BR type bridge vlan_filtering 1
>
> To add VLANs to bridge in trunk mode:
> bridge vlan add dev $PF1 vid 110-111
> bridge vlan add dev $VF1_PR vid 110-111
>
> Signed-off-by: Marcin Szycik <marcin.szycik@intel.com>
> Signed-off-by: Wojciech Drewek <wojciech.drewek@intel.com>
> Tested-by: Sujai Buvaneswaran <sujai.buvaneswaran@intel.com>
> Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
> ---
> .../net/ethernet/intel/ice/ice_eswitch_br.c | 296 +++++++++++++++++-
> .../net/ethernet/intel/ice/ice_eswitch_br.h | 21 ++
> 2 files changed, 309 insertions(+), 8 deletions(-)
>
> diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch_br.c b/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
> index 1e57ce7b22d3..805a6b2fd965 100644
> --- a/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
> +++ b/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
> @@ -70,16 +70,34 @@ ice_eswitch_br_rule_delete(struct ice_hw *hw, struct ice_rule_query_data *rule)
> return err;
> }
>
> +static u16
> +ice_eswitch_br_get_lkups_cnt(u16 vid)
> +{
> + return ice_eswitch_br_is_vid_valid(vid) ? 2 : 1;
> +}
> +
> +static void
> +ice_eswitch_br_add_vlan_lkup(struct ice_adv_lkup_elem *list, u16 vid)
> +{
> + if (ice_eswitch_br_is_vid_valid(vid)) {
> + list[1].type = ICE_VLAN_OFOS;
> + list[1].h_u.vlan_hdr.vlan = cpu_to_be16(vid & VLAN_VID_MASK);
> + list[1].m_u.vlan_hdr.vlan = cpu_to_be16(0xFFFF);
> + }
> +}
> +
> static struct ice_rule_query_data *
> ice_eswitch_br_fwd_rule_create(struct ice_hw *hw, int vsi_idx, int port_type,
> - const unsigned char *mac)
> + const unsigned char *mac, u16 vid)
> {
> struct ice_adv_rule_info rule_info = { 0 };
> struct ice_rule_query_data *rule;
> struct ice_adv_lkup_elem *list;
> - u16 lkups_cnt = 1;
> + u16 lkups_cnt;
> int err;
>
> + lkups_cnt = ice_eswitch_br_get_lkups_cnt(vid);
> +
> rule = kzalloc(sizeof(*rule), GFP_KERNEL);
> if (!rule)
> return ERR_PTR(-ENOMEM);
> @@ -107,6 +125,8 @@ ice_eswitch_br_fwd_rule_create(struct ice_hw *hw, int vsi_idx, int port_type,
> ether_addr_copy(list[0].h_u.eth_hdr.dst_addr, mac);
> eth_broadcast_addr(list[0].m_u.eth_hdr.dst_addr);
>
> + ice_eswitch_br_add_vlan_lkup(list, vid);
> +
> rule_info.need_pass_l2 = true;
>
> rule_info.sw_act.fltr_act = ICE_FWD_TO_VSI;
> @@ -129,13 +149,15 @@ ice_eswitch_br_fwd_rule_create(struct ice_hw *hw, int vsi_idx, int port_type,
>
> static struct ice_rule_query_data *
> ice_eswitch_br_guard_rule_create(struct ice_hw *hw, u16 vsi_idx,
> - const unsigned char *mac)
> + const unsigned char *mac, u16 vid)
> {
> struct ice_adv_rule_info rule_info = { 0 };
> struct ice_rule_query_data *rule;
> struct ice_adv_lkup_elem *list;
> - const u16 lkups_cnt = 1;
> int err = -ENOMEM;
> + u16 lkups_cnt;
> +
> + lkups_cnt = ice_eswitch_br_get_lkups_cnt(vid);
>
> rule = kzalloc(sizeof(*rule), GFP_KERNEL);
> if (!rule)
> @@ -149,6 +171,8 @@ ice_eswitch_br_guard_rule_create(struct ice_hw *hw, u16 vsi_idx,
> ether_addr_copy(list[0].h_u.eth_hdr.src_addr, mac);
> eth_broadcast_addr(list[0].m_u.eth_hdr.src_addr);
>
> + ice_eswitch_br_add_vlan_lkup(list, vid);
> +
> rule_info.allow_pass_l2 = true;
> rule_info.sw_act.vsi_handle = vsi_idx;
> rule_info.sw_act.fltr_act = ICE_NOP;
> @@ -172,7 +196,7 @@ ice_eswitch_br_guard_rule_create(struct ice_hw *hw, u16 vsi_idx,
>
> static struct ice_esw_br_flow *
> ice_eswitch_br_flow_create(struct device *dev, struct ice_hw *hw, int vsi_idx,
> - int port_type, const unsigned char *mac)
> + int port_type, const unsigned char *mac, u16 vid)
> {
> struct ice_rule_query_data *fwd_rule, *guard_rule;
> struct ice_esw_br_flow *flow;
> @@ -182,7 +206,8 @@ ice_eswitch_br_flow_create(struct device *dev, struct ice_hw *hw, int vsi_idx,
> if (!flow)
> return ERR_PTR(-ENOMEM);
>
> - fwd_rule = ice_eswitch_br_fwd_rule_create(hw, vsi_idx, port_type, mac);
> + fwd_rule = ice_eswitch_br_fwd_rule_create(hw, vsi_idx, port_type, mac,
> + vid);
> err = PTR_ERR_OR_ZERO(fwd_rule);
> if (err) {
> dev_err(dev, "Failed to create eswitch bridge %sgress forward rule, err: %d\n",
> @@ -191,7 +216,7 @@ ice_eswitch_br_flow_create(struct device *dev, struct ice_hw *hw, int vsi_idx,
> goto err_fwd_rule;
> }
>
> - guard_rule = ice_eswitch_br_guard_rule_create(hw, vsi_idx, mac);
> + guard_rule = ice_eswitch_br_guard_rule_create(hw, vsi_idx, mac, vid);
> err = PTR_ERR_OR_ZERO(guard_rule);
> if (err) {
> dev_err(dev, "Failed to create eswitch bridge %sgress guard rule, err: %d\n",
> @@ -245,6 +270,30 @@ ice_eswitch_br_flow_delete(struct ice_pf *pf, struct ice_esw_br_flow *flow)
> kfree(flow);
> }
>
> +static struct ice_esw_br_vlan *
> +ice_esw_br_port_vlan_lookup(struct ice_esw_br *bridge, u16 vsi_idx, u16 vid)
> +{
> + struct ice_pf *pf = bridge->br_offloads->pf;
> + struct device *dev = ice_pf_to_dev(pf);
> + struct ice_esw_br_port *port;
> + struct ice_esw_br_vlan *vlan;
> +
> + port = xa_load(&bridge->ports, vsi_idx);
> + if (!port) {
> + dev_info(dev, "Bridge port lookup failed (vsi=%u)\n", vsi_idx);
> + return ERR_PTR(-EINVAL);
> + }
> +
> + vlan = xa_load(&port->vlans, vid);
> + if (!vlan) {
> + dev_info(dev, "Bridge port vlan metadata lookup failed (vsi=%u)\n",
> + vsi_idx);
> + return ERR_PTR(-EINVAL);
> + }
> +
> + return vlan;
> +}
> +
> static void
> ice_eswitch_br_fdb_entry_delete(struct ice_esw_br *bridge,
> struct ice_esw_br_fdb_entry *fdb_entry)
> @@ -314,10 +363,25 @@ ice_eswitch_br_fdb_entry_create(struct net_device *netdev,
> struct device *dev = ice_pf_to_dev(pf);
> struct ice_esw_br_fdb_entry *fdb_entry;
> struct ice_esw_br_flow *flow;
> + struct ice_esw_br_vlan *vlan;
> struct ice_hw *hw = &pf->hw;
> unsigned long event;
> int err;
>
> + /* untagged filtering is not yet supported */
> + if (!(bridge->flags & ICE_ESWITCH_BR_VLAN_FILTERING) && vid)
> + return;
> +
> + if ((bridge->flags & ICE_ESWITCH_BR_VLAN_FILTERING)) {
> + vlan = ice_esw_br_port_vlan_lookup(bridge, br_port->vsi_idx,
> + vid);
> + if (IS_ERR(vlan)) {
> + dev_err(dev, "Failed to find vlan lookup, err: %ld\n",
> + PTR_ERR(vlan));
> + return;
> + }
> + }
> +
> fdb_entry = ice_eswitch_br_fdb_find(bridge, mac, vid);
> if (fdb_entry)
> ice_eswitch_br_fdb_entry_notify_and_cleanup(bridge, fdb_entry);
> @@ -329,7 +393,7 @@ ice_eswitch_br_fdb_entry_create(struct net_device *netdev,
> }
>
> flow = ice_eswitch_br_flow_create(dev, hw, br_port->vsi_idx,
> - br_port->type, mac);
> + br_port->type, mac, vid);
> if (IS_ERR(flow)) {
> err = PTR_ERR(flow);
> goto err_add_flow;
> @@ -488,6 +552,207 @@ ice_eswitch_br_switchdev_event(struct notifier_block *nb,
> return NOTIFY_DONE;
> }
>
> +static void ice_eswitch_br_fdb_flush(struct ice_esw_br *bridge)
> +{
> + struct ice_esw_br_fdb_entry *entry, *tmp;
> +
> + list_for_each_entry_safe(entry, tmp, &bridge->fdb_list, list)
> + ice_eswitch_br_fdb_entry_notify_and_cleanup(bridge, entry);
> +}
> +
> +static void
> +ice_eswitch_br_vlan_filtering_set(struct ice_esw_br *bridge, bool enable)
> +{
> + if (enable == !!(bridge->flags & ICE_ESWITCH_BR_VLAN_FILTERING))
> + return;
> +
> + ice_eswitch_br_fdb_flush(bridge);
> + if (enable)
> + bridge->flags |= ICE_ESWITCH_BR_VLAN_FILTERING;
> + else
> + bridge->flags &= ~ICE_ESWITCH_BR_VLAN_FILTERING;
> +}
> +
> +static void
> +ice_eswitch_br_vlan_cleanup(struct ice_esw_br_port *port,
> + struct ice_esw_br_vlan *vlan)
> +{
> + xa_erase(&port->vlans, vlan->vid);
> + kfree(vlan);
> +}
> +
> +static void ice_eswitch_br_port_vlans_flush(struct ice_esw_br_port *port)
> +{
> + struct ice_esw_br_vlan *vlan;
> + unsigned long index;
> +
> + xa_for_each(&port->vlans, index, vlan)
> + ice_eswitch_br_vlan_cleanup(port, vlan);
> +}
> +
> +static struct ice_esw_br_vlan *
> +ice_eswitch_br_vlan_create(u16 vid, u16 flags, struct ice_esw_br_port *port)
> +{
> + struct ice_esw_br_vlan *vlan;
> + int err;
> +
> + vlan = kzalloc(sizeof(*vlan), GFP_KERNEL);
> + if (!vlan)
> + return ERR_PTR(-ENOMEM);
> +
> + vlan->vid = vid;
> + vlan->flags = flags;
> +
> + err = xa_insert(&port->vlans, vlan->vid, vlan, GFP_KERNEL);
> + if (err) {
> + kfree(vlan);
> + return ERR_PTR(err);
> + }
> +
> + return vlan;
> +}
> +
> +static int
> +ice_eswitch_br_port_vlan_add(struct ice_esw_br *bridge, u16 vsi_idx, u16 vid,
> + u16 flags, struct netlink_ext_ack *extack)
> +{
> + struct ice_esw_br_port *port;
> + struct ice_esw_br_vlan *vlan;
> +
> + port = xa_load(&bridge->ports, vsi_idx);
> + if (!port)
> + return -EINVAL;
> +
> + vlan = xa_load(&port->vlans, vid);
> + if (vlan) {
> + if (vlan->flags == flags)
> + return 0;
> +
> + ice_eswitch_br_vlan_cleanup(port, vlan);
> + }
> +
> + vlan = ice_eswitch_br_vlan_create(vid, flags, port);
> + if (IS_ERR(vlan)) {
> + NL_SET_ERR_MSG_FMT_MOD(extack, "Failed to create VLAN entry, vid: %u, vsi: %u",
> + vid, vsi_idx);
> + return PTR_ERR(vlan);
> + }
> +
> + return 0;
> +}
> +
> +static void
> +ice_eswitch_br_port_vlan_del(struct ice_esw_br *bridge, u16 vsi_idx, u16 vid)
> +{
> + struct ice_esw_br_port *port;
> + struct ice_esw_br_vlan *vlan;
> +
> + port = xa_load(&bridge->ports, vsi_idx);
> + if (!port)
> + return;
> +
> + vlan = xa_load(&port->vlans, vid);
> + if (!vlan)
> + return;
> +
Don't you also need to cleanup all FDBs on the port matching the vid
being deleted here?
> + ice_eswitch_br_vlan_cleanup(port, vlan);
> +}
> +
> +static int
> +ice_eswitch_br_port_obj_add(struct net_device *netdev, const void *ctx,
> + const struct switchdev_obj *obj,
> + struct netlink_ext_ack *extack)
> +{
> + struct ice_esw_br_port *br_port = ice_eswitch_br_netdev_to_port(netdev);
> + struct switchdev_obj_port_vlan *vlan;
> + int err;
> +
> + if (!br_port)
> + return -EINVAL;
> +
> + switch (obj->id) {
> + case SWITCHDEV_OBJ_ID_PORT_VLAN:
> + vlan = SWITCHDEV_OBJ_PORT_VLAN(obj);
> + err = ice_eswitch_br_port_vlan_add(br_port->bridge,
> + br_port->vsi_idx, vlan->vid,
> + vlan->flags, extack);
> + return err;
> + default:
> + return -EOPNOTSUPP;
> + }
> +}
> +
> +static int
> +ice_eswitch_br_port_obj_del(struct net_device *netdev, const void *ctx,
> + const struct switchdev_obj *obj)
> +{
> + struct ice_esw_br_port *br_port = ice_eswitch_br_netdev_to_port(netdev);
> + struct switchdev_obj_port_vlan *vlan;
> +
> + if (!br_port)
> + return -EINVAL;
> +
> + switch (obj->id) {
> + case SWITCHDEV_OBJ_ID_PORT_VLAN:
> + vlan = SWITCHDEV_OBJ_PORT_VLAN(obj);
> + ice_eswitch_br_port_vlan_del(br_port->bridge, br_port->vsi_idx,
> + vlan->vid);
> + return 0;
> + default:
> + return -EOPNOTSUPP;
> + }
> +}
> +
> +static int
> +ice_eswitch_br_port_obj_attr_set(struct net_device *netdev, const void *ctx,
> + const struct switchdev_attr *attr,
> + struct netlink_ext_ack *extack)
> +{
> + struct ice_esw_br_port *br_port = ice_eswitch_br_netdev_to_port(netdev);
> +
> + if (!br_port)
> + return -EINVAL;
> +
> + switch (attr->id) {
> + case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
> + ice_eswitch_br_vlan_filtering_set(br_port->bridge,
> + attr->u.vlan_filtering);
> + return 0;
> + default:
> + return -EOPNOTSUPP;
> + }
> +}
> +
> +static int
> +ice_eswitch_br_event_blocking(struct notifier_block *nb, unsigned long event,
> + void *ptr)
> +{
> + struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
> + int err;
> +
> + switch (event) {
> + case SWITCHDEV_PORT_OBJ_ADD:
> + err = switchdev_handle_port_obj_add(dev, ptr,
> + ice_eswitch_br_is_dev_valid,
> + ice_eswitch_br_port_obj_add);
> + break;
> + case SWITCHDEV_PORT_OBJ_DEL:
> + err = switchdev_handle_port_obj_del(dev, ptr,
> + ice_eswitch_br_is_dev_valid,
> + ice_eswitch_br_port_obj_del);
> + break;
> + case SWITCHDEV_PORT_ATTR_SET:
> + err = switchdev_handle_port_attr_set(dev, ptr,
> + ice_eswitch_br_is_dev_valid,
> + ice_eswitch_br_port_obj_attr_set);
> + break;
> + default:
> + err = 0;
> + }
> +
> + return notifier_from_errno(err);
> +}
> +
> static void
> ice_eswitch_br_port_deinit(struct ice_esw_br *bridge,
> struct ice_esw_br_port *br_port)
> @@ -506,6 +771,7 @@ ice_eswitch_br_port_deinit(struct ice_esw_br *bridge,
> vsi->vf->repr->br_port = NULL;
>
> xa_erase(&bridge->ports, br_port->vsi_idx);
> + ice_eswitch_br_port_vlans_flush(br_port);
> kfree(br_port);
> }
>
> @@ -518,6 +784,8 @@ ice_eswitch_br_port_init(struct ice_esw_br *bridge)
> if (!br_port)
> return ERR_PTR(-ENOMEM);
>
> + xa_init(&br_port->vlans);
> +
> br_port->bridge = bridge;
>
> return br_port;
> @@ -817,6 +1085,7 @@ ice_eswitch_br_offloads_deinit(struct ice_pf *pf)
> return;
>
> unregister_netdevice_notifier(&br_offloads->netdev_nb);
> + unregister_switchdev_blocking_notifier(&br_offloads->switchdev_blk);
> unregister_switchdev_notifier(&br_offloads->switchdev_nb);
> destroy_workqueue(br_offloads->wq);
> /* Although notifier block is unregistered just before,
> @@ -860,6 +1129,15 @@ ice_eswitch_br_offloads_init(struct ice_pf *pf)
> goto err_reg_switchdev_nb;
> }
>
> + br_offloads->switchdev_blk.notifier_call =
> + ice_eswitch_br_event_blocking;
> + err = register_switchdev_blocking_notifier(&br_offloads->switchdev_blk);
> + if (err) {
> + dev_err(dev,
> + "Failed to register bridge blocking switchdev notifier\n");
> + goto err_reg_switchdev_blk;
> + }
> +
> br_offloads->netdev_nb.notifier_call = ice_eswitch_br_port_event;
> err = register_netdevice_notifier(&br_offloads->netdev_nb);
> if (err) {
> @@ -871,6 +1149,8 @@ ice_eswitch_br_offloads_init(struct ice_pf *pf)
> return 0;
>
> err_reg_netdev_nb:
> + unregister_switchdev_blocking_notifier(&br_offloads->switchdev_blk);
> +err_reg_switchdev_blk:
> unregister_switchdev_notifier(&br_offloads->switchdev_nb);
> err_reg_switchdev_nb:
> destroy_workqueue(br_offloads->wq);
> diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch_br.h b/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
> index 7afd00cdea9a..dd49b273451a 100644
> --- a/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
> +++ b/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
> @@ -42,6 +42,11 @@ struct ice_esw_br_port {
> struct ice_vsi *vsi;
> enum ice_esw_br_port_type type;
> u16 vsi_idx;
> + struct xarray vlans;
> +};
> +
> +enum {
> + ICE_ESWITCH_BR_VLAN_FILTERING = BIT(0),
> };
>
> struct ice_esw_br {
> @@ -52,12 +57,14 @@ struct ice_esw_br {
> struct list_head fdb_list;
>
> int ifindex;
> + u32 flags;
> };
>
> struct ice_esw_br_offloads {
> struct ice_pf *pf;
> struct ice_esw_br *bridge;
> struct notifier_block netdev_nb;
> + struct notifier_block switchdev_blk;
> struct notifier_block switchdev_nb;
>
> struct workqueue_struct *wq;
> @@ -71,6 +78,11 @@ struct ice_esw_br_fdb_work {
> unsigned long event;
> };
>
> +struct ice_esw_br_vlan {
> + u16 vid;
> + u16 flags;
> +};
> +
> #define ice_nb_to_br_offloads(nb, nb_name) \
> container_of(nb, \
> struct ice_esw_br_offloads, \
> @@ -81,6 +93,15 @@ struct ice_esw_br_fdb_work {
> struct ice_esw_br_fdb_work, \
> work)
>
> +static inline bool ice_eswitch_br_is_vid_valid(u16 vid)
> +{
> + /* In trunk VLAN mode, for untagged traffic the bridge sends requests
> + * to offload VLAN 1 with pvid and untagged flags set. Since these
> + * flags are not supported, add a MAC filter instead.
> + */
> + return vid > 1;
> +}
> +
> void
> ice_eswitch_br_offloads_deinit(struct ice_pf *pf);
> int
^ permalink raw reply [flat|nested] 29+ messages in thread* RE: [PATCH net-next 09/12] ice: Add VLAN FDB support in switchdev mode
2023-06-22 12:03 ` Vlad Buslov
@ 2023-06-22 13:06 ` Drewek, Wojciech
0 siblings, 0 replies; 29+ messages in thread
From: Drewek, Wojciech @ 2023-06-22 13:06 UTC (permalink / raw)
To: Vlad Buslov, Nguyen, Anthony L
Cc: davem@davemloft.net, kuba@kernel.org, pabeni@redhat.com,
edumazet@google.com, netdev@vger.kernel.org, Szycik, Marcin,
jiri@resnulli.us, ivecera, simon.horman@corigine.com,
Buvaneswaran, Sujai
> -----Original Message-----
> From: Vlad Buslov <vladbu@nvidia.com>
> Sent: czwartek, 22 czerwca 2023 14:04
> To: Nguyen, Anthony L <anthony.l.nguyen@intel.com>
> Cc: davem@davemloft.net; kuba@kernel.org; pabeni@redhat.com; edumazet@google.com; netdev@vger.kernel.org; Szycik, Marcin
> <marcin.szycik@intel.com>; jiri@resnulli.us; ivecera <ivecera@redhat.com>; simon.horman@corigine.com; Drewek, Wojciech
> <wojciech.drewek@intel.com>; Buvaneswaran, Sujai <sujai.buvaneswaran@intel.com>
> Subject: Re: [PATCH net-next 09/12] ice: Add VLAN FDB support in switchdev mode
>
> On Tue 20 Jun 2023 at 10:44, Tony Nguyen <anthony.l.nguyen@intel.com> wrote:
> > From: Marcin Szycik <marcin.szycik@intel.com>
> >
> > Add support for matching on VLAN tag in bridge offloads.
> > Currently only trunk mode is supported.
> >
> > To enable VLAN filtering (existing FDB entries will be deleted):
> > ip link set $BR type bridge vlan_filtering 1
> >
> > To add VLANs to bridge in trunk mode:
> > bridge vlan add dev $PF1 vid 110-111
> > bridge vlan add dev $VF1_PR vid 110-111
> >
> > Signed-off-by: Marcin Szycik <marcin.szycik@intel.com>
> > Signed-off-by: Wojciech Drewek <wojciech.drewek@intel.com>
> > Tested-by: Sujai Buvaneswaran <sujai.buvaneswaran@intel.com>
> > Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
> > ---
> > .../net/ethernet/intel/ice/ice_eswitch_br.c | 296 +++++++++++++++++-
> > .../net/ethernet/intel/ice/ice_eswitch_br.h | 21 ++
> > 2 files changed, 309 insertions(+), 8 deletions(-)
> >
> > diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch_br.c b/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
> > index 1e57ce7b22d3..805a6b2fd965 100644
> > --- a/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
> > +++ b/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
> > @@ -70,16 +70,34 @@ ice_eswitch_br_rule_delete(struct ice_hw *hw, struct ice_rule_query_data *rule)
> > return err;
> > }
> >
> > +static u16
> > +ice_eswitch_br_get_lkups_cnt(u16 vid)
> > +{
> > + return ice_eswitch_br_is_vid_valid(vid) ? 2 : 1;
> > +}
> > +
> > +static void
> > +ice_eswitch_br_add_vlan_lkup(struct ice_adv_lkup_elem *list, u16 vid)
> > +{
> > + if (ice_eswitch_br_is_vid_valid(vid)) {
> > + list[1].type = ICE_VLAN_OFOS;
> > + list[1].h_u.vlan_hdr.vlan = cpu_to_be16(vid & VLAN_VID_MASK);
> > + list[1].m_u.vlan_hdr.vlan = cpu_to_be16(0xFFFF);
> > + }
> > +}
> > +
> > static struct ice_rule_query_data *
> > ice_eswitch_br_fwd_rule_create(struct ice_hw *hw, int vsi_idx, int port_type,
> > - const unsigned char *mac)
> > + const unsigned char *mac, u16 vid)
> > {
> > struct ice_adv_rule_info rule_info = { 0 };
> > struct ice_rule_query_data *rule;
> > struct ice_adv_lkup_elem *list;
> > - u16 lkups_cnt = 1;
> > + u16 lkups_cnt;
> > int err;
> >
> > + lkups_cnt = ice_eswitch_br_get_lkups_cnt(vid);
> > +
> > rule = kzalloc(sizeof(*rule), GFP_KERNEL);
> > if (!rule)
> > return ERR_PTR(-ENOMEM);
> > @@ -107,6 +125,8 @@ ice_eswitch_br_fwd_rule_create(struct ice_hw *hw, int vsi_idx, int port_type,
> > ether_addr_copy(list[0].h_u.eth_hdr.dst_addr, mac);
> > eth_broadcast_addr(list[0].m_u.eth_hdr.dst_addr);
> >
> > + ice_eswitch_br_add_vlan_lkup(list, vid);
> > +
> > rule_info.need_pass_l2 = true;
> >
> > rule_info.sw_act.fltr_act = ICE_FWD_TO_VSI;
> > @@ -129,13 +149,15 @@ ice_eswitch_br_fwd_rule_create(struct ice_hw *hw, int vsi_idx, int port_type,
> >
> > static struct ice_rule_query_data *
> > ice_eswitch_br_guard_rule_create(struct ice_hw *hw, u16 vsi_idx,
> > - const unsigned char *mac)
> > + const unsigned char *mac, u16 vid)
> > {
> > struct ice_adv_rule_info rule_info = { 0 };
> > struct ice_rule_query_data *rule;
> > struct ice_adv_lkup_elem *list;
> > - const u16 lkups_cnt = 1;
> > int err = -ENOMEM;
> > + u16 lkups_cnt;
> > +
> > + lkups_cnt = ice_eswitch_br_get_lkups_cnt(vid);
> >
> > rule = kzalloc(sizeof(*rule), GFP_KERNEL);
> > if (!rule)
> > @@ -149,6 +171,8 @@ ice_eswitch_br_guard_rule_create(struct ice_hw *hw, u16 vsi_idx,
> > ether_addr_copy(list[0].h_u.eth_hdr.src_addr, mac);
> > eth_broadcast_addr(list[0].m_u.eth_hdr.src_addr);
> >
> > + ice_eswitch_br_add_vlan_lkup(list, vid);
> > +
> > rule_info.allow_pass_l2 = true;
> > rule_info.sw_act.vsi_handle = vsi_idx;
> > rule_info.sw_act.fltr_act = ICE_NOP;
> > @@ -172,7 +196,7 @@ ice_eswitch_br_guard_rule_create(struct ice_hw *hw, u16 vsi_idx,
> >
> > static struct ice_esw_br_flow *
> > ice_eswitch_br_flow_create(struct device *dev, struct ice_hw *hw, int vsi_idx,
> > - int port_type, const unsigned char *mac)
> > + int port_type, const unsigned char *mac, u16 vid)
> > {
> > struct ice_rule_query_data *fwd_rule, *guard_rule;
> > struct ice_esw_br_flow *flow;
> > @@ -182,7 +206,8 @@ ice_eswitch_br_flow_create(struct device *dev, struct ice_hw *hw, int vsi_idx,
> > if (!flow)
> > return ERR_PTR(-ENOMEM);
> >
> > - fwd_rule = ice_eswitch_br_fwd_rule_create(hw, vsi_idx, port_type, mac);
> > + fwd_rule = ice_eswitch_br_fwd_rule_create(hw, vsi_idx, port_type, mac,
> > + vid);
> > err = PTR_ERR_OR_ZERO(fwd_rule);
> > if (err) {
> > dev_err(dev, "Failed to create eswitch bridge %sgress forward rule, err: %d\n",
> > @@ -191,7 +216,7 @@ ice_eswitch_br_flow_create(struct device *dev, struct ice_hw *hw, int vsi_idx,
> > goto err_fwd_rule;
> > }
> >
> > - guard_rule = ice_eswitch_br_guard_rule_create(hw, vsi_idx, mac);
> > + guard_rule = ice_eswitch_br_guard_rule_create(hw, vsi_idx, mac, vid);
> > err = PTR_ERR_OR_ZERO(guard_rule);
> > if (err) {
> > dev_err(dev, "Failed to create eswitch bridge %sgress guard rule, err: %d\n",
> > @@ -245,6 +270,30 @@ ice_eswitch_br_flow_delete(struct ice_pf *pf, struct ice_esw_br_flow *flow)
> > kfree(flow);
> > }
> >
> > +static struct ice_esw_br_vlan *
> > +ice_esw_br_port_vlan_lookup(struct ice_esw_br *bridge, u16 vsi_idx, u16 vid)
> > +{
> > + struct ice_pf *pf = bridge->br_offloads->pf;
> > + struct device *dev = ice_pf_to_dev(pf);
> > + struct ice_esw_br_port *port;
> > + struct ice_esw_br_vlan *vlan;
> > +
> > + port = xa_load(&bridge->ports, vsi_idx);
> > + if (!port) {
> > + dev_info(dev, "Bridge port lookup failed (vsi=%u)\n", vsi_idx);
> > + return ERR_PTR(-EINVAL);
> > + }
> > +
> > + vlan = xa_load(&port->vlans, vid);
> > + if (!vlan) {
> > + dev_info(dev, "Bridge port vlan metadata lookup failed (vsi=%u)\n",
> > + vsi_idx);
> > + return ERR_PTR(-EINVAL);
> > + }
> > +
> > + return vlan;
> > +}
> > +
> > static void
> > ice_eswitch_br_fdb_entry_delete(struct ice_esw_br *bridge,
> > struct ice_esw_br_fdb_entry *fdb_entry)
> > @@ -314,10 +363,25 @@ ice_eswitch_br_fdb_entry_create(struct net_device *netdev,
> > struct device *dev = ice_pf_to_dev(pf);
> > struct ice_esw_br_fdb_entry *fdb_entry;
> > struct ice_esw_br_flow *flow;
> > + struct ice_esw_br_vlan *vlan;
> > struct ice_hw *hw = &pf->hw;
> > unsigned long event;
> > int err;
> >
> > + /* untagged filtering is not yet supported */
> > + if (!(bridge->flags & ICE_ESWITCH_BR_VLAN_FILTERING) && vid)
> > + return;
> > +
> > + if ((bridge->flags & ICE_ESWITCH_BR_VLAN_FILTERING)) {
> > + vlan = ice_esw_br_port_vlan_lookup(bridge, br_port->vsi_idx,
> > + vid);
> > + if (IS_ERR(vlan)) {
> > + dev_err(dev, "Failed to find vlan lookup, err: %ld\n",
> > + PTR_ERR(vlan));
> > + return;
> > + }
> > + }
> > +
> > fdb_entry = ice_eswitch_br_fdb_find(bridge, mac, vid);
> > if (fdb_entry)
> > ice_eswitch_br_fdb_entry_notify_and_cleanup(bridge, fdb_entry);
> > @@ -329,7 +393,7 @@ ice_eswitch_br_fdb_entry_create(struct net_device *netdev,
> > }
> >
> > flow = ice_eswitch_br_flow_create(dev, hw, br_port->vsi_idx,
> > - br_port->type, mac);
> > + br_port->type, mac, vid);
> > if (IS_ERR(flow)) {
> > err = PTR_ERR(flow);
> > goto err_add_flow;
> > @@ -488,6 +552,207 @@ ice_eswitch_br_switchdev_event(struct notifier_block *nb,
> > return NOTIFY_DONE;
> > }
> >
> > +static void ice_eswitch_br_fdb_flush(struct ice_esw_br *bridge)
> > +{
> > + struct ice_esw_br_fdb_entry *entry, *tmp;
> > +
> > + list_for_each_entry_safe(entry, tmp, &bridge->fdb_list, list)
> > + ice_eswitch_br_fdb_entry_notify_and_cleanup(bridge, entry);
> > +}
> > +
> > +static void
> > +ice_eswitch_br_vlan_filtering_set(struct ice_esw_br *bridge, bool enable)
> > +{
> > + if (enable == !!(bridge->flags & ICE_ESWITCH_BR_VLAN_FILTERING))
> > + return;
> > +
> > + ice_eswitch_br_fdb_flush(bridge);
> > + if (enable)
> > + bridge->flags |= ICE_ESWITCH_BR_VLAN_FILTERING;
> > + else
> > + bridge->flags &= ~ICE_ESWITCH_BR_VLAN_FILTERING;
> > +}
> > +
> > +static void
> > +ice_eswitch_br_vlan_cleanup(struct ice_esw_br_port *port,
> > + struct ice_esw_br_vlan *vlan)
> > +{
> > + xa_erase(&port->vlans, vlan->vid);
> > + kfree(vlan);
> > +}
> > +
> > +static void ice_eswitch_br_port_vlans_flush(struct ice_esw_br_port *port)
> > +{
> > + struct ice_esw_br_vlan *vlan;
> > + unsigned long index;
> > +
> > + xa_for_each(&port->vlans, index, vlan)
> > + ice_eswitch_br_vlan_cleanup(port, vlan);
> > +}
> > +
> > +static struct ice_esw_br_vlan *
> > +ice_eswitch_br_vlan_create(u16 vid, u16 flags, struct ice_esw_br_port *port)
> > +{
> > + struct ice_esw_br_vlan *vlan;
> > + int err;
> > +
> > + vlan = kzalloc(sizeof(*vlan), GFP_KERNEL);
> > + if (!vlan)
> > + return ERR_PTR(-ENOMEM);
> > +
> > + vlan->vid = vid;
> > + vlan->flags = flags;
> > +
> > + err = xa_insert(&port->vlans, vlan->vid, vlan, GFP_KERNEL);
> > + if (err) {
> > + kfree(vlan);
> > + return ERR_PTR(err);
> > + }
> > +
> > + return vlan;
> > +}
> > +
> > +static int
> > +ice_eswitch_br_port_vlan_add(struct ice_esw_br *bridge, u16 vsi_idx, u16 vid,
> > + u16 flags, struct netlink_ext_ack *extack)
> > +{
> > + struct ice_esw_br_port *port;
> > + struct ice_esw_br_vlan *vlan;
> > +
> > + port = xa_load(&bridge->ports, vsi_idx);
> > + if (!port)
> > + return -EINVAL;
> > +
> > + vlan = xa_load(&port->vlans, vid);
> > + if (vlan) {
> > + if (vlan->flags == flags)
> > + return 0;
> > +
> > + ice_eswitch_br_vlan_cleanup(port, vlan);
> > + }
> > +
> > + vlan = ice_eswitch_br_vlan_create(vid, flags, port);
> > + if (IS_ERR(vlan)) {
> > + NL_SET_ERR_MSG_FMT_MOD(extack, "Failed to create VLAN entry, vid: %u, vsi: %u",
> > + vid, vsi_idx);
> > + return PTR_ERR(vlan);
> > + }
> > +
> > + return 0;
> > +}
> > +
> > +static void
> > +ice_eswitch_br_port_vlan_del(struct ice_esw_br *bridge, u16 vsi_idx, u16 vid)
> > +{
> > + struct ice_esw_br_port *port;
> > + struct ice_esw_br_vlan *vlan;
> > +
> > + port = xa_load(&bridge->ports, vsi_idx);
> > + if (!port)
> > + return;
> > +
> > + vlan = xa_load(&port->vlans, vid);
> > + if (!vlan)
> > + return;
> > +
>
> Don't you also need to cleanup all FDBs on the port matching the vid
> being deleted here?
Correct, we will add it to the next PR.
>
> > + ice_eswitch_br_vlan_cleanup(port, vlan);
> > +}
> > +
> > +static int
> > +ice_eswitch_br_port_obj_add(struct net_device *netdev, const void *ctx,
> > + const struct switchdev_obj *obj,
> > + struct netlink_ext_ack *extack)
> > +{
> > + struct ice_esw_br_port *br_port = ice_eswitch_br_netdev_to_port(netdev);
> > + struct switchdev_obj_port_vlan *vlan;
> > + int err;
> > +
> > + if (!br_port)
> > + return -EINVAL;
> > +
> > + switch (obj->id) {
> > + case SWITCHDEV_OBJ_ID_PORT_VLAN:
> > + vlan = SWITCHDEV_OBJ_PORT_VLAN(obj);
> > + err = ice_eswitch_br_port_vlan_add(br_port->bridge,
> > + br_port->vsi_idx, vlan->vid,
> > + vlan->flags, extack);
> > + return err;
> > + default:
> > + return -EOPNOTSUPP;
> > + }
> > +}
> > +
> > +static int
> > +ice_eswitch_br_port_obj_del(struct net_device *netdev, const void *ctx,
> > + const struct switchdev_obj *obj)
> > +{
> > + struct ice_esw_br_port *br_port = ice_eswitch_br_netdev_to_port(netdev);
> > + struct switchdev_obj_port_vlan *vlan;
> > +
> > + if (!br_port)
> > + return -EINVAL;
> > +
> > + switch (obj->id) {
> > + case SWITCHDEV_OBJ_ID_PORT_VLAN:
> > + vlan = SWITCHDEV_OBJ_PORT_VLAN(obj);
> > + ice_eswitch_br_port_vlan_del(br_port->bridge, br_port->vsi_idx,
> > + vlan->vid);
> > + return 0;
> > + default:
> > + return -EOPNOTSUPP;
> > + }
> > +}
> > +
> > +static int
> > +ice_eswitch_br_port_obj_attr_set(struct net_device *netdev, const void *ctx,
> > + const struct switchdev_attr *attr,
> > + struct netlink_ext_ack *extack)
> > +{
> > + struct ice_esw_br_port *br_port = ice_eswitch_br_netdev_to_port(netdev);
> > +
> > + if (!br_port)
> > + return -EINVAL;
> > +
> > + switch (attr->id) {
> > + case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
> > + ice_eswitch_br_vlan_filtering_set(br_port->bridge,
> > + attr->u.vlan_filtering);
> > + return 0;
> > + default:
> > + return -EOPNOTSUPP;
> > + }
> > +}
> > +
> > +static int
> > +ice_eswitch_br_event_blocking(struct notifier_block *nb, unsigned long event,
> > + void *ptr)
> > +{
> > + struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
> > + int err;
> > +
> > + switch (event) {
> > + case SWITCHDEV_PORT_OBJ_ADD:
> > + err = switchdev_handle_port_obj_add(dev, ptr,
> > + ice_eswitch_br_is_dev_valid,
> > + ice_eswitch_br_port_obj_add);
> > + break;
> > + case SWITCHDEV_PORT_OBJ_DEL:
> > + err = switchdev_handle_port_obj_del(dev, ptr,
> > + ice_eswitch_br_is_dev_valid,
> > + ice_eswitch_br_port_obj_del);
> > + break;
> > + case SWITCHDEV_PORT_ATTR_SET:
> > + err = switchdev_handle_port_attr_set(dev, ptr,
> > + ice_eswitch_br_is_dev_valid,
> > + ice_eswitch_br_port_obj_attr_set);
> > + break;
> > + default:
> > + err = 0;
> > + }
> > +
> > + return notifier_from_errno(err);
> > +}
> > +
> > static void
> > ice_eswitch_br_port_deinit(struct ice_esw_br *bridge,
> > struct ice_esw_br_port *br_port)
> > @@ -506,6 +771,7 @@ ice_eswitch_br_port_deinit(struct ice_esw_br *bridge,
> > vsi->vf->repr->br_port = NULL;
> >
> > xa_erase(&bridge->ports, br_port->vsi_idx);
> > + ice_eswitch_br_port_vlans_flush(br_port);
> > kfree(br_port);
> > }
> >
> > @@ -518,6 +784,8 @@ ice_eswitch_br_port_init(struct ice_esw_br *bridge)
> > if (!br_port)
> > return ERR_PTR(-ENOMEM);
> >
> > + xa_init(&br_port->vlans);
> > +
> > br_port->bridge = bridge;
> >
> > return br_port;
> > @@ -817,6 +1085,7 @@ ice_eswitch_br_offloads_deinit(struct ice_pf *pf)
> > return;
> >
> > unregister_netdevice_notifier(&br_offloads->netdev_nb);
> > + unregister_switchdev_blocking_notifier(&br_offloads->switchdev_blk);
> > unregister_switchdev_notifier(&br_offloads->switchdev_nb);
> > destroy_workqueue(br_offloads->wq);
> > /* Although notifier block is unregistered just before,
> > @@ -860,6 +1129,15 @@ ice_eswitch_br_offloads_init(struct ice_pf *pf)
> > goto err_reg_switchdev_nb;
> > }
> >
> > + br_offloads->switchdev_blk.notifier_call =
> > + ice_eswitch_br_event_blocking;
> > + err = register_switchdev_blocking_notifier(&br_offloads->switchdev_blk);
> > + if (err) {
> > + dev_err(dev,
> > + "Failed to register bridge blocking switchdev notifier\n");
> > + goto err_reg_switchdev_blk;
> > + }
> > +
> > br_offloads->netdev_nb.notifier_call = ice_eswitch_br_port_event;
> > err = register_netdevice_notifier(&br_offloads->netdev_nb);
> > if (err) {
> > @@ -871,6 +1149,8 @@ ice_eswitch_br_offloads_init(struct ice_pf *pf)
> > return 0;
> >
> > err_reg_netdev_nb:
> > + unregister_switchdev_blocking_notifier(&br_offloads->switchdev_blk);
> > +err_reg_switchdev_blk:
> > unregister_switchdev_notifier(&br_offloads->switchdev_nb);
> > err_reg_switchdev_nb:
> > destroy_workqueue(br_offloads->wq);
> > diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch_br.h b/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
> > index 7afd00cdea9a..dd49b273451a 100644
> > --- a/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
> > +++ b/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
> > @@ -42,6 +42,11 @@ struct ice_esw_br_port {
> > struct ice_vsi *vsi;
> > enum ice_esw_br_port_type type;
> > u16 vsi_idx;
> > + struct xarray vlans;
> > +};
> > +
> > +enum {
> > + ICE_ESWITCH_BR_VLAN_FILTERING = BIT(0),
> > };
> >
> > struct ice_esw_br {
> > @@ -52,12 +57,14 @@ struct ice_esw_br {
> > struct list_head fdb_list;
> >
> > int ifindex;
> > + u32 flags;
> > };
> >
> > struct ice_esw_br_offloads {
> > struct ice_pf *pf;
> > struct ice_esw_br *bridge;
> > struct notifier_block netdev_nb;
> > + struct notifier_block switchdev_blk;
> > struct notifier_block switchdev_nb;
> >
> > struct workqueue_struct *wq;
> > @@ -71,6 +78,11 @@ struct ice_esw_br_fdb_work {
> > unsigned long event;
> > };
> >
> > +struct ice_esw_br_vlan {
> > + u16 vid;
> > + u16 flags;
> > +};
> > +
> > #define ice_nb_to_br_offloads(nb, nb_name) \
> > container_of(nb, \
> > struct ice_esw_br_offloads, \
> > @@ -81,6 +93,15 @@ struct ice_esw_br_fdb_work {
> > struct ice_esw_br_fdb_work, \
> > work)
> >
> > +static inline bool ice_eswitch_br_is_vid_valid(u16 vid)
> > +{
> > + /* In trunk VLAN mode, for untagged traffic the bridge sends requests
> > + * to offload VLAN 1 with pvid and untagged flags set. Since these
> > + * flags are not supported, add a MAC filter instead.
> > + */
> > + return vid > 1;
> > +}
> > +
> > void
> > ice_eswitch_br_offloads_deinit(struct ice_pf *pf);
> > int
^ permalink raw reply [flat|nested] 29+ messages in thread
* [PATCH net-next 10/12] ice: implement bridge port vlan
2023-06-20 17:44 [PATCH net-next 00/12][pull request] ice: switchdev bridge offload Tony Nguyen
` (8 preceding siblings ...)
2023-06-20 17:44 ` [PATCH net-next 09/12] ice: Add VLAN FDB support in switchdev mode Tony Nguyen
@ 2023-06-20 17:44 ` Tony Nguyen
2023-06-22 12:07 ` Vlad Buslov
2023-06-20 17:44 ` [PATCH net-next 11/12] ice: implement static version of aging Tony Nguyen
` (2 subsequent siblings)
12 siblings, 1 reply; 29+ messages in thread
From: Tony Nguyen @ 2023-06-20 17:44 UTC (permalink / raw)
To: davem, kuba, pabeni, edumazet, netdev
Cc: Michal Swiatkowski, anthony.l.nguyen, jiri, ivecera, simon.horman,
Wojciech Drewek, Sujai Buvaneswaran
From: Michal Swiatkowski <michal.swiatkowski@linux.intel.com>
Port VLAN in this case means push and pop VLAN action on specific vid.
There are a few limitation in hardware:
- push and pop can't be used separately
- if port VLAN is used there can't be any trunk VLANs, because pop
action is done on all traffic received by VSI in port VLAN mode
- port VLAN mode on uplink port isn't supported
Reflect these limitations in code using dev_info to inform the user
about unsupported configuration.
In bridge mode there is a need to configure port vlan without resetting
VFs. To do that implement ice_port_vlan_on/off() functions. They are
only configuring correct vlan_ops to allow setting port vlan.
We also need to clear port vlan without resetting the VF which is not
supported right now. Change it by implementing clear_port_vlan ops.
As previous VLAN configuration isn't always the same, store current
config while creating port vlan and restore it in clear function.
Configuration steps:
- configure switchdev with bridge
- #bridge vlan add dev eth0 vid 120 pvid untagged
- #bridge vlan add dev eth1 vid 120 pvid untagged
- ping from VF0 to VF1
Reviewed-by: Simon Horman <simon.horman@corigine.com>
Signed-off-by: Michal Swiatkowski <michal.swiatkowski@linux.intel.com>
Signed-off-by: Wojciech Drewek <wojciech.drewek@intel.com>
Tested-by: Sujai Buvaneswaran <sujai.buvaneswaran@intel.com>
Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
---
drivers/net/ethernet/intel/ice/ice.h | 1 +
.../net/ethernet/intel/ice/ice_eswitch_br.c | 90 ++++++++-
.../net/ethernet/intel/ice/ice_eswitch_br.h | 1 +
.../ethernet/intel/ice/ice_vf_vsi_vlan_ops.c | 186 ++++++++++--------
.../ethernet/intel/ice/ice_vf_vsi_vlan_ops.h | 4 +
.../net/ethernet/intel/ice/ice_vsi_vlan_lib.c | 84 +++++++-
.../net/ethernet/intel/ice/ice_vsi_vlan_lib.h | 8 +
.../net/ethernet/intel/ice/ice_vsi_vlan_ops.h | 1 +
8 files changed, 285 insertions(+), 90 deletions(-)
diff --git a/drivers/net/ethernet/intel/ice/ice.h b/drivers/net/ethernet/intel/ice/ice.h
index 8918a4b836a2..9109006336f0 100644
--- a/drivers/net/ethernet/intel/ice/ice.h
+++ b/drivers/net/ethernet/intel/ice/ice.h
@@ -370,6 +370,7 @@ struct ice_vsi {
u16 rx_buf_len;
struct ice_aqc_vsi_props info; /* VSI properties */
+ struct ice_vsi_vlan_info vlan_info; /* vlan config to be restored */
/* VSI stats */
struct rtnl_link_stats64 net_stats;
diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch_br.c b/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
index 805a6b2fd965..d7e96241e8af 100644
--- a/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
+++ b/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
@@ -5,6 +5,8 @@
#include "ice_eswitch_br.h"
#include "ice_repr.h"
#include "ice_switch.h"
+#include "ice_vlan.h"
+#include "ice_vf_vsi_vlan_ops.h"
static const struct rhashtable_params ice_fdb_ht_params = {
.key_offset = offsetof(struct ice_esw_br_fdb_entry, data),
@@ -573,11 +575,27 @@ ice_eswitch_br_vlan_filtering_set(struct ice_esw_br *bridge, bool enable)
bridge->flags &= ~ICE_ESWITCH_BR_VLAN_FILTERING;
}
+static void
+ice_eswitch_br_clear_pvid(struct ice_esw_br_port *port)
+{
+ struct ice_vsi_vlan_ops *vlan_ops;
+
+ vlan_ops = ice_get_compat_vsi_vlan_ops(port->vsi);
+
+ vlan_ops->clear_port_vlan(port->vsi);
+
+ ice_vf_vsi_disable_port_vlan(port->vsi);
+
+ port->pvid = 0;
+}
+
static void
ice_eswitch_br_vlan_cleanup(struct ice_esw_br_port *port,
struct ice_esw_br_vlan *vlan)
{
xa_erase(&port->vlans, vlan->vid);
+ if (port->pvid == vlan->vid)
+ ice_eswitch_br_clear_pvid(port);
kfree(vlan);
}
@@ -590,9 +608,50 @@ static void ice_eswitch_br_port_vlans_flush(struct ice_esw_br_port *port)
ice_eswitch_br_vlan_cleanup(port, vlan);
}
+static int
+ice_eswitch_br_set_pvid(struct ice_esw_br_port *port,
+ struct ice_esw_br_vlan *vlan)
+{
+ struct ice_vlan port_vlan = ICE_VLAN(ETH_P_8021Q, vlan->vid, 0);
+ struct device *dev = ice_pf_to_dev(port->vsi->back);
+ struct ice_vsi_vlan_ops *vlan_ops;
+ int err;
+
+ if (port->pvid == vlan->vid || vlan->vid == 1)
+ return 0;
+
+ /* Setting port vlan on uplink isn't supported by hw */
+ if (port->type == ICE_ESWITCH_BR_UPLINK_PORT)
+ return -EOPNOTSUPP;
+
+ if (port->pvid) {
+ dev_info(dev,
+ "Port VLAN (vsi=%u, vid=%u) already exists on the port, remove it before adding new one\n",
+ port->vsi_idx, port->pvid);
+ return -EEXIST;
+ }
+
+ ice_vf_vsi_enable_port_vlan(port->vsi);
+
+ vlan_ops = ice_get_compat_vsi_vlan_ops(port->vsi);
+ err = vlan_ops->set_port_vlan(port->vsi, &port_vlan);
+ if (err)
+ return err;
+
+ err = vlan_ops->add_vlan(port->vsi, &port_vlan);
+ if (err)
+ return err;
+
+ ice_eswitch_br_port_vlans_flush(port);
+ port->pvid = vlan->vid;
+
+ return 0;
+}
+
static struct ice_esw_br_vlan *
ice_eswitch_br_vlan_create(u16 vid, u16 flags, struct ice_esw_br_port *port)
{
+ struct device *dev = ice_pf_to_dev(port->vsi->back);
struct ice_esw_br_vlan *vlan;
int err;
@@ -602,14 +661,30 @@ ice_eswitch_br_vlan_create(u16 vid, u16 flags, struct ice_esw_br_port *port)
vlan->vid = vid;
vlan->flags = flags;
+ if ((flags & BRIDGE_VLAN_INFO_PVID) &&
+ (flags & BRIDGE_VLAN_INFO_UNTAGGED)) {
+ err = ice_eswitch_br_set_pvid(port, vlan);
+ if (err)
+ goto err_set_pvid;
+ } else if ((flags & BRIDGE_VLAN_INFO_PVID) ||
+ (flags & BRIDGE_VLAN_INFO_UNTAGGED)) {
+ dev_info(dev, "VLAN push and pop are supported only simultaneously\n");
+ err = -EOPNOTSUPP;
+ goto err_set_pvid;
+ }
err = xa_insert(&port->vlans, vlan->vid, vlan, GFP_KERNEL);
- if (err) {
- kfree(vlan);
- return ERR_PTR(err);
- }
+ if (err)
+ goto err_insert;
return vlan;
+
+err_insert:
+ if (port->pvid)
+ ice_eswitch_br_clear_pvid(port);
+err_set_pvid:
+ kfree(vlan);
+ return ERR_PTR(err);
}
static int
@@ -623,6 +698,13 @@ ice_eswitch_br_port_vlan_add(struct ice_esw_br *bridge, u16 vsi_idx, u16 vid,
if (!port)
return -EINVAL;
+ if (port->pvid) {
+ dev_info(ice_pf_to_dev(port->vsi->back),
+ "Port VLAN (vsi=%u, vid=%d) exists on the port, remove it to add trunk VLANs\n",
+ port->vsi_idx, port->pvid);
+ return -EEXIST;
+ }
+
vlan = xa_load(&port->vlans, vid);
if (vlan) {
if (vlan->flags == flags)
diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch_br.h b/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
index dd49b273451a..be4e6f096d55 100644
--- a/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
+++ b/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
@@ -42,6 +42,7 @@ struct ice_esw_br_port {
struct ice_vsi *vsi;
enum ice_esw_br_port_type type;
u16 vsi_idx;
+ u16 pvid;
struct xarray vlans;
};
diff --git a/drivers/net/ethernet/intel/ice/ice_vf_vsi_vlan_ops.c b/drivers/net/ethernet/intel/ice/ice_vf_vsi_vlan_ops.c
index b1ffb81893d4..d7b10dc67f03 100644
--- a/drivers/net/ethernet/intel/ice/ice_vf_vsi_vlan_ops.c
+++ b/drivers/net/ethernet/intel/ice/ice_vf_vsi_vlan_ops.c
@@ -21,6 +21,99 @@ noop_vlan(struct ice_vsi __always_unused *vsi)
return 0;
}
+static void ice_port_vlan_on(struct ice_vsi *vsi)
+{
+ struct ice_vsi_vlan_ops *vlan_ops;
+ struct ice_pf *pf = vsi->back;
+
+ if (ice_is_dvm_ena(&pf->hw)) {
+ vlan_ops = &vsi->outer_vlan_ops;
+
+ /* setup outer VLAN ops */
+ vlan_ops->set_port_vlan = ice_vsi_set_outer_port_vlan;
+ vlan_ops->clear_port_vlan = ice_vsi_clear_outer_port_vlan;
+ vlan_ops->clear_port_vlan = ice_vsi_clear_outer_port_vlan;
+
+ /* setup inner VLAN ops */
+ vlan_ops = &vsi->inner_vlan_ops;
+ vlan_ops->add_vlan = noop_vlan_arg;
+ vlan_ops->del_vlan = noop_vlan_arg;
+ vlan_ops->ena_stripping = ice_vsi_ena_inner_stripping;
+ vlan_ops->dis_stripping = ice_vsi_dis_inner_stripping;
+ vlan_ops->ena_insertion = ice_vsi_ena_inner_insertion;
+ vlan_ops->dis_insertion = ice_vsi_dis_inner_insertion;
+ } else {
+ vlan_ops = &vsi->inner_vlan_ops;
+
+ vlan_ops->set_port_vlan = ice_vsi_set_inner_port_vlan;
+ vlan_ops->clear_port_vlan = ice_vsi_clear_inner_port_vlan;
+ vlan_ops->clear_port_vlan = ice_vsi_clear_inner_port_vlan;
+ }
+ vlan_ops->ena_rx_filtering = ice_vsi_ena_rx_vlan_filtering;
+}
+
+static void ice_port_vlan_off(struct ice_vsi *vsi)
+{
+ struct ice_vsi_vlan_ops *vlan_ops;
+ struct ice_pf *pf = vsi->back;
+
+ /* setup inner VLAN ops */
+ vlan_ops = &vsi->inner_vlan_ops;
+
+ vlan_ops->ena_stripping = ice_vsi_ena_inner_stripping;
+ vlan_ops->dis_stripping = ice_vsi_dis_inner_stripping;
+ vlan_ops->ena_insertion = ice_vsi_ena_inner_insertion;
+ vlan_ops->dis_insertion = ice_vsi_dis_inner_insertion;
+
+ if (ice_is_dvm_ena(&pf->hw)) {
+ vlan_ops = &vsi->outer_vlan_ops;
+
+ vlan_ops->del_vlan = ice_vsi_del_vlan;
+ vlan_ops->ena_stripping = ice_vsi_ena_outer_stripping;
+ vlan_ops->dis_stripping = ice_vsi_dis_outer_stripping;
+ vlan_ops->ena_insertion = ice_vsi_ena_outer_insertion;
+ vlan_ops->dis_insertion = ice_vsi_dis_outer_insertion;
+ } else {
+ vlan_ops->del_vlan = ice_vsi_del_vlan;
+ }
+
+ if (!test_bit(ICE_FLAG_VF_VLAN_PRUNING, pf->flags))
+ vlan_ops->ena_rx_filtering = noop_vlan;
+ else
+ vlan_ops->ena_rx_filtering =
+ ice_vsi_ena_rx_vlan_filtering;
+}
+
+/**
+ * ice_vf_vsi_enable_port_vlan - Set VSI VLAN ops to support port VLAN
+ * @vsi: VF's VSI being configured
+ *
+ * The function won't create port VLAN, it only allows to create port VLAN
+ * using VLAN ops on the VF VSI.
+ */
+void ice_vf_vsi_enable_port_vlan(struct ice_vsi *vsi)
+{
+ if (WARN_ON_ONCE(!vsi->vf))
+ return;
+
+ ice_port_vlan_on(vsi);
+}
+
+/**
+ * ice_vf_vsi_disable_port_vlan - Clear VSI support for creating port VLAN
+ * @vsi: VF's VSI being configured
+ *
+ * The function should be called after removing port VLAN on VSI
+ * (using VLAN ops)
+ */
+void ice_vf_vsi_disable_port_vlan(struct ice_vsi *vsi)
+{
+ if (WARN_ON_ONCE(!vsi->vf))
+ return;
+
+ ice_port_vlan_off(vsi);
+}
+
/**
* ice_vf_vsi_init_vlan_ops - Initialize default VSI VLAN ops for VF VSI
* @vsi: VF's VSI being configured
@@ -39,91 +132,18 @@ void ice_vf_vsi_init_vlan_ops(struct ice_vsi *vsi)
if (WARN_ON(!vf))
return;
- if (ice_is_dvm_ena(&pf->hw)) {
- vlan_ops = &vsi->outer_vlan_ops;
+ if (ice_vf_is_port_vlan_ena(vf))
+ ice_port_vlan_on(vsi);
+ else
+ ice_port_vlan_off(vsi);
- /* outer VLAN ops regardless of port VLAN config */
- vlan_ops->add_vlan = ice_vsi_add_vlan;
- vlan_ops->ena_tx_filtering = ice_vsi_ena_tx_vlan_filtering;
- vlan_ops->dis_tx_filtering = ice_vsi_dis_tx_vlan_filtering;
-
- if (ice_vf_is_port_vlan_ena(vf)) {
- /* setup outer VLAN ops */
- vlan_ops->set_port_vlan = ice_vsi_set_outer_port_vlan;
- /* all Rx traffic should be in the domain of the
- * assigned port VLAN, so prevent disabling Rx VLAN
- * filtering
- */
- vlan_ops->dis_rx_filtering = noop_vlan;
- vlan_ops->ena_rx_filtering =
- ice_vsi_ena_rx_vlan_filtering;
-
- /* setup inner VLAN ops */
- vlan_ops = &vsi->inner_vlan_ops;
- vlan_ops->add_vlan = noop_vlan_arg;
- vlan_ops->del_vlan = noop_vlan_arg;
- vlan_ops->ena_stripping = ice_vsi_ena_inner_stripping;
- vlan_ops->dis_stripping = ice_vsi_dis_inner_stripping;
- vlan_ops->ena_insertion = ice_vsi_ena_inner_insertion;
- vlan_ops->dis_insertion = ice_vsi_dis_inner_insertion;
- } else {
- vlan_ops->dis_rx_filtering =
- ice_vsi_dis_rx_vlan_filtering;
-
- if (!test_bit(ICE_FLAG_VF_VLAN_PRUNING, pf->flags))
- vlan_ops->ena_rx_filtering = noop_vlan;
- else
- vlan_ops->ena_rx_filtering =
- ice_vsi_ena_rx_vlan_filtering;
-
- vlan_ops->del_vlan = ice_vsi_del_vlan;
- vlan_ops->ena_stripping = ice_vsi_ena_outer_stripping;
- vlan_ops->dis_stripping = ice_vsi_dis_outer_stripping;
- vlan_ops->ena_insertion = ice_vsi_ena_outer_insertion;
- vlan_ops->dis_insertion = ice_vsi_dis_outer_insertion;
-
- /* setup inner VLAN ops */
- vlan_ops = &vsi->inner_vlan_ops;
-
- vlan_ops->ena_stripping = ice_vsi_ena_inner_stripping;
- vlan_ops->dis_stripping = ice_vsi_dis_inner_stripping;
- vlan_ops->ena_insertion = ice_vsi_ena_inner_insertion;
- vlan_ops->dis_insertion = ice_vsi_dis_inner_insertion;
- }
- } else {
- vlan_ops = &vsi->inner_vlan_ops;
+ vlan_ops = ice_is_dvm_ena(&pf->hw) ?
+ &vsi->outer_vlan_ops : &vsi->inner_vlan_ops;
- /* inner VLAN ops regardless of port VLAN config */
- vlan_ops->add_vlan = ice_vsi_add_vlan;
- vlan_ops->dis_rx_filtering = ice_vsi_dis_rx_vlan_filtering;
- vlan_ops->ena_tx_filtering = ice_vsi_ena_tx_vlan_filtering;
- vlan_ops->dis_tx_filtering = ice_vsi_dis_tx_vlan_filtering;
-
- if (ice_vf_is_port_vlan_ena(vf)) {
- vlan_ops->set_port_vlan = ice_vsi_set_inner_port_vlan;
- vlan_ops->ena_rx_filtering =
- ice_vsi_ena_rx_vlan_filtering;
- /* all Rx traffic should be in the domain of the
- * assigned port VLAN, so prevent disabling Rx VLAN
- * filtering
- */
- vlan_ops->dis_rx_filtering = noop_vlan;
- } else {
- vlan_ops->dis_rx_filtering =
- ice_vsi_dis_rx_vlan_filtering;
- if (!test_bit(ICE_FLAG_VF_VLAN_PRUNING, pf->flags))
- vlan_ops->ena_rx_filtering = noop_vlan;
- else
- vlan_ops->ena_rx_filtering =
- ice_vsi_ena_rx_vlan_filtering;
-
- vlan_ops->del_vlan = ice_vsi_del_vlan;
- vlan_ops->ena_stripping = ice_vsi_ena_inner_stripping;
- vlan_ops->dis_stripping = ice_vsi_dis_inner_stripping;
- vlan_ops->ena_insertion = ice_vsi_ena_inner_insertion;
- vlan_ops->dis_insertion = ice_vsi_dis_inner_insertion;
- }
- }
+ vlan_ops->add_vlan = ice_vsi_add_vlan;
+ vlan_ops->dis_rx_filtering = ice_vsi_dis_rx_vlan_filtering;
+ vlan_ops->ena_tx_filtering = ice_vsi_ena_tx_vlan_filtering;
+ vlan_ops->dis_tx_filtering = ice_vsi_dis_tx_vlan_filtering;
}
/**
diff --git a/drivers/net/ethernet/intel/ice/ice_vf_vsi_vlan_ops.h b/drivers/net/ethernet/intel/ice/ice_vf_vsi_vlan_ops.h
index 875a4e615f39..df8aa09df3e3 100644
--- a/drivers/net/ethernet/intel/ice/ice_vf_vsi_vlan_ops.h
+++ b/drivers/net/ethernet/intel/ice/ice_vf_vsi_vlan_ops.h
@@ -13,7 +13,11 @@ void ice_vf_vsi_cfg_svm_legacy_vlan_mode(struct ice_vsi *vsi);
#ifdef CONFIG_PCI_IOV
void ice_vf_vsi_init_vlan_ops(struct ice_vsi *vsi);
+void ice_vf_vsi_enable_port_vlan(struct ice_vsi *vsi);
+void ice_vf_vsi_disable_port_vlan(struct ice_vsi *vsi);
#else
static inline void ice_vf_vsi_init_vlan_ops(struct ice_vsi *vsi) { }
+static inline void ice_vf_vsi_enable_port_vlan(struct ice_vsi *vsi) { }
+static inline void ice_vf_vsi_disable_port_vlan(struct ice_vsi *vsi) { }
#endif /* CONFIG_PCI_IOV */
#endif /* _ICE_PF_VSI_VLAN_OPS_H_ */
diff --git a/drivers/net/ethernet/intel/ice/ice_vsi_vlan_lib.c b/drivers/net/ethernet/intel/ice/ice_vsi_vlan_lib.c
index 5b4a0abb4607..76266e709a39 100644
--- a/drivers/net/ethernet/intel/ice/ice_vsi_vlan_lib.c
+++ b/drivers/net/ethernet/intel/ice/ice_vsi_vlan_lib.c
@@ -202,6 +202,24 @@ int ice_vsi_dis_inner_insertion(struct ice_vsi *vsi)
return ice_vsi_manage_vlan_insertion(vsi);
}
+static void
+ice_save_vlan_info(struct ice_aqc_vsi_props *info,
+ struct ice_vsi_vlan_info *vlan)
+{
+ vlan->sw_flags2 = info->sw_flags2;
+ vlan->inner_vlan_flags = info->inner_vlan_flags;
+ vlan->outer_vlan_flags = info->outer_vlan_flags;
+}
+
+static void
+ice_restore_vlan_info(struct ice_aqc_vsi_props *info,
+ struct ice_vsi_vlan_info *vlan)
+{
+ info->sw_flags2 = vlan->sw_flags2;
+ info->inner_vlan_flags = vlan->inner_vlan_flags;
+ info->outer_vlan_flags = vlan->outer_vlan_flags;
+}
+
/**
* __ice_vsi_set_inner_port_vlan - set port VLAN VSI context settings to enable a port VLAN
* @vsi: the VSI to update
@@ -218,6 +236,7 @@ static int __ice_vsi_set_inner_port_vlan(struct ice_vsi *vsi, u16 pvid_info)
if (!ctxt)
return -ENOMEM;
+ ice_save_vlan_info(&vsi->info, &vsi->vlan_info);
ctxt->info = vsi->info;
info = &ctxt->info;
info->inner_vlan_flags = ICE_AQ_VSI_INNER_VLAN_TX_MODE_ACCEPTUNTAGGED |
@@ -259,6 +278,33 @@ int ice_vsi_set_inner_port_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan)
return __ice_vsi_set_inner_port_vlan(vsi, port_vlan_info);
}
+int ice_vsi_clear_inner_port_vlan(struct ice_vsi *vsi)
+{
+ struct ice_hw *hw = &vsi->back->hw;
+ struct ice_aqc_vsi_props *info;
+ struct ice_vsi_ctx *ctxt;
+ int ret;
+
+ ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL);
+ if (!ctxt)
+ return -ENOMEM;
+
+ ice_restore_vlan_info(&vsi->info, &vsi->vlan_info);
+ vsi->info.port_based_inner_vlan = 0;
+ ctxt->info = vsi->info;
+ info = &ctxt->info;
+ info->valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_VLAN_VALID |
+ ICE_AQ_VSI_PROP_SW_VALID);
+
+ ret = ice_update_vsi(hw, vsi->idx, ctxt, NULL);
+ if (ret)
+ dev_err(ice_hw_to_dev(hw), "update VSI for port VLAN failed, err %d aq_err %s\n",
+ ret, ice_aq_str(hw->adminq.sq_last_status));
+
+ kfree(ctxt);
+ return ret;
+}
+
/**
* ice_cfg_vlan_pruning - enable or disable VLAN pruning on the VSI
* @vsi: VSI to enable or disable VLAN pruning on
@@ -647,6 +693,7 @@ __ice_vsi_set_outer_port_vlan(struct ice_vsi *vsi, u16 vlan_info, u16 tpid)
if (!ctxt)
return -ENOMEM;
+ ice_save_vlan_info(&vsi->info, &vsi->vlan_info);
ctxt->info = vsi->info;
ctxt->info.sw_flags2 |= ICE_AQ_VSI_SW_FLAG_RX_VLAN_PRUNE_ENA;
@@ -689,9 +736,6 @@ __ice_vsi_set_outer_port_vlan(struct ice_vsi *vsi, u16 vlan_info, u16 tpid)
* used if DVM is supported. Also, this function should never be called directly
* as it should be part of ice_vsi_vlan_ops if it's needed.
*
- * This function does not support clearing the port VLAN as there is currently
- * no use case for this.
- *
* Use the ice_vlan structure passed in to set this VSI in a port VLAN.
*/
int ice_vsi_set_outer_port_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan)
@@ -705,3 +749,37 @@ int ice_vsi_set_outer_port_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan)
return __ice_vsi_set_outer_port_vlan(vsi, port_vlan_info, vlan->tpid);
}
+
+/**
+ * ice_vsi_clear_outer_port_vlan - clear outer port vlan
+ * @vsi: VSI to configure
+ *
+ * The function is restoring previously set vlan config (saved in
+ * vsi->vlan_info). Setting happens in port vlan configuration.
+ */
+int ice_vsi_clear_outer_port_vlan(struct ice_vsi *vsi)
+{
+ struct ice_hw *hw = &vsi->back->hw;
+ struct ice_vsi_ctx *ctxt;
+ int err;
+
+ ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL);
+ if (!ctxt)
+ return -ENOMEM;
+
+ ice_restore_vlan_info(&vsi->info, &vsi->vlan_info);
+ vsi->info.port_based_outer_vlan = 0;
+ ctxt->info = vsi->info;
+
+ ctxt->info.valid_sections =
+ cpu_to_le16(ICE_AQ_VSI_PROP_OUTER_TAG_VALID |
+ ICE_AQ_VSI_PROP_SW_VALID);
+
+ err = ice_update_vsi(hw, vsi->idx, ctxt, NULL);
+ if (err)
+ dev_err(ice_pf_to_dev(vsi->back), "update VSI for clearing outer port based VLAN failed, err %d aq_err %s\n",
+ err, ice_aq_str(hw->adminq.sq_last_status));
+
+ kfree(ctxt);
+ return err;
+}
diff --git a/drivers/net/ethernet/intel/ice/ice_vsi_vlan_lib.h b/drivers/net/ethernet/intel/ice/ice_vsi_vlan_lib.h
index f459909490ec..f0d84d11bd5b 100644
--- a/drivers/net/ethernet/intel/ice/ice_vsi_vlan_lib.h
+++ b/drivers/net/ethernet/intel/ice/ice_vsi_vlan_lib.h
@@ -7,6 +7,12 @@
#include <linux/types.h>
#include "ice_vlan.h"
+struct ice_vsi_vlan_info {
+ u8 sw_flags2;
+ u8 inner_vlan_flags;
+ u8 outer_vlan_flags;
+};
+
struct ice_vsi;
int ice_vsi_add_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan);
@@ -17,6 +23,7 @@ int ice_vsi_dis_inner_stripping(struct ice_vsi *vsi);
int ice_vsi_ena_inner_insertion(struct ice_vsi *vsi, u16 tpid);
int ice_vsi_dis_inner_insertion(struct ice_vsi *vsi);
int ice_vsi_set_inner_port_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan);
+int ice_vsi_clear_inner_port_vlan(struct ice_vsi *vsi);
int ice_vsi_ena_rx_vlan_filtering(struct ice_vsi *vsi);
int ice_vsi_dis_rx_vlan_filtering(struct ice_vsi *vsi);
@@ -28,5 +35,6 @@ int ice_vsi_dis_outer_stripping(struct ice_vsi *vsi);
int ice_vsi_ena_outer_insertion(struct ice_vsi *vsi, u16 tpid);
int ice_vsi_dis_outer_insertion(struct ice_vsi *vsi);
int ice_vsi_set_outer_port_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan);
+int ice_vsi_clear_outer_port_vlan(struct ice_vsi *vsi);
#endif /* _ICE_VSI_VLAN_LIB_H_ */
diff --git a/drivers/net/ethernet/intel/ice/ice_vsi_vlan_ops.h b/drivers/net/ethernet/intel/ice/ice_vsi_vlan_ops.h
index 5b47568f6256..b2d2330dedcb 100644
--- a/drivers/net/ethernet/intel/ice/ice_vsi_vlan_ops.h
+++ b/drivers/net/ethernet/intel/ice/ice_vsi_vlan_ops.h
@@ -21,6 +21,7 @@ struct ice_vsi_vlan_ops {
int (*ena_tx_filtering)(struct ice_vsi *vsi);
int (*dis_tx_filtering)(struct ice_vsi *vsi);
int (*set_port_vlan)(struct ice_vsi *vsi, struct ice_vlan *vlan);
+ int (*clear_port_vlan)(struct ice_vsi *vsi);
};
void ice_vsi_init_vlan_ops(struct ice_vsi *vsi);
--
2.38.1
^ permalink raw reply related [flat|nested] 29+ messages in thread* Re: [PATCH net-next 10/12] ice: implement bridge port vlan
2023-06-20 17:44 ` [PATCH net-next 10/12] ice: implement bridge port vlan Tony Nguyen
@ 2023-06-22 12:07 ` Vlad Buslov
2023-06-22 17:07 ` Drewek, Wojciech
0 siblings, 1 reply; 29+ messages in thread
From: Vlad Buslov @ 2023-06-22 12:07 UTC (permalink / raw)
To: Tony Nguyen
Cc: davem, kuba, pabeni, edumazet, netdev, Michal Swiatkowski, jiri,
ivecera, simon.horman, Wojciech Drewek, Sujai Buvaneswaran
On Tue 20 Jun 2023 at 10:44, Tony Nguyen <anthony.l.nguyen@intel.com> wrote:
> From: Michal Swiatkowski <michal.swiatkowski@linux.intel.com>
>
> Port VLAN in this case means push and pop VLAN action on specific vid.
> There are a few limitation in hardware:
> - push and pop can't be used separately
> - if port VLAN is used there can't be any trunk VLANs, because pop
> action is done on all traffic received by VSI in port VLAN mode
> - port VLAN mode on uplink port isn't supported
>
> Reflect these limitations in code using dev_info to inform the user
> about unsupported configuration.
>
> In bridge mode there is a need to configure port vlan without resetting
> VFs. To do that implement ice_port_vlan_on/off() functions. They are
> only configuring correct vlan_ops to allow setting port vlan.
>
> We also need to clear port vlan without resetting the VF which is not
> supported right now. Change it by implementing clear_port_vlan ops.
> As previous VLAN configuration isn't always the same, store current
> config while creating port vlan and restore it in clear function.
>
> Configuration steps:
> - configure switchdev with bridge
> - #bridge vlan add dev eth0 vid 120 pvid untagged
> - #bridge vlan add dev eth1 vid 120 pvid untagged
> - ping from VF0 to VF1
>
> Reviewed-by: Simon Horman <simon.horman@corigine.com>
> Signed-off-by: Michal Swiatkowski <michal.swiatkowski@linux.intel.com>
> Signed-off-by: Wojciech Drewek <wojciech.drewek@intel.com>
> Tested-by: Sujai Buvaneswaran <sujai.buvaneswaran@intel.com>
> Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
> ---
> drivers/net/ethernet/intel/ice/ice.h | 1 +
> .../net/ethernet/intel/ice/ice_eswitch_br.c | 90 ++++++++-
> .../net/ethernet/intel/ice/ice_eswitch_br.h | 1 +
> .../ethernet/intel/ice/ice_vf_vsi_vlan_ops.c | 186 ++++++++++--------
> .../ethernet/intel/ice/ice_vf_vsi_vlan_ops.h | 4 +
> .../net/ethernet/intel/ice/ice_vsi_vlan_lib.c | 84 +++++++-
> .../net/ethernet/intel/ice/ice_vsi_vlan_lib.h | 8 +
> .../net/ethernet/intel/ice/ice_vsi_vlan_ops.h | 1 +
> 8 files changed, 285 insertions(+), 90 deletions(-)
>
> diff --git a/drivers/net/ethernet/intel/ice/ice.h b/drivers/net/ethernet/intel/ice/ice.h
> index 8918a4b836a2..9109006336f0 100644
> --- a/drivers/net/ethernet/intel/ice/ice.h
> +++ b/drivers/net/ethernet/intel/ice/ice.h
> @@ -370,6 +370,7 @@ struct ice_vsi {
> u16 rx_buf_len;
>
> struct ice_aqc_vsi_props info; /* VSI properties */
> + struct ice_vsi_vlan_info vlan_info; /* vlan config to be restored */
>
> /* VSI stats */
> struct rtnl_link_stats64 net_stats;
> diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch_br.c b/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
> index 805a6b2fd965..d7e96241e8af 100644
> --- a/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
> +++ b/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
> @@ -5,6 +5,8 @@
> #include "ice_eswitch_br.h"
> #include "ice_repr.h"
> #include "ice_switch.h"
> +#include "ice_vlan.h"
> +#include "ice_vf_vsi_vlan_ops.h"
>
> static const struct rhashtable_params ice_fdb_ht_params = {
> .key_offset = offsetof(struct ice_esw_br_fdb_entry, data),
> @@ -573,11 +575,27 @@ ice_eswitch_br_vlan_filtering_set(struct ice_esw_br *bridge, bool enable)
> bridge->flags &= ~ICE_ESWITCH_BR_VLAN_FILTERING;
> }
>
> +static void
> +ice_eswitch_br_clear_pvid(struct ice_esw_br_port *port)
> +{
> + struct ice_vsi_vlan_ops *vlan_ops;
> +
> + vlan_ops = ice_get_compat_vsi_vlan_ops(port->vsi);
> +
> + vlan_ops->clear_port_vlan(port->vsi);
> +
vlan_ops->del_vlan() call seem to be missing here (dual to
vlan_ops->add_vlan() ice_eswitch_br_set_pvid()).
> + ice_vf_vsi_disable_port_vlan(port->vsi);
> +
> + port->pvid = 0;
> +}
> +
> static void
> ice_eswitch_br_vlan_cleanup(struct ice_esw_br_port *port,
> struct ice_esw_br_vlan *vlan)
> {
> xa_erase(&port->vlans, vlan->vid);
> + if (port->pvid == vlan->vid)
> + ice_eswitch_br_clear_pvid(port);
> kfree(vlan);
> }
>
> @@ -590,9 +608,50 @@ static void ice_eswitch_br_port_vlans_flush(struct ice_esw_br_port *port)
> ice_eswitch_br_vlan_cleanup(port, vlan);
> }
>
> +static int
> +ice_eswitch_br_set_pvid(struct ice_esw_br_port *port,
> + struct ice_esw_br_vlan *vlan)
> +{
> + struct ice_vlan port_vlan = ICE_VLAN(ETH_P_8021Q, vlan->vid, 0);
> + struct device *dev = ice_pf_to_dev(port->vsi->back);
> + struct ice_vsi_vlan_ops *vlan_ops;
> + int err;
> +
> + if (port->pvid == vlan->vid || vlan->vid == 1)
> + return 0;
> +
> + /* Setting port vlan on uplink isn't supported by hw */
> + if (port->type == ICE_ESWITCH_BR_UPLINK_PORT)
> + return -EOPNOTSUPP;
> +
> + if (port->pvid) {
> + dev_info(dev,
> + "Port VLAN (vsi=%u, vid=%u) already exists on the port, remove it before adding new one\n",
> + port->vsi_idx, port->pvid);
> + return -EEXIST;
> + }
> +
> + ice_vf_vsi_enable_port_vlan(port->vsi);
> +
> + vlan_ops = ice_get_compat_vsi_vlan_ops(port->vsi);
> + err = vlan_ops->set_port_vlan(port->vsi, &port_vlan);
> + if (err)
> + return err;
> +
> + err = vlan_ops->add_vlan(port->vsi, &port_vlan);
> + if (err)
> + return err;
> +
> + ice_eswitch_br_port_vlans_flush(port);
> + port->pvid = vlan->vid;
> +
> + return 0;
> +}
> +
> static struct ice_esw_br_vlan *
> ice_eswitch_br_vlan_create(u16 vid, u16 flags, struct ice_esw_br_port *port)
> {
> + struct device *dev = ice_pf_to_dev(port->vsi->back);
> struct ice_esw_br_vlan *vlan;
> int err;
>
> @@ -602,14 +661,30 @@ ice_eswitch_br_vlan_create(u16 vid, u16 flags, struct ice_esw_br_port *port)
>
> vlan->vid = vid;
> vlan->flags = flags;
> + if ((flags & BRIDGE_VLAN_INFO_PVID) &&
> + (flags & BRIDGE_VLAN_INFO_UNTAGGED)) {
> + err = ice_eswitch_br_set_pvid(port, vlan);
> + if (err)
> + goto err_set_pvid;
> + } else if ((flags & BRIDGE_VLAN_INFO_PVID) ||
> + (flags & BRIDGE_VLAN_INFO_UNTAGGED)) {
> + dev_info(dev, "VLAN push and pop are supported only simultaneously\n");
> + err = -EOPNOTSUPP;
> + goto err_set_pvid;
> + }
>
> err = xa_insert(&port->vlans, vlan->vid, vlan, GFP_KERNEL);
> - if (err) {
> - kfree(vlan);
> - return ERR_PTR(err);
> - }
> + if (err)
> + goto err_insert;
>
> return vlan;
> +
> +err_insert:
> + if (port->pvid)
> + ice_eswitch_br_clear_pvid(port);
> +err_set_pvid:
> + kfree(vlan);
> + return ERR_PTR(err);
> }
>
> static int
> @@ -623,6 +698,13 @@ ice_eswitch_br_port_vlan_add(struct ice_esw_br *bridge, u16 vsi_idx, u16 vid,
> if (!port)
> return -EINVAL;
>
> + if (port->pvid) {
> + dev_info(ice_pf_to_dev(port->vsi->back),
> + "Port VLAN (vsi=%u, vid=%d) exists on the port, remove it to add trunk VLANs\n",
> + port->vsi_idx, port->pvid);
> + return -EEXIST;
> + }
> +
> vlan = xa_load(&port->vlans, vid);
> if (vlan) {
> if (vlan->flags == flags)
> diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch_br.h b/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
> index dd49b273451a..be4e6f096d55 100644
> --- a/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
> +++ b/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
> @@ -42,6 +42,7 @@ struct ice_esw_br_port {
> struct ice_vsi *vsi;
> enum ice_esw_br_port_type type;
> u16 vsi_idx;
> + u16 pvid;
> struct xarray vlans;
> };
>
> diff --git a/drivers/net/ethernet/intel/ice/ice_vf_vsi_vlan_ops.c b/drivers/net/ethernet/intel/ice/ice_vf_vsi_vlan_ops.c
> index b1ffb81893d4..d7b10dc67f03 100644
> --- a/drivers/net/ethernet/intel/ice/ice_vf_vsi_vlan_ops.c
> +++ b/drivers/net/ethernet/intel/ice/ice_vf_vsi_vlan_ops.c
> @@ -21,6 +21,99 @@ noop_vlan(struct ice_vsi __always_unused *vsi)
> return 0;
> }
>
> +static void ice_port_vlan_on(struct ice_vsi *vsi)
> +{
> + struct ice_vsi_vlan_ops *vlan_ops;
> + struct ice_pf *pf = vsi->back;
> +
> + if (ice_is_dvm_ena(&pf->hw)) {
> + vlan_ops = &vsi->outer_vlan_ops;
> +
> + /* setup outer VLAN ops */
> + vlan_ops->set_port_vlan = ice_vsi_set_outer_port_vlan;
> + vlan_ops->clear_port_vlan = ice_vsi_clear_outer_port_vlan;
> + vlan_ops->clear_port_vlan = ice_vsi_clear_outer_port_vlan;
> +
> + /* setup inner VLAN ops */
> + vlan_ops = &vsi->inner_vlan_ops;
> + vlan_ops->add_vlan = noop_vlan_arg;
> + vlan_ops->del_vlan = noop_vlan_arg;
> + vlan_ops->ena_stripping = ice_vsi_ena_inner_stripping;
> + vlan_ops->dis_stripping = ice_vsi_dis_inner_stripping;
> + vlan_ops->ena_insertion = ice_vsi_ena_inner_insertion;
> + vlan_ops->dis_insertion = ice_vsi_dis_inner_insertion;
> + } else {
> + vlan_ops = &vsi->inner_vlan_ops;
> +
> + vlan_ops->set_port_vlan = ice_vsi_set_inner_port_vlan;
> + vlan_ops->clear_port_vlan = ice_vsi_clear_inner_port_vlan;
> + vlan_ops->clear_port_vlan = ice_vsi_clear_inner_port_vlan;
> + }
> + vlan_ops->ena_rx_filtering = ice_vsi_ena_rx_vlan_filtering;
> +}
> +
> +static void ice_port_vlan_off(struct ice_vsi *vsi)
> +{
> + struct ice_vsi_vlan_ops *vlan_ops;
> + struct ice_pf *pf = vsi->back;
> +
> + /* setup inner VLAN ops */
> + vlan_ops = &vsi->inner_vlan_ops;
> +
> + vlan_ops->ena_stripping = ice_vsi_ena_inner_stripping;
> + vlan_ops->dis_stripping = ice_vsi_dis_inner_stripping;
> + vlan_ops->ena_insertion = ice_vsi_ena_inner_insertion;
> + vlan_ops->dis_insertion = ice_vsi_dis_inner_insertion;
> +
> + if (ice_is_dvm_ena(&pf->hw)) {
> + vlan_ops = &vsi->outer_vlan_ops;
> +
> + vlan_ops->del_vlan = ice_vsi_del_vlan;
> + vlan_ops->ena_stripping = ice_vsi_ena_outer_stripping;
> + vlan_ops->dis_stripping = ice_vsi_dis_outer_stripping;
> + vlan_ops->ena_insertion = ice_vsi_ena_outer_insertion;
> + vlan_ops->dis_insertion = ice_vsi_dis_outer_insertion;
> + } else {
> + vlan_ops->del_vlan = ice_vsi_del_vlan;
> + }
> +
> + if (!test_bit(ICE_FLAG_VF_VLAN_PRUNING, pf->flags))
> + vlan_ops->ena_rx_filtering = noop_vlan;
> + else
> + vlan_ops->ena_rx_filtering =
> + ice_vsi_ena_rx_vlan_filtering;
> +}
> +
> +/**
> + * ice_vf_vsi_enable_port_vlan - Set VSI VLAN ops to support port VLAN
> + * @vsi: VF's VSI being configured
> + *
> + * The function won't create port VLAN, it only allows to create port VLAN
> + * using VLAN ops on the VF VSI.
> + */
> +void ice_vf_vsi_enable_port_vlan(struct ice_vsi *vsi)
> +{
> + if (WARN_ON_ONCE(!vsi->vf))
> + return;
> +
> + ice_port_vlan_on(vsi);
> +}
> +
> +/**
> + * ice_vf_vsi_disable_port_vlan - Clear VSI support for creating port VLAN
> + * @vsi: VF's VSI being configured
> + *
> + * The function should be called after removing port VLAN on VSI
> + * (using VLAN ops)
> + */
> +void ice_vf_vsi_disable_port_vlan(struct ice_vsi *vsi)
> +{
> + if (WARN_ON_ONCE(!vsi->vf))
> + return;
> +
> + ice_port_vlan_off(vsi);
> +}
> +
> /**
> * ice_vf_vsi_init_vlan_ops - Initialize default VSI VLAN ops for VF VSI
> * @vsi: VF's VSI being configured
> @@ -39,91 +132,18 @@ void ice_vf_vsi_init_vlan_ops(struct ice_vsi *vsi)
> if (WARN_ON(!vf))
> return;
>
> - if (ice_is_dvm_ena(&pf->hw)) {
> - vlan_ops = &vsi->outer_vlan_ops;
> + if (ice_vf_is_port_vlan_ena(vf))
> + ice_port_vlan_on(vsi);
> + else
> + ice_port_vlan_off(vsi);
>
> - /* outer VLAN ops regardless of port VLAN config */
> - vlan_ops->add_vlan = ice_vsi_add_vlan;
> - vlan_ops->ena_tx_filtering = ice_vsi_ena_tx_vlan_filtering;
> - vlan_ops->dis_tx_filtering = ice_vsi_dis_tx_vlan_filtering;
> -
> - if (ice_vf_is_port_vlan_ena(vf)) {
> - /* setup outer VLAN ops */
> - vlan_ops->set_port_vlan = ice_vsi_set_outer_port_vlan;
> - /* all Rx traffic should be in the domain of the
> - * assigned port VLAN, so prevent disabling Rx VLAN
> - * filtering
> - */
> - vlan_ops->dis_rx_filtering = noop_vlan;
> - vlan_ops->ena_rx_filtering =
> - ice_vsi_ena_rx_vlan_filtering;
> -
> - /* setup inner VLAN ops */
> - vlan_ops = &vsi->inner_vlan_ops;
> - vlan_ops->add_vlan = noop_vlan_arg;
> - vlan_ops->del_vlan = noop_vlan_arg;
> - vlan_ops->ena_stripping = ice_vsi_ena_inner_stripping;
> - vlan_ops->dis_stripping = ice_vsi_dis_inner_stripping;
> - vlan_ops->ena_insertion = ice_vsi_ena_inner_insertion;
> - vlan_ops->dis_insertion = ice_vsi_dis_inner_insertion;
> - } else {
> - vlan_ops->dis_rx_filtering =
> - ice_vsi_dis_rx_vlan_filtering;
> -
> - if (!test_bit(ICE_FLAG_VF_VLAN_PRUNING, pf->flags))
> - vlan_ops->ena_rx_filtering = noop_vlan;
> - else
> - vlan_ops->ena_rx_filtering =
> - ice_vsi_ena_rx_vlan_filtering;
> -
> - vlan_ops->del_vlan = ice_vsi_del_vlan;
> - vlan_ops->ena_stripping = ice_vsi_ena_outer_stripping;
> - vlan_ops->dis_stripping = ice_vsi_dis_outer_stripping;
> - vlan_ops->ena_insertion = ice_vsi_ena_outer_insertion;
> - vlan_ops->dis_insertion = ice_vsi_dis_outer_insertion;
> -
> - /* setup inner VLAN ops */
> - vlan_ops = &vsi->inner_vlan_ops;
> -
> - vlan_ops->ena_stripping = ice_vsi_ena_inner_stripping;
> - vlan_ops->dis_stripping = ice_vsi_dis_inner_stripping;
> - vlan_ops->ena_insertion = ice_vsi_ena_inner_insertion;
> - vlan_ops->dis_insertion = ice_vsi_dis_inner_insertion;
> - }
> - } else {
> - vlan_ops = &vsi->inner_vlan_ops;
> + vlan_ops = ice_is_dvm_ena(&pf->hw) ?
> + &vsi->outer_vlan_ops : &vsi->inner_vlan_ops;
>
> - /* inner VLAN ops regardless of port VLAN config */
> - vlan_ops->add_vlan = ice_vsi_add_vlan;
> - vlan_ops->dis_rx_filtering = ice_vsi_dis_rx_vlan_filtering;
> - vlan_ops->ena_tx_filtering = ice_vsi_ena_tx_vlan_filtering;
> - vlan_ops->dis_tx_filtering = ice_vsi_dis_tx_vlan_filtering;
> -
> - if (ice_vf_is_port_vlan_ena(vf)) {
> - vlan_ops->set_port_vlan = ice_vsi_set_inner_port_vlan;
> - vlan_ops->ena_rx_filtering =
> - ice_vsi_ena_rx_vlan_filtering;
> - /* all Rx traffic should be in the domain of the
> - * assigned port VLAN, so prevent disabling Rx VLAN
> - * filtering
> - */
> - vlan_ops->dis_rx_filtering = noop_vlan;
> - } else {
> - vlan_ops->dis_rx_filtering =
> - ice_vsi_dis_rx_vlan_filtering;
> - if (!test_bit(ICE_FLAG_VF_VLAN_PRUNING, pf->flags))
> - vlan_ops->ena_rx_filtering = noop_vlan;
> - else
> - vlan_ops->ena_rx_filtering =
> - ice_vsi_ena_rx_vlan_filtering;
> -
> - vlan_ops->del_vlan = ice_vsi_del_vlan;
> - vlan_ops->ena_stripping = ice_vsi_ena_inner_stripping;
> - vlan_ops->dis_stripping = ice_vsi_dis_inner_stripping;
> - vlan_ops->ena_insertion = ice_vsi_ena_inner_insertion;
> - vlan_ops->dis_insertion = ice_vsi_dis_inner_insertion;
> - }
> - }
> + vlan_ops->add_vlan = ice_vsi_add_vlan;
> + vlan_ops->dis_rx_filtering = ice_vsi_dis_rx_vlan_filtering;
> + vlan_ops->ena_tx_filtering = ice_vsi_ena_tx_vlan_filtering;
> + vlan_ops->dis_tx_filtering = ice_vsi_dis_tx_vlan_filtering;
> }
>
> /**
> diff --git a/drivers/net/ethernet/intel/ice/ice_vf_vsi_vlan_ops.h b/drivers/net/ethernet/intel/ice/ice_vf_vsi_vlan_ops.h
> index 875a4e615f39..df8aa09df3e3 100644
> --- a/drivers/net/ethernet/intel/ice/ice_vf_vsi_vlan_ops.h
> +++ b/drivers/net/ethernet/intel/ice/ice_vf_vsi_vlan_ops.h
> @@ -13,7 +13,11 @@ void ice_vf_vsi_cfg_svm_legacy_vlan_mode(struct ice_vsi *vsi);
>
> #ifdef CONFIG_PCI_IOV
> void ice_vf_vsi_init_vlan_ops(struct ice_vsi *vsi);
> +void ice_vf_vsi_enable_port_vlan(struct ice_vsi *vsi);
> +void ice_vf_vsi_disable_port_vlan(struct ice_vsi *vsi);
> #else
> static inline void ice_vf_vsi_init_vlan_ops(struct ice_vsi *vsi) { }
> +static inline void ice_vf_vsi_enable_port_vlan(struct ice_vsi *vsi) { }
> +static inline void ice_vf_vsi_disable_port_vlan(struct ice_vsi *vsi) { }
> #endif /* CONFIG_PCI_IOV */
> #endif /* _ICE_PF_VSI_VLAN_OPS_H_ */
> diff --git a/drivers/net/ethernet/intel/ice/ice_vsi_vlan_lib.c b/drivers/net/ethernet/intel/ice/ice_vsi_vlan_lib.c
> index 5b4a0abb4607..76266e709a39 100644
> --- a/drivers/net/ethernet/intel/ice/ice_vsi_vlan_lib.c
> +++ b/drivers/net/ethernet/intel/ice/ice_vsi_vlan_lib.c
> @@ -202,6 +202,24 @@ int ice_vsi_dis_inner_insertion(struct ice_vsi *vsi)
> return ice_vsi_manage_vlan_insertion(vsi);
> }
>
> +static void
> +ice_save_vlan_info(struct ice_aqc_vsi_props *info,
> + struct ice_vsi_vlan_info *vlan)
> +{
> + vlan->sw_flags2 = info->sw_flags2;
> + vlan->inner_vlan_flags = info->inner_vlan_flags;
> + vlan->outer_vlan_flags = info->outer_vlan_flags;
> +}
> +
> +static void
> +ice_restore_vlan_info(struct ice_aqc_vsi_props *info,
> + struct ice_vsi_vlan_info *vlan)
> +{
> + info->sw_flags2 = vlan->sw_flags2;
> + info->inner_vlan_flags = vlan->inner_vlan_flags;
> + info->outer_vlan_flags = vlan->outer_vlan_flags;
> +}
> +
> /**
> * __ice_vsi_set_inner_port_vlan - set port VLAN VSI context settings to enable a port VLAN
> * @vsi: the VSI to update
> @@ -218,6 +236,7 @@ static int __ice_vsi_set_inner_port_vlan(struct ice_vsi *vsi, u16 pvid_info)
> if (!ctxt)
> return -ENOMEM;
>
> + ice_save_vlan_info(&vsi->info, &vsi->vlan_info);
> ctxt->info = vsi->info;
> info = &ctxt->info;
> info->inner_vlan_flags = ICE_AQ_VSI_INNER_VLAN_TX_MODE_ACCEPTUNTAGGED |
> @@ -259,6 +278,33 @@ int ice_vsi_set_inner_port_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan)
> return __ice_vsi_set_inner_port_vlan(vsi, port_vlan_info);
> }
>
> +int ice_vsi_clear_inner_port_vlan(struct ice_vsi *vsi)
> +{
> + struct ice_hw *hw = &vsi->back->hw;
> + struct ice_aqc_vsi_props *info;
> + struct ice_vsi_ctx *ctxt;
> + int ret;
> +
> + ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL);
> + if (!ctxt)
> + return -ENOMEM;
> +
> + ice_restore_vlan_info(&vsi->info, &vsi->vlan_info);
> + vsi->info.port_based_inner_vlan = 0;
> + ctxt->info = vsi->info;
> + info = &ctxt->info;
> + info->valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_VLAN_VALID |
> + ICE_AQ_VSI_PROP_SW_VALID);
> +
> + ret = ice_update_vsi(hw, vsi->idx, ctxt, NULL);
> + if (ret)
> + dev_err(ice_hw_to_dev(hw), "update VSI for port VLAN failed, err %d aq_err %s\n",
> + ret, ice_aq_str(hw->adminq.sq_last_status));
> +
> + kfree(ctxt);
> + return ret;
> +}
> +
> /**
> * ice_cfg_vlan_pruning - enable or disable VLAN pruning on the VSI
> * @vsi: VSI to enable or disable VLAN pruning on
> @@ -647,6 +693,7 @@ __ice_vsi_set_outer_port_vlan(struct ice_vsi *vsi, u16 vlan_info, u16 tpid)
> if (!ctxt)
> return -ENOMEM;
>
> + ice_save_vlan_info(&vsi->info, &vsi->vlan_info);
> ctxt->info = vsi->info;
>
> ctxt->info.sw_flags2 |= ICE_AQ_VSI_SW_FLAG_RX_VLAN_PRUNE_ENA;
> @@ -689,9 +736,6 @@ __ice_vsi_set_outer_port_vlan(struct ice_vsi *vsi, u16 vlan_info, u16 tpid)
> * used if DVM is supported. Also, this function should never be called directly
> * as it should be part of ice_vsi_vlan_ops if it's needed.
> *
> - * This function does not support clearing the port VLAN as there is currently
> - * no use case for this.
> - *
> * Use the ice_vlan structure passed in to set this VSI in a port VLAN.
> */
> int ice_vsi_set_outer_port_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan)
> @@ -705,3 +749,37 @@ int ice_vsi_set_outer_port_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan)
>
> return __ice_vsi_set_outer_port_vlan(vsi, port_vlan_info, vlan->tpid);
> }
> +
> +/**
> + * ice_vsi_clear_outer_port_vlan - clear outer port vlan
> + * @vsi: VSI to configure
> + *
> + * The function is restoring previously set vlan config (saved in
> + * vsi->vlan_info). Setting happens in port vlan configuration.
> + */
> +int ice_vsi_clear_outer_port_vlan(struct ice_vsi *vsi)
> +{
> + struct ice_hw *hw = &vsi->back->hw;
> + struct ice_vsi_ctx *ctxt;
> + int err;
> +
> + ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL);
> + if (!ctxt)
> + return -ENOMEM;
> +
> + ice_restore_vlan_info(&vsi->info, &vsi->vlan_info);
> + vsi->info.port_based_outer_vlan = 0;
> + ctxt->info = vsi->info;
> +
> + ctxt->info.valid_sections =
> + cpu_to_le16(ICE_AQ_VSI_PROP_OUTER_TAG_VALID |
> + ICE_AQ_VSI_PROP_SW_VALID);
> +
> + err = ice_update_vsi(hw, vsi->idx, ctxt, NULL);
> + if (err)
> + dev_err(ice_pf_to_dev(vsi->back), "update VSI for clearing outer port based VLAN failed, err %d aq_err %s\n",
> + err, ice_aq_str(hw->adminq.sq_last_status));
> +
> + kfree(ctxt);
> + return err;
> +}
> diff --git a/drivers/net/ethernet/intel/ice/ice_vsi_vlan_lib.h b/drivers/net/ethernet/intel/ice/ice_vsi_vlan_lib.h
> index f459909490ec..f0d84d11bd5b 100644
> --- a/drivers/net/ethernet/intel/ice/ice_vsi_vlan_lib.h
> +++ b/drivers/net/ethernet/intel/ice/ice_vsi_vlan_lib.h
> @@ -7,6 +7,12 @@
> #include <linux/types.h>
> #include "ice_vlan.h"
>
> +struct ice_vsi_vlan_info {
> + u8 sw_flags2;
> + u8 inner_vlan_flags;
> + u8 outer_vlan_flags;
> +};
> +
> struct ice_vsi;
>
> int ice_vsi_add_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan);
> @@ -17,6 +23,7 @@ int ice_vsi_dis_inner_stripping(struct ice_vsi *vsi);
> int ice_vsi_ena_inner_insertion(struct ice_vsi *vsi, u16 tpid);
> int ice_vsi_dis_inner_insertion(struct ice_vsi *vsi);
> int ice_vsi_set_inner_port_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan);
> +int ice_vsi_clear_inner_port_vlan(struct ice_vsi *vsi);
>
> int ice_vsi_ena_rx_vlan_filtering(struct ice_vsi *vsi);
> int ice_vsi_dis_rx_vlan_filtering(struct ice_vsi *vsi);
> @@ -28,5 +35,6 @@ int ice_vsi_dis_outer_stripping(struct ice_vsi *vsi);
> int ice_vsi_ena_outer_insertion(struct ice_vsi *vsi, u16 tpid);
> int ice_vsi_dis_outer_insertion(struct ice_vsi *vsi);
> int ice_vsi_set_outer_port_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan);
> +int ice_vsi_clear_outer_port_vlan(struct ice_vsi *vsi);
>
> #endif /* _ICE_VSI_VLAN_LIB_H_ */
> diff --git a/drivers/net/ethernet/intel/ice/ice_vsi_vlan_ops.h b/drivers/net/ethernet/intel/ice/ice_vsi_vlan_ops.h
> index 5b47568f6256..b2d2330dedcb 100644
> --- a/drivers/net/ethernet/intel/ice/ice_vsi_vlan_ops.h
> +++ b/drivers/net/ethernet/intel/ice/ice_vsi_vlan_ops.h
> @@ -21,6 +21,7 @@ struct ice_vsi_vlan_ops {
> int (*ena_tx_filtering)(struct ice_vsi *vsi);
> int (*dis_tx_filtering)(struct ice_vsi *vsi);
> int (*set_port_vlan)(struct ice_vsi *vsi, struct ice_vlan *vlan);
> + int (*clear_port_vlan)(struct ice_vsi *vsi);
> };
>
> void ice_vsi_init_vlan_ops(struct ice_vsi *vsi);
^ permalink raw reply [flat|nested] 29+ messages in thread* RE: [PATCH net-next 10/12] ice: implement bridge port vlan
2023-06-22 12:07 ` Vlad Buslov
@ 2023-06-22 17:07 ` Drewek, Wojciech
0 siblings, 0 replies; 29+ messages in thread
From: Drewek, Wojciech @ 2023-06-22 17:07 UTC (permalink / raw)
To: Vlad Buslov, Nguyen, Anthony L
Cc: davem@davemloft.net, kuba@kernel.org, pabeni@redhat.com,
edumazet@google.com, netdev@vger.kernel.org, Michal Swiatkowski,
jiri@resnulli.us, ivecera, simon.horman@corigine.com,
Buvaneswaran, Sujai
> -----Original Message-----
> From: Vlad Buslov <vladbu@nvidia.com>
> Sent: czwartek, 22 czerwca 2023 14:07
> To: Nguyen, Anthony L <anthony.l.nguyen@intel.com>
> Cc: davem@davemloft.net; kuba@kernel.org; pabeni@redhat.com; edumazet@google.com; netdev@vger.kernel.org; Michal
> Swiatkowski <michal.swiatkowski@linux.intel.com>; jiri@resnulli.us; ivecera <ivecera@redhat.com>; simon.horman@corigine.com;
> Drewek, Wojciech <wojciech.drewek@intel.com>; Buvaneswaran, Sujai <sujai.buvaneswaran@intel.com>
> Subject: Re: [PATCH net-next 10/12] ice: implement bridge port vlan
>
> On Tue 20 Jun 2023 at 10:44, Tony Nguyen <anthony.l.nguyen@intel.com> wrote:
> > From: Michal Swiatkowski <michal.swiatkowski@linux.intel.com>
> >
> > Port VLAN in this case means push and pop VLAN action on specific vid.
> > There are a few limitation in hardware:
> > - push and pop can't be used separately
> > - if port VLAN is used there can't be any trunk VLANs, because pop
> > action is done on all traffic received by VSI in port VLAN mode
> > - port VLAN mode on uplink port isn't supported
> >
> > Reflect these limitations in code using dev_info to inform the user
> > about unsupported configuration.
> >
> > In bridge mode there is a need to configure port vlan without resetting
> > VFs. To do that implement ice_port_vlan_on/off() functions. They are
> > only configuring correct vlan_ops to allow setting port vlan.
> >
> > We also need to clear port vlan without resetting the VF which is not
> > supported right now. Change it by implementing clear_port_vlan ops.
> > As previous VLAN configuration isn't always the same, store current
> > config while creating port vlan and restore it in clear function.
> >
> > Configuration steps:
> > - configure switchdev with bridge
> > - #bridge vlan add dev eth0 vid 120 pvid untagged
> > - #bridge vlan add dev eth1 vid 120 pvid untagged
> > - ping from VF0 to VF1
> >
> > Reviewed-by: Simon Horman <simon.horman@corigine.com>
> > Signed-off-by: Michal Swiatkowski <michal.swiatkowski@linux.intel.com>
> > Signed-off-by: Wojciech Drewek <wojciech.drewek@intel.com>
> > Tested-by: Sujai Buvaneswaran <sujai.buvaneswaran@intel.com>
> > Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
> > ---
> > drivers/net/ethernet/intel/ice/ice.h | 1 +
> > .../net/ethernet/intel/ice/ice_eswitch_br.c | 90 ++++++++-
> > .../net/ethernet/intel/ice/ice_eswitch_br.h | 1 +
> > .../ethernet/intel/ice/ice_vf_vsi_vlan_ops.c | 186 ++++++++++--------
> > .../ethernet/intel/ice/ice_vf_vsi_vlan_ops.h | 4 +
> > .../net/ethernet/intel/ice/ice_vsi_vlan_lib.c | 84 +++++++-
> > .../net/ethernet/intel/ice/ice_vsi_vlan_lib.h | 8 +
> > .../net/ethernet/intel/ice/ice_vsi_vlan_ops.h | 1 +
> > 8 files changed, 285 insertions(+), 90 deletions(-)
> >
> > diff --git a/drivers/net/ethernet/intel/ice/ice.h b/drivers/net/ethernet/intel/ice/ice.h
> > index 8918a4b836a2..9109006336f0 100644
> > --- a/drivers/net/ethernet/intel/ice/ice.h
> > +++ b/drivers/net/ethernet/intel/ice/ice.h
> > @@ -370,6 +370,7 @@ struct ice_vsi {
> > u16 rx_buf_len;
> >
> > struct ice_aqc_vsi_props info; /* VSI properties */
> > + struct ice_vsi_vlan_info vlan_info; /* vlan config to be restored */
> >
> > /* VSI stats */
> > struct rtnl_link_stats64 net_stats;
> > diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch_br.c b/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
> > index 805a6b2fd965..d7e96241e8af 100644
> > --- a/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
> > +++ b/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
> > @@ -5,6 +5,8 @@
> > #include "ice_eswitch_br.h"
> > #include "ice_repr.h"
> > #include "ice_switch.h"
> > +#include "ice_vlan.h"
> > +#include "ice_vf_vsi_vlan_ops.h"
> >
> > static const struct rhashtable_params ice_fdb_ht_params = {
> > .key_offset = offsetof(struct ice_esw_br_fdb_entry, data),
> > @@ -573,11 +575,27 @@ ice_eswitch_br_vlan_filtering_set(struct ice_esw_br *bridge, bool enable)
> > bridge->flags &= ~ICE_ESWITCH_BR_VLAN_FILTERING;
> > }
> >
> > +static void
> > +ice_eswitch_br_clear_pvid(struct ice_esw_br_port *port)
> > +{
> > + struct ice_vsi_vlan_ops *vlan_ops;
> > +
> > + vlan_ops = ice_get_compat_vsi_vlan_ops(port->vsi);
> > +
> > + vlan_ops->clear_port_vlan(port->vsi);
> > +
>
> vlan_ops->del_vlan() call seem to be missing here (dual to
> vlan_ops->add_vlan() ice_eswitch_br_set_pvid()).
Good point, we will fix it.
>
> > + ice_vf_vsi_disable_port_vlan(port->vsi);
> > +
> > + port->pvid = 0;
> > +}
> > +
> > static void
> > ice_eswitch_br_vlan_cleanup(struct ice_esw_br_port *port,
> > struct ice_esw_br_vlan *vlan)
> > {
> > xa_erase(&port->vlans, vlan->vid);
> > + if (port->pvid == vlan->vid)
> > + ice_eswitch_br_clear_pvid(port);
> > kfree(vlan);
> > }
> >
> > @@ -590,9 +608,50 @@ static void ice_eswitch_br_port_vlans_flush(struct ice_esw_br_port *port)
> > ice_eswitch_br_vlan_cleanup(port, vlan);
> > }
> >
> > +static int
> > +ice_eswitch_br_set_pvid(struct ice_esw_br_port *port,
> > + struct ice_esw_br_vlan *vlan)
> > +{
> > + struct ice_vlan port_vlan = ICE_VLAN(ETH_P_8021Q, vlan->vid, 0);
> > + struct device *dev = ice_pf_to_dev(port->vsi->back);
> > + struct ice_vsi_vlan_ops *vlan_ops;
> > + int err;
> > +
> > + if (port->pvid == vlan->vid || vlan->vid == 1)
> > + return 0;
> > +
> > + /* Setting port vlan on uplink isn't supported by hw */
> > + if (port->type == ICE_ESWITCH_BR_UPLINK_PORT)
> > + return -EOPNOTSUPP;
> > +
> > + if (port->pvid) {
> > + dev_info(dev,
> > + "Port VLAN (vsi=%u, vid=%u) already exists on the port, remove it before adding new one\n",
> > + port->vsi_idx, port->pvid);
> > + return -EEXIST;
> > + }
> > +
> > + ice_vf_vsi_enable_port_vlan(port->vsi);
> > +
> > + vlan_ops = ice_get_compat_vsi_vlan_ops(port->vsi);
> > + err = vlan_ops->set_port_vlan(port->vsi, &port_vlan);
> > + if (err)
> > + return err;
> > +
> > + err = vlan_ops->add_vlan(port->vsi, &port_vlan);
> > + if (err)
> > + return err;
> > +
> > + ice_eswitch_br_port_vlans_flush(port);
> > + port->pvid = vlan->vid;
> > +
> > + return 0;
> > +}
> > +
> > static struct ice_esw_br_vlan *
> > ice_eswitch_br_vlan_create(u16 vid, u16 flags, struct ice_esw_br_port *port)
> > {
> > + struct device *dev = ice_pf_to_dev(port->vsi->back);
> > struct ice_esw_br_vlan *vlan;
> > int err;
> >
> > @@ -602,14 +661,30 @@ ice_eswitch_br_vlan_create(u16 vid, u16 flags, struct ice_esw_br_port *port)
> >
> > vlan->vid = vid;
> > vlan->flags = flags;
> > + if ((flags & BRIDGE_VLAN_INFO_PVID) &&
> > + (flags & BRIDGE_VLAN_INFO_UNTAGGED)) {
> > + err = ice_eswitch_br_set_pvid(port, vlan);
> > + if (err)
> > + goto err_set_pvid;
> > + } else if ((flags & BRIDGE_VLAN_INFO_PVID) ||
> > + (flags & BRIDGE_VLAN_INFO_UNTAGGED)) {
> > + dev_info(dev, "VLAN push and pop are supported only simultaneously\n");
> > + err = -EOPNOTSUPP;
> > + goto err_set_pvid;
> > + }
> >
> > err = xa_insert(&port->vlans, vlan->vid, vlan, GFP_KERNEL);
> > - if (err) {
> > - kfree(vlan);
> > - return ERR_PTR(err);
> > - }
> > + if (err)
> > + goto err_insert;
> >
> > return vlan;
> > +
> > +err_insert:
> > + if (port->pvid)
> > + ice_eswitch_br_clear_pvid(port);
> > +err_set_pvid:
> > + kfree(vlan);
> > + return ERR_PTR(err);
> > }
> >
> > static int
> > @@ -623,6 +698,13 @@ ice_eswitch_br_port_vlan_add(struct ice_esw_br *bridge, u16 vsi_idx, u16 vid,
> > if (!port)
> > return -EINVAL;
> >
> > + if (port->pvid) {
> > + dev_info(ice_pf_to_dev(port->vsi->back),
> > + "Port VLAN (vsi=%u, vid=%d) exists on the port, remove it to add trunk VLANs\n",
> > + port->vsi_idx, port->pvid);
> > + return -EEXIST;
> > + }
> > +
> > vlan = xa_load(&port->vlans, vid);
> > if (vlan) {
> > if (vlan->flags == flags)
> > diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch_br.h b/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
> > index dd49b273451a..be4e6f096d55 100644
> > --- a/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
> > +++ b/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
> > @@ -42,6 +42,7 @@ struct ice_esw_br_port {
> > struct ice_vsi *vsi;
> > enum ice_esw_br_port_type type;
> > u16 vsi_idx;
> > + u16 pvid;
> > struct xarray vlans;
> > };
> >
> > diff --git a/drivers/net/ethernet/intel/ice/ice_vf_vsi_vlan_ops.c b/drivers/net/ethernet/intel/ice/ice_vf_vsi_vlan_ops.c
> > index b1ffb81893d4..d7b10dc67f03 100644
> > --- a/drivers/net/ethernet/intel/ice/ice_vf_vsi_vlan_ops.c
> > +++ b/drivers/net/ethernet/intel/ice/ice_vf_vsi_vlan_ops.c
> > @@ -21,6 +21,99 @@ noop_vlan(struct ice_vsi __always_unused *vsi)
> > return 0;
> > }
> >
> > +static void ice_port_vlan_on(struct ice_vsi *vsi)
> > +{
> > + struct ice_vsi_vlan_ops *vlan_ops;
> > + struct ice_pf *pf = vsi->back;
> > +
> > + if (ice_is_dvm_ena(&pf->hw)) {
> > + vlan_ops = &vsi->outer_vlan_ops;
> > +
> > + /* setup outer VLAN ops */
> > + vlan_ops->set_port_vlan = ice_vsi_set_outer_port_vlan;
> > + vlan_ops->clear_port_vlan = ice_vsi_clear_outer_port_vlan;
> > + vlan_ops->clear_port_vlan = ice_vsi_clear_outer_port_vlan;
> > +
> > + /* setup inner VLAN ops */
> > + vlan_ops = &vsi->inner_vlan_ops;
> > + vlan_ops->add_vlan = noop_vlan_arg;
> > + vlan_ops->del_vlan = noop_vlan_arg;
> > + vlan_ops->ena_stripping = ice_vsi_ena_inner_stripping;
> > + vlan_ops->dis_stripping = ice_vsi_dis_inner_stripping;
> > + vlan_ops->ena_insertion = ice_vsi_ena_inner_insertion;
> > + vlan_ops->dis_insertion = ice_vsi_dis_inner_insertion;
> > + } else {
> > + vlan_ops = &vsi->inner_vlan_ops;
> > +
> > + vlan_ops->set_port_vlan = ice_vsi_set_inner_port_vlan;
> > + vlan_ops->clear_port_vlan = ice_vsi_clear_inner_port_vlan;
> > + vlan_ops->clear_port_vlan = ice_vsi_clear_inner_port_vlan;
> > + }
> > + vlan_ops->ena_rx_filtering = ice_vsi_ena_rx_vlan_filtering;
> > +}
> > +
> > +static void ice_port_vlan_off(struct ice_vsi *vsi)
> > +{
> > + struct ice_vsi_vlan_ops *vlan_ops;
> > + struct ice_pf *pf = vsi->back;
> > +
> > + /* setup inner VLAN ops */
> > + vlan_ops = &vsi->inner_vlan_ops;
> > +
> > + vlan_ops->ena_stripping = ice_vsi_ena_inner_stripping;
> > + vlan_ops->dis_stripping = ice_vsi_dis_inner_stripping;
> > + vlan_ops->ena_insertion = ice_vsi_ena_inner_insertion;
> > + vlan_ops->dis_insertion = ice_vsi_dis_inner_insertion;
> > +
> > + if (ice_is_dvm_ena(&pf->hw)) {
> > + vlan_ops = &vsi->outer_vlan_ops;
> > +
> > + vlan_ops->del_vlan = ice_vsi_del_vlan;
> > + vlan_ops->ena_stripping = ice_vsi_ena_outer_stripping;
> > + vlan_ops->dis_stripping = ice_vsi_dis_outer_stripping;
> > + vlan_ops->ena_insertion = ice_vsi_ena_outer_insertion;
> > + vlan_ops->dis_insertion = ice_vsi_dis_outer_insertion;
> > + } else {
> > + vlan_ops->del_vlan = ice_vsi_del_vlan;
> > + }
> > +
> > + if (!test_bit(ICE_FLAG_VF_VLAN_PRUNING, pf->flags))
> > + vlan_ops->ena_rx_filtering = noop_vlan;
> > + else
> > + vlan_ops->ena_rx_filtering =
> > + ice_vsi_ena_rx_vlan_filtering;
> > +}
> > +
> > +/**
> > + * ice_vf_vsi_enable_port_vlan - Set VSI VLAN ops to support port VLAN
> > + * @vsi: VF's VSI being configured
> > + *
> > + * The function won't create port VLAN, it only allows to create port VLAN
> > + * using VLAN ops on the VF VSI.
> > + */
> > +void ice_vf_vsi_enable_port_vlan(struct ice_vsi *vsi)
> > +{
> > + if (WARN_ON_ONCE(!vsi->vf))
> > + return;
> > +
> > + ice_port_vlan_on(vsi);
> > +}
> > +
> > +/**
> > + * ice_vf_vsi_disable_port_vlan - Clear VSI support for creating port VLAN
> > + * @vsi: VF's VSI being configured
> > + *
> > + * The function should be called after removing port VLAN on VSI
> > + * (using VLAN ops)
> > + */
> > +void ice_vf_vsi_disable_port_vlan(struct ice_vsi *vsi)
> > +{
> > + if (WARN_ON_ONCE(!vsi->vf))
> > + return;
> > +
> > + ice_port_vlan_off(vsi);
> > +}
> > +
> > /**
> > * ice_vf_vsi_init_vlan_ops - Initialize default VSI VLAN ops for VF VSI
> > * @vsi: VF's VSI being configured
> > @@ -39,91 +132,18 @@ void ice_vf_vsi_init_vlan_ops(struct ice_vsi *vsi)
> > if (WARN_ON(!vf))
> > return;
> >
> > - if (ice_is_dvm_ena(&pf->hw)) {
> > - vlan_ops = &vsi->outer_vlan_ops;
> > + if (ice_vf_is_port_vlan_ena(vf))
> > + ice_port_vlan_on(vsi);
> > + else
> > + ice_port_vlan_off(vsi);
> >
> > - /* outer VLAN ops regardless of port VLAN config */
> > - vlan_ops->add_vlan = ice_vsi_add_vlan;
> > - vlan_ops->ena_tx_filtering = ice_vsi_ena_tx_vlan_filtering;
> > - vlan_ops->dis_tx_filtering = ice_vsi_dis_tx_vlan_filtering;
> > -
> > - if (ice_vf_is_port_vlan_ena(vf)) {
> > - /* setup outer VLAN ops */
> > - vlan_ops->set_port_vlan = ice_vsi_set_outer_port_vlan;
> > - /* all Rx traffic should be in the domain of the
> > - * assigned port VLAN, so prevent disabling Rx VLAN
> > - * filtering
> > - */
> > - vlan_ops->dis_rx_filtering = noop_vlan;
> > - vlan_ops->ena_rx_filtering =
> > - ice_vsi_ena_rx_vlan_filtering;
> > -
> > - /* setup inner VLAN ops */
> > - vlan_ops = &vsi->inner_vlan_ops;
> > - vlan_ops->add_vlan = noop_vlan_arg;
> > - vlan_ops->del_vlan = noop_vlan_arg;
> > - vlan_ops->ena_stripping = ice_vsi_ena_inner_stripping;
> > - vlan_ops->dis_stripping = ice_vsi_dis_inner_stripping;
> > - vlan_ops->ena_insertion = ice_vsi_ena_inner_insertion;
> > - vlan_ops->dis_insertion = ice_vsi_dis_inner_insertion;
> > - } else {
> > - vlan_ops->dis_rx_filtering =
> > - ice_vsi_dis_rx_vlan_filtering;
> > -
> > - if (!test_bit(ICE_FLAG_VF_VLAN_PRUNING, pf->flags))
> > - vlan_ops->ena_rx_filtering = noop_vlan;
> > - else
> > - vlan_ops->ena_rx_filtering =
> > - ice_vsi_ena_rx_vlan_filtering;
> > -
> > - vlan_ops->del_vlan = ice_vsi_del_vlan;
> > - vlan_ops->ena_stripping = ice_vsi_ena_outer_stripping;
> > - vlan_ops->dis_stripping = ice_vsi_dis_outer_stripping;
> > - vlan_ops->ena_insertion = ice_vsi_ena_outer_insertion;
> > - vlan_ops->dis_insertion = ice_vsi_dis_outer_insertion;
> > -
> > - /* setup inner VLAN ops */
> > - vlan_ops = &vsi->inner_vlan_ops;
> > -
> > - vlan_ops->ena_stripping = ice_vsi_ena_inner_stripping;
> > - vlan_ops->dis_stripping = ice_vsi_dis_inner_stripping;
> > - vlan_ops->ena_insertion = ice_vsi_ena_inner_insertion;
> > - vlan_ops->dis_insertion = ice_vsi_dis_inner_insertion;
> > - }
> > - } else {
> > - vlan_ops = &vsi->inner_vlan_ops;
> > + vlan_ops = ice_is_dvm_ena(&pf->hw) ?
> > + &vsi->outer_vlan_ops : &vsi->inner_vlan_ops;
> >
> > - /* inner VLAN ops regardless of port VLAN config */
> > - vlan_ops->add_vlan = ice_vsi_add_vlan;
> > - vlan_ops->dis_rx_filtering = ice_vsi_dis_rx_vlan_filtering;
> > - vlan_ops->ena_tx_filtering = ice_vsi_ena_tx_vlan_filtering;
> > - vlan_ops->dis_tx_filtering = ice_vsi_dis_tx_vlan_filtering;
> > -
> > - if (ice_vf_is_port_vlan_ena(vf)) {
> > - vlan_ops->set_port_vlan = ice_vsi_set_inner_port_vlan;
> > - vlan_ops->ena_rx_filtering =
> > - ice_vsi_ena_rx_vlan_filtering;
> > - /* all Rx traffic should be in the domain of the
> > - * assigned port VLAN, so prevent disabling Rx VLAN
> > - * filtering
> > - */
> > - vlan_ops->dis_rx_filtering = noop_vlan;
> > - } else {
> > - vlan_ops->dis_rx_filtering =
> > - ice_vsi_dis_rx_vlan_filtering;
> > - if (!test_bit(ICE_FLAG_VF_VLAN_PRUNING, pf->flags))
> > - vlan_ops->ena_rx_filtering = noop_vlan;
> > - else
> > - vlan_ops->ena_rx_filtering =
> > - ice_vsi_ena_rx_vlan_filtering;
> > -
> > - vlan_ops->del_vlan = ice_vsi_del_vlan;
> > - vlan_ops->ena_stripping = ice_vsi_ena_inner_stripping;
> > - vlan_ops->dis_stripping = ice_vsi_dis_inner_stripping;
> > - vlan_ops->ena_insertion = ice_vsi_ena_inner_insertion;
> > - vlan_ops->dis_insertion = ice_vsi_dis_inner_insertion;
> > - }
> > - }
> > + vlan_ops->add_vlan = ice_vsi_add_vlan;
> > + vlan_ops->dis_rx_filtering = ice_vsi_dis_rx_vlan_filtering;
> > + vlan_ops->ena_tx_filtering = ice_vsi_ena_tx_vlan_filtering;
> > + vlan_ops->dis_tx_filtering = ice_vsi_dis_tx_vlan_filtering;
> > }
> >
> > /**
> > diff --git a/drivers/net/ethernet/intel/ice/ice_vf_vsi_vlan_ops.h b/drivers/net/ethernet/intel/ice/ice_vf_vsi_vlan_ops.h
> > index 875a4e615f39..df8aa09df3e3 100644
> > --- a/drivers/net/ethernet/intel/ice/ice_vf_vsi_vlan_ops.h
> > +++ b/drivers/net/ethernet/intel/ice/ice_vf_vsi_vlan_ops.h
> > @@ -13,7 +13,11 @@ void ice_vf_vsi_cfg_svm_legacy_vlan_mode(struct ice_vsi *vsi);
> >
> > #ifdef CONFIG_PCI_IOV
> > void ice_vf_vsi_init_vlan_ops(struct ice_vsi *vsi);
> > +void ice_vf_vsi_enable_port_vlan(struct ice_vsi *vsi);
> > +void ice_vf_vsi_disable_port_vlan(struct ice_vsi *vsi);
> > #else
> > static inline void ice_vf_vsi_init_vlan_ops(struct ice_vsi *vsi) { }
> > +static inline void ice_vf_vsi_enable_port_vlan(struct ice_vsi *vsi) { }
> > +static inline void ice_vf_vsi_disable_port_vlan(struct ice_vsi *vsi) { }
> > #endif /* CONFIG_PCI_IOV */
> > #endif /* _ICE_PF_VSI_VLAN_OPS_H_ */
> > diff --git a/drivers/net/ethernet/intel/ice/ice_vsi_vlan_lib.c b/drivers/net/ethernet/intel/ice/ice_vsi_vlan_lib.c
> > index 5b4a0abb4607..76266e709a39 100644
> > --- a/drivers/net/ethernet/intel/ice/ice_vsi_vlan_lib.c
> > +++ b/drivers/net/ethernet/intel/ice/ice_vsi_vlan_lib.c
> > @@ -202,6 +202,24 @@ int ice_vsi_dis_inner_insertion(struct ice_vsi *vsi)
> > return ice_vsi_manage_vlan_insertion(vsi);
> > }
> >
> > +static void
> > +ice_save_vlan_info(struct ice_aqc_vsi_props *info,
> > + struct ice_vsi_vlan_info *vlan)
> > +{
> > + vlan->sw_flags2 = info->sw_flags2;
> > + vlan->inner_vlan_flags = info->inner_vlan_flags;
> > + vlan->outer_vlan_flags = info->outer_vlan_flags;
> > +}
> > +
> > +static void
> > +ice_restore_vlan_info(struct ice_aqc_vsi_props *info,
> > + struct ice_vsi_vlan_info *vlan)
> > +{
> > + info->sw_flags2 = vlan->sw_flags2;
> > + info->inner_vlan_flags = vlan->inner_vlan_flags;
> > + info->outer_vlan_flags = vlan->outer_vlan_flags;
> > +}
> > +
> > /**
> > * __ice_vsi_set_inner_port_vlan - set port VLAN VSI context settings to enable a port VLAN
> > * @vsi: the VSI to update
> > @@ -218,6 +236,7 @@ static int __ice_vsi_set_inner_port_vlan(struct ice_vsi *vsi, u16 pvid_info)
> > if (!ctxt)
> > return -ENOMEM;
> >
> > + ice_save_vlan_info(&vsi->info, &vsi->vlan_info);
> > ctxt->info = vsi->info;
> > info = &ctxt->info;
> > info->inner_vlan_flags = ICE_AQ_VSI_INNER_VLAN_TX_MODE_ACCEPTUNTAGGED |
> > @@ -259,6 +278,33 @@ int ice_vsi_set_inner_port_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan)
> > return __ice_vsi_set_inner_port_vlan(vsi, port_vlan_info);
> > }
> >
> > +int ice_vsi_clear_inner_port_vlan(struct ice_vsi *vsi)
> > +{
> > + struct ice_hw *hw = &vsi->back->hw;
> > + struct ice_aqc_vsi_props *info;
> > + struct ice_vsi_ctx *ctxt;
> > + int ret;
> > +
> > + ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL);
> > + if (!ctxt)
> > + return -ENOMEM;
> > +
> > + ice_restore_vlan_info(&vsi->info, &vsi->vlan_info);
> > + vsi->info.port_based_inner_vlan = 0;
> > + ctxt->info = vsi->info;
> > + info = &ctxt->info;
> > + info->valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_VLAN_VALID |
> > + ICE_AQ_VSI_PROP_SW_VALID);
> > +
> > + ret = ice_update_vsi(hw, vsi->idx, ctxt, NULL);
> > + if (ret)
> > + dev_err(ice_hw_to_dev(hw), "update VSI for port VLAN failed, err %d aq_err %s\n",
> > + ret, ice_aq_str(hw->adminq.sq_last_status));
> > +
> > + kfree(ctxt);
> > + return ret;
> > +}
> > +
> > /**
> > * ice_cfg_vlan_pruning - enable or disable VLAN pruning on the VSI
> > * @vsi: VSI to enable or disable VLAN pruning on
> > @@ -647,6 +693,7 @@ __ice_vsi_set_outer_port_vlan(struct ice_vsi *vsi, u16 vlan_info, u16 tpid)
> > if (!ctxt)
> > return -ENOMEM;
> >
> > + ice_save_vlan_info(&vsi->info, &vsi->vlan_info);
> > ctxt->info = vsi->info;
> >
> > ctxt->info.sw_flags2 |= ICE_AQ_VSI_SW_FLAG_RX_VLAN_PRUNE_ENA;
> > @@ -689,9 +736,6 @@ __ice_vsi_set_outer_port_vlan(struct ice_vsi *vsi, u16 vlan_info, u16 tpid)
> > * used if DVM is supported. Also, this function should never be called directly
> > * as it should be part of ice_vsi_vlan_ops if it's needed.
> > *
> > - * This function does not support clearing the port VLAN as there is currently
> > - * no use case for this.
> > - *
> > * Use the ice_vlan structure passed in to set this VSI in a port VLAN.
> > */
> > int ice_vsi_set_outer_port_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan)
> > @@ -705,3 +749,37 @@ int ice_vsi_set_outer_port_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan)
> >
> > return __ice_vsi_set_outer_port_vlan(vsi, port_vlan_info, vlan->tpid);
> > }
> > +
> > +/**
> > + * ice_vsi_clear_outer_port_vlan - clear outer port vlan
> > + * @vsi: VSI to configure
> > + *
> > + * The function is restoring previously set vlan config (saved in
> > + * vsi->vlan_info). Setting happens in port vlan configuration.
> > + */
> > +int ice_vsi_clear_outer_port_vlan(struct ice_vsi *vsi)
> > +{
> > + struct ice_hw *hw = &vsi->back->hw;
> > + struct ice_vsi_ctx *ctxt;
> > + int err;
> > +
> > + ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL);
> > + if (!ctxt)
> > + return -ENOMEM;
> > +
> > + ice_restore_vlan_info(&vsi->info, &vsi->vlan_info);
> > + vsi->info.port_based_outer_vlan = 0;
> > + ctxt->info = vsi->info;
> > +
> > + ctxt->info.valid_sections =
> > + cpu_to_le16(ICE_AQ_VSI_PROP_OUTER_TAG_VALID |
> > + ICE_AQ_VSI_PROP_SW_VALID);
> > +
> > + err = ice_update_vsi(hw, vsi->idx, ctxt, NULL);
> > + if (err)
> > + dev_err(ice_pf_to_dev(vsi->back), "update VSI for clearing outer port based VLAN failed, err %d aq_err %s\n",
> > + err, ice_aq_str(hw->adminq.sq_last_status));
> > +
> > + kfree(ctxt);
> > + return err;
> > +}
> > diff --git a/drivers/net/ethernet/intel/ice/ice_vsi_vlan_lib.h b/drivers/net/ethernet/intel/ice/ice_vsi_vlan_lib.h
> > index f459909490ec..f0d84d11bd5b 100644
> > --- a/drivers/net/ethernet/intel/ice/ice_vsi_vlan_lib.h
> > +++ b/drivers/net/ethernet/intel/ice/ice_vsi_vlan_lib.h
> > @@ -7,6 +7,12 @@
> > #include <linux/types.h>
> > #include "ice_vlan.h"
> >
> > +struct ice_vsi_vlan_info {
> > + u8 sw_flags2;
> > + u8 inner_vlan_flags;
> > + u8 outer_vlan_flags;
> > +};
> > +
> > struct ice_vsi;
> >
> > int ice_vsi_add_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan);
> > @@ -17,6 +23,7 @@ int ice_vsi_dis_inner_stripping(struct ice_vsi *vsi);
> > int ice_vsi_ena_inner_insertion(struct ice_vsi *vsi, u16 tpid);
> > int ice_vsi_dis_inner_insertion(struct ice_vsi *vsi);
> > int ice_vsi_set_inner_port_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan);
> > +int ice_vsi_clear_inner_port_vlan(struct ice_vsi *vsi);
> >
> > int ice_vsi_ena_rx_vlan_filtering(struct ice_vsi *vsi);
> > int ice_vsi_dis_rx_vlan_filtering(struct ice_vsi *vsi);
> > @@ -28,5 +35,6 @@ int ice_vsi_dis_outer_stripping(struct ice_vsi *vsi);
> > int ice_vsi_ena_outer_insertion(struct ice_vsi *vsi, u16 tpid);
> > int ice_vsi_dis_outer_insertion(struct ice_vsi *vsi);
> > int ice_vsi_set_outer_port_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan);
> > +int ice_vsi_clear_outer_port_vlan(struct ice_vsi *vsi);
> >
> > #endif /* _ICE_VSI_VLAN_LIB_H_ */
> > diff --git a/drivers/net/ethernet/intel/ice/ice_vsi_vlan_ops.h b/drivers/net/ethernet/intel/ice/ice_vsi_vlan_ops.h
> > index 5b47568f6256..b2d2330dedcb 100644
> > --- a/drivers/net/ethernet/intel/ice/ice_vsi_vlan_ops.h
> > +++ b/drivers/net/ethernet/intel/ice/ice_vsi_vlan_ops.h
> > @@ -21,6 +21,7 @@ struct ice_vsi_vlan_ops {
> > int (*ena_tx_filtering)(struct ice_vsi *vsi);
> > int (*dis_tx_filtering)(struct ice_vsi *vsi);
> > int (*set_port_vlan)(struct ice_vsi *vsi, struct ice_vlan *vlan);
> > + int (*clear_port_vlan)(struct ice_vsi *vsi);
> > };
> >
> > void ice_vsi_init_vlan_ops(struct ice_vsi *vsi);
^ permalink raw reply [flat|nested] 29+ messages in thread
* [PATCH net-next 11/12] ice: implement static version of aging
2023-06-20 17:44 [PATCH net-next 00/12][pull request] ice: switchdev bridge offload Tony Nguyen
` (9 preceding siblings ...)
2023-06-20 17:44 ` [PATCH net-next 10/12] ice: implement bridge port vlan Tony Nguyen
@ 2023-06-20 17:44 ` Tony Nguyen
2023-06-20 17:44 ` [PATCH net-next 12/12] ice: add tracepoints for the switchdev bridge Tony Nguyen
2023-06-20 18:12 ` [PATCH net-next 00/12][pull request] ice: switchdev bridge offload Jakub Kicinski
12 siblings, 0 replies; 29+ messages in thread
From: Tony Nguyen @ 2023-06-20 17:44 UTC (permalink / raw)
To: davem, kuba, pabeni, edumazet, netdev
Cc: Michal Swiatkowski, anthony.l.nguyen, jiri, ivecera, simon.horman,
Wojciech Drewek, Sujai Buvaneswaran
From: Michal Swiatkowski <michal.swiatkowski@linux.intel.com>
Remove fdb entries always when ageing time expired.
Allow user to set ageing time using port object attribute.
Reviewed-by: Simon Horman <simon.horman@corigine.com>
Signed-off-by: Michal Swiatkowski <michal.swiatkowski@linux.intel.com>
Signed-off-by: Wojciech Drewek <wojciech.drewek@intel.com>
Tested-by: Sujai Buvaneswaran <sujai.buvaneswaran@intel.com>
Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
---
.../net/ethernet/intel/ice/ice_eswitch_br.c | 48 +++++++++++++++++++
.../net/ethernet/intel/ice/ice_eswitch_br.h | 10 ++++
2 files changed, 58 insertions(+)
diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch_br.c b/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
index d7e96241e8af..bf1b7dd278e5 100644
--- a/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
+++ b/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
@@ -8,6 +8,8 @@
#include "ice_vlan.h"
#include "ice_vf_vsi_vlan_ops.h"
+#define ICE_ESW_BRIDGE_UPDATE_INTERVAL msecs_to_jiffies(1000)
+
static const struct rhashtable_params ice_fdb_ht_params = {
.key_offset = offsetof(struct ice_esw_br_fdb_entry, data),
.key_len = sizeof(struct ice_esw_br_fdb_data),
@@ -406,6 +408,7 @@ ice_eswitch_br_fdb_entry_create(struct net_device *netdev,
fdb_entry->br_port = br_port;
fdb_entry->flow = flow;
fdb_entry->dev = netdev;
+ fdb_entry->last_use = jiffies;
event = SWITCHDEV_FDB_ADD_TO_BRIDGE;
if (added_by_user) {
@@ -800,6 +803,10 @@ ice_eswitch_br_port_obj_attr_set(struct net_device *netdev, const void *ctx,
ice_eswitch_br_vlan_filtering_set(br_port->bridge,
attr->u.vlan_filtering);
return 0;
+ case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
+ br_port->bridge->ageing_time =
+ clock_t_to_jiffies(attr->u.ageing_time);
+ return 0;
default:
return -EOPNOTSUPP;
}
@@ -971,6 +978,7 @@ ice_eswitch_br_init(struct ice_esw_br_offloads *br_offloads, int ifindex)
INIT_LIST_HEAD(&bridge->fdb_list);
bridge->br_offloads = br_offloads;
bridge->ifindex = ifindex;
+ bridge->ageing_time = clock_t_to_jiffies(BR_DEFAULT_AGEING_TIME);
xa_init(&bridge->ports);
br_offloads->bridge = bridge;
@@ -1166,6 +1174,7 @@ ice_eswitch_br_offloads_deinit(struct ice_pf *pf)
if (!br_offloads)
return;
+ cancel_delayed_work_sync(&br_offloads->update_work);
unregister_netdevice_notifier(&br_offloads->netdev_nb);
unregister_switchdev_blocking_notifier(&br_offloads->switchdev_blk);
unregister_switchdev_notifier(&br_offloads->switchdev_nb);
@@ -1180,6 +1189,40 @@ ice_eswitch_br_offloads_deinit(struct ice_pf *pf)
rtnl_unlock();
}
+static void ice_eswitch_br_update(struct ice_esw_br_offloads *br_offloads)
+{
+ struct ice_esw_br *bridge = br_offloads->bridge;
+ struct ice_esw_br_fdb_entry *entry, *tmp;
+
+ if (!bridge)
+ return;
+
+ rtnl_lock();
+ list_for_each_entry_safe(entry, tmp, &bridge->fdb_list, list) {
+ if (entry->flags & ICE_ESWITCH_BR_FDB_ADDED_BY_USER)
+ continue;
+
+ if (time_is_after_eq_jiffies(entry->last_use +
+ bridge->ageing_time))
+ continue;
+
+ ice_eswitch_br_fdb_entry_notify_and_cleanup(bridge, entry);
+ }
+ rtnl_unlock();
+}
+
+static void ice_eswitch_br_update_work(struct work_struct *work)
+{
+ struct ice_esw_br_offloads *br_offloads;
+
+ br_offloads = ice_work_to_br_offloads(work);
+
+ ice_eswitch_br_update(br_offloads);
+
+ queue_delayed_work(br_offloads->wq, &br_offloads->update_work,
+ ICE_ESW_BRIDGE_UPDATE_INTERVAL);
+}
+
int
ice_eswitch_br_offloads_init(struct ice_pf *pf)
{
@@ -1228,6 +1271,11 @@ ice_eswitch_br_offloads_init(struct ice_pf *pf)
goto err_reg_netdev_nb;
}
+ INIT_DELAYED_WORK(&br_offloads->update_work,
+ ice_eswitch_br_update_work);
+ queue_delayed_work(br_offloads->wq, &br_offloads->update_work,
+ ICE_ESW_BRIDGE_UPDATE_INTERVAL);
+
return 0;
err_reg_netdev_nb:
diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch_br.h b/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
index be4e6f096d55..f734e3bd2c75 100644
--- a/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
+++ b/drivers/net/ethernet/intel/ice/ice_eswitch_br.h
@@ -5,6 +5,7 @@
#define _ICE_ESWITCH_BR_H_
#include <linux/rhashtable.h>
+#include <linux/workqueue.h>
struct ice_esw_br_fdb_data {
unsigned char addr[ETH_ALEN];
@@ -30,6 +31,8 @@ struct ice_esw_br_fdb_entry {
struct net_device *dev;
struct ice_esw_br_port *br_port;
struct ice_esw_br_flow *flow;
+
+ unsigned long last_use;
};
enum ice_esw_br_port_type {
@@ -59,6 +62,7 @@ struct ice_esw_br {
int ifindex;
u32 flags;
+ unsigned long ageing_time;
};
struct ice_esw_br_offloads {
@@ -69,6 +73,7 @@ struct ice_esw_br_offloads {
struct notifier_block switchdev_nb;
struct workqueue_struct *wq;
+ struct delayed_work update_work;
};
struct ice_esw_br_fdb_work {
@@ -89,6 +94,11 @@ struct ice_esw_br_vlan {
struct ice_esw_br_offloads, \
nb_name)
+#define ice_work_to_br_offloads(w) \
+ container_of(w, \
+ struct ice_esw_br_offloads, \
+ update_work.work)
+
#define ice_work_to_fdb_work(w) \
container_of(w, \
struct ice_esw_br_fdb_work, \
--
2.38.1
^ permalink raw reply related [flat|nested] 29+ messages in thread* [PATCH net-next 12/12] ice: add tracepoints for the switchdev bridge
2023-06-20 17:44 [PATCH net-next 00/12][pull request] ice: switchdev bridge offload Tony Nguyen
` (10 preceding siblings ...)
2023-06-20 17:44 ` [PATCH net-next 11/12] ice: implement static version of aging Tony Nguyen
@ 2023-06-20 17:44 ` Tony Nguyen
2023-06-20 18:12 ` [PATCH net-next 00/12][pull request] ice: switchdev bridge offload Jakub Kicinski
12 siblings, 0 replies; 29+ messages in thread
From: Tony Nguyen @ 2023-06-20 17:44 UTC (permalink / raw)
To: davem, kuba, pabeni, edumazet, netdev
Cc: Pawel Chmielewski, anthony.l.nguyen, jiri, ivecera, simon.horman,
Wojciech Drewek, Sujai Buvaneswaran
From: Pawel Chmielewski <pawel.chmielewski@intel.com>
Add tracepoints for the following events:
- Add FDB entry
- Delete FDB entry
- Create bridge VLAN
- Cleanup bridge VLAN
- Link port to the bridge
- Unlink port from the bridge
Signed-off-by: Pawel Chmielewski <pawel.chmielewski@intel.com>
Signed-off-by: Wojciech Drewek <wojciech.drewek@intel.com>
Tested-by: Sujai Buvaneswaran <sujai.buvaneswaran@intel.com>
Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
---
.../net/ethernet/intel/ice/ice_eswitch_br.c | 9 ++
drivers/net/ethernet/intel/ice/ice_trace.h | 90 +++++++++++++++++++
2 files changed, 99 insertions(+)
diff --git a/drivers/net/ethernet/intel/ice/ice_eswitch_br.c b/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
index bf1b7dd278e5..8acfd2299d4d 100644
--- a/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
+++ b/drivers/net/ethernet/intel/ice/ice_eswitch_br.c
@@ -7,6 +7,7 @@
#include "ice_switch.h"
#include "ice_vlan.h"
#include "ice_vf_vsi_vlan_ops.h"
+#include "ice_trace.h"
#define ICE_ESW_BRIDGE_UPDATE_INTERVAL msecs_to_jiffies(1000)
@@ -353,6 +354,7 @@ ice_eswitch_br_fdb_entry_find_and_delete(struct ice_esw_br *bridge,
return;
}
+ trace_ice_eswitch_br_fdb_entry_find_and_delete(fdb_entry);
ice_eswitch_br_fdb_entry_notify_and_cleanup(bridge, fdb_entry);
}
@@ -422,6 +424,7 @@ ice_eswitch_br_fdb_entry_create(struct net_device *netdev,
goto err_fdb_insert;
list_add(&fdb_entry->list, &bridge->fdb_list);
+ trace_ice_eswitch_br_fdb_entry_create(fdb_entry);
ice_eswitch_br_fdb_offload_notify(netdev, mac, vid, event);
@@ -596,6 +599,7 @@ static void
ice_eswitch_br_vlan_cleanup(struct ice_esw_br_port *port,
struct ice_esw_br_vlan *vlan)
{
+ trace_ice_eswitch_br_vlan_cleanup(vlan);
xa_erase(&port->vlans, vlan->vid);
if (port->pvid == vlan->vid)
ice_eswitch_br_clear_pvid(port);
@@ -680,6 +684,8 @@ ice_eswitch_br_vlan_create(u16 vid, u16 flags, struct ice_esw_br_port *port)
if (err)
goto err_insert;
+ trace_ice_eswitch_br_vlan_create(vlan);
+
return vlan;
err_insert:
@@ -1041,6 +1047,7 @@ ice_eswitch_br_port_unlink(struct ice_esw_br_offloads *br_offloads,
bridge = br_port->bridge;
+ trace_ice_eswitch_br_port_unlink(br_port);
ice_eswitch_br_port_deinit(br_port->bridge, br_port);
ice_eswitch_br_verify_deinit(br_offloads, bridge);
@@ -1069,10 +1076,12 @@ ice_eswitch_br_port_link(struct ice_esw_br_offloads *br_offloads,
struct ice_repr *repr = ice_netdev_to_repr(dev);
err = ice_eswitch_br_vf_repr_port_init(bridge, repr);
+ trace_ice_eswitch_br_port_link(repr->br_port);
} else {
struct ice_pf *pf = ice_netdev_to_pf(dev);
err = ice_eswitch_br_uplink_port_init(bridge, pf);
+ trace_ice_eswitch_br_port_link(pf->br_port);
}
if (err) {
NL_SET_ERR_MSG_MOD(extack, "Failed to init bridge port");
diff --git a/drivers/net/ethernet/intel/ice/ice_trace.h b/drivers/net/ethernet/intel/ice/ice_trace.h
index ae98d5a8ff60..b2f5c9fe0149 100644
--- a/drivers/net/ethernet/intel/ice/ice_trace.h
+++ b/drivers/net/ethernet/intel/ice/ice_trace.h
@@ -21,6 +21,7 @@
#define _ICE_TRACE_H_
#include <linux/tracepoint.h>
+#include "ice_eswitch_br.h"
/* ice_trace() macro enables shared code to refer to trace points
* like:
@@ -240,6 +241,95 @@ DEFINE_TX_TSTAMP_OP_EVENT(ice_tx_tstamp_fw_req);
DEFINE_TX_TSTAMP_OP_EVENT(ice_tx_tstamp_fw_done);
DEFINE_TX_TSTAMP_OP_EVENT(ice_tx_tstamp_complete);
+DECLARE_EVENT_CLASS(ice_esw_br_fdb_template,
+ TP_PROTO(struct ice_esw_br_fdb_entry *fdb),
+ TP_ARGS(fdb),
+ TP_STRUCT__entry(__array(char, dev_name, IFNAMSIZ)
+ __array(unsigned char, addr, ETH_ALEN)
+ __field(u16, vid)
+ __field(int, flags)),
+ TP_fast_assign(strscpy(__entry->dev_name,
+ netdev_name(fdb->dev),
+ IFNAMSIZ);
+ memcpy(__entry->addr, fdb->data.addr, ETH_ALEN);
+ __entry->vid = fdb->data.vid;
+ __entry->flags = fdb->flags;),
+ TP_printk("net_device=%s addr=%pM vid=%u flags=%x",
+ __entry->dev_name,
+ __entry->addr,
+ __entry->vid,
+ __entry->flags)
+);
+
+DEFINE_EVENT(ice_esw_br_fdb_template,
+ ice_eswitch_br_fdb_entry_create,
+ TP_PROTO(struct ice_esw_br_fdb_entry *fdb),
+ TP_ARGS(fdb)
+);
+
+DEFINE_EVENT(ice_esw_br_fdb_template,
+ ice_eswitch_br_fdb_entry_find_and_delete,
+ TP_PROTO(struct ice_esw_br_fdb_entry *fdb),
+ TP_ARGS(fdb)
+);
+
+DECLARE_EVENT_CLASS(ice_esw_br_vlan_template,
+ TP_PROTO(struct ice_esw_br_vlan *vlan),
+ TP_ARGS(vlan),
+ TP_STRUCT__entry(__field(u16, vid)
+ __field(u16, flags)),
+ TP_fast_assign(__entry->vid = vlan->vid;
+ __entry->flags = vlan->flags;),
+ TP_printk("vid=%u flags=%x",
+ __entry->vid,
+ __entry->flags)
+);
+
+DEFINE_EVENT(ice_esw_br_vlan_template,
+ ice_eswitch_br_vlan_create,
+ TP_PROTO(struct ice_esw_br_vlan *vlan),
+ TP_ARGS(vlan)
+);
+
+DEFINE_EVENT(ice_esw_br_vlan_template,
+ ice_eswitch_br_vlan_cleanup,
+ TP_PROTO(struct ice_esw_br_vlan *vlan),
+ TP_ARGS(vlan)
+);
+
+#define ICE_ESW_BR_PORT_NAME_L 16
+
+DECLARE_EVENT_CLASS(ice_esw_br_port_template,
+ TP_PROTO(struct ice_esw_br_port *port),
+ TP_ARGS(port),
+ TP_STRUCT__entry(__field(u16, vport_num)
+ __array(char, port_type, ICE_ESW_BR_PORT_NAME_L)),
+ TP_fast_assign(__entry->vport_num = port->vsi_idx;
+ if (port->type == ICE_ESWITCH_BR_UPLINK_PORT)
+ strscpy(__entry->port_type,
+ "Uplink",
+ ICE_ESW_BR_PORT_NAME_L);
+ else
+ strscpy(__entry->port_type,
+ "VF Representor",
+ ICE_ESW_BR_PORT_NAME_L);),
+ TP_printk("vport_num=%u port type=%s",
+ __entry->vport_num,
+ __entry->port_type)
+);
+
+DEFINE_EVENT(ice_esw_br_port_template,
+ ice_eswitch_br_port_link,
+ TP_PROTO(struct ice_esw_br_port *port),
+ TP_ARGS(port)
+);
+
+DEFINE_EVENT(ice_esw_br_port_template,
+ ice_eswitch_br_port_unlink,
+ TP_PROTO(struct ice_esw_br_port *port),
+ TP_ARGS(port)
+);
+
/* End tracepoints */
#endif /* _ICE_TRACE_H_ */
--
2.38.1
^ permalink raw reply related [flat|nested] 29+ messages in thread* Re: [PATCH net-next 00/12][pull request] ice: switchdev bridge offload
2023-06-20 17:44 [PATCH net-next 00/12][pull request] ice: switchdev bridge offload Tony Nguyen
` (11 preceding siblings ...)
2023-06-20 17:44 ` [PATCH net-next 12/12] ice: add tracepoints for the switchdev bridge Tony Nguyen
@ 2023-06-20 18:12 ` Jakub Kicinski
2023-06-21 19:25 ` Vlad Buslov
12 siblings, 1 reply; 29+ messages in thread
From: Jakub Kicinski @ 2023-06-20 18:12 UTC (permalink / raw)
To: Vlad Buslov
Cc: Tony Nguyen, davem, pabeni, edumazet, netdev, wojciech.drewek,
jiri, ivecera, simon.horman
On Tue, 20 Jun 2023 10:44:11 -0700 Tony Nguyen wrote:
> Linux bridge provides ability to learn MAC addresses and vlans
> detected on bridge's ports. As a result of this, FDB (forward data base)
> entries are created and they can be offloaded to the HW. By adding
> VF's port representors to the bridge together with the uplink netdev,
> we can learn VF's and link partner's MAC addresses. This is achieved
> by slow/exception-path, where packets that do not match any filters
> (FDB entries in this case) are send to the bridge ports.
Hi Vlad, it would be great to have your review on this one!
^ permalink raw reply [flat|nested] 29+ messages in thread* Re: [PATCH net-next 00/12][pull request] ice: switchdev bridge offload
2023-06-20 18:12 ` [PATCH net-next 00/12][pull request] ice: switchdev bridge offload Jakub Kicinski
@ 2023-06-21 19:25 ` Vlad Buslov
2023-06-22 17:13 ` Jakub Kicinski
0 siblings, 1 reply; 29+ messages in thread
From: Vlad Buslov @ 2023-06-21 19:25 UTC (permalink / raw)
To: Jakub Kicinski
Cc: Tony Nguyen, davem, pabeni, edumazet, netdev, wojciech.drewek,
jiri, ivecera, simon.horman
On Tue 20 Jun 2023 at 11:12, Jakub Kicinski <kuba@kernel.org> wrote:
> On Tue, 20 Jun 2023 10:44:11 -0700 Tony Nguyen wrote:
>> Linux bridge provides ability to learn MAC addresses and vlans
>> detected on bridge's ports. As a result of this, FDB (forward data base)
>> entries are created and they can be offloaded to the HW. By adding
>> VF's port representors to the bridge together with the uplink netdev,
>> we can learn VF's and link partner's MAC addresses. This is achieved
>> by slow/exception-path, where packets that do not match any filters
>> (FDB entries in this case) are send to the bridge ports.
>
> Hi Vlad, it would be great to have your review on this one!
Hi Jakub. Sorry for late response, I'm OoO till next week and seldom
check my work email. Will try to look at the patches tomorrow.
^ permalink raw reply [flat|nested] 29+ messages in thread
* Re: [PATCH net-next 00/12][pull request] ice: switchdev bridge offload
2023-06-21 19:25 ` Vlad Buslov
@ 2023-06-22 17:13 ` Jakub Kicinski
0 siblings, 0 replies; 29+ messages in thread
From: Jakub Kicinski @ 2023-06-22 17:13 UTC (permalink / raw)
To: Vlad Buslov
Cc: Tony Nguyen, davem, pabeni, edumazet, netdev, wojciech.drewek,
jiri, ivecera, simon.horman
On Wed, 21 Jun 2023 22:25:39 +0300 Vlad Buslov wrote:
> > Hi Vlad, it would be great to have your review on this one!
>
> Hi Jakub. Sorry for late response, I'm OoO till next week and seldom
> check my work email. Will try to look at the patches tomorrow.
Thanks Vlad!
--
pw-bot: cr
^ permalink raw reply [flat|nested] 29+ messages in thread