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