History

qede: Error recovery process

This patch adds the error recovery process in the qede driver. The process includes a partial/customized driver unload and load, which allows it to look like a short suspend period to the kernel while preserving the net devices' state.

Tomer Tayar committed 7 years ago

Commit 278396d1 parent c75860e4 files · +314 −74Browse files

Unified · Split

4 files
  1. drivers/net/ethernet/qlogic/qede/qede.h +3 −0
  2. drivers/net/ethernet/qlogic/qede/qede_main.c +250 −50
  3. drivers/net/ethernet/qlogic/qede/qede_rdma.c +44 −20
  4. include/linux/qed/qede_rdma.h +17 −4
drivers/net/ethernet/qlogic/qede/qede.h+3−0
@@ -162,6 +162,7 @@ struct qede_rdma_dev { · 161 unmodified lines
162162 struct list_head entry;
163163 struct list_head rdma_event_list;
164164 struct workqueue_struct *rdma_wq;
165+ bool exp_recovery;
165166 };
166167
167168 struct qede_ptp;
@@ -264,6 +265,7 @@ struct qede_dev { · 96 unmodified lines
264265 enum QEDE_STATE {
265266 QEDE_STATE_CLOSED,
266267 QEDE_STATE_OPEN,
268+ QEDE_STATE_RECOVERY,
267269 };
268270
269271 #define HILO_U64(hi, lo) ((((u64)(hi)) << 32) + (lo))
@@ -462,6 +464,7 @@ struct qede_fastpath { · 192 unmodified lines
462464 #define QEDE_CSUM_UNNECESSARY BIT(1)
463465 #define QEDE_TUNN_CSUM_UNNECESSARY BIT(2)
464466
467+#define QEDE_SP_RECOVERY 0
465468 #define QEDE_SP_RX_MODE 1
466469
467470 #ifdef CONFIG_RFS_ACCEL
drivers/net/ethernet/qlogic/qede/qede_main.c+250−50
@@ -133,23 +133,12 @@ static int qede_probe(struct pci_dev *pdev, const struct pci_device_id *id); · 132 unmodified lines
133133 static void qede_remove(struct pci_dev *pdev);
134134 static void qede_shutdown(struct pci_dev *pdev);
135135 static void qede_link_update(void *dev, struct qed_link_output *link);
136+static void qede_schedule_recovery_handler(void *dev);
137+static void qede_recovery_handler(struct qede_dev *edev);
136138 static void qede_get_eth_tlv_data(void *edev, void *data);
137139 static void qede_get_generic_tlv_data(void *edev,
138140 struct qed_generic_tlvs *data);
139141
140−/* The qede lock is used to protect driver state change and driver flows that
141− * are not reentrant.
142− */
143−void __qede_lock(struct qede_dev *edev)
144−{
145− mutex_lock(&edev->qede_lock);
146−}
147−
148−void __qede_unlock(struct qede_dev *edev)
149−{
150− mutex_unlock(&edev->qede_lock);
151−}
152−
153142 #ifdef CONFIG_QED_SRIOV
154143 static int qede_set_vf_vlan(struct net_device *ndev, int vf, u16 vlan, u8 qos,
155144 __be16 vlan_proto)
@@ -231,6 +220,7 @@ static struct qed_eth_cb_ops qede_ll_ops = { · 75 unmodified lines
231220 .arfs_filter_op = qede_arfs_filter_op,
232221 #endif
233222 .link_update = qede_link_update,
223+ .schedule_recovery_handler = qede_schedule_recovery_handler,
234224 .get_generic_tlv_data = qede_get_generic_tlv_data,
235225 .get_protocol_tlv_data = qede_get_eth_tlv_data,
236226 },
@@ -950,11 +940,57 @@ err: · 713 unmodified lines
950940 return -ENOMEM;
951941 }
952942
943+/* The qede lock is used to protect driver state change and driver flows that
944+ * are not reentrant.
945+ */
946+void __qede_lock(struct qede_dev *edev)
947+{
948+ mutex_lock(&edev->qede_lock);
949+}
950+
951+void __qede_unlock(struct qede_dev *edev)
952+{
953+ mutex_unlock(&edev->qede_lock);
954+}
955+
956+/* This version of the lock should be used when acquiring the RTNL lock is also
957+ * needed in addition to the internal qede lock.
958+ */
959+void qede_lock(struct qede_dev *edev)
960+{
961+ rtnl_lock();
962+ __qede_lock(edev);
963+}
964+
965+void qede_unlock(struct qede_dev *edev)
966+{
967+ __qede_unlock(edev);
968+ rtnl_unlock();
969+}
970+
953971 static void qede_sp_task(struct work_struct *work)
954972 {
955973 struct qede_dev *edev = container_of(work, struct qede_dev,
956974 sp_task.work);
957975
976+ /* The locking scheme depends on the specific flag:
977+ * In case of QEDE_SP_RECOVERY, acquiring the RTNL lock is required to
978+ * ensure that ongoing flows are ended and new ones are not started.
979+ * In other cases - only the internal qede lock should be acquired.
980+ */
981+
982+ if (test_and_clear_bit(QEDE_SP_RECOVERY, &edev->sp_flags)) {
983+#ifdef CONFIG_QED_SRIOV
984+ /* SRIOV must be disabled outside the lock to avoid a deadlock.
985+ * The recovery of the active VFs is currently not supported.
986+ */
987+ qede_sriov_configure(edev->pdev, 0);
988+#endif
989+ qede_lock(edev);
990+ qede_recovery_handler(edev);
991+ qede_unlock(edev);
992+ }
993+
958994 __qede_lock(edev);
959995
960996 if (test_and_clear_bit(QEDE_SP_RX_MODE, &edev->sp_flags))
@@ -1031,8 +1067,13 @@ static void qede_log_probe(struct qede_dev *edev) · 70 unmodified lines
10311067
10321068 enum qede_probe_mode {
10331069 QEDE_PROBE_NORMAL,
1070+ QEDE_PROBE_RECOVERY,
10341071 };
10351072
1073+#define QEDE_RDMA_PROBE_MODE(mode) \
1074+ ((mode) == QEDE_PROBE_NORMAL ? QEDE_RDMA_PROBE_NORMAL \
1075+ : QEDE_RDMA_PROBE_RECOVERY)
1076+
10361077 static int __qede_probe(struct pci_dev *pdev, u32 dp_module, u8 dp_level,
10371078 bool is_vf, enum qede_probe_mode mode)
10381079 {
@@ -1051,6 +1092,7 @@ static int __qede_probe(struct pci_dev *pdev, u32 dp_module, u8 dp_level, · 12 unmodified lines
10511092 probe_params.dp_module = dp_module;
10521093 probe_params.dp_level = dp_level;
10531094 probe_params.is_vf = is_vf;
1095+ probe_params.recov_in_prog = (mode == QEDE_PROBE_RECOVERY);
10541096 cdev = qed_ops->common->probe(pdev, &probe_params);
10551097 if (!cdev) {
10561098 rc = -ENODEV;
@@ -1078,11 +1120,20 @@ static int __qede_probe(struct pci_dev *pdev, u32 dp_module, u8 dp_level, · 21 unmodified lines
10781120 if (rc)
10791121 goto err2;
10801122
1081− edev = qede_alloc_etherdev(cdev, pdev, &dev_info, dp_module,
1082− dp_level);
1083− if (!edev) {
1084− rc = -ENOMEM;
1085− goto err2;
1123+ if (mode != QEDE_PROBE_RECOVERY) {
1124+ edev = qede_alloc_etherdev(cdev, pdev, &dev_info, dp_module,
1125+ dp_level);
1126+ if (!edev) {
1127+ rc = -ENOMEM;
1128+ goto err2;
1129+ }
1130+ } else {
1131+ struct net_device *ndev = pci_get_drvdata(pdev);
1132+
1133+ edev = netdev_priv(ndev);
1134+ edev->cdev = cdev;
1135+ memset(&edev->stats, 0, sizeof(edev->stats));
1136+ memcpy(&edev->dev_info, &dev_info, sizeof(dev_info));
10861137 }
10871138
10881139 if (is_vf)
@@ -1090,28 +1141,31 @@ static int __qede_probe(struct pci_dev *pdev, u32 dp_module, u8 dp_level, · 1 unmodified line
10901141
10911142 qede_init_ndev(edev);
10921143
1093− rc = qede_rdma_dev_add(edev);
1144+ rc = qede_rdma_dev_add(edev, QEDE_RDMA_PROBE_MODE(mode));
10941145 if (rc)
10951146 goto err3;
10961147
1097− /* Prepare the lock prior to the registration of the netdev,
1098− * as once it's registered we might reach flows requiring it
1099− * [it's even possible to reach a flow needing it directly
1100− * from there, although it's unlikely].
1101− */
1102− INIT_DELAYED_WORK(&edev->sp_task, qede_sp_task);
1103− mutex_init(&edev->qede_lock);
1104− rc = register_netdev(edev->ndev);
1105− if (rc) {
1106− DP_NOTICE(edev, "Cannot register net-device\n");
1107− goto err4;
1148+ if (mode != QEDE_PROBE_RECOVERY) {
1149+ /* Prepare the lock prior to the registration of the netdev,
1150+ * as once it's registered we might reach flows requiring it
1151+ * [it's even possible to reach a flow needing it directly
1152+ * from there, although it's unlikely].
1153+ */
1154+ INIT_DELAYED_WORK(&edev->sp_task, qede_sp_task);
1155+ mutex_init(&edev->qede_lock);
1156+
1157+ rc = register_netdev(edev->ndev);
1158+ if (rc) {
1159+ DP_NOTICE(edev, "Cannot register net-device\n");
1160+ goto err4;
1161+ }
11081162 }
11091163
11101164 edev->ops->common->set_name(cdev, edev->ndev->name);
11111165
11121166 /* PTP not supported on VFs */
11131167 if (!is_vf)
1114− qede_ptp_enable(edev, true);
1168+ qede_ptp_enable(edev, (mode == QEDE_PROBE_NORMAL));
11151169
11161170 edev->ops->register_ops(cdev, &qede_ll_ops, edev);
11171171
@@ -1126,7 +1180,7 @@ static int __qede_probe(struct pci_dev *pdev, u32 dp_module, u8 dp_level, · 8 unmodified lines
11261180 return 0;
11271181
11281182 err4:
1129− qede_rdma_dev_remove(edev);
1183+ qede_rdma_dev_remove(edev, QEDE_RDMA_PROBE_MODE(mode));
11301184 err3:
11311185 free_netdev(edev->ndev);
11321186 err2:
@@ -1162,8 +1216,13 @@ static int qede_probe(struct pci_dev *pdev, const struct pci_device_id *id) · 29 unmodified lines
11621216
11631217 enum qede_remove_mode {
11641218 QEDE_REMOVE_NORMAL,
1219+ QEDE_REMOVE_RECOVERY,
11651220 };
11661221
1222+#define QEDE_RDMA_REMOVE_MODE(mode) \
1223+ ((mode) == QEDE_REMOVE_NORMAL ? QEDE_RDMA_REMOVE_NORMAL \
1224+ : QEDE_RDMA_REMOVE_RECOVERY)
1225+
11671226 static void __qede_remove(struct pci_dev *pdev, enum qede_remove_mode mode)
11681227 {
11691228 struct net_device *ndev = pci_get_drvdata(pdev);
@@ -1172,15 +1231,19 @@ static void __qede_remove(struct pci_dev *pdev, enum qede_remove_mode mode) · 2 unmodified lines
11721231
11731232 DP_INFO(edev, "Starting qede_remove\n");
11741233
1175− qede_rdma_dev_remove(edev);
1176− unregister_netdev(ndev);
1177− cancel_delayed_work_sync(&edev->sp_task);
1234+ qede_rdma_dev_remove(edev, QEDE_RDMA_REMOVE_MODE(mode));
11781235
1179− qede_ptp_disable(edev);
1236+ if (mode != QEDE_REMOVE_RECOVERY) {
1237+ unregister_netdev(ndev);
11801238
1181− edev->ops->common->set_power_state(cdev, PCI_D0);
1239+ cancel_delayed_work_sync(&edev->sp_task);
11821240
1183− pci_set_drvdata(pdev, NULL);
1241+ edev->ops->common->set_power_state(cdev, PCI_D0);
1242+
1243+ pci_set_drvdata(pdev, NULL);
1244+ }
1245+
1246+ qede_ptp_disable(edev);
11841247
11851248 /* Use global ops since we've freed edev */
11861249 qed_ops->common->slowpath_stop(cdev);
@@ -1194,7 +1257,8 @@ static void __qede_remove(struct pci_dev *pdev, enum qede_remove_mode mode) · 7 unmodified lines
11941257 * [e.g., QED register callbacks] won't break anything when
11951258 * accessing the netdevice.
11961259 */
1197− free_netdev(ndev);
1260+ if (mode != QEDE_REMOVE_RECOVERY)
1261+ free_netdev(ndev);
11981262
11991263 dev_info(&pdev->dev, "Ending qede_remove successfully\n");
12001264 }
@@ -1539,6 +1603,58 @@ static int qede_alloc_mem_load(struct qede_dev *edev) · 338 unmodified lines
15391603 return 0;
15401604 }
15411605
1606+static void qede_empty_tx_queue(struct qede_dev *edev,
1607+ struct qede_tx_queue *txq)
1608+{
1609+ unsigned int pkts_compl = 0, bytes_compl = 0;
1610+ struct netdev_queue *netdev_txq;
1611+ int rc, len = 0;
1612+
1613+ netdev_txq = netdev_get_tx_queue(edev->ndev, txq->ndev_txq_id);
1614+
1615+ while (qed_chain_get_cons_idx(&txq->tx_pbl) !=
1616+ qed_chain_get_prod_idx(&txq->tx_pbl)) {
1617+ DP_VERBOSE(edev, NETIF_MSG_IFDOWN,
1618+ "Freeing a packet on tx queue[%d]: chain_cons 0x%x, chain_prod 0x%x\n",
1619+ txq->index, qed_chain_get_cons_idx(&txq->tx_pbl),
1620+ qed_chain_get_prod_idx(&txq->tx_pbl));
1621+
1622+ rc = qede_free_tx_pkt(edev, txq, &len);
1623+ if (rc) {
1624+ DP_NOTICE(edev,
1625+ "Failed to free a packet on tx queue[%d]: chain_cons 0x%x, chain_prod 0x%x\n",
1626+ txq->index,
1627+ qed_chain_get_cons_idx(&txq->tx_pbl),
1628+ qed_chain_get_prod_idx(&txq->tx_pbl));
1629+ break;
1630+ }
1631+
1632+ bytes_compl += len;
1633+ pkts_compl++;
1634+ txq->sw_tx_cons++;
1635+ }
1636+
1637+ netdev_tx_completed_queue(netdev_txq, pkts_compl, bytes_compl);
1638+}
1639+
1640+static void qede_empty_tx_queues(struct qede_dev *edev)
1641+{
1642+ int i;
1643+
1644+ for_each_queue(i)
1645+ if (edev->fp_array[i].type & QEDE_FASTPATH_TX) {
1646+ int cos;
1647+
1648+ for_each_cos_in_txq(edev, cos) {
1649+ struct qede_fastpath *fp;
1650+
1651+ fp = &edev->fp_array[i];
1652+ qede_empty_tx_queue(edev,
1653+ &fp->txq[cos]);
1654+ }
1655+ }
1656+}
1657+
15421658 /* This function inits fp content and resets the SB, RXQ and TXQ structures */
15431659 static void qede_init_fp(struct qede_dev *edev)
15441660 {
@@ -2053,6 +2169,7 @@ out: · 508 unmodified lines
20532169
20542170 enum qede_unload_mode {
20552171 QEDE_UNLOAD_NORMAL,
2172+ QEDE_UNLOAD_RECOVERY,
20562173 };
20572174
20582175 static void qede_unload(struct qede_dev *edev, enum qede_unload_mode mode,
@@ -2068,7 +2185,8 @@ static void qede_unload(struct qede_dev *edev, enum qede_unload_mode mode, · 9 unmodified lines
20682185
20692186 clear_bit(QEDE_FLAGS_LINK_REQUESTED, &edev->flags);
20702187
2071− edev->state = QEDE_STATE_CLOSED;
2188+ if (mode != QEDE_UNLOAD_RECOVERY)
2189+ edev->state = QEDE_STATE_CLOSED;
20722190
20732191 qede_rdma_dev_event_close(edev);
20742192
@@ -2076,17 +2194,20 @@ static void qede_unload(struct qede_dev *edev, enum qede_unload_mode mode, · 1 unmodified line
20762194 netif_tx_disable(edev->ndev);
20772195 netif_carrier_off(edev->ndev);
20782196
2079− /* Reset the link */
2080− memset(&link_params, 0, sizeof(link_params));
2081− link_params.link_up = false;
2082− edev->ops->common->set_link(edev->cdev, &link_params);
2083− rc = qede_stop_queues(edev);
2084− if (rc) {
2085− qede_sync_free_irqs(edev);
2086− goto out;
2087− }
2197+ if (mode != QEDE_UNLOAD_RECOVERY) {
2198+ /* Reset the link */
2199+ memset(&link_params, 0, sizeof(link_params));
2200+ link_params.link_up = false;
2201+ edev->ops->common->set_link(edev->cdev, &link_params);
20882202
2089− DP_INFO(edev, "Stopped Queues\n");
2203+ rc = qede_stop_queues(edev);
2204+ if (rc) {
2205+ qede_sync_free_irqs(edev);
2206+ goto out;
2207+ }
2208+
2209+ DP_INFO(edev, "Stopped Queues\n");
2210+ }
20902211
20912212 qede_vlan_mark_nonconfigured(edev);
20922213 edev->ops->fastpath_stop(edev->cdev);
@@ -2102,18 +2223,26 @@ static void qede_unload(struct qede_dev *edev, enum qede_unload_mode mode, · 9 unmodified lines
21022223
21032224 qede_napi_disable_remove(edev);
21042225
2226+ if (mode == QEDE_UNLOAD_RECOVERY)
2227+ qede_empty_tx_queues(edev);
2228+
21052229 qede_free_mem_load(edev);
21062230 qede_free_fp_array(edev);
21072231
21082232 out:
21092233 if (!is_locked)
21102234 __qede_unlock(edev);
2235+
2236+ if (mode != QEDE_UNLOAD_RECOVERY)
2237+ DP_NOTICE(edev, "Link is down\n");
2238+
21112239 DP_INFO(edev, "Ending qede unload\n");
21122240 }
21132241
21142242 enum qede_load_mode {
21152243 QEDE_LOAD_NORMAL,
21162244 QEDE_LOAD_RELOAD,
2245+ QEDE_LOAD_RECOVERY,
21172246 };
21182247
21192248 static int qede_load(struct qede_dev *edev, enum qede_load_mode mode,
@@ -2293,6 +2422,77 @@ static void qede_link_update(void *dev, struct qed_link_output *link) · 173 unmodified lines
22932422 }
22942423 }
22952424
2425+static void qede_schedule_recovery_handler(void *dev)
2426+{
2427+ struct qede_dev *edev = dev;
2428+
2429+ if (edev->state == QEDE_STATE_RECOVERY) {
2430+ DP_NOTICE(edev,
2431+ "Avoid scheduling a recovery handling since already in recovery state\n");
2432+ return;
2433+ }
2434+
2435+ set_bit(QEDE_SP_RECOVERY, &edev->sp_flags);
2436+ schedule_delayed_work(&edev->sp_task, 0);
2437+
2438+ DP_INFO(edev, "Scheduled a recovery handler\n");
2439+}
2440+
2441+static void qede_recovery_failed(struct qede_dev *edev)
2442+{
2443+ netdev_err(edev->ndev, "Recovery handling has failed. Power cycle is needed.\n");
2444+
2445+ netif_device_detach(edev->ndev);
2446+
2447+ if (edev->cdev)
2448+ edev->ops->common->set_power_state(edev->cdev, PCI_D3hot);
2449+}
2450+
2451+static void qede_recovery_handler(struct qede_dev *edev)
2452+{
2453+ u32 curr_state = edev->state;
2454+ int rc;
2455+
2456+ DP_NOTICE(edev, "Starting a recovery process\n");
2457+
2458+ /* No need to acquire first the qede_lock since is done by qede_sp_task
2459+ * before calling this function.
2460+ */
2461+ edev->state = QEDE_STATE_RECOVERY;
2462+
2463+ edev->ops->common->recovery_prolog(edev->cdev);
2464+
2465+ if (curr_state == QEDE_STATE_OPEN)
2466+ qede_unload(edev, QEDE_UNLOAD_RECOVERY, true);
2467+
2468+ __qede_remove(edev->pdev, QEDE_REMOVE_RECOVERY);
2469+
2470+ rc = __qede_probe(edev->pdev, edev->dp_module, edev->dp_level,
2471+ IS_VF(edev), QEDE_PROBE_RECOVERY);
2472+ if (rc) {
2473+ edev->cdev = NULL;
2474+ goto err;
2475+ }
2476+
2477+ if (curr_state == QEDE_STATE_OPEN) {
2478+ rc = qede_load(edev, QEDE_LOAD_RECOVERY, true);
2479+ if (rc)
2480+ goto err;
2481+
2482+ qede_config_rx_mode(edev->ndev);
2483+ udp_tunnel_get_rx_info(edev->ndev);
2484+ }
2485+
2486+ edev->state = curr_state;
2487+
2488+ DP_NOTICE(edev, "Recovery handling is done\n");
2489+
2490+ return;
2491+
2492+err:
2493+ qede_recovery_failed(edev);
2494+}
2495+
22962496 static bool qede_is_txq_full(struct qede_dev *edev, struct qede_tx_queue *txq)
22972497 {
22982498 struct netdev_queue *netdev_txq;
drivers/net/ethernet/qlogic/qede/qede_rdma.c+44−20
@@ -50,6 +50,8 @@ static void _qede_rdma_dev_add(struct qede_dev *edev) · 49 unmodified lines
5050 if (!qedr_drv)
5151 return;
5252
53+ /* Leftovers from previous error recovery */
54+ edev->rdma_info.exp_recovery = false;
5355 edev->rdma_info.qedr_dev = qedr_drv->add(edev->cdev, edev->pdev,
5456 edev->ndev);
5557 }
@@ -87,21 +89,26 @@ static void qede_rdma_destroy_wq(struct qede_dev *edev) · 31 unmodified lines
8789 destroy_workqueue(edev->rdma_info.rdma_wq);
8890 }
8991
90−int qede_rdma_dev_add(struct qede_dev *edev)
92+int qede_rdma_dev_add(struct qede_dev *edev, enum qede_rdma_probe_mode mode)
9193 {
92− int rc = 0;
94+ int rc;
9395
94− if (qede_rdma_supported(edev)) {
95− rc = qede_rdma_create_wq(edev);
96− if (rc)
97− return rc;
96+ if (!qede_rdma_supported(edev))
97+ return 0;
9898
99− INIT_LIST_HEAD(&edev->rdma_info.entry);
100− mutex_lock(&qedr_dev_list_lock);
101− list_add_tail(&edev->rdma_info.entry, &qedr_dev_list);
102− _qede_rdma_dev_add(edev);
103− mutex_unlock(&qedr_dev_list_lock);
104− }
99+ /* Cannot start qedr while recovering since it wasn't fully stopped */
100+ if (mode == QEDE_RDMA_PROBE_RECOVERY)
101+ return 0;
102+
103+ rc = qede_rdma_create_wq(edev);
104+ if (rc)
105+ return rc;
106+
107+ INIT_LIST_HEAD(&edev->rdma_info.entry);
108+ mutex_lock(&qedr_dev_list_lock);
109+ list_add_tail(&edev->rdma_info.entry, &qedr_dev_list);
110+ _qede_rdma_dev_add(edev);
111+ mutex_unlock(&qedr_dev_list_lock);
105112
106113 return rc;
107114 }
@@ -110,19 +117,31 @@ static void _qede_rdma_dev_remove(struct qede_dev *edev) · 2 unmodified lines
110117 {
111118 if (qedr_drv && qedr_drv->remove && edev->rdma_info.qedr_dev)
112119 qedr_drv->remove(edev->rdma_info.qedr_dev);
113− edev->rdma_info.qedr_dev = NULL;
114120 }
115121
116−void qede_rdma_dev_remove(struct qede_dev *edev)
122+void qede_rdma_dev_remove(struct qede_dev *edev,
123+ enum qede_rdma_remove_mode mode)
117124 {
118125 if (!qede_rdma_supported(edev))
119126 return;
120127
121− qede_rdma_destroy_wq(edev);
122− mutex_lock(&qedr_dev_list_lock);
123− _qede_rdma_dev_remove(edev);
124− list_del(&edev->rdma_info.entry);
125− mutex_unlock(&qedr_dev_list_lock);
128+ /* Cannot remove qedr while recovering since it wasn't fully stopped */
129+ if (mode == QEDE_RDMA_REMOVE_NORMAL) {
130+ qede_rdma_destroy_wq(edev);
131+ mutex_lock(&qedr_dev_list_lock);
132+ if (!edev->rdma_info.exp_recovery)
133+ _qede_rdma_dev_remove(edev);
134+ edev->rdma_info.qedr_dev = NULL;
135+ list_del(&edev->rdma_info.entry);
136+ mutex_unlock(&qedr_dev_list_lock);
137+ } else {
138+ if (!edev->rdma_info.exp_recovery) {
139+ mutex_lock(&qedr_dev_list_lock);
140+ _qede_rdma_dev_remove(edev);
141+ mutex_unlock(&qedr_dev_list_lock);
142+ }
143+ edev->rdma_info.exp_recovery = true;
144+ }
126145 }
127146
128147 static void _qede_rdma_dev_open(struct qede_dev *edev)
@@ -204,7 +223,8 @@ void qede_rdma_unregister_driver(struct qedr_driver *drv) · 75 unmodified lines
204223
205224 mutex_lock(&qedr_dev_list_lock);
206225 list_for_each_entry(edev, &qedr_dev_list, rdma_info.entry) {
207− if (edev->rdma_info.qedr_dev)
226+ /* If device has experienced recovery it was already removed */
227+ if (edev->rdma_info.qedr_dev && !edev->rdma_info.exp_recovery)
208228 _qede_rdma_dev_remove(edev);
209229 }
210230 qedr_drv = NULL;
@@ -284,6 +304,10 @@ static void qede_rdma_add_event(struct qede_dev *edev, · 73 unmodified lines
284304 {
285305 struct qede_rdma_event_work *event_node;
286306
307+ /* If a recovery was experienced avoid adding the event */
308+ if (edev->rdma_info.exp_recovery)
309+ return;
310+
287311 if (!edev->rdma_info.qedr_dev)
288312 return;
289313
include/linux/qed/qede_rdma.h+17−4
@@ -55,6 +55,16 @@ struct qede_rdma_event_work { · 54 unmodified lines
5555 enum qede_rdma_event event;
5656 };
5757
58+enum qede_rdma_probe_mode {
59+ QEDE_RDMA_PROBE_NORMAL,
60+ QEDE_RDMA_PROBE_RECOVERY,
61+};
62+
63+enum qede_rdma_remove_mode {
64+ QEDE_RDMA_REMOVE_NORMAL,
65+ QEDE_RDMA_REMOVE_RECOVERY,
66+};
67+
5868 struct qedr_driver {
5969 unsigned char name[32];
6070
@@ -74,21 +84,24 @@ void qede_rdma_unregister_driver(struct qedr_driver *drv); · 13 unmodified lines
7484 bool qede_rdma_supported(struct qede_dev *dev);
7585
7686 #if IS_ENABLED(CONFIG_QED_RDMA)
77−int qede_rdma_dev_add(struct qede_dev *dev);
87+int qede_rdma_dev_add(struct qede_dev *dev, enum qede_rdma_probe_mode mode);
7888 void qede_rdma_dev_event_open(struct qede_dev *dev);
7989 void qede_rdma_dev_event_close(struct qede_dev *dev);
80−void qede_rdma_dev_remove(struct qede_dev *dev);
90+void qede_rdma_dev_remove(struct qede_dev *dev,
91+ enum qede_rdma_remove_mode mode);
8192 void qede_rdma_event_changeaddr(struct qede_dev *edr);
8293
8394 #else
84−static inline int qede_rdma_dev_add(struct qede_dev *dev)
95+static inline int qede_rdma_dev_add(struct qede_dev *dev,
96+ enum qede_rdma_probe_mode mode)
8597 {
8698 return 0;
8799 }
88100
89101 static inline void qede_rdma_dev_event_open(struct qede_dev *dev) {}
90102 static inline void qede_rdma_dev_event_close(struct qede_dev *dev) {}
91−static inline void qede_rdma_dev_remove(struct qede_dev *dev) {}
103+static inline void qede_rdma_dev_remove(struct qede_dev *dev,
104+ enum qede_rdma_remove_mode mode) {}
92105 static inline void qede_rdma_event_changeaddr(struct qede_dev *edr) {}
93106 #endif
94107 #endif

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t