drivers/net/ethernet/mellanox/mlx5/core/en/reporter_tx.c

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /* Copyright (c) 2019 Mellanox Technologies. */
   3
   4 #include "health.h"
   5 #include "en/ptp.h"
   6 #include "en/devlink.h"
   7 #include "lib/tout.h"
   8
   9 /* Keep this string array consistent with the MLX5E_SQ_STATE_* enums in en.h */
  10 static const char * const sq_sw_state_type_name[] = {
  11         [MLX5E_SQ_STATE_ENABLED] = "enabled",
  12         [MLX5E_SQ_STATE_MPWQE] = "mpwqe",
  13         [MLX5E_SQ_STATE_RECOVERING] = "recovering",
  14         [MLX5E_SQ_STATE_IPSEC] = "ipsec",
  15         [MLX5E_SQ_STATE_DIM] = "dim",
  16         [MLX5E_SQ_STATE_VLAN_NEED_L2_INLINE] = "vlan_need_l2_inline",
  17         [MLX5E_SQ_STATE_PENDING_XSK_TX] = "pending_xsk_tx",
  18         [MLX5E_SQ_STATE_PENDING_TLS_RX_RESYNC] = "pending_tls_rx_resync",
  19         [MLX5E_SQ_STATE_XDP_MULTIBUF] = "xdp_multibuf",
  20 };
  21
  22 static int mlx5e_wait_for_sq_flush(struct mlx5e_txqsq *sq)
  23 {
  24         struct mlx5_core_dev *dev = sq->mdev;
  25         unsigned long exp_time;
  26
  27         exp_time = jiffies + msecs_to_jiffies(mlx5_tout_ms(dev, FLUSH_ON_ERROR));
  28
  29         while (time_before(jiffies, exp_time)) {
  30                 if (sq->cc == sq->pc)
  31                         return 0;
  32
  33                 msleep(20);
  34         }
  35
  36         netdev_err(sq->netdev,
  37                    "Wait for SQ 0x%x flush timeout (sq cc = 0x%x, sq pc = 0x%x)\n",
  38                    sq->sqn, sq->cc, sq->pc);
  39
  40         return -ETIMEDOUT;
  41 }
  42
  43 static void mlx5e_reset_txqsq_cc_pc(struct mlx5e_txqsq *sq)
  44 {
  45         WARN_ONCE(sq->cc != sq->pc,
  46                   "SQ 0x%x: cc (0x%x) != pc (0x%x)\n",
  47                   sq->sqn, sq->cc, sq->pc);
  48         sq->cc = 0;
  49         sq->dma_fifo_cc = 0;
  50         sq->pc = 0;
  51 }
  52
  53 static void mlx5e_health_sq_put_sw_state(struct devlink_fmsg *fmsg, struct mlx5e_txqsq *sq)
  54 {
  55         int i;
  56
  57         BUILD_BUG_ON_MSG(ARRAY_SIZE(sq_sw_state_type_name) != MLX5E_NUM_SQ_STATES,
  58                          "sq_sw_state_type_name string array must be consistent with MLX5E_SQ_STATE_* enum in en.h");
  59         mlx5e_health_fmsg_named_obj_nest_start(fmsg, "SW State");
  60
  61         for (i = 0; i < ARRAY_SIZE(sq_sw_state_type_name); ++i)
  62                 devlink_fmsg_u32_pair_put(fmsg, sq_sw_state_type_name[i],
  63                                           test_bit(i, &sq->state));
  64
  65         mlx5e_health_fmsg_named_obj_nest_end(fmsg);
  66 }
  67
  68 static int mlx5e_tx_reporter_err_cqe_recover(void *ctx)
  69 {
  70         struct mlx5_core_dev *mdev;
  71         struct net_device *dev;
  72         struct mlx5e_txqsq *sq;
  73         u8 state;
  74         int err;
  75
  76         sq = ctx;
  77         mdev = sq->mdev;
  78         dev = sq->netdev;
  79
  80         if (!test_bit(MLX5E_SQ_STATE_RECOVERING, &sq->state))
  81                 return 0;
  82
  83         err = mlx5_core_query_sq_state(mdev, sq->sqn, &state);
  84         if (err) {
  85                 netdev_err(dev, "Failed to query SQ 0x%x state. err = %d\n",
  86                            sq->sqn, err);
  87                 goto out;
  88         }
  89
  90         if (state != MLX5_SQC_STATE_ERR)
  91                 goto out;
  92
  93         mlx5e_tx_disable_queue(sq->txq);
  94
  95         err = mlx5e_wait_for_sq_flush(sq);
  96         if (err)
  97                 goto out;
  98
  99         /* At this point, no new packets will arrive from the stack as TXQ is
 100          * marked with QUEUE_STATE_DRV_XOFF. In addition, NAPI cleared all
 101          * pending WQEs. SQ can safely reset the SQ.
 102          */
 103
 104         err = mlx5e_health_sq_to_ready(mdev, dev, sq->sqn);
 105         if (err)
 106                 goto out;
 107
 108         mlx5e_reset_txqsq_cc_pc(sq);
 109         sq->stats->recover++;
 110         clear_bit(MLX5E_SQ_STATE_RECOVERING, &sq->state);
 111         mlx5e_activate_txqsq(sq);
 112         if (sq->channel)
 113                 mlx5e_trigger_napi_icosq(sq->channel);
 114         else
 115                 mlx5e_trigger_napi_sched(sq->cq.napi);
 116
 117         return 0;
 118 out:
 119         clear_bit(MLX5E_SQ_STATE_RECOVERING, &sq->state);
 120         return err;
 121 }
 122
 123 struct mlx5e_tx_timeout_ctx {
 124         struct mlx5e_txqsq *sq;
 125         signed int status;
 126 };
 127
 128 static int mlx5e_tx_reporter_timeout_recover(void *ctx)
 129 {
 130         struct mlx5e_tx_timeout_ctx *to_ctx;
 131         struct mlx5e_priv *priv;
 132         struct mlx5_eq_comp *eq;
 133         struct mlx5e_txqsq *sq;
 134         int err;
 135
 136         to_ctx = ctx;
 137         sq = to_ctx->sq;
 138         eq = sq->cq.mcq.eq;
 139         priv = sq->priv;
 140         err = mlx5e_health_channel_eq_recover(sq->netdev, eq, sq->cq.ch_stats);
 141         if (!err) {
 142                 to_ctx->status = 0; /* this sq recovered */
 143                 return err;
 144         }
 145
 146         err = mlx5e_safe_reopen_channels(priv);
 147         if (!err) {
 148                 to_ctx->status = 1; /* all channels recovered */
 149                 return err;
 150         }
 151
 152         to_ctx->status = err;
 153         clear_bit(MLX5E_SQ_STATE_ENABLED, &sq->state);
 154         netdev_err(priv->netdev,
 155                    "mlx5e_safe_reopen_channels failed recovering from a tx_timeout, err(%d).\n",
 156                    err);
 157
 158         return err;
 159 }
 160
 161 static int mlx5e_tx_reporter_ptpsq_unhealthy_recover(void *ctx)
 162 {
 163         struct mlx5e_ptpsq *ptpsq = ctx;
 164         struct mlx5e_channels *chs;
 165         struct net_device *netdev;
 166         struct mlx5e_priv *priv;
 167         int carrier_ok;
 168         int err;
 169
 170         if (!test_bit(MLX5E_SQ_STATE_RECOVERING, &ptpsq->txqsq.state))
 171                 return 0;
 172
 173         priv = ptpsq->txqsq.priv;
 174
 175         mutex_lock(&priv->state_lock);
 176         chs = &priv->channels;
 177         netdev = priv->netdev;
 178
 179         carrier_ok = netif_carrier_ok(netdev);
 180         netif_carrier_off(netdev);
 181
 182         mlx5e_deactivate_priv_channels(priv);
 183
 184         mlx5e_ptp_close(chs->ptp);
 185         err = mlx5e_ptp_open(priv, &chs->params, chs->c[0]->lag_port, &chs->ptp);
 186
 187         mlx5e_activate_priv_channels(priv);
 188
 189         /* return carrier back if needed */
 190         if (carrier_ok)
 191                 netif_carrier_on(netdev);
 192
 193         mutex_unlock(&priv->state_lock);
 194
 195         return err;
 196 }
 197
 198 /* state lock cannot be grabbed within this function.
 199  * It can cause a dead lock or a read-after-free.
 200  */
 201 static int mlx5e_tx_reporter_recover_from_ctx(struct mlx5e_err_ctx *err_ctx)
 202 {
 203         return err_ctx->recover(err_ctx->ctx);
 204 }
 205
 206 static int mlx5e_tx_reporter_recover(struct devlink_health_reporter *reporter,
 207                                      void *context,
 208                                      struct netlink_ext_ack *extack)
 209 {
 210         struct mlx5e_priv *priv = devlink_health_reporter_priv(reporter);
 211         struct mlx5e_err_ctx *err_ctx = context;
 212
 213         return err_ctx ? mlx5e_tx_reporter_recover_from_ctx(err_ctx) :
 214                          mlx5e_health_recover_channels(priv);
 215 }
 216
 217 static void
 218 mlx5e_tx_reporter_build_diagnose_output_sq_common(struct devlink_fmsg *fmsg,
 219                                                   struct mlx5e_txqsq *sq, int tc)
 220 {
 221         bool stopped = netif_xmit_stopped(sq->txq);
 222         u8 state;
 223         int err;
 224
 225         devlink_fmsg_u32_pair_put(fmsg, "tc", tc);
 226         devlink_fmsg_u32_pair_put(fmsg, "txq ix", sq->txq_ix);
 227         devlink_fmsg_u32_pair_put(fmsg, "sqn", sq->sqn);
 228
 229         err = mlx5_core_query_sq_state(sq->mdev, sq->sqn, &state);
 230         if (!err)
 231                 devlink_fmsg_u8_pair_put(fmsg, "HW state", state);
 232
 233         devlink_fmsg_bool_pair_put(fmsg, "stopped", stopped);
 234         devlink_fmsg_u32_pair_put(fmsg, "cc", sq->cc);
 235         devlink_fmsg_u32_pair_put(fmsg, "pc", sq->pc);
 236         mlx5e_health_sq_put_sw_state(fmsg, sq);
 237         mlx5e_health_cq_diag_fmsg(&sq->cq, fmsg);
 238         mlx5e_health_eq_diag_fmsg(sq->cq.mcq.eq, fmsg);
 239 }
 240
 241 static void
 242 mlx5e_tx_reporter_build_diagnose_output(struct devlink_fmsg *fmsg,
 243                                         struct mlx5e_txqsq *sq, int tc)
 244 {
 245         devlink_fmsg_obj_nest_start(fmsg);
 246         devlink_fmsg_u32_pair_put(fmsg, "channel ix", sq->ch_ix);
 247         mlx5e_tx_reporter_build_diagnose_output_sq_common(fmsg, sq, tc);
 248         devlink_fmsg_obj_nest_end(fmsg);
 249 }
 250
 251 static void
 252 mlx5e_tx_reporter_build_diagnose_output_ptpsq(struct devlink_fmsg *fmsg,
 253                                               struct mlx5e_ptpsq *ptpsq, int tc)
 254 {
 255         devlink_fmsg_obj_nest_start(fmsg);
 256         devlink_fmsg_string_pair_put(fmsg, "channel", "ptp");
 257         mlx5e_tx_reporter_build_diagnose_output_sq_common(fmsg, &ptpsq->txqsq, tc);
 258         mlx5e_health_fmsg_named_obj_nest_start(fmsg, "Port TS");
 259         mlx5e_health_cq_diag_fmsg(&ptpsq->ts_cq, fmsg);
 260         mlx5e_health_fmsg_named_obj_nest_end(fmsg);
 261         devlink_fmsg_obj_nest_end(fmsg);
 262 }
 263
 264 static void
 265 mlx5e_tx_reporter_diagnose_generic_txqsq(struct devlink_fmsg *fmsg,
 266                                          struct mlx5e_txqsq *txqsq)
 267 {
 268         bool real_time =  mlx5_is_real_time_sq(txqsq->mdev);
 269         u32 sq_sz = mlx5_wq_cyc_get_size(&txqsq->wq);
 270         u32 sq_stride = MLX5_SEND_WQE_BB;
 271
 272         mlx5e_health_fmsg_named_obj_nest_start(fmsg, "SQ");
 273         devlink_fmsg_u64_pair_put(fmsg, "stride size", sq_stride);
 274         devlink_fmsg_u32_pair_put(fmsg, "size", sq_sz);
 275         devlink_fmsg_string_pair_put(fmsg, "ts_format", real_time ? "RT" : "FRC");
 276         mlx5e_health_cq_common_diag_fmsg(&txqsq->cq, fmsg);
 277         mlx5e_health_fmsg_named_obj_nest_end(fmsg);
 278 }
 279
 280 static void
 281 mlx5e_tx_reporter_diagnose_generic_tx_port_ts(struct devlink_fmsg *fmsg,
 282                                               struct mlx5e_ptpsq *ptpsq)
 283 {
 284         mlx5e_health_fmsg_named_obj_nest_start(fmsg, "Port TS");
 285         mlx5e_health_cq_common_diag_fmsg(&ptpsq->ts_cq, fmsg);
 286         mlx5e_health_fmsg_named_obj_nest_end(fmsg);
 287 }
 288
 289 static void
 290 mlx5e_tx_reporter_diagnose_common_config(struct devlink_health_reporter *reporter,
 291                                          struct devlink_fmsg *fmsg)
 292 {
 293         struct mlx5e_priv *priv = devlink_health_reporter_priv(reporter);
 294         struct mlx5e_txqsq *generic_sq = priv->txq2sq[0];
 295         struct mlx5e_ptp *ptp_ch = priv->channels.ptp;
 296         struct mlx5e_ptpsq *generic_ptpsq;
 297
 298         mlx5e_health_fmsg_named_obj_nest_start(fmsg, "Common Config");
 299         mlx5e_tx_reporter_diagnose_generic_txqsq(fmsg, generic_sq);
 300
 301         if (!ptp_ch || !test_bit(MLX5E_PTP_STATE_TX, ptp_ch->state))
 302                 goto out;
 303
 304         generic_ptpsq = &ptp_ch->ptpsq[0];
 305         mlx5e_health_fmsg_named_obj_nest_start(fmsg, "PTP");
 306         mlx5e_tx_reporter_diagnose_generic_txqsq(fmsg, &generic_ptpsq->txqsq);
 307         mlx5e_tx_reporter_diagnose_generic_tx_port_ts(fmsg, generic_ptpsq);
 308         mlx5e_health_fmsg_named_obj_nest_end(fmsg);
 309 out:
 310         mlx5e_health_fmsg_named_obj_nest_end(fmsg);
 311 }
 312
 313 static int mlx5e_tx_reporter_diagnose(struct devlink_health_reporter *reporter,
 314                                       struct devlink_fmsg *fmsg,
 315                                       struct netlink_ext_ack *extack)
 316 {
 317         struct mlx5e_priv *priv = devlink_health_reporter_priv(reporter);
 318         struct mlx5e_ptp *ptp_ch = priv->channels.ptp;
 319
 320         int i, tc;
 321
 322         mutex_lock(&priv->state_lock);
 323
 324         if (!test_bit(MLX5E_STATE_OPENED, &priv->state))
 325                 goto unlock;
 326
 327         mlx5e_tx_reporter_diagnose_common_config(reporter, fmsg);
 328         devlink_fmsg_arr_pair_nest_start(fmsg, "SQs");
 329
 330         for (i = 0; i < priv->channels.num; i++) {
 331                 struct mlx5e_channel *c = priv->channels.c[i];
 332
 333                 for (tc = 0; tc < mlx5e_get_dcb_num_tc(&priv->channels.params); tc++) {
 334                         struct mlx5e_txqsq *sq = &c->sq[tc];
 335
 336                         mlx5e_tx_reporter_build_diagnose_output(fmsg, sq, tc);
 337                 }
 338         }
 339
 340         if (!ptp_ch || !test_bit(MLX5E_PTP_STATE_TX, ptp_ch->state))
 341                 goto close_sqs_nest;
 342
 343         for (tc = 0; tc < mlx5e_get_dcb_num_tc(&priv->channels.params); tc++)
 344                 mlx5e_tx_reporter_build_diagnose_output_ptpsq(fmsg,
 345                                                               &ptp_ch->ptpsq[tc],
 346                                                               tc);
 347
 348 close_sqs_nest:
 349         devlink_fmsg_arr_pair_nest_end(fmsg);
 350 unlock:
 351         mutex_unlock(&priv->state_lock);
 352         return 0;
 353 }
 354
 355 static int mlx5e_tx_reporter_dump_sq(struct mlx5e_priv *priv, struct devlink_fmsg *fmsg,
 356                                      void *ctx)
 357 {
 358         struct mlx5_rsc_key key = {};
 359         struct mlx5e_txqsq *sq = ctx;
 360
 361         if (!test_bit(MLX5E_STATE_OPENED, &priv->state))
 362                 return 0;
 363
 364         mlx5e_health_fmsg_named_obj_nest_start(fmsg, "SX Slice");
 365         key.size = PAGE_SIZE;
 366         key.rsc = MLX5_SGMT_TYPE_SX_SLICE_ALL;
 367         mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
 368         mlx5e_health_fmsg_named_obj_nest_end(fmsg);
 369
 370         mlx5e_health_fmsg_named_obj_nest_start(fmsg, "SQ");
 371         mlx5e_health_fmsg_named_obj_nest_start(fmsg, "QPC");
 372         key.rsc = MLX5_SGMT_TYPE_FULL_QPC;
 373         key.index1 = sq->sqn;
 374         key.num_of_obj1 = 1;
 375         mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
 376         mlx5e_health_fmsg_named_obj_nest_end(fmsg);
 377
 378         mlx5e_health_fmsg_named_obj_nest_start(fmsg, "send_buff");
 379         key.rsc = MLX5_SGMT_TYPE_SND_BUFF;
 380         key.num_of_obj2 = MLX5_RSC_DUMP_ALL;
 381         mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
 382         mlx5e_health_fmsg_named_obj_nest_end(fmsg);
 383
 384         mlx5e_health_fmsg_named_obj_nest_end(fmsg);
 385
 386         return 0;
 387 }
 388
 389 static int mlx5e_tx_reporter_timeout_dump(struct mlx5e_priv *priv, struct devlink_fmsg *fmsg,
 390                                           void *ctx)
 391 {
 392         struct mlx5e_tx_timeout_ctx *to_ctx = ctx;
 393
 394         return mlx5e_tx_reporter_dump_sq(priv, fmsg, to_ctx->sq);
 395 }
 396
 397 static int mlx5e_tx_reporter_ptpsq_unhealthy_dump(struct mlx5e_priv *priv,
 398                                                   struct devlink_fmsg *fmsg,
 399                                                   void *ctx)
 400 {
 401         struct mlx5e_ptpsq *ptpsq = ctx;
 402
 403         return mlx5e_tx_reporter_dump_sq(priv, fmsg, &ptpsq->txqsq);
 404 }
 405
 406 static int mlx5e_tx_reporter_dump_all_sqs(struct mlx5e_priv *priv,
 407                                           struct devlink_fmsg *fmsg)
 408 {
 409         struct mlx5e_ptp *ptp_ch = priv->channels.ptp;
 410         struct mlx5_rsc_key key = {};
 411         int i, tc;
 412
 413         if (!test_bit(MLX5E_STATE_OPENED, &priv->state))
 414                 return 0;
 415
 416         mlx5e_health_fmsg_named_obj_nest_start(fmsg, "SX Slice");
 417         key.size = PAGE_SIZE;
 418         key.rsc = MLX5_SGMT_TYPE_SX_SLICE_ALL;
 419         mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg);
 420         mlx5e_health_fmsg_named_obj_nest_end(fmsg);
 421         devlink_fmsg_arr_pair_nest_start(fmsg, "SQs");
 422
 423         for (i = 0; i < priv->channels.num; i++) {
 424                 struct mlx5e_channel *c = priv->channels.c[i];
 425
 426                 for (tc = 0; tc < mlx5e_get_dcb_num_tc(&priv->channels.params); tc++) {
 427                         struct mlx5e_txqsq *sq = &c->sq[tc];
 428
 429                         mlx5e_health_queue_dump(priv, fmsg, sq->sqn, "SQ");
 430                 }
 431         }
 432
 433         if (ptp_ch && test_bit(MLX5E_PTP_STATE_TX, ptp_ch->state)) {
 434                 for (tc = 0; tc < mlx5e_get_dcb_num_tc(&priv->channels.params); tc++) {
 435                         struct mlx5e_txqsq *sq = &ptp_ch->ptpsq[tc].txqsq;
 436
 437                         mlx5e_health_queue_dump(priv, fmsg, sq->sqn, "PTP SQ");
 438                 }
 439         }
 440
 441         devlink_fmsg_arr_pair_nest_end(fmsg);
 442         return 0;
 443 }
 444
 445 static int mlx5e_tx_reporter_dump_from_ctx(struct mlx5e_priv *priv,
 446                                            struct mlx5e_err_ctx *err_ctx,
 447                                            struct devlink_fmsg *fmsg)
 448 {
 449         return err_ctx->dump(priv, fmsg, err_ctx->ctx);
 450 }
 451
 452 static int mlx5e_tx_reporter_dump(struct devlink_health_reporter *reporter,
 453                                   struct devlink_fmsg *fmsg, void *context,
 454                                   struct netlink_ext_ack *extack)
 455 {
 456         struct mlx5e_priv *priv = devlink_health_reporter_priv(reporter);
 457         struct mlx5e_err_ctx *err_ctx = context;
 458
 459         return err_ctx ? mlx5e_tx_reporter_dump_from_ctx(priv, err_ctx, fmsg) :
 460                          mlx5e_tx_reporter_dump_all_sqs(priv, fmsg);
 461 }
 462
 463 void mlx5e_reporter_tx_err_cqe(struct mlx5e_txqsq *sq)
 464 {
 465         char err_str[MLX5E_REPORTER_PER_Q_MAX_LEN];
 466         struct mlx5e_priv *priv = sq->priv;
 467         struct mlx5e_err_ctx err_ctx = {};
 468
 469         err_ctx.ctx = sq;
 470         err_ctx.recover = mlx5e_tx_reporter_err_cqe_recover;
 471         err_ctx.dump = mlx5e_tx_reporter_dump_sq;
 472         snprintf(err_str, sizeof(err_str), "ERR CQE on SQ: 0x%x", sq->sqn);
 473
 474         mlx5e_health_report(priv, priv->tx_reporter, err_str, &err_ctx);
 475 }
 476
 477 int mlx5e_reporter_tx_timeout(struct mlx5e_txqsq *sq)
 478 {
 479         char err_str[MLX5E_REPORTER_PER_Q_MAX_LEN];
 480         struct mlx5e_tx_timeout_ctx to_ctx = {};
 481         struct mlx5e_priv *priv = sq->priv;
 482         struct mlx5e_err_ctx err_ctx = {};
 483
 484         to_ctx.sq = sq;
 485         err_ctx.ctx = &to_ctx;
 486         err_ctx.recover = mlx5e_tx_reporter_timeout_recover;
 487         err_ctx.dump = mlx5e_tx_reporter_timeout_dump;
 488         snprintf(err_str, sizeof(err_str),
 489                  "TX timeout on queue: %d, SQ: 0x%x, CQ: 0x%x, SQ Cons: 0x%x SQ Prod: 0x%x, usecs since last trans: %u",
 490                  sq->ch_ix, sq->sqn, sq->cq.mcq.cqn, sq->cc, sq->pc,
 491                  jiffies_to_usecs(jiffies - READ_ONCE(sq->txq->trans_start)));
 492
 493         mlx5e_health_report(priv, priv->tx_reporter, err_str, &err_ctx);
 494         return to_ctx.status;
 495 }
 496
 497 void mlx5e_reporter_tx_ptpsq_unhealthy(struct mlx5e_ptpsq *ptpsq)
 498 {
 499         struct mlx5e_ptp_metadata_map *map = &ptpsq->metadata_map;
 500         char err_str[MLX5E_REPORTER_PER_Q_MAX_LEN];
 501         struct mlx5e_txqsq *txqsq = &ptpsq->txqsq;
 502         struct mlx5e_cq *ts_cq = &ptpsq->ts_cq;
 503         struct mlx5e_priv *priv = txqsq->priv;
 504         struct mlx5e_err_ctx err_ctx = {};
 505
 506         err_ctx.ctx = ptpsq;
 507         err_ctx.recover = mlx5e_tx_reporter_ptpsq_unhealthy_recover;
 508         err_ctx.dump = mlx5e_tx_reporter_ptpsq_unhealthy_dump;
 509         snprintf(err_str, sizeof(err_str),
 510                  "Unhealthy TX port TS queue: %d, SQ: 0x%x, CQ: 0x%x, Undelivered CQEs: %u Map Capacity: %u",
 511                  txqsq->ch_ix, txqsq->sqn, ts_cq->mcq.cqn, map->undelivered_counter, map->capacity);
 512
 513         mlx5e_health_report(priv, priv->tx_reporter, err_str, &err_ctx);
 514 }
 515
 516 static const struct devlink_health_reporter_ops mlx5_tx_reporter_ops = {
 517                 .name = "tx",
 518                 .recover = mlx5e_tx_reporter_recover,
 519                 .diagnose = mlx5e_tx_reporter_diagnose,
 520                 .dump = mlx5e_tx_reporter_dump,
 521 };
 522
 523 #define MLX5_REPORTER_TX_GRACEFUL_PERIOD 500
 524
 525 void mlx5e_reporter_tx_create(struct mlx5e_priv *priv)
 526 {
 527         struct devlink_health_reporter *reporter;
 528
 529         reporter = devlink_port_health_reporter_create(priv->netdev->devlink_port,
 530                                                        &mlx5_tx_reporter_ops,
 531                                                        MLX5_REPORTER_TX_GRACEFUL_PERIOD, priv);
 532         if (IS_ERR(reporter)) {
 533                 netdev_warn(priv->netdev,
 534                             "Failed to create tx reporter, err = %ld\n",
 535                             PTR_ERR(reporter));
 536                 return;
 537         }
 538         priv->tx_reporter = reporter;
 539 }
 540
 541 void mlx5e_reporter_tx_destroy(struct mlx5e_priv *priv)
 542 {
 543         if (!priv->tx_reporter)
 544                 return;
 545
 546         devlink_health_reporter_destroy(priv->tx_reporter);
 547         priv->tx_reporter = NULL;
 548 }