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