1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (c) 2019 Mellanox Technologies.
3
4 #include "health.h"
5 #include "params.h"
6 #include "txrx.h"
7 #include "devlink.h"
8 #include "ptp.h"
9
mlx5e_query_rq_state(struct mlx5_core_dev * dev,u32 rqn,u8 * state)10 static int mlx5e_query_rq_state(struct mlx5_core_dev *dev, u32 rqn, u8 *state)
11 {
12 int outlen = MLX5_ST_SZ_BYTES(query_rq_out);
13 void *out;
14 void *rqc;
15 int err;
16
17 out = kvzalloc(outlen, GFP_KERNEL);
18 if (!out)
19 return -ENOMEM;
20
21 err = mlx5_core_query_rq(dev, rqn, out);
22 if (err)
23 goto out;
24
25 rqc = MLX5_ADDR_OF(query_rq_out, out, rq_context);
26 *state = MLX5_GET(rqc, rqc, state);
27
28 out:
29 kvfree(out);
30 return err;
31 }
32
mlx5e_wait_for_icosq_flush(struct mlx5e_icosq * icosq)33 static int mlx5e_wait_for_icosq_flush(struct mlx5e_icosq *icosq)
34 {
35 unsigned long exp_time = jiffies +
36 msecs_to_jiffies(MLX5E_REPORTER_FLUSH_TIMEOUT_MSEC);
37
38 while (time_before(jiffies, exp_time)) {
39 if (icosq->cc == icosq->pc)
40 return 0;
41
42 msleep(20);
43 }
44
45 netdev_err(icosq->channel->netdev,
46 "Wait for ICOSQ 0x%x flush timeout (cc = 0x%x, pc = 0x%x)\n",
47 icosq->sqn, icosq->cc, icosq->pc);
48
49 return -ETIMEDOUT;
50 }
51
mlx5e_reset_icosq_cc_pc(struct mlx5e_icosq * icosq)52 static void mlx5e_reset_icosq_cc_pc(struct mlx5e_icosq *icosq)
53 {
54 WARN_ONCE(icosq->cc != icosq->pc, "ICOSQ 0x%x: cc (0x%x) != pc (0x%x)\n",
55 icosq->sqn, icosq->cc, icosq->pc);
56 icosq->cc = 0;
57 icosq->pc = 0;
58 }
59
mlx5e_rx_reporter_err_icosq_cqe_recover(void * ctx)60 static int mlx5e_rx_reporter_err_icosq_cqe_recover(void *ctx)
61 {
62 struct mlx5e_rq *xskrq = NULL;
63 struct mlx5_core_dev *mdev;
64 struct mlx5e_icosq *icosq;
65 struct net_device *dev;
66 struct mlx5e_rq *rq;
67 u8 state;
68 int err;
69
70 icosq = ctx;
71
72 mutex_lock(&icosq->channel->icosq_recovery_lock);
73
74 /* mlx5e_close_rq cancels this work before RQ and ICOSQ are killed. */
75 rq = &icosq->channel->rq;
76 if (test_bit(MLX5E_RQ_STATE_ENABLED, &icosq->channel->xskrq.state))
77 xskrq = &icosq->channel->xskrq;
78 mdev = icosq->channel->mdev;
79 dev = icosq->channel->netdev;
80 err = mlx5_core_query_sq_state(mdev, icosq->sqn, &state);
81 if (err) {
82 netdev_err(dev, "Failed to query ICOSQ 0x%x state. err = %d\n",
83 icosq->sqn, err);
84 goto out;
85 }
86
87 if (state != MLX5_SQC_STATE_ERR)
88 goto out;
89
90 mlx5e_deactivate_rq(rq);
91 if (xskrq)
92 mlx5e_deactivate_rq(xskrq);
93
94 err = mlx5e_wait_for_icosq_flush(icosq);
95 if (err)
96 goto out;
97
98 mlx5e_deactivate_icosq(icosq);
99
100 /* At this point, both the rq and the icosq are disabled */
101
102 err = mlx5e_health_sq_to_ready(mdev, dev, icosq->sqn);
103 if (err)
104 goto out;
105
106 mlx5e_reset_icosq_cc_pc(icosq);
107
108 mlx5e_free_rx_in_progress_descs(rq);
109 if (xskrq)
110 mlx5e_free_rx_in_progress_descs(xskrq);
111
112 clear_bit(MLX5E_SQ_STATE_RECOVERING, &icosq->state);
113 mlx5e_activate_icosq(icosq);
114
115 mlx5e_activate_rq(rq);
116 rq->stats->recover++;
117
118 if (xskrq) {
119 mlx5e_activate_rq(xskrq);
120 xskrq->stats->recover++;
121 }
122
123 mutex_unlock(&icosq->channel->icosq_recovery_lock);
124
125 return 0;
126 out:
127 clear_bit(MLX5E_SQ_STATE_RECOVERING, &icosq->state);
128 mutex_unlock(&icosq->channel->icosq_recovery_lock);
129 return err;
130 }
131
mlx5e_rx_reporter_err_rq_cqe_recover(void * ctx)132 static int mlx5e_rx_reporter_err_rq_cqe_recover(void *ctx)
133 {
134 struct mlx5e_rq *rq = ctx;
135 int err;
136
137 mlx5e_deactivate_rq(rq);
138 err = mlx5e_flush_rq(rq, MLX5_RQC_STATE_ERR);
139 clear_bit(MLX5E_RQ_STATE_RECOVERING, &rq->state);
140 if (err)
141 return err;
142
143 mlx5e_activate_rq(rq);
144 rq->stats->recover++;
145 return 0;
146 }
147
mlx5e_rx_reporter_timeout_recover(void * ctx)148 static int mlx5e_rx_reporter_timeout_recover(void *ctx)
149 {
150 struct mlx5_eq_comp *eq;
151 struct mlx5e_rq *rq;
152 int err;
153
154 rq = ctx;
155 eq = rq->cq.mcq.eq;
156
157 err = mlx5e_health_channel_eq_recover(rq->netdev, eq, rq->cq.ch_stats);
158 if (err && rq->icosq)
159 clear_bit(MLX5E_SQ_STATE_ENABLED, &rq->icosq->state);
160
161 return err;
162 }
163
mlx5e_rx_reporter_recover_from_ctx(struct mlx5e_err_ctx * err_ctx)164 static int mlx5e_rx_reporter_recover_from_ctx(struct mlx5e_err_ctx *err_ctx)
165 {
166 return err_ctx->recover(err_ctx->ctx);
167 }
168
mlx5e_rx_reporter_recover(struct devlink_health_reporter * reporter,void * context,struct netlink_ext_ack * extack)169 static int mlx5e_rx_reporter_recover(struct devlink_health_reporter *reporter,
170 void *context,
171 struct netlink_ext_ack *extack)
172 {
173 struct mlx5e_priv *priv = devlink_health_reporter_priv(reporter);
174 struct mlx5e_err_ctx *err_ctx = context;
175
176 return err_ctx ? mlx5e_rx_reporter_recover_from_ctx(err_ctx) :
177 mlx5e_health_recover_channels(priv);
178 }
179
mlx5e_reporter_icosq_diagnose(struct mlx5e_icosq * icosq,u8 hw_state,struct devlink_fmsg * fmsg)180 static int mlx5e_reporter_icosq_diagnose(struct mlx5e_icosq *icosq, u8 hw_state,
181 struct devlink_fmsg *fmsg)
182 {
183 int err;
184
185 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "ICOSQ");
186 if (err)
187 return err;
188
189 err = devlink_fmsg_u32_pair_put(fmsg, "sqn", icosq->sqn);
190 if (err)
191 return err;
192
193 err = devlink_fmsg_u8_pair_put(fmsg, "HW state", hw_state);
194 if (err)
195 return err;
196
197 err = devlink_fmsg_u32_pair_put(fmsg, "cc", icosq->cc);
198 if (err)
199 return err;
200
201 err = devlink_fmsg_u32_pair_put(fmsg, "pc", icosq->pc);
202 if (err)
203 return err;
204
205 err = devlink_fmsg_u32_pair_put(fmsg, "WQE size",
206 mlx5_wq_cyc_get_size(&icosq->wq));
207 if (err)
208 return err;
209
210 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "CQ");
211 if (err)
212 return err;
213
214 err = devlink_fmsg_u32_pair_put(fmsg, "cqn", icosq->cq.mcq.cqn);
215 if (err)
216 return err;
217
218 err = devlink_fmsg_u32_pair_put(fmsg, "cc", icosq->cq.wq.cc);
219 if (err)
220 return err;
221
222 err = devlink_fmsg_u32_pair_put(fmsg, "size", mlx5_cqwq_get_size(&icosq->cq.wq));
223 if (err)
224 return err;
225
226 err = mlx5e_health_fmsg_named_obj_nest_end(fmsg);
227 if (err)
228 return err;
229
230 return mlx5e_health_fmsg_named_obj_nest_end(fmsg);
231 }
232
233 static int
mlx5e_rx_reporter_build_diagnose_output_rq_common(struct mlx5e_rq * rq,struct devlink_fmsg * fmsg)234 mlx5e_rx_reporter_build_diagnose_output_rq_common(struct mlx5e_rq *rq,
235 struct devlink_fmsg *fmsg)
236 {
237 u16 wqe_counter;
238 int wqes_sz;
239 u8 hw_state;
240 u16 wq_head;
241 int err;
242
243 err = mlx5e_query_rq_state(rq->mdev, rq->rqn, &hw_state);
244 if (err)
245 return err;
246
247 wqes_sz = mlx5e_rqwq_get_cur_sz(rq);
248 wq_head = mlx5e_rqwq_get_head(rq);
249 wqe_counter = mlx5e_rqwq_get_wqe_counter(rq);
250
251 err = devlink_fmsg_u32_pair_put(fmsg, "rqn", rq->rqn);
252 if (err)
253 return err;
254
255 err = devlink_fmsg_u8_pair_put(fmsg, "HW state", hw_state);
256 if (err)
257 return err;
258
259 err = devlink_fmsg_u8_pair_put(fmsg, "SW state", rq->state);
260 if (err)
261 return err;
262
263 err = devlink_fmsg_u32_pair_put(fmsg, "WQE counter", wqe_counter);
264 if (err)
265 return err;
266
267 err = devlink_fmsg_u32_pair_put(fmsg, "posted WQEs", wqes_sz);
268 if (err)
269 return err;
270
271 err = devlink_fmsg_u32_pair_put(fmsg, "cc", wq_head);
272 if (err)
273 return err;
274
275 err = mlx5e_health_cq_diag_fmsg(&rq->cq, fmsg);
276 if (err)
277 return err;
278
279 err = mlx5e_health_eq_diag_fmsg(rq->cq.mcq.eq, fmsg);
280 if (err)
281 return err;
282
283 if (rq->icosq) {
284 struct mlx5e_icosq *icosq = rq->icosq;
285 u8 icosq_hw_state;
286
287 err = mlx5_core_query_sq_state(rq->mdev, icosq->sqn, &icosq_hw_state);
288 if (err)
289 return err;
290
291 err = mlx5e_reporter_icosq_diagnose(icosq, icosq_hw_state, fmsg);
292 if (err)
293 return err;
294 }
295
296 return 0;
297 }
298
mlx5e_rx_reporter_build_diagnose_output(struct mlx5e_rq * rq,struct devlink_fmsg * fmsg)299 static int mlx5e_rx_reporter_build_diagnose_output(struct mlx5e_rq *rq,
300 struct devlink_fmsg *fmsg)
301 {
302 int err;
303
304 err = devlink_fmsg_obj_nest_start(fmsg);
305 if (err)
306 return err;
307
308 err = devlink_fmsg_u32_pair_put(fmsg, "channel ix", rq->ix);
309 if (err)
310 return err;
311
312 err = mlx5e_rx_reporter_build_diagnose_output_rq_common(rq, fmsg);
313 if (err)
314 return err;
315
316 return devlink_fmsg_obj_nest_end(fmsg);
317 }
318
mlx5e_rx_reporter_diagnose_generic_rq(struct mlx5e_rq * rq,struct devlink_fmsg * fmsg)319 static int mlx5e_rx_reporter_diagnose_generic_rq(struct mlx5e_rq *rq,
320 struct devlink_fmsg *fmsg)
321 {
322 struct mlx5e_priv *priv = rq->priv;
323 struct mlx5e_params *params;
324 u32 rq_stride, rq_sz;
325 bool real_time;
326 int err;
327
328 params = &priv->channels.params;
329 rq_sz = mlx5e_rqwq_get_size(rq);
330 real_time = mlx5_is_real_time_rq(priv->mdev);
331 rq_stride = BIT(mlx5e_mpwqe_get_log_stride_size(priv->mdev, params, NULL));
332
333 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "RQ");
334 if (err)
335 return err;
336
337 err = devlink_fmsg_u8_pair_put(fmsg, "type", params->rq_wq_type);
338 if (err)
339 return err;
340
341 err = devlink_fmsg_u64_pair_put(fmsg, "stride size", rq_stride);
342 if (err)
343 return err;
344
345 err = devlink_fmsg_u32_pair_put(fmsg, "size", rq_sz);
346 if (err)
347 return err;
348
349 err = devlink_fmsg_string_pair_put(fmsg, "ts_format", real_time ? "RT" : "FRC");
350 if (err)
351 return err;
352
353 err = mlx5e_health_cq_common_diag_fmsg(&rq->cq, fmsg);
354 if (err)
355 return err;
356
357 return mlx5e_health_fmsg_named_obj_nest_end(fmsg);
358 }
359
360 static int
mlx5e_rx_reporter_diagnose_common_ptp_config(struct mlx5e_priv * priv,struct mlx5e_ptp * ptp_ch,struct devlink_fmsg * fmsg)361 mlx5e_rx_reporter_diagnose_common_ptp_config(struct mlx5e_priv *priv, struct mlx5e_ptp *ptp_ch,
362 struct devlink_fmsg *fmsg)
363 {
364 int err;
365
366 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "PTP");
367 if (err)
368 return err;
369
370 err = devlink_fmsg_u32_pair_put(fmsg, "filter_type", priv->tstamp.rx_filter);
371 if (err)
372 return err;
373
374 err = mlx5e_rx_reporter_diagnose_generic_rq(&ptp_ch->rq, fmsg);
375 if (err)
376 return err;
377
378 return mlx5e_health_fmsg_named_obj_nest_end(fmsg);
379 }
380
381 static int
mlx5e_rx_reporter_diagnose_common_config(struct devlink_health_reporter * reporter,struct devlink_fmsg * fmsg)382 mlx5e_rx_reporter_diagnose_common_config(struct devlink_health_reporter *reporter,
383 struct devlink_fmsg *fmsg)
384 {
385 struct mlx5e_priv *priv = devlink_health_reporter_priv(reporter);
386 struct mlx5e_rq *generic_rq = &priv->channels.c[0]->rq;
387 struct mlx5e_ptp *ptp_ch = priv->channels.ptp;
388 int err;
389
390 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "Common config");
391 if (err)
392 return err;
393
394 err = mlx5e_rx_reporter_diagnose_generic_rq(generic_rq, fmsg);
395 if (err)
396 return err;
397
398 if (ptp_ch && test_bit(MLX5E_PTP_STATE_RX, ptp_ch->state)) {
399 err = mlx5e_rx_reporter_diagnose_common_ptp_config(priv, ptp_ch, fmsg);
400 if (err)
401 return err;
402 }
403
404 return mlx5e_health_fmsg_named_obj_nest_end(fmsg);
405 }
406
mlx5e_rx_reporter_build_diagnose_output_ptp_rq(struct mlx5e_rq * rq,struct devlink_fmsg * fmsg)407 static int mlx5e_rx_reporter_build_diagnose_output_ptp_rq(struct mlx5e_rq *rq,
408 struct devlink_fmsg *fmsg)
409 {
410 int err;
411
412 err = devlink_fmsg_obj_nest_start(fmsg);
413 if (err)
414 return err;
415
416 err = devlink_fmsg_string_pair_put(fmsg, "channel", "ptp");
417 if (err)
418 return err;
419
420 err = mlx5e_rx_reporter_build_diagnose_output_rq_common(rq, fmsg);
421 if (err)
422 return err;
423
424 err = devlink_fmsg_obj_nest_end(fmsg);
425 if (err)
426 return err;
427
428 return 0;
429 }
430
mlx5e_rx_reporter_diagnose(struct devlink_health_reporter * reporter,struct devlink_fmsg * fmsg,struct netlink_ext_ack * extack)431 static int mlx5e_rx_reporter_diagnose(struct devlink_health_reporter *reporter,
432 struct devlink_fmsg *fmsg,
433 struct netlink_ext_ack *extack)
434 {
435 struct mlx5e_priv *priv = devlink_health_reporter_priv(reporter);
436 struct mlx5e_ptp *ptp_ch = priv->channels.ptp;
437 int i, err = 0;
438
439 mutex_lock(&priv->state_lock);
440
441 if (!test_bit(MLX5E_STATE_OPENED, &priv->state))
442 goto unlock;
443
444 err = mlx5e_rx_reporter_diagnose_common_config(reporter, fmsg);
445 if (err)
446 goto unlock;
447
448 err = devlink_fmsg_arr_pair_nest_start(fmsg, "RQs");
449 if (err)
450 goto unlock;
451
452 for (i = 0; i < priv->channels.num; i++) {
453 struct mlx5e_rq *rq = &priv->channels.c[i]->rq;
454
455 err = mlx5e_rx_reporter_build_diagnose_output(rq, fmsg);
456 if (err)
457 goto unlock;
458 }
459 if (ptp_ch && test_bit(MLX5E_PTP_STATE_RX, ptp_ch->state)) {
460 err = mlx5e_rx_reporter_build_diagnose_output_ptp_rq(&ptp_ch->rq, fmsg);
461 if (err)
462 goto unlock;
463 }
464 err = devlink_fmsg_arr_pair_nest_end(fmsg);
465 unlock:
466 mutex_unlock(&priv->state_lock);
467 return err;
468 }
469
mlx5e_rx_reporter_dump_icosq(struct mlx5e_priv * priv,struct devlink_fmsg * fmsg,void * ctx)470 static int mlx5e_rx_reporter_dump_icosq(struct mlx5e_priv *priv, struct devlink_fmsg *fmsg,
471 void *ctx)
472 {
473 struct mlx5e_txqsq *icosq = ctx;
474 struct mlx5_rsc_key key = {};
475 int err;
476
477 if (!test_bit(MLX5E_STATE_OPENED, &priv->state))
478 return 0;
479
480 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "SX Slice");
481 if (err)
482 return err;
483
484 key.size = PAGE_SIZE;
485 key.rsc = MLX5_SGMT_TYPE_SX_SLICE_ALL;
486 err = mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
487 if (err)
488 return err;
489
490 err = mlx5e_health_fmsg_named_obj_nest_end(fmsg);
491 if (err)
492 return err;
493
494 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "ICOSQ");
495 if (err)
496 return err;
497
498 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "QPC");
499 if (err)
500 return err;
501
502 key.rsc = MLX5_SGMT_TYPE_FULL_QPC;
503 key.index1 = icosq->sqn;
504 key.num_of_obj1 = 1;
505
506 err = mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
507 if (err)
508 return err;
509
510 err = mlx5e_health_fmsg_named_obj_nest_end(fmsg);
511 if (err)
512 return err;
513
514 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "send_buff");
515 if (err)
516 return err;
517
518 key.rsc = MLX5_SGMT_TYPE_SND_BUFF;
519 key.num_of_obj2 = MLX5_RSC_DUMP_ALL;
520
521 err = mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
522 if (err)
523 return err;
524
525 err = mlx5e_health_fmsg_named_obj_nest_end(fmsg);
526 if (err)
527 return err;
528
529 return mlx5e_health_fmsg_named_obj_nest_end(fmsg);
530 }
531
mlx5e_rx_reporter_dump_rq(struct mlx5e_priv * priv,struct devlink_fmsg * fmsg,void * ctx)532 static int mlx5e_rx_reporter_dump_rq(struct mlx5e_priv *priv, struct devlink_fmsg *fmsg,
533 void *ctx)
534 {
535 struct mlx5_rsc_key key = {};
536 struct mlx5e_rq *rq = ctx;
537 int err;
538
539 if (!test_bit(MLX5E_STATE_OPENED, &priv->state))
540 return 0;
541
542 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "RX Slice");
543 if (err)
544 return err;
545
546 key.size = PAGE_SIZE;
547 key.rsc = MLX5_SGMT_TYPE_RX_SLICE_ALL;
548 err = mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
549 if (err)
550 return err;
551
552 err = mlx5e_health_fmsg_named_obj_nest_end(fmsg);
553 if (err)
554 return err;
555
556 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "RQ");
557 if (err)
558 return err;
559
560 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "QPC");
561 if (err)
562 return err;
563
564 key.rsc = MLX5_SGMT_TYPE_FULL_QPC;
565 key.index1 = rq->rqn;
566 key.num_of_obj1 = 1;
567
568 err = mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
569 if (err)
570 return err;
571
572 err = mlx5e_health_fmsg_named_obj_nest_end(fmsg);
573 if (err)
574 return err;
575
576 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "receive_buff");
577 if (err)
578 return err;
579
580 key.rsc = MLX5_SGMT_TYPE_RCV_BUFF;
581 key.num_of_obj2 = MLX5_RSC_DUMP_ALL;
582 err = mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
583 if (err)
584 return err;
585
586 err = mlx5e_health_fmsg_named_obj_nest_end(fmsg);
587 if (err)
588 return err;
589
590 return mlx5e_health_fmsg_named_obj_nest_end(fmsg);
591 }
592
mlx5e_rx_reporter_dump_all_rqs(struct mlx5e_priv * priv,struct devlink_fmsg * fmsg)593 static int mlx5e_rx_reporter_dump_all_rqs(struct mlx5e_priv *priv,
594 struct devlink_fmsg *fmsg)
595 {
596 struct mlx5e_ptp *ptp_ch = priv->channels.ptp;
597 struct mlx5_rsc_key key = {};
598 int i, err;
599
600 if (!test_bit(MLX5E_STATE_OPENED, &priv->state))
601 return 0;
602
603 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "RX Slice");
604 if (err)
605 return err;
606
607 key.size = PAGE_SIZE;
608 key.rsc = MLX5_SGMT_TYPE_RX_SLICE_ALL;
609 err = mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
610 if (err)
611 return err;
612
613 err = mlx5e_health_fmsg_named_obj_nest_end(fmsg);
614 if (err)
615 return err;
616
617 err = devlink_fmsg_arr_pair_nest_start(fmsg, "RQs");
618 if (err)
619 return err;
620
621 for (i = 0; i < priv->channels.num; i++) {
622 struct mlx5e_rq *rq = &priv->channels.c[i]->rq;
623
624 err = mlx5e_health_queue_dump(priv, fmsg, rq->rqn, "RQ");
625 if (err)
626 return err;
627 }
628
629 if (ptp_ch && test_bit(MLX5E_PTP_STATE_RX, ptp_ch->state)) {
630 err = mlx5e_health_queue_dump(priv, fmsg, ptp_ch->rq.rqn, "PTP RQ");
631 if (err)
632 return err;
633 }
634
635 return devlink_fmsg_arr_pair_nest_end(fmsg);
636 }
637
mlx5e_rx_reporter_dump_from_ctx(struct mlx5e_priv * priv,struct mlx5e_err_ctx * err_ctx,struct devlink_fmsg * fmsg)638 static int mlx5e_rx_reporter_dump_from_ctx(struct mlx5e_priv *priv,
639 struct mlx5e_err_ctx *err_ctx,
640 struct devlink_fmsg *fmsg)
641 {
642 return err_ctx->dump(priv, fmsg, err_ctx->ctx);
643 }
644
mlx5e_rx_reporter_dump(struct devlink_health_reporter * reporter,struct devlink_fmsg * fmsg,void * context,struct netlink_ext_ack * extack)645 static int mlx5e_rx_reporter_dump(struct devlink_health_reporter *reporter,
646 struct devlink_fmsg *fmsg, void *context,
647 struct netlink_ext_ack *extack)
648 {
649 struct mlx5e_priv *priv = devlink_health_reporter_priv(reporter);
650 struct mlx5e_err_ctx *err_ctx = context;
651
652 return err_ctx ? mlx5e_rx_reporter_dump_from_ctx(priv, err_ctx, fmsg) :
653 mlx5e_rx_reporter_dump_all_rqs(priv, fmsg);
654 }
655
mlx5e_reporter_rx_timeout(struct mlx5e_rq * rq)656 void mlx5e_reporter_rx_timeout(struct mlx5e_rq *rq)
657 {
658 char err_str[MLX5E_REPORTER_PER_Q_MAX_LEN];
659 struct mlx5e_icosq *icosq = rq->icosq;
660 struct mlx5e_priv *priv = rq->priv;
661 struct mlx5e_err_ctx err_ctx = {};
662 char icosq_str[32] = {};
663
664 err_ctx.ctx = rq;
665 err_ctx.recover = mlx5e_rx_reporter_timeout_recover;
666 err_ctx.dump = mlx5e_rx_reporter_dump_rq;
667
668 if (icosq)
669 snprintf(icosq_str, sizeof(icosq_str), "ICOSQ: 0x%x, ", icosq->sqn);
670 snprintf(err_str, sizeof(err_str),
671 "RX timeout on channel: %d, %s RQ: 0x%x, CQ: 0x%x",
672 rq->ix, icosq_str, rq->rqn, rq->cq.mcq.cqn);
673
674 mlx5e_health_report(priv, priv->rx_reporter, err_str, &err_ctx);
675 }
676
mlx5e_reporter_rq_cqe_err(struct mlx5e_rq * rq)677 void mlx5e_reporter_rq_cqe_err(struct mlx5e_rq *rq)
678 {
679 char err_str[MLX5E_REPORTER_PER_Q_MAX_LEN];
680 struct mlx5e_priv *priv = rq->priv;
681 struct mlx5e_err_ctx err_ctx = {};
682
683 err_ctx.ctx = rq;
684 err_ctx.recover = mlx5e_rx_reporter_err_rq_cqe_recover;
685 err_ctx.dump = mlx5e_rx_reporter_dump_rq;
686 snprintf(err_str, sizeof(err_str), "ERR CQE on RQ: 0x%x", rq->rqn);
687
688 mlx5e_health_report(priv, priv->rx_reporter, err_str, &err_ctx);
689 }
690
mlx5e_reporter_icosq_cqe_err(struct mlx5e_icosq * icosq)691 void mlx5e_reporter_icosq_cqe_err(struct mlx5e_icosq *icosq)
692 {
693 struct mlx5e_priv *priv = icosq->channel->priv;
694 char err_str[MLX5E_REPORTER_PER_Q_MAX_LEN];
695 struct mlx5e_err_ctx err_ctx = {};
696
697 err_ctx.ctx = icosq;
698 err_ctx.recover = mlx5e_rx_reporter_err_icosq_cqe_recover;
699 err_ctx.dump = mlx5e_rx_reporter_dump_icosq;
700 snprintf(err_str, sizeof(err_str), "ERR CQE on ICOSQ: 0x%x", icosq->sqn);
701
702 mlx5e_health_report(priv, priv->rx_reporter, err_str, &err_ctx);
703 }
704
mlx5e_reporter_icosq_suspend_recovery(struct mlx5e_channel * c)705 void mlx5e_reporter_icosq_suspend_recovery(struct mlx5e_channel *c)
706 {
707 mutex_lock(&c->icosq_recovery_lock);
708 }
709
mlx5e_reporter_icosq_resume_recovery(struct mlx5e_channel * c)710 void mlx5e_reporter_icosq_resume_recovery(struct mlx5e_channel *c)
711 {
712 mutex_unlock(&c->icosq_recovery_lock);
713 }
714
715 static const struct devlink_health_reporter_ops mlx5_rx_reporter_ops = {
716 .name = "rx",
717 .recover = mlx5e_rx_reporter_recover,
718 .diagnose = mlx5e_rx_reporter_diagnose,
719 .dump = mlx5e_rx_reporter_dump,
720 };
721
722 #define MLX5E_REPORTER_RX_GRACEFUL_PERIOD 500
723
mlx5e_reporter_rx_create(struct mlx5e_priv * priv)724 void mlx5e_reporter_rx_create(struct mlx5e_priv *priv)
725 {
726 struct devlink_port *dl_port = mlx5e_devlink_get_dl_port(priv);
727 struct devlink_health_reporter *reporter;
728
729 reporter = devlink_port_health_reporter_create(dl_port, &mlx5_rx_reporter_ops,
730 MLX5E_REPORTER_RX_GRACEFUL_PERIOD, priv);
731 if (IS_ERR(reporter)) {
732 netdev_warn(priv->netdev, "Failed to create rx reporter, err = %ld\n",
733 PTR_ERR(reporter));
734 return;
735 }
736 priv->rx_reporter = reporter;
737 }
738
mlx5e_reporter_rx_destroy(struct mlx5e_priv * priv)739 void mlx5e_reporter_rx_destroy(struct mlx5e_priv *priv)
740 {
741 if (!priv->rx_reporter)
742 return;
743
744 devlink_port_health_reporter_destroy(priv->rx_reporter);
745 priv->rx_reporter = NULL;
746 }
747