1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2010-2016 Intel Corporation
3 */
4
5 #include <stdio.h>
6 #include <stdlib.h>
7 #include <stdint.h>
8
9 #include <rte_log.h>
10 #include <rte_ethdev.h>
11 #include <rte_ether.h>
12 #include <rte_ip.h>
13 #include <rte_byteorder.h>
14
15 #include <rte_port_ring.h>
16 #include <rte_table_acl.h>
17 #include <rte_pipeline.h>
18
19 #include "main.h"
20
21 enum {
22 PROTO_FIELD_IPV4,
23 SRC_FIELD_IPV4,
24 DST_FIELD_IPV4,
25 SRCP_FIELD_IPV4,
26 DSTP_FIELD_IPV4,
27 NUM_FIELDS_IPV4
28 };
29
30 /*
31 * Here we define the 'shape' of the data we're searching for,
32 * by defining the meta-data of the ACL rules.
33 * in this case, we're defining 5 tuples. IP addresses, ports,
34 * and protocol.
35 */
36 struct rte_acl_field_def ipv4_field_formats[NUM_FIELDS_IPV4] = {
37 {
38 .type = RTE_ACL_FIELD_TYPE_BITMASK,
39 .size = sizeof(uint8_t),
40 .field_index = PROTO_FIELD_IPV4,
41 .input_index = PROTO_FIELD_IPV4,
42 .offset = sizeof(struct rte_ether_hdr) +
43 offsetof(struct rte_ipv4_hdr, next_proto_id),
44 },
45 {
46 .type = RTE_ACL_FIELD_TYPE_MASK,
47 .size = sizeof(uint32_t),
48 .field_index = SRC_FIELD_IPV4,
49 .input_index = SRC_FIELD_IPV4,
50 .offset = sizeof(struct rte_ether_hdr) +
51 offsetof(struct rte_ipv4_hdr, src_addr),
52 },
53 {
54 .type = RTE_ACL_FIELD_TYPE_MASK,
55 .size = sizeof(uint32_t),
56 .field_index = DST_FIELD_IPV4,
57 .input_index = DST_FIELD_IPV4,
58 .offset = sizeof(struct rte_ether_hdr) +
59 offsetof(struct rte_ipv4_hdr, dst_addr),
60 },
61 {
62 .type = RTE_ACL_FIELD_TYPE_RANGE,
63 .size = sizeof(uint16_t),
64 .field_index = SRCP_FIELD_IPV4,
65 .input_index = SRCP_FIELD_IPV4,
66 .offset = sizeof(struct rte_ether_hdr) +
67 sizeof(struct rte_ipv4_hdr),
68 },
69 {
70 .type = RTE_ACL_FIELD_TYPE_RANGE,
71 .size = sizeof(uint16_t),
72 .field_index = DSTP_FIELD_IPV4,
73 .input_index = SRCP_FIELD_IPV4,
74 .offset = sizeof(struct rte_ether_hdr) +
75 sizeof(struct rte_ipv4_hdr) + sizeof(uint16_t),
76 },
77 };
78
79
80
81 void
app_main_loop_worker_pipeline_acl(void)82 app_main_loop_worker_pipeline_acl(void) {
83 struct rte_pipeline_params pipeline_params = {
84 .name = "pipeline",
85 .socket_id = rte_socket_id(),
86 };
87
88 struct rte_pipeline *p;
89 uint32_t port_in_id[APP_MAX_PORTS];
90 uint32_t port_out_id[APP_MAX_PORTS];
91 uint32_t table_id;
92 uint32_t i;
93
94 RTE_LOG(INFO, USER1,
95 "Core %u is doing work (pipeline with ACL table)\n",
96 rte_lcore_id());
97
98 /* Pipeline configuration */
99 p = rte_pipeline_create(&pipeline_params);
100 if (p == NULL)
101 rte_panic("Unable to configure the pipeline\n");
102
103 /* Input port configuration */
104 for (i = 0; i < app.n_ports; i++) {
105 struct rte_port_ring_reader_params port_ring_params = {
106 .ring = app.rings_rx[i],
107 };
108
109 struct rte_pipeline_port_in_params port_params = {
110 .ops = &rte_port_ring_reader_ops,
111 .arg_create = (void *) &port_ring_params,
112 .f_action = NULL,
113 .arg_ah = NULL,
114 .burst_size = app.burst_size_worker_read,
115 };
116
117 if (rte_pipeline_port_in_create(p, &port_params,
118 &port_in_id[i]))
119 rte_panic("Unable to configure input port for "
120 "ring %d\n", i);
121 }
122
123 /* Output port configuration */
124 for (i = 0; i < app.n_ports; i++) {
125 struct rte_port_ring_writer_params port_ring_params = {
126 .ring = app.rings_tx[i],
127 .tx_burst_sz = app.burst_size_worker_write,
128 };
129
130 struct rte_pipeline_port_out_params port_params = {
131 .ops = &rte_port_ring_writer_ops,
132 .arg_create = (void *) &port_ring_params,
133 .f_action = NULL,
134 .arg_ah = NULL,
135 };
136
137 if (rte_pipeline_port_out_create(p, &port_params,
138 &port_out_id[i]))
139 rte_panic("Unable to configure output port for "
140 "ring %d\n", i);
141 }
142
143 /* Table configuration */
144 {
145 struct rte_table_acl_params table_acl_params = {
146 .name = "test", /* unique identifier for acl contexts */
147 .n_rules = 1 << 5,
148 .n_rule_fields = DIM(ipv4_field_formats),
149 };
150
151 /* Copy in the rule meta-data defined above into the params */
152 memcpy(table_acl_params.field_format, ipv4_field_formats,
153 sizeof(ipv4_field_formats));
154
155 struct rte_pipeline_table_params table_params = {
156 .ops = &rte_table_acl_ops,
157 .arg_create = &table_acl_params,
158 .f_action_hit = NULL,
159 .f_action_miss = NULL,
160 .arg_ah = NULL,
161 .action_data_size = 0,
162 };
163
164 if (rte_pipeline_table_create(p, &table_params, &table_id))
165 rte_panic("Unable to configure the ACL table\n");
166 }
167
168 /* Interconnecting ports and tables */
169 for (i = 0; i < app.n_ports; i++)
170 if (rte_pipeline_port_in_connect_to_table(p, port_in_id[i],
171 table_id))
172 rte_panic("Unable to connect input port %u to "
173 "table %u\n", port_in_id[i], table_id);
174
175 /* Add entries to tables */
176 for (i = 0; i < app.n_ports; i++) {
177 struct rte_pipeline_table_entry table_entry = {
178 .action = RTE_PIPELINE_ACTION_PORT,
179 {.port_id = port_out_id[i & (app.n_ports - 1)]},
180 };
181 struct rte_table_acl_rule_add_params rule_params;
182 struct rte_pipeline_table_entry *entry_ptr;
183 int key_found, ret;
184
185 memset(&rule_params, 0, sizeof(rule_params));
186
187 /* Set the rule values */
188 rule_params.field_value[SRC_FIELD_IPV4].value.u32 = 0;
189 rule_params.field_value[SRC_FIELD_IPV4].mask_range.u32 = 0;
190 rule_params.field_value[DST_FIELD_IPV4].value.u32 =
191 i << (24 - rte_popcount32(app.n_ports - 1));
192 rule_params.field_value[DST_FIELD_IPV4].mask_range.u32 =
193 8 + rte_popcount32(app.n_ports - 1);
194 rule_params.field_value[SRCP_FIELD_IPV4].value.u16 = 0;
195 rule_params.field_value[SRCP_FIELD_IPV4].mask_range.u16 =
196 UINT16_MAX;
197 rule_params.field_value[DSTP_FIELD_IPV4].value.u16 = 0;
198 rule_params.field_value[DSTP_FIELD_IPV4].mask_range.u16 =
199 UINT16_MAX;
200 rule_params.field_value[PROTO_FIELD_IPV4].value.u8 = 0;
201 rule_params.field_value[PROTO_FIELD_IPV4].mask_range.u8 = 0;
202
203 rule_params.priority = 0;
204
205 uint32_t dst_addr = rule_params.field_value[DST_FIELD_IPV4].
206 value.u32;
207 uint32_t dst_mask =
208 rule_params.field_value[DST_FIELD_IPV4].mask_range.u32;
209
210 printf("Adding rule to ACL table (IPv4 destination = "
211 "%u.%u.%u.%u/%u => port out = %u)\n",
212 (dst_addr & 0xFF000000) >> 24,
213 (dst_addr & 0x00FF0000) >> 16,
214 (dst_addr & 0x0000FF00) >> 8,
215 dst_addr & 0x000000FF,
216 dst_mask,
217 table_entry.port_id);
218
219 /* For ACL, add needs an rte_table_acl_rule_add_params struct */
220 ret = rte_pipeline_table_entry_add(p, table_id, &rule_params,
221 &table_entry, &key_found, &entry_ptr);
222 if (ret < 0)
223 rte_panic("Unable to add entry to table %u (%d)\n",
224 table_id, ret);
225 }
226
227 /* Enable input ports */
228 for (i = 0; i < app.n_ports; i++)
229 if (rte_pipeline_port_in_enable(p, port_in_id[i]))
230 rte_panic("Unable to enable input port %u\n",
231 port_in_id[i]);
232
233 /* Check pipeline consistency */
234 if (rte_pipeline_check(p) < 0)
235 rte_panic("Pipeline consistency check failed\n");
236
237 /* Run-time */
238 #if APP_FLUSH == 0
239 while (!force_quit)
240 rte_pipeline_run(p);
241 #else
242 i = 0;
243 while (!force_quit) {
244 rte_pipeline_run(p);
245
246 if ((i & APP_FLUSH) == 0)
247 rte_pipeline_flush(p);
248 i++;
249 }
250 #endif
251 }
252