]> git.proxmox.com Git - ceph.git/blob - ceph/src/spdk/dpdk/drivers/net/e1000/igb_flow.c
projects / ceph.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
update sources to ceph Nautilus 14.2.1
[ceph.git] / ceph / src / spdk / dpdk / drivers / net / e1000 / igb_flow.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2010-2016 Intel Corporation
3 */
4
5 #include <sys/queue.h>
6 #include <stdio.h>
7 #include <errno.h>
8 #include <stdint.h>
9 #include <stdarg.h>
10
11 #include <rte_common.h>
12 #include <rte_interrupts.h>
13 #include <rte_byteorder.h>
14 #include <rte_log.h>
15 #include <rte_debug.h>
16 #include <rte_pci.h>
17 #include <rte_ether.h>
18 #include <rte_ethdev_driver.h>
19 #include <rte_ethdev_pci.h>
20 #include <rte_memory.h>
21 #include <rte_eal.h>
22 #include <rte_atomic.h>
23 #include <rte_malloc.h>
24 #include <rte_dev.h>
25 #include <rte_flow.h>
26 #include <rte_flow_driver.h>
27
28 #include "e1000_logs.h"
29 #include "base/e1000_api.h"
30 #include "e1000_ethdev.h"
31
32 #define NEXT_ITEM_OF_PATTERN(item, pattern, index) \
33 do { \
34 item = (pattern) + (index); \
35 while (item->type == RTE_FLOW_ITEM_TYPE_VOID) { \
36 (index)++; \
37 item = (pattern) + (index); \
38 } \
39 } while (0)
40
41 #define NEXT_ITEM_OF_ACTION(act, actions, index) \
42 do { \
43 act = (actions) + (index); \
44 while (act->type == RTE_FLOW_ACTION_TYPE_VOID) {\
45 (index)++; \
46 act = (actions) + (index); \
47 } \
48 } while (0)
49
50 #define IGB_FLEX_RAW_NUM 12
51
52 /**
53 * Please aware there's an asumption for all the parsers.
54 * rte_flow_item is using big endian, rte_flow_attr and
55 * rte_flow_action are using CPU order.
56 * Because the pattern is used to describe the packets,
57 * normally the packets should use network order.
58 */
59
60 /**
61 * Parse the rule to see if it is a n-tuple rule.
62 * And get the n-tuple filter info BTW.
63 * pattern:
64 * The first not void item can be ETH or IPV4.
65 * The second not void item must be IPV4 if the first one is ETH.
66 * The third not void item must be UDP or TCP or SCTP
67 * The next not void item must be END.
68 * action:
69 * The first not void action should be QUEUE.
70 * The next not void action should be END.
71 * pattern example:
72 * ITEM Spec Mask
73 * ETH NULL NULL
74 * IPV4 src_addr 192.168.1.20 0xFFFFFFFF
75 * dst_addr 192.167.3.50 0xFFFFFFFF
76 * next_proto_id 17 0xFF
77 * UDP/TCP/ src_port 80 0xFFFF
78 * SCTP dst_port 80 0xFFFF
79 * END
80 * other members in mask and spec should set to 0x00.
81 * item->last should be NULL.
82 */
83 static int
84 cons_parse_ntuple_filter(const struct rte_flow_attr *attr,
85 const struct rte_flow_item pattern[],
86 const struct rte_flow_action actions[],
87 struct rte_eth_ntuple_filter *filter,
88 struct rte_flow_error *error)
89 {
90 const struct rte_flow_item *item;
91 const struct rte_flow_action *act;
92 const struct rte_flow_item_ipv4 *ipv4_spec;
93 const struct rte_flow_item_ipv4 *ipv4_mask;
94 const struct rte_flow_item_tcp *tcp_spec;
95 const struct rte_flow_item_tcp *tcp_mask;
96 const struct rte_flow_item_udp *udp_spec;
97 const struct rte_flow_item_udp *udp_mask;
98 const struct rte_flow_item_sctp *sctp_spec;
99 const struct rte_flow_item_sctp *sctp_mask;
100 uint32_t index;
101
102 if (!pattern) {
103 rte_flow_error_set(error,
104 EINVAL, RTE_FLOW_ERROR_TYPE_ITEM_NUM,
105 NULL, "NULL pattern.");
106 return -rte_errno;
107 }
108
109 if (!actions) {
110 rte_flow_error_set(error, EINVAL,
111 RTE_FLOW_ERROR_TYPE_ACTION_NUM,
112 NULL, "NULL action.");
113 return -rte_errno;
114 }
115 if (!attr) {
116 rte_flow_error_set(error, EINVAL,
117 RTE_FLOW_ERROR_TYPE_ATTR,
118 NULL, "NULL attribute.");
119 return -rte_errno;
120 }
121
122 /* parse pattern */
123 index = 0;
124
125 /* the first not void item can be MAC or IPv4 */
126 NEXT_ITEM_OF_PATTERN(item, pattern, index);
127
128 if (item->type != RTE_FLOW_ITEM_TYPE_ETH &&
129 item->type != RTE_FLOW_ITEM_TYPE_IPV4) {
130 rte_flow_error_set(error, EINVAL,
131 RTE_FLOW_ERROR_TYPE_ITEM,
132 item, "Not supported by ntuple filter");
133 return -rte_errno;
134 }
135 /* Skip Ethernet */
136 if (item->type == RTE_FLOW_ITEM_TYPE_ETH) {
137 /*Not supported last point for range*/
138 if (item->last) {
139 rte_flow_error_set(error,
140 EINVAL,
141 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
142 item, "Not supported last point for range");
143 return -rte_errno;
144 }
145 /* if the first item is MAC, the content should be NULL */
146 if (item->spec || item->mask) {
147 rte_flow_error_set(error, EINVAL,
148 RTE_FLOW_ERROR_TYPE_ITEM,
149 item, "Not supported by ntuple filter");
150 return -rte_errno;
151 }
152 /* check if the next not void item is IPv4 */
153 index++;
154 NEXT_ITEM_OF_PATTERN(item, pattern, index);
155 if (item->type != RTE_FLOW_ITEM_TYPE_IPV4) {
156 rte_flow_error_set(error,
157 EINVAL, RTE_FLOW_ERROR_TYPE_ITEM,
158 item, "Not supported by ntuple filter");
159 return -rte_errno;
160 }
161 }
162
163 /* get the IPv4 info */
164 if (!item->spec || !item->mask) {
165 rte_flow_error_set(error, EINVAL,
166 RTE_FLOW_ERROR_TYPE_ITEM,
167 item, "Invalid ntuple mask");
168 return -rte_errno;
169 }
170 /* Not supported last point for range */
171 if (item->last) {
172 rte_flow_error_set(error, EINVAL,
173 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
174 item, "Not supported last point for range");
175 return -rte_errno;
176 }
177
178 ipv4_mask = item->mask;
179 /**
180 * Only support src & dst addresses, protocol,
181 * others should be masked.
182 */
183
184 if (ipv4_mask->hdr.version_ihl ||
185 ipv4_mask->hdr.type_of_service ||
186 ipv4_mask->hdr.total_length ||
187 ipv4_mask->hdr.packet_id ||
188 ipv4_mask->hdr.fragment_offset ||
189 ipv4_mask->hdr.time_to_live ||
190 ipv4_mask->hdr.hdr_checksum) {
191 rte_flow_error_set(error,
192 EINVAL, RTE_FLOW_ERROR_TYPE_ITEM,
193 item, "Not supported by ntuple filter");
194 return -rte_errno;
195 }
196
197 filter->dst_ip_mask = ipv4_mask->hdr.dst_addr;
198 filter->src_ip_mask = ipv4_mask->hdr.src_addr;
199 filter->proto_mask = ipv4_mask->hdr.next_proto_id;
200
201 ipv4_spec = item->spec;
202 filter->dst_ip = ipv4_spec->hdr.dst_addr;
203 filter->src_ip = ipv4_spec->hdr.src_addr;
204 filter->proto = ipv4_spec->hdr.next_proto_id;
205
206 /* check if the next not void item is TCP or UDP or SCTP */
207 index++;
208 NEXT_ITEM_OF_PATTERN(item, pattern, index);
209 if (item->type != RTE_FLOW_ITEM_TYPE_TCP &&
210 item->type != RTE_FLOW_ITEM_TYPE_UDP &&
211 item->type != RTE_FLOW_ITEM_TYPE_SCTP) {
212 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
213 rte_flow_error_set(error, EINVAL,
214 RTE_FLOW_ERROR_TYPE_ITEM,
215 item, "Not supported by ntuple filter");
216 return -rte_errno;
217 }
218
219 /* Not supported last point for range */
220 if (item->last) {
221 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
222 rte_flow_error_set(error, EINVAL,
223 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
224 item, "Not supported last point for range");
225 return -rte_errno;
226 }
227
228 /* get the TCP/UDP/SCTP info */
229 if (item->type == RTE_FLOW_ITEM_TYPE_TCP) {
230 if (item->spec && item->mask) {
231 tcp_mask = item->mask;
232
233 /**
234 * Only support src & dst ports, tcp flags,
235 * others should be masked.
236 */
237 if (tcp_mask->hdr.sent_seq ||
238 tcp_mask->hdr.recv_ack ||
239 tcp_mask->hdr.data_off ||
240 tcp_mask->hdr.rx_win ||
241 tcp_mask->hdr.cksum ||
242 tcp_mask->hdr.tcp_urp) {
243 memset(filter, 0,
244 sizeof(struct rte_eth_ntuple_filter));
245 rte_flow_error_set(error, EINVAL,
246 RTE_FLOW_ERROR_TYPE_ITEM,
247 item, "Not supported by ntuple filter");
248 return -rte_errno;
249 }
250
251 filter->dst_port_mask = tcp_mask->hdr.dst_port;
252 filter->src_port_mask = tcp_mask->hdr.src_port;
253 if (tcp_mask->hdr.tcp_flags == 0xFF) {
254 filter->flags |= RTE_NTUPLE_FLAGS_TCP_FLAG;
255 } else if (!tcp_mask->hdr.tcp_flags) {
256 filter->flags &= ~RTE_NTUPLE_FLAGS_TCP_FLAG;
257 } else {
258 memset(filter, 0,
259 sizeof(struct rte_eth_ntuple_filter));
260 rte_flow_error_set(error, EINVAL,
261 RTE_FLOW_ERROR_TYPE_ITEM,
262 item, "Not supported by ntuple filter");
263 return -rte_errno;
264 }
265
266 tcp_spec = item->spec;
267 filter->dst_port = tcp_spec->hdr.dst_port;
268 filter->src_port = tcp_spec->hdr.src_port;
269 filter->tcp_flags = tcp_spec->hdr.tcp_flags;
270 }
271 } else if (item->type == RTE_FLOW_ITEM_TYPE_UDP) {
272 if (item->spec && item->mask) {
273 udp_mask = item->mask;
274
275 /**
276 * Only support src & dst ports,
277 * others should be masked.
278 */
279 if (udp_mask->hdr.dgram_len ||
280 udp_mask->hdr.dgram_cksum) {
281 memset(filter, 0,
282 sizeof(struct rte_eth_ntuple_filter));
283 rte_flow_error_set(error, EINVAL,
284 RTE_FLOW_ERROR_TYPE_ITEM,
285 item, "Not supported by ntuple filter");
286 return -rte_errno;
287 }
288
289 filter->dst_port_mask = udp_mask->hdr.dst_port;
290 filter->src_port_mask = udp_mask->hdr.src_port;
291
292 udp_spec = item->spec;
293 filter->dst_port = udp_spec->hdr.dst_port;
294 filter->src_port = udp_spec->hdr.src_port;
295 }
296 } else {
297 if (item->spec && item->mask) {
298 sctp_mask = item->mask;
299
300 /**
301 * Only support src & dst ports,
302 * others should be masked.
303 */
304 if (sctp_mask->hdr.tag ||
305 sctp_mask->hdr.cksum) {
306 memset(filter, 0,
307 sizeof(struct rte_eth_ntuple_filter));
308 rte_flow_error_set(error, EINVAL,
309 RTE_FLOW_ERROR_TYPE_ITEM,
310 item, "Not supported by ntuple filter");
311 return -rte_errno;
312 }
313
314 filter->dst_port_mask = sctp_mask->hdr.dst_port;
315 filter->src_port_mask = sctp_mask->hdr.src_port;
316
317 sctp_spec = (const struct rte_flow_item_sctp *)
318 item->spec;
319 filter->dst_port = sctp_spec->hdr.dst_port;
320 filter->src_port = sctp_spec->hdr.src_port;
321 }
322 }
323 /* check if the next not void item is END */
324 index++;
325 NEXT_ITEM_OF_PATTERN(item, pattern, index);
326 if (item->type != RTE_FLOW_ITEM_TYPE_END) {
327 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
328 rte_flow_error_set(error, EINVAL,
329 RTE_FLOW_ERROR_TYPE_ITEM,
330 item, "Not supported by ntuple filter");
331 return -rte_errno;
332 }
333
334 /* parse action */
335 index = 0;
336
337 /**
338 * n-tuple only supports forwarding,
339 * check if the first not void action is QUEUE.
340 */
341 NEXT_ITEM_OF_ACTION(act, actions, index);
342 if (act->type != RTE_FLOW_ACTION_TYPE_QUEUE) {
343 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
344 rte_flow_error_set(error, EINVAL,
345 RTE_FLOW_ERROR_TYPE_ACTION,
346 item, "Not supported action.");
347 return -rte_errno;
348 }
349 filter->queue =
350 ((const struct rte_flow_action_queue *)act->conf)->index;
351
352 /* check if the next not void item is END */
353 index++;
354 NEXT_ITEM_OF_ACTION(act, actions, index);
355 if (act->type != RTE_FLOW_ACTION_TYPE_END) {
356 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
357 rte_flow_error_set(error, EINVAL,
358 RTE_FLOW_ERROR_TYPE_ACTION,
359 act, "Not supported action.");
360 return -rte_errno;
361 }
362
363 /* parse attr */
364 /* must be input direction */
365 if (!attr->ingress) {
366 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
367 rte_flow_error_set(error, EINVAL,
368 RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
369 attr, "Only support ingress.");
370 return -rte_errno;
371 }
372
373 /* not supported */
374 if (attr->egress) {
375 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
376 rte_flow_error_set(error, EINVAL,
377 RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
378 attr, "Not support egress.");
379 return -rte_errno;
380 }
381
382 /* not supported */
383 if (attr->transfer) {
384 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
385 rte_flow_error_set(error, EINVAL,
386 RTE_FLOW_ERROR_TYPE_ATTR_TRANSFER,
387 attr, "No support for transfer.");
388 return -rte_errno;
389 }
390
391 if (attr->priority > 0xFFFF) {
392 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
393 rte_flow_error_set(error, EINVAL,
394 RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
395 attr, "Error priority.");
396 return -rte_errno;
397 }
398 filter->priority = (uint16_t)attr->priority;
399
400 return 0;
401 }
402
403 /* a specific function for igb because the flags is specific */
404 static int
405 igb_parse_ntuple_filter(struct rte_eth_dev *dev,
406 const struct rte_flow_attr *attr,
407 const struct rte_flow_item pattern[],
408 const struct rte_flow_action actions[],
409 struct rte_eth_ntuple_filter *filter,
410 struct rte_flow_error *error)
411 {
412 struct e1000_hw *hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
413 int ret;
414
415 MAC_TYPE_FILTER_SUP(hw->mac.type);
416
417 ret = cons_parse_ntuple_filter(attr, pattern, actions, filter, error);
418
419 if (ret)
420 return ret;
421
422 /* Igb doesn't support many priorities. */
423 if (filter->priority > E1000_2TUPLE_MAX_PRI) {
424 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
425 rte_flow_error_set(error, EINVAL,
426 RTE_FLOW_ERROR_TYPE_ITEM,
427 NULL, "Priority not supported by ntuple filter");
428 return -rte_errno;
429 }
430
431 if (hw->mac.type == e1000_82576) {
432 if (filter->queue >= IGB_MAX_RX_QUEUE_NUM_82576) {
433 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
434 rte_flow_error_set(error, EINVAL,
435 RTE_FLOW_ERROR_TYPE_ITEM,
436 NULL, "queue number not "
437 "supported by ntuple filter");
438 return -rte_errno;
439 }
440 filter->flags |= RTE_5TUPLE_FLAGS;
441 } else {
442 if (filter->src_ip_mask || filter->dst_ip_mask ||
443 filter->src_port_mask) {
444 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
445 rte_flow_error_set(error, EINVAL,
446 RTE_FLOW_ERROR_TYPE_ITEM,
447 NULL, "only two tuple are "
448 "supported by this filter");
449 return -rte_errno;
450 }
451 if (filter->queue >= IGB_MAX_RX_QUEUE_NUM) {
452 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
453 rte_flow_error_set(error, EINVAL,
454 RTE_FLOW_ERROR_TYPE_ITEM,
455 NULL, "queue number not "
456 "supported by ntuple filter");
457 return -rte_errno;
458 }
459 filter->flags |= RTE_2TUPLE_FLAGS;
460 }
461
462 return 0;
463 }
464
465 /**
466 * Parse the rule to see if it is a ethertype rule.
467 * And get the ethertype filter info BTW.
468 * pattern:
469 * The first not void item can be ETH.
470 * The next not void item must be END.
471 * action:
472 * The first not void action should be QUEUE.
473 * The next not void action should be END.
474 * pattern example:
475 * ITEM Spec Mask
476 * ETH type 0x0807 0xFFFF
477 * END
478 * other members in mask and spec should set to 0x00.
479 * item->last should be NULL.
480 */
481 static int
482 cons_parse_ethertype_filter(const struct rte_flow_attr *attr,
483 const struct rte_flow_item *pattern,
484 const struct rte_flow_action *actions,
485 struct rte_eth_ethertype_filter *filter,
486 struct rte_flow_error *error)
487 {
488 const struct rte_flow_item *item;
489 const struct rte_flow_action *act;
490 const struct rte_flow_item_eth *eth_spec;
491 const struct rte_flow_item_eth *eth_mask;
492 const struct rte_flow_action_queue *act_q;
493 uint32_t index;
494
495 if (!pattern) {
496 rte_flow_error_set(error, EINVAL,
497 RTE_FLOW_ERROR_TYPE_ITEM_NUM,
498 NULL, "NULL pattern.");
499 return -rte_errno;
500 }
501
502 if (!actions) {
503 rte_flow_error_set(error, EINVAL,
504 RTE_FLOW_ERROR_TYPE_ACTION_NUM,
505 NULL, "NULL action.");
506 return -rte_errno;
507 }
508
509 if (!attr) {
510 rte_flow_error_set(error, EINVAL,
511 RTE_FLOW_ERROR_TYPE_ATTR,
512 NULL, "NULL attribute.");
513 return -rte_errno;
514 }
515
516 /* Parse pattern */
517 index = 0;
518
519 /* The first non-void item should be MAC. */
520 NEXT_ITEM_OF_PATTERN(item, pattern, index);
521 if (item->type != RTE_FLOW_ITEM_TYPE_ETH) {
522 rte_flow_error_set(error, EINVAL,
523 RTE_FLOW_ERROR_TYPE_ITEM,
524 item, "Not supported by ethertype filter");
525 return -rte_errno;
526 }
527
528 /*Not supported last point for range*/
529 if (item->last) {
530 rte_flow_error_set(error, EINVAL,
531 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
532 item, "Not supported last point for range");
533 return -rte_errno;
534 }
535
536 /* Get the MAC info. */
537 if (!item->spec || !item->mask) {
538 rte_flow_error_set(error, EINVAL,
539 RTE_FLOW_ERROR_TYPE_ITEM,
540 item, "Not supported by ethertype filter");
541 return -rte_errno;
542 }
543
544 eth_spec = item->spec;
545 eth_mask = item->mask;
546
547 /* Mask bits of source MAC address must be full of 0.
548 * Mask bits of destination MAC address must be full
549 * of 1 or full of 0.
550 */
551 if (!is_zero_ether_addr(&eth_mask->src) ||
552 (!is_zero_ether_addr(&eth_mask->dst) &&
553 !is_broadcast_ether_addr(&eth_mask->dst))) {
554 rte_flow_error_set(error, EINVAL,
555 RTE_FLOW_ERROR_TYPE_ITEM,
556 item, "Invalid ether address mask");
557 return -rte_errno;
558 }
559
560 if ((eth_mask->type & UINT16_MAX) != UINT16_MAX) {
561 rte_flow_error_set(error, EINVAL,
562 RTE_FLOW_ERROR_TYPE_ITEM,
563 item, "Invalid ethertype mask");
564 return -rte_errno;
565 }
566
567 /* If mask bits of destination MAC address
568 * are full of 1, set RTE_ETHTYPE_FLAGS_MAC.
569 */
570 if (is_broadcast_ether_addr(&eth_mask->dst)) {
571 filter->mac_addr = eth_spec->dst;
572 filter->flags |= RTE_ETHTYPE_FLAGS_MAC;
573 } else {
574 filter->flags &= ~RTE_ETHTYPE_FLAGS_MAC;
575 }
576 filter->ether_type = rte_be_to_cpu_16(eth_spec->type);
577
578 /* Check if the next non-void item is END. */
579 index++;
580 NEXT_ITEM_OF_PATTERN(item, pattern, index);
581 if (item->type != RTE_FLOW_ITEM_TYPE_END) {
582 rte_flow_error_set(error, EINVAL,
583 RTE_FLOW_ERROR_TYPE_ITEM,
584 item, "Not supported by ethertype filter.");
585 return -rte_errno;
586 }
587
588 /* Parse action */
589
590 index = 0;
591 /* Check if the first non-void action is QUEUE or DROP. */
592 NEXT_ITEM_OF_ACTION(act, actions, index);
593 if (act->type != RTE_FLOW_ACTION_TYPE_QUEUE &&
594 act->type != RTE_FLOW_ACTION_TYPE_DROP) {
595 rte_flow_error_set(error, EINVAL,
596 RTE_FLOW_ERROR_TYPE_ACTION,
597 act, "Not supported action.");
598 return -rte_errno;
599 }
600
601 if (act->type == RTE_FLOW_ACTION_TYPE_QUEUE) {
602 act_q = (const struct rte_flow_action_queue *)act->conf;
603 filter->queue = act_q->index;
604 } else {
605 filter->flags |= RTE_ETHTYPE_FLAGS_DROP;
606 }
607
608 /* Check if the next non-void item is END */
609 index++;
610 NEXT_ITEM_OF_ACTION(act, actions, index);
611 if (act->type != RTE_FLOW_ACTION_TYPE_END) {
612 rte_flow_error_set(error, EINVAL,
613 RTE_FLOW_ERROR_TYPE_ACTION,
614 act, "Not supported action.");
615 return -rte_errno;
616 }
617
618 /* Parse attr */
619 /* Must be input direction */
620 if (!attr->ingress) {
621 rte_flow_error_set(error, EINVAL,
622 RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
623 attr, "Only support ingress.");
624 return -rte_errno;
625 }
626
627 /* Not supported */
628 if (attr->egress) {
629 rte_flow_error_set(error, EINVAL,
630 RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
631 attr, "Not support egress.");
632 return -rte_errno;
633 }
634
635 /* Not supported */
636 if (attr->transfer) {
637 rte_flow_error_set(error, EINVAL,
638 RTE_FLOW_ERROR_TYPE_ATTR_TRANSFER,
639 attr, "No support for transfer.");
640 return -rte_errno;
641 }
642
643 /* Not supported */
644 if (attr->priority) {
645 rte_flow_error_set(error, EINVAL,
646 RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
647 attr, "Not support priority.");
648 return -rte_errno;
649 }
650
651 /* Not supported */
652 if (attr->group) {
653 rte_flow_error_set(error, EINVAL,
654 RTE_FLOW_ERROR_TYPE_ATTR_GROUP,
655 attr, "Not support group.");
656 return -rte_errno;
657 }
658
659 return 0;
660 }
661
662 static int
663 igb_parse_ethertype_filter(struct rte_eth_dev *dev,
664 const struct rte_flow_attr *attr,
665 const struct rte_flow_item pattern[],
666 const struct rte_flow_action actions[],
667 struct rte_eth_ethertype_filter *filter,
668 struct rte_flow_error *error)
669 {
670 struct e1000_hw *hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
671 int ret;
672
673 MAC_TYPE_FILTER_SUP(hw->mac.type);
674
675 ret = cons_parse_ethertype_filter(attr, pattern,
676 actions, filter, error);
677
678 if (ret)
679 return ret;
680
681 if (hw->mac.type == e1000_82576) {
682 if (filter->queue >= IGB_MAX_RX_QUEUE_NUM_82576) {
683 memset(filter, 0, sizeof(
684 struct rte_eth_ethertype_filter));
685 rte_flow_error_set(error, EINVAL,
686 RTE_FLOW_ERROR_TYPE_ITEM,
687 NULL, "queue number not supported "
688 "by ethertype filter");
689 return -rte_errno;
690 }
691 } else {
692 if (filter->queue >= IGB_MAX_RX_QUEUE_NUM) {
693 memset(filter, 0, sizeof(
694 struct rte_eth_ethertype_filter));
695 rte_flow_error_set(error, EINVAL,
696 RTE_FLOW_ERROR_TYPE_ITEM,
697 NULL, "queue number not supported "
698 "by ethertype filter");
699 return -rte_errno;
700 }
701 }
702
703 if (filter->ether_type == ETHER_TYPE_IPv4 ||
704 filter->ether_type == ETHER_TYPE_IPv6) {
705 memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
706 rte_flow_error_set(error, EINVAL,
707 RTE_FLOW_ERROR_TYPE_ITEM,
708 NULL, "IPv4/IPv6 not supported by ethertype filter");
709 return -rte_errno;
710 }
711
712 if (filter->flags & RTE_ETHTYPE_FLAGS_MAC) {
713 memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
714 rte_flow_error_set(error, EINVAL,
715 RTE_FLOW_ERROR_TYPE_ITEM,
716 NULL, "mac compare is unsupported");
717 return -rte_errno;
718 }
719
720 if (filter->flags & RTE_ETHTYPE_FLAGS_DROP) {
721 memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
722 rte_flow_error_set(error, EINVAL,
723 RTE_FLOW_ERROR_TYPE_ITEM,
724 NULL, "drop option is unsupported");
725 return -rte_errno;
726 }
727
728 return 0;
729 }
730
731 /**
732 * Parse the rule to see if it is a TCP SYN rule.
733 * And get the TCP SYN filter info BTW.
734 * pattern:
735 * The first not void item must be ETH.
736 * The second not void item must be IPV4 or IPV6.
737 * The third not void item must be TCP.
738 * The next not void item must be END.
739 * action:
740 * The first not void action should be QUEUE.
741 * The next not void action should be END.
742 * pattern example:
743 * ITEM Spec Mask
744 * ETH NULL NULL
745 * IPV4/IPV6 NULL NULL
746 * TCP tcp_flags 0x02 0xFF
747 * END
748 * other members in mask and spec should set to 0x00.
749 * item->last should be NULL.
750 */
751 static int
752 cons_parse_syn_filter(const struct rte_flow_attr *attr,
753 const struct rte_flow_item pattern[],
754 const struct rte_flow_action actions[],
755 struct rte_eth_syn_filter *filter,
756 struct rte_flow_error *error)
757 {
758 const struct rte_flow_item *item;
759 const struct rte_flow_action *act;
760 const struct rte_flow_item_tcp *tcp_spec;
761 const struct rte_flow_item_tcp *tcp_mask;
762 const struct rte_flow_action_queue *act_q;
763 uint32_t index;
764
765 if (!pattern) {
766 rte_flow_error_set(error, EINVAL,
767 RTE_FLOW_ERROR_TYPE_ITEM_NUM,
768 NULL, "NULL pattern.");
769 return -rte_errno;
770 }
771
772 if (!actions) {
773 rte_flow_error_set(error, EINVAL,
774 RTE_FLOW_ERROR_TYPE_ACTION_NUM,
775 NULL, "NULL action.");
776 return -rte_errno;
777 }
778
779 if (!attr) {
780 rte_flow_error_set(error, EINVAL,
781 RTE_FLOW_ERROR_TYPE_ATTR,
782 NULL, "NULL attribute.");
783 return -rte_errno;
784 }
785
786 /* parse pattern */
787 index = 0;
788
789 /* the first not void item should be MAC or IPv4 or IPv6 or TCP */
790 NEXT_ITEM_OF_PATTERN(item, pattern, index);
791 if (item->type != RTE_FLOW_ITEM_TYPE_ETH &&
792 item->type != RTE_FLOW_ITEM_TYPE_IPV4 &&
793 item->type != RTE_FLOW_ITEM_TYPE_IPV6 &&
794 item->type != RTE_FLOW_ITEM_TYPE_TCP) {
795 rte_flow_error_set(error, EINVAL,
796 RTE_FLOW_ERROR_TYPE_ITEM,
797 item, "Not supported by syn filter");
798 return -rte_errno;
799 }
800 /*Not supported last point for range*/
801 if (item->last) {
802 rte_flow_error_set(error, EINVAL,
803 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
804 item, "Not supported last point for range");
805 return -rte_errno;
806 }
807
808 /* Skip Ethernet */
809 if (item->type == RTE_FLOW_ITEM_TYPE_ETH) {
810 /* if the item is MAC, the content should be NULL */
811 if (item->spec || item->mask) {
812 rte_flow_error_set(error, EINVAL,
813 RTE_FLOW_ERROR_TYPE_ITEM,
814 item, "Invalid SYN address mask");
815 return -rte_errno;
816 }
817
818 /* check if the next not void item is IPv4 or IPv6 */
819 index++;
820 NEXT_ITEM_OF_PATTERN(item, pattern, index);
821 if (item->type != RTE_FLOW_ITEM_TYPE_IPV4 &&
822 item->type != RTE_FLOW_ITEM_TYPE_IPV6) {
823 rte_flow_error_set(error, EINVAL,
824 RTE_FLOW_ERROR_TYPE_ITEM,
825 item, "Not supported by syn filter");
826 return -rte_errno;
827 }
828 }
829
830 /* Skip IP */
831 if (item->type == RTE_FLOW_ITEM_TYPE_IPV4 ||
832 item->type == RTE_FLOW_ITEM_TYPE_IPV6) {
833 /* if the item is IP, the content should be NULL */
834 if (item->spec || item->mask) {
835 rte_flow_error_set(error, EINVAL,
836 RTE_FLOW_ERROR_TYPE_ITEM,
837 item, "Invalid SYN mask");
838 return -rte_errno;
839 }
840
841 /* check if the next not void item is TCP */
842 index++;
843 NEXT_ITEM_OF_PATTERN(item, pattern, index);
844 if (item->type != RTE_FLOW_ITEM_TYPE_TCP) {
845 rte_flow_error_set(error, EINVAL,
846 RTE_FLOW_ERROR_TYPE_ITEM,
847 item, "Not supported by syn filter");
848 return -rte_errno;
849 }
850 }
851
852 /* Get the TCP info. Only support SYN. */
853 if (!item->spec || !item->mask) {
854 rte_flow_error_set(error, EINVAL,
855 RTE_FLOW_ERROR_TYPE_ITEM,
856 item, "Invalid SYN mask");
857 return -rte_errno;
858 }
859 /*Not supported last point for range*/
860 if (item->last) {
861 rte_flow_error_set(error, EINVAL,
862 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
863 item, "Not supported last point for range");
864 return -rte_errno;
865 }
866
867 tcp_spec = item->spec;
868 tcp_mask = item->mask;
869 if (!(tcp_spec->hdr.tcp_flags & TCP_SYN_FLAG) ||
870 tcp_mask->hdr.src_port ||
871 tcp_mask->hdr.dst_port ||
872 tcp_mask->hdr.sent_seq ||
873 tcp_mask->hdr.recv_ack ||
874 tcp_mask->hdr.data_off ||
875 tcp_mask->hdr.tcp_flags != TCP_SYN_FLAG ||
876 tcp_mask->hdr.rx_win ||
877 tcp_mask->hdr.cksum ||
878 tcp_mask->hdr.tcp_urp) {
879 memset(filter, 0, sizeof(struct rte_eth_syn_filter));
880 rte_flow_error_set(error, EINVAL,
881 RTE_FLOW_ERROR_TYPE_ITEM,
882 item, "Not supported by syn filter");
883 return -rte_errno;
884 }
885
886 /* check if the next not void item is END */
887 index++;
888 NEXT_ITEM_OF_PATTERN(item, pattern, index);
889 if (item->type != RTE_FLOW_ITEM_TYPE_END) {
890 memset(filter, 0, sizeof(struct rte_eth_syn_filter));
891 rte_flow_error_set(error, EINVAL,
892 RTE_FLOW_ERROR_TYPE_ITEM,
893 item, "Not supported by syn filter");
894 return -rte_errno;
895 }
896
897 /* parse action */
898 index = 0;
899
900 /* check if the first not void action is QUEUE. */
901 NEXT_ITEM_OF_ACTION(act, actions, index);
902 if (act->type != RTE_FLOW_ACTION_TYPE_QUEUE) {
903 memset(filter, 0, sizeof(struct rte_eth_syn_filter));
904 rte_flow_error_set(error, EINVAL,
905 RTE_FLOW_ERROR_TYPE_ACTION,
906 act, "Not supported action.");
907 return -rte_errno;
908 }
909
910 act_q = (const struct rte_flow_action_queue *)act->conf;
911 filter->queue = act_q->index;
912
913 /* check if the next not void item is END */
914 index++;
915 NEXT_ITEM_OF_ACTION(act, actions, index);
916 if (act->type != RTE_FLOW_ACTION_TYPE_END) {
917 memset(filter, 0, sizeof(struct rte_eth_syn_filter));
918 rte_flow_error_set(error, EINVAL,
919 RTE_FLOW_ERROR_TYPE_ACTION,
920 act, "Not supported action.");
921 return -rte_errno;
922 }
923
924 /* parse attr */
925 /* must be input direction */
926 if (!attr->ingress) {
927 memset(filter, 0, sizeof(struct rte_eth_syn_filter));
928 rte_flow_error_set(error, EINVAL,
929 RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
930 attr, "Only support ingress.");
931 return -rte_errno;
932 }
933
934 /* not supported */
935 if (attr->egress) {
936 memset(filter, 0, sizeof(struct rte_eth_syn_filter));
937 rte_flow_error_set(error, EINVAL,
938 RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
939 attr, "Not support egress.");
940 return -rte_errno;
941 }
942
943 /* not supported */
944 if (attr->transfer) {
945 memset(filter, 0, sizeof(struct rte_eth_syn_filter));
946 rte_flow_error_set(error, EINVAL,
947 RTE_FLOW_ERROR_TYPE_ATTR_TRANSFER,
948 attr, "No support for transfer.");
949 return -rte_errno;
950 }
951
952 /* Support 2 priorities, the lowest or highest. */
953 if (!attr->priority) {
954 filter->hig_pri = 0;
955 } else if (attr->priority == (uint32_t)~0U) {
956 filter->hig_pri = 1;
957 } else {
958 memset(filter, 0, sizeof(struct rte_eth_syn_filter));
959 rte_flow_error_set(error, EINVAL,
960 RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
961 attr, "Not support priority.");
962 return -rte_errno;
963 }
964
965 return 0;
966 }
967
968 static int
969 igb_parse_syn_filter(struct rte_eth_dev *dev,
970 const struct rte_flow_attr *attr,
971 const struct rte_flow_item pattern[],
972 const struct rte_flow_action actions[],
973 struct rte_eth_syn_filter *filter,
974 struct rte_flow_error *error)
975 {
976 struct e1000_hw *hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
977 int ret;
978
979 MAC_TYPE_FILTER_SUP(hw->mac.type);
980
981 ret = cons_parse_syn_filter(attr, pattern,
982 actions, filter, error);
983
984 if (hw->mac.type == e1000_82576) {
985 if (filter->queue >= IGB_MAX_RX_QUEUE_NUM_82576) {
986 memset(filter, 0, sizeof(struct rte_eth_syn_filter));
987 rte_flow_error_set(error, EINVAL,
988 RTE_FLOW_ERROR_TYPE_ITEM,
989 NULL, "queue number not "
990 "supported by syn filter");
991 return -rte_errno;
992 }
993 } else {
994 if (filter->queue >= IGB_MAX_RX_QUEUE_NUM) {
995 memset(filter, 0, sizeof(struct rte_eth_syn_filter));
996 rte_flow_error_set(error, EINVAL,
997 RTE_FLOW_ERROR_TYPE_ITEM,
998 NULL, "queue number not "
999 "supported by syn filter");
1000 return -rte_errno;
1001 }
1002 }
1003
1004 if (ret)
1005 return ret;
1006
1007 return 0;
1008 }
1009
1010 /**
1011 * Parse the rule to see if it is a flex byte rule.
1012 * And get the flex byte filter info BTW.
1013 * pattern:
1014 * The first not void item must be RAW.
1015 * The second not void item can be RAW or END.
1016 * The third not void item can be RAW or END.
1017 * The last not void item must be END.
1018 * action:
1019 * The first not void action should be QUEUE.
1020 * The next not void action should be END.
1021 * pattern example:
1022 * ITEM Spec Mask
1023 * RAW relative 0 0x1
1024 * offset 0 0xFFFFFFFF
1025 * pattern {0x08, 0x06} {0xFF, 0xFF}
1026 * RAW relative 1 0x1
1027 * offset 100 0xFFFFFFFF
1028 * pattern {0x11, 0x22, 0x33} {0xFF, 0xFF, 0xFF}
1029 * END
1030 * other members in mask and spec should set to 0x00.
1031 * item->last should be NULL.
1032 */
1033 static int
1034 cons_parse_flex_filter(const struct rte_flow_attr *attr,
1035 const struct rte_flow_item pattern[],
1036 const struct rte_flow_action actions[],
1037 struct rte_eth_flex_filter *filter,
1038 struct rte_flow_error *error)
1039 {
1040 const struct rte_flow_item *item;
1041 const struct rte_flow_action *act;
1042 const struct rte_flow_item_raw *raw_spec;
1043 const struct rte_flow_item_raw *raw_mask;
1044 const struct rte_flow_action_queue *act_q;
1045 uint32_t index, i, offset, total_offset;
1046 uint32_t max_offset = 0;
1047 int32_t shift, j, raw_index = 0;
1048 int32_t relative[IGB_FLEX_RAW_NUM] = {0};
1049 int32_t raw_offset[IGB_FLEX_RAW_NUM] = {0};
1050
1051 if (!pattern) {
1052 rte_flow_error_set(error, EINVAL,
1053 RTE_FLOW_ERROR_TYPE_ITEM_NUM,
1054 NULL, "NULL pattern.");
1055 return -rte_errno;
1056 }
1057
1058 if (!actions) {
1059 rte_flow_error_set(error, EINVAL,
1060 RTE_FLOW_ERROR_TYPE_ACTION_NUM,
1061 NULL, "NULL action.");
1062 return -rte_errno;
1063 }
1064
1065 if (!attr) {
1066 rte_flow_error_set(error, EINVAL,
1067 RTE_FLOW_ERROR_TYPE_ATTR,
1068 NULL, "NULL attribute.");
1069 return -rte_errno;
1070 }
1071
1072 /* parse pattern */
1073 index = 0;
1074
1075 item_loop:
1076
1077 /* the first not void item should be RAW */
1078 NEXT_ITEM_OF_PATTERN(item, pattern, index);
1079 if (item->type != RTE_FLOW_ITEM_TYPE_RAW) {
1080 rte_flow_error_set(error, EINVAL,
1081 RTE_FLOW_ERROR_TYPE_ITEM,
1082 item, "Not supported by flex filter");
1083 return -rte_errno;
1084 }
1085 /*Not supported last point for range*/
1086 if (item->last) {
1087 rte_flow_error_set(error, EINVAL,
1088 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
1089 item, "Not supported last point for range");
1090 return -rte_errno;
1091 }
1092
1093 raw_spec = item->spec;
1094 raw_mask = item->mask;
1095
1096 if (!raw_mask->length ||
1097 !raw_mask->relative) {
1098 memset(filter, 0, sizeof(struct rte_eth_flex_filter));
1099 rte_flow_error_set(error, EINVAL,
1100 RTE_FLOW_ERROR_TYPE_ITEM,
1101 item, "Not supported by flex filter");
1102 return -rte_errno;
1103 }
1104
1105 if (raw_mask->offset)
1106 offset = raw_spec->offset;
1107 else
1108 offset = 0;
1109
1110 for (j = 0; j < raw_spec->length; j++) {
1111 if (raw_mask->pattern[j] != 0xFF) {
1112 memset(filter, 0, sizeof(struct rte_eth_flex_filter));
1113 rte_flow_error_set(error, EINVAL,
1114 RTE_FLOW_ERROR_TYPE_ITEM,
1115 item, "Not supported by flex filter");
1116 return -rte_errno;
1117 }
1118 }
1119
1120 total_offset = 0;
1121
1122 if (raw_spec->relative) {
1123 for (j = raw_index; j > 0; j--) {
1124 total_offset += raw_offset[j - 1];
1125 if (!relative[j - 1])
1126 break;
1127 }
1128 if (total_offset + raw_spec->length + offset > max_offset)
1129 max_offset = total_offset + raw_spec->length + offset;
1130 } else {
1131 if (raw_spec->length + offset > max_offset)
1132 max_offset = raw_spec->length + offset;
1133 }
1134
1135 if ((raw_spec->length + offset + total_offset) >
1136 RTE_FLEX_FILTER_MAXLEN) {
1137 memset(filter, 0, sizeof(struct rte_eth_flex_filter));
1138 rte_flow_error_set(error, EINVAL,
1139 RTE_FLOW_ERROR_TYPE_ITEM,
1140 item, "Not supported by flex filter");
1141 return -rte_errno;
1142 }
1143
1144 if (raw_spec->relative == 0) {
1145 for (j = 0; j < raw_spec->length; j++)
1146 filter->bytes[offset + j] =
1147 raw_spec->pattern[j];
1148 j = offset / CHAR_BIT;
1149 shift = offset % CHAR_BIT;
1150 } else {
1151 for (j = 0; j < raw_spec->length; j++)
1152 filter->bytes[total_offset + offset + j] =
1153 raw_spec->pattern[j];
1154 j = (total_offset + offset) / CHAR_BIT;
1155 shift = (total_offset + offset) % CHAR_BIT;
1156 }
1157
1158 i = 0;
1159
1160 for ( ; shift < CHAR_BIT; shift++) {
1161 filter->mask[j] |= (0x80 >> shift);
1162 i++;
1163 if (i == raw_spec->length)
1164 break;
1165 if (shift == (CHAR_BIT - 1)) {
1166 j++;
1167 shift = -1;
1168 }
1169 }
1170
1171 relative[raw_index] = raw_spec->relative;
1172 raw_offset[raw_index] = offset + raw_spec->length;
1173 raw_index++;
1174
1175 /* check if the next not void item is RAW */
1176 index++;
1177 NEXT_ITEM_OF_PATTERN(item, pattern, index);
1178 if (item->type != RTE_FLOW_ITEM_TYPE_RAW &&
1179 item->type != RTE_FLOW_ITEM_TYPE_END) {
1180 rte_flow_error_set(error, EINVAL,
1181 RTE_FLOW_ERROR_TYPE_ITEM,
1182 item, "Not supported by flex filter");
1183 return -rte_errno;
1184 }
1185
1186 /* go back to parser */
1187 if (item->type == RTE_FLOW_ITEM_TYPE_RAW) {
1188 /* if the item is RAW, the content should be parse */
1189 goto item_loop;
1190 }
1191
1192 filter->len = RTE_ALIGN(max_offset, 8);
1193
1194 /* parse action */
1195 index = 0;
1196
1197 /* check if the first not void action is QUEUE. */
1198 NEXT_ITEM_OF_ACTION(act, actions, index);
1199 if (act->type != RTE_FLOW_ACTION_TYPE_QUEUE) {
1200 memset(filter, 0, sizeof(struct rte_eth_flex_filter));
1201 rte_flow_error_set(error, EINVAL,
1202 RTE_FLOW_ERROR_TYPE_ACTION,
1203 act, "Not supported action.");
1204 return -rte_errno;
1205 }
1206
1207 act_q = (const struct rte_flow_action_queue *)act->conf;
1208 filter->queue = act_q->index;
1209
1210 /* check if the next not void item is END */
1211 index++;
1212 NEXT_ITEM_OF_ACTION(act, actions, index);
1213 if (act->type != RTE_FLOW_ACTION_TYPE_END) {
1214 memset(filter, 0, sizeof(struct rte_eth_flex_filter));
1215 rte_flow_error_set(error, EINVAL,
1216 RTE_FLOW_ERROR_TYPE_ACTION,
1217 act, "Not supported action.");
1218 return -rte_errno;
1219 }
1220
1221 /* parse attr */
1222 /* must be input direction */
1223 if (!attr->ingress) {
1224 memset(filter, 0, sizeof(struct rte_eth_flex_filter));
1225 rte_flow_error_set(error, EINVAL,
1226 RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
1227 attr, "Only support ingress.");
1228 return -rte_errno;
1229 }
1230
1231 /* not supported */
1232 if (attr->egress) {
1233 memset(filter, 0, sizeof(struct rte_eth_flex_filter));
1234 rte_flow_error_set(error, EINVAL,
1235 RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
1236 attr, "Not support egress.");
1237 return -rte_errno;
1238 }
1239
1240 /* not supported */
1241 if (attr->transfer) {
1242 memset(filter, 0, sizeof(struct rte_eth_flex_filter));
1243 rte_flow_error_set(error, EINVAL,
1244 RTE_FLOW_ERROR_TYPE_ATTR_TRANSFER,
1245 attr, "No support for transfer.");
1246 return -rte_errno;
1247 }
1248
1249 if (attr->priority > 0xFFFF) {
1250 memset(filter, 0, sizeof(struct rte_eth_flex_filter));
1251 rte_flow_error_set(error, EINVAL,
1252 RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
1253 attr, "Error priority.");
1254 return -rte_errno;
1255 }
1256
1257 filter->priority = (uint16_t)attr->priority;
1258
1259 return 0;
1260 }
1261
1262 static int
1263 igb_parse_flex_filter(struct rte_eth_dev *dev,
1264 const struct rte_flow_attr *attr,
1265 const struct rte_flow_item pattern[],
1266 const struct rte_flow_action actions[],
1267 struct rte_eth_flex_filter *filter,
1268 struct rte_flow_error *error)
1269 {
1270 struct e1000_hw *hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1271 int ret;
1272
1273 MAC_TYPE_FILTER_SUP_EXT(hw->mac.type);
1274
1275 ret = cons_parse_flex_filter(attr, pattern,
1276 actions, filter, error);
1277
1278 if (filter->queue >= IGB_MAX_RX_QUEUE_NUM) {
1279 memset(filter, 0, sizeof(struct rte_eth_flex_filter));
1280 rte_flow_error_set(error, EINVAL,
1281 RTE_FLOW_ERROR_TYPE_ITEM,
1282 NULL, "queue number not supported by flex filter");
1283 return -rte_errno;
1284 }
1285
1286 if (filter->len == 0 || filter->len > E1000_MAX_FLEX_FILTER_LEN ||
1287 filter->len % sizeof(uint64_t) != 0) {
1288 PMD_DRV_LOG(ERR, "filter's length is out of range");
1289 return -EINVAL;
1290 }
1291
1292 if (filter->priority > E1000_MAX_FLEX_FILTER_PRI) {
1293 PMD_DRV_LOG(ERR, "filter's priority is out of range");
1294 return -EINVAL;
1295 }
1296
1297 if (ret)
1298 return ret;
1299
1300 return 0;
1301 }
1302
1303 static int
1304 igb_parse_rss_filter(struct rte_eth_dev *dev,
1305 const struct rte_flow_attr *attr,
1306 const struct rte_flow_action actions[],
1307 struct igb_rte_flow_rss_conf *rss_conf,
1308 struct rte_flow_error *error)
1309 {
1310 const struct rte_flow_action *act;
1311 const struct rte_flow_action_rss *rss;
1312 uint16_t n, index;
1313
1314 /**
1315 * rss only supports forwarding,
1316 * check if the first not void action is RSS.
1317 */
1318 index = 0;
1319 NEXT_ITEM_OF_ACTION(act, actions, index);
1320 if (act->type != RTE_FLOW_ACTION_TYPE_RSS) {
1321 memset(rss_conf, 0, sizeof(struct igb_rte_flow_rss_conf));
1322 rte_flow_error_set(error, EINVAL,
1323 RTE_FLOW_ERROR_TYPE_ACTION,
1324 act, "Not supported action.");
1325 return -rte_errno;
1326 }
1327
1328 rss = (const struct rte_flow_action_rss *)act->conf;
1329
1330 if (!rss || !rss->queue_num) {
1331 rte_flow_error_set(error, EINVAL,
1332 RTE_FLOW_ERROR_TYPE_ACTION,
1333 act,
1334 "no valid queues");
1335 return -rte_errno;
1336 }
1337
1338 for (n = 0; n < rss->queue_num; n++) {
1339 if (rss->queue[n] >= dev->data->nb_rx_queues) {
1340 rte_flow_error_set(error, EINVAL,
1341 RTE_FLOW_ERROR_TYPE_ACTION,
1342 act,
1343 "queue id > max number of queues");
1344 return -rte_errno;
1345 }
1346 }
1347
1348 if (rss->func != RTE_ETH_HASH_FUNCTION_DEFAULT)
1349 return rte_flow_error_set
1350 (error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ACTION, act,
1351 "non-default RSS hash functions are not supported");
1352 if (rss->level)
1353 return rte_flow_error_set
1354 (error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ACTION, act,
1355 "a nonzero RSS encapsulation level is not supported");
1356 if (rss->key_len && rss->key_len != RTE_DIM(rss_conf->key))
1357 return rte_flow_error_set
1358 (error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ACTION, act,
1359 "RSS hash key must be exactly 40 bytes");
1360 if (rss->queue_num > RTE_DIM(rss_conf->queue))
1361 return rte_flow_error_set
1362 (error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ACTION, act,
1363 "too many queues for RSS context");
1364 if (igb_rss_conf_init(rss_conf, rss))
1365 return rte_flow_error_set
1366 (error, EINVAL, RTE_FLOW_ERROR_TYPE_ACTION, act,
1367 "RSS context initialization failure");
1368
1369 /* check if the next not void item is END */
1370 index++;
1371 NEXT_ITEM_OF_ACTION(act, actions, index);
1372 if (act->type != RTE_FLOW_ACTION_TYPE_END) {
1373 memset(rss_conf, 0, sizeof(struct rte_eth_rss_conf));
1374 rte_flow_error_set(error, EINVAL,
1375 RTE_FLOW_ERROR_TYPE_ACTION,
1376 act, "Not supported action.");
1377 return -rte_errno;
1378 }
1379
1380 /* parse attr */
1381 /* must be input direction */
1382 if (!attr->ingress) {
1383 memset(rss_conf, 0, sizeof(struct igb_rte_flow_rss_conf));
1384 rte_flow_error_set(error, EINVAL,
1385 RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
1386 attr, "Only support ingress.");
1387 return -rte_errno;
1388 }
1389
1390 /* not supported */
1391 if (attr->egress) {
1392 memset(rss_conf, 0, sizeof(struct igb_rte_flow_rss_conf));
1393 rte_flow_error_set(error, EINVAL,
1394 RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
1395 attr, "Not support egress.");
1396 return -rte_errno;
1397 }
1398
1399 /* not supported */
1400 if (attr->transfer) {
1401 memset(rss_conf, 0, sizeof(struct igb_rte_flow_rss_conf));
1402 rte_flow_error_set(error, EINVAL,
1403 RTE_FLOW_ERROR_TYPE_ATTR_TRANSFER,
1404 attr, "No support for transfer.");
1405 return -rte_errno;
1406 }
1407
1408 if (attr->priority > 0xFFFF) {
1409 memset(rss_conf, 0, sizeof(struct igb_rte_flow_rss_conf));
1410 rte_flow_error_set(error, EINVAL,
1411 RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
1412 attr, "Error priority.");
1413 return -rte_errno;
1414 }
1415
1416 return 0;
1417 }
1418
1419 /**
1420 * Create a flow rule.
1421 * Theorically one rule can match more than one filters.
1422 * We will let it use the filter which it hitt first.
1423 * So, the sequence matters.
1424 */
1425 static struct rte_flow *
1426 igb_flow_create(struct rte_eth_dev *dev,
1427 const struct rte_flow_attr *attr,
1428 const struct rte_flow_item pattern[],
1429 const struct rte_flow_action actions[],
1430 struct rte_flow_error *error)
1431 {
1432 int ret;
1433 struct rte_eth_ntuple_filter ntuple_filter;
1434 struct rte_eth_ethertype_filter ethertype_filter;
1435 struct rte_eth_syn_filter syn_filter;
1436 struct rte_eth_flex_filter flex_filter;
1437 struct igb_rte_flow_rss_conf rss_conf;
1438 struct rte_flow *flow = NULL;
1439 struct igb_ntuple_filter_ele *ntuple_filter_ptr;
1440 struct igb_ethertype_filter_ele *ethertype_filter_ptr;
1441 struct igb_eth_syn_filter_ele *syn_filter_ptr;
1442 struct igb_flex_filter_ele *flex_filter_ptr;
1443 struct igb_rss_conf_ele *rss_filter_ptr;
1444 struct igb_flow_mem *igb_flow_mem_ptr;
1445
1446 flow = rte_zmalloc("igb_rte_flow", sizeof(struct rte_flow), 0);
1447 if (!flow) {
1448 PMD_DRV_LOG(ERR, "failed to allocate memory");
1449 return (struct rte_flow *)flow;
1450 }
1451 igb_flow_mem_ptr = rte_zmalloc("igb_flow_mem",
1452 sizeof(struct igb_flow_mem), 0);
1453 if (!igb_flow_mem_ptr) {
1454 PMD_DRV_LOG(ERR, "failed to allocate memory");
1455 rte_free(flow);
1456 return NULL;
1457 }
1458 igb_flow_mem_ptr->flow = flow;
1459 igb_flow_mem_ptr->dev = dev;
1460 TAILQ_INSERT_TAIL(&igb_flow_list,
1461 igb_flow_mem_ptr, entries);
1462
1463 memset(&ntuple_filter, 0, sizeof(struct rte_eth_ntuple_filter));
1464 ret = igb_parse_ntuple_filter(dev, attr, pattern,
1465 actions, &ntuple_filter, error);
1466 if (!ret) {
1467 ret = igb_add_del_ntuple_filter(dev, &ntuple_filter, TRUE);
1468 if (!ret) {
1469 ntuple_filter_ptr = rte_zmalloc("igb_ntuple_filter",
1470 sizeof(struct igb_ntuple_filter_ele), 0);
1471 if (!ntuple_filter_ptr) {
1472 PMD_DRV_LOG(ERR, "failed to allocate memory");
1473 goto out;
1474 }
1475
1476 rte_memcpy(&ntuple_filter_ptr->filter_info,
1477 &ntuple_filter,
1478 sizeof(struct rte_eth_ntuple_filter));
1479 TAILQ_INSERT_TAIL(&igb_filter_ntuple_list,
1480 ntuple_filter_ptr, entries);
1481 flow->rule = ntuple_filter_ptr;
1482 flow->filter_type = RTE_ETH_FILTER_NTUPLE;
1483 return flow;
1484 }
1485 goto out;
1486 }
1487
1488 memset(&ethertype_filter, 0, sizeof(struct rte_eth_ethertype_filter));
1489 ret = igb_parse_ethertype_filter(dev, attr, pattern,
1490 actions, &ethertype_filter, error);
1491 if (!ret) {
1492 ret = igb_add_del_ethertype_filter(dev,
1493 &ethertype_filter, TRUE);
1494 if (!ret) {
1495 ethertype_filter_ptr = rte_zmalloc(
1496 "igb_ethertype_filter",
1497 sizeof(struct igb_ethertype_filter_ele), 0);
1498 if (!ethertype_filter_ptr) {
1499 PMD_DRV_LOG(ERR, "failed to allocate memory");
1500 goto out;
1501 }
1502
1503 rte_memcpy(&ethertype_filter_ptr->filter_info,
1504 &ethertype_filter,
1505 sizeof(struct rte_eth_ethertype_filter));
1506 TAILQ_INSERT_TAIL(&igb_filter_ethertype_list,
1507 ethertype_filter_ptr, entries);
1508 flow->rule = ethertype_filter_ptr;
1509 flow->filter_type = RTE_ETH_FILTER_ETHERTYPE;
1510 return flow;
1511 }
1512 goto out;
1513 }
1514
1515 memset(&syn_filter, 0, sizeof(struct rte_eth_syn_filter));
1516 ret = igb_parse_syn_filter(dev, attr, pattern,
1517 actions, &syn_filter, error);
1518 if (!ret) {
1519 ret = eth_igb_syn_filter_set(dev, &syn_filter, TRUE);
1520 if (!ret) {
1521 syn_filter_ptr = rte_zmalloc("igb_syn_filter",
1522 sizeof(struct igb_eth_syn_filter_ele), 0);
1523 if (!syn_filter_ptr) {
1524 PMD_DRV_LOG(ERR, "failed to allocate memory");
1525 goto out;
1526 }
1527
1528 rte_memcpy(&syn_filter_ptr->filter_info,
1529 &syn_filter,
1530 sizeof(struct rte_eth_syn_filter));
1531 TAILQ_INSERT_TAIL(&igb_filter_syn_list,
1532 syn_filter_ptr,
1533 entries);
1534 flow->rule = syn_filter_ptr;
1535 flow->filter_type = RTE_ETH_FILTER_SYN;
1536 return flow;
1537 }
1538 goto out;
1539 }
1540
1541 memset(&flex_filter, 0, sizeof(struct rte_eth_flex_filter));
1542 ret = igb_parse_flex_filter(dev, attr, pattern,
1543 actions, &flex_filter, error);
1544 if (!ret) {
1545 ret = eth_igb_add_del_flex_filter(dev, &flex_filter, TRUE);
1546 if (!ret) {
1547 flex_filter_ptr = rte_zmalloc("igb_flex_filter",
1548 sizeof(struct igb_flex_filter_ele), 0);
1549 if (!flex_filter_ptr) {
1550 PMD_DRV_LOG(ERR, "failed to allocate memory");
1551 goto out;
1552 }
1553
1554 rte_memcpy(&flex_filter_ptr->filter_info,
1555 &flex_filter,
1556 sizeof(struct rte_eth_flex_filter));
1557 TAILQ_INSERT_TAIL(&igb_filter_flex_list,
1558 flex_filter_ptr, entries);
1559 flow->rule = flex_filter_ptr;
1560 flow->filter_type = RTE_ETH_FILTER_FLEXIBLE;
1561 return flow;
1562 }
1563 }
1564
1565 memset(&rss_conf, 0, sizeof(struct igb_rte_flow_rss_conf));
1566 ret = igb_parse_rss_filter(dev, attr,
1567 actions, &rss_conf, error);
1568 if (!ret) {
1569 ret = igb_config_rss_filter(dev, &rss_conf, TRUE);
1570 if (!ret) {
1571 rss_filter_ptr = rte_zmalloc("igb_rss_filter",
1572 sizeof(struct igb_rss_conf_ele), 0);
1573 if (!rss_filter_ptr) {
1574 PMD_DRV_LOG(ERR, "failed to allocate memory");
1575 goto out;
1576 }
1577 igb_rss_conf_init(&rss_filter_ptr->filter_info,
1578 &rss_conf.conf);
1579 TAILQ_INSERT_TAIL(&igb_filter_rss_list,
1580 rss_filter_ptr, entries);
1581 flow->rule = rss_filter_ptr;
1582 flow->filter_type = RTE_ETH_FILTER_HASH;
1583 return flow;
1584 }
1585 }
1586
1587 out:
1588 TAILQ_REMOVE(&igb_flow_list,
1589 igb_flow_mem_ptr, entries);
1590 rte_flow_error_set(error, -ret,
1591 RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1592 "Failed to create flow.");
1593 rte_free(igb_flow_mem_ptr);
1594 rte_free(flow);
1595 return NULL;
1596 }
1597
1598 /**
1599 * Check if the flow rule is supported by igb.
1600 * It only checkes the format. Don't guarantee the rule can be programmed into
1601 * the HW. Because there can be no enough room for the rule.
1602 */
1603 static int
1604 igb_flow_validate(__rte_unused struct rte_eth_dev *dev,
1605 const struct rte_flow_attr *attr,
1606 const struct rte_flow_item pattern[],
1607 const struct rte_flow_action actions[],
1608 struct rte_flow_error *error)
1609 {
1610 struct rte_eth_ntuple_filter ntuple_filter;
1611 struct rte_eth_ethertype_filter ethertype_filter;
1612 struct rte_eth_syn_filter syn_filter;
1613 struct rte_eth_flex_filter flex_filter;
1614 struct igb_rte_flow_rss_conf rss_conf;
1615 int ret;
1616
1617 memset(&ntuple_filter, 0, sizeof(struct rte_eth_ntuple_filter));
1618 ret = igb_parse_ntuple_filter(dev, attr, pattern,
1619 actions, &ntuple_filter, error);
1620 if (!ret)
1621 return 0;
1622
1623 memset(&ethertype_filter, 0, sizeof(struct rte_eth_ethertype_filter));
1624 ret = igb_parse_ethertype_filter(dev, attr, pattern,
1625 actions, &ethertype_filter, error);
1626 if (!ret)
1627 return 0;
1628
1629 memset(&syn_filter, 0, sizeof(struct rte_eth_syn_filter));
1630 ret = igb_parse_syn_filter(dev, attr, pattern,
1631 actions, &syn_filter, error);
1632 if (!ret)
1633 return 0;
1634
1635 memset(&flex_filter, 0, sizeof(struct rte_eth_flex_filter));
1636 ret = igb_parse_flex_filter(dev, attr, pattern,
1637 actions, &flex_filter, error);
1638 if (!ret)
1639 return 0;
1640
1641 memset(&rss_conf, 0, sizeof(struct igb_rte_flow_rss_conf));
1642 ret = igb_parse_rss_filter(dev, attr,
1643 actions, &rss_conf, error);
1644
1645 return ret;
1646 }
1647
1648 /* Destroy a flow rule on igb. */
1649 static int
1650 igb_flow_destroy(struct rte_eth_dev *dev,
1651 struct rte_flow *flow,
1652 struct rte_flow_error *error)
1653 {
1654 int ret;
1655 struct rte_flow *pmd_flow = flow;
1656 enum rte_filter_type filter_type = pmd_flow->filter_type;
1657 struct igb_ntuple_filter_ele *ntuple_filter_ptr;
1658 struct igb_ethertype_filter_ele *ethertype_filter_ptr;
1659 struct igb_eth_syn_filter_ele *syn_filter_ptr;
1660 struct igb_flex_filter_ele *flex_filter_ptr;
1661 struct igb_flow_mem *igb_flow_mem_ptr;
1662 struct igb_rss_conf_ele *rss_filter_ptr;
1663
1664 switch (filter_type) {
1665 case RTE_ETH_FILTER_NTUPLE:
1666 ntuple_filter_ptr = (struct igb_ntuple_filter_ele *)
1667 pmd_flow->rule;
1668 ret = igb_add_del_ntuple_filter(dev,
1669 &ntuple_filter_ptr->filter_info, FALSE);
1670 if (!ret) {
1671 TAILQ_REMOVE(&igb_filter_ntuple_list,
1672 ntuple_filter_ptr, entries);
1673 rte_free(ntuple_filter_ptr);
1674 }
1675 break;
1676 case RTE_ETH_FILTER_ETHERTYPE:
1677 ethertype_filter_ptr = (struct igb_ethertype_filter_ele *)
1678 pmd_flow->rule;
1679 ret = igb_add_del_ethertype_filter(dev,
1680 &ethertype_filter_ptr->filter_info, FALSE);
1681 if (!ret) {
1682 TAILQ_REMOVE(&igb_filter_ethertype_list,
1683 ethertype_filter_ptr, entries);
1684 rte_free(ethertype_filter_ptr);
1685 }
1686 break;
1687 case RTE_ETH_FILTER_SYN:
1688 syn_filter_ptr = (struct igb_eth_syn_filter_ele *)
1689 pmd_flow->rule;
1690 ret = eth_igb_syn_filter_set(dev,
1691 &syn_filter_ptr->filter_info, FALSE);
1692 if (!ret) {
1693 TAILQ_REMOVE(&igb_filter_syn_list,
1694 syn_filter_ptr, entries);
1695 rte_free(syn_filter_ptr);
1696 }
1697 break;
1698 case RTE_ETH_FILTER_FLEXIBLE:
1699 flex_filter_ptr = (struct igb_flex_filter_ele *)
1700 pmd_flow->rule;
1701 ret = eth_igb_add_del_flex_filter(dev,
1702 &flex_filter_ptr->filter_info, FALSE);
1703 if (!ret) {
1704 TAILQ_REMOVE(&igb_filter_flex_list,
1705 flex_filter_ptr, entries);
1706 rte_free(flex_filter_ptr);
1707 }
1708 break;
1709 case RTE_ETH_FILTER_HASH:
1710 rss_filter_ptr = (struct igb_rss_conf_ele *)
1711 pmd_flow->rule;
1712 ret = igb_config_rss_filter(dev,
1713 &rss_filter_ptr->filter_info, FALSE);
1714 if (!ret) {
1715 TAILQ_REMOVE(&igb_filter_rss_list,
1716 rss_filter_ptr, entries);
1717 rte_free(rss_filter_ptr);
1718 }
1719 break;
1720 default:
1721 PMD_DRV_LOG(WARNING, "Filter type (%d) not supported",
1722 filter_type);
1723 ret = -EINVAL;
1724 break;
1725 }
1726
1727 if (ret) {
1728 rte_flow_error_set(error, EINVAL,
1729 RTE_FLOW_ERROR_TYPE_HANDLE,
1730 NULL, "Failed to destroy flow");
1731 return ret;
1732 }
1733
1734 TAILQ_FOREACH(igb_flow_mem_ptr, &igb_flow_list, entries) {
1735 if (igb_flow_mem_ptr->flow == pmd_flow) {
1736 TAILQ_REMOVE(&igb_flow_list,
1737 igb_flow_mem_ptr, entries);
1738 rte_free(igb_flow_mem_ptr);
1739 }
1740 }
1741 rte_free(flow);
1742
1743 return ret;
1744 }
1745
1746 /* remove all the n-tuple filters */
1747 static void
1748 igb_clear_all_ntuple_filter(struct rte_eth_dev *dev)
1749 {
1750 struct e1000_filter_info *filter_info =
1751 E1000_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
1752 struct e1000_5tuple_filter *p_5tuple;
1753 struct e1000_2tuple_filter *p_2tuple;
1754
1755 while ((p_5tuple = TAILQ_FIRST(&filter_info->fivetuple_list)))
1756 igb_delete_5tuple_filter_82576(dev, p_5tuple);
1757
1758 while ((p_2tuple = TAILQ_FIRST(&filter_info->twotuple_list)))
1759 igb_delete_2tuple_filter(dev, p_2tuple);
1760 }
1761
1762 /* remove all the ether type filters */
1763 static void
1764 igb_clear_all_ethertype_filter(struct rte_eth_dev *dev)
1765 {
1766 struct e1000_hw *hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1767 struct e1000_filter_info *filter_info =
1768 E1000_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
1769 int i;
1770
1771 for (i = 0; i < E1000_MAX_ETQF_FILTERS; i++) {
1772 if (filter_info->ethertype_mask & (1 << i)) {
1773 (void)igb_ethertype_filter_remove(filter_info,
1774 (uint8_t)i);
1775 E1000_WRITE_REG(hw, E1000_ETQF(i), 0);
1776 E1000_WRITE_FLUSH(hw);
1777 }
1778 }
1779 }
1780
1781 /* remove the SYN filter */
1782 static void
1783 igb_clear_syn_filter(struct rte_eth_dev *dev)
1784 {
1785 struct e1000_hw *hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1786 struct e1000_filter_info *filter_info =
1787 E1000_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
1788
1789 if (filter_info->syn_info & E1000_SYN_FILTER_ENABLE) {
1790 filter_info->syn_info = 0;
1791 E1000_WRITE_REG(hw, E1000_SYNQF(0), 0);
1792 E1000_WRITE_FLUSH(hw);
1793 }
1794 }
1795
1796 /* remove all the flex filters */
1797 static void
1798 igb_clear_all_flex_filter(struct rte_eth_dev *dev)
1799 {
1800 struct e1000_filter_info *filter_info =
1801 E1000_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
1802 struct e1000_flex_filter *flex_filter;
1803
1804 while ((flex_filter = TAILQ_FIRST(&filter_info->flex_list)))
1805 igb_remove_flex_filter(dev, flex_filter);
1806 }
1807
1808 /* remove the rss filter */
1809 static void
1810 igb_clear_rss_filter(struct rte_eth_dev *dev)
1811 {
1812 struct e1000_filter_info *filter =
1813 E1000_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
1814
1815 if (filter->rss_info.conf.queue_num)
1816 igb_config_rss_filter(dev, &filter->rss_info, FALSE);
1817 }
1818
1819 void
1820 igb_filterlist_flush(struct rte_eth_dev *dev)
1821 {
1822 struct igb_ntuple_filter_ele *ntuple_filter_ptr;
1823 struct igb_ethertype_filter_ele *ethertype_filter_ptr;
1824 struct igb_eth_syn_filter_ele *syn_filter_ptr;
1825 struct igb_flex_filter_ele *flex_filter_ptr;
1826 struct igb_rss_conf_ele *rss_filter_ptr;
1827 struct igb_flow_mem *igb_flow_mem_ptr;
1828 enum rte_filter_type filter_type;
1829 struct rte_flow *pmd_flow;
1830
1831 TAILQ_FOREACH(igb_flow_mem_ptr, &igb_flow_list, entries) {
1832 if (igb_flow_mem_ptr->dev == dev) {
1833 pmd_flow = igb_flow_mem_ptr->flow;
1834 filter_type = pmd_flow->filter_type;
1835
1836 switch (filter_type) {
1837 case RTE_ETH_FILTER_NTUPLE:
1838 ntuple_filter_ptr =
1839 (struct igb_ntuple_filter_ele *)
1840 pmd_flow->rule;
1841 TAILQ_REMOVE(&igb_filter_ntuple_list,
1842 ntuple_filter_ptr, entries);
1843 rte_free(ntuple_filter_ptr);
1844 break;
1845 case RTE_ETH_FILTER_ETHERTYPE:
1846 ethertype_filter_ptr =
1847 (struct igb_ethertype_filter_ele *)
1848 pmd_flow->rule;
1849 TAILQ_REMOVE(&igb_filter_ethertype_list,
1850 ethertype_filter_ptr, entries);
1851 rte_free(ethertype_filter_ptr);
1852 break;
1853 case RTE_ETH_FILTER_SYN:
1854 syn_filter_ptr =
1855 (struct igb_eth_syn_filter_ele *)
1856 pmd_flow->rule;
1857 TAILQ_REMOVE(&igb_filter_syn_list,
1858 syn_filter_ptr, entries);
1859 rte_free(syn_filter_ptr);
1860 break;
1861 case RTE_ETH_FILTER_FLEXIBLE:
1862 flex_filter_ptr =
1863 (struct igb_flex_filter_ele *)
1864 pmd_flow->rule;
1865 TAILQ_REMOVE(&igb_filter_flex_list,
1866 flex_filter_ptr, entries);
1867 rte_free(flex_filter_ptr);
1868 break;
1869 case RTE_ETH_FILTER_HASH:
1870 rss_filter_ptr =
1871 (struct igb_rss_conf_ele *)
1872 pmd_flow->rule;
1873 TAILQ_REMOVE(&igb_filter_rss_list,
1874 rss_filter_ptr, entries);
1875 rte_free(rss_filter_ptr);
1876 break;
1877 default:
1878 PMD_DRV_LOG(WARNING, "Filter type"
1879 "(%d) not supported", filter_type);
1880 break;
1881 }
1882 TAILQ_REMOVE(&igb_flow_list,
1883 igb_flow_mem_ptr,
1884 entries);
1885 rte_free(igb_flow_mem_ptr->flow);
1886 rte_free(igb_flow_mem_ptr);
1887 }
1888 }
1889 }
1890
1891 /* Destroy all flow rules associated with a port on igb. */
1892 static int
1893 igb_flow_flush(struct rte_eth_dev *dev,
1894 __rte_unused struct rte_flow_error *error)
1895 {
1896 igb_clear_all_ntuple_filter(dev);
1897 igb_clear_all_ethertype_filter(dev);
1898 igb_clear_syn_filter(dev);
1899 igb_clear_all_flex_filter(dev);
1900 igb_clear_rss_filter(dev);
1901 igb_filterlist_flush(dev);
1902
1903 return 0;
1904 }
1905
1906 const struct rte_flow_ops igb_flow_ops = {
1907 .validate = igb_flow_validate,
1908 .create = igb_flow_create,
1909 .destroy = igb_flow_destroy,
1910 .flush = igb_flow_flush,
1911 };
Ceph