flow_db.c (28105B)
1 /* 2 * 3 * This license is set out in https://raw.githubusercontent.com/Broadcom-Network-Switching-Software/OpenBCM/master/Legal/LICENSE file. 4 * 5 * Copyright 2007-2019 Broadcom Inc. All rights reserved. 6 * 7 * File: flow db.c 8 * Purpose: diag commands for flow db 9 */ 10 11 #ifndef NO_SAL_APPL 12 13 #include <sal/types.h> 14 #include <sal/core/libc.h> 15 #include <sal/appl/sal.h> 16 #include <sal/appl/io.h> 17 #include <shared/bsl.h> 18 #include <appl/diag/shell.h> 19 #include <appl/diag/system.h> 20 #include <soc/drv.h> 21 #include <soc/esw/cancun.h> 22 #include <soc/esw/flow_db.h> 23 #include <soc/esw/flow_db_core.h> 24 25 char cmd_flow_db_usage [] = 26 "Parameters: [flow_info|flow|flow_option|ffo|flow_logical_field|view|help] <args...>\n" 27 #ifndef COMPILER_STRING_CONST_LIMIT 28 " Flow DB database for flexible tables.\n"\ 29 "\t flow_info show - Detailed per flow information. \n"\ 30 "\t flow show - Flow table, Displays available flows and associated flow handles.\n"\ 31 "\t flow_option show - Flow option table, Displays avaiable options per flow\n"\ 32 "\t ffo show - Flow function option tuple table\n\n"\ 33 "\t ffo entry [<flow_id>] [<function_id>] [<option_id> \n"\ 34 " \t\t- Display the associated view id for flow, function, option combination \n"\ 35 "\t flow_logical_field show - Logical field table, displays logical fields per flow. \n"\ 36 "\t view show - View table \n"\ 37 "\t view entry [<view_id>] - \n"\ 38 " \t\t- View information.\n"\ 39 "\t view field entry [<view_id> <field_id>] - \n"\ 40 " \t\t- Field information. \n"\ 41 "\t help\t - display this usage page.\n"\ 42 "\n"\ 43 " arguments for each operation:\n" 44 #endif 45 ; 46 STATIC cmd_result_t _cmd_flow_db_flow_tbl(int unit); 47 STATIC cmd_result_t _cmd_flow_db_flow_op_tbl(int unit); 48 STATIC cmd_result_t _cmd_flow_db_flow_lg_tbl(int unit); 49 STATIC cmd_result_t _cmd_flow_db_ffo_tpl_tbl(int unit, 50 int flow_handle, 51 int func_id, 52 int option_id); 53 STATIC cmd_result_t 54 _cmd_flow_db_view_tbl(int unit, int view_id, int field_id); 55 STATIC cmd_result_t _cmd_flow_db_flow_info_show(int unit, 56 char *flow_name); 57 58 /* 59 * function: cmd_flow_db 60 * purpose: flow db for flexible tables. 61 * parameters: unit - unit 62 * a - args, each of the files to be displayed. 63 * returns: CMD_OK/CMD_FAIL/CMD_USAGE 64 */ 65 cmd_result_t 66 cmd_flow_db(int unit, args_t *a) 67 { 68 char *c; 69 int flow_handle = -1; 70 int func_id = -1; 71 int option_id = -1; 72 int view_id = -1; 73 int field_id = -1; 74 int rv = 0; 75 76 if (!soc_feature(unit, soc_feature_cancun)) { 77 return (CMD_NFND); 78 } 79 80 81 if (!soc_feature(unit,soc_feature_flex_flow)) { 82 return (CMD_NFND); 83 } 84 85 c = ARG_GET(a); 86 if(!c) { 87 return (CMD_USAGE); 88 } else if(!sal_strcasecmp(c, "help")) { 89 return (CMD_USAGE); 90 } 91 92 if (!sal_strcmp(c, "flow_info")) { 93 c = ARG_GET(a); 94 if (c) { 95 if (sal_strcmp(c, "show")) { 96 return (CMD_FAIL); 97 } 98 c = ARG_GET(a); 99 if (!c) { 100 return (CMD_FAIL); 101 } 102 rv = (int) _cmd_flow_db_flow_info_show(unit, c); 103 }else 104 return (CMD_FAIL); 105 } else if (!sal_strcmp(c, "flow")) { 106 c = ARG_GET(a); 107 if (c) { 108 if (sal_strcmp(c, "show")) { 109 return (CMD_FAIL); 110 } 111 rv = (int) _cmd_flow_db_flow_tbl(unit); 112 } else 113 return (CMD_FAIL); 114 } else if (!sal_strcmp(c, "flow_option")) { 115 c = ARG_GET(a); 116 if (c) { 117 if (sal_strcmp(c, "show")) { 118 return (CMD_FAIL); 119 } 120 rv = (int) _cmd_flow_db_flow_op_tbl(unit); 121 } else 122 return (CMD_FAIL); 123 } else if (!sal_strcmp(c, "ffo")) { 124 c = ARG_GET(a); 125 if (c) { 126 if (!sal_strcmp(c, "show")) { 127 flow_handle = func_id = option_id = -1; 128 } else if (!sal_strcmp(c, "entry")) { 129 flow_handle = sal_ctoi(ARG_GET(a), 0); 130 func_id = sal_ctoi(ARG_GET(a), 0); 131 option_id = sal_ctoi(ARG_GET(a), 0); 132 } else { 133 return (CMD_FAIL); 134 } 135 rv = (int) _cmd_flow_db_ffo_tpl_tbl(unit, 136 flow_handle, func_id, option_id); 137 } else 138 return (CMD_FAIL); 139 } else if (!sal_strcmp(c, "flow_logical_field")) { 140 c = ARG_GET(a); 141 if (c) { 142 if (sal_strcmp(c, "show")) { 143 return (CMD_FAIL); 144 } 145 rv = (int) _cmd_flow_db_flow_lg_tbl(unit); 146 } else 147 return (CMD_FAIL); 148 } else if (!sal_strcmp(c, "view")) { 149 c = ARG_GET(a); 150 if (c) { 151 if (!sal_strcmp(c, "show")) { 152 view_id = -1; 153 field_id = -1; 154 } else if (!sal_strcmp(c, "entry")) { 155 view_id = sal_ctoi(ARG_GET(a), 0); 156 field_id = -1; 157 } else if (!sal_strcmp(c, "field")) { 158 c = ARG_GET(a); 159 if (!sal_strcmp(c, "entry")) { 160 view_id = sal_ctoi(ARG_GET(a), 0); 161 field_id = sal_ctoi(ARG_GET(a), 0); 162 } else { 163 return (CMD_FAIL); 164 } 165 } else { 166 return (CMD_FAIL); 167 } 168 rv = (int) _cmd_flow_db_view_tbl(unit, view_id, field_id); 169 } else 170 return (CMD_FAIL); 171 } else { 172 rv = SOC_E_NOT_FOUND; 173 } 174 175 if (rv != 0) { 176 return (CMD_FAIL); 177 } 178 179 return (CMD_OK); 180 } 181 182 STATIC cmd_result_t 183 _cmd_flow_db_flow_tbl(int unit) 184 { 185 soc_cancun_t *cc = NULL; 186 soc_flow_db_t *flow_db = NULL; 187 soc_flow_db_tbl_map_t *tbl_map = NULL; 188 soc_flow_db_legacy_flow_rec_t *fmap = NULL; 189 soc_flow_db_legacy_flow_rec_t *legacy_entry = NULL; 190 soc_flow_db_flow_rec_t *entry = NULL; 191 int i = 0; 192 int offset = -1; 193 uint32 *p = NULL; 194 uint32 *hash_entry = NULL; 195 uint32 entry_num = 0; 196 uint32 j = 0; 197 uint32 num_hash_entries = 0; 198 uint32 fmap_entries = 0; 199 char *str_tbl; 200 201 str_tbl = SOC_FLOW_DB_STR_TBL(unit); 202 203 if ((soc_cancun_info_get(unit, &cc)) != SOC_E_NONE) 204 { 205 return(CMD_FAIL); 206 } 207 208 flow_db = cc->flow_db; 209 210 if (flow_db == NULL) { 211 return(CMD_FAIL) ; 212 } 213 214 tbl_map = SOC_FLOW_DB_FLOW_TBL_MAP(unit); 215 216 if (tbl_map == NULL) { 217 return(CMD_FAIL); 218 } 219 220 if (soc_flow_db_legacy_flow_map_get(unit, &fmap, &fmap_entries) != SOC_E_NONE) { 221 return(CMD_FAIL); 222 } 223 224 num_hash_entries = tbl_map->pe; 225 hash_entry = &tbl_map->tbl_entry; 226 cli_out("\n FLOW TABLE\n"); 227 cli_out("=========================================="\ 228 "======================================\n"); 229 cli_out("%-48s %-10s \n", "flow_name", "flow_handle"); 230 cli_out("========================================"\ 231 "========================================\n"); 232 233 for (i = 0, legacy_entry = fmap; 234 i < fmap_entries; 235 i++, legacy_entry++) { 236 cli_out("%-48s %-10d \n", 237 legacy_entry->name, 238 legacy_entry->flow_handle); 239 240 } 241 242 for (i = 0; i < num_hash_entries; i++) { 243 offset = *(hash_entry + i); 244 if (offset == 0) { 245 continue; 246 } 247 248 p = hash_entry + offset; 249 entry_num = *p++; 250 entry = (soc_flow_db_flow_rec_t *) p; 251 if (entry_num !=0) { 252 for (j = 0; j < entry_num; j++, entry++) { 253 cli_out("%-48s %-10d \n", 254 str_tbl + entry->name_offset, 255 entry->flow_handle); 256 } 257 } 258 259 } 260 return(CMD_OK); 261 } 262 263 STATIC cmd_result_t 264 _cmd_flow_db_flow_op_tbl(int unit) 265 { 266 267 soc_cancun_t *cc = NULL; 268 soc_flow_db_t *flow_db = NULL; 269 soc_flow_db_tbl_map_t *tbl_map = NULL; 270 soc_flow_db_flow_option_rec_t *entry = NULL; 271 int i = 0; 272 int offset = -1; 273 uint32 *p = NULL; 274 uint32 *hash_entry = NULL; 275 uint32 entry_num = 0; 276 uint32 j = 0; 277 uint32 num_hash_entries = 0; 278 char *str_tbl; 279 280 str_tbl = SOC_FLOW_DB_STR_TBL(unit); 281 282 if ((soc_cancun_info_get(unit, &cc)) != SOC_E_NONE) 283 { 284 return(CMD_FAIL); 285 } 286 287 flow_db = cc->flow_db; 288 289 if (flow_db == NULL) { 290 return(CMD_FAIL) ; 291 } 292 293 tbl_map = SOC_FLOW_DB_FLOW_OP_TBL_MAP(unit); 294 295 if (tbl_map == NULL) { 296 return(CMD_FAIL); 297 } 298 299 num_hash_entries = tbl_map->pe; 300 hash_entry = &tbl_map->tbl_entry; 301 cli_out("\n FLOW OPTION TABLE \n"); 302 cli_out("========================================="\ 303 "===================================================\n"); 304 cli_out("%-13s %-64s %-10s \n", "FLOW_HANDLE", "OPTION_NAME", "OPTION_ID"); 305 cli_out("========================================="\ 306 "===================================================\n"); 307 for (i = 0; i < num_hash_entries; i++) { 308 offset = *(hash_entry + i); 309 if (offset == 0) { 310 continue; 311 } 312 313 p = hash_entry + offset; 314 entry_num = *p++; 315 entry = (soc_flow_db_flow_option_rec_t *) p; 316 if (entry_num !=0) { 317 for (j = 0; j < entry_num; j++, entry++) { 318 cli_out("%-13d %-64s %-10d \n", 319 entry->flow_handle, 320 str_tbl + entry->name_offset, 321 entry->option_id); 322 } 323 } 324 325 } 326 return(CMD_OK); 327 } 328 329 STATIC cmd_result_t _cmd_flow_db_ffo_tpl_tbl(int unit, 330 int flow_handle, 331 int func_id, 332 int option_id) 333 { 334 335 soc_cancun_t *cc = NULL; 336 soc_flow_db_t *flow_db = NULL; 337 soc_flow_db_tbl_map_t *tbl_map = NULL; 338 soc_flow_db_ffo_tuple_rec_t *entry = NULL; 339 int i = 0; 340 int offset = -1; 341 uint32 *p = NULL; 342 uint32 *hash_entry = NULL; 343 uint32 entry_num = 0; 344 uint32 j = 0; 345 uint32 num_hash_entries = 0; 346 uint32 view_id = 0; 347 int rv = -1; 348 349 350 if ((func_id != -1) && (flow_handle != -1) && 351 (option_id != -1)) { 352 rv = soc_flow_db_ffo_to_mem_view_id_get(unit, 353 flow_handle, 354 option_id, 355 func_id, 356 &view_id); 357 if (SOC_SUCCESS(rv)) { 358 cli_out("%-s : %d\n", "FLOW_HANDLE", flow_handle); 359 cli_out("%-s : %d\n", "FUNCTION_ID", func_id); 360 cli_out("%-s : %d\n", "OPTION_ID", option_id); 361 cli_out("%-s : %d\n", "VIEW_ID", view_id); 362 cli_out("\n"); 363 } 364 } else { 365 if ((soc_cancun_info_get(unit, &cc)) != SOC_E_NONE) 366 { 367 return(CMD_FAIL); 368 } 369 370 flow_db = cc->flow_db; 371 372 if (flow_db == NULL) { 373 return(CMD_FAIL) ; 374 } 375 376 tbl_map = SOC_FLOW_DB_FFO_TPL_TBL_MAP(unit); 377 378 if (tbl_map == NULL) { 379 return(CMD_FAIL); 380 } 381 382 num_hash_entries = tbl_map->pe; 383 hash_entry = &tbl_map->tbl_entry; 384 cli_out("\n FLOW FUNCTION OPTION TUPLE TABLE \n"); 385 cli_out("========================================="\ 386 "==================================\n"); 387 cli_out("%-13s %-13s %-10s %-10s\n", 388 "FLOW_HANDLE", "FUNCTION_ID", "OPTION_ID", "VIEW_ID"); 389 cli_out("========================================="\ 390 "==================================\n"); 391 392 for (i = 0; i < num_hash_entries; i++) { 393 offset = *(hash_entry + i); 394 if (offset == 0) { 395 continue; 396 } 397 398 p = hash_entry + offset; 399 entry_num = *p++; 400 entry = (soc_flow_db_ffo_tuple_rec_t *) p; 401 if (entry_num !=0) { 402 for (j = 0; j < entry_num; j++, entry++) { 403 cli_out("%-13d %-13d %-10d %-10d \n", 404 entry->flow_handle, 405 entry->function_id, 406 entry->option_id, 407 entry->view_id); 408 } 409 } 410 411 } 412 } 413 return(CMD_OK); 414 } 415 416 STATIC cmd_result_t 417 _cmd_flow_db_flow_lg_tbl(int unit) 418 { 419 420 soc_cancun_t *cc = NULL; 421 soc_flow_db_t *flow_db = NULL; 422 soc_flow_db_tbl_map_t *tbl_map = NULL; 423 soc_flow_db_flow_lg_field_rec_t *entry = NULL; 424 int i = 0; 425 int offset = -1; 426 uint32 *p = NULL; 427 uint32 *hash_entry = NULL; 428 uint32 entry_num = 0; 429 uint32 j = 0; 430 uint32 num_hash_entries = 0; 431 char *str_tbl; 432 433 str_tbl = SOC_FLOW_DB_STR_TBL(unit); 434 435 if ((soc_cancun_info_get(unit, &cc)) != SOC_E_NONE) 436 { 437 return(CMD_FAIL); 438 } 439 440 flow_db = cc->flow_db; 441 442 if (flow_db == NULL) { 443 return(CMD_FAIL) ; 444 } 445 446 tbl_map = SOC_FLOW_DB_FLOW_LG_FL_TBL_MAP(unit); 447 448 if (tbl_map == NULL) { 449 return(CMD_FAIL); 450 } 451 452 num_hash_entries = tbl_map->pe; 453 hash_entry = &tbl_map->tbl_entry; 454 cli_out("\n FLOW LOGICAL FIELDS TABLE \n"); 455 cli_out("==================================="\ 456 "=============================================\n"); 457 cli_out("%-13s %-48s %-10s \n", "FLOW_HANDLE", "LOGICAL FIELD", "FIELD_ID"); 458 cli_out("==================================="\ 459 "=============================================\n"); 460 461 for (i = 0; i < num_hash_entries; i++) { 462 offset = *(hash_entry + i); 463 if (offset == 0) { 464 continue; 465 } 466 467 p = hash_entry + offset; 468 entry_num = *p++; 469 entry = (soc_flow_db_flow_lg_field_rec_t *) p; 470 if (entry_num !=0) { 471 for (j = 0; j < entry_num; j++, entry++) { 472 cli_out("%-13d %-48s %-10d \n", 473 entry->flow_handle, 474 str_tbl + entry->name_offset, 475 entry->field_id); 476 } 477 } 478 479 } 480 return(CMD_OK); 481 } 482 483 STATIC cmd_result_t 484 _cmd_flow_db_view_tbl(int unit, int view_id, int field_id) 485 { 486 soc_cancun_t *cc = NULL; 487 soc_flow_db_t *flow_db = NULL; 488 soc_flow_db_tbl_map_t *tbl_map = NULL; 489 soc_flow_db_view_rec_t *entry = NULL; 490 soc_flow_db_field_rec_t *f_entry = NULL; 491 int i = 0; 492 int offset = -1; 493 uint32 *p = NULL; 494 uint32 *pf = NULL; 495 uint32 *hash_entry = NULL; 496 uint32 entry_num = 0; 497 uint32 j = 0; 498 uint32 num_hash_entries = 0; 499 soc_flow_db_mem_view_info_t view_info; 500 soc_flow_db_mem_view_field_info_t field_info; 501 int rv = -1; 502 uint32 k = 0; 503 soc_flow_db_ffo_t ffo[SOC_FLOW_DB_MAX_VIEW_FFO_TPL]; 504 uint32 num_ffo = 0; 505 char *field_name = NULL; 506 char *mem_name = NULL; 507 uint32 size = SOC_FLOW_DB_MAX_VIEW_FIELDS; 508 uint32 fields[SOC_FLOW_DB_MAX_VIEW_FIELDS]; 509 uint32 field_count = 0; 510 uint32 field_type[] = {SOC_FLOW_DB_FIELD_TYPE_KEY, 511 SOC_FLOW_DB_FIELD_TYPE_CONTROL, 512 SOC_FLOW_DB_FIELD_TYPE_POLICY_DATA, 513 SOC_FLOW_DB_FIELD_TYPE_POLICY_DATA_ENCODING, 514 SOC_FLOW_DB_FIELD_TYPE_LOGICAL_KEY, 515 SOC_FLOW_DB_FIELD_TYPE_LOGICAL_POLICY_DATA}; 516 char *_t_names[] = BCM_FEILD_TYPE_NAME_INITIALIZER; 517 char *t_name = NULL; 518 char *str_tbl; 519 520 str_tbl = SOC_FLOW_DB_STR_TBL(unit); 521 522 if ((view_id != -1) || 523 (field_id != -1)) { 524 525 if (field_id == -1) { 526 /* only view infromation */ 527 cli_out("\n============================VIEW INFORAMTION===="\ 528 "=============================\n"); 529 rv = soc_flow_db_mem_view_info_get(unit, view_id, 530 &view_info); 531 if (SOC_FAILURE(rv)) { 532 return (CMD_FAIL); 533 } 534 rv = soc_flow_db_mem_view_mem_name_get(unit, view_id, 535 &mem_name); 536 if (SOC_FAILURE(rv)) { 537 return (CMD_FAIL); 538 } 539 540 cli_out("%-10s : %d\n", "VIEW_ID", view_info.mem_view_id); 541 cli_out("%-10s : %s\n", "PHY MEM", mem_name); 542 cli_out("%-10s : %d\n", "WIDTH", view_info.width); 543 544 switch(view_info.type) { 545 case SOC_FLOW_DB_VIEW_TYPE_DIRECT: 546 cli_out("%-10s : %s\n", "TYPE", "SOC_FLOW_DB_VIEW_TYPE_DIRECT"); 547 break; 548 case SOC_FLOW_DB_VIEW_TYPE_HASH: 549 cli_out("%-10s : %s\n", "TYPE", "SOC_FLOW_DB_VIEW_TYPE_HASH"); 550 break; 551 case SOC_FLOW_DB_VIEW_TYPE_TCAM: 552 cli_out("%-10s : %s\n", "TYPE", "SOC_FLOW_DB_VIEW_TYPE_TCAM"); 553 break; 554 default: 555 cli_out("%-10s : %s\n", "TYPE", "SOC_FLOW_DB_VIEW_TYPE_INVALID"); 556 break; 557 } 558 559 cli_out("\n FIELD TABLE\n"); 560 cli_out("======================================================="\ 561 "==================================================\n"); 562 cli_out("%-10s %-48s %-32s\n", "FEILD_ID", 563 "FIELD_NAME", "FIELD_TYPE"); 564 cli_out("======================================================="\ 565 "==================================================\n"); 566 for (i = 0; i < sizeof(field_type)/sizeof(field_type[0]); 567 i++) { 568 569 SOC_IF_ERROR_RETURN(soc_flow_db_mem_view_field_list_get( 570 unit, 571 view_id, 572 field_type[i], 573 size, 574 fields, 575 &field_count)); 576 for (j = 0; j < field_count; j++) { 577 /* field table per view */ 578 rv = soc_flow_db_mem_view_field_info_get(unit, view_id, 579 fields[j], &field_info); 580 if (SOC_FAILURE(rv)) { 581 return (CMD_FAIL); 582 } 583 584 rv = soc_flow_db_mem_view_field_name_get(unit, view_id, 585 field_info.field_id, &field_name); 586 587 if (SOC_FAILURE(rv)) { 588 return (CMD_FAIL); 589 } 590 if ((field_info.type < SOC_FLOW_DB_FIELD_TYPE_INVALID) || 591 (field_info.type > SOC_FLOW_DB_FIELD_TYPE_MAX)) { 592 return (CMD_FAIL); 593 } 594 t_name = _t_names[field_info.type]; 595 cli_out("%-10d %-48s %-32s\n", field_info.field_id, field_name, t_name); 596 } /* end of field list per type */ 597 } /* end of field types - table */ 598 /* ffo table per view */ 599 cli_out("\n"); 600 601 rv = soc_flow_db_mem_view_to_ffo_get(unit, 602 view_id, 603 SOC_FLOW_DB_MAX_VIEW_FFO_TPL, 604 ffo, 605 &num_ffo); 606 if (SOC_FAILURE(rv)) { 607 return (CMD_FAIL); 608 } 609 cli_out("\n FFO TUPLE INFORMATION\n"); 610 cli_out("=================================="\ 611 "======================\n"); 612 cli_out("%-13s %-13s %-13s\n", 613 "FLOW_HANDLE ", "FUNCTION_ID", "OPTION_ID"); 614 cli_out("=======================\n"\ 615 "=================================\n"); 616 for (i = 0; i < num_ffo; i++) { 617 cli_out("%-13d %-13d %-13d\n", 618 ffo[i].flow_handle, 619 ffo[i].function_id, 620 ffo[i].option_id); 621 622 } 623 cli_out("\n"); 624 625 } else { 626 /* field information */ 627 rv = soc_flow_db_mem_view_field_info_get(unit, view_id, 628 field_id, &field_info); 629 if (SOC_FAILURE(rv)) { 630 return (CMD_FAIL); 631 } 632 rv = soc_flow_db_mem_view_field_name_get(unit, view_id, 633 field_info.field_id, &field_name); 634 635 if (SOC_FAILURE(rv)) { 636 return (CMD_FAIL); 637 } 638 639 cli_out("%-10s : %d\n", "FIELD_ID", field_info.field_id); 640 cli_out("%-10s : %s\n", "NAME", field_name); 641 switch(field_info.type) { 642 case SOC_FLOW_DB_FIELD_TYPE_CONTROL: 643 cli_out("%-10s : %s\n", 644 "TYPE", "SOC_FLOW_DB_FIELD_TYPE_CONTROL"); 645 break; 646 case SOC_FLOW_DB_FIELD_TYPE_KEY: 647 cli_out("%-10s : %s\n", 648 "TYPE", "SOC_FLOW_DB_FIELD_TYPE_KEY"); 649 break; 650 case SOC_FLOW_DB_FIELD_TYPE_VALID: 651 cli_out("%-10s : %s\n", 652 "TYPE", "SOC_FLOW_DB_FIELD_TYPE_VALID"); 653 break; 654 case SOC_FLOW_DB_FIELD_TYPE_POLICY_DATA: 655 cli_out("%-10s : %s\n", 656 "TYPE", "SOC_FLOW_DB_FIELD_TYPE_POLICY_DATA"); 657 break; 658 case SOC_FLOW_DB_FIELD_TYPE_POLICY_DATA_ENCODING: 659 cli_out("%-10s : %s\n", 660 "TYPE", "SOC_FLOW_DB_FIELD_TYPE_POLICY_DATA_ENCODING"); 661 break; 662 case SOC_FLOW_DB_FIELD_TYPE_LOGICAL_KEY: 663 cli_out("%-10s : %s\n", 664 "TYPE", "SOC_FLOW_DB_FIELD_TYPE_LOGICAL_KEY"); 665 break; 666 case SOC_FLOW_DB_FIELD_TYPE_LOGICAL_POLICY_DATA: 667 cli_out("%-10s : %s\n", 668 "TYPE", "SOC_FLOW_DB_FIELD_TYPE_LOGICAL_POLICY_DATA"); 669 break; 670 default: 671 cli_out("%-10s : %s\n", 672 "TYPE", "SOC_FLOW_DB_FIELD_TYPE_INVALID"); 673 break; 674 } 675 676 cli_out("%-10s : %d\n", "OFFSET", field_info.offset); 677 cli_out("%-10s : %d\n", "width", field_info.width); 678 cli_out("%-10s : %d\n", "flags", field_info.flags); 679 cli_out("%-10s : %d\n", "value", field_info.value); 680 cli_out("\n"); 681 } 682 683 } else { 684 if ((soc_cancun_info_get(unit, &cc)) != SOC_E_NONE) 685 { 686 return(CMD_FAIL); 687 } 688 flow_db = cc->flow_db; 689 690 if (flow_db == NULL) { 691 return(CMD_FAIL) ; 692 } 693 694 tbl_map = SOC_FLOW_DB_VIEW_TBL_MAP(unit); 695 696 if (tbl_map == NULL) { 697 return(CMD_FAIL); 698 } 699 700 num_hash_entries = tbl_map->pe; 701 hash_entry = &tbl_map->tbl_entry; 702 cli_out("\n VIEW TABLE \n"); 703 cli_out("========================================"\ 704 "=====================================\n"); 705 cli_out("%-10s %-10s \n", "VIEW ID ", "PHY_MEM"); 706 cli_out("========================================"\ 707 "=====================================\n"); 708 709 for (i = 0; i < num_hash_entries; i++) { 710 offset = *(hash_entry + i); 711 if (offset == 0) { 712 continue; 713 } 714 715 p = hash_entry + offset; 716 entry_num = *p++; 717 entry = (soc_flow_db_view_rec_t *) p; 718 if (entry_num !=0) { 719 for (j = 0; j < entry_num; j++, entry++) { 720 cli_out("%-10d %-10d \n", 721 entry->view_id, 722 entry->mem); 723 cli_out("%-12s: %d\n", "NFields",entry->nFields); 724 pf = &entry->field_entry; 725 f_entry = (soc_flow_db_field_rec_t *)pf; 726 for (k = 0; k < entry->nFields; k++, f_entry++) { 727 cli_out("%-12s : %d\n", "Field_id",f_entry->field_id); 728 cli_out("%-12s : %s\n","Field_name", 729 str_tbl + f_entry->name_offset); 730 } 731 } 732 } 733 734 } 735 } 736 return(CMD_OK); 737 } 738 739 STATIC cmd_result_t 740 _cmd_flow_db_flow_info_show(int unit, char *flow_name) 741 { 742 uint32 handle; 743 soc_cancun_t *cc = NULL; 744 soc_flow_db_t *flow_db = NULL; 745 soc_flow_db_tbl_map_t *ffo_tbl_map = NULL; 746 soc_flow_db_ffo_tuple_rec_t *ffo_entry = NULL; 747 int offset1 = -1; 748 uint32 *ffo = NULL; 749 uint32 *ffo_hash_entry = NULL; 750 uint32 ffo_entry_num = 0; 751 uint32 ffo_num_hash_entries = 0; 752 char *_func_names[] = BCM_FUNCTION_NAME_INITIALIZER; 753 char *fname = NULL; 754 int rv = -1; 755 int k, l, m; 756 uint32 func_type = SOC_FLOW_DB_FUNC_ID_START; 757 char *option_name; 758 char *mem_name; 759 760 if ((soc_cancun_info_get(unit, &cc)) != SOC_E_NONE) 761 { 762 return(CMD_FAIL); 763 } 764 765 rv = soc_flow_db_flow_handle_get(unit, flow_name, &handle); 766 if (rv != SOC_E_NONE) { 767 return CMD_FAIL; 768 } 769 770 flow_db = cc->flow_db; 771 if (flow_db == NULL) { 772 return(CMD_FAIL) ; 773 } 774 775 776 cli_out ("\n FLOW : %s \n", flow_name); 777 cli_out("================================================================"\ 778 "==================================================="\ 779 "===================================\n"); 780 cli_out("%-60s %-20s %-7s %-s\n", 781 "OPTION_NAME", "FUNCTION", "VIEW_ID", "MEMORY"); 782 cli_out("================================================================"\ 783 "===================================================="\ 784 "===================================\n"); 785 786 787 /* flow match */ 788 789 for (k = SOC_FLOW_DB_FUNC_ID_START+1; 790 k < SOC_FLOW_DB_FUNC_ID_END; 791 k++) { 792 func_type = k; 793 fname = _func_names[k]; 794 ffo_tbl_map = SOC_FLOW_DB_FFO_TPL_TBL_MAP(unit); 795 if (ffo_tbl_map == NULL) { 796 return(CMD_FAIL); 797 } 798 ffo_num_hash_entries = ffo_tbl_map->pe; 799 ffo_hash_entry = &ffo_tbl_map->tbl_entry; 800 for (l = 0; l < ffo_num_hash_entries; l++) { 801 offset1 = *(ffo_hash_entry + l); 802 if (offset1 == 0) { 803 continue; 804 } 805 806 ffo = ffo_hash_entry + offset1; 807 ffo_entry_num = *ffo++; 808 ffo_entry = (soc_flow_db_ffo_tuple_rec_t *) ffo; 809 for (m = 0; (ffo_entry_num != 0) && 810 (m < ffo_entry_num); 811 m++, ffo_entry++) { 812 if ((ffo_entry->flow_handle == 813 handle) && 814 (ffo_entry->function_id == func_type)) { 815 /*Get the option name from option id */ 816 rv = soc_flow_db_mem_view_option_name_get(unit, 817 ffo_entry->flow_handle, 818 ffo_entry->option_id, 819 &option_name); 820 if (rv != SOC_E_NONE) { 821 return (CMD_FAIL); 822 } 823 rv = soc_flow_db_mem_view_mem_name_get(unit, 824 ffo_entry->view_id, 825 &mem_name); 826 if (rv != SOC_E_NONE) { 827 return (CMD_FAIL); 828 } 829 830 fname = _func_names[ffo_entry->function_id]; 831 cli_out("%-60s %-20s %-7d %-s\n",option_name, 832 fname, ffo_entry->view_id, 833 mem_name); 834 835 } 836 } 837 838 } /* end of ffo Table */ 839 840 } /* end of function type */ 841 842 return(CMD_OK); 843 } 844 #endif /* NO_SAL_APPL */