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