Branch data Line data Source code
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 : : #include <rte_debug.h>
13 : : #include <rte_ether.h>
14 : : #include <ethdev_driver.h>
15 : : #include <rte_log.h>
16 : : #include <rte_malloc.h>
17 : : #include <rte_eth_ctrl.h>
18 : : #include <rte_tailq.h>
19 : : #include <rte_flow_driver.h>
20 : : #include <rte_flow.h>
21 : : #include "base/ice_type.h"
22 : : #include "base/ice_switch.h"
23 : : #include "ice_logs.h"
24 : : #include "ice_ethdev.h"
25 : : #include "ice_generic_flow.h"
26 : : #include "ice_dcf_ethdev.h"
27 : :
28 : :
29 : : #define MAX_QGRP_NUM_TYPE 7
30 : : #define MAX_INPUT_SET_BYTE 32
31 : : #define ICE_PPP_IPV4_PROTO 0x0021
32 : : #define ICE_PPP_IPV6_PROTO 0x0057
33 : : #define ICE_IPV4_PROTO_NVGRE 0x002F
34 : : #define ICE_SW_PRI_BASE 6
35 : :
36 : : #define ICE_SW_INSET_ETHER ( \
37 : : ICE_INSET_DMAC | ICE_INSET_SMAC | ICE_INSET_ETHERTYPE)
38 : : #define ICE_SW_INSET_MAC_VLAN ( \
39 : : ICE_SW_INSET_ETHER | ICE_INSET_VLAN_INNER)
40 : : #define ICE_SW_INSET_MAC_QINQ ( \
41 : : ICE_INSET_DMAC | ICE_INSET_SMAC | ICE_INSET_VLAN_INNER | \
42 : : ICE_INSET_VLAN_OUTER)
43 : : #define ICE_SW_INSET_MAC_IPV4 ( \
44 : : ICE_INSET_DMAC | ICE_INSET_IPV4_DST | ICE_INSET_IPV4_SRC | \
45 : : ICE_INSET_IPV4_PROTO | ICE_INSET_IPV4_TTL | ICE_INSET_IPV4_TOS)
46 : : #define ICE_SW_INSET_MAC_QINQ_IPV4 ( \
47 : : ICE_SW_INSET_MAC_QINQ | ICE_SW_INSET_MAC_IPV4)
48 : : #define ICE_SW_INSET_MAC_QINQ_IPV4_TCP ( \
49 : : ICE_SW_INSET_MAC_QINQ_IPV4 | \
50 : : ICE_INSET_TCP_DST_PORT | ICE_INSET_TCP_SRC_PORT)
51 : : #define ICE_SW_INSET_MAC_QINQ_IPV4_UDP ( \
52 : : ICE_SW_INSET_MAC_QINQ_IPV4 | \
53 : : ICE_INSET_UDP_DST_PORT | ICE_INSET_UDP_SRC_PORT)
54 : : #define ICE_SW_INSET_MAC_IPV4_TCP ( \
55 : : ICE_INSET_DMAC | ICE_INSET_IPV4_DST | ICE_INSET_IPV4_SRC | \
56 : : ICE_INSET_IPV4_TTL | ICE_INSET_IPV4_TOS | \
57 : : ICE_INSET_TCP_DST_PORT | ICE_INSET_TCP_SRC_PORT)
58 : : #define ICE_SW_INSET_MAC_IPV4_UDP ( \
59 : : ICE_INSET_DMAC | ICE_INSET_IPV4_DST | ICE_INSET_IPV4_SRC | \
60 : : ICE_INSET_IPV4_TTL | ICE_INSET_IPV4_TOS | \
61 : : ICE_INSET_UDP_DST_PORT | ICE_INSET_UDP_SRC_PORT)
62 : : #define ICE_SW_INSET_MAC_IPV6 ( \
63 : : ICE_INSET_DMAC | ICE_INSET_IPV6_DST | ICE_INSET_IPV6_SRC | \
64 : : ICE_INSET_IPV6_TC | ICE_INSET_IPV6_HOP_LIMIT | \
65 : : ICE_INSET_IPV6_NEXT_HDR)
66 : : #define ICE_SW_INSET_MAC_QINQ_IPV6 ( \
67 : : ICE_SW_INSET_MAC_QINQ | ICE_SW_INSET_MAC_IPV6)
68 : : #define ICE_SW_INSET_MAC_QINQ_IPV6_TCP ( \
69 : : ICE_SW_INSET_MAC_QINQ_IPV6 | \
70 : : ICE_INSET_TCP_DST_PORT | ICE_INSET_TCP_SRC_PORT)
71 : : #define ICE_SW_INSET_MAC_QINQ_IPV6_UDP ( \
72 : : ICE_SW_INSET_MAC_QINQ_IPV6 | \
73 : : ICE_INSET_UDP_DST_PORT | ICE_INSET_UDP_SRC_PORT)
74 : : #define ICE_SW_INSET_MAC_IPV6_TCP ( \
75 : : ICE_INSET_DMAC | ICE_INSET_IPV6_DST | ICE_INSET_IPV6_SRC | \
76 : : ICE_INSET_IPV6_HOP_LIMIT | ICE_INSET_IPV6_TC | \
77 : : ICE_INSET_TCP_DST_PORT | ICE_INSET_TCP_SRC_PORT)
78 : : #define ICE_SW_INSET_MAC_IPV6_UDP ( \
79 : : ICE_INSET_DMAC | ICE_INSET_IPV6_DST | ICE_INSET_IPV6_SRC | \
80 : : ICE_INSET_IPV6_HOP_LIMIT | ICE_INSET_IPV6_TC | \
81 : : ICE_INSET_UDP_DST_PORT | ICE_INSET_UDP_SRC_PORT)
82 : : #define ICE_SW_INSET_DIST_NVGRE_IPV4 ( \
83 : : ICE_INSET_IPV4_SRC | ICE_INSET_IPV4_DST | ICE_INSET_DMAC | \
84 : : ICE_INSET_NVGRE_TNI)
85 : : #define ICE_SW_INSET_DIST_VXLAN_IPV4 ( \
86 : : ICE_INSET_IPV4_SRC | ICE_INSET_IPV4_DST | ICE_INSET_DMAC | \
87 : : ICE_INSET_VXLAN_VNI)
88 : : #define ICE_SW_INSET_DIST_NVGRE_IPV4_TCP ( \
89 : : ICE_INSET_IPV4_SRC | ICE_INSET_IPV4_DST | \
90 : : ICE_INSET_TCP_SRC_PORT | ICE_INSET_TCP_DST_PORT | \
91 : : ICE_INSET_DMAC | ICE_INSET_NVGRE_TNI)
92 : : #define ICE_SW_INSET_DIST_NVGRE_IPV4_UDP ( \
93 : : ICE_INSET_IPV4_SRC | ICE_INSET_IPV4_DST | \
94 : : ICE_INSET_UDP_SRC_PORT | ICE_INSET_UDP_DST_PORT | \
95 : : ICE_INSET_DMAC | ICE_INSET_NVGRE_TNI)
96 : : #define ICE_SW_INSET_DIST_VXLAN_IPV4_TCP ( \
97 : : ICE_INSET_IPV4_SRC | ICE_INSET_IPV4_DST | \
98 : : ICE_INSET_TCP_SRC_PORT | ICE_INSET_TCP_DST_PORT | \
99 : : ICE_INSET_DMAC | ICE_INSET_VXLAN_VNI)
100 : : #define ICE_SW_INSET_DIST_VXLAN_IPV4_UDP ( \
101 : : ICE_INSET_IPV4_SRC | ICE_INSET_IPV4_DST | \
102 : : ICE_INSET_UDP_SRC_PORT | ICE_INSET_UDP_DST_PORT | \
103 : : ICE_INSET_DMAC | ICE_INSET_VXLAN_VNI)
104 : : #define ICE_SW_INSET_PERM_TUNNEL_IPV4 ( \
105 : : ICE_INSET_IPV4_SRC | ICE_INSET_IPV4_DST | \
106 : : ICE_INSET_IPV4_PROTO | ICE_INSET_IPV4_TOS)
107 : : #define ICE_SW_INSET_PERM_TUNNEL_IPV4_TCP ( \
108 : : ICE_INSET_IPV4_SRC | ICE_INSET_IPV4_DST | \
109 : : ICE_INSET_TCP_SRC_PORT | ICE_INSET_TCP_DST_PORT | \
110 : : ICE_INSET_IPV4_TOS)
111 : : #define ICE_SW_INSET_PERM_TUNNEL_IPV4_UDP ( \
112 : : ICE_INSET_IPV4_SRC | ICE_INSET_IPV4_DST | \
113 : : ICE_INSET_UDP_SRC_PORT | ICE_INSET_UDP_DST_PORT | \
114 : : ICE_INSET_IPV4_TOS)
115 : : #define ICE_SW_INSET_MAC_PPPOE ( \
116 : : ICE_INSET_VLAN_OUTER | ICE_INSET_VLAN_INNER | \
117 : : ICE_INSET_DMAC | ICE_INSET_ETHERTYPE | ICE_INSET_PPPOE_SESSION)
118 : : #define ICE_SW_INSET_MAC_PPPOE_PROTO ( \
119 : : ICE_INSET_VLAN_OUTER | ICE_INSET_VLAN_INNER | \
120 : : ICE_INSET_DMAC | ICE_INSET_ETHERTYPE | ICE_INSET_PPPOE_SESSION | \
121 : : ICE_INSET_PPPOE_PROTO)
122 : : #define ICE_SW_INSET_MAC_PPPOE_IPV4 ( \
123 : : ICE_SW_INSET_MAC_PPPOE | ICE_SW_INSET_MAC_IPV4)
124 : : #define ICE_SW_INSET_MAC_PPPOE_IPV4_TCP ( \
125 : : ICE_SW_INSET_MAC_PPPOE | ICE_SW_INSET_MAC_IPV4_TCP)
126 : : #define ICE_SW_INSET_MAC_PPPOE_IPV4_UDP ( \
127 : : ICE_SW_INSET_MAC_PPPOE | ICE_SW_INSET_MAC_IPV4_UDP)
128 : : #define ICE_SW_INSET_MAC_PPPOE_IPV6 ( \
129 : : ICE_SW_INSET_MAC_PPPOE | ICE_SW_INSET_MAC_IPV6)
130 : : #define ICE_SW_INSET_MAC_PPPOE_IPV6_TCP ( \
131 : : ICE_SW_INSET_MAC_PPPOE | ICE_SW_INSET_MAC_IPV6_TCP)
132 : : #define ICE_SW_INSET_MAC_PPPOE_IPV6_UDP ( \
133 : : ICE_SW_INSET_MAC_PPPOE | ICE_SW_INSET_MAC_IPV6_UDP)
134 : : #define ICE_SW_INSET_MAC_IPV4_ESP ( \
135 : : ICE_SW_INSET_MAC_IPV4 | ICE_INSET_ESP_SPI)
136 : : #define ICE_SW_INSET_MAC_IPV6_ESP ( \
137 : : ICE_SW_INSET_MAC_IPV6 | ICE_INSET_ESP_SPI)
138 : : #define ICE_SW_INSET_MAC_IPV4_AH ( \
139 : : ICE_SW_INSET_MAC_IPV4 | ICE_INSET_AH_SPI)
140 : : #define ICE_SW_INSET_MAC_IPV6_AH ( \
141 : : ICE_SW_INSET_MAC_IPV6 | ICE_INSET_AH_SPI)
142 : : #define ICE_SW_INSET_MAC_IPV4_L2TP ( \
143 : : ICE_SW_INSET_MAC_IPV4 | ICE_INSET_L2TPV3OIP_SESSION_ID)
144 : : #define ICE_SW_INSET_MAC_IPV6_L2TP ( \
145 : : ICE_SW_INSET_MAC_IPV6 | ICE_INSET_L2TPV3OIP_SESSION_ID)
146 : : #define ICE_SW_INSET_MAC_IPV4_PFCP ( \
147 : : ICE_SW_INSET_MAC_IPV4 | \
148 : : ICE_INSET_PFCP_S_FIELD | ICE_INSET_PFCP_SEID)
149 : : #define ICE_SW_INSET_MAC_IPV6_PFCP ( \
150 : : ICE_SW_INSET_MAC_IPV6 | \
151 : : ICE_INSET_PFCP_S_FIELD | ICE_INSET_PFCP_SEID)
152 : : #define ICE_SW_INSET_MAC_IPV4_GTPU ( \
153 : : ICE_SW_INSET_MAC_IPV4 | ICE_INSET_GTPU_TEID)
154 : : #define ICE_SW_INSET_MAC_IPV6_GTPU ( \
155 : : ICE_SW_INSET_MAC_IPV6 | ICE_INSET_GTPU_TEID)
156 : : #define ICE_SW_INSET_MAC_GTPU_OUTER ( \
157 : : ICE_INSET_DMAC | ICE_INSET_GTPU_TEID)
158 : : #define ICE_SW_INSET_MAC_GTPU_EH_OUTER ( \
159 : : ICE_SW_INSET_MAC_GTPU_OUTER | ICE_INSET_GTPU_QFI)
160 : : #define ICE_SW_INSET_GTPU_IPV4 ( \
161 : : ICE_INSET_IPV4_SRC | ICE_INSET_IPV4_DST)
162 : : #define ICE_SW_INSET_GTPU_IPV6 ( \
163 : : ICE_INSET_IPV6_SRC | ICE_INSET_IPV6_DST)
164 : : #define ICE_SW_INSET_GTPU_IPV4_UDP ( \
165 : : ICE_SW_INSET_GTPU_IPV4 | ICE_INSET_UDP_SRC_PORT | \
166 : : ICE_INSET_UDP_DST_PORT)
167 : : #define ICE_SW_INSET_GTPU_IPV4_TCP ( \
168 : : ICE_SW_INSET_GTPU_IPV4 | ICE_INSET_TCP_SRC_PORT | \
169 : : ICE_INSET_TCP_DST_PORT)
170 : : #define ICE_SW_INSET_GTPU_IPV6_UDP ( \
171 : : ICE_SW_INSET_GTPU_IPV6 | ICE_INSET_UDP_SRC_PORT | \
172 : : ICE_INSET_UDP_DST_PORT)
173 : : #define ICE_SW_INSET_GTPU_IPV6_TCP ( \
174 : : ICE_SW_INSET_GTPU_IPV6 | ICE_INSET_TCP_SRC_PORT | \
175 : : ICE_INSET_TCP_DST_PORT)
176 : :
177 : : struct sw_meta {
178 : : struct ice_adv_lkup_elem *list;
179 : : uint16_t lkups_num;
180 : : struct ice_adv_rule_info rule_info;
181 : : };
182 : :
183 : : enum ice_sw_fltr_status {
184 : : ICE_SW_FLTR_ADDED,
185 : : ICE_SW_FLTR_RMV_FAILED_ON_RIDRECT,
186 : : ICE_SW_FLTR_ADD_FAILED_ON_RIDRECT,
187 : : };
188 : :
189 : : struct ice_switch_filter_conf {
190 : : enum ice_sw_fltr_status fltr_status;
191 : :
192 : : struct ice_rule_query_data sw_query_data;
193 : :
194 : : /*
195 : : * The lookup elements and rule info are saved here when filter creation
196 : : * succeeds.
197 : : */
198 : : uint16_t vsi_num;
199 : : uint16_t lkups_num;
200 : : struct ice_adv_lkup_elem *lkups;
201 : : struct ice_adv_rule_info rule_info;
202 : : };
203 : :
204 : : static struct
205 : : ice_pattern_match_item ice_switch_supported_pattern[] = {
206 : : {pattern_any, ICE_INSET_NONE, ICE_INSET_NONE, ICE_INSET_NONE},
207 : : {pattern_ethertype, ICE_SW_INSET_ETHER, ICE_INSET_NONE, ICE_INSET_NONE},
208 : : {pattern_ethertype_vlan, ICE_SW_INSET_MAC_VLAN, ICE_INSET_NONE, ICE_INSET_NONE},
209 : : {pattern_ethertype_qinq, ICE_SW_INSET_MAC_QINQ, ICE_INSET_NONE, ICE_INSET_NONE},
210 : : {pattern_eth_arp, ICE_INSET_NONE, ICE_INSET_NONE, ICE_INSET_NONE},
211 : : {pattern_eth_ipv4, ICE_SW_INSET_MAC_IPV4, ICE_INSET_NONE, ICE_INSET_NONE},
212 : : {pattern_eth_ipv4_udp, ICE_SW_INSET_MAC_IPV4_UDP, ICE_INSET_NONE, ICE_INSET_NONE},
213 : : {pattern_eth_ipv4_tcp, ICE_SW_INSET_MAC_IPV4_TCP, ICE_INSET_NONE, ICE_INSET_NONE},
214 : : {pattern_eth_ipv6, ICE_SW_INSET_MAC_IPV6, ICE_INSET_NONE, ICE_INSET_NONE},
215 : : {pattern_eth_ipv6_udp, ICE_SW_INSET_MAC_IPV6_UDP, ICE_INSET_NONE, ICE_INSET_NONE},
216 : : {pattern_eth_ipv6_tcp, ICE_SW_INSET_MAC_IPV6_TCP, ICE_INSET_NONE, ICE_INSET_NONE},
217 : : {pattern_eth_ipv4_udp_vxlan_eth_ipv4, ICE_INSET_IPV4_DST, ICE_SW_INSET_DIST_VXLAN_IPV4, ICE_INSET_NONE},
218 : : {pattern_eth_ipv4_udp_vxlan_eth_ipv4_udp, ICE_INSET_IPV4_DST, ICE_SW_INSET_DIST_VXLAN_IPV4_UDP, ICE_INSET_NONE},
219 : : {pattern_eth_ipv4_udp_vxlan_eth_ipv4_tcp, ICE_INSET_IPV4_DST, ICE_SW_INSET_DIST_VXLAN_IPV4_TCP, ICE_INSET_NONE},
220 : : {pattern_eth_ipv4_nvgre_eth_ipv4, ICE_INSET_IPV4_DST, ICE_SW_INSET_DIST_NVGRE_IPV4, ICE_INSET_NONE},
221 : : {pattern_eth_ipv4_nvgre_eth_ipv4_udp, ICE_INSET_IPV4_DST, ICE_SW_INSET_DIST_NVGRE_IPV4_UDP, ICE_INSET_NONE},
222 : : {pattern_eth_ipv4_nvgre_eth_ipv4_tcp, ICE_INSET_IPV4_DST, ICE_SW_INSET_DIST_NVGRE_IPV4_TCP, ICE_INSET_NONE},
223 : : {pattern_eth_pppoes, ICE_SW_INSET_MAC_PPPOE, ICE_INSET_NONE, ICE_INSET_NONE},
224 : : {pattern_eth_vlan_pppoes, ICE_SW_INSET_MAC_PPPOE, ICE_INSET_NONE, ICE_INSET_NONE},
225 : : {pattern_eth_pppoes_proto, ICE_SW_INSET_MAC_PPPOE_PROTO, ICE_INSET_NONE, ICE_INSET_NONE},
226 : : {pattern_eth_vlan_pppoes_proto, ICE_SW_INSET_MAC_PPPOE_PROTO, ICE_INSET_NONE, ICE_INSET_NONE},
227 : : {pattern_eth_pppoes_ipv4, ICE_SW_INSET_MAC_PPPOE_IPV4, ICE_INSET_NONE, ICE_INSET_NONE},
228 : : {pattern_eth_pppoes_ipv4_tcp, ICE_SW_INSET_MAC_PPPOE_IPV4_TCP, ICE_INSET_NONE, ICE_INSET_NONE},
229 : : {pattern_eth_pppoes_ipv4_udp, ICE_SW_INSET_MAC_PPPOE_IPV4_UDP, ICE_INSET_NONE, ICE_INSET_NONE},
230 : : {pattern_eth_pppoes_ipv6, ICE_SW_INSET_MAC_PPPOE_IPV6, ICE_INSET_NONE, ICE_INSET_NONE},
231 : : {pattern_eth_pppoes_ipv6_tcp, ICE_SW_INSET_MAC_PPPOE_IPV6_TCP, ICE_INSET_NONE, ICE_INSET_NONE},
232 : : {pattern_eth_pppoes_ipv6_udp, ICE_SW_INSET_MAC_PPPOE_IPV6_UDP, ICE_INSET_NONE, ICE_INSET_NONE},
233 : : {pattern_eth_vlan_pppoes_ipv4, ICE_SW_INSET_MAC_PPPOE_IPV4, ICE_INSET_NONE, ICE_INSET_NONE},
234 : : {pattern_eth_vlan_pppoes_ipv4_tcp, ICE_SW_INSET_MAC_PPPOE_IPV4_TCP, ICE_INSET_NONE, ICE_INSET_NONE},
235 : : {pattern_eth_vlan_pppoes_ipv4_udp, ICE_SW_INSET_MAC_PPPOE_IPV4_UDP, ICE_INSET_NONE, ICE_INSET_NONE},
236 : : {pattern_eth_vlan_pppoes_ipv6, ICE_SW_INSET_MAC_PPPOE_IPV6, ICE_INSET_NONE, ICE_INSET_NONE},
237 : : {pattern_eth_vlan_pppoes_ipv6_tcp, ICE_SW_INSET_MAC_PPPOE_IPV6_TCP, ICE_INSET_NONE, ICE_INSET_NONE},
238 : : {pattern_eth_vlan_pppoes_ipv6_udp, ICE_SW_INSET_MAC_PPPOE_IPV6_UDP, ICE_INSET_NONE, ICE_INSET_NONE},
239 : : {pattern_eth_ipv4_esp, ICE_SW_INSET_MAC_IPV4_ESP, ICE_INSET_NONE, ICE_INSET_NONE},
240 : : {pattern_eth_ipv4_udp_esp, ICE_SW_INSET_MAC_IPV4_ESP, ICE_INSET_NONE, ICE_INSET_NONE},
241 : : {pattern_eth_ipv6_esp, ICE_SW_INSET_MAC_IPV6_ESP, ICE_INSET_NONE, ICE_INSET_NONE},
242 : : {pattern_eth_ipv6_udp_esp, ICE_SW_INSET_MAC_IPV6_ESP, ICE_INSET_NONE, ICE_INSET_NONE},
243 : : {pattern_eth_ipv4_ah, ICE_SW_INSET_MAC_IPV4_AH, ICE_INSET_NONE, ICE_INSET_NONE},
244 : : {pattern_eth_ipv6_ah, ICE_SW_INSET_MAC_IPV6_AH, ICE_INSET_NONE, ICE_INSET_NONE},
245 : : {pattern_eth_ipv6_udp_ah, ICE_INSET_NONE, ICE_INSET_NONE, ICE_INSET_NONE},
246 : : {pattern_eth_ipv4_l2tp, ICE_SW_INSET_MAC_IPV4_L2TP, ICE_INSET_NONE, ICE_INSET_NONE},
247 : : {pattern_eth_ipv6_l2tp, ICE_SW_INSET_MAC_IPV6_L2TP, ICE_INSET_NONE, ICE_INSET_NONE},
248 : : {pattern_eth_ipv4_pfcp, ICE_INSET_NONE, ICE_INSET_NONE, ICE_INSET_NONE},
249 : : {pattern_eth_ipv6_pfcp, ICE_INSET_NONE, ICE_INSET_NONE, ICE_INSET_NONE},
250 : : {pattern_eth_qinq_ipv4, ICE_SW_INSET_MAC_QINQ_IPV4, ICE_INSET_NONE, ICE_INSET_NONE},
251 : : {pattern_eth_qinq_ipv4_tcp, ICE_SW_INSET_MAC_QINQ_IPV4_TCP, ICE_INSET_NONE, ICE_INSET_NONE},
252 : : {pattern_eth_qinq_ipv4_udp, ICE_SW_INSET_MAC_QINQ_IPV4_UDP, ICE_INSET_NONE, ICE_INSET_NONE},
253 : : {pattern_eth_qinq_ipv6, ICE_SW_INSET_MAC_QINQ_IPV6, ICE_INSET_NONE, ICE_INSET_NONE},
254 : : {pattern_eth_qinq_ipv6_tcp, ICE_SW_INSET_MAC_QINQ_IPV6_TCP, ICE_INSET_NONE, ICE_INSET_NONE},
255 : : {pattern_eth_qinq_ipv6_udp, ICE_SW_INSET_MAC_QINQ_IPV6_UDP, ICE_INSET_NONE, ICE_INSET_NONE},
256 : : {pattern_eth_qinq_pppoes, ICE_SW_INSET_MAC_PPPOE, ICE_INSET_NONE, ICE_INSET_NONE},
257 : : {pattern_eth_qinq_pppoes_proto, ICE_SW_INSET_MAC_PPPOE_PROTO, ICE_INSET_NONE, ICE_INSET_NONE},
258 : : {pattern_eth_qinq_pppoes_ipv4, ICE_SW_INSET_MAC_PPPOE_IPV4, ICE_INSET_NONE, ICE_INSET_NONE},
259 : : {pattern_eth_qinq_pppoes_ipv6, ICE_SW_INSET_MAC_PPPOE_IPV6, ICE_INSET_NONE, ICE_INSET_NONE},
260 : : {pattern_eth_ipv4_gtpu, ICE_SW_INSET_MAC_IPV4_GTPU, ICE_INSET_NONE, ICE_INSET_NONE},
261 : : {pattern_eth_ipv6_gtpu, ICE_SW_INSET_MAC_IPV6_GTPU, ICE_INSET_NONE, ICE_INSET_NONE},
262 : : {pattern_eth_ipv4_gtpu_ipv4, ICE_SW_INSET_MAC_GTPU_OUTER, ICE_SW_INSET_GTPU_IPV4, ICE_INSET_NONE},
263 : : {pattern_eth_ipv4_gtpu_eh_ipv4, ICE_SW_INSET_MAC_GTPU_EH_OUTER, ICE_SW_INSET_GTPU_IPV4, ICE_INSET_NONE},
264 : : {pattern_eth_ipv4_gtpu_ipv4_udp, ICE_SW_INSET_MAC_GTPU_OUTER, ICE_SW_INSET_GTPU_IPV4_UDP, ICE_INSET_NONE},
265 : : {pattern_eth_ipv4_gtpu_eh_ipv4_udp, ICE_SW_INSET_MAC_GTPU_EH_OUTER, ICE_SW_INSET_GTPU_IPV4_UDP, ICE_INSET_NONE},
266 : : {pattern_eth_ipv4_gtpu_ipv4_tcp, ICE_SW_INSET_MAC_GTPU_OUTER, ICE_SW_INSET_GTPU_IPV4_TCP, ICE_INSET_NONE},
267 : : {pattern_eth_ipv4_gtpu_eh_ipv4_tcp, ICE_SW_INSET_MAC_GTPU_EH_OUTER, ICE_SW_INSET_GTPU_IPV4_TCP, ICE_INSET_NONE},
268 : : {pattern_eth_ipv4_gtpu_ipv6, ICE_SW_INSET_MAC_GTPU_OUTER, ICE_SW_INSET_GTPU_IPV6, ICE_INSET_NONE},
269 : : {pattern_eth_ipv4_gtpu_eh_ipv6, ICE_SW_INSET_MAC_GTPU_EH_OUTER, ICE_SW_INSET_GTPU_IPV6, ICE_INSET_NONE},
270 : : {pattern_eth_ipv4_gtpu_ipv6_udp, ICE_SW_INSET_MAC_GTPU_OUTER, ICE_SW_INSET_GTPU_IPV6_UDP, ICE_INSET_NONE},
271 : : {pattern_eth_ipv4_gtpu_eh_ipv6_udp, ICE_SW_INSET_MAC_GTPU_EH_OUTER, ICE_SW_INSET_GTPU_IPV6_UDP, ICE_INSET_NONE},
272 : : {pattern_eth_ipv4_gtpu_ipv6_tcp, ICE_SW_INSET_MAC_GTPU_OUTER, ICE_SW_INSET_GTPU_IPV6_TCP, ICE_INSET_NONE},
273 : : {pattern_eth_ipv4_gtpu_eh_ipv6_tcp, ICE_SW_INSET_MAC_GTPU_EH_OUTER, ICE_SW_INSET_GTPU_IPV6_TCP, ICE_INSET_NONE},
274 : : {pattern_eth_ipv6_gtpu_ipv4, ICE_SW_INSET_MAC_GTPU_OUTER, ICE_SW_INSET_GTPU_IPV4, ICE_INSET_NONE},
275 : : {pattern_eth_ipv6_gtpu_eh_ipv4, ICE_SW_INSET_MAC_GTPU_EH_OUTER, ICE_SW_INSET_GTPU_IPV4, ICE_INSET_NONE},
276 : : {pattern_eth_ipv6_gtpu_ipv4_udp, ICE_SW_INSET_MAC_GTPU_OUTER, ICE_SW_INSET_GTPU_IPV4_UDP, ICE_INSET_NONE},
277 : : {pattern_eth_ipv6_gtpu_eh_ipv4_udp, ICE_SW_INSET_MAC_GTPU_EH_OUTER, ICE_SW_INSET_GTPU_IPV4_UDP, ICE_INSET_NONE},
278 : : {pattern_eth_ipv6_gtpu_ipv4_tcp, ICE_SW_INSET_MAC_GTPU_OUTER, ICE_SW_INSET_GTPU_IPV4_TCP, ICE_INSET_NONE},
279 : : {pattern_eth_ipv6_gtpu_eh_ipv4_tcp, ICE_SW_INSET_MAC_GTPU_EH_OUTER, ICE_SW_INSET_GTPU_IPV4_TCP, ICE_INSET_NONE},
280 : : {pattern_eth_ipv6_gtpu_ipv6, ICE_SW_INSET_MAC_GTPU_OUTER, ICE_SW_INSET_GTPU_IPV6, ICE_INSET_NONE},
281 : : {pattern_eth_ipv6_gtpu_eh_ipv6, ICE_SW_INSET_MAC_GTPU_EH_OUTER, ICE_SW_INSET_GTPU_IPV6, ICE_INSET_NONE},
282 : : {pattern_eth_ipv6_gtpu_ipv6_udp, ICE_SW_INSET_MAC_GTPU_OUTER, ICE_SW_INSET_GTPU_IPV6_UDP, ICE_INSET_NONE},
283 : : {pattern_eth_ipv6_gtpu_eh_ipv6_udp, ICE_SW_INSET_MAC_GTPU_EH_OUTER, ICE_SW_INSET_GTPU_IPV6_UDP, ICE_INSET_NONE},
284 : : {pattern_eth_ipv6_gtpu_ipv6_tcp, ICE_SW_INSET_MAC_GTPU_OUTER, ICE_SW_INSET_GTPU_IPV6_TCP, ICE_INSET_NONE},
285 : : {pattern_eth_ipv6_gtpu_eh_ipv6_tcp, ICE_SW_INSET_MAC_GTPU_EH_OUTER, ICE_SW_INSET_GTPU_IPV6_TCP, ICE_INSET_NONE},
286 : : };
287 : :
288 : : static int
289 : 0 : ice_switch_create(struct ice_adapter *ad,
290 : : struct rte_flow *flow,
291 : : void *meta,
292 : : struct rte_flow_error *error)
293 : : {
294 : : int ret = 0;
295 : : struct ice_pf *pf = &ad->pf;
296 : 0 : struct ice_hw *hw = ICE_PF_TO_HW(pf);
297 : 0 : struct ice_rule_query_data rule_added = {0};
298 : : struct ice_switch_filter_conf *filter_conf_ptr;
299 : 0 : struct ice_adv_lkup_elem *list =
300 : : ((struct sw_meta *)meta)->list;
301 : 0 : uint16_t lkups_cnt =
302 : : ((struct sw_meta *)meta)->lkups_num;
303 : 0 : struct ice_adv_rule_info *rule_info =
304 : : &((struct sw_meta *)meta)->rule_info;
305 : :
306 [ # # ]: 0 : if (lkups_cnt > ICE_MAX_CHAIN_WORDS) {
307 : 0 : rte_flow_error_set(error, EINVAL,
308 : : RTE_FLOW_ERROR_TYPE_ITEM, NULL,
309 : : "item number too large for rule");
310 : 0 : goto error;
311 : : }
312 [ # # ]: 0 : if (!list) {
313 : 0 : rte_flow_error_set(error, EINVAL,
314 : : RTE_FLOW_ERROR_TYPE_ITEM, NULL,
315 : : "lookup list should not be NULL");
316 : 0 : goto error;
317 : : }
318 : :
319 [ # # ]: 0 : if (ice_dcf_adminq_need_retry(ad)) {
320 : 0 : rte_flow_error_set(error, EAGAIN,
321 : : RTE_FLOW_ERROR_TYPE_ITEM, NULL,
322 : : "DCF is not on");
323 : 0 : goto error;
324 : : }
325 : :
326 : 0 : ret = ice_add_adv_rule(hw, list, lkups_cnt, rule_info, &rule_added);
327 [ # # ]: 0 : if (!ret) {
328 : 0 : filter_conf_ptr = rte_zmalloc("ice_switch_filter",
329 : : sizeof(struct ice_switch_filter_conf), 0);
330 [ # # ]: 0 : if (!filter_conf_ptr) {
331 : 0 : rte_flow_error_set(error, EINVAL,
332 : : RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
333 : : "No memory for ice_switch_filter");
334 : 0 : goto error;
335 : : }
336 : :
337 : 0 : filter_conf_ptr->sw_query_data = rule_added;
338 : :
339 : 0 : filter_conf_ptr->vsi_num =
340 : 0 : ice_get_hw_vsi_num(hw, rule_info->sw_act.vsi_handle);
341 : 0 : filter_conf_ptr->lkups = list;
342 : 0 : filter_conf_ptr->lkups_num = lkups_cnt;
343 : 0 : filter_conf_ptr->rule_info = *rule_info;
344 : :
345 : 0 : filter_conf_ptr->fltr_status = ICE_SW_FLTR_ADDED;
346 : :
347 : 0 : flow->rule = filter_conf_ptr;
348 : : } else {
349 [ # # ]: 0 : if (ice_dcf_adminq_need_retry(ad))
350 : : ret = -EAGAIN;
351 : : else
352 : : ret = -EINVAL;
353 : :
354 : 0 : rte_flow_error_set(error, -ret,
355 : : RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
356 : : "switch filter create flow fail");
357 : 0 : goto error;
358 : : }
359 : :
360 : 0 : rte_free(meta);
361 : 0 : return 0;
362 : :
363 : 0 : error:
364 : 0 : rte_free(list);
365 : 0 : rte_free(meta);
366 : :
367 : 0 : return -rte_errno;
368 : : }
369 : :
370 : : static inline void
371 : 0 : ice_switch_filter_rule_free(struct rte_flow *flow)
372 : : {
373 : 0 : struct ice_switch_filter_conf *filter_conf_ptr =
374 : : (struct ice_switch_filter_conf *)flow->rule;
375 : :
376 [ # # ]: 0 : if (filter_conf_ptr)
377 : 0 : rte_free(filter_conf_ptr->lkups);
378 : :
379 : 0 : rte_free(filter_conf_ptr);
380 : 0 : }
381 : :
382 : : static int
383 : 0 : ice_switch_destroy(struct ice_adapter *ad,
384 : : struct rte_flow *flow,
385 : : struct rte_flow_error *error)
386 : : {
387 : 0 : struct ice_hw *hw = &ad->hw;
388 : : int ret;
389 : : struct ice_switch_filter_conf *filter_conf_ptr;
390 : :
391 : 0 : filter_conf_ptr = (struct ice_switch_filter_conf *)
392 : : flow->rule;
393 : :
394 [ # # ]: 0 : if (!filter_conf_ptr ||
395 [ # # ]: 0 : filter_conf_ptr->fltr_status == ICE_SW_FLTR_ADD_FAILED_ON_RIDRECT) {
396 : 0 : rte_flow_error_set(error, EINVAL,
397 : : RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
398 : : "no such flow"
399 : : " create by switch filter");
400 : :
401 : 0 : ice_switch_filter_rule_free(flow);
402 : :
403 : 0 : return -rte_errno;
404 : : }
405 : :
406 [ # # ]: 0 : if (ice_dcf_adminq_need_retry(ad)) {
407 : 0 : rte_flow_error_set(error, EAGAIN,
408 : : RTE_FLOW_ERROR_TYPE_ITEM, NULL,
409 : : "DCF is not on");
410 : 0 : return -rte_errno;
411 : : }
412 : :
413 : 0 : ret = ice_rem_adv_rule_by_id(hw, &filter_conf_ptr->sw_query_data);
414 [ # # ]: 0 : if (ret) {
415 [ # # ]: 0 : if (ice_dcf_adminq_need_retry(ad))
416 : : ret = -EAGAIN;
417 : : else
418 : : ret = -EINVAL;
419 : :
420 : 0 : rte_flow_error_set(error, -ret,
421 : : RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
422 : : "fail to destroy switch filter rule");
423 : 0 : return -rte_errno;
424 : : }
425 : :
426 : 0 : ice_switch_filter_rule_free(flow);
427 : 0 : return ret;
428 : : }
429 : :
430 : : static bool
431 : 0 : ice_switch_parse_pattern(const struct rte_flow_item pattern[],
432 : : struct rte_flow_error *error,
433 : : struct ice_adv_lkup_elem *list,
434 : : uint16_t *lkups_num,
435 : : enum ice_sw_tunnel_type *tun_type,
436 : : const struct ice_pattern_match_item *pattern_match_item)
437 : : {
438 : : const struct rte_flow_item *item = pattern;
439 : : enum rte_flow_item_type item_type;
440 : : const struct rte_flow_item_eth *eth_spec, *eth_mask;
441 : : const struct rte_flow_item_ipv4 *ipv4_spec, *ipv4_mask;
442 : : const struct rte_flow_item_ipv6 *ipv6_spec, *ipv6_mask;
443 : : const struct rte_flow_item_tcp *tcp_spec, *tcp_mask;
444 : : const struct rte_flow_item_udp *udp_spec, *udp_mask;
445 : : const struct rte_flow_item_sctp *sctp_spec, *sctp_mask;
446 : : const struct rte_flow_item_nvgre *nvgre_spec, *nvgre_mask;
447 : : const struct rte_flow_item_vxlan *vxlan_spec, *vxlan_mask;
448 : : const struct rte_flow_item_vlan *vlan_spec, *vlan_mask;
449 : : const struct rte_flow_item_pppoe *pppoe_spec, *pppoe_mask;
450 : : const struct rte_flow_item_pppoe_proto_id *pppoe_proto_spec,
451 : : *pppoe_proto_mask;
452 : : const struct rte_flow_item_esp *esp_spec, *esp_mask;
453 : : const struct rte_flow_item_ah *ah_spec, *ah_mask;
454 : : const struct rte_flow_item_l2tpv3oip *l2tp_spec, *l2tp_mask;
455 : : const struct rte_flow_item_pfcp *pfcp_spec, *pfcp_mask;
456 : : const struct rte_flow_item_gtp *gtp_spec, *gtp_mask;
457 : : const struct rte_flow_item_gtp_psc *gtp_psc_spec, *gtp_psc_mask;
458 : 0 : uint64_t outer_input_set = ICE_INSET_NONE;
459 : 0 : uint64_t inner_input_set = ICE_INSET_NONE;
460 : : uint64_t *input = NULL;
461 : : uint16_t input_set_byte = 0;
462 : : bool pppoe_elem_valid = 0;
463 : : bool pppoe_patt_valid = 0;
464 : : bool pppoe_prot_valid = 0;
465 : : bool inner_vlan_valid = 0;
466 : : bool outer_vlan_valid = 0;
467 : : bool tunnel_valid = 0;
468 : : bool profile_rule = 0;
469 : : bool nvgre_valid = 0;
470 : : bool vxlan_valid = 0;
471 : : bool qinq_valid = 0;
472 : : bool ipv6_valid = 0;
473 : : bool ipv4_valid = 0;
474 : : bool udp_valid = 0;
475 : : bool tcp_valid = 0;
476 : : bool gtpu_valid = 0;
477 : : bool gtpu_psc_valid = 0;
478 : : bool inner_ipv4_valid = 0;
479 : : bool inner_ipv6_valid = 0;
480 : : bool inner_tcp_valid = 0;
481 : : bool inner_udp_valid = 0;
482 : : uint16_t j, k, t = 0;
483 : :
484 [ # # ]: 0 : if (*tun_type == ICE_SW_TUN_AND_NON_TUN_QINQ ||
485 : : *tun_type == ICE_NON_TUN_QINQ)
486 : : qinq_valid = 1;
487 : :
488 [ # # ]: 0 : for (item = pattern; item->type !=
489 : 0 : RTE_FLOW_ITEM_TYPE_END; item++) {
490 [ # # ]: 0 : if (item->last) {
491 : 0 : rte_flow_error_set(error, EINVAL,
492 : : RTE_FLOW_ERROR_TYPE_ITEM,
493 : : item,
494 : : "Not support range");
495 : 0 : return false;
496 : : }
497 : : item_type = item->type;
498 : :
499 [ # # # # : 0 : switch (item_type) {
# # # # #
# # # # #
# # # # #
# ]
500 : 0 : case RTE_FLOW_ITEM_TYPE_ANY:
501 : 0 : *tun_type = ICE_SW_TUN_AND_NON_TUN;
502 : 0 : break;
503 : :
504 : 0 : case RTE_FLOW_ITEM_TYPE_ETH:
505 : 0 : eth_spec = item->spec;
506 : 0 : eth_mask = item->mask;
507 [ # # ]: 0 : if (eth_spec && eth_mask) {
508 : 0 : const uint8_t *a = eth_mask->hdr.src_addr.addr_bytes;
509 : 0 : const uint8_t *b = eth_mask->hdr.dst_addr.addr_bytes;
510 [ # # ]: 0 : if (tunnel_valid)
511 : : input = &inner_input_set;
512 : : else
513 : : input = &outer_input_set;
514 [ # # ]: 0 : for (j = 0; j < RTE_ETHER_ADDR_LEN; j++) {
515 [ # # ]: 0 : if (a[j]) {
516 : 0 : *input |= ICE_INSET_SMAC;
517 : 0 : break;
518 : : }
519 : : }
520 [ # # ]: 0 : for (j = 0; j < RTE_ETHER_ADDR_LEN; j++) {
521 [ # # ]: 0 : if (b[j]) {
522 : 0 : *input |= ICE_INSET_DMAC;
523 : 0 : break;
524 : : }
525 : : }
526 [ # # ]: 0 : if (eth_mask->hdr.ether_type)
527 : 0 : *input |= ICE_INSET_ETHERTYPE;
528 : 0 : list[t].type = (tunnel_valid == 0) ?
529 [ # # ]: 0 : ICE_MAC_OFOS : ICE_MAC_IL;
530 : : struct ice_ether_hdr *h;
531 : : struct ice_ether_hdr *m;
532 : : uint16_t i = 0;
533 : : h = &list[t].h_u.eth_hdr;
534 : : m = &list[t].m_u.eth_hdr;
535 [ # # ]: 0 : for (j = 0; j < RTE_ETHER_ADDR_LEN; j++) {
536 [ # # ]: 0 : if (eth_mask->hdr.src_addr.addr_bytes[j]) {
537 : 0 : h->src_addr[j] =
538 : 0 : eth_spec->hdr.src_addr.addr_bytes[j];
539 : 0 : m->src_addr[j] =
540 : : eth_mask->hdr.src_addr.addr_bytes[j];
541 : : i = 1;
542 : 0 : input_set_byte++;
543 : : }
544 [ # # ]: 0 : if (eth_mask->hdr.dst_addr.addr_bytes[j]) {
545 : 0 : h->dst_addr[j] =
546 : 0 : eth_spec->hdr.dst_addr.addr_bytes[j];
547 : 0 : m->dst_addr[j] =
548 : : eth_mask->hdr.dst_addr.addr_bytes[j];
549 : : i = 1;
550 : 0 : input_set_byte++;
551 : : }
552 : : }
553 [ # # ]: 0 : if (i)
554 : 0 : t++;
555 [ # # ]: 0 : if (eth_mask->hdr.ether_type) {
556 : 0 : list[t].type = ICE_ETYPE_OL;
557 : 0 : list[t].h_u.ethertype.ethtype_id =
558 : 0 : eth_spec->hdr.ether_type;
559 : 0 : list[t].m_u.ethertype.ethtype_id =
560 : : eth_mask->hdr.ether_type;
561 : 0 : input_set_byte += 2;
562 : 0 : t++;
563 : : }
564 : : }
565 : : break;
566 : :
567 : 0 : case RTE_FLOW_ITEM_TYPE_IPV4:
568 : 0 : ipv4_spec = item->spec;
569 : 0 : ipv4_mask = item->mask;
570 [ # # ]: 0 : if (tunnel_valid) {
571 : : inner_ipv4_valid = 1;
572 : : input = &inner_input_set;
573 : : } else {
574 : : ipv4_valid = 1;
575 : : input = &outer_input_set;
576 : : }
577 : :
578 [ # # ]: 0 : if (ipv4_spec && ipv4_mask) {
579 : : /* Check IPv4 mask and update input set */
580 [ # # ]: 0 : if (ipv4_mask->hdr.version_ihl ||
581 [ # # ]: 0 : ipv4_mask->hdr.total_length ||
582 [ # # ]: 0 : ipv4_mask->hdr.packet_id ||
583 [ # # ]: 0 : ipv4_mask->hdr.hdr_checksum) {
584 : 0 : rte_flow_error_set(error, EINVAL,
585 : : RTE_FLOW_ERROR_TYPE_ITEM,
586 : : item,
587 : : "Invalid IPv4 mask.");
588 : 0 : return false;
589 : : }
590 : :
591 [ # # ]: 0 : if (ipv4_mask->hdr.src_addr)
592 : 0 : *input |= ICE_INSET_IPV4_SRC;
593 [ # # ]: 0 : if (ipv4_mask->hdr.dst_addr)
594 : 0 : *input |= ICE_INSET_IPV4_DST;
595 [ # # ]: 0 : if (ipv4_mask->hdr.time_to_live)
596 : 0 : *input |= ICE_INSET_IPV4_TTL;
597 [ # # ]: 0 : if (ipv4_mask->hdr.next_proto_id)
598 : 0 : *input |= ICE_INSET_IPV4_PROTO;
599 [ # # ]: 0 : if (ipv4_mask->hdr.type_of_service)
600 : 0 : *input |= ICE_INSET_IPV4_TOS;
601 : :
602 : 0 : list[t].type = (tunnel_valid == 0) ?
603 [ # # ]: 0 : ICE_IPV4_OFOS : ICE_IPV4_IL;
604 [ # # ]: 0 : if (ipv4_mask->hdr.src_addr) {
605 : 0 : list[t].h_u.ipv4_hdr.src_addr =
606 : 0 : ipv4_spec->hdr.src_addr;
607 : 0 : list[t].m_u.ipv4_hdr.src_addr =
608 : : ipv4_mask->hdr.src_addr;
609 : 0 : input_set_byte += 2;
610 : : }
611 [ # # ]: 0 : if (ipv4_mask->hdr.dst_addr) {
612 : 0 : list[t].h_u.ipv4_hdr.dst_addr =
613 : 0 : ipv4_spec->hdr.dst_addr;
614 : 0 : list[t].m_u.ipv4_hdr.dst_addr =
615 : : ipv4_mask->hdr.dst_addr;
616 : 0 : input_set_byte += 2;
617 : : }
618 [ # # ]: 0 : if (ipv4_mask->hdr.time_to_live) {
619 : 0 : list[t].h_u.ipv4_hdr.time_to_live =
620 : 0 : ipv4_spec->hdr.time_to_live;
621 : 0 : list[t].m_u.ipv4_hdr.time_to_live =
622 : : ipv4_mask->hdr.time_to_live;
623 : 0 : input_set_byte++;
624 : : }
625 [ # # ]: 0 : if (ipv4_mask->hdr.next_proto_id) {
626 : 0 : list[t].h_u.ipv4_hdr.protocol =
627 : 0 : ipv4_spec->hdr.next_proto_id;
628 : 0 : list[t].m_u.ipv4_hdr.protocol =
629 : : ipv4_mask->hdr.next_proto_id;
630 : 0 : input_set_byte++;
631 : : }
632 : 0 : if ((ipv4_spec->hdr.next_proto_id &
633 [ # # ]: 0 : ipv4_mask->hdr.next_proto_id) ==
634 : : ICE_IPV4_PROTO_NVGRE)
635 : 0 : *tun_type = ICE_SW_TUN_AND_NON_TUN;
636 [ # # ]: 0 : if (ipv4_mask->hdr.type_of_service) {
637 : 0 : list[t].h_u.ipv4_hdr.tos =
638 : 0 : ipv4_spec->hdr.type_of_service;
639 : 0 : list[t].m_u.ipv4_hdr.tos =
640 : : ipv4_mask->hdr.type_of_service;
641 : 0 : input_set_byte++;
642 : : }
643 : 0 : t++;
644 : : }
645 : : break;
646 : :
647 : 0 : case RTE_FLOW_ITEM_TYPE_IPV6:
648 : 0 : ipv6_spec = item->spec;
649 : 0 : ipv6_mask = item->mask;
650 [ # # ]: 0 : if (tunnel_valid) {
651 : : inner_ipv6_valid = 1;
652 : : input = &inner_input_set;
653 : : } else {
654 : : ipv6_valid = 1;
655 : : input = &outer_input_set;
656 : : }
657 : :
658 [ # # ]: 0 : if (ipv6_spec && ipv6_mask) {
659 [ # # ]: 0 : if (ipv6_mask->hdr.payload_len) {
660 : 0 : rte_flow_error_set(error, EINVAL,
661 : : RTE_FLOW_ERROR_TYPE_ITEM,
662 : : item,
663 : : "Invalid IPv6 mask");
664 : 0 : return false;
665 : : }
666 : :
667 [ # # ]: 0 : for (j = 0; j < ICE_IPV6_ADDR_LENGTH; j++) {
668 [ # # ]: 0 : if (ipv6_mask->hdr.src_addr[j]) {
669 : 0 : *input |= ICE_INSET_IPV6_SRC;
670 : 0 : break;
671 : : }
672 : : }
673 [ # # ]: 0 : for (j = 0; j < ICE_IPV6_ADDR_LENGTH; j++) {
674 [ # # ]: 0 : if (ipv6_mask->hdr.dst_addr[j]) {
675 : 0 : *input |= ICE_INSET_IPV6_DST;
676 : 0 : break;
677 : : }
678 : : }
679 [ # # ]: 0 : if (ipv6_mask->hdr.proto)
680 : 0 : *input |= ICE_INSET_IPV6_NEXT_HDR;
681 [ # # ]: 0 : if (ipv6_mask->hdr.hop_limits)
682 : 0 : *input |= ICE_INSET_IPV6_HOP_LIMIT;
683 [ # # ]: 0 : if (ipv6_mask->hdr.vtc_flow &
684 : : rte_cpu_to_be_32(RTE_IPV6_HDR_TC_MASK))
685 : 0 : *input |= ICE_INSET_IPV6_TC;
686 : :
687 : 0 : list[t].type = (tunnel_valid == 0) ?
688 [ # # ]: 0 : ICE_IPV6_OFOS : ICE_IPV6_IL;
689 : : struct ice_ipv6_hdr *f;
690 : : struct ice_ipv6_hdr *s;
691 : : f = &list[t].h_u.ipv6_hdr;
692 : : s = &list[t].m_u.ipv6_hdr;
693 [ # # ]: 0 : for (j = 0; j < ICE_IPV6_ADDR_LENGTH; j++) {
694 [ # # ]: 0 : if (ipv6_mask->hdr.src_addr[j]) {
695 : 0 : f->src_addr[j] =
696 : 0 : ipv6_spec->hdr.src_addr[j];
697 : 0 : s->src_addr[j] =
698 : : ipv6_mask->hdr.src_addr[j];
699 : 0 : input_set_byte++;
700 : : }
701 [ # # ]: 0 : if (ipv6_mask->hdr.dst_addr[j]) {
702 : 0 : f->dst_addr[j] =
703 : 0 : ipv6_spec->hdr.dst_addr[j];
704 : 0 : s->dst_addr[j] =
705 : : ipv6_mask->hdr.dst_addr[j];
706 : 0 : input_set_byte++;
707 : : }
708 : : }
709 [ # # ]: 0 : if (ipv6_mask->hdr.proto) {
710 : 0 : f->next_hdr =
711 : 0 : ipv6_spec->hdr.proto;
712 : 0 : s->next_hdr =
713 : : ipv6_mask->hdr.proto;
714 : 0 : input_set_byte++;
715 : : }
716 [ # # ]: 0 : if (ipv6_mask->hdr.hop_limits) {
717 : 0 : f->hop_limit =
718 : 0 : ipv6_spec->hdr.hop_limits;
719 : 0 : s->hop_limit =
720 : : ipv6_mask->hdr.hop_limits;
721 : 0 : input_set_byte++;
722 : : }
723 [ # # ]: 0 : if (ipv6_mask->hdr.vtc_flow &
724 : : rte_cpu_to_be_32
725 : : (RTE_IPV6_HDR_TC_MASK)) {
726 : : struct ice_le_ver_tc_flow vtf;
727 : 0 : vtf.u.fld.version = 0;
728 : 0 : vtf.u.fld.flow_label = 0;
729 [ # # ]: 0 : vtf.u.fld.tc = (rte_be_to_cpu_32
730 : : (ipv6_spec->hdr.vtc_flow) &
731 : 0 : RTE_IPV6_HDR_TC_MASK) >>
732 : : RTE_IPV6_HDR_TC_SHIFT;
733 [ # # ]: 0 : f->be_ver_tc_flow = CPU_TO_BE32(vtf.u.val);
734 [ # # ]: 0 : vtf.u.fld.tc = (rte_be_to_cpu_32
735 : : (ipv6_mask->hdr.vtc_flow) &
736 : 0 : RTE_IPV6_HDR_TC_MASK) >>
737 : : RTE_IPV6_HDR_TC_SHIFT;
738 [ # # ]: 0 : s->be_ver_tc_flow = CPU_TO_BE32(vtf.u.val);
739 : 0 : input_set_byte += 4;
740 : : }
741 : 0 : t++;
742 : : }
743 : : break;
744 : :
745 : 0 : case RTE_FLOW_ITEM_TYPE_UDP:
746 : 0 : udp_spec = item->spec;
747 : 0 : udp_mask = item->mask;
748 [ # # ]: 0 : if (tunnel_valid) {
749 : : inner_udp_valid = 1;
750 : : input = &inner_input_set;
751 : : } else {
752 : : udp_valid = 1;
753 : : input = &outer_input_set;
754 : : }
755 : :
756 [ # # ]: 0 : if (udp_spec && udp_mask) {
757 : : /* Check UDP mask and update input set*/
758 [ # # ]: 0 : if (udp_mask->hdr.dgram_len ||
759 [ # # ]: 0 : udp_mask->hdr.dgram_cksum) {
760 : 0 : rte_flow_error_set(error, EINVAL,
761 : : RTE_FLOW_ERROR_TYPE_ITEM,
762 : : item,
763 : : "Invalid UDP mask");
764 : 0 : return false;
765 : : }
766 : :
767 [ # # ]: 0 : if (udp_mask->hdr.src_port)
768 : 0 : *input |= ICE_INSET_UDP_SRC_PORT;
769 [ # # ]: 0 : if (udp_mask->hdr.dst_port)
770 : 0 : *input |= ICE_INSET_UDP_DST_PORT;
771 : :
772 [ # # # # ]: 0 : if (*tun_type == ICE_SW_TUN_VXLAN &&
773 : : tunnel_valid == 0)
774 : 0 : list[t].type = ICE_UDP_OF;
775 : : else
776 : 0 : list[t].type = ICE_UDP_ILOS;
777 [ # # ]: 0 : if (udp_mask->hdr.src_port) {
778 : 0 : list[t].h_u.l4_hdr.src_port =
779 : 0 : udp_spec->hdr.src_port;
780 : 0 : list[t].m_u.l4_hdr.src_port =
781 : : udp_mask->hdr.src_port;
782 : 0 : input_set_byte += 2;
783 : : }
784 [ # # ]: 0 : if (udp_mask->hdr.dst_port) {
785 : 0 : list[t].h_u.l4_hdr.dst_port =
786 : 0 : udp_spec->hdr.dst_port;
787 : 0 : list[t].m_u.l4_hdr.dst_port =
788 : : udp_mask->hdr.dst_port;
789 : 0 : input_set_byte += 2;
790 : : }
791 : 0 : t++;
792 : : }
793 : : break;
794 : :
795 : 0 : case RTE_FLOW_ITEM_TYPE_TCP:
796 : 0 : tcp_spec = item->spec;
797 : 0 : tcp_mask = item->mask;
798 [ # # ]: 0 : if (tunnel_valid) {
799 : : inner_tcp_valid = 1;
800 : : input = &inner_input_set;
801 : : } else {
802 : : tcp_valid = 1;
803 : : input = &outer_input_set;
804 : : }
805 : :
806 [ # # ]: 0 : if (tcp_spec && tcp_mask) {
807 : : /* Check TCP mask and update input set */
808 [ # # ]: 0 : if (tcp_mask->hdr.sent_seq ||
809 [ # # ]: 0 : tcp_mask->hdr.recv_ack ||
810 [ # # ]: 0 : tcp_mask->hdr.data_off ||
811 [ # # ]: 0 : tcp_mask->hdr.tcp_flags ||
812 [ # # ]: 0 : tcp_mask->hdr.rx_win ||
813 [ # # ]: 0 : tcp_mask->hdr.cksum ||
814 [ # # ]: 0 : tcp_mask->hdr.tcp_urp) {
815 : 0 : rte_flow_error_set(error, EINVAL,
816 : : RTE_FLOW_ERROR_TYPE_ITEM,
817 : : item,
818 : : "Invalid TCP mask");
819 : 0 : return false;
820 : : }
821 : :
822 [ # # ]: 0 : if (tcp_mask->hdr.src_port)
823 : 0 : *input |= ICE_INSET_TCP_SRC_PORT;
824 [ # # ]: 0 : if (tcp_mask->hdr.dst_port)
825 : 0 : *input |= ICE_INSET_TCP_DST_PORT;
826 : 0 : list[t].type = ICE_TCP_IL;
827 [ # # ]: 0 : if (tcp_mask->hdr.src_port) {
828 : 0 : list[t].h_u.l4_hdr.src_port =
829 : 0 : tcp_spec->hdr.src_port;
830 : 0 : list[t].m_u.l4_hdr.src_port =
831 : : tcp_mask->hdr.src_port;
832 : 0 : input_set_byte += 2;
833 : : }
834 [ # # ]: 0 : if (tcp_mask->hdr.dst_port) {
835 : 0 : list[t].h_u.l4_hdr.dst_port =
836 : 0 : tcp_spec->hdr.dst_port;
837 : 0 : list[t].m_u.l4_hdr.dst_port =
838 : : tcp_mask->hdr.dst_port;
839 : 0 : input_set_byte += 2;
840 : : }
841 : 0 : t++;
842 : : }
843 : : break;
844 : :
845 : 0 : case RTE_FLOW_ITEM_TYPE_SCTP:
846 : 0 : sctp_spec = item->spec;
847 : 0 : sctp_mask = item->mask;
848 [ # # ]: 0 : if (sctp_spec && sctp_mask) {
849 : : /* Check SCTP mask and update input set */
850 [ # # ]: 0 : if (sctp_mask->hdr.cksum) {
851 : 0 : rte_flow_error_set(error, EINVAL,
852 : : RTE_FLOW_ERROR_TYPE_ITEM,
853 : : item,
854 : : "Invalid SCTP mask");
855 : 0 : return false;
856 : : }
857 [ # # ]: 0 : if (tunnel_valid)
858 : : input = &inner_input_set;
859 : : else
860 : : input = &outer_input_set;
861 : :
862 [ # # ]: 0 : if (sctp_mask->hdr.src_port)
863 : 0 : *input |= ICE_INSET_SCTP_SRC_PORT;
864 [ # # ]: 0 : if (sctp_mask->hdr.dst_port)
865 : 0 : *input |= ICE_INSET_SCTP_DST_PORT;
866 : :
867 : 0 : list[t].type = ICE_SCTP_IL;
868 [ # # ]: 0 : if (sctp_mask->hdr.src_port) {
869 : 0 : list[t].h_u.sctp_hdr.src_port =
870 : 0 : sctp_spec->hdr.src_port;
871 : 0 : list[t].m_u.sctp_hdr.src_port =
872 : : sctp_mask->hdr.src_port;
873 : 0 : input_set_byte += 2;
874 : : }
875 [ # # ]: 0 : if (sctp_mask->hdr.dst_port) {
876 : 0 : list[t].h_u.sctp_hdr.dst_port =
877 : 0 : sctp_spec->hdr.dst_port;
878 : 0 : list[t].m_u.sctp_hdr.dst_port =
879 : : sctp_mask->hdr.dst_port;
880 : 0 : input_set_byte += 2;
881 : : }
882 : 0 : t++;
883 : : }
884 : : break;
885 : :
886 : 0 : case RTE_FLOW_ITEM_TYPE_VXLAN:
887 : 0 : vxlan_spec = item->spec;
888 : 0 : vxlan_mask = item->mask;
889 : : /* Check if VXLAN item is used to describe protocol.
890 : : * If yes, both spec and mask should be NULL.
891 : : * If no, both spec and mask shouldn't be NULL.
892 : : */
893 [ # # ]: 0 : if ((!vxlan_spec && vxlan_mask) ||
894 : : (vxlan_spec && !vxlan_mask)) {
895 : 0 : rte_flow_error_set(error, EINVAL,
896 : : RTE_FLOW_ERROR_TYPE_ITEM,
897 : : item,
898 : : "Invalid VXLAN item");
899 : 0 : return false;
900 : : }
901 : : vxlan_valid = 1;
902 : : tunnel_valid = 1;
903 : : input = &inner_input_set;
904 [ # # ]: 0 : if (vxlan_spec && vxlan_mask) {
905 : 0 : list[t].type = ICE_VXLAN;
906 [ # # ]: 0 : if (vxlan_mask->hdr.vni[0] ||
907 [ # # ]: 0 : vxlan_mask->hdr.vni[1] ||
908 [ # # ]: 0 : vxlan_mask->hdr.vni[2]) {
909 : 0 : list[t].h_u.tnl_hdr.vni =
910 : 0 : (vxlan_spec->hdr.vni[2] << 16) |
911 : 0 : (vxlan_spec->hdr.vni[1] << 8) |
912 : 0 : vxlan_spec->hdr.vni[0];
913 : 0 : list[t].m_u.tnl_hdr.vni =
914 : 0 : (vxlan_mask->hdr.vni[2] << 16) |
915 : 0 : (vxlan_mask->hdr.vni[1] << 8) |
916 : 0 : vxlan_mask->hdr.vni[0];
917 : 0 : *input |= ICE_INSET_VXLAN_VNI;
918 : 0 : input_set_byte += 2;
919 : : }
920 : 0 : t++;
921 : : }
922 : : break;
923 : :
924 : 0 : case RTE_FLOW_ITEM_TYPE_NVGRE:
925 : 0 : nvgre_spec = item->spec;
926 : 0 : nvgre_mask = item->mask;
927 : : /* Check if NVGRE item is used to describe protocol.
928 : : * If yes, both spec and mask should be NULL.
929 : : * If no, both spec and mask shouldn't be NULL.
930 : : */
931 [ # # ]: 0 : if ((!nvgre_spec && nvgre_mask) ||
932 : : (nvgre_spec && !nvgre_mask)) {
933 : 0 : rte_flow_error_set(error, EINVAL,
934 : : RTE_FLOW_ERROR_TYPE_ITEM,
935 : : item,
936 : : "Invalid NVGRE item");
937 : 0 : return false;
938 : : }
939 : : nvgre_valid = 1;
940 : : tunnel_valid = 1;
941 : : input = &inner_input_set;
942 [ # # ]: 0 : if (nvgre_spec && nvgre_mask) {
943 : 0 : list[t].type = ICE_NVGRE;
944 [ # # ]: 0 : if (nvgre_mask->tni[0] ||
945 : 0 : nvgre_mask->tni[1] ||
946 [ # # ]: 0 : nvgre_mask->tni[2]) {
947 : 0 : list[t].h_u.nvgre_hdr.tni_flow =
948 : 0 : (nvgre_spec->tni[2] << 16) |
949 : 0 : (nvgre_spec->tni[1] << 8) |
950 : 0 : nvgre_spec->tni[0];
951 : 0 : list[t].m_u.nvgre_hdr.tni_flow =
952 : 0 : (nvgre_mask->tni[2] << 16) |
953 : 0 : (nvgre_mask->tni[1] << 8) |
954 : 0 : nvgre_mask->tni[0];
955 : 0 : *input |= ICE_INSET_NVGRE_TNI;
956 : 0 : input_set_byte += 2;
957 : : }
958 : 0 : t++;
959 : : }
960 : : break;
961 : :
962 : 0 : case RTE_FLOW_ITEM_TYPE_VLAN:
963 : 0 : vlan_spec = item->spec;
964 : 0 : vlan_mask = item->mask;
965 : : /* Check if VLAN item is used to describe protocol.
966 : : * If yes, both spec and mask should be NULL.
967 : : * If no, both spec and mask shouldn't be NULL.
968 : : */
969 [ # # ]: 0 : if ((!vlan_spec && vlan_mask) ||
970 : : (vlan_spec && !vlan_mask)) {
971 : 0 : rte_flow_error_set(error, EINVAL,
972 : : RTE_FLOW_ERROR_TYPE_ITEM,
973 : : item,
974 : : "Invalid VLAN item");
975 : 0 : return false;
976 : : }
977 : :
978 [ # # ]: 0 : if (qinq_valid) {
979 [ # # ]: 0 : if (!outer_vlan_valid)
980 : : outer_vlan_valid = 1;
981 : : else
982 : : inner_vlan_valid = 1;
983 : : }
984 : :
985 : : input = &outer_input_set;
986 : :
987 [ # # ]: 0 : if (vlan_spec && vlan_mask) {
988 [ # # ]: 0 : if (qinq_valid) {
989 [ # # ]: 0 : if (!inner_vlan_valid) {
990 : 0 : list[t].type = ICE_VLAN_EX;
991 : 0 : *input |=
992 : : ICE_INSET_VLAN_OUTER;
993 : : } else {
994 : 0 : list[t].type = ICE_VLAN_IN;
995 : 0 : *input |=
996 : : ICE_INSET_VLAN_INNER;
997 : : }
998 : : } else {
999 : 0 : list[t].type = ICE_VLAN_OFOS;
1000 : 0 : *input |= ICE_INSET_VLAN_INNER;
1001 : : }
1002 : :
1003 [ # # ]: 0 : if (vlan_mask->hdr.vlan_tci) {
1004 : 0 : list[t].h_u.vlan_hdr.vlan =
1005 : 0 : vlan_spec->hdr.vlan_tci;
1006 : 0 : list[t].m_u.vlan_hdr.vlan =
1007 : : vlan_mask->hdr.vlan_tci;
1008 : 0 : input_set_byte += 2;
1009 : : }
1010 [ # # ]: 0 : if (vlan_mask->hdr.eth_proto) {
1011 : 0 : rte_flow_error_set(error, EINVAL,
1012 : : RTE_FLOW_ERROR_TYPE_ITEM,
1013 : : item,
1014 : : "Invalid VLAN input set.");
1015 : 0 : return false;
1016 : : }
1017 : 0 : t++;
1018 : : }
1019 : : break;
1020 : :
1021 : 0 : case RTE_FLOW_ITEM_TYPE_PPPOED:
1022 : : case RTE_FLOW_ITEM_TYPE_PPPOES:
1023 : 0 : pppoe_spec = item->spec;
1024 : 0 : pppoe_mask = item->mask;
1025 : : /* Check if PPPoE item is used to describe protocol.
1026 : : * If yes, both spec and mask should be NULL.
1027 : : * If no, both spec and mask shouldn't be NULL.
1028 : : */
1029 [ # # ]: 0 : if ((!pppoe_spec && pppoe_mask) ||
1030 : : (pppoe_spec && !pppoe_mask)) {
1031 : 0 : rte_flow_error_set(error, EINVAL,
1032 : : RTE_FLOW_ERROR_TYPE_ITEM,
1033 : : item,
1034 : : "Invalid pppoe item");
1035 : 0 : return false;
1036 : : }
1037 : : pppoe_patt_valid = 1;
1038 : : input = &outer_input_set;
1039 [ # # ]: 0 : if (pppoe_spec && pppoe_mask) {
1040 : : /* Check pppoe mask and update input set */
1041 [ # # ]: 0 : if (pppoe_mask->length ||
1042 [ # # ]: 0 : pppoe_mask->code ||
1043 : : pppoe_mask->version_type) {
1044 : 0 : rte_flow_error_set(error, EINVAL,
1045 : : RTE_FLOW_ERROR_TYPE_ITEM,
1046 : : item,
1047 : : "Invalid pppoe mask");
1048 : 0 : return false;
1049 : : }
1050 : 0 : list[t].type = ICE_PPPOE;
1051 [ # # ]: 0 : if (pppoe_mask->session_id) {
1052 : 0 : list[t].h_u.pppoe_hdr.session_id =
1053 : 0 : pppoe_spec->session_id;
1054 : 0 : list[t].m_u.pppoe_hdr.session_id =
1055 : : pppoe_mask->session_id;
1056 : 0 : *input |= ICE_INSET_PPPOE_SESSION;
1057 : 0 : input_set_byte += 2;
1058 : : }
1059 : 0 : t++;
1060 : : pppoe_elem_valid = 1;
1061 : : }
1062 : : break;
1063 : :
1064 : 0 : case RTE_FLOW_ITEM_TYPE_PPPOE_PROTO_ID:
1065 : 0 : pppoe_proto_spec = item->spec;
1066 : 0 : pppoe_proto_mask = item->mask;
1067 : : /* Check if PPPoE optional proto_id item
1068 : : * is used to describe protocol.
1069 : : * If yes, both spec and mask should be NULL.
1070 : : * If no, both spec and mask shouldn't be NULL.
1071 : : */
1072 [ # # ]: 0 : if ((!pppoe_proto_spec && pppoe_proto_mask) ||
1073 : : (pppoe_proto_spec && !pppoe_proto_mask)) {
1074 : 0 : rte_flow_error_set(error, EINVAL,
1075 : : RTE_FLOW_ERROR_TYPE_ITEM,
1076 : : item,
1077 : : "Invalid pppoe proto item");
1078 : 0 : return false;
1079 : : }
1080 : : input = &outer_input_set;
1081 [ # # ]: 0 : if (pppoe_proto_spec && pppoe_proto_mask) {
1082 [ # # ]: 0 : if (pppoe_elem_valid)
1083 : 0 : t--;
1084 : 0 : list[t].type = ICE_PPPOE;
1085 [ # # ]: 0 : if (pppoe_proto_mask->proto_id) {
1086 : 0 : list[t].h_u.pppoe_hdr.ppp_prot_id =
1087 : 0 : pppoe_proto_spec->proto_id;
1088 : 0 : list[t].m_u.pppoe_hdr.ppp_prot_id =
1089 : : pppoe_proto_mask->proto_id;
1090 : 0 : *input |= ICE_INSET_PPPOE_PROTO;
1091 : 0 : input_set_byte += 2;
1092 : : pppoe_prot_valid = 1;
1093 : : }
1094 : 0 : if ((pppoe_proto_mask->proto_id &
1095 [ # # ]: 0 : pppoe_proto_spec->proto_id) !=
1096 [ # # ]: 0 : CPU_TO_BE16(ICE_PPP_IPV4_PROTO) &&
1097 : : (pppoe_proto_mask->proto_id &
1098 : : pppoe_proto_spec->proto_id) !=
1099 : : CPU_TO_BE16(ICE_PPP_IPV6_PROTO))
1100 : 0 : *tun_type = ICE_SW_TUN_PPPOE_PAY;
1101 : : else
1102 : 0 : *tun_type = ICE_SW_TUN_PPPOE;
1103 : 0 : t++;
1104 : : }
1105 : :
1106 : : break;
1107 : :
1108 : 0 : case RTE_FLOW_ITEM_TYPE_ESP:
1109 : 0 : esp_spec = item->spec;
1110 : 0 : esp_mask = item->mask;
1111 [ # # ]: 0 : if ((esp_spec && !esp_mask) ||
1112 : : (!esp_spec && esp_mask)) {
1113 : 0 : rte_flow_error_set(error, EINVAL,
1114 : : RTE_FLOW_ERROR_TYPE_ITEM,
1115 : : item,
1116 : : "Invalid esp item");
1117 : 0 : return false;
1118 : : }
1119 : : /* Check esp mask and update input set */
1120 [ # # # # ]: 0 : if (esp_mask && esp_mask->hdr.seq) {
1121 : 0 : rte_flow_error_set(error, EINVAL,
1122 : : RTE_FLOW_ERROR_TYPE_ITEM,
1123 : : item,
1124 : : "Invalid esp mask");
1125 : 0 : return false;
1126 : : }
1127 : : input = &outer_input_set;
1128 [ # # # # ]: 0 : if (!esp_spec && !esp_mask && !(*input)) {
1129 : : profile_rule = 1;
1130 [ # # ]: 0 : if (ipv6_valid && udp_valid)
1131 : 0 : *tun_type =
1132 : : ICE_SW_TUN_PROFID_IPV6_NAT_T;
1133 [ # # ]: 0 : else if (ipv6_valid)
1134 : 0 : *tun_type = ICE_SW_TUN_PROFID_IPV6_ESP;
1135 [ # # ]: 0 : else if (ipv4_valid)
1136 : 0 : goto inset_check;
1137 [ # # ]: 0 : } else if (esp_spec && esp_mask &&
1138 [ # # ]: 0 : esp_mask->hdr.spi){
1139 [ # # ]: 0 : if (udp_valid)
1140 : 0 : list[t].type = ICE_NAT_T;
1141 : : else
1142 : 0 : list[t].type = ICE_ESP;
1143 : 0 : list[t].h_u.esp_hdr.spi =
1144 : 0 : esp_spec->hdr.spi;
1145 : 0 : list[t].m_u.esp_hdr.spi =
1146 : : esp_mask->hdr.spi;
1147 : 0 : *input |= ICE_INSET_ESP_SPI;
1148 : 0 : input_set_byte += 4;
1149 : 0 : t++;
1150 : : }
1151 : :
1152 [ # # ]: 0 : if (!profile_rule) {
1153 [ # # ]: 0 : if (ipv6_valid && udp_valid)
1154 : 0 : *tun_type = ICE_SW_TUN_IPV6_NAT_T;
1155 [ # # ]: 0 : else if (ipv4_valid && udp_valid)
1156 : 0 : *tun_type = ICE_SW_TUN_IPV4_NAT_T;
1157 [ # # ]: 0 : else if (ipv6_valid)
1158 : 0 : *tun_type = ICE_SW_TUN_IPV6_ESP;
1159 [ # # ]: 0 : else if (ipv4_valid)
1160 : 0 : *tun_type = ICE_SW_TUN_IPV4_ESP;
1161 : : }
1162 : : break;
1163 : :
1164 : 0 : case RTE_FLOW_ITEM_TYPE_AH:
1165 : 0 : ah_spec = item->spec;
1166 : 0 : ah_mask = item->mask;
1167 [ # # ]: 0 : if ((ah_spec && !ah_mask) ||
1168 : : (!ah_spec && ah_mask)) {
1169 : 0 : rte_flow_error_set(error, EINVAL,
1170 : : RTE_FLOW_ERROR_TYPE_ITEM,
1171 : : item,
1172 : : "Invalid ah item");
1173 : 0 : return false;
1174 : : }
1175 : : /* Check ah mask and update input set */
1176 [ # # ]: 0 : if (ah_mask &&
1177 [ # # ]: 0 : (ah_mask->next_hdr ||
1178 : 0 : ah_mask->payload_len ||
1179 [ # # ]: 0 : ah_mask->seq_num ||
1180 [ # # ]: 0 : ah_mask->reserved)) {
1181 : 0 : rte_flow_error_set(error, EINVAL,
1182 : : RTE_FLOW_ERROR_TYPE_ITEM,
1183 : : item,
1184 : : "Invalid ah mask");
1185 : 0 : return false;
1186 : : }
1187 : :
1188 : : input = &outer_input_set;
1189 [ # # # # ]: 0 : if (!ah_spec && !ah_mask && !(*input)) {
1190 : : profile_rule = 1;
1191 [ # # ]: 0 : if (ipv6_valid && udp_valid)
1192 : 0 : *tun_type =
1193 : : ICE_SW_TUN_PROFID_IPV6_NAT_T;
1194 [ # # ]: 0 : else if (ipv6_valid)
1195 : 0 : *tun_type = ICE_SW_TUN_PROFID_IPV6_AH;
1196 [ # # ]: 0 : else if (ipv4_valid)
1197 : 0 : goto inset_check;
1198 [ # # ]: 0 : } else if (ah_spec && ah_mask &&
1199 [ # # ]: 0 : ah_mask->spi){
1200 : 0 : list[t].type = ICE_AH;
1201 : 0 : list[t].h_u.ah_hdr.spi =
1202 : 0 : ah_spec->spi;
1203 : 0 : list[t].m_u.ah_hdr.spi =
1204 : : ah_mask->spi;
1205 : 0 : *input |= ICE_INSET_AH_SPI;
1206 : 0 : input_set_byte += 4;
1207 : 0 : t++;
1208 : : }
1209 : :
1210 [ # # ]: 0 : if (!profile_rule) {
1211 [ # # ]: 0 : if (udp_valid)
1212 : 0 : goto inset_check;
1213 [ # # ]: 0 : else if (ipv6_valid)
1214 : 0 : *tun_type = ICE_SW_TUN_IPV6_AH;
1215 [ # # ]: 0 : else if (ipv4_valid)
1216 : 0 : *tun_type = ICE_SW_TUN_IPV4_AH;
1217 : : }
1218 : : break;
1219 : :
1220 : 0 : case RTE_FLOW_ITEM_TYPE_L2TPV3OIP:
1221 : 0 : l2tp_spec = item->spec;
1222 : 0 : l2tp_mask = item->mask;
1223 [ # # ]: 0 : if ((l2tp_spec && !l2tp_mask) ||
1224 : : (!l2tp_spec && l2tp_mask)) {
1225 : 0 : rte_flow_error_set(error, EINVAL,
1226 : : RTE_FLOW_ERROR_TYPE_ITEM,
1227 : : item,
1228 : : "Invalid l2tp item");
1229 : 0 : return false;
1230 : : }
1231 : :
1232 : : input = &outer_input_set;
1233 [ # # # # ]: 0 : if (!l2tp_spec && !l2tp_mask && !(*input)) {
1234 [ # # ]: 0 : if (ipv6_valid)
1235 : 0 : *tun_type =
1236 : : ICE_SW_TUN_PROFID_MAC_IPV6_L2TPV3;
1237 [ # # ]: 0 : else if (ipv4_valid)
1238 : 0 : goto inset_check;
1239 [ # # ]: 0 : } else if (l2tp_spec && l2tp_mask &&
1240 [ # # ]: 0 : l2tp_mask->session_id){
1241 : 0 : list[t].type = ICE_L2TPV3;
1242 : 0 : list[t].h_u.l2tpv3_sess_hdr.session_id =
1243 : 0 : l2tp_spec->session_id;
1244 : 0 : list[t].m_u.l2tpv3_sess_hdr.session_id =
1245 : : l2tp_mask->session_id;
1246 : 0 : *input |= ICE_INSET_L2TPV3OIP_SESSION_ID;
1247 : 0 : input_set_byte += 4;
1248 : 0 : t++;
1249 : : }
1250 : :
1251 [ # # ]: 0 : if (!profile_rule) {
1252 [ # # ]: 0 : if (ipv6_valid)
1253 : 0 : *tun_type =
1254 : : ICE_SW_TUN_IPV6_L2TPV3;
1255 [ # # ]: 0 : else if (ipv4_valid)
1256 : 0 : *tun_type =
1257 : : ICE_SW_TUN_IPV4_L2TPV3;
1258 : : }
1259 : : break;
1260 : :
1261 : 0 : case RTE_FLOW_ITEM_TYPE_PFCP:
1262 : 0 : pfcp_spec = item->spec;
1263 : 0 : pfcp_mask = item->mask;
1264 : : /* Check if PFCP item is used to describe protocol.
1265 : : * If yes, both spec and mask should be NULL.
1266 : : * If no, both spec and mask shouldn't be NULL.
1267 : : */
1268 [ # # ]: 0 : if ((!pfcp_spec && pfcp_mask) ||
1269 : : (pfcp_spec && !pfcp_mask)) {
1270 : 0 : rte_flow_error_set(error, EINVAL,
1271 : : RTE_FLOW_ERROR_TYPE_ITEM,
1272 : : item,
1273 : : "Invalid PFCP item");
1274 : 0 : return false;
1275 : : }
1276 [ # # ]: 0 : if (pfcp_spec && pfcp_mask) {
1277 : : /* Check pfcp mask and update input set */
1278 [ # # ]: 0 : if (pfcp_mask->msg_type ||
1279 : 0 : pfcp_mask->msg_len ||
1280 [ # # ]: 0 : pfcp_mask->seid) {
1281 : 0 : rte_flow_error_set(error, EINVAL,
1282 : : RTE_FLOW_ERROR_TYPE_ITEM,
1283 : : item,
1284 : : "Invalid pfcp mask");
1285 : 0 : return false;
1286 : : }
1287 [ # # ]: 0 : if (pfcp_mask->s_field &&
1288 [ # # # # ]: 0 : pfcp_spec->s_field == 0x01 &&
1289 : : ipv6_valid)
1290 : 0 : *tun_type =
1291 : : ICE_SW_TUN_PROFID_IPV6_PFCP_SESSION;
1292 [ # # ]: 0 : else if (pfcp_mask->s_field &&
1293 [ # # ]: 0 : pfcp_spec->s_field == 0x01)
1294 : 0 : *tun_type =
1295 : : ICE_SW_TUN_PROFID_IPV4_PFCP_SESSION;
1296 [ # # ]: 0 : else if (pfcp_mask->s_field &&
1297 [ # # # # ]: 0 : !pfcp_spec->s_field &&
1298 : : ipv6_valid)
1299 : 0 : *tun_type =
1300 : : ICE_SW_TUN_PROFID_IPV6_PFCP_NODE;
1301 [ # # ]: 0 : else if (pfcp_mask->s_field &&
1302 [ # # ]: 0 : !pfcp_spec->s_field)
1303 : 0 : *tun_type =
1304 : : ICE_SW_TUN_PROFID_IPV4_PFCP_NODE;
1305 : : else
1306 : : return false;
1307 : : }
1308 : : break;
1309 : :
1310 : 0 : case RTE_FLOW_ITEM_TYPE_GTPU:
1311 : 0 : gtp_spec = item->spec;
1312 : 0 : gtp_mask = item->mask;
1313 [ # # ]: 0 : if (gtp_spec && !gtp_mask) {
1314 : 0 : rte_flow_error_set(error, EINVAL,
1315 : : RTE_FLOW_ERROR_TYPE_ITEM,
1316 : : item,
1317 : : "Invalid GTP item");
1318 : 0 : return false;
1319 : : }
1320 [ # # ]: 0 : if (gtp_spec && gtp_mask) {
1321 : 0 : if (gtp_mask->hdr.gtp_hdr_info ||
1322 [ # # ]: 0 : gtp_mask->hdr.msg_type ||
1323 : : gtp_mask->hdr.plen) {
1324 : 0 : rte_flow_error_set(error, EINVAL,
1325 : : RTE_FLOW_ERROR_TYPE_ITEM,
1326 : : item,
1327 : : "Invalid GTP mask");
1328 : 0 : return false;
1329 : : }
1330 : : input = &outer_input_set;
1331 [ # # ]: 0 : if (gtp_mask->hdr.teid)
1332 : 0 : *input |= ICE_INSET_GTPU_TEID;
1333 : 0 : list[t].type = ICE_GTP;
1334 : 0 : list[t].h_u.gtp_hdr.teid =
1335 : 0 : gtp_spec->hdr.teid;
1336 : 0 : list[t].m_u.gtp_hdr.teid =
1337 : : gtp_mask->hdr.teid;
1338 : 0 : input_set_byte += 4;
1339 : 0 : t++;
1340 : : }
1341 : : tunnel_valid = 1;
1342 : : gtpu_valid = 1;
1343 : : break;
1344 : :
1345 : 0 : case RTE_FLOW_ITEM_TYPE_GTP_PSC:
1346 : 0 : gtp_psc_spec = item->spec;
1347 : 0 : gtp_psc_mask = item->mask;
1348 [ # # ]: 0 : if (gtp_psc_spec && !gtp_psc_mask) {
1349 : 0 : rte_flow_error_set(error, EINVAL,
1350 : : RTE_FLOW_ERROR_TYPE_ITEM,
1351 : : item,
1352 : : "Invalid GTPU_EH item");
1353 : 0 : return false;
1354 : : }
1355 [ # # ]: 0 : if (gtp_psc_spec && gtp_psc_mask) {
1356 [ # # ]: 0 : if (gtp_psc_mask->hdr.type) {
1357 : 0 : rte_flow_error_set(error, EINVAL,
1358 : : RTE_FLOW_ERROR_TYPE_ITEM,
1359 : : item,
1360 : : "Invalid GTPU_EH mask");
1361 : 0 : return false;
1362 : : }
1363 : : input = &outer_input_set;
1364 [ # # ]: 0 : if (gtp_psc_mask->hdr.qfi)
1365 : 0 : *input |= ICE_INSET_GTPU_QFI;
1366 : 0 : list[t].type = ICE_GTP;
1367 : 0 : list[t].h_u.gtp_hdr.qfi =
1368 : 0 : gtp_psc_spec->hdr.qfi;
1369 : 0 : list[t].m_u.gtp_hdr.qfi =
1370 : 0 : gtp_psc_mask->hdr.qfi;
1371 : 0 : input_set_byte += 1;
1372 : 0 : t++;
1373 : : }
1374 : : gtpu_psc_valid = 1;
1375 : : break;
1376 : :
1377 : : case RTE_FLOW_ITEM_TYPE_VOID:
1378 : : break;
1379 : :
1380 : 0 : default:
1381 : 0 : rte_flow_error_set(error, EINVAL,
1382 : : RTE_FLOW_ERROR_TYPE_ITEM, pattern,
1383 : : "Invalid pattern item.");
1384 : 0 : return false;
1385 : : }
1386 : : }
1387 : :
1388 [ # # ]: 0 : if (*tun_type == ICE_SW_TUN_PPPOE_PAY &&
1389 [ # # ]: 0 : inner_vlan_valid && outer_vlan_valid)
1390 : 0 : *tun_type = ICE_SW_TUN_PPPOE_PAY_QINQ;
1391 [ # # ]: 0 : else if (*tun_type == ICE_SW_TUN_PPPOE &&
1392 [ # # ]: 0 : inner_vlan_valid && outer_vlan_valid)
1393 : 0 : *tun_type = ICE_SW_TUN_PPPOE_QINQ;
1394 [ # # ]: 0 : else if (*tun_type == ICE_NON_TUN &&
1395 [ # # ]: 0 : inner_vlan_valid && outer_vlan_valid)
1396 : 0 : *tun_type = ICE_NON_TUN_QINQ;
1397 [ # # ]: 0 : else if (*tun_type == ICE_SW_TUN_AND_NON_TUN &&
1398 [ # # ]: 0 : inner_vlan_valid && outer_vlan_valid)
1399 : 0 : *tun_type = ICE_SW_TUN_AND_NON_TUN_QINQ;
1400 : :
1401 [ # # ]: 0 : if (pppoe_patt_valid && !pppoe_prot_valid) {
1402 [ # # # # ]: 0 : if (inner_vlan_valid && outer_vlan_valid && ipv4_valid)
1403 : 0 : *tun_type = ICE_SW_TUN_PPPOE_IPV4_QINQ;
1404 [ # # # # ]: 0 : else if (inner_vlan_valid && outer_vlan_valid && ipv6_valid)
1405 : 0 : *tun_type = ICE_SW_TUN_PPPOE_IPV6_QINQ;
1406 [ # # ]: 0 : else if (inner_vlan_valid && outer_vlan_valid)
1407 : 0 : *tun_type = ICE_SW_TUN_PPPOE_QINQ;
1408 [ # # ]: 0 : else if (ipv6_valid && udp_valid)
1409 : 0 : *tun_type = ICE_SW_TUN_PPPOE_IPV6_UDP;
1410 [ # # ]: 0 : else if (ipv6_valid && tcp_valid)
1411 : 0 : *tun_type = ICE_SW_TUN_PPPOE_IPV6_TCP;
1412 [ # # ]: 0 : else if (ipv4_valid && udp_valid)
1413 : 0 : *tun_type = ICE_SW_TUN_PPPOE_IPV4_UDP;
1414 [ # # ]: 0 : else if (ipv4_valid && tcp_valid)
1415 : 0 : *tun_type = ICE_SW_TUN_PPPOE_IPV4_TCP;
1416 [ # # ]: 0 : else if (ipv6_valid)
1417 : 0 : *tun_type = ICE_SW_TUN_PPPOE_IPV6;
1418 [ # # ]: 0 : else if (ipv4_valid)
1419 : 0 : *tun_type = ICE_SW_TUN_PPPOE_IPV4;
1420 : : else
1421 : 0 : *tun_type = ICE_SW_TUN_PPPOE;
1422 : : }
1423 : :
1424 [ # # ]: 0 : if (gtpu_valid && gtpu_psc_valid) {
1425 [ # # # # ]: 0 : if (ipv4_valid && inner_ipv4_valid && inner_udp_valid)
1426 : 0 : *tun_type = ICE_SW_TUN_IPV4_GTPU_EH_IPV4_UDP;
1427 [ # # # # ]: 0 : else if (ipv4_valid && inner_ipv4_valid && inner_tcp_valid)
1428 : 0 : *tun_type = ICE_SW_TUN_IPV4_GTPU_EH_IPV4_TCP;
1429 [ # # ]: 0 : else if (ipv4_valid && inner_ipv4_valid)
1430 : 0 : *tun_type = ICE_SW_TUN_IPV4_GTPU_EH_IPV4;
1431 [ # # # # ]: 0 : else if (ipv4_valid && inner_ipv6_valid && inner_udp_valid)
1432 : 0 : *tun_type = ICE_SW_TUN_IPV4_GTPU_EH_IPV6_UDP;
1433 [ # # # # ]: 0 : else if (ipv4_valid && inner_ipv6_valid && inner_tcp_valid)
1434 : 0 : *tun_type = ICE_SW_TUN_IPV4_GTPU_EH_IPV6_TCP;
1435 [ # # ]: 0 : else if (ipv4_valid && inner_ipv6_valid)
1436 : 0 : *tun_type = ICE_SW_TUN_IPV4_GTPU_EH_IPV6;
1437 [ # # # # ]: 0 : else if (ipv6_valid && inner_ipv4_valid && inner_udp_valid)
1438 : 0 : *tun_type = ICE_SW_TUN_IPV6_GTPU_EH_IPV4_UDP;
1439 [ # # # # ]: 0 : else if (ipv6_valid && inner_ipv4_valid && inner_tcp_valid)
1440 : 0 : *tun_type = ICE_SW_TUN_IPV6_GTPU_EH_IPV4_TCP;
1441 [ # # ]: 0 : else if (ipv6_valid && inner_ipv4_valid)
1442 : 0 : *tun_type = ICE_SW_TUN_IPV6_GTPU_EH_IPV4;
1443 [ # # # # ]: 0 : else if (ipv6_valid && inner_ipv6_valid && inner_udp_valid)
1444 : 0 : *tun_type = ICE_SW_TUN_IPV6_GTPU_EH_IPV6_UDP;
1445 [ # # # # ]: 0 : else if (ipv6_valid && inner_ipv6_valid && inner_tcp_valid)
1446 : 0 : *tun_type = ICE_SW_TUN_IPV6_GTPU_EH_IPV6_TCP;
1447 [ # # ]: 0 : else if (ipv6_valid && inner_ipv6_valid)
1448 : 0 : *tun_type = ICE_SW_TUN_IPV6_GTPU_EH_IPV6;
1449 [ # # ]: 0 : else if (ipv4_valid)
1450 : 0 : *tun_type = ICE_SW_TUN_IPV4_GTPU_NO_PAY;
1451 [ # # ]: 0 : else if (ipv6_valid)
1452 : 0 : *tun_type = ICE_SW_TUN_IPV6_GTPU_NO_PAY;
1453 [ # # ]: 0 : } else if (gtpu_valid) {
1454 [ # # # # ]: 0 : if (ipv4_valid && inner_ipv4_valid && inner_udp_valid)
1455 : 0 : *tun_type = ICE_SW_TUN_IPV4_GTPU_IPV4_UDP;
1456 [ # # # # ]: 0 : else if (ipv4_valid && inner_ipv4_valid && inner_tcp_valid)
1457 : 0 : *tun_type = ICE_SW_TUN_IPV4_GTPU_IPV4_TCP;
1458 [ # # ]: 0 : else if (ipv4_valid && inner_ipv4_valid)
1459 : 0 : *tun_type = ICE_SW_TUN_IPV4_GTPU_IPV4;
1460 [ # # # # ]: 0 : else if (ipv4_valid && inner_ipv6_valid && inner_udp_valid)
1461 : 0 : *tun_type = ICE_SW_TUN_IPV4_GTPU_IPV6_UDP;
1462 [ # # # # ]: 0 : else if (ipv4_valid && inner_ipv6_valid && inner_tcp_valid)
1463 : 0 : *tun_type = ICE_SW_TUN_IPV4_GTPU_IPV6_TCP;
1464 [ # # ]: 0 : else if (ipv4_valid && inner_ipv6_valid)
1465 : 0 : *tun_type = ICE_SW_TUN_IPV4_GTPU_IPV6;
1466 [ # # # # ]: 0 : else if (ipv6_valid && inner_ipv4_valid && inner_udp_valid)
1467 : 0 : *tun_type = ICE_SW_TUN_IPV6_GTPU_IPV4_UDP;
1468 [ # # # # ]: 0 : else if (ipv6_valid && inner_ipv4_valid && inner_tcp_valid)
1469 : 0 : *tun_type = ICE_SW_TUN_IPV6_GTPU_IPV4_TCP;
1470 [ # # ]: 0 : else if (ipv6_valid && inner_ipv4_valid)
1471 : 0 : *tun_type = ICE_SW_TUN_IPV6_GTPU_IPV4;
1472 [ # # # # ]: 0 : else if (ipv6_valid && inner_ipv6_valid && inner_udp_valid)
1473 : 0 : *tun_type = ICE_SW_TUN_IPV6_GTPU_IPV6_UDP;
1474 [ # # # # ]: 0 : else if (ipv6_valid && inner_ipv6_valid && inner_tcp_valid)
1475 : 0 : *tun_type = ICE_SW_TUN_IPV6_GTPU_IPV6_TCP;
1476 [ # # ]: 0 : else if (ipv6_valid && inner_ipv6_valid)
1477 : 0 : *tun_type = ICE_SW_TUN_IPV6_GTPU_IPV6;
1478 [ # # ]: 0 : else if (ipv4_valid)
1479 : 0 : *tun_type = ICE_SW_TUN_IPV4_GTPU_NO_PAY;
1480 [ # # ]: 0 : else if (ipv6_valid)
1481 : 0 : *tun_type = ICE_SW_TUN_IPV6_GTPU_NO_PAY;
1482 : : }
1483 : :
1484 [ # # ]: 0 : if (*tun_type == ICE_SW_TUN_IPV4_GTPU_NO_PAY ||
1485 : : *tun_type == ICE_SW_TUN_IPV6_GTPU_NO_PAY) {
1486 [ # # ]: 0 : for (k = 0; k < t; k++) {
1487 [ # # ]: 0 : if (list[k].type == ICE_GTP)
1488 : 0 : list[k].type = ICE_GTP_NO_PAY;
1489 : : }
1490 : : }
1491 : :
1492 [ # # ]: 0 : if (*tun_type == ICE_NON_TUN) {
1493 [ # # ]: 0 : if (vxlan_valid)
1494 : 0 : *tun_type = ICE_SW_TUN_VXLAN;
1495 [ # # ]: 0 : else if (nvgre_valid)
1496 : 0 : *tun_type = ICE_SW_TUN_NVGRE;
1497 [ # # ]: 0 : else if (ipv4_valid && tcp_valid)
1498 : 0 : *tun_type = ICE_SW_IPV4_TCP;
1499 [ # # ]: 0 : else if (ipv4_valid && udp_valid)
1500 : 0 : *tun_type = ICE_SW_IPV4_UDP;
1501 [ # # ]: 0 : else if (ipv6_valid && tcp_valid)
1502 : 0 : *tun_type = ICE_SW_IPV6_TCP;
1503 [ # # ]: 0 : else if (ipv6_valid && udp_valid)
1504 : 0 : *tun_type = ICE_SW_IPV6_UDP;
1505 : : }
1506 : :
1507 [ # # ]: 0 : if (input_set_byte > MAX_INPUT_SET_BYTE) {
1508 : 0 : rte_flow_error_set(error, EINVAL,
1509 : : RTE_FLOW_ERROR_TYPE_ITEM,
1510 : : item,
1511 : : "too much input set");
1512 : 0 : return false;
1513 : : }
1514 : :
1515 : 0 : *lkups_num = t;
1516 : :
1517 : 0 : inset_check:
1518 [ # # # # : 0 : if ((!outer_input_set && !inner_input_set &&
# # ]
1519 : 0 : !ice_is_prof_rule(*tun_type)) || (outer_input_set &
1520 [ # # ]: 0 : ~pattern_match_item->input_set_mask_o) ||
1521 [ # # ]: 0 : (inner_input_set & ~pattern_match_item->input_set_mask_i))
1522 : 0 : return false;
1523 : :
1524 : : return true;
1525 : : }
1526 : :
1527 : : static int
1528 : 0 : ice_switch_parse_dcf_action(struct ice_dcf_adapter *ad,
1529 : : const struct rte_flow_action *actions,
1530 : : uint32_t priority,
1531 : : struct rte_flow_error *error,
1532 : : struct ice_adv_rule_info *rule_info)
1533 : : {
1534 : : const struct rte_flow_action_ethdev *act_ethdev;
1535 : : const struct rte_flow_action *action;
1536 : : const struct rte_eth_dev *repr_dev;
1537 : : enum rte_flow_action_type action_type;
1538 : : uint16_t rule_port_id, backer_port_id;
1539 : :
1540 [ # # ]: 0 : for (action = actions; action->type !=
1541 : 0 : RTE_FLOW_ACTION_TYPE_END; action++) {
1542 : : action_type = action->type;
1543 [ # # # # ]: 0 : switch (action_type) {
1544 : 0 : case RTE_FLOW_ACTION_TYPE_PORT_REPRESENTOR:
1545 : 0 : rule_info->sw_act.fltr_act = ICE_FWD_TO_VSI;
1546 : 0 : act_ethdev = action->conf;
1547 : :
1548 [ # # ]: 0 : if (!rte_eth_dev_is_valid_port(act_ethdev->port_id))
1549 : 0 : goto invalid_port_id;
1550 : :
1551 : : /* For traffic to original DCF port */
1552 : 0 : rule_port_id = ad->parent.pf.dev_data->port_id;
1553 : :
1554 [ # # ]: 0 : if (rule_port_id != act_ethdev->port_id)
1555 : 0 : goto invalid_port_id;
1556 : :
1557 : 0 : rule_info->sw_act.vsi_handle = 0;
1558 : :
1559 : 0 : break;
1560 : :
1561 : 0 : invalid_port_id:
1562 : 0 : rte_flow_error_set(error,
1563 : : EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
1564 : : actions,
1565 : : "Invalid port_id");
1566 : 0 : return -rte_errno;
1567 : :
1568 : 0 : case RTE_FLOW_ACTION_TYPE_REPRESENTED_PORT:
1569 : 0 : rule_info->sw_act.fltr_act = ICE_FWD_TO_VSI;
1570 : 0 : act_ethdev = action->conf;
1571 : :
1572 [ # # ]: 0 : if (!rte_eth_dev_is_valid_port(act_ethdev->port_id))
1573 : 0 : goto invalid;
1574 : :
1575 : 0 : repr_dev = &rte_eth_devices[act_ethdev->port_id];
1576 : :
1577 [ # # ]: 0 : if (!repr_dev->data)
1578 : 0 : goto invalid;
1579 : :
1580 : 0 : rule_port_id = ad->parent.pf.dev_data->port_id;
1581 : 0 : backer_port_id = repr_dev->data->backer_port_id;
1582 : :
1583 [ # # ]: 0 : if (backer_port_id != rule_port_id)
1584 : 0 : goto invalid;
1585 : :
1586 : 0 : rule_info->sw_act.vsi_handle = repr_dev->data->representor_id;
1587 : 0 : break;
1588 : :
1589 : 0 : invalid:
1590 : 0 : rte_flow_error_set(error,
1591 : : EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
1592 : : actions,
1593 : : "Invalid ethdev_port_id");
1594 : 0 : return -rte_errno;
1595 : :
1596 : 0 : case RTE_FLOW_ACTION_TYPE_DROP:
1597 : 0 : rule_info->sw_act.fltr_act = ICE_DROP_PACKET;
1598 : 0 : break;
1599 : :
1600 : 0 : default:
1601 : 0 : rte_flow_error_set(error,
1602 : : EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
1603 : : actions,
1604 : : "Invalid action type");
1605 : 0 : return -rte_errno;
1606 : : }
1607 : : }
1608 : :
1609 : 0 : rule_info->sw_act.src = rule_info->sw_act.vsi_handle;
1610 : 0 : rule_info->sw_act.flag = ICE_FLTR_RX;
1611 : 0 : rule_info->rx = 1;
1612 : : /* 0 denotes lowest priority of recipe and highest priority
1613 : : * of rte_flow. Change rte_flow priority into recipe priority.
1614 : : */
1615 : 0 : rule_info->priority = ICE_SW_PRI_BASE - priority;
1616 : :
1617 : 0 : return 0;
1618 : : }
1619 : :
1620 : : static int
1621 : 0 : ice_switch_parse_action(struct ice_pf *pf,
1622 : : const struct rte_flow_action *actions,
1623 : : uint32_t priority,
1624 : : struct rte_flow_error *error,
1625 : : struct ice_adv_rule_info *rule_info)
1626 : : {
1627 : 0 : struct ice_vsi *vsi = pf->main_vsi;
1628 : 0 : struct rte_eth_dev_data *dev_data = pf->adapter->pf.dev_data;
1629 : : const struct rte_flow_action_queue *act_q;
1630 : : const struct rte_flow_action_rss *act_qgrop;
1631 : : uint16_t base_queue, i;
1632 : : const struct rte_flow_action *action;
1633 : : enum rte_flow_action_type action_type;
1634 : 0 : uint16_t valid_qgrop_number[MAX_QGRP_NUM_TYPE] = {
1635 : : 2, 4, 8, 16, 32, 64, 128};
1636 : :
1637 : 0 : base_queue = pf->base_queue + vsi->base_queue;
1638 [ # # ]: 0 : for (action = actions; action->type !=
1639 : 0 : RTE_FLOW_ACTION_TYPE_END; action++) {
1640 : : action_type = action->type;
1641 [ # # # # : 0 : switch (action_type) {
# ]
1642 : 0 : case RTE_FLOW_ACTION_TYPE_RSS:
1643 : 0 : act_qgrop = action->conf;
1644 [ # # ]: 0 : if (act_qgrop->queue_num <= 1)
1645 : 0 : goto error;
1646 : 0 : rule_info->sw_act.fltr_act =
1647 : : ICE_FWD_TO_QGRP;
1648 : 0 : rule_info->sw_act.fwd_id.q_id =
1649 : 0 : base_queue + act_qgrop->queue[0];
1650 [ # # ]: 0 : for (i = 0; i < MAX_QGRP_NUM_TYPE; i++) {
1651 : 0 : if (act_qgrop->queue_num ==
1652 [ # # ]: 0 : valid_qgrop_number[i])
1653 : : break;
1654 : : }
1655 [ # # ]: 0 : if (i == MAX_QGRP_NUM_TYPE)
1656 : 0 : goto error;
1657 : 0 : if ((act_qgrop->queue[0] +
1658 : : act_qgrop->queue_num) >
1659 [ # # ]: 0 : dev_data->nb_rx_queues)
1660 : 0 : goto error1;
1661 [ # # ]: 0 : for (i = 0; i < act_qgrop->queue_num - 1; i++)
1662 : 0 : if (act_qgrop->queue[i + 1] !=
1663 [ # # ]: 0 : act_qgrop->queue[i] + 1)
1664 : 0 : goto error2;
1665 : 0 : rule_info->sw_act.qgrp_size =
1666 : : act_qgrop->queue_num;
1667 : 0 : break;
1668 : 0 : case RTE_FLOW_ACTION_TYPE_QUEUE:
1669 : 0 : act_q = action->conf;
1670 [ # # ]: 0 : if (act_q->index >= dev_data->nb_rx_queues)
1671 : 0 : goto error;
1672 : 0 : rule_info->sw_act.fltr_act =
1673 : : ICE_FWD_TO_Q;
1674 : 0 : rule_info->sw_act.fwd_id.q_id =
1675 : 0 : base_queue + act_q->index;
1676 : 0 : break;
1677 : :
1678 : 0 : case RTE_FLOW_ACTION_TYPE_DROP:
1679 : 0 : rule_info->sw_act.fltr_act =
1680 : : ICE_DROP_PACKET;
1681 : 0 : break;
1682 : :
1683 : : case RTE_FLOW_ACTION_TYPE_VOID:
1684 : : break;
1685 : :
1686 : 0 : default:
1687 : 0 : goto error;
1688 : : }
1689 : : }
1690 : :
1691 : 0 : rule_info->sw_act.vsi_handle = vsi->idx;
1692 : 0 : rule_info->rx = 1;
1693 : 0 : rule_info->sw_act.src = vsi->idx;
1694 : : /* 0 denotes lowest priority of recipe and highest priority
1695 : : * of rte_flow. Change rte_flow priority into recipe priority.
1696 : : */
1697 : 0 : rule_info->priority = ICE_SW_PRI_BASE - priority;
1698 : :
1699 : 0 : return 0;
1700 : :
1701 : 0 : error:
1702 : 0 : rte_flow_error_set(error,
1703 : : EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
1704 : : actions,
1705 : : "Invalid action type or queue number");
1706 : 0 : return -rte_errno;
1707 : :
1708 : : error1:
1709 : 0 : rte_flow_error_set(error,
1710 : : EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
1711 : : actions,
1712 : : "Invalid queue region indexes");
1713 : 0 : return -rte_errno;
1714 : :
1715 : : error2:
1716 : 0 : rte_flow_error_set(error,
1717 : : EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
1718 : : actions,
1719 : : "Discontinuous queue region");
1720 : 0 : return -rte_errno;
1721 : : }
1722 : :
1723 : : static int
1724 : 0 : ice_switch_check_action(const struct rte_flow_action *actions,
1725 : : struct rte_flow_error *error)
1726 : : {
1727 : : const struct rte_flow_action *action;
1728 : : enum rte_flow_action_type action_type;
1729 : : uint16_t actions_num = 0;
1730 : :
1731 [ # # ]: 0 : for (action = actions; action->type !=
1732 : 0 : RTE_FLOW_ACTION_TYPE_END; action++) {
1733 : : action_type = action->type;
1734 [ # # # ]: 0 : switch (action_type) {
1735 : 0 : case RTE_FLOW_ACTION_TYPE_RSS:
1736 : : case RTE_FLOW_ACTION_TYPE_QUEUE:
1737 : : case RTE_FLOW_ACTION_TYPE_DROP:
1738 : : case RTE_FLOW_ACTION_TYPE_REPRESENTED_PORT:
1739 : : case RTE_FLOW_ACTION_TYPE_PORT_REPRESENTOR:
1740 : 0 : actions_num++;
1741 : 0 : break;
1742 : 0 : case RTE_FLOW_ACTION_TYPE_VOID:
1743 : 0 : continue;
1744 : 0 : default:
1745 : 0 : rte_flow_error_set(error,
1746 : : EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
1747 : : actions,
1748 : : "Invalid action type");
1749 : 0 : return -rte_errno;
1750 : : }
1751 : : }
1752 : :
1753 [ # # ]: 0 : if (actions_num != 1) {
1754 : 0 : rte_flow_error_set(error,
1755 : : EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
1756 : : actions,
1757 : : "Invalid action number");
1758 : 0 : return -rte_errno;
1759 : : }
1760 : :
1761 : : return 0;
1762 : : }
1763 : :
1764 : : static int
1765 : 0 : ice_switch_parse_pattern_action(struct ice_adapter *ad,
1766 : : struct ice_pattern_match_item *array,
1767 : : uint32_t array_len,
1768 : : const struct rte_flow_item pattern[],
1769 : : const struct rte_flow_action actions[],
1770 : : uint32_t priority,
1771 : : void **meta,
1772 : : struct rte_flow_error *error)
1773 : : {
1774 : 0 : struct ice_pf *pf = &ad->pf;
1775 : : int ret = 0;
1776 : : struct sw_meta *sw_meta_ptr = NULL;
1777 : : struct ice_adv_rule_info rule_info;
1778 : : struct ice_adv_lkup_elem *list = NULL;
1779 : 0 : uint16_t lkups_num = 0;
1780 : : const struct rte_flow_item *item = pattern;
1781 : : uint16_t item_num = 0;
1782 : : uint16_t vlan_num = 0;
1783 : 0 : enum ice_sw_tunnel_type tun_type =
1784 : : ICE_NON_TUN;
1785 : : struct ice_pattern_match_item *pattern_match_item = NULL;
1786 : :
1787 [ # # ]: 0 : for (; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
1788 : 0 : item_num++;
1789 [ # # ]: 0 : if (item->type == RTE_FLOW_ITEM_TYPE_ETH) {
1790 : : const struct rte_flow_item_eth *eth_mask;
1791 [ # # ]: 0 : if (item->mask)
1792 : : eth_mask = item->mask;
1793 : : else
1794 : 0 : continue;
1795 [ # # ]: 0 : if (eth_mask->hdr.ether_type == UINT16_MAX)
1796 : 0 : tun_type = ICE_SW_TUN_AND_NON_TUN;
1797 : : }
1798 : :
1799 [ # # ]: 0 : if (item->type == RTE_FLOW_ITEM_TYPE_VLAN)
1800 : 0 : vlan_num++;
1801 : :
1802 : : /* reserve one more memory slot for ETH which may
1803 : : * consume 2 lookup items.
1804 : : */
1805 [ # # ]: 0 : if (item->type == RTE_FLOW_ITEM_TYPE_ETH)
1806 : 0 : item_num++;
1807 : : }
1808 : :
1809 [ # # ]: 0 : if (vlan_num == 2 && tun_type == ICE_SW_TUN_AND_NON_TUN)
1810 : 0 : tun_type = ICE_SW_TUN_AND_NON_TUN_QINQ;
1811 [ # # ]: 0 : else if (vlan_num == 2)
1812 : 0 : tun_type = ICE_NON_TUN_QINQ;
1813 : :
1814 : : /* reserve one more memory slot for direction flag which may
1815 : : * consume 1 lookup item.
1816 : : */
1817 : 0 : list = rte_zmalloc(NULL, (item_num + 1) * sizeof(*list), 0);
1818 [ # # ]: 0 : if (!list) {
1819 : 0 : rte_flow_error_set(error, EINVAL,
1820 : : RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1821 : : "No memory for PMD internal items");
1822 : 0 : return -rte_errno;
1823 : : }
1824 : :
1825 : : sw_meta_ptr =
1826 : 0 : rte_zmalloc(NULL, sizeof(*sw_meta_ptr), 0);
1827 [ # # ]: 0 : if (!sw_meta_ptr) {
1828 : 0 : rte_flow_error_set(error, EINVAL,
1829 : : RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1830 : : "No memory for sw_pattern_meta_ptr");
1831 : 0 : goto error;
1832 : : }
1833 : :
1834 : : pattern_match_item =
1835 : 0 : ice_search_pattern_match_item(ad, pattern, array, array_len,
1836 : : error);
1837 [ # # ]: 0 : if (!pattern_match_item) {
1838 : 0 : rte_flow_error_set(error, EINVAL,
1839 : : RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1840 : : "Invalid input pattern");
1841 : 0 : goto error;
1842 : : }
1843 : :
1844 [ # # ]: 0 : if (!ice_switch_parse_pattern(pattern, error, list, &lkups_num,
1845 : : &tun_type, pattern_match_item)) {
1846 : 0 : rte_flow_error_set(error, EINVAL,
1847 : : RTE_FLOW_ERROR_TYPE_ITEM_SPEC,
1848 : : pattern,
1849 : : "Invalid input set");
1850 : 0 : goto error;
1851 : : }
1852 : :
1853 : : memset(&rule_info, 0, sizeof(rule_info));
1854 : 0 : rule_info.tun_type = tun_type;
1855 : :
1856 : 0 : ret = ice_switch_check_action(actions, error);
1857 [ # # ]: 0 : if (ret)
1858 : 0 : goto error;
1859 : :
1860 [ # # ]: 0 : if (ad->hw.dcf_enabled)
1861 : 0 : ret = ice_switch_parse_dcf_action((void *)ad, actions, priority,
1862 : : error, &rule_info);
1863 : : else
1864 : 0 : ret = ice_switch_parse_action(pf, actions, priority, error,
1865 : : &rule_info);
1866 : :
1867 [ # # ]: 0 : if (ret)
1868 : 0 : goto error;
1869 : :
1870 [ # # ]: 0 : if (meta) {
1871 : 0 : *meta = sw_meta_ptr;
1872 : 0 : ((struct sw_meta *)*meta)->list = list;
1873 : 0 : ((struct sw_meta *)*meta)->lkups_num = lkups_num;
1874 : 0 : ((struct sw_meta *)*meta)->rule_info = rule_info;
1875 : : } else {
1876 : 0 : rte_free(list);
1877 : 0 : rte_free(sw_meta_ptr);
1878 : : }
1879 : :
1880 : 0 : rte_free(pattern_match_item);
1881 : :
1882 : 0 : return 0;
1883 : :
1884 : 0 : error:
1885 : 0 : rte_free(list);
1886 : 0 : rte_free(sw_meta_ptr);
1887 : 0 : rte_free(pattern_match_item);
1888 : :
1889 : 0 : return -rte_errno;
1890 : : }
1891 : :
1892 : : static int
1893 : 0 : ice_switch_query(struct ice_adapter *ad __rte_unused,
1894 : : struct rte_flow *flow __rte_unused,
1895 : : struct rte_flow_query_count *count __rte_unused,
1896 : : struct rte_flow_error *error)
1897 : : {
1898 : 0 : rte_flow_error_set(error, EINVAL,
1899 : : RTE_FLOW_ERROR_TYPE_HANDLE,
1900 : : NULL,
1901 : : "count action not supported by switch filter");
1902 : :
1903 : 0 : return -rte_errno;
1904 : : }
1905 : :
1906 : : static int
1907 : 0 : ice_switch_redirect(struct ice_adapter *ad,
1908 : : struct rte_flow *flow,
1909 : : struct ice_flow_redirect *rd)
1910 : : {
1911 : : struct ice_rule_query_data *rdata;
1912 : 0 : struct ice_switch_filter_conf *filter_conf_ptr =
1913 : : (struct ice_switch_filter_conf *)flow->rule;
1914 : 0 : struct ice_rule_query_data added_rdata = { 0 };
1915 : : struct ice_adv_fltr_mgmt_list_entry *list_itr;
1916 : : struct ice_adv_lkup_elem *lkups_ref = NULL;
1917 : : struct ice_adv_lkup_elem *lkups_dp = NULL;
1918 : : struct LIST_HEAD_TYPE *list_head;
1919 : : struct ice_adv_rule_info rinfo;
1920 : 0 : struct ice_hw *hw = &ad->hw;
1921 : : struct ice_switch_info *sw;
1922 : : uint16_t lkups_cnt;
1923 : : int ret;
1924 : :
1925 : : rdata = &filter_conf_ptr->sw_query_data;
1926 : :
1927 [ # # ]: 0 : if (rdata->vsi_handle != rd->vsi_handle)
1928 : : return 0;
1929 : :
1930 : 0 : sw = hw->switch_info;
1931 [ # # ]: 0 : if (!sw->recp_list[rdata->rid].recp_created)
1932 : : return -EINVAL;
1933 : :
1934 [ # # ]: 0 : if (rd->type != ICE_FLOW_REDIRECT_VSI)
1935 : : return -ENOTSUP;
1936 : :
1937 [ # # # # ]: 0 : switch (filter_conf_ptr->fltr_status) {
1938 : 0 : case ICE_SW_FLTR_ADDED:
1939 : : list_head = &sw->recp_list[rdata->rid].filt_rules;
1940 [ # # # # : 0 : LIST_FOR_EACH_ENTRY(list_itr, list_head,
# # ]
1941 : : ice_adv_fltr_mgmt_list_entry,
1942 : : list_entry) {
1943 : 0 : rinfo = list_itr->rule_info;
1944 [ # # ]: 0 : if ((rinfo.fltr_rule_id == rdata->rule_id &&
1945 [ # # ]: 0 : rinfo.sw_act.fltr_act == ICE_FWD_TO_VSI &&
1946 [ # # # # ]: 0 : rinfo.sw_act.vsi_handle == rd->vsi_handle) ||
1947 : 0 : (rinfo.fltr_rule_id == rdata->rule_id &&
1948 [ # # ]: 0 : rinfo.sw_act.fltr_act == ICE_FWD_TO_VSI_LIST)){
1949 : 0 : lkups_cnt = list_itr->lkups_cnt;
1950 : :
1951 : : lkups_dp = (struct ice_adv_lkup_elem *)
1952 : 0 : ice_memdup(hw, list_itr->lkups,
1953 : : sizeof(*list_itr->lkups) *
1954 : : lkups_cnt,
1955 : : ICE_NONDMA_TO_NONDMA);
1956 [ # # ]: 0 : if (!lkups_dp) {
1957 : 0 : PMD_DRV_LOG(ERR,
1958 : : "Failed to allocate memory.");
1959 : 0 : return -EINVAL;
1960 : : }
1961 : : lkups_ref = lkups_dp;
1962 : :
1963 [ # # ]: 0 : if (rinfo.sw_act.fltr_act ==
1964 : : ICE_FWD_TO_VSI_LIST) {
1965 : 0 : rinfo.sw_act.vsi_handle =
1966 : 0 : rd->vsi_handle;
1967 : 0 : rinfo.sw_act.fltr_act = ICE_FWD_TO_VSI;
1968 : : }
1969 : : break;
1970 : : }
1971 : : }
1972 : :
1973 [ # # ]: 0 : if (!lkups_ref)
1974 : : return -EINVAL;
1975 : :
1976 : 0 : goto rmv_rule;
1977 : 0 : case ICE_SW_FLTR_RMV_FAILED_ON_RIDRECT:
1978 : : /* Recover VSI context */
1979 : 0 : hw->vsi_ctx[rd->vsi_handle]->vsi_num = filter_conf_ptr->vsi_num;
1980 : 0 : rinfo = filter_conf_ptr->rule_info;
1981 : 0 : lkups_cnt = filter_conf_ptr->lkups_num;
1982 : 0 : lkups_ref = filter_conf_ptr->lkups;
1983 : :
1984 [ # # ]: 0 : if (rinfo.sw_act.fltr_act == ICE_FWD_TO_VSI_LIST) {
1985 : 0 : rinfo.sw_act.vsi_handle = rd->vsi_handle;
1986 : 0 : rinfo.sw_act.fltr_act = ICE_FWD_TO_VSI;
1987 : : }
1988 : :
1989 : 0 : goto rmv_rule;
1990 : 0 : case ICE_SW_FLTR_ADD_FAILED_ON_RIDRECT:
1991 : 0 : rinfo = filter_conf_ptr->rule_info;
1992 : 0 : lkups_cnt = filter_conf_ptr->lkups_num;
1993 : 0 : lkups_ref = filter_conf_ptr->lkups;
1994 : :
1995 : 0 : goto add_rule;
1996 : : default:
1997 : : return -EINVAL;
1998 : : }
1999 : :
2000 : 0 : rmv_rule:
2001 [ # # ]: 0 : if (ice_dcf_adminq_need_retry(ad)) {
2002 : 0 : PMD_DRV_LOG(WARNING, "DCF is not on");
2003 : : ret = -EAGAIN;
2004 : 0 : goto out;
2005 : : }
2006 : :
2007 : : /* Remove the old rule */
2008 : 0 : ret = ice_rem_adv_rule(hw, lkups_ref, lkups_cnt, &rinfo);
2009 [ # # ]: 0 : if (ret) {
2010 : 0 : PMD_DRV_LOG(ERR, "Failed to delete the old rule %d",
2011 : : rdata->rule_id);
2012 : 0 : filter_conf_ptr->fltr_status =
2013 : : ICE_SW_FLTR_RMV_FAILED_ON_RIDRECT;
2014 : : ret = -EINVAL;
2015 : 0 : goto out;
2016 : : }
2017 : :
2018 : 0 : add_rule:
2019 [ # # ]: 0 : if (ice_dcf_adminq_need_retry(ad)) {
2020 : 0 : PMD_DRV_LOG(WARNING, "DCF is not on");
2021 : : ret = -EAGAIN;
2022 : 0 : goto out;
2023 : : }
2024 : :
2025 : : /* Update VSI context */
2026 : 0 : hw->vsi_ctx[rd->vsi_handle]->vsi_num = rd->new_vsi_num;
2027 : :
2028 : : /* Replay the rule */
2029 : 0 : ret = ice_add_adv_rule(hw, lkups_ref, lkups_cnt,
2030 : : &rinfo, &added_rdata);
2031 [ # # ]: 0 : if (ret) {
2032 : 0 : PMD_DRV_LOG(ERR, "Failed to replay the rule");
2033 : 0 : filter_conf_ptr->fltr_status =
2034 : : ICE_SW_FLTR_ADD_FAILED_ON_RIDRECT;
2035 : : ret = -EINVAL;
2036 : : } else {
2037 : 0 : filter_conf_ptr->sw_query_data = added_rdata;
2038 : : /* Save VSI number for failure recover */
2039 : 0 : filter_conf_ptr->vsi_num = rd->new_vsi_num;
2040 : 0 : filter_conf_ptr->fltr_status = ICE_SW_FLTR_ADDED;
2041 : : }
2042 : :
2043 : : out:
2044 : : if (ret == -EINVAL)
2045 [ # # ]: 0 : if (ice_dcf_adminq_need_retry(ad))
2046 : : ret = -EAGAIN;
2047 : :
2048 : 0 : ice_free(hw, lkups_dp);
2049 : 0 : return ret;
2050 : : }
2051 : :
2052 : : static int
2053 : 0 : ice_switch_init(struct ice_adapter *ad __rte_unused)
2054 : : {
2055 : 0 : return 0;
2056 : : }
2057 : :
2058 : : static void
2059 : 0 : ice_switch_uninit(struct ice_adapter *ad __rte_unused)
2060 : : {
2061 : 0 : }
2062 : :
2063 : : static struct
2064 : : ice_flow_engine ice_switch_engine = {
2065 : : .init = ice_switch_init,
2066 : : .uninit = ice_switch_uninit,
2067 : : .create = ice_switch_create,
2068 : : .destroy = ice_switch_destroy,
2069 : : .query_count = ice_switch_query,
2070 : : .redirect = ice_switch_redirect,
2071 : : .free = ice_switch_filter_rule_free,
2072 : : .type = ICE_FLOW_ENGINE_SWITCH,
2073 : : };
2074 : :
2075 : : struct
2076 : : ice_flow_parser ice_switch_parser = {
2077 : : .engine = &ice_switch_engine,
2078 : : .array = ice_switch_supported_pattern,
2079 : : .array_len = RTE_DIM(ice_switch_supported_pattern),
2080 : : .parse_pattern_action = ice_switch_parse_pattern_action,
2081 : : .stage = ICE_FLOW_STAGE_DISTRIBUTOR,
2082 : : };
2083 : :
2084 : 238 : RTE_INIT(ice_sw_engine_init)
2085 : : {
2086 : : struct ice_flow_engine *engine = &ice_switch_engine;
2087 : 238 : ice_register_flow_engine(engine);
2088 : 238 : }
|