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

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