ice: Fix VF Reset paths when interface in a failed over aggregate

[ Upstream commit 9f74a3dfcf83e11aedcb98250b8040dbc6d9659a ]

There is an error when an interface has the following conditions:
- PF is in an aggregate (bond)
- PF has VFs created on it
- bond is in a state where it is failed-over to the secondary interface
- A VF reset is issued on one or more of those VFs

The issue is generated by the originating PF trying to rebuild or
reconfigure the VF resources.  Since the bond is failed over to the
secondary interface the queue contexts are in a modified state.

To fix this issue, have the originating interface reclaim its resources
prior to the tear-down and rebuild or reconfigure.  Then after the process
is complete, move the resources back to the currently active interface.

There are multiple paths that can be used depending on what triggered the
event, so create a helper function to move the queues and use paired calls
to the helper (back to origin, process, then move back to active interface)
under the same lag_mutex lock.

Fixes: 1e0f9881ef79 ("ice: Flesh out implementation of support for SRIOV on bonded interface")
Signed-off-by: Dave Ertman <david.m.ertman@intel.com>
Tested-by: Sujai Buvaneswaran <sujai.buvaneswaran@intel.com>
Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
Reviewed-by: Przemek Kitszel <przemyslaw.kitszel@intel.com>
Link: https://lore.kernel.org/r/20231127212340.1137657-1-anthony.l.nguyen@intel.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
Signed-off-by: Sasha Levin <sashal@kernel.org>

diff --git a/drivers/net/ethernet/intel/ice/ice_lag.c b/drivers/net/ethernet/intel/ice/ice_lag.c
index fb40ad98e6aad04212426fc3790bbb0ba23949a8..d86e2460b5a4d9ba61daf1d4f94cfc264195cda0 100644 (file)
--- a/drivers/net/ethernet/intel/ice/ice_lag.c
+++ b/drivers/net/ethernet/intel/ice/ice_lag.c
@@ -536,6 +536,50 @@ resume_traffic:
                dev_dbg(dev, "Problem restarting traffic for LAG node move\n");
 }
 
+/**
+ * ice_lag_build_netdev_list - populate the lag struct's netdev list
+ * @lag: local lag struct
+ * @ndlist: pointer to netdev list to populate
+ */
+static void ice_lag_build_netdev_list(struct ice_lag *lag,
+                                     struct ice_lag_netdev_list *ndlist)
+{
+       struct ice_lag_netdev_list *nl;
+       struct net_device *tmp_nd;
+
+       INIT_LIST_HEAD(&ndlist->node);
+       rcu_read_lock();
+       for_each_netdev_in_bond_rcu(lag->upper_netdev, tmp_nd) {
+               nl = kzalloc(sizeof(*nl), GFP_ATOMIC);
+               if (!nl)
+                       break;
+
+               nl->netdev = tmp_nd;
+               list_add(&nl->node, &ndlist->node);
+       }
+       rcu_read_unlock();
+       lag->netdev_head = &ndlist->node;
+}
+
+/**
+ * ice_lag_destroy_netdev_list - free lag struct's netdev list
+ * @lag: pointer to local lag struct
+ * @ndlist: pointer to lag struct netdev list
+ */
+static void ice_lag_destroy_netdev_list(struct ice_lag *lag,
+                                       struct ice_lag_netdev_list *ndlist)
+{
+       struct ice_lag_netdev_list *entry, *n;
+
+       rcu_read_lock();
+       list_for_each_entry_safe(entry, n, &ndlist->node, node) {
+               list_del(&entry->node);
+               kfree(entry);
+       }
+       rcu_read_unlock();
+       lag->netdev_head = NULL;
+}
+
 /**
  * ice_lag_move_single_vf_nodes - Move Tx scheduling nodes for single VF
  * @lag: primary interface LAG struct
@@ -564,7 +608,6 @@ ice_lag_move_single_vf_nodes(struct ice_lag *lag, u8 oldport, u8 newport,
 void ice_lag_move_new_vf_nodes(struct ice_vf *vf)
 {
        struct ice_lag_netdev_list ndlist;
-       struct list_head *tmp, *n;
        u8 pri_port, act_port;
        struct ice_lag *lag;
        struct ice_vsi *vsi;
@@ -588,38 +631,15 @@ void ice_lag_move_new_vf_nodes(struct ice_vf *vf)
        pri_port = pf->hw.port_info->lport;
        act_port = lag->active_port;
 
-       if (lag->upper_netdev) {
-               struct ice_lag_netdev_list *nl;
-               struct net_device *tmp_nd;
-
-               INIT_LIST_HEAD(&ndlist.node);
-               rcu_read_lock();
-               for_each_netdev_in_bond_rcu(lag->upper_netdev, tmp_nd) {
-                       nl = kzalloc(sizeof(*nl), GFP_ATOMIC);
-                       if (!nl)
-                               break;
-
-                       nl->netdev = tmp_nd;
-                       list_add(&nl->node, &ndlist.node);
-               }
-               rcu_read_unlock();
-       }
-
-       lag->netdev_head = &ndlist.node;
+       if (lag->upper_netdev)
+               ice_lag_build_netdev_list(lag, &ndlist);
 
        if (ice_is_feature_supported(pf, ICE_F_SRIOV_LAG) &&
            lag->bonded && lag->primary && pri_port != act_port &&
            !list_empty(lag->netdev_head))
                ice_lag_move_single_vf_nodes(lag, pri_port, act_port, vsi->idx);
 
-       list_for_each_safe(tmp, n, &ndlist.node) {
-               struct ice_lag_netdev_list *entry;
-
-               entry = list_entry(tmp, struct ice_lag_netdev_list, node);
-               list_del(&entry->node);
-               kfree(entry);
-       }
-       lag->netdev_head = NULL;
+       ice_lag_destroy_netdev_list(lag, &ndlist);
 
 new_vf_unlock:
        mutex_unlock(&pf->lag_mutex);
@@ -646,6 +666,29 @@ static void ice_lag_move_vf_nodes(struct ice_lag *lag, u8 oldport, u8 newport)
                        ice_lag_move_single_vf_nodes(lag, oldport, newport, i);
 }
 
+/**
+ * ice_lag_move_vf_nodes_cfg - move vf nodes outside LAG netdev event context
+ * @lag: local lag struct
+ * @src_prt: lport value for source port
+ * @dst_prt: lport value for destination port
+ *
+ * This function is used to move nodes during an out-of-netdev-event situation,
+ * primarily when the driver needs to reconfigure or recreate resources.
+ *
+ * Must be called while holding the lag_mutex to avoid lag events from
+ * processing while out-of-sync moves are happening.  Also, paired moves,
+ * such as used in a reset flow, should both be called under the same mutex
+ * lock to avoid changes between start of reset and end of reset.
+ */
+void ice_lag_move_vf_nodes_cfg(struct ice_lag *lag, u8 src_prt, u8 dst_prt)
+{
+       struct ice_lag_netdev_list ndlist;
+
+       ice_lag_build_netdev_list(lag, &ndlist);
+       ice_lag_move_vf_nodes(lag, src_prt, dst_prt);
+       ice_lag_destroy_netdev_list(lag, &ndlist);
+}
+
 #define ICE_LAG_SRIOV_CP_RECIPE                10
 #define ICE_LAG_SRIOV_TRAIN_PKT_LEN    16
 
@@ -2022,7 +2065,6 @@ void ice_lag_rebuild(struct ice_pf *pf)
 {
        struct ice_lag_netdev_list ndlist;
        struct ice_lag *lag, *prim_lag;
-       struct list_head *tmp, *n;
        u8 act_port, loc_port;
 
        if (!pf->lag || !pf->lag->bonded)
@@ -2034,21 +2076,7 @@ void ice_lag_rebuild(struct ice_pf *pf)
        if (lag->primary) {
                prim_lag = lag;
        } else {
-               struct ice_lag_netdev_list *nl;
-               struct net_device *tmp_nd;
-
-               INIT_LIST_HEAD(&ndlist.node);
-               rcu_read_lock();
-               for_each_netdev_in_bond_rcu(lag->upper_netdev, tmp_nd) {
-                       nl = kzalloc(sizeof(*nl), GFP_ATOMIC);
-                       if (!nl)
-                               break;
-
-                       nl->netdev = tmp_nd;
-                       list_add(&nl->node, &ndlist.node);
-               }
-               rcu_read_unlock();
-               lag->netdev_head = &ndlist.node;
+               ice_lag_build_netdev_list(lag, &ndlist);
                prim_lag = ice_lag_find_primary(lag);
        }
 
@@ -2078,13 +2106,7 @@ void ice_lag_rebuild(struct ice_pf *pf)
 
        ice_clear_rdma_cap(pf);
 lag_rebuild_out:
-       list_for_each_safe(tmp, n, &ndlist.node) {
-               struct ice_lag_netdev_list *entry;
-
-               entry = list_entry(tmp, struct ice_lag_netdev_list, node);
-               list_del(&entry->node);
-               kfree(entry);
-       }
+       ice_lag_destroy_netdev_list(lag, &ndlist);
        mutex_unlock(&pf->lag_mutex);
 }
 

diff --git a/drivers/net/ethernet/intel/ice/ice_lag.h b/drivers/net/ethernet/intel/ice/ice_lag.h
index facb6c894b6dd17ff13d92e53bcd9af2a6db726e..7f22987675012390180222a39d9f92fe732017f9 100644 (file)
--- a/drivers/net/ethernet/intel/ice/ice_lag.h
+++ b/drivers/net/ethernet/intel/ice/ice_lag.h
@@ -63,4 +63,5 @@ int ice_init_lag(struct ice_pf *pf);
 void ice_deinit_lag(struct ice_pf *pf);
 void ice_lag_rebuild(struct ice_pf *pf);
 bool ice_lag_is_switchdev_running(struct ice_pf *pf);
+void ice_lag_move_vf_nodes_cfg(struct ice_lag *lag, u8 src_prt, u8 dst_prt);
 #endif /* _ICE_LAG_H_ */

diff --git a/drivers/net/ethernet/intel/ice/ice_vf_lib.c b/drivers/net/ethernet/intel/ice/ice_vf_lib.c
index 24e4f4d897b6667d717683f1e52aa0ab2db033b5..d488c7156d093161278b2169e2a6450493f397a7 100644 (file)
--- a/drivers/net/ethernet/intel/ice/ice_vf_lib.c
+++ b/drivers/net/ethernet/intel/ice/ice_vf_lib.c
@@ -827,12 +827,16 @@ static void ice_notify_vf_reset(struct ice_vf *vf)
 int ice_reset_vf(struct ice_vf *vf, u32 flags)
 {
        struct ice_pf *pf = vf->pf;
+       struct ice_lag *lag;
        struct ice_vsi *vsi;
+       u8 act_prt, pri_prt;
        struct device *dev;
        int err = 0;
        bool rsd;
 
        dev = ice_pf_to_dev(pf);
+       act_prt = ICE_LAG_INVALID_PORT;
+       pri_prt = pf->hw.port_info->lport;
 
        if (flags & ICE_VF_RESET_NOTIFY)
                ice_notify_vf_reset(vf);
@@ -843,6 +847,17 @@ int ice_reset_vf(struct ice_vf *vf, u32 flags)
                return 0;
        }
 
+       lag = pf->lag;
+       mutex_lock(&pf->lag_mutex);
+       if (lag && lag->bonded && lag->primary) {
+               act_prt = lag->active_port;
+               if (act_prt != pri_prt && act_prt != ICE_LAG_INVALID_PORT &&
+                   lag->upper_netdev)
+                       ice_lag_move_vf_nodes_cfg(lag, act_prt, pri_prt);
+               else
+                       act_prt = ICE_LAG_INVALID_PORT;
+       }
+
        if (flags & ICE_VF_RESET_LOCK)
                mutex_lock(&vf->cfg_lock);
        else
@@ -935,6 +950,11 @@ out_unlock:
        if (flags & ICE_VF_RESET_LOCK)
                mutex_unlock(&vf->cfg_lock);
 
+       if (lag && lag->bonded && lag->primary &&
+           act_prt != ICE_LAG_INVALID_PORT)
+               ice_lag_move_vf_nodes_cfg(lag, pri_prt, act_prt);
+       mutex_unlock(&pf->lag_mutex);
+
        return err;
 }
 

diff --git a/drivers/net/ethernet/intel/ice/ice_virtchnl.c b/drivers/net/ethernet/intel/ice/ice_virtchnl.c
index db97353efd067f496150bdf0a2213fa3b1755414..62337e6569b2368cca16b5860e2425cea7ff3db6 100644 (file)
--- a/drivers/net/ethernet/intel/ice/ice_virtchnl.c
+++ b/drivers/net/ethernet/intel/ice/ice_virtchnl.c
@@ -1600,9 +1600,24 @@ static int ice_vc_cfg_qs_msg(struct ice_vf *vf, u8 *msg)
            (struct virtchnl_vsi_queue_config_info *)msg;
        struct virtchnl_queue_pair_info *qpi;
        struct ice_pf *pf = vf->pf;
+       struct ice_lag *lag;
        struct ice_vsi *vsi;
+       u8 act_prt, pri_prt;
        int i = -1, q_idx;
 
+       lag = pf->lag;
+       mutex_lock(&pf->lag_mutex);
+       act_prt = ICE_LAG_INVALID_PORT;
+       pri_prt = pf->hw.port_info->lport;
+       if (lag && lag->bonded && lag->primary) {
+               act_prt = lag->active_port;
+               if (act_prt != pri_prt && act_prt != ICE_LAG_INVALID_PORT &&
+                   lag->upper_netdev)
+                       ice_lag_move_vf_nodes_cfg(lag, act_prt, pri_prt);
+               else
+                       act_prt = ICE_LAG_INVALID_PORT;
+       }
+
        if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states))
                goto error_param;
 
@@ -1710,6 +1725,11 @@ static int ice_vc_cfg_qs_msg(struct ice_vf *vf, u8 *msg)
                }
        }
 
+       if (lag && lag->bonded && lag->primary &&
+           act_prt != ICE_LAG_INVALID_PORT)
+               ice_lag_move_vf_nodes_cfg(lag, pri_prt, act_prt);
+       mutex_unlock(&pf->lag_mutex);
+
        /* send the response to the VF */
        return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_CONFIG_VSI_QUEUES,
                                     VIRTCHNL_STATUS_SUCCESS, NULL, 0);
@@ -1724,6 +1744,11 @@ error_param:
                                vf->vf_id, i);
        }
 
+       if (lag && lag->bonded && lag->primary &&
+           act_prt != ICE_LAG_INVALID_PORT)
+               ice_lag_move_vf_nodes_cfg(lag, pri_prt, act_prt);
+       mutex_unlock(&pf->lag_mutex);
+
        ice_lag_move_new_vf_nodes(vf);
 
        /* send the response to the VF */