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