1 // SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB 2 // Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. 3 4 #include <linux/debugfs.h> 5 #include <linux/kernel.h> 6 #include <linux/seq_file.h> 7 #include "dr_types.h" 8 9 #define DR_DBG_PTR_TO_ID(p) ((u64)(uintptr_t)(p) & 0xFFFFFFFFULL) 10 11 enum dr_dump_rec_type { 12 DR_DUMP_REC_TYPE_DOMAIN = 3000, 13 DR_DUMP_REC_TYPE_DOMAIN_INFO_FLEX_PARSER = 3001, 14 DR_DUMP_REC_TYPE_DOMAIN_INFO_DEV_ATTR = 3002, 15 DR_DUMP_REC_TYPE_DOMAIN_INFO_VPORT = 3003, 16 DR_DUMP_REC_TYPE_DOMAIN_INFO_CAPS = 3004, 17 DR_DUMP_REC_TYPE_DOMAIN_SEND_RING = 3005, 18 19 DR_DUMP_REC_TYPE_TABLE = 3100, 20 DR_DUMP_REC_TYPE_TABLE_RX = 3101, 21 DR_DUMP_REC_TYPE_TABLE_TX = 3102, 22 23 DR_DUMP_REC_TYPE_MATCHER = 3200, 24 DR_DUMP_REC_TYPE_MATCHER_MASK_DEPRECATED = 3201, 25 DR_DUMP_REC_TYPE_MATCHER_RX = 3202, 26 DR_DUMP_REC_TYPE_MATCHER_TX = 3203, 27 DR_DUMP_REC_TYPE_MATCHER_BUILDER = 3204, 28 DR_DUMP_REC_TYPE_MATCHER_MASK = 3205, 29 30 DR_DUMP_REC_TYPE_RULE = 3300, 31 DR_DUMP_REC_TYPE_RULE_RX_ENTRY_V0 = 3301, 32 DR_DUMP_REC_TYPE_RULE_TX_ENTRY_V0 = 3302, 33 DR_DUMP_REC_TYPE_RULE_RX_ENTRY_V1 = 3303, 34 DR_DUMP_REC_TYPE_RULE_TX_ENTRY_V1 = 3304, 35 36 DR_DUMP_REC_TYPE_ACTION_ENCAP_L2 = 3400, 37 DR_DUMP_REC_TYPE_ACTION_ENCAP_L3 = 3401, 38 DR_DUMP_REC_TYPE_ACTION_MODIFY_HDR = 3402, 39 DR_DUMP_REC_TYPE_ACTION_DROP = 3403, 40 DR_DUMP_REC_TYPE_ACTION_QP = 3404, 41 DR_DUMP_REC_TYPE_ACTION_FT = 3405, 42 DR_DUMP_REC_TYPE_ACTION_CTR = 3406, 43 DR_DUMP_REC_TYPE_ACTION_TAG = 3407, 44 DR_DUMP_REC_TYPE_ACTION_VPORT = 3408, 45 DR_DUMP_REC_TYPE_ACTION_DECAP_L2 = 3409, 46 DR_DUMP_REC_TYPE_ACTION_DECAP_L3 = 3410, 47 DR_DUMP_REC_TYPE_ACTION_DEVX_TIR = 3411, 48 DR_DUMP_REC_TYPE_ACTION_PUSH_VLAN = 3412, 49 DR_DUMP_REC_TYPE_ACTION_POP_VLAN = 3413, 50 DR_DUMP_REC_TYPE_ACTION_SAMPLER = 3415, 51 DR_DUMP_REC_TYPE_ACTION_INSERT_HDR = 3420, 52 DR_DUMP_REC_TYPE_ACTION_REMOVE_HDR = 3421 53 }; 54 55 void mlx5dr_dbg_tbl_add(struct mlx5dr_table *tbl) 56 { 57 mutex_lock(&tbl->dmn->dump_info.dbg_mutex); 58 list_add_tail(&tbl->dbg_node, &tbl->dmn->dbg_tbl_list); 59 mutex_unlock(&tbl->dmn->dump_info.dbg_mutex); 60 } 61 62 void mlx5dr_dbg_tbl_del(struct mlx5dr_table *tbl) 63 { 64 mutex_lock(&tbl->dmn->dump_info.dbg_mutex); 65 list_del(&tbl->dbg_node); 66 mutex_unlock(&tbl->dmn->dump_info.dbg_mutex); 67 } 68 69 void mlx5dr_dbg_rule_add(struct mlx5dr_rule *rule) 70 { 71 struct mlx5dr_domain *dmn = rule->matcher->tbl->dmn; 72 73 mutex_lock(&dmn->dump_info.dbg_mutex); 74 list_add_tail(&rule->dbg_node, &rule->matcher->dbg_rule_list); 75 mutex_unlock(&dmn->dump_info.dbg_mutex); 76 } 77 78 void mlx5dr_dbg_rule_del(struct mlx5dr_rule *rule) 79 { 80 struct mlx5dr_domain *dmn = rule->matcher->tbl->dmn; 81 82 mutex_lock(&dmn->dump_info.dbg_mutex); 83 list_del(&rule->dbg_node); 84 mutex_unlock(&dmn->dump_info.dbg_mutex); 85 } 86 87 static u64 dr_dump_icm_to_idx(u64 icm_addr) 88 { 89 return (icm_addr >> 6) & 0xffffffff; 90 } 91 92 #define DR_HEX_SIZE 256 93 94 static void 95 dr_dump_hex_print(char hex[DR_HEX_SIZE], char *src, u32 size) 96 { 97 if (WARN_ON_ONCE(DR_HEX_SIZE < 2 * size + 1)) 98 size = DR_HEX_SIZE / 2 - 1; /* truncate */ 99 100 bin2hex(hex, src, size); 101 hex[2 * size] = 0; /* NULL-terminate */ 102 } 103 104 static int 105 dr_dump_rule_action_mem(struct seq_file *file, const u64 rule_id, 106 struct mlx5dr_rule_action_member *action_mem) 107 { 108 struct mlx5dr_action *action = action_mem->action; 109 const u64 action_id = DR_DBG_PTR_TO_ID(action); 110 111 switch (action->action_type) { 112 case DR_ACTION_TYP_DROP: 113 seq_printf(file, "%d,0x%llx,0x%llx\n", 114 DR_DUMP_REC_TYPE_ACTION_DROP, action_id, rule_id); 115 break; 116 case DR_ACTION_TYP_FT: 117 if (action->dest_tbl->is_fw_tbl) 118 seq_printf(file, "%d,0x%llx,0x%llx,0x%x,0x%x\n", 119 DR_DUMP_REC_TYPE_ACTION_FT, action_id, 120 rule_id, action->dest_tbl->fw_tbl.id, 121 -1); 122 else 123 seq_printf(file, "%d,0x%llx,0x%llx,0x%x,0x%llx\n", 124 DR_DUMP_REC_TYPE_ACTION_FT, action_id, 125 rule_id, action->dest_tbl->tbl->table_id, 126 DR_DBG_PTR_TO_ID(action->dest_tbl->tbl)); 127 128 break; 129 case DR_ACTION_TYP_CTR: 130 seq_printf(file, "%d,0x%llx,0x%llx,0x%x\n", 131 DR_DUMP_REC_TYPE_ACTION_CTR, action_id, rule_id, 132 action->ctr->ctr_id + action->ctr->offset); 133 break; 134 case DR_ACTION_TYP_TAG: 135 seq_printf(file, "%d,0x%llx,0x%llx,0x%x\n", 136 DR_DUMP_REC_TYPE_ACTION_TAG, action_id, rule_id, 137 action->flow_tag->flow_tag); 138 break; 139 case DR_ACTION_TYP_MODIFY_HDR: 140 seq_printf(file, "%d,0x%llx,0x%llx,0x%x\n", 141 DR_DUMP_REC_TYPE_ACTION_MODIFY_HDR, action_id, 142 rule_id, action->rewrite->index); 143 break; 144 case DR_ACTION_TYP_VPORT: 145 seq_printf(file, "%d,0x%llx,0x%llx,0x%x\n", 146 DR_DUMP_REC_TYPE_ACTION_VPORT, action_id, rule_id, 147 action->vport->caps->num); 148 break; 149 case DR_ACTION_TYP_TNL_L2_TO_L2: 150 seq_printf(file, "%d,0x%llx,0x%llx\n", 151 DR_DUMP_REC_TYPE_ACTION_DECAP_L2, action_id, 152 rule_id); 153 break; 154 case DR_ACTION_TYP_TNL_L3_TO_L2: 155 seq_printf(file, "%d,0x%llx,0x%llx,0x%x\n", 156 DR_DUMP_REC_TYPE_ACTION_DECAP_L3, action_id, 157 rule_id, action->rewrite->index); 158 break; 159 case DR_ACTION_TYP_L2_TO_TNL_L2: 160 seq_printf(file, "%d,0x%llx,0x%llx,0x%x\n", 161 DR_DUMP_REC_TYPE_ACTION_ENCAP_L2, action_id, 162 rule_id, action->reformat->id); 163 break; 164 case DR_ACTION_TYP_L2_TO_TNL_L3: 165 seq_printf(file, "%d,0x%llx,0x%llx,0x%x\n", 166 DR_DUMP_REC_TYPE_ACTION_ENCAP_L3, action_id, 167 rule_id, action->reformat->id); 168 break; 169 case DR_ACTION_TYP_POP_VLAN: 170 seq_printf(file, "%d,0x%llx,0x%llx\n", 171 DR_DUMP_REC_TYPE_ACTION_POP_VLAN, action_id, 172 rule_id); 173 break; 174 case DR_ACTION_TYP_PUSH_VLAN: 175 seq_printf(file, "%d,0x%llx,0x%llx,0x%x\n", 176 DR_DUMP_REC_TYPE_ACTION_PUSH_VLAN, action_id, 177 rule_id, action->push_vlan->vlan_hdr); 178 break; 179 case DR_ACTION_TYP_INSERT_HDR: 180 seq_printf(file, "%d,0x%llx,0x%llx,0x%x,0x%x,0x%x\n", 181 DR_DUMP_REC_TYPE_ACTION_INSERT_HDR, action_id, 182 rule_id, action->reformat->id, 183 action->reformat->param_0, 184 action->reformat->param_1); 185 break; 186 case DR_ACTION_TYP_REMOVE_HDR: 187 seq_printf(file, "%d,0x%llx,0x%llx,0x%x,0x%x,0x%x\n", 188 DR_DUMP_REC_TYPE_ACTION_REMOVE_HDR, action_id, 189 rule_id, action->reformat->id, 190 action->reformat->param_0, 191 action->reformat->param_1); 192 break; 193 case DR_ACTION_TYP_SAMPLER: 194 seq_printf(file, 195 "%d,0x%llx,0x%llx,0x%x,0x%x,0x%x,0x%llx,0x%llx\n", 196 DR_DUMP_REC_TYPE_ACTION_SAMPLER, action_id, rule_id, 197 0, 0, action->sampler->sampler_id, 198 action->sampler->rx_icm_addr, 199 action->sampler->tx_icm_addr); 200 break; 201 default: 202 return 0; 203 } 204 205 return 0; 206 } 207 208 static int 209 dr_dump_rule_mem(struct seq_file *file, struct mlx5dr_ste *ste, 210 bool is_rx, const u64 rule_id, u8 format_ver) 211 { 212 char hw_ste_dump[DR_HEX_SIZE]; 213 u32 mem_rec_type; 214 215 if (format_ver == MLX5_STEERING_FORMAT_CONNECTX_5) { 216 mem_rec_type = is_rx ? DR_DUMP_REC_TYPE_RULE_RX_ENTRY_V0 : 217 DR_DUMP_REC_TYPE_RULE_TX_ENTRY_V0; 218 } else { 219 mem_rec_type = is_rx ? DR_DUMP_REC_TYPE_RULE_RX_ENTRY_V1 : 220 DR_DUMP_REC_TYPE_RULE_TX_ENTRY_V1; 221 } 222 223 dr_dump_hex_print(hw_ste_dump, (char *)mlx5dr_ste_get_hw_ste(ste), 224 DR_STE_SIZE_REDUCED); 225 226 seq_printf(file, "%d,0x%llx,0x%llx,%s\n", mem_rec_type, 227 dr_dump_icm_to_idx(mlx5dr_ste_get_icm_addr(ste)), rule_id, 228 hw_ste_dump); 229 230 return 0; 231 } 232 233 static int 234 dr_dump_rule_rx_tx(struct seq_file *file, struct mlx5dr_rule_rx_tx *rule_rx_tx, 235 bool is_rx, const u64 rule_id, u8 format_ver) 236 { 237 struct mlx5dr_ste *ste_arr[DR_RULE_MAX_STES + DR_ACTION_MAX_STES]; 238 struct mlx5dr_ste *curr_ste = rule_rx_tx->last_rule_ste; 239 int ret, i; 240 241 if (mlx5dr_rule_get_reverse_rule_members(ste_arr, curr_ste, &i)) 242 return 0; 243 244 while (i--) { 245 ret = dr_dump_rule_mem(file, ste_arr[i], is_rx, rule_id, 246 format_ver); 247 if (ret < 0) 248 return ret; 249 } 250 251 return 0; 252 } 253 254 static int dr_dump_rule(struct seq_file *file, struct mlx5dr_rule *rule) 255 { 256 struct mlx5dr_rule_action_member *action_mem; 257 const u64 rule_id = DR_DBG_PTR_TO_ID(rule); 258 struct mlx5dr_rule_rx_tx *rx = &rule->rx; 259 struct mlx5dr_rule_rx_tx *tx = &rule->tx; 260 u8 format_ver; 261 int ret; 262 263 format_ver = rule->matcher->tbl->dmn->info.caps.sw_format_ver; 264 265 seq_printf(file, "%d,0x%llx,0x%llx\n", DR_DUMP_REC_TYPE_RULE, rule_id, 266 DR_DBG_PTR_TO_ID(rule->matcher)); 267 268 if (rx->nic_matcher) { 269 ret = dr_dump_rule_rx_tx(file, rx, true, rule_id, format_ver); 270 if (ret < 0) 271 return ret; 272 } 273 274 if (tx->nic_matcher) { 275 ret = dr_dump_rule_rx_tx(file, tx, false, rule_id, format_ver); 276 if (ret < 0) 277 return ret; 278 } 279 280 list_for_each_entry(action_mem, &rule->rule_actions_list, list) { 281 ret = dr_dump_rule_action_mem(file, rule_id, action_mem); 282 if (ret < 0) 283 return ret; 284 } 285 286 return 0; 287 } 288 289 static int 290 dr_dump_matcher_mask(struct seq_file *file, struct mlx5dr_match_param *mask, 291 u8 criteria, const u64 matcher_id) 292 { 293 char dump[DR_HEX_SIZE]; 294 295 seq_printf(file, "%d,0x%llx,", DR_DUMP_REC_TYPE_MATCHER_MASK, 296 matcher_id); 297 298 if (criteria & DR_MATCHER_CRITERIA_OUTER) { 299 dr_dump_hex_print(dump, (char *)&mask->outer, sizeof(mask->outer)); 300 seq_printf(file, "%s,", dump); 301 } else { 302 seq_puts(file, ","); 303 } 304 305 if (criteria & DR_MATCHER_CRITERIA_INNER) { 306 dr_dump_hex_print(dump, (char *)&mask->inner, sizeof(mask->inner)); 307 seq_printf(file, "%s,", dump); 308 } else { 309 seq_puts(file, ","); 310 } 311 312 if (criteria & DR_MATCHER_CRITERIA_MISC) { 313 dr_dump_hex_print(dump, (char *)&mask->misc, sizeof(mask->misc)); 314 seq_printf(file, "%s,", dump); 315 } else { 316 seq_puts(file, ","); 317 } 318 319 if (criteria & DR_MATCHER_CRITERIA_MISC2) { 320 dr_dump_hex_print(dump, (char *)&mask->misc2, sizeof(mask->misc2)); 321 seq_printf(file, "%s,", dump); 322 } else { 323 seq_puts(file, ","); 324 } 325 326 if (criteria & DR_MATCHER_CRITERIA_MISC3) { 327 dr_dump_hex_print(dump, (char *)&mask->misc3, sizeof(mask->misc3)); 328 seq_printf(file, "%s\n", dump); 329 } else { 330 seq_puts(file, ",\n"); 331 } 332 333 return 0; 334 } 335 336 static int 337 dr_dump_matcher_builder(struct seq_file *file, struct mlx5dr_ste_build *builder, 338 u32 index, bool is_rx, const u64 matcher_id) 339 { 340 seq_printf(file, "%d,0x%llx,%d,%d,0x%x\n", 341 DR_DUMP_REC_TYPE_MATCHER_BUILDER, matcher_id, index, is_rx, 342 builder->lu_type); 343 344 return 0; 345 } 346 347 static int 348 dr_dump_matcher_rx_tx(struct seq_file *file, bool is_rx, 349 struct mlx5dr_matcher_rx_tx *matcher_rx_tx, 350 const u64 matcher_id) 351 { 352 enum dr_dump_rec_type rec_type; 353 u64 s_icm_addr, e_icm_addr; 354 int i, ret; 355 356 rec_type = is_rx ? DR_DUMP_REC_TYPE_MATCHER_RX : 357 DR_DUMP_REC_TYPE_MATCHER_TX; 358 359 s_icm_addr = mlx5dr_icm_pool_get_chunk_icm_addr(matcher_rx_tx->s_htbl->chunk); 360 e_icm_addr = mlx5dr_icm_pool_get_chunk_icm_addr(matcher_rx_tx->e_anchor->chunk); 361 seq_printf(file, "%d,0x%llx,0x%llx,%d,0x%llx,0x%llx\n", 362 rec_type, DR_DBG_PTR_TO_ID(matcher_rx_tx), 363 matcher_id, matcher_rx_tx->num_of_builders, 364 dr_dump_icm_to_idx(s_icm_addr), 365 dr_dump_icm_to_idx(e_icm_addr)); 366 367 for (i = 0; i < matcher_rx_tx->num_of_builders; i++) { 368 ret = dr_dump_matcher_builder(file, 369 &matcher_rx_tx->ste_builder[i], 370 i, is_rx, matcher_id); 371 if (ret < 0) 372 return ret; 373 } 374 375 return 0; 376 } 377 378 static int 379 dr_dump_matcher(struct seq_file *file, struct mlx5dr_matcher *matcher) 380 { 381 struct mlx5dr_matcher_rx_tx *rx = &matcher->rx; 382 struct mlx5dr_matcher_rx_tx *tx = &matcher->tx; 383 u64 matcher_id; 384 int ret; 385 386 matcher_id = DR_DBG_PTR_TO_ID(matcher); 387 388 seq_printf(file, "%d,0x%llx,0x%llx,%d\n", DR_DUMP_REC_TYPE_MATCHER, 389 matcher_id, DR_DBG_PTR_TO_ID(matcher->tbl), matcher->prio); 390 391 ret = dr_dump_matcher_mask(file, &matcher->mask, 392 matcher->match_criteria, matcher_id); 393 if (ret < 0) 394 return ret; 395 396 if (rx->nic_tbl) { 397 ret = dr_dump_matcher_rx_tx(file, true, rx, matcher_id); 398 if (ret < 0) 399 return ret; 400 } 401 402 if (tx->nic_tbl) { 403 ret = dr_dump_matcher_rx_tx(file, false, tx, matcher_id); 404 if (ret < 0) 405 return ret; 406 } 407 408 return 0; 409 } 410 411 static int 412 dr_dump_matcher_all(struct seq_file *file, struct mlx5dr_matcher *matcher) 413 { 414 struct mlx5dr_rule *rule; 415 int ret; 416 417 ret = dr_dump_matcher(file, matcher); 418 if (ret < 0) 419 return ret; 420 421 list_for_each_entry(rule, &matcher->dbg_rule_list, dbg_node) { 422 ret = dr_dump_rule(file, rule); 423 if (ret < 0) 424 return ret; 425 } 426 427 return 0; 428 } 429 430 static int 431 dr_dump_table_rx_tx(struct seq_file *file, bool is_rx, 432 struct mlx5dr_table_rx_tx *table_rx_tx, 433 const u64 table_id) 434 { 435 enum dr_dump_rec_type rec_type; 436 u64 s_icm_addr; 437 438 rec_type = is_rx ? DR_DUMP_REC_TYPE_TABLE_RX : 439 DR_DUMP_REC_TYPE_TABLE_TX; 440 441 s_icm_addr = mlx5dr_icm_pool_get_chunk_icm_addr(table_rx_tx->s_anchor->chunk); 442 seq_printf(file, "%d,0x%llx,0x%llx\n", rec_type, table_id, 443 dr_dump_icm_to_idx(s_icm_addr)); 444 445 return 0; 446 } 447 448 static int dr_dump_table(struct seq_file *file, struct mlx5dr_table *table) 449 { 450 struct mlx5dr_table_rx_tx *rx = &table->rx; 451 struct mlx5dr_table_rx_tx *tx = &table->tx; 452 int ret; 453 454 seq_printf(file, "%d,0x%llx,0x%llx,%d,%d\n", DR_DUMP_REC_TYPE_TABLE, 455 DR_DBG_PTR_TO_ID(table), DR_DBG_PTR_TO_ID(table->dmn), 456 table->table_type, table->level); 457 458 if (rx->nic_dmn) { 459 ret = dr_dump_table_rx_tx(file, true, rx, 460 DR_DBG_PTR_TO_ID(table)); 461 if (ret < 0) 462 return ret; 463 } 464 465 if (tx->nic_dmn) { 466 ret = dr_dump_table_rx_tx(file, false, tx, 467 DR_DBG_PTR_TO_ID(table)); 468 if (ret < 0) 469 return ret; 470 } 471 return 0; 472 } 473 474 static int dr_dump_table_all(struct seq_file *file, struct mlx5dr_table *tbl) 475 { 476 struct mlx5dr_matcher *matcher; 477 int ret; 478 479 ret = dr_dump_table(file, tbl); 480 if (ret < 0) 481 return ret; 482 483 list_for_each_entry(matcher, &tbl->matcher_list, list_node) { 484 ret = dr_dump_matcher_all(file, matcher); 485 if (ret < 0) 486 return ret; 487 } 488 return 0; 489 } 490 491 static int 492 dr_dump_send_ring(struct seq_file *file, struct mlx5dr_send_ring *ring, 493 const u64 domain_id) 494 { 495 seq_printf(file, "%d,0x%llx,0x%llx,0x%x,0x%x\n", 496 DR_DUMP_REC_TYPE_DOMAIN_SEND_RING, DR_DBG_PTR_TO_ID(ring), 497 domain_id, ring->cq->mcq.cqn, ring->qp->qpn); 498 return 0; 499 } 500 501 static int 502 dr_dump_domain_info_flex_parser(struct seq_file *file, 503 const char *flex_parser_name, 504 const u8 flex_parser_value, 505 const u64 domain_id) 506 { 507 seq_printf(file, "%d,0x%llx,%s,0x%x\n", 508 DR_DUMP_REC_TYPE_DOMAIN_INFO_FLEX_PARSER, domain_id, 509 flex_parser_name, flex_parser_value); 510 return 0; 511 } 512 513 static int 514 dr_dump_domain_info_caps(struct seq_file *file, struct mlx5dr_cmd_caps *caps, 515 const u64 domain_id) 516 { 517 struct mlx5dr_cmd_vport_cap *vport_caps; 518 unsigned long i, vports_num; 519 520 xa_for_each(&caps->vports.vports_caps_xa, vports_num, vport_caps) 521 ; /* count the number of vports in xarray */ 522 523 seq_printf(file, "%d,0x%llx,0x%x,0x%llx,0x%llx,0x%x,%lu,%d\n", 524 DR_DUMP_REC_TYPE_DOMAIN_INFO_CAPS, domain_id, caps->gvmi, 525 caps->nic_rx_drop_address, caps->nic_tx_drop_address, 526 caps->flex_protocols, vports_num, caps->eswitch_manager); 527 528 xa_for_each(&caps->vports.vports_caps_xa, i, vport_caps) { 529 vport_caps = xa_load(&caps->vports.vports_caps_xa, i); 530 531 seq_printf(file, "%d,0x%llx,%lu,0x%x,0x%llx,0x%llx\n", 532 DR_DUMP_REC_TYPE_DOMAIN_INFO_VPORT, domain_id, i, 533 vport_caps->vport_gvmi, vport_caps->icm_address_rx, 534 vport_caps->icm_address_tx); 535 } 536 return 0; 537 } 538 539 static int 540 dr_dump_domain_info(struct seq_file *file, struct mlx5dr_domain_info *info, 541 const u64 domain_id) 542 { 543 int ret; 544 545 ret = dr_dump_domain_info_caps(file, &info->caps, domain_id); 546 if (ret < 0) 547 return ret; 548 549 ret = dr_dump_domain_info_flex_parser(file, "icmp_dw0", 550 info->caps.flex_parser_id_icmp_dw0, 551 domain_id); 552 if (ret < 0) 553 return ret; 554 555 ret = dr_dump_domain_info_flex_parser(file, "icmp_dw1", 556 info->caps.flex_parser_id_icmp_dw1, 557 domain_id); 558 if (ret < 0) 559 return ret; 560 561 ret = dr_dump_domain_info_flex_parser(file, "icmpv6_dw0", 562 info->caps.flex_parser_id_icmpv6_dw0, 563 domain_id); 564 if (ret < 0) 565 return ret; 566 567 ret = dr_dump_domain_info_flex_parser(file, "icmpv6_dw1", 568 info->caps.flex_parser_id_icmpv6_dw1, 569 domain_id); 570 if (ret < 0) 571 return ret; 572 573 return 0; 574 } 575 576 static int 577 dr_dump_domain(struct seq_file *file, struct mlx5dr_domain *dmn) 578 { 579 u64 domain_id = DR_DBG_PTR_TO_ID(dmn); 580 int ret; 581 582 seq_printf(file, "%d,0x%llx,%d,0%x,%d,%s\n", DR_DUMP_REC_TYPE_DOMAIN, 583 domain_id, dmn->type, dmn->info.caps.gvmi, 584 dmn->info.supp_sw_steering, pci_name(dmn->mdev->pdev)); 585 586 ret = dr_dump_domain_info(file, &dmn->info, domain_id); 587 if (ret < 0) 588 return ret; 589 590 if (dmn->info.supp_sw_steering) { 591 ret = dr_dump_send_ring(file, dmn->send_ring, domain_id); 592 if (ret < 0) 593 return ret; 594 } 595 596 return 0; 597 } 598 599 static int dr_dump_domain_all(struct seq_file *file, struct mlx5dr_domain *dmn) 600 { 601 struct mlx5dr_table *tbl; 602 int ret; 603 604 mutex_lock(&dmn->dump_info.dbg_mutex); 605 mlx5dr_domain_lock(dmn); 606 607 ret = dr_dump_domain(file, dmn); 608 if (ret < 0) 609 goto unlock_mutex; 610 611 list_for_each_entry(tbl, &dmn->dbg_tbl_list, dbg_node) { 612 ret = dr_dump_table_all(file, tbl); 613 if (ret < 0) 614 break; 615 } 616 617 unlock_mutex: 618 mlx5dr_domain_unlock(dmn); 619 mutex_unlock(&dmn->dump_info.dbg_mutex); 620 return ret; 621 } 622 623 static int dr_dump_show(struct seq_file *file, void *priv) 624 { 625 return dr_dump_domain_all(file, file->private); 626 } 627 DEFINE_SHOW_ATTRIBUTE(dr_dump); 628 629 void mlx5dr_dbg_init_dump(struct mlx5dr_domain *dmn) 630 { 631 struct mlx5_core_dev *dev = dmn->mdev; 632 char file_name[128]; 633 634 if (dmn->type != MLX5DR_DOMAIN_TYPE_FDB) { 635 mlx5_core_warn(dev, 636 "Steering dump is not supported for NIC RX/TX domains\n"); 637 return; 638 } 639 640 dmn->dump_info.steering_debugfs = 641 debugfs_create_dir("steering", mlx5_debugfs_get_dev_root(dev)); 642 dmn->dump_info.fdb_debugfs = 643 debugfs_create_dir("fdb", dmn->dump_info.steering_debugfs); 644 645 sprintf(file_name, "dmn_%p", dmn); 646 debugfs_create_file(file_name, 0444, dmn->dump_info.fdb_debugfs, 647 dmn, &dr_dump_fops); 648 649 INIT_LIST_HEAD(&dmn->dbg_tbl_list); 650 mutex_init(&dmn->dump_info.dbg_mutex); 651 } 652 653 void mlx5dr_dbg_uninit_dump(struct mlx5dr_domain *dmn) 654 { 655 debugfs_remove_recursive(dmn->dump_info.steering_debugfs); 656 mutex_destroy(&dmn->dump_info.dbg_mutex); 657 } 658