1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) 2019-2021, Intel Corporation. */
3
4 #include "ice.h"
5 #include "ice_tc_lib.h"
6 #include "ice_fltr.h"
7 #include "ice_lib.h"
8 #include "ice_protocol_type.h"
9
10 #define ICE_TC_METADATA_LKUP_IDX 0
11
12 /**
13 * ice_tc_count_lkups - determine lookup count for switch filter
14 * @flags: TC-flower flags
15 * @headers: Pointer to TC flower filter header structure
16 * @fltr: Pointer to outer TC filter structure
17 *
18 * Determine lookup count based on TC flower input for switch filter.
19 */
20 static int
ice_tc_count_lkups(u32 flags,struct ice_tc_flower_lyr_2_4_hdrs * headers,struct ice_tc_flower_fltr * fltr)21 ice_tc_count_lkups(u32 flags, struct ice_tc_flower_lyr_2_4_hdrs *headers,
22 struct ice_tc_flower_fltr *fltr)
23 {
24 int lkups_cnt = 1; /* 0th lookup is metadata */
25
26 /* Always add metadata as the 0th lookup. Included elements:
27 * - Direction flag (always present)
28 * - ICE_TC_FLWR_FIELD_VLAN_TPID (present if specified)
29 * - Tunnel flag (present if tunnel)
30 */
31
32 if (flags & ICE_TC_FLWR_FIELD_TENANT_ID)
33 lkups_cnt++;
34
35 if (flags & ICE_TC_FLWR_FIELD_ENC_DST_MAC)
36 lkups_cnt++;
37
38 if (flags & ICE_TC_FLWR_FIELD_ENC_OPTS)
39 lkups_cnt++;
40
41 if (flags & (ICE_TC_FLWR_FIELD_ENC_SRC_IPV4 |
42 ICE_TC_FLWR_FIELD_ENC_DEST_IPV4 |
43 ICE_TC_FLWR_FIELD_ENC_SRC_IPV6 |
44 ICE_TC_FLWR_FIELD_ENC_DEST_IPV6))
45 lkups_cnt++;
46
47 if (flags & (ICE_TC_FLWR_FIELD_ENC_IP_TOS |
48 ICE_TC_FLWR_FIELD_ENC_IP_TTL))
49 lkups_cnt++;
50
51 if (flags & ICE_TC_FLWR_FIELD_ENC_DEST_L4_PORT)
52 lkups_cnt++;
53
54 if (flags & ICE_TC_FLWR_FIELD_ETH_TYPE_ID)
55 lkups_cnt++;
56
57 /* are MAC fields specified? */
58 if (flags & (ICE_TC_FLWR_FIELD_DST_MAC | ICE_TC_FLWR_FIELD_SRC_MAC))
59 lkups_cnt++;
60
61 /* is VLAN specified? */
62 if (flags & (ICE_TC_FLWR_FIELD_VLAN | ICE_TC_FLWR_FIELD_VLAN_PRIO))
63 lkups_cnt++;
64
65 /* is CVLAN specified? */
66 if (flags & (ICE_TC_FLWR_FIELD_CVLAN | ICE_TC_FLWR_FIELD_CVLAN_PRIO))
67 lkups_cnt++;
68
69 /* are PPPoE options specified? */
70 if (flags & (ICE_TC_FLWR_FIELD_PPPOE_SESSID |
71 ICE_TC_FLWR_FIELD_PPP_PROTO))
72 lkups_cnt++;
73
74 /* are IPv[4|6] fields specified? */
75 if (flags & (ICE_TC_FLWR_FIELD_DEST_IPV4 | ICE_TC_FLWR_FIELD_SRC_IPV4 |
76 ICE_TC_FLWR_FIELD_DEST_IPV6 | ICE_TC_FLWR_FIELD_SRC_IPV6))
77 lkups_cnt++;
78
79 if (flags & (ICE_TC_FLWR_FIELD_IP_TOS | ICE_TC_FLWR_FIELD_IP_TTL))
80 lkups_cnt++;
81
82 /* are L2TPv3 options specified? */
83 if (flags & ICE_TC_FLWR_FIELD_L2TPV3_SESSID)
84 lkups_cnt++;
85
86 /* is L4 (TCP/UDP/any other L4 protocol fields) specified? */
87 if (flags & (ICE_TC_FLWR_FIELD_DEST_L4_PORT |
88 ICE_TC_FLWR_FIELD_SRC_L4_PORT))
89 lkups_cnt++;
90
91 return lkups_cnt;
92 }
93
ice_proto_type_from_mac(bool inner)94 static enum ice_protocol_type ice_proto_type_from_mac(bool inner)
95 {
96 return inner ? ICE_MAC_IL : ICE_MAC_OFOS;
97 }
98
ice_proto_type_from_etype(bool inner)99 static enum ice_protocol_type ice_proto_type_from_etype(bool inner)
100 {
101 return inner ? ICE_ETYPE_IL : ICE_ETYPE_OL;
102 }
103
ice_proto_type_from_ipv4(bool inner)104 static enum ice_protocol_type ice_proto_type_from_ipv4(bool inner)
105 {
106 return inner ? ICE_IPV4_IL : ICE_IPV4_OFOS;
107 }
108
ice_proto_type_from_ipv6(bool inner)109 static enum ice_protocol_type ice_proto_type_from_ipv6(bool inner)
110 {
111 return inner ? ICE_IPV6_IL : ICE_IPV6_OFOS;
112 }
113
ice_proto_type_from_l4_port(u16 ip_proto)114 static enum ice_protocol_type ice_proto_type_from_l4_port(u16 ip_proto)
115 {
116 switch (ip_proto) {
117 case IPPROTO_TCP:
118 return ICE_TCP_IL;
119 case IPPROTO_UDP:
120 return ICE_UDP_ILOS;
121 }
122
123 return 0;
124 }
125
126 static enum ice_protocol_type
ice_proto_type_from_tunnel(enum ice_tunnel_type type)127 ice_proto_type_from_tunnel(enum ice_tunnel_type type)
128 {
129 switch (type) {
130 case TNL_VXLAN:
131 return ICE_VXLAN;
132 case TNL_GENEVE:
133 return ICE_GENEVE;
134 case TNL_GRETAP:
135 return ICE_NVGRE;
136 case TNL_GTPU:
137 /* NO_PAY profiles will not work with GTP-U */
138 return ICE_GTP;
139 case TNL_GTPC:
140 return ICE_GTP_NO_PAY;
141 default:
142 return 0;
143 }
144 }
145
146 static enum ice_sw_tunnel_type
ice_sw_type_from_tunnel(enum ice_tunnel_type type)147 ice_sw_type_from_tunnel(enum ice_tunnel_type type)
148 {
149 switch (type) {
150 case TNL_VXLAN:
151 return ICE_SW_TUN_VXLAN;
152 case TNL_GENEVE:
153 return ICE_SW_TUN_GENEVE;
154 case TNL_GRETAP:
155 return ICE_SW_TUN_NVGRE;
156 case TNL_GTPU:
157 return ICE_SW_TUN_GTPU;
158 case TNL_GTPC:
159 return ICE_SW_TUN_GTPC;
160 default:
161 return ICE_NON_TUN;
162 }
163 }
164
ice_check_supported_vlan_tpid(u16 vlan_tpid)165 static u16 ice_check_supported_vlan_tpid(u16 vlan_tpid)
166 {
167 switch (vlan_tpid) {
168 case ETH_P_8021Q:
169 case ETH_P_8021AD:
170 case ETH_P_QINQ1:
171 return vlan_tpid;
172 default:
173 return 0;
174 }
175 }
176
177 static int
ice_tc_fill_tunnel_outer(u32 flags,struct ice_tc_flower_fltr * fltr,struct ice_adv_lkup_elem * list,int i)178 ice_tc_fill_tunnel_outer(u32 flags, struct ice_tc_flower_fltr *fltr,
179 struct ice_adv_lkup_elem *list, int i)
180 {
181 struct ice_tc_flower_lyr_2_4_hdrs *hdr = &fltr->outer_headers;
182
183 if (flags & ICE_TC_FLWR_FIELD_TENANT_ID) {
184 u32 tenant_id;
185
186 list[i].type = ice_proto_type_from_tunnel(fltr->tunnel_type);
187 switch (fltr->tunnel_type) {
188 case TNL_VXLAN:
189 case TNL_GENEVE:
190 tenant_id = be32_to_cpu(fltr->tenant_id) << 8;
191 list[i].h_u.tnl_hdr.vni = cpu_to_be32(tenant_id);
192 memcpy(&list[i].m_u.tnl_hdr.vni, "\xff\xff\xff\x00", 4);
193 i++;
194 break;
195 case TNL_GRETAP:
196 list[i].h_u.nvgre_hdr.tni_flow = fltr->tenant_id;
197 memcpy(&list[i].m_u.nvgre_hdr.tni_flow,
198 "\xff\xff\xff\xff", 4);
199 i++;
200 break;
201 case TNL_GTPC:
202 case TNL_GTPU:
203 list[i].h_u.gtp_hdr.teid = fltr->tenant_id;
204 memcpy(&list[i].m_u.gtp_hdr.teid,
205 "\xff\xff\xff\xff", 4);
206 i++;
207 break;
208 default:
209 break;
210 }
211 }
212
213 if (flags & ICE_TC_FLWR_FIELD_ENC_DST_MAC) {
214 list[i].type = ice_proto_type_from_mac(false);
215 ether_addr_copy(list[i].h_u.eth_hdr.dst_addr,
216 hdr->l2_key.dst_mac);
217 ether_addr_copy(list[i].m_u.eth_hdr.dst_addr,
218 hdr->l2_mask.dst_mac);
219 i++;
220 }
221
222 if (flags & ICE_TC_FLWR_FIELD_ENC_OPTS &&
223 (fltr->tunnel_type == TNL_GTPU || fltr->tunnel_type == TNL_GTPC)) {
224 list[i].type = ice_proto_type_from_tunnel(fltr->tunnel_type);
225
226 if (fltr->gtp_pdu_info_masks.pdu_type) {
227 list[i].h_u.gtp_hdr.pdu_type =
228 fltr->gtp_pdu_info_keys.pdu_type << 4;
229 memcpy(&list[i].m_u.gtp_hdr.pdu_type, "\xf0", 1);
230 }
231
232 if (fltr->gtp_pdu_info_masks.qfi) {
233 list[i].h_u.gtp_hdr.qfi = fltr->gtp_pdu_info_keys.qfi;
234 memcpy(&list[i].m_u.gtp_hdr.qfi, "\x3f", 1);
235 }
236
237 i++;
238 }
239
240 if (flags & (ICE_TC_FLWR_FIELD_ENC_SRC_IPV4 |
241 ICE_TC_FLWR_FIELD_ENC_DEST_IPV4)) {
242 list[i].type = ice_proto_type_from_ipv4(false);
243
244 if (flags & ICE_TC_FLWR_FIELD_ENC_SRC_IPV4) {
245 list[i].h_u.ipv4_hdr.src_addr = hdr->l3_key.src_ipv4;
246 list[i].m_u.ipv4_hdr.src_addr = hdr->l3_mask.src_ipv4;
247 }
248 if (flags & ICE_TC_FLWR_FIELD_ENC_DEST_IPV4) {
249 list[i].h_u.ipv4_hdr.dst_addr = hdr->l3_key.dst_ipv4;
250 list[i].m_u.ipv4_hdr.dst_addr = hdr->l3_mask.dst_ipv4;
251 }
252 i++;
253 }
254
255 if (flags & (ICE_TC_FLWR_FIELD_ENC_SRC_IPV6 |
256 ICE_TC_FLWR_FIELD_ENC_DEST_IPV6)) {
257 list[i].type = ice_proto_type_from_ipv6(false);
258
259 if (flags & ICE_TC_FLWR_FIELD_ENC_SRC_IPV6) {
260 memcpy(&list[i].h_u.ipv6_hdr.src_addr,
261 &hdr->l3_key.src_ipv6_addr,
262 sizeof(hdr->l3_key.src_ipv6_addr));
263 memcpy(&list[i].m_u.ipv6_hdr.src_addr,
264 &hdr->l3_mask.src_ipv6_addr,
265 sizeof(hdr->l3_mask.src_ipv6_addr));
266 }
267 if (flags & ICE_TC_FLWR_FIELD_ENC_DEST_IPV6) {
268 memcpy(&list[i].h_u.ipv6_hdr.dst_addr,
269 &hdr->l3_key.dst_ipv6_addr,
270 sizeof(hdr->l3_key.dst_ipv6_addr));
271 memcpy(&list[i].m_u.ipv6_hdr.dst_addr,
272 &hdr->l3_mask.dst_ipv6_addr,
273 sizeof(hdr->l3_mask.dst_ipv6_addr));
274 }
275 i++;
276 }
277
278 if (fltr->inner_headers.l2_key.n_proto == htons(ETH_P_IP) &&
279 (flags & (ICE_TC_FLWR_FIELD_ENC_IP_TOS |
280 ICE_TC_FLWR_FIELD_ENC_IP_TTL))) {
281 list[i].type = ice_proto_type_from_ipv4(false);
282
283 if (flags & ICE_TC_FLWR_FIELD_ENC_IP_TOS) {
284 list[i].h_u.ipv4_hdr.tos = hdr->l3_key.tos;
285 list[i].m_u.ipv4_hdr.tos = hdr->l3_mask.tos;
286 }
287
288 if (flags & ICE_TC_FLWR_FIELD_ENC_IP_TTL) {
289 list[i].h_u.ipv4_hdr.time_to_live = hdr->l3_key.ttl;
290 list[i].m_u.ipv4_hdr.time_to_live = hdr->l3_mask.ttl;
291 }
292
293 i++;
294 }
295
296 if (fltr->inner_headers.l2_key.n_proto == htons(ETH_P_IPV6) &&
297 (flags & (ICE_TC_FLWR_FIELD_ENC_IP_TOS |
298 ICE_TC_FLWR_FIELD_ENC_IP_TTL))) {
299 struct ice_ipv6_hdr *hdr_h, *hdr_m;
300
301 hdr_h = &list[i].h_u.ipv6_hdr;
302 hdr_m = &list[i].m_u.ipv6_hdr;
303 list[i].type = ice_proto_type_from_ipv6(false);
304
305 if (flags & ICE_TC_FLWR_FIELD_ENC_IP_TOS) {
306 be32p_replace_bits(&hdr_h->be_ver_tc_flow,
307 hdr->l3_key.tos,
308 ICE_IPV6_HDR_TC_MASK);
309 be32p_replace_bits(&hdr_m->be_ver_tc_flow,
310 hdr->l3_mask.tos,
311 ICE_IPV6_HDR_TC_MASK);
312 }
313
314 if (flags & ICE_TC_FLWR_FIELD_ENC_IP_TTL) {
315 hdr_h->hop_limit = hdr->l3_key.ttl;
316 hdr_m->hop_limit = hdr->l3_mask.ttl;
317 }
318
319 i++;
320 }
321
322 if ((flags & ICE_TC_FLWR_FIELD_ENC_DEST_L4_PORT) &&
323 hdr->l3_key.ip_proto == IPPROTO_UDP) {
324 list[i].type = ICE_UDP_OF;
325 list[i].h_u.l4_hdr.dst_port = hdr->l4_key.dst_port;
326 list[i].m_u.l4_hdr.dst_port = hdr->l4_mask.dst_port;
327 i++;
328 }
329
330 /* always fill matching on tunneled packets in metadata */
331 ice_rule_add_tunnel_metadata(&list[ICE_TC_METADATA_LKUP_IDX]);
332
333 return i;
334 }
335
336 /**
337 * ice_tc_fill_rules - fill filter rules based on TC fltr
338 * @hw: pointer to HW structure
339 * @flags: tc flower field flags
340 * @tc_fltr: pointer to TC flower filter
341 * @list: list of advance rule elements
342 * @rule_info: pointer to information about rule
343 * @l4_proto: pointer to information such as L4 proto type
344 *
345 * Fill ice_adv_lkup_elem list based on TC flower flags and
346 * TC flower headers. This list should be used to add
347 * advance filter in hardware.
348 */
349 static int
ice_tc_fill_rules(struct ice_hw * hw,u32 flags,struct ice_tc_flower_fltr * tc_fltr,struct ice_adv_lkup_elem * list,struct ice_adv_rule_info * rule_info,u16 * l4_proto)350 ice_tc_fill_rules(struct ice_hw *hw, u32 flags,
351 struct ice_tc_flower_fltr *tc_fltr,
352 struct ice_adv_lkup_elem *list,
353 struct ice_adv_rule_info *rule_info,
354 u16 *l4_proto)
355 {
356 struct ice_tc_flower_lyr_2_4_hdrs *headers = &tc_fltr->outer_headers;
357 bool inner = false;
358 u16 vlan_tpid = 0;
359 int i = 1; /* 0th lookup is metadata */
360
361 rule_info->vlan_type = vlan_tpid;
362
363 /* Always add direction metadata */
364 ice_rule_add_direction_metadata(&list[ICE_TC_METADATA_LKUP_IDX]);
365
366 rule_info->tun_type = ice_sw_type_from_tunnel(tc_fltr->tunnel_type);
367 if (tc_fltr->tunnel_type != TNL_LAST) {
368 i = ice_tc_fill_tunnel_outer(flags, tc_fltr, list, i);
369
370 headers = &tc_fltr->inner_headers;
371 inner = true;
372 }
373
374 if (flags & ICE_TC_FLWR_FIELD_ETH_TYPE_ID) {
375 list[i].type = ice_proto_type_from_etype(inner);
376 list[i].h_u.ethertype.ethtype_id = headers->l2_key.n_proto;
377 list[i].m_u.ethertype.ethtype_id = headers->l2_mask.n_proto;
378 i++;
379 }
380
381 if (flags & (ICE_TC_FLWR_FIELD_DST_MAC |
382 ICE_TC_FLWR_FIELD_SRC_MAC)) {
383 struct ice_tc_l2_hdr *l2_key, *l2_mask;
384
385 l2_key = &headers->l2_key;
386 l2_mask = &headers->l2_mask;
387
388 list[i].type = ice_proto_type_from_mac(inner);
389 if (flags & ICE_TC_FLWR_FIELD_DST_MAC) {
390 ether_addr_copy(list[i].h_u.eth_hdr.dst_addr,
391 l2_key->dst_mac);
392 ether_addr_copy(list[i].m_u.eth_hdr.dst_addr,
393 l2_mask->dst_mac);
394 }
395 if (flags & ICE_TC_FLWR_FIELD_SRC_MAC) {
396 ether_addr_copy(list[i].h_u.eth_hdr.src_addr,
397 l2_key->src_mac);
398 ether_addr_copy(list[i].m_u.eth_hdr.src_addr,
399 l2_mask->src_mac);
400 }
401 i++;
402 }
403
404 /* copy VLAN info */
405 if (flags & (ICE_TC_FLWR_FIELD_VLAN | ICE_TC_FLWR_FIELD_VLAN_PRIO)) {
406 if (flags & ICE_TC_FLWR_FIELD_CVLAN)
407 list[i].type = ICE_VLAN_EX;
408 else
409 list[i].type = ICE_VLAN_OFOS;
410
411 if (flags & ICE_TC_FLWR_FIELD_VLAN) {
412 list[i].h_u.vlan_hdr.vlan = headers->vlan_hdr.vlan_id;
413 list[i].m_u.vlan_hdr.vlan = cpu_to_be16(0x0FFF);
414 }
415
416 if (flags & ICE_TC_FLWR_FIELD_VLAN_PRIO) {
417 if (flags & ICE_TC_FLWR_FIELD_VLAN) {
418 list[i].m_u.vlan_hdr.vlan = cpu_to_be16(0xEFFF);
419 } else {
420 list[i].m_u.vlan_hdr.vlan = cpu_to_be16(0xE000);
421 list[i].h_u.vlan_hdr.vlan = 0;
422 }
423 list[i].h_u.vlan_hdr.vlan |=
424 headers->vlan_hdr.vlan_prio;
425 }
426
427 i++;
428 }
429
430 if (flags & ICE_TC_FLWR_FIELD_VLAN_TPID) {
431 vlan_tpid = be16_to_cpu(headers->vlan_hdr.vlan_tpid);
432 rule_info->vlan_type =
433 ice_check_supported_vlan_tpid(vlan_tpid);
434
435 ice_rule_add_vlan_metadata(&list[ICE_TC_METADATA_LKUP_IDX]);
436 }
437
438 if (flags & (ICE_TC_FLWR_FIELD_CVLAN | ICE_TC_FLWR_FIELD_CVLAN_PRIO)) {
439 list[i].type = ICE_VLAN_IN;
440
441 if (flags & ICE_TC_FLWR_FIELD_CVLAN) {
442 list[i].h_u.vlan_hdr.vlan = headers->cvlan_hdr.vlan_id;
443 list[i].m_u.vlan_hdr.vlan = cpu_to_be16(0x0FFF);
444 }
445
446 if (flags & ICE_TC_FLWR_FIELD_CVLAN_PRIO) {
447 if (flags & ICE_TC_FLWR_FIELD_CVLAN) {
448 list[i].m_u.vlan_hdr.vlan = cpu_to_be16(0xEFFF);
449 } else {
450 list[i].m_u.vlan_hdr.vlan = cpu_to_be16(0xE000);
451 list[i].h_u.vlan_hdr.vlan = 0;
452 }
453 list[i].h_u.vlan_hdr.vlan |=
454 headers->cvlan_hdr.vlan_prio;
455 }
456
457 i++;
458 }
459
460 if (flags & (ICE_TC_FLWR_FIELD_PPPOE_SESSID |
461 ICE_TC_FLWR_FIELD_PPP_PROTO)) {
462 struct ice_pppoe_hdr *vals, *masks;
463
464 vals = &list[i].h_u.pppoe_hdr;
465 masks = &list[i].m_u.pppoe_hdr;
466
467 list[i].type = ICE_PPPOE;
468
469 if (flags & ICE_TC_FLWR_FIELD_PPPOE_SESSID) {
470 vals->session_id = headers->pppoe_hdr.session_id;
471 masks->session_id = cpu_to_be16(0xFFFF);
472 }
473
474 if (flags & ICE_TC_FLWR_FIELD_PPP_PROTO) {
475 vals->ppp_prot_id = headers->pppoe_hdr.ppp_proto;
476 masks->ppp_prot_id = cpu_to_be16(0xFFFF);
477 }
478
479 i++;
480 }
481
482 /* copy L3 (IPv[4|6]: src, dest) address */
483 if (flags & (ICE_TC_FLWR_FIELD_DEST_IPV4 |
484 ICE_TC_FLWR_FIELD_SRC_IPV4)) {
485 struct ice_tc_l3_hdr *l3_key, *l3_mask;
486
487 list[i].type = ice_proto_type_from_ipv4(inner);
488 l3_key = &headers->l3_key;
489 l3_mask = &headers->l3_mask;
490 if (flags & ICE_TC_FLWR_FIELD_DEST_IPV4) {
491 list[i].h_u.ipv4_hdr.dst_addr = l3_key->dst_ipv4;
492 list[i].m_u.ipv4_hdr.dst_addr = l3_mask->dst_ipv4;
493 }
494 if (flags & ICE_TC_FLWR_FIELD_SRC_IPV4) {
495 list[i].h_u.ipv4_hdr.src_addr = l3_key->src_ipv4;
496 list[i].m_u.ipv4_hdr.src_addr = l3_mask->src_ipv4;
497 }
498 i++;
499 } else if (flags & (ICE_TC_FLWR_FIELD_DEST_IPV6 |
500 ICE_TC_FLWR_FIELD_SRC_IPV6)) {
501 struct ice_ipv6_hdr *ipv6_hdr, *ipv6_mask;
502 struct ice_tc_l3_hdr *l3_key, *l3_mask;
503
504 list[i].type = ice_proto_type_from_ipv6(inner);
505 ipv6_hdr = &list[i].h_u.ipv6_hdr;
506 ipv6_mask = &list[i].m_u.ipv6_hdr;
507 l3_key = &headers->l3_key;
508 l3_mask = &headers->l3_mask;
509
510 if (flags & ICE_TC_FLWR_FIELD_DEST_IPV6) {
511 memcpy(&ipv6_hdr->dst_addr, &l3_key->dst_ipv6_addr,
512 sizeof(l3_key->dst_ipv6_addr));
513 memcpy(&ipv6_mask->dst_addr, &l3_mask->dst_ipv6_addr,
514 sizeof(l3_mask->dst_ipv6_addr));
515 }
516 if (flags & ICE_TC_FLWR_FIELD_SRC_IPV6) {
517 memcpy(&ipv6_hdr->src_addr, &l3_key->src_ipv6_addr,
518 sizeof(l3_key->src_ipv6_addr));
519 memcpy(&ipv6_mask->src_addr, &l3_mask->src_ipv6_addr,
520 sizeof(l3_mask->src_ipv6_addr));
521 }
522 i++;
523 }
524
525 if (headers->l2_key.n_proto == htons(ETH_P_IP) &&
526 (flags & (ICE_TC_FLWR_FIELD_IP_TOS | ICE_TC_FLWR_FIELD_IP_TTL))) {
527 list[i].type = ice_proto_type_from_ipv4(inner);
528
529 if (flags & ICE_TC_FLWR_FIELD_IP_TOS) {
530 list[i].h_u.ipv4_hdr.tos = headers->l3_key.tos;
531 list[i].m_u.ipv4_hdr.tos = headers->l3_mask.tos;
532 }
533
534 if (flags & ICE_TC_FLWR_FIELD_IP_TTL) {
535 list[i].h_u.ipv4_hdr.time_to_live =
536 headers->l3_key.ttl;
537 list[i].m_u.ipv4_hdr.time_to_live =
538 headers->l3_mask.ttl;
539 }
540
541 i++;
542 }
543
544 if (headers->l2_key.n_proto == htons(ETH_P_IPV6) &&
545 (flags & (ICE_TC_FLWR_FIELD_IP_TOS | ICE_TC_FLWR_FIELD_IP_TTL))) {
546 struct ice_ipv6_hdr *hdr_h, *hdr_m;
547
548 hdr_h = &list[i].h_u.ipv6_hdr;
549 hdr_m = &list[i].m_u.ipv6_hdr;
550 list[i].type = ice_proto_type_from_ipv6(inner);
551
552 if (flags & ICE_TC_FLWR_FIELD_IP_TOS) {
553 be32p_replace_bits(&hdr_h->be_ver_tc_flow,
554 headers->l3_key.tos,
555 ICE_IPV6_HDR_TC_MASK);
556 be32p_replace_bits(&hdr_m->be_ver_tc_flow,
557 headers->l3_mask.tos,
558 ICE_IPV6_HDR_TC_MASK);
559 }
560
561 if (flags & ICE_TC_FLWR_FIELD_IP_TTL) {
562 hdr_h->hop_limit = headers->l3_key.ttl;
563 hdr_m->hop_limit = headers->l3_mask.ttl;
564 }
565
566 i++;
567 }
568
569 if (flags & ICE_TC_FLWR_FIELD_L2TPV3_SESSID) {
570 list[i].type = ICE_L2TPV3;
571
572 list[i].h_u.l2tpv3_sess_hdr.session_id =
573 headers->l2tpv3_hdr.session_id;
574 list[i].m_u.l2tpv3_sess_hdr.session_id =
575 cpu_to_be32(0xFFFFFFFF);
576
577 i++;
578 }
579
580 /* copy L4 (src, dest) port */
581 if (flags & (ICE_TC_FLWR_FIELD_DEST_L4_PORT |
582 ICE_TC_FLWR_FIELD_SRC_L4_PORT)) {
583 struct ice_tc_l4_hdr *l4_key, *l4_mask;
584
585 list[i].type = ice_proto_type_from_l4_port(headers->l3_key.ip_proto);
586 l4_key = &headers->l4_key;
587 l4_mask = &headers->l4_mask;
588
589 if (flags & ICE_TC_FLWR_FIELD_DEST_L4_PORT) {
590 list[i].h_u.l4_hdr.dst_port = l4_key->dst_port;
591 list[i].m_u.l4_hdr.dst_port = l4_mask->dst_port;
592 }
593 if (flags & ICE_TC_FLWR_FIELD_SRC_L4_PORT) {
594 list[i].h_u.l4_hdr.src_port = l4_key->src_port;
595 list[i].m_u.l4_hdr.src_port = l4_mask->src_port;
596 }
597 i++;
598 }
599
600 return i;
601 }
602
603 /**
604 * ice_tc_tun_get_type - get the tunnel type
605 * @tunnel_dev: ptr to tunnel device
606 *
607 * This function detects appropriate tunnel_type if specified device is
608 * tunnel device such as VXLAN/Geneve
609 */
ice_tc_tun_get_type(struct net_device * tunnel_dev)610 static int ice_tc_tun_get_type(struct net_device *tunnel_dev)
611 {
612 if (netif_is_vxlan(tunnel_dev))
613 return TNL_VXLAN;
614 if (netif_is_geneve(tunnel_dev))
615 return TNL_GENEVE;
616 if (netif_is_gretap(tunnel_dev) ||
617 netif_is_ip6gretap(tunnel_dev))
618 return TNL_GRETAP;
619
620 /* Assume GTP-U by default in case of GTP netdev.
621 * GTP-C may be selected later, based on enc_dst_port.
622 */
623 if (netif_is_gtp(tunnel_dev))
624 return TNL_GTPU;
625 return TNL_LAST;
626 }
627
ice_is_tunnel_supported(struct net_device * dev)628 bool ice_is_tunnel_supported(struct net_device *dev)
629 {
630 return ice_tc_tun_get_type(dev) != TNL_LAST;
631 }
632
633 static int
ice_eswitch_tc_parse_action(struct ice_tc_flower_fltr * fltr,struct flow_action_entry * act)634 ice_eswitch_tc_parse_action(struct ice_tc_flower_fltr *fltr,
635 struct flow_action_entry *act)
636 {
637 struct ice_repr *repr;
638
639 switch (act->id) {
640 case FLOW_ACTION_DROP:
641 fltr->action.fltr_act = ICE_DROP_PACKET;
642 break;
643
644 case FLOW_ACTION_REDIRECT:
645 fltr->action.fltr_act = ICE_FWD_TO_VSI;
646
647 if (ice_is_port_repr_netdev(act->dev)) {
648 repr = ice_netdev_to_repr(act->dev);
649
650 fltr->dest_vsi = repr->src_vsi;
651 fltr->direction = ICE_ESWITCH_FLTR_INGRESS;
652 } else if (netif_is_ice(act->dev) ||
653 ice_is_tunnel_supported(act->dev)) {
654 fltr->direction = ICE_ESWITCH_FLTR_EGRESS;
655 } else {
656 NL_SET_ERR_MSG_MOD(fltr->extack, "Unsupported netdevice in switchdev mode");
657 return -EINVAL;
658 }
659
660 break;
661
662 default:
663 NL_SET_ERR_MSG_MOD(fltr->extack, "Unsupported action in switchdev mode");
664 return -EINVAL;
665 }
666
667 return 0;
668 }
669
670 static int
ice_eswitch_add_tc_fltr(struct ice_vsi * vsi,struct ice_tc_flower_fltr * fltr)671 ice_eswitch_add_tc_fltr(struct ice_vsi *vsi, struct ice_tc_flower_fltr *fltr)
672 {
673 struct ice_tc_flower_lyr_2_4_hdrs *headers = &fltr->outer_headers;
674 struct ice_adv_rule_info rule_info = { 0 };
675 struct ice_rule_query_data rule_added;
676 struct ice_hw *hw = &vsi->back->hw;
677 struct ice_adv_lkup_elem *list;
678 u32 flags = fltr->flags;
679 int lkups_cnt;
680 int ret;
681 int i;
682
683 if (!flags || (flags & ICE_TC_FLWR_FIELD_ENC_SRC_L4_PORT)) {
684 NL_SET_ERR_MSG_MOD(fltr->extack, "Unsupported encap field(s)");
685 return -EOPNOTSUPP;
686 }
687
688 lkups_cnt = ice_tc_count_lkups(flags, headers, fltr);
689 list = kcalloc(lkups_cnt, sizeof(*list), GFP_ATOMIC);
690 if (!list)
691 return -ENOMEM;
692
693 i = ice_tc_fill_rules(hw, flags, fltr, list, &rule_info, NULL);
694 if (i != lkups_cnt) {
695 ret = -EINVAL;
696 goto exit;
697 }
698
699 /* egress traffic is always redirect to uplink */
700 if (fltr->direction == ICE_ESWITCH_FLTR_EGRESS)
701 fltr->dest_vsi = vsi->back->switchdev.uplink_vsi;
702
703 rule_info.sw_act.fltr_act = fltr->action.fltr_act;
704 if (fltr->action.fltr_act != ICE_DROP_PACKET)
705 rule_info.sw_act.vsi_handle = fltr->dest_vsi->idx;
706 /* For now, making priority to be highest, and it also becomes
707 * the priority for recipe which will get created as a result of
708 * new extraction sequence based on input set.
709 * Priority '7' is max val for switch recipe, higher the number
710 * results into order of switch rule evaluation.
711 */
712 rule_info.priority = 7;
713 rule_info.flags_info.act_valid = true;
714
715 if (fltr->direction == ICE_ESWITCH_FLTR_INGRESS) {
716 rule_info.sw_act.flag |= ICE_FLTR_RX;
717 rule_info.sw_act.src = hw->pf_id;
718 rule_info.flags_info.act = ICE_SINGLE_ACT_LB_ENABLE;
719 } else {
720 rule_info.sw_act.flag |= ICE_FLTR_TX;
721 rule_info.sw_act.src = vsi->idx;
722 rule_info.flags_info.act = ICE_SINGLE_ACT_LAN_ENABLE;
723 }
724
725 /* specify the cookie as filter_rule_id */
726 rule_info.fltr_rule_id = fltr->cookie;
727
728 ret = ice_add_adv_rule(hw, list, lkups_cnt, &rule_info, &rule_added);
729 if (ret == -EEXIST) {
730 NL_SET_ERR_MSG_MOD(fltr->extack, "Unable to add filter because it already exist");
731 ret = -EINVAL;
732 goto exit;
733 } else if (ret) {
734 NL_SET_ERR_MSG_MOD(fltr->extack, "Unable to add filter due to error");
735 goto exit;
736 }
737
738 /* store the output params, which are needed later for removing
739 * advanced switch filter
740 */
741 fltr->rid = rule_added.rid;
742 fltr->rule_id = rule_added.rule_id;
743 fltr->dest_vsi_handle = rule_added.vsi_handle;
744
745 exit:
746 kfree(list);
747 return ret;
748 }
749
750 /**
751 * ice_locate_vsi_using_queue - locate VSI using queue (forward to queue action)
752 * @vsi: Pointer to VSI
753 * @queue: Queue index
754 *
755 * Locate the VSI using specified "queue". When ADQ is not enabled,
756 * always return input VSI, otherwise locate corresponding
757 * VSI based on per channel "offset" and "qcount"
758 */
759 struct ice_vsi *
ice_locate_vsi_using_queue(struct ice_vsi * vsi,int queue)760 ice_locate_vsi_using_queue(struct ice_vsi *vsi, int queue)
761 {
762 int num_tc, tc;
763
764 /* if ADQ is not active, passed VSI is the candidate VSI */
765 if (!ice_is_adq_active(vsi->back))
766 return vsi;
767
768 /* Locate the VSI (it could still be main PF VSI or CHNL_VSI depending
769 * upon queue number)
770 */
771 num_tc = vsi->mqprio_qopt.qopt.num_tc;
772
773 for (tc = 0; tc < num_tc; tc++) {
774 int qcount = vsi->mqprio_qopt.qopt.count[tc];
775 int offset = vsi->mqprio_qopt.qopt.offset[tc];
776
777 if (queue >= offset && queue < offset + qcount) {
778 /* for non-ADQ TCs, passed VSI is the candidate VSI */
779 if (tc < ICE_CHNL_START_TC)
780 return vsi;
781 else
782 return vsi->tc_map_vsi[tc];
783 }
784 }
785 return NULL;
786 }
787
788 static struct ice_rx_ring *
ice_locate_rx_ring_using_queue(struct ice_vsi * vsi,struct ice_tc_flower_fltr * tc_fltr)789 ice_locate_rx_ring_using_queue(struct ice_vsi *vsi,
790 struct ice_tc_flower_fltr *tc_fltr)
791 {
792 u16 queue = tc_fltr->action.fwd.q.queue;
793
794 return queue < vsi->num_rxq ? vsi->rx_rings[queue] : NULL;
795 }
796
797 /**
798 * ice_tc_forward_action - Determine destination VSI and queue for the action
799 * @vsi: Pointer to VSI
800 * @tc_fltr: Pointer to TC flower filter structure
801 *
802 * Validates the tc forward action and determines the destination VSI and queue
803 * for the forward action.
804 */
805 static struct ice_vsi *
ice_tc_forward_action(struct ice_vsi * vsi,struct ice_tc_flower_fltr * tc_fltr)806 ice_tc_forward_action(struct ice_vsi *vsi, struct ice_tc_flower_fltr *tc_fltr)
807 {
808 struct ice_rx_ring *ring = NULL;
809 struct ice_vsi *dest_vsi = NULL;
810 struct ice_pf *pf = vsi->back;
811 struct device *dev;
812 u32 tc_class;
813 int q;
814
815 dev = ice_pf_to_dev(pf);
816
817 /* Get the destination VSI and/or destination queue and validate them */
818 switch (tc_fltr->action.fltr_act) {
819 case ICE_FWD_TO_VSI:
820 tc_class = tc_fltr->action.fwd.tc.tc_class;
821 /* Select the destination VSI */
822 if (tc_class < ICE_CHNL_START_TC) {
823 NL_SET_ERR_MSG_MOD(tc_fltr->extack,
824 "Unable to add filter because of unsupported destination");
825 return ERR_PTR(-EOPNOTSUPP);
826 }
827 /* Locate ADQ VSI depending on hw_tc number */
828 dest_vsi = vsi->tc_map_vsi[tc_class];
829 break;
830 case ICE_FWD_TO_Q:
831 /* Locate the Rx queue */
832 ring = ice_locate_rx_ring_using_queue(vsi, tc_fltr);
833 if (!ring) {
834 dev_err(dev,
835 "Unable to locate Rx queue for action fwd_to_queue: %u\n",
836 tc_fltr->action.fwd.q.queue);
837 return ERR_PTR(-EINVAL);
838 }
839 /* Determine destination VSI even though the action is
840 * FWD_TO_QUEUE, because QUEUE is associated with VSI
841 */
842 q = tc_fltr->action.fwd.q.queue;
843 dest_vsi = ice_locate_vsi_using_queue(vsi, q);
844 break;
845 default:
846 dev_err(dev,
847 "Unable to add filter because of unsupported action %u (supported actions: fwd to tc, fwd to queue)\n",
848 tc_fltr->action.fltr_act);
849 return ERR_PTR(-EINVAL);
850 }
851 /* Must have valid dest_vsi (it could be main VSI or ADQ VSI) */
852 if (!dest_vsi) {
853 dev_err(dev,
854 "Unable to add filter because specified destination VSI doesn't exist\n");
855 return ERR_PTR(-EINVAL);
856 }
857 return dest_vsi;
858 }
859
860 /**
861 * ice_add_tc_flower_adv_fltr - add appropriate filter rules
862 * @vsi: Pointer to VSI
863 * @tc_fltr: Pointer to TC flower filter structure
864 *
865 * based on filter parameters using Advance recipes supported
866 * by OS package.
867 */
868 static int
ice_add_tc_flower_adv_fltr(struct ice_vsi * vsi,struct ice_tc_flower_fltr * tc_fltr)869 ice_add_tc_flower_adv_fltr(struct ice_vsi *vsi,
870 struct ice_tc_flower_fltr *tc_fltr)
871 {
872 struct ice_tc_flower_lyr_2_4_hdrs *headers = &tc_fltr->outer_headers;
873 struct ice_adv_rule_info rule_info = {0};
874 struct ice_rule_query_data rule_added;
875 struct ice_adv_lkup_elem *list;
876 struct ice_pf *pf = vsi->back;
877 struct ice_hw *hw = &pf->hw;
878 u32 flags = tc_fltr->flags;
879 struct ice_vsi *dest_vsi;
880 struct device *dev;
881 u16 lkups_cnt = 0;
882 u16 l4_proto = 0;
883 int ret = 0;
884 u16 i = 0;
885
886 dev = ice_pf_to_dev(pf);
887 if (ice_is_safe_mode(pf)) {
888 NL_SET_ERR_MSG_MOD(tc_fltr->extack, "Unable to add filter because driver is in safe mode");
889 return -EOPNOTSUPP;
890 }
891
892 if (!flags || (flags & (ICE_TC_FLWR_FIELD_ENC_DEST_IPV4 |
893 ICE_TC_FLWR_FIELD_ENC_SRC_IPV4 |
894 ICE_TC_FLWR_FIELD_ENC_DEST_IPV6 |
895 ICE_TC_FLWR_FIELD_ENC_SRC_IPV6 |
896 ICE_TC_FLWR_FIELD_ENC_SRC_L4_PORT))) {
897 NL_SET_ERR_MSG_MOD(tc_fltr->extack, "Unsupported encap field(s)");
898 return -EOPNOTSUPP;
899 }
900
901 /* validate forwarding action VSI and queue */
902 if (ice_is_forward_action(tc_fltr->action.fltr_act)) {
903 dest_vsi = ice_tc_forward_action(vsi, tc_fltr);
904 if (IS_ERR(dest_vsi))
905 return PTR_ERR(dest_vsi);
906 }
907
908 lkups_cnt = ice_tc_count_lkups(flags, headers, tc_fltr);
909 list = kcalloc(lkups_cnt, sizeof(*list), GFP_ATOMIC);
910 if (!list)
911 return -ENOMEM;
912
913 i = ice_tc_fill_rules(hw, flags, tc_fltr, list, &rule_info, &l4_proto);
914 if (i != lkups_cnt) {
915 ret = -EINVAL;
916 goto exit;
917 }
918
919 rule_info.sw_act.fltr_act = tc_fltr->action.fltr_act;
920 /* specify the cookie as filter_rule_id */
921 rule_info.fltr_rule_id = tc_fltr->cookie;
922
923 switch (tc_fltr->action.fltr_act) {
924 case ICE_FWD_TO_VSI:
925 rule_info.sw_act.vsi_handle = dest_vsi->idx;
926 rule_info.priority = ICE_SWITCH_FLTR_PRIO_VSI;
927 rule_info.sw_act.src = hw->pf_id;
928 dev_dbg(dev, "add switch rule for TC:%u vsi_idx:%u, lkups_cnt:%u\n",
929 tc_fltr->action.fwd.tc.tc_class,
930 rule_info.sw_act.vsi_handle, lkups_cnt);
931 break;
932 case ICE_FWD_TO_Q:
933 /* HW queue number in global space */
934 rule_info.sw_act.fwd_id.q_id = tc_fltr->action.fwd.q.hw_queue;
935 rule_info.sw_act.vsi_handle = dest_vsi->idx;
936 rule_info.priority = ICE_SWITCH_FLTR_PRIO_QUEUE;
937 rule_info.sw_act.src = hw->pf_id;
938 dev_dbg(dev, "add switch rule action to forward to queue:%u (HW queue %u), lkups_cnt:%u\n",
939 tc_fltr->action.fwd.q.queue,
940 tc_fltr->action.fwd.q.hw_queue, lkups_cnt);
941 break;
942 case ICE_DROP_PACKET:
943 rule_info.sw_act.flag |= ICE_FLTR_RX;
944 rule_info.sw_act.src = hw->pf_id;
945 rule_info.priority = ICE_SWITCH_FLTR_PRIO_VSI;
946 break;
947 default:
948 ret = -EOPNOTSUPP;
949 goto exit;
950 }
951
952 ret = ice_add_adv_rule(hw, list, lkups_cnt, &rule_info, &rule_added);
953 if (ret == -EEXIST) {
954 NL_SET_ERR_MSG_MOD(tc_fltr->extack,
955 "Unable to add filter because it already exist");
956 ret = -EINVAL;
957 goto exit;
958 } else if (ret) {
959 NL_SET_ERR_MSG_MOD(tc_fltr->extack,
960 "Unable to add filter due to error");
961 goto exit;
962 }
963
964 /* store the output params, which are needed later for removing
965 * advanced switch filter
966 */
967 tc_fltr->rid = rule_added.rid;
968 tc_fltr->rule_id = rule_added.rule_id;
969 tc_fltr->dest_vsi_handle = rule_added.vsi_handle;
970 if (tc_fltr->action.fltr_act == ICE_FWD_TO_VSI ||
971 tc_fltr->action.fltr_act == ICE_FWD_TO_Q) {
972 tc_fltr->dest_vsi = dest_vsi;
973 /* keep track of advanced switch filter for
974 * destination VSI
975 */
976 dest_vsi->num_chnl_fltr++;
977
978 /* keeps track of channel filters for PF VSI */
979 if (vsi->type == ICE_VSI_PF &&
980 (flags & (ICE_TC_FLWR_FIELD_DST_MAC |
981 ICE_TC_FLWR_FIELD_ENC_DST_MAC)))
982 pf->num_dmac_chnl_fltrs++;
983 }
984 switch (tc_fltr->action.fltr_act) {
985 case ICE_FWD_TO_VSI:
986 dev_dbg(dev, "added switch rule (lkups_cnt %u, flags 0x%x), action is forward to TC %u, rid %u, rule_id %u, vsi_idx %u\n",
987 lkups_cnt, flags,
988 tc_fltr->action.fwd.tc.tc_class, rule_added.rid,
989 rule_added.rule_id, rule_added.vsi_handle);
990 break;
991 case ICE_FWD_TO_Q:
992 dev_dbg(dev, "added switch rule (lkups_cnt %u, flags 0x%x), action is forward to queue: %u (HW queue %u) , rid %u, rule_id %u\n",
993 lkups_cnt, flags, tc_fltr->action.fwd.q.queue,
994 tc_fltr->action.fwd.q.hw_queue, rule_added.rid,
995 rule_added.rule_id);
996 break;
997 case ICE_DROP_PACKET:
998 dev_dbg(dev, "added switch rule (lkups_cnt %u, flags 0x%x), action is drop, rid %u, rule_id %u\n",
999 lkups_cnt, flags, rule_added.rid, rule_added.rule_id);
1000 break;
1001 default:
1002 break;
1003 }
1004 exit:
1005 kfree(list);
1006 return ret;
1007 }
1008
1009 /**
1010 * ice_tc_set_pppoe - Parse PPPoE fields from TC flower filter
1011 * @match: Pointer to flow match structure
1012 * @fltr: Pointer to filter structure
1013 * @headers: Pointer to outer header fields
1014 * @returns PPP protocol used in filter (ppp_ses or ppp_disc)
1015 */
1016 static u16
ice_tc_set_pppoe(struct flow_match_pppoe * match,struct ice_tc_flower_fltr * fltr,struct ice_tc_flower_lyr_2_4_hdrs * headers)1017 ice_tc_set_pppoe(struct flow_match_pppoe *match,
1018 struct ice_tc_flower_fltr *fltr,
1019 struct ice_tc_flower_lyr_2_4_hdrs *headers)
1020 {
1021 if (match->mask->session_id) {
1022 fltr->flags |= ICE_TC_FLWR_FIELD_PPPOE_SESSID;
1023 headers->pppoe_hdr.session_id = match->key->session_id;
1024 }
1025
1026 if (match->mask->ppp_proto) {
1027 fltr->flags |= ICE_TC_FLWR_FIELD_PPP_PROTO;
1028 headers->pppoe_hdr.ppp_proto = match->key->ppp_proto;
1029 }
1030
1031 return be16_to_cpu(match->key->type);
1032 }
1033
1034 /**
1035 * ice_tc_set_ipv4 - Parse IPv4 addresses from TC flower filter
1036 * @match: Pointer to flow match structure
1037 * @fltr: Pointer to filter structure
1038 * @headers: inner or outer header fields
1039 * @is_encap: set true for tunnel IPv4 address
1040 */
1041 static int
ice_tc_set_ipv4(struct flow_match_ipv4_addrs * match,struct ice_tc_flower_fltr * fltr,struct ice_tc_flower_lyr_2_4_hdrs * headers,bool is_encap)1042 ice_tc_set_ipv4(struct flow_match_ipv4_addrs *match,
1043 struct ice_tc_flower_fltr *fltr,
1044 struct ice_tc_flower_lyr_2_4_hdrs *headers, bool is_encap)
1045 {
1046 if (match->key->dst) {
1047 if (is_encap)
1048 fltr->flags |= ICE_TC_FLWR_FIELD_ENC_DEST_IPV4;
1049 else
1050 fltr->flags |= ICE_TC_FLWR_FIELD_DEST_IPV4;
1051 headers->l3_key.dst_ipv4 = match->key->dst;
1052 headers->l3_mask.dst_ipv4 = match->mask->dst;
1053 }
1054 if (match->key->src) {
1055 if (is_encap)
1056 fltr->flags |= ICE_TC_FLWR_FIELD_ENC_SRC_IPV4;
1057 else
1058 fltr->flags |= ICE_TC_FLWR_FIELD_SRC_IPV4;
1059 headers->l3_key.src_ipv4 = match->key->src;
1060 headers->l3_mask.src_ipv4 = match->mask->src;
1061 }
1062 return 0;
1063 }
1064
1065 /**
1066 * ice_tc_set_ipv6 - Parse IPv6 addresses from TC flower filter
1067 * @match: Pointer to flow match structure
1068 * @fltr: Pointer to filter structure
1069 * @headers: inner or outer header fields
1070 * @is_encap: set true for tunnel IPv6 address
1071 */
1072 static int
ice_tc_set_ipv6(struct flow_match_ipv6_addrs * match,struct ice_tc_flower_fltr * fltr,struct ice_tc_flower_lyr_2_4_hdrs * headers,bool is_encap)1073 ice_tc_set_ipv6(struct flow_match_ipv6_addrs *match,
1074 struct ice_tc_flower_fltr *fltr,
1075 struct ice_tc_flower_lyr_2_4_hdrs *headers, bool is_encap)
1076 {
1077 struct ice_tc_l3_hdr *l3_key, *l3_mask;
1078
1079 /* src and dest IPV6 address should not be LOOPBACK
1080 * (0:0:0:0:0:0:0:1), which can be represented as ::1
1081 */
1082 if (ipv6_addr_loopback(&match->key->dst) ||
1083 ipv6_addr_loopback(&match->key->src)) {
1084 NL_SET_ERR_MSG_MOD(fltr->extack, "Bad IPv6, addr is LOOPBACK");
1085 return -EINVAL;
1086 }
1087 /* if src/dest IPv6 address is *,* error */
1088 if (ipv6_addr_any(&match->mask->dst) &&
1089 ipv6_addr_any(&match->mask->src)) {
1090 NL_SET_ERR_MSG_MOD(fltr->extack, "Bad src/dest IPv6, addr is any");
1091 return -EINVAL;
1092 }
1093 if (!ipv6_addr_any(&match->mask->dst)) {
1094 if (is_encap)
1095 fltr->flags |= ICE_TC_FLWR_FIELD_ENC_DEST_IPV6;
1096 else
1097 fltr->flags |= ICE_TC_FLWR_FIELD_DEST_IPV6;
1098 }
1099 if (!ipv6_addr_any(&match->mask->src)) {
1100 if (is_encap)
1101 fltr->flags |= ICE_TC_FLWR_FIELD_ENC_SRC_IPV6;
1102 else
1103 fltr->flags |= ICE_TC_FLWR_FIELD_SRC_IPV6;
1104 }
1105
1106 l3_key = &headers->l3_key;
1107 l3_mask = &headers->l3_mask;
1108
1109 if (fltr->flags & (ICE_TC_FLWR_FIELD_ENC_SRC_IPV6 |
1110 ICE_TC_FLWR_FIELD_SRC_IPV6)) {
1111 memcpy(&l3_key->src_ipv6_addr, &match->key->src.s6_addr,
1112 sizeof(match->key->src.s6_addr));
1113 memcpy(&l3_mask->src_ipv6_addr, &match->mask->src.s6_addr,
1114 sizeof(match->mask->src.s6_addr));
1115 }
1116 if (fltr->flags & (ICE_TC_FLWR_FIELD_ENC_DEST_IPV6 |
1117 ICE_TC_FLWR_FIELD_DEST_IPV6)) {
1118 memcpy(&l3_key->dst_ipv6_addr, &match->key->dst.s6_addr,
1119 sizeof(match->key->dst.s6_addr));
1120 memcpy(&l3_mask->dst_ipv6_addr, &match->mask->dst.s6_addr,
1121 sizeof(match->mask->dst.s6_addr));
1122 }
1123
1124 return 0;
1125 }
1126
1127 /**
1128 * ice_tc_set_tos_ttl - Parse IP ToS/TTL from TC flower filter
1129 * @match: Pointer to flow match structure
1130 * @fltr: Pointer to filter structure
1131 * @headers: inner or outer header fields
1132 * @is_encap: set true for tunnel
1133 */
1134 static void
ice_tc_set_tos_ttl(struct flow_match_ip * match,struct ice_tc_flower_fltr * fltr,struct ice_tc_flower_lyr_2_4_hdrs * headers,bool is_encap)1135 ice_tc_set_tos_ttl(struct flow_match_ip *match,
1136 struct ice_tc_flower_fltr *fltr,
1137 struct ice_tc_flower_lyr_2_4_hdrs *headers,
1138 bool is_encap)
1139 {
1140 if (match->mask->tos) {
1141 if (is_encap)
1142 fltr->flags |= ICE_TC_FLWR_FIELD_ENC_IP_TOS;
1143 else
1144 fltr->flags |= ICE_TC_FLWR_FIELD_IP_TOS;
1145
1146 headers->l3_key.tos = match->key->tos;
1147 headers->l3_mask.tos = match->mask->tos;
1148 }
1149
1150 if (match->mask->ttl) {
1151 if (is_encap)
1152 fltr->flags |= ICE_TC_FLWR_FIELD_ENC_IP_TTL;
1153 else
1154 fltr->flags |= ICE_TC_FLWR_FIELD_IP_TTL;
1155
1156 headers->l3_key.ttl = match->key->ttl;
1157 headers->l3_mask.ttl = match->mask->ttl;
1158 }
1159 }
1160
1161 /**
1162 * ice_tc_set_port - Parse ports from TC flower filter
1163 * @match: Flow match structure
1164 * @fltr: Pointer to filter structure
1165 * @headers: inner or outer header fields
1166 * @is_encap: set true for tunnel port
1167 */
1168 static int
ice_tc_set_port(struct flow_match_ports match,struct ice_tc_flower_fltr * fltr,struct ice_tc_flower_lyr_2_4_hdrs * headers,bool is_encap)1169 ice_tc_set_port(struct flow_match_ports match,
1170 struct ice_tc_flower_fltr *fltr,
1171 struct ice_tc_flower_lyr_2_4_hdrs *headers, bool is_encap)
1172 {
1173 if (match.key->dst) {
1174 if (is_encap)
1175 fltr->flags |= ICE_TC_FLWR_FIELD_ENC_DEST_L4_PORT;
1176 else
1177 fltr->flags |= ICE_TC_FLWR_FIELD_DEST_L4_PORT;
1178
1179 headers->l4_key.dst_port = match.key->dst;
1180 headers->l4_mask.dst_port = match.mask->dst;
1181 }
1182 if (match.key->src) {
1183 if (is_encap)
1184 fltr->flags |= ICE_TC_FLWR_FIELD_ENC_SRC_L4_PORT;
1185 else
1186 fltr->flags |= ICE_TC_FLWR_FIELD_SRC_L4_PORT;
1187
1188 headers->l4_key.src_port = match.key->src;
1189 headers->l4_mask.src_port = match.mask->src;
1190 }
1191 return 0;
1192 }
1193
1194 static struct net_device *
ice_get_tunnel_device(struct net_device * dev,struct flow_rule * rule)1195 ice_get_tunnel_device(struct net_device *dev, struct flow_rule *rule)
1196 {
1197 struct flow_action_entry *act;
1198 int i;
1199
1200 if (ice_is_tunnel_supported(dev))
1201 return dev;
1202
1203 flow_action_for_each(i, act, &rule->action) {
1204 if (act->id == FLOW_ACTION_REDIRECT &&
1205 ice_is_tunnel_supported(act->dev))
1206 return act->dev;
1207 }
1208
1209 return NULL;
1210 }
1211
1212 /**
1213 * ice_parse_gtp_type - Sets GTP tunnel type to GTP-U or GTP-C
1214 * @match: Flow match structure
1215 * @fltr: Pointer to filter structure
1216 *
1217 * GTP-C/GTP-U is selected based on destination port number (enc_dst_port).
1218 * Before calling this funtcion, fltr->tunnel_type should be set to TNL_GTPU,
1219 * therefore making GTP-U the default choice (when destination port number is
1220 * not specified).
1221 */
1222 static int
ice_parse_gtp_type(struct flow_match_ports match,struct ice_tc_flower_fltr * fltr)1223 ice_parse_gtp_type(struct flow_match_ports match,
1224 struct ice_tc_flower_fltr *fltr)
1225 {
1226 u16 dst_port;
1227
1228 if (match.key->dst) {
1229 dst_port = be16_to_cpu(match.key->dst);
1230
1231 switch (dst_port) {
1232 case 2152:
1233 break;
1234 case 2123:
1235 fltr->tunnel_type = TNL_GTPC;
1236 break;
1237 default:
1238 NL_SET_ERR_MSG_MOD(fltr->extack, "Unsupported GTP port number");
1239 return -EINVAL;
1240 }
1241 }
1242
1243 return 0;
1244 }
1245
1246 static int
ice_parse_tunnel_attr(struct net_device * dev,struct flow_rule * rule,struct ice_tc_flower_fltr * fltr)1247 ice_parse_tunnel_attr(struct net_device *dev, struct flow_rule *rule,
1248 struct ice_tc_flower_fltr *fltr)
1249 {
1250 struct ice_tc_flower_lyr_2_4_hdrs *headers = &fltr->outer_headers;
1251 struct flow_match_control enc_control;
1252
1253 fltr->tunnel_type = ice_tc_tun_get_type(dev);
1254 headers->l3_key.ip_proto = IPPROTO_UDP;
1255
1256 if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_KEYID)) {
1257 struct flow_match_enc_keyid enc_keyid;
1258
1259 flow_rule_match_enc_keyid(rule, &enc_keyid);
1260
1261 if (!enc_keyid.mask->keyid ||
1262 enc_keyid.mask->keyid != cpu_to_be32(ICE_TC_FLOWER_MASK_32))
1263 return -EINVAL;
1264
1265 fltr->flags |= ICE_TC_FLWR_FIELD_TENANT_ID;
1266 fltr->tenant_id = enc_keyid.key->keyid;
1267 }
1268
1269 flow_rule_match_enc_control(rule, &enc_control);
1270
1271 if (enc_control.key->addr_type == FLOW_DISSECTOR_KEY_IPV4_ADDRS) {
1272 struct flow_match_ipv4_addrs match;
1273
1274 flow_rule_match_enc_ipv4_addrs(rule, &match);
1275 if (ice_tc_set_ipv4(&match, fltr, headers, true))
1276 return -EINVAL;
1277 } else if (enc_control.key->addr_type ==
1278 FLOW_DISSECTOR_KEY_IPV6_ADDRS) {
1279 struct flow_match_ipv6_addrs match;
1280
1281 flow_rule_match_enc_ipv6_addrs(rule, &match);
1282 if (ice_tc_set_ipv6(&match, fltr, headers, true))
1283 return -EINVAL;
1284 }
1285
1286 if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_IP)) {
1287 struct flow_match_ip match;
1288
1289 flow_rule_match_enc_ip(rule, &match);
1290 ice_tc_set_tos_ttl(&match, fltr, headers, true);
1291 }
1292
1293 if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_PORTS) &&
1294 fltr->tunnel_type != TNL_VXLAN && fltr->tunnel_type != TNL_GENEVE) {
1295 struct flow_match_ports match;
1296
1297 flow_rule_match_enc_ports(rule, &match);
1298
1299 if (fltr->tunnel_type != TNL_GTPU) {
1300 if (ice_tc_set_port(match, fltr, headers, true))
1301 return -EINVAL;
1302 } else {
1303 if (ice_parse_gtp_type(match, fltr))
1304 return -EINVAL;
1305 }
1306 }
1307
1308 if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_OPTS)) {
1309 struct flow_match_enc_opts match;
1310
1311 flow_rule_match_enc_opts(rule, &match);
1312
1313 memcpy(&fltr->gtp_pdu_info_keys, &match.key->data[0],
1314 sizeof(struct gtp_pdu_session_info));
1315
1316 memcpy(&fltr->gtp_pdu_info_masks, &match.mask->data[0],
1317 sizeof(struct gtp_pdu_session_info));
1318
1319 fltr->flags |= ICE_TC_FLWR_FIELD_ENC_OPTS;
1320 }
1321
1322 return 0;
1323 }
1324
1325 /**
1326 * ice_parse_cls_flower - Parse TC flower filters provided by kernel
1327 * @vsi: Pointer to the VSI
1328 * @filter_dev: Pointer to device on which filter is being added
1329 * @f: Pointer to struct flow_cls_offload
1330 * @fltr: Pointer to filter structure
1331 */
1332 static int
ice_parse_cls_flower(struct net_device * filter_dev,struct ice_vsi * vsi,struct flow_cls_offload * f,struct ice_tc_flower_fltr * fltr)1333 ice_parse_cls_flower(struct net_device *filter_dev, struct ice_vsi *vsi,
1334 struct flow_cls_offload *f,
1335 struct ice_tc_flower_fltr *fltr)
1336 {
1337 struct ice_tc_flower_lyr_2_4_hdrs *headers = &fltr->outer_headers;
1338 struct flow_rule *rule = flow_cls_offload_flow_rule(f);
1339 u16 n_proto_mask = 0, n_proto_key = 0, addr_type = 0;
1340 struct flow_dissector *dissector;
1341 struct net_device *tunnel_dev;
1342
1343 dissector = rule->match.dissector;
1344
1345 if (dissector->used_keys &
1346 ~(BIT_ULL(FLOW_DISSECTOR_KEY_CONTROL) |
1347 BIT_ULL(FLOW_DISSECTOR_KEY_BASIC) |
1348 BIT_ULL(FLOW_DISSECTOR_KEY_ETH_ADDRS) |
1349 BIT_ULL(FLOW_DISSECTOR_KEY_VLAN) |
1350 BIT_ULL(FLOW_DISSECTOR_KEY_CVLAN) |
1351 BIT_ULL(FLOW_DISSECTOR_KEY_IPV4_ADDRS) |
1352 BIT_ULL(FLOW_DISSECTOR_KEY_IPV6_ADDRS) |
1353 BIT_ULL(FLOW_DISSECTOR_KEY_ENC_CONTROL) |
1354 BIT_ULL(FLOW_DISSECTOR_KEY_ENC_KEYID) |
1355 BIT_ULL(FLOW_DISSECTOR_KEY_ENC_IPV4_ADDRS) |
1356 BIT_ULL(FLOW_DISSECTOR_KEY_ENC_IPV6_ADDRS) |
1357 BIT_ULL(FLOW_DISSECTOR_KEY_ENC_PORTS) |
1358 BIT_ULL(FLOW_DISSECTOR_KEY_ENC_OPTS) |
1359 BIT_ULL(FLOW_DISSECTOR_KEY_IP) |
1360 BIT_ULL(FLOW_DISSECTOR_KEY_ENC_IP) |
1361 BIT_ULL(FLOW_DISSECTOR_KEY_PORTS) |
1362 BIT_ULL(FLOW_DISSECTOR_KEY_PPPOE) |
1363 BIT_ULL(FLOW_DISSECTOR_KEY_L2TPV3))) {
1364 NL_SET_ERR_MSG_MOD(fltr->extack, "Unsupported key used");
1365 return -EOPNOTSUPP;
1366 }
1367
1368 tunnel_dev = ice_get_tunnel_device(filter_dev, rule);
1369 if (tunnel_dev) {
1370 int err;
1371
1372 filter_dev = tunnel_dev;
1373
1374 err = ice_parse_tunnel_attr(filter_dev, rule, fltr);
1375 if (err) {
1376 NL_SET_ERR_MSG_MOD(fltr->extack, "Failed to parse TC flower tunnel attributes");
1377 return err;
1378 }
1379
1380 /* header pointers should point to the inner headers, outer
1381 * header were already set by ice_parse_tunnel_attr
1382 */
1383 headers = &fltr->inner_headers;
1384 } else if (dissector->used_keys &
1385 (BIT_ULL(FLOW_DISSECTOR_KEY_ENC_IPV4_ADDRS) |
1386 BIT_ULL(FLOW_DISSECTOR_KEY_ENC_IPV6_ADDRS) |
1387 BIT_ULL(FLOW_DISSECTOR_KEY_ENC_KEYID) |
1388 BIT_ULL(FLOW_DISSECTOR_KEY_ENC_PORTS))) {
1389 NL_SET_ERR_MSG_MOD(fltr->extack, "Tunnel key used, but device isn't a tunnel");
1390 return -EOPNOTSUPP;
1391 } else {
1392 fltr->tunnel_type = TNL_LAST;
1393 }
1394
1395 if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_BASIC)) {
1396 struct flow_match_basic match;
1397
1398 flow_rule_match_basic(rule, &match);
1399
1400 n_proto_key = ntohs(match.key->n_proto);
1401 n_proto_mask = ntohs(match.mask->n_proto);
1402
1403 if (n_proto_key == ETH_P_ALL || n_proto_key == 0 ||
1404 fltr->tunnel_type == TNL_GTPU ||
1405 fltr->tunnel_type == TNL_GTPC) {
1406 n_proto_key = 0;
1407 n_proto_mask = 0;
1408 } else {
1409 fltr->flags |= ICE_TC_FLWR_FIELD_ETH_TYPE_ID;
1410 }
1411
1412 headers->l2_key.n_proto = cpu_to_be16(n_proto_key);
1413 headers->l2_mask.n_proto = cpu_to_be16(n_proto_mask);
1414 headers->l3_key.ip_proto = match.key->ip_proto;
1415 }
1416
1417 if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ETH_ADDRS)) {
1418 struct flow_match_eth_addrs match;
1419
1420 flow_rule_match_eth_addrs(rule, &match);
1421
1422 if (!is_zero_ether_addr(match.key->dst)) {
1423 ether_addr_copy(headers->l2_key.dst_mac,
1424 match.key->dst);
1425 ether_addr_copy(headers->l2_mask.dst_mac,
1426 match.mask->dst);
1427 fltr->flags |= ICE_TC_FLWR_FIELD_DST_MAC;
1428 }
1429
1430 if (!is_zero_ether_addr(match.key->src)) {
1431 ether_addr_copy(headers->l2_key.src_mac,
1432 match.key->src);
1433 ether_addr_copy(headers->l2_mask.src_mac,
1434 match.mask->src);
1435 fltr->flags |= ICE_TC_FLWR_FIELD_SRC_MAC;
1436 }
1437 }
1438
1439 if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_VLAN) ||
1440 is_vlan_dev(filter_dev)) {
1441 struct flow_dissector_key_vlan mask;
1442 struct flow_dissector_key_vlan key;
1443 struct flow_match_vlan match;
1444
1445 if (is_vlan_dev(filter_dev)) {
1446 match.key = &key;
1447 match.key->vlan_id = vlan_dev_vlan_id(filter_dev);
1448 match.key->vlan_priority = 0;
1449 match.mask = &mask;
1450 memset(match.mask, 0xff, sizeof(*match.mask));
1451 match.mask->vlan_priority = 0;
1452 } else {
1453 flow_rule_match_vlan(rule, &match);
1454 }
1455
1456 if (match.mask->vlan_id) {
1457 if (match.mask->vlan_id == VLAN_VID_MASK) {
1458 fltr->flags |= ICE_TC_FLWR_FIELD_VLAN;
1459 headers->vlan_hdr.vlan_id =
1460 cpu_to_be16(match.key->vlan_id &
1461 VLAN_VID_MASK);
1462 } else {
1463 NL_SET_ERR_MSG_MOD(fltr->extack, "Bad VLAN mask");
1464 return -EINVAL;
1465 }
1466 }
1467
1468 if (match.mask->vlan_priority) {
1469 fltr->flags |= ICE_TC_FLWR_FIELD_VLAN_PRIO;
1470 headers->vlan_hdr.vlan_prio =
1471 be16_encode_bits(match.key->vlan_priority,
1472 VLAN_PRIO_MASK);
1473 }
1474
1475 if (match.mask->vlan_tpid) {
1476 headers->vlan_hdr.vlan_tpid = match.key->vlan_tpid;
1477 fltr->flags |= ICE_TC_FLWR_FIELD_VLAN_TPID;
1478 }
1479 }
1480
1481 if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_CVLAN)) {
1482 struct flow_match_vlan match;
1483
1484 if (!ice_is_dvm_ena(&vsi->back->hw)) {
1485 NL_SET_ERR_MSG_MOD(fltr->extack, "Double VLAN mode is not enabled");
1486 return -EINVAL;
1487 }
1488
1489 flow_rule_match_cvlan(rule, &match);
1490
1491 if (match.mask->vlan_id) {
1492 if (match.mask->vlan_id == VLAN_VID_MASK) {
1493 fltr->flags |= ICE_TC_FLWR_FIELD_CVLAN;
1494 headers->cvlan_hdr.vlan_id =
1495 cpu_to_be16(match.key->vlan_id &
1496 VLAN_VID_MASK);
1497 } else {
1498 NL_SET_ERR_MSG_MOD(fltr->extack,
1499 "Bad CVLAN mask");
1500 return -EINVAL;
1501 }
1502 }
1503
1504 if (match.mask->vlan_priority) {
1505 fltr->flags |= ICE_TC_FLWR_FIELD_CVLAN_PRIO;
1506 headers->cvlan_hdr.vlan_prio =
1507 be16_encode_bits(match.key->vlan_priority,
1508 VLAN_PRIO_MASK);
1509 }
1510 }
1511
1512 if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_PPPOE)) {
1513 struct flow_match_pppoe match;
1514
1515 flow_rule_match_pppoe(rule, &match);
1516 n_proto_key = ice_tc_set_pppoe(&match, fltr, headers);
1517
1518 /* If ethertype equals ETH_P_PPP_SES, n_proto might be
1519 * overwritten by encapsulated protocol (ppp_proto field) or set
1520 * to 0. To correct this, flow_match_pppoe provides the type
1521 * field, which contains the actual ethertype (ETH_P_PPP_SES).
1522 */
1523 headers->l2_key.n_proto = cpu_to_be16(n_proto_key);
1524 headers->l2_mask.n_proto = cpu_to_be16(0xFFFF);
1525 fltr->flags |= ICE_TC_FLWR_FIELD_ETH_TYPE_ID;
1526 }
1527
1528 if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_CONTROL)) {
1529 struct flow_match_control match;
1530
1531 flow_rule_match_control(rule, &match);
1532
1533 addr_type = match.key->addr_type;
1534 }
1535
1536 if (addr_type == FLOW_DISSECTOR_KEY_IPV4_ADDRS) {
1537 struct flow_match_ipv4_addrs match;
1538
1539 flow_rule_match_ipv4_addrs(rule, &match);
1540 if (ice_tc_set_ipv4(&match, fltr, headers, false))
1541 return -EINVAL;
1542 }
1543
1544 if (addr_type == FLOW_DISSECTOR_KEY_IPV6_ADDRS) {
1545 struct flow_match_ipv6_addrs match;
1546
1547 flow_rule_match_ipv6_addrs(rule, &match);
1548 if (ice_tc_set_ipv6(&match, fltr, headers, false))
1549 return -EINVAL;
1550 }
1551
1552 if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_IP)) {
1553 struct flow_match_ip match;
1554
1555 flow_rule_match_ip(rule, &match);
1556 ice_tc_set_tos_ttl(&match, fltr, headers, false);
1557 }
1558
1559 if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_L2TPV3)) {
1560 struct flow_match_l2tpv3 match;
1561
1562 flow_rule_match_l2tpv3(rule, &match);
1563
1564 fltr->flags |= ICE_TC_FLWR_FIELD_L2TPV3_SESSID;
1565 headers->l2tpv3_hdr.session_id = match.key->session_id;
1566 }
1567
1568 if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_PORTS)) {
1569 struct flow_match_ports match;
1570
1571 flow_rule_match_ports(rule, &match);
1572 if (ice_tc_set_port(match, fltr, headers, false))
1573 return -EINVAL;
1574 switch (headers->l3_key.ip_proto) {
1575 case IPPROTO_TCP:
1576 case IPPROTO_UDP:
1577 break;
1578 default:
1579 NL_SET_ERR_MSG_MOD(fltr->extack, "Only UDP and TCP transport are supported");
1580 return -EINVAL;
1581 }
1582 }
1583 return 0;
1584 }
1585
1586 /**
1587 * ice_add_switch_fltr - Add TC flower filters
1588 * @vsi: Pointer to VSI
1589 * @fltr: Pointer to struct ice_tc_flower_fltr
1590 *
1591 * Add filter in HW switch block
1592 */
1593 static int
ice_add_switch_fltr(struct ice_vsi * vsi,struct ice_tc_flower_fltr * fltr)1594 ice_add_switch_fltr(struct ice_vsi *vsi, struct ice_tc_flower_fltr *fltr)
1595 {
1596 if (fltr->action.fltr_act == ICE_FWD_TO_QGRP)
1597 return -EOPNOTSUPP;
1598
1599 if (ice_is_eswitch_mode_switchdev(vsi->back))
1600 return ice_eswitch_add_tc_fltr(vsi, fltr);
1601
1602 return ice_add_tc_flower_adv_fltr(vsi, fltr);
1603 }
1604
1605 /**
1606 * ice_prep_adq_filter - Prepare ADQ filter with the required additional headers
1607 * @vsi: Pointer to VSI
1608 * @fltr: Pointer to TC flower filter structure
1609 *
1610 * Prepare ADQ filter with the required additional header fields
1611 */
1612 static int
ice_prep_adq_filter(struct ice_vsi * vsi,struct ice_tc_flower_fltr * fltr)1613 ice_prep_adq_filter(struct ice_vsi *vsi, struct ice_tc_flower_fltr *fltr)
1614 {
1615 if ((fltr->flags & ICE_TC_FLWR_FIELD_TENANT_ID) &&
1616 (fltr->flags & (ICE_TC_FLWR_FIELD_DST_MAC |
1617 ICE_TC_FLWR_FIELD_SRC_MAC))) {
1618 NL_SET_ERR_MSG_MOD(fltr->extack,
1619 "Unable to add filter because filter using tunnel key and inner MAC is unsupported combination");
1620 return -EOPNOTSUPP;
1621 }
1622
1623 /* For ADQ, filter must include dest MAC address, otherwise unwanted
1624 * packets with unrelated MAC address get delivered to ADQ VSIs as long
1625 * as remaining filter criteria is satisfied such as dest IP address
1626 * and dest/src L4 port. Below code handles the following cases:
1627 * 1. For non-tunnel, if user specify MAC addresses, use them.
1628 * 2. For non-tunnel, if user didn't specify MAC address, add implicit
1629 * dest MAC to be lower netdev's active unicast MAC address
1630 * 3. For tunnel, as of now TC-filter through flower classifier doesn't
1631 * have provision for user to specify outer DMAC, hence driver to
1632 * implicitly add outer dest MAC to be lower netdev's active unicast
1633 * MAC address.
1634 */
1635 if (fltr->tunnel_type != TNL_LAST &&
1636 !(fltr->flags & ICE_TC_FLWR_FIELD_ENC_DST_MAC))
1637 fltr->flags |= ICE_TC_FLWR_FIELD_ENC_DST_MAC;
1638
1639 if (fltr->tunnel_type == TNL_LAST &&
1640 !(fltr->flags & ICE_TC_FLWR_FIELD_DST_MAC))
1641 fltr->flags |= ICE_TC_FLWR_FIELD_DST_MAC;
1642
1643 if (fltr->flags & (ICE_TC_FLWR_FIELD_DST_MAC |
1644 ICE_TC_FLWR_FIELD_ENC_DST_MAC)) {
1645 ether_addr_copy(fltr->outer_headers.l2_key.dst_mac,
1646 vsi->netdev->dev_addr);
1647 eth_broadcast_addr(fltr->outer_headers.l2_mask.dst_mac);
1648 }
1649
1650 /* Make sure VLAN is already added to main VSI, before allowing ADQ to
1651 * add a VLAN based filter such as MAC + VLAN + L4 port.
1652 */
1653 if (fltr->flags & ICE_TC_FLWR_FIELD_VLAN) {
1654 u16 vlan_id = be16_to_cpu(fltr->outer_headers.vlan_hdr.vlan_id);
1655
1656 if (!ice_vlan_fltr_exist(&vsi->back->hw, vlan_id, vsi->idx)) {
1657 NL_SET_ERR_MSG_MOD(fltr->extack,
1658 "Unable to add filter because legacy VLAN filter for specified destination doesn't exist");
1659 return -EINVAL;
1660 }
1661 }
1662 return 0;
1663 }
1664
1665 /**
1666 * ice_handle_tclass_action - Support directing to a traffic class
1667 * @vsi: Pointer to VSI
1668 * @cls_flower: Pointer to TC flower offload structure
1669 * @fltr: Pointer to TC flower filter structure
1670 *
1671 * Support directing traffic to a traffic class/queue-set
1672 */
1673 static int
ice_handle_tclass_action(struct ice_vsi * vsi,struct flow_cls_offload * cls_flower,struct ice_tc_flower_fltr * fltr)1674 ice_handle_tclass_action(struct ice_vsi *vsi,
1675 struct flow_cls_offload *cls_flower,
1676 struct ice_tc_flower_fltr *fltr)
1677 {
1678 int tc = tc_classid_to_hwtc(vsi->netdev, cls_flower->classid);
1679
1680 /* user specified hw_tc (must be non-zero for ADQ TC), action is forward
1681 * to hw_tc (i.e. ADQ channel number)
1682 */
1683 if (tc < ICE_CHNL_START_TC) {
1684 NL_SET_ERR_MSG_MOD(fltr->extack,
1685 "Unable to add filter because of unsupported destination");
1686 return -EOPNOTSUPP;
1687 }
1688 if (!(vsi->all_enatc & BIT(tc))) {
1689 NL_SET_ERR_MSG_MOD(fltr->extack,
1690 "Unable to add filter because of non-existence destination");
1691 return -EINVAL;
1692 }
1693 fltr->action.fltr_act = ICE_FWD_TO_VSI;
1694 fltr->action.fwd.tc.tc_class = tc;
1695
1696 return ice_prep_adq_filter(vsi, fltr);
1697 }
1698
1699 static int
ice_tc_forward_to_queue(struct ice_vsi * vsi,struct ice_tc_flower_fltr * fltr,struct flow_action_entry * act)1700 ice_tc_forward_to_queue(struct ice_vsi *vsi, struct ice_tc_flower_fltr *fltr,
1701 struct flow_action_entry *act)
1702 {
1703 struct ice_vsi *ch_vsi = NULL;
1704 u16 queue = act->rx_queue;
1705
1706 if (queue >= vsi->num_rxq) {
1707 NL_SET_ERR_MSG_MOD(fltr->extack,
1708 "Unable to add filter because specified queue is invalid");
1709 return -EINVAL;
1710 }
1711 fltr->action.fltr_act = ICE_FWD_TO_Q;
1712 fltr->action.fwd.q.queue = queue;
1713 /* determine corresponding HW queue */
1714 fltr->action.fwd.q.hw_queue = vsi->rxq_map[queue];
1715
1716 /* If ADQ is configured, and the queue belongs to ADQ VSI, then prepare
1717 * ADQ switch filter
1718 */
1719 ch_vsi = ice_locate_vsi_using_queue(vsi, fltr->action.fwd.q.queue);
1720 if (!ch_vsi)
1721 return -EINVAL;
1722 fltr->dest_vsi = ch_vsi;
1723 if (!ice_is_chnl_fltr(fltr))
1724 return 0;
1725
1726 return ice_prep_adq_filter(vsi, fltr);
1727 }
1728
1729 static int
ice_tc_parse_action(struct ice_vsi * vsi,struct ice_tc_flower_fltr * fltr,struct flow_action_entry * act)1730 ice_tc_parse_action(struct ice_vsi *vsi, struct ice_tc_flower_fltr *fltr,
1731 struct flow_action_entry *act)
1732 {
1733 switch (act->id) {
1734 case FLOW_ACTION_RX_QUEUE_MAPPING:
1735 /* forward to queue */
1736 return ice_tc_forward_to_queue(vsi, fltr, act);
1737 case FLOW_ACTION_DROP:
1738 fltr->action.fltr_act = ICE_DROP_PACKET;
1739 return 0;
1740 default:
1741 NL_SET_ERR_MSG_MOD(fltr->extack, "Unsupported TC action");
1742 return -EOPNOTSUPP;
1743 }
1744 }
1745
1746 /**
1747 * ice_parse_tc_flower_actions - Parse the actions for a TC filter
1748 * @vsi: Pointer to VSI
1749 * @cls_flower: Pointer to TC flower offload structure
1750 * @fltr: Pointer to TC flower filter structure
1751 *
1752 * Parse the actions for a TC filter
1753 */
1754 static int
ice_parse_tc_flower_actions(struct ice_vsi * vsi,struct flow_cls_offload * cls_flower,struct ice_tc_flower_fltr * fltr)1755 ice_parse_tc_flower_actions(struct ice_vsi *vsi,
1756 struct flow_cls_offload *cls_flower,
1757 struct ice_tc_flower_fltr *fltr)
1758 {
1759 struct flow_rule *rule = flow_cls_offload_flow_rule(cls_flower);
1760 struct flow_action *flow_action = &rule->action;
1761 struct flow_action_entry *act;
1762 int i, err;
1763
1764 if (cls_flower->classid)
1765 return ice_handle_tclass_action(vsi, cls_flower, fltr);
1766
1767 if (!flow_action_has_entries(flow_action))
1768 return -EINVAL;
1769
1770 flow_action_for_each(i, act, flow_action) {
1771 if (ice_is_eswitch_mode_switchdev(vsi->back))
1772 err = ice_eswitch_tc_parse_action(fltr, act);
1773 else
1774 err = ice_tc_parse_action(vsi, fltr, act);
1775 if (err)
1776 return err;
1777 continue;
1778 }
1779 return 0;
1780 }
1781
1782 /**
1783 * ice_del_tc_fltr - deletes a filter from HW table
1784 * @vsi: Pointer to VSI
1785 * @fltr: Pointer to struct ice_tc_flower_fltr
1786 *
1787 * This function deletes a filter from HW table and manages book-keeping
1788 */
ice_del_tc_fltr(struct ice_vsi * vsi,struct ice_tc_flower_fltr * fltr)1789 static int ice_del_tc_fltr(struct ice_vsi *vsi, struct ice_tc_flower_fltr *fltr)
1790 {
1791 struct ice_rule_query_data rule_rem;
1792 struct ice_pf *pf = vsi->back;
1793 int err;
1794
1795 rule_rem.rid = fltr->rid;
1796 rule_rem.rule_id = fltr->rule_id;
1797 rule_rem.vsi_handle = fltr->dest_vsi_handle;
1798 err = ice_rem_adv_rule_by_id(&pf->hw, &rule_rem);
1799 if (err) {
1800 if (err == -ENOENT) {
1801 NL_SET_ERR_MSG_MOD(fltr->extack, "Filter does not exist");
1802 return -ENOENT;
1803 }
1804 NL_SET_ERR_MSG_MOD(fltr->extack, "Failed to delete TC flower filter");
1805 return -EIO;
1806 }
1807
1808 /* update advanced switch filter count for destination
1809 * VSI if filter destination was VSI
1810 */
1811 if (fltr->dest_vsi) {
1812 if (fltr->dest_vsi->type == ICE_VSI_CHNL) {
1813 fltr->dest_vsi->num_chnl_fltr--;
1814
1815 /* keeps track of channel filters for PF VSI */
1816 if (vsi->type == ICE_VSI_PF &&
1817 (fltr->flags & (ICE_TC_FLWR_FIELD_DST_MAC |
1818 ICE_TC_FLWR_FIELD_ENC_DST_MAC)))
1819 pf->num_dmac_chnl_fltrs--;
1820 }
1821 }
1822 return 0;
1823 }
1824
1825 /**
1826 * ice_add_tc_fltr - adds a TC flower filter
1827 * @netdev: Pointer to netdev
1828 * @vsi: Pointer to VSI
1829 * @f: Pointer to flower offload structure
1830 * @__fltr: Pointer to struct ice_tc_flower_fltr
1831 *
1832 * This function parses TC-flower input fields, parses action,
1833 * and adds a filter.
1834 */
1835 static int
ice_add_tc_fltr(struct net_device * netdev,struct ice_vsi * vsi,struct flow_cls_offload * f,struct ice_tc_flower_fltr ** __fltr)1836 ice_add_tc_fltr(struct net_device *netdev, struct ice_vsi *vsi,
1837 struct flow_cls_offload *f,
1838 struct ice_tc_flower_fltr **__fltr)
1839 {
1840 struct ice_tc_flower_fltr *fltr;
1841 int err;
1842
1843 /* by default, set output to be INVALID */
1844 *__fltr = NULL;
1845
1846 fltr = kzalloc(sizeof(*fltr), GFP_KERNEL);
1847 if (!fltr)
1848 return -ENOMEM;
1849
1850 fltr->cookie = f->cookie;
1851 fltr->extack = f->common.extack;
1852 fltr->src_vsi = vsi;
1853 INIT_HLIST_NODE(&fltr->tc_flower_node);
1854
1855 err = ice_parse_cls_flower(netdev, vsi, f, fltr);
1856 if (err < 0)
1857 goto err;
1858
1859 err = ice_parse_tc_flower_actions(vsi, f, fltr);
1860 if (err < 0)
1861 goto err;
1862
1863 err = ice_add_switch_fltr(vsi, fltr);
1864 if (err < 0)
1865 goto err;
1866
1867 /* return the newly created filter */
1868 *__fltr = fltr;
1869
1870 return 0;
1871 err:
1872 kfree(fltr);
1873 return err;
1874 }
1875
1876 /**
1877 * ice_find_tc_flower_fltr - Find the TC flower filter in the list
1878 * @pf: Pointer to PF
1879 * @cookie: filter specific cookie
1880 */
1881 static struct ice_tc_flower_fltr *
ice_find_tc_flower_fltr(struct ice_pf * pf,unsigned long cookie)1882 ice_find_tc_flower_fltr(struct ice_pf *pf, unsigned long cookie)
1883 {
1884 struct ice_tc_flower_fltr *fltr;
1885
1886 hlist_for_each_entry(fltr, &pf->tc_flower_fltr_list, tc_flower_node)
1887 if (cookie == fltr->cookie)
1888 return fltr;
1889
1890 return NULL;
1891 }
1892
1893 /**
1894 * ice_add_cls_flower - add TC flower filters
1895 * @netdev: Pointer to filter device
1896 * @vsi: Pointer to VSI
1897 * @cls_flower: Pointer to flower offload structure
1898 */
1899 int
ice_add_cls_flower(struct net_device * netdev,struct ice_vsi * vsi,struct flow_cls_offload * cls_flower)1900 ice_add_cls_flower(struct net_device *netdev, struct ice_vsi *vsi,
1901 struct flow_cls_offload *cls_flower)
1902 {
1903 struct netlink_ext_ack *extack = cls_flower->common.extack;
1904 struct net_device *vsi_netdev = vsi->netdev;
1905 struct ice_tc_flower_fltr *fltr;
1906 struct ice_pf *pf = vsi->back;
1907 int err;
1908
1909 if (ice_is_reset_in_progress(pf->state))
1910 return -EBUSY;
1911 if (test_bit(ICE_FLAG_FW_LLDP_AGENT, pf->flags))
1912 return -EINVAL;
1913
1914 if (ice_is_port_repr_netdev(netdev))
1915 vsi_netdev = netdev;
1916
1917 if (!(vsi_netdev->features & NETIF_F_HW_TC) &&
1918 !test_bit(ICE_FLAG_CLS_FLOWER, pf->flags)) {
1919 /* Based on TC indirect notifications from kernel, all ice
1920 * devices get an instance of rule from higher level device.
1921 * Avoid triggering explicit error in this case.
1922 */
1923 if (netdev == vsi_netdev)
1924 NL_SET_ERR_MSG_MOD(extack, "can't apply TC flower filters, turn ON hw-tc-offload and try again");
1925 return -EINVAL;
1926 }
1927
1928 /* avoid duplicate entries, if exists - return error */
1929 fltr = ice_find_tc_flower_fltr(pf, cls_flower->cookie);
1930 if (fltr) {
1931 NL_SET_ERR_MSG_MOD(extack, "filter cookie already exists, ignoring");
1932 return -EEXIST;
1933 }
1934
1935 /* prep and add TC-flower filter in HW */
1936 err = ice_add_tc_fltr(netdev, vsi, cls_flower, &fltr);
1937 if (err)
1938 return err;
1939
1940 /* add filter into an ordered list */
1941 hlist_add_head(&fltr->tc_flower_node, &pf->tc_flower_fltr_list);
1942 return 0;
1943 }
1944
1945 /**
1946 * ice_del_cls_flower - delete TC flower filters
1947 * @vsi: Pointer to VSI
1948 * @cls_flower: Pointer to struct flow_cls_offload
1949 */
1950 int
ice_del_cls_flower(struct ice_vsi * vsi,struct flow_cls_offload * cls_flower)1951 ice_del_cls_flower(struct ice_vsi *vsi, struct flow_cls_offload *cls_flower)
1952 {
1953 struct ice_tc_flower_fltr *fltr;
1954 struct ice_pf *pf = vsi->back;
1955 int err;
1956
1957 /* find filter */
1958 fltr = ice_find_tc_flower_fltr(pf, cls_flower->cookie);
1959 if (!fltr) {
1960 if (!test_bit(ICE_FLAG_TC_MQPRIO, pf->flags) &&
1961 hlist_empty(&pf->tc_flower_fltr_list))
1962 return 0;
1963
1964 NL_SET_ERR_MSG_MOD(cls_flower->common.extack, "failed to delete TC flower filter because unable to find it");
1965 return -EINVAL;
1966 }
1967
1968 fltr->extack = cls_flower->common.extack;
1969 /* delete filter from HW */
1970 err = ice_del_tc_fltr(vsi, fltr);
1971 if (err)
1972 return err;
1973
1974 /* delete filter from an ordered list */
1975 hlist_del(&fltr->tc_flower_node);
1976
1977 /* free the filter node */
1978 kfree(fltr);
1979
1980 return 0;
1981 }
1982
1983 /**
1984 * ice_replay_tc_fltrs - replay TC filters
1985 * @pf: pointer to PF struct
1986 */
ice_replay_tc_fltrs(struct ice_pf * pf)1987 void ice_replay_tc_fltrs(struct ice_pf *pf)
1988 {
1989 struct ice_tc_flower_fltr *fltr;
1990 struct hlist_node *node;
1991
1992 hlist_for_each_entry_safe(fltr, node,
1993 &pf->tc_flower_fltr_list,
1994 tc_flower_node) {
1995 fltr->extack = NULL;
1996 ice_add_switch_fltr(fltr->src_vsi, fltr);
1997 }
1998 }
1999
