drivers/net/softnic/rte_eth_softnic_internals.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2017 Intel Corporation
   3  */
   4
   5 #ifndef __INCLUDE_RTE_ETH_SOFTNIC_INTERNALS_H__
   6 #define __INCLUDE_RTE_ETH_SOFTNIC_INTERNALS_H__
   7
   8 #include <stddef.h>
   9 #include <stdint.h>
  10 #include <sys/queue.h>
  11
  12 #include <rte_mempool.h>
  13 #include <rte_mbuf.h>
  14 #include <rte_ring.h>
  15 #include <rte_ethdev.h>
  16 #include <rte_sched.h>
  17 #include <rte_port_in_action.h>
  18 #include <rte_table_action.h>
  19 #include <rte_pipeline.h>
  20
  21 #include <rte_ethdev_driver.h>
  22 #include <rte_tm_driver.h>
  23 #include <rte_flow_driver.h>
  24
  25 #include "rte_eth_softnic.h"
  26 #include "conn.h"
  27
  28 #define NAME_SIZE                                            64
  29
  30 /**
  31  * PMD Parameters
  32  */
  33
  34 struct pmd_params {
  35         const char *name;
  36         const char *firmware;
  37         uint16_t conn_port;
  38         uint32_t cpu_id;
  39
  40         /** Traffic Management (TM) */
  41         struct {
  42                 uint32_t n_queues; /**< Number of queues */
  43                 uint16_t qsize[RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE];
  44         } tm;
  45 };
  46
  47 /**
  48  * Ethdev Flow API
  49  */
  50 struct rte_flow;
  51
  52 TAILQ_HEAD(flow_list, rte_flow);
  53
  54 struct flow_attr_map {
  55         char pipeline_name[NAME_SIZE];
  56         uint32_t table_id;
  57         int valid;
  58 };
  59
  60 #ifndef SOFTNIC_FLOW_MAX_GROUPS
  61 #define SOFTNIC_FLOW_MAX_GROUPS                            64
  62 #endif
  63
  64 struct flow_internals {
  65         struct flow_attr_map ingress_map[SOFTNIC_FLOW_MAX_GROUPS];
  66         struct flow_attr_map egress_map[SOFTNIC_FLOW_MAX_GROUPS];
  67 };
  68
  69 /**
  70  * MEMPOOL
  71  */
  72 struct softnic_mempool_params {
  73         uint32_t buffer_size;
  74         uint32_t pool_size;
  75         uint32_t cache_size;
  76 };
  77
  78 struct softnic_mempool {
  79         TAILQ_ENTRY(softnic_mempool) node;
  80         char name[NAME_SIZE];
  81         struct rte_mempool *m;
  82         uint32_t buffer_size;
  83 };
  84
  85 TAILQ_HEAD(softnic_mempool_list, softnic_mempool);
  86
  87 /**
  88  * SWQ
  89  */
  90 struct softnic_swq_params {
  91         uint32_t size;
  92 };
  93
  94 struct softnic_swq {
  95         TAILQ_ENTRY(softnic_swq) node;
  96         char name[NAME_SIZE];
  97         struct rte_ring *r;
  98 };
  99
 100 TAILQ_HEAD(softnic_swq_list, softnic_swq);
 101
 102 /**
 103  * LINK
 104  */
 105 struct softnic_link_params {
 106         const char *dev_name;
 107         uint16_t port_id; /**< Valid only when *dev_name* is NULL. */
 108 };
 109
 110 struct softnic_link {
 111         TAILQ_ENTRY(softnic_link) node;
 112         char name[NAME_SIZE];
 113         uint16_t port_id;
 114         uint32_t n_rxq;
 115         uint32_t n_txq;
 116 };
 117
 118 TAILQ_HEAD(softnic_link_list, softnic_link);
 119
 120 /**
 121  * TMGR
 122  */
 123
 124 #ifndef TM_MAX_SUBPORTS
 125 #define TM_MAX_SUBPORTS                                 8
 126 #endif
 127
 128 #ifndef TM_MAX_PIPES_PER_SUBPORT
 129 #define TM_MAX_PIPES_PER_SUBPORT                        4096
 130 #endif
 131
 132 struct tm_params {
 133         struct rte_sched_port_params port_params;
 134
 135         struct rte_sched_subport_params subport_params[TM_MAX_SUBPORTS];
 136
 137         struct rte_sched_pipe_params
 138                 pipe_profiles[RTE_SCHED_PIPE_PROFILES_PER_PORT];
 139         uint32_t n_pipe_profiles;
 140         uint32_t pipe_to_profile[TM_MAX_SUBPORTS * TM_MAX_PIPES_PER_SUBPORT];
 141 };
 142
 143 /* TM Levels */
 144 enum tm_node_level {
 145         TM_NODE_LEVEL_PORT = 0,
 146         TM_NODE_LEVEL_SUBPORT,
 147         TM_NODE_LEVEL_PIPE,
 148         TM_NODE_LEVEL_TC,
 149         TM_NODE_LEVEL_QUEUE,
 150         TM_NODE_LEVEL_MAX,
 151 };
 152
 153 /* TM Shaper Profile */
 154 struct tm_shaper_profile {
 155         TAILQ_ENTRY(tm_shaper_profile) node;
 156         uint32_t shaper_profile_id;
 157         uint32_t n_users;
 158         struct rte_tm_shaper_params params;
 159 };
 160
 161 TAILQ_HEAD(tm_shaper_profile_list, tm_shaper_profile);
 162
 163 /* TM Shared Shaper */
 164 struct tm_shared_shaper {
 165         TAILQ_ENTRY(tm_shared_shaper) node;
 166         uint32_t shared_shaper_id;
 167         uint32_t n_users;
 168         uint32_t shaper_profile_id;
 169 };
 170
 171 TAILQ_HEAD(tm_shared_shaper_list, tm_shared_shaper);
 172
 173 /* TM WRED Profile */
 174 struct tm_wred_profile {
 175         TAILQ_ENTRY(tm_wred_profile) node;
 176         uint32_t wred_profile_id;
 177         uint32_t n_users;
 178         struct rte_tm_wred_params params;
 179 };
 180
 181 TAILQ_HEAD(tm_wred_profile_list, tm_wred_profile);
 182
 183 /* TM Node */
 184 struct tm_node {
 185         TAILQ_ENTRY(tm_node) node;
 186         uint32_t node_id;
 187         uint32_t parent_node_id;
 188         uint32_t priority;
 189         uint32_t weight;
 190         uint32_t level;
 191         struct tm_node *parent_node;
 192         struct tm_shaper_profile *shaper_profile;
 193         struct tm_wred_profile *wred_profile;
 194         struct rte_tm_node_params params;
 195         struct rte_tm_node_stats stats;
 196         uint32_t n_children;
 197 };
 198
 199 TAILQ_HEAD(tm_node_list, tm_node);
 200
 201 /* TM Hierarchy Specification */
 202 struct tm_hierarchy {
 203         struct tm_shaper_profile_list shaper_profiles;
 204         struct tm_shared_shaper_list shared_shapers;
 205         struct tm_wred_profile_list wred_profiles;
 206         struct tm_node_list nodes;
 207
 208         uint32_t n_shaper_profiles;
 209         uint32_t n_shared_shapers;
 210         uint32_t n_wred_profiles;
 211         uint32_t n_nodes;
 212
 213         uint32_t n_tm_nodes[TM_NODE_LEVEL_MAX];
 214 };
 215
 216 struct tm_internals {
 217         /** Hierarchy specification
 218          *
 219          *     -Hierarchy is unfrozen at init and when port is stopped.
 220          *     -Hierarchy is frozen on successful hierarchy commit.
 221          *     -Run-time hierarchy changes are not allowed, therefore it makes
 222          *      sense to keep the hierarchy frozen after the port is started.
 223          */
 224         struct tm_hierarchy h;
 225         int hierarchy_frozen;
 226
 227         /** Blueprints */
 228         struct tm_params params;
 229 };
 230
 231 struct softnic_tmgr_port {
 232         TAILQ_ENTRY(softnic_tmgr_port) node;
 233         char name[NAME_SIZE];
 234         struct rte_sched_port *s;
 235 };
 236
 237 TAILQ_HEAD(softnic_tmgr_port_list, softnic_tmgr_port);
 238
 239 /**
 240  * TAP
 241  */
 242 struct softnic_tap {
 243         TAILQ_ENTRY(softnic_tap) node;
 244         char name[NAME_SIZE];
 245         int fd;
 246 };
 247
 248 TAILQ_HEAD(softnic_tap_list, softnic_tap);
 249
 250 /**
 251  * Input port action
 252  */
 253 struct softnic_port_in_action_profile_params {
 254         uint64_t action_mask;
 255         struct rte_port_in_action_fltr_config fltr;
 256         struct rte_port_in_action_lb_config lb;
 257 };
 258
 259 struct softnic_port_in_action_profile {
 260         TAILQ_ENTRY(softnic_port_in_action_profile) node;
 261         char name[NAME_SIZE];
 262         struct softnic_port_in_action_profile_params params;
 263         struct rte_port_in_action_profile *ap;
 264 };
 265
 266 TAILQ_HEAD(softnic_port_in_action_profile_list, softnic_port_in_action_profile);
 267
 268 /**
 269  * Table action
 270  */
 271 struct softnic_table_action_profile_params {
 272         uint64_t action_mask;
 273         struct rte_table_action_common_config common;
 274         struct rte_table_action_lb_config lb;
 275         struct rte_table_action_mtr_config mtr;
 276         struct rte_table_action_tm_config tm;
 277         struct rte_table_action_encap_config encap;
 278         struct rte_table_action_nat_config nat;
 279         struct rte_table_action_ttl_config ttl;
 280         struct rte_table_action_stats_config stats;
 281 };
 282
 283 struct softnic_table_action_profile {
 284         TAILQ_ENTRY(softnic_table_action_profile) node;
 285         char name[NAME_SIZE];
 286         struct softnic_table_action_profile_params params;
 287         struct rte_table_action_profile *ap;
 288 };
 289
 290 TAILQ_HEAD(softnic_table_action_profile_list, softnic_table_action_profile);
 291
 292 /**
 293  * Pipeline
 294  */
 295 struct pipeline_params {
 296         uint32_t timer_period_ms;
 297         uint32_t offset_port_id;
 298 };
 299
 300 enum softnic_port_in_type {
 301         PORT_IN_RXQ,
 302         PORT_IN_SWQ,
 303         PORT_IN_TMGR,
 304         PORT_IN_TAP,
 305         PORT_IN_SOURCE,
 306 };
 307
 308 struct softnic_port_in_params {
 309         /* Read */
 310         enum softnic_port_in_type type;
 311         char dev_name[NAME_SIZE];
 312         union {
 313                 struct {
 314                         uint16_t queue_id;
 315                 } rxq;
 316
 317                 struct {
 318                         const char *mempool_name;
 319                         uint32_t mtu;
 320                 } tap;
 321
 322                 struct {
 323                         const char *mempool_name;
 324                         const char *file_name;
 325                         uint32_t n_bytes_per_pkt;
 326                 } source;
 327         };
 328         uint32_t burst_size;
 329
 330         /* Action */
 331         char action_profile_name[NAME_SIZE];
 332 };
 333
 334 enum softnic_port_out_type {
 335         PORT_OUT_TXQ,
 336         PORT_OUT_SWQ,
 337         PORT_OUT_TMGR,
 338         PORT_OUT_TAP,
 339         PORT_OUT_SINK,
 340 };
 341
 342 struct softnic_port_out_params {
 343         enum softnic_port_out_type type;
 344         char dev_name[NAME_SIZE];
 345         union {
 346                 struct {
 347                         uint16_t queue_id;
 348                 } txq;
 349
 350                 struct {
 351                         const char *file_name;
 352                         uint32_t max_n_pkts;
 353                 } sink;
 354         };
 355         uint32_t burst_size;
 356         int retry;
 357         uint32_t n_retries;
 358 };
 359
 360 enum softnic_table_type {
 361         TABLE_ACL,
 362         TABLE_ARRAY,
 363         TABLE_HASH,
 364         TABLE_LPM,
 365         TABLE_STUB,
 366 };
 367
 368 struct softnic_table_acl_params {
 369         uint32_t n_rules;
 370         uint32_t ip_header_offset;
 371         int ip_version;
 372 };
 373
 374 struct softnic_table_array_params {
 375         uint32_t n_keys;
 376         uint32_t key_offset;
 377 };
 378
 379 #ifndef TABLE_RULE_MATCH_SIZE_MAX
 380 #define TABLE_RULE_MATCH_SIZE_MAX                          256
 381 #endif
 382
 383 struct softnic_table_hash_params {
 384         uint32_t n_keys;
 385         uint32_t key_offset;
 386         uint32_t key_size;
 387         uint8_t key_mask[TABLE_RULE_MATCH_SIZE_MAX];
 388         uint32_t n_buckets;
 389         int extendable_bucket;
 390 };
 391
 392 struct softnic_table_lpm_params {
 393         uint32_t n_rules;
 394         uint32_t key_offset;
 395         uint32_t key_size;
 396 };
 397
 398 struct softnic_table_params {
 399         /* Match */
 400         enum softnic_table_type match_type;
 401         union {
 402                 struct softnic_table_acl_params acl;
 403                 struct softnic_table_array_params array;
 404                 struct softnic_table_hash_params hash;
 405                 struct softnic_table_lpm_params lpm;
 406         } match;
 407
 408         /* Action */
 409         char action_profile_name[NAME_SIZE];
 410 };
 411
 412 struct softnic_port_in {
 413         struct softnic_port_in_params params;
 414         struct softnic_port_in_action_profile *ap;
 415         struct rte_port_in_action *a;
 416 };
 417
 418 struct softnic_table {
 419         struct softnic_table_params params;
 420         struct softnic_table_action_profile *ap;
 421         struct rte_table_action *a;
 422 };
 423
 424 struct pipeline {
 425         TAILQ_ENTRY(pipeline) node;
 426         char name[NAME_SIZE];
 427
 428         struct rte_pipeline *p;
 429         struct softnic_port_in port_in[RTE_PIPELINE_PORT_IN_MAX];
 430         struct softnic_table table[RTE_PIPELINE_TABLE_MAX];
 431         uint32_t n_ports_in;
 432         uint32_t n_ports_out;
 433         uint32_t n_tables;
 434
 435         struct rte_ring *msgq_req;
 436         struct rte_ring *msgq_rsp;
 437         uint32_t timer_period_ms;
 438
 439         int enabled;
 440         uint32_t thread_id;
 441         uint32_t cpu_id;
 442 };
 443
 444 TAILQ_HEAD(pipeline_list, pipeline);
 445
 446 /**
 447  * Thread
 448  */
 449 #ifndef THREAD_PIPELINES_MAX
 450 #define THREAD_PIPELINES_MAX                               256
 451 #endif
 452
 453 #ifndef THREAD_MSGQ_SIZE
 454 #define THREAD_MSGQ_SIZE                                   64
 455 #endif
 456
 457 #ifndef THREAD_TIMER_PERIOD_MS
 458 #define THREAD_TIMER_PERIOD_MS                             100
 459 #endif
 460
 461 /**
 462  * Master thead: data plane thread context
 463  */
 464 struct softnic_thread {
 465         struct rte_ring *msgq_req;
 466         struct rte_ring *msgq_rsp;
 467
 468         uint32_t enabled;
 469 };
 470
 471 /**
 472  * Data plane threads: context
 473  */
 474 #ifndef TABLE_RULE_ACTION_SIZE_MAX
 475 #define TABLE_RULE_ACTION_SIZE_MAX                         2048
 476 #endif
 477
 478 struct softnic_table_data {
 479         struct rte_table_action *a;
 480 };
 481
 482 struct pipeline_data {
 483         struct rte_pipeline *p;
 484         struct softnic_table_data table_data[RTE_PIPELINE_TABLE_MAX];
 485         uint32_t n_tables;
 486
 487         struct rte_ring *msgq_req;
 488         struct rte_ring *msgq_rsp;
 489         uint64_t timer_period; /* Measured in CPU cycles. */
 490         uint64_t time_next;
 491
 492         uint8_t buffer[TABLE_RULE_ACTION_SIZE_MAX];
 493 };
 494
 495 struct softnic_thread_data {
 496         struct rte_pipeline *p[THREAD_PIPELINES_MAX];
 497         uint32_t n_pipelines;
 498
 499         struct pipeline_data pipeline_data[THREAD_PIPELINES_MAX];
 500         struct rte_ring *msgq_req;
 501         struct rte_ring *msgq_rsp;
 502         uint64_t timer_period; /* Measured in CPU cycles. */
 503         uint64_t time_next;
 504         uint64_t time_next_min;
 505         uint64_t iter;
 506 } __rte_cache_aligned;
 507
 508 /**
 509  * PMD Internals
 510  */
 511 struct pmd_internals {
 512         /** Params */
 513         struct pmd_params params;
 514
 515         struct {
 516                 struct tm_internals tm; /**< Traffic Management */
 517         } soft;
 518
 519         struct flow_internals flow;
 520         struct softnic_conn *conn;
 521         struct softnic_mempool_list mempool_list;
 522         struct softnic_swq_list swq_list;
 523         struct softnic_link_list link_list;
 524         struct softnic_tmgr_port_list tmgr_port_list;
 525         struct softnic_tap_list tap_list;
 526         struct softnic_port_in_action_profile_list port_in_action_profile_list;
 527         struct softnic_table_action_profile_list table_action_profile_list;
 528         struct pipeline_list pipeline_list;
 529         struct softnic_thread thread[RTE_MAX_LCORE];
 530         struct softnic_thread_data thread_data[RTE_MAX_LCORE];
 531 };
 532
 533 /**
 534  * Ethdev Flow API
 535  */
 536 int
 537 flow_attr_map_set(struct pmd_internals *softnic,
 538                 uint32_t group_id,
 539                 int ingress,
 540                 const char *pipeline_name,
 541                 uint32_t table_id);
 542
 543 struct flow_attr_map *
 544 flow_attr_map_get(struct pmd_internals *softnic,
 545                 uint32_t group_id,
 546                 int ingress);
 547
 548 /**
 549  * MEMPOOL
 550  */
 551 int
 552 softnic_mempool_init(struct pmd_internals *p);
 553
 554 void
 555 softnic_mempool_free(struct pmd_internals *p);
 556
 557 struct softnic_mempool *
 558 softnic_mempool_find(struct pmd_internals *p,
 559         const char *name);
 560
 561 struct softnic_mempool *
 562 softnic_mempool_create(struct pmd_internals *p,
 563         const char *name,
 564         struct softnic_mempool_params *params);
 565
 566 /**
 567  * SWQ
 568  */
 569 int
 570 softnic_swq_init(struct pmd_internals *p);
 571
 572 void
 573 softnic_swq_free(struct pmd_internals *p);
 574
 575 void
 576 softnic_softnic_swq_free_keep_rxq_txq(struct pmd_internals *p);
 577
 578 struct softnic_swq *
 579 softnic_swq_find(struct pmd_internals *p,
 580         const char *name);
 581
 582 struct softnic_swq *
 583 softnic_swq_create(struct pmd_internals *p,
 584         const char *name,
 585         struct softnic_swq_params *params);
 586
 587 /**
 588  * LINK
 589  */
 590 int
 591 softnic_link_init(struct pmd_internals *p);
 592
 593 void
 594 softnic_link_free(struct pmd_internals *p);
 595
 596 struct softnic_link *
 597 softnic_link_find(struct pmd_internals *p,
 598         const char *name);
 599
 600 struct softnic_link *
 601 softnic_link_create(struct pmd_internals *p,
 602         const char *name,
 603         struct softnic_link_params *params);
 604
 605 /**
 606  * TMGR
 607  */
 608 int
 609 softnic_tmgr_init(struct pmd_internals *p);
 610
 611 void
 612 softnic_tmgr_free(struct pmd_internals *p);
 613
 614 struct softnic_tmgr_port *
 615 softnic_tmgr_port_find(struct pmd_internals *p,
 616         const char *name);
 617
 618 struct softnic_tmgr_port *
 619 softnic_tmgr_port_create(struct pmd_internals *p,
 620         const char *name);
 621
 622 void
 623 tm_hierarchy_init(struct pmd_internals *p);
 624
 625 void
 626 tm_hierarchy_free(struct pmd_internals *p);
 627
 628 static inline int
 629 tm_used(struct rte_eth_dev *dev)
 630 {
 631         struct pmd_internals *p = dev->data->dev_private;
 632
 633         return p->soft.tm.h.n_tm_nodes[TM_NODE_LEVEL_PORT];
 634 }
 635
 636 extern const struct rte_tm_ops pmd_tm_ops;
 637
 638 /**
 639  * TAP
 640  */
 641 int
 642 softnic_tap_init(struct pmd_internals *p);
 643
 644 void
 645 softnic_tap_free(struct pmd_internals *p);
 646
 647 struct softnic_tap *
 648 softnic_tap_find(struct pmd_internals *p,
 649         const char *name);
 650
 651 struct softnic_tap *
 652 softnic_tap_create(struct pmd_internals *p,
 653         const char *name);
 654
 655 /**
 656  * Input port action
 657  */
 658 int
 659 softnic_port_in_action_profile_init(struct pmd_internals *p);
 660
 661 void
 662 softnic_port_in_action_profile_free(struct pmd_internals *p);
 663
 664 struct softnic_port_in_action_profile *
 665 softnic_port_in_action_profile_find(struct pmd_internals *p,
 666         const char *name);
 667
 668 struct softnic_port_in_action_profile *
 669 softnic_port_in_action_profile_create(struct pmd_internals *p,
 670         const char *name,
 671         struct softnic_port_in_action_profile_params *params);
 672
 673 /**
 674  * Table action
 675  */
 676 int
 677 softnic_table_action_profile_init(struct pmd_internals *p);
 678
 679 void
 680 softnic_table_action_profile_free(struct pmd_internals *p);
 681
 682 struct softnic_table_action_profile *
 683 softnic_table_action_profile_find(struct pmd_internals *p,
 684         const char *name);
 685
 686 struct softnic_table_action_profile *
 687 softnic_table_action_profile_create(struct pmd_internals *p,
 688         const char *name,
 689         struct softnic_table_action_profile_params *params);
 690
 691 /**
 692  * Pipeline
 693  */
 694 int
 695 softnic_pipeline_init(struct pmd_internals *p);
 696
 697 void
 698 softnic_pipeline_free(struct pmd_internals *p);
 699
 700 void
 701 softnic_pipeline_disable_all(struct pmd_internals *p);
 702
 703 struct pipeline *
 704 softnic_pipeline_find(struct pmd_internals *p, const char *name);
 705
 706 struct pipeline *
 707 softnic_pipeline_create(struct pmd_internals *p,
 708         const char *name,
 709         struct pipeline_params *params);
 710
 711 int
 712 softnic_pipeline_port_in_create(struct pmd_internals *p,
 713         const char *pipeline_name,
 714         struct softnic_port_in_params *params,
 715         int enabled);
 716
 717 int
 718 softnic_pipeline_port_in_connect_to_table(struct pmd_internals *p,
 719         const char *pipeline_name,
 720         uint32_t port_id,
 721         uint32_t table_id);
 722
 723 int
 724 softnic_pipeline_port_out_create(struct pmd_internals *p,
 725         const char *pipeline_name,
 726         struct softnic_port_out_params *params);
 727
 728 int
 729 softnic_pipeline_table_create(struct pmd_internals *p,
 730         const char *pipeline_name,
 731         struct softnic_table_params *params);
 732
 733 struct softnic_table_rule_match_acl {
 734         int ip_version;
 735
 736         RTE_STD_C11
 737         union {
 738                 struct {
 739                         uint32_t sa;
 740                         uint32_t da;
 741                 } ipv4;
 742
 743                 struct {
 744                         uint8_t sa[16];
 745                         uint8_t da[16];
 746                 } ipv6;
 747         };
 748
 749         uint32_t sa_depth;
 750         uint32_t da_depth;
 751         uint16_t sp0;
 752         uint16_t sp1;
 753         uint16_t dp0;
 754         uint16_t dp1;
 755         uint8_t proto;
 756         uint8_t proto_mask;
 757         uint32_t priority;
 758 };
 759
 760 struct softnic_table_rule_match_array {
 761         uint32_t pos;
 762 };
 763
 764 struct softnic_table_rule_match_hash {
 765         uint8_t key[TABLE_RULE_MATCH_SIZE_MAX];
 766 };
 767
 768 struct softnic_table_rule_match_lpm {
 769         int ip_version;
 770
 771         RTE_STD_C11
 772         union {
 773                 uint32_t ipv4;
 774                 uint8_t ipv6[16];
 775         };
 776
 777         uint8_t depth;
 778 };
 779
 780 struct softnic_table_rule_match {
 781         enum softnic_table_type match_type;
 782
 783         union {
 784                 struct softnic_table_rule_match_acl acl;
 785                 struct softnic_table_rule_match_array array;
 786                 struct softnic_table_rule_match_hash hash;
 787                 struct softnic_table_rule_match_lpm lpm;
 788         } match;
 789 };
 790
 791 struct softnic_table_rule_action {
 792         uint64_t action_mask;
 793         struct rte_table_action_fwd_params fwd;
 794         struct rte_table_action_lb_params lb;
 795         struct rte_table_action_mtr_params mtr;
 796         struct rte_table_action_tm_params tm;
 797         struct rte_table_action_encap_params encap;
 798         struct rte_table_action_nat_params nat;
 799         struct rte_table_action_ttl_params ttl;
 800         struct rte_table_action_stats_params stats;
 801         struct rte_table_action_time_params time;
 802 };
 803
 804 struct rte_flow {
 805         TAILQ_ENTRY(rte_flow) node;
 806         struct softnic_table_rule_match match;
 807         struct softnic_table_rule_action action;
 808         void *data;
 809         struct pipeline *pipeline;
 810         uint32_t table_id;
 811 };
 812
 813 int
 814 softnic_pipeline_port_in_stats_read(struct pmd_internals *p,
 815         const char *pipeline_name,
 816         uint32_t port_id,
 817         struct rte_pipeline_port_in_stats *stats,
 818         int clear);
 819
 820 int
 821 softnic_pipeline_port_in_enable(struct pmd_internals *p,
 822         const char *pipeline_name,
 823         uint32_t port_id);
 824
 825 int
 826 softnic_pipeline_port_in_disable(struct pmd_internals *p,
 827         const char *pipeline_name,
 828         uint32_t port_id);
 829
 830 int
 831 softnic_pipeline_port_out_stats_read(struct pmd_internals *p,
 832         const char *pipeline_name,
 833         uint32_t port_id,
 834         struct rte_pipeline_port_out_stats *stats,
 835         int clear);
 836
 837 int
 838 softnic_pipeline_table_stats_read(struct pmd_internals *p,
 839         const char *pipeline_name,
 840         uint32_t table_id,
 841         struct rte_pipeline_table_stats *stats,
 842         int clear);
 843
 844 int
 845 softnic_pipeline_table_rule_add(struct pmd_internals *p,
 846         const char *pipeline_name,
 847         uint32_t table_id,
 848         struct softnic_table_rule_match *match,
 849         struct softnic_table_rule_action *action,
 850         void **data);
 851
 852 int
 853 softnic_pipeline_table_rule_add_bulk(struct pmd_internals *p,
 854         const char *pipeline_name,
 855         uint32_t table_id,
 856         struct softnic_table_rule_match *match,
 857         struct softnic_table_rule_action *action,
 858         void **data,
 859         uint32_t *n_rules);
 860
 861 int
 862 softnic_pipeline_table_rule_add_default(struct pmd_internals *p,
 863         const char *pipeline_name,
 864         uint32_t table_id,
 865         struct softnic_table_rule_action *action,
 866         void **data);
 867
 868 int
 869 softnic_pipeline_table_rule_delete(struct pmd_internals *p,
 870         const char *pipeline_name,
 871         uint32_t table_id,
 872         struct softnic_table_rule_match *match);
 873
 874 int
 875 softnic_pipeline_table_rule_delete_default(struct pmd_internals *p,
 876         const char *pipeline_name,
 877         uint32_t table_id);
 878
 879 int
 880 softnic_pipeline_table_rule_stats_read(struct pmd_internals *p,
 881         const char *pipeline_name,
 882         uint32_t table_id,
 883         void *data,
 884         struct rte_table_action_stats_counters *stats,
 885         int clear);
 886
 887 int
 888 softnic_pipeline_table_mtr_profile_add(struct pmd_internals *p,
 889         const char *pipeline_name,
 890         uint32_t table_id,
 891         uint32_t meter_profile_id,
 892         struct rte_table_action_meter_profile *profile);
 893
 894 int
 895 softnic_pipeline_table_mtr_profile_delete(struct pmd_internals *p,
 896         const char *pipeline_name,
 897         uint32_t table_id,
 898         uint32_t meter_profile_id);
 899
 900 int
 901 softnic_pipeline_table_rule_mtr_read(struct pmd_internals *p,
 902         const char *pipeline_name,
 903         uint32_t table_id,
 904         void *data,
 905         uint32_t tc_mask,
 906         struct rte_table_action_mtr_counters *stats,
 907         int clear);
 908
 909 int
 910 softnic_pipeline_table_dscp_table_update(struct pmd_internals *p,
 911         const char *pipeline_name,
 912         uint32_t table_id,
 913         uint64_t dscp_mask,
 914         struct rte_table_action_dscp_table *dscp_table);
 915
 916 int
 917 softnic_pipeline_table_rule_ttl_read(struct pmd_internals *p,
 918         const char *pipeline_name,
 919         uint32_t table_id,
 920         void *data,
 921         struct rte_table_action_ttl_counters *stats,
 922         int clear);
 923
 924 /**
 925  * Thread
 926  */
 927 int
 928 softnic_thread_init(struct pmd_internals *p);
 929
 930 void
 931 softnic_thread_free(struct pmd_internals *p);
 932
 933 int
 934 softnic_thread_pipeline_enable(struct pmd_internals *p,
 935         uint32_t thread_id,
 936         const char *pipeline_name);
 937
 938 int
 939 softnic_thread_pipeline_disable(struct pmd_internals *p,
 940         uint32_t thread_id,
 941         const char *pipeline_name);
 942
 943 /**
 944  * CLI
 945  */
 946 void
 947 softnic_cli_process(char *in,
 948         char *out,
 949         size_t out_size,
 950         void *arg);
 951
 952 int
 953 softnic_cli_script_process(struct pmd_internals *softnic,
 954         const char *file_name,
 955         size_t msg_in_len_max,
 956         size_t msg_out_len_max);
 957
 958 #endif /* __INCLUDE_RTE_ETH_SOFTNIC_INTERNALS_H__ */