1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2017 Intel Corporation. 3 * Copyright(c) 2017 Cavium. 4 * Copyright(c) 2017 NXP. 5 */ 6 7 #ifndef __INCLUDE_RTE_TM_H__ 8 #define __INCLUDE_RTE_TM_H__ 9 10 /** 11 * @file 12 * RTE Generic Traffic Manager API 13 * 14 * This interface provides the ability to configure the traffic manager in a 15 * generic way. It includes features such as: hierarchical scheduling, 16 * traffic shaping, congestion management, packet marking, etc. 17 * 18 * @warning 19 * @b EXPERIMENTAL: 20 * All functions in this file may be changed or removed without prior notice. 21 */ 22 23 #include <stdint.h> 24 25 #include <rte_common.h> 26 #include <rte_meter.h> 27 28 #ifdef __cplusplus 29 extern "C" { 30 #endif 31 32 /** 33 * Ethernet framing overhead. 34 * 35 * Overhead fields per Ethernet frame: 36 * 1. Preamble: 7 bytes; 37 * 2. Start of Frame Delimiter (SFD): 1 byte; 38 * 3. Inter-Frame Gap (IFG): 12 bytes. 39 * 40 * One of the typical values for the *pkt_length_adjust* field of the shaper 41 * profile. 42 * 43 * @see struct rte_tm_shaper_params 44 */ 45 #define RTE_TM_ETH_FRAMING_OVERHEAD 20 46 47 /** 48 * Ethernet framing overhead including the Frame Check Sequence (FCS) field. 49 * Useful when FCS is generated and added at the end of the Ethernet frame on 50 * Tx side without any SW intervention. 51 * 52 * One of the typical values for the pkt_length_adjust field of the shaper 53 * profile. 54 * 55 * @see struct rte_tm_shaper_params 56 */ 57 #define RTE_TM_ETH_FRAMING_OVERHEAD_FCS 24 58 59 /** 60 * Invalid WRED profile ID. 61 * 62 * @see struct rte_tm_node_params 63 * @see rte_tm_node_add() 64 * @see rte_tm_node_wred_context_update() 65 */ 66 #define RTE_TM_WRED_PROFILE_ID_NONE UINT32_MAX 67 68 /** 69 *Invalid shaper profile ID. 70 * 71 * @see struct rte_tm_node_params 72 * @see rte_tm_node_add() 73 * @see rte_tm_node_shaper_update() 74 */ 75 #define RTE_TM_SHAPER_PROFILE_ID_NONE UINT32_MAX 76 77 /** 78 * Node ID for the parent of the root node. 79 * 80 * @see rte_tm_node_add() 81 */ 82 #define RTE_TM_NODE_ID_NULL UINT32_MAX 83 84 /** 85 * Node level ID used to disable level ID checking. 86 * 87 * @see rte_tm_node_add() 88 */ 89 #define RTE_TM_NODE_LEVEL_ID_ANY UINT32_MAX 90 91 /** 92 * Node statistics counter type 93 */ 94 enum rte_tm_stats_type { 95 /** Number of packets scheduled from current node. */ 96 RTE_TM_STATS_N_PKTS = 1 << 0, 97 98 /** Number of bytes scheduled from current node. */ 99 RTE_TM_STATS_N_BYTES = 1 << 1, 100 101 /** Number of green packets dropped by current leaf node. */ 102 RTE_TM_STATS_N_PKTS_GREEN_DROPPED = 1 << 2, 103 104 /** Number of yellow packets dropped by current leaf node. */ 105 RTE_TM_STATS_N_PKTS_YELLOW_DROPPED = 1 << 3, 106 107 /** Number of red packets dropped by current leaf node. */ 108 RTE_TM_STATS_N_PKTS_RED_DROPPED = 1 << 4, 109 110 /** Number of green bytes dropped by current leaf node. */ 111 RTE_TM_STATS_N_BYTES_GREEN_DROPPED = 1 << 5, 112 113 /** Number of yellow bytes dropped by current leaf node. */ 114 RTE_TM_STATS_N_BYTES_YELLOW_DROPPED = 1 << 6, 115 116 /** Number of red bytes dropped by current leaf node. */ 117 RTE_TM_STATS_N_BYTES_RED_DROPPED = 1 << 7, 118 119 /** Number of packets currently waiting in the packet queue of current 120 * leaf node. 121 */ 122 RTE_TM_STATS_N_PKTS_QUEUED = 1 << 8, 123 124 /** Number of bytes currently waiting in the packet queue of current 125 * leaf node. 126 */ 127 RTE_TM_STATS_N_BYTES_QUEUED = 1 << 9, 128 }; 129 130 /** 131 * Node statistics counters 132 */ 133 struct rte_tm_node_stats { 134 /** Number of packets scheduled from current node. */ 135 uint64_t n_pkts; 136 137 /** Number of bytes scheduled from current node. */ 138 uint64_t n_bytes; 139 140 /** Statistics counters for leaf nodes only. */ 141 struct { 142 /** Number of packets dropped by current leaf node per each 143 * color. 144 */ 145 uint64_t n_pkts_dropped[RTE_COLORS]; 146 147 /** Number of bytes dropped by current leaf node per each 148 * color. 149 */ 150 uint64_t n_bytes_dropped[RTE_COLORS]; 151 152 /** Number of packets currently waiting in the packet queue of 153 * current leaf node. 154 */ 155 uint64_t n_pkts_queued; 156 157 /** Number of bytes currently waiting in the packet queue of 158 * current leaf node. 159 */ 160 uint64_t n_bytes_queued; 161 } leaf; 162 }; 163 164 /** 165 * Traffic manager dynamic updates 166 */ 167 enum rte_tm_dynamic_update_type { 168 /** Dynamic parent node update. The new parent node is located on same 169 * hierarchy level as the former parent node. Consequently, the node 170 * whose parent is changed preserves its hierarchy level. 171 */ 172 RTE_TM_UPDATE_NODE_PARENT_KEEP_LEVEL = 1 << 0, 173 174 /** Dynamic parent node update. The new parent node is located on 175 * different hierarchy level than the former parent node. Consequently, 176 * the node whose parent is changed also changes its hierarchy level. 177 */ 178 RTE_TM_UPDATE_NODE_PARENT_CHANGE_LEVEL = 1 << 1, 179 180 /** Dynamic node add/delete. */ 181 RTE_TM_UPDATE_NODE_ADD_DELETE = 1 << 2, 182 183 /** Suspend/resume nodes. */ 184 RTE_TM_UPDATE_NODE_SUSPEND_RESUME = 1 << 3, 185 186 /** Dynamic switch between byte-based and packet-based WFQ weights. */ 187 RTE_TM_UPDATE_NODE_WFQ_WEIGHT_MODE = 1 << 4, 188 189 /** Dynamic update on number of SP priorities. */ 190 RTE_TM_UPDATE_NODE_N_SP_PRIORITIES = 1 << 5, 191 192 /** Dynamic update of congestion management mode for leaf nodes. */ 193 RTE_TM_UPDATE_NODE_CMAN = 1 << 6, 194 195 /** Dynamic update of the set of enabled stats counter types. */ 196 RTE_TM_UPDATE_NODE_STATS = 1 << 7, 197 }; 198 199 /** 200 * Traffic manager capabilities 201 */ 202 struct rte_tm_capabilities { 203 /** Maximum number of nodes. */ 204 uint32_t n_nodes_max; 205 206 /** Maximum number of levels (i.e. number of nodes connecting the root 207 * node with any leaf node, including the root and the leaf). 208 */ 209 uint32_t n_levels_max; 210 211 /** When non-zero, this flag indicates that all the non-leaf nodes 212 * (with the exception of the root node) have identical capability set. 213 */ 214 int non_leaf_nodes_identical; 215 216 /** When non-zero, this flag indicates that all the leaf nodes have 217 * identical capability set. 218 */ 219 int leaf_nodes_identical; 220 221 /** Maximum number of shapers, either private or shared. In case the 222 * implementation does not share any resources between private and 223 * shared shapers, it is typically equal to the sum of 224 * *shaper_private_n_max* and *shaper_shared_n_max*. The 225 * value of zero indicates that traffic shaping is not supported. 226 */ 227 uint32_t shaper_n_max; 228 229 /** Maximum number of private shapers. Indicates the maximum number of 230 * nodes that can concurrently have their private shaper enabled. The 231 * value of zero indicates that private shapers are not supported. 232 */ 233 uint32_t shaper_private_n_max; 234 235 /** Maximum number of private shapers that support dual rate shaping. 236 * Indicates the maximum number of nodes that can concurrently have 237 * their private shaper enabled with dual rate support. Only valid when 238 * private shapers are supported. The value of zero indicates that dual 239 * rate shaping is not available for private shapers. The maximum value 240 * is *shaper_private_n_max*. 241 */ 242 int shaper_private_dual_rate_n_max; 243 244 /** Minimum committed/peak rate (bytes per second) for any private 245 * shaper. Valid only when private shapers are supported. 246 */ 247 uint64_t shaper_private_rate_min; 248 249 /** Maximum committed/peak rate (bytes per second) for any private 250 * shaper. Valid only when private shapers are supported. 251 */ 252 uint64_t shaper_private_rate_max; 253 254 /** Shaper private packet mode supported. When non-zero, this parameter 255 * indicates that there is at least one node that can be configured 256 * with packet mode in its private shaper. When shaper is configured 257 * in packet mode, committed/peak rate provided is interpreted 258 * in packets per second. 259 */ 260 int shaper_private_packet_mode_supported; 261 262 /** Shaper private byte mode supported. When non-zero, this parameter 263 * indicates that there is at least one node that can be configured 264 * with byte mode in its private shaper. When shaper is configured 265 * in byte mode, committed/peak rate provided is interpreted in 266 * bytes per second. 267 */ 268 int shaper_private_byte_mode_supported; 269 270 271 /** Maximum number of shared shapers. The value of zero indicates that 272 * shared shapers are not supported. 273 */ 274 uint32_t shaper_shared_n_max; 275 276 /** Maximum number of nodes that can share the same shared shaper. 277 * Only valid when shared shapers are supported. 278 */ 279 uint32_t shaper_shared_n_nodes_per_shaper_max; 280 281 /** Maximum number of shared shapers a node can be part of. This 282 * parameter indicates that there is at least one node that can be 283 * configured with this many shared shapers, which might not be true for 284 * all the nodes. Only valid when shared shapers are supported, in which 285 * case it ranges from 1 to *shaper_shared_n_max*. 286 */ 287 uint32_t shaper_shared_n_shapers_per_node_max; 288 289 /** Maximum number of shared shapers that can be configured with dual 290 * rate shaping. The value of zero indicates that dual rate shaping 291 * support is not available for shared shapers. 292 */ 293 uint32_t shaper_shared_dual_rate_n_max; 294 295 /** Minimum committed/peak rate (bytes per second) for any shared 296 * shaper. Only valid when shared shapers are supported. 297 */ 298 uint64_t shaper_shared_rate_min; 299 300 /** Maximum committed/peak rate (bytes per second) for any shared 301 * shaper. Only valid when shared shapers are supported. 302 */ 303 uint64_t shaper_shared_rate_max; 304 305 /** Shaper shared packet mode supported. When non-zero, this parameter 306 * indicates a shared shaper can be configured with packet mode. 307 * When shared shaper is configured in packet mode, committed/peak rate 308 * provided is interpreted in packets per second. 309 */ 310 int shaper_shared_packet_mode_supported; 311 312 /** Shaper shared byte mode supported. When non-zero, this parameter 313 * indicates that a shared shaper can be configured with byte mode. 314 * When shared shaper is configured in byte mode, committed/peak rate 315 * provided is interpreted in bytes per second. 316 */ 317 int shaper_shared_byte_mode_supported; 318 319 320 /** Minimum value allowed for packet length adjustment for any private 321 * or shared shaper. 322 */ 323 int shaper_pkt_length_adjust_min; 324 325 /** Maximum value allowed for packet length adjustment for any private 326 * or shared shaper. 327 */ 328 int shaper_pkt_length_adjust_max; 329 330 /** Maximum number of children nodes. This parameter indicates that 331 * there is at least one non-leaf node that can be configured with this 332 * many children nodes, which might not be true for all the non-leaf 333 * nodes. 334 */ 335 uint32_t sched_n_children_max; 336 337 /** Maximum number of supported priority levels. This parameter 338 * indicates that there is at least one non-leaf node that can be 339 * configured with this many priority levels for managing its children 340 * nodes, which might not be true for all the non-leaf nodes. The value 341 * of zero is invalid. The value of 1 indicates that only priority 0 is 342 * supported, which essentially means that Strict Priority (SP) 343 * algorithm is not supported. 344 */ 345 uint32_t sched_sp_n_priorities_max; 346 347 /** Maximum number of sibling nodes that can have the same priority at 348 * any given time, i.e. maximum size of the WFQ sibling node group. This 349 * parameter indicates there is at least one non-leaf node that meets 350 * this condition, which might not be true for all the non-leaf nodes. 351 * The value of zero is invalid. The value of 1 indicates that WFQ 352 * algorithm is not supported. The maximum value is 353 * *sched_n_children_max*. 354 */ 355 uint32_t sched_wfq_n_children_per_group_max; 356 357 /** Maximum number of priority levels that can have more than one child 358 * node at any given time, i.e. maximum number of WFQ sibling node 359 * groups that have two or more members. This parameter indicates there 360 * is at least one non-leaf node that meets this condition, which might 361 * not be true for all the non-leaf nodes. The value of zero states that 362 * WFQ algorithm is not supported. The value of 1 indicates that 363 * (*sched_sp_n_priorities_max* - 1) priority levels have at most one 364 * child node, so there can be only one priority level with two or 365 * more sibling nodes making up a WFQ group. The maximum value is: 366 * min(floor(*sched_n_children_max* / 2), *sched_sp_n_priorities_max*). 367 */ 368 uint32_t sched_wfq_n_groups_max; 369 370 /** Maximum WFQ weight. The value of 1 indicates that all sibling nodes 371 * with same priority have the same WFQ weight, so WFQ is reduced to FQ. 372 */ 373 uint32_t sched_wfq_weight_max; 374 375 /** WFQ packet mode supported. When non-zero, this parameter indicates 376 * that there is at least one non-leaf node that supports packet mode 377 * for WFQ among its children. WFQ weights will be applied against 378 * packet count for scheduling children when a non-leaf node 379 * is configured appropriately. 380 */ 381 int sched_wfq_packet_mode_supported; 382 383 /** WFQ byte mode supported. When non-zero, this parameter indicates 384 * that there is at least one non-leaf node that supports byte mode 385 * for WFQ among its children. WFQ weights will be applied against 386 * bytes for scheduling children when a non-leaf node is configured 387 * appropriately. 388 */ 389 int sched_wfq_byte_mode_supported; 390 391 /** WRED packet mode support. When non-zero, this parameter indicates 392 * that there is at least one leaf node that supports the WRED packet 393 * mode, which might not be true for all the leaf nodes. In packet 394 * mode, the WRED thresholds specify the queue length in packets, as 395 * opposed to bytes. 396 */ 397 int cman_wred_packet_mode_supported; 398 399 /** WRED byte mode support. When non-zero, this parameter indicates that 400 * there is at least one leaf node that supports the WRED byte mode, 401 * which might not be true for all the leaf nodes. In byte mode, the 402 * WRED thresholds specify the queue length in bytes, as opposed to 403 * packets. 404 */ 405 int cman_wred_byte_mode_supported; 406 407 /** Head drop algorithm support. When non-zero, this parameter 408 * indicates that there is at least one leaf node that supports the head 409 * drop algorithm, which might not be true for all the leaf nodes. 410 */ 411 int cman_head_drop_supported; 412 413 /** Maximum number of WRED contexts, either private or shared. In case 414 * the implementation does not share any resources between private and 415 * shared WRED contexts, it is typically equal to the sum of 416 * *cman_wred_context_private_n_max* and 417 * *cman_wred_context_shared_n_max*. The value of zero indicates that 418 * WRED is not supported. 419 */ 420 uint32_t cman_wred_context_n_max; 421 422 /** Maximum number of private WRED contexts. Indicates the maximum 423 * number of leaf nodes that can concurrently have their private WRED 424 * context enabled. The value of zero indicates that private WRED 425 * contexts are not supported. 426 */ 427 uint32_t cman_wred_context_private_n_max; 428 429 /** Maximum number of shared WRED contexts. The value of zero 430 * indicates that shared WRED contexts are not supported. 431 */ 432 uint32_t cman_wred_context_shared_n_max; 433 434 /** Maximum number of leaf nodes that can share the same WRED context. 435 * Only valid when shared WRED contexts are supported. 436 */ 437 uint32_t cman_wred_context_shared_n_nodes_per_context_max; 438 439 /** Maximum number of shared WRED contexts a leaf node can be part of. 440 * This parameter indicates that there is at least one leaf node that 441 * can be configured with this many shared WRED contexts, which might 442 * not be true for all the leaf nodes. Only valid when shared WRED 443 * contexts are supported, in which case it ranges from 1 to 444 * *cman_wred_context_shared_n_max*. 445 */ 446 uint32_t cman_wred_context_shared_n_contexts_per_node_max; 447 448 /** Support for VLAN DEI packet marking (per color). */ 449 int mark_vlan_dei_supported[RTE_COLORS]; 450 451 /** Support for IPv4/IPv6 ECN marking of TCP packets (per color). */ 452 int mark_ip_ecn_tcp_supported[RTE_COLORS]; 453 454 /** Support for IPv4/IPv6 ECN marking of SCTP packets (per color). */ 455 int mark_ip_ecn_sctp_supported[RTE_COLORS]; 456 457 /** Support for IPv4/IPv6 DSCP packet marking (per color). */ 458 int mark_ip_dscp_supported[RTE_COLORS]; 459 460 /** Set of supported dynamic update operations. 461 * @see enum rte_tm_dynamic_update_type 462 */ 463 uint64_t dynamic_update_mask; 464 465 /** Set of supported statistics counter types. 466 * @see enum rte_tm_stats_type 467 */ 468 uint64_t stats_mask; 469 }; 470 471 /** 472 * Traffic manager level capabilities 473 */ 474 struct rte_tm_level_capabilities { 475 /** Maximum number of nodes for the current hierarchy level. */ 476 uint32_t n_nodes_max; 477 478 /** Maximum number of non-leaf nodes for the current hierarchy level. 479 * The value of 0 indicates that current level only supports leaf 480 * nodes. The maximum value is *n_nodes_max*. 481 */ 482 uint32_t n_nodes_nonleaf_max; 483 484 /** Maximum number of leaf nodes for the current hierarchy level. The 485 * value of 0 indicates that current level only supports non-leaf 486 * nodes. The maximum value is *n_nodes_max*. 487 */ 488 uint32_t n_nodes_leaf_max; 489 490 /** When non-zero, this flag indicates that all the non-leaf nodes on 491 * this level have identical capability set. Valid only when 492 * *n_nodes_nonleaf_max* is non-zero. 493 */ 494 int non_leaf_nodes_identical; 495 496 /** When non-zero, this flag indicates that all the leaf nodes on this 497 * level have identical capability set. Valid only when 498 * *n_nodes_leaf_max* is non-zero. 499 */ 500 int leaf_nodes_identical; 501 502 RTE_STD_C11 503 union { 504 /** Items valid only for the non-leaf nodes on this level. */ 505 struct { 506 /** Private shaper support. When non-zero, it indicates 507 * there is at least one non-leaf node on this level 508 * with private shaper support, which may not be the 509 * case for all the non-leaf nodes on this level. 510 */ 511 int shaper_private_supported; 512 513 /** Dual rate support for private shaper. Valid only 514 * when private shaper is supported for the non-leaf 515 * nodes on the current level. When non-zero, it 516 * indicates there is at least one non-leaf node on this 517 * level with dual rate private shaper support, which 518 * may not be the case for all the non-leaf nodes on 519 * this level. 520 */ 521 int shaper_private_dual_rate_supported; 522 523 /** Minimum committed/peak rate (bytes per second) for 524 * private shapers of the non-leaf nodes of this level. 525 * Valid only when private shaper is supported on this 526 * level. 527 */ 528 uint64_t shaper_private_rate_min; 529 530 /** Maximum committed/peak rate (bytes per second) for 531 * private shapers of the non-leaf nodes on this level. 532 * Valid only when private shaper is supported on this 533 * level. 534 */ 535 uint64_t shaper_private_rate_max; 536 537 /** Shaper private packet mode supported. When non-zero, 538 * this parameter indicates there is at least one 539 * non-leaf node at this level that can be configured 540 * with packet mode in its private shaper. When private 541 * shaper is configured in packet mode, committed/peak 542 * rate provided is interpreted in packets per second. 543 */ 544 int shaper_private_packet_mode_supported; 545 546 /** Shaper private byte mode supported. When non-zero, 547 * this parameter indicates there is at least one 548 * non-leaf node at this level that can be configured 549 * with byte mode in its private shaper. When private 550 * shaper is configured in byte mode, committed/peak 551 * rate provided is interpreted in bytes per second. 552 */ 553 int shaper_private_byte_mode_supported; 554 555 /** Maximum number of shared shapers that any non-leaf 556 * node on this level can be part of. The value of zero 557 * indicates that shared shapers are not supported by 558 * the non-leaf nodes on this level. When non-zero, it 559 * indicates there is at least one non-leaf node on this 560 * level that meets this condition, which may not be the 561 * case for all the non-leaf nodes on this level. 562 */ 563 uint32_t shaper_shared_n_max; 564 565 /** Shaper shared packet mode supported. When non-zero, 566 * this parameter indicates that there is at least one 567 * non-leaf node on this level that can be part of 568 * shared shapers which work in packet mode. 569 */ 570 int shaper_shared_packet_mode_supported; 571 572 /** Shaper shared byte mode supported. When non-zero, 573 * this parameter indicates that there is at least one 574 * non-leaf node on this level that can be part of 575 * shared shapers which work in byte mode. 576 */ 577 int shaper_shared_byte_mode_supported; 578 579 /** Maximum number of children nodes. This parameter 580 * indicates that there is at least one non-leaf node on 581 * this level that can be configured with this many 582 * children nodes, which might not be true for all the 583 * non-leaf nodes on this level. 584 */ 585 uint32_t sched_n_children_max; 586 587 /** Maximum number of supported priority levels. This 588 * parameter indicates that there is at least one 589 * non-leaf node on this level that can be configured 590 * with this many priority levels for managing its 591 * children nodes, which might not be true for all the 592 * non-leaf nodes on this level. The value of zero is 593 * invalid. The value of 1 indicates that only priority 594 * 0 is supported, which essentially means that Strict 595 * Priority (SP) algorithm is not supported on this 596 * level. 597 */ 598 uint32_t sched_sp_n_priorities_max; 599 600 /** Maximum number of sibling nodes that can have the 601 * same priority at any given time, i.e. maximum size of 602 * the WFQ sibling node group. This parameter indicates 603 * there is at least one non-leaf node on this level 604 * that meets this condition, which may not be true for 605 * all the non-leaf nodes on this level. The value of 606 * zero is invalid. The value of 1 indicates that WFQ 607 * algorithm is not supported on this level. The maximum 608 * value is *sched_n_children_max*. 609 */ 610 uint32_t sched_wfq_n_children_per_group_max; 611 612 /** Maximum number of priority levels that can have 613 * more than one child node at any given time, i.e. 614 * maximum number of WFQ sibling node groups that 615 * have two or more members. This parameter indicates 616 * there is at least one non-leaf node on this level 617 * that meets this condition, which might not be true 618 * for all the non-leaf nodes. The value of zero states 619 * that WFQ algorithm is not supported on this level. 620 * The value of 1 indicates that 621 * (*sched_sp_n_priorities_max* - 1) priority levels on 622 * this level have at most one child node, so there can 623 * be only one priority level with two or more sibling 624 * nodes making up a WFQ group on this level. The 625 * maximum value is: 626 * min(floor(*sched_n_children_max* / 2), 627 * *sched_sp_n_priorities_max*). 628 */ 629 uint32_t sched_wfq_n_groups_max; 630 631 /** Maximum WFQ weight. The value of 1 indicates that 632 * all sibling nodes on this level with same priority 633 * have the same WFQ weight, so on this level WFQ is 634 * reduced to FQ. 635 */ 636 uint32_t sched_wfq_weight_max; 637 638 /** WFQ packet mode supported. When non-zero, this 639 * parameter indicates that there is at least one 640 * non-leaf node at this level that supports packet 641 * mode for WFQ among its children. WFQ weights will 642 * be applied against packet count for scheduling 643 * children when a non-leaf node is configured 644 * appropriately. 645 */ 646 int sched_wfq_packet_mode_supported; 647 648 /** WFQ byte mode supported. When non-zero, this 649 * parameter indicates that there is at least one 650 * non-leaf node at this level that supports byte 651 * mode for WFQ among its children. WFQ weights will 652 * be applied against bytes for scheduling children 653 * when a non-leaf node is configured appropriately. 654 */ 655 int sched_wfq_byte_mode_supported; 656 657 /** Mask of statistics counter types supported by the 658 * non-leaf nodes on this level. Every supported 659 * statistics counter type is supported by at least one 660 * non-leaf node on this level, which may not be true 661 * for all the non-leaf nodes on this level. 662 * @see enum rte_tm_stats_type 663 */ 664 uint64_t stats_mask; 665 } nonleaf; 666 667 /** Items valid only for the leaf nodes on this level. */ 668 struct { 669 /** Private shaper support. When non-zero, it indicates 670 * there is at least one leaf node on this level with 671 * private shaper support, which may not be the case for 672 * all the leaf nodes on this level. 673 */ 674 int shaper_private_supported; 675 676 /** Dual rate support for private shaper. Valid only 677 * when private shaper is supported for the leaf nodes 678 * on this level. When non-zero, it indicates there is 679 * at least one leaf node on this level with dual rate 680 * private shaper support, which may not be the case for 681 * all the leaf nodes on this level. 682 */ 683 int shaper_private_dual_rate_supported; 684 685 /** Minimum committed/peak rate (bytes per second) for 686 * private shapers of the leaf nodes of this level. 687 * Valid only when private shaper is supported for the 688 * leaf nodes on this level. 689 */ 690 uint64_t shaper_private_rate_min; 691 692 /** Maximum committed/peak rate (bytes per second) for 693 * private shapers of the leaf nodes on this level. 694 * Valid only when private shaper is supported for the 695 * leaf nodes on this level. 696 */ 697 uint64_t shaper_private_rate_max; 698 699 /** Shaper private packet mode supported. When non-zero, 700 * this parameter indicates there is at least one leaf 701 * node at this level that can be configured with 702 * packet mode in its private shaper. When private 703 * shaper is configured in packet mode, committed/peak 704 * rate provided is interpreted in packets per second. 705 */ 706 int shaper_private_packet_mode_supported; 707 708 /** Shaper private byte mode supported. When non-zero, 709 * this parameter indicates there is at least one leaf 710 * node at this level that can be configured with 711 * byte mode in its private shaper. When private shaper 712 * is configured in byte mode, committed/peak rate 713 * provided is interpreted in bytes per second. 714 */ 715 int shaper_private_byte_mode_supported; 716 717 /** Maximum number of shared shapers that any leaf node 718 * on this level can be part of. The value of zero 719 * indicates that shared shapers are not supported by 720 * the leaf nodes on this level. When non-zero, it 721 * indicates there is at least one leaf node on this 722 * level that meets this condition, which may not be the 723 * case for all the leaf nodes on this level. 724 */ 725 uint32_t shaper_shared_n_max; 726 727 /** Shaper shared packet mode supported. When non-zero, 728 * this parameter indicates that there is at least one 729 * leaf node on this level that can be part of 730 * shared shapers which work in packet mode. 731 */ 732 int shaper_shared_packet_mode_supported; 733 734 /** Shaper shared byte mode supported. When non-zero, 735 * this parameter indicates that there is at least one 736 * leaf node on this level that can be part of 737 * shared shapers which work in byte mode. 738 */ 739 int shaper_shared_byte_mode_supported; 740 741 /** WRED packet mode support. When non-zero, this 742 * parameter indicates that there is at least one leaf 743 * node on this level that supports the WRED packet 744 * mode, which might not be true for all the leaf 745 * nodes. In packet mode, the WRED thresholds specify 746 * the queue length in packets, as opposed to bytes. 747 */ 748 int cman_wred_packet_mode_supported; 749 750 /** WRED byte mode support. When non-zero, this 751 * parameter indicates that there is at least one leaf 752 * node on this level that supports the WRED byte mode, 753 * which might not be true for all the leaf nodes. In 754 * byte mode, the WRED thresholds specify the queue 755 * length in bytes, as opposed to packets. 756 */ 757 int cman_wred_byte_mode_supported; 758 759 /** Head drop algorithm support. When non-zero, this 760 * parameter indicates that there is at least one leaf 761 * node on this level that supports the head drop 762 * algorithm, which might not be true for all the leaf 763 * nodes on this level. 764 */ 765 int cman_head_drop_supported; 766 767 /** Private WRED context support. When non-zero, it 768 * indicates there is at least one node on this level 769 * with private WRED context support, which may not be 770 * true for all the leaf nodes on this level. 771 */ 772 int cman_wred_context_private_supported; 773 774 /** Maximum number of shared WRED contexts that any 775 * leaf node on this level can be part of. The value of 776 * zero indicates that shared WRED contexts are not 777 * supported by the leaf nodes on this level. When 778 * non-zero, it indicates there is at least one leaf 779 * node on this level that meets this condition, which 780 * may not be the case for all the leaf nodes on this 781 * level. 782 */ 783 uint32_t cman_wred_context_shared_n_max; 784 785 /** Mask of statistics counter types supported by the 786 * leaf nodes on this level. Every supported statistics 787 * counter type is supported by at least one leaf node 788 * on this level, which may not be true for all the leaf 789 * nodes on this level. 790 * @see enum rte_tm_stats_type 791 */ 792 uint64_t stats_mask; 793 } leaf; 794 }; 795 }; 796 797 /** 798 * Traffic manager node capabilities 799 */ 800 struct rte_tm_node_capabilities { 801 /** Private shaper support for the current node. */ 802 int shaper_private_supported; 803 804 /** Dual rate shaping support for private shaper of current node. 805 * Valid only when private shaper is supported by the current node. 806 */ 807 int shaper_private_dual_rate_supported; 808 809 /** Minimum committed/peak rate (bytes per second) for private 810 * shaper of current node. Valid only when private shaper is supported 811 * by the current node. 812 */ 813 uint64_t shaper_private_rate_min; 814 815 /** Maximum committed/peak rate (bytes per second) for private 816 * shaper of current node. Valid only when private shaper is supported 817 * by the current node. 818 */ 819 uint64_t shaper_private_rate_max; 820 821 /** Shaper private packet mode supported. When non-zero, this parameter 822 * indicates private shaper of current node can be configured with 823 * packet mode. When configured in packet mode, committed/peak rate 824 * provided is interpreted in packets per second. 825 */ 826 int shaper_private_packet_mode_supported; 827 828 /** Shaper private byte mode supported. When non-zero, this parameter 829 * indicates private shaper of current node can be configured with 830 * byte mode. When configured in byte mode, committed/peak rate 831 * provided is interpreted in bytes per second. 832 */ 833 int shaper_private_byte_mode_supported; 834 835 /** Maximum number of shared shapers the current node can be part of. 836 * The value of zero indicates that shared shapers are not supported by 837 * the current node. 838 */ 839 uint32_t shaper_shared_n_max; 840 841 /** Shaper shared packet mode supported. When non-zero, 842 * this parameter indicates that current node can be part of 843 * shared shapers which work in packet mode. 844 */ 845 int shaper_shared_packet_mode_supported; 846 847 /** Shaper shared byte mode supported. When non-zero, 848 * this parameter indicates that current node can be part of 849 * shared shapers which work in byte mode. 850 */ 851 int shaper_shared_byte_mode_supported; 852 853 RTE_STD_C11 854 union { 855 /** Items valid only for non-leaf nodes. */ 856 struct { 857 /** Maximum number of children nodes. */ 858 uint32_t sched_n_children_max; 859 860 /** Maximum number of supported priority levels. The 861 * value of zero is invalid. The value of 1 indicates 862 * that only priority 0 is supported, which essentially 863 * means that Strict Priority (SP) algorithm is not 864 * supported. 865 */ 866 uint32_t sched_sp_n_priorities_max; 867 868 /** Maximum number of sibling nodes that can have the 869 * same priority at any given time, i.e. maximum size 870 * of the WFQ sibling node group. The value of zero 871 * is invalid. The value of 1 indicates that WFQ 872 * algorithm is not supported. The maximum value is 873 * *sched_n_children_max*. 874 */ 875 uint32_t sched_wfq_n_children_per_group_max; 876 877 /** Maximum number of priority levels that can have 878 * more than one child node at any given time, i.e. 879 * maximum number of WFQ sibling node groups that have 880 * two or more members. The value of zero states that 881 * WFQ algorithm is not supported. The value of 1 882 * indicates that (*sched_sp_n_priorities_max* - 1) 883 * priority levels have at most one child node, so there 884 * can be only one priority level with two or more 885 * sibling nodes making up a WFQ group. The maximum 886 * value is: min(floor(*sched_n_children_max* / 2), 887 * *sched_sp_n_priorities_max*). 888 */ 889 uint32_t sched_wfq_n_groups_max; 890 891 /** Maximum WFQ weight. The value of 1 indicates that 892 * all sibling nodes with same priority have the same 893 * WFQ weight, so WFQ is reduced to FQ. 894 */ 895 uint32_t sched_wfq_weight_max; 896 897 /** WFQ packet mode supported. When non-zero, this 898 * parameter indicates that current node supports packet 899 * mode for WFQ among its children. WFQ weights will be 900 * applied against packet count for scheduling children 901 * when configured appropriately. 902 */ 903 int sched_wfq_packet_mode_supported; 904 905 /** WFQ byte mode supported. When non-zero, this 906 * parameter indicates that current node supports byte 907 * mode for WFQ among its children. WFQ weights will be 908 * applied against bytes for scheduling children when 909 * configured appropriately. 910 */ 911 int sched_wfq_byte_mode_supported; 912 913 } nonleaf; 914 915 /** Items valid only for leaf nodes. */ 916 struct { 917 /** WRED packet mode support for current node. */ 918 int cman_wred_packet_mode_supported; 919 920 /** WRED byte mode support for current node. */ 921 int cman_wred_byte_mode_supported; 922 923 /** Head drop algorithm support for current node. */ 924 int cman_head_drop_supported; 925 926 /** Private WRED context support for current node. */ 927 int cman_wred_context_private_supported; 928 929 /** Maximum number of shared WRED contexts the current 930 * node can be part of. The value of zero indicates that 931 * shared WRED contexts are not supported by the current 932 * node. 933 */ 934 uint32_t cman_wred_context_shared_n_max; 935 } leaf; 936 }; 937 938 /** Mask of statistics counter types supported by the current node. 939 * @see enum rte_tm_stats_type 940 */ 941 uint64_t stats_mask; 942 }; 943 944 /** 945 * Congestion management (CMAN) mode 946 * 947 * This is used for controlling the admission of packets into a packet queue or 948 * group of packet queues on congestion. On request of writing a new packet 949 * into the current queue while the queue is full, the *tail drop* algorithm 950 * drops the new packet while leaving the queue unmodified, as opposed to *head 951 * drop* algorithm, which drops the packet at the head of the queue (the oldest 952 * packet waiting in the queue) and admits the new packet at the tail of the 953 * queue. 954 * 955 * The *Random Early Detection (RED)* algorithm works by proactively dropping 956 * more and more input packets as the queue occupancy builds up. When the queue 957 * is full or almost full, RED effectively works as *tail drop*. The *Weighted 958 * RED* algorithm uses a separate set of RED thresholds for each packet color. 959 */ 960 enum rte_tm_cman_mode { 961 RTE_TM_CMAN_TAIL_DROP = 0, /**< Tail drop */ 962 RTE_TM_CMAN_HEAD_DROP, /**< Head drop */ 963 RTE_TM_CMAN_WRED, /**< Weighted Random Early Detection (WRED) */ 964 }; 965 966 /** 967 * Random Early Detection (RED) profile 968 */ 969 struct rte_tm_red_params { 970 /** Minimum queue threshold */ 971 uint64_t min_th; 972 973 /** Maximum queue threshold */ 974 uint64_t max_th; 975 976 /** Inverse of packet marking probability maximum value (maxp), i.e. 977 * maxp_inv = 1 / maxp 978 */ 979 uint16_t maxp_inv; 980 981 /** Negated log2 of queue weight (wq), i.e. wq = 1 / (2 ^ wq_log2) */ 982 uint16_t wq_log2; 983 }; 984 985 /** 986 * Weighted RED (WRED) profile 987 * 988 * Multiple WRED contexts can share the same WRED profile. Each leaf node with 989 * WRED enabled as its congestion management mode has zero or one private WRED 990 * context (only one leaf node using it) and/or zero, one or several shared 991 * WRED contexts (multiple leaf nodes use the same WRED context). A private 992 * WRED context is used to perform congestion management for a single leaf 993 * node, while a shared WRED context is used to perform congestion management 994 * for a group of leaf nodes. 995 * 996 * @see struct rte_tm_capabilities::cman_wred_packet_mode_supported 997 * @see struct rte_tm_capabilities::cman_wred_byte_mode_supported 998 */ 999 struct rte_tm_wred_params { 1000 /** One set of RED parameters per packet color */ 1001 struct rte_tm_red_params red_params[RTE_COLORS]; 1002 1003 /** When non-zero, the *min_th* and *max_th* thresholds are specified 1004 * in packets (WRED packet mode). When zero, the *min_th* and *max_th* 1005 * thresholds are specified in bytes (WRED byte mode) 1006 */ 1007 int packet_mode; 1008 }; 1009 1010 /** 1011 * Token bucket 1012 */ 1013 struct rte_tm_token_bucket { 1014 /** Token bucket rate (bytes per second or packets per second) */ 1015 uint64_t rate; 1016 1017 /** Token bucket size (bytes or packets), a.k.a. max burst size */ 1018 uint64_t size; 1019 }; 1020 1021 /** 1022 * Shaper (rate limiter) profile 1023 * 1024 * Multiple shaper instances can share the same shaper profile. Each node has 1025 * zero or one private shaper (only one node using it) and/or zero, one or 1026 * several shared shapers (multiple nodes use the same shaper instance). 1027 * A private shaper is used to perform traffic shaping for a single node, while 1028 * a shared shaper is used to perform traffic shaping for a group of nodes. 1029 * 1030 * Single rate shapers use a single token bucket. A single rate shaper can be 1031 * configured by setting the rate of the committed bucket to zero, which 1032 * effectively disables this bucket. The peak bucket is used to limit the rate 1033 * and the burst size for the current shaper. 1034 * 1035 * Dual rate shapers use both the committed and the peak token buckets. The 1036 * rate of the peak bucket has to be bigger than zero, as well as greater than 1037 * or equal to the rate of the committed bucket. 1038 * 1039 * @see struct rte_tm_capabilities::shaper_private_packet_mode_supported 1040 * @see struct rte_tm_capabilities::shaper_private_byte_mode_supported 1041 * @see struct rte_tm_capabilities::shaper_shared_packet_mode_supported 1042 * @see struct rte_tm_capabilities::shaper_shared_byte_mode_supported 1043 */ 1044 struct rte_tm_shaper_params { 1045 /** Committed token bucket */ 1046 struct rte_tm_token_bucket committed; 1047 1048 /** Peak token bucket */ 1049 struct rte_tm_token_bucket peak; 1050 1051 /** Signed value to be added to the length of each packet for the 1052 * purpose of shaping. Can be used to correct the packet length with 1053 * the framing overhead bytes that are also consumed on the wire (e.g. 1054 * RTE_TM_ETH_FRAMING_OVERHEAD_FCS). 1055 * This field is ignored when the profile enables packet mode. 1056 */ 1057 int32_t pkt_length_adjust; 1058 1059 /** When zero, the byte mode is enabled for the current profile, so the 1060 * *rate* and *size* fields in both the committed and peak token buckets 1061 * are specified in bytes per second and bytes, respectively. 1062 * When non-zero, the packet mode is enabled for the current profile, 1063 * so the *rate* and *size* fields in both the committed and peak token 1064 * buckets are specified in packets per second and packets, 1065 * respectively. 1066 */ 1067 int packet_mode; 1068 }; 1069 1070 /** 1071 * Node parameters 1072 * 1073 * Each non-leaf node has multiple inputs (its children nodes) and single output 1074 * (which is input to its parent node). It arbitrates its inputs using Strict 1075 * Priority (SP) and Weighted Fair Queuing (WFQ) algorithms to schedule input 1076 * packets to its output while observing its shaping (rate limiting) 1077 * constraints. 1078 * 1079 * Algorithms such as Weighted Round Robin (WRR), Byte-level WRR, Deficit WRR 1080 * (DWRR), etc. are considered approximations of the WFQ ideal and are 1081 * assimilated to WFQ, although an associated implementation-dependent trade-off 1082 * on accuracy, performance and resource usage might exist. 1083 * 1084 * Children nodes with different priorities are scheduled using the SP algorithm 1085 * based on their priority, with zero (0) as the highest priority. Children with 1086 * the same priority are scheduled using the WFQ algorithm according to their 1087 * weights. The WFQ weight of a given child node is relative to the sum of the 1088 * weights of all its sibling nodes that have the same priority, with one (1) as 1089 * the lowest weight. For each SP priority, the WFQ weight mode can be set as 1090 * either byte-based or packet-based. 1091 * 1092 * Each leaf node sits on top of a Tx queue of the current Ethernet port. Hence, 1093 * the leaf nodes are predefined, with their node IDs set to 0 .. (N-1), where N 1094 * is the number of Tx queues configured for the current Ethernet port. The 1095 * non-leaf nodes have their IDs generated by the application. 1096 */ 1097 struct rte_tm_node_params { 1098 /** Shaper profile for the private shaper. The absence of the private 1099 * shaper for the current node is indicated by setting this parameter 1100 * to RTE_TM_SHAPER_PROFILE_ID_NONE. 1101 */ 1102 uint32_t shaper_profile_id; 1103 1104 /** User allocated array of valid shared shaper IDs. */ 1105 uint32_t *shared_shaper_id; 1106 1107 /** Number of shared shaper IDs in the *shared_shaper_id* array. */ 1108 uint32_t n_shared_shapers; 1109 1110 RTE_STD_C11 1111 union { 1112 /** Parameters only valid for non-leaf nodes. */ 1113 struct { 1114 /** WFQ weight mode for each SP priority. When NULL, it 1115 * indicates that WFQ is to be used for all priorities. 1116 * When non-NULL, it points to a pre-allocated array of 1117 * *n_sp_priorities* values, with non-zero value for 1118 * byte-mode and zero for packet-mode. 1119 * @see struct rte_tm_node_capabilities::sched_wfq_packet_mode_supported 1120 * @see struct rte_tm_node_capabilities::sched_wfq_byte_mode_supported 1121 */ 1122 int *wfq_weight_mode; 1123 1124 /** Number of SP priorities. */ 1125 uint32_t n_sp_priorities; 1126 } nonleaf; 1127 1128 /** Parameters only valid for leaf nodes. */ 1129 struct { 1130 /** Congestion management mode */ 1131 enum rte_tm_cman_mode cman; 1132 1133 /** WRED parameters (only valid when *cman* is set to 1134 * WRED). 1135 */ 1136 struct { 1137 /** WRED profile for private WRED context. The 1138 * absence of a private WRED context for the 1139 * current leaf node is indicated by value 1140 * RTE_TM_WRED_PROFILE_ID_NONE. 1141 */ 1142 uint32_t wred_profile_id; 1143 1144 /** User allocated array of shared WRED context 1145 * IDs. When set to NULL, it indicates that the 1146 * current leaf node should not currently be 1147 * part of any shared WRED contexts. 1148 */ 1149 uint32_t *shared_wred_context_id; 1150 1151 /** Number of elements in the 1152 * *shared_wred_context_id* array. Only valid 1153 * when *shared_wred_context_id* is non-NULL, 1154 * in which case it should be non-zero. 1155 */ 1156 uint32_t n_shared_wred_contexts; 1157 } wred; 1158 } leaf; 1159 }; 1160 1161 /** Mask of statistics counter types to be enabled for this node. This 1162 * needs to be a subset of the statistics counter types available for 1163 * the current node. Any statistics counter type not included in this 1164 * set is to be disabled for the current node. 1165 * @see enum rte_tm_stats_type 1166 */ 1167 uint64_t stats_mask; 1168 }; 1169 1170 /** 1171 * Verbose error types. 1172 * 1173 * Most of them provide the type of the object referenced by struct 1174 * rte_tm_error::cause. 1175 */ 1176 enum rte_tm_error_type { 1177 RTE_TM_ERROR_TYPE_NONE, /**< No error. */ 1178 RTE_TM_ERROR_TYPE_UNSPECIFIED, /**< Cause unspecified. */ 1179 RTE_TM_ERROR_TYPE_CAPABILITIES, 1180 RTE_TM_ERROR_TYPE_LEVEL_ID, 1181 RTE_TM_ERROR_TYPE_WRED_PROFILE, 1182 RTE_TM_ERROR_TYPE_WRED_PROFILE_GREEN, 1183 RTE_TM_ERROR_TYPE_WRED_PROFILE_YELLOW, 1184 RTE_TM_ERROR_TYPE_WRED_PROFILE_RED, 1185 RTE_TM_ERROR_TYPE_WRED_PROFILE_ID, 1186 RTE_TM_ERROR_TYPE_SHARED_WRED_CONTEXT_ID, 1187 RTE_TM_ERROR_TYPE_SHAPER_PROFILE, 1188 RTE_TM_ERROR_TYPE_SHAPER_PROFILE_COMMITTED_RATE, 1189 RTE_TM_ERROR_TYPE_SHAPER_PROFILE_COMMITTED_SIZE, 1190 RTE_TM_ERROR_TYPE_SHAPER_PROFILE_PEAK_RATE, 1191 RTE_TM_ERROR_TYPE_SHAPER_PROFILE_PEAK_SIZE, 1192 RTE_TM_ERROR_TYPE_SHAPER_PROFILE_PKT_ADJUST_LEN, 1193 RTE_TM_ERROR_TYPE_SHAPER_PROFILE_PACKET_MODE, 1194 RTE_TM_ERROR_TYPE_SHAPER_PROFILE_ID, 1195 RTE_TM_ERROR_TYPE_SHARED_SHAPER_ID, 1196 RTE_TM_ERROR_TYPE_NODE_PARENT_NODE_ID, 1197 RTE_TM_ERROR_TYPE_NODE_PRIORITY, 1198 RTE_TM_ERROR_TYPE_NODE_WEIGHT, 1199 RTE_TM_ERROR_TYPE_NODE_PARAMS, 1200 RTE_TM_ERROR_TYPE_NODE_PARAMS_SHAPER_PROFILE_ID, 1201 RTE_TM_ERROR_TYPE_NODE_PARAMS_SHARED_SHAPER_ID, 1202 RTE_TM_ERROR_TYPE_NODE_PARAMS_N_SHARED_SHAPERS, 1203 RTE_TM_ERROR_TYPE_NODE_PARAMS_WFQ_WEIGHT_MODE, 1204 RTE_TM_ERROR_TYPE_NODE_PARAMS_N_SP_PRIORITIES, 1205 RTE_TM_ERROR_TYPE_NODE_PARAMS_CMAN, 1206 RTE_TM_ERROR_TYPE_NODE_PARAMS_WRED_PROFILE_ID, 1207 RTE_TM_ERROR_TYPE_NODE_PARAMS_SHARED_WRED_CONTEXT_ID, 1208 RTE_TM_ERROR_TYPE_NODE_PARAMS_N_SHARED_WRED_CONTEXTS, 1209 RTE_TM_ERROR_TYPE_NODE_PARAMS_STATS, 1210 RTE_TM_ERROR_TYPE_NODE_ID, 1211 }; 1212 1213 /** 1214 * Verbose error structure definition. 1215 * 1216 * This object is normally allocated by applications and set by PMDs, the 1217 * message points to a constant string which does not need to be freed by 1218 * the application, however its pointer can be considered valid only as long 1219 * as its associated DPDK port remains configured. Closing the underlying 1220 * device or unloading the PMD invalidates it. 1221 * 1222 * Both cause and message may be NULL regardless of the error type. 1223 */ 1224 struct rte_tm_error { 1225 enum rte_tm_error_type type; /**< Cause field and error type. */ 1226 const void *cause; /**< Object responsible for the error. */ 1227 const char *message; /**< Human-readable error message. */ 1228 }; 1229 1230 /** 1231 * Traffic manager get number of leaf nodes 1232 * 1233 * Each leaf node sits on top of a Tx queue of the current Ethernet port. 1234 * Therefore, the set of leaf nodes is predefined, their number is always equal 1235 * to N (where N is the number of Tx queues configured for the current port) 1236 * and their IDs are 0 .. (N-1). 1237 * 1238 * @param[in] port_id 1239 * The port identifier of the Ethernet device. 1240 * @param[out] n_leaf_nodes 1241 * Number of leaf nodes for the current port. 1242 * @param[out] error 1243 * Error details. Filled in only on error, when not NULL. 1244 * @return 1245 * 0 on success, non-zero error code otherwise. 1246 */ 1247 __rte_experimental 1248 int 1249 rte_tm_get_number_of_leaf_nodes(uint16_t port_id, 1250 uint32_t *n_leaf_nodes, 1251 struct rte_tm_error *error); 1252 1253 /** 1254 * Traffic manager node ID validate and type (i.e. leaf or non-leaf) get 1255 * 1256 * The leaf nodes have predefined IDs in the range of 0 .. (N-1), where N is 1257 * the number of Tx queues of the current Ethernet port. The non-leaf nodes 1258 * have their IDs generated by the application outside of the above range, 1259 * which is reserved for leaf nodes. 1260 * 1261 * @param[in] port_id 1262 * The port identifier of the Ethernet device. 1263 * @param[in] node_id 1264 * Node ID value. Needs to be valid. 1265 * @param[out] is_leaf 1266 * Set to non-zero value when node is leaf and to zero otherwise (non-leaf). 1267 * @param[out] error 1268 * Error details. Filled in only on error, when not NULL. 1269 * @return 1270 * 0 on success, non-zero error code otherwise. 1271 */ 1272 __rte_experimental 1273 int 1274 rte_tm_node_type_get(uint16_t port_id, 1275 uint32_t node_id, 1276 int *is_leaf, 1277 struct rte_tm_error *error); 1278 1279 /** 1280 * Traffic manager capabilities get 1281 * 1282 * @param[in] port_id 1283 * The port identifier of the Ethernet device. 1284 * @param[out] cap 1285 * Traffic manager capabilities. Needs to be pre-allocated and valid. 1286 * @param[out] error 1287 * Error details. Filled in only on error, when not NULL. 1288 * @return 1289 * 0 on success, non-zero error code otherwise. 1290 */ 1291 __rte_experimental 1292 int 1293 rte_tm_capabilities_get(uint16_t port_id, 1294 struct rte_tm_capabilities *cap, 1295 struct rte_tm_error *error); 1296 1297 /** 1298 * Traffic manager level capabilities get 1299 * 1300 * @param[in] port_id 1301 * The port identifier of the Ethernet device. 1302 * @param[in] level_id 1303 * The hierarchy level identifier. The value of 0 identifies the level of the 1304 * root node. 1305 * @param[out] cap 1306 * Traffic manager level capabilities. Needs to be pre-allocated and valid. 1307 * @param[out] error 1308 * Error details. Filled in only on error, when not NULL. 1309 * @return 1310 * 0 on success, non-zero error code otherwise. 1311 */ 1312 __rte_experimental 1313 int 1314 rte_tm_level_capabilities_get(uint16_t port_id, 1315 uint32_t level_id, 1316 struct rte_tm_level_capabilities *cap, 1317 struct rte_tm_error *error); 1318 1319 /** 1320 * Traffic manager node capabilities get 1321 * 1322 * @param[in] port_id 1323 * The port identifier of the Ethernet device. 1324 * @param[in] node_id 1325 * Node ID. Needs to be valid. 1326 * @param[out] cap 1327 * Traffic manager node capabilities. Needs to be pre-allocated and valid. 1328 * @param[out] error 1329 * Error details. Filled in only on error, when not NULL. 1330 * @return 1331 * 0 on success, non-zero error code otherwise. 1332 */ 1333 __rte_experimental 1334 int 1335 rte_tm_node_capabilities_get(uint16_t port_id, 1336 uint32_t node_id, 1337 struct rte_tm_node_capabilities *cap, 1338 struct rte_tm_error *error); 1339 1340 /** 1341 * Traffic manager WRED profile add 1342 * 1343 * Create a new WRED profile with ID set to *wred_profile_id*. The new profile 1344 * is used to create one or several WRED contexts. 1345 * 1346 * @param[in] port_id 1347 * The port identifier of the Ethernet device. 1348 * @param[in] wred_profile_id 1349 * WRED profile ID for the new profile. Needs to be unused. 1350 * @param[in] profile 1351 * WRED profile parameters. Needs to be pre-allocated and valid. 1352 * @param[out] error 1353 * Error details. Filled in only on error, when not NULL. 1354 * @return 1355 * 0 on success, non-zero error code otherwise. 1356 * 1357 * @see struct rte_tm_capabilities::cman_wred_context_n_max 1358 */ 1359 __rte_experimental 1360 int 1361 rte_tm_wred_profile_add(uint16_t port_id, 1362 uint32_t wred_profile_id, 1363 struct rte_tm_wred_params *profile, 1364 struct rte_tm_error *error); 1365 1366 /** 1367 * Traffic manager WRED profile delete 1368 * 1369 * Delete an existing WRED profile. This operation fails when there is 1370 * currently at least one user (i.e. WRED context) of this WRED profile. 1371 * 1372 * @param[in] port_id 1373 * The port identifier of the Ethernet device. 1374 * @param[in] wred_profile_id 1375 * WRED profile ID. Needs to be the valid. 1376 * @param[out] error 1377 * Error details. Filled in only on error, when not NULL. 1378 * @return 1379 * 0 on success, non-zero error code otherwise. 1380 * 1381 * @see struct rte_tm_capabilities::cman_wred_context_n_max 1382 */ 1383 __rte_experimental 1384 int 1385 rte_tm_wred_profile_delete(uint16_t port_id, 1386 uint32_t wred_profile_id, 1387 struct rte_tm_error *error); 1388 1389 /** 1390 * Traffic manager shared WRED context add or update 1391 * 1392 * When *shared_wred_context_id* is invalid, a new WRED context with this ID is 1393 * created by using the WRED profile identified by *wred_profile_id*. 1394 * 1395 * When *shared_wred_context_id* is valid, this WRED context is no longer using 1396 * the profile previously assigned to it and is updated to use the profile 1397 * identified by *wred_profile_id*. 1398 * 1399 * A valid shared WRED context can be assigned to several hierarchy leaf nodes 1400 * configured to use WRED as the congestion management mode. 1401 * 1402 * @param[in] port_id 1403 * The port identifier of the Ethernet device. 1404 * @param[in] shared_wred_context_id 1405 * Shared WRED context ID 1406 * @param[in] wred_profile_id 1407 * WRED profile ID. Needs to be the valid. 1408 * @param[out] error 1409 * Error details. Filled in only on error, when not NULL. 1410 * @return 1411 * 0 on success, non-zero error code otherwise. 1412 * 1413 * @see struct rte_tm_capabilities::cman_wred_context_shared_n_max 1414 */ 1415 __rte_experimental 1416 int 1417 rte_tm_shared_wred_context_add_update(uint16_t port_id, 1418 uint32_t shared_wred_context_id, 1419 uint32_t wred_profile_id, 1420 struct rte_tm_error *error); 1421 1422 /** 1423 * Traffic manager shared WRED context delete 1424 * 1425 * Delete an existing shared WRED context. This operation fails when there is 1426 * currently at least one user (i.e. hierarchy leaf node) of this shared WRED 1427 * context. 1428 * 1429 * @param[in] port_id 1430 * The port identifier of the Ethernet device. 1431 * @param[in] shared_wred_context_id 1432 * Shared WRED context ID. Needs to be the valid. 1433 * @param[out] error 1434 * Error details. Filled in only on error, when not NULL. 1435 * @return 1436 * 0 on success, non-zero error code otherwise. 1437 * 1438 * @see struct rte_tm_capabilities::cman_wred_context_shared_n_max 1439 */ 1440 __rte_experimental 1441 int 1442 rte_tm_shared_wred_context_delete(uint16_t port_id, 1443 uint32_t shared_wred_context_id, 1444 struct rte_tm_error *error); 1445 1446 /** 1447 * Traffic manager shaper profile add 1448 * 1449 * Create a new shaper profile with ID set to *shaper_profile_id*. The new 1450 * shaper profile is used to create one or several shapers. 1451 * 1452 * @param[in] port_id 1453 * The port identifier of the Ethernet device. 1454 * @param[in] shaper_profile_id 1455 * Shaper profile ID for the new profile. Needs to be unused. 1456 * @param[in] profile 1457 * Shaper profile parameters. Needs to be pre-allocated and valid. 1458 * @param[out] error 1459 * Error details. Filled in only on error, when not NULL. 1460 * @return 1461 * 0 on success, non-zero error code otherwise. 1462 * 1463 * @see struct rte_tm_capabilities::shaper_n_max 1464 */ 1465 __rte_experimental 1466 int 1467 rte_tm_shaper_profile_add(uint16_t port_id, 1468 uint32_t shaper_profile_id, 1469 struct rte_tm_shaper_params *profile, 1470 struct rte_tm_error *error); 1471 1472 /** 1473 * Traffic manager shaper profile delete 1474 * 1475 * Delete an existing shaper profile. This operation fails when there is 1476 * currently at least one user (i.e. shaper) of this shaper profile. 1477 * 1478 * @param[in] port_id 1479 * The port identifier of the Ethernet device. 1480 * @param[in] shaper_profile_id 1481 * Shaper profile ID. Needs to be the valid. 1482 * @param[out] error 1483 * Error details. Filled in only on error, when not NULL. 1484 * @return 1485 * 0 on success, non-zero error code otherwise. 1486 * 1487 * @see struct rte_tm_capabilities::shaper_n_max 1488 */ 1489 __rte_experimental 1490 int 1491 rte_tm_shaper_profile_delete(uint16_t port_id, 1492 uint32_t shaper_profile_id, 1493 struct rte_tm_error *error); 1494 1495 /** 1496 * Traffic manager shared shaper add or update 1497 * 1498 * When *shared_shaper_id* is not a valid shared shaper ID, a new shared shaper 1499 * with this ID is created using the shaper profile identified by 1500 * *shaper_profile_id*. 1501 * 1502 * When *shared_shaper_id* is a valid shared shaper ID, this shared shaper is 1503 * no longer using the shaper profile previously assigned to it and is updated 1504 * to use the shaper profile identified by *shaper_profile_id*. 1505 * 1506 * @param[in] port_id 1507 * The port identifier of the Ethernet device. 1508 * @param[in] shared_shaper_id 1509 * Shared shaper ID 1510 * @param[in] shaper_profile_id 1511 * Shaper profile ID. Needs to be the valid. 1512 * @param[out] error 1513 * Error details. Filled in only on error, when not NULL. 1514 * @return 1515 * 0 on success, non-zero error code otherwise. 1516 * 1517 * @see struct rte_tm_capabilities::shaper_shared_n_max 1518 */ 1519 __rte_experimental 1520 int 1521 rte_tm_shared_shaper_add_update(uint16_t port_id, 1522 uint32_t shared_shaper_id, 1523 uint32_t shaper_profile_id, 1524 struct rte_tm_error *error); 1525 1526 /** 1527 * Traffic manager shared shaper delete 1528 * 1529 * Delete an existing shared shaper. This operation fails when there is 1530 * currently at least one user (i.e. hierarchy node) of this shared shaper. 1531 * 1532 * @param[in] port_id 1533 * The port identifier of the Ethernet device. 1534 * @param[in] shared_shaper_id 1535 * Shared shaper ID. Needs to be the valid. 1536 * @param[out] error 1537 * Error details. Filled in only on error, when not NULL. 1538 * @return 1539 * 0 on success, non-zero error code otherwise. 1540 * 1541 * @see struct rte_tm_capabilities::shaper_shared_n_max 1542 */ 1543 __rte_experimental 1544 int 1545 rte_tm_shared_shaper_delete(uint16_t port_id, 1546 uint32_t shared_shaper_id, 1547 struct rte_tm_error *error); 1548 1549 /** 1550 * Traffic manager node add 1551 * 1552 * Create new node and connect it as child of an existing node. The new node is 1553 * further identified by *node_id*, which needs to be unused by any of the 1554 * existing nodes. The parent node is identified by *parent_node_id*, which 1555 * needs to be the valid ID of an existing non-leaf node. The parent node is 1556 * going to use the provided SP *priority* and WFQ *weight* to schedule its new 1557 * child node. 1558 * 1559 * This function has to be called for both leaf and non-leaf nodes. In the case 1560 * of leaf nodes (i.e. *node_id* is within the range of 0 .. (N-1), with N as 1561 * the number of configured Tx queues of the current port), the leaf node is 1562 * configured rather than created (as the set of leaf nodes is predefined) and 1563 * it is also connected as child of an existing node. 1564 * 1565 * The first node that is added becomes the root node and all the nodes that 1566 * are subsequently added have to be added as descendants of the root node. The 1567 * parent of the root node has to be specified as RTE_TM_NODE_ID_NULL and there 1568 * can only be one node with this parent ID (i.e. the root node). Further 1569 * restrictions for root node: needs to be non-leaf, its private shaper profile 1570 * needs to be valid and single rate, cannot use any shared shapers. 1571 * 1572 * When called before rte_tm_hierarchy_commit() invocation, this function is 1573 * typically used to define the initial start-up hierarchy for the port. 1574 * Provided that dynamic hierarchy updates are supported by the current port (as 1575 * advertised in the port capability set), this function can be also called 1576 * after the rte_tm_hierarchy_commit() invocation. 1577 * 1578 * @param[in] port_id 1579 * The port identifier of the Ethernet device. 1580 * @param[in] node_id 1581 * Node ID. Needs to be unused by any of the existing nodes. 1582 * @param[in] parent_node_id 1583 * Parent node ID. Needs to be the valid. 1584 * @param[in] priority 1585 * Node priority. The highest node priority is zero. Used by the SP algorithm 1586 * running on the parent of the current node for scheduling this child node. 1587 * @param[in] weight 1588 * Node weight. The node weight is relative to the weight sum of all siblings 1589 * that have the same priority. The lowest weight is one. Used by the WFQ 1590 * algorithm running on the parent of the current node for scheduling this 1591 * child node. 1592 * @param[in] level_id 1593 * Level ID that should be met by this node. The hierarchy level of the 1594 * current node is already fully specified through its parent node (i.e. the 1595 * level of this node is equal to the level of its parent node plus one), 1596 * therefore the reason for providing this parameter is to enable the 1597 * application to perform step-by-step checking of the node level during 1598 * successive invocations of this function. When not desired, this check can 1599 * be disabled by assigning value RTE_TM_NODE_LEVEL_ID_ANY to this parameter. 1600 * @param[in] params 1601 * Node parameters. Needs to be pre-allocated and valid. 1602 * @param[out] error 1603 * Error details. Filled in only on error, when not NULL. 1604 * @return 1605 * 0 on success, non-zero error code otherwise. 1606 * 1607 * @see rte_tm_hierarchy_commit() 1608 * @see RTE_TM_UPDATE_NODE_ADD_DELETE 1609 * @see RTE_TM_NODE_LEVEL_ID_ANY 1610 * @see struct rte_tm_capabilities 1611 */ 1612 __rte_experimental 1613 int 1614 rte_tm_node_add(uint16_t port_id, 1615 uint32_t node_id, 1616 uint32_t parent_node_id, 1617 uint32_t priority, 1618 uint32_t weight, 1619 uint32_t level_id, 1620 struct rte_tm_node_params *params, 1621 struct rte_tm_error *error); 1622 1623 /** 1624 * Traffic manager node delete 1625 * 1626 * Delete an existing node. This operation fails when this node currently has 1627 * at least one user (i.e. child node). 1628 * 1629 * When called before rte_tm_hierarchy_commit() invocation, this function is 1630 * typically used to define the initial start-up hierarchy for the port. 1631 * Provided that dynamic hierarchy updates are supported by the current port (as 1632 * advertised in the port capability set), this function can be also called 1633 * after the rte_tm_hierarchy_commit() invocation. 1634 * 1635 * @param[in] port_id 1636 * The port identifier of the Ethernet device. 1637 * @param[in] node_id 1638 * Node ID. Needs to be valid. 1639 * @param[out] error 1640 * Error details. Filled in only on error, when not NULL. 1641 * @return 1642 * 0 on success, non-zero error code otherwise. 1643 * 1644 * @see RTE_TM_UPDATE_NODE_ADD_DELETE 1645 */ 1646 __rte_experimental 1647 int 1648 rte_tm_node_delete(uint16_t port_id, 1649 uint32_t node_id, 1650 struct rte_tm_error *error); 1651 1652 /** 1653 * Traffic manager node suspend 1654 * 1655 * Suspend an existing node. While the node is in suspended state, no packet is 1656 * scheduled from this node and its descendants. The node exits the suspended 1657 * state through the node resume operation. 1658 * 1659 * @param[in] port_id 1660 * The port identifier of the Ethernet device. 1661 * @param[in] node_id 1662 * Node ID. Needs to be valid. 1663 * @param[out] error 1664 * Error details. Filled in only on error, when not NULL. 1665 * @return 1666 * 0 on success, non-zero error code otherwise. 1667 * 1668 * @see rte_tm_node_resume() 1669 * @see RTE_TM_UPDATE_NODE_SUSPEND_RESUME 1670 */ 1671 __rte_experimental 1672 int 1673 rte_tm_node_suspend(uint16_t port_id, 1674 uint32_t node_id, 1675 struct rte_tm_error *error); 1676 1677 /** 1678 * Traffic manager node resume 1679 * 1680 * Resume an existing node that is currently in suspended state. The node 1681 * entered the suspended state as result of a previous node suspend operation. 1682 * 1683 * @param[in] port_id 1684 * The port identifier of the Ethernet device. 1685 * @param[in] node_id 1686 * Node ID. Needs to be valid. 1687 * @param[out] error 1688 * Error details. Filled in only on error, when not NULL. 1689 * @return 1690 * 0 on success, non-zero error code otherwise. 1691 * 1692 * @see rte_tm_node_suspend() 1693 * @see RTE_TM_UPDATE_NODE_SUSPEND_RESUME 1694 */ 1695 __rte_experimental 1696 int 1697 rte_tm_node_resume(uint16_t port_id, 1698 uint32_t node_id, 1699 struct rte_tm_error *error); 1700 1701 /** 1702 * Traffic manager hierarchy commit 1703 * 1704 * This function is called during the port initialization phase (before the 1705 * Ethernet port is started) to freeze the start-up hierarchy. 1706 * 1707 * This function typically performs the following steps: 1708 * a) It validates the start-up hierarchy that was previously defined for the 1709 * current port through successive rte_tm_node_add() invocations; 1710 * b) Assuming successful validation, it performs all the necessary port 1711 * specific configuration operations to install the specified hierarchy on 1712 * the current port, with immediate effect once the port is started. 1713 * 1714 * This function fails when the currently configured hierarchy is not supported 1715 * by the Ethernet port, in which case the user can abort or try out another 1716 * hierarchy configuration (e.g. a hierarchy with less leaf nodes), which can be 1717 * build from scratch (when *clear_on_fail* is enabled) or by modifying the 1718 * existing hierarchy configuration (when *clear_on_fail* is disabled). 1719 * 1720 * Note that this function can still fail due to other causes (e.g. not enough 1721 * memory available in the system, etc), even though the specified hierarchy is 1722 * supported in principle by the current port. 1723 * 1724 * @param[in] port_id 1725 * The port identifier of the Ethernet device. 1726 * @param[in] clear_on_fail 1727 * On function call failure, hierarchy is cleared when this parameter is 1728 * non-zero and preserved when this parameter is equal to zero. 1729 * @param[out] error 1730 * Error details. Filled in only on error, when not NULL. 1731 * @return 1732 * 0 on success, non-zero error code otherwise. 1733 * 1734 * @see rte_tm_node_add() 1735 * @see rte_tm_node_delete() 1736 */ 1737 __rte_experimental 1738 int 1739 rte_tm_hierarchy_commit(uint16_t port_id, 1740 int clear_on_fail, 1741 struct rte_tm_error *error); 1742 1743 /** 1744 * Traffic manager node parent update 1745 * 1746 * This function may be used to move a node and its children to a different 1747 * parent. Additionally, if the new parent is the same as the current parent, 1748 * this function will update the priority/weight of an existing node. 1749 * 1750 * Restriction for root node: its parent cannot be changed. 1751 * 1752 * This function can only be called after the rte_tm_hierarchy_commit() 1753 * invocation. Its success depends on the port support for this operation, as 1754 * advertised through the port capability set. 1755 * 1756 * @param[in] port_id 1757 * The port identifier of the Ethernet device. 1758 * @param[in] node_id 1759 * Node ID. Needs to be valid. 1760 * @param[in] parent_node_id 1761 * Node ID for the new parent. Needs to be valid. 1762 * @param[in] priority 1763 * Node priority. The highest node priority is zero. Used by the SP algorithm 1764 * running on the parent of the current node for scheduling this child node. 1765 * @param[in] weight 1766 * Node weight. The node weight is relative to the weight sum of all siblings 1767 * that have the same priority. The lowest weight is zero. Used by the WFQ 1768 * algorithm running on the parent of the current node for scheduling this 1769 * child node. 1770 * @param[out] error 1771 * Error details. Filled in only on error, when not NULL. 1772 * @return 1773 * 0 on success, non-zero error code otherwise. 1774 * 1775 * @see RTE_TM_UPDATE_NODE_PARENT_KEEP_LEVEL 1776 * @see RTE_TM_UPDATE_NODE_PARENT_CHANGE_LEVEL 1777 */ 1778 __rte_experimental 1779 int 1780 rte_tm_node_parent_update(uint16_t port_id, 1781 uint32_t node_id, 1782 uint32_t parent_node_id, 1783 uint32_t priority, 1784 uint32_t weight, 1785 struct rte_tm_error *error); 1786 1787 /** 1788 * Traffic manager node private shaper update 1789 * 1790 * Restriction for the root node: its private shaper profile needs to be valid 1791 * and single rate. 1792 * 1793 * @param[in] port_id 1794 * The port identifier of the Ethernet device. 1795 * @param[in] node_id 1796 * Node ID. Needs to be valid. 1797 * @param[in] shaper_profile_id 1798 * Shaper profile ID for the private shaper of the current node. Needs to be 1799 * either valid shaper profile ID or RTE_TM_SHAPER_PROFILE_ID_NONE, with 1800 * the latter disabling the private shaper of the current node. 1801 * @param[out] error 1802 * Error details. Filled in only on error, when not NULL. 1803 * @return 1804 * 0 on success, non-zero error code otherwise. 1805 * 1806 * @see struct rte_tm_capabilities::shaper_private_n_max 1807 */ 1808 __rte_experimental 1809 int 1810 rte_tm_node_shaper_update(uint16_t port_id, 1811 uint32_t node_id, 1812 uint32_t shaper_profile_id, 1813 struct rte_tm_error *error); 1814 1815 /** 1816 * Traffic manager node shared shapers update 1817 * 1818 * Restriction for root node: cannot use any shared rate shapers. 1819 * 1820 * @param[in] port_id 1821 * The port identifier of the Ethernet device. 1822 * @param[in] node_id 1823 * Node ID. Needs to be valid. 1824 * @param[in] shared_shaper_id 1825 * Shared shaper ID. Needs to be valid. 1826 * @param[in] add 1827 * Set to non-zero value to add this shared shaper to current node or to zero 1828 * to delete this shared shaper from current node. 1829 * @param[out] error 1830 * Error details. Filled in only on error, when not NULL. 1831 * @return 1832 * 0 on success, non-zero error code otherwise. 1833 * 1834 * @see struct rte_tm_capabilities::shaper_shared_n_max 1835 */ 1836 __rte_experimental 1837 int 1838 rte_tm_node_shared_shaper_update(uint16_t port_id, 1839 uint32_t node_id, 1840 uint32_t shared_shaper_id, 1841 int add, 1842 struct rte_tm_error *error); 1843 1844 /** 1845 * Traffic manager node enabled statistics counters update 1846 * 1847 * @param[in] port_id 1848 * The port identifier of the Ethernet device. 1849 * @param[in] node_id 1850 * Node ID. Needs to be valid. 1851 * @param[in] stats_mask 1852 * Mask of statistics counter types to be enabled for the current node. This 1853 * needs to be a subset of the statistics counter types available for the 1854 * current node. Any statistics counter type not included in this set is to 1855 * be disabled for the current node. 1856 * @param[out] error 1857 * Error details. Filled in only on error, when not NULL. 1858 * @return 1859 * 0 on success, non-zero error code otherwise. 1860 * 1861 * @see enum rte_tm_stats_type 1862 * @see RTE_TM_UPDATE_NODE_STATS 1863 */ 1864 __rte_experimental 1865 int 1866 rte_tm_node_stats_update(uint16_t port_id, 1867 uint32_t node_id, 1868 uint64_t stats_mask, 1869 struct rte_tm_error *error); 1870 1871 /** 1872 * Traffic manager node WFQ weight mode update 1873 * 1874 * @param[in] port_id 1875 * The port identifier of the Ethernet device. 1876 * @param[in] node_id 1877 * Node ID. Needs to be valid non-leaf node ID. 1878 * @param[in] wfq_weight_mode 1879 * WFQ weight mode for each SP priority. When NULL, it indicates that WFQ is 1880 * to be used for all priorities. When non-NULL, it points to a pre-allocated 1881 * array of *n_sp_priorities* values, with non-zero value for byte-mode and 1882 * zero for packet-mode. 1883 * @param[in] n_sp_priorities 1884 * Number of SP priorities. 1885 * @param[out] error 1886 * Error details. Filled in only on error, when not NULL. 1887 * @return 1888 * 0 on success, non-zero error code otherwise. 1889 * 1890 * @see RTE_TM_UPDATE_NODE_WFQ_WEIGHT_MODE 1891 * @see RTE_TM_UPDATE_NODE_N_SP_PRIORITIES 1892 */ 1893 __rte_experimental 1894 int 1895 rte_tm_node_wfq_weight_mode_update(uint16_t port_id, 1896 uint32_t node_id, 1897 int *wfq_weight_mode, 1898 uint32_t n_sp_priorities, 1899 struct rte_tm_error *error); 1900 1901 /** 1902 * Traffic manager node congestion management mode update 1903 * 1904 * @param[in] port_id 1905 * The port identifier of the Ethernet device. 1906 * @param[in] node_id 1907 * Node ID. Needs to be valid leaf node ID. 1908 * @param[in] cman 1909 * Congestion management mode. 1910 * @param[out] error 1911 * Error details. Filled in only on error, when not NULL. 1912 * @return 1913 * 0 on success, non-zero error code otherwise. 1914 * 1915 * @see RTE_TM_UPDATE_NODE_CMAN 1916 */ 1917 __rte_experimental 1918 int 1919 rte_tm_node_cman_update(uint16_t port_id, 1920 uint32_t node_id, 1921 enum rte_tm_cman_mode cman, 1922 struct rte_tm_error *error); 1923 1924 /** 1925 * Traffic manager node private WRED context update 1926 * 1927 * @param[in] port_id 1928 * The port identifier of the Ethernet device. 1929 * @param[in] node_id 1930 * Node ID. Needs to be valid leaf node ID. 1931 * @param[in] wred_profile_id 1932 * WRED profile ID for the private WRED context of the current node. Needs to 1933 * be either valid WRED profile ID or RTE_TM_WRED_PROFILE_ID_NONE, with the 1934 * latter disabling the private WRED context of the current node. 1935 * @param[out] error 1936 * Error details. Filled in only on error, when not NULL. 1937 * @return 1938 * 0 on success, non-zero error code otherwise. 1939 * 1940 * @see struct rte_tm_capabilities::cman_wred_context_private_n_max 1941 */ 1942 __rte_experimental 1943 int 1944 rte_tm_node_wred_context_update(uint16_t port_id, 1945 uint32_t node_id, 1946 uint32_t wred_profile_id, 1947 struct rte_tm_error *error); 1948 1949 /** 1950 * Traffic manager node shared WRED context update 1951 * 1952 * @param[in] port_id 1953 * The port identifier of the Ethernet device. 1954 * @param[in] node_id 1955 * Node ID. Needs to be valid leaf node ID. 1956 * @param[in] shared_wred_context_id 1957 * Shared WRED context ID. Needs to be valid. 1958 * @param[in] add 1959 * Set to non-zero value to add this shared WRED context to current node or 1960 * to zero to delete this shared WRED context from current node. 1961 * @param[out] error 1962 * Error details. Filled in only on error, when not NULL. 1963 * @return 1964 * 0 on success, non-zero error code otherwise. 1965 * 1966 * @see struct rte_tm_capabilities::cman_wred_context_shared_n_max 1967 */ 1968 __rte_experimental 1969 int 1970 rte_tm_node_shared_wred_context_update(uint16_t port_id, 1971 uint32_t node_id, 1972 uint32_t shared_wred_context_id, 1973 int add, 1974 struct rte_tm_error *error); 1975 1976 /** 1977 * Traffic manager node statistics counters read 1978 * 1979 * @param[in] port_id 1980 * The port identifier of the Ethernet device. 1981 * @param[in] node_id 1982 * Node ID. Needs to be valid. 1983 * @param[out] stats 1984 * When non-NULL, it contains the current value for the statistics counters 1985 * enabled for the current node. 1986 * @param[out] stats_mask 1987 * When non-NULL, it contains the mask of statistics counter types that are 1988 * currently enabled for this node, indicating which of the counters 1989 * retrieved with the *stats* structure are valid. 1990 * @param[in] clear 1991 * When this parameter has a non-zero value, the statistics counters are 1992 * cleared (i.e. set to zero) immediately after they have been read, 1993 * otherwise the statistics counters are left untouched. 1994 * @param[out] error 1995 * Error details. Filled in only on error, when not NULL. 1996 * @return 1997 * 0 on success, non-zero error code otherwise. 1998 * 1999 * @see enum rte_tm_stats_type 2000 */ 2001 __rte_experimental 2002 int 2003 rte_tm_node_stats_read(uint16_t port_id, 2004 uint32_t node_id, 2005 struct rte_tm_node_stats *stats, 2006 uint64_t *stats_mask, 2007 int clear, 2008 struct rte_tm_error *error); 2009 2010 /** 2011 * Traffic manager packet marking - VLAN DEI (IEEE 802.1Q) 2012 * 2013 * IEEE 802.1p maps the traffic class to the VLAN Priority Code Point (PCP) 2014 * field (3 bits), while IEEE 802.1q maps the drop priority to the VLAN Drop 2015 * Eligible Indicator (DEI) field (1 bit), which was previously named Canonical 2016 * Format Indicator (CFI). 2017 * 2018 * All VLAN frames of a given color get their DEI bit set if marking is enabled 2019 * for this color; otherwise, their DEI bit is left as is (either set or not). 2020 * 2021 * @param[in] port_id 2022 * The port identifier of the Ethernet device. 2023 * @param[in] mark_green 2024 * Set to non-zero value to enable marking of green packets and to zero to 2025 * disable it. 2026 * @param[in] mark_yellow 2027 * Set to non-zero value to enable marking of yellow packets and to zero to 2028 * disable it. 2029 * @param[in] mark_red 2030 * Set to non-zero value to enable marking of red packets and to zero to 2031 * disable it. 2032 * @param[out] error 2033 * Error details. Filled in only on error, when not NULL. 2034 * @return 2035 * 0 on success, non-zero error code otherwise. 2036 * 2037 * @see struct rte_tm_capabilities::mark_vlan_dei_supported 2038 */ 2039 __rte_experimental 2040 int 2041 rte_tm_mark_vlan_dei(uint16_t port_id, 2042 int mark_green, 2043 int mark_yellow, 2044 int mark_red, 2045 struct rte_tm_error *error); 2046 2047 /** 2048 * Traffic manager packet marking - IPv4 / IPv6 ECN (IETF RFC 3168) 2049 * 2050 * IETF RFCs 2474 and 3168 reorganize the IPv4 Type of Service (TOS) field 2051 * (8 bits) and the IPv6 Traffic Class (TC) field (8 bits) into Differentiated 2052 * Services Codepoint (DSCP) field (6 bits) and Explicit Congestion 2053 * Notification (ECN) field (2 bits). The DSCP field is typically used to 2054 * encode the traffic class and/or drop priority (RFC 2597), while the ECN 2055 * field is used by RFC 3168 to implement a congestion notification mechanism 2056 * to be leveraged by transport layer protocols such as TCP and SCTP that have 2057 * congestion control mechanisms. 2058 * 2059 * When congestion is experienced, as alternative to dropping the packet, 2060 * routers can change the ECN field of input packets from 2'b01 or 2'b10 2061 * (values indicating that source endpoint is ECN-capable) to 2'b11 (meaning 2062 * that congestion is experienced). The destination endpoint can use the 2063 * ECN-Echo (ECE) TCP flag to relay the congestion indication back to the 2064 * source endpoint, which acknowledges it back to the destination endpoint with 2065 * the Congestion Window Reduced (CWR) TCP flag. 2066 * 2067 * All IPv4/IPv6 packets of a given color with ECN set to 2’b01 or 2’b10 2068 * carrying TCP or SCTP have their ECN set to 2’b11 if the marking feature is 2069 * enabled for the current color, otherwise the ECN field is left as is. 2070 * 2071 * @param[in] port_id 2072 * The port identifier of the Ethernet device. 2073 * @param[in] mark_green 2074 * Set to non-zero value to enable marking of green packets and to zero to 2075 * disable it. 2076 * @param[in] mark_yellow 2077 * Set to non-zero value to enable marking of yellow packets and to zero to 2078 * disable it. 2079 * @param[in] mark_red 2080 * Set to non-zero value to enable marking of red packets and to zero to 2081 * disable it. 2082 * @param[out] error 2083 * Error details. Filled in only on error, when not NULL. 2084 * @return 2085 * 0 on success, non-zero error code otherwise. 2086 * 2087 * @see struct rte_tm_capabilities::mark_ip_ecn_tcp_supported 2088 * @see struct rte_tm_capabilities::mark_ip_ecn_sctp_supported 2089 */ 2090 __rte_experimental 2091 int 2092 rte_tm_mark_ip_ecn(uint16_t port_id, 2093 int mark_green, 2094 int mark_yellow, 2095 int mark_red, 2096 struct rte_tm_error *error); 2097 2098 /** 2099 * Traffic manager packet marking - IPv4 / IPv6 DSCP (IETF RFC 2597) 2100 * 2101 * IETF RFC 2597 maps the traffic class and the drop priority to the IPv4/IPv6 2102 * Differentiated Services Codepoint (DSCP) field (6 bits). Here are the DSCP 2103 * values proposed by this RFC: 2104 * 2105 * <pre> Class 1 Class 2 Class 3 Class 4 </pre> 2106 * <pre> +----------+----------+----------+----------+</pre> 2107 * <pre>Low Drop Prec | 001010 | 010010 | 011010 | 100010 |</pre> 2108 * <pre>Medium Drop Prec | 001100 | 010100 | 011100 | 100100 |</pre> 2109 * <pre>High Drop Prec | 001110 | 010110 | 011110 | 100110 |</pre> 2110 * <pre> +----------+----------+----------+----------+</pre> 2111 * 2112 * There are 4 traffic classes (classes 1 .. 4) encoded by DSCP bits 1 and 2, 2113 * as well as 3 drop priorities (low/medium/high) encoded by DSCP bits 3 and 4. 2114 * 2115 * All IPv4/IPv6 packets have their color marked into DSCP bits 3 and 4 as 2116 * follows: green mapped to Low Drop Precedence (2’b01), yellow to Medium 2117 * (2’b10) and red to High (2’b11). Marking needs to be explicitly enabled 2118 * for each color; when not enabled for a given color, the DSCP field of all 2119 * packets with that color is left as is. 2120 * 2121 * @param[in] port_id 2122 * The port identifier of the Ethernet device. 2123 * @param[in] mark_green 2124 * Set to non-zero value to enable marking of green packets and to zero to 2125 * disable it. 2126 * @param[in] mark_yellow 2127 * Set to non-zero value to enable marking of yellow packets and to zero to 2128 * disable it. 2129 * @param[in] mark_red 2130 * Set to non-zero value to enable marking of red packets and to zero to 2131 * disable it. 2132 * @param[out] error 2133 * Error details. Filled in only on error, when not NULL. 2134 * @return 2135 * 0 on success, non-zero error code otherwise. 2136 * 2137 * @see struct rte_tm_capabilities::mark_ip_dscp_supported 2138 */ 2139 __rte_experimental 2140 int 2141 rte_tm_mark_ip_dscp(uint16_t port_id, 2142 int mark_green, 2143 int mark_yellow, 2144 int mark_red, 2145 struct rte_tm_error *error); 2146 2147 #ifdef __cplusplus 2148 } 2149 #endif 2150 2151 #endif /* __INCLUDE_RTE_TM_H__ */ 2152