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