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
162 struct list_head entry;162 struct list_head entry;
163 struct list_head rdma_event_list;163 struct list_head rdma_event_list;
164 struct workqueue_struct *rdma_wq;164 struct workqueue_struct *rdma_wq;
165 bool exp_recovery;
165};166};
166 167
167struct qede_ptp;168struct qede_ptp;
@@ -264,6 +265,7 @@ struct qede_dev { · 96 unmodified lines
264enum QEDE_STATE {265enum QEDE_STATE {
265 QEDE_STATE_CLOSED,266 QEDE_STATE_CLOSED,
266 QEDE_STATE_OPEN,267 QEDE_STATE_OPEN,
268 QEDE_STATE_RECOVERY,
267};269};
268 270
269#define HILO_U64(hi, lo) ((((u64)(hi)) << 32) + (lo))271#define HILO_U64(hi, lo) ((((u64)(hi)) << 32) + (lo))
@@ -462,6 +464,7 @@ struct qede_fastpath { · 192 unmodified lines
462#define QEDE_CSUM_UNNECESSARY BIT(1)464#define QEDE_CSUM_UNNECESSARY BIT(1)
463#define QEDE_TUNN_CSUM_UNNECESSARY BIT(2)465#define QEDE_TUNN_CSUM_UNNECESSARY BIT(2)
464 466
467#define QEDE_SP_RECOVERY 0
465#define QEDE_SP_RX_MODE 1468#define QEDE_SP_RX_MODE 1
466 469
467#ifdef CONFIG_RFS_ACCEL470#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
133static void qede_remove(struct pci_dev *pdev);133static void qede_remove(struct pci_dev *pdev);
134static void qede_shutdown(struct pci_dev *pdev);134static void qede_shutdown(struct pci_dev *pdev);
135static void qede_link_update(void *dev, struct qed_link_output *link);135static void qede_link_update(void *dev, struct qed_link_output *link);
136static void qede_schedule_recovery_handler(void *dev);
137static void qede_recovery_handler(struct qede_dev *edev);
136static void qede_get_eth_tlv_data(void *edev, void *data);138static void qede_get_eth_tlv_data(void *edev, void *data);
137static void qede_get_generic_tlv_data(void *edev,139static void qede_get_generic_tlv_data(void *edev,
138 struct qed_generic_tlvs *data);140 struct qed_generic_tlvs *data);
139 141
140/* The qede lock is used to protect driver state change and driver flows that
141 * are not reentrant.
142 */
143void __qede_lock(struct qede_dev *edev)
144{
145 mutex_lock(&edev->qede_lock);
146}
147
148void __qede_unlock(struct qede_dev *edev)
149{
150 mutex_unlock(&edev->qede_lock);
151}
152
153#ifdef CONFIG_QED_SRIOV142#ifdef CONFIG_QED_SRIOV
154static int qede_set_vf_vlan(struct net_device *ndev, int vf, u16 vlan, u8 qos,143static int qede_set_vf_vlan(struct net_device *ndev, int vf, u16 vlan, u8 qos,
155 __be16 vlan_proto)144 __be16 vlan_proto)
@@ -231,6 +220,7 @@ static struct qed_eth_cb_ops qede_ll_ops = { · 75 unmodified lines
231 .arfs_filter_op = qede_arfs_filter_op,220 .arfs_filter_op = qede_arfs_filter_op,
232#endif221#endif
233 .link_update = qede_link_update,222 .link_update = qede_link_update,
223 .schedule_recovery_handler = qede_schedule_recovery_handler,
234 .get_generic_tlv_data = qede_get_generic_tlv_data,224 .get_generic_tlv_data = qede_get_generic_tlv_data,
235 .get_protocol_tlv_data = qede_get_eth_tlv_data,225 .get_protocol_tlv_data = qede_get_eth_tlv_data,
236 },226 },
@@ -950,11 +940,57 @@ err: · 713 unmodified lines
950 return -ENOMEM;940 return -ENOMEM;
951}941}
952 942
943/* The qede lock is used to protect driver state change and driver flows that
944 * are not reentrant.
945 */
946void __qede_lock(struct qede_dev *edev)
947{
948 mutex_lock(&edev->qede_lock);
949}
950
951void __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 */
959void qede_lock(struct qede_dev *edev)
960{
961 rtnl_lock();
962 __qede_lock(edev);
963}
964
965void qede_unlock(struct qede_dev *edev)
966{
967 __qede_unlock(edev);
968 rtnl_unlock();
969}
970
953static void qede_sp_task(struct work_struct *work)971static void qede_sp_task(struct work_struct *work)
954{972{
955 struct qede_dev *edev = container_of(work, struct qede_dev,973 struct qede_dev *edev = container_of(work, struct qede_dev,
956 sp_task.work);974 sp_task.work);
957 975
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
958 __qede_lock(edev);994 __qede_lock(edev);
959 995
960 if (test_and_clear_bit(QEDE_SP_RX_MODE, &edev->sp_flags))996 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
1031 1067
1032enum qede_probe_mode {1068enum qede_probe_mode {
1033 QEDE_PROBE_NORMAL,1069 QEDE_PROBE_NORMAL,
1070 QEDE_PROBE_RECOVERY,
1034};1071};
1035 1072
1073#define QEDE_RDMA_PROBE_MODE(mode) \
1074 ((mode) == QEDE_PROBE_NORMAL ? QEDE_RDMA_PROBE_NORMAL \
1075 : QEDE_RDMA_PROBE_RECOVERY)
1076
1036static int __qede_probe(struct pci_dev *pdev, u32 dp_module, u8 dp_level,1077static int __qede_probe(struct pci_dev *pdev, u32 dp_module, u8 dp_level,
1037 bool is_vf, enum qede_probe_mode mode)1078 bool is_vf, enum qede_probe_mode mode)
1038{1079{
@@ -1051,6 +1092,7 @@ static int __qede_probe(struct pci_dev *pdev, u32 dp_module, u8 dp_level, · 12 unmodified lines
1051 probe_params.dp_module = dp_module;1092 probe_params.dp_module = dp_module;
1052 probe_params.dp_level = dp_level;1093 probe_params.dp_level = dp_level;
1053 probe_params.is_vf = is_vf;1094 probe_params.is_vf = is_vf;
1095 probe_params.recov_in_prog = (mode == QEDE_PROBE_RECOVERY);
1054 cdev = qed_ops->common->probe(pdev, &probe_params);1096 cdev = qed_ops->common->probe(pdev, &probe_params);
1055 if (!cdev) {1097 if (!cdev) {
1056 rc = -ENODEV;1098 rc = -ENODEV;
@@ -1078,11 +1120,20 @@ static int __qede_probe(struct pci_dev *pdev, u32 dp_module, u8 dp_level, · 21 unmodified lines
1078 if (rc)1120 if (rc)
1079 goto err2;1121 goto err2;
1080 1122
1081 edev = qede_alloc_etherdev(cdev, pdev, &dev_info, dp_module,1123 if (mode != QEDE_PROBE_RECOVERY) {
1082 dp_level);1124 edev = qede_alloc_etherdev(cdev, pdev, &dev_info, dp_module,
1083 if (!edev) {1125 dp_level);
1084 rc = -ENOMEM;1126 if (!edev) {
1085 goto err2;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));
1086 }1137 }
1087 1138
1088 if (is_vf)1139 if (is_vf)
@@ -1090,28 +1141,31 @@ static int __qede_probe(struct pci_dev *pdev, u32 dp_module, u8 dp_level, · 1 unmodified line
1090 1141
1091 qede_init_ndev(edev);1142 qede_init_ndev(edev);
1092 1143
1093 rc = qede_rdma_dev_add(edev);1144 rc = qede_rdma_dev_add(edev, QEDE_RDMA_PROBE_MODE(mode));
1094 if (rc)1145 if (rc)
1095 goto err3;1146 goto err3;
1096 1147
1097 /* Prepare the lock prior to the registration of the netdev,1148 if (mode != QEDE_PROBE_RECOVERY) {
1098 * as once it's registered we might reach flows requiring it1149 /* Prepare the lock prior to the registration of the netdev,
1099 * [it's even possible to reach a flow needing it directly1150 * as once it's registered we might reach flows requiring it
1100 * from there, although it's unlikely].1151 * [it's even possible to reach a flow needing it directly
1101 */1152 * from there, although it's unlikely].
1102 INIT_DELAYED_WORK(&edev->sp_task, qede_sp_task);1153 */
1103 mutex_init(&edev->qede_lock);1154 INIT_DELAYED_WORK(&edev->sp_task, qede_sp_task);
1104 rc = register_netdev(edev->ndev);1155 mutex_init(&edev->qede_lock);
1105 if (rc) {1156
1106 DP_NOTICE(edev, "Cannot register net-device\n");1157 rc = register_netdev(edev->ndev);
1107 goto err4;1158 if (rc) {
1159 DP_NOTICE(edev, "Cannot register net-device\n");
1160 goto err4;
1161 }
1108 }1162 }
1109 1163
1110 edev->ops->common->set_name(cdev, edev->ndev->name);1164 edev->ops->common->set_name(cdev, edev->ndev->name);
1111 1165
1112 /* PTP not supported on VFs */1166 /* PTP not supported on VFs */
1113 if (!is_vf)1167 if (!is_vf)
1114 qede_ptp_enable(edev, true);1168 qede_ptp_enable(edev, (mode == QEDE_PROBE_NORMAL));
1115 1169
1116 edev->ops->register_ops(cdev, &qede_ll_ops, edev);1170 edev->ops->register_ops(cdev, &qede_ll_ops, edev);
1117 1171
@@ -1126,7 +1180,7 @@ static int __qede_probe(struct pci_dev *pdev, u32 dp_module, u8 dp_level, · 8 unmodified lines
1126 return 0;1180 return 0;
1127 1181
1128err4:1182err4:
1129 qede_rdma_dev_remove(edev);1183 qede_rdma_dev_remove(edev, QEDE_RDMA_PROBE_MODE(mode));
1130err3:1184err3:
1131 free_netdev(edev->ndev);1185 free_netdev(edev->ndev);
1132err2:1186err2:
@@ -1162,8 +1216,13 @@ static int qede_probe(struct pci_dev *pdev, const struct pci_device_id *id) · 29 unmodified lines
1162 1216
1163enum qede_remove_mode {1217enum qede_remove_mode {
1164 QEDE_REMOVE_NORMAL,1218 QEDE_REMOVE_NORMAL,
1219 QEDE_REMOVE_RECOVERY,
1165};1220};
1166 1221
1222#define QEDE_RDMA_REMOVE_MODE(mode) \
1223 ((mode) == QEDE_REMOVE_NORMAL ? QEDE_RDMA_REMOVE_NORMAL \
1224 : QEDE_RDMA_REMOVE_RECOVERY)
1225
1167static void __qede_remove(struct pci_dev *pdev, enum qede_remove_mode mode)1226static void __qede_remove(struct pci_dev *pdev, enum qede_remove_mode mode)
1168{1227{
1169 struct net_device *ndev = pci_get_drvdata(pdev);1228 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
1172 1231
1173 DP_INFO(edev, "Starting qede_remove\n");1232 DP_INFO(edev, "Starting qede_remove\n");
1174 1233
1175 qede_rdma_dev_remove(edev);1234 qede_rdma_dev_remove(edev, QEDE_RDMA_REMOVE_MODE(mode));
1176 unregister_netdev(ndev);
1177 cancel_delayed_work_sync(&edev->sp_task);
1178 1235
1179 qede_ptp_disable(edev);1236 if (mode != QEDE_REMOVE_RECOVERY) {
1237 unregister_netdev(ndev);
1180 1238
1181 edev->ops->common->set_power_state(cdev, PCI_D0);1239 cancel_delayed_work_sync(&edev->sp_task);
1182 1240
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);
1184 1247
1185 /* Use global ops since we've freed edev */1248 /* Use global ops since we've freed edev */
1186 qed_ops->common->slowpath_stop(cdev);1249 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
1194 * [e.g., QED register callbacks] won't break anything when1257 * [e.g., QED register callbacks] won't break anything when
1195 * accessing the netdevice.1258 * accessing the netdevice.
1196 */1259 */
1197 free_netdev(ndev);1260 if (mode != QEDE_REMOVE_RECOVERY)
1261 free_netdev(ndev);
1198 1262
1199 dev_info(&pdev->dev, "Ending qede_remove successfully\n");1263 dev_info(&pdev->dev, "Ending qede_remove successfully\n");
1200}1264}
@@ -1539,6 +1603,58 @@ static int qede_alloc_mem_load(struct qede_dev *edev) · 338 unmodified lines
1539 return 0;1603 return 0;
1540}1604}
1541 1605
1606static 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
1640static 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
1542/* This function inits fp content and resets the SB, RXQ and TXQ structures */1658/* This function inits fp content and resets the SB, RXQ and TXQ structures */
1543static void qede_init_fp(struct qede_dev *edev)1659static void qede_init_fp(struct qede_dev *edev)
1544{1660{
@@ -2053,6 +2169,7 @@ out: · 508 unmodified lines
2053 2169
2054enum qede_unload_mode {2170enum qede_unload_mode {
2055 QEDE_UNLOAD_NORMAL,2171 QEDE_UNLOAD_NORMAL,
2172 QEDE_UNLOAD_RECOVERY,
2056};2173};
2057 2174
2058static void qede_unload(struct qede_dev *edev, enum qede_unload_mode mode,2175static 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
2068 2185
2069 clear_bit(QEDE_FLAGS_LINK_REQUESTED, &edev->flags);2186 clear_bit(QEDE_FLAGS_LINK_REQUESTED, &edev->flags);
2070 2187
2071 edev->state = QEDE_STATE_CLOSED;2188 if (mode != QEDE_UNLOAD_RECOVERY)
2189 edev->state = QEDE_STATE_CLOSED;
2072 2190
2073 qede_rdma_dev_event_close(edev);2191 qede_rdma_dev_event_close(edev);
2074 2192
@@ -2076,17 +2194,20 @@ static void qede_unload(struct qede_dev *edev, enum qede_unload_mode mode, · 1 unmodified line
2076 netif_tx_disable(edev->ndev);2194 netif_tx_disable(edev->ndev);
2077 netif_carrier_off(edev->ndev);2195 netif_carrier_off(edev->ndev);
2078 2196
2079 /* Reset the link */2197 if (mode != QEDE_UNLOAD_RECOVERY) {
2080 memset(&link_params, 0, sizeof(link_params));2198 /* Reset the link */
2081 link_params.link_up = false;2199 memset(&link_params, 0, sizeof(link_params));
2082 edev->ops->common->set_link(edev->cdev, &link_params);2200 link_params.link_up = false;
2083 rc = qede_stop_queues(edev);2201 edev->ops->common->set_link(edev->cdev, &link_params);
2084 if (rc) {
2085 qede_sync_free_irqs(edev);
2086 goto out;
2087 }
2088 2202
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 }
2090 2211
2091 qede_vlan_mark_nonconfigured(edev);2212 qede_vlan_mark_nonconfigured(edev);
2092 edev->ops->fastpath_stop(edev->cdev);2213 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
2102 2223
2103 qede_napi_disable_remove(edev);2224 qede_napi_disable_remove(edev);
2104 2225
2226 if (mode == QEDE_UNLOAD_RECOVERY)
2227 qede_empty_tx_queues(edev);
2228
2105 qede_free_mem_load(edev);2229 qede_free_mem_load(edev);
2106 qede_free_fp_array(edev);2230 qede_free_fp_array(edev);
2107 2231
2108out:2232out:
2109 if (!is_locked)2233 if (!is_locked)
2110 __qede_unlock(edev);2234 __qede_unlock(edev);
2235
2236 if (mode != QEDE_UNLOAD_RECOVERY)
2237 DP_NOTICE(edev, "Link is down\n");
2238
2111 DP_INFO(edev, "Ending qede unload\n");2239 DP_INFO(edev, "Ending qede unload\n");
2112}2240}
2113 2241
2114enum qede_load_mode {2242enum qede_load_mode {
2115 QEDE_LOAD_NORMAL,2243 QEDE_LOAD_NORMAL,
2116 QEDE_LOAD_RELOAD,2244 QEDE_LOAD_RELOAD,
2245 QEDE_LOAD_RECOVERY,
2117};2246};
2118 2247
2119static int qede_load(struct qede_dev *edev, enum qede_load_mode mode,2248static 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
2293 }2422 }
2294}2423}
2295 2424
2425static 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
2441static 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
2451static 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
2492err:
2493 qede_recovery_failed(edev);
2494}
2495
2296static bool qede_is_txq_full(struct qede_dev *edev, struct qede_tx_queue *txq)2496static bool qede_is_txq_full(struct qede_dev *edev, struct qede_tx_queue *txq)
2297{2497{
2298 struct netdev_queue *netdev_txq;2498 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
50 if (!qedr_drv)50 if (!qedr_drv)
51 return;51 return;
52 52
53 /* Leftovers from previous error recovery */
54 edev->rdma_info.exp_recovery = false;
53 edev->rdma_info.qedr_dev = qedr_drv->add(edev->cdev, edev->pdev,55 edev->rdma_info.qedr_dev = qedr_drv->add(edev->cdev, edev->pdev,
54 edev->ndev);56 edev->ndev);
55}57}
@@ -87,21 +89,26 @@ static void qede_rdma_destroy_wq(struct qede_dev *edev) · 31 unmodified lines
87 destroy_workqueue(edev->rdma_info.rdma_wq);89 destroy_workqueue(edev->rdma_info.rdma_wq);
88}90}
89 91
90int qede_rdma_dev_add(struct qede_dev *edev)92int qede_rdma_dev_add(struct qede_dev *edev, enum qede_rdma_probe_mode mode)
91{93{
92 int rc = 0;94 int rc;
93 95
94 if (qede_rdma_supported(edev)) {96 if (!qede_rdma_supported(edev))
95 rc = qede_rdma_create_wq(edev);97 return 0;
96 if (rc)
97 return rc;
98 98
99 INIT_LIST_HEAD(&edev->rdma_info.entry);99 /* Cannot start qedr while recovering since it wasn't fully stopped */
100 mutex_lock(&qedr_dev_list_lock);100 if (mode == QEDE_RDMA_PROBE_RECOVERY)
101 list_add_tail(&edev->rdma_info.entry, &qedr_dev_list);101 return 0;
102 _qede_rdma_dev_add(edev);102
103 mutex_unlock(&qedr_dev_list_lock);103 rc = qede_rdma_create_wq(edev);
104 }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);
105 112
106 return rc;113 return rc;
107}114}
@@ -110,19 +117,31 @@ static void _qede_rdma_dev_remove(struct qede_dev *edev) · 2 unmodified lines
110{117{
111 if (qedr_drv && qedr_drv->remove && edev->rdma_info.qedr_dev)118 if (qedr_drv && qedr_drv->remove && edev->rdma_info.qedr_dev)
112 qedr_drv->remove(edev->rdma_info.qedr_dev);119 qedr_drv->remove(edev->rdma_info.qedr_dev);
113 edev->rdma_info.qedr_dev = NULL;
114}120}
115 121
116void qede_rdma_dev_remove(struct qede_dev *edev)122void qede_rdma_dev_remove(struct qede_dev *edev,
123 enum qede_rdma_remove_mode mode)
117{124{
118 if (!qede_rdma_supported(edev))125 if (!qede_rdma_supported(edev))
119 return;126 return;
120 127
121 qede_rdma_destroy_wq(edev);128 /* Cannot remove qedr while recovering since it wasn't fully stopped */
122 mutex_lock(&qedr_dev_list_lock);129 if (mode == QEDE_RDMA_REMOVE_NORMAL) {
123 _qede_rdma_dev_remove(edev);130 qede_rdma_destroy_wq(edev);
124 list_del(&edev->rdma_info.entry);131 mutex_lock(&qedr_dev_list_lock);
125 mutex_unlock(&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 }
126}145}
127 146
128static void _qede_rdma_dev_open(struct qede_dev *edev)147static 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
204 223
205 mutex_lock(&qedr_dev_list_lock);224 mutex_lock(&qedr_dev_list_lock);
206 list_for_each_entry(edev, &qedr_dev_list, rdma_info.entry) {225 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)
208 _qede_rdma_dev_remove(edev);228 _qede_rdma_dev_remove(edev);
209 }229 }
210 qedr_drv = NULL;230 qedr_drv = NULL;
@@ -284,6 +304,10 @@ static void qede_rdma_add_event(struct qede_dev *edev, · 73 unmodified lines
284{304{
285 struct qede_rdma_event_work *event_node;305 struct qede_rdma_event_work *event_node;
286 306
307 /* If a recovery was experienced avoid adding the event */
308 if (edev->rdma_info.exp_recovery)
309 return;
310
287 if (!edev->rdma_info.qedr_dev)311 if (!edev->rdma_info.qedr_dev)
288 return;312 return;
289 313
include/linux/qed/qede_rdma.h+17−4
@@ -55,6 +55,16 @@ struct qede_rdma_event_work { · 54 unmodified lines
55 enum qede_rdma_event event;55 enum qede_rdma_event event;
56};56};
57 57
58enum qede_rdma_probe_mode {
59 QEDE_RDMA_PROBE_NORMAL,
60 QEDE_RDMA_PROBE_RECOVERY,
61};
62
63enum qede_rdma_remove_mode {
64 QEDE_RDMA_REMOVE_NORMAL,
65 QEDE_RDMA_REMOVE_RECOVERY,
66};
67
58struct qedr_driver {68struct qedr_driver {
59 unsigned char name[32];69 unsigned char name[32];
60 70
@@ -74,21 +84,24 @@ void qede_rdma_unregister_driver(struct qedr_driver *drv); · 13 unmodified lines
74bool qede_rdma_supported(struct qede_dev *dev);84bool qede_rdma_supported(struct qede_dev *dev);
75 85
76#if IS_ENABLED(CONFIG_QED_RDMA)86#if IS_ENABLED(CONFIG_QED_RDMA)
77int qede_rdma_dev_add(struct qede_dev *dev);87int qede_rdma_dev_add(struct qede_dev *dev, enum qede_rdma_probe_mode mode);
78void qede_rdma_dev_event_open(struct qede_dev *dev);88void qede_rdma_dev_event_open(struct qede_dev *dev);
79void qede_rdma_dev_event_close(struct qede_dev *dev);89void qede_rdma_dev_event_close(struct qede_dev *dev);
80void qede_rdma_dev_remove(struct qede_dev *dev);90void qede_rdma_dev_remove(struct qede_dev *dev,
91 enum qede_rdma_remove_mode mode);
81void qede_rdma_event_changeaddr(struct qede_dev *edr);92void qede_rdma_event_changeaddr(struct qede_dev *edr);
82 93
83#else94#else
84static inline int qede_rdma_dev_add(struct qede_dev *dev)95static inline int qede_rdma_dev_add(struct qede_dev *dev,
96 enum qede_rdma_probe_mode mode)
85{97{
86 return 0;98 return 0;
87}99}
88 100
89static inline void qede_rdma_dev_event_open(struct qede_dev *dev) {}101static inline void qede_rdma_dev_event_open(struct qede_dev *dev) {}
90static inline void qede_rdma_dev_event_close(struct qede_dev *dev) {}102static inline void qede_rdma_dev_event_close(struct qede_dev *dev) {}
91static inline void qede_rdma_dev_remove(struct qede_dev *dev) {}103static inline void qede_rdma_dev_remove(struct qede_dev *dev,
104 enum qede_rdma_remove_mode mode) {}
92static inline void qede_rdma_event_changeaddr(struct qede_dev *edr) {}105static inline void qede_rdma_event_changeaddr(struct qede_dev *edr) {}
93#endif106#endif
94#endif107#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