1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2019 Intel Corporation
13 #include <rte_ether.h>
14 #include <rte_ethdev_driver.h>
15 #include <rte_malloc.h>
16 #include <rte_tailq.h>
19 #include "iavf_generic_flow.h"
21 static struct iavf_engine_list engine_list =
22 TAILQ_HEAD_INITIALIZER(engine_list);
24 static int iavf_flow_validate(struct rte_eth_dev *dev,
25 const struct rte_flow_attr *attr,
26 const struct rte_flow_item pattern[],
27 const struct rte_flow_action actions[],
28 struct rte_flow_error *error);
29 static struct rte_flow *iavf_flow_create(struct rte_eth_dev *dev,
30 const struct rte_flow_attr *attr,
31 const struct rte_flow_item pattern[],
32 const struct rte_flow_action actions[],
33 struct rte_flow_error *error);
34 static int iavf_flow_destroy(struct rte_eth_dev *dev,
35 struct rte_flow *flow,
36 struct rte_flow_error *error);
37 static int iavf_flow_flush(struct rte_eth_dev *dev,
38 struct rte_flow_error *error);
39 static int iavf_flow_query(struct rte_eth_dev *dev,
40 struct rte_flow *flow,
41 const struct rte_flow_action *actions,
43 struct rte_flow_error *error);
45 const struct rte_flow_ops iavf_flow_ops = {
46 .validate = iavf_flow_validate,
47 .create = iavf_flow_create,
48 .destroy = iavf_flow_destroy,
49 .flush = iavf_flow_flush,
50 .query = iavf_flow_query,
54 enum rte_flow_item_type iavf_pattern_empty[] = {
55 RTE_FLOW_ITEM_TYPE_END,
59 enum rte_flow_item_type iavf_pattern_ethertype[] = {
60 RTE_FLOW_ITEM_TYPE_ETH,
61 RTE_FLOW_ITEM_TYPE_END,
64 enum rte_flow_item_type iavf_pattern_ethertype_vlan[] = {
65 RTE_FLOW_ITEM_TYPE_ETH,
66 RTE_FLOW_ITEM_TYPE_VLAN,
67 RTE_FLOW_ITEM_TYPE_END,
70 enum rte_flow_item_type iavf_pattern_ethertype_qinq[] = {
71 RTE_FLOW_ITEM_TYPE_ETH,
72 RTE_FLOW_ITEM_TYPE_VLAN,
73 RTE_FLOW_ITEM_TYPE_VLAN,
74 RTE_FLOW_ITEM_TYPE_END,
78 enum rte_flow_item_type iavf_pattern_eth_arp[] = {
79 RTE_FLOW_ITEM_TYPE_ETH,
80 RTE_FLOW_ITEM_TYPE_ARP_ETH_IPV4,
81 RTE_FLOW_ITEM_TYPE_END,
85 enum rte_flow_item_type iavf_pattern_eth_ipv4[] = {
86 RTE_FLOW_ITEM_TYPE_ETH,
87 RTE_FLOW_ITEM_TYPE_IPV4,
88 RTE_FLOW_ITEM_TYPE_END,
91 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv4[] = {
92 RTE_FLOW_ITEM_TYPE_ETH,
93 RTE_FLOW_ITEM_TYPE_VLAN,
94 RTE_FLOW_ITEM_TYPE_IPV4,
95 RTE_FLOW_ITEM_TYPE_END,
98 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv4[] = {
99 RTE_FLOW_ITEM_TYPE_ETH,
100 RTE_FLOW_ITEM_TYPE_VLAN,
101 RTE_FLOW_ITEM_TYPE_VLAN,
102 RTE_FLOW_ITEM_TYPE_IPV4,
103 RTE_FLOW_ITEM_TYPE_END,
106 enum rte_flow_item_type iavf_pattern_eth_ipv4_udp[] = {
107 RTE_FLOW_ITEM_TYPE_ETH,
108 RTE_FLOW_ITEM_TYPE_IPV4,
109 RTE_FLOW_ITEM_TYPE_UDP,
110 RTE_FLOW_ITEM_TYPE_END,
113 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv4_udp[] = {
114 RTE_FLOW_ITEM_TYPE_ETH,
115 RTE_FLOW_ITEM_TYPE_VLAN,
116 RTE_FLOW_ITEM_TYPE_IPV4,
117 RTE_FLOW_ITEM_TYPE_UDP,
118 RTE_FLOW_ITEM_TYPE_END,
121 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv4_udp[] = {
122 RTE_FLOW_ITEM_TYPE_ETH,
123 RTE_FLOW_ITEM_TYPE_VLAN,
124 RTE_FLOW_ITEM_TYPE_VLAN,
125 RTE_FLOW_ITEM_TYPE_IPV4,
126 RTE_FLOW_ITEM_TYPE_UDP,
127 RTE_FLOW_ITEM_TYPE_END,
130 enum rte_flow_item_type iavf_pattern_eth_ipv4_tcp[] = {
131 RTE_FLOW_ITEM_TYPE_ETH,
132 RTE_FLOW_ITEM_TYPE_IPV4,
133 RTE_FLOW_ITEM_TYPE_TCP,
134 RTE_FLOW_ITEM_TYPE_END,
137 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv4_tcp[] = {
138 RTE_FLOW_ITEM_TYPE_ETH,
139 RTE_FLOW_ITEM_TYPE_VLAN,
140 RTE_FLOW_ITEM_TYPE_IPV4,
141 RTE_FLOW_ITEM_TYPE_TCP,
142 RTE_FLOW_ITEM_TYPE_END,
145 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv4_tcp[] = {
146 RTE_FLOW_ITEM_TYPE_ETH,
147 RTE_FLOW_ITEM_TYPE_VLAN,
148 RTE_FLOW_ITEM_TYPE_VLAN,
149 RTE_FLOW_ITEM_TYPE_IPV4,
150 RTE_FLOW_ITEM_TYPE_TCP,
151 RTE_FLOW_ITEM_TYPE_END,
154 enum rte_flow_item_type iavf_pattern_eth_ipv4_sctp[] = {
155 RTE_FLOW_ITEM_TYPE_ETH,
156 RTE_FLOW_ITEM_TYPE_IPV4,
157 RTE_FLOW_ITEM_TYPE_SCTP,
158 RTE_FLOW_ITEM_TYPE_END,
161 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv4_sctp[] = {
162 RTE_FLOW_ITEM_TYPE_ETH,
163 RTE_FLOW_ITEM_TYPE_VLAN,
164 RTE_FLOW_ITEM_TYPE_IPV4,
165 RTE_FLOW_ITEM_TYPE_SCTP,
166 RTE_FLOW_ITEM_TYPE_END,
169 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv4_sctp[] = {
170 RTE_FLOW_ITEM_TYPE_ETH,
171 RTE_FLOW_ITEM_TYPE_VLAN,
172 RTE_FLOW_ITEM_TYPE_VLAN,
173 RTE_FLOW_ITEM_TYPE_IPV4,
174 RTE_FLOW_ITEM_TYPE_SCTP,
175 RTE_FLOW_ITEM_TYPE_END,
178 enum rte_flow_item_type iavf_pattern_eth_ipv4_icmp[] = {
179 RTE_FLOW_ITEM_TYPE_ETH,
180 RTE_FLOW_ITEM_TYPE_IPV4,
181 RTE_FLOW_ITEM_TYPE_ICMP,
182 RTE_FLOW_ITEM_TYPE_END,
185 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv4_icmp[] = {
186 RTE_FLOW_ITEM_TYPE_ETH,
187 RTE_FLOW_ITEM_TYPE_VLAN,
188 RTE_FLOW_ITEM_TYPE_IPV4,
189 RTE_FLOW_ITEM_TYPE_ICMP,
190 RTE_FLOW_ITEM_TYPE_END,
193 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv4_icmp[] = {
194 RTE_FLOW_ITEM_TYPE_ETH,
195 RTE_FLOW_ITEM_TYPE_VLAN,
196 RTE_FLOW_ITEM_TYPE_VLAN,
197 RTE_FLOW_ITEM_TYPE_IPV4,
198 RTE_FLOW_ITEM_TYPE_ICMP,
199 RTE_FLOW_ITEM_TYPE_END,
202 /* non-tunnel IPv6 */
203 enum rte_flow_item_type iavf_pattern_eth_ipv6[] = {
204 RTE_FLOW_ITEM_TYPE_ETH,
205 RTE_FLOW_ITEM_TYPE_IPV6,
206 RTE_FLOW_ITEM_TYPE_END,
209 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv6[] = {
210 RTE_FLOW_ITEM_TYPE_ETH,
211 RTE_FLOW_ITEM_TYPE_VLAN,
212 RTE_FLOW_ITEM_TYPE_IPV6,
213 RTE_FLOW_ITEM_TYPE_END,
216 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv6[] = {
217 RTE_FLOW_ITEM_TYPE_ETH,
218 RTE_FLOW_ITEM_TYPE_VLAN,
219 RTE_FLOW_ITEM_TYPE_VLAN,
220 RTE_FLOW_ITEM_TYPE_IPV6,
221 RTE_FLOW_ITEM_TYPE_END,
224 enum rte_flow_item_type iavf_pattern_eth_ipv6_udp[] = {
225 RTE_FLOW_ITEM_TYPE_ETH,
226 RTE_FLOW_ITEM_TYPE_IPV6,
227 RTE_FLOW_ITEM_TYPE_UDP,
228 RTE_FLOW_ITEM_TYPE_END,
231 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv6_udp[] = {
232 RTE_FLOW_ITEM_TYPE_ETH,
233 RTE_FLOW_ITEM_TYPE_VLAN,
234 RTE_FLOW_ITEM_TYPE_IPV6,
235 RTE_FLOW_ITEM_TYPE_UDP,
236 RTE_FLOW_ITEM_TYPE_END,
239 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv6_udp[] = {
240 RTE_FLOW_ITEM_TYPE_ETH,
241 RTE_FLOW_ITEM_TYPE_VLAN,
242 RTE_FLOW_ITEM_TYPE_VLAN,
243 RTE_FLOW_ITEM_TYPE_IPV6,
244 RTE_FLOW_ITEM_TYPE_UDP,
245 RTE_FLOW_ITEM_TYPE_END,
248 enum rte_flow_item_type iavf_pattern_eth_ipv6_tcp[] = {
249 RTE_FLOW_ITEM_TYPE_ETH,
250 RTE_FLOW_ITEM_TYPE_IPV6,
251 RTE_FLOW_ITEM_TYPE_TCP,
252 RTE_FLOW_ITEM_TYPE_END,
255 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv6_tcp[] = {
256 RTE_FLOW_ITEM_TYPE_ETH,
257 RTE_FLOW_ITEM_TYPE_VLAN,
258 RTE_FLOW_ITEM_TYPE_IPV6,
259 RTE_FLOW_ITEM_TYPE_TCP,
260 RTE_FLOW_ITEM_TYPE_END,
263 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv6_tcp[] = {
264 RTE_FLOW_ITEM_TYPE_ETH,
265 RTE_FLOW_ITEM_TYPE_VLAN,
266 RTE_FLOW_ITEM_TYPE_VLAN,
267 RTE_FLOW_ITEM_TYPE_IPV6,
268 RTE_FLOW_ITEM_TYPE_TCP,
269 RTE_FLOW_ITEM_TYPE_END,
272 enum rte_flow_item_type iavf_pattern_eth_ipv6_sctp[] = {
273 RTE_FLOW_ITEM_TYPE_ETH,
274 RTE_FLOW_ITEM_TYPE_IPV6,
275 RTE_FLOW_ITEM_TYPE_SCTP,
276 RTE_FLOW_ITEM_TYPE_END,
279 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv6_sctp[] = {
280 RTE_FLOW_ITEM_TYPE_ETH,
281 RTE_FLOW_ITEM_TYPE_VLAN,
282 RTE_FLOW_ITEM_TYPE_IPV6,
283 RTE_FLOW_ITEM_TYPE_SCTP,
284 RTE_FLOW_ITEM_TYPE_END,
287 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv6_sctp[] = {
288 RTE_FLOW_ITEM_TYPE_ETH,
289 RTE_FLOW_ITEM_TYPE_VLAN,
290 RTE_FLOW_ITEM_TYPE_VLAN,
291 RTE_FLOW_ITEM_TYPE_IPV6,
292 RTE_FLOW_ITEM_TYPE_SCTP,
293 RTE_FLOW_ITEM_TYPE_END,
296 enum rte_flow_item_type iavf_pattern_eth_ipv6_icmp6[] = {
297 RTE_FLOW_ITEM_TYPE_ETH,
298 RTE_FLOW_ITEM_TYPE_IPV6,
299 RTE_FLOW_ITEM_TYPE_ICMP6,
300 RTE_FLOW_ITEM_TYPE_END,
303 enum rte_flow_item_type iavf_pattern_eth_vlan_ipv6_icmp6[] = {
304 RTE_FLOW_ITEM_TYPE_ETH,
305 RTE_FLOW_ITEM_TYPE_VLAN,
306 RTE_FLOW_ITEM_TYPE_IPV6,
307 RTE_FLOW_ITEM_TYPE_ICMP6,
308 RTE_FLOW_ITEM_TYPE_END,
311 enum rte_flow_item_type iavf_pattern_eth_qinq_ipv6_icmp6[] = {
312 RTE_FLOW_ITEM_TYPE_ETH,
313 RTE_FLOW_ITEM_TYPE_VLAN,
314 RTE_FLOW_ITEM_TYPE_VLAN,
315 RTE_FLOW_ITEM_TYPE_IPV6,
316 RTE_FLOW_ITEM_TYPE_ICMP6,
317 RTE_FLOW_ITEM_TYPE_END,
321 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu[] = {
322 RTE_FLOW_ITEM_TYPE_ETH,
323 RTE_FLOW_ITEM_TYPE_IPV4,
324 RTE_FLOW_ITEM_TYPE_UDP,
325 RTE_FLOW_ITEM_TYPE_GTPU,
326 RTE_FLOW_ITEM_TYPE_END,
329 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh[] = {
330 RTE_FLOW_ITEM_TYPE_ETH,
331 RTE_FLOW_ITEM_TYPE_IPV4,
332 RTE_FLOW_ITEM_TYPE_UDP,
333 RTE_FLOW_ITEM_TYPE_GTPU,
334 RTE_FLOW_ITEM_TYPE_GTP_PSC,
335 RTE_FLOW_ITEM_TYPE_END,
338 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_ipv4[] = {
339 RTE_FLOW_ITEM_TYPE_ETH,
340 RTE_FLOW_ITEM_TYPE_IPV4,
341 RTE_FLOW_ITEM_TYPE_UDP,
342 RTE_FLOW_ITEM_TYPE_GTPU,
343 RTE_FLOW_ITEM_TYPE_IPV4,
344 RTE_FLOW_ITEM_TYPE_END,
347 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv4[] = {
348 RTE_FLOW_ITEM_TYPE_ETH,
349 RTE_FLOW_ITEM_TYPE_IPV4,
350 RTE_FLOW_ITEM_TYPE_UDP,
351 RTE_FLOW_ITEM_TYPE_GTPU,
352 RTE_FLOW_ITEM_TYPE_GTP_PSC,
353 RTE_FLOW_ITEM_TYPE_IPV4,
354 RTE_FLOW_ITEM_TYPE_END,
357 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv4_udp[] = {
358 RTE_FLOW_ITEM_TYPE_ETH,
359 RTE_FLOW_ITEM_TYPE_IPV4,
360 RTE_FLOW_ITEM_TYPE_UDP,
361 RTE_FLOW_ITEM_TYPE_GTPU,
362 RTE_FLOW_ITEM_TYPE_GTP_PSC,
363 RTE_FLOW_ITEM_TYPE_IPV4,
364 RTE_FLOW_ITEM_TYPE_UDP,
365 RTE_FLOW_ITEM_TYPE_END,
368 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv4_tcp[] = {
369 RTE_FLOW_ITEM_TYPE_ETH,
370 RTE_FLOW_ITEM_TYPE_IPV4,
371 RTE_FLOW_ITEM_TYPE_UDP,
372 RTE_FLOW_ITEM_TYPE_GTPU,
373 RTE_FLOW_ITEM_TYPE_GTP_PSC,
374 RTE_FLOW_ITEM_TYPE_IPV4,
375 RTE_FLOW_ITEM_TYPE_TCP,
376 RTE_FLOW_ITEM_TYPE_END,
380 enum rte_flow_item_type iavf_pattern_eth_ipv4_gtpu_eh_ipv4_icmp[] = {
381 RTE_FLOW_ITEM_TYPE_ETH,
382 RTE_FLOW_ITEM_TYPE_IPV4,
383 RTE_FLOW_ITEM_TYPE_UDP,
384 RTE_FLOW_ITEM_TYPE_GTPU,
385 RTE_FLOW_ITEM_TYPE_GTP_PSC,
386 RTE_FLOW_ITEM_TYPE_IPV4,
387 RTE_FLOW_ITEM_TYPE_ICMP,
388 RTE_FLOW_ITEM_TYPE_END,
392 enum rte_flow_item_type iavf_pattern_eth_ipv4_esp[] = {
393 RTE_FLOW_ITEM_TYPE_ETH,
394 RTE_FLOW_ITEM_TYPE_IPV4,
395 RTE_FLOW_ITEM_TYPE_ESP,
396 RTE_FLOW_ITEM_TYPE_END,
399 enum rte_flow_item_type iavf_pattern_eth_ipv4_udp_esp[] = {
400 RTE_FLOW_ITEM_TYPE_ETH,
401 RTE_FLOW_ITEM_TYPE_IPV4,
402 RTE_FLOW_ITEM_TYPE_UDP,
403 RTE_FLOW_ITEM_TYPE_ESP,
404 RTE_FLOW_ITEM_TYPE_END,
407 enum rte_flow_item_type iavf_pattern_eth_ipv6_esp[] = {
408 RTE_FLOW_ITEM_TYPE_ETH,
409 RTE_FLOW_ITEM_TYPE_IPV6,
410 RTE_FLOW_ITEM_TYPE_ESP,
411 RTE_FLOW_ITEM_TYPE_END,
414 enum rte_flow_item_type iavf_pattern_eth_ipv6_udp_esp[] = {
415 RTE_FLOW_ITEM_TYPE_ETH,
416 RTE_FLOW_ITEM_TYPE_IPV6,
417 RTE_FLOW_ITEM_TYPE_UDP,
418 RTE_FLOW_ITEM_TYPE_ESP,
419 RTE_FLOW_ITEM_TYPE_END,
423 enum rte_flow_item_type iavf_pattern_eth_ipv4_ah[] = {
424 RTE_FLOW_ITEM_TYPE_ETH,
425 RTE_FLOW_ITEM_TYPE_IPV4,
426 RTE_FLOW_ITEM_TYPE_AH,
427 RTE_FLOW_ITEM_TYPE_END,
430 enum rte_flow_item_type iavf_pattern_eth_ipv6_ah[] = {
431 RTE_FLOW_ITEM_TYPE_ETH,
432 RTE_FLOW_ITEM_TYPE_IPV6,
433 RTE_FLOW_ITEM_TYPE_AH,
434 RTE_FLOW_ITEM_TYPE_END,
438 enum rte_flow_item_type iavf_pattern_eth_ipv4_l2tpv3[] = {
439 RTE_FLOW_ITEM_TYPE_ETH,
440 RTE_FLOW_ITEM_TYPE_IPV4,
441 RTE_FLOW_ITEM_TYPE_L2TPV3OIP,
442 RTE_FLOW_ITEM_TYPE_END,
445 enum rte_flow_item_type iavf_pattern_eth_ipv6_l2tpv3[] = {
446 RTE_FLOW_ITEM_TYPE_ETH,
447 RTE_FLOW_ITEM_TYPE_IPV6,
448 RTE_FLOW_ITEM_TYPE_L2TPV3OIP,
449 RTE_FLOW_ITEM_TYPE_END,
453 enum rte_flow_item_type iavf_pattern_eth_ipv4_pfcp[] = {
454 RTE_FLOW_ITEM_TYPE_ETH,
455 RTE_FLOW_ITEM_TYPE_IPV4,
456 RTE_FLOW_ITEM_TYPE_UDP,
457 RTE_FLOW_ITEM_TYPE_PFCP,
458 RTE_FLOW_ITEM_TYPE_END,
461 enum rte_flow_item_type iavf_pattern_eth_ipv6_pfcp[] = {
462 RTE_FLOW_ITEM_TYPE_ETH,
463 RTE_FLOW_ITEM_TYPE_IPV6,
464 RTE_FLOW_ITEM_TYPE_UDP,
465 RTE_FLOW_ITEM_TYPE_PFCP,
466 RTE_FLOW_ITEM_TYPE_END,
469 typedef struct iavf_flow_engine * (*parse_engine_t)(struct iavf_adapter *ad,
470 struct rte_flow *flow,
471 struct iavf_parser_list *parser_list,
472 const struct rte_flow_item pattern[],
473 const struct rte_flow_action actions[],
474 struct rte_flow_error *error);
477 iavf_register_flow_engine(struct iavf_flow_engine *engine)
479 TAILQ_INSERT_TAIL(&engine_list, engine, node);
483 iavf_flow_init(struct iavf_adapter *ad)
486 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
488 struct iavf_flow_engine *engine;
490 TAILQ_INIT(&vf->flow_list);
491 TAILQ_INIT(&vf->rss_parser_list);
492 TAILQ_INIT(&vf->dist_parser_list);
493 rte_spinlock_init(&vf->flow_ops_lock);
495 TAILQ_FOREACH_SAFE(engine, &engine_list, node, temp) {
496 if (engine->init == NULL) {
497 PMD_INIT_LOG(ERR, "Invalid engine type (%d)",
502 ret = engine->init(ad);
503 if (ret && ret != -ENOTSUP) {
504 PMD_INIT_LOG(ERR, "Failed to initialize engine %d",
513 iavf_flow_uninit(struct iavf_adapter *ad)
515 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
516 struct iavf_flow_engine *engine;
517 struct rte_flow *p_flow;
518 struct iavf_flow_parser_node *p_parser;
521 TAILQ_FOREACH_SAFE(engine, &engine_list, node, temp) {
526 /* Remove all flows */
527 while ((p_flow = TAILQ_FIRST(&vf->flow_list))) {
528 TAILQ_REMOVE(&vf->flow_list, p_flow, node);
529 if (p_flow->engine->free)
530 p_flow->engine->free(p_flow);
534 /* Cleanup parser list */
535 while ((p_parser = TAILQ_FIRST(&vf->rss_parser_list))) {
536 TAILQ_REMOVE(&vf->rss_parser_list, p_parser, node);
540 while ((p_parser = TAILQ_FIRST(&vf->dist_parser_list))) {
541 TAILQ_REMOVE(&vf->dist_parser_list, p_parser, node);
547 iavf_register_parser(struct iavf_flow_parser *parser,
548 struct iavf_adapter *ad)
550 struct iavf_parser_list *list = NULL;
551 struct iavf_flow_parser_node *parser_node;
552 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
554 parser_node = rte_zmalloc("iavf_parser", sizeof(*parser_node), 0);
555 if (parser_node == NULL) {
556 PMD_DRV_LOG(ERR, "Failed to allocate memory.");
559 parser_node->parser = parser;
561 if (parser->engine->type == IAVF_FLOW_ENGINE_HASH) {
562 list = &vf->rss_parser_list;
563 TAILQ_INSERT_TAIL(list, parser_node, node);
564 } else if (parser->engine->type == IAVF_FLOW_ENGINE_FDIR) {
565 list = &vf->dist_parser_list;
566 TAILQ_INSERT_HEAD(list, parser_node, node);
575 iavf_unregister_parser(struct iavf_flow_parser *parser,
576 struct iavf_adapter *ad)
578 struct iavf_parser_list *list = NULL;
579 struct iavf_flow_parser_node *p_parser;
580 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
583 if (parser->engine->type == IAVF_FLOW_ENGINE_HASH)
584 list = &vf->rss_parser_list;
585 else if (parser->engine->type == IAVF_FLOW_ENGINE_FDIR)
586 list = &vf->dist_parser_list;
591 TAILQ_FOREACH_SAFE(p_parser, list, node, temp) {
592 if (p_parser->parser->engine->type == parser->engine->type) {
593 TAILQ_REMOVE(list, p_parser, node);
600 iavf_flow_valid_attr(const struct rte_flow_attr *attr,
601 struct rte_flow_error *error)
603 /* Must be input direction */
604 if (!attr->ingress) {
605 rte_flow_error_set(error, EINVAL,
606 RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
607 attr, "Only support ingress.");
613 rte_flow_error_set(error, EINVAL,
614 RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
615 attr, "Not support egress.");
620 if (attr->priority) {
621 rte_flow_error_set(error, EINVAL,
622 RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
623 attr, "Not support priority.");
629 rte_flow_error_set(error, EINVAL,
630 RTE_FLOW_ERROR_TYPE_ATTR_GROUP,
631 attr, "Not support group.");
638 /* Find the first VOID or non-VOID item pointer */
639 static const struct rte_flow_item *
640 iavf_find_first_item(const struct rte_flow_item *item, bool is_void)
644 while (item->type != RTE_FLOW_ITEM_TYPE_END) {
646 is_find = item->type == RTE_FLOW_ITEM_TYPE_VOID;
648 is_find = item->type != RTE_FLOW_ITEM_TYPE_VOID;
656 /* Skip all VOID items of the pattern */
658 iavf_pattern_skip_void_item(struct rte_flow_item *items,
659 const struct rte_flow_item *pattern)
661 uint32_t cpy_count = 0;
662 const struct rte_flow_item *pb = pattern, *pe = pattern;
665 /* Find a non-void item first */
666 pb = iavf_find_first_item(pb, false);
667 if (pb->type == RTE_FLOW_ITEM_TYPE_END) {
672 /* Find a void item */
673 pe = iavf_find_first_item(pb + 1, true);
676 rte_memcpy(items, pb, sizeof(struct rte_flow_item) * cpy_count);
680 if (pe->type == RTE_FLOW_ITEM_TYPE_END)
685 /* Copy the END item. */
686 rte_memcpy(items, pe, sizeof(struct rte_flow_item));
689 /* Check if the pattern matches a supported item type array */
691 iavf_match_pattern(enum rte_flow_item_type *item_array,
692 const struct rte_flow_item *pattern)
694 const struct rte_flow_item *item = pattern;
696 while ((*item_array == item->type) &&
697 (*item_array != RTE_FLOW_ITEM_TYPE_END)) {
702 return (*item_array == RTE_FLOW_ITEM_TYPE_END &&
703 item->type == RTE_FLOW_ITEM_TYPE_END);
706 struct iavf_pattern_match_item *
707 iavf_search_pattern_match_item(const struct rte_flow_item pattern[],
708 struct iavf_pattern_match_item *array,
710 struct rte_flow_error *error)
713 struct iavf_pattern_match_item *pattern_match_item;
714 /* need free by each filter */
715 struct rte_flow_item *items; /* used for pattern without VOID items */
716 uint32_t item_num = 0; /* non-void item number */
718 /* Get the non-void item number of pattern */
719 while ((pattern + i)->type != RTE_FLOW_ITEM_TYPE_END) {
720 if ((pattern + i)->type != RTE_FLOW_ITEM_TYPE_VOID)
726 items = rte_zmalloc("iavf_pattern",
727 item_num * sizeof(struct rte_flow_item), 0);
729 rte_flow_error_set(error, ENOMEM, RTE_FLOW_ERROR_TYPE_ITEM_NUM,
730 NULL, "No memory for PMD internal items.");
733 pattern_match_item = rte_zmalloc("iavf_pattern_match_item",
734 sizeof(struct iavf_pattern_match_item), 0);
735 if (!pattern_match_item) {
736 rte_flow_error_set(error, ENOMEM, RTE_FLOW_ERROR_TYPE_HANDLE,
737 NULL, "Failed to allocate memory.");
741 iavf_pattern_skip_void_item(items, pattern);
743 for (i = 0; i < array_len; i++)
744 if (iavf_match_pattern(array[i].pattern_list,
746 pattern_match_item->input_set_mask =
747 array[i].input_set_mask;
748 pattern_match_item->pattern_list =
749 array[i].pattern_list;
750 pattern_match_item->meta = array[i].meta;
752 return pattern_match_item;
754 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM,
755 pattern, "Unsupported pattern");
758 rte_free(pattern_match_item);
762 static struct iavf_flow_engine *
763 iavf_parse_engine_create(struct iavf_adapter *ad,
764 struct rte_flow *flow,
765 struct iavf_parser_list *parser_list,
766 const struct rte_flow_item pattern[],
767 const struct rte_flow_action actions[],
768 struct rte_flow_error *error)
770 struct iavf_flow_engine *engine = NULL;
771 struct iavf_flow_parser_node *parser_node;
775 TAILQ_FOREACH_SAFE(parser_node, parser_list, node, temp) {
776 if (parser_node->parser->parse_pattern_action(ad,
777 parser_node->parser->array,
778 parser_node->parser->array_len,
779 pattern, actions, &meta, error) < 0)
782 engine = parser_node->parser->engine;
784 RTE_ASSERT(engine->create != NULL);
785 if (!(engine->create(ad, flow, meta, error)))
791 static struct iavf_flow_engine *
792 iavf_parse_engine_validate(struct iavf_adapter *ad,
793 struct rte_flow *flow,
794 struct iavf_parser_list *parser_list,
795 const struct rte_flow_item pattern[],
796 const struct rte_flow_action actions[],
797 struct rte_flow_error *error)
799 struct iavf_flow_engine *engine = NULL;
800 struct iavf_flow_parser_node *parser_node;
804 TAILQ_FOREACH_SAFE(parser_node, parser_list, node, temp) {
805 if (parser_node->parser->parse_pattern_action(ad,
806 parser_node->parser->array,
807 parser_node->parser->array_len,
808 pattern, actions, &meta, error) < 0)
811 engine = parser_node->parser->engine;
812 if (engine->validation == NULL) {
813 rte_flow_error_set(error, EINVAL,
814 RTE_FLOW_ERROR_TYPE_HANDLE,
815 NULL, "Validation not support");
819 if (engine->validation(ad, flow, meta, error)) {
820 rte_flow_error_set(error, EINVAL,
821 RTE_FLOW_ERROR_TYPE_HANDLE,
822 NULL, "Validation failed");
831 iavf_flow_process_filter(struct rte_eth_dev *dev,
832 struct rte_flow *flow,
833 const struct rte_flow_attr *attr,
834 const struct rte_flow_item pattern[],
835 const struct rte_flow_action actions[],
836 struct iavf_flow_engine **engine,
837 parse_engine_t iavf_parse_engine,
838 struct rte_flow_error *error)
840 int ret = IAVF_ERR_CONFIG;
841 struct iavf_adapter *ad =
842 IAVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
843 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
846 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM_NUM,
847 NULL, "NULL pattern.");
852 rte_flow_error_set(error, EINVAL,
853 RTE_FLOW_ERROR_TYPE_ACTION_NUM,
854 NULL, "NULL action.");
859 rte_flow_error_set(error, EINVAL,
860 RTE_FLOW_ERROR_TYPE_ATTR,
861 NULL, "NULL attribute.");
865 ret = iavf_flow_valid_attr(attr, error);
869 *engine = iavf_parse_engine(ad, flow, &vf->rss_parser_list, pattern,
874 *engine = iavf_parse_engine(ad, flow, &vf->dist_parser_list, pattern,
884 iavf_flow_validate(struct rte_eth_dev *dev,
885 const struct rte_flow_attr *attr,
886 const struct rte_flow_item pattern[],
887 const struct rte_flow_action actions[],
888 struct rte_flow_error *error)
890 struct iavf_flow_engine *engine;
892 return iavf_flow_process_filter(dev, NULL, attr, pattern, actions,
893 &engine, iavf_parse_engine_validate, error);
896 static struct rte_flow *
897 iavf_flow_create(struct rte_eth_dev *dev,
898 const struct rte_flow_attr *attr,
899 const struct rte_flow_item pattern[],
900 const struct rte_flow_action actions[],
901 struct rte_flow_error *error)
903 struct iavf_adapter *ad =
904 IAVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
905 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
906 struct iavf_flow_engine *engine = NULL;
907 struct rte_flow *flow = NULL;
910 flow = rte_zmalloc("iavf_flow", sizeof(struct rte_flow), 0);
912 rte_flow_error_set(error, ENOMEM,
913 RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
914 "Failed to allocate memory");
918 ret = iavf_flow_process_filter(dev, flow, attr, pattern, actions,
919 &engine, iavf_parse_engine_create, error);
921 PMD_DRV_LOG(ERR, "Failed to create flow");
927 flow->engine = engine;
928 TAILQ_INSERT_TAIL(&vf->flow_list, flow, node);
929 PMD_DRV_LOG(INFO, "Succeeded to create (%d) flow", engine->type);
932 rte_spinlock_unlock(&vf->flow_ops_lock);
937 iavf_flow_destroy(struct rte_eth_dev *dev,
938 struct rte_flow *flow,
939 struct rte_flow_error *error)
941 struct iavf_adapter *ad =
942 IAVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
943 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
946 if (!flow || !flow->engine || !flow->engine->destroy) {
947 rte_flow_error_set(error, EINVAL,
948 RTE_FLOW_ERROR_TYPE_HANDLE,
949 NULL, "Invalid flow");
953 rte_spinlock_lock(&vf->flow_ops_lock);
955 ret = flow->engine->destroy(ad, flow, error);
958 TAILQ_REMOVE(&vf->flow_list, flow, node);
961 PMD_DRV_LOG(ERR, "Failed to destroy flow");
964 rte_spinlock_unlock(&vf->flow_ops_lock);
970 iavf_flow_flush(struct rte_eth_dev *dev,
971 struct rte_flow_error *error)
973 struct iavf_adapter *ad =
974 IAVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
975 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(ad);
976 struct rte_flow *p_flow;
980 TAILQ_FOREACH_SAFE(p_flow, &vf->flow_list, node, temp) {
981 ret = iavf_flow_destroy(dev, p_flow, error);
983 PMD_DRV_LOG(ERR, "Failed to flush flows");
992 iavf_flow_query(struct rte_eth_dev *dev,
993 struct rte_flow *flow,
994 const struct rte_flow_action *actions,
996 struct rte_flow_error *error)
999 struct iavf_adapter *ad =
1000 IAVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
1001 struct rte_flow_query_count *count = data;
1003 if (!flow || !flow->engine || !flow->engine->query_count) {
1004 rte_flow_error_set(error, EINVAL,
1005 RTE_FLOW_ERROR_TYPE_HANDLE,
1006 NULL, "Invalid flow");
1010 for (; actions->type != RTE_FLOW_ACTION_TYPE_END; actions++) {
1011 switch (actions->type) {
1012 case RTE_FLOW_ACTION_TYPE_VOID:
1014 case RTE_FLOW_ACTION_TYPE_COUNT:
1015 ret = flow->engine->query_count(ad, flow, count, error);
1018 return rte_flow_error_set(error, ENOTSUP,
1019 RTE_FLOW_ERROR_TYPE_ACTION,
1021 "action not supported");