xref: /dpdk/drivers/net/ice/ice_generic_flow.c (revision 7f12dfdc) 
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2019 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 
13 #include <rte_ether.h>
14 #include <rte_ethdev_driver.h>
15 #include <rte_malloc.h>
16 #include <rte_tailq.h>
17 
18 #include "ice_ethdev.h"
19 #include "ice_generic_flow.h"
20 #include "ice_switch_filter.h"
21 
22 static int ice_flow_validate(struct rte_eth_dev *dev,
23 		const struct rte_flow_attr *attr,
24 		const struct rte_flow_item pattern[],
25 		const struct rte_flow_action actions[],
26 		struct rte_flow_error *error);
27 static struct rte_flow *ice_flow_create(struct rte_eth_dev *dev,
28 		const struct rte_flow_attr *attr,
29 		const struct rte_flow_item pattern[],
30 		const struct rte_flow_action actions[],
31 		struct rte_flow_error *error);
32 static int ice_flow_destroy(struct rte_eth_dev *dev,
33 		struct rte_flow *flow,
34 		struct rte_flow_error *error);
35 static int ice_flow_flush(struct rte_eth_dev *dev,
36 		struct rte_flow_error *error);
37 
38 const struct rte_flow_ops ice_flow_ops = {
39 	.validate = ice_flow_validate,
40 	.create = ice_flow_create,
41 	.destroy = ice_flow_destroy,
42 	.flush = ice_flow_flush,
43 };
44 
45 static int
46 ice_flow_valid_attr(const struct rte_flow_attr *attr,
47 		     struct rte_flow_error *error)
48 {
49 	/* Must be input direction */
50 	if (!attr->ingress) {
51 		rte_flow_error_set(error, EINVAL,
52 				   RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
53 				   attr, "Only support ingress.");
54 		return -rte_errno;
55 	}
56 
57 	/* Not supported */
58 	if (attr->egress) {
59 		rte_flow_error_set(error, EINVAL,
60 				   RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
61 				   attr, "Not support egress.");
62 		return -rte_errno;
63 	}
64 
65 	/* Not supported */
66 	if (attr->priority) {
67 		rte_flow_error_set(error, EINVAL,
68 				   RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
69 				   attr, "Not support priority.");
70 		return -rte_errno;
71 	}
72 
73 	/* Not supported */
74 	if (attr->group) {
75 		rte_flow_error_set(error, EINVAL,
76 				   RTE_FLOW_ERROR_TYPE_ATTR_GROUP,
77 				   attr, "Not support group.");
78 		return -rte_errno;
79 	}
80 
81 	return 0;
82 }
83 
84 /* Find the first VOID or non-VOID item pointer */
85 static const struct rte_flow_item *
86 ice_find_first_item(const struct rte_flow_item *item, bool is_void)
87 {
88 	bool is_find;
89 
90 	while (item->type != RTE_FLOW_ITEM_TYPE_END) {
91 		if (is_void)
92 			is_find = item->type == RTE_FLOW_ITEM_TYPE_VOID;
93 		else
94 			is_find = item->type != RTE_FLOW_ITEM_TYPE_VOID;
95 		if (is_find)
96 			break;
97 		item++;
98 	}
99 	return item;
100 }
101 
102 /* Skip all VOID items of the pattern */
103 static void
104 ice_pattern_skip_void_item(struct rte_flow_item *items,
105 			    const struct rte_flow_item *pattern)
106 {
107 	uint32_t cpy_count = 0;
108 	const struct rte_flow_item *pb = pattern, *pe = pattern;
109 
110 	for (;;) {
111 		/* Find a non-void item first */
112 		pb = ice_find_first_item(pb, false);
113 		if (pb->type == RTE_FLOW_ITEM_TYPE_END) {
114 			pe = pb;
115 			break;
116 		}
117 
118 		/* Find a void item */
119 		pe = ice_find_first_item(pb + 1, true);
120 
121 		cpy_count = pe - pb;
122 		rte_memcpy(items, pb, sizeof(struct rte_flow_item) * cpy_count);
123 
124 		items += cpy_count;
125 
126 		if (pe->type == RTE_FLOW_ITEM_TYPE_END) {
127 			pb = pe;
128 			break;
129 		}
130 
131 		pb = pe + 1;
132 	}
133 	/* Copy the END item. */
134 	rte_memcpy(items, pe, sizeof(struct rte_flow_item));
135 }
136 
137 /* Check if the pattern matches a supported item type array */
138 static bool
139 ice_match_pattern(enum rte_flow_item_type *item_array,
140 		const struct rte_flow_item *pattern)
141 {
142 	const struct rte_flow_item *item = pattern;
143 
144 	while ((*item_array == item->type) &&
145 	       (*item_array != RTE_FLOW_ITEM_TYPE_END)) {
146 		item_array++;
147 		item++;
148 	}
149 
150 	return (*item_array == RTE_FLOW_ITEM_TYPE_END &&
151 		item->type == RTE_FLOW_ITEM_TYPE_END);
152 }
153 
154 static uint64_t ice_flow_valid_pattern(const struct rte_flow_item pattern[],
155 		struct rte_flow_error *error)
156 {
157 	uint16_t i = 0;
158 	uint64_t inset;
159 	struct rte_flow_item *items; /* used for pattern without VOID items */
160 	uint32_t item_num = 0; /* non-void item number */
161 
162 	/* Get the non-void item number of pattern */
163 	while ((pattern + i)->type != RTE_FLOW_ITEM_TYPE_END) {
164 		if ((pattern + i)->type != RTE_FLOW_ITEM_TYPE_VOID)
165 			item_num++;
166 		i++;
167 	}
168 	item_num++;
169 
170 	items = rte_zmalloc("ice_pattern",
171 			    item_num * sizeof(struct rte_flow_item), 0);
172 	if (!items) {
173 		rte_flow_error_set(error, ENOMEM, RTE_FLOW_ERROR_TYPE_ITEM_NUM,
174 				   NULL, "No memory for PMD internal items.");
175 		return -ENOMEM;
176 	}
177 
178 	ice_pattern_skip_void_item(items, pattern);
179 
180 	for (i = 0; i < RTE_DIM(ice_supported_patterns); i++)
181 		if (ice_match_pattern(ice_supported_patterns[i].items,
182 				      items)) {
183 			inset = ice_supported_patterns[i].sw_fields;
184 			rte_free(items);
185 			return inset;
186 		}
187 	rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM,
188 			   pattern, "Unsupported pattern");
189 
190 	rte_free(items);
191 	return 0;
192 }
193 
194 static uint64_t ice_get_flow_field(const struct rte_flow_item pattern[],
195 			struct rte_flow_error *error)
196 {
197 	const struct rte_flow_item *item = pattern;
198 	const struct rte_flow_item_eth *eth_spec, *eth_mask;
199 	const struct rte_flow_item_ipv4 *ipv4_spec, *ipv4_mask;
200 	const struct rte_flow_item_ipv6 *ipv6_spec, *ipv6_mask;
201 	const struct rte_flow_item_tcp *tcp_spec, *tcp_mask;
202 	const struct rte_flow_item_udp *udp_spec, *udp_mask;
203 	const struct rte_flow_item_sctp *sctp_spec, *sctp_mask;
204 	const struct rte_flow_item_icmp *icmp_mask;
205 	const struct rte_flow_item_icmp6 *icmp6_mask;
206 	const struct rte_flow_item_vxlan *vxlan_spec, *vxlan_mask;
207 	const struct rte_flow_item_nvgre *nvgre_spec, *nvgre_mask;
208 	enum rte_flow_item_type item_type;
209 	uint8_t  ipv6_addr_mask[16] = {
210 		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
211 		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
212 	uint64_t input_set = ICE_INSET_NONE;
213 	bool is_tunnel = false;
214 
215 	for (; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
216 		if (item->last) {
217 			rte_flow_error_set(error, EINVAL,
218 					   RTE_FLOW_ERROR_TYPE_ITEM,
219 					   item,
220 					   "Not support range");
221 			return 0;
222 		}
223 		item_type = item->type;
224 		switch (item_type) {
225 		case RTE_FLOW_ITEM_TYPE_ETH:
226 			eth_spec = item->spec;
227 			eth_mask = item->mask;
228 
229 			if (eth_spec && eth_mask) {
230 				if (rte_is_broadcast_ether_addr(&eth_mask->src))
231 					input_set |= ICE_INSET_SMAC;
232 				if (rte_is_broadcast_ether_addr(&eth_mask->dst))
233 					input_set |= ICE_INSET_DMAC;
234 				if (eth_mask->type == RTE_BE16(0xffff))
235 					input_set |= ICE_INSET_ETHERTYPE;
236 			}
237 			break;
238 		case RTE_FLOW_ITEM_TYPE_IPV4:
239 			ipv4_spec = item->spec;
240 			ipv4_mask = item->mask;
241 
242 			if (!(ipv4_spec && ipv4_mask))
243 				break;
244 
245 			/* Check IPv4 mask and update input set */
246 			if (ipv4_mask->hdr.version_ihl ||
247 			    ipv4_mask->hdr.total_length ||
248 			    ipv4_mask->hdr.packet_id ||
249 			    ipv4_mask->hdr.hdr_checksum) {
250 				rte_flow_error_set(error, EINVAL,
251 					   RTE_FLOW_ERROR_TYPE_ITEM,
252 					   item,
253 					   "Invalid IPv4 mask.");
254 				return 0;
255 			}
256 
257 			if (is_tunnel) {
258 				if (ipv4_mask->hdr.src_addr == UINT32_MAX)
259 					input_set |= ICE_INSET_TUN_IPV4_SRC;
260 				if (ipv4_mask->hdr.dst_addr == UINT32_MAX)
261 					input_set |= ICE_INSET_TUN_IPV4_DST;
262 				if (ipv4_mask->hdr.time_to_live == UINT8_MAX)
263 					input_set |= ICE_INSET_TUN_IPV4_TTL;
264 				if (ipv4_mask->hdr.next_proto_id == UINT8_MAX)
265 					input_set |= ICE_INSET_TUN_IPV4_PROTO;
266 			} else {
267 				if (ipv4_mask->hdr.src_addr == UINT32_MAX)
268 					input_set |= ICE_INSET_IPV4_SRC;
269 				if (ipv4_mask->hdr.dst_addr == UINT32_MAX)
270 					input_set |= ICE_INSET_IPV4_DST;
271 				if (ipv4_mask->hdr.time_to_live == UINT8_MAX)
272 					input_set |= ICE_INSET_IPV4_TTL;
273 				if (ipv4_mask->hdr.next_proto_id == UINT8_MAX)
274 					input_set |= ICE_INSET_IPV4_PROTO;
275 				if (ipv4_mask->hdr.type_of_service == UINT8_MAX)
276 					input_set |= ICE_INSET_IPV4_TOS;
277 			}
278 			break;
279 		case RTE_FLOW_ITEM_TYPE_IPV6:
280 			ipv6_spec = item->spec;
281 			ipv6_mask = item->mask;
282 
283 			if (!(ipv6_spec && ipv6_mask))
284 				break;
285 
286 			if (ipv6_mask->hdr.payload_len) {
287 				rte_flow_error_set(error, EINVAL,
288 					   RTE_FLOW_ERROR_TYPE_ITEM,
289 					   item,
290 					   "Invalid IPv6 mask");
291 				return 0;
292 			}
293 
294 			if (is_tunnel) {
295 				if (!memcmp(ipv6_mask->hdr.src_addr,
296 					    ipv6_addr_mask,
297 					    RTE_DIM(ipv6_mask->hdr.src_addr)))
298 					input_set |= ICE_INSET_TUN_IPV6_SRC;
299 				if (!memcmp(ipv6_mask->hdr.dst_addr,
300 					    ipv6_addr_mask,
301 					    RTE_DIM(ipv6_mask->hdr.dst_addr)))
302 					input_set |= ICE_INSET_TUN_IPV6_DST;
303 				if (ipv6_mask->hdr.proto == UINT8_MAX)
304 					input_set |= ICE_INSET_TUN_IPV6_PROTO;
305 				if (ipv6_mask->hdr.hop_limits == UINT8_MAX)
306 					input_set |= ICE_INSET_TUN_IPV6_TTL;
307 			} else {
308 				if (!memcmp(ipv6_mask->hdr.src_addr,
309 					    ipv6_addr_mask,
310 					    RTE_DIM(ipv6_mask->hdr.src_addr)))
311 					input_set |= ICE_INSET_IPV6_SRC;
312 				if (!memcmp(ipv6_mask->hdr.dst_addr,
313 					    ipv6_addr_mask,
314 					    RTE_DIM(ipv6_mask->hdr.dst_addr)))
315 					input_set |= ICE_INSET_IPV6_DST;
316 				if (ipv6_mask->hdr.proto == UINT8_MAX)
317 					input_set |= ICE_INSET_IPV6_PROTO;
318 				if (ipv6_mask->hdr.hop_limits == UINT8_MAX)
319 					input_set |= ICE_INSET_IPV6_HOP_LIMIT;
320 				if ((ipv6_mask->hdr.vtc_flow &
321 					rte_cpu_to_be_32(RTE_IPV6_HDR_TC_MASK))
322 						== rte_cpu_to_be_32
323 						(RTE_IPV6_HDR_TC_MASK))
324 					input_set |= ICE_INSET_IPV6_TOS;
325 			}
326 
327 			break;
328 		case RTE_FLOW_ITEM_TYPE_UDP:
329 			udp_spec = item->spec;
330 			udp_mask = item->mask;
331 
332 			if (!(udp_spec && udp_mask))
333 				break;
334 
335 			/* Check UDP mask and update input set*/
336 			if (udp_mask->hdr.dgram_len ||
337 			    udp_mask->hdr.dgram_cksum) {
338 				rte_flow_error_set(error, EINVAL,
339 						   RTE_FLOW_ERROR_TYPE_ITEM,
340 						   item,
341 						   "Invalid UDP mask");
342 				return 0;
343 			}
344 
345 			if (is_tunnel) {
346 				if (udp_mask->hdr.src_port == UINT16_MAX)
347 					input_set |= ICE_INSET_TUN_SRC_PORT;
348 				if (udp_mask->hdr.dst_port == UINT16_MAX)
349 					input_set |= ICE_INSET_TUN_DST_PORT;
350 			} else {
351 				if (udp_mask->hdr.src_port == UINT16_MAX)
352 					input_set |= ICE_INSET_SRC_PORT;
353 				if (udp_mask->hdr.dst_port == UINT16_MAX)
354 					input_set |= ICE_INSET_DST_PORT;
355 			}
356 
357 			break;
358 		case RTE_FLOW_ITEM_TYPE_TCP:
359 			tcp_spec = item->spec;
360 			tcp_mask = item->mask;
361 
362 			if (!(tcp_spec && tcp_mask))
363 				break;
364 
365 			/* Check TCP mask and update input set */
366 			if (tcp_mask->hdr.sent_seq ||
367 			    tcp_mask->hdr.recv_ack ||
368 			    tcp_mask->hdr.data_off ||
369 			    tcp_mask->hdr.tcp_flags ||
370 			    tcp_mask->hdr.rx_win ||
371 			    tcp_mask->hdr.cksum ||
372 			    tcp_mask->hdr.tcp_urp) {
373 				rte_flow_error_set(error, EINVAL,
374 						   RTE_FLOW_ERROR_TYPE_ITEM,
375 						   item,
376 						   "Invalid TCP mask");
377 				return 0;
378 			}
379 
380 			if (is_tunnel) {
381 				if (tcp_mask->hdr.src_port == UINT16_MAX)
382 					input_set |= ICE_INSET_TUN_SRC_PORT;
383 				if (tcp_mask->hdr.dst_port == UINT16_MAX)
384 					input_set |= ICE_INSET_TUN_DST_PORT;
385 			} else {
386 				if (tcp_mask->hdr.src_port == UINT16_MAX)
387 					input_set |= ICE_INSET_SRC_PORT;
388 				if (tcp_mask->hdr.dst_port == UINT16_MAX)
389 					input_set |= ICE_INSET_DST_PORT;
390 			}
391 
392 			break;
393 		case RTE_FLOW_ITEM_TYPE_SCTP:
394 			sctp_spec = item->spec;
395 			sctp_mask = item->mask;
396 
397 			if (!(sctp_spec && sctp_mask))
398 				break;
399 
400 			/* Check SCTP mask and update input set */
401 			if (sctp_mask->hdr.cksum) {
402 				rte_flow_error_set(error, EINVAL,
403 					   RTE_FLOW_ERROR_TYPE_ITEM,
404 					   item,
405 					   "Invalid SCTP mask");
406 				return 0;
407 			}
408 
409 			if (is_tunnel) {
410 				if (sctp_mask->hdr.src_port == UINT16_MAX)
411 					input_set |= ICE_INSET_TUN_SRC_PORT;
412 				if (sctp_mask->hdr.dst_port == UINT16_MAX)
413 					input_set |= ICE_INSET_TUN_DST_PORT;
414 			} else {
415 				if (sctp_mask->hdr.src_port == UINT16_MAX)
416 					input_set |= ICE_INSET_SRC_PORT;
417 				if (sctp_mask->hdr.dst_port == UINT16_MAX)
418 					input_set |= ICE_INSET_DST_PORT;
419 			}
420 
421 			break;
422 		case RTE_FLOW_ITEM_TYPE_ICMP:
423 			icmp_mask = item->mask;
424 			if (icmp_mask->hdr.icmp_code ||
425 			    icmp_mask->hdr.icmp_cksum ||
426 			    icmp_mask->hdr.icmp_ident ||
427 			    icmp_mask->hdr.icmp_seq_nb) {
428 				rte_flow_error_set(error, EINVAL,
429 						   RTE_FLOW_ERROR_TYPE_ITEM,
430 						   item,
431 						   "Invalid ICMP mask");
432 				return 0;
433 			}
434 
435 			if (icmp_mask->hdr.icmp_type == UINT8_MAX)
436 				input_set |= ICE_INSET_ICMP;
437 			break;
438 		case RTE_FLOW_ITEM_TYPE_ICMP6:
439 			icmp6_mask = item->mask;
440 			if (icmp6_mask->code ||
441 			    icmp6_mask->checksum) {
442 				rte_flow_error_set(error, EINVAL,
443 						   RTE_FLOW_ERROR_TYPE_ITEM,
444 						   item,
445 						   "Invalid ICMP6 mask");
446 				return 0;
447 			}
448 
449 			if (icmp6_mask->type == UINT8_MAX)
450 				input_set |= ICE_INSET_ICMP6;
451 			break;
452 		case RTE_FLOW_ITEM_TYPE_VXLAN:
453 			vxlan_spec = item->spec;
454 			vxlan_mask = item->mask;
455 			/* Check if VXLAN item is used to describe protocol.
456 			 * If yes, both spec and mask should be NULL.
457 			 * If no, both spec and mask shouldn't be NULL.
458 			 */
459 			if ((!vxlan_spec && vxlan_mask) ||
460 			    (vxlan_spec && !vxlan_mask)) {
461 				rte_flow_error_set(error, EINVAL,
462 					   RTE_FLOW_ERROR_TYPE_ITEM,
463 					   item,
464 					   "Invalid VXLAN item");
465 				return 0;
466 			}
467 			if (vxlan_mask->vni[0] == UINT8_MAX &&
468 					vxlan_mask->vni[1] == UINT8_MAX &&
469 					vxlan_mask->vni[2] == UINT8_MAX)
470 				input_set |= ICE_INSET_TUN_ID;
471 			is_tunnel = 1;
472 
473 			break;
474 		case RTE_FLOW_ITEM_TYPE_NVGRE:
475 			nvgre_spec = item->spec;
476 			nvgre_mask = item->mask;
477 			/* Check if NVGRE item is used to describe protocol.
478 			 * If yes, both spec and mask should be NULL.
479 			 * If no, both spec and mask shouldn't be NULL.
480 			 */
481 			if ((!nvgre_spec && nvgre_mask) ||
482 			    (nvgre_spec && !nvgre_mask)) {
483 				rte_flow_error_set(error, EINVAL,
484 					   RTE_FLOW_ERROR_TYPE_ITEM,
485 					   item,
486 					   "Invalid NVGRE item");
487 				return 0;
488 			}
489 			if (nvgre_mask->tni[0] == UINT8_MAX &&
490 					nvgre_mask->tni[1] == UINT8_MAX &&
491 					nvgre_mask->tni[2] == UINT8_MAX)
492 				input_set |= ICE_INSET_TUN_ID;
493 			is_tunnel = 1;
494 
495 			break;
496 		case RTE_FLOW_ITEM_TYPE_VOID:
497 			break;
498 		default:
499 			rte_flow_error_set(error, EINVAL,
500 					   RTE_FLOW_ERROR_TYPE_ITEM,
501 					   item,
502 					   "Invalid pattern");
503 			break;
504 		}
505 	}
506 	return input_set;
507 }
508 
509 static int ice_flow_valid_inset(const struct rte_flow_item pattern[],
510 			uint64_t inset, struct rte_flow_error *error)
511 {
512 	uint64_t fields;
513 
514 	/* get valid field */
515 	fields = ice_get_flow_field(pattern, error);
516 	if (!fields || fields & (~inset)) {
517 		rte_flow_error_set(error, EINVAL,
518 				   RTE_FLOW_ERROR_TYPE_ITEM_SPEC,
519 				   pattern,
520 				   "Invalid input set");
521 		return -rte_errno;
522 	}
523 
524 	return 0;
525 }
526 
527 static int ice_flow_valid_action(struct rte_eth_dev *dev,
528 				const struct rte_flow_action *actions,
529 				struct rte_flow_error *error)
530 {
531 	const struct rte_flow_action_queue *act_q;
532 	uint16_t queue;
533 	const struct rte_flow_action *action;
534 	for (action = actions; action->type !=
535 			RTE_FLOW_ACTION_TYPE_END; action++) {
536 		switch (action->type) {
537 		case RTE_FLOW_ACTION_TYPE_QUEUE:
538 			act_q = action->conf;
539 			queue = act_q->index;
540 			if (queue >= dev->data->nb_rx_queues) {
541 				rte_flow_error_set(error, EINVAL,
542 						RTE_FLOW_ERROR_TYPE_ACTION,
543 						actions, "Invalid queue ID for"
544 						" switch filter.");
545 				return -rte_errno;
546 			}
547 			break;
548 		case RTE_FLOW_ACTION_TYPE_DROP:
549 		case RTE_FLOW_ACTION_TYPE_VOID:
550 			break;
551 		default:
552 			rte_flow_error_set(error, EINVAL,
553 					   RTE_FLOW_ERROR_TYPE_ACTION, actions,
554 					   "Invalid action.");
555 			return -rte_errno;
556 		}
557 	}
558 	return 0;
559 }
560 
561 static int
562 ice_flow_validate(struct rte_eth_dev *dev,
563 		   const struct rte_flow_attr *attr,
564 		   const struct rte_flow_item pattern[],
565 		   const struct rte_flow_action actions[],
566 		   struct rte_flow_error *error)
567 {
568 	uint64_t inset = 0;
569 	int ret = ICE_ERR_NOT_SUPPORTED;
570 
571 	if (!pattern) {
572 		rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM_NUM,
573 				   NULL, "NULL pattern.");
574 		return -rte_errno;
575 	}
576 
577 	if (!actions) {
578 		rte_flow_error_set(error, EINVAL,
579 				   RTE_FLOW_ERROR_TYPE_ACTION_NUM,
580 				   NULL, "NULL action.");
581 		return -rte_errno;
582 	}
583 
584 	if (!attr) {
585 		rte_flow_error_set(error, EINVAL,
586 				   RTE_FLOW_ERROR_TYPE_ATTR,
587 				   NULL, "NULL attribute.");
588 		return -rte_errno;
589 	}
590 
591 	ret = ice_flow_valid_attr(attr, error);
592 	if (ret)
593 		return ret;
594 
595 	inset = ice_flow_valid_pattern(pattern, error);
596 	if (!inset)
597 		return -rte_errno;
598 
599 	ret = ice_flow_valid_inset(pattern, inset, error);
600 	if (ret)
601 		return ret;
602 
603 	ret = ice_flow_valid_action(dev, actions, error);
604 	if (ret)
605 		return ret;
606 
607 	return 0;
608 }
609 
610 static struct rte_flow *
611 ice_flow_create(struct rte_eth_dev *dev,
612 		 const struct rte_flow_attr *attr,
613 		 const struct rte_flow_item pattern[],
614 		 const struct rte_flow_action actions[],
615 		 struct rte_flow_error *error)
616 {
617 	struct ice_pf *pf = ICE_DEV_PRIVATE_TO_PF(dev->data->dev_private);
618 	struct rte_flow *flow = NULL;
619 	int ret;
620 
621 	flow = rte_zmalloc("ice_flow", sizeof(struct rte_flow), 0);
622 	if (!flow) {
623 		rte_flow_error_set(error, ENOMEM,
624 				   RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
625 				   "Failed to allocate memory");
626 		return flow;
627 	}
628 
629 	ret = ice_flow_validate(dev, attr, pattern, actions, error);
630 	if (ret < 0)
631 		goto free_flow;
632 
633 	ret = ice_create_switch_filter(pf, pattern, actions, flow, error);
634 	if (ret)
635 		goto free_flow;
636 
637 	TAILQ_INSERT_TAIL(&pf->flow_list, flow, node);
638 	return flow;
639 
640 free_flow:
641 	rte_flow_error_set(error, -ret,
642 			   RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
643 			   "Failed to create flow.");
644 	rte_free(flow);
645 	return NULL;
646 }
647 
648 static int
649 ice_flow_destroy(struct rte_eth_dev *dev,
650 		 struct rte_flow *flow,
651 		 struct rte_flow_error *error)
652 {
653 	struct ice_pf *pf = ICE_DEV_PRIVATE_TO_PF(dev->data->dev_private);
654 	int ret = 0;
655 
656 	ret = ice_destroy_switch_filter(pf, flow, error);
657 
658 	if (!ret) {
659 		TAILQ_REMOVE(&pf->flow_list, flow, node);
660 		rte_free(flow);
661 	} else {
662 		rte_flow_error_set(error, -ret,
663 				   RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
664 				   "Failed to destroy flow.");
665 	}
666 
667 	return ret;
668 }
669 
670 static int
671 ice_flow_flush(struct rte_eth_dev *dev,
672 	       struct rte_flow_error *error)
673 {
674 	struct ice_pf *pf = ICE_DEV_PRIVATE_TO_PF(dev->data->dev_private);
675 	struct rte_flow *p_flow;
676 	void *temp;
677 	int ret = 0;
678 
679 	TAILQ_FOREACH_SAFE(p_flow, &pf->flow_list, node, temp) {
680 		ret = ice_flow_destroy(dev, p_flow, error);
681 		if (ret) {
682 			rte_flow_error_set(error, -ret,
683 					   RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
684 					   "Failed to flush SW flows.");
685 			return -rte_errno;
686 		}
687 	}
688 
689 	return ret;
690 }
691