summaryrefslogtreecommitdiffstats
path: root/VNFs/DPPD-PROX/task_init.h
blob: c5a17796e176b69d1fcfa9612646425c7fd241c4 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
/*
// Copyright (c) 2010-2017 Intel Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
*/

#ifndef _TASK_INIT_H_
#define _TASK_INIT_H_

#include <sys/queue.h>

#include <rte_common.h>
#include <rte_sched.h>
#include <rte_ether.h>
#include "task_base.h"
#include "prox_globals.h"
#include "ip6_addr.h"
#include "flow_iter.h"
#include "parse_utils.h"

struct rte_mbuf;
struct lcore_cfg;

#if MAX_RINGS_PER_TASK < PROX_MAX_PORTS
#error MAX_RINGS_PER_TASK < PROX_MAX_PORTS
#endif

#define TASK_ARG_DROP           0x01
#define TASK_ARG_RX_RING        0x02
#define TASK_ARG_RTE_TABLE      0x08
#define TASK_ARG_LOCAL_LPM      0x10
#define TASK_ARG_QINQ_ACL       0x20
#define TASK_ARG_CTRL_RINGS_P   0x40
#define TASK_ARG_DST_MAC_SET	0x80
#define TASK_ARG_SRC_MAC_SET	0x100
#define	TASK_ARG_DO_NOT_SET_SRC_MAC 0x200
#define	TASK_ARG_DO_NOT_SET_DST_MAC 0x400
#define	TASK_ARG_HW_SRC_MAC 	0x800
#define TASK_ARG_L3		0x1000

#define PROX_MODE_LEN	32

enum protocols {IPV4, ARP, IPV6};

struct qos_cfg {
	struct rte_sched_port_params port_params;
	struct rte_sched_subport_params subport_params[1];
	struct rte_sched_pipe_params pipe_params[1];
};

enum task_mode {NOT_SET, MASTER, QINQ_DECAP4, QINQ_DECAP6,
		QINQ_ENCAP4, QINQ_ENCAP6, GRE_DECAP, GRE_ENCAP,CGNAT, ESP_ENC, ESP_DEC,
};

struct task_args;

struct task_init {
	enum task_mode mode;
	char mode_str[PROX_MODE_LEN];
	char sub_mode_str[PROX_MODE_LEN];
	void (*early_init)(struct task_args *targ);
	void (*init)(struct task_base *tbase, struct task_args *targ);
	int (*handle)(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts);
	void (*start)(struct task_base *tbase);
	void (*stop)(struct task_base *tbase);
	void (*start_first)(struct task_base *tbase);
	void (*stop_last)(struct task_base *tbase);
	int (*thread_x)(struct lcore_cfg* lconf);
	struct flow_iter flow_iter;
	size_t size;
	uint16_t     flag_req_data; /* flags from prox_shared.h */
	uint64_t     flag_features;
	uint32_t mbuf_size;
	LIST_ENTRY(task_init) entries;
};

static int task_init_flag_set(struct task_init *task_init, uint64_t flag)
{
	return !!(task_init->flag_features & flag);
}

enum police_action {
        ACT_GREEN = e_RTE_METER_GREEN,
        ACT_YELLOW = e_RTE_METER_YELLOW,
        ACT_RED = e_RTE_METER_RED,
        ACT_DROP = 3,
	ACT_INVALID = 4
};

/* Configuration for task that is only used during startup. */
struct task_args {
	struct task_base       *tbase;
	struct task_init*       task_init;
	struct rte_mempool     *pool;
	char		       pool_name[MAX_NAME_SIZE];
	struct lcore_cfg       *lconf;
	uint32_t               nb_mbuf;
	uint32_t               mbuf_size;
	uint8_t    	       mbuf_size_set_explicitely;
	uint32_t               nb_cache_mbuf;
	uint8_t                nb_slave_threads;
	uint8_t		       nb_worker_threads;
	uint8_t		       worker_thread_id;
	uint8_t		       task;
	uint32_t               id;
	struct core_task_set   core_task_set[MAX_PROTOCOLS];
	struct task_args       *prev_tasks[MAX_RINGS_PER_TASK];
	uint32_t               n_prev_tasks;
	uint32_t               ring_size; /* default is RX_RING_SIZE */
	struct qos_cfg         qos_conf;
	uint32_t               flags;
	uint32_t               runtime_flags;
	uint8_t                nb_txports;
	uint8_t                nb_txrings;
	uint8_t                nb_rxrings;
	uint8_t                tot_rxrings;
	uint8_t                nb_rxports;
	uint32_t               byte_offset;
	uint32_t               gateway_ipv4;
	uint32_t               local_ipv4;
	uint32_t               remote_ipv4;
	struct ipv6_addr       local_ipv6;    /* For IPv6 Tunnel, it's the local tunnel endpoint address */
	struct rte_ring        *rx_rings[MAX_RINGS_PER_TASK];
	struct rte_ring        *tx_rings[MAX_RINGS_PER_TASK];
	struct rte_ring        *ctrl_plane_ring;
	uint32_t               tot_n_txrings_inited;
	struct ether_addr      edaddr;
	struct ether_addr      esaddr;
	struct port_queue      tx_port_queue[PROX_MAX_PORTS];
	struct port_queue      rx_port_queue[PROX_MAX_PORTS];
	/* Used to set up actual task at initialization time. */
	enum task_mode         mode;
	/* Destination output position in hw or sw when using mac learned dest port. */
	uint8_t                mapping[PROX_MAX_PORTS];
	struct rte_table_hash  *cpe_table;
	struct rte_table_hash  *qinq_gre_table;
	struct rte_hash        *cpe_gre_hash;
	struct rte_hash        *qinq_gre_hash;
	struct cpe_data        *cpe_data;
	struct cpe_gre_data    *cpe_gre_data;
	struct qinq_gre_data   *qinq_gre_data;
	uint8_t                tx_opt_ring;
	struct task_args       *tx_opt_ring_task;
	uint32_t               qinq_tag;

#ifdef ENABLE_EXTRA_USER_STATISTICS
	uint32_t               n_users;	// Number of users in user table.
#endif
	uint32_t               n_flows;	// Number of flows used in policing
	uint32_t               cir;
	uint32_t               cbs;
	uint32_t               ebs;
	uint32_t               pir;
	uint32_t               pbs;
	uint32_t               overhead;
	enum police_action     police_act[3][3];
	uint32_t               marking[4];
	uint32_t               n_max_rules;
	uint32_t               random_delay_us;
	uint32_t               delay_us;
	uint32_t               cpe_table_timeout_ms;
	uint32_t               etype;
#ifdef GRE_TP
	uint32_t tb_rate;                /**< Pipe token bucket rate (measured in bytes per second) */
	uint32_t tb_size;                /**< Pipe token bucket size (measured in credits) */
#endif
	uint8_t                tunnel_hop_limit;  /* IPv6 Tunnel - Hop limit */
        uint16_t               lookup_port_mask;  /* Ipv6 Tunnel - Mask applied to UDP/TCP port before lookup */
	uint32_t               ctrl_freq;
	uint8_t                lb_friend_core;
	uint8_t                lb_friend_task;
	/* gen related*/
	uint64_t               rate_bps;
	uint32_t               n_rand_str;
	char                   rand_str[64][64];
	uint32_t               rand_offset[64];
	char                   pcap_file[256];
	uint32_t               accur_pos;
	uint32_t               sig_pos;
	uint32_t               sig;
	uint32_t               lat_pos;
	uint32_t               packet_id_pos;
	uint32_t               latency_buffer_size;
	uint32_t               bucket_size;
	uint32_t               lat_enabled;
	uint32_t               pkt_size;
	uint8_t                pkt_inline[ETHER_MAX_LEN];
	uint32_t               probability;
	char                   nat_table[256];
	uint32_t               use_src;
	char                   route_table[256];
	char                   rules[256];
	char                   dscp[256];
	char                   tun_bindings[256];
	char                   cpe_table_name[256];
	char                   user_table[256];
	uint32_t               n_concur_conn;
	char                   streams[256];
	uint32_t               min_bulk_size;
	uint32_t               max_bulk_size;
	uint32_t               max_setup_rate;
	uint32_t               n_pkts;
	uint32_t               loop;
	uint32_t               flow_table_size;
	char                   dpi_engine_path[256];
	char                   dpi_engine_args[16][256];
	uint32_t               n_dpi_engine_args;
	uint32_t               generator_id;
	uint32_t               accuracy_limit_nsec;
	/* cgnat related */
	uint32_t                     public_ip_count;
	struct public_ip_config_info *public_ip_config_info;
	struct public_entry          *public_entries;
	struct private_flow_entry    *private_flow_entries;
	struct rte_hash              *public_ip_port_hash;
	struct rte_hash              *private_ip_port_hash;
	struct rte_hash              *private_ip_hash;
	struct private_ip_info       *private_ip_info;
	struct rte_ring			**ctrl_rx_rings;
	struct rte_ring			**ctrl_tx_rings;
	int				n_ctrl_rings;
	uint				irq_debug;
	struct task_base *tmaster;
	char sub_mode_str[PROX_MODE_LEN];
};

/* Return the first port that is reachable through the task. If the
   task itself does not send directly to a port, the function will
   search reachable tasks through each outgoing ring */
struct task_args *find_reachable_task_sending_to_port(struct task_args *from);
struct prox_port_cfg *find_reachable_port(struct task_args *from);

struct task_base *init_task_struct(struct task_args *targ);
struct task_init *to_task_init(const char *mode_str, const char *sub_mode_str);
void tasks_list(void);
int task_is_master(struct task_args *targ);

void reg_task(struct task_init* t);

#endif /* _TASK_INIT_H_ */