]> git.proxmox.com Git - ceph.git/blob - ceph/src/spdk/dpdk/drivers/net/ixgbe/ixgbe_flow.c
projects / ceph.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
update source to Ceph Pacific 16.2.2
[ceph.git] / ceph / src / spdk / dpdk / drivers / net / ixgbe / ixgbe_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 <string.h>
10 #include <unistd.h>
11 #include <stdarg.h>
12 #include <inttypes.h>
13 #include <netinet/in.h>
14 #include <rte_byteorder.h>
15 #include <rte_common.h>
16 #include <rte_cycles.h>
17
18 #include <rte_interrupts.h>
19 #include <rte_log.h>
20 #include <rte_debug.h>
21 #include <rte_pci.h>
22 #include <rte_atomic.h>
23 #include <rte_branch_prediction.h>
24 #include <rte_memory.h>
25 #include <rte_eal.h>
26 #include <rte_alarm.h>
27 #include <rte_ether.h>
28 #include <rte_ethdev_driver.h>
29 #include <rte_malloc.h>
30 #include <rte_random.h>
31 #include <rte_dev.h>
32 #include <rte_hash_crc.h>
33 #include <rte_flow.h>
34 #include <rte_flow_driver.h>
35
36 #include "ixgbe_logs.h"
37 #include "base/ixgbe_api.h"
38 #include "base/ixgbe_vf.h"
39 #include "base/ixgbe_common.h"
40 #include "ixgbe_ethdev.h"
41 #include "ixgbe_bypass.h"
42 #include "ixgbe_rxtx.h"
43 #include "base/ixgbe_type.h"
44 #include "base/ixgbe_phy.h"
45 #include "rte_pmd_ixgbe.h"
46
47
48 #define IXGBE_MIN_N_TUPLE_PRIO 1
49 #define IXGBE_MAX_N_TUPLE_PRIO 7
50 #define IXGBE_MAX_FLX_SOURCE_OFF 62
51
52 /* ntuple filter list structure */
53 struct ixgbe_ntuple_filter_ele {
54 TAILQ_ENTRY(ixgbe_ntuple_filter_ele) entries;
55 struct rte_eth_ntuple_filter filter_info;
56 };
57 /* ethertype filter list structure */
58 struct ixgbe_ethertype_filter_ele {
59 TAILQ_ENTRY(ixgbe_ethertype_filter_ele) entries;
60 struct rte_eth_ethertype_filter filter_info;
61 };
62 /* syn filter list structure */
63 struct ixgbe_eth_syn_filter_ele {
64 TAILQ_ENTRY(ixgbe_eth_syn_filter_ele) entries;
65 struct rte_eth_syn_filter filter_info;
66 };
67 /* fdir filter list structure */
68 struct ixgbe_fdir_rule_ele {
69 TAILQ_ENTRY(ixgbe_fdir_rule_ele) entries;
70 struct ixgbe_fdir_rule filter_info;
71 };
72 /* l2_tunnel filter list structure */
73 struct ixgbe_eth_l2_tunnel_conf_ele {
74 TAILQ_ENTRY(ixgbe_eth_l2_tunnel_conf_ele) entries;
75 struct rte_eth_l2_tunnel_conf filter_info;
76 };
77 /* rss filter list structure */
78 struct ixgbe_rss_conf_ele {
79 TAILQ_ENTRY(ixgbe_rss_conf_ele) entries;
80 struct ixgbe_rte_flow_rss_conf filter_info;
81 };
82 /* ixgbe_flow memory list structure */
83 struct ixgbe_flow_mem {
84 TAILQ_ENTRY(ixgbe_flow_mem) entries;
85 struct rte_flow *flow;
86 };
87
88 TAILQ_HEAD(ixgbe_ntuple_filter_list, ixgbe_ntuple_filter_ele);
89 TAILQ_HEAD(ixgbe_ethertype_filter_list, ixgbe_ethertype_filter_ele);
90 TAILQ_HEAD(ixgbe_syn_filter_list, ixgbe_eth_syn_filter_ele);
91 TAILQ_HEAD(ixgbe_fdir_rule_filter_list, ixgbe_fdir_rule_ele);
92 TAILQ_HEAD(ixgbe_l2_tunnel_filter_list, ixgbe_eth_l2_tunnel_conf_ele);
93 TAILQ_HEAD(ixgbe_rss_filter_list, ixgbe_rss_conf_ele);
94 TAILQ_HEAD(ixgbe_flow_mem_list, ixgbe_flow_mem);
95
96 static struct ixgbe_ntuple_filter_list filter_ntuple_list;
97 static struct ixgbe_ethertype_filter_list filter_ethertype_list;
98 static struct ixgbe_syn_filter_list filter_syn_list;
99 static struct ixgbe_fdir_rule_filter_list filter_fdir_list;
100 static struct ixgbe_l2_tunnel_filter_list filter_l2_tunnel_list;
101 static struct ixgbe_rss_filter_list filter_rss_list;
102 static struct ixgbe_flow_mem_list ixgbe_flow_list;
103
104 /**
105 * Endless loop will never happen with below assumption
106 * 1. there is at least one no-void item(END)
107 * 2. cur is before END.
108 */
109 static inline
110 const struct rte_flow_item *next_no_void_pattern(
111 const struct rte_flow_item pattern[],
112 const struct rte_flow_item *cur)
113 {
114 const struct rte_flow_item *next =
115 cur ? cur + 1 : &pattern[0];
116 while (1) {
117 if (next->type != RTE_FLOW_ITEM_TYPE_VOID)
118 return next;
119 next++;
120 }
121 }
122
123 static inline
124 const struct rte_flow_action *next_no_void_action(
125 const struct rte_flow_action actions[],
126 const struct rte_flow_action *cur)
127 {
128 const struct rte_flow_action *next =
129 cur ? cur + 1 : &actions[0];
130 while (1) {
131 if (next->type != RTE_FLOW_ACTION_TYPE_VOID)
132 return next;
133 next++;
134 }
135 }
136
137 /**
138 * Please aware there's an asumption for all the parsers.
139 * rte_flow_item is using big endian, rte_flow_attr and
140 * rte_flow_action are using CPU order.
141 * Because the pattern is used to describe the packets,
142 * normally the packets should use network order.
143 */
144
145 /**
146 * Parse the rule to see if it is a n-tuple rule.
147 * And get the n-tuple filter info BTW.
148 * pattern:
149 * The first not void item can be ETH or IPV4.
150 * The second not void item must be IPV4 if the first one is ETH.
151 * The third not void item must be UDP or TCP.
152 * The next not void item must be END.
153 * action:
154 * The first not void action should be QUEUE.
155 * The next not void action should be END.
156 * pattern example:
157 * ITEM Spec Mask
158 * ETH NULL NULL
159 * IPV4 src_addr 192.168.1.20 0xFFFFFFFF
160 * dst_addr 192.167.3.50 0xFFFFFFFF
161 * next_proto_id 17 0xFF
162 * UDP/TCP/ src_port 80 0xFFFF
163 * SCTP dst_port 80 0xFFFF
164 * END
165 * other members in mask and spec should set to 0x00.
166 * item->last should be NULL.
167 *
168 * Special case for flow action type RTE_FLOW_ACTION_TYPE_SECURITY.
169 *
170 */
171 static int
172 cons_parse_ntuple_filter(const struct rte_flow_attr *attr,
173 const struct rte_flow_item pattern[],
174 const struct rte_flow_action actions[],
175 struct rte_eth_ntuple_filter *filter,
176 struct rte_flow_error *error)
177 {
178 const struct rte_flow_item *item;
179 const struct rte_flow_action *act;
180 const struct rte_flow_item_ipv4 *ipv4_spec;
181 const struct rte_flow_item_ipv4 *ipv4_mask;
182 const struct rte_flow_item_tcp *tcp_spec;
183 const struct rte_flow_item_tcp *tcp_mask;
184 const struct rte_flow_item_udp *udp_spec;
185 const struct rte_flow_item_udp *udp_mask;
186 const struct rte_flow_item_sctp *sctp_spec;
187 const struct rte_flow_item_sctp *sctp_mask;
188 const struct rte_flow_item_eth *eth_spec;
189 const struct rte_flow_item_eth *eth_mask;
190 const struct rte_flow_item_vlan *vlan_spec;
191 const struct rte_flow_item_vlan *vlan_mask;
192 struct rte_flow_item_eth eth_null;
193 struct rte_flow_item_vlan vlan_null;
194
195 if (!pattern) {
196 rte_flow_error_set(error,
197 EINVAL, RTE_FLOW_ERROR_TYPE_ITEM_NUM,
198 NULL, "NULL pattern.");
199 return -rte_errno;
200 }
201
202 if (!actions) {
203 rte_flow_error_set(error, EINVAL,
204 RTE_FLOW_ERROR_TYPE_ACTION_NUM,
205 NULL, "NULL action.");
206 return -rte_errno;
207 }
208 if (!attr) {
209 rte_flow_error_set(error, EINVAL,
210 RTE_FLOW_ERROR_TYPE_ATTR,
211 NULL, "NULL attribute.");
212 return -rte_errno;
213 }
214
215 memset(&eth_null, 0, sizeof(struct rte_flow_item_eth));
216 memset(&vlan_null, 0, sizeof(struct rte_flow_item_vlan));
217
218 #ifdef RTE_LIBRTE_SECURITY
219 /**
220 * Special case for flow action type RTE_FLOW_ACTION_TYPE_SECURITY
221 */
222 act = next_no_void_action(actions, NULL);
223 if (act->type == RTE_FLOW_ACTION_TYPE_SECURITY) {
224 const void *conf = act->conf;
225 /* check if the next not void item is END */
226 act = next_no_void_action(actions, act);
227 if (act->type != RTE_FLOW_ACTION_TYPE_END) {
228 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
229 rte_flow_error_set(error, EINVAL,
230 RTE_FLOW_ERROR_TYPE_ACTION,
231 act, "Not supported action.");
232 return -rte_errno;
233 }
234
235 /* get the IP pattern*/
236 item = next_no_void_pattern(pattern, NULL);
237 while (item->type != RTE_FLOW_ITEM_TYPE_IPV4 &&
238 item->type != RTE_FLOW_ITEM_TYPE_IPV6) {
239 if (item->last ||
240 item->type == RTE_FLOW_ITEM_TYPE_END) {
241 rte_flow_error_set(error, EINVAL,
242 RTE_FLOW_ERROR_TYPE_ITEM,
243 item, "IP pattern missing.");
244 return -rte_errno;
245 }
246 item = next_no_void_pattern(pattern, item);
247 }
248
249 filter->proto = IPPROTO_ESP;
250 return ixgbe_crypto_add_ingress_sa_from_flow(conf, item->spec,
251 item->type == RTE_FLOW_ITEM_TYPE_IPV6);
252 }
253 #endif
254
255 /* the first not void item can be MAC or IPv4 */
256 item = next_no_void_pattern(pattern, NULL);
257
258 if (item->type != RTE_FLOW_ITEM_TYPE_ETH &&
259 item->type != RTE_FLOW_ITEM_TYPE_IPV4) {
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 /* Skip Ethernet */
266 if (item->type == RTE_FLOW_ITEM_TYPE_ETH) {
267 eth_spec = item->spec;
268 eth_mask = item->mask;
269 /*Not supported last point for range*/
270 if (item->last) {
271 rte_flow_error_set(error,
272 EINVAL,
273 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
274 item, "Not supported last point for range");
275 return -rte_errno;
276
277 }
278 /* if the first item is MAC, the content should be NULL */
279 if ((item->spec || item->mask) &&
280 (memcmp(eth_spec, &eth_null,
281 sizeof(struct rte_flow_item_eth)) ||
282 memcmp(eth_mask, &eth_null,
283 sizeof(struct rte_flow_item_eth)))) {
284 rte_flow_error_set(error, EINVAL,
285 RTE_FLOW_ERROR_TYPE_ITEM,
286 item, "Not supported by ntuple filter");
287 return -rte_errno;
288 }
289 /* check if the next not void item is IPv4 or Vlan */
290 item = next_no_void_pattern(pattern, item);
291 if (item->type != RTE_FLOW_ITEM_TYPE_IPV4 &&
292 item->type != RTE_FLOW_ITEM_TYPE_VLAN) {
293 rte_flow_error_set(error,
294 EINVAL, RTE_FLOW_ERROR_TYPE_ITEM,
295 item, "Not supported by ntuple filter");
296 return -rte_errno;
297 }
298 }
299
300 if (item->type == RTE_FLOW_ITEM_TYPE_VLAN) {
301 vlan_spec = item->spec;
302 vlan_mask = item->mask;
303 /*Not supported last point for range*/
304 if (item->last) {
305 rte_flow_error_set(error,
306 EINVAL,
307 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
308 item, "Not supported last point for range");
309 return -rte_errno;
310 }
311 /* the content should be NULL */
312 if ((item->spec || item->mask) &&
313 (memcmp(vlan_spec, &vlan_null,
314 sizeof(struct rte_flow_item_vlan)) ||
315 memcmp(vlan_mask, &vlan_null,
316 sizeof(struct rte_flow_item_vlan)))) {
317
318 rte_flow_error_set(error, EINVAL,
319 RTE_FLOW_ERROR_TYPE_ITEM,
320 item, "Not supported by ntuple filter");
321 return -rte_errno;
322 }
323 /* check if the next not void item is IPv4 */
324 item = next_no_void_pattern(pattern, item);
325 if (item->type != RTE_FLOW_ITEM_TYPE_IPV4) {
326 rte_flow_error_set(error,
327 EINVAL, RTE_FLOW_ERROR_TYPE_ITEM,
328 item, "Not supported by ntuple filter");
329 return -rte_errno;
330 }
331 }
332
333 if (item->mask) {
334 /* get the IPv4 info */
335 if (!item->spec || !item->mask) {
336 rte_flow_error_set(error, EINVAL,
337 RTE_FLOW_ERROR_TYPE_ITEM,
338 item, "Invalid ntuple mask");
339 return -rte_errno;
340 }
341 /*Not supported last point for range*/
342 if (item->last) {
343 rte_flow_error_set(error, EINVAL,
344 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
345 item, "Not supported last point for range");
346 return -rte_errno;
347 }
348
349 ipv4_mask = item->mask;
350 /**
351 * Only support src & dst addresses, protocol,
352 * others should be masked.
353 */
354 if (ipv4_mask->hdr.version_ihl ||
355 ipv4_mask->hdr.type_of_service ||
356 ipv4_mask->hdr.total_length ||
357 ipv4_mask->hdr.packet_id ||
358 ipv4_mask->hdr.fragment_offset ||
359 ipv4_mask->hdr.time_to_live ||
360 ipv4_mask->hdr.hdr_checksum) {
361 rte_flow_error_set(error,
362 EINVAL, RTE_FLOW_ERROR_TYPE_ITEM,
363 item, "Not supported by ntuple filter");
364 return -rte_errno;
365 }
366 if ((ipv4_mask->hdr.src_addr != 0 &&
367 ipv4_mask->hdr.src_addr != UINT32_MAX) ||
368 (ipv4_mask->hdr.dst_addr != 0 &&
369 ipv4_mask->hdr.dst_addr != UINT32_MAX) ||
370 (ipv4_mask->hdr.next_proto_id != UINT8_MAX &&
371 ipv4_mask->hdr.next_proto_id != 0)) {
372 rte_flow_error_set(error,
373 EINVAL, RTE_FLOW_ERROR_TYPE_ITEM,
374 item, "Not supported by ntuple filter");
375 return -rte_errno;
376 }
377
378 filter->dst_ip_mask = ipv4_mask->hdr.dst_addr;
379 filter->src_ip_mask = ipv4_mask->hdr.src_addr;
380 filter->proto_mask = ipv4_mask->hdr.next_proto_id;
381
382 ipv4_spec = item->spec;
383 filter->dst_ip = ipv4_spec->hdr.dst_addr;
384 filter->src_ip = ipv4_spec->hdr.src_addr;
385 filter->proto = ipv4_spec->hdr.next_proto_id;
386 }
387
388 /* check if the next not void item is TCP or UDP */
389 item = next_no_void_pattern(pattern, item);
390 if (item->type != RTE_FLOW_ITEM_TYPE_TCP &&
391 item->type != RTE_FLOW_ITEM_TYPE_UDP &&
392 item->type != RTE_FLOW_ITEM_TYPE_SCTP &&
393 item->type != RTE_FLOW_ITEM_TYPE_END) {
394 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
395 rte_flow_error_set(error, EINVAL,
396 RTE_FLOW_ERROR_TYPE_ITEM,
397 item, "Not supported by ntuple filter");
398 return -rte_errno;
399 }
400
401 if ((item->type != RTE_FLOW_ITEM_TYPE_END) &&
402 (!item->spec && !item->mask)) {
403 goto action;
404 }
405
406 /* get the TCP/UDP/SCTP info */
407 if (item->type != RTE_FLOW_ITEM_TYPE_END &&
408 (!item->spec || !item->mask)) {
409 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
410 rte_flow_error_set(error, EINVAL,
411 RTE_FLOW_ERROR_TYPE_ITEM,
412 item, "Invalid ntuple mask");
413 return -rte_errno;
414 }
415
416 /*Not supported last point for range*/
417 if (item->last) {
418 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
419 rte_flow_error_set(error, EINVAL,
420 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
421 item, "Not supported last point for range");
422 return -rte_errno;
423
424 }
425
426 if (item->type == RTE_FLOW_ITEM_TYPE_TCP) {
427 tcp_mask = item->mask;
428
429 /**
430 * Only support src & dst ports, tcp flags,
431 * others should be masked.
432 */
433 if (tcp_mask->hdr.sent_seq ||
434 tcp_mask->hdr.recv_ack ||
435 tcp_mask->hdr.data_off ||
436 tcp_mask->hdr.rx_win ||
437 tcp_mask->hdr.cksum ||
438 tcp_mask->hdr.tcp_urp) {
439 memset(filter, 0,
440 sizeof(struct rte_eth_ntuple_filter));
441 rte_flow_error_set(error, EINVAL,
442 RTE_FLOW_ERROR_TYPE_ITEM,
443 item, "Not supported by ntuple filter");
444 return -rte_errno;
445 }
446 if ((tcp_mask->hdr.src_port != 0 &&
447 tcp_mask->hdr.src_port != UINT16_MAX) ||
448 (tcp_mask->hdr.dst_port != 0 &&
449 tcp_mask->hdr.dst_port != UINT16_MAX)) {
450 rte_flow_error_set(error,
451 EINVAL, RTE_FLOW_ERROR_TYPE_ITEM,
452 item, "Not supported by ntuple filter");
453 return -rte_errno;
454 }
455
456 filter->dst_port_mask = tcp_mask->hdr.dst_port;
457 filter->src_port_mask = tcp_mask->hdr.src_port;
458 if (tcp_mask->hdr.tcp_flags == 0xFF) {
459 filter->flags |= RTE_NTUPLE_FLAGS_TCP_FLAG;
460 } else if (!tcp_mask->hdr.tcp_flags) {
461 filter->flags &= ~RTE_NTUPLE_FLAGS_TCP_FLAG;
462 } else {
463 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
464 rte_flow_error_set(error, EINVAL,
465 RTE_FLOW_ERROR_TYPE_ITEM,
466 item, "Not supported by ntuple filter");
467 return -rte_errno;
468 }
469
470 tcp_spec = item->spec;
471 filter->dst_port = tcp_spec->hdr.dst_port;
472 filter->src_port = tcp_spec->hdr.src_port;
473 filter->tcp_flags = tcp_spec->hdr.tcp_flags;
474 } else if (item->type == RTE_FLOW_ITEM_TYPE_UDP) {
475 udp_mask = item->mask;
476
477 /**
478 * Only support src & dst ports,
479 * others should be masked.
480 */
481 if (udp_mask->hdr.dgram_len ||
482 udp_mask->hdr.dgram_cksum) {
483 memset(filter, 0,
484 sizeof(struct rte_eth_ntuple_filter));
485 rte_flow_error_set(error, EINVAL,
486 RTE_FLOW_ERROR_TYPE_ITEM,
487 item, "Not supported by ntuple filter");
488 return -rte_errno;
489 }
490 if ((udp_mask->hdr.src_port != 0 &&
491 udp_mask->hdr.src_port != UINT16_MAX) ||
492 (udp_mask->hdr.dst_port != 0 &&
493 udp_mask->hdr.dst_port != UINT16_MAX)) {
494 rte_flow_error_set(error,
495 EINVAL, RTE_FLOW_ERROR_TYPE_ITEM,
496 item, "Not supported by ntuple filter");
497 return -rte_errno;
498 }
499
500 filter->dst_port_mask = udp_mask->hdr.dst_port;
501 filter->src_port_mask = udp_mask->hdr.src_port;
502
503 udp_spec = item->spec;
504 filter->dst_port = udp_spec->hdr.dst_port;
505 filter->src_port = udp_spec->hdr.src_port;
506 } else if (item->type == RTE_FLOW_ITEM_TYPE_SCTP) {
507 sctp_mask = item->mask;
508
509 /**
510 * Only support src & dst ports,
511 * others should be masked.
512 */
513 if (sctp_mask->hdr.tag ||
514 sctp_mask->hdr.cksum) {
515 memset(filter, 0,
516 sizeof(struct rte_eth_ntuple_filter));
517 rte_flow_error_set(error, EINVAL,
518 RTE_FLOW_ERROR_TYPE_ITEM,
519 item, "Not supported by ntuple filter");
520 return -rte_errno;
521 }
522
523 filter->dst_port_mask = sctp_mask->hdr.dst_port;
524 filter->src_port_mask = sctp_mask->hdr.src_port;
525
526 sctp_spec = item->spec;
527 filter->dst_port = sctp_spec->hdr.dst_port;
528 filter->src_port = sctp_spec->hdr.src_port;
529 } else {
530 goto action;
531 }
532
533 /* check if the next not void item is END */
534 item = next_no_void_pattern(pattern, item);
535 if (item->type != RTE_FLOW_ITEM_TYPE_END) {
536 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
537 rte_flow_error_set(error, EINVAL,
538 RTE_FLOW_ERROR_TYPE_ITEM,
539 item, "Not supported by ntuple filter");
540 return -rte_errno;
541 }
542
543 action:
544
545 /**
546 * n-tuple only supports forwarding,
547 * check if the first not void action is QUEUE.
548 */
549 act = next_no_void_action(actions, NULL);
550 if (act->type != RTE_FLOW_ACTION_TYPE_QUEUE) {
551 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
552 rte_flow_error_set(error, EINVAL,
553 RTE_FLOW_ERROR_TYPE_ACTION,
554 item, "Not supported action.");
555 return -rte_errno;
556 }
557 filter->queue =
558 ((const struct rte_flow_action_queue *)act->conf)->index;
559
560 /* check if the next not void item is END */
561 act = next_no_void_action(actions, act);
562 if (act->type != RTE_FLOW_ACTION_TYPE_END) {
563 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
564 rte_flow_error_set(error, EINVAL,
565 RTE_FLOW_ERROR_TYPE_ACTION,
566 act, "Not supported action.");
567 return -rte_errno;
568 }
569
570 /* parse attr */
571 /* must be input direction */
572 if (!attr->ingress) {
573 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
574 rte_flow_error_set(error, EINVAL,
575 RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
576 attr, "Only support ingress.");
577 return -rte_errno;
578 }
579
580 /* not supported */
581 if (attr->egress) {
582 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
583 rte_flow_error_set(error, EINVAL,
584 RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
585 attr, "Not support egress.");
586 return -rte_errno;
587 }
588
589 /* not supported */
590 if (attr->transfer) {
591 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
592 rte_flow_error_set(error, EINVAL,
593 RTE_FLOW_ERROR_TYPE_ATTR_TRANSFER,
594 attr, "No support for transfer.");
595 return -rte_errno;
596 }
597
598 if (attr->priority > 0xFFFF) {
599 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
600 rte_flow_error_set(error, EINVAL,
601 RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
602 attr, "Error priority.");
603 return -rte_errno;
604 }
605 filter->priority = (uint16_t)attr->priority;
606 if (attr->priority < IXGBE_MIN_N_TUPLE_PRIO ||
607 attr->priority > IXGBE_MAX_N_TUPLE_PRIO)
608 filter->priority = 1;
609
610 return 0;
611 }
612
613 /* a specific function for ixgbe because the flags is specific */
614 static int
615 ixgbe_parse_ntuple_filter(struct rte_eth_dev *dev,
616 const struct rte_flow_attr *attr,
617 const struct rte_flow_item pattern[],
618 const struct rte_flow_action actions[],
619 struct rte_eth_ntuple_filter *filter,
620 struct rte_flow_error *error)
621 {
622 int ret;
623 struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
624
625 MAC_TYPE_FILTER_SUP_EXT(hw->mac.type);
626
627 ret = cons_parse_ntuple_filter(attr, pattern, actions, filter, error);
628
629 if (ret)
630 return ret;
631
632 #ifdef RTE_LIBRTE_SECURITY
633 /* ESP flow not really a flow*/
634 if (filter->proto == IPPROTO_ESP)
635 return 0;
636 #endif
637
638 /* Ixgbe doesn't support tcp flags. */
639 if (filter->flags & RTE_NTUPLE_FLAGS_TCP_FLAG) {
640 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
641 rte_flow_error_set(error, EINVAL,
642 RTE_FLOW_ERROR_TYPE_ITEM,
643 NULL, "Not supported by ntuple filter");
644 return -rte_errno;
645 }
646
647 /* Ixgbe doesn't support many priorities. */
648 if (filter->priority < IXGBE_MIN_N_TUPLE_PRIO ||
649 filter->priority > IXGBE_MAX_N_TUPLE_PRIO) {
650 memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
651 rte_flow_error_set(error, EINVAL,
652 RTE_FLOW_ERROR_TYPE_ITEM,
653 NULL, "Priority not supported by ntuple filter");
654 return -rte_errno;
655 }
656
657 if (filter->queue >= dev->data->nb_rx_queues)
658 return -rte_errno;
659
660 /* fixed value for ixgbe */
661 filter->flags = RTE_5TUPLE_FLAGS;
662 return 0;
663 }
664
665 /**
666 * Parse the rule to see if it is a ethertype rule.
667 * And get the ethertype filter info BTW.
668 * pattern:
669 * The first not void item can be ETH.
670 * The next not void item must be END.
671 * action:
672 * The first not void action should be QUEUE.
673 * The next not void action should be END.
674 * pattern example:
675 * ITEM Spec Mask
676 * ETH type 0x0807 0xFFFF
677 * END
678 * other members in mask and spec should set to 0x00.
679 * item->last should be NULL.
680 */
681 static int
682 cons_parse_ethertype_filter(const struct rte_flow_attr *attr,
683 const struct rte_flow_item *pattern,
684 const struct rte_flow_action *actions,
685 struct rte_eth_ethertype_filter *filter,
686 struct rte_flow_error *error)
687 {
688 const struct rte_flow_item *item;
689 const struct rte_flow_action *act;
690 const struct rte_flow_item_eth *eth_spec;
691 const struct rte_flow_item_eth *eth_mask;
692 const struct rte_flow_action_queue *act_q;
693
694 if (!pattern) {
695 rte_flow_error_set(error, EINVAL,
696 RTE_FLOW_ERROR_TYPE_ITEM_NUM,
697 NULL, "NULL pattern.");
698 return -rte_errno;
699 }
700
701 if (!actions) {
702 rte_flow_error_set(error, EINVAL,
703 RTE_FLOW_ERROR_TYPE_ACTION_NUM,
704 NULL, "NULL action.");
705 return -rte_errno;
706 }
707
708 if (!attr) {
709 rte_flow_error_set(error, EINVAL,
710 RTE_FLOW_ERROR_TYPE_ATTR,
711 NULL, "NULL attribute.");
712 return -rte_errno;
713 }
714
715 item = next_no_void_pattern(pattern, NULL);
716 /* The first non-void item should be MAC. */
717 if (item->type != RTE_FLOW_ITEM_TYPE_ETH) {
718 rte_flow_error_set(error, EINVAL,
719 RTE_FLOW_ERROR_TYPE_ITEM,
720 item, "Not supported by ethertype filter");
721 return -rte_errno;
722 }
723
724 /*Not supported last point for range*/
725 if (item->last) {
726 rte_flow_error_set(error, EINVAL,
727 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
728 item, "Not supported last point for range");
729 return -rte_errno;
730 }
731
732 /* Get the MAC info. */
733 if (!item->spec || !item->mask) {
734 rte_flow_error_set(error, EINVAL,
735 RTE_FLOW_ERROR_TYPE_ITEM,
736 item, "Not supported by ethertype filter");
737 return -rte_errno;
738 }
739
740 eth_spec = item->spec;
741 eth_mask = item->mask;
742
743 /* Mask bits of source MAC address must be full of 0.
744 * Mask bits of destination MAC address must be full
745 * of 1 or full of 0.
746 */
747 if (!rte_is_zero_ether_addr(&eth_mask->src) ||
748 (!rte_is_zero_ether_addr(&eth_mask->dst) &&
749 !rte_is_broadcast_ether_addr(&eth_mask->dst))) {
750 rte_flow_error_set(error, EINVAL,
751 RTE_FLOW_ERROR_TYPE_ITEM,
752 item, "Invalid ether address mask");
753 return -rte_errno;
754 }
755
756 if ((eth_mask->type & UINT16_MAX) != UINT16_MAX) {
757 rte_flow_error_set(error, EINVAL,
758 RTE_FLOW_ERROR_TYPE_ITEM,
759 item, "Invalid ethertype mask");
760 return -rte_errno;
761 }
762
763 /* If mask bits of destination MAC address
764 * are full of 1, set RTE_ETHTYPE_FLAGS_MAC.
765 */
766 if (rte_is_broadcast_ether_addr(&eth_mask->dst)) {
767 filter->mac_addr = eth_spec->dst;
768 filter->flags |= RTE_ETHTYPE_FLAGS_MAC;
769 } else {
770 filter->flags &= ~RTE_ETHTYPE_FLAGS_MAC;
771 }
772 filter->ether_type = rte_be_to_cpu_16(eth_spec->type);
773
774 /* Check if the next non-void item is END. */
775 item = next_no_void_pattern(pattern, item);
776 if (item->type != RTE_FLOW_ITEM_TYPE_END) {
777 rte_flow_error_set(error, EINVAL,
778 RTE_FLOW_ERROR_TYPE_ITEM,
779 item, "Not supported by ethertype filter.");
780 return -rte_errno;
781 }
782
783 /* Parse action */
784
785 act = next_no_void_action(actions, NULL);
786 if (act->type != RTE_FLOW_ACTION_TYPE_QUEUE &&
787 act->type != RTE_FLOW_ACTION_TYPE_DROP) {
788 rte_flow_error_set(error, EINVAL,
789 RTE_FLOW_ERROR_TYPE_ACTION,
790 act, "Not supported action.");
791 return -rte_errno;
792 }
793
794 if (act->type == RTE_FLOW_ACTION_TYPE_QUEUE) {
795 act_q = (const struct rte_flow_action_queue *)act->conf;
796 filter->queue = act_q->index;
797 } else {
798 filter->flags |= RTE_ETHTYPE_FLAGS_DROP;
799 }
800
801 /* Check if the next non-void item is END */
802 act = next_no_void_action(actions, act);
803 if (act->type != RTE_FLOW_ACTION_TYPE_END) {
804 rte_flow_error_set(error, EINVAL,
805 RTE_FLOW_ERROR_TYPE_ACTION,
806 act, "Not supported action.");
807 return -rte_errno;
808 }
809
810 /* Parse attr */
811 /* Must be input direction */
812 if (!attr->ingress) {
813 rte_flow_error_set(error, EINVAL,
814 RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
815 attr, "Only support ingress.");
816 return -rte_errno;
817 }
818
819 /* Not supported */
820 if (attr->egress) {
821 rte_flow_error_set(error, EINVAL,
822 RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
823 attr, "Not support egress.");
824 return -rte_errno;
825 }
826
827 /* Not supported */
828 if (attr->transfer) {
829 rte_flow_error_set(error, EINVAL,
830 RTE_FLOW_ERROR_TYPE_ATTR_TRANSFER,
831 attr, "No support for transfer.");
832 return -rte_errno;
833 }
834
835 /* Not supported */
836 if (attr->priority) {
837 rte_flow_error_set(error, EINVAL,
838 RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
839 attr, "Not support priority.");
840 return -rte_errno;
841 }
842
843 /* Not supported */
844 if (attr->group) {
845 rte_flow_error_set(error, EINVAL,
846 RTE_FLOW_ERROR_TYPE_ATTR_GROUP,
847 attr, "Not support group.");
848 return -rte_errno;
849 }
850
851 return 0;
852 }
853
854 static int
855 ixgbe_parse_ethertype_filter(struct rte_eth_dev *dev,
856 const struct rte_flow_attr *attr,
857 const struct rte_flow_item pattern[],
858 const struct rte_flow_action actions[],
859 struct rte_eth_ethertype_filter *filter,
860 struct rte_flow_error *error)
861 {
862 int ret;
863 struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
864
865 MAC_TYPE_FILTER_SUP(hw->mac.type);
866
867 ret = cons_parse_ethertype_filter(attr, pattern,
868 actions, filter, error);
869
870 if (ret)
871 return ret;
872
873 /* Ixgbe doesn't support MAC address. */
874 if (filter->flags & RTE_ETHTYPE_FLAGS_MAC) {
875 memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
876 rte_flow_error_set(error, EINVAL,
877 RTE_FLOW_ERROR_TYPE_ITEM,
878 NULL, "Not supported by ethertype filter");
879 return -rte_errno;
880 }
881
882 if (filter->queue >= dev->data->nb_rx_queues) {
883 memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
884 rte_flow_error_set(error, EINVAL,
885 RTE_FLOW_ERROR_TYPE_ITEM,
886 NULL, "queue index much too big");
887 return -rte_errno;
888 }
889
890 if (filter->ether_type == RTE_ETHER_TYPE_IPV4 ||
891 filter->ether_type == RTE_ETHER_TYPE_IPV6) {
892 memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
893 rte_flow_error_set(error, EINVAL,
894 RTE_FLOW_ERROR_TYPE_ITEM,
895 NULL, "IPv4/IPv6 not supported by ethertype filter");
896 return -rte_errno;
897 }
898
899 if (filter->flags & RTE_ETHTYPE_FLAGS_MAC) {
900 memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
901 rte_flow_error_set(error, EINVAL,
902 RTE_FLOW_ERROR_TYPE_ITEM,
903 NULL, "mac compare is unsupported");
904 return -rte_errno;
905 }
906
907 if (filter->flags & RTE_ETHTYPE_FLAGS_DROP) {
908 memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
909 rte_flow_error_set(error, EINVAL,
910 RTE_FLOW_ERROR_TYPE_ITEM,
911 NULL, "drop option is unsupported");
912 return -rte_errno;
913 }
914
915 return 0;
916 }
917
918 /**
919 * Parse the rule to see if it is a TCP SYN rule.
920 * And get the TCP SYN filter info BTW.
921 * pattern:
922 * The first not void item must be ETH.
923 * The second not void item must be IPV4 or IPV6.
924 * The third not void item must be TCP.
925 * The next not void item must be END.
926 * action:
927 * The first not void action should be QUEUE.
928 * The next not void action should be END.
929 * pattern example:
930 * ITEM Spec Mask
931 * ETH NULL NULL
932 * IPV4/IPV6 NULL NULL
933 * TCP tcp_flags 0x02 0xFF
934 * END
935 * other members in mask and spec should set to 0x00.
936 * item->last should be NULL.
937 */
938 static int
939 cons_parse_syn_filter(const struct rte_flow_attr *attr,
940 const struct rte_flow_item pattern[],
941 const struct rte_flow_action actions[],
942 struct rte_eth_syn_filter *filter,
943 struct rte_flow_error *error)
944 {
945 const struct rte_flow_item *item;
946 const struct rte_flow_action *act;
947 const struct rte_flow_item_tcp *tcp_spec;
948 const struct rte_flow_item_tcp *tcp_mask;
949 const struct rte_flow_action_queue *act_q;
950
951 if (!pattern) {
952 rte_flow_error_set(error, EINVAL,
953 RTE_FLOW_ERROR_TYPE_ITEM_NUM,
954 NULL, "NULL pattern.");
955 return -rte_errno;
956 }
957
958 if (!actions) {
959 rte_flow_error_set(error, EINVAL,
960 RTE_FLOW_ERROR_TYPE_ACTION_NUM,
961 NULL, "NULL action.");
962 return -rte_errno;
963 }
964
965 if (!attr) {
966 rte_flow_error_set(error, EINVAL,
967 RTE_FLOW_ERROR_TYPE_ATTR,
968 NULL, "NULL attribute.");
969 return -rte_errno;
970 }
971
972
973 /* the first not void item should be MAC or IPv4 or IPv6 or TCP */
974 item = next_no_void_pattern(pattern, NULL);
975 if (item->type != RTE_FLOW_ITEM_TYPE_ETH &&
976 item->type != RTE_FLOW_ITEM_TYPE_IPV4 &&
977 item->type != RTE_FLOW_ITEM_TYPE_IPV6 &&
978 item->type != RTE_FLOW_ITEM_TYPE_TCP) {
979 rte_flow_error_set(error, EINVAL,
980 RTE_FLOW_ERROR_TYPE_ITEM,
981 item, "Not supported by syn filter");
982 return -rte_errno;
983 }
984 /*Not supported last point for range*/
985 if (item->last) {
986 rte_flow_error_set(error, EINVAL,
987 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
988 item, "Not supported last point for range");
989 return -rte_errno;
990 }
991
992 /* Skip Ethernet */
993 if (item->type == RTE_FLOW_ITEM_TYPE_ETH) {
994 /* if the item is MAC, the content should be NULL */
995 if (item->spec || item->mask) {
996 rte_flow_error_set(error, EINVAL,
997 RTE_FLOW_ERROR_TYPE_ITEM,
998 item, "Invalid SYN address mask");
999 return -rte_errno;
1000 }
1001
1002 /* check if the next not void item is IPv4 or IPv6 */
1003 item = next_no_void_pattern(pattern, item);
1004 if (item->type != RTE_FLOW_ITEM_TYPE_IPV4 &&
1005 item->type != RTE_FLOW_ITEM_TYPE_IPV6) {
1006 rte_flow_error_set(error, EINVAL,
1007 RTE_FLOW_ERROR_TYPE_ITEM,
1008 item, "Not supported by syn filter");
1009 return -rte_errno;
1010 }
1011 }
1012
1013 /* Skip IP */
1014 if (item->type == RTE_FLOW_ITEM_TYPE_IPV4 ||
1015 item->type == RTE_FLOW_ITEM_TYPE_IPV6) {
1016 /* if the item is IP, the content should be NULL */
1017 if (item->spec || item->mask) {
1018 rte_flow_error_set(error, EINVAL,
1019 RTE_FLOW_ERROR_TYPE_ITEM,
1020 item, "Invalid SYN mask");
1021 return -rte_errno;
1022 }
1023
1024 /* check if the next not void item is TCP */
1025 item = next_no_void_pattern(pattern, item);
1026 if (item->type != RTE_FLOW_ITEM_TYPE_TCP) {
1027 rte_flow_error_set(error, EINVAL,
1028 RTE_FLOW_ERROR_TYPE_ITEM,
1029 item, "Not supported by syn filter");
1030 return -rte_errno;
1031 }
1032 }
1033
1034 /* Get the TCP info. Only support SYN. */
1035 if (!item->spec || !item->mask) {
1036 rte_flow_error_set(error, EINVAL,
1037 RTE_FLOW_ERROR_TYPE_ITEM,
1038 item, "Invalid SYN mask");
1039 return -rte_errno;
1040 }
1041 /*Not supported last point for range*/
1042 if (item->last) {
1043 rte_flow_error_set(error, EINVAL,
1044 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
1045 item, "Not supported last point for range");
1046 return -rte_errno;
1047 }
1048
1049 tcp_spec = item->spec;
1050 tcp_mask = item->mask;
1051 if (!(tcp_spec->hdr.tcp_flags & RTE_TCP_SYN_FLAG) ||
1052 tcp_mask->hdr.src_port ||
1053 tcp_mask->hdr.dst_port ||
1054 tcp_mask->hdr.sent_seq ||
1055 tcp_mask->hdr.recv_ack ||
1056 tcp_mask->hdr.data_off ||
1057 tcp_mask->hdr.tcp_flags != RTE_TCP_SYN_FLAG ||
1058 tcp_mask->hdr.rx_win ||
1059 tcp_mask->hdr.cksum ||
1060 tcp_mask->hdr.tcp_urp) {
1061 memset(filter, 0, sizeof(struct rte_eth_syn_filter));
1062 rte_flow_error_set(error, EINVAL,
1063 RTE_FLOW_ERROR_TYPE_ITEM,
1064 item, "Not supported by syn filter");
1065 return -rte_errno;
1066 }
1067
1068 /* check if the next not void item is END */
1069 item = next_no_void_pattern(pattern, item);
1070 if (item->type != RTE_FLOW_ITEM_TYPE_END) {
1071 memset(filter, 0, sizeof(struct rte_eth_syn_filter));
1072 rte_flow_error_set(error, EINVAL,
1073 RTE_FLOW_ERROR_TYPE_ITEM,
1074 item, "Not supported by syn filter");
1075 return -rte_errno;
1076 }
1077
1078 /* check if the first not void action is QUEUE. */
1079 act = next_no_void_action(actions, NULL);
1080 if (act->type != RTE_FLOW_ACTION_TYPE_QUEUE) {
1081 memset(filter, 0, sizeof(struct rte_eth_syn_filter));
1082 rte_flow_error_set(error, EINVAL,
1083 RTE_FLOW_ERROR_TYPE_ACTION,
1084 act, "Not supported action.");
1085 return -rte_errno;
1086 }
1087
1088 act_q = (const struct rte_flow_action_queue *)act->conf;
1089 filter->queue = act_q->index;
1090 if (filter->queue >= IXGBE_MAX_RX_QUEUE_NUM) {
1091 memset(filter, 0, sizeof(struct rte_eth_syn_filter));
1092 rte_flow_error_set(error, EINVAL,
1093 RTE_FLOW_ERROR_TYPE_ACTION,
1094 act, "Not supported action.");
1095 return -rte_errno;
1096 }
1097
1098 /* check if the next not void item is END */
1099 act = next_no_void_action(actions, act);
1100 if (act->type != RTE_FLOW_ACTION_TYPE_END) {
1101 memset(filter, 0, sizeof(struct rte_eth_syn_filter));
1102 rte_flow_error_set(error, EINVAL,
1103 RTE_FLOW_ERROR_TYPE_ACTION,
1104 act, "Not supported action.");
1105 return -rte_errno;
1106 }
1107
1108 /* parse attr */
1109 /* must be input direction */
1110 if (!attr->ingress) {
1111 memset(filter, 0, sizeof(struct rte_eth_syn_filter));
1112 rte_flow_error_set(error, EINVAL,
1113 RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
1114 attr, "Only support ingress.");
1115 return -rte_errno;
1116 }
1117
1118 /* not supported */
1119 if (attr->egress) {
1120 memset(filter, 0, sizeof(struct rte_eth_syn_filter));
1121 rte_flow_error_set(error, EINVAL,
1122 RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
1123 attr, "Not support egress.");
1124 return -rte_errno;
1125 }
1126
1127 /* not supported */
1128 if (attr->transfer) {
1129 memset(filter, 0, sizeof(struct rte_eth_syn_filter));
1130 rte_flow_error_set(error, EINVAL,
1131 RTE_FLOW_ERROR_TYPE_ATTR_TRANSFER,
1132 attr, "No support for transfer.");
1133 return -rte_errno;
1134 }
1135
1136 /* Support 2 priorities, the lowest or highest. */
1137 if (!attr->priority) {
1138 filter->hig_pri = 0;
1139 } else if (attr->priority == (uint32_t)~0U) {
1140 filter->hig_pri = 1;
1141 } else {
1142 memset(filter, 0, sizeof(struct rte_eth_syn_filter));
1143 rte_flow_error_set(error, EINVAL,
1144 RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
1145 attr, "Not support priority.");
1146 return -rte_errno;
1147 }
1148
1149 return 0;
1150 }
1151
1152 static int
1153 ixgbe_parse_syn_filter(struct rte_eth_dev *dev,
1154 const struct rte_flow_attr *attr,
1155 const struct rte_flow_item pattern[],
1156 const struct rte_flow_action actions[],
1157 struct rte_eth_syn_filter *filter,
1158 struct rte_flow_error *error)
1159 {
1160 int ret;
1161 struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1162
1163 MAC_TYPE_FILTER_SUP(hw->mac.type);
1164
1165 ret = cons_parse_syn_filter(attr, pattern,
1166 actions, filter, error);
1167
1168 if (filter->queue >= dev->data->nb_rx_queues)
1169 return -rte_errno;
1170
1171 if (ret)
1172 return ret;
1173
1174 return 0;
1175 }
1176
1177 /**
1178 * Parse the rule to see if it is a L2 tunnel rule.
1179 * And get the L2 tunnel filter info BTW.
1180 * Only support E-tag now.
1181 * pattern:
1182 * The first not void item can be E_TAG.
1183 * The next not void item must be END.
1184 * action:
1185 * The first not void action should be VF or PF.
1186 * The next not void action should be END.
1187 * pattern example:
1188 * ITEM Spec Mask
1189 * E_TAG grp 0x1 0x3
1190 e_cid_base 0x309 0xFFF
1191 * END
1192 * other members in mask and spec should set to 0x00.
1193 * item->last should be NULL.
1194 */
1195 static int
1196 cons_parse_l2_tn_filter(struct rte_eth_dev *dev,
1197 const struct rte_flow_attr *attr,
1198 const struct rte_flow_item pattern[],
1199 const struct rte_flow_action actions[],
1200 struct rte_eth_l2_tunnel_conf *filter,
1201 struct rte_flow_error *error)
1202 {
1203 const struct rte_flow_item *item;
1204 const struct rte_flow_item_e_tag *e_tag_spec;
1205 const struct rte_flow_item_e_tag *e_tag_mask;
1206 const struct rte_flow_action *act;
1207 const struct rte_flow_action_vf *act_vf;
1208 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev);
1209
1210 if (!pattern) {
1211 rte_flow_error_set(error, EINVAL,
1212 RTE_FLOW_ERROR_TYPE_ITEM_NUM,
1213 NULL, "NULL pattern.");
1214 return -rte_errno;
1215 }
1216
1217 if (!actions) {
1218 rte_flow_error_set(error, EINVAL,
1219 RTE_FLOW_ERROR_TYPE_ACTION_NUM,
1220 NULL, "NULL action.");
1221 return -rte_errno;
1222 }
1223
1224 if (!attr) {
1225 rte_flow_error_set(error, EINVAL,
1226 RTE_FLOW_ERROR_TYPE_ATTR,
1227 NULL, "NULL attribute.");
1228 return -rte_errno;
1229 }
1230
1231 /* The first not void item should be e-tag. */
1232 item = next_no_void_pattern(pattern, NULL);
1233 if (item->type != RTE_FLOW_ITEM_TYPE_E_TAG) {
1234 memset(filter, 0, sizeof(struct rte_eth_l2_tunnel_conf));
1235 rte_flow_error_set(error, EINVAL,
1236 RTE_FLOW_ERROR_TYPE_ITEM,
1237 item, "Not supported by L2 tunnel filter");
1238 return -rte_errno;
1239 }
1240
1241 if (!item->spec || !item->mask) {
1242 memset(filter, 0, sizeof(struct rte_eth_l2_tunnel_conf));
1243 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM,
1244 item, "Not supported by L2 tunnel filter");
1245 return -rte_errno;
1246 }
1247
1248 /*Not supported last point for range*/
1249 if (item->last) {
1250 rte_flow_error_set(error, EINVAL,
1251 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
1252 item, "Not supported last point for range");
1253 return -rte_errno;
1254 }
1255
1256 e_tag_spec = item->spec;
1257 e_tag_mask = item->mask;
1258
1259 /* Only care about GRP and E cid base. */
1260 if (e_tag_mask->epcp_edei_in_ecid_b ||
1261 e_tag_mask->in_ecid_e ||
1262 e_tag_mask->ecid_e ||
1263 e_tag_mask->rsvd_grp_ecid_b != rte_cpu_to_be_16(0x3FFF)) {
1264 memset(filter, 0, sizeof(struct rte_eth_l2_tunnel_conf));
1265 rte_flow_error_set(error, EINVAL,
1266 RTE_FLOW_ERROR_TYPE_ITEM,
1267 item, "Not supported by L2 tunnel filter");
1268 return -rte_errno;
1269 }
1270
1271 filter->l2_tunnel_type = RTE_L2_TUNNEL_TYPE_E_TAG;
1272 /**
1273 * grp and e_cid_base are bit fields and only use 14 bits.
1274 * e-tag id is taken as little endian by HW.
1275 */
1276 filter->tunnel_id = rte_be_to_cpu_16(e_tag_spec->rsvd_grp_ecid_b);
1277
1278 /* check if the next not void item is END */
1279 item = next_no_void_pattern(pattern, item);
1280 if (item->type != RTE_FLOW_ITEM_TYPE_END) {
1281 memset(filter, 0, sizeof(struct rte_eth_l2_tunnel_conf));
1282 rte_flow_error_set(error, EINVAL,
1283 RTE_FLOW_ERROR_TYPE_ITEM,
1284 item, "Not supported by L2 tunnel filter");
1285 return -rte_errno;
1286 }
1287
1288 /* parse attr */
1289 /* must be input direction */
1290 if (!attr->ingress) {
1291 memset(filter, 0, sizeof(struct rte_eth_l2_tunnel_conf));
1292 rte_flow_error_set(error, EINVAL,
1293 RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
1294 attr, "Only support ingress.");
1295 return -rte_errno;
1296 }
1297
1298 /* not supported */
1299 if (attr->egress) {
1300 memset(filter, 0, sizeof(struct rte_eth_l2_tunnel_conf));
1301 rte_flow_error_set(error, EINVAL,
1302 RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
1303 attr, "Not support egress.");
1304 return -rte_errno;
1305 }
1306
1307 /* not supported */
1308 if (attr->transfer) {
1309 memset(filter, 0, sizeof(struct rte_eth_l2_tunnel_conf));
1310 rte_flow_error_set(error, EINVAL,
1311 RTE_FLOW_ERROR_TYPE_ATTR_TRANSFER,
1312 attr, "No support for transfer.");
1313 return -rte_errno;
1314 }
1315
1316 /* not supported */
1317 if (attr->priority) {
1318 memset(filter, 0, sizeof(struct rte_eth_l2_tunnel_conf));
1319 rte_flow_error_set(error, EINVAL,
1320 RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
1321 attr, "Not support priority.");
1322 return -rte_errno;
1323 }
1324
1325 /* check if the first not void action is VF or PF. */
1326 act = next_no_void_action(actions, NULL);
1327 if (act->type != RTE_FLOW_ACTION_TYPE_VF &&
1328 act->type != RTE_FLOW_ACTION_TYPE_PF) {
1329 memset(filter, 0, sizeof(struct rte_eth_l2_tunnel_conf));
1330 rte_flow_error_set(error, EINVAL,
1331 RTE_FLOW_ERROR_TYPE_ACTION,
1332 act, "Not supported action.");
1333 return -rte_errno;
1334 }
1335
1336 if (act->type == RTE_FLOW_ACTION_TYPE_VF) {
1337 act_vf = (const struct rte_flow_action_vf *)act->conf;
1338 filter->pool = act_vf->id;
1339 } else {
1340 filter->pool = pci_dev->max_vfs;
1341 }
1342
1343 /* check if the next not void item is END */
1344 act = next_no_void_action(actions, act);
1345 if (act->type != RTE_FLOW_ACTION_TYPE_END) {
1346 memset(filter, 0, sizeof(struct rte_eth_l2_tunnel_conf));
1347 rte_flow_error_set(error, EINVAL,
1348 RTE_FLOW_ERROR_TYPE_ACTION,
1349 act, "Not supported action.");
1350 return -rte_errno;
1351 }
1352
1353 return 0;
1354 }
1355
1356 static int
1357 ixgbe_parse_l2_tn_filter(struct rte_eth_dev *dev,
1358 const struct rte_flow_attr *attr,
1359 const struct rte_flow_item pattern[],
1360 const struct rte_flow_action actions[],
1361 struct rte_eth_l2_tunnel_conf *l2_tn_filter,
1362 struct rte_flow_error *error)
1363 {
1364 int ret = 0;
1365 struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1366 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev);
1367 uint16_t vf_num;
1368
1369 ret = cons_parse_l2_tn_filter(dev, attr, pattern,
1370 actions, l2_tn_filter, error);
1371
1372 if (hw->mac.type != ixgbe_mac_X550 &&
1373 hw->mac.type != ixgbe_mac_X550EM_x &&
1374 hw->mac.type != ixgbe_mac_X550EM_a) {
1375 memset(l2_tn_filter, 0, sizeof(struct rte_eth_l2_tunnel_conf));
1376 rte_flow_error_set(error, EINVAL,
1377 RTE_FLOW_ERROR_TYPE_ITEM,
1378 NULL, "Not supported by L2 tunnel filter");
1379 return -rte_errno;
1380 }
1381
1382 vf_num = pci_dev->max_vfs;
1383
1384 if (l2_tn_filter->pool > vf_num)
1385 return -rte_errno;
1386
1387 return ret;
1388 }
1389
1390 /* Parse to get the attr and action info of flow director rule. */
1391 static int
1392 ixgbe_parse_fdir_act_attr(const struct rte_flow_attr *attr,
1393 const struct rte_flow_action actions[],
1394 struct ixgbe_fdir_rule *rule,
1395 struct rte_flow_error *error)
1396 {
1397 const struct rte_flow_action *act;
1398 const struct rte_flow_action_queue *act_q;
1399 const struct rte_flow_action_mark *mark;
1400
1401 /* parse attr */
1402 /* must be input direction */
1403 if (!attr->ingress) {
1404 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
1405 rte_flow_error_set(error, EINVAL,
1406 RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
1407 attr, "Only support ingress.");
1408 return -rte_errno;
1409 }
1410
1411 /* not supported */
1412 if (attr->egress) {
1413 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
1414 rte_flow_error_set(error, EINVAL,
1415 RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
1416 attr, "Not support egress.");
1417 return -rte_errno;
1418 }
1419
1420 /* not supported */
1421 if (attr->transfer) {
1422 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
1423 rte_flow_error_set(error, EINVAL,
1424 RTE_FLOW_ERROR_TYPE_ATTR_TRANSFER,
1425 attr, "No support for transfer.");
1426 return -rte_errno;
1427 }
1428
1429 /* not supported */
1430 if (attr->priority) {
1431 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
1432 rte_flow_error_set(error, EINVAL,
1433 RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
1434 attr, "Not support priority.");
1435 return -rte_errno;
1436 }
1437
1438 /* check if the first not void action is QUEUE or DROP. */
1439 act = next_no_void_action(actions, NULL);
1440 if (act->type != RTE_FLOW_ACTION_TYPE_QUEUE &&
1441 act->type != RTE_FLOW_ACTION_TYPE_DROP) {
1442 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
1443 rte_flow_error_set(error, EINVAL,
1444 RTE_FLOW_ERROR_TYPE_ACTION,
1445 act, "Not supported action.");
1446 return -rte_errno;
1447 }
1448
1449 if (act->type == RTE_FLOW_ACTION_TYPE_QUEUE) {
1450 act_q = (const struct rte_flow_action_queue *)act->conf;
1451 rule->queue = act_q->index;
1452 } else { /* drop */
1453 /* signature mode does not support drop action. */
1454 if (rule->mode == RTE_FDIR_MODE_SIGNATURE) {
1455 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
1456 rte_flow_error_set(error, EINVAL,
1457 RTE_FLOW_ERROR_TYPE_ACTION,
1458 act, "Not supported action.");
1459 return -rte_errno;
1460 }
1461 rule->fdirflags = IXGBE_FDIRCMD_DROP;
1462 }
1463
1464 /* check if the next not void item is MARK */
1465 act = next_no_void_action(actions, act);
1466 if ((act->type != RTE_FLOW_ACTION_TYPE_MARK) &&
1467 (act->type != RTE_FLOW_ACTION_TYPE_END)) {
1468 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
1469 rte_flow_error_set(error, EINVAL,
1470 RTE_FLOW_ERROR_TYPE_ACTION,
1471 act, "Not supported action.");
1472 return -rte_errno;
1473 }
1474
1475 rule->soft_id = 0;
1476
1477 if (act->type == RTE_FLOW_ACTION_TYPE_MARK) {
1478 mark = (const struct rte_flow_action_mark *)act->conf;
1479 rule->soft_id = mark->id;
1480 act = next_no_void_action(actions, act);
1481 }
1482
1483 /* check if the next not void item is END */
1484 if (act->type != RTE_FLOW_ACTION_TYPE_END) {
1485 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
1486 rte_flow_error_set(error, EINVAL,
1487 RTE_FLOW_ERROR_TYPE_ACTION,
1488 act, "Not supported action.");
1489 return -rte_errno;
1490 }
1491
1492 return 0;
1493 }
1494
1495 /* search next no void pattern and skip fuzzy */
1496 static inline
1497 const struct rte_flow_item *next_no_fuzzy_pattern(
1498 const struct rte_flow_item pattern[],
1499 const struct rte_flow_item *cur)
1500 {
1501 const struct rte_flow_item *next =
1502 next_no_void_pattern(pattern, cur);
1503 while (1) {
1504 if (next->type != RTE_FLOW_ITEM_TYPE_FUZZY)
1505 return next;
1506 next = next_no_void_pattern(pattern, next);
1507 }
1508 }
1509
1510 static inline uint8_t signature_match(const struct rte_flow_item pattern[])
1511 {
1512 const struct rte_flow_item_fuzzy *spec, *last, *mask;
1513 const struct rte_flow_item *item;
1514 uint32_t sh, lh, mh;
1515 int i = 0;
1516
1517 while (1) {
1518 item = pattern + i;
1519 if (item->type == RTE_FLOW_ITEM_TYPE_END)
1520 break;
1521
1522 if (item->type == RTE_FLOW_ITEM_TYPE_FUZZY) {
1523 spec = item->spec;
1524 last = item->last;
1525 mask = item->mask;
1526
1527 if (!spec || !mask)
1528 return 0;
1529
1530 sh = spec->thresh;
1531
1532 if (!last)
1533 lh = sh;
1534 else
1535 lh = last->thresh;
1536
1537 mh = mask->thresh;
1538 sh = sh & mh;
1539 lh = lh & mh;
1540
1541 if (!sh || sh > lh)
1542 return 0;
1543
1544 return 1;
1545 }
1546
1547 i++;
1548 }
1549
1550 return 0;
1551 }
1552
1553 /**
1554 * Parse the rule to see if it is a IP or MAC VLAN flow director rule.
1555 * And get the flow director filter info BTW.
1556 * UDP/TCP/SCTP PATTERN:
1557 * The first not void item can be ETH or IPV4 or IPV6
1558 * The second not void item must be IPV4 or IPV6 if the first one is ETH.
1559 * The next not void item could be UDP or TCP or SCTP (optional)
1560 * The next not void item could be RAW (for flexbyte, optional)
1561 * The next not void item must be END.
1562 * A Fuzzy Match pattern can appear at any place before END.
1563 * Fuzzy Match is optional for IPV4 but is required for IPV6
1564 * MAC VLAN PATTERN:
1565 * The first not void item must be ETH.
1566 * The second not void item must be MAC VLAN.
1567 * The next not void item must be END.
1568 * ACTION:
1569 * The first not void action should be QUEUE or DROP.
1570 * The second not void optional action should be MARK,
1571 * mark_id is a uint32_t number.
1572 * The next not void action should be END.
1573 * UDP/TCP/SCTP pattern example:
1574 * ITEM Spec Mask
1575 * ETH NULL NULL
1576 * IPV4 src_addr 192.168.1.20 0xFFFFFFFF
1577 * dst_addr 192.167.3.50 0xFFFFFFFF
1578 * UDP/TCP/SCTP src_port 80 0xFFFF
1579 * dst_port 80 0xFFFF
1580 * FLEX relative 0 0x1
1581 * search 0 0x1
1582 * reserved 0 0
1583 * offset 12 0xFFFFFFFF
1584 * limit 0 0xFFFF
1585 * length 2 0xFFFF
1586 * pattern[0] 0x86 0xFF
1587 * pattern[1] 0xDD 0xFF
1588 * END
1589 * MAC VLAN pattern example:
1590 * ITEM Spec Mask
1591 * ETH dst_addr
1592 {0xAC, 0x7B, 0xA1, {0xFF, 0xFF, 0xFF,
1593 0x2C, 0x6D, 0x36} 0xFF, 0xFF, 0xFF}
1594 * MAC VLAN tci 0x2016 0xEFFF
1595 * END
1596 * Other members in mask and spec should set to 0x00.
1597 * Item->last should be NULL.
1598 */
1599 static int
1600 ixgbe_parse_fdir_filter_normal(struct rte_eth_dev *dev,
1601 const struct rte_flow_attr *attr,
1602 const struct rte_flow_item pattern[],
1603 const struct rte_flow_action actions[],
1604 struct ixgbe_fdir_rule *rule,
1605 struct rte_flow_error *error)
1606 {
1607 const struct rte_flow_item *item;
1608 const struct rte_flow_item_eth *eth_spec;
1609 const struct rte_flow_item_eth *eth_mask;
1610 const struct rte_flow_item_ipv4 *ipv4_spec;
1611 const struct rte_flow_item_ipv4 *ipv4_mask;
1612 const struct rte_flow_item_ipv6 *ipv6_spec;
1613 const struct rte_flow_item_ipv6 *ipv6_mask;
1614 const struct rte_flow_item_tcp *tcp_spec;
1615 const struct rte_flow_item_tcp *tcp_mask;
1616 const struct rte_flow_item_udp *udp_spec;
1617 const struct rte_flow_item_udp *udp_mask;
1618 const struct rte_flow_item_sctp *sctp_spec;
1619 const struct rte_flow_item_sctp *sctp_mask;
1620 const struct rte_flow_item_vlan *vlan_spec;
1621 const struct rte_flow_item_vlan *vlan_mask;
1622 const struct rte_flow_item_raw *raw_mask;
1623 const struct rte_flow_item_raw *raw_spec;
1624 uint8_t j;
1625
1626 struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1627
1628 if (!pattern) {
1629 rte_flow_error_set(error, EINVAL,
1630 RTE_FLOW_ERROR_TYPE_ITEM_NUM,
1631 NULL, "NULL pattern.");
1632 return -rte_errno;
1633 }
1634
1635 if (!actions) {
1636 rte_flow_error_set(error, EINVAL,
1637 RTE_FLOW_ERROR_TYPE_ACTION_NUM,
1638 NULL, "NULL action.");
1639 return -rte_errno;
1640 }
1641
1642 if (!attr) {
1643 rte_flow_error_set(error, EINVAL,
1644 RTE_FLOW_ERROR_TYPE_ATTR,
1645 NULL, "NULL attribute.");
1646 return -rte_errno;
1647 }
1648
1649 /**
1650 * Some fields may not be provided. Set spec to 0 and mask to default
1651 * value. So, we need not do anything for the not provided fields later.
1652 */
1653 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
1654 memset(&rule->mask, 0xFF, sizeof(struct ixgbe_hw_fdir_mask));
1655 rule->mask.vlan_tci_mask = 0;
1656 rule->mask.flex_bytes_mask = 0;
1657
1658 /**
1659 * The first not void item should be
1660 * MAC or IPv4 or TCP or UDP or SCTP.
1661 */
1662 item = next_no_fuzzy_pattern(pattern, NULL);
1663 if (item->type != RTE_FLOW_ITEM_TYPE_ETH &&
1664 item->type != RTE_FLOW_ITEM_TYPE_IPV4 &&
1665 item->type != RTE_FLOW_ITEM_TYPE_IPV6 &&
1666 item->type != RTE_FLOW_ITEM_TYPE_TCP &&
1667 item->type != RTE_FLOW_ITEM_TYPE_UDP &&
1668 item->type != RTE_FLOW_ITEM_TYPE_SCTP) {
1669 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
1670 rte_flow_error_set(error, EINVAL,
1671 RTE_FLOW_ERROR_TYPE_ITEM,
1672 item, "Not supported by fdir filter");
1673 return -rte_errno;
1674 }
1675
1676 if (signature_match(pattern))
1677 rule->mode = RTE_FDIR_MODE_SIGNATURE;
1678 else
1679 rule->mode = RTE_FDIR_MODE_PERFECT;
1680
1681 /*Not supported last point for range*/
1682 if (item->last) {
1683 rte_flow_error_set(error, EINVAL,
1684 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
1685 item, "Not supported last point for range");
1686 return -rte_errno;
1687 }
1688
1689 /* Get the MAC info. */
1690 if (item->type == RTE_FLOW_ITEM_TYPE_ETH) {
1691 /**
1692 * Only support vlan and dst MAC address,
1693 * others should be masked.
1694 */
1695 if (item->spec && !item->mask) {
1696 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
1697 rte_flow_error_set(error, EINVAL,
1698 RTE_FLOW_ERROR_TYPE_ITEM,
1699 item, "Not supported by fdir filter");
1700 return -rte_errno;
1701 }
1702
1703 if (item->spec) {
1704 rule->b_spec = TRUE;
1705 eth_spec = item->spec;
1706
1707 /* Get the dst MAC. */
1708 for (j = 0; j < RTE_ETHER_ADDR_LEN; j++) {
1709 rule->ixgbe_fdir.formatted.inner_mac[j] =
1710 eth_spec->dst.addr_bytes[j];
1711 }
1712 }
1713
1714
1715 if (item->mask) {
1716
1717 rule->b_mask = TRUE;
1718 eth_mask = item->mask;
1719
1720 /* Ether type should be masked. */
1721 if (eth_mask->type ||
1722 rule->mode == RTE_FDIR_MODE_SIGNATURE) {
1723 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
1724 rte_flow_error_set(error, EINVAL,
1725 RTE_FLOW_ERROR_TYPE_ITEM,
1726 item, "Not supported by fdir filter");
1727 return -rte_errno;
1728 }
1729
1730 /* If ethernet has meaning, it means MAC VLAN mode. */
1731 rule->mode = RTE_FDIR_MODE_PERFECT_MAC_VLAN;
1732
1733 /**
1734 * src MAC address must be masked,
1735 * and don't support dst MAC address mask.
1736 */
1737 for (j = 0; j < RTE_ETHER_ADDR_LEN; j++) {
1738 if (eth_mask->src.addr_bytes[j] ||
1739 eth_mask->dst.addr_bytes[j] != 0xFF) {
1740 memset(rule, 0,
1741 sizeof(struct ixgbe_fdir_rule));
1742 rte_flow_error_set(error, EINVAL,
1743 RTE_FLOW_ERROR_TYPE_ITEM,
1744 item, "Not supported by fdir filter");
1745 return -rte_errno;
1746 }
1747 }
1748
1749 /* When no VLAN, considered as full mask. */
1750 rule->mask.vlan_tci_mask = rte_cpu_to_be_16(0xEFFF);
1751 }
1752 /*** If both spec and mask are item,
1753 * it means don't care about ETH.
1754 * Do nothing.
1755 */
1756
1757 /**
1758 * Check if the next not void item is vlan or ipv4.
1759 * IPv6 is not supported.
1760 */
1761 item = next_no_fuzzy_pattern(pattern, item);
1762 if (rule->mode == RTE_FDIR_MODE_PERFECT_MAC_VLAN) {
1763 if (item->type != RTE_FLOW_ITEM_TYPE_VLAN) {
1764 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
1765 rte_flow_error_set(error, EINVAL,
1766 RTE_FLOW_ERROR_TYPE_ITEM,
1767 item, "Not supported by fdir filter");
1768 return -rte_errno;
1769 }
1770 } else {
1771 if (item->type != RTE_FLOW_ITEM_TYPE_IPV4 &&
1772 item->type != RTE_FLOW_ITEM_TYPE_VLAN) {
1773 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
1774 rte_flow_error_set(error, EINVAL,
1775 RTE_FLOW_ERROR_TYPE_ITEM,
1776 item, "Not supported by fdir filter");
1777 return -rte_errno;
1778 }
1779 }
1780 }
1781
1782 if (item->type == RTE_FLOW_ITEM_TYPE_VLAN) {
1783 if (!(item->spec && item->mask)) {
1784 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
1785 rte_flow_error_set(error, EINVAL,
1786 RTE_FLOW_ERROR_TYPE_ITEM,
1787 item, "Not supported by fdir filter");
1788 return -rte_errno;
1789 }
1790
1791 /*Not supported last point for range*/
1792 if (item->last) {
1793 rte_flow_error_set(error, EINVAL,
1794 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
1795 item, "Not supported last point for range");
1796 return -rte_errno;
1797 }
1798
1799 vlan_spec = item->spec;
1800 vlan_mask = item->mask;
1801
1802 rule->ixgbe_fdir.formatted.vlan_id = vlan_spec->tci;
1803
1804 rule->mask.vlan_tci_mask = vlan_mask->tci;
1805 rule->mask.vlan_tci_mask &= rte_cpu_to_be_16(0xEFFF);
1806 /* More than one tags are not supported. */
1807
1808 /* Next not void item must be END */
1809 item = next_no_fuzzy_pattern(pattern, item);
1810 if (item->type != RTE_FLOW_ITEM_TYPE_END) {
1811 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
1812 rte_flow_error_set(error, EINVAL,
1813 RTE_FLOW_ERROR_TYPE_ITEM,
1814 item, "Not supported by fdir filter");
1815 return -rte_errno;
1816 }
1817 }
1818
1819 /* Get the IPV4 info. */
1820 if (item->type == RTE_FLOW_ITEM_TYPE_IPV4) {
1821 /**
1822 * Set the flow type even if there's no content
1823 * as we must have a flow type.
1824 */
1825 rule->ixgbe_fdir.formatted.flow_type =
1826 IXGBE_ATR_FLOW_TYPE_IPV4;
1827 /*Not supported last point for range*/
1828 if (item->last) {
1829 rte_flow_error_set(error, EINVAL,
1830 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
1831 item, "Not supported last point for range");
1832 return -rte_errno;
1833 }
1834 /**
1835 * Only care about src & dst addresses,
1836 * others should be masked.
1837 */
1838 if (!item->mask) {
1839 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
1840 rte_flow_error_set(error, EINVAL,
1841 RTE_FLOW_ERROR_TYPE_ITEM,
1842 item, "Not supported by fdir filter");
1843 return -rte_errno;
1844 }
1845 rule->b_mask = TRUE;
1846 ipv4_mask = item->mask;
1847 if (ipv4_mask->hdr.version_ihl ||
1848 ipv4_mask->hdr.type_of_service ||
1849 ipv4_mask->hdr.total_length ||
1850 ipv4_mask->hdr.packet_id ||
1851 ipv4_mask->hdr.fragment_offset ||
1852 ipv4_mask->hdr.time_to_live ||
1853 ipv4_mask->hdr.next_proto_id ||
1854 ipv4_mask->hdr.hdr_checksum) {
1855 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
1856 rte_flow_error_set(error, EINVAL,
1857 RTE_FLOW_ERROR_TYPE_ITEM,
1858 item, "Not supported by fdir filter");
1859 return -rte_errno;
1860 }
1861 rule->mask.dst_ipv4_mask = ipv4_mask->hdr.dst_addr;
1862 rule->mask.src_ipv4_mask = ipv4_mask->hdr.src_addr;
1863
1864 if (item->spec) {
1865 rule->b_spec = TRUE;
1866 ipv4_spec = item->spec;
1867 rule->ixgbe_fdir.formatted.dst_ip[0] =
1868 ipv4_spec->hdr.dst_addr;
1869 rule->ixgbe_fdir.formatted.src_ip[0] =
1870 ipv4_spec->hdr.src_addr;
1871 }
1872
1873 /**
1874 * Check if the next not void item is
1875 * TCP or UDP or SCTP or END.
1876 */
1877 item = next_no_fuzzy_pattern(pattern, item);
1878 if (item->type != RTE_FLOW_ITEM_TYPE_TCP &&
1879 item->type != RTE_FLOW_ITEM_TYPE_UDP &&
1880 item->type != RTE_FLOW_ITEM_TYPE_SCTP &&
1881 item->type != RTE_FLOW_ITEM_TYPE_END &&
1882 item->type != RTE_FLOW_ITEM_TYPE_RAW) {
1883 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
1884 rte_flow_error_set(error, EINVAL,
1885 RTE_FLOW_ERROR_TYPE_ITEM,
1886 item, "Not supported by fdir filter");
1887 return -rte_errno;
1888 }
1889 }
1890
1891 /* Get the IPV6 info. */
1892 if (item->type == RTE_FLOW_ITEM_TYPE_IPV6) {
1893 /**
1894 * Set the flow type even if there's no content
1895 * as we must have a flow type.
1896 */
1897 rule->ixgbe_fdir.formatted.flow_type =
1898 IXGBE_ATR_FLOW_TYPE_IPV6;
1899
1900 /**
1901 * 1. must signature match
1902 * 2. not support last
1903 * 3. mask must not null
1904 */
1905 if (rule->mode != RTE_FDIR_MODE_SIGNATURE ||
1906 item->last ||
1907 !item->mask) {
1908 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
1909 rte_flow_error_set(error, EINVAL,
1910 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
1911 item, "Not supported last point for range");
1912 return -rte_errno;
1913 }
1914
1915 rule->b_mask = TRUE;
1916 ipv6_mask = item->mask;
1917 if (ipv6_mask->hdr.vtc_flow ||
1918 ipv6_mask->hdr.payload_len ||
1919 ipv6_mask->hdr.proto ||
1920 ipv6_mask->hdr.hop_limits) {
1921 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
1922 rte_flow_error_set(error, EINVAL,
1923 RTE_FLOW_ERROR_TYPE_ITEM,
1924 item, "Not supported by fdir filter");
1925 return -rte_errno;
1926 }
1927
1928 /* check src addr mask */
1929 for (j = 0; j < 16; j++) {
1930 if (ipv6_mask->hdr.src_addr[j] == UINT8_MAX) {
1931 rule->mask.src_ipv6_mask |= 1 << j;
1932 } else if (ipv6_mask->hdr.src_addr[j] != 0) {
1933 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
1934 rte_flow_error_set(error, EINVAL,
1935 RTE_FLOW_ERROR_TYPE_ITEM,
1936 item, "Not supported by fdir filter");
1937 return -rte_errno;
1938 }
1939 }
1940
1941 /* check dst addr mask */
1942 for (j = 0; j < 16; j++) {
1943 if (ipv6_mask->hdr.dst_addr[j] == UINT8_MAX) {
1944 rule->mask.dst_ipv6_mask |= 1 << j;
1945 } else if (ipv6_mask->hdr.dst_addr[j] != 0) {
1946 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
1947 rte_flow_error_set(error, EINVAL,
1948 RTE_FLOW_ERROR_TYPE_ITEM,
1949 item, "Not supported by fdir filter");
1950 return -rte_errno;
1951 }
1952 }
1953
1954 if (item->spec) {
1955 rule->b_spec = TRUE;
1956 ipv6_spec = item->spec;
1957 rte_memcpy(rule->ixgbe_fdir.formatted.src_ip,
1958 ipv6_spec->hdr.src_addr, 16);
1959 rte_memcpy(rule->ixgbe_fdir.formatted.dst_ip,
1960 ipv6_spec->hdr.dst_addr, 16);
1961 }
1962
1963 /**
1964 * Check if the next not void item is
1965 * TCP or UDP or SCTP or END.
1966 */
1967 item = next_no_fuzzy_pattern(pattern, item);
1968 if (item->type != RTE_FLOW_ITEM_TYPE_TCP &&
1969 item->type != RTE_FLOW_ITEM_TYPE_UDP &&
1970 item->type != RTE_FLOW_ITEM_TYPE_SCTP &&
1971 item->type != RTE_FLOW_ITEM_TYPE_END &&
1972 item->type != RTE_FLOW_ITEM_TYPE_RAW) {
1973 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
1974 rte_flow_error_set(error, EINVAL,
1975 RTE_FLOW_ERROR_TYPE_ITEM,
1976 item, "Not supported by fdir filter");
1977 return -rte_errno;
1978 }
1979 }
1980
1981 /* Get the TCP info. */
1982 if (item->type == RTE_FLOW_ITEM_TYPE_TCP) {
1983 /**
1984 * Set the flow type even if there's no content
1985 * as we must have a flow type.
1986 */
1987 rule->ixgbe_fdir.formatted.flow_type |=
1988 IXGBE_ATR_L4TYPE_TCP;
1989 /*Not supported last point for range*/
1990 if (item->last) {
1991 rte_flow_error_set(error, EINVAL,
1992 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
1993 item, "Not supported last point for range");
1994 return -rte_errno;
1995 }
1996 /**
1997 * Only care about src & dst ports,
1998 * others should be masked.
1999 */
2000 if (!item->mask) {
2001 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2002 rte_flow_error_set(error, EINVAL,
2003 RTE_FLOW_ERROR_TYPE_ITEM,
2004 item, "Not supported by fdir filter");
2005 return -rte_errno;
2006 }
2007 rule->b_mask = TRUE;
2008 tcp_mask = item->mask;
2009 if (tcp_mask->hdr.sent_seq ||
2010 tcp_mask->hdr.recv_ack ||
2011 tcp_mask->hdr.data_off ||
2012 tcp_mask->hdr.tcp_flags ||
2013 tcp_mask->hdr.rx_win ||
2014 tcp_mask->hdr.cksum ||
2015 tcp_mask->hdr.tcp_urp) {
2016 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2017 rte_flow_error_set(error, EINVAL,
2018 RTE_FLOW_ERROR_TYPE_ITEM,
2019 item, "Not supported by fdir filter");
2020 return -rte_errno;
2021 }
2022 rule->mask.src_port_mask = tcp_mask->hdr.src_port;
2023 rule->mask.dst_port_mask = tcp_mask->hdr.dst_port;
2024
2025 if (item->spec) {
2026 rule->b_spec = TRUE;
2027 tcp_spec = item->spec;
2028 rule->ixgbe_fdir.formatted.src_port =
2029 tcp_spec->hdr.src_port;
2030 rule->ixgbe_fdir.formatted.dst_port =
2031 tcp_spec->hdr.dst_port;
2032 }
2033
2034 item = next_no_fuzzy_pattern(pattern, item);
2035 if (item->type != RTE_FLOW_ITEM_TYPE_RAW &&
2036 item->type != RTE_FLOW_ITEM_TYPE_END) {
2037 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2038 rte_flow_error_set(error, EINVAL,
2039 RTE_FLOW_ERROR_TYPE_ITEM,
2040 item, "Not supported by fdir filter");
2041 return -rte_errno;
2042 }
2043
2044 }
2045
2046 /* Get the UDP info */
2047 if (item->type == RTE_FLOW_ITEM_TYPE_UDP) {
2048 /**
2049 * Set the flow type even if there's no content
2050 * as we must have a flow type.
2051 */
2052 rule->ixgbe_fdir.formatted.flow_type |=
2053 IXGBE_ATR_L4TYPE_UDP;
2054 /*Not supported last point for range*/
2055 if (item->last) {
2056 rte_flow_error_set(error, EINVAL,
2057 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
2058 item, "Not supported last point for range");
2059 return -rte_errno;
2060 }
2061 /**
2062 * Only care about src & dst ports,
2063 * others should be masked.
2064 */
2065 if (!item->mask) {
2066 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2067 rte_flow_error_set(error, EINVAL,
2068 RTE_FLOW_ERROR_TYPE_ITEM,
2069 item, "Not supported by fdir filter");
2070 return -rte_errno;
2071 }
2072 rule->b_mask = TRUE;
2073 udp_mask = item->mask;
2074 if (udp_mask->hdr.dgram_len ||
2075 udp_mask->hdr.dgram_cksum) {
2076 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2077 rte_flow_error_set(error, EINVAL,
2078 RTE_FLOW_ERROR_TYPE_ITEM,
2079 item, "Not supported by fdir filter");
2080 return -rte_errno;
2081 }
2082 rule->mask.src_port_mask = udp_mask->hdr.src_port;
2083 rule->mask.dst_port_mask = udp_mask->hdr.dst_port;
2084
2085 if (item->spec) {
2086 rule->b_spec = TRUE;
2087 udp_spec = item->spec;
2088 rule->ixgbe_fdir.formatted.src_port =
2089 udp_spec->hdr.src_port;
2090 rule->ixgbe_fdir.formatted.dst_port =
2091 udp_spec->hdr.dst_port;
2092 }
2093
2094 item = next_no_fuzzy_pattern(pattern, item);
2095 if (item->type != RTE_FLOW_ITEM_TYPE_RAW &&
2096 item->type != RTE_FLOW_ITEM_TYPE_END) {
2097 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2098 rte_flow_error_set(error, EINVAL,
2099 RTE_FLOW_ERROR_TYPE_ITEM,
2100 item, "Not supported by fdir filter");
2101 return -rte_errno;
2102 }
2103
2104 }
2105
2106 /* Get the SCTP info */
2107 if (item->type == RTE_FLOW_ITEM_TYPE_SCTP) {
2108 /**
2109 * Set the flow type even if there's no content
2110 * as we must have a flow type.
2111 */
2112 rule->ixgbe_fdir.formatted.flow_type |=
2113 IXGBE_ATR_L4TYPE_SCTP;
2114 /*Not supported last point for range*/
2115 if (item->last) {
2116 rte_flow_error_set(error, EINVAL,
2117 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
2118 item, "Not supported last point for range");
2119 return -rte_errno;
2120 }
2121
2122 /* only x550 family only support sctp port */
2123 if (hw->mac.type == ixgbe_mac_X550 ||
2124 hw->mac.type == ixgbe_mac_X550EM_x ||
2125 hw->mac.type == ixgbe_mac_X550EM_a) {
2126 /**
2127 * Only care about src & dst ports,
2128 * others should be masked.
2129 */
2130 if (!item->mask) {
2131 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2132 rte_flow_error_set(error, EINVAL,
2133 RTE_FLOW_ERROR_TYPE_ITEM,
2134 item, "Not supported by fdir filter");
2135 return -rte_errno;
2136 }
2137 rule->b_mask = TRUE;
2138 sctp_mask = item->mask;
2139 if (sctp_mask->hdr.tag ||
2140 sctp_mask->hdr.cksum) {
2141 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2142 rte_flow_error_set(error, EINVAL,
2143 RTE_FLOW_ERROR_TYPE_ITEM,
2144 item, "Not supported by fdir filter");
2145 return -rte_errno;
2146 }
2147 rule->mask.src_port_mask = sctp_mask->hdr.src_port;
2148 rule->mask.dst_port_mask = sctp_mask->hdr.dst_port;
2149
2150 if (item->spec) {
2151 rule->b_spec = TRUE;
2152 sctp_spec = item->spec;
2153 rule->ixgbe_fdir.formatted.src_port =
2154 sctp_spec->hdr.src_port;
2155 rule->ixgbe_fdir.formatted.dst_port =
2156 sctp_spec->hdr.dst_port;
2157 }
2158 /* others even sctp port is not supported */
2159 } else {
2160 sctp_mask = item->mask;
2161 if (sctp_mask &&
2162 (sctp_mask->hdr.src_port ||
2163 sctp_mask->hdr.dst_port ||
2164 sctp_mask->hdr.tag ||
2165 sctp_mask->hdr.cksum)) {
2166 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2167 rte_flow_error_set(error, EINVAL,
2168 RTE_FLOW_ERROR_TYPE_ITEM,
2169 item, "Not supported by fdir filter");
2170 return -rte_errno;
2171 }
2172 }
2173
2174 item = next_no_fuzzy_pattern(pattern, item);
2175 if (item->type != RTE_FLOW_ITEM_TYPE_RAW &&
2176 item->type != RTE_FLOW_ITEM_TYPE_END) {
2177 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2178 rte_flow_error_set(error, EINVAL,
2179 RTE_FLOW_ERROR_TYPE_ITEM,
2180 item, "Not supported by fdir filter");
2181 return -rte_errno;
2182 }
2183 }
2184
2185 /* Get the flex byte info */
2186 if (item->type == RTE_FLOW_ITEM_TYPE_RAW) {
2187 /* Not supported last point for range*/
2188 if (item->last) {
2189 rte_flow_error_set(error, EINVAL,
2190 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
2191 item, "Not supported last point for range");
2192 return -rte_errno;
2193 }
2194 /* mask should not be null */
2195 if (!item->mask || !item->spec) {
2196 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2197 rte_flow_error_set(error, EINVAL,
2198 RTE_FLOW_ERROR_TYPE_ITEM,
2199 item, "Not supported by fdir filter");
2200 return -rte_errno;
2201 }
2202
2203 raw_mask = item->mask;
2204
2205 /* check mask */
2206 if (raw_mask->relative != 0x1 ||
2207 raw_mask->search != 0x1 ||
2208 raw_mask->reserved != 0x0 ||
2209 (uint32_t)raw_mask->offset != 0xffffffff ||
2210 raw_mask->limit != 0xffff ||
2211 raw_mask->length != 0xffff) {
2212 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2213 rte_flow_error_set(error, EINVAL,
2214 RTE_FLOW_ERROR_TYPE_ITEM,
2215 item, "Not supported by fdir filter");
2216 return -rte_errno;
2217 }
2218
2219 raw_spec = item->spec;
2220
2221 /* check spec */
2222 if (raw_spec->relative != 0 ||
2223 raw_spec->search != 0 ||
2224 raw_spec->reserved != 0 ||
2225 raw_spec->offset > IXGBE_MAX_FLX_SOURCE_OFF ||
2226 raw_spec->offset % 2 ||
2227 raw_spec->limit != 0 ||
2228 raw_spec->length != 2 ||
2229 /* pattern can't be 0xffff */
2230 (raw_spec->pattern[0] == 0xff &&
2231 raw_spec->pattern[1] == 0xff)) {
2232 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2233 rte_flow_error_set(error, EINVAL,
2234 RTE_FLOW_ERROR_TYPE_ITEM,
2235 item, "Not supported by fdir filter");
2236 return -rte_errno;
2237 }
2238
2239 /* check pattern mask */
2240 if (raw_mask->pattern[0] != 0xff ||
2241 raw_mask->pattern[1] != 0xff) {
2242 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2243 rte_flow_error_set(error, EINVAL,
2244 RTE_FLOW_ERROR_TYPE_ITEM,
2245 item, "Not supported by fdir filter");
2246 return -rte_errno;
2247 }
2248
2249 rule->mask.flex_bytes_mask = 0xffff;
2250 rule->ixgbe_fdir.formatted.flex_bytes =
2251 (((uint16_t)raw_spec->pattern[1]) << 8) |
2252 raw_spec->pattern[0];
2253 rule->flex_bytes_offset = raw_spec->offset;
2254 }
2255
2256 if (item->type != RTE_FLOW_ITEM_TYPE_END) {
2257 /* check if the next not void item is END */
2258 item = next_no_fuzzy_pattern(pattern, item);
2259 if (item->type != RTE_FLOW_ITEM_TYPE_END) {
2260 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2261 rte_flow_error_set(error, EINVAL,
2262 RTE_FLOW_ERROR_TYPE_ITEM,
2263 item, "Not supported by fdir filter");
2264 return -rte_errno;
2265 }
2266 }
2267
2268 return ixgbe_parse_fdir_act_attr(attr, actions, rule, error);
2269 }
2270
2271 #define NVGRE_PROTOCOL 0x6558
2272
2273 /**
2274 * Parse the rule to see if it is a VxLAN or NVGRE flow director rule.
2275 * And get the flow director filter info BTW.
2276 * VxLAN PATTERN:
2277 * The first not void item must be ETH.
2278 * The second not void item must be IPV4/ IPV6.
2279 * The third not void item must be NVGRE.
2280 * The next not void item must be END.
2281 * NVGRE PATTERN:
2282 * The first not void item must be ETH.
2283 * The second not void item must be IPV4/ IPV6.
2284 * The third not void item must be NVGRE.
2285 * The next not void item must be END.
2286 * ACTION:
2287 * The first not void action should be QUEUE or DROP.
2288 * The second not void optional action should be MARK,
2289 * mark_id is a uint32_t number.
2290 * The next not void action should be END.
2291 * VxLAN pattern example:
2292 * ITEM Spec Mask
2293 * ETH NULL NULL
2294 * IPV4/IPV6 NULL NULL
2295 * UDP NULL NULL
2296 * VxLAN vni{0x00, 0x32, 0x54} {0xFF, 0xFF, 0xFF}
2297 * MAC VLAN tci 0x2016 0xEFFF
2298 * END
2299 * NEGRV pattern example:
2300 * ITEM Spec Mask
2301 * ETH NULL NULL
2302 * IPV4/IPV6 NULL NULL
2303 * NVGRE protocol 0x6558 0xFFFF
2304 * tni{0x00, 0x32, 0x54} {0xFF, 0xFF, 0xFF}
2305 * MAC VLAN tci 0x2016 0xEFFF
2306 * END
2307 * other members in mask and spec should set to 0x00.
2308 * item->last should be NULL.
2309 */
2310 static int
2311 ixgbe_parse_fdir_filter_tunnel(const struct rte_flow_attr *attr,
2312 const struct rte_flow_item pattern[],
2313 const struct rte_flow_action actions[],
2314 struct ixgbe_fdir_rule *rule,
2315 struct rte_flow_error *error)
2316 {
2317 const struct rte_flow_item *item;
2318 const struct rte_flow_item_vxlan *vxlan_spec;
2319 const struct rte_flow_item_vxlan *vxlan_mask;
2320 const struct rte_flow_item_nvgre *nvgre_spec;
2321 const struct rte_flow_item_nvgre *nvgre_mask;
2322 const struct rte_flow_item_eth *eth_spec;
2323 const struct rte_flow_item_eth *eth_mask;
2324 const struct rte_flow_item_vlan *vlan_spec;
2325 const struct rte_flow_item_vlan *vlan_mask;
2326 uint32_t j;
2327
2328 if (!pattern) {
2329 rte_flow_error_set(error, EINVAL,
2330 RTE_FLOW_ERROR_TYPE_ITEM_NUM,
2331 NULL, "NULL pattern.");
2332 return -rte_errno;
2333 }
2334
2335 if (!actions) {
2336 rte_flow_error_set(error, EINVAL,
2337 RTE_FLOW_ERROR_TYPE_ACTION_NUM,
2338 NULL, "NULL action.");
2339 return -rte_errno;
2340 }
2341
2342 if (!attr) {
2343 rte_flow_error_set(error, EINVAL,
2344 RTE_FLOW_ERROR_TYPE_ATTR,
2345 NULL, "NULL attribute.");
2346 return -rte_errno;
2347 }
2348
2349 /**
2350 * Some fields may not be provided. Set spec to 0 and mask to default
2351 * value. So, we need not do anything for the not provided fields later.
2352 */
2353 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2354 memset(&rule->mask, 0xFF, sizeof(struct ixgbe_hw_fdir_mask));
2355 rule->mask.vlan_tci_mask = 0;
2356
2357 /**
2358 * The first not void item should be
2359 * MAC or IPv4 or IPv6 or UDP or VxLAN.
2360 */
2361 item = next_no_void_pattern(pattern, NULL);
2362 if (item->type != RTE_FLOW_ITEM_TYPE_ETH &&
2363 item->type != RTE_FLOW_ITEM_TYPE_IPV4 &&
2364 item->type != RTE_FLOW_ITEM_TYPE_IPV6 &&
2365 item->type != RTE_FLOW_ITEM_TYPE_UDP &&
2366 item->type != RTE_FLOW_ITEM_TYPE_VXLAN &&
2367 item->type != RTE_FLOW_ITEM_TYPE_NVGRE) {
2368 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2369 rte_flow_error_set(error, EINVAL,
2370 RTE_FLOW_ERROR_TYPE_ITEM,
2371 item, "Not supported by fdir filter");
2372 return -rte_errno;
2373 }
2374
2375 rule->mode = RTE_FDIR_MODE_PERFECT_TUNNEL;
2376
2377 /* Skip MAC. */
2378 if (item->type == RTE_FLOW_ITEM_TYPE_ETH) {
2379 /* Only used to describe the protocol stack. */
2380 if (item->spec || item->mask) {
2381 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2382 rte_flow_error_set(error, EINVAL,
2383 RTE_FLOW_ERROR_TYPE_ITEM,
2384 item, "Not supported by fdir filter");
2385 return -rte_errno;
2386 }
2387 /* Not supported last point for range*/
2388 if (item->last) {
2389 rte_flow_error_set(error, EINVAL,
2390 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
2391 item, "Not supported last point for range");
2392 return -rte_errno;
2393 }
2394
2395 /* Check if the next not void item is IPv4 or IPv6. */
2396 item = next_no_void_pattern(pattern, item);
2397 if (item->type != RTE_FLOW_ITEM_TYPE_IPV4 &&
2398 item->type != RTE_FLOW_ITEM_TYPE_IPV6) {
2399 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2400 rte_flow_error_set(error, EINVAL,
2401 RTE_FLOW_ERROR_TYPE_ITEM,
2402 item, "Not supported by fdir filter");
2403 return -rte_errno;
2404 }
2405 }
2406
2407 /* Skip IP. */
2408 if (item->type == RTE_FLOW_ITEM_TYPE_IPV4 ||
2409 item->type == RTE_FLOW_ITEM_TYPE_IPV6) {
2410 /* Only used to describe the protocol stack. */
2411 if (item->spec || item->mask) {
2412 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2413 rte_flow_error_set(error, EINVAL,
2414 RTE_FLOW_ERROR_TYPE_ITEM,
2415 item, "Not supported by fdir filter");
2416 return -rte_errno;
2417 }
2418 /*Not supported last point for range*/
2419 if (item->last) {
2420 rte_flow_error_set(error, EINVAL,
2421 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
2422 item, "Not supported last point for range");
2423 return -rte_errno;
2424 }
2425
2426 /* Check if the next not void item is UDP or NVGRE. */
2427 item = next_no_void_pattern(pattern, item);
2428 if (item->type != RTE_FLOW_ITEM_TYPE_UDP &&
2429 item->type != RTE_FLOW_ITEM_TYPE_NVGRE) {
2430 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2431 rte_flow_error_set(error, EINVAL,
2432 RTE_FLOW_ERROR_TYPE_ITEM,
2433 item, "Not supported by fdir filter");
2434 return -rte_errno;
2435 }
2436 }
2437
2438 /* Skip UDP. */
2439 if (item->type == RTE_FLOW_ITEM_TYPE_UDP) {
2440 /* Only used to describe the protocol stack. */
2441 if (item->spec || item->mask) {
2442 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2443 rte_flow_error_set(error, EINVAL,
2444 RTE_FLOW_ERROR_TYPE_ITEM,
2445 item, "Not supported by fdir filter");
2446 return -rte_errno;
2447 }
2448 /*Not supported last point for range*/
2449 if (item->last) {
2450 rte_flow_error_set(error, EINVAL,
2451 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
2452 item, "Not supported last point for range");
2453 return -rte_errno;
2454 }
2455
2456 /* Check if the next not void item is VxLAN. */
2457 item = next_no_void_pattern(pattern, item);
2458 if (item->type != RTE_FLOW_ITEM_TYPE_VXLAN) {
2459 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2460 rte_flow_error_set(error, EINVAL,
2461 RTE_FLOW_ERROR_TYPE_ITEM,
2462 item, "Not supported by fdir filter");
2463 return -rte_errno;
2464 }
2465 }
2466
2467 /* Get the VxLAN info */
2468 if (item->type == RTE_FLOW_ITEM_TYPE_VXLAN) {
2469 rule->ixgbe_fdir.formatted.tunnel_type =
2470 IXGBE_FDIR_VXLAN_TUNNEL_TYPE;
2471
2472 /* Only care about VNI, others should be masked. */
2473 if (!item->mask) {
2474 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2475 rte_flow_error_set(error, EINVAL,
2476 RTE_FLOW_ERROR_TYPE_ITEM,
2477 item, "Not supported by fdir filter");
2478 return -rte_errno;
2479 }
2480 /*Not supported last point for range*/
2481 if (item->last) {
2482 rte_flow_error_set(error, EINVAL,
2483 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
2484 item, "Not supported last point for range");
2485 return -rte_errno;
2486 }
2487 rule->b_mask = TRUE;
2488
2489 /* Tunnel type is always meaningful. */
2490 rule->mask.tunnel_type_mask = 1;
2491
2492 vxlan_mask = item->mask;
2493 if (vxlan_mask->flags) {
2494 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2495 rte_flow_error_set(error, EINVAL,
2496 RTE_FLOW_ERROR_TYPE_ITEM,
2497 item, "Not supported by fdir filter");
2498 return -rte_errno;
2499 }
2500 /* VNI must be totally masked or not. */
2501 if ((vxlan_mask->vni[0] || vxlan_mask->vni[1] ||
2502 vxlan_mask->vni[2]) &&
2503 ((vxlan_mask->vni[0] != 0xFF) ||
2504 (vxlan_mask->vni[1] != 0xFF) ||
2505 (vxlan_mask->vni[2] != 0xFF))) {
2506 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2507 rte_flow_error_set(error, EINVAL,
2508 RTE_FLOW_ERROR_TYPE_ITEM,
2509 item, "Not supported by fdir filter");
2510 return -rte_errno;
2511 }
2512
2513 rte_memcpy(&rule->mask.tunnel_id_mask, vxlan_mask->vni,
2514 RTE_DIM(vxlan_mask->vni));
2515
2516 if (item->spec) {
2517 rule->b_spec = TRUE;
2518 vxlan_spec = item->spec;
2519 rte_memcpy(((uint8_t *)
2520 &rule->ixgbe_fdir.formatted.tni_vni),
2521 vxlan_spec->vni, RTE_DIM(vxlan_spec->vni));
2522 }
2523 }
2524
2525 /* Get the NVGRE info */
2526 if (item->type == RTE_FLOW_ITEM_TYPE_NVGRE) {
2527 rule->ixgbe_fdir.formatted.tunnel_type =
2528 IXGBE_FDIR_NVGRE_TUNNEL_TYPE;
2529
2530 /**
2531 * Only care about flags0, flags1, protocol and TNI,
2532 * others should be masked.
2533 */
2534 if (!item->mask) {
2535 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2536 rte_flow_error_set(error, EINVAL,
2537 RTE_FLOW_ERROR_TYPE_ITEM,
2538 item, "Not supported by fdir filter");
2539 return -rte_errno;
2540 }
2541 /*Not supported last point for range*/
2542 if (item->last) {
2543 rte_flow_error_set(error, EINVAL,
2544 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
2545 item, "Not supported last point for range");
2546 return -rte_errno;
2547 }
2548 rule->b_mask = TRUE;
2549
2550 /* Tunnel type is always meaningful. */
2551 rule->mask.tunnel_type_mask = 1;
2552
2553 nvgre_mask = item->mask;
2554 if (nvgre_mask->flow_id) {
2555 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2556 rte_flow_error_set(error, EINVAL,
2557 RTE_FLOW_ERROR_TYPE_ITEM,
2558 item, "Not supported by fdir filter");
2559 return -rte_errno;
2560 }
2561 if (nvgre_mask->protocol &&
2562 nvgre_mask->protocol != 0xFFFF) {
2563 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2564 rte_flow_error_set(error, EINVAL,
2565 RTE_FLOW_ERROR_TYPE_ITEM,
2566 item, "Not supported by fdir filter");
2567 return -rte_errno;
2568 }
2569 if (nvgre_mask->c_k_s_rsvd0_ver &&
2570 nvgre_mask->c_k_s_rsvd0_ver !=
2571 rte_cpu_to_be_16(0xFFFF)) {
2572 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2573 rte_flow_error_set(error, EINVAL,
2574 RTE_FLOW_ERROR_TYPE_ITEM,
2575 item, "Not supported by fdir filter");
2576 return -rte_errno;
2577 }
2578 /* TNI must be totally masked or not. */
2579 if (nvgre_mask->tni[0] &&
2580 ((nvgre_mask->tni[0] != 0xFF) ||
2581 (nvgre_mask->tni[1] != 0xFF) ||
2582 (nvgre_mask->tni[2] != 0xFF))) {
2583 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2584 rte_flow_error_set(error, EINVAL,
2585 RTE_FLOW_ERROR_TYPE_ITEM,
2586 item, "Not supported by fdir filter");
2587 return -rte_errno;
2588 }
2589 /* tni is a 24-bits bit field */
2590 rte_memcpy(&rule->mask.tunnel_id_mask, nvgre_mask->tni,
2591 RTE_DIM(nvgre_mask->tni));
2592 rule->mask.tunnel_id_mask <<= 8;
2593
2594 if (item->spec) {
2595 rule->b_spec = TRUE;
2596 nvgre_spec = item->spec;
2597 if (nvgre_spec->c_k_s_rsvd0_ver !=
2598 rte_cpu_to_be_16(0x2000) &&
2599 nvgre_mask->c_k_s_rsvd0_ver) {
2600 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2601 rte_flow_error_set(error, EINVAL,
2602 RTE_FLOW_ERROR_TYPE_ITEM,
2603 item, "Not supported by fdir filter");
2604 return -rte_errno;
2605 }
2606 if (nvgre_mask->protocol &&
2607 nvgre_spec->protocol !=
2608 rte_cpu_to_be_16(NVGRE_PROTOCOL)) {
2609 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2610 rte_flow_error_set(error, EINVAL,
2611 RTE_FLOW_ERROR_TYPE_ITEM,
2612 item, "Not supported by fdir filter");
2613 return -rte_errno;
2614 }
2615 /* tni is a 24-bits bit field */
2616 rte_memcpy(&rule->ixgbe_fdir.formatted.tni_vni,
2617 nvgre_spec->tni, RTE_DIM(nvgre_spec->tni));
2618 }
2619 }
2620
2621 /* check if the next not void item is MAC */
2622 item = next_no_void_pattern(pattern, item);
2623 if (item->type != RTE_FLOW_ITEM_TYPE_ETH) {
2624 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2625 rte_flow_error_set(error, EINVAL,
2626 RTE_FLOW_ERROR_TYPE_ITEM,
2627 item, "Not supported by fdir filter");
2628 return -rte_errno;
2629 }
2630
2631 /**
2632 * Only support vlan and dst MAC address,
2633 * others should be masked.
2634 */
2635
2636 if (!item->mask) {
2637 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2638 rte_flow_error_set(error, EINVAL,
2639 RTE_FLOW_ERROR_TYPE_ITEM,
2640 item, "Not supported by fdir filter");
2641 return -rte_errno;
2642 }
2643 /*Not supported last point for range*/
2644 if (item->last) {
2645 rte_flow_error_set(error, EINVAL,
2646 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
2647 item, "Not supported last point for range");
2648 return -rte_errno;
2649 }
2650 rule->b_mask = TRUE;
2651 eth_mask = item->mask;
2652
2653 /* Ether type should be masked. */
2654 if (eth_mask->type) {
2655 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2656 rte_flow_error_set(error, EINVAL,
2657 RTE_FLOW_ERROR_TYPE_ITEM,
2658 item, "Not supported by fdir filter");
2659 return -rte_errno;
2660 }
2661
2662 /* src MAC address should be masked. */
2663 for (j = 0; j < RTE_ETHER_ADDR_LEN; j++) {
2664 if (eth_mask->src.addr_bytes[j]) {
2665 memset(rule, 0,
2666 sizeof(struct ixgbe_fdir_rule));
2667 rte_flow_error_set(error, EINVAL,
2668 RTE_FLOW_ERROR_TYPE_ITEM,
2669 item, "Not supported by fdir filter");
2670 return -rte_errno;
2671 }
2672 }
2673 rule->mask.mac_addr_byte_mask = 0;
2674 for (j = 0; j < RTE_ETHER_ADDR_LEN; j++) {
2675 /* It's a per byte mask. */
2676 if (eth_mask->dst.addr_bytes[j] == 0xFF) {
2677 rule->mask.mac_addr_byte_mask |= 0x1 << j;
2678 } else if (eth_mask->dst.addr_bytes[j]) {
2679 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2680 rte_flow_error_set(error, EINVAL,
2681 RTE_FLOW_ERROR_TYPE_ITEM,
2682 item, "Not supported by fdir filter");
2683 return -rte_errno;
2684 }
2685 }
2686
2687 /* When no vlan, considered as full mask. */
2688 rule->mask.vlan_tci_mask = rte_cpu_to_be_16(0xEFFF);
2689
2690 if (item->spec) {
2691 rule->b_spec = TRUE;
2692 eth_spec = item->spec;
2693
2694 /* Get the dst MAC. */
2695 for (j = 0; j < RTE_ETHER_ADDR_LEN; j++) {
2696 rule->ixgbe_fdir.formatted.inner_mac[j] =
2697 eth_spec->dst.addr_bytes[j];
2698 }
2699 }
2700
2701 /**
2702 * Check if the next not void item is vlan or ipv4.
2703 * IPv6 is not supported.
2704 */
2705 item = next_no_void_pattern(pattern, item);
2706 if ((item->type != RTE_FLOW_ITEM_TYPE_VLAN) &&
2707 (item->type != RTE_FLOW_ITEM_TYPE_IPV4)) {
2708 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2709 rte_flow_error_set(error, EINVAL,
2710 RTE_FLOW_ERROR_TYPE_ITEM,
2711 item, "Not supported by fdir filter");
2712 return -rte_errno;
2713 }
2714 /*Not supported last point for range*/
2715 if (item->last) {
2716 rte_flow_error_set(error, EINVAL,
2717 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
2718 item, "Not supported last point for range");
2719 return -rte_errno;
2720 }
2721
2722 if (item->type == RTE_FLOW_ITEM_TYPE_VLAN) {
2723 if (!(item->spec && item->mask)) {
2724 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2725 rte_flow_error_set(error, EINVAL,
2726 RTE_FLOW_ERROR_TYPE_ITEM,
2727 item, "Not supported by fdir filter");
2728 return -rte_errno;
2729 }
2730
2731 vlan_spec = item->spec;
2732 vlan_mask = item->mask;
2733
2734 rule->ixgbe_fdir.formatted.vlan_id = vlan_spec->tci;
2735
2736 rule->mask.vlan_tci_mask = vlan_mask->tci;
2737 rule->mask.vlan_tci_mask &= rte_cpu_to_be_16(0xEFFF);
2738 /* More than one tags are not supported. */
2739
2740 /* check if the next not void item is END */
2741 item = next_no_void_pattern(pattern, item);
2742
2743 if (item->type != RTE_FLOW_ITEM_TYPE_END) {
2744 memset(rule, 0, sizeof(struct ixgbe_fdir_rule));
2745 rte_flow_error_set(error, EINVAL,
2746 RTE_FLOW_ERROR_TYPE_ITEM,
2747 item, "Not supported by fdir filter");
2748 return -rte_errno;
2749 }
2750 }
2751
2752 /**
2753 * If the tags is 0, it means don't care about the VLAN.
2754 * Do nothing.
2755 */
2756
2757 return ixgbe_parse_fdir_act_attr(attr, actions, rule, error);
2758 }
2759
2760 static int
2761 ixgbe_parse_fdir_filter(struct rte_eth_dev *dev,
2762 const struct rte_flow_attr *attr,
2763 const struct rte_flow_item pattern[],
2764 const struct rte_flow_action actions[],
2765 struct ixgbe_fdir_rule *rule,
2766 struct rte_flow_error *error)
2767 {
2768 int ret;
2769 struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
2770 enum rte_fdir_mode fdir_mode = dev->data->dev_conf.fdir_conf.mode;
2771
2772 if (hw->mac.type != ixgbe_mac_82599EB &&
2773 hw->mac.type != ixgbe_mac_X540 &&
2774 hw->mac.type != ixgbe_mac_X550 &&
2775 hw->mac.type != ixgbe_mac_X550EM_x &&
2776 hw->mac.type != ixgbe_mac_X550EM_a)
2777 return -ENOTSUP;
2778
2779 ret = ixgbe_parse_fdir_filter_normal(dev, attr, pattern,
2780 actions, rule, error);
2781
2782 if (!ret)
2783 goto step_next;
2784
2785 ret = ixgbe_parse_fdir_filter_tunnel(attr, pattern,
2786 actions, rule, error);
2787
2788 if (ret)
2789 return ret;
2790
2791 step_next:
2792
2793 if (hw->mac.type == ixgbe_mac_82599EB &&
2794 rule->fdirflags == IXGBE_FDIRCMD_DROP &&
2795 (rule->ixgbe_fdir.formatted.src_port != 0 ||
2796 rule->ixgbe_fdir.formatted.dst_port != 0))
2797 return -ENOTSUP;
2798
2799 if (fdir_mode == RTE_FDIR_MODE_NONE ||
2800 fdir_mode != rule->mode)
2801 return -ENOTSUP;
2802
2803 if (rule->queue >= dev->data->nb_rx_queues)
2804 return -ENOTSUP;
2805
2806 return ret;
2807 }
2808
2809 static int
2810 ixgbe_parse_rss_filter(struct rte_eth_dev *dev,
2811 const struct rte_flow_attr *attr,
2812 const struct rte_flow_action actions[],
2813 struct ixgbe_rte_flow_rss_conf *rss_conf,
2814 struct rte_flow_error *error)
2815 {
2816 const struct rte_flow_action *act;
2817 const struct rte_flow_action_rss *rss;
2818 uint16_t n;
2819
2820 /**
2821 * rss only supports forwarding,
2822 * check if the first not void action is RSS.
2823 */
2824 act = next_no_void_action(actions, NULL);
2825 if (act->type != RTE_FLOW_ACTION_TYPE_RSS) {
2826 memset(rss_conf, 0, sizeof(struct ixgbe_rte_flow_rss_conf));
2827 rte_flow_error_set(error, EINVAL,
2828 RTE_FLOW_ERROR_TYPE_ACTION,
2829 act, "Not supported action.");
2830 return -rte_errno;
2831 }
2832
2833 rss = (const struct rte_flow_action_rss *)act->conf;
2834
2835 if (!rss || !rss->queue_num) {
2836 rte_flow_error_set(error, EINVAL,
2837 RTE_FLOW_ERROR_TYPE_ACTION,
2838 act,
2839 "no valid queues");
2840 return -rte_errno;
2841 }
2842
2843 for (n = 0; n < rss->queue_num; n++) {
2844 if (rss->queue[n] >= dev->data->nb_rx_queues) {
2845 rte_flow_error_set(error, EINVAL,
2846 RTE_FLOW_ERROR_TYPE_ACTION,
2847 act,
2848 "queue id > max number of queues");
2849 return -rte_errno;
2850 }
2851 }
2852
2853 if (rss->func != RTE_ETH_HASH_FUNCTION_DEFAULT)
2854 return rte_flow_error_set
2855 (error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ACTION, act,
2856 "non-default RSS hash functions are not supported");
2857 if (rss->level)
2858 return rte_flow_error_set
2859 (error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ACTION, act,
2860 "a nonzero RSS encapsulation level is not supported");
2861 if (rss->key_len && rss->key_len != RTE_DIM(rss_conf->key))
2862 return rte_flow_error_set
2863 (error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ACTION, act,
2864 "RSS hash key must be exactly 40 bytes");
2865 if (rss->queue_num > RTE_DIM(rss_conf->queue))
2866 return rte_flow_error_set
2867 (error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ACTION, act,
2868 "too many queues for RSS context");
2869 if (ixgbe_rss_conf_init(rss_conf, rss))
2870 return rte_flow_error_set
2871 (error, EINVAL, RTE_FLOW_ERROR_TYPE_ACTION, act,
2872 "RSS context initialization failure");
2873
2874 /* check if the next not void item is END */
2875 act = next_no_void_action(actions, act);
2876 if (act->type != RTE_FLOW_ACTION_TYPE_END) {
2877 memset(rss_conf, 0, sizeof(struct ixgbe_rte_flow_rss_conf));
2878 rte_flow_error_set(error, EINVAL,
2879 RTE_FLOW_ERROR_TYPE_ACTION,
2880 act, "Not supported action.");
2881 return -rte_errno;
2882 }
2883
2884 /* parse attr */
2885 /* must be input direction */
2886 if (!attr->ingress) {
2887 memset(rss_conf, 0, sizeof(struct ixgbe_rte_flow_rss_conf));
2888 rte_flow_error_set(error, EINVAL,
2889 RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
2890 attr, "Only support ingress.");
2891 return -rte_errno;
2892 }
2893
2894 /* not supported */
2895 if (attr->egress) {
2896 memset(rss_conf, 0, sizeof(struct ixgbe_rte_flow_rss_conf));
2897 rte_flow_error_set(error, EINVAL,
2898 RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
2899 attr, "Not support egress.");
2900 return -rte_errno;
2901 }
2902
2903 /* not supported */
2904 if (attr->transfer) {
2905 memset(rss_conf, 0, sizeof(struct ixgbe_rte_flow_rss_conf));
2906 rte_flow_error_set(error, EINVAL,
2907 RTE_FLOW_ERROR_TYPE_ATTR_TRANSFER,
2908 attr, "No support for transfer.");
2909 return -rte_errno;
2910 }
2911
2912 if (attr->priority > 0xFFFF) {
2913 memset(rss_conf, 0, sizeof(struct ixgbe_rte_flow_rss_conf));
2914 rte_flow_error_set(error, EINVAL,
2915 RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
2916 attr, "Error priority.");
2917 return -rte_errno;
2918 }
2919
2920 return 0;
2921 }
2922
2923 /* remove the rss filter */
2924 static void
2925 ixgbe_clear_rss_filter(struct rte_eth_dev *dev)
2926 {
2927 struct ixgbe_filter_info *filter_info =
2928 IXGBE_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
2929
2930 if (filter_info->rss_info.conf.queue_num)
2931 ixgbe_config_rss_filter(dev, &filter_info->rss_info, FALSE);
2932 }
2933
2934 void
2935 ixgbe_filterlist_init(void)
2936 {
2937 TAILQ_INIT(&filter_ntuple_list);
2938 TAILQ_INIT(&filter_ethertype_list);
2939 TAILQ_INIT(&filter_syn_list);
2940 TAILQ_INIT(&filter_fdir_list);
2941 TAILQ_INIT(&filter_l2_tunnel_list);
2942 TAILQ_INIT(&filter_rss_list);
2943 TAILQ_INIT(&ixgbe_flow_list);
2944 }
2945
2946 void
2947 ixgbe_filterlist_flush(void)
2948 {
2949 struct ixgbe_ntuple_filter_ele *ntuple_filter_ptr;
2950 struct ixgbe_ethertype_filter_ele *ethertype_filter_ptr;
2951 struct ixgbe_eth_syn_filter_ele *syn_filter_ptr;
2952 struct ixgbe_eth_l2_tunnel_conf_ele *l2_tn_filter_ptr;
2953 struct ixgbe_fdir_rule_ele *fdir_rule_ptr;
2954 struct ixgbe_flow_mem *ixgbe_flow_mem_ptr;
2955 struct ixgbe_rss_conf_ele *rss_filter_ptr;
2956
2957 while ((ntuple_filter_ptr = TAILQ_FIRST(&filter_ntuple_list))) {
2958 TAILQ_REMOVE(&filter_ntuple_list,
2959 ntuple_filter_ptr,
2960 entries);
2961 rte_free(ntuple_filter_ptr);
2962 }
2963
2964 while ((ethertype_filter_ptr = TAILQ_FIRST(&filter_ethertype_list))) {
2965 TAILQ_REMOVE(&filter_ethertype_list,
2966 ethertype_filter_ptr,
2967 entries);
2968 rte_free(ethertype_filter_ptr);
2969 }
2970
2971 while ((syn_filter_ptr = TAILQ_FIRST(&filter_syn_list))) {
2972 TAILQ_REMOVE(&filter_syn_list,
2973 syn_filter_ptr,
2974 entries);
2975 rte_free(syn_filter_ptr);
2976 }
2977
2978 while ((l2_tn_filter_ptr = TAILQ_FIRST(&filter_l2_tunnel_list))) {
2979 TAILQ_REMOVE(&filter_l2_tunnel_list,
2980 l2_tn_filter_ptr,
2981 entries);
2982 rte_free(l2_tn_filter_ptr);
2983 }
2984
2985 while ((fdir_rule_ptr = TAILQ_FIRST(&filter_fdir_list))) {
2986 TAILQ_REMOVE(&filter_fdir_list,
2987 fdir_rule_ptr,
2988 entries);
2989 rte_free(fdir_rule_ptr);
2990 }
2991
2992 while ((rss_filter_ptr = TAILQ_FIRST(&filter_rss_list))) {
2993 TAILQ_REMOVE(&filter_rss_list,
2994 rss_filter_ptr,
2995 entries);
2996 rte_free(rss_filter_ptr);
2997 }
2998
2999 while ((ixgbe_flow_mem_ptr = TAILQ_FIRST(&ixgbe_flow_list))) {
3000 TAILQ_REMOVE(&ixgbe_flow_list,
3001 ixgbe_flow_mem_ptr,
3002 entries);
3003 rte_free(ixgbe_flow_mem_ptr->flow);
3004 rte_free(ixgbe_flow_mem_ptr);
3005 }
3006 }
3007
3008 /**
3009 * Create or destroy a flow rule.
3010 * Theorically one rule can match more than one filters.
3011 * We will let it use the filter which it hitt first.
3012 * So, the sequence matters.
3013 */
3014 static struct rte_flow *
3015 ixgbe_flow_create(struct rte_eth_dev *dev,
3016 const struct rte_flow_attr *attr,
3017 const struct rte_flow_item pattern[],
3018 const struct rte_flow_action actions[],
3019 struct rte_flow_error *error)
3020 {
3021 int ret;
3022 struct rte_eth_ntuple_filter ntuple_filter;
3023 struct rte_eth_ethertype_filter ethertype_filter;
3024 struct rte_eth_syn_filter syn_filter;
3025 struct ixgbe_fdir_rule fdir_rule;
3026 struct rte_eth_l2_tunnel_conf l2_tn_filter;
3027 struct ixgbe_hw_fdir_info *fdir_info =
3028 IXGBE_DEV_PRIVATE_TO_FDIR_INFO(dev->data->dev_private);
3029 struct ixgbe_rte_flow_rss_conf rss_conf;
3030 struct rte_flow *flow = NULL;
3031 struct ixgbe_ntuple_filter_ele *ntuple_filter_ptr;
3032 struct ixgbe_ethertype_filter_ele *ethertype_filter_ptr;
3033 struct ixgbe_eth_syn_filter_ele *syn_filter_ptr;
3034 struct ixgbe_eth_l2_tunnel_conf_ele *l2_tn_filter_ptr;
3035 struct ixgbe_fdir_rule_ele *fdir_rule_ptr;
3036 struct ixgbe_rss_conf_ele *rss_filter_ptr;
3037 struct ixgbe_flow_mem *ixgbe_flow_mem_ptr;
3038 uint8_t first_mask = FALSE;
3039
3040 flow = rte_zmalloc("ixgbe_rte_flow", sizeof(struct rte_flow), 0);
3041 if (!flow) {
3042 PMD_DRV_LOG(ERR, "failed to allocate memory");
3043 return (struct rte_flow *)flow;
3044 }
3045 ixgbe_flow_mem_ptr = rte_zmalloc("ixgbe_flow_mem",
3046 sizeof(struct ixgbe_flow_mem), 0);
3047 if (!ixgbe_flow_mem_ptr) {
3048 PMD_DRV_LOG(ERR, "failed to allocate memory");
3049 rte_free(flow);
3050 return NULL;
3051 }
3052 ixgbe_flow_mem_ptr->flow = flow;
3053 TAILQ_INSERT_TAIL(&ixgbe_flow_list,
3054 ixgbe_flow_mem_ptr, entries);
3055
3056 memset(&ntuple_filter, 0, sizeof(struct rte_eth_ntuple_filter));
3057 ret = ixgbe_parse_ntuple_filter(dev, attr, pattern,
3058 actions, &ntuple_filter, error);
3059
3060 #ifdef RTE_LIBRTE_SECURITY
3061 /* ESP flow not really a flow*/
3062 if (ntuple_filter.proto == IPPROTO_ESP)
3063 return flow;
3064 #endif
3065
3066 if (!ret) {
3067 ret = ixgbe_add_del_ntuple_filter(dev, &ntuple_filter, TRUE);
3068 if (!ret) {
3069 ntuple_filter_ptr = rte_zmalloc("ixgbe_ntuple_filter",
3070 sizeof(struct ixgbe_ntuple_filter_ele), 0);
3071 if (!ntuple_filter_ptr) {
3072 PMD_DRV_LOG(ERR, "failed to allocate memory");
3073 goto out;
3074 }
3075 rte_memcpy(&ntuple_filter_ptr->filter_info,
3076 &ntuple_filter,
3077 sizeof(struct rte_eth_ntuple_filter));
3078 TAILQ_INSERT_TAIL(&filter_ntuple_list,
3079 ntuple_filter_ptr, entries);
3080 flow->rule = ntuple_filter_ptr;
3081 flow->filter_type = RTE_ETH_FILTER_NTUPLE;
3082 return flow;
3083 }
3084 goto out;
3085 }
3086
3087 memset(&ethertype_filter, 0, sizeof(struct rte_eth_ethertype_filter));
3088 ret = ixgbe_parse_ethertype_filter(dev, attr, pattern,
3089 actions, &ethertype_filter, error);
3090 if (!ret) {
3091 ret = ixgbe_add_del_ethertype_filter(dev,
3092 &ethertype_filter, TRUE);
3093 if (!ret) {
3094 ethertype_filter_ptr = rte_zmalloc(
3095 "ixgbe_ethertype_filter",
3096 sizeof(struct ixgbe_ethertype_filter_ele), 0);
3097 if (!ethertype_filter_ptr) {
3098 PMD_DRV_LOG(ERR, "failed to allocate memory");
3099 goto out;
3100 }
3101 rte_memcpy(&ethertype_filter_ptr->filter_info,
3102 &ethertype_filter,
3103 sizeof(struct rte_eth_ethertype_filter));
3104 TAILQ_INSERT_TAIL(&filter_ethertype_list,
3105 ethertype_filter_ptr, entries);
3106 flow->rule = ethertype_filter_ptr;
3107 flow->filter_type = RTE_ETH_FILTER_ETHERTYPE;
3108 return flow;
3109 }
3110 goto out;
3111 }
3112
3113 memset(&syn_filter, 0, sizeof(struct rte_eth_syn_filter));
3114 ret = ixgbe_parse_syn_filter(dev, attr, pattern,
3115 actions, &syn_filter, error);
3116 if (!ret) {
3117 ret = ixgbe_syn_filter_set(dev, &syn_filter, TRUE);
3118 if (!ret) {
3119 syn_filter_ptr = rte_zmalloc("ixgbe_syn_filter",
3120 sizeof(struct ixgbe_eth_syn_filter_ele), 0);
3121 if (!syn_filter_ptr) {
3122 PMD_DRV_LOG(ERR, "failed to allocate memory");
3123 goto out;
3124 }
3125 rte_memcpy(&syn_filter_ptr->filter_info,
3126 &syn_filter,
3127 sizeof(struct rte_eth_syn_filter));
3128 TAILQ_INSERT_TAIL(&filter_syn_list,
3129 syn_filter_ptr,
3130 entries);
3131 flow->rule = syn_filter_ptr;
3132 flow->filter_type = RTE_ETH_FILTER_SYN;
3133 return flow;
3134 }
3135 goto out;
3136 }
3137
3138 memset(&fdir_rule, 0, sizeof(struct ixgbe_fdir_rule));
3139 ret = ixgbe_parse_fdir_filter(dev, attr, pattern,
3140 actions, &fdir_rule, error);
3141 if (!ret) {
3142 /* A mask cannot be deleted. */
3143 if (fdir_rule.b_mask) {
3144 if (!fdir_info->mask_added) {
3145 /* It's the first time the mask is set. */
3146 rte_memcpy(&fdir_info->mask,
3147 &fdir_rule.mask,
3148 sizeof(struct ixgbe_hw_fdir_mask));
3149 fdir_info->flex_bytes_offset =
3150 fdir_rule.flex_bytes_offset;
3151
3152 if (fdir_rule.mask.flex_bytes_mask)
3153 ixgbe_fdir_set_flexbytes_offset(dev,
3154 fdir_rule.flex_bytes_offset);
3155
3156 ret = ixgbe_fdir_set_input_mask(dev);
3157 if (ret)
3158 goto out;
3159
3160 fdir_info->mask_added = TRUE;
3161 first_mask = TRUE;
3162 } else {
3163 /**
3164 * Only support one global mask,
3165 * all the masks should be the same.
3166 */
3167 ret = memcmp(&fdir_info->mask,
3168 &fdir_rule.mask,
3169 sizeof(struct ixgbe_hw_fdir_mask));
3170 if (ret)
3171 goto out;
3172
3173 if (fdir_info->flex_bytes_offset !=
3174 fdir_rule.flex_bytes_offset)
3175 goto out;
3176 }
3177 }
3178
3179 if (fdir_rule.b_spec) {
3180 ret = ixgbe_fdir_filter_program(dev, &fdir_rule,
3181 FALSE, FALSE);
3182 if (!ret) {
3183 fdir_rule_ptr = rte_zmalloc("ixgbe_fdir_filter",
3184 sizeof(struct ixgbe_fdir_rule_ele), 0);
3185 if (!fdir_rule_ptr) {
3186 PMD_DRV_LOG(ERR, "failed to allocate memory");
3187 goto out;
3188 }
3189 rte_memcpy(&fdir_rule_ptr->filter_info,
3190 &fdir_rule,
3191 sizeof(struct ixgbe_fdir_rule));
3192 TAILQ_INSERT_TAIL(&filter_fdir_list,
3193 fdir_rule_ptr, entries);
3194 flow->rule = fdir_rule_ptr;
3195 flow->filter_type = RTE_ETH_FILTER_FDIR;
3196
3197 return flow;
3198 }
3199
3200 if (ret) {
3201 /**
3202 * clean the mask_added flag if fail to
3203 * program
3204 **/
3205 if (first_mask)
3206 fdir_info->mask_added = FALSE;
3207 goto out;
3208 }
3209 }
3210
3211 goto out;
3212 }
3213
3214 memset(&l2_tn_filter, 0, sizeof(struct rte_eth_l2_tunnel_conf));
3215 ret = ixgbe_parse_l2_tn_filter(dev, attr, pattern,
3216 actions, &l2_tn_filter, error);
3217 if (!ret) {
3218 ret = ixgbe_dev_l2_tunnel_filter_add(dev, &l2_tn_filter, FALSE);
3219 if (!ret) {
3220 l2_tn_filter_ptr = rte_zmalloc("ixgbe_l2_tn_filter",
3221 sizeof(struct ixgbe_eth_l2_tunnel_conf_ele), 0);
3222 if (!l2_tn_filter_ptr) {
3223 PMD_DRV_LOG(ERR, "failed to allocate memory");
3224 goto out;
3225 }
3226 rte_memcpy(&l2_tn_filter_ptr->filter_info,
3227 &l2_tn_filter,
3228 sizeof(struct rte_eth_l2_tunnel_conf));
3229 TAILQ_INSERT_TAIL(&filter_l2_tunnel_list,
3230 l2_tn_filter_ptr, entries);
3231 flow->rule = l2_tn_filter_ptr;
3232 flow->filter_type = RTE_ETH_FILTER_L2_TUNNEL;
3233 return flow;
3234 }
3235 }
3236
3237 memset(&rss_conf, 0, sizeof(struct ixgbe_rte_flow_rss_conf));
3238 ret = ixgbe_parse_rss_filter(dev, attr,
3239 actions, &rss_conf, error);
3240 if (!ret) {
3241 ret = ixgbe_config_rss_filter(dev, &rss_conf, TRUE);
3242 if (!ret) {
3243 rss_filter_ptr = rte_zmalloc("ixgbe_rss_filter",
3244 sizeof(struct ixgbe_rss_conf_ele), 0);
3245 if (!rss_filter_ptr) {
3246 PMD_DRV_LOG(ERR, "failed to allocate memory");
3247 goto out;
3248 }
3249 ixgbe_rss_conf_init(&rss_filter_ptr->filter_info,
3250 &rss_conf.conf);
3251 TAILQ_INSERT_TAIL(&filter_rss_list,
3252 rss_filter_ptr, entries);
3253 flow->rule = rss_filter_ptr;
3254 flow->filter_type = RTE_ETH_FILTER_HASH;
3255 return flow;
3256 }
3257 }
3258
3259 out:
3260 TAILQ_REMOVE(&ixgbe_flow_list,
3261 ixgbe_flow_mem_ptr, entries);
3262 rte_flow_error_set(error, -ret,
3263 RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
3264 "Failed to create flow.");
3265 rte_free(ixgbe_flow_mem_ptr);
3266 rte_free(flow);
3267 return NULL;
3268 }
3269
3270 /**
3271 * Check if the flow rule is supported by ixgbe.
3272 * It only checkes the format. Don't guarantee the rule can be programmed into
3273 * the HW. Because there can be no enough room for the rule.
3274 */
3275 static int
3276 ixgbe_flow_validate(struct rte_eth_dev *dev,
3277 const struct rte_flow_attr *attr,
3278 const struct rte_flow_item pattern[],
3279 const struct rte_flow_action actions[],
3280 struct rte_flow_error *error)
3281 {
3282 struct rte_eth_ntuple_filter ntuple_filter;
3283 struct rte_eth_ethertype_filter ethertype_filter;
3284 struct rte_eth_syn_filter syn_filter;
3285 struct rte_eth_l2_tunnel_conf l2_tn_filter;
3286 struct ixgbe_fdir_rule fdir_rule;
3287 struct ixgbe_rte_flow_rss_conf rss_conf;
3288 int ret;
3289
3290 memset(&ntuple_filter, 0, sizeof(struct rte_eth_ntuple_filter));
3291 ret = ixgbe_parse_ntuple_filter(dev, attr, pattern,
3292 actions, &ntuple_filter, error);
3293 if (!ret)
3294 return 0;
3295
3296 memset(&ethertype_filter, 0, sizeof(struct rte_eth_ethertype_filter));
3297 ret = ixgbe_parse_ethertype_filter(dev, attr, pattern,
3298 actions, &ethertype_filter, error);
3299 if (!ret)
3300 return 0;
3301
3302 memset(&syn_filter, 0, sizeof(struct rte_eth_syn_filter));
3303 ret = ixgbe_parse_syn_filter(dev, attr, pattern,
3304 actions, &syn_filter, error);
3305 if (!ret)
3306 return 0;
3307
3308 memset(&fdir_rule, 0, sizeof(struct ixgbe_fdir_rule));
3309 ret = ixgbe_parse_fdir_filter(dev, attr, pattern,
3310 actions, &fdir_rule, error);
3311 if (!ret)
3312 return 0;
3313
3314 memset(&l2_tn_filter, 0, sizeof(struct rte_eth_l2_tunnel_conf));
3315 ret = ixgbe_parse_l2_tn_filter(dev, attr, pattern,
3316 actions, &l2_tn_filter, error);
3317 if (!ret)
3318 return 0;
3319
3320 memset(&rss_conf, 0, sizeof(struct ixgbe_rte_flow_rss_conf));
3321 ret = ixgbe_parse_rss_filter(dev, attr,
3322 actions, &rss_conf, error);
3323
3324 return ret;
3325 }
3326
3327 /* Destroy a flow rule on ixgbe. */
3328 static int
3329 ixgbe_flow_destroy(struct rte_eth_dev *dev,
3330 struct rte_flow *flow,
3331 struct rte_flow_error *error)
3332 {
3333 int ret;
3334 struct rte_flow *pmd_flow = flow;
3335 enum rte_filter_type filter_type = pmd_flow->filter_type;
3336 struct rte_eth_ntuple_filter ntuple_filter;
3337 struct rte_eth_ethertype_filter ethertype_filter;
3338 struct rte_eth_syn_filter syn_filter;
3339 struct ixgbe_fdir_rule fdir_rule;
3340 struct rte_eth_l2_tunnel_conf l2_tn_filter;
3341 struct ixgbe_ntuple_filter_ele *ntuple_filter_ptr;
3342 struct ixgbe_ethertype_filter_ele *ethertype_filter_ptr;
3343 struct ixgbe_eth_syn_filter_ele *syn_filter_ptr;
3344 struct ixgbe_eth_l2_tunnel_conf_ele *l2_tn_filter_ptr;
3345 struct ixgbe_fdir_rule_ele *fdir_rule_ptr;
3346 struct ixgbe_flow_mem *ixgbe_flow_mem_ptr;
3347 struct ixgbe_hw_fdir_info *fdir_info =
3348 IXGBE_DEV_PRIVATE_TO_FDIR_INFO(dev->data->dev_private);
3349 struct ixgbe_rss_conf_ele *rss_filter_ptr;
3350
3351 switch (filter_type) {
3352 case RTE_ETH_FILTER_NTUPLE:
3353 ntuple_filter_ptr = (struct ixgbe_ntuple_filter_ele *)
3354 pmd_flow->rule;
3355 rte_memcpy(&ntuple_filter,
3356 &ntuple_filter_ptr->filter_info,
3357 sizeof(struct rte_eth_ntuple_filter));
3358 ret = ixgbe_add_del_ntuple_filter(dev, &ntuple_filter, FALSE);
3359 if (!ret) {
3360 TAILQ_REMOVE(&filter_ntuple_list,
3361 ntuple_filter_ptr, entries);
3362 rte_free(ntuple_filter_ptr);
3363 }
3364 break;
3365 case RTE_ETH_FILTER_ETHERTYPE:
3366 ethertype_filter_ptr = (struct ixgbe_ethertype_filter_ele *)
3367 pmd_flow->rule;
3368 rte_memcpy(&ethertype_filter,
3369 &ethertype_filter_ptr->filter_info,
3370 sizeof(struct rte_eth_ethertype_filter));
3371 ret = ixgbe_add_del_ethertype_filter(dev,
3372 &ethertype_filter, FALSE);
3373 if (!ret) {
3374 TAILQ_REMOVE(&filter_ethertype_list,
3375 ethertype_filter_ptr, entries);
3376 rte_free(ethertype_filter_ptr);
3377 }
3378 break;
3379 case RTE_ETH_FILTER_SYN:
3380 syn_filter_ptr = (struct ixgbe_eth_syn_filter_ele *)
3381 pmd_flow->rule;
3382 rte_memcpy(&syn_filter,
3383 &syn_filter_ptr->filter_info,
3384 sizeof(struct rte_eth_syn_filter));
3385 ret = ixgbe_syn_filter_set(dev, &syn_filter, FALSE);
3386 if (!ret) {
3387 TAILQ_REMOVE(&filter_syn_list,
3388 syn_filter_ptr, entries);
3389 rte_free(syn_filter_ptr);
3390 }
3391 break;
3392 case RTE_ETH_FILTER_FDIR:
3393 fdir_rule_ptr = (struct ixgbe_fdir_rule_ele *)pmd_flow->rule;
3394 rte_memcpy(&fdir_rule,
3395 &fdir_rule_ptr->filter_info,
3396 sizeof(struct ixgbe_fdir_rule));
3397 ret = ixgbe_fdir_filter_program(dev, &fdir_rule, TRUE, FALSE);
3398 if (!ret) {
3399 TAILQ_REMOVE(&filter_fdir_list,
3400 fdir_rule_ptr, entries);
3401 rte_free(fdir_rule_ptr);
3402 if (TAILQ_EMPTY(&filter_fdir_list))
3403 fdir_info->mask_added = false;
3404 }
3405 break;
3406 case RTE_ETH_FILTER_L2_TUNNEL:
3407 l2_tn_filter_ptr = (struct ixgbe_eth_l2_tunnel_conf_ele *)
3408 pmd_flow->rule;
3409 rte_memcpy(&l2_tn_filter, &l2_tn_filter_ptr->filter_info,
3410 sizeof(struct rte_eth_l2_tunnel_conf));
3411 ret = ixgbe_dev_l2_tunnel_filter_del(dev, &l2_tn_filter);
3412 if (!ret) {
3413 TAILQ_REMOVE(&filter_l2_tunnel_list,
3414 l2_tn_filter_ptr, entries);
3415 rte_free(l2_tn_filter_ptr);
3416 }
3417 break;
3418 case RTE_ETH_FILTER_HASH:
3419 rss_filter_ptr = (struct ixgbe_rss_conf_ele *)
3420 pmd_flow->rule;
3421 ret = ixgbe_config_rss_filter(dev,
3422 &rss_filter_ptr->filter_info, FALSE);
3423 if (!ret) {
3424 TAILQ_REMOVE(&filter_rss_list,
3425 rss_filter_ptr, entries);
3426 rte_free(rss_filter_ptr);
3427 }
3428 break;
3429 default:
3430 PMD_DRV_LOG(WARNING, "Filter type (%d) not supported",
3431 filter_type);
3432 ret = -EINVAL;
3433 break;
3434 }
3435
3436 if (ret) {
3437 rte_flow_error_set(error, EINVAL,
3438 RTE_FLOW_ERROR_TYPE_HANDLE,
3439 NULL, "Failed to destroy flow");
3440 return ret;
3441 }
3442
3443 TAILQ_FOREACH(ixgbe_flow_mem_ptr, &ixgbe_flow_list, entries) {
3444 if (ixgbe_flow_mem_ptr->flow == pmd_flow) {
3445 TAILQ_REMOVE(&ixgbe_flow_list,
3446 ixgbe_flow_mem_ptr, entries);
3447 rte_free(ixgbe_flow_mem_ptr);
3448 }
3449 }
3450 rte_free(flow);
3451
3452 return ret;
3453 }
3454
3455 /* Destroy all flow rules associated with a port on ixgbe. */
3456 static int
3457 ixgbe_flow_flush(struct rte_eth_dev *dev,
3458 struct rte_flow_error *error)
3459 {
3460 int ret = 0;
3461
3462 ixgbe_clear_all_ntuple_filter(dev);
3463 ixgbe_clear_all_ethertype_filter(dev);
3464 ixgbe_clear_syn_filter(dev);
3465
3466 ret = ixgbe_clear_all_fdir_filter(dev);
3467 if (ret < 0) {
3468 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_HANDLE,
3469 NULL, "Failed to flush rule");
3470 return ret;
3471 }
3472
3473 ret = ixgbe_clear_all_l2_tn_filter(dev);
3474 if (ret < 0) {
3475 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_HANDLE,
3476 NULL, "Failed to flush rule");
3477 return ret;
3478 }
3479
3480 ixgbe_clear_rss_filter(dev);
3481
3482 ixgbe_filterlist_flush();
3483
3484 return 0;
3485 }
3486
3487 const struct rte_flow_ops ixgbe_flow_ops = {
3488 .validate = ixgbe_flow_validate,
3489 .create = ixgbe_flow_create,
3490 .destroy = ixgbe_flow_destroy,
3491 .flush = ixgbe_flow_flush,
3492 };
Ceph