1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2020 Intel Corporation 3 */ 4 #ifndef __INCLUDE_RTE_SWX_CTL_H__ 5 #define __INCLUDE_RTE_SWX_CTL_H__ 6 7 #ifdef __cplusplus 8 extern "C" { 9 #endif 10 11 /** 12 * @file 13 * RTE SWX Pipeline Control 14 */ 15 16 #include <stddef.h> 17 #include <stdint.h> 18 #include <stdio.h> 19 20 #include <rte_compat.h> 21 #include <rte_meter.h> 22 23 #include "rte_swx_port.h" 24 #include "rte_swx_table.h" 25 #include "rte_swx_table_selector.h" 26 27 struct rte_swx_pipeline; 28 29 /** Name size. */ 30 #ifndef RTE_SWX_CTL_NAME_SIZE 31 #define RTE_SWX_CTL_NAME_SIZE 64 32 #endif 33 34 /* 35 * Pipeline Query API. 36 */ 37 38 /** Pipeline info. */ 39 struct rte_swx_ctl_pipeline_info { 40 /** Number of input ports. */ 41 uint32_t n_ports_in; 42 43 /** Number of input ports. */ 44 uint32_t n_ports_out; 45 46 /** Number of actions. */ 47 uint32_t n_actions; 48 49 /** Number of tables. */ 50 uint32_t n_tables; 51 52 /** Number of selector tables. */ 53 uint32_t n_selectors; 54 55 /** Number of register arrays. */ 56 uint32_t n_regarrays; 57 58 /** Number of meter arrays. */ 59 uint32_t n_metarrays; 60 }; 61 62 /** 63 * Pipeline info get 64 * 65 * @param[in] p 66 * Pipeline handle. 67 * @param[out] pipeline 68 * Pipeline info. 69 * @return 70 * 0 on success or the following error codes otherwise: 71 * -EINVAL: Invalid argument. 72 */ 73 __rte_experimental 74 int 75 rte_swx_ctl_pipeline_info_get(struct rte_swx_pipeline *p, 76 struct rte_swx_ctl_pipeline_info *pipeline); 77 78 /** 79 * Pipeline NUMA node get 80 * 81 * @param[in] p 82 * Pipeline handle. 83 * @param[out] numa_node 84 * Pipeline NUMA node. 85 * @return 86 * 0 on success or the following error codes otherwise: 87 * -EINVAL: Invalid argument. 88 */ 89 __rte_experimental 90 int 91 rte_swx_ctl_pipeline_numa_node_get(struct rte_swx_pipeline *p, 92 int *numa_node); 93 94 /* 95 * Ports Query API. 96 */ 97 98 /** 99 * Input port statistics counters read 100 * 101 * @param[in] p 102 * Pipeline handle. 103 * @param[in] port_id 104 * Port ID (0 .. *n_ports_in* - 1). 105 * @param[out] stats 106 * Input port stats. 107 * @return 108 * 0 on success or the following error codes otherwise: 109 * -EINVAL: Invalid argument. 110 */ 111 __rte_experimental 112 int 113 rte_swx_ctl_pipeline_port_in_stats_read(struct rte_swx_pipeline *p, 114 uint32_t port_id, 115 struct rte_swx_port_in_stats *stats); 116 117 /** 118 * Output port statistics counters read 119 * 120 * @param[in] p 121 * Pipeline handle. 122 * @param[in] port_id 123 * Port ID (0 .. *n_ports_out* - 1). 124 * @param[out] stats 125 * Output port stats. 126 * @return 127 * 0 on success or the following error codes otherwise: 128 * -EINVAL: Invalid argument. 129 */ 130 __rte_experimental 131 int 132 rte_swx_ctl_pipeline_port_out_stats_read(struct rte_swx_pipeline *p, 133 uint32_t port_id, 134 struct rte_swx_port_out_stats *stats); 135 136 /* 137 * Action Query API. 138 */ 139 140 /** Action info. */ 141 struct rte_swx_ctl_action_info { 142 /** Action name. */ 143 char name[RTE_SWX_CTL_NAME_SIZE]; 144 145 /** Number of action arguments. */ 146 uint32_t n_args; 147 }; 148 149 /** 150 * Action info get 151 * 152 * @param[in] p 153 * Pipeline handle. 154 * @param[in] action_id 155 * Action ID (0 .. *n_actions* - 1). 156 * @param[out] action 157 * Action info. 158 * @return 159 * 0 on success or the following error codes otherwise: 160 * -EINVAL: Invalid argument. 161 */ 162 __rte_experimental 163 int 164 rte_swx_ctl_action_info_get(struct rte_swx_pipeline *p, 165 uint32_t action_id, 166 struct rte_swx_ctl_action_info *action); 167 168 /** Action argument info. */ 169 struct rte_swx_ctl_action_arg_info { 170 /** Action argument name. */ 171 char name[RTE_SWX_CTL_NAME_SIZE]; 172 173 /** Action argument size (in bits). */ 174 uint32_t n_bits; 175 176 /** Non-zero (true) when this action argument must be stored in the 177 * table in network byte order (NBO), zero when it must be stored in 178 * host byte order (HBO). 179 */ 180 int is_network_byte_order; 181 }; 182 183 /** 184 * Action argument info get 185 * 186 * @param[in] p 187 * Pipeline handle. 188 * @param[in] action_id 189 * Action ID (0 .. *n_actions* - 1). 190 * @param[in] action_arg_id 191 * Action ID (0 .. *n_args* - 1). 192 * @param[out] action_arg 193 * Action argument info. 194 * @return 195 * 0 on success or the following error codes otherwise: 196 * -EINVAL: Invalid argument. 197 */ 198 __rte_experimental 199 int 200 rte_swx_ctl_action_arg_info_get(struct rte_swx_pipeline *p, 201 uint32_t action_id, 202 uint32_t action_arg_id, 203 struct rte_swx_ctl_action_arg_info *action_arg); 204 205 /* 206 * Table Query API. 207 */ 208 209 /** Table info. */ 210 struct rte_swx_ctl_table_info { 211 /** Table name. */ 212 char name[RTE_SWX_CTL_NAME_SIZE]; 213 214 /** Table creation arguments. */ 215 char args[RTE_SWX_CTL_NAME_SIZE]; 216 217 /** Number of match fields. */ 218 uint32_t n_match_fields; 219 220 /** Number of actions. */ 221 uint32_t n_actions; 222 223 /** Non-zero (true) when the default action is constant, therefore it 224 * cannot be changed; zero (false) when the default action not constant, 225 * therefore it can be changed. 226 */ 227 int default_action_is_const; 228 229 /** Table size parameter. */ 230 uint32_t size; 231 }; 232 233 /** 234 * Table info get 235 * 236 * @param[in] p 237 * Pipeline handle. 238 * @param[in] table_id 239 * Table ID (0 .. *n_tables* - 1). 240 * @param[out] table 241 * Table info. 242 * @return 243 * 0 on success or the following error codes otherwise: 244 * -EINVAL: Invalid argument. 245 */ 246 __rte_experimental 247 int 248 rte_swx_ctl_table_info_get(struct rte_swx_pipeline *p, 249 uint32_t table_id, 250 struct rte_swx_ctl_table_info *table); 251 252 /** Table match field info. 253 * 254 * If (n_bits, offset) are known for all the match fields of the table, then the 255 * table (key_offset, key_size, key_mask0) can be computed. 256 */ 257 struct rte_swx_ctl_table_match_field_info { 258 /** Match type of the current match field. */ 259 enum rte_swx_table_match_type match_type; 260 261 /** Non-zero (true) when the current match field is part of a registered 262 * header, zero (false) when it is part of the registered meta-data. 263 */ 264 int is_header; 265 266 /** Match field size (in bits). */ 267 uint32_t n_bits; 268 269 /** Match field offset within its parent struct (one of the headers or 270 * the meta-data). 271 */ 272 uint32_t offset; 273 }; 274 275 /** 276 * Table match field info get 277 * 278 * @param[in] p 279 * Pipeline handle. 280 * @param[in] table_id 281 * Table ID (0 .. *n_tables*). 282 * @param[in] match_field_id 283 * Match field ID (0 .. *n_match_fields* - 1). 284 * @param[out] match_field 285 * Table match field info. 286 * @return 287 * 0 on success or the following error codes otherwise: 288 * -EINVAL: Invalid argument. 289 */ 290 __rte_experimental 291 int 292 rte_swx_ctl_table_match_field_info_get(struct rte_swx_pipeline *p, 293 uint32_t table_id, 294 uint32_t match_field_id, 295 struct rte_swx_ctl_table_match_field_info *match_field); 296 297 /** Table action info. */ 298 struct rte_swx_ctl_table_action_info { 299 /** Action ID. */ 300 uint32_t action_id; 301 }; 302 303 /** 304 * Table action info get 305 * 306 * @param[in] p 307 * Pipeline handle. 308 * @param[in] table_id 309 * Table ID (0 .. *n_tables*). 310 * @param[in] table_action_id 311 * Action index within the set of table actions (0 .. table n_actions - 1). 312 * Not to be confused with the action ID, which works at the pipeline level 313 * (0 .. pipeline n_actions - 1), which is precisely what this function 314 * returns as part of *table_action*. 315 * @param[out] table_action 316 * Table action info. 317 * @return 318 * 0 on success or the following error codes otherwise: 319 * -EINVAL: Invalid argument. 320 */ 321 __rte_experimental 322 int 323 rte_swx_ctl_table_action_info_get(struct rte_swx_pipeline *p, 324 uint32_t table_id, 325 uint32_t table_action_id, 326 struct rte_swx_ctl_table_action_info *table_action); 327 328 /** 329 * Table operations get 330 * 331 * @param[in] p 332 * Pipeline handle. 333 * @param[in] table_id 334 * Table ID (0 .. *n_tables*). 335 * @param[out] table_ops 336 * Table operations. Only valid when function returns success and *is_stub* is 337 * zero (false). 338 * @param[out] is_stub 339 * A stub table is a table with no match fields. No "regular" table entries 340 * (i.e. entries other than the default entry) can be added to such a table, 341 * therefore the lookup operation always results in lookup miss. Non-zero 342 * (true) when the current table is a stub table, zero (false) otherwise. 343 * @return 344 * 0 on success or the following error codes otherwise: 345 * -EINVAL: Invalid argument. 346 */ 347 __rte_experimental 348 int 349 rte_swx_ctl_table_ops_get(struct rte_swx_pipeline *p, 350 uint32_t table_id, 351 struct rte_swx_table_ops *table_ops, 352 int *is_stub); 353 354 /** Table statistics. */ 355 struct rte_swx_table_stats { 356 /** Number of packets with lookup hit. */ 357 uint64_t n_pkts_hit; 358 359 /** Number of packets with lookup miss. */ 360 uint64_t n_pkts_miss; 361 362 /** Number of packets (with either lookup hit or miss) per pipeline 363 * action. Array of pipeline *n_actions* elements indedex by the 364 * pipeline-level *action_id*, therefore this array has the same size 365 * for all the tables within the same pipeline. 366 */ 367 uint64_t *n_pkts_action; 368 }; 369 370 /** 371 * Table statistics counters read 372 * 373 * @param[in] p 374 * Pipeline handle. 375 * @param[in] table_name 376 * Table name. 377 * @param[out] stats 378 * Table stats. Must point to a pre-allocated structure. The *n_pkts_action* 379 * field also needs to be pre-allocated as array of pipeline *n_actions* 380 * elements. The pipeline actions that are not valid for the current table 381 * have their associated *n_pkts_action* element always set to zero. 382 * @return 383 * 0 on success or the following error codes otherwise: 384 * -EINVAL: Invalid argument. 385 */ 386 __rte_experimental 387 int 388 rte_swx_ctl_pipeline_table_stats_read(struct rte_swx_pipeline *p, 389 const char *table_name, 390 struct rte_swx_table_stats *stats); 391 392 /* 393 * Selector Table Query API. 394 */ 395 396 /** Selector info. */ 397 struct rte_swx_ctl_selector_info { 398 /** Selector table name. */ 399 char name[RTE_SWX_CTL_NAME_SIZE]; 400 401 /** Number of selector fields. */ 402 uint32_t n_selector_fields; 403 404 /** Maximum number of groups. */ 405 uint32_t n_groups_max; 406 407 /** Maximum number of members per group. */ 408 uint32_t n_members_per_group_max; 409 }; 410 411 /** 412 * Selector table info get 413 * 414 * @param[in] p 415 * Pipeline handle. 416 * @param[in] selector_id 417 * Selector table ID (0 .. *n_selectors* - 1). 418 * @param[out] selector 419 * Selector table info. 420 * @return 421 * 0 on success or the following error codes otherwise: 422 * -EINVAL: Invalid argument. 423 */ 424 __rte_experimental 425 int 426 rte_swx_ctl_selector_info_get(struct rte_swx_pipeline *p, 427 uint32_t selector_id, 428 struct rte_swx_ctl_selector_info *selector); 429 430 /** 431 * Selector table "group ID" field info get 432 * 433 * @param[in] p 434 * Pipeline handle. 435 * @param[in] selector_id 436 * Selector table ID (0 .. *n_selectors*). 437 * @param[out] field 438 * Selector table "group ID" field info. 439 * @return 440 * 0 on success or the following error codes otherwise: 441 * -EINVAL: Invalid argument. 442 */ 443 __rte_experimental 444 int 445 rte_swx_ctl_selector_group_id_field_info_get(struct rte_swx_pipeline *p, 446 uint32_t selector_id, 447 struct rte_swx_ctl_table_match_field_info *field); 448 449 /** 450 * Sselector table selector field info get 451 * 452 * @param[in] p 453 * Pipeline handle. 454 * @param[in] selector_id 455 * Selector table ID (0 .. *n_selectors*). 456 * @param[in] selector_field_id 457 * Selector table selector field ID (0 .. *n_selector_fields* - 1). 458 * @param[out] field 459 * Selector table selector field info. 460 * @return 461 * 0 on success or the following error codes otherwise: 462 * -EINVAL: Invalid argument. 463 */ 464 __rte_experimental 465 int 466 rte_swx_ctl_selector_field_info_get(struct rte_swx_pipeline *p, 467 uint32_t selector_id, 468 uint32_t selector_field_id, 469 struct rte_swx_ctl_table_match_field_info *field); 470 471 /** 472 * Selector table "member ID" field info get 473 * 474 * @param[in] p 475 * Pipeline handle. 476 * @param[in] selector_id 477 * Selector table ID (0 .. *n_selectors*). 478 * @param[out] field 479 * Selector table "member ID" field info. 480 * @return 481 * 0 on success or the following error codes otherwise: 482 * -EINVAL: Invalid argument. 483 */ 484 __rte_experimental 485 int 486 rte_swx_ctl_selector_member_id_field_info_get(struct rte_swx_pipeline *p, 487 uint32_t selector_id, 488 struct rte_swx_ctl_table_match_field_info *field); 489 490 /** Selector table statistics. */ 491 struct rte_swx_pipeline_selector_stats { 492 /** Number of packets. */ 493 uint64_t n_pkts; 494 }; 495 496 /** 497 * Selector table statistics counters read 498 * 499 * @param[in] p 500 * Pipeline handle. 501 * @param[in] selector_name 502 * Selector table name. 503 * @param[out] stats 504 * Selector table stats. Must point to a pre-allocated structure. 505 * @return 506 * 0 on success or the following error codes otherwise: 507 * -EINVAL: Invalid argument. 508 */ 509 __rte_experimental 510 int 511 rte_swx_ctl_pipeline_selector_stats_read(struct rte_swx_pipeline *p, 512 const char *selector_name, 513 struct rte_swx_pipeline_selector_stats *stats); 514 515 /* 516 * Table Update API. 517 */ 518 519 /** Table state. */ 520 struct rte_swx_table_state { 521 /** Table object. */ 522 void *obj; 523 524 /** Action ID of the table default action. */ 525 uint64_t default_action_id; 526 527 /** Action data of the table default action. Ignored when the action 528 * data size is zero; otherwise, action data size bytes are meaningful. 529 */ 530 uint8_t *default_action_data; 531 }; 532 533 /** 534 * Pipeline table state get 535 * 536 * @param[in] p 537 * Pipeline handle. 538 * @param[out] table_state 539 * After successful execution, the *table_state* contains the pointer to the 540 * current pipeline table state, which is an array of *n_tables* elements, 541 * with array element i containing the state of the i-th pipeline table. The 542 * pipeline continues to own all the data structures directly or indirectly 543 * referenced by the *table_state* until the subsequent successful invocation 544 * of function *rte_swx_pipeline_table_state_set*. 545 * @return 546 * 0 on success or the following error codes otherwise: 547 * -EINVAL: Invalid argument. 548 */ 549 __rte_experimental 550 int 551 rte_swx_pipeline_table_state_get(struct rte_swx_pipeline *p, 552 struct rte_swx_table_state **table_state); 553 554 /** 555 * Pipeline table state set 556 * 557 * @param[in] p 558 * Pipeline handle. 559 * @param[out] table_state 560 * After successful execution, the pipeline table state is updated to this 561 * *table_state*. The ownership of all the data structures directly or 562 * indirectly referenced by this *table_state* is passed from the caller to 563 * the pipeline. 564 * @return 565 * 0 on success or the following error codes otherwise: 566 * -EINVAL: Invalid argument. 567 */ 568 __rte_experimental 569 int 570 rte_swx_pipeline_table_state_set(struct rte_swx_pipeline *p, 571 struct rte_swx_table_state *table_state); 572 573 /* 574 * High Level Reference Table Update API. 575 */ 576 577 /** Pipeline control opaque data structure. */ 578 struct rte_swx_ctl_pipeline; 579 580 /** 581 * Pipeline control create 582 * 583 * @param[in] p 584 * Pipeline handle. 585 * @return 586 * Pipeline control handle, on success, or NULL, on error. 587 */ 588 __rte_experimental 589 struct rte_swx_ctl_pipeline * 590 rte_swx_ctl_pipeline_create(struct rte_swx_pipeline *p); 591 592 /** 593 * Pipeline table entry add 594 * 595 * Schedule entry for addition to table or update as part of the next commit 596 * operation. 597 * 598 * @param[in] ctl 599 * Pipeline control handle. 600 * @param[in] table_name 601 * Table name. 602 * @param[in] entry 603 * Entry to be added to the table. 604 * @return 605 * 0 on success or the following error codes otherwise: 606 * -EINVAL: Invalid argument. 607 */ 608 __rte_experimental 609 int 610 rte_swx_ctl_pipeline_table_entry_add(struct rte_swx_ctl_pipeline *ctl, 611 const char *table_name, 612 struct rte_swx_table_entry *entry); 613 614 /** 615 * Pipeline table default entry add 616 * 617 * Schedule table default entry update as part of the next commit operation. 618 * 619 * @param[in] ctl 620 * Pipeline control handle. 621 * @param[in] table_name 622 * Table name. 623 * @param[in] entry 624 * The new table default entry. The *key* and *key_mask* entry fields are 625 * ignored. 626 * @return 627 * 0 on success or the following error codes otherwise: 628 * -EINVAL: Invalid argument. 629 */ 630 __rte_experimental 631 int 632 rte_swx_ctl_pipeline_table_default_entry_add(struct rte_swx_ctl_pipeline *ctl, 633 const char *table_name, 634 struct rte_swx_table_entry *entry); 635 636 /** 637 * Pipeline table entry delete 638 * 639 * Schedule entry for deletion from table as part of the next commit operation. 640 * Request is silently discarded if no such entry exists. 641 * 642 * @param[in] ctl 643 * Pipeline control handle. 644 * @param[in] table_name 645 * Table name. 646 * @param[in] entry 647 * Entry to be deleted from the table. The *action_id* and *action_data* entry 648 * fields are ignored. 649 * @return 650 * 0 on success or the following error codes otherwise: 651 * -EINVAL: Invalid argument. 652 */ 653 __rte_experimental 654 int 655 rte_swx_ctl_pipeline_table_entry_delete(struct rte_swx_ctl_pipeline *ctl, 656 const char *table_name, 657 struct rte_swx_table_entry *entry); 658 659 /** 660 * Pipeline selector table group add 661 * 662 * Add a new group to a selector table. This operation is executed before this 663 * function returns and its result is independent of the result of the next 664 * commit operation. 665 * 666 * @param[in] ctl 667 * Pipeline control handle. 668 * @param[in] selector_name 669 * Selector table name. 670 * @param[out] group_id 671 * The ID of the new group. Only valid when the function call is successful. 672 * This group is initially empty, i.e. it does not contain any members. 673 * @return 674 * 0 on success or the following error codes otherwise: 675 * -EINVAL: Invalid argument; 676 * -ENOSPC: All groups are currently in use, no group available. 677 */ 678 __rte_experimental 679 int 680 rte_swx_ctl_pipeline_selector_group_add(struct rte_swx_ctl_pipeline *ctl, 681 const char *selector_name, 682 uint32_t *group_id); 683 684 /** 685 * Pipeline selector table group delete 686 * 687 * Schedule a group for deletion as part of the next commit operation. The group 688 * to be deleted can be empty or non-empty. 689 * 690 * @param[in] ctl 691 * Pipeline control handle. 692 * @param[in] selector_name 693 * Selector table name. 694 * @param[in] group_id 695 * Group to be deleted from the selector table. 696 * @return 697 * 0 on success or the following error codes otherwise: 698 * -EINVAL: Invalid argument; 699 * -ENOMEM: Not enough memory. 700 */ 701 __rte_experimental 702 int 703 rte_swx_ctl_pipeline_selector_group_delete(struct rte_swx_ctl_pipeline *ctl, 704 const char *selector_name, 705 uint32_t group_id); 706 707 /** 708 * Pipeline selector table member add to group 709 * 710 * Schedule the operation to add a new member to an existing group as part of 711 * the next commit operation. If this member is already in this group, the 712 * member weight is updated to the new value. A weight of zero means this member 713 * is to be deleted from the group. 714 * 715 * @param[in] ctl 716 * Pipeline control handle. 717 * @param[in] selector_name 718 * Selector table name. 719 * @param[in] group_id 720 * The group ID. 721 * @param[in] member_id 722 * The member to be added to the group. 723 * @param[in] member_weight 724 * Member weight. 725 * @return 726 * 0 on success or the following error codes otherwise: 727 * -EINVAL: Invalid argument; 728 * -ENOMEM: Not enough memory; 729 * -ENOSPC: The group is full. 730 */ 731 __rte_experimental 732 int 733 rte_swx_ctl_pipeline_selector_group_member_add(struct rte_swx_ctl_pipeline *ctl, 734 const char *selector_name, 735 uint32_t group_id, 736 uint32_t member_id, 737 uint32_t member_weight); 738 739 /** 740 * Pipeline selector table member delete from group 741 * 742 * Schedule the operation to delete a member from an existing group as part of 743 * the next commit operation. 744 * 745 * @param[in] ctl 746 * Pipeline control handle. 747 * @param[in] selector_name 748 * Selector table name. 749 * @param[in] group_id 750 * The group ID. Must be valid. 751 * @param[in] member_id 752 * The member to be added to the group. Must be valid. 753 * @return 754 * 0 on success or the following error codes otherwise: 755 * -EINVAL: Invalid argument. 756 */ 757 __rte_experimental 758 int 759 rte_swx_ctl_pipeline_selector_group_member_delete(struct rte_swx_ctl_pipeline *ctl, 760 const char *selector_name, 761 uint32_t group_id, 762 uint32_t member_id); 763 764 /** 765 * Pipeline commit 766 * 767 * Perform all the scheduled table work. 768 * 769 * @param[in] ctl 770 * Pipeline control handle. 771 * @param[in] abort_on_fail 772 * When non-zero (false), all the scheduled work is discarded after a failed 773 * commit. Otherwise, the scheduled work is still kept pending for the next 774 * commit. 775 * @return 776 * 0 on success or the following error codes otherwise: 777 * -EINVAL: Invalid argument. 778 */ 779 __rte_experimental 780 int 781 rte_swx_ctl_pipeline_commit(struct rte_swx_ctl_pipeline *ctl, 782 int abort_on_fail); 783 784 /** 785 * Pipeline abort 786 * 787 * Discard all the scheduled table work. 788 * 789 * @param[in] ctl 790 * Pipeline control handle. 791 */ 792 __rte_experimental 793 void 794 rte_swx_ctl_pipeline_abort(struct rte_swx_ctl_pipeline *ctl); 795 796 /** 797 * Pipeline table entry read 798 * 799 * Read table entry from string. 800 * 801 * @param[in] ctl 802 * Pipeline control handle. 803 * @param[in] table_name 804 * Table name. 805 * @param[in] string 806 * String containing the table entry. 807 * @param[out] is_blank_or_comment 808 * On error, this argument provides an indication of whether *string* contains 809 * an invalid table entry (set to zero) or a blank or comment line that should 810 * typically be ignored (set to a non-zero value). 811 * @return 812 * 0 on success or the following error codes otherwise: 813 * -EINVAL: Invalid argument. 814 */ 815 __rte_experimental 816 struct rte_swx_table_entry * 817 rte_swx_ctl_pipeline_table_entry_read(struct rte_swx_ctl_pipeline *ctl, 818 const char *table_name, 819 const char *string, 820 int *is_blank_or_comment); 821 822 /** 823 * Pipeline table print to file 824 * 825 * Print all the table entries to file. 826 * 827 * @param[in] f 828 * Output file. 829 * @param[in] ctl 830 * Pipeline control handle. 831 * @param[in] table_name 832 * Table name. 833 * @return 834 * 0 on success or the following error codes otherwise: 835 * -EINVAL: Invalid argument. 836 */ 837 __rte_experimental 838 int 839 rte_swx_ctl_pipeline_table_fprintf(FILE *f, 840 struct rte_swx_ctl_pipeline *ctl, 841 const char *table_name); 842 843 /** 844 * Pipeline selector print to file 845 * 846 * Print all the selector entries to file. 847 * 848 * @param[in] f 849 * Output file. 850 * @param[in] ctl 851 * Pipeline control handle. 852 * @param[in] selector_name 853 * Selector table name. 854 * @return 855 * 0 on success or the following error codes otherwise: 856 * -EINVAL: Invalid argument. 857 */ 858 __rte_experimental 859 int 860 rte_swx_ctl_pipeline_selector_fprintf(FILE *f, 861 struct rte_swx_ctl_pipeline *ctl, 862 const char *selector_name); 863 864 /* 865 * Register Array Query API. 866 */ 867 868 /** Register array info. */ 869 struct rte_swx_ctl_regarray_info { 870 /** Register array name. */ 871 char name[RTE_SWX_CTL_NAME_SIZE]; 872 873 /** Register array size. */ 874 uint32_t size; 875 }; 876 877 /** 878 * Register array info get 879 * 880 * @param[in] p 881 * Pipeline handle. 882 * @param[in] regarray_id 883 * Register array ID (0 .. *n_regarrays* - 1). 884 * @param[out] regarray 885 * Register array info. 886 * @return 887 * 0 on success or the following error codes otherwise: 888 * -EINVAL: Invalid argument. 889 */ 890 __rte_experimental 891 int 892 rte_swx_ctl_regarray_info_get(struct rte_swx_pipeline *p, 893 uint32_t regarray_id, 894 struct rte_swx_ctl_regarray_info *regarray); 895 896 /** 897 * Register read 898 * 899 * @param[in] p 900 * Pipeline handle. 901 * @param[in] regarray_name 902 * Register array name. 903 * @param[in] regarray_index 904 * Register index within the array (0 .. *size* - 1). 905 * @param[out] value 906 * Current register value. 907 * @return 908 * 0 on success or the following error codes otherwise: 909 * -EINVAL: Invalid argument. 910 */ 911 __rte_experimental 912 int 913 rte_swx_ctl_pipeline_regarray_read(struct rte_swx_pipeline *p, 914 const char *regarray_name, 915 uint32_t regarray_index, 916 uint64_t *value); 917 918 /** 919 * Register write 920 * 921 * @param[in] p 922 * Pipeline handle. 923 * @param[in] regarray_name 924 * Register array name. 925 * @param[in] regarray_index 926 * Register index within the array (0 .. *size* - 1). 927 * @param[in] value 928 * Value to be written to the register. 929 * @return 930 * 0 on success or the following error codes otherwise: 931 * -EINVAL: Invalid argument. 932 */ 933 __rte_experimental 934 int 935 rte_swx_ctl_pipeline_regarray_write(struct rte_swx_pipeline *p, 936 const char *regarray_name, 937 uint32_t regarray_index, 938 uint64_t value); 939 940 /* 941 * Meter Array Query and Configuration API. 942 */ 943 944 /** Meter array info. */ 945 struct rte_swx_ctl_metarray_info { 946 /** Meter array name. */ 947 char name[RTE_SWX_CTL_NAME_SIZE]; 948 949 /** Meter array size. */ 950 uint32_t size; 951 }; 952 953 /** 954 * Meter array info get 955 * 956 * @param[in] p 957 * Pipeline handle. 958 * @param[in] metarray_id 959 * Meter array ID (0 .. *n_metarrays* - 1). 960 * @param[out] metarray 961 * Meter array info. 962 * @return 963 * 0 on success or the following error codes otherwise: 964 * -EINVAL: Invalid argument. 965 */ 966 __rte_experimental 967 int 968 rte_swx_ctl_metarray_info_get(struct rte_swx_pipeline *p, 969 uint32_t metarray_id, 970 struct rte_swx_ctl_metarray_info *metarray); 971 972 /** 973 * Meter profile add 974 * 975 * @param[in] p 976 * Pipeline handle. 977 * @param[in] name 978 * Meter profile name. 979 * @param[in] params 980 * Meter profile parameters. 981 * @return 982 * 0 on success or the following error codes otherwise: 983 * -EINVAL: Invalid argument; 984 * -ENOMEM: Not enough space/cannot allocate memory; 985 * -EEXIST: Meter profile with this name already exists. 986 */ 987 __rte_experimental 988 int 989 rte_swx_ctl_meter_profile_add(struct rte_swx_pipeline *p, 990 const char *name, 991 struct rte_meter_trtcm_params *params); 992 993 /** 994 * Meter profile delete 995 * 996 * @param[in] p 997 * Pipeline handle. 998 * @param[in] name 999 * Meter profile name. 1000 * @return 1001 * 0 on success or the following error codes otherwise: 1002 * -EINVAL: Invalid argument; 1003 * -EBUSY: Meter profile is currently in use. 1004 */ 1005 __rte_experimental 1006 int 1007 rte_swx_ctl_meter_profile_delete(struct rte_swx_pipeline *p, 1008 const char *name); 1009 1010 /** 1011 * Meter reset 1012 * 1013 * Reset a meter within a given meter array to use the default profile that 1014 * causes all the input packets to be colored as green. It is the responsibility 1015 * of the control plane to make sure this meter is not used by the data plane 1016 * pipeline before calling this function. 1017 * 1018 * @param[in] p 1019 * Pipeline handle. 1020 * @param[in] metarray_name 1021 * Meter array name. 1022 * @param[in] metarray_index 1023 * Meter index within the meter array. 1024 * @return 1025 * 0 on success or the following error codes otherwise: 1026 * -EINVAL: Invalid argument. 1027 */ 1028 __rte_experimental 1029 int 1030 rte_swx_ctl_meter_reset(struct rte_swx_pipeline *p, 1031 const char *metarray_name, 1032 uint32_t metarray_index); 1033 1034 /** 1035 * Meter set 1036 * 1037 * Set a meter within a given meter array to use a specific profile. It is the 1038 * responsibility of the control plane to make sure this meter is not used by 1039 * the data plane pipeline before calling this function. 1040 * 1041 * @param[in] p 1042 * Pipeline handle. 1043 * @param[in] metarray_name 1044 * Meter array name. 1045 * @param[in] metarray_index 1046 * Meter index within the meter array. 1047 * @param[in] profile_name 1048 * Existing meter profile name. 1049 * @return 1050 * 0 on success or the following error codes otherwise: 1051 * -EINVAL: Invalid argument. 1052 */ 1053 __rte_experimental 1054 int 1055 rte_swx_ctl_meter_set(struct rte_swx_pipeline *p, 1056 const char *metarray_name, 1057 uint32_t metarray_index, 1058 const char *profile_name); 1059 1060 /** Meter statistics counters. */ 1061 struct rte_swx_ctl_meter_stats { 1062 /** Number of packets tagged by the meter for each color. */ 1063 uint64_t n_pkts[RTE_COLORS]; 1064 1065 /** Number of bytes tagged by the meter for each color. */ 1066 uint64_t n_bytes[RTE_COLORS]; 1067 }; 1068 1069 /** 1070 * Meter statistics counters read 1071 * 1072 * @param[in] p 1073 * Pipeline handle. 1074 * @param[in] metarray_name 1075 * Meter array name. 1076 * @param[in] metarray_index 1077 * Meter index within the meter array. 1078 * @param[out] stats 1079 * Meter statistics counters. 1080 * @return 1081 * 0 on success or the following error codes otherwise: 1082 * -EINVAL: Invalid argument. 1083 */ 1084 __rte_experimental 1085 int 1086 rte_swx_ctl_meter_stats_read(struct rte_swx_pipeline *p, 1087 const char *metarray_name, 1088 uint32_t metarray_index, 1089 struct rte_swx_ctl_meter_stats *stats); 1090 1091 /** 1092 * Pipeline control free 1093 * 1094 * @param[in] ctl 1095 * Pipeline control handle. 1096 */ 1097 __rte_experimental 1098 void 1099 rte_swx_ctl_pipeline_free(struct rte_swx_ctl_pipeline *ctl); 1100 1101 #ifdef __cplusplus 1102 } 1103 #endif 1104 1105 #endif 1106