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