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 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 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 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 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_in_progress_descs(rq); 125 if (xskrq) 126 mlx5e_free_rx_in_progress_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 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 170 static int mlx5e_rx_reporter_timeout_recover(void *ctx) 171 { 172 struct mlx5_eq_comp *eq; 173 struct mlx5e_rq *rq; 174 int err; 175 176 rq = ctx; 177 eq = rq->cq.mcq.eq; 178 179 err = mlx5e_health_channel_eq_recover(rq->netdev, eq, rq->cq.ch_stats); 180 if (err && rq->icosq) 181 clear_bit(MLX5E_SQ_STATE_ENABLED, &rq->icosq->state); 182 183 return err; 184 } 185 186 static int mlx5e_rx_reporter_recover_from_ctx(struct mlx5e_err_ctx *err_ctx) 187 { 188 return err_ctx->recover(err_ctx->ctx); 189 } 190 191 static int mlx5e_rx_reporter_recover(struct devlink_health_reporter *reporter, 192 void *context, 193 struct netlink_ext_ack *extack) 194 { 195 struct mlx5e_priv *priv = devlink_health_reporter_priv(reporter); 196 struct mlx5e_err_ctx *err_ctx = context; 197 198 return err_ctx ? mlx5e_rx_reporter_recover_from_ctx(err_ctx) : 199 mlx5e_health_recover_channels(priv); 200 } 201 202 static int mlx5e_reporter_icosq_diagnose(struct mlx5e_icosq *icosq, u8 hw_state, 203 struct devlink_fmsg *fmsg) 204 { 205 int err; 206 207 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "ICOSQ"); 208 if (err) 209 return err; 210 211 err = devlink_fmsg_u32_pair_put(fmsg, "sqn", icosq->sqn); 212 if (err) 213 return err; 214 215 err = devlink_fmsg_u8_pair_put(fmsg, "HW state", hw_state); 216 if (err) 217 return err; 218 219 err = devlink_fmsg_u32_pair_put(fmsg, "cc", icosq->cc); 220 if (err) 221 return err; 222 223 err = devlink_fmsg_u32_pair_put(fmsg, "pc", icosq->pc); 224 if (err) 225 return err; 226 227 err = devlink_fmsg_u32_pair_put(fmsg, "WQE size", 228 mlx5_wq_cyc_get_size(&icosq->wq)); 229 if (err) 230 return err; 231 232 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "CQ"); 233 if (err) 234 return err; 235 236 err = devlink_fmsg_u32_pair_put(fmsg, "cqn", icosq->cq.mcq.cqn); 237 if (err) 238 return err; 239 240 err = devlink_fmsg_u32_pair_put(fmsg, "cc", icosq->cq.wq.cc); 241 if (err) 242 return err; 243 244 err = devlink_fmsg_u32_pair_put(fmsg, "size", mlx5_cqwq_get_size(&icosq->cq.wq)); 245 if (err) 246 return err; 247 248 err = mlx5e_health_fmsg_named_obj_nest_end(fmsg); 249 if (err) 250 return err; 251 252 return mlx5e_health_fmsg_named_obj_nest_end(fmsg); 253 } 254 255 static int mlx5e_health_rq_put_sw_state(struct devlink_fmsg *fmsg, struct mlx5e_rq *rq) 256 { 257 int err; 258 int i; 259 260 BUILD_BUG_ON_MSG(ARRAY_SIZE(rq_sw_state_type_name) != MLX5E_NUM_RQ_STATES, 261 "rq_sw_state_type_name string array must be consistent with MLX5E_RQ_STATE_* enum in en.h"); 262 err = devlink_fmsg_obj_nest_start(fmsg); 263 if (err) 264 return err; 265 266 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "SW State"); 267 if (err) 268 return err; 269 270 for (i = 0; i < ARRAY_SIZE(rq_sw_state_type_name); ++i) { 271 err = devlink_fmsg_u32_pair_put(fmsg, rq_sw_state_type_name[i], 272 test_bit(i, &rq->state)); 273 if (err) 274 return err; 275 } 276 277 err = mlx5e_health_fmsg_named_obj_nest_end(fmsg); 278 if (err) 279 return err; 280 281 return devlink_fmsg_obj_nest_end(fmsg); 282 } 283 284 static int 285 mlx5e_rx_reporter_build_diagnose_output_rq_common(struct mlx5e_rq *rq, 286 struct devlink_fmsg *fmsg) 287 { 288 u16 wqe_counter; 289 int wqes_sz; 290 u8 hw_state; 291 u16 wq_head; 292 int err; 293 294 err = mlx5e_query_rq_state(rq->mdev, rq->rqn, &hw_state); 295 if (err) 296 return err; 297 298 wqes_sz = mlx5e_rqwq_get_cur_sz(rq); 299 wq_head = mlx5e_rqwq_get_head(rq); 300 wqe_counter = mlx5e_rqwq_get_wqe_counter(rq); 301 302 err = devlink_fmsg_u32_pair_put(fmsg, "rqn", rq->rqn); 303 if (err) 304 return err; 305 306 err = devlink_fmsg_u8_pair_put(fmsg, "HW state", hw_state); 307 if (err) 308 return err; 309 310 err = devlink_fmsg_u32_pair_put(fmsg, "WQE counter", wqe_counter); 311 if (err) 312 return err; 313 314 err = devlink_fmsg_u32_pair_put(fmsg, "posted WQEs", wqes_sz); 315 if (err) 316 return err; 317 318 err = devlink_fmsg_u32_pair_put(fmsg, "cc", wq_head); 319 if (err) 320 return err; 321 322 err = mlx5e_health_rq_put_sw_state(fmsg, rq); 323 if (err) 324 return err; 325 326 err = mlx5e_health_cq_diag_fmsg(&rq->cq, fmsg); 327 if (err) 328 return err; 329 330 err = mlx5e_health_eq_diag_fmsg(rq->cq.mcq.eq, fmsg); 331 if (err) 332 return err; 333 334 if (rq->icosq) { 335 struct mlx5e_icosq *icosq = rq->icosq; 336 u8 icosq_hw_state; 337 338 err = mlx5_core_query_sq_state(rq->mdev, icosq->sqn, &icosq_hw_state); 339 if (err) 340 return err; 341 342 err = mlx5e_reporter_icosq_diagnose(icosq, icosq_hw_state, fmsg); 343 if (err) 344 return err; 345 } 346 347 return 0; 348 } 349 350 static int mlx5e_rx_reporter_build_diagnose_output(struct mlx5e_rq *rq, 351 struct devlink_fmsg *fmsg) 352 { 353 int err; 354 355 err = devlink_fmsg_obj_nest_start(fmsg); 356 if (err) 357 return err; 358 359 err = devlink_fmsg_u32_pair_put(fmsg, "channel ix", rq->ix); 360 if (err) 361 return err; 362 363 err = mlx5e_rx_reporter_build_diagnose_output_rq_common(rq, fmsg); 364 if (err) 365 return err; 366 367 return devlink_fmsg_obj_nest_end(fmsg); 368 } 369 370 static int mlx5e_rx_reporter_diagnose_generic_rq(struct mlx5e_rq *rq, 371 struct devlink_fmsg *fmsg) 372 { 373 struct mlx5e_priv *priv = rq->priv; 374 struct mlx5e_params *params; 375 u32 rq_stride, rq_sz; 376 bool real_time; 377 int err; 378 379 params = &priv->channels.params; 380 rq_sz = mlx5e_rqwq_get_size(rq); 381 real_time = mlx5_is_real_time_rq(priv->mdev); 382 rq_stride = BIT(mlx5e_mpwqe_get_log_stride_size(priv->mdev, params, NULL)); 383 384 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "RQ"); 385 if (err) 386 return err; 387 388 err = devlink_fmsg_u8_pair_put(fmsg, "type", params->rq_wq_type); 389 if (err) 390 return err; 391 392 err = devlink_fmsg_u64_pair_put(fmsg, "stride size", rq_stride); 393 if (err) 394 return err; 395 396 err = devlink_fmsg_u32_pair_put(fmsg, "size", rq_sz); 397 if (err) 398 return err; 399 400 err = devlink_fmsg_string_pair_put(fmsg, "ts_format", real_time ? "RT" : "FRC"); 401 if (err) 402 return err; 403 404 err = mlx5e_health_cq_common_diag_fmsg(&rq->cq, fmsg); 405 if (err) 406 return err; 407 408 return mlx5e_health_fmsg_named_obj_nest_end(fmsg); 409 } 410 411 static int 412 mlx5e_rx_reporter_diagnose_common_ptp_config(struct mlx5e_priv *priv, struct mlx5e_ptp *ptp_ch, 413 struct devlink_fmsg *fmsg) 414 { 415 int err; 416 417 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "PTP"); 418 if (err) 419 return err; 420 421 err = devlink_fmsg_u32_pair_put(fmsg, "filter_type", priv->tstamp.rx_filter); 422 if (err) 423 return err; 424 425 err = mlx5e_rx_reporter_diagnose_generic_rq(&ptp_ch->rq, fmsg); 426 if (err) 427 return err; 428 429 return mlx5e_health_fmsg_named_obj_nest_end(fmsg); 430 } 431 432 static int 433 mlx5e_rx_reporter_diagnose_common_config(struct devlink_health_reporter *reporter, 434 struct devlink_fmsg *fmsg) 435 { 436 struct mlx5e_priv *priv = devlink_health_reporter_priv(reporter); 437 struct mlx5e_rq *generic_rq = &priv->channels.c[0]->rq; 438 struct mlx5e_ptp *ptp_ch = priv->channels.ptp; 439 int err; 440 441 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "Common config"); 442 if (err) 443 return err; 444 445 err = mlx5e_rx_reporter_diagnose_generic_rq(generic_rq, fmsg); 446 if (err) 447 return err; 448 449 if (ptp_ch && test_bit(MLX5E_PTP_STATE_RX, ptp_ch->state)) { 450 err = mlx5e_rx_reporter_diagnose_common_ptp_config(priv, ptp_ch, fmsg); 451 if (err) 452 return err; 453 } 454 455 return mlx5e_health_fmsg_named_obj_nest_end(fmsg); 456 } 457 458 static int mlx5e_rx_reporter_build_diagnose_output_ptp_rq(struct mlx5e_rq *rq, 459 struct devlink_fmsg *fmsg) 460 { 461 int err; 462 463 err = devlink_fmsg_obj_nest_start(fmsg); 464 if (err) 465 return err; 466 467 err = devlink_fmsg_string_pair_put(fmsg, "channel", "ptp"); 468 if (err) 469 return err; 470 471 err = mlx5e_rx_reporter_build_diagnose_output_rq_common(rq, fmsg); 472 if (err) 473 return err; 474 475 err = devlink_fmsg_obj_nest_end(fmsg); 476 if (err) 477 return err; 478 479 return 0; 480 } 481 482 static int mlx5e_rx_reporter_diagnose(struct devlink_health_reporter *reporter, 483 struct devlink_fmsg *fmsg, 484 struct netlink_ext_ack *extack) 485 { 486 struct mlx5e_priv *priv = devlink_health_reporter_priv(reporter); 487 struct mlx5e_ptp *ptp_ch = priv->channels.ptp; 488 int i, err = 0; 489 490 mutex_lock(&priv->state_lock); 491 492 if (!test_bit(MLX5E_STATE_OPENED, &priv->state)) 493 goto unlock; 494 495 err = mlx5e_rx_reporter_diagnose_common_config(reporter, fmsg); 496 if (err) 497 goto unlock; 498 499 err = devlink_fmsg_arr_pair_nest_start(fmsg, "RQs"); 500 if (err) 501 goto unlock; 502 503 for (i = 0; i < priv->channels.num; i++) { 504 struct mlx5e_channel *c = priv->channels.c[i]; 505 struct mlx5e_rq *rq; 506 507 rq = test_bit(MLX5E_CHANNEL_STATE_XSK, c->state) ? 508 &c->xskrq : &c->rq; 509 510 err = mlx5e_rx_reporter_build_diagnose_output(rq, fmsg); 511 if (err) 512 goto unlock; 513 } 514 if (ptp_ch && test_bit(MLX5E_PTP_STATE_RX, ptp_ch->state)) { 515 err = mlx5e_rx_reporter_build_diagnose_output_ptp_rq(&ptp_ch->rq, fmsg); 516 if (err) 517 goto unlock; 518 } 519 err = devlink_fmsg_arr_pair_nest_end(fmsg); 520 unlock: 521 mutex_unlock(&priv->state_lock); 522 return err; 523 } 524 525 static int mlx5e_rx_reporter_dump_icosq(struct mlx5e_priv *priv, struct devlink_fmsg *fmsg, 526 void *ctx) 527 { 528 struct mlx5e_txqsq *icosq = ctx; 529 struct mlx5_rsc_key key = {}; 530 int err; 531 532 if (!test_bit(MLX5E_STATE_OPENED, &priv->state)) 533 return 0; 534 535 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "SX Slice"); 536 if (err) 537 return err; 538 539 key.size = PAGE_SIZE; 540 key.rsc = MLX5_SGMT_TYPE_SX_SLICE_ALL; 541 err = mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg); 542 if (err) 543 return err; 544 545 err = mlx5e_health_fmsg_named_obj_nest_end(fmsg); 546 if (err) 547 return err; 548 549 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "ICOSQ"); 550 if (err) 551 return err; 552 553 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "QPC"); 554 if (err) 555 return err; 556 557 key.rsc = MLX5_SGMT_TYPE_FULL_QPC; 558 key.index1 = icosq->sqn; 559 key.num_of_obj1 = 1; 560 561 err = mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg); 562 if (err) 563 return err; 564 565 err = mlx5e_health_fmsg_named_obj_nest_end(fmsg); 566 if (err) 567 return err; 568 569 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "send_buff"); 570 if (err) 571 return err; 572 573 key.rsc = MLX5_SGMT_TYPE_SND_BUFF; 574 key.num_of_obj2 = MLX5_RSC_DUMP_ALL; 575 576 err = mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg); 577 if (err) 578 return err; 579 580 err = mlx5e_health_fmsg_named_obj_nest_end(fmsg); 581 if (err) 582 return err; 583 584 return mlx5e_health_fmsg_named_obj_nest_end(fmsg); 585 } 586 587 static int mlx5e_rx_reporter_dump_rq(struct mlx5e_priv *priv, struct devlink_fmsg *fmsg, 588 void *ctx) 589 { 590 struct mlx5_rsc_key key = {}; 591 struct mlx5e_rq *rq = ctx; 592 int err; 593 594 if (!test_bit(MLX5E_STATE_OPENED, &priv->state)) 595 return 0; 596 597 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "RX Slice"); 598 if (err) 599 return err; 600 601 key.size = PAGE_SIZE; 602 key.rsc = MLX5_SGMT_TYPE_RX_SLICE_ALL; 603 err = mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg); 604 if (err) 605 return err; 606 607 err = mlx5e_health_fmsg_named_obj_nest_end(fmsg); 608 if (err) 609 return err; 610 611 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "RQ"); 612 if (err) 613 return err; 614 615 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "QPC"); 616 if (err) 617 return err; 618 619 key.rsc = MLX5_SGMT_TYPE_FULL_QPC; 620 key.index1 = rq->rqn; 621 key.num_of_obj1 = 1; 622 623 err = mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg); 624 if (err) 625 return err; 626 627 err = mlx5e_health_fmsg_named_obj_nest_end(fmsg); 628 if (err) 629 return err; 630 631 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "receive_buff"); 632 if (err) 633 return err; 634 635 key.rsc = MLX5_SGMT_TYPE_RCV_BUFF; 636 key.num_of_obj2 = MLX5_RSC_DUMP_ALL; 637 err = mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg); 638 if (err) 639 return err; 640 641 err = mlx5e_health_fmsg_named_obj_nest_end(fmsg); 642 if (err) 643 return err; 644 645 return mlx5e_health_fmsg_named_obj_nest_end(fmsg); 646 } 647 648 static int mlx5e_rx_reporter_dump_all_rqs(struct mlx5e_priv *priv, 649 struct devlink_fmsg *fmsg) 650 { 651 struct mlx5e_ptp *ptp_ch = priv->channels.ptp; 652 struct mlx5_rsc_key key = {}; 653 int i, err; 654 655 if (!test_bit(MLX5E_STATE_OPENED, &priv->state)) 656 return 0; 657 658 err = mlx5e_health_fmsg_named_obj_nest_start(fmsg, "RX Slice"); 659 if (err) 660 return err; 661 662 key.size = PAGE_SIZE; 663 key.rsc = MLX5_SGMT_TYPE_RX_SLICE_ALL; 664 err = mlx5e_health_rsc_fmsg_dump(priv, &key, fmsg); 665 if (err) 666 return err; 667 668 err = mlx5e_health_fmsg_named_obj_nest_end(fmsg); 669 if (err) 670 return err; 671 672 err = devlink_fmsg_arr_pair_nest_start(fmsg, "RQs"); 673 if (err) 674 return err; 675 676 for (i = 0; i < priv->channels.num; i++) { 677 struct mlx5e_rq *rq = &priv->channels.c[i]->rq; 678 679 err = mlx5e_health_queue_dump(priv, fmsg, rq->rqn, "RQ"); 680 if (err) 681 return err; 682 } 683 684 if (ptp_ch && test_bit(MLX5E_PTP_STATE_RX, ptp_ch->state)) { 685 err = mlx5e_health_queue_dump(priv, fmsg, ptp_ch->rq.rqn, "PTP RQ"); 686 if (err) 687 return err; 688 } 689 690 return devlink_fmsg_arr_pair_nest_end(fmsg); 691 } 692 693 static int mlx5e_rx_reporter_dump_from_ctx(struct mlx5e_priv *priv, 694 struct mlx5e_err_ctx *err_ctx, 695 struct devlink_fmsg *fmsg) 696 { 697 return err_ctx->dump(priv, fmsg, err_ctx->ctx); 698 } 699 700 static int mlx5e_rx_reporter_dump(struct devlink_health_reporter *reporter, 701 struct devlink_fmsg *fmsg, void *context, 702 struct netlink_ext_ack *extack) 703 { 704 struct mlx5e_priv *priv = devlink_health_reporter_priv(reporter); 705 struct mlx5e_err_ctx *err_ctx = context; 706 707 return err_ctx ? mlx5e_rx_reporter_dump_from_ctx(priv, err_ctx, fmsg) : 708 mlx5e_rx_reporter_dump_all_rqs(priv, fmsg); 709 } 710 711 void mlx5e_reporter_rx_timeout(struct mlx5e_rq *rq) 712 { 713 char icosq_str[MLX5E_REPORTER_PER_Q_MAX_LEN] = {}; 714 char err_str[MLX5E_REPORTER_PER_Q_MAX_LEN]; 715 struct mlx5e_icosq *icosq = rq->icosq; 716 struct mlx5e_priv *priv = rq->priv; 717 struct mlx5e_err_ctx err_ctx = {}; 718 719 err_ctx.ctx = rq; 720 err_ctx.recover = mlx5e_rx_reporter_timeout_recover; 721 err_ctx.dump = mlx5e_rx_reporter_dump_rq; 722 723 if (icosq) 724 snprintf(icosq_str, sizeof(icosq_str), "ICOSQ: 0x%x, ", icosq->sqn); 725 snprintf(err_str, sizeof(err_str), 726 "RX timeout on channel: %d, %sRQ: 0x%x, CQ: 0x%x", 727 rq->ix, icosq_str, rq->rqn, rq->cq.mcq.cqn); 728 729 mlx5e_health_report(priv, priv->rx_reporter, err_str, &err_ctx); 730 } 731 732 void mlx5e_reporter_rq_cqe_err(struct mlx5e_rq *rq) 733 { 734 char err_str[MLX5E_REPORTER_PER_Q_MAX_LEN]; 735 struct mlx5e_priv *priv = rq->priv; 736 struct mlx5e_err_ctx err_ctx = {}; 737 738 err_ctx.ctx = rq; 739 err_ctx.recover = mlx5e_rx_reporter_err_rq_cqe_recover; 740 err_ctx.dump = mlx5e_rx_reporter_dump_rq; 741 snprintf(err_str, sizeof(err_str), "ERR CQE on RQ: 0x%x", rq->rqn); 742 743 mlx5e_health_report(priv, priv->rx_reporter, err_str, &err_ctx); 744 } 745 746 void mlx5e_reporter_icosq_cqe_err(struct mlx5e_icosq *icosq) 747 { 748 struct mlx5e_priv *priv = icosq->channel->priv; 749 char err_str[MLX5E_REPORTER_PER_Q_MAX_LEN]; 750 struct mlx5e_err_ctx err_ctx = {}; 751 752 err_ctx.ctx = icosq; 753 err_ctx.recover = mlx5e_rx_reporter_err_icosq_cqe_recover; 754 err_ctx.dump = mlx5e_rx_reporter_dump_icosq; 755 snprintf(err_str, sizeof(err_str), "ERR CQE on ICOSQ: 0x%x", icosq->sqn); 756 757 mlx5e_health_report(priv, priv->rx_reporter, err_str, &err_ctx); 758 } 759 760 void mlx5e_reporter_icosq_suspend_recovery(struct mlx5e_channel *c) 761 { 762 mutex_lock(&c->icosq_recovery_lock); 763 } 764 765 void mlx5e_reporter_icosq_resume_recovery(struct mlx5e_channel *c) 766 { 767 mutex_unlock(&c->icosq_recovery_lock); 768 } 769 770 static const struct devlink_health_reporter_ops mlx5_rx_reporter_ops = { 771 .name = "rx", 772 .recover = mlx5e_rx_reporter_recover, 773 .diagnose = mlx5e_rx_reporter_diagnose, 774 .dump = mlx5e_rx_reporter_dump, 775 }; 776 777 #define MLX5E_REPORTER_RX_GRACEFUL_PERIOD 500 778 779 void mlx5e_reporter_rx_create(struct mlx5e_priv *priv) 780 { 781 struct devlink_health_reporter *reporter; 782 783 reporter = devlink_port_health_reporter_create(priv->netdev->devlink_port, 784 &mlx5_rx_reporter_ops, 785 MLX5E_REPORTER_RX_GRACEFUL_PERIOD, priv); 786 if (IS_ERR(reporter)) { 787 netdev_warn(priv->netdev, "Failed to create rx reporter, err = %ld\n", 788 PTR_ERR(reporter)); 789 return; 790 } 791 priv->rx_reporter = reporter; 792 } 793 794 void mlx5e_reporter_rx_destroy(struct mlx5e_priv *priv) 795 { 796 if (!priv->rx_reporter) 797 return; 798 799 devlink_health_reporter_destroy(priv->rx_reporter); 800 priv->rx_reporter = NULL; 801 } 802