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 26 struct rte_swx_pipeline; 27 28 /** Name size. */ 29 #ifndef RTE_SWX_CTL_NAME_SIZE 30 #define RTE_SWX_CTL_NAME_SIZE 64 31 #endif 32 33 /* 34 * Pipeline Query API. 35 */ 36 37 /** Pipeline info. */ 38 struct rte_swx_ctl_pipeline_info { 39 /** Number of input ports. */ 40 uint32_t n_ports_in; 41 42 /** Number of input ports. */ 43 uint32_t n_ports_out; 44 45 /** Number of actions. */ 46 uint32_t n_actions; 47 48 /** Number of tables. */ 49 uint32_t n_tables; 50 51 /** Number of register arrays. */ 52 uint32_t n_regarrays; 53 54 /** Number of meter arrays. */ 55 uint32_t n_metarrays; 56 }; 57 58 /** 59 * Pipeline info get 60 * 61 * @param[in] p 62 * Pipeline handle. 63 * @param[out] pipeline 64 * Pipeline info. 65 * @return 66 * 0 on success or the following error codes otherwise: 67 * -EINVAL: Invalid argument. 68 */ 69 __rte_experimental 70 int 71 rte_swx_ctl_pipeline_info_get(struct rte_swx_pipeline *p, 72 struct rte_swx_ctl_pipeline_info *pipeline); 73 74 /** 75 * Pipeline NUMA node get 76 * 77 * @param[in] p 78 * Pipeline handle. 79 * @param[out] numa_node 80 * Pipeline NUMA node. 81 * @return 82 * 0 on success or the following error codes otherwise: 83 * -EINVAL: Invalid argument. 84 */ 85 __rte_experimental 86 int 87 rte_swx_ctl_pipeline_numa_node_get(struct rte_swx_pipeline *p, 88 int *numa_node); 89 90 /* 91 * Ports Query API. 92 */ 93 94 /** 95 * Input port statistics counters read 96 * 97 * @param[in] p 98 * Pipeline handle. 99 * @param[in] port_id 100 * Port ID (0 .. *n_ports_in* - 1). 101 * @param[out] stats 102 * Input port stats. 103 * @return 104 * 0 on success or the following error codes otherwise: 105 * -EINVAL: Invalid argument. 106 */ 107 __rte_experimental 108 int 109 rte_swx_ctl_pipeline_port_in_stats_read(struct rte_swx_pipeline *p, 110 uint32_t port_id, 111 struct rte_swx_port_in_stats *stats); 112 113 /** 114 * Output port statistics counters read 115 * 116 * @param[in] p 117 * Pipeline handle. 118 * @param[in] port_id 119 * Port ID (0 .. *n_ports_out* - 1). 120 * @param[out] stats 121 * Output port stats. 122 * @return 123 * 0 on success or the following error codes otherwise: 124 * -EINVAL: Invalid argument. 125 */ 126 __rte_experimental 127 int 128 rte_swx_ctl_pipeline_port_out_stats_read(struct rte_swx_pipeline *p, 129 uint32_t port_id, 130 struct rte_swx_port_out_stats *stats); 131 132 /* 133 * Action Query API. 134 */ 135 136 /** Action info. */ 137 struct rte_swx_ctl_action_info { 138 /** Action name. */ 139 char name[RTE_SWX_CTL_NAME_SIZE]; 140 141 /** Number of action arguments. */ 142 uint32_t n_args; 143 }; 144 145 /** 146 * Action info get 147 * 148 * @param[in] p 149 * Pipeline handle. 150 * @param[in] action_id 151 * Action ID (0 .. *n_actions* - 1). 152 * @param[out] action 153 * Action info. 154 * @return 155 * 0 on success or the following error codes otherwise: 156 * -EINVAL: Invalid argument. 157 */ 158 __rte_experimental 159 int 160 rte_swx_ctl_action_info_get(struct rte_swx_pipeline *p, 161 uint32_t action_id, 162 struct rte_swx_ctl_action_info *action); 163 164 /** Action argument info. */ 165 struct rte_swx_ctl_action_arg_info { 166 /** Action argument name. */ 167 char name[RTE_SWX_CTL_NAME_SIZE]; 168 169 /** Action argument size (in bits). */ 170 uint32_t n_bits; 171 172 /** Non-zero (true) when this action argument must be stored in the 173 * table in network byte order (NBO), zero when it must be stored in 174 * host byte order (HBO). 175 */ 176 int is_network_byte_order; 177 }; 178 179 /** 180 * Action argument info get 181 * 182 * @param[in] p 183 * Pipeline handle. 184 * @param[in] action_id 185 * Action ID (0 .. *n_actions* - 1). 186 * @param[in] action_arg_id 187 * Action ID (0 .. *n_args* - 1). 188 * @param[out] action_arg 189 * Action argument info. 190 * @return 191 * 0 on success or the following error codes otherwise: 192 * -EINVAL: Invalid argument. 193 */ 194 __rte_experimental 195 int 196 rte_swx_ctl_action_arg_info_get(struct rte_swx_pipeline *p, 197 uint32_t action_id, 198 uint32_t action_arg_id, 199 struct rte_swx_ctl_action_arg_info *action_arg); 200 201 /* 202 * Table Query API. 203 */ 204 205 /** Table info. */ 206 struct rte_swx_ctl_table_info { 207 /** Table name. */ 208 char name[RTE_SWX_CTL_NAME_SIZE]; 209 210 /** Table creation arguments. */ 211 char args[RTE_SWX_CTL_NAME_SIZE]; 212 213 /** Number of match fields. */ 214 uint32_t n_match_fields; 215 216 /** Number of actions. */ 217 uint32_t n_actions; 218 219 /** Non-zero (true) when the default action is constant, therefore it 220 * cannot be changed; zero (false) when the default action not constant, 221 * therefore it can be changed. 222 */ 223 int default_action_is_const; 224 225 /** Table size parameter. */ 226 uint32_t size; 227 }; 228 229 /** 230 * Table info get 231 * 232 * @param[in] p 233 * Pipeline handle. 234 * @param[in] table_id 235 * Table ID (0 .. *n_tables* - 1). 236 * @param[out] table 237 * Table info. 238 * @return 239 * 0 on success or the following error codes otherwise: 240 * -EINVAL: Invalid argument. 241 */ 242 __rte_experimental 243 int 244 rte_swx_ctl_table_info_get(struct rte_swx_pipeline *p, 245 uint32_t table_id, 246 struct rte_swx_ctl_table_info *table); 247 248 /** Table match field info. 249 * 250 * If (n_bits, offset) are known for all the match fields of the table, then the 251 * table (key_offset, key_size, key_mask0) can be computed. 252 */ 253 struct rte_swx_ctl_table_match_field_info { 254 /** Match type of the current match field. */ 255 enum rte_swx_table_match_type match_type; 256 257 /** Non-zero (true) when the current match field is part of a registered 258 * header, zero (false) when it is part of the registered meta-data. 259 */ 260 int is_header; 261 262 /** Match field size (in bits). */ 263 uint32_t n_bits; 264 265 /** Match field offset within its parent struct (one of the headers or 266 * the meta-data). 267 */ 268 uint32_t offset; 269 }; 270 271 /** 272 * Table match field info get 273 * 274 * @param[in] p 275 * Pipeline handle. 276 * @param[in] table_id 277 * Table ID (0 .. *n_tables*). 278 * @param[in] match_field_id 279 * Match field ID (0 .. *n_match_fields* - 1). 280 * @param[out] match_field 281 * Table match field info. 282 * @return 283 * 0 on success or the following error codes otherwise: 284 * -EINVAL: Invalid argument. 285 */ 286 __rte_experimental 287 int 288 rte_swx_ctl_table_match_field_info_get(struct rte_swx_pipeline *p, 289 uint32_t table_id, 290 uint32_t match_field_id, 291 struct rte_swx_ctl_table_match_field_info *match_field); 292 293 /** Table action info. */ 294 struct rte_swx_ctl_table_action_info { 295 /** Action ID. */ 296 uint32_t action_id; 297 }; 298 299 /** 300 * Table action info get 301 * 302 * @param[in] p 303 * Pipeline handle. 304 * @param[in] table_id 305 * Table ID (0 .. *n_tables*). 306 * @param[in] table_action_id 307 * Action index within the set of table actions (0 .. table n_actions - 1). 308 * Not to be confused with the action ID, which works at the pipeline level 309 * (0 .. pipeline n_actions - 1), which is precisely what this function 310 * returns as part of *table_action*. 311 * @param[out] table_action 312 * Table action info. 313 * @return 314 * 0 on success or the following error codes otherwise: 315 * -EINVAL: Invalid argument. 316 */ 317 __rte_experimental 318 int 319 rte_swx_ctl_table_action_info_get(struct rte_swx_pipeline *p, 320 uint32_t table_id, 321 uint32_t table_action_id, 322 struct rte_swx_ctl_table_action_info *table_action); 323 324 /** 325 * Table operations get 326 * 327 * @param[in] p 328 * Pipeline handle. 329 * @param[in] table_id 330 * Table ID (0 .. *n_tables*). 331 * @param[out] table_ops 332 * Table operations. Only valid when function returns success and *is_stub* is 333 * zero (false). 334 * @param[out] is_stub 335 * A stub table is a table with no match fields. No "regular" table entries 336 * (i.e. entries other than the default entry) can be added to such a table, 337 * therefore the lookup operation always results in lookup miss. Non-zero 338 * (true) when the current table is a stub table, zero (false) otherwise. 339 * @return 340 * 0 on success or the following error codes otherwise: 341 * -EINVAL: Invalid argument. 342 */ 343 __rte_experimental 344 int 345 rte_swx_ctl_table_ops_get(struct rte_swx_pipeline *p, 346 uint32_t table_id, 347 struct rte_swx_table_ops *table_ops, 348 int *is_stub); 349 350 /** Table statistics. */ 351 struct rte_swx_table_stats { 352 /** Number of packets with lookup hit. */ 353 uint64_t n_pkts_hit; 354 355 /** Number of packets with lookup miss. */ 356 uint64_t n_pkts_miss; 357 358 /** Number of packets (with either lookup hit or miss) per pipeline 359 * action. Array of pipeline *n_actions* elements indedex by the 360 * pipeline-level *action_id*, therefore this array has the same size 361 * for all the tables within the same pipeline. 362 */ 363 uint64_t *n_pkts_action; 364 }; 365 366 /** 367 * Table statistics counters read 368 * 369 * @param[in] p 370 * Pipeline handle. 371 * @param[in] table_name 372 * Table name. 373 * @param[out] stats 374 * Table stats. Must point to a pre-allocated structure. The *n_pkts_action* 375 * field also needs to be pre-allocated as array of pipeline *n_actions* 376 * elements. The pipeline actions that are not valid for the current table 377 * have their associated *n_pkts_action* element always set to zero. 378 * @return 379 * 0 on success or the following error codes otherwise: 380 * -EINVAL: Invalid argument. 381 */ 382 __rte_experimental 383 int 384 rte_swx_ctl_pipeline_table_stats_read(struct rte_swx_pipeline *p, 385 const char *table_name, 386 struct rte_swx_table_stats *stats); 387 388 /* 389 * Table Update API. 390 */ 391 392 /** Table state. */ 393 struct rte_swx_table_state { 394 /** Table object. */ 395 void *obj; 396 397 /** Action ID of the table default action. */ 398 uint64_t default_action_id; 399 400 /** Action data of the table default action. Ignored when the action 401 * data size is zero; otherwise, action data size bytes are meaningful. 402 */ 403 uint8_t *default_action_data; 404 }; 405 406 /** 407 * Pipeline table state get 408 * 409 * @param[in] p 410 * Pipeline handle. 411 * @param[out] table_state 412 * After successful execution, the *table_state* contains the pointer to the 413 * current pipeline table state, which is an array of *n_tables* elements, 414 * with array element i containing the state of the i-th pipeline table. The 415 * pipeline continues to own all the data structures directly or indirectly 416 * referenced by the *table_state* until the subsequent successful invocation 417 * of function *rte_swx_pipeline_table_state_set*. 418 * @return 419 * 0 on success or the following error codes otherwise: 420 * -EINVAL: Invalid argument. 421 */ 422 __rte_experimental 423 int 424 rte_swx_pipeline_table_state_get(struct rte_swx_pipeline *p, 425 struct rte_swx_table_state **table_state); 426 427 /** 428 * Pipeline table state set 429 * 430 * @param[in] p 431 * Pipeline handle. 432 * @param[out] table_state 433 * After successful execution, the pipeline table state is updated to this 434 * *table_state*. The ownership of all the data structures directly or 435 * indirectly referenced by this *table_state* is passed from the caller to 436 * the pipeline. 437 * @return 438 * 0 on success or the following error codes otherwise: 439 * -EINVAL: Invalid argument. 440 */ 441 __rte_experimental 442 int 443 rte_swx_pipeline_table_state_set(struct rte_swx_pipeline *p, 444 struct rte_swx_table_state *table_state); 445 446 /* 447 * High Level Reference Table Update API. 448 */ 449 450 /** Pipeline control opaque data structure. */ 451 struct rte_swx_ctl_pipeline; 452 453 /** 454 * Pipeline control create 455 * 456 * @param[in] p 457 * Pipeline handle. 458 * @return 459 * Pipeline control handle, on success, or NULL, on error. 460 */ 461 __rte_experimental 462 struct rte_swx_ctl_pipeline * 463 rte_swx_ctl_pipeline_create(struct rte_swx_pipeline *p); 464 465 /** 466 * Pipeline table entry add 467 * 468 * Schedule entry for addition to table or update as part of the next commit 469 * operation. 470 * 471 * @param[in] ctl 472 * Pipeline control handle. 473 * @param[in] table_name 474 * Table name. 475 * @param[in] entry 476 * Entry to be added to the table. 477 * @return 478 * 0 on success or the following error codes otherwise: 479 * -EINVAL: Invalid argument. 480 */ 481 __rte_experimental 482 int 483 rte_swx_ctl_pipeline_table_entry_add(struct rte_swx_ctl_pipeline *ctl, 484 const char *table_name, 485 struct rte_swx_table_entry *entry); 486 487 /** 488 * Pipeline table default entry add 489 * 490 * Schedule table default entry update as part of the next commit operation. 491 * 492 * @param[in] ctl 493 * Pipeline control handle. 494 * @param[in] table_name 495 * Table name. 496 * @param[in] entry 497 * The new table default entry. The *key* and *key_mask* entry fields are 498 * ignored. 499 * @return 500 * 0 on success or the following error codes otherwise: 501 * -EINVAL: Invalid argument. 502 */ 503 __rte_experimental 504 int 505 rte_swx_ctl_pipeline_table_default_entry_add(struct rte_swx_ctl_pipeline *ctl, 506 const char *table_name, 507 struct rte_swx_table_entry *entry); 508 509 /** 510 * Pipeline table entry delete 511 * 512 * Schedule entry for deletion from table as part of the next commit operation. 513 * Request is silently discarded if no such entry exists. 514 * 515 * @param[in] ctl 516 * Pipeline control handle. 517 * @param[in] table_name 518 * Table name. 519 * @param[in] entry 520 * Entry to be deleted from the table. The *action_id* and *action_data* entry 521 * fields are ignored. 522 * @return 523 * 0 on success or the following error codes otherwise: 524 * -EINVAL: Invalid argument. 525 */ 526 __rte_experimental 527 int 528 rte_swx_ctl_pipeline_table_entry_delete(struct rte_swx_ctl_pipeline *ctl, 529 const char *table_name, 530 struct rte_swx_table_entry *entry); 531 532 /** 533 * Pipeline commit 534 * 535 * Perform all the scheduled table work. 536 * 537 * @param[in] ctl 538 * Pipeline control handle. 539 * @param[in] abort_on_fail 540 * When non-zero (false), all the scheduled work is discarded after a failed 541 * commit. Otherwise, the scheduled work is still kept pending for the next 542 * commit. 543 * @return 544 * 0 on success or the following error codes otherwise: 545 * -EINVAL: Invalid argument. 546 */ 547 __rte_experimental 548 int 549 rte_swx_ctl_pipeline_commit(struct rte_swx_ctl_pipeline *ctl, 550 int abort_on_fail); 551 552 /** 553 * Pipeline abort 554 * 555 * Discard all the scheduled table work. 556 * 557 * @param[in] ctl 558 * Pipeline control handle. 559 */ 560 __rte_experimental 561 void 562 rte_swx_ctl_pipeline_abort(struct rte_swx_ctl_pipeline *ctl); 563 564 /** 565 * Pipeline table entry read 566 * 567 * Read table entry from string. 568 * 569 * @param[in] ctl 570 * Pipeline control handle. 571 * @param[in] table_name 572 * Table name. 573 * @param[in] string 574 * String containing the table entry. 575 * @param[out] is_blank_or_comment 576 * On error, this argument provides an indication of whether *string* contains 577 * an invalid table entry (set to zero) or a blank or comment line that should 578 * typically be ignored (set to a non-zero value). 579 * @return 580 * 0 on success or the following error codes otherwise: 581 * -EINVAL: Invalid argument. 582 */ 583 __rte_experimental 584 struct rte_swx_table_entry * 585 rte_swx_ctl_pipeline_table_entry_read(struct rte_swx_ctl_pipeline *ctl, 586 const char *table_name, 587 const char *string, 588 int *is_blank_or_comment); 589 590 /** 591 * Pipeline table print to file 592 * 593 * Print all the table entries to file. 594 * 595 * @param[in] f 596 * Output file. 597 * @param[in] ctl 598 * Pipeline control handle. 599 * @param[in] table_name 600 * Table name. 601 * @return 602 * 0 on success or the following error codes otherwise: 603 * -EINVAL: Invalid argument. 604 */ 605 __rte_experimental 606 int 607 rte_swx_ctl_pipeline_table_fprintf(FILE *f, 608 struct rte_swx_ctl_pipeline *ctl, 609 const char *table_name); 610 611 /* 612 * Register Array Query API. 613 */ 614 615 /** Register array info. */ 616 struct rte_swx_ctl_regarray_info { 617 /** Register array name. */ 618 char name[RTE_SWX_CTL_NAME_SIZE]; 619 620 /** Register array size. */ 621 uint32_t size; 622 }; 623 624 /** 625 * Register array info get 626 * 627 * @param[in] p 628 * Pipeline handle. 629 * @param[in] regarray_id 630 * Register array ID (0 .. *n_regarrays* - 1). 631 * @param[out] regarray 632 * Register array info. 633 * @return 634 * 0 on success or the following error codes otherwise: 635 * -EINVAL: Invalid argument. 636 */ 637 __rte_experimental 638 int 639 rte_swx_ctl_regarray_info_get(struct rte_swx_pipeline *p, 640 uint32_t regarray_id, 641 struct rte_swx_ctl_regarray_info *regarray); 642 643 /** 644 * Register read 645 * 646 * @param[in] p 647 * Pipeline handle. 648 * @param[in] regarray_name 649 * Register array name. 650 * @param[in] regarray_index 651 * Register index within the array (0 .. *size* - 1). 652 * @param[out] value 653 * Current register value. 654 * @return 655 * 0 on success or the following error codes otherwise: 656 * -EINVAL: Invalid argument. 657 */ 658 __rte_experimental 659 int 660 rte_swx_ctl_pipeline_regarray_read(struct rte_swx_pipeline *p, 661 const char *regarray_name, 662 uint32_t regarray_index, 663 uint64_t *value); 664 665 /** 666 * Register write 667 * 668 * @param[in] p 669 * Pipeline handle. 670 * @param[in] regarray_name 671 * Register array name. 672 * @param[in] regarray_index 673 * Register index within the array (0 .. *size* - 1). 674 * @param[in] value 675 * Value to be written to the register. 676 * @return 677 * 0 on success or the following error codes otherwise: 678 * -EINVAL: Invalid argument. 679 */ 680 __rte_experimental 681 int 682 rte_swx_ctl_pipeline_regarray_write(struct rte_swx_pipeline *p, 683 const char *regarray_name, 684 uint32_t regarray_index, 685 uint64_t value); 686 687 /* 688 * Meter Array Query and Configuration API. 689 */ 690 691 /** Meter array info. */ 692 struct rte_swx_ctl_metarray_info { 693 /** Meter array name. */ 694 char name[RTE_SWX_CTL_NAME_SIZE]; 695 696 /** Meter array size. */ 697 uint32_t size; 698 }; 699 700 /** 701 * Meter array info get 702 * 703 * @param[in] p 704 * Pipeline handle. 705 * @param[in] metarray_id 706 * Meter array ID (0 .. *n_metarrays* - 1). 707 * @param[out] metarray 708 * Meter array info. 709 * @return 710 * 0 on success or the following error codes otherwise: 711 * -EINVAL: Invalid argument. 712 */ 713 __rte_experimental 714 int 715 rte_swx_ctl_metarray_info_get(struct rte_swx_pipeline *p, 716 uint32_t metarray_id, 717 struct rte_swx_ctl_metarray_info *metarray); 718 719 /** 720 * Meter profile add 721 * 722 * @param[in] p 723 * Pipeline handle. 724 * @param[in] name 725 * Meter profile name. 726 * @param[in] params 727 * Meter profile parameters. 728 * @return 729 * 0 on success or the following error codes otherwise: 730 * -EINVAL: Invalid argument; 731 * -ENOMEM: Not enough space/cannot allocate memory; 732 * -EEXIST: Meter profile with this name already exists. 733 */ 734 __rte_experimental 735 int 736 rte_swx_ctl_meter_profile_add(struct rte_swx_pipeline *p, 737 const char *name, 738 struct rte_meter_trtcm_params *params); 739 740 /** 741 * Meter profile delete 742 * 743 * @param[in] p 744 * Pipeline handle. 745 * @param[in] name 746 * Meter profile name. 747 * @return 748 * 0 on success or the following error codes otherwise: 749 * -EINVAL: Invalid argument; 750 * -EBUSY: Meter profile is currently in use. 751 */ 752 __rte_experimental 753 int 754 rte_swx_ctl_meter_profile_delete(struct rte_swx_pipeline *p, 755 const char *name); 756 757 /** 758 * Meter reset 759 * 760 * Reset a meter within a given meter array to use the default profile that 761 * causes all the input packets to be colored as green. It is the responsibility 762 * of the control plane to make sure this meter is not used by the data plane 763 * pipeline before calling this function. 764 * 765 * @param[in] p 766 * Pipeline handle. 767 * @param[in] metarray_name 768 * Meter array name. 769 * @param[in] metarray_index 770 * Meter index within the meter array. 771 * @return 772 * 0 on success or the following error codes otherwise: 773 * -EINVAL: Invalid argument. 774 */ 775 __rte_experimental 776 int 777 rte_swx_ctl_meter_reset(struct rte_swx_pipeline *p, 778 const char *metarray_name, 779 uint32_t metarray_index); 780 781 /** 782 * Meter set 783 * 784 * Set a meter within a given meter array to use a specific profile. It is the 785 * responsibility of the control plane to make sure this meter is not used by 786 * the data plane pipeline before calling this function. 787 * 788 * @param[in] p 789 * Pipeline handle. 790 * @param[in] metarray_name 791 * Meter array name. 792 * @param[in] metarray_index 793 * Meter index within the meter array. 794 * @param[in] profile_name 795 * Existing meter profile name. 796 * @return 797 * 0 on success or the following error codes otherwise: 798 * -EINVAL: Invalid argument. 799 */ 800 __rte_experimental 801 int 802 rte_swx_ctl_meter_set(struct rte_swx_pipeline *p, 803 const char *metarray_name, 804 uint32_t metarray_index, 805 const char *profile_name); 806 807 /** Meter statistics counters. */ 808 struct rte_swx_ctl_meter_stats { 809 /** Number of packets tagged by the meter for each color. */ 810 uint64_t n_pkts[RTE_COLORS]; 811 812 /** Number of bytes tagged by the meter for each color. */ 813 uint64_t n_bytes[RTE_COLORS]; 814 }; 815 816 /** 817 * Meter statistics counters read 818 * 819 * @param[in] p 820 * Pipeline handle. 821 * @param[in] metarray_name 822 * Meter array name. 823 * @param[in] metarray_index 824 * Meter index within the meter array. 825 * @param[out] stats 826 * Meter statistics counters. 827 * @return 828 * 0 on success or the following error codes otherwise: 829 * -EINVAL: Invalid argument. 830 */ 831 __rte_experimental 832 int 833 rte_swx_ctl_meter_stats_read(struct rte_swx_pipeline *p, 834 const char *metarray_name, 835 uint32_t metarray_index, 836 struct rte_swx_ctl_meter_stats *stats); 837 838 /** 839 * Pipeline control free 840 * 841 * @param[in] ctl 842 * Pipeline control handle. 843 */ 844 __rte_experimental 845 void 846 rte_swx_ctl_pipeline_free(struct rte_swx_ctl_pipeline *ctl); 847 848 #ifdef __cplusplus 849 } 850 #endif 851 852 #endif 853