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         const char *dev_name;
 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         const char *action_profile_name;
 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         const char *dev_name;
 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 struct softnic_table_hash_params {
 380         uint32_t n_keys;
 381         uint32_t key_offset;
 382         uint32_t key_size;
 383         uint8_t *key_mask;
 384         uint32_t n_buckets;
 385         int extendable_bucket;
 386 };
 387
 388 struct softnic_table_lpm_params {
 389         uint32_t n_rules;
 390         uint32_t key_offset;
 391         uint32_t key_size;
 392 };
 393
 394 struct softnic_table_params {
 395         /* Match */
 396         enum softnic_table_type match_type;
 397         union {
 398                 struct softnic_table_acl_params acl;
 399                 struct softnic_table_array_params array;
 400                 struct softnic_table_hash_params hash;
 401                 struct softnic_table_lpm_params lpm;
 402         } match;
 403
 404         /* Action */
 405         const char *action_profile_name;
 406 };
 407
 408 struct softnic_port_in {
 409         struct softnic_port_in_params params;
 410         struct softnic_port_in_action_profile *ap;
 411         struct rte_port_in_action *a;
 412 };
 413
 414 struct softnic_table {
 415         struct softnic_table_params params;
 416         struct softnic_table_action_profile *ap;
 417         struct rte_table_action *a;
 418 };
 419
 420 struct pipeline {
 421         TAILQ_ENTRY(pipeline) node;
 422         char name[NAME_SIZE];
 423
 424         struct rte_pipeline *p;
 425         struct softnic_port_in port_in[RTE_PIPELINE_PORT_IN_MAX];
 426         struct softnic_table table[RTE_PIPELINE_TABLE_MAX];
 427         uint32_t n_ports_in;
 428         uint32_t n_ports_out;
 429         uint32_t n_tables;
 430
 431         struct rte_ring *msgq_req;
 432         struct rte_ring *msgq_rsp;
 433         uint32_t timer_period_ms;
 434
 435         int enabled;
 436         uint32_t thread_id;
 437         uint32_t cpu_id;
 438 };
 439
 440 TAILQ_HEAD(pipeline_list, pipeline);
 441
 442 /**
 443  * Thread
 444  */
 445 #ifndef THREAD_PIPELINES_MAX
 446 #define THREAD_PIPELINES_MAX                               256
 447 #endif
 448
 449 #ifndef THREAD_MSGQ_SIZE
 450 #define THREAD_MSGQ_SIZE                                   64
 451 #endif
 452
 453 #ifndef THREAD_TIMER_PERIOD_MS
 454 #define THREAD_TIMER_PERIOD_MS                             100
 455 #endif
 456
 457 /**
 458  * Master thead: data plane thread context
 459  */
 460 struct softnic_thread {
 461         struct rte_ring *msgq_req;
 462         struct rte_ring *msgq_rsp;
 463
 464         uint32_t enabled;
 465 };
 466
 467 /**
 468  * Data plane threads: context
 469  */
 470 #ifndef TABLE_RULE_ACTION_SIZE_MAX
 471 #define TABLE_RULE_ACTION_SIZE_MAX                         2048
 472 #endif
 473
 474 struct softnic_table_data {
 475         struct rte_table_action *a;
 476 };
 477
 478 struct pipeline_data {
 479         struct rte_pipeline *p;
 480         struct softnic_table_data table_data[RTE_PIPELINE_TABLE_MAX];
 481         uint32_t n_tables;
 482
 483         struct rte_ring *msgq_req;
 484         struct rte_ring *msgq_rsp;
 485         uint64_t timer_period; /* Measured in CPU cycles. */
 486         uint64_t time_next;
 487
 488         uint8_t buffer[TABLE_RULE_ACTION_SIZE_MAX];
 489 };
 490
 491 struct softnic_thread_data {
 492         struct rte_pipeline *p[THREAD_PIPELINES_MAX];
 493         uint32_t n_pipelines;
 494
 495         struct pipeline_data pipeline_data[THREAD_PIPELINES_MAX];
 496         struct rte_ring *msgq_req;
 497         struct rte_ring *msgq_rsp;
 498         uint64_t timer_period; /* Measured in CPU cycles. */
 499         uint64_t time_next;
 500         uint64_t time_next_min;
 501         uint64_t iter;
 502 } __rte_cache_aligned;
 503
 504 /**
 505  * PMD Internals
 506  */
 507 struct pmd_internals {
 508         /** Params */
 509         struct pmd_params params;
 510
 511         struct {
 512                 struct tm_internals tm; /**< Traffic Management */
 513         } soft;
 514
 515         struct flow_internals flow;
 516         struct softnic_conn *conn;
 517         struct softnic_mempool_list mempool_list;
 518         struct softnic_swq_list swq_list;
 519         struct softnic_link_list link_list;
 520         struct softnic_tmgr_port_list tmgr_port_list;
 521         struct softnic_tap_list tap_list;
 522         struct softnic_port_in_action_profile_list port_in_action_profile_list;
 523         struct softnic_table_action_profile_list table_action_profile_list;
 524         struct pipeline_list pipeline_list;
 525         struct softnic_thread thread[RTE_MAX_LCORE];
 526         struct softnic_thread_data thread_data[RTE_MAX_LCORE];
 527 };
 528
 529 /**
 530  * Ethdev Flow API
 531  */
 532 int
 533 flow_attr_map_set(struct pmd_internals *softnic,
 534                 uint32_t group_id,
 535                 int ingress,
 536                 const char *pipeline_name,
 537                 uint32_t table_id);
 538
 539 struct flow_attr_map *
 540 flow_attr_map_get(struct pmd_internals *softnic,
 541                 uint32_t group_id,
 542                 int ingress);
 543
 544 /**
 545  * MEMPOOL
 546  */
 547 int
 548 softnic_mempool_init(struct pmd_internals *p);
 549
 550 void
 551 softnic_mempool_free(struct pmd_internals *p);
 552
 553 struct softnic_mempool *
 554 softnic_mempool_find(struct pmd_internals *p,
 555         const char *name);
 556
 557 struct softnic_mempool *
 558 softnic_mempool_create(struct pmd_internals *p,
 559         const char *name,
 560         struct softnic_mempool_params *params);
 561
 562 /**
 563  * SWQ
 564  */
 565 int
 566 softnic_swq_init(struct pmd_internals *p);
 567
 568 void
 569 softnic_swq_free(struct pmd_internals *p);
 570
 571 void
 572 softnic_softnic_swq_free_keep_rxq_txq(struct pmd_internals *p);
 573
 574 struct softnic_swq *
 575 softnic_swq_find(struct pmd_internals *p,
 576         const char *name);
 577
 578 struct softnic_swq *
 579 softnic_swq_create(struct pmd_internals *p,
 580         const char *name,
 581         struct softnic_swq_params *params);
 582
 583 /**
 584  * LINK
 585  */
 586 int
 587 softnic_link_init(struct pmd_internals *p);
 588
 589 void
 590 softnic_link_free(struct pmd_internals *p);
 591
 592 struct softnic_link *
 593 softnic_link_find(struct pmd_internals *p,
 594         const char *name);
 595
 596 struct softnic_link *
 597 softnic_link_create(struct pmd_internals *p,
 598         const char *name,
 599         struct softnic_link_params *params);
 600
 601 /**
 602  * TMGR
 603  */
 604 int
 605 softnic_tmgr_init(struct pmd_internals *p);
 606
 607 void
 608 softnic_tmgr_free(struct pmd_internals *p);
 609
 610 struct softnic_tmgr_port *
 611 softnic_tmgr_port_find(struct pmd_internals *p,
 612         const char *name);
 613
 614 struct softnic_tmgr_port *
 615 softnic_tmgr_port_create(struct pmd_internals *p,
 616         const char *name);
 617
 618 void
 619 tm_hierarchy_init(struct pmd_internals *p);
 620
 621 void
 622 tm_hierarchy_free(struct pmd_internals *p);
 623
 624 static inline int
 625 tm_used(struct rte_eth_dev *dev)
 626 {
 627         struct pmd_internals *p = dev->data->dev_private;
 628
 629         return p->soft.tm.h.n_tm_nodes[TM_NODE_LEVEL_PORT];
 630 }
 631
 632 extern const struct rte_tm_ops pmd_tm_ops;
 633
 634 /**
 635  * TAP
 636  */
 637 int
 638 softnic_tap_init(struct pmd_internals *p);
 639
 640 void
 641 softnic_tap_free(struct pmd_internals *p);
 642
 643 struct softnic_tap *
 644 softnic_tap_find(struct pmd_internals *p,
 645         const char *name);
 646
 647 struct softnic_tap *
 648 softnic_tap_create(struct pmd_internals *p,
 649         const char *name);
 650
 651 /**
 652  * Input port action
 653  */
 654 int
 655 softnic_port_in_action_profile_init(struct pmd_internals *p);
 656
 657 void
 658 softnic_port_in_action_profile_free(struct pmd_internals *p);
 659
 660 struct softnic_port_in_action_profile *
 661 softnic_port_in_action_profile_find(struct pmd_internals *p,
 662         const char *name);
 663
 664 struct softnic_port_in_action_profile *
 665 softnic_port_in_action_profile_create(struct pmd_internals *p,
 666         const char *name,
 667         struct softnic_port_in_action_profile_params *params);
 668
 669 /**
 670  * Table action
 671  */
 672 int
 673 softnic_table_action_profile_init(struct pmd_internals *p);
 674
 675 void
 676 softnic_table_action_profile_free(struct pmd_internals *p);
 677
 678 struct softnic_table_action_profile *
 679 softnic_table_action_profile_find(struct pmd_internals *p,
 680         const char *name);
 681
 682 struct softnic_table_action_profile *
 683 softnic_table_action_profile_create(struct pmd_internals *p,
 684         const char *name,
 685         struct softnic_table_action_profile_params *params);
 686
 687 /**
 688  * Pipeline
 689  */
 690 int
 691 softnic_pipeline_init(struct pmd_internals *p);
 692
 693 void
 694 softnic_pipeline_free(struct pmd_internals *p);
 695
 696 void
 697 softnic_pipeline_disable_all(struct pmd_internals *p);
 698
 699 struct pipeline *
 700 softnic_pipeline_find(struct pmd_internals *p, const char *name);
 701
 702 struct pipeline *
 703 softnic_pipeline_create(struct pmd_internals *p,
 704         const char *name,
 705         struct pipeline_params *params);
 706
 707 int
 708 softnic_pipeline_port_in_create(struct pmd_internals *p,
 709         const char *pipeline_name,
 710         struct softnic_port_in_params *params,
 711         int enabled);
 712
 713 int
 714 softnic_pipeline_port_in_connect_to_table(struct pmd_internals *p,
 715         const char *pipeline_name,
 716         uint32_t port_id,
 717         uint32_t table_id);
 718
 719 int
 720 softnic_pipeline_port_out_create(struct pmd_internals *p,
 721         const char *pipeline_name,
 722         struct softnic_port_out_params *params);
 723
 724 int
 725 softnic_pipeline_table_create(struct pmd_internals *p,
 726         const char *pipeline_name,
 727         struct softnic_table_params *params);
 728
 729 struct softnic_table_rule_match_acl {
 730         int ip_version;
 731
 732         RTE_STD_C11
 733         union {
 734                 struct {
 735                         uint32_t sa;
 736                         uint32_t da;
 737                 } ipv4;
 738
 739                 struct {
 740                         uint8_t sa[16];
 741                         uint8_t da[16];
 742                 } ipv6;
 743         };
 744
 745         uint32_t sa_depth;
 746         uint32_t da_depth;
 747         uint16_t sp0;
 748         uint16_t sp1;
 749         uint16_t dp0;
 750         uint16_t dp1;
 751         uint8_t proto;
 752         uint8_t proto_mask;
 753         uint32_t priority;
 754 };
 755
 756 struct softnic_table_rule_match_array {
 757         uint32_t pos;
 758 };
 759
 760 #ifndef TABLE_RULE_MATCH_SIZE_MAX
 761 #define TABLE_RULE_MATCH_SIZE_MAX                          256
 762 #endif
 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__ */