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 <stdlib.h>
13 : :
14 : : #include <rte_debug.h>
15 : : #include <rte_ether.h>
16 : : #include <ethdev_driver.h>
17 : : #include <rte_log.h>
18 : : #include <rte_malloc.h>
19 : : #include <rte_eth_ctrl.h>
20 : : #include <rte_tailq.h>
21 : : #include <rte_flow_driver.h>
22 : :
23 : : #include "ice_logs.h"
24 : : #include "base/ice_type.h"
25 : : #include "base/ice_flow.h"
26 : : #include "ice_ethdev.h"
27 : : #include "ice_generic_flow.h"
28 : :
29 : : #include "../common/flow_check.h"
30 : :
31 : : #define ICE_PHINT_NONE 0
32 : : #define ICE_PHINT_VLAN BIT_ULL(0)
33 : : #define ICE_PHINT_PPPOE BIT_ULL(1)
34 : : #define ICE_PHINT_GTPU BIT_ULL(2)
35 : : #define ICE_PHINT_GTPU_EH BIT_ULL(3)
36 : : #define ICE_PHINT_GTPU_EH_DWN BIT_ULL(4)
37 : : #define ICE_PHINT_GTPU_EH_UP BIT_ULL(5)
38 : : #define ICE_PHINT_RAW BIT_ULL(6)
39 : :
40 : : #define ICE_GTPU_EH_DWNLINK 0
41 : : #define ICE_GTPU_EH_UPLINK 1
42 : :
43 : : #define ICE_IPV4_PROT BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT)
44 : : #define ICE_IPV6_PROT BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT)
45 : :
46 : : #define VALID_RSS_IPV4_L4 (RTE_ETH_RSS_NONFRAG_IPV4_UDP | \
47 : : RTE_ETH_RSS_NONFRAG_IPV4_TCP | \
48 : : RTE_ETH_RSS_NONFRAG_IPV4_SCTP)
49 : :
50 : : #define VALID_RSS_IPV6_L4 (RTE_ETH_RSS_NONFRAG_IPV6_UDP | \
51 : : RTE_ETH_RSS_NONFRAG_IPV6_TCP | \
52 : : RTE_ETH_RSS_NONFRAG_IPV6_SCTP)
53 : :
54 : : #define VALID_RSS_IPV4 (RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_FRAG_IPV4 | \
55 : : VALID_RSS_IPV4_L4)
56 : : #define VALID_RSS_IPV6 (RTE_ETH_RSS_IPV6 | RTE_ETH_RSS_FRAG_IPV6 | \
57 : : VALID_RSS_IPV6_L4)
58 : : #define VALID_RSS_L3 (VALID_RSS_IPV4 | VALID_RSS_IPV6)
59 : : #define VALID_RSS_L4 (VALID_RSS_IPV4_L4 | VALID_RSS_IPV6_L4)
60 : :
61 : : #define VALID_RSS_ATTR (RTE_ETH_RSS_L3_SRC_ONLY | \
62 : : RTE_ETH_RSS_L3_DST_ONLY | \
63 : : RTE_ETH_RSS_L4_SRC_ONLY | \
64 : : RTE_ETH_RSS_L4_DST_ONLY | \
65 : : RTE_ETH_RSS_L2_SRC_ONLY | \
66 : : RTE_ETH_RSS_L2_DST_ONLY | \
67 : : RTE_ETH_RSS_L3_PRE32 | \
68 : : RTE_ETH_RSS_L3_PRE48 | \
69 : : RTE_ETH_RSS_L3_PRE64)
70 : :
71 : : #define INVALID_RSS_ATTR (RTE_ETH_RSS_L3_PRE40 | \
72 : : RTE_ETH_RSS_L3_PRE56 | \
73 : : RTE_ETH_RSS_L3_PRE96)
74 : :
75 : : struct ice_rss_meta {
76 : : uint8_t hash_function;
77 : : struct ice_rss_hash_cfg cfg;
78 : : struct ice_rss_raw_cfg raw;
79 : : };
80 : :
81 : : struct ice_hash_flow_cfg {
82 : : bool simple_xor;
83 : : struct ice_rss_cfg rss_cfg;
84 : : };
85 : :
86 : : static int
87 : : ice_hash_init(struct ice_adapter *ad);
88 : :
89 : : static int
90 : : ice_hash_create(struct ice_adapter *ad,
91 : : struct rte_flow *flow,
92 : : void *meta,
93 : : struct rte_flow_error *error);
94 : :
95 : : static int
96 : : ice_hash_destroy(struct ice_adapter *ad,
97 : : struct rte_flow *flow,
98 : : struct rte_flow_error *error);
99 : :
100 : : static void
101 : : ice_hash_uninit(struct ice_adapter *ad);
102 : :
103 : : static void
104 : : ice_hash_free(struct rte_flow *flow);
105 : :
106 : : static int
107 : : ice_hash_parse_pattern_action(struct ice_adapter *ad,
108 : : struct ice_pattern_match_item *array,
109 : : uint32_t array_len,
110 : : const struct rte_flow_item pattern[],
111 : : const struct rte_flow_action actions[],
112 : : const struct rte_flow_attr *attr,
113 : : void **meta,
114 : : struct rte_flow_error *error);
115 : :
116 : : /* Rss configuration template */
117 : : struct ice_rss_hash_cfg ipv4_tmplt = {
118 : : ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV4 |
119 : : ICE_FLOW_SEG_HDR_IPV_OTHER,
120 : : ICE_FLOW_HASH_ETH | ICE_FLOW_HASH_IPV4,
121 : : ICE_RSS_OUTER_HEADERS,
122 : : 0
123 : : };
124 : :
125 : : struct ice_rss_hash_cfg ipv4_udp_tmplt = {
126 : : ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV4 |
127 : : ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_UDP,
128 : : ICE_FLOW_HASH_ETH | ICE_HASH_UDP_IPV4 | ICE_IPV4_PROT,
129 : : ICE_RSS_OUTER_HEADERS,
130 : : 0
131 : : };
132 : :
133 : : struct ice_rss_hash_cfg ipv4_tcp_tmplt = {
134 : : ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV4 |
135 : : ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_TCP,
136 : : ICE_FLOW_HASH_ETH | ICE_HASH_TCP_IPV4 | ICE_IPV4_PROT,
137 : : ICE_RSS_OUTER_HEADERS,
138 : : 0
139 : : };
140 : :
141 : : struct ice_rss_hash_cfg ipv4_sctp_tmplt = {
142 : : ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV4 |
143 : : ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_SCTP,
144 : : ICE_FLOW_HASH_ETH | ICE_HASH_SCTP_IPV4 | ICE_IPV4_PROT,
145 : : ICE_RSS_OUTER_HEADERS,
146 : : 0
147 : : };
148 : :
149 : : struct ice_rss_hash_cfg ipv6_tmplt = {
150 : : ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV6 |
151 : : ICE_FLOW_SEG_HDR_IPV_OTHER,
152 : : ICE_FLOW_HASH_ETH | ICE_FLOW_HASH_IPV6,
153 : : ICE_RSS_OUTER_HEADERS,
154 : : 0
155 : : };
156 : :
157 : : struct ice_rss_hash_cfg ipv6_frag_tmplt = {
158 : : ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV6 |
159 : : ICE_FLOW_SEG_HDR_IPV_FRAG,
160 : : ICE_FLOW_HASH_ETH | ICE_FLOW_HASH_IPV6,
161 : : ICE_RSS_OUTER_HEADERS,
162 : : 0
163 : : };
164 : :
165 : : struct ice_rss_hash_cfg ipv6_udp_tmplt = {
166 : : ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV6 |
167 : : ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_UDP,
168 : : ICE_FLOW_HASH_ETH | ICE_HASH_UDP_IPV6 | ICE_IPV6_PROT,
169 : : ICE_RSS_OUTER_HEADERS,
170 : : 0
171 : : };
172 : :
173 : : struct ice_rss_hash_cfg ipv6_tcp_tmplt = {
174 : : ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV6 |
175 : : ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_TCP,
176 : : ICE_FLOW_HASH_ETH | ICE_HASH_TCP_IPV6 | ICE_IPV6_PROT,
177 : : ICE_RSS_OUTER_HEADERS,
178 : : 0
179 : : };
180 : :
181 : : struct ice_rss_hash_cfg ipv6_sctp_tmplt = {
182 : : ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV6 |
183 : : ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_SCTP,
184 : : ICE_FLOW_HASH_ETH | ICE_HASH_SCTP_IPV6 | ICE_IPV6_PROT,
185 : : ICE_RSS_OUTER_HEADERS,
186 : : 0
187 : : };
188 : :
189 : : struct ice_rss_hash_cfg outer_ipv4_inner_ipv4_tmplt = {
190 : : ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER,
191 : : ICE_FLOW_HASH_IPV4,
192 : : ICE_RSS_INNER_HEADERS_W_OUTER_IPV4,
193 : : 0
194 : : };
195 : : struct ice_rss_hash_cfg outer_ipv4_inner_ipv4_udp_tmplt = {
196 : : ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
197 : : ICE_FLOW_SEG_HDR_UDP,
198 : : ICE_HASH_UDP_IPV4 | ICE_IPV4_PROT,
199 : : ICE_RSS_INNER_HEADERS_W_OUTER_IPV4,
200 : : 0
201 : : };
202 : :
203 : : struct ice_rss_hash_cfg outer_ipv4_inner_ipv4_tcp_tmplt = {
204 : : ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
205 : : ICE_FLOW_SEG_HDR_TCP,
206 : : ICE_HASH_TCP_IPV4 | ICE_IPV4_PROT,
207 : : ICE_RSS_INNER_HEADERS_W_OUTER_IPV4,
208 : : 0
209 : : };
210 : :
211 : : struct ice_rss_hash_cfg outer_ipv6_inner_ipv4_tmplt = {
212 : : ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER,
213 : : ICE_FLOW_HASH_IPV4,
214 : : ICE_RSS_INNER_HEADERS_W_OUTER_IPV6,
215 : : 0
216 : : };
217 : :
218 : : struct ice_rss_hash_cfg outer_ipv6_inner_ipv4_udp_tmplt = {
219 : : ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
220 : : ICE_FLOW_SEG_HDR_UDP,
221 : : ICE_HASH_UDP_IPV4 | ICE_IPV4_PROT,
222 : : ICE_RSS_INNER_HEADERS_W_OUTER_IPV6,
223 : : 0
224 : : };
225 : :
226 : : struct ice_rss_hash_cfg outer_ipv6_inner_ipv4_tcp_tmplt = {
227 : : ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
228 : : ICE_FLOW_SEG_HDR_TCP,
229 : : ICE_HASH_TCP_IPV4 | ICE_IPV4_PROT,
230 : : ICE_RSS_INNER_HEADERS_W_OUTER_IPV6,
231 : : 0
232 : : };
233 : :
234 : : struct ice_rss_hash_cfg outer_ipv4_inner_ipv6_tmplt = {
235 : : ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER,
236 : : ICE_FLOW_HASH_IPV6,
237 : : ICE_RSS_INNER_HEADERS_W_OUTER_IPV4,
238 : : 0
239 : : };
240 : :
241 : : struct ice_rss_hash_cfg outer_ipv4_inner_ipv6_udp_tmplt = {
242 : : ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
243 : : ICE_FLOW_SEG_HDR_UDP,
244 : : ICE_HASH_UDP_IPV6 | ICE_IPV6_PROT,
245 : : ICE_RSS_INNER_HEADERS_W_OUTER_IPV4,
246 : : 0
247 : : };
248 : :
249 : : struct ice_rss_hash_cfg outer_ipv4_inner_ipv6_tcp_tmplt = {
250 : : ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
251 : : ICE_FLOW_SEG_HDR_TCP,
252 : : ICE_HASH_TCP_IPV6 | ICE_IPV6_PROT,
253 : : ICE_RSS_INNER_HEADERS_W_OUTER_IPV4,
254 : : 0
255 : : };
256 : :
257 : : struct ice_rss_hash_cfg outer_ipv6_inner_ipv6_tmplt = {
258 : : ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER,
259 : : ICE_FLOW_HASH_IPV6,
260 : : ICE_RSS_INNER_HEADERS_W_OUTER_IPV6,
261 : : 0
262 : : };
263 : : struct ice_rss_hash_cfg outer_ipv6_inner_ipv6_udp_tmplt = {
264 : : ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
265 : : ICE_FLOW_SEG_HDR_UDP,
266 : : ICE_HASH_UDP_IPV6 | ICE_IPV6_PROT,
267 : : ICE_RSS_INNER_HEADERS_W_OUTER_IPV6,
268 : : 0
269 : : };
270 : :
271 : : struct ice_rss_hash_cfg outer_ipv6_inner_ipv6_tcp_tmplt = {
272 : : ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
273 : : ICE_FLOW_SEG_HDR_TCP,
274 : : ICE_HASH_TCP_IPV6 | ICE_IPV6_PROT,
275 : : ICE_RSS_INNER_HEADERS_W_OUTER_IPV6,
276 : : 0
277 : : };
278 : :
279 : : struct ice_rss_hash_cfg eth_ipv4_esp_tmplt = {
280 : : ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
281 : : ICE_FLOW_SEG_HDR_ESP,
282 : : ICE_FLOW_HASH_ESP_SPI,
283 : : ICE_RSS_OUTER_HEADERS,
284 : : 0
285 : : };
286 : :
287 : : struct ice_rss_hash_cfg eth_ipv4_udp_esp_tmplt = {
288 : : ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
289 : : ICE_FLOW_SEG_HDR_NAT_T_ESP,
290 : : ICE_FLOW_HASH_NAT_T_ESP_SPI,
291 : : ICE_RSS_OUTER_HEADERS,
292 : : 0
293 : : };
294 : :
295 : : struct ice_rss_hash_cfg eth_ipv4_ah_tmplt = {
296 : : ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
297 : : ICE_FLOW_SEG_HDR_AH,
298 : : ICE_FLOW_HASH_AH_SPI,
299 : : ICE_RSS_OUTER_HEADERS,
300 : : 0
301 : : };
302 : :
303 : : struct ice_rss_hash_cfg eth_ipv4_l2tpv3_tmplt = {
304 : : ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
305 : : ICE_FLOW_SEG_HDR_L2TPV3,
306 : : ICE_FLOW_HASH_L2TPV3_SESS_ID,
307 : : ICE_RSS_OUTER_HEADERS,
308 : : 0
309 : : };
310 : :
311 : : struct ice_rss_hash_cfg eth_ipv4_l2tpv2_tmplt = {
312 : : ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
313 : : ICE_FLOW_SEG_HDR_L2TPV2,
314 : : ICE_FLOW_HASH_L2TPV2_SESS_ID,
315 : : ICE_RSS_OUTER_HEADERS,
316 : : 0
317 : : };
318 : :
319 : : struct ice_rss_hash_cfg eth_ipv6_l2tpv2_tmplt = {
320 : : ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
321 : : ICE_FLOW_SEG_HDR_L2TPV2,
322 : : ICE_FLOW_HASH_L2TPV2_SESS_ID,
323 : : ICE_RSS_OUTER_HEADERS,
324 : : 0
325 : : };
326 : :
327 : : struct ice_rss_hash_cfg eth_ipv4_pfcp_tmplt = {
328 : : ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
329 : : ICE_FLOW_SEG_HDR_PFCP_SESSION,
330 : : ICE_FLOW_HASH_PFCP_SEID,
331 : : ICE_RSS_OUTER_HEADERS,
332 : : 0
333 : : };
334 : :
335 : : struct ice_rss_hash_cfg eth_ipv6_esp_tmplt = {
336 : : ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
337 : : ICE_FLOW_SEG_HDR_ESP,
338 : : ICE_FLOW_HASH_ESP_SPI,
339 : : ICE_RSS_OUTER_HEADERS,
340 : : 0
341 : : };
342 : :
343 : : struct ice_rss_hash_cfg eth_ipv6_udp_esp_tmplt = {
344 : : ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
345 : : ICE_FLOW_SEG_HDR_NAT_T_ESP,
346 : : ICE_FLOW_HASH_NAT_T_ESP_SPI,
347 : : ICE_RSS_OUTER_HEADERS,
348 : : 0
349 : : };
350 : :
351 : : struct ice_rss_hash_cfg eth_ipv6_ah_tmplt = {
352 : : ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
353 : : ICE_FLOW_SEG_HDR_AH,
354 : : ICE_FLOW_HASH_AH_SPI,
355 : : ICE_RSS_OUTER_HEADERS,
356 : : 0
357 : : };
358 : :
359 : : struct ice_rss_hash_cfg eth_ipv6_l2tpv3_tmplt = {
360 : : ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
361 : : ICE_FLOW_SEG_HDR_L2TPV3,
362 : : ICE_FLOW_HASH_L2TPV3_SESS_ID,
363 : : ICE_RSS_OUTER_HEADERS,
364 : : 0
365 : : };
366 : :
367 : : struct ice_rss_hash_cfg eth_ipv6_pfcp_tmplt = {
368 : : ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
369 : : ICE_FLOW_SEG_HDR_PFCP_SESSION,
370 : : ICE_FLOW_HASH_PFCP_SEID,
371 : : ICE_RSS_OUTER_HEADERS,
372 : : 0
373 : : };
374 : :
375 : : struct ice_rss_hash_cfg pppoe_tmplt = {
376 : : ICE_FLOW_SEG_HDR_ETH,
377 : : ICE_FLOW_HASH_ETH | ICE_FLOW_HASH_PPPOE_SESS_ID,
378 : : ICE_RSS_OUTER_HEADERS,
379 : : 0
380 : : };
381 : :
382 : : struct ice_rss_hash_cfg empty_tmplt = {
383 : : ICE_FLOW_SEG_HDR_NONE,
384 : : 0,
385 : : ICE_RSS_ANY_HEADERS,
386 : : 0
387 : : };
388 : :
389 : : struct ice_rss_hash_cfg eth_tmplt = {
390 : : ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_ETH_NON_IP,
391 : : ICE_FLOW_HASH_ETH,
392 : : ICE_RSS_OUTER_HEADERS,
393 : : 0
394 : : };
395 : :
396 : : /* IPv4 */
397 : : #define ICE_RSS_TYPE_ETH_IPV4 (RTE_ETH_RSS_ETH | RTE_ETH_RSS_IPV4 | \
398 : : RTE_ETH_RSS_FRAG_IPV4 | \
399 : : RTE_ETH_RSS_IPV4_CHKSUM)
400 : : #define ICE_RSS_TYPE_ETH_IPV4_UDP (ICE_RSS_TYPE_ETH_IPV4 | \
401 : : RTE_ETH_RSS_NONFRAG_IPV4_UDP | \
402 : : RTE_ETH_RSS_L4_CHKSUM)
403 : : #define ICE_RSS_TYPE_ETH_IPV4_TCP (ICE_RSS_TYPE_ETH_IPV4 | \
404 : : RTE_ETH_RSS_NONFRAG_IPV4_TCP | \
405 : : RTE_ETH_RSS_L4_CHKSUM)
406 : : #define ICE_RSS_TYPE_ETH_IPV4_SCTP (ICE_RSS_TYPE_ETH_IPV4 | \
407 : : RTE_ETH_RSS_NONFRAG_IPV4_SCTP | \
408 : : RTE_ETH_RSS_L4_CHKSUM)
409 : : #define ICE_RSS_TYPE_IPV4 RTE_ETH_RSS_IPV4
410 : : #define ICE_RSS_TYPE_IPV4_UDP (RTE_ETH_RSS_IPV4 | \
411 : : RTE_ETH_RSS_NONFRAG_IPV4_UDP)
412 : : #define ICE_RSS_TYPE_IPV4_TCP (RTE_ETH_RSS_IPV4 | \
413 : : RTE_ETH_RSS_NONFRAG_IPV4_TCP)
414 : : #define ICE_RSS_TYPE_IPV4_SCTP (RTE_ETH_RSS_IPV4 | \
415 : : RTE_ETH_RSS_NONFRAG_IPV4_SCTP)
416 : :
417 : : /* IPv6 */
418 : : #define ICE_RSS_TYPE_ETH_IPV6 (RTE_ETH_RSS_ETH | RTE_ETH_RSS_IPV6)
419 : : #define ICE_RSS_TYPE_ETH_IPV6_FRAG (RTE_ETH_RSS_ETH | RTE_ETH_RSS_IPV6 | \
420 : : RTE_ETH_RSS_FRAG_IPV6)
421 : : #define ICE_RSS_TYPE_ETH_IPV6_UDP (ICE_RSS_TYPE_ETH_IPV6 | \
422 : : RTE_ETH_RSS_NONFRAG_IPV6_UDP | \
423 : : RTE_ETH_RSS_L4_CHKSUM)
424 : : #define ICE_RSS_TYPE_ETH_IPV6_TCP (ICE_RSS_TYPE_ETH_IPV6 | \
425 : : RTE_ETH_RSS_NONFRAG_IPV6_TCP | \
426 : : RTE_ETH_RSS_L4_CHKSUM)
427 : : #define ICE_RSS_TYPE_ETH_IPV6_SCTP (ICE_RSS_TYPE_ETH_IPV6 | \
428 : : RTE_ETH_RSS_NONFRAG_IPV6_SCTP | \
429 : : RTE_ETH_RSS_L4_CHKSUM)
430 : : #define ICE_RSS_TYPE_IPV6 RTE_ETH_RSS_IPV6
431 : : #define ICE_RSS_TYPE_IPV6_UDP (RTE_ETH_RSS_IPV6 | \
432 : : RTE_ETH_RSS_NONFRAG_IPV6_UDP)
433 : : #define ICE_RSS_TYPE_IPV6_TCP (RTE_ETH_RSS_IPV6 | \
434 : : RTE_ETH_RSS_NONFRAG_IPV6_TCP)
435 : : #define ICE_RSS_TYPE_IPV6_SCTP (RTE_ETH_RSS_IPV6 | \
436 : : RTE_ETH_RSS_NONFRAG_IPV6_SCTP)
437 : :
438 : : /* VLAN IPV4 */
439 : : #define ICE_RSS_TYPE_VLAN_IPV4 (ICE_RSS_TYPE_IPV4 | \
440 : : RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN | \
441 : : RTE_ETH_RSS_FRAG_IPV4)
442 : : #define ICE_RSS_TYPE_VLAN_IPV4_UDP (ICE_RSS_TYPE_IPV4_UDP | \
443 : : RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
444 : : #define ICE_RSS_TYPE_VLAN_IPV4_TCP (ICE_RSS_TYPE_IPV4_TCP | \
445 : : RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
446 : : #define ICE_RSS_TYPE_VLAN_IPV4_SCTP (ICE_RSS_TYPE_IPV4_SCTP | \
447 : : RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
448 : : /* VLAN IPv6 */
449 : : #define ICE_RSS_TYPE_VLAN_IPV6 (ICE_RSS_TYPE_IPV6 | \
450 : : RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
451 : : #define ICE_RSS_TYPE_VLAN_IPV6_FRAG (ICE_RSS_TYPE_IPV6 | \
452 : : RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN | \
453 : : RTE_ETH_RSS_FRAG_IPV6)
454 : : #define ICE_RSS_TYPE_VLAN_IPV6_UDP (ICE_RSS_TYPE_IPV6_UDP | \
455 : : RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
456 : : #define ICE_RSS_TYPE_VLAN_IPV6_TCP (ICE_RSS_TYPE_IPV6_TCP | \
457 : : RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
458 : : #define ICE_RSS_TYPE_VLAN_IPV6_SCTP (ICE_RSS_TYPE_IPV6_SCTP | \
459 : : RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
460 : :
461 : : /* GTPU IPv4 */
462 : : #define ICE_RSS_TYPE_GTPU_IPV4 (ICE_RSS_TYPE_IPV4 | \
463 : : RTE_ETH_RSS_GTPU)
464 : : #define ICE_RSS_TYPE_GTPU_IPV4_UDP (ICE_RSS_TYPE_IPV4_UDP | \
465 : : RTE_ETH_RSS_GTPU)
466 : : #define ICE_RSS_TYPE_GTPU_IPV4_TCP (ICE_RSS_TYPE_IPV4_TCP | \
467 : : RTE_ETH_RSS_GTPU)
468 : : /* GTPU IPv6 */
469 : : #define ICE_RSS_TYPE_GTPU_IPV6 (ICE_RSS_TYPE_IPV6 | \
470 : : RTE_ETH_RSS_GTPU)
471 : : #define ICE_RSS_TYPE_GTPU_IPV6_UDP (ICE_RSS_TYPE_IPV6_UDP | \
472 : : RTE_ETH_RSS_GTPU)
473 : : #define ICE_RSS_TYPE_GTPU_IPV6_TCP (ICE_RSS_TYPE_IPV6_TCP | \
474 : : RTE_ETH_RSS_GTPU)
475 : :
476 : : /* PPPOE */
477 : : #define ICE_RSS_TYPE_PPPOE (RTE_ETH_RSS_ETH | RTE_ETH_RSS_PPPOE)
478 : :
479 : : /* PPPOE IPv4 */
480 : : #define ICE_RSS_TYPE_PPPOE_IPV4 (ICE_RSS_TYPE_IPV4 | \
481 : : ICE_RSS_TYPE_PPPOE)
482 : : #define ICE_RSS_TYPE_PPPOE_IPV4_UDP (ICE_RSS_TYPE_IPV4_UDP | \
483 : : ICE_RSS_TYPE_PPPOE)
484 : : #define ICE_RSS_TYPE_PPPOE_IPV4_TCP (ICE_RSS_TYPE_IPV4_TCP | \
485 : : ICE_RSS_TYPE_PPPOE)
486 : :
487 : : /* PPPOE IPv6 */
488 : : #define ICE_RSS_TYPE_PPPOE_IPV6 (ICE_RSS_TYPE_IPV6 | \
489 : : ICE_RSS_TYPE_PPPOE)
490 : : #define ICE_RSS_TYPE_PPPOE_IPV6_UDP (ICE_RSS_TYPE_IPV6_UDP | \
491 : : ICE_RSS_TYPE_PPPOE)
492 : : #define ICE_RSS_TYPE_PPPOE_IPV6_TCP (ICE_RSS_TYPE_IPV6_TCP | \
493 : : ICE_RSS_TYPE_PPPOE)
494 : :
495 : : /* ESP, AH, L2TPV3 and PFCP */
496 : : #define ICE_RSS_TYPE_IPV4_ESP (RTE_ETH_RSS_ESP | RTE_ETH_RSS_IPV4)
497 : : #define ICE_RSS_TYPE_IPV6_ESP (RTE_ETH_RSS_ESP | RTE_ETH_RSS_IPV6)
498 : : #define ICE_RSS_TYPE_IPV4_AH (RTE_ETH_RSS_AH | RTE_ETH_RSS_IPV4)
499 : : #define ICE_RSS_TYPE_IPV6_AH (RTE_ETH_RSS_AH | RTE_ETH_RSS_IPV6)
500 : : #define ICE_RSS_TYPE_IPV4_L2TPV3 (RTE_ETH_RSS_L2TPV3 | RTE_ETH_RSS_IPV4)
501 : : #define ICE_RSS_TYPE_IPV6_L2TPV3 (RTE_ETH_RSS_L2TPV3 | RTE_ETH_RSS_IPV6)
502 : : #define ICE_RSS_TYPE_IPV4_L2TPV2 (RTE_ETH_RSS_L2TPV2 | RTE_ETH_RSS_IPV4)
503 : : #define ICE_RSS_TYPE_IPV6_L2TPV2 (RTE_ETH_RSS_L2TPV2 | RTE_ETH_RSS_IPV6)
504 : : #define ICE_RSS_TYPE_IPV4_PFCP (RTE_ETH_RSS_PFCP | RTE_ETH_RSS_IPV4)
505 : : #define ICE_RSS_TYPE_IPV6_PFCP (RTE_ETH_RSS_PFCP | RTE_ETH_RSS_IPV6)
506 : :
507 : : /* MAC */
508 : : #define ICE_RSS_TYPE_ETH RTE_ETH_RSS_ETH
509 : :
510 : : /**
511 : : * Supported pattern for hash.
512 : : * The first member is pattern item type,
513 : : * the second member is input set mask,
514 : : * the third member is ice_rss_hash_cfg template.
515 : : */
516 : : static struct ice_pattern_match_item ice_hash_pattern_list[] = {
517 : : /* IPV4 */
518 : : {pattern_raw, ICE_INSET_NONE, ICE_INSET_NONE, NULL},
519 : : {pattern_eth_ipv4, ICE_RSS_TYPE_ETH_IPV4, ICE_INSET_NONE, &ipv4_tmplt},
520 : : {pattern_eth_ipv4_udp, ICE_RSS_TYPE_ETH_IPV4_UDP, ICE_INSET_NONE, &ipv4_udp_tmplt},
521 : : {pattern_eth_ipv4_tcp, ICE_RSS_TYPE_ETH_IPV4_TCP, ICE_INSET_NONE, &ipv4_tcp_tmplt},
522 : : {pattern_eth_ipv4_sctp, ICE_RSS_TYPE_ETH_IPV4_SCTP, ICE_INSET_NONE, &ipv4_sctp_tmplt},
523 : : {pattern_eth_vlan_ipv4, ICE_RSS_TYPE_VLAN_IPV4, ICE_INSET_NONE, &ipv4_tmplt},
524 : : {pattern_eth_vlan_ipv4_udp, ICE_RSS_TYPE_VLAN_IPV4_UDP, ICE_INSET_NONE, &ipv4_udp_tmplt},
525 : : {pattern_eth_vlan_ipv4_tcp, ICE_RSS_TYPE_VLAN_IPV4_TCP, ICE_INSET_NONE, &ipv4_tcp_tmplt},
526 : : {pattern_eth_vlan_ipv4_sctp, ICE_RSS_TYPE_VLAN_IPV4_SCTP, ICE_INSET_NONE, &ipv4_sctp_tmplt},
527 : : {pattern_eth_ipv4_gtpu_ipv4, ICE_RSS_TYPE_GTPU_IPV4, ICE_INSET_NONE, &outer_ipv4_inner_ipv4_tmplt},
528 : : {pattern_eth_ipv4_gtpu_ipv4_udp, ICE_RSS_TYPE_GTPU_IPV4_UDP, ICE_INSET_NONE, &outer_ipv4_inner_ipv4_udp_tmplt},
529 : : {pattern_eth_ipv4_gtpu_ipv4_tcp, ICE_RSS_TYPE_GTPU_IPV4_TCP, ICE_INSET_NONE, &outer_ipv4_inner_ipv4_tcp_tmplt},
530 : : {pattern_eth_ipv6_gtpu_ipv4, ICE_RSS_TYPE_GTPU_IPV4, ICE_INSET_NONE, &outer_ipv6_inner_ipv4_tmplt},
531 : : {pattern_eth_ipv6_gtpu_ipv4_udp, ICE_RSS_TYPE_GTPU_IPV4_UDP, ICE_INSET_NONE, &outer_ipv6_inner_ipv4_udp_tmplt},
532 : : {pattern_eth_ipv6_gtpu_ipv4_tcp, ICE_RSS_TYPE_GTPU_IPV4_TCP, ICE_INSET_NONE, &outer_ipv6_inner_ipv4_tcp_tmplt},
533 : : {pattern_eth_ipv4_gtpu_eh_ipv4, ICE_RSS_TYPE_GTPU_IPV4, ICE_INSET_NONE, &outer_ipv4_inner_ipv4_tmplt},
534 : : {pattern_eth_ipv4_gtpu_eh_ipv4_udp, ICE_RSS_TYPE_GTPU_IPV4_UDP, ICE_INSET_NONE, &outer_ipv4_inner_ipv4_udp_tmplt},
535 : : {pattern_eth_ipv4_gtpu_eh_ipv4_tcp, ICE_RSS_TYPE_GTPU_IPV4_TCP, ICE_INSET_NONE, &outer_ipv4_inner_ipv4_tcp_tmplt},
536 : : {pattern_eth_ipv6_gtpu_eh_ipv4, ICE_RSS_TYPE_GTPU_IPV4, ICE_INSET_NONE, &outer_ipv6_inner_ipv4_tmplt},
537 : : {pattern_eth_ipv6_gtpu_eh_ipv4_udp, ICE_RSS_TYPE_GTPU_IPV4_UDP, ICE_INSET_NONE, &outer_ipv6_inner_ipv4_udp_tmplt},
538 : : {pattern_eth_ipv6_gtpu_eh_ipv4_tcp, ICE_RSS_TYPE_GTPU_IPV4_TCP, ICE_INSET_NONE, &outer_ipv6_inner_ipv4_tcp_tmplt},
539 : : {pattern_eth_pppoes_ipv4, ICE_RSS_TYPE_PPPOE_IPV4, ICE_INSET_NONE, &ipv4_tmplt},
540 : : {pattern_eth_pppoes_ipv4_udp, ICE_RSS_TYPE_PPPOE_IPV4_UDP, ICE_INSET_NONE, &ipv4_udp_tmplt},
541 : : {pattern_eth_pppoes_ipv4_tcp, ICE_RSS_TYPE_PPPOE_IPV4_TCP, ICE_INSET_NONE, &ipv4_tcp_tmplt},
542 : : {pattern_eth_ipv4_esp, ICE_RSS_TYPE_IPV4_ESP, ICE_INSET_NONE, ð_ipv4_esp_tmplt},
543 : : {pattern_eth_ipv4_udp_esp, ICE_RSS_TYPE_IPV4_ESP, ICE_INSET_NONE, ð_ipv4_udp_esp_tmplt},
544 : : {pattern_eth_ipv4_ah, ICE_RSS_TYPE_IPV4_AH, ICE_INSET_NONE, ð_ipv4_ah_tmplt},
545 : : {pattern_eth_ipv4_l2tp, ICE_RSS_TYPE_IPV4_L2TPV3, ICE_INSET_NONE, ð_ipv4_l2tpv3_tmplt},
546 : : {pattern_eth_ipv4_l2tpv2, ICE_RSS_TYPE_IPV4_L2TPV2, ICE_INSET_NONE, ð_ipv4_l2tpv2_tmplt},
547 : : {pattern_eth_ipv6_l2tpv2, ICE_RSS_TYPE_IPV6_L2TPV2, ICE_INSET_NONE, ð_ipv6_l2tpv2_tmplt},
548 : : {pattern_eth_ipv4_pfcp, ICE_RSS_TYPE_IPV4_PFCP, ICE_INSET_NONE, ð_ipv4_pfcp_tmplt},
549 : : /* IPV6 */
550 : : {pattern_eth_ipv6, ICE_RSS_TYPE_ETH_IPV6, ICE_INSET_NONE, &ipv6_tmplt},
551 : : {pattern_eth_ipv6_frag_ext, ICE_RSS_TYPE_ETH_IPV6_FRAG, ICE_INSET_NONE, &ipv6_frag_tmplt},
552 : : {pattern_eth_ipv6_udp, ICE_RSS_TYPE_ETH_IPV6_UDP, ICE_INSET_NONE, &ipv6_udp_tmplt},
553 : : {pattern_eth_ipv6_tcp, ICE_RSS_TYPE_ETH_IPV6_TCP, ICE_INSET_NONE, &ipv6_tcp_tmplt},
554 : : {pattern_eth_ipv6_sctp, ICE_RSS_TYPE_ETH_IPV6_SCTP, ICE_INSET_NONE, &ipv6_sctp_tmplt},
555 : : {pattern_eth_vlan_ipv6, ICE_RSS_TYPE_VLAN_IPV6, ICE_INSET_NONE, &ipv6_tmplt},
556 : : {pattern_eth_vlan_ipv6_frag_ext, ICE_RSS_TYPE_VLAN_IPV6_FRAG, ICE_INSET_NONE, &ipv6_frag_tmplt},
557 : : {pattern_eth_vlan_ipv6_udp, ICE_RSS_TYPE_VLAN_IPV6_UDP, ICE_INSET_NONE, &ipv6_udp_tmplt},
558 : : {pattern_eth_vlan_ipv6_tcp, ICE_RSS_TYPE_VLAN_IPV6_TCP, ICE_INSET_NONE, &ipv6_tcp_tmplt},
559 : : {pattern_eth_vlan_ipv6_sctp, ICE_RSS_TYPE_VLAN_IPV6_SCTP, ICE_INSET_NONE, &ipv6_sctp_tmplt},
560 : : {pattern_eth_ipv4_gtpu_ipv6, ICE_RSS_TYPE_GTPU_IPV6, ICE_INSET_NONE, &outer_ipv4_inner_ipv6_tmplt},
561 : : {pattern_eth_ipv4_gtpu_ipv6_udp, ICE_RSS_TYPE_GTPU_IPV6_UDP, ICE_INSET_NONE, &outer_ipv4_inner_ipv6_udp_tmplt},
562 : : {pattern_eth_ipv4_gtpu_ipv6_tcp, ICE_RSS_TYPE_GTPU_IPV6_TCP, ICE_INSET_NONE, &outer_ipv4_inner_ipv6_tcp_tmplt},
563 : : {pattern_eth_ipv6_gtpu_ipv6, ICE_RSS_TYPE_GTPU_IPV6, ICE_INSET_NONE, &outer_ipv6_inner_ipv6_tmplt},
564 : : {pattern_eth_ipv6_gtpu_ipv6_udp, ICE_RSS_TYPE_GTPU_IPV6_UDP, ICE_INSET_NONE, &outer_ipv6_inner_ipv6_udp_tmplt},
565 : : {pattern_eth_ipv6_gtpu_ipv6_tcp, ICE_RSS_TYPE_GTPU_IPV6_TCP, ICE_INSET_NONE, &outer_ipv6_inner_ipv6_tcp_tmplt},
566 : : {pattern_eth_ipv4_gtpu_eh_ipv6, ICE_RSS_TYPE_GTPU_IPV6, ICE_INSET_NONE, &outer_ipv4_inner_ipv6_tmplt},
567 : : {pattern_eth_ipv4_gtpu_eh_ipv6_udp, ICE_RSS_TYPE_GTPU_IPV6_UDP, ICE_INSET_NONE, &outer_ipv4_inner_ipv6_udp_tmplt},
568 : : {pattern_eth_ipv4_gtpu_eh_ipv6_tcp, ICE_RSS_TYPE_GTPU_IPV6_TCP, ICE_INSET_NONE, &outer_ipv4_inner_ipv6_tcp_tmplt},
569 : : {pattern_eth_ipv6_gtpu_eh_ipv6, ICE_RSS_TYPE_GTPU_IPV6, ICE_INSET_NONE, &outer_ipv6_inner_ipv6_tmplt},
570 : : {pattern_eth_ipv6_gtpu_eh_ipv6_udp, ICE_RSS_TYPE_GTPU_IPV6_UDP, ICE_INSET_NONE, &outer_ipv6_inner_ipv6_udp_tmplt},
571 : : {pattern_eth_ipv6_gtpu_eh_ipv6_tcp, ICE_RSS_TYPE_GTPU_IPV6_TCP, ICE_INSET_NONE, &outer_ipv6_inner_ipv6_tcp_tmplt},
572 : : {pattern_eth_pppoes_ipv6, ICE_RSS_TYPE_PPPOE_IPV6, ICE_INSET_NONE, &ipv6_tmplt},
573 : : {pattern_eth_pppoes_ipv6_udp, ICE_RSS_TYPE_PPPOE_IPV6_UDP, ICE_INSET_NONE, &ipv6_udp_tmplt},
574 : : {pattern_eth_pppoes_ipv6_tcp, ICE_RSS_TYPE_PPPOE_IPV6_TCP, ICE_INSET_NONE, &ipv6_tcp_tmplt},
575 : : {pattern_eth_ipv6_esp, ICE_RSS_TYPE_IPV6_ESP, ICE_INSET_NONE, ð_ipv6_esp_tmplt},
576 : : {pattern_eth_ipv6_udp_esp, ICE_RSS_TYPE_IPV6_ESP, ICE_INSET_NONE, ð_ipv6_udp_esp_tmplt},
577 : : {pattern_eth_ipv6_ah, ICE_RSS_TYPE_IPV6_AH, ICE_INSET_NONE, ð_ipv6_ah_tmplt},
578 : : {pattern_eth_ipv6_l2tp, ICE_RSS_TYPE_IPV6_L2TPV3, ICE_INSET_NONE, ð_ipv6_l2tpv3_tmplt},
579 : : {pattern_eth_ipv6_pfcp, ICE_RSS_TYPE_IPV6_PFCP, ICE_INSET_NONE, ð_ipv6_pfcp_tmplt},
580 : : /* PPPOE */
581 : : {pattern_eth_pppoes, ICE_RSS_TYPE_PPPOE, ICE_INSET_NONE, &pppoe_tmplt},
582 : : /* MAC */
583 : : {pattern_ethertype, ICE_RSS_TYPE_ETH, ICE_INSET_NONE, ð_tmplt},
584 : : /* EMPTY */
585 : : {pattern_empty, ICE_INSET_NONE, ICE_INSET_NONE, &empty_tmplt},
586 : : };
587 : :
588 : : static struct ice_flow_engine ice_hash_engine = {
589 : : .init = ice_hash_init,
590 : : .create = ice_hash_create,
591 : : .destroy = ice_hash_destroy,
592 : : .uninit = ice_hash_uninit,
593 : : .free = ice_hash_free,
594 : : .name = "hash",
595 : : .type = ICE_FLOW_ENGINE_HASH,
596 : : .rule_size = sizeof(struct ice_hash_flow_cfg),
597 : : };
598 : :
599 : : /* Register parser for os package. */
600 : : struct ice_flow_parser ice_hash_parser = {
601 : : .engine = &ice_hash_engine,
602 : : .array = ice_hash_pattern_list,
603 : : .array_len = RTE_DIM(ice_hash_pattern_list),
604 : : .parse_pattern_action = ice_hash_parse_pattern_action,
605 : : .stage = ICE_FLOW_STAGE_RSS,
606 : : };
607 : :
608 : 301 : RTE_INIT(ice_hash_engine_init)
609 : : {
610 : : struct ice_flow_engine *engine = &ice_hash_engine;
611 : 301 : ice_register_flow_engine(engine);
612 : 301 : }
613 : :
614 : : static int
615 : 0 : ice_hash_init(struct ice_adapter *ad __rte_unused)
616 : : {
617 : 0 : return 0;
618 : : }
619 : :
620 : : static int
621 : 0 : ice_hash_parse_pattern(const struct rte_flow_item pattern[], uint64_t *phint,
622 : : struct rte_flow_error *error)
623 : : {
624 : : const struct rte_flow_item *item = pattern;
625 : : const struct rte_flow_item_gtp_psc *psc;
626 : :
627 [ # # ]: 0 : for (item = pattern; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
628 [ # # ]: 0 : if (item->last) {
629 : 0 : rte_flow_error_set(error, EINVAL,
630 : : RTE_FLOW_ERROR_TYPE_ITEM, item,
631 : : "Not support range");
632 : 0 : return -rte_errno;
633 : : }
634 : :
635 [ # # # # : 0 : switch (item->type) {
# # ]
636 : 0 : case RTE_FLOW_ITEM_TYPE_RAW:
637 : 0 : *phint |= ICE_PHINT_RAW;
638 : 0 : break;
639 : 0 : case RTE_FLOW_ITEM_TYPE_VLAN:
640 : 0 : *phint |= ICE_PHINT_VLAN;
641 : 0 : break;
642 : 0 : case RTE_FLOW_ITEM_TYPE_PPPOES:
643 : 0 : *phint |= ICE_PHINT_PPPOE;
644 : 0 : break;
645 : 0 : case RTE_FLOW_ITEM_TYPE_GTPU:
646 : 0 : *phint |= ICE_PHINT_GTPU;
647 : 0 : break;
648 : 0 : case RTE_FLOW_ITEM_TYPE_GTP_PSC:
649 : 0 : *phint |= ICE_PHINT_GTPU_EH;
650 : 0 : psc = item->spec;
651 [ # # ]: 0 : if (!psc)
652 : : break;
653 [ # # ]: 0 : else if (psc->hdr.type == ICE_GTPU_EH_UPLINK)
654 : 0 : *phint |= ICE_PHINT_GTPU_EH_UP;
655 [ # # ]: 0 : else if (psc->hdr.type == ICE_GTPU_EH_DWNLINK)
656 : 0 : *phint |= ICE_PHINT_GTPU_EH_DWN;
657 : : break;
658 : : default:
659 : : break;
660 : : }
661 : : }
662 : :
663 : : return 0;
664 : : }
665 : :
666 : : static int
667 : 0 : ice_hash_parse_raw_pattern(struct ice_adapter *ad,
668 : : const struct rte_flow_item *item,
669 : : struct rte_flow_error *error,
670 : : struct ice_rss_meta *meta)
671 : : {
672 : : const struct rte_flow_item_raw *raw_spec, *raw_mask;
673 : : struct ice_parser_profile prof;
674 : : struct ice_parser_result rslt;
675 : : uint16_t spec_len, pkt_len;
676 : : uint8_t *pkt_buf, *msk_buf;
677 : : uint8_t tmp_val = 0;
678 : : uint8_t tmp_c = 0;
679 : : int i, j, ret = 0;
680 : :
681 [ # # ]: 0 : if (ad->psr == NULL)
682 : : return -ENOTSUP;
683 : :
684 : 0 : raw_spec = item->spec;
685 : 0 : raw_mask = item->mask;
686 : :
687 [ # # ]: 0 : if (!raw_spec || !raw_mask) {
688 : 0 : rte_flow_error_set(error, EINVAL,
689 : : RTE_FLOW_ERROR_TYPE_ITEM,
690 : : item, "NULL RAW spec/mask");
691 : 0 : return -rte_errno;
692 : : }
693 : :
694 : 0 : spec_len = strnlen((char *)(uintptr_t)raw_spec->pattern,
695 : 0 : raw_spec->length + 1);
696 [ # # ]: 0 : if (spec_len != raw_spec->length)
697 : : return -EINVAL;
698 [ # # ]: 0 : if (strnlen((char *)(uintptr_t)raw_mask->pattern, raw_spec->length + 1) !=
699 : : spec_len)
700 : : return -EINVAL;
701 : :
702 : 0 : pkt_len = spec_len / 2;
703 : :
704 : 0 : pkt_buf = calloc(1, pkt_len);
705 [ # # ]: 0 : if (!pkt_buf)
706 : : return -ENOMEM;
707 : :
708 : 0 : msk_buf = calloc(1, pkt_len);
709 [ # # ]: 0 : if (!msk_buf) {
710 : 0 : free(pkt_buf);
711 : 0 : return -ENOMEM;
712 : : }
713 : :
714 : : /* convert string to int array */
715 [ # # ]: 0 : for (i = 0, j = 0; i < spec_len; i += 2, j++) {
716 : 0 : tmp_c = raw_spec->pattern[i];
717 [ # # ]: 0 : if (tmp_c >= 'a' && tmp_c <= 'f')
718 : 0 : tmp_val = tmp_c - 'a' + 10;
719 [ # # ]: 0 : if (tmp_c >= 'A' && tmp_c <= 'F')
720 : 0 : tmp_val = tmp_c - 'A' + 10;
721 [ # # ]: 0 : if (tmp_c >= '0' && tmp_c <= '9')
722 : : tmp_val = tmp_c - '0';
723 : :
724 : 0 : tmp_c = raw_spec->pattern[i + 1];
725 [ # # ]: 0 : if (tmp_c >= 'a' && tmp_c <= 'f')
726 : 0 : pkt_buf[j] = tmp_val * 16 + tmp_c - 'a' + 10;
727 [ # # ]: 0 : if (tmp_c >= 'A' && tmp_c <= 'F')
728 : 0 : pkt_buf[j] = tmp_val * 16 + tmp_c - 'A' + 10;
729 [ # # ]: 0 : if (tmp_c >= '0' && tmp_c <= '9')
730 : 0 : pkt_buf[j] = tmp_val * 16 + tmp_c - '0';
731 : :
732 : 0 : tmp_c = raw_mask->pattern[i];
733 [ # # ]: 0 : if (tmp_c >= 'a' && tmp_c <= 'f')
734 : 0 : tmp_val = tmp_c - 0x57;
735 [ # # ]: 0 : if (tmp_c >= 'A' && tmp_c <= 'F')
736 : 0 : tmp_val = tmp_c - 0x37;
737 [ # # ]: 0 : if (tmp_c >= '0' && tmp_c <= '9')
738 : : tmp_val = tmp_c - '0';
739 : :
740 : 0 : tmp_c = raw_mask->pattern[i + 1];
741 [ # # ]: 0 : if (tmp_c >= 'a' && tmp_c <= 'f')
742 : 0 : msk_buf[j] = tmp_val * 16 + tmp_c - 'a' + 10;
743 [ # # ]: 0 : if (tmp_c >= 'A' && tmp_c <= 'F')
744 : 0 : msk_buf[j] = tmp_val * 16 + tmp_c - 'A' + 10;
745 [ # # ]: 0 : if (tmp_c >= '0' && tmp_c <= '9')
746 : 0 : msk_buf[j] = tmp_val * 16 + tmp_c - '0';
747 : : }
748 : :
749 : 0 : ret = ice_parser_run(ad->psr, pkt_buf, pkt_len, &rslt);
750 [ # # ]: 0 : if (ret)
751 : 0 : goto free_mem;
752 : :
753 : 0 : ret = ice_parser_profile_init(&rslt, pkt_buf, msk_buf,
754 : : pkt_len, ICE_BLK_RSS, true, &prof);
755 [ # # ]: 0 : if (ret)
756 : 0 : goto free_mem;
757 : :
758 : 0 : memcpy(&meta->raw.prof, &prof, sizeof(prof));
759 : :
760 : 0 : free_mem:
761 : 0 : free(pkt_buf);
762 : 0 : free(msk_buf);
763 : :
764 : 0 : return ret;
765 : : }
766 : :
767 : : static void
768 : 0 : ice_refine_hash_cfg_l234(struct ice_rss_hash_cfg *hash_cfg,
769 : : uint64_t rss_type)
770 : : {
771 : : uint32_t *addl_hdrs = &hash_cfg->addl_hdrs;
772 : : uint64_t *hash_flds = &hash_cfg->hash_flds;
773 : :
774 [ # # ]: 0 : if (*addl_hdrs & ICE_FLOW_SEG_HDR_ETH) {
775 [ # # ]: 0 : if (!(rss_type & RTE_ETH_RSS_ETH))
776 : 0 : *hash_flds &= ~ICE_FLOW_HASH_ETH;
777 [ # # ]: 0 : if (rss_type & RTE_ETH_RSS_L2_SRC_ONLY)
778 : 0 : *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_ETH_DA));
779 [ # # ]: 0 : else if (rss_type & RTE_ETH_RSS_L2_DST_ONLY)
780 : 0 : *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_ETH_SA));
781 : 0 : *addl_hdrs &= ~ICE_FLOW_SEG_HDR_ETH;
782 : : }
783 : :
784 [ # # ]: 0 : if (*addl_hdrs & ICE_FLOW_SEG_HDR_ETH_NON_IP) {
785 [ # # ]: 0 : if (rss_type & RTE_ETH_RSS_ETH)
786 : 0 : *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_ETH_TYPE);
787 : : }
788 : :
789 [ # # ]: 0 : if (*addl_hdrs & ICE_FLOW_SEG_HDR_VLAN) {
790 [ # # ]: 0 : if (rss_type & RTE_ETH_RSS_C_VLAN)
791 : 0 : *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_C_VLAN);
792 [ # # ]: 0 : else if (rss_type & RTE_ETH_RSS_S_VLAN)
793 : 0 : *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_S_VLAN);
794 : : }
795 : :
796 [ # # ]: 0 : if (*addl_hdrs & ICE_FLOW_SEG_HDR_PPPOE) {
797 [ # # ]: 0 : if (!(rss_type & RTE_ETH_RSS_PPPOE))
798 : 0 : *hash_flds &= ~ICE_FLOW_HASH_PPPOE_SESS_ID;
799 : : }
800 : :
801 [ # # ]: 0 : if (*addl_hdrs & ICE_FLOW_SEG_HDR_IPV4) {
802 [ # # ]: 0 : if (rss_type &
803 : : (RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_FRAG_IPV4 |
804 : : RTE_ETH_RSS_NONFRAG_IPV4_UDP |
805 : : RTE_ETH_RSS_NONFRAG_IPV4_TCP |
806 : : RTE_ETH_RSS_NONFRAG_IPV4_SCTP)) {
807 [ # # ]: 0 : if (rss_type & RTE_ETH_RSS_FRAG_IPV4) {
808 : 0 : *addl_hdrs |= ICE_FLOW_SEG_HDR_IPV_FRAG;
809 : 0 : *addl_hdrs &= ~(ICE_FLOW_SEG_HDR_IPV_OTHER);
810 : 0 : *hash_flds |=
811 : : BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_ID);
812 : : }
813 [ # # ]: 0 : if (rss_type & RTE_ETH_RSS_L3_SRC_ONLY)
814 : 0 : *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA));
815 [ # # ]: 0 : else if (rss_type & RTE_ETH_RSS_L3_DST_ONLY)
816 : 0 : *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA));
817 [ # # ]: 0 : else if (rss_type &
818 : : (RTE_ETH_RSS_L4_SRC_ONLY |
819 : : RTE_ETH_RSS_L4_DST_ONLY))
820 : 0 : *hash_flds &= ~ICE_FLOW_HASH_IPV4;
821 : : } else {
822 : 0 : *hash_flds &= ~ICE_FLOW_HASH_IPV4;
823 : : }
824 : :
825 [ # # ]: 0 : if (rss_type & RTE_ETH_RSS_IPV4_CHKSUM)
826 : 0 : *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_CHKSUM);
827 : : }
828 : :
829 [ # # ]: 0 : if (*addl_hdrs & ICE_FLOW_SEG_HDR_IPV6) {
830 [ # # ]: 0 : if (rss_type &
831 : : (RTE_ETH_RSS_IPV6 | RTE_ETH_RSS_FRAG_IPV6 |
832 : : RTE_ETH_RSS_NONFRAG_IPV6_UDP |
833 : : RTE_ETH_RSS_NONFRAG_IPV6_TCP |
834 : : RTE_ETH_RSS_NONFRAG_IPV6_SCTP)) {
835 [ # # ]: 0 : if (rss_type & RTE_ETH_RSS_FRAG_IPV6)
836 : 0 : *hash_flds |=
837 : : BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_ID);
838 [ # # ]: 0 : if (rss_type & RTE_ETH_RSS_L3_SRC_ONLY)
839 : 0 : *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA));
840 [ # # ]: 0 : else if (rss_type & RTE_ETH_RSS_L3_DST_ONLY)
841 : 0 : *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA));
842 [ # # ]: 0 : else if (rss_type &
843 : : (RTE_ETH_RSS_L4_SRC_ONLY |
844 : : RTE_ETH_RSS_L4_DST_ONLY))
845 : 0 : *hash_flds &= ~ICE_FLOW_HASH_IPV6;
846 : : } else {
847 : 0 : *hash_flds &= ~ICE_FLOW_HASH_IPV6;
848 : : }
849 : :
850 [ # # ]: 0 : if (rss_type & RTE_ETH_RSS_L3_PRE32) {
851 [ # # ]: 0 : if (rss_type & RTE_ETH_RSS_L3_SRC_ONLY) {
852 : 0 : *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA));
853 : 0 : *hash_flds |= (BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE32_SA));
854 [ # # ]: 0 : } else if (rss_type & RTE_ETH_RSS_L3_DST_ONLY) {
855 : 0 : *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA));
856 : 0 : *hash_flds |= (BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE32_DA));
857 : : } else {
858 : 0 : *hash_flds &= ~ICE_FLOW_HASH_IPV6;
859 : 0 : *hash_flds |= ICE_FLOW_HASH_IPV6_PRE32;
860 : : }
861 : : }
862 [ # # ]: 0 : if (rss_type & RTE_ETH_RSS_L3_PRE48) {
863 [ # # ]: 0 : if (rss_type & RTE_ETH_RSS_L3_SRC_ONLY) {
864 : 0 : *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA));
865 : 0 : *hash_flds |= (BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE48_SA));
866 [ # # ]: 0 : } else if (rss_type & RTE_ETH_RSS_L3_DST_ONLY) {
867 : 0 : *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA));
868 : 0 : *hash_flds |= (BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE48_DA));
869 : : } else {
870 : 0 : *hash_flds &= ~ICE_FLOW_HASH_IPV6;
871 : 0 : *hash_flds |= ICE_FLOW_HASH_IPV6_PRE48;
872 : : }
873 : : }
874 [ # # ]: 0 : if (rss_type & RTE_ETH_RSS_L3_PRE64) {
875 [ # # ]: 0 : if (rss_type & RTE_ETH_RSS_L3_SRC_ONLY) {
876 : 0 : *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA));
877 : 0 : *hash_flds |= (BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE64_SA));
878 [ # # ]: 0 : } else if (rss_type & RTE_ETH_RSS_L3_DST_ONLY) {
879 : 0 : *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA));
880 : 0 : *hash_flds |= (BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE64_DA));
881 : : } else {
882 : 0 : *hash_flds &= ~ICE_FLOW_HASH_IPV6;
883 : 0 : *hash_flds |= ICE_FLOW_HASH_IPV6_PRE64;
884 : : }
885 : : }
886 : : }
887 : :
888 [ # # ]: 0 : if (*addl_hdrs & ICE_FLOW_SEG_HDR_UDP) {
889 [ # # ]: 0 : if (rss_type &
890 : : (RTE_ETH_RSS_NONFRAG_IPV4_UDP |
891 : : RTE_ETH_RSS_NONFRAG_IPV6_UDP)) {
892 [ # # ]: 0 : if (rss_type & RTE_ETH_RSS_L4_SRC_ONLY)
893 : 0 : *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_DST_PORT));
894 [ # # ]: 0 : else if (rss_type & RTE_ETH_RSS_L4_DST_ONLY)
895 : 0 : *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_SRC_PORT));
896 [ # # ]: 0 : else if (rss_type &
897 : : (RTE_ETH_RSS_L3_SRC_ONLY |
898 : : RTE_ETH_RSS_L3_DST_ONLY))
899 : 0 : *hash_flds &= ~ICE_FLOW_HASH_UDP_PORT;
900 : : } else {
901 : 0 : *hash_flds &= ~ICE_FLOW_HASH_UDP_PORT;
902 : : }
903 : :
904 [ # # ]: 0 : if (rss_type & RTE_ETH_RSS_L4_CHKSUM)
905 : 0 : *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_CHKSUM);
906 : : }
907 : :
908 [ # # ]: 0 : if (*addl_hdrs & ICE_FLOW_SEG_HDR_TCP) {
909 [ # # ]: 0 : if (rss_type &
910 : : (RTE_ETH_RSS_NONFRAG_IPV4_TCP |
911 : : RTE_ETH_RSS_NONFRAG_IPV6_TCP)) {
912 [ # # ]: 0 : if (rss_type & RTE_ETH_RSS_L4_SRC_ONLY)
913 : 0 : *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_DST_PORT));
914 [ # # ]: 0 : else if (rss_type & RTE_ETH_RSS_L4_DST_ONLY)
915 : 0 : *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_SRC_PORT));
916 [ # # ]: 0 : else if (rss_type &
917 : : (RTE_ETH_RSS_L3_SRC_ONLY |
918 : : RTE_ETH_RSS_L3_DST_ONLY))
919 : 0 : *hash_flds &= ~ICE_FLOW_HASH_TCP_PORT;
920 : : } else {
921 : 0 : *hash_flds &= ~ICE_FLOW_HASH_TCP_PORT;
922 : : }
923 : :
924 [ # # ]: 0 : if (rss_type & RTE_ETH_RSS_L4_CHKSUM)
925 : 0 : *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_CHKSUM);
926 : : }
927 : :
928 [ # # ]: 0 : if (*addl_hdrs & ICE_FLOW_SEG_HDR_SCTP) {
929 [ # # ]: 0 : if (rss_type &
930 : : (RTE_ETH_RSS_NONFRAG_IPV4_SCTP |
931 : : RTE_ETH_RSS_NONFRAG_IPV6_SCTP)) {
932 [ # # ]: 0 : if (rss_type & RTE_ETH_RSS_L4_SRC_ONLY)
933 : 0 : *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_DST_PORT));
934 [ # # ]: 0 : else if (rss_type & RTE_ETH_RSS_L4_DST_ONLY)
935 : 0 : *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT));
936 [ # # ]: 0 : else if (rss_type &
937 : : (RTE_ETH_RSS_L3_SRC_ONLY |
938 : : RTE_ETH_RSS_L3_DST_ONLY))
939 : 0 : *hash_flds &= ~ICE_FLOW_HASH_SCTP_PORT;
940 : : } else {
941 : 0 : *hash_flds &= ~ICE_FLOW_HASH_SCTP_PORT;
942 : : }
943 : :
944 [ # # ]: 0 : if (rss_type & RTE_ETH_RSS_L4_CHKSUM)
945 : 0 : *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_CHKSUM);
946 : : }
947 : :
948 [ # # ]: 0 : if (*addl_hdrs & ICE_FLOW_SEG_HDR_L2TPV3) {
949 [ # # ]: 0 : if (!(rss_type & RTE_ETH_RSS_L2TPV3))
950 : 0 : *hash_flds &= ~ICE_FLOW_HASH_L2TPV3_SESS_ID;
951 : : }
952 : :
953 [ # # ]: 0 : if (*addl_hdrs & ICE_FLOW_SEG_HDR_L2TPV2) {
954 [ # # ]: 0 : if (!(rss_type & RTE_ETH_RSS_L2TPV2))
955 : 0 : *hash_flds &= ~ICE_FLOW_HASH_L2TPV2_SESS_ID;
956 : : }
957 : :
958 [ # # ]: 0 : if (*addl_hdrs & ICE_FLOW_SEG_HDR_ESP) {
959 [ # # ]: 0 : if (!(rss_type & RTE_ETH_RSS_ESP))
960 : 0 : *hash_flds &= ~ICE_FLOW_HASH_ESP_SPI;
961 : : }
962 : :
963 [ # # ]: 0 : if (*addl_hdrs & ICE_FLOW_SEG_HDR_AH) {
964 [ # # ]: 0 : if (!(rss_type & RTE_ETH_RSS_AH))
965 : 0 : *hash_flds &= ~ICE_FLOW_HASH_AH_SPI;
966 : : }
967 : :
968 [ # # ]: 0 : if (*addl_hdrs & ICE_FLOW_SEG_HDR_PFCP_SESSION) {
969 [ # # ]: 0 : if (!(rss_type & RTE_ETH_RSS_PFCP))
970 : 0 : *hash_flds &= ~ICE_FLOW_HASH_PFCP_SEID;
971 : : }
972 : 0 : }
973 : :
974 : : static void
975 : 0 : ice_refine_proto_hdrs_by_pattern(struct ice_rss_hash_cfg *hash_cfg,
976 : : uint64_t phint)
977 : : {
978 : : uint32_t *addl_hdrs = &hash_cfg->addl_hdrs;
979 [ # # ]: 0 : if (phint & ICE_PHINT_VLAN)
980 : 0 : *addl_hdrs |= ICE_FLOW_SEG_HDR_VLAN;
981 : :
982 [ # # ]: 0 : if (phint & ICE_PHINT_PPPOE)
983 : 0 : *addl_hdrs |= ICE_FLOW_SEG_HDR_PPPOE;
984 : :
985 [ # # ]: 0 : if (phint & ICE_PHINT_GTPU_EH_DWN)
986 : 0 : *addl_hdrs |= ICE_FLOW_SEG_HDR_GTPU_DWN;
987 [ # # ]: 0 : else if (phint & ICE_PHINT_GTPU_EH_UP)
988 : 0 : *addl_hdrs |= ICE_FLOW_SEG_HDR_GTPU_UP;
989 [ # # ]: 0 : else if (phint & ICE_PHINT_GTPU_EH)
990 : 0 : *addl_hdrs |= ICE_FLOW_SEG_HDR_GTPU_EH;
991 [ # # ]: 0 : else if (phint & ICE_PHINT_GTPU)
992 : 0 : *addl_hdrs |= ICE_FLOW_SEG_HDR_GTPU_IP;
993 : 0 : }
994 : :
995 : : static void
996 : 0 : ice_refine_hash_cfg_gtpu(struct ice_rss_hash_cfg *hash_cfg,
997 : : uint64_t rss_type)
998 : : {
999 : : uint32_t *addl_hdrs = &hash_cfg->addl_hdrs;
1000 : : uint64_t *hash_flds = &hash_cfg->hash_flds;
1001 : :
1002 : : /* update hash field for gtpu eh/gtpu dwn/gtpu up. */
1003 [ # # ]: 0 : if (!(rss_type & RTE_ETH_RSS_GTPU))
1004 : : return;
1005 : :
1006 [ # # ]: 0 : if (*addl_hdrs & ICE_FLOW_SEG_HDR_GTPU_DWN)
1007 : 0 : *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_GTPU_DWN_TEID);
1008 [ # # ]: 0 : else if (*addl_hdrs & ICE_FLOW_SEG_HDR_GTPU_UP)
1009 : 0 : *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_GTPU_UP_TEID);
1010 [ # # ]: 0 : else if (*addl_hdrs & ICE_FLOW_SEG_HDR_GTPU_EH)
1011 : 0 : *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_GTPU_EH_TEID);
1012 [ # # ]: 0 : else if (*addl_hdrs & ICE_FLOW_SEG_HDR_GTPU_IP)
1013 : 0 : *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_GTPU_IP_TEID);
1014 : : }
1015 : :
1016 : 0 : static void ice_refine_hash_cfg(struct ice_rss_hash_cfg *hash_cfg,
1017 : : uint64_t rss_type, uint64_t phint)
1018 : : {
1019 : 0 : ice_refine_proto_hdrs_by_pattern(hash_cfg, phint);
1020 : 0 : ice_refine_hash_cfg_l234(hash_cfg, rss_type);
1021 : 0 : ice_refine_hash_cfg_gtpu(hash_cfg, rss_type);
1022 : 0 : }
1023 : :
1024 : : static uint64_t invalid_rss_comb[] = {
1025 : : RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_NONFRAG_IPV4_UDP,
1026 : : RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_NONFRAG_IPV4_TCP,
1027 : : RTE_ETH_RSS_IPV6 | RTE_ETH_RSS_NONFRAG_IPV6_UDP,
1028 : : RTE_ETH_RSS_IPV6 | RTE_ETH_RSS_NONFRAG_IPV6_TCP,
1029 : : RTE_ETH_RSS_L3_PRE40 |
1030 : : RTE_ETH_RSS_L3_PRE56 |
1031 : : RTE_ETH_RSS_L3_PRE96
1032 : : };
1033 : :
1034 : : struct rss_attr_type {
1035 : : uint64_t attr;
1036 : : uint64_t type;
1037 : : };
1038 : :
1039 : : static struct rss_attr_type rss_attr_to_valid_type[] = {
1040 : : {RTE_ETH_RSS_L2_SRC_ONLY | RTE_ETH_RSS_L2_DST_ONLY, RTE_ETH_RSS_ETH},
1041 : : {RTE_ETH_RSS_L3_SRC_ONLY | RTE_ETH_RSS_L3_DST_ONLY, VALID_RSS_L3},
1042 : : {RTE_ETH_RSS_L4_SRC_ONLY | RTE_ETH_RSS_L4_DST_ONLY, VALID_RSS_L4},
1043 : : /* current ipv6 prefix only supports prefix 64 bits*/
1044 : : {RTE_ETH_RSS_L3_PRE32, VALID_RSS_IPV6},
1045 : : {RTE_ETH_RSS_L3_PRE48, VALID_RSS_IPV6},
1046 : : {RTE_ETH_RSS_L3_PRE64, VALID_RSS_IPV6},
1047 : : {INVALID_RSS_ATTR, 0}
1048 : : };
1049 : :
1050 : : static bool
1051 : 0 : ice_any_invalid_rss_type(enum rte_eth_hash_function rss_func,
1052 : : uint64_t rss_type, uint64_t allow_rss_type)
1053 : : {
1054 : : uint32_t i;
1055 : :
1056 : : /**
1057 : : * Check if l3/l4 SRC/DST_ONLY is set for SYMMETRIC_TOEPLITZ
1058 : : * hash function.
1059 : : */
1060 [ # # ]: 0 : if (rss_func == RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ) {
1061 [ # # ]: 0 : if (rss_type & (RTE_ETH_RSS_L3_SRC_ONLY | RTE_ETH_RSS_L3_DST_ONLY |
1062 : : RTE_ETH_RSS_L4_SRC_ONLY | RTE_ETH_RSS_L4_DST_ONLY))
1063 : : return true;
1064 : :
1065 [ # # ]: 0 : if (!(rss_type &
1066 : : (RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_IPV6 |
1067 : : RTE_ETH_RSS_FRAG_IPV4 | RTE_ETH_RSS_FRAG_IPV6 |
1068 : : RTE_ETH_RSS_NONFRAG_IPV4_UDP | RTE_ETH_RSS_NONFRAG_IPV6_UDP |
1069 : : RTE_ETH_RSS_NONFRAG_IPV4_TCP | RTE_ETH_RSS_NONFRAG_IPV6_TCP |
1070 : : RTE_ETH_RSS_NONFRAG_IPV4_SCTP | RTE_ETH_RSS_NONFRAG_IPV6_SCTP)))
1071 : : return true;
1072 : : }
1073 : :
1074 : : /* check invalid combination */
1075 [ # # ]: 0 : for (i = 0; i < RTE_DIM(invalid_rss_comb); i++) {
1076 [ # # ]: 0 : if (rte_popcount64(rss_type & invalid_rss_comb[i]) > 1)
1077 : : return true;
1078 : : }
1079 : :
1080 : : /* check invalid RSS attribute */
1081 [ # # ]: 0 : for (i = 0; i < RTE_DIM(rss_attr_to_valid_type); i++) {
1082 : : struct rss_attr_type *rat = &rss_attr_to_valid_type[i];
1083 : :
1084 [ # # # # ]: 0 : if (rat->attr & rss_type && !(rat->type & rss_type))
1085 : : return true;
1086 : : }
1087 : :
1088 : : /* check not allowed RSS type */
1089 : 0 : rss_type &= ~VALID_RSS_ATTR;
1090 : :
1091 : 0 : return ((rss_type & allow_rss_type) != rss_type);
1092 : : }
1093 : :
1094 : : static int
1095 : 0 : ice_hash_parse_action_check(const struct ci_flow_actions *actions,
1096 : : const struct ci_flow_actions_check_param *param __rte_unused,
1097 : : struct rte_flow_error *error)
1098 : : {
1099 : : const struct rte_flow_action_rss *rss;
1100 : :
1101 : 0 : rss = actions->actions[0]->conf;
1102 : :
1103 [ # # ]: 0 : switch (rss->func) {
1104 : : case RTE_ETH_HASH_FUNCTION_DEFAULT:
1105 : : case RTE_ETH_HASH_FUNCTION_TOEPLITZ:
1106 : : case RTE_ETH_HASH_FUNCTION_SIMPLE_XOR:
1107 : : case RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ:
1108 : : break;
1109 : 0 : default:
1110 : 0 : return rte_flow_error_set(error, ENOTSUP,
1111 : : RTE_FLOW_ERROR_TYPE_ACTION_CONF, rss,
1112 : : "Selected RSS hash function not supported");
1113 : : }
1114 : :
1115 [ # # ]: 0 : if (rss->level)
1116 : 0 : return rte_flow_error_set(error, ENOTSUP,
1117 : : RTE_FLOW_ERROR_TYPE_ACTION_CONF, rss,
1118 : : "a nonzero RSS encapsulation level is not supported");
1119 : :
1120 [ # # ]: 0 : if (rss->key_len)
1121 : 0 : return rte_flow_error_set(error, ENOTSUP,
1122 : : RTE_FLOW_ERROR_TYPE_ACTION_CONF, rss,
1123 : : "a nonzero RSS key_len is not supported");
1124 : :
1125 [ # # ]: 0 : if (rss->queue)
1126 : 0 : return rte_flow_error_set(error, ENOTSUP,
1127 : : RTE_FLOW_ERROR_TYPE_ACTION_CONF, rss,
1128 : : "a non-NULL RSS queue is not supported");
1129 : :
1130 : : return 0;
1131 : : }
1132 : :
1133 : : static int
1134 : 0 : ice_hash_parse_rss_action(struct ice_pattern_match_item *pattern_match_item,
1135 : : const struct rte_flow_action_rss *rss,
1136 : : uint64_t pattern_hint, struct ice_rss_meta *rss_meta,
1137 : : struct rte_flow_error *error)
1138 : : {
1139 : 0 : struct ice_rss_hash_cfg *cfg = pattern_match_item->meta;
1140 : : uint64_t rss_type;
1141 : : bool symm = false;
1142 : :
1143 [ # # ]: 0 : if (rss->func == RTE_ETH_HASH_FUNCTION_SIMPLE_XOR) {
1144 [ # # ]: 0 : if (pattern_match_item->pattern_list != pattern_empty) {
1145 : 0 : return rte_flow_error_set(error, ENOTSUP,
1146 : : RTE_FLOW_ERROR_TYPE_ACTION_CONF, rss,
1147 : : "XOR hash function is only supported for empty pattern");
1148 : : }
1149 : 0 : rss_meta->hash_function = RTE_ETH_HASH_FUNCTION_SIMPLE_XOR;
1150 : 0 : return 0;
1151 : : }
1152 : :
1153 [ # # ]: 0 : if (rss->func == RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ) {
1154 : 0 : rss_meta->hash_function = RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ;
1155 : : symm = true;
1156 : : }
1157 : :
1158 : : /* If pattern type is raw, no need to refine rss type */
1159 [ # # ]: 0 : if (pattern_hint == ICE_PHINT_RAW) {
1160 : 0 : rss_meta->raw.symm = symm;
1161 : 0 : return 0;
1162 : : }
1163 : 0 : cfg->symm = symm;
1164 : :
1165 : : /**
1166 : : * Check simultaneous use of SRC_ONLY and DST_ONLY
1167 : : * of the same level.
1168 : : */
1169 [ # # ]: 0 : rss_type = rte_eth_rss_hf_refine(rss->types);
1170 : :
1171 [ # # ]: 0 : if (ice_any_invalid_rss_type(rss->func, rss_type,
1172 : : pattern_match_item->input_set_mask_o))
1173 : 0 : return rte_flow_error_set(error, ENOTSUP,
1174 : : RTE_FLOW_ERROR_TYPE_ACTION_CONF,
1175 : : rss, "RSS type not supported");
1176 : :
1177 : 0 : rss_meta->cfg = *cfg;
1178 : 0 : ice_refine_hash_cfg(&rss_meta->cfg,
1179 : : rss_type, pattern_hint);
1180 : :
1181 : 0 : return 0;
1182 : : }
1183 : :
1184 : : static int
1185 : 0 : ice_hash_parse_pattern_action(__rte_unused struct ice_adapter *ad,
1186 : : struct ice_pattern_match_item *array,
1187 : : uint32_t array_len,
1188 : : const struct rte_flow_item pattern[],
1189 : : const struct rte_flow_action actions[],
1190 : : const struct rte_flow_attr *attr,
1191 : : void **meta,
1192 : : struct rte_flow_error *error)
1193 : : {
1194 : 0 : struct ci_flow_actions parsed_actions = {0};
1195 : 0 : struct ci_flow_actions_check_param param = {
1196 : 0 : .allowed_types = (enum rte_flow_action_type[]){
1197 : : RTE_FLOW_ACTION_TYPE_RSS,
1198 : : RTE_FLOW_ACTION_TYPE_END
1199 : : },
1200 : : .max_actions = 1,
1201 : : .check = ice_hash_parse_action_check,
1202 : : };
1203 : : const struct rte_flow_action_rss *rss;
1204 : : struct ice_pattern_match_item *pattern_match_item;
1205 : : struct ice_rss_meta *rss_meta_ptr;
1206 : 0 : uint64_t phint = ICE_PHINT_NONE;
1207 : : int ret = 0;
1208 : :
1209 : 0 : ret = ci_flow_check_attr(attr, NULL, error);
1210 [ # # ]: 0 : if (ret)
1211 : : return ret;
1212 : :
1213 : 0 : ret = ci_flow_check_actions(actions, ¶m, &parsed_actions, error);
1214 [ # # ]: 0 : if (ret)
1215 : : return ret;
1216 : :
1217 : 0 : rss_meta_ptr = rte_zmalloc(NULL, sizeof(*rss_meta_ptr), 0);
1218 [ # # ]: 0 : if (!rss_meta_ptr) {
1219 : 0 : rte_flow_error_set(error, EINVAL,
1220 : : RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1221 : : "No memory for rss_meta_ptr");
1222 : 0 : return -ENOMEM;
1223 : : }
1224 : :
1225 : : /* Check rss supported pattern and find matched pattern. */
1226 : 0 : pattern_match_item = ice_search_pattern_match_item(ad, pattern, array,
1227 : : array_len, error);
1228 [ # # ]: 0 : if (!pattern_match_item) {
1229 : 0 : ret = -rte_errno;
1230 : 0 : goto error;
1231 : : }
1232 : :
1233 : 0 : ret = ice_hash_parse_pattern(pattern, &phint, error);
1234 [ # # ]: 0 : if (ret)
1235 : 0 : goto error;
1236 : :
1237 [ # # ]: 0 : if (phint == ICE_PHINT_RAW) {
1238 : 0 : rss_meta_ptr->raw.raw_ena = true;
1239 : 0 : ret = ice_hash_parse_raw_pattern(ad, pattern, error, rss_meta_ptr);
1240 [ # # ]: 0 : if (ret) {
1241 : 0 : rte_flow_error_set(error, EINVAL,
1242 : : RTE_FLOW_ERROR_TYPE_ITEM, NULL,
1243 : : "Parse raw pattern failed");
1244 : 0 : goto error;
1245 : : }
1246 : : }
1247 : :
1248 : 0 : rss = parsed_actions.actions[0]->conf;
1249 : 0 : ret = ice_hash_parse_rss_action(pattern_match_item, rss, phint,
1250 : : rss_meta_ptr, error);
1251 : :
1252 : 0 : error:
1253 [ # # ]: 0 : if (!ret && meta)
1254 : 0 : *meta = rss_meta_ptr;
1255 : : else
1256 : 0 : rte_free(rss_meta_ptr);
1257 : 0 : free(pattern_match_item);
1258 : :
1259 : 0 : return ret;
1260 : : }
1261 : :
1262 : : static int
1263 : 0 : ice_hash_add_raw_cfg(struct ice_adapter *ad,
1264 : : struct ice_rss_raw_cfg *cfg, u16 vsi_handle)
1265 : : {
1266 : 0 : struct ice_parser_profile *prof = &cfg->prof;
1267 : : struct ice_rss_prof_info *rss_prof;
1268 : 0 : struct ice_hw *hw = &ad->hw;
1269 : : int i, ptg, ret;
1270 : : u64 id;
1271 : :
1272 : 0 : id = (u64)ice_find_first_bit(prof->ptypes, UINT16_MAX);
1273 : :
1274 : 0 : ptg = hw->blk[ICE_BLK_RSS].xlt1.t[id];
1275 : : rss_prof = &ad->rss_prof_info[ptg];
1276 : : /* check if ptg already has profile */
1277 [ # # ]: 0 : if (rss_prof->prof.fv_num) {
1278 [ # # ]: 0 : for (i = 0; i < ICE_MAX_FV_WORDS; i++) {
1279 : 0 : if (rss_prof->prof.fv[i].proto_id !=
1280 [ # # ]: 0 : prof->fv[i].proto_id ||
1281 : 0 : rss_prof->prof.fv[i].offset !=
1282 [ # # ]: 0 : prof->fv[i].offset)
1283 : : break;
1284 : : }
1285 : :
1286 : : /* current profile is matched, check symmetric hash */
1287 [ # # ]: 0 : if (i == ICE_MAX_FV_WORDS) {
1288 [ # # ]: 0 : if (rss_prof->symm != cfg->symm)
1289 : 0 : goto update_symm;
1290 : :
1291 : : return 0;
1292 : : }
1293 : :
1294 : : /* current profile is not matched, remove it */
1295 : 0 : ret = ice_rem_prof_id_flow(hw, ICE_BLK_RSS,
1296 : 0 : ice_get_hw_vsi_num(hw, vsi_handle),
1297 : : id);
1298 [ # # ]: 0 : if (ret) {
1299 : 0 : PMD_DRV_LOG(ERR, "remove RSS flow failed");
1300 : 0 : return ret;
1301 : : }
1302 : :
1303 : 0 : ret = ice_rem_prof(hw, ICE_BLK_RSS, id);
1304 [ # # ]: 0 : if (ret) {
1305 : 0 : PMD_DRV_LOG(ERR, "remove RSS profile failed");
1306 : 0 : return ret;
1307 : : }
1308 : : }
1309 : :
1310 : : /* add new profile */
1311 : 0 : ret = ice_flow_set_hw_prof(hw, vsi_handle, 0, prof, ICE_BLK_RSS);
1312 [ # # ]: 0 : if (ret) {
1313 : 0 : PMD_DRV_LOG(ERR, "HW profile add failed");
1314 : 0 : return ret;
1315 : : }
1316 : :
1317 : 0 : rss_prof->symm = cfg->symm;
1318 : 0 : ice_memcpy(&rss_prof->prof, prof,
1319 : : sizeof(struct ice_parser_profile),
1320 : : ICE_NONDMA_TO_NONDMA);
1321 : :
1322 : 0 : update_symm:
1323 : 0 : ice_rss_update_raw_symm(hw, cfg, id);
1324 : 0 : return 0;
1325 : : }
1326 : :
1327 : : static int
1328 : 0 : ice_hash_create(struct ice_adapter *ad,
1329 : : struct rte_flow *flow,
1330 : : void *meta,
1331 : : struct rte_flow_error *error)
1332 : : {
1333 : 0 : struct ice_pf *pf = &ad->pf;
1334 : 0 : struct ice_hw *hw = ICE_PF_TO_HW(pf);
1335 : 0 : struct ice_vsi *vsi = pf->main_vsi;
1336 : : int ret;
1337 : : uint32_t reg;
1338 : : struct ice_hash_flow_cfg *filter_ptr;
1339 : : struct ice_rss_meta *rss_meta = (struct ice_rss_meta *)meta;
1340 : 0 : uint8_t hash_function = rss_meta->hash_function;
1341 : :
1342 : 0 : filter_ptr = rte_zmalloc("ice_rss_filter",
1343 : : sizeof(struct ice_hash_flow_cfg), 0);
1344 [ # # ]: 0 : if (!filter_ptr) {
1345 : 0 : rte_flow_error_set(error, EINVAL,
1346 : : RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1347 : : "No memory for filter_ptr");
1348 : 0 : return -ENOMEM;
1349 : : }
1350 : :
1351 [ # # ]: 0 : if (hash_function == RTE_ETH_HASH_FUNCTION_SIMPLE_XOR) {
1352 : : /* Enable registers for simple_xor hash function. */
1353 : 0 : reg = ICE_READ_REG(hw, VSIQF_HASH_CTL(vsi->vsi_id));
1354 : 0 : reg = (reg & (~VSIQF_HASH_CTL_HASH_SCHEME_M)) |
1355 : : (2 << VSIQF_HASH_CTL_HASH_SCHEME_S);
1356 : 0 : ICE_WRITE_REG(hw, VSIQF_HASH_CTL(vsi->vsi_id), reg);
1357 : :
1358 : 0 : filter_ptr->simple_xor = 1;
1359 : :
1360 : 0 : goto out;
1361 : : } else {
1362 [ # # ]: 0 : if (rss_meta->raw.raw_ena) {
1363 : 0 : filter_ptr->rss_cfg.raw = rss_meta->raw;
1364 : 0 : ret = ice_hash_add_raw_cfg(ad, &rss_meta->raw,
1365 : 0 : pf->main_vsi->idx);
1366 [ # # ]: 0 : if (ret) {
1367 : 0 : rte_flow_error_set(error, EINVAL,
1368 : : RTE_FLOW_ERROR_TYPE_HANDLE,
1369 : : NULL,
1370 : : "rss flow create fail");
1371 : 0 : goto error;
1372 : : }
1373 : : } else {
1374 : 0 : filter_ptr->rss_cfg.hash = rss_meta->cfg;
1375 : 0 : ret = ice_add_rss_cfg_wrap(pf, vsi->idx,
1376 : : &filter_ptr->rss_cfg.hash);
1377 [ # # ]: 0 : if (ret) {
1378 : 0 : rte_flow_error_set(error, EINVAL,
1379 : : RTE_FLOW_ERROR_TYPE_HANDLE,
1380 : : NULL,
1381 : : "rss flow create fail");
1382 : 0 : goto error;
1383 : : }
1384 : : }
1385 : : }
1386 : :
1387 : 0 : out:
1388 : 0 : flow->rule = filter_ptr;
1389 : 0 : rte_free(meta);
1390 : 0 : return 0;
1391 : :
1392 : 0 : error:
1393 : 0 : rte_free(filter_ptr);
1394 : 0 : rte_free(meta);
1395 : 0 : return -rte_errno;
1396 : : }
1397 : :
1398 : : static int
1399 : 0 : ice_hash_rem_raw_cfg(struct ice_adapter *ad,
1400 : : struct ice_parser_profile *prof,
1401 : : u16 vsi_handle)
1402 : : {
1403 : 0 : struct ice_hw *hw = &ad->hw;
1404 : : int ptg, ret;
1405 : : u16 vsig;
1406 : : u64 id;
1407 : :
1408 : 0 : id = (u64)ice_find_first_bit(prof->ptypes, 0xFFFF);
1409 : :
1410 : 0 : ptg = hw->blk[ICE_BLK_RSS].xlt1.t[id];
1411 : :
1412 : 0 : memset(&ad->rss_prof_info[ptg], 0,
1413 : : sizeof(struct ice_rss_prof_info));
1414 : :
1415 : : /* check if vsig is already removed */
1416 : 0 : ret = ice_vsig_find_vsi(hw, ICE_BLK_RSS,
1417 : 0 : ice_get_hw_vsi_num(hw, vsi_handle), &vsig);
1418 [ # # # # ]: 0 : if (!ret && vsig) {
1419 : 0 : ret = ice_rem_prof_id_flow(hw, ICE_BLK_RSS,
1420 : 0 : ice_get_hw_vsi_num(hw, vsi_handle),
1421 : : id);
1422 [ # # ]: 0 : if (ret)
1423 : 0 : goto err;
1424 : :
1425 : 0 : ret = ice_rem_prof(hw, ICE_BLK_RSS, id);
1426 [ # # ]: 0 : if (ret)
1427 : 0 : goto err;
1428 : : }
1429 : :
1430 : : return 0;
1431 : :
1432 : 0 : err:
1433 : 0 : PMD_DRV_LOG(ERR, "HW profile remove failed");
1434 : 0 : return ret;
1435 : : }
1436 : :
1437 : : static int
1438 : 0 : ice_hash_destroy(struct ice_adapter *ad,
1439 : : struct rte_flow *flow,
1440 : : struct rte_flow_error *error)
1441 : : {
1442 : 0 : struct ice_pf *pf = ICE_DEV_PRIVATE_TO_PF(ad);
1443 : 0 : struct ice_hw *hw = ICE_PF_TO_HW(pf);
1444 : 0 : struct ice_vsi *vsi = pf->main_vsi;
1445 : : int ret;
1446 : : uint32_t reg;
1447 : : struct ice_hash_flow_cfg *filter_ptr;
1448 : :
1449 : 0 : filter_ptr = (struct ice_hash_flow_cfg *)flow->rule;
1450 : :
1451 [ # # ]: 0 : if (filter_ptr->simple_xor == 1) {
1452 : : /* Return to symmetric_toeplitz state. */
1453 : 0 : reg = ICE_READ_REG(hw, VSIQF_HASH_CTL(vsi->vsi_id));
1454 : 0 : reg = (reg & (~VSIQF_HASH_CTL_HASH_SCHEME_M)) |
1455 : : (1 << VSIQF_HASH_CTL_HASH_SCHEME_S);
1456 : 0 : ICE_WRITE_REG(hw, VSIQF_HASH_CTL(vsi->vsi_id), reg);
1457 : : } else {
1458 [ # # ]: 0 : if (filter_ptr->rss_cfg.raw.raw_ena) {
1459 : : ret =
1460 : 0 : ice_hash_rem_raw_cfg(ad, &filter_ptr->rss_cfg.raw.prof,
1461 : 0 : pf->main_vsi->idx);
1462 [ # # ]: 0 : if (ret) {
1463 : 0 : rte_flow_error_set(error, EINVAL,
1464 : : RTE_FLOW_ERROR_TYPE_HANDLE,
1465 : : NULL,
1466 : : "rss flow destroy fail");
1467 : 0 : goto error;
1468 : : }
1469 : : } else {
1470 : 0 : ret = ice_rem_rss_cfg_wrap(pf, vsi->idx,
1471 : : &filter_ptr->rss_cfg.hash);
1472 : : /* Fixme: Ignore the error if a rule does not exist.
1473 : : * Currently a rule for inputset change or symm turn
1474 : : * on/off will overwrite an exist rule, while
1475 : : * application still have 2 rte_flow handles.
1476 : : **/
1477 [ # # ]: 0 : if (ret && ret != ICE_ERR_DOES_NOT_EXIST) {
1478 : 0 : rte_flow_error_set(error, EINVAL,
1479 : : RTE_FLOW_ERROR_TYPE_HANDLE,
1480 : : NULL,
1481 : : "rss flow destroy fail");
1482 : 0 : goto error;
1483 : : }
1484 : : }
1485 : : }
1486 : :
1487 : 0 : rte_free(filter_ptr);
1488 : 0 : return 0;
1489 : :
1490 : 0 : error:
1491 : 0 : rte_free(filter_ptr);
1492 : 0 : return -rte_errno;
1493 : : }
1494 : :
1495 : : static void
1496 : 0 : ice_hash_uninit(struct ice_adapter *ad __rte_unused)
1497 : : {
1498 : 0 : }
1499 : :
1500 : : static void
1501 : 0 : ice_hash_free(struct rte_flow *flow)
1502 : : {
1503 : 0 : rte_free(flow->rule);
1504 : 0 : }
|
